diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 000000000..e75348362 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,8 @@ +root = true + +[*] +indent_style = space +indent_size = 4 +end_of_line = lf +insert_final_newline = true +trim_trailing_whitespace = true diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs new file mode 100644 index 000000000..8867ff6bf --- /dev/null +++ b/.git-blame-ignore-revs @@ -0,0 +1,5 @@ +# Ignore the commit where all the sources were reformatted with no other changes. +ac8da77c937f3c98c3959f72e76184b6b577cf38 +# Ignore some followup commits for things swift-format lint reported. +e1c4ca3714b1d423b2257a4f4050b73d7a46f04d +10ed2c6e30d5ea7982590f6424e161386bfc444d diff --git a/.github/release.yml b/.github/release.yml new file mode 100644 index 000000000..e29eb8464 --- /dev/null +++ b/.github/release.yml @@ -0,0 +1,14 @@ +changelog: + categories: + - title: SemVer Major + labels: + - ⚠️ semver/major + - title: SemVer Minor + labels: + - 🆕 semver/minor + - title: SemVer Patch + labels: + - 🔨 semver/patch + - title: Other Changes + labels: + - semver/none diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 3f678f351..070e73cc6 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -1,7 +1,7 @@ name: Build and Test -# NOTE: If making changes to most of the steps, please also look to update -# regular_conformance.yml also. +permissions: + contents: read on: push: @@ -11,94 +11,125 @@ on: jobs: core: - runs-on: ubuntu-18.04 + runs-on: ubuntu-latest strategy: fail-fast: false matrix: - swift: ["5.5-bionic", "5.4-bionic", "5.3.3-bionic", "5.2.5-bionic", "5.1.5-bionic", "5.0.3-bionic", "4.2.4"] - # protobuf_git can reference a commit, tag, or branch - # commit: "commits/6935eae45c99926a000ecbef0be20dfd3d159e71" - # tag: "ref/tags/v3.11.4" - # branch: "ref/heads/master" - protobuf_git: ["ref/heads/master"] + # We "float" the bug fix so we pick up new ones. This helps since the GitHub CI + # is set to ensure the actions pass, thus updates are only needed when the + # "major.minor" pairs changes. + # + # Looking at https://hub.docker.com/_/swift, the version only tags (i.e. - 6.1) + # could use different Ubuntu releases. At the moment they are all the "noble", + # which is also what would be desired, so we don't bother listing explicit ones. + swift: + - version: "6.2" + hook: "SWIFT_BUILD_TEST_HOOK=\"-Xswiftc -warnings-as-errors\"" + - version: "6.1" + hook: "SWIFT_BUILD_TEST_HOOK=\"-Xswiftc -warnings-as-errors\"" + - version: "6.0" + hook: "SWIFT_BUILD_TEST_HOOK=\"-Xswiftc -warnings-as-errors\"" + - version: "5.10" + # No "hook", see https://github.com/apple/swift-protobuf/issues/1560 for the + # current issue with using -warnings-as-errors on linux. container: - image: swift:${{ matrix.swift }} + image: swift:${{ matrix.swift.version }} steps: - name: Checkout - uses: actions/checkout@v2 + uses: actions/checkout@v4 with: - path: main + submodules: true - name: Update and install dependencies - # dependencies from https://github.com/protocolbuffers/protobuf/blob/master/src/README.md - # this step is run before get-sha because we need curl and jq for get-sha - # NOTE: zlib1g-dev is added to fix the Swift 5.0.x builds, when those builds aren't needed - # that dep likely can be removed. - run: | - set -eu - apt-get update - apt-get install -y autoconf automake libtool curl make g++ unzip jq - [ \"${{ matrix.swift }}\" != \"5.0.3-bionic\" ] || apt-get install zlib1g-dev - - name: Get Protobuf Commit SHA - id: get-sha - run: | - set -eu - url="https://api.github.com/repos/protocolbuffers/protobuf/git/${{ matrix.protobuf_git }}" - case ${{ matrix.protobuf_git }} in - ref/*) - echo ::set-output name=sha::$( curl -s -u "u:${{ github.token }}" "${url}" | jq -r .object.sha ) - ;; - commits/*) - echo ::set-output name=sha::$( curl -s -u "u:${{ github.token }}" "${url}" | jq -r .sha ) - ;; - esac + # Just ensure we have the latest `g++` for building protoc (since it is + # built by SwiftPM), full dependencies available at + # https://github.com/protocolbuffers/protobuf/blob/main/src/README.md + # + # `make` is needed for using our own `Makefile`. + run: apt-get update && apt-get install -y make g++ - name: Build - working-directory: main - run: make build + run: make build ${{ matrix.swift.hook }} - name: Test runtime - working-directory: main - run: make test-runtime - - name: Cache protobuf - id: cache-protobuf - uses: actions/cache@v2 + run: make test-runtime ${{ matrix.swift.hook }} + - name: Test plugin + # The protoc build isn't part of Package@swift-5.10.swift + if: ${{ matrix.swift.version != '5.10' }} + run: make test-plugin + - name: Test SPM plugin + # The protoc build isn't part of Package@swift-5.10.swift + if: ${{ matrix.swift.version != '5.10' }} + run: make test-spm-plugin + - name: Compilation Tests + # The protoc build isn't part of Package@swift-5.10.swift + if: ${{ matrix.swift.version != '5.10' }} + run: make compile-tests + + api-breakage: + name: Api Breakage Compared to main branch + # Only on pull requests + if: github.event_name == 'pull_request' + runs-on: ubuntu-latest + container: + # Test on the latest Swift release. This could run on all the support + # Swift versions, but that doesn't seem worth it until there are Swift + # version specific conditionals to justify it. + image: swift:latest + steps: + - name: Checkout + uses: actions/checkout@v4 with: - path: protobuf - # NOTE: for refs that can float like 'main' the cache might be out of date! - key: ${{ runner.os }}-${{ matrix.swift}}-protobuf-${{ steps.get-sha.outputs.sha }} - - name: Checkout protobuf repo - if: steps.cache-protobuf.outputs.cache-hit != 'true' - uses: actions/checkout@v2 + fetch-depth: 0 + submodules: true + - name: Mark the workspace as safe + # https://github.com/actions/checkout/issues/766 + run: git config --global --add safe.directory ${GITHUB_WORKSPACE} + - name: Check for API breaking changes + run: swift package diagnose-api-breaking-changes origin/main + + format-check: + name: swift-format Check + # Only on pull requests + if: github.event_name == 'pull_request' + runs-on: ubuntu-latest + container: + # Use use the latest Swift release and that's the version of swift-format + # people should use. + image: swift:latest + steps: + - name: Checkout + uses: actions/checkout@v4 with: - repository: protocolbuffers/protobuf - ref: ${{ steps.get-sha.outputs.sha }} - path: protobuf - - name: Build protobuf - if: steps.cache-protobuf.outputs.cache-hit != 'true' - working-directory: protobuf - run: | - ./autogen.sh - ./configure - NUM_CPUS=$(getconf _NPROCESSORS_ONLN) - make -C ./src -j "${NUM_CPUS}" protoc - make -C ./conformance conformance-test-runner - - name: Test plugin - working-directory: main - run: make test-plugin PROTOC=../protobuf/src/protoc - - name: Test conformance - working-directory: main - run: make test-conformance + submodules: true + - name: Mark the workspace as safe + # https://github.com/actions/checkout/issues/766 + run: git config --global --add safe.directory ${GITHUB_WORKSPACE} + - name: Run format check + run: | + set -eu + git ls-files -z '*.swift' | xargs -0 swift format format --parallel --in-place + GIT_PAGER='' git diff --exit-code '*.swift' + - name: Run format lint check + run: | + set -eu + git ls-files -z '*.swift' | xargs -0 swift format lint --strict --parallel sanitizer_testing: - runs-on: ubuntu-18.04 + runs-on: ubuntu-latest strategy: fail-fast: false matrix: sanitizer: ["address", "thread"] swiftpm_config: ["debug", "release"] + exclude: # Excluded due to a clang crasher that is fixed in a more recent clang https://github.com/llvm/llvm-project/issues/95928 + - sanitizer: "address" + swiftpm_config: "debug" container: - # Test on the latest Swift release - image: swift:bionic + # Test on the latest Swift release. + image: swift:latest steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v4 + with: + submodules: true + - name: Test run: | set -eu @@ -107,26 +138,24 @@ jobs: rm Tests/SwiftProtobufTests/generated_swift_names* # On linux, the tests seem to always see leaks that don't show up on macOS. Disable the # leak detection and just assume it is a Linux Swift issue. This still gets validation - # for other memory errors. Maybe https://bugs.swift.org/browse/SR-6848. + # for other memory errors. Maybe https://github.com/swiftlang/swift/issues/49397 if [ "${{ matrix.sanitizer }}" = "address" ] ; then export ASAN_OPTIONS=detect_leaks=0 fi - # 'release' doesn't support @testable, force it on. - if [ "${{ matrix.swiftpm_config }}" = "release" ] ; then - EXTRAS="-Xswiftc -enable-testing" - fi - swift test -c ${{ matrix.swiftpm_config }} --sanitize=${{ matrix.sanitizer }} ${EXTRAS:-} + swift test -c ${{ matrix.swiftpm_config }} --sanitize=${{ matrix.sanitizer }} fuzzing_regressions: - runs-on: ubuntu-18.04 + runs-on: ubuntu-latest strategy: fail-fast: false matrix: swiftpm_config: ["debug", "release"] container: - # Test on the latest Swift release - image: swift:bionic + # Test on the latest Swift release. + image: swift:latest steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v4 + with: + submodules: true - name: Build run: FuzzTesting/do_build.sh --${{ matrix.swiftpm_config }}-only --run-regressions diff --git a/.github/workflows/check_upstream_protos.yml b/.github/workflows/check_upstream_protos.yml index 36449810c..86f200c04 100644 --- a/.github/workflows/check_upstream_protos.yml +++ b/.github/workflows/check_upstream_protos.yml @@ -1,23 +1,29 @@ name: Check Upstream Proto Files +permissions: + contents: read + on: schedule: # Every Sunday at 4am. - cron: '0 4 * * 0' + # Also allow manual triggering from the github UX to revalidate things. + workflow_dispatch: jobs: build: runs-on: ubuntu-latest steps: - name: Checkout - uses: actions/checkout@v2 + uses: actions/checkout@v4 with: - path: main + path: swift-protobuf + # Don't need the submodules since we are checking against upstream. - name: Checkout protobufbuffers/protobuf - uses: actions/checkout@v2 + uses: actions/checkout@v4 with: repository: protocolbuffers/protobuf path: protobuf - name: Check Upstream Proto Files - working-directory: main - run: make check-proto-files + working-directory: swift-protobuf + run: make check-proto-files GOOGLE_PROTOBUF_CHECKOUT=../protobuf diff --git a/.github/workflows/head_conformance.yml b/.github/workflows/head_conformance.yml new file mode 100644 index 000000000..a951599ed --- /dev/null +++ b/.github/workflows/head_conformance.yml @@ -0,0 +1,61 @@ +name: Run Protobuf Head Conformance Tests + +# This work workflow checks out head protocolbuffers/protobuf and runs the +# conformances with that. +# +# It runs on all PRs/Commits and also runs on a Cron to keep an eye out for +# new conformance tests that get added upstream. + +permissions: + contents: read + +on: + push: + branches: [ main ] + pull_request: + branches: [ main ] + # Every Sunday at 5am to get warning on any new conformance tests upstream. + schedule: + - cron: '0 5 * * 0' + # Also allow manual triggering from the github UX to revalidate things. + workflow_dispatch: + +jobs: + build: + runs-on: ubuntu-latest + container: + # Unlike build.yml we only worry about the conformance test with the + # latest Swift release. + image: swift:latest + steps: + - name: Checkout + uses: actions/checkout@v4 + with: + path: swift-protobuf + submodules: true + - name: Update and install dependencies + # Dependencies from https://github.com/protocolbuffers/protobuf/blob/main/src/README.md + run: apt-get update && apt-get install -y make g++ cmake + - name: Checkout protobufbuffers/protobuf + uses: actions/checkout@v4 + with: + repository: protocolbuffers/protobuf + path: protobuf + - name: Build protobuf + working-directory: protobuf + # https://github.com/protocolbuffers/protobuf/blob/main/cmake/README.md#c-version + run: | + mkdir cmake_build + cd cmake_build + cmake \ + -DCMAKE_CXX_STANDARD=17 \ + -DCMAKE_BUILD_TYPE=Release \ + -Dprotobuf_BUILD_TESTS=OFF \ + -Dprotobuf_INSTALL=OFF \ + -Dprotobuf_BUILD_CONFORMANCE=ON \ + -S .. + NUM_CPUS=$(getconf _NPROCESSORS_ONLN) + make -j "${NUM_CPUS}" conformance_test_runner + - name: Test conformance + working-directory: swift-protobuf + run: make test-conformance GOOGLE_PROTOBUF_CHECKOUT=../protobuf diff --git a/.github/workflows/pull_request_label.yml b/.github/workflows/pull_request_label.yml new file mode 100644 index 000000000..d2da2f1ac --- /dev/null +++ b/.github/workflows/pull_request_label.yml @@ -0,0 +1,21 @@ +name: PR label + +permissions: + contents: read + +on: + pull_request: + types: [labeled, unlabeled, opened, reopened, synchronize] + +jobs: + semver-label-check: + name: Semantic version label check + runs-on: ubuntu-latest + timeout-minutes: 1 + steps: + - name: Checkout repository + uses: actions/checkout@v4 + with: + persist-credentials: false + - name: Check for Semantic Version label + uses: apple/swift-nio/.github/actions/pull_request_semver_label_checker@main diff --git a/.github/workflows/regular_conformance.yml b/.github/workflows/regular_conformance.yml deleted file mode 100644 index fd2d0eb7d..000000000 --- a/.github/workflows/regular_conformance.yml +++ /dev/null @@ -1,81 +0,0 @@ -name: Run Conformance Tests - -# This workflow is a subset of the build.yml. It *only* try to run the -# conformance checks. It is triggered weekly on a cron to catch when new -# conformance tests are added and they don't pass. -# -# Without this workflow the new tests wouldn't be noticed until a PR was made. -# -# This workflow shares the caching logic with build.yml. It should serve to -# update a subset of the caches for when things do land on trunk. If that -# is deemed not worth it in the future, this can be simplify. - -# NOTE: If making changes to most of the steps, please also look to update -# build.yml also. - -on: - schedule: - # Every Sunday at 5am. - - cron: '0 5 * * 0' - -jobs: - build: - runs-on: ubuntu-18.04 - strategy: - matrix: - swift: ["5.5-bionic"] - # protobuf_git can reference a commit, tag, or branch - # commit: "commits/6935eae45c99926a000ecbef0be20dfd3d159e71" - # tag: "ref/tags/v3.11.4" - # branch: "ref/heads/master" - protobuf_git: ["ref/heads/master"] - container: - image: swift:${{ matrix.swift }} - steps: - - name: Checkout - uses: actions/checkout@v2 - with: - path: main - - name: Update and install dependencies - # dependencies from https://github.com/protocolbuffers/protobuf/blob/master/src/README.md - # this step is run before get-sha because we need curl and jq for get-sha - run: apt-get update && apt-get install -y autoconf automake libtool curl make g++ unzip jq - - name: Get Protobuf Commit SHA - id: get-sha - run: | - set -eu - url="https://api.github.com/repos/protocolbuffers/protobuf/git/${{ matrix.protobuf_git }}" - case ${{ matrix.protobuf_git }} in - ref/*) - echo ::set-output name=sha::$( curl -s -u "u:${{ github.token }}" "${url}" | jq -r .object.sha ) - ;; - commits/*) - echo ::set-output name=sha::$( curl -s -u "u:${{ github.token }}" "${url}" | jq -r .sha ) - ;; - esac - - name: Cache protobuf - id: cache-protobuf - uses: actions/cache@v2 - with: - path: protobuf - # NOTE: for refs that can float like 'main' the cache might be out of date! - key: ${{ runner.os }}-${{ matrix.swift}}-protobuf-${{ steps.get-sha.outputs.sha }} - - name: Checkout protobuf repo - if: steps.cache-protobuf.outputs.cache-hit != 'true' - uses: actions/checkout@v2 - with: - repository: protocolbuffers/protobuf - ref: ${{ steps.get-sha.outputs.sha }} - path: protobuf - - name: Build protobuf - if: steps.cache-protobuf.outputs.cache-hit != 'true' - working-directory: protobuf - run: | - ./autogen.sh - ./configure - NUM_CPUS=$(getconf _NPROCESSORS_ONLN) - make -C ./src -j "${NUM_CPUS}" protoc - make -C ./conformance conformance-test-runner - - name: Test conformance - working-directory: main - run: make test-conformance diff --git a/.github/workflows/update_protobuf.yml b/.github/workflows/update_protobuf.yml new file mode 100644 index 000000000..8239a966d --- /dev/null +++ b/.github/workflows/update_protobuf.yml @@ -0,0 +1,119 @@ +name: Update Protobuf and Abseil Submodules + +permissions: + contents: write + pull-requests: write + +on: + schedule: + # Every night at 2am UTC + - cron: '0 2 * * *' + workflow_dispatch: + +jobs: + check-and-update: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + with: + submodules: true + token: ${{ secrets.GITHUB_TOKEN }} + + - name: Check for new protobuf release + id: check_release + run: | + # Get the latest protobuf release tag + LATEST_TAG=$(curl -s https://api.github.com/repos/protocolbuffers/protobuf/releases/latest | jq -r '.tag_name') + echo "Latest protobuf release: $LATEST_TAG" + + # Get current protobuf submodule commit + cd Sources/protobuf/protobuf + CURRENT_TAG=$(git describe --tags --exact-match 2>/dev/null || echo "none") + echo "Current protobuf version: $CURRENT_TAG" + cd ../../.. + + # Check if update is needed + if [ "$LATEST_TAG" != "$CURRENT_TAG" ] && [ "$LATEST_TAG" != "null" ]; then + echo "needs_update=true" >> $GITHUB_OUTPUT + echo "latest_tag=$LATEST_TAG" >> $GITHUB_OUTPUT + echo "Update needed: $CURRENT_TAG -> $LATEST_TAG" + else + echo "needs_update=false" >> $GITHUB_OUTPUT + echo "No update needed" + fi + + - name: Update protobuf submodule + if: steps.check_release.outputs.needs_update == 'true' + run: | + cd Sources/protobuf/protobuf + git fetch --tags + git checkout ${{ steps.check_release.outputs.latest_tag }} + cd ../../.. + + - name: Determine required abseil version + if: steps.check_release.outputs.needs_update == 'true' + id: check_abseil + run: | + # Extract abseil commit from protobuf_deps.bzl + ABSEIL_COMMIT=$(grep -A 10 '"com_google_absl"' Sources/protobuf/protobuf/protobuf_deps.bzl | grep 'commit' | head -1 | sed 's/.*"\([a-f0-9]*\)".*/\1/') + + if [ -z "$ABSEIL_COMMIT" ]; then + echo "Error: Could not determine abseil commit" + exit 1 + fi + + echo "Required abseil commit: $ABSEIL_COMMIT" + echo "abseil_commit=$ABSEIL_COMMIT" >> $GITHUB_OUTPUT + + - name: Update abseil submodule + if: steps.check_release.outputs.needs_update == 'true' + run: | + cd Sources/protobuf/abseil + git fetch + git checkout ${{ steps.check_abseil.outputs.abseil_commit }} + cd ../../.. + + - name: Stage submodule updates + if: steps.check_release.outputs.needs_update == 'true' + run: | + git add Sources/protobuf/protobuf + git add Sources/protobuf/abseil + + - name: Get abseil version info + if: steps.check_release.outputs.needs_update == 'true' + id: abseil_info + run: | + cd Sources/protobuf/abseil + ABSEIL_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "commit ${{ steps.check_abseil.outputs.abseil_commit }}") + echo "abseil_version=$ABSEIL_TAG" >> $GITHUB_OUTPUT + cd ../../.. + + - name: Create Pull Request + if: steps.check_release.outputs.needs_update == 'true' + uses: peter-evans/create-pull-request@v6 + with: + token: ${{ secrets.GITHUB_TOKEN }} + commit-message: | + Update protobuf to ${{ steps.check_release.outputs.latest_tag }} and abseil-cpp + + - Update protobuf submodule to ${{ steps.check_release.outputs.latest_tag }} + - Update abseil-cpp submodule to ${{ steps.abseil_info.outputs.abseil_version }} + branch: automated/update-protobuf-${{ steps.check_release.outputs.latest_tag }} + delete-branch: true + title: 'Update protobuf to ${{ steps.check_release.outputs.latest_tag }}' + body: | + ## Automated Protobuf Update + + This PR automatically updates the protobuf and abseil-cpp submodules to their latest versions. + + ### Changes + - **Protobuf**: Updated to `${{ steps.check_release.outputs.latest_tag }}` + - **Abseil-cpp**: Updated to `${{ steps.abseil_info.outputs.abseil_version }}` + + ### Release Notes + See the [protobuf ${{ steps.check_release.outputs.latest_tag }} release notes](https://github.com/protocolbuffers/protobuf/releases/tag/${{ steps.check_release.outputs.latest_tag }}) for details. + + --- + + *This PR was automatically created by the [Update Protobuf workflow](https://github.com/${{ github.repository }}/actions/workflows/update_protobuf.yml)* diff --git a/.gitignore b/.gitignore index 6bc29bdac..819219ddf 100644 --- a/.gitignore +++ b/.gitignore @@ -9,8 +9,19 @@ xcbaselines /docs /build mined_words.txt -/DescriptorTestData.bin +/CompileTests/MultiModule/.build +/CompileTests/MultiModule/.swiftpm +/CompileTests/InternalImportsByDefault/.build +/CompileTests/InternalImportsByDefault/.swiftpm +/*DescriptorTestData.bin +/Package.resolved +/PluginLibEditionDefaults.bin +/PluginLibTestingEditionDefaults.bin # Intermediate conformance test outputs failing_tests.txt nonexistent_tests.txt +succeeding_tests.txt + +PluginExamples/.build +PluginExamples/.swiftpm/ diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 000000000..4c62003bf --- /dev/null +++ b/.gitmodules @@ -0,0 +1,8 @@ +[submodule "Sources/protobuf/protobuf"] + path = Sources/protobuf/protobuf + url = https://github.com/protocolbuffers/protobuf + branch = main +[submodule "Sources/protobuf/abseil"] + path = Sources/protobuf/abseil + url = https://github.com/abseil/abseil-cpp + branch = main diff --git a/.spi.yml b/.spi.yml index 2f94c4454..6c373378d 100644 --- a/.spi.yml +++ b/.spi.yml @@ -2,12 +2,9 @@ version: 1 builder: configs: - platform: ios - scheme: SwiftProtobuf_iOS - - platform: macos-xcodebuild - scheme: SwiftProtobuf_macOS - - platform: macos-xcodebuild-arm - scheme: SwiftProtobuf_macOS + documentation_targets: [SwiftProtobuf] + scheme: SwiftProtobuf - platform: tvos - scheme: SwiftProtobuf_tvOS + scheme: SwiftProtobuf - platform: watchos - scheme: SwiftProtobuf_watchOS + scheme: SwiftProtobuf diff --git a/.swift-format b/.swift-format new file mode 100644 index 000000000..7fa06fb30 --- /dev/null +++ b/.swift-format @@ -0,0 +1,62 @@ +{ + "version" : 1, + "indentation" : { + "spaces" : 4 + }, + "tabWidth" : 4, + "fileScopedDeclarationPrivacy" : { + "accessLevel" : "private" + }, + "spacesAroundRangeFormationOperators" : false, + "indentConditionalCompilationBlocks" : false, + "indentSwitchCaseLabels" : false, + "lineBreakAroundMultilineExpressionChainComponents" : false, + "lineBreakBeforeControlFlowKeywords" : false, + "lineBreakBeforeEachArgument" : true, + "lineBreakBeforeEachGenericRequirement" : true, + "lineLength" : 120, + "maximumBlankLines" : 1, + "respectsExistingLineBreaks" : true, + "prioritizeKeepingFunctionOutputTogether" : true, + "rules" : { + "AllPublicDeclarationsHaveDocumentation" : false, + "AlwaysUseLiteralForEmptyCollectionInit" : false, + "AlwaysUseLowerCamelCase" : false, + "AmbiguousTrailingClosureOverload" : true, + "BeginDocumentationCommentWithOneLineSummary" : false, + "DoNotUseSemicolons" : true, + "DontRepeatTypeInStaticProperties" : true, + "FileScopedDeclarationPrivacy" : true, + "FullyIndirectEnum" : true, + "GroupNumericLiterals" : true, + "IdentifiersMustBeASCII" : true, + "NeverForceUnwrap" : false, + "NeverUseForceTry" : false, + "NeverUseImplicitlyUnwrappedOptionals" : false, + "NoAccessLevelOnExtensionDeclaration" : true, + "NoAssignmentInExpressions" : true, + "NoBlockComments" : true, + "NoCasesWithOnlyFallthrough" : true, + "NoEmptyTrailingClosureParentheses" : true, + "NoLabelsInCasePatterns" : true, + "NoLeadingUnderscores" : false, + "NoParensAroundConditions" : true, + "NoVoidReturnOnFunctionSignature" : true, + "OmitExplicitReturns" : true, + "OneCasePerLine" : true, + "OneVariableDeclarationPerLine" : true, + "OnlyOneTrailingClosureArgument" : true, + "OrderedImports" : true, + "ReplaceForEachWithForLoop" : true, + "ReturnVoidInsteadOfEmptyTuple" : true, + "UseEarlyExits" : false, + "UseExplicitNilCheckInConditions" : false, + "UseLetInEveryBoundCaseVariable" : false, + "UseShorthandTypeNames" : true, + "UseSingleLinePropertyGetter" : false, + "UseSynthesizedInitializer" : false, + "UseTripleSlashForDocumentationComments" : true, + "UseWhereClausesInForLoops" : false, + "ValidateDocumentationComments" : false + } +} diff --git a/CompileTests/InternalImportsByDefault/Package.swift b/CompileTests/InternalImportsByDefault/Package.swift new file mode 100644 index 000000000..33d1183d5 --- /dev/null +++ b/CompileTests/InternalImportsByDefault/Package.swift @@ -0,0 +1,41 @@ +// swift-tools-version: 6.0 + +// Package.swift +// +// Copyright (c) 2024 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt + +import PackageDescription + +let package = Package( + name: "CompileTests", + dependencies: [ + .package(path: "../..") + ], + targets: [ + .executableTarget( + name: "InternalImportsByDefault", + dependencies: [ + .product(name: "SwiftProtobuf", package: "swift-protobuf") + ], + exclude: [ + "Protos/SomeProtoWithBytes.proto", + "Protos/ServiceOnly.proto", + ], + swiftSettings: [ + .enableExperimentalFeature("InternalImportsByDefault"), + .enableExperimentalFeature("AccessLevelOnImport"), + // Enable warnings as errors so the build fails if warnings are + // present in generated code. + .unsafeFlags(["-warnings-as-errors"]), + ], + plugins: [ + .plugin(name: "SwiftProtobufPlugin", package: "swift-protobuf") + ] + ) + ], + swiftLanguageModes: [.v6] +) diff --git a/CompileTests/InternalImportsByDefault/Package@swift-5.10.swift b/CompileTests/InternalImportsByDefault/Package@swift-5.10.swift new file mode 100644 index 000000000..a1139925c --- /dev/null +++ b/CompileTests/InternalImportsByDefault/Package@swift-5.10.swift @@ -0,0 +1,40 @@ +// swift-tools-version: 5.10 + +// Package.swift +// +// Copyright (c) 2024 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt + +import PackageDescription + +let package = Package( + name: "CompileTests", + dependencies: [ + .package(path: "../..") + ], + targets: [ + .executableTarget( + name: "InternalImportsByDefault", + dependencies: [ + .product(name: "SwiftProtobuf", package: "swift-protobuf") + ], + exclude: [ + "Protos/SomeProtoWithBytes.proto", + "Protos/ServiceOnly.proto", + ], + swiftSettings: [ + .enableExperimentalFeature("InternalImportsByDefault"), + .enableExperimentalFeature("AccessLevelOnImport"), + // Enable warnings as errors so the build fails if warnings are + // present in generated code. + .unsafeFlags(["-warnings-as-errors"]), + ], + plugins: [ + .plugin(name: "SwiftProtobufPlugin", package: "swift-protobuf") + ] + ) + ] +) diff --git a/CompileTests/InternalImportsByDefault/README.md b/CompileTests/InternalImportsByDefault/README.md new file mode 100644 index 000000000..5b3f9a914 --- /dev/null +++ b/CompileTests/InternalImportsByDefault/README.md @@ -0,0 +1,12 @@ +# CompileTests/InternalImportsByDefault + +This is a test case that ensures that generated code builds correctly when +`InternalImportsByDefault` is enabled and the code is generated with public +visibility. + +When support for access level modifiers on imports was first added, an issue +was encountered where publicly-generated protos would generate build errors and +warnings when `InternalImportsByDefault` was enabled, as some dependencies were +imported without an explicit access level modifier (i.e. `Foundation`), and some +where sometimes imported as `public` without actually being used in the +generated code at all (i.e. `Foundation` and `SwiftProtobuf`). diff --git a/CompileTests/InternalImportsByDefault/Sources/InternalImportsByDefault/Protos/ServiceOnly.proto b/CompileTests/InternalImportsByDefault/Sources/InternalImportsByDefault/Protos/ServiceOnly.proto new file mode 100644 index 000000000..ff4bdac9e --- /dev/null +++ b/CompileTests/InternalImportsByDefault/Sources/InternalImportsByDefault/Protos/ServiceOnly.proto @@ -0,0 +1,7 @@ +// This proto file should generate an empty file, since the plugin will ignore +// service definitions. +// This is here to make sure we don't import Foundation or SwiftProtobuf when +// it's not necessary. + +service SomeService { +} diff --git a/CompileTests/InternalImportsByDefault/Sources/InternalImportsByDefault/Protos/SomeProtoWithBytes.proto b/CompileTests/InternalImportsByDefault/Sources/InternalImportsByDefault/Protos/SomeProtoWithBytes.proto new file mode 100644 index 000000000..d838a7884 --- /dev/null +++ b/CompileTests/InternalImportsByDefault/Sources/InternalImportsByDefault/Protos/SomeProtoWithBytes.proto @@ -0,0 +1,12 @@ +// This proto will generate a Swift file that imports Foundation, because it +// defines a bytes field. +// Because InternalImportsByDefault is enabled on this module and we generate +// protos with public visibility, the build will fail if the access level +// modifier is missing (or wrong) since it will default the import to `internal` +// and cause a conflict of access levels, since the `someBytes` property defined +// on the message will be public. + +message SomeProtoWithBytes { + optional bytes someBytes = 2; + optional string ext_str = 100; +} diff --git a/CompileTests/InternalImportsByDefault/Sources/InternalImportsByDefault/main.swift b/CompileTests/InternalImportsByDefault/Sources/InternalImportsByDefault/main.swift new file mode 100644 index 000000000..34aff05ca --- /dev/null +++ b/CompileTests/InternalImportsByDefault/Sources/InternalImportsByDefault/main.swift @@ -0,0 +1,22 @@ +// main.swift +// +// Copyright (c) 2024 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt + +private import Foundation + +struct InternalImportsByDefault { + static func main() { + let protoWithBytes = SomeProtoWithBytes.with { proto in + proto.someBytes = Data() + proto.extStr = "" + } + blackhole(protoWithBytes) + } +} + +@inline(never) +func blackhole(_: T) {} diff --git a/CompileTests/InternalImportsByDefault/Sources/InternalImportsByDefault/swift-protobuf-config.json b/CompileTests/InternalImportsByDefault/Sources/InternalImportsByDefault/swift-protobuf-config.json new file mode 100644 index 000000000..40e96eb23 --- /dev/null +++ b/CompileTests/InternalImportsByDefault/Sources/InternalImportsByDefault/swift-protobuf-config.json @@ -0,0 +1,12 @@ +{ + "invocations": [ + { + "protoFiles": [ + "Protos/SomeProtoWithBytes.proto", + "Protos/ServiceOnly.proto", + ], + "visibility": "public", + "useAccessLevelOnImports": true + } + ] +} diff --git a/CompileTests/MultiModule/Package.swift b/CompileTests/MultiModule/Package.swift new file mode 100644 index 000000000..d67a02322 --- /dev/null +++ b/CompileTests/MultiModule/Package.swift @@ -0,0 +1,41 @@ +// swift-tools-version: 6.0 + +import PackageDescription + +let package = Package( + name: "CompileTests", + dependencies: [ + .package(name: "swift-protobuf", path: "../..") + ], + targets: [ + .testTarget( + name: "Test1", + dependencies: ["ImportsAPublicly"] + ), + .testTarget( + name: "Test2", + dependencies: ["ImportsImportsAPublicly"] + ), + .target( + name: "ModuleA", + dependencies: [ + .product(name: "SwiftProtobuf", package: "swift-protobuf") + ] + ), + .target( + name: "ImportsAPublicly", + dependencies: [ + .product(name: "SwiftProtobuf", package: "swift-protobuf"), + .target(name: "ModuleA"), + ] + ), + .target( + name: "ImportsImportsAPublicly", + dependencies: [ + .product(name: "SwiftProtobuf", package: "swift-protobuf"), + .target(name: "ImportsAPublicly"), + ] + ), + ], + swiftLanguageModes: [.v6] +) diff --git a/CompileTests/MultiModule/Package@swift-5.10.swift b/CompileTests/MultiModule/Package@swift-5.10.swift new file mode 100644 index 000000000..bd57970c7 --- /dev/null +++ b/CompileTests/MultiModule/Package@swift-5.10.swift @@ -0,0 +1,40 @@ +// swift-tools-version: 5.10 + +import PackageDescription + +let package = Package( + name: "CompileTests", + dependencies: [ + .package(name: "swift-protobuf", path: "../..") + ], + targets: [ + .testTarget( + name: "Test1", + dependencies: ["ImportsAPublicly"] + ), + .testTarget( + name: "Test2", + dependencies: ["ImportsImportsAPublicly"] + ), + .target( + name: "ModuleA", + dependencies: [ + .product(name: "SwiftProtobuf", package: "swift-protobuf") + ] + ), + .target( + name: "ImportsAPublicly", + dependencies: [ + .product(name: "SwiftProtobuf", package: "swift-protobuf"), + .target(name: "ModuleA"), + ] + ), + .target( + name: "ImportsImportsAPublicly", + dependencies: [ + .product(name: "SwiftProtobuf", package: "swift-protobuf"), + .target(name: "ImportsAPublicly"), + ] + ), + ] +) diff --git a/CompileTests/MultiModule/README.md b/CompileTests/MultiModule/README.md new file mode 100644 index 000000000..245e25c16 --- /dev/null +++ b/CompileTests/MultiModule/README.md @@ -0,0 +1,7 @@ +# CompileTests/MultiModule + +This is a test case that uses sources generated into multiple modules and +ensures the generated code compiles with the cross modules references. + +This can't use the SwiftPM Plugin as that currently doesn't have support for the +module mappings. diff --git a/CompileTests/MultiModule/Sources/ImportsAPublicly/imports_a_publicly.pb.swift b/CompileTests/MultiModule/Sources/ImportsAPublicly/imports_a_publicly.pb.swift new file mode 100644 index 000000000..9804820f7 --- /dev/null +++ b/CompileTests/MultiModule/Sources/ImportsAPublicly/imports_a_publicly.pb.swift @@ -0,0 +1,103 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: Sources/ImportsAPublicly/imports_a_publicly.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +import SwiftProtobuf + +// Use of 'import public' causes re-exports: +@_exported import enum ModuleA.E +@_exported import let ModuleA.Extensions_ext_str +@_exported import struct ModuleA.A + +// 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 +} + +public struct ImportsAPublicly: Sendable { + // 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. + + public var a: ModuleA.A { + get {_a ?? ModuleA.A()} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + public var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + public mutating func clearA() {self._a = nil} + + public var e: ModuleA.E { + get {_e ?? .unset} + set {_e = newValue} + } + /// Returns true if `e` has been explicitly set. + public var hasE: Bool {self._e != nil} + /// Clears the value of `e`. Subsequent reads from it will return its default value. + public mutating func clearE() {self._e = nil} + + public var unknownFields = SwiftProtobuf.UnknownStorage() + + public init() {} + + fileprivate var _a: ModuleA.A? = nil + fileprivate var _e: ModuleA.E? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension ImportsAPublicly: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = "ImportsAPublicly" + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{b}a\0\u{1}e\0") + + public var isInitialized: Bool { + if let v = self._a, !v.isInitialized {return false} + return true + } + + public 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 11: try { try decoder.decodeSingularMessageField(value: &self._a) }() + case 12: try { try decoder.decodeSingularEnumField(value: &self._e) }() + default: break + } + } + } + + public 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 + try { if let v = self._a { + try visitor.visitSingularMessageField(value: v, fieldNumber: 11) + } }() + try { if let v = self._e { + try visitor.visitSingularEnumField(value: v, fieldNumber: 12) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: ImportsAPublicly, rhs: ImportsAPublicly) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._e != rhs._e {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/CompileTests/MultiModule/Sources/ImportsImportsAPublicly/imports_imports_a_publicly.pb.swift b/CompileTests/MultiModule/Sources/ImportsImportsAPublicly/imports_imports_a_publicly.pb.swift new file mode 100644 index 000000000..7eca48637 --- /dev/null +++ b/CompileTests/MultiModule/Sources/ImportsImportsAPublicly/imports_imports_a_publicly.pb.swift @@ -0,0 +1,104 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: Sources/ImportsImportsAPublicly/imports_imports_a_publicly.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +import SwiftProtobuf + +// Use of 'import public' causes re-exports: +@_exported import enum ModuleA.E +@_exported import let ModuleA.Extensions_ext_str +@_exported import struct ImportsAPublicly.ImportsAPublicly +@_exported import struct ModuleA.A + +// 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 +} + +public struct ImportsImportsAPublicly: Sendable { + // 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. + + public var a: ModuleA.A { + get {_a ?? ModuleA.A()} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + public var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + public mutating func clearA() {self._a = nil} + + public var e: ModuleA.E { + get {_e ?? .unset} + set {_e = newValue} + } + /// Returns true if `e` has been explicitly set. + public var hasE: Bool {self._e != nil} + /// Clears the value of `e`. Subsequent reads from it will return its default value. + public mutating func clearE() {self._e = nil} + + public var unknownFields = SwiftProtobuf.UnknownStorage() + + public init() {} + + fileprivate var _a: ModuleA.A? = nil + fileprivate var _e: ModuleA.E? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension ImportsImportsAPublicly: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = "ImportsImportsAPublicly" + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{15}a\0\u{1}e\0") + + public var isInitialized: Bool { + if let v = self._a, !v.isInitialized {return false} + return true + } + + public 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 21: try { try decoder.decodeSingularMessageField(value: &self._a) }() + case 22: try { try decoder.decodeSingularEnumField(value: &self._e) }() + default: break + } + } + } + + public 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 + try { if let v = self._a { + try visitor.visitSingularMessageField(value: v, fieldNumber: 21) + } }() + try { if let v = self._e { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: ImportsImportsAPublicly, rhs: ImportsImportsAPublicly) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._e != rhs._e {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/CompileTests/MultiModule/Sources/ModuleA/a.pb.swift b/CompileTests/MultiModule/Sources/ModuleA/a.pb.swift new file mode 100644 index 000000000..a25937f57 --- /dev/null +++ b/CompileTests/MultiModule/Sources/ModuleA/a.pb.swift @@ -0,0 +1,150 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: Sources/ModuleA/a.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +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 +} + +public enum E: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unset = 0 + case a = 1 + case b = 2 + + public init() { + self = .unset + } + +} + +public struct A: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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. + + public var e: E { + get {_e ?? .unset} + set {_e = newValue} + } + /// Returns true if `e` has been explicitly set. + public var hasE: Bool {self._e != nil} + /// Clears the value of `e`. Subsequent reads from it will return its default value. + public mutating func clearE() {self._e = nil} + + public var unknownFields = SwiftProtobuf.UnknownStorage() + + public init() {} + + public var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _e: E? = nil +} + +// MARK: - Extension support defined in a.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 A { + + public var extStr: String { + get {return getExtensionValue(ext: Extensions_ext_str) ?? String()} + set {setExtensionValue(ext: Extensions_ext_str, value: newValue)} + } + /// Returns true if extension `Extensions_ext_str` + /// has been explicitly set. + public var hasExtStr: Bool { + return hasExtensionValue(ext: Extensions_ext_str) + } + /// Clears the value of extension `Extensions_ext_str`. + /// Subsequent reads from it will return its default value. + public mutating func clearExtStr() { + clearExtensionValue(ext: Extensions_ext_str) + } + +} + +// MARK: - File's ExtensionMap: A_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`. +public let A_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Extensions_ext_str +] + +// 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. + +public let Extensions_ext_str = SwiftProtobuf.MessageExtension, A>( + _protobuf_fieldNumber: 100, + fieldName: "ext_str" +) + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension E: SwiftProtobuf._ProtoNameProviding { + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0E_UNSET\0\u{1}E_A\0\u{1}E_B\0") +} + +extension A: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = "A" + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}e\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + public 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._e) }() + case 100..<1001: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: A.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + + public 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 + try { if let v = self._e { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 100, end: 1001) + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: A, rhs: A) -> Bool { + if lhs._e != rhs._e {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} diff --git a/CompileTests/MultiModule/Sources/ReExportAOnly/reexport_a_only.pb.swift b/CompileTests/MultiModule/Sources/ReExportAOnly/reexport_a_only.pb.swift new file mode 100644 index 000000000..907b20296 --- /dev/null +++ b/CompileTests/MultiModule/Sources/ReExportAOnly/reexport_a_only.pb.swift @@ -0,0 +1,16 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: Sources/ReExportAOnly/reexport_a_only.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Use of 'import public' causes re-exports: +@_exported import enum ModuleA.E +@_exported import let ModuleA.Extensions_ext_str +@_exported import struct ModuleA.A + +// This file contained no messages, enums, or extensions. diff --git a/CompileTests/MultiModule/Tests/Test1/test1.swift b/CompileTests/MultiModule/Tests/Test1/test1.swift new file mode 100644 index 000000000..f9cefc125 --- /dev/null +++ b/CompileTests/MultiModule/Tests/Test1/test1.swift @@ -0,0 +1,31 @@ +import ImportsAPublicly +import XCTest + +// Don't need to import ModuleA because of the file being a `import public` + +final class ExampleTests: XCTestCase { + func testA() { + let anA = A.with { $0.e = .a } + XCTAssertEqual(anA.e, .a) + } + + func testImportsAPublicly() { + let imports = ImportsAPublicly.with { $0.a.e = .a } + XCTAssertEqual(imports.a.e, .a) + } + + func testInterop() { + let anA = A.with { $0.e = .b } + let imports = ImportsAPublicly.with { + $0.a = anA + $0.e = .b + } + XCTAssertEqual(imports.a.e, imports.e) + let transitively = UsesATransitively.with { + $0.a = anA + $0.e = imports.e + } + XCTAssertEqual(transitively.a, anA) + XCTAssertEqual(transitively.e, imports.e) + } +} diff --git a/CompileTests/MultiModule/Tests/Test1/uses_a_transitively.pb.swift b/CompileTests/MultiModule/Tests/Test1/uses_a_transitively.pb.swift new file mode 100644 index 000000000..36563c266 --- /dev/null +++ b/CompileTests/MultiModule/Tests/Test1/uses_a_transitively.pb.swift @@ -0,0 +1,100 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: Tests/Test1/uses_a_transitively.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +import SwiftProtobuf + +import ImportsAPublicly + +// 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 +} + +public struct UsesATransitively: Sendable { + // 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. + + public var a: ModuleA.A { + get {_a ?? ModuleA.A()} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + public var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + public mutating func clearA() {self._a = nil} + + public var e: ModuleA.E { + get {_e ?? .unset} + set {_e = newValue} + } + /// Returns true if `e` has been explicitly set. + public var hasE: Bool {self._e != nil} + /// Clears the value of `e`. Subsequent reads from it will return its default value. + public mutating func clearE() {self._e = nil} + + public var unknownFields = SwiftProtobuf.UnknownStorage() + + public init() {} + + fileprivate var _a: ModuleA.A? = nil + fileprivate var _e: ModuleA.E? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension UsesATransitively: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = "UsesATransitively" + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}e\u{1}a\0\u{1}e\0") + + public var isInitialized: Bool { + if let v = self._a, !v.isInitialized {return false} + return true + } + + public 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 101: try { try decoder.decodeSingularMessageField(value: &self._a) }() + case 102: try { try decoder.decodeSingularEnumField(value: &self._e) }() + default: break + } + } + } + + public 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 + try { if let v = self._a { + try visitor.visitSingularMessageField(value: v, fieldNumber: 101) + } }() + try { if let v = self._e { + try visitor.visitSingularEnumField(value: v, fieldNumber: 102) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: UsesATransitively, rhs: UsesATransitively) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._e != rhs._e {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/CompileTests/MultiModule/Tests/Test2/test2.swift b/CompileTests/MultiModule/Tests/Test2/test2.swift new file mode 100644 index 000000000..3e47bbeae --- /dev/null +++ b/CompileTests/MultiModule/Tests/Test2/test2.swift @@ -0,0 +1,31 @@ +import ImportsImportsAPublicly +import XCTest + +// Don't need to import ModuleA because of the file being a `import public` + +final class ExampleTests: XCTestCase { + func testA() { + let anA = A.with { $0.e = .a } + XCTAssertEqual(anA.e, .a) + } + + func testImportsImportsAPublicly() { + let imports = ImportsImportsAPublicly.with { $0.a.e = .a } + XCTAssertEqual(imports.a.e, .a) + } + + func testInterop() { + let anA = A.with { $0.e = .b } + let imports = ImportsImportsAPublicly.with { + $0.a = anA + $0.e = .b + } + XCTAssertEqual(imports.a.e, imports.e) + let transitively = UsesATransitively2.with { + $0.a = anA + $0.e = imports.e + } + XCTAssertEqual(transitively.a, anA) + XCTAssertEqual(transitively.e, imports.e) + } +} diff --git a/CompileTests/MultiModule/Tests/Test2/uses_a_transitively2.pb.swift b/CompileTests/MultiModule/Tests/Test2/uses_a_transitively2.pb.swift new file mode 100644 index 000000000..c9dad2c68 --- /dev/null +++ b/CompileTests/MultiModule/Tests/Test2/uses_a_transitively2.pb.swift @@ -0,0 +1,100 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: Tests/Test2/uses_a_transitively2.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +import SwiftProtobuf + +import ImportsImportsAPublicly + +// 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 +} + +public struct UsesATransitively2: Sendable { + // 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. + + public var a: ModuleA.A { + get {_a ?? ModuleA.A()} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + public var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + public mutating func clearA() {self._a = nil} + + public var e: ModuleA.E { + get {_e ?? .unset} + set {_e = newValue} + } + /// Returns true if `e` has been explicitly set. + public var hasE: Bool {self._e != nil} + /// Clears the value of `e`. Subsequent reads from it will return its default value. + public mutating func clearE() {self._e = nil} + + public var unknownFields = SwiftProtobuf.UnknownStorage() + + public init() {} + + fileprivate var _a: ModuleA.A? = nil + fileprivate var _e: ModuleA.E? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension UsesATransitively2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = "UsesATransitively2" + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}o\u{1}a\0\u{2}\u{b}e\0") + + public var isInitialized: Bool { + if let v = self._a, !v.isInitialized {return false} + return true + } + + public 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 111: try { try decoder.decodeSingularMessageField(value: &self._a) }() + case 122: try { try decoder.decodeSingularEnumField(value: &self._e) }() + default: break + } + } + } + + public 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 + try { if let v = self._a { + try visitor.visitSingularMessageField(value: v, fieldNumber: 111) + } }() + try { if let v = self._e { + try visitor.visitSingularEnumField(value: v, fieldNumber: 122) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: UsesATransitively2, rhs: UsesATransitively2) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._e != rhs._e {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/DevTools/CollectTests.awk b/DevTools/CollectTests.awk deleted file mode 100644 index 2bf7e59a0..000000000 --- a/DevTools/CollectTests.awk +++ /dev/null @@ -1,83 +0,0 @@ -#!/usr/bin/awk -f - -# ProtobufRuntime/Sources/Protobuf/ProtobufBinaryEncoding.swift - Binary encoding support -# -# This source file is part of the Swift.org open source project -# -# Copyright (c) 2014 - 2016 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 -# -# ----------------------------------------------------------------------------- -# -# The Linux version of XCTest cannot automatically -# discover tests at run-time. So you can either manually -# maintain lists of tests or collect them at build time. -# -# This script is used by the Makefile to do the latter: -# = Scans each XCTest source file for 'class Foo: XCTestCase' -# = Looks for 'func test*' within those classes -# = Emits a class extension with the necessary 'allTests' property -# = Emits an XCTMain invocation to run all the classes -# -# The macOS version of XCTest has another mechanism for -# finding tests at run-time, so this is not needed there. -# -# ----------------------------------------------------------------------------- - -BEGIN { - CLASS="" - TESTCASES="" - TESTCASE_separator="" - printf("//\n") - printf("// GENERATED FILE\n") - printf("// DO NOT EDIT\n") - printf("// swift-format-ignore-file\n") - printf("//\n") - printf("\n") - printf("import XCTest\n") - printf("@testable import SwiftProtobufTests\n") - printf("@testable import SwiftProtobufPluginLibraryTests\n") - printf("\n") -} - -/class .*:.* XCTestCase/ { - if (CLASS != "") { - printf("\n ]\n") - printf("}\n") - } - split($0, a, ":") - split(a[1], words, " ") - CLASS=words[2] - TESTCASES = TESTCASES TESTCASE_separator "\n" " testCase(" CLASS ".allTests)" - TESTCASE_separator = "," - printf("\n") - printf("extension %s {\n", CLASS) - printf(" static var allTests = [") - FUNC_separator="" -} - - -/^ *func *test.*/ { - split($0, a, "(") - split(a[1], words, " ") - FUNC=words[2] - printf("") - printf("%s\n (\"%s\", %s)", FUNC_separator, FUNC, FUNC) - FUNC_separator = "," -} - -END { - if (CLASS != "") { - printf("\n ]\n") - printf("}\n") - } - printf("\n") - - printf("XCTMain(\n") - printf(" [") - printf(TESTCASES) - printf("\n ]\n)\n") -} diff --git a/DevTools/LibraryVersions.py b/DevTools/LibraryVersions.py index 1efd6aad9..0d3d43f45 100755 --- a/DevTools/LibraryVersions.py +++ b/DevTools/LibraryVersions.py @@ -1,4 +1,4 @@ -#! /usr/bin/python +#! /usr/bin/python3 # DevTools/LibraryVersions.py - Helper for the library's version number # # Copyright (c) 2014 - 2017 Apple Inc. and the project authors @@ -20,7 +20,6 @@ _PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) _PODSPEC_PATH = os.path.join(_PROJECT_ROOT, 'SwiftProtobuf.podspec') _VERSION_SWIFT_PATH = os.path.join(_PROJECT_ROOT, 'Sources/SwiftProtobuf/Version.swift') -_XCCONFIG_PATH = os.path.join(_PROJECT_ROOT, 'SwiftProtobuf.xcodeproj/xcconfigs/Base.xcconfig') def Fail(message): sys.stderr.write('Error: %s\n' % message) @@ -51,12 +50,6 @@ def ValidateFiles(): if not had_major or not had_minor or not had_revision: Fail('Version in Sources/SwiftProtobuf/Version.swift did not match SwiftProtobuf.podspec') - # Test SwiftProtobuf.xcodeproj/xcconfigs/Base.xcconfig - xcconfig_content = open(_XCCONFIG_PATH).read() - current_version_line = 'CURRENT_PROJECT_VERSION = %s.%s.%s' % (major, minor, revision) - if current_version_line not in xcconfig_content: - Fail('Version in SwiftProtobuf.xcodeproj/xcconfigs/Base.xcconfig did not match SwiftProtobuf.podspec') - def UpdateFiles(version_string): (major, minor, revision) = ExtractVersion(version_string) @@ -81,13 +74,6 @@ def UpdateFiles(version_string): version_swift_content) open(_VERSION_SWIFT_PATH, 'w').write(version_swift_content) - # Update SwiftProtobuf.xcodeproj/xcconfigs/Base.xcconfig - xcconfig_content = open(_XCCONFIG_PATH).read() - xcconfig_content = re.sub(r'CURRENT_PROJECT_VERSION = \d+\.\d+\.\d+', - 'CURRENT_PROJECT_VERSION = %s.%s.%s' % (major, minor, revision), - xcconfig_content) - open(_XCCONFIG_PATH, 'w').write(xcconfig_content) - def main(args): usage = '%prog [OPTIONS] [VERSION]' diff --git a/Documentation/API.md b/Documentation/API.md index 2016540c2..5b4d01a56 100644 --- a/Documentation/API.md +++ b/Documentation/API.md @@ -68,14 +68,14 @@ public struct Example: SwiftProtobuf.Message { // An extension map may be needed when decoding nested // proto2-format messages that utilize extensions. // See below for more details. - func serializedData() throws -> Data - init(serializedData: Data) throws { - init(serializedData: Data, extensions: ExtensionMap? = nil, partial: Bool = false) throws + func serializedBytes() throws -> Bytes + init(serializedBytes: Bytes) throws { + init(serializedBytes: Bytes, extensions: ExtensionMap? = nil, partial: Bool = false) throws // Messages can be serialized or deserialized to JSON format - // as either UTF8-encoded Data objects or as Strings. - func jsonUTF8Data() throws -> Data - init(jsonUTF8Data: Data) throws + // as either UTF8-encoded ``SwiftProtobufContiguousBytes``-conforming objects or as Strings. + func jsonUTF8Bytes(options:) throws -> Bytes + init(jsonUTF8Bytes: Bytes) throws func jsonString() throws -> String init(jsonString: String) throws @@ -615,6 +615,42 @@ public func -(lhs: Google_Protobuf_Timestamp, rhs: Google_Protobuf_Duration) -> public func +(lhs: Google_Protobuf_Timestamp, rhs: Google_Protobuf_Duration) -> Google_Protobuf_Timestamp ``` +### Google_Protobuf_FieldMask + +`Google_Protobuf_FieldMask` is used to specify which fields in +a protocol buffer message should be included in operations such as updates or merges. +It allows precise control over which parts of the message +are affected by defining a list of field paths. + +For example, consider a protocol buffer message with nested fields: + +```protobuf +message ParentMessage { + string name = 1; + ChildMessage child = 2; + + message ChildMessage { + string childName = 1; + int32 age = 2; + } +} +``` + +If you want to update only the `name` field of `ParentMessage` +and the `childName` field within `ChildMessage`, +you would use a `FieldMask` as follows: + +```swift +let fieldMask = Google_Protobuf_FieldMask.with { + $0.paths = ["name", "child.childName"] +} +``` + +In this example, the `paths` list includes `"name"` to target +the `name` field in `ParentMessage` and `"child.childName"` +to target the `childName` field inside the nested `ChildMessage`. +This setup allows you to perform operations that affect +only these specified fields while leaving others unchanged. ## Extensions @@ -687,7 +723,7 @@ those descriptors. Support for descriptors ends up requiring some amount of code, but more importantly it requires capturing a large binary blob of data for every -message, enum, oneof, etc. That data has two potenial issues, it bloats the +message, enum, oneof, etc. That data has two potential issues, it bloats the binaries, and it is something that can be extracted from the binary to help reverse engineer details about the binary. @@ -696,6 +732,106 @@ Descriptor objects. It is something that could get revisited in the future, but will need careful consideration; the bloat/size issues is of the most concern because of Swift's common use for mobile applications. +## FieldMask Utilities + +### Merging Two Messages + +The `merge(from:fieldMask:)` function in Swift Protobuf selectively merges +fields from one message into another, guided by a `Google_Protobuf_FieldMask`. +This method is particularly useful when you need to update only specific +fields in a message without affecting others. +The `merge` function is available as a method on `Message` types and requires two parameters: +the source message (`from`) containing the data to merge +and the `fieldMask` that specifies which fields should be updated. + +For example, consider a message with the following structure: + +```protobuf +message ExampleMessage { + + message NestedMessage { + string baz = 1; + string qux = 2; + } + + string foo = 1; + string bar = 2; + NestedMessage nested = 3; +} +``` + +Assume we have two instances of `ExampleMessage`: + +```swift +let message1: ExampleMessage = .with { + $0.foo = "foo1" + $0.nested = .with { + $0.baz = "baz1" + } +} + +let message2: ExampleMessage = .with { + $0.foo = "foo2" + $0.bar = "bar2" + $0.nested = .with { + $0.baz = "baz2" + $0.qux = "qux2" + } +} +``` + +To merge `message2` into `message1` but only update the `bar` field +and `qux` field of `nested`, you can use a `Google_Protobuf_FieldMask` +like this: + +```swift +let fieldMask = Google_Protobuf_FieldMask.with { + $0.paths = ["bar", "nested.qux"] +} +try message1.merge(from: message2, fieldMask: fieldMask) +``` + +After this operation, `message1.bar` will have the value `"bar2"` from `message2`, +and `message1.nested.qux` will have the value `"qux2"` from `message2`, +while `message1.foo` and `message1.nested.baz` remain `"foo1"` and `"baz1"`. +Be aware that including `"nested"` in the FieldMask paths will cause all fields +within `message1.nested` to be updated from `message2` (including `baz` and `qux`), +whereas adding `"nested.qux"` only affects the `qux` field in the `nested` message. +The `merge` function operates in-place, meaning it directly modifies `message1`. + +### Trimming a Message + +The `trim(keeping:)` function retains only specific +fields in a protocol buffer message while clearing the rest. + +Consider the `ExampleMessage` structure from the previous example. +Suppose you have an instance of `ExampleMessage` initialized as follows: + +```swift +let message = ExampleMessage.with { + $0.foo = "foo" + $0.bar = "bar" +} +``` + +If you want to trim this message so that only the `bar` field retains its value, +you can use a `Google_Protobuf_FieldMask` like this: + +```swift +let fieldMask = Google_Protobuf_FieldMask.with { $0.paths = ["bar"] } +``` + +Then, you apply the `trim` function: + +```swift +message.trim(keeping: fieldMask) +``` + +After this operation, the `bar` field in `message` will still have the value `"bar"`, +while the `foo` field will be cleared, resetting to its default value (an empty string, +in this case). The `trim(keeping:)` function is performed in-place, meaning it directly +modifies the original message. + ## Aside: proto2 vs. proto3 The terms *proto2* and *proto3* refer to two different dialects of the proto diff --git a/Documentation/CONFORMANCE_TESTS.md b/Documentation/CONFORMANCE_TESTS.md index 81bbbb77e..8b8b81173 100644 --- a/Documentation/CONFORMANCE_TESTS.md +++ b/Documentation/CONFORMANCE_TESTS.md @@ -30,14 +30,14 @@ environment variable to the full path of the protobuf checkout. If the Makefile can find the protobuf project sources, then the following should suffice: ```console -$ make test +make test ``` This will build and run the SwiftProtobuf test suite, verify the code generator, and finally run the conformance tests. You can also run the conformance tests by themselves: ```console -$ make test-conformance +make test-conformance ``` ## Test Environment @@ -54,7 +54,7 @@ GOOGLE_PROTOBUF_CHECKOUT?=../protobuf If these do not match your system, you can specify one or both on the command line ``` -$ make PROTOC=[path] GOOGLE_PROTOBUF_CHECKOUT=[path] test +make PROTOC=[path] GOOGLE_PROTOBUF_CHECKOUT=[path] test ``` ## If you have problems @@ -64,16 +64,16 @@ program. You may find it easier to switch to the directory where you have checked out Google's protobuf sources and build the host program manually: ```console -$ cd protobuf -$ ./configure -$ make -C src -$ make -C conformance +cd protobuf +./configure +make -C src +make -C conformance ``` You can then manually run the conformance test using the following commands: ```console -$ cd swift-protobuf -$ ../protobuf/conformance/conformance-test-runner --failure_list failure_list_swift.txt .build/debug/Conformance +cd swift-protobuf +../protobuf/conformance/conformance-test-runner --failure_list failure_list_swift.txt .build/debug/Conformance ``` ## Known Issues diff --git a/Documentation/FAQ.md b/Documentation/FAQ.md index 470e7066d..5928f1a22 100644 --- a/Documentation/FAQ.md +++ b/Documentation/FAQ.md @@ -61,7 +61,7 @@ to expose similar data publicly from the Swift Runtime. ## Why are field names and enum case names mangled? -Protocol Buffers has a [styleguide](https://developers.google.com/protocol-buffers/docs/style), +Protocol Buffers has a [styleguide](https://protobuf.dev/programming-guides/style/), and it calls for field names to be _underscore_separated_names_ and enum cases to be _CAPITALS_WITH_UNDERSCORES_, to support all languages, it also says the enum cases should be prefixed with the type name (avoids naming collisions in C diff --git a/Documentation/INTERNALS.md b/Documentation/INTERNALS.md index 7913e7691..d1be92069 100644 --- a/Documentation/INTERNALS.md +++ b/Documentation/INTERNALS.md @@ -17,16 +17,13 @@ behavior are always appreciated. ## Swift Language Support -The goal is to always support "one full major version”, which basically -means if the current official release of Swift is `X.Y`, the library will -support back to `X-1.Y`. That is, when Swift 4.2 was released, the minimum -for support got moved up to 3.2. +SwiftProtobuf tries to support back to the oldest of: -NOTE: While things like Swift 4.1 existed from a packaging/install pov, -`swiftc` does not support `4.1` as a value for `-swift-version`, so the minimum -can't be made to something like _4.1_ because that can't be targeted. So when -the minimum would move to a version like that, it instead says on the previous -minimum that was targetable (4.0 in the 4.1 case). +* The + [Swift NIO guidelines support version](https://github.com/apple/swift-nio#supported-versions). +* Apple’s App Store submission requirements. This is announced on the + [Apple Developer News](https://developer.apple.com/news/) page; an + [example from March 2023](https://developer.apple.com/news/?id=jd9wcyov). When the minimum Swift version gets updated, update: - The `README.md` in the root of the project @@ -37,6 +34,16 @@ When the minimum Swift version gets updated, update: versions supported. Eventually the version specific `Package@*.swift` files will go away. + NOTE: As the minimum Xcode version updates, that also implicitly updates + the minimum supports Apple OS versions. Those updates also go into the + podspec file. If the an older Xcode might support the NIO Swift version, + we still listed the lower Swift version but higher Xcode version in the + `README.md` and we adopt the deployment minimums from the Xcode in + `SwiftProtobuf.podspec`. + + The deployment minimums for Xcode versions can be found on the [Developer + Support: Xcode](https://developer.apple.com/support/xcode/) page. + ## Field Storage The generated message structs follow one of several different patterns diff --git a/Documentation/PLUGIN.md b/Documentation/PLUGIN.md index 6abb18b5f..d0710f90f 100644 --- a/Documentation/PLUGIN.md +++ b/Documentation/PLUGIN.md @@ -19,9 +19,8 @@ Swift runtime library to your project. To use Swift with Protocol buffers, you'll need: -* A recent Swift 4.0 compiler that includes the Swift Package Manager. - We recommend using the latest release build from - [Swift.org](https://swift.org) or the command-line tools included +* A recent Swift compiler. We recommend using the latest release build + from [Swift.org](https://swift.org) or the command-line tools included with the latest version of Xcode. * Google's protoc compiler. You can get recent versions from @@ -32,26 +31,22 @@ To use Swift with Protocol buffers, you'll need: Building the plugin should be simple on any supported Swift platform: ``` -$ git clone https://github.com/apple/swift-protobuf -$ cd swift-protobuf -$ swift build -c release +git clone https://github.com/apple/swift-protobuf +cd swift-protobuf +swift build -c release ``` This will create a binary called `protoc-gen-swift` in the `.build/release` directory. To install, just copy this one executable anywhere in your PATH. -NOTE: The Swift runtime support is now included with macOS. If you are -using old Xcode versions or are on older system versions, you might need -to use also use `--static-swift-stdlib` with `swift build`. - ### Converting .proto files into Swift To generate Swift output for your .proto files, you run the `protoc` command as usual, using the `--swift_out=` option: ``` -$ protoc --swift_out=. my.proto +protoc --swift_out=. my.proto ``` The `protoc` program will automatically look for `protoc-gen-swift` in your @@ -69,13 +64,13 @@ specific needs. You can use the `--swift_opt` argument to `protoc` to pass options to the Swift code generator as follows: ``` -$ protoc --swift_opt=[NAME]=[VALUE] --swift_out:. foo/bar/*.proto mumble/*.proto +protoc --swift_opt=[NAME]=[VALUE] --swift_out:. foo/bar/*.proto mumble/*.proto ``` If you need to specify multiple options, you can use more than one `--swift_opt` argument: ``` -$ protoc \ +protoc \ --swift_opt=[NAME1]=[VALUE1] \ --swift_opt=[NAME2]=[VALUE2] \ --swift_out=. foo/bar/*.proto mumble/*.proto @@ -96,7 +91,7 @@ supports an option to control the generated file names, the option is given as part of the `--swift_opt` argument like this: ``` -$ protoc --swift_opt=FileNaming=[value] --swift_out=. foo/bar/*.proto mumble/*.proto +protoc --swift_opt=FileNaming=[value] --swift_out=. foo/bar/*.proto mumble/*.proto ``` The possible values for `FileNaming` are: @@ -117,13 +112,15 @@ up with the default (`internal`) access. You can change this with the `Visibility` option: ``` -$ protoc --swift_opt=Visibility=[value] --swift_out=. foo/bar/*.proto mumble/*.proto +protoc --swift_opt=Visibility=[value] --swift_out=. foo/bar/*.proto mumble/*.proto ``` The possible values for `Visibility` are: * `Internal` (default): No visibility is set for the types, so they get the default internal visibility. +* `Package`: The visibility on the types is set to`package` so the types + will be exposed across the whole Swift package they belong to. * `Public`: The visibility on the types is set to `public` so the types will be exposed outside the module they are compiled into. @@ -139,7 +136,7 @@ generation to then `import` the module and scope the types. This option takes the path of a file providing the mapping: ``` -$ protoc --swift_opt=ProtoPathModuleMappings=[path.asciipb] --swift_out=. foo/bar/*.proto +protoc --swift_opt=ProtoPathModuleMappings=[path.asciipb] --swift_out=. foo/bar/*.proto ``` The format of that mapping file is defined in @@ -161,6 +158,50 @@ mapping { The `proto_file_path` values here should match the paths used in the proto file `import` statements. + +##### Generation Option: `ImplementationOnlyImports` - `@_implementationOnly`-annotated imports + +By default, SwiftProtobuf does not annotate any imports with `@_implementationOnly`. +However, in some scenarios, such as when distributing an `XCFramework`, imports +for types used only internally should be annotated as `@_implementationOnly` to +avoid exposing internal symbols to clients. +You can change this with the `ImplementationOnlyImports` option: + +``` +protoc --swift_opt=ImplementationOnlyImports=[value] --swift_out=. foo/bar/*.proto mumble/*.proto +``` + +The possible values for `ImplementationOnlyImports` are: + +* `false` (default): The `@_implementationOnly` annotation will never be used. +* `true`: Imports of internal dependencies and any modules defined in the module +mappings will be annotated as `@_implementationOnly`. + +**Important:** Modules cannot be imported as implementation-only if they're +exposed via public API, so even if `ImplementationOnlyImports` is set to `true`, +this will only work if the `Visibility` is set to `internal`. + + +##### Generation Option: `UseAccessLevelOnImports` - imports preceded by a visibility modifier (`public`, `package`, `internal`) + +The default behavior depends on the Swift version the plugin is compiled with. +For Swift versions below 6.0 the default is `false` and the code generator does not precede any imports with a visibility modifier. +You can change this by explicitly setting the `UseAccessLevelOnImports` option: + +``` +$ protoc --swift_opt=UseAccessLevelOnImports=[value] --swift_out=. foo/bar/*.proto mumble/*.proto +``` + +The possible values for `UseAccessLevelOnImports` are: + +* `false`: Generates plain import directives without a visibility modifier. +* `true`: Imports of internal dependencies and any modules defined in the module +mappings will be preceded by a visibility modifier corresponding to the visibility of the generated types - see `Visibility` option. + +**Important:** It is strongly encouraged to use `internal` imports instead of `@_implementationOnly` imports. +Hence `UseAccessLevelOnImports` and `ImplementationOnlyImports` options exclude each other. + + ### Building your project After copying the `.pb.swift` files into your project, you will need @@ -189,7 +230,5 @@ If you are using Xcode, then you should: * Add the Swift source files generated from your protos directly to your project. -* Clone the SwiftProtobuf package. -* Add the SwiftProtobuf target from the Xcode project from that package to your - project. - +* Add this SwiftPM package as dependency of your Xcode project: + [Apple Docs](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app) diff --git a/Documentation/RELEASING.md b/Documentation/RELEASING.md index 201bb10c1..ac583e60b 100644 --- a/Documentation/RELEASING.md +++ b/Documentation/RELEASING.md @@ -2,7 +2,14 @@ --- -When doing a release: +This document covers two types of releases: + +1. **Swift Protobuf Library Releases** - New versions of the Swift protobuf library itself +2. **Protoc Artifactbundle Releases** - Updates to the bundled protoc compiler when new protoc versions are available + +## Swift Protobuf Library Releases + +When doing a Swift Protobuf library release: 1. Examine what has changed @@ -18,73 +25,122 @@ When doing a release: and include a reference '#XYZ', this tells you what pull request it was part of. This is useful for doing the release notes in the next section. -1. Validate the versions numbers - - 1. Inspect `Sources/SwiftProtobuf/Version.swift` and ensure the number is what you expect for - the next release. +1. Update the version on _main_ - Normally we try to bump _main_ to a new revision after each release, so this number may - be fine, but if this release includes import things (api changes, etc.), it may make sense - to go back and bump the _major_ or _minor_ number instead. If you do need to change the - number: `DevTools/LibraryVersions.py a.b.c`. + ``` + DevTools/LibraryVersions.py [a.b.c] + ``` - 1. Run our tool to ensure the versions are all in sync: + If you aren't sure if `b` or `c`, rather then checking all the _semver_ tags on the + PRs, you can use the [project's releases page](https://github.com/apple/swift-protobuf/releases) + and _Draft a new release_; fill in _99.99_ for that tag, and then click the _Generate + release notes_ button, it will include sections based on the _semver_ tags to indicate + which segment *must* be updated. If you do this *discard* this draft as you don't + actually want to create a _99.99_ release later on. - ``` - $ DevTools/LibraryVersions.py --validate - ``` + _Note:__ `a` is really rare since it is a major version bump usually reserved for + breaking changes as it has a cost on all things that depend on this repo. - This will run silently if everything was ok; if something was wrong, you'll need to figure - out why and get things back in sync. + *Import* Make sure to commit/merge this _main_ on github. 1. Create a release on github Top left of the [project's releases page](https://github.com/apple/swift-protobuf/releases) is _Draft a new release_. - The tag should be `[a.b.c]` where the number *exactly* matches one you examined in - `Sources/SwiftProtobuf/Version.swift`. + The tag should be `[a.b.c]` where the number *exactly* matches one you used in the + previous step (and just committed to the repo). + + For the description click the _Generate release notes_ button. That should do + everything based on the PR descriptions and _semver_ tags in the repo. Just read + though was was generate to see if any tweaks are needed. - For the description call out any major things in that release. Usually a short summary and - then a reference to the pull request for more info is enough. + *Important* Ensure that the `Set as the latest release` is checked. -1. Publish the CocoaPod +1. Publish the `SwiftProtobuf.podspec` - 1. Do a final sanity check that CocoaPods is happy with the release you just made, in the project - directory: + _Note:_ You must be an _owner_ of the pod to do this, see `pod trunk info SwiftProtobuf` + for who are owners. ``` - $ pod spec lint SwiftProtobuf.podspec + pod trunk push SwiftProtobuf.podspec ``` - _Note:_ This uses that local copy of the podspec, but pulls the code off the tag on github. + _Note:_ This uses that local copy of `SwiftProtobuf.podspec`, but checks + against the sources on github. - If this doesn't pass, you have two options: +## Updating Protobuf and Abseil Submodules - - If the problem is just with the `podspec`, you can edit it, and try again. The version of - the podspec in the branch doesn't really matter, so just ensure things get fixed on main - for the future. - - If the problem is within the code, you'll likely need to abandon this release. Fix the - code and start the process over cutting a new tag. +The swift-protobuf repository uses git submodules for protobuf and abseil-cpp dependencies. - 1. Publish the pod: +### Automatic Updates (Recommended) - ``` - $ pod trunk push SwiftProtobuf.podspec - ``` +The repository has an automated workflow that checks for new protobuf releases **every night at 2am UTC**. +When a new release is detected, the workflow will: + +1. Update the protobuf submodule to the latest release tag +2. Determine the required abseil-cpp version from protobuf's `protobuf_deps.bzl` +3. Update the abseil-cpp submodule accordingly +4. Create a pull request with the changes + +The workflow can also be triggered manually from the [Actions tab](https://github.com/apple/swift-protobuf/actions/workflows/update_protobuf.yml). + +**No manual intervention is typically required** - just review and merge the automated PR after CI passes. - _Note:_ This uses that local copy of the podspec. +### Manual Updates (If Needed) -1. Bump the version on _main_ +If you need to update the submodules manually (e.g., to test a pre-release version), follow these steps: - To help tell if someone is using _main_ before it has been cut as a release, go ahead and - bump it to a new revision: +1. **Check for new protobuf releases** + Visit the [protobuf releases page](https://github.com/protocolbuffers/protobuf/releases) + to check if a new version is available. + +1. **Update the protobuf submodule** + + From the repository root, update the protobuf submodule to the latest release tag: + + ```bash + cd Sources/protobuf/protobuf + git fetch --tags + git checkout vX.Y.Z # Replace with the actual release tag, e.g., v29.2 + cd ../../.. + git add Sources/protobuf/protobuf ``` - $ DevTools/LibraryVersions.py [a.b.c] + +1. **Check the abseil-cpp version** + + The protobuf library depends on a specific version of abseil-cpp. Check which version + is required by examining `Sources/protobuf/protobuf/protobuf_deps.bzl`: + + ```bash + grep -A 3 "abseil-cpp" Sources/protobuf/protobuf/protobuf_deps.bzl ``` - Where _c_ is one higher than the release that was just done. + Look for the `commit` field in the abseil-cpp section to find the required commit hash. + +1. **Update the abseil-cpp submodule** - Make sure to commit/merge this _main_ on github. + Update the abseil-cpp submodule to match the version required by protobuf: + + ```bash + cd Sources/protobuf/abseil + git fetch + git checkout # Use the commit from protobuf_deps.bzl + cd ../../.. + git add Sources/protobuf/abseil + ``` + +1. **Create a pull request** + + Commit the submodule updates and create a PR: + + ```bash + git commit -m "Update protobuf submodule to vX.Y.Z and abseil-cpp to " + git push origin + ``` + In the PR description, include: + - The protobuf version being updated to + - The abseil-cpp version/commit being updated to + - Any relevant release notes from the protobuf release diff --git a/Documentation/STYLE_GUIDELINES.md b/Documentation/STYLE_GUIDELINES.md index 6fc9b4350..132d0bc24 100644 --- a/Documentation/STYLE_GUIDELINES.md +++ b/Documentation/STYLE_GUIDELINES.md @@ -17,7 +17,7 @@ a method with a large number of generic types and/or arguments), we suggest two pieces of advice: 1. Look to the - [Swift standard library](https://github.com/apple/swift/tree/main/stdlib/public/core) + [Swift standard library](https://github.com/swiftlang/swift/tree/main/stdlib/public/core) for guidance. 1. Don't fight Xcode's auto-indenting unless doing so would make the formatting look horrible. Xcode has some baked-in assumptions about how diff --git a/FuzzTesting/FailCases/clusterfuzz-testcase-FuzzTextFormat_release-4619956026146816 b/FuzzTesting/FailCases/clusterfuzz-testcase-FuzzTextFormat_release-4619956026146816 new file mode 100644 index 000000000..727fd7cb3 Binary files /dev/null and b/FuzzTesting/FailCases/clusterfuzz-testcase-FuzzTextFormat_release-4619956026146816 differ diff --git a/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzAsyncMessageSequence_debug-5217919734513664 b/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzAsyncMessageSequence_debug-5217919734513664 new file mode 100644 index 000000000..a95e33e09 Binary files /dev/null and b/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzAsyncMessageSequence_debug-5217919734513664 differ diff --git a/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzBinaryDelimited_debug-4802082831204352 b/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzBinaryDelimited_debug-4802082831204352 new file mode 100644 index 000000000..d6a8bf780 --- /dev/null +++ b/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzBinaryDelimited_debug-4802082831204352 @@ -0,0 +1 @@ +? \ No newline at end of file diff --git a/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzBinaryDelimited_debug-5927982738046976 b/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzBinaryDelimited_debug-5927982738046976 new file mode 100644 index 000000000..b8c815dbe --- /dev/null +++ b/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzBinaryDelimited_debug-5927982738046976 @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzBinaryDelimited_release-5166893326794752 b/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzBinaryDelimited_release-5166893326794752 new file mode 100644 index 000000000..b8c815dbe --- /dev/null +++ b/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzBinaryDelimited_release-5166893326794752 @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzJSON_debug-6286338012282880 b/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzJSON_debug-6286338012282880 new file mode 100644 index 000000000..064746ff3 --- /dev/null +++ b/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzJSON_debug-6286338012282880 @@ -0,0 +1 @@ +{"wktTimestamp":"9999-12-31T23:59:60Z"} \ No newline at end of file diff --git a/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzTextFormat_debug-5700784104275968 b/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzTextFormat_debug-5700784104275968 new file mode 100644 index 000000000..d04d44344 Binary files /dev/null and b/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzTextFormat_debug-5700784104275968 differ diff --git a/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzTextFormat_release-4619956026146816 b/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzTextFormat_release-4619956026146816 new file mode 100644 index 000000000..5154a9301 Binary files /dev/null and b/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzTextFormat_release-4619956026146816 differ diff --git a/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzTextFormat_release-5003886170537984 b/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzTextFormat_release-5003886170537984 new file mode 100644 index 000000000..ecff5523a Binary files /dev/null and b/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzTextFormat_release-5003886170537984 differ diff --git a/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzTextFormat_release-6026353006215168 b/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzTextFormat_release-6026353006215168 new file mode 100644 index 000000000..3a3aee802 Binary files /dev/null and b/FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzTextFormat_release-6026353006215168 differ diff --git a/FuzzTesting/FailCases/oom-fb8c6ebb36a5ad53472bc2c006de6e7c6e2d10e3 b/FuzzTesting/FailCases/oom-fb8c6ebb36a5ad53472bc2c006de6e7c6e2d10e3 new file mode 100644 index 000000000..1a491e272 Binary files /dev/null and b/FuzzTesting/FailCases/oom-fb8c6ebb36a5ad53472bc2c006de6e7c6e2d10e3 differ diff --git a/FuzzTesting/FuzzAsyncMessageSequence.dict b/FuzzTesting/FuzzAsyncMessageSequence.dict new file mode 100644 index 000000000..16f421412 --- /dev/null +++ b/FuzzTesting/FuzzAsyncMessageSequence.dict @@ -0,0 +1,410 @@ +# To generate the data set. +# FuzzTesting/make_FuzzBinary_dict Protos/SwiftProtobufTests/fuzz_testing.proto +# Yes, this is the same as FuzzBinary.dict to help guide the contents of the +# messages. + +# Tags for all the fields +"\x51" +"\x5d" +"\x61" +"\x68" +"\x72" +"\x7a" +"\x80\x01" +"\x8b\x01" +"\x8c\x01" +"\x90\x01" +"\x9a\x01" +"\xf8\x01" +"\xfa\x01" +"\x80\x02" +"\x82\x02" +"\x88\x02" +"\x8a\x02" +"\x90\x02" +"\x92\x02" +"\x98\x02" +"\x9a\x02" +"\xa0\x02" +"\xa2\x02" +"\xad\x02" +"\xaa\x02" +"\xb1\x02" +"\xb2\x02" +"\xbd\x02" +"\xba\x02" +"\xc1\x02" +"\xc2\x02" +"\xcd\x02" +"\xca\x02" +"\xd1\x02" +"\xd2\x02" +"\xd8\x02" +"\xda\x02" +"\xe2\x02" +"\xea\x02" +"\xf0\x02" +"\xf2\x02" +"\xfb\x02" +"\xfc\x02" +"\x80\x03" +"\x8a\x03" +"\xe8\x03" +"\xf0\x03" +"\xf8\x03" +"\x80\x04" +"\x88\x04" +"\x90\x04" +"\x9d\x04" +"\xa1\x04" +"\xad\x04" +"\xb1\x04" +"\xbd\x04" +"\xc1\x04" +"\xc8\x04" +"\xd2\x04" +"\xda\x04" +"\xe0\x04" +"\xeb\x04" +"\xec\x04" +"\xf0\x04" +"\xfa\x04" +"\x88\x05" +"\x8a\x05" +"\x90\x05" +"\x92\x05" +"\x98\x05" +"\x9a\x05" +"\xa0\x05" +"\xa2\x05" +"\xa8\x05" +"\xaa\x05" +"\xb0\x05" +"\xb2\x05" +"\xbd\x05" +"\xba\x05" +"\xc1\x05" +"\xc2\x05" +"\xcd\x05" +"\xca\x05" +"\xd1\x05" +"\xd2\x05" +"\xdd\x05" +"\xda\x05" +"\xe1\x05" +"\xe2\x05" +"\xe8\x05" +"\xea\x05" +"\xf0\x05" +"\xf2\x05" +"\xa2\x06" +"\xaa\x06" +"\xb2\x06" +"\xba\x06" +"\xc2\x06" +"\xca\x06" +"\xd2\x06" +"\xda\x06" +"\xe2\x06" +"\xea\x06" +"\xf2\x06" +"\xfa\x06" +"\x82\x07" +"\x8a\x07" +"\x92\x07" +"\x9a\x07" +"\xa2\x07" +"\xaa\x07" +"\xb2\x07" +"\xba\x07" +"\xc2\x07" +"\xca\x07" +"\xd2\x07" +"\xda\x07" +"\xe2\x07" +"\xea\x07" +"\xf2\x07" +"\xfa\x07" +"\x82\x08" +"\x8a\x08" +"\x92\x08" +"\x9a\x08" +"\xa2\x08" +"\xaa\x08" +"\xb2\x08" +"\xba\x08" +"\xc2\x08" +"\xca\x08" +"\xd2\x08" +"\xda\x08" +"\xe2\x08" +"\xea\x08" +"\xf2\x08" +"\xfa\x08" +"\x82\x09" +"\x8a\x09" +"\x92\x09" +"\x9a\x09" +"\xa2\x09" +"\xaa\x09" +"\xb2\x09" +"\xba\x09" +"\xc2\x09" +"\xca\x09" +"\xd2\x09" +"\xda\x09" +"\xe2\x09" +"\xea\x09" +"\xf2\x09" +"\xfa\x09" +"\x82\x0a" +"\x8a\x0a" +"\x92\x0a" +"\x9a\x0a" +"\xa2\x0a" +"\xaa\x0a" +"\xb2\x0a" +"\xba\x0a" +"\xc2\x0a" +"\xca\x0a" +"\xd2\x0a" +"\xda\x0a" +"\xe2\x0a" +"\xea\x0a" +"\xf2\x0a" +"\xfa\x0a" +"\x82\x0b" +"\x8a\x0b" +"\x92\x0b" +"\x9a\x0b" +"\xa2\x0b" +"\xaa\x0b" +"\xb2\x0b" +"\xba\x0b" +"\xc2\x0b" +"\xca\x0b" +"\xd2\x0b" +"\xda\x0b" +"\xe2\x0b" +"\xea\x0b" +"\xf2\x0b" +"\xfa\x0b" +"\x82\x0c" +"\x8a\x0c" +"\x92\x0c" +"\x9a\x0c" +"\xa2\x0c" +"\xaa\x0c" +"\xb2\x0c" +"\xba\x0c" +"\xc2\x0c" +"\xca\x0c" +"\xd2\x0c" +"\xda\x0c" +"\xe2\x0c" +"\xea\x0c" +"\xf2\x0c" +"\xfa\x0c" +"\x82\x0d" +"\x8a\x0d" +"\x92\x0d" +"\x9a\x0d" +"\xa2\x0d" +"\xaa\x0d" +"\xb2\x0d" +"\xba\x0d" +"\xc2\x0d" +"\xca\x0d" +"\xd2\x0d" +"\xda\x0d" +"\xe2\x0d" +"\xea\x0d" +"\xf2\x0d" +"\xfa\x0d" +"\x82\x0e" +"\x8a\x0e" +"\x92\x0e" +"\x9a\x0e" +"\xa2\x0e" +"\xaa\x0e" +"\xb2\x0e" +"\xba\x0e" +"\xc2\x0e" +"\xca\x0e" +"\xd2\x0e" +"\xda\x0e" +"\xe2\x0e" +"\xea\x0e" +"\xf2\x0e" +"\xfa\x0e" +"\x82\x0f" +"\x8a\x0f" +"\x92\x0f" +"\x9a\x0f" +"\xa2\x0f" +"\xaa\x0f" +"\xb2\x0f" +"\xba\x0f" +"\xc2\x0f" +"\xca\x0f" +"\xd2\x0f" +"\xda\x0f" +"\xe2\x0f" +"\xea\x0f" +"\xf2\x0f" +"\xfa\x0f" +"\x82\x10" +"\x8a\x10" +"\x92\x10" +"\x9a\x10" +"\xa2\x10" +"\xaa\x10" +"\xb2\x10" +"\xba\x10" +"\xc2\x10" +"\xca\x10" +"\xd2\x10" +"\xda\x10" +"\xe2\x10" +"\xea\x10" +"\xf2\x10" +"\xfa\x10" +"\x82\x11" +"\x8a\x11" +"\x92\x11" +"\x9a\x11" +"\xa2\x11" +"\xaa\x11" +"\xb2\x11" +"\xba\x11" +"\xc2\x11" +"\xca\x11" +"\xd2\x11" +"\xda\x11" +"\xe2\x11" +"\xea\x11" +"\xf2\x11" +"\xa2\x1f" +"\xaa\x1f" +"\xb2\x1f" +"\xba\x1f" +"\xc2\x1f" +"\xca\x1f" +"\xd2\x1f" +"\xda\x1f" +"\xe2\x1f" +"\xea\x1f" +"\xf2\x1f" +"\xfa\x1f" +"\x82\x20" +"\x8a\x20" +"\x92\x20" +"\x9a\x20" +"\xa2\x20" +"\xaa\x20" +"\xc2\x25" +"\xca\x25" +"\xca\xdf\xf3\x05" +"\x52" +"\x82\x99\xe3\x0f" +"\xa0\x01" +"\xc8\x3e" +"\xd0\x3e" +"\xd8\x3e" +"\xe0\x3e" +"\xe8\x3e" +"\xf0\x3e" +"\xfd\x3e" +"\x81\x3f" +"\x8d\x3f" +"\x91\x3f" +"\x9d\x3f" +"\xa1\x3f" +"\xa8\x3f" +"\xb2\x3f" +"\xba\x3f" +"\xc0\x3f" +"\xcb\x3f" +"\xcc\x3f" +"\xd0\x3f" +"\xda\x3f" +"\xb8\x40" +"\xba\x40" +"\xc0\x40" +"\xc2\x40" +"\xc8\x40" +"\xca\x40" +"\xd0\x40" +"\xd2\x40" +"\xd8\x40" +"\xda\x40" +"\xe0\x40" +"\xe2\x40" +"\xed\x40" +"\xea\x40" +"\xf1\x40" +"\xf2\x40" +"\xfd\x40" +"\xfa\x40" +"\x81\x41" +"\x82\x41" +"\x8d\x41" +"\x8a\x41" +"\x91\x41" +"\x92\x41" +"\x98\x41" +"\x9a\x41" +"\xa2\x41" +"\xaa\x41" +"\xb0\x41" +"\xb2\x41" +"\xbb\x41" +"\xbc\x41" +"\xc0\x41" +"\xca\x41" +"\xa8\x42" +"\xaa\x42" +"\xb0\x42" +"\xb2\x42" +"\xb8\x42" +"\xba\x42" +"\xc0\x42" +"\xc2\x42" +"\xc8\x42" +"\xca\x42" +"\xd0\x42" +"\xd2\x42" +"\xdd\x42" +"\xda\x42" +"\xe1\x42" +"\xe2\x42" +"\xed\x42" +"\xea\x42" +"\xf1\x42" +"\xf2\x42" +"\xfd\x42" +"\xfa\x42" +"\x81\x43" +"\x82\x43" +"\x88\x43" +"\x8a\x43" +"\x90\x43" +"\x92\x43" + +# Include a few example values: +# varint: +"\x00" +"\x88\x27" +"\xd0\x86\x03" +# fixed32: +"\x01\x02\x03\x04" +"\x05\x06\x07\x08" +# fixed64: +"\x01\x02\x03\x04\x05\x06\x07\x08" +"\x01\x02\x03\x04\x50\x60\x70\x80" +# length delimited: +"\x03abc" +"\x071234567" +"\x1aabcdefghijklmnopqrstuvwxyz" +# start/end group just have tags/values after them, no tag specific payload; so +# nothing to provide as an example. diff --git a/FuzzTesting/FuzzBinary.dict b/FuzzTesting/FuzzBinary.dict index 0bc8660d6..ad03e756b 100644 --- a/FuzzTesting/FuzzBinary.dict +++ b/FuzzTesting/FuzzBinary.dict @@ -1,5 +1,5 @@ -# To generate the descriptor set. -# FuzzTesting/make_FuzzBinary_dict Protos/fuzz_testing.proto +# To generate the data set. +# FuzzTesting/make_FuzzBinary_dict Protos/SwiftProtobufTests/fuzz_testing.proto # Tags for all the fields "\x51" @@ -302,6 +302,10 @@ "\xaa\x20" "\xc2\x25" "\xca\x25" +"\xca\xdf\xf3\x05" +"\x52" +"\x82\x99\xe3\x0f" +"\xa0\x01" "\xc8\x3e" "\xd0\x3e" "\xd8\x3e" diff --git a/FuzzTesting/FuzzBinaryDelimited.dict b/FuzzTesting/FuzzBinaryDelimited.dict new file mode 100644 index 000000000..16f421412 --- /dev/null +++ b/FuzzTesting/FuzzBinaryDelimited.dict @@ -0,0 +1,410 @@ +# To generate the data set. +# FuzzTesting/make_FuzzBinary_dict Protos/SwiftProtobufTests/fuzz_testing.proto +# Yes, this is the same as FuzzBinary.dict to help guide the contents of the +# messages. + +# Tags for all the fields +"\x51" +"\x5d" +"\x61" +"\x68" +"\x72" +"\x7a" +"\x80\x01" +"\x8b\x01" +"\x8c\x01" +"\x90\x01" +"\x9a\x01" +"\xf8\x01" +"\xfa\x01" +"\x80\x02" +"\x82\x02" +"\x88\x02" +"\x8a\x02" +"\x90\x02" +"\x92\x02" +"\x98\x02" +"\x9a\x02" +"\xa0\x02" +"\xa2\x02" +"\xad\x02" +"\xaa\x02" +"\xb1\x02" +"\xb2\x02" +"\xbd\x02" +"\xba\x02" +"\xc1\x02" +"\xc2\x02" +"\xcd\x02" +"\xca\x02" +"\xd1\x02" +"\xd2\x02" +"\xd8\x02" +"\xda\x02" +"\xe2\x02" +"\xea\x02" +"\xf0\x02" +"\xf2\x02" +"\xfb\x02" +"\xfc\x02" +"\x80\x03" +"\x8a\x03" +"\xe8\x03" +"\xf0\x03" +"\xf8\x03" +"\x80\x04" +"\x88\x04" +"\x90\x04" +"\x9d\x04" +"\xa1\x04" +"\xad\x04" +"\xb1\x04" +"\xbd\x04" +"\xc1\x04" +"\xc8\x04" +"\xd2\x04" +"\xda\x04" +"\xe0\x04" +"\xeb\x04" +"\xec\x04" +"\xf0\x04" +"\xfa\x04" +"\x88\x05" +"\x8a\x05" +"\x90\x05" +"\x92\x05" +"\x98\x05" +"\x9a\x05" +"\xa0\x05" +"\xa2\x05" +"\xa8\x05" +"\xaa\x05" +"\xb0\x05" +"\xb2\x05" +"\xbd\x05" +"\xba\x05" +"\xc1\x05" +"\xc2\x05" +"\xcd\x05" +"\xca\x05" +"\xd1\x05" +"\xd2\x05" +"\xdd\x05" +"\xda\x05" +"\xe1\x05" +"\xe2\x05" +"\xe8\x05" +"\xea\x05" +"\xf0\x05" +"\xf2\x05" +"\xa2\x06" +"\xaa\x06" +"\xb2\x06" +"\xba\x06" +"\xc2\x06" +"\xca\x06" +"\xd2\x06" +"\xda\x06" +"\xe2\x06" +"\xea\x06" +"\xf2\x06" +"\xfa\x06" +"\x82\x07" +"\x8a\x07" +"\x92\x07" +"\x9a\x07" +"\xa2\x07" +"\xaa\x07" +"\xb2\x07" +"\xba\x07" +"\xc2\x07" +"\xca\x07" +"\xd2\x07" +"\xda\x07" +"\xe2\x07" +"\xea\x07" +"\xf2\x07" +"\xfa\x07" +"\x82\x08" +"\x8a\x08" +"\x92\x08" +"\x9a\x08" +"\xa2\x08" +"\xaa\x08" +"\xb2\x08" +"\xba\x08" +"\xc2\x08" +"\xca\x08" +"\xd2\x08" +"\xda\x08" +"\xe2\x08" +"\xea\x08" +"\xf2\x08" +"\xfa\x08" +"\x82\x09" +"\x8a\x09" +"\x92\x09" +"\x9a\x09" +"\xa2\x09" +"\xaa\x09" +"\xb2\x09" +"\xba\x09" +"\xc2\x09" +"\xca\x09" +"\xd2\x09" +"\xda\x09" +"\xe2\x09" +"\xea\x09" +"\xf2\x09" +"\xfa\x09" +"\x82\x0a" +"\x8a\x0a" +"\x92\x0a" +"\x9a\x0a" +"\xa2\x0a" +"\xaa\x0a" +"\xb2\x0a" +"\xba\x0a" +"\xc2\x0a" +"\xca\x0a" +"\xd2\x0a" +"\xda\x0a" +"\xe2\x0a" +"\xea\x0a" +"\xf2\x0a" +"\xfa\x0a" +"\x82\x0b" +"\x8a\x0b" +"\x92\x0b" +"\x9a\x0b" +"\xa2\x0b" +"\xaa\x0b" +"\xb2\x0b" +"\xba\x0b" +"\xc2\x0b" +"\xca\x0b" +"\xd2\x0b" +"\xda\x0b" +"\xe2\x0b" +"\xea\x0b" +"\xf2\x0b" +"\xfa\x0b" +"\x82\x0c" +"\x8a\x0c" +"\x92\x0c" +"\x9a\x0c" +"\xa2\x0c" +"\xaa\x0c" +"\xb2\x0c" +"\xba\x0c" +"\xc2\x0c" +"\xca\x0c" +"\xd2\x0c" +"\xda\x0c" +"\xe2\x0c" +"\xea\x0c" +"\xf2\x0c" +"\xfa\x0c" +"\x82\x0d" +"\x8a\x0d" +"\x92\x0d" +"\x9a\x0d" +"\xa2\x0d" +"\xaa\x0d" +"\xb2\x0d" +"\xba\x0d" +"\xc2\x0d" +"\xca\x0d" +"\xd2\x0d" +"\xda\x0d" +"\xe2\x0d" +"\xea\x0d" +"\xf2\x0d" +"\xfa\x0d" +"\x82\x0e" +"\x8a\x0e" +"\x92\x0e" +"\x9a\x0e" +"\xa2\x0e" +"\xaa\x0e" +"\xb2\x0e" +"\xba\x0e" +"\xc2\x0e" +"\xca\x0e" +"\xd2\x0e" +"\xda\x0e" +"\xe2\x0e" +"\xea\x0e" +"\xf2\x0e" +"\xfa\x0e" +"\x82\x0f" +"\x8a\x0f" +"\x92\x0f" +"\x9a\x0f" +"\xa2\x0f" +"\xaa\x0f" +"\xb2\x0f" +"\xba\x0f" +"\xc2\x0f" +"\xca\x0f" +"\xd2\x0f" +"\xda\x0f" +"\xe2\x0f" +"\xea\x0f" +"\xf2\x0f" +"\xfa\x0f" +"\x82\x10" +"\x8a\x10" +"\x92\x10" +"\x9a\x10" +"\xa2\x10" +"\xaa\x10" +"\xb2\x10" +"\xba\x10" +"\xc2\x10" +"\xca\x10" +"\xd2\x10" +"\xda\x10" +"\xe2\x10" +"\xea\x10" +"\xf2\x10" +"\xfa\x10" +"\x82\x11" +"\x8a\x11" +"\x92\x11" +"\x9a\x11" +"\xa2\x11" +"\xaa\x11" +"\xb2\x11" +"\xba\x11" +"\xc2\x11" +"\xca\x11" +"\xd2\x11" +"\xda\x11" +"\xe2\x11" +"\xea\x11" +"\xf2\x11" +"\xa2\x1f" +"\xaa\x1f" +"\xb2\x1f" +"\xba\x1f" +"\xc2\x1f" +"\xca\x1f" +"\xd2\x1f" +"\xda\x1f" +"\xe2\x1f" +"\xea\x1f" +"\xf2\x1f" +"\xfa\x1f" +"\x82\x20" +"\x8a\x20" +"\x92\x20" +"\x9a\x20" +"\xa2\x20" +"\xaa\x20" +"\xc2\x25" +"\xca\x25" +"\xca\xdf\xf3\x05" +"\x52" +"\x82\x99\xe3\x0f" +"\xa0\x01" +"\xc8\x3e" +"\xd0\x3e" +"\xd8\x3e" +"\xe0\x3e" +"\xe8\x3e" +"\xf0\x3e" +"\xfd\x3e" +"\x81\x3f" +"\x8d\x3f" +"\x91\x3f" +"\x9d\x3f" +"\xa1\x3f" +"\xa8\x3f" +"\xb2\x3f" +"\xba\x3f" +"\xc0\x3f" +"\xcb\x3f" +"\xcc\x3f" +"\xd0\x3f" +"\xda\x3f" +"\xb8\x40" +"\xba\x40" +"\xc0\x40" +"\xc2\x40" +"\xc8\x40" +"\xca\x40" +"\xd0\x40" +"\xd2\x40" +"\xd8\x40" +"\xda\x40" +"\xe0\x40" +"\xe2\x40" +"\xed\x40" +"\xea\x40" +"\xf1\x40" +"\xf2\x40" +"\xfd\x40" +"\xfa\x40" +"\x81\x41" +"\x82\x41" +"\x8d\x41" +"\x8a\x41" +"\x91\x41" +"\x92\x41" +"\x98\x41" +"\x9a\x41" +"\xa2\x41" +"\xaa\x41" +"\xb0\x41" +"\xb2\x41" +"\xbb\x41" +"\xbc\x41" +"\xc0\x41" +"\xca\x41" +"\xa8\x42" +"\xaa\x42" +"\xb0\x42" +"\xb2\x42" +"\xb8\x42" +"\xba\x42" +"\xc0\x42" +"\xc2\x42" +"\xc8\x42" +"\xca\x42" +"\xd0\x42" +"\xd2\x42" +"\xdd\x42" +"\xda\x42" +"\xe1\x42" +"\xe2\x42" +"\xed\x42" +"\xea\x42" +"\xf1\x42" +"\xf2\x42" +"\xfd\x42" +"\xfa\x42" +"\x81\x43" +"\x82\x43" +"\x88\x43" +"\x8a\x43" +"\x90\x43" +"\x92\x43" + +# Include a few example values: +# varint: +"\x00" +"\x88\x27" +"\xd0\x86\x03" +# fixed32: +"\x01\x02\x03\x04" +"\x05\x06\x07\x08" +# fixed64: +"\x01\x02\x03\x04\x05\x06\x07\x08" +"\x01\x02\x03\x04\x50\x60\x70\x80" +# length delimited: +"\x03abc" +"\x071234567" +"\x1aabcdefghijklmnopqrstuvwxyz" +# start/end group just have tags/values after them, no tag specific payload; so +# nothing to provide as an example. diff --git a/FuzzTesting/FuzzJSON.dict b/FuzzTesting/FuzzJSON.dict index 357dc3f0a..00d975c6d 100644 --- a/FuzzTesting/FuzzJSON.dict +++ b/FuzzTesting/FuzzJSON.dict @@ -1,14 +1,17 @@ # To generate the descriptor set. -# ../protobuf/src/protoc -o ~/fuzz.bin -I Protos Protos/fuzz_testing.proto +# ../protobuf/bazel-bin/protoc -o ~/fuzz.bin -I Protos -I Protos/upstream \ +# SwiftProtobufTests/fuzz_testing.proto # Collect the json_names and make them keys: # cat ~/fuzz.bin \ -# | ../protobuf/src/protoc \ +# | ../protobuf/bazel-bin/protoc \ # --decode=google.protobuf.FileDescriptorSet \ # -I ../protobuf/src \ # ../protobuf/src/google/protobuf/descriptor.proto \ # | sed -n -E 's/ *json_name: "(.*)"/"\\"\1\\":"/p' \ # | sort -u +"\"aString\":" +"\"anInt32\":" "\"groupField\":" "\"key\":" "\"mapBoolAnEnum\":" @@ -198,6 +201,7 @@ "\"mapUint64String\":" "\"mapUint64Uint32\":" "\"mapUint64Uint64\":" +"\"messageSetExtension\":" "\"oneofBool\":" "\"oneofBytes\":" "\"oneofDouble\":" diff --git a/FuzzTesting/FuzzTextFormat.dict b/FuzzTesting/FuzzTextFormat.dict index d7f77fa82..f62e92357 100644 --- a/FuzzTesting/FuzzTextFormat.dict +++ b/FuzzTesting/FuzzTextFormat.dict @@ -1,17 +1,20 @@ # To generate the descriptor set. -# ../protobuf/src/protoc -o ~/fuzz.bin -I Protos Protos/fuzz_testing.proto +# ../protobuf/bazel-bin/protoc -o ~/fuzz.bin -I Protos -I Protos/upstream \ +# SwiftProtobufTests/fuzz_testing.proto # Collect the json_names and make them keys: # cat ~/fuzz.bin \ -# | ../protobuf/src/protoc \ +# | ../protobuf/bazel-bin/protoc \ # --decode=google.protobuf.FileDescriptorSet \ # -I ../protobuf/src \ # ../protobuf/src/google/protobuf/descriptor.proto \ # | sed -n -E 's/^ *name: "(.*_.*)"/"\1:"/p' \ +# | grep -v "fuzz_testing.proto" \ # | sort -u "RepeatedGroup_ext:" "SingularGroup_ext:" -"fuzz_testing.proto:" +"a_string:" +"an_int32:" "group_field:" "map_bool_AnEnum:" "map_bool_Message:" @@ -200,6 +203,7 @@ "map_uint64_string:" "map_uint64_uint32:" "map_uint64_uint64:" +"message_set_extension:" "oneof_bool:" "oneof_bytes:" "oneof_double:" diff --git a/FuzzTesting/Package.swift b/FuzzTesting/Package.swift index 4f88bdede..94718497b 100644 --- a/FuzzTesting/Package.swift +++ b/FuzzTesting/Package.swift @@ -1,25 +1,45 @@ // swift-tools-version:5.3 // The swift-tools-version declares the minimum version of Swift required to build this package. +// **NOTE**: 5.3 due to https://github.com/swiftlang/swift/issues/75800 import PackageDescription let package = Package( name: "FuzzTesting", + platforms: [ + .macOS(.v10_15) + ], dependencies: [ - .package(name: "SwiftProtobuf", path: ".."), + .package(name: "SwiftProtobuf", path: "..") ], targets: [ .target( name: "FuzzCommon", - dependencies: ["SwiftProtobuf"]), + dependencies: ["SwiftProtobuf"] + ), .target( name: "FuzzBinary", - dependencies: ["SwiftProtobuf", "FuzzCommon"]), + dependencies: ["SwiftProtobuf", "FuzzCommon"] + ), + .target( + name: "FuzzBinaryDelimited", + dependencies: ["SwiftProtobuf", "FuzzCommon"] + ), + .target( + name: "FuzzAsyncMessageSequence", + dependencies: ["SwiftProtobuf", "FuzzCommon"] + ), .target( name: "FuzzJSON", - dependencies: ["SwiftProtobuf", "FuzzCommon"]), + dependencies: ["SwiftProtobuf", "FuzzCommon"] + ), .target( name: "FuzzTextFormat", - dependencies: ["SwiftProtobuf", "FuzzCommon"]), + dependencies: ["SwiftProtobuf", "FuzzCommon"] + ), + .testTarget( + name: "FuzzCommonTests", + dependencies: ["FuzzCommon"] + ), ] ) diff --git a/FuzzTesting/Sources/FuzzAsyncMessageSequence/main.swift b/FuzzTesting/Sources/FuzzAsyncMessageSequence/main.swift new file mode 100644 index 000000000..27ccb1a4f --- /dev/null +++ b/FuzzTesting/Sources/FuzzAsyncMessageSequence/main.swift @@ -0,0 +1,54 @@ +// Copyright (c) 2014 - 2024 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +import Foundation +import FuzzCommon +import SwiftProtobuf + +private func asyncByteStream(bytes: UnsafeRawBufferPointer) -> AsyncStream { + AsyncStream(UInt8.self) { continuation in + for i in 0.. CInt { + // No decoding options here, a leading zero is actually valid (zero length message), + // so we rely on the other Binary fuzz tester to test options, and just let this + // one focus on issue around framing of the messages on the stream. + let bytes = UnsafeRawBufferPointer(start: start, count: count) + let asyncBytes = asyncByteStream(bytes: bytes) + let decoding = asyncBytes.binaryProtobufDelimitedMessages( + of: SwiftProtoTesting_Fuzz_Message.self, + extensions: SwiftProtoTesting_Fuzz_FuzzTesting_Extensions + ) + + let semaphore = DispatchSemaphore(value: 0) + Task { + do { + for try await _ in decoding { + // TODO: Test serialization for completeness. + // We could serialize individual messages like this: + // let _: [UInt8] = try! msg.serializedBytes() + // but we don't have a stream writer which is what + // we really want to exercise here. + + // Also, serialization here more than doubles the total + // run time, leading to timeouts for the fuzz tester. :( + } + } catch { + // Error parsing are to be expected since not all input will be well formed. + } + semaphore.signal() + } + semaphore.wait() + return 0 +} diff --git a/FuzzTesting/Sources/FuzzBinary/main.swift b/FuzzTesting/Sources/FuzzBinary/main.swift index 73efb5c93..a442a4ba5 100644 --- a/FuzzTesting/Sources/FuzzBinary/main.swift +++ b/FuzzTesting/Sources/FuzzBinary/main.swift @@ -1,21 +1,32 @@ -import Foundation +// Copyright (c) 2014 - 2024 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- import FuzzCommon +import SwiftProtobuf @_cdecl("LLVMFuzzerTestOneInput") public func FuzzBinary(_ start: UnsafeRawPointer, _ count: Int) -> CInt { - let bytes = UnsafeRawBufferPointer(start: start, count: count) - var msg: Fuzz_Testing_Message? - do { - msg = try Fuzz_Testing_Message( - serializedData: Data(bytes), - extensions: Fuzz_Testing_FuzzTesting_Extensions) - } catch { - // Error parsing are to be expected since not all input will be well formed. - } - // Test serialization for completeness. - // If a message was parsed, it should not fail to serialize, so assert as such. - let _ = try! msg?.serializedData() + guard let (options, bytes) = BinaryDecodingOptions.extractOptions(start, count) else { + return 1 + } + var msg: SwiftProtoTesting_Fuzz_Message? + do { + msg = try SwiftProtoTesting_Fuzz_Message( + serializedBytes: Array(bytes), + extensions: SwiftProtoTesting_Fuzz_FuzzTesting_Extensions, + options: options + ) + } catch { + // Error parsing are to be expected since not all input will be well formed. + } + // Test serialization for completeness. + // If a message was parsed, it should not fail to serialize, so assert as such. + let _: [UInt8]? = try! msg?.serializedBytes() - return 0 + return 0 } diff --git a/FuzzTesting/Sources/FuzzBinaryDelimited/main.swift b/FuzzTesting/Sources/FuzzBinaryDelimited/main.swift new file mode 100644 index 000000000..3fdee5a6a --- /dev/null +++ b/FuzzTesting/Sources/FuzzBinaryDelimited/main.swift @@ -0,0 +1,46 @@ +// Copyright (c) 2014 - 2024 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +import Foundation +import FuzzCommon +import SwiftProtobuf + +@_cdecl("LLVMFuzzerTestOneInput") +public func FuzzDelimited(_ start: UnsafeRawPointer, _ count: Int) -> CInt { + // No decoding options here, a leading zero is actually valid (zero length message), + // so we rely on the other Binary fuzz tester to test options, and just let this + // one focus on issue around framing of the messages on the stream. + let bytes = UnsafeRawBufferPointer(start: start, count: count) + let istream = InputStream(data: Data(bytes)) + istream.open() + while true { + let msg: SwiftProtoTesting_Fuzz_Message? + do { + msg = try BinaryDelimited.parse( + messageType: SwiftProtoTesting_Fuzz_Message.self, + from: istream, + extensions: SwiftProtoTesting_Fuzz_FuzzTesting_Extensions + ) + } catch { + // Error parsing are to be expected since not all input will be well formed. + break + } + // Test serialization for completeness. + // If a message was parsed, it should not fail to serialize, so assert as such. + if let msg = msg { + // Could use one stream for all messages, but since fuzz tests have + // memory limits, attempt to avoid hitting that limit with a new stream + // for each output attempt. + let ostream = OutputStream.toMemory() + ostream.open() + try! BinaryDelimited.serialize(message: msg, to: ostream) + } + } + + return 0 +} diff --git a/FuzzTesting/Sources/FuzzCommon/Options.swift b/FuzzTesting/Sources/FuzzCommon/Options.swift new file mode 100644 index 000000000..c886597a0 --- /dev/null +++ b/FuzzTesting/Sources/FuzzCommon/Options.swift @@ -0,0 +1,146 @@ +// Copyright (c) 2014 - 2024 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +import Foundation +import SwiftProtobuf + +public enum FuzzOption { + case boolean(WritableKeyPath) + case byte(WritableKeyPath, mod: UInt8 = .max) +} + +public protocol SupportsFuzzOptions { + static var fuzzOptionsList: [FuzzOption] { get } + init() +} + +extension SupportsFuzzOptions { + public static func extractOptions( + _ start: UnsafeRawPointer, + _ count: Int + ) -> (Self, UnsafeRawBufferPointer)? { + var start = start + let initialCount = count + var count = count + var options = Self() + let reportInfo = ProcessInfo.processInfo.environment["DUMP_DECODE_INFO"] == "1" + + // No format can start with zero (invalid tag, not really UTF-8), so use that to + // indicate there are decoding options. The one case that can start with a zero + // would be length delimited binary, but since that's a zero length message, we + // can go ahead and use that one also. + guard count >= 2, start.loadUnaligned(as: UInt8.self) == 0 else { + if reportInfo { + print("No options to decode") + } + return (options, UnsafeRawBufferPointer(start: start, count: count)) + } + + // Step over the zero + start += 1 + count -= 1 + + var optionsBits = start.loadUnaligned(as: UInt8.self) + start += 1 + count -= 1 + var bit = 0 + for opt in fuzzOptionsList { + var isSet = optionsBits & (1 << bit) != 0 + if bit == 7 { + // About the use the last bit of this byte, to allow more options in + // the future, use this bit to indicate reading another byte. + guard isSet else { + // No continuation, just return whatever we got. + bit = 8 + break + } + guard count >= 1 else { + return nil // No data left to read bits + } + optionsBits = start.loadUnaligned(as: UInt8.self) + start += 1 + count -= 1 + bit = 0 + isSet = optionsBits & (1 << bit) != 0 + } + + switch opt { + case .boolean(let keypath): + options[keyPath: keypath] = isSet + case .byte(let keypath, let mod): + assert(mod >= 1 && mod <= UInt8.max) + if isSet { + guard count >= 1 else { + return nil // No more bytes to get a value, fail + } + let value = start.loadUnaligned(as: UInt8.self) + start += 1 + count -= 1 + options[keyPath: keypath] = Int(value % mod) + } + } + bit += 1 + } + // Ensure the any remaining bits are zero so they can be used in the future + while bit < 8 { + if optionsBits & (1 << bit) != 0 { + return nil + } + bit += 1 + } + + if reportInfo { + print("\(initialCount - count) bytes consumed off front for options: \(options)") + } + return (options, UnsafeRawBufferPointer(start: start, count: count)) + } + +} + +extension BinaryDecodingOptions: SupportsFuzzOptions { + public static var fuzzOptionsList: [FuzzOption] { + [ + // NOTE: Do not reorder these in the future as it invalidates all + // existing cases. + + // The default depth is 100, so limit outselves to modding by 8 to + // avoid allowing larger depths that could timeout. + .byte(\.messageDepthLimit, mod: 8), + .boolean(\.discardUnknownFields), + ] + } +} + +extension JSONDecodingOptions: SupportsFuzzOptions { + public static var fuzzOptionsList: [FuzzOption] { + [ + // NOTE: Do not reorder these in the future as it invalidates all + // existing cases. + + // The default depth is 100, so limit outselves to modding by 8 to + // avoid allowing larger depths that could timeout. + .byte(\.messageDepthLimit, mod: 8), + .boolean(\.ignoreUnknownFields), + ] + } +} + +extension TextFormatDecodingOptions: SupportsFuzzOptions { + public static var fuzzOptionsList: [FuzzOption] { + [ + // NOTE: Do not reorder these in the future as it invalidates all + // existing cases. + + // The default depth is 100, so limit outselves to modding by 8 to + // avoid allowing larger depths that could timeout. + .byte(\.messageDepthLimit, mod: 8), + .boolean(\.ignoreUnknownFields), + .boolean(\.ignoreUnknownExtensionFields), + ] + } +} diff --git a/FuzzTesting/Sources/FuzzCommon/fuzz_testing.pb.swift b/FuzzTesting/Sources/FuzzCommon/fuzz_testing.pb.swift index 9ebf3ef12..c860cc8c2 100644 --- a/FuzzTesting/Sources/FuzzCommon/fuzz_testing.pb.swift +++ b/FuzzTesting/Sources/FuzzCommon/fuzz_testing.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: fuzz_testing.proto @@ -34,302 +35,274 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -public enum Fuzz_Testing_AnEnum: SwiftProtobuf.Enum { - public typealias RawValue = Int - case zero // = 0 - case one // = 1 - case two // = 2 - case three // = 3 +public enum SwiftProtoTesting_Fuzz_AnEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case zero = 0 + case one = 1 + case two = 2 + case three = 3 public init() { self = .zero } - public init?(rawValue: Int) { - switch rawValue { - case 0: self = .zero - case 1: self = .one - case 2: self = .two - case 3: self = .three - default: return nil - } - } - - public var rawValue: Int { - switch self { - case .zero: return 0 - case .one: return 1 - case .two: return 2 - case .three: return 3 - } - } - -} - -#if swift(>=4.2) - -extension Fuzz_Testing_AnEnum: CaseIterable { - // Support synthesized by the compiler. } -#endif // swift(>=4.2) - -public struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { +public struct SwiftProtoTesting_Fuzz_Message: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { // 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. /// Singular public var singularInt32: Int32 { - get {return _storage._singularInt32 ?? 0} + get {_storage._singularInt32 ?? 0} set {_uniqueStorage()._singularInt32 = newValue} } /// Returns true if `singularInt32` has been explicitly set. - public var hasSingularInt32: Bool {return _storage._singularInt32 != nil} + public var hasSingularInt32: Bool {_storage._singularInt32 != nil} /// Clears the value of `singularInt32`. Subsequent reads from it will return its default value. public mutating func clearSingularInt32() {_uniqueStorage()._singularInt32 = nil} public var singularInt64: Int64 { - get {return _storage._singularInt64 ?? 0} + get {_storage._singularInt64 ?? 0} set {_uniqueStorage()._singularInt64 = newValue} } /// Returns true if `singularInt64` has been explicitly set. - public var hasSingularInt64: Bool {return _storage._singularInt64 != nil} + public var hasSingularInt64: Bool {_storage._singularInt64 != nil} /// Clears the value of `singularInt64`. Subsequent reads from it will return its default value. public mutating func clearSingularInt64() {_uniqueStorage()._singularInt64 = nil} public var singularUint32: UInt32 { - get {return _storage._singularUint32 ?? 0} + get {_storage._singularUint32 ?? 0} set {_uniqueStorage()._singularUint32 = newValue} } /// Returns true if `singularUint32` has been explicitly set. - public var hasSingularUint32: Bool {return _storage._singularUint32 != nil} + public var hasSingularUint32: Bool {_storage._singularUint32 != nil} /// Clears the value of `singularUint32`. Subsequent reads from it will return its default value. public mutating func clearSingularUint32() {_uniqueStorage()._singularUint32 = nil} public var singularUint64: UInt64 { - get {return _storage._singularUint64 ?? 0} + get {_storage._singularUint64 ?? 0} set {_uniqueStorage()._singularUint64 = newValue} } /// Returns true if `singularUint64` has been explicitly set. - public var hasSingularUint64: Bool {return _storage._singularUint64 != nil} + public var hasSingularUint64: Bool {_storage._singularUint64 != nil} /// Clears the value of `singularUint64`. Subsequent reads from it will return its default value. public mutating func clearSingularUint64() {_uniqueStorage()._singularUint64 = nil} public var singularSint32: Int32 { - get {return _storage._singularSint32 ?? 0} + get {_storage._singularSint32 ?? 0} set {_uniqueStorage()._singularSint32 = newValue} } /// Returns true if `singularSint32` has been explicitly set. - public var hasSingularSint32: Bool {return _storage._singularSint32 != nil} + public var hasSingularSint32: Bool {_storage._singularSint32 != nil} /// Clears the value of `singularSint32`. Subsequent reads from it will return its default value. public mutating func clearSingularSint32() {_uniqueStorage()._singularSint32 = nil} public var singularSint64: Int64 { - get {return _storage._singularSint64 ?? 0} + get {_storage._singularSint64 ?? 0} set {_uniqueStorage()._singularSint64 = newValue} } /// Returns true if `singularSint64` has been explicitly set. - public var hasSingularSint64: Bool {return _storage._singularSint64 != nil} + public var hasSingularSint64: Bool {_storage._singularSint64 != nil} /// Clears the value of `singularSint64`. Subsequent reads from it will return its default value. public mutating func clearSingularSint64() {_uniqueStorage()._singularSint64 = nil} public var singularFixed32: UInt32 { - get {return _storage._singularFixed32 ?? 0} + get {_storage._singularFixed32 ?? 0} set {_uniqueStorage()._singularFixed32 = newValue} } /// Returns true if `singularFixed32` has been explicitly set. - public var hasSingularFixed32: Bool {return _storage._singularFixed32 != nil} + public var hasSingularFixed32: Bool {_storage._singularFixed32 != nil} /// Clears the value of `singularFixed32`. Subsequent reads from it will return its default value. public mutating func clearSingularFixed32() {_uniqueStorage()._singularFixed32 = nil} public var singularFixed64: UInt64 { - get {return _storage._singularFixed64 ?? 0} + get {_storage._singularFixed64 ?? 0} set {_uniqueStorage()._singularFixed64 = newValue} } /// Returns true if `singularFixed64` has been explicitly set. - public var hasSingularFixed64: Bool {return _storage._singularFixed64 != nil} + public var hasSingularFixed64: Bool {_storage._singularFixed64 != nil} /// Clears the value of `singularFixed64`. Subsequent reads from it will return its default value. public mutating func clearSingularFixed64() {_uniqueStorage()._singularFixed64 = nil} public var singularSfixed32: Int32 { - get {return _storage._singularSfixed32 ?? 0} + get {_storage._singularSfixed32 ?? 0} set {_uniqueStorage()._singularSfixed32 = newValue} } /// Returns true if `singularSfixed32` has been explicitly set. - public var hasSingularSfixed32: Bool {return _storage._singularSfixed32 != nil} + public var hasSingularSfixed32: Bool {_storage._singularSfixed32 != nil} /// Clears the value of `singularSfixed32`. Subsequent reads from it will return its default value. public mutating func clearSingularSfixed32() {_uniqueStorage()._singularSfixed32 = nil} public var singularSfixed64: Int64 { - get {return _storage._singularSfixed64 ?? 0} + get {_storage._singularSfixed64 ?? 0} set {_uniqueStorage()._singularSfixed64 = newValue} } /// Returns true if `singularSfixed64` has been explicitly set. - public var hasSingularSfixed64: Bool {return _storage._singularSfixed64 != nil} + public var hasSingularSfixed64: Bool {_storage._singularSfixed64 != nil} /// Clears the value of `singularSfixed64`. Subsequent reads from it will return its default value. public mutating func clearSingularSfixed64() {_uniqueStorage()._singularSfixed64 = nil} public var singularFloat: Float { - get {return _storage._singularFloat ?? 0} + get {_storage._singularFloat ?? 0} set {_uniqueStorage()._singularFloat = newValue} } /// Returns true if `singularFloat` has been explicitly set. - public var hasSingularFloat: Bool {return _storage._singularFloat != nil} + public var hasSingularFloat: Bool {_storage._singularFloat != nil} /// Clears the value of `singularFloat`. Subsequent reads from it will return its default value. public mutating func clearSingularFloat() {_uniqueStorage()._singularFloat = nil} public var singularDouble: Double { - get {return _storage._singularDouble ?? 0} + get {_storage._singularDouble ?? 0} set {_uniqueStorage()._singularDouble = newValue} } /// Returns true if `singularDouble` has been explicitly set. - public var hasSingularDouble: Bool {return _storage._singularDouble != nil} + public var hasSingularDouble: Bool {_storage._singularDouble != nil} /// Clears the value of `singularDouble`. Subsequent reads from it will return its default value. public mutating func clearSingularDouble() {_uniqueStorage()._singularDouble = nil} public var singularBool: Bool { - get {return _storage._singularBool ?? false} + get {_storage._singularBool ?? false} set {_uniqueStorage()._singularBool = newValue} } /// Returns true if `singularBool` has been explicitly set. - public var hasSingularBool: Bool {return _storage._singularBool != nil} + public var hasSingularBool: Bool {_storage._singularBool != nil} /// Clears the value of `singularBool`. Subsequent reads from it will return its default value. public mutating func clearSingularBool() {_uniqueStorage()._singularBool = nil} public var singularString: String { - get {return _storage._singularString ?? String()} + get {_storage._singularString ?? String()} set {_uniqueStorage()._singularString = newValue} } /// Returns true if `singularString` has been explicitly set. - public var hasSingularString: Bool {return _storage._singularString != nil} + public var hasSingularString: Bool {_storage._singularString != nil} /// Clears the value of `singularString`. Subsequent reads from it will return its default value. public mutating func clearSingularString() {_uniqueStorage()._singularString = nil} public var singularBytes: Data { - get {return _storage._singularBytes ?? Data()} + get {_storage._singularBytes ?? Data()} set {_uniqueStorage()._singularBytes = newValue} } /// Returns true if `singularBytes` has been explicitly set. - public var hasSingularBytes: Bool {return _storage._singularBytes != nil} + public var hasSingularBytes: Bool {_storage._singularBytes != nil} /// Clears the value of `singularBytes`. Subsequent reads from it will return its default value. public mutating func clearSingularBytes() {_uniqueStorage()._singularBytes = nil} - public var singularEnum: Fuzz_Testing_AnEnum { - get {return _storage._singularEnum ?? .zero} + public var singularEnum: SwiftProtoTesting_Fuzz_AnEnum { + get {_storage._singularEnum ?? .zero} set {_uniqueStorage()._singularEnum = newValue} } /// Returns true if `singularEnum` has been explicitly set. - public var hasSingularEnum: Bool {return _storage._singularEnum != nil} + public var hasSingularEnum: Bool {_storage._singularEnum != nil} /// Clears the value of `singularEnum`. Subsequent reads from it will return its default value. public mutating func clearSingularEnum() {_uniqueStorage()._singularEnum = nil} - public var singularGroup: Fuzz_Testing_Message.SingularGroup { - get {return _storage._singularGroup ?? Fuzz_Testing_Message.SingularGroup()} + public var singularGroup: SwiftProtoTesting_Fuzz_Message.SingularGroup { + get {_storage._singularGroup ?? SwiftProtoTesting_Fuzz_Message.SingularGroup()} set {_uniqueStorage()._singularGroup = newValue} } /// Returns true if `singularGroup` has been explicitly set. - public var hasSingularGroup: Bool {return _storage._singularGroup != nil} + public var hasSingularGroup: Bool {_storage._singularGroup != nil} /// Clears the value of `singularGroup`. Subsequent reads from it will return its default value. public mutating func clearSingularGroup() {_uniqueStorage()._singularGroup = nil} - public var singularMessage: Fuzz_Testing_Message { - get {return _storage._singularMessage ?? Fuzz_Testing_Message()} + public var singularMessage: SwiftProtoTesting_Fuzz_Message { + get {_storage._singularMessage ?? SwiftProtoTesting_Fuzz_Message()} set {_uniqueStorage()._singularMessage = newValue} } /// Returns true if `singularMessage` has been explicitly set. - public var hasSingularMessage: Bool {return _storage._singularMessage != nil} + public var hasSingularMessage: Bool {_storage._singularMessage != nil} /// Clears the value of `singularMessage`. Subsequent reads from it will return its default value. public mutating func clearSingularMessage() {_uniqueStorage()._singularMessage = nil} /// Repeated public var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } public var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } public var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } public var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } public var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } public var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } public var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } public var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } public var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } public var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } public var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } public var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } public var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } public var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } public var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } - public var repeatedEnum: [Fuzz_Testing_AnEnum] { - get {return _storage._repeatedEnum} + public var repeatedEnum: [SwiftProtoTesting_Fuzz_AnEnum] { + get {_storage._repeatedEnum} set {_uniqueStorage()._repeatedEnum = newValue} } - public var repeatedGroup: [Fuzz_Testing_Message.RepeatedGroup] { - get {return _storage._repeatedGroup} + public var repeatedGroup: [SwiftProtoTesting_Fuzz_Message.RepeatedGroup] { + get {_storage._repeatedGroup} set {_uniqueStorage()._repeatedGroup = newValue} } - public var repeatedMessage: [Fuzz_Testing_Message] { - get {return _storage._repeatedMessage} + public var repeatedMessage: [SwiftProtoTesting_Fuzz_Message] { + get {_storage._repeatedMessage} set {_uniqueStorage()._repeatedMessage = newValue} } @@ -459,7 +432,7 @@ public struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { set {_uniqueStorage()._o = .oneofBytes(newValue)} } - public var oneofEnum: Fuzz_Testing_AnEnum { + public var oneofEnum: SwiftProtoTesting_Fuzz_AnEnum { get { if case .oneofEnum(let v)? = _storage._o {return v} return .zero @@ -467,1211 +440,1211 @@ public struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { set {_uniqueStorage()._o = .oneofEnum(newValue)} } - public var oneofGroup: Fuzz_Testing_Message.OneofGroup { + public var oneofGroup: SwiftProtoTesting_Fuzz_Message.OneofGroup { get { if case .oneofGroup(let v)? = _storage._o {return v} - return Fuzz_Testing_Message.OneofGroup() + return SwiftProtoTesting_Fuzz_Message.OneofGroup() } set {_uniqueStorage()._o = .oneofGroup(newValue)} } - public var oneofMessage: Fuzz_Testing_Message { + public var oneofMessage: SwiftProtoTesting_Fuzz_Message { get { if case .oneofMessage(let v)? = _storage._o {return v} - return Fuzz_Testing_Message() + return SwiftProtoTesting_Fuzz_Message() } set {_uniqueStorage()._o = .oneofMessage(newValue)} } /// Repeated Packed public var repeatedPackedInt32: [Int32] { - get {return _storage._repeatedPackedInt32} + get {_storage._repeatedPackedInt32} set {_uniqueStorage()._repeatedPackedInt32 = newValue} } public var repeatedPackedInt64: [Int64] { - get {return _storage._repeatedPackedInt64} + get {_storage._repeatedPackedInt64} set {_uniqueStorage()._repeatedPackedInt64 = newValue} } public var repeatedPackedUint32: [UInt32] { - get {return _storage._repeatedPackedUint32} + get {_storage._repeatedPackedUint32} set {_uniqueStorage()._repeatedPackedUint32 = newValue} } public var repeatedPackedUint64: [UInt64] { - get {return _storage._repeatedPackedUint64} + get {_storage._repeatedPackedUint64} set {_uniqueStorage()._repeatedPackedUint64 = newValue} } public var repeatedPackedSint32: [Int32] { - get {return _storage._repeatedPackedSint32} + get {_storage._repeatedPackedSint32} set {_uniqueStorage()._repeatedPackedSint32 = newValue} } public var repeatedPackedSint64: [Int64] { - get {return _storage._repeatedPackedSint64} + get {_storage._repeatedPackedSint64} set {_uniqueStorage()._repeatedPackedSint64 = newValue} } public var repeatedPackedFixed32: [UInt32] { - get {return _storage._repeatedPackedFixed32} + get {_storage._repeatedPackedFixed32} set {_uniqueStorage()._repeatedPackedFixed32 = newValue} } public var repeatedPackedFixed64: [UInt64] { - get {return _storage._repeatedPackedFixed64} + get {_storage._repeatedPackedFixed64} set {_uniqueStorage()._repeatedPackedFixed64 = newValue} } public var repeatedPackedSfixed32: [Int32] { - get {return _storage._repeatedPackedSfixed32} + get {_storage._repeatedPackedSfixed32} set {_uniqueStorage()._repeatedPackedSfixed32 = newValue} } public var repeatedPackedSfixed64: [Int64] { - get {return _storage._repeatedPackedSfixed64} + get {_storage._repeatedPackedSfixed64} set {_uniqueStorage()._repeatedPackedSfixed64 = newValue} } public var repeatedPackedFloat: [Float] { - get {return _storage._repeatedPackedFloat} + get {_storage._repeatedPackedFloat} set {_uniqueStorage()._repeatedPackedFloat = newValue} } public var repeatedPackedDouble: [Double] { - get {return _storage._repeatedPackedDouble} + get {_storage._repeatedPackedDouble} set {_uniqueStorage()._repeatedPackedDouble = newValue} } public var repeatedPackedBool: [Bool] { - get {return _storage._repeatedPackedBool} + get {_storage._repeatedPackedBool} set {_uniqueStorage()._repeatedPackedBool = newValue} } - public var repeatedPackedEnum: [Fuzz_Testing_AnEnum] { - get {return _storage._repeatedPackedEnum} + public var repeatedPackedEnum: [SwiftProtoTesting_Fuzz_AnEnum] { + get {_storage._repeatedPackedEnum} set {_uniqueStorage()._repeatedPackedEnum = newValue} } /// map<> public var mapInt32Int32: Dictionary { - get {return _storage._mapInt32Int32} + get {_storage._mapInt32Int32} set {_uniqueStorage()._mapInt32Int32 = newValue} } public var mapInt32Int64: Dictionary { - get {return _storage._mapInt32Int64} + get {_storage._mapInt32Int64} set {_uniqueStorage()._mapInt32Int64 = newValue} } public var mapInt32Uint32: Dictionary { - get {return _storage._mapInt32Uint32} + get {_storage._mapInt32Uint32} set {_uniqueStorage()._mapInt32Uint32 = newValue} } public var mapInt32Uint64: Dictionary { - get {return _storage._mapInt32Uint64} + get {_storage._mapInt32Uint64} set {_uniqueStorage()._mapInt32Uint64 = newValue} } public var mapInt32Sint32: Dictionary { - get {return _storage._mapInt32Sint32} + get {_storage._mapInt32Sint32} set {_uniqueStorage()._mapInt32Sint32 = newValue} } public var mapInt32Sint64: Dictionary { - get {return _storage._mapInt32Sint64} + get {_storage._mapInt32Sint64} set {_uniqueStorage()._mapInt32Sint64 = newValue} } public var mapInt32Fixed32: Dictionary { - get {return _storage._mapInt32Fixed32} + get {_storage._mapInt32Fixed32} set {_uniqueStorage()._mapInt32Fixed32 = newValue} } public var mapInt32Fixed64: Dictionary { - get {return _storage._mapInt32Fixed64} + get {_storage._mapInt32Fixed64} set {_uniqueStorage()._mapInt32Fixed64 = newValue} } public var mapInt32Sfixed32: Dictionary { - get {return _storage._mapInt32Sfixed32} + get {_storage._mapInt32Sfixed32} set {_uniqueStorage()._mapInt32Sfixed32 = newValue} } public var mapInt32Sfixed64: Dictionary { - get {return _storage._mapInt32Sfixed64} + get {_storage._mapInt32Sfixed64} set {_uniqueStorage()._mapInt32Sfixed64 = newValue} } public var mapInt32Float: Dictionary { - get {return _storage._mapInt32Float} + get {_storage._mapInt32Float} set {_uniqueStorage()._mapInt32Float = newValue} } public var mapInt32Double: Dictionary { - get {return _storage._mapInt32Double} + get {_storage._mapInt32Double} set {_uniqueStorage()._mapInt32Double = newValue} } public var mapInt32Bool: Dictionary { - get {return _storage._mapInt32Bool} + get {_storage._mapInt32Bool} set {_uniqueStorage()._mapInt32Bool = newValue} } public var mapInt32String: Dictionary { - get {return _storage._mapInt32String} + get {_storage._mapInt32String} set {_uniqueStorage()._mapInt32String = newValue} } public var mapInt32Bytes: Dictionary { - get {return _storage._mapInt32Bytes} + get {_storage._mapInt32Bytes} set {_uniqueStorage()._mapInt32Bytes = newValue} } - public var mapInt32AnEnum: Dictionary { - get {return _storage._mapInt32AnEnum} + public var mapInt32AnEnum: Dictionary { + get {_storage._mapInt32AnEnum} set {_uniqueStorage()._mapInt32AnEnum = newValue} } - public var mapInt32Message: Dictionary { - get {return _storage._mapInt32Message} + public var mapInt32Message: Dictionary { + get {_storage._mapInt32Message} set {_uniqueStorage()._mapInt32Message = newValue} } public var mapInt64Int32: Dictionary { - get {return _storage._mapInt64Int32} + get {_storage._mapInt64Int32} set {_uniqueStorage()._mapInt64Int32 = newValue} } public var mapInt64Int64: Dictionary { - get {return _storage._mapInt64Int64} + get {_storage._mapInt64Int64} set {_uniqueStorage()._mapInt64Int64 = newValue} } public var mapInt64Uint32: Dictionary { - get {return _storage._mapInt64Uint32} + get {_storage._mapInt64Uint32} set {_uniqueStorage()._mapInt64Uint32 = newValue} } public var mapInt64Uint64: Dictionary { - get {return _storage._mapInt64Uint64} + get {_storage._mapInt64Uint64} set {_uniqueStorage()._mapInt64Uint64 = newValue} } public var mapInt64Sint32: Dictionary { - get {return _storage._mapInt64Sint32} + get {_storage._mapInt64Sint32} set {_uniqueStorage()._mapInt64Sint32 = newValue} } public var mapInt64Sint64: Dictionary { - get {return _storage._mapInt64Sint64} + get {_storage._mapInt64Sint64} set {_uniqueStorage()._mapInt64Sint64 = newValue} } public var mapInt64Fixed32: Dictionary { - get {return _storage._mapInt64Fixed32} + get {_storage._mapInt64Fixed32} set {_uniqueStorage()._mapInt64Fixed32 = newValue} } public var mapInt64Fixed64: Dictionary { - get {return _storage._mapInt64Fixed64} + get {_storage._mapInt64Fixed64} set {_uniqueStorage()._mapInt64Fixed64 = newValue} } public var mapInt64Sfixed32: Dictionary { - get {return _storage._mapInt64Sfixed32} + get {_storage._mapInt64Sfixed32} set {_uniqueStorage()._mapInt64Sfixed32 = newValue} } public var mapInt64Sfixed64: Dictionary { - get {return _storage._mapInt64Sfixed64} + get {_storage._mapInt64Sfixed64} set {_uniqueStorage()._mapInt64Sfixed64 = newValue} } public var mapInt64Float: Dictionary { - get {return _storage._mapInt64Float} + get {_storage._mapInt64Float} set {_uniqueStorage()._mapInt64Float = newValue} } public var mapInt64Double: Dictionary { - get {return _storage._mapInt64Double} + get {_storage._mapInt64Double} set {_uniqueStorage()._mapInt64Double = newValue} } public var mapInt64Bool: Dictionary { - get {return _storage._mapInt64Bool} + get {_storage._mapInt64Bool} set {_uniqueStorage()._mapInt64Bool = newValue} } public var mapInt64String: Dictionary { - get {return _storage._mapInt64String} + get {_storage._mapInt64String} set {_uniqueStorage()._mapInt64String = newValue} } public var mapInt64Bytes: Dictionary { - get {return _storage._mapInt64Bytes} + get {_storage._mapInt64Bytes} set {_uniqueStorage()._mapInt64Bytes = newValue} } - public var mapInt64AnEnum: Dictionary { - get {return _storage._mapInt64AnEnum} + public var mapInt64AnEnum: Dictionary { + get {_storage._mapInt64AnEnum} set {_uniqueStorage()._mapInt64AnEnum = newValue} } - public var mapInt64Message: Dictionary { - get {return _storage._mapInt64Message} + public var mapInt64Message: Dictionary { + get {_storage._mapInt64Message} set {_uniqueStorage()._mapInt64Message = newValue} } public var mapUint32Int32: Dictionary { - get {return _storage._mapUint32Int32} + get {_storage._mapUint32Int32} set {_uniqueStorage()._mapUint32Int32 = newValue} } public var mapUint32Int64: Dictionary { - get {return _storage._mapUint32Int64} + get {_storage._mapUint32Int64} set {_uniqueStorage()._mapUint32Int64 = newValue} } public var mapUint32Uint32: Dictionary { - get {return _storage._mapUint32Uint32} + get {_storage._mapUint32Uint32} set {_uniqueStorage()._mapUint32Uint32 = newValue} } public var mapUint32Uint64: Dictionary { - get {return _storage._mapUint32Uint64} + get {_storage._mapUint32Uint64} set {_uniqueStorage()._mapUint32Uint64 = newValue} } public var mapUint32Sint32: Dictionary { - get {return _storage._mapUint32Sint32} + get {_storage._mapUint32Sint32} set {_uniqueStorage()._mapUint32Sint32 = newValue} } public var mapUint32Sint64: Dictionary { - get {return _storage._mapUint32Sint64} + get {_storage._mapUint32Sint64} set {_uniqueStorage()._mapUint32Sint64 = newValue} } public var mapUint32Fixed32: Dictionary { - get {return _storage._mapUint32Fixed32} + get {_storage._mapUint32Fixed32} set {_uniqueStorage()._mapUint32Fixed32 = newValue} } public var mapUint32Fixed64: Dictionary { - get {return _storage._mapUint32Fixed64} + get {_storage._mapUint32Fixed64} set {_uniqueStorage()._mapUint32Fixed64 = newValue} } public var mapUint32Sfixed32: Dictionary { - get {return _storage._mapUint32Sfixed32} + get {_storage._mapUint32Sfixed32} set {_uniqueStorage()._mapUint32Sfixed32 = newValue} } public var mapUint32Sfixed64: Dictionary { - get {return _storage._mapUint32Sfixed64} + get {_storage._mapUint32Sfixed64} set {_uniqueStorage()._mapUint32Sfixed64 = newValue} } public var mapUint32Float: Dictionary { - get {return _storage._mapUint32Float} + get {_storage._mapUint32Float} set {_uniqueStorage()._mapUint32Float = newValue} } public var mapUint32Double: Dictionary { - get {return _storage._mapUint32Double} + get {_storage._mapUint32Double} set {_uniqueStorage()._mapUint32Double = newValue} } public var mapUint32Bool: Dictionary { - get {return _storage._mapUint32Bool} + get {_storage._mapUint32Bool} set {_uniqueStorage()._mapUint32Bool = newValue} } public var mapUint32String: Dictionary { - get {return _storage._mapUint32String} + get {_storage._mapUint32String} set {_uniqueStorage()._mapUint32String = newValue} } public var mapUint32Bytes: Dictionary { - get {return _storage._mapUint32Bytes} + get {_storage._mapUint32Bytes} set {_uniqueStorage()._mapUint32Bytes = newValue} } - public var mapUint32AnEnum: Dictionary { - get {return _storage._mapUint32AnEnum} + public var mapUint32AnEnum: Dictionary { + get {_storage._mapUint32AnEnum} set {_uniqueStorage()._mapUint32AnEnum = newValue} } - public var mapUint32Message: Dictionary { - get {return _storage._mapUint32Message} + public var mapUint32Message: Dictionary { + get {_storage._mapUint32Message} set {_uniqueStorage()._mapUint32Message = newValue} } public var mapUint64Int32: Dictionary { - get {return _storage._mapUint64Int32} + get {_storage._mapUint64Int32} set {_uniqueStorage()._mapUint64Int32 = newValue} } public var mapUint64Int64: Dictionary { - get {return _storage._mapUint64Int64} + get {_storage._mapUint64Int64} set {_uniqueStorage()._mapUint64Int64 = newValue} } public var mapUint64Uint32: Dictionary { - get {return _storage._mapUint64Uint32} + get {_storage._mapUint64Uint32} set {_uniqueStorage()._mapUint64Uint32 = newValue} } public var mapUint64Uint64: Dictionary { - get {return _storage._mapUint64Uint64} + get {_storage._mapUint64Uint64} set {_uniqueStorage()._mapUint64Uint64 = newValue} } public var mapUint64Sint32: Dictionary { - get {return _storage._mapUint64Sint32} + get {_storage._mapUint64Sint32} set {_uniqueStorage()._mapUint64Sint32 = newValue} } public var mapUint64Sint64: Dictionary { - get {return _storage._mapUint64Sint64} + get {_storage._mapUint64Sint64} set {_uniqueStorage()._mapUint64Sint64 = newValue} } public var mapUint64Fixed32: Dictionary { - get {return _storage._mapUint64Fixed32} + get {_storage._mapUint64Fixed32} set {_uniqueStorage()._mapUint64Fixed32 = newValue} } public var mapUint64Fixed64: Dictionary { - get {return _storage._mapUint64Fixed64} + get {_storage._mapUint64Fixed64} set {_uniqueStorage()._mapUint64Fixed64 = newValue} } public var mapUint64Sfixed32: Dictionary { - get {return _storage._mapUint64Sfixed32} + get {_storage._mapUint64Sfixed32} set {_uniqueStorage()._mapUint64Sfixed32 = newValue} } public var mapUint64Sfixed64: Dictionary { - get {return _storage._mapUint64Sfixed64} + get {_storage._mapUint64Sfixed64} set {_uniqueStorage()._mapUint64Sfixed64 = newValue} } public var mapUint64Float: Dictionary { - get {return _storage._mapUint64Float} + get {_storage._mapUint64Float} set {_uniqueStorage()._mapUint64Float = newValue} } public var mapUint64Double: Dictionary { - get {return _storage._mapUint64Double} + get {_storage._mapUint64Double} set {_uniqueStorage()._mapUint64Double = newValue} } public var mapUint64Bool: Dictionary { - get {return _storage._mapUint64Bool} + get {_storage._mapUint64Bool} set {_uniqueStorage()._mapUint64Bool = newValue} } public var mapUint64String: Dictionary { - get {return _storage._mapUint64String} + get {_storage._mapUint64String} set {_uniqueStorage()._mapUint64String = newValue} } public var mapUint64Bytes: Dictionary { - get {return _storage._mapUint64Bytes} + get {_storage._mapUint64Bytes} set {_uniqueStorage()._mapUint64Bytes = newValue} } - public var mapUint64AnEnum: Dictionary { - get {return _storage._mapUint64AnEnum} + public var mapUint64AnEnum: Dictionary { + get {_storage._mapUint64AnEnum} set {_uniqueStorage()._mapUint64AnEnum = newValue} } - public var mapUint64Message: Dictionary { - get {return _storage._mapUint64Message} + public var mapUint64Message: Dictionary { + get {_storage._mapUint64Message} set {_uniqueStorage()._mapUint64Message = newValue} } public var mapSint32Int32: Dictionary { - get {return _storage._mapSint32Int32} + get {_storage._mapSint32Int32} set {_uniqueStorage()._mapSint32Int32 = newValue} } public var mapSint32Int64: Dictionary { - get {return _storage._mapSint32Int64} + get {_storage._mapSint32Int64} set {_uniqueStorage()._mapSint32Int64 = newValue} } public var mapSint32Uint32: Dictionary { - get {return _storage._mapSint32Uint32} + get {_storage._mapSint32Uint32} set {_uniqueStorage()._mapSint32Uint32 = newValue} } public var mapSint32Uint64: Dictionary { - get {return _storage._mapSint32Uint64} + get {_storage._mapSint32Uint64} set {_uniqueStorage()._mapSint32Uint64 = newValue} } public var mapSint32Sint32: Dictionary { - get {return _storage._mapSint32Sint32} + get {_storage._mapSint32Sint32} set {_uniqueStorage()._mapSint32Sint32 = newValue} } public var mapSint32Sint64: Dictionary { - get {return _storage._mapSint32Sint64} + get {_storage._mapSint32Sint64} set {_uniqueStorage()._mapSint32Sint64 = newValue} } public var mapSint32Fixed32: Dictionary { - get {return _storage._mapSint32Fixed32} + get {_storage._mapSint32Fixed32} set {_uniqueStorage()._mapSint32Fixed32 = newValue} } public var mapSint32Fixed64: Dictionary { - get {return _storage._mapSint32Fixed64} + get {_storage._mapSint32Fixed64} set {_uniqueStorage()._mapSint32Fixed64 = newValue} } public var mapSint32Sfixed32: Dictionary { - get {return _storage._mapSint32Sfixed32} + get {_storage._mapSint32Sfixed32} set {_uniqueStorage()._mapSint32Sfixed32 = newValue} } public var mapSint32Sfixed64: Dictionary { - get {return _storage._mapSint32Sfixed64} + get {_storage._mapSint32Sfixed64} set {_uniqueStorage()._mapSint32Sfixed64 = newValue} } public var mapSint32Float: Dictionary { - get {return _storage._mapSint32Float} + get {_storage._mapSint32Float} set {_uniqueStorage()._mapSint32Float = newValue} } public var mapSint32Double: Dictionary { - get {return _storage._mapSint32Double} + get {_storage._mapSint32Double} set {_uniqueStorage()._mapSint32Double = newValue} } public var mapSint32Bool: Dictionary { - get {return _storage._mapSint32Bool} + get {_storage._mapSint32Bool} set {_uniqueStorage()._mapSint32Bool = newValue} } public var mapSint32String: Dictionary { - get {return _storage._mapSint32String} + get {_storage._mapSint32String} set {_uniqueStorage()._mapSint32String = newValue} } public var mapSint32Bytes: Dictionary { - get {return _storage._mapSint32Bytes} + get {_storage._mapSint32Bytes} set {_uniqueStorage()._mapSint32Bytes = newValue} } - public var mapSint32AnEnum: Dictionary { - get {return _storage._mapSint32AnEnum} + public var mapSint32AnEnum: Dictionary { + get {_storage._mapSint32AnEnum} set {_uniqueStorage()._mapSint32AnEnum = newValue} } - public var mapSint32Message: Dictionary { - get {return _storage._mapSint32Message} + public var mapSint32Message: Dictionary { + get {_storage._mapSint32Message} set {_uniqueStorage()._mapSint32Message = newValue} } public var mapSint64Int32: Dictionary { - get {return _storage._mapSint64Int32} + get {_storage._mapSint64Int32} set {_uniqueStorage()._mapSint64Int32 = newValue} } public var mapSint64Int64: Dictionary { - get {return _storage._mapSint64Int64} + get {_storage._mapSint64Int64} set {_uniqueStorage()._mapSint64Int64 = newValue} } public var mapSint64Uint32: Dictionary { - get {return _storage._mapSint64Uint32} + get {_storage._mapSint64Uint32} set {_uniqueStorage()._mapSint64Uint32 = newValue} } public var mapSint64Uint64: Dictionary { - get {return _storage._mapSint64Uint64} + get {_storage._mapSint64Uint64} set {_uniqueStorage()._mapSint64Uint64 = newValue} } public var mapSint64Sint32: Dictionary { - get {return _storage._mapSint64Sint32} + get {_storage._mapSint64Sint32} set {_uniqueStorage()._mapSint64Sint32 = newValue} } public var mapSint64Sint64: Dictionary { - get {return _storage._mapSint64Sint64} + get {_storage._mapSint64Sint64} set {_uniqueStorage()._mapSint64Sint64 = newValue} } public var mapSint64Fixed32: Dictionary { - get {return _storage._mapSint64Fixed32} + get {_storage._mapSint64Fixed32} set {_uniqueStorage()._mapSint64Fixed32 = newValue} } public var mapSint64Fixed64: Dictionary { - get {return _storage._mapSint64Fixed64} + get {_storage._mapSint64Fixed64} set {_uniqueStorage()._mapSint64Fixed64 = newValue} } public var mapSint64Sfixed32: Dictionary { - get {return _storage._mapSint64Sfixed32} + get {_storage._mapSint64Sfixed32} set {_uniqueStorage()._mapSint64Sfixed32 = newValue} } public var mapSint64Sfixed64: Dictionary { - get {return _storage._mapSint64Sfixed64} + get {_storage._mapSint64Sfixed64} set {_uniqueStorage()._mapSint64Sfixed64 = newValue} } public var mapSint64Float: Dictionary { - get {return _storage._mapSint64Float} + get {_storage._mapSint64Float} set {_uniqueStorage()._mapSint64Float = newValue} } public var mapSint64Double: Dictionary { - get {return _storage._mapSint64Double} + get {_storage._mapSint64Double} set {_uniqueStorage()._mapSint64Double = newValue} } public var mapSint64Bool: Dictionary { - get {return _storage._mapSint64Bool} + get {_storage._mapSint64Bool} set {_uniqueStorage()._mapSint64Bool = newValue} } public var mapSint64String: Dictionary { - get {return _storage._mapSint64String} + get {_storage._mapSint64String} set {_uniqueStorage()._mapSint64String = newValue} } public var mapSint64Bytes: Dictionary { - get {return _storage._mapSint64Bytes} + get {_storage._mapSint64Bytes} set {_uniqueStorage()._mapSint64Bytes = newValue} } - public var mapSint64AnEnum: Dictionary { - get {return _storage._mapSint64AnEnum} + public var mapSint64AnEnum: Dictionary { + get {_storage._mapSint64AnEnum} set {_uniqueStorage()._mapSint64AnEnum = newValue} } - public var mapSint64Message: Dictionary { - get {return _storage._mapSint64Message} + public var mapSint64Message: Dictionary { + get {_storage._mapSint64Message} set {_uniqueStorage()._mapSint64Message = newValue} } public var mapFixed32Int32: Dictionary { - get {return _storage._mapFixed32Int32} + get {_storage._mapFixed32Int32} set {_uniqueStorage()._mapFixed32Int32 = newValue} } public var mapFixed32Int64: Dictionary { - get {return _storage._mapFixed32Int64} + get {_storage._mapFixed32Int64} set {_uniqueStorage()._mapFixed32Int64 = newValue} } public var mapFixed32Uint32: Dictionary { - get {return _storage._mapFixed32Uint32} + get {_storage._mapFixed32Uint32} set {_uniqueStorage()._mapFixed32Uint32 = newValue} } public var mapFixed32Uint64: Dictionary { - get {return _storage._mapFixed32Uint64} + get {_storage._mapFixed32Uint64} set {_uniqueStorage()._mapFixed32Uint64 = newValue} } public var mapFixed32Sint32: Dictionary { - get {return _storage._mapFixed32Sint32} + get {_storage._mapFixed32Sint32} set {_uniqueStorage()._mapFixed32Sint32 = newValue} } public var mapFixed32Sint64: Dictionary { - get {return _storage._mapFixed32Sint64} + get {_storage._mapFixed32Sint64} set {_uniqueStorage()._mapFixed32Sint64 = newValue} } public var mapFixed32Fixed32: Dictionary { - get {return _storage._mapFixed32Fixed32} + get {_storage._mapFixed32Fixed32} set {_uniqueStorage()._mapFixed32Fixed32 = newValue} } public var mapFixed32Fixed64: Dictionary { - get {return _storage._mapFixed32Fixed64} + get {_storage._mapFixed32Fixed64} set {_uniqueStorage()._mapFixed32Fixed64 = newValue} } public var mapFixed32Sfixed32: Dictionary { - get {return _storage._mapFixed32Sfixed32} + get {_storage._mapFixed32Sfixed32} set {_uniqueStorage()._mapFixed32Sfixed32 = newValue} } public var mapFixed32Sfixed64: Dictionary { - get {return _storage._mapFixed32Sfixed64} + get {_storage._mapFixed32Sfixed64} set {_uniqueStorage()._mapFixed32Sfixed64 = newValue} } public var mapFixed32Float: Dictionary { - get {return _storage._mapFixed32Float} + get {_storage._mapFixed32Float} set {_uniqueStorage()._mapFixed32Float = newValue} } public var mapFixed32Double: Dictionary { - get {return _storage._mapFixed32Double} + get {_storage._mapFixed32Double} set {_uniqueStorage()._mapFixed32Double = newValue} } public var mapFixed32Bool: Dictionary { - get {return _storage._mapFixed32Bool} + get {_storage._mapFixed32Bool} set {_uniqueStorage()._mapFixed32Bool = newValue} } public var mapFixed32String: Dictionary { - get {return _storage._mapFixed32String} + get {_storage._mapFixed32String} set {_uniqueStorage()._mapFixed32String = newValue} } public var mapFixed32Bytes: Dictionary { - get {return _storage._mapFixed32Bytes} + get {_storage._mapFixed32Bytes} set {_uniqueStorage()._mapFixed32Bytes = newValue} } - public var mapFixed32AnEnum: Dictionary { - get {return _storage._mapFixed32AnEnum} + public var mapFixed32AnEnum: Dictionary { + get {_storage._mapFixed32AnEnum} set {_uniqueStorage()._mapFixed32AnEnum = newValue} } - public var mapFixed32Message: Dictionary { - get {return _storage._mapFixed32Message} + public var mapFixed32Message: Dictionary { + get {_storage._mapFixed32Message} set {_uniqueStorage()._mapFixed32Message = newValue} } public var mapFixed64Int32: Dictionary { - get {return _storage._mapFixed64Int32} + get {_storage._mapFixed64Int32} set {_uniqueStorage()._mapFixed64Int32 = newValue} } public var mapFixed64Int64: Dictionary { - get {return _storage._mapFixed64Int64} + get {_storage._mapFixed64Int64} set {_uniqueStorage()._mapFixed64Int64 = newValue} } public var mapFixed64Uint32: Dictionary { - get {return _storage._mapFixed64Uint32} + get {_storage._mapFixed64Uint32} set {_uniqueStorage()._mapFixed64Uint32 = newValue} } public var mapFixed64Uint64: Dictionary { - get {return _storage._mapFixed64Uint64} + get {_storage._mapFixed64Uint64} set {_uniqueStorage()._mapFixed64Uint64 = newValue} } public var mapFixed64Sint32: Dictionary { - get {return _storage._mapFixed64Sint32} + get {_storage._mapFixed64Sint32} set {_uniqueStorage()._mapFixed64Sint32 = newValue} } public var mapFixed64Sint64: Dictionary { - get {return _storage._mapFixed64Sint64} + get {_storage._mapFixed64Sint64} set {_uniqueStorage()._mapFixed64Sint64 = newValue} } public var mapFixed64Fixed32: Dictionary { - get {return _storage._mapFixed64Fixed32} + get {_storage._mapFixed64Fixed32} set {_uniqueStorage()._mapFixed64Fixed32 = newValue} } public var mapFixed64Fixed64: Dictionary { - get {return _storage._mapFixed64Fixed64} + get {_storage._mapFixed64Fixed64} set {_uniqueStorage()._mapFixed64Fixed64 = newValue} } public var mapFixed64Sfixed32: Dictionary { - get {return _storage._mapFixed64Sfixed32} + get {_storage._mapFixed64Sfixed32} set {_uniqueStorage()._mapFixed64Sfixed32 = newValue} } public var mapFixed64Sfixed64: Dictionary { - get {return _storage._mapFixed64Sfixed64} + get {_storage._mapFixed64Sfixed64} set {_uniqueStorage()._mapFixed64Sfixed64 = newValue} } public var mapFixed64Float: Dictionary { - get {return _storage._mapFixed64Float} + get {_storage._mapFixed64Float} set {_uniqueStorage()._mapFixed64Float = newValue} } public var mapFixed64Double: Dictionary { - get {return _storage._mapFixed64Double} + get {_storage._mapFixed64Double} set {_uniqueStorage()._mapFixed64Double = newValue} } public var mapFixed64Bool: Dictionary { - get {return _storage._mapFixed64Bool} + get {_storage._mapFixed64Bool} set {_uniqueStorage()._mapFixed64Bool = newValue} } public var mapFixed64String: Dictionary { - get {return _storage._mapFixed64String} + get {_storage._mapFixed64String} set {_uniqueStorage()._mapFixed64String = newValue} } public var mapFixed64Bytes: Dictionary { - get {return _storage._mapFixed64Bytes} + get {_storage._mapFixed64Bytes} set {_uniqueStorage()._mapFixed64Bytes = newValue} } - public var mapFixed64AnEnum: Dictionary { - get {return _storage._mapFixed64AnEnum} + public var mapFixed64AnEnum: Dictionary { + get {_storage._mapFixed64AnEnum} set {_uniqueStorage()._mapFixed64AnEnum = newValue} } - public var mapFixed64Message: Dictionary { - get {return _storage._mapFixed64Message} + public var mapFixed64Message: Dictionary { + get {_storage._mapFixed64Message} set {_uniqueStorage()._mapFixed64Message = newValue} } public var mapSfixed32Int32: Dictionary { - get {return _storage._mapSfixed32Int32} + get {_storage._mapSfixed32Int32} set {_uniqueStorage()._mapSfixed32Int32 = newValue} } public var mapSfixed32Int64: Dictionary { - get {return _storage._mapSfixed32Int64} + get {_storage._mapSfixed32Int64} set {_uniqueStorage()._mapSfixed32Int64 = newValue} } public var mapSfixed32Uint32: Dictionary { - get {return _storage._mapSfixed32Uint32} + get {_storage._mapSfixed32Uint32} set {_uniqueStorage()._mapSfixed32Uint32 = newValue} } public var mapSfixed32Uint64: Dictionary { - get {return _storage._mapSfixed32Uint64} + get {_storage._mapSfixed32Uint64} set {_uniqueStorage()._mapSfixed32Uint64 = newValue} } public var mapSfixed32Sint32: Dictionary { - get {return _storage._mapSfixed32Sint32} + get {_storage._mapSfixed32Sint32} set {_uniqueStorage()._mapSfixed32Sint32 = newValue} } public var mapSfixed32Sint64: Dictionary { - get {return _storage._mapSfixed32Sint64} + get {_storage._mapSfixed32Sint64} set {_uniqueStorage()._mapSfixed32Sint64 = newValue} } public var mapSfixed32Fixed32: Dictionary { - get {return _storage._mapSfixed32Fixed32} + get {_storage._mapSfixed32Fixed32} set {_uniqueStorage()._mapSfixed32Fixed32 = newValue} } public var mapSfixed32Fixed64: Dictionary { - get {return _storage._mapSfixed32Fixed64} + get {_storage._mapSfixed32Fixed64} set {_uniqueStorage()._mapSfixed32Fixed64 = newValue} } public var mapSfixed32Sfixed32: Dictionary { - get {return _storage._mapSfixed32Sfixed32} + get {_storage._mapSfixed32Sfixed32} set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} } public var mapSfixed32Sfixed64: Dictionary { - get {return _storage._mapSfixed32Sfixed64} + get {_storage._mapSfixed32Sfixed64} set {_uniqueStorage()._mapSfixed32Sfixed64 = newValue} } public var mapSfixed32Float: Dictionary { - get {return _storage._mapSfixed32Float} + get {_storage._mapSfixed32Float} set {_uniqueStorage()._mapSfixed32Float = newValue} } public var mapSfixed32Double: Dictionary { - get {return _storage._mapSfixed32Double} + get {_storage._mapSfixed32Double} set {_uniqueStorage()._mapSfixed32Double = newValue} } public var mapSfixed32Bool: Dictionary { - get {return _storage._mapSfixed32Bool} + get {_storage._mapSfixed32Bool} set {_uniqueStorage()._mapSfixed32Bool = newValue} } public var mapSfixed32String: Dictionary { - get {return _storage._mapSfixed32String} + get {_storage._mapSfixed32String} set {_uniqueStorage()._mapSfixed32String = newValue} } public var mapSfixed32Bytes: Dictionary { - get {return _storage._mapSfixed32Bytes} + get {_storage._mapSfixed32Bytes} set {_uniqueStorage()._mapSfixed32Bytes = newValue} } - public var mapSfixed32AnEnum: Dictionary { - get {return _storage._mapSfixed32AnEnum} + public var mapSfixed32AnEnum: Dictionary { + get {_storage._mapSfixed32AnEnum} set {_uniqueStorage()._mapSfixed32AnEnum = newValue} } - public var mapSfixed32Message: Dictionary { - get {return _storage._mapSfixed32Message} + public var mapSfixed32Message: Dictionary { + get {_storage._mapSfixed32Message} set {_uniqueStorage()._mapSfixed32Message = newValue} } public var mapSfixed64Int32: Dictionary { - get {return _storage._mapSfixed64Int32} + get {_storage._mapSfixed64Int32} set {_uniqueStorage()._mapSfixed64Int32 = newValue} } public var mapSfixed64Int64: Dictionary { - get {return _storage._mapSfixed64Int64} + get {_storage._mapSfixed64Int64} set {_uniqueStorage()._mapSfixed64Int64 = newValue} } public var mapSfixed64Uint32: Dictionary { - get {return _storage._mapSfixed64Uint32} + get {_storage._mapSfixed64Uint32} set {_uniqueStorage()._mapSfixed64Uint32 = newValue} } public var mapSfixed64Uint64: Dictionary { - get {return _storage._mapSfixed64Uint64} + get {_storage._mapSfixed64Uint64} set {_uniqueStorage()._mapSfixed64Uint64 = newValue} } public var mapSfixed64Sint32: Dictionary { - get {return _storage._mapSfixed64Sint32} + get {_storage._mapSfixed64Sint32} set {_uniqueStorage()._mapSfixed64Sint32 = newValue} } public var mapSfixed64Sint64: Dictionary { - get {return _storage._mapSfixed64Sint64} + get {_storage._mapSfixed64Sint64} set {_uniqueStorage()._mapSfixed64Sint64 = newValue} } public var mapSfixed64Fixed32: Dictionary { - get {return _storage._mapSfixed64Fixed32} + get {_storage._mapSfixed64Fixed32} set {_uniqueStorage()._mapSfixed64Fixed32 = newValue} } public var mapSfixed64Fixed64: Dictionary { - get {return _storage._mapSfixed64Fixed64} + get {_storage._mapSfixed64Fixed64} set {_uniqueStorage()._mapSfixed64Fixed64 = newValue} } public var mapSfixed64Sfixed32: Dictionary { - get {return _storage._mapSfixed64Sfixed32} + get {_storage._mapSfixed64Sfixed32} set {_uniqueStorage()._mapSfixed64Sfixed32 = newValue} } public var mapSfixed64Sfixed64: Dictionary { - get {return _storage._mapSfixed64Sfixed64} + get {_storage._mapSfixed64Sfixed64} set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} } public var mapSfixed64Float: Dictionary { - get {return _storage._mapSfixed64Float} + get {_storage._mapSfixed64Float} set {_uniqueStorage()._mapSfixed64Float = newValue} } public var mapSfixed64Double: Dictionary { - get {return _storage._mapSfixed64Double} + get {_storage._mapSfixed64Double} set {_uniqueStorage()._mapSfixed64Double = newValue} } public var mapSfixed64Bool: Dictionary { - get {return _storage._mapSfixed64Bool} + get {_storage._mapSfixed64Bool} set {_uniqueStorage()._mapSfixed64Bool = newValue} } public var mapSfixed64String: Dictionary { - get {return _storage._mapSfixed64String} + get {_storage._mapSfixed64String} set {_uniqueStorage()._mapSfixed64String = newValue} } public var mapSfixed64Bytes: Dictionary { - get {return _storage._mapSfixed64Bytes} + get {_storage._mapSfixed64Bytes} set {_uniqueStorage()._mapSfixed64Bytes = newValue} } - public var mapSfixed64AnEnum: Dictionary { - get {return _storage._mapSfixed64AnEnum} + public var mapSfixed64AnEnum: Dictionary { + get {_storage._mapSfixed64AnEnum} set {_uniqueStorage()._mapSfixed64AnEnum = newValue} } - public var mapSfixed64Message: Dictionary { - get {return _storage._mapSfixed64Message} + public var mapSfixed64Message: Dictionary { + get {_storage._mapSfixed64Message} set {_uniqueStorage()._mapSfixed64Message = newValue} } public var mapBoolInt32: Dictionary { - get {return _storage._mapBoolInt32} + get {_storage._mapBoolInt32} set {_uniqueStorage()._mapBoolInt32 = newValue} } public var mapBoolInt64: Dictionary { - get {return _storage._mapBoolInt64} + get {_storage._mapBoolInt64} set {_uniqueStorage()._mapBoolInt64 = newValue} } public var mapBoolUint32: Dictionary { - get {return _storage._mapBoolUint32} + get {_storage._mapBoolUint32} set {_uniqueStorage()._mapBoolUint32 = newValue} } public var mapBoolUint64: Dictionary { - get {return _storage._mapBoolUint64} + get {_storage._mapBoolUint64} set {_uniqueStorage()._mapBoolUint64 = newValue} } public var mapBoolSint32: Dictionary { - get {return _storage._mapBoolSint32} + get {_storage._mapBoolSint32} set {_uniqueStorage()._mapBoolSint32 = newValue} } public var mapBoolSint64: Dictionary { - get {return _storage._mapBoolSint64} + get {_storage._mapBoolSint64} set {_uniqueStorage()._mapBoolSint64 = newValue} } public var mapBoolFixed32: Dictionary { - get {return _storage._mapBoolFixed32} + get {_storage._mapBoolFixed32} set {_uniqueStorage()._mapBoolFixed32 = newValue} } public var mapBoolFixed64: Dictionary { - get {return _storage._mapBoolFixed64} + get {_storage._mapBoolFixed64} set {_uniqueStorage()._mapBoolFixed64 = newValue} } public var mapBoolSfixed32: Dictionary { - get {return _storage._mapBoolSfixed32} + get {_storage._mapBoolSfixed32} set {_uniqueStorage()._mapBoolSfixed32 = newValue} } public var mapBoolSfixed64: Dictionary { - get {return _storage._mapBoolSfixed64} + get {_storage._mapBoolSfixed64} set {_uniqueStorage()._mapBoolSfixed64 = newValue} } public var mapBoolFloat: Dictionary { - get {return _storage._mapBoolFloat} + get {_storage._mapBoolFloat} set {_uniqueStorage()._mapBoolFloat = newValue} } public var mapBoolDouble: Dictionary { - get {return _storage._mapBoolDouble} + get {_storage._mapBoolDouble} set {_uniqueStorage()._mapBoolDouble = newValue} } public var mapBoolBool: Dictionary { - get {return _storage._mapBoolBool} + get {_storage._mapBoolBool} set {_uniqueStorage()._mapBoolBool = newValue} } public var mapBoolString: Dictionary { - get {return _storage._mapBoolString} + get {_storage._mapBoolString} set {_uniqueStorage()._mapBoolString = newValue} } public var mapBoolBytes: Dictionary { - get {return _storage._mapBoolBytes} + get {_storage._mapBoolBytes} set {_uniqueStorage()._mapBoolBytes = newValue} } - public var mapBoolAnEnum: Dictionary { - get {return _storage._mapBoolAnEnum} + public var mapBoolAnEnum: Dictionary { + get {_storage._mapBoolAnEnum} set {_uniqueStorage()._mapBoolAnEnum = newValue} } - public var mapBoolMessage: Dictionary { - get {return _storage._mapBoolMessage} + public var mapBoolMessage: Dictionary { + get {_storage._mapBoolMessage} set {_uniqueStorage()._mapBoolMessage = newValue} } /// WKTs since some get special handing in JSON. public var wktAny: SwiftProtobuf.Google_Protobuf_Any { - get {return _storage._wktAny ?? SwiftProtobuf.Google_Protobuf_Any()} + get {_storage._wktAny ?? SwiftProtobuf.Google_Protobuf_Any()} set {_uniqueStorage()._wktAny = newValue} } /// Returns true if `wktAny` has been explicitly set. - public var hasWktAny: Bool {return _storage._wktAny != nil} + public var hasWktAny: Bool {_storage._wktAny != nil} /// Clears the value of `wktAny`. Subsequent reads from it will return its default value. public mutating func clearWktAny() {_uniqueStorage()._wktAny = nil} public var wktApi: SwiftProtobuf.Google_Protobuf_Api { - get {return _storage._wktApi ?? SwiftProtobuf.Google_Protobuf_Api()} + get {_storage._wktApi ?? SwiftProtobuf.Google_Protobuf_Api()} set {_uniqueStorage()._wktApi = newValue} } /// Returns true if `wktApi` has been explicitly set. - public var hasWktApi: Bool {return _storage._wktApi != nil} + public var hasWktApi: Bool {_storage._wktApi != nil} /// Clears the value of `wktApi`. Subsequent reads from it will return its default value. public mutating func clearWktApi() {_uniqueStorage()._wktApi = nil} public var wktDuration: SwiftProtobuf.Google_Protobuf_Duration { - get {return _storage._wktDuration ?? SwiftProtobuf.Google_Protobuf_Duration()} + get {_storage._wktDuration ?? SwiftProtobuf.Google_Protobuf_Duration()} set {_uniqueStorage()._wktDuration = newValue} } /// Returns true if `wktDuration` has been explicitly set. - public var hasWktDuration: Bool {return _storage._wktDuration != nil} + public var hasWktDuration: Bool {_storage._wktDuration != nil} /// Clears the value of `wktDuration`. Subsequent reads from it will return its default value. public mutating func clearWktDuration() {_uniqueStorage()._wktDuration = nil} public var wktEmpty: SwiftProtobuf.Google_Protobuf_Empty { - get {return _storage._wktEmpty ?? SwiftProtobuf.Google_Protobuf_Empty()} + get {_storage._wktEmpty ?? SwiftProtobuf.Google_Protobuf_Empty()} set {_uniqueStorage()._wktEmpty = newValue} } /// Returns true if `wktEmpty` has been explicitly set. - public var hasWktEmpty: Bool {return _storage._wktEmpty != nil} + public var hasWktEmpty: Bool {_storage._wktEmpty != nil} /// Clears the value of `wktEmpty`. Subsequent reads from it will return its default value. public mutating func clearWktEmpty() {_uniqueStorage()._wktEmpty = nil} public var wktFieldMask: SwiftProtobuf.Google_Protobuf_FieldMask { - get {return _storage._wktFieldMask ?? SwiftProtobuf.Google_Protobuf_FieldMask()} + get {_storage._wktFieldMask ?? SwiftProtobuf.Google_Protobuf_FieldMask()} set {_uniqueStorage()._wktFieldMask = newValue} } /// Returns true if `wktFieldMask` has been explicitly set. - public var hasWktFieldMask: Bool {return _storage._wktFieldMask != nil} + public var hasWktFieldMask: Bool {_storage._wktFieldMask != nil} /// Clears the value of `wktFieldMask`. Subsequent reads from it will return its default value. public mutating func clearWktFieldMask() {_uniqueStorage()._wktFieldMask = nil} public var wktSourceContext: SwiftProtobuf.Google_Protobuf_SourceContext { - get {return _storage._wktSourceContext ?? SwiftProtobuf.Google_Protobuf_SourceContext()} + get {_storage._wktSourceContext ?? SwiftProtobuf.Google_Protobuf_SourceContext()} set {_uniqueStorage()._wktSourceContext = newValue} } /// Returns true if `wktSourceContext` has been explicitly set. - public var hasWktSourceContext: Bool {return _storage._wktSourceContext != nil} + public var hasWktSourceContext: Bool {_storage._wktSourceContext != nil} /// Clears the value of `wktSourceContext`. Subsequent reads from it will return its default value. public mutating func clearWktSourceContext() {_uniqueStorage()._wktSourceContext = nil} public var wktStruct: SwiftProtobuf.Google_Protobuf_Struct { - get {return _storage._wktStruct ?? SwiftProtobuf.Google_Protobuf_Struct()} + get {_storage._wktStruct ?? SwiftProtobuf.Google_Protobuf_Struct()} set {_uniqueStorage()._wktStruct = newValue} } /// Returns true if `wktStruct` has been explicitly set. - public var hasWktStruct: Bool {return _storage._wktStruct != nil} + public var hasWktStruct: Bool {_storage._wktStruct != nil} /// Clears the value of `wktStruct`. Subsequent reads from it will return its default value. public mutating func clearWktStruct() {_uniqueStorage()._wktStruct = nil} public var wktTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp { - get {return _storage._wktTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()} + get {_storage._wktTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()} set {_uniqueStorage()._wktTimestamp = newValue} } /// Returns true if `wktTimestamp` has been explicitly set. - public var hasWktTimestamp: Bool {return _storage._wktTimestamp != nil} + public var hasWktTimestamp: Bool {_storage._wktTimestamp != nil} /// Clears the value of `wktTimestamp`. Subsequent reads from it will return its default value. public mutating func clearWktTimestamp() {_uniqueStorage()._wktTimestamp = nil} public var wktType: SwiftProtobuf.Google_Protobuf_Type { - get {return _storage._wktType ?? SwiftProtobuf.Google_Protobuf_Type()} + get {_storage._wktType ?? SwiftProtobuf.Google_Protobuf_Type()} set {_uniqueStorage()._wktType = newValue} } /// Returns true if `wktType` has been explicitly set. - public var hasWktType: Bool {return _storage._wktType != nil} + public var hasWktType: Bool {_storage._wktType != nil} /// Clears the value of `wktType`. Subsequent reads from it will return its default value. public mutating func clearWktType() {_uniqueStorage()._wktType = nil} public var wktDoubleValue: SwiftProtobuf.Google_Protobuf_DoubleValue { - get {return _storage._wktDoubleValue ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} + get {_storage._wktDoubleValue ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} set {_uniqueStorage()._wktDoubleValue = newValue} } /// Returns true if `wktDoubleValue` has been explicitly set. - public var hasWktDoubleValue: Bool {return _storage._wktDoubleValue != nil} + public var hasWktDoubleValue: Bool {_storage._wktDoubleValue != nil} /// Clears the value of `wktDoubleValue`. Subsequent reads from it will return its default value. public mutating func clearWktDoubleValue() {_uniqueStorage()._wktDoubleValue = nil} public var wktFloatValue: SwiftProtobuf.Google_Protobuf_FloatValue { - get {return _storage._wktFloatValue ?? SwiftProtobuf.Google_Protobuf_FloatValue()} + get {_storage._wktFloatValue ?? SwiftProtobuf.Google_Protobuf_FloatValue()} set {_uniqueStorage()._wktFloatValue = newValue} } /// Returns true if `wktFloatValue` has been explicitly set. - public var hasWktFloatValue: Bool {return _storage._wktFloatValue != nil} + public var hasWktFloatValue: Bool {_storage._wktFloatValue != nil} /// Clears the value of `wktFloatValue`. Subsequent reads from it will return its default value. public mutating func clearWktFloatValue() {_uniqueStorage()._wktFloatValue = nil} public var wktInt64Value: SwiftProtobuf.Google_Protobuf_Int64Value { - get {return _storage._wktInt64Value ?? SwiftProtobuf.Google_Protobuf_Int64Value()} + get {_storage._wktInt64Value ?? SwiftProtobuf.Google_Protobuf_Int64Value()} set {_uniqueStorage()._wktInt64Value = newValue} } /// Returns true if `wktInt64Value` has been explicitly set. - public var hasWktInt64Value: Bool {return _storage._wktInt64Value != nil} + public var hasWktInt64Value: Bool {_storage._wktInt64Value != nil} /// Clears the value of `wktInt64Value`. Subsequent reads from it will return its default value. public mutating func clearWktInt64Value() {_uniqueStorage()._wktInt64Value = nil} public var wktUint64Value: SwiftProtobuf.Google_Protobuf_UInt64Value { - get {return _storage._wktUint64Value ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} + get {_storage._wktUint64Value ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} set {_uniqueStorage()._wktUint64Value = newValue} } /// Returns true if `wktUint64Value` has been explicitly set. - public var hasWktUint64Value: Bool {return _storage._wktUint64Value != nil} + public var hasWktUint64Value: Bool {_storage._wktUint64Value != nil} /// Clears the value of `wktUint64Value`. Subsequent reads from it will return its default value. public mutating func clearWktUint64Value() {_uniqueStorage()._wktUint64Value = nil} public var wktInt32Value: SwiftProtobuf.Google_Protobuf_Int32Value { - get {return _storage._wktInt32Value ?? SwiftProtobuf.Google_Protobuf_Int32Value()} + get {_storage._wktInt32Value ?? SwiftProtobuf.Google_Protobuf_Int32Value()} set {_uniqueStorage()._wktInt32Value = newValue} } /// Returns true if `wktInt32Value` has been explicitly set. - public var hasWktInt32Value: Bool {return _storage._wktInt32Value != nil} + public var hasWktInt32Value: Bool {_storage._wktInt32Value != nil} /// Clears the value of `wktInt32Value`. Subsequent reads from it will return its default value. public mutating func clearWktInt32Value() {_uniqueStorage()._wktInt32Value = nil} public var wktUint32Value: SwiftProtobuf.Google_Protobuf_UInt32Value { - get {return _storage._wktUint32Value ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} + get {_storage._wktUint32Value ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} set {_uniqueStorage()._wktUint32Value = newValue} } /// Returns true if `wktUint32Value` has been explicitly set. - public var hasWktUint32Value: Bool {return _storage._wktUint32Value != nil} + public var hasWktUint32Value: Bool {_storage._wktUint32Value != nil} /// Clears the value of `wktUint32Value`. Subsequent reads from it will return its default value. public mutating func clearWktUint32Value() {_uniqueStorage()._wktUint32Value = nil} public var wktBoolValue: SwiftProtobuf.Google_Protobuf_BoolValue { - get {return _storage._wktBoolValue ?? SwiftProtobuf.Google_Protobuf_BoolValue()} + get {_storage._wktBoolValue ?? SwiftProtobuf.Google_Protobuf_BoolValue()} set {_uniqueStorage()._wktBoolValue = newValue} } /// Returns true if `wktBoolValue` has been explicitly set. - public var hasWktBoolValue: Bool {return _storage._wktBoolValue != nil} + public var hasWktBoolValue: Bool {_storage._wktBoolValue != nil} /// Clears the value of `wktBoolValue`. Subsequent reads from it will return its default value. public mutating func clearWktBoolValue() {_uniqueStorage()._wktBoolValue = nil} public var wktStringValue: SwiftProtobuf.Google_Protobuf_StringValue { - get {return _storage._wktStringValue ?? SwiftProtobuf.Google_Protobuf_StringValue()} + get {_storage._wktStringValue ?? SwiftProtobuf.Google_Protobuf_StringValue()} set {_uniqueStorage()._wktStringValue = newValue} } /// Returns true if `wktStringValue` has been explicitly set. - public var hasWktStringValue: Bool {return _storage._wktStringValue != nil} + public var hasWktStringValue: Bool {_storage._wktStringValue != nil} /// Clears the value of `wktStringValue`. Subsequent reads from it will return its default value. public mutating func clearWktStringValue() {_uniqueStorage()._wktStringValue = nil} public var wktBytesValue: SwiftProtobuf.Google_Protobuf_BytesValue { - get {return _storage._wktBytesValue ?? SwiftProtobuf.Google_Protobuf_BytesValue()} + get {_storage._wktBytesValue ?? SwiftProtobuf.Google_Protobuf_BytesValue()} set {_uniqueStorage()._wktBytesValue = newValue} } /// Returns true if `wktBytesValue` has been explicitly set. - public var hasWktBytesValue: Bool {return _storage._wktBytesValue != nil} + public var hasWktBytesValue: Bool {_storage._wktBytesValue != nil} /// Clears the value of `wktBytesValue`. Subsequent reads from it will return its default value. public mutating func clearWktBytesValue() {_uniqueStorage()._wktBytesValue = nil} /// Get some coverage for the special message_set_wire_format. - public var singularMessageSet: Fuzz_Testing_AMessageSetMessage { - get {return _storage._singularMessageSet ?? Fuzz_Testing_AMessageSetMessage()} + public var singularMessageSet: SwiftProtoTesting_Fuzz_AMessageSetMessage { + get {_storage._singularMessageSet ?? SwiftProtoTesting_Fuzz_AMessageSetMessage()} set {_uniqueStorage()._singularMessageSet = newValue} } /// Returns true if `singularMessageSet` has been explicitly set. - public var hasSingularMessageSet: Bool {return _storage._singularMessageSet != nil} + public var hasSingularMessageSet: Bool {_storage._singularMessageSet != nil} /// Clears the value of `singularMessageSet`. Subsequent reads from it will return its default value. public mutating func clearSingularMessageSet() {_uniqueStorage()._singularMessageSet = nil} - public var repeatedMessageSet: [Fuzz_Testing_AMessageSetMessage] { - get {return _storage._repeatedMessageSet} + public var repeatedMessageSet: [SwiftProtoTesting_Fuzz_AMessageSetMessage] { + get {_storage._repeatedMessageSet} set {_uniqueStorage()._repeatedMessageSet = newValue} } public var unknownFields = SwiftProtobuf.UnknownStorage() /// oneof - public enum OneOf_O: Equatable { + public enum OneOf_O: Equatable, Sendable { case oneofInt32(Int32) case oneofInt64(Int64) case oneofUint32(UInt32) @@ -1687,110 +1660,28 @@ public struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { case oneofBool(Bool) case oneofString(String) case oneofBytes(Data) - case oneofEnum(Fuzz_Testing_AnEnum) - case oneofGroup(Fuzz_Testing_Message.OneofGroup) - case oneofMessage(Fuzz_Testing_Message) + case oneofEnum(SwiftProtoTesting_Fuzz_AnEnum) + case oneofGroup(SwiftProtoTesting_Fuzz_Message.OneofGroup) + case oneofMessage(SwiftProtoTesting_Fuzz_Message) fileprivate var isInitialized: Bool { guard case .oneofMessage(let v) = self else {return true} return v.isInitialized } - #if !swift(>=4.1) - public static func ==(lhs: Fuzz_Testing_Message.OneOf_O, rhs: Fuzz_Testing_Message.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 (.oneofInt32, .oneofInt32): return { - guard case .oneofInt32(let l) = lhs, case .oneofInt32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofInt64, .oneofInt64): return { - guard case .oneofInt64(let l) = lhs, case .oneofInt64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint64, .oneofUint64): return { - guard case .oneofUint64(let l) = lhs, case .oneofUint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSint32, .oneofSint32): return { - guard case .oneofSint32(let l) = lhs, case .oneofSint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSint64, .oneofSint64): return { - guard case .oneofSint64(let l) = lhs, case .oneofSint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFixed32, .oneofFixed32): return { - guard case .oneofFixed32(let l) = lhs, case .oneofFixed32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFixed64, .oneofFixed64): return { - guard case .oneofFixed64(let l) = lhs, case .oneofFixed64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSfixed32, .oneofSfixed32): return { - guard case .oneofSfixed32(let l) = lhs, case .oneofSfixed32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSfixed64, .oneofSfixed64): return { - guard case .oneofSfixed64(let l) = lhs, case .oneofSfixed64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFloat, .oneofFloat): return { - guard case .oneofFloat(let l) = lhs, case .oneofFloat(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofDouble, .oneofDouble): return { - guard case .oneofDouble(let l) = lhs, case .oneofDouble(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBool, .oneofBool): return { - guard case .oneofBool(let l) = lhs, case .oneofBool(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofEnum, .oneofEnum): return { - guard case .oneofEnum(let l) = lhs, case .oneofEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofGroup, .oneofGroup): return { - guard case .oneofGroup(let l) = lhs, case .oneofGroup(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofMessage, .oneofMessage): return { - guard case .oneofMessage(let l) = lhs, case .oneofMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - public struct SingularGroup { + public struct SingularGroup: Sendable { // 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. public var groupField: Int32 { - get {return _groupField ?? 0} + get {_groupField ?? 0} set {_groupField = newValue} } /// Returns true if `groupField` has been explicitly set. - public var hasGroupField: Bool {return self._groupField != nil} + public var hasGroupField: Bool {self._groupField != nil} /// Clears the value of `groupField`. Subsequent reads from it will return its default value. public mutating func clearGroupField() {self._groupField = nil} @@ -1801,17 +1692,17 @@ public struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { fileprivate var _groupField: Int32? = nil } - public struct RepeatedGroup { + public struct RepeatedGroup: Sendable { // 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. public var groupField: Int32 { - get {return _groupField ?? 0} + get {_groupField ?? 0} set {_groupField = newValue} } /// Returns true if `groupField` has been explicitly set. - public var hasGroupField: Bool {return self._groupField != nil} + public var hasGroupField: Bool {self._groupField != nil} /// Clears the value of `groupField`. Subsequent reads from it will return its default value. public mutating func clearGroupField() {self._groupField = nil} @@ -1822,17 +1713,17 @@ public struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { fileprivate var _groupField: Int32? = nil } - public struct OneofGroup { + public struct OneofGroup: Sendable { // 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. public var groupField: Int32 { - get {return _groupField ?? 0} + get {_groupField ?? 0} set {_groupField = newValue} } /// Returns true if `groupField` has been explicitly set. - public var hasGroupField: Bool {return self._groupField != nil} + public var hasGroupField: Bool {self._groupField != nil} /// Clears the value of `groupField`. Subsequent reads from it will return its default value. public mutating func clearGroupField() {self._groupField = nil} @@ -1850,7 +1741,7 @@ public struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { } /// A message with message_set_wire_format. -public struct Fuzz_Testing_AMessageSetMessage: SwiftProtobuf.ExtensibleMessage { +public struct SwiftProtoTesting_Fuzz_AMessageSetMessage: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -1862,17 +1753,60 @@ public struct Fuzz_Testing_AMessageSetMessage: SwiftProtobuf.ExtensibleMessage { public var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -public struct Fuzz_Testing_SingularGroup_ext { +/// Two extensions to go with the message_set_wire_format testing. +public struct SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1: Sendable { + // 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. + + public var aString: String { + get {_aString ?? String()} + set {_aString = newValue} + } + /// Returns true if `aString` has been explicitly set. + public var hasAString: Bool {self._aString != nil} + /// Clears the value of `aString`. Subsequent reads from it will return its default value. + public mutating func clearAString() {self._aString = nil} + + public var unknownFields = SwiftProtobuf.UnknownStorage() + + public init() {} + + fileprivate var _aString: String? = nil +} + +public struct SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2: Sendable { + // 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. + + public var anInt32: Int32 { + get {_anInt32 ?? 0} + set {_anInt32 = newValue} + } + /// Returns true if `anInt32` has been explicitly set. + public var hasAnInt32: Bool {self._anInt32 != nil} + /// Clears the value of `anInt32`. Subsequent reads from it will return its default value. + public mutating func clearAnInt32() {self._anInt32 = nil} + + public var unknownFields = SwiftProtobuf.UnknownStorage() + + public init() {} + + fileprivate var _anInt32: Int32? = nil +} + +public struct SwiftProtoTesting_Fuzz_SingularGroup_ext: Sendable { // 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. public var groupField: Int32 { - get {return _groupField ?? 0} + get {_groupField ?? 0} set {_groupField = newValue} } /// Returns true if `groupField` has been explicitly set. - public var hasGroupField: Bool {return self._groupField != nil} + public var hasGroupField: Bool {self._groupField != nil} /// Clears the value of `groupField`. Subsequent reads from it will return its default value. public mutating func clearGroupField() {self._groupField = nil} @@ -1883,17 +1817,17 @@ public struct Fuzz_Testing_SingularGroup_ext { fileprivate var _groupField: Int32? = nil } -public struct Fuzz_Testing_RepeatedGroup_ext { +public struct SwiftProtoTesting_Fuzz_RepeatedGroup_ext: Sendable { // 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. public var groupField: Int32 { - get {return _groupField ?? 0} + get {_groupField ?? 0} set {_groupField = newValue} } /// Returns true if `groupField` has been explicitly set. - public var hasGroupField: Bool {return self._groupField != nil} + public var hasGroupField: Bool {self._groupField != nil} /// Clears the value of `groupField`. Subsequent reads from it will return its default value. public mutating func clearGroupField() {self._groupField = nil} @@ -1904,841 +1838,544 @@ public struct Fuzz_Testing_RepeatedGroup_ext { fileprivate var _groupField: Int32? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension Fuzz_Testing_AnEnum: @unchecked Sendable {} -extension Fuzz_Testing_Message: @unchecked Sendable {} -extension Fuzz_Testing_Message.OneOf_O: @unchecked Sendable {} -extension Fuzz_Testing_Message.SingularGroup: @unchecked Sendable {} -extension Fuzz_Testing_Message.RepeatedGroup: @unchecked Sendable {} -extension Fuzz_Testing_Message.OneofGroup: @unchecked Sendable {} -extension Fuzz_Testing_AMessageSetMessage: @unchecked Sendable {} -extension Fuzz_Testing_SingularGroup_ext: @unchecked Sendable {} -extension Fuzz_Testing_RepeatedGroup_ext: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in fuzz_testing.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 Fuzz_Testing_Message { +extension SwiftProtoTesting_Fuzz_AMessageSetMessage { - /// Singular - public var Fuzz_Testing_singularInt32Ext: Int32 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_int32_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_int32_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1_messageSetExtension: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension) ?? SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1()} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_int32_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension` /// has been explicitly set. - public var hasFuzz_Testing_singularInt32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_int32_ext) + public var hasSwiftProtoTesting_Fuzz_AMessageSetMessageExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_int32_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_singularInt32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_int32_ext) + public mutating func clearSwiftProtoTesting_Fuzz_AMessageSetMessageExtension1_messageSetExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension) } - public var Fuzz_Testing_singularInt64Ext: Int64 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_int64_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_int64_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2_messageSetExtension: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension) ?? SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2()} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_int64_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension` /// has been explicitly set. - public var hasFuzz_Testing_singularInt64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_int64_ext) + public var hasSwiftProtoTesting_Fuzz_AMessageSetMessageExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_int64_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_singularInt64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_int64_ext) + public mutating func clearSwiftProtoTesting_Fuzz_AMessageSetMessageExtension2_messageSetExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension) } +} - public var Fuzz_Testing_singularUint32Ext: UInt32 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint32_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_uint32_ext` - /// has been explicitly set. - public var hasFuzz_Testing_singularUint32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_uint32_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_singularUint32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint32_ext) - } +extension SwiftProtoTesting_Fuzz_Message { - public var Fuzz_Testing_singularUint64Ext: UInt64 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint64_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint64_ext, value: newValue)} + /// Singular + public var SwiftProtoTesting_Fuzz_singularInt32Ext: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_uint64_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext` /// has been explicitly set. - public var hasFuzz_Testing_singularUint64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint64_ext) + public var hasSwiftProtoTesting_Fuzz_singularInt32Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_uint64_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_singularUint64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint64_ext) + public mutating func clearSwiftProtoTesting_Fuzz_singularInt32Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext) } - public var Fuzz_Testing_singularSint32Ext: Int32 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint32_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint32_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_singularInt64Ext: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_sint32_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext` /// has been explicitly set. - public var hasFuzz_Testing_singularSint32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint32_ext) + public var hasSwiftProtoTesting_Fuzz_singularInt64Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_sint32_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_singularSint32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint32_ext) + public mutating func clearSwiftProtoTesting_Fuzz_singularInt64Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext) } - public var Fuzz_Testing_singularSint64Ext: Int64 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint64_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint64_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_singularUint32Ext: UInt32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_sint64_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext` /// has been explicitly set. - public var hasFuzz_Testing_singularSint64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint64_ext) + public var hasSwiftProtoTesting_Fuzz_singularUint32Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_sint64_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_singularSint64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint64_ext) + public mutating func clearSwiftProtoTesting_Fuzz_singularUint32Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext) } - public var Fuzz_Testing_singularFixed32Ext: UInt32 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed32_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed32_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_singularUint64Ext: UInt64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_fixed32_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext` /// has been explicitly set. - public var hasFuzz_Testing_singularFixed32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed32_ext) + public var hasSwiftProtoTesting_Fuzz_singularUint64Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_fixed32_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_singularFixed32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed32_ext) + public mutating func clearSwiftProtoTesting_Fuzz_singularUint64Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext) } - public var Fuzz_Testing_singularFixed64Ext: UInt64 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed64_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed64_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_singularSint32Ext: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_fixed64_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext` /// has been explicitly set. - public var hasFuzz_Testing_singularFixed64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed64_ext) + public var hasSwiftProtoTesting_Fuzz_singularSint32Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_fixed64_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_singularFixed64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed64_ext) + public mutating func clearSwiftProtoTesting_Fuzz_singularSint32Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext) } - public var Fuzz_Testing_singularSfixed32Ext: Int32 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed32_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed32_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_singularSint64Ext: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_sfixed32_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext` /// has been explicitly set. - public var hasFuzz_Testing_singularSfixed32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed32_ext) + public var hasSwiftProtoTesting_Fuzz_singularSint64Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_sfixed32_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_singularSfixed32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed32_ext) + public mutating func clearSwiftProtoTesting_Fuzz_singularSint64Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext) } - public var Fuzz_Testing_singularSfixed64Ext: Int64 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed64_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed64_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_singularFixed32Ext: UInt32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_sfixed64_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext` /// has been explicitly set. - public var hasFuzz_Testing_singularSfixed64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed64_ext) + public var hasSwiftProtoTesting_Fuzz_singularFixed32Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_sfixed64_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_singularSfixed64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed64_ext) + public mutating func clearSwiftProtoTesting_Fuzz_singularFixed32Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext) } - public var Fuzz_Testing_singularFloatExt: Float { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_float_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_float_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_singularFixed64Ext: UInt64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_float_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext` /// has been explicitly set. - public var hasFuzz_Testing_singularFloatExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_float_ext) + public var hasSwiftProtoTesting_Fuzz_singularFixed64Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_float_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_singularFloatExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_float_ext) + public mutating func clearSwiftProtoTesting_Fuzz_singularFixed64Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext) } - public var Fuzz_Testing_singularDoubleExt: Double { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_double_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_double_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_singularSfixed32Ext: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_double_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext` /// has been explicitly set. - public var hasFuzz_Testing_singularDoubleExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_double_ext) + public var hasSwiftProtoTesting_Fuzz_singularSfixed32Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_double_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_singularDoubleExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_double_ext) + public mutating func clearSwiftProtoTesting_Fuzz_singularSfixed32Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext) } - public var Fuzz_Testing_singularBoolExt: Bool { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_bool_ext) ?? false} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_bool_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_singularSfixed64Ext: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_bool_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext` /// has been explicitly set. - public var hasFuzz_Testing_singularBoolExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_bool_ext) + public var hasSwiftProtoTesting_Fuzz_singularSfixed64Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_bool_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_singularBoolExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_bool_ext) + public mutating func clearSwiftProtoTesting_Fuzz_singularSfixed64Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext) } - public var Fuzz_Testing_singularStringExt: String { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_string_ext) ?? String()} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_string_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_singularFloatExt: Float { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_float_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_float_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_string_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_float_ext` /// has been explicitly set. - public var hasFuzz_Testing_singularStringExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_string_ext) + public var hasSwiftProtoTesting_Fuzz_singularFloatExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_float_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_string_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_float_ext`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_singularStringExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_string_ext) + public mutating func clearSwiftProtoTesting_Fuzz_singularFloatExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_float_ext) } - public var Fuzz_Testing_singularBytesExt: Data { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_bytes_ext) ?? Data()} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_bytes_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_singularDoubleExt: Double { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_double_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_double_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_bytes_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_double_ext` /// has been explicitly set. - public var hasFuzz_Testing_singularBytesExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_bytes_ext) + public var hasSwiftProtoTesting_Fuzz_singularDoubleExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_double_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_bytes_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_double_ext`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_singularBytesExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_bytes_ext) + public mutating func clearSwiftProtoTesting_Fuzz_singularDoubleExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_double_ext) } - public var Fuzz_Testing_singularEnumExt: Fuzz_Testing_AnEnum { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_enum_ext) ?? .zero} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_enum_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_singularBoolExt: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_enum_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext` /// has been explicitly set. - public var hasFuzz_Testing_singularEnumExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_enum_ext) + public var hasSwiftProtoTesting_Fuzz_singularBoolExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_enum_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_singularEnumExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_enum_ext) + public mutating func clearSwiftProtoTesting_Fuzz_singularBoolExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext) } - public var Fuzz_Testing_singularGroupExt: Fuzz_Testing_SingularGroup_ext { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_SingularGroup_ext) ?? Fuzz_Testing_SingularGroup_ext()} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_SingularGroup_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_singularStringExt: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_string_ext) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_string_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_SingularGroup_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_string_ext` /// has been explicitly set. - public var hasFuzz_Testing_singularGroupExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_SingularGroup_ext) + public var hasSwiftProtoTesting_Fuzz_singularStringExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_string_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_SingularGroup_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_string_ext`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_singularGroupExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_SingularGroup_ext) + public mutating func clearSwiftProtoTesting_Fuzz_singularStringExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_string_ext) } - public var Fuzz_Testing_singularMessageExt: Fuzz_Testing_Message { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_message_ext) ?? Fuzz_Testing_Message()} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_message_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_singularBytesExt: Data { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext) ?? Data()} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_message_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext` /// has been explicitly set. - public var hasFuzz_Testing_singularMessageExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_message_ext) + public var hasSwiftProtoTesting_Fuzz_singularBytesExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_message_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_singularMessageExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_message_ext) + public mutating func clearSwiftProtoTesting_Fuzz_singularBytesExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext) } - /// Repeated - public var Fuzz_Testing_repeatedInt32Ext: [Int32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int32_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_singularEnumExt: SwiftProtoTesting_Fuzz_AnEnum { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext) ?? .zero} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_int32_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext` /// has been explicitly set. - public var hasFuzz_Testing_repeatedInt32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int32_ext) + public var hasSwiftProtoTesting_Fuzz_singularEnumExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_int32_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedInt32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int32_ext) + public mutating func clearSwiftProtoTesting_Fuzz_singularEnumExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext) } - public var Fuzz_Testing_repeatedInt64Ext: [Int64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int64_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_singularGroupExt: SwiftProtoTesting_Fuzz_SingularGroup_ext { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext) ?? SwiftProtoTesting_Fuzz_SingularGroup_ext()} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_int64_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext` /// has been explicitly set. - public var hasFuzz_Testing_repeatedInt64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int64_ext) + public var hasSwiftProtoTesting_Fuzz_singularGroupExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_int64_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedInt64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int64_ext) + public mutating func clearSwiftProtoTesting_Fuzz_singularGroupExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext) } - public var Fuzz_Testing_repeatedUint32Ext: [UInt32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint32_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_singularMessageExt: SwiftProtoTesting_Fuzz_Message { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_message_ext) ?? SwiftProtoTesting_Fuzz_Message()} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_message_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_uint32_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_message_ext` /// has been explicitly set. - public var hasFuzz_Testing_repeatedUint32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint32_ext) + public var hasSwiftProtoTesting_Fuzz_singularMessageExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_message_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_uint32_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_message_ext`. /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedUint32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint32_ext) + public mutating func clearSwiftProtoTesting_Fuzz_singularMessageExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_message_ext) } - public var Fuzz_Testing_repeatedUint64Ext: [UInt64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_uint64_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedUint64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_uint64_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedUint64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint64_ext) + /// Repeated + public var SwiftProtoTesting_Fuzz_repeatedInt32Ext: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_int32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_int32_ext, value: newValue)} } - public var Fuzz_Testing_repeatedSint32Ext: [Int32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_sint32_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedSint32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_sint32_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedSint32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint32_ext) + public var SwiftProtoTesting_Fuzz_repeatedInt64Ext: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_int64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_int64_ext, value: newValue)} } - public var Fuzz_Testing_repeatedSint64Ext: [Int64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_sint64_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedSint64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_sint64_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedSint64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint64_ext) + public var SwiftProtoTesting_Fuzz_repeatedUint32Ext: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_uint32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_uint32_ext, value: newValue)} } - public var Fuzz_Testing_repeatedFixed32Ext: [UInt32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_fixed32_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedFixed32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_fixed32_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedFixed32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed32_ext) + public var SwiftProtoTesting_Fuzz_repeatedUint64Ext: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_uint64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_uint64_ext, value: newValue)} } - public var Fuzz_Testing_repeatedFixed64Ext: [UInt64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_fixed64_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedFixed64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_fixed64_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedFixed64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed64_ext) + public var SwiftProtoTesting_Fuzz_repeatedSint32Ext: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sint32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sint32_ext, value: newValue)} } - public var Fuzz_Testing_repeatedSfixed32Ext: [Int32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_sfixed32_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedSfixed32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_sfixed32_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedSfixed32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed32_ext) + public var SwiftProtoTesting_Fuzz_repeatedSint64Ext: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sint64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sint64_ext, value: newValue)} } - public var Fuzz_Testing_repeatedSfixed64Ext: [Int64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_sfixed64_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedSfixed64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_sfixed64_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedSfixed64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed64_ext) + public var SwiftProtoTesting_Fuzz_repeatedFixed32Ext: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_fixed32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_fixed32_ext, value: newValue)} } - public var Fuzz_Testing_repeatedFloatExt: [Float] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_float_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_float_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_float_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedFloatExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_float_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_float_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedFloatExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_float_ext) + public var SwiftProtoTesting_Fuzz_repeatedFixed64Ext: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_fixed64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_fixed64_ext, value: newValue)} } - public var Fuzz_Testing_repeatedDoubleExt: [Double] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_double_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_double_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_double_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedDoubleExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_double_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_double_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedDoubleExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_double_ext) + public var SwiftProtoTesting_Fuzz_repeatedSfixed32Ext: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed32_ext, value: newValue)} } - public var Fuzz_Testing_repeatedBoolExt: [Bool] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bool_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bool_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_bool_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedBoolExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bool_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_bool_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedBoolExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bool_ext) + public var SwiftProtoTesting_Fuzz_repeatedSfixed64Ext: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed64_ext, value: newValue)} } - public var Fuzz_Testing_repeatedStringExt: [String] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_string_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_string_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_string_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedStringExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_string_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_string_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedStringExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_string_ext) + public var SwiftProtoTesting_Fuzz_repeatedFloatExt: [Float] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_float_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_float_ext, value: newValue)} } - public var Fuzz_Testing_repeatedBytesExt: [Data] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bytes_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bytes_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_bytes_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedBytesExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bytes_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_bytes_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedBytesExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bytes_ext) + public var SwiftProtoTesting_Fuzz_repeatedDoubleExt: [Double] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_double_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_double_ext, value: newValue)} } - public var Fuzz_Testing_repeatedEnumExt: [Fuzz_Testing_AnEnum] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_enum_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_enum_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_enum_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedEnumExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_enum_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_enum_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedEnumExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_enum_ext) + public var SwiftProtoTesting_Fuzz_repeatedBoolExt: [Bool] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_bool_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_bool_ext, value: newValue)} } - public var Fuzz_Testing_repeatedGroupExt: [Fuzz_Testing_RepeatedGroup_ext] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_RepeatedGroup_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_RepeatedGroup_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_RepeatedGroup_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedGroupExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_RepeatedGroup_ext) + public var SwiftProtoTesting_Fuzz_repeatedStringExt: [String] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_string_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_string_ext, value: newValue)} } - /// Clears the value of extension `Fuzz_Testing_Extensions_RepeatedGroup_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedGroupExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_RepeatedGroup_ext) + + public var SwiftProtoTesting_Fuzz_repeatedBytesExt: [Data] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_bytes_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_bytes_ext, value: newValue)} } - public var Fuzz_Testing_repeatedMessageExt: [Fuzz_Testing_Message] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_message_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_message_ext, value: newValue)} + public var SwiftProtoTesting_Fuzz_repeatedEnumExt: [SwiftProtoTesting_Fuzz_AnEnum] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_enum_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_enum_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_message_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedMessageExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_message_ext) + + public var SwiftProtoTesting_Fuzz_repeatedGroupExt: [SwiftProtoTesting_Fuzz_RepeatedGroup_ext] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_RepeatedGroup_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_RepeatedGroup_ext, value: newValue)} } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_message_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedMessageExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_message_ext) + + public var SwiftProtoTesting_Fuzz_repeatedMessageExt: [SwiftProtoTesting_Fuzz_Message] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_message_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_message_ext, value: newValue)} } /// Repeated Packed - public var Fuzz_Testing_repeatedPackedInt32Ext: [Int32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_int32_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedPackedInt32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_int32_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedPackedInt32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int32_ext) + public var SwiftProtoTesting_Fuzz_repeatedPackedInt32Ext: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int32_ext, value: newValue)} } - public var Fuzz_Testing_repeatedPackedInt64Ext: [Int64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_int64_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedPackedInt64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_int64_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedPackedInt64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int64_ext) + public var SwiftProtoTesting_Fuzz_repeatedPackedInt64Ext: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int64_ext, value: newValue)} } - public var Fuzz_Testing_repeatedPackedUint32Ext: [UInt32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_uint32_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedPackedUint32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_uint32_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedPackedUint32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint32_ext) + public var SwiftProtoTesting_Fuzz_repeatedPackedUint32Ext: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint32_ext, value: newValue)} } - public var Fuzz_Testing_repeatedPackedUint64Ext: [UInt64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_uint64_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedPackedUint64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_uint64_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedPackedUint64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint64_ext) + public var SwiftProtoTesting_Fuzz_repeatedPackedUint64Ext: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint64_ext, value: newValue)} } - public var Fuzz_Testing_repeatedPackedSint32Ext: [Int32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_sint32_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedPackedSint32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_sint32_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedPackedSint32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint32_ext) + public var SwiftProtoTesting_Fuzz_repeatedPackedSint32Ext: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint32_ext, value: newValue)} } - public var Fuzz_Testing_repeatedPackedSint64Ext: [Int64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_sint64_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedPackedSint64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_sint64_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedPackedSint64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint64_ext) + public var SwiftProtoTesting_Fuzz_repeatedPackedSint64Ext: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint64_ext, value: newValue)} } - public var Fuzz_Testing_repeatedPackedFixed32Ext: [UInt32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_fixed32_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedPackedFixed32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_fixed32_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedPackedFixed32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed32_ext) + public var SwiftProtoTesting_Fuzz_repeatedPackedFixed32Ext: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed32_ext, value: newValue)} } - public var Fuzz_Testing_repeatedPackedFixed64Ext: [UInt64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_fixed64_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedPackedFixed64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_fixed64_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedPackedFixed64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed64_ext) + public var SwiftProtoTesting_Fuzz_repeatedPackedFixed64Ext: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed64_ext, value: newValue)} } - public var Fuzz_Testing_repeatedPackedSfixed32Ext: [Int32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedPackedSfixed32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedPackedSfixed32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext) + public var SwiftProtoTesting_Fuzz_repeatedPackedSfixed32Ext: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed32_ext, value: newValue)} } - public var Fuzz_Testing_repeatedPackedSfixed64Ext: [Int64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedPackedSfixed64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedPackedSfixed64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext) + public var SwiftProtoTesting_Fuzz_repeatedPackedSfixed64Ext: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed64_ext, value: newValue)} } - public var Fuzz_Testing_repeatedPackedFloatExt: [Float] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_float_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_float_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_float_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedPackedFloatExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_float_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_float_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedPackedFloatExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_float_ext) + public var SwiftProtoTesting_Fuzz_repeatedPackedFloatExt: [Float] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_float_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_float_ext, value: newValue)} } - public var Fuzz_Testing_repeatedPackedDoubleExt: [Double] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_double_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_double_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_double_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedPackedDoubleExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_double_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_double_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedPackedDoubleExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_double_ext) + public var SwiftProtoTesting_Fuzz_repeatedPackedDoubleExt: [Double] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_double_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_double_ext, value: newValue)} } - public var Fuzz_Testing_repeatedPackedBoolExt: [Bool] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_bool_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_bool_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_bool_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedPackedBoolExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_bool_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_bool_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedPackedBoolExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_bool_ext) + public var SwiftProtoTesting_Fuzz_repeatedPackedBoolExt: [Bool] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_bool_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_bool_ext, value: newValue)} } - public var Fuzz_Testing_repeatedPackedEnumExt: [Fuzz_Testing_AnEnum] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_enum_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_enum_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_enum_ext` - /// has been explicitly set. - public var hasFuzz_Testing_repeatedPackedEnumExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_enum_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_enum_ext`. - /// Subsequent reads from it will return its default value. - public mutating func clearFuzz_Testing_repeatedPackedEnumExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_enum_ext) + public var SwiftProtoTesting_Fuzz_repeatedPackedEnumExt: [SwiftProtoTesting_Fuzz_AnEnum] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_enum_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_enum_ext, value: newValue)} } } -// MARK: - File's ExtensionMap: Fuzz_Testing_FuzzTesting_Extensions +// MARK: - File's ExtensionMap: SwiftProtoTesting_Fuzz_FuzzTesting_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`. -public let Fuzz_Testing_FuzzTesting_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - Fuzz_Testing_Extensions_singular_int32_ext, - Fuzz_Testing_Extensions_singular_int64_ext, - Fuzz_Testing_Extensions_singular_uint32_ext, - Fuzz_Testing_Extensions_singular_uint64_ext, - Fuzz_Testing_Extensions_singular_sint32_ext, - Fuzz_Testing_Extensions_singular_sint64_ext, - Fuzz_Testing_Extensions_singular_fixed32_ext, - Fuzz_Testing_Extensions_singular_fixed64_ext, - Fuzz_Testing_Extensions_singular_sfixed32_ext, - Fuzz_Testing_Extensions_singular_sfixed64_ext, - Fuzz_Testing_Extensions_singular_float_ext, - Fuzz_Testing_Extensions_singular_double_ext, - Fuzz_Testing_Extensions_singular_bool_ext, - Fuzz_Testing_Extensions_singular_string_ext, - Fuzz_Testing_Extensions_singular_bytes_ext, - Fuzz_Testing_Extensions_singular_enum_ext, - Fuzz_Testing_Extensions_SingularGroup_ext, - Fuzz_Testing_Extensions_singular_message_ext, - Fuzz_Testing_Extensions_repeated_int32_ext, - Fuzz_Testing_Extensions_repeated_int64_ext, - Fuzz_Testing_Extensions_repeated_uint32_ext, - Fuzz_Testing_Extensions_repeated_uint64_ext, - Fuzz_Testing_Extensions_repeated_sint32_ext, - Fuzz_Testing_Extensions_repeated_sint64_ext, - Fuzz_Testing_Extensions_repeated_fixed32_ext, - Fuzz_Testing_Extensions_repeated_fixed64_ext, - Fuzz_Testing_Extensions_repeated_sfixed32_ext, - Fuzz_Testing_Extensions_repeated_sfixed64_ext, - Fuzz_Testing_Extensions_repeated_float_ext, - Fuzz_Testing_Extensions_repeated_double_ext, - Fuzz_Testing_Extensions_repeated_bool_ext, - Fuzz_Testing_Extensions_repeated_string_ext, - Fuzz_Testing_Extensions_repeated_bytes_ext, - Fuzz_Testing_Extensions_repeated_enum_ext, - Fuzz_Testing_Extensions_RepeatedGroup_ext, - Fuzz_Testing_Extensions_repeated_message_ext, - Fuzz_Testing_Extensions_repeated_packed_int32_ext, - Fuzz_Testing_Extensions_repeated_packed_int64_ext, - Fuzz_Testing_Extensions_repeated_packed_uint32_ext, - Fuzz_Testing_Extensions_repeated_packed_uint64_ext, - Fuzz_Testing_Extensions_repeated_packed_sint32_ext, - Fuzz_Testing_Extensions_repeated_packed_sint64_ext, - Fuzz_Testing_Extensions_repeated_packed_fixed32_ext, - Fuzz_Testing_Extensions_repeated_packed_fixed64_ext, - Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext, - Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext, - Fuzz_Testing_Extensions_repeated_packed_float_ext, - Fuzz_Testing_Extensions_repeated_packed_double_ext, - Fuzz_Testing_Extensions_repeated_packed_bool_ext, - Fuzz_Testing_Extensions_repeated_packed_enum_ext +public let SwiftProtoTesting_Fuzz_FuzzTesting_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_float_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_double_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_string_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext, + SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_message_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_int32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_int64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_uint32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_uint64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_sint32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_sint64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_fixed32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_fixed64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_float_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_double_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_bool_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_string_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_bytes_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_enum_ext, + SwiftProtoTesting_Fuzz_Extensions_RepeatedGroup_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_message_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_float_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_double_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_bool_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_enum_ext, + SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension, + SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension ] // Extension Objects - The only reason these might be needed is when manually @@ -2746,550 +2383,287 @@ public let Fuzz_Testing_FuzzTesting_Extensions: SwiftProtobuf.SimpleExtensionMap // accessors for the extension fields on the messages directly. /// Singular -public let Fuzz_Testing_Extensions_singular_int32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1001, - fieldName: "fuzz.testing.singular_int32_ext" + fieldName: "swift_proto_testing.fuzz.singular_int32_ext" ) -public let Fuzz_Testing_Extensions_singular_int64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1002, - fieldName: "fuzz.testing.singular_int64_ext" + fieldName: "swift_proto_testing.fuzz.singular_int64_ext" ) -public let Fuzz_Testing_Extensions_singular_uint32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1003, - fieldName: "fuzz.testing.singular_uint32_ext" + fieldName: "swift_proto_testing.fuzz.singular_uint32_ext" ) -public let Fuzz_Testing_Extensions_singular_uint64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1004, - fieldName: "fuzz.testing.singular_uint64_ext" + fieldName: "swift_proto_testing.fuzz.singular_uint64_ext" ) -public let Fuzz_Testing_Extensions_singular_sint32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1005, - fieldName: "fuzz.testing.singular_sint32_ext" + fieldName: "swift_proto_testing.fuzz.singular_sint32_ext" ) -public let Fuzz_Testing_Extensions_singular_sint64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1006, - fieldName: "fuzz.testing.singular_sint64_ext" + fieldName: "swift_proto_testing.fuzz.singular_sint64_ext" ) -public let Fuzz_Testing_Extensions_singular_fixed32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1007, - fieldName: "fuzz.testing.singular_fixed32_ext" + fieldName: "swift_proto_testing.fuzz.singular_fixed32_ext" ) -public let Fuzz_Testing_Extensions_singular_fixed64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1008, - fieldName: "fuzz.testing.singular_fixed64_ext" + fieldName: "swift_proto_testing.fuzz.singular_fixed64_ext" ) -public let Fuzz_Testing_Extensions_singular_sfixed32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1009, - fieldName: "fuzz.testing.singular_sfixed32_ext" + fieldName: "swift_proto_testing.fuzz.singular_sfixed32_ext" ) -public let Fuzz_Testing_Extensions_singular_sfixed64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1010, - fieldName: "fuzz.testing.singular_sfixed64_ext" + fieldName: "swift_proto_testing.fuzz.singular_sfixed64_ext" ) -public let Fuzz_Testing_Extensions_singular_float_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_singular_float_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1011, - fieldName: "fuzz.testing.singular_float_ext" + fieldName: "swift_proto_testing.fuzz.singular_float_ext" ) -public let Fuzz_Testing_Extensions_singular_double_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_singular_double_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1012, - fieldName: "fuzz.testing.singular_double_ext" + fieldName: "swift_proto_testing.fuzz.singular_double_ext" ) -public let Fuzz_Testing_Extensions_singular_bool_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1013, - fieldName: "fuzz.testing.singular_bool_ext" + fieldName: "swift_proto_testing.fuzz.singular_bool_ext" ) -public let Fuzz_Testing_Extensions_singular_string_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_singular_string_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1014, - fieldName: "fuzz.testing.singular_string_ext" + fieldName: "swift_proto_testing.fuzz.singular_string_ext" ) -public let Fuzz_Testing_Extensions_singular_bytes_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1015, - fieldName: "fuzz.testing.singular_bytes_ext" + fieldName: "swift_proto_testing.fuzz.singular_bytes_ext" ) -public let Fuzz_Testing_Extensions_singular_enum_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1016, - fieldName: "fuzz.testing.singular_enum_ext" + fieldName: "swift_proto_testing.fuzz.singular_enum_ext" ) -public let Fuzz_Testing_Extensions_SingularGroup_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1017, - fieldName: "fuzz.testing.singulargroup_ext" + fieldName: "swift_proto_testing.fuzz.singulargroup_ext" ) -public let Fuzz_Testing_Extensions_singular_message_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_singular_message_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1019, - fieldName: "fuzz.testing.singular_message_ext" + fieldName: "swift_proto_testing.fuzz.singular_message_ext" ) /// Repeated -public let Fuzz_Testing_Extensions_repeated_int32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_int32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1031, - fieldName: "fuzz.testing.repeated_int32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_int32_ext" ) -public let Fuzz_Testing_Extensions_repeated_int64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_int64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1032, - fieldName: "fuzz.testing.repeated_int64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_int64_ext" ) -public let Fuzz_Testing_Extensions_repeated_uint32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_uint32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1033, - fieldName: "fuzz.testing.repeated_uint32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_uint32_ext" ) -public let Fuzz_Testing_Extensions_repeated_uint64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_uint64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1034, - fieldName: "fuzz.testing.repeated_uint64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_uint64_ext" ) -public let Fuzz_Testing_Extensions_repeated_sint32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_sint32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1035, - fieldName: "fuzz.testing.repeated_sint32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_sint32_ext" ) -public let Fuzz_Testing_Extensions_repeated_sint64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_sint64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1036, - fieldName: "fuzz.testing.repeated_sint64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_sint64_ext" ) -public let Fuzz_Testing_Extensions_repeated_fixed32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_fixed32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1037, - fieldName: "fuzz.testing.repeated_fixed32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_fixed32_ext" ) -public let Fuzz_Testing_Extensions_repeated_fixed64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_fixed64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1038, - fieldName: "fuzz.testing.repeated_fixed64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_fixed64_ext" ) -public let Fuzz_Testing_Extensions_repeated_sfixed32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1039, - fieldName: "fuzz.testing.repeated_sfixed32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_sfixed32_ext" ) -public let Fuzz_Testing_Extensions_repeated_sfixed64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1040, - fieldName: "fuzz.testing.repeated_sfixed64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_sfixed64_ext" ) -public let Fuzz_Testing_Extensions_repeated_float_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_float_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1041, - fieldName: "fuzz.testing.repeated_float_ext" + fieldName: "swift_proto_testing.fuzz.repeated_float_ext" ) -public let Fuzz_Testing_Extensions_repeated_double_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_double_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1042, - fieldName: "fuzz.testing.repeated_double_ext" + fieldName: "swift_proto_testing.fuzz.repeated_double_ext" ) -public let Fuzz_Testing_Extensions_repeated_bool_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_bool_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1043, - fieldName: "fuzz.testing.repeated_bool_ext" + fieldName: "swift_proto_testing.fuzz.repeated_bool_ext" ) -public let Fuzz_Testing_Extensions_repeated_string_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_string_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1044, - fieldName: "fuzz.testing.repeated_string_ext" + fieldName: "swift_proto_testing.fuzz.repeated_string_ext" ) -public let Fuzz_Testing_Extensions_repeated_bytes_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_bytes_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1045, - fieldName: "fuzz.testing.repeated_bytes_ext" + fieldName: "swift_proto_testing.fuzz.repeated_bytes_ext" ) -public let Fuzz_Testing_Extensions_repeated_enum_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_enum_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1046, - fieldName: "fuzz.testing.repeated_enum_ext" + fieldName: "swift_proto_testing.fuzz.repeated_enum_ext" ) -public let Fuzz_Testing_Extensions_RepeatedGroup_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_RepeatedGroup_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1047, - fieldName: "fuzz.testing.repeatedgroup_ext" + fieldName: "swift_proto_testing.fuzz.repeatedgroup_ext" ) -public let Fuzz_Testing_Extensions_repeated_message_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_message_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1049, - fieldName: "fuzz.testing.repeated_message_ext" + fieldName: "swift_proto_testing.fuzz.repeated_message_ext" ) /// Repeated Packed -public let Fuzz_Testing_Extensions_repeated_packed_int32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1061, - fieldName: "fuzz.testing.repeated_packed_int32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_int32_ext" ) -public let Fuzz_Testing_Extensions_repeated_packed_int64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1062, - fieldName: "fuzz.testing.repeated_packed_int64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_int64_ext" ) -public let Fuzz_Testing_Extensions_repeated_packed_uint32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1063, - fieldName: "fuzz.testing.repeated_packed_uint32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_uint32_ext" ) -public let Fuzz_Testing_Extensions_repeated_packed_uint64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1064, - fieldName: "fuzz.testing.repeated_packed_uint64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_uint64_ext" ) -public let Fuzz_Testing_Extensions_repeated_packed_sint32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1065, - fieldName: "fuzz.testing.repeated_packed_sint32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_sint32_ext" ) -public let Fuzz_Testing_Extensions_repeated_packed_sint64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1066, - fieldName: "fuzz.testing.repeated_packed_sint64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_sint64_ext" ) -public let Fuzz_Testing_Extensions_repeated_packed_fixed32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1067, - fieldName: "fuzz.testing.repeated_packed_fixed32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_fixed32_ext" ) -public let Fuzz_Testing_Extensions_repeated_packed_fixed64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1068, - fieldName: "fuzz.testing.repeated_packed_fixed64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_fixed64_ext" ) -public let Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1069, - fieldName: "fuzz.testing.repeated_packed_sfixed32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_sfixed32_ext" ) -public let Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1070, - fieldName: "fuzz.testing.repeated_packed_sfixed64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_sfixed64_ext" ) -public let Fuzz_Testing_Extensions_repeated_packed_float_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_float_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1071, - fieldName: "fuzz.testing.repeated_packed_float_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_float_ext" ) -public let Fuzz_Testing_Extensions_repeated_packed_double_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_double_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1072, - fieldName: "fuzz.testing.repeated_packed_double_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_double_ext" ) -public let Fuzz_Testing_Extensions_repeated_packed_bool_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_bool_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1073, - fieldName: "fuzz.testing.repeated_packed_bool_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_bool_ext" ) -public let Fuzz_Testing_Extensions_repeated_packed_enum_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +public let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_enum_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1074, - fieldName: "fuzz.testing.repeated_packed_enum_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_enum_ext" ) +extension SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1 { + public enum Extensions { + public static let message_set_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_AMessageSetMessage>( + _protobuf_fieldNumber: 1547769, + fieldName: "swift_proto_testing.fuzz.AMessageSetMessageExtension1" + ) + } +} + +extension SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2 { + public enum Extensions { + public static let message_set_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_AMessageSetMessage>( + _protobuf_fieldNumber: 4135312, + fieldName: "swift_proto_testing.fuzz.AMessageSetMessageExtension2" + ) + } +} + // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "fuzz.testing" +fileprivate let _protobuf_package = "swift_proto_testing.fuzz" -extension Fuzz_Testing_AnEnum: SwiftProtobuf._ProtoNameProviding { - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ZERO"), - 1: .same(proto: "ONE"), - 2: .same(proto: "TWO"), - 3: .same(proto: "THREE"), - ] +extension SwiftProtoTesting_Fuzz_AnEnum: SwiftProtobuf._ProtoNameProviding { + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ZERO\0\u{1}ONE\0\u{1}TWO\0\u{1}THREE\0") } -extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Fuzz_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".Message" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "singular_int32"), - 2: .standard(proto: "singular_int64"), - 3: .standard(proto: "singular_uint32"), - 4: .standard(proto: "singular_uint64"), - 5: .standard(proto: "singular_sint32"), - 6: .standard(proto: "singular_sint64"), - 7: .standard(proto: "singular_fixed32"), - 8: .standard(proto: "singular_fixed64"), - 9: .standard(proto: "singular_sfixed32"), - 10: .standard(proto: "singular_sfixed64"), - 11: .standard(proto: "singular_float"), - 12: .standard(proto: "singular_double"), - 13: .standard(proto: "singular_bool"), - 14: .standard(proto: "singular_string"), - 15: .standard(proto: "singular_bytes"), - 16: .standard(proto: "singular_enum"), - 17: .unique(proto: "SingularGroup", json: "singulargroup"), - 19: .standard(proto: "singular_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 46: .standard(proto: "repeated_enum"), - 47: .unique(proto: "RepeatedGroup", json: "repeatedgroup"), - 49: .standard(proto: "repeated_message"), - 61: .standard(proto: "oneof_int32"), - 62: .standard(proto: "oneof_int64"), - 63: .standard(proto: "oneof_uint32"), - 64: .standard(proto: "oneof_uint64"), - 65: .standard(proto: "oneof_sint32"), - 66: .standard(proto: "oneof_sint64"), - 67: .standard(proto: "oneof_fixed32"), - 68: .standard(proto: "oneof_fixed64"), - 69: .standard(proto: "oneof_sfixed32"), - 70: .standard(proto: "oneof_sfixed64"), - 71: .standard(proto: "oneof_float"), - 72: .standard(proto: "oneof_double"), - 73: .standard(proto: "oneof_bool"), - 74: .standard(proto: "oneof_string"), - 75: .standard(proto: "oneof_bytes"), - 76: .standard(proto: "oneof_enum"), - 77: .unique(proto: "OneofGroup", json: "oneofgroup"), - 79: .standard(proto: "oneof_message"), - 81: .standard(proto: "repeated_packed_int32"), - 82: .standard(proto: "repeated_packed_int64"), - 83: .standard(proto: "repeated_packed_uint32"), - 84: .standard(proto: "repeated_packed_uint64"), - 85: .standard(proto: "repeated_packed_sint32"), - 86: .standard(proto: "repeated_packed_sint64"), - 87: .standard(proto: "repeated_packed_fixed32"), - 88: .standard(proto: "repeated_packed_fixed64"), - 89: .standard(proto: "repeated_packed_sfixed32"), - 90: .standard(proto: "repeated_packed_sfixed64"), - 91: .standard(proto: "repeated_packed_float"), - 92: .standard(proto: "repeated_packed_double"), - 93: .standard(proto: "repeated_packed_bool"), - 94: .standard(proto: "repeated_packed_enum"), - 100: .standard(proto: "map_int32_int32"), - 101: .standard(proto: "map_int32_int64"), - 102: .standard(proto: "map_int32_uint32"), - 103: .standard(proto: "map_int32_uint64"), - 104: .standard(proto: "map_int32_sint32"), - 105: .standard(proto: "map_int32_sint64"), - 106: .standard(proto: "map_int32_fixed32"), - 107: .standard(proto: "map_int32_fixed64"), - 108: .standard(proto: "map_int32_sfixed32"), - 109: .standard(proto: "map_int32_sfixed64"), - 110: .standard(proto: "map_int32_float"), - 111: .standard(proto: "map_int32_double"), - 112: .standard(proto: "map_int32_bool"), - 113: .standard(proto: "map_int32_string"), - 114: .standard(proto: "map_int32_bytes"), - 115: .standard(proto: "map_int32_AnEnum"), - 116: .standard(proto: "map_int32_Message"), - 117: .standard(proto: "map_int64_int32"), - 118: .standard(proto: "map_int64_int64"), - 119: .standard(proto: "map_int64_uint32"), - 120: .standard(proto: "map_int64_uint64"), - 121: .standard(proto: "map_int64_sint32"), - 122: .standard(proto: "map_int64_sint64"), - 123: .standard(proto: "map_int64_fixed32"), - 124: .standard(proto: "map_int64_fixed64"), - 125: .standard(proto: "map_int64_sfixed32"), - 126: .standard(proto: "map_int64_sfixed64"), - 127: .standard(proto: "map_int64_float"), - 128: .standard(proto: "map_int64_double"), - 129: .standard(proto: "map_int64_bool"), - 130: .standard(proto: "map_int64_string"), - 131: .standard(proto: "map_int64_bytes"), - 132: .standard(proto: "map_int64_AnEnum"), - 133: .standard(proto: "map_int64_Message"), - 134: .standard(proto: "map_uint32_int32"), - 135: .standard(proto: "map_uint32_int64"), - 136: .standard(proto: "map_uint32_uint32"), - 137: .standard(proto: "map_uint32_uint64"), - 138: .standard(proto: "map_uint32_sint32"), - 139: .standard(proto: "map_uint32_sint64"), - 140: .standard(proto: "map_uint32_fixed32"), - 141: .standard(proto: "map_uint32_fixed64"), - 142: .standard(proto: "map_uint32_sfixed32"), - 143: .standard(proto: "map_uint32_sfixed64"), - 144: .standard(proto: "map_uint32_float"), - 145: .standard(proto: "map_uint32_double"), - 146: .standard(proto: "map_uint32_bool"), - 147: .standard(proto: "map_uint32_string"), - 148: .standard(proto: "map_uint32_bytes"), - 149: .standard(proto: "map_uint32_AnEnum"), - 150: .standard(proto: "map_uint32_Message"), - 151: .standard(proto: "map_uint64_int32"), - 152: .standard(proto: "map_uint64_int64"), - 153: .standard(proto: "map_uint64_uint32"), - 154: .standard(proto: "map_uint64_uint64"), - 155: .standard(proto: "map_uint64_sint32"), - 156: .standard(proto: "map_uint64_sint64"), - 157: .standard(proto: "map_uint64_fixed32"), - 158: .standard(proto: "map_uint64_fixed64"), - 159: .standard(proto: "map_uint64_sfixed32"), - 160: .standard(proto: "map_uint64_sfixed64"), - 161: .standard(proto: "map_uint64_float"), - 162: .standard(proto: "map_uint64_double"), - 163: .standard(proto: "map_uint64_bool"), - 164: .standard(proto: "map_uint64_string"), - 165: .standard(proto: "map_uint64_bytes"), - 166: .standard(proto: "map_uint64_AnEnum"), - 167: .standard(proto: "map_uint64_Message"), - 168: .standard(proto: "map_sint32_int32"), - 169: .standard(proto: "map_sint32_int64"), - 170: .standard(proto: "map_sint32_uint32"), - 171: .standard(proto: "map_sint32_uint64"), - 172: .standard(proto: "map_sint32_sint32"), - 173: .standard(proto: "map_sint32_sint64"), - 174: .standard(proto: "map_sint32_fixed32"), - 175: .standard(proto: "map_sint32_fixed64"), - 176: .standard(proto: "map_sint32_sfixed32"), - 177: .standard(proto: "map_sint32_sfixed64"), - 178: .standard(proto: "map_sint32_float"), - 179: .standard(proto: "map_sint32_double"), - 180: .standard(proto: "map_sint32_bool"), - 181: .standard(proto: "map_sint32_string"), - 182: .standard(proto: "map_sint32_bytes"), - 183: .standard(proto: "map_sint32_AnEnum"), - 184: .standard(proto: "map_sint32_Message"), - 185: .standard(proto: "map_sint64_int32"), - 186: .standard(proto: "map_sint64_int64"), - 187: .standard(proto: "map_sint64_uint32"), - 188: .standard(proto: "map_sint64_uint64"), - 189: .standard(proto: "map_sint64_sint32"), - 190: .standard(proto: "map_sint64_sint64"), - 191: .standard(proto: "map_sint64_fixed32"), - 192: .standard(proto: "map_sint64_fixed64"), - 193: .standard(proto: "map_sint64_sfixed32"), - 194: .standard(proto: "map_sint64_sfixed64"), - 195: .standard(proto: "map_sint64_float"), - 196: .standard(proto: "map_sint64_double"), - 197: .standard(proto: "map_sint64_bool"), - 198: .standard(proto: "map_sint64_string"), - 199: .standard(proto: "map_sint64_bytes"), - 200: .standard(proto: "map_sint64_AnEnum"), - 201: .standard(proto: "map_sint64_Message"), - 202: .standard(proto: "map_fixed32_int32"), - 203: .standard(proto: "map_fixed32_int64"), - 204: .standard(proto: "map_fixed32_uint32"), - 205: .standard(proto: "map_fixed32_uint64"), - 206: .standard(proto: "map_fixed32_sint32"), - 207: .standard(proto: "map_fixed32_sint64"), - 208: .standard(proto: "map_fixed32_fixed32"), - 209: .standard(proto: "map_fixed32_fixed64"), - 210: .standard(proto: "map_fixed32_sfixed32"), - 211: .standard(proto: "map_fixed32_sfixed64"), - 212: .standard(proto: "map_fixed32_float"), - 213: .standard(proto: "map_fixed32_double"), - 214: .standard(proto: "map_fixed32_bool"), - 215: .standard(proto: "map_fixed32_string"), - 216: .standard(proto: "map_fixed32_bytes"), - 217: .standard(proto: "map_fixed32_AnEnum"), - 218: .standard(proto: "map_fixed32_Message"), - 219: .standard(proto: "map_fixed64_int32"), - 220: .standard(proto: "map_fixed64_int64"), - 221: .standard(proto: "map_fixed64_uint32"), - 222: .standard(proto: "map_fixed64_uint64"), - 223: .standard(proto: "map_fixed64_sint32"), - 224: .standard(proto: "map_fixed64_sint64"), - 225: .standard(proto: "map_fixed64_fixed32"), - 226: .standard(proto: "map_fixed64_fixed64"), - 227: .standard(proto: "map_fixed64_sfixed32"), - 228: .standard(proto: "map_fixed64_sfixed64"), - 229: .standard(proto: "map_fixed64_float"), - 230: .standard(proto: "map_fixed64_double"), - 231: .standard(proto: "map_fixed64_bool"), - 232: .standard(proto: "map_fixed64_string"), - 233: .standard(proto: "map_fixed64_bytes"), - 234: .standard(proto: "map_fixed64_AnEnum"), - 235: .standard(proto: "map_fixed64_Message"), - 236: .standard(proto: "map_sfixed32_int32"), - 237: .standard(proto: "map_sfixed32_int64"), - 238: .standard(proto: "map_sfixed32_uint32"), - 239: .standard(proto: "map_sfixed32_uint64"), - 240: .standard(proto: "map_sfixed32_sint32"), - 241: .standard(proto: "map_sfixed32_sint64"), - 242: .standard(proto: "map_sfixed32_fixed32"), - 243: .standard(proto: "map_sfixed32_fixed64"), - 244: .standard(proto: "map_sfixed32_sfixed32"), - 245: .standard(proto: "map_sfixed32_sfixed64"), - 246: .standard(proto: "map_sfixed32_float"), - 247: .standard(proto: "map_sfixed32_double"), - 248: .standard(proto: "map_sfixed32_bool"), - 249: .standard(proto: "map_sfixed32_string"), - 250: .standard(proto: "map_sfixed32_bytes"), - 251: .standard(proto: "map_sfixed32_AnEnum"), - 252: .standard(proto: "map_sfixed32_Message"), - 253: .standard(proto: "map_sfixed64_int32"), - 254: .standard(proto: "map_sfixed64_int64"), - 255: .standard(proto: "map_sfixed64_uint32"), - 256: .standard(proto: "map_sfixed64_uint64"), - 257: .standard(proto: "map_sfixed64_sint32"), - 258: .standard(proto: "map_sfixed64_sint64"), - 259: .standard(proto: "map_sfixed64_fixed32"), - 260: .standard(proto: "map_sfixed64_fixed64"), - 261: .standard(proto: "map_sfixed64_sfixed32"), - 262: .standard(proto: "map_sfixed64_sfixed64"), - 263: .standard(proto: "map_sfixed64_float"), - 264: .standard(proto: "map_sfixed64_double"), - 265: .standard(proto: "map_sfixed64_bool"), - 266: .standard(proto: "map_sfixed64_string"), - 267: .standard(proto: "map_sfixed64_bytes"), - 268: .standard(proto: "map_sfixed64_AnEnum"), - 269: .standard(proto: "map_sfixed64_Message"), - 270: .standard(proto: "map_bool_int32"), - 271: .standard(proto: "map_bool_int64"), - 272: .standard(proto: "map_bool_uint32"), - 273: .standard(proto: "map_bool_uint64"), - 274: .standard(proto: "map_bool_sint32"), - 275: .standard(proto: "map_bool_sint64"), - 276: .standard(proto: "map_bool_fixed32"), - 277: .standard(proto: "map_bool_fixed64"), - 278: .standard(proto: "map_bool_sfixed32"), - 279: .standard(proto: "map_bool_sfixed64"), - 280: .standard(proto: "map_bool_float"), - 281: .standard(proto: "map_bool_double"), - 282: .standard(proto: "map_bool_bool"), - 283: .standard(proto: "map_bool_string"), - 284: .standard(proto: "map_bool_bytes"), - 285: .standard(proto: "map_bool_AnEnum"), - 286: .standard(proto: "map_bool_Message"), - 500: .standard(proto: "wkt_any"), - 501: .standard(proto: "wkt_api"), - 502: .standard(proto: "wkt_duration"), - 503: .standard(proto: "wkt_empty"), - 504: .standard(proto: "wkt_field_mask"), - 505: .standard(proto: "wkt_source_context"), - 506: .standard(proto: "wkt_struct"), - 507: .standard(proto: "wkt_timestamp"), - 508: .standard(proto: "wkt_type"), - 509: .standard(proto: "wkt_double_value"), - 510: .standard(proto: "wkt_float_value"), - 511: .standard(proto: "wkt_int64_value"), - 512: .standard(proto: "wkt_uint64_value"), - 513: .standard(proto: "wkt_int32_value"), - 514: .standard(proto: "wkt_uint32_value"), - 515: .standard(proto: "wkt_bool_value"), - 516: .standard(proto: "wkt_string_value"), - 517: .standard(proto: "wkt_bytes_value"), - 600: .standard(proto: "singular_message_set"), - 601: .standard(proto: "repeated_message_set"), - ] + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}singular_int32\0\u{3}singular_int64\0\u{3}singular_uint32\0\u{3}singular_uint64\0\u{3}singular_sint32\0\u{3}singular_sint64\0\u{3}singular_fixed32\0\u{3}singular_fixed64\0\u{3}singular_sfixed32\0\u{3}singular_sfixed64\0\u{3}singular_float\0\u{3}singular_double\0\u{3}singular_bool\0\u{3}singular_string\0\u{3}singular_bytes\0\u{3}singular_enum\0\u{7}SingularGroup\0\u{4}\u{2}singular_message\0\u{4}\u{c}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{3}repeated_enum\0\u{7}RepeatedGroup\0\u{4}\u{2}repeated_message\0\u{4}\u{c}oneof_int32\0\u{3}oneof_int64\0\u{3}oneof_uint32\0\u{3}oneof_uint64\0\u{3}oneof_sint32\0\u{3}oneof_sint64\0\u{3}oneof_fixed32\0\u{3}oneof_fixed64\0\u{3}oneof_sfixed32\0\u{3}oneof_sfixed64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_bool\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_enum\0\u{7}OneofGroup\0\u{4}\u{2}oneof_message\0\u{4}\u{2}repeated_packed_int32\0\u{3}repeated_packed_int64\0\u{3}repeated_packed_uint32\0\u{3}repeated_packed_uint64\0\u{3}repeated_packed_sint32\0\u{3}repeated_packed_sint64\0\u{3}repeated_packed_fixed32\0\u{3}repeated_packed_fixed64\0\u{3}repeated_packed_sfixed32\0\u{3}repeated_packed_sfixed64\0\u{3}repeated_packed_float\0\u{3}repeated_packed_double\0\u{3}repeated_packed_bool\0\u{3}repeated_packed_enum\0\u{4}\u{6}map_int32_int32\0\u{3}map_int32_int64\0\u{3}map_int32_uint32\0\u{3}map_int32_uint64\0\u{3}map_int32_sint32\0\u{3}map_int32_sint64\0\u{3}map_int32_fixed32\0\u{3}map_int32_fixed64\0\u{3}map_int32_sfixed32\0\u{3}map_int32_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_int32_bool\0\u{3}map_int32_string\0\u{3}map_int32_bytes\0\u{3}map_int32_AnEnum\0\u{3}map_int32_Message\0\u{3}map_int64_int32\0\u{3}map_int64_int64\0\u{3}map_int64_uint32\0\u{3}map_int64_uint64\0\u{3}map_int64_sint32\0\u{3}map_int64_sint64\0\u{3}map_int64_fixed32\0\u{3}map_int64_fixed64\0\u{3}map_int64_sfixed32\0\u{3}map_int64_sfixed64\0\u{3}map_int64_float\0\u{3}map_int64_double\0\u{3}map_int64_bool\0\u{3}map_int64_string\0\u{3}map_int64_bytes\0\u{3}map_int64_AnEnum\0\u{3}map_int64_Message\0\u{3}map_uint32_int32\0\u{3}map_uint32_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint32_uint64\0\u{3}map_uint32_sint32\0\u{3}map_uint32_sint64\0\u{3}map_uint32_fixed32\0\u{3}map_uint32_fixed64\0\u{3}map_uint32_sfixed32\0\u{3}map_uint32_sfixed64\0\u{3}map_uint32_float\0\u{3}map_uint32_double\0\u{3}map_uint32_bool\0\u{3}map_uint32_string\0\u{3}map_uint32_bytes\0\u{3}map_uint32_AnEnum\0\u{3}map_uint32_Message\0\u{3}map_uint64_int32\0\u{3}map_uint64_int64\0\u{3}map_uint64_uint32\0\u{3}map_uint64_uint64\0\u{3}map_uint64_sint32\0\u{3}map_uint64_sint64\0\u{3}map_uint64_fixed32\0\u{3}map_uint64_fixed64\0\u{3}map_uint64_sfixed32\0\u{3}map_uint64_sfixed64\0\u{3}map_uint64_float\0\u{3}map_uint64_double\0\u{3}map_uint64_bool\0\u{3}map_uint64_string\0\u{3}map_uint64_bytes\0\u{3}map_uint64_AnEnum\0\u{3}map_uint64_Message\0\u{3}map_sint32_int32\0\u{3}map_sint32_int64\0\u{3}map_sint32_uint32\0\u{3}map_sint32_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint32_sint64\0\u{3}map_sint32_fixed32\0\u{3}map_sint32_fixed64\0\u{3}map_sint32_sfixed32\0\u{3}map_sint32_sfixed64\0\u{3}map_sint32_float\0\u{3}map_sint32_double\0\u{3}map_sint32_bool\0\u{3}map_sint32_string\0\u{3}map_sint32_bytes\0\u{3}map_sint32_AnEnum\0\u{3}map_sint32_Message\0\u{3}map_sint64_int32\0\u{3}map_sint64_int64\0\u{3}map_sint64_uint32\0\u{3}map_sint64_uint64\0\u{3}map_sint64_sint32\0\u{3}map_sint64_sint64\0\u{3}map_sint64_fixed32\0\u{3}map_sint64_fixed64\0\u{3}map_sint64_sfixed32\0\u{3}map_sint64_sfixed64\0\u{3}map_sint64_float\0\u{3}map_sint64_double\0\u{3}map_sint64_bool\0\u{3}map_sint64_string\0\u{3}map_sint64_bytes\0\u{3}map_sint64_AnEnum\0\u{3}map_sint64_Message\0\u{3}map_fixed32_int32\0\u{3}map_fixed32_int64\0\u{3}map_fixed32_uint32\0\u{3}map_fixed32_uint64\0\u{3}map_fixed32_sint32\0\u{3}map_fixed32_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed32_fixed64\0\u{3}map_fixed32_sfixed32\0\u{3}map_fixed32_sfixed64\0\u{3}map_fixed32_float\0\u{3}map_fixed32_double\0\u{3}map_fixed32_bool\0\u{3}map_fixed32_string\0\u{3}map_fixed32_bytes\0\u{3}map_fixed32_AnEnum\0\u{3}map_fixed32_Message\0\u{3}map_fixed64_int32\0\u{3}map_fixed64_int64\0\u{3}map_fixed64_uint32\0\u{3}map_fixed64_uint64\0\u{3}map_fixed64_sint32\0\u{3}map_fixed64_sint64\0\u{3}map_fixed64_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_fixed64_sfixed32\0\u{3}map_fixed64_sfixed64\0\u{3}map_fixed64_float\0\u{3}map_fixed64_double\0\u{3}map_fixed64_bool\0\u{3}map_fixed64_string\0\u{3}map_fixed64_bytes\0\u{3}map_fixed64_AnEnum\0\u{3}map_fixed64_Message\0\u{3}map_sfixed32_int32\0\u{3}map_sfixed32_int64\0\u{3}map_sfixed32_uint32\0\u{3}map_sfixed32_uint64\0\u{3}map_sfixed32_sint32\0\u{3}map_sfixed32_sint64\0\u{3}map_sfixed32_fixed32\0\u{3}map_sfixed32_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed32_sfixed64\0\u{3}map_sfixed32_float\0\u{3}map_sfixed32_double\0\u{3}map_sfixed32_bool\0\u{3}map_sfixed32_string\0\u{3}map_sfixed32_bytes\0\u{3}map_sfixed32_AnEnum\0\u{3}map_sfixed32_Message\0\u{3}map_sfixed64_int32\0\u{3}map_sfixed64_int64\0\u{3}map_sfixed64_uint32\0\u{3}map_sfixed64_uint64\0\u{3}map_sfixed64_sint32\0\u{3}map_sfixed64_sint64\0\u{3}map_sfixed64_fixed32\0\u{3}map_sfixed64_fixed64\0\u{3}map_sfixed64_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_sfixed64_float\0\u{3}map_sfixed64_double\0\u{3}map_sfixed64_bool\0\u{3}map_sfixed64_string\0\u{3}map_sfixed64_bytes\0\u{3}map_sfixed64_AnEnum\0\u{3}map_sfixed64_Message\0\u{3}map_bool_int32\0\u{3}map_bool_int64\0\u{3}map_bool_uint32\0\u{3}map_bool_uint64\0\u{3}map_bool_sint32\0\u{3}map_bool_sint64\0\u{3}map_bool_fixed32\0\u{3}map_bool_fixed64\0\u{3}map_bool_sfixed32\0\u{3}map_bool_sfixed64\0\u{3}map_bool_float\0\u{3}map_bool_double\0\u{3}map_bool_bool\0\u{3}map_bool_string\0\u{3}map_bool_bytes\0\u{3}map_bool_AnEnum\0\u{3}map_bool_Message\0\u{4}V\u{3}wkt_any\0\u{3}wkt_api\0\u{3}wkt_duration\0\u{3}wkt_empty\0\u{3}wkt_field_mask\0\u{3}wkt_source_context\0\u{3}wkt_struct\0\u{3}wkt_timestamp\0\u{3}wkt_type\0\u{3}wkt_double_value\0\u{3}wkt_float_value\0\u{3}wkt_int64_value\0\u{3}wkt_uint64_value\0\u{3}wkt_int32_value\0\u{3}wkt_uint32_value\0\u{3}wkt_bool_value\0\u{3}wkt_string_value\0\u{3}wkt_bytes_value\0\u{4}S\u{1}singular_message_set\0\u{3}repeated_message_set\0") fileprivate class _StorageClass { var _singularInt32: Int32? = nil @@ -3307,9 +2681,9 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _singularBool: Bool? = nil var _singularString: String? = nil var _singularBytes: Data? = nil - var _singularEnum: Fuzz_Testing_AnEnum? = nil - var _singularGroup: Fuzz_Testing_Message.SingularGroup? = nil - var _singularMessage: Fuzz_Testing_Message? = nil + var _singularEnum: SwiftProtoTesting_Fuzz_AnEnum? = nil + var _singularGroup: SwiftProtoTesting_Fuzz_Message.SingularGroup? = nil + var _singularMessage: SwiftProtoTesting_Fuzz_Message? = nil var _repeatedInt32: [Int32] = [] var _repeatedInt64: [Int64] = [] var _repeatedUint32: [UInt32] = [] @@ -3325,10 +2699,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _repeatedBool: [Bool] = [] var _repeatedString: [String] = [] var _repeatedBytes: [Data] = [] - var _repeatedEnum: [Fuzz_Testing_AnEnum] = [] - var _repeatedGroup: [Fuzz_Testing_Message.RepeatedGroup] = [] - var _repeatedMessage: [Fuzz_Testing_Message] = [] - var _o: Fuzz_Testing_Message.OneOf_O? + var _repeatedEnum: [SwiftProtoTesting_Fuzz_AnEnum] = [] + var _repeatedGroup: [SwiftProtoTesting_Fuzz_Message.RepeatedGroup] = [] + var _repeatedMessage: [SwiftProtoTesting_Fuzz_Message] = [] + var _o: SwiftProtoTesting_Fuzz_Message.OneOf_O? var _repeatedPackedInt32: [Int32] = [] var _repeatedPackedInt64: [Int64] = [] var _repeatedPackedUint32: [UInt32] = [] @@ -3342,7 +2716,7 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _repeatedPackedFloat: [Float] = [] var _repeatedPackedDouble: [Double] = [] var _repeatedPackedBool: [Bool] = [] - var _repeatedPackedEnum: [Fuzz_Testing_AnEnum] = [] + var _repeatedPackedEnum: [SwiftProtoTesting_Fuzz_AnEnum] = [] var _mapInt32Int32: Dictionary = [:] var _mapInt32Int64: Dictionary = [:] var _mapInt32Uint32: Dictionary = [:] @@ -3358,8 +2732,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapInt32Bool: Dictionary = [:] var _mapInt32String: Dictionary = [:] var _mapInt32Bytes: Dictionary = [:] - var _mapInt32AnEnum: Dictionary = [:] - var _mapInt32Message: Dictionary = [:] + var _mapInt32AnEnum: Dictionary = [:] + var _mapInt32Message: Dictionary = [:] var _mapInt64Int32: Dictionary = [:] var _mapInt64Int64: Dictionary = [:] var _mapInt64Uint32: Dictionary = [:] @@ -3375,8 +2749,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapInt64Bool: Dictionary = [:] var _mapInt64String: Dictionary = [:] var _mapInt64Bytes: Dictionary = [:] - var _mapInt64AnEnum: Dictionary = [:] - var _mapInt64Message: Dictionary = [:] + var _mapInt64AnEnum: Dictionary = [:] + var _mapInt64Message: Dictionary = [:] var _mapUint32Int32: Dictionary = [:] var _mapUint32Int64: Dictionary = [:] var _mapUint32Uint32: Dictionary = [:] @@ -3392,8 +2766,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapUint32Bool: Dictionary = [:] var _mapUint32String: Dictionary = [:] var _mapUint32Bytes: Dictionary = [:] - var _mapUint32AnEnum: Dictionary = [:] - var _mapUint32Message: Dictionary = [:] + var _mapUint32AnEnum: Dictionary = [:] + var _mapUint32Message: Dictionary = [:] var _mapUint64Int32: Dictionary = [:] var _mapUint64Int64: Dictionary = [:] var _mapUint64Uint32: Dictionary = [:] @@ -3409,8 +2783,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapUint64Bool: Dictionary = [:] var _mapUint64String: Dictionary = [:] var _mapUint64Bytes: Dictionary = [:] - var _mapUint64AnEnum: Dictionary = [:] - var _mapUint64Message: Dictionary = [:] + var _mapUint64AnEnum: Dictionary = [:] + var _mapUint64Message: Dictionary = [:] var _mapSint32Int32: Dictionary = [:] var _mapSint32Int64: Dictionary = [:] var _mapSint32Uint32: Dictionary = [:] @@ -3426,8 +2800,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapSint32Bool: Dictionary = [:] var _mapSint32String: Dictionary = [:] var _mapSint32Bytes: Dictionary = [:] - var _mapSint32AnEnum: Dictionary = [:] - var _mapSint32Message: Dictionary = [:] + var _mapSint32AnEnum: Dictionary = [:] + var _mapSint32Message: Dictionary = [:] var _mapSint64Int32: Dictionary = [:] var _mapSint64Int64: Dictionary = [:] var _mapSint64Uint32: Dictionary = [:] @@ -3443,8 +2817,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapSint64Bool: Dictionary = [:] var _mapSint64String: Dictionary = [:] var _mapSint64Bytes: Dictionary = [:] - var _mapSint64AnEnum: Dictionary = [:] - var _mapSint64Message: Dictionary = [:] + var _mapSint64AnEnum: Dictionary = [:] + var _mapSint64Message: Dictionary = [:] var _mapFixed32Int32: Dictionary = [:] var _mapFixed32Int64: Dictionary = [:] var _mapFixed32Uint32: Dictionary = [:] @@ -3460,8 +2834,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapFixed32Bool: Dictionary = [:] var _mapFixed32String: Dictionary = [:] var _mapFixed32Bytes: Dictionary = [:] - var _mapFixed32AnEnum: Dictionary = [:] - var _mapFixed32Message: Dictionary = [:] + var _mapFixed32AnEnum: Dictionary = [:] + var _mapFixed32Message: Dictionary = [:] var _mapFixed64Int32: Dictionary = [:] var _mapFixed64Int64: Dictionary = [:] var _mapFixed64Uint32: Dictionary = [:] @@ -3477,8 +2851,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapFixed64Bool: Dictionary = [:] var _mapFixed64String: Dictionary = [:] var _mapFixed64Bytes: Dictionary = [:] - var _mapFixed64AnEnum: Dictionary = [:] - var _mapFixed64Message: Dictionary = [:] + var _mapFixed64AnEnum: Dictionary = [:] + var _mapFixed64Message: Dictionary = [:] var _mapSfixed32Int32: Dictionary = [:] var _mapSfixed32Int64: Dictionary = [:] var _mapSfixed32Uint32: Dictionary = [:] @@ -3494,8 +2868,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapSfixed32Bool: Dictionary = [:] var _mapSfixed32String: Dictionary = [:] var _mapSfixed32Bytes: Dictionary = [:] - var _mapSfixed32AnEnum: Dictionary = [:] - var _mapSfixed32Message: Dictionary = [:] + var _mapSfixed32AnEnum: Dictionary = [:] + var _mapSfixed32Message: Dictionary = [:] var _mapSfixed64Int32: Dictionary = [:] var _mapSfixed64Int64: Dictionary = [:] var _mapSfixed64Uint32: Dictionary = [:] @@ -3511,8 +2885,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapSfixed64Bool: Dictionary = [:] var _mapSfixed64String: Dictionary = [:] var _mapSfixed64Bytes: Dictionary = [:] - var _mapSfixed64AnEnum: Dictionary = [:] - var _mapSfixed64Message: Dictionary = [:] + var _mapSfixed64AnEnum: Dictionary = [:] + var _mapSfixed64Message: Dictionary = [:] var _mapBoolInt32: Dictionary = [:] var _mapBoolInt64: Dictionary = [:] var _mapBoolUint32: Dictionary = [:] @@ -3528,8 +2902,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapBoolBool: Dictionary = [:] var _mapBoolString: Dictionary = [:] var _mapBoolBytes: Dictionary = [:] - var _mapBoolAnEnum: Dictionary = [:] - var _mapBoolMessage: Dictionary = [:] + var _mapBoolAnEnum: Dictionary = [:] + var _mapBoolMessage: Dictionary = [:] var _wktAny: SwiftProtobuf.Google_Protobuf_Any? = nil var _wktApi: SwiftProtobuf.Google_Protobuf_Api? = nil var _wktDuration: SwiftProtobuf.Google_Protobuf_Duration? = nil @@ -3548,10 +2922,14 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _wktBoolValue: SwiftProtobuf.Google_Protobuf_BoolValue? = nil var _wktStringValue: SwiftProtobuf.Google_Protobuf_StringValue? = nil var _wktBytesValue: SwiftProtobuf.Google_Protobuf_BytesValue? = nil - var _singularMessageSet: Fuzz_Testing_AMessageSetMessage? = nil - var _repeatedMessageSet: [Fuzz_Testing_AMessageSetMessage] = [] + var _singularMessageSet: SwiftProtoTesting_Fuzz_AMessageSetMessage? = nil + var _repeatedMessageSet: [SwiftProtoTesting_Fuzz_AMessageSetMessage] = [] - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -4012,7 +3390,7 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp } }() case 76: try { - var v: Fuzz_Testing_AnEnum? + var v: SwiftProtoTesting_Fuzz_AnEnum? try decoder.decodeSingularEnumField(value: &v) if let v = v { if _storage._o != nil {try decoder.handleConflictingOneOf()} @@ -4020,7 +3398,7 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp } }() case 77: try { - var v: Fuzz_Testing_Message.OneofGroup? + var v: SwiftProtoTesting_Fuzz_Message.OneofGroup? var hadOneofValue = false if let current = _storage._o { hadOneofValue = true @@ -4033,7 +3411,7 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp } }() case 79: try { - var v: Fuzz_Testing_Message? + var v: SwiftProtoTesting_Fuzz_Message? var hadOneofValue = false if let current = _storage._o { hadOneofValue = true @@ -4074,8 +3452,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 112: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bool) }() case 113: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32String) }() case 114: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bytes) }() - case 115: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32AnEnum) }() - case 116: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32Message) }() + case 115: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32AnEnum) }() + case 116: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32Message) }() case 117: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int32) }() case 118: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() case 119: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Uint32) }() @@ -4091,8 +3469,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 129: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Bool) }() case 130: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64String) }() case 131: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Bytes) }() - case 132: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt64AnEnum) }() - case 133: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt64Message) }() + case 132: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt64AnEnum) }() + case 133: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt64Message) }() case 134: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Int32) }() case 135: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Int64) }() case 136: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() @@ -4108,8 +3486,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 146: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Bool) }() case 147: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32String) }() case 148: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Bytes) }() - case 149: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapUint32AnEnum) }() - case 150: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapUint32Message) }() + case 149: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapUint32AnEnum) }() + case 150: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapUint32Message) }() case 151: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Int32) }() case 152: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Int64) }() case 153: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Uint32) }() @@ -4125,8 +3503,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 163: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Bool) }() case 164: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64String) }() case 165: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Bytes) }() - case 166: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapUint64AnEnum) }() - case 167: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapUint64Message) }() + case 166: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapUint64AnEnum) }() + case 167: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapUint64Message) }() case 168: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Int32) }() case 169: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Int64) }() case 170: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Uint32) }() @@ -4142,8 +3520,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 180: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Bool) }() case 181: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32String) }() case 182: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Bytes) }() - case 183: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSint32AnEnum) }() - case 184: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSint32Message) }() + case 183: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSint32AnEnum) }() + case 184: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSint32Message) }() case 185: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Int32) }() case 186: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Int64) }() case 187: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Uint32) }() @@ -4159,8 +3537,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 197: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Bool) }() case 198: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64String) }() case 199: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Bytes) }() - case 200: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSint64AnEnum) }() - case 201: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSint64Message) }() + case 200: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSint64AnEnum) }() + case 201: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSint64Message) }() case 202: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Int32) }() case 203: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Int64) }() case 204: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Uint32) }() @@ -4176,8 +3554,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 214: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Bool) }() case 215: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32String) }() case 216: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Bytes) }() - case 217: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapFixed32AnEnum) }() - case 218: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapFixed32Message) }() + case 217: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapFixed32AnEnum) }() + case 218: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapFixed32Message) }() case 219: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Int32) }() case 220: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Int64) }() case 221: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Uint32) }() @@ -4193,8 +3571,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 231: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Bool) }() case 232: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64String) }() case 233: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Bytes) }() - case 234: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapFixed64AnEnum) }() - case 235: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapFixed64Message) }() + case 234: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapFixed64AnEnum) }() + case 235: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapFixed64Message) }() case 236: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Int32) }() case 237: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Int64) }() case 238: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Uint32) }() @@ -4210,8 +3588,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 248: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Bool) }() case 249: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32String) }() case 250: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Bytes) }() - case 251: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSfixed32AnEnum) }() - case 252: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSfixed32Message) }() + case 251: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSfixed32AnEnum) }() + case 252: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSfixed32Message) }() case 253: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Int32) }() case 254: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Int64) }() case 255: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Uint32) }() @@ -4227,8 +3605,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 265: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Bool) }() case 266: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64String) }() case 267: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Bytes) }() - case 268: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSfixed64AnEnum) }() - case 269: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSfixed64Message) }() + case 268: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSfixed64AnEnum) }() + case 269: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSfixed64Message) }() case 270: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolInt32) }() case 271: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolInt64) }() case 272: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolUint32) }() @@ -4244,8 +3622,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 282: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() case 283: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolString) }() case 284: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBytes) }() - case 285: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapBoolAnEnum) }() - case 286: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapBoolMessage) }() + case 285: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapBoolAnEnum) }() + case 286: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapBoolMessage) }() case 500: try { try decoder.decodeSingularMessageField(value: &_storage._wktAny) }() case 501: try { try decoder.decodeSingularMessageField(value: &_storage._wktApi) }() case 502: try { try decoder.decodeSingularMessageField(value: &_storage._wktDuration) }() @@ -4267,7 +3645,7 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 600: try { try decoder.decodeSingularMessageField(value: &_storage._singularMessageSet) }() case 601: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedMessageSet) }() case 1000..<2001: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Fuzz_Testing_Message.self, fieldNumber: fieldNumber) }() + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Fuzz_Message.self, fieldNumber: fieldNumber) }() default: break } } @@ -4551,10 +3929,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bytes, fieldNumber: 114) } if !_storage._mapInt32AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32AnEnum, fieldNumber: 115) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32AnEnum, fieldNumber: 115) } if !_storage._mapInt32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32Message, fieldNumber: 116) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32Message, fieldNumber: 116) } if !_storage._mapInt64Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Int32, fieldNumber: 117) @@ -4602,10 +3980,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Bytes, fieldNumber: 131) } if !_storage._mapInt64AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt64AnEnum, fieldNumber: 132) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt64AnEnum, fieldNumber: 132) } if !_storage._mapInt64Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt64Message, fieldNumber: 133) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt64Message, fieldNumber: 133) } if !_storage._mapUint32Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Int32, fieldNumber: 134) @@ -4653,10 +4031,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Bytes, fieldNumber: 148) } if !_storage._mapUint32AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapUint32AnEnum, fieldNumber: 149) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapUint32AnEnum, fieldNumber: 149) } if !_storage._mapUint32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapUint32Message, fieldNumber: 150) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapUint32Message, fieldNumber: 150) } if !_storage._mapUint64Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Int32, fieldNumber: 151) @@ -4704,10 +4082,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Bytes, fieldNumber: 165) } if !_storage._mapUint64AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapUint64AnEnum, fieldNumber: 166) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapUint64AnEnum, fieldNumber: 166) } if !_storage._mapUint64Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapUint64Message, fieldNumber: 167) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapUint64Message, fieldNumber: 167) } if !_storage._mapSint32Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Int32, fieldNumber: 168) @@ -4755,10 +4133,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Bytes, fieldNumber: 182) } if !_storage._mapSint32AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSint32AnEnum, fieldNumber: 183) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSint32AnEnum, fieldNumber: 183) } if !_storage._mapSint32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSint32Message, fieldNumber: 184) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSint32Message, fieldNumber: 184) } if !_storage._mapSint64Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Int32, fieldNumber: 185) @@ -4806,10 +4184,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Bytes, fieldNumber: 199) } if !_storage._mapSint64AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSint64AnEnum, fieldNumber: 200) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSint64AnEnum, fieldNumber: 200) } if !_storage._mapSint64Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSint64Message, fieldNumber: 201) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSint64Message, fieldNumber: 201) } if !_storage._mapFixed32Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Int32, fieldNumber: 202) @@ -4857,10 +4235,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Bytes, fieldNumber: 216) } if !_storage._mapFixed32AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapFixed32AnEnum, fieldNumber: 217) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapFixed32AnEnum, fieldNumber: 217) } if !_storage._mapFixed32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapFixed32Message, fieldNumber: 218) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapFixed32Message, fieldNumber: 218) } if !_storage._mapFixed64Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Int32, fieldNumber: 219) @@ -4908,10 +4286,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Bytes, fieldNumber: 233) } if !_storage._mapFixed64AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapFixed64AnEnum, fieldNumber: 234) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapFixed64AnEnum, fieldNumber: 234) } if !_storage._mapFixed64Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapFixed64Message, fieldNumber: 235) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapFixed64Message, fieldNumber: 235) } if !_storage._mapSfixed32Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Int32, fieldNumber: 236) @@ -4959,10 +4337,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Bytes, fieldNumber: 250) } if !_storage._mapSfixed32AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSfixed32AnEnum, fieldNumber: 251) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSfixed32AnEnum, fieldNumber: 251) } if !_storage._mapSfixed32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSfixed32Message, fieldNumber: 252) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSfixed32Message, fieldNumber: 252) } if !_storage._mapSfixed64Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Int32, fieldNumber: 253) @@ -5010,10 +4388,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Bytes, fieldNumber: 267) } if !_storage._mapSfixed64AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSfixed64AnEnum, fieldNumber: 268) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSfixed64AnEnum, fieldNumber: 268) } if !_storage._mapSfixed64Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSfixed64Message, fieldNumber: 269) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSfixed64Message, fieldNumber: 269) } if !_storage._mapBoolInt32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolInt32, fieldNumber: 270) @@ -5061,10 +4439,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolBytes, fieldNumber: 284) } if !_storage._mapBoolAnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapBoolAnEnum, fieldNumber: 285) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapBoolAnEnum, fieldNumber: 285) } if !_storage._mapBoolMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapBoolMessage, fieldNumber: 286) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapBoolMessage, fieldNumber: 286) } try { if let v = _storage._wktAny { try visitor.visitSingularMessageField(value: v, fieldNumber: 500) @@ -5131,7 +4509,7 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try unknownFields.traverse(visitor: &visitor) } - public static func ==(lhs: Fuzz_Testing_Message, rhs: Fuzz_Testing_Message) -> Bool { + public static func ==(lhs: SwiftProtoTesting_Fuzz_Message, rhs: SwiftProtoTesting_Fuzz_Message) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -5404,11 +4782,9 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp } } -extension Fuzz_Testing_Message.SingularGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - public static let protoMessageName: String = Fuzz_Testing_Message.protoMessageName + ".SingularGroup" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 18: .standard(proto: "group_field"), - ] +extension SwiftProtoTesting_Fuzz_Message.SingularGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = SwiftProtoTesting_Fuzz_Message.protoMessageName + ".SingularGroup" + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{12}group_field\0") public mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -5433,18 +4809,16 @@ extension Fuzz_Testing_Message.SingularGroup: SwiftProtobuf.Message, SwiftProtob try unknownFields.traverse(visitor: &visitor) } - public static func ==(lhs: Fuzz_Testing_Message.SingularGroup, rhs: Fuzz_Testing_Message.SingularGroup) -> Bool { + public static func ==(lhs: SwiftProtoTesting_Fuzz_Message.SingularGroup, rhs: SwiftProtoTesting_Fuzz_Message.SingularGroup) -> Bool { if lhs._groupField != rhs._groupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Fuzz_Testing_Message.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - public static let protoMessageName: String = Fuzz_Testing_Message.protoMessageName + ".RepeatedGroup" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 48: .standard(proto: "group_field"), - ] +extension SwiftProtoTesting_Fuzz_Message.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = SwiftProtoTesting_Fuzz_Message.protoMessageName + ".RepeatedGroup" + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}0group_field\0") public mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -5469,18 +4843,16 @@ extension Fuzz_Testing_Message.RepeatedGroup: SwiftProtobuf.Message, SwiftProtob try unknownFields.traverse(visitor: &visitor) } - public static func ==(lhs: Fuzz_Testing_Message.RepeatedGroup, rhs: Fuzz_Testing_Message.RepeatedGroup) -> Bool { + public static func ==(lhs: SwiftProtoTesting_Fuzz_Message.RepeatedGroup, rhs: SwiftProtoTesting_Fuzz_Message.RepeatedGroup) -> Bool { if lhs._groupField != rhs._groupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Fuzz_Testing_Message.OneofGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - public static let protoMessageName: String = Fuzz_Testing_Message.protoMessageName + ".OneofGroup" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 78: .standard(proto: "group_field"), - ] +extension SwiftProtoTesting_Fuzz_Message.OneofGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = SwiftProtoTesting_Fuzz_Message.protoMessageName + ".OneofGroup" + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}N\u{1}group_field\0") public mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -5505,14 +4877,14 @@ extension Fuzz_Testing_Message.OneofGroup: SwiftProtobuf.Message, SwiftProtobuf. try unknownFields.traverse(visitor: &visitor) } - public static func ==(lhs: Fuzz_Testing_Message.OneofGroup, rhs: Fuzz_Testing_Message.OneofGroup) -> Bool { + public static func ==(lhs: SwiftProtoTesting_Fuzz_Message.OneofGroup, rhs: SwiftProtoTesting_Fuzz_Message.OneofGroup) -> Bool { if lhs._groupField != rhs._groupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Fuzz_Testing_AMessageSetMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Fuzz_AMessageSetMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".AMessageSetMessage" public static let _protobuf_nameMap = SwiftProtobuf._NameMap() @@ -5522,7 +4894,7 @@ extension Fuzz_Testing_AMessageSetMessage: SwiftProtobuf.Message, SwiftProtobuf. } public mutating func decodeMessage(decoder: inout D) throws { - try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: Fuzz_Testing_AMessageSetMessage.self) + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Fuzz_AMessageSetMessage.self) } public func traverse(visitor: inout V) throws { @@ -5530,18 +4902,84 @@ extension Fuzz_Testing_AMessageSetMessage: SwiftProtobuf.Message, SwiftProtobuf. try unknownFields.traverse(visitor: &visitor) } - public static func ==(lhs: Fuzz_Testing_AMessageSetMessage, rhs: Fuzz_Testing_AMessageSetMessage) -> Bool { + public static func ==(lhs: SwiftProtoTesting_Fuzz_AMessageSetMessage, rhs: SwiftProtoTesting_Fuzz_AMessageSetMessage) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension Fuzz_Testing_SingularGroup_ext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = _protobuf_package + ".AMessageSetMessageExtension1" + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{a}a_string\0") + + public 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 10: try { try decoder.decodeSingularStringField(value: &self._aString) }() + default: break + } + } + } + + public 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 + try { if let v = self._aString { + try visitor.visitSingularStringField(value: v, fieldNumber: 10) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1, rhs: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1) -> Bool { + if lhs._aString != rhs._aString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = _protobuf_package + ".AMessageSetMessageExtension2" + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{14}an_int32\0") + + public 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 20: try { try decoder.decodeSingularInt32Field(value: &self._anInt32) }() + default: break + } + } + } + + public 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 + try { if let v = self._anInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 20) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2, rhs: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2) -> Bool { + if lhs._anInt32 != rhs._anInt32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Fuzz_SingularGroup_ext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".SingularGroup_ext" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1018: .standard(proto: "group_field"), - ] + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}z\u{f}group_field\0") public mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -5566,18 +5004,16 @@ extension Fuzz_Testing_SingularGroup_ext: SwiftProtobuf.Message, SwiftProtobuf._ try unknownFields.traverse(visitor: &visitor) } - public static func ==(lhs: Fuzz_Testing_SingularGroup_ext, rhs: Fuzz_Testing_SingularGroup_ext) -> Bool { + public static func ==(lhs: SwiftProtoTesting_Fuzz_SingularGroup_ext, rhs: SwiftProtoTesting_Fuzz_SingularGroup_ext) -> Bool { if lhs._groupField != rhs._groupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Fuzz_Testing_RepeatedGroup_ext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Fuzz_RepeatedGroup_ext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".RepeatedGroup_ext" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1048: .standard(proto: "group_field"), - ] + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}X\u{10}group_field\0") public mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -5602,7 +5038,7 @@ extension Fuzz_Testing_RepeatedGroup_ext: SwiftProtobuf.Message, SwiftProtobuf._ try unknownFields.traverse(visitor: &visitor) } - public static func ==(lhs: Fuzz_Testing_RepeatedGroup_ext, rhs: Fuzz_Testing_RepeatedGroup_ext) -> Bool { + public static func ==(lhs: SwiftProtoTesting_Fuzz_RepeatedGroup_ext, rhs: SwiftProtoTesting_Fuzz_RepeatedGroup_ext) -> Bool { if lhs._groupField != rhs._groupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/FuzzTesting/Sources/FuzzJSON/main.swift b/FuzzTesting/Sources/FuzzJSON/main.swift index b3c84e09a..898e09f4b 100644 --- a/FuzzTesting/Sources/FuzzJSON/main.swift +++ b/FuzzTesting/Sources/FuzzJSON/main.swift @@ -1,20 +1,32 @@ -import Foundation +// Copyright (c) 2014 - 2024 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +import Foundation import FuzzCommon +import SwiftProtobuf @_cdecl("LLVMFuzzerTestOneInput") public func FuzzJSON(_ start: UnsafeRawPointer, _ count: Int) -> CInt { - let bytes = UnsafeRawBufferPointer(start: start, count: count) - var msg: Fuzz_Testing_Message? - do { - msg = try Fuzz_Testing_Message( - jsonUTF8Data: Data(bytes), - extensions: Fuzz_Testing_FuzzTesting_Extensions) - } catch { - // Error parsing are to be expected since not all input will be well formed. - } - // Test serialization for completeness. - // If a message was parsed, it should not fail to serialize, so assert as such. - let _ = try! msg?.jsonString() - return 0 + guard let (options, bytes) = JSONDecodingOptions.extractOptions(start, count) else { + return 1 + } + var msg: SwiftProtoTesting_Fuzz_Message? + do { + msg = try SwiftProtoTesting_Fuzz_Message( + jsonUTF8Data: Data(bytes), + extensions: SwiftProtoTesting_Fuzz_FuzzTesting_Extensions, + options: options + ) + } catch { + // Error parsing are to be expected since not all input will be well formed. + } + // Test serialization for completeness. + // If a message was parsed, it should not fail to serialize, so assert as such. + let _ = try! msg?.jsonString() + return 0 } diff --git a/FuzzTesting/Sources/FuzzTextFormat/main.swift b/FuzzTesting/Sources/FuzzTextFormat/main.swift index d51857826..8f7531b2b 100644 --- a/FuzzTesting/Sources/FuzzTextFormat/main.swift +++ b/FuzzTesting/Sources/FuzzTextFormat/main.swift @@ -1,21 +1,33 @@ -import Foundation +// Copyright (c) 2014 - 2024 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +import Foundation import FuzzCommon +import SwiftProtobuf @_cdecl("LLVMFuzzerTestOneInput") public func FuzzTextFormat(_ start: UnsafeRawPointer, _ count: Int) -> CInt { - let bytes = UnsafeRawBufferPointer(start: start, count: count) - guard let str = String(data: Data(bytes), encoding: .utf8) else { return 0 } - var msg: Fuzz_Testing_Message? - do { - msg = try Fuzz_Testing_Message( - textFormatString: str, - extensions: Fuzz_Testing_FuzzTesting_Extensions) - } catch { - // Error parsing are to be expected since not all input will be well formed. - } - // Test serialization for completeness. - let _ = msg?.textFormatString() + guard let (options, bytes) = TextFormatDecodingOptions.extractOptions(start, count) else { + return 1 + } + guard let str = String(data: Data(bytes), encoding: .utf8) else { return 0 } + var msg: SwiftProtoTesting_Fuzz_Message? + do { + msg = try SwiftProtoTesting_Fuzz_Message( + textFormatString: str, + options: options, + extensions: SwiftProtoTesting_Fuzz_FuzzTesting_Extensions + ) + } catch { + // Error parsing are to be expected since not all input will be well formed. + } + // Test serialization for completeness. + let _ = msg?.textFormatString() - return 0 + return 0 } diff --git a/FuzzTesting/Tests/FuzzCommonTests/Test_Options.swift b/FuzzTesting/Tests/FuzzCommonTests/Test_Options.swift new file mode 100644 index 000000000..02b84f00f --- /dev/null +++ b/FuzzTesting/Tests/FuzzCommonTests/Test_Options.swift @@ -0,0 +1,280 @@ +// Copyright (c) 2014 - 2024 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +import Foundation +import FuzzCommon +import XCTest + +struct TestOptions: SupportsFuzzOptions { + + var bool1: Bool = false { + didSet { sets.append("bool1:\(bool1)") } + } + + var bool2: Bool = false { + didSet { sets.append("bool2:\(bool2)") } + } + + var int1: Int = 100 { + didSet { sets.append("int1:\(int1)") } + } + var int2: Int = 1 { + didSet { sets.append("int2:\(int2)") } + } + + var sets: [String] = [] + + static var fuzzOptionsList: [FuzzCommon.FuzzOption] = [ + .boolean(\.bool1), + .boolean(\.bool2), + .byte(\.int1), + .byte(\.int2, mod: 16), + ] + + init() {} +} + +struct TestOptionsLarge: SupportsFuzzOptions { + + var bool1: Bool = false { + didSet { sets.append("bool1:\(bool1)") } + } + var bool2: Bool = false { + didSet { sets.append("bool2:\(bool2)") } + } + var bool3: Bool = false { + didSet { sets.append("bool3:\(bool3)") } + } + var bool4: Bool = false { + didSet { sets.append("bool4:\(bool4)") } + } + var int1: Int = 100 { + didSet { sets.append("int1:\(int1)") } + } + var bool5: Bool = false { + didSet { sets.append("bool5:\(bool5)") } + } + var bool6: Bool = false { + didSet { sets.append("bool6:\(bool6)") } + } + var bool7: Bool = false { + didSet { sets.append("bool7:\(bool7)") } + } + var bool8: Bool = false { + didSet { sets.append("bool8:\(bool8)") } + } + var int2: Int = 1 { + didSet { sets.append("int2:\(int2)") } + } + + var sets: [String] = [] + + static var fuzzOptionsList: [FuzzCommon.FuzzOption] = [ + .boolean(\.bool1), + .boolean(\.bool2), + .boolean(\.bool3), + .boolean(\.bool4), + .byte(\.int1), + .boolean(\.bool5), + .boolean(\.bool6), + .boolean(\.bool7), + .boolean(\.bool8), + .byte(\.int2), + ] + + init() {} +} + +final class Test_FuzzOptions: XCTestCase { + + func testOptionBasics_noOptionsSignal() throws { + // Claim no bytes passed. + let bytes: [UInt8] = [] + XCTAssertEqual(bytes.count, 0) + try bytes.withUnsafeBytes { ptr in + let result = TestOptions.extractOptions(ptr.baseAddress!, bytes.count) + let (opts, bytes) = try XCTUnwrap(result) + XCTAssertEqual(opts.sets, []) + XCTAssertEqual(bytes.count, 0) + } + + // Try with no leading zero, so no options. + for x: UInt8 in 1...UInt8.max { + let bytes: [UInt8] = [x] + XCTAssertEqual(bytes.count, 1) + try bytes.withUnsafeBytes { ptr in + let result = TestOptions.extractOptions(ptr.baseAddress!, bytes.count) + let (opts, bytes) = try XCTUnwrap(result) + XCTAssertEqual(opts.sets, []) + // The buffer comes through. + XCTAssertEqual(bytes.count, 1) + XCTAssertEqual(bytes.baseAddress, ptr.baseAddress) + } + } + } + + func testOptionBasics_optionsSignalNoBytes() throws { + let bytes: [UInt8] = [0] // Options signal, then nothing + XCTAssertEqual(bytes.count, 1) + try bytes.withUnsafeBytes { ptr in + let result = TestOptions.extractOptions(ptr.baseAddress!, bytes.count) + let (opts, bytes) = try XCTUnwrap(result) + XCTAssertEqual(opts.sets, []) + // Since no following bytes, the buffer comes through. + XCTAssertEqual(bytes.count, 1) + XCTAssertEqual(bytes.baseAddress, ptr.baseAddress) + } + } + + func testOptionBasics_bool() throws { + let testCases: [(byte: UInt8, b1: Bool, b2: Bool, sets: [String])] = [ + (0x0, false, false, ["bool1:false", "bool2:false"]), + (0x1, true, false, ["bool1:true", "bool2:false"]), + (0x2, false, true, ["bool1:false", "bool2:true"]), + (0x3, true, true, ["bool1:true", "bool2:true"]), + ] + for test in testCases { + let bytes: [UInt8] = [0, test.byte] + XCTAssertEqual(bytes.count, 2) + try bytes.withUnsafeBytes { ptr in + let result = TestOptions.extractOptions(ptr.baseAddress!, bytes.count) + let (opts, bytes) = try XCTUnwrap(result) + XCTAssertEqual(opts.sets, test.sets) + XCTAssertEqual(bytes.count, 0) // No bytes, the one was the options + XCTAssertNotEqual(bytes.baseAddress, ptr.baseAddress) + XCTAssertEqual(opts.bool1, test.b1) + XCTAssertEqual(opts.bool2, test.b2) + } + } + } + + func testOptionBasics_byte() throws { + let testCases: [(bytes: [UInt8], i1: Int, i2: Int, sets: [String])] = [ + ([0x0], 100, 1, []), + ([0x4, 2], 2, 1, ["int1:2"]), + ([0x8, 7], 100, 7, ["int2:7"]), + ([0xC, 3, 20], 3, 4, ["int1:3", "int2:4"]), // int2 has a mod applied + ] + for test in testCases { + let bytes: [UInt8] = [0] + test.bytes + try bytes.withUnsafeBytes { ptr in + let result = TestOptions.extractOptions(ptr.baseAddress!, bytes.count) + let (opts, bytes) = try XCTUnwrap(result) + XCTAssertEqual(opts.sets, ["bool1:false", "bool2:false"] + test.sets) + XCTAssertEqual(bytes.count, 0) // No bytes, the one was the options + XCTAssertNotEqual(bytes.baseAddress, ptr.baseAddress) + XCTAssertEqual(opts.int1, test.i1) + XCTAssertEqual(opts.int2, test.i2) + } + } + } + + func testOptionBasics_byteMissingData() { + let testCases: [[UInt8]] = [ + [0x4], // int1, no data + [0x8], // int2, no data + [0xC], // int1 & int2, no data + [0xC, 20], // int1 & int2, data for only int1 + ] + for test in testCases { + let bytes: [UInt8] = [0] + test + bytes.withUnsafeBytes { ptr in + XCTAssertNil(TestOptions.extractOptions(ptr.baseAddress!, bytes.count)) + } + } + } + + func testOptionBasics_tailingZeros() { + // Try every value that will have at least one bit set above the valid ones + // to ensure it causing parsing failure. + for x: UInt8 in 0x10...UInt8.max { + let bytes: [UInt8] = [0, x] + bytes.withUnsafeBytes { ptr in + XCTAssertNil(TestOptions.extractOptions(ptr.baseAddress!, bytes.count)) + } + } + } + + func testOptionBasics_tailingMoreThan7_tailingZeros() { + // For the first byte of optionBits, just signal that there is a second, but + // then set all the expected zero bits to ensure it fails. + for x: UInt8 in 0x8...UInt8.max { + let bytes: [UInt8] = [0, 0x80, x] + bytes.withUnsafeBytes { ptr in + XCTAssertNil(TestOptions.extractOptions(ptr.baseAddress!, bytes.count)) + } + } + } + + func testOptionBasics_bytesAfterOptsComeThrough() throws { + let bytes: [UInt8] = [0, 0, 1, 2, 3] + XCTAssertEqual(bytes.count, 5) + try bytes.withUnsafeBytes { ptr in + let result = TestOptions.extractOptions(ptr.baseAddress!, bytes.count) + let (opts, bytes) = try XCTUnwrap(result) + XCTAssertEqual(opts.sets, ["bool1:false", "bool2:false"]) + XCTAssertEqual(bytes.count, 3) + XCTAssertNotEqual(bytes.baseAddress, ptr.baseAddress) + XCTAssertEqual(bytes.loadUnaligned(fromByteOffset: 0, as: UInt8.self), 1) + XCTAssertEqual(bytes.loadUnaligned(fromByteOffset: 1, as: UInt8.self), 2) + XCTAssertEqual(bytes.loadUnaligned(fromByteOffset: 2, as: UInt8.self), 3) + } + + // Make sure data is right after a bytes value also + let bytes2: [UInt8] = [0, 0x4, 20, 4, 15, 26] + try bytes2.withUnsafeBytes { ptr in + let result = TestOptions.extractOptions(ptr.baseAddress!, bytes2.count) + let (opts, bytes) = try XCTUnwrap(result) + XCTAssertEqual(opts.sets, ["bool1:false", "bool2:false", "int1:20"]) + XCTAssertEqual(bytes.count, 3) + XCTAssertNotEqual(bytes.baseAddress, ptr.baseAddress) + XCTAssertEqual(bytes.loadUnaligned(fromByteOffset: 0, as: UInt8.self), 4) + XCTAssertEqual(bytes.loadUnaligned(fromByteOffset: 1, as: UInt8.self), 15) + XCTAssertEqual(bytes.loadUnaligned(fromByteOffset: 2, as: UInt8.self), 26) + } + + // Options that can spill to two bytes for the optionBits. + + // Only one byte of optionsBits + let bytes3: [UInt8] = [0, 0, 1, 2, 3] + XCTAssertEqual(bytes3.count, 5) + try bytes3.withUnsafeBytes { ptr in + let result = TestOptionsLarge.extractOptions(ptr.baseAddress!, bytes3.count) + let (opts, bytes) = try XCTUnwrap(result) + XCTAssertEqual( + opts.sets, + ["bool1:false", "bool2:false", "bool3:false", "bool4:false", "bool5:false", "bool6:false"] + ) + XCTAssertEqual(bytes.count, 3) + XCTAssertNotEqual(bytes.baseAddress, ptr.baseAddress) + XCTAssertEqual(bytes.loadUnaligned(fromByteOffset: 0, as: UInt8.self), 1) + XCTAssertEqual(bytes.loadUnaligned(fromByteOffset: 1, as: UInt8.self), 2) + XCTAssertEqual(bytes.loadUnaligned(fromByteOffset: 2, as: UInt8.self), 3) + } + + // Two bytes of optionsBits with a `byte` value + let bytes4: [UInt8] = [0, 0x90, 123, 0x4, 20, 81, 92, 103] + XCTAssertEqual(bytes4.count, 8) + try bytes4.withUnsafeBytes { ptr in + let result = TestOptionsLarge.extractOptions(ptr.baseAddress!, bytes4.count) + let (opts, bytes) = try XCTUnwrap(result) + XCTAssertEqual( + opts.sets, + [ + "bool1:false", "bool2:false", "bool3:false", "bool4:false", "int1:123", "bool5:false", + "bool6:false", "bool7:false", "bool8:false", "int2:20", + ] + ) + XCTAssertEqual(bytes.count, 3) + XCTAssertNotEqual(bytes.baseAddress, ptr.baseAddress) + XCTAssertEqual(bytes.loadUnaligned(fromByteOffset: 0, as: UInt8.self), 81) + XCTAssertEqual(bytes.loadUnaligned(fromByteOffset: 1, as: UInt8.self), 92) + XCTAssertEqual(bytes.loadUnaligned(fromByteOffset: 2, as: UInt8.self), 103) + } + } +} diff --git a/FuzzTesting/do_build.sh b/FuzzTesting/do_build.sh index 5b5a0ebea..48fb6b596 100755 --- a/FuzzTesting/do_build.sh +++ b/FuzzTesting/do_build.sh @@ -31,7 +31,14 @@ OPTIONS: EOF } -FUZZ_TESTS=("FuzzBinary" "FuzzJSON" "FuzzTextFormat") +FUZZ_TESTS=( + "FuzzBinary" + "FuzzBinaryDelimited" + "FuzzAsyncMessageSequence" + "FuzzJSON" + "FuzzTextFormat" +) +RUN_TESTS="yes" CHECK_REGRESSIONS="no" # Default to both CMD_CONFIGS=("debug" "release") @@ -54,6 +61,9 @@ while [[ $# != 0 ]]; do --run-regressions | --run ) CHECK_REGRESSIONS="yes" ;; + --skip-tests ) + RUN_TESTS="no" + ;; -*) echo "ERROR: Unknown option: ${1}" 1>&2 printUsage @@ -70,6 +80,12 @@ done cd "${FuzzTestingDir}" +if [[ "${RUN_TESTS}" == "yes" ]] ; then + echo "------------------------------------------------------------------------------------------" + echo "Testing: swift test" + swift test +fi + declare -a CMD_BASE if [ "$(uname)" == "Darwin" ]; then CMD_BASE=( diff --git a/Makefile b/Makefile index 50a5757fd..e9788cd6a 100644 --- a/Makefile +++ b/Makefile @@ -11,8 +11,6 @@ # make regenerate # Recompile all the necessary protos # (requires protoc in path) -# make test-xcode[-NAME]: -# Runs the tests in the Xcode project in the requested mode(s). # # Caution: 'test' does not 'regenerate', so if you've made changes to the code # generation, you'll need to do more than just 'test': @@ -27,10 +25,11 @@ # 'swift test', etc commands. SWIFT=swift -# How to run a working version of protoc. Invoke make with PROTOC=[path] to -# override this value, i.e. - +# How to run a working version of protoc. By default, we build our own copy +# from the submodule using Swift Package Manager. Invoke make with PROTOC=[path] +# to override this value, i.e. - # make [TARGET] PROTOC=../protobuf/src/protoc -PROTOC=protoc +PROTOC?=.build/debug/protoc # How to run awk on your system AWK=awk @@ -41,173 +40,59 @@ BINDIR=/usr/local/bin # Install tool name INSTALL=install -# Where to find a google/protobuf checkout. Defaults be being beside this -# checkout. Invoke make with GOOGLE_PROTOBUF_CHECKOUT=[PATH_TO_CHECKOUT] to +# Where to find a google/protobuf checkout. Defaults to the submodule. +# Invoke make with GOOGLE_PROTOBUF_CHECKOUT=[PATH_TO_CHECKOUT] to # override this value, i.e. - # make [TARGET] GOOGLE_PROTOBUF_CHECKOUT=[PATH_TO_CHECKOUT] -GOOGLE_PROTOBUF_CHECKOUT?=../protobuf +GOOGLE_PROTOBUF_CHECKOUT?=Sources/protobuf/protobuf # Helpers for the common parts of source generation. # # To ensure that the local version of the plugin is always used (and not a # previously installed one), we use a custom output name (-tfiws_out). PROTOC_GEN_SWIFT=.build/debug/protoc-gen-swift -GENERATE_SRCS_BASE=${PROTOC} --plugin=protoc-gen-tfiws=${PROTOC_GEN_SWIFT} -# Until the flag isn't needed, add the flag to enable proto3 optional. -GENERATE_SRCS=${GENERATE_SRCS_BASE} -I Protos --experimental_allow_proto3_optional +# Need to provide paths to find the language specific editions features files +# also. If we used a released protoc distro, they would be bundled like the WKTs. +GENERATE_SRCS_BASE=${PROTOC} --plugin=protoc-gen-tfiws=${PROTOC_GEN_SWIFT} -I Protos/upstream/go -I Protos/upstream/java/core/src/main/resources +# Search 'Protos/Sources/SwiftProtobuf/' so the WKTs can be found (google/protobuf/*). +GENERATE_SRCS=${GENERATE_SRCS_BASE} -I Protos/Sources/SwiftProtobuf # Where to find the Swift conformance test runner executable. SWIFT_CONFORMANCE_PLUGIN=.build/debug/Conformance -# If you have already build conformance-test-runner in -# a nearby directory, just set the full path here and -# we'll use it instead. -CONFORMANCE_HOST=${GOOGLE_PROTOBUF_CHECKOUT}/conformance/conformance-test-runner +# Where to find the conformance-test-runner. Defaults to being in your protobuf +# checkout when built with CMake. Invoke make with +# CONFORMANCE_TEST_RUNNER=[PATH_TO_BINARY] to override this value. +CONFORMANCE_TEST_RUNNER?=${GOOGLE_PROTOBUF_CHECKOUT}/cmake_build/conformance_test_runner -# NOTE: TEST_PROTOS, LIBRARY_PROTOS, and PLUGIN_PROTOS are all full paths so -# eventually we might be able to do proper dependencies and use them as inputs -# for other rules (we'll also likely need outputs). -# -# But since plugin is also Swift code using the runtime, there's a bit of -# recursion that doesn't lend itself to easily being resolved; as the build -# could create a new plugin that in turn could cause new sources need to -# generated, which in turns means the plugin needs to be rebuilt... -# -# It might be easier in the long run to give up on make, and instead have a -# script that does the build and then generation and checks to see if generated -# source change, and if it doesn't errors out to have the developer restart -# the process so they stabilize. - -# Protos used for the unit and functional tests -TEST_PROTOS= \ - Protos/conformance/conformance.proto \ - Protos/generated_swift_names_enums.proto \ - Protos/generated_swift_names_enum_cases.proto \ - Protos/generated_swift_names_fields.proto \ - Protos/generated_swift_names_messages.proto \ - Protos/google/protobuf/any_test.proto \ - Protos/google/protobuf/map_proto2_unittest.proto \ - Protos/google/protobuf/map_unittest.proto \ - Protos/google/protobuf/test_messages_proto3.proto \ - Protos/google/protobuf/unittest.proto \ - Protos/google/protobuf/unittest_arena.proto \ - Protos/google/protobuf/unittest_custom_options.proto \ - Protos/google/protobuf/unittest_drop_unknown_fields.proto \ - Protos/google/protobuf/unittest_embed_optimize_for.proto \ - Protos/google/protobuf/unittest_empty.proto \ - Protos/google/protobuf/unittest_import.proto \ - Protos/google/protobuf/unittest_import_lite.proto \ - Protos/google/protobuf/unittest_import_public.proto \ - Protos/google/protobuf/unittest_import_public_lite.proto \ - Protos/google/protobuf/unittest_lite.proto \ - Protos/google/protobuf/unittest_lite_imports_nonlite.proto \ - Protos/google/protobuf/unittest_mset.proto \ - Protos/google/protobuf/unittest_mset_wire_format.proto \ - Protos/google/protobuf/unittest_no_field_presence.proto \ - Protos/google/protobuf/unittest_no_generic_services.proto \ - Protos/google/protobuf/unittest_optimize_for.proto \ - Protos/google/protobuf/unittest_preserve_unknown_enum.proto \ - Protos/google/protobuf/unittest_preserve_unknown_enum2.proto \ - Protos/google/protobuf/unittest_proto3.proto \ - Protos/google/protobuf/unittest_proto3_arena.proto \ - Protos/google/protobuf/unittest_proto3_optional.proto \ - Protos/google/protobuf/unittest_well_known_types.proto \ - Protos/fuzz_testing.proto \ - Protos/unittest_swift_all_required_types.proto \ - Protos/unittest_swift_cycle.proto \ - Protos/unittest_swift_enum.proto \ - Protos/unittest_swift_enum_optional_default.proto \ - Protos/unittest_swift_enum_proto3.proto \ - Protos/unittest_swift_extension.proto \ - Protos/unittest_swift_extension2.proto \ - Protos/unittest_swift_extension3.proto \ - Protos/unittest_swift_extension4.proto \ - Protos/unittest_swift_fieldorder.proto \ - Protos/unittest_swift_groups.proto \ - Protos/unittest_swift_json.proto \ - Protos/unittest_swift_naming.proto \ - Protos/unittest_swift_naming_no_prefix.proto \ - Protos/unittest_swift_naming_number_prefix.proto \ - Protos/unittest_swift_oneof_all_required.proto \ - Protos/unittest_swift_oneof_merging.proto \ - Protos/unittest_swift_performance.proto \ - Protos/unittest_swift_reserved.proto \ - Protos/unittest_swift_reserved_ext.proto \ - Protos/unittest_swift_runtime_proto2.proto \ - Protos/unittest_swift_runtime_proto3.proto \ - Protos/unittest_swift_startup.proto - -# TODO: The library and plugin Protos come directly from google sources. -# There should be an easy way to copy the Google versions from a protobuf -# checkout into this project. - -# Protos that are embedded into the SwiftProtobuf runtime library module -LIBRARY_PROTOS= \ - Protos/google/protobuf/any.proto \ - Protos/google/protobuf/api.proto \ - Protos/google/protobuf/descriptor.proto \ - Protos/google/protobuf/duration.proto \ - Protos/google/protobuf/empty.proto \ - Protos/google/protobuf/field_mask.proto \ - Protos/google/protobuf/source_context.proto \ - Protos/google/protobuf/struct.proto \ - Protos/google/protobuf/timestamp.proto \ - Protos/google/protobuf/type.proto \ - Protos/google/protobuf/wrappers.proto - -# Protos that are used internally by the plugin -PLUGIN_PROTOS= \ - Protos/google/protobuf/compiler/plugin.proto \ - Protos/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.proto - -# Protos that are used by the conformance test runner. -CONFORMANCE_PROTOS= \ - Protos/conformance/conformance.proto \ - Protos/google/protobuf/test_messages_proto2.proto \ - Protos/google/protobuf/test_messages_proto3.proto - -SWIFT_DESCRIPTOR_TEST_PROTOS= \ - Protos/pluginlib_descriptor_test.proto \ - Protos/pluginlib_descriptor_test2.proto \ - ${PLUGIN_PROTOS} - -XCODEBUILD_EXTRAS = -# Invoke make with XCODE_SKIP_OPTIMIZER=1 to suppress the optimizer when -# building the Xcode projects. For Release builds, this is a non trivial speed -# up for compilation -XCODE_SKIP_OPTIMIZER=0 -ifeq "$(XCODE_SKIP_OPTIMIZER)" "1" - XCODEBUILD_EXTRAS += SWIFT_OPTIMIZATION_LEVEL=-Onone -endif - -# Invoke make with XCODE_ANALYZE=1 to enable the analyzer while building the -# Xcode projects. -XCODE_ANALYZE=0 -ifeq "$(XCODE_ANALYZE)" "1" - XCODEBUILD_EXTRAS += RUN_CLANG_STATIC_ANALYZER=YES CLANG_STATIC_ANALYZER_MODE=deep -endif - -# Invoke make with XCODE_NOISY to get the default output of everything little -# thing Xcode does. -XCODE_NOISY=0 -ifeq "$(XCODE_NOISY)" "0" - XCODEBUILD_EXTRAS += -quiet -endif +# Hook to pass arge to swift build|test (mainly for the CI setup) +SWIFT_BUILD_TEST_HOOK?= + +# The directories within Protos/ with the exception of "upstream". Use for the +# maintenance of the 'Reference' target and test-plugin. +PROTOS_DIRS=Sources/Conformance Sources/SwiftProtobuf Sources/SwiftProtobufPluginLibrary Tests/protoc-gen-swiftTests Tests/SwiftProtobufPluginLibraryTests Tests/SwiftProtobufTests .PHONY: \ all \ build \ check \ + check-for-conformance-runner \ check-for-protobuf-checkout \ check-proto-files \ check-version-numbers \ clean \ - conformance-host \ + compile-tests \ + compile-tests-multimodule \ + compile-tests-internalimportsbydefault \ default \ docs \ install \ + pod-lib-lint \ reference \ regenerate \ + regenerate-compiletests-multimodule-protos \ + copy-compiletests-internalimportsbydefault-protos \ + regenerate-compiletests-protos \ regenerate-conformance-protos \ regenerate-fuzz-protos \ regenerate-library-protos \ @@ -218,62 +103,31 @@ endif test-everything \ test-plugin \ test-runtime \ - test-xcode \ - test-xcode-debug \ - test-xcode-release \ - test-xcode-iOS \ - test-xcode-iOS-debug \ - test-xcode-iOS-release \ - test-xcode-macOS \ - test-xcode-macOS-debug \ - test-xcode-macOS-release \ - test-xcode-tvOS \ - test-xcode-tvOS-debug \ - test-xcode-tvOS-release \ - test-xcode-watchOS \ - test-xcode-watchOS-debug \ - test-xcode-watchOS-release \ + test-spm-plugin \ update-proto-files -.NOTPARALLEL: \ - test-xcode-iOS-debug \ - test-xcode-iOS-release \ - test-xcode-macOS-debug \ - test-xcode-macOS-release \ - test-xcode-tvOS-debug \ - test-xcode-tvOS-release \ - test-xcode-watchOS-debug \ - test-xcode-watchOS-release - default: build all: build -# This also rebuilds LinuxMain.swift to include all of the test cases. -# (The awk script is very fast, so re-running it on every build is reasonable, -# but we only update the file when it changes to avoid extra builds.) -# (Someday, 'swift test' will learn how to auto-discover test cases on Linux, -# at which time this will no longer be needed.) +# Builds all the targets of the package. build: - @${AWK} -f DevTools/CollectTests.awk Tests/*/Test_*.swift > Tests/LinuxMain.swift.new - @if ! cmp -s Tests/LinuxMain.swift.new Tests/LinuxMain.swift; then \ - cp Tests/LinuxMain.swift.new Tests/LinuxMain.swift; \ - echo "FYI: Tests/LinuxMain.swift Updated"; \ - fi - @rm Tests/LinuxMain.swift.new - ${SWIFT} build + ${SWIFT} build ${SWIFT_BUILD_TEST_HOOK} # Anything that needs the plugin should do a build. ${PROTOC_GEN_SWIFT}: build +# Build our local copy of protoc from the submodule +${PROTOC}: build + # Does it really make sense to install a debug build, or should this be forcing # a release build and then installing that instead? install: build ${INSTALL} ${PROTOC_GEN_SWIFT} ${BINDIR} clean: - swift package clean - rm -rf .build _test ${PROTOC_GEN_SWIFT} DescriptorTestData.bin \ + ${SWIFT} package clean + rm -rf .build _test ${PROTOC_GEN_SWIFT} *DescriptorTestData.bin \ Performance/_generated Performance/_results Protos/mined_words.txt \ docs build find . -name '*~' | xargs rm -f @@ -294,8 +148,8 @@ docs: # check test: build test-runtime test-plugin test-conformance check-version-numbers -# Test everything (runtime, plugin, xcode project) -test-all test-everything: test test-xcode +# Test everything (runtime, plugin) +test-all test-everything: test # Check the version numbers are all in sync. check-version-numbers: @@ -306,7 +160,7 @@ check-version-numbers: # and functional tests for the Swift code generated by the plugin. # test-runtime: build - ${SWIFT} test + ${SWIFT} test ${SWIFT_BUILD_TEST_HOOK} # # Test the plugin by itself: @@ -326,28 +180,108 @@ test-runtime: build # Note: Some of these protos define the same package.(message|enum)s, so they # can't be done in a single protoc/proto-gen-swift invoke and have to be done # one at a time instead. -test-plugin: build ${PROTOC_GEN_SWIFT} - @rm -rf _test && mkdir _test - for p in `find Protos/ -type f -name '*.proto'`; do \ - ${GENERATE_SRCS} --tfiws_out=_test $$p || exit 1; \ +test-plugin: build ${PROTOC_GEN_SWIFT} ${PROTOC} + @rm -rf _test && mkdir -p _test/upstream + for p in `find Protos/upstream -type f -name '*.proto'`; do \ + ${GENERATE_SRCS_BASE} \ + -I Protos/upstream \ + --tfiws_out=_test/upstream $$p || exit 1; \ done + for d in ${PROTOS_DIRS}; do \ + mkdir -p _test/$$d ; \ + ${GENERATE_SRCS_BASE} \ + -I Protos/Sources/SwiftProtobuf \ + -I Protos/Sources/SwiftProtobufPluginLibrary \ + -I Protos/$$d \ + --tfiws_out=_test/$$d \ + `find Protos/$$d -type f -name "*.proto"` || exit 1; \ + done + @mkdir -p _test/CompileTests/MultiModule + ${GENERATE_SRCS} \ + -I Protos/CompileTests/MultiModule \ + --tfiws_opt=Visibility=Public \ + --tfiws_opt=ProtoPathModuleMappings=Protos/CompileTests/MultiModule/module_mappings.pbascii \ + --tfiws_out=_test/CompileTests/MultiModule \ + `(find Protos/CompileTests/MultiModule -type f -name "*.proto")` + @mkdir -p _test/CompileTests/InternalImportsByDefault + ${GENERATE_SRCS} \ + -I Protos/CompileTests/InternalImportsByDefault \ + --tfiws_opt=Visibility=Public \ + --tfiws_opt=UseAccessLevelOnImports=true \ + --tfiws_out=_test/CompileTests/InternalImportsByDefault \ + `(find Protos/CompileTests/InternalImportsByDefault -type f -name "*.proto")` diff -ru _test Reference -# +# Test the SPM plugin. +# TODO: simplify this when swift 5.10 support is dropped. +test-spm-plugin: + @SWIFT_VERSION=$$(${SWIFT} --version | head -n1 | sed 's/.*Swift version \([0-9]*\)\..*/\1/'); \ + if [ "$$SWIFT_VERSION" -lt 6 ]; then \ + env PROTOC_PATH=$$(realpath ${PROTOC}) ${SWIFT} test --package-path PluginExamples; \ + else \ + ${SWIFT} test --package-path PluginExamples; \ + fi + +compile-tests: \ + compile-tests-multimodule \ + compile-tests-internalimportsbydefault + +# Test that ensures generating public into multiple modules with `import public` +# yields buildable code. +compile-tests-multimodule: + ${SWIFT} test --package-path CompileTests/MultiModule + +# Test that ensures that using access level modifiers on imports yields code that's buildable +# when `InternalImportsByDefault` is enabled on the module. +# TODO: simplify this when swift 5.10 support is dropped. +compile-tests-internalimportsbydefault: + @SWIFT_VERSION=$$(${SWIFT} --version | head -n1 | sed 's/.*Swift version \([0-9]*\)\..*/\1/'); \ + if [ "$$SWIFT_VERSION" -lt 6 ]; then \ + env PROTOC_PATH=$$(realpath ${PROTOC}) ${SWIFT} build --package-path CompileTests/InternalImportsByDefault; \ + else \ + ${SWIFT} build --package-path CompileTests/InternalImportsByDefault; \ + fi + + # Rebuild the reference files by running the local version of protoc-gen-swift # against our menagerie of sample protos. # # If you do this, you MUST MANUALLY verify these files before checking them in, # since the new checkin will become the new main reference. # -# Note: Some of these protos define the same package.(message|enum)s, so they -# can't be done in a single protoc/proto-gen-swift invoke and have to be done -# one at a time instead. -reference: build ${PROTOC_GEN_SWIFT} - @rm -rf Reference && mkdir Reference - for p in `find Protos/ -type f -name '*.proto'`; do \ - ${GENERATE_SRCS} --tfiws_out=Reference $$p || exit 1; \ +# Note: Some of the upstream protos define the same package.(message|enum)s, so +# they can't be done in a single protoc/proto-gen-swift invoke and have to be +# done one at a time instead. +reference: build ${PROTOC_GEN_SWIFT} ${PROTOC} + @rm -rf Reference && mkdir -p Reference/upstream + for p in `find Protos/upstream -type f -name '*.proto'`; do \ + ${GENERATE_SRCS_BASE} \ + -I Protos/upstream \ + --tfiws_out=Reference/upstream $$p || exit 1; \ done + for d in ${PROTOS_DIRS}; do \ + mkdir -p Reference/$$d ; \ + ${GENERATE_SRCS_BASE} \ + -I Protos/Sources/SwiftProtobuf \ + -I Protos/Sources/SwiftProtobufPluginLibrary \ + -I Protos/$$d \ + --tfiws_out=Reference/$$d \ + `find Protos/$$d -type f -name "*.proto"` || exit 1; \ + done + @mkdir -p Reference/CompileTests/MultiModule + ${GENERATE_SRCS} \ + -I Protos/CompileTests/MultiModule \ + --tfiws_opt=Visibility=Public \ + --tfiws_opt=ProtoPathModuleMappings=Protos/CompileTests/MultiModule/module_mappings.pbascii \ + --tfiws_out=Reference/CompileTests/MultiModule \ + `(find Protos/CompileTests/MultiModule -type f -name "*.proto")` + @mkdir -p Reference/CompileTests/InternalImportsByDefault + ${GENERATE_SRCS} \ + -I Protos/CompileTests/InternalImportsByDefault \ + --tfiws_opt=Visibility=Public \ + --tfiws_opt=UseAccessLevelOnImports=true \ + --tfiws_out=Reference/CompileTests/InternalImportsByDefault \ + `(find Protos/CompileTests/InternalImportsByDefault -type f -name "*.proto")` # # Rebuild the generated .pb.swift test files by running @@ -363,63 +297,138 @@ regenerate: \ regenerate-fuzz-protos \ regenerate-plugin-protos \ regenerate-test-protos \ + regenerate-compiletests-protos \ regenerate-conformance-protos \ - Tests/SwiftProtobufPluginLibraryTests/DescriptorTestData.swift + Sources/SwiftProtobufPluginLibrary/PluginLibEditionDefaults.swift \ + Tests/protoc-gen-swiftTests/DescriptorTestData.swift \ + Tests/SwiftProtobufPluginLibraryTests/DescriptorTestData.swift \ + Tests/SwiftProtobufPluginLibraryTests/PluginLibTestingEditionDefaults.swift # Rebuild just the protos included in the runtime library -regenerate-library-protos: build ${PROTOC_GEN_SWIFT} +# NOTE: dependencies doesn't include the source .proto files, should fix that; +# would also need to list all the outputs. +regenerate-library-protos: build ${PROTOC_GEN_SWIFT} ${PROTOC} find Sources/SwiftProtobuf -name "*.pb.swift" -exec rm -f {} \; ${GENERATE_SRCS} \ --tfiws_opt=FileNaming=DropPath \ --tfiws_opt=Visibility=Public \ --tfiws_out=Sources/SwiftProtobuf \ - ${LIBRARY_PROTOS} + `find Protos/Sources/SwiftProtobuf -type f -name "*.proto"` # Rebuild just the protos used by the plugin -regenerate-plugin-protos: build ${PROTOC_GEN_SWIFT} +# NOTE: dependencies doesn't include the source .proto files, should fix that; +# would also need to list all the outputs. +regenerate-plugin-protos: build ${PROTOC_GEN_SWIFT} ${PROTOC} find Sources/SwiftProtobufPluginLibrary -name "*.pb.swift" -exec rm -f {} \; ${GENERATE_SRCS} \ + -I Protos/Sources/SwiftProtobufPluginLibrary \ --tfiws_opt=FileNaming=DropPath \ --tfiws_opt=Visibility=Public \ --tfiws_out=Sources/SwiftProtobufPluginLibrary \ - ${PLUGIN_PROTOS} + `find Protos/Sources/SwiftProtobufPluginLibrary -type f -name "*.proto"` -# Rebuild just the protos used by the runtime test suite -# Note: Some of these protos define the same package.(message|enum)s, so they -# can't be done in a single protoc/proto-gen-swift invoke and have to be done -# one at a time instead. -regenerate-test-protos: build ${PROTOC_GEN_SWIFT} Protos/generated_swift_names_enums.proto Protos/generated_swift_names_enum_cases.proto Protos/generated_swift_names_fields.proto Protos/generated_swift_names_messages.proto +# Is this based on the upstream bazel rules `compile_edition_defaults` and +# `embed_edition_defaults`. +Sources/SwiftProtobufPluginLibrary/PluginLibEditionDefaults.swift: build ${PROTOC_GEN_SWIFT} ${PROTOC} Protos/Sources/SwiftProtobuf/google/protobuf/descriptor.proto + @${PROTOC} \ + --edition_defaults_out=PluginLibEditionDefaults.bin \ + --edition_defaults_minimum=PROTO2 \ + --edition_defaults_maximum=2024 \ + -I Protos/Sources/SwiftProtobuf \ + Protos/Sources/SwiftProtobuf/google/protobuf/descriptor.proto + @rm -f $@ + @echo '// See Makefile how this is generated.' >> $@ + @echo '// swift-format-ignore-file' >> $@ + @echo 'import Foundation' >> $@ + @echo 'let bundledFeatureSetDefaultBytes: [UInt8] = [' >> $@ + @xxd -i < PluginLibEditionDefaults.bin >> $@ + @echo ']' >> $@ + +# Some defaults for the testing of custom features +Tests/SwiftProtobufPluginLibraryTests/PluginLibTestingEditionDefaults.swift: build ${PROTOC_GEN_SWIFT} ${PROTOC} Protos/Tests/SwiftProtobufPluginLibraryTests/test_features.proto + @${PROTOC} \ + --edition_defaults_out=PluginLibTestingEditionDefaults.bin \ + --edition_defaults_minimum=PROTO2 \ + --edition_defaults_maximum=2024 \ + -I Protos/Sources/SwiftProtobuf \ + -I Protos/Tests/SwiftProtobufPluginLibraryTests \ + Protos/Tests/SwiftProtobufPluginLibraryTests/test_features.proto + @rm -f $@ + @echo '// See Makefile how this is generated.' >> $@ + @echo '// swift-format-ignore-file' >> $@ + @echo 'import Foundation' >> $@ + @echo 'let testFeatureSetDefaultBytes: [UInt8] = [' >> $@ + @xxd -i < PluginLibTestingEditionDefaults.bin >> $@ + @echo ']' >> $@ + +# Rebuild just the protos used by the tests +# NOTE: dependencies doesn't include the source .proto files, should fix that; +# would also need to list all the outputs. +regenerate-test-protos: build ${PROTOC_GEN_SWIFT} ${PROTOC} Protos/Tests/SwiftProtobufTests/generated_swift_names_enums.proto Protos/Tests/SwiftProtobufTests/generated_swift_names_enum_cases.proto Protos/Tests/SwiftProtobufTests/generated_swift_names_fields.proto Protos/Tests/SwiftProtobufTests/generated_swift_names_messages.proto find Tests/SwiftProtobufTests -name "*.pb.swift" -exec rm -f {} \; ${GENERATE_SRCS} \ + -I Protos/Tests/SwiftProtobufTests \ --tfiws_opt=FileNaming=DropPath \ --tfiws_out=Tests/SwiftProtobufTests \ - ${TEST_PROTOS} + `find Protos/Tests/SwiftProtobufTests -type f -name "*.proto"` + find Tests/SwiftProtobufPluginLibraryTests -name "*.pb.swift" -exec rm -f {} \; + ${GENERATE_SRCS} \ + -I Protos/Tests/SwiftProtobufPluginLibraryTests \ + --tfiws_opt=FileNaming=DropPath \ + --tfiws_out=Tests/SwiftProtobufPluginLibraryTests \ + `find Protos/Tests/SwiftProtobufPluginLibraryTests -type f -name "*.proto"` -# Rebuild just the protos used by the plugin -regenerate-fuzz-protos: build ${PROTOC_GEN_SWIFT} +# Rebuild the protos for FuzzTesting/Sources/FuzzCommon, the file lives in the +# Protos/Tests/SwiftProtobufTests to have just one copy. +regenerate-fuzz-protos: build ${PROTOC_GEN_SWIFT} ${PROTOC} find FuzzTesting/Sources/FuzzCommon -name "*.pb.swift" -exec rm -f {} \; ${GENERATE_SRCS} \ + -I Protos/Tests/SwiftProtobufTests \ --tfiws_opt=FileNaming=DropPath \ --tfiws_opt=Visibility=Public \ --tfiws_out=FuzzTesting/Sources/FuzzCommon \ - Protos/fuzz_testing.proto + Protos/Tests/SwiftProtobufTests/fuzz_testing.proto + +SWIFT_PLUGINLIB_DESCRIPTOR_TEST_PROTOS= \ + Protos/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test.proto \ + Protos/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test2.proto \ + Protos/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test_import.proto \ + Protos/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_delimited.proto \ + Protos/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited.proto \ + Protos/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited_import.proto \ + Protos/Sources/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.proto + +Tests/SwiftProtobufPluginLibraryTests/DescriptorTestData.swift: build ${PROTOC_GEN_SWIFT} ${PROTOC} ${SWIFT_PLUGINLIB_DESCRIPTOR_TEST_PROTOS} + @${PROTOC} \ + --include_source_info \ + --descriptor_set_out=PluginLibDescriptorTestData.bin \ + -I Protos/Sources/SwiftProtobuf \ + -I Protos/Sources/SwiftProtobufPluginLibrary \ + -I Protos/Tests/SwiftProtobufPluginLibraryTests \ + ${SWIFT_PLUGINLIB_DESCRIPTOR_TEST_PROTOS} + @rm -f $@ + @echo '// See Makefile how this is generated.' >> $@ + @echo '// swift-format-ignore-file' >> $@ + @echo 'import Foundation' >> $@ + @echo 'let fileDescriptorSetBytes: [UInt8] = [' >> $@ + @xxd -i < PluginLibDescriptorTestData.bin >> $@ + @echo ']' >> $@ + +SWIFT_PLUGIN_DESCRIPTOR_TEST_PROTOS= \ + Protos/Tests/protoc-gen-swiftTests/plugin_descriptor_test.proto -Tests/SwiftProtobufPluginLibraryTests/DescriptorTestData.swift: build ${PROTOC_GEN_SWIFT} ${SWIFT_DESCRIPTOR_TEST_PROTOS} - # Until the flag isn't needed, add the flag to enable proto3 optional. +Tests/protoc-gen-swiftTests/DescriptorTestData.swift: build ${PROTOC_GEN_SWIFT} ${PROTOC} ${SWIFT_PLUGIN_DESCRIPTOR_TEST_PROTOS} @${PROTOC} \ - --experimental_allow_proto3_optional \ - --include_imports \ - --descriptor_set_out=DescriptorTestData.bin \ - -I Protos \ - ${SWIFT_DESCRIPTOR_TEST_PROTOS} + --descriptor_set_out=PluginDescriptorTestData.bin \ + -I Protos/Tests/protoc-gen-swiftTests \ + ${SWIFT_PLUGIN_DESCRIPTOR_TEST_PROTOS} @rm -f $@ @echo '// See Makefile how this is generated.' >> $@ @echo '// swift-format-ignore-file' >> $@ @echo 'import Foundation' >> $@ @echo 'let fileDescriptorSetBytes: [UInt8] = [' >> $@ - @xxd -i < DescriptorTestData.bin >> $@ + @xxd -i < PluginDescriptorTestData.bin >> $@ @echo ']' >> $@ - @echo 'let fileDescriptorSetData = Data(fileDescriptorSetBytes)' >> $@ # # Collect a list of words that appear in the SwiftProtobuf library @@ -429,23 +438,27 @@ Tests/SwiftProtobufPluginLibraryTests/DescriptorTestData.swift: build ${PROTOC_G # = Look at every Swift source file in the library # = Take every line with the word 'public', 'func', or 'var' # = Remove any comments from the line. +# = Remove any string literals from the line. # = Break each such line into words (stripping all punctuation) # = Remove words that differ only in case +# = Remove anything that will cause proto parsing issues (things named "reserved") # # Selecting lines with 'public', 'func' or 'var' ensures we get every # public protocol, struct, enum, or class name, as well as every # method or property defined in a public protocol, struct, or class. # It also gives us a large collection of Swift names. -Protos/mined_words.txt: Sources/SwiftProtobuf/* +Protos/mined_words.txt: Sources/SwiftProtobuf/*.swift @echo Building $@ - @cat Sources/SwiftProtobuf/* | \ + @cat $^ | \ grep -E '\b(public|func|var)\b' | \ grep -vE '\b(private|internal|fileprivate)\b' | \ sed -e 's|//.*$$||g' | \ + sed -e 's|"\([^"\\]*\\.\)*[^"]*"||g' | \ sed -e 's/[^a-zA-Z0-9_]/ /g' | \ tr " " "\n" | \ sed -e 's/^_//' | \ sort -uf | \ + grep -vE '(reserved)' | \ grep '^[a-zA-Z_]' > $@ # Build some proto files full of landmines @@ -462,62 +475,86 @@ Protos/mined_words.txt: Sources/SwiftProtobuf/* # might cause problems. Failures compiling this indicate weaknesses # in protoc-gen-swift's name sanitization logic. # -Protos/generated_swift_names_fields.proto: Protos/mined_words.txt +Protos/Tests/SwiftProtobufTests/generated_swift_names_fields.proto: Protos/mined_words.txt @echo Building $@ @rm $@ @echo '// See Makefile for the logic that generates this' >> $@ @echo '// Protoc errors imply this file is being generated incorrectly' >> $@ @echo '// Swift compile errors are probably bugs in protoc-gen-swift' >> $@ @echo 'syntax = "proto3";' >> $@ - @echo 'package protobuf_unittest_generated;' >> $@ + @echo 'package swift_proto_testing.generated;' >> $@ @echo 'message GeneratedSwiftReservedFields {' >> $@ - @cat Protos/mined_words.txt | awk 'BEGIN{n = 1} {print " int32 " $$1 " = " n ";"; n += 1 }' >> $@ + @cat Protos/mined_words.txt | ${AWK} 'BEGIN{n = 1} {print " int32 " $$1 " = " n ";"; n += 1 }' >> $@ @echo '}' >> $@ -Protos/generated_swift_names_enum_cases.proto: Protos/mined_words.txt +Protos/Tests/SwiftProtobufTests/generated_swift_names_enum_cases.proto: Protos/mined_words.txt @echo Building $@ @rm $@ @echo '// See Makefile for the logic that generates this' >> $@ @echo '// Protoc errors imply this file is being generated incorrectly' >> $@ @echo '// Swift compile errors are probably bugs in protoc-gen-swift' >> $@ @echo 'syntax = "proto3";' >> $@ - @echo 'package protobuf_unittest_generated;' >> $@ + @echo 'package swift_proto_testing.generated;' >> $@ @echo 'enum GeneratedSwiftReservedEnum {' >> $@ @echo ' NONE = 0;' >> $@ - @cat Protos/mined_words.txt | awk 'BEGIN{n = 1} {print " " $$1 " = " n ";"; n += 1 }' >> $@ + @cat Protos/mined_words.txt | ${AWK} 'BEGIN{n = 1} {print " " $$1 " = " n ";"; n += 1 }' >> $@ @echo '}' >> $@ -Protos/generated_swift_names_messages.proto: Protos/mined_words.txt +Protos/Tests/SwiftProtobufTests/generated_swift_names_messages.proto: Protos/mined_words.txt @echo Building $@ @rm $@ @echo '// See Makefile for the logic that generates this' >> $@ @echo '// Protoc errors imply this file is being generated incorrectly' >> $@ @echo '// Swift compile errors are probably bugs in protoc-gen-swift' >> $@ @echo 'syntax = "proto3";' >> $@ - @echo 'package protobuf_unittest_generated;' >> $@ + @echo 'package swift_proto_testing.generated;' >> $@ @echo 'message GeneratedSwiftReservedMessages {' >> $@ - @cat Protos/mined_words.txt | awk '{print " message " $$1 " { int32 " $$1 " = 1; }"}' >> $@ + @cat Protos/mined_words.txt | ${AWK} '{print " message " $$1 " { int32 " $$1 " = 1; }"}' >> $@ @echo '}' >> $@ -Protos/generated_swift_names_enums.proto: Protos/mined_words.txt +Protos/Tests/SwiftProtobufTests/generated_swift_names_enums.proto: Protos/mined_words.txt @echo Building $@ @rm $@ @echo '// See Makefile for the logic that generates this' >> $@ @echo '// Protoc errors imply this file is being generated incorrectly' >> $@ @echo '// Swift compile errors are probably bugs in protoc-gen-swift' >> $@ @echo 'syntax = "proto3";' >> $@ - @echo 'package protobuf_unittest_generated;' >> $@ + @echo 'package swift_proto_testing.generated;' >> $@ @echo 'message GeneratedSwiftReservedEnums {' >> $@ - @cat Protos/mined_words.txt | awk '{print " enum " $$1 " { NONE_" $$1 " = 0; }"}' >> $@ + @cat Protos/mined_words.txt | ${AWK} '{print " enum " $$1 " { NONE_" $$1 " = 0; }"}' >> $@ @echo '}' >> $@ # Rebuild just the protos used by the conformance test runner. -regenerate-conformance-protos: build ${PROTOC_GEN_SWIFT} +regenerate-conformance-protos: build ${PROTOC_GEN_SWIFT} ${PROTOC} find Sources/Conformance -name "*.pb.swift" -exec rm -f {} \; ${GENERATE_SRCS} \ + -I Protos/Sources/Conformance \ --tfiws_opt=FileNaming=DropPath \ --tfiws_out=Sources/Conformance \ - ${CONFORMANCE_PROTOS} + `find Protos/Sources/Conformance -type f -name "*.proto"` + +# Rebuild just the protos used by the CompileTests. +regenerate-compiletests-protos: \ + regenerate-compiletests-multimodule-protos \ + copy-compiletests-internalimportsbydefault-protos + +# Update the CompileTests/MultiModule files. +# NOTE: Any changes here must also be done on the "test-plugin" target so it +# generates in the same way. +regenerate-compiletests-multimodule-protos: build ${PROTOC_GEN_SWIFT} ${PROTOC} + find CompileTests/MultiModule -name "*.pb.swift" -exec rm -f {} \; + ${GENERATE_SRCS} \ + -I Protos/CompileTests/MultiModule \ + --tfiws_opt=Visibility=Public \ + --tfiws_opt=ProtoPathModuleMappings=Protos/CompileTests/MultiModule/module_mappings.pbascii \ + --tfiws_out=CompileTests/MultiModule \ + `(find Protos/CompileTests/MultiModule -type f -name "*.proto")` + +# We use the plugin for the InternalImportsByDefault test, so we don't actually need to regenerate +# anything. However, to keep the protos centralised in a single place (the Protos directory), +# this simply copies those files to the InternalImportsByDefault package in case they change. +copy-compiletests-internalimportsbydefault-protos: + @cp Protos/CompileTests/InternalImportsByDefault/* CompileTests/InternalImportsByDefault/Sources/InternalImportsByDefault/Protos # Helper to check if there is a protobuf checkout as expected. check-for-protobuf-checkout: @@ -531,125 +568,103 @@ check-for-protobuf-checkout: # # Helper to update the .proto files copied from the protocolbuffers/protobuf distro. # +# (We also have to pick up some the the [LANG]_features.proto files for language +# specific Editions, if when generating we used a release protoc, then they would +# be copied like the WKTs to live "next too" the compiler and we wouldn't need to +# provide them on input paths.) +# update-proto-files: check-for-protobuf-checkout - @rm -rf Protos/conformance && mkdir Protos/conformance - @cp -v "${GOOGLE_PROTOBUF_CHECKOUT}"/conformance/*.proto Protos/conformance/ - @rm -rf Protos/google && mkdir -p Protos/google/protobuf/compiler - @cp -v "${GOOGLE_PROTOBUF_CHECKOUT}"/src/google/protobuf/*.proto Protos/google/protobuf/ - @cp -v "${GOOGLE_PROTOBUF_CHECKOUT}"/src/google/protobuf/compiler/*.proto Protos/google/protobuf/compiler/ + @rm -rf Protos/upstream + @mkdir -p \ + Protos/upstream/conformance/test_protos \ + Protos/upstream/google/protobuf/compiler \ + Protos/upstream/editions/golden \ + Protos/upstream/go/google/protobuf \ + Protos/upstream/java/core/src/main/resources/google/protobuf + @cp -v "${GOOGLE_PROTOBUF_CHECKOUT}"/conformance/*.proto Protos/upstream/conformance/ + @cp -v "${GOOGLE_PROTOBUF_CHECKOUT}"/conformance/test_protos/*.proto Protos/upstream/conformance/test_protos/ + @cp -v "${GOOGLE_PROTOBUF_CHECKOUT}"/src/google/protobuf/*.proto Protos/upstream/google/protobuf/ + @cp -v "${GOOGLE_PROTOBUF_CHECKOUT}"/src/google/protobuf/compiler/*.proto Protos/upstream/google/protobuf/compiler/ + @cp -v "${GOOGLE_PROTOBUF_CHECKOUT}"/editions/golden/test_messages_proto?_editions.proto Protos/upstream/editions/golden/ + @cp -v "${GOOGLE_PROTOBUF_CHECKOUT}"/go/google/protobuf/*_features.proto Protos/upstream/go/google/protobuf/ + @cp -v "${GOOGLE_PROTOBUF_CHECKOUT}"/java/core/src/main/resources/google/protobuf/*_features.proto Protos/upstream/java/core/src/main/resources/google/protobuf/ + # Now copy into the Proto directories for the local targets. + @rm -rf Protos/Sources/Conformance/conformance/test_protos && mkdir -p Protos/Sources/Conformance/conformance/test_protos + @cp -v Protos/upstream/conformance/*.proto Protos/Sources/Conformance/conformance + @cp -v Protos/upstream/conformance/test_protos/*.proto Protos/Sources/Conformance/conformance/test_protos + @rm -rf Protos/Sources/Conformance/google && mkdir -p Protos/Sources/Conformance/google/protobuf Protos/Sources/Conformance/editions + @cp -v \ + Protos/upstream/google/protobuf/test_messages_proto2.proto \ + Protos/upstream/google/protobuf/test_messages_proto3.proto \ + Protos/Sources/Conformance/google/protobuf/ + @cp -v \ + Protos/upstream/editions/golden/test_messages_proto2_editions.proto \ + Protos/upstream/editions/golden/test_messages_proto3_editions.proto \ + Protos/Sources/Conformance/editions/ + @rm -rf Protos/Sources/SwiftProtobuf/google && mkdir -p Protos/Sources/SwiftProtobuf/google/protobuf + @cp -v \ + Protos/upstream/google/protobuf/timestamp.proto \ + Protos/upstream/google/protobuf/field_mask.proto \ + Protos/upstream/google/protobuf/api.proto \ + Protos/upstream/google/protobuf/duration.proto \ + Protos/upstream/google/protobuf/struct.proto \ + Protos/upstream/google/protobuf/wrappers.proto \ + Protos/upstream/google/protobuf/source_context.proto \ + Protos/upstream/google/protobuf/any.proto \ + Protos/upstream/google/protobuf/type.proto \ + Protos/upstream/google/protobuf/empty.proto \ + Protos/upstream/google/protobuf/descriptor.proto \ + Protos/Sources/SwiftProtobuf/google/protobuf + @rm -rf Protos/Sources/SwiftProtobufPluginLibrary/google && mkdir -p Protos/Sources/SwiftProtobufPluginLibrary/google/protobuf/compiler + @cp -v Protos/upstream/google/protobuf/compiler/*.proto Protos/Sources/SwiftProtobufPluginLibrary/google/protobuf/compiler # # Helper to see if update-proto-files should be done # +# Usually want to also provide `GOOGLE_PROTOBUF_CHECKOUT=some_local_head_protobuf` so +# you are checking against a state this project hasn't adopted yet. +# +# Since there are multiple things to check we direct the diffs all into a file and check +# at the end. check-proto-files: check-for-protobuf-checkout - @for p in `cd ${GOOGLE_PROTOBUF_CHECKOUT} && ls conformance/*.proto`; do \ - diff -u "Protos/$$p" "${GOOGLE_PROTOBUF_CHECKOUT}/$$p" \ - || (echo "ERROR: Time to do a 'make update-proto-files'" && exit 1); \ + @rm -f _check_protos.txt && touch _check_protos.txt + @for p in `cd ${GOOGLE_PROTOBUF_CHECKOUT} && ls conformance/*.proto conformance/test_protos/*.proto`; do \ + diff -u "Protos/upstream/$$p" "${GOOGLE_PROTOBUF_CHECKOUT}/$$p" >> _check_protos.txt; \ done @for p in `cd ${GOOGLE_PROTOBUF_CHECKOUT}/src && ls google/protobuf/*.proto | grep -v test`; do \ - diff -u "Protos/$$p" "${GOOGLE_PROTOBUF_CHECKOUT}/src/$$p" \ - || (echo "ERROR: Time to do a 'make update-proto-files'" && exit 1); \ + diff -u "Protos/upstream/$$p" "${GOOGLE_PROTOBUF_CHECKOUT}/src/$$p" >> _check_protos.txt; \ done @for p in `cd ${GOOGLE_PROTOBUF_CHECKOUT}/src && ls google/protobuf/compiler/*.proto`; do \ - diff -u "Protos/$$p" "${GOOGLE_PROTOBUF_CHECKOUT}/src/$$p" \ - || (echo "ERROR: Time to do a 'make update-proto-files'" && exit 1); \ + diff -u "Protos/upstream/$$p" "${GOOGLE_PROTOBUF_CHECKOUT}/src/$$p" >> _check_protos.txt; \ done + @if [ -s _check_protos.txt ] ; then \ + cat _check_protos.txt; \ + rm -f _check_protos.txt; \ + echo "ERROR: Time to do a 'make update-proto-files'"; \ + exit 1; \ + else \ + rm -f _check_protos.txt; \ + fi + +check-for-conformance-runner: + @if [ ! -x "${CONFORMANCE_TEST_RUNNER}" ]; then \ + echo "ERROR: ${CONFORMANCE_TEST_RUNNER} does not appear to exist"; \ + echo "ERROR: built build it or set CONFORMANCE_TEST_RUNNER to point"; \ + echo "ERROR: a runner."; \ + exit 1; \ + fi # Runs the conformance tests. -test-conformance: build check-for-protobuf-checkout $(CONFORMANCE_HOST) Sources/Conformance/failure_list_swift.txt Sources/Conformance/text_format_failure_list_swift.txt - ( \ - ABS_PBDIR=`cd ${GOOGLE_PROTOBUF_CHECKOUT}; pwd`; \ - $${ABS_PBDIR}/conformance/conformance-test-runner \ - --enforce_recommended \ - --failure_list Sources/Conformance/failure_list_swift.txt \ - --text_format_failure_list Sources/Conformance/text_format_failure_list_swift.txt\ - $(SWIFT_CONFORMANCE_PLUGIN); \ - ) - -# The 'conformance-host' program is part of the protobuf project. -# It generates test cases, feeds them to our plugin, and verifies the results: -conformance-host $(CONFORMANCE_HOST): check-for-protobuf-checkout - @if [ ! -f "${GOOGLE_PROTOBUF_CHECKOUT}/Makefile" ]; then \ - echo "No Makefile, running autogen.sh and configure." ; \ - ( cd ${GOOGLE_PROTOBUF_CHECKOUT} && \ - ./autogen.sh && \ - ./configure ) \ +test-conformance: check-for-conformance-runner build Sources/Conformance/failure_list_swift.txt Sources/Conformance/text_format_failure_list_swift.txt + $(CONFORMANCE_TEST_RUNNER) \ + --enforce_recommended \ + --failure_list Sources/Conformance/failure_list_swift.txt \ + --text_format_failure_list Sources/Conformance/text_format_failure_list_swift.txt \ + --maximum_edition 2024 \ + $(SWIFT_CONFORMANCE_PLUGIN) + +# Validate the CocoaPods podspec file against the current tree state. +pod-lib-lint: + @if [ `uname -s` = "Darwin" ] ; then \ + pod lib lint SwiftProtobuf.podspec ; \ fi - $(MAKE) -C ${GOOGLE_PROTOBUF_CHECKOUT}/src - $(MAKE) -C ${GOOGLE_PROTOBUF_CHECKOUT}/conformance - - -# Helpers to put the Xcode project through all modes. - -# Grouping targets -test-xcode: test-xcode-iOS test-xcode-macOS test-xcode-tvOS test-xcode-watchOS -test-xcode-iOS: test-xcode-iOS-debug test-xcode-iOS-release -test-xcode-macOS: test-xcode-macOS-debug test-xcode-macOS-release -test-xcode-tvOS: test-xcode-tvOS-debug test-xcode-tvOS-release -test-xcode-watchOS: test-xcode-watchOS-debug test-xcode-watchOS-release -test-xcode-debug: test-xcode-iOS-debug test-xcode-macOS-debug test-xcode-tvOS-debug test-xcode-watchOS-debug -test-xcode-release: test-xcode-iOS-release test-xcode-macOS-release test-xcode-tvOS-release test-xcode-watchOS-release - -# The individual ones - -test-xcode-iOS-debug: - xcodebuild -project SwiftProtobuf.xcodeproj \ - -scheme SwiftProtobuf_iOS \ - -configuration Debug \ - -destination "platform=iOS Simulator,name=iPhone 8,OS=latest" \ - -disable-concurrent-destination-testing \ - test $(XCODEBUILD_EXTRAS) - -# Release defaults to not supporting testing, so add ENABLE_TESTABILITY=YES -# to ensure the main library gets testing support. -test-xcode-iOS-release: - xcodebuild -project SwiftProtobuf.xcodeproj \ - -scheme SwiftProtobuf_iOS \ - -configuration Release \ - -destination "platform=iOS Simulator,name=iPhone 8,OS=latest" \ - -disable-concurrent-destination-testing \ - test ENABLE_TESTABILITY=YES $(XCODEBUILD_EXTRAS) - -test-xcode-macOS-debug: - xcodebuild -project SwiftProtobuf.xcodeproj \ - -scheme SwiftProtobuf_macOS \ - -configuration Debug \ - build test $(XCODEBUILD_EXTRAS) - -# Release defaults to not supporting testing, so add ENABLE_TESTABILITY=YES -# to ensure the main library gets testing support. -test-xcode-macOS-release: - xcodebuild -project SwiftProtobuf.xcodeproj \ - -scheme SwiftProtobuf_macOS \ - -configuration Release \ - build test ENABLE_TESTABILITY=YES $(XCODEBUILD_EXTRAS) - -test-xcode-tvOS-debug: - xcodebuild -project SwiftProtobuf.xcodeproj \ - -scheme SwiftProtobuf_tvOS \ - -configuration Debug \ - -destination "platform=tvOS Simulator,name=Apple TV,OS=latest" \ - build test $(XCODEBUILD_EXTRAS) - -# Release defaults to not supporting testing, so add ENABLE_TESTABILITY=YES -# to ensure the main library gets testing support. -test-xcode-tvOS-release: - xcodebuild -project SwiftProtobuf.xcodeproj \ - -scheme SwiftProtobuf_tvOS \ - -configuration Release \ - -destination "platform=tvOS Simulator,name=Apple TV,OS=latest" \ - build test ENABLE_TESTABILITY=YES $(XCODEBUILD_EXTRAS) - -# watchOS doesn't support tests, just do a build. -test-xcode-watchOS-debug: - xcodebuild -project SwiftProtobuf.xcodeproj \ - -scheme SwiftProtobuf_watchOS \ - -configuration Debug \ - build $(XCODEBUILD_EXTRAS) - -# watchOS doesn't support tests, just do a build. -test-xcode-watchOS-release: - xcodebuild -project SwiftProtobuf.xcodeproj \ - -scheme SwiftProtobuf_watchOS \ - -configuration Release \ - build $(XCODEBUILD_EXTRAS) diff --git a/Package.swift b/Package.swift index 198c2e733..d13064687 100644 --- a/Package.swift +++ b/Package.swift @@ -1,4 +1,4 @@ -// swift-tools-version:4.2 +// swift-tools-version:6.2 // Package.swift // @@ -12,24 +12,422 @@ import PackageDescription let package = Package( - name: "SwiftProtobuf", - products: [ - .executable(name: "protoc-gen-swift", targets: ["protoc-gen-swift"]), - .library(name: "SwiftProtobuf", targets: ["SwiftProtobuf"]), - .library(name: "SwiftProtobufPluginLibrary", targets: ["SwiftProtobufPluginLibrary"]), - ], - targets: [ - .target(name: "SwiftProtobuf"), - .target(name: "SwiftProtobufPluginLibrary", - dependencies: ["SwiftProtobuf"]), - .target(name: "protoc-gen-swift", - dependencies: ["SwiftProtobufPluginLibrary", "SwiftProtobuf"]), - .target(name: "Conformance", - dependencies: ["SwiftProtobuf"]), - .testTarget(name: "SwiftProtobufTests", - dependencies: ["SwiftProtobuf"]), - .testTarget(name: "SwiftProtobufPluginLibraryTests", - dependencies: ["SwiftProtobufPluginLibrary"]), - ], - swiftLanguageVersions: [.v4, .v4_2, .version("5")] + name: "SwiftProtobuf", + products: [ + .executable( + name: "protoc-gen-swift", + targets: ["protoc-gen-swift"] + ), + .executable( + name: "protoc", + targets: ["protoc"] + ), + .library( + name: "SwiftProtobuf", + targets: ["SwiftProtobuf"] + ), + .library( + name: "SwiftProtobufPluginLibrary", + targets: ["SwiftProtobufPluginLibrary"] + ), + .plugin( + name: "SwiftProtobufPlugin", + targets: ["SwiftProtobufPlugin"] + ), + ], + targets: [ + .target( + name: "SwiftProtobuf", + exclude: ["CMakeLists.txt"], + resources: [.copy("PrivacyInfo.xcprivacy")], + swiftSettings: .packageSettings + ), + .target( + name: "SwiftProtobufPluginLibrary", + dependencies: ["SwiftProtobuf"], + exclude: ["CMakeLists.txt"], + resources: [.copy("PrivacyInfo.xcprivacy")], + swiftSettings: .packageSettings + ), + .target( + name: "SwiftProtobufTestHelpers", + dependencies: ["SwiftProtobuf"], + swiftSettings: .packageSettings + ), + .executableTarget( + name: "protoc", + path: "Sources/protobuf", + exclude: [ + "abseil/PrivacyInfo.xcprivacy" + ], + sources: [ + // protoc main + "protobuf/src/google/protobuf/compiler/main_no_generators.cc", + + // libprotoc + "protobuf/src/google/protobuf/any.cc", + "protobuf/src/google/protobuf/any.pb.cc", + "protobuf/src/google/protobuf/any_lite.cc", + "protobuf/src/google/protobuf/api.pb.cc", + "protobuf/src/google/protobuf/arena.cc", + "protobuf/src/google/protobuf/arenastring.cc", + "protobuf/src/google/protobuf/arenaz_sampler.cc", + "protobuf/src/google/protobuf/arena_align.cc", + "protobuf/src/google/protobuf/compiler/code_generator.cc", + "protobuf/src/google/protobuf/compiler/command_line_interface.cc", + "protobuf/src/google/protobuf/compiler/code_generator_lite.cc", + "protobuf/src/google/protobuf/compiler/versions.cc", + "protobuf/src/google/protobuf/compiler/subprocess.cc", + "protobuf/src/google/protobuf/compiler/importer.cc", + "protobuf/src/google/protobuf/compiler/parser.cc", + "protobuf/src/google/protobuf/compiler/plugin.cc", + "protobuf/src/google/protobuf/compiler/plugin.pb.cc", + "protobuf/src/google/protobuf/compiler/zip_writer.cc", + "protobuf/src/google/protobuf/compiler/retention.cc", + + // libprotobuf + "protobuf/src/google/protobuf/cpp_features.pb.cc", + "protobuf/src/google/protobuf/descriptor.cc", + "protobuf/src/google/protobuf/descriptor.pb.cc", + "protobuf/src/google/protobuf/descriptor_database.cc", + "protobuf/src/google/protobuf/duration.pb.cc", + "protobuf/src/google/protobuf/dynamic_message.cc", + "protobuf/src/google/protobuf/empty.pb.cc", + "protobuf/src/google/protobuf/extension_set.cc", + "protobuf/src/google/protobuf/extension_set_heavy.cc", + "protobuf/src/google/protobuf/feature_resolver.cc", + "protobuf/src/google/protobuf/field_mask.pb.cc", + "protobuf/src/google/protobuf/generated_enum_util.cc", + "protobuf/src/google/protobuf/generated_message_bases.cc", + "protobuf/src/google/protobuf/generated_message_reflection.cc", + "protobuf/src/google/protobuf/generated_message_tctable_full.cc", + "protobuf/src/google/protobuf/generated_message_tctable_gen.cc", + "protobuf/src/google/protobuf/generated_message_tctable_lite.cc", + "protobuf/src/google/protobuf/generated_message_util.cc", + "protobuf/src/google/protobuf/implicit_weak_message.cc", + "protobuf/src/google/protobuf/inlined_string_field.cc", + "protobuf/src/google/protobuf/internal_feature_helper.cc", + "protobuf/src/google/protobuf/io/coded_stream.cc", + "protobuf/src/google/protobuf/io/gzip_stream.cc", + "protobuf/src/google/protobuf/io/io_win32.cc", + "protobuf/src/google/protobuf/io/printer.cc", + "protobuf/src/google/protobuf/io/strtod.cc", + "protobuf/src/google/protobuf/io/tokenizer.cc", + "protobuf/src/google/protobuf/io/zero_copy_sink.cc", + "protobuf/src/google/protobuf/io/zero_copy_stream.cc", + "protobuf/src/google/protobuf/io/zero_copy_stream_impl.cc", + "protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.cc", + "protobuf/src/google/protobuf/json/internal/lexer.cc", + "protobuf/src/google/protobuf/json/internal/message_path.cc", + "protobuf/src/google/protobuf/json/internal/parser.cc", + "protobuf/src/google/protobuf/json/internal/unparser.cc", + "protobuf/src/google/protobuf/json/internal/untyped_message.cc", + "protobuf/src/google/protobuf/json/internal/writer.cc", + "protobuf/src/google/protobuf/json/internal/zero_copy_buffered_stream.cc", + "protobuf/src/google/protobuf/json/json.cc", + "protobuf/src/google/protobuf/map.cc", + "protobuf/src/google/protobuf/map_field.cc", + "protobuf/src/google/protobuf/message.cc", + "protobuf/src/google/protobuf/message_lite.cc", + "protobuf/src/google/protobuf/micro_string.cc", + "protobuf/src/google/protobuf/parse_context.cc", + "protobuf/src/google/protobuf/port.cc", + "protobuf/src/google/protobuf/raw_ptr.cc", + "protobuf/src/google/protobuf/reflection_mode.cc", + "protobuf/src/google/protobuf/reflection_ops.cc", + "protobuf/src/google/protobuf/repeated_field.cc", + "protobuf/src/google/protobuf/repeated_ptr_field.cc", + "protobuf/src/google/protobuf/service.cc", + "protobuf/src/google/protobuf/source_context.pb.cc", + "protobuf/src/google/protobuf/struct.pb.cc", + "protobuf/src/google/protobuf/stubs/common.cc", + "protobuf/src/google/protobuf/text_format.cc", + "protobuf/src/google/protobuf/timestamp.pb.cc", + "protobuf/src/google/protobuf/type.pb.cc", + "protobuf/src/google/protobuf/unknown_field_set.cc", + "protobuf/src/google/protobuf/util/delimited_message_util.cc", + "protobuf/src/google/protobuf/util/field_comparator.cc", + "protobuf/src/google/protobuf/util/field_mask_util.cc", + "protobuf/src/google/protobuf/util/message_differencer.cc", + "protobuf/src/google/protobuf/util/time_util.cc", + "protobuf/src/google/protobuf/util/type_resolver_util.cc", + "protobuf/src/google/protobuf/wire_format.cc", + "protobuf/src/google/protobuf/wire_format_lite.cc", + "protobuf/src/google/protobuf/wrappers.pb.cc", + + // abseil + "abseil/absl/base/internal/cycleclock.cc", + "abseil/absl/base/internal/low_level_alloc.cc", + "abseil/absl/base/internal/raw_logging.cc", + "abseil/absl/base/internal/spinlock.cc", + "abseil/absl/base/internal/spinlock_wait.cc", + "abseil/absl/base/internal/strerror.cc", + "abseil/absl/base/internal/sysinfo.cc", + "abseil/absl/base/internal/tracing.cc", + "abseil/absl/base/internal/thread_identity.cc", + "abseil/absl/base/internal/throw_delegate.cc", + "abseil/absl/base/internal/unscaledcycleclock.cc", + "abseil/absl/container/internal/raw_hash_set.cc", + "abseil/absl/container/internal/hashtablez_sampler.cc", + "abseil/absl/container/internal/hashtablez_sampler_force_weak_definition.cc", + "abseil/absl/crc/crc32c.cc", + "abseil/absl/crc/internal/cpu_detect.cc", + "abseil/absl/crc/internal/crc.cc", + "abseil/absl/crc/internal/crc_cord_state.cc", + "abseil/absl/crc/internal/crc_memcpy_fallback.cc", + "abseil/absl/crc/internal/crc_memcpy_x86_arm_combined.cc", + "abseil/absl/crc/internal/crc_non_temporal_memcpy.cc", + "abseil/absl/crc/internal/crc_x86_arm_combined.cc", + "abseil/absl/debugging/internal/address_is_readable.cc", + "abseil/absl/debugging/internal/decode_rust_punycode.cc", + "abseil/absl/debugging/internal/demangle.cc", + "abseil/absl/debugging/internal/demangle_rust.cc", + "abseil/absl/debugging/internal/elf_mem_image.cc", + "abseil/absl/debugging/internal/examine_stack.cc", + "abseil/absl/debugging/internal/utf8_for_code_point.cc", + "abseil/absl/debugging/internal/vdso_support.cc", + "abseil/absl/debugging/leak_check.cc", + "abseil/absl/debugging/stacktrace.cc", + "abseil/absl/debugging/symbolize.cc", + "abseil/absl/hash/internal/city.cc", + "abseil/absl/hash/internal/hash.cc", + "abseil/absl/hash/internal/low_level_hash.cc", + "abseil/absl/log/die_if_null.cc", + "abseil/absl/log/globals.cc", + "abseil/absl/log/initialize.cc", + "abseil/absl/log/internal/check_op.cc", + "abseil/absl/log/internal/conditions.cc", + "abseil/absl/log/internal/globals.cc", + "abseil/absl/log/internal/log_format.cc", + "abseil/absl/log/internal/log_message.cc", + "abseil/absl/log/internal/log_sink_set.cc", + "abseil/absl/log/internal/nullguard.cc", + "abseil/absl/log/internal/proto.cc", + "abseil/absl/log/internal/structured_proto.cc", + "abseil/absl/log/log_sink.cc", + "abseil/absl/numeric/int128.cc", + "abseil/absl/profiling/internal/exponential_biased.cc", + "abseil/absl/status/status.cc", + "abseil/absl/status/statusor.cc", + "abseil/absl/status/status_payload_printer.cc", + "abseil/absl/status/internal/status_internal.cc", + "abseil/absl/strings/ascii.cc", + "abseil/absl/strings/charconv.cc", + "abseil/absl/strings/cord.cc", + "abseil/absl/strings/cord_analysis.cc", + "abseil/absl/strings/escaping.cc", + "abseil/absl/strings/internal/charconv_bigint.cc", + "abseil/absl/strings/internal/charconv_parse.cc", + "abseil/absl/strings/internal/cordz_functions.cc", + "abseil/absl/strings/internal/cordz_handle.cc", + "abseil/absl/strings/internal/cordz_info.cc", + "abseil/absl/strings/internal/cord_internal.cc", + "abseil/absl/strings/internal/cord_rep_btree.cc", + "abseil/absl/strings/internal/cord_rep_btree_navigator.cc", + "abseil/absl/strings/internal/cord_rep_btree_reader.cc", + "abseil/absl/strings/internal/cord_rep_consume.cc", + "abseil/absl/strings/internal/cord_rep_crc.cc", + "abseil/absl/strings/internal/damerau_levenshtein_distance.cc", + "abseil/absl/strings/internal/escaping.cc", + "abseil/absl/strings/internal/memutil.cc", + "abseil/absl/strings/internal/ostringstream.cc", + "abseil/absl/strings/internal/stringify_sink.cc", + "abseil/absl/strings/internal/str_format/arg.cc", + "abseil/absl/strings/internal/str_format/bind.cc", + "abseil/absl/strings/internal/str_format/extension.cc", + "abseil/absl/strings/internal/str_format/float_conversion.cc", + "abseil/absl/strings/internal/str_format/output.cc", + "abseil/absl/strings/internal/str_format/parser.cc", + "abseil/absl/strings/internal/utf8.cc", + "abseil/absl/strings/match.cc", + "abseil/absl/strings/numbers.cc", + "abseil/absl/strings/string_view.cc", + "abseil/absl/strings/str_cat.cc", + "abseil/absl/strings/str_replace.cc", + "abseil/absl/strings/str_split.cc", + "abseil/absl/strings/substitute.cc", + "abseil/absl/synchronization/barrier.cc", + "abseil/absl/synchronization/blocking_counter.cc", + "abseil/absl/synchronization/internal/create_thread_identity.cc", + "abseil/absl/synchronization/internal/graphcycles.cc", + "abseil/absl/synchronization/internal/per_thread_sem.cc", + "abseil/absl/synchronization/internal/kernel_timeout.cc", + "abseil/absl/synchronization/internal/pthread_waiter.cc", + "abseil/absl/synchronization/internal/stdcpp_waiter.cc", + "abseil/absl/synchronization/internal/futex_waiter.cc", + "abseil/absl/synchronization/internal/sem_waiter.cc", + "abseil/absl/synchronization/internal/win32_waiter.cc", + "abseil/absl/synchronization/internal/waiter_base.cc", + "abseil/absl/synchronization/mutex.cc", + "abseil/absl/synchronization/notification.cc", + "abseil/absl/time/civil_time.cc", + "abseil/absl/time/clock.cc", + "abseil/absl/time/duration.cc", + "abseil/absl/time/format.cc", + "abseil/absl/time/internal/cctz/src/time_zone_fixed.cc", + "abseil/absl/time/internal/cctz/src/time_zone_format.cc", + "abseil/absl/time/internal/cctz/src/time_zone_if.cc", + "abseil/absl/time/internal/cctz/src/time_zone_impl.cc", + "abseil/absl/time/internal/cctz/src/time_zone_info.cc", + "abseil/absl/time/internal/cctz/src/time_zone_libc.cc", + "abseil/absl/time/internal/cctz/src/time_zone_lookup.cc", + "abseil/absl/time/internal/cctz/src/time_zone_posix.cc", + "abseil/absl/time/internal/cctz/src/zone_info_source.cc", + "abseil/absl/time/time.cc", + + // utf8 validation + "protobuf/third_party/utf8_range/utf8_range.c", + + // UPB files + "protobuf/upb/base/status.c", + "protobuf/upb/mem/alloc.c", + "protobuf/upb/mem/arena.c", + "protobuf/upb/wire/decode.c", + "protobuf/upb/wire/encode.c", + "protobuf/upb/wire/eps_copy_input_stream.c", + "protobuf/upb/wire/reader.c", + "protobuf/upb/wire/byte_size.c", + "protobuf/upb/wire/internal/decoder.c", + "protobuf/upb/wire/decode_fast/dispatch.c", + "protobuf/upb/wire/decode_fast/field_fixed.c", + "protobuf/upb/wire/decode_fast/field_generic.c", + "protobuf/upb/wire/decode_fast/field_message.c", + "protobuf/upb/wire/decode_fast/field_string.c", + "protobuf/upb/wire/decode_fast/field_varint.c", + "protobuf/upb/wire/decode_fast/function_array.c", + "protobuf/upb/wire/decode_fast/select.c", + "protobuf/upb/hash/common.c", + "protobuf/upb/message/accessors.c", + "protobuf/upb/message/array.c", + "protobuf/upb/message/compare.c", + "protobuf/upb/message/copy.c", + "protobuf/upb/message/map.c", + "protobuf/upb/message/map_sorter.c", + "protobuf/upb/message/merge.c", + "protobuf/upb/message/message.c", + "protobuf/upb/message/promote.c", + "protobuf/upb/message/internal/compare_unknown.c", + "protobuf/upb/message/internal/extension.c", + "protobuf/upb/message/internal/iterator.c", + "protobuf/upb/message/internal/message.c", + "protobuf/upb/mini_table/compat.c", + "protobuf/upb/mini_table/extension_registry.c", + "protobuf/upb/mini_table/message.c", + "protobuf/upb/mini_table/internal/message.c", + "protobuf/upb/mini_descriptor/build_enum.c", + "protobuf/upb/mini_descriptor/decode.c", + "protobuf/upb/mini_descriptor/link.c", + "protobuf/upb/mini_descriptor/internal/base92.c", + "protobuf/upb/mini_descriptor/internal/encode.c", + "protobuf/upb/reflection/def_pool.c", + "protobuf/upb/reflection/def_type.c", + "protobuf/upb/reflection/desc_state.c", + "protobuf/upb/reflection/enum_def.c", + "protobuf/upb/reflection/enum_reserved_range.c", + "protobuf/upb/reflection/enum_value_def.c", + "protobuf/upb/reflection/extension_range.c", + "protobuf/upb/reflection/field_def.c", + "protobuf/upb/reflection/file_def.c", + "protobuf/upb/reflection/message.c", + "protobuf/upb/reflection/message_def.c", + "protobuf/upb/reflection/message_reserved_range.c", + "protobuf/upb/reflection/method_def.c", + "protobuf/upb/reflection/oneof_def.c", + "protobuf/upb/reflection/service_def.c", + "protobuf/upb/reflection/stage0/google/protobuf/descriptor.upb.c", + "protobuf/upb/reflection/internal/def_builder.c", + "protobuf/upb/reflection/internal/strdup2.c", + "protobuf/upb/text/debug_string.c", + "protobuf/upb/text/encode.c", + "protobuf/upb/text/internal/encode.c", + + // UPB lex files for round trip functions + "protobuf/upb/lex/round_trip.c", + + // upb_generator additional files (minimal set) + "protobuf/upb_generator/plugin.cc", + "protobuf/upb_generator/common.cc", + "protobuf/upb_generator/common/names.cc", + "protobuf/upb_generator/file_layout.cc", + "protobuf/upb_generator/minitable/names.cc", + "protobuf/upb_generator/minitable/names_internal.cc", + ], + cSettings: [ + .disableWarning("conversion"), + .disableWarning("deprecated-declarations"), + ], + cxxSettings: [ + .headerSearchPath("abseil/"), + .headerSearchPath("protobuf/"), + .headerSearchPath("protobuf/third_party/utf8_range/"), + .headerSearchPath("protobuf/src/"), + .headerSearchPath("protobuf/upb/"), + .headerSearchPath("protobuf/upb_generator/"), + .define("UPB_BOOTSTRAP_STAGE", to: "0"), + .disableWarning("conversion"), + .disableWarning("deprecated-declarations"), + ], + linkerSettings: [ + .linkedFramework( + "CoreFoundation", + .when( + platforms: [ + .macOS, + .macCatalyst, + .iOS, + .tvOS, + .watchOS, + .visionOS, + ] + ) + ), + .linkedLibrary("m"), + ] + ), + .executableTarget( + name: "protoc-gen-swift", + dependencies: ["SwiftProtobufPluginLibrary", "SwiftProtobuf"], + exclude: ["CMakeLists.txt"], + swiftSettings: .packageSettings + ), + .executableTarget( + name: "Conformance", + dependencies: ["SwiftProtobuf"], + exclude: ["failure_list_swift.txt", "text_format_failure_list_swift.txt"], + swiftSettings: .packageSettings + ), + .plugin( + name: "SwiftProtobufPlugin", + capability: .buildTool(), + dependencies: ["protoc-gen-swift", "protoc"] + ), + .testTarget( + name: "SwiftProtobufTests", + dependencies: ["SwiftProtobuf"], + swiftSettings: .packageSettings + ), + .testTarget( + name: "SwiftProtobufPluginLibraryTests", + dependencies: ["SwiftProtobufPluginLibrary", "SwiftProtobufTestHelpers"], + swiftSettings: .packageSettings + ), + .testTarget( + name: "protoc-gen-swiftTests", + dependencies: ["protoc-gen-swift", "SwiftProtobufTestHelpers"], + swiftSettings: .packageSettings + ), + ], + swiftLanguageModes: [.v5], + cxxLanguageStandard: .gnucxx17 ) + +// Settings for every Swift target in this package, like project-level settings +// in an Xcode project. +extension Array where Element == PackageDescription.SwiftSetting { + static var packageSettings: Self { + [ + .enableExperimentalFeature("StrictConcurrency=complete"), + .enableUpcomingFeature("ExistentialAny"), + ] + } +} diff --git a/Package@swift-5.10.swift b/Package@swift-5.10.swift new file mode 100644 index 000000000..c6fed849a --- /dev/null +++ b/Package@swift-5.10.swift @@ -0,0 +1,98 @@ +// swift-tools-version:5.10 + +// Package.swift +// +// Copyright (c) 2014 - 2018 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// + +import PackageDescription + +let package = Package( + name: "SwiftProtobuf", + products: [ + .executable( + name: "protoc-gen-swift", + targets: ["protoc-gen-swift"] + ), + .library( + name: "SwiftProtobuf", + targets: ["SwiftProtobuf"] + ), + .library( + name: "SwiftProtobufPluginLibrary", + targets: ["SwiftProtobufPluginLibrary"] + ), + .plugin( + name: "SwiftProtobufPlugin", + targets: ["SwiftProtobufPlugin"] + ), + ], + targets: [ + .target( + name: "SwiftProtobuf", + exclude: ["CMakeLists.txt"], + resources: [.copy("PrivacyInfo.xcprivacy")], + swiftSettings: .packageSettings + ), + .target( + name: "SwiftProtobufPluginLibrary", + dependencies: ["SwiftProtobuf"], + exclude: ["CMakeLists.txt"], + resources: [.copy("PrivacyInfo.xcprivacy")], + swiftSettings: .packageSettings + ), + .target( + name: "SwiftProtobufTestHelpers", + dependencies: ["SwiftProtobuf"], + swiftSettings: .packageSettings + ), + .executableTarget( + name: "protoc-gen-swift", + dependencies: ["SwiftProtobufPluginLibrary", "SwiftProtobuf"], + exclude: ["CMakeLists.txt"], + swiftSettings: .packageSettings + ), + .executableTarget( + name: "Conformance", + dependencies: ["SwiftProtobuf"], + exclude: ["failure_list_swift.txt", "text_format_failure_list_swift.txt"], + swiftSettings: .packageSettings + ), + .plugin( + name: "SwiftProtobufPlugin", + capability: .buildTool(), + dependencies: ["protoc-gen-swift"] + ), + .testTarget( + name: "SwiftProtobufTests", + dependencies: ["SwiftProtobuf"], + swiftSettings: .packageSettings + ), + .testTarget( + name: "SwiftProtobufPluginLibraryTests", + dependencies: ["SwiftProtobufPluginLibrary", "SwiftProtobufTestHelpers"], + swiftSettings: .packageSettings + ), + .testTarget( + name: "protoc-gen-swiftTests", + dependencies: ["protoc-gen-swift", "SwiftProtobufTestHelpers"], + swiftSettings: .packageSettings + ), + ], + swiftLanguageVersions: [.v5] +) + +// Settings for every Swift target in this package, like project-level settings +// in an Xcode project. +extension Array where Element == PackageDescription.SwiftSetting { + static var packageSettings: Self { + [ + .enableExperimentalFeature("StrictConcurrency=complete"), + .enableUpcomingFeature("ExistentialAny"), + ] + } +} diff --git a/Package@swift-6.0.swift b/Package@swift-6.0.swift new file mode 100644 index 000000000..9c3f2170c --- /dev/null +++ b/Package@swift-6.0.swift @@ -0,0 +1,424 @@ +// swift-tools-version:5.10 + +// Package.swift +// +// Copyright (c) 2014 - 2018 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// + +import PackageDescription + +let package = Package( + name: "SwiftProtobuf", + products: [ + .executable( + name: "protoc-gen-swift", + targets: ["protoc-gen-swift"] + ), + .executable( + name: "protoc", + targets: ["protoc"] + ), + .library( + name: "SwiftProtobuf", + targets: ["SwiftProtobuf"] + ), + .library( + name: "SwiftProtobufPluginLibrary", + targets: ["SwiftProtobufPluginLibrary"] + ), + .plugin( + name: "SwiftProtobufPlugin", + targets: ["SwiftProtobufPlugin"] + ), + ], + targets: [ + .target( + name: "SwiftProtobuf", + exclude: ["CMakeLists.txt"], + resources: [.copy("PrivacyInfo.xcprivacy")], + swiftSettings: .packageSettings + ), + .target( + name: "SwiftProtobufPluginLibrary", + dependencies: ["SwiftProtobuf"], + exclude: ["CMakeLists.txt"], + resources: [.copy("PrivacyInfo.xcprivacy")], + swiftSettings: .packageSettings + ), + .target( + name: "SwiftProtobufTestHelpers", + dependencies: ["SwiftProtobuf"], + swiftSettings: .packageSettings + ), + .executableTarget( + name: "protoc", + path: "Sources/protobuf", + sources: [ + // protoc main + "protobuf/src/google/protobuf/compiler/main_no_generators.cc", + + // libprotoc + "protobuf/src/google/protobuf/any.cc", + "protobuf/src/google/protobuf/any.pb.cc", + "protobuf/src/google/protobuf/any_lite.cc", + "protobuf/src/google/protobuf/api.pb.cc", + "protobuf/src/google/protobuf/arena.cc", + "protobuf/src/google/protobuf/arenastring.cc", + "protobuf/src/google/protobuf/arenaz_sampler.cc", + "protobuf/src/google/protobuf/arena_align.cc", + "protobuf/src/google/protobuf/compiler/code_generator.cc", + "protobuf/src/google/protobuf/compiler/command_line_interface.cc", + "protobuf/src/google/protobuf/compiler/code_generator_lite.cc", + "protobuf/src/google/protobuf/compiler/versions.cc", + "protobuf/src/google/protobuf/compiler/subprocess.cc", + "protobuf/src/google/protobuf/compiler/importer.cc", + "protobuf/src/google/protobuf/compiler/parser.cc", + "protobuf/src/google/protobuf/compiler/plugin.cc", + "protobuf/src/google/protobuf/compiler/plugin.pb.cc", + "protobuf/src/google/protobuf/compiler/zip_writer.cc", + "protobuf/src/google/protobuf/compiler/retention.cc", + + // libprotobuf + "protobuf/src/google/protobuf/cpp_features.pb.cc", + "protobuf/src/google/protobuf/descriptor.cc", + "protobuf/src/google/protobuf/descriptor.pb.cc", + "protobuf/src/google/protobuf/descriptor_database.cc", + "protobuf/src/google/protobuf/duration.pb.cc", + "protobuf/src/google/protobuf/dynamic_message.cc", + "protobuf/src/google/protobuf/empty.pb.cc", + "protobuf/src/google/protobuf/extension_set.cc", + "protobuf/src/google/protobuf/extension_set_heavy.cc", + "protobuf/src/google/protobuf/feature_resolver.cc", + "protobuf/src/google/protobuf/field_mask.pb.cc", + "protobuf/src/google/protobuf/generated_enum_util.cc", + "protobuf/src/google/protobuf/generated_message_bases.cc", + "protobuf/src/google/protobuf/generated_message_reflection.cc", + "protobuf/src/google/protobuf/generated_message_tctable_full.cc", + "protobuf/src/google/protobuf/generated_message_tctable_gen.cc", + "protobuf/src/google/protobuf/generated_message_tctable_lite.cc", + "protobuf/src/google/protobuf/generated_message_util.cc", + "protobuf/src/google/protobuf/implicit_weak_message.cc", + "protobuf/src/google/protobuf/inlined_string_field.cc", + "protobuf/src/google/protobuf/internal_feature_helper.cc", + "protobuf/src/google/protobuf/io/coded_stream.cc", + "protobuf/src/google/protobuf/io/gzip_stream.cc", + "protobuf/src/google/protobuf/io/io_win32.cc", + "protobuf/src/google/protobuf/io/printer.cc", + "protobuf/src/google/protobuf/io/strtod.cc", + "protobuf/src/google/protobuf/io/tokenizer.cc", + "protobuf/src/google/protobuf/io/zero_copy_sink.cc", + "protobuf/src/google/protobuf/io/zero_copy_stream.cc", + "protobuf/src/google/protobuf/io/zero_copy_stream_impl.cc", + "protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.cc", + "protobuf/src/google/protobuf/json/internal/lexer.cc", + "protobuf/src/google/protobuf/json/internal/message_path.cc", + "protobuf/src/google/protobuf/json/internal/parser.cc", + "protobuf/src/google/protobuf/json/internal/unparser.cc", + "protobuf/src/google/protobuf/json/internal/untyped_message.cc", + "protobuf/src/google/protobuf/json/internal/writer.cc", + "protobuf/src/google/protobuf/json/internal/zero_copy_buffered_stream.cc", + "protobuf/src/google/protobuf/json/json.cc", + "protobuf/src/google/protobuf/map.cc", + "protobuf/src/google/protobuf/map_field.cc", + "protobuf/src/google/protobuf/message.cc", + "protobuf/src/google/protobuf/message_lite.cc", + "protobuf/src/google/protobuf/micro_string.cc", + "protobuf/src/google/protobuf/parse_context.cc", + "protobuf/src/google/protobuf/port.cc", + "protobuf/src/google/protobuf/raw_ptr.cc", + "protobuf/src/google/protobuf/reflection_mode.cc", + "protobuf/src/google/protobuf/reflection_ops.cc", + "protobuf/src/google/protobuf/repeated_field.cc", + "protobuf/src/google/protobuf/repeated_ptr_field.cc", + "protobuf/src/google/protobuf/service.cc", + "protobuf/src/google/protobuf/source_context.pb.cc", + "protobuf/src/google/protobuf/struct.pb.cc", + "protobuf/src/google/protobuf/stubs/common.cc", + "protobuf/src/google/protobuf/text_format.cc", + "protobuf/src/google/protobuf/timestamp.pb.cc", + "protobuf/src/google/protobuf/type.pb.cc", + "protobuf/src/google/protobuf/unknown_field_set.cc", + "protobuf/src/google/protobuf/util/delimited_message_util.cc", + "protobuf/src/google/protobuf/util/field_comparator.cc", + "protobuf/src/google/protobuf/util/field_mask_util.cc", + "protobuf/src/google/protobuf/util/message_differencer.cc", + "protobuf/src/google/protobuf/util/time_util.cc", + "protobuf/src/google/protobuf/util/type_resolver_util.cc", + "protobuf/src/google/protobuf/wire_format.cc", + "protobuf/src/google/protobuf/wire_format_lite.cc", + "protobuf/src/google/protobuf/wrappers.pb.cc", + + // abseil + "abseil/absl/base/internal/cycleclock.cc", + "abseil/absl/base/internal/low_level_alloc.cc", + "abseil/absl/base/internal/raw_logging.cc", + "abseil/absl/base/internal/spinlock.cc", + "abseil/absl/base/internal/spinlock_wait.cc", + "abseil/absl/base/internal/strerror.cc", + "abseil/absl/base/internal/sysinfo.cc", + "abseil/absl/base/internal/tracing.cc", + "abseil/absl/base/internal/thread_identity.cc", + "abseil/absl/base/internal/throw_delegate.cc", + "abseil/absl/base/internal/unscaledcycleclock.cc", + "abseil/absl/container/internal/raw_hash_set.cc", + "abseil/absl/container/internal/hashtablez_sampler.cc", + "abseil/absl/container/internal/hashtablez_sampler_force_weak_definition.cc", + "abseil/absl/crc/crc32c.cc", + "abseil/absl/crc/internal/cpu_detect.cc", + "abseil/absl/crc/internal/crc.cc", + "abseil/absl/crc/internal/crc_cord_state.cc", + "abseil/absl/crc/internal/crc_memcpy_fallback.cc", + "abseil/absl/crc/internal/crc_memcpy_x86_arm_combined.cc", + "abseil/absl/crc/internal/crc_non_temporal_memcpy.cc", + "abseil/absl/crc/internal/crc_x86_arm_combined.cc", + "abseil/absl/debugging/internal/address_is_readable.cc", + "abseil/absl/debugging/internal/decode_rust_punycode.cc", + "abseil/absl/debugging/internal/demangle.cc", + "abseil/absl/debugging/internal/demangle_rust.cc", + "abseil/absl/debugging/internal/elf_mem_image.cc", + "abseil/absl/debugging/internal/examine_stack.cc", + "abseil/absl/debugging/internal/utf8_for_code_point.cc", + "abseil/absl/debugging/internal/vdso_support.cc", + "abseil/absl/debugging/leak_check.cc", + "abseil/absl/debugging/stacktrace.cc", + "abseil/absl/debugging/symbolize.cc", + "abseil/absl/hash/internal/city.cc", + "abseil/absl/hash/internal/hash.cc", + "abseil/absl/hash/internal/low_level_hash.cc", + "abseil/absl/log/die_if_null.cc", + "abseil/absl/log/globals.cc", + "abseil/absl/log/initialize.cc", + "abseil/absl/log/internal/check_op.cc", + "abseil/absl/log/internal/conditions.cc", + "abseil/absl/log/internal/globals.cc", + "abseil/absl/log/internal/log_format.cc", + "abseil/absl/log/internal/log_message.cc", + "abseil/absl/log/internal/log_sink_set.cc", + "abseil/absl/log/internal/nullguard.cc", + "abseil/absl/log/internal/proto.cc", + "abseil/absl/log/internal/structured_proto.cc", + "abseil/absl/log/log_sink.cc", + "abseil/absl/numeric/int128.cc", + "abseil/absl/profiling/internal/exponential_biased.cc", + "abseil/absl/status/status.cc", + "abseil/absl/status/statusor.cc", + "abseil/absl/status/status_payload_printer.cc", + "abseil/absl/status/internal/status_internal.cc", + "abseil/absl/strings/ascii.cc", + "abseil/absl/strings/charconv.cc", + "abseil/absl/strings/cord.cc", + "abseil/absl/strings/cord_analysis.cc", + "abseil/absl/strings/escaping.cc", + "abseil/absl/strings/internal/charconv_bigint.cc", + "abseil/absl/strings/internal/charconv_parse.cc", + "abseil/absl/strings/internal/cordz_functions.cc", + "abseil/absl/strings/internal/cordz_handle.cc", + "abseil/absl/strings/internal/cordz_info.cc", + "abseil/absl/strings/internal/cord_internal.cc", + "abseil/absl/strings/internal/cord_rep_btree.cc", + "abseil/absl/strings/internal/cord_rep_btree_navigator.cc", + "abseil/absl/strings/internal/cord_rep_btree_reader.cc", + "abseil/absl/strings/internal/cord_rep_consume.cc", + "abseil/absl/strings/internal/cord_rep_crc.cc", + "abseil/absl/strings/internal/damerau_levenshtein_distance.cc", + "abseil/absl/strings/internal/escaping.cc", + "abseil/absl/strings/internal/memutil.cc", + "abseil/absl/strings/internal/ostringstream.cc", + "abseil/absl/strings/internal/stringify_sink.cc", + "abseil/absl/strings/internal/str_format/arg.cc", + "abseil/absl/strings/internal/str_format/bind.cc", + "abseil/absl/strings/internal/str_format/extension.cc", + "abseil/absl/strings/internal/str_format/float_conversion.cc", + "abseil/absl/strings/internal/str_format/output.cc", + "abseil/absl/strings/internal/str_format/parser.cc", + "abseil/absl/strings/internal/utf8.cc", + "abseil/absl/strings/match.cc", + "abseil/absl/strings/numbers.cc", + "abseil/absl/strings/string_view.cc", + "abseil/absl/strings/str_cat.cc", + "abseil/absl/strings/str_replace.cc", + "abseil/absl/strings/str_split.cc", + "abseil/absl/strings/substitute.cc", + "abseil/absl/synchronization/barrier.cc", + "abseil/absl/synchronization/blocking_counter.cc", + "abseil/absl/synchronization/internal/create_thread_identity.cc", + "abseil/absl/synchronization/internal/graphcycles.cc", + "abseil/absl/synchronization/internal/per_thread_sem.cc", + "abseil/absl/synchronization/internal/kernel_timeout.cc", + "abseil/absl/synchronization/internal/pthread_waiter.cc", + "abseil/absl/synchronization/internal/stdcpp_waiter.cc", + "abseil/absl/synchronization/internal/futex_waiter.cc", + "abseil/absl/synchronization/internal/sem_waiter.cc", + "abseil/absl/synchronization/internal/win32_waiter.cc", + "abseil/absl/synchronization/internal/waiter_base.cc", + "abseil/absl/synchronization/mutex.cc", + "abseil/absl/synchronization/notification.cc", + "abseil/absl/time/civil_time.cc", + "abseil/absl/time/clock.cc", + "abseil/absl/time/duration.cc", + "abseil/absl/time/format.cc", + "abseil/absl/time/internal/cctz/src/time_zone_fixed.cc", + "abseil/absl/time/internal/cctz/src/time_zone_format.cc", + "abseil/absl/time/internal/cctz/src/time_zone_if.cc", + "abseil/absl/time/internal/cctz/src/time_zone_impl.cc", + "abseil/absl/time/internal/cctz/src/time_zone_info.cc", + "abseil/absl/time/internal/cctz/src/time_zone_libc.cc", + "abseil/absl/time/internal/cctz/src/time_zone_lookup.cc", + "abseil/absl/time/internal/cctz/src/time_zone_posix.cc", + "abseil/absl/time/internal/cctz/src/zone_info_source.cc", + "abseil/absl/time/time.cc", + + // utf8 validation + "protobuf/third_party/utf8_range/utf8_range.c", + + // UPB files + "protobuf/upb/base/status.c", + "protobuf/upb/mem/alloc.c", + "protobuf/upb/mem/arena.c", + "protobuf/upb/wire/decode.c", + "protobuf/upb/wire/encode.c", + "protobuf/upb/wire/eps_copy_input_stream.c", + "protobuf/upb/wire/reader.c", + "protobuf/upb/wire/byte_size.c", + "protobuf/upb/wire/internal/decoder.c", + "protobuf/upb/wire/decode_fast/dispatch.c", + "protobuf/upb/wire/decode_fast/field_fixed.c", + "protobuf/upb/wire/decode_fast/field_generic.c", + "protobuf/upb/wire/decode_fast/field_message.c", + "protobuf/upb/wire/decode_fast/field_string.c", + "protobuf/upb/wire/decode_fast/field_varint.c", + "protobuf/upb/wire/decode_fast/function_array.c", + "protobuf/upb/wire/decode_fast/select.c", + "protobuf/upb/hash/common.c", + "protobuf/upb/message/accessors.c", + "protobuf/upb/message/array.c", + "protobuf/upb/message/compare.c", + "protobuf/upb/message/copy.c", + "protobuf/upb/message/map.c", + "protobuf/upb/message/map_sorter.c", + "protobuf/upb/message/merge.c", + "protobuf/upb/message/message.c", + "protobuf/upb/message/promote.c", + "protobuf/upb/message/internal/compare_unknown.c", + "protobuf/upb/message/internal/extension.c", + "protobuf/upb/message/internal/iterator.c", + "protobuf/upb/message/internal/message.c", + "protobuf/upb/mini_table/compat.c", + "protobuf/upb/mini_table/extension_registry.c", + "protobuf/upb/mini_table/message.c", + "protobuf/upb/mini_table/internal/message.c", + "protobuf/upb/mini_descriptor/build_enum.c", + "protobuf/upb/mini_descriptor/decode.c", + "protobuf/upb/mini_descriptor/link.c", + "protobuf/upb/mini_descriptor/internal/base92.c", + "protobuf/upb/mini_descriptor/internal/encode.c", + "protobuf/upb/reflection/def_pool.c", + "protobuf/upb/reflection/def_type.c", + "protobuf/upb/reflection/desc_state.c", + "protobuf/upb/reflection/enum_def.c", + "protobuf/upb/reflection/enum_reserved_range.c", + "protobuf/upb/reflection/enum_value_def.c", + "protobuf/upb/reflection/extension_range.c", + "protobuf/upb/reflection/field_def.c", + "protobuf/upb/reflection/file_def.c", + "protobuf/upb/reflection/message.c", + "protobuf/upb/reflection/message_def.c", + "protobuf/upb/reflection/message_reserved_range.c", + "protobuf/upb/reflection/method_def.c", + "protobuf/upb/reflection/oneof_def.c", + "protobuf/upb/reflection/service_def.c", + "protobuf/upb/reflection/stage0/google/protobuf/descriptor.upb.c", + "protobuf/upb/reflection/internal/def_builder.c", + "protobuf/upb/reflection/internal/strdup2.c", + "protobuf/upb/text/debug_string.c", + "protobuf/upb/text/encode.c", + "protobuf/upb/text/internal/encode.c", + + // UPB lex files for round trip functions + "protobuf/upb/lex/round_trip.c", + + // upb_generator additional files (minimal set) + "protobuf/upb_generator/plugin.cc", + "protobuf/upb_generator/common.cc", + "protobuf/upb_generator/common/names.cc", + "protobuf/upb_generator/file_layout.cc", + "protobuf/upb_generator/minitable/names.cc", + "protobuf/upb_generator/minitable/names_internal.cc", + ], + cxxSettings: [ + .headerSearchPath("abseil/"), + .headerSearchPath("protobuf/"), + .headerSearchPath("protobuf/third_party/utf8_range/"), + .headerSearchPath("protobuf/src/"), + .headerSearchPath("protobuf/upb/"), + .headerSearchPath("protobuf/upb_generator/"), + .define("UPB_BOOTSTRAP_STAGE", to: "0"), + ], + linkerSettings: [ + .linkedFramework( + "CoreFoundation", + .when( + platforms: [ + .macOS, + .macCatalyst, + .iOS, + .tvOS, + .watchOS, + .visionOS, + ] + ) + ), + .linkedLibrary("m"), + ] + ), + .executableTarget( + name: "protoc-gen-swift", + dependencies: ["SwiftProtobufPluginLibrary", "SwiftProtobuf"], + exclude: ["CMakeLists.txt"], + swiftSettings: .packageSettings + ), + .executableTarget( + name: "Conformance", + dependencies: ["SwiftProtobuf"], + exclude: ["failure_list_swift.txt", "text_format_failure_list_swift.txt"], + swiftSettings: .packageSettings + ), + .plugin( + name: "SwiftProtobufPlugin", + capability: .buildTool(), + dependencies: ["protoc-gen-swift", "protoc"] + ), + .testTarget( + name: "SwiftProtobufTests", + dependencies: ["SwiftProtobuf"], + swiftSettings: .packageSettings + ), + .testTarget( + name: "SwiftProtobufPluginLibraryTests", + dependencies: ["SwiftProtobufPluginLibrary", "SwiftProtobufTestHelpers"], + swiftSettings: .packageSettings + ), + .testTarget( + name: "protoc-gen-swiftTests", + dependencies: ["protoc-gen-swift", "SwiftProtobufTestHelpers"], + swiftSettings: .packageSettings + ), + ], + swiftLanguageVersions: [.v5], + cxxLanguageStandard: .gnucxx17 +) + +// Settings for every Swift target in this package, like project-level settings +// in an Xcode project. +extension Array where Element == PackageDescription.SwiftSetting { + static var packageSettings: Self { + [ + .enableExperimentalFeature("StrictConcurrency=complete"), + .enableUpcomingFeature("ExistentialAny"), + ] + } +} diff --git a/Performance/Harness.h b/Performance/Harness.h index ef2e29d4b..02c57fd5d 100644 --- a/Performance/Harness.h +++ b/Performance/Harness.h @@ -94,7 +94,7 @@ class Harness { * from the main results. */ template - typename std::result_of::type measure_subtask( + typename std::invoke_result::type measure_subtask( const std::string& name, Function&& func); /** @@ -171,7 +171,7 @@ void Harness::measure(const Function& func) { } template -typename std::result_of::type Harness::measure_subtask( +typename std::invoke_result::type Harness::measure_subtask( const std::string& name, Function&& func) { subtask_names.push_back(name); using std::chrono::steady_clock; diff --git a/Performance/Harness.swift b/Performance/Harness.swift index 71939edb7..c7e32038a 100644 --- a/Performance/Harness.swift +++ b/Performance/Harness.swift @@ -15,17 +15,17 @@ import Foundation private func padded(_ input: String, to width: Int) -> String { - return input + String(repeating: " ", count: max(0, width - input.count)) + input + String(repeating: " ", count: max(0, width - input.count)) } /// It is expected that the generator will provide these in an extension. protocol GeneratedHarnessMembers { - /// The number of times to loop the body of the run() method. - /// Increase this to get better precision. - var runCount: Int { get } + /// The number of times to loop the body of the run() method. + /// Increase this to get better precision. + var runCount: Int { get } - /// The main body of the performance harness. - func run() + /// The main body of the performance harness. + func run() } /// Harness used for performance tests. @@ -34,135 +34,134 @@ protocol GeneratedHarnessMembers { /// run() method, which the main.swift file calls. class Harness: GeneratedHarnessMembers { - /// The number of times to execute the block passed to measure(). - var measurementCount = 10 - - /// The number of times to call append() for repeated fields. - let repeatedCount: Int32 = 10 - - /// Ordered list of task names - var taskNames = [String]() - - /// The times taken by subtasks during each measured attempt. - var subtaskTimings = [String: [TimeInterval]]() - - /// Times for the subtasks in the current attempt. - var currentSubtasks = [String: TimeInterval]() - - /// The file to which results should be written. - let resultsFile: FileHandle? - - /// Creates a new harness that writes its statistics to the given file - /// (as well as to stdout). - init(resultsFile: FileHandle?) { - self.resultsFile = resultsFile - } - - /// Measures the time it takes to execute the given block. The block is - /// executed five times and the mean/standard deviation are computed. - func measure(block: () throws -> Void) { - var timings = [TimeInterval]() - subtaskTimings.removeAll() - print("Running each check \(runCount) times, times in µs") - - var headingsDisplayed = false - - do { - // Do each measurement multiple times and collect the means and standard - // deviation to account for noise. - for attempt in 1...measurementCount { - currentSubtasks.removeAll() - taskNames.removeAll() - let start = Date() - for _ in 0.. Void) { + var timings = [TimeInterval]() + subtaskTimings.removeAll() + print("Running each check \(runCount) times, times in µs") + + var headingsDisplayed = false + + do { + // Do each measurement multiple times and collect the means and standard + // deviation to account for noise. + for attempt in 1...measurementCount { + currentSubtasks.removeAll() + taskNames.removeAll() + let start = Date() + for _ in 0..( + _ name: String, + block: () throws -> Result + ) rethrows -> Result { + try autoreleasepool { () -> Result in + taskNames.append(name) + let start = Date() + let result = try block() + let end = Date() + let diff = end.timeIntervalSince(start) / Double(runCount) * 1000000.0 + currentSubtasks[name] = (currentSubtasks[name] ?? 0) + diff + return result + } } - let (mean, stddev) = statistics(timings) - let stats = - String(format: "Relative stddev = %.1f%%\n", (stddev / mean) * 100.0) - print(stats) - } - - /// Measure an individual subtask whose timing will be printed separately - /// from the main results. - func measureSubtask( - _ name: String, - block: () throws -> Result - ) rethrows -> Result { - return try autoreleasepool { () -> Result in - taskNames.append(name) - let start = Date() - let result = try block() - let end = Date() - let diff = end.timeIntervalSince(start) / Double(runCount) * 1000000.0 - currentSubtasks[name] = (currentSubtasks[name] ?? 0) + diff - return result - } - } - - /// Compute the mean and standard deviation of the given time intervals. - private func statistics(_ timings: [TimeInterval]) -> - (mean: TimeInterval, stddev: TimeInterval) { - var sum: TimeInterval = 0 - var sqsum: TimeInterval = 0 - for timing in timings { - sum += timing - sqsum += timing * timing + /// Compute the mean and standard deviation of the given time intervals. + private func statistics(_ timings: [TimeInterval]) -> (mean: TimeInterval, stddev: TimeInterval) { + var sum: TimeInterval = 0 + var sqsum: TimeInterval = 0 + for timing in timings { + sum += timing + sqsum += timing * timing + } + let n = TimeInterval(timings.count) + let mean = sum / n + let variance = sqsum / n - mean * mean + return (mean: mean, stddev: sqrt(variance)) } - let n = TimeInterval(timings.count) - let mean = sum / n - let variance = sqsum / n - mean * mean - return (mean: mean, stddev: sqrt(variance)) - } - - /// Writes a string to the data results file that will be parsed by the - /// calling script to produce visualizations. - private func writeToLog(_ string: String) { - if let resultsFile = resultsFile { - let utf8 = Data(string.utf8) - resultsFile.write(utf8) + + /// Writes a string to the data results file that will be parsed by the + /// calling script to produce visualizations. + private func writeToLog(_ string: String) { + if let resultsFile = resultsFile { + let utf8 = Data(string.utf8) + resultsFile.write(utf8) + } } - } } diff --git a/Performance/generators/cpp.sh b/Performance/generators/cpp.sh index e144d880f..c52fce353 100644 --- a/Performance/generators/cpp.sh +++ b/Performance/generators/cpp.sh @@ -98,7 +98,6 @@ using google::protobuf::util::BinaryToJsonString; using google::protobuf::util::JsonToBinaryString; using google::protobuf::util::MessageDifferencer; using google::protobuf::util::NewTypeResolverForDescriptorPool; -using google::protobuf::util::Status; using google::protobuf::util::TypeResolver; using std::cerr; using std::endl; @@ -148,12 +147,14 @@ void Harness::run() { // Exercise JSON serialization. auto json = measure_subtask("Encode JSON", [&]() { string out_json; - BinaryToJsonString(type_resolver, *type_url, data, &out_json); + auto r = BinaryToJsonString(type_resolver, *type_url, data, &out_json); + (void)r; // UNUSED return out_json; }); auto decoded_binary = measure_subtask("Decode JSON", [&]() { string out_binary; - JsonToBinaryString(type_resolver, *type_url, json, &out_binary); + auto r = JsonToBinaryString(type_resolver, *type_url, json, &out_binary); + (void)r; // UNUSED return out_binary; }); diff --git a/Performance/generators/swift.sh b/Performance/generators/swift.sh index 4c4c74a40..162b6bd68 100644 --- a/Performance/generators/swift.sh +++ b/Performance/generators/swift.sh @@ -106,24 +106,24 @@ extension Harness { populateFields(of: &message) } - message = measureSubtask("Populate fields with with") { + message = measureSubtask("Populate (with)") { return populateFieldsWithWith() } // Exercise binary serialization. - let data = try measureSubtask("Encode binary") { - return try message.serializedData() + let data = try measureSubtask("Encode binary") { () -> Data in + try message.serializedBytes() } let message2 = try measureSubtask("Decode binary") { return try PerfMessage(serializedData: data) } // Exercise JSON serialization. - let json = try measureSubtask("Encode JSON") { - return try message.jsonUTF8Data() + let json = try measureSubtask("Encode JSON") { () -> Data in + return try message.jsonUTF8Bytes() } _ = try measureSubtask("Decode JSON") { - return try PerfMessage(jsonUTF8Data: json) + return try PerfMessage(jsonUTF8Bytes: json) } // Exercise text serialization. diff --git a/Performance/main.swift b/Performance/main.swift index 922fd72ad..40f93d468 100644 --- a/Performance/main.swift +++ b/Performance/main.swift @@ -15,8 +15,7 @@ import Foundation let args = CommandLine.arguments -let resultsFile = args.count > 1 ? - FileHandle(forWritingAtPath: args[1]) : nil +let resultsFile = args.count > 1 ? FileHandle(forWritingAtPath: args[1]) : nil resultsFile?.seekToEndOfFile() let harness = Harness(resultsFile: resultsFile) diff --git a/Performance/perf_runner.sh b/Performance/perf_runner.sh index 03bfbec94..73d6e281e 100755 --- a/Performance/perf_runner.sh +++ b/Performance/perf_runner.sh @@ -41,12 +41,12 @@ else fi # Directory containing this script -readonly script_dir="." +readonly script_dir=`pwd` # Change this if your checkout of github.com/protocolbuffers/protobuf is in a # different location. readonly GOOGLE_PROTOBUF_CHECKOUT=${GOOGLE_PROTOBUF_CHECKOUT:-"$script_dir/../../protobuf"} -readonly PROTOC=${PROTOC:-"${GOOGLE_PROTOBUF_CHECKOUT}/src/protoc"} +readonly PROTOC=${PROTOC:-"${GOOGLE_PROTOBUF_CHECKOUT}/protoc"} function usage() { cat >&2 < PackagePlugin.PluginContext.Tool + ) throws -> [Command] { + guard + let configurationFilePath = sourceFiles.first( + where: { + $0.path.lastComponent == Self.configurationFileName + } + )?.path + else { + throw PluginError.noConfigFound(Self.configurationFileName) + } + let data = try Data(contentsOf: URL(fileURLWithPath: "\(configurationFilePath)")) + let configuration = try JSONDecoder().decode(Configuration.self, from: data) + try validateConfiguration(configuration) + + // We need to find the path of protoc and protoc-gen-swift + let protocPath: Path + if let configuredProtocPath = configuration.protocPath { + // The user set the config path in the file. So let's take that + protocPath = Path(configuredProtocPath) + } else if let environmentPath = ProcessInfo.processInfo.environment["PROTOC_PATH"] { + // The user set the env variable. So let's take that + protocPath = Path(environmentPath) + } else { + // The user didn't set anything so let's try see if SPM can find a binary for us + protocPath = try tool("protoc").path + } + let protocGenSwiftPath = try tool("protoc-gen-swift").path + + return configuration.invocations.map { invocation in + self.invokeProtoc( + directory: configurationFilePath.removingLastComponent(), + invocation: invocation, + protocPath: protocPath, + protocGenSwiftPath: protocGenSwiftPath, + outputDirectory: pluginWorkDirectory + ) + } + } + + /// Invokes `protoc` with the given inputs + /// + /// - Parameters: + /// - directory: The plugin's target directory. + /// - invocation: The `protoc` invocation. + /// - protocPath: The path to the `protoc` binary. + /// - protocGenSwiftPath: The path to the `protoc-gen-swift` binary. + /// - outputDirectory: The output directory for the generated files. + /// - Returns: The build command configured based on the arguments. + private func invokeProtoc( + directory: PackagePlugin.Path, + invocation: Configuration.Invocation, + protocPath: Path, + protocGenSwiftPath: Path, + outputDirectory: Path + ) -> Command { + // Construct the `protoc` arguments. + var protocArgs = [ + "--plugin=protoc-gen-swift=\(protocGenSwiftPath)", + "--swift_out=\(outputDirectory)", + ] + + // We need to add the target directory as a search path since we require the user to specify + // the proto files relative to it. + protocArgs.append("-I") + protocArgs.append("\(directory)") + + // Add the visibility if it was set + if let visibility = invocation.visibility { + protocArgs.append("--swift_opt=Visibility=\(visibility.rawValue)") + } + + // Add the file naming if it was set + if let fileNaming = invocation.fileNaming { + protocArgs.append("--swift_opt=FileNaming=\(fileNaming.rawValue)") + } + + // Add the implementation only imports flag if it was set + if let implementationOnlyImports = invocation.implementationOnlyImports { + protocArgs.append("--swift_opt=ImplementationOnlyImports=\(implementationOnlyImports)") + } + + // Add the useAccessLevelOnImports only imports flag if it was set + if let useAccessLevelOnImports = invocation.useAccessLevelOnImports { + protocArgs.append("--swift_opt=UseAccessLevelOnImports=\(useAccessLevelOnImports)") + } + + var inputFiles = [Path]() + var outputFiles = [Path]() + + for var file in invocation.protoFiles { + // Append the file to the protoc args so that it is used for generating + protocArgs.append("\(file)") + inputFiles.append(directory.appending(file)) + + // The name of the output file is based on the name of the input file. + // We validated in the beginning that every file has the suffix of .proto + // This means we can just drop the last 5 elements and append the new suffix + file.removeLast(5) + file.append("pb.swift") + let protobufOutputPath = outputDirectory.appending(file) + + // Add the outputPath as an output file + outputFiles.append(protobufOutputPath) + } + + // Construct the command. Specifying the input and output paths lets the build + // system know when to invoke the command. The output paths are passed on to + // the rule engine in the build system. + return Command.buildCommand( + displayName: "Generating swift files from proto files", + executable: protocPath, + arguments: protocArgs, + inputFiles: inputFiles + [protocGenSwiftPath], + outputFiles: outputFiles + ) + } + + /// Validates the configuration file for various user errors. + private func validateConfiguration(_ configuration: Configuration) throws { + for invocation in configuration.invocations { + for protoFile in invocation.protoFiles { + if !protoFile.hasSuffix(".proto") { + throw PluginError.invalidInputFileExtension(protoFile) + } + } + } + } +} + +extension SwiftProtobufPlugin: BuildToolPlugin { + func createBuildCommands( + context: PluginContext, + target: Target + ) async throws -> [Command] { + guard let swiftTarget = target as? SwiftSourceModuleTarget else { + throw PluginError.invalidTarget(target) + } + return try createBuildCommands( + pluginWorkDirectory: context.pluginWorkDirectory, + sourceFiles: swiftTarget.sourceFiles, + tool: context.tool + ) + } +} + +#if canImport(XcodeProjectPlugin) +import XcodeProjectPlugin + +extension SwiftProtobufPlugin: XcodeBuildToolPlugin { + func createBuildCommands( + context: XcodePluginContext, + target: XcodeTarget + ) throws -> [Command] { + try createBuildCommands( + pluginWorkDirectory: context.pluginWorkDirectory, + sourceFiles: target.inputFiles, + tool: context.tool + ) + } +} +#endif diff --git a/Protos/CompileTests/InternalImportsByDefault/ServiceOnly.proto b/Protos/CompileTests/InternalImportsByDefault/ServiceOnly.proto new file mode 100644 index 000000000..ff4bdac9e --- /dev/null +++ b/Protos/CompileTests/InternalImportsByDefault/ServiceOnly.proto @@ -0,0 +1,7 @@ +// This proto file should generate an empty file, since the plugin will ignore +// service definitions. +// This is here to make sure we don't import Foundation or SwiftProtobuf when +// it's not necessary. + +service SomeService { +} diff --git a/Protos/CompileTests/InternalImportsByDefault/SomeProtoWithBytes.proto b/Protos/CompileTests/InternalImportsByDefault/SomeProtoWithBytes.proto new file mode 100644 index 000000000..d838a7884 --- /dev/null +++ b/Protos/CompileTests/InternalImportsByDefault/SomeProtoWithBytes.proto @@ -0,0 +1,12 @@ +// This proto will generate a Swift file that imports Foundation, because it +// defines a bytes field. +// Because InternalImportsByDefault is enabled on this module and we generate +// protos with public visibility, the build will fail if the access level +// modifier is missing (or wrong) since it will default the import to `internal` +// and cause a conflict of access levels, since the `someBytes` property defined +// on the message will be public. + +message SomeProtoWithBytes { + optional bytes someBytes = 2; + optional string ext_str = 100; +} diff --git a/Protos/CompileTests/MultiModule/Sources/ImportsAPublicly/imports_a_publicly.proto b/Protos/CompileTests/MultiModule/Sources/ImportsAPublicly/imports_a_publicly.proto new file mode 100644 index 000000000..f8bdb3722 --- /dev/null +++ b/Protos/CompileTests/MultiModule/Sources/ImportsAPublicly/imports_a_publicly.proto @@ -0,0 +1,6 @@ +import public "Sources/ModuleA/a.proto"; + +message ImportsAPublicly { + optional A a = 11; + optional E e = 12; +} diff --git a/Protos/CompileTests/MultiModule/Sources/ImportsImportsAPublicly/imports_imports_a_publicly.proto b/Protos/CompileTests/MultiModule/Sources/ImportsImportsAPublicly/imports_imports_a_publicly.proto new file mode 100644 index 000000000..0b34fc68d --- /dev/null +++ b/Protos/CompileTests/MultiModule/Sources/ImportsImportsAPublicly/imports_imports_a_publicly.proto @@ -0,0 +1,6 @@ +import public "Sources/ImportsAPublicly/imports_a_publicly.proto"; + +message ImportsImportsAPublicly { + optional A a = 21; + optional E e = 22; +} diff --git a/Protos/CompileTests/MultiModule/Sources/ModuleA/a.proto b/Protos/CompileTests/MultiModule/Sources/ModuleA/a.proto new file mode 100644 index 000000000..75c1506a7 --- /dev/null +++ b/Protos/CompileTests/MultiModule/Sources/ModuleA/a.proto @@ -0,0 +1,14 @@ +enum E { + E_UNSET = 0; + E_A = 1; + E_B = 2; +} + +message A { + optional E e = 1; + extensions 100 to 1000; +} + +extend A { + optional string ext_str = 100; +} diff --git a/Protos/CompileTests/MultiModule/Sources/ReExportAOnly/reexport_a_only.proto b/Protos/CompileTests/MultiModule/Sources/ReExportAOnly/reexport_a_only.proto new file mode 100644 index 000000000..9f4855a69 --- /dev/null +++ b/Protos/CompileTests/MultiModule/Sources/ReExportAOnly/reexport_a_only.proto @@ -0,0 +1 @@ +import public "Sources/ModuleA/a.proto"; diff --git a/Protos/CompileTests/MultiModule/Tests/Test1/uses_a_transitively.proto b/Protos/CompileTests/MultiModule/Tests/Test1/uses_a_transitively.proto new file mode 100644 index 000000000..f8c2c3a80 --- /dev/null +++ b/Protos/CompileTests/MultiModule/Tests/Test1/uses_a_transitively.proto @@ -0,0 +1,6 @@ +import "Sources/ImportsAPublicly/imports_a_publicly.proto"; + +message UsesATransitively { + optional A a = 101; + optional E e = 102; +} diff --git a/Protos/CompileTests/MultiModule/Tests/Test2/uses_a_transitively2.proto b/Protos/CompileTests/MultiModule/Tests/Test2/uses_a_transitively2.proto new file mode 100644 index 000000000..e05621dfa --- /dev/null +++ b/Protos/CompileTests/MultiModule/Tests/Test2/uses_a_transitively2.proto @@ -0,0 +1,6 @@ +import "Sources/ImportsImportsAPublicly/imports_imports_a_publicly.proto"; + +message UsesATransitively2 { + optional A a = 111; + optional E e = 122; +} diff --git a/Protos/CompileTests/MultiModule/module_mappings.pbascii b/Protos/CompileTests/MultiModule/module_mappings.pbascii new file mode 100644 index 000000000..08a643ba9 --- /dev/null +++ b/Protos/CompileTests/MultiModule/module_mappings.pbascii @@ -0,0 +1,16 @@ +mapping { + module_name: "ModuleA" + proto_file_path: "Sources/ModuleA/a.proto" +} +mapping { + module_name: "ImportsAPublicly" + proto_file_path: "Sources/ImportsAPublicly/imports_a_publicly.proto" +} +mapping { + module_name: "ImportsImportsAPublicly" + proto_file_path: "Sources/ImportsImportsAPublicly/imports_imports_a_publicly.proto" +} +mapping { + module_name: "ReExportAOnly" + proto_file_path: "Sources/ReExportAOnly/reexport_a_only.proto" +} diff --git a/Protos/conformance/conformance.proto b/Protos/Sources/Conformance/conformance/conformance.proto similarity index 69% rename from Protos/conformance/conformance.proto rename to Protos/Sources/Conformance/conformance/conformance.proto index 7248e9896..e3298f085 100644 --- a/Protos/conformance/conformance.proto +++ b/Protos/Sources/Conformance/conformance/conformance.proto @@ -1,36 +1,16 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd syntax = "proto3"; + package conformance; + option java_package = "com.google.protobuf.conformance"; +option objc_class_prefix = "Conformance"; // This defines the conformance testing protocol. This protocol exists between // the conformance test suite itself and the code being tested. For each test, @@ -55,7 +35,7 @@ enum WireFormat { UNSPECIFIED = 0; PROTOBUF = 1; JSON = 2; - JSPB = 3; // Google internal only. Opensource testees just skip it. + JSPB = 3; // Only used inside Google. Opensource testees just skip it. TEXT_FORMAT = 4; } @@ -69,18 +49,31 @@ enum TestCategory { // https://developers.google.com/protocol-buffers/docs/proto3#json_options // for more detail. JSON_IGNORE_UNKNOWN_PARSING_TEST = 3; - // Test jspb wire format. Google internal only. Opensource testees just skip it. + // Test jspb wire format. Only used inside Google. Opensource testees just + // skip it. JSPB_TEST = 4; // Test text format. For cpp, java and python, testees can already deal with // this type. Testees of other languages can simply skip it. TEXT_FORMAT_TEST = 5; } +// Meant to encapsulate all types of tests: successes, skips, failures, etc. +// Therefore, this may or may not have a failure message. Failure messages +// may be truncated for our failure lists. +message TestStatus { + string name = 1; + string failure_message = 2; + // What an actual test name matched to in a failure list. Can be wildcarded or + // an exact match without wildcards. + string matched_name = 3; +} + // The conformance runner will request a list of failures as the first request. // This will be known by message_type == "conformance.FailureSet", a conformance // test should return a serialized FailureSet in protobuf_payload. message FailureSet { - repeated string failure = 1; + repeated TestStatus test = 2; + reserved 1; } // Represents a single test case's input. The testee should: @@ -92,14 +85,10 @@ message ConformanceRequest { // The payload (whether protobuf of JSON) is always for a // protobuf_test_messages.proto3.TestAllTypes proto (as defined in // src/google/protobuf/proto3_test_messages.proto). - // - // TODO(haberman): if/when we expand the conformance tests to support proto2, - // we will want to include a field that lets the payload/response be a - // protobuf_test_messages.google.protobuf.TestAllTypes message instead. oneof payload { bytes protobuf_payload = 1; string json_payload = 2; - // Google internal only. Opensource testees just skip it. + // Only used inside Google. Opensource testees just skip it. string jspb_payload = 7; string text_payload = 8; } @@ -109,12 +98,15 @@ message ConformanceRequest { // The full name for the test message to use; for the moment, either: // protobuf_test_messages.proto3.TestAllTypesProto3 or - // protobuf_test_messages.google.protobuf.TestAllTypesProto2. + // protobuf_test_messages.proto2.TestAllTypesProto2 or + // protobuf_test_messages.editions.proto2.TestAllTypesProto2 or + // protobuf_test_messages.editions.proto3.TestAllTypesProto3 or + // protobuf_test_messages.editions.TestAllTypesEdition2023. string message_type = 4; // Each test is given a specific test category. Some category may need - // specific support in testee programs. Refer to the definition of TestCategory - // for more information. + // specific support in testee programs. Refer to the definition of + // TestCategory for more information. TestCategory test_category = 5; // Specify details for how to encode jspb. @@ -140,6 +132,11 @@ message ConformanceResponse { // this field. string serialize_error = 6; + // This should be set if the test program timed out. The string should + // provide more information about what the child process was doing when it + // was killed. + string timeout_error = 9; + // This should be set if some other error occurred. This will always // indicate that the test failed. The string can provide more information // about the failure. @@ -158,8 +155,8 @@ message ConformanceResponse { string skipped = 5; // If the input was successfully parsed and the requested output was JSPB, - // serialize to JSPB and set it in this field. JSPB is google internal only - // format. Opensource testees can just skip it. + // serialize to JSPB and set it in this field. JSPB is only used inside + // Google. Opensource testees can just skip it. string jspb_payload = 7; // If the input was successfully parsed and the requested output was @@ -173,4 +170,3 @@ message JspbEncodingConfig { // Encode the value field of Any as jspb array if true, otherwise binary. bool use_jspb_array_any_format = 1; } - diff --git a/Protos/Sources/Conformance/conformance/test_protos/test_messages_edition2023.proto b/Protos/Sources/Conformance/conformance/test_protos/test_messages_edition2023.proto new file mode 100644 index 000000000..7affff6fd --- /dev/null +++ b/Protos/Sources/Conformance/conformance/test_protos/test_messages_edition2023.proto @@ -0,0 +1,217 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2024 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +edition = "2023"; + +package protobuf_test_messages.editions; + +option features.message_encoding = DELIMITED; +option java_package = "com.google.protobuf_test_messages.edition2023"; +option java_multiple_files = true; +option objc_class_prefix = "Editions"; + +message ComplexMessage { + int32 d = 1; +} + +message TestAllTypesEdition2023 { + message NestedMessage { + int32 a = 1; + TestAllTypesEdition2023 corecursive = 2 + [features.message_encoding = LENGTH_PREFIXED]; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + NEG = -1; // Intentionally negative. + } + + // Singular + int32 optional_int32 = 1; + int64 optional_int64 = 2; + uint32 optional_uint32 = 3; + uint64 optional_uint64 = 4; + sint32 optional_sint32 = 5; + sint64 optional_sint64 = 6; + fixed32 optional_fixed32 = 7; + fixed64 optional_fixed64 = 8; + sfixed32 optional_sfixed32 = 9; + sfixed64 optional_sfixed64 = 10; + float optional_float = 11; + double optional_double = 12; + bool optional_bool = 13; + string optional_string = 14; + bytes optional_bytes = 15; + + NestedMessage optional_nested_message = 18 + [features.message_encoding = LENGTH_PREFIXED]; + ForeignMessageEdition2023 optional_foreign_message = 19 + [features.message_encoding = LENGTH_PREFIXED]; + + NestedEnum optional_nested_enum = 21; + ForeignEnumEdition2023 optional_foreign_enum = 22; + + string optional_string_piece = 24 [ctype = STRING_PIECE]; + string optional_cord = 25 [ctype = CORD]; + + TestAllTypesEdition2023 recursive_message = 27 + [features.message_encoding = LENGTH_PREFIXED]; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + + repeated NestedMessage repeated_nested_message = 48 + [features.message_encoding = LENGTH_PREFIXED]; + repeated ForeignMessageEdition2023 repeated_foreign_message = 49 + [features.message_encoding = LENGTH_PREFIXED]; + + repeated NestedEnum repeated_nested_enum = 51; + repeated ForeignEnumEdition2023 repeated_foreign_enum = 52; + + repeated string repeated_string_piece = 54 [ctype = STRING_PIECE]; + repeated string repeated_cord = 55 [ctype = CORD]; + + // Packed + repeated int32 packed_int32 = 75 [features.repeated_field_encoding = PACKED]; + repeated int64 packed_int64 = 76 [features.repeated_field_encoding = PACKED]; + repeated uint32 packed_uint32 = 77 + [features.repeated_field_encoding = PACKED]; + repeated uint64 packed_uint64 = 78 + [features.repeated_field_encoding = PACKED]; + repeated sint32 packed_sint32 = 79 + [features.repeated_field_encoding = PACKED]; + repeated sint64 packed_sint64 = 80 + [features.repeated_field_encoding = PACKED]; + repeated fixed32 packed_fixed32 = 81 + [features.repeated_field_encoding = PACKED]; + repeated fixed64 packed_fixed64 = 82 + [features.repeated_field_encoding = PACKED]; + repeated sfixed32 packed_sfixed32 = 83 + [features.repeated_field_encoding = PACKED]; + repeated sfixed64 packed_sfixed64 = 84 + [features.repeated_field_encoding = PACKED]; + repeated float packed_float = 85 [features.repeated_field_encoding = PACKED]; + repeated double packed_double = 86 + [features.repeated_field_encoding = PACKED]; + repeated bool packed_bool = 87 [features.repeated_field_encoding = PACKED]; + repeated NestedEnum packed_nested_enum = 88 + [features.repeated_field_encoding = PACKED]; + + // Unpacked + repeated int32 unpacked_int32 = 89 + [features.repeated_field_encoding = EXPANDED]; + repeated int64 unpacked_int64 = 90 + [features.repeated_field_encoding = EXPANDED]; + repeated uint32 unpacked_uint32 = 91 + [features.repeated_field_encoding = EXPANDED]; + repeated uint64 unpacked_uint64 = 92 + [features.repeated_field_encoding = EXPANDED]; + repeated sint32 unpacked_sint32 = 93 + [features.repeated_field_encoding = EXPANDED]; + repeated sint64 unpacked_sint64 = 94 + [features.repeated_field_encoding = EXPANDED]; + repeated fixed32 unpacked_fixed32 = 95 + [features.repeated_field_encoding = EXPANDED]; + repeated fixed64 unpacked_fixed64 = 96 + [features.repeated_field_encoding = EXPANDED]; + repeated sfixed32 unpacked_sfixed32 = 97 + [features.repeated_field_encoding = EXPANDED]; + repeated sfixed64 unpacked_sfixed64 = 98 + [features.repeated_field_encoding = EXPANDED]; + repeated float unpacked_float = 99 + [features.repeated_field_encoding = EXPANDED]; + repeated double unpacked_double = 100 + [features.repeated_field_encoding = EXPANDED]; + repeated bool unpacked_bool = 101 + [features.repeated_field_encoding = EXPANDED]; + repeated NestedEnum unpacked_nested_enum = 102 + [features.repeated_field_encoding = EXPANDED]; + + // Map + map map_int32_int32 = 56; + map map_int64_int64 = 57; + map map_uint32_uint32 = 58; + map map_uint64_uint64 = 59; + map map_sint32_sint32 = 60; + map map_sint64_sint64 = 61; + map map_fixed32_fixed32 = 62; + map map_fixed64_fixed64 = 63; + map map_sfixed32_sfixed32 = 64; + map map_sfixed64_sfixed64 = 65; + map map_int32_float = 66; + map map_int32_double = 67; + map map_bool_bool = 68; + map map_string_string = 69; + map map_string_bytes = 70; + map map_string_nested_message = 71; + map map_string_foreign_message = 72; + map map_string_nested_enum = 73; + map map_string_foreign_enum = 74; + + oneof oneof_field { + uint32 oneof_uint32 = 111; + NestedMessage oneof_nested_message = 112 + [features.message_encoding = LENGTH_PREFIXED]; + string oneof_string = 113; + bytes oneof_bytes = 114; + bool oneof_bool = 115; + uint64 oneof_uint64 = 116; + float oneof_float = 117; + double oneof_double = 118; + NestedEnum oneof_enum = 119; + } + + // extensions + extensions 120 to 200; + + // groups + message GroupLikeType { + int32 group_int32 = 202; + uint32 group_uint32 = 203; + } + GroupLikeType groupliketype = 201; + GroupLikeType delimited_field = 202; +} + +message ForeignMessageEdition2023 { + int32 c = 1; +} + +enum ForeignEnumEdition2023 { + FOREIGN_FOO = 0; + FOREIGN_BAR = 1; + FOREIGN_BAZ = 2; +} + +extend TestAllTypesEdition2023 { + int32 extension_int32 = 120; +} + +message GroupLikeType { + int32 c = 1; +} + +extend TestAllTypesEdition2023 { + GroupLikeType groupliketype = 121; + GroupLikeType delimited_ext = 122; +} diff --git a/Protos/Sources/Conformance/editions/test_messages_proto2_editions.proto b/Protos/Sources/Conformance/editions/test_messages_proto2_editions.proto new file mode 100644 index 000000000..5e5183db1 --- /dev/null +++ b/Protos/Sources/Conformance/editions/test_messages_proto2_editions.proto @@ -0,0 +1,687 @@ +// clang-format off +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Test schema for proto2 messages. This test schema is used by: +// +// - conformance tests + +// LINT: ALLOW_GROUPS + +edition = "2023"; + +package protobuf_test_messages.editions.proto2; + +option features.enum_type = CLOSED; +option features.repeated_field_encoding = EXPANDED; +option features.utf8_validation = NONE; +option java_package = "com.google.protobuf_test_messages.editions.proto2"; +option objc_class_prefix = "EditionsProto2"; + +// This is the default, but we specify it here explicitly. +option optimize_for = SPEED; +option cc_enable_arenas = true; + +// This proto includes every type of field in both singular and repeated +// forms. +// +// Also, crucially, all messages and enums in this file are eventually +// submessages of this message. So for example, a fuzz test of TestAllTypes +// could trigger bugs that occur in any message type in this file. We verify +// this stays true in a unit test. +message TestAllTypesProto2 { + message NestedMessage { + int32 a = 1; + TestAllTypesProto2 corecursive = 2; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + NEG = -1; // Intentionally negative. + } + + // Singular + int32 optional_int32 = 1; + int64 optional_int64 = 2; + uint32 optional_uint32 = 3; + uint64 optional_uint64 = 4; + sint32 optional_sint32 = 5; + sint64 optional_sint64 = 6; + fixed32 optional_fixed32 = 7; + fixed64 optional_fixed64 = 8; + sfixed32 optional_sfixed32 = 9; + sfixed64 optional_sfixed64 = 10; + float optional_float = 11; + double optional_double = 12; + bool optional_bool = 13; + string optional_string = 14; + bytes optional_bytes = 15; + NestedMessage optional_nested_message = 18; + ForeignMessageProto2 optional_foreign_message = 19; + NestedEnum optional_nested_enum = 21; + ForeignEnumProto2 optional_foreign_enum = 22; + string optional_string_piece = 24 [ + ctype = STRING_PIECE + ]; + + string optional_cord = 25 [ + ctype = CORD + ]; + + TestAllTypesProto2 recursive_message = 27; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + repeated NestedMessage repeated_nested_message = 48; + repeated ForeignMessageProto2 repeated_foreign_message = 49; + repeated NestedEnum repeated_nested_enum = 51; + repeated ForeignEnumProto2 repeated_foreign_enum = 52; + repeated string repeated_string_piece = 54 [ + ctype = STRING_PIECE + ]; + + repeated string repeated_cord = 55 [ + ctype = CORD + ]; + + // Packed + repeated int32 packed_int32 = 75 [ + features.repeated_field_encoding = PACKED + ]; + + repeated int64 packed_int64 = 76 [ + features.repeated_field_encoding = PACKED + ]; + + repeated uint32 packed_uint32 = 77 [ + features.repeated_field_encoding = PACKED + ]; + + repeated uint64 packed_uint64 = 78 [ + features.repeated_field_encoding = PACKED + ]; + + repeated sint32 packed_sint32 = 79 [ + features.repeated_field_encoding = PACKED + ]; + + repeated sint64 packed_sint64 = 80 [ + features.repeated_field_encoding = PACKED + ]; + + repeated fixed32 packed_fixed32 = 81 [ + features.repeated_field_encoding = PACKED + ]; + + repeated fixed64 packed_fixed64 = 82 [ + features.repeated_field_encoding = PACKED + ]; + + repeated sfixed32 packed_sfixed32 = 83 [ + features.repeated_field_encoding = PACKED + ]; + + repeated sfixed64 packed_sfixed64 = 84 [ + features.repeated_field_encoding = PACKED + ]; + + repeated float packed_float = 85 [ + features.repeated_field_encoding = PACKED + ]; + + repeated double packed_double = 86 [ + features.repeated_field_encoding = PACKED + ]; + + repeated bool packed_bool = 87 [ + features.repeated_field_encoding = PACKED + ]; + + repeated NestedEnum packed_nested_enum = 88 [ + features.repeated_field_encoding = PACKED + ]; + + // Unpacked + repeated int32 unpacked_int32 = 89; + repeated int64 unpacked_int64 = 90; + repeated uint32 unpacked_uint32 = 91; + repeated uint64 unpacked_uint64 = 92; + repeated sint32 unpacked_sint32 = 93; + repeated sint64 unpacked_sint64 = 94; + repeated fixed32 unpacked_fixed32 = 95; + repeated fixed64 unpacked_fixed64 = 96; + repeated sfixed32 unpacked_sfixed32 = 97; + repeated sfixed64 unpacked_sfixed64 = 98; + repeated float unpacked_float = 99; + repeated double unpacked_double = 100; + repeated bool unpacked_bool = 101; + repeated NestedEnum unpacked_nested_enum = 102; + + // Map + map map_int32_int32 = 56; + map map_int64_int64 = 57; + map map_uint32_uint32 = 58; + map map_uint64_uint64 = 59; + map map_sint32_sint32 = 60; + map map_sint64_sint64 = 61; + map map_fixed32_fixed32 = 62; + map map_fixed64_fixed64 = 63; + map map_sfixed32_sfixed32 = 64; + map map_sfixed64_sfixed64 = 65; + map map_int32_bool = 104; + map map_int32_float = 66; + map map_int32_double = 67; + map map_int32_nested_message = 103; + map map_bool_bool = 68; + map map_string_string = 69; + map map_string_bytes = 70; + map map_string_nested_message = 71; + map map_string_foreign_message = 72; + map map_string_nested_enum = 73; + map map_string_foreign_enum = 74; + + oneof oneof_field { + uint32 oneof_uint32 = 111; + NestedMessage oneof_nested_message = 112; + string oneof_string = 113; + bytes oneof_bytes = 114; + bool oneof_bool = 115; + uint64 oneof_uint64 = 116; + float oneof_float = 117; + double oneof_double = 118; + NestedEnum oneof_enum = 119; + } + + // extensions + extensions 120 to 200; + + // groups + message Data { + int32 group_int32 = 202; + uint32 group_uint32 = 203; + } + + Data data = 201 [ + features.message_encoding = DELIMITED + ]; + + message MultiWordGroupField { + int32 group_int32 = 205; + uint32 group_uint32 = 206; + } + + MultiWordGroupField multiwordgroupfield = 204 [ + features.message_encoding = DELIMITED + ]; + + // default values + int32 default_int32 = 241 [ + default = -123456789 + ]; + + int64 default_int64 = 242 [ + default = -9123456789123456789 + ]; + + uint32 default_uint32 = 243 [ + default = 2123456789 + ]; + + uint64 default_uint64 = 244 [ + default = 10123456789123456789 + ]; + + sint32 default_sint32 = 245 [ + default = -123456789 + ]; + + sint64 default_sint64 = 246 [ + default = -9123456789123456789 + ]; + + fixed32 default_fixed32 = 247 [ + default = 2123456789 + ]; + + fixed64 default_fixed64 = 248 [ + default = 10123456789123456789 + ]; + + sfixed32 default_sfixed32 = 249 [ + default = -123456789 + ]; + + sfixed64 default_sfixed64 = 250 [ + default = -9123456789123456789 + ]; + + float default_float = 251 [ + default = 9e9 + ]; + + double default_double = 252 [ + default = 7e22 + ]; + + bool default_bool = 253 [ + default = true + ]; + + string default_string = 254 [ + default = "Rosebud" + ]; + + bytes default_bytes = 255 [ + default = "joshua" + ]; + + // Test field-name-to-JSON-name convention. + // (protobuf says names can be any valid C/C++ identifier.) + int32 fieldname1 = 401; + int32 field_name2 = 402; + int32 _field_name3 = 403; + int32 field__name4_ = 404; + int32 field0name5 = 405; + int32 field_0_name6 = 406; + int32 fieldName7 = 407; + int32 FieldName8 = 408; + int32 field_Name9 = 409; + int32 Field_Name10 = 410; + int32 FIELD_NAME11 = 411; + int32 FIELD_name12 = 412; + int32 __field_name13 = 413; + int32 __Field_name14 = 414; + int32 field__name15 = 415; + int32 field__Name16 = 416; + int32 field_name17__ = 417; + int32 Field_name18__ = 418; + + // Reserved for unknown fields test. + reserved 1000 to 9999; + + MessageSetCorrect message_set_correct = 500; + + // message_set test case. + message MessageSetCorrect { + option message_set_wire_format = true; + + extensions 4 to max; + } + + message MessageSetCorrectExtension1 { + extend MessageSetCorrect { + MessageSetCorrectExtension1 message_set_extension = 1547769; + } + + string str = 25; + } + + message MessageSetCorrectExtension2 { + extend MessageSetCorrect { + MessageSetCorrectExtension2 message_set_extension = 4135312; + } + + int32 i = 9; + } + + message ExtensionWithOneof { + oneof oneof_field { + int32 a = 1; + int32 b = 2; + } + + extend MessageSetCorrect { + ExtensionWithOneof extension_with_oneof = 123456789; + } + } + + reserved reserved_field; + + reserved 999999; +} + +message ForeignMessageProto2 { + int32 c = 1; +} + +enum ForeignEnumProto2 { + FOREIGN_FOO = 0; + FOREIGN_BAR = 1; + FOREIGN_BAZ = 2; +} + +extend TestAllTypesProto2 { + int32 extension_int32 = 120; +} + +extend TestAllTypesProto2 { + GroupField groupfield = 121 [ + features.message_encoding = DELIMITED + ]; +} + +message GroupField { + int32 group_int32 = 122; + uint32 group_uint32 = 123; +} + +message UnknownToTestAllTypes { + int32 optional_int32 = 1001; + string optional_string = 1002; + ForeignMessageProto2 nested_message = 1003; + + message OptionalGroup { + int32 a = 1; + } + + OptionalGroup optionalgroup = 1004 [ + features.message_encoding = DELIMITED + ]; + + bool optional_bool = 1006; + repeated int32 repeated_int32 = 1011; +} + +message NullHypothesisProto2 { +} + +message EnumOnlyProto2 { + enum Bool { + kFalse = 0; + kTrue = 1; + } +} + +message OneStringProto2 { + string data = 1; +} + +message ProtoWithKeywords { + int32 inline = 1; + string concept = 2; + repeated string requires = 3; +} + +message TestAllRequiredTypesProto2 { + message NestedMessage { + int32 a = 1 [ + features.field_presence = LEGACY_REQUIRED + ]; + + TestAllRequiredTypesProto2 corecursive = 2 [ + features.field_presence = LEGACY_REQUIRED + ]; + + TestAllRequiredTypesProto2 optional_corecursive = 3; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + NEG = -1; // Intentionally negative. + } + + // Singular + int32 required_int32 = 1 [ + features.field_presence = LEGACY_REQUIRED + ]; + + int64 required_int64 = 2 [ + features.field_presence = LEGACY_REQUIRED + ]; + + uint32 required_uint32 = 3 [ + features.field_presence = LEGACY_REQUIRED + ]; + + uint64 required_uint64 = 4 [ + features.field_presence = LEGACY_REQUIRED + ]; + + sint32 required_sint32 = 5 [ + features.field_presence = LEGACY_REQUIRED + ]; + + sint64 required_sint64 = 6 [ + features.field_presence = LEGACY_REQUIRED + ]; + + fixed32 required_fixed32 = 7 [ + features.field_presence = LEGACY_REQUIRED + ]; + + fixed64 required_fixed64 = 8 [ + features.field_presence = LEGACY_REQUIRED + ]; + + sfixed32 required_sfixed32 = 9 [ + features.field_presence = LEGACY_REQUIRED + ]; + + sfixed64 required_sfixed64 = 10 [ + features.field_presence = LEGACY_REQUIRED + ]; + + float required_float = 11 [ + features.field_presence = LEGACY_REQUIRED + ]; + + double required_double = 12 [ + features.field_presence = LEGACY_REQUIRED + ]; + + bool required_bool = 13 [ + features.field_presence = LEGACY_REQUIRED + ]; + + string required_string = 14 [ + features.field_presence = LEGACY_REQUIRED + ]; + + bytes required_bytes = 15 [ + features.field_presence = LEGACY_REQUIRED + ]; + + NestedMessage required_nested_message = 18 [ + features.field_presence = LEGACY_REQUIRED + ]; + + ForeignMessageProto2 required_foreign_message = 19 [ + features.field_presence = LEGACY_REQUIRED + ]; + + NestedEnum required_nested_enum = 21 [ + features.field_presence = LEGACY_REQUIRED + ]; + + ForeignEnumProto2 required_foreign_enum = 22 [ + features.field_presence = LEGACY_REQUIRED + ]; + + string required_string_piece = 24 [ + features.field_presence = LEGACY_REQUIRED, + ctype = STRING_PIECE + ]; + + string required_cord = 25 [ + features.field_presence = LEGACY_REQUIRED, + ctype = CORD + ]; + + TestAllRequiredTypesProto2 recursive_message = 27 [ + features.field_presence = LEGACY_REQUIRED + ]; + + TestAllRequiredTypesProto2 optional_recursive_message = 28; + + // extensions + extensions 120 to 200; + + // groups + message Data { + int32 group_int32 = 202 [ + features.field_presence = LEGACY_REQUIRED + ]; + + uint32 group_uint32 = 203 [ + features.field_presence = LEGACY_REQUIRED + ]; + } + + Data data = 201 [ + features.field_presence = LEGACY_REQUIRED, + features.message_encoding = DELIMITED + ]; + + // default values + int32 default_int32 = 241 [ + features.field_presence = LEGACY_REQUIRED, + default = -123456789 + ]; + + int64 default_int64 = 242 [ + features.field_presence = LEGACY_REQUIRED, + default = -9123456789123456789 + ]; + + uint32 default_uint32 = 243 [ + features.field_presence = LEGACY_REQUIRED, + default = 2123456789 + ]; + + uint64 default_uint64 = 244 [ + features.field_presence = LEGACY_REQUIRED, + default = 10123456789123456789 + ]; + + sint32 default_sint32 = 245 [ + features.field_presence = LEGACY_REQUIRED, + default = -123456789 + ]; + + sint64 default_sint64 = 246 [ + features.field_presence = LEGACY_REQUIRED, + default = -9123456789123456789 + ]; + + fixed32 default_fixed32 = 247 [ + features.field_presence = LEGACY_REQUIRED, + default = 2123456789 + ]; + + fixed64 default_fixed64 = 248 [ + features.field_presence = LEGACY_REQUIRED, + default = 10123456789123456789 + ]; + + sfixed32 default_sfixed32 = 249 [ + features.field_presence = LEGACY_REQUIRED, + default = -123456789 + ]; + + sfixed64 default_sfixed64 = 250 [ + features.field_presence = LEGACY_REQUIRED, + default = -9123456789123456789 + ]; + + float default_float = 251 [ + features.field_presence = LEGACY_REQUIRED, + default = 9e9 + ]; + + double default_double = 252 [ + features.field_presence = LEGACY_REQUIRED, + default = 7e22 + ]; + + bool default_bool = 253 [ + features.field_presence = LEGACY_REQUIRED, + default = true + ]; + + string default_string = 254 [ + features.field_presence = LEGACY_REQUIRED, + default = "Rosebud" + ]; + + bytes default_bytes = 255 [ + features.field_presence = LEGACY_REQUIRED, + default = "joshua" + ]; + + // Reserved for unknown fields test. + reserved 1000 to 9999; + + // message_set test case. + message MessageSetCorrect { + option message_set_wire_format = true; + + extensions 4 to max; + } + + message MessageSetCorrectExtension1 { + extend MessageSetCorrect { + MessageSetCorrectExtension1 message_set_extension = 1547769; + } + + string str = 25 [ + features.field_presence = LEGACY_REQUIRED + ]; + } + + message MessageSetCorrectExtension2 { + extend MessageSetCorrect { + MessageSetCorrectExtension2 message_set_extension = 4135312; + } + + int32 i = 9 [ + features.field_presence = LEGACY_REQUIRED + ]; + } +} + +message TestLargeOneof { + message A1 { + } + + message A2 { + } + + message A3 { + } + + message A4 { + } + + message A5 { + } + + oneof large_oneof { + A1 a1 = 1; + A2 a2 = 2; + A3 a3 = 3; + A4 a4 = 4; + A5 a5 = 5; + } +} diff --git a/Protos/Sources/Conformance/editions/test_messages_proto3_editions.proto b/Protos/Sources/Conformance/editions/test_messages_proto3_editions.proto new file mode 100644 index 000000000..ea6b0946f --- /dev/null +++ b/Protos/Sources/Conformance/editions/test_messages_proto3_editions.proto @@ -0,0 +1,313 @@ +// clang-format off +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Test schema for proto3 messages. This test schema is used by: +// +// - benchmarks +// - fuzz tests +// - conformance tests + +edition = "2023"; + +package protobuf_test_messages.editions.proto3; + +import "google/protobuf/any.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/field_mask.proto"; +import "google/protobuf/struct.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/wrappers.proto"; + +option features.field_presence = IMPLICIT; +option java_package = "com.google.protobuf_test_messages.editions.proto3"; +option objc_class_prefix = "EditionsProto3"; + +// This is the default, but we specify it here explicitly. +option optimize_for = SPEED; +option cc_enable_arenas = true; + +// This proto includes every type of field in both singular and repeated +// forms. +// +// Also, crucially, all messages and enums in this file are eventually +// submessages of this message. So for example, a fuzz test of TestAllTypes +// could trigger bugs that occur in any message type in this file. We verify +// this stays true in a unit test. +message TestAllTypesProto3 { + message NestedMessage { + int32 a = 1; + TestAllTypesProto3 corecursive = 2; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + NEG = -1; // Intentionally negative. + } + + enum AliasedEnum { + option allow_alias = true; + + ALIAS_FOO = 0; + ALIAS_BAR = 1; + ALIAS_BAZ = 2; + MOO = 2; + moo = 2; + bAz = 2; + } + + // Singular + // test [kotlin] comment + int32 optional_int32 = 1; + int64 optional_int64 = 2; + uint32 optional_uint32 = 3; + uint64 optional_uint64 = 4; + sint32 optional_sint32 = 5; + sint64 optional_sint64 = 6; + fixed32 optional_fixed32 = 7; + fixed64 optional_fixed64 = 8; + sfixed32 optional_sfixed32 = 9; + sfixed64 optional_sfixed64 = 10; + float optional_float = 11; + double optional_double = 12; + bool optional_bool = 13; + string optional_string = 14; + bytes optional_bytes = 15; + NestedMessage optional_nested_message = 18; + ForeignMessage optional_foreign_message = 19; + NestedEnum optional_nested_enum = 21; + ForeignEnum optional_foreign_enum = 22; + AliasedEnum optional_aliased_enum = 23; + string optional_string_piece = 24 [ + ctype = STRING_PIECE + ]; + + string optional_cord = 25 [ + ctype = CORD + ]; + + TestAllTypesProto3 recursive_message = 27; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + repeated NestedMessage repeated_nested_message = 48; + repeated ForeignMessage repeated_foreign_message = 49; + repeated NestedEnum repeated_nested_enum = 51; + repeated ForeignEnum repeated_foreign_enum = 52; + repeated string repeated_string_piece = 54 [ + ctype = STRING_PIECE + ]; + + repeated string repeated_cord = 55 [ + ctype = CORD + ]; + + // Packed + repeated int32 packed_int32 = 75; + repeated int64 packed_int64 = 76; + repeated uint32 packed_uint32 = 77; + repeated uint64 packed_uint64 = 78; + repeated sint32 packed_sint32 = 79; + repeated sint64 packed_sint64 = 80; + repeated fixed32 packed_fixed32 = 81; + repeated fixed64 packed_fixed64 = 82; + repeated sfixed32 packed_sfixed32 = 83; + repeated sfixed64 packed_sfixed64 = 84; + repeated float packed_float = 85; + repeated double packed_double = 86; + repeated bool packed_bool = 87; + repeated NestedEnum packed_nested_enum = 88; + + // Unpacked + repeated int32 unpacked_int32 = 89 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated int64 unpacked_int64 = 90 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated uint32 unpacked_uint32 = 91 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated uint64 unpacked_uint64 = 92 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated sint32 unpacked_sint32 = 93 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated sint64 unpacked_sint64 = 94 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated fixed32 unpacked_fixed32 = 95 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated fixed64 unpacked_fixed64 = 96 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated sfixed32 unpacked_sfixed32 = 97 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated sfixed64 unpacked_sfixed64 = 98 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated float unpacked_float = 99 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated double unpacked_double = 100 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated bool unpacked_bool = 101 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated NestedEnum unpacked_nested_enum = 102 [ + features.repeated_field_encoding = EXPANDED + ]; + + // Map + map map_int32_int32 = 56; + map map_int64_int64 = 57; + map map_uint32_uint32 = 58; + map map_uint64_uint64 = 59; + map map_sint32_sint32 = 60; + map map_sint64_sint64 = 61; + map map_fixed32_fixed32 = 62; + map map_fixed64_fixed64 = 63; + map map_sfixed32_sfixed32 = 64; + map map_sfixed64_sfixed64 = 65; + map map_int32_float = 66; + map map_int32_double = 67; + map map_bool_bool = 68; + map map_string_string = 69; + map map_string_bytes = 70; + map map_string_nested_message = 71; + map map_string_foreign_message = 72; + map map_string_nested_enum = 73; + map map_string_foreign_enum = 74; + + oneof oneof_field { + uint32 oneof_uint32 = 111; + NestedMessage oneof_nested_message = 112; + string oneof_string = 113; + bytes oneof_bytes = 114; + bool oneof_bool = 115; + uint64 oneof_uint64 = 116; + float oneof_float = 117; + double oneof_double = 118; + NestedEnum oneof_enum = 119; + google.protobuf.NullValue oneof_null_value = 120; + } + + // Well-known types + google.protobuf.BoolValue optional_bool_wrapper = 201; + google.protobuf.Int32Value optional_int32_wrapper = 202; + google.protobuf.Int64Value optional_int64_wrapper = 203; + google.protobuf.UInt32Value optional_uint32_wrapper = 204; + google.protobuf.UInt64Value optional_uint64_wrapper = 205; + google.protobuf.FloatValue optional_float_wrapper = 206; + google.protobuf.DoubleValue optional_double_wrapper = 207; + google.protobuf.StringValue optional_string_wrapper = 208; + google.protobuf.BytesValue optional_bytes_wrapper = 209; + repeated google.protobuf.BoolValue repeated_bool_wrapper = 211; + repeated google.protobuf.Int32Value repeated_int32_wrapper = 212; + repeated google.protobuf.Int64Value repeated_int64_wrapper = 213; + repeated google.protobuf.UInt32Value repeated_uint32_wrapper = 214; + repeated google.protobuf.UInt64Value repeated_uint64_wrapper = 215; + repeated google.protobuf.FloatValue repeated_float_wrapper = 216; + repeated google.protobuf.DoubleValue repeated_double_wrapper = 217; + repeated google.protobuf.StringValue repeated_string_wrapper = 218; + repeated google.protobuf.BytesValue repeated_bytes_wrapper = 219; + google.protobuf.Duration optional_duration = 301; + google.protobuf.Timestamp optional_timestamp = 302; + google.protobuf.FieldMask optional_field_mask = 303; + google.protobuf.Struct optional_struct = 304; + google.protobuf.Any optional_any = 305; + google.protobuf.Value optional_value = 306; + google.protobuf.NullValue optional_null_value = 307; + repeated google.protobuf.Duration repeated_duration = 311; + repeated google.protobuf.Timestamp repeated_timestamp = 312; + repeated google.protobuf.FieldMask repeated_fieldmask = 313; + repeated google.protobuf.Struct repeated_struct = 324; + repeated google.protobuf.Any repeated_any = 315; + repeated google.protobuf.Value repeated_value = 316; + repeated google.protobuf.ListValue repeated_list_value = 317; + + // Test field-name-to-JSON-name convention. + // (protobuf says names can be any valid C/C++ identifier.) + int32 fieldname1 = 401; + int32 field_name2 = 402; + int32 _field_name3 = 403; + int32 field__name4_ = 404; + int32 field0name5 = 405; + int32 field_0_name6 = 406; + int32 fieldName7 = 407; + int32 FieldName8 = 408; + int32 field_Name9 = 409; + int32 Field_Name10 = 410; + int32 FIELD_NAME11 = 411; + int32 FIELD_name12 = 412; + int32 __field_name13 = 413; + int32 __Field_name14 = 414; + int32 field__name15 = 415; + int32 field__Name16 = 416; + int32 field_name17__ = 417; + int32 Field_name18__ = 418; + + // Reserved for testing unknown fields + reserved 501 to 510; + + reserved reserved_field; + + reserved 999999; +} + +message ForeignMessage { + int32 c = 1; +} + +enum ForeignEnum { + FOREIGN_FOO = 0; + FOREIGN_BAR = 1; + FOREIGN_BAZ = 2; +} + +message NullHypothesisProto3 { +} + +message EnumOnlyProto3 { + enum Bool { + kFalse = 0; + kTrue = 1; + } +} diff --git a/Protos/google/protobuf/test_messages_proto2.proto b/Protos/Sources/Conformance/google/protobuf/test_messages_proto2.proto similarity index 60% rename from Protos/google/protobuf/test_messages_proto2.proto rename to Protos/Sources/Conformance/google/protobuf/test_messages_proto2.proto index d064fbb88..d62480684 100644 --- a/Protos/google/protobuf/test_messages_proto2.proto +++ b/Protos/Sources/Conformance/google/protobuf/test_messages_proto2.proto @@ -1,32 +1,9 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd // // Test schema for proto2 messages. This test schema is used by: // @@ -40,12 +17,14 @@ syntax = "proto2"; package protobuf_test_messages.proto2; option java_package = "com.google.protobuf_test_messages.proto2"; +option objc_class_prefix = "Proto2"; // This is the default, but we specify it here explicitly. option optimize_for = SPEED; option cc_enable_arenas = true; + // This proto includes every type of field in both singular and repeated // forms. // @@ -163,8 +142,10 @@ message TestAllTypesProto2 { map map_fixed64_fixed64 = 63; map map_sfixed32_sfixed32 = 64; map map_sfixed64_sfixed64 = 65; + map map_int32_bool = 104; map map_int32_float = 66; map map_int32_double = 67; + map map_int32_nested_message = 103; map map_bool_bool = 68; map map_string_string = 69; map map_string_bytes = 70; @@ -194,6 +175,28 @@ message TestAllTypesProto2 { optional uint32 group_uint32 = 203; } + optional group MultiWordGroupField = 204 { + optional int32 group_int32 = 205; + optional uint32 group_uint32 = 206; + } + + // default values + optional int32 default_int32 = 241 [default = -123456789]; + optional int64 default_int64 = 242 [default = -9123456789123456789]; + optional uint32 default_uint32 = 243 [default = 2123456789]; + optional uint64 default_uint64 = 244 [default = 10123456789123456789]; + optional sint32 default_sint32 = 245 [default = -123456789]; + optional sint64 default_sint64 = 246 [default = -9123456789123456789]; + optional fixed32 default_fixed32 = 247 [default = 2123456789]; + optional fixed64 default_fixed64 = 248 [default = 10123456789123456789]; + optional sfixed32 default_sfixed32 = 249 [default = -123456789]; + optional sfixed64 default_sfixed64 = 250 [default = -9123456789123456789]; + optional float default_float = 251 [default = 9e9]; + optional double default_double = 252 [default = 7e22]; + optional bool default_bool = 253 [default = true]; + optional string default_string = 254 [default = "Rosebud"]; + optional bytes default_bytes = 255 [default = "joshua"]; + // Test field-name-to-JSON-name convention. // (protobuf says names can be any valid C/C++ identifier.) optional int32 fieldname1 = 401; @@ -218,6 +221,8 @@ message TestAllTypesProto2 { // Reserved for unknown fields test. reserved 1000 to 9999; + optional MessageSetCorrect message_set_correct = 500; + // message_set test case. message MessageSetCorrect { option message_set_wire_format = true; @@ -238,6 +243,19 @@ message TestAllTypesProto2 { } optional int32 i = 9; } + + message ExtensionWithOneof { + oneof oneof_field { + int32 a = 1; + int32 b = 2; + } + extend MessageSetCorrect { + optional ExtensionWithOneof extension_with_oneof = 123456789; + } + } + + reserved "reserved_field"; + reserved 999999; } message ForeignMessageProto2 { @@ -254,6 +272,13 @@ extend TestAllTypesProto2 { optional int32 extension_int32 = 120; } +extend TestAllTypesProto2 { + optional group GroupField = 121 { + optional int32 group_int32 = 122; + optional uint32 group_uint32 = 123; + } +} + message UnknownToTestAllTypes { optional int32 optional_int32 = 1001; optional string optional_string = 1002; @@ -265,8 +290,7 @@ message UnknownToTestAllTypes { repeated int32 repeated_int32 = 1011; } -message NullHypothesisProto2 { -} +message NullHypothesisProto2 {} message EnumOnlyProto2 { enum Bool { @@ -274,3 +298,122 @@ message EnumOnlyProto2 { kTrue = 1; } } + +message OneStringProto2 { + optional string data = 1; +} + +message ProtoWithKeywords { + optional int32 inline = 1; + optional string concept = 2; + repeated string requires = 3; +} + +message TestAllRequiredTypesProto2 { + message NestedMessage { + required int32 a = 1; + required TestAllRequiredTypesProto2 corecursive = 2; + optional TestAllRequiredTypesProto2 optional_corecursive = 3; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + NEG = -1; // Intentionally negative. + } + + // Singular + required int32 required_int32 = 1; + required int64 required_int64 = 2; + required uint32 required_uint32 = 3; + required uint64 required_uint64 = 4; + required sint32 required_sint32 = 5; + required sint64 required_sint64 = 6; + required fixed32 required_fixed32 = 7; + required fixed64 required_fixed64 = 8; + required sfixed32 required_sfixed32 = 9; + required sfixed64 required_sfixed64 = 10; + required float required_float = 11; + required double required_double = 12; + required bool required_bool = 13; + required string required_string = 14; + required bytes required_bytes = 15; + + required NestedMessage required_nested_message = 18; + required ForeignMessageProto2 required_foreign_message = 19; + + required NestedEnum required_nested_enum = 21; + required ForeignEnumProto2 required_foreign_enum = 22; + + required string required_string_piece = 24 [ctype = STRING_PIECE]; + required string required_cord = 25 [ctype = CORD]; + + required TestAllRequiredTypesProto2 recursive_message = 27; + optional TestAllRequiredTypesProto2 optional_recursive_message = 28; + + // extensions + extensions 120 to 200; + + // groups + required group Data = 201 { + required int32 group_int32 = 202; + required uint32 group_uint32 = 203; + } + + // default values + required int32 default_int32 = 241 [default = -123456789]; + required int64 default_int64 = 242 [default = -9123456789123456789]; + required uint32 default_uint32 = 243 [default = 2123456789]; + required uint64 default_uint64 = 244 [default = 10123456789123456789]; + required sint32 default_sint32 = 245 [default = -123456789]; + required sint64 default_sint64 = 246 [default = -9123456789123456789]; + required fixed32 default_fixed32 = 247 [default = 2123456789]; + required fixed64 default_fixed64 = 248 [default = 10123456789123456789]; + required sfixed32 default_sfixed32 = 249 [default = -123456789]; + required sfixed64 default_sfixed64 = 250 [default = -9123456789123456789]; + required float default_float = 251 [default = 9e9]; + required double default_double = 252 [default = 7e22]; + required bool default_bool = 253 [default = true]; + required string default_string = 254 [default = "Rosebud"]; + required bytes default_bytes = 255 [default = "joshua"]; + + // Reserved for unknown fields test. + reserved 1000 to 9999; + + // message_set test case. + message MessageSetCorrect { + option message_set_wire_format = true; + + extensions 4 to max; + } + + message MessageSetCorrectExtension1 { + extend MessageSetCorrect { + optional MessageSetCorrectExtension1 message_set_extension = 1547769; + } + required string str = 25; + } + + message MessageSetCorrectExtension2 { + extend MessageSetCorrect { + optional MessageSetCorrectExtension2 message_set_extension = 4135312; + } + required int32 i = 9; + } +} + +message TestLargeOneof { + message A1 {} + message A2 {} + message A3 {} + message A4 {} + message A5 {} + oneof large_oneof { + A1 a1 = 1; + A2 a2 = 2; + A3 a3 = 3; + A4 a4 = 4; + A5 a5 = 5; + } +} diff --git a/Protos/google/protobuf/test_messages_proto3.proto b/Protos/Sources/Conformance/google/protobuf/test_messages_proto3.proto similarity index 84% rename from Protos/google/protobuf/test_messages_proto3.proto rename to Protos/Sources/Conformance/google/protobuf/test_messages_proto3.proto index 278ee4f93..6d29b1b38 100644 --- a/Protos/google/protobuf/test_messages_proto3.proto +++ b/Protos/Sources/Conformance/google/protobuf/test_messages_proto3.proto @@ -1,32 +1,9 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd // // Test schema for proto3 messages. This test schema is used by: // @@ -80,12 +57,13 @@ message TestAllTypesProto3 { ALIAS_FOO = 0; ALIAS_BAR = 1; ALIAS_BAZ = 2; - QUX = 2; - qux = 2; + MOO = 2; + moo = 2; bAz = 2; } // Singular + // test [kotlin] comment int32 optional_int32 = 1; int64 optional_int64 = 2; uint32 optional_uint32 = 3; @@ -266,6 +244,9 @@ message TestAllTypesProto3 { // Reserved for testing unknown fields reserved 501 to 510; + + reserved "reserved_field"; + reserved 999999; } message ForeignMessage { @@ -278,8 +259,7 @@ enum ForeignEnum { FOREIGN_BAZ = 2; } -message NullHypothesisProto3 { -} +message NullHypothesisProto3 {} message EnumOnlyProto3 { enum Bool { diff --git a/Protos/google/protobuf/any.proto b/Protos/Sources/SwiftProtobuf/google/protobuf/any.proto similarity index 95% rename from Protos/google/protobuf/any.proto rename to Protos/Sources/SwiftProtobuf/google/protobuf/any.proto index 6ed8a23cf..eff44e509 100644 --- a/Protos/google/protobuf/any.proto +++ b/Protos/Sources/SwiftProtobuf/google/protobuf/any.proto @@ -32,12 +32,12 @@ syntax = "proto3"; package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option go_package = "google.golang.org/protobuf/types/known/anypb"; option java_package = "com.google.protobuf"; option java_outer_classname = "AnyProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; // `Any` contains an arbitrary serialized protocol buffer message along with a // URL that describes the type of the serialized message. @@ -63,6 +63,10 @@ option objc_class_prefix = "GPB"; // if (any.is(Foo.class)) { // foo = any.unpack(Foo.class); // } +// // or ... +// if (any.isSameTypeAs(Foo.getDefaultInstance())) { +// foo = any.unpack(Foo.getDefaultInstance()); +// } // // Example 3: Pack and unpack a message in Python. // @@ -93,7 +97,6 @@ option objc_class_prefix = "GPB"; // in the type URL, for example "foo.bar.com/x/y.z" will yield type // name "y.z". // -// // JSON // ==== // The JSON representation of an `Any` value uses the regular @@ -146,7 +149,8 @@ message Any { // // Note: this functionality is not currently available in the official // protobuf release, and it is not used for type URLs beginning with - // type.googleapis.com. + // type.googleapis.com. As of May 2023, there are no widely used type server + // implementations and no plans to implement one. // // Schemes other than `http`, `https` (or the empty scheme) might be // used with implementation specific semantics. diff --git a/Protos/google/protobuf/api.proto b/Protos/Sources/SwiftProtobuf/google/protobuf/api.proto similarity index 87% rename from Protos/google/protobuf/api.proto rename to Protos/Sources/SwiftProtobuf/google/protobuf/api.proto index 3d598fc85..c8f742543 100644 --- a/Protos/google/protobuf/api.proto +++ b/Protos/Sources/SwiftProtobuf/google/protobuf/api.proto @@ -35,11 +35,11 @@ package google.protobuf; import "google/protobuf/source_context.proto"; import "google/protobuf/type.proto"; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option java_package = "com.google.protobuf"; option java_outer_classname = "ApiProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option go_package = "google.golang.org/protobuf/types/known/apipb"; // Api is a light-weight descriptor for an API Interface. @@ -51,6 +51,11 @@ option go_package = "google.golang.org/protobuf/types/known/apipb"; // sometimes simply referred to as "APIs" in other contexts, such as the name of // this message itself. See https://cloud.google.com/apis/design/glossary for // detailed terminology. +// +// New usages of this message as an alternative to ServiceDescriptorProto are +// strongly discouraged. This message does not reliability preserve all +// information necessary to model the schema and preserve semantics. Instead +// make use of FileDescriptorSet which preserves the necessary information. message Api { // The fully qualified name of this interface, including package name // followed by the interface's simple name. @@ -82,7 +87,6 @@ message Api { // be omitted. Zero major versions must only be used for // experimental, non-GA interfaces. // - // string version = 4; // Source context for the protocol buffer service represented by this @@ -94,9 +98,17 @@ message Api { // The source syntax of the service. Syntax syntax = 7; + + // The source edition string, only valid when syntax is SYNTAX_EDITIONS. + string edition = 8; } // Method represents a method of an API interface. +// +// New usages of this message as an alternative to MethodDescriptorProto are +// strongly discouraged. This message does not reliability preserve all +// information necessary to model the schema and preserve semantics. Instead +// make use of FileDescriptorSet which preserves the necessary information. message Method { // The simple name of this method. string name = 1; @@ -117,7 +129,16 @@ message Method { repeated Option options = 6; // The source syntax of this method. - Syntax syntax = 7; + // + // This field should be ignored, instead the syntax should be inherited from + // Api. This is similar to Field and EnumValue. + Syntax syntax = 7 [deprecated = true]; + + // The source edition string, only valid when syntax is SYNTAX_EDITIONS. + // + // This field should be ignored, instead the edition should be inherited from + // Api. This is similar to Field and EnumValue. + string edition = 8 [deprecated = true]; } // Declares an API Interface to be included in this interface. The including diff --git a/Protos/google/protobuf/descriptor.proto b/Protos/Sources/SwiftProtobuf/google/protobuf/descriptor.proto similarity index 60% rename from Protos/google/protobuf/descriptor.proto rename to Protos/Sources/SwiftProtobuf/google/protobuf/descriptor.proto index 156e410ae..e5683a271 100644 --- a/Protos/google/protobuf/descriptor.proto +++ b/Protos/Sources/SwiftProtobuf/google/protobuf/descriptor.proto @@ -36,7 +36,6 @@ // A valid .proto file can be translated directly to a FileDescriptorProto // without any other information (e.g. without reading its imports). - syntax = "proto2"; package google.protobuf; @@ -56,6 +55,52 @@ option optimize_for = SPEED; // files it parses. message FileDescriptorSet { repeated FileDescriptorProto file = 1; + + // Extensions for tooling. + extensions 536000000 [declaration = { + number: 536000000 + type: ".buf.descriptor.v1.FileDescriptorSetExtension" + full_name: ".buf.descriptor.v1.buf_file_descriptor_set_extension" + }]; +} + +// The full set of known editions. +enum Edition { + // A placeholder for an unknown edition value. + EDITION_UNKNOWN = 0; + + // A placeholder edition for specifying default behaviors *before* a feature + // was first introduced. This is effectively an "infinite past". + EDITION_LEGACY = 900; + + // Legacy syntax "editions". These pre-date editions, but behave much like + // distinct editions. These can't be used to specify the edition of proto + // files, but feature definitions must supply proto2/proto3 defaults for + // backwards compatibility. + EDITION_PROTO2 = 998; + EDITION_PROTO3 = 999; + + // Editions that have been released. The specific values are arbitrary and + // should not be depended on, but they will always be time-ordered for easy + // comparison. + EDITION_2023 = 1000; + EDITION_2024 = 1001; + + // A placeholder edition for developing and testing unscheduled features. + EDITION_UNSTABLE = 9999; + + // Placeholder editions for testing feature resolution. These should not be + // used or relied on outside of tests. + EDITION_1_TEST_ONLY = 1; + EDITION_2_TEST_ONLY = 2; + EDITION_99997_TEST_ONLY = 99997; + EDITION_99998_TEST_ONLY = 99998; + EDITION_99999_TEST_ONLY = 99999; + + // Placeholder for specifying unbounded edition support. This should only + // ever be used by plugins that can expect to never require any changes to + // support a new edition. + EDITION_MAX = 0x7FFFFFFF; } // Describes a complete .proto file. @@ -71,6 +116,10 @@ message FileDescriptorProto { // For Google-internal migration only. Do not use. repeated int32 weak_dependency = 11; + // Names of files imported by this file purely for the purpose of providing + // option extensions. These are excluded from the dependency list above. + repeated string option_dependency = 15; + // All top-level definitions in this file. repeated DescriptorProto message_type = 4; repeated EnumDescriptorProto enum_type = 5; @@ -86,8 +135,19 @@ message FileDescriptorProto { optional SourceCodeInfo source_code_info = 9; // The syntax of the proto file. - // The supported values are "proto2" and "proto3". + // The supported values are "proto2", "proto3", and "editions". + // + // If `edition` is present, this value must be "editions". + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. optional string syntax = 12; + + // The edition of the proto file. + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional Edition edition = 14; } // Describes a message type. @@ -123,12 +183,60 @@ message DescriptorProto { // Reserved field names, which may not be used by fields in the same message. // A given name may only be reserved once. repeated string reserved_name = 10; + + // Support for `export` and `local` keywords on enums. + optional SymbolVisibility visibility = 11; } message ExtensionRangeOptions { // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; + message Declaration { + // The extension number declared within the extension range. + optional int32 number = 1; + + // The fully-qualified name of the extension field. There must be a leading + // dot in front of the full name. + optional string full_name = 2; + + // The fully-qualified type name of the extension field. Unlike + // Metadata.type, Declaration.type must have a leading dot for messages + // and enums. + optional string type = 3; + + // If true, indicates that the number is reserved in the extension range, + // and any extension field with the number will fail to compile. Set this + // when a declared extension field is deleted. + optional bool reserved = 5; + + // If true, indicates that the extension must be defined as repeated. + // Otherwise the extension must be defined as optional. + optional bool repeated = 6; + + reserved 4; // removed is_repeated + } + + // For external users: DO NOT USE. We are in the process of open sourcing + // extension declaration and executing internal cleanups before it can be + // used externally. + repeated Declaration declaration = 2 [retention = RETENTION_SOURCE]; + + // Any features defined in the specific edition. + optional FeatureSet features = 50; + + // The verification state of the extension range. + enum VerificationState { + // All the extensions of the range must be declared. + DECLARATION = 0; + UNVERIFIED = 1; + } + + // The verification state of the range. + // TODO: flip the default to DECLARATION once all empty ranges + // are marked as UNVERIFIED. + optional VerificationState verification = 3 + [default = UNVERIFIED, retention = RETENTION_SOURCE]; // Clients can define custom options in extensions of this message. See above. extensions 1000 to max; @@ -153,9 +261,10 @@ message FieldDescriptorProto { TYPE_BOOL = 8; TYPE_STRING = 9; // Tag-delimited aggregate. - // Group type is deprecated and not supported in proto3. However, Proto3 + // Group type is deprecated and not supported after google.protobuf. However, Proto3 // implementations should still be able to parse the group wire format and - // treat group fields as unknown fields. + // treat group fields as unknown fields. In Editions, the group wire format + // can be enabled via the `message_encoding` feature. TYPE_GROUP = 10; TYPE_MESSAGE = 11; // Length-delimited aggregate. @@ -172,8 +281,11 @@ message FieldDescriptorProto { enum Label { // 0 is reserved for errors LABEL_OPTIONAL = 1; - LABEL_REQUIRED = 2; LABEL_REPEATED = 3; + // The required label is only allowed in google.protobuf. In proto3 and Editions + // it's explicitly prohibited. In Editions, the `field_presence` feature + // can be used to get this behavior. + LABEL_REQUIRED = 2; } optional string name = 1; @@ -199,7 +311,6 @@ message FieldDescriptorProto { // For booleans, "true" or "false". // For strings, contains the default text contents (not escaped in any way). // For bytes, contains the C escaped value. All bytes >= 128 are escaped. - // TODO(kenton): Base-64 encode? optional string default_value = 7; // If set, gives the index of a oneof in the containing type's oneof_decl @@ -217,12 +328,12 @@ message FieldDescriptorProto { // If true, this is a proto3 "optional". When a proto3 field is optional, it // tracks presence regardless of field type. // - // When proto3_optional is true, this field must be belong to a oneof to - // signal to old proto3 clients that presence is tracked for this field. This - // oneof is known as a "synthetic" oneof, and this field must be its sole - // member (each proto3 optional field gets its own synthetic oneof). Synthetic - // oneofs exist in the descriptor only, and do not generate any API. Synthetic - // oneofs must be ordered after all "real" oneofs. + // When proto3_optional is true, this field must belong to a oneof to signal + // to old proto3 clients that presence is tracked for this field. This oneof + // is known as a "synthetic" oneof, and this field must be its sole member + // (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs + // exist in the descriptor only, and do not generate any API. Synthetic oneofs + // must be ordered after all "real" oneofs. // // For message fields, proto3_optional doesn't create any semantic change, // since non-repeated message fields always track presence. However it still @@ -271,6 +382,9 @@ message EnumDescriptorProto { // Reserved enum value names, which may not be reused. A given name may only // be reserved once. repeated string reserved_name = 5; + + // Support for `export` and `local` keywords on enums. + optional SymbolVisibility visibility = 6; } // Describes a value within an enum. @@ -287,6 +401,9 @@ message ServiceDescriptorProto { repeated MethodDescriptorProto method = 2; optional ServiceOptions options = 3; + + reserved 4; + reserved "stream"; } // Describes a method of a service. @@ -306,7 +423,6 @@ message MethodDescriptorProto { optional bool server_streaming = 6 [default = false]; } - // =================================================================== // Options @@ -347,7 +463,6 @@ message FileOptions { // domain names. optional string java_package = 1; - // Controls the name of the wrapper Java class generated for the .proto file. // That class will always contain the .proto file's getDescriptor() method as // well as any top-level extensions defined in the .proto file. @@ -361,20 +476,33 @@ message FileOptions { // named by java_outer_classname. However, the wrapper class will still be // generated to contain the file's getDescriptor() method as well as any // top-level extensions defined in the file. - optional bool java_multiple_files = 10 [default = false]; + optional bool java_multiple_files = 10 [ + default = false, + feature_support = { + edition_introduced: EDITION_PROTO2 + edition_removed: EDITION_2024 + removal_error: "This behavior is enabled by default in editions 2024 and above. " + "To disable it, you can set `features.(pb.java).nest_in_file_class = YES` " + "on individual messages, enums, or services." + + } + ]; // This option does nothing. optional bool java_generate_equals_and_hash = 20 [deprecated=true]; - // If set true, then the Java2 code generator will generate code that - // throws an exception whenever an attempt is made to assign a non-UTF-8 - // byte sequence to a string field. - // Message reflection will do the same. - // However, an extension field still accepts non-UTF-8 byte sequences. - // This option has no effect on when used with the lite runtime. + // A proto2 file can set this to true to opt in to UTF-8 checking for Java, + // which will throw an exception if invalid UTF-8 is parsed from the wire or + // assigned to a string field. + // + // TODO: clarify exactly what kinds of field types this option + // applies to, and update these docs accordingly. + // + // Proto3 files already perform these checks. Setting the option explicitly to + // false has no effect: it cannot be used to opt proto3 files out of UTF-8 + // checks. optional bool java_string_check_utf8 = 27 [default = false]; - // Generated classes can be optimized for speed or code size. enum OptimizeMode { SPEED = 1; // Generate complete code for parsing, serialization, @@ -391,9 +519,6 @@ message FileOptions { // - Otherwise, the basename of the .proto file, without extension. optional string go_package = 11; - - - // Should generic services be generated in each language? "Generic" services // are not specific to any particular RPC system. They are generated by the // main code generators in each language (without additional plugins). @@ -407,7 +532,8 @@ message FileOptions { optional bool cc_generic_services = 16 [default = false]; optional bool java_generic_services = 17 [default = false]; optional bool py_generic_services = 18 [default = false]; - optional bool php_generic_services = 42 [default = false]; + reserved 42; // removed php_generic_services + reserved "php_generic_services"; // Is this file deprecated? // Depending on the target platform, this can emit Deprecated annotations @@ -419,7 +545,6 @@ message FileOptions { // only to generated classes for C++. optional bool cc_enable_arenas = 31 [default = true]; - // Sets the objective c class prefix which is prepended to all objective c // generated classes from this .proto. There is no default. optional string objc_class_prefix = 36; @@ -452,6 +577,11 @@ message FileOptions { // determining the ruby package. optional string ruby_package = 45; + // Any features defined in the specific edition. + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional FeatureSet features = 50; // The parser stores options it doesn't recognize here. // See the documentation for the "Options" section above. @@ -524,6 +654,23 @@ message MessageOptions { reserved 8; // javalite_serializable reserved 9; // javanano_as_lite + // Enable the legacy handling of JSON field name conflicts. This lowercases + // and strips underscored from the fields before comparison in proto3 only. + // The new behavior takes `json_name` into account and applies to proto2 as + // well. + // + // This should only be used as a temporary measure against broken builds due + // to the change in behavior for JSON field name conflicts. + // + // TODO This is legacy behavior we plan to remove once downstream + // teams have had time to migrate. + optional bool deprecated_legacy_json_field_conflicts = 11 [deprecated = true]; + + // Any features defined in the specific edition. + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional FeatureSet features = 12; // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; @@ -533,15 +680,24 @@ message MessageOptions { } message FieldOptions { + // NOTE: ctype is deprecated. Use `features.(pb.cpp).string_type` instead. // The ctype option instructs the C++ code generator to use a different // representation of the field than it normally would. See the specific - // options below. This option is not yet implemented in the open source - // release -- sorry, we'll try to include it in a future version! - optional CType ctype = 1 [default = STRING]; + // options below. This option is only implemented to support use of + // [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of + // type "bytes" in the open source release. + // TODO: make ctype actually deprecated. + optional CType ctype = 1 [/*deprecated = true,*/ default = STRING]; enum CType { // Default mode. STRING = 0; + // The option [ctype=CORD] may be applied to a non-repeated field of type + // "bytes". It indicates that in C++, the data should be stored in a Cord + // instead of a string. For very large strings, this may reduce memory + // fragmentation. It may also allow better performance when parsing from a + // Cord, or when parsing with aliasing enabled, as the parsed Cord may then + // alias the original buffer. CORD = 1; STRING_PIECE = 2; @@ -550,7 +706,9 @@ message FieldOptions { // a more efficient representation on the wire. Rather than repeatedly // writing the tag and type for each element, the entire array is encoded as // a single length-delimited blob. In proto3, only explicit setting it to - // false will avoid using packed encoding. + // false will avoid using packed encoding. This option is prohibited in + // Editions, but the `repeated_field_encoding` feature can be used to control + // the behavior. optional bool packed = 2; // The jstype option determines the JavaScript type used for values of the @@ -593,28 +751,96 @@ message FieldOptions { // call from multiple threads concurrently, while non-const methods continue // to require exclusive access. // - // - // Note that implementations may choose not to check required fields within - // a lazy sub-message. That is, calling IsInitialized() on the outer message - // may return true even if the inner message has missing required fields. - // This is necessary because otherwise the inner message would have to be - // parsed in order to perform the check, defeating the purpose of lazy - // parsing. An implementation which chooses not to check required fields - // must be consistent about it. That is, for any particular sub-message, the - // implementation must either *always* check its required fields, or *never* - // check its required fields, regardless of whether or not the message has - // been parsed. + // Note that lazy message fields are still eagerly verified to check + // ill-formed wireformat or missing required fields. Calling IsInitialized() + // on the outer message would fail if the inner message has missing required + // fields. Failed verification would result in parsing failure (except when + // uninitialized messages are acceptable). optional bool lazy = 5 [default = false]; + // unverified_lazy does no correctness checks on the byte stream. This should + // only be used where lazy with verification is prohibitive for performance + // reasons. + optional bool unverified_lazy = 15 [default = false]; + // Is this field deprecated? // Depending on the target platform, this can emit Deprecated annotations // for accessors, or it will be completely ignored; in the very least, this // is a formalization for deprecating fields. optional bool deprecated = 3 [default = false]; + // DEPRECATED. DO NOT USE! // For Google-internal migration only. Do not use. - optional bool weak = 10 [default = false]; + optional bool weak = 10 [default = false, deprecated = true]; + // Indicate that the field value should not be printed out when using debug + // formats, e.g. when the field contains sensitive credentials. + optional bool debug_redact = 16 [default = false]; + + // If set to RETENTION_SOURCE, the option will be omitted from the binary. + enum OptionRetention { + RETENTION_UNKNOWN = 0; + RETENTION_RUNTIME = 1; + RETENTION_SOURCE = 2; + } + + optional OptionRetention retention = 17; + + // This indicates the types of entities that the field may apply to when used + // as an option. If it is unset, then the field may be freely used as an + // option on any kind of entity. + enum OptionTargetType { + TARGET_TYPE_UNKNOWN = 0; + TARGET_TYPE_FILE = 1; + TARGET_TYPE_EXTENSION_RANGE = 2; + TARGET_TYPE_MESSAGE = 3; + TARGET_TYPE_FIELD = 4; + TARGET_TYPE_ONEOF = 5; + TARGET_TYPE_ENUM = 6; + TARGET_TYPE_ENUM_ENTRY = 7; + TARGET_TYPE_SERVICE = 8; + TARGET_TYPE_METHOD = 9; + } + + repeated OptionTargetType targets = 19; + + message EditionDefault { + optional Edition edition = 3; + optional string value = 2; // Textproto value. + } + repeated EditionDefault edition_defaults = 20; + + // Any features defined in the specific edition. + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional FeatureSet features = 21; + + // Information about the support window of a feature. + message FeatureSupport { + // The edition that this feature was first available in. In editions + // earlier than this one, the default assigned to EDITION_LEGACY will be + // used, and proto files will not be able to override it. + optional Edition edition_introduced = 1; + + // The edition this feature becomes deprecated in. Using this after this + // edition may trigger warnings. + optional Edition edition_deprecated = 2; + + // The deprecation warning text if this feature is used after the edition it + // was marked deprecated in. + optional string deprecation_warning = 3; + + // The edition this feature is no longer available in. In editions after + // this one, the last default assigned will be used, and proto files will + // not be able to override it. + optional Edition edition_removed = 4; + + // The removal error text if this feature is used after the edition it was + // removed in. + optional string removal_error = 5; + } + optional FeatureSupport feature_support = 22; // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; @@ -622,10 +848,17 @@ message FieldOptions { // Clients can define custom options in extensions of this message. See above. extensions 1000 to max; - reserved 4; // removed jtype + reserved 4; // removed jtype + reserved 18; // reserve target, target_obsolete_do_not_use } message OneofOptions { + // Any features defined in the specific edition. + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional FeatureSet features = 1; + // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; @@ -647,6 +880,20 @@ message EnumOptions { reserved 5; // javanano_as_lite + // Enable the legacy handling of JSON field name conflicts. This lowercases + // and strips underscored from the fields before comparison in proto3 only. + // The new behavior takes `json_name` into account and applies to proto2 as + // well. + // TODO Remove this legacy behavior once downstream teams have + // had time to migrate. + optional bool deprecated_legacy_json_field_conflicts = 6 [deprecated = true]; + + // Any features defined in the specific edition. + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional FeatureSet features = 7; + // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; @@ -661,6 +908,20 @@ message EnumValueOptions { // this is a formalization for deprecating enum values. optional bool deprecated = 1 [default = false]; + // Any features defined in the specific edition. + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional FeatureSet features = 2; + + // Indicate that fields annotated with this enum value should not be printed + // out when using debug formats, e.g. when the field contains sensitive + // credentials. + optional bool debug_redact = 3 [default = false]; + + // Information about the support window of a feature value. + optional FieldOptions.FeatureSupport feature_support = 4; + // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; @@ -670,6 +931,12 @@ message EnumValueOptions { message ServiceOptions { + // Any features defined in the specific edition. + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional FeatureSet features = 34; + // Note: Field numbers 1 through 32 are reserved for Google's internal RPC // framework. We apologize for hoarding these numbers to ourselves, but // we were already using them long before we decided to release Protocol @@ -712,6 +979,12 @@ message MethodOptions { optional IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN]; + // Any features defined in the specific edition. + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional FeatureSet features = 35; + // The parser stores options it doesn't recognize here. See above. repeated UninterpretedOption uninterpreted_option = 999; @@ -719,7 +992,6 @@ message MethodOptions { extensions 1000 to max; } - // A message representing a option the parser does not recognize. This only // appears in options protos created by the compiler::Parser class. // DescriptorPool resolves these when building Descriptor objects. Therefore, @@ -730,8 +1002,8 @@ message UninterpretedOption { // The name of the uninterpreted option. Each string represents a segment in // a dot-separated name. is_extension is true iff a segment represents an // extension (denoted with parentheses in options specs in .proto files). - // E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents - // "foo.(bar.baz).qux". + // E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents + // "foo.(bar.baz).moo". message NamePart { required string name_part = 1; required bool is_extension = 2; @@ -748,6 +1020,241 @@ message UninterpretedOption { optional string aggregate_value = 8; } +// =================================================================== +// Features + +// TODO Enums in C++ gencode (and potentially other languages) are +// not well scoped. This means that each of the feature enums below can clash +// with each other. The short names we've chosen maximize call-site +// readability, but leave us very open to this scenario. A future feature will +// be designed and implemented to handle this, hopefully before we ever hit a +// conflict here. +message FeatureSet { + enum FieldPresence { + FIELD_PRESENCE_UNKNOWN = 0; + EXPLICIT = 1; + IMPLICIT = 2; + LEGACY_REQUIRED = 3; + } + optional FieldPresence field_presence = 1 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "EXPLICIT" }, + edition_defaults = { edition: EDITION_PROTO3, value: "IMPLICIT" }, + edition_defaults = { edition: EDITION_2023, value: "EXPLICIT" } + ]; + + enum EnumType { + ENUM_TYPE_UNKNOWN = 0; + OPEN = 1; + CLOSED = 2; + } + optional EnumType enum_type = 2 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "CLOSED" }, + edition_defaults = { edition: EDITION_PROTO3, value: "OPEN" } + ]; + + enum RepeatedFieldEncoding { + REPEATED_FIELD_ENCODING_UNKNOWN = 0; + PACKED = 1; + EXPANDED = 2; + } + optional RepeatedFieldEncoding repeated_field_encoding = 3 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "EXPANDED" }, + edition_defaults = { edition: EDITION_PROTO3, value: "PACKED" } + ]; + + enum Utf8Validation { + UTF8_VALIDATION_UNKNOWN = 0; + VERIFY = 2; + NONE = 3; + reserved 1; + } + optional Utf8Validation utf8_validation = 4 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "NONE" }, + edition_defaults = { edition: EDITION_PROTO3, value: "VERIFY" } + ]; + + enum MessageEncoding { + MESSAGE_ENCODING_UNKNOWN = 0; + LENGTH_PREFIXED = 1; + DELIMITED = 2; + } + optional MessageEncoding message_encoding = 5 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "LENGTH_PREFIXED" } + ]; + + enum JsonFormat { + JSON_FORMAT_UNKNOWN = 0; + ALLOW = 1; + LEGACY_BEST_EFFORT = 2; + } + optional JsonFormat json_format = 6 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_MESSAGE, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "LEGACY_BEST_EFFORT" }, + edition_defaults = { edition: EDITION_PROTO3, value: "ALLOW" } + ]; + + enum EnforceNamingStyle { + ENFORCE_NAMING_STYLE_UNKNOWN = 0; + STYLE2024 = 1; + STYLE_LEGACY = 2; + } + optional EnforceNamingStyle enforce_naming_style = 7 [ + retention = RETENTION_SOURCE, + targets = TARGET_TYPE_FILE, + targets = TARGET_TYPE_EXTENSION_RANGE, + targets = TARGET_TYPE_MESSAGE, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_ONEOF, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_ENUM_ENTRY, + targets = TARGET_TYPE_SERVICE, + targets = TARGET_TYPE_METHOD, + feature_support = { + edition_introduced: EDITION_2024, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "STYLE_LEGACY" }, + edition_defaults = { edition: EDITION_2024, value: "STYLE2024" } + ]; + + message VisibilityFeature { + enum DefaultSymbolVisibility { + DEFAULT_SYMBOL_VISIBILITY_UNKNOWN = 0; + + // Default pre-EDITION_2024, all UNSET visibility are export. + EXPORT_ALL = 1; + + // All top-level symbols default to export, nested default to local. + EXPORT_TOP_LEVEL = 2; + + // All symbols default to local. + LOCAL_ALL = 3; + + // All symbols local by default. Nested types cannot be exported. + // With special case caveat for message { enum {} reserved 1 to max; } + // This is the recommended setting for new protos. + STRICT = 4; + } + reserved 1 to max; + } + optional VisibilityFeature.DefaultSymbolVisibility default_symbol_visibility = + 8 [ + retention = RETENTION_SOURCE, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2024, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "EXPORT_ALL" }, + edition_defaults = { edition: EDITION_2024, value: "EXPORT_TOP_LEVEL" } + ]; + + reserved 999; + + extensions 1000 to 9994 [ + declaration = { + number: 1000, + full_name: ".pb.cpp", + type: ".pb.CppFeatures" + }, + declaration = { + number: 1001, + full_name: ".pb.java", + type: ".pb.JavaFeatures" + }, + declaration = { number: 1002, full_name: ".pb.go", type: ".pb.GoFeatures" }, + declaration = { + number: 1003, + full_name: ".pb.python", + type: ".pb.PythonFeatures" + }, + declaration = { + number: 1100, + full_name: ".imp.impress_feature_set", + type: ".imp.ImpressFeatureSet" + }, + declaration = { + number: 9989, + full_name: ".pb.java_mutable", + type: ".pb.JavaMutableFeatures" + }, + declaration = { + number: 9990, + full_name: ".pb.proto1", + type: ".pb.Proto1Features" + } + ]; + + extensions 9995 to 9999; // For internal testing + extensions 10000; // for https://github.com/bufbuild/protobuf-es +} + +// A compiled specification for the defaults of a set of features. These +// messages are generated from FeatureSet extensions and can be used to seed +// feature resolution. The resolution with this object becomes a simple search +// for the closest matching edition, followed by proto merges. +message FeatureSetDefaults { + // A map from every known edition with a unique set of defaults to its + // defaults. Not all editions may be contained here. For a given edition, + // the defaults at the closest matching edition ordered at or before it should + // be used. This field must be in strict ascending order by edition. + message FeatureSetEditionDefault { + optional Edition edition = 3; + + // Defaults of features that can be overridden in this edition. + optional FeatureSet overridable_features = 4; + + // Defaults of features that can't be overridden in this edition. + optional FeatureSet fixed_features = 5; + + reserved 1, 2; + reserved "features"; + } + repeated FeatureSetEditionDefault defaults = 1; + + // The minimum supported edition (inclusive) when this was constructed. + // Editions before this will not have defaults. + optional Edition minimum_edition = 4; + + // The maximum known edition (inclusive) when this was constructed. Editions + // after this will not have reliable defaults. + optional Edition maximum_edition = 5; +} + // =================================================================== // Optional source code info @@ -803,8 +1310,8 @@ message SourceCodeInfo { // location. // // Each element is a field number or an index. They form a path from - // the root FileDescriptorProto to the place where the definition. For - // example, this path: + // the root FileDescriptorProto to the place where the definition appears. + // For example, this path: // [ 4, 3, 2, 7, 1 ] // refers to: // file.message_type(3) // 4, 3 @@ -858,13 +1365,13 @@ message SourceCodeInfo { // // Comment attached to baz. // // Another line attached to baz. // - // // Comment attached to qux. + // // Comment attached to moo. // // - // // Another line attached to qux. - // optional double qux = 4; + // // Another line attached to moo. + // optional double moo = 4; // // // Detached comment for corge. This is not leading or trailing comments - // // to qux or corge because there are blank lines separating it from + // // to moo or corge because there are blank lines separating it from // // both. // // // Detached comment for corge paragraph 2. @@ -882,6 +1389,13 @@ message SourceCodeInfo { optional string trailing_comments = 4; repeated string leading_detached_comments = 6; } + + // Extensions for tooling. + extensions 536000000 [declaration = { + number: 536000000 + type: ".buf.descriptor.v1.SourceCodeInfoExtension" + full_name: ".buf.descriptor.v1.buf_source_code_info_extension" + }]; } // Describes the relationship between generated code and its original source @@ -904,8 +1418,31 @@ message GeneratedCodeInfo { optional int32 begin = 3; // Identifies the ending offset in bytes in the generated code that - // relates to the identified offset. The end offset should be one past + // relates to the identified object. The end offset should be one past // the last relevant byte (so the length of the text = end - begin). optional int32 end = 4; + + // Represents the identified object's effect on the element in the original + // .proto file. + enum Semantic { + // There is no effect or the effect is indescribable. + NONE = 0; + // The element is set or otherwise mutated. + SET = 1; + // An alias to the element is returned. + ALIAS = 2; + } + optional Semantic semantic = 5; } } + +// Describes the 'visibility' of a symbol with respect to the proto import +// system. Symbols can only be imported when the visibility rules do not prevent +// it (ex: local symbols cannot be imported). Visibility modifiers can only set +// on `message` and `enum` as they are the only types available to be referenced +// from other files. +enum SymbolVisibility { + VISIBILITY_UNSET = 0; + VISIBILITY_LOCAL = 1; + VISIBILITY_EXPORT = 2; +} diff --git a/Protos/google/protobuf/duration.proto b/Protos/Sources/SwiftProtobuf/google/protobuf/duration.proto similarity index 99% rename from Protos/google/protobuf/duration.proto rename to Protos/Sources/SwiftProtobuf/google/protobuf/duration.proto index 81c3e369f..41f40c222 100644 --- a/Protos/google/protobuf/duration.proto +++ b/Protos/Sources/SwiftProtobuf/google/protobuf/duration.proto @@ -32,13 +32,13 @@ syntax = "proto3"; package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true; option go_package = "google.golang.org/protobuf/types/known/durationpb"; option java_package = "com.google.protobuf"; option java_outer_classname = "DurationProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; // A Duration represents a signed, fixed-length span of time represented // as a count of seconds and fractions of seconds at nanosecond @@ -99,7 +99,6 @@ option objc_class_prefix = "GPB"; // be expressed in JSON format as "3.000000001s", and 3 seconds and 1 // microsecond should be expressed in JSON format as "3.000001s". // -// message Duration { // Signed seconds of the span of time. Must be from -315,576,000,000 // to +315,576,000,000 inclusive. Note: these bounds are computed from: diff --git a/Protos/google/protobuf/empty.proto b/Protos/Sources/SwiftProtobuf/google/protobuf/empty.proto similarity index 97% rename from Protos/google/protobuf/empty.proto rename to Protos/Sources/SwiftProtobuf/google/protobuf/empty.proto index 5f992de94..b87c89dcf 100644 --- a/Protos/google/protobuf/empty.proto +++ b/Protos/Sources/SwiftProtobuf/google/protobuf/empty.proto @@ -32,12 +32,12 @@ syntax = "proto3"; package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option go_package = "google.golang.org/protobuf/types/known/emptypb"; option java_package = "com.google.protobuf"; option java_outer_classname = "EmptyProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true; // A generic empty message that you can re-use to avoid defining duplicated @@ -48,5 +48,4 @@ option cc_enable_arenas = true; // rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); // } // -// The JSON representation for `Empty` is empty JSON object `{}`. message Empty {} diff --git a/Protos/google/protobuf/field_mask.proto b/Protos/Sources/SwiftProtobuf/google/protobuf/field_mask.proto similarity index 100% rename from Protos/google/protobuf/field_mask.proto rename to Protos/Sources/SwiftProtobuf/google/protobuf/field_mask.proto index 6b5104f18..b28334b94 100644 --- a/Protos/google/protobuf/field_mask.proto +++ b/Protos/Sources/SwiftProtobuf/google/protobuf/field_mask.proto @@ -32,11 +32,11 @@ syntax = "proto3"; package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option java_package = "com.google.protobuf"; option java_outer_classname = "FieldMaskProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option go_package = "google.golang.org/protobuf/types/known/fieldmaskpb"; option cc_enable_arenas = true; diff --git a/Protos/google/protobuf/source_context.proto b/Protos/Sources/SwiftProtobuf/google/protobuf/source_context.proto similarity index 100% rename from Protos/google/protobuf/source_context.proto rename to Protos/Sources/SwiftProtobuf/google/protobuf/source_context.proto index 06bfc43a7..135f50fea 100644 --- a/Protos/google/protobuf/source_context.proto +++ b/Protos/Sources/SwiftProtobuf/google/protobuf/source_context.proto @@ -32,11 +32,11 @@ syntax = "proto3"; package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option java_package = "com.google.protobuf"; option java_outer_classname = "SourceContextProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option go_package = "google.golang.org/protobuf/types/known/sourcecontextpb"; // `SourceContext` represents information about the source of a diff --git a/Protos/google/protobuf/struct.proto b/Protos/Sources/SwiftProtobuf/google/protobuf/struct.proto similarity index 98% rename from Protos/google/protobuf/struct.proto rename to Protos/Sources/SwiftProtobuf/google/protobuf/struct.proto index 0ac843ca0..1bf0c1ad9 100644 --- a/Protos/google/protobuf/struct.proto +++ b/Protos/Sources/SwiftProtobuf/google/protobuf/struct.proto @@ -32,13 +32,13 @@ syntax = "proto3"; package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true; option go_package = "google.golang.org/protobuf/types/known/structpb"; option java_package = "com.google.protobuf"; option java_outer_classname = "StructProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; // `Struct` represents a structured data value, consisting of fields // which map to dynamically typed values. In some languages, `Struct` @@ -80,7 +80,7 @@ message Value { // `NullValue` is a singleton enumeration to represent the null value for the // `Value` type union. // -// The JSON representation for `NullValue` is JSON `null`. +// The JSON representation for `NullValue` is JSON `null`. enum NullValue { // Null value. NULL_VALUE = 0; diff --git a/Protos/google/protobuf/timestamp.proto b/Protos/Sources/SwiftProtobuf/google/protobuf/timestamp.proto similarity index 89% rename from Protos/google/protobuf/timestamp.proto rename to Protos/Sources/SwiftProtobuf/google/protobuf/timestamp.proto index 3b2df6d91..6bc1efc6d 100644 --- a/Protos/google/protobuf/timestamp.proto +++ b/Protos/Sources/SwiftProtobuf/google/protobuf/timestamp.proto @@ -32,13 +32,13 @@ syntax = "proto3"; package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true; option go_package = "google.golang.org/protobuf/types/known/timestamppb"; option java_package = "com.google.protobuf"; option java_outer_classname = "TimestampProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; // A Timestamp represents a point in time independent of any time zone or local // calendar, encoded as a count of seconds and fractions of seconds at @@ -90,7 +90,6 @@ option objc_class_prefix = "GPB"; // Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) // .setNanos((int) ((millis % 1000) * 1000000)).build(); // -// // Example 5: Compute Timestamp from Java `Instant.now()`. // // Instant now = Instant.now(); @@ -99,7 +98,6 @@ option objc_class_prefix = "GPB"; // Timestamp.newBuilder().setSeconds(now.getEpochSecond()) // .setNanos(now.getNano()).build(); // -// // Example 6: Compute Timestamp from current time in Python. // // timestamp = Timestamp() @@ -114,8 +112,8 @@ option objc_class_prefix = "GPB"; // {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional // seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), // are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone -// is required. A proto3 JSON serializer should always use UTC (as indicated by -// "Z") when printing the Timestamp type and a proto3 JSON parser should be +// is required. A ProtoJSON serializer should always use UTC (as indicated by +// "Z") when printing the Timestamp type and a ProtoJSON parser should be // able to accept both UTC and other timezones (as indicated by an offset). // // For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past @@ -129,19 +127,19 @@ option objc_class_prefix = "GPB"; // [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with // the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use // the Joda Time's [`ISODateTimeFormat.dateTime()`]( -// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D +// http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime() // ) to obtain a formatter capable of generating timestamps in this format. // -// message Timestamp { - // Represents seconds of UTC time since Unix epoch - // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to - // 9999-12-31T23:59:59Z inclusive. + // Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must + // be between -62135596800 and 253402300799 inclusive (which corresponds to + // 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z). int64 seconds = 1; - // Non-negative fractions of a second at nanosecond resolution. Negative - // second values with fractions must still have non-negative nanos values - // that count forward in time. Must be from 0 to 999,999,999 + // Non-negative fractions of a second at nanosecond resolution. This field is + // the nanosecond portion of the duration, not an alternative to seconds. + // Negative second values with fractions must still have non-negative nanos + // values that count forward in time. Must be between 0 and 999,999,999 // inclusive. int32 nanos = 2; } diff --git a/Protos/google/protobuf/type.proto b/Protos/Sources/SwiftProtobuf/google/protobuf/type.proto similarity index 78% rename from Protos/google/protobuf/type.proto rename to Protos/Sources/SwiftProtobuf/google/protobuf/type.proto index d3f6a68b8..2c7615ed6 100644 --- a/Protos/google/protobuf/type.proto +++ b/Protos/Sources/SwiftProtobuf/google/protobuf/type.proto @@ -35,15 +35,20 @@ package google.protobuf; import "google/protobuf/any.proto"; import "google/protobuf/source_context.proto"; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true; option java_package = "com.google.protobuf"; option java_outer_classname = "TypeProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option go_package = "google.golang.org/protobuf/types/known/typepb"; // A protocol buffer message type. +// +// New usages of this message as an alternative to DescriptorProto are strongly +// discouraged. This message does not reliability preserve all information +// necessary to model the schema and preserve semantics. Instead make use of +// FileDescriptorSet which preserves the necessary information. message Type { // The fully qualified message name. string name = 1; @@ -57,9 +62,16 @@ message Type { SourceContext source_context = 5; // The source syntax. Syntax syntax = 6; + // The source edition string, only valid when syntax is SYNTAX_EDITIONS. + string edition = 7; } // A single field of a message type. +// +// New usages of this message as an alternative to FieldDescriptorProto are +// strongly discouraged. This message does not reliability preserve all +// information necessary to model the schema and preserve semantics. Instead +// make use of FileDescriptorSet which preserves the necessary information. message Field { // Basic field types. enum Kind { @@ -140,6 +152,11 @@ message Field { } // Enum type definition. +// +// New usages of this message as an alternative to EnumDescriptorProto are +// strongly discouraged. This message does not reliability preserve all +// information necessary to model the schema and preserve semantics. Instead +// make use of FileDescriptorSet which preserves the necessary information. message Enum { // Enum type name. string name = 1; @@ -151,9 +168,16 @@ message Enum { SourceContext source_context = 4; // The source syntax. Syntax syntax = 5; + // The source edition string, only valid when syntax is SYNTAX_EDITIONS. + string edition = 6; } // Enum value definition. +// +// New usages of this message as an alternative to EnumValueDescriptorProto are +// strongly discouraged. This message does not reliability preserve all +// information necessary to model the schema and preserve semantics. Instead +// make use of FileDescriptorSet which preserves the necessary information. message EnumValue { // Enum value name. string name = 1; @@ -165,6 +189,10 @@ message EnumValue { // A protocol buffer option, which can be attached to a message, field, // enumeration, etc. +// +// New usages of this message as an alternative to FileOptions, MessageOptions, +// FieldOptions, EnumOptions, EnumValueOptions, ServiceOptions, or MethodOptions +// are strongly discouraged. message Option { // The option's name. For protobuf built-in options (options defined in // descriptor.proto), this is the short name. For example, `"map_entry"`. @@ -184,4 +212,6 @@ enum Syntax { SYNTAX_PROTO2 = 0; // Syntax `proto3`. SYNTAX_PROTO3 = 1; + // Syntax `editions`. + SYNTAX_EDITIONS = 2; } diff --git a/Protos/google/protobuf/wrappers.proto b/Protos/Sources/SwiftProtobuf/google/protobuf/wrappers.proto similarity index 70% rename from Protos/google/protobuf/wrappers.proto rename to Protos/Sources/SwiftProtobuf/google/protobuf/wrappers.proto index d49dd53c8..e583e7c40 100644 --- a/Protos/google/protobuf/wrappers.proto +++ b/Protos/Sources/SwiftProtobuf/google/protobuf/wrappers.proto @@ -27,11 +27,18 @@ // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Wrappers for primitive (non-message) types. These types are useful -// for embedding primitives in the `google.protobuf.Any` type and for places -// where we need to distinguish between the absence of a primitive -// typed field and its default value. +// +// Wrappers for primitive (non-message) types. These types were needed +// for legacy reasons and are not recommended for use in new APIs. +// +// Historically these wrappers were useful to have presence on proto3 primitive +// fields, but proto3 syntax has been updated to support the `optional` keyword. +// Using that keyword is now the strongly preferred way to add presence to +// proto3 primitive fields. +// +// A secondary usecase was to embed primitives in the `google.protobuf.Any` +// type: it is now recommended that you embed your value in your own wrapper +// message which can be specifically documented. // // These wrappers have no meaningful use within repeated fields as they lack // the ability to detect presence on individual elements. @@ -42,17 +49,20 @@ syntax = "proto3"; package google.protobuf; -option csharp_namespace = "Google.Protobuf.WellKnownTypes"; option cc_enable_arenas = true; option go_package = "google.golang.org/protobuf/types/known/wrapperspb"; option java_package = "com.google.protobuf"; option java_outer_classname = "WrappersProto"; option java_multiple_files = true; option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; // Wrapper message for `double`. // // The JSON representation for `DoubleValue` is JSON number. +// +// Not recommended for use in new APIs, but still useful for legacy APIs and +// has no plan to be removed. message DoubleValue { // The double value. double value = 1; @@ -61,6 +71,9 @@ message DoubleValue { // Wrapper message for `float`. // // The JSON representation for `FloatValue` is JSON number. +// +// Not recommended for use in new APIs, but still useful for legacy APIs and +// has no plan to be removed. message FloatValue { // The float value. float value = 1; @@ -69,6 +82,9 @@ message FloatValue { // Wrapper message for `int64`. // // The JSON representation for `Int64Value` is JSON string. +// +// Not recommended for use in new APIs, but still useful for legacy APIs and +// has no plan to be removed. message Int64Value { // The int64 value. int64 value = 1; @@ -77,6 +93,9 @@ message Int64Value { // Wrapper message for `uint64`. // // The JSON representation for `UInt64Value` is JSON string. +// +// Not recommended for use in new APIs, but still useful for legacy APIs and +// has no plan to be removed. message UInt64Value { // The uint64 value. uint64 value = 1; @@ -85,6 +104,9 @@ message UInt64Value { // Wrapper message for `int32`. // // The JSON representation for `Int32Value` is JSON number. +// +// Not recommended for use in new APIs, but still useful for legacy APIs and +// has no plan to be removed. message Int32Value { // The int32 value. int32 value = 1; @@ -93,6 +115,9 @@ message Int32Value { // Wrapper message for `uint32`. // // The JSON representation for `UInt32Value` is JSON number. +// +// Not recommended for use in new APIs, but still useful for legacy APIs and +// has no plan to be removed. message UInt32Value { // The uint32 value. uint32 value = 1; @@ -101,6 +126,9 @@ message UInt32Value { // Wrapper message for `bool`. // // The JSON representation for `BoolValue` is JSON `true` and `false`. +// +// Not recommended for use in new APIs, but still useful for legacy APIs and +// has no plan to be removed. message BoolValue { // The bool value. bool value = 1; @@ -109,6 +137,9 @@ message BoolValue { // Wrapper message for `string`. // // The JSON representation for `StringValue` is JSON string. +// +// Not recommended for use in new APIs, but still useful for legacy APIs and +// has no plan to be removed. message StringValue { // The string value. string value = 1; @@ -117,6 +148,9 @@ message StringValue { // Wrapper message for `bytes`. // // The JSON representation for `BytesValue` is JSON string. +// +// Not recommended for use in new APIs, but still useful for legacy APIs and +// has no plan to be removed. message BytesValue { // The bytes value. bytes value = 1; diff --git a/Protos/google/protobuf/compiler/plugin.proto b/Protos/Sources/SwiftProtobufPluginLibrary/google/protobuf/compiler/plugin.proto similarity index 81% rename from Protos/google/protobuf/compiler/plugin.proto rename to Protos/Sources/SwiftProtobufPluginLibrary/google/protobuf/compiler/plugin.proto index 9242aacc5..10d285f8a 100644 --- a/Protos/google/protobuf/compiler/plugin.proto +++ b/Protos/Sources/SwiftProtobufPluginLibrary/google/protobuf/compiler/plugin.proto @@ -1,38 +1,12 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd // Author: kenton@google.com (Kenton Varda) // -// WARNING: The plugin interface is currently EXPERIMENTAL and is subject to -// change. -// // protoc (aka the Protocol Compiler) can be extended via plugins. A plugin is // just a program that reads a CodeGeneratorRequest from stdin and writes a // CodeGeneratorResponse to stdout. @@ -50,10 +24,11 @@ package google.protobuf.compiler; option java_package = "com.google.protobuf.compiler"; option java_outer_classname = "PluginProtos"; -option go_package = "google.golang.org/protobuf/types/pluginpb"; - import "google/protobuf/descriptor.proto"; +option csharp_namespace = "Google.Protobuf.Compiler"; +option go_package = "google.golang.org/protobuf/types/pluginpb"; + // The version number of protocol compiler. message Version { optional int32 major = 1; @@ -78,6 +53,11 @@ message CodeGeneratorRequest { // they import. The files will appear in topological order, so each file // appears before any file that imports it. // + // Note: the files listed in files_to_generate will include runtime-retention + // options only, but all other files will include source-retention options. + // The source_file_descriptors field below is available in case you need + // source-retention options for files_to_generate. + // // protoc guarantees that all proto_files will be written after // the fields above, even though this is not technically guaranteed by the // protobuf wire format. This theoretically could allow a plugin to stream @@ -90,9 +70,13 @@ message CodeGeneratorRequest { // fully qualified. repeated FileDescriptorProto proto_file = 15; + // File descriptors with all options, including source-retention options. + // These descriptors are only provided for the files listed in + // files_to_generate. + repeated FileDescriptorProto source_file_descriptors = 17; + // The version number of protocol compiler. optional Version compiler_version = 3; - } // The plugin writes an encoded CodeGeneratorResponse to stdout. @@ -115,8 +99,21 @@ message CodeGeneratorResponse { enum Feature { FEATURE_NONE = 0; FEATURE_PROTO3_OPTIONAL = 1; + FEATURE_SUPPORTS_EDITIONS = 2; } + // The minimum edition this plugin supports. This will be treated as an + // Edition enum, but we want to allow unknown values. It should be specified + // according the edition enum value, *not* the edition number. Only takes + // effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + optional int32 minimum_edition = 3; + + // The maximum edition this plugin supports. This will be treated as an + // Edition enum, but we want to allow unknown values. It should be specified + // according the edition enum value, *not* the edition number. Only takes + // effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + optional int32 maximum_edition = 4; + // Represents a single generated file. message File { // The file name, relative to the output directory. The name must not diff --git a/Protos/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.proto b/Protos/Sources/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.proto similarity index 100% rename from Protos/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.proto rename to Protos/Sources/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.proto diff --git a/Protos/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_delimited.proto b/Protos/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_delimited.proto new file mode 100644 index 000000000..8a0a107c9 --- /dev/null +++ b/Protos/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_delimited.proto @@ -0,0 +1,31 @@ +// Protos/pluginlib_descriptor_test.proto - test proto +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2024 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 +/// +// ----------------------------------------------------------------------------- + +edition = "2023"; + +package swift_descriptor_test; + +option features.message_encoding = DELIMITED; + +message EditionsMessageForDelimited { + int32 scalar_field = 1; + map map_field = 2; + map message_map_field = 3; + EditionsMessageForDelimited delimited_field = 4; + EditionsMessageForDelimited length_prefixed_field = 5 [ + features.message_encoding = LENGTH_PREFIXED + ]; +} diff --git a/Protos/pluginlib_descriptor_test.proto b/Protos/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test.proto similarity index 62% rename from Protos/pluginlib_descriptor_test.proto rename to Protos/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test.proto index cf0340087..6893dfaa5 100644 --- a/Protos/pluginlib_descriptor_test.proto +++ b/Protos/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test.proto @@ -21,8 +21,7 @@ package swift_descriptor_test; // Use the option to test swift name generation. option swift_prefix = "SDT"; -import "google/protobuf/descriptor.proto"; -import "google/protobuf/compiler/plugin.proto"; +import "pluginlib_descriptor_test_import.proto"; enum TopLevelEnum { VALUE_ZERO = 0; @@ -61,23 +60,23 @@ message TopLevelMessage2 { } message ExternalRefs { - optional google.protobuf.DescriptorProto desc = 1; - optional google.protobuf.compiler.Version ver = 2; + optional swift_descriptor_test.import.ExtendableOne one = 1; + optional swift_descriptor_test.import.Version ver = 2; } -extend google.protobuf.FieldOptions { +extend swift_descriptor_test.import.ExtendableOne { optional string ext_str = 90000; } message ScoperForExt { - extend google.protobuf.MessageOptions { + extend swift_descriptor_test.import.ExtendableOne.ExtendableTwo { optional TopLevelEnum ext_enum = 99001; optional TopLevelMessage2 ext_msg = 99002; } } service SomeService { - rpc Foo(google.protobuf.DescriptorProto) returns (google.protobuf.compiler.Version); + rpc Foo(swift_descriptor_test.import.ExtendableOne) returns (swift_descriptor_test.import.Version); rpc Bar(TopLevelMessage) returns (TopLevelMessage2); } @@ -106,47 +105,3 @@ message Proto2MessageForPresence { } } - -// To check handling of extension ranges that are out of order. -message MsgExtensionRangeOrdering { - extensions 1, 3, 2, 4; - extensions 7; - reserved 8; - extensions 9; - - extensions 100 to 110; - reserved 121 to 125; - extensions 126 to 130; - extensions 111 to 120; -} - -// To check handling of extension ranges that are out of order, have fields or -// reserved things mix through them. -message MsgExtensionRangeOrderingWithFields { - extensions 1, 3, 2, 4; - optional int32 field6 = 6; - extensions 7; - reserved 8; - extensions 9; - - extensions 100 to 110; - reserved 121 to 123; - optional int32 field124 = 124; - optional int32 field125 = 125; - extensions 126 to 130; - extensions 111 to 120; - optional int32 field200 = 200; -} - -// Intermixed ranges and fields so help ensure no merge issues -message MsgExtensionRangeOrderingNoMerging { - optional int32 field1 = 1; - optional int32 field2 = 2; - extensions 3 to 5; - optional int32 field6 = 6; - extensions 7 to 12; - optional int32 field13 = 13; - optional int32 field15 = 15; - extensions 16 to 20; - optional int32 field21 = 21; -} diff --git a/Protos/pluginlib_descriptor_test2.proto b/Protos/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test2.proto similarity index 100% rename from Protos/pluginlib_descriptor_test2.proto rename to Protos/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test2.proto diff --git a/Protos/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test_import.proto b/Protos/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test_import.proto new file mode 100644 index 000000000..2cd4ccac2 --- /dev/null +++ b/Protos/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test_import.proto @@ -0,0 +1,37 @@ +// Protos/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test_import.proto - test proto +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2024 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 +/// +// ----------------------------------------------------------------------------- + +syntax = "proto2"; + +package swift_descriptor_test.import; + +message Version { + optional int32 major = 1; + optional int32 minor = 2; + optional int32 patch = 3; + optional string suffix = 4; +} + +message ExtendableOne { + + message ExtendableTwo { + extensions 1000 to max; + } + + optional ExtendableTwo sub_msg_field = 1; + + extensions 1000 to max; +} diff --git a/Protos/Tests/SwiftProtobufPluginLibraryTests/test_features.proto b/Protos/Tests/SwiftProtobufPluginLibraryTests/test_features.proto new file mode 100644 index 000000000..64423fde2 --- /dev/null +++ b/Protos/Tests/SwiftProtobufPluginLibraryTests/test_features.proto @@ -0,0 +1,103 @@ +// Protos/SwiftProtobufPluginLibraryTests/test_features.proto - test proto for Features +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2024 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 +// +// ----------------------------------------------------------------------------- + +syntax = "proto2"; + +package swift_feature_test; + +import "google/protobuf/descriptor.proto"; + +extend google.protobuf.FeatureSet { + optional TestFeatures test = 9999; +} + +message TestFeatures { + enum EnumFeature { + ENUM_FEATURE_UNKNOWN = 0; + ENUM_FEATURE_VALUE1 = 1; + ENUM_FEATURE_VALUE2 = 2; + ENUM_FEATURE_VALUE3 = 3; + ENUM_FEATURE_VALUE4 = 4; + ENUM_FEATURE_VALUE5 = 5; + ENUM_FEATURE_VALUE6 = 6; + } + optional EnumFeature feature1 = 1 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FILE, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_MESSAGE, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_ENUM_ENTRY, + targets = TARGET_TYPE_SERVICE, + targets = TARGET_TYPE_METHOD, + targets = TARGET_TYPE_ONEOF, + targets = TARGET_TYPE_EXTENSION_RANGE, + feature_support.edition_introduced = EDITION_2023, + edition_defaults = { edition: EDITION_LEGACY, value: "ENUM_FEATURE_VALUE1" } + ]; + optional EnumFeature feature2 = 2 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FILE, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_MESSAGE, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_ENUM_ENTRY, + targets = TARGET_TYPE_SERVICE, + targets = TARGET_TYPE_METHOD, + targets = TARGET_TYPE_ONEOF, + targets = TARGET_TYPE_EXTENSION_RANGE, + feature_support.edition_introduced = EDITION_2023, + edition_defaults = { edition: EDITION_LEGACY, value: "ENUM_FEATURE_VALUE1" } + ]; + optional EnumFeature feature3 = 3 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FILE, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_MESSAGE, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_ENUM_ENTRY, + targets = TARGET_TYPE_SERVICE, + targets = TARGET_TYPE_METHOD, + targets = TARGET_TYPE_ONEOF, + targets = TARGET_TYPE_EXTENSION_RANGE, + feature_support.edition_introduced = EDITION_2023, + edition_defaults = { edition: EDITION_LEGACY, value: "ENUM_FEATURE_VALUE1" } + ]; + optional EnumFeature feature4 = 4 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FILE, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_MESSAGE, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_ENUM_ENTRY, + targets = TARGET_TYPE_SERVICE, + targets = TARGET_TYPE_METHOD, + targets = TARGET_TYPE_ONEOF, + targets = TARGET_TYPE_EXTENSION_RANGE, + feature_support.edition_introduced = EDITION_2023, + edition_defaults = { edition: EDITION_LEGACY, value: "ENUM_FEATURE_VALUE1" } + ]; + optional EnumFeature feature5 = 5 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FILE, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_MESSAGE, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_ENUM_ENTRY, + targets = TARGET_TYPE_SERVICE, + targets = TARGET_TYPE_METHOD, + targets = TARGET_TYPE_ONEOF, + targets = TARGET_TYPE_EXTENSION_RANGE, + feature_support.edition_introduced = EDITION_2023, + edition_defaults = { edition: EDITION_LEGACY, value: "ENUM_FEATURE_VALUE1" } + ]; +} diff --git a/Protos/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited.proto b/Protos/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited.proto new file mode 100644 index 000000000..0ff738c98 --- /dev/null +++ b/Protos/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited.proto @@ -0,0 +1,75 @@ +edition = "2023"; + +package editions_unittest; + +import "unittest_delimited_import.proto"; + +// Test various scenarios that are now possible in edition 2023 that weren't in +// google.protobuf. + +message LengthPrefixed { + int32 a = 1; + int32 b = 2; +} + +message NotGroupLikeScope { + int32 a = 1; + int32 b = 2; +} + +message GroupLikeFileScope { + int32 a = 1; + int32 b = 2; +} + +message TestDelimited { + message LengthPrefixed { + int32 a = 1; + int32 b = 2; + } + // Non-delimited field that otherwise looks group-like. + LengthPrefixed lengthprefixed = 1; + + // Nested field for nested tests. + TestDelimited nested = 2 [features.message_encoding = DELIMITED]; + + message GroupLike { + int32 a = 1; + int32 b = 2; + } + + // Truly group-like field. + GroupLike grouplike = 3 [features.message_encoding = DELIMITED]; + + // Delimited field that isn't group-like solely because of its name. + GroupLike notgrouplike = 4 [features.message_encoding = DELIMITED]; + + // Delimited field that isn't group-like because of the scope of its type. + NotGroupLikeScope notgrouplikescope = 5 + [features.message_encoding = DELIMITED]; + + // Delimited field that's grouplike except that it's an imported type. + MessageImport messageimport = 6 [features.message_encoding = DELIMITED]; + + extensions 1000 to max; +} + +extend TestDelimited { + // Non-delimited field that otherwise looks group-like. + LengthPrefixed lengthprefixed = 1004; + + // Truly group-like extension. + GroupLikeFileScope grouplikefilescope = 1000 + [features.message_encoding = DELIMITED]; + + // Delimited extension that isn't group-like because of its name. + NotGroupLikeScope not_group_like_scope = 1001 + [features.message_encoding = DELIMITED]; + + // Delimited extension that isn't group-like because of the scope of its type. + TestDelimited.GroupLike grouplike = 1002 + [features.message_encoding = DELIMITED]; + + // Delimited extension that's grouplike except that it's an imported type. + MessageImport messageimport = 1003 [features.message_encoding = DELIMITED]; +} diff --git a/Protos/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited_import.proto b/Protos/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited_import.proto new file mode 100644 index 000000000..584aaf04a --- /dev/null +++ b/Protos/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited_import.proto @@ -0,0 +1,8 @@ +edition = "2023"; + +package editions_unittest; + +message MessageImport { + int32 a = 1; + int32 b = 2; +} diff --git a/Protos/google/protobuf/any_test.proto b/Protos/Tests/SwiftProtobufTests/any_test.proto similarity index 96% rename from Protos/google/protobuf/any_test.proto rename to Protos/Tests/SwiftProtobufTests/any_test.proto index 256035b44..d3babf6f5 100644 --- a/Protos/google/protobuf/any_test.proto +++ b/Protos/Tests/SwiftProtobufTests/any_test.proto @@ -30,12 +30,10 @@ syntax = "proto3"; -package protobuf_unittest; +package swift_proto_testing; import "google/protobuf/any.proto"; -option java_outer_classname = "TestAnyProto"; - message TestAny { int32 int32_value = 1; google.protobuf.Any any_value = 2; diff --git a/Protos/fuzz_testing.proto b/Protos/Tests/SwiftProtobufTests/fuzz_testing.proto similarity index 97% rename from Protos/fuzz_testing.proto rename to Protos/Tests/SwiftProtobufTests/fuzz_testing.proto index 433f6ee8d..be26c64f5 100644 --- a/Protos/fuzz_testing.proto +++ b/Protos/Tests/SwiftProtobufTests/fuzz_testing.proto @@ -15,7 +15,7 @@ syntax = "proto2"; -package fuzz.testing; +package swift_proto_testing.fuzz; import "google/protobuf/any.proto"; import "google/protobuf/api.proto"; @@ -343,6 +343,20 @@ message AMessageSetMessage { extensions 4 to max; } +// Two extensions to go with the message_set_wire_format testing. +message AMessageSetMessageExtension1 { + extend AMessageSetMessage { + optional AMessageSetMessageExtension1 message_set_extension = 1547769; + } + optional string a_string = 10; +} +message AMessageSetMessageExtension2 { + extend AMessageSetMessage { + optional AMessageSetMessageExtension2 message_set_extension = 4135312; + } + optional int32 an_int32 = 20; +} + extend Message { // Singular optional int32 singular_int32_ext = 1001; diff --git a/Protos/Tests/SwiftProtobufTests/generated_swift_names_enum_cases.proto b/Protos/Tests/SwiftProtobufTests/generated_swift_names_enum_cases.proto new file mode 100644 index 000000000..f4f3f5ab0 --- /dev/null +++ b/Protos/Tests/SwiftProtobufTests/generated_swift_names_enum_cases.proto @@ -0,0 +1,1035 @@ +// See Makefile for the logic that generates this +// Protoc errors imply this file is being generated incorrectly +// Swift compile errors are probably bugs in protoc-gen-swift +syntax = "proto3"; +package swift_proto_testing.generated; +enum GeneratedSwiftReservedEnum { + NONE = 0; + addPath = 1; + adjusted = 2; + aggregateValue = 3; + allCases = 4; + allowAlias = 5; + alwaysPrintEnumsAsInts = 6; + alwaysPrintInt64sAsNumbers = 7; + annotation = 8; + any = 9; + AnyExtensionField = 10; + AnyMessageExtension = 11; + AnyMessageStorage = 12; + AnyUnpackError = 13; + append = 14; + appended = 15; + appendUIntHex = 16; + appendUnknown = 17; + areAllInitialized = 18; + Array = 19; + arrayDepth = 20; + arrayLiteral = 21; + arraySeparator = 22; + as = 23; + asciiOpenCurlyBracket = 24; + asciiZero = 25; + async = 26; + AsyncIterator = 27; + AsyncIteratorProtocol = 28; + AsyncMessageSequence = 29; + available = 30; + b = 31; + Base = 32; + base64Values = 33; + baseAddress = 34; + BaseType = 35; + begin = 36; + binary = 37; + BinaryDecoder = 38; + BinaryDecoding = 39; + BinaryDecodingError = 40; + BinaryDecodingOptions = 41; + BinaryDelimited = 42; + BinaryEncoder = 43; + BinaryEncodingError = 44; + BinaryEncodingMessageSetSizeVisitor = 45; + BinaryEncodingMessageSetVisitor = 46; + BinaryEncodingOptions = 47; + BinaryEncodingSizeVisitor = 48; + BinaryEncodingVisitor = 49; + binaryOptions = 50; + binaryProtobufDelimitedMessages = 51; + BinaryStreamDecoding = 52; + binaryStreamDecodingError = 53; + bitPattern = 54; + body = 55; + Bool = 56; + booleanLiteral = 57; + BooleanLiteralType = 58; + boolValue = 59; + buffer = 60; + byte = 61; + bytecode = 62; + BytecodeReader = 63; + bytes = 64; + bytesInGroup = 65; + bytesNeeded = 66; + bytesRead = 67; + c = 68; + canonical = 69; + capitalizeNext = 70; + cardinality = 71; + CaseIterable = 72; + castedValue = 73; + ccEnableArenas = 74; + ccGenericServices = 75; + Character = 76; + chars = 77; + checkProgramFormat = 78; + chunk = 79; + class = 80; + clearAggregateValue = 81; + clearAllowAlias = 82; + clearBegin = 83; + clearCcEnableArenas = 84; + clearCcGenericServices = 85; + clearClientStreaming = 86; + clearCsharpNamespace = 87; + clearCtype = 88; + clearDebugRedact = 89; + clearDefaultSymbolVisibility = 90; + clearDefaultValue = 91; + clearDeprecated = 92; + clearDeprecatedLegacyJsonFieldConflicts = 93; + clearDeprecationWarning = 94; + clearDoubleValue = 95; + clearEdition = 96; + clearEditionDeprecated = 97; + clearEditionIntroduced = 98; + clearEditionRemoved = 99; + clearEnd = 100; + clearEnforceNamingStyle = 101; + clearEnumType = 102; + clearExtendee = 103; + clearExtensionValue = 104; + clearFeatures = 105; + clearFeatureSupport = 106; + clearFieldPresence = 107; + clearFixedFeatures = 108; + clearFullName = 109; + clearGoPackage = 110; + clearIdempotencyLevel = 111; + clearIdentifierValue = 112; + clearInputType = 113; + clearIsExtension = 114; + clearJavaGenerateEqualsAndHash = 115; + clearJavaGenericServices = 116; + clearJavaMultipleFiles = 117; + clearJavaOuterClassname = 118; + clearJavaPackage = 119; + clearJavaStringCheckUtf8 = 120; + clearJsonFormat = 121; + clearJsonName = 122; + clearJstype = 123; + clearLabel = 124; + clearLazy = 125; + clearLeadingComments = 126; + clearMapEntry = 127; + clearMaximumEdition = 128; + clearMessageEncoding = 129; + clearMessageSetWireFormat = 130; + clearMinimumEdition = 131; + clearName = 132; + clearNamePart = 133; + clearNegativeIntValue = 134; + clearNoStandardDescriptorAccessor = 135; + clearNumber = 136; + clearObjcClassPrefix = 137; + clearOneofIndex = 138; + clearOptimizeFor = 139; + clearOptions = 140; + clearOutputType = 141; + clearOverridableFeatures = 142; + clearPackage = 143; + clearPacked = 144; + clearPhpClassPrefix = 145; + clearPhpMetadataNamespace = 146; + clearPhpNamespace = 147; + clearPositiveIntValue = 148; + clearProto3Optional = 149; + clearPyGenericServices = 150; + clearRemovalError = 151; + clearRepeated = 152; + clearRepeatedFieldEncoding = 153; + clearReserved = 154; + clearRetention = 155; + clearRubyPackage = 156; + clearSemantic = 157; + clearServerStreaming = 158; + clearSourceCodeInfo = 159; + clearSourceContext = 160; + clearSourceFile = 161; + clearStart = 162; + clearStringValue = 163; + clearSwiftPrefix = 164; + clearSyntax = 165; + clearTrailingComments = 166; + clearType = 167; + clearTypeName = 168; + clearUnverifiedLazy = 169; + clearUtf8Validation = 170; + clearValue = 171; + clearVerification = 172; + clearVisibility = 173; + clearWeak = 174; + clientStreaming = 175; + code = 176; + codePoint = 177; + codeUnits = 178; + Collection = 179; + comma = 180; + consumedBytes = 181; + contains = 182; + contentsOf = 183; + ContiguousBytes = 184; + copy = 185; + count = 186; + countVarintsInBuffer = 187; + csharpNamespace = 188; + ctype = 189; + customCodable = 190; + CustomDebugStringConvertible = 191; + CustomStringConvertible = 192; + D = 193; + Data = 194; + dataResult = 195; + date = 196; + daySec = 197; + daysSinceEpoch = 198; + debugDescription = 199; + debugRedact = 200; + declaration = 201; + decoded = 202; + decodedFromJSONNull = 203; + decodeExtensionField = 204; + decodeExtensionFieldsAsMessageSet = 205; + decodeJSON = 206; + decodeMapField = 207; + decodeMessage = 208; + Decoder = 209; + decodeRepeated = 210; + decodeRepeatedBoolField = 211; + decodeRepeatedBytesField = 212; + decodeRepeatedDoubleField = 213; + decodeRepeatedEnumField = 214; + decodeRepeatedFixed32Field = 215; + decodeRepeatedFixed64Field = 216; + decodeRepeatedFloatField = 217; + decodeRepeatedGroupField = 218; + decodeRepeatedInt32Field = 219; + decodeRepeatedInt64Field = 220; + decodeRepeatedMessageField = 221; + decodeRepeatedSFixed32Field = 222; + decodeRepeatedSFixed64Field = 223; + decodeRepeatedSInt32Field = 224; + decodeRepeatedSInt64Field = 225; + decodeRepeatedStringField = 226; + decodeRepeatedUInt32Field = 227; + decodeRepeatedUInt64Field = 228; + decodeSingular = 229; + decodeSingularBoolField = 230; + decodeSingularBytesField = 231; + decodeSingularDoubleField = 232; + decodeSingularEnumField = 233; + decodeSingularFixed32Field = 234; + decodeSingularFixed64Field = 235; + decodeSingularFloatField = 236; + decodeSingularGroupField = 237; + decodeSingularInt32Field = 238; + decodeSingularInt64Field = 239; + decodeSingularMessageField = 240; + decodeSingularSFixed32Field = 241; + decodeSingularSFixed64Field = 242; + decodeSingularSInt32Field = 243; + decodeSingularSInt64Field = 244; + decodeSingularStringField = 245; + decodeSingularUInt32Field = 246; + decodeSingularUInt64Field = 247; + decodeTextFormat = 248; + defaultAnyTypeURLPrefix = 249; + defaults = 250; + defaultSymbolVisibility = 251; + defaultValue = 252; + dependency = 253; + deprecated = 254; + deprecatedLegacyJsonFieldConflicts = 255; + deprecationWarning = 256; + description = 257; + Dictionary = 258; + dictionaryLiteral = 259; + digit = 260; + digit0 = 261; + digit1 = 262; + digitCount = 263; + digits = 264; + digitValue = 265; + discardableResult = 266; + discardUnknownFields = 267; + Double = 268; + doubleValue = 269; + duration = 270; + E = 271; + edition = 272; + EditionDefault = 273; + editionDefaults = 274; + editionDeprecated = 275; + editionIntroduced = 276; + editionRemoved = 277; + Element = 278; + elements = 279; + else = 280; + emitExtensionFieldName = 281; + emitFieldName = 282; + emitFieldNumber = 283; + emptyAnyTypeURL = 284; + emptyData = 285; + encodeAsBytes = 286; + encoded = 287; + encodedJSONString = 288; + encodedSize = 289; + encodeField = 290; + encoder = 291; + end = 292; + endArray = 293; + endMessageField = 294; + endObject = 295; + endRegularField = 296; + enforceNamingStyle = 297; + enum = 298; + EnumReservedRange = 299; + enumType = 300; + enumvalue = 301; + Equatable = 302; + Error = 303; + execute = 304; + ExpressibleByArrayLiteral = 305; + ExpressibleByDictionaryLiteral = 306; + ext = 307; + extDecoder = 308; + extendedGraphemeClusterLiteral = 309; + ExtendedGraphemeClusterLiteralType = 310; + extendee = 311; + ExtensibleMessage = 312; + extension = 313; + ExtensionField = 314; + extensionFieldNumber = 315; + ExtensionFieldValueSet = 316; + ExtensionMap = 317; + extensionRange = 318; + extensions = 319; + extras = 320; + F = 321; + false = 322; + features = 323; + FeatureSetEditionDefault = 324; + featureSupport = 325; + field = 326; + fieldData = 327; + FieldMaskError = 328; + fieldName = 329; + fieldNameCount = 330; + fieldNum = 331; + fieldNumber = 332; + fieldNumberForProto = 333; + fieldPresence = 334; + fields = 335; + fieldSize = 336; + FieldTag = 337; + FieldType = 338; + file = 339; + fileName = 340; + filter = 341; + final = 342; + finiteOnly = 343; + first = 344; + firstItem = 345; + fixedFeatures = 346; + Float = 347; + floatLiteral = 348; + FloatLiteralType = 349; + for = 350; + forMessageName = 351; + formUnion = 352; + forReadingFrom = 353; + forTypeURL = 354; + ForwardParser = 355; + forWritingInto = 356; + from = 357; + fromAscii2 = 358; + fromAscii4 = 359; + fromByteOffset = 360; + fromHexDigit = 361; + fullName = 362; + func = 363; + function = 364; + G = 365; + get = 366; + getExtensionValue = 367; + Google_Protobuf_Any = 368; + Google_Protobuf_Api = 369; + Google_Protobuf_BoolValue = 370; + Google_Protobuf_BytesValue = 371; + Google_Protobuf_DescriptorProto = 372; + Google_Protobuf_DoubleValue = 373; + Google_Protobuf_Duration = 374; + Google_Protobuf_Edition = 375; + Google_Protobuf_Empty = 376; + Google_Protobuf_Enum = 377; + Google_Protobuf_EnumDescriptorProto = 378; + Google_Protobuf_EnumOptions = 379; + Google_Protobuf_EnumValue = 380; + Google_Protobuf_EnumValueDescriptorProto = 381; + Google_Protobuf_EnumValueOptions = 382; + Google_Protobuf_ExtensionRangeOptions = 383; + Google_Protobuf_FeatureSet = 384; + Google_Protobuf_FeatureSetDefaults = 385; + Google_Protobuf_Field = 386; + Google_Protobuf_FieldDescriptorProto = 387; + Google_Protobuf_FieldMask = 388; + Google_Protobuf_FieldOptions = 389; + Google_Protobuf_FileDescriptorProto = 390; + Google_Protobuf_FileDescriptorSet = 391; + Google_Protobuf_FileOptions = 392; + Google_Protobuf_FloatValue = 393; + Google_Protobuf_GeneratedCodeInfo = 394; + Google_Protobuf_Int32Value = 395; + Google_Protobuf_Int64Value = 396; + Google_Protobuf_ListValue = 397; + Google_Protobuf_MessageOptions = 398; + Google_Protobuf_Method = 399; + Google_Protobuf_MethodDescriptorProto = 400; + Google_Protobuf_MethodOptions = 401; + Google_Protobuf_Mixin = 402; + Google_Protobuf_NullValue = 403; + Google_Protobuf_OneofDescriptorProto = 404; + Google_Protobuf_OneofOptions = 405; + Google_Protobuf_Option = 406; + Google_Protobuf_ServiceDescriptorProto = 407; + Google_Protobuf_ServiceOptions = 408; + Google_Protobuf_SourceCodeInfo = 409; + Google_Protobuf_SourceContext = 410; + Google_Protobuf_StringValue = 411; + Google_Protobuf_Struct = 412; + Google_Protobuf_SymbolVisibility = 413; + Google_Protobuf_Syntax = 414; + Google_Protobuf_Timestamp = 415; + Google_Protobuf_Type = 416; + Google_Protobuf_UInt32Value = 417; + Google_Protobuf_UInt64Value = 418; + Google_Protobuf_UninterpretedOption = 419; + Google_Protobuf_Value = 420; + goPackage = 421; + gotData = 422; + group = 423; + groupFieldNumberStack = 424; + groupSize = 425; + guard = 426; + hadOneofValue = 427; + handleConflictingOneOf = 428; + handleInstruction = 429; + hasAggregateValue = 430; + hasAllowAlias = 431; + hasBegin = 432; + hasCcEnableArenas = 433; + hasCcGenericServices = 434; + hasClientStreaming = 435; + hasCsharpNamespace = 436; + hasCtype = 437; + hasData = 438; + hasDebugRedact = 439; + hasDefaultSymbolVisibility = 440; + hasDefaultValue = 441; + hasDeprecated = 442; + hasDeprecatedLegacyJsonFieldConflicts = 443; + hasDeprecationWarning = 444; + hasDoubleValue = 445; + hasEdition = 446; + hasEditionDeprecated = 447; + hasEditionIntroduced = 448; + hasEditionRemoved = 449; + hasEnd = 450; + hasEnforceNamingStyle = 451; + hasEnumType = 452; + hasExplicitDelta = 453; + hasExtendee = 454; + hasExtensionValue = 455; + hasFeatures = 456; + hasFeatureSupport = 457; + hasFieldPresence = 458; + hasFixedFeatures = 459; + hasFullName = 460; + hasGoPackage = 461; + hash = 462; + Hashable = 463; + hasher = 464; + HashVisitor = 465; + hasIdempotencyLevel = 466; + hasIdentifierValue = 467; + hasInputType = 468; + hasIsExtension = 469; + hasJavaGenerateEqualsAndHash = 470; + hasJavaGenericServices = 471; + hasJavaMultipleFiles = 472; + hasJavaOuterClassname = 473; + hasJavaPackage = 474; + hasJavaStringCheckUtf8 = 475; + hasJsonFormat = 476; + hasJsonName = 477; + hasJstype = 478; + hasLabel = 479; + hasLazy = 480; + hasLeadingComments = 481; + hasMapEntry = 482; + hasMaximumEdition = 483; + hasMessageEncoding = 484; + hasMessageSetWireFormat = 485; + hasMinimumEdition = 486; + hasName = 487; + hasNamePart = 488; + hasNegativeIntValue = 489; + hasNoStandardDescriptorAccessor = 490; + hasNumber = 491; + hasObjcClassPrefix = 492; + hasOneofIndex = 493; + hasOptimizeFor = 494; + hasOptions = 495; + hasOutputType = 496; + hasOverridableFeatures = 497; + hasPackage = 498; + hasPacked = 499; + hasPhpClassPrefix = 500; + hasPhpMetadataNamespace = 501; + hasPhpNamespace = 502; + hasPositiveIntValue = 503; + hasProto3Optional = 504; + hasPyGenericServices = 505; + hasRemovalError = 506; + hasRepeated = 507; + hasRepeatedFieldEncoding = 508; + hasReserved = 509; + hasRetention = 510; + hasRubyPackage = 511; + hasSemantic = 512; + hasServerStreaming = 513; + hasSourceCodeInfo = 514; + hasSourceContext = 515; + hasSourceFile = 516; + hasStart = 517; + hasStringValue = 518; + hasSwiftPrefix = 519; + hasSyntax = 520; + hasTrailingComments = 521; + hasType = 522; + hasTypeName = 523; + hasUnverifiedLazy = 524; + hasUtf8Validation = 525; + hasValue = 526; + hasVerification = 527; + hasVisibility = 528; + hasWeak = 529; + hour = 530; + i = 531; + idempotencyLevel = 532; + identifierValue = 533; + if = 534; + ignoreUnknownExtensionFields = 535; + ignoreUnknownFields = 536; + index = 537; + init = 538; + inout = 539; + inputType = 540; + insert = 541; + Instruction = 542; + Int = 543; + Int32 = 544; + Int64 = 545; + Int8 = 546; + integerLiteral = 547; + IntegerLiteralType = 548; + intern = 549; + Internal = 550; + InternalState = 551; + intersect = 552; + into = 553; + ints = 554; + invalidAnyTypeURL = 555; + isA = 556; + isEqual = 557; + isEqualTo = 558; + isExtension = 559; + isInitialized = 560; + isNegative = 561; + isPathValid = 562; + isReserved = 563; + isValid = 564; + itemTagsEncodedSize = 565; + iterator = 566; + javaGenerateEqualsAndHash = 567; + javaGenericServices = 568; + javaMultipleFiles = 569; + javaOuterClassname = 570; + javaPackage = 571; + javaStringCheckUtf8 = 572; + JSONDecoder = 573; + JSONDecoding = 574; + JSONDecodingError = 575; + JSONDecodingOptions = 576; + jsonEncoder = 577; + JSONEncoding = 578; + JSONEncodingError = 579; + JSONEncodingOptions = 580; + JSONEncodingVisitor = 581; + jsonFormat = 582; + JSONMapEncodingVisitor = 583; + jsonName = 584; + jsonPath = 585; + jsonPaths = 586; + JSONScanner = 587; + jsonString = 588; + jsonText = 589; + jsonUTF8Bytes = 590; + jsonUTF8Data = 591; + jstype = 592; + k = 593; + kChunkSize = 594; + Key = 595; + keyField = 596; + keyFieldOpt = 597; + KeyType = 598; + kind = 599; + l = 600; + label = 601; + lazy = 602; + leadingComments = 603; + leadingDetachedComments = 604; + length = 605; + lessThan = 606; + let = 607; + lhs = 608; + line = 609; + list = 610; + listOfMessages = 611; + listValue = 612; + littleEndian = 613; + load = 614; + localHasher = 615; + location = 616; + M = 617; + major = 618; + makeAsyncIterator = 619; + makeIterator = 620; + malformedLength = 621; + mapEntry = 622; + MapKeyType = 623; + mapToMessages = 624; + MapValueType = 625; + mapVisitor = 626; + mask = 627; + maximumEdition = 628; + mdayStart = 629; + merge = 630; + MergeOptions = 631; + message = 632; + messageDepthLimit = 633; + messageEncoding = 634; + MessageExtension = 635; + MessageImplementationBase = 636; + MessageSet = 637; + messageSetWireFormat = 638; + messageSize = 639; + messageType = 640; + method = 641; + methods = 642; + min = 643; + minimumEdition = 644; + minor = 645; + mixins = 646; + modify = 647; + month = 648; + msgExtension = 649; + mutating = 650; + n = 651; + name = 652; + NameDescription = 653; + NameMap = 654; + NamePart = 655; + names = 656; + nanos = 657; + negativeIntValue = 658; + nestedType = 659; + newExtensible = 660; + newL = 661; + newList = 662; + newMessage = 663; + newValue = 664; + next = 665; + nextByte = 666; + nextFieldNumber = 667; + nextInstruction = 668; + nextInt32 = 669; + nextNullTerminatedString = 670; + nextNullTerminatedStringArray = 671; + nextNumber = 672; + nextUInt64 = 673; + nextVarInt = 674; + nil = 675; + nilLiteral = 676; + noBytesAvailable = 677; + noStandardDescriptorAccessor = 678; + nullValue = 679; + number = 680; + numberValue = 681; + objcClassPrefix = 682; + of = 683; + OneOf_Kind = 684; + oneofDecl = 685; + oneofIndex = 686; + oneofs = 687; + optimizeFor = 688; + OptimizeMode = 689; + OptionalEnumExtensionField = 690; + OptionalExtensionField = 691; + OptionalGroupExtensionField = 692; + OptionalMessageExtensionField = 693; + optionDependency = 694; + OptionRetention = 695; + options = 696; + OptionTargetType = 697; + other = 698; + others = 699; + out = 700; + outputType = 701; + overridableFeatures = 702; + p = 703; + package = 704; + packed = 705; + PackedEnumExtensionField = 706; + PackedExtensionField = 707; + padding = 708; + parent = 709; + parse = 710; + partial = 711; + path = 712; + PathDecoder = 713; + PathDecodingError = 714; + paths = 715; + PathVisitor = 716; + payload = 717; + payloadSize = 718; + phpClassPrefix = 719; + phpMetadataNamespace = 720; + phpNamespace = 721; + pos = 722; + positiveIntValue = 723; + prefix = 724; + preserveProtoFieldNames = 725; + preTraverse = 726; + previousNumber = 727; + prevPath = 728; + printUnknownFields = 729; + programBuffer = 730; + programFormat = 731; + proto2 = 732; + proto3DefaultValue = 733; + proto3Optional = 734; + protobuf_extensionFieldValues = 735; + protobuf_fieldNumber = 736; + protobuf_generated_isEqualTo = 737; + protobuf_nameMap = 738; + protobuf_newField = 739; + protobuf_package = 740; + ProtobufAPIVersion_2 = 741; + ProtobufAPIVersionCheck = 742; + ProtobufBool = 743; + ProtobufBytes = 744; + protobufData = 745; + ProtobufDouble = 746; + ProtobufEnumMap = 747; + protobufExtension = 748; + ProtobufFixed32 = 749; + ProtobufFixed64 = 750; + ProtobufFloat = 751; + ProtobufInt32 = 752; + ProtobufInt64 = 753; + ProtobufMap = 754; + ProtobufMessageMap = 755; + ProtobufSFixed32 = 756; + ProtobufSFixed64 = 757; + ProtobufSInt32 = 758; + ProtobufSInt64 = 759; + ProtobufString = 760; + ProtobufUInt32 = 761; + ProtobufUInt64 = 762; + protocol = 763; + protoFieldName = 764; + protoMessageName = 765; + ProtoNameProviding = 766; + protoPaths = 767; + public = 768; + publicDependency = 769; + putBoolValue = 770; + putBytesValue = 771; + putDoubleValue = 772; + putEnumValue = 773; + putFixedUInt32 = 774; + putFixedUInt64 = 775; + putFloatValue = 776; + putInt64 = 777; + putStringValue = 778; + putUInt64 = 779; + putUInt64Hex = 780; + putVarInt = 781; + putZigZagVarInt = 782; + pyGenericServices = 783; + R = 784; + rawChars = 785; + RawRepresentable = 786; + RawValue = 787; + read4HexDigits = 788; + readBytes = 789; + reader = 790; + register = 791; + remainingProgram = 792; + removalError = 793; + removingAllFieldsOf = 794; + repeated = 795; + RepeatedEnumExtensionField = 796; + RepeatedExtensionField = 797; + repeatedFieldEncoding = 798; + RepeatedGroupExtensionField = 799; + RepeatedMessageExtensionField = 800; + repeating = 801; + replaceRepeatedFields = 802; + requestStreaming = 803; + requestTypeURL = 804; + requiredSize = 805; + responseStreaming = 806; + responseTypeURL = 807; + result = 808; + retention = 809; + rethrows = 810; + ReturnType = 811; + revision = 812; + rhs = 813; + root = 814; + rubyPackage = 815; + s = 816; + sawBackslash = 817; + sawSection4Characters = 818; + sawSection5Characters = 819; + Scalar = 820; + scan = 821; + scanner = 822; + seconds = 823; + self = 824; + semantic = 825; + Sendable = 826; + separator = 827; + serialize = 828; + serializedBytes = 829; + serializedData = 830; + serializedSize = 831; + serverStreaming = 832; + service = 833; + set = 834; + setExtensionValue = 835; + shift = 836; + SimpleExtensionMap = 837; + size = 838; + sizer = 839; + source = 840; + sourceCodeInfo = 841; + sourceContext = 842; + sourceEncoding = 843; + sourceFile = 844; + SourceLocation = 845; + span = 846; + split = 847; + start = 848; + startArray = 849; + startArrayObject = 850; + startField = 851; + startIndex = 852; + startMessageField = 853; + startObject = 854; + startRegularField = 855; + state = 856; + static = 857; + StaticString = 858; + storage = 859; + String = 860; + stringLiteral = 861; + StringLiteralType = 862; + stringResult = 863; + stringValue = 864; + struct = 865; + structValue = 866; + subDecoder = 867; + subscript = 868; + subtract = 869; + subVisitor = 870; + Swift = 871; + swiftPrefix = 872; + SwiftProtobufContiguousBytes = 873; + SwiftProtobufError = 874; + syntax = 875; + T = 876; + tag = 877; + targets = 878; + terminator = 879; + testDecoder = 880; + text = 881; + textDecoder = 882; + TextFormatDecoder = 883; + TextFormatDecodingError = 884; + TextFormatDecodingOptions = 885; + TextFormatEncodingOptions = 886; + TextFormatEncodingVisitor = 887; + textFormatString = 888; + throwOrIgnore = 889; + throws = 890; + timeInterval = 891; + timeIntervalSince1970 = 892; + timeIntervalSinceReferenceDate = 893; + tmp = 894; + tooLarge = 895; + total = 896; + totalArrayDepth = 897; + totalSize = 898; + trailingComments = 899; + traverse = 900; + trim = 901; + true = 902; + try = 903; + type = 904; + typealias = 905; + TypeEnum = 906; + typeName = 907; + typePrefix = 908; + typeStart = 909; + typeUnknown = 910; + typeURL = 911; + UInt32 = 912; + UInt64 = 913; + UInt8 = 914; + unchecked = 915; + Unicode = 916; + unicodeScalarLiteral = 917; + UnicodeScalarLiteralType = 918; + unicodeScalars = 919; + UnicodeScalarView = 920; + uninterpretedOption = 921; + union = 922; + uniqueStorage = 923; + unknown = 924; + unknownFields = 925; + UnknownStorage = 926; + unpackTo = 927; + UnsafeBufferPointer = 928; + UnsafeMutablePointer = 929; + UnsafeMutableRawBufferPointer = 930; + UnsafeRawBufferPointer = 931; + UnsafeRawPointer = 932; + unverifiedLazy = 933; + updatedOptions = 934; + uppercasedAssumingASCII = 935; + url = 936; + useDeterministicOrdering = 937; + utf8 = 938; + utf8Ptr = 939; + utf8ToDouble = 940; + utf8Validation = 941; + UTF8View = 942; + V = 943; + value = 944; + valueField = 945; + values = 946; + ValueType = 947; + var = 948; + verification = 949; + VerificationState = 950; + version = 951; + versionString = 952; + visibility = 953; + VisibilityFeature = 954; + visitExtensionFields = 955; + visitExtensionFieldsAsMessageSet = 956; + visitMapField = 957; + Visitor = 958; + visitPacked = 959; + visitPackedBoolField = 960; + visitPackedDoubleField = 961; + visitPackedEnumField = 962; + visitPackedFixed32Field = 963; + visitPackedFixed64Field = 964; + visitPackedFloatField = 965; + visitPackedInt32Field = 966; + visitPackedInt64Field = 967; + visitPackedSFixed32Field = 968; + visitPackedSFixed64Field = 969; + visitPackedSInt32Field = 970; + visitPackedSInt64Field = 971; + visitPackedUInt32Field = 972; + visitPackedUInt64Field = 973; + visitRepeated = 974; + visitRepeatedBoolField = 975; + visitRepeatedBytesField = 976; + visitRepeatedDoubleField = 977; + visitRepeatedEnumField = 978; + visitRepeatedFixed32Field = 979; + visitRepeatedFixed64Field = 980; + visitRepeatedFloatField = 981; + visitRepeatedGroupField = 982; + visitRepeatedInt32Field = 983; + visitRepeatedInt64Field = 984; + visitRepeatedMessageField = 985; + visitRepeatedSFixed32Field = 986; + visitRepeatedSFixed64Field = 987; + visitRepeatedSInt32Field = 988; + visitRepeatedSInt64Field = 989; + visitRepeatedStringField = 990; + visitRepeatedUInt32Field = 991; + visitRepeatedUInt64Field = 992; + visitSingular = 993; + visitSingularBoolField = 994; + visitSingularBytesField = 995; + visitSingularDoubleField = 996; + visitSingularEnumField = 997; + visitSingularFixed32Field = 998; + visitSingularFixed64Field = 999; + visitSingularFloatField = 1000; + visitSingularGroupField = 1001; + visitSingularInt32Field = 1002; + visitSingularInt64Field = 1003; + visitSingularMessageField = 1004; + visitSingularSFixed32Field = 1005; + visitSingularSFixed64Field = 1006; + visitSingularSInt32Field = 1007; + visitSingularSInt64Field = 1008; + visitSingularStringField = 1009; + visitSingularUInt32Field = 1010; + visitSingularUInt64Field = 1011; + visitUnknown = 1012; + Void = 1013; + wasDecoded = 1014; + weak = 1015; + weakDependency = 1016; + where = 1017; + wireFormat = 1018; + with = 1019; + withUnsafeBytes = 1020; + withUnsafeMutableBytes = 1021; + work = 1022; + Wrapped = 1023; + WrappedType = 1024; + wrappedValue = 1025; + written = 1026; + yday = 1027; +} diff --git a/Protos/generated_swift_names_enums.proto b/Protos/Tests/SwiftProtobufTests/generated_swift_names_enums.proto similarity index 78% rename from Protos/generated_swift_names_enums.proto rename to Protos/Tests/SwiftProtobufTests/generated_swift_names_enums.proto index e6d365e50..35772e127 100644 --- a/Protos/generated_swift_names_enums.proto +++ b/Protos/Tests/SwiftProtobufTests/generated_swift_names_enums.proto @@ -2,39 +2,47 @@ // Protoc errors imply this file is being generated incorrectly // Swift compile errors are probably bugs in protoc-gen-swift syntax = "proto3"; -package protobuf_unittest_generated; +package swift_proto_testing.generated; message GeneratedSwiftReservedEnums { + enum addPath { NONE_addPath = 0; } enum adjusted { NONE_adjusted = 0; } enum aggregateValue { NONE_aggregateValue = 0; } enum allCases { NONE_allCases = 0; } enum allowAlias { NONE_allowAlias = 0; } enum alwaysPrintEnumsAsInts { NONE_alwaysPrintEnumsAsInts = 0; } + enum alwaysPrintInt64sAsNumbers { NONE_alwaysPrintInt64sAsNumbers = 0; } enum annotation { NONE_annotation = 0; } enum any { NONE_any = 0; } enum AnyExtensionField { NONE_AnyExtensionField = 0; } enum AnyMessageExtension { NONE_AnyMessageExtension = 0; } enum AnyMessageStorage { NONE_AnyMessageStorage = 0; } enum AnyUnpackError { NONE_AnyUnpackError = 0; } - enum Api { NONE_Api = 0; } + enum append { NONE_append = 0; } enum appended { NONE_appended = 0; } enum appendUIntHex { NONE_appendUIntHex = 0; } enum appendUnknown { NONE_appendUnknown = 0; } enum areAllInitialized { NONE_areAllInitialized = 0; } - enum array { NONE_array = 0; } + enum Array { NONE_Array = 0; } enum arrayDepth { NONE_arrayDepth = 0; } enum arrayLiteral { NONE_arrayLiteral = 0; } enum arraySeparator { NONE_arraySeparator = 0; } enum as { NONE_as = 0; } enum asciiOpenCurlyBracket { NONE_asciiOpenCurlyBracket = 0; } enum asciiZero { NONE_asciiZero = 0; } + enum async { NONE_async = 0; } + enum AsyncIterator { NONE_AsyncIterator = 0; } + enum AsyncIteratorProtocol { NONE_AsyncIteratorProtocol = 0; } + enum AsyncMessageSequence { NONE_AsyncMessageSequence = 0; } enum available { NONE_available = 0; } enum b { NONE_b = 0; } + enum Base { NONE_Base = 0; } enum base64Values { NONE_base64Values = 0; } enum baseAddress { NONE_baseAddress = 0; } enum BaseType { NONE_BaseType = 0; } enum begin { NONE_begin = 0; } enum binary { NONE_binary = 0; } enum BinaryDecoder { NONE_BinaryDecoder = 0; } + enum BinaryDecoding { NONE_BinaryDecoding = 0; } enum BinaryDecodingError { NONE_BinaryDecodingError = 0; } enum BinaryDecodingOptions { NONE_BinaryDecodingOptions = 0; } enum BinaryDelimited { NONE_BinaryDelimited = 0; } @@ -42,25 +50,39 @@ message GeneratedSwiftReservedEnums { enum BinaryEncodingError { NONE_BinaryEncodingError = 0; } enum BinaryEncodingMessageSetSizeVisitor { NONE_BinaryEncodingMessageSetSizeVisitor = 0; } enum BinaryEncodingMessageSetVisitor { NONE_BinaryEncodingMessageSetVisitor = 0; } + enum BinaryEncodingOptions { NONE_BinaryEncodingOptions = 0; } enum BinaryEncodingSizeVisitor { NONE_BinaryEncodingSizeVisitor = 0; } enum BinaryEncodingVisitor { NONE_BinaryEncodingVisitor = 0; } enum binaryOptions { NONE_binaryOptions = 0; } + enum binaryProtobufDelimitedMessages { NONE_binaryProtobufDelimitedMessages = 0; } + enum BinaryStreamDecoding { NONE_BinaryStreamDecoding = 0; } + enum binaryStreamDecodingError { NONE_binaryStreamDecodingError = 0; } + enum bitPattern { NONE_bitPattern = 0; } enum body { NONE_body = 0; } enum Bool { NONE_Bool = 0; } enum booleanLiteral { NONE_booleanLiteral = 0; } enum BooleanLiteralType { NONE_BooleanLiteralType = 0; } enum boolValue { NONE_boolValue = 0; } + enum buffer { NONE_buffer = 0; } + enum byte { NONE_byte = 0; } + enum bytecode { NONE_bytecode = 0; } + enum BytecodeReader { NONE_BytecodeReader = 0; } enum bytes { NONE_bytes = 0; } enum bytesInGroup { NONE_bytesInGroup = 0; } + enum bytesNeeded { NONE_bytesNeeded = 0; } enum bytesRead { NONE_bytesRead = 0; } - enum BytesValue { NONE_BytesValue = 0; } enum c { NONE_c = 0; } + enum canonical { NONE_canonical = 0; } enum capitalizeNext { NONE_capitalizeNext = 0; } enum cardinality { NONE_cardinality = 0; } + enum CaseIterable { NONE_CaseIterable = 0; } + enum castedValue { NONE_castedValue = 0; } enum ccEnableArenas { NONE_ccEnableArenas = 0; } enum ccGenericServices { NONE_ccGenericServices = 0; } enum Character { NONE_Character = 0; } enum chars { NONE_chars = 0; } + enum checkProgramFormat { NONE_checkProgramFormat = 0; } + enum chunk { NONE_chunk = 0; } enum class { NONE_class = 0; } enum clearAggregateValue { NONE_clearAggregateValue = 0; } enum clearAllowAlias { NONE_clearAllowAlias = 0; } @@ -70,12 +92,27 @@ message GeneratedSwiftReservedEnums { enum clearClientStreaming { NONE_clearClientStreaming = 0; } enum clearCsharpNamespace { NONE_clearCsharpNamespace = 0; } enum clearCtype { NONE_clearCtype = 0; } + enum clearDebugRedact { NONE_clearDebugRedact = 0; } + enum clearDefaultSymbolVisibility { NONE_clearDefaultSymbolVisibility = 0; } enum clearDefaultValue { NONE_clearDefaultValue = 0; } enum clearDeprecated { NONE_clearDeprecated = 0; } + enum clearDeprecatedLegacyJsonFieldConflicts { NONE_clearDeprecatedLegacyJsonFieldConflicts = 0; } + enum clearDeprecationWarning { NONE_clearDeprecationWarning = 0; } enum clearDoubleValue { NONE_clearDoubleValue = 0; } + enum clearEdition { NONE_clearEdition = 0; } + enum clearEditionDeprecated { NONE_clearEditionDeprecated = 0; } + enum clearEditionIntroduced { NONE_clearEditionIntroduced = 0; } + enum clearEditionRemoved { NONE_clearEditionRemoved = 0; } enum clearEnd { NONE_clearEnd = 0; } + enum clearEnforceNamingStyle { NONE_clearEnforceNamingStyle = 0; } + enum clearEnumType { NONE_clearEnumType = 0; } enum clearExtendee { NONE_clearExtendee = 0; } enum clearExtensionValue { NONE_clearExtensionValue = 0; } + enum clearFeatures { NONE_clearFeatures = 0; } + enum clearFeatureSupport { NONE_clearFeatureSupport = 0; } + enum clearFieldPresence { NONE_clearFieldPresence = 0; } + enum clearFixedFeatures { NONE_clearFixedFeatures = 0; } + enum clearFullName { NONE_clearFullName = 0; } enum clearGoPackage { NONE_clearGoPackage = 0; } enum clearIdempotencyLevel { NONE_clearIdempotencyLevel = 0; } enum clearIdentifierValue { NONE_clearIdentifierValue = 0; } @@ -87,13 +124,17 @@ message GeneratedSwiftReservedEnums { enum clearJavaOuterClassname { NONE_clearJavaOuterClassname = 0; } enum clearJavaPackage { NONE_clearJavaPackage = 0; } enum clearJavaStringCheckUtf8 { NONE_clearJavaStringCheckUtf8 = 0; } + enum clearJsonFormat { NONE_clearJsonFormat = 0; } enum clearJsonName { NONE_clearJsonName = 0; } enum clearJstype { NONE_clearJstype = 0; } enum clearLabel { NONE_clearLabel = 0; } enum clearLazy { NONE_clearLazy = 0; } enum clearLeadingComments { NONE_clearLeadingComments = 0; } enum clearMapEntry { NONE_clearMapEntry = 0; } + enum clearMaximumEdition { NONE_clearMaximumEdition = 0; } + enum clearMessageEncoding { NONE_clearMessageEncoding = 0; } enum clearMessageSetWireFormat { NONE_clearMessageSetWireFormat = 0; } + enum clearMinimumEdition { NONE_clearMinimumEdition = 0; } enum clearName { NONE_clearName = 0; } enum clearNamePart { NONE_clearNamePart = 0; } enum clearNegativeIntValue { NONE_clearNegativeIntValue = 0; } @@ -104,16 +145,22 @@ message GeneratedSwiftReservedEnums { enum clearOptimizeFor { NONE_clearOptimizeFor = 0; } enum clearOptions { NONE_clearOptions = 0; } enum clearOutputType { NONE_clearOutputType = 0; } + enum clearOverridableFeatures { NONE_clearOverridableFeatures = 0; } enum clearPackage { NONE_clearPackage = 0; } enum clearPacked { NONE_clearPacked = 0; } enum clearPhpClassPrefix { NONE_clearPhpClassPrefix = 0; } - enum clearPhpGenericServices { NONE_clearPhpGenericServices = 0; } enum clearPhpMetadataNamespace { NONE_clearPhpMetadataNamespace = 0; } enum clearPhpNamespace { NONE_clearPhpNamespace = 0; } enum clearPositiveIntValue { NONE_clearPositiveIntValue = 0; } enum clearProto3Optional { NONE_clearProto3Optional = 0; } enum clearPyGenericServices { NONE_clearPyGenericServices = 0; } + enum clearRemovalError { NONE_clearRemovalError = 0; } + enum clearRepeated { NONE_clearRepeated = 0; } + enum clearRepeatedFieldEncoding { NONE_clearRepeatedFieldEncoding = 0; } + enum clearReserved { NONE_clearReserved = 0; } + enum clearRetention { NONE_clearRetention = 0; } enum clearRubyPackage { NONE_clearRubyPackage = 0; } + enum clearSemantic { NONE_clearSemantic = 0; } enum clearServerStreaming { NONE_clearServerStreaming = 0; } enum clearSourceCodeInfo { NONE_clearSourceCodeInfo = 0; } enum clearSourceContext { NONE_clearSourceContext = 0; } @@ -125,29 +172,39 @@ message GeneratedSwiftReservedEnums { enum clearTrailingComments { NONE_clearTrailingComments = 0; } enum clearType { NONE_clearType = 0; } enum clearTypeName { NONE_clearTypeName = 0; } + enum clearUnverifiedLazy { NONE_clearUnverifiedLazy = 0; } + enum clearUtf8Validation { NONE_clearUtf8Validation = 0; } enum clearValue { NONE_clearValue = 0; } + enum clearVerification { NONE_clearVerification = 0; } + enum clearVisibility { NONE_clearVisibility = 0; } enum clearWeak { NONE_clearWeak = 0; } enum clientStreaming { NONE_clientStreaming = 0; } + enum code { NONE_code = 0; } enum codePoint { NONE_codePoint = 0; } enum codeUnits { NONE_codeUnits = 0; } enum Collection { NONE_Collection = 0; } - enum com { NONE_com = 0; } enum comma { NONE_comma = 0; } + enum consumedBytes { NONE_consumedBytes = 0; } + enum contains { NONE_contains = 0; } enum contentsOf { NONE_contentsOf = 0; } enum ContiguousBytes { NONE_ContiguousBytes = 0; } + enum copy { NONE_copy = 0; } enum count { NONE_count = 0; } enum countVarintsInBuffer { NONE_countVarintsInBuffer = 0; } enum csharpNamespace { NONE_csharpNamespace = 0; } enum ctype { NONE_ctype = 0; } enum customCodable { NONE_customCodable = 0; } enum CustomDebugStringConvertible { NONE_CustomDebugStringConvertible = 0; } - enum d { NONE_d = 0; } + enum CustomStringConvertible { NONE_CustomStringConvertible = 0; } + enum D { NONE_D = 0; } enum Data { NONE_Data = 0; } enum dataResult { NONE_dataResult = 0; } enum date { NONE_date = 0; } enum daySec { NONE_daySec = 0; } enum daysSinceEpoch { NONE_daysSinceEpoch = 0; } enum debugDescription { NONE_debugDescription = 0; } + enum debugRedact { NONE_debugRedact = 0; } + enum declaration { NONE_declaration = 0; } enum decoded { NONE_decoded = 0; } enum decodedFromJSONNull { NONE_decodedFromJSONNull = 0; } enum decodeExtensionField { NONE_decodeExtensionField = 0; } @@ -155,7 +212,7 @@ message GeneratedSwiftReservedEnums { enum decodeJSON { NONE_decodeJSON = 0; } enum decodeMapField { NONE_decodeMapField = 0; } enum decodeMessage { NONE_decodeMessage = 0; } - enum decoder { NONE_decoder = 0; } + enum Decoder { NONE_Decoder = 0; } enum decodeRepeated { NONE_decodeRepeated = 0; } enum decodeRepeatedBoolField { NONE_decodeRepeatedBoolField = 0; } enum decodeRepeatedBytesField { NONE_decodeRepeatedBytesField = 0; } @@ -196,11 +253,14 @@ message GeneratedSwiftReservedEnums { enum decodeSingularUInt64Field { NONE_decodeSingularUInt64Field = 0; } enum decodeTextFormat { NONE_decodeTextFormat = 0; } enum defaultAnyTypeURLPrefix { NONE_defaultAnyTypeURLPrefix = 0; } + enum defaults { NONE_defaults = 0; } + enum defaultSymbolVisibility { NONE_defaultSymbolVisibility = 0; } enum defaultValue { NONE_defaultValue = 0; } enum dependency { NONE_dependency = 0; } enum deprecated { NONE_deprecated = 0; } + enum deprecatedLegacyJsonFieldConflicts { NONE_deprecatedLegacyJsonFieldConflicts = 0; } + enum deprecationWarning { NONE_deprecationWarning = 0; } enum description { NONE_description = 0; } - enum DescriptorProto { NONE_DescriptorProto = 0; } enum Dictionary { NONE_Dictionary = 0; } enum dictionaryLiteral { NONE_dictionaryLiteral = 0; } enum digit { NONE_digit = 0; } @@ -211,17 +271,23 @@ message GeneratedSwiftReservedEnums { enum digitValue { NONE_digitValue = 0; } enum discardableResult { NONE_discardableResult = 0; } enum discardUnknownFields { NONE_discardUnknownFields = 0; } - enum distance { NONE_distance = 0; } - enum double { NONE_double = 0; } + enum Double { NONE_Double = 0; } enum doubleValue { NONE_doubleValue = 0; } - enum Duration { NONE_Duration = 0; } + enum duration { NONE_duration = 0; } enum E { NONE_E = 0; } + enum edition { NONE_edition = 0; } + enum EditionDefault { NONE_EditionDefault = 0; } + enum editionDefaults { NONE_editionDefaults = 0; } + enum editionDeprecated { NONE_editionDeprecated = 0; } + enum editionIntroduced { NONE_editionIntroduced = 0; } + enum editionRemoved { NONE_editionRemoved = 0; } enum Element { NONE_Element = 0; } enum elements { NONE_elements = 0; } + enum else { NONE_else = 0; } enum emitExtensionFieldName { NONE_emitExtensionFieldName = 0; } enum emitFieldName { NONE_emitFieldName = 0; } enum emitFieldNumber { NONE_emitFieldNumber = 0; } - enum Empty { NONE_Empty = 0; } + enum emptyAnyTypeURL { NONE_emptyAnyTypeURL = 0; } enum emptyData { NONE_emptyData = 0; } enum encodeAsBytes { NONE_encodeAsBytes = 0; } enum encoded { NONE_encoded = 0; } @@ -234,16 +300,14 @@ message GeneratedSwiftReservedEnums { enum endMessageField { NONE_endMessageField = 0; } enum endObject { NONE_endObject = 0; } enum endRegularField { NONE_endRegularField = 0; } + enum enforceNamingStyle { NONE_enforceNamingStyle = 0; } enum enum { NONE_enum = 0; } - enum EnumDescriptorProto { NONE_EnumDescriptorProto = 0; } - enum EnumOptions { NONE_EnumOptions = 0; } enum EnumReservedRange { NONE_EnumReservedRange = 0; } enum enumType { NONE_enumType = 0; } enum enumvalue { NONE_enumvalue = 0; } - enum EnumValueDescriptorProto { NONE_EnumValueDescriptorProto = 0; } - enum EnumValueOptions { NONE_EnumValueOptions = 0; } enum Equatable { NONE_Equatable = 0; } enum Error { NONE_Error = 0; } + enum execute { NONE_execute = 0; } enum ExpressibleByArrayLiteral { NONE_ExpressibleByArrayLiteral = 0; } enum ExpressibleByDictionaryLiteral { NONE_ExpressibleByDictionaryLiteral = 0; } enum ext { NONE_ext = 0; } @@ -258,37 +322,38 @@ message GeneratedSwiftReservedEnums { enum ExtensionFieldValueSet { NONE_ExtensionFieldValueSet = 0; } enum ExtensionMap { NONE_ExtensionMap = 0; } enum extensionRange { NONE_extensionRange = 0; } - enum ExtensionRangeOptions { NONE_ExtensionRangeOptions = 0; } enum extensions { NONE_extensions = 0; } enum extras { NONE_extras = 0; } enum F { NONE_F = 0; } enum false { NONE_false = 0; } + enum features { NONE_features = 0; } + enum FeatureSetEditionDefault { NONE_FeatureSetEditionDefault = 0; } + enum featureSupport { NONE_featureSupport = 0; } enum field { NONE_field = 0; } enum fieldData { NONE_fieldData = 0; } - enum FieldDescriptorProto { NONE_FieldDescriptorProto = 0; } - enum FieldMask { NONE_FieldMask = 0; } + enum FieldMaskError { NONE_FieldMaskError = 0; } enum fieldName { NONE_fieldName = 0; } enum fieldNameCount { NONE_fieldNameCount = 0; } enum fieldNum { NONE_fieldNum = 0; } enum fieldNumber { NONE_fieldNumber = 0; } enum fieldNumberForProto { NONE_fieldNumberForProto = 0; } - enum FieldOptions { NONE_FieldOptions = 0; } + enum fieldPresence { NONE_fieldPresence = 0; } enum fields { NONE_fields = 0; } enum fieldSize { NONE_fieldSize = 0; } enum FieldTag { NONE_FieldTag = 0; } - enum fieldType { NONE_fieldType = 0; } + enum FieldType { NONE_FieldType = 0; } enum file { NONE_file = 0; } - enum FileDescriptorProto { NONE_FileDescriptorProto = 0; } - enum FileDescriptorSet { NONE_FileDescriptorSet = 0; } enum fileName { NONE_fileName = 0; } - enum FileOptions { NONE_FileOptions = 0; } enum filter { NONE_filter = 0; } + enum final { NONE_final = 0; } + enum finiteOnly { NONE_finiteOnly = 0; } enum first { NONE_first = 0; } enum firstItem { NONE_firstItem = 0; } - enum float { NONE_float = 0; } + enum fixedFeatures { NONE_fixedFeatures = 0; } + enum Float { NONE_Float = 0; } enum floatLiteral { NONE_floatLiteral = 0; } enum FloatLiteralType { NONE_FloatLiteralType = 0; } - enum FloatValue { NONE_FloatValue = 0; } + enum for { NONE_for = 0; } enum forMessageName { NONE_forMessageName = 0; } enum formUnion { NONE_formUnion = 0; } enum forReadingFrom { NONE_forReadingFrom = 0; } @@ -300,12 +365,12 @@ message GeneratedSwiftReservedEnums { enum fromAscii4 { NONE_fromAscii4 = 0; } enum fromByteOffset { NONE_fromByteOffset = 0; } enum fromHexDigit { NONE_fromHexDigit = 0; } + enum fullName { NONE_fullName = 0; } enum func { NONE_func = 0; } + enum function { NONE_function = 0; } enum G { NONE_G = 0; } - enum GeneratedCodeInfo { NONE_GeneratedCodeInfo = 0; } enum get { NONE_get = 0; } enum getExtensionValue { NONE_getExtensionValue = 0; } - enum googleapis { NONE_googleapis = 0; } enum Google_Protobuf_Any { NONE_Google_Protobuf_Any = 0; } enum Google_Protobuf_Api { NONE_Google_Protobuf_Api = 0; } enum Google_Protobuf_BoolValue { NONE_Google_Protobuf_BoolValue = 0; } @@ -313,6 +378,7 @@ message GeneratedSwiftReservedEnums { enum Google_Protobuf_DescriptorProto { NONE_Google_Protobuf_DescriptorProto = 0; } enum Google_Protobuf_DoubleValue { NONE_Google_Protobuf_DoubleValue = 0; } enum Google_Protobuf_Duration { NONE_Google_Protobuf_Duration = 0; } + enum Google_Protobuf_Edition { NONE_Google_Protobuf_Edition = 0; } enum Google_Protobuf_Empty { NONE_Google_Protobuf_Empty = 0; } enum Google_Protobuf_Enum { NONE_Google_Protobuf_Enum = 0; } enum Google_Protobuf_EnumDescriptorProto { NONE_Google_Protobuf_EnumDescriptorProto = 0; } @@ -321,6 +387,8 @@ message GeneratedSwiftReservedEnums { enum Google_Protobuf_EnumValueDescriptorProto { NONE_Google_Protobuf_EnumValueDescriptorProto = 0; } enum Google_Protobuf_EnumValueOptions { NONE_Google_Protobuf_EnumValueOptions = 0; } enum Google_Protobuf_ExtensionRangeOptions { NONE_Google_Protobuf_ExtensionRangeOptions = 0; } + enum Google_Protobuf_FeatureSet { NONE_Google_Protobuf_FeatureSet = 0; } + enum Google_Protobuf_FeatureSetDefaults { NONE_Google_Protobuf_FeatureSetDefaults = 0; } enum Google_Protobuf_Field { NONE_Google_Protobuf_Field = 0; } enum Google_Protobuf_FieldDescriptorProto { NONE_Google_Protobuf_FieldDescriptorProto = 0; } enum Google_Protobuf_FieldMask { NONE_Google_Protobuf_FieldMask = 0; } @@ -348,6 +416,7 @@ message GeneratedSwiftReservedEnums { enum Google_Protobuf_SourceContext { NONE_Google_Protobuf_SourceContext = 0; } enum Google_Protobuf_StringValue { NONE_Google_Protobuf_StringValue = 0; } enum Google_Protobuf_Struct { NONE_Google_Protobuf_Struct = 0; } + enum Google_Protobuf_SymbolVisibility { NONE_Google_Protobuf_SymbolVisibility = 0; } enum Google_Protobuf_Syntax { NONE_Google_Protobuf_Syntax = 0; } enum Google_Protobuf_Timestamp { NONE_Google_Protobuf_Timestamp = 0; } enum Google_Protobuf_Type { NONE_Google_Protobuf_Type = 0; } @@ -356,12 +425,14 @@ message GeneratedSwiftReservedEnums { enum Google_Protobuf_UninterpretedOption { NONE_Google_Protobuf_UninterpretedOption = 0; } enum Google_Protobuf_Value { NONE_Google_Protobuf_Value = 0; } enum goPackage { NONE_goPackage = 0; } + enum gotData { NONE_gotData = 0; } enum group { NONE_group = 0; } enum groupFieldNumberStack { NONE_groupFieldNumberStack = 0; } enum groupSize { NONE_groupSize = 0; } - enum h { NONE_h = 0; } + enum guard { NONE_guard = 0; } enum hadOneofValue { NONE_hadOneofValue = 0; } enum handleConflictingOneOf { NONE_handleConflictingOneOf = 0; } + enum handleInstruction { NONE_handleInstruction = 0; } enum hasAggregateValue { NONE_hasAggregateValue = 0; } enum hasAllowAlias { NONE_hasAllowAlias = 0; } enum hasBegin { NONE_hasBegin = 0; } @@ -370,17 +441,33 @@ message GeneratedSwiftReservedEnums { enum hasClientStreaming { NONE_hasClientStreaming = 0; } enum hasCsharpNamespace { NONE_hasCsharpNamespace = 0; } enum hasCtype { NONE_hasCtype = 0; } + enum hasData { NONE_hasData = 0; } + enum hasDebugRedact { NONE_hasDebugRedact = 0; } + enum hasDefaultSymbolVisibility { NONE_hasDefaultSymbolVisibility = 0; } enum hasDefaultValue { NONE_hasDefaultValue = 0; } enum hasDeprecated { NONE_hasDeprecated = 0; } + enum hasDeprecatedLegacyJsonFieldConflicts { NONE_hasDeprecatedLegacyJsonFieldConflicts = 0; } + enum hasDeprecationWarning { NONE_hasDeprecationWarning = 0; } enum hasDoubleValue { NONE_hasDoubleValue = 0; } + enum hasEdition { NONE_hasEdition = 0; } + enum hasEditionDeprecated { NONE_hasEditionDeprecated = 0; } + enum hasEditionIntroduced { NONE_hasEditionIntroduced = 0; } + enum hasEditionRemoved { NONE_hasEditionRemoved = 0; } enum hasEnd { NONE_hasEnd = 0; } + enum hasEnforceNamingStyle { NONE_hasEnforceNamingStyle = 0; } + enum hasEnumType { NONE_hasEnumType = 0; } + enum hasExplicitDelta { NONE_hasExplicitDelta = 0; } enum hasExtendee { NONE_hasExtendee = 0; } enum hasExtensionValue { NONE_hasExtensionValue = 0; } + enum hasFeatures { NONE_hasFeatures = 0; } + enum hasFeatureSupport { NONE_hasFeatureSupport = 0; } + enum hasFieldPresence { NONE_hasFieldPresence = 0; } + enum hasFixedFeatures { NONE_hasFixedFeatures = 0; } + enum hasFullName { NONE_hasFullName = 0; } enum hasGoPackage { NONE_hasGoPackage = 0; } enum hash { NONE_hash = 0; } enum Hashable { NONE_Hashable = 0; } enum hasher { NONE_hasher = 0; } - enum hashValue { NONE_hashValue = 0; } enum HashVisitor { NONE_HashVisitor = 0; } enum hasIdempotencyLevel { NONE_hasIdempotencyLevel = 0; } enum hasIdentifierValue { NONE_hasIdentifierValue = 0; } @@ -392,13 +479,17 @@ message GeneratedSwiftReservedEnums { enum hasJavaOuterClassname { NONE_hasJavaOuterClassname = 0; } enum hasJavaPackage { NONE_hasJavaPackage = 0; } enum hasJavaStringCheckUtf8 { NONE_hasJavaStringCheckUtf8 = 0; } + enum hasJsonFormat { NONE_hasJsonFormat = 0; } enum hasJsonName { NONE_hasJsonName = 0; } enum hasJstype { NONE_hasJstype = 0; } enum hasLabel { NONE_hasLabel = 0; } enum hasLazy { NONE_hasLazy = 0; } enum hasLeadingComments { NONE_hasLeadingComments = 0; } enum hasMapEntry { NONE_hasMapEntry = 0; } + enum hasMaximumEdition { NONE_hasMaximumEdition = 0; } + enum hasMessageEncoding { NONE_hasMessageEncoding = 0; } enum hasMessageSetWireFormat { NONE_hasMessageSetWireFormat = 0; } + enum hasMinimumEdition { NONE_hasMinimumEdition = 0; } enum hasName { NONE_hasName = 0; } enum hasNamePart { NONE_hasNamePart = 0; } enum hasNegativeIntValue { NONE_hasNegativeIntValue = 0; } @@ -409,16 +500,22 @@ message GeneratedSwiftReservedEnums { enum hasOptimizeFor { NONE_hasOptimizeFor = 0; } enum hasOptions { NONE_hasOptions = 0; } enum hasOutputType { NONE_hasOutputType = 0; } + enum hasOverridableFeatures { NONE_hasOverridableFeatures = 0; } enum hasPackage { NONE_hasPackage = 0; } enum hasPacked { NONE_hasPacked = 0; } enum hasPhpClassPrefix { NONE_hasPhpClassPrefix = 0; } - enum hasPhpGenericServices { NONE_hasPhpGenericServices = 0; } enum hasPhpMetadataNamespace { NONE_hasPhpMetadataNamespace = 0; } enum hasPhpNamespace { NONE_hasPhpNamespace = 0; } enum hasPositiveIntValue { NONE_hasPositiveIntValue = 0; } enum hasProto3Optional { NONE_hasProto3Optional = 0; } enum hasPyGenericServices { NONE_hasPyGenericServices = 0; } + enum hasRemovalError { NONE_hasRemovalError = 0; } + enum hasRepeated { NONE_hasRepeated = 0; } + enum hasRepeatedFieldEncoding { NONE_hasRepeatedFieldEncoding = 0; } + enum hasReserved { NONE_hasReserved = 0; } + enum hasRetention { NONE_hasRetention = 0; } enum hasRubyPackage { NONE_hasRubyPackage = 0; } + enum hasSemantic { NONE_hasSemantic = 0; } enum hasServerStreaming { NONE_hasServerStreaming = 0; } enum hasSourceCodeInfo { NONE_hasSourceCodeInfo = 0; } enum hasSourceContext { NONE_hasSourceContext = 0; } @@ -430,40 +527,49 @@ message GeneratedSwiftReservedEnums { enum hasTrailingComments { NONE_hasTrailingComments = 0; } enum hasType { NONE_hasType = 0; } enum hasTypeName { NONE_hasTypeName = 0; } + enum hasUnverifiedLazy { NONE_hasUnverifiedLazy = 0; } + enum hasUtf8Validation { NONE_hasUtf8Validation = 0; } enum hasValue { NONE_hasValue = 0; } + enum hasVerification { NONE_hasVerification = 0; } + enum hasVisibility { NONE_hasVisibility = 0; } enum hasWeak { NONE_hasWeak = 0; } enum hour { NONE_hour = 0; } enum i { NONE_i = 0; } enum idempotencyLevel { NONE_idempotencyLevel = 0; } enum identifierValue { NONE_identifierValue = 0; } enum if { NONE_if = 0; } + enum ignoreUnknownExtensionFields { NONE_ignoreUnknownExtensionFields = 0; } enum ignoreUnknownFields { NONE_ignoreUnknownFields = 0; } enum index { NONE_index = 0; } enum init { NONE_init = 0; } enum inout { NONE_inout = 0; } enum inputType { NONE_inputType = 0; } enum insert { NONE_insert = 0; } + enum Instruction { NONE_Instruction = 0; } enum Int { NONE_Int = 0; } enum Int32 { NONE_Int32 = 0; } - enum Int32Value { NONE_Int32Value = 0; } enum Int64 { NONE_Int64 = 0; } - enum Int64Value { NONE_Int64Value = 0; } enum Int8 { NONE_Int8 = 0; } enum integerLiteral { NONE_integerLiteral = 0; } enum IntegerLiteralType { NONE_IntegerLiteralType = 0; } enum intern { NONE_intern = 0; } enum Internal { NONE_Internal = 0; } enum InternalState { NONE_InternalState = 0; } + enum intersect { NONE_intersect = 0; } enum into { NONE_into = 0; } enum ints { NONE_ints = 0; } + enum invalidAnyTypeURL { NONE_invalidAnyTypeURL = 0; } enum isA { NONE_isA = 0; } enum isEqual { NONE_isEqual = 0; } enum isEqualTo { NONE_isEqualTo = 0; } enum isExtension { NONE_isExtension = 0; } enum isInitialized { NONE_isInitialized = 0; } + enum isNegative { NONE_isNegative = 0; } + enum isPathValid { NONE_isPathValid = 0; } + enum isReserved { NONE_isReserved = 0; } + enum isValid { NONE_isValid = 0; } enum itemTagsEncodedSize { NONE_itemTagsEncodedSize = 0; } - enum Iterator { NONE_Iterator = 0; } - enum i_2166136261 { NONE_i_2166136261 = 0; } + enum iterator { NONE_iterator = 0; } enum javaGenerateEqualsAndHash { NONE_javaGenerateEqualsAndHash = 0; } enum javaGenericServices { NONE_javaGenericServices = 0; } enum javaMultipleFiles { NONE_javaMultipleFiles = 0; } @@ -471,12 +577,15 @@ message GeneratedSwiftReservedEnums { enum javaPackage { NONE_javaPackage = 0; } enum javaStringCheckUtf8 { NONE_javaStringCheckUtf8 = 0; } enum JSONDecoder { NONE_JSONDecoder = 0; } + enum JSONDecoding { NONE_JSONDecoding = 0; } enum JSONDecodingError { NONE_JSONDecodingError = 0; } enum JSONDecodingOptions { NONE_JSONDecodingOptions = 0; } enum jsonEncoder { NONE_jsonEncoder = 0; } + enum JSONEncoding { NONE_JSONEncoding = 0; } enum JSONEncodingError { NONE_JSONEncodingError = 0; } enum JSONEncodingOptions { NONE_JSONEncodingOptions = 0; } enum JSONEncodingVisitor { NONE_JSONEncodingVisitor = 0; } + enum jsonFormat { NONE_jsonFormat = 0; } enum JSONMapEncodingVisitor { NONE_JSONMapEncodingVisitor = 0; } enum jsonName { NONE_jsonName = 0; } enum jsonPath { NONE_jsonPath = 0; } @@ -484,11 +593,14 @@ message GeneratedSwiftReservedEnums { enum JSONScanner { NONE_JSONScanner = 0; } enum jsonString { NONE_jsonString = 0; } enum jsonText { NONE_jsonText = 0; } + enum jsonUTF8Bytes { NONE_jsonUTF8Bytes = 0; } enum jsonUTF8Data { NONE_jsonUTF8Data = 0; } enum jstype { NONE_jstype = 0; } enum k { NONE_k = 0; } + enum kChunkSize { NONE_kChunkSize = 0; } enum Key { NONE_Key = 0; } enum keyField { NONE_keyField = 0; } + enum keyFieldOpt { NONE_keyFieldOpt = 0; } enum KeyType { NONE_KeyType = 0; } enum kind { NONE_kind = 0; } enum l { NONE_l = 0; } @@ -500,42 +612,44 @@ message GeneratedSwiftReservedEnums { enum lessThan { NONE_lessThan = 0; } enum let { NONE_let = 0; } enum lhs { NONE_lhs = 0; } + enum line { NONE_line = 0; } enum list { NONE_list = 0; } enum listOfMessages { NONE_listOfMessages = 0; } enum listValue { NONE_listValue = 0; } enum littleEndian { NONE_littleEndian = 0; } - enum littleEndianBytes { NONE_littleEndianBytes = 0; } enum load { NONE_load = 0; } enum localHasher { NONE_localHasher = 0; } enum location { NONE_location = 0; } enum M { NONE_M = 0; } enum major { NONE_major = 0; } + enum makeAsyncIterator { NONE_makeAsyncIterator = 0; } enum makeIterator { NONE_makeIterator = 0; } + enum malformedLength { NONE_malformedLength = 0; } enum mapEntry { NONE_mapEntry = 0; } - enum mapHash { NONE_mapHash = 0; } enum MapKeyType { NONE_MapKeyType = 0; } - enum mapNameResolver { NONE_mapNameResolver = 0; } enum mapToMessages { NONE_mapToMessages = 0; } enum MapValueType { NONE_MapValueType = 0; } enum mapVisitor { NONE_mapVisitor = 0; } + enum mask { NONE_mask = 0; } + enum maximumEdition { NONE_maximumEdition = 0; } enum mdayStart { NONE_mdayStart = 0; } enum merge { NONE_merge = 0; } + enum MergeOptions { NONE_MergeOptions = 0; } enum message { NONE_message = 0; } enum messageDepthLimit { NONE_messageDepthLimit = 0; } + enum messageEncoding { NONE_messageEncoding = 0; } enum MessageExtension { NONE_MessageExtension = 0; } enum MessageImplementationBase { NONE_MessageImplementationBase = 0; } - enum MessageOptions { NONE_MessageOptions = 0; } enum MessageSet { NONE_MessageSet = 0; } enum messageSetWireFormat { NONE_messageSetWireFormat = 0; } + enum messageSize { NONE_messageSize = 0; } enum messageType { NONE_messageType = 0; } - enum Method { NONE_Method = 0; } - enum MethodDescriptorProto { NONE_MethodDescriptorProto = 0; } - enum MethodOptions { NONE_MethodOptions = 0; } + enum method { NONE_method = 0; } enum methods { NONE_methods = 0; } + enum min { NONE_min = 0; } + enum minimumEdition { NONE_minimumEdition = 0; } enum minor { NONE_minor = 0; } - enum Mixin { NONE_Mixin = 0; } enum mixins { NONE_mixins = 0; } - enum modifier { NONE_modifier = 0; } enum modify { NONE_modify = 0; } enum month { NONE_month = 0; } enum msgExtension { NONE_msgExtension = 0; } @@ -545,44 +659,53 @@ message GeneratedSwiftReservedEnums { enum NameDescription { NONE_NameDescription = 0; } enum NameMap { NONE_NameMap = 0; } enum NamePart { NONE_NamePart = 0; } - enum nameResolver { NONE_nameResolver = 0; } enum names { NONE_names = 0; } enum nanos { NONE_nanos = 0; } - enum nativeBytes { NONE_nativeBytes = 0; } - enum nativeEndianBytes { NONE_nativeEndianBytes = 0; } enum negativeIntValue { NONE_negativeIntValue = 0; } enum nestedType { NONE_nestedType = 0; } + enum newExtensible { NONE_newExtensible = 0; } enum newL { NONE_newL = 0; } enum newList { NONE_newList = 0; } + enum newMessage { NONE_newMessage = 0; } enum newValue { NONE_newValue = 0; } + enum next { NONE_next = 0; } enum nextByte { NONE_nextByte = 0; } enum nextFieldNumber { NONE_nextFieldNumber = 0; } + enum nextInstruction { NONE_nextInstruction = 0; } + enum nextInt32 { NONE_nextInt32 = 0; } + enum nextNullTerminatedString { NONE_nextNullTerminatedString = 0; } + enum nextNullTerminatedStringArray { NONE_nextNullTerminatedStringArray = 0; } + enum nextNumber { NONE_nextNumber = 0; } + enum nextUInt64 { NONE_nextUInt64 = 0; } + enum nextVarInt { NONE_nextVarInt = 0; } enum nil { NONE_nil = 0; } enum nilLiteral { NONE_nilLiteral = 0; } + enum noBytesAvailable { NONE_noBytesAvailable = 0; } enum noStandardDescriptorAccessor { NONE_noStandardDescriptorAccessor = 0; } enum nullValue { NONE_nullValue = 0; } enum number { NONE_number = 0; } enum numberValue { NONE_numberValue = 0; } enum objcClassPrefix { NONE_objcClassPrefix = 0; } enum of { NONE_of = 0; } + enum OneOf_Kind { NONE_OneOf_Kind = 0; } enum oneofDecl { NONE_oneofDecl = 0; } - enum OneofDescriptorProto { NONE_OneofDescriptorProto = 0; } enum oneofIndex { NONE_oneofIndex = 0; } - enum OneofOptions { NONE_OneofOptions = 0; } enum oneofs { NONE_oneofs = 0; } - enum OneOf_Kind { NONE_OneOf_Kind = 0; } enum optimizeFor { NONE_optimizeFor = 0; } enum OptimizeMode { NONE_OptimizeMode = 0; } - enum Option { NONE_Option = 0; } enum OptionalEnumExtensionField { NONE_OptionalEnumExtensionField = 0; } enum OptionalExtensionField { NONE_OptionalExtensionField = 0; } enum OptionalGroupExtensionField { NONE_OptionalGroupExtensionField = 0; } enum OptionalMessageExtensionField { NONE_OptionalMessageExtensionField = 0; } + enum optionDependency { NONE_optionDependency = 0; } + enum OptionRetention { NONE_OptionRetention = 0; } enum options { NONE_options = 0; } + enum OptionTargetType { NONE_OptionTargetType = 0; } enum other { NONE_other = 0; } enum others { NONE_others = 0; } enum out { NONE_out = 0; } enum outputType { NONE_outputType = 0; } + enum overridableFeatures { NONE_overridableFeatures = 0; } enum p { NONE_p = 0; } enum package { NONE_package = 0; } enum packed { NONE_packed = 0; } @@ -593,27 +716,39 @@ message GeneratedSwiftReservedEnums { enum parse { NONE_parse = 0; } enum partial { NONE_partial = 0; } enum path { NONE_path = 0; } + enum PathDecoder { NONE_PathDecoder = 0; } + enum PathDecodingError { NONE_PathDecodingError = 0; } enum paths { NONE_paths = 0; } + enum PathVisitor { NONE_PathVisitor = 0; } enum payload { NONE_payload = 0; } enum payloadSize { NONE_payloadSize = 0; } enum phpClassPrefix { NONE_phpClassPrefix = 0; } - enum phpGenericServices { NONE_phpGenericServices = 0; } enum phpMetadataNamespace { NONE_phpMetadataNamespace = 0; } enum phpNamespace { NONE_phpNamespace = 0; } - enum pointer { NONE_pointer = 0; } enum pos { NONE_pos = 0; } enum positiveIntValue { NONE_positiveIntValue = 0; } enum prefix { NONE_prefix = 0; } enum preserveProtoFieldNames { NONE_preserveProtoFieldNames = 0; } enum preTraverse { NONE_preTraverse = 0; } + enum previousNumber { NONE_previousNumber = 0; } + enum prevPath { NONE_prevPath = 0; } enum printUnknownFields { NONE_printUnknownFields = 0; } + enum programBuffer { NONE_programBuffer = 0; } + enum programFormat { NONE_programFormat = 0; } enum proto2 { NONE_proto2 = 0; } enum proto3DefaultValue { NONE_proto3DefaultValue = 0; } enum proto3Optional { NONE_proto3Optional = 0; } - enum ProtobufAPIVersionCheck { NONE_ProtobufAPIVersionCheck = 0; } + enum protobuf_extensionFieldValues { NONE_protobuf_extensionFieldValues = 0; } + enum protobuf_fieldNumber { NONE_protobuf_fieldNumber = 0; } + enum protobuf_generated_isEqualTo { NONE_protobuf_generated_isEqualTo = 0; } + enum protobuf_nameMap { NONE_protobuf_nameMap = 0; } + enum protobuf_newField { NONE_protobuf_newField = 0; } + enum protobuf_package { NONE_protobuf_package = 0; } enum ProtobufAPIVersion_2 { NONE_ProtobufAPIVersion_2 = 0; } + enum ProtobufAPIVersionCheck { NONE_ProtobufAPIVersionCheck = 0; } enum ProtobufBool { NONE_ProtobufBool = 0; } enum ProtobufBytes { NONE_ProtobufBytes = 0; } + enum protobufData { NONE_protobufData = 0; } enum ProtobufDouble { NONE_ProtobufDouble = 0; } enum ProtobufEnumMap { NONE_ProtobufEnumMap = 0; } enum protobufExtension { NONE_protobufExtension = 0; } @@ -631,12 +766,6 @@ message GeneratedSwiftReservedEnums { enum ProtobufString { NONE_ProtobufString = 0; } enum ProtobufUInt32 { NONE_ProtobufUInt32 = 0; } enum ProtobufUInt64 { NONE_ProtobufUInt64 = 0; } - enum protobuf_extensionFieldValues { NONE_protobuf_extensionFieldValues = 0; } - enum protobuf_fieldNumber { NONE_protobuf_fieldNumber = 0; } - enum protobuf_generated_isEqualTo { NONE_protobuf_generated_isEqualTo = 0; } - enum protobuf_nameMap { NONE_protobuf_nameMap = 0; } - enum protobuf_newField { NONE_protobuf_newField = 0; } - enum protobuf_package { NONE_protobuf_package = 0; } enum protocol { NONE_protocol = 0; } enum protoFieldName { NONE_protoFieldName = 0; } enum protoMessageName { NONE_protoMessageName = 0; } @@ -658,25 +787,33 @@ message GeneratedSwiftReservedEnums { enum putVarInt { NONE_putVarInt = 0; } enum putZigZagVarInt { NONE_putZigZagVarInt = 0; } enum pyGenericServices { NONE_pyGenericServices = 0; } + enum R { NONE_R = 0; } enum rawChars { NONE_rawChars = 0; } enum RawRepresentable { NONE_RawRepresentable = 0; } enum RawValue { NONE_RawValue = 0; } enum read4HexDigits { NONE_read4HexDigits = 0; } + enum readBytes { NONE_readBytes = 0; } + enum reader { NONE_reader = 0; } enum register { NONE_register = 0; } + enum remainingProgram { NONE_remainingProgram = 0; } + enum removalError { NONE_removalError = 0; } + enum removingAllFieldsOf { NONE_removingAllFieldsOf = 0; } + enum repeated { NONE_repeated = 0; } enum RepeatedEnumExtensionField { NONE_RepeatedEnumExtensionField = 0; } enum RepeatedExtensionField { NONE_RepeatedExtensionField = 0; } + enum repeatedFieldEncoding { NONE_repeatedFieldEncoding = 0; } enum RepeatedGroupExtensionField { NONE_RepeatedGroupExtensionField = 0; } enum RepeatedMessageExtensionField { NONE_RepeatedMessageExtensionField = 0; } + enum repeating { NONE_repeating = 0; } + enum replaceRepeatedFields { NONE_replaceRepeatedFields = 0; } enum requestStreaming { NONE_requestStreaming = 0; } enum requestTypeURL { NONE_requestTypeURL = 0; } enum requiredSize { NONE_requiredSize = 0; } - enum reservedName { NONE_reservedName = 0; } - enum reservedRange { NONE_reservedRange = 0; } enum responseStreaming { NONE_responseStreaming = 0; } enum responseTypeURL { NONE_responseTypeURL = 0; } enum result { NONE_result = 0; } + enum retention { NONE_retention = 0; } enum rethrows { NONE_rethrows = 0; } - enum return { NONE_return = 0; } enum ReturnType { NONE_ReturnType = 0; } enum revision { NONE_revision = 0; } enum rhs { NONE_rhs = 0; } @@ -686,27 +823,32 @@ message GeneratedSwiftReservedEnums { enum sawBackslash { NONE_sawBackslash = 0; } enum sawSection4Characters { NONE_sawSection4Characters = 0; } enum sawSection5Characters { NONE_sawSection5Characters = 0; } + enum Scalar { NONE_Scalar = 0; } + enum scan { NONE_scan = 0; } enum scanner { NONE_scanner = 0; } enum seconds { NONE_seconds = 0; } enum self { NONE_self = 0; } + enum semantic { NONE_semantic = 0; } + enum Sendable { NONE_Sendable = 0; } enum separator { NONE_separator = 0; } enum serialize { NONE_serialize = 0; } + enum serializedBytes { NONE_serializedBytes = 0; } enum serializedData { NONE_serializedData = 0; } enum serializedSize { NONE_serializedSize = 0; } enum serverStreaming { NONE_serverStreaming = 0; } enum service { NONE_service = 0; } - enum ServiceDescriptorProto { NONE_ServiceDescriptorProto = 0; } - enum ServiceOptions { NONE_ServiceOptions = 0; } enum set { NONE_set = 0; } enum setExtensionValue { NONE_setExtensionValue = 0; } enum shift { NONE_shift = 0; } enum SimpleExtensionMap { NONE_SimpleExtensionMap = 0; } + enum size { NONE_size = 0; } enum sizer { NONE_sizer = 0; } enum source { NONE_source = 0; } enum sourceCodeInfo { NONE_sourceCodeInfo = 0; } enum sourceContext { NONE_sourceContext = 0; } enum sourceEncoding { NONE_sourceEncoding = 0; } enum sourceFile { NONE_sourceFile = 0; } + enum SourceLocation { NONE_SourceLocation = 0; } enum span { NONE_span = 0; } enum split { NONE_split = 0; } enum start { NONE_start = 0; } @@ -730,13 +872,16 @@ message GeneratedSwiftReservedEnums { enum structValue { NONE_structValue = 0; } enum subDecoder { NONE_subDecoder = 0; } enum subscript { NONE_subscript = 0; } + enum subtract { NONE_subtract = 0; } enum subVisitor { NONE_subVisitor = 0; } enum Swift { NONE_Swift = 0; } enum swiftPrefix { NONE_swiftPrefix = 0; } - enum SwiftProtobuf { NONE_SwiftProtobuf = 0; } + enum SwiftProtobufContiguousBytes { NONE_SwiftProtobufContiguousBytes = 0; } + enum SwiftProtobufError { NONE_SwiftProtobufError = 0; } enum syntax { NONE_syntax = 0; } enum T { NONE_T = 0; } enum tag { NONE_tag = 0; } + enum targets { NONE_targets = 0; } enum terminator { NONE_terminator = 0; } enum testDecoder { NONE_testDecoder = 0; } enum text { NONE_text = 0; } @@ -747,16 +892,19 @@ message GeneratedSwiftReservedEnums { enum TextFormatEncodingOptions { NONE_TextFormatEncodingOptions = 0; } enum TextFormatEncodingVisitor { NONE_TextFormatEncodingVisitor = 0; } enum textFormatString { NONE_textFormatString = 0; } + enum throwOrIgnore { NONE_throwOrIgnore = 0; } enum throws { NONE_throws = 0; } enum timeInterval { NONE_timeInterval = 0; } enum timeIntervalSince1970 { NONE_timeIntervalSince1970 = 0; } enum timeIntervalSinceReferenceDate { NONE_timeIntervalSinceReferenceDate = 0; } - enum Timestamp { NONE_Timestamp = 0; } + enum tmp { NONE_tmp = 0; } + enum tooLarge { NONE_tooLarge = 0; } enum total { NONE_total = 0; } enum totalArrayDepth { NONE_totalArrayDepth = 0; } enum totalSize { NONE_totalSize = 0; } enum trailingComments { NONE_trailingComments = 0; } enum traverse { NONE_traverse = 0; } + enum trim { NONE_trim = 0; } enum true { NONE_true = 0; } enum try { NONE_try = 0; } enum type { NONE_type = 0; } @@ -768,10 +916,10 @@ message GeneratedSwiftReservedEnums { enum typeUnknown { NONE_typeUnknown = 0; } enum typeURL { NONE_typeURL = 0; } enum UInt32 { NONE_UInt32 = 0; } - enum UInt32Value { NONE_UInt32Value = 0; } enum UInt64 { NONE_UInt64 = 0; } - enum UInt64Value { NONE_UInt64Value = 0; } enum UInt8 { NONE_UInt8 = 0; } + enum unchecked { NONE_unchecked = 0; } + enum Unicode { NONE_Unicode = 0; } enum unicodeScalarLiteral { NONE_unicodeScalarLiteral = 0; } enum UnicodeScalarLiteralType { NONE_UnicodeScalarLiteralType = 0; } enum unicodeScalars { NONE_unicodeScalars = 0; } @@ -786,27 +934,34 @@ message GeneratedSwiftReservedEnums { enum UnsafeBufferPointer { NONE_UnsafeBufferPointer = 0; } enum UnsafeMutablePointer { NONE_UnsafeMutablePointer = 0; } enum UnsafeMutableRawBufferPointer { NONE_UnsafeMutableRawBufferPointer = 0; } - enum UnsafeMutableRawPointer { NONE_UnsafeMutableRawPointer = 0; } enum UnsafeRawBufferPointer { NONE_UnsafeRawBufferPointer = 0; } enum UnsafeRawPointer { NONE_UnsafeRawPointer = 0; } + enum unverifiedLazy { NONE_unverifiedLazy = 0; } enum updatedOptions { NONE_updatedOptions = 0; } + enum uppercasedAssumingASCII { NONE_uppercasedAssumingASCII = 0; } enum url { NONE_url = 0; } + enum useDeterministicOrdering { NONE_useDeterministicOrdering = 0; } enum utf8 { NONE_utf8 = 0; } enum utf8Ptr { NONE_utf8Ptr = 0; } enum utf8ToDouble { NONE_utf8ToDouble = 0; } + enum utf8Validation { NONE_utf8Validation = 0; } enum UTF8View { NONE_UTF8View = 0; } - enum v { NONE_v = 0; } + enum V { NONE_V = 0; } enum value { NONE_value = 0; } enum valueField { NONE_valueField = 0; } enum values { NONE_values = 0; } enum ValueType { NONE_ValueType = 0; } enum var { NONE_var = 0; } - enum Version { NONE_Version = 0; } + enum verification { NONE_verification = 0; } + enum VerificationState { NONE_VerificationState = 0; } + enum version { NONE_version = 0; } enum versionString { NONE_versionString = 0; } + enum visibility { NONE_visibility = 0; } + enum VisibilityFeature { NONE_VisibilityFeature = 0; } enum visitExtensionFields { NONE_visitExtensionFields = 0; } enum visitExtensionFieldsAsMessageSet { NONE_visitExtensionFieldsAsMessageSet = 0; } enum visitMapField { NONE_visitMapField = 0; } - enum visitor { NONE_visitor = 0; } + enum Visitor { NONE_Visitor = 0; } enum visitPacked { NONE_visitPacked = 0; } enum visitPackedBoolField { NONE_visitPackedBoolField = 0; } enum visitPackedDoubleField { NONE_visitPackedDoubleField = 0; } @@ -861,6 +1016,7 @@ message GeneratedSwiftReservedEnums { enum visitSingularUInt32Field { NONE_visitSingularUInt32Field = 0; } enum visitSingularUInt64Field { NONE_visitSingularUInt64Field = 0; } enum visitUnknown { NONE_visitUnknown = 0; } + enum Void { NONE_Void = 0; } enum wasDecoded { NONE_wasDecoded = 0; } enum weak { NONE_weak = 0; } enum weakDependency { NONE_weakDependency = 0; } @@ -870,7 +1026,9 @@ message GeneratedSwiftReservedEnums { enum withUnsafeBytes { NONE_withUnsafeBytes = 0; } enum withUnsafeMutableBytes { NONE_withUnsafeMutableBytes = 0; } enum work { NONE_work = 0; } + enum Wrapped { NONE_Wrapped = 0; } enum WrappedType { NONE_WrappedType = 0; } + enum wrappedValue { NONE_wrappedValue = 0; } enum written { NONE_written = 0; } enum yday { NONE_yday = 0; } } diff --git a/Protos/Tests/SwiftProtobufTests/generated_swift_names_fields.proto b/Protos/Tests/SwiftProtobufTests/generated_swift_names_fields.proto new file mode 100644 index 000000000..a08012821 --- /dev/null +++ b/Protos/Tests/SwiftProtobufTests/generated_swift_names_fields.proto @@ -0,0 +1,1034 @@ +// See Makefile for the logic that generates this +// Protoc errors imply this file is being generated incorrectly +// Swift compile errors are probably bugs in protoc-gen-swift +syntax = "proto3"; +package swift_proto_testing.generated; +message GeneratedSwiftReservedFields { + int32 addPath = 1; + int32 adjusted = 2; + int32 aggregateValue = 3; + int32 allCases = 4; + int32 allowAlias = 5; + int32 alwaysPrintEnumsAsInts = 6; + int32 alwaysPrintInt64sAsNumbers = 7; + int32 annotation = 8; + int32 any = 9; + int32 AnyExtensionField = 10; + int32 AnyMessageExtension = 11; + int32 AnyMessageStorage = 12; + int32 AnyUnpackError = 13; + int32 append = 14; + int32 appended = 15; + int32 appendUIntHex = 16; + int32 appendUnknown = 17; + int32 areAllInitialized = 18; + int32 Array = 19; + int32 arrayDepth = 20; + int32 arrayLiteral = 21; + int32 arraySeparator = 22; + int32 as = 23; + int32 asciiOpenCurlyBracket = 24; + int32 asciiZero = 25; + int32 async = 26; + int32 AsyncIterator = 27; + int32 AsyncIteratorProtocol = 28; + int32 AsyncMessageSequence = 29; + int32 available = 30; + int32 b = 31; + int32 Base = 32; + int32 base64Values = 33; + int32 baseAddress = 34; + int32 BaseType = 35; + int32 begin = 36; + int32 binary = 37; + int32 BinaryDecoder = 38; + int32 BinaryDecoding = 39; + int32 BinaryDecodingError = 40; + int32 BinaryDecodingOptions = 41; + int32 BinaryDelimited = 42; + int32 BinaryEncoder = 43; + int32 BinaryEncodingError = 44; + int32 BinaryEncodingMessageSetSizeVisitor = 45; + int32 BinaryEncodingMessageSetVisitor = 46; + int32 BinaryEncodingOptions = 47; + int32 BinaryEncodingSizeVisitor = 48; + int32 BinaryEncodingVisitor = 49; + int32 binaryOptions = 50; + int32 binaryProtobufDelimitedMessages = 51; + int32 BinaryStreamDecoding = 52; + int32 binaryStreamDecodingError = 53; + int32 bitPattern = 54; + int32 body = 55; + int32 Bool = 56; + int32 booleanLiteral = 57; + int32 BooleanLiteralType = 58; + int32 boolValue = 59; + int32 buffer = 60; + int32 byte = 61; + int32 bytecode = 62; + int32 BytecodeReader = 63; + int32 bytes = 64; + int32 bytesInGroup = 65; + int32 bytesNeeded = 66; + int32 bytesRead = 67; + int32 c = 68; + int32 canonical = 69; + int32 capitalizeNext = 70; + int32 cardinality = 71; + int32 CaseIterable = 72; + int32 castedValue = 73; + int32 ccEnableArenas = 74; + int32 ccGenericServices = 75; + int32 Character = 76; + int32 chars = 77; + int32 checkProgramFormat = 78; + int32 chunk = 79; + int32 class = 80; + int32 clearAggregateValue = 81; + int32 clearAllowAlias = 82; + int32 clearBegin = 83; + int32 clearCcEnableArenas = 84; + int32 clearCcGenericServices = 85; + int32 clearClientStreaming = 86; + int32 clearCsharpNamespace = 87; + int32 clearCtype = 88; + int32 clearDebugRedact = 89; + int32 clearDefaultSymbolVisibility = 90; + int32 clearDefaultValue = 91; + int32 clearDeprecated = 92; + int32 clearDeprecatedLegacyJsonFieldConflicts = 93; + int32 clearDeprecationWarning = 94; + int32 clearDoubleValue = 95; + int32 clearEdition = 96; + int32 clearEditionDeprecated = 97; + int32 clearEditionIntroduced = 98; + int32 clearEditionRemoved = 99; + int32 clearEnd = 100; + int32 clearEnforceNamingStyle = 101; + int32 clearEnumType = 102; + int32 clearExtendee = 103; + int32 clearExtensionValue = 104; + int32 clearFeatures = 105; + int32 clearFeatureSupport = 106; + int32 clearFieldPresence = 107; + int32 clearFixedFeatures = 108; + int32 clearFullName = 109; + int32 clearGoPackage = 110; + int32 clearIdempotencyLevel = 111; + int32 clearIdentifierValue = 112; + int32 clearInputType = 113; + int32 clearIsExtension = 114; + int32 clearJavaGenerateEqualsAndHash = 115; + int32 clearJavaGenericServices = 116; + int32 clearJavaMultipleFiles = 117; + int32 clearJavaOuterClassname = 118; + int32 clearJavaPackage = 119; + int32 clearJavaStringCheckUtf8 = 120; + int32 clearJsonFormat = 121; + int32 clearJsonName = 122; + int32 clearJstype = 123; + int32 clearLabel = 124; + int32 clearLazy = 125; + int32 clearLeadingComments = 126; + int32 clearMapEntry = 127; + int32 clearMaximumEdition = 128; + int32 clearMessageEncoding = 129; + int32 clearMessageSetWireFormat = 130; + int32 clearMinimumEdition = 131; + int32 clearName = 132; + int32 clearNamePart = 133; + int32 clearNegativeIntValue = 134; + int32 clearNoStandardDescriptorAccessor = 135; + int32 clearNumber = 136; + int32 clearObjcClassPrefix = 137; + int32 clearOneofIndex = 138; + int32 clearOptimizeFor = 139; + int32 clearOptions = 140; + int32 clearOutputType = 141; + int32 clearOverridableFeatures = 142; + int32 clearPackage = 143; + int32 clearPacked = 144; + int32 clearPhpClassPrefix = 145; + int32 clearPhpMetadataNamespace = 146; + int32 clearPhpNamespace = 147; + int32 clearPositiveIntValue = 148; + int32 clearProto3Optional = 149; + int32 clearPyGenericServices = 150; + int32 clearRemovalError = 151; + int32 clearRepeated = 152; + int32 clearRepeatedFieldEncoding = 153; + int32 clearReserved = 154; + int32 clearRetention = 155; + int32 clearRubyPackage = 156; + int32 clearSemantic = 157; + int32 clearServerStreaming = 158; + int32 clearSourceCodeInfo = 159; + int32 clearSourceContext = 160; + int32 clearSourceFile = 161; + int32 clearStart = 162; + int32 clearStringValue = 163; + int32 clearSwiftPrefix = 164; + int32 clearSyntax = 165; + int32 clearTrailingComments = 166; + int32 clearType = 167; + int32 clearTypeName = 168; + int32 clearUnverifiedLazy = 169; + int32 clearUtf8Validation = 170; + int32 clearValue = 171; + int32 clearVerification = 172; + int32 clearVisibility = 173; + int32 clearWeak = 174; + int32 clientStreaming = 175; + int32 code = 176; + int32 codePoint = 177; + int32 codeUnits = 178; + int32 Collection = 179; + int32 comma = 180; + int32 consumedBytes = 181; + int32 contains = 182; + int32 contentsOf = 183; + int32 ContiguousBytes = 184; + int32 copy = 185; + int32 count = 186; + int32 countVarintsInBuffer = 187; + int32 csharpNamespace = 188; + int32 ctype = 189; + int32 customCodable = 190; + int32 CustomDebugStringConvertible = 191; + int32 CustomStringConvertible = 192; + int32 D = 193; + int32 Data = 194; + int32 dataResult = 195; + int32 date = 196; + int32 daySec = 197; + int32 daysSinceEpoch = 198; + int32 debugDescription = 199; + int32 debugRedact = 200; + int32 declaration = 201; + int32 decoded = 202; + int32 decodedFromJSONNull = 203; + int32 decodeExtensionField = 204; + int32 decodeExtensionFieldsAsMessageSet = 205; + int32 decodeJSON = 206; + int32 decodeMapField = 207; + int32 decodeMessage = 208; + int32 Decoder = 209; + int32 decodeRepeated = 210; + int32 decodeRepeatedBoolField = 211; + int32 decodeRepeatedBytesField = 212; + int32 decodeRepeatedDoubleField = 213; + int32 decodeRepeatedEnumField = 214; + int32 decodeRepeatedFixed32Field = 215; + int32 decodeRepeatedFixed64Field = 216; + int32 decodeRepeatedFloatField = 217; + int32 decodeRepeatedGroupField = 218; + int32 decodeRepeatedInt32Field = 219; + int32 decodeRepeatedInt64Field = 220; + int32 decodeRepeatedMessageField = 221; + int32 decodeRepeatedSFixed32Field = 222; + int32 decodeRepeatedSFixed64Field = 223; + int32 decodeRepeatedSInt32Field = 224; + int32 decodeRepeatedSInt64Field = 225; + int32 decodeRepeatedStringField = 226; + int32 decodeRepeatedUInt32Field = 227; + int32 decodeRepeatedUInt64Field = 228; + int32 decodeSingular = 229; + int32 decodeSingularBoolField = 230; + int32 decodeSingularBytesField = 231; + int32 decodeSingularDoubleField = 232; + int32 decodeSingularEnumField = 233; + int32 decodeSingularFixed32Field = 234; + int32 decodeSingularFixed64Field = 235; + int32 decodeSingularFloatField = 236; + int32 decodeSingularGroupField = 237; + int32 decodeSingularInt32Field = 238; + int32 decodeSingularInt64Field = 239; + int32 decodeSingularMessageField = 240; + int32 decodeSingularSFixed32Field = 241; + int32 decodeSingularSFixed64Field = 242; + int32 decodeSingularSInt32Field = 243; + int32 decodeSingularSInt64Field = 244; + int32 decodeSingularStringField = 245; + int32 decodeSingularUInt32Field = 246; + int32 decodeSingularUInt64Field = 247; + int32 decodeTextFormat = 248; + int32 defaultAnyTypeURLPrefix = 249; + int32 defaults = 250; + int32 defaultSymbolVisibility = 251; + int32 defaultValue = 252; + int32 dependency = 253; + int32 deprecated = 254; + int32 deprecatedLegacyJsonFieldConflicts = 255; + int32 deprecationWarning = 256; + int32 description = 257; + int32 Dictionary = 258; + int32 dictionaryLiteral = 259; + int32 digit = 260; + int32 digit0 = 261; + int32 digit1 = 262; + int32 digitCount = 263; + int32 digits = 264; + int32 digitValue = 265; + int32 discardableResult = 266; + int32 discardUnknownFields = 267; + int32 Double = 268; + int32 doubleValue = 269; + int32 duration = 270; + int32 E = 271; + int32 edition = 272; + int32 EditionDefault = 273; + int32 editionDefaults = 274; + int32 editionDeprecated = 275; + int32 editionIntroduced = 276; + int32 editionRemoved = 277; + int32 Element = 278; + int32 elements = 279; + int32 else = 280; + int32 emitExtensionFieldName = 281; + int32 emitFieldName = 282; + int32 emitFieldNumber = 283; + int32 emptyAnyTypeURL = 284; + int32 emptyData = 285; + int32 encodeAsBytes = 286; + int32 encoded = 287; + int32 encodedJSONString = 288; + int32 encodedSize = 289; + int32 encodeField = 290; + int32 encoder = 291; + int32 end = 292; + int32 endArray = 293; + int32 endMessageField = 294; + int32 endObject = 295; + int32 endRegularField = 296; + int32 enforceNamingStyle = 297; + int32 enum = 298; + int32 EnumReservedRange = 299; + int32 enumType = 300; + int32 enumvalue = 301; + int32 Equatable = 302; + int32 Error = 303; + int32 execute = 304; + int32 ExpressibleByArrayLiteral = 305; + int32 ExpressibleByDictionaryLiteral = 306; + int32 ext = 307; + int32 extDecoder = 308; + int32 extendedGraphemeClusterLiteral = 309; + int32 ExtendedGraphemeClusterLiteralType = 310; + int32 extendee = 311; + int32 ExtensibleMessage = 312; + int32 extension = 313; + int32 ExtensionField = 314; + int32 extensionFieldNumber = 315; + int32 ExtensionFieldValueSet = 316; + int32 ExtensionMap = 317; + int32 extensionRange = 318; + int32 extensions = 319; + int32 extras = 320; + int32 F = 321; + int32 false = 322; + int32 features = 323; + int32 FeatureSetEditionDefault = 324; + int32 featureSupport = 325; + int32 field = 326; + int32 fieldData = 327; + int32 FieldMaskError = 328; + int32 fieldName = 329; + int32 fieldNameCount = 330; + int32 fieldNum = 331; + int32 fieldNumber = 332; + int32 fieldNumberForProto = 333; + int32 fieldPresence = 334; + int32 fields = 335; + int32 fieldSize = 336; + int32 FieldTag = 337; + int32 FieldType = 338; + int32 file = 339; + int32 fileName = 340; + int32 filter = 341; + int32 final = 342; + int32 finiteOnly = 343; + int32 first = 344; + int32 firstItem = 345; + int32 fixedFeatures = 346; + int32 Float = 347; + int32 floatLiteral = 348; + int32 FloatLiteralType = 349; + int32 for = 350; + int32 forMessageName = 351; + int32 formUnion = 352; + int32 forReadingFrom = 353; + int32 forTypeURL = 354; + int32 ForwardParser = 355; + int32 forWritingInto = 356; + int32 from = 357; + int32 fromAscii2 = 358; + int32 fromAscii4 = 359; + int32 fromByteOffset = 360; + int32 fromHexDigit = 361; + int32 fullName = 362; + int32 func = 363; + int32 function = 364; + int32 G = 365; + int32 get = 366; + int32 getExtensionValue = 367; + int32 Google_Protobuf_Any = 368; + int32 Google_Protobuf_Api = 369; + int32 Google_Protobuf_BoolValue = 370; + int32 Google_Protobuf_BytesValue = 371; + int32 Google_Protobuf_DescriptorProto = 372; + int32 Google_Protobuf_DoubleValue = 373; + int32 Google_Protobuf_Duration = 374; + int32 Google_Protobuf_Edition = 375; + int32 Google_Protobuf_Empty = 376; + int32 Google_Protobuf_Enum = 377; + int32 Google_Protobuf_EnumDescriptorProto = 378; + int32 Google_Protobuf_EnumOptions = 379; + int32 Google_Protobuf_EnumValue = 380; + int32 Google_Protobuf_EnumValueDescriptorProto = 381; + int32 Google_Protobuf_EnumValueOptions = 382; + int32 Google_Protobuf_ExtensionRangeOptions = 383; + int32 Google_Protobuf_FeatureSet = 384; + int32 Google_Protobuf_FeatureSetDefaults = 385; + int32 Google_Protobuf_Field = 386; + int32 Google_Protobuf_FieldDescriptorProto = 387; + int32 Google_Protobuf_FieldMask = 388; + int32 Google_Protobuf_FieldOptions = 389; + int32 Google_Protobuf_FileDescriptorProto = 390; + int32 Google_Protobuf_FileDescriptorSet = 391; + int32 Google_Protobuf_FileOptions = 392; + int32 Google_Protobuf_FloatValue = 393; + int32 Google_Protobuf_GeneratedCodeInfo = 394; + int32 Google_Protobuf_Int32Value = 395; + int32 Google_Protobuf_Int64Value = 396; + int32 Google_Protobuf_ListValue = 397; + int32 Google_Protobuf_MessageOptions = 398; + int32 Google_Protobuf_Method = 399; + int32 Google_Protobuf_MethodDescriptorProto = 400; + int32 Google_Protobuf_MethodOptions = 401; + int32 Google_Protobuf_Mixin = 402; + int32 Google_Protobuf_NullValue = 403; + int32 Google_Protobuf_OneofDescriptorProto = 404; + int32 Google_Protobuf_OneofOptions = 405; + int32 Google_Protobuf_Option = 406; + int32 Google_Protobuf_ServiceDescriptorProto = 407; + int32 Google_Protobuf_ServiceOptions = 408; + int32 Google_Protobuf_SourceCodeInfo = 409; + int32 Google_Protobuf_SourceContext = 410; + int32 Google_Protobuf_StringValue = 411; + int32 Google_Protobuf_Struct = 412; + int32 Google_Protobuf_SymbolVisibility = 413; + int32 Google_Protobuf_Syntax = 414; + int32 Google_Protobuf_Timestamp = 415; + int32 Google_Protobuf_Type = 416; + int32 Google_Protobuf_UInt32Value = 417; + int32 Google_Protobuf_UInt64Value = 418; + int32 Google_Protobuf_UninterpretedOption = 419; + int32 Google_Protobuf_Value = 420; + int32 goPackage = 421; + int32 gotData = 422; + int32 group = 423; + int32 groupFieldNumberStack = 424; + int32 groupSize = 425; + int32 guard = 426; + int32 hadOneofValue = 427; + int32 handleConflictingOneOf = 428; + int32 handleInstruction = 429; + int32 hasAggregateValue = 430; + int32 hasAllowAlias = 431; + int32 hasBegin = 432; + int32 hasCcEnableArenas = 433; + int32 hasCcGenericServices = 434; + int32 hasClientStreaming = 435; + int32 hasCsharpNamespace = 436; + int32 hasCtype = 437; + int32 hasData = 438; + int32 hasDebugRedact = 439; + int32 hasDefaultSymbolVisibility = 440; + int32 hasDefaultValue = 441; + int32 hasDeprecated = 442; + int32 hasDeprecatedLegacyJsonFieldConflicts = 443; + int32 hasDeprecationWarning = 444; + int32 hasDoubleValue = 445; + int32 hasEdition = 446; + int32 hasEditionDeprecated = 447; + int32 hasEditionIntroduced = 448; + int32 hasEditionRemoved = 449; + int32 hasEnd = 450; + int32 hasEnforceNamingStyle = 451; + int32 hasEnumType = 452; + int32 hasExplicitDelta = 453; + int32 hasExtendee = 454; + int32 hasExtensionValue = 455; + int32 hasFeatures = 456; + int32 hasFeatureSupport = 457; + int32 hasFieldPresence = 458; + int32 hasFixedFeatures = 459; + int32 hasFullName = 460; + int32 hasGoPackage = 461; + int32 hash = 462; + int32 Hashable = 463; + int32 hasher = 464; + int32 HashVisitor = 465; + int32 hasIdempotencyLevel = 466; + int32 hasIdentifierValue = 467; + int32 hasInputType = 468; + int32 hasIsExtension = 469; + int32 hasJavaGenerateEqualsAndHash = 470; + int32 hasJavaGenericServices = 471; + int32 hasJavaMultipleFiles = 472; + int32 hasJavaOuterClassname = 473; + int32 hasJavaPackage = 474; + int32 hasJavaStringCheckUtf8 = 475; + int32 hasJsonFormat = 476; + int32 hasJsonName = 477; + int32 hasJstype = 478; + int32 hasLabel = 479; + int32 hasLazy = 480; + int32 hasLeadingComments = 481; + int32 hasMapEntry = 482; + int32 hasMaximumEdition = 483; + int32 hasMessageEncoding = 484; + int32 hasMessageSetWireFormat = 485; + int32 hasMinimumEdition = 486; + int32 hasName = 487; + int32 hasNamePart = 488; + int32 hasNegativeIntValue = 489; + int32 hasNoStandardDescriptorAccessor = 490; + int32 hasNumber = 491; + int32 hasObjcClassPrefix = 492; + int32 hasOneofIndex = 493; + int32 hasOptimizeFor = 494; + int32 hasOptions = 495; + int32 hasOutputType = 496; + int32 hasOverridableFeatures = 497; + int32 hasPackage = 498; + int32 hasPacked = 499; + int32 hasPhpClassPrefix = 500; + int32 hasPhpMetadataNamespace = 501; + int32 hasPhpNamespace = 502; + int32 hasPositiveIntValue = 503; + int32 hasProto3Optional = 504; + int32 hasPyGenericServices = 505; + int32 hasRemovalError = 506; + int32 hasRepeated = 507; + int32 hasRepeatedFieldEncoding = 508; + int32 hasReserved = 509; + int32 hasRetention = 510; + int32 hasRubyPackage = 511; + int32 hasSemantic = 512; + int32 hasServerStreaming = 513; + int32 hasSourceCodeInfo = 514; + int32 hasSourceContext = 515; + int32 hasSourceFile = 516; + int32 hasStart = 517; + int32 hasStringValue = 518; + int32 hasSwiftPrefix = 519; + int32 hasSyntax = 520; + int32 hasTrailingComments = 521; + int32 hasType = 522; + int32 hasTypeName = 523; + int32 hasUnverifiedLazy = 524; + int32 hasUtf8Validation = 525; + int32 hasValue = 526; + int32 hasVerification = 527; + int32 hasVisibility = 528; + int32 hasWeak = 529; + int32 hour = 530; + int32 i = 531; + int32 idempotencyLevel = 532; + int32 identifierValue = 533; + int32 if = 534; + int32 ignoreUnknownExtensionFields = 535; + int32 ignoreUnknownFields = 536; + int32 index = 537; + int32 init = 538; + int32 inout = 539; + int32 inputType = 540; + int32 insert = 541; + int32 Instruction = 542; + int32 Int = 543; + int32 Int32 = 544; + int32 Int64 = 545; + int32 Int8 = 546; + int32 integerLiteral = 547; + int32 IntegerLiteralType = 548; + int32 intern = 549; + int32 Internal = 550; + int32 InternalState = 551; + int32 intersect = 552; + int32 into = 553; + int32 ints = 554; + int32 invalidAnyTypeURL = 555; + int32 isA = 556; + int32 isEqual = 557; + int32 isEqualTo = 558; + int32 isExtension = 559; + int32 isInitialized = 560; + int32 isNegative = 561; + int32 isPathValid = 562; + int32 isReserved = 563; + int32 isValid = 564; + int32 itemTagsEncodedSize = 565; + int32 iterator = 566; + int32 javaGenerateEqualsAndHash = 567; + int32 javaGenericServices = 568; + int32 javaMultipleFiles = 569; + int32 javaOuterClassname = 570; + int32 javaPackage = 571; + int32 javaStringCheckUtf8 = 572; + int32 JSONDecoder = 573; + int32 JSONDecoding = 574; + int32 JSONDecodingError = 575; + int32 JSONDecodingOptions = 576; + int32 jsonEncoder = 577; + int32 JSONEncoding = 578; + int32 JSONEncodingError = 579; + int32 JSONEncodingOptions = 580; + int32 JSONEncodingVisitor = 581; + int32 jsonFormat = 582; + int32 JSONMapEncodingVisitor = 583; + int32 jsonName = 584; + int32 jsonPath = 585; + int32 jsonPaths = 586; + int32 JSONScanner = 587; + int32 jsonString = 588; + int32 jsonText = 589; + int32 jsonUTF8Bytes = 590; + int32 jsonUTF8Data = 591; + int32 jstype = 592; + int32 k = 593; + int32 kChunkSize = 594; + int32 Key = 595; + int32 keyField = 596; + int32 keyFieldOpt = 597; + int32 KeyType = 598; + int32 kind = 599; + int32 l = 600; + int32 label = 601; + int32 lazy = 602; + int32 leadingComments = 603; + int32 leadingDetachedComments = 604; + int32 length = 605; + int32 lessThan = 606; + int32 let = 607; + int32 lhs = 608; + int32 line = 609; + int32 list = 610; + int32 listOfMessages = 611; + int32 listValue = 612; + int32 littleEndian = 613; + int32 load = 614; + int32 localHasher = 615; + int32 location = 616; + int32 M = 617; + int32 major = 618; + int32 makeAsyncIterator = 619; + int32 makeIterator = 620; + int32 malformedLength = 621; + int32 mapEntry = 622; + int32 MapKeyType = 623; + int32 mapToMessages = 624; + int32 MapValueType = 625; + int32 mapVisitor = 626; + int32 mask = 627; + int32 maximumEdition = 628; + int32 mdayStart = 629; + int32 merge = 630; + int32 MergeOptions = 631; + int32 message = 632; + int32 messageDepthLimit = 633; + int32 messageEncoding = 634; + int32 MessageExtension = 635; + int32 MessageImplementationBase = 636; + int32 MessageSet = 637; + int32 messageSetWireFormat = 638; + int32 messageSize = 639; + int32 messageType = 640; + int32 method = 641; + int32 methods = 642; + int32 min = 643; + int32 minimumEdition = 644; + int32 minor = 645; + int32 mixins = 646; + int32 modify = 647; + int32 month = 648; + int32 msgExtension = 649; + int32 mutating = 650; + int32 n = 651; + int32 name = 652; + int32 NameDescription = 653; + int32 NameMap = 654; + int32 NamePart = 655; + int32 names = 656; + int32 nanos = 657; + int32 negativeIntValue = 658; + int32 nestedType = 659; + int32 newExtensible = 660; + int32 newL = 661; + int32 newList = 662; + int32 newMessage = 663; + int32 newValue = 664; + int32 next = 665; + int32 nextByte = 666; + int32 nextFieldNumber = 667; + int32 nextInstruction = 668; + int32 nextInt32 = 669; + int32 nextNullTerminatedString = 670; + int32 nextNullTerminatedStringArray = 671; + int32 nextNumber = 672; + int32 nextUInt64 = 673; + int32 nextVarInt = 674; + int32 nil = 675; + int32 nilLiteral = 676; + int32 noBytesAvailable = 677; + int32 noStandardDescriptorAccessor = 678; + int32 nullValue = 679; + int32 number = 680; + int32 numberValue = 681; + int32 objcClassPrefix = 682; + int32 of = 683; + int32 OneOf_Kind = 684; + int32 oneofDecl = 685; + int32 oneofIndex = 686; + int32 oneofs = 687; + int32 optimizeFor = 688; + int32 OptimizeMode = 689; + int32 OptionalEnumExtensionField = 690; + int32 OptionalExtensionField = 691; + int32 OptionalGroupExtensionField = 692; + int32 OptionalMessageExtensionField = 693; + int32 optionDependency = 694; + int32 OptionRetention = 695; + int32 options = 696; + int32 OptionTargetType = 697; + int32 other = 698; + int32 others = 699; + int32 out = 700; + int32 outputType = 701; + int32 overridableFeatures = 702; + int32 p = 703; + int32 package = 704; + int32 packed = 705; + int32 PackedEnumExtensionField = 706; + int32 PackedExtensionField = 707; + int32 padding = 708; + int32 parent = 709; + int32 parse = 710; + int32 partial = 711; + int32 path = 712; + int32 PathDecoder = 713; + int32 PathDecodingError = 714; + int32 paths = 715; + int32 PathVisitor = 716; + int32 payload = 717; + int32 payloadSize = 718; + int32 phpClassPrefix = 719; + int32 phpMetadataNamespace = 720; + int32 phpNamespace = 721; + int32 pos = 722; + int32 positiveIntValue = 723; + int32 prefix = 724; + int32 preserveProtoFieldNames = 725; + int32 preTraverse = 726; + int32 previousNumber = 727; + int32 prevPath = 728; + int32 printUnknownFields = 729; + int32 programBuffer = 730; + int32 programFormat = 731; + int32 proto2 = 732; + int32 proto3DefaultValue = 733; + int32 proto3Optional = 734; + int32 protobuf_extensionFieldValues = 735; + int32 protobuf_fieldNumber = 736; + int32 protobuf_generated_isEqualTo = 737; + int32 protobuf_nameMap = 738; + int32 protobuf_newField = 739; + int32 protobuf_package = 740; + int32 ProtobufAPIVersion_2 = 741; + int32 ProtobufAPIVersionCheck = 742; + int32 ProtobufBool = 743; + int32 ProtobufBytes = 744; + int32 protobufData = 745; + int32 ProtobufDouble = 746; + int32 ProtobufEnumMap = 747; + int32 protobufExtension = 748; + int32 ProtobufFixed32 = 749; + int32 ProtobufFixed64 = 750; + int32 ProtobufFloat = 751; + int32 ProtobufInt32 = 752; + int32 ProtobufInt64 = 753; + int32 ProtobufMap = 754; + int32 ProtobufMessageMap = 755; + int32 ProtobufSFixed32 = 756; + int32 ProtobufSFixed64 = 757; + int32 ProtobufSInt32 = 758; + int32 ProtobufSInt64 = 759; + int32 ProtobufString = 760; + int32 ProtobufUInt32 = 761; + int32 ProtobufUInt64 = 762; + int32 protocol = 763; + int32 protoFieldName = 764; + int32 protoMessageName = 765; + int32 ProtoNameProviding = 766; + int32 protoPaths = 767; + int32 public = 768; + int32 publicDependency = 769; + int32 putBoolValue = 770; + int32 putBytesValue = 771; + int32 putDoubleValue = 772; + int32 putEnumValue = 773; + int32 putFixedUInt32 = 774; + int32 putFixedUInt64 = 775; + int32 putFloatValue = 776; + int32 putInt64 = 777; + int32 putStringValue = 778; + int32 putUInt64 = 779; + int32 putUInt64Hex = 780; + int32 putVarInt = 781; + int32 putZigZagVarInt = 782; + int32 pyGenericServices = 783; + int32 R = 784; + int32 rawChars = 785; + int32 RawRepresentable = 786; + int32 RawValue = 787; + int32 read4HexDigits = 788; + int32 readBytes = 789; + int32 reader = 790; + int32 register = 791; + int32 remainingProgram = 792; + int32 removalError = 793; + int32 removingAllFieldsOf = 794; + int32 repeated = 795; + int32 RepeatedEnumExtensionField = 796; + int32 RepeatedExtensionField = 797; + int32 repeatedFieldEncoding = 798; + int32 RepeatedGroupExtensionField = 799; + int32 RepeatedMessageExtensionField = 800; + int32 repeating = 801; + int32 replaceRepeatedFields = 802; + int32 requestStreaming = 803; + int32 requestTypeURL = 804; + int32 requiredSize = 805; + int32 responseStreaming = 806; + int32 responseTypeURL = 807; + int32 result = 808; + int32 retention = 809; + int32 rethrows = 810; + int32 ReturnType = 811; + int32 revision = 812; + int32 rhs = 813; + int32 root = 814; + int32 rubyPackage = 815; + int32 s = 816; + int32 sawBackslash = 817; + int32 sawSection4Characters = 818; + int32 sawSection5Characters = 819; + int32 Scalar = 820; + int32 scan = 821; + int32 scanner = 822; + int32 seconds = 823; + int32 self = 824; + int32 semantic = 825; + int32 Sendable = 826; + int32 separator = 827; + int32 serialize = 828; + int32 serializedBytes = 829; + int32 serializedData = 830; + int32 serializedSize = 831; + int32 serverStreaming = 832; + int32 service = 833; + int32 set = 834; + int32 setExtensionValue = 835; + int32 shift = 836; + int32 SimpleExtensionMap = 837; + int32 size = 838; + int32 sizer = 839; + int32 source = 840; + int32 sourceCodeInfo = 841; + int32 sourceContext = 842; + int32 sourceEncoding = 843; + int32 sourceFile = 844; + int32 SourceLocation = 845; + int32 span = 846; + int32 split = 847; + int32 start = 848; + int32 startArray = 849; + int32 startArrayObject = 850; + int32 startField = 851; + int32 startIndex = 852; + int32 startMessageField = 853; + int32 startObject = 854; + int32 startRegularField = 855; + int32 state = 856; + int32 static = 857; + int32 StaticString = 858; + int32 storage = 859; + int32 String = 860; + int32 stringLiteral = 861; + int32 StringLiteralType = 862; + int32 stringResult = 863; + int32 stringValue = 864; + int32 struct = 865; + int32 structValue = 866; + int32 subDecoder = 867; + int32 subscript = 868; + int32 subtract = 869; + int32 subVisitor = 870; + int32 Swift = 871; + int32 swiftPrefix = 872; + int32 SwiftProtobufContiguousBytes = 873; + int32 SwiftProtobufError = 874; + int32 syntax = 875; + int32 T = 876; + int32 tag = 877; + int32 targets = 878; + int32 terminator = 879; + int32 testDecoder = 880; + int32 text = 881; + int32 textDecoder = 882; + int32 TextFormatDecoder = 883; + int32 TextFormatDecodingError = 884; + int32 TextFormatDecodingOptions = 885; + int32 TextFormatEncodingOptions = 886; + int32 TextFormatEncodingVisitor = 887; + int32 textFormatString = 888; + int32 throwOrIgnore = 889; + int32 throws = 890; + int32 timeInterval = 891; + int32 timeIntervalSince1970 = 892; + int32 timeIntervalSinceReferenceDate = 893; + int32 tmp = 894; + int32 tooLarge = 895; + int32 total = 896; + int32 totalArrayDepth = 897; + int32 totalSize = 898; + int32 trailingComments = 899; + int32 traverse = 900; + int32 trim = 901; + int32 true = 902; + int32 try = 903; + int32 type = 904; + int32 typealias = 905; + int32 TypeEnum = 906; + int32 typeName = 907; + int32 typePrefix = 908; + int32 typeStart = 909; + int32 typeUnknown = 910; + int32 typeURL = 911; + int32 UInt32 = 912; + int32 UInt64 = 913; + int32 UInt8 = 914; + int32 unchecked = 915; + int32 Unicode = 916; + int32 unicodeScalarLiteral = 917; + int32 UnicodeScalarLiteralType = 918; + int32 unicodeScalars = 919; + int32 UnicodeScalarView = 920; + int32 uninterpretedOption = 921; + int32 union = 922; + int32 uniqueStorage = 923; + int32 unknown = 924; + int32 unknownFields = 925; + int32 UnknownStorage = 926; + int32 unpackTo = 927; + int32 UnsafeBufferPointer = 928; + int32 UnsafeMutablePointer = 929; + int32 UnsafeMutableRawBufferPointer = 930; + int32 UnsafeRawBufferPointer = 931; + int32 UnsafeRawPointer = 932; + int32 unverifiedLazy = 933; + int32 updatedOptions = 934; + int32 uppercasedAssumingASCII = 935; + int32 url = 936; + int32 useDeterministicOrdering = 937; + int32 utf8 = 938; + int32 utf8Ptr = 939; + int32 utf8ToDouble = 940; + int32 utf8Validation = 941; + int32 UTF8View = 942; + int32 V = 943; + int32 value = 944; + int32 valueField = 945; + int32 values = 946; + int32 ValueType = 947; + int32 var = 948; + int32 verification = 949; + int32 VerificationState = 950; + int32 version = 951; + int32 versionString = 952; + int32 visibility = 953; + int32 VisibilityFeature = 954; + int32 visitExtensionFields = 955; + int32 visitExtensionFieldsAsMessageSet = 956; + int32 visitMapField = 957; + int32 Visitor = 958; + int32 visitPacked = 959; + int32 visitPackedBoolField = 960; + int32 visitPackedDoubleField = 961; + int32 visitPackedEnumField = 962; + int32 visitPackedFixed32Field = 963; + int32 visitPackedFixed64Field = 964; + int32 visitPackedFloatField = 965; + int32 visitPackedInt32Field = 966; + int32 visitPackedInt64Field = 967; + int32 visitPackedSFixed32Field = 968; + int32 visitPackedSFixed64Field = 969; + int32 visitPackedSInt32Field = 970; + int32 visitPackedSInt64Field = 971; + int32 visitPackedUInt32Field = 972; + int32 visitPackedUInt64Field = 973; + int32 visitRepeated = 974; + int32 visitRepeatedBoolField = 975; + int32 visitRepeatedBytesField = 976; + int32 visitRepeatedDoubleField = 977; + int32 visitRepeatedEnumField = 978; + int32 visitRepeatedFixed32Field = 979; + int32 visitRepeatedFixed64Field = 980; + int32 visitRepeatedFloatField = 981; + int32 visitRepeatedGroupField = 982; + int32 visitRepeatedInt32Field = 983; + int32 visitRepeatedInt64Field = 984; + int32 visitRepeatedMessageField = 985; + int32 visitRepeatedSFixed32Field = 986; + int32 visitRepeatedSFixed64Field = 987; + int32 visitRepeatedSInt32Field = 988; + int32 visitRepeatedSInt64Field = 989; + int32 visitRepeatedStringField = 990; + int32 visitRepeatedUInt32Field = 991; + int32 visitRepeatedUInt64Field = 992; + int32 visitSingular = 993; + int32 visitSingularBoolField = 994; + int32 visitSingularBytesField = 995; + int32 visitSingularDoubleField = 996; + int32 visitSingularEnumField = 997; + int32 visitSingularFixed32Field = 998; + int32 visitSingularFixed64Field = 999; + int32 visitSingularFloatField = 1000; + int32 visitSingularGroupField = 1001; + int32 visitSingularInt32Field = 1002; + int32 visitSingularInt64Field = 1003; + int32 visitSingularMessageField = 1004; + int32 visitSingularSFixed32Field = 1005; + int32 visitSingularSFixed64Field = 1006; + int32 visitSingularSInt32Field = 1007; + int32 visitSingularSInt64Field = 1008; + int32 visitSingularStringField = 1009; + int32 visitSingularUInt32Field = 1010; + int32 visitSingularUInt64Field = 1011; + int32 visitUnknown = 1012; + int32 Void = 1013; + int32 wasDecoded = 1014; + int32 weak = 1015; + int32 weakDependency = 1016; + int32 where = 1017; + int32 wireFormat = 1018; + int32 with = 1019; + int32 withUnsafeBytes = 1020; + int32 withUnsafeMutableBytes = 1021; + int32 work = 1022; + int32 Wrapped = 1023; + int32 WrappedType = 1024; + int32 wrappedValue = 1025; + int32 written = 1026; + int32 yday = 1027; +} diff --git a/Protos/generated_swift_names_messages.proto b/Protos/Tests/SwiftProtobufTests/generated_swift_names_messages.proto similarity index 78% rename from Protos/generated_swift_names_messages.proto rename to Protos/Tests/SwiftProtobufTests/generated_swift_names_messages.proto index 83c7efcb0..7171db123 100644 --- a/Protos/generated_swift_names_messages.proto +++ b/Protos/Tests/SwiftProtobufTests/generated_swift_names_messages.proto @@ -2,39 +2,47 @@ // Protoc errors imply this file is being generated incorrectly // Swift compile errors are probably bugs in protoc-gen-swift syntax = "proto3"; -package protobuf_unittest_generated; +package swift_proto_testing.generated; message GeneratedSwiftReservedMessages { + message addPath { int32 addPath = 1; } message adjusted { int32 adjusted = 1; } message aggregateValue { int32 aggregateValue = 1; } message allCases { int32 allCases = 1; } message allowAlias { int32 allowAlias = 1; } message alwaysPrintEnumsAsInts { int32 alwaysPrintEnumsAsInts = 1; } + message alwaysPrintInt64sAsNumbers { int32 alwaysPrintInt64sAsNumbers = 1; } message annotation { int32 annotation = 1; } message any { int32 any = 1; } message AnyExtensionField { int32 AnyExtensionField = 1; } message AnyMessageExtension { int32 AnyMessageExtension = 1; } message AnyMessageStorage { int32 AnyMessageStorage = 1; } message AnyUnpackError { int32 AnyUnpackError = 1; } - message Api { int32 Api = 1; } + message append { int32 append = 1; } message appended { int32 appended = 1; } message appendUIntHex { int32 appendUIntHex = 1; } message appendUnknown { int32 appendUnknown = 1; } message areAllInitialized { int32 areAllInitialized = 1; } - message array { int32 array = 1; } + message Array { int32 Array = 1; } message arrayDepth { int32 arrayDepth = 1; } message arrayLiteral { int32 arrayLiteral = 1; } message arraySeparator { int32 arraySeparator = 1; } message as { int32 as = 1; } message asciiOpenCurlyBracket { int32 asciiOpenCurlyBracket = 1; } message asciiZero { int32 asciiZero = 1; } + message async { int32 async = 1; } + message AsyncIterator { int32 AsyncIterator = 1; } + message AsyncIteratorProtocol { int32 AsyncIteratorProtocol = 1; } + message AsyncMessageSequence { int32 AsyncMessageSequence = 1; } message available { int32 available = 1; } message b { int32 b = 1; } + message Base { int32 Base = 1; } message base64Values { int32 base64Values = 1; } message baseAddress { int32 baseAddress = 1; } message BaseType { int32 BaseType = 1; } message begin { int32 begin = 1; } message binary { int32 binary = 1; } message BinaryDecoder { int32 BinaryDecoder = 1; } + message BinaryDecoding { int32 BinaryDecoding = 1; } message BinaryDecodingError { int32 BinaryDecodingError = 1; } message BinaryDecodingOptions { int32 BinaryDecodingOptions = 1; } message BinaryDelimited { int32 BinaryDelimited = 1; } @@ -42,25 +50,39 @@ message GeneratedSwiftReservedMessages { message BinaryEncodingError { int32 BinaryEncodingError = 1; } message BinaryEncodingMessageSetSizeVisitor { int32 BinaryEncodingMessageSetSizeVisitor = 1; } message BinaryEncodingMessageSetVisitor { int32 BinaryEncodingMessageSetVisitor = 1; } + message BinaryEncodingOptions { int32 BinaryEncodingOptions = 1; } message BinaryEncodingSizeVisitor { int32 BinaryEncodingSizeVisitor = 1; } message BinaryEncodingVisitor { int32 BinaryEncodingVisitor = 1; } message binaryOptions { int32 binaryOptions = 1; } + message binaryProtobufDelimitedMessages { int32 binaryProtobufDelimitedMessages = 1; } + message BinaryStreamDecoding { int32 BinaryStreamDecoding = 1; } + message binaryStreamDecodingError { int32 binaryStreamDecodingError = 1; } + message bitPattern { int32 bitPattern = 1; } message body { int32 body = 1; } message Bool { int32 Bool = 1; } message booleanLiteral { int32 booleanLiteral = 1; } message BooleanLiteralType { int32 BooleanLiteralType = 1; } message boolValue { int32 boolValue = 1; } + message buffer { int32 buffer = 1; } + message byte { int32 byte = 1; } + message bytecode { int32 bytecode = 1; } + message BytecodeReader { int32 BytecodeReader = 1; } message bytes { int32 bytes = 1; } message bytesInGroup { int32 bytesInGroup = 1; } + message bytesNeeded { int32 bytesNeeded = 1; } message bytesRead { int32 bytesRead = 1; } - message BytesValue { int32 BytesValue = 1; } message c { int32 c = 1; } + message canonical { int32 canonical = 1; } message capitalizeNext { int32 capitalizeNext = 1; } message cardinality { int32 cardinality = 1; } + message CaseIterable { int32 CaseIterable = 1; } + message castedValue { int32 castedValue = 1; } message ccEnableArenas { int32 ccEnableArenas = 1; } message ccGenericServices { int32 ccGenericServices = 1; } message Character { int32 Character = 1; } message chars { int32 chars = 1; } + message checkProgramFormat { int32 checkProgramFormat = 1; } + message chunk { int32 chunk = 1; } message class { int32 class = 1; } message clearAggregateValue { int32 clearAggregateValue = 1; } message clearAllowAlias { int32 clearAllowAlias = 1; } @@ -70,12 +92,27 @@ message GeneratedSwiftReservedMessages { message clearClientStreaming { int32 clearClientStreaming = 1; } message clearCsharpNamespace { int32 clearCsharpNamespace = 1; } message clearCtype { int32 clearCtype = 1; } + message clearDebugRedact { int32 clearDebugRedact = 1; } + message clearDefaultSymbolVisibility { int32 clearDefaultSymbolVisibility = 1; } message clearDefaultValue { int32 clearDefaultValue = 1; } message clearDeprecated { int32 clearDeprecated = 1; } + message clearDeprecatedLegacyJsonFieldConflicts { int32 clearDeprecatedLegacyJsonFieldConflicts = 1; } + message clearDeprecationWarning { int32 clearDeprecationWarning = 1; } message clearDoubleValue { int32 clearDoubleValue = 1; } + message clearEdition { int32 clearEdition = 1; } + message clearEditionDeprecated { int32 clearEditionDeprecated = 1; } + message clearEditionIntroduced { int32 clearEditionIntroduced = 1; } + message clearEditionRemoved { int32 clearEditionRemoved = 1; } message clearEnd { int32 clearEnd = 1; } + message clearEnforceNamingStyle { int32 clearEnforceNamingStyle = 1; } + message clearEnumType { int32 clearEnumType = 1; } message clearExtendee { int32 clearExtendee = 1; } message clearExtensionValue { int32 clearExtensionValue = 1; } + message clearFeatures { int32 clearFeatures = 1; } + message clearFeatureSupport { int32 clearFeatureSupport = 1; } + message clearFieldPresence { int32 clearFieldPresence = 1; } + message clearFixedFeatures { int32 clearFixedFeatures = 1; } + message clearFullName { int32 clearFullName = 1; } message clearGoPackage { int32 clearGoPackage = 1; } message clearIdempotencyLevel { int32 clearIdempotencyLevel = 1; } message clearIdentifierValue { int32 clearIdentifierValue = 1; } @@ -87,13 +124,17 @@ message GeneratedSwiftReservedMessages { message clearJavaOuterClassname { int32 clearJavaOuterClassname = 1; } message clearJavaPackage { int32 clearJavaPackage = 1; } message clearJavaStringCheckUtf8 { int32 clearJavaStringCheckUtf8 = 1; } + message clearJsonFormat { int32 clearJsonFormat = 1; } message clearJsonName { int32 clearJsonName = 1; } message clearJstype { int32 clearJstype = 1; } message clearLabel { int32 clearLabel = 1; } message clearLazy { int32 clearLazy = 1; } message clearLeadingComments { int32 clearLeadingComments = 1; } message clearMapEntry { int32 clearMapEntry = 1; } + message clearMaximumEdition { int32 clearMaximumEdition = 1; } + message clearMessageEncoding { int32 clearMessageEncoding = 1; } message clearMessageSetWireFormat { int32 clearMessageSetWireFormat = 1; } + message clearMinimumEdition { int32 clearMinimumEdition = 1; } message clearName { int32 clearName = 1; } message clearNamePart { int32 clearNamePart = 1; } message clearNegativeIntValue { int32 clearNegativeIntValue = 1; } @@ -104,16 +145,22 @@ message GeneratedSwiftReservedMessages { message clearOptimizeFor { int32 clearOptimizeFor = 1; } message clearOptions { int32 clearOptions = 1; } message clearOutputType { int32 clearOutputType = 1; } + message clearOverridableFeatures { int32 clearOverridableFeatures = 1; } message clearPackage { int32 clearPackage = 1; } message clearPacked { int32 clearPacked = 1; } message clearPhpClassPrefix { int32 clearPhpClassPrefix = 1; } - message clearPhpGenericServices { int32 clearPhpGenericServices = 1; } message clearPhpMetadataNamespace { int32 clearPhpMetadataNamespace = 1; } message clearPhpNamespace { int32 clearPhpNamespace = 1; } message clearPositiveIntValue { int32 clearPositiveIntValue = 1; } message clearProto3Optional { int32 clearProto3Optional = 1; } message clearPyGenericServices { int32 clearPyGenericServices = 1; } + message clearRemovalError { int32 clearRemovalError = 1; } + message clearRepeated { int32 clearRepeated = 1; } + message clearRepeatedFieldEncoding { int32 clearRepeatedFieldEncoding = 1; } + message clearReserved { int32 clearReserved = 1; } + message clearRetention { int32 clearRetention = 1; } message clearRubyPackage { int32 clearRubyPackage = 1; } + message clearSemantic { int32 clearSemantic = 1; } message clearServerStreaming { int32 clearServerStreaming = 1; } message clearSourceCodeInfo { int32 clearSourceCodeInfo = 1; } message clearSourceContext { int32 clearSourceContext = 1; } @@ -125,29 +172,39 @@ message GeneratedSwiftReservedMessages { message clearTrailingComments { int32 clearTrailingComments = 1; } message clearType { int32 clearType = 1; } message clearTypeName { int32 clearTypeName = 1; } + message clearUnverifiedLazy { int32 clearUnverifiedLazy = 1; } + message clearUtf8Validation { int32 clearUtf8Validation = 1; } message clearValue { int32 clearValue = 1; } + message clearVerification { int32 clearVerification = 1; } + message clearVisibility { int32 clearVisibility = 1; } message clearWeak { int32 clearWeak = 1; } message clientStreaming { int32 clientStreaming = 1; } + message code { int32 code = 1; } message codePoint { int32 codePoint = 1; } message codeUnits { int32 codeUnits = 1; } message Collection { int32 Collection = 1; } - message com { int32 com = 1; } message comma { int32 comma = 1; } + message consumedBytes { int32 consumedBytes = 1; } + message contains { int32 contains = 1; } message contentsOf { int32 contentsOf = 1; } message ContiguousBytes { int32 ContiguousBytes = 1; } + message copy { int32 copy = 1; } message count { int32 count = 1; } message countVarintsInBuffer { int32 countVarintsInBuffer = 1; } message csharpNamespace { int32 csharpNamespace = 1; } message ctype { int32 ctype = 1; } message customCodable { int32 customCodable = 1; } message CustomDebugStringConvertible { int32 CustomDebugStringConvertible = 1; } - message d { int32 d = 1; } + message CustomStringConvertible { int32 CustomStringConvertible = 1; } + message D { int32 D = 1; } message Data { int32 Data = 1; } message dataResult { int32 dataResult = 1; } message date { int32 date = 1; } message daySec { int32 daySec = 1; } message daysSinceEpoch { int32 daysSinceEpoch = 1; } message debugDescription { int32 debugDescription = 1; } + message debugRedact { int32 debugRedact = 1; } + message declaration { int32 declaration = 1; } message decoded { int32 decoded = 1; } message decodedFromJSONNull { int32 decodedFromJSONNull = 1; } message decodeExtensionField { int32 decodeExtensionField = 1; } @@ -155,7 +212,7 @@ message GeneratedSwiftReservedMessages { message decodeJSON { int32 decodeJSON = 1; } message decodeMapField { int32 decodeMapField = 1; } message decodeMessage { int32 decodeMessage = 1; } - message decoder { int32 decoder = 1; } + message Decoder { int32 Decoder = 1; } message decodeRepeated { int32 decodeRepeated = 1; } message decodeRepeatedBoolField { int32 decodeRepeatedBoolField = 1; } message decodeRepeatedBytesField { int32 decodeRepeatedBytesField = 1; } @@ -196,11 +253,14 @@ message GeneratedSwiftReservedMessages { message decodeSingularUInt64Field { int32 decodeSingularUInt64Field = 1; } message decodeTextFormat { int32 decodeTextFormat = 1; } message defaultAnyTypeURLPrefix { int32 defaultAnyTypeURLPrefix = 1; } + message defaults { int32 defaults = 1; } + message defaultSymbolVisibility { int32 defaultSymbolVisibility = 1; } message defaultValue { int32 defaultValue = 1; } message dependency { int32 dependency = 1; } message deprecated { int32 deprecated = 1; } + message deprecatedLegacyJsonFieldConflicts { int32 deprecatedLegacyJsonFieldConflicts = 1; } + message deprecationWarning { int32 deprecationWarning = 1; } message description { int32 description = 1; } - message DescriptorProto { int32 DescriptorProto = 1; } message Dictionary { int32 Dictionary = 1; } message dictionaryLiteral { int32 dictionaryLiteral = 1; } message digit { int32 digit = 1; } @@ -211,17 +271,23 @@ message GeneratedSwiftReservedMessages { message digitValue { int32 digitValue = 1; } message discardableResult { int32 discardableResult = 1; } message discardUnknownFields { int32 discardUnknownFields = 1; } - message distance { int32 distance = 1; } - message double { int32 double = 1; } + message Double { int32 Double = 1; } message doubleValue { int32 doubleValue = 1; } - message Duration { int32 Duration = 1; } + message duration { int32 duration = 1; } message E { int32 E = 1; } + message edition { int32 edition = 1; } + message EditionDefault { int32 EditionDefault = 1; } + message editionDefaults { int32 editionDefaults = 1; } + message editionDeprecated { int32 editionDeprecated = 1; } + message editionIntroduced { int32 editionIntroduced = 1; } + message editionRemoved { int32 editionRemoved = 1; } message Element { int32 Element = 1; } message elements { int32 elements = 1; } + message else { int32 else = 1; } message emitExtensionFieldName { int32 emitExtensionFieldName = 1; } message emitFieldName { int32 emitFieldName = 1; } message emitFieldNumber { int32 emitFieldNumber = 1; } - message Empty { int32 Empty = 1; } + message emptyAnyTypeURL { int32 emptyAnyTypeURL = 1; } message emptyData { int32 emptyData = 1; } message encodeAsBytes { int32 encodeAsBytes = 1; } message encoded { int32 encoded = 1; } @@ -234,16 +300,14 @@ message GeneratedSwiftReservedMessages { message endMessageField { int32 endMessageField = 1; } message endObject { int32 endObject = 1; } message endRegularField { int32 endRegularField = 1; } + message enforceNamingStyle { int32 enforceNamingStyle = 1; } message enum { int32 enum = 1; } - message EnumDescriptorProto { int32 EnumDescriptorProto = 1; } - message EnumOptions { int32 EnumOptions = 1; } message EnumReservedRange { int32 EnumReservedRange = 1; } message enumType { int32 enumType = 1; } message enumvalue { int32 enumvalue = 1; } - message EnumValueDescriptorProto { int32 EnumValueDescriptorProto = 1; } - message EnumValueOptions { int32 EnumValueOptions = 1; } message Equatable { int32 Equatable = 1; } message Error { int32 Error = 1; } + message execute { int32 execute = 1; } message ExpressibleByArrayLiteral { int32 ExpressibleByArrayLiteral = 1; } message ExpressibleByDictionaryLiteral { int32 ExpressibleByDictionaryLiteral = 1; } message ext { int32 ext = 1; } @@ -258,37 +322,38 @@ message GeneratedSwiftReservedMessages { message ExtensionFieldValueSet { int32 ExtensionFieldValueSet = 1; } message ExtensionMap { int32 ExtensionMap = 1; } message extensionRange { int32 extensionRange = 1; } - message ExtensionRangeOptions { int32 ExtensionRangeOptions = 1; } message extensions { int32 extensions = 1; } message extras { int32 extras = 1; } message F { int32 F = 1; } message false { int32 false = 1; } + message features { int32 features = 1; } + message FeatureSetEditionDefault { int32 FeatureSetEditionDefault = 1; } + message featureSupport { int32 featureSupport = 1; } message field { int32 field = 1; } message fieldData { int32 fieldData = 1; } - message FieldDescriptorProto { int32 FieldDescriptorProto = 1; } - message FieldMask { int32 FieldMask = 1; } + message FieldMaskError { int32 FieldMaskError = 1; } message fieldName { int32 fieldName = 1; } message fieldNameCount { int32 fieldNameCount = 1; } message fieldNum { int32 fieldNum = 1; } message fieldNumber { int32 fieldNumber = 1; } message fieldNumberForProto { int32 fieldNumberForProto = 1; } - message FieldOptions { int32 FieldOptions = 1; } + message fieldPresence { int32 fieldPresence = 1; } message fields { int32 fields = 1; } message fieldSize { int32 fieldSize = 1; } message FieldTag { int32 FieldTag = 1; } - message fieldType { int32 fieldType = 1; } + message FieldType { int32 FieldType = 1; } message file { int32 file = 1; } - message FileDescriptorProto { int32 FileDescriptorProto = 1; } - message FileDescriptorSet { int32 FileDescriptorSet = 1; } message fileName { int32 fileName = 1; } - message FileOptions { int32 FileOptions = 1; } message filter { int32 filter = 1; } + message final { int32 final = 1; } + message finiteOnly { int32 finiteOnly = 1; } message first { int32 first = 1; } message firstItem { int32 firstItem = 1; } - message float { int32 float = 1; } + message fixedFeatures { int32 fixedFeatures = 1; } + message Float { int32 Float = 1; } message floatLiteral { int32 floatLiteral = 1; } message FloatLiteralType { int32 FloatLiteralType = 1; } - message FloatValue { int32 FloatValue = 1; } + message for { int32 for = 1; } message forMessageName { int32 forMessageName = 1; } message formUnion { int32 formUnion = 1; } message forReadingFrom { int32 forReadingFrom = 1; } @@ -300,12 +365,12 @@ message GeneratedSwiftReservedMessages { message fromAscii4 { int32 fromAscii4 = 1; } message fromByteOffset { int32 fromByteOffset = 1; } message fromHexDigit { int32 fromHexDigit = 1; } + message fullName { int32 fullName = 1; } message func { int32 func = 1; } + message function { int32 function = 1; } message G { int32 G = 1; } - message GeneratedCodeInfo { int32 GeneratedCodeInfo = 1; } message get { int32 get = 1; } message getExtensionValue { int32 getExtensionValue = 1; } - message googleapis { int32 googleapis = 1; } message Google_Protobuf_Any { int32 Google_Protobuf_Any = 1; } message Google_Protobuf_Api { int32 Google_Protobuf_Api = 1; } message Google_Protobuf_BoolValue { int32 Google_Protobuf_BoolValue = 1; } @@ -313,6 +378,7 @@ message GeneratedSwiftReservedMessages { message Google_Protobuf_DescriptorProto { int32 Google_Protobuf_DescriptorProto = 1; } message Google_Protobuf_DoubleValue { int32 Google_Protobuf_DoubleValue = 1; } message Google_Protobuf_Duration { int32 Google_Protobuf_Duration = 1; } + message Google_Protobuf_Edition { int32 Google_Protobuf_Edition = 1; } message Google_Protobuf_Empty { int32 Google_Protobuf_Empty = 1; } message Google_Protobuf_Enum { int32 Google_Protobuf_Enum = 1; } message Google_Protobuf_EnumDescriptorProto { int32 Google_Protobuf_EnumDescriptorProto = 1; } @@ -321,6 +387,8 @@ message GeneratedSwiftReservedMessages { message Google_Protobuf_EnumValueDescriptorProto { int32 Google_Protobuf_EnumValueDescriptorProto = 1; } message Google_Protobuf_EnumValueOptions { int32 Google_Protobuf_EnumValueOptions = 1; } message Google_Protobuf_ExtensionRangeOptions { int32 Google_Protobuf_ExtensionRangeOptions = 1; } + message Google_Protobuf_FeatureSet { int32 Google_Protobuf_FeatureSet = 1; } + message Google_Protobuf_FeatureSetDefaults { int32 Google_Protobuf_FeatureSetDefaults = 1; } message Google_Protobuf_Field { int32 Google_Protobuf_Field = 1; } message Google_Protobuf_FieldDescriptorProto { int32 Google_Protobuf_FieldDescriptorProto = 1; } message Google_Protobuf_FieldMask { int32 Google_Protobuf_FieldMask = 1; } @@ -348,6 +416,7 @@ message GeneratedSwiftReservedMessages { message Google_Protobuf_SourceContext { int32 Google_Protobuf_SourceContext = 1; } message Google_Protobuf_StringValue { int32 Google_Protobuf_StringValue = 1; } message Google_Protobuf_Struct { int32 Google_Protobuf_Struct = 1; } + message Google_Protobuf_SymbolVisibility { int32 Google_Protobuf_SymbolVisibility = 1; } message Google_Protobuf_Syntax { int32 Google_Protobuf_Syntax = 1; } message Google_Protobuf_Timestamp { int32 Google_Protobuf_Timestamp = 1; } message Google_Protobuf_Type { int32 Google_Protobuf_Type = 1; } @@ -356,12 +425,14 @@ message GeneratedSwiftReservedMessages { message Google_Protobuf_UninterpretedOption { int32 Google_Protobuf_UninterpretedOption = 1; } message Google_Protobuf_Value { int32 Google_Protobuf_Value = 1; } message goPackage { int32 goPackage = 1; } + message gotData { int32 gotData = 1; } message group { int32 group = 1; } message groupFieldNumberStack { int32 groupFieldNumberStack = 1; } message groupSize { int32 groupSize = 1; } - message h { int32 h = 1; } + message guard { int32 guard = 1; } message hadOneofValue { int32 hadOneofValue = 1; } message handleConflictingOneOf { int32 handleConflictingOneOf = 1; } + message handleInstruction { int32 handleInstruction = 1; } message hasAggregateValue { int32 hasAggregateValue = 1; } message hasAllowAlias { int32 hasAllowAlias = 1; } message hasBegin { int32 hasBegin = 1; } @@ -370,17 +441,33 @@ message GeneratedSwiftReservedMessages { message hasClientStreaming { int32 hasClientStreaming = 1; } message hasCsharpNamespace { int32 hasCsharpNamespace = 1; } message hasCtype { int32 hasCtype = 1; } + message hasData { int32 hasData = 1; } + message hasDebugRedact { int32 hasDebugRedact = 1; } + message hasDefaultSymbolVisibility { int32 hasDefaultSymbolVisibility = 1; } message hasDefaultValue { int32 hasDefaultValue = 1; } message hasDeprecated { int32 hasDeprecated = 1; } + message hasDeprecatedLegacyJsonFieldConflicts { int32 hasDeprecatedLegacyJsonFieldConflicts = 1; } + message hasDeprecationWarning { int32 hasDeprecationWarning = 1; } message hasDoubleValue { int32 hasDoubleValue = 1; } + message hasEdition { int32 hasEdition = 1; } + message hasEditionDeprecated { int32 hasEditionDeprecated = 1; } + message hasEditionIntroduced { int32 hasEditionIntroduced = 1; } + message hasEditionRemoved { int32 hasEditionRemoved = 1; } message hasEnd { int32 hasEnd = 1; } + message hasEnforceNamingStyle { int32 hasEnforceNamingStyle = 1; } + message hasEnumType { int32 hasEnumType = 1; } + message hasExplicitDelta { int32 hasExplicitDelta = 1; } message hasExtendee { int32 hasExtendee = 1; } message hasExtensionValue { int32 hasExtensionValue = 1; } + message hasFeatures { int32 hasFeatures = 1; } + message hasFeatureSupport { int32 hasFeatureSupport = 1; } + message hasFieldPresence { int32 hasFieldPresence = 1; } + message hasFixedFeatures { int32 hasFixedFeatures = 1; } + message hasFullName { int32 hasFullName = 1; } message hasGoPackage { int32 hasGoPackage = 1; } message hash { int32 hash = 1; } message Hashable { int32 Hashable = 1; } message hasher { int32 hasher = 1; } - message hashValue { int32 hashValue = 1; } message HashVisitor { int32 HashVisitor = 1; } message hasIdempotencyLevel { int32 hasIdempotencyLevel = 1; } message hasIdentifierValue { int32 hasIdentifierValue = 1; } @@ -392,13 +479,17 @@ message GeneratedSwiftReservedMessages { message hasJavaOuterClassname { int32 hasJavaOuterClassname = 1; } message hasJavaPackage { int32 hasJavaPackage = 1; } message hasJavaStringCheckUtf8 { int32 hasJavaStringCheckUtf8 = 1; } + message hasJsonFormat { int32 hasJsonFormat = 1; } message hasJsonName { int32 hasJsonName = 1; } message hasJstype { int32 hasJstype = 1; } message hasLabel { int32 hasLabel = 1; } message hasLazy { int32 hasLazy = 1; } message hasLeadingComments { int32 hasLeadingComments = 1; } message hasMapEntry { int32 hasMapEntry = 1; } + message hasMaximumEdition { int32 hasMaximumEdition = 1; } + message hasMessageEncoding { int32 hasMessageEncoding = 1; } message hasMessageSetWireFormat { int32 hasMessageSetWireFormat = 1; } + message hasMinimumEdition { int32 hasMinimumEdition = 1; } message hasName { int32 hasName = 1; } message hasNamePart { int32 hasNamePart = 1; } message hasNegativeIntValue { int32 hasNegativeIntValue = 1; } @@ -409,16 +500,22 @@ message GeneratedSwiftReservedMessages { message hasOptimizeFor { int32 hasOptimizeFor = 1; } message hasOptions { int32 hasOptions = 1; } message hasOutputType { int32 hasOutputType = 1; } + message hasOverridableFeatures { int32 hasOverridableFeatures = 1; } message hasPackage { int32 hasPackage = 1; } message hasPacked { int32 hasPacked = 1; } message hasPhpClassPrefix { int32 hasPhpClassPrefix = 1; } - message hasPhpGenericServices { int32 hasPhpGenericServices = 1; } message hasPhpMetadataNamespace { int32 hasPhpMetadataNamespace = 1; } message hasPhpNamespace { int32 hasPhpNamespace = 1; } message hasPositiveIntValue { int32 hasPositiveIntValue = 1; } message hasProto3Optional { int32 hasProto3Optional = 1; } message hasPyGenericServices { int32 hasPyGenericServices = 1; } + message hasRemovalError { int32 hasRemovalError = 1; } + message hasRepeated { int32 hasRepeated = 1; } + message hasRepeatedFieldEncoding { int32 hasRepeatedFieldEncoding = 1; } + message hasReserved { int32 hasReserved = 1; } + message hasRetention { int32 hasRetention = 1; } message hasRubyPackage { int32 hasRubyPackage = 1; } + message hasSemantic { int32 hasSemantic = 1; } message hasServerStreaming { int32 hasServerStreaming = 1; } message hasSourceCodeInfo { int32 hasSourceCodeInfo = 1; } message hasSourceContext { int32 hasSourceContext = 1; } @@ -430,40 +527,49 @@ message GeneratedSwiftReservedMessages { message hasTrailingComments { int32 hasTrailingComments = 1; } message hasType { int32 hasType = 1; } message hasTypeName { int32 hasTypeName = 1; } + message hasUnverifiedLazy { int32 hasUnverifiedLazy = 1; } + message hasUtf8Validation { int32 hasUtf8Validation = 1; } message hasValue { int32 hasValue = 1; } + message hasVerification { int32 hasVerification = 1; } + message hasVisibility { int32 hasVisibility = 1; } message hasWeak { int32 hasWeak = 1; } message hour { int32 hour = 1; } message i { int32 i = 1; } message idempotencyLevel { int32 idempotencyLevel = 1; } message identifierValue { int32 identifierValue = 1; } message if { int32 if = 1; } + message ignoreUnknownExtensionFields { int32 ignoreUnknownExtensionFields = 1; } message ignoreUnknownFields { int32 ignoreUnknownFields = 1; } message index { int32 index = 1; } message init { int32 init = 1; } message inout { int32 inout = 1; } message inputType { int32 inputType = 1; } message insert { int32 insert = 1; } + message Instruction { int32 Instruction = 1; } message Int { int32 Int = 1; } message Int32 { int32 Int32 = 1; } - message Int32Value { int32 Int32Value = 1; } message Int64 { int32 Int64 = 1; } - message Int64Value { int32 Int64Value = 1; } message Int8 { int32 Int8 = 1; } message integerLiteral { int32 integerLiteral = 1; } message IntegerLiteralType { int32 IntegerLiteralType = 1; } message intern { int32 intern = 1; } message Internal { int32 Internal = 1; } message InternalState { int32 InternalState = 1; } + message intersect { int32 intersect = 1; } message into { int32 into = 1; } message ints { int32 ints = 1; } + message invalidAnyTypeURL { int32 invalidAnyTypeURL = 1; } message isA { int32 isA = 1; } message isEqual { int32 isEqual = 1; } message isEqualTo { int32 isEqualTo = 1; } message isExtension { int32 isExtension = 1; } message isInitialized { int32 isInitialized = 1; } + message isNegative { int32 isNegative = 1; } + message isPathValid { int32 isPathValid = 1; } + message isReserved { int32 isReserved = 1; } + message isValid { int32 isValid = 1; } message itemTagsEncodedSize { int32 itemTagsEncodedSize = 1; } - message Iterator { int32 Iterator = 1; } - message i_2166136261 { int32 i_2166136261 = 1; } + message iterator { int32 iterator = 1; } message javaGenerateEqualsAndHash { int32 javaGenerateEqualsAndHash = 1; } message javaGenericServices { int32 javaGenericServices = 1; } message javaMultipleFiles { int32 javaMultipleFiles = 1; } @@ -471,12 +577,15 @@ message GeneratedSwiftReservedMessages { message javaPackage { int32 javaPackage = 1; } message javaStringCheckUtf8 { int32 javaStringCheckUtf8 = 1; } message JSONDecoder { int32 JSONDecoder = 1; } + message JSONDecoding { int32 JSONDecoding = 1; } message JSONDecodingError { int32 JSONDecodingError = 1; } message JSONDecodingOptions { int32 JSONDecodingOptions = 1; } message jsonEncoder { int32 jsonEncoder = 1; } + message JSONEncoding { int32 JSONEncoding = 1; } message JSONEncodingError { int32 JSONEncodingError = 1; } message JSONEncodingOptions { int32 JSONEncodingOptions = 1; } message JSONEncodingVisitor { int32 JSONEncodingVisitor = 1; } + message jsonFormat { int32 jsonFormat = 1; } message JSONMapEncodingVisitor { int32 JSONMapEncodingVisitor = 1; } message jsonName { int32 jsonName = 1; } message jsonPath { int32 jsonPath = 1; } @@ -484,11 +593,14 @@ message GeneratedSwiftReservedMessages { message JSONScanner { int32 JSONScanner = 1; } message jsonString { int32 jsonString = 1; } message jsonText { int32 jsonText = 1; } + message jsonUTF8Bytes { int32 jsonUTF8Bytes = 1; } message jsonUTF8Data { int32 jsonUTF8Data = 1; } message jstype { int32 jstype = 1; } message k { int32 k = 1; } + message kChunkSize { int32 kChunkSize = 1; } message Key { int32 Key = 1; } message keyField { int32 keyField = 1; } + message keyFieldOpt { int32 keyFieldOpt = 1; } message KeyType { int32 KeyType = 1; } message kind { int32 kind = 1; } message l { int32 l = 1; } @@ -500,42 +612,44 @@ message GeneratedSwiftReservedMessages { message lessThan { int32 lessThan = 1; } message let { int32 let = 1; } message lhs { int32 lhs = 1; } + message line { int32 line = 1; } message list { int32 list = 1; } message listOfMessages { int32 listOfMessages = 1; } message listValue { int32 listValue = 1; } message littleEndian { int32 littleEndian = 1; } - message littleEndianBytes { int32 littleEndianBytes = 1; } message load { int32 load = 1; } message localHasher { int32 localHasher = 1; } message location { int32 location = 1; } message M { int32 M = 1; } message major { int32 major = 1; } + message makeAsyncIterator { int32 makeAsyncIterator = 1; } message makeIterator { int32 makeIterator = 1; } + message malformedLength { int32 malformedLength = 1; } message mapEntry { int32 mapEntry = 1; } - message mapHash { int32 mapHash = 1; } message MapKeyType { int32 MapKeyType = 1; } - message mapNameResolver { int32 mapNameResolver = 1; } message mapToMessages { int32 mapToMessages = 1; } message MapValueType { int32 MapValueType = 1; } message mapVisitor { int32 mapVisitor = 1; } + message mask { int32 mask = 1; } + message maximumEdition { int32 maximumEdition = 1; } message mdayStart { int32 mdayStart = 1; } message merge { int32 merge = 1; } + message MergeOptions { int32 MergeOptions = 1; } message message { int32 message = 1; } message messageDepthLimit { int32 messageDepthLimit = 1; } + message messageEncoding { int32 messageEncoding = 1; } message MessageExtension { int32 MessageExtension = 1; } message MessageImplementationBase { int32 MessageImplementationBase = 1; } - message MessageOptions { int32 MessageOptions = 1; } message MessageSet { int32 MessageSet = 1; } message messageSetWireFormat { int32 messageSetWireFormat = 1; } + message messageSize { int32 messageSize = 1; } message messageType { int32 messageType = 1; } - message Method { int32 Method = 1; } - message MethodDescriptorProto { int32 MethodDescriptorProto = 1; } - message MethodOptions { int32 MethodOptions = 1; } + message method { int32 method = 1; } message methods { int32 methods = 1; } + message min { int32 min = 1; } + message minimumEdition { int32 minimumEdition = 1; } message minor { int32 minor = 1; } - message Mixin { int32 Mixin = 1; } message mixins { int32 mixins = 1; } - message modifier { int32 modifier = 1; } message modify { int32 modify = 1; } message month { int32 month = 1; } message msgExtension { int32 msgExtension = 1; } @@ -545,44 +659,53 @@ message GeneratedSwiftReservedMessages { message NameDescription { int32 NameDescription = 1; } message NameMap { int32 NameMap = 1; } message NamePart { int32 NamePart = 1; } - message nameResolver { int32 nameResolver = 1; } message names { int32 names = 1; } message nanos { int32 nanos = 1; } - message nativeBytes { int32 nativeBytes = 1; } - message nativeEndianBytes { int32 nativeEndianBytes = 1; } message negativeIntValue { int32 negativeIntValue = 1; } message nestedType { int32 nestedType = 1; } + message newExtensible { int32 newExtensible = 1; } message newL { int32 newL = 1; } message newList { int32 newList = 1; } + message newMessage { int32 newMessage = 1; } message newValue { int32 newValue = 1; } + message next { int32 next = 1; } message nextByte { int32 nextByte = 1; } message nextFieldNumber { int32 nextFieldNumber = 1; } + message nextInstruction { int32 nextInstruction = 1; } + message nextInt32 { int32 nextInt32 = 1; } + message nextNullTerminatedString { int32 nextNullTerminatedString = 1; } + message nextNullTerminatedStringArray { int32 nextNullTerminatedStringArray = 1; } + message nextNumber { int32 nextNumber = 1; } + message nextUInt64 { int32 nextUInt64 = 1; } + message nextVarInt { int32 nextVarInt = 1; } message nil { int32 nil = 1; } message nilLiteral { int32 nilLiteral = 1; } + message noBytesAvailable { int32 noBytesAvailable = 1; } message noStandardDescriptorAccessor { int32 noStandardDescriptorAccessor = 1; } message nullValue { int32 nullValue = 1; } message number { int32 number = 1; } message numberValue { int32 numberValue = 1; } message objcClassPrefix { int32 objcClassPrefix = 1; } message of { int32 of = 1; } + message OneOf_Kind { int32 OneOf_Kind = 1; } message oneofDecl { int32 oneofDecl = 1; } - message OneofDescriptorProto { int32 OneofDescriptorProto = 1; } message oneofIndex { int32 oneofIndex = 1; } - message OneofOptions { int32 OneofOptions = 1; } message oneofs { int32 oneofs = 1; } - message OneOf_Kind { int32 OneOf_Kind = 1; } message optimizeFor { int32 optimizeFor = 1; } message OptimizeMode { int32 OptimizeMode = 1; } - message Option { int32 Option = 1; } message OptionalEnumExtensionField { int32 OptionalEnumExtensionField = 1; } message OptionalExtensionField { int32 OptionalExtensionField = 1; } message OptionalGroupExtensionField { int32 OptionalGroupExtensionField = 1; } message OptionalMessageExtensionField { int32 OptionalMessageExtensionField = 1; } + message optionDependency { int32 optionDependency = 1; } + message OptionRetention { int32 OptionRetention = 1; } message options { int32 options = 1; } + message OptionTargetType { int32 OptionTargetType = 1; } message other { int32 other = 1; } message others { int32 others = 1; } message out { int32 out = 1; } message outputType { int32 outputType = 1; } + message overridableFeatures { int32 overridableFeatures = 1; } message p { int32 p = 1; } message package { int32 package = 1; } message packed { int32 packed = 1; } @@ -593,27 +716,39 @@ message GeneratedSwiftReservedMessages { message parse { int32 parse = 1; } message partial { int32 partial = 1; } message path { int32 path = 1; } + message PathDecoder { int32 PathDecoder = 1; } + message PathDecodingError { int32 PathDecodingError = 1; } message paths { int32 paths = 1; } + message PathVisitor { int32 PathVisitor = 1; } message payload { int32 payload = 1; } message payloadSize { int32 payloadSize = 1; } message phpClassPrefix { int32 phpClassPrefix = 1; } - message phpGenericServices { int32 phpGenericServices = 1; } message phpMetadataNamespace { int32 phpMetadataNamespace = 1; } message phpNamespace { int32 phpNamespace = 1; } - message pointer { int32 pointer = 1; } message pos { int32 pos = 1; } message positiveIntValue { int32 positiveIntValue = 1; } message prefix { int32 prefix = 1; } message preserveProtoFieldNames { int32 preserveProtoFieldNames = 1; } message preTraverse { int32 preTraverse = 1; } + message previousNumber { int32 previousNumber = 1; } + message prevPath { int32 prevPath = 1; } message printUnknownFields { int32 printUnknownFields = 1; } + message programBuffer { int32 programBuffer = 1; } + message programFormat { int32 programFormat = 1; } message proto2 { int32 proto2 = 1; } message proto3DefaultValue { int32 proto3DefaultValue = 1; } message proto3Optional { int32 proto3Optional = 1; } - message ProtobufAPIVersionCheck { int32 ProtobufAPIVersionCheck = 1; } + message protobuf_extensionFieldValues { int32 protobuf_extensionFieldValues = 1; } + message protobuf_fieldNumber { int32 protobuf_fieldNumber = 1; } + message protobuf_generated_isEqualTo { int32 protobuf_generated_isEqualTo = 1; } + message protobuf_nameMap { int32 protobuf_nameMap = 1; } + message protobuf_newField { int32 protobuf_newField = 1; } + message protobuf_package { int32 protobuf_package = 1; } message ProtobufAPIVersion_2 { int32 ProtobufAPIVersion_2 = 1; } + message ProtobufAPIVersionCheck { int32 ProtobufAPIVersionCheck = 1; } message ProtobufBool { int32 ProtobufBool = 1; } message ProtobufBytes { int32 ProtobufBytes = 1; } + message protobufData { int32 protobufData = 1; } message ProtobufDouble { int32 ProtobufDouble = 1; } message ProtobufEnumMap { int32 ProtobufEnumMap = 1; } message protobufExtension { int32 protobufExtension = 1; } @@ -631,12 +766,6 @@ message GeneratedSwiftReservedMessages { message ProtobufString { int32 ProtobufString = 1; } message ProtobufUInt32 { int32 ProtobufUInt32 = 1; } message ProtobufUInt64 { int32 ProtobufUInt64 = 1; } - message protobuf_extensionFieldValues { int32 protobuf_extensionFieldValues = 1; } - message protobuf_fieldNumber { int32 protobuf_fieldNumber = 1; } - message protobuf_generated_isEqualTo { int32 protobuf_generated_isEqualTo = 1; } - message protobuf_nameMap { int32 protobuf_nameMap = 1; } - message protobuf_newField { int32 protobuf_newField = 1; } - message protobuf_package { int32 protobuf_package = 1; } message protocol { int32 protocol = 1; } message protoFieldName { int32 protoFieldName = 1; } message protoMessageName { int32 protoMessageName = 1; } @@ -658,25 +787,33 @@ message GeneratedSwiftReservedMessages { message putVarInt { int32 putVarInt = 1; } message putZigZagVarInt { int32 putZigZagVarInt = 1; } message pyGenericServices { int32 pyGenericServices = 1; } + message R { int32 R = 1; } message rawChars { int32 rawChars = 1; } message RawRepresentable { int32 RawRepresentable = 1; } message RawValue { int32 RawValue = 1; } message read4HexDigits { int32 read4HexDigits = 1; } + message readBytes { int32 readBytes = 1; } + message reader { int32 reader = 1; } message register { int32 register = 1; } + message remainingProgram { int32 remainingProgram = 1; } + message removalError { int32 removalError = 1; } + message removingAllFieldsOf { int32 removingAllFieldsOf = 1; } + message repeated { int32 repeated = 1; } message RepeatedEnumExtensionField { int32 RepeatedEnumExtensionField = 1; } message RepeatedExtensionField { int32 RepeatedExtensionField = 1; } + message repeatedFieldEncoding { int32 repeatedFieldEncoding = 1; } message RepeatedGroupExtensionField { int32 RepeatedGroupExtensionField = 1; } message RepeatedMessageExtensionField { int32 RepeatedMessageExtensionField = 1; } + message repeating { int32 repeating = 1; } + message replaceRepeatedFields { int32 replaceRepeatedFields = 1; } message requestStreaming { int32 requestStreaming = 1; } message requestTypeURL { int32 requestTypeURL = 1; } message requiredSize { int32 requiredSize = 1; } - message reservedName { int32 reservedName = 1; } - message reservedRange { int32 reservedRange = 1; } message responseStreaming { int32 responseStreaming = 1; } message responseTypeURL { int32 responseTypeURL = 1; } message result { int32 result = 1; } + message retention { int32 retention = 1; } message rethrows { int32 rethrows = 1; } - message return { int32 return = 1; } message ReturnType { int32 ReturnType = 1; } message revision { int32 revision = 1; } message rhs { int32 rhs = 1; } @@ -686,27 +823,32 @@ message GeneratedSwiftReservedMessages { message sawBackslash { int32 sawBackslash = 1; } message sawSection4Characters { int32 sawSection4Characters = 1; } message sawSection5Characters { int32 sawSection5Characters = 1; } + message Scalar { int32 Scalar = 1; } + message scan { int32 scan = 1; } message scanner { int32 scanner = 1; } message seconds { int32 seconds = 1; } message self { int32 self = 1; } + message semantic { int32 semantic = 1; } + message Sendable { int32 Sendable = 1; } message separator { int32 separator = 1; } message serialize { int32 serialize = 1; } + message serializedBytes { int32 serializedBytes = 1; } message serializedData { int32 serializedData = 1; } message serializedSize { int32 serializedSize = 1; } message serverStreaming { int32 serverStreaming = 1; } message service { int32 service = 1; } - message ServiceDescriptorProto { int32 ServiceDescriptorProto = 1; } - message ServiceOptions { int32 ServiceOptions = 1; } message set { int32 set = 1; } message setExtensionValue { int32 setExtensionValue = 1; } message shift { int32 shift = 1; } message SimpleExtensionMap { int32 SimpleExtensionMap = 1; } + message size { int32 size = 1; } message sizer { int32 sizer = 1; } message source { int32 source = 1; } message sourceCodeInfo { int32 sourceCodeInfo = 1; } message sourceContext { int32 sourceContext = 1; } message sourceEncoding { int32 sourceEncoding = 1; } message sourceFile { int32 sourceFile = 1; } + message SourceLocation { int32 SourceLocation = 1; } message span { int32 span = 1; } message split { int32 split = 1; } message start { int32 start = 1; } @@ -730,13 +872,16 @@ message GeneratedSwiftReservedMessages { message structValue { int32 structValue = 1; } message subDecoder { int32 subDecoder = 1; } message subscript { int32 subscript = 1; } + message subtract { int32 subtract = 1; } message subVisitor { int32 subVisitor = 1; } message Swift { int32 Swift = 1; } message swiftPrefix { int32 swiftPrefix = 1; } - message SwiftProtobuf { int32 SwiftProtobuf = 1; } + message SwiftProtobufContiguousBytes { int32 SwiftProtobufContiguousBytes = 1; } + message SwiftProtobufError { int32 SwiftProtobufError = 1; } message syntax { int32 syntax = 1; } message T { int32 T = 1; } message tag { int32 tag = 1; } + message targets { int32 targets = 1; } message terminator { int32 terminator = 1; } message testDecoder { int32 testDecoder = 1; } message text { int32 text = 1; } @@ -747,16 +892,19 @@ message GeneratedSwiftReservedMessages { message TextFormatEncodingOptions { int32 TextFormatEncodingOptions = 1; } message TextFormatEncodingVisitor { int32 TextFormatEncodingVisitor = 1; } message textFormatString { int32 textFormatString = 1; } + message throwOrIgnore { int32 throwOrIgnore = 1; } message throws { int32 throws = 1; } message timeInterval { int32 timeInterval = 1; } message timeIntervalSince1970 { int32 timeIntervalSince1970 = 1; } message timeIntervalSinceReferenceDate { int32 timeIntervalSinceReferenceDate = 1; } - message Timestamp { int32 Timestamp = 1; } + message tmp { int32 tmp = 1; } + message tooLarge { int32 tooLarge = 1; } message total { int32 total = 1; } message totalArrayDepth { int32 totalArrayDepth = 1; } message totalSize { int32 totalSize = 1; } message trailingComments { int32 trailingComments = 1; } message traverse { int32 traverse = 1; } + message trim { int32 trim = 1; } message true { int32 true = 1; } message try { int32 try = 1; } message type { int32 type = 1; } @@ -768,10 +916,10 @@ message GeneratedSwiftReservedMessages { message typeUnknown { int32 typeUnknown = 1; } message typeURL { int32 typeURL = 1; } message UInt32 { int32 UInt32 = 1; } - message UInt32Value { int32 UInt32Value = 1; } message UInt64 { int32 UInt64 = 1; } - message UInt64Value { int32 UInt64Value = 1; } message UInt8 { int32 UInt8 = 1; } + message unchecked { int32 unchecked = 1; } + message Unicode { int32 Unicode = 1; } message unicodeScalarLiteral { int32 unicodeScalarLiteral = 1; } message UnicodeScalarLiteralType { int32 UnicodeScalarLiteralType = 1; } message unicodeScalars { int32 unicodeScalars = 1; } @@ -786,27 +934,34 @@ message GeneratedSwiftReservedMessages { message UnsafeBufferPointer { int32 UnsafeBufferPointer = 1; } message UnsafeMutablePointer { int32 UnsafeMutablePointer = 1; } message UnsafeMutableRawBufferPointer { int32 UnsafeMutableRawBufferPointer = 1; } - message UnsafeMutableRawPointer { int32 UnsafeMutableRawPointer = 1; } message UnsafeRawBufferPointer { int32 UnsafeRawBufferPointer = 1; } message UnsafeRawPointer { int32 UnsafeRawPointer = 1; } + message unverifiedLazy { int32 unverifiedLazy = 1; } message updatedOptions { int32 updatedOptions = 1; } + message uppercasedAssumingASCII { int32 uppercasedAssumingASCII = 1; } message url { int32 url = 1; } + message useDeterministicOrdering { int32 useDeterministicOrdering = 1; } message utf8 { int32 utf8 = 1; } message utf8Ptr { int32 utf8Ptr = 1; } message utf8ToDouble { int32 utf8ToDouble = 1; } + message utf8Validation { int32 utf8Validation = 1; } message UTF8View { int32 UTF8View = 1; } - message v { int32 v = 1; } + message V { int32 V = 1; } message value { int32 value = 1; } message valueField { int32 valueField = 1; } message values { int32 values = 1; } message ValueType { int32 ValueType = 1; } message var { int32 var = 1; } - message Version { int32 Version = 1; } + message verification { int32 verification = 1; } + message VerificationState { int32 VerificationState = 1; } + message version { int32 version = 1; } message versionString { int32 versionString = 1; } + message visibility { int32 visibility = 1; } + message VisibilityFeature { int32 VisibilityFeature = 1; } message visitExtensionFields { int32 visitExtensionFields = 1; } message visitExtensionFieldsAsMessageSet { int32 visitExtensionFieldsAsMessageSet = 1; } message visitMapField { int32 visitMapField = 1; } - message visitor { int32 visitor = 1; } + message Visitor { int32 Visitor = 1; } message visitPacked { int32 visitPacked = 1; } message visitPackedBoolField { int32 visitPackedBoolField = 1; } message visitPackedDoubleField { int32 visitPackedDoubleField = 1; } @@ -861,6 +1016,7 @@ message GeneratedSwiftReservedMessages { message visitSingularUInt32Field { int32 visitSingularUInt32Field = 1; } message visitSingularUInt64Field { int32 visitSingularUInt64Field = 1; } message visitUnknown { int32 visitUnknown = 1; } + message Void { int32 Void = 1; } message wasDecoded { int32 wasDecoded = 1; } message weak { int32 weak = 1; } message weakDependency { int32 weakDependency = 1; } @@ -870,7 +1026,9 @@ message GeneratedSwiftReservedMessages { message withUnsafeBytes { int32 withUnsafeBytes = 1; } message withUnsafeMutableBytes { int32 withUnsafeMutableBytes = 1; } message work { int32 work = 1; } + message Wrapped { int32 Wrapped = 1; } message WrappedType { int32 WrappedType = 1; } + message wrappedValue { int32 wrappedValue = 1; } message written { int32 written = 1; } message yday { int32 yday = 1; } } diff --git a/Protos/google/protobuf/map_proto2_unittest.proto b/Protos/Tests/SwiftProtobufTests/map_proto2_unittest.proto similarity index 52% rename from Protos/google/protobuf/map_proto2_unittest.proto rename to Protos/Tests/SwiftProtobufTests/map_proto2_unittest.proto index 20d58f903..f8a82a41d 100644 --- a/Protos/google/protobuf/map_proto2_unittest.proto +++ b/Protos/Tests/SwiftProtobufTests/map_proto2_unittest.proto @@ -29,63 +29,58 @@ // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. syntax = "proto2"; -option cc_enable_arenas = true; -import "google/protobuf/unittest_import.proto"; +import "unittest_import.proto"; -// We don't put this in a package within proto2 because we need to make sure -// that the generated code doesn't depend on being in the proto2 namespace. -// In map_test_util.h we do "using namespace unittest = protobuf_unittest". -package protobuf_unittest; +package swift_proto_testing; enum Proto2MapEnum { - PROTO2_MAP_ENUM_FOO = 0; - PROTO2_MAP_ENUM_BAR = 1; - PROTO2_MAP_ENUM_BAZ = 2; + PROTO2_MAP_ENUM_FOO = 0; + PROTO2_MAP_ENUM_BAR = 1; + PROTO2_MAP_ENUM_BAZ = 2; } enum Proto2MapEnumPlusExtra { - E_PROTO2_MAP_ENUM_FOO = 0; - E_PROTO2_MAP_ENUM_BAR = 1; - E_PROTO2_MAP_ENUM_BAZ = 2; + E_PROTO2_MAP_ENUM_FOO = 0; + E_PROTO2_MAP_ENUM_BAR = 1; + E_PROTO2_MAP_ENUM_BAZ = 2; E_PROTO2_MAP_ENUM_EXTRA = 3; } message TestEnumMap { map known_map_field = 101; map unknown_map_field = 102; + + // Other maps with all key types to test the unknown entry serialization + map unknown_map_field_int64 = 200; + map unknown_map_field_uint64 = 201; + map unknown_map_field_int32 = 202; + map unknown_map_field_uint32 = 203; + map unknown_map_field_fixed32 = 204; + map unknown_map_field_fixed64 = 205; + map unknown_map_field_bool = 206; + map unknown_map_field_string = 207; + map unknown_map_field_sint32 = 208; + map unknown_map_field_sint64 = 209; + map unknown_map_field_sfixed32 = 210; + map unknown_map_field_sfixed64 = 211; } message TestEnumMapPlusExtra { map known_map_field = 101; map unknown_map_field = 102; -} - -message TestImportEnumMap { - map import_enum_amp = 1; -} - -message TestIntIntMap { - map m = 1; -} - -// Test all key types: string, plus the non-floating-point scalars. -message TestMaps { - map m_int32 = 1; - map m_int64 = 2; - map m_uint32 = 3; - map m_uint64 = 4; - map m_sint32 = 5; - map m_sint64 = 6; - map m_fixed32 = 7; - map m_fixed64 = 8; - map m_sfixed32 = 9; - map m_sfixed64 = 10; - map m_bool = 11; - map m_string = 12; -} -// Test maps in submessages. -message TestSubmessageMaps { - optional TestMaps m = 1; + // Other maps with all key types to test the unknown entry serialization + map unknown_map_field_int64 = 200; + map unknown_map_field_uint64 = 201; + map unknown_map_field_int32 = 202; + map unknown_map_field_uint32 = 203; + map unknown_map_field_fixed32 = 204; + map unknown_map_field_fixed64 = 205; + map unknown_map_field_bool = 206; + map unknown_map_field_string = 207; + map unknown_map_field_sint32 = 208; + map unknown_map_field_sint64 = 209; + map unknown_map_field_sfixed32 = 210; + map unknown_map_field_sfixed64 = 211; } diff --git a/Protos/google/protobuf/unittest_drop_unknown_fields.proto b/Protos/Tests/SwiftProtobufTests/map_unittest.proto similarity index 57% rename from Protos/google/protobuf/unittest_drop_unknown_fields.proto rename to Protos/Tests/SwiftProtobufTests/map_unittest.proto index 8aa3a37b8..475822b8f 100644 --- a/Protos/google/protobuf/unittest_drop_unknown_fields.proto +++ b/Protos/Tests/SwiftProtobufTests/map_unittest.proto @@ -30,29 +30,44 @@ syntax = "proto3"; -package unittest_drop_unknown_fields; -option objc_class_prefix = "DropUnknowns"; +import "unittest.proto"; -option csharp_namespace = "Google.Protobuf.TestProtos"; +package swift_proto_testing; -message Foo { - enum NestedEnum { - FOO = 0; - BAR = 1; - BAZ = 2; - } - int32 int32_value = 1; - NestedEnum enum_value = 2; +// Tests maps. +message TestMap { + map map_int32_int32 = 1; + map map_int64_int64 = 2; + map map_uint32_uint32 = 3; + map map_uint64_uint64 = 4; + map map_sint32_sint32 = 5; + map map_sint64_sint64 = 6; + map map_fixed32_fixed32 = 7; + map map_fixed64_fixed64 = 8; + map map_sfixed32_sfixed32 = 9; + map map_sfixed64_sfixed64 = 10; + map map_int32_float = 11; + map map_int32_double = 12; + map map_bool_bool = 13; + map map_string_string = 14; + map map_int32_bytes = 15; + map map_int32_enum = 16; + map map_int32_foreign_message = 17; + map map_string_foreign_message = 18; + map map_int32_all_types = 19; } -message FooWithExtraFields { - enum NestedEnum { - FOO = 0; - BAR = 1; - BAZ = 2; - QUX = 3; - } - int32 int32_value = 1; - NestedEnum enum_value = 2; - int32 extra_int32_value = 3; +enum MapEnum { + MAP_ENUM_FOO = 0; + MAP_ENUM_BAR = 1; + MAP_ENUM_BAZ = 2; +} + +// Test embedded message with required fields +message TestRequiredMessageMap { + map map_field = 1; +} + +message TestRecursiveMapMessage { + map a = 1; } diff --git a/Protos/Tests/SwiftProtobufTests/test_messages_proto3.proto b/Protos/Tests/SwiftProtobufTests/test_messages_proto3.proto new file mode 100644 index 000000000..0c454c345 --- /dev/null +++ b/Protos/Tests/SwiftProtobufTests/test_messages_proto3.proto @@ -0,0 +1,196 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +syntax = "proto3"; + +package swift_proto_testing.test3; + +import "google/protobuf/any.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/field_mask.proto"; +import "google/protobuf/struct.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/wrappers.proto"; + +// This proto includes every type of field in both singular and repeated +// forms. +// +// Also, crucially, all messages and enums in this file are eventually +// submessages of this message. So for example, a fuzz test of TestAllTypes +// could trigger bugs that occur in any message type in this file. We verify +// this stays true in a unit test. +message TestAllTypesProto3 { + message NestedMessage { + int32 a = 1; + TestAllTypesProto3 corecursive = 2; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + NEG = -1; // Intentionally negative. + } + + // Singular + int32 optional_int32 = 1; + int64 optional_int64 = 2; + uint32 optional_uint32 = 3; + uint64 optional_uint64 = 4; + sint32 optional_sint32 = 5; + sint64 optional_sint64 = 6; + fixed32 optional_fixed32 = 7; + fixed64 optional_fixed64 = 8; + sfixed32 optional_sfixed32 = 9; + sfixed64 optional_sfixed64 = 10; + float optional_float = 11; + double optional_double = 12; + bool optional_bool = 13; + string optional_string = 14; + bytes optional_bytes = 15; + + NestedMessage optional_nested_message = 18; + + NestedEnum optional_nested_enum = 21; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + + repeated NestedMessage repeated_nested_message = 48; + + repeated NestedEnum repeated_nested_enum = 51; + + // Map + map map_int32_int32 = 56; + map map_int64_int64 = 57; + map map_uint32_uint32 = 58; + map map_uint64_uint64 = 59; + map map_sint32_sint32 = 60; + map map_sint64_sint64 = 61; + map map_fixed32_fixed32 = 62; + map map_fixed64_fixed64 = 63; + map map_sfixed32_sfixed32 = 64; + map map_sfixed64_sfixed64 = 65; + map map_int32_float = 66; + map map_int32_double = 67; + map map_bool_bool = 68; + map map_string_string = 69; + map map_string_bytes = 70; + map map_string_nested_message = 71; + map map_string_nested_enum = 73; + + oneof oneof_field { + uint32 oneof_uint32 = 111; + NestedMessage oneof_nested_message = 112; + string oneof_string = 113; + bytes oneof_bytes = 114; + bool oneof_bool = 115; + uint64 oneof_uint64 = 116; + float oneof_float = 117; + double oneof_double = 118; + NestedEnum oneof_enum = 119; + google.protobuf.NullValue oneof_null_value = 120; + } + + // Well-known types + google.protobuf.BoolValue optional_bool_wrapper = 201; + google.protobuf.Int32Value optional_int32_wrapper = 202; + google.protobuf.Int64Value optional_int64_wrapper = 203; + google.protobuf.UInt32Value optional_uint32_wrapper = 204; + google.protobuf.UInt64Value optional_uint64_wrapper = 205; + google.protobuf.FloatValue optional_float_wrapper = 206; + google.protobuf.DoubleValue optional_double_wrapper = 207; + google.protobuf.StringValue optional_string_wrapper = 208; + google.protobuf.BytesValue optional_bytes_wrapper = 209; + + repeated google.protobuf.BoolValue repeated_bool_wrapper = 211; + repeated google.protobuf.Int32Value repeated_int32_wrapper = 212; + repeated google.protobuf.Int64Value repeated_int64_wrapper = 213; + repeated google.protobuf.UInt32Value repeated_uint32_wrapper = 214; + repeated google.protobuf.UInt64Value repeated_uint64_wrapper = 215; + repeated google.protobuf.FloatValue repeated_float_wrapper = 216; + repeated google.protobuf.DoubleValue repeated_double_wrapper = 217; + repeated google.protobuf.StringValue repeated_string_wrapper = 218; + repeated google.protobuf.BytesValue repeated_bytes_wrapper = 219; + + google.protobuf.Duration optional_duration = 301; + google.protobuf.Timestamp optional_timestamp = 302; + google.protobuf.FieldMask optional_field_mask = 303; + google.protobuf.Struct optional_struct = 304; + google.protobuf.Any optional_any = 305; + google.protobuf.Value optional_value = 306; + google.protobuf.NullValue optional_null_value = 307; + + repeated google.protobuf.Duration repeated_duration = 311; + repeated google.protobuf.Timestamp repeated_timestamp = 312; + repeated google.protobuf.FieldMask repeated_fieldmask = 313; + repeated google.protobuf.Struct repeated_struct = 324; + repeated google.protobuf.Any repeated_any = 315; + repeated google.protobuf.Value repeated_value = 316; + repeated google.protobuf.ListValue repeated_list_value = 317; + + // Test field-name-to-JSON-name convention. + // (protobuf says names can be any valid C/C++ identifier.) + int32 fieldname1 = 401; + int32 field_name2 = 402; + int32 _field_name3 = 403; + int32 field__name4_ = 404; + int32 field0name5 = 405; + int32 field_0_name6 = 406; + int32 fieldName7 = 407; + int32 FieldName8 = 408; + int32 field_Name9 = 409; + int32 Field_Name10 = 410; + int32 FIELD_NAME11 = 411; + int32 FIELD_name12 = 412; + int32 __field_name13 = 413; + int32 __Field_name14 = 414; + int32 field__name15 = 415; + int32 field__Name16 = 416; + int32 field_name17__ = 417; + int32 Field_name18__ = 418; + + // Reserved for testing unknown fields + reserved 501 to 510; +} diff --git a/Protos/google/protobuf/unittest.proto b/Protos/Tests/SwiftProtobufTests/unittest.proto similarity index 55% rename from Protos/google/protobuf/unittest.proto rename to Protos/Tests/SwiftProtobufTests/unittest.proto index 7dda92468..81b51f77d 100644 --- a/Protos/google/protobuf/unittest.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest.proto @@ -38,26 +38,9 @@ syntax = "proto2"; -// Some generic_services option(s) added automatically. -// See: http://go/proto2-generic-services-default -option cc_generic_services = true; // auto-added -option java_generic_services = true; // auto-added -option py_generic_services = true; // auto-added -option cc_enable_arenas = true; +import "unittest_import.proto"; -import "google/protobuf/unittest_import.proto"; - -// We don't put this in a package within proto2 because we need to make sure -// that the generated code doesn't depend on being in the proto2 namespace. -// In test_util.h we do "using namespace unittest = protobuf_unittest". -package protobuf_unittest; - -// Protos optimized for SPEED use a strict superset of the generated code -// of equivalent ones optimized for CODE_SIZE, so we should optimize all our -// tests for speed unless explicitly testing code size optimization. -option optimize_for = SPEED; - -option java_outer_classname = "UnittestProto"; +package swift_proto_testing; // This proto includes every type of field in both singular and repeated // forms. @@ -99,21 +82,16 @@ message TestAllTypes { optional NestedMessage optional_nested_message = 18; optional ForeignMessage optional_foreign_message = 19; - optional protobuf_unittest_import.ImportMessage optional_import_message = 20; + optional swift_proto_testing.import.ImportMessage optional_import_message = 20; optional NestedEnum optional_nested_enum = 21; optional ForeignEnum optional_foreign_enum = 22; - optional protobuf_unittest_import.ImportEnum optional_import_enum = 23; - - optional string optional_string_piece = 24 [ctype=STRING_PIECE]; - optional string optional_cord = 25 [ctype=CORD]; + optional swift_proto_testing.import.ImportEnum optional_import_enum = 23; // Defined in unittest_import_public.proto - optional protobuf_unittest_import.PublicImportMessage + optional swift_proto_testing.import.PublicImportMessage optional_public_import_message = 26; - optional NestedMessage optional_lazy_message = 27 [lazy=true]; - // Repeated repeated int32 repeated_int32 = 31; repeated int64 repeated_int64 = 32; @@ -137,16 +115,11 @@ message TestAllTypes { repeated NestedMessage repeated_nested_message = 48; repeated ForeignMessage repeated_foreign_message = 49; - repeated protobuf_unittest_import.ImportMessage repeated_import_message = 50; + repeated swift_proto_testing.import.ImportMessage repeated_import_message = 50; repeated NestedEnum repeated_nested_enum = 51; repeated ForeignEnum repeated_foreign_enum = 52; - repeated protobuf_unittest_import.ImportEnum repeated_import_enum = 53; - - repeated string repeated_string_piece = 54 [ctype=STRING_PIECE]; - repeated string repeated_cord = 55 [ctype=CORD]; - - repeated NestedMessage repeated_lazy_message = 57 [lazy=true]; + repeated swift_proto_testing.import.ImportEnum repeated_import_enum = 53; // Singular with defaults optional int32 default_int32 = 61 [default = 41 ]; @@ -167,12 +140,9 @@ message TestAllTypes { optional NestedEnum default_nested_enum = 81 [default = BAR ]; optional ForeignEnum default_foreign_enum = 82 [default = FOREIGN_BAR]; - optional protobuf_unittest_import.ImportEnum + optional swift_proto_testing.import.ImportEnum default_import_enum = 83 [default = IMPORT_BAR]; - optional string default_string_piece = 84 [ctype=STRING_PIECE,default="abc"]; - optional string default_cord = 85 [ctype=CORD,default="123"]; - // For oneof test oneof oneof_field { uint32 oneof_uint32 = 111; @@ -180,6 +150,13 @@ message TestAllTypes { string oneof_string = 113; bytes oneof_bytes = 114; } + + reserved "something_old", "reserved_field"; + reserved "something_long_gone"; + + reserved 1000010; + reserved 1000012; + reserved 999980 to 999989, 999998 to 999999, 1000011; } // This proto includes a recursively nested message. @@ -189,17 +166,6 @@ message NestedTestAllTypes { repeated NestedTestAllTypes repeated_child = 3; } -message TestDeprecatedFields { - optional int32 deprecated_int32 = 1 [deprecated=true]; - oneof oneof_fields { - int32 deprecated_int32_in_oneof = 2 [deprecated=true]; - } -} - -message TestDeprecatedMessage { - option deprecated = true; -} - // Define these after TestAllTypes to make sure the compiler can handle // that. message ForeignMessage { @@ -213,11 +179,6 @@ enum ForeignEnum { FOREIGN_BAZ = 6; } -message TestReservedFields { - reserved 2, 15, 9 to 11; - reserved "bar", "baz"; -} - message TestAllExtensions { extensions 1 to max; } @@ -246,23 +207,17 @@ extend TestAllExtensions { optional TestAllTypes.NestedMessage optional_nested_message_extension = 18; optional ForeignMessage optional_foreign_message_extension = 19; - optional protobuf_unittest_import.ImportMessage + optional swift_proto_testing.import.ImportMessage optional_import_message_extension = 20; optional TestAllTypes.NestedEnum optional_nested_enum_extension = 21; optional ForeignEnum optional_foreign_enum_extension = 22; - optional protobuf_unittest_import.ImportEnum + optional swift_proto_testing.import.ImportEnum optional_import_enum_extension = 23; - optional string optional_string_piece_extension = 24 [ctype=STRING_PIECE]; - optional string optional_cord_extension = 25 [ctype=CORD]; - - optional protobuf_unittest_import.PublicImportMessage + optional swift_proto_testing.import.PublicImportMessage optional_public_import_message_extension = 26; - optional TestAllTypes.NestedMessage - optional_lazy_message_extension = 27 [lazy=true]; - // Repeated repeated int32 repeated_int32_extension = 31; repeated int64 repeated_int64_extension = 32; @@ -286,20 +241,14 @@ extend TestAllExtensions { repeated TestAllTypes.NestedMessage repeated_nested_message_extension = 48; repeated ForeignMessage repeated_foreign_message_extension = 49; - repeated protobuf_unittest_import.ImportMessage + repeated swift_proto_testing.import.ImportMessage repeated_import_message_extension = 50; repeated TestAllTypes.NestedEnum repeated_nested_enum_extension = 51; repeated ForeignEnum repeated_foreign_enum_extension = 52; - repeated protobuf_unittest_import.ImportEnum + repeated swift_proto_testing.import.ImportEnum repeated_import_enum_extension = 53; - repeated string repeated_string_piece_extension = 54 [ctype=STRING_PIECE]; - repeated string repeated_cord_extension = 55 [ctype=CORD]; - - repeated TestAllTypes.NestedMessage - repeated_lazy_message_extension = 57 [lazy=true]; - // Singular with defaults optional int32 default_int32_extension = 61 [default = 41 ]; optional int64 default_int64_extension = 62 [default = 42 ]; @@ -321,13 +270,9 @@ extend TestAllExtensions { default_nested_enum_extension = 81 [default = BAR]; optional ForeignEnum default_foreign_enum_extension = 82 [default = FOREIGN_BAR]; - optional protobuf_unittest_import.ImportEnum + optional swift_proto_testing.import.ImportEnum default_import_enum_extension = 83 [default = IMPORT_BAR]; - optional string default_string_piece_extension = 84 [ctype=STRING_PIECE, - default="abc"]; - optional string default_cord_extension = 85 [ctype=CORD, default="123"]; - // For oneof test optional uint32 oneof_uint32_extension = 111; optional TestAllTypes.NestedMessage oneof_nested_message_extension = 112; @@ -335,17 +280,6 @@ extend TestAllExtensions { optional bytes oneof_bytes_extension = 114; } -message TestGroup { - optional group OptionalGroup = 16 { - optional int32 a = 17; - } - optional ForeignEnum optional_foreign_enum = 22; -} - -message TestGroupExtension { - extensions 1 to max; -} - message TestNestedExtension { extend TestAllExtensions { // Check for bug where string extensions declared in tested scope did not @@ -355,19 +289,6 @@ message TestNestedExtension { // underscores. optional string nested_string_extension = 1003; } - - extend TestGroupExtension { - optional group OptionalGroup_extension = 16 { - optional int32 a = 17; - } - optional ForeignEnum optional_foreign_enum_extension = 22; - } -} - -message TestChildExtension { - optional string a = 1; - optional string b = 2; - optional TestAllExtensions optional_extension = 3; } // We have separate messages for testing required fields because it's @@ -418,6 +339,8 @@ message TestRequired { optional int32 dummy32 = 32; required int32 c = 33; + + optional ForeignMessage optional_foreign = 34; } message TestRequiredForeign { @@ -432,37 +355,10 @@ message TestRequiredMessage { required TestRequired required_message = 3; } -// Test that we can use NestedMessage from outside TestAllTypes. -message TestForeignNested { - optional TestAllTypes.NestedMessage foreign_nested = 1; -} - // TestEmptyMessage is used to test unknown field support. message TestEmptyMessage { } -// Like above, but declare all field numbers as potential extensions. No -// actual extensions should ever be defined for this type. -message TestEmptyMessageWithExtensions { - extensions 1 to max; -} - -// Needed for a Python test. -message TestPickleNestedMessage { - message NestedMessage { - optional int32 bb = 1; - message NestedNestedMessage { - optional int32 cc = 1; - } - } -} - -message TestMultipleExtensionRanges { - extensions 42; - extensions 4143 to 4243; - extensions 65536 to max; -} - // Test that really large tag numbers don't break anything. message TestReallyLargeTagNumber { // The largest possible tag number is 2^28 - 1, since the wire format uses @@ -476,60 +372,6 @@ message TestRecursiveMessage { optional int32 i = 2; } -// Test that mutual recursion works. -message TestMutualRecursionA { - message SubMessage { - optional TestMutualRecursionB b = 1; - } - optional TestMutualRecursionB bb = 1; - optional group SubGroup = 2 { - optional SubMessage sub_message = 3; // Needed because of bug in javatest - optional TestAllTypes not_in_this_scc = 4; - } -} - -message TestMutualRecursionB { - optional TestMutualRecursionA a = 1; - optional int32 optional_int32 = 2; -} - -message TestIsInitialized { - message SubMessage { - optional group SubGroup = 1 { - required int32 i = 2; - } - } - optional SubMessage sub_message = 1; -} - -// Test that groups have disjoint field numbers from their siblings and -// parents. This is NOT possible in proto1; only google.protobuf. When attempting -// to compile with proto1, this will emit an error; so we only include it -// in protobuf_unittest_proto. -message TestDupFieldNumber { // NO_PROTO1 - optional int32 a = 1; // NO_PROTO1 - optional group Foo = 2 { optional int32 a = 1; } // NO_PROTO1 - optional group Bar = 3 { optional int32 a = 1; } // NO_PROTO1 -} // NO_PROTO1 - -// Additional messages for testing lazy fields. -message TestEagerMessage { - optional TestAllTypes sub_message = 1 [lazy=false]; -} -message TestLazyMessage { - optional TestAllTypes sub_message = 1 [lazy=true]; -} - -// Needed for a Python test. -message TestNestedMessageHasBits { - message NestedMessage { - repeated int32 nestedmessage_repeated_int32 = 1; - repeated ForeignMessage nestedmessage_repeated_foreignmessage = 2; - } - optional NestedMessage optional_nested_message = 1; -} - - // Test an enum that has multiple values with the same number. enum TestEnumWithDupValue { option allow_alias = true; @@ -541,36 +383,6 @@ enum TestEnumWithDupValue { BAR2 = 2; } -// Test an enum with large, unordered values. -enum TestSparseEnum { - SPARSE_A = 123; - SPARSE_B = 62374; - SPARSE_C = 12589234; - SPARSE_D = -15; - SPARSE_E = -53452; - SPARSE_F = 0; - SPARSE_G = 2; -} - -// Test message with CamelCase field names. This violates Protocol Buffer -// standard style. -message TestCamelCaseFieldNames { - optional int32 PrimitiveField = 1; - optional string StringField = 2; - optional ForeignEnum EnumField = 3; - optional ForeignMessage MessageField = 4; - optional string StringPieceField = 5 [ctype=STRING_PIECE]; - optional string CordField = 6 [ctype=CORD]; - - repeated int32 RepeatedPrimitiveField = 7; - repeated string RepeatedStringField = 8; - repeated ForeignEnum RepeatedEnumField = 9; - repeated ForeignMessage RepeatedMessageField = 10; - repeated string RepeatedStringPieceField = 11 [ctype=STRING_PIECE]; - repeated string RepeatedCordField = 12 [ctype=CORD]; -} - - // We list fields out of order, to ensure that we're using field number and not // field index to determine serialization order. message TestFieldOrderings { @@ -595,26 +407,6 @@ extend TestFieldOrderings { optional int32 my_extension_int = 5; } -message TestExtensionOrderings1 { - extend TestFieldOrderings { - optional TestExtensionOrderings1 test_ext_orderings1 = 13; - } - optional string my_string = 1; -} - -message TestExtensionOrderings2 { - extend TestFieldOrderings { - optional TestExtensionOrderings2 test_ext_orderings2 = 12; - } - message TestExtensionOrderings3 { - extend TestFieldOrderings { - optional TestExtensionOrderings3 test_ext_orderings3 = 14; - } - optional string my_string = 1; - } - optional string my_string = 1; -} - message TestExtremeDefaultValues { optional bytes escaped_bytes = 1 [default = "\0\001\a\b\f\n\r\t\v\\\'\"\xfe"]; optional uint32 large_uint32 = 2 [default = 0xFFFFFFFF]; @@ -657,55 +449,9 @@ message TestExtremeDefaultValues { // String defaults containing the character '\000' optional string string_with_zero = 23 [default = "hel\000lo"]; optional bytes bytes_with_zero = 24 [default = "wor\000ld"]; - optional string string_piece_with_zero = 25 [ctype=STRING_PIECE, - default="ab\000c"]; - optional string cord_with_zero = 26 [ctype=CORD, - default="12\0003"]; optional string replacement_string = 27 [default="${unknown}"]; } -message SparseEnumMessage { - optional TestSparseEnum sparse_enum = 1; -} - -// Test String and Bytes: string is for valid UTF-8 strings -message OneString { - optional string data = 1; -} - -message MoreString { - repeated string data = 1; -} - -message OneBytes { - optional bytes data = 1; -} - -message MoreBytes { - repeated bytes data = 1; -} - -// Test int32, uint32, int64, uint64, and bool are all compatible -message Int32Message { - optional int32 data = 1; -} - -message Uint32Message { - optional uint32 data = 1; -} - -message Int64Message { - optional int64 data = 1; -} - -message Uint64Message { - optional uint64 data = 1; -} - -message BoolMessage { - optional bool data = 1; -} - // Test oneofs. message TestOneof { oneof foo { @@ -719,60 +465,6 @@ message TestOneof { } } -message TestOneofBackwardsCompatible { - optional int32 foo_int = 1; - optional string foo_string = 2; - optional TestAllTypes foo_message = 3; - optional group FooGroup = 4 { - optional int32 a = 5; - optional string b = 6; - } -} - -message TestOneof2 { - oneof foo { - int32 foo_int = 1; - string foo_string = 2; - string foo_cord = 3 [ctype=CORD]; - string foo_string_piece = 4 [ctype=STRING_PIECE]; - bytes foo_bytes = 5; - NestedEnum foo_enum = 6; - NestedMessage foo_message = 7; - group FooGroup = 8 { - optional int32 a = 9; - optional string b = 10; - } - NestedMessage foo_lazy_message = 11 [lazy=true]; - } - - oneof bar { - int32 bar_int = 12 [default = 5]; - string bar_string = 13 [default = "STRING"]; - string bar_cord = 14 [ctype=CORD, default = "CORD"]; - string bar_string_piece = 15 [ctype=STRING_PIECE, default = "SPIECE"]; - bytes bar_bytes = 16 [default = "BYTES"]; - NestedEnum bar_enum = 17 [default = BAR]; - string bar_string_with_empty_default = 20 [default = ""]; - string bar_cord_with_empty_default = 21 [ctype=CORD, default = ""]; - string bar_string_piece_with_empty_default = 22 [ctype=STRING_PIECE, default = ""]; - bytes bar_bytes_with_empty_default = 23 [default = ""]; - } - - optional int32 baz_int = 18; - optional string baz_string = 19 [default = "BAZ"]; - - message NestedMessage { - optional int64 qux_int = 1; - repeated int32 corge_int = 2; - } - - enum NestedEnum { - FOO = 1; - BAR = 2; - BAZ = 3; - } -} - message TestRequiredOneof { oneof foo { int32 foo_int = 1; @@ -784,7 +476,6 @@ message TestRequiredOneof { } } - // Test messages for packed fields message TestPackedTypes { @@ -844,68 +535,6 @@ extend TestPackedExtensions { repeated ForeignEnum packed_enum_extension = 103 [packed = true]; } -message TestUnpackedExtensions { - extensions 1 to max; -} - -extend TestUnpackedExtensions { - repeated int32 unpacked_int32_extension = 90 [packed = false]; - repeated int64 unpacked_int64_extension = 91 [packed = false]; - repeated uint32 unpacked_uint32_extension = 92 [packed = false]; - repeated uint64 unpacked_uint64_extension = 93 [packed = false]; - repeated sint32 unpacked_sint32_extension = 94 [packed = false]; - repeated sint64 unpacked_sint64_extension = 95 [packed = false]; - repeated fixed32 unpacked_fixed32_extension = 96 [packed = false]; - repeated fixed64 unpacked_fixed64_extension = 97 [packed = false]; - repeated sfixed32 unpacked_sfixed32_extension = 98 [packed = false]; - repeated sfixed64 unpacked_sfixed64_extension = 99 [packed = false]; - repeated float unpacked_float_extension = 100 [packed = false]; - repeated double unpacked_double_extension = 101 [packed = false]; - repeated bool unpacked_bool_extension = 102 [packed = false]; - repeated ForeignEnum unpacked_enum_extension = 103 [packed = false]; -} - -// Used by ExtensionSetTest/DynamicExtensions. The test actually builds -// a set of extensions to TestAllExtensions dynamically, based on the fields -// of this message type. -message TestDynamicExtensions { - enum DynamicEnumType { - DYNAMIC_FOO = 2200; - DYNAMIC_BAR = 2201; - DYNAMIC_BAZ = 2202; - } - message DynamicMessageType { - optional int32 dynamic_field = 2100; - } - - optional fixed32 scalar_extension = 2000; - optional ForeignEnum enum_extension = 2001; - optional DynamicEnumType dynamic_enum_extension = 2002; - - optional ForeignMessage message_extension = 2003; - optional DynamicMessageType dynamic_message_extension = 2004; - - repeated string repeated_extension = 2005; - repeated sint32 packed_extension = 2006 [packed = true]; -} - -message TestRepeatedScalarDifferentTagSizes { - // Parsing repeated fixed size values used to fail. This message needs to be - // used in order to get a tag of the right size; all of the repeated fields - // in TestAllTypes didn't trigger the check. - repeated fixed32 repeated_fixed32 = 12; - // Check for a varint type, just for good measure. - repeated int32 repeated_int32 = 13; - - // These have two-byte tags. - repeated fixed64 repeated_fixed64 = 2046; - repeated int64 repeated_int64 = 2047; - - // Three byte tags. - repeated float repeated_float = 262142; - repeated uint64 repeated_uint64 = 262143; -} - // Test that if an optional or required message/group field appears multiple // times in the input, they need to be merged. message TestParsingMerge { @@ -942,217 +571,3 @@ message TestParsingMerge { repeated TestAllTypes repeated_ext = 1001; } } - -message TestCommentInjectionMessage { - // */ <- This should not close the generated doc comment - optional string a = 1 [default="*/ <- Neither should this."]; -} - - -// Test that RPC services work. -message FooRequest {} -message FooResponse {} - -message FooClientMessage {} -message FooServerMessage{} - -service TestService { - rpc Foo(FooRequest) returns (FooResponse); - rpc Bar(BarRequest) returns (BarResponse); -} - - -message BarRequest {} -message BarResponse {} - -message TestJsonName { - optional int32 field_name1 = 1; - optional int32 fieldName2 = 2; - optional int32 FieldName3 = 3; - optional int32 _field_name4 = 4; - optional int32 FIELD_NAME5 = 5; - optional int32 field_name6 = 6 [json_name = "@type"]; - optional int32 fieldname7 = 7; -} - -message TestHugeFieldNumbers { - optional int32 optional_int32 = 536870000; - optional int32 fixed_32 = 536870001; - repeated int32 repeated_int32 = 536870002 [packed = false]; - repeated int32 packed_int32 = 536870003 [packed = true]; - - optional ForeignEnum optional_enum = 536870004; - optional string optional_string = 536870005; - optional bytes optional_bytes = 536870006; - optional ForeignMessage optional_message = 536870007; - - optional group OptionalGroup = 536870008 { - optional int32 group_a = 536870009; - } - - map string_string_map = 536870010; - - oneof oneof_field { - uint32 oneof_uint32 = 536870011; - TestAllTypes oneof_test_all_types = 536870012; - string oneof_string = 536870013; - bytes oneof_bytes = 536870014; - } - - extensions 536860000 to 536869999; -} - -extend TestHugeFieldNumbers { - optional TestAllTypes test_all_types = 536860000; -} - -message TestExtensionInsideTable { - optional int32 field1 = 1; - optional int32 field2 = 2; - optional int32 field3 = 3; - optional int32 field4 = 4; - extensions 5 to 5; - optional int32 field6 = 6; - optional int32 field7 = 7; - optional int32 field8 = 8; - optional int32 field9 = 9; - optional int32 field10 = 10; -} - -extend TestExtensionInsideTable { - optional int32 test_extension_inside_table_extension = 5; -} - -enum VeryLargeEnum { - ENUM_LABEL_DEFAULT = 0; - ENUM_LABEL_1 = 1; - ENUM_LABEL_2 = 2; - ENUM_LABEL_3 = 3; - ENUM_LABEL_4 = 4; - ENUM_LABEL_5 = 5; - ENUM_LABEL_6 = 6; - ENUM_LABEL_7 = 7; - ENUM_LABEL_8 = 8; - ENUM_LABEL_9 = 9; - ENUM_LABEL_10 = 10; - ENUM_LABEL_11 = 11; - ENUM_LABEL_12 = 12; - ENUM_LABEL_13 = 13; - ENUM_LABEL_14 = 14; - ENUM_LABEL_15 = 15; - ENUM_LABEL_16 = 16; - ENUM_LABEL_17 = 17; - ENUM_LABEL_18 = 18; - ENUM_LABEL_19 = 19; - ENUM_LABEL_20 = 20; - ENUM_LABEL_21 = 21; - ENUM_LABEL_22 = 22; - ENUM_LABEL_23 = 23; - ENUM_LABEL_24 = 24; - ENUM_LABEL_25 = 25; - ENUM_LABEL_26 = 26; - ENUM_LABEL_27 = 27; - ENUM_LABEL_28 = 28; - ENUM_LABEL_29 = 29; - ENUM_LABEL_30 = 30; - ENUM_LABEL_31 = 31; - ENUM_LABEL_32 = 32; - ENUM_LABEL_33 = 33; - ENUM_LABEL_34 = 34; - ENUM_LABEL_35 = 35; - ENUM_LABEL_36 = 36; - ENUM_LABEL_37 = 37; - ENUM_LABEL_38 = 38; - ENUM_LABEL_39 = 39; - ENUM_LABEL_40 = 40; - ENUM_LABEL_41 = 41; - ENUM_LABEL_42 = 42; - ENUM_LABEL_43 = 43; - ENUM_LABEL_44 = 44; - ENUM_LABEL_45 = 45; - ENUM_LABEL_46 = 46; - ENUM_LABEL_47 = 47; - ENUM_LABEL_48 = 48; - ENUM_LABEL_49 = 49; - ENUM_LABEL_50 = 50; - ENUM_LABEL_51 = 51; - ENUM_LABEL_52 = 52; - ENUM_LABEL_53 = 53; - ENUM_LABEL_54 = 54; - ENUM_LABEL_55 = 55; - ENUM_LABEL_56 = 56; - ENUM_LABEL_57 = 57; - ENUM_LABEL_58 = 58; - ENUM_LABEL_59 = 59; - ENUM_LABEL_60 = 60; - ENUM_LABEL_61 = 61; - ENUM_LABEL_62 = 62; - ENUM_LABEL_63 = 63; - ENUM_LABEL_64 = 64; - ENUM_LABEL_65 = 65; - ENUM_LABEL_66 = 66; - ENUM_LABEL_67 = 67; - ENUM_LABEL_68 = 68; - ENUM_LABEL_69 = 69; - ENUM_LABEL_70 = 70; - ENUM_LABEL_71 = 71; - ENUM_LABEL_72 = 72; - ENUM_LABEL_73 = 73; - ENUM_LABEL_74 = 74; - ENUM_LABEL_75 = 75; - ENUM_LABEL_76 = 76; - ENUM_LABEL_77 = 77; - ENUM_LABEL_78 = 78; - ENUM_LABEL_79 = 79; - ENUM_LABEL_80 = 80; - ENUM_LABEL_81 = 81; - ENUM_LABEL_82 = 82; - ENUM_LABEL_83 = 83; - ENUM_LABEL_84 = 84; - ENUM_LABEL_85 = 85; - ENUM_LABEL_86 = 86; - ENUM_LABEL_87 = 87; - ENUM_LABEL_88 = 88; - ENUM_LABEL_89 = 89; - ENUM_LABEL_90 = 90; - ENUM_LABEL_91 = 91; - ENUM_LABEL_92 = 92; - ENUM_LABEL_93 = 93; - ENUM_LABEL_94 = 94; - ENUM_LABEL_95 = 95; - ENUM_LABEL_96 = 96; - ENUM_LABEL_97 = 97; - ENUM_LABEL_98 = 98; - ENUM_LABEL_99 = 99; - ENUM_LABEL_100 = 100; -}; - -message TestExtensionRangeSerialize { - optional int32 foo_one = 1; - - extensions 2 to 2; - extensions 3 to 4; - - optional int32 foo_two = 6; - optional int32 foo_three = 7; - - extensions 9 to 10; - - optional int32 foo_four = 13; - - extensions 15 to 15; - extensions 17 to 17; - extensions 19 to 19; - - extend TestExtensionRangeSerialize { - optional int32 bar_one = 2; - optional int32 bar_two = 4; - - optional int32 bar_three = 10; - - optional int32 bar_four = 15; - optional int32 bar_five = 19; - } -} - - diff --git a/Protos/google/protobuf/unittest_empty.proto b/Protos/Tests/SwiftProtobufTests/unittest_import.proto similarity index 85% rename from Protos/google/protobuf/unittest_empty.proto rename to Protos/Tests/SwiftProtobufTests/unittest_import.proto index 36443e7e0..da8be7d9d 100644 --- a/Protos/google/protobuf/unittest_empty.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_import.proto @@ -32,7 +32,21 @@ // Based on original Protocol Buffers design by // Sanjay Ghemawat, Jeff Dean, and others. // -// This file intentionally left blank. (At one point this wouldn't compile -// correctly.) +// A proto file which is imported by unittest.proto to test importing. syntax = "proto2"; + +package swift_proto_testing.import; + +// Test public import +import public "unittest_import_public.proto"; + +message ImportMessage { + optional int32 d = 1; +} + +enum ImportEnum { + IMPORT_FOO = 7; + IMPORT_BAR = 8; + IMPORT_BAZ = 9; +} diff --git a/Protos/google/protobuf/unittest_import_public.proto b/Protos/Tests/SwiftProtobufTests/unittest_import_public.proto similarity index 95% rename from Protos/google/protobuf/unittest_import_public.proto rename to Protos/Tests/SwiftProtobufTests/unittest_import_public.proto index ffaf77369..a38398fe4 100644 --- a/Protos/google/protobuf/unittest_import_public.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_import_public.proto @@ -32,9 +32,7 @@ syntax = "proto2"; -package protobuf_unittest_import; - -option java_package = "com.google.protobuf.test"; +package swift_proto_testing.import; message PublicImportMessage { optional int32 e = 1; diff --git a/Protos/google/protobuf/unittest_mset.proto b/Protos/Tests/SwiftProtobufTests/unittest_mset.proto similarity index 65% rename from Protos/google/protobuf/unittest_mset.proto rename to Protos/Tests/SwiftProtobufTests/unittest_mset.proto index 4e7a8c516..e77a48120 100644 --- a/Protos/google/protobuf/unittest_mset.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_mset.proto @@ -37,43 +37,49 @@ syntax = "proto2"; -import "google/protobuf/unittest_mset_wire_format.proto"; +import "unittest_mset_wire_format.proto"; -package protobuf_unittest; - -option cc_enable_arenas = true; -option optimize_for = SPEED; +package swift_proto_testing; message TestMessageSetContainer { - optional proto2_wireformat_unittest.TestMessageSet message_set = 1; + optional swift_proto_testing.wire_format.TestMessageSet message_set = 1; +} + +// A message without the message_set_wire_format option but still supports +// extensions. +message MessageEx { + extensions 4 to max; } message TestMessageSetExtension1 { - extend proto2_wireformat_unittest.TestMessageSet { + extend swift_proto_testing.wire_format.TestMessageSet { optional TestMessageSetExtension1 message_set_extension = 1545008; } + // Also extend a non-MessageSet with the same field number. This will allow us + // to test parsing a normal extension into a MessageSet. + extend MessageEx { + optional TestMessageSetExtension1 doppelganger_message_set_extension = 1545008; + } optional int32 i = 15; - optional proto2_wireformat_unittest.TestMessageSet recursive = 16; - optional string test_aliasing = 17 [ctype = STRING_PIECE]; + optional swift_proto_testing.wire_format.TestMessageSet recursive = 16; } message TestMessageSetExtension2 { - extend proto2_wireformat_unittest.TestMessageSet { + extend swift_proto_testing.wire_format.TestMessageSet { optional TestMessageSetExtension2 message_set_extension = 1547769; } optional string str = 25; } -// This message was used to generate -// //net/proto2/python/internal/testdata/message_set_message, but is commented -// out since it must not actually exist in code, to simulate an "unknown" -// extension. -// message TestMessageSetUnknownExtension { -// extend TestMessageSet { -// optional TestMessageSetUnknownExtension message_set_extension = 56141421; -// } -// optional int64 a = 1; -// } +// This isn't on swift_proto_testing.wire_format.TestMessageSet, so it will be unknown +// when parsing there. +message TestMessageSetExtension3 { + extend MessageEx { + optional TestMessageSetExtension3 doppelganger_message_set_extension = 1547770; + } + optional int32 x = 26; +} + // MessageSet wire format is equivalent to this. message RawMessageSet { @@ -82,3 +88,12 @@ message RawMessageSet { required bytes message = 3; } } + +// MessageSet wire format is equivalent to this but since the fields +// are repeated they can be left off or over present to testing. +message RawBreakableMessageSet { + repeated group Item = 1 { + repeated int32 type_id = 2; + repeated bytes message = 3; + } +} diff --git a/Protos/google/protobuf/unittest_mset_wire_format.proto b/Protos/Tests/SwiftProtobufTests/unittest_mset_wire_format.proto similarity index 89% rename from Protos/google/protobuf/unittest_mset_wire_format.proto rename to Protos/Tests/SwiftProtobufTests/unittest_mset_wire_format.proto index 04e4352e0..436039cdb 100644 --- a/Protos/google/protobuf/unittest_mset_wire_format.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_mset_wire_format.proto @@ -35,18 +35,12 @@ // This file contains messages for testing message_set_wire_format. syntax = "proto2"; -package proto2_wireformat_unittest; -option cc_enable_arenas = true; -option optimize_for = SPEED; -option csharp_namespace = "Google.ProtocolBuffers.TestProtos"; +package swift_proto_testing.wire_format; // A message with message_set_wire_format. message TestMessageSet { option message_set_wire_format = true; - extensions 4 to max; -} -message TestMessageSetWireFormatContainer { - optional TestMessageSet message_set = 1; + extensions 4 to max; } diff --git a/Protos/google/protobuf/unittest_preserve_unknown_enum.proto b/Protos/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum.proto similarity index 89% rename from Protos/google/protobuf/unittest_preserve_unknown_enum.proto rename to Protos/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum.proto index 2f91332c9..0899dab70 100644 --- a/Protos/google/protobuf/unittest_preserve_unknown_enum.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum.proto @@ -30,10 +30,7 @@ syntax = "proto3"; -package proto3_preserve_unknown_enum_unittest; -option objc_class_prefix = "UnknownEnums"; - -option csharp_namespace = "Google.Protobuf.TestProtos"; +package swift_proto_testing.unknown_enum.proto3; enum MyEnum { FOO = 0; @@ -51,7 +48,7 @@ enum MyEnumPlusExtra { message MyMessage { MyEnum e = 1; repeated MyEnum repeated_e = 2; - repeated MyEnum repeated_packed_e = 3 [packed=true]; + repeated MyEnum repeated_packed_e = 3 [packed = true]; repeated MyEnumPlusExtra repeated_packed_unexpected_e = 4; // not packed oneof o { MyEnum oneof_e_1 = 5; @@ -62,8 +59,8 @@ message MyMessage { message MyMessagePlusExtra { MyEnumPlusExtra e = 1; repeated MyEnumPlusExtra repeated_e = 2; - repeated MyEnumPlusExtra repeated_packed_e = 3 [packed=true]; - repeated MyEnumPlusExtra repeated_packed_unexpected_e = 4 [packed=true]; + repeated MyEnumPlusExtra repeated_packed_e = 3 [packed = true]; + repeated MyEnumPlusExtra repeated_packed_unexpected_e = 4 [packed = true]; oneof o { MyEnumPlusExtra oneof_e_1 = 5; MyEnumPlusExtra oneof_e_2 = 6; diff --git a/Protos/google/protobuf/unittest_preserve_unknown_enum2.proto b/Protos/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum2.proto similarity index 94% rename from Protos/google/protobuf/unittest_preserve_unknown_enum2.proto rename to Protos/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum2.proto index adf42968a..15d010f2a 100644 --- a/Protos/google/protobuf/unittest_preserve_unknown_enum2.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum2.proto @@ -30,7 +30,7 @@ syntax = "proto2"; -package proto2_preserve_unknown_enum_unittest; +package swift_proto_testing.unknown_enum.proto2; enum MyEnum { FOO = 0; @@ -41,7 +41,7 @@ enum MyEnum { message MyMessage { optional MyEnum e = 1; repeated MyEnum repeated_e = 2; - repeated MyEnum repeated_packed_e = 3 [packed=true]; + repeated MyEnum repeated_packed_e = 3 [packed = true]; repeated MyEnum repeated_packed_unexpected_e = 4; // not packed oneof o { MyEnum oneof_e_1 = 5; diff --git a/Protos/google/protobuf/unittest_proto3_lite.proto b/Protos/Tests/SwiftProtobufTests/unittest_proto3.proto similarity index 87% rename from Protos/google/protobuf/unittest_proto3_lite.proto rename to Protos/Tests/SwiftProtobufTests/unittest_proto3.proto index 837bb03c5..41fd8d934 100644 --- a/Protos/google/protobuf/unittest_proto3_lite.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_proto3.proto @@ -30,11 +30,10 @@ syntax = "proto3"; -package proto3_lite_unittest; +package swift_proto_testing.proto3; -import "google/protobuf/unittest_import.proto"; - -option optimize_for = LITE_RUNTIME; +import "unittest_import.proto"; +import "unittest.proto"; // This proto includes every type of field in both singular and repeated // forms. @@ -76,9 +75,9 @@ message TestAllTypes { // optional int32 a = 17; // } - NestedMessage optional_nested_message = 18; + optional NestedMessage optional_nested_message = 18; ForeignMessage optional_foreign_message = 19; - protobuf_unittest_import.ImportMessage optional_import_message = 20; + swift_proto_testing.import.ImportMessage optional_import_message = 20; NestedEnum optional_nested_enum = 21; ForeignEnum optional_foreign_enum = 22; @@ -86,17 +85,12 @@ message TestAllTypes { // Omitted (compared to unittest.proto) because proto2 enums are not allowed // inside proto2 messages. // - // optional protobuf_unittest_import.ImportEnum optional_import_enum = 23; - - string optional_string_piece = 24 [ctype = STRING_PIECE]; - string optional_cord = 25 [ctype = CORD]; + // optional swift_proto_testing.import.ImportEnum optional_import_enum = 23; // Defined in unittest_import_public.proto - protobuf_unittest_import.PublicImportMessage optional_public_import_message = + swift_proto_testing.import.PublicImportMessage optional_public_import_message = 26; - NestedMessage optional_lazy_message = 27 [lazy = true]; - // Repeated repeated int32 repeated_int32 = 31; repeated int64 repeated_int64 = 32; @@ -121,7 +115,7 @@ message TestAllTypes { repeated NestedMessage repeated_nested_message = 48; repeated ForeignMessage repeated_foreign_message = 49; - repeated protobuf_unittest_import.ImportMessage repeated_import_message = 50; + repeated swift_proto_testing.import.ImportMessage repeated_import_message = 50; repeated NestedEnum repeated_nested_enum = 51; repeated ForeignEnum repeated_foreign_enum = 52; @@ -129,12 +123,7 @@ message TestAllTypes { // Omitted (compared to unittest.proto) because proto2 enums are not allowed // inside proto2 messages. // - // repeated protobuf_unittest_import.ImportEnum repeated_import_enum = 53; - - repeated string repeated_string_piece = 54 [ctype = STRING_PIECE]; - repeated string repeated_cord = 55 [ctype = CORD]; - - repeated NestedMessage repeated_lazy_message = 57 [lazy = true]; + // repeated swift_proto_testing.import.ImportEnum repeated_import_enum = 53; oneof oneof_field { uint32 oneof_uint32 = 111; @@ -202,3 +191,8 @@ enum ForeignEnum { // TestEmptyMessage is used to test behavior of unknown fields. message TestEmptyMessage {} + +// Test a proto3 defined message with a proto2 as a field that has required fields. +message TestProto2Required { + swift_proto_testing.TestRequired proto2 = 1; +} diff --git a/Protos/google/protobuf/unittest_proto3_optional.proto b/Protos/Tests/SwiftProtobufTests/unittest_proto3_optional.proto similarity index 78% rename from Protos/google/protobuf/unittest_proto3_optional.proto rename to Protos/Tests/SwiftProtobufTests/unittest_proto3_optional.proto index 09d17182e..7118d86a7 100644 --- a/Protos/google/protobuf/unittest_proto3_optional.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_proto3_optional.proto @@ -30,12 +30,7 @@ syntax = "proto3"; -package protobuf_unittest; - -import "google/protobuf/descriptor.proto"; - -option java_multiple_files = true; -option java_package = "com.google.protobuf.testing.proto"; +package swift_proto_testing; message TestProto3Optional { message NestedMessage { @@ -69,32 +64,11 @@ message TestProto3Optional { optional bool optional_bool = 13; optional string optional_string = 14; optional bytes optional_bytes = 15; - optional string optional_cord = 16 [ctype = CORD]; optional NestedMessage optional_nested_message = 18; - optional NestedMessage lazy_nested_message = 19 [lazy = true]; optional NestedEnum optional_nested_enum = 21; // Add some non-optional fields to verify we can mix them. int32 singular_int32 = 22; int64 singular_int64 = 23; } - -message TestProto3OptionalMessage { - message NestedMessage { - string s = 1; - } - - NestedMessage nested_message = 1; - optional NestedMessage optional_nested_message = 2; -} - -message Proto3OptionalExtensions { - option (protobuf_unittest.Proto3OptionalExtensions.ext_no_optional) = 8; - option (protobuf_unittest.Proto3OptionalExtensions.ext_with_optional) = 16; - - extend google.protobuf.MessageOptions { - int32 ext_no_optional = 355886728; - optional int32 ext_with_optional = 355886729; - } -} diff --git a/Protos/unittest_swift_all_required_types.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_all_required_types.proto similarity index 87% rename from Protos/unittest_swift_all_required_types.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_all_required_types.proto index 47e0860dc..828a020a6 100644 --- a/Protos/unittest_swift_all_required_types.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_all_required_types.proto @@ -31,10 +31,10 @@ // An addition to unittest.proto syntax = "proto2"; -import "google/protobuf/unittest_import.proto"; -import "google/protobuf/unittest.proto"; +import "unittest_import.proto"; +import "unittest.proto"; -package protobuf_unittest; +package swift_proto_testing; message TestAllRequiredTypes { message NestedMessage { @@ -74,21 +74,16 @@ message TestAllRequiredTypes { required NestedMessage required_nested_message = 18; required ForeignMessage required_foreign_message = 19; - required protobuf_unittest_import.ImportMessage required_import_message = 20; + required swift_proto_testing.import.ImportMessage required_import_message = 20; required NestedEnum required_nested_enum = 21; required ForeignEnum required_foreign_enum = 22; - required protobuf_unittest_import.ImportEnum required_import_enum = 23; - - required string required_string_piece = 24 [ctype=STRING_PIECE]; - required string required_cord = 25 [ctype=CORD]; + required swift_proto_testing.import.ImportEnum required_import_enum = 23; // Defined in unittest_import_public.proto - required protobuf_unittest_import.PublicImportMessage + required swift_proto_testing.import.PublicImportMessage required_public_import_message = 26; - required NestedMessage required_lazy_message = 27 [lazy=true]; - // Singular with defaults required int32 default_int32 = 61 [default = 41 ]; required int64 default_int64 = 62 [default = 42 ]; @@ -108,12 +103,9 @@ message TestAllRequiredTypes { required NestedEnum default_nested_enum = 81 [default = BAR ]; required ForeignEnum default_foreign_enum = 82 [default = FOREIGN_BAR]; - required protobuf_unittest_import.ImportEnum + required swift_proto_testing.import.ImportEnum default_import_enum = 83 [default = IMPORT_BAR]; - required string default_string_piece = 84 [ctype=STRING_PIECE,default="abc"]; - required string default_cord = 85 [ctype=CORD,default="123"]; - // For oneof test oneof oneof_field { uint32 oneof_uint32 = 111; @@ -137,4 +129,4 @@ message TestSomeRequiredTypes { required bytes required_bytes = 5; required NestedEnum required_nested_enum = 6; -} \ No newline at end of file +} diff --git a/Protos/unittest_swift_cycle.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_cycle.proto similarity index 98% rename from Protos/unittest_swift_cycle.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_cycle.proto index 5f6f56a1a..2e2afc9fd 100644 --- a/Protos/unittest_swift_cycle.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_cycle.proto @@ -29,7 +29,7 @@ syntax = "proto2"; -package protobuf_unittest; +package swift_proto_testing; // Cycles in the Message graph can cause problems for the mutable classes // since the properties on the mutable class change types. This file just diff --git a/Protos/Tests/SwiftProtobufTests/unittest_swift_deprecated.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_deprecated.proto new file mode 100644 index 000000000..b1fe44497 --- /dev/null +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_deprecated.proto @@ -0,0 +1,84 @@ +// Protos/unittest_swift_deprecated.proto - test proto +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2023 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 generation support of deprecated attributes. +/// +// ----------------------------------------------------------------------------- + +syntax = "proto2"; + +package swift_proto_testing.deprecated; + +// The source generated from this file needs to be inspect to confirm it has all +// of the expected comments. See +// https://github.com/apple/swift-protobuf/issues/151 for why things currently +// don't generate annotations. If/when that is resolved, this file should be +// compiled also to confirm everything works as intended. + + +// Marking fields as deprecated. +message MyMsg { + extensions 100 to max; + + // Field comment + optional string string_field = 1 [deprecated=true]; + required int32 int_field = 2 [deprecated=true]; + repeated fixed32 fixed_field = 3 [deprecated=true]; + optional MyMsg msg_field = 4 [deprecated=true]; +} + +// Marking extension fields as deprecated. +extend MyMsg { + // Extension field comment + optional string string_ext_field = 101 [deprecated=true]; + optional int32 int_ext_field = 102 [deprecated=true]; + repeated fixed32 fixed_ext_field = 103 [deprecated=true]; + optional MyMsg msg_ext_field = 104 [deprecated=true]; +} + +// Marking extension fields (scoped to a message) as deprecated. +message MsgScope { + extend MyMsg { + // Another extension field comment + optional string string_ext2_field = 201 [deprecated=true]; + optional int32 int_ext2_field = 202 [deprecated=true]; + repeated fixed32 fixed_ext2_field = 203 [deprecated=true]; + optional MyMsg msg_ext2_field = 204 [deprecated=true]; + } +} + +// An enum value marked as deprecated. +enum MyEnum { + MYENUM_ONE = 1; + // Enum comment + MYENUM_TWO = 2 [deprecated=true]; + MYENUM_THREE = 3 [deprecated=true]; +} + +// Whole message marked as deprecated. +message MyMsg2 { + option deprecated = true; + + optional string string_field = 1; + required int32 int_field = 2; + repeated fixed32 fixed_field = 3; + optional MyMsg2 msg_field = 4; +} + +// Whole enum marked as deprecated. +enum MyEnum2 { + option deprecated = true; + + MYENUM2_ONE = 1; + MYENUM2_TWO = 2; + MYENUM2_THREE = 3; +} diff --git a/Protos/Tests/SwiftProtobufTests/unittest_swift_deprecated_file.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_deprecated_file.proto new file mode 100644 index 000000000..1e8473fe0 --- /dev/null +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_deprecated_file.proto @@ -0,0 +1,60 @@ +// Protos/unittest_swift_deprecated_file.proto - test proto +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2023 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 generation support of deprecated attributes. +/// +// ----------------------------------------------------------------------------- + +syntax = "proto2"; + +package swift_proto_testing.deprecated_file; + +// The source generated from this file needs to be inspect to confirm it has all +// of the expected comments. See +// https://github.com/apple/swift-protobuf/issues/151 for why things currently +// don't generate annotations. If/when that is resolved, this file should be +// compiled also to confirm everything works as intended. + +option deprecated = true; + +// Message comment +message MyMsg { + extensions 100 to max; + + optional string string_field = 1; +} + +// These fields will all catch the deprecation from the file. +extend MyMsg { + // Extension field comment + optional string string_ext_field = 101; + optional int32 int_ext_field = 102; + repeated fixed32 fixed_ext_field = 103; + optional MyMsg msg_ext_field = 104; +} + +message MsgScope { + // These extension fields (scoped within a message) will all catch the deprecation from the file. + extend MyMsg { + // Another extension field comment + optional string string_ext2_field = 201; + optional int32 int_ext2_field = 202; + repeated fixed32 fixed_ext2_field = 203; + optional MyMsg msg_ext2_field = 204; + } +} + +enum MyEnum { + MYENUM_ONE = 1; + MYENUM_TWO = 2; + MYENUM_THREE = 3; +} diff --git a/Protos/unittest_swift_enum_optional_default.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_enum_optional_default.proto similarity index 96% rename from Protos/unittest_swift_enum_optional_default.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_enum_optional_default.proto index 7aabf52a1..95aef643c 100644 --- a/Protos/unittest_swift_enum_optional_default.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_enum_optional_default.proto @@ -16,7 +16,7 @@ syntax = "proto2"; -package protobuf_unittest.extend; +package swift_proto_testing.extend; message EnumOptionalDefault { message NestedMessage { diff --git a/Protos/unittest_swift_enum.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_enum_proto2.proto similarity index 98% rename from Protos/unittest_swift_enum.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_enum_proto2.proto index daa262156..662c1f5a0 100644 --- a/Protos/unittest_swift_enum.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_enum_proto2.proto @@ -30,7 +30,7 @@ syntax = "proto2"; -package protobuf_unittest; +package swift_proto_testing.enum2; message SwiftEnumTest { enum EnumTest1 { diff --git a/Protos/unittest_swift_enum_proto3.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_enum_proto3.proto similarity index 98% rename from Protos/unittest_swift_enum_proto3.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_enum_proto3.proto index f45be4a35..aab0f5cf1 100644 --- a/Protos/unittest_swift_enum_proto3.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_enum_proto3.proto @@ -30,7 +30,7 @@ syntax = "proto3"; -package protobuf3_unittest; +package swift_proto_testing.enum3; message SwiftEnumTest { enum EnumTest1 { diff --git a/Protos/unittest_swift_extension.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_extension.proto similarity index 98% rename from Protos/unittest_swift_extension.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_extension.proto index f20a937b4..271771eee 100644 --- a/Protos/unittest_swift_extension.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_extension.proto @@ -16,7 +16,7 @@ syntax = "proto2"; -package protobuf_unittest.extend; +package swift_proto_testing.extend; message Foo { message Bar { diff --git a/Protos/unittest_swift_extension2.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_extension2.proto similarity index 88% rename from Protos/unittest_swift_extension2.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_extension2.proto index 703da2a83..2b3e159c8 100644 --- a/Protos/unittest_swift_extension2.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_extension2.proto @@ -18,12 +18,12 @@ syntax = "proto2"; -package protobuf_unittest.extend2; +package swift_proto_testing.extend2; import "unittest_swift_extension.proto"; message MyMessage { - extend protobuf_unittest.extend.Foo.Bar.Baz { + extend swift_proto_testing.extend.Foo.Bar.Baz { optional string b = 210; optional group C = 211 { optional int64 c = 1210; @@ -31,7 +31,7 @@ message MyMessage { } } -extend protobuf_unittest.extend.Foo.Bar.Baz { +extend swift_proto_testing.extend.Foo.Bar.Baz { optional string b = 220; optional group C = 221 { optional int64 c = 1220; diff --git a/Protos/unittest_swift_extension3.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_extension3.proto similarity index 88% rename from Protos/unittest_swift_extension3.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_extension3.proto index 2065a7d35..c7884c01b 100644 --- a/Protos/unittest_swift_extension3.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_extension3.proto @@ -18,12 +18,12 @@ syntax = "proto2"; -package protobuf_unittest.extend3; +package swift_proto_testing.extend3; import "unittest_swift_extension.proto"; message MyMessage { - extend protobuf_unittest.extend.Foo.Bar.Baz { + extend swift_proto_testing.extend.Foo.Bar.Baz { optional string b = 310; optional group C = 311 { optional int64 c = 1310; @@ -31,7 +31,7 @@ message MyMessage { } } -extend protobuf_unittest.extend.Foo.Bar.Baz { +extend swift_proto_testing.extend.Foo.Bar.Baz { optional string b = 320; optional group C = 321 { optional int64 c = 1320; diff --git a/Protos/unittest_swift_extension4.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_extension4.proto similarity index 89% rename from Protos/unittest_swift_extension4.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_extension4.proto index 3af489715..59cef65c6 100644 --- a/Protos/unittest_swift_extension4.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_extension4.proto @@ -18,13 +18,14 @@ syntax = "proto2"; -package protobuf_unittest.extend4; +package swift_proto_testing.extend4; + option swift_prefix = "Ext4"; import "unittest_swift_extension.proto"; message MyMessage { - extend protobuf_unittest.extend.Foo.Bar.Baz { + extend swift_proto_testing.extend.Foo.Bar.Baz { optional string b = 410; optional group C = 411 { optional int64 c = 1410; @@ -32,7 +33,7 @@ message MyMessage { } } -extend protobuf_unittest.extend.Foo.Bar.Baz { +extend swift_proto_testing.extend.Foo.Bar.Baz { optional string b = 420; optional group C = 421 { optional int64 c = 1420; diff --git a/Protos/unittest_swift_fieldorder.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_fieldorder.proto similarity index 89% rename from Protos/unittest_swift_fieldorder.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_fieldorder.proto index 6364c2791..5ec8cf9e5 100644 --- a/Protos/unittest_swift_fieldorder.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_fieldorder.proto @@ -16,7 +16,7 @@ syntax = "proto2"; -package swift.protobuf; +package swift_proto_testing.order; message TestFieldOrderings { optional string my_string = 11; @@ -25,15 +25,15 @@ message TestFieldOrderings { extensions 12 to 55; optional float my_float = 101; message NestedMessage { - optional int64 oo = 2; - optional int32 bb = 1; + optional int64 oo = 2; + optional int32 bb = 1; } oneof options { - int64 oneof_int64 = 60; - bool oneof_bool = 9; - string oneof_string = 150; - int32 oneof_int32 = 10; + int64 oneof_int64 = 60; + bool oneof_bool = 9; + string oneof_string = 150; + int32 oneof_int32 = 10; } optional NestedMessage optional_nested_message = 200; diff --git a/Protos/unittest_swift_groups.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_groups.proto similarity index 94% rename from Protos/unittest_swift_groups.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_groups.proto index de0045215..6544d5f78 100644 --- a/Protos/unittest_swift_groups.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_groups.proto @@ -30,13 +30,15 @@ syntax = "proto2"; +package swift_proto_testing; + // Same field number appears inside and outside of the group. -message SwiftTestGroupExtensions { +message GroupExtensions { optional int32 a = 1; extensions 2 to 10; } -extend SwiftTestGroupExtensions { +extend GroupExtensions { optional group ExtensionGroup = 2 { optional int32 a = 1; } @@ -45,11 +47,11 @@ extend SwiftTestGroupExtensions { } } -message SwiftTestGroupUnextended { +message GroupUnextended { optional int32 a = 1; } -message SwiftTestNestingGroupsMessage { +message NestingGroupsMessage { optional int32 outer_a = 1; optional group SubGroup1 = 2 { optional int32 sub1_a = 1; diff --git a/Protos/unittest_swift_json.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_json.proto similarity index 95% rename from Protos/unittest_swift_json.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_json.proto index 037b66023..a442dfcca 100644 --- a/Protos/unittest_swift_json.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_json.proto @@ -9,7 +9,7 @@ syntax = "proto3"; -package protobuf_unittest; +package swift_proto_testing; import "google/protobuf/struct.proto"; diff --git a/Protos/unittest_swift_naming.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_naming.proto similarity index 99% rename from Protos/unittest_swift_naming.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_naming.proto index 8a53ef3cf..efaea459f 100644 --- a/Protos/unittest_swift_naming.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_naming.proto @@ -16,7 +16,7 @@ // proto2 syntax is used so the has*/clear* names also get generated. syntax = "proto2"; -package swift_unittest.names; +package swift_proto_testing.names; // TODO: Build a MessageNames message with a submessage of every name below // TODO: Create tests that access every field, enum, message to verify the name is generated correctly @@ -233,7 +233,7 @@ message FieldNames { optional int32 TimeScale = 241; optional int32 TimeBase = 242; optional int32 TimeRecord = 243; - optional int32 json_should_be_overriden = 244 [json_name = "json_was_overridden"]; + optional int32 json_should_be_overridden = 244 [json_name = "json_was_overridden"]; optional int32 Any = 245; optional int32 Int32 = 246; optional int32 Int64 = 247; diff --git a/Protos/unittest_swift_naming_no_prefix.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_naming_no_prefix.proto similarity index 93% rename from Protos/unittest_swift_naming_no_prefix.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_naming_no_prefix.proto index 28617e3ed..6d15504c6 100644 --- a/Protos/unittest_swift_naming_no_prefix.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_naming_no_prefix.proto @@ -23,7 +23,7 @@ import "unittest_swift_naming.proto"; // No prefix, so these end up with global names and directly added to the message they // extend. -extend swift_unittest.names.ExtensionNamingInitialsLowers { +extend swift_proto_testing.names.ExtensionNamingInitialsLowers { optional int32 http = 101; optional int32 http_request = 102; optional int32 the_http_request = 103; @@ -47,7 +47,7 @@ extend swift_unittest.names.ExtensionNamingInitialsLowers { optional int32 request_id = 144; } -extend swift_unittest.names.ExtensionNamingInitialsUppers { +extend swift_proto_testing.names.ExtensionNamingInitialsUppers { optional int32 HTTP = 101; optional int32 HTTP_request = 102; optional int32 the_HTTP_request = 103; @@ -69,7 +69,7 @@ extend swift_unittest.names.ExtensionNamingInitialsUppers { optional int32 request_ID = 144; } -extend swift_unittest.names.ExtensionNamingInitialsWordCase { +extend swift_proto_testing.names.ExtensionNamingInitialsWordCase { optional int32 Http = 101; optional int32 HttpRequest = 102; optional int32 TheHttpRequest = 103; diff --git a/Protos/unittest_swift_naming_number_prefix.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_naming_number_prefix.proto similarity index 95% rename from Protos/unittest_swift_naming_number_prefix.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_naming_number_prefix.proto index 5ea165e97..dbbbd4f49 100644 --- a/Protos/unittest_swift_naming_number_prefix.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_naming_number_prefix.proto @@ -18,8 +18,7 @@ syntax = "proto2"; // A package that starts with an underscore and number so if the generator just // stripped the underscore, it would result in invalid Swift. - -package _4fun.mumble; +package _4fun.swift_proto_testing.mumble; message MyMessage { optional int32 a = 1; diff --git a/Protos/unittest_swift_oneof_all_required.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_oneof_all_required.proto similarity index 98% rename from Protos/unittest_swift_oneof_all_required.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_oneof_all_required.proto index 96fda41bf..1f98cf9c8 100644 --- a/Protos/unittest_swift_oneof_all_required.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_oneof_all_required.proto @@ -30,7 +30,7 @@ syntax = "proto2"; -package protobuf_unittest; +package swift_proto_testing; message OneOfOptionMessage1 { required int32 requiredField = 1; diff --git a/Protos/unittest_swift_oneof_merging.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_oneof_merging.proto similarity index 97% rename from Protos/unittest_swift_oneof_merging.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_oneof_merging.proto index 6949c595d..a4ac819f0 100644 --- a/Protos/unittest_swift_oneof_merging.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_oneof_merging.proto @@ -18,7 +18,7 @@ syntax = "proto2"; -package swift_unittest; +package swift_proto_testing.merging; message TestMessage { message NestedMessage { diff --git a/Protos/Tests/SwiftProtobufTests/unittest_swift_oneof_switch_split.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_oneof_switch_split.proto new file mode 100644 index 000000000..2a01f9aea --- /dev/null +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_oneof_switch_split.proto @@ -0,0 +1,543 @@ +// Protos/Tests/SwiftProtobufTests/unittest_swift_oneof_switch_split.proto +// Test for switch statement splitting in oneof traverse generation +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2025 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 +// +// ----------------------------------------------------------------------------- +/// +/// This message tests oneof switch splitting with interleaved non-oneof fields. +/// - Regular fields at 2, 251, 502, and 509 break oneof into multiple chunks +/// - Regular field at 2 creates first break +/// - Regular field at 251 creates second break +/// - Regular field at 502 creates third break +/// - Regular field at 509 creates fourth break +/// - The oneof fields are also reordered to test proper sorting in generated code +/// +// ----------------------------------------------------------------------------- + +syntax = "proto2"; + +package swift_proto_testing.switch_split; + +message SwitchSplitMessage { + // Regular fields that split the oneof into chunks + optional int32 regular_field_002 = 2; + optional int32 regular_field_251 = 251; + optional int32 regular_field_502 = 502; + optional int32 regular_field_509 = 509; + + oneof value { + int32 field_001 = 1; + int32 field_003 = 3; + int32 field_004 = 4; + int32 field_005 = 5; + int32 field_006 = 6; + int32 field_007 = 7; + int32 field_008 = 8; + int32 field_009 = 9; + int32 field_010 = 50; + int32 field_011 = 11; + int32 field_012 = 12; + int32 field_013 = 13; + int32 field_014 = 14; + int32 field_015 = 15; + int32 field_016 = 16; + int32 field_017 = 17; + int32 field_018 = 18; + int32 field_019 = 19; + int32 field_020 = 20; + int32 field_021 = 21; + int32 field_022 = 22; + int32 field_023 = 23; + int32 field_024 = 24; + int32 field_025 = 25; + int32 field_026 = 26; + int32 field_027 = 27; + int32 field_028 = 28; + int32 field_029 = 29; + int32 field_030 = 30; + int32 field_031 = 31; + int32 field_032 = 32; + int32 field_033 = 33; + int32 field_034 = 34; + int32 field_035 = 35; + int32 field_036 = 36; + int32 field_037 = 37; + int32 field_038 = 38; + int32 field_039 = 39; + int32 field_040 = 40; + int32 field_041 = 41; + int32 field_042 = 42; + int32 field_043 = 43; + int32 field_044 = 44; + int32 field_045 = 45; + int32 field_046 = 46; + int32 field_047 = 47; + int32 field_048 = 48; + int32 field_049 = 49; + int32 field_050 = 10; + int32 field_051 = 51; + int32 field_052 = 52; + int32 field_053 = 53; + int32 field_054 = 54; + int32 field_055 = 55; + int32 field_056 = 56; + int32 field_057 = 57; + int32 field_058 = 58; + int32 field_059 = 59; + int32 field_060 = 60; + int32 field_061 = 61; + int32 field_062 = 62; + int32 field_063 = 63; + int32 field_064 = 64; + int32 field_065 = 65; + int32 field_066 = 66; + int32 field_067 = 67; + int32 field_068 = 68; + int32 field_069 = 69; + int32 field_070 = 70; + int32 field_071 = 71; + int32 field_072 = 72; + int32 field_073 = 73; + int32 field_074 = 74; + int32 field_075 = 75; + int32 field_076 = 76; + int32 field_077 = 77; + int32 field_078 = 78; + int32 field_079 = 79; + int32 field_080 = 80; + int32 field_081 = 81; + int32 field_082 = 82; + int32 field_083 = 83; + int32 field_084 = 84; + int32 field_085 = 85; + int32 field_086 = 86; + int32 field_087 = 87; + int32 field_088 = 88; + int32 field_089 = 89; + int32 field_090 = 90; + int32 field_091 = 91; + int32 field_092 = 92; + int32 field_093 = 93; + int32 field_094 = 94; + int32 field_095 = 95; + int32 field_096 = 96; + int32 field_097 = 97; + int32 field_098 = 98; + int32 field_099 = 99; + int32 field_100 = 200; + int32 field_101 = 101; + int32 field_102 = 102; + int32 field_103 = 103; + int32 field_104 = 104; + int32 field_105 = 105; + int32 field_106 = 106; + int32 field_107 = 107; + int32 field_108 = 108; + int32 field_109 = 109; + int32 field_110 = 110; + int32 field_111 = 111; + int32 field_112 = 112; + int32 field_113 = 113; + int32 field_114 = 114; + int32 field_115 = 115; + int32 field_116 = 116; + int32 field_117 = 117; + int32 field_118 = 118; + int32 field_119 = 119; + int32 field_120 = 120; + int32 field_121 = 121; + int32 field_122 = 122; + int32 field_123 = 123; + int32 field_124 = 124; + int32 field_125 = 125; + int32 field_126 = 126; + int32 field_127 = 127; + int32 field_128 = 128; + int32 field_129 = 129; + int32 field_130 = 130; + int32 field_131 = 131; + int32 field_132 = 132; + int32 field_133 = 133; + int32 field_134 = 134; + int32 field_135 = 135; + int32 field_136 = 136; + int32 field_137 = 137; + int32 field_138 = 138; + int32 field_139 = 139; + int32 field_140 = 140; + int32 field_141 = 141; + int32 field_142 = 142; + int32 field_143 = 143; + int32 field_144 = 144; + int32 field_145 = 145; + int32 field_146 = 146; + int32 field_147 = 147; + int32 field_148 = 148; + int32 field_149 = 149; + int32 field_150 = 150; + int32 field_151 = 151; + int32 field_152 = 152; + int32 field_153 = 153; + int32 field_154 = 154; + int32 field_155 = 155; + int32 field_156 = 156; + int32 field_157 = 157; + int32 field_158 = 158; + int32 field_159 = 159; + int32 field_160 = 160; + int32 field_161 = 161; + int32 field_162 = 162; + int32 field_163 = 163; + int32 field_164 = 164; + int32 field_165 = 165; + int32 field_166 = 166; + int32 field_167 = 167; + int32 field_168 = 168; + int32 field_169 = 169; + int32 field_170 = 170; + int32 field_171 = 171; + int32 field_172 = 172; + int32 field_173 = 173; + int32 field_174 = 174; + int32 field_175 = 175; + int32 field_176 = 176; + int32 field_177 = 177; + int32 field_178 = 178; + int32 field_179 = 179; + int32 field_180 = 180; + int32 field_181 = 181; + int32 field_182 = 182; + int32 field_183 = 183; + int32 field_184 = 184; + int32 field_185 = 185; + int32 field_186 = 186; + int32 field_187 = 187; + int32 field_188 = 188; + int32 field_189 = 189; + int32 field_190 = 190; + int32 field_191 = 191; + int32 field_192 = 192; + int32 field_193 = 193; + int32 field_194 = 194; + int32 field_195 = 195; + int32 field_196 = 196; + int32 field_197 = 197; + int32 field_198 = 198; + int32 field_199 = 199; + int32 field_200 = 100; + int32 field_201 = 201; + int32 field_202 = 202; + int32 field_203 = 203; + int32 field_204 = 204; + int32 field_205 = 205; + int32 field_206 = 206; + int32 field_207 = 207; + int32 field_208 = 208; + int32 field_209 = 209; + int32 field_210 = 210; + int32 field_211 = 211; + int32 field_212 = 212; + int32 field_213 = 213; + int32 field_214 = 214; + int32 field_215 = 215; + int32 field_216 = 216; + int32 field_217 = 217; + int32 field_218 = 218; + int32 field_219 = 219; + int32 field_220 = 220; + int32 field_221 = 221; + int32 field_222 = 222; + int32 field_223 = 223; + int32 field_224 = 224; + int32 field_225 = 225; + int32 field_226 = 226; + int32 field_227 = 227; + int32 field_228 = 228; + int32 field_229 = 229; + int32 field_230 = 230; + int32 field_231 = 231; + int32 field_232 = 232; + int32 field_233 = 233; + int32 field_234 = 234; + int32 field_235 = 235; + int32 field_236 = 236; + int32 field_237 = 237; + int32 field_238 = 238; + int32 field_239 = 239; + int32 field_240 = 240; + int32 field_241 = 241; + int32 field_242 = 242; + int32 field_243 = 243; + int32 field_244 = 244; + int32 field_245 = 245; + int32 field_246 = 246; + int32 field_247 = 247; + int32 field_248 = 248; + int32 field_249 = 249; + int32 field_250 = 250; + int32 field_252 = 252; + int32 field_253 = 253; + int32 field_254 = 254; + int32 field_255 = 255; + int32 field_256 = 256; + int32 field_257 = 257; + int32 field_258 = 258; + int32 field_259 = 259; + int32 field_260 = 260; + int32 field_261 = 261; + int32 field_262 = 262; + int32 field_263 = 263; + int32 field_264 = 264; + int32 field_265 = 265; + int32 field_266 = 266; + int32 field_267 = 267; + int32 field_268 = 268; + int32 field_269 = 269; + int32 field_270 = 270; + int32 field_271 = 271; + int32 field_272 = 272; + int32 field_273 = 273; + int32 field_274 = 274; + int32 field_275 = 275; + int32 field_276 = 276; + int32 field_277 = 277; + int32 field_278 = 278; + int32 field_279 = 279; + int32 field_280 = 280; + int32 field_281 = 281; + int32 field_282 = 282; + int32 field_283 = 283; + int32 field_284 = 284; + int32 field_285 = 285; + int32 field_286 = 286; + int32 field_287 = 287; + int32 field_288 = 288; + int32 field_289 = 289; + int32 field_290 = 290; + int32 field_291 = 291; + int32 field_292 = 292; + int32 field_293 = 293; + int32 field_294 = 294; + int32 field_295 = 295; + int32 field_296 = 296; + int32 field_297 = 297; + int32 field_298 = 298; + int32 field_299 = 299; + int32 field_300 = 400; + int32 field_301 = 301; + int32 field_302 = 302; + int32 field_303 = 303; + int32 field_304 = 304; + int32 field_305 = 305; + int32 field_306 = 306; + int32 field_307 = 307; + int32 field_308 = 308; + int32 field_309 = 309; + int32 field_310 = 310; + int32 field_311 = 311; + int32 field_312 = 312; + int32 field_313 = 313; + int32 field_314 = 314; + int32 field_315 = 315; + int32 field_316 = 316; + int32 field_317 = 317; + int32 field_318 = 318; + int32 field_319 = 319; + int32 field_320 = 320; + int32 field_321 = 321; + int32 field_322 = 322; + int32 field_323 = 323; + int32 field_324 = 324; + int32 field_325 = 325; + int32 field_326 = 326; + int32 field_327 = 327; + int32 field_328 = 328; + int32 field_329 = 329; + int32 field_330 = 330; + int32 field_331 = 331; + int32 field_332 = 332; + int32 field_333 = 333; + int32 field_334 = 334; + int32 field_335 = 335; + int32 field_336 = 336; + int32 field_337 = 337; + int32 field_338 = 338; + int32 field_339 = 339; + int32 field_340 = 340; + int32 field_341 = 341; + int32 field_342 = 342; + int32 field_343 = 343; + int32 field_344 = 344; + int32 field_345 = 345; + int32 field_346 = 346; + int32 field_347 = 347; + int32 field_348 = 348; + int32 field_349 = 349; + int32 field_350 = 350; + int32 field_351 = 351; + int32 field_352 = 352; + int32 field_353 = 353; + int32 field_354 = 354; + int32 field_355 = 355; + int32 field_356 = 356; + int32 field_357 = 357; + int32 field_358 = 358; + int32 field_359 = 359; + int32 field_360 = 360; + int32 field_361 = 361; + int32 field_362 = 362; + int32 field_363 = 363; + int32 field_364 = 364; + int32 field_365 = 365; + int32 field_366 = 366; + int32 field_367 = 367; + int32 field_368 = 368; + int32 field_369 = 369; + int32 field_370 = 370; + int32 field_371 = 371; + int32 field_372 = 372; + int32 field_373 = 373; + int32 field_374 = 374; + int32 field_375 = 375; + int32 field_376 = 376; + int32 field_377 = 377; + int32 field_378 = 378; + int32 field_379 = 379; + int32 field_380 = 380; + int32 field_381 = 381; + int32 field_382 = 382; + int32 field_383 = 383; + int32 field_384 = 384; + int32 field_385 = 385; + int32 field_386 = 386; + int32 field_387 = 387; + int32 field_388 = 388; + int32 field_389 = 389; + int32 field_390 = 390; + int32 field_391 = 391; + int32 field_392 = 392; + int32 field_393 = 393; + int32 field_394 = 394; + int32 field_395 = 395; + int32 field_396 = 396; + int32 field_397 = 397; + int32 field_398 = 398; + int32 field_399 = 399; + int32 field_400 = 300; + int32 field_401 = 401; + int32 field_402 = 402; + int32 field_403 = 403; + int32 field_404 = 404; + int32 field_405 = 405; + int32 field_406 = 406; + int32 field_407 = 407; + int32 field_408 = 408; + int32 field_409 = 409; + int32 field_410 = 410; + int32 field_411 = 411; + int32 field_412 = 412; + int32 field_413 = 413; + int32 field_414 = 414; + int32 field_415 = 415; + int32 field_416 = 416; + int32 field_417 = 417; + int32 field_418 = 418; + int32 field_419 = 419; + int32 field_420 = 420; + int32 field_421 = 421; + int32 field_422 = 422; + int32 field_423 = 423; + int32 field_424 = 424; + int32 field_425 = 425; + int32 field_426 = 426; + int32 field_427 = 427; + int32 field_428 = 428; + int32 field_429 = 429; + int32 field_430 = 430; + int32 field_431 = 431; + int32 field_432 = 432; + int32 field_433 = 433; + int32 field_434 = 434; + int32 field_435 = 435; + int32 field_436 = 436; + int32 field_437 = 437; + int32 field_438 = 438; + int32 field_439 = 439; + int32 field_440 = 440; + int32 field_441 = 441; + int32 field_442 = 442; + int32 field_443 = 443; + int32 field_444 = 444; + int32 field_445 = 445; + int32 field_446 = 446; + int32 field_447 = 447; + int32 field_448 = 448; + int32 field_449 = 449; + int32 field_450 = 450; + int32 field_451 = 451; + int32 field_452 = 452; + int32 field_453 = 453; + int32 field_454 = 454; + int32 field_455 = 455; + int32 field_456 = 456; + int32 field_457 = 457; + int32 field_458 = 458; + int32 field_459 = 459; + int32 field_460 = 460; + int32 field_461 = 461; + int32 field_462 = 462; + int32 field_463 = 463; + int32 field_464 = 464; + int32 field_465 = 465; + int32 field_466 = 466; + int32 field_467 = 467; + int32 field_468 = 468; + int32 field_469 = 469; + int32 field_470 = 470; + int32 field_471 = 471; + int32 field_472 = 472; + int32 field_473 = 473; + int32 field_474 = 474; + int32 field_475 = 475; + int32 field_476 = 476; + int32 field_477 = 477; + int32 field_478 = 478; + int32 field_479 = 479; + int32 field_480 = 480; + int32 field_481 = 481; + int32 field_482 = 482; + int32 field_483 = 483; + int32 field_484 = 484; + int32 field_485 = 485; + int32 field_486 = 486; + int32 field_487 = 487; + int32 field_488 = 488; + int32 field_489 = 489; + int32 field_490 = 490; + int32 field_491 = 491; + int32 field_492 = 492; + int32 field_493 = 493; + int32 field_494 = 494; + int32 field_495 = 495; + int32 field_496 = 496; + int32 field_497 = 497; + int32 field_498 = 498; + int32 field_499 = 499; + int32 field_500 = 500; + int32 field_501 = 501; + int32 field_503 = 503; + int32 field_504 = 504; + int32 field_505 = 505; + int32 field_506 = 506; + int32 field_507 = 507; + int32 field_508 = 508; + int32 field_510 = 510; + } +} diff --git a/Protos/unittest_swift_reserved.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_reserved.proto similarity index 98% rename from Protos/unittest_swift_reserved.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_reserved.proto index 70265c38d..4d49e4b7e 100644 --- a/Protos/unittest_swift_reserved.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_reserved.proto @@ -16,7 +16,7 @@ syntax = "proto2"; -package protobuf_unittest; +package swift_proto_testing; message SwiftReservedTest { enum Enum { diff --git a/Protos/unittest_swift_reserved_ext.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_reserved_ext.proto similarity index 93% rename from Protos/unittest_swift_reserved_ext.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_reserved_ext.proto index a3092d2b6..658c658db 100644 --- a/Protos/unittest_swift_reserved_ext.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_reserved_ext.proto @@ -20,7 +20,7 @@ syntax = "proto2"; import "unittest_swift_reserved.proto"; -extend protobuf_unittest.SwiftReservedTest.Type { +extend swift_proto_testing.SwiftReservedTest.Type { // Will get _p added because it has no package/swift prefix to scope and // would otherwise be a problem when added to the message. optional bool debugDescription = 1000; @@ -34,7 +34,7 @@ extend protobuf_unittest.SwiftReservedTest.Type { } message SwiftReservedTestExt2 { - extend protobuf_unittest.SwiftReservedTest.Type { + extend swift_proto_testing.SwiftReservedTest.Type { optional bool hashValue = 1001; // Reserved words, since these end up in the "enum Extensions", they diff --git a/Protos/unittest_swift_runtime_proto2.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_runtime_proto2.proto similarity index 99% rename from Protos/unittest_swift_runtime_proto2.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_runtime_proto2.proto index f3a9f0551..c8d379805 100644 --- a/Protos/unittest_swift_runtime_proto2.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_runtime_proto2.proto @@ -29,7 +29,7 @@ syntax = "proto2"; -package protobuf_unittest; +package swift_proto_testing; message Message2 { enum Enum { diff --git a/Protos/unittest_swift_runtime_proto3.proto b/Protos/Tests/SwiftProtobufTests/unittest_swift_runtime_proto3.proto similarity index 99% rename from Protos/unittest_swift_runtime_proto3.proto rename to Protos/Tests/SwiftProtobufTests/unittest_swift_runtime_proto3.proto index 10f3f4dfd..ab21818f6 100644 --- a/Protos/unittest_swift_runtime_proto3.proto +++ b/Protos/Tests/SwiftProtobufTests/unittest_swift_runtime_proto3.proto @@ -29,7 +29,7 @@ syntax = "proto3"; -package protobuf_unittest; +package swift_proto_testing; message Message3 { enum Enum { diff --git a/Protos/Tests/SwiftProtobufTests/unittest_well_known_types.proto b/Protos/Tests/SwiftProtobufTests/unittest_well_known_types.proto new file mode 100644 index 000000000..d2cb047ee --- /dev/null +++ b/Protos/Tests/SwiftProtobufTests/unittest_well_known_types.proto @@ -0,0 +1,140 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +syntax = "proto3"; + +package swift_proto_testing; + +import "google/protobuf/any.proto"; +import "google/protobuf/api.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/empty.proto"; +import "google/protobuf/field_mask.proto"; +import "google/protobuf/source_context.proto"; +import "google/protobuf/struct.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/type.proto"; +import "google/protobuf/wrappers.proto"; + +// Test that we can include all well-known types. +// Each wrapper type is included separately, as languages +// map handle different wrappers in different ways. +message TestWellKnownTypes { + google.protobuf.Any any_field = 1; + google.protobuf.Api api_field = 2; + google.protobuf.Duration duration_field = 3; + google.protobuf.Empty empty_field = 4; + google.protobuf.FieldMask field_mask_field = 5; + google.protobuf.SourceContext source_context_field = 6; + google.protobuf.Struct struct_field = 7; + google.protobuf.Timestamp timestamp_field = 8; + google.protobuf.Type type_field = 9; + google.protobuf.DoubleValue double_field = 10; + google.protobuf.FloatValue float_field = 11; + google.protobuf.Int64Value int64_field = 12; + google.protobuf.UInt64Value uint64_field = 13; + google.protobuf.Int32Value int32_field = 14; + google.protobuf.UInt32Value uint32_field = 15; + google.protobuf.BoolValue bool_field = 16; + google.protobuf.StringValue string_field = 17; + google.protobuf.BytesValue bytes_field = 18; + // Part of struct, but useful to be able to test separately + google.protobuf.Value value_field = 19; +} + +// A repeated field for each well-known type. +message RepeatedWellKnownTypes { + repeated google.protobuf.Any any_field = 1; + repeated google.protobuf.Api api_field = 2; + repeated google.protobuf.Duration duration_field = 3; + repeated google.protobuf.Empty empty_field = 4; + repeated google.protobuf.FieldMask field_mask_field = 5; + repeated google.protobuf.SourceContext source_context_field = 6; + repeated google.protobuf.Struct struct_field = 7; + repeated google.protobuf.Timestamp timestamp_field = 8; + repeated google.protobuf.Type type_field = 9; + // These don't actually make a lot of sense, but they're not prohibited... + repeated google.protobuf.DoubleValue double_field = 10; + repeated google.protobuf.FloatValue float_field = 11; + repeated google.protobuf.Int64Value int64_field = 12; + repeated google.protobuf.UInt64Value uint64_field = 13; + repeated google.protobuf.Int32Value int32_field = 14; + repeated google.protobuf.UInt32Value uint32_field = 15; + repeated google.protobuf.BoolValue bool_field = 16; + repeated google.protobuf.StringValue string_field = 17; + repeated google.protobuf.BytesValue bytes_field = 18; +} + +message OneofWellKnownTypes { + oneof oneof_field { + google.protobuf.Any any_field = 1; + google.protobuf.Api api_field = 2; + google.protobuf.Duration duration_field = 3; + google.protobuf.Empty empty_field = 4; + google.protobuf.FieldMask field_mask_field = 5; + google.protobuf.SourceContext source_context_field = 6; + google.protobuf.Struct struct_field = 7; + google.protobuf.Timestamp timestamp_field = 8; + google.protobuf.Type type_field = 9; + google.protobuf.DoubleValue double_field = 10; + google.protobuf.FloatValue float_field = 11; + google.protobuf.Int64Value int64_field = 12; + google.protobuf.UInt64Value uint64_field = 13; + google.protobuf.Int32Value int32_field = 14; + google.protobuf.UInt32Value uint32_field = 15; + google.protobuf.BoolValue bool_field = 16; + google.protobuf.StringValue string_field = 17; + google.protobuf.BytesValue bytes_field = 18; + } +} + +// A map field for each well-known type. We only +// need to worry about the value part of the map being the +// well-known types, as messages can't be map keys. +message MapWellKnownTypes { + map any_field = 1; + map api_field = 2; + map duration_field = 3; + map empty_field = 4; + map field_mask_field = 5; + map source_context_field = 6; + map struct_field = 7; + map timestamp_field = 8; + map type_field = 9; + map double_field = 10; + map float_field = 11; + map int64_field = 12; + map uint64_field = 13; + map int32_field = 14; + map uint32_field = 15; + map bool_field = 16; + map string_field = 17; + map bytes_field = 18; +} diff --git a/Protos/Tests/protoc-gen-swiftTests/plugin_descriptor_test.proto b/Protos/Tests/protoc-gen-swiftTests/plugin_descriptor_test.proto new file mode 100644 index 000000000..d46ade2e4 --- /dev/null +++ b/Protos/Tests/protoc-gen-swiftTests/plugin_descriptor_test.proto @@ -0,0 +1,63 @@ +// 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 +/// +// ----------------------------------------------------------------------------- + +syntax = "proto2"; + +package swift_descriptor_test; + +// To check handling of extension ranges that are out of order. +message MsgExtensionRangeOrdering { + extensions 1, 3, 2, 4; + extensions 7; + reserved 8; + extensions 9; + + extensions 100 to 110; + reserved 121 to 125; + extensions 126 to 130; + extensions 111 to 120; +} + +// To check handling of extension ranges that are out of order, have fields or +// reserved things mix through them. +message MsgExtensionRangeOrderingWithFields { + extensions 1, 3, 2, 4; + optional int32 field6 = 6; + extensions 7; + reserved 8; + extensions 9; + + extensions 100 to 110; + reserved 121 to 123; + optional int32 field124 = 124; + optional int32 field125 = 125; + extensions 126 to 130; + extensions 111 to 120; + optional int32 field200 = 200; +} + +// Intermixed ranges and fields so help ensure no merge issues +message MsgExtensionRangeOrderingNoMerging { + optional int32 field1 = 1; + optional int32 field2 = 2; + extensions 3 to 5; + optional int32 field6 = 6; + extensions 7 to 12; + optional int32 field13 = 13; + optional int32 field15 = 15; + extensions 16 to 20; + optional int32 field21 = 21; +} diff --git a/Protos/generated_swift_names_enum_cases.proto b/Protos/generated_swift_names_enum_cases.proto deleted file mode 100644 index 384b8c637..000000000 --- a/Protos/generated_swift_names_enum_cases.proto +++ /dev/null @@ -1,877 +0,0 @@ -// See Makefile for the logic that generates this -// Protoc errors imply this file is being generated incorrectly -// Swift compile errors are probably bugs in protoc-gen-swift -syntax = "proto3"; -package protobuf_unittest_generated; -enum GeneratedSwiftReservedEnum { - NONE = 0; - adjusted = 1; - aggregateValue = 2; - allCases = 3; - allowAlias = 4; - alwaysPrintEnumsAsInts = 5; - annotation = 6; - any = 7; - AnyExtensionField = 8; - AnyMessageExtension = 9; - AnyMessageStorage = 10; - AnyUnpackError = 11; - Api = 12; - appended = 13; - appendUIntHex = 14; - appendUnknown = 15; - areAllInitialized = 16; - array = 17; - arrayDepth = 18; - arrayLiteral = 19; - arraySeparator = 20; - as = 21; - asciiOpenCurlyBracket = 22; - asciiZero = 23; - available = 24; - b = 25; - base64Values = 26; - baseAddress = 27; - BaseType = 28; - begin = 29; - binary = 30; - BinaryDecoder = 31; - BinaryDecodingError = 32; - BinaryDecodingOptions = 33; - BinaryDelimited = 34; - BinaryEncoder = 35; - BinaryEncodingError = 36; - BinaryEncodingMessageSetSizeVisitor = 37; - BinaryEncodingMessageSetVisitor = 38; - BinaryEncodingSizeVisitor = 39; - BinaryEncodingVisitor = 40; - binaryOptions = 41; - body = 42; - Bool = 43; - booleanLiteral = 44; - BooleanLiteralType = 45; - boolValue = 46; - bytes = 47; - bytesInGroup = 48; - bytesRead = 49; - BytesValue = 50; - c = 51; - capitalizeNext = 52; - cardinality = 53; - ccEnableArenas = 54; - ccGenericServices = 55; - Character = 56; - chars = 57; - class = 58; - clearAggregateValue = 59; - clearAllowAlias = 60; - clearBegin = 61; - clearCcEnableArenas = 62; - clearCcGenericServices = 63; - clearClientStreaming = 64; - clearCsharpNamespace = 65; - clearCtype = 66; - clearDefaultValue = 67; - clearDeprecated = 68; - clearDoubleValue = 69; - clearEnd = 70; - clearExtendee = 71; - clearExtensionValue = 72; - clearGoPackage = 73; - clearIdempotencyLevel = 74; - clearIdentifierValue = 75; - clearInputType = 76; - clearIsExtension = 77; - clearJavaGenerateEqualsAndHash = 78; - clearJavaGenericServices = 79; - clearJavaMultipleFiles = 80; - clearJavaOuterClassname = 81; - clearJavaPackage = 82; - clearJavaStringCheckUtf8 = 83; - clearJsonName = 84; - clearJstype = 85; - clearLabel = 86; - clearLazy = 87; - clearLeadingComments = 88; - clearMapEntry = 89; - clearMessageSetWireFormat = 90; - clearName = 91; - clearNamePart = 92; - clearNegativeIntValue = 93; - clearNoStandardDescriptorAccessor = 94; - clearNumber = 95; - clearObjcClassPrefix = 96; - clearOneofIndex = 97; - clearOptimizeFor = 98; - clearOptions = 99; - clearOutputType = 100; - clearPackage = 101; - clearPacked = 102; - clearPhpClassPrefix = 103; - clearPhpGenericServices = 104; - clearPhpMetadataNamespace = 105; - clearPhpNamespace = 106; - clearPositiveIntValue = 107; - clearProto3Optional = 108; - clearPyGenericServices = 109; - clearRubyPackage = 110; - clearServerStreaming = 111; - clearSourceCodeInfo = 112; - clearSourceContext = 113; - clearSourceFile = 114; - clearStart = 115; - clearStringValue = 116; - clearSwiftPrefix = 117; - clearSyntax = 118; - clearTrailingComments = 119; - clearType = 120; - clearTypeName = 121; - clearValue = 122; - clearWeak = 123; - clientStreaming = 124; - codePoint = 125; - codeUnits = 126; - Collection = 127; - com = 128; - comma = 129; - contentsOf = 130; - ContiguousBytes = 131; - count = 132; - countVarintsInBuffer = 133; - csharpNamespace = 134; - ctype = 135; - customCodable = 136; - CustomDebugStringConvertible = 137; - d = 138; - Data = 139; - dataResult = 140; - date = 141; - daySec = 142; - daysSinceEpoch = 143; - debugDescription = 144; - decoded = 145; - decodedFromJSONNull = 146; - decodeExtensionField = 147; - decodeExtensionFieldsAsMessageSet = 148; - decodeJSON = 149; - decodeMapField = 150; - decodeMessage = 151; - decoder = 152; - decodeRepeated = 153; - decodeRepeatedBoolField = 154; - decodeRepeatedBytesField = 155; - decodeRepeatedDoubleField = 156; - decodeRepeatedEnumField = 157; - decodeRepeatedFixed32Field = 158; - decodeRepeatedFixed64Field = 159; - decodeRepeatedFloatField = 160; - decodeRepeatedGroupField = 161; - decodeRepeatedInt32Field = 162; - decodeRepeatedInt64Field = 163; - decodeRepeatedMessageField = 164; - decodeRepeatedSFixed32Field = 165; - decodeRepeatedSFixed64Field = 166; - decodeRepeatedSInt32Field = 167; - decodeRepeatedSInt64Field = 168; - decodeRepeatedStringField = 169; - decodeRepeatedUInt32Field = 170; - decodeRepeatedUInt64Field = 171; - decodeSingular = 172; - decodeSingularBoolField = 173; - decodeSingularBytesField = 174; - decodeSingularDoubleField = 175; - decodeSingularEnumField = 176; - decodeSingularFixed32Field = 177; - decodeSingularFixed64Field = 178; - decodeSingularFloatField = 179; - decodeSingularGroupField = 180; - decodeSingularInt32Field = 181; - decodeSingularInt64Field = 182; - decodeSingularMessageField = 183; - decodeSingularSFixed32Field = 184; - decodeSingularSFixed64Field = 185; - decodeSingularSInt32Field = 186; - decodeSingularSInt64Field = 187; - decodeSingularStringField = 188; - decodeSingularUInt32Field = 189; - decodeSingularUInt64Field = 190; - decodeTextFormat = 191; - defaultAnyTypeURLPrefix = 192; - defaultValue = 193; - dependency = 194; - deprecated = 195; - description = 196; - DescriptorProto = 197; - Dictionary = 198; - dictionaryLiteral = 199; - digit = 200; - digit0 = 201; - digit1 = 202; - digitCount = 203; - digits = 204; - digitValue = 205; - discardableResult = 206; - discardUnknownFields = 207; - distance = 208; - double = 209; - doubleValue = 210; - Duration = 211; - E = 212; - Element = 213; - elements = 214; - emitExtensionFieldName = 215; - emitFieldName = 216; - emitFieldNumber = 217; - Empty = 218; - emptyData = 219; - encodeAsBytes = 220; - encoded = 221; - encodedJSONString = 222; - encodedSize = 223; - encodeField = 224; - encoder = 225; - end = 226; - endArray = 227; - endMessageField = 228; - endObject = 229; - endRegularField = 230; - enum = 231; - EnumDescriptorProto = 232; - EnumOptions = 233; - EnumReservedRange = 234; - enumType = 235; - enumvalue = 236; - EnumValueDescriptorProto = 237; - EnumValueOptions = 238; - Equatable = 239; - Error = 240; - ExpressibleByArrayLiteral = 241; - ExpressibleByDictionaryLiteral = 242; - ext = 243; - extDecoder = 244; - extendedGraphemeClusterLiteral = 245; - ExtendedGraphemeClusterLiteralType = 246; - extendee = 247; - ExtensibleMessage = 248; - extension = 249; - ExtensionField = 250; - extensionFieldNumber = 251; - ExtensionFieldValueSet = 252; - ExtensionMap = 253; - extensionRange = 254; - ExtensionRangeOptions = 255; - extensions = 256; - extras = 257; - F = 258; - false = 259; - field = 260; - fieldData = 261; - FieldDescriptorProto = 262; - FieldMask = 263; - fieldName = 264; - fieldNameCount = 265; - fieldNum = 266; - fieldNumber = 267; - fieldNumberForProto = 268; - FieldOptions = 269; - fields = 270; - fieldSize = 271; - FieldTag = 272; - fieldType = 273; - file = 274; - FileDescriptorProto = 275; - FileDescriptorSet = 276; - fileName = 277; - FileOptions = 278; - filter = 279; - first = 280; - firstItem = 281; - float = 282; - floatLiteral = 283; - FloatLiteralType = 284; - FloatValue = 285; - forMessageName = 286; - formUnion = 287; - forReadingFrom = 288; - forTypeURL = 289; - ForwardParser = 290; - forWritingInto = 291; - from = 292; - fromAscii2 = 293; - fromAscii4 = 294; - fromByteOffset = 295; - fromHexDigit = 296; - func = 297; - G = 298; - GeneratedCodeInfo = 299; - get = 300; - getExtensionValue = 301; - googleapis = 302; - Google_Protobuf_Any = 303; - Google_Protobuf_Api = 304; - Google_Protobuf_BoolValue = 305; - Google_Protobuf_BytesValue = 306; - Google_Protobuf_DescriptorProto = 307; - Google_Protobuf_DoubleValue = 308; - Google_Protobuf_Duration = 309; - Google_Protobuf_Empty = 310; - Google_Protobuf_Enum = 311; - Google_Protobuf_EnumDescriptorProto = 312; - Google_Protobuf_EnumOptions = 313; - Google_Protobuf_EnumValue = 314; - Google_Protobuf_EnumValueDescriptorProto = 315; - Google_Protobuf_EnumValueOptions = 316; - Google_Protobuf_ExtensionRangeOptions = 317; - Google_Protobuf_Field = 318; - Google_Protobuf_FieldDescriptorProto = 319; - Google_Protobuf_FieldMask = 320; - Google_Protobuf_FieldOptions = 321; - Google_Protobuf_FileDescriptorProto = 322; - Google_Protobuf_FileDescriptorSet = 323; - Google_Protobuf_FileOptions = 324; - Google_Protobuf_FloatValue = 325; - Google_Protobuf_GeneratedCodeInfo = 326; - Google_Protobuf_Int32Value = 327; - Google_Protobuf_Int64Value = 328; - Google_Protobuf_ListValue = 329; - Google_Protobuf_MessageOptions = 330; - Google_Protobuf_Method = 331; - Google_Protobuf_MethodDescriptorProto = 332; - Google_Protobuf_MethodOptions = 333; - Google_Protobuf_Mixin = 334; - Google_Protobuf_NullValue = 335; - Google_Protobuf_OneofDescriptorProto = 336; - Google_Protobuf_OneofOptions = 337; - Google_Protobuf_Option = 338; - Google_Protobuf_ServiceDescriptorProto = 339; - Google_Protobuf_ServiceOptions = 340; - Google_Protobuf_SourceCodeInfo = 341; - Google_Protobuf_SourceContext = 342; - Google_Protobuf_StringValue = 343; - Google_Protobuf_Struct = 344; - Google_Protobuf_Syntax = 345; - Google_Protobuf_Timestamp = 346; - Google_Protobuf_Type = 347; - Google_Protobuf_UInt32Value = 348; - Google_Protobuf_UInt64Value = 349; - Google_Protobuf_UninterpretedOption = 350; - Google_Protobuf_Value = 351; - goPackage = 352; - group = 353; - groupFieldNumberStack = 354; - groupSize = 355; - h = 356; - hadOneofValue = 357; - handleConflictingOneOf = 358; - hasAggregateValue = 359; - hasAllowAlias = 360; - hasBegin = 361; - hasCcEnableArenas = 362; - hasCcGenericServices = 363; - hasClientStreaming = 364; - hasCsharpNamespace = 365; - hasCtype = 366; - hasDefaultValue = 367; - hasDeprecated = 368; - hasDoubleValue = 369; - hasEnd = 370; - hasExtendee = 371; - hasExtensionValue = 372; - hasGoPackage = 373; - hash = 374; - Hashable = 375; - hasher = 376; - hashValue = 377; - HashVisitor = 378; - hasIdempotencyLevel = 379; - hasIdentifierValue = 380; - hasInputType = 381; - hasIsExtension = 382; - hasJavaGenerateEqualsAndHash = 383; - hasJavaGenericServices = 384; - hasJavaMultipleFiles = 385; - hasJavaOuterClassname = 386; - hasJavaPackage = 387; - hasJavaStringCheckUtf8 = 388; - hasJsonName = 389; - hasJstype = 390; - hasLabel = 391; - hasLazy = 392; - hasLeadingComments = 393; - hasMapEntry = 394; - hasMessageSetWireFormat = 395; - hasName = 396; - hasNamePart = 397; - hasNegativeIntValue = 398; - hasNoStandardDescriptorAccessor = 399; - hasNumber = 400; - hasObjcClassPrefix = 401; - hasOneofIndex = 402; - hasOptimizeFor = 403; - hasOptions = 404; - hasOutputType = 405; - hasPackage = 406; - hasPacked = 407; - hasPhpClassPrefix = 408; - hasPhpGenericServices = 409; - hasPhpMetadataNamespace = 410; - hasPhpNamespace = 411; - hasPositiveIntValue = 412; - hasProto3Optional = 413; - hasPyGenericServices = 414; - hasRubyPackage = 415; - hasServerStreaming = 416; - hasSourceCodeInfo = 417; - hasSourceContext = 418; - hasSourceFile = 419; - hasStart = 420; - hasStringValue = 421; - hasSwiftPrefix = 422; - hasSyntax = 423; - hasTrailingComments = 424; - hasType = 425; - hasTypeName = 426; - hasValue = 427; - hasWeak = 428; - hour = 429; - i = 430; - idempotencyLevel = 431; - identifierValue = 432; - if = 433; - ignoreUnknownFields = 434; - index = 435; - init = 436; - inout = 437; - inputType = 438; - insert = 439; - Int = 440; - Int32 = 441; - Int32Value = 442; - Int64 = 443; - Int64Value = 444; - Int8 = 445; - integerLiteral = 446; - IntegerLiteralType = 447; - intern = 448; - Internal = 449; - InternalState = 450; - into = 451; - ints = 452; - isA = 453; - isEqual = 454; - isEqualTo = 455; - isExtension = 456; - isInitialized = 457; - itemTagsEncodedSize = 458; - Iterator = 459; - i_2166136261 = 460; - javaGenerateEqualsAndHash = 461; - javaGenericServices = 462; - javaMultipleFiles = 463; - javaOuterClassname = 464; - javaPackage = 465; - javaStringCheckUtf8 = 466; - JSONDecoder = 467; - JSONDecodingError = 468; - JSONDecodingOptions = 469; - jsonEncoder = 470; - JSONEncodingError = 471; - JSONEncodingOptions = 472; - JSONEncodingVisitor = 473; - JSONMapEncodingVisitor = 474; - jsonName = 475; - jsonPath = 476; - jsonPaths = 477; - JSONScanner = 478; - jsonString = 479; - jsonText = 480; - jsonUTF8Data = 481; - jstype = 482; - k = 483; - Key = 484; - keyField = 485; - KeyType = 486; - kind = 487; - l = 488; - label = 489; - lazy = 490; - leadingComments = 491; - leadingDetachedComments = 492; - length = 493; - lessThan = 494; - let = 495; - lhs = 496; - list = 497; - listOfMessages = 498; - listValue = 499; - littleEndian = 500; - littleEndianBytes = 501; - load = 502; - localHasher = 503; - location = 504; - M = 505; - major = 506; - makeIterator = 507; - mapEntry = 508; - mapHash = 509; - MapKeyType = 510; - mapNameResolver = 511; - mapToMessages = 512; - MapValueType = 513; - mapVisitor = 514; - mdayStart = 515; - merge = 516; - message = 517; - messageDepthLimit = 518; - MessageExtension = 519; - MessageImplementationBase = 520; - MessageOptions = 521; - MessageSet = 522; - messageSetWireFormat = 523; - messageType = 524; - Method = 525; - MethodDescriptorProto = 526; - MethodOptions = 527; - methods = 528; - minor = 529; - Mixin = 530; - mixins = 531; - modifier = 532; - modify = 533; - month = 534; - msgExtension = 535; - mutating = 536; - n = 537; - name = 538; - NameDescription = 539; - NameMap = 540; - NamePart = 541; - nameResolver = 542; - names = 543; - nanos = 544; - nativeBytes = 545; - nativeEndianBytes = 546; - negativeIntValue = 547; - nestedType = 548; - newL = 549; - newList = 550; - newValue = 551; - nextByte = 552; - nextFieldNumber = 553; - nil = 554; - nilLiteral = 555; - noStandardDescriptorAccessor = 556; - nullValue = 557; - number = 558; - numberValue = 559; - objcClassPrefix = 560; - of = 561; - oneofDecl = 562; - OneofDescriptorProto = 563; - oneofIndex = 564; - OneofOptions = 565; - oneofs = 566; - OneOf_Kind = 567; - optimizeFor = 568; - OptimizeMode = 569; - Option = 570; - OptionalEnumExtensionField = 571; - OptionalExtensionField = 572; - OptionalGroupExtensionField = 573; - OptionalMessageExtensionField = 574; - options = 575; - other = 576; - others = 577; - out = 578; - outputType = 579; - p = 580; - package = 581; - packed = 582; - PackedEnumExtensionField = 583; - PackedExtensionField = 584; - padding = 585; - parent = 586; - parse = 587; - partial = 588; - path = 589; - paths = 590; - payload = 591; - payloadSize = 592; - phpClassPrefix = 593; - phpGenericServices = 594; - phpMetadataNamespace = 595; - phpNamespace = 596; - pointer = 597; - pos = 598; - positiveIntValue = 599; - prefix = 600; - preserveProtoFieldNames = 601; - preTraverse = 602; - printUnknownFields = 603; - proto2 = 604; - proto3DefaultValue = 605; - proto3Optional = 606; - ProtobufAPIVersionCheck = 607; - ProtobufAPIVersion_2 = 608; - ProtobufBool = 609; - ProtobufBytes = 610; - ProtobufDouble = 611; - ProtobufEnumMap = 612; - protobufExtension = 613; - ProtobufFixed32 = 614; - ProtobufFixed64 = 615; - ProtobufFloat = 616; - ProtobufInt32 = 617; - ProtobufInt64 = 618; - ProtobufMap = 619; - ProtobufMessageMap = 620; - ProtobufSFixed32 = 621; - ProtobufSFixed64 = 622; - ProtobufSInt32 = 623; - ProtobufSInt64 = 624; - ProtobufString = 625; - ProtobufUInt32 = 626; - ProtobufUInt64 = 627; - protobuf_extensionFieldValues = 628; - protobuf_fieldNumber = 629; - protobuf_generated_isEqualTo = 630; - protobuf_nameMap = 631; - protobuf_newField = 632; - protobuf_package = 633; - protocol = 634; - protoFieldName = 635; - protoMessageName = 636; - ProtoNameProviding = 637; - protoPaths = 638; - public = 639; - publicDependency = 640; - putBoolValue = 641; - putBytesValue = 642; - putDoubleValue = 643; - putEnumValue = 644; - putFixedUInt32 = 645; - putFixedUInt64 = 646; - putFloatValue = 647; - putInt64 = 648; - putStringValue = 649; - putUInt64 = 650; - putUInt64Hex = 651; - putVarInt = 652; - putZigZagVarInt = 653; - pyGenericServices = 654; - rawChars = 655; - RawRepresentable = 656; - RawValue = 657; - read4HexDigits = 658; - register = 659; - RepeatedEnumExtensionField = 660; - RepeatedExtensionField = 661; - RepeatedGroupExtensionField = 662; - RepeatedMessageExtensionField = 663; - requestStreaming = 664; - requestTypeURL = 665; - requiredSize = 666; - reservedName = 667; - reservedRange = 668; - responseStreaming = 669; - responseTypeURL = 670; - result = 671; - rethrows = 672; - return = 673; - ReturnType = 674; - revision = 675; - rhs = 676; - root = 677; - rubyPackage = 678; - s = 679; - sawBackslash = 680; - sawSection4Characters = 681; - sawSection5Characters = 682; - scanner = 683; - seconds = 684; - self = 685; - separator = 686; - serialize = 687; - serializedData = 688; - serializedSize = 689; - serverStreaming = 690; - service = 691; - ServiceDescriptorProto = 692; - ServiceOptions = 693; - set = 694; - setExtensionValue = 695; - shift = 696; - SimpleExtensionMap = 697; - sizer = 698; - source = 699; - sourceCodeInfo = 700; - sourceContext = 701; - sourceEncoding = 702; - sourceFile = 703; - span = 704; - split = 705; - start = 706; - startArray = 707; - startArrayObject = 708; - startField = 709; - startIndex = 710; - startMessageField = 711; - startObject = 712; - startRegularField = 713; - state = 714; - static = 715; - StaticString = 716; - storage = 717; - String = 718; - stringLiteral = 719; - StringLiteralType = 720; - stringResult = 721; - stringValue = 722; - struct = 723; - structValue = 724; - subDecoder = 725; - subscript = 726; - subVisitor = 727; - Swift = 728; - swiftPrefix = 729; - SwiftProtobuf = 730; - syntax = 731; - T = 732; - tag = 733; - terminator = 734; - testDecoder = 735; - text = 736; - textDecoder = 737; - TextFormatDecoder = 738; - TextFormatDecodingError = 739; - TextFormatDecodingOptions = 740; - TextFormatEncodingOptions = 741; - TextFormatEncodingVisitor = 742; - textFormatString = 743; - throws = 744; - timeInterval = 745; - timeIntervalSince1970 = 746; - timeIntervalSinceReferenceDate = 747; - Timestamp = 748; - total = 749; - totalArrayDepth = 750; - totalSize = 751; - trailingComments = 752; - traverse = 753; - true = 754; - try = 755; - type = 756; - typealias = 757; - TypeEnum = 758; - typeName = 759; - typePrefix = 760; - typeStart = 761; - typeUnknown = 762; - typeURL = 763; - UInt32 = 764; - UInt32Value = 765; - UInt64 = 766; - UInt64Value = 767; - UInt8 = 768; - unicodeScalarLiteral = 769; - UnicodeScalarLiteralType = 770; - unicodeScalars = 771; - UnicodeScalarView = 772; - uninterpretedOption = 773; - union = 774; - uniqueStorage = 775; - unknown = 776; - unknownFields = 777; - UnknownStorage = 778; - unpackTo = 779; - UnsafeBufferPointer = 780; - UnsafeMutablePointer = 781; - UnsafeMutableRawBufferPointer = 782; - UnsafeMutableRawPointer = 783; - UnsafeRawBufferPointer = 784; - UnsafeRawPointer = 785; - updatedOptions = 786; - url = 787; - utf8 = 788; - utf8Ptr = 789; - utf8ToDouble = 790; - UTF8View = 791; - v = 792; - value = 793; - valueField = 794; - values = 795; - ValueType = 796; - var = 797; - Version = 798; - versionString = 799; - visitExtensionFields = 800; - visitExtensionFieldsAsMessageSet = 801; - visitMapField = 802; - visitor = 803; - visitPacked = 804; - visitPackedBoolField = 805; - visitPackedDoubleField = 806; - visitPackedEnumField = 807; - visitPackedFixed32Field = 808; - visitPackedFixed64Field = 809; - visitPackedFloatField = 810; - visitPackedInt32Field = 811; - visitPackedInt64Field = 812; - visitPackedSFixed32Field = 813; - visitPackedSFixed64Field = 814; - visitPackedSInt32Field = 815; - visitPackedSInt64Field = 816; - visitPackedUInt32Field = 817; - visitPackedUInt64Field = 818; - visitRepeated = 819; - visitRepeatedBoolField = 820; - visitRepeatedBytesField = 821; - visitRepeatedDoubleField = 822; - visitRepeatedEnumField = 823; - visitRepeatedFixed32Field = 824; - visitRepeatedFixed64Field = 825; - visitRepeatedFloatField = 826; - visitRepeatedGroupField = 827; - visitRepeatedInt32Field = 828; - visitRepeatedInt64Field = 829; - visitRepeatedMessageField = 830; - visitRepeatedSFixed32Field = 831; - visitRepeatedSFixed64Field = 832; - visitRepeatedSInt32Field = 833; - visitRepeatedSInt64Field = 834; - visitRepeatedStringField = 835; - visitRepeatedUInt32Field = 836; - visitRepeatedUInt64Field = 837; - visitSingular = 838; - visitSingularBoolField = 839; - visitSingularBytesField = 840; - visitSingularDoubleField = 841; - visitSingularEnumField = 842; - visitSingularFixed32Field = 843; - visitSingularFixed64Field = 844; - visitSingularFloatField = 845; - visitSingularGroupField = 846; - visitSingularInt32Field = 847; - visitSingularInt64Field = 848; - visitSingularMessageField = 849; - visitSingularSFixed32Field = 850; - visitSingularSFixed64Field = 851; - visitSingularSInt32Field = 852; - visitSingularSInt64Field = 853; - visitSingularStringField = 854; - visitSingularUInt32Field = 855; - visitSingularUInt64Field = 856; - visitUnknown = 857; - wasDecoded = 858; - weak = 859; - weakDependency = 860; - where = 861; - wireFormat = 862; - with = 863; - withUnsafeBytes = 864; - withUnsafeMutableBytes = 865; - work = 866; - WrappedType = 867; - written = 868; - yday = 869; -} diff --git a/Protos/generated_swift_names_fields.proto b/Protos/generated_swift_names_fields.proto deleted file mode 100644 index 6eefe8085..000000000 --- a/Protos/generated_swift_names_fields.proto +++ /dev/null @@ -1,876 +0,0 @@ -// See Makefile for the logic that generates this -// Protoc errors imply this file is being generated incorrectly -// Swift compile errors are probably bugs in protoc-gen-swift -syntax = "proto3"; -package protobuf_unittest_generated; -message GeneratedSwiftReservedFields { - int32 adjusted = 1; - int32 aggregateValue = 2; - int32 allCases = 3; - int32 allowAlias = 4; - int32 alwaysPrintEnumsAsInts = 5; - int32 annotation = 6; - int32 any = 7; - int32 AnyExtensionField = 8; - int32 AnyMessageExtension = 9; - int32 AnyMessageStorage = 10; - int32 AnyUnpackError = 11; - int32 Api = 12; - int32 appended = 13; - int32 appendUIntHex = 14; - int32 appendUnknown = 15; - int32 areAllInitialized = 16; - int32 array = 17; - int32 arrayDepth = 18; - int32 arrayLiteral = 19; - int32 arraySeparator = 20; - int32 as = 21; - int32 asciiOpenCurlyBracket = 22; - int32 asciiZero = 23; - int32 available = 24; - int32 b = 25; - int32 base64Values = 26; - int32 baseAddress = 27; - int32 BaseType = 28; - int32 begin = 29; - int32 binary = 30; - int32 BinaryDecoder = 31; - int32 BinaryDecodingError = 32; - int32 BinaryDecodingOptions = 33; - int32 BinaryDelimited = 34; - int32 BinaryEncoder = 35; - int32 BinaryEncodingError = 36; - int32 BinaryEncodingMessageSetSizeVisitor = 37; - int32 BinaryEncodingMessageSetVisitor = 38; - int32 BinaryEncodingSizeVisitor = 39; - int32 BinaryEncodingVisitor = 40; - int32 binaryOptions = 41; - int32 body = 42; - int32 Bool = 43; - int32 booleanLiteral = 44; - int32 BooleanLiteralType = 45; - int32 boolValue = 46; - int32 bytes = 47; - int32 bytesInGroup = 48; - int32 bytesRead = 49; - int32 BytesValue = 50; - int32 c = 51; - int32 capitalizeNext = 52; - int32 cardinality = 53; - int32 ccEnableArenas = 54; - int32 ccGenericServices = 55; - int32 Character = 56; - int32 chars = 57; - int32 class = 58; - int32 clearAggregateValue = 59; - int32 clearAllowAlias = 60; - int32 clearBegin = 61; - int32 clearCcEnableArenas = 62; - int32 clearCcGenericServices = 63; - int32 clearClientStreaming = 64; - int32 clearCsharpNamespace = 65; - int32 clearCtype = 66; - int32 clearDefaultValue = 67; - int32 clearDeprecated = 68; - int32 clearDoubleValue = 69; - int32 clearEnd = 70; - int32 clearExtendee = 71; - int32 clearExtensionValue = 72; - int32 clearGoPackage = 73; - int32 clearIdempotencyLevel = 74; - int32 clearIdentifierValue = 75; - int32 clearInputType = 76; - int32 clearIsExtension = 77; - int32 clearJavaGenerateEqualsAndHash = 78; - int32 clearJavaGenericServices = 79; - int32 clearJavaMultipleFiles = 80; - int32 clearJavaOuterClassname = 81; - int32 clearJavaPackage = 82; - int32 clearJavaStringCheckUtf8 = 83; - int32 clearJsonName = 84; - int32 clearJstype = 85; - int32 clearLabel = 86; - int32 clearLazy = 87; - int32 clearLeadingComments = 88; - int32 clearMapEntry = 89; - int32 clearMessageSetWireFormat = 90; - int32 clearName = 91; - int32 clearNamePart = 92; - int32 clearNegativeIntValue = 93; - int32 clearNoStandardDescriptorAccessor = 94; - int32 clearNumber = 95; - int32 clearObjcClassPrefix = 96; - int32 clearOneofIndex = 97; - int32 clearOptimizeFor = 98; - int32 clearOptions = 99; - int32 clearOutputType = 100; - int32 clearPackage = 101; - int32 clearPacked = 102; - int32 clearPhpClassPrefix = 103; - int32 clearPhpGenericServices = 104; - int32 clearPhpMetadataNamespace = 105; - int32 clearPhpNamespace = 106; - int32 clearPositiveIntValue = 107; - int32 clearProto3Optional = 108; - int32 clearPyGenericServices = 109; - int32 clearRubyPackage = 110; - int32 clearServerStreaming = 111; - int32 clearSourceCodeInfo = 112; - int32 clearSourceContext = 113; - int32 clearSourceFile = 114; - int32 clearStart = 115; - int32 clearStringValue = 116; - int32 clearSwiftPrefix = 117; - int32 clearSyntax = 118; - int32 clearTrailingComments = 119; - int32 clearType = 120; - int32 clearTypeName = 121; - int32 clearValue = 122; - int32 clearWeak = 123; - int32 clientStreaming = 124; - int32 codePoint = 125; - int32 codeUnits = 126; - int32 Collection = 127; - int32 com = 128; - int32 comma = 129; - int32 contentsOf = 130; - int32 ContiguousBytes = 131; - int32 count = 132; - int32 countVarintsInBuffer = 133; - int32 csharpNamespace = 134; - int32 ctype = 135; - int32 customCodable = 136; - int32 CustomDebugStringConvertible = 137; - int32 d = 138; - int32 Data = 139; - int32 dataResult = 140; - int32 date = 141; - int32 daySec = 142; - int32 daysSinceEpoch = 143; - int32 debugDescription = 144; - int32 decoded = 145; - int32 decodedFromJSONNull = 146; - int32 decodeExtensionField = 147; - int32 decodeExtensionFieldsAsMessageSet = 148; - int32 decodeJSON = 149; - int32 decodeMapField = 150; - int32 decodeMessage = 151; - int32 decoder = 152; - int32 decodeRepeated = 153; - int32 decodeRepeatedBoolField = 154; - int32 decodeRepeatedBytesField = 155; - int32 decodeRepeatedDoubleField = 156; - int32 decodeRepeatedEnumField = 157; - int32 decodeRepeatedFixed32Field = 158; - int32 decodeRepeatedFixed64Field = 159; - int32 decodeRepeatedFloatField = 160; - int32 decodeRepeatedGroupField = 161; - int32 decodeRepeatedInt32Field = 162; - int32 decodeRepeatedInt64Field = 163; - int32 decodeRepeatedMessageField = 164; - int32 decodeRepeatedSFixed32Field = 165; - int32 decodeRepeatedSFixed64Field = 166; - int32 decodeRepeatedSInt32Field = 167; - int32 decodeRepeatedSInt64Field = 168; - int32 decodeRepeatedStringField = 169; - int32 decodeRepeatedUInt32Field = 170; - int32 decodeRepeatedUInt64Field = 171; - int32 decodeSingular = 172; - int32 decodeSingularBoolField = 173; - int32 decodeSingularBytesField = 174; - int32 decodeSingularDoubleField = 175; - int32 decodeSingularEnumField = 176; - int32 decodeSingularFixed32Field = 177; - int32 decodeSingularFixed64Field = 178; - int32 decodeSingularFloatField = 179; - int32 decodeSingularGroupField = 180; - int32 decodeSingularInt32Field = 181; - int32 decodeSingularInt64Field = 182; - int32 decodeSingularMessageField = 183; - int32 decodeSingularSFixed32Field = 184; - int32 decodeSingularSFixed64Field = 185; - int32 decodeSingularSInt32Field = 186; - int32 decodeSingularSInt64Field = 187; - int32 decodeSingularStringField = 188; - int32 decodeSingularUInt32Field = 189; - int32 decodeSingularUInt64Field = 190; - int32 decodeTextFormat = 191; - int32 defaultAnyTypeURLPrefix = 192; - int32 defaultValue = 193; - int32 dependency = 194; - int32 deprecated = 195; - int32 description = 196; - int32 DescriptorProto = 197; - int32 Dictionary = 198; - int32 dictionaryLiteral = 199; - int32 digit = 200; - int32 digit0 = 201; - int32 digit1 = 202; - int32 digitCount = 203; - int32 digits = 204; - int32 digitValue = 205; - int32 discardableResult = 206; - int32 discardUnknownFields = 207; - int32 distance = 208; - int32 double = 209; - int32 doubleValue = 210; - int32 Duration = 211; - int32 E = 212; - int32 Element = 213; - int32 elements = 214; - int32 emitExtensionFieldName = 215; - int32 emitFieldName = 216; - int32 emitFieldNumber = 217; - int32 Empty = 218; - int32 emptyData = 219; - int32 encodeAsBytes = 220; - int32 encoded = 221; - int32 encodedJSONString = 222; - int32 encodedSize = 223; - int32 encodeField = 224; - int32 encoder = 225; - int32 end = 226; - int32 endArray = 227; - int32 endMessageField = 228; - int32 endObject = 229; - int32 endRegularField = 230; - int32 enum = 231; - int32 EnumDescriptorProto = 232; - int32 EnumOptions = 233; - int32 EnumReservedRange = 234; - int32 enumType = 235; - int32 enumvalue = 236; - int32 EnumValueDescriptorProto = 237; - int32 EnumValueOptions = 238; - int32 Equatable = 239; - int32 Error = 240; - int32 ExpressibleByArrayLiteral = 241; - int32 ExpressibleByDictionaryLiteral = 242; - int32 ext = 243; - int32 extDecoder = 244; - int32 extendedGraphemeClusterLiteral = 245; - int32 ExtendedGraphemeClusterLiteralType = 246; - int32 extendee = 247; - int32 ExtensibleMessage = 248; - int32 extension = 249; - int32 ExtensionField = 250; - int32 extensionFieldNumber = 251; - int32 ExtensionFieldValueSet = 252; - int32 ExtensionMap = 253; - int32 extensionRange = 254; - int32 ExtensionRangeOptions = 255; - int32 extensions = 256; - int32 extras = 257; - int32 F = 258; - int32 false = 259; - int32 field = 260; - int32 fieldData = 261; - int32 FieldDescriptorProto = 262; - int32 FieldMask = 263; - int32 fieldName = 264; - int32 fieldNameCount = 265; - int32 fieldNum = 266; - int32 fieldNumber = 267; - int32 fieldNumberForProto = 268; - int32 FieldOptions = 269; - int32 fields = 270; - int32 fieldSize = 271; - int32 FieldTag = 272; - int32 fieldType = 273; - int32 file = 274; - int32 FileDescriptorProto = 275; - int32 FileDescriptorSet = 276; - int32 fileName = 277; - int32 FileOptions = 278; - int32 filter = 279; - int32 first = 280; - int32 firstItem = 281; - int32 float = 282; - int32 floatLiteral = 283; - int32 FloatLiteralType = 284; - int32 FloatValue = 285; - int32 forMessageName = 286; - int32 formUnion = 287; - int32 forReadingFrom = 288; - int32 forTypeURL = 289; - int32 ForwardParser = 290; - int32 forWritingInto = 291; - int32 from = 292; - int32 fromAscii2 = 293; - int32 fromAscii4 = 294; - int32 fromByteOffset = 295; - int32 fromHexDigit = 296; - int32 func = 297; - int32 G = 298; - int32 GeneratedCodeInfo = 299; - int32 get = 300; - int32 getExtensionValue = 301; - int32 googleapis = 302; - int32 Google_Protobuf_Any = 303; - int32 Google_Protobuf_Api = 304; - int32 Google_Protobuf_BoolValue = 305; - int32 Google_Protobuf_BytesValue = 306; - int32 Google_Protobuf_DescriptorProto = 307; - int32 Google_Protobuf_DoubleValue = 308; - int32 Google_Protobuf_Duration = 309; - int32 Google_Protobuf_Empty = 310; - int32 Google_Protobuf_Enum = 311; - int32 Google_Protobuf_EnumDescriptorProto = 312; - int32 Google_Protobuf_EnumOptions = 313; - int32 Google_Protobuf_EnumValue = 314; - int32 Google_Protobuf_EnumValueDescriptorProto = 315; - int32 Google_Protobuf_EnumValueOptions = 316; - int32 Google_Protobuf_ExtensionRangeOptions = 317; - int32 Google_Protobuf_Field = 318; - int32 Google_Protobuf_FieldDescriptorProto = 319; - int32 Google_Protobuf_FieldMask = 320; - int32 Google_Protobuf_FieldOptions = 321; - int32 Google_Protobuf_FileDescriptorProto = 322; - int32 Google_Protobuf_FileDescriptorSet = 323; - int32 Google_Protobuf_FileOptions = 324; - int32 Google_Protobuf_FloatValue = 325; - int32 Google_Protobuf_GeneratedCodeInfo = 326; - int32 Google_Protobuf_Int32Value = 327; - int32 Google_Protobuf_Int64Value = 328; - int32 Google_Protobuf_ListValue = 329; - int32 Google_Protobuf_MessageOptions = 330; - int32 Google_Protobuf_Method = 331; - int32 Google_Protobuf_MethodDescriptorProto = 332; - int32 Google_Protobuf_MethodOptions = 333; - int32 Google_Protobuf_Mixin = 334; - int32 Google_Protobuf_NullValue = 335; - int32 Google_Protobuf_OneofDescriptorProto = 336; - int32 Google_Protobuf_OneofOptions = 337; - int32 Google_Protobuf_Option = 338; - int32 Google_Protobuf_ServiceDescriptorProto = 339; - int32 Google_Protobuf_ServiceOptions = 340; - int32 Google_Protobuf_SourceCodeInfo = 341; - int32 Google_Protobuf_SourceContext = 342; - int32 Google_Protobuf_StringValue = 343; - int32 Google_Protobuf_Struct = 344; - int32 Google_Protobuf_Syntax = 345; - int32 Google_Protobuf_Timestamp = 346; - int32 Google_Protobuf_Type = 347; - int32 Google_Protobuf_UInt32Value = 348; - int32 Google_Protobuf_UInt64Value = 349; - int32 Google_Protobuf_UninterpretedOption = 350; - int32 Google_Protobuf_Value = 351; - int32 goPackage = 352; - int32 group = 353; - int32 groupFieldNumberStack = 354; - int32 groupSize = 355; - int32 h = 356; - int32 hadOneofValue = 357; - int32 handleConflictingOneOf = 358; - int32 hasAggregateValue = 359; - int32 hasAllowAlias = 360; - int32 hasBegin = 361; - int32 hasCcEnableArenas = 362; - int32 hasCcGenericServices = 363; - int32 hasClientStreaming = 364; - int32 hasCsharpNamespace = 365; - int32 hasCtype = 366; - int32 hasDefaultValue = 367; - int32 hasDeprecated = 368; - int32 hasDoubleValue = 369; - int32 hasEnd = 370; - int32 hasExtendee = 371; - int32 hasExtensionValue = 372; - int32 hasGoPackage = 373; - int32 hash = 374; - int32 Hashable = 375; - int32 hasher = 376; - int32 hashValue = 377; - int32 HashVisitor = 378; - int32 hasIdempotencyLevel = 379; - int32 hasIdentifierValue = 380; - int32 hasInputType = 381; - int32 hasIsExtension = 382; - int32 hasJavaGenerateEqualsAndHash = 383; - int32 hasJavaGenericServices = 384; - int32 hasJavaMultipleFiles = 385; - int32 hasJavaOuterClassname = 386; - int32 hasJavaPackage = 387; - int32 hasJavaStringCheckUtf8 = 388; - int32 hasJsonName = 389; - int32 hasJstype = 390; - int32 hasLabel = 391; - int32 hasLazy = 392; - int32 hasLeadingComments = 393; - int32 hasMapEntry = 394; - int32 hasMessageSetWireFormat = 395; - int32 hasName = 396; - int32 hasNamePart = 397; - int32 hasNegativeIntValue = 398; - int32 hasNoStandardDescriptorAccessor = 399; - int32 hasNumber = 400; - int32 hasObjcClassPrefix = 401; - int32 hasOneofIndex = 402; - int32 hasOptimizeFor = 403; - int32 hasOptions = 404; - int32 hasOutputType = 405; - int32 hasPackage = 406; - int32 hasPacked = 407; - int32 hasPhpClassPrefix = 408; - int32 hasPhpGenericServices = 409; - int32 hasPhpMetadataNamespace = 410; - int32 hasPhpNamespace = 411; - int32 hasPositiveIntValue = 412; - int32 hasProto3Optional = 413; - int32 hasPyGenericServices = 414; - int32 hasRubyPackage = 415; - int32 hasServerStreaming = 416; - int32 hasSourceCodeInfo = 417; - int32 hasSourceContext = 418; - int32 hasSourceFile = 419; - int32 hasStart = 420; - int32 hasStringValue = 421; - int32 hasSwiftPrefix = 422; - int32 hasSyntax = 423; - int32 hasTrailingComments = 424; - int32 hasType = 425; - int32 hasTypeName = 426; - int32 hasValue = 427; - int32 hasWeak = 428; - int32 hour = 429; - int32 i = 430; - int32 idempotencyLevel = 431; - int32 identifierValue = 432; - int32 if = 433; - int32 ignoreUnknownFields = 434; - int32 index = 435; - int32 init = 436; - int32 inout = 437; - int32 inputType = 438; - int32 insert = 439; - int32 Int = 440; - int32 Int32 = 441; - int32 Int32Value = 442; - int32 Int64 = 443; - int32 Int64Value = 444; - int32 Int8 = 445; - int32 integerLiteral = 446; - int32 IntegerLiteralType = 447; - int32 intern = 448; - int32 Internal = 449; - int32 InternalState = 450; - int32 into = 451; - int32 ints = 452; - int32 isA = 453; - int32 isEqual = 454; - int32 isEqualTo = 455; - int32 isExtension = 456; - int32 isInitialized = 457; - int32 itemTagsEncodedSize = 458; - int32 Iterator = 459; - int32 i_2166136261 = 460; - int32 javaGenerateEqualsAndHash = 461; - int32 javaGenericServices = 462; - int32 javaMultipleFiles = 463; - int32 javaOuterClassname = 464; - int32 javaPackage = 465; - int32 javaStringCheckUtf8 = 466; - int32 JSONDecoder = 467; - int32 JSONDecodingError = 468; - int32 JSONDecodingOptions = 469; - int32 jsonEncoder = 470; - int32 JSONEncodingError = 471; - int32 JSONEncodingOptions = 472; - int32 JSONEncodingVisitor = 473; - int32 JSONMapEncodingVisitor = 474; - int32 jsonName = 475; - int32 jsonPath = 476; - int32 jsonPaths = 477; - int32 JSONScanner = 478; - int32 jsonString = 479; - int32 jsonText = 480; - int32 jsonUTF8Data = 481; - int32 jstype = 482; - int32 k = 483; - int32 Key = 484; - int32 keyField = 485; - int32 KeyType = 486; - int32 kind = 487; - int32 l = 488; - int32 label = 489; - int32 lazy = 490; - int32 leadingComments = 491; - int32 leadingDetachedComments = 492; - int32 length = 493; - int32 lessThan = 494; - int32 let = 495; - int32 lhs = 496; - int32 list = 497; - int32 listOfMessages = 498; - int32 listValue = 499; - int32 littleEndian = 500; - int32 littleEndianBytes = 501; - int32 load = 502; - int32 localHasher = 503; - int32 location = 504; - int32 M = 505; - int32 major = 506; - int32 makeIterator = 507; - int32 mapEntry = 508; - int32 mapHash = 509; - int32 MapKeyType = 510; - int32 mapNameResolver = 511; - int32 mapToMessages = 512; - int32 MapValueType = 513; - int32 mapVisitor = 514; - int32 mdayStart = 515; - int32 merge = 516; - int32 message = 517; - int32 messageDepthLimit = 518; - int32 MessageExtension = 519; - int32 MessageImplementationBase = 520; - int32 MessageOptions = 521; - int32 MessageSet = 522; - int32 messageSetWireFormat = 523; - int32 messageType = 524; - int32 Method = 525; - int32 MethodDescriptorProto = 526; - int32 MethodOptions = 527; - int32 methods = 528; - int32 minor = 529; - int32 Mixin = 530; - int32 mixins = 531; - int32 modifier = 532; - int32 modify = 533; - int32 month = 534; - int32 msgExtension = 535; - int32 mutating = 536; - int32 n = 537; - int32 name = 538; - int32 NameDescription = 539; - int32 NameMap = 540; - int32 NamePart = 541; - int32 nameResolver = 542; - int32 names = 543; - int32 nanos = 544; - int32 nativeBytes = 545; - int32 nativeEndianBytes = 546; - int32 negativeIntValue = 547; - int32 nestedType = 548; - int32 newL = 549; - int32 newList = 550; - int32 newValue = 551; - int32 nextByte = 552; - int32 nextFieldNumber = 553; - int32 nil = 554; - int32 nilLiteral = 555; - int32 noStandardDescriptorAccessor = 556; - int32 nullValue = 557; - int32 number = 558; - int32 numberValue = 559; - int32 objcClassPrefix = 560; - int32 of = 561; - int32 oneofDecl = 562; - int32 OneofDescriptorProto = 563; - int32 oneofIndex = 564; - int32 OneofOptions = 565; - int32 oneofs = 566; - int32 OneOf_Kind = 567; - int32 optimizeFor = 568; - int32 OptimizeMode = 569; - int32 Option = 570; - int32 OptionalEnumExtensionField = 571; - int32 OptionalExtensionField = 572; - int32 OptionalGroupExtensionField = 573; - int32 OptionalMessageExtensionField = 574; - int32 options = 575; - int32 other = 576; - int32 others = 577; - int32 out = 578; - int32 outputType = 579; - int32 p = 580; - int32 package = 581; - int32 packed = 582; - int32 PackedEnumExtensionField = 583; - int32 PackedExtensionField = 584; - int32 padding = 585; - int32 parent = 586; - int32 parse = 587; - int32 partial = 588; - int32 path = 589; - int32 paths = 590; - int32 payload = 591; - int32 payloadSize = 592; - int32 phpClassPrefix = 593; - int32 phpGenericServices = 594; - int32 phpMetadataNamespace = 595; - int32 phpNamespace = 596; - int32 pointer = 597; - int32 pos = 598; - int32 positiveIntValue = 599; - int32 prefix = 600; - int32 preserveProtoFieldNames = 601; - int32 preTraverse = 602; - int32 printUnknownFields = 603; - int32 proto2 = 604; - int32 proto3DefaultValue = 605; - int32 proto3Optional = 606; - int32 ProtobufAPIVersionCheck = 607; - int32 ProtobufAPIVersion_2 = 608; - int32 ProtobufBool = 609; - int32 ProtobufBytes = 610; - int32 ProtobufDouble = 611; - int32 ProtobufEnumMap = 612; - int32 protobufExtension = 613; - int32 ProtobufFixed32 = 614; - int32 ProtobufFixed64 = 615; - int32 ProtobufFloat = 616; - int32 ProtobufInt32 = 617; - int32 ProtobufInt64 = 618; - int32 ProtobufMap = 619; - int32 ProtobufMessageMap = 620; - int32 ProtobufSFixed32 = 621; - int32 ProtobufSFixed64 = 622; - int32 ProtobufSInt32 = 623; - int32 ProtobufSInt64 = 624; - int32 ProtobufString = 625; - int32 ProtobufUInt32 = 626; - int32 ProtobufUInt64 = 627; - int32 protobuf_extensionFieldValues = 628; - int32 protobuf_fieldNumber = 629; - int32 protobuf_generated_isEqualTo = 630; - int32 protobuf_nameMap = 631; - int32 protobuf_newField = 632; - int32 protobuf_package = 633; - int32 protocol = 634; - int32 protoFieldName = 635; - int32 protoMessageName = 636; - int32 ProtoNameProviding = 637; - int32 protoPaths = 638; - int32 public = 639; - int32 publicDependency = 640; - int32 putBoolValue = 641; - int32 putBytesValue = 642; - int32 putDoubleValue = 643; - int32 putEnumValue = 644; - int32 putFixedUInt32 = 645; - int32 putFixedUInt64 = 646; - int32 putFloatValue = 647; - int32 putInt64 = 648; - int32 putStringValue = 649; - int32 putUInt64 = 650; - int32 putUInt64Hex = 651; - int32 putVarInt = 652; - int32 putZigZagVarInt = 653; - int32 pyGenericServices = 654; - int32 rawChars = 655; - int32 RawRepresentable = 656; - int32 RawValue = 657; - int32 read4HexDigits = 658; - int32 register = 659; - int32 RepeatedEnumExtensionField = 660; - int32 RepeatedExtensionField = 661; - int32 RepeatedGroupExtensionField = 662; - int32 RepeatedMessageExtensionField = 663; - int32 requestStreaming = 664; - int32 requestTypeURL = 665; - int32 requiredSize = 666; - int32 reservedName = 667; - int32 reservedRange = 668; - int32 responseStreaming = 669; - int32 responseTypeURL = 670; - int32 result = 671; - int32 rethrows = 672; - int32 return = 673; - int32 ReturnType = 674; - int32 revision = 675; - int32 rhs = 676; - int32 root = 677; - int32 rubyPackage = 678; - int32 s = 679; - int32 sawBackslash = 680; - int32 sawSection4Characters = 681; - int32 sawSection5Characters = 682; - int32 scanner = 683; - int32 seconds = 684; - int32 self = 685; - int32 separator = 686; - int32 serialize = 687; - int32 serializedData = 688; - int32 serializedSize = 689; - int32 serverStreaming = 690; - int32 service = 691; - int32 ServiceDescriptorProto = 692; - int32 ServiceOptions = 693; - int32 set = 694; - int32 setExtensionValue = 695; - int32 shift = 696; - int32 SimpleExtensionMap = 697; - int32 sizer = 698; - int32 source = 699; - int32 sourceCodeInfo = 700; - int32 sourceContext = 701; - int32 sourceEncoding = 702; - int32 sourceFile = 703; - int32 span = 704; - int32 split = 705; - int32 start = 706; - int32 startArray = 707; - int32 startArrayObject = 708; - int32 startField = 709; - int32 startIndex = 710; - int32 startMessageField = 711; - int32 startObject = 712; - int32 startRegularField = 713; - int32 state = 714; - int32 static = 715; - int32 StaticString = 716; - int32 storage = 717; - int32 String = 718; - int32 stringLiteral = 719; - int32 StringLiteralType = 720; - int32 stringResult = 721; - int32 stringValue = 722; - int32 struct = 723; - int32 structValue = 724; - int32 subDecoder = 725; - int32 subscript = 726; - int32 subVisitor = 727; - int32 Swift = 728; - int32 swiftPrefix = 729; - int32 SwiftProtobuf = 730; - int32 syntax = 731; - int32 T = 732; - int32 tag = 733; - int32 terminator = 734; - int32 testDecoder = 735; - int32 text = 736; - int32 textDecoder = 737; - int32 TextFormatDecoder = 738; - int32 TextFormatDecodingError = 739; - int32 TextFormatDecodingOptions = 740; - int32 TextFormatEncodingOptions = 741; - int32 TextFormatEncodingVisitor = 742; - int32 textFormatString = 743; - int32 throws = 744; - int32 timeInterval = 745; - int32 timeIntervalSince1970 = 746; - int32 timeIntervalSinceReferenceDate = 747; - int32 Timestamp = 748; - int32 total = 749; - int32 totalArrayDepth = 750; - int32 totalSize = 751; - int32 trailingComments = 752; - int32 traverse = 753; - int32 true = 754; - int32 try = 755; - int32 type = 756; - int32 typealias = 757; - int32 TypeEnum = 758; - int32 typeName = 759; - int32 typePrefix = 760; - int32 typeStart = 761; - int32 typeUnknown = 762; - int32 typeURL = 763; - int32 UInt32 = 764; - int32 UInt32Value = 765; - int32 UInt64 = 766; - int32 UInt64Value = 767; - int32 UInt8 = 768; - int32 unicodeScalarLiteral = 769; - int32 UnicodeScalarLiteralType = 770; - int32 unicodeScalars = 771; - int32 UnicodeScalarView = 772; - int32 uninterpretedOption = 773; - int32 union = 774; - int32 uniqueStorage = 775; - int32 unknown = 776; - int32 unknownFields = 777; - int32 UnknownStorage = 778; - int32 unpackTo = 779; - int32 UnsafeBufferPointer = 780; - int32 UnsafeMutablePointer = 781; - int32 UnsafeMutableRawBufferPointer = 782; - int32 UnsafeMutableRawPointer = 783; - int32 UnsafeRawBufferPointer = 784; - int32 UnsafeRawPointer = 785; - int32 updatedOptions = 786; - int32 url = 787; - int32 utf8 = 788; - int32 utf8Ptr = 789; - int32 utf8ToDouble = 790; - int32 UTF8View = 791; - int32 v = 792; - int32 value = 793; - int32 valueField = 794; - int32 values = 795; - int32 ValueType = 796; - int32 var = 797; - int32 Version = 798; - int32 versionString = 799; - int32 visitExtensionFields = 800; - int32 visitExtensionFieldsAsMessageSet = 801; - int32 visitMapField = 802; - int32 visitor = 803; - int32 visitPacked = 804; - int32 visitPackedBoolField = 805; - int32 visitPackedDoubleField = 806; - int32 visitPackedEnumField = 807; - int32 visitPackedFixed32Field = 808; - int32 visitPackedFixed64Field = 809; - int32 visitPackedFloatField = 810; - int32 visitPackedInt32Field = 811; - int32 visitPackedInt64Field = 812; - int32 visitPackedSFixed32Field = 813; - int32 visitPackedSFixed64Field = 814; - int32 visitPackedSInt32Field = 815; - int32 visitPackedSInt64Field = 816; - int32 visitPackedUInt32Field = 817; - int32 visitPackedUInt64Field = 818; - int32 visitRepeated = 819; - int32 visitRepeatedBoolField = 820; - int32 visitRepeatedBytesField = 821; - int32 visitRepeatedDoubleField = 822; - int32 visitRepeatedEnumField = 823; - int32 visitRepeatedFixed32Field = 824; - int32 visitRepeatedFixed64Field = 825; - int32 visitRepeatedFloatField = 826; - int32 visitRepeatedGroupField = 827; - int32 visitRepeatedInt32Field = 828; - int32 visitRepeatedInt64Field = 829; - int32 visitRepeatedMessageField = 830; - int32 visitRepeatedSFixed32Field = 831; - int32 visitRepeatedSFixed64Field = 832; - int32 visitRepeatedSInt32Field = 833; - int32 visitRepeatedSInt64Field = 834; - int32 visitRepeatedStringField = 835; - int32 visitRepeatedUInt32Field = 836; - int32 visitRepeatedUInt64Field = 837; - int32 visitSingular = 838; - int32 visitSingularBoolField = 839; - int32 visitSingularBytesField = 840; - int32 visitSingularDoubleField = 841; - int32 visitSingularEnumField = 842; - int32 visitSingularFixed32Field = 843; - int32 visitSingularFixed64Field = 844; - int32 visitSingularFloatField = 845; - int32 visitSingularGroupField = 846; - int32 visitSingularInt32Field = 847; - int32 visitSingularInt64Field = 848; - int32 visitSingularMessageField = 849; - int32 visitSingularSFixed32Field = 850; - int32 visitSingularSFixed64Field = 851; - int32 visitSingularSInt32Field = 852; - int32 visitSingularSInt64Field = 853; - int32 visitSingularStringField = 854; - int32 visitSingularUInt32Field = 855; - int32 visitSingularUInt64Field = 856; - int32 visitUnknown = 857; - int32 wasDecoded = 858; - int32 weak = 859; - int32 weakDependency = 860; - int32 where = 861; - int32 wireFormat = 862; - int32 with = 863; - int32 withUnsafeBytes = 864; - int32 withUnsafeMutableBytes = 865; - int32 work = 866; - int32 WrappedType = 867; - int32 written = 868; - int32 yday = 869; -} diff --git a/Protos/google/protobuf/unittest_arena.proto b/Protos/google/protobuf/unittest_arena.proto deleted file mode 100644 index 7b3173996..000000000 --- a/Protos/google/protobuf/unittest_arena.proto +++ /dev/null @@ -1,43 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -syntax = "proto2"; - -package proto2_arena_unittest; - -option cc_enable_arenas = true; - -message NestedMessage { - optional int32 d = 1; -} - -message ArenaMessage { - repeated NestedMessage repeated_nested_message = 1; -} diff --git a/Protos/google/protobuf/unittest_embed_optimize_for.proto b/Protos/google/protobuf/unittest_embed_optimize_for.proto deleted file mode 100644 index d8b0f9b94..000000000 --- a/Protos/google/protobuf/unittest_embed_optimize_for.proto +++ /dev/null @@ -1,51 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// A proto file which imports a proto file that uses optimize_for = CODE_SIZE. - -syntax = "proto2"; -import "google/protobuf/unittest_optimize_for.proto"; - -package protobuf_unittest; - -// We optimize for speed here, but we are importing a proto that is optimized -// for code size. -option optimize_for = SPEED; - -message TestEmbedOptimizedForSize { - // Test that embedding a message which has optimize_for = CODE_SIZE into - // one optimized for speed works. - optional TestOptimizedForSize optional_message = 1; - repeated TestOptimizedForSize repeated_message = 2; -} diff --git a/Protos/google/protobuf/unittest_import.proto b/Protos/google/protobuf/unittest_import.proto deleted file mode 100644 index 8d03e3888..000000000 --- a/Protos/google/protobuf/unittest_import.proto +++ /dev/null @@ -1,73 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// A proto file which is imported by unittest.proto to test importing. - -syntax = "proto2"; - -// We don't put this in a package within proto2 because we need to make sure -// that the generated code doesn't depend on being in the proto2 namespace. -// In test_util.h we do -// "using namespace unittest_import = protobuf_unittest_import". -package protobuf_unittest_import; - -option optimize_for = SPEED; -option cc_enable_arenas = true; - -// Exercise the java_package option. -option java_package = "com.google.protobuf.test"; - -// Do not set a java_outer_classname here to verify that Proto2 works without -// one. - -// Test public import -import public "google/protobuf/unittest_import_public.proto"; - -message ImportMessage { - optional int32 d = 1; -} - -enum ImportEnum { - IMPORT_FOO = 7; - IMPORT_BAR = 8; - IMPORT_BAZ = 9; -} - - -// To use an enum in a map, it must has the first value as 0. -enum ImportEnumForMap { - UNKNOWN = 0; - FOO = 1; - BAR = 2; -} diff --git a/Protos/google/protobuf/unittest_lazy_dependencies.proto b/Protos/google/protobuf/unittest_lazy_dependencies.proto deleted file mode 100644 index 2f5efd2aa..000000000 --- a/Protos/google/protobuf/unittest_lazy_dependencies.proto +++ /dev/null @@ -1,75 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: trafacz@google.com (Todd Rafacz) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// A proto file we will use for unit testing. - -syntax = "proto2"; - -import "google/protobuf/unittest_lazy_dependencies_custom_option.proto"; - -// Some generic_services option(s) added automatically. -// See: http://go/proto2-generic-services-default -option cc_generic_services = true; // auto-added -option java_generic_services = true; // auto-added -option py_generic_services = true; // auto-added -option cc_enable_arenas = true; - -// We don't put this in a package within proto2 because we need to make sure -// that the generated code doesn't depend on being in the proto2 namespace. -// In test_util.h we do "using namespace unittest = protobuf_unittest". -package protobuf_unittest.lazy_imports; - -// Protos optimized for SPEED use a strict superset of the generated code -// of equivalent ones optimized for CODE_SIZE, so we should optimize all our -// tests for speed unless explicitly testing code size optimization. -option optimize_for = SPEED; - -option java_outer_classname = "UnittestLazyImportsProto"; - -// The following are used to test that the proto file -// with the definition of the following field types is -// not built when this proto file is built. Then test -// that calling message_type() etc will build the correct -// descriptor lazily and return it. - -message ImportedMessage { - optional LazyMessage lazy_message = 1; -} - -message MessageCustomOption { -} - -message MessageCustomOption2 { - option (lazy_enum_option) = LAZY_ENUM_0; -} diff --git a/Protos/google/protobuf/unittest_lazy_dependencies_custom_option.proto b/Protos/google/protobuf/unittest_lazy_dependencies_custom_option.proto deleted file mode 100644 index 22438257d..000000000 --- a/Protos/google/protobuf/unittest_lazy_dependencies_custom_option.proto +++ /dev/null @@ -1,67 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: trafacz@google.com (Todd Rafacz) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// A proto file we will use for unit testing. - -syntax = "proto2"; - -import "google/protobuf/unittest_lazy_dependencies_enum.proto"; -import "google/protobuf/descriptor.proto"; - -// Some generic_services option(s) added automatically. -// See: http://go/proto2-generic-services-default -option cc_generic_services = true; // auto-added -option java_generic_services = true; // auto-added -option py_generic_services = true; // auto-added -option cc_enable_arenas = true; - -// We don't put this in a package within proto2 because we need to make sure -// that the generated code doesn't depend on being in the proto2 namespace. -// In test_util.h we do "using namespace unittest = protobuf_unittest". -package protobuf_unittest.lazy_imports; - -// Protos optimized for SPEED use a strict superset of the generated code -// of equivalent ones optimized for CODE_SIZE, so we should optimize all our -// tests for speed unless explicitly testing code size optimization. -option optimize_for = SPEED; - -option java_outer_classname = "UnittestLazyImportsCustomOptionProto"; - -message LazyMessage { - optional int32 a = 1; -} - -extend google.protobuf.MessageOptions { - optional LazyEnum lazy_enum_option = 138596335 [default = LAZY_ENUM_1]; -} diff --git a/Protos/google/protobuf/unittest_lazy_dependencies_enum.proto b/Protos/google/protobuf/unittest_lazy_dependencies_enum.proto deleted file mode 100644 index 9be64d858..000000000 --- a/Protos/google/protobuf/unittest_lazy_dependencies_enum.proto +++ /dev/null @@ -1,61 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: trafacz@google.com (Todd Rafacz) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// A proto file we will use for unit testing. - -syntax = "proto2"; - -// Some generic_services option(s) added automatically. -// See: http://go/proto2-generic-services-default -option cc_generic_services = true; // auto-added -option java_generic_services = true; // auto-added -option py_generic_services = true; // auto-added -option cc_enable_arenas = true; - -// We don't put this in a package within proto2 because we need to make sure -// that the generated code doesn't depend on being in the proto2 namespace. -// In test_util.h we do "using namespace unittest = protobuf_unittest". -package protobuf_unittest.lazy_imports; - -// Protos optimized for SPEED use a strict superset of the generated code -// of equivalent ones optimized for CODE_SIZE, so we should optimize all our -// tests for speed unless explicitly testing code size optimization. -option optimize_for = SPEED; - -option java_outer_classname = "UnittestLazyImportsEnumProto"; - -enum LazyEnum { - LAZY_ENUM_0 = 0; - LAZY_ENUM_1 = 1; -} diff --git a/Protos/google/protobuf/unittest_lite.proto b/Protos/google/protobuf/unittest_lite.proto deleted file mode 100644 index 92282a6fc..000000000 --- a/Protos/google/protobuf/unittest_lite.proto +++ /dev/null @@ -1,501 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) -// -// This is like unittest.proto but with optimize_for = LITE_RUNTIME. - -syntax = "proto2"; - -package protobuf_unittest; - -import "google/protobuf/unittest_import_lite.proto"; - -option cc_enable_arenas = true; -option optimize_for = LITE_RUNTIME; -option java_package = "com.google.protobuf"; - -// Same as TestAllTypes but with the lite runtime. -message TestAllTypesLite { - message NestedMessage { - optional int32 bb = 1; - optional int64 cc = 2; - } - - message NestedMessage2 { - optional int32 dd = 1; - } - - enum NestedEnum { - FOO = 1; - BAR = 2; - BAZ = 3; - } - - // Singular - optional int32 optional_int32 = 1; - optional int64 optional_int64 = 2; - optional uint32 optional_uint32 = 3; - optional uint64 optional_uint64 = 4; - optional sint32 optional_sint32 = 5; - optional sint64 optional_sint64 = 6; - optional fixed32 optional_fixed32 = 7; - optional fixed64 optional_fixed64 = 8; - optional sfixed32 optional_sfixed32 = 9; - optional sfixed64 optional_sfixed64 = 10; - optional float optional_float = 11; - optional double optional_double = 12; - optional bool optional_bool = 13; - optional string optional_string = 14; - optional bytes optional_bytes = 15; - - optional group OptionalGroup = 16 { - optional int32 a = 17; - } - - optional NestedMessage optional_nested_message = 18; - optional ForeignMessageLite optional_foreign_message = 19; - optional protobuf_unittest_import.ImportMessageLite optional_import_message = - 20; - - optional NestedEnum optional_nested_enum = 21; - optional ForeignEnumLite optional_foreign_enum = 22; - optional protobuf_unittest_import.ImportEnumLite optional_import_enum = 23; - - optional string optional_string_piece = 24 [ctype = STRING_PIECE]; - optional string optional_cord = 25 [ctype = CORD]; - - // Defined in unittest_import_public.proto - optional protobuf_unittest_import.PublicImportMessageLite - optional_public_import_message = 26; - - optional NestedMessage optional_lazy_message = 27 [lazy = true]; - - // Repeated - repeated int32 repeated_int32 = 31; - repeated int64 repeated_int64 = 32; - repeated uint32 repeated_uint32 = 33; - repeated uint64 repeated_uint64 = 34; - repeated sint32 repeated_sint32 = 35; - repeated sint64 repeated_sint64 = 36; - repeated fixed32 repeated_fixed32 = 37; - repeated fixed64 repeated_fixed64 = 38; - repeated sfixed32 repeated_sfixed32 = 39; - repeated sfixed64 repeated_sfixed64 = 40; - repeated float repeated_float = 41; - repeated double repeated_double = 42; - repeated bool repeated_bool = 43; - repeated string repeated_string = 44; - repeated bytes repeated_bytes = 45; - - repeated group RepeatedGroup = 46 { - optional int32 a = 47; - } - - repeated NestedMessage repeated_nested_message = 48; - repeated ForeignMessageLite repeated_foreign_message = 49; - repeated protobuf_unittest_import.ImportMessageLite repeated_import_message = - 50; - - repeated NestedEnum repeated_nested_enum = 51; - repeated ForeignEnumLite repeated_foreign_enum = 52; - repeated protobuf_unittest_import.ImportEnumLite repeated_import_enum = 53; - - repeated string repeated_string_piece = 54 [ctype = STRING_PIECE]; - repeated string repeated_cord = 55 [ctype = CORD]; - - repeated NestedMessage repeated_lazy_message = 57 [lazy = true]; - - // Singular with defaults - optional int32 default_int32 = 61 [default = 41]; - optional int64 default_int64 = 62 [default = 42]; - optional uint32 default_uint32 = 63 [default = 43]; - optional uint64 default_uint64 = 64 [default = 44]; - optional sint32 default_sint32 = 65 [default = -45]; - optional sint64 default_sint64 = 66 [default = 46]; - optional fixed32 default_fixed32 = 67 [default = 47]; - optional fixed64 default_fixed64 = 68 [default = 48]; - optional sfixed32 default_sfixed32 = 69 [default = 49]; - optional sfixed64 default_sfixed64 = 70 [default = -50]; - optional float default_float = 71 [default = 51.5]; - optional double default_double = 72 [default = 52e3]; - optional bool default_bool = 73 [default = true]; - optional string default_string = 74 [default = "hello"]; - optional bytes default_bytes = 75 [default = "world"]; - - optional NestedEnum default_nested_enum = 81 [default = BAR]; - optional ForeignEnumLite default_foreign_enum = 82 - [default = FOREIGN_LITE_BAR]; - optional protobuf_unittest_import.ImportEnumLite default_import_enum = 83 - [default = IMPORT_LITE_BAR]; - - optional string default_string_piece = 84 - [ctype = STRING_PIECE, default = "abc"]; - optional string default_cord = 85 [ctype = CORD, default = "123"]; - - // For oneof test - oneof oneof_field { - uint32 oneof_uint32 = 111; - NestedMessage oneof_nested_message = 112; - string oneof_string = 113; - bytes oneof_bytes = 114; - NestedMessage oneof_lazy_nested_message = 115 [lazy = true]; - NestedMessage2 oneof_nested_message2 = 117; - } - - // Tests toString for non-repeated fields with a list suffix - optional int32 deceptively_named_list = 116; -} - -message ForeignMessageLite { - optional int32 c = 1; -} - -enum ForeignEnumLite { - FOREIGN_LITE_FOO = 4; - FOREIGN_LITE_BAZ = 6; - FOREIGN_LITE_BAR = 5; -} - -message TestPackedTypesLite { - repeated int32 packed_int32 = 90 [packed = true]; - repeated int64 packed_int64 = 91 [packed = true]; - repeated uint32 packed_uint32 = 92 [packed = true]; - repeated uint64 packed_uint64 = 93 [packed = true]; - repeated sint32 packed_sint32 = 94 [packed = true]; - repeated sint64 packed_sint64 = 95 [packed = true]; - repeated fixed32 packed_fixed32 = 96 [packed = true]; - repeated fixed64 packed_fixed64 = 97 [packed = true]; - repeated sfixed32 packed_sfixed32 = 98 [packed = true]; - repeated sfixed64 packed_sfixed64 = 99 [packed = true]; - repeated float packed_float = 100 [packed = true]; - repeated double packed_double = 101 [packed = true]; - repeated bool packed_bool = 102 [packed = true]; - repeated ForeignEnumLite packed_enum = 103 [packed = true]; -} - -message TestAllExtensionsLite { - extensions 1 to max; -} - -extend TestAllExtensionsLite { - // Singular - optional int32 optional_int32_extension_lite = 1; - optional int64 optional_int64_extension_lite = 2; - optional uint32 optional_uint32_extension_lite = 3; - optional uint64 optional_uint64_extension_lite = 4; - optional sint32 optional_sint32_extension_lite = 5; - optional sint64 optional_sint64_extension_lite = 6; - optional fixed32 optional_fixed32_extension_lite = 7; - optional fixed64 optional_fixed64_extension_lite = 8; - optional sfixed32 optional_sfixed32_extension_lite = 9; - optional sfixed64 optional_sfixed64_extension_lite = 10; - optional float optional_float_extension_lite = 11; - optional double optional_double_extension_lite = 12; - optional bool optional_bool_extension_lite = 13; - optional string optional_string_extension_lite = 14; - optional bytes optional_bytes_extension_lite = 15; - - optional group OptionalGroup_extension_lite = 16 { - optional int32 a = 17; - } - - optional TestAllTypesLite.NestedMessage - optional_nested_message_extension_lite = 18; - optional ForeignMessageLite optional_foreign_message_extension_lite = 19; - optional protobuf_unittest_import.ImportMessageLite - optional_import_message_extension_lite = 20; - - optional TestAllTypesLite.NestedEnum optional_nested_enum_extension_lite = 21; - optional ForeignEnumLite optional_foreign_enum_extension_lite = 22; - optional protobuf_unittest_import.ImportEnumLite - optional_import_enum_extension_lite = 23; - - optional string optional_string_piece_extension_lite = 24 - [ctype = STRING_PIECE]; - optional string optional_cord_extension_lite = 25 [ctype = CORD]; - - optional protobuf_unittest_import.PublicImportMessageLite - optional_public_import_message_extension_lite = 26; - - optional TestAllTypesLite.NestedMessage optional_lazy_message_extension_lite = - 27 [lazy = true]; - - // Repeated - repeated int32 repeated_int32_extension_lite = 31; - repeated int64 repeated_int64_extension_lite = 32; - repeated uint32 repeated_uint32_extension_lite = 33; - repeated uint64 repeated_uint64_extension_lite = 34; - repeated sint32 repeated_sint32_extension_lite = 35; - repeated sint64 repeated_sint64_extension_lite = 36; - repeated fixed32 repeated_fixed32_extension_lite = 37; - repeated fixed64 repeated_fixed64_extension_lite = 38; - repeated sfixed32 repeated_sfixed32_extension_lite = 39; - repeated sfixed64 repeated_sfixed64_extension_lite = 40; - repeated float repeated_float_extension_lite = 41; - repeated double repeated_double_extension_lite = 42; - repeated bool repeated_bool_extension_lite = 43; - repeated string repeated_string_extension_lite = 44; - repeated bytes repeated_bytes_extension_lite = 45; - - repeated group RepeatedGroup_extension_lite = 46 { - optional int32 a = 47; - } - - repeated TestAllTypesLite.NestedMessage - repeated_nested_message_extension_lite = 48; - repeated ForeignMessageLite repeated_foreign_message_extension_lite = 49; - repeated protobuf_unittest_import.ImportMessageLite - repeated_import_message_extension_lite = 50; - - repeated TestAllTypesLite.NestedEnum repeated_nested_enum_extension_lite = 51; - repeated ForeignEnumLite repeated_foreign_enum_extension_lite = 52; - repeated protobuf_unittest_import.ImportEnumLite - repeated_import_enum_extension_lite = 53; - - repeated string repeated_string_piece_extension_lite = 54 - [ctype = STRING_PIECE]; - repeated string repeated_cord_extension_lite = 55 [ctype = CORD]; - - repeated TestAllTypesLite.NestedMessage repeated_lazy_message_extension_lite = - 57 [lazy = true]; - - // Singular with defaults - optional int32 default_int32_extension_lite = 61 [default = 41]; - optional int64 default_int64_extension_lite = 62 [default = 42]; - optional uint32 default_uint32_extension_lite = 63 [default = 43]; - optional uint64 default_uint64_extension_lite = 64 [default = 44]; - optional sint32 default_sint32_extension_lite = 65 [default = -45]; - optional sint64 default_sint64_extension_lite = 66 [default = 46]; - optional fixed32 default_fixed32_extension_lite = 67 [default = 47]; - optional fixed64 default_fixed64_extension_lite = 68 [default = 48]; - optional sfixed32 default_sfixed32_extension_lite = 69 [default = 49]; - optional sfixed64 default_sfixed64_extension_lite = 70 [default = -50]; - optional float default_float_extension_lite = 71 [default = 51.5]; - optional double default_double_extension_lite = 72 [default = 52e3]; - optional bool default_bool_extension_lite = 73 [default = true]; - optional string default_string_extension_lite = 74 [default = "hello"]; - optional bytes default_bytes_extension_lite = 75 [default = "world"]; - - optional TestAllTypesLite.NestedEnum default_nested_enum_extension_lite = 81 - [default = BAR]; - optional ForeignEnumLite default_foreign_enum_extension_lite = 82 - [default = FOREIGN_LITE_BAR]; - optional protobuf_unittest_import.ImportEnumLite - default_import_enum_extension_lite = 83 [default = IMPORT_LITE_BAR]; - - optional string default_string_piece_extension_lite = 84 - [ctype = STRING_PIECE, default = "abc"]; - optional string default_cord_extension_lite = 85 - [ctype = CORD, default = "123"]; - - // For oneof test - optional uint32 oneof_uint32_extension_lite = 111; - optional TestAllTypesLite.NestedMessage oneof_nested_message_extension_lite = - 112; - optional string oneof_string_extension_lite = 113; - optional bytes oneof_bytes_extension_lite = 114; -} - -message TestPackedExtensionsLite { - extensions 1 to max; -} - -extend TestPackedExtensionsLite { - repeated int32 packed_int32_extension_lite = 90 [packed = true]; - repeated int64 packed_int64_extension_lite = 91 [packed = true]; - repeated uint32 packed_uint32_extension_lite = 92 [packed = true]; - repeated uint64 packed_uint64_extension_lite = 93 [packed = true]; - repeated sint32 packed_sint32_extension_lite = 94 [packed = true]; - repeated sint64 packed_sint64_extension_lite = 95 [packed = true]; - repeated fixed32 packed_fixed32_extension_lite = 96 [packed = true]; - repeated fixed64 packed_fixed64_extension_lite = 97 [packed = true]; - repeated sfixed32 packed_sfixed32_extension_lite = 98 [packed = true]; - repeated sfixed64 packed_sfixed64_extension_lite = 99 [packed = true]; - repeated float packed_float_extension_lite = 100 [packed = true]; - repeated double packed_double_extension_lite = 101 [packed = true]; - repeated bool packed_bool_extension_lite = 102 [packed = true]; - repeated ForeignEnumLite packed_enum_extension_lite = 103 [packed = true]; -} - -message TestNestedExtensionLite { - extend TestAllExtensionsLite { - optional int32 nested_extension = 12345; - } -} - -// Test that deprecated fields work. We only verify that they compile (at one -// point this failed). -message TestDeprecatedLite { - optional int32 deprecated_field = 1 [deprecated = true]; - required int32 deprecated_field2 = 2 [deprecated = true]; - optional string deprecated_field3 = 3 [deprecated = true]; - optional TestDeprecatedLite deprecated_field4 = 4 [deprecated = true]; -} - -// See the comments of the same type in unittest.proto. -message TestParsingMergeLite { - message RepeatedFieldsGenerator { - repeated TestAllTypesLite field1 = 1; - repeated TestAllTypesLite field2 = 2; - repeated TestAllTypesLite field3 = 3; - repeated group Group1 = 10 { - optional TestAllTypesLite field1 = 11; - } - repeated group Group2 = 20 { - optional TestAllTypesLite field1 = 21; - } - repeated TestAllTypesLite ext1 = 1000; - repeated TestAllTypesLite ext2 = 1001; - } - required TestAllTypesLite required_all_types = 1; - optional TestAllTypesLite optional_all_types = 2; - repeated TestAllTypesLite repeated_all_types = 3; - optional group OptionalGroup = 10 { - optional TestAllTypesLite optional_group_all_types = 11; - } - repeated group RepeatedGroup = 20 { - optional TestAllTypesLite repeated_group_all_types = 21; - } - extensions 1000 to max; - extend TestParsingMergeLite { - optional TestAllTypesLite optional_ext = 1000; - repeated TestAllTypesLite repeated_ext = 1001; - } -} - -// TestEmptyMessageLite is used to test unknown fields support in lite mode. -message TestEmptyMessageLite {} - -// Like above, but declare all field numbers as potential extensions. No -// actual extensions should ever be defined for this type. -message TestEmptyMessageWithExtensionsLite { - extensions 1 to max; -} - -enum V1EnumLite { V1_FIRST = 1; } - -enum V2EnumLite { - V2_FIRST = 1; - V2_SECOND = 2; -} - -message V1MessageLite { - required int32 int_field = 1; - optional V1EnumLite enum_field = 2 [default = V1_FIRST]; -} - -message V2MessageLite { - required int32 int_field = 1; - optional V2EnumLite enum_field = 2 [default = V2_FIRST]; -} - -message TestHugeFieldNumbersLite { - optional int32 optional_int32 = 536870000; - optional int32 fixed_32 = 536870001; - repeated int32 repeated_int32 = 536870002 [packed = false]; - repeated int32 packed_int32 = 536870003 [packed = true]; - - optional ForeignEnumLite optional_enum = 536870004; - optional string optional_string = 536870005; - optional bytes optional_bytes = 536870006; - optional ForeignMessageLite optional_message = 536870007; - - optional group OptionalGroup = 536870008 { - optional int32 group_a = 536870009; - } - - map string_string_map = 536870010; - - oneof oneof_field { - uint32 oneof_uint32 = 536870011; - TestAllTypesLite oneof_test_all_types = 536870012; - string oneof_string = 536870013; - bytes oneof_bytes = 536870014; - } - - extensions 536860000 to 536869999; -} - -extend TestHugeFieldNumbersLite { - optional TestAllTypesLite test_all_types_lite = 536860000; -} - -message TestOneofParsingLite { - oneof oneof_field { - int32 oneof_int32 = 1; - TestAllTypesLite oneof_submessage = 2; - string oneof_string = 3; - bytes oneof_bytes = 4 [default = "default bytes"]; - string oneof_string_cord = 5 [ctype = CORD, default = "default Cord"]; - bytes oneof_bytes_cord = 6 [ctype = CORD]; - string oneof_string_string_piece = 7 [ctype = STRING_PIECE]; - bytes oneof_bytes_string_piece = 8 - [ctype = STRING_PIECE, default = "default StringPiece"]; - V2EnumLite oneof_enum = 9; - } -} - -// The following four messages are set up to test for wire compatibility between -// packed and non-packed repeated fields. We use the field number 2048, because -// that is large enough to require a 3-byte varint for the tag. -message PackedInt32 { - repeated int32 repeated_int32 = 2048 [packed = true]; -} - -message NonPackedInt32 { - repeated int32 repeated_int32 = 2048; -} - -message PackedFixed32 { - repeated fixed32 repeated_fixed32 = 2048 [packed = true]; -} - -message NonPackedFixed32 { - repeated fixed32 repeated_fixed32 = 2048; -} - -// Test an enum that has multiple values with the same number. -message DupEnum { - enum TestEnumWithDupValueLite { - option allow_alias = true; - - FOO1 = 1; - BAR1 = 2; - BAZ = 3; - FOO2 = 1; - BAR2 = 2; - } -} - -message RecursiveMessage { - optional RecursiveMessage recurse = 1; - optional bytes payload = 2; -} diff --git a/Protos/google/protobuf/unittest_lite_imports_nonlite.proto b/Protos/google/protobuf/unittest_lite_imports_nonlite.proto deleted file mode 100644 index 8a470160a..000000000 --- a/Protos/google/protobuf/unittest_lite_imports_nonlite.proto +++ /dev/null @@ -1,47 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) -// -// Tests that a "lite" message can import a regular message. - -syntax = "proto2"; -package protobuf_unittest; - -import "google/protobuf/unittest.proto"; - -option optimize_for = LITE_RUNTIME; - -message TestLiteImportsNonlite { - optional TestAllTypes message = 1; - - // Verifies that transitive required fields generates valid code. - optional TestRequired message_with_required = 2; -} diff --git a/Protos/google/protobuf/unittest_no_field_presence.proto b/Protos/google/protobuf/unittest_no_field_presence.proto deleted file mode 100644 index 994afff42..000000000 --- a/Protos/google/protobuf/unittest_no_field_presence.proto +++ /dev/null @@ -1,138 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// A proto file used to test a message type with no explicit field presence. - -syntax = "proto3"; - -// We want to test embedded proto2 messages, so include some proto2 types. -import "google/protobuf/unittest.proto"; - -package proto2_nofieldpresence_unittest; - -// This proto includes every type of field in both singular and repeated -// forms. -message TestAllTypes { - message NestedMessage { - int32 bb = 1; - } - - enum NestedEnum { - FOO = 0; - BAR = 1; - BAZ = 2; - } - - // Singular - // TODO: remove 'optional' labels as soon as CL 69188077 is LGTM'd to make - // 'optional' optional. - int32 optional_int32 = 1; - int64 optional_int64 = 2; - uint32 optional_uint32 = 3; - uint64 optional_uint64 = 4; - sint32 optional_sint32 = 5; - sint64 optional_sint64 = 6; - fixed32 optional_fixed32 = 7; - fixed64 optional_fixed64 = 8; - sfixed32 optional_sfixed32 = 9; - sfixed64 optional_sfixed64 = 10; - float optional_float = 11; - double optional_double = 12; - bool optional_bool = 13; - string optional_string = 14; - bytes optional_bytes = 15; - - NestedMessage optional_nested_message = 18; - ForeignMessage optional_foreign_message = 19; - protobuf_unittest.TestAllTypes optional_proto2_message = 20; - - NestedEnum optional_nested_enum = 21; - ForeignEnum optional_foreign_enum = 22; - // N.B.: proto2-enum-type fields not allowed, because their default values - // might not be zero. - //optional protobuf_unittest.ForeignEnum optional_proto2_enum = 23; - - string optional_string_piece = 24 [ctype=STRING_PIECE]; - string optional_cord = 25 [ctype=CORD]; - - NestedMessage optional_lazy_message = 30 [lazy=true]; - - // Repeated - repeated int32 repeated_int32 = 31; - repeated int64 repeated_int64 = 32; - repeated uint32 repeated_uint32 = 33; - repeated uint64 repeated_uint64 = 34; - repeated sint32 repeated_sint32 = 35; - repeated sint64 repeated_sint64 = 36; - repeated fixed32 repeated_fixed32 = 37; - repeated fixed64 repeated_fixed64 = 38; - repeated sfixed32 repeated_sfixed32 = 39; - repeated sfixed64 repeated_sfixed64 = 40; - repeated float repeated_float = 41; - repeated double repeated_double = 42; - repeated bool repeated_bool = 43; - repeated string repeated_string = 44; - repeated bytes repeated_bytes = 45; - - repeated NestedMessage repeated_nested_message = 48; - repeated ForeignMessage repeated_foreign_message = 49; - repeated protobuf_unittest.TestAllTypes repeated_proto2_message = 50; - - repeated NestedEnum repeated_nested_enum = 51; - repeated ForeignEnum repeated_foreign_enum = 52; - - repeated string repeated_string_piece = 54 [ctype=STRING_PIECE]; - repeated string repeated_cord = 55 [ctype=CORD]; - - repeated NestedMessage repeated_lazy_message = 57 [lazy=true]; - - oneof oneof_field { - uint32 oneof_uint32 = 111; - NestedMessage oneof_nested_message = 112; - string oneof_string = 113; - NestedEnum oneof_enum = 114; - } -} - -message TestProto2Required { - protobuf_unittest.TestRequired proto2 = 1; -} - -// Define these after TestAllTypes to make sure the compiler can handle -// that. -message ForeignMessage { - int32 c = 1; -} - -enum ForeignEnum { - FOREIGN_FOO = 0; - FOREIGN_BAR = 1; - FOREIGN_BAZ = 2; -} diff --git a/Protos/google/protobuf/unittest_no_generic_services.proto b/Protos/google/protobuf/unittest_no_generic_services.proto deleted file mode 100644 index c2f042ba0..000000000 --- a/Protos/google/protobuf/unittest_no_generic_services.proto +++ /dev/null @@ -1,54 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) - -syntax = "proto2"; -package protobuf_unittest.no_generic_services_test; - - -// *_generic_services are false by default. - -message TestMessage { - optional int32 a = 1; - extensions 1000 to max; -} - -enum TestEnum { - FOO = 1; -} - -extend TestMessage { - optional int32 test_extension = 1000; -} - -service TestService { - rpc Foo(TestMessage) returns(TestMessage); -} diff --git a/Protos/google/protobuf/unittest_optimize_for.proto b/Protos/google/protobuf/unittest_optimize_for.proto deleted file mode 100644 index ee9cc7bd4..000000000 --- a/Protos/google/protobuf/unittest_optimize_for.proto +++ /dev/null @@ -1,67 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// A proto file which uses optimize_for = CODE_SIZE. - -syntax = "proto2"; -import "google/protobuf/unittest.proto"; - -package protobuf_unittest; - -option optimize_for = CODE_SIZE; - -message TestOptimizedForSize { - optional int32 i = 1; - optional ForeignMessage msg = 19; - - extensions 1000 to max; - - extend TestOptimizedForSize { - optional int32 test_extension = 1234; - optional TestRequiredOptimizedForSize test_extension2 = 1235; - } - - oneof foo { - int32 integer_field = 2; - string string_field = 3; - } -} - -message TestRequiredOptimizedForSize { - required int32 x = 1; -} - -message TestOptionalOptimizedForSize { - optional TestRequiredOptimizedForSize o = 1; -} diff --git a/Protos/unittest_swift_performance.proto b/Protos/unittest_swift_performance.proto deleted file mode 100644 index 856bb9cc4..000000000 --- a/Protos/unittest_swift_performance.proto +++ /dev/null @@ -1,73 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -syntax = "proto3"; -package swift.performance; - -message TestAllTypes { - // One of every singular field type - int32 optional_int32 = 1; - int64 optional_int64 = 2; - uint32 optional_uint32 = 3; - uint64 optional_uint64 = 4; - sint32 optional_sint32 = 5; - sint64 optional_sint64 = 6; - fixed32 optional_fixed32 = 7; - fixed64 optional_fixed64 = 8; - sfixed32 optional_sfixed32 = 9; - sfixed64 optional_sfixed64 = 10; - float optional_float = 11; - double optional_double = 12; - bool optional_bool = 13; - string optional_string = 14; - bytes optional_bytes = 15; - - repeated TestAllTypes repeated_recursive_message = 27; - - // Repeated - repeated int32 repeated_int32 = 31; - repeated int64 repeated_int64 = 32; - repeated uint32 repeated_uint32 = 33; - repeated uint64 repeated_uint64 = 34; - repeated sint32 repeated_sint32 = 35; - repeated sint64 repeated_sint64 = 36; - repeated fixed32 repeated_fixed32 = 37; - repeated fixed64 repeated_fixed64 = 38; - repeated sfixed32 repeated_sfixed32 = 39; - repeated sfixed64 repeated_sfixed64 = 40; - repeated float repeated_float = 41; - repeated double repeated_double = 42; - repeated bool repeated_bool = 43; - repeated string repeated_string = 44; - repeated bytes repeated_bytes = 45; - - // Map - map < string, TestAllTypes> map_string_message = 71; -} diff --git a/Protos/unittest_swift_startup.proto b/Protos/unittest_swift_startup.proto deleted file mode 100644 index aee7bd556..000000000 --- a/Protos/unittest_swift_startup.proto +++ /dev/null @@ -1,49 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -syntax = "proto2"; - -package protobuf_objc_unittest; - -message TestObjCStartupMessage { - extensions 1 to max; -} - -extend TestObjCStartupMessage { - // Singular - optional int32 optional_int32_extension = 1; - repeated int32 repeated_int32_extension = 2; -} - -message TestObjCStartupNested { - extend TestObjCStartupMessage { - optional string nested_string_extension = 3; - } -} diff --git a/Protos/upstream/conformance/conformance.proto b/Protos/upstream/conformance/conformance.proto new file mode 100644 index 000000000..e3298f085 --- /dev/null +++ b/Protos/upstream/conformance/conformance.proto @@ -0,0 +1,172 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +syntax = "proto3"; + +package conformance; + +option java_package = "com.google.protobuf.conformance"; +option objc_class_prefix = "Conformance"; + +// This defines the conformance testing protocol. This protocol exists between +// the conformance test suite itself and the code being tested. For each test, +// the suite will send a ConformanceRequest message and expect a +// ConformanceResponse message. +// +// You can either run the tests in two different ways: +// +// 1. in-process (using the interface in conformance_test.h). +// +// 2. as a sub-process communicating over a pipe. Information about how to +// do this is in conformance_test_runner.cc. +// +// Pros/cons of the two approaches: +// +// - running as a sub-process is much simpler for languages other than C/C++. +// +// - running as a sub-process may be more tricky in unusual environments like +// iOS apps, where fork/stdin/stdout are not available. + +enum WireFormat { + UNSPECIFIED = 0; + PROTOBUF = 1; + JSON = 2; + JSPB = 3; // Only used inside Google. Opensource testees just skip it. + TEXT_FORMAT = 4; +} + +enum TestCategory { + UNSPECIFIED_TEST = 0; + BINARY_TEST = 1; // Test binary wire format. + JSON_TEST = 2; // Test json wire format. + // Similar to JSON_TEST. However, during parsing json, testee should ignore + // unknown fields. This feature is optional. Each implementation can decide + // whether to support it. See + // https://developers.google.com/protocol-buffers/docs/proto3#json_options + // for more detail. + JSON_IGNORE_UNKNOWN_PARSING_TEST = 3; + // Test jspb wire format. Only used inside Google. Opensource testees just + // skip it. + JSPB_TEST = 4; + // Test text format. For cpp, java and python, testees can already deal with + // this type. Testees of other languages can simply skip it. + TEXT_FORMAT_TEST = 5; +} + +// Meant to encapsulate all types of tests: successes, skips, failures, etc. +// Therefore, this may or may not have a failure message. Failure messages +// may be truncated for our failure lists. +message TestStatus { + string name = 1; + string failure_message = 2; + // What an actual test name matched to in a failure list. Can be wildcarded or + // an exact match without wildcards. + string matched_name = 3; +} + +// The conformance runner will request a list of failures as the first request. +// This will be known by message_type == "conformance.FailureSet", a conformance +// test should return a serialized FailureSet in protobuf_payload. +message FailureSet { + repeated TestStatus test = 2; + reserved 1; +} + +// Represents a single test case's input. The testee should: +// +// 1. parse this proto (which should always succeed) +// 2. parse the protobuf or JSON payload in "payload" (which may fail) +// 3. if the parse succeeded, serialize the message in the requested format. +message ConformanceRequest { + // The payload (whether protobuf of JSON) is always for a + // protobuf_test_messages.proto3.TestAllTypes proto (as defined in + // src/google/protobuf/proto3_test_messages.proto). + oneof payload { + bytes protobuf_payload = 1; + string json_payload = 2; + // Only used inside Google. Opensource testees just skip it. + string jspb_payload = 7; + string text_payload = 8; + } + + // Which format should the testee serialize its message to? + WireFormat requested_output_format = 3; + + // The full name for the test message to use; for the moment, either: + // protobuf_test_messages.proto3.TestAllTypesProto3 or + // protobuf_test_messages.proto2.TestAllTypesProto2 or + // protobuf_test_messages.editions.proto2.TestAllTypesProto2 or + // protobuf_test_messages.editions.proto3.TestAllTypesProto3 or + // protobuf_test_messages.editions.TestAllTypesEdition2023. + string message_type = 4; + + // Each test is given a specific test category. Some category may need + // specific support in testee programs. Refer to the definition of + // TestCategory for more information. + TestCategory test_category = 5; + + // Specify details for how to encode jspb. + JspbEncodingConfig jspb_encoding_options = 6; + + // This can be used in json and text format. If true, testee should print + // unknown fields instead of ignore. This feature is optional. + bool print_unknown_fields = 9; +} + +// Represents a single test case's output. +message ConformanceResponse { + oneof result { + // This string should be set to indicate parsing failed. The string can + // provide more information about the parse error if it is available. + // + // Setting this string does not necessarily mean the testee failed the + // test. Some of the test cases are intentionally invalid input. + string parse_error = 1; + + // If the input was successfully parsed but errors occurred when + // serializing it to the requested output format, set the error message in + // this field. + string serialize_error = 6; + + // This should be set if the test program timed out. The string should + // provide more information about what the child process was doing when it + // was killed. + string timeout_error = 9; + + // This should be set if some other error occurred. This will always + // indicate that the test failed. The string can provide more information + // about the failure. + string runtime_error = 2; + + // If the input was successfully parsed and the requested output was + // protobuf, serialize it to protobuf and set it in this field. + bytes protobuf_payload = 3; + + // If the input was successfully parsed and the requested output was JSON, + // serialize to JSON and set it in this field. + string json_payload = 4; + + // For when the testee skipped the test, likely because a certain feature + // wasn't supported, like JSON input/output. + string skipped = 5; + + // If the input was successfully parsed and the requested output was JSPB, + // serialize to JSPB and set it in this field. JSPB is only used inside + // Google. Opensource testees can just skip it. + string jspb_payload = 7; + + // If the input was successfully parsed and the requested output was + // TEXT_FORMAT, serialize to TEXT_FORMAT and set it in this field. + string text_payload = 8; + } +} + +// Encoding options for jspb format. +message JspbEncodingConfig { + // Encode the value field of Any as jspb array if true, otherwise binary. + bool use_jspb_array_any_format = 1; +} diff --git a/Protos/upstream/conformance/test_protos/test_messages_edition2023.proto b/Protos/upstream/conformance/test_protos/test_messages_edition2023.proto new file mode 100644 index 000000000..7affff6fd --- /dev/null +++ b/Protos/upstream/conformance/test_protos/test_messages_edition2023.proto @@ -0,0 +1,217 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2024 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +edition = "2023"; + +package protobuf_test_messages.editions; + +option features.message_encoding = DELIMITED; +option java_package = "com.google.protobuf_test_messages.edition2023"; +option java_multiple_files = true; +option objc_class_prefix = "Editions"; + +message ComplexMessage { + int32 d = 1; +} + +message TestAllTypesEdition2023 { + message NestedMessage { + int32 a = 1; + TestAllTypesEdition2023 corecursive = 2 + [features.message_encoding = LENGTH_PREFIXED]; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + NEG = -1; // Intentionally negative. + } + + // Singular + int32 optional_int32 = 1; + int64 optional_int64 = 2; + uint32 optional_uint32 = 3; + uint64 optional_uint64 = 4; + sint32 optional_sint32 = 5; + sint64 optional_sint64 = 6; + fixed32 optional_fixed32 = 7; + fixed64 optional_fixed64 = 8; + sfixed32 optional_sfixed32 = 9; + sfixed64 optional_sfixed64 = 10; + float optional_float = 11; + double optional_double = 12; + bool optional_bool = 13; + string optional_string = 14; + bytes optional_bytes = 15; + + NestedMessage optional_nested_message = 18 + [features.message_encoding = LENGTH_PREFIXED]; + ForeignMessageEdition2023 optional_foreign_message = 19 + [features.message_encoding = LENGTH_PREFIXED]; + + NestedEnum optional_nested_enum = 21; + ForeignEnumEdition2023 optional_foreign_enum = 22; + + string optional_string_piece = 24 [ctype = STRING_PIECE]; + string optional_cord = 25 [ctype = CORD]; + + TestAllTypesEdition2023 recursive_message = 27 + [features.message_encoding = LENGTH_PREFIXED]; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + + repeated NestedMessage repeated_nested_message = 48 + [features.message_encoding = LENGTH_PREFIXED]; + repeated ForeignMessageEdition2023 repeated_foreign_message = 49 + [features.message_encoding = LENGTH_PREFIXED]; + + repeated NestedEnum repeated_nested_enum = 51; + repeated ForeignEnumEdition2023 repeated_foreign_enum = 52; + + repeated string repeated_string_piece = 54 [ctype = STRING_PIECE]; + repeated string repeated_cord = 55 [ctype = CORD]; + + // Packed + repeated int32 packed_int32 = 75 [features.repeated_field_encoding = PACKED]; + repeated int64 packed_int64 = 76 [features.repeated_field_encoding = PACKED]; + repeated uint32 packed_uint32 = 77 + [features.repeated_field_encoding = PACKED]; + repeated uint64 packed_uint64 = 78 + [features.repeated_field_encoding = PACKED]; + repeated sint32 packed_sint32 = 79 + [features.repeated_field_encoding = PACKED]; + repeated sint64 packed_sint64 = 80 + [features.repeated_field_encoding = PACKED]; + repeated fixed32 packed_fixed32 = 81 + [features.repeated_field_encoding = PACKED]; + repeated fixed64 packed_fixed64 = 82 + [features.repeated_field_encoding = PACKED]; + repeated sfixed32 packed_sfixed32 = 83 + [features.repeated_field_encoding = PACKED]; + repeated sfixed64 packed_sfixed64 = 84 + [features.repeated_field_encoding = PACKED]; + repeated float packed_float = 85 [features.repeated_field_encoding = PACKED]; + repeated double packed_double = 86 + [features.repeated_field_encoding = PACKED]; + repeated bool packed_bool = 87 [features.repeated_field_encoding = PACKED]; + repeated NestedEnum packed_nested_enum = 88 + [features.repeated_field_encoding = PACKED]; + + // Unpacked + repeated int32 unpacked_int32 = 89 + [features.repeated_field_encoding = EXPANDED]; + repeated int64 unpacked_int64 = 90 + [features.repeated_field_encoding = EXPANDED]; + repeated uint32 unpacked_uint32 = 91 + [features.repeated_field_encoding = EXPANDED]; + repeated uint64 unpacked_uint64 = 92 + [features.repeated_field_encoding = EXPANDED]; + repeated sint32 unpacked_sint32 = 93 + [features.repeated_field_encoding = EXPANDED]; + repeated sint64 unpacked_sint64 = 94 + [features.repeated_field_encoding = EXPANDED]; + repeated fixed32 unpacked_fixed32 = 95 + [features.repeated_field_encoding = EXPANDED]; + repeated fixed64 unpacked_fixed64 = 96 + [features.repeated_field_encoding = EXPANDED]; + repeated sfixed32 unpacked_sfixed32 = 97 + [features.repeated_field_encoding = EXPANDED]; + repeated sfixed64 unpacked_sfixed64 = 98 + [features.repeated_field_encoding = EXPANDED]; + repeated float unpacked_float = 99 + [features.repeated_field_encoding = EXPANDED]; + repeated double unpacked_double = 100 + [features.repeated_field_encoding = EXPANDED]; + repeated bool unpacked_bool = 101 + [features.repeated_field_encoding = EXPANDED]; + repeated NestedEnum unpacked_nested_enum = 102 + [features.repeated_field_encoding = EXPANDED]; + + // Map + map map_int32_int32 = 56; + map map_int64_int64 = 57; + map map_uint32_uint32 = 58; + map map_uint64_uint64 = 59; + map map_sint32_sint32 = 60; + map map_sint64_sint64 = 61; + map map_fixed32_fixed32 = 62; + map map_fixed64_fixed64 = 63; + map map_sfixed32_sfixed32 = 64; + map map_sfixed64_sfixed64 = 65; + map map_int32_float = 66; + map map_int32_double = 67; + map map_bool_bool = 68; + map map_string_string = 69; + map map_string_bytes = 70; + map map_string_nested_message = 71; + map map_string_foreign_message = 72; + map map_string_nested_enum = 73; + map map_string_foreign_enum = 74; + + oneof oneof_field { + uint32 oneof_uint32 = 111; + NestedMessage oneof_nested_message = 112 + [features.message_encoding = LENGTH_PREFIXED]; + string oneof_string = 113; + bytes oneof_bytes = 114; + bool oneof_bool = 115; + uint64 oneof_uint64 = 116; + float oneof_float = 117; + double oneof_double = 118; + NestedEnum oneof_enum = 119; + } + + // extensions + extensions 120 to 200; + + // groups + message GroupLikeType { + int32 group_int32 = 202; + uint32 group_uint32 = 203; + } + GroupLikeType groupliketype = 201; + GroupLikeType delimited_field = 202; +} + +message ForeignMessageEdition2023 { + int32 c = 1; +} + +enum ForeignEnumEdition2023 { + FOREIGN_FOO = 0; + FOREIGN_BAR = 1; + FOREIGN_BAZ = 2; +} + +extend TestAllTypesEdition2023 { + int32 extension_int32 = 120; +} + +message GroupLikeType { + int32 c = 1; +} + +extend TestAllTypesEdition2023 { + GroupLikeType groupliketype = 121; + GroupLikeType delimited_ext = 122; +} diff --git a/Protos/upstream/editions/golden/test_messages_proto2_editions.proto b/Protos/upstream/editions/golden/test_messages_proto2_editions.proto new file mode 100644 index 000000000..5e5183db1 --- /dev/null +++ b/Protos/upstream/editions/golden/test_messages_proto2_editions.proto @@ -0,0 +1,687 @@ +// clang-format off +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Test schema for proto2 messages. This test schema is used by: +// +// - conformance tests + +// LINT: ALLOW_GROUPS + +edition = "2023"; + +package protobuf_test_messages.editions.proto2; + +option features.enum_type = CLOSED; +option features.repeated_field_encoding = EXPANDED; +option features.utf8_validation = NONE; +option java_package = "com.google.protobuf_test_messages.editions.proto2"; +option objc_class_prefix = "EditionsProto2"; + +// This is the default, but we specify it here explicitly. +option optimize_for = SPEED; +option cc_enable_arenas = true; + +// This proto includes every type of field in both singular and repeated +// forms. +// +// Also, crucially, all messages and enums in this file are eventually +// submessages of this message. So for example, a fuzz test of TestAllTypes +// could trigger bugs that occur in any message type in this file. We verify +// this stays true in a unit test. +message TestAllTypesProto2 { + message NestedMessage { + int32 a = 1; + TestAllTypesProto2 corecursive = 2; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + NEG = -1; // Intentionally negative. + } + + // Singular + int32 optional_int32 = 1; + int64 optional_int64 = 2; + uint32 optional_uint32 = 3; + uint64 optional_uint64 = 4; + sint32 optional_sint32 = 5; + sint64 optional_sint64 = 6; + fixed32 optional_fixed32 = 7; + fixed64 optional_fixed64 = 8; + sfixed32 optional_sfixed32 = 9; + sfixed64 optional_sfixed64 = 10; + float optional_float = 11; + double optional_double = 12; + bool optional_bool = 13; + string optional_string = 14; + bytes optional_bytes = 15; + NestedMessage optional_nested_message = 18; + ForeignMessageProto2 optional_foreign_message = 19; + NestedEnum optional_nested_enum = 21; + ForeignEnumProto2 optional_foreign_enum = 22; + string optional_string_piece = 24 [ + ctype = STRING_PIECE + ]; + + string optional_cord = 25 [ + ctype = CORD + ]; + + TestAllTypesProto2 recursive_message = 27; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + repeated NestedMessage repeated_nested_message = 48; + repeated ForeignMessageProto2 repeated_foreign_message = 49; + repeated NestedEnum repeated_nested_enum = 51; + repeated ForeignEnumProto2 repeated_foreign_enum = 52; + repeated string repeated_string_piece = 54 [ + ctype = STRING_PIECE + ]; + + repeated string repeated_cord = 55 [ + ctype = CORD + ]; + + // Packed + repeated int32 packed_int32 = 75 [ + features.repeated_field_encoding = PACKED + ]; + + repeated int64 packed_int64 = 76 [ + features.repeated_field_encoding = PACKED + ]; + + repeated uint32 packed_uint32 = 77 [ + features.repeated_field_encoding = PACKED + ]; + + repeated uint64 packed_uint64 = 78 [ + features.repeated_field_encoding = PACKED + ]; + + repeated sint32 packed_sint32 = 79 [ + features.repeated_field_encoding = PACKED + ]; + + repeated sint64 packed_sint64 = 80 [ + features.repeated_field_encoding = PACKED + ]; + + repeated fixed32 packed_fixed32 = 81 [ + features.repeated_field_encoding = PACKED + ]; + + repeated fixed64 packed_fixed64 = 82 [ + features.repeated_field_encoding = PACKED + ]; + + repeated sfixed32 packed_sfixed32 = 83 [ + features.repeated_field_encoding = PACKED + ]; + + repeated sfixed64 packed_sfixed64 = 84 [ + features.repeated_field_encoding = PACKED + ]; + + repeated float packed_float = 85 [ + features.repeated_field_encoding = PACKED + ]; + + repeated double packed_double = 86 [ + features.repeated_field_encoding = PACKED + ]; + + repeated bool packed_bool = 87 [ + features.repeated_field_encoding = PACKED + ]; + + repeated NestedEnum packed_nested_enum = 88 [ + features.repeated_field_encoding = PACKED + ]; + + // Unpacked + repeated int32 unpacked_int32 = 89; + repeated int64 unpacked_int64 = 90; + repeated uint32 unpacked_uint32 = 91; + repeated uint64 unpacked_uint64 = 92; + repeated sint32 unpacked_sint32 = 93; + repeated sint64 unpacked_sint64 = 94; + repeated fixed32 unpacked_fixed32 = 95; + repeated fixed64 unpacked_fixed64 = 96; + repeated sfixed32 unpacked_sfixed32 = 97; + repeated sfixed64 unpacked_sfixed64 = 98; + repeated float unpacked_float = 99; + repeated double unpacked_double = 100; + repeated bool unpacked_bool = 101; + repeated NestedEnum unpacked_nested_enum = 102; + + // Map + map map_int32_int32 = 56; + map map_int64_int64 = 57; + map map_uint32_uint32 = 58; + map map_uint64_uint64 = 59; + map map_sint32_sint32 = 60; + map map_sint64_sint64 = 61; + map map_fixed32_fixed32 = 62; + map map_fixed64_fixed64 = 63; + map map_sfixed32_sfixed32 = 64; + map map_sfixed64_sfixed64 = 65; + map map_int32_bool = 104; + map map_int32_float = 66; + map map_int32_double = 67; + map map_int32_nested_message = 103; + map map_bool_bool = 68; + map map_string_string = 69; + map map_string_bytes = 70; + map map_string_nested_message = 71; + map map_string_foreign_message = 72; + map map_string_nested_enum = 73; + map map_string_foreign_enum = 74; + + oneof oneof_field { + uint32 oneof_uint32 = 111; + NestedMessage oneof_nested_message = 112; + string oneof_string = 113; + bytes oneof_bytes = 114; + bool oneof_bool = 115; + uint64 oneof_uint64 = 116; + float oneof_float = 117; + double oneof_double = 118; + NestedEnum oneof_enum = 119; + } + + // extensions + extensions 120 to 200; + + // groups + message Data { + int32 group_int32 = 202; + uint32 group_uint32 = 203; + } + + Data data = 201 [ + features.message_encoding = DELIMITED + ]; + + message MultiWordGroupField { + int32 group_int32 = 205; + uint32 group_uint32 = 206; + } + + MultiWordGroupField multiwordgroupfield = 204 [ + features.message_encoding = DELIMITED + ]; + + // default values + int32 default_int32 = 241 [ + default = -123456789 + ]; + + int64 default_int64 = 242 [ + default = -9123456789123456789 + ]; + + uint32 default_uint32 = 243 [ + default = 2123456789 + ]; + + uint64 default_uint64 = 244 [ + default = 10123456789123456789 + ]; + + sint32 default_sint32 = 245 [ + default = -123456789 + ]; + + sint64 default_sint64 = 246 [ + default = -9123456789123456789 + ]; + + fixed32 default_fixed32 = 247 [ + default = 2123456789 + ]; + + fixed64 default_fixed64 = 248 [ + default = 10123456789123456789 + ]; + + sfixed32 default_sfixed32 = 249 [ + default = -123456789 + ]; + + sfixed64 default_sfixed64 = 250 [ + default = -9123456789123456789 + ]; + + float default_float = 251 [ + default = 9e9 + ]; + + double default_double = 252 [ + default = 7e22 + ]; + + bool default_bool = 253 [ + default = true + ]; + + string default_string = 254 [ + default = "Rosebud" + ]; + + bytes default_bytes = 255 [ + default = "joshua" + ]; + + // Test field-name-to-JSON-name convention. + // (protobuf says names can be any valid C/C++ identifier.) + int32 fieldname1 = 401; + int32 field_name2 = 402; + int32 _field_name3 = 403; + int32 field__name4_ = 404; + int32 field0name5 = 405; + int32 field_0_name6 = 406; + int32 fieldName7 = 407; + int32 FieldName8 = 408; + int32 field_Name9 = 409; + int32 Field_Name10 = 410; + int32 FIELD_NAME11 = 411; + int32 FIELD_name12 = 412; + int32 __field_name13 = 413; + int32 __Field_name14 = 414; + int32 field__name15 = 415; + int32 field__Name16 = 416; + int32 field_name17__ = 417; + int32 Field_name18__ = 418; + + // Reserved for unknown fields test. + reserved 1000 to 9999; + + MessageSetCorrect message_set_correct = 500; + + // message_set test case. + message MessageSetCorrect { + option message_set_wire_format = true; + + extensions 4 to max; + } + + message MessageSetCorrectExtension1 { + extend MessageSetCorrect { + MessageSetCorrectExtension1 message_set_extension = 1547769; + } + + string str = 25; + } + + message MessageSetCorrectExtension2 { + extend MessageSetCorrect { + MessageSetCorrectExtension2 message_set_extension = 4135312; + } + + int32 i = 9; + } + + message ExtensionWithOneof { + oneof oneof_field { + int32 a = 1; + int32 b = 2; + } + + extend MessageSetCorrect { + ExtensionWithOneof extension_with_oneof = 123456789; + } + } + + reserved reserved_field; + + reserved 999999; +} + +message ForeignMessageProto2 { + int32 c = 1; +} + +enum ForeignEnumProto2 { + FOREIGN_FOO = 0; + FOREIGN_BAR = 1; + FOREIGN_BAZ = 2; +} + +extend TestAllTypesProto2 { + int32 extension_int32 = 120; +} + +extend TestAllTypesProto2 { + GroupField groupfield = 121 [ + features.message_encoding = DELIMITED + ]; +} + +message GroupField { + int32 group_int32 = 122; + uint32 group_uint32 = 123; +} + +message UnknownToTestAllTypes { + int32 optional_int32 = 1001; + string optional_string = 1002; + ForeignMessageProto2 nested_message = 1003; + + message OptionalGroup { + int32 a = 1; + } + + OptionalGroup optionalgroup = 1004 [ + features.message_encoding = DELIMITED + ]; + + bool optional_bool = 1006; + repeated int32 repeated_int32 = 1011; +} + +message NullHypothesisProto2 { +} + +message EnumOnlyProto2 { + enum Bool { + kFalse = 0; + kTrue = 1; + } +} + +message OneStringProto2 { + string data = 1; +} + +message ProtoWithKeywords { + int32 inline = 1; + string concept = 2; + repeated string requires = 3; +} + +message TestAllRequiredTypesProto2 { + message NestedMessage { + int32 a = 1 [ + features.field_presence = LEGACY_REQUIRED + ]; + + TestAllRequiredTypesProto2 corecursive = 2 [ + features.field_presence = LEGACY_REQUIRED + ]; + + TestAllRequiredTypesProto2 optional_corecursive = 3; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + NEG = -1; // Intentionally negative. + } + + // Singular + int32 required_int32 = 1 [ + features.field_presence = LEGACY_REQUIRED + ]; + + int64 required_int64 = 2 [ + features.field_presence = LEGACY_REQUIRED + ]; + + uint32 required_uint32 = 3 [ + features.field_presence = LEGACY_REQUIRED + ]; + + uint64 required_uint64 = 4 [ + features.field_presence = LEGACY_REQUIRED + ]; + + sint32 required_sint32 = 5 [ + features.field_presence = LEGACY_REQUIRED + ]; + + sint64 required_sint64 = 6 [ + features.field_presence = LEGACY_REQUIRED + ]; + + fixed32 required_fixed32 = 7 [ + features.field_presence = LEGACY_REQUIRED + ]; + + fixed64 required_fixed64 = 8 [ + features.field_presence = LEGACY_REQUIRED + ]; + + sfixed32 required_sfixed32 = 9 [ + features.field_presence = LEGACY_REQUIRED + ]; + + sfixed64 required_sfixed64 = 10 [ + features.field_presence = LEGACY_REQUIRED + ]; + + float required_float = 11 [ + features.field_presence = LEGACY_REQUIRED + ]; + + double required_double = 12 [ + features.field_presence = LEGACY_REQUIRED + ]; + + bool required_bool = 13 [ + features.field_presence = LEGACY_REQUIRED + ]; + + string required_string = 14 [ + features.field_presence = LEGACY_REQUIRED + ]; + + bytes required_bytes = 15 [ + features.field_presence = LEGACY_REQUIRED + ]; + + NestedMessage required_nested_message = 18 [ + features.field_presence = LEGACY_REQUIRED + ]; + + ForeignMessageProto2 required_foreign_message = 19 [ + features.field_presence = LEGACY_REQUIRED + ]; + + NestedEnum required_nested_enum = 21 [ + features.field_presence = LEGACY_REQUIRED + ]; + + ForeignEnumProto2 required_foreign_enum = 22 [ + features.field_presence = LEGACY_REQUIRED + ]; + + string required_string_piece = 24 [ + features.field_presence = LEGACY_REQUIRED, + ctype = STRING_PIECE + ]; + + string required_cord = 25 [ + features.field_presence = LEGACY_REQUIRED, + ctype = CORD + ]; + + TestAllRequiredTypesProto2 recursive_message = 27 [ + features.field_presence = LEGACY_REQUIRED + ]; + + TestAllRequiredTypesProto2 optional_recursive_message = 28; + + // extensions + extensions 120 to 200; + + // groups + message Data { + int32 group_int32 = 202 [ + features.field_presence = LEGACY_REQUIRED + ]; + + uint32 group_uint32 = 203 [ + features.field_presence = LEGACY_REQUIRED + ]; + } + + Data data = 201 [ + features.field_presence = LEGACY_REQUIRED, + features.message_encoding = DELIMITED + ]; + + // default values + int32 default_int32 = 241 [ + features.field_presence = LEGACY_REQUIRED, + default = -123456789 + ]; + + int64 default_int64 = 242 [ + features.field_presence = LEGACY_REQUIRED, + default = -9123456789123456789 + ]; + + uint32 default_uint32 = 243 [ + features.field_presence = LEGACY_REQUIRED, + default = 2123456789 + ]; + + uint64 default_uint64 = 244 [ + features.field_presence = LEGACY_REQUIRED, + default = 10123456789123456789 + ]; + + sint32 default_sint32 = 245 [ + features.field_presence = LEGACY_REQUIRED, + default = -123456789 + ]; + + sint64 default_sint64 = 246 [ + features.field_presence = LEGACY_REQUIRED, + default = -9123456789123456789 + ]; + + fixed32 default_fixed32 = 247 [ + features.field_presence = LEGACY_REQUIRED, + default = 2123456789 + ]; + + fixed64 default_fixed64 = 248 [ + features.field_presence = LEGACY_REQUIRED, + default = 10123456789123456789 + ]; + + sfixed32 default_sfixed32 = 249 [ + features.field_presence = LEGACY_REQUIRED, + default = -123456789 + ]; + + sfixed64 default_sfixed64 = 250 [ + features.field_presence = LEGACY_REQUIRED, + default = -9123456789123456789 + ]; + + float default_float = 251 [ + features.field_presence = LEGACY_REQUIRED, + default = 9e9 + ]; + + double default_double = 252 [ + features.field_presence = LEGACY_REQUIRED, + default = 7e22 + ]; + + bool default_bool = 253 [ + features.field_presence = LEGACY_REQUIRED, + default = true + ]; + + string default_string = 254 [ + features.field_presence = LEGACY_REQUIRED, + default = "Rosebud" + ]; + + bytes default_bytes = 255 [ + features.field_presence = LEGACY_REQUIRED, + default = "joshua" + ]; + + // Reserved for unknown fields test. + reserved 1000 to 9999; + + // message_set test case. + message MessageSetCorrect { + option message_set_wire_format = true; + + extensions 4 to max; + } + + message MessageSetCorrectExtension1 { + extend MessageSetCorrect { + MessageSetCorrectExtension1 message_set_extension = 1547769; + } + + string str = 25 [ + features.field_presence = LEGACY_REQUIRED + ]; + } + + message MessageSetCorrectExtension2 { + extend MessageSetCorrect { + MessageSetCorrectExtension2 message_set_extension = 4135312; + } + + int32 i = 9 [ + features.field_presence = LEGACY_REQUIRED + ]; + } +} + +message TestLargeOneof { + message A1 { + } + + message A2 { + } + + message A3 { + } + + message A4 { + } + + message A5 { + } + + oneof large_oneof { + A1 a1 = 1; + A2 a2 = 2; + A3 a3 = 3; + A4 a4 = 4; + A5 a5 = 5; + } +} diff --git a/Protos/upstream/editions/golden/test_messages_proto3_editions.proto b/Protos/upstream/editions/golden/test_messages_proto3_editions.proto new file mode 100644 index 000000000..ea6b0946f --- /dev/null +++ b/Protos/upstream/editions/golden/test_messages_proto3_editions.proto @@ -0,0 +1,313 @@ +// clang-format off +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Test schema for proto3 messages. This test schema is used by: +// +// - benchmarks +// - fuzz tests +// - conformance tests + +edition = "2023"; + +package protobuf_test_messages.editions.proto3; + +import "google/protobuf/any.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/field_mask.proto"; +import "google/protobuf/struct.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/wrappers.proto"; + +option features.field_presence = IMPLICIT; +option java_package = "com.google.protobuf_test_messages.editions.proto3"; +option objc_class_prefix = "EditionsProto3"; + +// This is the default, but we specify it here explicitly. +option optimize_for = SPEED; +option cc_enable_arenas = true; + +// This proto includes every type of field in both singular and repeated +// forms. +// +// Also, crucially, all messages and enums in this file are eventually +// submessages of this message. So for example, a fuzz test of TestAllTypes +// could trigger bugs that occur in any message type in this file. We verify +// this stays true in a unit test. +message TestAllTypesProto3 { + message NestedMessage { + int32 a = 1; + TestAllTypesProto3 corecursive = 2; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + NEG = -1; // Intentionally negative. + } + + enum AliasedEnum { + option allow_alias = true; + + ALIAS_FOO = 0; + ALIAS_BAR = 1; + ALIAS_BAZ = 2; + MOO = 2; + moo = 2; + bAz = 2; + } + + // Singular + // test [kotlin] comment + int32 optional_int32 = 1; + int64 optional_int64 = 2; + uint32 optional_uint32 = 3; + uint64 optional_uint64 = 4; + sint32 optional_sint32 = 5; + sint64 optional_sint64 = 6; + fixed32 optional_fixed32 = 7; + fixed64 optional_fixed64 = 8; + sfixed32 optional_sfixed32 = 9; + sfixed64 optional_sfixed64 = 10; + float optional_float = 11; + double optional_double = 12; + bool optional_bool = 13; + string optional_string = 14; + bytes optional_bytes = 15; + NestedMessage optional_nested_message = 18; + ForeignMessage optional_foreign_message = 19; + NestedEnum optional_nested_enum = 21; + ForeignEnum optional_foreign_enum = 22; + AliasedEnum optional_aliased_enum = 23; + string optional_string_piece = 24 [ + ctype = STRING_PIECE + ]; + + string optional_cord = 25 [ + ctype = CORD + ]; + + TestAllTypesProto3 recursive_message = 27; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + repeated NestedMessage repeated_nested_message = 48; + repeated ForeignMessage repeated_foreign_message = 49; + repeated NestedEnum repeated_nested_enum = 51; + repeated ForeignEnum repeated_foreign_enum = 52; + repeated string repeated_string_piece = 54 [ + ctype = STRING_PIECE + ]; + + repeated string repeated_cord = 55 [ + ctype = CORD + ]; + + // Packed + repeated int32 packed_int32 = 75; + repeated int64 packed_int64 = 76; + repeated uint32 packed_uint32 = 77; + repeated uint64 packed_uint64 = 78; + repeated sint32 packed_sint32 = 79; + repeated sint64 packed_sint64 = 80; + repeated fixed32 packed_fixed32 = 81; + repeated fixed64 packed_fixed64 = 82; + repeated sfixed32 packed_sfixed32 = 83; + repeated sfixed64 packed_sfixed64 = 84; + repeated float packed_float = 85; + repeated double packed_double = 86; + repeated bool packed_bool = 87; + repeated NestedEnum packed_nested_enum = 88; + + // Unpacked + repeated int32 unpacked_int32 = 89 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated int64 unpacked_int64 = 90 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated uint32 unpacked_uint32 = 91 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated uint64 unpacked_uint64 = 92 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated sint32 unpacked_sint32 = 93 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated sint64 unpacked_sint64 = 94 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated fixed32 unpacked_fixed32 = 95 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated fixed64 unpacked_fixed64 = 96 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated sfixed32 unpacked_sfixed32 = 97 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated sfixed64 unpacked_sfixed64 = 98 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated float unpacked_float = 99 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated double unpacked_double = 100 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated bool unpacked_bool = 101 [ + features.repeated_field_encoding = EXPANDED + ]; + + repeated NestedEnum unpacked_nested_enum = 102 [ + features.repeated_field_encoding = EXPANDED + ]; + + // Map + map map_int32_int32 = 56; + map map_int64_int64 = 57; + map map_uint32_uint32 = 58; + map map_uint64_uint64 = 59; + map map_sint32_sint32 = 60; + map map_sint64_sint64 = 61; + map map_fixed32_fixed32 = 62; + map map_fixed64_fixed64 = 63; + map map_sfixed32_sfixed32 = 64; + map map_sfixed64_sfixed64 = 65; + map map_int32_float = 66; + map map_int32_double = 67; + map map_bool_bool = 68; + map map_string_string = 69; + map map_string_bytes = 70; + map map_string_nested_message = 71; + map map_string_foreign_message = 72; + map map_string_nested_enum = 73; + map map_string_foreign_enum = 74; + + oneof oneof_field { + uint32 oneof_uint32 = 111; + NestedMessage oneof_nested_message = 112; + string oneof_string = 113; + bytes oneof_bytes = 114; + bool oneof_bool = 115; + uint64 oneof_uint64 = 116; + float oneof_float = 117; + double oneof_double = 118; + NestedEnum oneof_enum = 119; + google.protobuf.NullValue oneof_null_value = 120; + } + + // Well-known types + google.protobuf.BoolValue optional_bool_wrapper = 201; + google.protobuf.Int32Value optional_int32_wrapper = 202; + google.protobuf.Int64Value optional_int64_wrapper = 203; + google.protobuf.UInt32Value optional_uint32_wrapper = 204; + google.protobuf.UInt64Value optional_uint64_wrapper = 205; + google.protobuf.FloatValue optional_float_wrapper = 206; + google.protobuf.DoubleValue optional_double_wrapper = 207; + google.protobuf.StringValue optional_string_wrapper = 208; + google.protobuf.BytesValue optional_bytes_wrapper = 209; + repeated google.protobuf.BoolValue repeated_bool_wrapper = 211; + repeated google.protobuf.Int32Value repeated_int32_wrapper = 212; + repeated google.protobuf.Int64Value repeated_int64_wrapper = 213; + repeated google.protobuf.UInt32Value repeated_uint32_wrapper = 214; + repeated google.protobuf.UInt64Value repeated_uint64_wrapper = 215; + repeated google.protobuf.FloatValue repeated_float_wrapper = 216; + repeated google.protobuf.DoubleValue repeated_double_wrapper = 217; + repeated google.protobuf.StringValue repeated_string_wrapper = 218; + repeated google.protobuf.BytesValue repeated_bytes_wrapper = 219; + google.protobuf.Duration optional_duration = 301; + google.protobuf.Timestamp optional_timestamp = 302; + google.protobuf.FieldMask optional_field_mask = 303; + google.protobuf.Struct optional_struct = 304; + google.protobuf.Any optional_any = 305; + google.protobuf.Value optional_value = 306; + google.protobuf.NullValue optional_null_value = 307; + repeated google.protobuf.Duration repeated_duration = 311; + repeated google.protobuf.Timestamp repeated_timestamp = 312; + repeated google.protobuf.FieldMask repeated_fieldmask = 313; + repeated google.protobuf.Struct repeated_struct = 324; + repeated google.protobuf.Any repeated_any = 315; + repeated google.protobuf.Value repeated_value = 316; + repeated google.protobuf.ListValue repeated_list_value = 317; + + // Test field-name-to-JSON-name convention. + // (protobuf says names can be any valid C/C++ identifier.) + int32 fieldname1 = 401; + int32 field_name2 = 402; + int32 _field_name3 = 403; + int32 field__name4_ = 404; + int32 field0name5 = 405; + int32 field_0_name6 = 406; + int32 fieldName7 = 407; + int32 FieldName8 = 408; + int32 field_Name9 = 409; + int32 Field_Name10 = 410; + int32 FIELD_NAME11 = 411; + int32 FIELD_name12 = 412; + int32 __field_name13 = 413; + int32 __Field_name14 = 414; + int32 field__name15 = 415; + int32 field__Name16 = 416; + int32 field_name17__ = 417; + int32 Field_name18__ = 418; + + // Reserved for testing unknown fields + reserved 501 to 510; + + reserved reserved_field; + + reserved 999999; +} + +message ForeignMessage { + int32 c = 1; +} + +enum ForeignEnum { + FOREIGN_FOO = 0; + FOREIGN_BAR = 1; + FOREIGN_BAZ = 2; +} + +message NullHypothesisProto3 { +} + +message EnumOnlyProto3 { + enum Bool { + kFalse = 0; + kTrue = 1; + } +} diff --git a/Protos/upstream/go/google/protobuf/go_features.proto b/Protos/upstream/go/google/protobuf/go_features.proto new file mode 100644 index 000000000..13819acd3 --- /dev/null +++ b/Protos/upstream/go/google/protobuf/go_features.proto @@ -0,0 +1,112 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2023 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +syntax = "proto2"; + +package pb; + +import "google/protobuf/descriptor.proto"; + +option go_package = "google.golang.org/protobuf/types/gofeaturespb"; + +extend google.protobuf.FeatureSet { + optional GoFeatures go = 1002; +} + +message GoFeatures { + // Whether or not to generate the deprecated UnmarshalJSON method for enums. + // Can only be true for proto using the Open Struct api. + optional bool legacy_unmarshal_json_enum = 1 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023, + edition_deprecated: EDITION_2023, + deprecation_warning: "The legacy UnmarshalJSON API is deprecated and " + "will be removed in a future edition.", + }, + edition_defaults = { edition: EDITION_LEGACY, value: "true" }, + edition_defaults = { edition: EDITION_PROTO3, value: "false" } + ]; + + enum APILevel { + // API_LEVEL_UNSPECIFIED results in selecting the OPEN API, + // but needs to be a separate value to distinguish between + // an explicitly set api level or a missing api level. + API_LEVEL_UNSPECIFIED = 0; + API_OPEN = 1; + API_HYBRID = 2; + API_OPAQUE = 3; + } + + // One of OPEN, HYBRID or OPAQUE. + optional APILevel api_level = 2 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_MESSAGE, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023, + }, + edition_defaults = { + edition: EDITION_LEGACY, + value: "API_LEVEL_UNSPECIFIED" + }, + edition_defaults = { edition: EDITION_2024, value: "API_OPAQUE" } + ]; + + enum StripEnumPrefix { + STRIP_ENUM_PREFIX_UNSPECIFIED = 0; + STRIP_ENUM_PREFIX_KEEP = 1; + STRIP_ENUM_PREFIX_GENERATE_BOTH = 2; + STRIP_ENUM_PREFIX_STRIP = 3; + } + + optional StripEnumPrefix strip_enum_prefix = 3 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_ENUM_ENTRY, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2024, + }, + // TODO: change the default to STRIP_ENUM_PREFIX_STRIP for edition 2025. + edition_defaults = { + edition: EDITION_LEGACY, + value: "STRIP_ENUM_PREFIX_KEEP" + } + ]; + + // Wrap the OptimizeMode enum in a message for scoping: + // This way, users can type shorter names (SPEED, CODE_SIZE). + message OptimizeModeFeature { + // The name of this enum matches OptimizeMode in descriptor.proto. + enum OptimizeMode { + // OPTIMIZE_MODE_UNSPECIFIED results in falling back to the default + // (optimize for code size), but needs to be a separate value to distinguish + // between an explicitly set optimize mode or a missing optimize mode. + OPTIMIZE_MODE_UNSPECIFIED = 0; + SPEED = 1; + CODE_SIZE = 2; + // There is no enum entry for LITE_RUNTIME (descriptor.proto), + // because Go Protobuf does not have the concept of a lite runtime. + } + } + + optional OptimizeModeFeature.OptimizeMode optimize_mode = 4 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_MESSAGE, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2024, + }, + edition_defaults = { + edition: EDITION_LEGACY, + value: "OPTIMIZE_MODE_UNSPECIFIED" + } + ]; +} diff --git a/Protos/upstream/google/protobuf/any.proto b/Protos/upstream/google/protobuf/any.proto new file mode 100644 index 000000000..eff44e509 --- /dev/null +++ b/Protos/upstream/google/protobuf/any.proto @@ -0,0 +1,162 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +syntax = "proto3"; + +package google.protobuf; + +option go_package = "google.golang.org/protobuf/types/known/anypb"; +option java_package = "com.google.protobuf"; +option java_outer_classname = "AnyProto"; +option java_multiple_files = true; +option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; + +// `Any` contains an arbitrary serialized protocol buffer message along with a +// URL that describes the type of the serialized message. +// +// Protobuf library provides support to pack/unpack Any values in the form +// of utility functions or additional generated methods of the Any type. +// +// Example 1: Pack and unpack a message in C++. +// +// Foo foo = ...; +// Any any; +// any.PackFrom(foo); +// ... +// if (any.UnpackTo(&foo)) { +// ... +// } +// +// Example 2: Pack and unpack a message in Java. +// +// Foo foo = ...; +// Any any = Any.pack(foo); +// ... +// if (any.is(Foo.class)) { +// foo = any.unpack(Foo.class); +// } +// // or ... +// if (any.isSameTypeAs(Foo.getDefaultInstance())) { +// foo = any.unpack(Foo.getDefaultInstance()); +// } +// +// Example 3: Pack and unpack a message in Python. +// +// foo = Foo(...) +// any = Any() +// any.Pack(foo) +// ... +// if any.Is(Foo.DESCRIPTOR): +// any.Unpack(foo) +// ... +// +// Example 4: Pack and unpack a message in Go +// +// foo := &pb.Foo{...} +// any, err := anypb.New(foo) +// if err != nil { +// ... +// } +// ... +// foo := &pb.Foo{} +// if err := any.UnmarshalTo(foo); err != nil { +// ... +// } +// +// The pack methods provided by protobuf library will by default use +// 'type.googleapis.com/full.type.name' as the type URL and the unpack +// methods only use the fully qualified type name after the last '/' +// in the type URL, for example "foo.bar.com/x/y.z" will yield type +// name "y.z". +// +// JSON +// ==== +// The JSON representation of an `Any` value uses the regular +// representation of the deserialized, embedded message, with an +// additional field `@type` which contains the type URL. Example: +// +// package google.profile; +// message Person { +// string first_name = 1; +// string last_name = 2; +// } +// +// { +// "@type": "type.googleapis.com/google.profile.Person", +// "firstName": , +// "lastName": +// } +// +// If the embedded message type is well-known and has a custom JSON +// representation, that representation will be embedded adding a field +// `value` which holds the custom JSON in addition to the `@type` +// field. Example (for message [google.protobuf.Duration][]): +// +// { +// "@type": "type.googleapis.com/google.protobuf.Duration", +// "value": "1.212s" +// } +// +message Any { + // A URL/resource name that uniquely identifies the type of the serialized + // protocol buffer message. This string must contain at least + // one "/" character. The last segment of the URL's path must represent + // the fully qualified name of the type (as in + // `path/google.protobuf.Duration`). The name should be in a canonical form + // (e.g., leading "." is not accepted). + // + // In practice, teams usually precompile into the binary all types that they + // expect it to use in the context of Any. However, for URLs which use the + // scheme `http`, `https`, or no scheme, one can optionally set up a type + // server that maps type URLs to message definitions as follows: + // + // * If no scheme is provided, `https` is assumed. + // * An HTTP GET on the URL must yield a [google.protobuf.Type][] + // value in binary format, or produce an error. + // * Applications are allowed to cache lookup results based on the + // URL, or have them precompiled into a binary to avoid any + // lookup. Therefore, binary compatibility needs to be preserved + // on changes to types. (Use versioned type names to manage + // breaking changes.) + // + // Note: this functionality is not currently available in the official + // protobuf release, and it is not used for type URLs beginning with + // type.googleapis.com. As of May 2023, there are no widely used type server + // implementations and no plans to implement one. + // + // Schemes other than `http`, `https` (or the empty scheme) might be + // used with implementation specific semantics. + // + string type_url = 1; + + // Must be a valid serialized protocol buffer of the above specified type. + bytes value = 2; +} diff --git a/Protos/upstream/google/protobuf/any_test.proto b/Protos/upstream/google/protobuf/any_test.proto new file mode 100644 index 000000000..05b0c8bcd --- /dev/null +++ b/Protos/upstream/google/protobuf/any_test.proto @@ -0,0 +1,21 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +syntax = "proto3"; + +package proto2_unittest; + +import "google/protobuf/any.proto"; + +option java_outer_classname = "TestAnyProto"; + +message TestAny { + int32 int32_value = 1; + google.protobuf.Any any_value = 2; + repeated google.protobuf.Any repeated_any_value = 3; + string text = 4; +} diff --git a/Protos/upstream/google/protobuf/api.proto b/Protos/upstream/google/protobuf/api.proto new file mode 100644 index 000000000..c8f742543 --- /dev/null +++ b/Protos/upstream/google/protobuf/api.proto @@ -0,0 +1,229 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +syntax = "proto3"; + +package google.protobuf; + +import "google/protobuf/source_context.proto"; +import "google/protobuf/type.proto"; + +option java_package = "com.google.protobuf"; +option java_outer_classname = "ApiProto"; +option java_multiple_files = true; +option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option go_package = "google.golang.org/protobuf/types/known/apipb"; + +// Api is a light-weight descriptor for an API Interface. +// +// Interfaces are also described as "protocol buffer services" in some contexts, +// such as by the "service" keyword in a .proto file, but they are different +// from API Services, which represent a concrete implementation of an interface +// as opposed to simply a description of methods and bindings. They are also +// sometimes simply referred to as "APIs" in other contexts, such as the name of +// this message itself. See https://cloud.google.com/apis/design/glossary for +// detailed terminology. +// +// New usages of this message as an alternative to ServiceDescriptorProto are +// strongly discouraged. This message does not reliability preserve all +// information necessary to model the schema and preserve semantics. Instead +// make use of FileDescriptorSet which preserves the necessary information. +message Api { + // The fully qualified name of this interface, including package name + // followed by the interface's simple name. + string name = 1; + + // The methods of this interface, in unspecified order. + repeated Method methods = 2; + + // Any metadata attached to the interface. + repeated Option options = 3; + + // A version string for this interface. If specified, must have the form + // `major-version.minor-version`, as in `1.10`. If the minor version is + // omitted, it defaults to zero. If the entire version field is empty, the + // major version is derived from the package name, as outlined below. If the + // field is not empty, the version in the package name will be verified to be + // consistent with what is provided here. + // + // The versioning schema uses [semantic + // versioning](http://semver.org) where the major version number + // indicates a breaking change and the minor version an additive, + // non-breaking change. Both version numbers are signals to users + // what to expect from different versions, and should be carefully + // chosen based on the product plan. + // + // The major version is also reflected in the package name of the + // interface, which must end in `v`, as in + // `google.feature.v1`. For major versions 0 and 1, the suffix can + // be omitted. Zero major versions must only be used for + // experimental, non-GA interfaces. + // + string version = 4; + + // Source context for the protocol buffer service represented by this + // message. + SourceContext source_context = 5; + + // Included interfaces. See [Mixin][]. + repeated Mixin mixins = 6; + + // The source syntax of the service. + Syntax syntax = 7; + + // The source edition string, only valid when syntax is SYNTAX_EDITIONS. + string edition = 8; +} + +// Method represents a method of an API interface. +// +// New usages of this message as an alternative to MethodDescriptorProto are +// strongly discouraged. This message does not reliability preserve all +// information necessary to model the schema and preserve semantics. Instead +// make use of FileDescriptorSet which preserves the necessary information. +message Method { + // The simple name of this method. + string name = 1; + + // A URL of the input message type. + string request_type_url = 2; + + // If true, the request is streamed. + bool request_streaming = 3; + + // The URL of the output message type. + string response_type_url = 4; + + // If true, the response is streamed. + bool response_streaming = 5; + + // Any metadata attached to the method. + repeated Option options = 6; + + // The source syntax of this method. + // + // This field should be ignored, instead the syntax should be inherited from + // Api. This is similar to Field and EnumValue. + Syntax syntax = 7 [deprecated = true]; + + // The source edition string, only valid when syntax is SYNTAX_EDITIONS. + // + // This field should be ignored, instead the edition should be inherited from + // Api. This is similar to Field and EnumValue. + string edition = 8 [deprecated = true]; +} + +// Declares an API Interface to be included in this interface. The including +// interface must redeclare all the methods from the included interface, but +// documentation and options are inherited as follows: +// +// - If after comment and whitespace stripping, the documentation +// string of the redeclared method is empty, it will be inherited +// from the original method. +// +// - Each annotation belonging to the service config (http, +// visibility) which is not set in the redeclared method will be +// inherited. +// +// - If an http annotation is inherited, the path pattern will be +// modified as follows. Any version prefix will be replaced by the +// version of the including interface plus the [root][] path if +// specified. +// +// Example of a simple mixin: +// +// package google.acl.v1; +// service AccessControl { +// // Get the underlying ACL object. +// rpc GetAcl(GetAclRequest) returns (Acl) { +// option (google.api.http).get = "/v1/{resource=**}:getAcl"; +// } +// } +// +// package google.storage.v2; +// service Storage { +// rpc GetAcl(GetAclRequest) returns (Acl); +// +// // Get a data record. +// rpc GetData(GetDataRequest) returns (Data) { +// option (google.api.http).get = "/v2/{resource=**}"; +// } +// } +// +// Example of a mixin configuration: +// +// apis: +// - name: google.storage.v2.Storage +// mixins: +// - name: google.acl.v1.AccessControl +// +// The mixin construct implies that all methods in `AccessControl` are +// also declared with same name and request/response types in +// `Storage`. A documentation generator or annotation processor will +// see the effective `Storage.GetAcl` method after inheriting +// documentation and annotations as follows: +// +// service Storage { +// // Get the underlying ACL object. +// rpc GetAcl(GetAclRequest) returns (Acl) { +// option (google.api.http).get = "/v2/{resource=**}:getAcl"; +// } +// ... +// } +// +// Note how the version in the path pattern changed from `v1` to `v2`. +// +// If the `root` field in the mixin is specified, it should be a +// relative path under which inherited HTTP paths are placed. Example: +// +// apis: +// - name: google.storage.v2.Storage +// mixins: +// - name: google.acl.v1.AccessControl +// root: acls +// +// This implies the following inherited HTTP annotation: +// +// service Storage { +// // Get the underlying ACL object. +// rpc GetAcl(GetAclRequest) returns (Acl) { +// option (google.api.http).get = "/v2/acls/{resource=**}:getAcl"; +// } +// ... +// } +message Mixin { + // The fully qualified name of the interface which is included. + string name = 1; + + // If non-empty specifies a path under which inherited HTTP paths + // are rooted. + string root = 2; +} diff --git a/Protos/upstream/google/protobuf/compiler/plugin.proto b/Protos/upstream/google/protobuf/compiler/plugin.proto new file mode 100644 index 000000000..10d285f8a --- /dev/null +++ b/Protos/upstream/google/protobuf/compiler/plugin.proto @@ -0,0 +1,180 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// +// protoc (aka the Protocol Compiler) can be extended via plugins. A plugin is +// just a program that reads a CodeGeneratorRequest from stdin and writes a +// CodeGeneratorResponse to stdout. +// +// Plugins written using C++ can use google/protobuf/compiler/plugin.h instead +// of dealing with the raw protocol defined here. +// +// A plugin executable needs only to be placed somewhere in the path. The +// plugin should be named "protoc-gen-$NAME", and will then be used when the +// flag "--${NAME}_out" is passed to protoc. + +syntax = "proto2"; + +package google.protobuf.compiler; +option java_package = "com.google.protobuf.compiler"; +option java_outer_classname = "PluginProtos"; + +import "google/protobuf/descriptor.proto"; + +option csharp_namespace = "Google.Protobuf.Compiler"; +option go_package = "google.golang.org/protobuf/types/pluginpb"; + +// The version number of protocol compiler. +message Version { + optional int32 major = 1; + optional int32 minor = 2; + optional int32 patch = 3; + // A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should + // be empty for mainline stable releases. + optional string suffix = 4; +} + +// An encoded CodeGeneratorRequest is written to the plugin's stdin. +message CodeGeneratorRequest { + // The .proto files that were explicitly listed on the command-line. The + // code generator should generate code only for these files. Each file's + // descriptor will be included in proto_file, below. + repeated string file_to_generate = 1; + + // The generator parameter passed on the command-line. + optional string parameter = 2; + + // FileDescriptorProtos for all files in files_to_generate and everything + // they import. The files will appear in topological order, so each file + // appears before any file that imports it. + // + // Note: the files listed in files_to_generate will include runtime-retention + // options only, but all other files will include source-retention options. + // The source_file_descriptors field below is available in case you need + // source-retention options for files_to_generate. + // + // protoc guarantees that all proto_files will be written after + // the fields above, even though this is not technically guaranteed by the + // protobuf wire format. This theoretically could allow a plugin to stream + // in the FileDescriptorProtos and handle them one by one rather than read + // the entire set into memory at once. However, as of this writing, this + // is not similarly optimized on protoc's end -- it will store all fields in + // memory at once before sending them to the plugin. + // + // Type names of fields and extensions in the FileDescriptorProto are always + // fully qualified. + repeated FileDescriptorProto proto_file = 15; + + // File descriptors with all options, including source-retention options. + // These descriptors are only provided for the files listed in + // files_to_generate. + repeated FileDescriptorProto source_file_descriptors = 17; + + // The version number of protocol compiler. + optional Version compiler_version = 3; +} + +// The plugin writes an encoded CodeGeneratorResponse to stdout. +message CodeGeneratorResponse { + // Error message. If non-empty, code generation failed. The plugin process + // should exit with status code zero even if it reports an error in this way. + // + // This should be used to indicate errors in .proto files which prevent the + // code generator from generating correct code. Errors which indicate a + // problem in protoc itself -- such as the input CodeGeneratorRequest being + // unparseable -- should be reported by writing a message to stderr and + // exiting with a non-zero status code. + optional string error = 1; + + // A bitmask of supported features that the code generator supports. + // This is a bitwise "or" of values from the Feature enum. + optional uint64 supported_features = 2; + + // Sync with code_generator.h. + enum Feature { + FEATURE_NONE = 0; + FEATURE_PROTO3_OPTIONAL = 1; + FEATURE_SUPPORTS_EDITIONS = 2; + } + + // The minimum edition this plugin supports. This will be treated as an + // Edition enum, but we want to allow unknown values. It should be specified + // according the edition enum value, *not* the edition number. Only takes + // effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + optional int32 minimum_edition = 3; + + // The maximum edition this plugin supports. This will be treated as an + // Edition enum, but we want to allow unknown values. It should be specified + // according the edition enum value, *not* the edition number. Only takes + // effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + optional int32 maximum_edition = 4; + + // Represents a single generated file. + message File { + // The file name, relative to the output directory. The name must not + // contain "." or ".." components and must be relative, not be absolute (so, + // the file cannot lie outside the output directory). "/" must be used as + // the path separator, not "\". + // + // If the name is omitted, the content will be appended to the previous + // file. This allows the generator to break large files into small chunks, + // and allows the generated text to be streamed back to protoc so that large + // files need not reside completely in memory at one time. Note that as of + // this writing protoc does not optimize for this -- it will read the entire + // CodeGeneratorResponse before writing files to disk. + optional string name = 1; + + // If non-empty, indicates that the named file should already exist, and the + // content here is to be inserted into that file at a defined insertion + // point. This feature allows a code generator to extend the output + // produced by another code generator. The original generator may provide + // insertion points by placing special annotations in the file that look + // like: + // @@protoc_insertion_point(NAME) + // The annotation can have arbitrary text before and after it on the line, + // which allows it to be placed in a comment. NAME should be replaced with + // an identifier naming the point -- this is what other generators will use + // as the insertion_point. Code inserted at this point will be placed + // immediately above the line containing the insertion point (thus multiple + // insertions to the same point will come out in the order they were added). + // The double-@ is intended to make it unlikely that the generated code + // could contain things that look like insertion points by accident. + // + // For example, the C++ code generator places the following line in the + // .pb.h files that it generates: + // // @@protoc_insertion_point(namespace_scope) + // This line appears within the scope of the file's package namespace, but + // outside of any particular class. Another plugin can then specify the + // insertion_point "namespace_scope" to generate additional classes or + // other declarations that should be placed in this scope. + // + // Note that if the line containing the insertion point begins with + // whitespace, the same whitespace will be added to every line of the + // inserted text. This is useful for languages like Python, where + // indentation matters. In these languages, the insertion point comment + // should be indented the same amount as any inserted code will need to be + // in order to work correctly in that context. + // + // The code generator that generates the initial file and the one which + // inserts into it must both run as part of a single invocation of protoc. + // Code generators are executed in the order in which they appear on the + // command line. + // + // If |insertion_point| is present, |name| must also be present. + optional string insertion_point = 2; + + // The file contents. + optional string content = 15; + + // Information describing the file content being inserted. If an insertion + // point is used, this information will be appropriately offset and inserted + // into the code generation metadata for the generated files. + optional GeneratedCodeInfo generated_code_info = 16; + } + repeated File file = 15; +} diff --git a/Protos/upstream/google/protobuf/cpp_features.proto b/Protos/upstream/google/protobuf/cpp_features.proto new file mode 100644 index 000000000..75bf6b859 --- /dev/null +++ b/Protos/upstream/google/protobuf/cpp_features.proto @@ -0,0 +1,67 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2023 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +syntax = "proto2"; + +package pb; + +import "google/protobuf/descriptor.proto"; + +extend google.protobuf.FeatureSet { + optional CppFeatures cpp = 1000; +} + +message CppFeatures { + // Whether or not to treat an enum field as closed. This option is only + // applicable to enum fields, and will be removed in the future. It is + // consistent with the legacy behavior of using proto3 enum types for proto2 + // fields. + optional bool legacy_closed_enum = 1 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023, + edition_deprecated: EDITION_2023, + deprecation_warning: "The legacy closed enum behavior in C++ is " + "deprecated and is scheduled to be removed in " + "edition 2025. See http://protobuf.dev/programming-guides/enum/#cpp for " + "more information", + }, + edition_defaults = { edition: EDITION_LEGACY, value: "true" }, + edition_defaults = { edition: EDITION_PROTO3, value: "false" } + ]; + + enum StringType { + STRING_TYPE_UNKNOWN = 0; + VIEW = 1; + CORD = 2; + STRING = 3; + } + + optional StringType string_type = 2 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "STRING" }, + edition_defaults = { edition: EDITION_2024, value: "VIEW" } + ]; + + optional bool enum_name_uses_string_view = 3 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2024, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "false" }, + edition_defaults = { edition: EDITION_2024, value: "true" } + ]; +} diff --git a/Protos/upstream/google/protobuf/descriptor.proto b/Protos/upstream/google/protobuf/descriptor.proto new file mode 100644 index 000000000..e5683a271 --- /dev/null +++ b/Protos/upstream/google/protobuf/descriptor.proto @@ -0,0 +1,1448 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// The messages in this file describe the definitions found in .proto files. +// A valid .proto file can be translated directly to a FileDescriptorProto +// without any other information (e.g. without reading its imports). + +syntax = "proto2"; + +package google.protobuf; + +option go_package = "google.golang.org/protobuf/types/descriptorpb"; +option java_package = "com.google.protobuf"; +option java_outer_classname = "DescriptorProtos"; +option csharp_namespace = "Google.Protobuf.Reflection"; +option objc_class_prefix = "GPB"; +option cc_enable_arenas = true; + +// descriptor.proto must be optimized for speed because reflection-based +// algorithms don't work during bootstrapping. +option optimize_for = SPEED; + +// The protocol compiler can output a FileDescriptorSet containing the .proto +// files it parses. +message FileDescriptorSet { + repeated FileDescriptorProto file = 1; + + // Extensions for tooling. + extensions 536000000 [declaration = { + number: 536000000 + type: ".buf.descriptor.v1.FileDescriptorSetExtension" + full_name: ".buf.descriptor.v1.buf_file_descriptor_set_extension" + }]; +} + +// The full set of known editions. +enum Edition { + // A placeholder for an unknown edition value. + EDITION_UNKNOWN = 0; + + // A placeholder edition for specifying default behaviors *before* a feature + // was first introduced. This is effectively an "infinite past". + EDITION_LEGACY = 900; + + // Legacy syntax "editions". These pre-date editions, but behave much like + // distinct editions. These can't be used to specify the edition of proto + // files, but feature definitions must supply proto2/proto3 defaults for + // backwards compatibility. + EDITION_PROTO2 = 998; + EDITION_PROTO3 = 999; + + // Editions that have been released. The specific values are arbitrary and + // should not be depended on, but they will always be time-ordered for easy + // comparison. + EDITION_2023 = 1000; + EDITION_2024 = 1001; + + // A placeholder edition for developing and testing unscheduled features. + EDITION_UNSTABLE = 9999; + + // Placeholder editions for testing feature resolution. These should not be + // used or relied on outside of tests. + EDITION_1_TEST_ONLY = 1; + EDITION_2_TEST_ONLY = 2; + EDITION_99997_TEST_ONLY = 99997; + EDITION_99998_TEST_ONLY = 99998; + EDITION_99999_TEST_ONLY = 99999; + + // Placeholder for specifying unbounded edition support. This should only + // ever be used by plugins that can expect to never require any changes to + // support a new edition. + EDITION_MAX = 0x7FFFFFFF; +} + +// Describes a complete .proto file. +message FileDescriptorProto { + optional string name = 1; // file name, relative to root of source tree + optional string package = 2; // e.g. "foo", "foo.bar", etc. + + // Names of files imported by this file. + repeated string dependency = 3; + // Indexes of the public imported files in the dependency list above. + repeated int32 public_dependency = 10; + // Indexes of the weak imported files in the dependency list. + // For Google-internal migration only. Do not use. + repeated int32 weak_dependency = 11; + + // Names of files imported by this file purely for the purpose of providing + // option extensions. These are excluded from the dependency list above. + repeated string option_dependency = 15; + + // All top-level definitions in this file. + repeated DescriptorProto message_type = 4; + repeated EnumDescriptorProto enum_type = 5; + repeated ServiceDescriptorProto service = 6; + repeated FieldDescriptorProto extension = 7; + + optional FileOptions options = 8; + + // This field contains optional information about the original source code. + // You may safely remove this entire field without harming runtime + // functionality of the descriptors -- the information is needed only by + // development tools. + optional SourceCodeInfo source_code_info = 9; + + // The syntax of the proto file. + // The supported values are "proto2", "proto3", and "editions". + // + // If `edition` is present, this value must be "editions". + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional string syntax = 12; + + // The edition of the proto file. + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional Edition edition = 14; +} + +// Describes a message type. +message DescriptorProto { + optional string name = 1; + + repeated FieldDescriptorProto field = 2; + repeated FieldDescriptorProto extension = 6; + + repeated DescriptorProto nested_type = 3; + repeated EnumDescriptorProto enum_type = 4; + + message ExtensionRange { + optional int32 start = 1; // Inclusive. + optional int32 end = 2; // Exclusive. + + optional ExtensionRangeOptions options = 3; + } + repeated ExtensionRange extension_range = 5; + + repeated OneofDescriptorProto oneof_decl = 8; + + optional MessageOptions options = 7; + + // Range of reserved tag numbers. Reserved tag numbers may not be used by + // fields or extension ranges in the same message. Reserved ranges may + // not overlap. + message ReservedRange { + optional int32 start = 1; // Inclusive. + optional int32 end = 2; // Exclusive. + } + repeated ReservedRange reserved_range = 9; + // Reserved field names, which may not be used by fields in the same message. + // A given name may only be reserved once. + repeated string reserved_name = 10; + + // Support for `export` and `local` keywords on enums. + optional SymbolVisibility visibility = 11; +} + +message ExtensionRangeOptions { + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + message Declaration { + // The extension number declared within the extension range. + optional int32 number = 1; + + // The fully-qualified name of the extension field. There must be a leading + // dot in front of the full name. + optional string full_name = 2; + + // The fully-qualified type name of the extension field. Unlike + // Metadata.type, Declaration.type must have a leading dot for messages + // and enums. + optional string type = 3; + + // If true, indicates that the number is reserved in the extension range, + // and any extension field with the number will fail to compile. Set this + // when a declared extension field is deleted. + optional bool reserved = 5; + + // If true, indicates that the extension must be defined as repeated. + // Otherwise the extension must be defined as optional. + optional bool repeated = 6; + + reserved 4; // removed is_repeated + } + + // For external users: DO NOT USE. We are in the process of open sourcing + // extension declaration and executing internal cleanups before it can be + // used externally. + repeated Declaration declaration = 2 [retention = RETENTION_SOURCE]; + + // Any features defined in the specific edition. + optional FeatureSet features = 50; + + // The verification state of the extension range. + enum VerificationState { + // All the extensions of the range must be declared. + DECLARATION = 0; + UNVERIFIED = 1; + } + + // The verification state of the range. + // TODO: flip the default to DECLARATION once all empty ranges + // are marked as UNVERIFIED. + optional VerificationState verification = 3 + [default = UNVERIFIED, retention = RETENTION_SOURCE]; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +// Describes a field within a message. +message FieldDescriptorProto { + enum Type { + // 0 is reserved for errors. + // Order is weird for historical reasons. + TYPE_DOUBLE = 1; + TYPE_FLOAT = 2; + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + // negative values are likely. + TYPE_INT64 = 3; + TYPE_UINT64 = 4; + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + // negative values are likely. + TYPE_INT32 = 5; + TYPE_FIXED64 = 6; + TYPE_FIXED32 = 7; + TYPE_BOOL = 8; + TYPE_STRING = 9; + // Tag-delimited aggregate. + // Group type is deprecated and not supported after google.protobuf. However, Proto3 + // implementations should still be able to parse the group wire format and + // treat group fields as unknown fields. In Editions, the group wire format + // can be enabled via the `message_encoding` feature. + TYPE_GROUP = 10; + TYPE_MESSAGE = 11; // Length-delimited aggregate. + + // New in version 2. + TYPE_BYTES = 12; + TYPE_UINT32 = 13; + TYPE_ENUM = 14; + TYPE_SFIXED32 = 15; + TYPE_SFIXED64 = 16; + TYPE_SINT32 = 17; // Uses ZigZag encoding. + TYPE_SINT64 = 18; // Uses ZigZag encoding. + } + + enum Label { + // 0 is reserved for errors + LABEL_OPTIONAL = 1; + LABEL_REPEATED = 3; + // The required label is only allowed in google.protobuf. In proto3 and Editions + // it's explicitly prohibited. In Editions, the `field_presence` feature + // can be used to get this behavior. + LABEL_REQUIRED = 2; + } + + optional string name = 1; + optional int32 number = 3; + optional Label label = 4; + + // If type_name is set, this need not be set. If both this and type_name + // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. + optional Type type = 5; + + // For message and enum types, this is the name of the type. If the name + // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping + // rules are used to find the type (i.e. first the nested types within this + // message are searched, then within the parent, on up to the root + // namespace). + optional string type_name = 6; + + // For extensions, this is the name of the type being extended. It is + // resolved in the same manner as type_name. + optional string extendee = 2; + + // For numeric types, contains the original text representation of the value. + // For booleans, "true" or "false". + // For strings, contains the default text contents (not escaped in any way). + // For bytes, contains the C escaped value. All bytes >= 128 are escaped. + optional string default_value = 7; + + // If set, gives the index of a oneof in the containing type's oneof_decl + // list. This field is a member of that oneof. + optional int32 oneof_index = 9; + + // JSON name of this field. The value is set by protocol compiler. If the + // user has set a "json_name" option on this field, that option's value + // will be used. Otherwise, it's deduced from the field's name by converting + // it to camelCase. + optional string json_name = 10; + + optional FieldOptions options = 8; + + // If true, this is a proto3 "optional". When a proto3 field is optional, it + // tracks presence regardless of field type. + // + // When proto3_optional is true, this field must belong to a oneof to signal + // to old proto3 clients that presence is tracked for this field. This oneof + // is known as a "synthetic" oneof, and this field must be its sole member + // (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs + // exist in the descriptor only, and do not generate any API. Synthetic oneofs + // must be ordered after all "real" oneofs. + // + // For message fields, proto3_optional doesn't create any semantic change, + // since non-repeated message fields always track presence. However it still + // indicates the semantic detail of whether the user wrote "optional" or not. + // This can be useful for round-tripping the .proto file. For consistency we + // give message fields a synthetic oneof also, even though it is not required + // to track presence. This is especially important because the parser can't + // tell if a field is a message or an enum, so it must always create a + // synthetic oneof. + // + // Proto2 optional fields do not set this flag, because they already indicate + // optional with `LABEL_OPTIONAL`. + optional bool proto3_optional = 17; +} + +// Describes a oneof. +message OneofDescriptorProto { + optional string name = 1; + optional OneofOptions options = 2; +} + +// Describes an enum type. +message EnumDescriptorProto { + optional string name = 1; + + repeated EnumValueDescriptorProto value = 2; + + optional EnumOptions options = 3; + + // Range of reserved numeric values. Reserved values may not be used by + // entries in the same enum. Reserved ranges may not overlap. + // + // Note that this is distinct from DescriptorProto.ReservedRange in that it + // is inclusive such that it can appropriately represent the entire int32 + // domain. + message EnumReservedRange { + optional int32 start = 1; // Inclusive. + optional int32 end = 2; // Inclusive. + } + + // Range of reserved numeric values. Reserved numeric values may not be used + // by enum values in the same enum declaration. Reserved ranges may not + // overlap. + repeated EnumReservedRange reserved_range = 4; + + // Reserved enum value names, which may not be reused. A given name may only + // be reserved once. + repeated string reserved_name = 5; + + // Support for `export` and `local` keywords on enums. + optional SymbolVisibility visibility = 6; +} + +// Describes a value within an enum. +message EnumValueDescriptorProto { + optional string name = 1; + optional int32 number = 2; + + optional EnumValueOptions options = 3; +} + +// Describes a service. +message ServiceDescriptorProto { + optional string name = 1; + repeated MethodDescriptorProto method = 2; + + optional ServiceOptions options = 3; + + reserved 4; + reserved "stream"; +} + +// Describes a method of a service. +message MethodDescriptorProto { + optional string name = 1; + + // Input and output type names. These are resolved in the same way as + // FieldDescriptorProto.type_name, but must refer to a message type. + optional string input_type = 2; + optional string output_type = 3; + + optional MethodOptions options = 4; + + // Identifies if client streams multiple client messages + optional bool client_streaming = 5 [default = false]; + // Identifies if server streams multiple server messages + optional bool server_streaming = 6 [default = false]; +} + +// =================================================================== +// Options + +// Each of the definitions above may have "options" attached. These are +// just annotations which may cause code to be generated slightly differently +// or may contain hints for code that manipulates protocol messages. +// +// Clients may define custom options as extensions of the *Options messages. +// These extensions may not yet be known at parsing time, so the parser cannot +// store the values in them. Instead it stores them in a field in the *Options +// message called uninterpreted_option. This field must have the same name +// across all *Options messages. We then use this field to populate the +// extensions when we build a descriptor, at which point all protos have been +// parsed and so all extensions are known. +// +// Extension numbers for custom options may be chosen as follows: +// * For options which will only be used within a single application or +// organization, or for experimental options, use field numbers 50000 +// through 99999. It is up to you to ensure that you do not use the +// same number for multiple options. +// * For options which will be published and used publicly by multiple +// independent entities, e-mail protobuf-global-extension-registry@google.com +// to reserve extension numbers. Simply provide your project name (e.g. +// Objective-C plugin) and your project website (if available) -- there's no +// need to explain how you intend to use them. Usually you only need one +// extension number. You can declare multiple options with only one extension +// number by putting them in a sub-message. See the Custom Options section of +// the docs for examples: +// https://developers.google.com/protocol-buffers/docs/proto#options +// If this turns out to be popular, a web service will be set up +// to automatically assign option numbers. + +message FileOptions { + + // Sets the Java package where classes generated from this .proto will be + // placed. By default, the proto package is used, but this is often + // inappropriate because proto packages do not normally start with backwards + // domain names. + optional string java_package = 1; + + // Controls the name of the wrapper Java class generated for the .proto file. + // That class will always contain the .proto file's getDescriptor() method as + // well as any top-level extensions defined in the .proto file. + // If java_multiple_files is disabled, then all the other classes from the + // .proto file will be nested inside the single wrapper outer class. + optional string java_outer_classname = 8; + + // If enabled, then the Java code generator will generate a separate .java + // file for each top-level message, enum, and service defined in the .proto + // file. Thus, these types will *not* be nested inside the wrapper class + // named by java_outer_classname. However, the wrapper class will still be + // generated to contain the file's getDescriptor() method as well as any + // top-level extensions defined in the file. + optional bool java_multiple_files = 10 [ + default = false, + feature_support = { + edition_introduced: EDITION_PROTO2 + edition_removed: EDITION_2024 + removal_error: "This behavior is enabled by default in editions 2024 and above. " + "To disable it, you can set `features.(pb.java).nest_in_file_class = YES` " + "on individual messages, enums, or services." + + } + ]; + + // This option does nothing. + optional bool java_generate_equals_and_hash = 20 [deprecated=true]; + + // A proto2 file can set this to true to opt in to UTF-8 checking for Java, + // which will throw an exception if invalid UTF-8 is parsed from the wire or + // assigned to a string field. + // + // TODO: clarify exactly what kinds of field types this option + // applies to, and update these docs accordingly. + // + // Proto3 files already perform these checks. Setting the option explicitly to + // false has no effect: it cannot be used to opt proto3 files out of UTF-8 + // checks. + optional bool java_string_check_utf8 = 27 [default = false]; + + // Generated classes can be optimized for speed or code size. + enum OptimizeMode { + SPEED = 1; // Generate complete code for parsing, serialization, + // etc. + CODE_SIZE = 2; // Use ReflectionOps to implement these methods. + LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime. + } + optional OptimizeMode optimize_for = 9 [default = SPEED]; + + // Sets the Go package where structs generated from this .proto will be + // placed. If omitted, the Go package will be derived from the following: + // - The basename of the package import path, if provided. + // - Otherwise, the package statement in the .proto file, if present. + // - Otherwise, the basename of the .proto file, without extension. + optional string go_package = 11; + + // Should generic services be generated in each language? "Generic" services + // are not specific to any particular RPC system. They are generated by the + // main code generators in each language (without additional plugins). + // Generic services were the only kind of service generation supported by + // early versions of google.protobuf. + // + // Generic services are now considered deprecated in favor of using plugins + // that generate code specific to your particular RPC system. Therefore, + // these default to false. Old code which depends on generic services should + // explicitly set them to true. + optional bool cc_generic_services = 16 [default = false]; + optional bool java_generic_services = 17 [default = false]; + optional bool py_generic_services = 18 [default = false]; + reserved 42; // removed php_generic_services + reserved "php_generic_services"; + + // Is this file deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for everything in the file, or it will be completely ignored; in the very + // least, this is a formalization for deprecating files. + optional bool deprecated = 23 [default = false]; + + // Enables the use of arenas for the proto messages in this file. This applies + // only to generated classes for C++. + optional bool cc_enable_arenas = 31 [default = true]; + + // Sets the objective c class prefix which is prepended to all objective c + // generated classes from this .proto. There is no default. + optional string objc_class_prefix = 36; + + // Namespace for generated classes; defaults to the package. + optional string csharp_namespace = 37; + + // By default Swift generators will take the proto package and CamelCase it + // replacing '.' with underscore and use that to prefix the types/symbols + // defined. When this options is provided, they will use this value instead + // to prefix the types/symbols defined. + optional string swift_prefix = 39; + + // Sets the php class prefix which is prepended to all php generated classes + // from this .proto. Default is empty. + optional string php_class_prefix = 40; + + // Use this option to change the namespace of php generated classes. Default + // is empty. When this option is empty, the package name will be used for + // determining the namespace. + optional string php_namespace = 41; + + // Use this option to change the namespace of php generated metadata classes. + // Default is empty. When this option is empty, the proto file name will be + // used for determining the namespace. + optional string php_metadata_namespace = 44; + + // Use this option to change the package of ruby generated classes. Default + // is empty. When this option is not set, the package name will be used for + // determining the ruby package. + optional string ruby_package = 45; + + // Any features defined in the specific edition. + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional FeatureSet features = 50; + + // The parser stores options it doesn't recognize here. + // See the documentation for the "Options" section above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. + // See the documentation for the "Options" section above. + extensions 1000 to max; + + reserved 38; +} + +message MessageOptions { + // Set true to use the old proto1 MessageSet wire format for extensions. + // This is provided for backwards-compatibility with the MessageSet wire + // format. You should not use this for any other reason: It's less + // efficient, has fewer features, and is more complicated. + // + // The message must be defined exactly as follows: + // message Foo { + // option message_set_wire_format = true; + // extensions 4 to max; + // } + // Note that the message cannot have any defined fields; MessageSets only + // have extensions. + // + // All extensions of your type must be singular messages; e.g. they cannot + // be int32s, enums, or repeated messages. + // + // Because this is an option, the above two restrictions are not enforced by + // the protocol compiler. + optional bool message_set_wire_format = 1 [default = false]; + + // Disables the generation of the standard "descriptor()" accessor, which can + // conflict with a field of the same name. This is meant to make migration + // from proto1 easier; new code should avoid fields named "descriptor". + optional bool no_standard_descriptor_accessor = 2 [default = false]; + + // Is this message deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the message, or it will be completely ignored; in the very least, + // this is a formalization for deprecating messages. + optional bool deprecated = 3 [default = false]; + + reserved 4, 5, 6; + + // Whether the message is an automatically generated map entry type for the + // maps field. + // + // For maps fields: + // map map_field = 1; + // The parsed descriptor looks like: + // message MapFieldEntry { + // option map_entry = true; + // optional KeyType key = 1; + // optional ValueType value = 2; + // } + // repeated MapFieldEntry map_field = 1; + // + // Implementations may choose not to generate the map_entry=true message, but + // use a native map in the target language to hold the keys and values. + // The reflection APIs in such implementations still need to work as + // if the field is a repeated message field. + // + // NOTE: Do not set the option in .proto files. Always use the maps syntax + // instead. The option should only be implicitly set by the proto compiler + // parser. + optional bool map_entry = 7; + + reserved 8; // javalite_serializable + reserved 9; // javanano_as_lite + + // Enable the legacy handling of JSON field name conflicts. This lowercases + // and strips underscored from the fields before comparison in proto3 only. + // The new behavior takes `json_name` into account and applies to proto2 as + // well. + // + // This should only be used as a temporary measure against broken builds due + // to the change in behavior for JSON field name conflicts. + // + // TODO This is legacy behavior we plan to remove once downstream + // teams have had time to migrate. + optional bool deprecated_legacy_json_field_conflicts = 11 [deprecated = true]; + + // Any features defined in the specific edition. + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional FeatureSet features = 12; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message FieldOptions { + // NOTE: ctype is deprecated. Use `features.(pb.cpp).string_type` instead. + // The ctype option instructs the C++ code generator to use a different + // representation of the field than it normally would. See the specific + // options below. This option is only implemented to support use of + // [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of + // type "bytes" in the open source release. + // TODO: make ctype actually deprecated. + optional CType ctype = 1 [/*deprecated = true,*/ default = STRING]; + enum CType { + // Default mode. + STRING = 0; + + // The option [ctype=CORD] may be applied to a non-repeated field of type + // "bytes". It indicates that in C++, the data should be stored in a Cord + // instead of a string. For very large strings, this may reduce memory + // fragmentation. It may also allow better performance when parsing from a + // Cord, or when parsing with aliasing enabled, as the parsed Cord may then + // alias the original buffer. + CORD = 1; + + STRING_PIECE = 2; + } + // The packed option can be enabled for repeated primitive fields to enable + // a more efficient representation on the wire. Rather than repeatedly + // writing the tag and type for each element, the entire array is encoded as + // a single length-delimited blob. In proto3, only explicit setting it to + // false will avoid using packed encoding. This option is prohibited in + // Editions, but the `repeated_field_encoding` feature can be used to control + // the behavior. + optional bool packed = 2; + + // The jstype option determines the JavaScript type used for values of the + // field. The option is permitted only for 64 bit integral and fixed types + // (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING + // is represented as JavaScript string, which avoids loss of precision that + // can happen when a large value is converted to a floating point JavaScript. + // Specifying JS_NUMBER for the jstype causes the generated JavaScript code to + // use the JavaScript "number" type. The behavior of the default option + // JS_NORMAL is implementation dependent. + // + // This option is an enum to permit additional types to be added, e.g. + // goog.math.Integer. + optional JSType jstype = 6 [default = JS_NORMAL]; + enum JSType { + // Use the default type. + JS_NORMAL = 0; + + // Use JavaScript strings. + JS_STRING = 1; + + // Use JavaScript numbers. + JS_NUMBER = 2; + } + + // Should this field be parsed lazily? Lazy applies only to message-type + // fields. It means that when the outer message is initially parsed, the + // inner message's contents will not be parsed but instead stored in encoded + // form. The inner message will actually be parsed when it is first accessed. + // + // This is only a hint. Implementations are free to choose whether to use + // eager or lazy parsing regardless of the value of this option. However, + // setting this option true suggests that the protocol author believes that + // using lazy parsing on this field is worth the additional bookkeeping + // overhead typically needed to implement it. + // + // This option does not affect the public interface of any generated code; + // all method signatures remain the same. Furthermore, thread-safety of the + // interface is not affected by this option; const methods remain safe to + // call from multiple threads concurrently, while non-const methods continue + // to require exclusive access. + // + // Note that lazy message fields are still eagerly verified to check + // ill-formed wireformat or missing required fields. Calling IsInitialized() + // on the outer message would fail if the inner message has missing required + // fields. Failed verification would result in parsing failure (except when + // uninitialized messages are acceptable). + optional bool lazy = 5 [default = false]; + + // unverified_lazy does no correctness checks on the byte stream. This should + // only be used where lazy with verification is prohibitive for performance + // reasons. + optional bool unverified_lazy = 15 [default = false]; + + // Is this field deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for accessors, or it will be completely ignored; in the very least, this + // is a formalization for deprecating fields. + optional bool deprecated = 3 [default = false]; + + // DEPRECATED. DO NOT USE! + // For Google-internal migration only. Do not use. + optional bool weak = 10 [default = false, deprecated = true]; + + // Indicate that the field value should not be printed out when using debug + // formats, e.g. when the field contains sensitive credentials. + optional bool debug_redact = 16 [default = false]; + + // If set to RETENTION_SOURCE, the option will be omitted from the binary. + enum OptionRetention { + RETENTION_UNKNOWN = 0; + RETENTION_RUNTIME = 1; + RETENTION_SOURCE = 2; + } + + optional OptionRetention retention = 17; + + // This indicates the types of entities that the field may apply to when used + // as an option. If it is unset, then the field may be freely used as an + // option on any kind of entity. + enum OptionTargetType { + TARGET_TYPE_UNKNOWN = 0; + TARGET_TYPE_FILE = 1; + TARGET_TYPE_EXTENSION_RANGE = 2; + TARGET_TYPE_MESSAGE = 3; + TARGET_TYPE_FIELD = 4; + TARGET_TYPE_ONEOF = 5; + TARGET_TYPE_ENUM = 6; + TARGET_TYPE_ENUM_ENTRY = 7; + TARGET_TYPE_SERVICE = 8; + TARGET_TYPE_METHOD = 9; + } + + repeated OptionTargetType targets = 19; + + message EditionDefault { + optional Edition edition = 3; + optional string value = 2; // Textproto value. + } + repeated EditionDefault edition_defaults = 20; + + // Any features defined in the specific edition. + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional FeatureSet features = 21; + + // Information about the support window of a feature. + message FeatureSupport { + // The edition that this feature was first available in. In editions + // earlier than this one, the default assigned to EDITION_LEGACY will be + // used, and proto files will not be able to override it. + optional Edition edition_introduced = 1; + + // The edition this feature becomes deprecated in. Using this after this + // edition may trigger warnings. + optional Edition edition_deprecated = 2; + + // The deprecation warning text if this feature is used after the edition it + // was marked deprecated in. + optional string deprecation_warning = 3; + + // The edition this feature is no longer available in. In editions after + // this one, the last default assigned will be used, and proto files will + // not be able to override it. + optional Edition edition_removed = 4; + + // The removal error text if this feature is used after the edition it was + // removed in. + optional string removal_error = 5; + } + optional FeatureSupport feature_support = 22; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; + + reserved 4; // removed jtype + reserved 18; // reserve target, target_obsolete_do_not_use +} + +message OneofOptions { + // Any features defined in the specific edition. + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional FeatureSet features = 1; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message EnumOptions { + + // Set this option to true to allow mapping different tag names to the same + // value. + optional bool allow_alias = 2; + + // Is this enum deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the enum, or it will be completely ignored; in the very least, this + // is a formalization for deprecating enums. + optional bool deprecated = 3 [default = false]; + + reserved 5; // javanano_as_lite + + // Enable the legacy handling of JSON field name conflicts. This lowercases + // and strips underscored from the fields before comparison in proto3 only. + // The new behavior takes `json_name` into account and applies to proto2 as + // well. + // TODO Remove this legacy behavior once downstream teams have + // had time to migrate. + optional bool deprecated_legacy_json_field_conflicts = 6 [deprecated = true]; + + // Any features defined in the specific edition. + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional FeatureSet features = 7; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message EnumValueOptions { + // Is this enum value deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the enum value, or it will be completely ignored; in the very least, + // this is a formalization for deprecating enum values. + optional bool deprecated = 1 [default = false]; + + // Any features defined in the specific edition. + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional FeatureSet features = 2; + + // Indicate that fields annotated with this enum value should not be printed + // out when using debug formats, e.g. when the field contains sensitive + // credentials. + optional bool debug_redact = 3 [default = false]; + + // Information about the support window of a feature value. + optional FieldOptions.FeatureSupport feature_support = 4; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message ServiceOptions { + + // Any features defined in the specific edition. + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional FeatureSet features = 34; + + // Note: Field numbers 1 through 32 are reserved for Google's internal RPC + // framework. We apologize for hoarding these numbers to ourselves, but + // we were already using them long before we decided to release Protocol + // Buffers. + + // Is this service deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the service, or it will be completely ignored; in the very least, + // this is a formalization for deprecating services. + optional bool deprecated = 33 [default = false]; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +message MethodOptions { + + // Note: Field numbers 1 through 32 are reserved for Google's internal RPC + // framework. We apologize for hoarding these numbers to ourselves, but + // we were already using them long before we decided to release Protocol + // Buffers. + + // Is this method deprecated? + // Depending on the target platform, this can emit Deprecated annotations + // for the method, or it will be completely ignored; in the very least, + // this is a formalization for deprecating methods. + optional bool deprecated = 33 [default = false]; + + // Is this method side-effect-free (or safe in HTTP parlance), or idempotent, + // or neither? HTTP based RPC implementation may choose GET verb for safe + // methods, and PUT verb for idempotent methods instead of the default POST. + enum IdempotencyLevel { + IDEMPOTENCY_UNKNOWN = 0; + NO_SIDE_EFFECTS = 1; // implies idempotent + IDEMPOTENT = 2; // idempotent, but may have side effects + } + optional IdempotencyLevel idempotency_level = 34 + [default = IDEMPOTENCY_UNKNOWN]; + + // Any features defined in the specific edition. + // WARNING: This field should only be used by protobuf plugins or special + // cases like the proto compiler. Other uses are discouraged and + // developers should rely on the protoreflect APIs for their client language. + optional FeatureSet features = 35; + + // The parser stores options it doesn't recognize here. See above. + repeated UninterpretedOption uninterpreted_option = 999; + + // Clients can define custom options in extensions of this message. See above. + extensions 1000 to max; +} + +// A message representing a option the parser does not recognize. This only +// appears in options protos created by the compiler::Parser class. +// DescriptorPool resolves these when building Descriptor objects. Therefore, +// options protos in descriptor objects (e.g. returned by Descriptor::options(), +// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions +// in them. +message UninterpretedOption { + // The name of the uninterpreted option. Each string represents a segment in + // a dot-separated name. is_extension is true iff a segment represents an + // extension (denoted with parentheses in options specs in .proto files). + // E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents + // "foo.(bar.baz).moo". + message NamePart { + required string name_part = 1; + required bool is_extension = 2; + } + repeated NamePart name = 2; + + // The value of the uninterpreted option, in whatever type the tokenizer + // identified it as during parsing. Exactly one of these should be set. + optional string identifier_value = 3; + optional uint64 positive_int_value = 4; + optional int64 negative_int_value = 5; + optional double double_value = 6; + optional bytes string_value = 7; + optional string aggregate_value = 8; +} + +// =================================================================== +// Features + +// TODO Enums in C++ gencode (and potentially other languages) are +// not well scoped. This means that each of the feature enums below can clash +// with each other. The short names we've chosen maximize call-site +// readability, but leave us very open to this scenario. A future feature will +// be designed and implemented to handle this, hopefully before we ever hit a +// conflict here. +message FeatureSet { + enum FieldPresence { + FIELD_PRESENCE_UNKNOWN = 0; + EXPLICIT = 1; + IMPLICIT = 2; + LEGACY_REQUIRED = 3; + } + optional FieldPresence field_presence = 1 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "EXPLICIT" }, + edition_defaults = { edition: EDITION_PROTO3, value: "IMPLICIT" }, + edition_defaults = { edition: EDITION_2023, value: "EXPLICIT" } + ]; + + enum EnumType { + ENUM_TYPE_UNKNOWN = 0; + OPEN = 1; + CLOSED = 2; + } + optional EnumType enum_type = 2 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "CLOSED" }, + edition_defaults = { edition: EDITION_PROTO3, value: "OPEN" } + ]; + + enum RepeatedFieldEncoding { + REPEATED_FIELD_ENCODING_UNKNOWN = 0; + PACKED = 1; + EXPANDED = 2; + } + optional RepeatedFieldEncoding repeated_field_encoding = 3 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "EXPANDED" }, + edition_defaults = { edition: EDITION_PROTO3, value: "PACKED" } + ]; + + enum Utf8Validation { + UTF8_VALIDATION_UNKNOWN = 0; + VERIFY = 2; + NONE = 3; + reserved 1; + } + optional Utf8Validation utf8_validation = 4 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "NONE" }, + edition_defaults = { edition: EDITION_PROTO3, value: "VERIFY" } + ]; + + enum MessageEncoding { + MESSAGE_ENCODING_UNKNOWN = 0; + LENGTH_PREFIXED = 1; + DELIMITED = 2; + } + optional MessageEncoding message_encoding = 5 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "LENGTH_PREFIXED" } + ]; + + enum JsonFormat { + JSON_FORMAT_UNKNOWN = 0; + ALLOW = 1; + LEGACY_BEST_EFFORT = 2; + } + optional JsonFormat json_format = 6 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_MESSAGE, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "LEGACY_BEST_EFFORT" }, + edition_defaults = { edition: EDITION_PROTO3, value: "ALLOW" } + ]; + + enum EnforceNamingStyle { + ENFORCE_NAMING_STYLE_UNKNOWN = 0; + STYLE2024 = 1; + STYLE_LEGACY = 2; + } + optional EnforceNamingStyle enforce_naming_style = 7 [ + retention = RETENTION_SOURCE, + targets = TARGET_TYPE_FILE, + targets = TARGET_TYPE_EXTENSION_RANGE, + targets = TARGET_TYPE_MESSAGE, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_ONEOF, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_ENUM_ENTRY, + targets = TARGET_TYPE_SERVICE, + targets = TARGET_TYPE_METHOD, + feature_support = { + edition_introduced: EDITION_2024, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "STYLE_LEGACY" }, + edition_defaults = { edition: EDITION_2024, value: "STYLE2024" } + ]; + + message VisibilityFeature { + enum DefaultSymbolVisibility { + DEFAULT_SYMBOL_VISIBILITY_UNKNOWN = 0; + + // Default pre-EDITION_2024, all UNSET visibility are export. + EXPORT_ALL = 1; + + // All top-level symbols default to export, nested default to local. + EXPORT_TOP_LEVEL = 2; + + // All symbols default to local. + LOCAL_ALL = 3; + + // All symbols local by default. Nested types cannot be exported. + // With special case caveat for message { enum {} reserved 1 to max; } + // This is the recommended setting for new protos. + STRICT = 4; + } + reserved 1 to max; + } + optional VisibilityFeature.DefaultSymbolVisibility default_symbol_visibility = + 8 [ + retention = RETENTION_SOURCE, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2024, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "EXPORT_ALL" }, + edition_defaults = { edition: EDITION_2024, value: "EXPORT_TOP_LEVEL" } + ]; + + reserved 999; + + extensions 1000 to 9994 [ + declaration = { + number: 1000, + full_name: ".pb.cpp", + type: ".pb.CppFeatures" + }, + declaration = { + number: 1001, + full_name: ".pb.java", + type: ".pb.JavaFeatures" + }, + declaration = { number: 1002, full_name: ".pb.go", type: ".pb.GoFeatures" }, + declaration = { + number: 1003, + full_name: ".pb.python", + type: ".pb.PythonFeatures" + }, + declaration = { + number: 1100, + full_name: ".imp.impress_feature_set", + type: ".imp.ImpressFeatureSet" + }, + declaration = { + number: 9989, + full_name: ".pb.java_mutable", + type: ".pb.JavaMutableFeatures" + }, + declaration = { + number: 9990, + full_name: ".pb.proto1", + type: ".pb.Proto1Features" + } + ]; + + extensions 9995 to 9999; // For internal testing + extensions 10000; // for https://github.com/bufbuild/protobuf-es +} + +// A compiled specification for the defaults of a set of features. These +// messages are generated from FeatureSet extensions and can be used to seed +// feature resolution. The resolution with this object becomes a simple search +// for the closest matching edition, followed by proto merges. +message FeatureSetDefaults { + // A map from every known edition with a unique set of defaults to its + // defaults. Not all editions may be contained here. For a given edition, + // the defaults at the closest matching edition ordered at or before it should + // be used. This field must be in strict ascending order by edition. + message FeatureSetEditionDefault { + optional Edition edition = 3; + + // Defaults of features that can be overridden in this edition. + optional FeatureSet overridable_features = 4; + + // Defaults of features that can't be overridden in this edition. + optional FeatureSet fixed_features = 5; + + reserved 1, 2; + reserved "features"; + } + repeated FeatureSetEditionDefault defaults = 1; + + // The minimum supported edition (inclusive) when this was constructed. + // Editions before this will not have defaults. + optional Edition minimum_edition = 4; + + // The maximum known edition (inclusive) when this was constructed. Editions + // after this will not have reliable defaults. + optional Edition maximum_edition = 5; +} + +// =================================================================== +// Optional source code info + +// Encapsulates information about the original source file from which a +// FileDescriptorProto was generated. +message SourceCodeInfo { + // A Location identifies a piece of source code in a .proto file which + // corresponds to a particular definition. This information is intended + // to be useful to IDEs, code indexers, documentation generators, and similar + // tools. + // + // For example, say we have a file like: + // message Foo { + // optional string foo = 1; + // } + // Let's look at just the field definition: + // optional string foo = 1; + // ^ ^^ ^^ ^ ^^^ + // a bc de f ghi + // We have the following locations: + // span path represents + // [a,i) [ 4, 0, 2, 0 ] The whole field definition. + // [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). + // [c,d) [ 4, 0, 2, 0, 5 ] The type (string). + // [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). + // [g,h) [ 4, 0, 2, 0, 3 ] The number (1). + // + // Notes: + // - A location may refer to a repeated field itself (i.e. not to any + // particular index within it). This is used whenever a set of elements are + // logically enclosed in a single code segment. For example, an entire + // extend block (possibly containing multiple extension definitions) will + // have an outer location whose path refers to the "extensions" repeated + // field without an index. + // - Multiple locations may have the same path. This happens when a single + // logical declaration is spread out across multiple places. The most + // obvious example is the "extend" block again -- there may be multiple + // extend blocks in the same scope, each of which will have the same path. + // - A location's span is not always a subset of its parent's span. For + // example, the "extendee" of an extension declaration appears at the + // beginning of the "extend" block and is shared by all extensions within + // the block. + // - Just because a location's span is a subset of some other location's span + // does not mean that it is a descendant. For example, a "group" defines + // both a type and a field in a single declaration. Thus, the locations + // corresponding to the type and field and their components will overlap. + // - Code which tries to interpret locations should probably be designed to + // ignore those that it doesn't understand, as more types of locations could + // be recorded in the future. + repeated Location location = 1; + message Location { + // Identifies which part of the FileDescriptorProto was defined at this + // location. + // + // Each element is a field number or an index. They form a path from + // the root FileDescriptorProto to the place where the definition appears. + // For example, this path: + // [ 4, 3, 2, 7, 1 ] + // refers to: + // file.message_type(3) // 4, 3 + // .field(7) // 2, 7 + // .name() // 1 + // This is because FileDescriptorProto.message_type has field number 4: + // repeated DescriptorProto message_type = 4; + // and DescriptorProto.field has field number 2: + // repeated FieldDescriptorProto field = 2; + // and FieldDescriptorProto.name has field number 1: + // optional string name = 1; + // + // Thus, the above path gives the location of a field name. If we removed + // the last element: + // [ 4, 3, 2, 7 ] + // this path refers to the whole field declaration (from the beginning + // of the label to the terminating semicolon). + repeated int32 path = 1 [packed = true]; + + // Always has exactly three or four elements: start line, start column, + // end line (optional, otherwise assumed same as start line), end column. + // These are packed into a single field for efficiency. Note that line + // and column numbers are zero-based -- typically you will want to add + // 1 to each before displaying to a user. + repeated int32 span = 2 [packed = true]; + + // If this SourceCodeInfo represents a complete declaration, these are any + // comments appearing before and after the declaration which appear to be + // attached to the declaration. + // + // A series of line comments appearing on consecutive lines, with no other + // tokens appearing on those lines, will be treated as a single comment. + // + // leading_detached_comments will keep paragraphs of comments that appear + // before (but not connected to) the current element. Each paragraph, + // separated by empty lines, will be one comment element in the repeated + // field. + // + // Only the comment content is provided; comment markers (e.g. //) are + // stripped out. For block comments, leading whitespace and an asterisk + // will be stripped from the beginning of each line other than the first. + // Newlines are included in the output. + // + // Examples: + // + // optional int32 foo = 1; // Comment attached to foo. + // // Comment attached to bar. + // optional int32 bar = 2; + // + // optional string baz = 3; + // // Comment attached to baz. + // // Another line attached to baz. + // + // // Comment attached to moo. + // // + // // Another line attached to moo. + // optional double moo = 4; + // + // // Detached comment for corge. This is not leading or trailing comments + // // to moo or corge because there are blank lines separating it from + // // both. + // + // // Detached comment for corge paragraph 2. + // + // optional string corge = 5; + // /* Block comment attached + // * to corge. Leading asterisks + // * will be removed. */ + // /* Block comment attached to + // * grault. */ + // optional int32 grault = 6; + // + // // ignored detached comments. + optional string leading_comments = 3; + optional string trailing_comments = 4; + repeated string leading_detached_comments = 6; + } + + // Extensions for tooling. + extensions 536000000 [declaration = { + number: 536000000 + type: ".buf.descriptor.v1.SourceCodeInfoExtension" + full_name: ".buf.descriptor.v1.buf_source_code_info_extension" + }]; +} + +// Describes the relationship between generated code and its original source +// file. A GeneratedCodeInfo message is associated with only one generated +// source file, but may contain references to different source .proto files. +message GeneratedCodeInfo { + // An Annotation connects some span of text in generated code to an element + // of its generating .proto file. + repeated Annotation annotation = 1; + message Annotation { + // Identifies the element in the original source .proto file. This field + // is formatted the same as SourceCodeInfo.Location.path. + repeated int32 path = 1 [packed = true]; + + // Identifies the filesystem path to the original source .proto. + optional string source_file = 2; + + // Identifies the starting offset in bytes in the generated code + // that relates to the identified object. + optional int32 begin = 3; + + // Identifies the ending offset in bytes in the generated code that + // relates to the identified object. The end offset should be one past + // the last relevant byte (so the length of the text = end - begin). + optional int32 end = 4; + + // Represents the identified object's effect on the element in the original + // .proto file. + enum Semantic { + // There is no effect or the effect is indescribable. + NONE = 0; + // The element is set or otherwise mutated. + SET = 1; + // An alias to the element is returned. + ALIAS = 2; + } + optional Semantic semantic = 5; + } +} + +// Describes the 'visibility' of a symbol with respect to the proto import +// system. Symbols can only be imported when the visibility rules do not prevent +// it (ex: local symbols cannot be imported). Visibility modifiers can only set +// on `message` and `enum` as they are the only types available to be referenced +// from other files. +enum SymbolVisibility { + VISIBILITY_UNSET = 0; + VISIBILITY_LOCAL = 1; + VISIBILITY_EXPORT = 2; +} diff --git a/Protos/upstream/google/protobuf/duration.proto b/Protos/upstream/google/protobuf/duration.proto new file mode 100644 index 000000000..41f40c222 --- /dev/null +++ b/Protos/upstream/google/protobuf/duration.proto @@ -0,0 +1,115 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +syntax = "proto3"; + +package google.protobuf; + +option cc_enable_arenas = true; +option go_package = "google.golang.org/protobuf/types/known/durationpb"; +option java_package = "com.google.protobuf"; +option java_outer_classname = "DurationProto"; +option java_multiple_files = true; +option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; + +// A Duration represents a signed, fixed-length span of time represented +// as a count of seconds and fractions of seconds at nanosecond +// resolution. It is independent of any calendar and concepts like "day" +// or "month". It is related to Timestamp in that the difference between +// two Timestamp values is a Duration and it can be added or subtracted +// from a Timestamp. Range is approximately +-10,000 years. +// +// # Examples +// +// Example 1: Compute Duration from two Timestamps in pseudo code. +// +// Timestamp start = ...; +// Timestamp end = ...; +// Duration duration = ...; +// +// duration.seconds = end.seconds - start.seconds; +// duration.nanos = end.nanos - start.nanos; +// +// if (duration.seconds < 0 && duration.nanos > 0) { +// duration.seconds += 1; +// duration.nanos -= 1000000000; +// } else if (duration.seconds > 0 && duration.nanos < 0) { +// duration.seconds -= 1; +// duration.nanos += 1000000000; +// } +// +// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. +// +// Timestamp start = ...; +// Duration duration = ...; +// Timestamp end = ...; +// +// end.seconds = start.seconds + duration.seconds; +// end.nanos = start.nanos + duration.nanos; +// +// if (end.nanos < 0) { +// end.seconds -= 1; +// end.nanos += 1000000000; +// } else if (end.nanos >= 1000000000) { +// end.seconds += 1; +// end.nanos -= 1000000000; +// } +// +// Example 3: Compute Duration from datetime.timedelta in Python. +// +// td = datetime.timedelta(days=3, minutes=10) +// duration = Duration() +// duration.FromTimedelta(td) +// +// # JSON Mapping +// +// In JSON format, the Duration type is encoded as a string rather than an +// object, where the string ends in the suffix "s" (indicating seconds) and +// is preceded by the number of seconds, with nanoseconds expressed as +// fractional seconds. For example, 3 seconds with 0 nanoseconds should be +// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should +// be expressed in JSON format as "3.000000001s", and 3 seconds and 1 +// microsecond should be expressed in JSON format as "3.000001s". +// +message Duration { + // Signed seconds of the span of time. Must be from -315,576,000,000 + // to +315,576,000,000 inclusive. Note: these bounds are computed from: + // 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years + int64 seconds = 1; + + // Signed fractions of a second at nanosecond resolution of the span + // of time. Durations less than one second are represented with a 0 + // `seconds` field and a positive or negative `nanos` field. For durations + // of one second or more, a non-zero value for the `nanos` field must be + // of the same sign as the `seconds` field. Must be from -999,999,999 + // to +999,999,999 inclusive. + int32 nanos = 2; +} diff --git a/Protos/upstream/google/protobuf/edition_unittest.proto b/Protos/upstream/google/protobuf/edition_unittest.proto new file mode 100644 index 000000000..fab6b2f9f --- /dev/null +++ b/Protos/upstream/google/protobuf/edition_unittest.proto @@ -0,0 +1,1955 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// A proto file we will use for unit testing. See comments in +// edition_message_unittest.cc before adding new features. +// +// LINT: ALLOW_GROUPS, LEGACY_NAMES + +edition = "2024"; + +import "google/protobuf/unittest_import.proto"; + +import option "google/protobuf/cpp_features.proto"; + +option features.field_presence = EXPLICIT; +option features.enum_type = CLOSED; + +// Some generic_services option(s) added automatically. +// See: http://go/proto2-generic-services-default +option cc_generic_services = true; // auto-added +option java_generic_services = true; // auto-added +option py_generic_services = true; // auto-added +option cc_enable_arenas = true; + +// We don't put this in a package within proto2 because we need to make sure +// that the generated code doesn't depend on being in the proto2 namespace. +// In test_util.h we do "using namespace unittest = edition_unittest". +package edition_unittest; + +// Protos optimized for SPEED use a strict superset of the generated code +// of equivalent ones optimized for CODE_SIZE, so we should optimize all our +// tests for speed unless explicitly testing code size optimization. +option optimize_for = SPEED; + +// This proto includes every type of field in both singular and repeated +// forms. +message TestAllTypes { + message NestedMessage { + // The field name "b" fails to compile in proto1 because it conflicts with + // a local variable named "b" in one of the generated methods. Doh. + // This file needs to compile in proto1 to test backwards-compatibility. + int32 bb = 1; + } + + enum NestedEnum { + FOO = 1; + BAR = 2; + BAZ = 3; + NEG = -1; // Intentionally negative. + } + + // Singular + int32 optional_int32 = 1; + int64 optional_int64 = 2; + uint32 optional_uint32 = 3; + uint64 optional_uint64 = 4; + sint32 optional_sint32 = 5; + sint64 optional_sint64 = 6; + fixed32 optional_fixed32 = 7; + fixed64 optional_fixed64 = 8; + sfixed32 optional_sfixed32 = 9; + sfixed64 optional_sfixed64 = 10; + float optional_float = 11; + double optional_double = 12; + bool optional_bool = 13; + string optional_string = 14; + bytes optional_bytes = 15; + + message OptionalGroup { + int32 a = 17; + } + OptionalGroup optionalgroup = 16 + [features.message_encoding = DELIMITED]; + + NestedMessage optional_nested_message = 18; + ForeignMessage optional_foreign_message = 19; + proto2_unittest_import.ImportMessage optional_import_message = 20; + + NestedEnum optional_nested_enum = 21; + ForeignEnum optional_foreign_enum = 22; + proto2_unittest_import.ImportEnum optional_import_enum = 23; + + string optional_string_piece = 24; + string optional_cord = 25 [features.(pb.cpp).string_type=CORD]; + bytes optional_bytes_cord = 86 [features.(pb.cpp).string_type=CORD]; + + // Defined in unittest_import_public.proto + proto2_unittest_import.PublicImportMessage + optional_public_import_message = 26; + + NestedMessage optional_lazy_message = 27 [lazy=true]; + NestedMessage optional_unverified_lazy_message = 28 [unverified_lazy=true]; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + + message RepeatedGroup { + int32 a = 47; + } + repeated RepeatedGroup repeatedgroup = 46 + [features.message_encoding = DELIMITED]; + + repeated NestedMessage repeated_nested_message = 48; + repeated ForeignMessage repeated_foreign_message = 49; + repeated proto2_unittest_import.ImportMessage repeated_import_message = 50; + + repeated NestedEnum repeated_nested_enum = 51; + repeated ForeignEnum repeated_foreign_enum = 52; + repeated proto2_unittest_import.ImportEnum repeated_import_enum = 53; + + repeated string repeated_string_piece = 54; + repeated string repeated_cord = 55 [features.(pb.cpp).string_type=CORD]; + + repeated NestedMessage repeated_lazy_message = 57 ; + + // Singular with defaults + int32 default_int32 = 61 [default = 41 ]; + int64 default_int64 = 62 [default = 42 ]; + uint32 default_uint32 = 63 [default = 43 ]; + uint64 default_uint64 = 64 [default = 44 ]; + sint32 default_sint32 = 65 [default = -45 ]; + sint64 default_sint64 = 66 [default = 46 ]; + fixed32 default_fixed32 = 67 [default = 47 ]; + fixed64 default_fixed64 = 68 [default = 48 ]; + sfixed32 default_sfixed32 = 69 [default = 49 ]; + sfixed64 default_sfixed64 = 70 [default = -50 ]; + float default_float = 71 [default = 51.5 ]; + double default_double = 72 [default = 52e3 ]; + bool default_bool = 73 [default = true ]; + string default_string = 74 [default = "hello"]; + bytes default_bytes = 75 [default = "world"]; + + NestedEnum default_nested_enum = 81 [default = BAR ]; + ForeignEnum default_foreign_enum = 82 [default = FOREIGN_BAR]; + proto2_unittest_import.ImportEnum + default_import_enum = 83 [default = IMPORT_BAR]; + + string default_string_piece = 84 [default="abc"]; + string default_cord = 85 [features.(pb.cpp).string_type=CORD,default="123"]; + + // For oneof test + oneof oneof_field { + uint32 oneof_uint32 = 111; + NestedMessage oneof_nested_message = 112; + string oneof_string = 113; + bytes oneof_bytes = 114; + string oneof_cord = 115 [features.(pb.cpp).string_type=CORD]; + string oneof_string_piece = 116; + NestedMessage oneof_lazy_nested_message = 117 [lazy=true]; + } +} + +// This proto includes a recursively nested message. +message NestedTestAllTypes { + NestedTestAllTypes child = 1; + TestAllTypes payload = 2; + repeated NestedTestAllTypes repeated_child = 3; + NestedTestAllTypes lazy_child = 4 [lazy=true]; + TestAllTypes eager_child = 5 [lazy=false]; +} + +message TestDeprecatedFields { + int32 deprecated_int32 = 1 [deprecated=true]; + repeated string deprecated_repeated_string = 4 [deprecated=true]; + TestAllTypes.NestedMessage deprecated_message = 3 [deprecated=true]; + oneof oneof_fields { + int32 deprecated_int32_in_oneof = 2 [deprecated=true]; + } + TestDeprecatedFields nested = 5; +} + +message TestDeprecatedMessage { + option deprecated = true; +} + +// Define these after TestAllTypes to make sure the compiler can handle that. +message ForeignMessage { + int32 c = 1; + int32 d = 2; +} + +enum ForeignEnum { + FOREIGN_FOO = 4; + FOREIGN_BAR = 5; + FOREIGN_BAZ = 6; + FOREIGN_BAX = 32; // (1 << 32) to generate a 64b bitmask would be incorrect. +} + +message TestReservedFields { + reserved 2, 15, 9 to 11; + reserved bar, baz; +} + +enum TestReservedEnumFields { + UNKNOWN = 0; + reserved 2, 15, 9 to 11; + reserved bar, baz; +} + +message TestAllExtensions { + extensions 1 to max; +} + +message OptionalGroup_extension { + option features.enforce_naming_style = STYLE_LEGACY; + + int32 a = 17; +} + +message RepeatedGroup_extension { + option features.enforce_naming_style = STYLE_LEGACY; + + int32 a = 47; +} + +extend TestAllExtensions { + // Singular + int32 optional_int32_extension = 1; + int64 optional_int64_extension = 2; + uint32 optional_uint32_extension = 3; + uint64 optional_uint64_extension = 4; + sint32 optional_sint32_extension = 5; + sint64 optional_sint64_extension = 6; + fixed32 optional_fixed32_extension = 7; + fixed64 optional_fixed64_extension = 8; + sfixed32 optional_sfixed32_extension = 9; + sfixed64 optional_sfixed64_extension = 10; + float optional_float_extension = 11; + double optional_double_extension = 12; + bool optional_bool_extension = 13; + string optional_string_extension = 14; + bytes optional_bytes_extension = 15; + + OptionalGroup_extension optionalgroup_extension = 16 + [features.message_encoding = DELIMITED]; + + TestAllTypes.NestedMessage optional_nested_message_extension = 18; + ForeignMessage optional_foreign_message_extension = 19; + proto2_unittest_import.ImportMessage + optional_import_message_extension = 20; + + TestAllTypes.NestedEnum optional_nested_enum_extension = 21; + ForeignEnum optional_foreign_enum_extension = 22; + proto2_unittest_import.ImportEnum + optional_import_enum_extension = 23; + + string optional_string_piece_extension = 24; + // TODO: ctype=CORD is not supported for extension. Add + // ctype=CORD option back after it is supported. + string optional_cord_extension = 25; + bytes optional_bytes_cord_extension = 86; + + proto2_unittest_import.PublicImportMessage + optional_public_import_message_extension = 26; + + TestAllTypes.NestedMessage + optional_lazy_message_extension = 27 [lazy=true]; + TestAllTypes.NestedMessage + optional_unverified_lazy_message_extension = 28 [unverified_lazy=true]; + + // Repeated + repeated int32 repeated_int32_extension = 31; + repeated int64 repeated_int64_extension = 32; + repeated uint32 repeated_uint32_extension = 33; + repeated uint64 repeated_uint64_extension = 34; + repeated sint32 repeated_sint32_extension = 35; + repeated sint64 repeated_sint64_extension = 36; + repeated fixed32 repeated_fixed32_extension = 37; + repeated fixed64 repeated_fixed64_extension = 38; + repeated sfixed32 repeated_sfixed32_extension = 39; + repeated sfixed64 repeated_sfixed64_extension = 40; + repeated float repeated_float_extension = 41; + repeated double repeated_double_extension = 42; + repeated bool repeated_bool_extension = 43; + repeated string repeated_string_extension = 44; + repeated bytes repeated_bytes_extension = 45; + + repeated RepeatedGroup_extension repeatedgroup_extension = 46 + [features.message_encoding = DELIMITED]; + + repeated TestAllTypes.NestedMessage repeated_nested_message_extension = 48; + repeated ForeignMessage repeated_foreign_message_extension = 49; + repeated proto2_unittest_import.ImportMessage + repeated_import_message_extension = 50; + + repeated TestAllTypes.NestedEnum repeated_nested_enum_extension = 51; + repeated ForeignEnum repeated_foreign_enum_extension = 52; + repeated proto2_unittest_import.ImportEnum + repeated_import_enum_extension = 53; + + repeated string repeated_string_piece_extension = 54; + // TODO: ctype=CORD is not supported for extension. Add + // ctype=CORD option back after it is supported. + repeated string repeated_cord_extension = 55; + + repeated TestAllTypes.NestedMessage + repeated_lazy_message_extension = 57 [lazy=true]; + + // Singular with defaults + int32 default_int32_extension = 61 [default = 41 ]; + int64 default_int64_extension = 62 [default = 42 ]; + uint32 default_uint32_extension = 63 [default = 43 ]; + uint64 default_uint64_extension = 64 [default = 44 ]; + sint32 default_sint32_extension = 65 [default = -45 ]; + sint64 default_sint64_extension = 66 [default = 46 ]; + fixed32 default_fixed32_extension = 67 [default = 47 ]; + fixed64 default_fixed64_extension = 68 [default = 48 ]; + sfixed32 default_sfixed32_extension = 69 [default = 49 ]; + sfixed64 default_sfixed64_extension = 70 [default = -50 ]; + float default_float_extension = 71 [default = 51.5 ]; + double default_double_extension = 72 [default = 52e3 ]; + bool default_bool_extension = 73 [default = true ]; + string default_string_extension = 74 [default = "hello"]; + bytes default_bytes_extension = 75 [default = "world"]; + + TestAllTypes.NestedEnum + default_nested_enum_extension = 81 [default = BAR]; + ForeignEnum + default_foreign_enum_extension = 82 [default = FOREIGN_BAR]; + proto2_unittest_import.ImportEnum + default_import_enum_extension = 83 [default = IMPORT_BAR]; + + string default_string_piece_extension = 84 [default="abc"]; + // TODO: ctype=CORD is not supported for extension. Add + // ctype=CORD option back after it is supported. + string default_cord_extension = 85 [default="123"]; + + // For oneof test + uint32 oneof_uint32_extension = 111; + TestAllTypes.NestedMessage oneof_nested_message_extension = 112; + string oneof_string_extension = 113; + bytes oneof_bytes_extension = 114; +} + +message TestMixedFieldsAndExtensions { + int32 a = 1; + repeated fixed32 b = 3; + extensions 2, 4; + extend TestMixedFieldsAndExtensions { + int32 c = 2; + repeated fixed32 d = 4; + } +} + +message TestGroup { + message OptionalGroup { + int32 a = 17; + int32 zz = 89; // fast table size must be at least 16, for this + // field to be parsed by the fast parser, since + // 89 - 17 = 72 is a multiple of 8. + } + OptionalGroup optionalgroup = 16 [features.message_encoding = DELIMITED]; + ForeignEnum optional_foreign_enum = 22; +} + +message TestGroupExtension { + extensions 1 to max; +} + +message TestNestedExtension { + extend TestAllExtensions { + // Check for bug where string extensions declared in tested scope did not + // compile. + string test = 1002 [default="test"]; + // Used to test if generated extension name is correct when there are + // underscores. + string nested_string_extension = 1003; + } + + message OptionalGroup_extension { + option features.enforce_naming_style = STYLE_LEGACY; + + int32 a = 17; + } + + extend TestGroupExtension { + OptionalGroup_extension optionalgroup_extension = 16 + [features.message_encoding = DELIMITED]; + ForeignEnum optional_foreign_enum_extension = 22; + } +} + +message TestChildExtension { + string a = 1; + string b = 2; + TestAllExtensions optional_extension = 3; +} + +// Emulates wireformat data of TestChildExtension with dynamic extension +// (DynamicExtension). +message TestChildExtensionData { + message NestedTestAllExtensionsData { + message NestedDynamicExtensions { + int32 a = 1; + int32 b = 2; + } + NestedDynamicExtensions dynamic = 409707008; + } + string a = 1; + string b = 2; + NestedTestAllExtensionsData optional_extension = 3; +} + +message TestNestedChildExtension { + int32 a = 1; + TestChildExtension child = 2; +} + +// Emulates wireformat data of TestNestedChildExtension with dynamic extension +// (DynamicExtension). +message TestNestedChildExtensionData { + int32 a = 1; + TestChildExtensionData child = 2; +} + +// Required and closed enum fields are considered unknown fields if the value is +// not valid. We need to make sure it functions as expected. +message TestRequiredEnum { + ForeignEnum required_enum = 1 [features.field_presence = LEGACY_REQUIRED]; + + // A dummy optional field. + int32 a = 2; +} + +// TestRequiredEnum + using enum values that won't fit to 64 bitmask. +message TestRequiredEnumNoMask { + enum NestedEnum { + UNSPECIFIED = 0; + FOO = 2; + BAR = 100; + BAZ = -1; // Intentionally negative. + } + + NestedEnum required_enum = 1 [features.field_presence = LEGACY_REQUIRED]; + + // A dummy optional field. + int32 a = 2; +} + +message TestRequiredEnumMulti { + enum NestedEnum { + UNSPECIFIED = 0; + FOO = 1; + BAR = 2; + BAZ = 100; + } + option features.enforce_naming_style = STYLE_LEGACY; + + // Intentionally placed in descending field number to force sorting in closed + // enum verification. + NestedEnum required_enum_4 = 4 [features.field_presence = LEGACY_REQUIRED]; + int32 a_3 = 3; + NestedEnum required_enum_2 = 2 [features.field_presence = LEGACY_REQUIRED]; + ForeignEnum required_enum_1 = 1 [features.field_presence = LEGACY_REQUIRED]; +} + +message TestRequiredNoMaskMulti { + enum NestedEnum { + UNSPECIFIED = 0; + FOO = 1; + BAR = 2; + BAZ = 100; + } + option features.enforce_naming_style = STYLE_LEGACY; + + // Intentionally placed in descending field number to force sorting in closed + // enum verification. Also, using large field numbers to use tag only + // matching for fields. + fixed32 required_fixed32_80 = 80 [features.field_presence = LEGACY_REQUIRED]; + fixed32 required_fixed32_70 = 70 [features.field_presence = LEGACY_REQUIRED]; + + NestedEnum required_enum_64 = 64 [features.field_presence = LEGACY_REQUIRED]; + NestedEnum required_enum_4 = 4 [features.field_presence = LEGACY_REQUIRED]; + int32 a_3 = 3; + NestedEnum required_enum_2 = 2 [features.field_presence = LEGACY_REQUIRED]; + ForeignEnum required_enum_1 = 1 [features.field_presence = LEGACY_REQUIRED]; +} + +// We have separate messages for testing fields because it's +// annoying to have to fill in fields in TestProto in order to +// do anything with it. Note that we don't need to test every type of +// filed because the code output is basically identical to +// optional fields for all types. +message TestRequired { + int32 a = 1 [features.field_presence = LEGACY_REQUIRED]; + int32 dummy2 = 2; + int32 b = 3 [features.field_presence = LEGACY_REQUIRED]; + + extend TestAllExtensions { + TestRequired single = 1000; + repeated TestRequired multi = 1001; + } + + // Pad the field count to 32 so that we can test that IsInitialized() + // properly checks multiple elements of has_bits_. + int32 dummy4 = 4; + int32 dummy5 = 5; + int32 dummy6 = 6; + int32 dummy7 = 7; + int32 dummy8 = 8; + int32 dummy9 = 9; + int32 dummy10 = 10; + int32 dummy11 = 11; + int32 dummy12 = 12; + int32 dummy13 = 13; + int32 dummy14 = 14; + int32 dummy15 = 15; + int32 dummy16 = 16; + int32 dummy17 = 17; + int32 dummy18 = 18; + int32 dummy19 = 19; + int32 dummy20 = 20; + int32 dummy21 = 21; + int32 dummy22 = 22; + int32 dummy23 = 23; + int32 dummy24 = 24; + int32 dummy25 = 25; + int32 dummy26 = 26; + int32 dummy27 = 27; + int32 dummy28 = 28; + int32 dummy29 = 29; + int32 dummy30 = 30; + int32 dummy31 = 31; + int32 dummy32 = 32; + + int32 c = 33 [features.field_presence = LEGACY_REQUIRED]; + + // Add an optional child message to make this non-trivial for go/pdlazy. + ForeignMessage optional_foreign = 34; +} + +message TestRequiredForeign { + TestRequired optional_message = 1; + repeated TestRequired repeated_message = 2; + int32 dummy = 3; + + // Missing fields must not affect verification of child messages. + NestedTestAllTypes optional_lazy_message = 4 [lazy = true]; +} + +message TestRequiredMessage { + TestRequired optional_message = 1; + repeated TestRequired repeated_message = 2; + TestRequired required_message = 3 [features.field_presence = LEGACY_REQUIRED]; +} + +message TestNestedRequiredForeign { + TestNestedRequiredForeign child = 1; + TestRequiredForeign payload = 2; + int32 dummy = 3; + // optional message to test closed enum. + TestRequiredEnum required_enum = 5; + TestRequiredEnumNoMask required_enum_no_mask = 6; + TestRequiredEnumMulti required_enum_multi = 7; + TestRequiredNoMaskMulti required_no_mask = 9; +} + +// Test that we can use NestedMessage from outside TestAllTypes. +message TestForeignNested { + TestAllTypes.NestedMessage foreign_nested = 1; +} + +// TestEmptyMessage is used to test unknown field support. +message TestEmptyMessage { +} + +// Like above, but declare all field numbers as potential extensions. No +// actual extensions should ever be defined for this type. +message TestEmptyMessageWithExtensions { + extensions 1 to max; +} + +// Needed for a Python test. +message TestPickleNestedMessage { + message NestedMessage { + int32 bb = 1; + message NestedNestedMessage { + int32 cc = 1; + } + } +} + +message TestMultipleExtensionRanges { + extensions 42; + extensions 4143 to 4243; + extensions 65536 to max; +} + +// Test that really large tag numbers don't break anything. +message TestReallyLargeTagNumber { + // The largest possible tag number is 2^28 - 1, since the wire format uses + // three bits to communicate wire type. + int32 a = 1; + int32 bb = 268435455; +} + +message TestRecursiveMessage { + TestRecursiveMessage a = 1; + int32 i = 2; +} + +// Test that mutual recursion works. +message TestMutualRecursionA { + message SubMessage { + TestMutualRecursionB b = 1; + } + TestMutualRecursionB bb = 1; + message SubGroup { + SubMessage sub_message = 3; // Needed because of bug in javatest + TestAllTypes not_in_this_scc = 4; + } + SubGroup subgroup = 2 [features.message_encoding = DELIMITED]; + message SubGroupR { + TestAllTypes payload = 6; + } + repeated SubGroupR subgroupr = 5 [features.message_encoding = DELIMITED]; +} + +message TestMutualRecursionB { + TestMutualRecursionA a = 1; + int32 optional_int32 = 2; +} + +message TestIsInitialized { + message SubMessage { + message SubGroup { + int32 i = 2 [features.field_presence = LEGACY_REQUIRED]; + } + SubGroup subgroup = 1 [features.message_encoding = DELIMITED]; + } + SubMessage sub_message = 1; +} + +// Test that groups have disjoint field numbers from their siblings and +// parents. This is NOT possible in proto1; only google.protobuf. When attempting +// to compile with proto1, this will emit an error; so we only include it +// in proto2_unittest_proto. +message TestDupFieldNumber { // NO_PROTO1 + int32 a = 1; // NO_PROTO1 + message Foo { int32 a = 1; } // NO_PROTO1 + message Bar { int32 a = 1; } // NO_PROTO1 + Foo foo = 2 [features.message_encoding = DELIMITED]; + Bar bar = 3 [features.message_encoding = DELIMITED]; +} // NO_PROTO1 + +// Additional messages for testing lazy fields. +message TestEagerMessage { + TestAllTypes sub_message = 1 [lazy=false]; +} +message TestLazyMessage { + TestAllTypes sub_message = 1 [lazy=true]; +} +message TestLazyMessageRepeated { + repeated TestLazyMessage repeated_message = 1; +} +message TestEagerMaybeLazy { + message NestedMessage { + TestPackedTypes packed = 1; + } + TestAllTypes message_foo = 1; + TestAllTypes message_bar = 2; + NestedMessage message_baz = 3; +} +// Needed for a Python test. +message TestNestedMessageHasBits { + message NestedMessage { + repeated int32 nestedmessage_repeated_int32 = 1; + repeated ForeignMessage nestedmessage_repeated_foreignmessage = 2; + } + NestedMessage optional_nested_message = 1; +} + + +// Test an enum that has multiple values with the same number. +enum TestEnumWithDupValue { + option allow_alias = true; + + DUP_UNKNOWN1 = 0; + DUP_FOO1 = 1; + DUP_BAR1 = 2; + DUP_BAZ = 3; + DUP_UNKNOWN2 = 0; + DUP_FOO2 = 1; + DUP_BAR2 = 2; +} + +// Test an enum with large, unordered values. +enum TestSparseEnum { + SPARSE_A = 123; + SPARSE_B = 62374; + SPARSE_C = 12589234; + SPARSE_D = -15; + SPARSE_E = -53452; + SPARSE_F = 0; + SPARSE_G = 2; +} + +// Test message with CamelCase field names. This violates Protocol Buffer +// standard style. +message TestCamelCaseFieldNames { + option features.enforce_naming_style = STYLE_LEGACY; + + int32 PrimitiveField = 1; + string StringField = 2; + ForeignEnum EnumField = 3; + ForeignMessage MessageField = 4; + string StringPieceField = 5; + string CordField = 6 [features.(pb.cpp).string_type=CORD]; + + repeated int32 RepeatedPrimitiveField = 7; + repeated string RepeatedStringField = 8; + repeated ForeignEnum RepeatedEnumField = 9; + repeated ForeignMessage RepeatedMessageField = 10; + repeated string RepeatedStringPieceField = 11; + repeated string RepeatedCordField = 12 [features.(pb.cpp).string_type=CORD]; +} + + +// We list fields out of order, to ensure that we're using field number and not +// field index to determine serialization order. +message TestFieldOrderings { + string my_string = 11; + extensions 2 to 10; + int64 my_int = 1; + extensions 12 to 100; + float my_float = 101; + message NestedMessage { + int64 oo = 2; + // The field name "b" fails to compile in proto1 because it conflicts with + // a local variable named "b" in one of the generated methods. Doh. + // This file needs to compile in proto1 to test backwards-compatibility. + int32 bb = 1; + } + + NestedMessage optional_nested_message = 200; +} + +extend TestFieldOrderings { + string my_extension_string = 50; + int32 my_extension_int = 5; +} + +message TestExtensionOrderings1 { + extend TestFieldOrderings { + TestExtensionOrderings1 test_ext_orderings1 = 13; + } + string my_string = 1; +} + +message TestExtensionOrderings2 { + extend TestFieldOrderings { + TestExtensionOrderings2 test_ext_orderings2 = 12; + } + message TestExtensionOrderings3 { + extend TestFieldOrderings { + TestExtensionOrderings3 test_ext_orderings3 = 14; + } + string my_string = 1; + } + string my_string = 1; +} + +message TestExtremeDefaultValues { + bytes escaped_bytes = 1 [default = "\0\001\a\b\f\n\r\t\v\\\'\"\xfe"]; + uint32 large_uint32 = 2 [default = 0xFFFFFFFF]; + uint64 large_uint64 = 3 [default = 0xFFFFFFFFFFFFFFFF]; + int32 small_int32 = 4 [default = -0x7FFFFFFF]; + int64 small_int64 = 5 [default = -0x7FFFFFFFFFFFFFFF]; + int32 really_small_int32 = 21 [default = -0x80000000]; + int64 really_small_int64 = 22 [default = -0x8000000000000000]; + + // The default value here is UTF-8 for "\u1234". (We could also just type + // the UTF-8 text directly into this text file rather than escape it, but + // lots of people use editors that would be confused by this.) + string utf8_string = 6 [default = "\341\210\264"]; + + // Tests for single-precision floating-point values. + float zero_float = 7 [default = 0]; + float one_float = 8 [default = 1]; + float small_float = 9 [default = 1.5]; + float negative_one_float = 10 [default = -1]; + float negative_float = 11 [default = -1.5]; + // Using exponents + float large_float = 12 [default = 2E8]; + float small_negative_float = 13 [default = -8e-28]; + + // Text for nonfinite floating-point values. + double inf_double = 14 [default = inf]; + double neg_inf_double = 15 [default = -inf]; + double nan_double = 16 [default = nan]; + float inf_float = 17 [default = inf]; + float neg_inf_float = 18 [default = -inf]; + float nan_float = 19 [default = nan]; + + // Tests for C++ trigraphs. + // Trigraphs should be escaped in C++ generated files, but they should not be + // escaped for other languages. + // Note that in .proto file, "\?" is a valid way to escape ? in string + // literals. + string cpp_trigraph = 20 [default = "? \? ?? \?? \??? ??/ ?\?-"]; + + // String defaults containing the character '\000' + string string_with_zero = 23 [default = "hel\000lo"]; + bytes bytes_with_zero = 24 [default = "wor\000ld"]; + string string_piece_with_zero = 25 [default="ab\000c"]; + string cord_with_zero = 26 [features.(pb.cpp).string_type=CORD, + default="12\0003"]; + string replacement_string = 27 [default="${unknown}"]; +} + +message SparseEnumMessage { + TestSparseEnum sparse_enum = 1; +} + +// Test String and Bytes: string is for valid UTF-8 strings +message OneString { + string data = 1; +} + +message MoreString { + repeated string data = 1; +} + +message OneBytes { + bytes data = 1; +} + +message MoreBytes { + repeated bytes data = 1; +} + +message ManyOptionalString { + string str1 = 1; + string str2 = 2; + string str3 = 3; + string str4 = 4; + string str5 = 5; + string str6 = 6; + string str7 = 7; + string str8 = 8; + string str9 = 9; + string str10 = 10; + string str11 = 11; + string str12 = 12; + string str13 = 13; + string str14 = 14; + string str15 = 15; + string str16 = 16; + string str17 = 17; + string str18 = 18; + string str19 = 19; + string str20 = 20; + string str21 = 21; + string str22 = 22; + string str23 = 23; + string str24 = 24; + string str25 = 25; + string str26 = 26; + string str27 = 27; + string str28 = 28; + string str29 = 29; + string str30 = 30; + string str31 = 31; + string str32 = 32; +} + +// Test int32, uint32, int64, uint64, and bool are all compatible +message Int32Message { + int32 data = 1; +} + +message Uint32Message { + uint32 data = 1; +} + +message Int64Message { + int64 data = 1; +} + +message Uint64Message { + uint64 data = 1; +} + +message BoolMessage { + bool data = 1; +} + +// Test oneofs. +message TestOneof { + message FooGroup { + int32 a = 5; + string b = 6; + } + oneof foo { + int32 foo_int = 1; + string foo_string = 2; + TestAllTypes foo_message = 3; + FooGroup foogroup= 4 [features.message_encoding = DELIMITED]; + } +} + +message TestOneofBackwardsCompatible { + int32 foo_int = 1; + string foo_string = 2; + TestAllTypes foo_message = 3; + message FooGroup { + int32 a = 5; + string b = 6; + } + FooGroup foogroup= 4 [features.message_encoding = DELIMITED]; +} + +message TestOneof2 { + message FooGroup { + int32 a = 9; + string b = 10; + } + oneof foo { + int32 foo_int = 1; + string foo_string = 2; + string foo_cord = 3 [features.(pb.cpp).string_type=CORD]; + string foo_string_piece = 4; + bytes foo_bytes = 5; + NestedEnum foo_enum = 6; + NestedMessage foo_message = 7; + FooGroup foogroup = 8 [features.message_encoding = DELIMITED]; + NestedMessage foo_lazy_message = 11 [lazy=true]; + bytes foo_bytes_cord = 30 [features.(pb.cpp).string_type=CORD]; + } + + oneof bar { + int32 bar_int = 12 [default = 5]; + string bar_string = 13 [default = "STRING"]; + string bar_cord = 14 [features.(pb.cpp).string_type=CORD, default = "CORD"]; + string bar_string_piece = 15 [default = "SPIECE"]; + bytes bar_bytes = 16 [default = "BYTES"]; + NestedEnum bar_enum = 17 [default = BAR]; + string bar_string_with_empty_default = 20 [default = ""]; + string bar_cord_with_empty_default = 21 [features.(pb.cpp).string_type=CORD, default = ""]; + string bar_string_piece_with_empty_default = 22 [default = ""]; + bytes bar_bytes_with_empty_default = 23 [default = ""]; + } + + int32 baz_int = 18; + string baz_string = 19 [default = "BAZ"]; + + message NestedMessage { + int64 moo_int = 1; + repeated int32 corge_int = 2; + } + + enum NestedEnum { + UNKNOWN = 0; + FOO = 1; + BAR = 2; + BAZ = 3; + } +} + +message TestRequiredOneof { + oneof foo { + int32 foo_int = 1; + string foo_string = 2; + NestedMessage foo_message = 3; + NestedMessage foo_lazy_message = 4 [lazy = true]; + } + message NestedMessage { + double required_double = 1 [features.field_presence = LEGACY_REQUIRED]; + } +} + +// Test messages for packed fields + +message TestPackedTypes { + repeated int32 packed_int32 = 90 [features.repeated_field_encoding = PACKED]; + repeated int64 packed_int64 = 91 [features.repeated_field_encoding = PACKED]; + repeated uint32 packed_uint32 = 92 [features.repeated_field_encoding = PACKED]; + repeated uint64 packed_uint64 = 93 [features.repeated_field_encoding = PACKED]; + repeated sint32 packed_sint32 = 94 [features.repeated_field_encoding = PACKED]; + repeated sint64 packed_sint64 = 95 [features.repeated_field_encoding = PACKED]; + repeated fixed32 packed_fixed32 = 96 [features.repeated_field_encoding = PACKED]; + repeated fixed64 packed_fixed64 = 97 [features.repeated_field_encoding = PACKED]; + repeated sfixed32 packed_sfixed32 = 98 [features.repeated_field_encoding = PACKED]; + repeated sfixed64 packed_sfixed64 = 99 [features.repeated_field_encoding = PACKED]; + repeated float packed_float = 100 [features.repeated_field_encoding = PACKED]; + repeated double packed_double = 101 [features.repeated_field_encoding = PACKED]; + repeated bool packed_bool = 102 [features.repeated_field_encoding = PACKED]; + repeated ForeignEnum packed_enum = 103 [features.repeated_field_encoding = PACKED]; +} + +// A message with the same fields as TestPackedTypes, but without packing. Used +// to test packed <-> unpacked wire compatibility. +message TestUnpackedTypes { + repeated int32 unpacked_int32 = 90 [features.repeated_field_encoding = EXPANDED]; + repeated int64 unpacked_int64 = 91 [features.repeated_field_encoding = EXPANDED]; + repeated uint32 unpacked_uint32 = 92 [features.repeated_field_encoding = EXPANDED]; + repeated uint64 unpacked_uint64 = 93 [features.repeated_field_encoding = EXPANDED]; + repeated sint32 unpacked_sint32 = 94 [features.repeated_field_encoding = EXPANDED]; + repeated sint64 unpacked_sint64 = 95 [features.repeated_field_encoding = EXPANDED]; + repeated fixed32 unpacked_fixed32 = 96 [features.repeated_field_encoding = EXPANDED]; + repeated fixed64 unpacked_fixed64 = 97 [features.repeated_field_encoding = EXPANDED]; + repeated sfixed32 unpacked_sfixed32 = 98 [features.repeated_field_encoding = EXPANDED]; + repeated sfixed64 unpacked_sfixed64 = 99 [features.repeated_field_encoding = EXPANDED]; + repeated float unpacked_float = 100 [features.repeated_field_encoding = EXPANDED]; + repeated double unpacked_double = 101 [features.repeated_field_encoding = EXPANDED]; + repeated bool unpacked_bool = 102 [features.repeated_field_encoding = EXPANDED]; + repeated ForeignEnum unpacked_enum = 103 [features.repeated_field_encoding = EXPANDED]; +} + +message TestPackedExtensions { + extensions 1 to max; +} + +extend TestPackedExtensions { + repeated int32 packed_int32_extension = 90 [features.repeated_field_encoding = PACKED]; + repeated int64 packed_int64_extension = 91 [features.repeated_field_encoding = PACKED]; + repeated uint32 packed_uint32_extension = 92 [features.repeated_field_encoding = PACKED]; + repeated uint64 packed_uint64_extension = 93 [features.repeated_field_encoding = PACKED]; + repeated sint32 packed_sint32_extension = 94 [features.repeated_field_encoding = PACKED]; + repeated sint64 packed_sint64_extension = 95 [features.repeated_field_encoding = PACKED]; + repeated fixed32 packed_fixed32_extension = 96 [features.repeated_field_encoding = PACKED]; + repeated fixed64 packed_fixed64_extension = 97 [features.repeated_field_encoding = PACKED]; + repeated sfixed32 packed_sfixed32_extension = 98 [features.repeated_field_encoding = PACKED]; + repeated sfixed64 packed_sfixed64_extension = 99 [features.repeated_field_encoding = PACKED]; + repeated float packed_float_extension = 100 [features.repeated_field_encoding = PACKED]; + repeated double packed_double_extension = 101 [features.repeated_field_encoding = PACKED]; + repeated bool packed_bool_extension = 102 [features.repeated_field_encoding = PACKED]; + repeated ForeignEnum packed_enum_extension = 103 [features.repeated_field_encoding = PACKED]; +} + +message TestUnpackedExtensions { + extensions 1 to max; +} + +extend TestUnpackedExtensions { + repeated int32 unpacked_int32_extension = 90 [features.repeated_field_encoding = EXPANDED]; + repeated int64 unpacked_int64_extension = 91 [features.repeated_field_encoding = EXPANDED]; + repeated uint32 unpacked_uint32_extension = 92 [features.repeated_field_encoding = EXPANDED]; + repeated uint64 unpacked_uint64_extension = 93 [features.repeated_field_encoding = EXPANDED]; + repeated sint32 unpacked_sint32_extension = 94 [features.repeated_field_encoding = EXPANDED]; + repeated sint64 unpacked_sint64_extension = 95 [features.repeated_field_encoding = EXPANDED]; + repeated fixed32 unpacked_fixed32_extension = 96 [features.repeated_field_encoding = EXPANDED]; + repeated fixed64 unpacked_fixed64_extension = 97 [features.repeated_field_encoding = EXPANDED]; + repeated sfixed32 unpacked_sfixed32_extension = 98 [features.repeated_field_encoding = EXPANDED]; + repeated sfixed64 unpacked_sfixed64_extension = 99 [features.repeated_field_encoding = EXPANDED]; + repeated float unpacked_float_extension = 100 [features.repeated_field_encoding = EXPANDED]; + repeated double unpacked_double_extension = 101 [features.repeated_field_encoding = EXPANDED]; + repeated bool unpacked_bool_extension = 102 [features.repeated_field_encoding = EXPANDED]; + repeated ForeignEnum unpacked_enum_extension = 103 [features.repeated_field_encoding = EXPANDED]; +} + +// Used by ExtensionSetTest/DynamicExtensions. The test actually builds +// a set of extensions to TestAllExtensions dynamically, based on the fields +// of this message type. +message TestDynamicExtensions { + enum DynamicEnumType { + DYNAMIC_UNKNOWN = 0; + DYNAMIC_FOO = 2200; + DYNAMIC_BAR = 2201; + DYNAMIC_BAZ = 2202; + } + message DynamicMessageType { + int32 dynamic_field = 2100; + } + + fixed32 scalar_extension = 2000; + ForeignEnum enum_extension = 2001; + DynamicEnumType dynamic_enum_extension = 2002; + + ForeignMessage message_extension = 2003; + DynamicMessageType dynamic_message_extension = 2004; + + repeated string repeated_extension = 2005; + repeated sint32 packed_extension = 2006 [features.repeated_field_encoding = PACKED]; +} + +message TestRepeatedString { + repeated string repeated_string1 = 1; + repeated string repeated_string2 = 2; + + repeated bytes repeated_bytes11 = 11; + repeated bytes repeated_bytes12 = 12; +} + +message TestRepeatedScalarDifferentTagSizes { + // Parsing repeated fixed size values used to fail. This message needs to be + // used in order to get a tag of the right size; all of the repeated fields + // in TestAllTypes didn't trigger the check. + repeated fixed32 repeated_fixed32 = 12; + // Check for a varint type, just for good measure. + repeated int32 repeated_int32 = 13; + + // These have two-byte tags. + repeated fixed64 repeated_fixed64 = 2046; + repeated int64 repeated_int64 = 2047; + + // Three byte tags. + repeated float repeated_float = 262142; + repeated uint64 repeated_uint64 = 262143; +} + +// Test that if an optional or message/group field appears multiple +// times in the input, they need to be merged. +message TestParsingMerge { + // RepeatedFieldsGenerator defines matching field types as TestParsingMerge, + // except that all fields are repeated. In the tests, we will serialize the + // RepeatedFieldsGenerator to bytes, and parse the bytes to TestParsingMerge. + // Repeated fields in RepeatedFieldsGenerator are expected to be merged into + // the corresponding required/optional fields in TestParsingMerge. + message RepeatedFieldsGenerator { + repeated TestAllTypes field1 = 1; + repeated TestAllTypes field2 = 2; + repeated TestAllTypes field3 = 3; + message Group1 { + TestAllTypes field1 = 11; + } + repeated Group1 group1= 10 [features.message_encoding = DELIMITED]; + message Group2 { + TestAllTypes field1 = 21; + } + repeated Group2 group2= 20 [features.message_encoding = DELIMITED]; + repeated TestAllTypes ext1 = 1000; + repeated TestAllTypes ext2 = 1001; + } + TestAllTypes required_all_types = 1 [features.field_presence = LEGACY_REQUIRED]; + TestAllTypes optional_all_types = 2; + repeated TestAllTypes repeated_all_types = 3; + message OptionalGroup { + TestAllTypes optional_group_all_types = 11; + } + OptionalGroup optionalgroup= 10 [features.message_encoding = DELIMITED]; + message RepeatedGroup { + TestAllTypes repeated_group_all_types = 21; + } + repeated RepeatedGroup repeatedgroup= 20 [features.message_encoding = DELIMITED]; + extensions 1000 to max; + extend TestParsingMerge { + TestAllTypes optional_ext = 1000; + repeated TestAllTypes repeated_ext = 1001; + } +} + +// Test that the correct exception is thrown by parseFrom in a corner case +// involving merging, extensions, and fields. +message TestMergeException { + TestAllExtensions all_extensions = 1; +} + +message TestCommentInjectionMessage { + // */ <- This should not close the generated doc comment + string a = 1 [default="*/ <- Neither should this."]; +} + +// Used to check that the c++ code generator re-orders messages to reduce +// padding. +message TestMessageSize { + bool m1 = 1; + int64 m2 = 2; + bool m3 = 3; + string m4 = 4; + int32 m5 = 5; + int64 m6 = 6; +} + +// Tests eager verification of a lazy message field. +message TestEagerlyVerifiedLazyMessage { + message LazyMessage { + bytes bytes_field = 1; + } + LazyMessage lazy_message = 1 [lazy = true]; +} + +// Test that RPC services work. +message FooRequest {} +message FooResponse {} + +message FooClientMessage {} +message FooServerMessage{} + +message BarRequest {} +message BarResponse {} + +message TestJsonName { + int32 field_name1 = 1; + int32 fieldName2 = 2 [features.enforce_naming_style = STYLE_LEGACY]; + int32 FieldName3 = 3 [features.enforce_naming_style = STYLE_LEGACY]; + int32 _field_name4 = 4 [features.enforce_naming_style = STYLE_LEGACY]; + int32 FIELD_NAME5 = 5 [features.enforce_naming_style = STYLE_LEGACY]; + int32 field_name6 = 6 [json_name = "@type"]; + int32 fieldname7 = 7; +} + +message TestHugeFieldNumbers { + int32 optional_int32 = 536870000; + int32 fixed_32 = 536870001 [features.enforce_naming_style = STYLE_LEGACY]; + repeated int32 repeated_int32 = 536870002 [features.repeated_field_encoding = EXPANDED]; + repeated int32 packed_int32 = 536870003 [features.repeated_field_encoding = PACKED]; + + ForeignEnum optional_enum = 536870004; + string optional_string = 536870005; + bytes optional_bytes = 536870006; + ForeignMessage optional_message = 536870007; + + message OptionalGroup { + int32 group_a = 536870009; + } + OptionalGroup optionalgroup = 536870008 [features.message_encoding = DELIMITED]; + + map string_string_map = 536870010; + + oneof oneof_field { + uint32 oneof_uint32 = 536870011; + TestAllTypes oneof_test_all_types = 536870012; + string oneof_string = 536870013; + bytes oneof_bytes = 536870014; + } + + extensions 536860000 to 536869999 [declaration = { + number: 536860000 + full_name: ".edition_unittest.test_all_types" + type: ".edition_unittest.TestAllTypes" + }]; +} + +extend TestHugeFieldNumbers { + TestAllTypes test_all_types = 536860000; +} + +message TestExtensionInsideTable { + int32 field1 = 1; + int32 field2 = 2; + int32 field3 = 3; + int32 field4 = 4; + extensions 5 to 5; + int32 field6 = 6; + int32 field7 = 7; + int32 field8 = 8; + int32 field9 = 9; + int32 field10 = 10; +} + +extend TestExtensionInsideTable { + int32 test_extension_inside_table_extension = 5; +} + +// NOTE: Intentionally nested to mirror go/glep. +message TestNestedGroupExtensionOuter { + message Layer1OptionalGroup { + message Layer2RepeatedGroup { + extensions 3 + // NOTE: extension metadata is not supported due to targets such as + // `//google/protobuf_legacy_opensource/src:shell_scripts_test`, + // eee https://screenshot.googleplex.com/Axz2QD8nxjdpyFF + //[metadata = { + // NOTE: can't write type there due to some clever build gen code at + // http://google3/google/protobuf/BUILD;l=1247;rcl=411090862 + // type: "edition_unittest.TestNestedGroupExtensionInnerExtension", + // name: "inner", + // }] + ; + string another_field = 6; + } + message Layer2AnotherOptionalRepeatedGroup { + string but_why_tho = 5; + } + repeated Layer2RepeatedGroup layer2repeatedgroup = 2 [features.message_encoding = DELIMITED]; + repeated Layer2AnotherOptionalRepeatedGroup layer2anotheroptionalrepeatedgroup = 4 [features.message_encoding = DELIMITED]; + } + Layer1OptionalGroup lay1optionalgroup = 1 [features.message_encoding = DELIMITED]; +} + +message TestNestedGroupExtensionInnerExtension { + string inner_name= 1; +} + +extend TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2RepeatedGroup { + TestNestedGroupExtensionInnerExtension inner = 3; +} + +enum VeryLargeEnum { + option features.enforce_naming_style = STYLE_LEGACY; + + ENUM_LABEL_DEFAULT = 0; + ENUM_LABEL_1 = 1; + ENUM_LABEL_2 = 2; + ENUM_LABEL_3 = 3; + ENUM_LABEL_4 = 4; + ENUM_LABEL_5 = 5; + ENUM_LABEL_6 = 6; + ENUM_LABEL_7 = 7; + ENUM_LABEL_8 = 8; + ENUM_LABEL_9 = 9; + ENUM_LABEL_10 = 10; + ENUM_LABEL_11 = 11; + ENUM_LABEL_12 = 12; + ENUM_LABEL_13 = 13; + ENUM_LABEL_14 = 14; + ENUM_LABEL_15 = 15; + ENUM_LABEL_16 = 16; + ENUM_LABEL_17 = 17; + ENUM_LABEL_18 = 18; + ENUM_LABEL_19 = 19; + ENUM_LABEL_20 = 20; + ENUM_LABEL_21 = 21; + ENUM_LABEL_22 = 22; + ENUM_LABEL_23 = 23; + ENUM_LABEL_24 = 24; + ENUM_LABEL_25 = 25; + ENUM_LABEL_26 = 26; + ENUM_LABEL_27 = 27; + ENUM_LABEL_28 = 28; + ENUM_LABEL_29 = 29; + ENUM_LABEL_30 = 30; + ENUM_LABEL_31 = 31; + ENUM_LABEL_32 = 32; + ENUM_LABEL_33 = 33; + ENUM_LABEL_34 = 34; + ENUM_LABEL_35 = 35; + ENUM_LABEL_36 = 36; + ENUM_LABEL_37 = 37; + ENUM_LABEL_38 = 38; + ENUM_LABEL_39 = 39; + ENUM_LABEL_40 = 40; + ENUM_LABEL_41 = 41; + ENUM_LABEL_42 = 42; + ENUM_LABEL_43 = 43; + ENUM_LABEL_44 = 44; + ENUM_LABEL_45 = 45; + ENUM_LABEL_46 = 46; + ENUM_LABEL_47 = 47; + ENUM_LABEL_48 = 48; + ENUM_LABEL_49 = 49; + ENUM_LABEL_50 = 50; + ENUM_LABEL_51 = 51; + ENUM_LABEL_52 = 52; + ENUM_LABEL_53 = 53; + ENUM_LABEL_54 = 54; + ENUM_LABEL_55 = 55; + ENUM_LABEL_56 = 56; + ENUM_LABEL_57 = 57; + ENUM_LABEL_58 = 58; + ENUM_LABEL_59 = 59; + ENUM_LABEL_60 = 60; + ENUM_LABEL_61 = 61; + ENUM_LABEL_62 = 62; + ENUM_LABEL_63 = 63; + ENUM_LABEL_64 = 64; + ENUM_LABEL_65 = 65; + ENUM_LABEL_66 = 66; + ENUM_LABEL_67 = 67; + ENUM_LABEL_68 = 68; + ENUM_LABEL_69 = 69; + ENUM_LABEL_70 = 70; + ENUM_LABEL_71 = 71; + ENUM_LABEL_72 = 72; + ENUM_LABEL_73 = 73; + ENUM_LABEL_74 = 74; + ENUM_LABEL_75 = 75; + ENUM_LABEL_76 = 76; + ENUM_LABEL_77 = 77; + ENUM_LABEL_78 = 78; + ENUM_LABEL_79 = 79; + ENUM_LABEL_80 = 80; + ENUM_LABEL_81 = 81; + ENUM_LABEL_82 = 82; + ENUM_LABEL_83 = 83; + ENUM_LABEL_84 = 84; + ENUM_LABEL_85 = 85; + ENUM_LABEL_86 = 86; + ENUM_LABEL_87 = 87; + ENUM_LABEL_88 = 88; + ENUM_LABEL_89 = 89; + ENUM_LABEL_90 = 90; + ENUM_LABEL_91 = 91; + ENUM_LABEL_92 = 92; + ENUM_LABEL_93 = 93; + ENUM_LABEL_94 = 94; + ENUM_LABEL_95 = 95; + ENUM_LABEL_96 = 96; + ENUM_LABEL_97 = 97; + ENUM_LABEL_98 = 98; + ENUM_LABEL_99 = 99; + ENUM_LABEL_100 = 100; +}; + +message TestExtensionRangeSerialize { + int32 foo_one = 1; + + extensions 2 to 2; + extensions 3 to 4; + + int32 foo_two = 6; + int32 foo_three = 7; + + extensions 9 to 10; + + int32 foo_four = 13; + + extensions 15 to 15; + extensions 17 to 17; + extensions 19 to 19; + + extend TestExtensionRangeSerialize { + int32 bar_one = 2; + int32 bar_two = 4; + + int32 bar_three = 10; + + int32 bar_four = 15; + int32 bar_five = 19; + } +} + +message TestVerifyInt32Simple { + option features.enforce_naming_style = STYLE_LEGACY; + + int32 optional_int32_1 = 1; + int32 optional_int32_2 = 2; + int32 optional_int32_63 = 63; + int32 optional_int32_64 = 64; +} + +message TestVerifyInt32 { + option features.enforce_naming_style = STYLE_LEGACY; + + int32 optional_int32_1 = 1; + int32 optional_int32_2 = 2; + int32 optional_int32_63 = 63; + int32 optional_int32_64 = 64; + + TestAllTypes optional_all_types = 9; + repeated TestAllTypes repeated_all_types = 10; +} + +message TestVerifyMostlyInt32 { + option features.enforce_naming_style = STYLE_LEGACY; + + int64 optional_int64_30 = 30; + + int32 optional_int32_1 = 1; + int32 optional_int32_2 = 2; + int32 optional_int32_3 = 3; + int32 optional_int32_4 = 4; + int32 optional_int32_63 = 63; + int32 optional_int32_64 = 64; + + TestAllTypes optional_all_types = 9; + repeated TestAllTypes repeated_all_types = 10; +} + +message TestVerifyMostlyInt32BigFieldNumber { + option features.enforce_naming_style = STYLE_LEGACY; + + int64 optional_int64_30 = 30; + int32 optional_int32_300 = 300; + + int32 optional_int32_1 = 1; + int32 optional_int32_2 = 2; + int32 optional_int32_3 = 3; + int32 optional_int32_4 = 4; + int32 optional_int32_63 = 63; + int32 optional_int32_64 = 64; + + TestAllTypes optional_all_types = 9; + repeated TestAllTypes repeated_all_types = 10; +} + +message TestVerifyUint32Simple { + option features.enforce_naming_style = STYLE_LEGACY; + + uint32 optional_uint32_1 = 1; + uint32 optional_uint32_2 = 2; + uint32 optional_uint32_63 = 63; + uint32 optional_uint32_64 = 64; +} + +message TestVerifyUint32 { + option features.enforce_naming_style = STYLE_LEGACY; + + uint32 optional_uint32_1 = 1; + uint32 optional_uint32_2 = 2; + uint32 optional_uint32_63 = 63; + uint32 optional_uint32_64 = 64; + + TestAllTypes optional_all_types = 9; + repeated TestAllTypes repeated_all_types = 10; +} + +message TestVerifyOneUint32 { + option features.enforce_naming_style = STYLE_LEGACY; + + uint32 optional_uint32_1 = 1; + int32 optional_int32_2 = 2; + int32 optional_int32_63 = 63; + int32 optional_int32_64 = 64; + + TestAllTypes optional_all_types = 9; + repeated TestAllTypes repeated_all_types = 10; +} + +message TestVerifyOneInt32BigFieldNumber { + option features.enforce_naming_style = STYLE_LEGACY; + + int32 optional_int32_65 = 65; + + int64 optional_int64_1 = 1; + int64 optional_int64_2 = 2; + int64 optional_int64_63 = 63; + int64 optional_int64_64 = 64; + + TestAllTypes optional_all_types = 9; + repeated TestAllTypes repeated_all_types = 10; +} + +message TestVerifyInt32BigFieldNumber { + option features.enforce_naming_style = STYLE_LEGACY; + + int32 optional_int32_1000 = 1000; + int32 optional_int32_65 = 65; + + int32 optional_int32_1 = 1; + int32 optional_int32_2 = 2; + int32 optional_int32_63 = 63; + int32 optional_int32_64 = 64; + + TestAllTypes optional_all_types = 9; + repeated TestAllTypes repeated_all_types = 10; +} + +message TestVerifyUint32BigFieldNumber { + option features.enforce_naming_style = STYLE_LEGACY; + + uint32 optional_uint32_1000 = 1000; + uint32 optional_uint32_65 = 65; + + uint32 optional_uint32_1 = 1; + uint32 optional_uint32_2 = 2; + uint32 optional_uint32_63 = 63; + uint32 optional_uint32_64 = 64; + + TestAllTypes optional_all_types = 9; + repeated TestAllTypes repeated_all_types = 10; +} + +message TestVerifyBigFieldNumberUint32 { + message Nested { + option features.enforce_naming_style = STYLE_LEGACY; + + uint32 optional_uint32_5000 = 5000; + uint32 optional_uint32_1000 = 1000; + uint32 optional_uint32_66 = 66; + uint32 optional_uint32_65 = 65; + + uint32 optional_uint32_1 = 1; + uint32 optional_uint32_2 = 2; + uint32 optional_uint32_63 = 63; + uint32 optional_uint32_64 = 64; + + Nested optional_nested = 9; + repeated Nested repeated_nested = 10; + } + Nested optional_nested = 1; +} + +// This message contains different kind of enums to exercise the different +// parsers in table-driven. +message EnumParseTester { + option features.enforce_naming_style = STYLE_LEGACY; + + enum SeqSmall0 { + SEQ_SMALL_0_DEFAULT = 0; + SEQ_SMALL_0_1 = 1; + SEQ_SMALL_0_2 = 2; + }; + SeqSmall0 optional_seq_small_0_lowfield = 1; + SeqSmall0 optional_seq_small_0_midfield = 1001; + SeqSmall0 optional_seq_small_0_hifield = 1000001; + repeated SeqSmall0 repeated_seq_small_0_lowfield = 2; + repeated SeqSmall0 repeated_seq_small_0_midfield = 1002; + repeated SeqSmall0 repeated_seq_small_0_hifield = 1000002; + repeated SeqSmall0 packed_seq_small_0_lowfield = 3 + [features.repeated_field_encoding = PACKED]; + repeated SeqSmall0 packed_seq_small_0_midfield = 1003 + [features.repeated_field_encoding = PACKED]; + repeated SeqSmall0 packed_seq_small_0_hifield = 1000003 + [features.repeated_field_encoding = PACKED]; + + enum SeqSmall1 { + UNKNOWN = 0; + SEQ_SMALL_1_DEFAULT = 1; + SEQ_SMALL_1_2 = 2; + SEQ_SMALL_1_3 = 3; + }; + SeqSmall1 optional_seq_small_1_lowfield = 4; + SeqSmall1 optional_seq_small_1_midfield = 1004; + SeqSmall1 optional_seq_small_1_hifield = 1000004; + repeated SeqSmall1 repeated_seq_small_1_lowfield = 5; + repeated SeqSmall1 repeated_seq_small_1_midfield = 1005; + repeated SeqSmall1 repeated_seq_small_1_hifield = 1000005; + repeated SeqSmall1 packed_seq_small_1_lowfield = 6 + [features.repeated_field_encoding = PACKED]; + repeated SeqSmall1 packed_seq_small_1_midfield = 1006 + [features.repeated_field_encoding = PACKED]; + repeated SeqSmall1 packed_seq_small_1_hifield = 1000006 + [features.repeated_field_encoding = PACKED]; + + enum SeqLarge { + option features.enforce_naming_style = STYLE_LEGACY; + + SEQ_LARGE_DEFAULT = -1; + SEQ_LARGE_0 = 0; + SEQ_LARGE_1 = 1; + SEQ_LARGE_2 = 2; + SEQ_LARGE_3 = 3; + SEQ_LARGE_4 = 4; + SEQ_LARGE_5 = 5; + SEQ_LARGE_6 = 6; + SEQ_LARGE_7 = 7; + SEQ_LARGE_8 = 8; + SEQ_LARGE_9 = 9; + SEQ_LARGE_10 = 10; + SEQ_LARGE_11 = 11; + SEQ_LARGE_12 = 12; + SEQ_LARGE_13 = 13; + SEQ_LARGE_14 = 14; + SEQ_LARGE_15 = 15; + SEQ_LARGE_16 = 16; + SEQ_LARGE_17 = 17; + SEQ_LARGE_18 = 18; + SEQ_LARGE_19 = 19; + SEQ_LARGE_20 = 20; + SEQ_LARGE_21 = 21; + SEQ_LARGE_22 = 22; + SEQ_LARGE_23 = 23; + SEQ_LARGE_24 = 24; + SEQ_LARGE_25 = 25; + SEQ_LARGE_26 = 26; + SEQ_LARGE_27 = 27; + SEQ_LARGE_28 = 28; + SEQ_LARGE_29 = 29; + SEQ_LARGE_30 = 30; + SEQ_LARGE_31 = 31; + SEQ_LARGE_32 = 32; + SEQ_LARGE_33 = 33; + }; + SeqLarge optional_seq_large_lowfield = 7; + SeqLarge optional_seq_large_midfield = 1007; + SeqLarge optional_seq_large_hifield = 1000007; + repeated SeqLarge repeated_seq_large_lowfield = 8; + repeated SeqLarge repeated_seq_large_midfield = 1008; + repeated SeqLarge repeated_seq_large_hifield = 1000008; + repeated SeqLarge packed_seq_large_lowfield = 9 + [features.repeated_field_encoding = PACKED]; + repeated SeqLarge packed_seq_large_midfield = 1009 + [features.repeated_field_encoding = PACKED]; + repeated SeqLarge packed_seq_large_hifield = 1000009 + [features.repeated_field_encoding = PACKED]; + + enum Arbitrary { + ARBITRARY_DEFAULT = -123123; + ARBITRARY_1 = -123; + ARBITRARY_2 = 213; + ARBITRARY_3 = 213213; + ARBITRARY_MIN = -2147483648; + ARBITRARY_MAX = 2147483647; + }; + Arbitrary optional_arbitrary_lowfield = 10; + Arbitrary optional_arbitrary_midfield = 1010; + Arbitrary optional_arbitrary_hifield = 1000010; + repeated Arbitrary repeated_arbitrary_lowfield = 11; + repeated Arbitrary repeated_arbitrary_midfield = 1011; + repeated Arbitrary repeated_arbitrary_hifield = 1000011; + repeated Arbitrary packed_arbitrary_lowfield = 12 + [features.repeated_field_encoding = PACKED]; + repeated Arbitrary packed_arbitrary_midfield = 1012 + [features.repeated_field_encoding = PACKED]; + repeated Arbitrary packed_arbitrary_hifield = 1000012 + [features.repeated_field_encoding = PACKED]; + + extensions 2000000 to max; + extend EnumParseTester { + Arbitrary optional_arbitrary_ext = 2000000; + repeated Arbitrary repeated_arbitrary_ext = 2000001; + repeated Arbitrary packed_arbitrary_ext = 2000002 + [features.repeated_field_encoding = PACKED]; + } + + // An arbitrary field we can append to to break the runs of repeated fields. + int32 other_field = 99; +} + +// This message contains different kind of bool fields to exercise the different +// parsers in table-drived. +message BoolParseTester { + bool optional_bool_lowfield = 1; + bool optional_bool_midfield = 1001; + bool optional_bool_hifield = 1000001; + repeated bool repeated_bool_lowfield = 2; + repeated bool repeated_bool_midfield = 1002; + repeated bool repeated_bool_hifield = 1000002; + repeated bool packed_bool_lowfield = 3 + [features.repeated_field_encoding = PACKED]; + repeated bool packed_bool_midfield = 1003 + [features.repeated_field_encoding = PACKED]; + repeated bool packed_bool_hifield = 1000003 + [features.repeated_field_encoding = PACKED]; + + extensions 2000000 to max; + extend BoolParseTester { + bool optional_bool_ext = 2000000; + repeated bool repeated_bool_ext = 2000001; + repeated bool packed_bool_ext = 2000002 + [features.repeated_field_encoding = PACKED]; + } + + // An arbitrary field we can append to to break the runs of repeated fields. + int32 other_field = 99; +} + +message Int32ParseTester { + int32 optional_int32_lowfield = 1; + int32 optional_int32_midfield = 1001; + int32 optional_int32_hifield = 1000001; + repeated int32 repeated_int32_lowfield = 2; + repeated int32 repeated_int32_midfield = 1002; + repeated int32 repeated_int32_hifield = 1000002; + repeated int32 packed_int32_lowfield = 3 + [features.repeated_field_encoding = PACKED]; + repeated int32 packed_int32_midfield = 1003 + [features.repeated_field_encoding = PACKED]; + repeated int32 packed_int32_hifield = 1000003 + [features.repeated_field_encoding = PACKED]; + + extensions 2000000 to max; + extend Int32ParseTester { + int32 optional_int32_ext = 2000000; + repeated int32 repeated_int32_ext = 2000001; + repeated int32 packed_int32_ext = 2000002 + [features.repeated_field_encoding = PACKED]; + } + + // An arbitrary field we can append to to break the runs of repeated fields. + int32 other_field = 99; +} + +message Int64ParseTester { + int64 optional_int64_lowfield = 1; + int64 optional_int64_midfield = 1001; + int64 optional_int64_hifield = 1000001; + repeated int64 repeated_int64_lowfield = 2; + repeated int64 repeated_int64_midfield = 1002; + repeated int64 repeated_int64_hifield = 1000002; + repeated int64 packed_int64_lowfield = 3 + [features.repeated_field_encoding = PACKED]; + repeated int64 packed_int64_midfield = 1003 + [features.repeated_field_encoding = PACKED]; + repeated int64 packed_int64_hifield = 1000003 + [features.repeated_field_encoding = PACKED]; + + extensions 2000000 to max; + extend Int64ParseTester { + int64 optional_int64_ext = 2000000; + repeated int64 repeated_int64_ext = 2000001; + repeated int64 packed_int64_ext = 2000002 + [features.repeated_field_encoding = PACKED]; + } + + // An arbitrary field we can append to to break the runs of repeated fields. + int32 other_field = 99; +} + +message InlinedStringIdxRegressionProto { + // We mix data to make sure aux ids and inlined string idx do not match. + // aux_idx == inlined_string_idx == 1 + string str1 = 1; + // aux_idx == 2 + InlinedStringIdxRegressionProto sub = 2; + // aux_idx == 3, inlined_string_idx == 2 + string str2 = 3; + // aux_idx == 4, inlined_string_idx == 3 + bytes str3 = 4; +} + +message StringParseTester { + string optional_string_lowfield = 1; + string optional_string_midfield = 1001; + string optional_string_hifield = 1000001; + repeated string repeated_string_lowfield = 2; + repeated string repeated_string_midfield = 1002; + repeated string repeated_string_hifield = 1000002; + + extensions 2000000 to max; + extend StringParseTester { + string optional_string_ext = 2000000; + repeated string repeated_string_ext = 2000001; + } +} + +message BadFieldNames{ + int32 OptionalInt32 = 1 [features.enforce_naming_style = STYLE_LEGACY]; + int32 for = 2; +} + +message TestNestedMessageRedaction { + string optional_unredacted_nested_string = 1; + string optional_redacted_nested_string = 2 [debug_redact = true]; +} + +message RedactedFields { + string optional_redacted_string = 1 [debug_redact = true]; + string optional_unredacted_string = 2; + repeated string repeated_redacted_string = 3 [debug_redact = true]; + repeated string repeated_unredacted_string = 4; + TestNestedMessageRedaction optional_redacted_message = 5 [debug_redact = true]; + TestNestedMessageRedaction optional_unredacted_message = 6; + repeated TestNestedMessageRedaction repeated_redacted_message = 7 + [debug_redact = true]; + repeated TestNestedMessageRedaction repeated_unredacted_message = 8; + map map_redacted_string = 9 [debug_redact = true]; + map map_unredacted_string = 10; +} + +message TestCord{ + bytes optional_bytes_cord = 1 [features.(pb.cpp).string_type = CORD]; + bytes optional_bytes_cord_default = 2 [features.(pb.cpp).string_type = CORD, default = "hello"]; +} + +message TestPackedEnumSmallRange { + enum NestedEnum { + UNSPECIFIED = 0; + FOO = 1; + BAR = 2; + BAZ = 3; + } + repeated NestedEnum vals = 1 + [features.repeated_field_encoding = PACKED]; +} + +message EnumsForBenchmark { + enum Flat { + A0 = 0; + A1 = 1; + A2 = 2; + A3 = 3; + A4 = 4; + A5 = 5; + A6 = 6; + A7 = 7; + A8 = 8; + A9 = 9; + A10 = 10; + A11 = 11; + A12 = 12; + A13 = 13; + A14 = 14; + A15 = 15; + } + // Has a few holes, bitmap can be used. + enum AlmostFlat { + B0 = 0; + B1 = 1; + B2 = 2; + B3 = 3; + B5 = 5; + B6 = 6; + B7 = 7; + B8 = 8; + B9 = 9; + B11 = 11; + B12 = 12; + B13 = 13; + B14 = 14; + B15 = 15; + B17 = 17; + B19 = 19; + } + enum Sparse { + C0 = 0; + C536 = 536; + C8387 = 8387; + C9673 = 9673; + C10285 = 10285; + C13318 = 13318; + C15963 = 15963; + C16439 = 16439; + C18197 = 18197; + C19430 = 19430; + C20361 = 20361; + C20706 = 20706; + C21050 = 21050; + C21906 = 21906; + C27265 = 27265; + C30109 = 30109; + C31670 = 31670; + } +} + +message TestMessageWithManyRepeatedPtrFields { + option features.enforce_naming_style = STYLE_LEGACY; + + repeated string repeated_string_1 = 1; + repeated string repeated_string_2 = 2; + repeated string repeated_string_3 = 3; + repeated string repeated_string_4 = 4; + repeated string repeated_string_5 = 5; + repeated string repeated_string_6 = 6; + repeated string repeated_string_7 = 7; + repeated string repeated_string_8 = 8; + repeated string repeated_string_9 = 9; + repeated string repeated_string_10 = 10; + repeated string repeated_string_11 = 11; + repeated string repeated_string_12 = 12; + repeated string repeated_string_13 = 13; + repeated string repeated_string_14 = 14; + repeated string repeated_string_15 = 15; + repeated string repeated_string_16 = 16; + repeated string repeated_string_17 = 17; + repeated string repeated_string_18 = 18; + repeated string repeated_string_19 = 19; + repeated string repeated_string_20 = 20; + repeated string repeated_string_21 = 21; + repeated string repeated_string_22 = 22; + repeated string repeated_string_23 = 23; + repeated string repeated_string_24 = 24; + repeated string repeated_string_25 = 25; + repeated string repeated_string_26 = 26; + repeated string repeated_string_27 = 27; + repeated string repeated_string_28 = 28; + repeated string repeated_string_29 = 29; + repeated string repeated_string_30 = 30; + repeated string repeated_string_31 = 31; + repeated string repeated_string_32 = 32; +} diff --git a/Protos/google/protobuf/unittest_import_public_lite.proto b/Protos/upstream/google/protobuf/empty.proto similarity index 72% rename from Protos/google/protobuf/unittest_import_public_lite.proto rename to Protos/upstream/google/protobuf/empty.proto index 33549c227..b87c89dcf 100644 --- a/Protos/google/protobuf/unittest_import_public_lite.proto +++ b/Protos/upstream/google/protobuf/empty.proto @@ -28,16 +28,24 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Author: liujisi@google.com (Pherl Liu) +syntax = "proto3"; -syntax = "proto2"; - -package protobuf_unittest_import; - -option optimize_for = LITE_RUNTIME; +package google.protobuf; +option go_package = "google.golang.org/protobuf/types/known/emptypb"; option java_package = "com.google.protobuf"; +option java_outer_classname = "EmptyProto"; +option java_multiple_files = true; +option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option cc_enable_arenas = true; -message PublicImportMessageLite { - optional int32 e = 1; -} +// A generic empty message that you can re-use to avoid defining duplicated +// empty messages in your APIs. A typical example is to use it as the request +// or the response type of an API method. For instance: +// +// service Foo { +// rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); +// } +// +message Empty {} diff --git a/Protos/upstream/google/protobuf/field_mask.proto b/Protos/upstream/google/protobuf/field_mask.proto new file mode 100644 index 000000000..b28334b94 --- /dev/null +++ b/Protos/upstream/google/protobuf/field_mask.proto @@ -0,0 +1,245 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +syntax = "proto3"; + +package google.protobuf; + +option java_package = "com.google.protobuf"; +option java_outer_classname = "FieldMaskProto"; +option java_multiple_files = true; +option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option go_package = "google.golang.org/protobuf/types/known/fieldmaskpb"; +option cc_enable_arenas = true; + +// `FieldMask` represents a set of symbolic field paths, for example: +// +// paths: "f.a" +// paths: "f.b.d" +// +// Here `f` represents a field in some root message, `a` and `b` +// fields in the message found in `f`, and `d` a field found in the +// message in `f.b`. +// +// Field masks are used to specify a subset of fields that should be +// returned by a get operation or modified by an update operation. +// Field masks also have a custom JSON encoding (see below). +// +// # Field Masks in Projections +// +// When used in the context of a projection, a response message or +// sub-message is filtered by the API to only contain those fields as +// specified in the mask. For example, if the mask in the previous +// example is applied to a response message as follows: +// +// f { +// a : 22 +// b { +// d : 1 +// x : 2 +// } +// y : 13 +// } +// z: 8 +// +// The result will not contain specific values for fields x,y and z +// (their value will be set to the default, and omitted in proto text +// output): +// +// +// f { +// a : 22 +// b { +// d : 1 +// } +// } +// +// A repeated field is not allowed except at the last position of a +// paths string. +// +// If a FieldMask object is not present in a get operation, the +// operation applies to all fields (as if a FieldMask of all fields +// had been specified). +// +// Note that a field mask does not necessarily apply to the +// top-level response message. In case of a REST get operation, the +// field mask applies directly to the response, but in case of a REST +// list operation, the mask instead applies to each individual message +// in the returned resource list. In case of a REST custom method, +// other definitions may be used. Where the mask applies will be +// clearly documented together with its declaration in the API. In +// any case, the effect on the returned resource/resources is required +// behavior for APIs. +// +// # Field Masks in Update Operations +// +// A field mask in update operations specifies which fields of the +// targeted resource are going to be updated. The API is required +// to only change the values of the fields as specified in the mask +// and leave the others untouched. If a resource is passed in to +// describe the updated values, the API ignores the values of all +// fields not covered by the mask. +// +// If a repeated field is specified for an update operation, new values will +// be appended to the existing repeated field in the target resource. Note that +// a repeated field is only allowed in the last position of a `paths` string. +// +// If a sub-message is specified in the last position of the field mask for an +// update operation, then new value will be merged into the existing sub-message +// in the target resource. +// +// For example, given the target message: +// +// f { +// b { +// d: 1 +// x: 2 +// } +// c: [1] +// } +// +// And an update message: +// +// f { +// b { +// d: 10 +// } +// c: [2] +// } +// +// then if the field mask is: +// +// paths: ["f.b", "f.c"] +// +// then the result will be: +// +// f { +// b { +// d: 10 +// x: 2 +// } +// c: [1, 2] +// } +// +// An implementation may provide options to override this default behavior for +// repeated and message fields. +// +// In order to reset a field's value to the default, the field must +// be in the mask and set to the default value in the provided resource. +// Hence, in order to reset all fields of a resource, provide a default +// instance of the resource and set all fields in the mask, or do +// not provide a mask as described below. +// +// If a field mask is not present on update, the operation applies to +// all fields (as if a field mask of all fields has been specified). +// Note that in the presence of schema evolution, this may mean that +// fields the client does not know and has therefore not filled into +// the request will be reset to their default. If this is unwanted +// behavior, a specific service may require a client to always specify +// a field mask, producing an error if not. +// +// As with get operations, the location of the resource which +// describes the updated values in the request message depends on the +// operation kind. In any case, the effect of the field mask is +// required to be honored by the API. +// +// ## Considerations for HTTP REST +// +// The HTTP kind of an update operation which uses a field mask must +// be set to PATCH instead of PUT in order to satisfy HTTP semantics +// (PUT must only be used for full updates). +// +// # JSON Encoding of Field Masks +// +// In JSON, a field mask is encoded as a single string where paths are +// separated by a comma. Fields name in each path are converted +// to/from lower-camel naming conventions. +// +// As an example, consider the following message declarations: +// +// message Profile { +// User user = 1; +// Photo photo = 2; +// } +// message User { +// string display_name = 1; +// string address = 2; +// } +// +// In proto a field mask for `Profile` may look as such: +// +// mask { +// paths: "user.display_name" +// paths: "photo" +// } +// +// In JSON, the same mask is represented as below: +// +// { +// mask: "user.displayName,photo" +// } +// +// # Field Masks and Oneof Fields +// +// Field masks treat fields in oneofs just as regular fields. Consider the +// following message: +// +// message SampleMessage { +// oneof test_oneof { +// string name = 4; +// SubMessage sub_message = 9; +// } +// } +// +// The field mask can be: +// +// mask { +// paths: "name" +// } +// +// Or: +// +// mask { +// paths: "sub_message" +// } +// +// Note that oneof type names ("test_oneof" in this case) cannot be used in +// paths. +// +// ## Field Mask Verification +// +// The implementation of any API method which has a FieldMask type field in the +// request should verify the included field paths, and return an +// `INVALID_ARGUMENT` error if any path is unmappable. +message FieldMask { + // The set of field mask paths. + repeated string paths = 1; +} diff --git a/Protos/upstream/google/protobuf/internal_metadata_locator_test.proto b/Protos/upstream/google/protobuf/internal_metadata_locator_test.proto new file mode 100644 index 000000000..d666ef2c7 --- /dev/null +++ b/Protos/upstream/google/protobuf/internal_metadata_locator_test.proto @@ -0,0 +1,8 @@ +edition = "2023"; + +package proto2_unittest; + +// The test that uses this message requires that the message has only one field. +message TestOneRepeatedField { + repeated int32 repeated_int32 = 1; +} diff --git a/Protos/upstream/google/protobuf/internal_options.proto b/Protos/upstream/google/protobuf/internal_options.proto new file mode 100644 index 000000000..2bc37f019 --- /dev/null +++ b/Protos/upstream/google/protobuf/internal_options.proto @@ -0,0 +1,35 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2023 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +edition = "2024"; + +package pb; + +import "google/protobuf/descriptor.proto"; + +// Internal options for testing only. +// These are used to turn on/off certain features that are not normally +// controlled from the .proto file, but we want to be able to control them for +// unit tests of said features. + +message InternalOptionsForce { + enum Enum { + UNSPECIFIED = 0; + FORCE_ON = 1; + FORCE_OFF = 2; + } +} + +message InternalFieldOptionsCpp {} + +message InternalFieldOptions { + InternalFieldOptionsCpp cpp = 1; +} + +extend google.protobuf.FieldOptions { + InternalFieldOptions internal_field_options = 535801550; +} diff --git a/Protos/upstream/google/protobuf/late_loaded_option.proto b/Protos/upstream/google/protobuf/late_loaded_option.proto new file mode 100644 index 000000000..0e0d4e9d7 --- /dev/null +++ b/Protos/upstream/google/protobuf/late_loaded_option.proto @@ -0,0 +1,13 @@ +edition = "2024"; + +package proto2_unittest; + +import "google/protobuf/descriptor.proto"; + +message LateLoadedOption { + int32 value = 1; + + extend google.protobuf.MessageOptions { + LateLoadedOption ext = 95126892; + } +} diff --git a/Protos/upstream/google/protobuf/late_loaded_option_user.proto b/Protos/upstream/google/protobuf/late_loaded_option_user.proto new file mode 100644 index 000000000..9b99e9250 --- /dev/null +++ b/Protos/upstream/google/protobuf/late_loaded_option_user.proto @@ -0,0 +1,11 @@ +edition = "2024"; + +package proto2_unittest; + +import option "google/protobuf/late_loaded_option.proto"; + +message LateLoadedOptionUser { + option (proto2_unittest.LateLoadedOption.ext) = { + value: 1 + }; +} diff --git a/Protos/google/protobuf/map_lite_unittest.proto b/Protos/upstream/google/protobuf/map_lite_unittest.proto similarity index 63% rename from Protos/google/protobuf/map_lite_unittest.proto rename to Protos/upstream/google/protobuf/map_lite_unittest.proto index cc00deec2..3bf3e2c23 100644 --- a/Protos/google/protobuf/map_lite_unittest.proto +++ b/Protos/upstream/google/protobuf/map_lite_unittest.proto @@ -1,39 +1,18 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -syntax = "proto2"; - -package protobuf_unittest; +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +edition = "2023"; + +package proto2_unittest; import "google/protobuf/unittest_lite.proto"; +option features.enum_type = CLOSED; +option features.utf8_validation = NONE; option cc_enable_arenas = true; option optimize_for = LITE_RUNTIME; @@ -117,11 +96,17 @@ enum MapEnumLite { } message TestRequiredLite { - required int32 a = 1; - required int32 b = 2; - required int32 c = 3; + int32 a = 1 [features.field_presence = LEGACY_REQUIRED]; + + int32 b = 2 [features.field_presence = LEGACY_REQUIRED]; + + int32 c = 3 [features.field_presence = LEGACY_REQUIRED]; + + extend TestAllExtensionsLite { + TestRequiredLite single = 1000; + } } message ForeignMessageArenaLite { - optional int32 c = 1; + int32 c = 1; } diff --git a/Protos/upstream/google/protobuf/map_proto2_unittest.proto b/Protos/upstream/google/protobuf/map_proto2_unittest.proto new file mode 100644 index 000000000..a9c09e80c --- /dev/null +++ b/Protos/upstream/google/protobuf/map_proto2_unittest.proto @@ -0,0 +1,102 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +syntax = "proto2"; + +import "google/protobuf/unittest_import.proto"; + +option cc_enable_arenas = true; + +// We don't put this in a package within proto2 because we need to make sure +// that the generated code doesn't depend on being in the proto2 namespace. +// In map_test_util.h we do "using namespace unittest = proto2_unittest". +package proto2_unittest; + +enum Proto2MapEnum { + PROTO2_MAP_ENUM_FOO = 0; + PROTO2_MAP_ENUM_BAR = 1; + PROTO2_MAP_ENUM_BAZ = 2; +} + +enum Proto2MapEnumPlusExtra { + E_PROTO2_MAP_ENUM_FOO = 0; + E_PROTO2_MAP_ENUM_BAR = 1; + E_PROTO2_MAP_ENUM_BAZ = 2; + E_PROTO2_MAP_ENUM_EXTRA = 3; +} + +message TestEnumMap { + map known_map_field = 101; + map unknown_map_field = 102; + + // Other maps with all key types to test the unknown entry serialization + map unknown_map_field_int64 = 200; + map unknown_map_field_uint64 = 201; + map unknown_map_field_int32 = 202; + map unknown_map_field_uint32 = 203; + map unknown_map_field_fixed32 = 204; + map unknown_map_field_fixed64 = 205; + map unknown_map_field_bool = 206; + map unknown_map_field_string = 207; + map unknown_map_field_sint32 = 208; + map unknown_map_field_sint64 = 209; + map unknown_map_field_sfixed32 = 210; + map unknown_map_field_sfixed64 = 211; +} + +message TestEnumMapPlusExtra { + map known_map_field = 101; + map unknown_map_field = 102; + + // Other maps with all key types to test the unknown entry serialization + map unknown_map_field_int64 = 200; + map unknown_map_field_uint64 = 201; + map unknown_map_field_int32 = 202; + map unknown_map_field_uint32 = 203; + map unknown_map_field_fixed32 = 204; + map unknown_map_field_fixed64 = 205; + map unknown_map_field_bool = 206; + map unknown_map_field_string = 207; + map unknown_map_field_sint32 = 208; + map unknown_map_field_sint64 = 209; + map unknown_map_field_sfixed32 = 210; + map unknown_map_field_sfixed64 = 211; +} + +message TestImportEnumMap { + map import_enum_amp = 1; +} + +message TestIntIntMap { + map m = 1; +} + +// Test all key types: string, plus the non-floating-point scalars. +message TestMaps { + map m_int32 = 1; + map m_int64 = 2; + map m_uint32 = 3; + map m_uint64 = 4; + map m_sint32 = 5; + map m_sint64 = 6; + map m_fixed32 = 7; + map m_fixed64 = 8; + map m_sfixed32 = 9; + map m_sfixed64 = 10; + map m_bool = 11; + map m_string = 12; +} + +// Test maps in submessages. +message TestSubmessageMaps { + optional TestMaps m = 1; +} + +message TestProto2BytesMap { + map map_bytes = 1; + map map_string = 2; +} diff --git a/Protos/upstream/google/protobuf/map_proto3_unittest.proto b/Protos/upstream/google/protobuf/map_proto3_unittest.proto new file mode 100644 index 000000000..42e1ce3b2 --- /dev/null +++ b/Protos/upstream/google/protobuf/map_proto3_unittest.proto @@ -0,0 +1,29 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +edition = "2024"; + +// Treat all fields as implicit present by default (proto3 behavior). +option features.field_presence = IMPLICIT; + +// This file contains definitions that have different behavior in proto3. + +// We don't put this in a package within proto2 because we need to make sure +// that the generated code doesn't depend on being in the proto2 namespace. +// In map_test_util.h we do "using namespace unittest = proto2_unittest". +package proto3_unittest; + +message TestProto3BytesMap { + map map_bytes = 1; + map map_string = 2; +} + +message TestI32StrMap { + option features.enforce_naming_style = STYLE_LEGACY; + + map m_32_str = 1; +} diff --git a/Protos/google/protobuf/map_unittest.proto b/Protos/upstream/google/protobuf/map_unittest.proto similarity index 63% rename from Protos/google/protobuf/map_unittest.proto rename to Protos/upstream/google/protobuf/map_unittest.proto index 263ef61f8..f3ae9367b 100644 --- a/Protos/google/protobuf/map_unittest.proto +++ b/Protos/upstream/google/protobuf/map_unittest.proto @@ -1,43 +1,18 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd syntax = "proto3"; -option cc_enable_arenas = true; - import "google/protobuf/unittest.proto"; // We don't put this in a package within proto2 because we need to make sure // that the generated code doesn't depend on being in the proto2 namespace. -// In map_test_util.h we do "using namespace unittest = protobuf_unittest". -package protobuf_unittest; +// In map_test_util.h we do "using namespace unittest = proto2_unittest". +package proto2_unittest; // Tests maps. message TestMap { @@ -60,6 +35,24 @@ message TestMap { map map_int32_foreign_message = 17; map map_string_foreign_message = 18; map map_int32_all_types = 19; + // Caveat emptor: be careful adding new fields here. + // The TestMap proto is used to generate additional tests and couples tightly + // with map_test_util.h, which in turn couples tightly with TestMapLite. +} + +message TestMapWithMessages { + map map_int32_all_types = 1; + map map_int64_all_types = 2; + map map_uint32_all_types = 3; + map map_uint64_all_types = 4; + map map_sint32_all_types = 5; + map map_sint64_all_types = 6; + map map_fixed32_all_types = 7; + map map_fixed64_all_types = 8; + map map_sfixed32_all_types = 9; + map map_sfixed64_all_types = 10; + map map_bool_all_types = 11; + map map_string_all_types = 12; } message TestMapSubmessage { @@ -76,7 +69,6 @@ message TestSameTypeMap { map map2 = 2; } - enum MapEnum { MAP_ENUM_FOO = 0; MAP_ENUM_BAR = 1; @@ -111,7 +103,9 @@ message TestArenaMap { // Previously, message containing enum called Type cannot be used as value of // map field. message MessageContainingEnumCalledType { - enum Type { TYPE_FOO = 0; } + enum Type { + TYPE_FOO = 0; + } map type = 1; } @@ -123,3 +117,7 @@ message MessageContainingMapCalledEntry { message TestRecursiveMapMessage { map a = 1; } + +message TestI32StrMap { + map m_32_str = 1; +} diff --git a/Protos/upstream/google/protobuf/only_one_enum_test.proto b/Protos/upstream/google/protobuf/only_one_enum_test.proto new file mode 100644 index 000000000..2f8d26f94 --- /dev/null +++ b/Protos/upstream/google/protobuf/only_one_enum_test.proto @@ -0,0 +1,14 @@ +edition = "2024"; + +package proto2_unittest; + +option optimize_for = LITE_RUNTIME; + +// A file with only a single enum, without any use of it. +// This is useful for testing enum specific codegen that is not directly related +// to field codegen. + +enum OnlyOneEnum { + ONLY_ONE_ENUM_DEFAULT = 0; + ONLY_ONE_ENUM_VALID = 10; +} diff --git a/Protos/upstream/google/protobuf/sample_messages_edition.proto b/Protos/upstream/google/protobuf/sample_messages_edition.proto new file mode 100644 index 000000000..7853b477f --- /dev/null +++ b/Protos/upstream/google/protobuf/sample_messages_edition.proto @@ -0,0 +1,430 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Sample messages to generate example code. + +edition = "2024"; + +package protobuf_test_messages.edition; + +option optimize_for = SPEED; + +import option "google/protobuf/cpp_features.proto"; + +// This proto includes every type of field in both singular and repeated +// forms. +// +// Also, crucially, all messages and enums in this file are eventually +// submessages of this message. So for example, a fuzz test of TestAllTypes +// could trigger bugs that occur in any message type in this file. We verify +// this stays true in a unit test. +message TestAllTypesEdition { + message NestedMessage { + int32 a = 1; + TestAllTypesEdition corecursive = 2; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + NEG = -1; // Intentionally negative. + } + + // Singular + int32 optional_int32 = 1; + int64 optional_int64 = 2; + uint32 optional_uint32 = 3; + uint64 optional_uint64 = 4; + sint32 optional_sint32 = 5; + sint64 optional_sint64 = 6; + fixed32 optional_fixed32 = 7; + fixed64 optional_fixed64 = 8; + sfixed32 optional_sfixed32 = 9; + sfixed64 optional_sfixed64 = 10; + float optional_float = 11; + double optional_double = 12; + bool optional_bool = 13; + string optional_string = 14; + bytes optional_bytes = 15; + + NestedMessage optional_nested_message = 18; + ForeignMessageEdition optional_foreign_message = 19; + + NestedEnum optional_nested_enum = 21; + ForeignEnumEdition optional_foreign_enum = 22; + + string optional_string_piece = 24; + string optional_cord = 25 [features.(pb.cpp).string_type = CORD]; + + TestAllTypesEdition recursive_message = 27; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + + repeated NestedMessage repeated_nested_message = 48; + repeated ForeignMessageEdition repeated_foreign_message = 49; + + repeated NestedEnum repeated_nested_enum = 51; + repeated ForeignEnumEdition repeated_foreign_enum = 52; + + repeated string repeated_string_piece = 54; + repeated string repeated_cord = 55 [features.(pb.cpp).string_type = CORD]; + + // Packed + repeated int32 packed_int32 = 75 [features.repeated_field_encoding = PACKED]; + repeated int64 packed_int64 = 76 [features.repeated_field_encoding = PACKED]; + repeated uint32 packed_uint32 = 77 + [features.repeated_field_encoding = PACKED]; + repeated uint64 packed_uint64 = 78 + [features.repeated_field_encoding = PACKED]; + repeated sint32 packed_sint32 = 79 + [features.repeated_field_encoding = PACKED]; + repeated sint64 packed_sint64 = 80 + [features.repeated_field_encoding = PACKED]; + repeated fixed32 packed_fixed32 = 81 + [features.repeated_field_encoding = PACKED]; + repeated fixed64 packed_fixed64 = 82 + [features.repeated_field_encoding = PACKED]; + repeated sfixed32 packed_sfixed32 = 83 + [features.repeated_field_encoding = PACKED]; + repeated sfixed64 packed_sfixed64 = 84 + [features.repeated_field_encoding = PACKED]; + repeated float packed_float = 85 [features.repeated_field_encoding = PACKED]; + repeated double packed_double = 86 + [features.repeated_field_encoding = PACKED]; + repeated bool packed_bool = 87 [features.repeated_field_encoding = PACKED]; + repeated NestedEnum packed_nested_enum = 88 + [features.repeated_field_encoding = PACKED]; + + // Unpacked + repeated int32 unpacked_int32 = 89 + [features.repeated_field_encoding = EXPANDED]; + repeated int64 unpacked_int64 = 90 + [features.repeated_field_encoding = EXPANDED]; + repeated uint32 unpacked_uint32 = 91 + [features.repeated_field_encoding = EXPANDED]; + repeated uint64 unpacked_uint64 = 92 + [features.repeated_field_encoding = EXPANDED]; + repeated sint32 unpacked_sint32 = 93 + [features.repeated_field_encoding = EXPANDED]; + repeated sint64 unpacked_sint64 = 94 + [features.repeated_field_encoding = EXPANDED]; + repeated fixed32 unpacked_fixed32 = 95 + [features.repeated_field_encoding = EXPANDED]; + repeated fixed64 unpacked_fixed64 = 96 + [features.repeated_field_encoding = EXPANDED]; + repeated sfixed32 unpacked_sfixed32 = 97 + [features.repeated_field_encoding = EXPANDED]; + repeated sfixed64 unpacked_sfixed64 = 98 + [features.repeated_field_encoding = EXPANDED]; + repeated float unpacked_float = 99 + [features.repeated_field_encoding = EXPANDED]; + repeated double unpacked_double = 100 + [features.repeated_field_encoding = EXPANDED]; + repeated bool unpacked_bool = 101 + [features.repeated_field_encoding = EXPANDED]; + repeated NestedEnum unpacked_nested_enum = 102 + [features.repeated_field_encoding = EXPANDED]; + + // Map + map map_int32_int32 = 56; + map map_int64_int64 = 57; + map map_uint32_uint32 = 58; + map map_uint64_uint64 = 59; + map map_sint32_sint32 = 60; + map map_sint64_sint64 = 61; + map map_fixed32_fixed32 = 62; + map map_fixed64_fixed64 = 63; + map map_sfixed32_sfixed32 = 64; + map map_sfixed64_sfixed64 = 65; + map map_int32_float = 66; + map map_int32_double = 67; + map map_bool_bool = 68; + map map_string_string = 69; + map map_string_bytes = 70; + map map_string_nested_message = 71; + map map_string_foreign_message = 72; + map map_string_nested_enum = 73; + map map_string_foreign_enum = 74; + + oneof oneof_field { + uint32 oneof_uint32 = 111; + NestedMessage oneof_nested_message = 112; + string oneof_string = 113; + bytes oneof_bytes = 114; + bool oneof_bool = 115; + uint64 oneof_uint64 = 116; + float oneof_float = 117; + double oneof_double = 118; + NestedEnum oneof_enum = 119; + } + + // extensions + extensions 120 to 200; + + // groups + message Data { + int32 group_int32 = 202; + uint32 group_uint32 = 203; + } + + Data data = 201 [features.message_encoding = DELIMITED]; + + // default values + int32 default_int32 = 241 [default = -123456789]; + int64 default_int64 = 242 [default = -9123456789123456789]; + uint32 default_uint32 = 243 [default = 2123456789]; + uint64 default_uint64 = 244 [default = 10123456789123456789]; + sint32 default_sint32 = 245 [default = -123456789]; + sint64 default_sint64 = 246 [default = -9123456789123456789]; + fixed32 default_fixed32 = 247 [default = 2123456789]; + fixed64 default_fixed64 = 248 [default = 10123456789123456789]; + sfixed32 default_sfixed32 = 249 [default = -123456789]; + sfixed64 default_sfixed64 = 250 [default = -9123456789123456789]; + float default_float = 251 [default = 9e9]; + double default_double = 252 [default = 7e22]; + bool default_bool = 253 [default = true]; + string default_string = 254 [default = "Rosebud"]; + bytes default_bytes = 255 [default = "joshua"]; + + // Test field-name-to-JSON-name convention. + // (protobuf says names can be any valid C/C++ identifier.) + int32 fieldname1 = 401; + int32 field_name2 = 402 [features.enforce_naming_style = STYLE_LEGACY]; + int32 _field_name3 = 403 [features.enforce_naming_style = STYLE_LEGACY]; + int32 field__name4_ = 404 [features.enforce_naming_style = STYLE_LEGACY]; + int32 field0name5 = 405 [features.enforce_naming_style = STYLE_LEGACY]; + int32 field_0_name6 = 406 [features.enforce_naming_style = STYLE_LEGACY]; + int32 fieldName7 = 407 [features.enforce_naming_style = STYLE_LEGACY]; + int32 FieldName8 = 408 [features.enforce_naming_style = STYLE_LEGACY]; + int32 field_Name9 = 409 [features.enforce_naming_style = STYLE_LEGACY]; + int32 Field_Name10 = 410 [features.enforce_naming_style = STYLE_LEGACY]; + int32 FIELD_NAME11 = 411 [features.enforce_naming_style = STYLE_LEGACY]; + int32 FIELD_name12 = 412 [features.enforce_naming_style = STYLE_LEGACY]; + int32 __field_name13 = 413 [features.enforce_naming_style = STYLE_LEGACY]; + int32 __Field_name14 = 414 [features.enforce_naming_style = STYLE_LEGACY]; + int32 field__name15 = 415 [features.enforce_naming_style = STYLE_LEGACY]; + int32 field__Name16 = 416 [features.enforce_naming_style = STYLE_LEGACY]; + int32 field_name17__ = 417 [features.enforce_naming_style = STYLE_LEGACY]; + int32 Field_name18__ = 418 [features.enforce_naming_style = STYLE_LEGACY]; + + // Reserved for unknown fields test. + reserved 1000 to 9999; + + // message_set test case. + message MessageSetCorrect { + option message_set_wire_format = true; + + extensions 4 to max; + } + + message MessageSetCorrectExtension1 { + extend MessageSetCorrect { + MessageSetCorrectExtension1 message_set_extension = 1547769; + } + string str = 25; + } + + message MessageSetCorrectExtension2 { + extend MessageSetCorrect { + MessageSetCorrectExtension2 message_set_extension = 4135312; + } + int32 i = 9; + } +} + +message ForeignMessageEdition { + int32 c = 1; +} + +enum ForeignEnumEdition { + FOREIGN_FOO = 0; + FOREIGN_BAR = 1; + FOREIGN_BAZ = 2; +} + +extend TestAllTypesEdition { + int32 extension_int32 = 120; +} + +message UnknownToTestAllTypes { + int32 optional_int32 = 1001; + string optional_string = 1002; + ForeignMessageEdition nested_message = 1003; + message OptionalGroup { + int32 a = 1; + } + OptionalGroup optionalgroup = 1004 [features.message_encoding = DELIMITED]; + bool optional_bool = 1006; + repeated int32 repeated_int32 = 1011; +} + +message NullHypothesisEdition {} + +message EnumOnlyEdition { + enum Bool { + option features.enforce_naming_style = STYLE_LEGACY; + + kFalse = 0; + kTrue = 1; + } +} + +message OneStringEdition { + string data = 1; +} + +message ProtoWithKeywords { + int32 inline = 1; + string concept = 2; + repeated string requires = 3; +} + +message TestAllRequiredTypesEdition { + message NestedMessage { + int32 a = 1 [features.field_presence = LEGACY_REQUIRED]; + TestAllRequiredTypesEdition corecursive = 2 + [features.field_presence = LEGACY_REQUIRED]; + TestAllRequiredTypesEdition optional_corecursive = 3; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + NEG = -1; // Intentionally negative. + } + + // Singular + int32 required_int32 = 1 [features.field_presence = LEGACY_REQUIRED]; + int64 required_int64 = 2 [features.field_presence = LEGACY_REQUIRED]; + uint32 required_uint32 = 3 [features.field_presence = LEGACY_REQUIRED]; + uint64 required_uint64 = 4 [features.field_presence = LEGACY_REQUIRED]; + sint32 required_sint32 = 5 [features.field_presence = LEGACY_REQUIRED]; + sint64 required_sint64 = 6 [features.field_presence = LEGACY_REQUIRED]; + fixed32 required_fixed32 = 7 [features.field_presence = LEGACY_REQUIRED]; + fixed64 required_fixed64 = 8 [features.field_presence = LEGACY_REQUIRED]; + sfixed32 required_sfixed32 = 9 [features.field_presence = LEGACY_REQUIRED]; + sfixed64 required_sfixed64 = 10 [features.field_presence = LEGACY_REQUIRED]; + float required_float = 11 [features.field_presence = LEGACY_REQUIRED]; + double required_double = 12 [features.field_presence = LEGACY_REQUIRED]; + bool required_bool = 13 [features.field_presence = LEGACY_REQUIRED]; + string required_string = 14 [features.field_presence = LEGACY_REQUIRED]; + bytes required_bytes = 15 [features.field_presence = LEGACY_REQUIRED]; + + NestedMessage required_nested_message = 18 + [features.field_presence = LEGACY_REQUIRED]; + ForeignMessageEdition required_foreign_message = 19 + [features.field_presence = LEGACY_REQUIRED]; + + NestedEnum required_nested_enum = 21 + [features.field_presence = LEGACY_REQUIRED]; + ForeignEnumEdition required_foreign_enum = 22 + [features.field_presence = LEGACY_REQUIRED]; + + string required_string_piece = 24 + [features.field_presence = LEGACY_REQUIRED]; + string required_cord = 25 [ + features.(pb.cpp).string_type = CORD, + features.field_presence = LEGACY_REQUIRED + ]; + + TestAllRequiredTypesEdition recursive_message = 27; + TestAllRequiredTypesEdition optional_recursive_message = 28; + + // extensions + extensions 120 to 200; + + // groups + message Data { + int32 group_int32 = 202 [features.field_presence = LEGACY_REQUIRED]; + uint32 group_uint32 = 203 [features.field_presence = LEGACY_REQUIRED]; + } + + Data data = 201 [features.message_encoding = DELIMITED]; + + // default values + int32 default_int32 = 241 + [default = -123456789, features.field_presence = LEGACY_REQUIRED]; + int64 default_int64 = 242 [ + default = -9123456789123456789, + features.field_presence = LEGACY_REQUIRED + ]; + uint32 default_uint32 = 243 + [default = 2123456789, features.field_presence = LEGACY_REQUIRED]; + uint64 default_uint64 = 244 [ + default = 10123456789123456789, + features.field_presence = LEGACY_REQUIRED + ]; + sint32 default_sint32 = 245 + [default = -123456789, features.field_presence = LEGACY_REQUIRED]; + sint64 default_sint64 = 246 [ + default = -9123456789123456789, + features.field_presence = LEGACY_REQUIRED + ]; + fixed32 default_fixed32 = 247 + [default = 2123456789, features.field_presence = LEGACY_REQUIRED]; + fixed64 default_fixed64 = 248 [ + default = 10123456789123456789, + features.field_presence = LEGACY_REQUIRED + ]; + sfixed32 default_sfixed32 = 249 + [default = -123456789, features.field_presence = LEGACY_REQUIRED]; + sfixed64 default_sfixed64 = 250 [ + default = -9123456789123456789, + features.field_presence = LEGACY_REQUIRED + ]; + float default_float = 251 + [default = 9e9, features.field_presence = LEGACY_REQUIRED]; + double default_double = 252 + [default = 7e22, features.field_presence = LEGACY_REQUIRED]; + bool default_bool = 253 + [default = true, features.field_presence = LEGACY_REQUIRED]; + string default_string = 254 + [default = "Rosebud", features.field_presence = LEGACY_REQUIRED]; + bytes default_bytes = 255 + [default = "joshua", features.field_presence = LEGACY_REQUIRED]; + + // Reserved for unknown fields test. + reserved 1000 to 9999; + + // message_set test case. + message MessageSetCorrect { + option message_set_wire_format = true; + + extensions 4 to max; + } + + message MessageSetCorrectExtension1 { + extend MessageSetCorrect { + MessageSetCorrectExtension1 message_set_extension = 1547769; + } + string str = 25 [features.field_presence = LEGACY_REQUIRED]; + } + + message MessageSetCorrectExtension2 { + extend MessageSetCorrect { + MessageSetCorrectExtension2 message_set_extension = 4135312; + } + int32 i = 9 [features.field_presence = LEGACY_REQUIRED]; + } +} diff --git a/Protos/google/protobuf/unittest_import_lite.proto b/Protos/upstream/google/protobuf/source_context.proto similarity index 73% rename from Protos/google/protobuf/unittest_import_lite.proto rename to Protos/upstream/google/protobuf/source_context.proto index a7afa4523..135f50fea 100644 --- a/Protos/google/protobuf/unittest_import_lite.proto +++ b/Protos/upstream/google/protobuf/source_context.proto @@ -28,25 +28,21 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Author: kenton@google.com (Kenton Varda) -// -// This is like unittest_import.proto but with optimize_for = LITE_RUNTIME. - -syntax = "proto2"; -package protobuf_unittest_import; +syntax = "proto3"; -option optimize_for = LITE_RUNTIME; +package google.protobuf; option java_package = "com.google.protobuf"; +option java_outer_classname = "SourceContextProto"; +option java_multiple_files = true; +option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option go_package = "google.golang.org/protobuf/types/known/sourcecontextpb"; -import public "google/protobuf/unittest_import_public_lite.proto"; - -message ImportMessageLite { - optional int32 d = 1; -} - -enum ImportEnumLite { - IMPORT_LITE_FOO = 7; - IMPORT_LITE_BAR = 8; - IMPORT_LITE_BAZ = 9; +// `SourceContext` represents information about the source of a +// protobuf element, like the file in which it is defined. +message SourceContext { + // The path-qualified name of the .proto file that contained the associated + // protobuf element. For example: `"google/protobuf/source_context.proto"`. + string file_name = 1; } diff --git a/Protos/upstream/google/protobuf/struct.proto b/Protos/upstream/google/protobuf/struct.proto new file mode 100644 index 000000000..1bf0c1ad9 --- /dev/null +++ b/Protos/upstream/google/protobuf/struct.proto @@ -0,0 +1,95 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +syntax = "proto3"; + +package google.protobuf; + +option cc_enable_arenas = true; +option go_package = "google.golang.org/protobuf/types/known/structpb"; +option java_package = "com.google.protobuf"; +option java_outer_classname = "StructProto"; +option java_multiple_files = true; +option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; + +// `Struct` represents a structured data value, consisting of fields +// which map to dynamically typed values. In some languages, `Struct` +// might be supported by a native representation. For example, in +// scripting languages like JS a struct is represented as an +// object. The details of that representation are described together +// with the proto support for the language. +// +// The JSON representation for `Struct` is JSON object. +message Struct { + // Unordered map of dynamically typed values. + map fields = 1; +} + +// `Value` represents a dynamically typed value which can be either +// null, a number, a string, a boolean, a recursive struct value, or a +// list of values. A producer of value is expected to set one of these +// variants. Absence of any variant indicates an error. +// +// The JSON representation for `Value` is JSON value. +message Value { + // The kind of value. + oneof kind { + // Represents a null value. + NullValue null_value = 1; + // Represents a double value. + double number_value = 2; + // Represents a string value. + string string_value = 3; + // Represents a boolean value. + bool bool_value = 4; + // Represents a structured value. + Struct struct_value = 5; + // Represents a repeated `Value`. + ListValue list_value = 6; + } +} + +// `NullValue` is a singleton enumeration to represent the null value for the +// `Value` type union. +// +// The JSON representation for `NullValue` is JSON `null`. +enum NullValue { + // Null value. + NULL_VALUE = 0; +} + +// `ListValue` is a wrapper around a repeated field of values. +// +// The JSON representation for `ListValue` is JSON array. +message ListValue { + // Repeated field of dynamically typed values. + repeated Value values = 1; +} diff --git a/Protos/upstream/google/protobuf/test_messages_proto2.proto b/Protos/upstream/google/protobuf/test_messages_proto2.proto new file mode 100644 index 000000000..d62480684 --- /dev/null +++ b/Protos/upstream/google/protobuf/test_messages_proto2.proto @@ -0,0 +1,419 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Test schema for proto2 messages. This test schema is used by: +// +// - conformance tests +// + +// LINT: ALLOW_GROUPS + +syntax = "proto2"; + +package protobuf_test_messages.proto2; + +option java_package = "com.google.protobuf_test_messages.proto2"; +option objc_class_prefix = "Proto2"; + +// This is the default, but we specify it here explicitly. +option optimize_for = SPEED; + +option cc_enable_arenas = true; + + +// This proto includes every type of field in both singular and repeated +// forms. +// +// Also, crucially, all messages and enums in this file are eventually +// submessages of this message. So for example, a fuzz test of TestAllTypes +// could trigger bugs that occur in any message type in this file. We verify +// this stays true in a unit test. +message TestAllTypesProto2 { + message NestedMessage { + optional int32 a = 1; + optional TestAllTypesProto2 corecursive = 2; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + NEG = -1; // Intentionally negative. + } + + // Singular + optional int32 optional_int32 = 1; + optional int64 optional_int64 = 2; + optional uint32 optional_uint32 = 3; + optional uint64 optional_uint64 = 4; + optional sint32 optional_sint32 = 5; + optional sint64 optional_sint64 = 6; + optional fixed32 optional_fixed32 = 7; + optional fixed64 optional_fixed64 = 8; + optional sfixed32 optional_sfixed32 = 9; + optional sfixed64 optional_sfixed64 = 10; + optional float optional_float = 11; + optional double optional_double = 12; + optional bool optional_bool = 13; + optional string optional_string = 14; + optional bytes optional_bytes = 15; + + optional NestedMessage optional_nested_message = 18; + optional ForeignMessageProto2 optional_foreign_message = 19; + + optional NestedEnum optional_nested_enum = 21; + optional ForeignEnumProto2 optional_foreign_enum = 22; + + optional string optional_string_piece = 24 [ctype = STRING_PIECE]; + optional string optional_cord = 25 [ctype = CORD]; + + optional TestAllTypesProto2 recursive_message = 27; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + + repeated NestedMessage repeated_nested_message = 48; + repeated ForeignMessageProto2 repeated_foreign_message = 49; + + repeated NestedEnum repeated_nested_enum = 51; + repeated ForeignEnumProto2 repeated_foreign_enum = 52; + + repeated string repeated_string_piece = 54 [ctype = STRING_PIECE]; + repeated string repeated_cord = 55 [ctype = CORD]; + + // Packed + repeated int32 packed_int32 = 75 [packed = true]; + repeated int64 packed_int64 = 76 [packed = true]; + repeated uint32 packed_uint32 = 77 [packed = true]; + repeated uint64 packed_uint64 = 78 [packed = true]; + repeated sint32 packed_sint32 = 79 [packed = true]; + repeated sint64 packed_sint64 = 80 [packed = true]; + repeated fixed32 packed_fixed32 = 81 [packed = true]; + repeated fixed64 packed_fixed64 = 82 [packed = true]; + repeated sfixed32 packed_sfixed32 = 83 [packed = true]; + repeated sfixed64 packed_sfixed64 = 84 [packed = true]; + repeated float packed_float = 85 [packed = true]; + repeated double packed_double = 86 [packed = true]; + repeated bool packed_bool = 87 [packed = true]; + repeated NestedEnum packed_nested_enum = 88 [packed = true]; + + // Unpacked + repeated int32 unpacked_int32 = 89 [packed = false]; + repeated int64 unpacked_int64 = 90 [packed = false]; + repeated uint32 unpacked_uint32 = 91 [packed = false]; + repeated uint64 unpacked_uint64 = 92 [packed = false]; + repeated sint32 unpacked_sint32 = 93 [packed = false]; + repeated sint64 unpacked_sint64 = 94 [packed = false]; + repeated fixed32 unpacked_fixed32 = 95 [packed = false]; + repeated fixed64 unpacked_fixed64 = 96 [packed = false]; + repeated sfixed32 unpacked_sfixed32 = 97 [packed = false]; + repeated sfixed64 unpacked_sfixed64 = 98 [packed = false]; + repeated float unpacked_float = 99 [packed = false]; + repeated double unpacked_double = 100 [packed = false]; + repeated bool unpacked_bool = 101 [packed = false]; + repeated NestedEnum unpacked_nested_enum = 102 [packed = false]; + + // Map + map map_int32_int32 = 56; + map map_int64_int64 = 57; + map map_uint32_uint32 = 58; + map map_uint64_uint64 = 59; + map map_sint32_sint32 = 60; + map map_sint64_sint64 = 61; + map map_fixed32_fixed32 = 62; + map map_fixed64_fixed64 = 63; + map map_sfixed32_sfixed32 = 64; + map map_sfixed64_sfixed64 = 65; + map map_int32_bool = 104; + map map_int32_float = 66; + map map_int32_double = 67; + map map_int32_nested_message = 103; + map map_bool_bool = 68; + map map_string_string = 69; + map map_string_bytes = 70; + map map_string_nested_message = 71; + map map_string_foreign_message = 72; + map map_string_nested_enum = 73; + map map_string_foreign_enum = 74; + + oneof oneof_field { + uint32 oneof_uint32 = 111; + NestedMessage oneof_nested_message = 112; + string oneof_string = 113; + bytes oneof_bytes = 114; + bool oneof_bool = 115; + uint64 oneof_uint64 = 116; + float oneof_float = 117; + double oneof_double = 118; + NestedEnum oneof_enum = 119; + } + + // extensions + extensions 120 to 200; + + // groups + optional group Data = 201 { + optional int32 group_int32 = 202; + optional uint32 group_uint32 = 203; + } + + optional group MultiWordGroupField = 204 { + optional int32 group_int32 = 205; + optional uint32 group_uint32 = 206; + } + + // default values + optional int32 default_int32 = 241 [default = -123456789]; + optional int64 default_int64 = 242 [default = -9123456789123456789]; + optional uint32 default_uint32 = 243 [default = 2123456789]; + optional uint64 default_uint64 = 244 [default = 10123456789123456789]; + optional sint32 default_sint32 = 245 [default = -123456789]; + optional sint64 default_sint64 = 246 [default = -9123456789123456789]; + optional fixed32 default_fixed32 = 247 [default = 2123456789]; + optional fixed64 default_fixed64 = 248 [default = 10123456789123456789]; + optional sfixed32 default_sfixed32 = 249 [default = -123456789]; + optional sfixed64 default_sfixed64 = 250 [default = -9123456789123456789]; + optional float default_float = 251 [default = 9e9]; + optional double default_double = 252 [default = 7e22]; + optional bool default_bool = 253 [default = true]; + optional string default_string = 254 [default = "Rosebud"]; + optional bytes default_bytes = 255 [default = "joshua"]; + + // Test field-name-to-JSON-name convention. + // (protobuf says names can be any valid C/C++ identifier.) + optional int32 fieldname1 = 401; + optional int32 field_name2 = 402; + optional int32 _field_name3 = 403; + optional int32 field__name4_ = 404; + optional int32 field0name5 = 405; + optional int32 field_0_name6 = 406; + optional int32 fieldName7 = 407; + optional int32 FieldName8 = 408; + optional int32 field_Name9 = 409; + optional int32 Field_Name10 = 410; + optional int32 FIELD_NAME11 = 411; + optional int32 FIELD_name12 = 412; + optional int32 __field_name13 = 413; + optional int32 __Field_name14 = 414; + optional int32 field__name15 = 415; + optional int32 field__Name16 = 416; + optional int32 field_name17__ = 417; + optional int32 Field_name18__ = 418; + + // Reserved for unknown fields test. + reserved 1000 to 9999; + + optional MessageSetCorrect message_set_correct = 500; + + // message_set test case. + message MessageSetCorrect { + option message_set_wire_format = true; + + extensions 4 to max; + } + + message MessageSetCorrectExtension1 { + extend MessageSetCorrect { + optional MessageSetCorrectExtension1 message_set_extension = 1547769; + } + optional string str = 25; + } + + message MessageSetCorrectExtension2 { + extend MessageSetCorrect { + optional MessageSetCorrectExtension2 message_set_extension = 4135312; + } + optional int32 i = 9; + } + + message ExtensionWithOneof { + oneof oneof_field { + int32 a = 1; + int32 b = 2; + } + extend MessageSetCorrect { + optional ExtensionWithOneof extension_with_oneof = 123456789; + } + } + + reserved "reserved_field"; + reserved 999999; +} + +message ForeignMessageProto2 { + optional int32 c = 1; +} + +enum ForeignEnumProto2 { + FOREIGN_FOO = 0; + FOREIGN_BAR = 1; + FOREIGN_BAZ = 2; +} + +extend TestAllTypesProto2 { + optional int32 extension_int32 = 120; +} + +extend TestAllTypesProto2 { + optional group GroupField = 121 { + optional int32 group_int32 = 122; + optional uint32 group_uint32 = 123; + } +} + +message UnknownToTestAllTypes { + optional int32 optional_int32 = 1001; + optional string optional_string = 1002; + optional ForeignMessageProto2 nested_message = 1003; + optional group OptionalGroup = 1004 { + optional int32 a = 1; + } + optional bool optional_bool = 1006; + repeated int32 repeated_int32 = 1011; +} + +message NullHypothesisProto2 {} + +message EnumOnlyProto2 { + enum Bool { + kFalse = 0; + kTrue = 1; + } +} + +message OneStringProto2 { + optional string data = 1; +} + +message ProtoWithKeywords { + optional int32 inline = 1; + optional string concept = 2; + repeated string requires = 3; +} + +message TestAllRequiredTypesProto2 { + message NestedMessage { + required int32 a = 1; + required TestAllRequiredTypesProto2 corecursive = 2; + optional TestAllRequiredTypesProto2 optional_corecursive = 3; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + NEG = -1; // Intentionally negative. + } + + // Singular + required int32 required_int32 = 1; + required int64 required_int64 = 2; + required uint32 required_uint32 = 3; + required uint64 required_uint64 = 4; + required sint32 required_sint32 = 5; + required sint64 required_sint64 = 6; + required fixed32 required_fixed32 = 7; + required fixed64 required_fixed64 = 8; + required sfixed32 required_sfixed32 = 9; + required sfixed64 required_sfixed64 = 10; + required float required_float = 11; + required double required_double = 12; + required bool required_bool = 13; + required string required_string = 14; + required bytes required_bytes = 15; + + required NestedMessage required_nested_message = 18; + required ForeignMessageProto2 required_foreign_message = 19; + + required NestedEnum required_nested_enum = 21; + required ForeignEnumProto2 required_foreign_enum = 22; + + required string required_string_piece = 24 [ctype = STRING_PIECE]; + required string required_cord = 25 [ctype = CORD]; + + required TestAllRequiredTypesProto2 recursive_message = 27; + optional TestAllRequiredTypesProto2 optional_recursive_message = 28; + + // extensions + extensions 120 to 200; + + // groups + required group Data = 201 { + required int32 group_int32 = 202; + required uint32 group_uint32 = 203; + } + + // default values + required int32 default_int32 = 241 [default = -123456789]; + required int64 default_int64 = 242 [default = -9123456789123456789]; + required uint32 default_uint32 = 243 [default = 2123456789]; + required uint64 default_uint64 = 244 [default = 10123456789123456789]; + required sint32 default_sint32 = 245 [default = -123456789]; + required sint64 default_sint64 = 246 [default = -9123456789123456789]; + required fixed32 default_fixed32 = 247 [default = 2123456789]; + required fixed64 default_fixed64 = 248 [default = 10123456789123456789]; + required sfixed32 default_sfixed32 = 249 [default = -123456789]; + required sfixed64 default_sfixed64 = 250 [default = -9123456789123456789]; + required float default_float = 251 [default = 9e9]; + required double default_double = 252 [default = 7e22]; + required bool default_bool = 253 [default = true]; + required string default_string = 254 [default = "Rosebud"]; + required bytes default_bytes = 255 [default = "joshua"]; + + // Reserved for unknown fields test. + reserved 1000 to 9999; + + // message_set test case. + message MessageSetCorrect { + option message_set_wire_format = true; + + extensions 4 to max; + } + + message MessageSetCorrectExtension1 { + extend MessageSetCorrect { + optional MessageSetCorrectExtension1 message_set_extension = 1547769; + } + required string str = 25; + } + + message MessageSetCorrectExtension2 { + extend MessageSetCorrect { + optional MessageSetCorrectExtension2 message_set_extension = 4135312; + } + required int32 i = 9; + } +} + +message TestLargeOneof { + message A1 {} + message A2 {} + message A3 {} + message A4 {} + message A5 {} + oneof large_oneof { + A1 a1 = 1; + A2 a2 = 2; + A3 a3 = 3; + A4 a4 = 4; + A5 a5 = 5; + } +} diff --git a/Protos/upstream/google/protobuf/test_messages_proto3.proto b/Protos/upstream/google/protobuf/test_messages_proto3.proto new file mode 100644 index 000000000..6d29b1b38 --- /dev/null +++ b/Protos/upstream/google/protobuf/test_messages_proto3.proto @@ -0,0 +1,269 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Test schema for proto3 messages. This test schema is used by: +// +// - benchmarks +// - fuzz tests +// - conformance tests +// + +syntax = "proto3"; + +package protobuf_test_messages.proto3; + +option java_package = "com.google.protobuf_test_messages.proto3"; +option objc_class_prefix = "Proto3"; + +// This is the default, but we specify it here explicitly. +option optimize_for = SPEED; + +import "google/protobuf/any.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/field_mask.proto"; +import "google/protobuf/struct.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/wrappers.proto"; + +option cc_enable_arenas = true; + +// This proto includes every type of field in both singular and repeated +// forms. +// +// Also, crucially, all messages and enums in this file are eventually +// submessages of this message. So for example, a fuzz test of TestAllTypes +// could trigger bugs that occur in any message type in this file. We verify +// this stays true in a unit test. +message TestAllTypesProto3 { + message NestedMessage { + int32 a = 1; + TestAllTypesProto3 corecursive = 2; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + NEG = -1; // Intentionally negative. + } + + enum AliasedEnum { + option allow_alias = true; + + ALIAS_FOO = 0; + ALIAS_BAR = 1; + ALIAS_BAZ = 2; + MOO = 2; + moo = 2; + bAz = 2; + } + + // Singular + // test [kotlin] comment + int32 optional_int32 = 1; + int64 optional_int64 = 2; + uint32 optional_uint32 = 3; + uint64 optional_uint64 = 4; + sint32 optional_sint32 = 5; + sint64 optional_sint64 = 6; + fixed32 optional_fixed32 = 7; + fixed64 optional_fixed64 = 8; + sfixed32 optional_sfixed32 = 9; + sfixed64 optional_sfixed64 = 10; + float optional_float = 11; + double optional_double = 12; + bool optional_bool = 13; + string optional_string = 14; + bytes optional_bytes = 15; + + NestedMessage optional_nested_message = 18; + ForeignMessage optional_foreign_message = 19; + + NestedEnum optional_nested_enum = 21; + ForeignEnum optional_foreign_enum = 22; + AliasedEnum optional_aliased_enum = 23; + + string optional_string_piece = 24 [ctype = STRING_PIECE]; + string optional_cord = 25 [ctype = CORD]; + + TestAllTypesProto3 recursive_message = 27; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + + repeated NestedMessage repeated_nested_message = 48; + repeated ForeignMessage repeated_foreign_message = 49; + + repeated NestedEnum repeated_nested_enum = 51; + repeated ForeignEnum repeated_foreign_enum = 52; + + repeated string repeated_string_piece = 54 [ctype = STRING_PIECE]; + repeated string repeated_cord = 55 [ctype = CORD]; + + // Packed + repeated int32 packed_int32 = 75 [packed = true]; + repeated int64 packed_int64 = 76 [packed = true]; + repeated uint32 packed_uint32 = 77 [packed = true]; + repeated uint64 packed_uint64 = 78 [packed = true]; + repeated sint32 packed_sint32 = 79 [packed = true]; + repeated sint64 packed_sint64 = 80 [packed = true]; + repeated fixed32 packed_fixed32 = 81 [packed = true]; + repeated fixed64 packed_fixed64 = 82 [packed = true]; + repeated sfixed32 packed_sfixed32 = 83 [packed = true]; + repeated sfixed64 packed_sfixed64 = 84 [packed = true]; + repeated float packed_float = 85 [packed = true]; + repeated double packed_double = 86 [packed = true]; + repeated bool packed_bool = 87 [packed = true]; + repeated NestedEnum packed_nested_enum = 88 [packed = true]; + + // Unpacked + repeated int32 unpacked_int32 = 89 [packed = false]; + repeated int64 unpacked_int64 = 90 [packed = false]; + repeated uint32 unpacked_uint32 = 91 [packed = false]; + repeated uint64 unpacked_uint64 = 92 [packed = false]; + repeated sint32 unpacked_sint32 = 93 [packed = false]; + repeated sint64 unpacked_sint64 = 94 [packed = false]; + repeated fixed32 unpacked_fixed32 = 95 [packed = false]; + repeated fixed64 unpacked_fixed64 = 96 [packed = false]; + repeated sfixed32 unpacked_sfixed32 = 97 [packed = false]; + repeated sfixed64 unpacked_sfixed64 = 98 [packed = false]; + repeated float unpacked_float = 99 [packed = false]; + repeated double unpacked_double = 100 [packed = false]; + repeated bool unpacked_bool = 101 [packed = false]; + repeated NestedEnum unpacked_nested_enum = 102 [packed = false]; + + // Map + map map_int32_int32 = 56; + map map_int64_int64 = 57; + map map_uint32_uint32 = 58; + map map_uint64_uint64 = 59; + map map_sint32_sint32 = 60; + map map_sint64_sint64 = 61; + map map_fixed32_fixed32 = 62; + map map_fixed64_fixed64 = 63; + map map_sfixed32_sfixed32 = 64; + map map_sfixed64_sfixed64 = 65; + map map_int32_float = 66; + map map_int32_double = 67; + map map_bool_bool = 68; + map map_string_string = 69; + map map_string_bytes = 70; + map map_string_nested_message = 71; + map map_string_foreign_message = 72; + map map_string_nested_enum = 73; + map map_string_foreign_enum = 74; + + oneof oneof_field { + uint32 oneof_uint32 = 111; + NestedMessage oneof_nested_message = 112; + string oneof_string = 113; + bytes oneof_bytes = 114; + bool oneof_bool = 115; + uint64 oneof_uint64 = 116; + float oneof_float = 117; + double oneof_double = 118; + NestedEnum oneof_enum = 119; + google.protobuf.NullValue oneof_null_value = 120; + } + + // Well-known types + google.protobuf.BoolValue optional_bool_wrapper = 201; + google.protobuf.Int32Value optional_int32_wrapper = 202; + google.protobuf.Int64Value optional_int64_wrapper = 203; + google.protobuf.UInt32Value optional_uint32_wrapper = 204; + google.protobuf.UInt64Value optional_uint64_wrapper = 205; + google.protobuf.FloatValue optional_float_wrapper = 206; + google.protobuf.DoubleValue optional_double_wrapper = 207; + google.protobuf.StringValue optional_string_wrapper = 208; + google.protobuf.BytesValue optional_bytes_wrapper = 209; + + repeated google.protobuf.BoolValue repeated_bool_wrapper = 211; + repeated google.protobuf.Int32Value repeated_int32_wrapper = 212; + repeated google.protobuf.Int64Value repeated_int64_wrapper = 213; + repeated google.protobuf.UInt32Value repeated_uint32_wrapper = 214; + repeated google.protobuf.UInt64Value repeated_uint64_wrapper = 215; + repeated google.protobuf.FloatValue repeated_float_wrapper = 216; + repeated google.protobuf.DoubleValue repeated_double_wrapper = 217; + repeated google.protobuf.StringValue repeated_string_wrapper = 218; + repeated google.protobuf.BytesValue repeated_bytes_wrapper = 219; + + google.protobuf.Duration optional_duration = 301; + google.protobuf.Timestamp optional_timestamp = 302; + google.protobuf.FieldMask optional_field_mask = 303; + google.protobuf.Struct optional_struct = 304; + google.protobuf.Any optional_any = 305; + google.protobuf.Value optional_value = 306; + google.protobuf.NullValue optional_null_value = 307; + + repeated google.protobuf.Duration repeated_duration = 311; + repeated google.protobuf.Timestamp repeated_timestamp = 312; + repeated google.protobuf.FieldMask repeated_fieldmask = 313; + repeated google.protobuf.Struct repeated_struct = 324; + repeated google.protobuf.Any repeated_any = 315; + repeated google.protobuf.Value repeated_value = 316; + repeated google.protobuf.ListValue repeated_list_value = 317; + + // Test field-name-to-JSON-name convention. + // (protobuf says names can be any valid C/C++ identifier.) + int32 fieldname1 = 401; + int32 field_name2 = 402; + int32 _field_name3 = 403; + int32 field__name4_ = 404; + int32 field0name5 = 405; + int32 field_0_name6 = 406; + int32 fieldName7 = 407; + int32 FieldName8 = 408; + int32 field_Name9 = 409; + int32 Field_Name10 = 410; + int32 FIELD_NAME11 = 411; + int32 FIELD_name12 = 412; + int32 __field_name13 = 413; + int32 __Field_name14 = 414; + int32 field__name15 = 415; + int32 field__Name16 = 416; + int32 field_name17__ = 417; + int32 Field_name18__ = 418; + + // Reserved for testing unknown fields + reserved 501 to 510; + + reserved "reserved_field"; + reserved 999999; +} + +message ForeignMessage { + int32 c = 1; +} + +enum ForeignEnum { + FOREIGN_FOO = 0; + FOREIGN_BAR = 1; + FOREIGN_BAZ = 2; +} + +message NullHypothesisProto3 {} + +message EnumOnlyProto3 { + enum Bool { + kFalse = 0; + kTrue = 1; + } +} diff --git a/Protos/upstream/google/protobuf/timestamp.proto b/Protos/upstream/google/protobuf/timestamp.proto new file mode 100644 index 000000000..6bc1efc6d --- /dev/null +++ b/Protos/upstream/google/protobuf/timestamp.proto @@ -0,0 +1,145 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +syntax = "proto3"; + +package google.protobuf; + +option cc_enable_arenas = true; +option go_package = "google.golang.org/protobuf/types/known/timestamppb"; +option java_package = "com.google.protobuf"; +option java_outer_classname = "TimestampProto"; +option java_multiple_files = true; +option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; + +// A Timestamp represents a point in time independent of any time zone or local +// calendar, encoded as a count of seconds and fractions of seconds at +// nanosecond resolution. The count is relative to an epoch at UTC midnight on +// January 1, 1970, in the proleptic Gregorian calendar which extends the +// Gregorian calendar backwards to year one. +// +// All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap +// second table is needed for interpretation, using a [24-hour linear +// smear](https://developers.google.com/time/smear). +// +// The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By +// restricting to that range, we ensure that we can convert to and from [RFC +// 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. +// +// # Examples +// +// Example 1: Compute Timestamp from POSIX `time()`. +// +// Timestamp timestamp; +// timestamp.set_seconds(time(NULL)); +// timestamp.set_nanos(0); +// +// Example 2: Compute Timestamp from POSIX `gettimeofday()`. +// +// struct timeval tv; +// gettimeofday(&tv, NULL); +// +// Timestamp timestamp; +// timestamp.set_seconds(tv.tv_sec); +// timestamp.set_nanos(tv.tv_usec * 1000); +// +// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. +// +// FILETIME ft; +// GetSystemTimeAsFileTime(&ft); +// UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; +// +// // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z +// // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. +// Timestamp timestamp; +// timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); +// timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); +// +// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. +// +// long millis = System.currentTimeMillis(); +// +// Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) +// .setNanos((int) ((millis % 1000) * 1000000)).build(); +// +// Example 5: Compute Timestamp from Java `Instant.now()`. +// +// Instant now = Instant.now(); +// +// Timestamp timestamp = +// Timestamp.newBuilder().setSeconds(now.getEpochSecond()) +// .setNanos(now.getNano()).build(); +// +// Example 6: Compute Timestamp from current time in Python. +// +// timestamp = Timestamp() +// timestamp.GetCurrentTime() +// +// # JSON Mapping +// +// In JSON format, the Timestamp type is encoded as a string in the +// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the +// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" +// where {year} is always expressed using four digits while {month}, {day}, +// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional +// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), +// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone +// is required. A ProtoJSON serializer should always use UTC (as indicated by +// "Z") when printing the Timestamp type and a ProtoJSON parser should be +// able to accept both UTC and other timezones (as indicated by an offset). +// +// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past +// 01:30 UTC on January 15, 2017. +// +// In JavaScript, one can convert a Date object to this format using the +// standard +// [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) +// method. In Python, a standard `datetime.datetime` object can be converted +// to this format using +// [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with +// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use +// the Joda Time's [`ISODateTimeFormat.dateTime()`]( +// http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime() +// ) to obtain a formatter capable of generating timestamps in this format. +// +message Timestamp { + // Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must + // be between -62135596800 and 253402300799 inclusive (which corresponds to + // 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z). + int64 seconds = 1; + + // Non-negative fractions of a second at nanosecond resolution. This field is + // the nanosecond portion of the duration, not an alternative to seconds. + // Negative second values with fractions must still have non-negative nanos + // values that count forward in time. Must be between 0 and 999,999,999 + // inclusive. + int32 nanos = 2; +} diff --git a/Protos/upstream/google/protobuf/type.proto b/Protos/upstream/google/protobuf/type.proto new file mode 100644 index 000000000..2c7615ed6 --- /dev/null +++ b/Protos/upstream/google/protobuf/type.proto @@ -0,0 +1,217 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +syntax = "proto3"; + +package google.protobuf; + +import "google/protobuf/any.proto"; +import "google/protobuf/source_context.proto"; + +option cc_enable_arenas = true; +option java_package = "com.google.protobuf"; +option java_outer_classname = "TypeProto"; +option java_multiple_files = true; +option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option go_package = "google.golang.org/protobuf/types/known/typepb"; + +// A protocol buffer message type. +// +// New usages of this message as an alternative to DescriptorProto are strongly +// discouraged. This message does not reliability preserve all information +// necessary to model the schema and preserve semantics. Instead make use of +// FileDescriptorSet which preserves the necessary information. +message Type { + // The fully qualified message name. + string name = 1; + // The list of fields. + repeated Field fields = 2; + // The list of types appearing in `oneof` definitions in this type. + repeated string oneofs = 3; + // The protocol buffer options. + repeated Option options = 4; + // The source context. + SourceContext source_context = 5; + // The source syntax. + Syntax syntax = 6; + // The source edition string, only valid when syntax is SYNTAX_EDITIONS. + string edition = 7; +} + +// A single field of a message type. +// +// New usages of this message as an alternative to FieldDescriptorProto are +// strongly discouraged. This message does not reliability preserve all +// information necessary to model the schema and preserve semantics. Instead +// make use of FileDescriptorSet which preserves the necessary information. +message Field { + // Basic field types. + enum Kind { + // Field type unknown. + TYPE_UNKNOWN = 0; + // Field type double. + TYPE_DOUBLE = 1; + // Field type float. + TYPE_FLOAT = 2; + // Field type int64. + TYPE_INT64 = 3; + // Field type uint64. + TYPE_UINT64 = 4; + // Field type int32. + TYPE_INT32 = 5; + // Field type fixed64. + TYPE_FIXED64 = 6; + // Field type fixed32. + TYPE_FIXED32 = 7; + // Field type bool. + TYPE_BOOL = 8; + // Field type string. + TYPE_STRING = 9; + // Field type group. Proto2 syntax only, and deprecated. + TYPE_GROUP = 10; + // Field type message. + TYPE_MESSAGE = 11; + // Field type bytes. + TYPE_BYTES = 12; + // Field type uint32. + TYPE_UINT32 = 13; + // Field type enum. + TYPE_ENUM = 14; + // Field type sfixed32. + TYPE_SFIXED32 = 15; + // Field type sfixed64. + TYPE_SFIXED64 = 16; + // Field type sint32. + TYPE_SINT32 = 17; + // Field type sint64. + TYPE_SINT64 = 18; + } + + // Whether a field is optional, required, or repeated. + enum Cardinality { + // For fields with unknown cardinality. + CARDINALITY_UNKNOWN = 0; + // For optional fields. + CARDINALITY_OPTIONAL = 1; + // For required fields. Proto2 syntax only. + CARDINALITY_REQUIRED = 2; + // For repeated fields. + CARDINALITY_REPEATED = 3; + } + + // The field type. + Kind kind = 1; + // The field cardinality. + Cardinality cardinality = 2; + // The field number. + int32 number = 3; + // The field name. + string name = 4; + // The field type URL, without the scheme, for message or enumeration + // types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`. + string type_url = 6; + // The index of the field type in `Type.oneofs`, for message or enumeration + // types. The first type has index 1; zero means the type is not in the list. + int32 oneof_index = 7; + // Whether to use alternative packed wire representation. + bool packed = 8; + // The protocol buffer options. + repeated Option options = 9; + // The field JSON name. + string json_name = 10; + // The string value of the default value of this field. Proto2 syntax only. + string default_value = 11; +} + +// Enum type definition. +// +// New usages of this message as an alternative to EnumDescriptorProto are +// strongly discouraged. This message does not reliability preserve all +// information necessary to model the schema and preserve semantics. Instead +// make use of FileDescriptorSet which preserves the necessary information. +message Enum { + // Enum type name. + string name = 1; + // Enum value definitions. + repeated EnumValue enumvalue = 2; + // Protocol buffer options. + repeated Option options = 3; + // The source context. + SourceContext source_context = 4; + // The source syntax. + Syntax syntax = 5; + // The source edition string, only valid when syntax is SYNTAX_EDITIONS. + string edition = 6; +} + +// Enum value definition. +// +// New usages of this message as an alternative to EnumValueDescriptorProto are +// strongly discouraged. This message does not reliability preserve all +// information necessary to model the schema and preserve semantics. Instead +// make use of FileDescriptorSet which preserves the necessary information. +message EnumValue { + // Enum value name. + string name = 1; + // Enum value number. + int32 number = 2; + // Protocol buffer options. + repeated Option options = 3; +} + +// A protocol buffer option, which can be attached to a message, field, +// enumeration, etc. +// +// New usages of this message as an alternative to FileOptions, MessageOptions, +// FieldOptions, EnumOptions, EnumValueOptions, ServiceOptions, or MethodOptions +// are strongly discouraged. +message Option { + // The option's name. For protobuf built-in options (options defined in + // descriptor.proto), this is the short name. For example, `"map_entry"`. + // For custom options, it should be the fully-qualified name. For example, + // `"google.api.http"`. + string name = 1; + // The option's value packed in an Any message. If the value is a primitive, + // the corresponding wrapper type defined in google/protobuf/wrappers.proto + // should be used. If the value is an enum, it should be stored as an int32 + // value using the google.protobuf.Int32Value type. + Any value = 2; +} + +// The syntax in which a protocol buffer element is defined. +enum Syntax { + // Syntax `proto2`. + SYNTAX_PROTO2 = 0; + // Syntax `proto3`. + SYNTAX_PROTO3 = 1; + // Syntax `editions`. + SYNTAX_EDITIONS = 2; +} diff --git a/Protos/upstream/google/protobuf/unittest.proto b/Protos/upstream/google/protobuf/unittest.proto new file mode 100644 index 000000000..683251b4d --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest.proto @@ -0,0 +1,2714 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// A proto file we will use for unit testing. +// +// LINT: ALLOW_GROUPS, LEGACY_NAMES + +edition = "2023"; + +// We don't put this in a package within proto2 because we need to make sure +// that the generated code doesn't depend on being in the proto2 namespace. +// In test_util.h we do "using namespace unittest = proto2_unittest". +package proto2_unittest; + +import "google/protobuf/unittest_import.proto"; + +option features = { + enum_type: CLOSED + repeated_field_encoding: EXPANDED + utf8_validation: NONE +}; + +// Some generic_services option(s) added automatically. +// See: http://go/proto2-generic-services-default +option cc_generic_services = true; // auto-added +option java_generic_services = true; // auto-added +option py_generic_services = true; // auto-added +option cc_enable_arenas = true; + +// Protos optimized for SPEED use a strict superset of the generated code +// of equivalent ones optimized for CODE_SIZE, so we should optimize all our +// tests for speed unless explicitly testing code size optimization. +option optimize_for = SPEED; +option java_outer_classname = "UnittestProto"; + +// This proto includes every type of field in both singular and repeated +// forms. +message TestAllTypes { + message NestedMessage { + // The field name "b" fails to compile in proto1 because it conflicts with + // a local variable named "b" in one of the generated methods. Doh. + // This file needs to compile in proto1 to test backwards-compatibility. + int32 bb = 1; + } + + enum NestedEnum { + FOO = 1; + BAR = 2; + BAZ = 3; + NEG = -1; // Intentionally negative. + } + + // Singular + int32 optional_int32 = 1; + int64 optional_int64 = 2; + uint32 optional_uint32 = 3; + uint64 optional_uint64 = 4; + sint32 optional_sint32 = 5; + sint64 optional_sint64 = 6; + fixed32 optional_fixed32 = 7; + fixed64 optional_fixed64 = 8; + sfixed32 optional_sfixed32 = 9; + sfixed64 optional_sfixed64 = 10; + float optional_float = 11; + double optional_double = 12; + bool optional_bool = 13; + string optional_string = 14; + bytes optional_bytes = 15; + + message OptionalGroup { + int32 a = 17; + } + + OptionalGroup optionalgroup = 16 [ + features.message_encoding = DELIMITED + ]; + + NestedMessage optional_nested_message = 18; + ForeignMessage optional_foreign_message = 19; + proto2_unittest_import.ImportMessage optional_import_message = 20; + NestedEnum optional_nested_enum = 21; + ForeignEnum optional_foreign_enum = 22; + proto2_unittest_import.ImportEnum optional_import_enum = 23; + string optional_string_piece = 24 [ + ctype = STRING_PIECE + ]; + + string optional_cord = 25 [ + ctype = CORD + ]; + bytes optional_bytes_cord = 86 [ctype=CORD]; + + // Defined in unittest_import_public.proto + proto2_unittest_import.PublicImportMessage optional_public_import_message = 26; + NestedMessage optional_lazy_message = 27 [ + lazy = true + ]; + + NestedMessage optional_unverified_lazy_message = 28 [ + unverified_lazy = true + ]; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + + message RepeatedGroup { + int32 a = 47; + } + + repeated RepeatedGroup repeatedgroup = 46 [ + features.message_encoding = DELIMITED + ]; + + repeated NestedMessage repeated_nested_message = 48; + repeated ForeignMessage repeated_foreign_message = 49; + repeated proto2_unittest_import.ImportMessage repeated_import_message = 50; + repeated NestedEnum repeated_nested_enum = 51; + repeated ForeignEnum repeated_foreign_enum = 52; + repeated proto2_unittest_import.ImportEnum repeated_import_enum = 53; + repeated string repeated_string_piece = 54 [ + ctype = STRING_PIECE + ]; + + repeated string repeated_cord = 55 [ + ctype = CORD + ]; + + repeated NestedMessage repeated_lazy_message = 57 [ + lazy = true + ]; + + // Singular with defaults + int32 default_int32 = 61 [ + default = 41 + ]; + + int64 default_int64 = 62 [ + default = 42 + ]; + + uint32 default_uint32 = 63 [ + default = 43 + ]; + + uint64 default_uint64 = 64 [ + default = 44 + ]; + + sint32 default_sint32 = 65 [ + default = -45 + ]; + + sint64 default_sint64 = 66 [ + default = 46 + ]; + + fixed32 default_fixed32 = 67 [ + default = 47 + ]; + + fixed64 default_fixed64 = 68 [ + default = 48 + ]; + + sfixed32 default_sfixed32 = 69 [ + default = 49 + ]; + + sfixed64 default_sfixed64 = 70 [ + default = -50 + ]; + + float default_float = 71 [ + default = 51.5 + ]; + + double default_double = 72 [ + default = 5.2e4 + ]; + + bool default_bool = 73 [ + default = true + ]; + + string default_string = 74 [ + default = "hello" + ]; + + bytes default_bytes = 75 [ + default = "world" + ]; + + NestedEnum default_nested_enum = 81 [ + default = BAR + ]; + + ForeignEnum default_foreign_enum = 82 [ + default = FOREIGN_BAR + ]; + + proto2_unittest_import.ImportEnum default_import_enum = 83 [ + default = IMPORT_BAR + ]; + + string default_string_piece = 84 [ + ctype = STRING_PIECE, + default = "abc" + ]; + + string default_cord = 85 [ + ctype = CORD, + default = "123" + ]; + + // For oneof test + oneof oneof_field { + uint32 oneof_uint32 = 111; + NestedMessage oneof_nested_message = 112; + string oneof_string = 113; + bytes oneof_bytes = 114; + string oneof_cord = 115 [ + ctype = CORD + ]; + + string oneof_string_piece = 116 [ + ctype = STRING_PIECE + ]; + + NestedMessage oneof_lazy_nested_message = 117 [ + lazy = true + ]; + } +} + +// This proto includes a recursively nested message. +message NestedTestAllTypes { + NestedTestAllTypes child = 1; + TestAllTypes payload = 2; + repeated NestedTestAllTypes repeated_child = 3; + NestedTestAllTypes lazy_child = 4 [ + lazy = true + ]; + + TestAllTypes eager_child = 5 [ + lazy = false + ]; +} + +message TestDeprecatedFields { + int32 deprecated_int32 = 1 [ + deprecated = true + ]; + + repeated string deprecated_repeated_string = 4 [ + deprecated = true + ]; + + TestAllTypes.NestedMessage deprecated_message = 3 [ + deprecated = true + ]; + + oneof oneof_fields { + int32 deprecated_int32_in_oneof = 2 [ + deprecated = true + ]; + } + + TestDeprecatedFields nested = 5; +} + +message TestDeprecatedMessage { + option deprecated = true; +} + +// Define these after TestAllTypes to make sure the compiler can handle +// that. +message ForeignMessage { + int32 c = 1; + int32 d = 2; +} + +enum ForeignEnum { + FOREIGN_FOO = 4; + FOREIGN_BAR = 5; + FOREIGN_BAZ = 6; + FOREIGN_BAX = 32; // (1 << 32) to generate a 64b bitmask would be incorrect. + FOREIGN_LARGE = 123456; // Large enough to escape the Boxed Integer cache. +} + +message TestReservedFields { + reserved 2, 15, 9 to 11; + + reserved bar, baz; +} + +enum TestReservedEnumFields { + UNKNOWN = 0; + + reserved 2, 15, 9 to 11; + + reserved bar, baz; +} + +message TestAllExtensions { + extensions 1 to max; +} + +extend TestAllExtensions { + // Singular + int32 optional_int32_extension = 1; + int64 optional_int64_extension = 2; + uint32 optional_uint32_extension = 3; + uint64 optional_uint64_extension = 4; + sint32 optional_sint32_extension = 5; + sint64 optional_sint64_extension = 6; + fixed32 optional_fixed32_extension = 7; + fixed64 optional_fixed64_extension = 8; + sfixed32 optional_sfixed32_extension = 9; + sfixed64 optional_sfixed64_extension = 10; + float optional_float_extension = 11; + double optional_double_extension = 12; + bool optional_bool_extension = 13; + string optional_string_extension = 14; + bytes optional_bytes_extension = 15; + OptionalGroup_extension optionalgroup_extension = 16 [ + features.message_encoding = DELIMITED + ]; + + TestAllTypes.NestedMessage optional_nested_message_extension = 18; + ForeignMessage optional_foreign_message_extension = 19; + proto2_unittest_import.ImportMessage optional_import_message_extension = 20; + TestAllTypes.NestedEnum optional_nested_enum_extension = 21; + ForeignEnum optional_foreign_enum_extension = 22; + proto2_unittest_import.ImportEnum optional_import_enum_extension = 23; + string optional_string_piece_extension = 24 [ + ctype = STRING_PIECE + ]; + + // TODO: ctype=CORD is not supported for extension. Add + // ctype=CORD option back after it is supported. + string optional_cord_extension = 25; + bytes optional_bytes_cord_extension = 86; + + proto2_unittest_import.PublicImportMessage + optional_public_import_message_extension = 26; + TestAllTypes.NestedMessage optional_lazy_message_extension = 27 [ + lazy = true + ]; + + TestAllTypes.NestedMessage optional_unverified_lazy_message_extension = 28 [ + unverified_lazy = true + ]; + + // Repeated + repeated int32 repeated_int32_extension = 31; + repeated int64 repeated_int64_extension = 32; + repeated uint32 repeated_uint32_extension = 33; + repeated uint64 repeated_uint64_extension = 34; + repeated sint32 repeated_sint32_extension = 35; + repeated sint64 repeated_sint64_extension = 36; + repeated fixed32 repeated_fixed32_extension = 37; + repeated fixed64 repeated_fixed64_extension = 38; + repeated sfixed32 repeated_sfixed32_extension = 39; + repeated sfixed64 repeated_sfixed64_extension = 40; + repeated float repeated_float_extension = 41; + repeated double repeated_double_extension = 42; + repeated bool repeated_bool_extension = 43; + repeated string repeated_string_extension = 44; + repeated bytes repeated_bytes_extension = 45; + repeated RepeatedGroup_extension repeatedgroup_extension = 46 [ + features.message_encoding = DELIMITED + ]; + + repeated TestAllTypes.NestedMessage repeated_nested_message_extension = 48; + repeated ForeignMessage repeated_foreign_message_extension = 49; + repeated proto2_unittest_import.ImportMessage + repeated_import_message_extension = 50; + repeated TestAllTypes.NestedEnum repeated_nested_enum_extension = 51; + repeated ForeignEnum repeated_foreign_enum_extension = 52; + repeated proto2_unittest_import.ImportEnum repeated_import_enum_extension = 53; + repeated string repeated_string_piece_extension = 54 [ + ctype = STRING_PIECE + ]; + + // TODO: ctype=CORD is not supported for extension. Add + // ctype=CORD option back after it is supported. + repeated string repeated_cord_extension = 55; + repeated TestAllTypes.NestedMessage repeated_lazy_message_extension = 57 [ + lazy = true + ]; + + // Singular with defaults + int32 default_int32_extension = 61 [ + default = 41 + ]; + + int64 default_int64_extension = 62 [ + default = 42 + ]; + + uint32 default_uint32_extension = 63 [ + default = 43 + ]; + + uint64 default_uint64_extension = 64 [ + default = 44 + ]; + + sint32 default_sint32_extension = 65 [ + default = -45 + ]; + + sint64 default_sint64_extension = 66 [ + default = 46 + ]; + + fixed32 default_fixed32_extension = 67 [ + default = 47 + ]; + + fixed64 default_fixed64_extension = 68 [ + default = 48 + ]; + + sfixed32 default_sfixed32_extension = 69 [ + default = 49 + ]; + + sfixed64 default_sfixed64_extension = 70 [ + default = -50 + ]; + + float default_float_extension = 71 [ + default = 51.5 + ]; + + double default_double_extension = 72 [ + default = 5.2e4 + ]; + + bool default_bool_extension = 73 [ + default = true + ]; + + string default_string_extension = 74 [ + default = "hello" + ]; + + bytes default_bytes_extension = 75 [ + default = "world" + ]; + + TestAllTypes.NestedEnum default_nested_enum_extension = 81 [ + default = BAR + ]; + + ForeignEnum default_foreign_enum_extension = 82 [ + default = FOREIGN_BAR + ]; + + proto2_unittest_import.ImportEnum default_import_enum_extension = 83 [ + default = IMPORT_BAR + ]; + + string default_string_piece_extension = 84 [ + ctype = STRING_PIECE, + default = "abc" + ]; + + // TODO: ctype=CORD is not supported for extension. Add + // ctype=CORD option back after it is supported. + string default_cord_extension = 85 [ + default = "123" + ]; + + // For oneof test + uint32 oneof_uint32_extension = 111; + TestAllTypes.NestedMessage oneof_nested_message_extension = 112; + string oneof_string_extension = 113; + bytes oneof_bytes_extension = 114; + + string optional_utf8_string_extension = 115 [ + features.utf8_validation = VERIFY + ]; + repeated string repeated_utf8_string_extension = 116 [ + features.utf8_validation = VERIFY + ]; + + // Singular message containing required fields; used to test initialization. + TestRequired required_message_extension = 117; +} + +message OptionalGroup_extension { + int32 a = 17; +} + +message RepeatedGroup_extension { + int32 a = 47; +} + +message TestMixedFieldsAndExtensions { + int32 a = 1; + repeated fixed32 b = 3; + + extensions 2, 4; + + extend TestMixedFieldsAndExtensions { + int32 c = 2; + repeated fixed32 d = 4; + } +} + +message TestGroup { + message OptionalGroup { + int32 a = 17; + int32 zz = 89; // fast table size must be at least 16, for this + // field to be parsed by the fast parser, since + // 89 - 17 = 72 is a multiple of 8. + } + + OptionalGroup optionalgroup = 16 [ + features.message_encoding = DELIMITED + ]; + + ForeignEnum optional_foreign_enum = 22; +} + +message TestGroupExtension { + extensions 1 to max; +} + +message TestNestedExtension { + extend TestAllExtensions { + // Check for bug where string extensions declared in tested scope did not + // compile. + string test = 1002 [ + default = "test" + ]; + + // Used to test if generated extension name is correct when there are + // underscores. + string nested_string_extension = 1003; + } + + extend TestGroupExtension { + OptionalGroup_extension optionalgroup_extension = 16 [ + features.message_encoding = DELIMITED + ]; + + ForeignEnum optional_foreign_enum_extension = 22; + } + + message OptionalGroup_extension { + int32 a = 17; + } +} + +message TestChildExtension { + string a = 1; + string b = 2; + TestAllExtensions optional_extension = 3; +} + +// Emulates wireformat data of TestChildExtension with dynamic extension +// (DynamicExtension). +message TestChildExtensionData { + message NestedTestAllExtensionsData { + message NestedDynamicExtensions { + int32 a = 1; + int32 b = 2; + } + + NestedDynamicExtensions dynamic = 409707008; + } + + string a = 1; + string b = 2; + NestedTestAllExtensionsData optional_extension = 3; +} + +message TestNestedChildExtension { + int32 a = 1; + TestChildExtension child = 2; +} + +// Emulates wireformat data of TestNestedChildExtension with dynamic extension +// (DynamicExtension). +message TestNestedChildExtensionData { + int32 a = 1; + TestChildExtensionData child = 2; +} + +// Required and closed enum fields are considered unknown fields if the value is +// not valid. We need to make sure it functions as expected. +message TestRequiredEnum { + ForeignEnum required_enum = 1 [ + features.field_presence = LEGACY_REQUIRED + ]; + + // A dummy optional field. + int32 a = 2; +} + +// Required and open enum accepts invalid enum values. +enum ForeignOpenEnum { + option features.enum_type = OPEN; + + FOREIGN_OPEN_UNKNOWN = 0; + FOREIGN_OPEN_FOO = 4; + FOREIGN_OPEN_BAR = 5; + FOREIGN_OPEN_BAZ = 6; + FOREIGN_OPEN_BAX = 32; // (1 << 32) to generate a 64b bitmask would be + // incorrect. +} + +message TestRequiredOpenEnum { + ForeignOpenEnum required_enum = 1 [ + features.field_presence = LEGACY_REQUIRED + ]; + + // A dummy optional field. + int32 a = 2; +} + +// TestRequiredEnum + using enum values that won't fit to 64 bitmask. +message TestRequiredEnumNoMask { + enum NestedEnum { + UNSPECIFIED = 0; + FOO = 2; + BAR = 100; + BAZ = -1; // Intentionally negative. + } + + NestedEnum required_enum = 1 [ + features.field_presence = LEGACY_REQUIRED + ]; + + // A dummy optional field. + int32 a = 2; +} + +message TestRequiredEnumMulti { + enum NestedEnum { + UNSPECIFIED = 0; + FOO = 1; + BAR = 2; + BAZ = 100; + } + + // Intentionally placed in descending field number to force sorting in closed + // enum verification. + NestedEnum required_enum_4 = 4 [ + features.field_presence = LEGACY_REQUIRED + ]; + + int32 a_3 = 3; + NestedEnum required_enum_2 = 2 [ + features.field_presence = LEGACY_REQUIRED + ]; + + ForeignEnum required_enum_1 = 1 [ + features.field_presence = LEGACY_REQUIRED + ]; +} + +message TestRequiredNoMaskMulti { + enum NestedEnum { + UNSPECIFIED = 0; + FOO = 1; + BAR = 2; + BAZ = 100; + } + + // Intentionally placed in descending field number to force sorting in closed + // enum verification. Also, using large field numbers to use tag only + // matching for required fields. + fixed32 required_fixed32_80 = 80 [ + features.field_presence = LEGACY_REQUIRED + ]; + + fixed32 required_fixed32_70 = 70 [ + features.field_presence = LEGACY_REQUIRED + ]; + + NestedEnum required_enum_64 = 64 [ + features.field_presence = LEGACY_REQUIRED + ]; + + NestedEnum required_enum_4 = 4 [ + features.field_presence = LEGACY_REQUIRED + ]; + + int32 a_3 = 3; + NestedEnum required_enum_2 = 2 [ + features.field_presence = LEGACY_REQUIRED + ]; + + ForeignEnum required_enum_1 = 1 [ + features.field_presence = LEGACY_REQUIRED + ]; +} + +// We have separate messages for testing required fields because it's +// annoying to have to fill in required fields in TestProto in order to +// do anything with it. Note that we don't need to test every type of +// required filed because the code output is basically identical to +// optional fields for all types. +message TestRequired { + int32 a = 1 [ + features.field_presence = LEGACY_REQUIRED + ]; + + int32 dummy2 = 2; + int32 b = 3 [ + features.field_presence = LEGACY_REQUIRED + ]; + + extend TestAllExtensions { + TestRequired single = 1000; + repeated TestRequired multi = 1001; + } + + // Pad the field count to 32 so that we can test that IsInitialized() + // properly checks multiple elements of has_bits_. + int32 dummy4 = 4; + int32 dummy5 = 5; + int32 dummy6 = 6; + int32 dummy7 = 7; + int32 dummy8 = 8; + int32 dummy9 = 9; + int32 dummy10 = 10; + int32 dummy11 = 11; + int32 dummy12 = 12; + int32 dummy13 = 13; + int32 dummy14 = 14; + int32 dummy15 = 15; + int32 dummy16 = 16; + int32 dummy17 = 17; + int32 dummy18 = 18; + int32 dummy19 = 19; + int32 dummy20 = 20; + int32 dummy21 = 21; + int32 dummy22 = 22; + int32 dummy23 = 23; + int32 dummy24 = 24; + int32 dummy25 = 25; + int32 dummy26 = 26; + int32 dummy27 = 27; + int32 dummy28 = 28; + int32 dummy29 = 29; + int32 dummy30 = 30; + int32 dummy31 = 31; + int32 dummy32 = 32; + int32 c = 33 [ + features.field_presence = LEGACY_REQUIRED + ]; + + // Add an optional child message to make this non-trivial for go/pdlazy. + ForeignMessage optional_foreign = 34; + + map map_field = 35; +} + +message TestRequiredForeign { + TestRequired optional_message = 1; + repeated TestRequired repeated_message = 2; + int32 dummy = 3; + + // Missing required fields must not affect verification of child messages. + NestedTestAllTypes optional_lazy_message = 4 [ + lazy = true + ]; +} + +message TestRequiredMessage { + TestRequired optional_message = 1; + repeated TestRequired repeated_message = 2; + TestRequired required_message = 3 [ + features.field_presence = LEGACY_REQUIRED + ]; +} + +message TestRequiredLazyMessage { + TestRequired child = 1 [lazy = true]; + TestRequiredLazyMessage recurse = 2 [lazy = true]; +} + +message TestNestedRequiredForeign { + TestNestedRequiredForeign child = 1; + TestRequiredForeign payload = 2; + int32 dummy = 3; + + // optional message to test required closed enum. + TestRequiredEnum required_enum = 5; + TestRequiredEnumNoMask required_enum_no_mask = 6; + TestRequiredEnumMulti required_enum_multi = 7; + TestRequiredNoMaskMulti required_no_mask = 9; +} + +// Test that we can use NestedMessage from outside TestAllTypes. +message TestForeignNested { + TestAllTypes.NestedMessage foreign_nested = 1; +} + +// TestEmptyMessage is used to test unknown field support. +message TestEmptyMessage { +} + +// Like above, but declare all field numbers as potential extensions. No +// actual extensions should ever be defined for this type. +message TestEmptyMessageWithExtensions { + extensions 1 to max; +} + +// Needed for a Python test. +message TestPickleNestedMessage { + message NestedMessage { + int32 bb = 1; + + message NestedNestedMessage { + int32 cc = 1; + } + } +} + +message TestMultipleExtensionRanges { + extensions 42; + extensions 4143 to 4243; + extensions 65536 to max; +} + +// Test that really large tag numbers don't break anything. +message TestReallyLargeTagNumber { + // The largest possible tag number is 2^28 - 1, since the wire format uses + // three bits to communicate wire type. + int32 a = 1; + int32 bb = 268435455; +} + +message TestRecursiveMessage { + TestRecursiveMessage a = 1; + int32 i = 2; +} + +// Test that mutual recursion works. +message TestMutualRecursionA { + message SubMessage { + TestMutualRecursionB b = 1; + } + + TestMutualRecursionB bb = 1; + + message SubGroup { + SubMessage sub_message = 3; // Needed because of bug in javatest + TestAllTypes not_in_this_scc = 4; + } + + SubGroup subgroup = 2 [ + features.message_encoding = DELIMITED + ]; + + message SubGroupR { + TestAllTypes payload = 6; + } + + repeated SubGroupR subgroupr = 5 [ + features.message_encoding = DELIMITED + ]; +} + +message TestMutualRecursionB { + TestMutualRecursionA a = 1; + int32 optional_int32 = 2; +} + +message TestIsInitialized { + message SubMessage { + message SubGroup { + int32 i = 2 [ + features.field_presence = LEGACY_REQUIRED + ]; + } + + SubGroup subgroup = 1 [ + features.message_encoding = DELIMITED + ]; + } + + SubMessage sub_message = 1; +} + +// Test that groups have disjoint field numbers from their siblings and +// parents. This is NOT possible in proto1; only google.protobuf. When attempting +// to compile with proto1, this will emit an error; so we only include it +// in proto2_unittest_proto. +message TestDupFieldNumber {// NO_PROTO1 + int32 a = 1; // NO_PROTO1 + message Foo { // NO_PROTO1 + int32 a = 1; // NO_PROTO1 + } // NO_PROTO1 + Foo foo = 2 [features.message_encoding = DELIMITED]; // NO_PROTO1 + message Bar { // NO_PROTO1 + int32 a = 1; // NO_PROTO1 + } // NO_PROTO1 + Bar bar = 3 [features.message_encoding = DELIMITED]; // NO_PROTO1 +} // NO_PROTO1 + +// Additional messages for testing lazy fields. +message TestEagerMessage { + TestAllTypes sub_message = 1 [ + lazy = false + ]; +} + +message TestLazyMessage { + TestAllTypes sub_message = 1 [ + lazy = true + ]; +} + +message TestLazyRequiredEnum { + TestRequiredOpenEnum optional_required_open_enum = 1 [lazy = true]; + TestRequiredEnum optional_required_enum = 2 [lazy = true]; + TestRequiredEnumNoMask optional_required_enum_no_mask = 3 [lazy = true]; + TestRequiredEnumMulti optional_required_enum_multi = 4 [lazy = true]; + TestRequiredNoMaskMulti optional_required_no_mask = 5 [lazy = true]; +} + +message TestLazyMessageRepeated { + repeated TestLazyMessage repeated_message = 1; +} + +message TestEagerMaybeLazy { + message NestedMessage { + TestPackedTypes packed = 1; + } + + TestAllTypes message_foo = 1; + TestAllTypes message_bar = 2; + NestedMessage message_baz = 3; +} + +// Needed for a Python test. +message TestNestedMessageHasBits { + message NestedMessage { + repeated int32 nestedmessage_repeated_int32 = 1; + repeated ForeignMessage nestedmessage_repeated_foreignmessage = 2; + } + + NestedMessage optional_nested_message = 1; +} + +// Test an enum that has multiple values with the same number. +enum TestEnumWithDupValue { + option allow_alias = true; + + FOO1 = 1; + BAR1 = 2; + BAZ = 3; + FOO2 = 1; + BAR2 = 2; +} + +// Test an enum with large, unordered values. +enum TestSparseEnum { + SPARSE_A = 123; + SPARSE_B = 62374; + SPARSE_C = 12589234; + SPARSE_D = -15; + SPARSE_E = -53452; + SPARSE_F = 0; + SPARSE_G = 2; +} + +// Test message with CamelCase field names. This violates Protocol Buffer +// standard style. +message TestCamelCaseFieldNames { + int32 PrimitiveField = 1; + string StringField = 2; + ForeignEnum EnumField = 3; + ForeignMessage MessageField = 4; + string StringPieceField = 5 [ + ctype = STRING_PIECE + ]; + + string CordField = 6 [ + ctype = CORD + ]; + + repeated int32 RepeatedPrimitiveField = 7; + repeated string RepeatedStringField = 8; + repeated ForeignEnum RepeatedEnumField = 9; + repeated ForeignMessage RepeatedMessageField = 10; + repeated string RepeatedStringPieceField = 11 [ + ctype = STRING_PIECE + ]; + + repeated string RepeatedCordField = 12 [ + ctype = CORD + ]; +} + +// We list fields out of order, to ensure that we're using field number and not +// field index to determine serialization order. +message TestFieldOrderings { + string my_string = 11; + + extensions 2 to 10; + + int64 my_int = 1; + + extensions 12 to 100; + + float my_float = 101; + + message NestedMessage { + int64 oo = 2; + + // The field name "b" fails to compile in proto1 because it conflicts with + // a local variable named "b" in one of the generated methods. Doh. + // This file needs to compile in proto1 to test backwards-compatibility. + int32 bb = 1; + } + + NestedMessage optional_nested_message = 200; +} + +extend TestFieldOrderings { + string my_extension_string = 50; + int32 my_extension_int = 5; +} + +message TestExtensionOrderings1 { + extend TestFieldOrderings { + TestExtensionOrderings1 test_ext_orderings1 = 13; + } + + string my_string = 1; +} + +message TestExtensionOrderings2 { + extend TestFieldOrderings { + TestExtensionOrderings2 test_ext_orderings2 = 12; + } + + message TestExtensionOrderings3 { + extend TestFieldOrderings { + TestExtensionOrderings3 test_ext_orderings3 = 14; + } + + string my_string = 1; + } + + string my_string = 1; +} + +message TestExtremeDefaultValues { + bytes escaped_bytes = 1 [ + default = + "\0\001\a\b\f\n\r\t\v\\\'\"\xfe" + ]; + + uint32 large_uint32 = 2 [ + default = 0xFFFFFFFF + ]; + + uint64 large_uint64 = 3 [ + default = 0xFFFFFFFFFFFFFFFF + ]; + + int32 small_int32 = 4 [ + default = -0x7FFFFFFF + ]; + + int64 small_int64 = 5 [ + default = -0x7FFFFFFFFFFFFFFF + ]; + + int32 really_small_int32 = 21 [ + default = -0x80000000 + ]; + + int64 really_small_int64 = 22 [ + default = -0x8000000000000000 + ]; + + // The default value here is UTF-8 for "\u1234". (We could also just type + // the UTF-8 text directly into this text file rather than escape it, but + // lots of people use editors that would be confused by this.) + string utf8_string = 6 [ + default = "\341\210\264" + ]; + + // Tests for single-precision floating-point values. + float zero_float = 7 [ + default = 0 + ]; + + float one_float = 8 [ + default = 1 + ]; + + float small_float = 9 [ + default = 1.5 + ]; + + float negative_one_float = 10 [ + default = -1 + ]; + + float negative_float = 11 [ + default = -1.5 + ]; + + // Using exponents + float large_float = 12 [ + default = 2e8 + ]; + + float small_negative_float = 13 [ + default = -8e-28 + ]; + + // Text for nonfinite floating-point values. + double inf_double = 14 [ + default = inf + ]; + + double neg_inf_double = 15 [ + default = -inf + ]; + + double nan_double = 16 [ + default = nan + ]; + + float inf_float = 17 [ + default = inf + ]; + + float neg_inf_float = 18 [ + default = -inf + ]; + + float nan_float = 19 [ + default = nan + ]; + + // Tests for C++ trigraphs. + // Trigraphs should be escaped in C++ generated files, but they should not be + // escaped for other languages. + // Note that in .proto file, "\?" is a valid way to escape ? in string + // literals. + string cpp_trigraph = 20 [ + default = "? \? ?? \?? \??? ??/ ?\?-" + ]; + + // String defaults containing the character '\000' + string string_with_zero = 23 [ + default = "hel\000lo" + ]; + + bytes bytes_with_zero = 24 [ + default = "wor\000ld" + ]; + + string string_piece_with_zero = 25 [ + ctype = STRING_PIECE, + default = "ab\000c" + ]; + + string cord_with_zero = 26 [ + ctype = CORD, + default = "12\0003" + ]; + + string replacement_string = 27 [ + default = "${unknown}" + ]; +} + +message SparseEnumMessage { + TestSparseEnum sparse_enum = 1; +} + +// Test String and Bytes: string is for valid UTF-8 strings +message OneString { + string data = 1; +} + +message MoreString { + repeated string data = 1; +} + +message OneBytes { + bytes data = 1; +} + +message MoreBytes { + repeated bytes data = 1; +} + +message ManyOptionalString { + string str1 = 1; + string str2 = 2; + string str3 = 3; + string str4 = 4; + string str5 = 5; + string str6 = 6; + string str7 = 7; + string str8 = 8; + string str9 = 9; + string str10 = 10; + string str11 = 11; + string str12 = 12; + string str13 = 13; + string str14 = 14; + string str15 = 15; + string str16 = 16; + string str17 = 17; + string str18 = 18; + string str19 = 19; + string str20 = 20; + string str21 = 21; + string str22 = 22; + string str23 = 23; + string str24 = 24; + string str25 = 25; + string str26 = 26; + string str27 = 27; + string str28 = 28; + string str29 = 29; + string str30 = 30; + string str31 = 31; + string str32 = 32; +} + +// Test int32, uint32, int64, uint64, and bool are all compatible +message Int32Message { + int32 data = 1; +} + +message Uint32Message { + uint32 data = 1; +} + +message Int64Message { + int64 data = 1; +} + +message Uint64Message { + uint64 data = 1; +} + +message BoolMessage { + bool data = 1; +} + +// Test oneofs. +message TestOneof { + oneof foo { + int32 foo_int = 1; + string foo_string = 2; + TestAllTypes foo_message = 3; + FooGroup foogroup = 4 [ + features.message_encoding = DELIMITED + ]; + } + + message FooGroup { + int32 a = 5; + string b = 6; + } +} + +message TestOneofBackwardsCompatible { + int32 foo_int = 1; + string foo_string = 2; + TestAllTypes foo_message = 3; + + message FooGroup { + int32 a = 5; + string b = 6; + } + + FooGroup foogroup = 4 [ + features.message_encoding = DELIMITED + ]; +} + +message TestOneof2 { + oneof foo { + int32 foo_int = 1; + string foo_string = 2; + string foo_cord = 3 [ + ctype = CORD + ]; + + string foo_string_piece = 4 [ + ctype = STRING_PIECE + ]; + + bytes foo_bytes = 5; + NestedEnum foo_enum = 6; + NestedMessage foo_message = 7; + FooGroup foogroup = 8 [ + features.message_encoding = DELIMITED + ]; + + NestedMessage foo_lazy_message = 11 [ + lazy = true + ]; + + bytes foo_bytes_cord = 30 [ + ctype = CORD + ]; + } + + message FooGroup { + int32 a = 9; + string b = 10; + } + + oneof bar { + int32 bar_int = 12 [ + default = 5 + ]; + + string bar_string = 13 [ + default = "STRING" + ]; + + string bar_cord = 14 [ + ctype = CORD, + default = "CORD" + ]; + + string bar_string_piece = 15 [ + ctype = STRING_PIECE, + default = "SPIECE" + ]; + + bytes bar_bytes = 16 [ + default = "BYTES" + ]; + + NestedEnum bar_enum = 17 [ + default = BAR + ]; + + string bar_string_with_empty_default = 20 [ + default = "" + ]; + + string bar_cord_with_empty_default = 21 [ + ctype = CORD, + default = "" + ]; + + string bar_string_piece_with_empty_default = 22 [ + ctype = STRING_PIECE, + default = "" + ]; + + bytes bar_bytes_with_empty_default = 23 [ + default = "" + ]; + } + + int32 baz_int = 18; + string baz_string = 19 [ + default = "BAZ" + ]; + + message NestedMessage { + int64 moo_int = 1; + repeated int32 corge_int = 2; + NestedMessage child = 3; + } + + enum NestedEnum { + FOO = 1; + BAR = 2; + BAZ = 3; + } +} + +message TestRequiredOneof { + oneof foo { + int32 foo_int = 1; + string foo_string = 2; + NestedMessage foo_message = 3; + NestedMessage foo_lazy_message = 4 [ + lazy = true + ]; + } + + message NestedMessage { + double required_double = 1 [ + features.field_presence = LEGACY_REQUIRED + ]; + } +} + +// Test messages for packed fields + +message TestPackedTypes { + repeated int32 packed_int32 = 90 [ + features.repeated_field_encoding = PACKED + ]; + + repeated int64 packed_int64 = 91 [ + features.repeated_field_encoding = PACKED + ]; + + repeated uint32 packed_uint32 = 92 [ + features.repeated_field_encoding = PACKED + ]; + + repeated uint64 packed_uint64 = 93 [ + features.repeated_field_encoding = PACKED + ]; + + repeated sint32 packed_sint32 = 94 [ + features.repeated_field_encoding = PACKED + ]; + + repeated sint64 packed_sint64 = 95 [ + features.repeated_field_encoding = PACKED + ]; + + repeated fixed32 packed_fixed32 = 96 [ + features.repeated_field_encoding = PACKED + ]; + + repeated fixed64 packed_fixed64 = 97 [ + features.repeated_field_encoding = PACKED + ]; + + repeated sfixed32 packed_sfixed32 = 98 [ + features.repeated_field_encoding = PACKED + ]; + + repeated sfixed64 packed_sfixed64 = 99 [ + features.repeated_field_encoding = PACKED + ]; + + repeated float packed_float = 100 [ + features.repeated_field_encoding = PACKED + ]; + + repeated double packed_double = 101 [ + features.repeated_field_encoding = PACKED + ]; + + repeated bool packed_bool = 102 [ + features.repeated_field_encoding = PACKED + ]; + + repeated ForeignEnum packed_enum = 103 [ + features.repeated_field_encoding = PACKED + ]; +} + +// A message with the same fields as TestPackedTypes, but without packing. Used +// to test packed <-> unpacked wire compatibility. +message TestUnpackedTypes { + repeated int32 unpacked_int32 = 90; + repeated int64 unpacked_int64 = 91; + repeated uint32 unpacked_uint32 = 92; + repeated uint64 unpacked_uint64 = 93; + repeated sint32 unpacked_sint32 = 94; + repeated sint64 unpacked_sint64 = 95; + repeated fixed32 unpacked_fixed32 = 96; + repeated fixed64 unpacked_fixed64 = 97; + repeated sfixed32 unpacked_sfixed32 = 98; + repeated sfixed64 unpacked_sfixed64 = 99; + repeated float unpacked_float = 100; + repeated double unpacked_double = 101; + repeated bool unpacked_bool = 102; + repeated ForeignEnum unpacked_enum = 103; +} + +message TestPackedExtensions { + extensions 1 to max; +} + +extend TestPackedExtensions { + repeated int32 packed_int32_extension = 90 [ + features.repeated_field_encoding = PACKED + ]; + + repeated int64 packed_int64_extension = 91 [ + features.repeated_field_encoding = PACKED + ]; + + repeated uint32 packed_uint32_extension = 92 [ + features.repeated_field_encoding = PACKED + ]; + + repeated uint64 packed_uint64_extension = 93 [ + features.repeated_field_encoding = PACKED + ]; + + repeated sint32 packed_sint32_extension = 94 [ + features.repeated_field_encoding = PACKED + ]; + + repeated sint64 packed_sint64_extension = 95 [ + features.repeated_field_encoding = PACKED + ]; + + repeated fixed32 packed_fixed32_extension = 96 [ + features.repeated_field_encoding = PACKED + ]; + + repeated fixed64 packed_fixed64_extension = 97 [ + features.repeated_field_encoding = PACKED + ]; + + repeated sfixed32 packed_sfixed32_extension = 98 [ + features.repeated_field_encoding = PACKED + ]; + + repeated sfixed64 packed_sfixed64_extension = 99 [ + features.repeated_field_encoding = PACKED + ]; + + repeated float packed_float_extension = 100 [ + features.repeated_field_encoding = PACKED + ]; + + repeated double packed_double_extension = 101 [ + features.repeated_field_encoding = PACKED + ]; + + repeated bool packed_bool_extension = 102 [ + features.repeated_field_encoding = PACKED + ]; + + repeated ForeignEnum packed_enum_extension = 103 [ + features.repeated_field_encoding = PACKED + ]; +} + +message TestUnpackedExtensions { + extensions 1 to max; +} + +extend TestUnpackedExtensions { + repeated int32 unpacked_int32_extension = 90; + repeated int64 unpacked_int64_extension = 91; + repeated uint32 unpacked_uint32_extension = 92; + repeated uint64 unpacked_uint64_extension = 93; + repeated sint32 unpacked_sint32_extension = 94; + repeated sint64 unpacked_sint64_extension = 95; + repeated fixed32 unpacked_fixed32_extension = 96; + repeated fixed64 unpacked_fixed64_extension = 97; + repeated sfixed32 unpacked_sfixed32_extension = 98; + repeated sfixed64 unpacked_sfixed64_extension = 99; + repeated float unpacked_float_extension = 100; + repeated double unpacked_double_extension = 101; + repeated bool unpacked_bool_extension = 102; + repeated ForeignEnum unpacked_enum_extension = 103; +} + +// Used by ExtensionSetTest/DynamicExtensions. The test actually builds +// a set of extensions to TestAllExtensions dynamically, based on the fields +// of this message type. +message TestDynamicExtensions { + enum DynamicEnumType { + DYNAMIC_FOO = 2200; + DYNAMIC_BAR = 2201; + DYNAMIC_BAZ = 2202; + } + + message DynamicMessageType { + int32 dynamic_field = 2100; + } + + fixed32 scalar_extension = 2000; + ForeignEnum enum_extension = 2001; + DynamicEnumType dynamic_enum_extension = 2002; + ForeignMessage message_extension = 2003; + DynamicMessageType dynamic_message_extension = 2004; + repeated string repeated_extension = 2005; + repeated sint32 packed_extension = 2006 [ + features.repeated_field_encoding = PACKED + ]; +} + +message TestRepeatedString { + repeated string repeated_string1 = 1; + repeated string repeated_string2 = 2; + repeated bytes repeated_bytes11 = 11; + repeated bytes repeated_bytes12 = 12; +} + +message TestRepeatedScalarDifferentTagSizes { + // Parsing repeated fixed size values used to fail. This message needs to be + // used in order to get a tag of the right size; all of the repeated fields + // in TestAllTypes didn't trigger the check. + repeated fixed32 repeated_fixed32 = 12; + + // Check for a varint type, just for good measure. + repeated int32 repeated_int32 = 13; + + // These have two-byte tags. + repeated fixed64 repeated_fixed64 = 2046; + repeated int64 repeated_int64 = 2047; + + // Three byte tags. + repeated float repeated_float = 262142; + repeated uint64 repeated_uint64 = 262143; +} + +// Test that if an optional or required message/group field appears multiple +// times in the input, they need to be merged. +message TestParsingMerge { + // RepeatedFieldsGenerator defines matching field types as TestParsingMerge, + // except that all fields are repeated. In the tests, we will serialize the + // RepeatedFieldsGenerator to bytes, and parse the bytes to TestParsingMerge. + // Repeated fields in RepeatedFieldsGenerator are expected to be merged into + // the corresponding required/optional fields in TestParsingMerge. + message RepeatedFieldsGenerator { + repeated TestAllTypes field1 = 1; + repeated TestAllTypes field2 = 2; + repeated TestAllTypes field3 = 3; + + message Group1 { + TestAllTypes field1 = 11; + } + + repeated Group1 group1 = 10 [ + features.message_encoding = DELIMITED + ]; + + message Group2 { + TestAllTypes field1 = 21; + } + + repeated Group2 group2 = 20 [ + features.message_encoding = DELIMITED + ]; + + repeated TestAllTypes ext1 = 1000; + repeated TestAllTypes ext2 = 1001; + } + + TestAllTypes required_all_types = 1 [ + features.field_presence = LEGACY_REQUIRED + ]; + + TestAllTypes optional_all_types = 2; + repeated TestAllTypes repeated_all_types = 3; + + message OptionalGroup { + TestAllTypes optional_group_all_types = 11; + } + + OptionalGroup optionalgroup = 10 [ + features.message_encoding = DELIMITED + ]; + + message RepeatedGroup { + TestAllTypes repeated_group_all_types = 21; + } + + repeated RepeatedGroup repeatedgroup = 20 [ + features.message_encoding = DELIMITED + ]; + + extensions 1000 to max; + + extend TestParsingMerge { + TestAllTypes optional_ext = 1000; + repeated TestAllTypes repeated_ext = 1001; + } +} + +// Test that the correct exception is thrown by parseFrom in a corner case +// involving merging, extensions, and required fields. +message TestMergeException { + TestAllExtensions all_extensions = 1; +} + +message TestCommentInjectionMessage { + // */ <- This should not close the generated doc comment + string a = 1 [ + default = "*/ <- Neither should this." + ]; +} + +// Used to check that the c++ code generator re-orders messages to reduce +// padding. +message TestMessageSize { + bool m1 = 1; + int64 m2 = 2; + bool m3 = 3; + string m4 = 4; + int32 m5 = 5; + int64 m6 = 6; +} + +message OpenEnumMessage { + enum TestEnum { + option features.enum_type = OPEN; + + UNKNOWN = 0; + FOO = 1; + BAR = 2; + BAZ = 3; + } + + TestEnum opt_open = 1; + + ForeignEnum opt_closed = 2; + repeated TestEnum repeated_open = 3; + + repeated ForeignEnum repeated_closed = 4; +} + +// Tests eager verification of a lazy message field. +message TestEagerlyVerifiedLazyMessage { + message LazyMessage { + bytes bytes_field = 1; + } + LazyMessage lazy_message = 1 [lazy = true]; +} + +// Test that RPC services work. +message FooRequest { +} + +message FooResponse { +} + +message FooClientMessage { +} + +message FooServerMessage { +} + +service TestService { + rpc Foo(FooRequest) returns (FooResponse); + + rpc Bar(BarRequest) returns (BarResponse); +} + +message BarRequest { +} + +message BarResponse { +} + +message TestJsonName { + int32 field_name1 = 1; + int32 fieldName2 = 2; + int32 FieldName3 = 3; + int32 _field_name4 = 4; + int32 FIELD_NAME5 = 5; + int32 field_name6 = 6 [ + json_name = "@type" + ]; + + int32 fieldname7 = 7; +} + +message TestHugeFieldNumbers { + int32 optional_int32 = 536870000; + int32 fixed_32 = 536870001; + repeated int32 repeated_int32 = 536870002; + repeated int32 packed_int32 = 536870003 [ + features.repeated_field_encoding = PACKED + ]; + + ForeignEnum optional_enum = 536870004; + string optional_string = 536870005; + bytes optional_bytes = 536870006; + ForeignMessage optional_message = 536870007; + + message OptionalGroup { + int32 group_a = 536870009; + } + + OptionalGroup optionalgroup = 536870008 [ + features.message_encoding = DELIMITED + ]; + + map string_string_map = 536870010; + + oneof oneof_field { + uint32 oneof_uint32 = 536870011; + TestAllTypes oneof_test_all_types = 536870012; + string oneof_string = 536870013; + bytes oneof_bytes = 536870014; + } + + bool optional_bool = 536870015; + int64 optional_int64 = 536870016; + float optional_float = 536870017; + double optional_double = 536870018; + string optional_utf8_string = 536870019 [ + features.utf8_validation = VERIFY + ]; + string optional_cord = 536870020 [ + ctype=CORD, features.utf8_validation = VERIFY + ]; + string optional_string_piece = 536870021 [ + ctype=STRING_PIECE, features.utf8_validation = VERIFY + ]; + + repeated string repeated_utf8_string = 536870022 [ + features.utf8_validation = VERIFY + ]; + + extensions 536860000 to 536869999 [ + declaration = { + number: 536860000 + full_name: ".proto2_unittest.test_all_types" + type: ".proto2_unittest.TestAllTypes" + } + ]; +} + +extend TestHugeFieldNumbers { + TestAllTypes test_all_types = 536860000; +} + +message TestExtensionInsideTable { + int32 field1 = 1; + int32 field2 = 2; + int32 field3 = 3; + int32 field4 = 4; + + extensions 5; + + int32 field6 = 6; + int32 field7 = 7; + int32 field8 = 8; + int32 field9 = 9; + int32 field10 = 10; +} + +extend TestExtensionInsideTable { + int32 test_extension_inside_table_extension = 5; +} + +// NOTE: Intentionally nested to mirror go/glep. +message TestNestedGroupExtensionOuter { + message Layer1OptionalGroup { + message Layer2RepeatedGroup { + extensions 3 + // NOTE: extension metadata is not supported due to targets such as + // `//google/protobuf_legacy_opensource/src:shell_scripts_test`, + // eee https://screenshot.googleplex.com/Axz2QD8nxjdpyFF + // [metadata = { + // NOTE: can't write type there due to some clever build gen code at + // http://google3/google/protobuf/BUILD;l=1247;rcl=411090862 + // type: "proto2_unittest.TestNestedGroupExtensionInnerExtension", + // name: "inner", + // }] + ; + + string another_field = 6; + } + + repeated Layer2RepeatedGroup layer2repeatedgroup = 2 [ + features.message_encoding = DELIMITED + ]; + + message Layer2AnotherOptionalRepeatedGroup { + string but_why_tho = 5; + } + + repeated Layer2AnotherOptionalRepeatedGroup + layer2anotheroptionalrepeatedgroup = 4 [ + features.message_encoding = DELIMITED + ]; + } + + Layer1OptionalGroup layer1optionalgroup = 1 [ + features.message_encoding = DELIMITED + ]; +} + +message TestNestedGroupExtensionInnerExtension { + string inner_name = 1; +} + +extend TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2RepeatedGroup { + TestNestedGroupExtensionInnerExtension inner = 3; +} + +enum VeryLargeEnum { + ENUM_LABEL_DEFAULT = 0; + ENUM_LABEL_1 = 1; + ENUM_LABEL_2 = 2; + ENUM_LABEL_3 = 3; + ENUM_LABEL_4 = 4; + ENUM_LABEL_5 = 5; + ENUM_LABEL_6 = 6; + ENUM_LABEL_7 = 7; + ENUM_LABEL_8 = 8; + ENUM_LABEL_9 = 9; + ENUM_LABEL_10 = 10; + ENUM_LABEL_11 = 11; + ENUM_LABEL_12 = 12; + ENUM_LABEL_13 = 13; + ENUM_LABEL_14 = 14; + ENUM_LABEL_15 = 15; + ENUM_LABEL_16 = 16; + ENUM_LABEL_17 = 17; + ENUM_LABEL_18 = 18; + ENUM_LABEL_19 = 19; + ENUM_LABEL_20 = 20; + ENUM_LABEL_21 = 21; + ENUM_LABEL_22 = 22; + ENUM_LABEL_23 = 23; + ENUM_LABEL_24 = 24; + ENUM_LABEL_25 = 25; + ENUM_LABEL_26 = 26; + ENUM_LABEL_27 = 27; + ENUM_LABEL_28 = 28; + ENUM_LABEL_29 = 29; + ENUM_LABEL_30 = 30; + ENUM_LABEL_31 = 31; + ENUM_LABEL_32 = 32; + ENUM_LABEL_33 = 33; + ENUM_LABEL_34 = 34; + ENUM_LABEL_35 = 35; + ENUM_LABEL_36 = 36; + ENUM_LABEL_37 = 37; + ENUM_LABEL_38 = 38; + ENUM_LABEL_39 = 39; + ENUM_LABEL_40 = 40; + ENUM_LABEL_41 = 41; + ENUM_LABEL_42 = 42; + ENUM_LABEL_43 = 43; + ENUM_LABEL_44 = 44; + ENUM_LABEL_45 = 45; + ENUM_LABEL_46 = 46; + ENUM_LABEL_47 = 47; + ENUM_LABEL_48 = 48; + ENUM_LABEL_49 = 49; + ENUM_LABEL_50 = 50; + ENUM_LABEL_51 = 51; + ENUM_LABEL_52 = 52; + ENUM_LABEL_53 = 53; + ENUM_LABEL_54 = 54; + ENUM_LABEL_55 = 55; + ENUM_LABEL_56 = 56; + ENUM_LABEL_57 = 57; + ENUM_LABEL_58 = 58; + ENUM_LABEL_59 = 59; + ENUM_LABEL_60 = 60; + ENUM_LABEL_61 = 61; + ENUM_LABEL_62 = 62; + ENUM_LABEL_63 = 63; + ENUM_LABEL_64 = 64; + ENUM_LABEL_65 = 65; + ENUM_LABEL_66 = 66; + ENUM_LABEL_67 = 67; + ENUM_LABEL_68 = 68; + ENUM_LABEL_69 = 69; + ENUM_LABEL_70 = 70; + ENUM_LABEL_71 = 71; + ENUM_LABEL_72 = 72; + ENUM_LABEL_73 = 73; + ENUM_LABEL_74 = 74; + ENUM_LABEL_75 = 75; + ENUM_LABEL_76 = 76; + ENUM_LABEL_77 = 77; + ENUM_LABEL_78 = 78; + ENUM_LABEL_79 = 79; + ENUM_LABEL_80 = 80; + ENUM_LABEL_81 = 81; + ENUM_LABEL_82 = 82; + ENUM_LABEL_83 = 83; + ENUM_LABEL_84 = 84; + ENUM_LABEL_85 = 85; + ENUM_LABEL_86 = 86; + ENUM_LABEL_87 = 87; + ENUM_LABEL_88 = 88; + ENUM_LABEL_89 = 89; + ENUM_LABEL_90 = 90; + ENUM_LABEL_91 = 91; + ENUM_LABEL_92 = 92; + ENUM_LABEL_93 = 93; + ENUM_LABEL_94 = 94; + ENUM_LABEL_95 = 95; + ENUM_LABEL_96 = 96; + ENUM_LABEL_97 = 97; + ENUM_LABEL_98 = 98; + ENUM_LABEL_99 = 99; + ENUM_LABEL_100 = 100; +} + +message TestExtensionRangeSerialize { + int32 foo_one = 1; + + extensions 2; + extensions 3 to 4; + + int32 foo_two = 6; + int32 foo_three = 7; + + extensions 9 to 10; + + int32 foo_four = 13; + + extensions 15 to 15; + extensions 17 to 17; + extensions 19 to 19; + + extend TestExtensionRangeSerialize { + int32 bar_one = 2; + int32 bar_two = 4; + int32 bar_three = 10; + int32 bar_four = 15; + int32 bar_five = 19; + } +} + +message TestVerifyInt32Simple { + int32 optional_int32_1 = 1; + int32 optional_int32_2 = 2; + int32 optional_int32_63 = 63; + int32 optional_int32_64 = 64; +} + +message TestVerifyInt32 { + int32 optional_int32_1 = 1; + int32 optional_int32_2 = 2; + int32 optional_int32_63 = 63; + int32 optional_int32_64 = 64; + TestAllTypes optional_all_types = 9; + repeated TestAllTypes repeated_all_types = 10; +} + +message TestVerifyMostlyInt32 { + int64 optional_int64_30 = 30; + int32 optional_int32_1 = 1; + int32 optional_int32_2 = 2; + int32 optional_int32_3 = 3; + int32 optional_int32_4 = 4; + int32 optional_int32_63 = 63; + int32 optional_int32_64 = 64; + TestAllTypes optional_all_types = 9; + repeated TestAllTypes repeated_all_types = 10; +} + +message TestVerifyMostlyInt32BigFieldNumber { + int64 optional_int64_30 = 30; + int32 optional_int32_300 = 300; + int32 optional_int32_1 = 1; + int32 optional_int32_2 = 2; + int32 optional_int32_3 = 3; + int32 optional_int32_4 = 4; + int32 optional_int32_63 = 63; + int32 optional_int32_64 = 64; + TestAllTypes optional_all_types = 9; + repeated TestAllTypes repeated_all_types = 10; +} + +message TestVerifyUint32Simple { + uint32 optional_uint32_1 = 1; + uint32 optional_uint32_2 = 2; + uint32 optional_uint32_63 = 63; + uint32 optional_uint32_64 = 64; +} + +message TestVerifyUint32 { + uint32 optional_uint32_1 = 1; + uint32 optional_uint32_2 = 2; + uint32 optional_uint32_63 = 63; + uint32 optional_uint32_64 = 64; + TestAllTypes optional_all_types = 9; + repeated TestAllTypes repeated_all_types = 10; +} + +message TestVerifyOneUint32 { + uint32 optional_uint32_1 = 1; + int32 optional_int32_2 = 2; + int32 optional_int32_63 = 63; + int32 optional_int32_64 = 64; + TestAllTypes optional_all_types = 9; + repeated TestAllTypes repeated_all_types = 10; +} + +message TestVerifyOneInt32BigFieldNumber { + int32 optional_int32_65 = 65; + int64 optional_int64_1 = 1; + int64 optional_int64_2 = 2; + int64 optional_int64_63 = 63; + int64 optional_int64_64 = 64; + TestAllTypes optional_all_types = 9; + repeated TestAllTypes repeated_all_types = 10; +} + +message TestVerifyInt32BigFieldNumber { + int32 optional_int32_1000 = 1000; + int32 optional_int32_65 = 65; + int32 optional_int32_1 = 1; + int32 optional_int32_2 = 2; + int32 optional_int32_63 = 63; + int32 optional_int32_64 = 64; + TestAllTypes optional_all_types = 9; + repeated TestAllTypes repeated_all_types = 10; +} + +message TestVerifyUint32BigFieldNumber { + uint32 optional_uint32_1000 = 1000; + uint32 optional_uint32_65 = 65; + uint32 optional_uint32_1 = 1; + uint32 optional_uint32_2 = 2; + uint32 optional_uint32_63 = 63; + uint32 optional_uint32_64 = 64; + TestAllTypes optional_all_types = 9; + repeated TestAllTypes repeated_all_types = 10; +} + +message TestVerifyBigFieldNumberUint32 { + message Nested { + uint32 optional_uint32_5000 = 5000; + uint32 optional_uint32_1000 = 1000; + uint32 optional_uint32_66 = 66; + uint32 optional_uint32_65 = 65; + uint32 optional_uint32_1 = 1; + uint32 optional_uint32_2 = 2; + uint32 optional_uint32_63 = 63; + uint32 optional_uint32_64 = 64; + Nested optional_nested = 9; + repeated Nested repeated_nested = 10; + } + + Nested optional_nested = 1; +} + +// This message contains different kind of enums to exercise the different +// parsers in table-driven. +message EnumParseTester { + enum SeqSmall0 { + SEQ_SMALL_0_DEFAULT = 0; + SEQ_SMALL_0_1 = 1; + SEQ_SMALL_0_2 = 2; + } + + SeqSmall0 optional_seq_small_0_lowfield = 1; + SeqSmall0 optional_seq_small_0_midfield = 1001; + SeqSmall0 optional_seq_small_0_hifield = 1000001; + repeated SeqSmall0 repeated_seq_small_0_lowfield = 2; + repeated SeqSmall0 repeated_seq_small_0_midfield = 1002; + repeated SeqSmall0 repeated_seq_small_0_hifield = 1000002; + repeated SeqSmall0 packed_seq_small_0_lowfield = 3 [ + features.repeated_field_encoding = PACKED + ]; + + repeated SeqSmall0 packed_seq_small_0_midfield = 1003 [ + features.repeated_field_encoding = PACKED + ]; + + repeated SeqSmall0 packed_seq_small_0_hifield = 1000003 [ + features.repeated_field_encoding = PACKED + ]; + + enum SeqSmall1 { + SEQ_SMALL_1_DEFAULT = 1; + SEQ_SMALL_1_2 = 2; + SEQ_SMALL_1_3 = 3; + } + + SeqSmall1 optional_seq_small_1_lowfield = 4; + SeqSmall1 optional_seq_small_1_midfield = 1004; + SeqSmall1 optional_seq_small_1_hifield = 1000004; + repeated SeqSmall1 repeated_seq_small_1_lowfield = 5; + repeated SeqSmall1 repeated_seq_small_1_midfield = 1005; + repeated SeqSmall1 repeated_seq_small_1_hifield = 1000005; + repeated SeqSmall1 packed_seq_small_1_lowfield = 6 [ + features.repeated_field_encoding = PACKED + ]; + + repeated SeqSmall1 packed_seq_small_1_midfield = 1006 [ + features.repeated_field_encoding = PACKED + ]; + + repeated SeqSmall1 packed_seq_small_1_hifield = 1000006 [ + features.repeated_field_encoding = PACKED + ]; + + enum SeqLarge { + SEQ_LARGE_DEFAULT = -1; + SEQ_LARGE_0 = 0; + SEQ_LARGE_1 = 1; + SEQ_LARGE_2 = 2; + SEQ_LARGE_3 = 3; + SEQ_LARGE_4 = 4; + SEQ_LARGE_5 = 5; + SEQ_LARGE_6 = 6; + SEQ_LARGE_7 = 7; + SEQ_LARGE_8 = 8; + SEQ_LARGE_9 = 9; + SEQ_LARGE_10 = 10; + SEQ_LARGE_11 = 11; + SEQ_LARGE_12 = 12; + SEQ_LARGE_13 = 13; + SEQ_LARGE_14 = 14; + SEQ_LARGE_15 = 15; + SEQ_LARGE_16 = 16; + SEQ_LARGE_17 = 17; + SEQ_LARGE_18 = 18; + SEQ_LARGE_19 = 19; + SEQ_LARGE_20 = 20; + SEQ_LARGE_21 = 21; + SEQ_LARGE_22 = 22; + SEQ_LARGE_23 = 23; + SEQ_LARGE_24 = 24; + SEQ_LARGE_25 = 25; + SEQ_LARGE_26 = 26; + SEQ_LARGE_27 = 27; + SEQ_LARGE_28 = 28; + SEQ_LARGE_29 = 29; + SEQ_LARGE_30 = 30; + SEQ_LARGE_31 = 31; + SEQ_LARGE_32 = 32; + SEQ_LARGE_33 = 33; + } + + SeqLarge optional_seq_large_lowfield = 7; + SeqLarge optional_seq_large_midfield = 1007; + SeqLarge optional_seq_large_hifield = 1000007; + repeated SeqLarge repeated_seq_large_lowfield = 8; + repeated SeqLarge repeated_seq_large_midfield = 1008; + repeated SeqLarge repeated_seq_large_hifield = 1000008; + repeated SeqLarge packed_seq_large_lowfield = 9 [ + features.repeated_field_encoding = PACKED + ]; + + repeated SeqLarge packed_seq_large_midfield = 1009 [ + features.repeated_field_encoding = PACKED + ]; + + repeated SeqLarge packed_seq_large_hifield = 1000009 [ + features.repeated_field_encoding = PACKED + ]; + + enum Arbitrary { + ARBITRARY_DEFAULT = -123123; + ARBITRARY_1 = -123; + ARBITRARY_2 = 213; + ARBITRARY_3 = 213213; + ARBITRARY_MIN = -2147483648; + ARBITRARY_MAX = 2147483647; + } + + Arbitrary optional_arbitrary_lowfield = 10; + Arbitrary optional_arbitrary_midfield = 1010; + Arbitrary optional_arbitrary_hifield = 1000010; + repeated Arbitrary repeated_arbitrary_lowfield = 11; + repeated Arbitrary repeated_arbitrary_midfield = 1011; + repeated Arbitrary repeated_arbitrary_hifield = 1000011; + repeated Arbitrary packed_arbitrary_lowfield = 12 [ + features.repeated_field_encoding = PACKED + ]; + + repeated Arbitrary packed_arbitrary_midfield = 1012 [ + features.repeated_field_encoding = PACKED + ]; + + repeated Arbitrary packed_arbitrary_hifield = 1000012 [ + features.repeated_field_encoding = PACKED + ]; + + extensions 2000000 to max; + + extend EnumParseTester { + Arbitrary optional_arbitrary_ext = 2000000; + repeated Arbitrary repeated_arbitrary_ext = 2000001; + repeated Arbitrary packed_arbitrary_ext = 2000002 [ + features.repeated_field_encoding = PACKED + ]; + } + + // An arbitrary field we can append to to break the runs of repeated fields. + int32 other_field = 99; +} + +// This message contains different kind of bool fields to exercise the different +// parsers in table-drived. +message BoolParseTester { + bool optional_bool_lowfield = 1; + bool optional_bool_midfield = 1001; + bool optional_bool_hifield = 1000001; + repeated bool repeated_bool_lowfield = 2; + repeated bool repeated_bool_midfield = 1002; + repeated bool repeated_bool_hifield = 1000002; + repeated bool packed_bool_lowfield = 3 [ + features.repeated_field_encoding = PACKED + ]; + + repeated bool packed_bool_midfield = 1003 [ + features.repeated_field_encoding = PACKED + ]; + + repeated bool packed_bool_hifield = 1000003 [ + features.repeated_field_encoding = PACKED + ]; + + extensions 2000000 to max; + + extend BoolParseTester { + bool optional_bool_ext = 2000000; + repeated bool repeated_bool_ext = 2000001; + repeated bool packed_bool_ext = 2000002 [ + features.repeated_field_encoding = PACKED + ]; + } + + // An arbitrary field we can append to to break the runs of repeated fields. + int32 other_field = 99; +} + +message Int32ParseTester { + int32 optional_int32_lowfield = 1; + int32 optional_int32_midfield = 1001; + int32 optional_int32_hifield = 1000001; + repeated int32 repeated_int32_lowfield = 2; + repeated int32 repeated_int32_midfield = 1002; + repeated int32 repeated_int32_hifield = 1000002; + repeated int32 packed_int32_lowfield = 3 [ + features.repeated_field_encoding = PACKED + ]; + + repeated int32 packed_int32_midfield = 1003 [ + features.repeated_field_encoding = PACKED + ]; + + repeated int32 packed_int32_hifield = 1000003 [ + features.repeated_field_encoding = PACKED + ]; + + extensions 2000000 to max; + + extend Int32ParseTester { + int32 optional_int32_ext = 2000000; + repeated int32 repeated_int32_ext = 2000001; + repeated int32 packed_int32_ext = 2000002 [ + features.repeated_field_encoding = PACKED + ]; + } + + // An arbitrary field we can append to to break the runs of repeated fields. + int32 other_field = 99; +} + +message Int64ParseTester { + int64 optional_int64_lowfield = 1; + int64 optional_int64_midfield = 1001; + int64 optional_int64_hifield = 1000001; + repeated int64 repeated_int64_lowfield = 2; + repeated int64 repeated_int64_midfield = 1002; + repeated int64 repeated_int64_hifield = 1000002; + repeated int64 packed_int64_lowfield = 3 [ + features.repeated_field_encoding = PACKED + ]; + + repeated int64 packed_int64_midfield = 1003 [ + features.repeated_field_encoding = PACKED + ]; + + repeated int64 packed_int64_hifield = 1000003 [ + features.repeated_field_encoding = PACKED + ]; + + extensions 2000000 to max; + + extend Int64ParseTester { + int64 optional_int64_ext = 2000000; + repeated int64 repeated_int64_ext = 2000001; + repeated int64 packed_int64_ext = 2000002 [ + features.repeated_field_encoding = PACKED + ]; + } + + // An arbitrary field we can append to to break the runs of repeated fields. + int32 other_field = 99; +} + +message InlinedStringIdxRegressionProto { + // We mix data to make sure aux ids and inlined string idx do not match. + // aux_idx == inlined_string_idx == 1 + string str1 = 1; + + // aux_idx == 2 + InlinedStringIdxRegressionProto sub = 2; + + // aux_idx == 3, inlined_string_idx == 2 + string str2 = 3; + + // aux_idx == 4, inlined_string_idx == 3 + bytes str3 = 4; +} + +message StringParseTester { + string optional_string_lowfield = 1; + string optional_string_midfield = 1001; + string optional_string_hifield = 1000001; + repeated string repeated_string_lowfield = 2; + repeated string repeated_string_midfield = 1002; + repeated string repeated_string_hifield = 1000002; + + extensions 2000000 to max; + + extend StringParseTester { + string optional_string_ext = 2000000; + repeated string repeated_string_ext = 2000001; + } +} + +message BadFieldNames { + int32 OptionalInt32 = 1; + int32 for = 2; +} + +message TestNestedMessageRedaction { + string optional_unredacted_nested_string = 1; + string optional_redacted_nested_string = 2 [ + debug_redact = true + ]; +} + +message RedactedFields { + string optional_redacted_string = 1 [ + debug_redact = true + ]; + + string optional_unredacted_string = 2; + repeated string repeated_redacted_string = 3 [ + debug_redact = true + ]; + + repeated string repeated_unredacted_string = 4; + TestNestedMessageRedaction optional_redacted_message = 5 [ + debug_redact = true + ]; + + TestNestedMessageRedaction optional_unredacted_message = 6; + repeated TestNestedMessageRedaction repeated_redacted_message = 7 [ + debug_redact = true + ]; + + repeated TestNestedMessageRedaction repeated_unredacted_message = 8; + map map_redacted_string = 9 [ + debug_redact = true + ]; + + map map_unredacted_string = 10; + string optional_redacted_false_string = 11 [ + debug_redact = false + ]; + + extensions 20 to 30; +} + +extend RedactedFields { + string redacted_extension = 20 [ + debug_redact = true + ]; +} + +message TestString { + string optional_string = 1; +} + +message TestCord { + bytes optional_bytes_cord = 1 [ + ctype = CORD + ]; + + bytes optional_bytes_cord_default = 2 [ + ctype = CORD, + default = "hello" + ]; +} + +message TestPackedEnumSmallRange { + enum NestedEnum { + UNSPECIFIED = 0; + FOO = 1; + BAR = 2; + BAZ = 3; + } + + repeated NestedEnum vals = 1 [ + features.repeated_field_encoding = PACKED + ]; +} + +message EnumsForBenchmark { + enum Flat { + A0 = 0; + A1 = 1; + A2 = 2; + A3 = 3; + A4 = 4; + A5 = 5; + A6 = 6; + A7 = 7; + A8 = 8; + A9 = 9; + A10 = 10; + A11 = 11; + A12 = 12; + A13 = 13; + A14 = 14; + A15 = 15; + } + + // Has a few holes, bitmap can be used. + enum AlmostFlat { + B0 = 0; + B1 = 1; + B2 = 2; + B3 = 3; + B5 = 5; + B6 = 6; + B7 = 7; + B8 = 8; + B9 = 9; + B11 = 11; + B12 = 12; + B13 = 13; + B14 = 14; + B15 = 15; + B17 = 17; + B19 = 19; + } + + enum Sparse { + C536 = 536; + C8387 = 8387; + C9673 = 9673; + C10285 = 10285; + C13318 = 13318; + C15963 = 15963; + C16439 = 16439; + C18197 = 18197; + C19430 = 19430; + C20361 = 20361; + C20706 = 20706; + C21050 = 21050; + C21906 = 21906; + C27265 = 27265; + C30109 = 30109; + C31670 = 31670; + } +} + +message TestMessageWithManyRepeatedPtrFields { + repeated string repeated_string_1 = 1; + repeated string repeated_string_2 = 2; + repeated string repeated_string_3 = 3; + repeated string repeated_string_4 = 4; + repeated string repeated_string_5 = 5; + repeated string repeated_string_6 = 6; + repeated string repeated_string_7 = 7; + repeated string repeated_string_8 = 8; + repeated string repeated_string_9 = 9; + repeated string repeated_string_10 = 10; + repeated string repeated_string_11 = 11; + repeated string repeated_string_12 = 12; + repeated string repeated_string_13 = 13; + repeated string repeated_string_14 = 14; + repeated string repeated_string_15 = 15; + repeated string repeated_string_16 = 16; + repeated string repeated_string_17 = 17; + repeated string repeated_string_18 = 18; + repeated string repeated_string_19 = 19; + repeated string repeated_string_20 = 20; + repeated string repeated_string_21 = 21; + repeated string repeated_string_22 = 22; + repeated string repeated_string_23 = 23; + repeated string repeated_string_24 = 24; + repeated string repeated_string_25 = 25; + repeated string repeated_string_26 = 26; + repeated string repeated_string_27 = 27; + repeated string repeated_string_28 = 28; + repeated string repeated_string_29 = 29; + repeated string repeated_string_30 = 30; + repeated string repeated_string_31 = 31; + repeated string repeated_string_32 = 32; +} + +message MessageCreatorZeroInit { + int32 i = 1; + double d = 2; + MessageCreatorZeroInit m = 3; + + oneof one { + string os = 10; + string oc = 11 [ + ctype = CORD + ]; + + fixed64 of = 12; + MessageCreatorZeroInit ol = 13 [ + lazy = true + ]; + } +} + +message MessageCreatorMemcpy { + string s = 1; + repeated int32 i = 2 [ + features.repeated_field_encoding = PACKED + ]; + + MessageCreatorMemcpy m = 3 [ + lazy = true + ]; + + map m2 = 4; +} + +message MessageCreatorFunc { + // This one is ArenaDtorNeeds::kRequired so we must run the constructor. + string c = 3 [ + ctype = CORD + ]; +} + +message FastParseTableCompression { + int32 important_field_1 = 1; + int32 important_field_2 = 2; + int32 unimportant_field_3 = 3; + int32 unimportant_field_4 = 4; + int32 unimportant_field_5 = 5; + reserved 6, 7, 8; + + int32 unimportant_field_9 = 9; + reserved 10; + int32 important_field_11 = 11; + int32 unimportant_field_12 = 12; + reserved 13; + int32 important_field_14 = 14; + int32 unimportant_field_15 = 15; + reserved 16; +} + +message TestMessageForMove_Small { + int32 a = 1; + int32 b = 2; +} + +message TestMessageForMove_Large { + int32 a1 = 1; + int32 a2 = 2; + int32 a3 = 3; + int32 a4 = 4; + int32 a5 = 5; + int32 a6 = 6; + int32 a7 = 7; + int32 a8 = 8; + int32 a9 = 9; + repeated int32 a11 = 11; + repeated int32 a12 = 12; + repeated int32 a13 = 13; + repeated int32 a14 = 14; + repeated int32 a15 = 15; + repeated int32 a16 = 16; + repeated int32 a17 = 17; + repeated int32 a18 = 18; + repeated int32 a19 = 19; + string s101 = 101; + string s102 = 102; + string s103 = 103; + string s104 = 104; + string s105 = 105; + string s106 = 106; + string s107 = 107; + string s108 = 108; + string s109 = 109; + repeated string s111 = 111; + repeated string s112 = 112; + repeated string s113 = 113; + repeated string s114 = 114; + repeated string s115 = 115; + repeated string s116 = 116; + repeated string s117 = 117; + repeated string s118 = 118; + repeated string s119 = 119; +} diff --git a/Protos/upstream/google/protobuf/unittest_arena.proto b/Protos/upstream/google/protobuf/unittest_arena.proto new file mode 100644 index 000000000..1effadac4 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_arena.proto @@ -0,0 +1,22 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +edition = "2024"; + +package proto2_arena_unittest; + +// Use expanded encoding for repeated fields by default (proto2 behavior). +option features.repeated_field_encoding = EXPANDED; +option cc_enable_arenas = true; + +message NestedMessage { + int32 d = 1; +} + +message ArenaMessage { + repeated NestedMessage repeated_nested_message = 1; +} diff --git a/Protos/google/protobuf/unittest_custom_options.proto b/Protos/upstream/google/protobuf/unittest_custom_options.proto similarity index 80% rename from Protos/google/protobuf/unittest_custom_options.proto rename to Protos/upstream/google/protobuf/unittest_custom_options.proto index f774c766e..3ebb8e36a 100644 --- a/Protos/google/protobuf/unittest_custom_options.proto +++ b/Protos/upstream/google/protobuf/unittest_custom_options.proto @@ -1,32 +1,9 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd // Author: benjy@google.com (Benjy Weinberger) // Based on original Protocol Buffers design by @@ -50,7 +27,7 @@ import "google/protobuf/descriptor.proto"; // We don't put this in a package within proto2 because we need to make sure // that the generated code doesn't depend on being in the proto2 namespace. -package protobuf_unittest; +package proto2_unittest; // Some simple test custom options of various types. @@ -108,6 +85,8 @@ message TestMessageWithCustomOptions { int32 oneof_field = 2; } + map map_field = 3 [(field_opt1) = 12345]; + enum AnEnum { option (enum_opt1) = -789; @@ -212,6 +191,26 @@ message SettingRealsFromNegativeInts { option (double_opt) = -154; } +message SettingRealsFromInf { + option (float_opt) = inf; + option (double_opt) = inf; +} + +message SettingRealsFromNegativeInf { + option (float_opt) = -inf; + option (double_opt) = -inf; +} + +message SettingRealsFromNan { + option (float_opt) = nan; + option (double_opt) = nan; +} + +message SettingRealsFromNegativeNan { + option (float_opt) = -nan; + option (double_opt) = -nan; +} + // Options of complex message types, themselves combined and extended in // various ways. @@ -243,7 +242,7 @@ message ComplexOptionType2 { } message ComplexOptionType3 { - optional int32 qux = 1; + optional int32 moo = 1; optional group ComplexOptionType5 = 2 { optional int32 plugh = 3; @@ -251,7 +250,7 @@ message ComplexOptionType3 { } extend ComplexOptionType1 { - optional int32 quux = 7663707; + optional int32 mooo = 7663707; optional ComplexOptionType3 corge = 7663442; } @@ -261,7 +260,7 @@ extend ComplexOptionType2 { } extend google.protobuf.MessageOptions { - optional protobuf_unittest.ComplexOptionType1 complex_opt1 = 7646756; + optional proto2_unittest.ComplexOptionType1 complex_opt1 = 7646756; optional ComplexOptionType2 complex_opt2 = 7636949; optional ComplexOptionType3 complex_opt3 = 7636463; optional group ComplexOpt6 = 7595468 { @@ -271,19 +270,19 @@ extend google.protobuf.MessageOptions { // Note that we try various different ways of naming the same extension. message VariousComplexOptions { - option (.protobuf_unittest.complex_opt1).foo = 42; - option (protobuf_unittest.complex_opt1).(.protobuf_unittest.quux) = 324; - option (.protobuf_unittest.complex_opt1).(protobuf_unittest.corge).qux = 876; - option (protobuf_unittest.complex_opt1).foo4 = 99; - option (protobuf_unittest.complex_opt1).foo4 = 88; + option (.proto2_unittest.complex_opt1).foo = 42; + option (proto2_unittest.complex_opt1).(.proto2_unittest.mooo) = 324; + option (.proto2_unittest.complex_opt1).(proto2_unittest.corge).moo = 876; + option (proto2_unittest.complex_opt1).foo4 = 99; + option (proto2_unittest.complex_opt1).foo4 = 88; option (complex_opt2).baz = 987; option (complex_opt2).(grault) = 654; option (complex_opt2).bar.foo = 743; - option (complex_opt2).bar.(quux) = 1999; - option (complex_opt2).bar.(protobuf_unittest.corge).qux = 2008; + option (complex_opt2).bar.(mooo) = 1999; + option (complex_opt2).bar.(proto2_unittest.corge).moo = 2008; option (complex_opt2).(garply).foo = 741; - option (complex_opt2).(garply).(.protobuf_unittest.quux) = 1998; - option (complex_opt2).(protobuf_unittest.garply).(corge).qux = 2121; + option (complex_opt2).(garply).(.proto2_unittest.mooo) = 1998; + option (complex_opt2).(proto2_unittest.garply).(corge).moo = 2121; option (ComplexOptionType2.ComplexOptionType4.complex_opt4).waldo = 1971; option (complex_opt2).fred.waldo = 321; option (complex_opt2).barney = { @@ -292,7 +291,7 @@ message VariousComplexOptions { option (complex_opt2).barney = { waldo: 212 }; - option (protobuf_unittest.complex_opt3).qux = 9; + option (proto2_unittest.complex_opt3).moo = 9; option (complex_opt3).complexoptiontype5.plugh = 22; option (complexopt6).xyzzy = 24; } @@ -371,18 +370,18 @@ option (fileopt) = { // Include a google.protobuf.FileOptions and recursively extend it with // another fileopt. file { - [protobuf_unittest.fileopt] { s: 'FileExtensionAnnotation' } + [proto2_unittest.fileopt] { s: 'FileExtensionAnnotation' } } // A message set inside an option value mset { - [protobuf_unittest.AggregateMessageSetElement.message_set_extension] { + [proto2_unittest.AggregateMessageSetElement.message_set_extension] { s: 'EmbeddedMessageSetElement' } } any { - [type.googleapis.com/protobuf_unittest.AggregateMessageSetElement] { + [type.googleapis.com/proto2_unittest.AggregateMessageSetElement] { s: 'EmbeddedMessageSetElement' } } @@ -437,7 +436,9 @@ message NestedOptionType { // Custom message option that has a required enum field. // WARNING: this is strongly discouraged! message OldOptionType { - enum TestEnum { OLD_VALUE = 0; } + enum TestEnum { + OLD_VALUE = 0; + } required TestEnum value = 1; } diff --git a/Protos/upstream/google/protobuf/unittest_custom_options_unlinked.proto b/Protos/upstream/google/protobuf/unittest_custom_options_unlinked.proto new file mode 100644 index 000000000..4addbaf89 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_custom_options_unlinked.proto @@ -0,0 +1,37 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: benjy@google.com (Benjy Weinberger) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// A proto file used to test the "custom options" feature when not linked in. + +edition = "2024"; + +// A custom file option (defined below). +option (file_opt1) = 9876543210; + +import "google/protobuf/descriptor.proto"; + +// We don't put this in a package within proto2 because we need to make sure +// that the generated code doesn't depend on being in the proto2 namespace. +package proto2_unittest_unlinked; + +// Some simple test custom options of various types. + +extend google.protobuf.FileOptions { + uint64 file_opt1 = 7736975; +} + +extend google.protobuf.MessageOptions { + int32 message_opt1 = 7739037; +} + +extend google.protobuf.FieldOptions { + fixed64 field_opt1 = 7740937; +} diff --git a/Protos/upstream/google/protobuf/unittest_delimited.proto b/Protos/upstream/google/protobuf/unittest_delimited.proto new file mode 100644 index 000000000..30fa79097 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_delimited.proto @@ -0,0 +1,77 @@ +edition = "2024"; + +package editions_unittest; + +import "google/protobuf/unittest_delimited_import.proto"; + +option java_outer_classname = "UnittestDelimited"; + +// Test various scenarios that are now possible in edition 2023+ that weren't in +// google.protobuf. + +message LengthPrefixed { + int32 a = 1; + int32 b = 2; +} + +message NotGroupLikeScope { + int32 a = 1; + int32 b = 2; +} + +message GroupLikeFileScope { + int32 a = 1; + int32 b = 2; +} + +message TestDelimited { + message LengthPrefixed { + int32 a = 1; + int32 b = 2; + } + // Non-delimited field that otherwise looks group-like. + LengthPrefixed lengthprefixed = 1; + + // Nested field for nested tests. + TestDelimited nested = 2 [features.message_encoding = DELIMITED]; + + message GroupLike { + int32 a = 1; + int32 b = 2; + } + + // Truly group-like field. + GroupLike grouplike = 3 [features.message_encoding = DELIMITED]; + + // Delimited field that isn't group-like solely because of its name. + GroupLike notgrouplike = 4 [features.message_encoding = DELIMITED]; + + // Delimited field that isn't group-like because of the scope of its type. + NotGroupLikeScope notgrouplikescope = 5 + [features.message_encoding = DELIMITED]; + + // Delimited field that's grouplike except that it's an imported type. + MessageImport messageimport = 6 [features.message_encoding = DELIMITED]; + + extensions 1000 to max; +} + +extend TestDelimited { + // Non-delimited field that otherwise looks group-like. + LengthPrefixed lengthprefixed = 1004; + + // Truly group-like extension. + GroupLikeFileScope grouplikefilescope = 1000 + [features.message_encoding = DELIMITED]; + + // Delimited extension that isn't group-like because of its name. + NotGroupLikeScope not_group_like_scope = 1001 + [features.message_encoding = DELIMITED]; + + // Delimited extension that isn't group-like because of the scope of its type. + TestDelimited.GroupLike grouplike = 1002 + [features.message_encoding = DELIMITED]; + + // Delimited extension that's grouplike except that it's an imported type. + MessageImport messageimport = 1003 [features.message_encoding = DELIMITED]; +} diff --git a/Protos/upstream/google/protobuf/unittest_delimited_import.proto b/Protos/upstream/google/protobuf/unittest_delimited_import.proto new file mode 100644 index 000000000..5b53d1843 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_delimited_import.proto @@ -0,0 +1,8 @@ +edition = "2024"; + +package editions_unittest; + +message MessageImport { + int32 a = 1; + int32 b = 2; +} diff --git a/Protos/upstream/google/protobuf/unittest_drop_unknown_fields.proto b/Protos/upstream/google/protobuf/unittest_drop_unknown_fields.proto new file mode 100644 index 000000000..c3ab2b22d --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_drop_unknown_fields.proto @@ -0,0 +1,37 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +edition = "2024"; + +package unittest_drop_unknown_fields; + +// Treat all fields as implicit present by default (proto3 behavior). +option features.field_presence = IMPLICIT; +option objc_class_prefix = "DropUnknowns"; +option csharp_namespace = "Google.Protobuf.TestProtos"; + +message Foo { + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + } + int32 int32_value = 1; + NestedEnum enum_value = 2; +} + +message FooWithExtraFields { + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + MOO = 3; + } + int32 int32_value = 1; + NestedEnum enum_value = 2; + int32 extra_int32_value = 3; +} diff --git a/Protos/upstream/google/protobuf/unittest_embed_optimize_for.proto b/Protos/upstream/google/protobuf/unittest_embed_optimize_for.proto new file mode 100644 index 000000000..ef9b567ee --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_embed_optimize_for.proto @@ -0,0 +1,29 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// A proto file which imports a proto file that uses optimize_for = CODE_SIZE. + +syntax = "proto2"; + +package proto2_unittest; + +import "google/protobuf/unittest_optimize_for.proto"; + +// We optimize for speed here, but we are importing a proto that is optimized +// for code size. +option optimize_for = SPEED; + +message TestEmbedOptimizedForSize { + // Test that embedding a message which has optimize_for = CODE_SIZE into + // one optimized for speed works. + optional TestOptimizedForSize optional_message = 1; + repeated TestOptimizedForSize repeated_message = 2; +} diff --git a/Protos/upstream/google/protobuf/unittest_empty.proto b/Protos/upstream/google/protobuf/unittest_empty.proto new file mode 100644 index 000000000..f24117817 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_empty.proto @@ -0,0 +1,18 @@ +// NOLINT(no_package_specified): Test proto with no package + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// This file intentionally left blank. (At one point this wouldn't compile +// correctly.) + +syntax = "proto2"; + diff --git a/Protos/google/protobuf/unittest_enormous_descriptor.proto b/Protos/upstream/google/protobuf/unittest_enormous_descriptor.proto similarity index 99% rename from Protos/google/protobuf/unittest_enormous_descriptor.proto rename to Protos/upstream/google/protobuf/unittest_enormous_descriptor.proto index c700a273b..5a1acd8eb 100644 --- a/Protos/google/protobuf/unittest_enormous_descriptor.proto +++ b/Protos/upstream/google/protobuf/unittest_enormous_descriptor.proto @@ -1,33 +1,11 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// Copyright 2009 Google Inc. All rights reserved. // Author: kenton@google.com (Kenton Varda) // Based on original Protocol Buffers design by // Sanjay Ghemawat, Jeff Dean, and others. @@ -38,12 +16,13 @@ syntax = "proto2"; -package protobuf_unittest; +package proto2_unittest; option java_package = "com.google.protobuf"; // Avoid generating insanely long methods. option optimize_for = CODE_SIZE; +// clang-format off message TestEnormousDescriptor { optional string long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_1 = 1 [default="long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"]; optional string long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_2 = 2 [default="long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"]; @@ -1046,3 +1025,4 @@ message TestEnormousDescriptor { optional string long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_999 = 999 [default="long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"]; optional string long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_1000 = 1000 [default="long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"]; } +// clang-format on diff --git a/Protos/upstream/google/protobuf/unittest_extension_set.proto b/Protos/upstream/google/protobuf/unittest_extension_set.proto new file mode 100644 index 000000000..1f67b5ba8 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_extension_set.proto @@ -0,0 +1,28 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// This file contains messages for testing extensions. + +syntax = "proto2"; + +package proto2_unittest; + +option optimize_for = SPEED; +option csharp_namespace = "Google.ProtocolBuffers.TestProtos"; + +// A message with message_set_wire_format. +message TestExtensionSet { + extensions 4 to max; +} + +message TestExtensionSetContainer { + optional TestExtensionSet extension = 1; +} diff --git a/Protos/upstream/google/protobuf/unittest_features.proto b/Protos/upstream/google/protobuf/unittest_features.proto new file mode 100644 index 000000000..57d17e388 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_features.proto @@ -0,0 +1,297 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2023 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +edition = "2024"; + +package pb; + +import "google/protobuf/descriptor.proto"; + +option java_outer_classname = "UnittestFeatures"; + +extend google.protobuf.FeatureSet { + TestFeatures test = 9999; +} + +message TestMessage { + extend google.protobuf.FeatureSet { + TestFeatures test_message = 9998; + } + message Nested { + extend google.protobuf.FeatureSet { + TestFeatures test_nested = 9997; + } + } +} + +enum EnumFeature { + TEST_ENUM_FEATURE_UNKNOWN = 0; + VALUE1 = 1; + VALUE2 = 2; + VALUE3 = 3; + VALUE4 = 4; + VALUE5 = 5; + VALUE6 = 6; + VALUE7 = 7; + VALUE8 = 8; + VALUE9 = 9; + VALUE10 = 10; + VALUE11 = 11; + VALUE12 = 12; + VALUE13 = 13; + VALUE14 = 14; + VALUE15 = 15; +} + +enum UnstableEnumFeature { + TEST_UNSTABLE_ENUM_FEATURE_UNKNOWN = 0; + UNSTABLE1 = 1; + UNSTABLE2 = 2; + UNSTABLE3 = 3 [feature_support = { edition_introduced: EDITION_UNSTABLE }]; + UNSTABLE4 = 4; +} + +enum ValueLifetimeFeature { + TEST_VALUE_LIFETIME_UNKNOWN = 0; + VALUE_LIFETIME_INHERITED = 1; + VALUE_LIFETIME_SUPPORT = 2 [feature_support = { + edition_introduced: EDITION_99997_TEST_ONLY + edition_deprecated: EDITION_99998_TEST_ONLY + deprecation_warning: "Custom feature deprecation warning" + edition_removed: EDITION_99999_TEST_ONLY + }]; + VALUE_LIFETIME_EMPTY_SUPPORT = 3 [feature_support = {}]; + VALUE_LIFETIME_FUTURE = 4 + [feature_support.edition_introduced = EDITION_99997_TEST_ONLY]; + VALUE_LIFETIME_DEPRECATED = 5 [feature_support = { + edition_deprecated: EDITION_99997_TEST_ONLY + deprecation_warning: "Custom feature deprecation warning" + }]; + VALUE_LIFETIME_REMOVED = 6 [feature_support = { + edition_deprecated: EDITION_2023 + edition_removed: EDITION_99997_TEST_ONLY + removal_error: "Custom feature removal error" + }]; +} + +message TestFeatures { + EnumFeature file_feature = 1 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FILE, + feature_support.edition_introduced = EDITION_2023, + edition_defaults = { edition: EDITION_LEGACY, value: "VALUE1" }, + edition_defaults = { edition: EDITION_PROTO3, value: "VALUE2" }, + edition_defaults = { edition: EDITION_2023, value: "VALUE3" }, + edition_defaults = { edition: EDITION_99997_TEST_ONLY, value: "VALUE4" }, + edition_defaults = { edition: EDITION_99998_TEST_ONLY, value: "VALUE5" } + ]; + EnumFeature extension_range_feature = 2 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_EXTENSION_RANGE, + feature_support.edition_introduced = EDITION_2023, + edition_defaults = { edition: EDITION_LEGACY, value: "VALUE1" } + ]; + EnumFeature message_feature = 3 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_MESSAGE, + feature_support.edition_introduced = EDITION_2023, + edition_defaults = { edition: EDITION_LEGACY, value: "VALUE1" } + ]; + EnumFeature field_feature = 4 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FIELD, + feature_support.edition_introduced = EDITION_2023, + edition_defaults = { edition: EDITION_LEGACY, value: "VALUE1" } + ]; + EnumFeature oneof_feature = 5 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_ONEOF, + feature_support.edition_introduced = EDITION_2023, + edition_defaults = { edition: EDITION_LEGACY, value: "VALUE1" } + ]; + EnumFeature enum_feature = 6 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_ENUM, + feature_support.edition_introduced = EDITION_2023, + edition_defaults = { edition: EDITION_LEGACY, value: "VALUE1" } + ]; + EnumFeature enum_entry_feature = 7 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_ENUM_ENTRY, + feature_support.edition_introduced = EDITION_2023, + edition_defaults = { edition: EDITION_LEGACY, value: "VALUE1" } + ]; + EnumFeature service_feature = 8 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_SERVICE, + feature_support.edition_introduced = EDITION_2023, + edition_defaults = { edition: EDITION_LEGACY, value: "VALUE1" } + ]; + EnumFeature method_feature = 9 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_METHOD, + feature_support = { + edition_introduced: EDITION_2023, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "VALUE1" } + ]; + EnumFeature multiple_feature = 10 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FILE, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_MESSAGE, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_ENUM_ENTRY, + targets = TARGET_TYPE_SERVICE, + targets = TARGET_TYPE_METHOD, + targets = TARGET_TYPE_ONEOF, + targets = TARGET_TYPE_EXTENSION_RANGE, + feature_support.edition_introduced = EDITION_2023, + edition_defaults = { edition: EDITION_LEGACY, value: "VALUE1" } + ]; + + bool bool_field_feature = 11 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FIELD, + feature_support.edition_introduced = EDITION_2023, + edition_defaults = { edition: EDITION_LEGACY, value: "false" }, + edition_defaults = { edition: EDITION_99997_TEST_ONLY, value: "true" } + ]; + + EnumFeature source_feature = 15 [ + retention = RETENTION_SOURCE, + targets = TARGET_TYPE_FILE, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_MESSAGE, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_ENUM_ENTRY, + targets = TARGET_TYPE_SERVICE, + targets = TARGET_TYPE_METHOD, + targets = TARGET_TYPE_ONEOF, + targets = TARGET_TYPE_EXTENSION_RANGE, + feature_support.edition_introduced = EDITION_2023, + edition_defaults = { edition: EDITION_LEGACY, value: "VALUE1" } + ]; + + EnumFeature source_feature2 = 16 [ + retention = RETENTION_SOURCE, + targets = TARGET_TYPE_FILE, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_MESSAGE, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_ENUM_ENTRY, + targets = TARGET_TYPE_SERVICE, + targets = TARGET_TYPE_METHOD, + targets = TARGET_TYPE_ONEOF, + targets = TARGET_TYPE_EXTENSION_RANGE, + feature_support.edition_introduced = EDITION_2023, + edition_defaults = { edition: EDITION_LEGACY, value: "VALUE1" } + ]; + + EnumFeature removed_feature = 17 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FILE, + targets = TARGET_TYPE_FIELD, + feature_support = { + edition_introduced: EDITION_2023 + edition_deprecated: EDITION_2023 + deprecation_warning: "Custom feature deprecation warning" + edition_removed: EDITION_2024 + removal_error: "Custom feature removal error" + }, + edition_defaults = { edition: EDITION_LEGACY, value: "VALUE1" }, + edition_defaults = { edition: EDITION_2023, value: "VALUE2" }, + edition_defaults = { edition: EDITION_2024, value: "VALUE3" } + ]; + + EnumFeature same_edition_removed_feature = 21 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FILE, + targets = TARGET_TYPE_FIELD, + feature_support = { + edition_introduced: EDITION_2023 + edition_removed: EDITION_2023 + }, + edition_defaults = { edition: EDITION_LEGACY, value: "VALUE1" } + ]; + + EnumFeature future_feature = 18 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FILE, + targets = TARGET_TYPE_FIELD, + feature_support = { edition_introduced: EDITION_2024 }, + edition_defaults = { edition: EDITION_LEGACY, value: "VALUE1" }, + edition_defaults = { edition: EDITION_2024, value: "VALUE2" } + ]; + + EnumFeature legacy_feature = 19 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FILE, + targets = TARGET_TYPE_FIELD, + feature_support = { + edition_introduced: EDITION_PROTO3 + edition_removed: EDITION_2023 + removal_error: "Custom feature removal error" + }, + edition_defaults = { edition: EDITION_LEGACY, value: "VALUE1" }, + edition_defaults = { edition: EDITION_2023, value: "VALUE2" } + ]; + + ValueLifetimeFeature value_lifetime_feature = 20 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023 + edition_deprecated: EDITION_99998_TEST_ONLY + deprecation_warning: "Custom feature deprecation warning" + edition_removed: EDITION_99999_TEST_ONLY + removal_error: "Custom feature removal error" + }, + edition_defaults = { + edition: EDITION_LEGACY, + value: "VALUE_LIFETIME_INHERITED" + }, + // Verify edition defaults can use future values. + edition_defaults = { + edition: EDITION_2023, + value: "VALUE_LIFETIME_FUTURE" + }, + // Verify edition defaults can use removed values. + edition_defaults = { + edition: EDITION_99999_TEST_ONLY, + value: "VALUE_LIFETIME_FUTURE" + } + ]; + + UnstableEnumFeature new_unstable_feature = 22 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FILE, + targets = TARGET_TYPE_FIELD, + feature_support = { edition_introduced: EDITION_UNSTABLE }, + edition_defaults = { edition: EDITION_LEGACY, value: "UNSTABLE1" }, + edition_defaults = { edition: EDITION_UNSTABLE, value: "UNSTABLE2" } + ]; + + UnstableEnumFeature unstable_existing_feature = 23 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_ENUM, + feature_support.edition_introduced = EDITION_2023, + edition_defaults = { edition: EDITION_LEGACY, value: "UNSTABLE1" }, + edition_defaults = { edition: EDITION_2023, value: "UNSTABLE2" }, + edition_defaults = { edition: EDITION_UNSTABLE, value: "UNSTABLE3" } + ]; + UnstableEnumFeature removed_unstable_feature = 24 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_METHOD, + feature_support = { + edition_introduced: EDITION_2023, + edition_removed: EDITION_UNSTABLE, + removal_error: "Custom feature removal error" + }, + edition_defaults = { edition: EDITION_LEGACY, value: "UNSTABLE1" } + ]; +} diff --git a/Protos/upstream/google/protobuf/unittest_import.proto b/Protos/upstream/google/protobuf/unittest_import.proto new file mode 100644 index 000000000..41abd761d --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_import.proto @@ -0,0 +1,49 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// A proto file which is imported by unittest.proto to test importing. + +syntax = "proto2"; + +// We don't put this in a package within proto2 because we need to make sure +// that the generated code doesn't depend on being in the proto2 namespace. +// In test_util.h we do +// "using namespace unittest_import = proto2_unittest_import". +package proto2_unittest_import; + +option optimize_for = SPEED; +option cc_enable_arenas = true; + +// Exercise the java_package option. +option java_package = "com.google.protobuf.test"; + +// Do not set a java_outer_classname here to verify that Proto2 works without +// one. + +// Test public import +import public "google/protobuf/unittest_import_public.proto"; + +message ImportMessage { + optional int32 d = 1; +} + +enum ImportEnum { + IMPORT_FOO = 7; + IMPORT_BAR = 8; + IMPORT_BAZ = 9; +} + +// To use an enum in a map, it must has the first value as 0. +enum ImportEnumForMap { + UNKNOWN = 0; + FOO = 1; + BAR = 2; +} diff --git a/Protos/upstream/google/protobuf/unittest_import_lite.proto b/Protos/upstream/google/protobuf/unittest_import_lite.proto new file mode 100644 index 000000000..39e71214b --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_import_lite.proto @@ -0,0 +1,31 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// +// This is like unittest_import.proto but with optimize_for = LITE_RUNTIME. + +edition = "2023"; + +package proto2_unittest_import; + +import public "google/protobuf/unittest_import_public_lite.proto"; + +option optimize_for = LITE_RUNTIME; +option java_package = "com.google.protobuf"; + +message ImportMessageLite { + int32 d = 1; +} + +enum ImportEnumLite { + option features.enum_type = CLOSED; + + IMPORT_LITE_FOO = 7; + IMPORT_LITE_BAR = 8; + IMPORT_LITE_BAZ = 9; +} diff --git a/Protos/upstream/google/protobuf/unittest_import_option.proto b/Protos/upstream/google/protobuf/unittest_import_option.proto new file mode 100644 index 000000000..346826ada --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_import_option.proto @@ -0,0 +1,31 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// A proto file to test options importing. +edition = "2024"; + +package proto2_unittest_import_option; + +// Test option import +import option "google/protobuf/unittest_custom_options.proto"; +import option "google/protobuf/unittest_custom_options_unlinked.proto"; + +option (proto2_unittest.file_opt1) = 1; +option (proto2_unittest_unlinked.file_opt1) = 1; + +message TestMessage { + option (proto2_unittest.message_opt1) = 2; + option (proto2_unittest_unlinked.message_opt1) = 2; + + int32 field1 = 1 [ + (proto2_unittest.field_opt1) = 3, + (proto2_unittest_unlinked.field_opt1) = 3 + ]; +} diff --git a/Protos/upstream/google/protobuf/unittest_import_public.proto b/Protos/upstream/google/protobuf/unittest_import_public.proto new file mode 100644 index 000000000..34701fe31 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_import_public.proto @@ -0,0 +1,18 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: liujisi@google.com (Pherl Liu) + +syntax = "proto2"; + +package proto2_unittest_import; + +option java_package = "com.google.protobuf.test"; + +message PublicImportMessage { + optional int32 e = 1; +} diff --git a/Protos/upstream/google/protobuf/unittest_import_public_lite.proto b/Protos/upstream/google/protobuf/unittest_import_public_lite.proto new file mode 100644 index 000000000..1dd1ebd61 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_import_public_lite.proto @@ -0,0 +1,19 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: liujisi@google.com (Pherl Liu) + +edition = "2023"; + +package proto2_unittest_import; + +option optimize_for = LITE_RUNTIME; +option java_package = "com.google.protobuf"; + +message PublicImportMessageLite { + int32 e = 1; +} diff --git a/Protos/upstream/google/protobuf/unittest_invalid_features.proto b/Protos/upstream/google/protobuf/unittest_invalid_features.proto new file mode 100644 index 000000000..aaecbf488 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_invalid_features.proto @@ -0,0 +1,24 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2023 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +syntax = "proto2"; + +package pb; + +import "google/protobuf/descriptor.proto"; + +extend google.protobuf.FeatureSet { + optional TestInvalidFeatures test_invalid = 9996; +} + +message TestInvalidFeatures { + repeated int32 repeated_feature = 1 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FIELD, + edition_defaults = { edition: EDITION_2023, value: "3" } + ]; +} diff --git a/Protos/upstream/google/protobuf/unittest_lazy_dependencies.proto b/Protos/upstream/google/protobuf/unittest_lazy_dependencies.proto new file mode 100644 index 000000000..8d755bf9a --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_lazy_dependencies.proto @@ -0,0 +1,51 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: trafacz@google.com (Todd Rafacz) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// A proto file we will use for unit testing. + +edition = "2024"; + +import "google/protobuf/unittest_lazy_dependencies_custom_option.proto"; + +// Some generic_services option(s) added automatically. +// See: http://go/proto2-generic-services-default +option cc_generic_services = true; // auto-added +option java_generic_services = true; // auto-added +option py_generic_services = true; // auto-added +option cc_enable_arenas = true; + +// We don't put this in a package within proto2 because we need to make sure +// that the generated code doesn't depend on being in the proto2 namespace. +// In test_util.h we do "using namespace unittest = proto2_unittest". +package proto2_unittest.lazy_imports; + +// Protos optimized for SPEED use a strict superset of the generated code +// of equivalent ones optimized for CODE_SIZE, so we should optimize all our +// tests for speed unless explicitly testing code size optimization. +option optimize_for = SPEED; + +option java_outer_classname = "UnittestLazyImportsProto"; + +// The following are used to test that the proto file +// with the definition of the following field types is +// not built when this proto file is built. Then test +// that calling message_type() etc will build the correct +// descriptor lazily and return it. + +message ImportedMessage { + LazyMessage lazy_message = 1; +} + +message MessageCustomOption {} + +message MessageCustomOption2 { + option (lazy_enum_option) = LAZY_ENUM_0; +} diff --git a/Protos/upstream/google/protobuf/unittest_lazy_dependencies_custom_option.proto b/Protos/upstream/google/protobuf/unittest_lazy_dependencies_custom_option.proto new file mode 100644 index 000000000..67ede038f --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_lazy_dependencies_custom_option.proto @@ -0,0 +1,44 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: trafacz@google.com (Todd Rafacz) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// A proto file we will use for unit testing. + +edition = "2024"; + +import "google/protobuf/descriptor.proto"; +import "google/protobuf/unittest_lazy_dependencies_enum.proto"; + +// Some generic_services option(s) added automatically. +// See: http://go/proto2-generic-services-default +option cc_generic_services = true; // auto-added +option java_generic_services = true; // auto-added +option py_generic_services = true; // auto-added +option cc_enable_arenas = true; + +// We don't put this in a package within proto2 because we need to make sure +// that the generated code doesn't depend on being in the proto2 namespace. +// In test_util.h we do "using namespace unittest = proto2_unittest". +package proto2_unittest.lazy_imports; + +// Protos optimized for SPEED use a strict superset of the generated code +// of equivalent ones optimized for CODE_SIZE, so we should optimize all our +// tests for speed unless explicitly testing code size optimization. +option optimize_for = SPEED; + +option java_outer_classname = "UnittestLazyImportsCustomOptionProto"; + +message LazyMessage { + int32 a = 1; +} + +extend google.protobuf.MessageOptions { + LazyEnum lazy_enum_option = 138596335 [default = LAZY_ENUM_1]; +} diff --git a/Protos/upstream/google/protobuf/unittest_lazy_dependencies_enum.proto b/Protos/upstream/google/protobuf/unittest_lazy_dependencies_enum.proto new file mode 100644 index 000000000..1fd05966d --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_lazy_dependencies_enum.proto @@ -0,0 +1,43 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: trafacz@google.com (Todd Rafacz) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// A proto file we will use for unit testing. + +edition = "2024"; + +// Treat all enums as closed by default (proto2 behavior). +option features.enum_type = CLOSED; + +// Some generic_services option(s) added automatically. +// See: http://go/proto2-generic-services-default +option cc_generic_services = true; // auto-added +option java_generic_services = true; // auto-added +option py_generic_services = true; // auto-added +option cc_enable_arenas = true; + +// We don't put this in a package within proto2 because we need to make sure +// that the generated code doesn't depend on being in the proto2 namespace. +// In test_util.h we do "using namespace unittest = proto2_unittest". +package proto2_unittest.lazy_imports; + +// Protos optimized for SPEED use a strict superset of the generated code +// of equivalent ones optimized for CODE_SIZE, so we should optimize all our +// tests for speed unless explicitly testing code size optimization. +option optimize_for = SPEED; + +option java_outer_classname = "UnittestLazyImportsEnumProto"; + +enum LazyEnum { + option features.enforce_naming_style = STYLE_LEGACY; + + LAZY_ENUM_0 = 0; + LAZY_ENUM_1 = 1; +} diff --git a/Protos/upstream/google/protobuf/unittest_legacy_features.proto b/Protos/upstream/google/protobuf/unittest_legacy_features.proto new file mode 100644 index 000000000..96b9b441c --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_legacy_features.proto @@ -0,0 +1,24 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Test that features with legacy descriptor helpers get properly converted. + +edition = "2024"; + +package legacy_features_unittest; + +option java_outer_classname = "UnittestLegacyFeatures"; + +import option "google/protobuf/java_features.proto"; + +message TestEditionsMessage { + option features.(pb.java).nest_in_file_class = YES; + + int32 required_field = 1 [features.field_presence = LEGACY_REQUIRED]; + TestEditionsMessage delimited_field = 2 + [features.message_encoding = DELIMITED]; +} diff --git a/Protos/upstream/google/protobuf/unittest_lite.proto b/Protos/upstream/google/protobuf/unittest_lite.proto new file mode 100644 index 000000000..1ea260cec --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_lite.proto @@ -0,0 +1,633 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// +// This is like unittest.proto but with optimize_for = LITE_RUNTIME. + +edition = "2023"; + +package proto2_unittest; + +import "google/protobuf/unittest_import_lite.proto"; + +option features.enum_type = CLOSED; +option features.repeated_field_encoding = EXPANDED; +option features.utf8_validation = NONE; +option cc_enable_arenas = true; +option optimize_for = LITE_RUNTIME; +option java_package = "com.google.protobuf"; + +// Same as TestAllTypes but with the lite runtime. +message TestAllTypesLite { + message NestedMessage { + int32 bb = 1; + int64 cc = 2; + repeated int32 dd = 3 [features.repeated_field_encoding = PACKED]; + } + + message NestedMessage2 { + int32 dd = 1; + } + + enum NestedEnum { + FOO = 1; + BAR = 2; + BAZ = 3; + } + + // Singular + int32 optional_int32 = 1; + int64 optional_int64 = 2; + uint32 optional_uint32 = 3; + uint64 optional_uint64 = 4; + sint32 optional_sint32 = 5; + sint64 optional_sint64 = 6; + fixed32 optional_fixed32 = 7; + fixed64 optional_fixed64 = 8; + sfixed32 optional_sfixed32 = 9; + sfixed64 optional_sfixed64 = 10; + float optional_float = 11; + double optional_double = 12; + bool optional_bool = 13; + string optional_string = 14; + bytes optional_bytes = 15; + + message OptionalGroup { + int32 a = 17; + } + + OptionalGroup optionalgroup = 16 [features.message_encoding = DELIMITED]; + + NestedMessage optional_nested_message = 18; + ForeignMessageLite optional_foreign_message = 19; + proto2_unittest_import.ImportMessageLite optional_import_message = 20; + NestedEnum optional_nested_enum = 21; + ForeignEnumLite optional_foreign_enum = 22; + proto2_unittest_import.ImportEnumLite optional_import_enum = 23; + string optional_string_piece = 24 [ctype = STRING_PIECE]; + + string optional_cord = 25 [ctype = CORD]; + bytes optional_bytes_cord = 86 [ctype = CORD]; + + // Defined in unittest_import_public.proto + proto2_unittest_import.PublicImportMessageLite + optional_public_import_message = 26; + NestedMessage optional_lazy_message = 27 [lazy = true]; + + NestedMessage optional_unverified_lazy_message = 28 [unverified_lazy = true]; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + + message RepeatedGroup { + int32 a = 47; + } + + repeated RepeatedGroup repeatedgroup = 46 + [features.message_encoding = DELIMITED]; + + repeated NestedMessage repeated_nested_message = 48; + repeated ForeignMessageLite repeated_foreign_message = 49; + repeated proto2_unittest_import.ImportMessageLite repeated_import_message = + 50; + repeated NestedEnum repeated_nested_enum = 51; + repeated ForeignEnumLite repeated_foreign_enum = 52; + repeated proto2_unittest_import.ImportEnumLite repeated_import_enum = 53; + repeated string repeated_string_piece = 54 [ctype = STRING_PIECE]; + + repeated string repeated_cord = 55 [ctype = CORD]; + + repeated NestedMessage repeated_lazy_message = 57; + + // Singular with defaults + int32 default_int32 = 61 [default = 41]; + + int64 default_int64 = 62 [default = 42]; + + uint32 default_uint32 = 63 [default = 43]; + + uint64 default_uint64 = 64 [default = 44]; + + sint32 default_sint32 = 65 [default = -45]; + + sint64 default_sint64 = 66 [default = 46]; + + fixed32 default_fixed32 = 67 [default = 47]; + + fixed64 default_fixed64 = 68 [default = 48]; + + sfixed32 default_sfixed32 = 69 [default = 49]; + + sfixed64 default_sfixed64 = 70 [default = -50]; + + float default_float = 71 [default = 51.5]; + + double default_double = 72 [default = 5.2e4]; + + bool default_bool = 73 [default = true]; + + string default_string = 74 [default = "hello"]; + + bytes default_bytes = 75 [default = "world"]; + + NestedEnum default_nested_enum = 81 [default = BAR]; + + ForeignEnumLite default_foreign_enum = 82 [default = FOREIGN_LITE_BAR]; + + proto2_unittest_import.ImportEnumLite default_import_enum = 83 + [default = IMPORT_LITE_BAR]; + + string default_string_piece = 84 [ctype = STRING_PIECE, default = "abc"]; + + string default_cord = 85 [ctype = CORD, default = "123"]; + + // For oneof test + oneof oneof_field { + uint32 oneof_uint32 = 111; + NestedMessage oneof_nested_message = 112; + string oneof_string = 113; + bytes oneof_bytes = 114; + NestedMessage oneof_lazy_nested_message = 115 [lazy = true]; + + NestedMessage2 oneof_nested_message2 = 117; + } + + // Tests toString for non-repeated fields with a list suffix + int32 deceptively_named_list = 116; +} + +message ForeignMessageLite { + int32 c = 1; +} + +enum ForeignEnumLite { + FOREIGN_LITE_FOO = 4; + FOREIGN_LITE_BAZ = 6; + FOREIGN_LITE_BAR = 5; +} + +message TestPackedTypesLite { + repeated int32 packed_int32 = 90 [features.repeated_field_encoding = PACKED]; + + repeated int64 packed_int64 = 91 [features.repeated_field_encoding = PACKED]; + + repeated uint32 packed_uint32 = 92 + [features.repeated_field_encoding = PACKED]; + + repeated uint64 packed_uint64 = 93 + [features.repeated_field_encoding = PACKED]; + + repeated sint32 packed_sint32 = 94 + [features.repeated_field_encoding = PACKED]; + + repeated sint64 packed_sint64 = 95 + [features.repeated_field_encoding = PACKED]; + + repeated fixed32 packed_fixed32 = 96 + [features.repeated_field_encoding = PACKED]; + + repeated fixed64 packed_fixed64 = 97 + [features.repeated_field_encoding = PACKED]; + + repeated sfixed32 packed_sfixed32 = 98 + [features.repeated_field_encoding = PACKED]; + + repeated sfixed64 packed_sfixed64 = 99 + [features.repeated_field_encoding = PACKED]; + + repeated float packed_float = 100 [features.repeated_field_encoding = PACKED]; + + repeated double packed_double = 101 + [features.repeated_field_encoding = PACKED]; + + repeated bool packed_bool = 102 [features.repeated_field_encoding = PACKED]; + + repeated ForeignEnumLite packed_enum = 103 + [features.repeated_field_encoding = PACKED]; +} + +message TestAllExtensionsLite { + extensions 1 to max; +} + +extend TestAllExtensionsLite { + // Singular + int32 optional_int32_extension_lite = 1; + int64 optional_int64_extension_lite = 2; + uint32 optional_uint32_extension_lite = 3; + uint64 optional_uint64_extension_lite = 4; + sint32 optional_sint32_extension_lite = 5; + sint64 optional_sint64_extension_lite = 6; + fixed32 optional_fixed32_extension_lite = 7; + fixed64 optional_fixed64_extension_lite = 8; + sfixed32 optional_sfixed32_extension_lite = 9; + sfixed64 optional_sfixed64_extension_lite = 10; + float optional_float_extension_lite = 11; + double optional_double_extension_lite = 12; + bool optional_bool_extension_lite = 13; + string optional_string_extension_lite = 14; + bytes optional_bytes_extension_lite = 15; + OptionalGroup_extension_lite optionalgroup_extension_lite = 16 + [features.message_encoding = DELIMITED]; + + TestAllTypesLite.NestedMessage optional_nested_message_extension_lite = 18; + ForeignMessageLite optional_foreign_message_extension_lite = 19; + proto2_unittest_import.ImportMessageLite + optional_import_message_extension_lite = 20; + TestAllTypesLite.NestedEnum optional_nested_enum_extension_lite = 21; + ForeignEnumLite optional_foreign_enum_extension_lite = 22; + proto2_unittest_import.ImportEnumLite optional_import_enum_extension_lite = + 23; + string optional_string_piece_extension_lite = 24 [ctype = STRING_PIECE]; + + // TODO: ctype=CORD is not supported for extension. Add + // ctype=CORD option back after it is supported. + string optional_cord_extension_lite = 25; + bytes optional_bytes_cord_extension_lite = 86; + proto2_unittest_import.PublicImportMessageLite + optional_public_import_message_extension_lite = 26; + TestAllTypesLite.NestedMessage optional_lazy_message_extension_lite = 27 + [lazy = true]; + + TestAllTypesLite.NestedMessage + optional_unverified_lazy_message_extension_lite = 28 + [unverified_lazy = true]; + + // Repeated + repeated int32 repeated_int32_extension_lite = 31; + repeated int64 repeated_int64_extension_lite = 32; + repeated uint32 repeated_uint32_extension_lite = 33; + repeated uint64 repeated_uint64_extension_lite = 34; + repeated sint32 repeated_sint32_extension_lite = 35; + repeated sint64 repeated_sint64_extension_lite = 36; + repeated fixed32 repeated_fixed32_extension_lite = 37; + repeated fixed64 repeated_fixed64_extension_lite = 38; + repeated sfixed32 repeated_sfixed32_extension_lite = 39; + repeated sfixed64 repeated_sfixed64_extension_lite = 40; + repeated float repeated_float_extension_lite = 41; + repeated double repeated_double_extension_lite = 42; + repeated bool repeated_bool_extension_lite = 43; + repeated string repeated_string_extension_lite = 44; + repeated bytes repeated_bytes_extension_lite = 45; + repeated RepeatedGroup_extension_lite repeatedgroup_extension_lite = 46 + [features.message_encoding = DELIMITED]; + + repeated TestAllTypesLite.NestedMessage + repeated_nested_message_extension_lite = 48; + repeated ForeignMessageLite repeated_foreign_message_extension_lite = 49; + repeated proto2_unittest_import.ImportMessageLite + repeated_import_message_extension_lite = 50; + repeated TestAllTypesLite.NestedEnum repeated_nested_enum_extension_lite = 51; + repeated ForeignEnumLite repeated_foreign_enum_extension_lite = 52; + repeated proto2_unittest_import.ImportEnumLite + repeated_import_enum_extension_lite = 53; + repeated string repeated_string_piece_extension_lite = 54 + [ctype = STRING_PIECE]; + + // TODO: ctype=CORD is not supported for extension. Add + // ctype=CORD option back after it is supported. + repeated string repeated_cord_extension_lite = 55; + repeated TestAllTypesLite.NestedMessage repeated_lazy_message_extension_lite = + 57 [lazy = true]; + + // Singular with defaults + int32 default_int32_extension_lite = 61 [default = 41]; + + int64 default_int64_extension_lite = 62 [default = 42]; + + uint32 default_uint32_extension_lite = 63 [default = 43]; + + uint64 default_uint64_extension_lite = 64 [default = 44]; + + sint32 default_sint32_extension_lite = 65 [default = -45]; + + sint64 default_sint64_extension_lite = 66 [default = 46]; + + fixed32 default_fixed32_extension_lite = 67 [default = 47]; + + fixed64 default_fixed64_extension_lite = 68 [default = 48]; + + sfixed32 default_sfixed32_extension_lite = 69 [default = 49]; + + sfixed64 default_sfixed64_extension_lite = 70 [default = -50]; + + float default_float_extension_lite = 71 [default = 51.5]; + + double default_double_extension_lite = 72 [default = 5.2e4]; + + bool default_bool_extension_lite = 73 [default = true]; + + string default_string_extension_lite = 74 [default = "hello"]; + + bytes default_bytes_extension_lite = 75 [default = "world"]; + + TestAllTypesLite.NestedEnum default_nested_enum_extension_lite = 81 + [default = BAR]; + + ForeignEnumLite default_foreign_enum_extension_lite = 82 + [default = FOREIGN_LITE_BAR]; + + proto2_unittest_import.ImportEnumLite default_import_enum_extension_lite = 83 + [default = IMPORT_LITE_BAR]; + + string default_string_piece_extension_lite = 84 + [ctype = STRING_PIECE, default = "abc"]; + + // TODO: ctype=CORD is not supported for extension. Add + // ctype=CORD option back after it is supported. + string default_cord_extension_lite = 85 [default = "123"]; + + // For oneof test + uint32 oneof_uint32_extension_lite = 111; + TestAllTypesLite.NestedMessage oneof_nested_message_extension_lite = 112; + string oneof_string_extension_lite = 113; + bytes oneof_bytes_extension_lite = 114; +} + +message OptionalGroup_extension_lite { + int32 a = 17; +} + +message RepeatedGroup_extension_lite { + int32 a = 47; +} + +message TestPackedExtensionsLite { + extensions 1 to max; +} + +extend TestPackedExtensionsLite { + repeated int32 packed_int32_extension_lite = 90 + [features.repeated_field_encoding = PACKED]; + + repeated int64 packed_int64_extension_lite = 91 + [features.repeated_field_encoding = PACKED]; + + repeated uint32 packed_uint32_extension_lite = 92 + [features.repeated_field_encoding = PACKED]; + + repeated uint64 packed_uint64_extension_lite = 93 + [features.repeated_field_encoding = PACKED]; + + repeated sint32 packed_sint32_extension_lite = 94 + [features.repeated_field_encoding = PACKED]; + + repeated sint64 packed_sint64_extension_lite = 95 + [features.repeated_field_encoding = PACKED]; + + repeated fixed32 packed_fixed32_extension_lite = 96 + [features.repeated_field_encoding = PACKED]; + + repeated fixed64 packed_fixed64_extension_lite = 97 + [features.repeated_field_encoding = PACKED]; + + repeated sfixed32 packed_sfixed32_extension_lite = 98 + [features.repeated_field_encoding = PACKED]; + + repeated sfixed64 packed_sfixed64_extension_lite = 99 + [features.repeated_field_encoding = PACKED]; + + repeated float packed_float_extension_lite = 100 + [features.repeated_field_encoding = PACKED]; + + repeated double packed_double_extension_lite = 101 + [features.repeated_field_encoding = PACKED]; + + repeated bool packed_bool_extension_lite = 102 + [features.repeated_field_encoding = PACKED]; + + repeated ForeignEnumLite packed_enum_extension_lite = 103 + [features.repeated_field_encoding = PACKED]; +} + +message TestNestedExtensionLite { + extend TestAllExtensionsLite { + int32 nested_extension = 12345; + } +} + +// Test that deprecated fields work. We only verify that they compile (at one +// point this failed). +message TestDeprecatedLite { + int32 deprecated_field = 1 [deprecated = true]; + + int32 deprecated_field2 = 2 + [features.field_presence = LEGACY_REQUIRED, deprecated = true]; + + string deprecated_field3 = 3 [deprecated = true]; + + TestDeprecatedLite deprecated_field4 = 4 [deprecated = true]; +} + +// See the comments of the same type in unittest.proto. +message TestParsingMergeLite { + message RepeatedFieldsGenerator { + repeated TestAllTypesLite field1 = 1; + repeated TestAllTypesLite field2 = 2; + repeated TestAllTypesLite field3 = 3; + + message Group1 { + TestAllTypesLite field1 = 11; + } + + repeated Group1 group1 = 10 [features.message_encoding = DELIMITED]; + + message Group2 { + TestAllTypesLite field1 = 21; + } + + repeated Group2 group2 = 20 [features.message_encoding = DELIMITED]; + + repeated TestAllTypesLite ext1 = 1000; + repeated TestAllTypesLite ext2 = 1001; + } + + TestAllTypesLite required_all_types = 1 + [features.field_presence = LEGACY_REQUIRED]; + + TestAllTypesLite optional_all_types = 2; + repeated TestAllTypesLite repeated_all_types = 3; + + message OptionalGroup { + TestAllTypesLite optional_group_all_types = 11; + } + + OptionalGroup optionalgroup = 10 [features.message_encoding = DELIMITED]; + + message RepeatedGroup { + TestAllTypesLite repeated_group_all_types = 21; + } + + repeated RepeatedGroup repeatedgroup = 20 + [features.message_encoding = DELIMITED]; + + extensions 1000 to max; + + extend TestParsingMergeLite { + TestAllTypesLite optional_ext = 1000; + repeated TestAllTypesLite repeated_ext = 1001; + } +} + +// Test that the correct exception is thrown by parseFrom in a corner case +// involving merging, extensions, and required fields. +message TestMergeExceptionLite { + TestAllExtensionsLite all_extensions = 1; +} + +// TestEmptyMessageLite is used to test unknown fields support in lite mode. +message TestEmptyMessageLite {} + +// Like above, but declare all field numbers as potential extensions. No +// actual extensions should ever be defined for this type. +message TestEmptyMessageWithExtensionsLite { + extensions 1 to max; +} + +enum V1EnumLite { + V1_FIRST = 1; +} + +enum V2EnumLite { + V2_FIRST = 1; + V2_SECOND = 2; +} + +message V1MessageLite { + int32 int_field = 1 [features.field_presence = LEGACY_REQUIRED]; + + V1EnumLite enum_field = 2 [default = V1_FIRST]; +} + +message V2MessageLite { + int32 int_field = 1 [features.field_presence = LEGACY_REQUIRED]; + + V2EnumLite enum_field = 2 [default = V2_FIRST]; +} + +message TestHugeFieldNumbersLite { + int32 optional_int32 = 536870000; + int32 fixed_32 = 536870001; + repeated int32 repeated_int32 = 536870002; + repeated int32 packed_int32 = 536870003 + [features.repeated_field_encoding = PACKED]; + + ForeignEnumLite optional_enum = 536870004; + string optional_string = 536870005; + bytes optional_bytes = 536870006; + ForeignMessageLite optional_message = 536870007; + + message OptionalGroup { + int32 group_a = 536870009; + } + + OptionalGroup optionalgroup = 536870008 + [features.message_encoding = DELIMITED]; + + map string_string_map = 536870010; + + oneof oneof_field { + uint32 oneof_uint32 = 536870011; + TestAllTypesLite oneof_test_all_types = 536870012; + string oneof_string = 536870013; + bytes oneof_bytes = 536870014; + } + + extensions 536860000 to 536869999 [declaration = { + number: 536860000 + full_name: ".proto2_unittest.test_all_types_lite" + type: ".proto2_unittest.TestAllTypesLite" + }]; +} + +extend TestHugeFieldNumbersLite { + TestAllTypesLite test_all_types_lite = 536860000; +} + +message TestOneofParsingLite { + oneof oneof_field { + int32 oneof_int32 = 1; + TestAllTypesLite oneof_submessage = 2; + string oneof_string = 3; + bytes oneof_bytes = 4 [default = "default bytes"]; + + string oneof_string_cord = 5 [ctype = CORD, default = "default Cord"]; + + bytes oneof_bytes_cord = 6 [ctype = CORD]; + + string oneof_string_string_piece = 7 [ctype = STRING_PIECE]; + + bytes oneof_bytes_string_piece = 8 + [ctype = STRING_PIECE, default = "default StringPiece"]; + + V2EnumLite oneof_enum = 9; + } +} + +message TestMessageSetLite { + option message_set_wire_format = true; + + extensions 100 to max; +} + +// The following four messages are set up to test for wire compatibility between +// packed and non-packed repeated fields. We use the field number 2048, because +// that is large enough to require a 3-byte varint for the tag. +message PackedInt32 { + repeated int32 repeated_int32 = 2048 + [features.repeated_field_encoding = PACKED]; +} + +message NonPackedInt32 { + repeated int32 repeated_int32 = 2048; +} + +message PackedFixed32 { + repeated fixed32 repeated_fixed32 = 2048 + [features.repeated_field_encoding = PACKED]; +} + +message NonPackedFixed32 { + repeated fixed32 repeated_fixed32 = 2048; +} + +// Test an enum that has multiple values with the same number. +message DupEnum { + enum TestEnumWithDupValueLite { + option allow_alias = true; + + FOO1 = 1; + BAR1 = 2; + BAZ = 3; + FOO2 = 1; + BAR2 = 2; + } +} + +message RecursiveMessage { + RecursiveMessage recurse = 1; + bytes payload = 2; +} + +message RecursiveGroup { + RecursiveGroup recurse = 1 [features.message_encoding = DELIMITED]; +} diff --git a/Protos/upstream/google/protobuf/unittest_lite_edition_2024.proto b/Protos/upstream/google/protobuf/unittest_lite_edition_2024.proto new file mode 100644 index 000000000..6cdaf7d79 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_lite_edition_2024.proto @@ -0,0 +1,10 @@ +edition = "2024"; + +package proto2_unittest; + +option optimize_for = LITE_RUNTIME; + +enum EnumNameStringView { + ENUM_NAME_STRING_VIEW_DEFAULT = 0; + ENUM_NAME_STRING_VIEW_ANOTHER_VALUE = 1; +} diff --git a/Protos/upstream/google/protobuf/unittest_lite_imports_nonlite.proto b/Protos/upstream/google/protobuf/unittest_lite_imports_nonlite.proto new file mode 100644 index 000000000..9399896d1 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_lite_imports_nonlite.proto @@ -0,0 +1,25 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// +// Tests that a "lite" message can import a regular message. + +syntax = "proto2"; + +package proto2_unittest; + +import "google/protobuf/unittest.proto"; + +option optimize_for = LITE_RUNTIME; + +message TestLiteImportsNonlite { + optional TestAllTypes message = 1; + + // Verifies that transitive required fields generates valid code. + optional TestRequired message_with_required = 2; +} diff --git a/Protos/upstream/google/protobuf/unittest_mset.proto b/Protos/upstream/google/protobuf/unittest_mset.proto new file mode 100644 index 000000000..94b47127f --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_mset.proto @@ -0,0 +1,81 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// This file is similar to unittest_mset_wire_format.proto, but does not +// have a TestMessageSet, so it can be downgraded to proto1. + +syntax = "proto2"; + +import "google/protobuf/unittest_mset_wire_format.proto"; + +package proto2_unittest; + +option cc_enable_arenas = true; +option optimize_for = SPEED; + +message TestMessageSetContainer { + optional proto2_wireformat_unittest.TestMessageSet message_set = 1; +} + +message NestedTestMessageSetContainer { + optional TestMessageSetContainer container = 1; + optional NestedTestMessageSetContainer child = 2; + optional NestedTestMessageSetContainer lazy_child = 3 [lazy = true]; +} + +message NestedTestInt { + optional fixed32 a = 1; + optional int32 b = 3; + optional NestedTestInt child = 2; +} + +message TestMessageSetExtension1 { + extend proto2_wireformat_unittest.TestMessageSet { + optional TestMessageSetExtension1 message_set_extension = 1545008; + } + optional int32 i = 15; + optional proto2_wireformat_unittest.TestMessageSet recursive = 16; + optional string test_aliasing = 17 [ctype = STRING_PIECE]; +} + +message TestMessageSetExtension2 { + extend proto2_wireformat_unittest.TestMessageSet { + optional TestMessageSetExtension2 message_set_extension = 1547769; + } + optional string str = 25; +} + +message TestMessageSetExtension3 { + extend proto2_wireformat_unittest.TestMessageSet { + optional TestMessageSetExtension3 message_set_extension = 195273129; + } + optional NestedTestInt msg = 35; + required int32 required_int = 36; +} + +// This message was used to generate +// //net/proto2/python/internal/testdata/message_set_message, but is commented +// out since it must not actually exist in code, to simulate an "unknown" +// extension. +// message TestMessageSetUnknownExtension { +// extend TestMessageSet { +// optional TestMessageSetUnknownExtension message_set_extension = 56141421; +// } +// optional int64 a = 1; +// } + +// MessageSet wire format is equivalent to this. +message RawMessageSet { + repeated group Item = 1 { + required int32 type_id = 2; + required bytes message = 3; + } +} diff --git a/Protos/upstream/google/protobuf/unittest_mset_wire_format.proto b/Protos/upstream/google/protobuf/unittest_mset_wire_format.proto new file mode 100644 index 000000000..6242b8031 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_mset_wire_format.proto @@ -0,0 +1,38 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// This file contains messages for testing message_set_wire_format. + +syntax = "proto2"; + +package proto2_wireformat_unittest; + +option cc_enable_arenas = true; +option optimize_for = SPEED; +option csharp_namespace = "Google.ProtocolBuffers.TestProtos"; + +// A message with message_set_wire_format. +message TestMessageSet { + option message_set_wire_format = true; + + extensions 4 to 529999999; + + extensions 530000000 to max + [declaration = { + number: 1952731290, + full_name: ".proto2_unittest_v1api.TestMessageSetExtension3.message_set_extension", + type: ".proto2_unittest_v1api.TestMessageSetExtension3" + }]; +} + +message TestMessageSetWireFormatContainer { + optional TestMessageSet message_set = 1; +} diff --git a/Protos/upstream/google/protobuf/unittest_no_field_presence.proto b/Protos/upstream/google/protobuf/unittest_no_field_presence.proto new file mode 100644 index 000000000..81ed4cb05 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_no_field_presence.proto @@ -0,0 +1,134 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// A proto file used to test a message type with no explicit field presence. + +edition = "2024"; + +import "google/protobuf/unittest.proto"; + +import option "google/protobuf/cpp_features.proto"; + +// Treat all fields as implicit present by default (proto3 behavior). +option features.field_presence = IMPLICIT; + +// We want to test embedded proto2 messages, so include some proto2 types. +package proto2_nofieldpresence_unittest; + +// This proto includes every type of field in both singular and repeated +// forms. +message TestAllTypes { + message NestedMessage { + int32 bb = 1; + } + + enum NestedEnum { + FOO = 0; + BAR = 1; + BAZ = 2; + } + + // Singular + // TODO: remove 'optional' labels as soon as CL 69188077 is LGTM'd to make + // 'optional' optional. + int32 optional_int32 = 1; + int64 optional_int64 = 2; + uint32 optional_uint32 = 3; + uint64 optional_uint64 = 4; + sint32 optional_sint32 = 5; + sint64 optional_sint64 = 6; + fixed32 optional_fixed32 = 7; + fixed64 optional_fixed64 = 8; + sfixed32 optional_sfixed32 = 9; + sfixed64 optional_sfixed64 = 10; + float optional_float = 11; + double optional_double = 12; + bool optional_bool = 13; + string optional_string = 14 [features.(pb.cpp).string_type = STRING]; + bytes optional_bytes = 15 [features.(pb.cpp).string_type = STRING]; + + NestedMessage optional_nested_message = 18; + ForeignMessage optional_foreign_message = 19; + proto2_unittest.TestAllTypes optional_proto2_message = 20; + + NestedEnum optional_nested_enum = 21; + ForeignEnum optional_foreign_enum = 22; + // N.B.: proto2-enum-type fields not allowed, because their default values + // might not be zero. + // optional proto2_unittest.ForeignEnum optional_proto2_enum = + // 23; + + string optional_string_piece = 24; + string optional_cord = 25 [features.(pb.cpp).string_type = CORD]; + + NestedMessage optional_lazy_message = 30 [lazy = true]; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + + repeated NestedMessage repeated_nested_message = 48; + repeated ForeignMessage repeated_foreign_message = 49; + repeated proto2_unittest.TestAllTypes repeated_proto2_message = 50; + + repeated NestedEnum repeated_nested_enum = 51; + repeated ForeignEnum repeated_foreign_enum = 52; + + repeated string repeated_string_piece = 54; + repeated string repeated_cord = 55 [features.(pb.cpp).string_type = CORD]; + + repeated NestedMessage repeated_lazy_message = 57; + + oneof oneof_field { + uint32 oneof_uint32 = 111; + NestedMessage oneof_nested_message = 112; + string oneof_string = 113; + NestedEnum oneof_enum = 114; + } +} + +message TestAllMapTypes { + map map_int32_bytes = 1; + map map_int32_foreign_enum = 2; + map map_int32_foreign_message = 3; + map map_int32_explicit_foreign_message = 4; +} + +message TestProto2Required { + proto2_unittest.TestRequired proto2 = 1; +} + +// Define these after TestAllTypes to make sure the compiler can handle +// that. +message ForeignMessage { + int32 c = 1; +} + +// Same as ForeignMessage, but all fields have explicit presence. +// It can be useful for testing explicit-implicit presence interop behaviour. +message ExplicitForeignMessage { + int32 c = 1 [features.field_presence = EXPLICIT]; +} + +enum ForeignEnum { + FOREIGN_FOO = 0; + FOREIGN_BAR = 1; + FOREIGN_BAZ = 2; +} diff --git a/Protos/upstream/google/protobuf/unittest_no_generic_services.proto b/Protos/upstream/google/protobuf/unittest_no_generic_services.proto new file mode 100644 index 000000000..3b1ab626c --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_no_generic_services.proto @@ -0,0 +1,32 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) + +syntax = "proto2"; + +package proto2_unittest.no_generic_services_test; + + +// *_generic_services are false by default. + +message TestMessage { + optional int32 a = 1; + extensions 1000 to max; +} + +enum TestEnum { + FOO = 1; +} + +extend TestMessage { + optional int32 test_extension = 1000; +} + +service TestService { + rpc Foo(TestMessage) returns (TestMessage); +} diff --git a/Protos/upstream/google/protobuf/unittest_optimize_for.proto b/Protos/upstream/google/protobuf/unittest_optimize_for.proto new file mode 100644 index 000000000..147fa4eb8 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_optimize_for.proto @@ -0,0 +1,45 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// A proto file which uses optimize_for = CODE_SIZE. + +syntax = "proto2"; + +package proto2_unittest; + +import "google/protobuf/unittest.proto"; + +option optimize_for = CODE_SIZE; + +message TestOptimizedForSize { + optional int32 i = 1; + optional ForeignMessage msg = 19; + + extensions 1000 to max; + + extend TestOptimizedForSize { + optional int32 test_extension = 1234; + optional TestRequiredOptimizedForSize test_extension2 = 1235; + } + + oneof foo { + int32 integer_field = 2; + string string_field = 3; + } +} + +message TestRequiredOptimizedForSize { + required int32 x = 1; +} + +message TestOptionalOptimizedForSize { + optional TestRequiredOptimizedForSize o = 1; +} diff --git a/Protos/upstream/google/protobuf/unittest_preserve_unknown_enum.proto b/Protos/upstream/google/protobuf/unittest_preserve_unknown_enum.proto new file mode 100644 index 000000000..5af149588 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_preserve_unknown_enum.proto @@ -0,0 +1,54 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +edition = "2024"; + +package proto3_preserve_unknown_enum_unittest; + +// Treat all fields as implicit present by default (proto3 behavior). +option features.field_presence = IMPLICIT; +option objc_class_prefix = "UnknownEnums"; +option csharp_namespace = "Google.Protobuf.TestProtos"; + +enum MyEnum { + FOO = 0; + BAR = 1; + BAZ = 2; +} + +enum MyEnumPlusExtra { + E_FOO = 0; + E_BAR = 1; + E_BAZ = 2; + E_EXTRA = 3; +} + +message MyMessage { + MyEnum e = 1; + repeated MyEnum repeated_e = 2; + repeated MyEnum repeated_packed_e = 3; + repeated MyEnumPlusExtra repeated_packed_unexpected_e = 4; // not packed + oneof o { + option features.enforce_naming_style = STYLE_LEGACY; + + MyEnum oneof_e_1 = 5; + MyEnum oneof_e_2 = 6; + } +} + +message MyMessagePlusExtra { + MyEnumPlusExtra e = 1; + repeated MyEnumPlusExtra repeated_e = 2; + repeated MyEnumPlusExtra repeated_packed_e = 3; + repeated MyEnumPlusExtra repeated_packed_unexpected_e = 4; + oneof o { + option features.enforce_naming_style = STYLE_LEGACY; + + MyEnumPlusExtra oneof_e_1 = 5; + MyEnumPlusExtra oneof_e_2 = 6; + } +} diff --git a/Protos/upstream/google/protobuf/unittest_preserve_unknown_enum2.proto b/Protos/upstream/google/protobuf/unittest_preserve_unknown_enum2.proto new file mode 100644 index 000000000..4ebb24ee5 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_preserve_unknown_enum2.proto @@ -0,0 +1,35 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +edition = "2024"; + +package proto2_preserve_unknown_enum_unittest; + +// Treat all enums as closed and use expanded encoding for repeated fields by +// default (proto2 behavior). +option features.enum_type = CLOSED; +option features.repeated_field_encoding = EXPANDED; + +enum MyEnum { + FOO = 0; + BAR = 1; + BAZ = 2; +} + +message MyMessage { + MyEnum e = 1; + repeated MyEnum repeated_e = 2; + repeated MyEnum repeated_packed_e = 3 + [features.repeated_field_encoding = PACKED]; + repeated MyEnum repeated_packed_unexpected_e = 4; // not packed + oneof o { + option features.enforce_naming_style = STYLE_LEGACY; + + MyEnum oneof_e_1 = 5; + MyEnum oneof_e_2 = 6; + } +} diff --git a/Protos/google/protobuf/unittest_proto3.proto b/Protos/upstream/google/protobuf/unittest_proto3.proto similarity index 71% rename from Protos/google/protobuf/unittest_proto3.proto rename to Protos/upstream/google/protobuf/unittest_proto3.proto index 89c8799ab..48674bd4c 100644 --- a/Protos/google/protobuf/unittest_proto3.proto +++ b/Protos/upstream/google/protobuf/unittest_proto3.proto @@ -1,32 +1,9 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd syntax = "proto3"; @@ -76,9 +53,9 @@ message TestAllTypes { // optional int32 a = 17; // } - NestedMessage optional_nested_message = 18; + optional NestedMessage optional_nested_message = 18; ForeignMessage optional_foreign_message = 19; - protobuf_unittest_import.ImportMessage optional_import_message = 20; + proto2_unittest_import.ImportMessage optional_import_message = 20; NestedEnum optional_nested_enum = 21; ForeignEnum optional_foreign_enum = 22; @@ -86,17 +63,18 @@ message TestAllTypes { // Omitted (compared to unittest.proto) because proto2 enums are not allowed // inside proto2 messages. // - // optional protobuf_unittest_import.ImportEnum optional_import_enum = 23; + // optional proto2_unittest_import.ImportEnum optional_import_enum = 23; string optional_string_piece = 24 [ctype = STRING_PIECE]; string optional_cord = 25 [ctype = CORD]; // Defined in unittest_import_public.proto - protobuf_unittest_import.PublicImportMessage optional_public_import_message = + proto2_unittest_import.PublicImportMessage optional_public_import_message = 26; NestedMessage optional_lazy_message = 27 [lazy = true]; - protobuf_unittest_import.ImportMessage optional_lazy_import_message = 115 + NestedMessage optional_unverified_lazy_message = 28 [unverified_lazy = true]; + proto2_unittest_import.ImportMessage optional_lazy_import_message = 115 [lazy = true]; // Repeated @@ -123,7 +101,7 @@ message TestAllTypes { repeated NestedMessage repeated_nested_message = 48; repeated ForeignMessage repeated_foreign_message = 49; - repeated protobuf_unittest_import.ImportMessage repeated_import_message = 50; + repeated proto2_unittest_import.ImportMessage repeated_import_message = 50; repeated NestedEnum repeated_nested_enum = 51; repeated ForeignEnum repeated_foreign_enum = 52; @@ -131,12 +109,12 @@ message TestAllTypes { // Omitted (compared to unittest.proto) because proto2 enums are not allowed // inside proto2 messages. // - // repeated protobuf_unittest_import.ImportEnum repeated_import_enum = 53; + // repeated proto2_unittest_import.ImportEnum repeated_import_enum = 53; repeated string repeated_string_piece = 54 [ctype = STRING_PIECE]; repeated string repeated_cord = 55 [ctype = CORD]; - repeated NestedMessage repeated_lazy_message = 57 [lazy = true]; + repeated NestedMessage repeated_lazy_message = 57; oneof oneof_field { uint32 oneof_uint32 = 111; @@ -200,6 +178,7 @@ enum ForeignEnum { FOREIGN_FOO = 4; FOREIGN_BAR = 5; FOREIGN_BAZ = 6; + FOREIGN_LARGE = 123456; // Large enough to escape the Boxed Integer cache. } // TestEmptyMessage is used to test behavior of unknown fields. @@ -226,3 +205,79 @@ message TestOneof2 { BAZ = 3; } } + +// If bool fields are incorrectly assumed to have hasbits, InternalSwap would +// result in swapping N more 32bit hasbits incorrectly. Considering padding, we +// need many bool fields to stress this. +message TestHasbits { + bool b1 = 1; + bool b2 = 2; + bool b3 = 3; + bool b4 = 4; + bool b5 = 5; + bool b6 = 6; + bool b7 = 7; + bool b8 = 8; + bool b9 = 9; + bool b10 = 10; + bool b11 = 11; + bool b12 = 12; + bool b13 = 13; + bool b14 = 14; + bool b15 = 15; + bool b16 = 16; + bool b17 = 17; + bool b18 = 18; + bool b19 = 19; + bool b20 = 20; + bool b21 = 21; + bool b22 = 22; + bool b23 = 23; + bool b24 = 24; + bool b25 = 25; + bool b26 = 26; + bool b27 = 27; + bool b28 = 28; + bool b29 = 29; + bool b30 = 30; + bool b31 = 31; + bool b32 = 32; + bool b33 = 33; + bool b34 = 34; + bool b35 = 35; + bool b36 = 36; + bool b37 = 37; + bool b38 = 38; + bool b39 = 39; + bool b40 = 40; + bool b41 = 41; + bool b42 = 42; + bool b43 = 43; + bool b44 = 44; + bool b45 = 45; + bool b46 = 46; + bool b47 = 47; + bool b48 = 48; + bool b49 = 49; + bool b50 = 50; + bool b51 = 51; + bool b52 = 52; + bool b53 = 53; + bool b54 = 54; + bool b55 = 55; + bool b56 = 56; + bool b57 = 57; + bool b58 = 58; + bool b59 = 59; + bool b60 = 60; + bool b61 = 61; + bool b62 = 62; + bool b63 = 63; + bool b64 = 64; + bool b65 = 65; + bool b66 = 66; + bool b67 = 67; + bool b68 = 68; + bool b69 = 69; + TestAllTypes child = 100; +} diff --git a/Protos/google/protobuf/unittest_proto3_arena.proto b/Protos/upstream/google/protobuf/unittest_proto3_arena.proto similarity index 77% rename from Protos/google/protobuf/unittest_proto3_arena.proto rename to Protos/upstream/google/protobuf/unittest_proto3_arena.proto index 175293979..1d8a59e38 100644 --- a/Protos/google/protobuf/unittest_proto3_arena.proto +++ b/Protos/upstream/google/protobuf/unittest_proto3_arena.proto @@ -1,32 +1,9 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd syntax = "proto3"; @@ -78,7 +55,7 @@ message TestAllTypes { NestedMessage optional_nested_message = 18; ForeignMessage optional_foreign_message = 19; - protobuf_unittest_import.ImportMessage optional_import_message = 20; + proto2_unittest_import.ImportMessage optional_import_message = 20; NestedEnum optional_nested_enum = 21; ForeignEnum optional_foreign_enum = 22; @@ -86,17 +63,19 @@ message TestAllTypes { // Omitted (compared to unittest.proto) because proto2 enums are not allowed // inside proto2 messages. // - // optional protobuf_unittest_import.ImportEnum optional_import_enum = 23; + // optional proto2_unittest_import.ImportEnum optional_import_enum = 23; string optional_string_piece = 24 [ctype=STRING_PIECE]; string optional_cord = 25 [ctype=CORD]; + bytes optional_bytes_cord = 86 [ctype=CORD]; // Defined in unittest_import_public.proto - protobuf_unittest_import.PublicImportMessage + proto2_unittest_import.PublicImportMessage optional_public_import_message = 26; NestedMessage optional_lazy_message = 27 [lazy=true]; - protobuf_unittest_import.ImportMessage optional_lazy_import_message = 115 + NestedMessage optional_unverified_lazy_message = 28 [unverified_lazy=true]; + proto2_unittest_import.ImportMessage optional_lazy_import_message = 115 [lazy = true]; // Repeated @@ -140,7 +119,7 @@ message TestAllTypes { repeated NestedMessage repeated_nested_message = 48; repeated ForeignMessage repeated_foreign_message = 49; - repeated protobuf_unittest_import.ImportMessage repeated_import_message = 50; + repeated proto2_unittest_import.ImportMessage repeated_import_message = 50; repeated NestedEnum repeated_nested_enum = 51; repeated ForeignEnum repeated_foreign_enum = 52; @@ -148,12 +127,12 @@ message TestAllTypes { // Omitted (compared to unittest.proto) because proto2 enums are not allowed // inside proto2 messages. // - // repeated protobuf_unittest_import.ImportEnum repeated_import_enum = 53; + // repeated proto2_unittest_import.ImportEnum repeated_import_enum = 53; repeated string repeated_string_piece = 54 [ctype=STRING_PIECE]; repeated string repeated_cord = 55 [ctype=CORD]; - repeated NestedMessage repeated_lazy_message = 57 [lazy=true]; + repeated NestedMessage repeated_lazy_message = 57 ; oneof oneof_field { uint32 oneof_uint32 = 111; @@ -205,6 +184,7 @@ message NestedTestAllTypes { NestedTestAllTypes child = 1; TestAllTypes payload = 2; repeated NestedTestAllTypes repeated_child = 3; + TestAllTypes lazy_payload = 4 [lazy = true]; } // Define these after TestAllTypes to make sure the compiler can handle @@ -218,6 +198,7 @@ enum ForeignEnum { FOREIGN_FOO = 4; FOREIGN_BAR = 5; FOREIGN_BAZ = 6; + FOREIGN_LARGE = 123456; // Large enough to escape the Boxed Integer cache. } // TestEmptyMessage is used to test behavior of unknown fields. diff --git a/Protos/google/protobuf/unittest_proto3_arena_lite.proto b/Protos/upstream/google/protobuf/unittest_proto3_arena_lite.proto similarity index 72% rename from Protos/google/protobuf/unittest_proto3_arena_lite.proto rename to Protos/upstream/google/protobuf/unittest_proto3_arena_lite.proto index 0d4218b97..5e38550bb 100644 --- a/Protos/google/protobuf/unittest_proto3_arena_lite.proto +++ b/Protos/upstream/google/protobuf/unittest_proto3_arena_lite.proto @@ -1,32 +1,9 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd syntax = "proto3"; @@ -79,7 +56,7 @@ message TestAllTypes { NestedMessage optional_nested_message = 18; ForeignMessage optional_foreign_message = 19; - protobuf_unittest_import.ImportMessage optional_import_message = 20; + proto2_unittest_import.ImportMessage optional_import_message = 20; NestedEnum optional_nested_enum = 21; ForeignEnum optional_foreign_enum = 22; @@ -87,13 +64,13 @@ message TestAllTypes { // Omitted (compared to unittest.proto) because proto2 enums are not allowed // inside proto2 messages. // - // optional protobuf_unittest_import.ImportEnum optional_import_enum = 23; + // optional proto2_unittest_import.ImportEnum optional_import_enum = 23; string optional_string_piece = 24 [ctype = STRING_PIECE]; string optional_cord = 25 [ctype = CORD]; // Defined in unittest_import_public.proto - protobuf_unittest_import.PublicImportMessage optional_public_import_message = + proto2_unittest_import.PublicImportMessage optional_public_import_message = 26; NestedMessage optional_lazy_message = 27 [lazy = true]; @@ -122,7 +99,7 @@ message TestAllTypes { repeated NestedMessage repeated_nested_message = 48; repeated ForeignMessage repeated_foreign_message = 49; - repeated protobuf_unittest_import.ImportMessage repeated_import_message = 50; + repeated proto2_unittest_import.ImportMessage repeated_import_message = 50; repeated NestedEnum repeated_nested_enum = 51; repeated ForeignEnum repeated_foreign_enum = 52; @@ -130,12 +107,12 @@ message TestAllTypes { // Omitted (compared to unittest.proto) because proto2 enums are not allowed // inside proto2 messages. // - // repeated protobuf_unittest_import.ImportEnum repeated_import_enum = 53; + // repeated proto2_unittest_import.ImportEnum repeated_import_enum = 53; repeated string repeated_string_piece = 54 [ctype = STRING_PIECE]; repeated string repeated_cord = 55 [ctype = CORD]; - repeated NestedMessage repeated_lazy_message = 57 [lazy = true]; + repeated NestedMessage repeated_lazy_message = 57; oneof oneof_field { uint32 oneof_uint32 = 111; diff --git a/Protos/upstream/google/protobuf/unittest_proto3_bad_macros.proto b/Protos/upstream/google/protobuf/unittest_proto3_bad_macros.proto new file mode 100644 index 000000000..14fbcde25 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_proto3_bad_macros.proto @@ -0,0 +1,75 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2023 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +syntax = "proto3"; + +package protobuf_unittest; + +option csharp_namespace = "ProtobufUnittest"; +option java_multiple_files = true; +option java_package = "com.google.protobuf.testing.proto"; + +// `google/protobuf/port_def.inc` #undef's a number of inconvenient macros +// defined in system headers under varying circumstances. The code generated +// from this file will not compile if those `#undef` calls are accidentally +// removed. + +// This generates `GID_MAX`, which is a macro in some circumstances. +enum GID { + GID_UNUSED = 0; +} + +// This generates `UID_MAX`, which is a mcro in some circumstances. +enum UID { + UID_UNUSED = 0; +} + +// Just a container for bad macro names. Some of these do not follow the normal +// naming conventions, this is intentional, we just want to trigger a build +// failure if the macro is left defined. +enum BadNames { + // autoheader defines this in some circumstances. + PACKAGE = 0; + // The comment says "a few common headers define this". + PACKED = 1; + // Defined in many Linux system headers. + linux = 2; + // This is often a macro in ``. + DOMAIN = 3; + // These are defined in both Windows and macOS headers. + TRUE = 4; + FALSE = 5; + // Sometimes defined in Windows system headers. + CREATE_NEW = 6; + DELETE = 7; + DOUBLE_CLICK = 8; + ERROR = 9; + ERROR_BUSY = 10; + ERROR_INSTALL_FAILED = 11; + ERROR_NOT_FOUND = 12; + GetClassName = 13; + GetCurrentTime = 14; + GetMessage = 15; + GetObject = 16; + IGNORE = 17; + IN = 18; + INPUT_KEYBOARD = 19; + NO_ERROR = 20; + OUT = 21; + OPTIONAL = 22; + NEAR = 23; + NO_DATA = 24; + REASON_UNKNOWN = 25; + SERVICE_DISABLED = 26; + SEVERITY_ERROR = 27; + STATUS_PENDING = 28; + STRICT = 29; + // Sometimed defined in macOS system headers. + TYPE_BOOL = 30; + // Defined in macOS, Windows, and Linux headers. + DEBUG = 31; +} diff --git a/Protos/upstream/google/protobuf/unittest_proto3_extensions.proto b/Protos/upstream/google/protobuf/unittest_proto3_extensions.proto new file mode 100644 index 000000000..a59c43e73 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_proto3_extensions.proto @@ -0,0 +1,15 @@ +syntax = "proto3"; + +package protobuf_unittest; + +import "google/protobuf/descriptor.proto"; + +option java_outer_classname = "UnittestProto3Extensions"; + +// For testing proto3 extension behaviors. +message Proto3FileExtensions { + extend google.protobuf.FileOptions { + int32 singular_int = 1001; + repeated int32 repeated_int = 1002; + } +} diff --git a/Protos/upstream/google/protobuf/unittest_proto3_lite.proto b/Protos/upstream/google/protobuf/unittest_proto3_lite.proto new file mode 100644 index 000000000..dee340174 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_proto3_lite.proto @@ -0,0 +1,181 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +syntax = "proto3"; + +package proto3_lite_unittest; + +import "google/protobuf/unittest_import.proto"; + +option optimize_for = LITE_RUNTIME; + +// This proto includes every type of field in both singular and repeated +// forms. +message TestAllTypes { + message NestedMessage { + // The field name "b" fails to compile in proto1 because it conflicts with + // a local variable named "b" in one of the generated methods. Doh. + // This file needs to compile in proto1 to test backwards-compatibility. + int32 bb = 1; + } + + enum NestedEnum { + ZERO = 0; + FOO = 1; + BAR = 2; + BAZ = 3; + NEG = -1; // Intentionally negative. + } + + // Singular + int32 optional_int32 = 1; + int64 optional_int64 = 2; + uint32 optional_uint32 = 3; + uint64 optional_uint64 = 4; + sint32 optional_sint32 = 5; + sint64 optional_sint64 = 6; + fixed32 optional_fixed32 = 7; + fixed64 optional_fixed64 = 8; + sfixed32 optional_sfixed32 = 9; + sfixed64 optional_sfixed64 = 10; + float optional_float = 11; + double optional_double = 12; + bool optional_bool = 13; + string optional_string = 14; + bytes optional_bytes = 15; + + // Groups are not allowed in proto3. + // optional group OptionalGroup = 16 { + // optional int32 a = 17; + // } + + NestedMessage optional_nested_message = 18; + ForeignMessage optional_foreign_message = 19; + proto2_unittest_import.ImportMessage optional_import_message = 20; + + NestedEnum optional_nested_enum = 21; + ForeignEnum optional_foreign_enum = 22; + + // Omitted (compared to unittest.proto) because proto2 enums are not allowed + // inside proto2 messages. + // + // optional proto2_unittest_import.ImportEnum optional_import_enum = 23; + + string optional_string_piece = 24 [ctype = STRING_PIECE]; + string optional_cord = 25 [ctype = CORD]; + + // Defined in unittest_import_public.proto + proto2_unittest_import.PublicImportMessage optional_public_import_message = + 26; + + NestedMessage optional_lazy_message = 27 [lazy = true]; + + // Repeated + repeated int32 repeated_int32 = 31; + repeated int64 repeated_int64 = 32; + repeated uint32 repeated_uint32 = 33; + repeated uint64 repeated_uint64 = 34; + repeated sint32 repeated_sint32 = 35; + repeated sint64 repeated_sint64 = 36; + repeated fixed32 repeated_fixed32 = 37; + repeated fixed64 repeated_fixed64 = 38; + repeated sfixed32 repeated_sfixed32 = 39; + repeated sfixed64 repeated_sfixed64 = 40; + repeated float repeated_float = 41; + repeated double repeated_double = 42; + repeated bool repeated_bool = 43; + repeated string repeated_string = 44; + repeated bytes repeated_bytes = 45; + + // Groups are not allowed in proto3. + // repeated group RepeatedGroup = 46 { + // optional int32 a = 47; + // } + + repeated NestedMessage repeated_nested_message = 48; + repeated ForeignMessage repeated_foreign_message = 49; + repeated proto2_unittest_import.ImportMessage repeated_import_message = 50; + + repeated NestedEnum repeated_nested_enum = 51; + repeated ForeignEnum repeated_foreign_enum = 52; + + // Omitted (compared to unittest.proto) because proto2 enums are not allowed + // inside proto2 messages. + // + // repeated proto2_unittest_import.ImportEnum repeated_import_enum = 53; + + repeated string repeated_string_piece = 54 [ctype = STRING_PIECE]; + repeated string repeated_cord = 55 [ctype = CORD]; + + repeated NestedMessage repeated_lazy_message = 57; + + oneof oneof_field { + uint32 oneof_uint32 = 111; + NestedMessage oneof_nested_message = 112; + string oneof_string = 113; + bytes oneof_bytes = 114; + } +} + +// Test messages for packed fields + +message TestPackedTypes { + repeated int32 packed_int32 = 90 [packed = true]; + repeated int64 packed_int64 = 91 [packed = true]; + repeated uint32 packed_uint32 = 92 [packed = true]; + repeated uint64 packed_uint64 = 93 [packed = true]; + repeated sint32 packed_sint32 = 94 [packed = true]; + repeated sint64 packed_sint64 = 95 [packed = true]; + repeated fixed32 packed_fixed32 = 96 [packed = true]; + repeated fixed64 packed_fixed64 = 97 [packed = true]; + repeated sfixed32 packed_sfixed32 = 98 [packed = true]; + repeated sfixed64 packed_sfixed64 = 99 [packed = true]; + repeated float packed_float = 100 [packed = true]; + repeated double packed_double = 101 [packed = true]; + repeated bool packed_bool = 102 [packed = true]; + repeated ForeignEnum packed_enum = 103 [packed = true]; +} + +// Explicitly set packed to false +message TestUnpackedTypes { + repeated int32 repeated_int32 = 1 [packed = false]; + repeated int64 repeated_int64 = 2 [packed = false]; + repeated uint32 repeated_uint32 = 3 [packed = false]; + repeated uint64 repeated_uint64 = 4 [packed = false]; + repeated sint32 repeated_sint32 = 5 [packed = false]; + repeated sint64 repeated_sint64 = 6 [packed = false]; + repeated fixed32 repeated_fixed32 = 7 [packed = false]; + repeated fixed64 repeated_fixed64 = 8 [packed = false]; + repeated sfixed32 repeated_sfixed32 = 9 [packed = false]; + repeated sfixed64 repeated_sfixed64 = 10 [packed = false]; + repeated float repeated_float = 11 [packed = false]; + repeated double repeated_double = 12 [packed = false]; + repeated bool repeated_bool = 13 [packed = false]; + repeated TestAllTypes.NestedEnum repeated_nested_enum = 14 [packed = false]; +} + +// This proto includes a recursively nested message. +message NestedTestAllTypes { + NestedTestAllTypes child = 1; + TestAllTypes payload = 2; +} + +// Define these after TestAllTypes to make sure the compiler can handle +// that. +message ForeignMessage { + int32 c = 1; +} + +enum ForeignEnum { + FOREIGN_ZERO = 0; + FOREIGN_FOO = 4; + FOREIGN_BAR = 5; + FOREIGN_BAZ = 6; +} + +// TestEmptyMessage is used to test behavior of unknown fields. +message TestEmptyMessage {} diff --git a/Protos/upstream/google/protobuf/unittest_proto3_optional.proto b/Protos/upstream/google/protobuf/unittest_proto3_optional.proto new file mode 100644 index 000000000..1354212b1 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_proto3_optional.proto @@ -0,0 +1,78 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +syntax = "proto3"; + +package proto2_unittest; + +import "google/protobuf/descriptor.proto"; + +option csharp_namespace = "ProtobufUnittest"; +option java_multiple_files = true; +option java_package = "com.google.protobuf.testing.proto"; + +message TestProto3Optional { + message NestedMessage { + // The field name "b" fails to compile in proto1 because it conflicts with + // a local variable named "b" in one of the generated methods. Doh. + // This file needs to compile in proto1 to test backwards-compatibility. + optional int32 bb = 1; + } + + enum NestedEnum { + UNSPECIFIED = 0; + FOO = 1; + BAR = 2; + BAZ = 3; + NEG = -1; // Intentionally negative. + } + + // Singular + optional int32 optional_int32 = 1; + optional int64 optional_int64 = 2; + optional uint32 optional_uint32 = 3; + optional uint64 optional_uint64 = 4; + optional sint32 optional_sint32 = 5; + optional sint64 optional_sint64 = 6; + optional fixed32 optional_fixed32 = 7; + optional fixed64 optional_fixed64 = 8; + optional sfixed32 optional_sfixed32 = 9; + optional sfixed64 optional_sfixed64 = 10; + optional float optional_float = 11; + optional double optional_double = 12; + optional bool optional_bool = 13; + optional string optional_string = 14; + optional bytes optional_bytes = 15; + optional string optional_cord = 16 [ctype = CORD]; + + optional NestedMessage optional_nested_message = 18; + optional NestedMessage lazy_nested_message = 19 [lazy = true]; + optional NestedEnum optional_nested_enum = 21; + + // Add some non-optional fields to verify we can mix them. + int32 singular_int32 = 22; + int64 singular_int64 = 23; +} + +message TestProto3OptionalMessage { + message NestedMessage { + string s = 1; + } + + NestedMessage nested_message = 1; + optional NestedMessage optional_nested_message = 2; +} + +message Proto3OptionalExtensions { + option (proto2_unittest.Proto3OptionalExtensions.ext_no_optional) = 8; + option (proto2_unittest.Proto3OptionalExtensions.ext_with_optional) = 16; + + extend google.protobuf.MessageOptions { + int32 ext_no_optional = 355886728; + optional int32 ext_with_optional = 355886729; + } +} diff --git a/Protos/upstream/google/protobuf/unittest_redaction.proto b/Protos/upstream/google/protobuf/unittest_redaction.proto new file mode 100644 index 000000000..51bd3fdde --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_redaction.proto @@ -0,0 +1,72 @@ +// Test proto for redaction +edition = "2024"; + +package proto2_unittest; + +import "google/protobuf/any.proto"; +import "google/protobuf/descriptor.proto"; + +option java_package = "com.google.protos"; +option java_outer_classname = "RedactionProto"; +option features.repeated_field_encoding = EXPANDED; +option features.utf8_validation = NONE; + +extend .google.protobuf.FieldOptions { + MetaAnnotatedEnum meta_annotated_enum = 535801413; + repeated MetaAnnotatedEnum repeated_meta_annotated_enum = 535801414; + TestNestedMessageEnum test_nested_message_enum = 535801415; +} + +message TestRedactedNestMessage { + string foo = 1; +} + +message TestRepeatedRedactedNestMessage { + string bar = 1; +} + +message TestMessageEnum { + repeated MetaAnnotatedEnum redactable_enum = 1; +} + +message TestNestedMessageEnum { + repeated MetaAnnotatedEnum direct_enum = 1; + TestMessageEnum nested_enum = 2; + string redacted_string = 3 [debug_redact = true]; +} + +message TestRedactedMessage { + string text_field = 1 [deprecated = true]; + string meta_annotated = 8 [(meta_annotated_enum) = TEST_REDACTABLE]; + string repeated_meta_annotated = 9 [ + (proto2_unittest.repeated_meta_annotated_enum) = TEST_NO_REDACT, + (proto2_unittest.repeated_meta_annotated_enum) = TEST_REDACTABLE + ]; + string unredacted_repeated_annotations = 10 [ + (proto2_unittest.repeated_meta_annotated_enum) = TEST_NO_REDACT, + (proto2_unittest.repeated_meta_annotated_enum) = TEST_NO_REDACT_AGAIN + ]; + string unreported_non_meta_debug_redact_field = 17 [debug_redact = true]; + google.protobuf.Any any_field = 18 [debug_redact = true]; + string redactable_false = 19 [(meta_annotated_enum) = TEST_REDACTABLE_FALSE]; + string test_direct_message_enum = 22 + [(proto2_unittest.test_nested_message_enum) = { + direct_enum: [ TEST_NO_REDACT, TEST_REDACTABLE ] + }]; + string test_nested_message_enum = 23 + [(proto2_unittest.test_nested_message_enum) = { + nested_enum { redactable_enum: [ TEST_NO_REDACT, TEST_REDACTABLE ] } + }]; + string test_redacted_message_enum = 24 + [(proto2_unittest.test_nested_message_enum) = { + redacted_string: "redacted_but_doesnt_redact" + }]; +} + +enum MetaAnnotatedEnum { + TEST_NULL = 0; + TEST_REDACTABLE = 1 [debug_redact = true]; + TEST_NO_REDACT = 2; + TEST_NO_REDACT_AGAIN = 3; + TEST_REDACTABLE_FALSE = 4 [debug_redact = false]; +} diff --git a/Protos/upstream/google/protobuf/unittest_retention.proto b/Protos/upstream/google/protobuf/unittest_retention.proto new file mode 100644 index 000000000..6c31846a2 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_retention.proto @@ -0,0 +1,185 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +syntax = "proto2"; + +package proto2_unittest; + +import "google/protobuf/descriptor.proto"; + +option csharp_namespace = "ProtobufUnittest"; + +// Retention attributes set directly on custom options +extend google.protobuf.FileOptions { + optional int32 plain_option = 505092806; + optional int32 runtime_retention_option = 505039132 + [retention = RETENTION_RUNTIME]; + optional int32 source_retention_option = 504878676 + [retention = RETENTION_SOURCE]; +} + +option (plain_option) = 1; +option (runtime_retention_option) = 2; +option (source_retention_option) = 3; + +// Retention attributes set on fields nested within a message +message OptionsMessage { + optional int32 plain_field = 1; + optional int32 runtime_retention_field = 2 [retention = RETENTION_RUNTIME]; + optional int32 source_retention_field = 3 [retention = RETENTION_SOURCE]; +} + +extend google.protobuf.FileOptions { + optional OptionsMessage file_option = 504871168; +} + +option (file_option) = { + plain_field: 1 + runtime_retention_field: 2 + source_retention_field: 3 +}; + +// Retention attribute nested inside a repeated message field +extend google.protobuf.FileOptions { + repeated OptionsMessage repeated_options = 504823570; +} + +option (repeated_options) = { + plain_field: 1 + runtime_retention_field: 2 + source_retention_field: 3 +}; + +extend google.protobuf.ExtensionRangeOptions { + optional OptionsMessage extension_range_option = 504822148; +} + +extend google.protobuf.MessageOptions { + optional OptionsMessage message_option = 504820819; +} + +extend google.protobuf.FieldOptions { + optional OptionsMessage field_option = 504589219; +} + +extend google.protobuf.OneofOptions { + optional OptionsMessage oneof_option = 504479153; +} + +extend google.protobuf.EnumOptions { + optional OptionsMessage enum_option = 504451567; +} + +extend google.protobuf.EnumValueOptions { + optional OptionsMessage enum_entry_option = 504450522; +} + +extend google.protobuf.ServiceOptions { + optional OptionsMessage service_option = 504387709; +} + +extend google.protobuf.MethodOptions { + optional OptionsMessage method_option = 504349420; +} + +message Extendee { + extensions 1, 2; +} + +extend Extendee { + optional int32 i = 1 [(field_option) = { + plain_field: 1 + runtime_retention_field: 2 + source_retention_field: 3 + }]; +} + +message TopLevelMessage { + option (message_option) = { + plain_field: 1 + runtime_retention_field: 2 + source_retention_field: 3 + }; + + message NestedMessage { + option (message_option) = { + plain_field: 1 + runtime_retention_field: 2 + source_retention_field: 3 + }; + } + + enum NestedEnum { + option (enum_option) = { + plain_field: 1 + runtime_retention_field: 2 + source_retention_field: 3 + }; + + NESTED_UNKNOWN = 0; + } + + optional float f = 1 [(field_option) = { + plain_field: 1 + runtime_retention_field: 2 + source_retention_field: 3 + }]; + + oneof o { + option (oneof_option) = { + plain_field: 1 + runtime_retention_field: 2 + source_retention_field: 3 + }; + + int64 i = 2; + } + + extensions 10 to 100 [(extension_range_option) = { + plain_field: 1 + runtime_retention_field: 2 + source_retention_field: 3 + }]; + + extend Extendee { + optional string s = 2 [(field_option) = { + plain_field: 1 + runtime_retention_field: 2 + source_retention_field: 3 + }]; + } +} + +enum TopLevelEnum { + option (enum_option) = { + plain_field: 1 + runtime_retention_field: 2 + source_retention_field: 3 + }; + + TOP_LEVEL_UNKNOWN = 0 [(enum_entry_option) = { + plain_field: 1 + runtime_retention_field: 2 + source_retention_field: 3 + }]; +} + +service Service { + option (service_option) = { + plain_field: 1 + runtime_retention_field: 2 + source_retention_field: 3 + }; + + rpc DoStuff(TopLevelMessage) returns (TopLevelMessage) { + option (method_option) = { + plain_field: 1 + runtime_retention_field: 2 + source_retention_field: 3 + }; + } +} diff --git a/Protos/upstream/google/protobuf/unittest_string_type.proto b/Protos/upstream/google/protobuf/unittest_string_type.proto new file mode 100644 index 000000000..62583cfe5 --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_string_type.proto @@ -0,0 +1,16 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +edition = "2024"; + +package proto2_unittest; + +import option "google/protobuf/cpp_features.proto"; + +message EntryProto { + bytes value = 3 [features.(pb.cpp).string_type = CORD]; +} diff --git a/Protos/upstream/google/protobuf/unittest_string_view.proto b/Protos/upstream/google/protobuf/unittest_string_view.proto new file mode 100644 index 000000000..70e89318a --- /dev/null +++ b/Protos/upstream/google/protobuf/unittest_string_view.proto @@ -0,0 +1,27 @@ +edition = "2024"; + +package proto2_unittest; + +option optimize_for = SPEED; + +// NEXT_TAG = 6; +message TestStringView { + string singular_string = 1; + bytes singular_bytes = 2; + string implicit_presence = 5 [features.field_presence = IMPLICIT]; + + repeated string repeated_string = 3; + repeated bytes repeated_bytes = 4; +} + +message TestStringViewExtension { + extensions 1 to max; +} + +extend TestStringViewExtension { + string singular_string_view_extension = 1; + bytes singular_bytes_view_extension = 2; + + repeated string repeated_string_view_extension = 3; + repeated bytes repeated_bytes_view_extension = 4; +} diff --git a/Protos/google/protobuf/unittest_well_known_types.proto b/Protos/upstream/google/protobuf/unittest_well_known_types.proto similarity index 74% rename from Protos/google/protobuf/unittest_well_known_types.proto rename to Protos/upstream/google/protobuf/unittest_well_known_types.proto index c90752440..36eff35a1 100644 --- a/Protos/google/protobuf/unittest_well_known_types.proto +++ b/Protos/upstream/google/protobuf/unittest_well_known_types.proto @@ -1,10 +1,13 @@ -syntax = "proto3"; +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd -package protobuf_unittest; +syntax = "proto3"; -option csharp_namespace = "Google.Protobuf.TestProtos"; -option java_multiple_files = true; -option java_package = "com.google.protobuf.test"; +package proto2_unittest; import "google/protobuf/any.proto"; import "google/protobuf/api.proto"; @@ -17,6 +20,10 @@ import "google/protobuf/timestamp.proto"; import "google/protobuf/type.proto"; import "google/protobuf/wrappers.proto"; +option csharp_namespace = "Google.Protobuf.TestProtos"; +option java_multiple_files = true; +option java_package = "com.google.protobuf.test"; + // Test that we can include all well-known types. // Each wrapper type is included separately, as languages // map handle different wrappers in different ways. @@ -93,22 +100,22 @@ message OneofWellKnownTypes { // need to worry about the value part of the map being the // well-known types, as messages can't be map keys. message MapWellKnownTypes { - map any_field = 1; - map api_field = 2; - map duration_field = 3; - map empty_field = 4; - map field_mask_field = 5; - map source_context_field = 6; - map struct_field = 7; - map timestamp_field = 8; - map type_field = 9; - map double_field = 10; - map float_field = 11; - map int64_field = 12; - map uint64_field = 13; - map int32_field = 14; - map uint32_field = 15; - map bool_field = 16; - map string_field = 17; - map bytes_field = 18; + map any_field = 1; + map api_field = 2; + map duration_field = 3; + map empty_field = 4; + map field_mask_field = 5; + map source_context_field = 6; + map struct_field = 7; + map timestamp_field = 8; + map type_field = 9; + map double_field = 10; + map float_field = 11; + map int64_field = 12; + map uint64_field = 13; + map int32_field = 14; + map uint32_field = 15; + map bool_field = 16; + map string_field = 17; + map bytes_field = 18; } diff --git a/Protos/upstream/google/protobuf/wrappers.proto b/Protos/upstream/google/protobuf/wrappers.proto new file mode 100644 index 000000000..e583e7c40 --- /dev/null +++ b/Protos/upstream/google/protobuf/wrappers.proto @@ -0,0 +1,157 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Wrappers for primitive (non-message) types. These types were needed +// for legacy reasons and are not recommended for use in new APIs. +// +// Historically these wrappers were useful to have presence on proto3 primitive +// fields, but proto3 syntax has been updated to support the `optional` keyword. +// Using that keyword is now the strongly preferred way to add presence to +// proto3 primitive fields. +// +// A secondary usecase was to embed primitives in the `google.protobuf.Any` +// type: it is now recommended that you embed your value in your own wrapper +// message which can be specifically documented. +// +// These wrappers have no meaningful use within repeated fields as they lack +// the ability to detect presence on individual elements. +// These wrappers have no meaningful use within a map or a oneof since +// individual entries of a map or fields of a oneof can already detect presence. + +syntax = "proto3"; + +package google.protobuf; + +option cc_enable_arenas = true; +option go_package = "google.golang.org/protobuf/types/known/wrapperspb"; +option java_package = "com.google.protobuf"; +option java_outer_classname = "WrappersProto"; +option java_multiple_files = true; +option objc_class_prefix = "GPB"; +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; + +// Wrapper message for `double`. +// +// The JSON representation for `DoubleValue` is JSON number. +// +// Not recommended for use in new APIs, but still useful for legacy APIs and +// has no plan to be removed. +message DoubleValue { + // The double value. + double value = 1; +} + +// Wrapper message for `float`. +// +// The JSON representation for `FloatValue` is JSON number. +// +// Not recommended for use in new APIs, but still useful for legacy APIs and +// has no plan to be removed. +message FloatValue { + // The float value. + float value = 1; +} + +// Wrapper message for `int64`. +// +// The JSON representation for `Int64Value` is JSON string. +// +// Not recommended for use in new APIs, but still useful for legacy APIs and +// has no plan to be removed. +message Int64Value { + // The int64 value. + int64 value = 1; +} + +// Wrapper message for `uint64`. +// +// The JSON representation for `UInt64Value` is JSON string. +// +// Not recommended for use in new APIs, but still useful for legacy APIs and +// has no plan to be removed. +message UInt64Value { + // The uint64 value. + uint64 value = 1; +} + +// Wrapper message for `int32`. +// +// The JSON representation for `Int32Value` is JSON number. +// +// Not recommended for use in new APIs, but still useful for legacy APIs and +// has no plan to be removed. +message Int32Value { + // The int32 value. + int32 value = 1; +} + +// Wrapper message for `uint32`. +// +// The JSON representation for `UInt32Value` is JSON number. +// +// Not recommended for use in new APIs, but still useful for legacy APIs and +// has no plan to be removed. +message UInt32Value { + // The uint32 value. + uint32 value = 1; +} + +// Wrapper message for `bool`. +// +// The JSON representation for `BoolValue` is JSON `true` and `false`. +// +// Not recommended for use in new APIs, but still useful for legacy APIs and +// has no plan to be removed. +message BoolValue { + // The bool value. + bool value = 1; +} + +// Wrapper message for `string`. +// +// The JSON representation for `StringValue` is JSON string. +// +// Not recommended for use in new APIs, but still useful for legacy APIs and +// has no plan to be removed. +message StringValue { + // The string value. + string value = 1; +} + +// Wrapper message for `bytes`. +// +// The JSON representation for `BytesValue` is JSON string. +// +// Not recommended for use in new APIs, but still useful for legacy APIs and +// has no plan to be removed. +message BytesValue { + // The bytes value. + bytes value = 1; +} diff --git a/Protos/upstream/java/core/src/main/resources/google/protobuf/java_features.proto b/Protos/upstream/java/core/src/main/resources/google/protobuf/java_features.proto new file mode 100644 index 000000000..80ac6fa9f --- /dev/null +++ b/Protos/upstream/java/core/src/main/resources/google/protobuf/java_features.proto @@ -0,0 +1,132 @@ + +// Protocol Buffers - Google's data interchange format +// Copyright 2023 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +syntax = "proto2"; + +package pb; + +import "google/protobuf/descriptor.proto"; + +option java_package = "com.google.protobuf"; +option java_outer_classname = "JavaFeaturesProto"; + +extend google.protobuf.FeatureSet { + optional JavaFeatures java = 1001; +} + +message JavaFeatures { + // Whether or not to treat an enum field as closed. This option is only + // applicable to enum fields, and will be removed in the future. It is + // consistent with the legacy behavior of using proto3 enum types for proto2 + // fields. + optional bool legacy_closed_enum = 1 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023, + edition_deprecated: EDITION_2023, + deprecation_warning: "The legacy closed enum behavior in Java is " + "deprecated and is scheduled to be removed in " + "edition 2025. See http://protobuf.dev/programming-guides/enum/#java for " + "more information.", + }, + edition_defaults = { edition: EDITION_LEGACY, value: "true" }, + edition_defaults = { edition: EDITION_PROTO3, value: "false" } + ]; + + // The UTF8 validation strategy to use. + enum Utf8Validation { + // Invalid default, which should never be used. + UTF8_VALIDATION_UNKNOWN = 0; + // Respect the UTF8 validation behavior specified by the global + // utf8_validation feature. + DEFAULT = 1; + // Verifies UTF8 validity overriding the global utf8_validation + // feature. This represents the legacy java_string_check_utf8 option. + VERIFY = 2; + } + optional Utf8Validation utf8_validation = 2 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FIELD, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2023, + edition_deprecated: EDITION_2024, + deprecation_warning: "The Java-specific utf8 validation feature is " + "deprecated and is scheduled to be removed in " + "edition 2025. Utf8 validation behavior should " + "use the global cross-language utf8_validation " + "feature.", + }, + edition_defaults = { edition: EDITION_LEGACY, value: "DEFAULT" } + ]; + + // Allows creation of large Java enums, extending beyond the standard + // constant limits imposed by the Java language. + optional bool large_enum = 3 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2024, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "false" } + ]; + + // Whether to use the old default outer class name scheme, or the new feature + // which adds a "Proto" suffix to the outer class name. + // + // Users will not be able to set this option, because we removed it in the + // same edition that it was introduced. But we use it to determine which + // naming scheme to use for outer class name defaults. + optional bool use_old_outer_classname_default = 4 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2024, + edition_removed: EDITION_2024, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "true" }, + edition_defaults = { edition: EDITION_2024, value: "false" } + ]; + + message NestInFileClassFeature { + enum NestInFileClass { + // Invalid default, which should never be used. + NEST_IN_FILE_CLASS_UNKNOWN = 0; + // Do not nest the generated class in the file class. + NO = 1; + // Nest the generated class in the file class. + YES = 2; + // Fall back to the `java_multiple_files` option. Users won't be able to + // set this option. + LEGACY = 3 [feature_support = { + edition_introduced: EDITION_2024 + edition_removed: EDITION_2024 + }]; + } + reserved 1 to max; + } + + // Whether to nest the generated class in the generated file class. This is + // only applicable to *top-level* messages, enums, and services. + optional NestInFileClassFeature.NestInFileClass nest_in_file_class = 5 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_MESSAGE, + targets = TARGET_TYPE_ENUM, + targets = TARGET_TYPE_SERVICE, + feature_support = { + edition_introduced: EDITION_2024, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "LEGACY" }, + edition_defaults = { edition: EDITION_2024, value: "NO" } + ]; + + reserved 6; // field `mutable_nest_in_file_class` removed. +} diff --git a/Protos/upstream/java/core/src/main/resources/google/protobuf/java_mutable_features.proto b/Protos/upstream/java/core/src/main/resources/google/protobuf/java_mutable_features.proto new file mode 100644 index 000000000..c356e72e9 --- /dev/null +++ b/Protos/upstream/java/core/src/main/resources/google/protobuf/java_mutable_features.proto @@ -0,0 +1,45 @@ +syntax = "proto2"; + +package pb; + +import "google/protobuf/descriptor.proto"; + +option java_package = "com.google.protobuf"; +option java_outer_classname = "JavaMutableFeaturesProto"; + +extend google.protobuf.FeatureSet { + optional JavaMutableFeatures java_mutable = 9989; +} + +message JavaMutableFeatures { + message NestInFileClassFeature { + enum NestInFileClass { + // Invalid default, which should never be used. + NEST_IN_FILE_CLASS_UNKNOWN = 0; + // Do not nest the generated class in the file class. + NO = 1; + // Nest the generated class in the file class. + YES = 2; + // Fall back to the `java_multiple_files` and + // `java_multiple_files_mutable_package` options. Users won't be able to + // set this option. + LEGACY = 3 [feature_support = { + edition_introduced: EDITION_2024 + edition_removed: EDITION_2024 + }]; + } + reserved 1 to max; + } + + // Whether to nest the generated class in the generated file class for + // Java Proto2 Mutable API. This is only available at the file level. + optional NestInFileClassFeature.NestInFileClass nest_in_file_class = 6 [ + retention = RETENTION_RUNTIME, + targets = TARGET_TYPE_FILE, + feature_support = { + edition_introduced: EDITION_2024, + }, + edition_defaults = { edition: EDITION_LEGACY, value: "LEGACY" }, + edition_defaults = { edition: EDITION_2024, value: "NO" } + ]; +} diff --git a/README.md b/README.md index 9956ee09a..67496ac27 100644 --- a/README.md +++ b/README.md @@ -5,9 +5,8 @@ **Welcome to Swift Protobuf!** [Apple's Swift programming language](https://swift.org/) is a perfect -complement to [Google's Protocol -Buffer](https://developers.google.com/protocol-buffers/) ("protobuf") serialization -technology. +complement to [Google's Protocol Buffer](https://protobuf.dev/) +("protobuf") serialization technology. They both emphasize high performance and programmer safety. This project provides both the command-line program that adds Swift @@ -36,12 +35,12 @@ systems: * Idiomatic: SwiftProtobuf takes full advantage of the Swift language. In particular, all generated types provide full Swift copy-on-write value semantics. -* Efficient binary serialization: The `.serializedData()` - method returns a `Data` with a compact binary form of your data. - You can deserialize the data using the `init(serializedData:)` +* Efficient binary serialization: The `.serializedBytes()` + method returns a bag of bytes with a compact binary form of your data. + You can deserialize the data using the `init(contiguousBytes:)` initializer. -* Standard JSON serialization: The `.jsonUTF8Data()` method returns a JSON - form of your data that can be parsed with the `init(jsonUTF8Data:)` +* Standard JSON serialization: The `.jsonUTF8Bytes()` method returns a JSON + form of your data that can be parsed with the `init(jsonUTF8Bytes:)` initializer. * Hashable, Equatable: The generated struct can be put into a `Set<>` or `Dictionary<>`. @@ -61,7 +60,7 @@ additional effort on your part. More information is available in the associated documentation: - * [Google's protobuf documentation](https://developers.google.com/protocol-buffers/) + * [Google's protobuf documentation](https://protobuf.dev/) provides general information about protocol buffers, the protoc compiler, and how to use protocol buffers with C++, Java, and other languages. * [PLUGIN.md](Documentation/PLUGIN.md) documents the `protoc-gen-swift` @@ -69,8 +68,6 @@ More information is available in the associated documentation: * [API.md](Documentation/API.md) documents how to use the generated code. This is recommended reading for anyone using SwiftProtobuf in their project. - * [cocoadocs.org](http://cocoadocs.org/docsets/SwiftProtobuf/) has the generated - API documentation * [INTERNALS.md](Documentation/INTERNALS.md) documents the internal structure of the generated code and the library. This should only be needed by folks interested in working on SwiftProtobuf @@ -93,18 +90,17 @@ your project as explained below. To use Swift with Protocol buffers, you'll need: -* A Swift 4.2 or later compiler (Xcode 10.0 or later). Support is included -for the Swift Package Manager; or using the included Xcode project. The Swift -protobuf project is being developed and tested against the latest release -version of Swift available from [Swift.org](https://swift.org) +* A Swift 5.10 or later compiler (or, if building with Xcode, Xcode 15.3 or later + as required by the App Store). The Swift protobuf project is being developed + and tested against the latest release version of Swift available from + [Swift.org](https://swift.org) -* Google's protoc compiler. The Swift protoc plugin is being actively -developed and tested against the latest protobuf sources. -The SwiftProtobuf tests need a version of protoc which supports the -`swift_prefix` option (introduced in protoc 3.2.0). -It may work with earlier versions of protoc. -You can get recent versions from -[Google's github repository](https://github.com/protocolbuffers/protobuf). +* Google's protoc compiler. The Swift protoc plugin is being actively developed + and tested against the latest protobuf sources. The SwiftProtobuf tests need a + version of protoc which supports the `swift_prefix` option (introduced in + protoc 3.2.0). It may work with earlier versions of protoc. You can get recent + versions from + [Google's github repository](https://github.com/protocolbuffers/protobuf). ## Building and Installing the Code Generator Plugin @@ -113,24 +109,24 @@ protoc compiler and the SwiftProtobuf code generator plugin. Building the plugin should be simple on any supported Swift platform: -``` -$ git clone https://github.com/apple/swift-protobuf.git -$ cd swift-protobuf +```bash +git clone https://github.com/apple/swift-protobuf.git +cd swift-protobuf ``` Pick what released version of SwiftProtobuf you are going to use. You can get a list of tags with: -``` -$ git tag -l +```bash +git tag -l ``` Once you pick the version you will use, set your local state to match, and build the protoc plugin: -``` -$ git checkout tags/[tag_name] -$ swift build -c release +```bash +git checkout tags/[tag_name] +swift build -c release ``` This will create a binary called `protoc-gen-swift` in the `.build/release` @@ -147,8 +143,8 @@ to use also use `--static-swift-stdlib` with `swift build`. If you prefer using [Homebrew](https://brew.sh): -``` -$ brew install swift-protobuf +```bash +brew install swift-protobuf ``` This will install `protoc` compiler and Swift code generator plugin. @@ -158,8 +154,8 @@ This will install `protoc` compiler and Swift code generator plugin. To generate Swift output for your .proto files, you run the `protoc` command as usual, using the `--swift_out=` option: -``` -$ protoc --swift_out=. my.proto +```bash +protoc --swift_out=. my.proto ``` The `protoc` program will automatically look for `protoc-gen-swift` in your @@ -186,15 +182,18 @@ After copying the `.pb.swift` files into your project, you will need to add the project to support the generated code. If you are using the Swift Package Manager, add a dependency to your `Package.swift` file and import the `SwiftProtobuf` library into the desired -targets. Adjust the `"1.6.0"` here to match the `[tag_name]` you used to build +targets. Adjust the `"1.27.0"` here to match the `[tag_name]` you used to build the plugin above: ```swift dependencies: [ - .package(name: "SwiftProtobuf", url: "https://github.com/apple/swift-protobuf.git", from: "1.6.0"), + .package(url: "https://github.com/apple/swift-protobuf.git", from: "1.27.0"), ], targets: [ - .target(name: "MyTarget", dependencies: ["SwiftProtobuf"]), + .target( + name: "MyTarget", + dependencies: [.product(name: "SwiftProtobuf", package: "swift-protobuf")] + ), ] ``` @@ -204,8 +203,8 @@ If you are using Xcode, then you should: * Add the `.pb.swift` source files generated from your protos directly to your project -* Add the appropriate `SwiftProtobuf_` target from the Xcode project - in this package to your project. +* Add this SwiftPM package as dependency of your xcode project: + [Apple Docs](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app) ### ...using CocoaPods @@ -220,16 +219,6 @@ And run `pod install`. NOTE: CocoaPods 1.7 or newer is required. -### ...using Carthage - -If you're using Carthage, add this to your `Cartfile` but adjust the tag to match the `[tag_name]` you used to build the plugin above: - -```ruby -github "apple/swift-protobuf" ~> 1.0 -``` - -Run `carthage update` and drag `SwiftProtobuf.framework` into your Xcode.project. - # Quick Start Once you have installed the code generator, used it to @@ -251,8 +240,8 @@ message BookInfo { ``` Then generate Swift code using: -``` -$ protoc --swift_out=. DataModel.proto +```bash +protoc --swift_out=. DataModel.proto ``` The generated code will expose a Swift property for @@ -272,17 +261,33 @@ let info2 = BookInfo.with { $0.author = "Jane Q. Smith" } -// Serialize to binary protobuf format: -let binaryData: Data = try info.serializedData() +// Serialize to binary protobuf format: you can choose to serialize into +// any type conforming to `SwiftProtobufContiguousBytes`. For example: +// Resolve the `SwiftProtobufContiguousBytes` return value to `Data` +let binaryData: Data = try info.serializedBytes() +// Resolve the `SwiftProtobufContiguousBytes` return value to `[UInt8]` +let binaryDataAsBytes: [UInt8] = try info.serializedBytes() + +// Note that while the `serializedBytes()` spelling is generally preferred, +// you may also use `serializedData()` to get the bytes as an instance of +// `Data` where required. +// This means that the following two statements are equivalent: +// let binaryData: Data = try info.serializedBytes() +// let binaryData: Data = try info.serializedData() // Deserialize a received Data object from `binaryData` let decodedInfo = try BookInfo(serializedData: binaryData) -// Serialize to JSON format as a Data object +// Deserialize a received [UInt8] object from `binaryDataAsBytes` +let decodedInfo = try BookInfo(serializedBytes: binaryDataAsBytes) + +// Serialize to JSON format as a Data object, or as any other type conforming to +// SwiftProtobufContiguousBytes. For example: let jsonData: Data = try info.jsonUTF8Data() +let jsonBytes: [UInt8] = try info.jsonUTF8Bytes() -// Deserialize from JSON format from `jsonData` -let receivedFromJSON = try BookInfo(jsonUTF8Data: jsonData) +// Deserialize from JSON format from `jsonBytes` +let receivedFromJSON = try BookInfo(jsonUTF8Bytes: jsonBytes) ``` You can find more information in the detailed diff --git a/Reference/CompileTests/InternalImportsByDefault/ServiceOnly.pb.swift b/Reference/CompileTests/InternalImportsByDefault/ServiceOnly.pb.swift new file mode 100644 index 000000000..d62687c93 --- /dev/null +++ b/Reference/CompileTests/InternalImportsByDefault/ServiceOnly.pb.swift @@ -0,0 +1,11 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: ServiceOnly.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// This file contained no messages, enums, or extensions. diff --git a/Reference/CompileTests/InternalImportsByDefault/SomeProtoWithBytes.pb.swift b/Reference/CompileTests/InternalImportsByDefault/SomeProtoWithBytes.pb.swift new file mode 100644 index 000000000..c2e52a20f --- /dev/null +++ b/Reference/CompileTests/InternalImportsByDefault/SomeProtoWithBytes.pb.swift @@ -0,0 +1,94 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: SomeProtoWithBytes.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +public import Foundation +public 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 +} + +public struct SomeProtoWithBytes: Sendable { + // 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. + + public var someBytes: Data { + get {_someBytes ?? Data()} + set {_someBytes = newValue} + } + /// Returns true if `someBytes` has been explicitly set. + public var hasSomeBytes: Bool {self._someBytes != nil} + /// Clears the value of `someBytes`. Subsequent reads from it will return its default value. + public mutating func clearSomeBytes() {self._someBytes = nil} + + public var extStr: String { + get {_extStr ?? String()} + set {_extStr = newValue} + } + /// Returns true if `extStr` has been explicitly set. + public var hasExtStr: Bool {self._extStr != nil} + /// Clears the value of `extStr`. Subsequent reads from it will return its default value. + public mutating func clearExtStr() {self._extStr = nil} + + public var unknownFields = SwiftProtobuf.UnknownStorage() + + public init() {} + + fileprivate var _someBytes: Data? = nil + fileprivate var _extStr: String? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension SomeProtoWithBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = "SomeProtoWithBytes" + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{2}someBytes\0\u{4}b\u{1}ext_str\0") + + public 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 2: try { try decoder.decodeSingularBytesField(value: &self._someBytes) }() + case 100: try { try decoder.decodeSingularStringField(value: &self._extStr) }() + default: break + } + } + } + + public 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 + try { if let v = self._someBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 2) + } }() + try { if let v = self._extStr { + try visitor.visitSingularStringField(value: v, fieldNumber: 100) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: SomeProtoWithBytes, rhs: SomeProtoWithBytes) -> Bool { + if lhs._someBytes != rhs._someBytes {return false} + if lhs._extStr != rhs._extStr {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/CompileTests/MultiModule/Sources/ImportsAPublicly/imports_a_publicly.pb.swift b/Reference/CompileTests/MultiModule/Sources/ImportsAPublicly/imports_a_publicly.pb.swift new file mode 100644 index 000000000..9804820f7 --- /dev/null +++ b/Reference/CompileTests/MultiModule/Sources/ImportsAPublicly/imports_a_publicly.pb.swift @@ -0,0 +1,103 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: Sources/ImportsAPublicly/imports_a_publicly.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +import SwiftProtobuf + +// Use of 'import public' causes re-exports: +@_exported import enum ModuleA.E +@_exported import let ModuleA.Extensions_ext_str +@_exported import struct ModuleA.A + +// 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 +} + +public struct ImportsAPublicly: Sendable { + // 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. + + public var a: ModuleA.A { + get {_a ?? ModuleA.A()} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + public var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + public mutating func clearA() {self._a = nil} + + public var e: ModuleA.E { + get {_e ?? .unset} + set {_e = newValue} + } + /// Returns true if `e` has been explicitly set. + public var hasE: Bool {self._e != nil} + /// Clears the value of `e`. Subsequent reads from it will return its default value. + public mutating func clearE() {self._e = nil} + + public var unknownFields = SwiftProtobuf.UnknownStorage() + + public init() {} + + fileprivate var _a: ModuleA.A? = nil + fileprivate var _e: ModuleA.E? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension ImportsAPublicly: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = "ImportsAPublicly" + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{b}a\0\u{1}e\0") + + public var isInitialized: Bool { + if let v = self._a, !v.isInitialized {return false} + return true + } + + public 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 11: try { try decoder.decodeSingularMessageField(value: &self._a) }() + case 12: try { try decoder.decodeSingularEnumField(value: &self._e) }() + default: break + } + } + } + + public 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 + try { if let v = self._a { + try visitor.visitSingularMessageField(value: v, fieldNumber: 11) + } }() + try { if let v = self._e { + try visitor.visitSingularEnumField(value: v, fieldNumber: 12) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: ImportsAPublicly, rhs: ImportsAPublicly) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._e != rhs._e {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/CompileTests/MultiModule/Sources/ImportsImportsAPublicly/imports_imports_a_publicly.pb.swift b/Reference/CompileTests/MultiModule/Sources/ImportsImportsAPublicly/imports_imports_a_publicly.pb.swift new file mode 100644 index 000000000..7eca48637 --- /dev/null +++ b/Reference/CompileTests/MultiModule/Sources/ImportsImportsAPublicly/imports_imports_a_publicly.pb.swift @@ -0,0 +1,104 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: Sources/ImportsImportsAPublicly/imports_imports_a_publicly.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +import SwiftProtobuf + +// Use of 'import public' causes re-exports: +@_exported import enum ModuleA.E +@_exported import let ModuleA.Extensions_ext_str +@_exported import struct ImportsAPublicly.ImportsAPublicly +@_exported import struct ModuleA.A + +// 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 +} + +public struct ImportsImportsAPublicly: Sendable { + // 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. + + public var a: ModuleA.A { + get {_a ?? ModuleA.A()} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + public var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + public mutating func clearA() {self._a = nil} + + public var e: ModuleA.E { + get {_e ?? .unset} + set {_e = newValue} + } + /// Returns true if `e` has been explicitly set. + public var hasE: Bool {self._e != nil} + /// Clears the value of `e`. Subsequent reads from it will return its default value. + public mutating func clearE() {self._e = nil} + + public var unknownFields = SwiftProtobuf.UnknownStorage() + + public init() {} + + fileprivate var _a: ModuleA.A? = nil + fileprivate var _e: ModuleA.E? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension ImportsImportsAPublicly: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = "ImportsImportsAPublicly" + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{15}a\0\u{1}e\0") + + public var isInitialized: Bool { + if let v = self._a, !v.isInitialized {return false} + return true + } + + public 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 21: try { try decoder.decodeSingularMessageField(value: &self._a) }() + case 22: try { try decoder.decodeSingularEnumField(value: &self._e) }() + default: break + } + } + } + + public 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 + try { if let v = self._a { + try visitor.visitSingularMessageField(value: v, fieldNumber: 21) + } }() + try { if let v = self._e { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: ImportsImportsAPublicly, rhs: ImportsImportsAPublicly) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._e != rhs._e {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/CompileTests/MultiModule/Sources/ModuleA/a.pb.swift b/Reference/CompileTests/MultiModule/Sources/ModuleA/a.pb.swift new file mode 100644 index 000000000..a25937f57 --- /dev/null +++ b/Reference/CompileTests/MultiModule/Sources/ModuleA/a.pb.swift @@ -0,0 +1,150 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: Sources/ModuleA/a.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +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 +} + +public enum E: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unset = 0 + case a = 1 + case b = 2 + + public init() { + self = .unset + } + +} + +public struct A: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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. + + public var e: E { + get {_e ?? .unset} + set {_e = newValue} + } + /// Returns true if `e` has been explicitly set. + public var hasE: Bool {self._e != nil} + /// Clears the value of `e`. Subsequent reads from it will return its default value. + public mutating func clearE() {self._e = nil} + + public var unknownFields = SwiftProtobuf.UnknownStorage() + + public init() {} + + public var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _e: E? = nil +} + +// MARK: - Extension support defined in a.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 A { + + public var extStr: String { + get {return getExtensionValue(ext: Extensions_ext_str) ?? String()} + set {setExtensionValue(ext: Extensions_ext_str, value: newValue)} + } + /// Returns true if extension `Extensions_ext_str` + /// has been explicitly set. + public var hasExtStr: Bool { + return hasExtensionValue(ext: Extensions_ext_str) + } + /// Clears the value of extension `Extensions_ext_str`. + /// Subsequent reads from it will return its default value. + public mutating func clearExtStr() { + clearExtensionValue(ext: Extensions_ext_str) + } + +} + +// MARK: - File's ExtensionMap: A_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`. +public let A_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Extensions_ext_str +] + +// 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. + +public let Extensions_ext_str = SwiftProtobuf.MessageExtension, A>( + _protobuf_fieldNumber: 100, + fieldName: "ext_str" +) + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension E: SwiftProtobuf._ProtoNameProviding { + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0E_UNSET\0\u{1}E_A\0\u{1}E_B\0") +} + +extension A: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = "A" + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}e\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + public 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._e) }() + case 100..<1001: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: A.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + + public 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 + try { if let v = self._e { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 100, end: 1001) + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: A, rhs: A) -> Bool { + if lhs._e != rhs._e {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} diff --git a/Reference/CompileTests/MultiModule/Sources/ReExportAOnly/reexport_a_only.pb.swift b/Reference/CompileTests/MultiModule/Sources/ReExportAOnly/reexport_a_only.pb.swift new file mode 100644 index 000000000..907b20296 --- /dev/null +++ b/Reference/CompileTests/MultiModule/Sources/ReExportAOnly/reexport_a_only.pb.swift @@ -0,0 +1,16 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: Sources/ReExportAOnly/reexport_a_only.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Use of 'import public' causes re-exports: +@_exported import enum ModuleA.E +@_exported import let ModuleA.Extensions_ext_str +@_exported import struct ModuleA.A + +// This file contained no messages, enums, or extensions. diff --git a/Reference/CompileTests/MultiModule/Tests/Test1/uses_a_transitively.pb.swift b/Reference/CompileTests/MultiModule/Tests/Test1/uses_a_transitively.pb.swift new file mode 100644 index 000000000..36563c266 --- /dev/null +++ b/Reference/CompileTests/MultiModule/Tests/Test1/uses_a_transitively.pb.swift @@ -0,0 +1,100 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: Tests/Test1/uses_a_transitively.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +import SwiftProtobuf + +import ImportsAPublicly + +// 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 +} + +public struct UsesATransitively: Sendable { + // 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. + + public var a: ModuleA.A { + get {_a ?? ModuleA.A()} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + public var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + public mutating func clearA() {self._a = nil} + + public var e: ModuleA.E { + get {_e ?? .unset} + set {_e = newValue} + } + /// Returns true if `e` has been explicitly set. + public var hasE: Bool {self._e != nil} + /// Clears the value of `e`. Subsequent reads from it will return its default value. + public mutating func clearE() {self._e = nil} + + public var unknownFields = SwiftProtobuf.UnknownStorage() + + public init() {} + + fileprivate var _a: ModuleA.A? = nil + fileprivate var _e: ModuleA.E? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension UsesATransitively: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = "UsesATransitively" + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}e\u{1}a\0\u{1}e\0") + + public var isInitialized: Bool { + if let v = self._a, !v.isInitialized {return false} + return true + } + + public 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 101: try { try decoder.decodeSingularMessageField(value: &self._a) }() + case 102: try { try decoder.decodeSingularEnumField(value: &self._e) }() + default: break + } + } + } + + public 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 + try { if let v = self._a { + try visitor.visitSingularMessageField(value: v, fieldNumber: 101) + } }() + try { if let v = self._e { + try visitor.visitSingularEnumField(value: v, fieldNumber: 102) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: UsesATransitively, rhs: UsesATransitively) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._e != rhs._e {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/CompileTests/MultiModule/Tests/Test2/uses_a_transitively2.pb.swift b/Reference/CompileTests/MultiModule/Tests/Test2/uses_a_transitively2.pb.swift new file mode 100644 index 000000000..c9dad2c68 --- /dev/null +++ b/Reference/CompileTests/MultiModule/Tests/Test2/uses_a_transitively2.pb.swift @@ -0,0 +1,100 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: Tests/Test2/uses_a_transitively2.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +import SwiftProtobuf + +import ImportsImportsAPublicly + +// 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 +} + +public struct UsesATransitively2: Sendable { + // 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. + + public var a: ModuleA.A { + get {_a ?? ModuleA.A()} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + public var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + public mutating func clearA() {self._a = nil} + + public var e: ModuleA.E { + get {_e ?? .unset} + set {_e = newValue} + } + /// Returns true if `e` has been explicitly set. + public var hasE: Bool {self._e != nil} + /// Clears the value of `e`. Subsequent reads from it will return its default value. + public mutating func clearE() {self._e = nil} + + public var unknownFields = SwiftProtobuf.UnknownStorage() + + public init() {} + + fileprivate var _a: ModuleA.A? = nil + fileprivate var _e: ModuleA.E? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension UsesATransitively2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + public static let protoMessageName: String = "UsesATransitively2" + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}o\u{1}a\0\u{2}\u{b}e\0") + + public var isInitialized: Bool { + if let v = self._a, !v.isInitialized {return false} + return true + } + + public 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 111: try { try decoder.decodeSingularMessageField(value: &self._a) }() + case 122: try { try decoder.decodeSingularEnumField(value: &self._e) }() + default: break + } + } + } + + public 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 + try { if let v = self._a { + try visitor.visitSingularMessageField(value: v, fieldNumber: 111) + } }() + try { if let v = self._e { + try visitor.visitSingularEnumField(value: v, fieldNumber: 122) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: UsesATransitively2, rhs: UsesATransitively2) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._e != rhs._e {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/conformance/conformance.pb.swift b/Reference/Sources/Conformance/conformance/conformance.pb.swift similarity index 73% rename from Reference/conformance/conformance.pb.swift rename to Reference/Sources/Conformance/conformance/conformance.pb.swift index d19d0cca6..d1e311190 100644 --- a/Reference/conformance/conformance.pb.swift +++ b/Reference/Sources/Conformance/conformance/conformance.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: conformance/conformance.proto @@ -9,33 +10,10 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd import Foundation import SwiftProtobuf @@ -50,13 +28,13 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum Conformance_WireFormat: SwiftProtobuf.Enum { +enum Conformance_WireFormat: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case unspecified // = 0 case protobuf // = 1 case json // = 2 - /// Google internal only. Opensource testees just skip it. + /// Only used inside Google. Opensource testees just skip it. case jspb // = 3 case textFormat // = 4 case UNRECOGNIZED(Int) @@ -87,24 +65,18 @@ enum Conformance_WireFormat: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension Conformance_WireFormat: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Conformance_WireFormat] = [ + static let allCases: [Conformance_WireFormat] = [ .unspecified, .protobuf, .json, .jspb, .textFormat, ] -} -#endif // swift(>=4.2) +} -enum Conformance_TestCategory: SwiftProtobuf.Enum { +enum Conformance_TestCategory: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case unspecifiedTest // = 0 @@ -121,7 +93,8 @@ enum Conformance_TestCategory: SwiftProtobuf.Enum { /// for more detail. case jsonIgnoreUnknownParsingTest // = 3 - /// Test jspb wire format. Google internal only. Opensource testees just skip it. + /// Test jspb wire format. Only used inside Google. Opensource testees just + /// skip it. case jspbTest // = 4 /// Test text format. For cpp, java and python, testees can already deal with @@ -157,13 +130,8 @@ enum Conformance_TestCategory: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension Conformance_TestCategory: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Conformance_TestCategory] = [ + static let allCases: [Conformance_TestCategory] = [ .unspecifiedTest, .binaryTest, .jsonTest, @@ -171,19 +139,39 @@ extension Conformance_TestCategory: CaseIterable { .jspbTest, .textFormatTest, ] + } -#endif // swift(>=4.2) +/// Meant to encapsulate all types of tests: successes, skips, failures, etc. +/// Therefore, this may or may not have a failure message. Failure messages +/// may be truncated for our failure lists. +struct Conformance_TestStatus: Sendable { + // 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 name: String = String() + + var failureMessage: String = String() + + /// What an actual test name matched to in a failure list. Can be wildcarded or + /// an exact match without wildcards. + var matchedName: String = String() + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} /// The conformance runner will request a list of failures as the first request. /// This will be known by message_type == "conformance.FailureSet", a conformance /// test should return a serialized FailureSet in protobuf_payload. -struct Conformance_FailureSet { +struct Conformance_FailureSet: Sendable { // 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 failure: [String] = [] + var test: [Conformance_TestStatus] = [] var unknownFields = SwiftProtobuf.UnknownStorage() @@ -195,7 +183,7 @@ struct Conformance_FailureSet { /// 1. parse this proto (which should always succeed) /// 2. parse the protobuf or JSON payload in "payload" (which may fail) /// 3. if the parse succeeded, serialize the message in the requested format. -struct Conformance_ConformanceRequest { +struct Conformance_ConformanceRequest: Sendable { // 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. @@ -203,10 +191,6 @@ struct Conformance_ConformanceRequest { /// The payload (whether protobuf of JSON) is always for a /// protobuf_test_messages.proto3.TestAllTypes proto (as defined in /// src/google/protobuf/proto3_test_messages.proto). - /// - /// TODO(haberman): if/when we expand the conformance tests to support proto2, - /// we will want to include a field that lets the payload/response be a - /// protobuf_test_messages.google.protobuf.TestAllTypes message instead. var payload: Conformance_ConformanceRequest.OneOf_Payload? = nil var protobufPayload: Data { @@ -225,7 +209,7 @@ struct Conformance_ConformanceRequest { set {payload = .jsonPayload(newValue)} } - /// Google internal only. Opensource testees just skip it. + /// Only used inside Google. Opensource testees just skip it. var jspbPayload: String { get { if case .jspbPayload(let v)? = payload {return v} @@ -247,21 +231,24 @@ struct Conformance_ConformanceRequest { /// The full name for the test message to use; for the moment, either: /// protobuf_test_messages.proto3.TestAllTypesProto3 or - /// protobuf_test_messages.google.protobuf.TestAllTypesProto2. + /// protobuf_test_messages.proto2.TestAllTypesProto2 or + /// protobuf_test_messages.editions.proto2.TestAllTypesProto2 or + /// protobuf_test_messages.editions.proto3.TestAllTypesProto3 or + /// protobuf_test_messages.editions.TestAllTypesEdition2023. var messageType: String = String() /// Each test is given a specific test category. Some category may need - /// specific support in testee programs. Refer to the definition of TestCategory - /// for more information. + /// specific support in testee programs. Refer to the definition of + /// TestCategory for more information. var testCategory: Conformance_TestCategory = .unspecifiedTest /// Specify details for how to encode jspb. var jspbEncodingOptions: Conformance_JspbEncodingConfig { - get {return _jspbEncodingOptions ?? Conformance_JspbEncodingConfig()} + get {_jspbEncodingOptions ?? Conformance_JspbEncodingConfig()} set {_jspbEncodingOptions = newValue} } /// Returns true if `jspbEncodingOptions` has been explicitly set. - var hasJspbEncodingOptions: Bool {return self._jspbEncodingOptions != nil} + var hasJspbEncodingOptions: Bool {self._jspbEncodingOptions != nil} /// Clears the value of `jspbEncodingOptions`. Subsequent reads from it will return its default value. mutating func clearJspbEncodingOptions() {self._jspbEncodingOptions = nil} @@ -274,43 +261,13 @@ struct Conformance_ConformanceRequest { /// The payload (whether protobuf of JSON) is always for a /// protobuf_test_messages.proto3.TestAllTypes proto (as defined in /// src/google/protobuf/proto3_test_messages.proto). - /// - /// TODO(haberman): if/when we expand the conformance tests to support proto2, - /// we will want to include a field that lets the payload/response be a - /// protobuf_test_messages.google.protobuf.TestAllTypes message instead. - enum OneOf_Payload: Equatable { + enum OneOf_Payload: Equatable, Sendable { case protobufPayload(Data) case jsonPayload(String) - /// Google internal only. Opensource testees just skip it. + /// Only used inside Google. Opensource testees just skip it. case jspbPayload(String) case textPayload(String) - #if !swift(>=4.1) - static func ==(lhs: Conformance_ConformanceRequest.OneOf_Payload, rhs: Conformance_ConformanceRequest.OneOf_Payload) -> 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 (.protobufPayload, .protobufPayload): return { - guard case .protobufPayload(let l) = lhs, case .protobufPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.jsonPayload, .jsonPayload): return { - guard case .jsonPayload(let l) = lhs, case .jsonPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.jspbPayload, .jspbPayload): return { - guard case .jspbPayload(let l) = lhs, case .jspbPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.textPayload, .textPayload): return { - guard case .textPayload(let l) = lhs, case .textPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } init() {} @@ -319,7 +276,7 @@ struct Conformance_ConformanceRequest { } /// Represents a single test case's output. -struct Conformance_ConformanceResponse { +struct Conformance_ConformanceResponse: Sendable { // 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. @@ -350,6 +307,17 @@ struct Conformance_ConformanceResponse { set {result = .serializeError(newValue)} } + /// This should be set if the test program timed out. The string should + /// provide more information about what the child process was doing when it + /// was killed. + var timeoutError: String { + get { + if case .timeoutError(let v)? = result {return v} + return String() + } + set {result = .timeoutError(newValue)} + } + /// This should be set if some other error occurred. This will always /// indicate that the test failed. The string can provide more information /// about the failure. @@ -392,8 +360,8 @@ struct Conformance_ConformanceResponse { } /// If the input was successfully parsed and the requested output was JSPB, - /// serialize to JSPB and set it in this field. JSPB is google internal only - /// format. Opensource testees can just skip it. + /// serialize to JSPB and set it in this field. JSPB is only used inside + /// Google. Opensource testees can just skip it. var jspbPayload: String { get { if case .jspbPayload(let v)? = result {return v} @@ -414,7 +382,7 @@ struct Conformance_ConformanceResponse { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_Result: Equatable { + enum OneOf_Result: Equatable, Sendable { /// This string should be set to indicate parsing failed. The string can /// provide more information about the parse error if it is available. /// @@ -425,6 +393,10 @@ struct Conformance_ConformanceResponse { /// serializing it to the requested output format, set the error message in /// this field. case serializeError(String) + /// This should be set if the test program timed out. The string should + /// provide more information about what the child process was doing when it + /// was killed. + case timeoutError(String) /// This should be set if some other error occurred. This will always /// indicate that the test failed. The string can provide more information /// about the failure. @@ -439,62 +411,20 @@ struct Conformance_ConformanceResponse { /// wasn't supported, like JSON input/output. case skipped(String) /// If the input was successfully parsed and the requested output was JSPB, - /// serialize to JSPB and set it in this field. JSPB is google internal only - /// format. Opensource testees can just skip it. + /// serialize to JSPB and set it in this field. JSPB is only used inside + /// Google. Opensource testees can just skip it. case jspbPayload(String) /// If the input was successfully parsed and the requested output was /// TEXT_FORMAT, serialize to TEXT_FORMAT and set it in this field. case textPayload(String) - #if !swift(>=4.1) - static func ==(lhs: Conformance_ConformanceResponse.OneOf_Result, rhs: Conformance_ConformanceResponse.OneOf_Result) -> 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 (.parseError, .parseError): return { - guard case .parseError(let l) = lhs, case .parseError(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.serializeError, .serializeError): return { - guard case .serializeError(let l) = lhs, case .serializeError(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.runtimeError, .runtimeError): return { - guard case .runtimeError(let l) = lhs, case .runtimeError(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.protobufPayload, .protobufPayload): return { - guard case .protobufPayload(let l) = lhs, case .protobufPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.jsonPayload, .jsonPayload): return { - guard case .jsonPayload(let l) = lhs, case .jsonPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.skipped, .skipped): return { - guard case .skipped(let l) = lhs, case .skipped(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.jspbPayload, .jspbPayload): return { - guard case .jspbPayload(let l) = lhs, case .jspbPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.textPayload, .textPayload): return { - guard case .textPayload(let l) = lhs, case .textPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } init() {} } /// Encoding options for jspb format. -struct Conformance_JspbEncodingConfig { +struct Conformance_JspbEncodingConfig: Sendable { // 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. @@ -507,47 +437,61 @@ struct Conformance_JspbEncodingConfig { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Conformance_WireFormat: @unchecked Sendable {} -extension Conformance_TestCategory: @unchecked Sendable {} -extension Conformance_FailureSet: @unchecked Sendable {} -extension Conformance_ConformanceRequest: @unchecked Sendable {} -extension Conformance_ConformanceRequest.OneOf_Payload: @unchecked Sendable {} -extension Conformance_ConformanceResponse: @unchecked Sendable {} -extension Conformance_ConformanceResponse.OneOf_Result: @unchecked Sendable {} -extension Conformance_JspbEncodingConfig: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "conformance" extension Conformance_WireFormat: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "UNSPECIFIED"), - 1: .same(proto: "PROTOBUF"), - 2: .same(proto: "JSON"), - 3: .same(proto: "JSPB"), - 4: .same(proto: "TEXT_FORMAT"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNSPECIFIED\0\u{1}PROTOBUF\0\u{1}JSON\0\u{1}JSPB\0\u{1}TEXT_FORMAT\0") } extension Conformance_TestCategory: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "UNSPECIFIED_TEST"), - 1: .same(proto: "BINARY_TEST"), - 2: .same(proto: "JSON_TEST"), - 3: .same(proto: "JSON_IGNORE_UNKNOWN_PARSING_TEST"), - 4: .same(proto: "JSPB_TEST"), - 5: .same(proto: "TEXT_FORMAT_TEST"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNSPECIFIED_TEST\0\u{1}BINARY_TEST\0\u{1}JSON_TEST\0\u{1}JSON_IGNORE_UNKNOWN_PARSING_TEST\0\u{1}JSPB_TEST\0\u{1}TEXT_FORMAT_TEST\0") +} + +extension Conformance_TestStatus: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestStatus" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}name\0\u{3}failure_message\0\u{3}matched_name\0") + + 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.name) }() + case 2: try { try decoder.decodeSingularStringField(value: &self.failureMessage) }() + case 3: try { try decoder.decodeSingularStringField(value: &self.matchedName) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.name.isEmpty { + try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) + } + if !self.failureMessage.isEmpty { + try visitor.visitSingularStringField(value: self.failureMessage, fieldNumber: 2) + } + if !self.matchedName.isEmpty { + try visitor.visitSingularStringField(value: self.matchedName, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Conformance_TestStatus, rhs: Conformance_TestStatus) -> Bool { + if lhs.name != rhs.name {return false} + if lhs.failureMessage != rhs.failureMessage {return false} + if lhs.matchedName != rhs.matchedName {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } } extension Conformance_FailureSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".FailureSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "failure"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{2}test\0\u{c}\u{1}\u{1}") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -555,21 +499,21 @@ extension Conformance_FailureSet: SwiftProtobuf.Message, SwiftProtobuf._MessageI // 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.decodeRepeatedStringField(value: &self.failure) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.test) }() default: break } } } func traverse(visitor: inout V) throws { - if !self.failure.isEmpty { - try visitor.visitRepeatedStringField(value: self.failure, fieldNumber: 1) + if !self.test.isEmpty { + try visitor.visitRepeatedMessageField(value: self.test, fieldNumber: 2) } try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Conformance_FailureSet, rhs: Conformance_FailureSet) -> Bool { - if lhs.failure != rhs.failure {return false} + if lhs.test != rhs.test {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } @@ -577,17 +521,7 @@ extension Conformance_FailureSet: SwiftProtobuf.Message, SwiftProtobuf._MessageI extension Conformance_ConformanceRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ConformanceRequest" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "protobuf_payload"), - 2: .standard(proto: "json_payload"), - 7: .standard(proto: "jspb_payload"), - 8: .standard(proto: "text_payload"), - 3: .standard(proto: "requested_output_format"), - 4: .standard(proto: "message_type"), - 5: .standard(proto: "test_category"), - 6: .standard(proto: "jspb_encoding_options"), - 9: .standard(proto: "print_unknown_fields"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}protobuf_payload\0\u{3}json_payload\0\u{3}requested_output_format\0\u{3}message_type\0\u{3}test_category\0\u{3}jspb_encoding_options\0\u{3}jspb_payload\0\u{3}text_payload\0\u{3}print_unknown_fields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -696,16 +630,7 @@ extension Conformance_ConformanceRequest: SwiftProtobuf.Message, SwiftProtobuf._ extension Conformance_ConformanceResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ConformanceResponse" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "parse_error"), - 6: .standard(proto: "serialize_error"), - 2: .standard(proto: "runtime_error"), - 3: .standard(proto: "protobuf_payload"), - 4: .standard(proto: "json_payload"), - 5: .same(proto: "skipped"), - 7: .standard(proto: "jspb_payload"), - 8: .standard(proto: "text_payload"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}parse_error\0\u{3}runtime_error\0\u{3}protobuf_payload\0\u{3}json_payload\0\u{1}skipped\0\u{3}serialize_error\0\u{3}jspb_payload\0\u{3}text_payload\0\u{3}timeout_error\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -777,6 +702,14 @@ extension Conformance_ConformanceResponse: SwiftProtobuf.Message, SwiftProtobuf. self.result = .textPayload(v) } }() + case 9: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.result != nil {try decoder.handleConflictingOneOf()} + self.result = .timeoutError(v) + } + }() default: break } } @@ -820,6 +753,10 @@ extension Conformance_ConformanceResponse: SwiftProtobuf.Message, SwiftProtobuf. guard case .textPayload(let v)? = self.result else { preconditionFailure() } try visitor.visitSingularStringField(value: v, fieldNumber: 8) }() + case .timeoutError?: try { + guard case .timeoutError(let v)? = self.result else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 9) + }() case nil: break } try unknownFields.traverse(visitor: &visitor) @@ -834,9 +771,7 @@ extension Conformance_ConformanceResponse: SwiftProtobuf.Message, SwiftProtobuf. extension Conformance_JspbEncodingConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".JspbEncodingConfig" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "use_jspb_array_any_format"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}use_jspb_array_any_format\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { diff --git a/Reference/google/protobuf/test_messages_proto2.pb.swift b/Reference/Sources/Conformance/conformance/test_protos/test_messages_edition2023.pb.swift similarity index 55% rename from Reference/google/protobuf/test_messages_proto2.pb.swift rename to Reference/Sources/Conformance/conformance/test_protos/test_messages_edition2023.pb.swift index 0ca42f176..e9601952b 100644 --- a/Reference/google/protobuf/test_messages_proto2.pb.swift +++ b/Reference/Sources/Conformance/conformance/test_protos/test_messages_edition2023.pb.swift @@ -1,47 +1,19 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/test_messages_proto2.proto +// Source: conformance/test_protos/test_messages_edition2023.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ // Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ +// Copyright 2024 Google Inc. All rights reserved. // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// -// Test schema for proto2 messages. This test schema is used by: -// -// - conformance tests - -// LINT: ALLOW_GROUPS +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd import Foundation import SwiftProtobuf @@ -56,11 +28,12 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum ProtobufTestMessages_Proto2_ForeignEnumProto2: SwiftProtobuf.Enum { +enum ProtobufTestMessages_Editions_ForeignEnumEdition2023: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foreignFoo // = 0 case foreignBar // = 1 case foreignBaz // = 2 + case UNRECOGNIZED(Int) init() { self = .foreignFoo @@ -71,7 +44,7 @@ enum ProtobufTestMessages_Proto2_ForeignEnumProto2: SwiftProtobuf.Enum { case 0: self = .foreignFoo case 1: self = .foreignBar case 2: self = .foreignBaz - default: return nil + default: self = .UNRECOGNIZED(rawValue) } } @@ -80,571 +53,585 @@ enum ProtobufTestMessages_Proto2_ForeignEnumProto2: SwiftProtobuf.Enum { case .foreignFoo: return 0 case .foreignBar: return 1 case .foreignBaz: return 2 + case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Editions_ForeignEnumEdition2023] = [ + .foreignFoo, + .foreignBar, + .foreignBaz, + ] + } -#if swift(>=4.2) +struct ProtobufTestMessages_Editions_ComplexMessage: Sendable { + // 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. -extension ProtobufTestMessages_Proto2_ForeignEnumProto2: CaseIterable { - // Support synthesized by the compiler. -} + var d: Int32 { + get {_d ?? 0} + set {_d = newValue} + } + /// Returns true if `d` has been explicitly set. + var hasD: Bool {self._d != nil} + /// Clears the value of `d`. Subsequent reads from it will return its default value. + mutating func clearD() {self._d = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() -#endif // swift(>=4.2) + init() {} + + fileprivate var _d: Int32? = nil +} -/// This proto includes every type of field in both singular and repeated -/// forms. -/// -/// Also, crucially, all messages and enums in this file are eventually -/// submessages of this message. So for example, a fuzz test of TestAllTypes -/// could trigger bugs that occur in any message type in this file. We verify -/// this stays true in a unit test. -struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleMessage { +struct ProtobufTestMessages_Editions_TestAllTypesEdition2023: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { // 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. /// Singular var optionalInt32: Int32 { - get {return _storage._optionalInt32 ?? 0} + get {_storage._optionalInt32 ?? 0} set {_uniqueStorage()._optionalInt32 = newValue} } /// Returns true if `optionalInt32` has been explicitly set. - var hasOptionalInt32: Bool {return _storage._optionalInt32 != nil} + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} var optionalInt64: Int64 { - get {return _storage._optionalInt64 ?? 0} + get {_storage._optionalInt64 ?? 0} set {_uniqueStorage()._optionalInt64 = newValue} } /// Returns true if `optionalInt64` has been explicitly set. - var hasOptionalInt64: Bool {return _storage._optionalInt64 != nil} + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} var optionalUint32: UInt32 { - get {return _storage._optionalUint32 ?? 0} + get {_storage._optionalUint32 ?? 0} set {_uniqueStorage()._optionalUint32 = newValue} } /// Returns true if `optionalUint32` has been explicitly set. - var hasOptionalUint32: Bool {return _storage._optionalUint32 != nil} + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} var optionalUint64: UInt64 { - get {return _storage._optionalUint64 ?? 0} + get {_storage._optionalUint64 ?? 0} set {_uniqueStorage()._optionalUint64 = newValue} } /// Returns true if `optionalUint64` has been explicitly set. - var hasOptionalUint64: Bool {return _storage._optionalUint64 != nil} + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} var optionalSint32: Int32 { - get {return _storage._optionalSint32 ?? 0} + get {_storage._optionalSint32 ?? 0} set {_uniqueStorage()._optionalSint32 = newValue} } /// Returns true if `optionalSint32` has been explicitly set. - var hasOptionalSint32: Bool {return _storage._optionalSint32 != nil} + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} var optionalSint64: Int64 { - get {return _storage._optionalSint64 ?? 0} + get {_storage._optionalSint64 ?? 0} set {_uniqueStorage()._optionalSint64 = newValue} } /// Returns true if `optionalSint64` has been explicitly set. - var hasOptionalSint64: Bool {return _storage._optionalSint64 != nil} + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32 ?? 0} + get {_storage._optionalFixed32 ?? 0} set {_uniqueStorage()._optionalFixed32 = newValue} } /// Returns true if `optionalFixed32` has been explicitly set. - var hasOptionalFixed32: Bool {return _storage._optionalFixed32 != nil} + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64 ?? 0} + get {_storage._optionalFixed64 ?? 0} set {_uniqueStorage()._optionalFixed64 = newValue} } /// Returns true if `optionalFixed64` has been explicitly set. - var hasOptionalFixed64: Bool {return _storage._optionalFixed64 != nil} + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32 ?? 0} + get {_storage._optionalSfixed32 ?? 0} set {_uniqueStorage()._optionalSfixed32 = newValue} } /// Returns true if `optionalSfixed32` has been explicitly set. - var hasOptionalSfixed32: Bool {return _storage._optionalSfixed32 != nil} + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64 ?? 0} + get {_storage._optionalSfixed64 ?? 0} set {_uniqueStorage()._optionalSfixed64 = newValue} } /// Returns true if `optionalSfixed64` has been explicitly set. - var hasOptionalSfixed64: Bool {return _storage._optionalSfixed64 != nil} + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} var optionalFloat: Float { - get {return _storage._optionalFloat ?? 0} + get {_storage._optionalFloat ?? 0} set {_uniqueStorage()._optionalFloat = newValue} } /// Returns true if `optionalFloat` has been explicitly set. - var hasOptionalFloat: Bool {return _storage._optionalFloat != nil} + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} var optionalDouble: Double { - get {return _storage._optionalDouble ?? 0} + get {_storage._optionalDouble ?? 0} set {_uniqueStorage()._optionalDouble = newValue} } /// Returns true if `optionalDouble` has been explicitly set. - var hasOptionalDouble: Bool {return _storage._optionalDouble != nil} + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} var optionalBool: Bool { - get {return _storage._optionalBool ?? false} + get {_storage._optionalBool ?? false} set {_uniqueStorage()._optionalBool = newValue} } /// Returns true if `optionalBool` has been explicitly set. - var hasOptionalBool: Bool {return _storage._optionalBool != nil} + var hasOptionalBool: Bool {_storage._optionalBool != nil} /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} var optionalString: String { - get {return _storage._optionalString ?? String()} + get {_storage._optionalString ?? String()} set {_uniqueStorage()._optionalString = newValue} } /// Returns true if `optionalString` has been explicitly set. - var hasOptionalString: Bool {return _storage._optionalString != nil} + var hasOptionalString: Bool {_storage._optionalString != nil} /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} var optionalBytes: Data { - get {return _storage._optionalBytes ?? Data()} + get {_storage._optionalBytes ?? Data()} set {_uniqueStorage()._optionalBytes = newValue} } /// Returns true if `optionalBytes` has been explicitly set. - var hasOptionalBytes: Bool {return _storage._optionalBytes != nil} + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} - var optionalNestedMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage { - get {return _storage._optionalNestedMessage ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage()} + var optionalNestedMessage: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage { + get {_storage._optionalNestedMessage ?? ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage()} set {_uniqueStorage()._optionalNestedMessage = newValue} } /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} - var optionalForeignMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2 { - get {return _storage._optionalForeignMessage ?? ProtobufTestMessages_Proto2_ForeignMessageProto2()} + var optionalForeignMessage: ProtobufTestMessages_Editions_ForeignMessageEdition2023 { + get {_storage._optionalForeignMessage ?? ProtobufTestMessages_Editions_ForeignMessageEdition2023()} set {_uniqueStorage()._optionalForeignMessage = newValue} } /// Returns true if `optionalForeignMessage` has been explicitly set. - var hasOptionalForeignMessage: Bool {return _storage._optionalForeignMessage != nil} + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} - var optionalNestedEnum: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum { - get {return _storage._optionalNestedEnum ?? .foo} + var optionalNestedEnum: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum { + get {_storage._optionalNestedEnum ?? .foo} set {_uniqueStorage()._optionalNestedEnum = newValue} } /// Returns true if `optionalNestedEnum` has been explicitly set. - var hasOptionalNestedEnum: Bool {return _storage._optionalNestedEnum != nil} + var hasOptionalNestedEnum: Bool {_storage._optionalNestedEnum != nil} /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} - var optionalForeignEnum: ProtobufTestMessages_Proto2_ForeignEnumProto2 { - get {return _storage._optionalForeignEnum ?? .foreignFoo} + var optionalForeignEnum: ProtobufTestMessages_Editions_ForeignEnumEdition2023 { + get {_storage._optionalForeignEnum ?? .foreignFoo} set {_uniqueStorage()._optionalForeignEnum = newValue} } /// Returns true if `optionalForeignEnum` has been explicitly set. - var hasOptionalForeignEnum: Bool {return _storage._optionalForeignEnum != nil} + var hasOptionalForeignEnum: Bool {_storage._optionalForeignEnum != nil} /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. mutating func clearOptionalForeignEnum() {_uniqueStorage()._optionalForeignEnum = nil} var optionalStringPiece: String { - get {return _storage._optionalStringPiece ?? String()} + get {_storage._optionalStringPiece ?? String()} set {_uniqueStorage()._optionalStringPiece = newValue} } /// Returns true if `optionalStringPiece` has been explicitly set. - var hasOptionalStringPiece: Bool {return _storage._optionalStringPiece != nil} + var hasOptionalStringPiece: Bool {_storage._optionalStringPiece != nil} /// Clears the value of `optionalStringPiece`. Subsequent reads from it will return its default value. mutating func clearOptionalStringPiece() {_uniqueStorage()._optionalStringPiece = nil} var optionalCord: String { - get {return _storage._optionalCord ?? String()} + get {_storage._optionalCord ?? String()} set {_uniqueStorage()._optionalCord = newValue} } /// Returns true if `optionalCord` has been explicitly set. - var hasOptionalCord: Bool {return _storage._optionalCord != nil} + var hasOptionalCord: Bool {_storage._optionalCord != nil} /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} - var recursiveMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2 { - get {return _storage._recursiveMessage ?? ProtobufTestMessages_Proto2_TestAllTypesProto2()} + var recursiveMessage: ProtobufTestMessages_Editions_TestAllTypesEdition2023 { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Editions_TestAllTypesEdition2023()} set {_uniqueStorage()._recursiveMessage = newValue} } /// Returns true if `recursiveMessage` has been explicitly set. - var hasRecursiveMessage: Bool {return _storage._recursiveMessage != nil} + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} /// Repeated var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } - var repeatedNestedMessage: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage] { - get {return _storage._repeatedNestedMessage} + var repeatedNestedMessage: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage] { + get {_storage._repeatedNestedMessage} set {_uniqueStorage()._repeatedNestedMessage = newValue} } - var repeatedForeignMessage: [ProtobufTestMessages_Proto2_ForeignMessageProto2] { - get {return _storage._repeatedForeignMessage} + var repeatedForeignMessage: [ProtobufTestMessages_Editions_ForeignMessageEdition2023] { + get {_storage._repeatedForeignMessage} set {_uniqueStorage()._repeatedForeignMessage = newValue} } - var repeatedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] { - get {return _storage._repeatedNestedEnum} + var repeatedNestedEnum: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] { + get {_storage._repeatedNestedEnum} set {_uniqueStorage()._repeatedNestedEnum = newValue} } - var repeatedForeignEnum: [ProtobufTestMessages_Proto2_ForeignEnumProto2] { - get {return _storage._repeatedForeignEnum} + var repeatedForeignEnum: [ProtobufTestMessages_Editions_ForeignEnumEdition2023] { + get {_storage._repeatedForeignEnum} set {_uniqueStorage()._repeatedForeignEnum = newValue} } var repeatedStringPiece: [String] { - get {return _storage._repeatedStringPiece} + get {_storage._repeatedStringPiece} set {_uniqueStorage()._repeatedStringPiece = newValue} } var repeatedCord: [String] { - get {return _storage._repeatedCord} + get {_storage._repeatedCord} set {_uniqueStorage()._repeatedCord = newValue} } /// Packed var packedInt32: [Int32] { - get {return _storage._packedInt32} + get {_storage._packedInt32} set {_uniqueStorage()._packedInt32 = newValue} } var packedInt64: [Int64] { - get {return _storage._packedInt64} + get {_storage._packedInt64} set {_uniqueStorage()._packedInt64 = newValue} } var packedUint32: [UInt32] { - get {return _storage._packedUint32} + get {_storage._packedUint32} set {_uniqueStorage()._packedUint32 = newValue} } var packedUint64: [UInt64] { - get {return _storage._packedUint64} + get {_storage._packedUint64} set {_uniqueStorage()._packedUint64 = newValue} } var packedSint32: [Int32] { - get {return _storage._packedSint32} + get {_storage._packedSint32} set {_uniqueStorage()._packedSint32 = newValue} } var packedSint64: [Int64] { - get {return _storage._packedSint64} + get {_storage._packedSint64} set {_uniqueStorage()._packedSint64 = newValue} } var packedFixed32: [UInt32] { - get {return _storage._packedFixed32} + get {_storage._packedFixed32} set {_uniqueStorage()._packedFixed32 = newValue} } var packedFixed64: [UInt64] { - get {return _storage._packedFixed64} + get {_storage._packedFixed64} set {_uniqueStorage()._packedFixed64 = newValue} } var packedSfixed32: [Int32] { - get {return _storage._packedSfixed32} + get {_storage._packedSfixed32} set {_uniqueStorage()._packedSfixed32 = newValue} } var packedSfixed64: [Int64] { - get {return _storage._packedSfixed64} + get {_storage._packedSfixed64} set {_uniqueStorage()._packedSfixed64 = newValue} } var packedFloat: [Float] { - get {return _storage._packedFloat} + get {_storage._packedFloat} set {_uniqueStorage()._packedFloat = newValue} } var packedDouble: [Double] { - get {return _storage._packedDouble} + get {_storage._packedDouble} set {_uniqueStorage()._packedDouble = newValue} } var packedBool: [Bool] { - get {return _storage._packedBool} + get {_storage._packedBool} set {_uniqueStorage()._packedBool = newValue} } - var packedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] { - get {return _storage._packedNestedEnum} + var packedNestedEnum: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] { + get {_storage._packedNestedEnum} set {_uniqueStorage()._packedNestedEnum = newValue} } /// Unpacked var unpackedInt32: [Int32] { - get {return _storage._unpackedInt32} + get {_storage._unpackedInt32} set {_uniqueStorage()._unpackedInt32 = newValue} } var unpackedInt64: [Int64] { - get {return _storage._unpackedInt64} + get {_storage._unpackedInt64} set {_uniqueStorage()._unpackedInt64 = newValue} } var unpackedUint32: [UInt32] { - get {return _storage._unpackedUint32} + get {_storage._unpackedUint32} set {_uniqueStorage()._unpackedUint32 = newValue} } var unpackedUint64: [UInt64] { - get {return _storage._unpackedUint64} + get {_storage._unpackedUint64} set {_uniqueStorage()._unpackedUint64 = newValue} } var unpackedSint32: [Int32] { - get {return _storage._unpackedSint32} + get {_storage._unpackedSint32} set {_uniqueStorage()._unpackedSint32 = newValue} } var unpackedSint64: [Int64] { - get {return _storage._unpackedSint64} + get {_storage._unpackedSint64} set {_uniqueStorage()._unpackedSint64 = newValue} } var unpackedFixed32: [UInt32] { - get {return _storage._unpackedFixed32} + get {_storage._unpackedFixed32} set {_uniqueStorage()._unpackedFixed32 = newValue} } var unpackedFixed64: [UInt64] { - get {return _storage._unpackedFixed64} + get {_storage._unpackedFixed64} set {_uniqueStorage()._unpackedFixed64 = newValue} } var unpackedSfixed32: [Int32] { - get {return _storage._unpackedSfixed32} + get {_storage._unpackedSfixed32} set {_uniqueStorage()._unpackedSfixed32 = newValue} } var unpackedSfixed64: [Int64] { - get {return _storage._unpackedSfixed64} + get {_storage._unpackedSfixed64} set {_uniqueStorage()._unpackedSfixed64 = newValue} } var unpackedFloat: [Float] { - get {return _storage._unpackedFloat} + get {_storage._unpackedFloat} set {_uniqueStorage()._unpackedFloat = newValue} } var unpackedDouble: [Double] { - get {return _storage._unpackedDouble} + get {_storage._unpackedDouble} set {_uniqueStorage()._unpackedDouble = newValue} } var unpackedBool: [Bool] { - get {return _storage._unpackedBool} + get {_storage._unpackedBool} set {_uniqueStorage()._unpackedBool = newValue} } - var unpackedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] { - get {return _storage._unpackedNestedEnum} + var unpackedNestedEnum: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] { + get {_storage._unpackedNestedEnum} set {_uniqueStorage()._unpackedNestedEnum = newValue} } /// Map var mapInt32Int32: Dictionary { - get {return _storage._mapInt32Int32} + get {_storage._mapInt32Int32} set {_uniqueStorage()._mapInt32Int32 = newValue} } var mapInt64Int64: Dictionary { - get {return _storage._mapInt64Int64} + get {_storage._mapInt64Int64} set {_uniqueStorage()._mapInt64Int64 = newValue} } var mapUint32Uint32: Dictionary { - get {return _storage._mapUint32Uint32} + get {_storage._mapUint32Uint32} set {_uniqueStorage()._mapUint32Uint32 = newValue} } var mapUint64Uint64: Dictionary { - get {return _storage._mapUint64Uint64} + get {_storage._mapUint64Uint64} set {_uniqueStorage()._mapUint64Uint64 = newValue} } var mapSint32Sint32: Dictionary { - get {return _storage._mapSint32Sint32} + get {_storage._mapSint32Sint32} set {_uniqueStorage()._mapSint32Sint32 = newValue} } var mapSint64Sint64: Dictionary { - get {return _storage._mapSint64Sint64} + get {_storage._mapSint64Sint64} set {_uniqueStorage()._mapSint64Sint64 = newValue} } var mapFixed32Fixed32: Dictionary { - get {return _storage._mapFixed32Fixed32} + get {_storage._mapFixed32Fixed32} set {_uniqueStorage()._mapFixed32Fixed32 = newValue} } var mapFixed64Fixed64: Dictionary { - get {return _storage._mapFixed64Fixed64} + get {_storage._mapFixed64Fixed64} set {_uniqueStorage()._mapFixed64Fixed64 = newValue} } var mapSfixed32Sfixed32: Dictionary { - get {return _storage._mapSfixed32Sfixed32} + get {_storage._mapSfixed32Sfixed32} set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} } var mapSfixed64Sfixed64: Dictionary { - get {return _storage._mapSfixed64Sfixed64} + get {_storage._mapSfixed64Sfixed64} set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} } var mapInt32Float: Dictionary { - get {return _storage._mapInt32Float} + get {_storage._mapInt32Float} set {_uniqueStorage()._mapInt32Float = newValue} } var mapInt32Double: Dictionary { - get {return _storage._mapInt32Double} + get {_storage._mapInt32Double} set {_uniqueStorage()._mapInt32Double = newValue} } var mapBoolBool: Dictionary { - get {return _storage._mapBoolBool} + get {_storage._mapBoolBool} set {_uniqueStorage()._mapBoolBool = newValue} } var mapStringString: Dictionary { - get {return _storage._mapStringString} + get {_storage._mapStringString} set {_uniqueStorage()._mapStringString = newValue} } var mapStringBytes: Dictionary { - get {return _storage._mapStringBytes} + get {_storage._mapStringBytes} set {_uniqueStorage()._mapStringBytes = newValue} } - var mapStringNestedMessage: Dictionary { - get {return _storage._mapStringNestedMessage} + var mapStringNestedMessage: Dictionary { + get {_storage._mapStringNestedMessage} set {_uniqueStorage()._mapStringNestedMessage = newValue} } - var mapStringForeignMessage: Dictionary { - get {return _storage._mapStringForeignMessage} + var mapStringForeignMessage: Dictionary { + get {_storage._mapStringForeignMessage} set {_uniqueStorage()._mapStringForeignMessage = newValue} } - var mapStringNestedEnum: Dictionary { - get {return _storage._mapStringNestedEnum} + var mapStringNestedEnum: Dictionary { + get {_storage._mapStringNestedEnum} set {_uniqueStorage()._mapStringNestedEnum = newValue} } - var mapStringForeignEnum: Dictionary { - get {return _storage._mapStringForeignEnum} + var mapStringForeignEnum: Dictionary { + get {_storage._mapStringForeignEnum} set {_uniqueStorage()._mapStringForeignEnum = newValue} } @@ -661,10 +648,10 @@ struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleM set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} } - var oneofNestedMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage { + var oneofNestedMessage: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage { get { if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} - return ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage() + return ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage() } set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} } @@ -717,7 +704,7 @@ struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleM set {_uniqueStorage()._oneofField = .oneofDouble(newValue)} } - var oneofEnum: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum { + var oneofEnum: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum { get { if case .oneofEnum(let v)? = _storage._oneofField {return v} return .foo @@ -725,246 +712,45 @@ struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleM set {_uniqueStorage()._oneofField = .oneofEnum(newValue)} } - var data: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage { - get {return _storage._data ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage()} - set {_uniqueStorage()._data = newValue} - } - /// Returns true if `data` has been explicitly set. - var hasData: Bool {return _storage._data != nil} - /// Clears the value of `data`. Subsequent reads from it will return its default value. - mutating func clearData() {_uniqueStorage()._data = nil} - - /// Test field-name-to-JSON-name convention. - /// (protobuf says names can be any valid C/C++ identifier.) - var fieldname1: Int32 { - get {return _storage._fieldname1 ?? 0} - set {_uniqueStorage()._fieldname1 = newValue} - } - /// Returns true if `fieldname1` has been explicitly set. - var hasFieldname1: Bool {return _storage._fieldname1 != nil} - /// Clears the value of `fieldname1`. Subsequent reads from it will return its default value. - mutating func clearFieldname1() {_uniqueStorage()._fieldname1 = nil} - - var fieldName2: Int32 { - get {return _storage._fieldName2 ?? 0} - set {_uniqueStorage()._fieldName2 = newValue} - } - /// Returns true if `fieldName2` has been explicitly set. - var hasFieldName2: Bool {return _storage._fieldName2 != nil} - /// Clears the value of `fieldName2`. Subsequent reads from it will return its default value. - mutating func clearFieldName2() {_uniqueStorage()._fieldName2 = nil} - - var fieldName3: Int32 { - get {return _storage._fieldName3 ?? 0} - set {_uniqueStorage()._fieldName3 = newValue} - } - /// Returns true if `fieldName3` has been explicitly set. - var hasFieldName3: Bool {return _storage._fieldName3 != nil} - /// Clears the value of `fieldName3`. Subsequent reads from it will return its default value. - mutating func clearFieldName3() {_uniqueStorage()._fieldName3 = nil} - - var field_Name4_: Int32 { - get {return _storage._field_Name4_ ?? 0} - set {_uniqueStorage()._field_Name4_ = newValue} - } - /// Returns true if `field_Name4_` has been explicitly set. - var hasField_Name4_: Bool {return _storage._field_Name4_ != nil} - /// Clears the value of `field_Name4_`. Subsequent reads from it will return its default value. - mutating func clearField_Name4_() {_uniqueStorage()._field_Name4_ = nil} - - var field0Name5: Int32 { - get {return _storage._field0Name5 ?? 0} - set {_uniqueStorage()._field0Name5 = newValue} - } - /// Returns true if `field0Name5` has been explicitly set. - var hasField0Name5: Bool {return _storage._field0Name5 != nil} - /// Clears the value of `field0Name5`. Subsequent reads from it will return its default value. - mutating func clearField0Name5() {_uniqueStorage()._field0Name5 = nil} - - var field0Name6: Int32 { - get {return _storage._field0Name6 ?? 0} - set {_uniqueStorage()._field0Name6 = newValue} - } - /// Returns true if `field0Name6` has been explicitly set. - var hasField0Name6: Bool {return _storage._field0Name6 != nil} - /// Clears the value of `field0Name6`. Subsequent reads from it will return its default value. - mutating func clearField0Name6() {_uniqueStorage()._field0Name6 = nil} - - var fieldName7: Int32 { - get {return _storage._fieldName7 ?? 0} - set {_uniqueStorage()._fieldName7 = newValue} - } - /// Returns true if `fieldName7` has been explicitly set. - var hasFieldName7: Bool {return _storage._fieldName7 != nil} - /// Clears the value of `fieldName7`. Subsequent reads from it will return its default value. - mutating func clearFieldName7() {_uniqueStorage()._fieldName7 = nil} - - var fieldName8: Int32 { - get {return _storage._fieldName8 ?? 0} - set {_uniqueStorage()._fieldName8 = newValue} - } - /// Returns true if `fieldName8` has been explicitly set. - var hasFieldName8: Bool {return _storage._fieldName8 != nil} - /// Clears the value of `fieldName8`. Subsequent reads from it will return its default value. - mutating func clearFieldName8() {_uniqueStorage()._fieldName8 = nil} - - var fieldName9: Int32 { - get {return _storage._fieldName9 ?? 0} - set {_uniqueStorage()._fieldName9 = newValue} - } - /// Returns true if `fieldName9` has been explicitly set. - var hasFieldName9: Bool {return _storage._fieldName9 != nil} - /// Clears the value of `fieldName9`. Subsequent reads from it will return its default value. - mutating func clearFieldName9() {_uniqueStorage()._fieldName9 = nil} - - var fieldName10: Int32 { - get {return _storage._fieldName10 ?? 0} - set {_uniqueStorage()._fieldName10 = newValue} - } - /// Returns true if `fieldName10` has been explicitly set. - var hasFieldName10: Bool {return _storage._fieldName10 != nil} - /// Clears the value of `fieldName10`. Subsequent reads from it will return its default value. - mutating func clearFieldName10() {_uniqueStorage()._fieldName10 = nil} - - var fieldName11: Int32 { - get {return _storage._fieldName11 ?? 0} - set {_uniqueStorage()._fieldName11 = newValue} - } - /// Returns true if `fieldName11` has been explicitly set. - var hasFieldName11: Bool {return _storage._fieldName11 != nil} - /// Clears the value of `fieldName11`. Subsequent reads from it will return its default value. - mutating func clearFieldName11() {_uniqueStorage()._fieldName11 = nil} - - var fieldName12: Int32 { - get {return _storage._fieldName12 ?? 0} - set {_uniqueStorage()._fieldName12 = newValue} - } - /// Returns true if `fieldName12` has been explicitly set. - var hasFieldName12: Bool {return _storage._fieldName12 != nil} - /// Clears the value of `fieldName12`. Subsequent reads from it will return its default value. - mutating func clearFieldName12() {_uniqueStorage()._fieldName12 = nil} - - var _FieldName13: Int32 { - get {return _storage.__FieldName13 ?? 0} - set {_uniqueStorage().__FieldName13 = newValue} - } - /// Returns true if `_FieldName13` has been explicitly set. - var has_FieldName13: Bool {return _storage.__FieldName13 != nil} - /// Clears the value of `_FieldName13`. Subsequent reads from it will return its default value. - mutating func clear_FieldName13() {_uniqueStorage().__FieldName13 = nil} - - var _FieldName14: Int32 { - get {return _storage.__FieldName14 ?? 0} - set {_uniqueStorage().__FieldName14 = newValue} - } - /// Returns true if `_FieldName14` has been explicitly set. - var has_FieldName14: Bool {return _storage.__FieldName14 != nil} - /// Clears the value of `_FieldName14`. Subsequent reads from it will return its default value. - mutating func clear_FieldName14() {_uniqueStorage().__FieldName14 = nil} - - var field_Name15: Int32 { - get {return _storage._field_Name15 ?? 0} - set {_uniqueStorage()._field_Name15 = newValue} - } - /// Returns true if `field_Name15` has been explicitly set. - var hasField_Name15: Bool {return _storage._field_Name15 != nil} - /// Clears the value of `field_Name15`. Subsequent reads from it will return its default value. - mutating func clearField_Name15() {_uniqueStorage()._field_Name15 = nil} - - var field_Name16: Int32 { - get {return _storage._field_Name16 ?? 0} - set {_uniqueStorage()._field_Name16 = newValue} - } - /// Returns true if `field_Name16` has been explicitly set. - var hasField_Name16: Bool {return _storage._field_Name16 != nil} - /// Clears the value of `field_Name16`. Subsequent reads from it will return its default value. - mutating func clearField_Name16() {_uniqueStorage()._field_Name16 = nil} - - var fieldName17__: Int32 { - get {return _storage._fieldName17__ ?? 0} - set {_uniqueStorage()._fieldName17__ = newValue} - } - /// Returns true if `fieldName17__` has been explicitly set. - var hasFieldName17__: Bool {return _storage._fieldName17__ != nil} - /// Clears the value of `fieldName17__`. Subsequent reads from it will return its default value. - mutating func clearFieldName17__() {_uniqueStorage()._fieldName17__ = nil} - - var fieldName18__: Int32 { - get {return _storage._fieldName18__ ?? 0} - set {_uniqueStorage()._fieldName18__ = newValue} - } - /// Returns true if `fieldName18__` has been explicitly set. - var hasFieldName18__: Bool {return _storage._fieldName18__ != nil} - /// Clears the value of `fieldName18__`. Subsequent reads from it will return its default value. - mutating func clearFieldName18__() {_uniqueStorage()._fieldName18__ = nil} + var groupLikeType: ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType { + get {_storage._groupLikeType ?? ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType()} + set {_uniqueStorage()._groupLikeType = newValue} + } + /// Returns true if `groupLikeType` has been explicitly set. + var hasGroupLikeType: Bool {_storage._groupLikeType != nil} + /// Clears the value of `groupLikeType`. Subsequent reads from it will return its default value. + mutating func clearGroupLikeType() {_uniqueStorage()._groupLikeType = nil} + + var delimitedField: ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType { + get {_storage._delimitedField ?? ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType()} + set {_uniqueStorage()._delimitedField = newValue} + } + /// Returns true if `delimitedField` has been explicitly set. + var hasDelimitedField: Bool {_storage._delimitedField != nil} + /// Clears the value of `delimitedField`. Subsequent reads from it will return its default value. + mutating func clearDelimitedField() {_uniqueStorage()._delimitedField = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case oneofUint32(UInt32) - case oneofNestedMessage(ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage) + case oneofNestedMessage(ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage) case oneofString(String) case oneofBytes(Data) case oneofBool(Bool) case oneofUint64(UInt64) case oneofFloat(Float) case oneofDouble(Double) - case oneofEnum(ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum) + case oneofEnum(ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum) fileprivate var isInitialized: Bool { guard case .oneofNestedMessage(let v) = self else {return true} return v.isInitialized } - #if !swift(>=4.1) - static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.OneOf_OneofField, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBool, .oneofBool): return { - guard case .oneofBool(let l) = lhs, case .oneofBool(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint64, .oneofUint64): return { - guard case .oneofUint64(let l) = lhs, case .oneofUint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFloat, .oneofFloat): return { - guard case .oneofFloat(let l) = lhs, case .oneofFloat(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofDouble, .oneofDouble): return { - guard case .oneofDouble(let l) = lhs, case .oneofDouble(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofEnum, .oneofEnum): return { - guard case .oneofEnum(let l) = lhs, case .oneofEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum NestedEnum: SwiftProtobuf.Enum { + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foo // = 0 case bar // = 1 @@ -972,6 +758,7 @@ struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleM /// Intentionally negative. case neg // = -1 + case UNRECOGNIZED(Int) init() { self = .foo @@ -983,7 +770,7 @@ struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleM case 0: self = .foo case 1: self = .bar case 2: self = .baz - default: return nil + default: self = .UNRECOGNIZED(rawValue) } } @@ -993,31 +780,40 @@ struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleM case .foo: return 0 case .bar: return 1 case .baz: return 2 + case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] = [ + .foo, + .bar, + .baz, + .neg, + ] + } - struct NestedMessage { + struct NestedMessage: @unchecked Sendable { // 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 a: Int32 { - get {return _storage._a ?? 0} + get {_storage._a ?? 0} set {_uniqueStorage()._a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return _storage._a != nil} + var hasA: Bool {_storage._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {_uniqueStorage()._a = nil} - var corecursive: ProtobufTestMessages_Proto2_TestAllTypesProto2 { - get {return _storage._corecursive ?? ProtobufTestMessages_Proto2_TestAllTypesProto2()} + var corecursive: ProtobufTestMessages_Editions_TestAllTypesEdition2023 { + get {_storage._corecursive ?? ProtobufTestMessages_Editions_TestAllTypesEdition2023()} set {_uniqueStorage()._corecursive = newValue} } /// Returns true if `corecursive` has been explicitly set. - var hasCorecursive: Bool {return _storage._corecursive != nil} + var hasCorecursive: Bool {_storage._corecursive != nil} /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} @@ -1029,26 +825,26 @@ struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleM } /// groups - struct DataMessage { + struct GroupLikeType: Sendable { // 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 groupInt32: Int32 { - get {return _groupInt32 ?? 0} + get {_groupInt32 ?? 0} set {_groupInt32 = newValue} } /// Returns true if `groupInt32` has been explicitly set. - var hasGroupInt32: Bool {return self._groupInt32 != nil} + var hasGroupInt32: Bool {self._groupInt32 != nil} /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. mutating func clearGroupInt32() {self._groupInt32 = nil} var groupUint32: UInt32 { - get {return _groupUint32 ?? 0} + get {_groupUint32 ?? 0} set {_groupUint32 = newValue} } /// Returns true if `groupUint32` has been explicitly set. - var hasGroupUint32: Bool {return self._groupUint32 != nil} + var hasGroupUint32: Bool {self._groupUint32 != nil} /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. mutating func clearGroupUint32() {self._groupUint32 = nil} @@ -1060,86 +856,23 @@ struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleM fileprivate var _groupUint32: UInt32? = nil } - /// message_set test case. - struct MessageSetCorrect: 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() - } - - struct MessageSetCorrectExtension1 { - // 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 str: String { - get {return _str ?? String()} - set {_str = newValue} - } - /// Returns true if `str` has been explicitly set. - var hasStr: Bool {return self._str != nil} - /// Clears the value of `str`. Subsequent reads from it will return its default value. - mutating func clearStr() {self._str = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _str: String? = nil - } - - struct MessageSetCorrectExtension2 { - // 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 i: Int32 { - get {return _i ?? 0} - set {_i = newValue} - } - /// Returns true if `i` has been explicitly set. - var hasI: Bool {return self._i != nil} - /// Clears the value of `i`. Subsequent reads from it will return its default value. - mutating func clearI() {self._i = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _i: Int32? = nil - } - init() {} var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufTestMessages_Proto2_ForeignMessageProto2 { +struct ProtobufTestMessages_Editions_ForeignMessageEdition2023: Sendable { // 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 c: Int32 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -1150,396 +883,161 @@ struct ProtobufTestMessages_Proto2_ForeignMessageProto2 { fileprivate var _c: Int32? = nil } -struct ProtobufTestMessages_Proto2_UnknownToTestAllTypes { +struct ProtobufTestMessages_Editions_GroupLikeType: Sendable { // 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 optionalInt32: Int32 { - get {return _optionalInt32 ?? 0} - set {_optionalInt32 = newValue} - } - /// Returns true if `optionalInt32` has been explicitly set. - var hasOptionalInt32: Bool {return self._optionalInt32 != nil} - /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. - mutating func clearOptionalInt32() {self._optionalInt32 = nil} - - var optionalString: String { - get {return _optionalString ?? String()} - set {_optionalString = newValue} - } - /// Returns true if `optionalString` has been explicitly set. - var hasOptionalString: Bool {return self._optionalString != nil} - /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. - mutating func clearOptionalString() {self._optionalString = nil} - - var nestedMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2 { - get {return _nestedMessage ?? ProtobufTestMessages_Proto2_ForeignMessageProto2()} - set {_nestedMessage = newValue} - } - /// Returns true if `nestedMessage` has been explicitly set. - var hasNestedMessage: Bool {return self._nestedMessage != nil} - /// Clears the value of `nestedMessage`. Subsequent reads from it will return its default value. - mutating func clearNestedMessage() {self._nestedMessage = nil} - - var optionalGroup: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup { - get {return _optionalGroup ?? ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup()} - set {_optionalGroup = newValue} - } - /// Returns true if `optionalGroup` has been explicitly set. - var hasOptionalGroup: Bool {return self._optionalGroup != nil} - /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. - mutating func clearOptionalGroup() {self._optionalGroup = nil} - - var optionalBool: Bool { - get {return _optionalBool ?? false} - set {_optionalBool = newValue} - } - /// Returns true if `optionalBool` has been explicitly set. - var hasOptionalBool: Bool {return self._optionalBool != nil} - /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. - mutating func clearOptionalBool() {self._optionalBool = nil} - - var repeatedInt32: [Int32] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct OptionalGroup { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil + var c: Int32 { + get {_c ?? 0} + set {_c = newValue} } - - init() {} - - fileprivate var _optionalInt32: Int32? = nil - fileprivate var _optionalString: String? = nil - fileprivate var _nestedMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2? = nil - fileprivate var _optionalGroup: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup? = nil - fileprivate var _optionalBool: Bool? = nil -} - -struct ProtobufTestMessages_Proto2_NullHypothesisProto2 { - // 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. + /// Returns true if `c` has been explicitly set. + var hasC: Bool {self._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {self._c = nil} var unknownFields = SwiftProtobuf.UnknownStorage() init() {} -} - -struct ProtobufTestMessages_Proto2_EnumOnlyProto2 { - // 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() - - enum BoolEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case kFalse // = 0 - case kTrue // = 1 - - init() { - self = .kFalse - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .kFalse - case 1: self = .kTrue - default: return nil - } - } - - var rawValue: Int { - switch self { - case .kFalse: return 0 - case .kTrue: return 1 - } - } - - } - - init() {} -} - -#if swift(>=4.2) - -extension ProtobufTestMessages_Proto2_EnumOnlyProto2.BoolEnum: CaseIterable { - // Support synthesized by the compiler. + fileprivate var _c: Int32? = nil } -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufTestMessages_Proto2_ForeignEnumProto2: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_ForeignMessageProto2: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_NullHypothesisProto2: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_EnumOnlyProto2: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_EnumOnlyProto2.BoolEnum: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Extension support defined in test_messages_proto2.proto. +// MARK: - Extension support defined in test_messages_edition2023.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 ProtobufTestMessages_Proto2_TestAllTypesProto2 { +extension ProtobufTestMessages_Editions_TestAllTypesEdition2023 { - var ProtobufTestMessages_Proto2_extensionInt32: Int32 { - get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32) ?? 0} - set {setExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32, value: newValue)} + var ProtobufTestMessages_Editions_extensionInt32: Int32 { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_extension_int32) ?? 0} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_extension_int32, value: newValue)} } - /// Returns true if extension `ProtobufTestMessages_Proto2_Extensions_extension_int32` + /// Returns true if extension `ProtobufTestMessages_Editions_Extensions_extension_int32` /// has been explicitly set. - var hasProtobufTestMessages_Proto2_extensionInt32: Bool { - return hasExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32) + var hasProtobufTestMessages_Editions_extensionInt32: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_extension_int32) } - /// Clears the value of extension `ProtobufTestMessages_Proto2_Extensions_extension_int32`. + /// Clears the value of extension `ProtobufTestMessages_Editions_Extensions_extension_int32`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufTestMessages_Proto2_extensionInt32() { - clearExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32) + mutating func clearProtobufTestMessages_Editions_extensionInt32() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_extension_int32) } -} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect { - - var ProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1 { - get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1()} - set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, value: newValue)} + var ProtobufTestMessages_Editions_groupLikeType: ProtobufTestMessages_Editions_GroupLikeType { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_GroupLikeType) ?? ProtobufTestMessages_Editions_GroupLikeType()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_GroupLikeType, value: newValue)} } - /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension` + /// Returns true if extension `ProtobufTestMessages_Editions_Extensions_GroupLikeType` /// has been explicitly set. - var hasProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension: Bool { - return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + var hasProtobufTestMessages_Editions_groupLikeType: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_GroupLikeType) } - /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension`. + /// Clears the value of extension `ProtobufTestMessages_Editions_Extensions_GroupLikeType`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension() { - clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + mutating func clearProtobufTestMessages_Editions_groupLikeType() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_GroupLikeType) } - var ProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2 { - get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2()} - set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, value: newValue)} + var ProtobufTestMessages_Editions_delimitedExt: ProtobufTestMessages_Editions_GroupLikeType { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_delimited_ext) ?? ProtobufTestMessages_Editions_GroupLikeType()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_delimited_ext, value: newValue)} } - /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension` + /// Returns true if extension `ProtobufTestMessages_Editions_Extensions_delimited_ext` /// has been explicitly set. - var hasProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension: Bool { - return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + var hasProtobufTestMessages_Editions_delimitedExt: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_delimited_ext) } - /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension`. + /// Clears the value of extension `ProtobufTestMessages_Editions_Extensions_delimited_ext`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension() { - clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + mutating func clearProtobufTestMessages_Editions_delimitedExt() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_delimited_ext) } } -// MARK: - File's ExtensionMap: ProtobufTestMessages_Proto2_TestMessagesProto2_Extensions +// MARK: - File's ExtensionMap: ProtobufTestMessages_Editions_TestMessagesEdition2023_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 ProtobufTestMessages_Proto2_TestMessagesProto2_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufTestMessages_Proto2_Extensions_extension_int32, - ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, - ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension +let ProtobufTestMessages_Editions_TestMessagesEdition2023_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + ProtobufTestMessages_Editions_Extensions_extension_int32, + ProtobufTestMessages_Editions_Extensions_GroupLikeType, + ProtobufTestMessages_Editions_Extensions_delimited_ext ] // 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 ProtobufTestMessages_Proto2_Extensions_extension_int32 = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2>( +let ProtobufTestMessages_Editions_Extensions_extension_int32 = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_TestAllTypesEdition2023>( _protobuf_fieldNumber: 120, - fieldName: "protobuf_test_messages.proto2.extension_int32" + fieldName: "protobuf_test_messages.editions.extension_int32" ) -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1 { - enum Extensions { - static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect>( - _protobuf_fieldNumber: 1547769, - fieldName: "protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension1" - ) - } -} +let ProtobufTestMessages_Editions_Extensions_GroupLikeType = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_TestAllTypesEdition2023>( + _protobuf_fieldNumber: 121, + fieldName: "protobuf_test_messages.editions.groupliketype" +) -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2 { - enum Extensions { - static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect>( - _protobuf_fieldNumber: 4135312, - fieldName: "protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension2" - ) - } -} +let ProtobufTestMessages_Editions_Extensions_delimited_ext = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_TestAllTypesEdition2023>( + _protobuf_fieldNumber: 122, + fieldName: "protobuf_test_messages.editions.delimited_ext" +) // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_test_messages.proto2" +fileprivate let _protobuf_package = "protobuf_test_messages.editions" -extension ProtobufTestMessages_Proto2_ForeignEnumProto2: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOREIGN_FOO"), - 1: .same(proto: "FOREIGN_BAR"), - 2: .same(proto: "FOREIGN_BAZ"), - ] +extension ProtobufTestMessages_Editions_ForeignEnumEdition2023: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") } -extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestAllTypesProto2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "optional_foreign_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "optional_foreign_enum"), - 24: .standard(proto: "optional_string_piece"), - 25: .standard(proto: "optional_cord"), - 27: .standard(proto: "recursive_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 48: .standard(proto: "repeated_nested_message"), - 49: .standard(proto: "repeated_foreign_message"), - 51: .standard(proto: "repeated_nested_enum"), - 52: .standard(proto: "repeated_foreign_enum"), - 54: .standard(proto: "repeated_string_piece"), - 55: .standard(proto: "repeated_cord"), - 75: .standard(proto: "packed_int32"), - 76: .standard(proto: "packed_int64"), - 77: .standard(proto: "packed_uint32"), - 78: .standard(proto: "packed_uint64"), - 79: .standard(proto: "packed_sint32"), - 80: .standard(proto: "packed_sint64"), - 81: .standard(proto: "packed_fixed32"), - 82: .standard(proto: "packed_fixed64"), - 83: .standard(proto: "packed_sfixed32"), - 84: .standard(proto: "packed_sfixed64"), - 85: .standard(proto: "packed_float"), - 86: .standard(proto: "packed_double"), - 87: .standard(proto: "packed_bool"), - 88: .standard(proto: "packed_nested_enum"), - 89: .standard(proto: "unpacked_int32"), - 90: .standard(proto: "unpacked_int64"), - 91: .standard(proto: "unpacked_uint32"), - 92: .standard(proto: "unpacked_uint64"), - 93: .standard(proto: "unpacked_sint32"), - 94: .standard(proto: "unpacked_sint64"), - 95: .standard(proto: "unpacked_fixed32"), - 96: .standard(proto: "unpacked_fixed64"), - 97: .standard(proto: "unpacked_sfixed32"), - 98: .standard(proto: "unpacked_sfixed64"), - 99: .standard(proto: "unpacked_float"), - 100: .standard(proto: "unpacked_double"), - 101: .standard(proto: "unpacked_bool"), - 102: .standard(proto: "unpacked_nested_enum"), - 56: .standard(proto: "map_int32_int32"), - 57: .standard(proto: "map_int64_int64"), - 58: .standard(proto: "map_uint32_uint32"), - 59: .standard(proto: "map_uint64_uint64"), - 60: .standard(proto: "map_sint32_sint32"), - 61: .standard(proto: "map_sint64_sint64"), - 62: .standard(proto: "map_fixed32_fixed32"), - 63: .standard(proto: "map_fixed64_fixed64"), - 64: .standard(proto: "map_sfixed32_sfixed32"), - 65: .standard(proto: "map_sfixed64_sfixed64"), - 66: .standard(proto: "map_int32_float"), - 67: .standard(proto: "map_int32_double"), - 68: .standard(proto: "map_bool_bool"), - 69: .standard(proto: "map_string_string"), - 70: .standard(proto: "map_string_bytes"), - 71: .standard(proto: "map_string_nested_message"), - 72: .standard(proto: "map_string_foreign_message"), - 73: .standard(proto: "map_string_nested_enum"), - 74: .standard(proto: "map_string_foreign_enum"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - 115: .standard(proto: "oneof_bool"), - 116: .standard(proto: "oneof_uint64"), - 117: .standard(proto: "oneof_float"), - 118: .standard(proto: "oneof_double"), - 119: .standard(proto: "oneof_enum"), - 201: .unique(proto: "Data", json: "data"), - 401: .same(proto: "fieldname1"), - 402: .standard(proto: "field_name2"), - 403: .standard(proto: "_field_name3"), - 404: .standard(proto: "field__name4_"), - 405: .same(proto: "field0name5"), - 406: .standard(proto: "field_0_name6"), - 407: .same(proto: "fieldName7"), - 408: .same(proto: "FieldName8"), - 409: .standard(proto: "field_Name9"), - 410: .standard(proto: "Field_Name10"), - 411: .standard(proto: "FIELD_NAME11"), - 412: .standard(proto: "FIELD_name12"), - 413: .standard(proto: "__field_name13"), - 414: .standard(proto: "__Field_name14"), - 415: .standard(proto: "field__name15"), - 416: .standard(proto: "field__Name16"), - 417: .standard(proto: "field_name17__"), - 418: .standard(proto: "Field_name18__"), - ] +extension ProtobufTestMessages_Editions_ComplexMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ComplexMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}d\0") + + 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._d) }() + 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 + try { if let v = self._d { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_ComplexMessage, rhs: ProtobufTestMessages_Editions_ComplexMessage) -> Bool { + if lhs._d != rhs._d {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_TestAllTypesEdition2023: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypesEdition2023" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{4}\u{2}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{4}\u{2}optional_string_piece\0\u{3}optional_cord\0\u{4}\u{2}recursive_message\0\u{4}\u{4}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{4}\u{2}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_nested_message\0\u{3}map_string_foreign_message\0\u{3}map_string_nested_enum\0\u{3}map_string_foreign_enum\0\u{3}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_nested_enum\0\u{3}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_nested_enum\0\u{4}\u{9}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_bool\0\u{3}oneof_uint64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_enum\0\u{8}R\u{1}GroupLikeType\0\u{3}delimited_field\0") fileprivate class _StorageClass { var _optionalInt32: Int32? = nil @@ -1557,13 +1055,13 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, var _optionalBool: Bool? = nil var _optionalString: String? = nil var _optionalBytes: Data? = nil - var _optionalNestedMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage? = nil - var _optionalForeignMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2? = nil - var _optionalNestedEnum: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum? = nil - var _optionalForeignEnum: ProtobufTestMessages_Proto2_ForeignEnumProto2? = nil + var _optionalNestedMessage: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage? = nil + var _optionalForeignMessage: ProtobufTestMessages_Editions_ForeignMessageEdition2023? = nil + var _optionalNestedEnum: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum? = nil + var _optionalForeignEnum: ProtobufTestMessages_Editions_ForeignEnumEdition2023? = nil var _optionalStringPiece: String? = nil var _optionalCord: String? = nil - var _recursiveMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2? = nil + var _recursiveMessage: ProtobufTestMessages_Editions_TestAllTypesEdition2023? = nil var _repeatedInt32: [Int32] = [] var _repeatedInt64: [Int64] = [] var _repeatedUint32: [UInt32] = [] @@ -1579,10 +1077,10 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, var _repeatedBool: [Bool] = [] var _repeatedString: [String] = [] var _repeatedBytes: [Data] = [] - var _repeatedNestedMessage: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage] = [] - var _repeatedForeignMessage: [ProtobufTestMessages_Proto2_ForeignMessageProto2] = [] - var _repeatedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] = [] - var _repeatedForeignEnum: [ProtobufTestMessages_Proto2_ForeignEnumProto2] = [] + var _repeatedNestedMessage: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage] = [] + var _repeatedForeignMessage: [ProtobufTestMessages_Editions_ForeignMessageEdition2023] = [] + var _repeatedNestedEnum: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] = [] + var _repeatedForeignEnum: [ProtobufTestMessages_Editions_ForeignEnumEdition2023] = [] var _repeatedStringPiece: [String] = [] var _repeatedCord: [String] = [] var _packedInt32: [Int32] = [] @@ -1598,7 +1096,7 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, var _packedFloat: [Float] = [] var _packedDouble: [Double] = [] var _packedBool: [Bool] = [] - var _packedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _packedNestedEnum: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] = [] var _unpackedInt32: [Int32] = [] var _unpackedInt64: [Int64] = [] var _unpackedUint32: [UInt32] = [] @@ -1612,7 +1110,7 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, var _unpackedFloat: [Float] = [] var _unpackedDouble: [Double] = [] var _unpackedBool: [Bool] = [] - var _unpackedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _unpackedNestedEnum: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] = [] var _mapInt32Int32: Dictionary = [:] var _mapInt64Int64: Dictionary = [:] var _mapUint32Uint32: Dictionary = [:] @@ -1628,32 +1126,19 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, var _mapBoolBool: Dictionary = [:] var _mapStringString: Dictionary = [:] var _mapStringBytes: Dictionary = [:] - var _mapStringNestedMessage: Dictionary = [:] - var _mapStringForeignMessage: Dictionary = [:] - var _mapStringNestedEnum: Dictionary = [:] - var _mapStringForeignEnum: Dictionary = [:] - var _oneofField: ProtobufTestMessages_Proto2_TestAllTypesProto2.OneOf_OneofField? - var _data: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage? = nil - var _fieldname1: Int32? = nil - var _fieldName2: Int32? = nil - var _fieldName3: Int32? = nil - var _field_Name4_: Int32? = nil - var _field0Name5: Int32? = nil - var _field0Name6: Int32? = nil - var _fieldName7: Int32? = nil - var _fieldName8: Int32? = nil - var _fieldName9: Int32? = nil - var _fieldName10: Int32? = nil - var _fieldName11: Int32? = nil - var _fieldName12: Int32? = nil - var __FieldName13: Int32? = nil - var __FieldName14: Int32? = nil - var _field_Name15: Int32? = nil - var _field_Name16: Int32? = nil - var _fieldName17__: Int32? = nil - var _fieldName18__: Int32? = nil - - static let defaultInstance = _StorageClass() + var _mapStringNestedMessage: Dictionary = [:] + var _mapStringForeignMessage: Dictionary = [:] + var _mapStringNestedEnum: Dictionary = [:] + var _mapStringForeignEnum: Dictionary = [:] + var _oneofField: ProtobufTestMessages_Editions_TestAllTypesEdition2023.OneOf_OneofField? + var _groupLikeType: ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType? = nil + var _delimitedField: ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType? = nil + + // 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() private init() {} @@ -1749,25 +1234,8 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, _mapStringNestedEnum = source._mapStringNestedEnum _mapStringForeignEnum = source._mapStringForeignEnum _oneofField = source._oneofField - _data = source._data - _fieldname1 = source._fieldname1 - _fieldName2 = source._fieldName2 - _fieldName3 = source._fieldName3 - _field_Name4_ = source._field_Name4_ - _field0Name5 = source._field0Name5 - _field0Name6 = source._field0Name6 - _fieldName7 = source._fieldName7 - _fieldName8 = source._fieldName8 - _fieldName9 = source._fieldName9 - _fieldName10 = source._fieldName10 - _fieldName11 = source._fieldName11 - _fieldName12 = source._fieldName12 - __FieldName13 = source.__FieldName13 - __FieldName14 = source.__FieldName14 - _field_Name15 = source._field_Name15 - _field_Name16 = source._field_Name16 - _fieldName17__ = source._fieldName17__ - _fieldName18__ = source._fieldName18__ + _groupLikeType = source._groupLikeType + _delimitedField = source._delimitedField } } @@ -1856,10 +1324,10 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, case 68: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() case 69: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() case 70: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() - case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringNestedMessage) }() - case 72: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() - case 73: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringNestedEnum) }() - case 74: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringForeignEnum) }() + case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringNestedMessage) }() + case 72: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() + case 73: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringNestedEnum) }() + case 74: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringForeignEnum) }() case 75: try { try decoder.decodeRepeatedInt32Field(value: &_storage._packedInt32) }() case 76: try { try decoder.decodeRepeatedInt64Field(value: &_storage._packedInt64) }() case 77: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._packedUint32) }() @@ -1897,7 +1365,7 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, } }() case 112: try { - var v: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage? + var v: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage? var hadOneofValue = false if let current = _storage._oneofField { hadOneofValue = true @@ -1958,34 +1426,17 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, } }() case 119: try { - var v: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum? + var v: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum? try decoder.decodeSingularEnumField(value: &v) if let v = v { if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} _storage._oneofField = .oneofEnum(v) } }() - case 201: try { try decoder.decodeSingularGroupField(value: &_storage._data) }() - case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldname1) }() - case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName2) }() - case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName3) }() - case 404: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name4_) }() - case 405: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name5) }() - case 406: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name6) }() - case 407: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName7) }() - case 408: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName8) }() - case 409: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName9) }() - case 410: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName10) }() - case 411: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName11) }() - case 412: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName12) }() - case 413: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName13) }() - case 414: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName14) }() - case 415: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name15) }() - case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name16) }() - case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName17__) }() - case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName18__) }() + case 201: try { try decoder.decodeSingularGroupField(value: &_storage._groupLikeType) }() + case 202: try { try decoder.decodeSingularGroupField(value: &_storage._delimitedField) }() case 120..<201: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Proto2_TestAllTypesProto2.self, fieldNumber: fieldNumber) }() + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Editions_TestAllTypesEdition2023.self, fieldNumber: fieldNumber) }() default: break } } @@ -2065,43 +1516,43 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, try visitor.visitSingularMessageField(value: v, fieldNumber: 27) } }() if !_storage._repeatedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) } if !_storage._repeatedInt64.isEmpty { - try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + try visitor.visitPackedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) } if !_storage._repeatedUint32.isEmpty { - try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + try visitor.visitPackedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) } if !_storage._repeatedUint64.isEmpty { - try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + try visitor.visitPackedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) } if !_storage._repeatedSint32.isEmpty { - try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + try visitor.visitPackedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) } if !_storage._repeatedSint64.isEmpty { - try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + try visitor.visitPackedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) } if !_storage._repeatedFixed32.isEmpty { - try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + try visitor.visitPackedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) } if !_storage._repeatedFixed64.isEmpty { - try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + try visitor.visitPackedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) } if !_storage._repeatedSfixed32.isEmpty { - try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + try visitor.visitPackedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) } if !_storage._repeatedSfixed64.isEmpty { - try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + try visitor.visitPackedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) } if !_storage._repeatedFloat.isEmpty { - try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + try visitor.visitPackedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) } if !_storage._repeatedDouble.isEmpty { - try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + try visitor.visitPackedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) } if !_storage._repeatedBool.isEmpty { - try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + try visitor.visitPackedBoolField(value: _storage._repeatedBool, fieldNumber: 43) } if !_storage._repeatedString.isEmpty { try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) @@ -2116,10 +1567,10 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) } if !_storage._repeatedNestedEnum.isEmpty { - try visitor.visitRepeatedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + try visitor.visitPackedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) } if !_storage._repeatedForeignEnum.isEmpty { - try visitor.visitRepeatedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) + try visitor.visitPackedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) } if !_storage._repeatedStringPiece.isEmpty { try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) @@ -2173,16 +1624,16 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 70) } if !_storage._mapStringNestedMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringNestedMessage, fieldNumber: 71) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringNestedMessage, fieldNumber: 71) } if !_storage._mapStringForeignMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 72) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 72) } if !_storage._mapStringNestedEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringNestedEnum, fieldNumber: 73) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringNestedEnum, fieldNumber: 73) } if !_storage._mapStringForeignEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringForeignEnum, fieldNumber: 74) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringForeignEnum, fieldNumber: 74) } if !_storage._packedInt32.isEmpty { try visitor.visitPackedInt32Field(value: _storage._packedInt32, fieldNumber: 75) @@ -2308,68 +1759,17 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, case nil: break } try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201) - try { if let v = _storage._data { + try { if let v = _storage._groupLikeType { try visitor.visitSingularGroupField(value: v, fieldNumber: 201) } }() - try { if let v = _storage._fieldname1 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 401) - } }() - try { if let v = _storage._fieldName2 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 402) - } }() - try { if let v = _storage._fieldName3 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 403) - } }() - try { if let v = _storage._field_Name4_ { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 404) - } }() - try { if let v = _storage._field0Name5 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 405) - } }() - try { if let v = _storage._field0Name6 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 406) - } }() - try { if let v = _storage._fieldName7 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 407) - } }() - try { if let v = _storage._fieldName8 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 408) - } }() - try { if let v = _storage._fieldName9 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 409) - } }() - try { if let v = _storage._fieldName10 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 410) - } }() - try { if let v = _storage._fieldName11 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 411) - } }() - try { if let v = _storage._fieldName12 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 412) - } }() - try { if let v = _storage.__FieldName13 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 413) - } }() - try { if let v = _storage.__FieldName14 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 414) - } }() - try { if let v = _storage._field_Name15 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 415) - } }() - try { if let v = _storage._field_Name16 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 416) - } }() - try { if let v = _storage._fieldName17__ { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 417) - } }() - try { if let v = _storage._fieldName18__ { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 418) + try { if let v = _storage._delimitedField { + try visitor.visitSingularGroupField(value: v, fieldNumber: 202) } }() } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2) -> Bool { + static func ==(lhs: ProtobufTestMessages_Editions_TestAllTypesEdition2023, rhs: ProtobufTestMessages_Editions_TestAllTypesEdition2023) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -2465,25 +1865,8 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, if _storage._mapStringNestedEnum != rhs_storage._mapStringNestedEnum {return false} if _storage._mapStringForeignEnum != rhs_storage._mapStringForeignEnum {return false} if _storage._oneofField != rhs_storage._oneofField {return false} - if _storage._data != rhs_storage._data {return false} - if _storage._fieldname1 != rhs_storage._fieldname1 {return false} - if _storage._fieldName2 != rhs_storage._fieldName2 {return false} - if _storage._fieldName3 != rhs_storage._fieldName3 {return false} - if _storage._field_Name4_ != rhs_storage._field_Name4_ {return false} - if _storage._field0Name5 != rhs_storage._field0Name5 {return false} - if _storage._field0Name6 != rhs_storage._field0Name6 {return false} - if _storage._fieldName7 != rhs_storage._fieldName7 {return false} - if _storage._fieldName8 != rhs_storage._fieldName8 {return false} - if _storage._fieldName9 != rhs_storage._fieldName9 {return false} - if _storage._fieldName10 != rhs_storage._fieldName10 {return false} - if _storage._fieldName11 != rhs_storage._fieldName11 {return false} - if _storage._fieldName12 != rhs_storage._fieldName12 {return false} - if _storage.__FieldName13 != rhs_storage.__FieldName13 {return false} - if _storage.__FieldName14 != rhs_storage.__FieldName14 {return false} - if _storage._field_Name15 != rhs_storage._field_Name15 {return false} - if _storage._field_Name16 != rhs_storage._field_Name16 {return false} - if _storage._fieldName17__ != rhs_storage._fieldName17__ {return false} - if _storage._fieldName18__ != rhs_storage._fieldName18__ {return false} + if _storage._groupLikeType != rhs_storage._groupLikeType {return false} + if _storage._delimitedField != rhs_storage._delimitedField {return false} return true } if !storagesAreEqual {return false} @@ -2494,27 +1877,23 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, } } -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -1: .same(proto: "NEG"), - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - ] +extension ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") } -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 2: .same(proto: "corecursive"), - ] +extension ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_TestAllTypesEdition2023.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0") fileprivate class _StorageClass { var _a: Int32? = nil - var _corecursive: ProtobufTestMessages_Proto2_TestAllTypesProto2? = nil + var _corecursive: ProtobufTestMessages_Editions_TestAllTypesEdition2023? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -2570,7 +1949,7 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage: SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage) -> Bool { + static func ==(lhs: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage, rhs: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -2586,12 +1965,9 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage: SwiftPro } } -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".Data" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 202: .standard(proto: "group_int32"), - 203: .standard(proto: "group_uint32"), - ] +extension ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_TestAllTypesEdition2023.protoMessageName + ".GroupLikeType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}J\u{3}group_int32\0\u{3}group_uint32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -2620,7 +1996,7 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage: SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage) -> Bool { + static func ==(lhs: ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType, rhs: ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType) -> Bool { if lhs._groupInt32 != rhs._groupInt32 {return false} if lhs._groupUint32 != rhs._groupUint32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -2628,108 +2004,9 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage: SwiftProto } } -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrect" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect.self) - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrectExtension1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 25: .same(proto: "str"), - ] - - 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 25: try { try decoder.decodeSingularStringField(value: &self._str) }() - 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 - try { if let v = self._str { - try visitor.visitSingularStringField(value: v, fieldNumber: 25) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1) -> Bool { - if lhs._str != rhs._str {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrectExtension2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 9: .same(proto: "i"), - ] - - 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 9: try { try decoder.decodeSingularInt32Field(value: &self._i) }() - 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 - try { if let v = self._i { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2) -> Bool { - if lhs._i != rhs._i {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufTestMessages_Proto2_ForeignMessageProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ForeignMessageProto2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - ] +extension ProtobufTestMessages_Editions_ForeignMessageEdition2023: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessageEdition2023" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -2754,23 +2031,16 @@ extension ProtobufTestMessages_Proto2_ForeignMessageProto2: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufTestMessages_Proto2_ForeignMessageProto2, rhs: ProtobufTestMessages_Proto2_ForeignMessageProto2) -> Bool { + static func ==(lhs: ProtobufTestMessages_Editions_ForeignMessageEdition2023, rhs: ProtobufTestMessages_Editions_ForeignMessageEdition2023) -> Bool { if lhs._c != rhs._c {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".UnknownToTestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1001: .standard(proto: "optional_int32"), - 1002: .standard(proto: "optional_string"), - 1003: .standard(proto: "nested_message"), - 1004: .unique(proto: "OptionalGroup", json: "optionalgroup"), - 1006: .standard(proto: "optional_bool"), - 1011: .standard(proto: "repeated_int32"), - ] +extension ProtobufTestMessages_Editions_GroupLikeType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GroupLikeType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -2778,68 +2048,7 @@ extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes: SwiftProtobuf.Messa // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { - case 1001: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32) }() - case 1002: try { try decoder.decodeSingularStringField(value: &self._optionalString) }() - case 1003: try { try decoder.decodeSingularMessageField(value: &self._nestedMessage) }() - case 1004: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() - case 1006: try { try decoder.decodeSingularBoolField(value: &self._optionalBool) }() - case 1011: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() - 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 - try { if let v = self._optionalInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1001) - } }() - try { if let v = self._optionalString { - try visitor.visitSingularStringField(value: v, fieldNumber: 1002) - } }() - try { if let v = self._nestedMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1003) - } }() - try { if let v = self._optionalGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 1004) - } }() - try { if let v = self._optionalBool { - try visitor.visitSingularBoolField(value: v, fieldNumber: 1006) - } }() - if !self.repeatedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 1011) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes, rhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes) -> Bool { - if lhs._optionalInt32 != rhs._optionalInt32 {return false} - if lhs._optionalString != rhs._optionalString {return false} - if lhs._nestedMessage != rhs._nestedMessage {return false} - if lhs._optionalGroup != rhs._optionalGroup {return false} - if lhs._optionalBool != rhs._optionalBool {return false} - if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufTestMessages_Proto2_UnknownToTestAllTypes.protoMessageName + ".OptionalGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] - - 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._a) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self._c) }() default: break } } @@ -2850,60 +2059,15 @@ extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup: Swift // 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._a { + try { if let v = self._c { try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup, rhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufTestMessages_Proto2_NullHypothesisProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".NullHypothesisProto2" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufTestMessages_Proto2_NullHypothesisProto2, rhs: ProtobufTestMessages_Proto2_NullHypothesisProto2) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufTestMessages_Proto2_EnumOnlyProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".EnumOnlyProto2" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufTestMessages_Proto2_EnumOnlyProto2, rhs: ProtobufTestMessages_Proto2_EnumOnlyProto2) -> Bool { + static func ==(lhs: ProtobufTestMessages_Editions_GroupLikeType, rhs: ProtobufTestMessages_Editions_GroupLikeType) -> Bool { + if lhs._c != rhs._c {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } - -extension ProtobufTestMessages_Proto2_EnumOnlyProto2.BoolEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "kFalse"), - 1: .same(proto: "kTrue"), - ] -} diff --git a/Reference/Sources/Conformance/editions/test_messages_proto2_editions.pb.swift b/Reference/Sources/Conformance/editions/test_messages_proto2_editions.pb.swift new file mode 100644 index 000000000..d586d6b91 --- /dev/null +++ b/Reference/Sources/Conformance/editions/test_messages_proto2_editions.pb.swift @@ -0,0 +1,4828 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: editions/test_messages_proto2_editions.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// clang-format off +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Test schema for proto2 messages. This test schema is used by: +// +// - conformance tests + +// LINT: ALLOW_GROUPS + +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 ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foreignFoo = 0 + case foreignBar = 1 + case foreignBaz = 2 + + init() { + self = .foreignFoo + } + +} + +/// This proto includes every type of field in both singular and repeated +/// forms. +/// +/// Also, crucially, all messages and enums in this file are eventually +/// submessages of this message. So for example, a fuzz test of TestAllTypes +/// could trigger bugs that occur in any message type in this file. We verify +/// this stays true in a unit test. +struct ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Singular + var optionalInt32: Int32 { + get {_storage._optionalInt32 ?? 0} + set {_uniqueStorage()._optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} + + var optionalInt64: Int64 { + get {_storage._optionalInt64 ?? 0} + set {_uniqueStorage()._optionalInt64 = newValue} + } + /// Returns true if `optionalInt64` has been explicitly set. + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} + /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} + + var optionalUint32: UInt32 { + get {_storage._optionalUint32 ?? 0} + set {_uniqueStorage()._optionalUint32 = newValue} + } + /// Returns true if `optionalUint32` has been explicitly set. + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} + /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} + + var optionalUint64: UInt64 { + get {_storage._optionalUint64 ?? 0} + set {_uniqueStorage()._optionalUint64 = newValue} + } + /// Returns true if `optionalUint64` has been explicitly set. + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} + /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} + + var optionalSint32: Int32 { + get {_storage._optionalSint32 ?? 0} + set {_uniqueStorage()._optionalSint32 = newValue} + } + /// Returns true if `optionalSint32` has been explicitly set. + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} + /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} + + var optionalSint64: Int64 { + get {_storage._optionalSint64 ?? 0} + set {_uniqueStorage()._optionalSint64 = newValue} + } + /// Returns true if `optionalSint64` has been explicitly set. + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} + /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} + + var optionalFixed32: UInt32 { + get {_storage._optionalFixed32 ?? 0} + set {_uniqueStorage()._optionalFixed32 = newValue} + } + /// Returns true if `optionalFixed32` has been explicitly set. + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} + /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} + + var optionalFixed64: UInt64 { + get {_storage._optionalFixed64 ?? 0} + set {_uniqueStorage()._optionalFixed64 = newValue} + } + /// Returns true if `optionalFixed64` has been explicitly set. + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} + /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} + + var optionalSfixed32: Int32 { + get {_storage._optionalSfixed32 ?? 0} + set {_uniqueStorage()._optionalSfixed32 = newValue} + } + /// Returns true if `optionalSfixed32` has been explicitly set. + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} + /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} + + var optionalSfixed64: Int64 { + get {_storage._optionalSfixed64 ?? 0} + set {_uniqueStorage()._optionalSfixed64 = newValue} + } + /// Returns true if `optionalSfixed64` has been explicitly set. + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} + /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} + + var optionalFloat: Float { + get {_storage._optionalFloat ?? 0} + set {_uniqueStorage()._optionalFloat = newValue} + } + /// Returns true if `optionalFloat` has been explicitly set. + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} + /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} + + var optionalDouble: Double { + get {_storage._optionalDouble ?? 0} + set {_uniqueStorage()._optionalDouble = newValue} + } + /// Returns true if `optionalDouble` has been explicitly set. + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} + /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. + mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} + + var optionalBool: Bool { + get {_storage._optionalBool ?? false} + set {_uniqueStorage()._optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {_storage._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} + + var optionalString: String { + get {_storage._optionalString ?? String()} + set {_uniqueStorage()._optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {_storage._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} + + var optionalBytes: Data { + get {_storage._optionalBytes ?? Data()} + set {_uniqueStorage()._optionalBytes = newValue} + } + /// Returns true if `optionalBytes` has been explicitly set. + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} + /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} + + var optionalNestedMessage: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage { + get {_storage._optionalNestedMessage ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage()} + set {_uniqueStorage()._optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} + + var optionalForeignMessage: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2 { + get {_storage._optionalForeignMessage ?? ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2()} + set {_uniqueStorage()._optionalForeignMessage = newValue} + } + /// Returns true if `optionalForeignMessage` has been explicitly set. + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} + /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} + + var optionalNestedEnum: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum { + get {_storage._optionalNestedEnum ?? .foo} + set {_uniqueStorage()._optionalNestedEnum = newValue} + } + /// Returns true if `optionalNestedEnum` has been explicitly set. + var hasOptionalNestedEnum: Bool {_storage._optionalNestedEnum != nil} + /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} + + var optionalForeignEnum: ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2 { + get {_storage._optionalForeignEnum ?? .foreignFoo} + set {_uniqueStorage()._optionalForeignEnum = newValue} + } + /// Returns true if `optionalForeignEnum` has been explicitly set. + var hasOptionalForeignEnum: Bool {_storage._optionalForeignEnum != nil} + /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignEnum() {_uniqueStorage()._optionalForeignEnum = nil} + + var optionalStringPiece: String { + get {_storage._optionalStringPiece ?? String()} + set {_uniqueStorage()._optionalStringPiece = newValue} + } + /// Returns true if `optionalStringPiece` has been explicitly set. + var hasOptionalStringPiece: Bool {_storage._optionalStringPiece != nil} + /// Clears the value of `optionalStringPiece`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringPiece() {_uniqueStorage()._optionalStringPiece = nil} + + var optionalCord: String { + get {_storage._optionalCord ?? String()} + set {_uniqueStorage()._optionalCord = newValue} + } + /// Returns true if `optionalCord` has been explicitly set. + var hasOptionalCord: Bool {_storage._optionalCord != nil} + /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. + mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} + + var recursiveMessage: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2 { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2()} + set {_uniqueStorage()._recursiveMessage = newValue} + } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} + + /// Repeated + var repeatedInt32: [Int32] { + get {_storage._repeatedInt32} + set {_uniqueStorage()._repeatedInt32 = newValue} + } + + var repeatedInt64: [Int64] { + get {_storage._repeatedInt64} + set {_uniqueStorage()._repeatedInt64 = newValue} + } + + var repeatedUint32: [UInt32] { + get {_storage._repeatedUint32} + set {_uniqueStorage()._repeatedUint32 = newValue} + } + + var repeatedUint64: [UInt64] { + get {_storage._repeatedUint64} + set {_uniqueStorage()._repeatedUint64 = newValue} + } + + var repeatedSint32: [Int32] { + get {_storage._repeatedSint32} + set {_uniqueStorage()._repeatedSint32 = newValue} + } + + var repeatedSint64: [Int64] { + get {_storage._repeatedSint64} + set {_uniqueStorage()._repeatedSint64 = newValue} + } + + var repeatedFixed32: [UInt32] { + get {_storage._repeatedFixed32} + set {_uniqueStorage()._repeatedFixed32 = newValue} + } + + var repeatedFixed64: [UInt64] { + get {_storage._repeatedFixed64} + set {_uniqueStorage()._repeatedFixed64 = newValue} + } + + var repeatedSfixed32: [Int32] { + get {_storage._repeatedSfixed32} + set {_uniqueStorage()._repeatedSfixed32 = newValue} + } + + var repeatedSfixed64: [Int64] { + get {_storage._repeatedSfixed64} + set {_uniqueStorage()._repeatedSfixed64 = newValue} + } + + var repeatedFloat: [Float] { + get {_storage._repeatedFloat} + set {_uniqueStorage()._repeatedFloat = newValue} + } + + var repeatedDouble: [Double] { + get {_storage._repeatedDouble} + set {_uniqueStorage()._repeatedDouble = newValue} + } + + var repeatedBool: [Bool] { + get {_storage._repeatedBool} + set {_uniqueStorage()._repeatedBool = newValue} + } + + var repeatedString: [String] { + get {_storage._repeatedString} + set {_uniqueStorage()._repeatedString = newValue} + } + + var repeatedBytes: [Data] { + get {_storage._repeatedBytes} + set {_uniqueStorage()._repeatedBytes = newValue} + } + + var repeatedNestedMessage: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage] { + get {_storage._repeatedNestedMessage} + set {_uniqueStorage()._repeatedNestedMessage = newValue} + } + + var repeatedForeignMessage: [ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2] { + get {_storage._repeatedForeignMessage} + set {_uniqueStorage()._repeatedForeignMessage = newValue} + } + + var repeatedNestedEnum: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum] { + get {_storage._repeatedNestedEnum} + set {_uniqueStorage()._repeatedNestedEnum = newValue} + } + + var repeatedForeignEnum: [ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2] { + get {_storage._repeatedForeignEnum} + set {_uniqueStorage()._repeatedForeignEnum = newValue} + } + + var repeatedStringPiece: [String] { + get {_storage._repeatedStringPiece} + set {_uniqueStorage()._repeatedStringPiece = newValue} + } + + var repeatedCord: [String] { + get {_storage._repeatedCord} + set {_uniqueStorage()._repeatedCord = newValue} + } + + /// Packed + var packedInt32: [Int32] { + get {_storage._packedInt32} + set {_uniqueStorage()._packedInt32 = newValue} + } + + var packedInt64: [Int64] { + get {_storage._packedInt64} + set {_uniqueStorage()._packedInt64 = newValue} + } + + var packedUint32: [UInt32] { + get {_storage._packedUint32} + set {_uniqueStorage()._packedUint32 = newValue} + } + + var packedUint64: [UInt64] { + get {_storage._packedUint64} + set {_uniqueStorage()._packedUint64 = newValue} + } + + var packedSint32: [Int32] { + get {_storage._packedSint32} + set {_uniqueStorage()._packedSint32 = newValue} + } + + var packedSint64: [Int64] { + get {_storage._packedSint64} + set {_uniqueStorage()._packedSint64 = newValue} + } + + var packedFixed32: [UInt32] { + get {_storage._packedFixed32} + set {_uniqueStorage()._packedFixed32 = newValue} + } + + var packedFixed64: [UInt64] { + get {_storage._packedFixed64} + set {_uniqueStorage()._packedFixed64 = newValue} + } + + var packedSfixed32: [Int32] { + get {_storage._packedSfixed32} + set {_uniqueStorage()._packedSfixed32 = newValue} + } + + var packedSfixed64: [Int64] { + get {_storage._packedSfixed64} + set {_uniqueStorage()._packedSfixed64 = newValue} + } + + var packedFloat: [Float] { + get {_storage._packedFloat} + set {_uniqueStorage()._packedFloat = newValue} + } + + var packedDouble: [Double] { + get {_storage._packedDouble} + set {_uniqueStorage()._packedDouble = newValue} + } + + var packedBool: [Bool] { + get {_storage._packedBool} + set {_uniqueStorage()._packedBool = newValue} + } + + var packedNestedEnum: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum] { + get {_storage._packedNestedEnum} + set {_uniqueStorage()._packedNestedEnum = newValue} + } + + /// Unpacked + var unpackedInt32: [Int32] { + get {_storage._unpackedInt32} + set {_uniqueStorage()._unpackedInt32 = newValue} + } + + var unpackedInt64: [Int64] { + get {_storage._unpackedInt64} + set {_uniqueStorage()._unpackedInt64 = newValue} + } + + var unpackedUint32: [UInt32] { + get {_storage._unpackedUint32} + set {_uniqueStorage()._unpackedUint32 = newValue} + } + + var unpackedUint64: [UInt64] { + get {_storage._unpackedUint64} + set {_uniqueStorage()._unpackedUint64 = newValue} + } + + var unpackedSint32: [Int32] { + get {_storage._unpackedSint32} + set {_uniqueStorage()._unpackedSint32 = newValue} + } + + var unpackedSint64: [Int64] { + get {_storage._unpackedSint64} + set {_uniqueStorage()._unpackedSint64 = newValue} + } + + var unpackedFixed32: [UInt32] { + get {_storage._unpackedFixed32} + set {_uniqueStorage()._unpackedFixed32 = newValue} + } + + var unpackedFixed64: [UInt64] { + get {_storage._unpackedFixed64} + set {_uniqueStorage()._unpackedFixed64 = newValue} + } + + var unpackedSfixed32: [Int32] { + get {_storage._unpackedSfixed32} + set {_uniqueStorage()._unpackedSfixed32 = newValue} + } + + var unpackedSfixed64: [Int64] { + get {_storage._unpackedSfixed64} + set {_uniqueStorage()._unpackedSfixed64 = newValue} + } + + var unpackedFloat: [Float] { + get {_storage._unpackedFloat} + set {_uniqueStorage()._unpackedFloat = newValue} + } + + var unpackedDouble: [Double] { + get {_storage._unpackedDouble} + set {_uniqueStorage()._unpackedDouble = newValue} + } + + var unpackedBool: [Bool] { + get {_storage._unpackedBool} + set {_uniqueStorage()._unpackedBool = newValue} + } + + var unpackedNestedEnum: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum] { + get {_storage._unpackedNestedEnum} + set {_uniqueStorage()._unpackedNestedEnum = newValue} + } + + /// Map + var mapInt32Int32: Dictionary { + get {_storage._mapInt32Int32} + set {_uniqueStorage()._mapInt32Int32 = newValue} + } + + var mapInt64Int64: Dictionary { + get {_storage._mapInt64Int64} + set {_uniqueStorage()._mapInt64Int64 = newValue} + } + + var mapUint32Uint32: Dictionary { + get {_storage._mapUint32Uint32} + set {_uniqueStorage()._mapUint32Uint32 = newValue} + } + + var mapUint64Uint64: Dictionary { + get {_storage._mapUint64Uint64} + set {_uniqueStorage()._mapUint64Uint64 = newValue} + } + + var mapSint32Sint32: Dictionary { + get {_storage._mapSint32Sint32} + set {_uniqueStorage()._mapSint32Sint32 = newValue} + } + + var mapSint64Sint64: Dictionary { + get {_storage._mapSint64Sint64} + set {_uniqueStorage()._mapSint64Sint64 = newValue} + } + + var mapFixed32Fixed32: Dictionary { + get {_storage._mapFixed32Fixed32} + set {_uniqueStorage()._mapFixed32Fixed32 = newValue} + } + + var mapFixed64Fixed64: Dictionary { + get {_storage._mapFixed64Fixed64} + set {_uniqueStorage()._mapFixed64Fixed64 = newValue} + } + + var mapSfixed32Sfixed32: Dictionary { + get {_storage._mapSfixed32Sfixed32} + set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} + } + + var mapSfixed64Sfixed64: Dictionary { + get {_storage._mapSfixed64Sfixed64} + set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} + } + + var mapInt32Bool: Dictionary { + get {_storage._mapInt32Bool} + set {_uniqueStorage()._mapInt32Bool = newValue} + } + + var mapInt32Float: Dictionary { + get {_storage._mapInt32Float} + set {_uniqueStorage()._mapInt32Float = newValue} + } + + var mapInt32Double: Dictionary { + get {_storage._mapInt32Double} + set {_uniqueStorage()._mapInt32Double = newValue} + } + + var mapInt32NestedMessage: Dictionary { + get {_storage._mapInt32NestedMessage} + set {_uniqueStorage()._mapInt32NestedMessage = newValue} + } + + var mapBoolBool: Dictionary { + get {_storage._mapBoolBool} + set {_uniqueStorage()._mapBoolBool = newValue} + } + + var mapStringString: Dictionary { + get {_storage._mapStringString} + set {_uniqueStorage()._mapStringString = newValue} + } + + var mapStringBytes: Dictionary { + get {_storage._mapStringBytes} + set {_uniqueStorage()._mapStringBytes = newValue} + } + + var mapStringNestedMessage: Dictionary { + get {_storage._mapStringNestedMessage} + set {_uniqueStorage()._mapStringNestedMessage = newValue} + } + + var mapStringForeignMessage: Dictionary { + get {_storage._mapStringForeignMessage} + set {_uniqueStorage()._mapStringForeignMessage = newValue} + } + + var mapStringNestedEnum: Dictionary { + get {_storage._mapStringNestedEnum} + set {_uniqueStorage()._mapStringNestedEnum = newValue} + } + + var mapStringForeignEnum: Dictionary { + get {_storage._mapStringForeignEnum} + set {_uniqueStorage()._mapStringForeignEnum = newValue} + } + + var oneofField: OneOf_OneofField? { + get {return _storage._oneofField} + set {_uniqueStorage()._oneofField = newValue} + } + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} + } + + var oneofNestedMessage: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage { + get { + if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} + return ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = _storage._oneofField {return v} + return Data() + } + set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} + } + + var oneofBool: Bool { + get { + if case .oneofBool(let v)? = _storage._oneofField {return v} + return false + } + set {_uniqueStorage()._oneofField = .oneofBool(newValue)} + } + + var oneofUint64: UInt64 { + get { + if case .oneofUint64(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint64(newValue)} + } + + var oneofFloat: Float { + get { + if case .oneofFloat(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofFloat(newValue)} + } + + var oneofDouble: Double { + get { + if case .oneofDouble(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofDouble(newValue)} + } + + var oneofEnum: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum { + get { + if case .oneofEnum(let v)? = _storage._oneofField {return v} + return .foo + } + set {_uniqueStorage()._oneofField = .oneofEnum(newValue)} + } + + var data: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.DataMessage { + get {_storage._data ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.DataMessage()} + set {_uniqueStorage()._data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {_storage._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {_uniqueStorage()._data = nil} + + var multiWordGroupField: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MultiWordGroupField { + get {_storage._multiWordGroupField ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MultiWordGroupField()} + set {_uniqueStorage()._multiWordGroupField = newValue} + } + /// Returns true if `multiWordGroupField` has been explicitly set. + var hasMultiWordGroupField: Bool {_storage._multiWordGroupField != nil} + /// Clears the value of `multiWordGroupField`. Subsequent reads from it will return its default value. + mutating func clearMultiWordGroupField() {_uniqueStorage()._multiWordGroupField = nil} + + /// default values + var defaultInt32: Int32 { + get {_storage._defaultInt32 ?? -123456789} + set {_uniqueStorage()._defaultInt32 = newValue} + } + /// Returns true if `defaultInt32` has been explicitly set. + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} + /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} + + var defaultInt64: Int64 { + get {_storage._defaultInt64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultInt64 = newValue} + } + /// Returns true if `defaultInt64` has been explicitly set. + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} + /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} + + var defaultUint32: UInt32 { + get {_storage._defaultUint32 ?? 2123456789} + set {_uniqueStorage()._defaultUint32 = newValue} + } + /// Returns true if `defaultUint32` has been explicitly set. + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} + /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} + + var defaultUint64: UInt64 { + get {_storage._defaultUint64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultUint64 = newValue} + } + /// Returns true if `defaultUint64` has been explicitly set. + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} + /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} + + var defaultSint32: Int32 { + get {_storage._defaultSint32 ?? -123456789} + set {_uniqueStorage()._defaultSint32 = newValue} + } + /// Returns true if `defaultSint32` has been explicitly set. + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} + /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} + + var defaultSint64: Int64 { + get {_storage._defaultSint64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSint64 = newValue} + } + /// Returns true if `defaultSint64` has been explicitly set. + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} + /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} + + var defaultFixed32: UInt32 { + get {_storage._defaultFixed32 ?? 2123456789} + set {_uniqueStorage()._defaultFixed32 = newValue} + } + /// Returns true if `defaultFixed32` has been explicitly set. + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} + /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} + + var defaultFixed64: UInt64 { + get {_storage._defaultFixed64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultFixed64 = newValue} + } + /// Returns true if `defaultFixed64` has been explicitly set. + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} + /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} + + var defaultSfixed32: Int32 { + get {_storage._defaultSfixed32 ?? -123456789} + set {_uniqueStorage()._defaultSfixed32 = newValue} + } + /// Returns true if `defaultSfixed32` has been explicitly set. + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} + /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} + + var defaultSfixed64: Int64 { + get {_storage._defaultSfixed64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSfixed64 = newValue} + } + /// Returns true if `defaultSfixed64` has been explicitly set. + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} + /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} + + var defaultFloat: Float { + get {_storage._defaultFloat ?? 9e+09} + set {_uniqueStorage()._defaultFloat = newValue} + } + /// Returns true if `defaultFloat` has been explicitly set. + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} + /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. + mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} + + var defaultDouble: Double { + get {_storage._defaultDouble ?? 7e+22} + set {_uniqueStorage()._defaultDouble = newValue} + } + /// Returns true if `defaultDouble` has been explicitly set. + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} + /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. + mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} + + var defaultBool: Bool { + get {_storage._defaultBool ?? true} + set {_uniqueStorage()._defaultBool = newValue} + } + /// Returns true if `defaultBool` has been explicitly set. + var hasDefaultBool: Bool {_storage._defaultBool != nil} + /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. + mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} + + var defaultString: String { + get {_storage._defaultString ?? "Rosebud"} + set {_uniqueStorage()._defaultString = newValue} + } + /// Returns true if `defaultString` has been explicitly set. + var hasDefaultString: Bool {_storage._defaultString != nil} + /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. + mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} + + var defaultBytes: Data { + get {_storage._defaultBytes ?? Data([106, 111, 115, 104, 117, 97])} + set {_uniqueStorage()._defaultBytes = newValue} + } + /// Returns true if `defaultBytes` has been explicitly set. + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} + /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. + mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} + + /// Test field-name-to-JSON-name convention. + /// (protobuf says names can be any valid C/C++ identifier.) + var fieldname1: Int32 { + get {_storage._fieldname1 ?? 0} + set {_uniqueStorage()._fieldname1 = newValue} + } + /// Returns true if `fieldname1` has been explicitly set. + var hasFieldname1: Bool {_storage._fieldname1 != nil} + /// Clears the value of `fieldname1`. Subsequent reads from it will return its default value. + mutating func clearFieldname1() {_uniqueStorage()._fieldname1 = nil} + + var fieldName2: Int32 { + get {_storage._fieldName2 ?? 0} + set {_uniqueStorage()._fieldName2 = newValue} + } + /// Returns true if `fieldName2` has been explicitly set. + var hasFieldName2: Bool {_storage._fieldName2 != nil} + /// Clears the value of `fieldName2`. Subsequent reads from it will return its default value. + mutating func clearFieldName2() {_uniqueStorage()._fieldName2 = nil} + + var fieldName3: Int32 { + get {_storage._fieldName3 ?? 0} + set {_uniqueStorage()._fieldName3 = newValue} + } + /// Returns true if `fieldName3` has been explicitly set. + var hasFieldName3: Bool {_storage._fieldName3 != nil} + /// Clears the value of `fieldName3`. Subsequent reads from it will return its default value. + mutating func clearFieldName3() {_uniqueStorage()._fieldName3 = nil} + + var field_Name4_: Int32 { + get {_storage._field_Name4_ ?? 0} + set {_uniqueStorage()._field_Name4_ = newValue} + } + /// Returns true if `field_Name4_` has been explicitly set. + var hasField_Name4_: Bool {_storage._field_Name4_ != nil} + /// Clears the value of `field_Name4_`. Subsequent reads from it will return its default value. + mutating func clearField_Name4_() {_uniqueStorage()._field_Name4_ = nil} + + var field0Name5: Int32 { + get {_storage._field0Name5 ?? 0} + set {_uniqueStorage()._field0Name5 = newValue} + } + /// Returns true if `field0Name5` has been explicitly set. + var hasField0Name5: Bool {_storage._field0Name5 != nil} + /// Clears the value of `field0Name5`. Subsequent reads from it will return its default value. + mutating func clearField0Name5() {_uniqueStorage()._field0Name5 = nil} + + var field0Name6: Int32 { + get {_storage._field0Name6 ?? 0} + set {_uniqueStorage()._field0Name6 = newValue} + } + /// Returns true if `field0Name6` has been explicitly set. + var hasField0Name6: Bool {_storage._field0Name6 != nil} + /// Clears the value of `field0Name6`. Subsequent reads from it will return its default value. + mutating func clearField0Name6() {_uniqueStorage()._field0Name6 = nil} + + var fieldName7: Int32 { + get {_storage._fieldName7 ?? 0} + set {_uniqueStorage()._fieldName7 = newValue} + } + /// Returns true if `fieldName7` has been explicitly set. + var hasFieldName7: Bool {_storage._fieldName7 != nil} + /// Clears the value of `fieldName7`. Subsequent reads from it will return its default value. + mutating func clearFieldName7() {_uniqueStorage()._fieldName7 = nil} + + var fieldName8: Int32 { + get {_storage._fieldName8 ?? 0} + set {_uniqueStorage()._fieldName8 = newValue} + } + /// Returns true if `fieldName8` has been explicitly set. + var hasFieldName8: Bool {_storage._fieldName8 != nil} + /// Clears the value of `fieldName8`. Subsequent reads from it will return its default value. + mutating func clearFieldName8() {_uniqueStorage()._fieldName8 = nil} + + var fieldName9: Int32 { + get {_storage._fieldName9 ?? 0} + set {_uniqueStorage()._fieldName9 = newValue} + } + /// Returns true if `fieldName9` has been explicitly set. + var hasFieldName9: Bool {_storage._fieldName9 != nil} + /// Clears the value of `fieldName9`. Subsequent reads from it will return its default value. + mutating func clearFieldName9() {_uniqueStorage()._fieldName9 = nil} + + var fieldName10: Int32 { + get {_storage._fieldName10 ?? 0} + set {_uniqueStorage()._fieldName10 = newValue} + } + /// Returns true if `fieldName10` has been explicitly set. + var hasFieldName10: Bool {_storage._fieldName10 != nil} + /// Clears the value of `fieldName10`. Subsequent reads from it will return its default value. + mutating func clearFieldName10() {_uniqueStorage()._fieldName10 = nil} + + var fieldName11: Int32 { + get {_storage._fieldName11 ?? 0} + set {_uniqueStorage()._fieldName11 = newValue} + } + /// Returns true if `fieldName11` has been explicitly set. + var hasFieldName11: Bool {_storage._fieldName11 != nil} + /// Clears the value of `fieldName11`. Subsequent reads from it will return its default value. + mutating func clearFieldName11() {_uniqueStorage()._fieldName11 = nil} + + var fieldName12: Int32 { + get {_storage._fieldName12 ?? 0} + set {_uniqueStorage()._fieldName12 = newValue} + } + /// Returns true if `fieldName12` has been explicitly set. + var hasFieldName12: Bool {_storage._fieldName12 != nil} + /// Clears the value of `fieldName12`. Subsequent reads from it will return its default value. + mutating func clearFieldName12() {_uniqueStorage()._fieldName12 = nil} + + var _FieldName13: Int32 { + get {_storage.__FieldName13 ?? 0} + set {_uniqueStorage().__FieldName13 = newValue} + } + /// Returns true if `_FieldName13` has been explicitly set. + var has_FieldName13: Bool {_storage.__FieldName13 != nil} + /// Clears the value of `_FieldName13`. Subsequent reads from it will return its default value. + mutating func clear_FieldName13() {_uniqueStorage().__FieldName13 = nil} + + var _FieldName14: Int32 { + get {_storage.__FieldName14 ?? 0} + set {_uniqueStorage().__FieldName14 = newValue} + } + /// Returns true if `_FieldName14` has been explicitly set. + var has_FieldName14: Bool {_storage.__FieldName14 != nil} + /// Clears the value of `_FieldName14`. Subsequent reads from it will return its default value. + mutating func clear_FieldName14() {_uniqueStorage().__FieldName14 = nil} + + var field_Name15: Int32 { + get {_storage._field_Name15 ?? 0} + set {_uniqueStorage()._field_Name15 = newValue} + } + /// Returns true if `field_Name15` has been explicitly set. + var hasField_Name15: Bool {_storage._field_Name15 != nil} + /// Clears the value of `field_Name15`. Subsequent reads from it will return its default value. + mutating func clearField_Name15() {_uniqueStorage()._field_Name15 = nil} + + var field_Name16: Int32 { + get {_storage._field_Name16 ?? 0} + set {_uniqueStorage()._field_Name16 = newValue} + } + /// Returns true if `field_Name16` has been explicitly set. + var hasField_Name16: Bool {_storage._field_Name16 != nil} + /// Clears the value of `field_Name16`. Subsequent reads from it will return its default value. + mutating func clearField_Name16() {_uniqueStorage()._field_Name16 = nil} + + var fieldName17__: Int32 { + get {_storage._fieldName17__ ?? 0} + set {_uniqueStorage()._fieldName17__ = newValue} + } + /// Returns true if `fieldName17__` has been explicitly set. + var hasFieldName17__: Bool {_storage._fieldName17__ != nil} + /// Clears the value of `fieldName17__`. Subsequent reads from it will return its default value. + mutating func clearFieldName17__() {_uniqueStorage()._fieldName17__ = nil} + + var fieldName18__: Int32 { + get {_storage._fieldName18__ ?? 0} + set {_uniqueStorage()._fieldName18__ = newValue} + } + /// Returns true if `fieldName18__` has been explicitly set. + var hasFieldName18__: Bool {_storage._fieldName18__ != nil} + /// Clears the value of `fieldName18__`. Subsequent reads from it will return its default value. + mutating func clearFieldName18__() {_uniqueStorage()._fieldName18__ = nil} + + var messageSetCorrect: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect { + get {_storage._messageSetCorrect ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect()} + set {_uniqueStorage()._messageSetCorrect = newValue} + } + /// Returns true if `messageSetCorrect` has been explicitly set. + var hasMessageSetCorrect: Bool {_storage._messageSetCorrect != nil} + /// Clears the value of `messageSetCorrect`. Subsequent reads from it will return its default value. + mutating func clearMessageSetCorrect() {_uniqueStorage()._messageSetCorrect = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofNestedMessage(ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage) + case oneofString(String) + case oneofBytes(Data) + case oneofBool(Bool) + case oneofUint64(UInt64) + case oneofFloat(Float) + case oneofDouble(Double) + case oneofEnum(ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum) + + fileprivate var isInitialized: Bool { + guard case .oneofNestedMessage(let v) = self else {return true} + return v.isInitialized + } + + } + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 + + /// Intentionally negative. + case neg = -1 + + init() { + self = .foo + } + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var corecursive: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2 { + get {_storage._corecursive ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + /// groups + struct DataMessage: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + struct MultiWordGroupField: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + /// message_set test case. + struct MessageSetCorrect: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() + } + + struct MessageSetCorrectExtension1: Sendable { + // 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 str: String { + get {_str ?? String()} + set {_str = newValue} + } + /// Returns true if `str` has been explicitly set. + var hasStr: Bool {self._str != nil} + /// Clears the value of `str`. Subsequent reads from it will return its default value. + mutating func clearStr() {self._str = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _str: String? = nil + } + + struct MessageSetCorrectExtension2: Sendable { + // 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 i: Int32 { + get {_i ?? 0} + set {_i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {self._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {self._i = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _i: Int32? = nil + } + + struct ExtensionWithOneof: Sendable { + // 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 oneofField: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.OneOf_OneofField? = nil + + var a: Int32 { + get { + if case .a(let v)? = oneofField {return v} + return 0 + } + set {oneofField = .a(newValue)} + } + + var b: Int32 { + get { + if case .b(let v)? = oneofField {return v} + return 0 + } + set {oneofField = .b(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case a(Int32) + case b(Int32) + + } + + init() {} + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2: Sendable { + // 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 c: Int32 { + get {_c ?? 0} + set {_c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {self._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {self._c = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _c: Int32? = nil +} + +struct ProtobufTestMessages_Editions_Proto2_GroupField: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil +} + +struct ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes: Sendable { + // 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 optionalInt32: Int32 { + get {_optionalInt32 ?? 0} + set {_optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {self._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {self._optionalInt32 = nil} + + var optionalString: String { + get {_optionalString ?? String()} + set {_optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {self._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {self._optionalString = nil} + + var nestedMessage: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2 { + get {_nestedMessage ?? ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2()} + set {_nestedMessage = newValue} + } + /// Returns true if `nestedMessage` has been explicitly set. + var hasNestedMessage: Bool {self._nestedMessage != nil} + /// Clears the value of `nestedMessage`. Subsequent reads from it will return its default value. + mutating func clearNestedMessage() {self._nestedMessage = nil} + + var optionalGroup: ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.OptionalGroup { + get {_optionalGroup ?? ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.OptionalGroup()} + set {_optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {self._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {self._optionalGroup = nil} + + var optionalBool: Bool { + get {_optionalBool ?? false} + set {_optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {self._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {self._optionalBool = nil} + + var repeatedInt32: [Int32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct OptionalGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + init() {} + + fileprivate var _optionalInt32: Int32? = nil + fileprivate var _optionalString: String? = nil + fileprivate var _nestedMessage: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2? = nil + fileprivate var _optionalGroup: ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.OptionalGroup? = nil + fileprivate var _optionalBool: Bool? = nil +} + +struct ProtobufTestMessages_Editions_Proto2_NullHypothesisProto2: Sendable { + // 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 ProtobufTestMessages_Editions_Proto2_EnumOnlyProto2: Sendable { + // 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() + + enum BoolEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case kFalse = 0 + case kTrue = 1 + + init() { + self = .kFalse + } + + } + + init() {} +} + +struct ProtobufTestMessages_Editions_Proto2_OneStringProto2: Sendable { + // 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 data: String { + get {_data ?? String()} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: String? = nil +} + +struct ProtobufTestMessages_Editions_Proto2_ProtoWithKeywords: Sendable { + // 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 inline: Int32 { + get {_inline ?? 0} + set {_inline = newValue} + } + /// Returns true if `inline` has been explicitly set. + var hasInline: Bool {self._inline != nil} + /// Clears the value of `inline`. Subsequent reads from it will return its default value. + mutating func clearInline() {self._inline = nil} + + var concept: String { + get {_concept ?? String()} + set {_concept = newValue} + } + /// Returns true if `concept` has been explicitly set. + var hasConcept: Bool {self._concept != nil} + /// Clears the value of `concept`. Subsequent reads from it will return its default value. + mutating func clearConcept() {self._concept = nil} + + var requires: [String] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _inline: Int32? = nil + fileprivate var _concept: String? = nil +} + +struct ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Singular + var requiredInt32: Int32 { + get {_storage._requiredInt32 ?? 0} + set {_uniqueStorage()._requiredInt32 = newValue} + } + /// Returns true if `requiredInt32` has been explicitly set. + var hasRequiredInt32: Bool {_storage._requiredInt32 != nil} + /// Clears the value of `requiredInt32`. Subsequent reads from it will return its default value. + mutating func clearRequiredInt32() {_uniqueStorage()._requiredInt32 = nil} + + var requiredInt64: Int64 { + get {_storage._requiredInt64 ?? 0} + set {_uniqueStorage()._requiredInt64 = newValue} + } + /// Returns true if `requiredInt64` has been explicitly set. + var hasRequiredInt64: Bool {_storage._requiredInt64 != nil} + /// Clears the value of `requiredInt64`. Subsequent reads from it will return its default value. + mutating func clearRequiredInt64() {_uniqueStorage()._requiredInt64 = nil} + + var requiredUint32: UInt32 { + get {_storage._requiredUint32 ?? 0} + set {_uniqueStorage()._requiredUint32 = newValue} + } + /// Returns true if `requiredUint32` has been explicitly set. + var hasRequiredUint32: Bool {_storage._requiredUint32 != nil} + /// Clears the value of `requiredUint32`. Subsequent reads from it will return its default value. + mutating func clearRequiredUint32() {_uniqueStorage()._requiredUint32 = nil} + + var requiredUint64: UInt64 { + get {_storage._requiredUint64 ?? 0} + set {_uniqueStorage()._requiredUint64 = newValue} + } + /// Returns true if `requiredUint64` has been explicitly set. + var hasRequiredUint64: Bool {_storage._requiredUint64 != nil} + /// Clears the value of `requiredUint64`. Subsequent reads from it will return its default value. + mutating func clearRequiredUint64() {_uniqueStorage()._requiredUint64 = nil} + + var requiredSint32: Int32 { + get {_storage._requiredSint32 ?? 0} + set {_uniqueStorage()._requiredSint32 = newValue} + } + /// Returns true if `requiredSint32` has been explicitly set. + var hasRequiredSint32: Bool {_storage._requiredSint32 != nil} + /// Clears the value of `requiredSint32`. Subsequent reads from it will return its default value. + mutating func clearRequiredSint32() {_uniqueStorage()._requiredSint32 = nil} + + var requiredSint64: Int64 { + get {_storage._requiredSint64 ?? 0} + set {_uniqueStorage()._requiredSint64 = newValue} + } + /// Returns true if `requiredSint64` has been explicitly set. + var hasRequiredSint64: Bool {_storage._requiredSint64 != nil} + /// Clears the value of `requiredSint64`. Subsequent reads from it will return its default value. + mutating func clearRequiredSint64() {_uniqueStorage()._requiredSint64 = nil} + + var requiredFixed32: UInt32 { + get {_storage._requiredFixed32 ?? 0} + set {_uniqueStorage()._requiredFixed32 = newValue} + } + /// Returns true if `requiredFixed32` has been explicitly set. + var hasRequiredFixed32: Bool {_storage._requiredFixed32 != nil} + /// Clears the value of `requiredFixed32`. Subsequent reads from it will return its default value. + mutating func clearRequiredFixed32() {_uniqueStorage()._requiredFixed32 = nil} + + var requiredFixed64: UInt64 { + get {_storage._requiredFixed64 ?? 0} + set {_uniqueStorage()._requiredFixed64 = newValue} + } + /// Returns true if `requiredFixed64` has been explicitly set. + var hasRequiredFixed64: Bool {_storage._requiredFixed64 != nil} + /// Clears the value of `requiredFixed64`. Subsequent reads from it will return its default value. + mutating func clearRequiredFixed64() {_uniqueStorage()._requiredFixed64 = nil} + + var requiredSfixed32: Int32 { + get {_storage._requiredSfixed32 ?? 0} + set {_uniqueStorage()._requiredSfixed32 = newValue} + } + /// Returns true if `requiredSfixed32` has been explicitly set. + var hasRequiredSfixed32: Bool {_storage._requiredSfixed32 != nil} + /// Clears the value of `requiredSfixed32`. Subsequent reads from it will return its default value. + mutating func clearRequiredSfixed32() {_uniqueStorage()._requiredSfixed32 = nil} + + var requiredSfixed64: Int64 { + get {_storage._requiredSfixed64 ?? 0} + set {_uniqueStorage()._requiredSfixed64 = newValue} + } + /// Returns true if `requiredSfixed64` has been explicitly set. + var hasRequiredSfixed64: Bool {_storage._requiredSfixed64 != nil} + /// Clears the value of `requiredSfixed64`. Subsequent reads from it will return its default value. + mutating func clearRequiredSfixed64() {_uniqueStorage()._requiredSfixed64 = nil} + + var requiredFloat: Float { + get {_storage._requiredFloat ?? 0} + set {_uniqueStorage()._requiredFloat = newValue} + } + /// Returns true if `requiredFloat` has been explicitly set. + var hasRequiredFloat: Bool {_storage._requiredFloat != nil} + /// Clears the value of `requiredFloat`. Subsequent reads from it will return its default value. + mutating func clearRequiredFloat() {_uniqueStorage()._requiredFloat = nil} + + var requiredDouble: Double { + get {_storage._requiredDouble ?? 0} + set {_uniqueStorage()._requiredDouble = newValue} + } + /// Returns true if `requiredDouble` has been explicitly set. + var hasRequiredDouble: Bool {_storage._requiredDouble != nil} + /// Clears the value of `requiredDouble`. Subsequent reads from it will return its default value. + mutating func clearRequiredDouble() {_uniqueStorage()._requiredDouble = nil} + + var requiredBool: Bool { + get {_storage._requiredBool ?? false} + set {_uniqueStorage()._requiredBool = newValue} + } + /// Returns true if `requiredBool` has been explicitly set. + var hasRequiredBool: Bool {_storage._requiredBool != nil} + /// Clears the value of `requiredBool`. Subsequent reads from it will return its default value. + mutating func clearRequiredBool() {_uniqueStorage()._requiredBool = nil} + + var requiredString: String { + get {_storage._requiredString ?? String()} + set {_uniqueStorage()._requiredString = newValue} + } + /// Returns true if `requiredString` has been explicitly set. + var hasRequiredString: Bool {_storage._requiredString != nil} + /// Clears the value of `requiredString`. Subsequent reads from it will return its default value. + mutating func clearRequiredString() {_uniqueStorage()._requiredString = nil} + + var requiredBytes: Data { + get {_storage._requiredBytes ?? Data()} + set {_uniqueStorage()._requiredBytes = newValue} + } + /// Returns true if `requiredBytes` has been explicitly set. + var hasRequiredBytes: Bool {_storage._requiredBytes != nil} + /// Clears the value of `requiredBytes`. Subsequent reads from it will return its default value. + mutating func clearRequiredBytes() {_uniqueStorage()._requiredBytes = nil} + + var requiredNestedMessage: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedMessage { + get {_storage._requiredNestedMessage ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedMessage()} + set {_uniqueStorage()._requiredNestedMessage = newValue} + } + /// Returns true if `requiredNestedMessage` has been explicitly set. + var hasRequiredNestedMessage: Bool {_storage._requiredNestedMessage != nil} + /// Clears the value of `requiredNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearRequiredNestedMessage() {_uniqueStorage()._requiredNestedMessage = nil} + + var requiredForeignMessage: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2 { + get {_storage._requiredForeignMessage ?? ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2()} + set {_uniqueStorage()._requiredForeignMessage = newValue} + } + /// Returns true if `requiredForeignMessage` has been explicitly set. + var hasRequiredForeignMessage: Bool {_storage._requiredForeignMessage != nil} + /// Clears the value of `requiredForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearRequiredForeignMessage() {_uniqueStorage()._requiredForeignMessage = nil} + + var requiredNestedEnum: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedEnum { + get {_storage._requiredNestedEnum ?? .foo} + set {_uniqueStorage()._requiredNestedEnum = newValue} + } + /// Returns true if `requiredNestedEnum` has been explicitly set. + var hasRequiredNestedEnum: Bool {_storage._requiredNestedEnum != nil} + /// Clears the value of `requiredNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredNestedEnum() {_uniqueStorage()._requiredNestedEnum = nil} + + var requiredForeignEnum: ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2 { + get {_storage._requiredForeignEnum ?? .foreignFoo} + set {_uniqueStorage()._requiredForeignEnum = newValue} + } + /// Returns true if `requiredForeignEnum` has been explicitly set. + var hasRequiredForeignEnum: Bool {_storage._requiredForeignEnum != nil} + /// Clears the value of `requiredForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredForeignEnum() {_uniqueStorage()._requiredForeignEnum = nil} + + var requiredStringPiece: String { + get {_storage._requiredStringPiece ?? String()} + set {_uniqueStorage()._requiredStringPiece = newValue} + } + /// Returns true if `requiredStringPiece` has been explicitly set. + var hasRequiredStringPiece: Bool {_storage._requiredStringPiece != nil} + /// Clears the value of `requiredStringPiece`. Subsequent reads from it will return its default value. + mutating func clearRequiredStringPiece() {_uniqueStorage()._requiredStringPiece = nil} + + var requiredCord: String { + get {_storage._requiredCord ?? String()} + set {_uniqueStorage()._requiredCord = newValue} + } + /// Returns true if `requiredCord` has been explicitly set. + var hasRequiredCord: Bool {_storage._requiredCord != nil} + /// Clears the value of `requiredCord`. Subsequent reads from it will return its default value. + mutating func clearRequiredCord() {_uniqueStorage()._requiredCord = nil} + + var recursiveMessage: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2 { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._recursiveMessage = newValue} + } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} + + var optionalRecursiveMessage: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2 { + get {_storage._optionalRecursiveMessage ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._optionalRecursiveMessage = newValue} + } + /// Returns true if `optionalRecursiveMessage` has been explicitly set. + var hasOptionalRecursiveMessage: Bool {_storage._optionalRecursiveMessage != nil} + /// Clears the value of `optionalRecursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalRecursiveMessage() {_uniqueStorage()._optionalRecursiveMessage = nil} + + var data: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.DataMessage { + get {_storage._data ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.DataMessage()} + set {_uniqueStorage()._data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {_storage._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {_uniqueStorage()._data = nil} + + /// default values + var defaultInt32: Int32 { + get {_storage._defaultInt32 ?? -123456789} + set {_uniqueStorage()._defaultInt32 = newValue} + } + /// Returns true if `defaultInt32` has been explicitly set. + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} + /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} + + var defaultInt64: Int64 { + get {_storage._defaultInt64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultInt64 = newValue} + } + /// Returns true if `defaultInt64` has been explicitly set. + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} + /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} + + var defaultUint32: UInt32 { + get {_storage._defaultUint32 ?? 2123456789} + set {_uniqueStorage()._defaultUint32 = newValue} + } + /// Returns true if `defaultUint32` has been explicitly set. + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} + /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} + + var defaultUint64: UInt64 { + get {_storage._defaultUint64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultUint64 = newValue} + } + /// Returns true if `defaultUint64` has been explicitly set. + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} + /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} + + var defaultSint32: Int32 { + get {_storage._defaultSint32 ?? -123456789} + set {_uniqueStorage()._defaultSint32 = newValue} + } + /// Returns true if `defaultSint32` has been explicitly set. + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} + /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} + + var defaultSint64: Int64 { + get {_storage._defaultSint64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSint64 = newValue} + } + /// Returns true if `defaultSint64` has been explicitly set. + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} + /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} + + var defaultFixed32: UInt32 { + get {_storage._defaultFixed32 ?? 2123456789} + set {_uniqueStorage()._defaultFixed32 = newValue} + } + /// Returns true if `defaultFixed32` has been explicitly set. + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} + /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} + + var defaultFixed64: UInt64 { + get {_storage._defaultFixed64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultFixed64 = newValue} + } + /// Returns true if `defaultFixed64` has been explicitly set. + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} + /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} + + var defaultSfixed32: Int32 { + get {_storage._defaultSfixed32 ?? -123456789} + set {_uniqueStorage()._defaultSfixed32 = newValue} + } + /// Returns true if `defaultSfixed32` has been explicitly set. + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} + /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} + + var defaultSfixed64: Int64 { + get {_storage._defaultSfixed64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSfixed64 = newValue} + } + /// Returns true if `defaultSfixed64` has been explicitly set. + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} + /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} + + var defaultFloat: Float { + get {_storage._defaultFloat ?? 9e+09} + set {_uniqueStorage()._defaultFloat = newValue} + } + /// Returns true if `defaultFloat` has been explicitly set. + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} + /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. + mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} + + var defaultDouble: Double { + get {_storage._defaultDouble ?? 7e+22} + set {_uniqueStorage()._defaultDouble = newValue} + } + /// Returns true if `defaultDouble` has been explicitly set. + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} + /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. + mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} + + var defaultBool: Bool { + get {_storage._defaultBool ?? true} + set {_uniqueStorage()._defaultBool = newValue} + } + /// Returns true if `defaultBool` has been explicitly set. + var hasDefaultBool: Bool {_storage._defaultBool != nil} + /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. + mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} + + var defaultString: String { + get {_storage._defaultString ?? "Rosebud"} + set {_uniqueStorage()._defaultString = newValue} + } + /// Returns true if `defaultString` has been explicitly set. + var hasDefaultString: Bool {_storage._defaultString != nil} + /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. + mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} + + var defaultBytes: Data { + get {_storage._defaultBytes ?? Data([106, 111, 115, 104, 117, 97])} + set {_uniqueStorage()._defaultBytes = newValue} + } + /// Returns true if `defaultBytes` has been explicitly set. + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} + /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. + mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 + + /// Intentionally negative. + case neg = -1 + + init() { + self = .foo + } + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var corecursive: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2 { + get {_storage._corecursive ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var optionalCorecursive: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2 { + get {_storage._optionalCorecursive ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._optionalCorecursive = newValue} + } + /// Returns true if `optionalCorecursive` has been explicitly set. + var hasOptionalCorecursive: Bool {_storage._optionalCorecursive != nil} + /// Clears the value of `optionalCorecursive`. Subsequent reads from it will return its default value. + mutating func clearOptionalCorecursive() {_uniqueStorage()._optionalCorecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + /// groups + struct DataMessage: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + /// message_set test case. + struct MessageSetCorrect: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() + } + + struct MessageSetCorrectExtension1: Sendable { + // 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 str: String { + get {_str ?? String()} + set {_str = newValue} + } + /// Returns true if `str` has been explicitly set. + var hasStr: Bool {self._str != nil} + /// Clears the value of `str`. Subsequent reads from it will return its default value. + mutating func clearStr() {self._str = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _str: String? = nil + } + + struct MessageSetCorrectExtension2: Sendable { + // 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 i: Int32 { + get {_i ?? 0} + set {_i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {self._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {self._i = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _i: Int32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct ProtobufTestMessages_Editions_Proto2_TestLargeOneof: Sendable { + // 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 largeOneof: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.OneOf_LargeOneof? = nil + + var a1: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1 { + get { + if case .a1(let v)? = largeOneof {return v} + return ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1() + } + set {largeOneof = .a1(newValue)} + } + + var a2: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2 { + get { + if case .a2(let v)? = largeOneof {return v} + return ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2() + } + set {largeOneof = .a2(newValue)} + } + + var a3: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3 { + get { + if case .a3(let v)? = largeOneof {return v} + return ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3() + } + set {largeOneof = .a3(newValue)} + } + + var a4: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4 { + get { + if case .a4(let v)? = largeOneof {return v} + return ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4() + } + set {largeOneof = .a4(newValue)} + } + + var a5: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5 { + get { + if case .a5(let v)? = largeOneof {return v} + return ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5() + } + set {largeOneof = .a5(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_LargeOneof: Equatable, Sendable { + case a1(ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1) + case a2(ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2) + case a3(ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3) + case a4(ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4) + case a5(ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5) + + } + + struct A1: Sendable { + // 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 A2: Sendable { + // 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 A3: Sendable { + // 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 A4: Sendable { + // 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 A5: Sendable { + // 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() {} + } + + init() {} +} + +// MARK: - Extension support defined in test_messages_proto2_editions.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect { + + var ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension1_messageSetExtension: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1 { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension1_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension2_messageSetExtension: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2 { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension2_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2 { + + var ProtobufTestMessages_Editions_Proto2_extensionInt32: Int32 { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32) ?? 0} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_extensionInt32: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_extensionInt32() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32) + } + + var ProtobufTestMessages_Editions_Proto2_groupField: ProtobufTestMessages_Editions_Proto2_GroupField { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_GroupField) ?? ProtobufTestMessages_Editions_Proto2_GroupField()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_GroupField, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_Extensions_GroupField` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_groupField: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_GroupField) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_Extensions_GroupField`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_groupField() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_GroupField) + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect { + + var ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1 { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2 { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_ExtensionWithOneof_extensionWithOneof: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof) ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_ExtensionWithOneof_extensionWithOneof: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_ExtensionWithOneof_extensionWithOneof() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof) + } + +} + +// MARK: - File's ExtensionMap: ProtobufTestMessages_Editions_Proto2_TestMessagesProto2Editions_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 ProtobufTestMessages_Editions_Proto2_TestMessagesProto2Editions_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32, + ProtobufTestMessages_Editions_Proto2_Extensions_GroupField, + ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, + ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, + ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof, + ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, + ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension +] + +// 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 ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32 = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2>( + _protobuf_fieldNumber: 120, + fieldName: "protobuf_test_messages.editions.proto2.extension_int32" +) + +let ProtobufTestMessages_Editions_Proto2_Extensions_GroupField = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2>( + _protobuf_fieldNumber: 121, + fieldName: "protobuf_test_messages.editions.proto2.groupfield" +) + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 1547769, + fieldName: "protobuf_test_messages.editions.proto2.TestAllTypesProto2.MessageSetCorrectExtension1" + ) + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 4135312, + fieldName: "protobuf_test_messages.editions.proto2.TestAllTypesProto2.MessageSetCorrectExtension2" + ) + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof { + enum Extensions { + static let extension_with_oneof = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 123456789, + fieldName: "protobuf_test_messages.editions.proto2.TestAllTypesProto2.ExtensionWithOneof" + ) + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 1547769, + fieldName: "protobuf_test_messages.editions.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension1" + ) + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 4135312, + fieldName: "protobuf_test_messages.editions.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension2" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "protobuf_test_messages.editions.proto2" + +extension ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypesProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{4}\u{2}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{4}\u{2}optional_string_piece\0\u{3}optional_cord\0\u{4}\u{2}recursive_message\0\u{4}\u{4}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{4}\u{2}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_nested_message\0\u{3}map_string_foreign_message\0\u{3}map_string_nested_enum\0\u{3}map_string_foreign_enum\0\u{3}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_nested_enum\0\u{3}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_nested_enum\0\u{3}map_int32_nested_message\0\u{3}map_int32_bool\0\u{4}\u{7}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_bool\0\u{3}oneof_uint64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_enum\0\u{8}R\u{1}Data\0\u{8}\u{3}MultiWordGroupField\0\u{4}%default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{2}R\u{2}fieldname1\0\u{3}field_name2\0\u{3}_field_name3\0\u{3}field__name4_\0\u{1}field0name5\0\u{3}field_0_name6\0\u{1}fieldName7\0\u{1}FieldName8\0\u{3}field_Name9\0\u{3}Field_Name10\0\u{3}FIELD_NAME11\0\u{3}FIELD_name12\0\u{3}__field_name13\0\u{3}__Field_name14\0\u{3}field__name15\0\u{3}field__Name16\0\u{3}field_name17__\0\u{3}Field_name18__\0\u{4}R\u{1}message_set_correct\0\u{b}reserved_field\0\u{c}h\u{f}hL\u{2}\u{c}\u{7f}Ht\u{3}\u{1}") + + fileprivate class _StorageClass { + var _optionalInt32: Int32? = nil + var _optionalInt64: Int64? = nil + var _optionalUint32: UInt32? = nil + var _optionalUint64: UInt64? = nil + var _optionalSint32: Int32? = nil + var _optionalSint64: Int64? = nil + var _optionalFixed32: UInt32? = nil + var _optionalFixed64: UInt64? = nil + var _optionalSfixed32: Int32? = nil + var _optionalSfixed64: Int64? = nil + var _optionalFloat: Float? = nil + var _optionalDouble: Double? = nil + var _optionalBool: Bool? = nil + var _optionalString: String? = nil + var _optionalBytes: Data? = nil + var _optionalNestedMessage: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage? = nil + var _optionalForeignMessage: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2? = nil + var _optionalNestedEnum: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum? = nil + var _optionalForeignEnum: ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2? = nil + var _optionalStringPiece: String? = nil + var _optionalCord: String? = nil + var _recursiveMessage: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2? = nil + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedNestedMessage: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage] = [] + var _repeatedForeignMessage: [ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2] = [] + var _repeatedNestedEnum: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _repeatedForeignEnum: [ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2] = [] + var _repeatedStringPiece: [String] = [] + var _repeatedCord: [String] = [] + var _packedInt32: [Int32] = [] + var _packedInt64: [Int64] = [] + var _packedUint32: [UInt32] = [] + var _packedUint64: [UInt64] = [] + var _packedSint32: [Int32] = [] + var _packedSint64: [Int64] = [] + var _packedFixed32: [UInt32] = [] + var _packedFixed64: [UInt64] = [] + var _packedSfixed32: [Int32] = [] + var _packedSfixed64: [Int64] = [] + var _packedFloat: [Float] = [] + var _packedDouble: [Double] = [] + var _packedBool: [Bool] = [] + var _packedNestedEnum: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _unpackedInt32: [Int32] = [] + var _unpackedInt64: [Int64] = [] + var _unpackedUint32: [UInt32] = [] + var _unpackedUint64: [UInt64] = [] + var _unpackedSint32: [Int32] = [] + var _unpackedSint64: [Int64] = [] + var _unpackedFixed32: [UInt32] = [] + var _unpackedFixed64: [UInt64] = [] + var _unpackedSfixed32: [Int32] = [] + var _unpackedSfixed64: [Int64] = [] + var _unpackedFloat: [Float] = [] + var _unpackedDouble: [Double] = [] + var _unpackedBool: [Bool] = [] + var _unpackedNestedEnum: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _mapInt32Int32: Dictionary = [:] + var _mapInt64Int64: Dictionary = [:] + var _mapUint32Uint32: Dictionary = [:] + var _mapUint64Uint64: Dictionary = [:] + var _mapSint32Sint32: Dictionary = [:] + var _mapSint64Sint64: Dictionary = [:] + var _mapFixed32Fixed32: Dictionary = [:] + var _mapFixed64Fixed64: Dictionary = [:] + var _mapSfixed32Sfixed32: Dictionary = [:] + var _mapSfixed64Sfixed64: Dictionary = [:] + var _mapInt32Bool: Dictionary = [:] + var _mapInt32Float: Dictionary = [:] + var _mapInt32Double: Dictionary = [:] + var _mapInt32NestedMessage: Dictionary = [:] + var _mapBoolBool: Dictionary = [:] + var _mapStringString: Dictionary = [:] + var _mapStringBytes: Dictionary = [:] + var _mapStringNestedMessage: Dictionary = [:] + var _mapStringForeignMessage: Dictionary = [:] + var _mapStringNestedEnum: Dictionary = [:] + var _mapStringForeignEnum: Dictionary = [:] + var _oneofField: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.OneOf_OneofField? + var _data: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.DataMessage? = nil + var _multiWordGroupField: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MultiWordGroupField? = nil + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + var _fieldname1: Int32? = nil + var _fieldName2: Int32? = nil + var _fieldName3: Int32? = nil + var _field_Name4_: Int32? = nil + var _field0Name5: Int32? = nil + var _field0Name6: Int32? = nil + var _fieldName7: Int32? = nil + var _fieldName8: Int32? = nil + var _fieldName9: Int32? = nil + var _fieldName10: Int32? = nil + var _fieldName11: Int32? = nil + var _fieldName12: Int32? = nil + var __FieldName13: Int32? = nil + var __FieldName14: Int32? = nil + var _field_Name15: Int32? = nil + var _field_Name16: Int32? = nil + var _fieldName17__: Int32? = nil + var _fieldName18__: Int32? = nil + var _messageSetCorrect: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalNestedMessage = source._optionalNestedMessage + _optionalForeignMessage = source._optionalForeignMessage + _optionalNestedEnum = source._optionalNestedEnum + _optionalForeignEnum = source._optionalForeignEnum + _optionalStringPiece = source._optionalStringPiece + _optionalCord = source._optionalCord + _recursiveMessage = source._recursiveMessage + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedForeignMessage = source._repeatedForeignMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _repeatedForeignEnum = source._repeatedForeignEnum + _repeatedStringPiece = source._repeatedStringPiece + _repeatedCord = source._repeatedCord + _packedInt32 = source._packedInt32 + _packedInt64 = source._packedInt64 + _packedUint32 = source._packedUint32 + _packedUint64 = source._packedUint64 + _packedSint32 = source._packedSint32 + _packedSint64 = source._packedSint64 + _packedFixed32 = source._packedFixed32 + _packedFixed64 = source._packedFixed64 + _packedSfixed32 = source._packedSfixed32 + _packedSfixed64 = source._packedSfixed64 + _packedFloat = source._packedFloat + _packedDouble = source._packedDouble + _packedBool = source._packedBool + _packedNestedEnum = source._packedNestedEnum + _unpackedInt32 = source._unpackedInt32 + _unpackedInt64 = source._unpackedInt64 + _unpackedUint32 = source._unpackedUint32 + _unpackedUint64 = source._unpackedUint64 + _unpackedSint32 = source._unpackedSint32 + _unpackedSint64 = source._unpackedSint64 + _unpackedFixed32 = source._unpackedFixed32 + _unpackedFixed64 = source._unpackedFixed64 + _unpackedSfixed32 = source._unpackedSfixed32 + _unpackedSfixed64 = source._unpackedSfixed64 + _unpackedFloat = source._unpackedFloat + _unpackedDouble = source._unpackedDouble + _unpackedBool = source._unpackedBool + _unpackedNestedEnum = source._unpackedNestedEnum + _mapInt32Int32 = source._mapInt32Int32 + _mapInt64Int64 = source._mapInt64Int64 + _mapUint32Uint32 = source._mapUint32Uint32 + _mapUint64Uint64 = source._mapUint64Uint64 + _mapSint32Sint32 = source._mapSint32Sint32 + _mapSint64Sint64 = source._mapSint64Sint64 + _mapFixed32Fixed32 = source._mapFixed32Fixed32 + _mapFixed64Fixed64 = source._mapFixed64Fixed64 + _mapSfixed32Sfixed32 = source._mapSfixed32Sfixed32 + _mapSfixed64Sfixed64 = source._mapSfixed64Sfixed64 + _mapInt32Bool = source._mapInt32Bool + _mapInt32Float = source._mapInt32Float + _mapInt32Double = source._mapInt32Double + _mapInt32NestedMessage = source._mapInt32NestedMessage + _mapBoolBool = source._mapBoolBool + _mapStringString = source._mapStringString + _mapStringBytes = source._mapStringBytes + _mapStringNestedMessage = source._mapStringNestedMessage + _mapStringForeignMessage = source._mapStringForeignMessage + _mapStringNestedEnum = source._mapStringNestedEnum + _mapStringForeignEnum = source._mapStringForeignEnum + _oneofField = source._oneofField + _data = source._data + _multiWordGroupField = source._multiWordGroupField + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + _fieldname1 = source._fieldname1 + _fieldName2 = source._fieldName2 + _fieldName3 = source._fieldName3 + _field_Name4_ = source._field_Name4_ + _field0Name5 = source._field0Name5 + _field0Name6 = source._field0Name6 + _fieldName7 = source._fieldName7 + _fieldName8 = source._fieldName8 + _fieldName9 = source._fieldName9 + _fieldName10 = source._fieldName10 + _fieldName11 = source._fieldName11 + _fieldName12 = source._fieldName12 + __FieldName13 = source.__FieldName13 + __FieldName14 = source.__FieldName14 + _field_Name15 = source._field_Name15 + _field_Name16 = source._field_Name16 + _fieldName17__ = source._fieldName17__ + _fieldName18__ = source._fieldName18__ + _messageSetCorrect = source._messageSetCorrect + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._optionalNestedMessage, !v.isInitialized {return false} + if let v = _storage._recursiveMessage, !v.isInitialized {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._repeatedNestedMessage) {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._mapInt32NestedMessage) {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._mapStringNestedMessage) {return false} + if let v = _storage._oneofField, !v.isInitialized {return false} + if let v = _storage._messageSetCorrect, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() + case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() + case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() + case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() + case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() + case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() + case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() + case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() + case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() + case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() + case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() + case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() + case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() + case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() + case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() + case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() + case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() + case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() + case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() + case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() + case 56: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Int32) }() + case 57: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() + case 58: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() + case 59: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Uint64) }() + case 60: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Sint32) }() + case 61: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Sint64) }() + case 62: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Fixed32) }() + case 63: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Fixed64) }() + case 64: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Sfixed32) }() + case 65: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Sfixed64) }() + case 66: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Float) }() + case 67: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Double) }() + case 68: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() + case 69: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() + case 70: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() + case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringNestedMessage) }() + case 72: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() + case 73: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringNestedEnum) }() + case 74: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringForeignEnum) }() + case 75: try { try decoder.decodeRepeatedInt32Field(value: &_storage._packedInt32) }() + case 76: try { try decoder.decodeRepeatedInt64Field(value: &_storage._packedInt64) }() + case 77: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._packedUint32) }() + case 78: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._packedUint64) }() + case 79: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._packedSint32) }() + case 80: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._packedSint64) }() + case 81: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._packedFixed32) }() + case 82: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._packedFixed64) }() + case 83: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._packedSfixed32) }() + case 84: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._packedSfixed64) }() + case 85: try { try decoder.decodeRepeatedFloatField(value: &_storage._packedFloat) }() + case 86: try { try decoder.decodeRepeatedDoubleField(value: &_storage._packedDouble) }() + case 87: try { try decoder.decodeRepeatedBoolField(value: &_storage._packedBool) }() + case 88: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedNestedEnum) }() + case 89: try { try decoder.decodeRepeatedInt32Field(value: &_storage._unpackedInt32) }() + case 90: try { try decoder.decodeRepeatedInt64Field(value: &_storage._unpackedInt64) }() + case 91: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._unpackedUint32) }() + case 92: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._unpackedUint64) }() + case 93: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._unpackedSint32) }() + case 94: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._unpackedSint64) }() + case 95: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._unpackedFixed32) }() + case 96: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._unpackedFixed64) }() + case 97: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._unpackedSfixed32) }() + case 98: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._unpackedSfixed64) }() + case 99: try { try decoder.decodeRepeatedFloatField(value: &_storage._unpackedFloat) }() + case 100: try { try decoder.decodeRepeatedDoubleField(value: &_storage._unpackedDouble) }() + case 101: try { try decoder.decodeRepeatedBoolField(value: &_storage._unpackedBool) }() + case 102: try { try decoder.decodeRepeatedEnumField(value: &_storage._unpackedNestedEnum) }() + case 103: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32NestedMessage) }() + case 104: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bool) }() + case 111: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 112: try { + var v: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage(v) + } + }() + case 113: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 114: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() + case 115: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBool(v) + } + }() + case 116: try { + var v: UInt64? + try decoder.decodeSingularUInt64Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint64(v) + } + }() + case 117: try { + var v: Float? + try decoder.decodeSingularFloatField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofFloat(v) + } + }() + case 118: try { + var v: Double? + try decoder.decodeSingularDoubleField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofDouble(v) + } + }() + case 119: try { + var v: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofEnum(v) + } + }() + case 201: try { try decoder.decodeSingularGroupField(value: &_storage._data) }() + case 204: try { try decoder.decodeSingularGroupField(value: &_storage._multiWordGroupField) }() + case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 242: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 243: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 244: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 245: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 246: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 247: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 248: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 249: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 250: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 251: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 252: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 253: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 254: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 255: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() + case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldname1) }() + case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName2) }() + case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName3) }() + case 404: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name4_) }() + case 405: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name5) }() + case 406: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name6) }() + case 407: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName7) }() + case 408: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName8) }() + case 409: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName9) }() + case 410: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName10) }() + case 411: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName11) }() + case 412: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName12) }() + case 413: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName13) }() + case 414: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName14) }() + case 415: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name15) }() + case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name16) }() + case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName17__) }() + case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName18__) }() + case 500: try { try decoder.decodeSingularMessageField(value: &_storage._messageSetCorrect) }() + case 120..<201: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._optionalInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._optionalUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._optionalSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._optionalSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._optionalFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._optionalFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._optionalSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._optionalSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._optionalFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._optionalDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._optionalBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._optionalForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._optionalNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._optionalForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._optionalStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._optionalCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + if !_storage._repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + } + if !_storage._repeatedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + } + if !_storage._repeatedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + } + if !_storage._repeatedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + } + if !_storage._repeatedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + } + if !_storage._repeatedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + } + if !_storage._repeatedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + } + if !_storage._repeatedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + } + if !_storage._repeatedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + } + if !_storage._repeatedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + } + if !_storage._repeatedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + } + if !_storage._repeatedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + } + if !_storage._repeatedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + } + if !_storage._repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) + } + if !_storage._repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) + } + if !_storage._repeatedNestedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) + } + if !_storage._repeatedForeignMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) + } + if !_storage._repeatedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + } + if !_storage._repeatedForeignEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) + } + if !_storage._repeatedStringPiece.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) + } + if !_storage._repeatedCord.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) + } + if !_storage._mapInt32Int32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Int32, fieldNumber: 56) + } + if !_storage._mapInt64Int64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Int64, fieldNumber: 57) + } + if !_storage._mapUint32Uint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Uint32, fieldNumber: 58) + } + if !_storage._mapUint64Uint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Uint64, fieldNumber: 59) + } + if !_storage._mapSint32Sint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Sint32, fieldNumber: 60) + } + if !_storage._mapSint64Sint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Sint64, fieldNumber: 61) + } + if !_storage._mapFixed32Fixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Fixed32, fieldNumber: 62) + } + if !_storage._mapFixed64Fixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Fixed64, fieldNumber: 63) + } + if !_storage._mapSfixed32Sfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 64) + } + if !_storage._mapSfixed64Sfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 65) + } + if !_storage._mapInt32Float.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Float, fieldNumber: 66) + } + if !_storage._mapInt32Double.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Double, fieldNumber: 67) + } + if !_storage._mapBoolBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolBool, fieldNumber: 68) + } + if !_storage._mapStringString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringString, fieldNumber: 69) + } + if !_storage._mapStringBytes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 70) + } + if !_storage._mapStringNestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringNestedMessage, fieldNumber: 71) + } + if !_storage._mapStringForeignMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 72) + } + if !_storage._mapStringNestedEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringNestedEnum, fieldNumber: 73) + } + if !_storage._mapStringForeignEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringForeignEnum, fieldNumber: 74) + } + if !_storage._packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._packedInt32, fieldNumber: 75) + } + if !_storage._packedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._packedInt64, fieldNumber: 76) + } + if !_storage._packedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._packedUint32, fieldNumber: 77) + } + if !_storage._packedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._packedUint64, fieldNumber: 78) + } + if !_storage._packedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._packedSint32, fieldNumber: 79) + } + if !_storage._packedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._packedSint64, fieldNumber: 80) + } + if !_storage._packedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._packedFixed32, fieldNumber: 81) + } + if !_storage._packedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._packedFixed64, fieldNumber: 82) + } + if !_storage._packedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._packedSfixed32, fieldNumber: 83) + } + if !_storage._packedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._packedSfixed64, fieldNumber: 84) + } + if !_storage._packedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._packedFloat, fieldNumber: 85) + } + if !_storage._packedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._packedDouble, fieldNumber: 86) + } + if !_storage._packedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._packedBool, fieldNumber: 87) + } + if !_storage._packedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedNestedEnum, fieldNumber: 88) + } + if !_storage._unpackedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._unpackedInt32, fieldNumber: 89) + } + if !_storage._unpackedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._unpackedInt64, fieldNumber: 90) + } + if !_storage._unpackedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._unpackedUint32, fieldNumber: 91) + } + if !_storage._unpackedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._unpackedUint64, fieldNumber: 92) + } + if !_storage._unpackedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._unpackedSint32, fieldNumber: 93) + } + if !_storage._unpackedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._unpackedSint64, fieldNumber: 94) + } + if !_storage._unpackedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._unpackedFixed32, fieldNumber: 95) + } + if !_storage._unpackedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._unpackedFixed64, fieldNumber: 96) + } + if !_storage._unpackedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._unpackedSfixed32, fieldNumber: 97) + } + if !_storage._unpackedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._unpackedSfixed64, fieldNumber: 98) + } + if !_storage._unpackedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._unpackedFloat, fieldNumber: 99) + } + if !_storage._unpackedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._unpackedDouble, fieldNumber: 100) + } + if !_storage._unpackedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._unpackedBool, fieldNumber: 101) + } + if !_storage._unpackedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._unpackedNestedEnum, fieldNumber: 102) + } + if !_storage._mapInt32NestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32NestedMessage, fieldNumber: 103) + } + if !_storage._mapInt32Bool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bool, fieldNumber: 104) + } + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case .oneofBool?: try { + guard case .oneofBool(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 115) + }() + case .oneofUint64?: try { + guard case .oneofUint64(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 116) + }() + case .oneofFloat?: try { + guard case .oneofFloat(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularFloatField(value: v, fieldNumber: 117) + }() + case .oneofDouble?: try { + guard case .oneofDouble(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularDoubleField(value: v, fieldNumber: 118) + }() + case .oneofEnum?: try { + guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 119) + }() + case nil: break + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201) + try { if let v = _storage._data { + try visitor.visitSingularGroupField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._multiWordGroupField { + try visitor.visitSingularGroupField(value: v, fieldNumber: 204) + } }() + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 241) + } }() + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 242) + } }() + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 243) + } }() + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 244) + } }() + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 245) + } }() + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 246) + } }() + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 247) + } }() + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 248) + } }() + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 249) + } }() + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 250) + } }() + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 251) + } }() + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 252) + } }() + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 253) + } }() + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 254) + } }() + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 255) + } }() + try { if let v = _storage._fieldname1 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 401) + } }() + try { if let v = _storage._fieldName2 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 402) + } }() + try { if let v = _storage._fieldName3 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 403) + } }() + try { if let v = _storage._field_Name4_ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 404) + } }() + try { if let v = _storage._field0Name5 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 405) + } }() + try { if let v = _storage._field0Name6 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 406) + } }() + try { if let v = _storage._fieldName7 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 407) + } }() + try { if let v = _storage._fieldName8 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 408) + } }() + try { if let v = _storage._fieldName9 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 409) + } }() + try { if let v = _storage._fieldName10 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 410) + } }() + try { if let v = _storage._fieldName11 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 411) + } }() + try { if let v = _storage._fieldName12 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 412) + } }() + try { if let v = _storage.__FieldName13 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 413) + } }() + try { if let v = _storage.__FieldName14 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 414) + } }() + try { if let v = _storage._field_Name15 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 415) + } }() + try { if let v = _storage._field_Name16 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 416) + } }() + try { if let v = _storage._fieldName17__ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 417) + } }() + try { if let v = _storage._fieldName18__ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 418) + } }() + try { if let v = _storage._messageSetCorrect { + try visitor.visitSingularMessageField(value: v, fieldNumber: 500) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} + if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} + if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} + if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} + if _storage._repeatedCord != rhs_storage._repeatedCord {return false} + if _storage._packedInt32 != rhs_storage._packedInt32 {return false} + if _storage._packedInt64 != rhs_storage._packedInt64 {return false} + if _storage._packedUint32 != rhs_storage._packedUint32 {return false} + if _storage._packedUint64 != rhs_storage._packedUint64 {return false} + if _storage._packedSint32 != rhs_storage._packedSint32 {return false} + if _storage._packedSint64 != rhs_storage._packedSint64 {return false} + if _storage._packedFixed32 != rhs_storage._packedFixed32 {return false} + if _storage._packedFixed64 != rhs_storage._packedFixed64 {return false} + if _storage._packedSfixed32 != rhs_storage._packedSfixed32 {return false} + if _storage._packedSfixed64 != rhs_storage._packedSfixed64 {return false} + if _storage._packedFloat != rhs_storage._packedFloat {return false} + if _storage._packedDouble != rhs_storage._packedDouble {return false} + if _storage._packedBool != rhs_storage._packedBool {return false} + if _storage._packedNestedEnum != rhs_storage._packedNestedEnum {return false} + if _storage._unpackedInt32 != rhs_storage._unpackedInt32 {return false} + if _storage._unpackedInt64 != rhs_storage._unpackedInt64 {return false} + if _storage._unpackedUint32 != rhs_storage._unpackedUint32 {return false} + if _storage._unpackedUint64 != rhs_storage._unpackedUint64 {return false} + if _storage._unpackedSint32 != rhs_storage._unpackedSint32 {return false} + if _storage._unpackedSint64 != rhs_storage._unpackedSint64 {return false} + if _storage._unpackedFixed32 != rhs_storage._unpackedFixed32 {return false} + if _storage._unpackedFixed64 != rhs_storage._unpackedFixed64 {return false} + if _storage._unpackedSfixed32 != rhs_storage._unpackedSfixed32 {return false} + if _storage._unpackedSfixed64 != rhs_storage._unpackedSfixed64 {return false} + if _storage._unpackedFloat != rhs_storage._unpackedFloat {return false} + if _storage._unpackedDouble != rhs_storage._unpackedDouble {return false} + if _storage._unpackedBool != rhs_storage._unpackedBool {return false} + if _storage._unpackedNestedEnum != rhs_storage._unpackedNestedEnum {return false} + if _storage._mapInt32Int32 != rhs_storage._mapInt32Int32 {return false} + if _storage._mapInt64Int64 != rhs_storage._mapInt64Int64 {return false} + if _storage._mapUint32Uint32 != rhs_storage._mapUint32Uint32 {return false} + if _storage._mapUint64Uint64 != rhs_storage._mapUint64Uint64 {return false} + if _storage._mapSint32Sint32 != rhs_storage._mapSint32Sint32 {return false} + if _storage._mapSint64Sint64 != rhs_storage._mapSint64Sint64 {return false} + if _storage._mapFixed32Fixed32 != rhs_storage._mapFixed32Fixed32 {return false} + if _storage._mapFixed64Fixed64 != rhs_storage._mapFixed64Fixed64 {return false} + if _storage._mapSfixed32Sfixed32 != rhs_storage._mapSfixed32Sfixed32 {return false} + if _storage._mapSfixed64Sfixed64 != rhs_storage._mapSfixed64Sfixed64 {return false} + if _storage._mapInt32Bool != rhs_storage._mapInt32Bool {return false} + if _storage._mapInt32Float != rhs_storage._mapInt32Float {return false} + if _storage._mapInt32Double != rhs_storage._mapInt32Double {return false} + if _storage._mapInt32NestedMessage != rhs_storage._mapInt32NestedMessage {return false} + if _storage._mapBoolBool != rhs_storage._mapBoolBool {return false} + if _storage._mapStringString != rhs_storage._mapStringString {return false} + if _storage._mapStringBytes != rhs_storage._mapStringBytes {return false} + if _storage._mapStringNestedMessage != rhs_storage._mapStringNestedMessage {return false} + if _storage._mapStringForeignMessage != rhs_storage._mapStringForeignMessage {return false} + if _storage._mapStringNestedEnum != rhs_storage._mapStringNestedEnum {return false} + if _storage._mapStringForeignEnum != rhs_storage._mapStringForeignEnum {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + if _storage._data != rhs_storage._data {return false} + if _storage._multiWordGroupField != rhs_storage._multiWordGroupField {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} + if _storage._fieldname1 != rhs_storage._fieldname1 {return false} + if _storage._fieldName2 != rhs_storage._fieldName2 {return false} + if _storage._fieldName3 != rhs_storage._fieldName3 {return false} + if _storage._field_Name4_ != rhs_storage._field_Name4_ {return false} + if _storage._field0Name5 != rhs_storage._field0Name5 {return false} + if _storage._field0Name6 != rhs_storage._field0Name6 {return false} + if _storage._fieldName7 != rhs_storage._fieldName7 {return false} + if _storage._fieldName8 != rhs_storage._fieldName8 {return false} + if _storage._fieldName9 != rhs_storage._fieldName9 {return false} + if _storage._fieldName10 != rhs_storage._fieldName10 {return false} + if _storage._fieldName11 != rhs_storage._fieldName11 {return false} + if _storage._fieldName12 != rhs_storage._fieldName12 {return false} + if _storage.__FieldName13 != rhs_storage.__FieldName13 {return false} + if _storage.__FieldName14 != rhs_storage.__FieldName14 {return false} + if _storage._field_Name15 != rhs_storage._field_Name15 {return false} + if _storage._field_Name16 != rhs_storage._field_Name16 {return false} + if _storage._fieldName17__ != rhs_storage._fieldName17__ {return false} + if _storage._fieldName18__ != rhs_storage._fieldName18__ {return false} + if _storage._messageSetCorrect != rhs_storage._messageSetCorrect {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _corecursive: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._corecursive, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}J\u{3}group_int32\0\u{3}group_uint32\0") + + 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 202: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 203: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 202) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 203) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.DataMessage, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.DataMessage) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MultiWordGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".MultiWordGroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}M\u{3}group_int32\0\u{3}group_uint32\0") + + 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 205: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 206: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 205) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 206) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MultiWordGroupField, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MultiWordGroupField) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect.self) + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrectExtension1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{19}str\0") + + 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 25: try { try decoder.decodeSingularStringField(value: &self._str) }() + 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 + try { if let v = self._str { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1) -> Bool { + if lhs._str != rhs._str {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrectExtension2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{9}i\0") + + 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 9: try { try decoder.decodeSingularInt32Field(value: &self._i) }() + 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 + try { if let v = self._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2) -> Bool { + if lhs._i != rhs._i {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".ExtensionWithOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .a(v) + } + }() + case 2: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .b(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.oneofField { + case .a?: try { + guard case .a(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + }() + case .b?: try { + guard case .b(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof) -> Bool { + if lhs.oneofField != rhs.oneofField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessageProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") + + 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._c) }() + 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 + try { if let v = self._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2, rhs: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2) -> Bool { + if lhs._c != rhs._c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_GroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}z\u{1}group_int32\0\u{3}group_uint32\0") + + 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 122: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 123: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 122) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 123) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_GroupField, rhs: ProtobufTestMessages_Editions_Proto2_GroupField) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".UnknownToTestAllTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}i\u{f}optional_int32\0\u{3}optional_string\0\u{3}nested_message\0\u{7}OptionalGroup\0\u{4}\u{2}optional_bool\0\u{4}\u{5}repeated_int32\0") + + 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 1001: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32) }() + case 1002: try { try decoder.decodeSingularStringField(value: &self._optionalString) }() + case 1003: try { try decoder.decodeSingularMessageField(value: &self._nestedMessage) }() + case 1004: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() + case 1006: try { try decoder.decodeSingularBoolField(value: &self._optionalBool) }() + case 1011: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() + 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 + try { if let v = self._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1001) + } }() + try { if let v = self._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1002) + } }() + try { if let v = self._nestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1003) + } }() + try { if let v = self._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 1004) + } }() + try { if let v = self._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1006) + } }() + if !self.repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 1011) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes, rhs: ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes) -> Bool { + if lhs._optionalInt32 != rhs._optionalInt32 {return false} + if lhs._optionalString != rhs._optionalString {return false} + if lhs._nestedMessage != rhs._nestedMessage {return false} + if lhs._optionalGroup != rhs._optionalGroup {return false} + if lhs._optionalBool != rhs._optionalBool {return false} + if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") + + 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._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.OptionalGroup, rhs: ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.OptionalGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_NullHypothesisProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NullHypothesisProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_NullHypothesisProto2, rhs: ProtobufTestMessages_Editions_Proto2_NullHypothesisProto2) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_EnumOnlyProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumOnlyProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_EnumOnlyProto2, rhs: ProtobufTestMessages_Editions_Proto2_EnumOnlyProto2) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_EnumOnlyProto2.BoolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0kFalse\0\u{1}kTrue\0") +} + +extension ProtobufTestMessages_Editions_Proto2_OneStringProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OneStringProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_OneStringProto2, rhs: ProtobufTestMessages_Editions_Proto2_OneStringProto2) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_ProtoWithKeywords: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ProtoWithKeywords" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}inline\0\u{1}concept\0\u{1}requires\0") + + 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._inline) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._concept) }() + case 3: try { try decoder.decodeRepeatedStringField(value: &self.requires) }() + 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 + try { if let v = self._inline { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._concept { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + if !self.requires.isEmpty { + try visitor.visitRepeatedStringField(value: self.requires, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_ProtoWithKeywords, rhs: ProtobufTestMessages_Editions_Proto2_ProtoWithKeywords) -> Bool { + if lhs._inline != rhs._inline {return false} + if lhs._concept != rhs._concept {return false} + if lhs.requires != rhs.requires {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllRequiredTypesProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_int32\0\u{3}required_int64\0\u{3}required_uint32\0\u{3}required_uint64\0\u{3}required_sint32\0\u{3}required_sint64\0\u{3}required_fixed32\0\u{3}required_fixed64\0\u{3}required_sfixed32\0\u{3}required_sfixed64\0\u{3}required_float\0\u{3}required_double\0\u{3}required_bool\0\u{3}required_string\0\u{3}required_bytes\0\u{4}\u{3}required_nested_message\0\u{3}required_foreign_message\0\u{4}\u{2}required_nested_enum\0\u{3}required_foreign_enum\0\u{4}\u{2}required_string_piece\0\u{3}required_cord\0\u{4}\u{2}recursive_message\0\u{3}optional_recursive_message\0\u{8}m\u{2}Data\0\u{4}(default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{c}h\u{f}hL\u{2}") + + fileprivate class _StorageClass { + var _requiredInt32: Int32? = nil + var _requiredInt64: Int64? = nil + var _requiredUint32: UInt32? = nil + var _requiredUint64: UInt64? = nil + var _requiredSint32: Int32? = nil + var _requiredSint64: Int64? = nil + var _requiredFixed32: UInt32? = nil + var _requiredFixed64: UInt64? = nil + var _requiredSfixed32: Int32? = nil + var _requiredSfixed64: Int64? = nil + var _requiredFloat: Float? = nil + var _requiredDouble: Double? = nil + var _requiredBool: Bool? = nil + var _requiredString: String? = nil + var _requiredBytes: Data? = nil + var _requiredNestedMessage: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedMessage? = nil + var _requiredForeignMessage: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2? = nil + var _requiredNestedEnum: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedEnum? = nil + var _requiredForeignEnum: ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2? = nil + var _requiredStringPiece: String? = nil + var _requiredCord: String? = nil + var _recursiveMessage: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2? = nil + var _optionalRecursiveMessage: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2? = nil + var _data: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.DataMessage? = nil + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _requiredInt32 = source._requiredInt32 + _requiredInt64 = source._requiredInt64 + _requiredUint32 = source._requiredUint32 + _requiredUint64 = source._requiredUint64 + _requiredSint32 = source._requiredSint32 + _requiredSint64 = source._requiredSint64 + _requiredFixed32 = source._requiredFixed32 + _requiredFixed64 = source._requiredFixed64 + _requiredSfixed32 = source._requiredSfixed32 + _requiredSfixed64 = source._requiredSfixed64 + _requiredFloat = source._requiredFloat + _requiredDouble = source._requiredDouble + _requiredBool = source._requiredBool + _requiredString = source._requiredString + _requiredBytes = source._requiredBytes + _requiredNestedMessage = source._requiredNestedMessage + _requiredForeignMessage = source._requiredForeignMessage + _requiredNestedEnum = source._requiredNestedEnum + _requiredForeignEnum = source._requiredForeignEnum + _requiredStringPiece = source._requiredStringPiece + _requiredCord = source._requiredCord + _recursiveMessage = source._recursiveMessage + _optionalRecursiveMessage = source._optionalRecursiveMessage + _data = source._data + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._requiredInt32 == nil {return false} + if _storage._requiredInt64 == nil {return false} + if _storage._requiredUint32 == nil {return false} + if _storage._requiredUint64 == nil {return false} + if _storage._requiredSint32 == nil {return false} + if _storage._requiredSint64 == nil {return false} + if _storage._requiredFixed32 == nil {return false} + if _storage._requiredFixed64 == nil {return false} + if _storage._requiredSfixed32 == nil {return false} + if _storage._requiredSfixed64 == nil {return false} + if _storage._requiredFloat == nil {return false} + if _storage._requiredDouble == nil {return false} + if _storage._requiredBool == nil {return false} + if _storage._requiredString == nil {return false} + if _storage._requiredBytes == nil {return false} + if _storage._requiredNestedMessage == nil {return false} + if _storage._requiredForeignMessage == nil {return false} + if _storage._requiredNestedEnum == nil {return false} + if _storage._requiredForeignEnum == nil {return false} + if _storage._requiredStringPiece == nil {return false} + if _storage._requiredCord == nil {return false} + if _storage._recursiveMessage == nil {return false} + if _storage._data == nil {return false} + if _storage._defaultInt32 == nil {return false} + if _storage._defaultInt64 == nil {return false} + if _storage._defaultUint32 == nil {return false} + if _storage._defaultUint64 == nil {return false} + if _storage._defaultSint32 == nil {return false} + if _storage._defaultSint64 == nil {return false} + if _storage._defaultFixed32 == nil {return false} + if _storage._defaultFixed64 == nil {return false} + if _storage._defaultSfixed32 == nil {return false} + if _storage._defaultSfixed64 == nil {return false} + if _storage._defaultFloat == nil {return false} + if _storage._defaultDouble == nil {return false} + if _storage._defaultBool == nil {return false} + if _storage._defaultString == nil {return false} + if _storage._defaultBytes == nil {return false} + if let v = _storage._requiredNestedMessage, !v.isInitialized {return false} + if let v = _storage._recursiveMessage, !v.isInitialized {return false} + if let v = _storage._optionalRecursiveMessage, !v.isInitialized {return false} + if let v = _storage._data, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._requiredInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._requiredInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._requiredUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._requiredUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._requiredSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._requiredSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._requiredFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._requiredFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._requiredSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._requiredSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._requiredFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._requiredDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._requiredBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._requiredString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._requiredBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._requiredNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._requiredForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._requiredNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._requiredForeignEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._requiredStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._requiredCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 28: try { try decoder.decodeSingularMessageField(value: &_storage._optionalRecursiveMessage) }() + case 201: try { try decoder.decodeSingularGroupField(value: &_storage._data) }() + case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 242: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 243: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 244: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 245: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 246: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 247: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 248: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 249: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 250: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 251: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 252: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 253: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 254: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 255: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() + case 120..<201: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._requiredInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._requiredInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._requiredUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._requiredUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._requiredSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._requiredSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._requiredFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._requiredFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._requiredSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._requiredSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._requiredFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._requiredDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._requiredBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._requiredString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._requiredBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._requiredNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._requiredForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._requiredNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._requiredForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._requiredStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._requiredCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + try { if let v = _storage._optionalRecursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 28) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201) + try { if let v = _storage._data { + try visitor.visitSingularGroupField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 241) + } }() + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 242) + } }() + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 243) + } }() + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 244) + } }() + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 245) + } }() + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 246) + } }() + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 247) + } }() + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 248) + } }() + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 249) + } }() + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 250) + } }() + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 251) + } }() + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 252) + } }() + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 253) + } }() + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 254) + } }() + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 255) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2, rhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2) -> 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._requiredInt32 != rhs_storage._requiredInt32 {return false} + if _storage._requiredInt64 != rhs_storage._requiredInt64 {return false} + if _storage._requiredUint32 != rhs_storage._requiredUint32 {return false} + if _storage._requiredUint64 != rhs_storage._requiredUint64 {return false} + if _storage._requiredSint32 != rhs_storage._requiredSint32 {return false} + if _storage._requiredSint64 != rhs_storage._requiredSint64 {return false} + if _storage._requiredFixed32 != rhs_storage._requiredFixed32 {return false} + if _storage._requiredFixed64 != rhs_storage._requiredFixed64 {return false} + if _storage._requiredSfixed32 != rhs_storage._requiredSfixed32 {return false} + if _storage._requiredSfixed64 != rhs_storage._requiredSfixed64 {return false} + if _storage._requiredFloat != rhs_storage._requiredFloat {return false} + if _storage._requiredDouble != rhs_storage._requiredDouble {return false} + if _storage._requiredBool != rhs_storage._requiredBool {return false} + if _storage._requiredString != rhs_storage._requiredString {return false} + if _storage._requiredBytes != rhs_storage._requiredBytes {return false} + if _storage._requiredNestedMessage != rhs_storage._requiredNestedMessage {return false} + if _storage._requiredForeignMessage != rhs_storage._requiredForeignMessage {return false} + if _storage._requiredNestedEnum != rhs_storage._requiredNestedEnum {return false} + if _storage._requiredForeignEnum != rhs_storage._requiredForeignEnum {return false} + if _storage._requiredStringPiece != rhs_storage._requiredStringPiece {return false} + if _storage._requiredCord != rhs_storage._requiredCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._optionalRecursiveMessage != rhs_storage._optionalRecursiveMessage {return false} + if _storage._data != rhs_storage._data {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0\u{3}optional_corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _corecursive: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2? = nil + var _optionalCorecursive: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + _optionalCorecursive = source._optionalCorecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._a == nil {return false} + if _storage._corecursive == nil {return false} + if let v = _storage._corecursive, !v.isInitialized {return false} + if let v = _storage._optionalCorecursive, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._optionalCorecursive) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalCorecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedMessage, rhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + if _storage._optionalCorecursive != rhs_storage._optionalCorecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}J\u{3}group_int32\0\u{3}group_uint32\0") + + public var isInitialized: Bool { + if self._groupInt32 == nil {return false} + if self._groupUint32 == nil {return false} + return true + } + + 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 202: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 203: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 202) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 203) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.DataMessage, rhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.DataMessage) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".MessageSetCorrect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect.self) + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect, rhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".MessageSetCorrectExtension1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{19}str\0") + + public var isInitialized: Bool { + if self._str == nil {return false} + return true + } + + 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 25: try { try decoder.decodeSingularStringField(value: &self._str) }() + 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 + try { if let v = self._str { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1, rhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1) -> Bool { + if lhs._str != rhs._str {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".MessageSetCorrectExtension2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{9}i\0") + + public var isInitialized: Bool { + if self._i == nil {return false} + return true + } + + 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 9: try { try decoder.decodeSingularInt32Field(value: &self._i) }() + 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 + try { if let v = self._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2, rhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2) -> Bool { + if lhs._i != rhs._i {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestLargeOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestLargeOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a1\0\u{1}a2\0\u{1}a3\0\u{1}a4\0\u{1}a5\0") + + 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: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a1(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a1(v) + } + }() + case 2: try { + var v: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a2(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a2(v) + } + }() + case 3: try { + var v: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a3(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a3(v) + } + }() + case 4: try { + var v: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a4(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a4(v) + } + }() + case 5: try { + var v: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a5(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a5(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.largeOneof { + case .a1?: try { + guard case .a1(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + }() + case .a2?: try { + guard case .a2(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + }() + case .a3?: try { + guard case .a3(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + }() + case .a4?: try { + guard case .a4(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + }() + case .a5?: try { + guard case .a5(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof, rhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof) -> Bool { + if lhs.largeOneof != rhs.largeOneof {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestLargeOneof.protoMessageName + ".A1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1, rhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestLargeOneof.protoMessageName + ".A2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2, rhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestLargeOneof.protoMessageName + ".A3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3, rhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestLargeOneof.protoMessageName + ".A4" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4, rhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestLargeOneof.protoMessageName + ".A5" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5, rhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/Sources/Conformance/editions/test_messages_proto3_editions.pb.swift b/Reference/Sources/Conformance/editions/test_messages_proto3_editions.pb.swift new file mode 100644 index 000000000..122771d23 --- /dev/null +++ b/Reference/Sources/Conformance/editions/test_messages_proto3_editions.pb.swift @@ -0,0 +1,2500 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: editions/test_messages_proto3_editions.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// clang-format off +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Test schema for proto3 messages. This test schema is used by: +// +// - benchmarks +// - fuzz tests +// - conformance tests + +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 ProtobufTestMessages_Editions_Proto3_ForeignEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foreignFoo // = 0 + case foreignBar // = 1 + case foreignBaz // = 2 + case UNRECOGNIZED(Int) + + init() { + self = .foreignFoo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .foreignFoo + case 1: self = .foreignBar + case 2: self = .foreignBaz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .foreignFoo: return 0 + case .foreignBar: return 1 + case .foreignBaz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Editions_Proto3_ForeignEnum] = [ + .foreignFoo, + .foreignBar, + .foreignBaz, + ] + +} + +/// This proto includes every type of field in both singular and repeated +/// forms. +/// +/// Also, crucially, all messages and enums in this file are eventually +/// submessages of this message. So for example, a fuzz test of TestAllTypes +/// could trigger bugs that occur in any message type in this file. We verify +/// this stays true in a unit test. +struct ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3: @unchecked Sendable { + // 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. + + /// Singular + /// test [kotlin] comment + var optionalInt32: Int32 { + get {_storage._optionalInt32} + set {_uniqueStorage()._optionalInt32 = newValue} + } + + var optionalInt64: Int64 { + get {_storage._optionalInt64} + set {_uniqueStorage()._optionalInt64 = newValue} + } + + var optionalUint32: UInt32 { + get {_storage._optionalUint32} + set {_uniqueStorage()._optionalUint32 = newValue} + } + + var optionalUint64: UInt64 { + get {_storage._optionalUint64} + set {_uniqueStorage()._optionalUint64 = newValue} + } + + var optionalSint32: Int32 { + get {_storage._optionalSint32} + set {_uniqueStorage()._optionalSint32 = newValue} + } + + var optionalSint64: Int64 { + get {_storage._optionalSint64} + set {_uniqueStorage()._optionalSint64 = newValue} + } + + var optionalFixed32: UInt32 { + get {_storage._optionalFixed32} + set {_uniqueStorage()._optionalFixed32 = newValue} + } + + var optionalFixed64: UInt64 { + get {_storage._optionalFixed64} + set {_uniqueStorage()._optionalFixed64 = newValue} + } + + var optionalSfixed32: Int32 { + get {_storage._optionalSfixed32} + set {_uniqueStorage()._optionalSfixed32 = newValue} + } + + var optionalSfixed64: Int64 { + get {_storage._optionalSfixed64} + set {_uniqueStorage()._optionalSfixed64 = newValue} + } + + var optionalFloat: Float { + get {_storage._optionalFloat} + set {_uniqueStorage()._optionalFloat = newValue} + } + + var optionalDouble: Double { + get {_storage._optionalDouble} + set {_uniqueStorage()._optionalDouble = newValue} + } + + var optionalBool: Bool { + get {_storage._optionalBool} + set {_uniqueStorage()._optionalBool = newValue} + } + + var optionalString: String { + get {_storage._optionalString} + set {_uniqueStorage()._optionalString = newValue} + } + + var optionalBytes: Data { + get {_storage._optionalBytes} + set {_uniqueStorage()._optionalBytes = newValue} + } + + var optionalNestedMessage: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage { + get {_storage._optionalNestedMessage ?? ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage()} + set {_uniqueStorage()._optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} + + var optionalForeignMessage: ProtobufTestMessages_Editions_Proto3_ForeignMessage { + get {_storage._optionalForeignMessage ?? ProtobufTestMessages_Editions_Proto3_ForeignMessage()} + set {_uniqueStorage()._optionalForeignMessage = newValue} + } + /// Returns true if `optionalForeignMessage` has been explicitly set. + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} + /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} + + var optionalNestedEnum: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum { + get {_storage._optionalNestedEnum} + set {_uniqueStorage()._optionalNestedEnum = newValue} + } + + var optionalForeignEnum: ProtobufTestMessages_Editions_Proto3_ForeignEnum { + get {_storage._optionalForeignEnum} + set {_uniqueStorage()._optionalForeignEnum = newValue} + } + + var optionalAliasedEnum: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.AliasedEnum { + get {_storage._optionalAliasedEnum} + set {_uniqueStorage()._optionalAliasedEnum = newValue} + } + + var optionalStringPiece: String { + get {_storage._optionalStringPiece} + set {_uniqueStorage()._optionalStringPiece = newValue} + } + + var optionalCord: String { + get {_storage._optionalCord} + set {_uniqueStorage()._optionalCord = newValue} + } + + var recursiveMessage: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3 { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3()} + set {_uniqueStorage()._recursiveMessage = newValue} + } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} + + /// Repeated + var repeatedInt32: [Int32] { + get {_storage._repeatedInt32} + set {_uniqueStorage()._repeatedInt32 = newValue} + } + + var repeatedInt64: [Int64] { + get {_storage._repeatedInt64} + set {_uniqueStorage()._repeatedInt64 = newValue} + } + + var repeatedUint32: [UInt32] { + get {_storage._repeatedUint32} + set {_uniqueStorage()._repeatedUint32 = newValue} + } + + var repeatedUint64: [UInt64] { + get {_storage._repeatedUint64} + set {_uniqueStorage()._repeatedUint64 = newValue} + } + + var repeatedSint32: [Int32] { + get {_storage._repeatedSint32} + set {_uniqueStorage()._repeatedSint32 = newValue} + } + + var repeatedSint64: [Int64] { + get {_storage._repeatedSint64} + set {_uniqueStorage()._repeatedSint64 = newValue} + } + + var repeatedFixed32: [UInt32] { + get {_storage._repeatedFixed32} + set {_uniqueStorage()._repeatedFixed32 = newValue} + } + + var repeatedFixed64: [UInt64] { + get {_storage._repeatedFixed64} + set {_uniqueStorage()._repeatedFixed64 = newValue} + } + + var repeatedSfixed32: [Int32] { + get {_storage._repeatedSfixed32} + set {_uniqueStorage()._repeatedSfixed32 = newValue} + } + + var repeatedSfixed64: [Int64] { + get {_storage._repeatedSfixed64} + set {_uniqueStorage()._repeatedSfixed64 = newValue} + } + + var repeatedFloat: [Float] { + get {_storage._repeatedFloat} + set {_uniqueStorage()._repeatedFloat = newValue} + } + + var repeatedDouble: [Double] { + get {_storage._repeatedDouble} + set {_uniqueStorage()._repeatedDouble = newValue} + } + + var repeatedBool: [Bool] { + get {_storage._repeatedBool} + set {_uniqueStorage()._repeatedBool = newValue} + } + + var repeatedString: [String] { + get {_storage._repeatedString} + set {_uniqueStorage()._repeatedString = newValue} + } + + var repeatedBytes: [Data] { + get {_storage._repeatedBytes} + set {_uniqueStorage()._repeatedBytes = newValue} + } + + var repeatedNestedMessage: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage] { + get {_storage._repeatedNestedMessage} + set {_uniqueStorage()._repeatedNestedMessage = newValue} + } + + var repeatedForeignMessage: [ProtobufTestMessages_Editions_Proto3_ForeignMessage] { + get {_storage._repeatedForeignMessage} + set {_uniqueStorage()._repeatedForeignMessage = newValue} + } + + var repeatedNestedEnum: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] { + get {_storage._repeatedNestedEnum} + set {_uniqueStorage()._repeatedNestedEnum = newValue} + } + + var repeatedForeignEnum: [ProtobufTestMessages_Editions_Proto3_ForeignEnum] { + get {_storage._repeatedForeignEnum} + set {_uniqueStorage()._repeatedForeignEnum = newValue} + } + + var repeatedStringPiece: [String] { + get {_storage._repeatedStringPiece} + set {_uniqueStorage()._repeatedStringPiece = newValue} + } + + var repeatedCord: [String] { + get {_storage._repeatedCord} + set {_uniqueStorage()._repeatedCord = newValue} + } + + /// Packed + var packedInt32: [Int32] { + get {_storage._packedInt32} + set {_uniqueStorage()._packedInt32 = newValue} + } + + var packedInt64: [Int64] { + get {_storage._packedInt64} + set {_uniqueStorage()._packedInt64 = newValue} + } + + var packedUint32: [UInt32] { + get {_storage._packedUint32} + set {_uniqueStorage()._packedUint32 = newValue} + } + + var packedUint64: [UInt64] { + get {_storage._packedUint64} + set {_uniqueStorage()._packedUint64 = newValue} + } + + var packedSint32: [Int32] { + get {_storage._packedSint32} + set {_uniqueStorage()._packedSint32 = newValue} + } + + var packedSint64: [Int64] { + get {_storage._packedSint64} + set {_uniqueStorage()._packedSint64 = newValue} + } + + var packedFixed32: [UInt32] { + get {_storage._packedFixed32} + set {_uniqueStorage()._packedFixed32 = newValue} + } + + var packedFixed64: [UInt64] { + get {_storage._packedFixed64} + set {_uniqueStorage()._packedFixed64 = newValue} + } + + var packedSfixed32: [Int32] { + get {_storage._packedSfixed32} + set {_uniqueStorage()._packedSfixed32 = newValue} + } + + var packedSfixed64: [Int64] { + get {_storage._packedSfixed64} + set {_uniqueStorage()._packedSfixed64 = newValue} + } + + var packedFloat: [Float] { + get {_storage._packedFloat} + set {_uniqueStorage()._packedFloat = newValue} + } + + var packedDouble: [Double] { + get {_storage._packedDouble} + set {_uniqueStorage()._packedDouble = newValue} + } + + var packedBool: [Bool] { + get {_storage._packedBool} + set {_uniqueStorage()._packedBool = newValue} + } + + var packedNestedEnum: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] { + get {_storage._packedNestedEnum} + set {_uniqueStorage()._packedNestedEnum = newValue} + } + + /// Unpacked + var unpackedInt32: [Int32] { + get {_storage._unpackedInt32} + set {_uniqueStorage()._unpackedInt32 = newValue} + } + + var unpackedInt64: [Int64] { + get {_storage._unpackedInt64} + set {_uniqueStorage()._unpackedInt64 = newValue} + } + + var unpackedUint32: [UInt32] { + get {_storage._unpackedUint32} + set {_uniqueStorage()._unpackedUint32 = newValue} + } + + var unpackedUint64: [UInt64] { + get {_storage._unpackedUint64} + set {_uniqueStorage()._unpackedUint64 = newValue} + } + + var unpackedSint32: [Int32] { + get {_storage._unpackedSint32} + set {_uniqueStorage()._unpackedSint32 = newValue} + } + + var unpackedSint64: [Int64] { + get {_storage._unpackedSint64} + set {_uniqueStorage()._unpackedSint64 = newValue} + } + + var unpackedFixed32: [UInt32] { + get {_storage._unpackedFixed32} + set {_uniqueStorage()._unpackedFixed32 = newValue} + } + + var unpackedFixed64: [UInt64] { + get {_storage._unpackedFixed64} + set {_uniqueStorage()._unpackedFixed64 = newValue} + } + + var unpackedSfixed32: [Int32] { + get {_storage._unpackedSfixed32} + set {_uniqueStorage()._unpackedSfixed32 = newValue} + } + + var unpackedSfixed64: [Int64] { + get {_storage._unpackedSfixed64} + set {_uniqueStorage()._unpackedSfixed64 = newValue} + } + + var unpackedFloat: [Float] { + get {_storage._unpackedFloat} + set {_uniqueStorage()._unpackedFloat = newValue} + } + + var unpackedDouble: [Double] { + get {_storage._unpackedDouble} + set {_uniqueStorage()._unpackedDouble = newValue} + } + + var unpackedBool: [Bool] { + get {_storage._unpackedBool} + set {_uniqueStorage()._unpackedBool = newValue} + } + + var unpackedNestedEnum: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] { + get {_storage._unpackedNestedEnum} + set {_uniqueStorage()._unpackedNestedEnum = newValue} + } + + /// Map + var mapInt32Int32: Dictionary { + get {_storage._mapInt32Int32} + set {_uniqueStorage()._mapInt32Int32 = newValue} + } + + var mapInt64Int64: Dictionary { + get {_storage._mapInt64Int64} + set {_uniqueStorage()._mapInt64Int64 = newValue} + } + + var mapUint32Uint32: Dictionary { + get {_storage._mapUint32Uint32} + set {_uniqueStorage()._mapUint32Uint32 = newValue} + } + + var mapUint64Uint64: Dictionary { + get {_storage._mapUint64Uint64} + set {_uniqueStorage()._mapUint64Uint64 = newValue} + } + + var mapSint32Sint32: Dictionary { + get {_storage._mapSint32Sint32} + set {_uniqueStorage()._mapSint32Sint32 = newValue} + } + + var mapSint64Sint64: Dictionary { + get {_storage._mapSint64Sint64} + set {_uniqueStorage()._mapSint64Sint64 = newValue} + } + + var mapFixed32Fixed32: Dictionary { + get {_storage._mapFixed32Fixed32} + set {_uniqueStorage()._mapFixed32Fixed32 = newValue} + } + + var mapFixed64Fixed64: Dictionary { + get {_storage._mapFixed64Fixed64} + set {_uniqueStorage()._mapFixed64Fixed64 = newValue} + } + + var mapSfixed32Sfixed32: Dictionary { + get {_storage._mapSfixed32Sfixed32} + set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} + } + + var mapSfixed64Sfixed64: Dictionary { + get {_storage._mapSfixed64Sfixed64} + set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} + } + + var mapInt32Float: Dictionary { + get {_storage._mapInt32Float} + set {_uniqueStorage()._mapInt32Float = newValue} + } + + var mapInt32Double: Dictionary { + get {_storage._mapInt32Double} + set {_uniqueStorage()._mapInt32Double = newValue} + } + + var mapBoolBool: Dictionary { + get {_storage._mapBoolBool} + set {_uniqueStorage()._mapBoolBool = newValue} + } + + var mapStringString: Dictionary { + get {_storage._mapStringString} + set {_uniqueStorage()._mapStringString = newValue} + } + + var mapStringBytes: Dictionary { + get {_storage._mapStringBytes} + set {_uniqueStorage()._mapStringBytes = newValue} + } + + var mapStringNestedMessage: Dictionary { + get {_storage._mapStringNestedMessage} + set {_uniqueStorage()._mapStringNestedMessage = newValue} + } + + var mapStringForeignMessage: Dictionary { + get {_storage._mapStringForeignMessage} + set {_uniqueStorage()._mapStringForeignMessage = newValue} + } + + var mapStringNestedEnum: Dictionary { + get {_storage._mapStringNestedEnum} + set {_uniqueStorage()._mapStringNestedEnum = newValue} + } + + var mapStringForeignEnum: Dictionary { + get {_storage._mapStringForeignEnum} + set {_uniqueStorage()._mapStringForeignEnum = newValue} + } + + var oneofField: OneOf_OneofField? { + get {return _storage._oneofField} + set {_uniqueStorage()._oneofField = newValue} + } + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} + } + + var oneofNestedMessage: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage { + get { + if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} + return ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = _storage._oneofField {return v} + return Data() + } + set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} + } + + var oneofBool: Bool { + get { + if case .oneofBool(let v)? = _storage._oneofField {return v} + return false + } + set {_uniqueStorage()._oneofField = .oneofBool(newValue)} + } + + var oneofUint64: UInt64 { + get { + if case .oneofUint64(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint64(newValue)} + } + + var oneofFloat: Float { + get { + if case .oneofFloat(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofFloat(newValue)} + } + + var oneofDouble: Double { + get { + if case .oneofDouble(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofDouble(newValue)} + } + + var oneofEnum: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum { + get { + if case .oneofEnum(let v)? = _storage._oneofField {return v} + return .foo + } + set {_uniqueStorage()._oneofField = .oneofEnum(newValue)} + } + + var oneofNullValue: SwiftProtobuf.Google_Protobuf_NullValue { + get { + if case .oneofNullValue(let v)? = _storage._oneofField {return v} + return .nullValue + } + set {_uniqueStorage()._oneofField = .oneofNullValue(newValue)} + } + + /// Well-known types + var optionalBoolWrapper: SwiftProtobuf.Google_Protobuf_BoolValue { + get {_storage._optionalBoolWrapper ?? SwiftProtobuf.Google_Protobuf_BoolValue()} + set {_uniqueStorage()._optionalBoolWrapper = newValue} + } + /// Returns true if `optionalBoolWrapper` has been explicitly set. + var hasOptionalBoolWrapper: Bool {_storage._optionalBoolWrapper != nil} + /// Clears the value of `optionalBoolWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalBoolWrapper() {_uniqueStorage()._optionalBoolWrapper = nil} + + var optionalInt32Wrapper: SwiftProtobuf.Google_Protobuf_Int32Value { + get {_storage._optionalInt32Wrapper ?? SwiftProtobuf.Google_Protobuf_Int32Value()} + set {_uniqueStorage()._optionalInt32Wrapper = newValue} + } + /// Returns true if `optionalInt32Wrapper` has been explicitly set. + var hasOptionalInt32Wrapper: Bool {_storage._optionalInt32Wrapper != nil} + /// Clears the value of `optionalInt32Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32Wrapper() {_uniqueStorage()._optionalInt32Wrapper = nil} + + var optionalInt64Wrapper: SwiftProtobuf.Google_Protobuf_Int64Value { + get {_storage._optionalInt64Wrapper ?? SwiftProtobuf.Google_Protobuf_Int64Value()} + set {_uniqueStorage()._optionalInt64Wrapper = newValue} + } + /// Returns true if `optionalInt64Wrapper` has been explicitly set. + var hasOptionalInt64Wrapper: Bool {_storage._optionalInt64Wrapper != nil} + /// Clears the value of `optionalInt64Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64Wrapper() {_uniqueStorage()._optionalInt64Wrapper = nil} + + var optionalUint32Wrapper: SwiftProtobuf.Google_Protobuf_UInt32Value { + get {_storage._optionalUint32Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} + set {_uniqueStorage()._optionalUint32Wrapper = newValue} + } + /// Returns true if `optionalUint32Wrapper` has been explicitly set. + var hasOptionalUint32Wrapper: Bool {_storage._optionalUint32Wrapper != nil} + /// Clears the value of `optionalUint32Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint32Wrapper() {_uniqueStorage()._optionalUint32Wrapper = nil} + + var optionalUint64Wrapper: SwiftProtobuf.Google_Protobuf_UInt64Value { + get {_storage._optionalUint64Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} + set {_uniqueStorage()._optionalUint64Wrapper = newValue} + } + /// Returns true if `optionalUint64Wrapper` has been explicitly set. + var hasOptionalUint64Wrapper: Bool {_storage._optionalUint64Wrapper != nil} + /// Clears the value of `optionalUint64Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint64Wrapper() {_uniqueStorage()._optionalUint64Wrapper = nil} + + var optionalFloatWrapper: SwiftProtobuf.Google_Protobuf_FloatValue { + get {_storage._optionalFloatWrapper ?? SwiftProtobuf.Google_Protobuf_FloatValue()} + set {_uniqueStorage()._optionalFloatWrapper = newValue} + } + /// Returns true if `optionalFloatWrapper` has been explicitly set. + var hasOptionalFloatWrapper: Bool {_storage._optionalFloatWrapper != nil} + /// Clears the value of `optionalFloatWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloatWrapper() {_uniqueStorage()._optionalFloatWrapper = nil} + + var optionalDoubleWrapper: SwiftProtobuf.Google_Protobuf_DoubleValue { + get {_storage._optionalDoubleWrapper ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} + set {_uniqueStorage()._optionalDoubleWrapper = newValue} + } + /// Returns true if `optionalDoubleWrapper` has been explicitly set. + var hasOptionalDoubleWrapper: Bool {_storage._optionalDoubleWrapper != nil} + /// Clears the value of `optionalDoubleWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalDoubleWrapper() {_uniqueStorage()._optionalDoubleWrapper = nil} + + var optionalStringWrapper: SwiftProtobuf.Google_Protobuf_StringValue { + get {_storage._optionalStringWrapper ?? SwiftProtobuf.Google_Protobuf_StringValue()} + set {_uniqueStorage()._optionalStringWrapper = newValue} + } + /// Returns true if `optionalStringWrapper` has been explicitly set. + var hasOptionalStringWrapper: Bool {_storage._optionalStringWrapper != nil} + /// Clears the value of `optionalStringWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringWrapper() {_uniqueStorage()._optionalStringWrapper = nil} + + var optionalBytesWrapper: SwiftProtobuf.Google_Protobuf_BytesValue { + get {_storage._optionalBytesWrapper ?? SwiftProtobuf.Google_Protobuf_BytesValue()} + set {_uniqueStorage()._optionalBytesWrapper = newValue} + } + /// Returns true if `optionalBytesWrapper` has been explicitly set. + var hasOptionalBytesWrapper: Bool {_storage._optionalBytesWrapper != nil} + /// Clears the value of `optionalBytesWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytesWrapper() {_uniqueStorage()._optionalBytesWrapper = nil} + + var repeatedBoolWrapper: [SwiftProtobuf.Google_Protobuf_BoolValue] { + get {_storage._repeatedBoolWrapper} + set {_uniqueStorage()._repeatedBoolWrapper = newValue} + } + + var repeatedInt32Wrapper: [SwiftProtobuf.Google_Protobuf_Int32Value] { + get {_storage._repeatedInt32Wrapper} + set {_uniqueStorage()._repeatedInt32Wrapper = newValue} + } + + var repeatedInt64Wrapper: [SwiftProtobuf.Google_Protobuf_Int64Value] { + get {_storage._repeatedInt64Wrapper} + set {_uniqueStorage()._repeatedInt64Wrapper = newValue} + } + + var repeatedUint32Wrapper: [SwiftProtobuf.Google_Protobuf_UInt32Value] { + get {_storage._repeatedUint32Wrapper} + set {_uniqueStorage()._repeatedUint32Wrapper = newValue} + } + + var repeatedUint64Wrapper: [SwiftProtobuf.Google_Protobuf_UInt64Value] { + get {_storage._repeatedUint64Wrapper} + set {_uniqueStorage()._repeatedUint64Wrapper = newValue} + } + + var repeatedFloatWrapper: [SwiftProtobuf.Google_Protobuf_FloatValue] { + get {_storage._repeatedFloatWrapper} + set {_uniqueStorage()._repeatedFloatWrapper = newValue} + } + + var repeatedDoubleWrapper: [SwiftProtobuf.Google_Protobuf_DoubleValue] { + get {_storage._repeatedDoubleWrapper} + set {_uniqueStorage()._repeatedDoubleWrapper = newValue} + } + + var repeatedStringWrapper: [SwiftProtobuf.Google_Protobuf_StringValue] { + get {_storage._repeatedStringWrapper} + set {_uniqueStorage()._repeatedStringWrapper = newValue} + } + + var repeatedBytesWrapper: [SwiftProtobuf.Google_Protobuf_BytesValue] { + get {_storage._repeatedBytesWrapper} + set {_uniqueStorage()._repeatedBytesWrapper = newValue} + } + + var optionalDuration: SwiftProtobuf.Google_Protobuf_Duration { + get {_storage._optionalDuration ?? SwiftProtobuf.Google_Protobuf_Duration()} + set {_uniqueStorage()._optionalDuration = newValue} + } + /// Returns true if `optionalDuration` has been explicitly set. + var hasOptionalDuration: Bool {_storage._optionalDuration != nil} + /// Clears the value of `optionalDuration`. Subsequent reads from it will return its default value. + mutating func clearOptionalDuration() {_uniqueStorage()._optionalDuration = nil} + + var optionalTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp { + get {_storage._optionalTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()} + set {_uniqueStorage()._optionalTimestamp = newValue} + } + /// Returns true if `optionalTimestamp` has been explicitly set. + var hasOptionalTimestamp: Bool {_storage._optionalTimestamp != nil} + /// Clears the value of `optionalTimestamp`. Subsequent reads from it will return its default value. + mutating func clearOptionalTimestamp() {_uniqueStorage()._optionalTimestamp = nil} + + var optionalFieldMask: SwiftProtobuf.Google_Protobuf_FieldMask { + get {_storage._optionalFieldMask ?? SwiftProtobuf.Google_Protobuf_FieldMask()} + set {_uniqueStorage()._optionalFieldMask = newValue} + } + /// Returns true if `optionalFieldMask` has been explicitly set. + var hasOptionalFieldMask: Bool {_storage._optionalFieldMask != nil} + /// Clears the value of `optionalFieldMask`. Subsequent reads from it will return its default value. + mutating func clearOptionalFieldMask() {_uniqueStorage()._optionalFieldMask = nil} + + var optionalStruct: SwiftProtobuf.Google_Protobuf_Struct { + get {_storage._optionalStruct ?? SwiftProtobuf.Google_Protobuf_Struct()} + set {_uniqueStorage()._optionalStruct = newValue} + } + /// Returns true if `optionalStruct` has been explicitly set. + var hasOptionalStruct: Bool {_storage._optionalStruct != nil} + /// Clears the value of `optionalStruct`. Subsequent reads from it will return its default value. + mutating func clearOptionalStruct() {_uniqueStorage()._optionalStruct = nil} + + var optionalAny: SwiftProtobuf.Google_Protobuf_Any { + get {_storage._optionalAny ?? SwiftProtobuf.Google_Protobuf_Any()} + set {_uniqueStorage()._optionalAny = newValue} + } + /// Returns true if `optionalAny` has been explicitly set. + var hasOptionalAny: Bool {_storage._optionalAny != nil} + /// Clears the value of `optionalAny`. Subsequent reads from it will return its default value. + mutating func clearOptionalAny() {_uniqueStorage()._optionalAny = nil} + + var optionalValue: SwiftProtobuf.Google_Protobuf_Value { + get {_storage._optionalValue ?? SwiftProtobuf.Google_Protobuf_Value()} + set {_uniqueStorage()._optionalValue = newValue} + } + /// Returns true if `optionalValue` has been explicitly set. + var hasOptionalValue: Bool {_storage._optionalValue != nil} + /// Clears the value of `optionalValue`. Subsequent reads from it will return its default value. + mutating func clearOptionalValue() {_uniqueStorage()._optionalValue = nil} + + var optionalNullValue: SwiftProtobuf.Google_Protobuf_NullValue { + get {_storage._optionalNullValue} + set {_uniqueStorage()._optionalNullValue = newValue} + } + + var repeatedDuration: [SwiftProtobuf.Google_Protobuf_Duration] { + get {_storage._repeatedDuration} + set {_uniqueStorage()._repeatedDuration = newValue} + } + + var repeatedTimestamp: [SwiftProtobuf.Google_Protobuf_Timestamp] { + get {_storage._repeatedTimestamp} + set {_uniqueStorage()._repeatedTimestamp = newValue} + } + + var repeatedFieldmask: [SwiftProtobuf.Google_Protobuf_FieldMask] { + get {_storage._repeatedFieldmask} + set {_uniqueStorage()._repeatedFieldmask = newValue} + } + + var repeatedStruct: [SwiftProtobuf.Google_Protobuf_Struct] { + get {_storage._repeatedStruct} + set {_uniqueStorage()._repeatedStruct = newValue} + } + + var repeatedAny: [SwiftProtobuf.Google_Protobuf_Any] { + get {_storage._repeatedAny} + set {_uniqueStorage()._repeatedAny = newValue} + } + + var repeatedValue: [SwiftProtobuf.Google_Protobuf_Value] { + get {_storage._repeatedValue} + set {_uniqueStorage()._repeatedValue = newValue} + } + + var repeatedListValue: [SwiftProtobuf.Google_Protobuf_ListValue] { + get {_storage._repeatedListValue} + set {_uniqueStorage()._repeatedListValue = newValue} + } + + /// Test field-name-to-JSON-name convention. + /// (protobuf says names can be any valid C/C++ identifier.) + var fieldname1: Int32 { + get {_storage._fieldname1} + set {_uniqueStorage()._fieldname1 = newValue} + } + + var fieldName2: Int32 { + get {_storage._fieldName2} + set {_uniqueStorage()._fieldName2 = newValue} + } + + var fieldName3: Int32 { + get {_storage._fieldName3} + set {_uniqueStorage()._fieldName3 = newValue} + } + + var field_Name4_: Int32 { + get {_storage._field_Name4_} + set {_uniqueStorage()._field_Name4_ = newValue} + } + + var field0Name5: Int32 { + get {_storage._field0Name5} + set {_uniqueStorage()._field0Name5 = newValue} + } + + var field0Name6: Int32 { + get {_storage._field0Name6} + set {_uniqueStorage()._field0Name6 = newValue} + } + + var fieldName7: Int32 { + get {_storage._fieldName7} + set {_uniqueStorage()._fieldName7 = newValue} + } + + var fieldName8: Int32 { + get {_storage._fieldName8} + set {_uniqueStorage()._fieldName8 = newValue} + } + + var fieldName9: Int32 { + get {_storage._fieldName9} + set {_uniqueStorage()._fieldName9 = newValue} + } + + var fieldName10: Int32 { + get {_storage._fieldName10} + set {_uniqueStorage()._fieldName10 = newValue} + } + + var fieldName11: Int32 { + get {_storage._fieldName11} + set {_uniqueStorage()._fieldName11 = newValue} + } + + var fieldName12: Int32 { + get {_storage._fieldName12} + set {_uniqueStorage()._fieldName12 = newValue} + } + + var _FieldName13: Int32 { + get {_storage.__FieldName13} + set {_uniqueStorage().__FieldName13 = newValue} + } + + var _FieldName14: Int32 { + get {_storage.__FieldName14} + set {_uniqueStorage().__FieldName14 = newValue} + } + + var field_Name15: Int32 { + get {_storage._field_Name15} + set {_uniqueStorage()._field_Name15 = newValue} + } + + var field_Name16: Int32 { + get {_storage._field_Name16} + set {_uniqueStorage()._field_Name16 = newValue} + } + + var fieldName17__: Int32 { + get {_storage._fieldName17__} + set {_uniqueStorage()._fieldName17__ = newValue} + } + + var fieldName18__: Int32 { + get {_storage._fieldName18__} + set {_uniqueStorage()._fieldName18__ = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofNestedMessage(ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage) + case oneofString(String) + case oneofBytes(Data) + case oneofBool(Bool) + case oneofUint64(UInt64) + case oneofFloat(Float) + case oneofDouble(Double) + case oneofEnum(ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum) + case oneofNullValue(SwiftProtobuf.Google_Protobuf_NullValue) + + } + + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foo // = 0 + case bar // = 1 + case baz // = 2 + + /// Intentionally negative. + case neg // = -1 + case UNRECOGNIZED(Int) + + init() { + self = .foo + } + + init?(rawValue: Int) { + switch rawValue { + case -1: self = .neg + case 0: self = .foo + case 1: self = .bar + case 2: self = .baz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .neg: return -1 + case .foo: return 0 + case .bar: return 1 + case .baz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] = [ + .foo, + .bar, + .baz, + .neg, + ] + + } + + enum AliasedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case aliasFoo // = 0 + case aliasBar // = 1 + case aliasBaz // = 2 + static let moo = aliasBaz + static let bAz = aliasBaz + case UNRECOGNIZED(Int) + + init() { + self = .aliasFoo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .aliasFoo + case 1: self = .aliasBar + case 2: self = .aliasBaz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .aliasFoo: return 0 + case .aliasBar: return 1 + case .aliasBaz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.AliasedEnum] = [ + .aliasFoo, + .aliasBar, + .aliasBaz, + ] + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a} + set {_uniqueStorage()._a = newValue} + } + + var corecursive: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3 { + get {_storage._corecursive ?? ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct ProtobufTestMessages_Editions_Proto3_ForeignMessage: Sendable { + // 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 c: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct ProtobufTestMessages_Editions_Proto3_NullHypothesisProto3: Sendable { + // 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 ProtobufTestMessages_Editions_Proto3_EnumOnlyProto3: Sendable { + // 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() + + enum BoolEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case kFalse // = 0 + case kTrue // = 1 + case UNRECOGNIZED(Int) + + init() { + self = .kFalse + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .kFalse + case 1: self = .kTrue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .kFalse: return 0 + case .kTrue: return 1 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Editions_Proto3_EnumOnlyProto3.BoolEnum] = [ + .kFalse, + .kTrue, + ] + + } + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "protobuf_test_messages.editions.proto3" + +extension ProtobufTestMessages_Editions_Proto3_ForeignEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") +} + +extension ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypesProto3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{4}\u{2}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{3}optional_aliased_enum\0\u{3}optional_string_piece\0\u{3}optional_cord\0\u{4}\u{2}recursive_message\0\u{4}\u{4}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{4}\u{2}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_nested_message\0\u{3}map_string_foreign_message\0\u{3}map_string_nested_enum\0\u{3}map_string_foreign_enum\0\u{3}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_nested_enum\0\u{3}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_nested_enum\0\u{4}\u{9}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_bool\0\u{3}oneof_uint64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_enum\0\u{3}oneof_null_value\0\u{4}Q\u{1}optional_bool_wrapper\0\u{3}optional_int32_wrapper\0\u{3}optional_int64_wrapper\0\u{3}optional_uint32_wrapper\0\u{3}optional_uint64_wrapper\0\u{3}optional_float_wrapper\0\u{3}optional_double_wrapper\0\u{3}optional_string_wrapper\0\u{3}optional_bytes_wrapper\0\u{4}\u{2}repeated_bool_wrapper\0\u{3}repeated_int32_wrapper\0\u{3}repeated_int64_wrapper\0\u{3}repeated_uint32_wrapper\0\u{3}repeated_uint64_wrapper\0\u{3}repeated_float_wrapper\0\u{3}repeated_double_wrapper\0\u{3}repeated_string_wrapper\0\u{3}repeated_bytes_wrapper\0\u{4}R\u{1}optional_duration\0\u{3}optional_timestamp\0\u{3}optional_field_mask\0\u{3}optional_struct\0\u{3}optional_any\0\u{3}optional_value\0\u{3}optional_null_value\0\u{4}\u{4}repeated_duration\0\u{3}repeated_timestamp\0\u{3}repeated_fieldmask\0\u{4}\u{2}repeated_any\0\u{3}repeated_value\0\u{3}repeated_list_value\0\u{4}\u{7}repeated_struct\0\u{2}M\u{1}fieldname1\0\u{3}field_name2\0\u{3}_field_name3\0\u{3}field__name4_\0\u{1}field0name5\0\u{3}field_0_name6\0\u{1}fieldName7\0\u{1}FieldName8\0\u{3}field_Name9\0\u{3}Field_Name10\0\u{3}FIELD_NAME11\0\u{3}FIELD_name12\0\u{3}__field_name13\0\u{3}__Field_name14\0\u{3}field__name15\0\u{3}field__Name16\0\u{3}field_name17__\0\u{3}Field_name18__\0\u{b}reserved_field\0\u{c}u\u{7}\u{a}\u{c}\u{7f}Ht\u{3}\u{1}") + + fileprivate class _StorageClass { + var _optionalInt32: Int32 = 0 + var _optionalInt64: Int64 = 0 + var _optionalUint32: UInt32 = 0 + var _optionalUint64: UInt64 = 0 + var _optionalSint32: Int32 = 0 + var _optionalSint64: Int64 = 0 + var _optionalFixed32: UInt32 = 0 + var _optionalFixed64: UInt64 = 0 + var _optionalSfixed32: Int32 = 0 + var _optionalSfixed64: Int64 = 0 + var _optionalFloat: Float = 0 + var _optionalDouble: Double = 0 + var _optionalBool: Bool = false + var _optionalString: String = String() + var _optionalBytes: Data = Data() + var _optionalNestedMessage: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage? = nil + var _optionalForeignMessage: ProtobufTestMessages_Editions_Proto3_ForeignMessage? = nil + var _optionalNestedEnum: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum = .foo + var _optionalForeignEnum: ProtobufTestMessages_Editions_Proto3_ForeignEnum = .foreignFoo + var _optionalAliasedEnum: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.AliasedEnum = .aliasFoo + var _optionalStringPiece: String = String() + var _optionalCord: String = String() + var _recursiveMessage: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3? = nil + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedNestedMessage: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage] = [] + var _repeatedForeignMessage: [ProtobufTestMessages_Editions_Proto3_ForeignMessage] = [] + var _repeatedNestedEnum: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] = [] + var _repeatedForeignEnum: [ProtobufTestMessages_Editions_Proto3_ForeignEnum] = [] + var _repeatedStringPiece: [String] = [] + var _repeatedCord: [String] = [] + var _packedInt32: [Int32] = [] + var _packedInt64: [Int64] = [] + var _packedUint32: [UInt32] = [] + var _packedUint64: [UInt64] = [] + var _packedSint32: [Int32] = [] + var _packedSint64: [Int64] = [] + var _packedFixed32: [UInt32] = [] + var _packedFixed64: [UInt64] = [] + var _packedSfixed32: [Int32] = [] + var _packedSfixed64: [Int64] = [] + var _packedFloat: [Float] = [] + var _packedDouble: [Double] = [] + var _packedBool: [Bool] = [] + var _packedNestedEnum: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] = [] + var _unpackedInt32: [Int32] = [] + var _unpackedInt64: [Int64] = [] + var _unpackedUint32: [UInt32] = [] + var _unpackedUint64: [UInt64] = [] + var _unpackedSint32: [Int32] = [] + var _unpackedSint64: [Int64] = [] + var _unpackedFixed32: [UInt32] = [] + var _unpackedFixed64: [UInt64] = [] + var _unpackedSfixed32: [Int32] = [] + var _unpackedSfixed64: [Int64] = [] + var _unpackedFloat: [Float] = [] + var _unpackedDouble: [Double] = [] + var _unpackedBool: [Bool] = [] + var _unpackedNestedEnum: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] = [] + var _mapInt32Int32: Dictionary = [:] + var _mapInt64Int64: Dictionary = [:] + var _mapUint32Uint32: Dictionary = [:] + var _mapUint64Uint64: Dictionary = [:] + var _mapSint32Sint32: Dictionary = [:] + var _mapSint64Sint64: Dictionary = [:] + var _mapFixed32Fixed32: Dictionary = [:] + var _mapFixed64Fixed64: Dictionary = [:] + var _mapSfixed32Sfixed32: Dictionary = [:] + var _mapSfixed64Sfixed64: Dictionary = [:] + var _mapInt32Float: Dictionary = [:] + var _mapInt32Double: Dictionary = [:] + var _mapBoolBool: Dictionary = [:] + var _mapStringString: Dictionary = [:] + var _mapStringBytes: Dictionary = [:] + var _mapStringNestedMessage: Dictionary = [:] + var _mapStringForeignMessage: Dictionary = [:] + var _mapStringNestedEnum: Dictionary = [:] + var _mapStringForeignEnum: Dictionary = [:] + var _oneofField: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.OneOf_OneofField? + var _optionalBoolWrapper: SwiftProtobuf.Google_Protobuf_BoolValue? = nil + var _optionalInt32Wrapper: SwiftProtobuf.Google_Protobuf_Int32Value? = nil + var _optionalInt64Wrapper: SwiftProtobuf.Google_Protobuf_Int64Value? = nil + var _optionalUint32Wrapper: SwiftProtobuf.Google_Protobuf_UInt32Value? = nil + var _optionalUint64Wrapper: SwiftProtobuf.Google_Protobuf_UInt64Value? = nil + var _optionalFloatWrapper: SwiftProtobuf.Google_Protobuf_FloatValue? = nil + var _optionalDoubleWrapper: SwiftProtobuf.Google_Protobuf_DoubleValue? = nil + var _optionalStringWrapper: SwiftProtobuf.Google_Protobuf_StringValue? = nil + var _optionalBytesWrapper: SwiftProtobuf.Google_Protobuf_BytesValue? = nil + var _repeatedBoolWrapper: [SwiftProtobuf.Google_Protobuf_BoolValue] = [] + var _repeatedInt32Wrapper: [SwiftProtobuf.Google_Protobuf_Int32Value] = [] + var _repeatedInt64Wrapper: [SwiftProtobuf.Google_Protobuf_Int64Value] = [] + var _repeatedUint32Wrapper: [SwiftProtobuf.Google_Protobuf_UInt32Value] = [] + var _repeatedUint64Wrapper: [SwiftProtobuf.Google_Protobuf_UInt64Value] = [] + var _repeatedFloatWrapper: [SwiftProtobuf.Google_Protobuf_FloatValue] = [] + var _repeatedDoubleWrapper: [SwiftProtobuf.Google_Protobuf_DoubleValue] = [] + var _repeatedStringWrapper: [SwiftProtobuf.Google_Protobuf_StringValue] = [] + var _repeatedBytesWrapper: [SwiftProtobuf.Google_Protobuf_BytesValue] = [] + var _optionalDuration: SwiftProtobuf.Google_Protobuf_Duration? = nil + var _optionalTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp? = nil + var _optionalFieldMask: SwiftProtobuf.Google_Protobuf_FieldMask? = nil + var _optionalStruct: SwiftProtobuf.Google_Protobuf_Struct? = nil + var _optionalAny: SwiftProtobuf.Google_Protobuf_Any? = nil + var _optionalValue: SwiftProtobuf.Google_Protobuf_Value? = nil + var _optionalNullValue: SwiftProtobuf.Google_Protobuf_NullValue = .nullValue + var _repeatedDuration: [SwiftProtobuf.Google_Protobuf_Duration] = [] + var _repeatedTimestamp: [SwiftProtobuf.Google_Protobuf_Timestamp] = [] + var _repeatedFieldmask: [SwiftProtobuf.Google_Protobuf_FieldMask] = [] + var _repeatedStruct: [SwiftProtobuf.Google_Protobuf_Struct] = [] + var _repeatedAny: [SwiftProtobuf.Google_Protobuf_Any] = [] + var _repeatedValue: [SwiftProtobuf.Google_Protobuf_Value] = [] + var _repeatedListValue: [SwiftProtobuf.Google_Protobuf_ListValue] = [] + var _fieldname1: Int32 = 0 + var _fieldName2: Int32 = 0 + var _fieldName3: Int32 = 0 + var _field_Name4_: Int32 = 0 + var _field0Name5: Int32 = 0 + var _field0Name6: Int32 = 0 + var _fieldName7: Int32 = 0 + var _fieldName8: Int32 = 0 + var _fieldName9: Int32 = 0 + var _fieldName10: Int32 = 0 + var _fieldName11: Int32 = 0 + var _fieldName12: Int32 = 0 + var __FieldName13: Int32 = 0 + var __FieldName14: Int32 = 0 + var _field_Name15: Int32 = 0 + var _field_Name16: Int32 = 0 + var _fieldName17__: Int32 = 0 + var _fieldName18__: Int32 = 0 + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalNestedMessage = source._optionalNestedMessage + _optionalForeignMessage = source._optionalForeignMessage + _optionalNestedEnum = source._optionalNestedEnum + _optionalForeignEnum = source._optionalForeignEnum + _optionalAliasedEnum = source._optionalAliasedEnum + _optionalStringPiece = source._optionalStringPiece + _optionalCord = source._optionalCord + _recursiveMessage = source._recursiveMessage + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedForeignMessage = source._repeatedForeignMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _repeatedForeignEnum = source._repeatedForeignEnum + _repeatedStringPiece = source._repeatedStringPiece + _repeatedCord = source._repeatedCord + _packedInt32 = source._packedInt32 + _packedInt64 = source._packedInt64 + _packedUint32 = source._packedUint32 + _packedUint64 = source._packedUint64 + _packedSint32 = source._packedSint32 + _packedSint64 = source._packedSint64 + _packedFixed32 = source._packedFixed32 + _packedFixed64 = source._packedFixed64 + _packedSfixed32 = source._packedSfixed32 + _packedSfixed64 = source._packedSfixed64 + _packedFloat = source._packedFloat + _packedDouble = source._packedDouble + _packedBool = source._packedBool + _packedNestedEnum = source._packedNestedEnum + _unpackedInt32 = source._unpackedInt32 + _unpackedInt64 = source._unpackedInt64 + _unpackedUint32 = source._unpackedUint32 + _unpackedUint64 = source._unpackedUint64 + _unpackedSint32 = source._unpackedSint32 + _unpackedSint64 = source._unpackedSint64 + _unpackedFixed32 = source._unpackedFixed32 + _unpackedFixed64 = source._unpackedFixed64 + _unpackedSfixed32 = source._unpackedSfixed32 + _unpackedSfixed64 = source._unpackedSfixed64 + _unpackedFloat = source._unpackedFloat + _unpackedDouble = source._unpackedDouble + _unpackedBool = source._unpackedBool + _unpackedNestedEnum = source._unpackedNestedEnum + _mapInt32Int32 = source._mapInt32Int32 + _mapInt64Int64 = source._mapInt64Int64 + _mapUint32Uint32 = source._mapUint32Uint32 + _mapUint64Uint64 = source._mapUint64Uint64 + _mapSint32Sint32 = source._mapSint32Sint32 + _mapSint64Sint64 = source._mapSint64Sint64 + _mapFixed32Fixed32 = source._mapFixed32Fixed32 + _mapFixed64Fixed64 = source._mapFixed64Fixed64 + _mapSfixed32Sfixed32 = source._mapSfixed32Sfixed32 + _mapSfixed64Sfixed64 = source._mapSfixed64Sfixed64 + _mapInt32Float = source._mapInt32Float + _mapInt32Double = source._mapInt32Double + _mapBoolBool = source._mapBoolBool + _mapStringString = source._mapStringString + _mapStringBytes = source._mapStringBytes + _mapStringNestedMessage = source._mapStringNestedMessage + _mapStringForeignMessage = source._mapStringForeignMessage + _mapStringNestedEnum = source._mapStringNestedEnum + _mapStringForeignEnum = source._mapStringForeignEnum + _oneofField = source._oneofField + _optionalBoolWrapper = source._optionalBoolWrapper + _optionalInt32Wrapper = source._optionalInt32Wrapper + _optionalInt64Wrapper = source._optionalInt64Wrapper + _optionalUint32Wrapper = source._optionalUint32Wrapper + _optionalUint64Wrapper = source._optionalUint64Wrapper + _optionalFloatWrapper = source._optionalFloatWrapper + _optionalDoubleWrapper = source._optionalDoubleWrapper + _optionalStringWrapper = source._optionalStringWrapper + _optionalBytesWrapper = source._optionalBytesWrapper + _repeatedBoolWrapper = source._repeatedBoolWrapper + _repeatedInt32Wrapper = source._repeatedInt32Wrapper + _repeatedInt64Wrapper = source._repeatedInt64Wrapper + _repeatedUint32Wrapper = source._repeatedUint32Wrapper + _repeatedUint64Wrapper = source._repeatedUint64Wrapper + _repeatedFloatWrapper = source._repeatedFloatWrapper + _repeatedDoubleWrapper = source._repeatedDoubleWrapper + _repeatedStringWrapper = source._repeatedStringWrapper + _repeatedBytesWrapper = source._repeatedBytesWrapper + _optionalDuration = source._optionalDuration + _optionalTimestamp = source._optionalTimestamp + _optionalFieldMask = source._optionalFieldMask + _optionalStruct = source._optionalStruct + _optionalAny = source._optionalAny + _optionalValue = source._optionalValue + _optionalNullValue = source._optionalNullValue + _repeatedDuration = source._repeatedDuration + _repeatedTimestamp = source._repeatedTimestamp + _repeatedFieldmask = source._repeatedFieldmask + _repeatedStruct = source._repeatedStruct + _repeatedAny = source._repeatedAny + _repeatedValue = source._repeatedValue + _repeatedListValue = source._repeatedListValue + _fieldname1 = source._fieldname1 + _fieldName2 = source._fieldName2 + _fieldName3 = source._fieldName3 + _field_Name4_ = source._field_Name4_ + _field0Name5 = source._field0Name5 + _field0Name6 = source._field0Name6 + _fieldName7 = source._fieldName7 + _fieldName8 = source._fieldName8 + _fieldName9 = source._fieldName9 + _fieldName10 = source._fieldName10 + _fieldName11 = source._fieldName11 + _fieldName12 = source._fieldName12 + __FieldName13 = source.__FieldName13 + __FieldName14 = source.__FieldName14 + _field_Name15 = source._field_Name15 + _field_Name16 = source._field_Name16 + _fieldName17__ = source._fieldName17__ + _fieldName18__ = source._fieldName18__ + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() + case 23: try { try decoder.decodeSingularEnumField(value: &_storage._optionalAliasedEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() + case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() + case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() + case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() + case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() + case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() + case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() + case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() + case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() + case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() + case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() + case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() + case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() + case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() + case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() + case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() + case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() + case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() + case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() + case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() + case 56: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Int32) }() + case 57: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() + case 58: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() + case 59: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Uint64) }() + case 60: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Sint32) }() + case 61: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Sint64) }() + case 62: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Fixed32) }() + case 63: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Fixed64) }() + case 64: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Sfixed32) }() + case 65: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Sfixed64) }() + case 66: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Float) }() + case 67: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Double) }() + case 68: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() + case 69: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() + case 70: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() + case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringNestedMessage) }() + case 72: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() + case 73: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringNestedEnum) }() + case 74: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringForeignEnum) }() + case 75: try { try decoder.decodeRepeatedInt32Field(value: &_storage._packedInt32) }() + case 76: try { try decoder.decodeRepeatedInt64Field(value: &_storage._packedInt64) }() + case 77: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._packedUint32) }() + case 78: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._packedUint64) }() + case 79: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._packedSint32) }() + case 80: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._packedSint64) }() + case 81: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._packedFixed32) }() + case 82: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._packedFixed64) }() + case 83: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._packedSfixed32) }() + case 84: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._packedSfixed64) }() + case 85: try { try decoder.decodeRepeatedFloatField(value: &_storage._packedFloat) }() + case 86: try { try decoder.decodeRepeatedDoubleField(value: &_storage._packedDouble) }() + case 87: try { try decoder.decodeRepeatedBoolField(value: &_storage._packedBool) }() + case 88: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedNestedEnum) }() + case 89: try { try decoder.decodeRepeatedInt32Field(value: &_storage._unpackedInt32) }() + case 90: try { try decoder.decodeRepeatedInt64Field(value: &_storage._unpackedInt64) }() + case 91: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._unpackedUint32) }() + case 92: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._unpackedUint64) }() + case 93: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._unpackedSint32) }() + case 94: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._unpackedSint64) }() + case 95: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._unpackedFixed32) }() + case 96: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._unpackedFixed64) }() + case 97: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._unpackedSfixed32) }() + case 98: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._unpackedSfixed64) }() + case 99: try { try decoder.decodeRepeatedFloatField(value: &_storage._unpackedFloat) }() + case 100: try { try decoder.decodeRepeatedDoubleField(value: &_storage._unpackedDouble) }() + case 101: try { try decoder.decodeRepeatedBoolField(value: &_storage._unpackedBool) }() + case 102: try { try decoder.decodeRepeatedEnumField(value: &_storage._unpackedNestedEnum) }() + case 111: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 112: try { + var v: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage(v) + } + }() + case 113: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 114: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() + case 115: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBool(v) + } + }() + case 116: try { + var v: UInt64? + try decoder.decodeSingularUInt64Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint64(v) + } + }() + case 117: try { + var v: Float? + try decoder.decodeSingularFloatField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofFloat(v) + } + }() + case 118: try { + var v: Double? + try decoder.decodeSingularDoubleField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofDouble(v) + } + }() + case 119: try { + var v: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofEnum(v) + } + }() + case 120: try { + var v: SwiftProtobuf.Google_Protobuf_NullValue? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNullValue(v) + } + }() + case 201: try { try decoder.decodeSingularMessageField(value: &_storage._optionalBoolWrapper) }() + case 202: try { try decoder.decodeSingularMessageField(value: &_storage._optionalInt32Wrapper) }() + case 203: try { try decoder.decodeSingularMessageField(value: &_storage._optionalInt64Wrapper) }() + case 204: try { try decoder.decodeSingularMessageField(value: &_storage._optionalUint32Wrapper) }() + case 205: try { try decoder.decodeSingularMessageField(value: &_storage._optionalUint64Wrapper) }() + case 206: try { try decoder.decodeSingularMessageField(value: &_storage._optionalFloatWrapper) }() + case 207: try { try decoder.decodeSingularMessageField(value: &_storage._optionalDoubleWrapper) }() + case 208: try { try decoder.decodeSingularMessageField(value: &_storage._optionalStringWrapper) }() + case 209: try { try decoder.decodeSingularMessageField(value: &_storage._optionalBytesWrapper) }() + case 211: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedBoolWrapper) }() + case 212: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedInt32Wrapper) }() + case 213: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedInt64Wrapper) }() + case 214: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedUint32Wrapper) }() + case 215: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedUint64Wrapper) }() + case 216: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedFloatWrapper) }() + case 217: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedDoubleWrapper) }() + case 218: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedStringWrapper) }() + case 219: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedBytesWrapper) }() + case 301: try { try decoder.decodeSingularMessageField(value: &_storage._optionalDuration) }() + case 302: try { try decoder.decodeSingularMessageField(value: &_storage._optionalTimestamp) }() + case 303: try { try decoder.decodeSingularMessageField(value: &_storage._optionalFieldMask) }() + case 304: try { try decoder.decodeSingularMessageField(value: &_storage._optionalStruct) }() + case 305: try { try decoder.decodeSingularMessageField(value: &_storage._optionalAny) }() + case 306: try { try decoder.decodeSingularMessageField(value: &_storage._optionalValue) }() + case 307: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNullValue) }() + case 311: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedDuration) }() + case 312: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedTimestamp) }() + case 313: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedFieldmask) }() + case 315: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedAny) }() + case 316: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedValue) }() + case 317: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedListValue) }() + case 324: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedStruct) }() + case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldname1) }() + case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName2) }() + case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName3) }() + case 404: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name4_) }() + case 405: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name5) }() + case 406: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name6) }() + case 407: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName7) }() + case 408: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName8) }() + case 409: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName9) }() + case 410: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName10) }() + case 411: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName11) }() + case 412: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName12) }() + case 413: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName13) }() + case 414: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName14) }() + case 415: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name15) }() + case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name16) }() + case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName17__) }() + case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName18__) }() + default: break + } + } + } + } + + func traverse(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 + if _storage._optionalInt32 != 0 { + try visitor.visitSingularInt32Field(value: _storage._optionalInt32, fieldNumber: 1) + } + if _storage._optionalInt64 != 0 { + try visitor.visitSingularInt64Field(value: _storage._optionalInt64, fieldNumber: 2) + } + if _storage._optionalUint32 != 0 { + try visitor.visitSingularUInt32Field(value: _storage._optionalUint32, fieldNumber: 3) + } + if _storage._optionalUint64 != 0 { + try visitor.visitSingularUInt64Field(value: _storage._optionalUint64, fieldNumber: 4) + } + if _storage._optionalSint32 != 0 { + try visitor.visitSingularSInt32Field(value: _storage._optionalSint32, fieldNumber: 5) + } + if _storage._optionalSint64 != 0 { + try visitor.visitSingularSInt64Field(value: _storage._optionalSint64, fieldNumber: 6) + } + if _storage._optionalFixed32 != 0 { + try visitor.visitSingularFixed32Field(value: _storage._optionalFixed32, fieldNumber: 7) + } + if _storage._optionalFixed64 != 0 { + try visitor.visitSingularFixed64Field(value: _storage._optionalFixed64, fieldNumber: 8) + } + if _storage._optionalSfixed32 != 0 { + try visitor.visitSingularSFixed32Field(value: _storage._optionalSfixed32, fieldNumber: 9) + } + if _storage._optionalSfixed64 != 0 { + try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) + } + if _storage._optionalFloat.bitPattern != 0 { + try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) + } + if _storage._optionalDouble.bitPattern != 0 { + try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) + } + if _storage._optionalBool != false { + try visitor.visitSingularBoolField(value: _storage._optionalBool, fieldNumber: 13) + } + if !_storage._optionalString.isEmpty { + try visitor.visitSingularStringField(value: _storage._optionalString, fieldNumber: 14) + } + if !_storage._optionalBytes.isEmpty { + try visitor.visitSingularBytesField(value: _storage._optionalBytes, fieldNumber: 15) + } + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._optionalForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + if _storage._optionalNestedEnum != .foo { + try visitor.visitSingularEnumField(value: _storage._optionalNestedEnum, fieldNumber: 21) + } + if _storage._optionalForeignEnum != .foreignFoo { + try visitor.visitSingularEnumField(value: _storage._optionalForeignEnum, fieldNumber: 22) + } + if _storage._optionalAliasedEnum != .aliasFoo { + try visitor.visitSingularEnumField(value: _storage._optionalAliasedEnum, fieldNumber: 23) + } + if !_storage._optionalStringPiece.isEmpty { + try visitor.visitSingularStringField(value: _storage._optionalStringPiece, fieldNumber: 24) + } + if !_storage._optionalCord.isEmpty { + try visitor.visitSingularStringField(value: _storage._optionalCord, fieldNumber: 25) + } + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + if !_storage._repeatedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + } + if !_storage._repeatedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + } + if !_storage._repeatedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + } + if !_storage._repeatedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + } + if !_storage._repeatedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + } + if !_storage._repeatedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + } + if !_storage._repeatedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + } + if !_storage._repeatedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + } + if !_storage._repeatedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + } + if !_storage._repeatedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + } + if !_storage._repeatedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + } + if !_storage._repeatedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + } + if !_storage._repeatedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + } + if !_storage._repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) + } + if !_storage._repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) + } + if !_storage._repeatedNestedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) + } + if !_storage._repeatedForeignMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) + } + if !_storage._repeatedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + } + if !_storage._repeatedForeignEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) + } + if !_storage._repeatedStringPiece.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) + } + if !_storage._repeatedCord.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) + } + if !_storage._mapInt32Int32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Int32, fieldNumber: 56) + } + if !_storage._mapInt64Int64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Int64, fieldNumber: 57) + } + if !_storage._mapUint32Uint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Uint32, fieldNumber: 58) + } + if !_storage._mapUint64Uint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Uint64, fieldNumber: 59) + } + if !_storage._mapSint32Sint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Sint32, fieldNumber: 60) + } + if !_storage._mapSint64Sint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Sint64, fieldNumber: 61) + } + if !_storage._mapFixed32Fixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Fixed32, fieldNumber: 62) + } + if !_storage._mapFixed64Fixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Fixed64, fieldNumber: 63) + } + if !_storage._mapSfixed32Sfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 64) + } + if !_storage._mapSfixed64Sfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 65) + } + if !_storage._mapInt32Float.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Float, fieldNumber: 66) + } + if !_storage._mapInt32Double.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Double, fieldNumber: 67) + } + if !_storage._mapBoolBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolBool, fieldNumber: 68) + } + if !_storage._mapStringString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringString, fieldNumber: 69) + } + if !_storage._mapStringBytes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 70) + } + if !_storage._mapStringNestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringNestedMessage, fieldNumber: 71) + } + if !_storage._mapStringForeignMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 72) + } + if !_storage._mapStringNestedEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringNestedEnum, fieldNumber: 73) + } + if !_storage._mapStringForeignEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringForeignEnum, fieldNumber: 74) + } + if !_storage._packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._packedInt32, fieldNumber: 75) + } + if !_storage._packedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._packedInt64, fieldNumber: 76) + } + if !_storage._packedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._packedUint32, fieldNumber: 77) + } + if !_storage._packedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._packedUint64, fieldNumber: 78) + } + if !_storage._packedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._packedSint32, fieldNumber: 79) + } + if !_storage._packedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._packedSint64, fieldNumber: 80) + } + if !_storage._packedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._packedFixed32, fieldNumber: 81) + } + if !_storage._packedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._packedFixed64, fieldNumber: 82) + } + if !_storage._packedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._packedSfixed32, fieldNumber: 83) + } + if !_storage._packedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._packedSfixed64, fieldNumber: 84) + } + if !_storage._packedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._packedFloat, fieldNumber: 85) + } + if !_storage._packedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._packedDouble, fieldNumber: 86) + } + if !_storage._packedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._packedBool, fieldNumber: 87) + } + if !_storage._packedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedNestedEnum, fieldNumber: 88) + } + if !_storage._unpackedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._unpackedInt32, fieldNumber: 89) + } + if !_storage._unpackedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._unpackedInt64, fieldNumber: 90) + } + if !_storage._unpackedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._unpackedUint32, fieldNumber: 91) + } + if !_storage._unpackedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._unpackedUint64, fieldNumber: 92) + } + if !_storage._unpackedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._unpackedSint32, fieldNumber: 93) + } + if !_storage._unpackedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._unpackedSint64, fieldNumber: 94) + } + if !_storage._unpackedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._unpackedFixed32, fieldNumber: 95) + } + if !_storage._unpackedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._unpackedFixed64, fieldNumber: 96) + } + if !_storage._unpackedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._unpackedSfixed32, fieldNumber: 97) + } + if !_storage._unpackedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._unpackedSfixed64, fieldNumber: 98) + } + if !_storage._unpackedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._unpackedFloat, fieldNumber: 99) + } + if !_storage._unpackedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._unpackedDouble, fieldNumber: 100) + } + if !_storage._unpackedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._unpackedBool, fieldNumber: 101) + } + if !_storage._unpackedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._unpackedNestedEnum, fieldNumber: 102) + } + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case .oneofBool?: try { + guard case .oneofBool(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 115) + }() + case .oneofUint64?: try { + guard case .oneofUint64(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 116) + }() + case .oneofFloat?: try { + guard case .oneofFloat(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularFloatField(value: v, fieldNumber: 117) + }() + case .oneofDouble?: try { + guard case .oneofDouble(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularDoubleField(value: v, fieldNumber: 118) + }() + case .oneofEnum?: try { + guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 119) + }() + case .oneofNullValue?: try { + guard case .oneofNullValue(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 120) + }() + case nil: break + } + try { if let v = _storage._optionalBoolWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._optionalInt32Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 202) + } }() + try { if let v = _storage._optionalInt64Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 203) + } }() + try { if let v = _storage._optionalUint32Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 204) + } }() + try { if let v = _storage._optionalUint64Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 205) + } }() + try { if let v = _storage._optionalFloatWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 206) + } }() + try { if let v = _storage._optionalDoubleWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 207) + } }() + try { if let v = _storage._optionalStringWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 208) + } }() + try { if let v = _storage._optionalBytesWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 209) + } }() + if !_storage._repeatedBoolWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedBoolWrapper, fieldNumber: 211) + } + if !_storage._repeatedInt32Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedInt32Wrapper, fieldNumber: 212) + } + if !_storage._repeatedInt64Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedInt64Wrapper, fieldNumber: 213) + } + if !_storage._repeatedUint32Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedUint32Wrapper, fieldNumber: 214) + } + if !_storage._repeatedUint64Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedUint64Wrapper, fieldNumber: 215) + } + if !_storage._repeatedFloatWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedFloatWrapper, fieldNumber: 216) + } + if !_storage._repeatedDoubleWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedDoubleWrapper, fieldNumber: 217) + } + if !_storage._repeatedStringWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedStringWrapper, fieldNumber: 218) + } + if !_storage._repeatedBytesWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedBytesWrapper, fieldNumber: 219) + } + try { if let v = _storage._optionalDuration { + try visitor.visitSingularMessageField(value: v, fieldNumber: 301) + } }() + try { if let v = _storage._optionalTimestamp { + try visitor.visitSingularMessageField(value: v, fieldNumber: 302) + } }() + try { if let v = _storage._optionalFieldMask { + try visitor.visitSingularMessageField(value: v, fieldNumber: 303) + } }() + try { if let v = _storage._optionalStruct { + try visitor.visitSingularMessageField(value: v, fieldNumber: 304) + } }() + try { if let v = _storage._optionalAny { + try visitor.visitSingularMessageField(value: v, fieldNumber: 305) + } }() + try { if let v = _storage._optionalValue { + try visitor.visitSingularMessageField(value: v, fieldNumber: 306) + } }() + if _storage._optionalNullValue != .nullValue { + try visitor.visitSingularEnumField(value: _storage._optionalNullValue, fieldNumber: 307) + } + if !_storage._repeatedDuration.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedDuration, fieldNumber: 311) + } + if !_storage._repeatedTimestamp.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedTimestamp, fieldNumber: 312) + } + if !_storage._repeatedFieldmask.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedFieldmask, fieldNumber: 313) + } + if !_storage._repeatedAny.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedAny, fieldNumber: 315) + } + if !_storage._repeatedValue.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedValue, fieldNumber: 316) + } + if !_storage._repeatedListValue.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedListValue, fieldNumber: 317) + } + if !_storage._repeatedStruct.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedStruct, fieldNumber: 324) + } + if _storage._fieldname1 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldname1, fieldNumber: 401) + } + if _storage._fieldName2 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName2, fieldNumber: 402) + } + if _storage._fieldName3 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName3, fieldNumber: 403) + } + if _storage._field_Name4_ != 0 { + try visitor.visitSingularInt32Field(value: _storage._field_Name4_, fieldNumber: 404) + } + if _storage._field0Name5 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field0Name5, fieldNumber: 405) + } + if _storage._field0Name6 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field0Name6, fieldNumber: 406) + } + if _storage._fieldName7 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName7, fieldNumber: 407) + } + if _storage._fieldName8 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName8, fieldNumber: 408) + } + if _storage._fieldName9 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName9, fieldNumber: 409) + } + if _storage._fieldName10 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName10, fieldNumber: 410) + } + if _storage._fieldName11 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName11, fieldNumber: 411) + } + if _storage._fieldName12 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName12, fieldNumber: 412) + } + if _storage.__FieldName13 != 0 { + try visitor.visitSingularInt32Field(value: _storage.__FieldName13, fieldNumber: 413) + } + if _storage.__FieldName14 != 0 { + try visitor.visitSingularInt32Field(value: _storage.__FieldName14, fieldNumber: 414) + } + if _storage._field_Name15 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field_Name15, fieldNumber: 415) + } + if _storage._field_Name16 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field_Name16, fieldNumber: 416) + } + if _storage._fieldName17__ != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName17__, fieldNumber: 417) + } + if _storage._fieldName18__ != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName18__, fieldNumber: 418) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3, rhs: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} + if _storage._optionalAliasedEnum != rhs_storage._optionalAliasedEnum {return false} + if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} + if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} + if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} + if _storage._repeatedCord != rhs_storage._repeatedCord {return false} + if _storage._packedInt32 != rhs_storage._packedInt32 {return false} + if _storage._packedInt64 != rhs_storage._packedInt64 {return false} + if _storage._packedUint32 != rhs_storage._packedUint32 {return false} + if _storage._packedUint64 != rhs_storage._packedUint64 {return false} + if _storage._packedSint32 != rhs_storage._packedSint32 {return false} + if _storage._packedSint64 != rhs_storage._packedSint64 {return false} + if _storage._packedFixed32 != rhs_storage._packedFixed32 {return false} + if _storage._packedFixed64 != rhs_storage._packedFixed64 {return false} + if _storage._packedSfixed32 != rhs_storage._packedSfixed32 {return false} + if _storage._packedSfixed64 != rhs_storage._packedSfixed64 {return false} + if _storage._packedFloat != rhs_storage._packedFloat {return false} + if _storage._packedDouble != rhs_storage._packedDouble {return false} + if _storage._packedBool != rhs_storage._packedBool {return false} + if _storage._packedNestedEnum != rhs_storage._packedNestedEnum {return false} + if _storage._unpackedInt32 != rhs_storage._unpackedInt32 {return false} + if _storage._unpackedInt64 != rhs_storage._unpackedInt64 {return false} + if _storage._unpackedUint32 != rhs_storage._unpackedUint32 {return false} + if _storage._unpackedUint64 != rhs_storage._unpackedUint64 {return false} + if _storage._unpackedSint32 != rhs_storage._unpackedSint32 {return false} + if _storage._unpackedSint64 != rhs_storage._unpackedSint64 {return false} + if _storage._unpackedFixed32 != rhs_storage._unpackedFixed32 {return false} + if _storage._unpackedFixed64 != rhs_storage._unpackedFixed64 {return false} + if _storage._unpackedSfixed32 != rhs_storage._unpackedSfixed32 {return false} + if _storage._unpackedSfixed64 != rhs_storage._unpackedSfixed64 {return false} + if _storage._unpackedFloat != rhs_storage._unpackedFloat {return false} + if _storage._unpackedDouble != rhs_storage._unpackedDouble {return false} + if _storage._unpackedBool != rhs_storage._unpackedBool {return false} + if _storage._unpackedNestedEnum != rhs_storage._unpackedNestedEnum {return false} + if _storage._mapInt32Int32 != rhs_storage._mapInt32Int32 {return false} + if _storage._mapInt64Int64 != rhs_storage._mapInt64Int64 {return false} + if _storage._mapUint32Uint32 != rhs_storage._mapUint32Uint32 {return false} + if _storage._mapUint64Uint64 != rhs_storage._mapUint64Uint64 {return false} + if _storage._mapSint32Sint32 != rhs_storage._mapSint32Sint32 {return false} + if _storage._mapSint64Sint64 != rhs_storage._mapSint64Sint64 {return false} + if _storage._mapFixed32Fixed32 != rhs_storage._mapFixed32Fixed32 {return false} + if _storage._mapFixed64Fixed64 != rhs_storage._mapFixed64Fixed64 {return false} + if _storage._mapSfixed32Sfixed32 != rhs_storage._mapSfixed32Sfixed32 {return false} + if _storage._mapSfixed64Sfixed64 != rhs_storage._mapSfixed64Sfixed64 {return false} + if _storage._mapInt32Float != rhs_storage._mapInt32Float {return false} + if _storage._mapInt32Double != rhs_storage._mapInt32Double {return false} + if _storage._mapBoolBool != rhs_storage._mapBoolBool {return false} + if _storage._mapStringString != rhs_storage._mapStringString {return false} + if _storage._mapStringBytes != rhs_storage._mapStringBytes {return false} + if _storage._mapStringNestedMessage != rhs_storage._mapStringNestedMessage {return false} + if _storage._mapStringForeignMessage != rhs_storage._mapStringForeignMessage {return false} + if _storage._mapStringNestedEnum != rhs_storage._mapStringNestedEnum {return false} + if _storage._mapStringForeignEnum != rhs_storage._mapStringForeignEnum {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + if _storage._optionalBoolWrapper != rhs_storage._optionalBoolWrapper {return false} + if _storage._optionalInt32Wrapper != rhs_storage._optionalInt32Wrapper {return false} + if _storage._optionalInt64Wrapper != rhs_storage._optionalInt64Wrapper {return false} + if _storage._optionalUint32Wrapper != rhs_storage._optionalUint32Wrapper {return false} + if _storage._optionalUint64Wrapper != rhs_storage._optionalUint64Wrapper {return false} + if _storage._optionalFloatWrapper != rhs_storage._optionalFloatWrapper {return false} + if _storage._optionalDoubleWrapper != rhs_storage._optionalDoubleWrapper {return false} + if _storage._optionalStringWrapper != rhs_storage._optionalStringWrapper {return false} + if _storage._optionalBytesWrapper != rhs_storage._optionalBytesWrapper {return false} + if _storage._repeatedBoolWrapper != rhs_storage._repeatedBoolWrapper {return false} + if _storage._repeatedInt32Wrapper != rhs_storage._repeatedInt32Wrapper {return false} + if _storage._repeatedInt64Wrapper != rhs_storage._repeatedInt64Wrapper {return false} + if _storage._repeatedUint32Wrapper != rhs_storage._repeatedUint32Wrapper {return false} + if _storage._repeatedUint64Wrapper != rhs_storage._repeatedUint64Wrapper {return false} + if _storage._repeatedFloatWrapper != rhs_storage._repeatedFloatWrapper {return false} + if _storage._repeatedDoubleWrapper != rhs_storage._repeatedDoubleWrapper {return false} + if _storage._repeatedStringWrapper != rhs_storage._repeatedStringWrapper {return false} + if _storage._repeatedBytesWrapper != rhs_storage._repeatedBytesWrapper {return false} + if _storage._optionalDuration != rhs_storage._optionalDuration {return false} + if _storage._optionalTimestamp != rhs_storage._optionalTimestamp {return false} + if _storage._optionalFieldMask != rhs_storage._optionalFieldMask {return false} + if _storage._optionalStruct != rhs_storage._optionalStruct {return false} + if _storage._optionalAny != rhs_storage._optionalAny {return false} + if _storage._optionalValue != rhs_storage._optionalValue {return false} + if _storage._optionalNullValue != rhs_storage._optionalNullValue {return false} + if _storage._repeatedDuration != rhs_storage._repeatedDuration {return false} + if _storage._repeatedTimestamp != rhs_storage._repeatedTimestamp {return false} + if _storage._repeatedFieldmask != rhs_storage._repeatedFieldmask {return false} + if _storage._repeatedStruct != rhs_storage._repeatedStruct {return false} + if _storage._repeatedAny != rhs_storage._repeatedAny {return false} + if _storage._repeatedValue != rhs_storage._repeatedValue {return false} + if _storage._repeatedListValue != rhs_storage._repeatedListValue {return false} + if _storage._fieldname1 != rhs_storage._fieldname1 {return false} + if _storage._fieldName2 != rhs_storage._fieldName2 {return false} + if _storage._fieldName3 != rhs_storage._fieldName3 {return false} + if _storage._field_Name4_ != rhs_storage._field_Name4_ {return false} + if _storage._field0Name5 != rhs_storage._field0Name5 {return false} + if _storage._field0Name6 != rhs_storage._field0Name6 {return false} + if _storage._fieldName7 != rhs_storage._fieldName7 {return false} + if _storage._fieldName8 != rhs_storage._fieldName8 {return false} + if _storage._fieldName9 != rhs_storage._fieldName9 {return false} + if _storage._fieldName10 != rhs_storage._fieldName10 {return false} + if _storage._fieldName11 != rhs_storage._fieldName11 {return false} + if _storage._fieldName12 != rhs_storage._fieldName12 {return false} + if _storage.__FieldName13 != rhs_storage.__FieldName13 {return false} + if _storage.__FieldName14 != rhs_storage.__FieldName14 {return false} + if _storage._field_Name15 != rhs_storage._field_Name15 {return false} + if _storage._field_Name16 != rhs_storage._field_Name16 {return false} + if _storage._fieldName17__ != rhs_storage._fieldName17__ {return false} + if _storage._fieldName18__ != rhs_storage._fieldName18__ {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.AliasedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ALIAS_FOO\0\u{1}ALIAS_BAR\0\u{9}ALIAS_BAZ\0\u{3}MOO\0moo\0bAz\0") +} + +extension ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32 = 0 + var _corecursive: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + default: break + } + } + } + } + + func traverse(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 + if _storage._a != 0 { + try visitor.visitSingularInt32Field(value: _storage._a, fieldNumber: 1) + } + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage, rhs: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto3_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") + + 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.c) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.c != 0 { + try visitor.visitSingularInt32Field(value: self.c, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto3_ForeignMessage, rhs: ProtobufTestMessages_Editions_Proto3_ForeignMessage) -> Bool { + if lhs.c != rhs.c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto3_NullHypothesisProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NullHypothesisProto3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto3_NullHypothesisProto3, rhs: ProtobufTestMessages_Editions_Proto3_NullHypothesisProto3) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto3_EnumOnlyProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumOnlyProto3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto3_EnumOnlyProto3, rhs: ProtobufTestMessages_Editions_Proto3_EnumOnlyProto3) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto3_EnumOnlyProto3.BoolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0kFalse\0\u{1}kTrue\0") +} diff --git a/Reference/Sources/Conformance/google/protobuf/test_messages_proto2.pb.swift b/Reference/Sources/Conformance/google/protobuf/test_messages_proto2.pb.swift new file mode 100644 index 000000000..2ea8fa80e --- /dev/null +++ b/Reference/Sources/Conformance/google/protobuf/test_messages_proto2.pb.swift @@ -0,0 +1,4827 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/test_messages_proto2.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Test schema for proto2 messages. This test schema is used by: +// +// - conformance tests + +// LINT: ALLOW_GROUPS + +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 ProtobufTestMessages_Proto2_ForeignEnumProto2: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foreignFoo = 0 + case foreignBar = 1 + case foreignBaz = 2 + + init() { + self = .foreignFoo + } + +} + +/// This proto includes every type of field in both singular and repeated +/// forms. +/// +/// Also, crucially, all messages and enums in this file are eventually +/// submessages of this message. So for example, a fuzz test of TestAllTypes +/// could trigger bugs that occur in any message type in this file. We verify +/// this stays true in a unit test. +struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Singular + var optionalInt32: Int32 { + get {_storage._optionalInt32 ?? 0} + set {_uniqueStorage()._optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} + + var optionalInt64: Int64 { + get {_storage._optionalInt64 ?? 0} + set {_uniqueStorage()._optionalInt64 = newValue} + } + /// Returns true if `optionalInt64` has been explicitly set. + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} + /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} + + var optionalUint32: UInt32 { + get {_storage._optionalUint32 ?? 0} + set {_uniqueStorage()._optionalUint32 = newValue} + } + /// Returns true if `optionalUint32` has been explicitly set. + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} + /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} + + var optionalUint64: UInt64 { + get {_storage._optionalUint64 ?? 0} + set {_uniqueStorage()._optionalUint64 = newValue} + } + /// Returns true if `optionalUint64` has been explicitly set. + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} + /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} + + var optionalSint32: Int32 { + get {_storage._optionalSint32 ?? 0} + set {_uniqueStorage()._optionalSint32 = newValue} + } + /// Returns true if `optionalSint32` has been explicitly set. + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} + /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} + + var optionalSint64: Int64 { + get {_storage._optionalSint64 ?? 0} + set {_uniqueStorage()._optionalSint64 = newValue} + } + /// Returns true if `optionalSint64` has been explicitly set. + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} + /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} + + var optionalFixed32: UInt32 { + get {_storage._optionalFixed32 ?? 0} + set {_uniqueStorage()._optionalFixed32 = newValue} + } + /// Returns true if `optionalFixed32` has been explicitly set. + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} + /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} + + var optionalFixed64: UInt64 { + get {_storage._optionalFixed64 ?? 0} + set {_uniqueStorage()._optionalFixed64 = newValue} + } + /// Returns true if `optionalFixed64` has been explicitly set. + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} + /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} + + var optionalSfixed32: Int32 { + get {_storage._optionalSfixed32 ?? 0} + set {_uniqueStorage()._optionalSfixed32 = newValue} + } + /// Returns true if `optionalSfixed32` has been explicitly set. + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} + /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} + + var optionalSfixed64: Int64 { + get {_storage._optionalSfixed64 ?? 0} + set {_uniqueStorage()._optionalSfixed64 = newValue} + } + /// Returns true if `optionalSfixed64` has been explicitly set. + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} + /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} + + var optionalFloat: Float { + get {_storage._optionalFloat ?? 0} + set {_uniqueStorage()._optionalFloat = newValue} + } + /// Returns true if `optionalFloat` has been explicitly set. + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} + /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} + + var optionalDouble: Double { + get {_storage._optionalDouble ?? 0} + set {_uniqueStorage()._optionalDouble = newValue} + } + /// Returns true if `optionalDouble` has been explicitly set. + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} + /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. + mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} + + var optionalBool: Bool { + get {_storage._optionalBool ?? false} + set {_uniqueStorage()._optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {_storage._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} + + var optionalString: String { + get {_storage._optionalString ?? String()} + set {_uniqueStorage()._optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {_storage._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} + + var optionalBytes: Data { + get {_storage._optionalBytes ?? Data()} + set {_uniqueStorage()._optionalBytes = newValue} + } + /// Returns true if `optionalBytes` has been explicitly set. + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} + /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} + + var optionalNestedMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage { + get {_storage._optionalNestedMessage ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage()} + set {_uniqueStorage()._optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} + + var optionalForeignMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2 { + get {_storage._optionalForeignMessage ?? ProtobufTestMessages_Proto2_ForeignMessageProto2()} + set {_uniqueStorage()._optionalForeignMessage = newValue} + } + /// Returns true if `optionalForeignMessage` has been explicitly set. + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} + /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} + + var optionalNestedEnum: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum { + get {_storage._optionalNestedEnum ?? .foo} + set {_uniqueStorage()._optionalNestedEnum = newValue} + } + /// Returns true if `optionalNestedEnum` has been explicitly set. + var hasOptionalNestedEnum: Bool {_storage._optionalNestedEnum != nil} + /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} + + var optionalForeignEnum: ProtobufTestMessages_Proto2_ForeignEnumProto2 { + get {_storage._optionalForeignEnum ?? .foreignFoo} + set {_uniqueStorage()._optionalForeignEnum = newValue} + } + /// Returns true if `optionalForeignEnum` has been explicitly set. + var hasOptionalForeignEnum: Bool {_storage._optionalForeignEnum != nil} + /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignEnum() {_uniqueStorage()._optionalForeignEnum = nil} + + var optionalStringPiece: String { + get {_storage._optionalStringPiece ?? String()} + set {_uniqueStorage()._optionalStringPiece = newValue} + } + /// Returns true if `optionalStringPiece` has been explicitly set. + var hasOptionalStringPiece: Bool {_storage._optionalStringPiece != nil} + /// Clears the value of `optionalStringPiece`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringPiece() {_uniqueStorage()._optionalStringPiece = nil} + + var optionalCord: String { + get {_storage._optionalCord ?? String()} + set {_uniqueStorage()._optionalCord = newValue} + } + /// Returns true if `optionalCord` has been explicitly set. + var hasOptionalCord: Bool {_storage._optionalCord != nil} + /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. + mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} + + var recursiveMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2 { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Proto2_TestAllTypesProto2()} + set {_uniqueStorage()._recursiveMessage = newValue} + } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} + + /// Repeated + var repeatedInt32: [Int32] { + get {_storage._repeatedInt32} + set {_uniqueStorage()._repeatedInt32 = newValue} + } + + var repeatedInt64: [Int64] { + get {_storage._repeatedInt64} + set {_uniqueStorage()._repeatedInt64 = newValue} + } + + var repeatedUint32: [UInt32] { + get {_storage._repeatedUint32} + set {_uniqueStorage()._repeatedUint32 = newValue} + } + + var repeatedUint64: [UInt64] { + get {_storage._repeatedUint64} + set {_uniqueStorage()._repeatedUint64 = newValue} + } + + var repeatedSint32: [Int32] { + get {_storage._repeatedSint32} + set {_uniqueStorage()._repeatedSint32 = newValue} + } + + var repeatedSint64: [Int64] { + get {_storage._repeatedSint64} + set {_uniqueStorage()._repeatedSint64 = newValue} + } + + var repeatedFixed32: [UInt32] { + get {_storage._repeatedFixed32} + set {_uniqueStorage()._repeatedFixed32 = newValue} + } + + var repeatedFixed64: [UInt64] { + get {_storage._repeatedFixed64} + set {_uniqueStorage()._repeatedFixed64 = newValue} + } + + var repeatedSfixed32: [Int32] { + get {_storage._repeatedSfixed32} + set {_uniqueStorage()._repeatedSfixed32 = newValue} + } + + var repeatedSfixed64: [Int64] { + get {_storage._repeatedSfixed64} + set {_uniqueStorage()._repeatedSfixed64 = newValue} + } + + var repeatedFloat: [Float] { + get {_storage._repeatedFloat} + set {_uniqueStorage()._repeatedFloat = newValue} + } + + var repeatedDouble: [Double] { + get {_storage._repeatedDouble} + set {_uniqueStorage()._repeatedDouble = newValue} + } + + var repeatedBool: [Bool] { + get {_storage._repeatedBool} + set {_uniqueStorage()._repeatedBool = newValue} + } + + var repeatedString: [String] { + get {_storage._repeatedString} + set {_uniqueStorage()._repeatedString = newValue} + } + + var repeatedBytes: [Data] { + get {_storage._repeatedBytes} + set {_uniqueStorage()._repeatedBytes = newValue} + } + + var repeatedNestedMessage: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage] { + get {_storage._repeatedNestedMessage} + set {_uniqueStorage()._repeatedNestedMessage = newValue} + } + + var repeatedForeignMessage: [ProtobufTestMessages_Proto2_ForeignMessageProto2] { + get {_storage._repeatedForeignMessage} + set {_uniqueStorage()._repeatedForeignMessage = newValue} + } + + var repeatedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] { + get {_storage._repeatedNestedEnum} + set {_uniqueStorage()._repeatedNestedEnum = newValue} + } + + var repeatedForeignEnum: [ProtobufTestMessages_Proto2_ForeignEnumProto2] { + get {_storage._repeatedForeignEnum} + set {_uniqueStorage()._repeatedForeignEnum = newValue} + } + + var repeatedStringPiece: [String] { + get {_storage._repeatedStringPiece} + set {_uniqueStorage()._repeatedStringPiece = newValue} + } + + var repeatedCord: [String] { + get {_storage._repeatedCord} + set {_uniqueStorage()._repeatedCord = newValue} + } + + /// Packed + var packedInt32: [Int32] { + get {_storage._packedInt32} + set {_uniqueStorage()._packedInt32 = newValue} + } + + var packedInt64: [Int64] { + get {_storage._packedInt64} + set {_uniqueStorage()._packedInt64 = newValue} + } + + var packedUint32: [UInt32] { + get {_storage._packedUint32} + set {_uniqueStorage()._packedUint32 = newValue} + } + + var packedUint64: [UInt64] { + get {_storage._packedUint64} + set {_uniqueStorage()._packedUint64 = newValue} + } + + var packedSint32: [Int32] { + get {_storage._packedSint32} + set {_uniqueStorage()._packedSint32 = newValue} + } + + var packedSint64: [Int64] { + get {_storage._packedSint64} + set {_uniqueStorage()._packedSint64 = newValue} + } + + var packedFixed32: [UInt32] { + get {_storage._packedFixed32} + set {_uniqueStorage()._packedFixed32 = newValue} + } + + var packedFixed64: [UInt64] { + get {_storage._packedFixed64} + set {_uniqueStorage()._packedFixed64 = newValue} + } + + var packedSfixed32: [Int32] { + get {_storage._packedSfixed32} + set {_uniqueStorage()._packedSfixed32 = newValue} + } + + var packedSfixed64: [Int64] { + get {_storage._packedSfixed64} + set {_uniqueStorage()._packedSfixed64 = newValue} + } + + var packedFloat: [Float] { + get {_storage._packedFloat} + set {_uniqueStorage()._packedFloat = newValue} + } + + var packedDouble: [Double] { + get {_storage._packedDouble} + set {_uniqueStorage()._packedDouble = newValue} + } + + var packedBool: [Bool] { + get {_storage._packedBool} + set {_uniqueStorage()._packedBool = newValue} + } + + var packedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] { + get {_storage._packedNestedEnum} + set {_uniqueStorage()._packedNestedEnum = newValue} + } + + /// Unpacked + var unpackedInt32: [Int32] { + get {_storage._unpackedInt32} + set {_uniqueStorage()._unpackedInt32 = newValue} + } + + var unpackedInt64: [Int64] { + get {_storage._unpackedInt64} + set {_uniqueStorage()._unpackedInt64 = newValue} + } + + var unpackedUint32: [UInt32] { + get {_storage._unpackedUint32} + set {_uniqueStorage()._unpackedUint32 = newValue} + } + + var unpackedUint64: [UInt64] { + get {_storage._unpackedUint64} + set {_uniqueStorage()._unpackedUint64 = newValue} + } + + var unpackedSint32: [Int32] { + get {_storage._unpackedSint32} + set {_uniqueStorage()._unpackedSint32 = newValue} + } + + var unpackedSint64: [Int64] { + get {_storage._unpackedSint64} + set {_uniqueStorage()._unpackedSint64 = newValue} + } + + var unpackedFixed32: [UInt32] { + get {_storage._unpackedFixed32} + set {_uniqueStorage()._unpackedFixed32 = newValue} + } + + var unpackedFixed64: [UInt64] { + get {_storage._unpackedFixed64} + set {_uniqueStorage()._unpackedFixed64 = newValue} + } + + var unpackedSfixed32: [Int32] { + get {_storage._unpackedSfixed32} + set {_uniqueStorage()._unpackedSfixed32 = newValue} + } + + var unpackedSfixed64: [Int64] { + get {_storage._unpackedSfixed64} + set {_uniqueStorage()._unpackedSfixed64 = newValue} + } + + var unpackedFloat: [Float] { + get {_storage._unpackedFloat} + set {_uniqueStorage()._unpackedFloat = newValue} + } + + var unpackedDouble: [Double] { + get {_storage._unpackedDouble} + set {_uniqueStorage()._unpackedDouble = newValue} + } + + var unpackedBool: [Bool] { + get {_storage._unpackedBool} + set {_uniqueStorage()._unpackedBool = newValue} + } + + var unpackedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] { + get {_storage._unpackedNestedEnum} + set {_uniqueStorage()._unpackedNestedEnum = newValue} + } + + /// Map + var mapInt32Int32: Dictionary { + get {_storage._mapInt32Int32} + set {_uniqueStorage()._mapInt32Int32 = newValue} + } + + var mapInt64Int64: Dictionary { + get {_storage._mapInt64Int64} + set {_uniqueStorage()._mapInt64Int64 = newValue} + } + + var mapUint32Uint32: Dictionary { + get {_storage._mapUint32Uint32} + set {_uniqueStorage()._mapUint32Uint32 = newValue} + } + + var mapUint64Uint64: Dictionary { + get {_storage._mapUint64Uint64} + set {_uniqueStorage()._mapUint64Uint64 = newValue} + } + + var mapSint32Sint32: Dictionary { + get {_storage._mapSint32Sint32} + set {_uniqueStorage()._mapSint32Sint32 = newValue} + } + + var mapSint64Sint64: Dictionary { + get {_storage._mapSint64Sint64} + set {_uniqueStorage()._mapSint64Sint64 = newValue} + } + + var mapFixed32Fixed32: Dictionary { + get {_storage._mapFixed32Fixed32} + set {_uniqueStorage()._mapFixed32Fixed32 = newValue} + } + + var mapFixed64Fixed64: Dictionary { + get {_storage._mapFixed64Fixed64} + set {_uniqueStorage()._mapFixed64Fixed64 = newValue} + } + + var mapSfixed32Sfixed32: Dictionary { + get {_storage._mapSfixed32Sfixed32} + set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} + } + + var mapSfixed64Sfixed64: Dictionary { + get {_storage._mapSfixed64Sfixed64} + set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} + } + + var mapInt32Bool: Dictionary { + get {_storage._mapInt32Bool} + set {_uniqueStorage()._mapInt32Bool = newValue} + } + + var mapInt32Float: Dictionary { + get {_storage._mapInt32Float} + set {_uniqueStorage()._mapInt32Float = newValue} + } + + var mapInt32Double: Dictionary { + get {_storage._mapInt32Double} + set {_uniqueStorage()._mapInt32Double = newValue} + } + + var mapInt32NestedMessage: Dictionary { + get {_storage._mapInt32NestedMessage} + set {_uniqueStorage()._mapInt32NestedMessage = newValue} + } + + var mapBoolBool: Dictionary { + get {_storage._mapBoolBool} + set {_uniqueStorage()._mapBoolBool = newValue} + } + + var mapStringString: Dictionary { + get {_storage._mapStringString} + set {_uniqueStorage()._mapStringString = newValue} + } + + var mapStringBytes: Dictionary { + get {_storage._mapStringBytes} + set {_uniqueStorage()._mapStringBytes = newValue} + } + + var mapStringNestedMessage: Dictionary { + get {_storage._mapStringNestedMessage} + set {_uniqueStorage()._mapStringNestedMessage = newValue} + } + + var mapStringForeignMessage: Dictionary { + get {_storage._mapStringForeignMessage} + set {_uniqueStorage()._mapStringForeignMessage = newValue} + } + + var mapStringNestedEnum: Dictionary { + get {_storage._mapStringNestedEnum} + set {_uniqueStorage()._mapStringNestedEnum = newValue} + } + + var mapStringForeignEnum: Dictionary { + get {_storage._mapStringForeignEnum} + set {_uniqueStorage()._mapStringForeignEnum = newValue} + } + + var oneofField: OneOf_OneofField? { + get {return _storage._oneofField} + set {_uniqueStorage()._oneofField = newValue} + } + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} + } + + var oneofNestedMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage { + get { + if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} + return ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = _storage._oneofField {return v} + return Data() + } + set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} + } + + var oneofBool: Bool { + get { + if case .oneofBool(let v)? = _storage._oneofField {return v} + return false + } + set {_uniqueStorage()._oneofField = .oneofBool(newValue)} + } + + var oneofUint64: UInt64 { + get { + if case .oneofUint64(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint64(newValue)} + } + + var oneofFloat: Float { + get { + if case .oneofFloat(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofFloat(newValue)} + } + + var oneofDouble: Double { + get { + if case .oneofDouble(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofDouble(newValue)} + } + + var oneofEnum: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum { + get { + if case .oneofEnum(let v)? = _storage._oneofField {return v} + return .foo + } + set {_uniqueStorage()._oneofField = .oneofEnum(newValue)} + } + + var data: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage { + get {_storage._data ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage()} + set {_uniqueStorage()._data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {_storage._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {_uniqueStorage()._data = nil} + + var multiWordGroupField: ProtobufTestMessages_Proto2_TestAllTypesProto2.MultiWordGroupField { + get {_storage._multiWordGroupField ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.MultiWordGroupField()} + set {_uniqueStorage()._multiWordGroupField = newValue} + } + /// Returns true if `multiWordGroupField` has been explicitly set. + var hasMultiWordGroupField: Bool {_storage._multiWordGroupField != nil} + /// Clears the value of `multiWordGroupField`. Subsequent reads from it will return its default value. + mutating func clearMultiWordGroupField() {_uniqueStorage()._multiWordGroupField = nil} + + /// default values + var defaultInt32: Int32 { + get {_storage._defaultInt32 ?? -123456789} + set {_uniqueStorage()._defaultInt32 = newValue} + } + /// Returns true if `defaultInt32` has been explicitly set. + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} + /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} + + var defaultInt64: Int64 { + get {_storage._defaultInt64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultInt64 = newValue} + } + /// Returns true if `defaultInt64` has been explicitly set. + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} + /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} + + var defaultUint32: UInt32 { + get {_storage._defaultUint32 ?? 2123456789} + set {_uniqueStorage()._defaultUint32 = newValue} + } + /// Returns true if `defaultUint32` has been explicitly set. + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} + /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} + + var defaultUint64: UInt64 { + get {_storage._defaultUint64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultUint64 = newValue} + } + /// Returns true if `defaultUint64` has been explicitly set. + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} + /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} + + var defaultSint32: Int32 { + get {_storage._defaultSint32 ?? -123456789} + set {_uniqueStorage()._defaultSint32 = newValue} + } + /// Returns true if `defaultSint32` has been explicitly set. + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} + /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} + + var defaultSint64: Int64 { + get {_storage._defaultSint64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSint64 = newValue} + } + /// Returns true if `defaultSint64` has been explicitly set. + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} + /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} + + var defaultFixed32: UInt32 { + get {_storage._defaultFixed32 ?? 2123456789} + set {_uniqueStorage()._defaultFixed32 = newValue} + } + /// Returns true if `defaultFixed32` has been explicitly set. + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} + /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} + + var defaultFixed64: UInt64 { + get {_storage._defaultFixed64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultFixed64 = newValue} + } + /// Returns true if `defaultFixed64` has been explicitly set. + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} + /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} + + var defaultSfixed32: Int32 { + get {_storage._defaultSfixed32 ?? -123456789} + set {_uniqueStorage()._defaultSfixed32 = newValue} + } + /// Returns true if `defaultSfixed32` has been explicitly set. + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} + /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} + + var defaultSfixed64: Int64 { + get {_storage._defaultSfixed64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSfixed64 = newValue} + } + /// Returns true if `defaultSfixed64` has been explicitly set. + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} + /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} + + var defaultFloat: Float { + get {_storage._defaultFloat ?? 9e+09} + set {_uniqueStorage()._defaultFloat = newValue} + } + /// Returns true if `defaultFloat` has been explicitly set. + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} + /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. + mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} + + var defaultDouble: Double { + get {_storage._defaultDouble ?? 7e+22} + set {_uniqueStorage()._defaultDouble = newValue} + } + /// Returns true if `defaultDouble` has been explicitly set. + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} + /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. + mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} + + var defaultBool: Bool { + get {_storage._defaultBool ?? true} + set {_uniqueStorage()._defaultBool = newValue} + } + /// Returns true if `defaultBool` has been explicitly set. + var hasDefaultBool: Bool {_storage._defaultBool != nil} + /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. + mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} + + var defaultString: String { + get {_storage._defaultString ?? "Rosebud"} + set {_uniqueStorage()._defaultString = newValue} + } + /// Returns true if `defaultString` has been explicitly set. + var hasDefaultString: Bool {_storage._defaultString != nil} + /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. + mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} + + var defaultBytes: Data { + get {_storage._defaultBytes ?? Data([106, 111, 115, 104, 117, 97])} + set {_uniqueStorage()._defaultBytes = newValue} + } + /// Returns true if `defaultBytes` has been explicitly set. + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} + /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. + mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} + + /// Test field-name-to-JSON-name convention. + /// (protobuf says names can be any valid C/C++ identifier.) + var fieldname1: Int32 { + get {_storage._fieldname1 ?? 0} + set {_uniqueStorage()._fieldname1 = newValue} + } + /// Returns true if `fieldname1` has been explicitly set. + var hasFieldname1: Bool {_storage._fieldname1 != nil} + /// Clears the value of `fieldname1`. Subsequent reads from it will return its default value. + mutating func clearFieldname1() {_uniqueStorage()._fieldname1 = nil} + + var fieldName2: Int32 { + get {_storage._fieldName2 ?? 0} + set {_uniqueStorage()._fieldName2 = newValue} + } + /// Returns true if `fieldName2` has been explicitly set. + var hasFieldName2: Bool {_storage._fieldName2 != nil} + /// Clears the value of `fieldName2`. Subsequent reads from it will return its default value. + mutating func clearFieldName2() {_uniqueStorage()._fieldName2 = nil} + + var fieldName3: Int32 { + get {_storage._fieldName3 ?? 0} + set {_uniqueStorage()._fieldName3 = newValue} + } + /// Returns true if `fieldName3` has been explicitly set. + var hasFieldName3: Bool {_storage._fieldName3 != nil} + /// Clears the value of `fieldName3`. Subsequent reads from it will return its default value. + mutating func clearFieldName3() {_uniqueStorage()._fieldName3 = nil} + + var field_Name4_: Int32 { + get {_storage._field_Name4_ ?? 0} + set {_uniqueStorage()._field_Name4_ = newValue} + } + /// Returns true if `field_Name4_` has been explicitly set. + var hasField_Name4_: Bool {_storage._field_Name4_ != nil} + /// Clears the value of `field_Name4_`. Subsequent reads from it will return its default value. + mutating func clearField_Name4_() {_uniqueStorage()._field_Name4_ = nil} + + var field0Name5: Int32 { + get {_storage._field0Name5 ?? 0} + set {_uniqueStorage()._field0Name5 = newValue} + } + /// Returns true if `field0Name5` has been explicitly set. + var hasField0Name5: Bool {_storage._field0Name5 != nil} + /// Clears the value of `field0Name5`. Subsequent reads from it will return its default value. + mutating func clearField0Name5() {_uniqueStorage()._field0Name5 = nil} + + var field0Name6: Int32 { + get {_storage._field0Name6 ?? 0} + set {_uniqueStorage()._field0Name6 = newValue} + } + /// Returns true if `field0Name6` has been explicitly set. + var hasField0Name6: Bool {_storage._field0Name6 != nil} + /// Clears the value of `field0Name6`. Subsequent reads from it will return its default value. + mutating func clearField0Name6() {_uniqueStorage()._field0Name6 = nil} + + var fieldName7: Int32 { + get {_storage._fieldName7 ?? 0} + set {_uniqueStorage()._fieldName7 = newValue} + } + /// Returns true if `fieldName7` has been explicitly set. + var hasFieldName7: Bool {_storage._fieldName7 != nil} + /// Clears the value of `fieldName7`. Subsequent reads from it will return its default value. + mutating func clearFieldName7() {_uniqueStorage()._fieldName7 = nil} + + var fieldName8: Int32 { + get {_storage._fieldName8 ?? 0} + set {_uniqueStorage()._fieldName8 = newValue} + } + /// Returns true if `fieldName8` has been explicitly set. + var hasFieldName8: Bool {_storage._fieldName8 != nil} + /// Clears the value of `fieldName8`. Subsequent reads from it will return its default value. + mutating func clearFieldName8() {_uniqueStorage()._fieldName8 = nil} + + var fieldName9: Int32 { + get {_storage._fieldName9 ?? 0} + set {_uniqueStorage()._fieldName9 = newValue} + } + /// Returns true if `fieldName9` has been explicitly set. + var hasFieldName9: Bool {_storage._fieldName9 != nil} + /// Clears the value of `fieldName9`. Subsequent reads from it will return its default value. + mutating func clearFieldName9() {_uniqueStorage()._fieldName9 = nil} + + var fieldName10: Int32 { + get {_storage._fieldName10 ?? 0} + set {_uniqueStorage()._fieldName10 = newValue} + } + /// Returns true if `fieldName10` has been explicitly set. + var hasFieldName10: Bool {_storage._fieldName10 != nil} + /// Clears the value of `fieldName10`. Subsequent reads from it will return its default value. + mutating func clearFieldName10() {_uniqueStorage()._fieldName10 = nil} + + var fieldName11: Int32 { + get {_storage._fieldName11 ?? 0} + set {_uniqueStorage()._fieldName11 = newValue} + } + /// Returns true if `fieldName11` has been explicitly set. + var hasFieldName11: Bool {_storage._fieldName11 != nil} + /// Clears the value of `fieldName11`. Subsequent reads from it will return its default value. + mutating func clearFieldName11() {_uniqueStorage()._fieldName11 = nil} + + var fieldName12: Int32 { + get {_storage._fieldName12 ?? 0} + set {_uniqueStorage()._fieldName12 = newValue} + } + /// Returns true if `fieldName12` has been explicitly set. + var hasFieldName12: Bool {_storage._fieldName12 != nil} + /// Clears the value of `fieldName12`. Subsequent reads from it will return its default value. + mutating func clearFieldName12() {_uniqueStorage()._fieldName12 = nil} + + var _FieldName13: Int32 { + get {_storage.__FieldName13 ?? 0} + set {_uniqueStorage().__FieldName13 = newValue} + } + /// Returns true if `_FieldName13` has been explicitly set. + var has_FieldName13: Bool {_storage.__FieldName13 != nil} + /// Clears the value of `_FieldName13`. Subsequent reads from it will return its default value. + mutating func clear_FieldName13() {_uniqueStorage().__FieldName13 = nil} + + var _FieldName14: Int32 { + get {_storage.__FieldName14 ?? 0} + set {_uniqueStorage().__FieldName14 = newValue} + } + /// Returns true if `_FieldName14` has been explicitly set. + var has_FieldName14: Bool {_storage.__FieldName14 != nil} + /// Clears the value of `_FieldName14`. Subsequent reads from it will return its default value. + mutating func clear_FieldName14() {_uniqueStorage().__FieldName14 = nil} + + var field_Name15: Int32 { + get {_storage._field_Name15 ?? 0} + set {_uniqueStorage()._field_Name15 = newValue} + } + /// Returns true if `field_Name15` has been explicitly set. + var hasField_Name15: Bool {_storage._field_Name15 != nil} + /// Clears the value of `field_Name15`. Subsequent reads from it will return its default value. + mutating func clearField_Name15() {_uniqueStorage()._field_Name15 = nil} + + var field_Name16: Int32 { + get {_storage._field_Name16 ?? 0} + set {_uniqueStorage()._field_Name16 = newValue} + } + /// Returns true if `field_Name16` has been explicitly set. + var hasField_Name16: Bool {_storage._field_Name16 != nil} + /// Clears the value of `field_Name16`. Subsequent reads from it will return its default value. + mutating func clearField_Name16() {_uniqueStorage()._field_Name16 = nil} + + var fieldName17__: Int32 { + get {_storage._fieldName17__ ?? 0} + set {_uniqueStorage()._fieldName17__ = newValue} + } + /// Returns true if `fieldName17__` has been explicitly set. + var hasFieldName17__: Bool {_storage._fieldName17__ != nil} + /// Clears the value of `fieldName17__`. Subsequent reads from it will return its default value. + mutating func clearFieldName17__() {_uniqueStorage()._fieldName17__ = nil} + + var fieldName18__: Int32 { + get {_storage._fieldName18__ ?? 0} + set {_uniqueStorage()._fieldName18__ = newValue} + } + /// Returns true if `fieldName18__` has been explicitly set. + var hasFieldName18__: Bool {_storage._fieldName18__ != nil} + /// Clears the value of `fieldName18__`. Subsequent reads from it will return its default value. + mutating func clearFieldName18__() {_uniqueStorage()._fieldName18__ = nil} + + var messageSetCorrect: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect { + get {_storage._messageSetCorrect ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect()} + set {_uniqueStorage()._messageSetCorrect = newValue} + } + /// Returns true if `messageSetCorrect` has been explicitly set. + var hasMessageSetCorrect: Bool {_storage._messageSetCorrect != nil} + /// Clears the value of `messageSetCorrect`. Subsequent reads from it will return its default value. + mutating func clearMessageSetCorrect() {_uniqueStorage()._messageSetCorrect = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofNestedMessage(ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage) + case oneofString(String) + case oneofBytes(Data) + case oneofBool(Bool) + case oneofUint64(UInt64) + case oneofFloat(Float) + case oneofDouble(Double) + case oneofEnum(ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum) + + fileprivate var isInitialized: Bool { + guard case .oneofNestedMessage(let v) = self else {return true} + return v.isInitialized + } + + } + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 + + /// Intentionally negative. + case neg = -1 + + init() { + self = .foo + } + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var corecursive: ProtobufTestMessages_Proto2_TestAllTypesProto2 { + get {_storage._corecursive ?? ProtobufTestMessages_Proto2_TestAllTypesProto2()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + /// groups + struct DataMessage: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + struct MultiWordGroupField: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + /// message_set test case. + struct MessageSetCorrect: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() + } + + struct MessageSetCorrectExtension1: Sendable { + // 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 str: String { + get {_str ?? String()} + set {_str = newValue} + } + /// Returns true if `str` has been explicitly set. + var hasStr: Bool {self._str != nil} + /// Clears the value of `str`. Subsequent reads from it will return its default value. + mutating func clearStr() {self._str = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _str: String? = nil + } + + struct MessageSetCorrectExtension2: Sendable { + // 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 i: Int32 { + get {_i ?? 0} + set {_i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {self._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {self._i = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _i: Int32? = nil + } + + struct ExtensionWithOneof: Sendable { + // 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 oneofField: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.OneOf_OneofField? = nil + + var a: Int32 { + get { + if case .a(let v)? = oneofField {return v} + return 0 + } + set {oneofField = .a(newValue)} + } + + var b: Int32 { + get { + if case .b(let v)? = oneofField {return v} + return 0 + } + set {oneofField = .b(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case a(Int32) + case b(Int32) + + } + + init() {} + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct ProtobufTestMessages_Proto2_ForeignMessageProto2: Sendable { + // 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 c: Int32 { + get {_c ?? 0} + set {_c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {self._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {self._c = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _c: Int32? = nil +} + +struct ProtobufTestMessages_Proto2_GroupField: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil +} + +struct ProtobufTestMessages_Proto2_UnknownToTestAllTypes: Sendable { + // 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 optionalInt32: Int32 { + get {_optionalInt32 ?? 0} + set {_optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {self._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {self._optionalInt32 = nil} + + var optionalString: String { + get {_optionalString ?? String()} + set {_optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {self._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {self._optionalString = nil} + + var nestedMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2 { + get {_nestedMessage ?? ProtobufTestMessages_Proto2_ForeignMessageProto2()} + set {_nestedMessage = newValue} + } + /// Returns true if `nestedMessage` has been explicitly set. + var hasNestedMessage: Bool {self._nestedMessage != nil} + /// Clears the value of `nestedMessage`. Subsequent reads from it will return its default value. + mutating func clearNestedMessage() {self._nestedMessage = nil} + + var optionalGroup: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup { + get {_optionalGroup ?? ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup()} + set {_optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {self._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {self._optionalGroup = nil} + + var optionalBool: Bool { + get {_optionalBool ?? false} + set {_optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {self._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {self._optionalBool = nil} + + var repeatedInt32: [Int32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct OptionalGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + init() {} + + fileprivate var _optionalInt32: Int32? = nil + fileprivate var _optionalString: String? = nil + fileprivate var _nestedMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2? = nil + fileprivate var _optionalGroup: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup? = nil + fileprivate var _optionalBool: Bool? = nil +} + +struct ProtobufTestMessages_Proto2_NullHypothesisProto2: Sendable { + // 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 ProtobufTestMessages_Proto2_EnumOnlyProto2: Sendable { + // 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() + + enum BoolEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case kFalse = 0 + case kTrue = 1 + + init() { + self = .kFalse + } + + } + + init() {} +} + +struct ProtobufTestMessages_Proto2_OneStringProto2: Sendable { + // 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 data: String { + get {_data ?? String()} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: String? = nil +} + +struct ProtobufTestMessages_Proto2_ProtoWithKeywords: Sendable { + // 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 inline: Int32 { + get {_inline ?? 0} + set {_inline = newValue} + } + /// Returns true if `inline` has been explicitly set. + var hasInline: Bool {self._inline != nil} + /// Clears the value of `inline`. Subsequent reads from it will return its default value. + mutating func clearInline() {self._inline = nil} + + var concept: String { + get {_concept ?? String()} + set {_concept = newValue} + } + /// Returns true if `concept` has been explicitly set. + var hasConcept: Bool {self._concept != nil} + /// Clears the value of `concept`. Subsequent reads from it will return its default value. + mutating func clearConcept() {self._concept = nil} + + var requires: [String] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _inline: Int32? = nil + fileprivate var _concept: String? = nil +} + +struct ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Singular + var requiredInt32: Int32 { + get {_storage._requiredInt32 ?? 0} + set {_uniqueStorage()._requiredInt32 = newValue} + } + /// Returns true if `requiredInt32` has been explicitly set. + var hasRequiredInt32: Bool {_storage._requiredInt32 != nil} + /// Clears the value of `requiredInt32`. Subsequent reads from it will return its default value. + mutating func clearRequiredInt32() {_uniqueStorage()._requiredInt32 = nil} + + var requiredInt64: Int64 { + get {_storage._requiredInt64 ?? 0} + set {_uniqueStorage()._requiredInt64 = newValue} + } + /// Returns true if `requiredInt64` has been explicitly set. + var hasRequiredInt64: Bool {_storage._requiredInt64 != nil} + /// Clears the value of `requiredInt64`. Subsequent reads from it will return its default value. + mutating func clearRequiredInt64() {_uniqueStorage()._requiredInt64 = nil} + + var requiredUint32: UInt32 { + get {_storage._requiredUint32 ?? 0} + set {_uniqueStorage()._requiredUint32 = newValue} + } + /// Returns true if `requiredUint32` has been explicitly set. + var hasRequiredUint32: Bool {_storage._requiredUint32 != nil} + /// Clears the value of `requiredUint32`. Subsequent reads from it will return its default value. + mutating func clearRequiredUint32() {_uniqueStorage()._requiredUint32 = nil} + + var requiredUint64: UInt64 { + get {_storage._requiredUint64 ?? 0} + set {_uniqueStorage()._requiredUint64 = newValue} + } + /// Returns true if `requiredUint64` has been explicitly set. + var hasRequiredUint64: Bool {_storage._requiredUint64 != nil} + /// Clears the value of `requiredUint64`. Subsequent reads from it will return its default value. + mutating func clearRequiredUint64() {_uniqueStorage()._requiredUint64 = nil} + + var requiredSint32: Int32 { + get {_storage._requiredSint32 ?? 0} + set {_uniqueStorage()._requiredSint32 = newValue} + } + /// Returns true if `requiredSint32` has been explicitly set. + var hasRequiredSint32: Bool {_storage._requiredSint32 != nil} + /// Clears the value of `requiredSint32`. Subsequent reads from it will return its default value. + mutating func clearRequiredSint32() {_uniqueStorage()._requiredSint32 = nil} + + var requiredSint64: Int64 { + get {_storage._requiredSint64 ?? 0} + set {_uniqueStorage()._requiredSint64 = newValue} + } + /// Returns true if `requiredSint64` has been explicitly set. + var hasRequiredSint64: Bool {_storage._requiredSint64 != nil} + /// Clears the value of `requiredSint64`. Subsequent reads from it will return its default value. + mutating func clearRequiredSint64() {_uniqueStorage()._requiredSint64 = nil} + + var requiredFixed32: UInt32 { + get {_storage._requiredFixed32 ?? 0} + set {_uniqueStorage()._requiredFixed32 = newValue} + } + /// Returns true if `requiredFixed32` has been explicitly set. + var hasRequiredFixed32: Bool {_storage._requiredFixed32 != nil} + /// Clears the value of `requiredFixed32`. Subsequent reads from it will return its default value. + mutating func clearRequiredFixed32() {_uniqueStorage()._requiredFixed32 = nil} + + var requiredFixed64: UInt64 { + get {_storage._requiredFixed64 ?? 0} + set {_uniqueStorage()._requiredFixed64 = newValue} + } + /// Returns true if `requiredFixed64` has been explicitly set. + var hasRequiredFixed64: Bool {_storage._requiredFixed64 != nil} + /// Clears the value of `requiredFixed64`. Subsequent reads from it will return its default value. + mutating func clearRequiredFixed64() {_uniqueStorage()._requiredFixed64 = nil} + + var requiredSfixed32: Int32 { + get {_storage._requiredSfixed32 ?? 0} + set {_uniqueStorage()._requiredSfixed32 = newValue} + } + /// Returns true if `requiredSfixed32` has been explicitly set. + var hasRequiredSfixed32: Bool {_storage._requiredSfixed32 != nil} + /// Clears the value of `requiredSfixed32`. Subsequent reads from it will return its default value. + mutating func clearRequiredSfixed32() {_uniqueStorage()._requiredSfixed32 = nil} + + var requiredSfixed64: Int64 { + get {_storage._requiredSfixed64 ?? 0} + set {_uniqueStorage()._requiredSfixed64 = newValue} + } + /// Returns true if `requiredSfixed64` has been explicitly set. + var hasRequiredSfixed64: Bool {_storage._requiredSfixed64 != nil} + /// Clears the value of `requiredSfixed64`. Subsequent reads from it will return its default value. + mutating func clearRequiredSfixed64() {_uniqueStorage()._requiredSfixed64 = nil} + + var requiredFloat: Float { + get {_storage._requiredFloat ?? 0} + set {_uniqueStorage()._requiredFloat = newValue} + } + /// Returns true if `requiredFloat` has been explicitly set. + var hasRequiredFloat: Bool {_storage._requiredFloat != nil} + /// Clears the value of `requiredFloat`. Subsequent reads from it will return its default value. + mutating func clearRequiredFloat() {_uniqueStorage()._requiredFloat = nil} + + var requiredDouble: Double { + get {_storage._requiredDouble ?? 0} + set {_uniqueStorage()._requiredDouble = newValue} + } + /// Returns true if `requiredDouble` has been explicitly set. + var hasRequiredDouble: Bool {_storage._requiredDouble != nil} + /// Clears the value of `requiredDouble`. Subsequent reads from it will return its default value. + mutating func clearRequiredDouble() {_uniqueStorage()._requiredDouble = nil} + + var requiredBool: Bool { + get {_storage._requiredBool ?? false} + set {_uniqueStorage()._requiredBool = newValue} + } + /// Returns true if `requiredBool` has been explicitly set. + var hasRequiredBool: Bool {_storage._requiredBool != nil} + /// Clears the value of `requiredBool`. Subsequent reads from it will return its default value. + mutating func clearRequiredBool() {_uniqueStorage()._requiredBool = nil} + + var requiredString: String { + get {_storage._requiredString ?? String()} + set {_uniqueStorage()._requiredString = newValue} + } + /// Returns true if `requiredString` has been explicitly set. + var hasRequiredString: Bool {_storage._requiredString != nil} + /// Clears the value of `requiredString`. Subsequent reads from it will return its default value. + mutating func clearRequiredString() {_uniqueStorage()._requiredString = nil} + + var requiredBytes: Data { + get {_storage._requiredBytes ?? Data()} + set {_uniqueStorage()._requiredBytes = newValue} + } + /// Returns true if `requiredBytes` has been explicitly set. + var hasRequiredBytes: Bool {_storage._requiredBytes != nil} + /// Clears the value of `requiredBytes`. Subsequent reads from it will return its default value. + mutating func clearRequiredBytes() {_uniqueStorage()._requiredBytes = nil} + + var requiredNestedMessage: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage { + get {_storage._requiredNestedMessage ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage()} + set {_uniqueStorage()._requiredNestedMessage = newValue} + } + /// Returns true if `requiredNestedMessage` has been explicitly set. + var hasRequiredNestedMessage: Bool {_storage._requiredNestedMessage != nil} + /// Clears the value of `requiredNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearRequiredNestedMessage() {_uniqueStorage()._requiredNestedMessage = nil} + + var requiredForeignMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2 { + get {_storage._requiredForeignMessage ?? ProtobufTestMessages_Proto2_ForeignMessageProto2()} + set {_uniqueStorage()._requiredForeignMessage = newValue} + } + /// Returns true if `requiredForeignMessage` has been explicitly set. + var hasRequiredForeignMessage: Bool {_storage._requiredForeignMessage != nil} + /// Clears the value of `requiredForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearRequiredForeignMessage() {_uniqueStorage()._requiredForeignMessage = nil} + + var requiredNestedEnum: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedEnum { + get {_storage._requiredNestedEnum ?? .foo} + set {_uniqueStorage()._requiredNestedEnum = newValue} + } + /// Returns true if `requiredNestedEnum` has been explicitly set. + var hasRequiredNestedEnum: Bool {_storage._requiredNestedEnum != nil} + /// Clears the value of `requiredNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredNestedEnum() {_uniqueStorage()._requiredNestedEnum = nil} + + var requiredForeignEnum: ProtobufTestMessages_Proto2_ForeignEnumProto2 { + get {_storage._requiredForeignEnum ?? .foreignFoo} + set {_uniqueStorage()._requiredForeignEnum = newValue} + } + /// Returns true if `requiredForeignEnum` has been explicitly set. + var hasRequiredForeignEnum: Bool {_storage._requiredForeignEnum != nil} + /// Clears the value of `requiredForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredForeignEnum() {_uniqueStorage()._requiredForeignEnum = nil} + + var requiredStringPiece: String { + get {_storage._requiredStringPiece ?? String()} + set {_uniqueStorage()._requiredStringPiece = newValue} + } + /// Returns true if `requiredStringPiece` has been explicitly set. + var hasRequiredStringPiece: Bool {_storage._requiredStringPiece != nil} + /// Clears the value of `requiredStringPiece`. Subsequent reads from it will return its default value. + mutating func clearRequiredStringPiece() {_uniqueStorage()._requiredStringPiece = nil} + + var requiredCord: String { + get {_storage._requiredCord ?? String()} + set {_uniqueStorage()._requiredCord = newValue} + } + /// Returns true if `requiredCord` has been explicitly set. + var hasRequiredCord: Bool {_storage._requiredCord != nil} + /// Clears the value of `requiredCord`. Subsequent reads from it will return its default value. + mutating func clearRequiredCord() {_uniqueStorage()._requiredCord = nil} + + var recursiveMessage: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2 { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._recursiveMessage = newValue} + } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} + + var optionalRecursiveMessage: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2 { + get {_storage._optionalRecursiveMessage ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._optionalRecursiveMessage = newValue} + } + /// Returns true if `optionalRecursiveMessage` has been explicitly set. + var hasOptionalRecursiveMessage: Bool {_storage._optionalRecursiveMessage != nil} + /// Clears the value of `optionalRecursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalRecursiveMessage() {_uniqueStorage()._optionalRecursiveMessage = nil} + + var data: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage { + get {_storage._data ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage()} + set {_uniqueStorage()._data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {_storage._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {_uniqueStorage()._data = nil} + + /// default values + var defaultInt32: Int32 { + get {_storage._defaultInt32 ?? -123456789} + set {_uniqueStorage()._defaultInt32 = newValue} + } + /// Returns true if `defaultInt32` has been explicitly set. + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} + /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} + + var defaultInt64: Int64 { + get {_storage._defaultInt64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultInt64 = newValue} + } + /// Returns true if `defaultInt64` has been explicitly set. + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} + /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} + + var defaultUint32: UInt32 { + get {_storage._defaultUint32 ?? 2123456789} + set {_uniqueStorage()._defaultUint32 = newValue} + } + /// Returns true if `defaultUint32` has been explicitly set. + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} + /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} + + var defaultUint64: UInt64 { + get {_storage._defaultUint64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultUint64 = newValue} + } + /// Returns true if `defaultUint64` has been explicitly set. + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} + /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} + + var defaultSint32: Int32 { + get {_storage._defaultSint32 ?? -123456789} + set {_uniqueStorage()._defaultSint32 = newValue} + } + /// Returns true if `defaultSint32` has been explicitly set. + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} + /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} + + var defaultSint64: Int64 { + get {_storage._defaultSint64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSint64 = newValue} + } + /// Returns true if `defaultSint64` has been explicitly set. + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} + /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} + + var defaultFixed32: UInt32 { + get {_storage._defaultFixed32 ?? 2123456789} + set {_uniqueStorage()._defaultFixed32 = newValue} + } + /// Returns true if `defaultFixed32` has been explicitly set. + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} + /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} + + var defaultFixed64: UInt64 { + get {_storage._defaultFixed64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultFixed64 = newValue} + } + /// Returns true if `defaultFixed64` has been explicitly set. + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} + /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} + + var defaultSfixed32: Int32 { + get {_storage._defaultSfixed32 ?? -123456789} + set {_uniqueStorage()._defaultSfixed32 = newValue} + } + /// Returns true if `defaultSfixed32` has been explicitly set. + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} + /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} + + var defaultSfixed64: Int64 { + get {_storage._defaultSfixed64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSfixed64 = newValue} + } + /// Returns true if `defaultSfixed64` has been explicitly set. + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} + /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} + + var defaultFloat: Float { + get {_storage._defaultFloat ?? 9e+09} + set {_uniqueStorage()._defaultFloat = newValue} + } + /// Returns true if `defaultFloat` has been explicitly set. + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} + /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. + mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} + + var defaultDouble: Double { + get {_storage._defaultDouble ?? 7e+22} + set {_uniqueStorage()._defaultDouble = newValue} + } + /// Returns true if `defaultDouble` has been explicitly set. + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} + /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. + mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} + + var defaultBool: Bool { + get {_storage._defaultBool ?? true} + set {_uniqueStorage()._defaultBool = newValue} + } + /// Returns true if `defaultBool` has been explicitly set. + var hasDefaultBool: Bool {_storage._defaultBool != nil} + /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. + mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} + + var defaultString: String { + get {_storage._defaultString ?? "Rosebud"} + set {_uniqueStorage()._defaultString = newValue} + } + /// Returns true if `defaultString` has been explicitly set. + var hasDefaultString: Bool {_storage._defaultString != nil} + /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. + mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} + + var defaultBytes: Data { + get {_storage._defaultBytes ?? Data([106, 111, 115, 104, 117, 97])} + set {_uniqueStorage()._defaultBytes = newValue} + } + /// Returns true if `defaultBytes` has been explicitly set. + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} + /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. + mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 + + /// Intentionally negative. + case neg = -1 + + init() { + self = .foo + } + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var corecursive: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2 { + get {_storage._corecursive ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var optionalCorecursive: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2 { + get {_storage._optionalCorecursive ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._optionalCorecursive = newValue} + } + /// Returns true if `optionalCorecursive` has been explicitly set. + var hasOptionalCorecursive: Bool {_storage._optionalCorecursive != nil} + /// Clears the value of `optionalCorecursive`. Subsequent reads from it will return its default value. + mutating func clearOptionalCorecursive() {_uniqueStorage()._optionalCorecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + /// groups + struct DataMessage: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + /// message_set test case. + struct MessageSetCorrect: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() + } + + struct MessageSetCorrectExtension1: Sendable { + // 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 str: String { + get {_str ?? String()} + set {_str = newValue} + } + /// Returns true if `str` has been explicitly set. + var hasStr: Bool {self._str != nil} + /// Clears the value of `str`. Subsequent reads from it will return its default value. + mutating func clearStr() {self._str = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _str: String? = nil + } + + struct MessageSetCorrectExtension2: Sendable { + // 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 i: Int32 { + get {_i ?? 0} + set {_i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {self._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {self._i = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _i: Int32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct ProtobufTestMessages_Proto2_TestLargeOneof: Sendable { + // 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 largeOneof: ProtobufTestMessages_Proto2_TestLargeOneof.OneOf_LargeOneof? = nil + + var a1: ProtobufTestMessages_Proto2_TestLargeOneof.A1 { + get { + if case .a1(let v)? = largeOneof {return v} + return ProtobufTestMessages_Proto2_TestLargeOneof.A1() + } + set {largeOneof = .a1(newValue)} + } + + var a2: ProtobufTestMessages_Proto2_TestLargeOneof.A2 { + get { + if case .a2(let v)? = largeOneof {return v} + return ProtobufTestMessages_Proto2_TestLargeOneof.A2() + } + set {largeOneof = .a2(newValue)} + } + + var a3: ProtobufTestMessages_Proto2_TestLargeOneof.A3 { + get { + if case .a3(let v)? = largeOneof {return v} + return ProtobufTestMessages_Proto2_TestLargeOneof.A3() + } + set {largeOneof = .a3(newValue)} + } + + var a4: ProtobufTestMessages_Proto2_TestLargeOneof.A4 { + get { + if case .a4(let v)? = largeOneof {return v} + return ProtobufTestMessages_Proto2_TestLargeOneof.A4() + } + set {largeOneof = .a4(newValue)} + } + + var a5: ProtobufTestMessages_Proto2_TestLargeOneof.A5 { + get { + if case .a5(let v)? = largeOneof {return v} + return ProtobufTestMessages_Proto2_TestLargeOneof.A5() + } + set {largeOneof = .a5(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_LargeOneof: Equatable, Sendable { + case a1(ProtobufTestMessages_Proto2_TestLargeOneof.A1) + case a2(ProtobufTestMessages_Proto2_TestLargeOneof.A2) + case a3(ProtobufTestMessages_Proto2_TestLargeOneof.A3) + case a4(ProtobufTestMessages_Proto2_TestLargeOneof.A4) + case a5(ProtobufTestMessages_Proto2_TestLargeOneof.A5) + + } + + struct A1: Sendable { + // 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 A2: Sendable { + // 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 A3: Sendable { + // 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 A4: Sendable { + // 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 A5: Sendable { + // 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() {} + } + + init() {} +} + +// MARK: - Extension support defined in test_messages_proto2.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect { + + var ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension1_messageSetExtension: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1 { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1()} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension1_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension2_messageSetExtension: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2 { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2()} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension2_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2 { + + var ProtobufTestMessages_Proto2_extensionInt32: Int32 { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32) ?? 0} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_Extensions_extension_int32` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_extensionInt32: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_Extensions_extension_int32`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_extensionInt32() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32) + } + + var ProtobufTestMessages_Proto2_groupField: ProtobufTestMessages_Proto2_GroupField { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_GroupField) ?? ProtobufTestMessages_Proto2_GroupField()} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_GroupField, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_Extensions_GroupField` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_groupField: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_GroupField) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_Extensions_GroupField`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_groupField() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_GroupField) + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect { + + var ProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1 { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1()} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2 { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2()} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Proto2_TestAllTypesProto2_ExtensionWithOneof_extensionWithOneof: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof) ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof()} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_TestAllTypesProto2_ExtensionWithOneof_extensionWithOneof: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_TestAllTypesProto2_ExtensionWithOneof_extensionWithOneof() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof) + } + +} + +// MARK: - File's ExtensionMap: ProtobufTestMessages_Proto2_TestMessagesProto2_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 ProtobufTestMessages_Proto2_TestMessagesProto2_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + ProtobufTestMessages_Proto2_Extensions_extension_int32, + ProtobufTestMessages_Proto2_Extensions_GroupField, + ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, + ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, + ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof, + ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, + ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension +] + +// 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 ProtobufTestMessages_Proto2_Extensions_extension_int32 = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2>( + _protobuf_fieldNumber: 120, + fieldName: "protobuf_test_messages.proto2.extension_int32" +) + +let ProtobufTestMessages_Proto2_Extensions_GroupField = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2>( + _protobuf_fieldNumber: 121, + fieldName: "protobuf_test_messages.proto2.groupfield" +) + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 1547769, + fieldName: "protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension1" + ) + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 4135312, + fieldName: "protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension2" + ) + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof { + enum Extensions { + static let extension_with_oneof = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 123456789, + fieldName: "protobuf_test_messages.proto2.TestAllTypesProto2.ExtensionWithOneof" + ) + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 1547769, + fieldName: "protobuf_test_messages.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension1" + ) + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 4135312, + fieldName: "protobuf_test_messages.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension2" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "protobuf_test_messages.proto2" + +extension ProtobufTestMessages_Proto2_ForeignEnumProto2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypesProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{4}\u{2}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{4}\u{2}optional_string_piece\0\u{3}optional_cord\0\u{4}\u{2}recursive_message\0\u{4}\u{4}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{4}\u{2}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_nested_message\0\u{3}map_string_foreign_message\0\u{3}map_string_nested_enum\0\u{3}map_string_foreign_enum\0\u{3}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_nested_enum\0\u{3}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_nested_enum\0\u{3}map_int32_nested_message\0\u{3}map_int32_bool\0\u{4}\u{7}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_bool\0\u{3}oneof_uint64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_enum\0\u{8}R\u{1}Data\0\u{8}\u{3}MultiWordGroupField\0\u{4}%default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{2}R\u{2}fieldname1\0\u{3}field_name2\0\u{3}_field_name3\0\u{3}field__name4_\0\u{1}field0name5\0\u{3}field_0_name6\0\u{1}fieldName7\0\u{1}FieldName8\0\u{3}field_Name9\0\u{3}Field_Name10\0\u{3}FIELD_NAME11\0\u{3}FIELD_name12\0\u{3}__field_name13\0\u{3}__Field_name14\0\u{3}field__name15\0\u{3}field__Name16\0\u{3}field_name17__\0\u{3}Field_name18__\0\u{4}R\u{1}message_set_correct\0\u{b}reserved_field\0\u{c}h\u{f}hL\u{2}\u{c}\u{7f}Ht\u{3}\u{1}") + + fileprivate class _StorageClass { + var _optionalInt32: Int32? = nil + var _optionalInt64: Int64? = nil + var _optionalUint32: UInt32? = nil + var _optionalUint64: UInt64? = nil + var _optionalSint32: Int32? = nil + var _optionalSint64: Int64? = nil + var _optionalFixed32: UInt32? = nil + var _optionalFixed64: UInt64? = nil + var _optionalSfixed32: Int32? = nil + var _optionalSfixed64: Int64? = nil + var _optionalFloat: Float? = nil + var _optionalDouble: Double? = nil + var _optionalBool: Bool? = nil + var _optionalString: String? = nil + var _optionalBytes: Data? = nil + var _optionalNestedMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage? = nil + var _optionalForeignMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2? = nil + var _optionalNestedEnum: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum? = nil + var _optionalForeignEnum: ProtobufTestMessages_Proto2_ForeignEnumProto2? = nil + var _optionalStringPiece: String? = nil + var _optionalCord: String? = nil + var _recursiveMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2? = nil + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedNestedMessage: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage] = [] + var _repeatedForeignMessage: [ProtobufTestMessages_Proto2_ForeignMessageProto2] = [] + var _repeatedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _repeatedForeignEnum: [ProtobufTestMessages_Proto2_ForeignEnumProto2] = [] + var _repeatedStringPiece: [String] = [] + var _repeatedCord: [String] = [] + var _packedInt32: [Int32] = [] + var _packedInt64: [Int64] = [] + var _packedUint32: [UInt32] = [] + var _packedUint64: [UInt64] = [] + var _packedSint32: [Int32] = [] + var _packedSint64: [Int64] = [] + var _packedFixed32: [UInt32] = [] + var _packedFixed64: [UInt64] = [] + var _packedSfixed32: [Int32] = [] + var _packedSfixed64: [Int64] = [] + var _packedFloat: [Float] = [] + var _packedDouble: [Double] = [] + var _packedBool: [Bool] = [] + var _packedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _unpackedInt32: [Int32] = [] + var _unpackedInt64: [Int64] = [] + var _unpackedUint32: [UInt32] = [] + var _unpackedUint64: [UInt64] = [] + var _unpackedSint32: [Int32] = [] + var _unpackedSint64: [Int64] = [] + var _unpackedFixed32: [UInt32] = [] + var _unpackedFixed64: [UInt64] = [] + var _unpackedSfixed32: [Int32] = [] + var _unpackedSfixed64: [Int64] = [] + var _unpackedFloat: [Float] = [] + var _unpackedDouble: [Double] = [] + var _unpackedBool: [Bool] = [] + var _unpackedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _mapInt32Int32: Dictionary = [:] + var _mapInt64Int64: Dictionary = [:] + var _mapUint32Uint32: Dictionary = [:] + var _mapUint64Uint64: Dictionary = [:] + var _mapSint32Sint32: Dictionary = [:] + var _mapSint64Sint64: Dictionary = [:] + var _mapFixed32Fixed32: Dictionary = [:] + var _mapFixed64Fixed64: Dictionary = [:] + var _mapSfixed32Sfixed32: Dictionary = [:] + var _mapSfixed64Sfixed64: Dictionary = [:] + var _mapInt32Bool: Dictionary = [:] + var _mapInt32Float: Dictionary = [:] + var _mapInt32Double: Dictionary = [:] + var _mapInt32NestedMessage: Dictionary = [:] + var _mapBoolBool: Dictionary = [:] + var _mapStringString: Dictionary = [:] + var _mapStringBytes: Dictionary = [:] + var _mapStringNestedMessage: Dictionary = [:] + var _mapStringForeignMessage: Dictionary = [:] + var _mapStringNestedEnum: Dictionary = [:] + var _mapStringForeignEnum: Dictionary = [:] + var _oneofField: ProtobufTestMessages_Proto2_TestAllTypesProto2.OneOf_OneofField? + var _data: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage? = nil + var _multiWordGroupField: ProtobufTestMessages_Proto2_TestAllTypesProto2.MultiWordGroupField? = nil + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + var _fieldname1: Int32? = nil + var _fieldName2: Int32? = nil + var _fieldName3: Int32? = nil + var _field_Name4_: Int32? = nil + var _field0Name5: Int32? = nil + var _field0Name6: Int32? = nil + var _fieldName7: Int32? = nil + var _fieldName8: Int32? = nil + var _fieldName9: Int32? = nil + var _fieldName10: Int32? = nil + var _fieldName11: Int32? = nil + var _fieldName12: Int32? = nil + var __FieldName13: Int32? = nil + var __FieldName14: Int32? = nil + var _field_Name15: Int32? = nil + var _field_Name16: Int32? = nil + var _fieldName17__: Int32? = nil + var _fieldName18__: Int32? = nil + var _messageSetCorrect: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalNestedMessage = source._optionalNestedMessage + _optionalForeignMessage = source._optionalForeignMessage + _optionalNestedEnum = source._optionalNestedEnum + _optionalForeignEnum = source._optionalForeignEnum + _optionalStringPiece = source._optionalStringPiece + _optionalCord = source._optionalCord + _recursiveMessage = source._recursiveMessage + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedForeignMessage = source._repeatedForeignMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _repeatedForeignEnum = source._repeatedForeignEnum + _repeatedStringPiece = source._repeatedStringPiece + _repeatedCord = source._repeatedCord + _packedInt32 = source._packedInt32 + _packedInt64 = source._packedInt64 + _packedUint32 = source._packedUint32 + _packedUint64 = source._packedUint64 + _packedSint32 = source._packedSint32 + _packedSint64 = source._packedSint64 + _packedFixed32 = source._packedFixed32 + _packedFixed64 = source._packedFixed64 + _packedSfixed32 = source._packedSfixed32 + _packedSfixed64 = source._packedSfixed64 + _packedFloat = source._packedFloat + _packedDouble = source._packedDouble + _packedBool = source._packedBool + _packedNestedEnum = source._packedNestedEnum + _unpackedInt32 = source._unpackedInt32 + _unpackedInt64 = source._unpackedInt64 + _unpackedUint32 = source._unpackedUint32 + _unpackedUint64 = source._unpackedUint64 + _unpackedSint32 = source._unpackedSint32 + _unpackedSint64 = source._unpackedSint64 + _unpackedFixed32 = source._unpackedFixed32 + _unpackedFixed64 = source._unpackedFixed64 + _unpackedSfixed32 = source._unpackedSfixed32 + _unpackedSfixed64 = source._unpackedSfixed64 + _unpackedFloat = source._unpackedFloat + _unpackedDouble = source._unpackedDouble + _unpackedBool = source._unpackedBool + _unpackedNestedEnum = source._unpackedNestedEnum + _mapInt32Int32 = source._mapInt32Int32 + _mapInt64Int64 = source._mapInt64Int64 + _mapUint32Uint32 = source._mapUint32Uint32 + _mapUint64Uint64 = source._mapUint64Uint64 + _mapSint32Sint32 = source._mapSint32Sint32 + _mapSint64Sint64 = source._mapSint64Sint64 + _mapFixed32Fixed32 = source._mapFixed32Fixed32 + _mapFixed64Fixed64 = source._mapFixed64Fixed64 + _mapSfixed32Sfixed32 = source._mapSfixed32Sfixed32 + _mapSfixed64Sfixed64 = source._mapSfixed64Sfixed64 + _mapInt32Bool = source._mapInt32Bool + _mapInt32Float = source._mapInt32Float + _mapInt32Double = source._mapInt32Double + _mapInt32NestedMessage = source._mapInt32NestedMessage + _mapBoolBool = source._mapBoolBool + _mapStringString = source._mapStringString + _mapStringBytes = source._mapStringBytes + _mapStringNestedMessage = source._mapStringNestedMessage + _mapStringForeignMessage = source._mapStringForeignMessage + _mapStringNestedEnum = source._mapStringNestedEnum + _mapStringForeignEnum = source._mapStringForeignEnum + _oneofField = source._oneofField + _data = source._data + _multiWordGroupField = source._multiWordGroupField + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + _fieldname1 = source._fieldname1 + _fieldName2 = source._fieldName2 + _fieldName3 = source._fieldName3 + _field_Name4_ = source._field_Name4_ + _field0Name5 = source._field0Name5 + _field0Name6 = source._field0Name6 + _fieldName7 = source._fieldName7 + _fieldName8 = source._fieldName8 + _fieldName9 = source._fieldName9 + _fieldName10 = source._fieldName10 + _fieldName11 = source._fieldName11 + _fieldName12 = source._fieldName12 + __FieldName13 = source.__FieldName13 + __FieldName14 = source.__FieldName14 + _field_Name15 = source._field_Name15 + _field_Name16 = source._field_Name16 + _fieldName17__ = source._fieldName17__ + _fieldName18__ = source._fieldName18__ + _messageSetCorrect = source._messageSetCorrect + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._optionalNestedMessage, !v.isInitialized {return false} + if let v = _storage._recursiveMessage, !v.isInitialized {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._repeatedNestedMessage) {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._mapInt32NestedMessage) {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._mapStringNestedMessage) {return false} + if let v = _storage._oneofField, !v.isInitialized {return false} + if let v = _storage._messageSetCorrect, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() + case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() + case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() + case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() + case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() + case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() + case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() + case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() + case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() + case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() + case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() + case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() + case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() + case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() + case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() + case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() + case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() + case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() + case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() + case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() + case 56: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Int32) }() + case 57: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() + case 58: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() + case 59: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Uint64) }() + case 60: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Sint32) }() + case 61: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Sint64) }() + case 62: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Fixed32) }() + case 63: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Fixed64) }() + case 64: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Sfixed32) }() + case 65: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Sfixed64) }() + case 66: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Float) }() + case 67: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Double) }() + case 68: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() + case 69: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() + case 70: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() + case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringNestedMessage) }() + case 72: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() + case 73: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringNestedEnum) }() + case 74: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringForeignEnum) }() + case 75: try { try decoder.decodeRepeatedInt32Field(value: &_storage._packedInt32) }() + case 76: try { try decoder.decodeRepeatedInt64Field(value: &_storage._packedInt64) }() + case 77: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._packedUint32) }() + case 78: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._packedUint64) }() + case 79: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._packedSint32) }() + case 80: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._packedSint64) }() + case 81: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._packedFixed32) }() + case 82: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._packedFixed64) }() + case 83: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._packedSfixed32) }() + case 84: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._packedSfixed64) }() + case 85: try { try decoder.decodeRepeatedFloatField(value: &_storage._packedFloat) }() + case 86: try { try decoder.decodeRepeatedDoubleField(value: &_storage._packedDouble) }() + case 87: try { try decoder.decodeRepeatedBoolField(value: &_storage._packedBool) }() + case 88: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedNestedEnum) }() + case 89: try { try decoder.decodeRepeatedInt32Field(value: &_storage._unpackedInt32) }() + case 90: try { try decoder.decodeRepeatedInt64Field(value: &_storage._unpackedInt64) }() + case 91: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._unpackedUint32) }() + case 92: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._unpackedUint64) }() + case 93: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._unpackedSint32) }() + case 94: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._unpackedSint64) }() + case 95: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._unpackedFixed32) }() + case 96: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._unpackedFixed64) }() + case 97: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._unpackedSfixed32) }() + case 98: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._unpackedSfixed64) }() + case 99: try { try decoder.decodeRepeatedFloatField(value: &_storage._unpackedFloat) }() + case 100: try { try decoder.decodeRepeatedDoubleField(value: &_storage._unpackedDouble) }() + case 101: try { try decoder.decodeRepeatedBoolField(value: &_storage._unpackedBool) }() + case 102: try { try decoder.decodeRepeatedEnumField(value: &_storage._unpackedNestedEnum) }() + case 103: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32NestedMessage) }() + case 104: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bool) }() + case 111: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 112: try { + var v: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage(v) + } + }() + case 113: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 114: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() + case 115: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBool(v) + } + }() + case 116: try { + var v: UInt64? + try decoder.decodeSingularUInt64Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint64(v) + } + }() + case 117: try { + var v: Float? + try decoder.decodeSingularFloatField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofFloat(v) + } + }() + case 118: try { + var v: Double? + try decoder.decodeSingularDoubleField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofDouble(v) + } + }() + case 119: try { + var v: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofEnum(v) + } + }() + case 201: try { try decoder.decodeSingularGroupField(value: &_storage._data) }() + case 204: try { try decoder.decodeSingularGroupField(value: &_storage._multiWordGroupField) }() + case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 242: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 243: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 244: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 245: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 246: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 247: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 248: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 249: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 250: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 251: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 252: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 253: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 254: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 255: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() + case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldname1) }() + case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName2) }() + case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName3) }() + case 404: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name4_) }() + case 405: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name5) }() + case 406: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name6) }() + case 407: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName7) }() + case 408: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName8) }() + case 409: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName9) }() + case 410: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName10) }() + case 411: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName11) }() + case 412: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName12) }() + case 413: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName13) }() + case 414: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName14) }() + case 415: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name15) }() + case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name16) }() + case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName17__) }() + case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName18__) }() + case 500: try { try decoder.decodeSingularMessageField(value: &_storage._messageSetCorrect) }() + case 120..<201: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Proto2_TestAllTypesProto2.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._optionalInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._optionalUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._optionalSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._optionalSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._optionalFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._optionalFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._optionalSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._optionalSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._optionalFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._optionalDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._optionalBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._optionalForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._optionalNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._optionalForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._optionalStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._optionalCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + if !_storage._repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + } + if !_storage._repeatedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + } + if !_storage._repeatedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + } + if !_storage._repeatedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + } + if !_storage._repeatedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + } + if !_storage._repeatedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + } + if !_storage._repeatedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + } + if !_storage._repeatedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + } + if !_storage._repeatedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + } + if !_storage._repeatedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + } + if !_storage._repeatedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + } + if !_storage._repeatedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + } + if !_storage._repeatedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + } + if !_storage._repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) + } + if !_storage._repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) + } + if !_storage._repeatedNestedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) + } + if !_storage._repeatedForeignMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) + } + if !_storage._repeatedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + } + if !_storage._repeatedForeignEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) + } + if !_storage._repeatedStringPiece.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) + } + if !_storage._repeatedCord.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) + } + if !_storage._mapInt32Int32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Int32, fieldNumber: 56) + } + if !_storage._mapInt64Int64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Int64, fieldNumber: 57) + } + if !_storage._mapUint32Uint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Uint32, fieldNumber: 58) + } + if !_storage._mapUint64Uint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Uint64, fieldNumber: 59) + } + if !_storage._mapSint32Sint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Sint32, fieldNumber: 60) + } + if !_storage._mapSint64Sint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Sint64, fieldNumber: 61) + } + if !_storage._mapFixed32Fixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Fixed32, fieldNumber: 62) + } + if !_storage._mapFixed64Fixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Fixed64, fieldNumber: 63) + } + if !_storage._mapSfixed32Sfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 64) + } + if !_storage._mapSfixed64Sfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 65) + } + if !_storage._mapInt32Float.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Float, fieldNumber: 66) + } + if !_storage._mapInt32Double.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Double, fieldNumber: 67) + } + if !_storage._mapBoolBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolBool, fieldNumber: 68) + } + if !_storage._mapStringString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringString, fieldNumber: 69) + } + if !_storage._mapStringBytes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 70) + } + if !_storage._mapStringNestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringNestedMessage, fieldNumber: 71) + } + if !_storage._mapStringForeignMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 72) + } + if !_storage._mapStringNestedEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringNestedEnum, fieldNumber: 73) + } + if !_storage._mapStringForeignEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringForeignEnum, fieldNumber: 74) + } + if !_storage._packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._packedInt32, fieldNumber: 75) + } + if !_storage._packedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._packedInt64, fieldNumber: 76) + } + if !_storage._packedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._packedUint32, fieldNumber: 77) + } + if !_storage._packedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._packedUint64, fieldNumber: 78) + } + if !_storage._packedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._packedSint32, fieldNumber: 79) + } + if !_storage._packedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._packedSint64, fieldNumber: 80) + } + if !_storage._packedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._packedFixed32, fieldNumber: 81) + } + if !_storage._packedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._packedFixed64, fieldNumber: 82) + } + if !_storage._packedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._packedSfixed32, fieldNumber: 83) + } + if !_storage._packedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._packedSfixed64, fieldNumber: 84) + } + if !_storage._packedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._packedFloat, fieldNumber: 85) + } + if !_storage._packedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._packedDouble, fieldNumber: 86) + } + if !_storage._packedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._packedBool, fieldNumber: 87) + } + if !_storage._packedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedNestedEnum, fieldNumber: 88) + } + if !_storage._unpackedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._unpackedInt32, fieldNumber: 89) + } + if !_storage._unpackedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._unpackedInt64, fieldNumber: 90) + } + if !_storage._unpackedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._unpackedUint32, fieldNumber: 91) + } + if !_storage._unpackedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._unpackedUint64, fieldNumber: 92) + } + if !_storage._unpackedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._unpackedSint32, fieldNumber: 93) + } + if !_storage._unpackedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._unpackedSint64, fieldNumber: 94) + } + if !_storage._unpackedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._unpackedFixed32, fieldNumber: 95) + } + if !_storage._unpackedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._unpackedFixed64, fieldNumber: 96) + } + if !_storage._unpackedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._unpackedSfixed32, fieldNumber: 97) + } + if !_storage._unpackedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._unpackedSfixed64, fieldNumber: 98) + } + if !_storage._unpackedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._unpackedFloat, fieldNumber: 99) + } + if !_storage._unpackedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._unpackedDouble, fieldNumber: 100) + } + if !_storage._unpackedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._unpackedBool, fieldNumber: 101) + } + if !_storage._unpackedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._unpackedNestedEnum, fieldNumber: 102) + } + if !_storage._mapInt32NestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32NestedMessage, fieldNumber: 103) + } + if !_storage._mapInt32Bool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bool, fieldNumber: 104) + } + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case .oneofBool?: try { + guard case .oneofBool(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 115) + }() + case .oneofUint64?: try { + guard case .oneofUint64(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 116) + }() + case .oneofFloat?: try { + guard case .oneofFloat(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularFloatField(value: v, fieldNumber: 117) + }() + case .oneofDouble?: try { + guard case .oneofDouble(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularDoubleField(value: v, fieldNumber: 118) + }() + case .oneofEnum?: try { + guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 119) + }() + case nil: break + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201) + try { if let v = _storage._data { + try visitor.visitSingularGroupField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._multiWordGroupField { + try visitor.visitSingularGroupField(value: v, fieldNumber: 204) + } }() + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 241) + } }() + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 242) + } }() + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 243) + } }() + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 244) + } }() + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 245) + } }() + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 246) + } }() + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 247) + } }() + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 248) + } }() + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 249) + } }() + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 250) + } }() + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 251) + } }() + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 252) + } }() + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 253) + } }() + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 254) + } }() + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 255) + } }() + try { if let v = _storage._fieldname1 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 401) + } }() + try { if let v = _storage._fieldName2 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 402) + } }() + try { if let v = _storage._fieldName3 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 403) + } }() + try { if let v = _storage._field_Name4_ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 404) + } }() + try { if let v = _storage._field0Name5 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 405) + } }() + try { if let v = _storage._field0Name6 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 406) + } }() + try { if let v = _storage._fieldName7 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 407) + } }() + try { if let v = _storage._fieldName8 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 408) + } }() + try { if let v = _storage._fieldName9 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 409) + } }() + try { if let v = _storage._fieldName10 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 410) + } }() + try { if let v = _storage._fieldName11 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 411) + } }() + try { if let v = _storage._fieldName12 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 412) + } }() + try { if let v = _storage.__FieldName13 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 413) + } }() + try { if let v = _storage.__FieldName14 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 414) + } }() + try { if let v = _storage._field_Name15 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 415) + } }() + try { if let v = _storage._field_Name16 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 416) + } }() + try { if let v = _storage._fieldName17__ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 417) + } }() + try { if let v = _storage._fieldName18__ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 418) + } }() + try { if let v = _storage._messageSetCorrect { + try visitor.visitSingularMessageField(value: v, fieldNumber: 500) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} + if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} + if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} + if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} + if _storage._repeatedCord != rhs_storage._repeatedCord {return false} + if _storage._packedInt32 != rhs_storage._packedInt32 {return false} + if _storage._packedInt64 != rhs_storage._packedInt64 {return false} + if _storage._packedUint32 != rhs_storage._packedUint32 {return false} + if _storage._packedUint64 != rhs_storage._packedUint64 {return false} + if _storage._packedSint32 != rhs_storage._packedSint32 {return false} + if _storage._packedSint64 != rhs_storage._packedSint64 {return false} + if _storage._packedFixed32 != rhs_storage._packedFixed32 {return false} + if _storage._packedFixed64 != rhs_storage._packedFixed64 {return false} + if _storage._packedSfixed32 != rhs_storage._packedSfixed32 {return false} + if _storage._packedSfixed64 != rhs_storage._packedSfixed64 {return false} + if _storage._packedFloat != rhs_storage._packedFloat {return false} + if _storage._packedDouble != rhs_storage._packedDouble {return false} + if _storage._packedBool != rhs_storage._packedBool {return false} + if _storage._packedNestedEnum != rhs_storage._packedNestedEnum {return false} + if _storage._unpackedInt32 != rhs_storage._unpackedInt32 {return false} + if _storage._unpackedInt64 != rhs_storage._unpackedInt64 {return false} + if _storage._unpackedUint32 != rhs_storage._unpackedUint32 {return false} + if _storage._unpackedUint64 != rhs_storage._unpackedUint64 {return false} + if _storage._unpackedSint32 != rhs_storage._unpackedSint32 {return false} + if _storage._unpackedSint64 != rhs_storage._unpackedSint64 {return false} + if _storage._unpackedFixed32 != rhs_storage._unpackedFixed32 {return false} + if _storage._unpackedFixed64 != rhs_storage._unpackedFixed64 {return false} + if _storage._unpackedSfixed32 != rhs_storage._unpackedSfixed32 {return false} + if _storage._unpackedSfixed64 != rhs_storage._unpackedSfixed64 {return false} + if _storage._unpackedFloat != rhs_storage._unpackedFloat {return false} + if _storage._unpackedDouble != rhs_storage._unpackedDouble {return false} + if _storage._unpackedBool != rhs_storage._unpackedBool {return false} + if _storage._unpackedNestedEnum != rhs_storage._unpackedNestedEnum {return false} + if _storage._mapInt32Int32 != rhs_storage._mapInt32Int32 {return false} + if _storage._mapInt64Int64 != rhs_storage._mapInt64Int64 {return false} + if _storage._mapUint32Uint32 != rhs_storage._mapUint32Uint32 {return false} + if _storage._mapUint64Uint64 != rhs_storage._mapUint64Uint64 {return false} + if _storage._mapSint32Sint32 != rhs_storage._mapSint32Sint32 {return false} + if _storage._mapSint64Sint64 != rhs_storage._mapSint64Sint64 {return false} + if _storage._mapFixed32Fixed32 != rhs_storage._mapFixed32Fixed32 {return false} + if _storage._mapFixed64Fixed64 != rhs_storage._mapFixed64Fixed64 {return false} + if _storage._mapSfixed32Sfixed32 != rhs_storage._mapSfixed32Sfixed32 {return false} + if _storage._mapSfixed64Sfixed64 != rhs_storage._mapSfixed64Sfixed64 {return false} + if _storage._mapInt32Bool != rhs_storage._mapInt32Bool {return false} + if _storage._mapInt32Float != rhs_storage._mapInt32Float {return false} + if _storage._mapInt32Double != rhs_storage._mapInt32Double {return false} + if _storage._mapInt32NestedMessage != rhs_storage._mapInt32NestedMessage {return false} + if _storage._mapBoolBool != rhs_storage._mapBoolBool {return false} + if _storage._mapStringString != rhs_storage._mapStringString {return false} + if _storage._mapStringBytes != rhs_storage._mapStringBytes {return false} + if _storage._mapStringNestedMessage != rhs_storage._mapStringNestedMessage {return false} + if _storage._mapStringForeignMessage != rhs_storage._mapStringForeignMessage {return false} + if _storage._mapStringNestedEnum != rhs_storage._mapStringNestedEnum {return false} + if _storage._mapStringForeignEnum != rhs_storage._mapStringForeignEnum {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + if _storage._data != rhs_storage._data {return false} + if _storage._multiWordGroupField != rhs_storage._multiWordGroupField {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} + if _storage._fieldname1 != rhs_storage._fieldname1 {return false} + if _storage._fieldName2 != rhs_storage._fieldName2 {return false} + if _storage._fieldName3 != rhs_storage._fieldName3 {return false} + if _storage._field_Name4_ != rhs_storage._field_Name4_ {return false} + if _storage._field0Name5 != rhs_storage._field0Name5 {return false} + if _storage._field0Name6 != rhs_storage._field0Name6 {return false} + if _storage._fieldName7 != rhs_storage._fieldName7 {return false} + if _storage._fieldName8 != rhs_storage._fieldName8 {return false} + if _storage._fieldName9 != rhs_storage._fieldName9 {return false} + if _storage._fieldName10 != rhs_storage._fieldName10 {return false} + if _storage._fieldName11 != rhs_storage._fieldName11 {return false} + if _storage._fieldName12 != rhs_storage._fieldName12 {return false} + if _storage.__FieldName13 != rhs_storage.__FieldName13 {return false} + if _storage.__FieldName14 != rhs_storage.__FieldName14 {return false} + if _storage._field_Name15 != rhs_storage._field_Name15 {return false} + if _storage._field_Name16 != rhs_storage._field_Name16 {return false} + if _storage._fieldName17__ != rhs_storage._fieldName17__ {return false} + if _storage._fieldName18__ != rhs_storage._fieldName18__ {return false} + if _storage._messageSetCorrect != rhs_storage._messageSetCorrect {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _corecursive: ProtobufTestMessages_Proto2_TestAllTypesProto2? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._corecursive, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}J\u{3}group_int32\0\u{3}group_uint32\0") + + 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 202: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 203: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 202) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 203) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MultiWordGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".MultiWordGroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}M\u{3}group_int32\0\u{3}group_uint32\0") + + 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 205: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 206: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 205) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 206) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MultiWordGroupField, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MultiWordGroupField) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect.self) + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrectExtension1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{19}str\0") + + 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 25: try { try decoder.decodeSingularStringField(value: &self._str) }() + 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 + try { if let v = self._str { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1) -> Bool { + if lhs._str != rhs._str {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrectExtension2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{9}i\0") + + 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 9: try { try decoder.decodeSingularInt32Field(value: &self._i) }() + 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 + try { if let v = self._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2) -> Bool { + if lhs._i != rhs._i {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".ExtensionWithOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .a(v) + } + }() + case 2: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .b(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.oneofField { + case .a?: try { + guard case .a(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + }() + case .b?: try { + guard case .b(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof) -> Bool { + if lhs.oneofField != rhs.oneofField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_ForeignMessageProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessageProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") + + 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._c) }() + 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 + try { if let v = self._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_ForeignMessageProto2, rhs: ProtobufTestMessages_Proto2_ForeignMessageProto2) -> Bool { + if lhs._c != rhs._c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_GroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}z\u{1}group_int32\0\u{3}group_uint32\0") + + 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 122: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 123: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 122) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 123) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_GroupField, rhs: ProtobufTestMessages_Proto2_GroupField) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".UnknownToTestAllTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}i\u{f}optional_int32\0\u{3}optional_string\0\u{3}nested_message\0\u{7}OptionalGroup\0\u{4}\u{2}optional_bool\0\u{4}\u{5}repeated_int32\0") + + 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 1001: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32) }() + case 1002: try { try decoder.decodeSingularStringField(value: &self._optionalString) }() + case 1003: try { try decoder.decodeSingularMessageField(value: &self._nestedMessage) }() + case 1004: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() + case 1006: try { try decoder.decodeSingularBoolField(value: &self._optionalBool) }() + case 1011: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() + 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 + try { if let v = self._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1001) + } }() + try { if let v = self._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1002) + } }() + try { if let v = self._nestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1003) + } }() + try { if let v = self._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 1004) + } }() + try { if let v = self._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1006) + } }() + if !self.repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 1011) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes, rhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes) -> Bool { + if lhs._optionalInt32 != rhs._optionalInt32 {return false} + if lhs._optionalString != rhs._optionalString {return false} + if lhs._nestedMessage != rhs._nestedMessage {return false} + if lhs._optionalGroup != rhs._optionalGroup {return false} + if lhs._optionalBool != rhs._optionalBool {return false} + if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_UnknownToTestAllTypes.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") + + 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._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup, rhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_NullHypothesisProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NullHypothesisProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_NullHypothesisProto2, rhs: ProtobufTestMessages_Proto2_NullHypothesisProto2) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_EnumOnlyProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumOnlyProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_EnumOnlyProto2, rhs: ProtobufTestMessages_Proto2_EnumOnlyProto2) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_EnumOnlyProto2.BoolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0kFalse\0\u{1}kTrue\0") +} + +extension ProtobufTestMessages_Proto2_OneStringProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OneStringProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_OneStringProto2, rhs: ProtobufTestMessages_Proto2_OneStringProto2) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_ProtoWithKeywords: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ProtoWithKeywords" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}inline\0\u{1}concept\0\u{1}requires\0") + + 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._inline) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._concept) }() + case 3: try { try decoder.decodeRepeatedStringField(value: &self.requires) }() + 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 + try { if let v = self._inline { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._concept { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + if !self.requires.isEmpty { + try visitor.visitRepeatedStringField(value: self.requires, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_ProtoWithKeywords, rhs: ProtobufTestMessages_Proto2_ProtoWithKeywords) -> Bool { + if lhs._inline != rhs._inline {return false} + if lhs._concept != rhs._concept {return false} + if lhs.requires != rhs.requires {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllRequiredTypesProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_int32\0\u{3}required_int64\0\u{3}required_uint32\0\u{3}required_uint64\0\u{3}required_sint32\0\u{3}required_sint64\0\u{3}required_fixed32\0\u{3}required_fixed64\0\u{3}required_sfixed32\0\u{3}required_sfixed64\0\u{3}required_float\0\u{3}required_double\0\u{3}required_bool\0\u{3}required_string\0\u{3}required_bytes\0\u{4}\u{3}required_nested_message\0\u{3}required_foreign_message\0\u{4}\u{2}required_nested_enum\0\u{3}required_foreign_enum\0\u{4}\u{2}required_string_piece\0\u{3}required_cord\0\u{4}\u{2}recursive_message\0\u{3}optional_recursive_message\0\u{8}m\u{2}Data\0\u{4}(default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{c}h\u{f}hL\u{2}") + + fileprivate class _StorageClass { + var _requiredInt32: Int32? = nil + var _requiredInt64: Int64? = nil + var _requiredUint32: UInt32? = nil + var _requiredUint64: UInt64? = nil + var _requiredSint32: Int32? = nil + var _requiredSint64: Int64? = nil + var _requiredFixed32: UInt32? = nil + var _requiredFixed64: UInt64? = nil + var _requiredSfixed32: Int32? = nil + var _requiredSfixed64: Int64? = nil + var _requiredFloat: Float? = nil + var _requiredDouble: Double? = nil + var _requiredBool: Bool? = nil + var _requiredString: String? = nil + var _requiredBytes: Data? = nil + var _requiredNestedMessage: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage? = nil + var _requiredForeignMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2? = nil + var _requiredNestedEnum: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedEnum? = nil + var _requiredForeignEnum: ProtobufTestMessages_Proto2_ForeignEnumProto2? = nil + var _requiredStringPiece: String? = nil + var _requiredCord: String? = nil + var _recursiveMessage: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2? = nil + var _optionalRecursiveMessage: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2? = nil + var _data: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage? = nil + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _requiredInt32 = source._requiredInt32 + _requiredInt64 = source._requiredInt64 + _requiredUint32 = source._requiredUint32 + _requiredUint64 = source._requiredUint64 + _requiredSint32 = source._requiredSint32 + _requiredSint64 = source._requiredSint64 + _requiredFixed32 = source._requiredFixed32 + _requiredFixed64 = source._requiredFixed64 + _requiredSfixed32 = source._requiredSfixed32 + _requiredSfixed64 = source._requiredSfixed64 + _requiredFloat = source._requiredFloat + _requiredDouble = source._requiredDouble + _requiredBool = source._requiredBool + _requiredString = source._requiredString + _requiredBytes = source._requiredBytes + _requiredNestedMessage = source._requiredNestedMessage + _requiredForeignMessage = source._requiredForeignMessage + _requiredNestedEnum = source._requiredNestedEnum + _requiredForeignEnum = source._requiredForeignEnum + _requiredStringPiece = source._requiredStringPiece + _requiredCord = source._requiredCord + _recursiveMessage = source._recursiveMessage + _optionalRecursiveMessage = source._optionalRecursiveMessage + _data = source._data + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._requiredInt32 == nil {return false} + if _storage._requiredInt64 == nil {return false} + if _storage._requiredUint32 == nil {return false} + if _storage._requiredUint64 == nil {return false} + if _storage._requiredSint32 == nil {return false} + if _storage._requiredSint64 == nil {return false} + if _storage._requiredFixed32 == nil {return false} + if _storage._requiredFixed64 == nil {return false} + if _storage._requiredSfixed32 == nil {return false} + if _storage._requiredSfixed64 == nil {return false} + if _storage._requiredFloat == nil {return false} + if _storage._requiredDouble == nil {return false} + if _storage._requiredBool == nil {return false} + if _storage._requiredString == nil {return false} + if _storage._requiredBytes == nil {return false} + if _storage._requiredNestedMessage == nil {return false} + if _storage._requiredForeignMessage == nil {return false} + if _storage._requiredNestedEnum == nil {return false} + if _storage._requiredForeignEnum == nil {return false} + if _storage._requiredStringPiece == nil {return false} + if _storage._requiredCord == nil {return false} + if _storage._recursiveMessage == nil {return false} + if _storage._data == nil {return false} + if _storage._defaultInt32 == nil {return false} + if _storage._defaultInt64 == nil {return false} + if _storage._defaultUint32 == nil {return false} + if _storage._defaultUint64 == nil {return false} + if _storage._defaultSint32 == nil {return false} + if _storage._defaultSint64 == nil {return false} + if _storage._defaultFixed32 == nil {return false} + if _storage._defaultFixed64 == nil {return false} + if _storage._defaultSfixed32 == nil {return false} + if _storage._defaultSfixed64 == nil {return false} + if _storage._defaultFloat == nil {return false} + if _storage._defaultDouble == nil {return false} + if _storage._defaultBool == nil {return false} + if _storage._defaultString == nil {return false} + if _storage._defaultBytes == nil {return false} + if let v = _storage._requiredNestedMessage, !v.isInitialized {return false} + if let v = _storage._recursiveMessage, !v.isInitialized {return false} + if let v = _storage._optionalRecursiveMessage, !v.isInitialized {return false} + if let v = _storage._data, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._requiredInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._requiredInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._requiredUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._requiredUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._requiredSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._requiredSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._requiredFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._requiredFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._requiredSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._requiredSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._requiredFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._requiredDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._requiredBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._requiredString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._requiredBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._requiredNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._requiredForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._requiredNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._requiredForeignEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._requiredStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._requiredCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 28: try { try decoder.decodeSingularMessageField(value: &_storage._optionalRecursiveMessage) }() + case 201: try { try decoder.decodeSingularGroupField(value: &_storage._data) }() + case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 242: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 243: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 244: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 245: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 246: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 247: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 248: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 249: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 250: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 251: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 252: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 253: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 254: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 255: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() + case 120..<201: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._requiredInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._requiredInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._requiredUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._requiredUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._requiredSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._requiredSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._requiredFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._requiredFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._requiredSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._requiredSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._requiredFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._requiredDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._requiredBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._requiredString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._requiredBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._requiredNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._requiredForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._requiredNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._requiredForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._requiredStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._requiredCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + try { if let v = _storage._optionalRecursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 28) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201) + try { if let v = _storage._data { + try visitor.visitSingularGroupField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 241) + } }() + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 242) + } }() + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 243) + } }() + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 244) + } }() + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 245) + } }() + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 246) + } }() + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 247) + } }() + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 248) + } }() + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 249) + } }() + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 250) + } }() + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 251) + } }() + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 252) + } }() + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 253) + } }() + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 254) + } }() + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 255) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2) -> 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._requiredInt32 != rhs_storage._requiredInt32 {return false} + if _storage._requiredInt64 != rhs_storage._requiredInt64 {return false} + if _storage._requiredUint32 != rhs_storage._requiredUint32 {return false} + if _storage._requiredUint64 != rhs_storage._requiredUint64 {return false} + if _storage._requiredSint32 != rhs_storage._requiredSint32 {return false} + if _storage._requiredSint64 != rhs_storage._requiredSint64 {return false} + if _storage._requiredFixed32 != rhs_storage._requiredFixed32 {return false} + if _storage._requiredFixed64 != rhs_storage._requiredFixed64 {return false} + if _storage._requiredSfixed32 != rhs_storage._requiredSfixed32 {return false} + if _storage._requiredSfixed64 != rhs_storage._requiredSfixed64 {return false} + if _storage._requiredFloat != rhs_storage._requiredFloat {return false} + if _storage._requiredDouble != rhs_storage._requiredDouble {return false} + if _storage._requiredBool != rhs_storage._requiredBool {return false} + if _storage._requiredString != rhs_storage._requiredString {return false} + if _storage._requiredBytes != rhs_storage._requiredBytes {return false} + if _storage._requiredNestedMessage != rhs_storage._requiredNestedMessage {return false} + if _storage._requiredForeignMessage != rhs_storage._requiredForeignMessage {return false} + if _storage._requiredNestedEnum != rhs_storage._requiredNestedEnum {return false} + if _storage._requiredForeignEnum != rhs_storage._requiredForeignEnum {return false} + if _storage._requiredStringPiece != rhs_storage._requiredStringPiece {return false} + if _storage._requiredCord != rhs_storage._requiredCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._optionalRecursiveMessage != rhs_storage._optionalRecursiveMessage {return false} + if _storage._data != rhs_storage._data {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0\u{3}optional_corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _corecursive: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2? = nil + var _optionalCorecursive: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + _optionalCorecursive = source._optionalCorecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._a == nil {return false} + if _storage._corecursive == nil {return false} + if let v = _storage._corecursive, !v.isInitialized {return false} + if let v = _storage._optionalCorecursive, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._optionalCorecursive) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalCorecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + if _storage._optionalCorecursive != rhs_storage._optionalCorecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}J\u{3}group_int32\0\u{3}group_uint32\0") + + public var isInitialized: Bool { + if self._groupInt32 == nil {return false} + if self._groupUint32 == nil {return false} + return true + } + + 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 202: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 203: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 202) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 203) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".MessageSetCorrect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect.self) + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".MessageSetCorrectExtension1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{19}str\0") + + public var isInitialized: Bool { + if self._str == nil {return false} + return true + } + + 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 25: try { try decoder.decodeSingularStringField(value: &self._str) }() + 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 + try { if let v = self._str { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1) -> Bool { + if lhs._str != rhs._str {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".MessageSetCorrectExtension2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{9}i\0") + + public var isInitialized: Bool { + if self._i == nil {return false} + return true + } + + 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 9: try { try decoder.decodeSingularInt32Field(value: &self._i) }() + 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 + try { if let v = self._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2) -> Bool { + if lhs._i != rhs._i {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestLargeOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestLargeOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a1\0\u{1}a2\0\u{1}a3\0\u{1}a4\0\u{1}a5\0") + + 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: ProtobufTestMessages_Proto2_TestLargeOneof.A1? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a1(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a1(v) + } + }() + case 2: try { + var v: ProtobufTestMessages_Proto2_TestLargeOneof.A2? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a2(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a2(v) + } + }() + case 3: try { + var v: ProtobufTestMessages_Proto2_TestLargeOneof.A3? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a3(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a3(v) + } + }() + case 4: try { + var v: ProtobufTestMessages_Proto2_TestLargeOneof.A4? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a4(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a4(v) + } + }() + case 5: try { + var v: ProtobufTestMessages_Proto2_TestLargeOneof.A5? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a5(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a5(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.largeOneof { + case .a1?: try { + guard case .a1(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + }() + case .a2?: try { + guard case .a2(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + }() + case .a3?: try { + guard case .a3(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + }() + case .a4?: try { + guard case .a4(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + }() + case .a5?: try { + guard case .a5(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestLargeOneof, rhs: ProtobufTestMessages_Proto2_TestLargeOneof) -> Bool { + if lhs.largeOneof != rhs.largeOneof {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestLargeOneof.A1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestLargeOneof.protoMessageName + ".A1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestLargeOneof.A1, rhs: ProtobufTestMessages_Proto2_TestLargeOneof.A1) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestLargeOneof.A2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestLargeOneof.protoMessageName + ".A2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestLargeOneof.A2, rhs: ProtobufTestMessages_Proto2_TestLargeOneof.A2) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestLargeOneof.A3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestLargeOneof.protoMessageName + ".A3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestLargeOneof.A3, rhs: ProtobufTestMessages_Proto2_TestLargeOneof.A3) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestLargeOneof.A4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestLargeOneof.protoMessageName + ".A4" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestLargeOneof.A4, rhs: ProtobufTestMessages_Proto2_TestLargeOneof.A4) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestLargeOneof.A5: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestLargeOneof.protoMessageName + ".A5" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestLargeOneof.A5, rhs: ProtobufTestMessages_Proto2_TestLargeOneof.A5) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/google/protobuf/test_messages_proto3.pb.swift b/Reference/Sources/Conformance/google/protobuf/test_messages_proto3.pb.swift similarity index 82% rename from Reference/google/protobuf/test_messages_proto3.pb.swift rename to Reference/Sources/Conformance/google/protobuf/test_messages_proto3.pb.swift index 4bd18c700..6e42eff19 100644 --- a/Reference/google/protobuf/test_messages_proto3.pb.swift +++ b/Reference/Sources/Conformance/google/protobuf/test_messages_proto3.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/test_messages_proto3.proto @@ -9,33 +10,10 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd // // Test schema for proto3 messages. This test schema is used by: // @@ -56,7 +34,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum ProtobufTestMessages_Proto3_ForeignEnum: SwiftProtobuf.Enum { +enum ProtobufTestMessages_Proto3_ForeignEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foreignFoo // = 0 case foreignBar // = 1 @@ -85,20 +63,14 @@ enum ProtobufTestMessages_Proto3_ForeignEnum: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension ProtobufTestMessages_Proto3_ForeignEnum: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufTestMessages_Proto3_ForeignEnum] = [ + static let allCases: [ProtobufTestMessages_Proto3_ForeignEnum] = [ .foreignFoo, .foreignBar, .foreignBaz, ] -} -#endif // swift(>=4.2) +} /// This proto includes every type of field in both singular and repeated /// forms. @@ -107,480 +79,481 @@ extension ProtobufTestMessages_Proto3_ForeignEnum: CaseIterable { /// submessages of this message. So for example, a fuzz test of TestAllTypes /// could trigger bugs that occur in any message type in this file. We verify /// this stays true in a unit test. -struct ProtobufTestMessages_Proto3_TestAllTypesProto3 { +struct ProtobufTestMessages_Proto3_TestAllTypesProto3: @unchecked Sendable { // 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. /// Singular + /// test [kotlin] comment var optionalInt32: Int32 { - get {return _storage._optionalInt32} + get {_storage._optionalInt32} set {_uniqueStorage()._optionalInt32 = newValue} } var optionalInt64: Int64 { - get {return _storage._optionalInt64} + get {_storage._optionalInt64} set {_uniqueStorage()._optionalInt64 = newValue} } var optionalUint32: UInt32 { - get {return _storage._optionalUint32} + get {_storage._optionalUint32} set {_uniqueStorage()._optionalUint32 = newValue} } var optionalUint64: UInt64 { - get {return _storage._optionalUint64} + get {_storage._optionalUint64} set {_uniqueStorage()._optionalUint64 = newValue} } var optionalSint32: Int32 { - get {return _storage._optionalSint32} + get {_storage._optionalSint32} set {_uniqueStorage()._optionalSint32 = newValue} } var optionalSint64: Int64 { - get {return _storage._optionalSint64} + get {_storage._optionalSint64} set {_uniqueStorage()._optionalSint64 = newValue} } var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32} + get {_storage._optionalFixed32} set {_uniqueStorage()._optionalFixed32 = newValue} } var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64} + get {_storage._optionalFixed64} set {_uniqueStorage()._optionalFixed64 = newValue} } var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32} + get {_storage._optionalSfixed32} set {_uniqueStorage()._optionalSfixed32 = newValue} } var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64} + get {_storage._optionalSfixed64} set {_uniqueStorage()._optionalSfixed64 = newValue} } var optionalFloat: Float { - get {return _storage._optionalFloat} + get {_storage._optionalFloat} set {_uniqueStorage()._optionalFloat = newValue} } var optionalDouble: Double { - get {return _storage._optionalDouble} + get {_storage._optionalDouble} set {_uniqueStorage()._optionalDouble = newValue} } var optionalBool: Bool { - get {return _storage._optionalBool} + get {_storage._optionalBool} set {_uniqueStorage()._optionalBool = newValue} } var optionalString: String { - get {return _storage._optionalString} + get {_storage._optionalString} set {_uniqueStorage()._optionalString = newValue} } var optionalBytes: Data { - get {return _storage._optionalBytes} + get {_storage._optionalBytes} set {_uniqueStorage()._optionalBytes = newValue} } var optionalNestedMessage: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage { - get {return _storage._optionalNestedMessage ?? ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage()} + get {_storage._optionalNestedMessage ?? ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage()} set {_uniqueStorage()._optionalNestedMessage = newValue} } /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} var optionalForeignMessage: ProtobufTestMessages_Proto3_ForeignMessage { - get {return _storage._optionalForeignMessage ?? ProtobufTestMessages_Proto3_ForeignMessage()} + get {_storage._optionalForeignMessage ?? ProtobufTestMessages_Proto3_ForeignMessage()} set {_uniqueStorage()._optionalForeignMessage = newValue} } /// Returns true if `optionalForeignMessage` has been explicitly set. - var hasOptionalForeignMessage: Bool {return _storage._optionalForeignMessage != nil} + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} var optionalNestedEnum: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum { - get {return _storage._optionalNestedEnum} + get {_storage._optionalNestedEnum} set {_uniqueStorage()._optionalNestedEnum = newValue} } var optionalForeignEnum: ProtobufTestMessages_Proto3_ForeignEnum { - get {return _storage._optionalForeignEnum} + get {_storage._optionalForeignEnum} set {_uniqueStorage()._optionalForeignEnum = newValue} } var optionalAliasedEnum: ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum { - get {return _storage._optionalAliasedEnum} + get {_storage._optionalAliasedEnum} set {_uniqueStorage()._optionalAliasedEnum = newValue} } var optionalStringPiece: String { - get {return _storage._optionalStringPiece} + get {_storage._optionalStringPiece} set {_uniqueStorage()._optionalStringPiece = newValue} } var optionalCord: String { - get {return _storage._optionalCord} + get {_storage._optionalCord} set {_uniqueStorage()._optionalCord = newValue} } var recursiveMessage: ProtobufTestMessages_Proto3_TestAllTypesProto3 { - get {return _storage._recursiveMessage ?? ProtobufTestMessages_Proto3_TestAllTypesProto3()} + get {_storage._recursiveMessage ?? ProtobufTestMessages_Proto3_TestAllTypesProto3()} set {_uniqueStorage()._recursiveMessage = newValue} } /// Returns true if `recursiveMessage` has been explicitly set. - var hasRecursiveMessage: Bool {return _storage._recursiveMessage != nil} + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} /// Repeated var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } var repeatedNestedMessage: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage] { - get {return _storage._repeatedNestedMessage} + get {_storage._repeatedNestedMessage} set {_uniqueStorage()._repeatedNestedMessage = newValue} } var repeatedForeignMessage: [ProtobufTestMessages_Proto3_ForeignMessage] { - get {return _storage._repeatedForeignMessage} + get {_storage._repeatedForeignMessage} set {_uniqueStorage()._repeatedForeignMessage = newValue} } var repeatedNestedEnum: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] { - get {return _storage._repeatedNestedEnum} + get {_storage._repeatedNestedEnum} set {_uniqueStorage()._repeatedNestedEnum = newValue} } var repeatedForeignEnum: [ProtobufTestMessages_Proto3_ForeignEnum] { - get {return _storage._repeatedForeignEnum} + get {_storage._repeatedForeignEnum} set {_uniqueStorage()._repeatedForeignEnum = newValue} } var repeatedStringPiece: [String] { - get {return _storage._repeatedStringPiece} + get {_storage._repeatedStringPiece} set {_uniqueStorage()._repeatedStringPiece = newValue} } var repeatedCord: [String] { - get {return _storage._repeatedCord} + get {_storage._repeatedCord} set {_uniqueStorage()._repeatedCord = newValue} } /// Packed var packedInt32: [Int32] { - get {return _storage._packedInt32} + get {_storage._packedInt32} set {_uniqueStorage()._packedInt32 = newValue} } var packedInt64: [Int64] { - get {return _storage._packedInt64} + get {_storage._packedInt64} set {_uniqueStorage()._packedInt64 = newValue} } var packedUint32: [UInt32] { - get {return _storage._packedUint32} + get {_storage._packedUint32} set {_uniqueStorage()._packedUint32 = newValue} } var packedUint64: [UInt64] { - get {return _storage._packedUint64} + get {_storage._packedUint64} set {_uniqueStorage()._packedUint64 = newValue} } var packedSint32: [Int32] { - get {return _storage._packedSint32} + get {_storage._packedSint32} set {_uniqueStorage()._packedSint32 = newValue} } var packedSint64: [Int64] { - get {return _storage._packedSint64} + get {_storage._packedSint64} set {_uniqueStorage()._packedSint64 = newValue} } var packedFixed32: [UInt32] { - get {return _storage._packedFixed32} + get {_storage._packedFixed32} set {_uniqueStorage()._packedFixed32 = newValue} } var packedFixed64: [UInt64] { - get {return _storage._packedFixed64} + get {_storage._packedFixed64} set {_uniqueStorage()._packedFixed64 = newValue} } var packedSfixed32: [Int32] { - get {return _storage._packedSfixed32} + get {_storage._packedSfixed32} set {_uniqueStorage()._packedSfixed32 = newValue} } var packedSfixed64: [Int64] { - get {return _storage._packedSfixed64} + get {_storage._packedSfixed64} set {_uniqueStorage()._packedSfixed64 = newValue} } var packedFloat: [Float] { - get {return _storage._packedFloat} + get {_storage._packedFloat} set {_uniqueStorage()._packedFloat = newValue} } var packedDouble: [Double] { - get {return _storage._packedDouble} + get {_storage._packedDouble} set {_uniqueStorage()._packedDouble = newValue} } var packedBool: [Bool] { - get {return _storage._packedBool} + get {_storage._packedBool} set {_uniqueStorage()._packedBool = newValue} } var packedNestedEnum: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] { - get {return _storage._packedNestedEnum} + get {_storage._packedNestedEnum} set {_uniqueStorage()._packedNestedEnum = newValue} } /// Unpacked var unpackedInt32: [Int32] { - get {return _storage._unpackedInt32} + get {_storage._unpackedInt32} set {_uniqueStorage()._unpackedInt32 = newValue} } var unpackedInt64: [Int64] { - get {return _storage._unpackedInt64} + get {_storage._unpackedInt64} set {_uniqueStorage()._unpackedInt64 = newValue} } var unpackedUint32: [UInt32] { - get {return _storage._unpackedUint32} + get {_storage._unpackedUint32} set {_uniqueStorage()._unpackedUint32 = newValue} } var unpackedUint64: [UInt64] { - get {return _storage._unpackedUint64} + get {_storage._unpackedUint64} set {_uniqueStorage()._unpackedUint64 = newValue} } var unpackedSint32: [Int32] { - get {return _storage._unpackedSint32} + get {_storage._unpackedSint32} set {_uniqueStorage()._unpackedSint32 = newValue} } var unpackedSint64: [Int64] { - get {return _storage._unpackedSint64} + get {_storage._unpackedSint64} set {_uniqueStorage()._unpackedSint64 = newValue} } var unpackedFixed32: [UInt32] { - get {return _storage._unpackedFixed32} + get {_storage._unpackedFixed32} set {_uniqueStorage()._unpackedFixed32 = newValue} } var unpackedFixed64: [UInt64] { - get {return _storage._unpackedFixed64} + get {_storage._unpackedFixed64} set {_uniqueStorage()._unpackedFixed64 = newValue} } var unpackedSfixed32: [Int32] { - get {return _storage._unpackedSfixed32} + get {_storage._unpackedSfixed32} set {_uniqueStorage()._unpackedSfixed32 = newValue} } var unpackedSfixed64: [Int64] { - get {return _storage._unpackedSfixed64} + get {_storage._unpackedSfixed64} set {_uniqueStorage()._unpackedSfixed64 = newValue} } var unpackedFloat: [Float] { - get {return _storage._unpackedFloat} + get {_storage._unpackedFloat} set {_uniqueStorage()._unpackedFloat = newValue} } var unpackedDouble: [Double] { - get {return _storage._unpackedDouble} + get {_storage._unpackedDouble} set {_uniqueStorage()._unpackedDouble = newValue} } var unpackedBool: [Bool] { - get {return _storage._unpackedBool} + get {_storage._unpackedBool} set {_uniqueStorage()._unpackedBool = newValue} } var unpackedNestedEnum: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] { - get {return _storage._unpackedNestedEnum} + get {_storage._unpackedNestedEnum} set {_uniqueStorage()._unpackedNestedEnum = newValue} } /// Map var mapInt32Int32: Dictionary { - get {return _storage._mapInt32Int32} + get {_storage._mapInt32Int32} set {_uniqueStorage()._mapInt32Int32 = newValue} } var mapInt64Int64: Dictionary { - get {return _storage._mapInt64Int64} + get {_storage._mapInt64Int64} set {_uniqueStorage()._mapInt64Int64 = newValue} } var mapUint32Uint32: Dictionary { - get {return _storage._mapUint32Uint32} + get {_storage._mapUint32Uint32} set {_uniqueStorage()._mapUint32Uint32 = newValue} } var mapUint64Uint64: Dictionary { - get {return _storage._mapUint64Uint64} + get {_storage._mapUint64Uint64} set {_uniqueStorage()._mapUint64Uint64 = newValue} } var mapSint32Sint32: Dictionary { - get {return _storage._mapSint32Sint32} + get {_storage._mapSint32Sint32} set {_uniqueStorage()._mapSint32Sint32 = newValue} } var mapSint64Sint64: Dictionary { - get {return _storage._mapSint64Sint64} + get {_storage._mapSint64Sint64} set {_uniqueStorage()._mapSint64Sint64 = newValue} } var mapFixed32Fixed32: Dictionary { - get {return _storage._mapFixed32Fixed32} + get {_storage._mapFixed32Fixed32} set {_uniqueStorage()._mapFixed32Fixed32 = newValue} } var mapFixed64Fixed64: Dictionary { - get {return _storage._mapFixed64Fixed64} + get {_storage._mapFixed64Fixed64} set {_uniqueStorage()._mapFixed64Fixed64 = newValue} } var mapSfixed32Sfixed32: Dictionary { - get {return _storage._mapSfixed32Sfixed32} + get {_storage._mapSfixed32Sfixed32} set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} } var mapSfixed64Sfixed64: Dictionary { - get {return _storage._mapSfixed64Sfixed64} + get {_storage._mapSfixed64Sfixed64} set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} } var mapInt32Float: Dictionary { - get {return _storage._mapInt32Float} + get {_storage._mapInt32Float} set {_uniqueStorage()._mapInt32Float = newValue} } var mapInt32Double: Dictionary { - get {return _storage._mapInt32Double} + get {_storage._mapInt32Double} set {_uniqueStorage()._mapInt32Double = newValue} } var mapBoolBool: Dictionary { - get {return _storage._mapBoolBool} + get {_storage._mapBoolBool} set {_uniqueStorage()._mapBoolBool = newValue} } var mapStringString: Dictionary { - get {return _storage._mapStringString} + get {_storage._mapStringString} set {_uniqueStorage()._mapStringString = newValue} } var mapStringBytes: Dictionary { - get {return _storage._mapStringBytes} + get {_storage._mapStringBytes} set {_uniqueStorage()._mapStringBytes = newValue} } var mapStringNestedMessage: Dictionary { - get {return _storage._mapStringNestedMessage} + get {_storage._mapStringNestedMessage} set {_uniqueStorage()._mapStringNestedMessage = newValue} } var mapStringForeignMessage: Dictionary { - get {return _storage._mapStringForeignMessage} + get {_storage._mapStringForeignMessage} set {_uniqueStorage()._mapStringForeignMessage = newValue} } var mapStringNestedEnum: Dictionary { - get {return _storage._mapStringNestedEnum} + get {_storage._mapStringNestedEnum} set {_uniqueStorage()._mapStringNestedEnum = newValue} } var mapStringForeignEnum: Dictionary { - get {return _storage._mapStringForeignEnum} + get {_storage._mapStringForeignEnum} set {_uniqueStorage()._mapStringForeignEnum = newValue} } @@ -671,320 +644,320 @@ struct ProtobufTestMessages_Proto3_TestAllTypesProto3 { /// Well-known types var optionalBoolWrapper: SwiftProtobuf.Google_Protobuf_BoolValue { - get {return _storage._optionalBoolWrapper ?? SwiftProtobuf.Google_Protobuf_BoolValue()} + get {_storage._optionalBoolWrapper ?? SwiftProtobuf.Google_Protobuf_BoolValue()} set {_uniqueStorage()._optionalBoolWrapper = newValue} } /// Returns true if `optionalBoolWrapper` has been explicitly set. - var hasOptionalBoolWrapper: Bool {return _storage._optionalBoolWrapper != nil} + var hasOptionalBoolWrapper: Bool {_storage._optionalBoolWrapper != nil} /// Clears the value of `optionalBoolWrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalBoolWrapper() {_uniqueStorage()._optionalBoolWrapper = nil} var optionalInt32Wrapper: SwiftProtobuf.Google_Protobuf_Int32Value { - get {return _storage._optionalInt32Wrapper ?? SwiftProtobuf.Google_Protobuf_Int32Value()} + get {_storage._optionalInt32Wrapper ?? SwiftProtobuf.Google_Protobuf_Int32Value()} set {_uniqueStorage()._optionalInt32Wrapper = newValue} } /// Returns true if `optionalInt32Wrapper` has been explicitly set. - var hasOptionalInt32Wrapper: Bool {return _storage._optionalInt32Wrapper != nil} + var hasOptionalInt32Wrapper: Bool {_storage._optionalInt32Wrapper != nil} /// Clears the value of `optionalInt32Wrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalInt32Wrapper() {_uniqueStorage()._optionalInt32Wrapper = nil} var optionalInt64Wrapper: SwiftProtobuf.Google_Protobuf_Int64Value { - get {return _storage._optionalInt64Wrapper ?? SwiftProtobuf.Google_Protobuf_Int64Value()} + get {_storage._optionalInt64Wrapper ?? SwiftProtobuf.Google_Protobuf_Int64Value()} set {_uniqueStorage()._optionalInt64Wrapper = newValue} } /// Returns true if `optionalInt64Wrapper` has been explicitly set. - var hasOptionalInt64Wrapper: Bool {return _storage._optionalInt64Wrapper != nil} + var hasOptionalInt64Wrapper: Bool {_storage._optionalInt64Wrapper != nil} /// Clears the value of `optionalInt64Wrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalInt64Wrapper() {_uniqueStorage()._optionalInt64Wrapper = nil} var optionalUint32Wrapper: SwiftProtobuf.Google_Protobuf_UInt32Value { - get {return _storage._optionalUint32Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} + get {_storage._optionalUint32Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} set {_uniqueStorage()._optionalUint32Wrapper = newValue} } /// Returns true if `optionalUint32Wrapper` has been explicitly set. - var hasOptionalUint32Wrapper: Bool {return _storage._optionalUint32Wrapper != nil} + var hasOptionalUint32Wrapper: Bool {_storage._optionalUint32Wrapper != nil} /// Clears the value of `optionalUint32Wrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalUint32Wrapper() {_uniqueStorage()._optionalUint32Wrapper = nil} var optionalUint64Wrapper: SwiftProtobuf.Google_Protobuf_UInt64Value { - get {return _storage._optionalUint64Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} + get {_storage._optionalUint64Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} set {_uniqueStorage()._optionalUint64Wrapper = newValue} } /// Returns true if `optionalUint64Wrapper` has been explicitly set. - var hasOptionalUint64Wrapper: Bool {return _storage._optionalUint64Wrapper != nil} + var hasOptionalUint64Wrapper: Bool {_storage._optionalUint64Wrapper != nil} /// Clears the value of `optionalUint64Wrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalUint64Wrapper() {_uniqueStorage()._optionalUint64Wrapper = nil} var optionalFloatWrapper: SwiftProtobuf.Google_Protobuf_FloatValue { - get {return _storage._optionalFloatWrapper ?? SwiftProtobuf.Google_Protobuf_FloatValue()} + get {_storage._optionalFloatWrapper ?? SwiftProtobuf.Google_Protobuf_FloatValue()} set {_uniqueStorage()._optionalFloatWrapper = newValue} } /// Returns true if `optionalFloatWrapper` has been explicitly set. - var hasOptionalFloatWrapper: Bool {return _storage._optionalFloatWrapper != nil} + var hasOptionalFloatWrapper: Bool {_storage._optionalFloatWrapper != nil} /// Clears the value of `optionalFloatWrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalFloatWrapper() {_uniqueStorage()._optionalFloatWrapper = nil} var optionalDoubleWrapper: SwiftProtobuf.Google_Protobuf_DoubleValue { - get {return _storage._optionalDoubleWrapper ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} + get {_storage._optionalDoubleWrapper ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} set {_uniqueStorage()._optionalDoubleWrapper = newValue} } /// Returns true if `optionalDoubleWrapper` has been explicitly set. - var hasOptionalDoubleWrapper: Bool {return _storage._optionalDoubleWrapper != nil} + var hasOptionalDoubleWrapper: Bool {_storage._optionalDoubleWrapper != nil} /// Clears the value of `optionalDoubleWrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalDoubleWrapper() {_uniqueStorage()._optionalDoubleWrapper = nil} var optionalStringWrapper: SwiftProtobuf.Google_Protobuf_StringValue { - get {return _storage._optionalStringWrapper ?? SwiftProtobuf.Google_Protobuf_StringValue()} + get {_storage._optionalStringWrapper ?? SwiftProtobuf.Google_Protobuf_StringValue()} set {_uniqueStorage()._optionalStringWrapper = newValue} } /// Returns true if `optionalStringWrapper` has been explicitly set. - var hasOptionalStringWrapper: Bool {return _storage._optionalStringWrapper != nil} + var hasOptionalStringWrapper: Bool {_storage._optionalStringWrapper != nil} /// Clears the value of `optionalStringWrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalStringWrapper() {_uniqueStorage()._optionalStringWrapper = nil} var optionalBytesWrapper: SwiftProtobuf.Google_Protobuf_BytesValue { - get {return _storage._optionalBytesWrapper ?? SwiftProtobuf.Google_Protobuf_BytesValue()} + get {_storage._optionalBytesWrapper ?? SwiftProtobuf.Google_Protobuf_BytesValue()} set {_uniqueStorage()._optionalBytesWrapper = newValue} } /// Returns true if `optionalBytesWrapper` has been explicitly set. - var hasOptionalBytesWrapper: Bool {return _storage._optionalBytesWrapper != nil} + var hasOptionalBytesWrapper: Bool {_storage._optionalBytesWrapper != nil} /// Clears the value of `optionalBytesWrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalBytesWrapper() {_uniqueStorage()._optionalBytesWrapper = nil} var repeatedBoolWrapper: [SwiftProtobuf.Google_Protobuf_BoolValue] { - get {return _storage._repeatedBoolWrapper} + get {_storage._repeatedBoolWrapper} set {_uniqueStorage()._repeatedBoolWrapper = newValue} } var repeatedInt32Wrapper: [SwiftProtobuf.Google_Protobuf_Int32Value] { - get {return _storage._repeatedInt32Wrapper} + get {_storage._repeatedInt32Wrapper} set {_uniqueStorage()._repeatedInt32Wrapper = newValue} } var repeatedInt64Wrapper: [SwiftProtobuf.Google_Protobuf_Int64Value] { - get {return _storage._repeatedInt64Wrapper} + get {_storage._repeatedInt64Wrapper} set {_uniqueStorage()._repeatedInt64Wrapper = newValue} } var repeatedUint32Wrapper: [SwiftProtobuf.Google_Protobuf_UInt32Value] { - get {return _storage._repeatedUint32Wrapper} + get {_storage._repeatedUint32Wrapper} set {_uniqueStorage()._repeatedUint32Wrapper = newValue} } var repeatedUint64Wrapper: [SwiftProtobuf.Google_Protobuf_UInt64Value] { - get {return _storage._repeatedUint64Wrapper} + get {_storage._repeatedUint64Wrapper} set {_uniqueStorage()._repeatedUint64Wrapper = newValue} } var repeatedFloatWrapper: [SwiftProtobuf.Google_Protobuf_FloatValue] { - get {return _storage._repeatedFloatWrapper} + get {_storage._repeatedFloatWrapper} set {_uniqueStorage()._repeatedFloatWrapper = newValue} } var repeatedDoubleWrapper: [SwiftProtobuf.Google_Protobuf_DoubleValue] { - get {return _storage._repeatedDoubleWrapper} + get {_storage._repeatedDoubleWrapper} set {_uniqueStorage()._repeatedDoubleWrapper = newValue} } var repeatedStringWrapper: [SwiftProtobuf.Google_Protobuf_StringValue] { - get {return _storage._repeatedStringWrapper} + get {_storage._repeatedStringWrapper} set {_uniqueStorage()._repeatedStringWrapper = newValue} } var repeatedBytesWrapper: [SwiftProtobuf.Google_Protobuf_BytesValue] { - get {return _storage._repeatedBytesWrapper} + get {_storage._repeatedBytesWrapper} set {_uniqueStorage()._repeatedBytesWrapper = newValue} } var optionalDuration: SwiftProtobuf.Google_Protobuf_Duration { - get {return _storage._optionalDuration ?? SwiftProtobuf.Google_Protobuf_Duration()} + get {_storage._optionalDuration ?? SwiftProtobuf.Google_Protobuf_Duration()} set {_uniqueStorage()._optionalDuration = newValue} } /// Returns true if `optionalDuration` has been explicitly set. - var hasOptionalDuration: Bool {return _storage._optionalDuration != nil} + var hasOptionalDuration: Bool {_storage._optionalDuration != nil} /// Clears the value of `optionalDuration`. Subsequent reads from it will return its default value. mutating func clearOptionalDuration() {_uniqueStorage()._optionalDuration = nil} var optionalTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp { - get {return _storage._optionalTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()} + get {_storage._optionalTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()} set {_uniqueStorage()._optionalTimestamp = newValue} } /// Returns true if `optionalTimestamp` has been explicitly set. - var hasOptionalTimestamp: Bool {return _storage._optionalTimestamp != nil} + var hasOptionalTimestamp: Bool {_storage._optionalTimestamp != nil} /// Clears the value of `optionalTimestamp`. Subsequent reads from it will return its default value. mutating func clearOptionalTimestamp() {_uniqueStorage()._optionalTimestamp = nil} var optionalFieldMask: SwiftProtobuf.Google_Protobuf_FieldMask { - get {return _storage._optionalFieldMask ?? SwiftProtobuf.Google_Protobuf_FieldMask()} + get {_storage._optionalFieldMask ?? SwiftProtobuf.Google_Protobuf_FieldMask()} set {_uniqueStorage()._optionalFieldMask = newValue} } /// Returns true if `optionalFieldMask` has been explicitly set. - var hasOptionalFieldMask: Bool {return _storage._optionalFieldMask != nil} + var hasOptionalFieldMask: Bool {_storage._optionalFieldMask != nil} /// Clears the value of `optionalFieldMask`. Subsequent reads from it will return its default value. mutating func clearOptionalFieldMask() {_uniqueStorage()._optionalFieldMask = nil} var optionalStruct: SwiftProtobuf.Google_Protobuf_Struct { - get {return _storage._optionalStruct ?? SwiftProtobuf.Google_Protobuf_Struct()} + get {_storage._optionalStruct ?? SwiftProtobuf.Google_Protobuf_Struct()} set {_uniqueStorage()._optionalStruct = newValue} } /// Returns true if `optionalStruct` has been explicitly set. - var hasOptionalStruct: Bool {return _storage._optionalStruct != nil} + var hasOptionalStruct: Bool {_storage._optionalStruct != nil} /// Clears the value of `optionalStruct`. Subsequent reads from it will return its default value. mutating func clearOptionalStruct() {_uniqueStorage()._optionalStruct = nil} var optionalAny: SwiftProtobuf.Google_Protobuf_Any { - get {return _storage._optionalAny ?? SwiftProtobuf.Google_Protobuf_Any()} + get {_storage._optionalAny ?? SwiftProtobuf.Google_Protobuf_Any()} set {_uniqueStorage()._optionalAny = newValue} } /// Returns true if `optionalAny` has been explicitly set. - var hasOptionalAny: Bool {return _storage._optionalAny != nil} + var hasOptionalAny: Bool {_storage._optionalAny != nil} /// Clears the value of `optionalAny`. Subsequent reads from it will return its default value. mutating func clearOptionalAny() {_uniqueStorage()._optionalAny = nil} var optionalValue: SwiftProtobuf.Google_Protobuf_Value { - get {return _storage._optionalValue ?? SwiftProtobuf.Google_Protobuf_Value()} + get {_storage._optionalValue ?? SwiftProtobuf.Google_Protobuf_Value()} set {_uniqueStorage()._optionalValue = newValue} } /// Returns true if `optionalValue` has been explicitly set. - var hasOptionalValue: Bool {return _storage._optionalValue != nil} + var hasOptionalValue: Bool {_storage._optionalValue != nil} /// Clears the value of `optionalValue`. Subsequent reads from it will return its default value. mutating func clearOptionalValue() {_uniqueStorage()._optionalValue = nil} var optionalNullValue: SwiftProtobuf.Google_Protobuf_NullValue { - get {return _storage._optionalNullValue} + get {_storage._optionalNullValue} set {_uniqueStorage()._optionalNullValue = newValue} } var repeatedDuration: [SwiftProtobuf.Google_Protobuf_Duration] { - get {return _storage._repeatedDuration} + get {_storage._repeatedDuration} set {_uniqueStorage()._repeatedDuration = newValue} } var repeatedTimestamp: [SwiftProtobuf.Google_Protobuf_Timestamp] { - get {return _storage._repeatedTimestamp} + get {_storage._repeatedTimestamp} set {_uniqueStorage()._repeatedTimestamp = newValue} } var repeatedFieldmask: [SwiftProtobuf.Google_Protobuf_FieldMask] { - get {return _storage._repeatedFieldmask} + get {_storage._repeatedFieldmask} set {_uniqueStorage()._repeatedFieldmask = newValue} } var repeatedStruct: [SwiftProtobuf.Google_Protobuf_Struct] { - get {return _storage._repeatedStruct} + get {_storage._repeatedStruct} set {_uniqueStorage()._repeatedStruct = newValue} } var repeatedAny: [SwiftProtobuf.Google_Protobuf_Any] { - get {return _storage._repeatedAny} + get {_storage._repeatedAny} set {_uniqueStorage()._repeatedAny = newValue} } var repeatedValue: [SwiftProtobuf.Google_Protobuf_Value] { - get {return _storage._repeatedValue} + get {_storage._repeatedValue} set {_uniqueStorage()._repeatedValue = newValue} } var repeatedListValue: [SwiftProtobuf.Google_Protobuf_ListValue] { - get {return _storage._repeatedListValue} + get {_storage._repeatedListValue} set {_uniqueStorage()._repeatedListValue = newValue} } /// Test field-name-to-JSON-name convention. /// (protobuf says names can be any valid C/C++ identifier.) var fieldname1: Int32 { - get {return _storage._fieldname1} + get {_storage._fieldname1} set {_uniqueStorage()._fieldname1 = newValue} } var fieldName2: Int32 { - get {return _storage._fieldName2} + get {_storage._fieldName2} set {_uniqueStorage()._fieldName2 = newValue} } var fieldName3: Int32 { - get {return _storage._fieldName3} + get {_storage._fieldName3} set {_uniqueStorage()._fieldName3 = newValue} } var field_Name4_: Int32 { - get {return _storage._field_Name4_} + get {_storage._field_Name4_} set {_uniqueStorage()._field_Name4_ = newValue} } var field0Name5: Int32 { - get {return _storage._field0Name5} + get {_storage._field0Name5} set {_uniqueStorage()._field0Name5 = newValue} } var field0Name6: Int32 { - get {return _storage._field0Name6} + get {_storage._field0Name6} set {_uniqueStorage()._field0Name6 = newValue} } var fieldName7: Int32 { - get {return _storage._fieldName7} + get {_storage._fieldName7} set {_uniqueStorage()._fieldName7 = newValue} } var fieldName8: Int32 { - get {return _storage._fieldName8} + get {_storage._fieldName8} set {_uniqueStorage()._fieldName8 = newValue} } var fieldName9: Int32 { - get {return _storage._fieldName9} + get {_storage._fieldName9} set {_uniqueStorage()._fieldName9 = newValue} } var fieldName10: Int32 { - get {return _storage._fieldName10} + get {_storage._fieldName10} set {_uniqueStorage()._fieldName10 = newValue} } var fieldName11: Int32 { - get {return _storage._fieldName11} + get {_storage._fieldName11} set {_uniqueStorage()._fieldName11 = newValue} } var fieldName12: Int32 { - get {return _storage._fieldName12} + get {_storage._fieldName12} set {_uniqueStorage()._fieldName12 = newValue} } var _FieldName13: Int32 { - get {return _storage.__FieldName13} + get {_storage.__FieldName13} set {_uniqueStorage().__FieldName13 = newValue} } var _FieldName14: Int32 { - get {return _storage.__FieldName14} + get {_storage.__FieldName14} set {_uniqueStorage().__FieldName14 = newValue} } var field_Name15: Int32 { - get {return _storage._field_Name15} + get {_storage._field_Name15} set {_uniqueStorage()._field_Name15 = newValue} } var field_Name16: Int32 { - get {return _storage._field_Name16} + get {_storage._field_Name16} set {_uniqueStorage()._field_Name16 = newValue} } var fieldName17__: Int32 { - get {return _storage._fieldName17__} + get {_storage._fieldName17__} set {_uniqueStorage()._fieldName17__ = newValue} } var fieldName18__: Int32 { - get {return _storage._fieldName18__} + get {_storage._fieldName18__} set {_uniqueStorage()._fieldName18__ = newValue} } var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case oneofUint32(UInt32) case oneofNestedMessage(ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage) case oneofString(String) @@ -996,59 +969,9 @@ struct ProtobufTestMessages_Proto3_TestAllTypesProto3 { case oneofEnum(ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum) case oneofNullValue(SwiftProtobuf.Google_Protobuf_NullValue) - #if !swift(>=4.1) - static func ==(lhs: ProtobufTestMessages_Proto3_TestAllTypesProto3.OneOf_OneofField, rhs: ProtobufTestMessages_Proto3_TestAllTypesProto3.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBool, .oneofBool): return { - guard case .oneofBool(let l) = lhs, case .oneofBool(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint64, .oneofUint64): return { - guard case .oneofUint64(let l) = lhs, case .oneofUint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFloat, .oneofFloat): return { - guard case .oneofFloat(let l) = lhs, case .oneofFloat(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofDouble, .oneofDouble): return { - guard case .oneofDouble(let l) = lhs, case .oneofDouble(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofEnum, .oneofEnum): return { - guard case .oneofEnum(let l) = lhs, case .oneofEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNullValue, .oneofNullValue): return { - guard case .oneofNullValue(let l) = lhs, case .oneofNullValue(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum NestedEnum: SwiftProtobuf.Enum { + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foo // = 0 case bar // = 1 @@ -1082,14 +1005,22 @@ struct ProtobufTestMessages_Proto3_TestAllTypesProto3 { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] = [ + .foo, + .bar, + .baz, + .neg, + ] + } - enum AliasedEnum: SwiftProtobuf.Enum { + enum AliasedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case aliasFoo // = 0 case aliasBar // = 1 case aliasBaz // = 2 - static let qux = aliasBaz + static let moo = aliasBaz static let bAz = aliasBaz case UNRECOGNIZED(Int) @@ -1115,24 +1046,31 @@ struct ProtobufTestMessages_Proto3_TestAllTypesProto3 { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum] = [ + .aliasFoo, + .aliasBar, + .aliasBaz, + ] + } - struct NestedMessage { + struct NestedMessage: @unchecked Sendable { // 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 a: Int32 { - get {return _storage._a} + get {_storage._a} set {_uniqueStorage()._a = newValue} } var corecursive: ProtobufTestMessages_Proto3_TestAllTypesProto3 { - get {return _storage._corecursive ?? ProtobufTestMessages_Proto3_TestAllTypesProto3()} + get {_storage._corecursive ?? ProtobufTestMessages_Proto3_TestAllTypesProto3()} set {_uniqueStorage()._corecursive = newValue} } /// Returns true if `corecursive` has been explicitly set. - var hasCorecursive: Bool {return _storage._corecursive != nil} + var hasCorecursive: Bool {_storage._corecursive != nil} /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} @@ -1148,30 +1086,7 @@ struct ProtobufTestMessages_Proto3_TestAllTypesProto3 { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] = [ - .foo, - .bar, - .baz, - .neg, - ] -} - -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum] = [ - .aliasFoo, - .aliasBar, - .aliasBaz, - ] -} - -#endif // swift(>=4.2) - -struct ProtobufTestMessages_Proto3_ForeignMessage { +struct ProtobufTestMessages_Proto3_ForeignMessage: Sendable { // 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. @@ -1183,7 +1098,7 @@ struct ProtobufTestMessages_Proto3_ForeignMessage { init() {} } -struct ProtobufTestMessages_Proto3_NullHypothesisProto3 { +struct ProtobufTestMessages_Proto3_NullHypothesisProto3: Sendable { // 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. @@ -1193,14 +1108,14 @@ struct ProtobufTestMessages_Proto3_NullHypothesisProto3 { init() {} } -struct ProtobufTestMessages_Proto3_EnumOnlyProto3 { +struct ProtobufTestMessages_Proto3_EnumOnlyProto3: Sendable { // 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() - enum BoolEnum: SwiftProtobuf.Enum { + enum BoolEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case kFalse // = 0 case kTrue // = 1 @@ -1226,203 +1141,28 @@ struct ProtobufTestMessages_Proto3_EnumOnlyProto3 { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Proto3_EnumOnlyProto3.BoolEnum] = [ + .kFalse, + .kTrue, + ] + } init() {} } -#if swift(>=4.2) - -extension ProtobufTestMessages_Proto3_EnumOnlyProto3.BoolEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufTestMessages_Proto3_EnumOnlyProto3.BoolEnum] = [ - .kFalse, - .kTrue, - ] -} - -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufTestMessages_Proto3_ForeignEnum: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_TestAllTypesProto3: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_ForeignMessage: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_NullHypothesisProto3: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_EnumOnlyProto3: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_EnumOnlyProto3.BoolEnum: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "protobuf_test_messages.proto3" extension ProtobufTestMessages_Proto3_ForeignEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOREIGN_FOO"), - 1: .same(proto: "FOREIGN_BAR"), - 2: .same(proto: "FOREIGN_BAZ"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") } extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestAllTypesProto3" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "optional_foreign_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "optional_foreign_enum"), - 23: .standard(proto: "optional_aliased_enum"), - 24: .standard(proto: "optional_string_piece"), - 25: .standard(proto: "optional_cord"), - 27: .standard(proto: "recursive_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 48: .standard(proto: "repeated_nested_message"), - 49: .standard(proto: "repeated_foreign_message"), - 51: .standard(proto: "repeated_nested_enum"), - 52: .standard(proto: "repeated_foreign_enum"), - 54: .standard(proto: "repeated_string_piece"), - 55: .standard(proto: "repeated_cord"), - 75: .standard(proto: "packed_int32"), - 76: .standard(proto: "packed_int64"), - 77: .standard(proto: "packed_uint32"), - 78: .standard(proto: "packed_uint64"), - 79: .standard(proto: "packed_sint32"), - 80: .standard(proto: "packed_sint64"), - 81: .standard(proto: "packed_fixed32"), - 82: .standard(proto: "packed_fixed64"), - 83: .standard(proto: "packed_sfixed32"), - 84: .standard(proto: "packed_sfixed64"), - 85: .standard(proto: "packed_float"), - 86: .standard(proto: "packed_double"), - 87: .standard(proto: "packed_bool"), - 88: .standard(proto: "packed_nested_enum"), - 89: .standard(proto: "unpacked_int32"), - 90: .standard(proto: "unpacked_int64"), - 91: .standard(proto: "unpacked_uint32"), - 92: .standard(proto: "unpacked_uint64"), - 93: .standard(proto: "unpacked_sint32"), - 94: .standard(proto: "unpacked_sint64"), - 95: .standard(proto: "unpacked_fixed32"), - 96: .standard(proto: "unpacked_fixed64"), - 97: .standard(proto: "unpacked_sfixed32"), - 98: .standard(proto: "unpacked_sfixed64"), - 99: .standard(proto: "unpacked_float"), - 100: .standard(proto: "unpacked_double"), - 101: .standard(proto: "unpacked_bool"), - 102: .standard(proto: "unpacked_nested_enum"), - 56: .standard(proto: "map_int32_int32"), - 57: .standard(proto: "map_int64_int64"), - 58: .standard(proto: "map_uint32_uint32"), - 59: .standard(proto: "map_uint64_uint64"), - 60: .standard(proto: "map_sint32_sint32"), - 61: .standard(proto: "map_sint64_sint64"), - 62: .standard(proto: "map_fixed32_fixed32"), - 63: .standard(proto: "map_fixed64_fixed64"), - 64: .standard(proto: "map_sfixed32_sfixed32"), - 65: .standard(proto: "map_sfixed64_sfixed64"), - 66: .standard(proto: "map_int32_float"), - 67: .standard(proto: "map_int32_double"), - 68: .standard(proto: "map_bool_bool"), - 69: .standard(proto: "map_string_string"), - 70: .standard(proto: "map_string_bytes"), - 71: .standard(proto: "map_string_nested_message"), - 72: .standard(proto: "map_string_foreign_message"), - 73: .standard(proto: "map_string_nested_enum"), - 74: .standard(proto: "map_string_foreign_enum"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - 115: .standard(proto: "oneof_bool"), - 116: .standard(proto: "oneof_uint64"), - 117: .standard(proto: "oneof_float"), - 118: .standard(proto: "oneof_double"), - 119: .standard(proto: "oneof_enum"), - 120: .standard(proto: "oneof_null_value"), - 201: .standard(proto: "optional_bool_wrapper"), - 202: .standard(proto: "optional_int32_wrapper"), - 203: .standard(proto: "optional_int64_wrapper"), - 204: .standard(proto: "optional_uint32_wrapper"), - 205: .standard(proto: "optional_uint64_wrapper"), - 206: .standard(proto: "optional_float_wrapper"), - 207: .standard(proto: "optional_double_wrapper"), - 208: .standard(proto: "optional_string_wrapper"), - 209: .standard(proto: "optional_bytes_wrapper"), - 211: .standard(proto: "repeated_bool_wrapper"), - 212: .standard(proto: "repeated_int32_wrapper"), - 213: .standard(proto: "repeated_int64_wrapper"), - 214: .standard(proto: "repeated_uint32_wrapper"), - 215: .standard(proto: "repeated_uint64_wrapper"), - 216: .standard(proto: "repeated_float_wrapper"), - 217: .standard(proto: "repeated_double_wrapper"), - 218: .standard(proto: "repeated_string_wrapper"), - 219: .standard(proto: "repeated_bytes_wrapper"), - 301: .standard(proto: "optional_duration"), - 302: .standard(proto: "optional_timestamp"), - 303: .standard(proto: "optional_field_mask"), - 304: .standard(proto: "optional_struct"), - 305: .standard(proto: "optional_any"), - 306: .standard(proto: "optional_value"), - 307: .standard(proto: "optional_null_value"), - 311: .standard(proto: "repeated_duration"), - 312: .standard(proto: "repeated_timestamp"), - 313: .standard(proto: "repeated_fieldmask"), - 324: .standard(proto: "repeated_struct"), - 315: .standard(proto: "repeated_any"), - 316: .standard(proto: "repeated_value"), - 317: .standard(proto: "repeated_list_value"), - 401: .same(proto: "fieldname1"), - 402: .standard(proto: "field_name2"), - 403: .standard(proto: "_field_name3"), - 404: .standard(proto: "field__name4_"), - 405: .same(proto: "field0name5"), - 406: .standard(proto: "field_0_name6"), - 407: .same(proto: "fieldName7"), - 408: .same(proto: "FieldName8"), - 409: .standard(proto: "field_Name9"), - 410: .standard(proto: "Field_Name10"), - 411: .standard(proto: "FIELD_NAME11"), - 412: .standard(proto: "FIELD_name12"), - 413: .standard(proto: "__field_name13"), - 414: .standard(proto: "__Field_name14"), - 415: .standard(proto: "field__name15"), - 416: .standard(proto: "field__Name16"), - 417: .standard(proto: "field_name17__"), - 418: .standard(proto: "Field_name18__"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{4}\u{2}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{3}optional_aliased_enum\0\u{3}optional_string_piece\0\u{3}optional_cord\0\u{4}\u{2}recursive_message\0\u{4}\u{4}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{4}\u{2}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_nested_message\0\u{3}map_string_foreign_message\0\u{3}map_string_nested_enum\0\u{3}map_string_foreign_enum\0\u{3}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_nested_enum\0\u{3}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_nested_enum\0\u{4}\u{9}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_bool\0\u{3}oneof_uint64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_enum\0\u{3}oneof_null_value\0\u{4}Q\u{1}optional_bool_wrapper\0\u{3}optional_int32_wrapper\0\u{3}optional_int64_wrapper\0\u{3}optional_uint32_wrapper\0\u{3}optional_uint64_wrapper\0\u{3}optional_float_wrapper\0\u{3}optional_double_wrapper\0\u{3}optional_string_wrapper\0\u{3}optional_bytes_wrapper\0\u{4}\u{2}repeated_bool_wrapper\0\u{3}repeated_int32_wrapper\0\u{3}repeated_int64_wrapper\0\u{3}repeated_uint32_wrapper\0\u{3}repeated_uint64_wrapper\0\u{3}repeated_float_wrapper\0\u{3}repeated_double_wrapper\0\u{3}repeated_string_wrapper\0\u{3}repeated_bytes_wrapper\0\u{4}R\u{1}optional_duration\0\u{3}optional_timestamp\0\u{3}optional_field_mask\0\u{3}optional_struct\0\u{3}optional_any\0\u{3}optional_value\0\u{3}optional_null_value\0\u{4}\u{4}repeated_duration\0\u{3}repeated_timestamp\0\u{3}repeated_fieldmask\0\u{4}\u{2}repeated_any\0\u{3}repeated_value\0\u{3}repeated_list_value\0\u{4}\u{7}repeated_struct\0\u{2}M\u{1}fieldname1\0\u{3}field_name2\0\u{3}_field_name3\0\u{3}field__name4_\0\u{1}field0name5\0\u{3}field_0_name6\0\u{1}fieldName7\0\u{1}FieldName8\0\u{3}field_Name9\0\u{3}Field_Name10\0\u{3}FIELD_NAME11\0\u{3}FIELD_name12\0\u{3}__field_name13\0\u{3}__Field_name14\0\u{3}field__name15\0\u{3}field__Name16\0\u{3}field_name17__\0\u{3}Field_name18__\0\u{b}reserved_field\0\u{c}u\u{7}\u{a}\u{c}\u{7f}Ht\u{3}\u{1}") fileprivate class _StorageClass { var _optionalInt32: Int32 = 0 @@ -1568,7 +1308,11 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, var _fieldName17__: Int32 = 0 var _fieldName18__: Int32 = 0 - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -2001,10 +1745,10 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, if _storage._optionalSfixed64 != 0 { try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) } - if _storage._optionalFloat != 0 { + if _storage._optionalFloat.bitPattern != 0 { try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) } - if _storage._optionalDouble != 0 { + if _storage._optionalDouble.bitPattern != 0 { try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) } if _storage._optionalBool != false { @@ -2598,34 +2342,26 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, } extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -1: .same(proto: "NEG"), - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") } extension ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ALIAS_FOO"), - 1: .same(proto: "ALIAS_BAR"), - 2: .aliased(proto: "ALIAS_BAZ", aliases: ["QUX", "qux", "bAz"]), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ALIAS_FOO\0\u{1}ALIAS_BAR\0\u{9}ALIAS_BAZ\0\u{3}MOO\0moo\0bAz\0") } extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = ProtobufTestMessages_Proto3_TestAllTypesProto3.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 2: .same(proto: "corecursive"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0") fileprivate class _StorageClass { var _a: Int32 = 0 var _corecursive: ProtobufTestMessages_Proto3_TestAllTypesProto3? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -2692,9 +2428,7 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage: SwiftPro extension ProtobufTestMessages_Proto3_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ForeignMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -2727,8 +2461,8 @@ extension ProtobufTestMessages_Proto3_NullHypothesisProto3: SwiftProtobuf.Messag static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { @@ -2746,8 +2480,8 @@ extension ProtobufTestMessages_Proto3_EnumOnlyProto3: SwiftProtobuf.Message, Swi static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { @@ -2761,8 +2495,5 @@ extension ProtobufTestMessages_Proto3_EnumOnlyProto3: SwiftProtobuf.Message, Swi } extension ProtobufTestMessages_Proto3_EnumOnlyProto3.BoolEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "kFalse"), - 1: .same(proto: "kTrue"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0kFalse\0\u{1}kTrue\0") } diff --git a/Reference/google/protobuf/any.pb.swift b/Reference/Sources/SwiftProtobuf/google/protobuf/any.pb.swift similarity index 90% rename from Reference/google/protobuf/any.pb.swift rename to Reference/Sources/SwiftProtobuf/google/protobuf/any.pb.swift index 78ab12d6e..76c554248 100644 --- a/Reference/google/protobuf/any.pb.swift +++ b/Reference/Sources/SwiftProtobuf/google/protobuf/any.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/any.proto @@ -38,14 +39,15 @@ // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } @@ -73,6 +75,10 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// if (any.is(Foo.class)) { /// foo = any.unpack(Foo.class); /// } +/// // or ... +/// if (any.isSameTypeAs(Foo.getDefaultInstance())) { +/// foo = any.unpack(Foo.getDefaultInstance()); +/// } /// /// Example 3: Pack and unpack a message in Python. /// @@ -103,7 +109,6 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// in the type URL, for example "foo.bar.com/x/y.z" will yield type /// name "y.z". /// -/// /// JSON /// ==== /// The JSON representation of an `Any` value uses the regular @@ -131,7 +136,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// "@type": "type.googleapis.com/google.protobuf.Duration", /// "value": "1.212s" /// } -struct Google_Protobuf_Any { +struct Google_Protobuf_Any: @unchecked Sendable { // 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. @@ -159,42 +164,36 @@ struct Google_Protobuf_Any { /// /// Note: this functionality is not currently available in the official /// protobuf release, and it is not used for type URLs beginning with - /// type.googleapis.com. + /// type.googleapis.com. As of May 2023, there are no widely used type server + /// implementations and no plans to implement one. /// /// Schemes other than `http`, `https` (or the empty scheme) might be /// used with implementation specific semantics. var typeURL: String { - get {return _storage._typeURL} + get {_storage._typeURL} set {_uniqueStorage()._typeURL = newValue} } /// Must be a valid serialized protocol buffer of the above specified type. var value: Data { - get {return _storage._value} + get {_storage._value} set {_uniqueStorage()._value = newValue} } - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} internal var _storage = _StorageClass.defaultInstance } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_Any: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_Any: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Any: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Any" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "type_url"), - 2: .same(proto: "value"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}type_url\0\u{1}value\0") typealias _StorageClass = AnyMessageStorage @@ -205,7 +204,7 @@ extension Google_Protobuf_Any: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl return _storage } - mutating func decodeMessage(decoder: inout D) throws { + mutating func decodeMessage(decoder: inout D) throws { _ = _uniqueStorage() try withExtendedLifetime(_storage) { (_storage: _StorageClass) in while let fieldNumber = try decoder.nextFieldNumber() { @@ -221,7 +220,7 @@ extension Google_Protobuf_Any: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { try withExtendedLifetime(_storage) { (_storage: _StorageClass) in try _storage.preTraverse() if !_storage._typeURL.isEmpty { diff --git a/Reference/google/protobuf/api.pb.swift b/Reference/Sources/SwiftProtobuf/google/protobuf/api.pb.swift similarity index 82% rename from Reference/google/protobuf/api.pb.swift rename to Reference/Sources/SwiftProtobuf/google/protobuf/api.pb.swift index c0d5bb1e1..645cddc18 100644 --- a/Reference/google/protobuf/api.pb.swift +++ b/Reference/Sources/SwiftProtobuf/google/protobuf/api.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/api.proto @@ -37,15 +38,15 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } @@ -58,7 +59,12 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// sometimes simply referred to as "APIs" in other contexts, such as the name of /// this message itself. See https://cloud.google.com/apis/design/glossary for /// detailed terminology. -struct Google_Protobuf_Api { +/// +/// New usages of this message as an alternative to ServiceDescriptorProto are +/// strongly discouraged. This message does not reliability preserve all +/// information necessary to model the schema and preserve semantics. Instead +/// make use of FileDescriptorSet which preserves the necessary information. +struct Google_Protobuf_Api: Sendable { // 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. @@ -97,11 +103,11 @@ struct Google_Protobuf_Api { /// Source context for the protocol buffer service represented by this /// message. var sourceContext: Google_Protobuf_SourceContext { - get {return _sourceContext ?? Google_Protobuf_SourceContext()} + get {_sourceContext ?? Google_Protobuf_SourceContext()} set {_sourceContext = newValue} } /// Returns true if `sourceContext` has been explicitly set. - var hasSourceContext: Bool {return self._sourceContext != nil} + var hasSourceContext: Bool {self._sourceContext != nil} /// Clears the value of `sourceContext`. Subsequent reads from it will return its default value. mutating func clearSourceContext() {self._sourceContext = nil} @@ -111,7 +117,10 @@ struct Google_Protobuf_Api { /// The source syntax of the service. var syntax: Google_Protobuf_Syntax = .proto2 - var unknownFields = SwiftProtobuf.UnknownStorage() + /// The source edition string, only valid when syntax is SYNTAX_EDITIONS. + var edition: String = String() + + var unknownFields = UnknownStorage() init() {} @@ -119,7 +128,12 @@ struct Google_Protobuf_Api { } /// Method represents a method of an API interface. -struct Google_Protobuf_Method { +/// +/// New usages of this message as an alternative to MethodDescriptorProto are +/// strongly discouraged. This message does not reliability preserve all +/// information necessary to model the schema and preserve semantics. Instead +/// make use of FileDescriptorSet which preserves the necessary information. +struct Google_Protobuf_Method: Sendable { // 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. @@ -143,9 +157,22 @@ struct Google_Protobuf_Method { var options: [Google_Protobuf_Option] = [] /// The source syntax of this method. + /// + /// This field should be ignored, instead the syntax should be inherited from + /// Api. This is similar to Field and EnumValue. + /// + /// NOTE: This field was marked as deprecated in the .proto file. var syntax: Google_Protobuf_Syntax = .proto2 - var unknownFields = SwiftProtobuf.UnknownStorage() + /// The source edition string, only valid when syntax is SYNTAX_EDITIONS. + /// + /// This field should be ignored, instead the edition should be inherited from + /// Api. This is similar to Field and EnumValue. + /// + /// NOTE: This field was marked as deprecated in the .proto file. + var edition: String = String() + + var unknownFields = UnknownStorage() init() {} } @@ -228,7 +255,7 @@ struct Google_Protobuf_Method { /// } /// ... /// } -struct Google_Protobuf_Mixin { +struct Google_Protobuf_Mixin: Sendable { // 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. @@ -240,34 +267,20 @@ struct Google_Protobuf_Mixin { /// are rooted. var root: String = String() - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_Api: @unchecked Sendable {} -extension Google_Protobuf_Method: @unchecked Sendable {} -extension Google_Protobuf_Mixin: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_Api: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Api: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Api" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "methods"), - 3: .same(proto: "options"), - 4: .same(proto: "version"), - 5: .standard(proto: "source_context"), - 6: .same(proto: "mixins"), - 7: .same(proto: "syntax"), - ] - - mutating func decodeMessage(decoder: inout D) throws { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}methods\0\u{1}options\0\u{1}version\0\u{3}source_context\0\u{1}mixins\0\u{1}syntax\0\u{1}edition\0") + + 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 @@ -280,12 +293,13 @@ extension Google_Protobuf_Api: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl case 5: try { try decoder.decodeSingularMessageField(value: &self._sourceContext) }() case 6: try { try decoder.decodeRepeatedMessageField(value: &self.mixins) }() case 7: try { try decoder.decodeSingularEnumField(value: &self.syntax) }() + case 8: try { try decoder.decodeSingularStringField(value: &self.edition) }() default: break } } } - func traverse(visitor: inout V) throws { + 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 @@ -311,6 +325,9 @@ extension Google_Protobuf_Api: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl if self.syntax != .proto2 { try visitor.visitSingularEnumField(value: self.syntax, fieldNumber: 7) } + if !self.edition.isEmpty { + try visitor.visitSingularStringField(value: self.edition, fieldNumber: 8) + } try unknownFields.traverse(visitor: &visitor) } @@ -322,24 +339,17 @@ extension Google_Protobuf_Api: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl if lhs._sourceContext != rhs._sourceContext {return false} if lhs.mixins != rhs.mixins {return false} if lhs.syntax != rhs.syntax {return false} + if lhs.edition != rhs.edition {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_Method: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Method: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Method" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .standard(proto: "request_type_url"), - 3: .standard(proto: "request_streaming"), - 4: .standard(proto: "response_type_url"), - 5: .standard(proto: "response_streaming"), - 6: .same(proto: "options"), - 7: .same(proto: "syntax"), - ] - - mutating func decodeMessage(decoder: inout D) throws { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{3}request_type_url\0\u{3}request_streaming\0\u{3}response_type_url\0\u{3}response_streaming\0\u{1}options\0\u{1}syntax\0\u{1}edition\0") + + 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 @@ -352,12 +362,13 @@ extension Google_Protobuf_Method: SwiftProtobuf.Message, SwiftProtobuf._MessageI case 5: try { try decoder.decodeSingularBoolField(value: &self.responseStreaming) }() case 6: try { try decoder.decodeRepeatedMessageField(value: &self.options) }() case 7: try { try decoder.decodeSingularEnumField(value: &self.syntax) }() + case 8: try { try decoder.decodeSingularStringField(value: &self.edition) }() default: break } } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if !self.name.isEmpty { try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) } @@ -379,6 +390,9 @@ extension Google_Protobuf_Method: SwiftProtobuf.Message, SwiftProtobuf._MessageI if self.syntax != .proto2 { try visitor.visitSingularEnumField(value: self.syntax, fieldNumber: 7) } + if !self.edition.isEmpty { + try visitor.visitSingularStringField(value: self.edition, fieldNumber: 8) + } try unknownFields.traverse(visitor: &visitor) } @@ -390,19 +404,17 @@ extension Google_Protobuf_Method: SwiftProtobuf.Message, SwiftProtobuf._MessageI if lhs.responseStreaming != rhs.responseStreaming {return false} if lhs.options != rhs.options {return false} if lhs.syntax != rhs.syntax {return false} + if lhs.edition != rhs.edition {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_Mixin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Mixin: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Mixin" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "root"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}root\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -415,7 +427,7 @@ extension Google_Protobuf_Mixin: SwiftProtobuf.Message, SwiftProtobuf._MessageIm } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if !self.name.isEmpty { try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) } diff --git a/Reference/google/protobuf/descriptor.pb.swift b/Reference/Sources/SwiftProtobuf/google/protobuf/descriptor.pb.swift similarity index 51% rename from Reference/google/protobuf/descriptor.pb.swift rename to Reference/Sources/SwiftProtobuf/google/protobuf/descriptor.pb.swift index caa8964a0..870941e7f 100644 --- a/Reference/google/protobuf/descriptor.pb.swift +++ b/Reference/Sources/SwiftProtobuf/google/protobuf/descriptor.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/descriptor.proto @@ -46,54 +47,118 @@ // without any other information (e.g. without reading its imports). import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } +/// The full set of known editions. +enum Google_Protobuf_Edition: Int, Enum, Swift.CaseIterable { + + /// A placeholder for an unknown edition value. + case unknown = 0 + + /// A placeholder edition for specifying default behaviors *before* a feature + /// was first introduced. This is effectively an "infinite past". + case legacy = 900 + + /// Legacy syntax "editions". These pre-date editions, but behave much like + /// distinct editions. These can't be used to specify the edition of proto + /// files, but feature definitions must supply proto2/proto3 defaults for + /// backwards compatibility. + case proto2 = 998 + case proto3 = 999 + + /// Editions that have been released. The specific values are arbitrary and + /// should not be depended on, but they will always be time-ordered for easy + /// comparison. + case edition2023 = 1000 + case edition2024 = 1001 + + /// A placeholder edition for developing and testing unscheduled features. + case unstable = 9999 + + /// Placeholder editions for testing feature resolution. These should not be + /// used or relied on outside of tests. + case edition1TestOnly = 1 + case edition2TestOnly = 2 + case edition99997TestOnly = 99997 + case edition99998TestOnly = 99998 + case edition99999TestOnly = 99999 + + /// Placeholder for specifying unbounded edition support. This should only + /// ever be used by plugins that can expect to never require any changes to + /// support a new edition. + case max = 2147483647 + + init() { + self = .unknown + } + +} + +/// Describes the 'visibility' of a symbol with respect to the proto import +/// system. Symbols can only be imported when the visibility rules do not prevent +/// it (ex: local symbols cannot be imported). Visibility modifiers can only set +/// on `message` and `enum` as they are the only types available to be referenced +/// from other files. +enum Google_Protobuf_SymbolVisibility: Int, Enum, Swift.CaseIterable { + case visibilityUnset = 0 + case visibilityLocal = 1 + case visibilityExport = 2 + + init() { + self = .visibilityUnset + } + +} + /// The protocol compiler can output a FileDescriptorSet containing the .proto /// files it parses. -struct Google_Protobuf_FileDescriptorSet { +struct Google_Protobuf_FileDescriptorSet: ExtensibleMessage, Sendable { // 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 file: [Google_Protobuf_FileDescriptorProto] = [] - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} + + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() } /// Describes a complete .proto file. -struct Google_Protobuf_FileDescriptorProto { +struct Google_Protobuf_FileDescriptorProto: Sendable { // 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. /// file name, relative to root of source tree var name: String { - get {return _name ?? String()} + get {_name ?? String()} set {_name = newValue} } /// Returns true if `name` has been explicitly set. - var hasName: Bool {return self._name != nil} + var hasName: Bool {self._name != nil} /// Clears the value of `name`. Subsequent reads from it will return its default value. mutating func clearName() {self._name = nil} /// e.g. "foo", "foo.bar", etc. var package: String { - get {return _package ?? String()} + get {_package ?? String()} set {_package = newValue} } /// Returns true if `package` has been explicitly set. - var hasPackage: Bool {return self._package != nil} + var hasPackage: Bool {self._package != nil} /// Clears the value of `package`. Subsequent reads from it will return its default value. mutating func clearPackage() {self._package = nil} @@ -107,6 +172,10 @@ struct Google_Protobuf_FileDescriptorProto { /// For Google-internal migration only. Do not use. var weakDependency: [Int32] = [] + /// Names of files imported by this file purely for the purpose of providing + /// option extensions. These are excluded from the dependency list above. + var optionDependency: [String] = [] + /// All top-level definitions in this file. var messageType: [Google_Protobuf_DescriptorProto] = [] @@ -117,11 +186,11 @@ struct Google_Protobuf_FileDescriptorProto { var `extension`: [Google_Protobuf_FieldDescriptorProto] = [] var options: Google_Protobuf_FileOptions { - get {return _options ?? Google_Protobuf_FileOptions()} + get {_options ?? Google_Protobuf_FileOptions()} set {_options = newValue} } /// Returns true if `options` has been explicitly set. - var hasOptions: Bool {return self._options != nil} + var hasOptions: Bool {self._options != nil} /// Clears the value of `options`. Subsequent reads from it will return its default value. mutating func clearOptions() {self._options = nil} @@ -130,26 +199,44 @@ struct Google_Protobuf_FileDescriptorProto { /// functionality of the descriptors -- the information is needed only by /// development tools. var sourceCodeInfo: Google_Protobuf_SourceCodeInfo { - get {return _sourceCodeInfo ?? Google_Protobuf_SourceCodeInfo()} + get {_sourceCodeInfo ?? Google_Protobuf_SourceCodeInfo()} set {_sourceCodeInfo = newValue} } /// Returns true if `sourceCodeInfo` has been explicitly set. - var hasSourceCodeInfo: Bool {return self._sourceCodeInfo != nil} + var hasSourceCodeInfo: Bool {self._sourceCodeInfo != nil} /// Clears the value of `sourceCodeInfo`. Subsequent reads from it will return its default value. mutating func clearSourceCodeInfo() {self._sourceCodeInfo = nil} /// The syntax of the proto file. - /// The supported values are "proto2" and "proto3". + /// The supported values are "proto2", "proto3", and "editions". + /// + /// If `edition` is present, this value must be "editions". + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. var syntax: String { - get {return _syntax ?? String()} + get {_syntax ?? String()} set {_syntax = newValue} } /// Returns true if `syntax` has been explicitly set. - var hasSyntax: Bool {return self._syntax != nil} + var hasSyntax: Bool {self._syntax != nil} /// Clears the value of `syntax`. Subsequent reads from it will return its default value. mutating func clearSyntax() {self._syntax = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + /// The edition of the proto file. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var edition: Google_Protobuf_Edition { + get {_edition ?? .unknown} + set {_edition = newValue} + } + /// Returns true if `edition` has been explicitly set. + var hasEdition: Bool {self._edition != nil} + /// Clears the value of `edition`. Subsequent reads from it will return its default value. + mutating func clearEdition() {self._edition = nil} + + var unknownFields = UnknownStorage() init() {} @@ -158,87 +245,122 @@ struct Google_Protobuf_FileDescriptorProto { fileprivate var _options: Google_Protobuf_FileOptions? = nil fileprivate var _sourceCodeInfo: Google_Protobuf_SourceCodeInfo? = nil fileprivate var _syntax: String? = nil + fileprivate var _edition: Google_Protobuf_Edition? = nil } /// Describes a message type. -struct Google_Protobuf_DescriptorProto { +struct Google_Protobuf_DescriptorProto: @unchecked Sendable { // 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 name: String { - get {return _name ?? String()} - set {_name = newValue} + get {_storage._name ?? String()} + set {_uniqueStorage()._name = newValue} } /// Returns true if `name` has been explicitly set. - var hasName: Bool {return self._name != nil} + var hasName: Bool {_storage._name != nil} /// Clears the value of `name`. Subsequent reads from it will return its default value. - mutating func clearName() {self._name = nil} + mutating func clearName() {_uniqueStorage()._name = nil} - var field: [Google_Protobuf_FieldDescriptorProto] = [] + var field: [Google_Protobuf_FieldDescriptorProto] { + get {_storage._field} + set {_uniqueStorage()._field = newValue} + } - var `extension`: [Google_Protobuf_FieldDescriptorProto] = [] + var `extension`: [Google_Protobuf_FieldDescriptorProto] { + get {_storage._extension} + set {_uniqueStorage()._extension = newValue} + } - var nestedType: [Google_Protobuf_DescriptorProto] = [] + var nestedType: [Google_Protobuf_DescriptorProto] { + get {_storage._nestedType} + set {_uniqueStorage()._nestedType = newValue} + } - var enumType: [Google_Protobuf_EnumDescriptorProto] = [] + var enumType: [Google_Protobuf_EnumDescriptorProto] { + get {_storage._enumType} + set {_uniqueStorage()._enumType = newValue} + } - var extensionRange: [Google_Protobuf_DescriptorProto.ExtensionRange] = [] + var extensionRange: [Google_Protobuf_DescriptorProto.ExtensionRange] { + get {_storage._extensionRange} + set {_uniqueStorage()._extensionRange = newValue} + } - var oneofDecl: [Google_Protobuf_OneofDescriptorProto] = [] + var oneofDecl: [Google_Protobuf_OneofDescriptorProto] { + get {_storage._oneofDecl} + set {_uniqueStorage()._oneofDecl = newValue} + } var options: Google_Protobuf_MessageOptions { - get {return _options ?? Google_Protobuf_MessageOptions()} - set {_options = newValue} + get {_storage._options ?? Google_Protobuf_MessageOptions()} + set {_uniqueStorage()._options = newValue} } /// Returns true if `options` has been explicitly set. - var hasOptions: Bool {return self._options != nil} + var hasOptions: Bool {_storage._options != nil} /// Clears the value of `options`. Subsequent reads from it will return its default value. - mutating func clearOptions() {self._options = nil} + mutating func clearOptions() {_uniqueStorage()._options = nil} - var reservedRange: [Google_Protobuf_DescriptorProto.ReservedRange] = [] + var reservedRange: [Google_Protobuf_DescriptorProto.ReservedRange] { + get {_storage._reservedRange} + set {_uniqueStorage()._reservedRange = newValue} + } /// Reserved field names, which may not be used by fields in the same message. /// A given name may only be reserved once. - var reservedName: [String] = [] + var reservedName: [String] { + get {_storage._reservedName} + set {_uniqueStorage()._reservedName = newValue} + } - var unknownFields = SwiftProtobuf.UnknownStorage() + /// Support for `export` and `local` keywords on enums. + var visibility: Google_Protobuf_SymbolVisibility { + get {_storage._visibility ?? .visibilityUnset} + set {_uniqueStorage()._visibility = newValue} + } + /// Returns true if `visibility` has been explicitly set. + var hasVisibility: Bool {_storage._visibility != nil} + /// Clears the value of `visibility`. Subsequent reads from it will return its default value. + mutating func clearVisibility() {_uniqueStorage()._visibility = nil} + + var unknownFields = UnknownStorage() - struct ExtensionRange { + struct ExtensionRange: Sendable { // 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. /// Inclusive. var start: Int32 { - get {return _start ?? 0} + get {_start ?? 0} set {_start = newValue} } /// Returns true if `start` has been explicitly set. - var hasStart: Bool {return self._start != nil} + var hasStart: Bool {self._start != nil} /// Clears the value of `start`. Subsequent reads from it will return its default value. mutating func clearStart() {self._start = nil} /// Exclusive. var end: Int32 { - get {return _end ?? 0} + get {_end ?? 0} set {_end = newValue} } /// Returns true if `end` has been explicitly set. - var hasEnd: Bool {return self._end != nil} + var hasEnd: Bool {self._end != nil} /// Clears the value of `end`. Subsequent reads from it will return its default value. mutating func clearEnd() {self._end = nil} var options: Google_Protobuf_ExtensionRangeOptions { - get {return _options ?? Google_Protobuf_ExtensionRangeOptions()} + get {_options ?? Google_Protobuf_ExtensionRangeOptions()} set {_options = newValue} } /// Returns true if `options` has been explicitly set. - var hasOptions: Bool {return self._options != nil} + var hasOptions: Bool {self._options != nil} /// Clears the value of `options`. Subsequent reads from it will return its default value. mutating func clearOptions() {self._options = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} @@ -250,32 +372,32 @@ struct Google_Protobuf_DescriptorProto { /// Range of reserved tag numbers. Reserved tag numbers may not be used by /// fields or extension ranges in the same message. Reserved ranges may /// not overlap. - struct ReservedRange { + struct ReservedRange: Sendable { // 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. /// Inclusive. var start: Int32 { - get {return _start ?? 0} + get {_start ?? 0} set {_start = newValue} } /// Returns true if `start` has been explicitly set. - var hasStart: Bool {return self._start != nil} + var hasStart: Bool {self._start != nil} /// Clears the value of `start`. Subsequent reads from it will return its default value. mutating func clearStart() {self._start = nil} /// Exclusive. var end: Int32 { - get {return _end ?? 0} + get {_end ?? 0} set {_end = newValue} } /// Returns true if `end` has been explicitly set. - var hasEnd: Bool {return self._end != nil} + var hasEnd: Bool {self._end != nil} /// Clears the value of `end`. Subsequent reads from it will return its default value. mutating func clearEnd() {self._end = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} @@ -285,11 +407,10 @@ struct Google_Protobuf_DescriptorProto { init() {} - fileprivate var _name: String? = nil - fileprivate var _options: Google_Protobuf_MessageOptions? = nil + fileprivate var _storage = _StorageClass.defaultInstance } -struct Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.ExtensibleMessage { +struct Google_Protobuf_ExtensionRangeOptions: ExtensibleMessage, Sendable { // 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. @@ -297,56 +418,170 @@ struct Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.ExtensibleMessage { /// The parser stores options it doesn't recognize here. See above. var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] - var unknownFields = SwiftProtobuf.UnknownStorage() + /// For external users: DO NOT USE. We are in the process of open sourcing + /// extension declaration and executing internal cleanups before it can be + /// used externally. + var declaration: [Google_Protobuf_ExtensionRangeOptions.Declaration] = [] + + /// Any features defined in the specific edition. + var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + mutating func clearFeatures() {self._features = nil} + + /// The verification state of the range. + /// TODO: flip the default to DECLARATION once all empty ranges + /// are marked as UNVERIFIED. + var verification: Google_Protobuf_ExtensionRangeOptions.VerificationState { + get {_verification ?? .unverified} + set {_verification = newValue} + } + /// Returns true if `verification` has been explicitly set. + var hasVerification: Bool {self._verification != nil} + /// Clears the value of `verification`. Subsequent reads from it will return its default value. + mutating func clearVerification() {self._verification = nil} + + var unknownFields = UnknownStorage() + + /// The verification state of the extension range. + enum VerificationState: Int, Enum, Swift.CaseIterable { + + /// All the extensions of the range must be declared. + case declaration = 0 + case unverified = 1 + + init() { + self = .declaration + } + + } + + struct Declaration: Sendable { + // 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. + + /// The extension number declared within the extension range. + var number: Int32 { + get {_number ?? 0} + set {_number = newValue} + } + /// Returns true if `number` has been explicitly set. + var hasNumber: Bool {self._number != nil} + /// Clears the value of `number`. Subsequent reads from it will return its default value. + mutating func clearNumber() {self._number = nil} + + /// The fully-qualified name of the extension field. There must be a leading + /// dot in front of the full name. + var fullName: String { + get {_fullName ?? String()} + set {_fullName = newValue} + } + /// Returns true if `fullName` has been explicitly set. + var hasFullName: Bool {self._fullName != nil} + /// Clears the value of `fullName`. Subsequent reads from it will return its default value. + mutating func clearFullName() {self._fullName = nil} + + /// The fully-qualified type name of the extension field. Unlike + /// Metadata.type, Declaration.type must have a leading dot for messages + /// and enums. + var type: String { + get {_type ?? String()} + set {_type = newValue} + } + /// Returns true if `type` has been explicitly set. + var hasType: Bool {self._type != nil} + /// Clears the value of `type`. Subsequent reads from it will return its default value. + mutating func clearType() {self._type = nil} + + /// If true, indicates that the number is reserved in the extension range, + /// and any extension field with the number will fail to compile. Set this + /// when a declared extension field is deleted. + var reserved: Bool { + get {_reserved ?? false} + set {_reserved = newValue} + } + /// Returns true if `reserved` has been explicitly set. + var hasReserved: Bool {self._reserved != nil} + /// Clears the value of `reserved`. Subsequent reads from it will return its default value. + mutating func clearReserved() {self._reserved = nil} + + /// If true, indicates that the extension must be defined as repeated. + /// Otherwise the extension must be defined as optional. + var repeated: Bool { + get {_repeated ?? false} + set {_repeated = newValue} + } + /// Returns true if `repeated` has been explicitly set. + var hasRepeated: Bool {self._repeated != nil} + /// Clears the value of `repeated`. Subsequent reads from it will return its default value. + mutating func clearRepeated() {self._repeated = nil} + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _number: Int32? = nil + fileprivate var _fullName: String? = nil + fileprivate var _type: String? = nil + fileprivate var _reserved: Bool? = nil + fileprivate var _repeated: Bool? = nil + } init() {} - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _features: Google_Protobuf_FeatureSet? = nil + fileprivate var _verification: Google_Protobuf_ExtensionRangeOptions.VerificationState? = nil } /// Describes a field within a message. -struct Google_Protobuf_FieldDescriptorProto { +struct Google_Protobuf_FieldDescriptorProto: Sendable { // 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 name: String { - get {return _storage._name ?? String()} - set {_uniqueStorage()._name = newValue} + get {_name ?? String()} + set {_name = newValue} } /// Returns true if `name` has been explicitly set. - var hasName: Bool {return _storage._name != nil} + var hasName: Bool {self._name != nil} /// Clears the value of `name`. Subsequent reads from it will return its default value. - mutating func clearName() {_uniqueStorage()._name = nil} + mutating func clearName() {self._name = nil} var number: Int32 { - get {return _storage._number ?? 0} - set {_uniqueStorage()._number = newValue} + get {_number ?? 0} + set {_number = newValue} } /// Returns true if `number` has been explicitly set. - var hasNumber: Bool {return _storage._number != nil} + var hasNumber: Bool {self._number != nil} /// Clears the value of `number`. Subsequent reads from it will return its default value. - mutating func clearNumber() {_uniqueStorage()._number = nil} + mutating func clearNumber() {self._number = nil} var label: Google_Protobuf_FieldDescriptorProto.Label { - get {return _storage._label ?? .optional} - set {_uniqueStorage()._label = newValue} + get {_label ?? .optional} + set {_label = newValue} } /// Returns true if `label` has been explicitly set. - var hasLabel: Bool {return _storage._label != nil} + var hasLabel: Bool {self._label != nil} /// Clears the value of `label`. Subsequent reads from it will return its default value. - mutating func clearLabel() {_uniqueStorage()._label = nil} + mutating func clearLabel() {self._label = nil} /// If type_name is set, this need not be set. If both this and type_name /// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. var type: Google_Protobuf_FieldDescriptorProto.TypeEnum { - get {return _storage._type ?? .double} - set {_uniqueStorage()._type = newValue} + get {_type ?? .double} + set {_type = newValue} } /// Returns true if `type` has been explicitly set. - var hasType: Bool {return _storage._type != nil} + var hasType: Bool {self._type != nil} /// Clears the value of `type`. Subsequent reads from it will return its default value. - mutating func clearType() {_uniqueStorage()._type = nil} + mutating func clearType() {self._type = nil} /// For message and enum types, this is the name of the type. If the name /// starts with a '.', it is fully-qualified. Otherwise, C++-like scoping @@ -354,81 +589,80 @@ struct Google_Protobuf_FieldDescriptorProto { /// message are searched, then within the parent, on up to the root /// namespace). var typeName: String { - get {return _storage._typeName ?? String()} - set {_uniqueStorage()._typeName = newValue} + get {_typeName ?? String()} + set {_typeName = newValue} } /// Returns true if `typeName` has been explicitly set. - var hasTypeName: Bool {return _storage._typeName != nil} + var hasTypeName: Bool {self._typeName != nil} /// Clears the value of `typeName`. Subsequent reads from it will return its default value. - mutating func clearTypeName() {_uniqueStorage()._typeName = nil} + mutating func clearTypeName() {self._typeName = nil} /// For extensions, this is the name of the type being extended. It is /// resolved in the same manner as type_name. var extendee: String { - get {return _storage._extendee ?? String()} - set {_uniqueStorage()._extendee = newValue} + get {_extendee ?? String()} + set {_extendee = newValue} } /// Returns true if `extendee` has been explicitly set. - var hasExtendee: Bool {return _storage._extendee != nil} + var hasExtendee: Bool {self._extendee != nil} /// Clears the value of `extendee`. Subsequent reads from it will return its default value. - mutating func clearExtendee() {_uniqueStorage()._extendee = nil} + mutating func clearExtendee() {self._extendee = nil} /// For numeric types, contains the original text representation of the value. /// For booleans, "true" or "false". /// For strings, contains the default text contents (not escaped in any way). /// For bytes, contains the C escaped value. All bytes >= 128 are escaped. - /// TODO(kenton): Base-64 encode? var defaultValue: String { - get {return _storage._defaultValue ?? String()} - set {_uniqueStorage()._defaultValue = newValue} + get {_defaultValue ?? String()} + set {_defaultValue = newValue} } /// Returns true if `defaultValue` has been explicitly set. - var hasDefaultValue: Bool {return _storage._defaultValue != nil} + var hasDefaultValue: Bool {self._defaultValue != nil} /// Clears the value of `defaultValue`. Subsequent reads from it will return its default value. - mutating func clearDefaultValue() {_uniqueStorage()._defaultValue = nil} + mutating func clearDefaultValue() {self._defaultValue = nil} /// If set, gives the index of a oneof in the containing type's oneof_decl /// list. This field is a member of that oneof. var oneofIndex: Int32 { - get {return _storage._oneofIndex ?? 0} - set {_uniqueStorage()._oneofIndex = newValue} + get {_oneofIndex ?? 0} + set {_oneofIndex = newValue} } /// Returns true if `oneofIndex` has been explicitly set. - var hasOneofIndex: Bool {return _storage._oneofIndex != nil} + var hasOneofIndex: Bool {self._oneofIndex != nil} /// Clears the value of `oneofIndex`. Subsequent reads from it will return its default value. - mutating func clearOneofIndex() {_uniqueStorage()._oneofIndex = nil} + mutating func clearOneofIndex() {self._oneofIndex = nil} /// JSON name of this field. The value is set by protocol compiler. If the /// user has set a "json_name" option on this field, that option's value /// will be used. Otherwise, it's deduced from the field's name by converting /// it to camelCase. var jsonName: String { - get {return _storage._jsonName ?? String()} - set {_uniqueStorage()._jsonName = newValue} + get {_jsonName ?? String()} + set {_jsonName = newValue} } /// Returns true if `jsonName` has been explicitly set. - var hasJsonName: Bool {return _storage._jsonName != nil} + var hasJsonName: Bool {self._jsonName != nil} /// Clears the value of `jsonName`. Subsequent reads from it will return its default value. - mutating func clearJsonName() {_uniqueStorage()._jsonName = nil} + mutating func clearJsonName() {self._jsonName = nil} var options: Google_Protobuf_FieldOptions { - get {return _storage._options ?? Google_Protobuf_FieldOptions()} - set {_uniqueStorage()._options = newValue} + get {_options ?? Google_Protobuf_FieldOptions()} + set {_options = newValue} } /// Returns true if `options` has been explicitly set. - var hasOptions: Bool {return _storage._options != nil} + var hasOptions: Bool {self._options != nil} /// Clears the value of `options`. Subsequent reads from it will return its default value. - mutating func clearOptions() {_uniqueStorage()._options = nil} + mutating func clearOptions() {self._options = nil} /// If true, this is a proto3 "optional". When a proto3 field is optional, it /// tracks presence regardless of field type. /// - /// When proto3_optional is true, this field must be belong to a oneof to - /// signal to old proto3 clients that presence is tracked for this field. This - /// oneof is known as a "synthetic" oneof, and this field must be its sole - /// member (each proto3 optional field gets its own synthetic oneof). Synthetic - /// oneofs exist in the descriptor only, and do not generate any API. Synthetic - /// oneofs must be ordered after all "real" oneofs. + /// When proto3_optional is true, this field must belong to a oneof to signal + /// to old proto3 clients that presence is tracked for this field. This oneof + /// is known as a "synthetic" oneof, and this field must be its sole member + /// (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs + /// exist in the descriptor only, and do not generate any API. Synthetic oneofs + /// must be ordered after all "real" oneofs. /// /// For message fields, proto3_optional doesn't create any semantic change, /// since non-repeated message fields always track presence. However it still @@ -442,185 +676,122 @@ struct Google_Protobuf_FieldDescriptorProto { /// Proto2 optional fields do not set this flag, because they already indicate /// optional with `LABEL_OPTIONAL`. var proto3Optional: Bool { - get {return _storage._proto3Optional ?? false} - set {_uniqueStorage()._proto3Optional = newValue} + get {_proto3Optional ?? false} + set {_proto3Optional = newValue} } /// Returns true if `proto3Optional` has been explicitly set. - var hasProto3Optional: Bool {return _storage._proto3Optional != nil} + var hasProto3Optional: Bool {self._proto3Optional != nil} /// Clears the value of `proto3Optional`. Subsequent reads from it will return its default value. - mutating func clearProto3Optional() {_uniqueStorage()._proto3Optional = nil} + mutating func clearProto3Optional() {self._proto3Optional = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() - enum TypeEnum: SwiftProtobuf.Enum { - typealias RawValue = Int + enum TypeEnum: Int, Enum, Swift.CaseIterable { /// 0 is reserved for errors. /// Order is weird for historical reasons. - case double // = 1 - case float // = 2 + case double = 1 + case float = 2 /// Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if /// negative values are likely. - case int64 // = 3 - case uint64 // = 4 + case int64 = 3 + case uint64 = 4 /// Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if /// negative values are likely. - case int32 // = 5 - case fixed64 // = 6 - case fixed32 // = 7 - case bool // = 8 - case string // = 9 + case int32 = 5 + case fixed64 = 6 + case fixed32 = 7 + case bool = 8 + case string = 9 /// Tag-delimited aggregate. - /// Group type is deprecated and not supported in proto3. However, Proto3 + /// Group type is deprecated and not supported after google.protobuf. However, Proto3 /// implementations should still be able to parse the group wire format and - /// treat group fields as unknown fields. - case group // = 10 + /// treat group fields as unknown fields. In Editions, the group wire format + /// can be enabled via the `message_encoding` feature. + case group = 10 /// Length-delimited aggregate. - case message // = 11 + case message = 11 /// New in version 2. - case bytes // = 12 - case uint32 // = 13 - case `enum` // = 14 - case sfixed32 // = 15 - case sfixed64 // = 16 + case bytes = 12 + case uint32 = 13 + case `enum` = 14 + case sfixed32 = 15 + case sfixed64 = 16 /// Uses ZigZag encoding. - case sint32 // = 17 + case sint32 = 17 /// Uses ZigZag encoding. - case sint64 // = 18 + case sint64 = 18 init() { self = .double } - init?(rawValue: Int) { - switch rawValue { - case 1: self = .double - case 2: self = .float - case 3: self = .int64 - case 4: self = .uint64 - case 5: self = .int32 - case 6: self = .fixed64 - case 7: self = .fixed32 - case 8: self = .bool - case 9: self = .string - case 10: self = .group - case 11: self = .message - case 12: self = .bytes - case 13: self = .uint32 - case 14: self = .enum - case 15: self = .sfixed32 - case 16: self = .sfixed64 - case 17: self = .sint32 - case 18: self = .sint64 - default: return nil - } - } - - var rawValue: Int { - switch self { - case .double: return 1 - case .float: return 2 - case .int64: return 3 - case .uint64: return 4 - case .int32: return 5 - case .fixed64: return 6 - case .fixed32: return 7 - case .bool: return 8 - case .string: return 9 - case .group: return 10 - case .message: return 11 - case .bytes: return 12 - case .uint32: return 13 - case .enum: return 14 - case .sfixed32: return 15 - case .sfixed64: return 16 - case .sint32: return 17 - case .sint64: return 18 - } - } - } - enum Label: SwiftProtobuf.Enum { - typealias RawValue = Int + enum Label: Int, Enum, Swift.CaseIterable { /// 0 is reserved for errors - case `optional` // = 1 - case `required` // = 2 - case repeated // = 3 + case `optional` = 1 + case repeated = 3 + + /// The required label is only allowed in google.protobuf. In proto3 and Editions + /// it's explicitly prohibited. In Editions, the `field_presence` feature + /// can be used to get this behavior. + case `required` = 2 init() { self = .optional } - init?(rawValue: Int) { - switch rawValue { - case 1: self = .optional - case 2: self = .required - case 3: self = .repeated - default: return nil - } - } - - var rawValue: Int { - switch self { - case .optional: return 1 - case .required: return 2 - case .repeated: return 3 - } - } - } init() {} - fileprivate var _storage = _StorageClass.defaultInstance -} - -#if swift(>=4.2) - -extension Google_Protobuf_FieldDescriptorProto.TypeEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension Google_Protobuf_FieldDescriptorProto.Label: CaseIterable { - // Support synthesized by the compiler. + fileprivate var _name: String? = nil + fileprivate var _number: Int32? = nil + fileprivate var _label: Google_Protobuf_FieldDescriptorProto.Label? = nil + fileprivate var _type: Google_Protobuf_FieldDescriptorProto.TypeEnum? = nil + fileprivate var _typeName: String? = nil + fileprivate var _extendee: String? = nil + fileprivate var _defaultValue: String? = nil + fileprivate var _oneofIndex: Int32? = nil + fileprivate var _jsonName: String? = nil + fileprivate var _options: Google_Protobuf_FieldOptions? = nil + fileprivate var _proto3Optional: Bool? = nil } -#endif // swift(>=4.2) - /// Describes a oneof. -struct Google_Protobuf_OneofDescriptorProto { +struct Google_Protobuf_OneofDescriptorProto: Sendable { // 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 name: String { - get {return _name ?? String()} + get {_name ?? String()} set {_name = newValue} } /// Returns true if `name` has been explicitly set. - var hasName: Bool {return self._name != nil} + var hasName: Bool {self._name != nil} /// Clears the value of `name`. Subsequent reads from it will return its default value. mutating func clearName() {self._name = nil} var options: Google_Protobuf_OneofOptions { - get {return _options ?? Google_Protobuf_OneofOptions()} + get {_options ?? Google_Protobuf_OneofOptions()} set {_options = newValue} } /// Returns true if `options` has been explicitly set. - var hasOptions: Bool {return self._options != nil} + var hasOptions: Bool {self._options != nil} /// Clears the value of `options`. Subsequent reads from it will return its default value. mutating func clearOptions() {self._options = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} @@ -629,41 +800,60 @@ struct Google_Protobuf_OneofDescriptorProto { } /// Describes an enum type. -struct Google_Protobuf_EnumDescriptorProto { +struct Google_Protobuf_EnumDescriptorProto: @unchecked Sendable { // 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 name: String { - get {return _name ?? String()} - set {_name = newValue} + get {_storage._name ?? String()} + set {_uniqueStorage()._name = newValue} } /// Returns true if `name` has been explicitly set. - var hasName: Bool {return self._name != nil} + var hasName: Bool {_storage._name != nil} /// Clears the value of `name`. Subsequent reads from it will return its default value. - mutating func clearName() {self._name = nil} + mutating func clearName() {_uniqueStorage()._name = nil} - var value: [Google_Protobuf_EnumValueDescriptorProto] = [] + var value: [Google_Protobuf_EnumValueDescriptorProto] { + get {_storage._value} + set {_uniqueStorage()._value = newValue} + } var options: Google_Protobuf_EnumOptions { - get {return _options ?? Google_Protobuf_EnumOptions()} - set {_options = newValue} + get {_storage._options ?? Google_Protobuf_EnumOptions()} + set {_uniqueStorage()._options = newValue} } /// Returns true if `options` has been explicitly set. - var hasOptions: Bool {return self._options != nil} + var hasOptions: Bool {_storage._options != nil} /// Clears the value of `options`. Subsequent reads from it will return its default value. - mutating func clearOptions() {self._options = nil} + mutating func clearOptions() {_uniqueStorage()._options = nil} /// Range of reserved numeric values. Reserved numeric values may not be used /// by enum values in the same enum declaration. Reserved ranges may not /// overlap. - var reservedRange: [Google_Protobuf_EnumDescriptorProto.EnumReservedRange] = [] + var reservedRange: [Google_Protobuf_EnumDescriptorProto.EnumReservedRange] { + get {_storage._reservedRange} + set {_uniqueStorage()._reservedRange = newValue} + } /// Reserved enum value names, which may not be reused. A given name may only /// be reserved once. - var reservedName: [String] = [] + var reservedName: [String] { + get {_storage._reservedName} + set {_uniqueStorage()._reservedName = newValue} + } - var unknownFields = SwiftProtobuf.UnknownStorage() + /// Support for `export` and `local` keywords on enums. + var visibility: Google_Protobuf_SymbolVisibility { + get {_storage._visibility ?? .visibilityUnset} + set {_uniqueStorage()._visibility = newValue} + } + /// Returns true if `visibility` has been explicitly set. + var hasVisibility: Bool {_storage._visibility != nil} + /// Clears the value of `visibility`. Subsequent reads from it will return its default value. + mutating func clearVisibility() {_uniqueStorage()._visibility = nil} + + var unknownFields = UnknownStorage() /// Range of reserved numeric values. Reserved values may not be used by /// entries in the same enum. Reserved ranges may not overlap. @@ -671,32 +861,32 @@ struct Google_Protobuf_EnumDescriptorProto { /// Note that this is distinct from DescriptorProto.ReservedRange in that it /// is inclusive such that it can appropriately represent the entire int32 /// domain. - struct EnumReservedRange { + struct EnumReservedRange: Sendable { // 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. /// Inclusive. var start: Int32 { - get {return _start ?? 0} + get {_start ?? 0} set {_start = newValue} } /// Returns true if `start` has been explicitly set. - var hasStart: Bool {return self._start != nil} + var hasStart: Bool {self._start != nil} /// Clears the value of `start`. Subsequent reads from it will return its default value. mutating func clearStart() {self._start = nil} /// Inclusive. var end: Int32 { - get {return _end ?? 0} + get {_end ?? 0} set {_end = newValue} } /// Returns true if `end` has been explicitly set. - var hasEnd: Bool {return self._end != nil} + var hasEnd: Bool {self._end != nil} /// Clears the value of `end`. Subsequent reads from it will return its default value. mutating func clearEnd() {self._end = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} @@ -706,79 +896,76 @@ struct Google_Protobuf_EnumDescriptorProto { init() {} - fileprivate var _name: String? = nil - fileprivate var _options: Google_Protobuf_EnumOptions? = nil + fileprivate var _storage = _StorageClass.defaultInstance } /// Describes a value within an enum. -struct Google_Protobuf_EnumValueDescriptorProto { +struct Google_Protobuf_EnumValueDescriptorProto: @unchecked Sendable { // 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 name: String { - get {return _name ?? String()} - set {_name = newValue} + get {_storage._name ?? String()} + set {_uniqueStorage()._name = newValue} } /// Returns true if `name` has been explicitly set. - var hasName: Bool {return self._name != nil} + var hasName: Bool {_storage._name != nil} /// Clears the value of `name`. Subsequent reads from it will return its default value. - mutating func clearName() {self._name = nil} + mutating func clearName() {_uniqueStorage()._name = nil} var number: Int32 { - get {return _number ?? 0} - set {_number = newValue} + get {_storage._number ?? 0} + set {_uniqueStorage()._number = newValue} } /// Returns true if `number` has been explicitly set. - var hasNumber: Bool {return self._number != nil} + var hasNumber: Bool {_storage._number != nil} /// Clears the value of `number`. Subsequent reads from it will return its default value. - mutating func clearNumber() {self._number = nil} + mutating func clearNumber() {_uniqueStorage()._number = nil} var options: Google_Protobuf_EnumValueOptions { - get {return _options ?? Google_Protobuf_EnumValueOptions()} - set {_options = newValue} + get {_storage._options ?? Google_Protobuf_EnumValueOptions()} + set {_uniqueStorage()._options = newValue} } /// Returns true if `options` has been explicitly set. - var hasOptions: Bool {return self._options != nil} + var hasOptions: Bool {_storage._options != nil} /// Clears the value of `options`. Subsequent reads from it will return its default value. - mutating func clearOptions() {self._options = nil} + mutating func clearOptions() {_uniqueStorage()._options = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} - fileprivate var _name: String? = nil - fileprivate var _number: Int32? = nil - fileprivate var _options: Google_Protobuf_EnumValueOptions? = nil + fileprivate var _storage = _StorageClass.defaultInstance } /// Describes a service. -struct Google_Protobuf_ServiceDescriptorProto { +struct Google_Protobuf_ServiceDescriptorProto: Sendable { // 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 name: String { - get {return _name ?? String()} + get {_name ?? String()} set {_name = newValue} } /// Returns true if `name` has been explicitly set. - var hasName: Bool {return self._name != nil} + var hasName: Bool {self._name != nil} /// Clears the value of `name`. Subsequent reads from it will return its default value. mutating func clearName() {self._name = nil} var method: [Google_Protobuf_MethodDescriptorProto] = [] var options: Google_Protobuf_ServiceOptions { - get {return _options ?? Google_Protobuf_ServiceOptions()} + get {_options ?? Google_Protobuf_ServiceOptions()} set {_options = newValue} } /// Returns true if `options` has been explicitly set. - var hasOptions: Bool {return self._options != nil} + var hasOptions: Bool {self._options != nil} /// Clears the value of `options`. Subsequent reads from it will return its default value. mutating func clearOptions() {self._options = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} @@ -787,70 +974,70 @@ struct Google_Protobuf_ServiceDescriptorProto { } /// Describes a method of a service. -struct Google_Protobuf_MethodDescriptorProto { +struct Google_Protobuf_MethodDescriptorProto: Sendable { // 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 name: String { - get {return _name ?? String()} + get {_name ?? String()} set {_name = newValue} } /// Returns true if `name` has been explicitly set. - var hasName: Bool {return self._name != nil} + var hasName: Bool {self._name != nil} /// Clears the value of `name`. Subsequent reads from it will return its default value. mutating func clearName() {self._name = nil} /// Input and output type names. These are resolved in the same way as /// FieldDescriptorProto.type_name, but must refer to a message type. var inputType: String { - get {return _inputType ?? String()} + get {_inputType ?? String()} set {_inputType = newValue} } /// Returns true if `inputType` has been explicitly set. - var hasInputType: Bool {return self._inputType != nil} + var hasInputType: Bool {self._inputType != nil} /// Clears the value of `inputType`. Subsequent reads from it will return its default value. mutating func clearInputType() {self._inputType = nil} var outputType: String { - get {return _outputType ?? String()} + get {_outputType ?? String()} set {_outputType = newValue} } /// Returns true if `outputType` has been explicitly set. - var hasOutputType: Bool {return self._outputType != nil} + var hasOutputType: Bool {self._outputType != nil} /// Clears the value of `outputType`. Subsequent reads from it will return its default value. mutating func clearOutputType() {self._outputType = nil} var options: Google_Protobuf_MethodOptions { - get {return _options ?? Google_Protobuf_MethodOptions()} + get {_options ?? Google_Protobuf_MethodOptions()} set {_options = newValue} } /// Returns true if `options` has been explicitly set. - var hasOptions: Bool {return self._options != nil} + var hasOptions: Bool {self._options != nil} /// Clears the value of `options`. Subsequent reads from it will return its default value. mutating func clearOptions() {self._options = nil} /// Identifies if client streams multiple client messages var clientStreaming: Bool { - get {return _clientStreaming ?? false} + get {_clientStreaming ?? false} set {_clientStreaming = newValue} } /// Returns true if `clientStreaming` has been explicitly set. - var hasClientStreaming: Bool {return self._clientStreaming != nil} + var hasClientStreaming: Bool {self._clientStreaming != nil} /// Clears the value of `clientStreaming`. Subsequent reads from it will return its default value. mutating func clearClientStreaming() {self._clientStreaming = nil} /// Identifies if server streams multiple server messages var serverStreaming: Bool { - get {return _serverStreaming ?? false} + get {_serverStreaming ?? false} set {_serverStreaming = newValue} } /// Returns true if `serverStreaming` has been explicitly set. - var hasServerStreaming: Bool {return self._serverStreaming != nil} + var hasServerStreaming: Bool {self._serverStreaming != nil} /// Clears the value of `serverStreaming`. Subsequent reads from it will return its default value. mutating func clearServerStreaming() {self._serverStreaming = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} @@ -862,7 +1049,7 @@ struct Google_Protobuf_MethodDescriptorProto { fileprivate var _serverStreaming: Bool? = nil } -struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { +struct Google_Protobuf_FileOptions: ExtensibleMessage, @unchecked Sendable { // 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. @@ -872,11 +1059,11 @@ struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { /// inappropriate because proto packages do not normally start with backwards /// domain names. var javaPackage: String { - get {return _storage._javaPackage ?? String()} + get {_storage._javaPackage ?? String()} set {_uniqueStorage()._javaPackage = newValue} } /// Returns true if `javaPackage` has been explicitly set. - var hasJavaPackage: Bool {return _storage._javaPackage != nil} + var hasJavaPackage: Bool {_storage._javaPackage != nil} /// Clears the value of `javaPackage`. Subsequent reads from it will return its default value. mutating func clearJavaPackage() {_uniqueStorage()._javaPackage = nil} @@ -886,11 +1073,11 @@ struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { /// If java_multiple_files is disabled, then all the other classes from the /// .proto file will be nested inside the single wrapper outer class. var javaOuterClassname: String { - get {return _storage._javaOuterClassname ?? String()} + get {_storage._javaOuterClassname ?? String()} set {_uniqueStorage()._javaOuterClassname = newValue} } /// Returns true if `javaOuterClassname` has been explicitly set. - var hasJavaOuterClassname: Bool {return _storage._javaOuterClassname != nil} + var hasJavaOuterClassname: Bool {_storage._javaOuterClassname != nil} /// Clears the value of `javaOuterClassname`. Subsequent reads from it will return its default value. mutating func clearJavaOuterClassname() {_uniqueStorage()._javaOuterClassname = nil} @@ -901,45 +1088,51 @@ struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { /// generated to contain the file's getDescriptor() method as well as any /// top-level extensions defined in the file. var javaMultipleFiles: Bool { - get {return _storage._javaMultipleFiles ?? false} + get {_storage._javaMultipleFiles ?? false} set {_uniqueStorage()._javaMultipleFiles = newValue} } /// Returns true if `javaMultipleFiles` has been explicitly set. - var hasJavaMultipleFiles: Bool {return _storage._javaMultipleFiles != nil} + var hasJavaMultipleFiles: Bool {_storage._javaMultipleFiles != nil} /// Clears the value of `javaMultipleFiles`. Subsequent reads from it will return its default value. mutating func clearJavaMultipleFiles() {_uniqueStorage()._javaMultipleFiles = nil} /// This option does nothing. + /// + /// NOTE: This field was marked as deprecated in the .proto file. var javaGenerateEqualsAndHash: Bool { - get {return _storage._javaGenerateEqualsAndHash ?? false} + get {_storage._javaGenerateEqualsAndHash ?? false} set {_uniqueStorage()._javaGenerateEqualsAndHash = newValue} } /// Returns true if `javaGenerateEqualsAndHash` has been explicitly set. - var hasJavaGenerateEqualsAndHash: Bool {return _storage._javaGenerateEqualsAndHash != nil} + var hasJavaGenerateEqualsAndHash: Bool {_storage._javaGenerateEqualsAndHash != nil} /// Clears the value of `javaGenerateEqualsAndHash`. Subsequent reads from it will return its default value. mutating func clearJavaGenerateEqualsAndHash() {_uniqueStorage()._javaGenerateEqualsAndHash = nil} - /// If set true, then the Java2 code generator will generate code that - /// throws an exception whenever an attempt is made to assign a non-UTF-8 - /// byte sequence to a string field. - /// Message reflection will do the same. - /// However, an extension field still accepts non-UTF-8 byte sequences. - /// This option has no effect on when used with the lite runtime. + /// A proto2 file can set this to true to opt in to UTF-8 checking for Java, + /// which will throw an exception if invalid UTF-8 is parsed from the wire or + /// assigned to a string field. + /// + /// TODO: clarify exactly what kinds of field types this option + /// applies to, and update these docs accordingly. + /// + /// Proto3 files already perform these checks. Setting the option explicitly to + /// false has no effect: it cannot be used to opt proto3 files out of UTF-8 + /// checks. var javaStringCheckUtf8: Bool { - get {return _storage._javaStringCheckUtf8 ?? false} + get {_storage._javaStringCheckUtf8 ?? false} set {_uniqueStorage()._javaStringCheckUtf8 = newValue} } /// Returns true if `javaStringCheckUtf8` has been explicitly set. - var hasJavaStringCheckUtf8: Bool {return _storage._javaStringCheckUtf8 != nil} + var hasJavaStringCheckUtf8: Bool {_storage._javaStringCheckUtf8 != nil} /// Clears the value of `javaStringCheckUtf8`. Subsequent reads from it will return its default value. mutating func clearJavaStringCheckUtf8() {_uniqueStorage()._javaStringCheckUtf8 = nil} var optimizeFor: Google_Protobuf_FileOptions.OptimizeMode { - get {return _storage._optimizeFor ?? .speed} + get {_storage._optimizeFor ?? .speed} set {_uniqueStorage()._optimizeFor = newValue} } /// Returns true if `optimizeFor` has been explicitly set. - var hasOptimizeFor: Bool {return _storage._optimizeFor != nil} + var hasOptimizeFor: Bool {_storage._optimizeFor != nil} /// Clears the value of `optimizeFor`. Subsequent reads from it will return its default value. mutating func clearOptimizeFor() {_uniqueStorage()._optimizeFor = nil} @@ -949,11 +1142,11 @@ struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { /// - Otherwise, the package statement in the .proto file, if present. /// - Otherwise, the basename of the .proto file, without extension. var goPackage: String { - get {return _storage._goPackage ?? String()} + get {_storage._goPackage ?? String()} set {_uniqueStorage()._goPackage = newValue} } /// Returns true if `goPackage` has been explicitly set. - var hasGoPackage: Bool {return _storage._goPackage != nil} + var hasGoPackage: Bool {_storage._goPackage != nil} /// Clears the value of `goPackage`. Subsequent reads from it will return its default value. mutating func clearGoPackage() {_uniqueStorage()._goPackage = nil} @@ -968,83 +1161,74 @@ struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { /// these default to false. Old code which depends on generic services should /// explicitly set them to true. var ccGenericServices: Bool { - get {return _storage._ccGenericServices ?? false} + get {_storage._ccGenericServices ?? false} set {_uniqueStorage()._ccGenericServices = newValue} } /// Returns true if `ccGenericServices` has been explicitly set. - var hasCcGenericServices: Bool {return _storage._ccGenericServices != nil} + var hasCcGenericServices: Bool {_storage._ccGenericServices != nil} /// Clears the value of `ccGenericServices`. Subsequent reads from it will return its default value. mutating func clearCcGenericServices() {_uniqueStorage()._ccGenericServices = nil} var javaGenericServices: Bool { - get {return _storage._javaGenericServices ?? false} + get {_storage._javaGenericServices ?? false} set {_uniqueStorage()._javaGenericServices = newValue} } /// Returns true if `javaGenericServices` has been explicitly set. - var hasJavaGenericServices: Bool {return _storage._javaGenericServices != nil} + var hasJavaGenericServices: Bool {_storage._javaGenericServices != nil} /// Clears the value of `javaGenericServices`. Subsequent reads from it will return its default value. mutating func clearJavaGenericServices() {_uniqueStorage()._javaGenericServices = nil} var pyGenericServices: Bool { - get {return _storage._pyGenericServices ?? false} + get {_storage._pyGenericServices ?? false} set {_uniqueStorage()._pyGenericServices = newValue} } /// Returns true if `pyGenericServices` has been explicitly set. - var hasPyGenericServices: Bool {return _storage._pyGenericServices != nil} + var hasPyGenericServices: Bool {_storage._pyGenericServices != nil} /// Clears the value of `pyGenericServices`. Subsequent reads from it will return its default value. mutating func clearPyGenericServices() {_uniqueStorage()._pyGenericServices = nil} - var phpGenericServices: Bool { - get {return _storage._phpGenericServices ?? false} - set {_uniqueStorage()._phpGenericServices = newValue} - } - /// Returns true if `phpGenericServices` has been explicitly set. - var hasPhpGenericServices: Bool {return _storage._phpGenericServices != nil} - /// Clears the value of `phpGenericServices`. Subsequent reads from it will return its default value. - mutating func clearPhpGenericServices() {_uniqueStorage()._phpGenericServices = nil} - /// Is this file deprecated? /// Depending on the target platform, this can emit Deprecated annotations /// for everything in the file, or it will be completely ignored; in the very /// least, this is a formalization for deprecating files. var deprecated: Bool { - get {return _storage._deprecated ?? false} + get {_storage._deprecated ?? false} set {_uniqueStorage()._deprecated = newValue} } /// Returns true if `deprecated` has been explicitly set. - var hasDeprecated: Bool {return _storage._deprecated != nil} + var hasDeprecated: Bool {_storage._deprecated != nil} /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. mutating func clearDeprecated() {_uniqueStorage()._deprecated = nil} /// Enables the use of arenas for the proto messages in this file. This applies /// only to generated classes for C++. var ccEnableArenas: Bool { - get {return _storage._ccEnableArenas ?? true} + get {_storage._ccEnableArenas ?? true} set {_uniqueStorage()._ccEnableArenas = newValue} } /// Returns true if `ccEnableArenas` has been explicitly set. - var hasCcEnableArenas: Bool {return _storage._ccEnableArenas != nil} + var hasCcEnableArenas: Bool {_storage._ccEnableArenas != nil} /// Clears the value of `ccEnableArenas`. Subsequent reads from it will return its default value. mutating func clearCcEnableArenas() {_uniqueStorage()._ccEnableArenas = nil} /// Sets the objective c class prefix which is prepended to all objective c /// generated classes from this .proto. There is no default. var objcClassPrefix: String { - get {return _storage._objcClassPrefix ?? String()} + get {_storage._objcClassPrefix ?? String()} set {_uniqueStorage()._objcClassPrefix = newValue} } /// Returns true if `objcClassPrefix` has been explicitly set. - var hasObjcClassPrefix: Bool {return _storage._objcClassPrefix != nil} + var hasObjcClassPrefix: Bool {_storage._objcClassPrefix != nil} /// Clears the value of `objcClassPrefix`. Subsequent reads from it will return its default value. mutating func clearObjcClassPrefix() {_uniqueStorage()._objcClassPrefix = nil} /// Namespace for generated classes; defaults to the package. var csharpNamespace: String { - get {return _storage._csharpNamespace ?? String()} + get {_storage._csharpNamespace ?? String()} set {_uniqueStorage()._csharpNamespace = newValue} } /// Returns true if `csharpNamespace` has been explicitly set. - var hasCsharpNamespace: Bool {return _storage._csharpNamespace != nil} + var hasCsharpNamespace: Bool {_storage._csharpNamespace != nil} /// Clears the value of `csharpNamespace`. Subsequent reads from it will return its default value. mutating func clearCsharpNamespace() {_uniqueStorage()._csharpNamespace = nil} @@ -1053,22 +1237,22 @@ struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { /// defined. When this options is provided, they will use this value instead /// to prefix the types/symbols defined. var swiftPrefix: String { - get {return _storage._swiftPrefix ?? String()} + get {_storage._swiftPrefix ?? String()} set {_uniqueStorage()._swiftPrefix = newValue} } /// Returns true if `swiftPrefix` has been explicitly set. - var hasSwiftPrefix: Bool {return _storage._swiftPrefix != nil} + var hasSwiftPrefix: Bool {_storage._swiftPrefix != nil} /// Clears the value of `swiftPrefix`. Subsequent reads from it will return its default value. mutating func clearSwiftPrefix() {_uniqueStorage()._swiftPrefix = nil} /// Sets the php class prefix which is prepended to all php generated classes /// from this .proto. Default is empty. var phpClassPrefix: String { - get {return _storage._phpClassPrefix ?? String()} + get {_storage._phpClassPrefix ?? String()} set {_uniqueStorage()._phpClassPrefix = newValue} } /// Returns true if `phpClassPrefix` has been explicitly set. - var hasPhpClassPrefix: Bool {return _storage._phpClassPrefix != nil} + var hasPhpClassPrefix: Bool {_storage._phpClassPrefix != nil} /// Clears the value of `phpClassPrefix`. Subsequent reads from it will return its default value. mutating func clearPhpClassPrefix() {_uniqueStorage()._phpClassPrefix = nil} @@ -1076,11 +1260,11 @@ struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { /// is empty. When this option is empty, the package name will be used for /// determining the namespace. var phpNamespace: String { - get {return _storage._phpNamespace ?? String()} + get {_storage._phpNamespace ?? String()} set {_uniqueStorage()._phpNamespace = newValue} } /// Returns true if `phpNamespace` has been explicitly set. - var hasPhpNamespace: Bool {return _storage._phpNamespace != nil} + var hasPhpNamespace: Bool {_storage._phpNamespace != nil} /// Clears the value of `phpNamespace`. Subsequent reads from it will return its default value. mutating func clearPhpNamespace() {_uniqueStorage()._phpNamespace = nil} @@ -1088,11 +1272,11 @@ struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { /// Default is empty. When this option is empty, the proto file name will be /// used for determining the namespace. var phpMetadataNamespace: String { - get {return _storage._phpMetadataNamespace ?? String()} + get {_storage._phpMetadataNamespace ?? String()} set {_uniqueStorage()._phpMetadataNamespace = newValue} } /// Returns true if `phpMetadataNamespace` has been explicitly set. - var hasPhpMetadataNamespace: Bool {return _storage._phpMetadataNamespace != nil} + var hasPhpMetadataNamespace: Bool {_storage._phpMetadataNamespace != nil} /// Clears the value of `phpMetadataNamespace`. Subsequent reads from it will return its default value. mutating func clearPhpMetadataNamespace() {_uniqueStorage()._phpMetadataNamespace = nil} @@ -1100,74 +1284,61 @@ struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { /// is empty. When this option is not set, the package name will be used for /// determining the ruby package. var rubyPackage: String { - get {return _storage._rubyPackage ?? String()} + get {_storage._rubyPackage ?? String()} set {_uniqueStorage()._rubyPackage = newValue} } /// Returns true if `rubyPackage` has been explicitly set. - var hasRubyPackage: Bool {return _storage._rubyPackage != nil} + var hasRubyPackage: Bool {_storage._rubyPackage != nil} /// Clears the value of `rubyPackage`. Subsequent reads from it will return its default value. mutating func clearRubyPackage() {_uniqueStorage()._rubyPackage = nil} + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var features: Google_Protobuf_FeatureSet { + get {_storage._features ?? Google_Protobuf_FeatureSet()} + set {_uniqueStorage()._features = newValue} + } + /// Returns true if `features` has been explicitly set. + var hasFeatures: Bool {_storage._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + mutating func clearFeatures() {_uniqueStorage()._features = nil} + /// The parser stores options it doesn't recognize here. /// See the documentation for the "Options" section above. var uninterpretedOption: [Google_Protobuf_UninterpretedOption] { - get {return _storage._uninterpretedOption} + get {_storage._uninterpretedOption} set {_uniqueStorage()._uninterpretedOption = newValue} } - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() /// Generated classes can be optimized for speed or code size. - enum OptimizeMode: SwiftProtobuf.Enum { - typealias RawValue = Int + enum OptimizeMode: Int, Enum, Swift.CaseIterable { /// Generate complete code for parsing, serialization, - case speed // = 1 + case speed = 1 /// etc. - case codeSize // = 2 + case codeSize = 2 /// Generate code using MessageLite and the lite runtime. - case liteRuntime // = 3 + case liteRuntime = 3 init() { self = .speed } - init?(rawValue: Int) { - switch rawValue { - case 1: self = .speed - case 2: self = .codeSize - case 3: self = .liteRuntime - default: return nil - } - } - - var rawValue: Int { - switch self { - case .speed: return 1 - case .codeSize: return 2 - case .liteRuntime: return 3 - } - } - } init() {} - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension Google_Protobuf_FileOptions.OptimizeMode: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct Google_Protobuf_MessageOptions: SwiftProtobuf.ExtensibleMessage { +struct Google_Protobuf_MessageOptions: ExtensibleMessage, Sendable { // 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. @@ -1191,11 +1362,11 @@ struct Google_Protobuf_MessageOptions: SwiftProtobuf.ExtensibleMessage { /// Because this is an option, the above two restrictions are not enforced by /// the protocol compiler. var messageSetWireFormat: Bool { - get {return _messageSetWireFormat ?? false} + get {_messageSetWireFormat ?? false} set {_messageSetWireFormat = newValue} } /// Returns true if `messageSetWireFormat` has been explicitly set. - var hasMessageSetWireFormat: Bool {return self._messageSetWireFormat != nil} + var hasMessageSetWireFormat: Bool {self._messageSetWireFormat != nil} /// Clears the value of `messageSetWireFormat`. Subsequent reads from it will return its default value. mutating func clearMessageSetWireFormat() {self._messageSetWireFormat = nil} @@ -1203,11 +1374,11 @@ struct Google_Protobuf_MessageOptions: SwiftProtobuf.ExtensibleMessage { /// conflict with a field of the same name. This is meant to make migration /// from proto1 easier; new code should avoid fields named "descriptor". var noStandardDescriptorAccessor: Bool { - get {return _noStandardDescriptorAccessor ?? false} + get {_noStandardDescriptorAccessor ?? false} set {_noStandardDescriptorAccessor = newValue} } /// Returns true if `noStandardDescriptorAccessor` has been explicitly set. - var hasNoStandardDescriptorAccessor: Bool {return self._noStandardDescriptorAccessor != nil} + var hasNoStandardDescriptorAccessor: Bool {self._noStandardDescriptorAccessor != nil} /// Clears the value of `noStandardDescriptorAccessor`. Subsequent reads from it will return its default value. mutating func clearNoStandardDescriptorAccessor() {self._noStandardDescriptorAccessor = nil} @@ -1216,11 +1387,11 @@ struct Google_Protobuf_MessageOptions: SwiftProtobuf.ExtensibleMessage { /// for the message, or it will be completely ignored; in the very least, /// this is a formalization for deprecating messages. var deprecated: Bool { - get {return _deprecated ?? false} + get {_deprecated ?? false} set {_deprecated = newValue} } /// Returns true if `deprecated` has been explicitly set. - var hasDeprecated: Bool {return self._deprecated != nil} + var hasDeprecated: Bool {self._deprecated != nil} /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. mutating func clearDeprecated() {self._deprecated = nil} @@ -1246,59 +1417,100 @@ struct Google_Protobuf_MessageOptions: SwiftProtobuf.ExtensibleMessage { /// instead. The option should only be implicitly set by the proto compiler /// parser. var mapEntry: Bool { - get {return _mapEntry ?? false} + get {_mapEntry ?? false} set {_mapEntry = newValue} } /// Returns true if `mapEntry` has been explicitly set. - var hasMapEntry: Bool {return self._mapEntry != nil} + var hasMapEntry: Bool {self._mapEntry != nil} /// Clears the value of `mapEntry`. Subsequent reads from it will return its default value. mutating func clearMapEntry() {self._mapEntry = nil} + /// Enable the legacy handling of JSON field name conflicts. This lowercases + /// and strips underscored from the fields before comparison in proto3 only. + /// The new behavior takes `json_name` into account and applies to proto2 as + /// well. + /// + /// This should only be used as a temporary measure against broken builds due + /// to the change in behavior for JSON field name conflicts. + /// + /// TODO This is legacy behavior we plan to remove once downstream + /// teams have had time to migrate. + /// + /// NOTE: This field was marked as deprecated in the .proto file. + var deprecatedLegacyJsonFieldConflicts: Bool { + get {_deprecatedLegacyJsonFieldConflicts ?? false} + set {_deprecatedLegacyJsonFieldConflicts = newValue} + } + /// Returns true if `deprecatedLegacyJsonFieldConflicts` has been explicitly set. + var hasDeprecatedLegacyJsonFieldConflicts: Bool {self._deprecatedLegacyJsonFieldConflicts != nil} + /// Clears the value of `deprecatedLegacyJsonFieldConflicts`. Subsequent reads from it will return its default value. + mutating func clearDeprecatedLegacyJsonFieldConflicts() {self._deprecatedLegacyJsonFieldConflicts = nil} + + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + mutating func clearFeatures() {self._features = nil} + /// The parser stores options it doesn't recognize here. See above. var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() fileprivate var _messageSetWireFormat: Bool? = nil fileprivate var _noStandardDescriptorAccessor: Bool? = nil fileprivate var _deprecated: Bool? = nil fileprivate var _mapEntry: Bool? = nil + fileprivate var _deprecatedLegacyJsonFieldConflicts: Bool? = nil + fileprivate var _features: Google_Protobuf_FeatureSet? = nil } -struct Google_Protobuf_FieldOptions: SwiftProtobuf.ExtensibleMessage { +struct Google_Protobuf_FieldOptions: ExtensibleMessage, @unchecked Sendable { // 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. + /// NOTE: ctype is deprecated. Use `features.(pb.cpp).string_type` instead. /// The ctype option instructs the C++ code generator to use a different /// representation of the field than it normally would. See the specific - /// options below. This option is not yet implemented in the open source - /// release -- sorry, we'll try to include it in a future version! + /// options below. This option is only implemented to support use of + /// [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of + /// type "bytes" in the open source release. + /// TODO: make ctype actually deprecated. var ctype: Google_Protobuf_FieldOptions.CType { - get {return _ctype ?? .string} - set {_ctype = newValue} + get {_storage._ctype ?? .string} + set {_uniqueStorage()._ctype = newValue} } /// Returns true if `ctype` has been explicitly set. - var hasCtype: Bool {return self._ctype != nil} + var hasCtype: Bool {_storage._ctype != nil} /// Clears the value of `ctype`. Subsequent reads from it will return its default value. - mutating func clearCtype() {self._ctype = nil} + mutating func clearCtype() {_uniqueStorage()._ctype = nil} /// The packed option can be enabled for repeated primitive fields to enable /// a more efficient representation on the wire. Rather than repeatedly /// writing the tag and type for each element, the entire array is encoded as /// a single length-delimited blob. In proto3, only explicit setting it to - /// false will avoid using packed encoding. + /// false will avoid using packed encoding. This option is prohibited in + /// Editions, but the `repeated_field_encoding` feature can be used to control + /// the behavior. var packed: Bool { - get {return _packed ?? false} - set {_packed = newValue} + get {_storage._packed ?? false} + set {_uniqueStorage()._packed = newValue} } /// Returns true if `packed` has been explicitly set. - var hasPacked: Bool {return self._packed != nil} + var hasPacked: Bool {_storage._packed != nil} /// Clears the value of `packed`. Subsequent reads from it will return its default value. - mutating func clearPacked() {self._packed = nil} + mutating func clearPacked() {_uniqueStorage()._packed = nil} /// The jstype option determines the JavaScript type used for values of the /// field. The option is permitted only for 64 bit integral and fixed types @@ -1312,13 +1524,13 @@ struct Google_Protobuf_FieldOptions: SwiftProtobuf.ExtensibleMessage { /// This option is an enum to permit additional types to be added, e.g. /// goog.math.Integer. var jstype: Google_Protobuf_FieldOptions.JSType { - get {return _jstype ?? .jsNormal} - set {_jstype = newValue} + get {_storage._jstype ?? .jsNormal} + set {_uniqueStorage()._jstype = newValue} } /// Returns true if `jstype` has been explicitly set. - var hasJstype: Bool {return self._jstype != nil} + var hasJstype: Bool {_storage._jstype != nil} /// Clears the value of `jstype`. Subsequent reads from it will return its default value. - mutating func clearJstype() {self._jstype = nil} + mutating func clearJstype() {_uniqueStorage()._jstype = nil} /// Should this field be parsed lazily? Lazy applies only to message-type /// fields. It means that when the outer message is initially parsed, the @@ -1337,159 +1549,330 @@ struct Google_Protobuf_FieldOptions: SwiftProtobuf.ExtensibleMessage { /// call from multiple threads concurrently, while non-const methods continue /// to require exclusive access. /// - /// - /// Note that implementations may choose not to check required fields within - /// a lazy sub-message. That is, calling IsInitialized() on the outer message - /// may return true even if the inner message has missing required fields. - /// This is necessary because otherwise the inner message would have to be - /// parsed in order to perform the check, defeating the purpose of lazy - /// parsing. An implementation which chooses not to check required fields - /// must be consistent about it. That is, for any particular sub-message, the - /// implementation must either *always* check its required fields, or *never* - /// check its required fields, regardless of whether or not the message has - /// been parsed. + /// Note that lazy message fields are still eagerly verified to check + /// ill-formed wireformat or missing required fields. Calling IsInitialized() + /// on the outer message would fail if the inner message has missing required + /// fields. Failed verification would result in parsing failure (except when + /// uninitialized messages are acceptable). var lazy: Bool { - get {return _lazy ?? false} - set {_lazy = newValue} + get {_storage._lazy ?? false} + set {_uniqueStorage()._lazy = newValue} } /// Returns true if `lazy` has been explicitly set. - var hasLazy: Bool {return self._lazy != nil} + var hasLazy: Bool {_storage._lazy != nil} /// Clears the value of `lazy`. Subsequent reads from it will return its default value. - mutating func clearLazy() {self._lazy = nil} + mutating func clearLazy() {_uniqueStorage()._lazy = nil} + + /// unverified_lazy does no correctness checks on the byte stream. This should + /// only be used where lazy with verification is prohibitive for performance + /// reasons. + var unverifiedLazy: Bool { + get {_storage._unverifiedLazy ?? false} + set {_uniqueStorage()._unverifiedLazy = newValue} + } + /// Returns true if `unverifiedLazy` has been explicitly set. + var hasUnverifiedLazy: Bool {_storage._unverifiedLazy != nil} + /// Clears the value of `unverifiedLazy`. Subsequent reads from it will return its default value. + mutating func clearUnverifiedLazy() {_uniqueStorage()._unverifiedLazy = nil} /// Is this field deprecated? /// Depending on the target platform, this can emit Deprecated annotations /// for accessors, or it will be completely ignored; in the very least, this /// is a formalization for deprecating fields. var deprecated: Bool { - get {return _deprecated ?? false} - set {_deprecated = newValue} + get {_storage._deprecated ?? false} + set {_uniqueStorage()._deprecated = newValue} } /// Returns true if `deprecated` has been explicitly set. - var hasDeprecated: Bool {return self._deprecated != nil} + var hasDeprecated: Bool {_storage._deprecated != nil} /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. - mutating func clearDeprecated() {self._deprecated = nil} + mutating func clearDeprecated() {_uniqueStorage()._deprecated = nil} + /// DEPRECATED. DO NOT USE! /// For Google-internal migration only. Do not use. + /// + /// NOTE: This field was marked as deprecated in the .proto file. var weak: Bool { - get {return _weak ?? false} - set {_weak = newValue} + get {_storage._weak ?? false} + set {_uniqueStorage()._weak = newValue} } /// Returns true if `weak` has been explicitly set. - var hasWeak: Bool {return self._weak != nil} + var hasWeak: Bool {_storage._weak != nil} /// Clears the value of `weak`. Subsequent reads from it will return its default value. - mutating func clearWeak() {self._weak = nil} + mutating func clearWeak() {_uniqueStorage()._weak = nil} + + /// Indicate that the field value should not be printed out when using debug + /// formats, e.g. when the field contains sensitive credentials. + var debugRedact: Bool { + get {_storage._debugRedact ?? false} + set {_uniqueStorage()._debugRedact = newValue} + } + /// Returns true if `debugRedact` has been explicitly set. + var hasDebugRedact: Bool {_storage._debugRedact != nil} + /// Clears the value of `debugRedact`. Subsequent reads from it will return its default value. + mutating func clearDebugRedact() {_uniqueStorage()._debugRedact = nil} + + var retention: Google_Protobuf_FieldOptions.OptionRetention { + get {_storage._retention ?? .retentionUnknown} + set {_uniqueStorage()._retention = newValue} + } + /// Returns true if `retention` has been explicitly set. + var hasRetention: Bool {_storage._retention != nil} + /// Clears the value of `retention`. Subsequent reads from it will return its default value. + mutating func clearRetention() {_uniqueStorage()._retention = nil} + + var targets: [Google_Protobuf_FieldOptions.OptionTargetType] { + get {_storage._targets} + set {_uniqueStorage()._targets = newValue} + } + + var editionDefaults: [Google_Protobuf_FieldOptions.EditionDefault] { + get {_storage._editionDefaults} + set {_uniqueStorage()._editionDefaults = newValue} + } + + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var features: Google_Protobuf_FeatureSet { + get {_storage._features ?? Google_Protobuf_FeatureSet()} + set {_uniqueStorage()._features = newValue} + } + /// Returns true if `features` has been explicitly set. + var hasFeatures: Bool {_storage._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + mutating func clearFeatures() {_uniqueStorage()._features = nil} + + var featureSupport: Google_Protobuf_FieldOptions.FeatureSupport { + get {_storage._featureSupport ?? Google_Protobuf_FieldOptions.FeatureSupport()} + set {_uniqueStorage()._featureSupport = newValue} + } + /// Returns true if `featureSupport` has been explicitly set. + var hasFeatureSupport: Bool {_storage._featureSupport != nil} + /// Clears the value of `featureSupport`. Subsequent reads from it will return its default value. + mutating func clearFeatureSupport() {_uniqueStorage()._featureSupport = nil} /// The parser stores options it doesn't recognize here. See above. - var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] + var uninterpretedOption: [Google_Protobuf_UninterpretedOption] { + get {_storage._uninterpretedOption} + set {_uniqueStorage()._uninterpretedOption = newValue} + } - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() - enum CType: SwiftProtobuf.Enum { - typealias RawValue = Int + enum CType: Int, Enum, Swift.CaseIterable { /// Default mode. - case string // = 0 - case cord // = 1 - case stringPiece // = 2 + case string = 0 + + /// The option [ctype=CORD] may be applied to a non-repeated field of type + /// "bytes". It indicates that in C++, the data should be stored in a Cord + /// instead of a string. For very large strings, this may reduce memory + /// fragmentation. It may also allow better performance when parsing from a + /// Cord, or when parsing with aliasing enabled, as the parsed Cord may then + /// alias the original buffer. + case cord = 1 + case stringPiece = 2 init() { self = .string } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .string - case 1: self = .cord - case 2: self = .stringPiece - default: return nil - } - } - - var rawValue: Int { - switch self { - case .string: return 0 - case .cord: return 1 - case .stringPiece: return 2 - } - } - } - enum JSType: SwiftProtobuf.Enum { - typealias RawValue = Int + enum JSType: Int, Enum, Swift.CaseIterable { /// Use the default type. - case jsNormal // = 0 + case jsNormal = 0 /// Use JavaScript strings. - case jsString // = 1 + case jsString = 1 /// Use JavaScript numbers. - case jsNumber // = 2 + case jsNumber = 2 init() { self = .jsNormal } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .jsNormal - case 1: self = .jsString - case 2: self = .jsNumber - default: return nil - } + } + + /// If set to RETENTION_SOURCE, the option will be omitted from the binary. + enum OptionRetention: Int, Enum, Swift.CaseIterable { + case retentionUnknown = 0 + case retentionRuntime = 1 + case retentionSource = 2 + + init() { + self = .retentionUnknown } - var rawValue: Int { - switch self { - case .jsNormal: return 0 - case .jsString: return 1 - case .jsNumber: return 2 - } + } + + /// This indicates the types of entities that the field may apply to when used + /// as an option. If it is unset, then the field may be freely used as an + /// option on any kind of entity. + enum OptionTargetType: Int, Enum, Swift.CaseIterable { + case targetTypeUnknown = 0 + case targetTypeFile = 1 + case targetTypeExtensionRange = 2 + case targetTypeMessage = 3 + case targetTypeField = 4 + case targetTypeOneof = 5 + case targetTypeEnum = 6 + case targetTypeEnumEntry = 7 + case targetTypeService = 8 + case targetTypeMethod = 9 + + init() { + self = .targetTypeUnknown } } - init() {} + struct EditionDefault: Sendable { + // 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 _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _ctype: Google_Protobuf_FieldOptions.CType? = nil - fileprivate var _packed: Bool? = nil - fileprivate var _jstype: Google_Protobuf_FieldOptions.JSType? = nil - fileprivate var _lazy: Bool? = nil - fileprivate var _deprecated: Bool? = nil - fileprivate var _weak: Bool? = nil -} + var edition: Google_Protobuf_Edition { + get {_edition ?? .unknown} + set {_edition = newValue} + } + /// Returns true if `edition` has been explicitly set. + var hasEdition: Bool {self._edition != nil} + /// Clears the value of `edition`. Subsequent reads from it will return its default value. + mutating func clearEdition() {self._edition = nil} + + /// Textproto value. + var value: String { + get {_value ?? String()} + set {_value = newValue} + } + /// Returns true if `value` has been explicitly set. + var hasValue: Bool {self._value != nil} + /// Clears the value of `value`. Subsequent reads from it will return its default value. + mutating func clearValue() {self._value = nil} -#if swift(>=4.2) + var unknownFields = UnknownStorage() -extension Google_Protobuf_FieldOptions.CType: CaseIterable { - // Support synthesized by the compiler. -} + init() {} -extension Google_Protobuf_FieldOptions.JSType: CaseIterable { - // Support synthesized by the compiler. -} + fileprivate var _edition: Google_Protobuf_Edition? = nil + fileprivate var _value: String? = nil + } + + /// Information about the support window of a feature. + struct FeatureSupport: Sendable { + // 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. + + /// The edition that this feature was first available in. In editions + /// earlier than this one, the default assigned to EDITION_LEGACY will be + /// used, and proto files will not be able to override it. + var editionIntroduced: Google_Protobuf_Edition { + get {_editionIntroduced ?? .unknown} + set {_editionIntroduced = newValue} + } + /// Returns true if `editionIntroduced` has been explicitly set. + var hasEditionIntroduced: Bool {self._editionIntroduced != nil} + /// Clears the value of `editionIntroduced`. Subsequent reads from it will return its default value. + mutating func clearEditionIntroduced() {self._editionIntroduced = nil} + + /// The edition this feature becomes deprecated in. Using this after this + /// edition may trigger warnings. + var editionDeprecated: Google_Protobuf_Edition { + get {_editionDeprecated ?? .unknown} + set {_editionDeprecated = newValue} + } + /// Returns true if `editionDeprecated` has been explicitly set. + var hasEditionDeprecated: Bool {self._editionDeprecated != nil} + /// Clears the value of `editionDeprecated`. Subsequent reads from it will return its default value. + mutating func clearEditionDeprecated() {self._editionDeprecated = nil} + + /// The deprecation warning text if this feature is used after the edition it + /// was marked deprecated in. + var deprecationWarning: String { + get {_deprecationWarning ?? String()} + set {_deprecationWarning = newValue} + } + /// Returns true if `deprecationWarning` has been explicitly set. + var hasDeprecationWarning: Bool {self._deprecationWarning != nil} + /// Clears the value of `deprecationWarning`. Subsequent reads from it will return its default value. + mutating func clearDeprecationWarning() {self._deprecationWarning = nil} + + /// The edition this feature is no longer available in. In editions after + /// this one, the last default assigned will be used, and proto files will + /// not be able to override it. + var editionRemoved: Google_Protobuf_Edition { + get {_editionRemoved ?? .unknown} + set {_editionRemoved = newValue} + } + /// Returns true if `editionRemoved` has been explicitly set. + var hasEditionRemoved: Bool {self._editionRemoved != nil} + /// Clears the value of `editionRemoved`. Subsequent reads from it will return its default value. + mutating func clearEditionRemoved() {self._editionRemoved = nil} + + /// The removal error text if this feature is used after the edition it was + /// removed in. + var removalError: String { + get {_removalError ?? String()} + set {_removalError = newValue} + } + /// Returns true if `removalError` has been explicitly set. + var hasRemovalError: Bool {self._removalError != nil} + /// Clears the value of `removalError`. Subsequent reads from it will return its default value. + mutating func clearRemovalError() {self._removalError = nil} + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _editionIntroduced: Google_Protobuf_Edition? = nil + fileprivate var _editionDeprecated: Google_Protobuf_Edition? = nil + fileprivate var _deprecationWarning: String? = nil + fileprivate var _editionRemoved: Google_Protobuf_Edition? = nil + fileprivate var _removalError: String? = nil + } -#endif // swift(>=4.2) + init() {} + + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} -struct Google_Protobuf_OneofOptions: SwiftProtobuf.ExtensibleMessage { +struct Google_Protobuf_OneofOptions: ExtensibleMessage, Sendable { // 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. + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + mutating func clearFeatures() {self._features = nil} + /// The parser stores options it doesn't recognize here. See above. var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _features: Google_Protobuf_FeatureSet? = nil } -struct Google_Protobuf_EnumOptions: SwiftProtobuf.ExtensibleMessage { +struct Google_Protobuf_EnumOptions: ExtensibleMessage, Sendable { // 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. @@ -1497,11 +1880,11 @@ struct Google_Protobuf_EnumOptions: SwiftProtobuf.ExtensibleMessage { /// Set this option to true to allow mapping different tag names to the same /// value. var allowAlias: Bool { - get {return _allowAlias ?? false} + get {_allowAlias ?? false} set {_allowAlias = newValue} } /// Returns true if `allowAlias` has been explicitly set. - var hasAllowAlias: Bool {return self._allowAlias != nil} + var hasAllowAlias: Bool {self._allowAlias != nil} /// Clears the value of `allowAlias`. Subsequent reads from it will return its default value. mutating func clearAllowAlias() {self._allowAlias = nil} @@ -1510,27 +1893,59 @@ struct Google_Protobuf_EnumOptions: SwiftProtobuf.ExtensibleMessage { /// for the enum, or it will be completely ignored; in the very least, this /// is a formalization for deprecating enums. var deprecated: Bool { - get {return _deprecated ?? false} + get {_deprecated ?? false} set {_deprecated = newValue} } /// Returns true if `deprecated` has been explicitly set. - var hasDeprecated: Bool {return self._deprecated != nil} + var hasDeprecated: Bool {self._deprecated != nil} /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. mutating func clearDeprecated() {self._deprecated = nil} + /// Enable the legacy handling of JSON field name conflicts. This lowercases + /// and strips underscored from the fields before comparison in proto3 only. + /// The new behavior takes `json_name` into account and applies to proto2 as + /// well. + /// TODO Remove this legacy behavior once downstream teams have + /// had time to migrate. + /// + /// NOTE: This field was marked as deprecated in the .proto file. + var deprecatedLegacyJsonFieldConflicts: Bool { + get {_deprecatedLegacyJsonFieldConflicts ?? false} + set {_deprecatedLegacyJsonFieldConflicts = newValue} + } + /// Returns true if `deprecatedLegacyJsonFieldConflicts` has been explicitly set. + var hasDeprecatedLegacyJsonFieldConflicts: Bool {self._deprecatedLegacyJsonFieldConflicts != nil} + /// Clears the value of `deprecatedLegacyJsonFieldConflicts`. Subsequent reads from it will return its default value. + mutating func clearDeprecatedLegacyJsonFieldConflicts() {self._deprecatedLegacyJsonFieldConflicts = nil} + + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + mutating func clearFeatures() {self._features = nil} + /// The parser stores options it doesn't recognize here. See above. var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() fileprivate var _allowAlias: Bool? = nil fileprivate var _deprecated: Bool? = nil + fileprivate var _deprecatedLegacyJsonFieldConflicts: Bool? = nil + fileprivate var _features: Google_Protobuf_FeatureSet? = nil } -struct Google_Protobuf_EnumValueOptions: SwiftProtobuf.ExtensibleMessage { +struct Google_Protobuf_EnumValueOptions: ExtensibleMessage, Sendable { // 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. @@ -1540,55 +1955,107 @@ struct Google_Protobuf_EnumValueOptions: SwiftProtobuf.ExtensibleMessage { /// for the enum value, or it will be completely ignored; in the very least, /// this is a formalization for deprecating enum values. var deprecated: Bool { - get {return _deprecated ?? false} + get {_deprecated ?? false} set {_deprecated = newValue} } /// Returns true if `deprecated` has been explicitly set. - var hasDeprecated: Bool {return self._deprecated != nil} + var hasDeprecated: Bool {self._deprecated != nil} /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. mutating func clearDeprecated() {self._deprecated = nil} + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + mutating func clearFeatures() {self._features = nil} + + /// Indicate that fields annotated with this enum value should not be printed + /// out when using debug formats, e.g. when the field contains sensitive + /// credentials. + var debugRedact: Bool { + get {_debugRedact ?? false} + set {_debugRedact = newValue} + } + /// Returns true if `debugRedact` has been explicitly set. + var hasDebugRedact: Bool {self._debugRedact != nil} + /// Clears the value of `debugRedact`. Subsequent reads from it will return its default value. + mutating func clearDebugRedact() {self._debugRedact = nil} + + /// Information about the support window of a feature value. + var featureSupport: Google_Protobuf_FieldOptions.FeatureSupport { + get {_featureSupport ?? Google_Protobuf_FieldOptions.FeatureSupport()} + set {_featureSupport = newValue} + } + /// Returns true if `featureSupport` has been explicitly set. + var hasFeatureSupport: Bool {self._featureSupport != nil} + /// Clears the value of `featureSupport`. Subsequent reads from it will return its default value. + mutating func clearFeatureSupport() {self._featureSupport = nil} + /// The parser stores options it doesn't recognize here. See above. var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() fileprivate var _deprecated: Bool? = nil + fileprivate var _features: Google_Protobuf_FeatureSet? = nil + fileprivate var _debugRedact: Bool? = nil + fileprivate var _featureSupport: Google_Protobuf_FieldOptions.FeatureSupport? = nil } -struct Google_Protobuf_ServiceOptions: SwiftProtobuf.ExtensibleMessage { +struct Google_Protobuf_ServiceOptions: ExtensibleMessage, Sendable { // 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. + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + mutating func clearFeatures() {self._features = nil} + /// Is this service deprecated? /// Depending on the target platform, this can emit Deprecated annotations /// for the service, or it will be completely ignored; in the very least, /// this is a formalization for deprecating services. var deprecated: Bool { - get {return _deprecated ?? false} + get {_deprecated ?? false} set {_deprecated = newValue} } /// Returns true if `deprecated` has been explicitly set. - var hasDeprecated: Bool {return self._deprecated != nil} + var hasDeprecated: Bool {self._deprecated != nil} /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. mutating func clearDeprecated() {self._deprecated = nil} /// The parser stores options it doesn't recognize here. See above. var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _features: Google_Protobuf_FeatureSet? = nil fileprivate var _deprecated: Bool? = nil } -struct Google_Protobuf_MethodOptions: SwiftProtobuf.ExtensibleMessage { +struct Google_Protobuf_MethodOptions: ExtensibleMessage, Sendable { // 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. @@ -1598,86 +2065,74 @@ struct Google_Protobuf_MethodOptions: SwiftProtobuf.ExtensibleMessage { /// for the method, or it will be completely ignored; in the very least, /// this is a formalization for deprecating methods. var deprecated: Bool { - get {return _deprecated ?? false} + get {_deprecated ?? false} set {_deprecated = newValue} } /// Returns true if `deprecated` has been explicitly set. - var hasDeprecated: Bool {return self._deprecated != nil} + var hasDeprecated: Bool {self._deprecated != nil} /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. mutating func clearDeprecated() {self._deprecated = nil} var idempotencyLevel: Google_Protobuf_MethodOptions.IdempotencyLevel { - get {return _idempotencyLevel ?? .idempotencyUnknown} + get {_idempotencyLevel ?? .idempotencyUnknown} set {_idempotencyLevel = newValue} } /// Returns true if `idempotencyLevel` has been explicitly set. - var hasIdempotencyLevel: Bool {return self._idempotencyLevel != nil} + var hasIdempotencyLevel: Bool {self._idempotencyLevel != nil} /// Clears the value of `idempotencyLevel`. Subsequent reads from it will return its default value. mutating func clearIdempotencyLevel() {self._idempotencyLevel = nil} + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + mutating func clearFeatures() {self._features = nil} + /// The parser stores options it doesn't recognize here. See above. var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() /// Is this method side-effect-free (or safe in HTTP parlance), or idempotent, /// or neither? HTTP based RPC implementation may choose GET verb for safe /// methods, and PUT verb for idempotent methods instead of the default POST. - enum IdempotencyLevel: SwiftProtobuf.Enum { - typealias RawValue = Int - case idempotencyUnknown // = 0 + enum IdempotencyLevel: Int, Enum, Swift.CaseIterable { + case idempotencyUnknown = 0 /// implies idempotent - case noSideEffects // = 1 + case noSideEffects = 1 /// idempotent, but may have side effects - case idempotent // = 2 + case idempotent = 2 init() { self = .idempotencyUnknown } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .idempotencyUnknown - case 1: self = .noSideEffects - case 2: self = .idempotent - default: return nil - } - } - - var rawValue: Int { - switch self { - case .idempotencyUnknown: return 0 - case .noSideEffects: return 1 - case .idempotent: return 2 - } - } - } init() {} - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() fileprivate var _deprecated: Bool? = nil fileprivate var _idempotencyLevel: Google_Protobuf_MethodOptions.IdempotencyLevel? = nil + fileprivate var _features: Google_Protobuf_FeatureSet? = nil } -#if swift(>=4.2) - -extension Google_Protobuf_MethodOptions.IdempotencyLevel: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - /// A message representing a option the parser does not recognize. This only /// appears in options protos created by the compiler::Parser class. /// DescriptorPool resolves these when building Descriptor objects. Therefore, /// options protos in descriptor objects (e.g. returned by Descriptor::options(), /// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions /// in them. -struct Google_Protobuf_UninterpretedOption { +struct Google_Protobuf_UninterpretedOption: Sendable { // 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. @@ -1687,90 +2142,90 @@ struct Google_Protobuf_UninterpretedOption { /// The value of the uninterpreted option, in whatever type the tokenizer /// identified it as during parsing. Exactly one of these should be set. var identifierValue: String { - get {return _identifierValue ?? String()} + get {_identifierValue ?? String()} set {_identifierValue = newValue} } /// Returns true if `identifierValue` has been explicitly set. - var hasIdentifierValue: Bool {return self._identifierValue != nil} + var hasIdentifierValue: Bool {self._identifierValue != nil} /// Clears the value of `identifierValue`. Subsequent reads from it will return its default value. mutating func clearIdentifierValue() {self._identifierValue = nil} var positiveIntValue: UInt64 { - get {return _positiveIntValue ?? 0} + get {_positiveIntValue ?? 0} set {_positiveIntValue = newValue} } /// Returns true if `positiveIntValue` has been explicitly set. - var hasPositiveIntValue: Bool {return self._positiveIntValue != nil} + var hasPositiveIntValue: Bool {self._positiveIntValue != nil} /// Clears the value of `positiveIntValue`. Subsequent reads from it will return its default value. mutating func clearPositiveIntValue() {self._positiveIntValue = nil} var negativeIntValue: Int64 { - get {return _negativeIntValue ?? 0} + get {_negativeIntValue ?? 0} set {_negativeIntValue = newValue} } /// Returns true if `negativeIntValue` has been explicitly set. - var hasNegativeIntValue: Bool {return self._negativeIntValue != nil} + var hasNegativeIntValue: Bool {self._negativeIntValue != nil} /// Clears the value of `negativeIntValue`. Subsequent reads from it will return its default value. mutating func clearNegativeIntValue() {self._negativeIntValue = nil} var doubleValue: Double { - get {return _doubleValue ?? 0} + get {_doubleValue ?? 0} set {_doubleValue = newValue} } /// Returns true if `doubleValue` has been explicitly set. - var hasDoubleValue: Bool {return self._doubleValue != nil} + var hasDoubleValue: Bool {self._doubleValue != nil} /// Clears the value of `doubleValue`. Subsequent reads from it will return its default value. mutating func clearDoubleValue() {self._doubleValue = nil} var stringValue: Data { - get {return _stringValue ?? Data()} + get {_stringValue ?? Data()} set {_stringValue = newValue} } /// Returns true if `stringValue` has been explicitly set. - var hasStringValue: Bool {return self._stringValue != nil} + var hasStringValue: Bool {self._stringValue != nil} /// Clears the value of `stringValue`. Subsequent reads from it will return its default value. mutating func clearStringValue() {self._stringValue = nil} var aggregateValue: String { - get {return _aggregateValue ?? String()} + get {_aggregateValue ?? String()} set {_aggregateValue = newValue} } /// Returns true if `aggregateValue` has been explicitly set. - var hasAggregateValue: Bool {return self._aggregateValue != nil} + var hasAggregateValue: Bool {self._aggregateValue != nil} /// Clears the value of `aggregateValue`. Subsequent reads from it will return its default value. mutating func clearAggregateValue() {self._aggregateValue = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() /// The name of the uninterpreted option. Each string represents a segment in /// a dot-separated name. is_extension is true iff a segment represents an /// extension (denoted with parentheses in options specs in .proto files). - /// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents - /// "foo.(bar.baz).qux". - struct NamePart { + /// E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents + /// "foo.(bar.baz).moo". + struct NamePart: Sendable { // 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 namePart: String { - get {return _namePart ?? String()} + get {_namePart ?? String()} set {_namePart = newValue} } /// Returns true if `namePart` has been explicitly set. - var hasNamePart: Bool {return self._namePart != nil} + var hasNamePart: Bool {self._namePart != nil} /// Clears the value of `namePart`. Subsequent reads from it will return its default value. mutating func clearNamePart() {self._namePart = nil} var isExtension: Bool { - get {return _isExtension ?? false} + get {_isExtension ?? false} set {_isExtension = newValue} } /// Returns true if `isExtension` has been explicitly set. - var hasIsExtension: Bool {return self._isExtension != nil} + var hasIsExtension: Bool {self._isExtension != nil} /// Clears the value of `isExtension`. Subsequent reads from it will return its default value. mutating func clearIsExtension() {self._isExtension = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} @@ -1788,20 +2243,315 @@ struct Google_Protobuf_UninterpretedOption { fileprivate var _aggregateValue: String? = nil } -/// Encapsulates information about the original source file from which a -/// FileDescriptorProto was generated. -struct Google_Protobuf_SourceCodeInfo { +/// TODO Enums in C++ gencode (and potentially other languages) are +/// not well scoped. This means that each of the feature enums below can clash +/// with each other. The short names we've chosen maximize call-site +/// readability, but leave us very open to this scenario. A future feature will +/// be designed and implemented to handle this, hopefully before we ever hit a +/// conflict here. +struct Google_Protobuf_FeatureSet: ExtensibleMessage, Sendable { // 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. - /// A Location identifies a piece of source code in a .proto file which - /// corresponds to a particular definition. This information is intended - /// to be useful to IDEs, code indexers, documentation generators, and similar - /// tools. - /// - /// For example, say we have a file like: - /// message Foo { + var fieldPresence: Google_Protobuf_FeatureSet.FieldPresence { + get {_fieldPresence ?? .unknown} + set {_fieldPresence = newValue} + } + /// Returns true if `fieldPresence` has been explicitly set. + var hasFieldPresence: Bool {self._fieldPresence != nil} + /// Clears the value of `fieldPresence`. Subsequent reads from it will return its default value. + mutating func clearFieldPresence() {self._fieldPresence = nil} + + var enumType: Google_Protobuf_FeatureSet.EnumType { + get {_enumType ?? .unknown} + set {_enumType = newValue} + } + /// Returns true if `enumType` has been explicitly set. + var hasEnumType: Bool {self._enumType != nil} + /// Clears the value of `enumType`. Subsequent reads from it will return its default value. + mutating func clearEnumType() {self._enumType = nil} + + var repeatedFieldEncoding: Google_Protobuf_FeatureSet.RepeatedFieldEncoding { + get {_repeatedFieldEncoding ?? .unknown} + set {_repeatedFieldEncoding = newValue} + } + /// Returns true if `repeatedFieldEncoding` has been explicitly set. + var hasRepeatedFieldEncoding: Bool {self._repeatedFieldEncoding != nil} + /// Clears the value of `repeatedFieldEncoding`. Subsequent reads from it will return its default value. + mutating func clearRepeatedFieldEncoding() {self._repeatedFieldEncoding = nil} + + var utf8Validation: Google_Protobuf_FeatureSet.Utf8Validation { + get {_utf8Validation ?? .unknown} + set {_utf8Validation = newValue} + } + /// Returns true if `utf8Validation` has been explicitly set. + var hasUtf8Validation: Bool {self._utf8Validation != nil} + /// Clears the value of `utf8Validation`. Subsequent reads from it will return its default value. + mutating func clearUtf8Validation() {self._utf8Validation = nil} + + var messageEncoding: Google_Protobuf_FeatureSet.MessageEncoding { + get {_messageEncoding ?? .unknown} + set {_messageEncoding = newValue} + } + /// Returns true if `messageEncoding` has been explicitly set. + var hasMessageEncoding: Bool {self._messageEncoding != nil} + /// Clears the value of `messageEncoding`. Subsequent reads from it will return its default value. + mutating func clearMessageEncoding() {self._messageEncoding = nil} + + var jsonFormat: Google_Protobuf_FeatureSet.JsonFormat { + get {_jsonFormat ?? .unknown} + set {_jsonFormat = newValue} + } + /// Returns true if `jsonFormat` has been explicitly set. + var hasJsonFormat: Bool {self._jsonFormat != nil} + /// Clears the value of `jsonFormat`. Subsequent reads from it will return its default value. + mutating func clearJsonFormat() {self._jsonFormat = nil} + + var enforceNamingStyle: Google_Protobuf_FeatureSet.EnforceNamingStyle { + get {_enforceNamingStyle ?? .unknown} + set {_enforceNamingStyle = newValue} + } + /// Returns true if `enforceNamingStyle` has been explicitly set. + var hasEnforceNamingStyle: Bool {self._enforceNamingStyle != nil} + /// Clears the value of `enforceNamingStyle`. Subsequent reads from it will return its default value. + mutating func clearEnforceNamingStyle() {self._enforceNamingStyle = nil} + + var defaultSymbolVisibility: Google_Protobuf_FeatureSet.VisibilityFeature.DefaultSymbolVisibility { + get {_defaultSymbolVisibility ?? .unknown} + set {_defaultSymbolVisibility = newValue} + } + /// Returns true if `defaultSymbolVisibility` has been explicitly set. + var hasDefaultSymbolVisibility: Bool {self._defaultSymbolVisibility != nil} + /// Clears the value of `defaultSymbolVisibility`. Subsequent reads from it will return its default value. + mutating func clearDefaultSymbolVisibility() {self._defaultSymbolVisibility = nil} + + var unknownFields = UnknownStorage() + + enum FieldPresence: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case explicit = 1 + case implicit = 2 + case legacyRequired = 3 + + init() { + self = .unknown + } + + } + + enum EnumType: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case `open` = 1 + case closed = 2 + + init() { + self = .unknown + } + + } + + enum RepeatedFieldEncoding: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case packed = 1 + case expanded = 2 + + init() { + self = .unknown + } + + } + + enum Utf8Validation: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case verify = 2 + case none = 3 + + init() { + self = .unknown + } + + } + + enum MessageEncoding: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case lengthPrefixed = 1 + case delimited = 2 + + init() { + self = .unknown + } + + } + + enum JsonFormat: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case allow = 1 + case legacyBestEffort = 2 + + init() { + self = .unknown + } + + } + + enum EnforceNamingStyle: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case style2024 = 1 + case styleLegacy = 2 + + init() { + self = .unknown + } + + } + + struct VisibilityFeature: Sendable { + // 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 = UnknownStorage() + + enum DefaultSymbolVisibility: Int, Enum, Swift.CaseIterable { + case unknown = 0 + + /// Default pre-EDITION_2024, all UNSET visibility are export. + case exportAll = 1 + + /// All top-level symbols default to export, nested default to local. + case exportTopLevel = 2 + + /// All symbols default to local. + case localAll = 3 + + /// All symbols local by default. Nested types cannot be exported. + /// With special case caveat for message { enum {} reserved 1 to max; } + /// This is the recommended setting for new protos. + case strict = 4 + + init() { + self = .unknown + } + + } + + init() {} + } + + init() {} + + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _fieldPresence: Google_Protobuf_FeatureSet.FieldPresence? = nil + fileprivate var _enumType: Google_Protobuf_FeatureSet.EnumType? = nil + fileprivate var _repeatedFieldEncoding: Google_Protobuf_FeatureSet.RepeatedFieldEncoding? = nil + fileprivate var _utf8Validation: Google_Protobuf_FeatureSet.Utf8Validation? = nil + fileprivate var _messageEncoding: Google_Protobuf_FeatureSet.MessageEncoding? = nil + fileprivate var _jsonFormat: Google_Protobuf_FeatureSet.JsonFormat? = nil + fileprivate var _enforceNamingStyle: Google_Protobuf_FeatureSet.EnforceNamingStyle? = nil + fileprivate var _defaultSymbolVisibility: Google_Protobuf_FeatureSet.VisibilityFeature.DefaultSymbolVisibility? = nil +} + +/// A compiled specification for the defaults of a set of features. These +/// messages are generated from FeatureSet extensions and can be used to seed +/// feature resolution. The resolution with this object becomes a simple search +/// for the closest matching edition, followed by proto merges. +struct Google_Protobuf_FeatureSetDefaults: Sendable { + // 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 defaults: [Google_Protobuf_FeatureSetDefaults.FeatureSetEditionDefault] = [] + + /// The minimum supported edition (inclusive) when this was constructed. + /// Editions before this will not have defaults. + var minimumEdition: Google_Protobuf_Edition { + get {_minimumEdition ?? .unknown} + set {_minimumEdition = newValue} + } + /// Returns true if `minimumEdition` has been explicitly set. + var hasMinimumEdition: Bool {self._minimumEdition != nil} + /// Clears the value of `minimumEdition`. Subsequent reads from it will return its default value. + mutating func clearMinimumEdition() {self._minimumEdition = nil} + + /// The maximum known edition (inclusive) when this was constructed. Editions + /// after this will not have reliable defaults. + var maximumEdition: Google_Protobuf_Edition { + get {_maximumEdition ?? .unknown} + set {_maximumEdition = newValue} + } + /// Returns true if `maximumEdition` has been explicitly set. + var hasMaximumEdition: Bool {self._maximumEdition != nil} + /// Clears the value of `maximumEdition`. Subsequent reads from it will return its default value. + mutating func clearMaximumEdition() {self._maximumEdition = nil} + + var unknownFields = UnknownStorage() + + /// A map from every known edition with a unique set of defaults to its + /// defaults. Not all editions may be contained here. For a given edition, + /// the defaults at the closest matching edition ordered at or before it should + /// be used. This field must be in strict ascending order by edition. + struct FeatureSetEditionDefault: @unchecked Sendable { + // 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 edition: Google_Protobuf_Edition { + get {_storage._edition ?? .unknown} + set {_uniqueStorage()._edition = newValue} + } + /// Returns true if `edition` has been explicitly set. + var hasEdition: Bool {_storage._edition != nil} + /// Clears the value of `edition`. Subsequent reads from it will return its default value. + mutating func clearEdition() {_uniqueStorage()._edition = nil} + + /// Defaults of features that can be overridden in this edition. + var overridableFeatures: Google_Protobuf_FeatureSet { + get {_storage._overridableFeatures ?? Google_Protobuf_FeatureSet()} + set {_uniqueStorage()._overridableFeatures = newValue} + } + /// Returns true if `overridableFeatures` has been explicitly set. + var hasOverridableFeatures: Bool {_storage._overridableFeatures != nil} + /// Clears the value of `overridableFeatures`. Subsequent reads from it will return its default value. + mutating func clearOverridableFeatures() {_uniqueStorage()._overridableFeatures = nil} + + /// Defaults of features that can't be overridden in this edition. + var fixedFeatures: Google_Protobuf_FeatureSet { + get {_storage._fixedFeatures ?? Google_Protobuf_FeatureSet()} + set {_uniqueStorage()._fixedFeatures = newValue} + } + /// Returns true if `fixedFeatures` has been explicitly set. + var hasFixedFeatures: Bool {_storage._fixedFeatures != nil} + /// Clears the value of `fixedFeatures`. Subsequent reads from it will return its default value. + mutating func clearFixedFeatures() {_uniqueStorage()._fixedFeatures = nil} + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + init() {} + + fileprivate var _minimumEdition: Google_Protobuf_Edition? = nil + fileprivate var _maximumEdition: Google_Protobuf_Edition? = nil +} + +/// Encapsulates information about the original source file from which a +/// FileDescriptorProto was generated. +struct Google_Protobuf_SourceCodeInfo: ExtensibleMessage, Sendable { + // 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. + + /// A Location identifies a piece of source code in a .proto file which + /// corresponds to a particular definition. This information is intended + /// to be useful to IDEs, code indexers, documentation generators, and similar + /// tools. + /// + /// For example, say we have a file like: + /// message Foo { /// optional string foo = 1; /// } /// Let's look at just the field definition: @@ -1840,9 +2590,9 @@ struct Google_Protobuf_SourceCodeInfo { /// be recorded in the future. var location: [Google_Protobuf_SourceCodeInfo.Location] = [] - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() - struct Location { + struct Location: Sendable { // 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. @@ -1851,8 +2601,8 @@ struct Google_Protobuf_SourceCodeInfo { /// location. /// /// Each element is a field number or an index. They form a path from - /// the root FileDescriptorProto to the place where the definition. For - /// example, this path: + /// the root FileDescriptorProto to the place where the definition appears. + /// For example, this path: /// [ 4, 3, 2, 7, 1 ] /// refers to: /// file.message_type(3) // 4, 3 @@ -1906,13 +2656,13 @@ struct Google_Protobuf_SourceCodeInfo { /// // Comment attached to baz. /// // Another line attached to baz. /// - /// // Comment attached to qux. + /// // Comment attached to moo. /// // - /// // Another line attached to qux. - /// optional double qux = 4; + /// // Another line attached to moo. + /// optional double moo = 4; /// /// // Detached comment for corge. This is not leading or trailing comments - /// // to qux or corge because there are blank lines separating it from + /// // to moo or corge because there are blank lines separating it from /// // both. /// /// // Detached comment for corge paragraph 2. @@ -1927,26 +2677,26 @@ struct Google_Protobuf_SourceCodeInfo { /// /// // ignored detached comments. var leadingComments: String { - get {return _leadingComments ?? String()} + get {_leadingComments ?? String()} set {_leadingComments = newValue} } /// Returns true if `leadingComments` has been explicitly set. - var hasLeadingComments: Bool {return self._leadingComments != nil} + var hasLeadingComments: Bool {self._leadingComments != nil} /// Clears the value of `leadingComments`. Subsequent reads from it will return its default value. mutating func clearLeadingComments() {self._leadingComments = nil} var trailingComments: String { - get {return _trailingComments ?? String()} + get {_trailingComments ?? String()} set {_trailingComments = newValue} } /// Returns true if `trailingComments` has been explicitly set. - var hasTrailingComments: Bool {return self._trailingComments != nil} + var hasTrailingComments: Bool {self._trailingComments != nil} /// Clears the value of `trailingComments`. Subsequent reads from it will return its default value. mutating func clearTrailingComments() {self._trailingComments = nil} var leadingDetachedComments: [String] = [] - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} @@ -1955,12 +2705,14 @@ struct Google_Protobuf_SourceCodeInfo { } init() {} + + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() } /// Describes the relationship between generated code and its original source /// file. A GeneratedCodeInfo message is associated with only one generated /// source file, but may contain references to different source .proto files. -struct Google_Protobuf_GeneratedCodeInfo { +struct Google_Protobuf_GeneratedCodeInfo: Sendable { // 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. @@ -1969,9 +2721,9 @@ struct Google_Protobuf_GeneratedCodeInfo { /// of its generating .proto file. var annotation: [Google_Protobuf_GeneratedCodeInfo.Annotation] = [] - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() - struct Annotation { + struct Annotation: Sendable { // 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. @@ -1982,153 +2734,145 @@ struct Google_Protobuf_GeneratedCodeInfo { /// Identifies the filesystem path to the original source .proto. var sourceFile: String { - get {return _sourceFile ?? String()} + get {_sourceFile ?? String()} set {_sourceFile = newValue} } /// Returns true if `sourceFile` has been explicitly set. - var hasSourceFile: Bool {return self._sourceFile != nil} + var hasSourceFile: Bool {self._sourceFile != nil} /// Clears the value of `sourceFile`. Subsequent reads from it will return its default value. mutating func clearSourceFile() {self._sourceFile = nil} /// Identifies the starting offset in bytes in the generated code /// that relates to the identified object. var begin: Int32 { - get {return _begin ?? 0} + get {_begin ?? 0} set {_begin = newValue} } /// Returns true if `begin` has been explicitly set. - var hasBegin: Bool {return self._begin != nil} + var hasBegin: Bool {self._begin != nil} /// Clears the value of `begin`. Subsequent reads from it will return its default value. mutating func clearBegin() {self._begin = nil} /// Identifies the ending offset in bytes in the generated code that - /// relates to the identified offset. The end offset should be one past + /// relates to the identified object. The end offset should be one past /// the last relevant byte (so the length of the text = end - begin). var end: Int32 { - get {return _end ?? 0} + get {_end ?? 0} set {_end = newValue} } /// Returns true if `end` has been explicitly set. - var hasEnd: Bool {return self._end != nil} + var hasEnd: Bool {self._end != nil} /// Clears the value of `end`. Subsequent reads from it will return its default value. mutating func clearEnd() {self._end = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var semantic: Google_Protobuf_GeneratedCodeInfo.Annotation.Semantic { + get {_semantic ?? .none} + set {_semantic = newValue} + } + /// Returns true if `semantic` has been explicitly set. + var hasSemantic: Bool {self._semantic != nil} + /// Clears the value of `semantic`. Subsequent reads from it will return its default value. + mutating func clearSemantic() {self._semantic = nil} + + var unknownFields = UnknownStorage() + + /// Represents the identified object's effect on the element in the original + /// .proto file. + enum Semantic: Int, Enum, Swift.CaseIterable { + + /// There is no effect or the effect is indescribable. + case none = 0 + + /// The element is set or otherwise mutated. + case set = 1 + + /// An alias to the element is returned. + case alias = 2 + + init() { + self = .none + } + + } init() {} fileprivate var _sourceFile: String? = nil fileprivate var _begin: Int32? = nil fileprivate var _end: Int32? = nil + fileprivate var _semantic: Google_Protobuf_GeneratedCodeInfo.Annotation.Semantic? = nil } init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_FileDescriptorSet: @unchecked Sendable {} -extension Google_Protobuf_FileDescriptorProto: @unchecked Sendable {} -extension Google_Protobuf_DescriptorProto: @unchecked Sendable {} -extension Google_Protobuf_DescriptorProto.ExtensionRange: @unchecked Sendable {} -extension Google_Protobuf_DescriptorProto.ReservedRange: @unchecked Sendable {} -extension Google_Protobuf_ExtensionRangeOptions: @unchecked Sendable {} -extension Google_Protobuf_FieldDescriptorProto: @unchecked Sendable {} -extension Google_Protobuf_FieldDescriptorProto.TypeEnum: @unchecked Sendable {} -extension Google_Protobuf_FieldDescriptorProto.Label: @unchecked Sendable {} -extension Google_Protobuf_OneofDescriptorProto: @unchecked Sendable {} -extension Google_Protobuf_EnumDescriptorProto: @unchecked Sendable {} -extension Google_Protobuf_EnumDescriptorProto.EnumReservedRange: @unchecked Sendable {} -extension Google_Protobuf_EnumValueDescriptorProto: @unchecked Sendable {} -extension Google_Protobuf_ServiceDescriptorProto: @unchecked Sendable {} -extension Google_Protobuf_MethodDescriptorProto: @unchecked Sendable {} -extension Google_Protobuf_FileOptions: @unchecked Sendable {} -extension Google_Protobuf_FileOptions.OptimizeMode: @unchecked Sendable {} -extension Google_Protobuf_MessageOptions: @unchecked Sendable {} -extension Google_Protobuf_FieldOptions: @unchecked Sendable {} -extension Google_Protobuf_FieldOptions.CType: @unchecked Sendable {} -extension Google_Protobuf_FieldOptions.JSType: @unchecked Sendable {} -extension Google_Protobuf_OneofOptions: @unchecked Sendable {} -extension Google_Protobuf_EnumOptions: @unchecked Sendable {} -extension Google_Protobuf_EnumValueOptions: @unchecked Sendable {} -extension Google_Protobuf_ServiceOptions: @unchecked Sendable {} -extension Google_Protobuf_MethodOptions: @unchecked Sendable {} -extension Google_Protobuf_MethodOptions.IdempotencyLevel: @unchecked Sendable {} -extension Google_Protobuf_UninterpretedOption: @unchecked Sendable {} -extension Google_Protobuf_UninterpretedOption.NamePart: @unchecked Sendable {} -extension Google_Protobuf_SourceCodeInfo: @unchecked Sendable {} -extension Google_Protobuf_SourceCodeInfo.Location: @unchecked Sendable {} -extension Google_Protobuf_GeneratedCodeInfo: @unchecked Sendable {} -extension Google_Protobuf_GeneratedCodeInfo.Annotation: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_FileDescriptorSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Edition: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0EDITION_UNKNOWN\0\u{1}EDITION_1_TEST_ONLY\0\u{1}EDITION_2_TEST_ONLY\0\u{2}B\u{e}EDITION_LEGACY\0\u{2}b\u{1}EDITION_PROTO2\0\u{1}EDITION_PROTO3\0\u{1}EDITION_2023\0\u{1}EDITION_2024\0\u{2}fL\u{2}EDITION_UNSTABLE\0\u{2}N~\u{15}EDITION_99997_TEST_ONLY\0\u{1}EDITION_99998_TEST_ONLY\0\u{1}EDITION_99999_TEST_ONLY\0\u{2}`eg\u{7f}\u{7f}\u{1}EDITION_MAX\0") +} + +extension Google_Protobuf_SymbolVisibility: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0VISIBILITY_UNSET\0\u{1}VISIBILITY_LOCAL\0\u{1}VISIBILITY_EXPORT\0") +} + +extension Google_Protobuf_FileDescriptorSet: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".FileDescriptorSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "file"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}file\0") public var isInitialized: Bool { - if !SwiftProtobuf.Internal.areAllInitialized(self.file) {return false} + if !_protobuf_extensionFieldValues.isInitialized {return false} + if !Internal.areAllInitialized(self.file) {return false} return true } - mutating func decodeMessage(decoder: inout D) throws { + 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.decodeRepeatedMessageField(value: &self.file) }() + case 536000000: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_FileDescriptorSet.self, fieldNumber: fieldNumber) }() default: break } } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if !self.file.isEmpty { try visitor.visitRepeatedMessageField(value: self.file, fieldNumber: 1) } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 536000000, end: 536000001) try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Google_Protobuf_FileDescriptorSet, rhs: Google_Protobuf_FileDescriptorSet) -> Bool { if lhs.file != rhs.file {return false} if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_FileDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".FileDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "package"), - 3: .same(proto: "dependency"), - 10: .standard(proto: "public_dependency"), - 11: .standard(proto: "weak_dependency"), - 4: .standard(proto: "message_type"), - 5: .standard(proto: "enum_type"), - 6: .same(proto: "service"), - 7: .same(proto: "extension"), - 8: .same(proto: "options"), - 9: .standard(proto: "source_code_info"), - 12: .same(proto: "syntax"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}package\0\u{1}dependency\0\u{3}message_type\0\u{3}enum_type\0\u{1}service\0\u{1}extension\0\u{1}options\0\u{3}source_code_info\0\u{3}public_dependency\0\u{3}weak_dependency\0\u{1}syntax\0\u{2}\u{2}edition\0\u{3}option_dependency\0") public var isInitialized: Bool { - if !SwiftProtobuf.Internal.areAllInitialized(self.messageType) {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.enumType) {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.service) {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.`extension`) {return false} + if !Internal.areAllInitialized(self.messageType) {return false} + if !Internal.areAllInitialized(self.enumType) {return false} + if !Internal.areAllInitialized(self.service) {return false} + if !Internal.areAllInitialized(self.`extension`) {return false} if let v = self._options, !v.isInitialized {return false} + if let v = self._sourceCodeInfo, !v.isInitialized {return false} return true } - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -2146,12 +2890,14 @@ extension Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Message, SwiftProto case 10: try { try decoder.decodeRepeatedInt32Field(value: &self.publicDependency) }() case 11: try { try decoder.decodeRepeatedInt32Field(value: &self.weakDependency) }() case 12: try { try decoder.decodeSingularStringField(value: &self._syntax) }() + case 14: try { try decoder.decodeSingularEnumField(value: &self._edition) }() + case 15: try { try decoder.decodeRepeatedStringField(value: &self.optionDependency) }() default: break } } } - func traverse(visitor: inout V) throws { + 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 @@ -2192,6 +2938,12 @@ extension Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Message, SwiftProto try { if let v = self._syntax { try visitor.visitSingularStringField(value: v, fieldNumber: 12) } }() + try { if let v = self._edition { + try visitor.visitSingularEnumField(value: v, fieldNumber: 14) + } }() + if !self.optionDependency.isEmpty { + try visitor.visitRepeatedStringField(value: self.optionDependency, fieldNumber: 15) + } try unknownFields.traverse(visitor: &visitor) } @@ -2201,6 +2953,7 @@ extension Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Message, SwiftProto if lhs.dependency != rhs.dependency {return false} if lhs.publicDependency != rhs.publicDependency {return false} if lhs.weakDependency != rhs.weakDependency {return false} + if lhs.optionDependency != rhs.optionDependency {return false} if lhs.messageType != rhs.messageType {return false} if lhs.enumType != rhs.enumType {return false} if lhs.service != rhs.service {return false} @@ -2208,126 +2961,175 @@ extension Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Message, SwiftProto if lhs._options != rhs._options {return false} if lhs._sourceCodeInfo != rhs._sourceCodeInfo {return false} if lhs._syntax != rhs._syntax {return false} + if lhs._edition != rhs._edition {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_DescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_DescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".DescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "field"), - 6: .same(proto: "extension"), - 3: .standard(proto: "nested_type"), - 4: .standard(proto: "enum_type"), - 5: .standard(proto: "extension_range"), - 8: .standard(proto: "oneof_decl"), - 7: .same(proto: "options"), - 9: .standard(proto: "reserved_range"), - 10: .standard(proto: "reserved_name"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}field\0\u{3}nested_type\0\u{3}enum_type\0\u{3}extension_range\0\u{1}extension\0\u{1}options\0\u{3}oneof_decl\0\u{3}reserved_range\0\u{3}reserved_name\0\u{1}visibility\0") - public var isInitialized: Bool { - if !SwiftProtobuf.Internal.areAllInitialized(self.field) {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.`extension`) {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.nestedType) {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.enumType) {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.extensionRange) {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.oneofDecl) {return false} - if let v = self._options, !v.isInitialized {return false} - return true - } + fileprivate class _StorageClass { + var _name: String? = nil + var _field: [Google_Protobuf_FieldDescriptorProto] = [] + var _extension: [Google_Protobuf_FieldDescriptorProto] = [] + var _nestedType: [Google_Protobuf_DescriptorProto] = [] + var _enumType: [Google_Protobuf_EnumDescriptorProto] = [] + var _extensionRange: [Google_Protobuf_DescriptorProto.ExtensionRange] = [] + var _oneofDecl: [Google_Protobuf_OneofDescriptorProto] = [] + var _options: Google_Protobuf_MessageOptions? = nil + var _reservedRange: [Google_Protobuf_DescriptorProto.ReservedRange] = [] + var _reservedName: [String] = [] + var _visibility: Google_Protobuf_SymbolVisibility? = nil + + // 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() - 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._name) }() - case 2: try { try decoder.decodeRepeatedMessageField(value: &self.field) }() - case 3: try { try decoder.decodeRepeatedMessageField(value: &self.nestedType) }() - case 4: try { try decoder.decodeRepeatedMessageField(value: &self.enumType) }() - case 5: try { try decoder.decodeRepeatedMessageField(value: &self.extensionRange) }() - case 6: try { try decoder.decodeRepeatedMessageField(value: &self.`extension`) }() - case 7: try { try decoder.decodeSingularMessageField(value: &self._options) }() - case 8: try { try decoder.decodeRepeatedMessageField(value: &self.oneofDecl) }() - case 9: try { try decoder.decodeRepeatedMessageField(value: &self.reservedRange) }() - case 10: try { try decoder.decodeRepeatedStringField(value: &self.reservedName) }() - default: break - } + private init() {} + + init(copying source: _StorageClass) { + _name = source._name + _field = source._field + _extension = source._extension + _nestedType = source._nestedType + _enumType = source._enumType + _extensionRange = source._extensionRange + _oneofDecl = source._oneofDecl + _options = source._options + _reservedRange = source._reservedRange + _reservedName = source._reservedName + _visibility = source._visibility } } - 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 - try { if let v = self._name { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - if !self.field.isEmpty { - try visitor.visitRepeatedMessageField(value: self.field, fieldNumber: 2) - } - if !self.nestedType.isEmpty { - try visitor.visitRepeatedMessageField(value: self.nestedType, fieldNumber: 3) - } - if !self.enumType.isEmpty { - try visitor.visitRepeatedMessageField(value: self.enumType, fieldNumber: 4) - } - if !self.extensionRange.isEmpty { - try visitor.visitRepeatedMessageField(value: self.extensionRange, fieldNumber: 5) - } - if !self.`extension`.isEmpty { - try visitor.visitRepeatedMessageField(value: self.`extension`, fieldNumber: 6) + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) } - try { if let v = self._options { - try visitor.visitSingularMessageField(value: v, fieldNumber: 7) - } }() - if !self.oneofDecl.isEmpty { - try visitor.visitRepeatedMessageField(value: self.oneofDecl, fieldNumber: 8) + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if !Internal.areAllInitialized(_storage._field) {return false} + if !Internal.areAllInitialized(_storage._extension) {return false} + if !Internal.areAllInitialized(_storage._nestedType) {return false} + if !Internal.areAllInitialized(_storage._enumType) {return false} + if !Internal.areAllInitialized(_storage._extensionRange) {return false} + if !Internal.areAllInitialized(_storage._oneofDecl) {return false} + if let v = _storage._options, !v.isInitialized {return false} + return true } - if !self.reservedRange.isEmpty { - try visitor.visitRepeatedMessageField(value: self.reservedRange, fieldNumber: 9) + } + + mutating func decodeMessage(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._name) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &_storage._field) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &_storage._nestedType) }() + case 4: try { try decoder.decodeRepeatedMessageField(value: &_storage._enumType) }() + case 5: try { try decoder.decodeRepeatedMessageField(value: &_storage._extensionRange) }() + case 6: try { try decoder.decodeRepeatedMessageField(value: &_storage._extension) }() + case 7: try { try decoder.decodeSingularMessageField(value: &_storage._options) }() + case 8: try { try decoder.decodeRepeatedMessageField(value: &_storage._oneofDecl) }() + case 9: try { try decoder.decodeRepeatedMessageField(value: &_storage._reservedRange) }() + case 10: try { try decoder.decodeRepeatedStringField(value: &_storage._reservedName) }() + case 11: try { try decoder.decodeSingularEnumField(value: &_storage._visibility) }() + default: break + } + } } - if !self.reservedName.isEmpty { - try visitor.visitRepeatedStringField(value: self.reservedName, fieldNumber: 10) + } + + func traverse(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._name { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + if !_storage._field.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._field, fieldNumber: 2) + } + if !_storage._nestedType.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._nestedType, fieldNumber: 3) + } + if !_storage._enumType.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._enumType, fieldNumber: 4) + } + if !_storage._extensionRange.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._extensionRange, fieldNumber: 5) + } + if !_storage._extension.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._extension, fieldNumber: 6) + } + try { if let v = _storage._options { + try visitor.visitSingularMessageField(value: v, fieldNumber: 7) + } }() + if !_storage._oneofDecl.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._oneofDecl, fieldNumber: 8) + } + if !_storage._reservedRange.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._reservedRange, fieldNumber: 9) + } + if !_storage._reservedName.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._reservedName, fieldNumber: 10) + } + try { if let v = _storage._visibility { + try visitor.visitSingularEnumField(value: v, fieldNumber: 11) + } }() } try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Google_Protobuf_DescriptorProto, rhs: Google_Protobuf_DescriptorProto) -> Bool { - if lhs._name != rhs._name {return false} - if lhs.field != rhs.field {return false} - if lhs.`extension` != rhs.`extension` {return false} - if lhs.nestedType != rhs.nestedType {return false} - if lhs.enumType != rhs.enumType {return false} - if lhs.extensionRange != rhs.extensionRange {return false} - if lhs.oneofDecl != rhs.oneofDecl {return false} - if lhs._options != rhs._options {return false} - if lhs.reservedRange != rhs.reservedRange {return false} - if lhs.reservedName != rhs.reservedName {return false} + 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._name != rhs_storage._name {return false} + if _storage._field != rhs_storage._field {return false} + if _storage._extension != rhs_storage._extension {return false} + if _storage._nestedType != rhs_storage._nestedType {return false} + if _storage._enumType != rhs_storage._enumType {return false} + if _storage._extensionRange != rhs_storage._extensionRange {return false} + if _storage._oneofDecl != rhs_storage._oneofDecl {return false} + if _storage._options != rhs_storage._options {return false} + if _storage._reservedRange != rhs_storage._reservedRange {return false} + if _storage._reservedName != rhs_storage._reservedName {return false} + if _storage._visibility != rhs_storage._visibility {return false} + return true + } + if !storagesAreEqual {return false} + } if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_DescriptorProto.ExtensionRange: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_DescriptorProto.ExtensionRange: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = Google_Protobuf_DescriptorProto.protoMessageName + ".ExtensionRange" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "start"), - 2: .same(proto: "end"), - 3: .same(proto: "options"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}start\0\u{1}end\0\u{1}options\0") public var isInitialized: Bool { if let v = self._options, !v.isInitialized {return false} return true } - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -2341,7 +3143,7 @@ extension Google_Protobuf_DescriptorProto.ExtensionRange: SwiftProtobuf.Message, } } - func traverse(visitor: inout V) throws { + 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 @@ -2367,14 +3169,11 @@ extension Google_Protobuf_DescriptorProto.ExtensionRange: SwiftProtobuf.Message, } } -extension Google_Protobuf_DescriptorProto.ReservedRange: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_DescriptorProto.ReservedRange: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = Google_Protobuf_DescriptorProto.protoMessageName + ".ReservedRange" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "start"), - 2: .same(proto: "end"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}start\0\u{1}end\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -2387,7 +3186,7 @@ extension Google_Protobuf_DescriptorProto.ReservedRange: SwiftProtobuf.Message, } } - func traverse(visitor: inout V) throws { + 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 @@ -2409,24 +3208,26 @@ extension Google_Protobuf_DescriptorProto.ReservedRange: SwiftProtobuf.Message, } } -extension Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_ExtensionRangeOptions: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ExtensionRangeOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 999: .standard(proto: "uninterpreted_option"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\u{2}declaration\0\u{1}verification\0\u{2}/features\0\u{4}u\u{e}uninterpreted_option\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.uninterpretedOption) {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} + if let v = self._features, !v.isInitialized {return false} return true } - mutating func decodeMessage(decoder: inout D) throws { + 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 2: try { try decoder.decodeRepeatedMessageField(value: &self.declaration) }() + case 3: try { try decoder.decodeSingularEnumField(value: &self._verification) }() + case 50: try { try decoder.decodeSingularMessageField(value: &self._features) }() case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() case 1000..<536870912: try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_ExtensionRangeOptions.self, fieldNumber: fieldNumber) }() @@ -2435,7 +3236,20 @@ extension Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.Message, SwiftPro } } - func traverse(visitor: inout V) throws { + 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 + if !self.declaration.isEmpty { + try visitor.visitRepeatedMessageField(value: self.declaration, fieldNumber: 2) + } + try { if let v = self._verification { + try visitor.visitSingularEnumField(value: v, fieldNumber: 3) + } }() + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 50) + } }() if !self.uninterpretedOption.isEmpty { try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) } @@ -2445,224 +3259,105 @@ extension Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.Message, SwiftPro static func ==(lhs: Google_Protobuf_ExtensionRangeOptions, rhs: Google_Protobuf_ExtensionRangeOptions) -> Bool { if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} + if lhs.declaration != rhs.declaration {return false} + if lhs._features != rhs._features {return false} + if lhs._verification != rhs._verification {return false} if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension Google_Protobuf_FieldDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".FieldDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 3: .same(proto: "number"), - 4: .same(proto: "label"), - 5: .same(proto: "type"), - 6: .standard(proto: "type_name"), - 2: .same(proto: "extendee"), - 7: .standard(proto: "default_value"), - 9: .standard(proto: "oneof_index"), - 10: .standard(proto: "json_name"), - 8: .same(proto: "options"), - 17: .standard(proto: "proto3_optional"), - ] - - fileprivate class _StorageClass { - var _name: String? = nil - var _number: Int32? = nil - var _label: Google_Protobuf_FieldDescriptorProto.Label? = nil - var _type: Google_Protobuf_FieldDescriptorProto.TypeEnum? = nil - var _typeName: String? = nil - var _extendee: String? = nil - var _defaultValue: String? = nil - var _oneofIndex: Int32? = nil - var _jsonName: String? = nil - var _options: Google_Protobuf_FieldOptions? = nil - var _proto3Optional: Bool? = nil - - static let defaultInstance = _StorageClass() +extension Google_Protobuf_ExtensionRangeOptions.VerificationState: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0DECLARATION\0\u{1}UNVERIFIED\0") +} - private init() {} +extension Google_Protobuf_ExtensionRangeOptions.Declaration: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = Google_Protobuf_ExtensionRangeOptions.protoMessageName + ".Declaration" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}number\0\u{3}full_name\0\u{1}type\0\u{2}\u{2}reserved\0\u{1}repeated\0\u{c}\u{4}\u{1}") - init(copying source: _StorageClass) { - _name = source._name - _number = source._number - _label = source._label - _type = source._type - _typeName = source._typeName - _extendee = source._extendee - _defaultValue = source._defaultValue - _oneofIndex = source._oneofIndex - _jsonName = source._jsonName - _options = source._options - _proto3Optional = source._proto3Optional + 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._number) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._fullName) }() + case 3: try { try decoder.decodeSingularStringField(value: &self._type) }() + case 5: try { try decoder.decodeSingularBoolField(value: &self._reserved) }() + case 6: try { try decoder.decodeSingularBoolField(value: &self._repeated) }() + default: break + } } } - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage + 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 + try { if let v = self._number { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._fullName { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._type { + try visitor.visitSingularStringField(value: v, fieldNumber: 3) + } }() + try { if let v = self._reserved { + try visitor.visitSingularBoolField(value: v, fieldNumber: 5) + } }() + try { if let v = self._repeated { + try visitor.visitSingularBoolField(value: v, fieldNumber: 6) + } }() + try unknownFields.traverse(visitor: &visitor) } - public var isInitialized: Bool { - return withExtendedLifetime(_storage) { (_storage: _StorageClass) in - if let v = _storage._options, !v.isInitialized {return false} - return true - } - } - - mutating func decodeMessage(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._name) }() - case 2: try { try decoder.decodeSingularStringField(value: &_storage._extendee) }() - case 3: try { try decoder.decodeSingularInt32Field(value: &_storage._number) }() - case 4: try { try decoder.decodeSingularEnumField(value: &_storage._label) }() - case 5: try { try decoder.decodeSingularEnumField(value: &_storage._type) }() - case 6: try { try decoder.decodeSingularStringField(value: &_storage._typeName) }() - case 7: try { try decoder.decodeSingularStringField(value: &_storage._defaultValue) }() - case 8: try { try decoder.decodeSingularMessageField(value: &_storage._options) }() - case 9: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofIndex) }() - case 10: try { try decoder.decodeSingularStringField(value: &_storage._jsonName) }() - case 17: try { try decoder.decodeSingularBoolField(value: &_storage._proto3Optional) }() - default: break - } - } - } - } - - func traverse(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._name { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._extendee { - try visitor.visitSingularStringField(value: v, fieldNumber: 2) - } }() - try { if let v = _storage._number { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) - } }() - try { if let v = _storage._label { - try visitor.visitSingularEnumField(value: v, fieldNumber: 4) - } }() - try { if let v = _storage._type { - try visitor.visitSingularEnumField(value: v, fieldNumber: 5) - } }() - try { if let v = _storage._typeName { - try visitor.visitSingularStringField(value: v, fieldNumber: 6) - } }() - try { if let v = _storage._defaultValue { - try visitor.visitSingularStringField(value: v, fieldNumber: 7) - } }() - try { if let v = _storage._options { - try visitor.visitSingularMessageField(value: v, fieldNumber: 8) - } }() - try { if let v = _storage._oneofIndex { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) - } }() - try { if let v = _storage._jsonName { - try visitor.visitSingularStringField(value: v, fieldNumber: 10) - } }() - try { if let v = _storage._proto3Optional { - try visitor.visitSingularBoolField(value: v, fieldNumber: 17) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: Google_Protobuf_FieldDescriptorProto, rhs: Google_Protobuf_FieldDescriptorProto) -> 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._name != rhs_storage._name {return false} - if _storage._number != rhs_storage._number {return false} - if _storage._label != rhs_storage._label {return false} - if _storage._type != rhs_storage._type {return false} - if _storage._typeName != rhs_storage._typeName {return false} - if _storage._extendee != rhs_storage._extendee {return false} - if _storage._defaultValue != rhs_storage._defaultValue {return false} - if _storage._oneofIndex != rhs_storage._oneofIndex {return false} - if _storage._jsonName != rhs_storage._jsonName {return false} - if _storage._options != rhs_storage._options {return false} - if _storage._proto3Optional != rhs_storage._proto3Optional {return false} - return true - } - if !storagesAreEqual {return false} - } + static func ==(lhs: Google_Protobuf_ExtensionRangeOptions.Declaration, rhs: Google_Protobuf_ExtensionRangeOptions.Declaration) -> Bool { + if lhs._number != rhs._number {return false} + if lhs._fullName != rhs._fullName {return false} + if lhs._type != rhs._type {return false} + if lhs._reserved != rhs._reserved {return false} + if lhs._repeated != rhs._repeated {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_FieldDescriptorProto.TypeEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TYPE_DOUBLE"), - 2: .same(proto: "TYPE_FLOAT"), - 3: .same(proto: "TYPE_INT64"), - 4: .same(proto: "TYPE_UINT64"), - 5: .same(proto: "TYPE_INT32"), - 6: .same(proto: "TYPE_FIXED64"), - 7: .same(proto: "TYPE_FIXED32"), - 8: .same(proto: "TYPE_BOOL"), - 9: .same(proto: "TYPE_STRING"), - 10: .same(proto: "TYPE_GROUP"), - 11: .same(proto: "TYPE_MESSAGE"), - 12: .same(proto: "TYPE_BYTES"), - 13: .same(proto: "TYPE_UINT32"), - 14: .same(proto: "TYPE_ENUM"), - 15: .same(proto: "TYPE_SFIXED32"), - 16: .same(proto: "TYPE_SFIXED64"), - 17: .same(proto: "TYPE_SINT32"), - 18: .same(proto: "TYPE_SINT64"), - ] -} - -extension Google_Protobuf_FieldDescriptorProto.Label: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "LABEL_OPTIONAL"), - 2: .same(proto: "LABEL_REQUIRED"), - 3: .same(proto: "LABEL_REPEATED"), - ] -} - -extension Google_Protobuf_OneofDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".OneofDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "options"), - ] +extension Google_Protobuf_FieldDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FieldDescriptorProto" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}extendee\0\u{1}number\0\u{1}label\0\u{1}type\0\u{3}type_name\0\u{3}default_value\0\u{1}options\0\u{3}oneof_index\0\u{3}json_name\0\u{4}\u{7}proto3_optional\0") public var isInitialized: Bool { if let v = self._options, !v.isInitialized {return false} return true } - mutating func decodeMessage(decoder: inout D) throws { + 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._name) }() - case 2: try { try decoder.decodeSingularMessageField(value: &self._options) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._extendee) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._number) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._label) }() + case 5: try { try decoder.decodeSingularEnumField(value: &self._type) }() + case 6: try { try decoder.decodeSingularStringField(value: &self._typeName) }() + case 7: try { try decoder.decodeSingularStringField(value: &self._defaultValue) }() + case 8: try { try decoder.decodeSingularMessageField(value: &self._options) }() + case 9: try { try decoder.decodeSingularInt32Field(value: &self._oneofIndex) }() + case 10: try { try decoder.decodeSingularStringField(value: &self._jsonName) }() + case 17: try { try decoder.decodeSingularBoolField(value: &self._proto3Optional) }() default: break } } } - func traverse(visitor: inout V) throws { + 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 @@ -2670,53 +3365,87 @@ extension Google_Protobuf_OneofDescriptorProto: SwiftProtobuf.Message, SwiftProt try { if let v = self._name { try visitor.visitSingularStringField(value: v, fieldNumber: 1) } }() + try { if let v = self._extendee { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._number { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._label { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + try { if let v = self._type { + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + } }() + try { if let v = self._typeName { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) + } }() + try { if let v = self._defaultValue { + try visitor.visitSingularStringField(value: v, fieldNumber: 7) + } }() try { if let v = self._options { - try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + try visitor.visitSingularMessageField(value: v, fieldNumber: 8) + } }() + try { if let v = self._oneofIndex { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try { if let v = self._jsonName { + try visitor.visitSingularStringField(value: v, fieldNumber: 10) + } }() + try { if let v = self._proto3Optional { + try visitor.visitSingularBoolField(value: v, fieldNumber: 17) } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Google_Protobuf_OneofDescriptorProto, rhs: Google_Protobuf_OneofDescriptorProto) -> Bool { + static func ==(lhs: Google_Protobuf_FieldDescriptorProto, rhs: Google_Protobuf_FieldDescriptorProto) -> Bool { if lhs._name != rhs._name {return false} + if lhs._number != rhs._number {return false} + if lhs._label != rhs._label {return false} + if lhs._type != rhs._type {return false} + if lhs._typeName != rhs._typeName {return false} + if lhs._extendee != rhs._extendee {return false} + if lhs._defaultValue != rhs._defaultValue {return false} + if lhs._oneofIndex != rhs._oneofIndex {return false} + if lhs._jsonName != rhs._jsonName {return false} if lhs._options != rhs._options {return false} + if lhs._proto3Optional != rhs._proto3Optional {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_EnumDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".EnumDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "value"), - 3: .same(proto: "options"), - 4: .standard(proto: "reserved_range"), - 5: .standard(proto: "reserved_name"), - ] +extension Google_Protobuf_FieldDescriptorProto.TypeEnum: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}TYPE_DOUBLE\0\u{1}TYPE_FLOAT\0\u{1}TYPE_INT64\0\u{1}TYPE_UINT64\0\u{1}TYPE_INT32\0\u{1}TYPE_FIXED64\0\u{1}TYPE_FIXED32\0\u{1}TYPE_BOOL\0\u{1}TYPE_STRING\0\u{1}TYPE_GROUP\0\u{1}TYPE_MESSAGE\0\u{1}TYPE_BYTES\0\u{1}TYPE_UINT32\0\u{1}TYPE_ENUM\0\u{1}TYPE_SFIXED32\0\u{1}TYPE_SFIXED64\0\u{1}TYPE_SINT32\0\u{1}TYPE_SINT64\0") +} + +extension Google_Protobuf_FieldDescriptorProto.Label: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}LABEL_OPTIONAL\0\u{1}LABEL_REQUIRED\0\u{1}LABEL_REPEATED\0") +} + +extension Google_Protobuf_OneofDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OneofDescriptorProto" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}options\0") public var isInitialized: Bool { - if !SwiftProtobuf.Internal.areAllInitialized(self.value) {return false} if let v = self._options, !v.isInitialized {return false} return true } - mutating func decodeMessage(decoder: inout D) throws { + 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._name) }() - case 2: try { try decoder.decodeRepeatedMessageField(value: &self.value) }() - case 3: try { try decoder.decodeSingularMessageField(value: &self._options) }() - case 4: try { try decoder.decodeRepeatedMessageField(value: &self.reservedRange) }() - case 5: try { try decoder.decodeRepeatedStringField(value: &self.reservedName) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._options) }() default: break } } } - func traverse(visitor: inout V) throws { + 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 @@ -2724,40 +3453,138 @@ extension Google_Protobuf_EnumDescriptorProto: SwiftProtobuf.Message, SwiftProto try { if let v = self._name { try visitor.visitSingularStringField(value: v, fieldNumber: 1) } }() - if !self.value.isEmpty { - try visitor.visitRepeatedMessageField(value: self.value, fieldNumber: 2) - } try { if let v = self._options { - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) } }() - if !self.reservedRange.isEmpty { - try visitor.visitRepeatedMessageField(value: self.reservedRange, fieldNumber: 4) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_OneofDescriptorProto, rhs: Google_Protobuf_OneofDescriptorProto) -> Bool { + if lhs._name != rhs._name {return false} + if lhs._options != rhs._options {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_EnumDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumDescriptorProto" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}value\0\u{1}options\0\u{3}reserved_range\0\u{3}reserved_name\0\u{1}visibility\0") + + fileprivate class _StorageClass { + var _name: String? = nil + var _value: [Google_Protobuf_EnumValueDescriptorProto] = [] + var _options: Google_Protobuf_EnumOptions? = nil + var _reservedRange: [Google_Protobuf_EnumDescriptorProto.EnumReservedRange] = [] + var _reservedName: [String] = [] + var _visibility: Google_Protobuf_SymbolVisibility? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _name = source._name + _value = source._value + _options = source._options + _reservedRange = source._reservedRange + _reservedName = source._reservedName + _visibility = source._visibility + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) } - if !self.reservedName.isEmpty { - try visitor.visitRepeatedStringField(value: self.reservedName, fieldNumber: 5) + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if !Internal.areAllInitialized(_storage._value) {return false} + if let v = _storage._options, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._name) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &_storage._value) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._options) }() + case 4: try { try decoder.decodeRepeatedMessageField(value: &_storage._reservedRange) }() + case 5: try { try decoder.decodeRepeatedStringField(value: &_storage._reservedName) }() + case 6: try { try decoder.decodeSingularEnumField(value: &_storage._visibility) }() + default: break + } + } + } + } + + func traverse(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._name { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + if !_storage._value.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._value, fieldNumber: 2) + } + try { if let v = _storage._options { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + if !_storage._reservedRange.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._reservedRange, fieldNumber: 4) + } + if !_storage._reservedName.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._reservedName, fieldNumber: 5) + } + try { if let v = _storage._visibility { + try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + } }() } try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Google_Protobuf_EnumDescriptorProto, rhs: Google_Protobuf_EnumDescriptorProto) -> Bool { - if lhs._name != rhs._name {return false} - if lhs.value != rhs.value {return false} - if lhs._options != rhs._options {return false} - if lhs.reservedRange != rhs.reservedRange {return false} - if lhs.reservedName != rhs.reservedName {return false} + 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._name != rhs_storage._name {return false} + if _storage._value != rhs_storage._value {return false} + if _storage._options != rhs_storage._options {return false} + if _storage._reservedRange != rhs_storage._reservedRange {return false} + if _storage._reservedName != rhs_storage._reservedName {return false} + if _storage._visibility != rhs_storage._visibility {return false} + return true + } + if !storagesAreEqual {return false} + } if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_EnumDescriptorProto.EnumReservedRange: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_EnumDescriptorProto.EnumReservedRange: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = Google_Protobuf_EnumDescriptorProto.protoMessageName + ".EnumReservedRange" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "start"), - 2: .same(proto: "end"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}start\0\u{1}end\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -2770,7 +3597,7 @@ extension Google_Protobuf_EnumDescriptorProto.EnumReservedRange: SwiftProtobuf.M } } - func traverse(visitor: inout V) throws { + 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 @@ -2792,74 +3619,108 @@ extension Google_Protobuf_EnumDescriptorProto.EnumReservedRange: SwiftProtobuf.M } } -extension Google_Protobuf_EnumValueDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_EnumValueDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".EnumValueDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "number"), - 3: .same(proto: "options"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}number\0\u{1}options\0") + + fileprivate class _StorageClass { + var _name: String? = nil + var _number: Int32? = nil + var _options: Google_Protobuf_EnumValueOptions? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _name = source._name + _number = source._number + _options = source._options + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } public var isInitialized: Bool { - if let v = self._options, !v.isInitialized {return false} - return true + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._options, !v.isInitialized {return false} + return true + } } - 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._name) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &self._number) }() - case 3: try { try decoder.decodeSingularMessageField(value: &self._options) }() - default: break + mutating func decodeMessage(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._name) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._number) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._options) }() + 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 - try { if let v = self._name { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try { if let v = self._number { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try { if let v = self._options { - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - } }() + func traverse(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._name { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._number { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._options { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + } try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Google_Protobuf_EnumValueDescriptorProto, rhs: Google_Protobuf_EnumValueDescriptorProto) -> Bool { - if lhs._name != rhs._name {return false} - if lhs._number != rhs._number {return false} - if lhs._options != rhs._options {return false} + 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._name != rhs_storage._name {return false} + if _storage._number != rhs_storage._number {return false} + if _storage._options != rhs_storage._options {return false} + return true + } + if !storagesAreEqual {return false} + } if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_ServiceDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ServiceDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "method"), - 3: .same(proto: "options"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}method\0\u{1}options\0\u{b}stream\0\u{c}\u{4}\u{1}") public var isInitialized: Bool { - if !SwiftProtobuf.Internal.areAllInitialized(self.method) {return false} + if !Internal.areAllInitialized(self.method) {return false} if let v = self._options, !v.isInitialized {return false} return true } - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -2873,7 +3734,7 @@ extension Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf.Message, SwiftPr } } - func traverse(visitor: inout V) throws { + 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 @@ -2899,23 +3760,16 @@ extension Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf.Message, SwiftPr } } -extension Google_Protobuf_MethodDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_MethodDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MethodDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .standard(proto: "input_type"), - 3: .standard(proto: "output_type"), - 4: .same(proto: "options"), - 5: .standard(proto: "client_streaming"), - 6: .standard(proto: "server_streaming"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{3}input_type\0\u{3}output_type\0\u{1}options\0\u{3}client_streaming\0\u{3}server_streaming\0") public var isInitialized: Bool { if let v = self._options, !v.isInitialized {return false} return true } - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -2932,7 +3786,7 @@ extension Google_Protobuf_MethodDescriptorProto: SwiftProtobuf.Message, SwiftPro } } - func traverse(visitor: inout V) throws { + 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 @@ -2970,31 +3824,9 @@ extension Google_Protobuf_MethodDescriptorProto: SwiftProtobuf.Message, SwiftPro } } -extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_FileOptions: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".FileOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "java_package"), - 8: .standard(proto: "java_outer_classname"), - 10: .standard(proto: "java_multiple_files"), - 20: .standard(proto: "java_generate_equals_and_hash"), - 27: .standard(proto: "java_string_check_utf8"), - 9: .standard(proto: "optimize_for"), - 11: .standard(proto: "go_package"), - 16: .standard(proto: "cc_generic_services"), - 17: .standard(proto: "java_generic_services"), - 18: .standard(proto: "py_generic_services"), - 42: .standard(proto: "php_generic_services"), - 23: .same(proto: "deprecated"), - 31: .standard(proto: "cc_enable_arenas"), - 36: .standard(proto: "objc_class_prefix"), - 37: .standard(proto: "csharp_namespace"), - 39: .standard(proto: "swift_prefix"), - 40: .standard(proto: "php_class_prefix"), - 41: .standard(proto: "php_namespace"), - 44: .standard(proto: "php_metadata_namespace"), - 45: .standard(proto: "ruby_package"), - 999: .standard(proto: "uninterpreted_option"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}java_package\0\u{4}\u{7}java_outer_classname\0\u{3}optimize_for\0\u{3}java_multiple_files\0\u{3}go_package\0\u{4}\u{5}cc_generic_services\0\u{3}java_generic_services\0\u{3}py_generic_services\0\u{4}\u{2}java_generate_equals_and_hash\0\u{2}\u{3}deprecated\0\u{4}\u{4}java_string_check_utf8\0\u{4}\u{4}cc_enable_arenas\0\u{4}\u{5}objc_class_prefix\0\u{3}csharp_namespace\0\u{4}\u{2}swift_prefix\0\u{3}php_class_prefix\0\u{3}php_namespace\0\u{4}\u{3}php_metadata_namespace\0\u{3}ruby_package\0\u{2}\u{5}features\0\u{4}u\u{e}uninterpreted_option\0\u{b}php_generic_services\0\u{c}*\u{1}\u{c}&\u{1}") fileprivate class _StorageClass { var _javaPackage: String? = nil @@ -3007,7 +3839,6 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes var _ccGenericServices: Bool? = nil var _javaGenericServices: Bool? = nil var _pyGenericServices: Bool? = nil - var _phpGenericServices: Bool? = nil var _deprecated: Bool? = nil var _ccEnableArenas: Bool? = nil var _objcClassPrefix: String? = nil @@ -3017,9 +3848,14 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes var _phpNamespace: String? = nil var _phpMetadataNamespace: String? = nil var _rubyPackage: String? = nil + var _features: Google_Protobuf_FeatureSet? = nil var _uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -3034,7 +3870,6 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes _ccGenericServices = source._ccGenericServices _javaGenericServices = source._javaGenericServices _pyGenericServices = source._pyGenericServices - _phpGenericServices = source._phpGenericServices _deprecated = source._deprecated _ccEnableArenas = source._ccEnableArenas _objcClassPrefix = source._objcClassPrefix @@ -3044,6 +3879,7 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes _phpNamespace = source._phpNamespace _phpMetadataNamespace = source._phpMetadataNamespace _rubyPackage = source._rubyPackage + _features = source._features _uninterpretedOption = source._uninterpretedOption } } @@ -3058,12 +3894,13 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} return withExtendedLifetime(_storage) { (_storage: _StorageClass) in - if !SwiftProtobuf.Internal.areAllInitialized(_storage._uninterpretedOption) {return false} + if let v = _storage._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(_storage._uninterpretedOption) {return false} return true } } - mutating func decodeMessage(decoder: inout D) throws { + mutating func decodeMessage(decoder: inout D) throws { _ = _uniqueStorage() try withExtendedLifetime(_storage) { (_storage: _StorageClass) in while let fieldNumber = try decoder.nextFieldNumber() { @@ -3088,9 +3925,9 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes case 39: try { try decoder.decodeSingularStringField(value: &_storage._swiftPrefix) }() case 40: try { try decoder.decodeSingularStringField(value: &_storage._phpClassPrefix) }() case 41: try { try decoder.decodeSingularStringField(value: &_storage._phpNamespace) }() - case 42: try { try decoder.decodeSingularBoolField(value: &_storage._phpGenericServices) }() case 44: try { try decoder.decodeSingularStringField(value: &_storage._phpMetadataNamespace) }() case 45: try { try decoder.decodeSingularStringField(value: &_storage._rubyPackage) }() + case 50: try { try decoder.decodeSingularMessageField(value: &_storage._features) }() case 999: try { try decoder.decodeRepeatedMessageField(value: &_storage._uninterpretedOption) }() case 1000..<536870912: try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_FileOptions.self, fieldNumber: fieldNumber) }() @@ -3100,7 +3937,7 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes } } - func traverse(visitor: inout V) throws { + func traverse(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 @@ -3157,15 +3994,15 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes try { if let v = _storage._phpNamespace { try visitor.visitSingularStringField(value: v, fieldNumber: 41) } }() - try { if let v = _storage._phpGenericServices { - try visitor.visitSingularBoolField(value: v, fieldNumber: 42) - } }() try { if let v = _storage._phpMetadataNamespace { try visitor.visitSingularStringField(value: v, fieldNumber: 44) } }() try { if let v = _storage._rubyPackage { try visitor.visitSingularStringField(value: v, fieldNumber: 45) } }() + try { if let v = _storage._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 50) + } }() if !_storage._uninterpretedOption.isEmpty { try visitor.visitRepeatedMessageField(value: _storage._uninterpretedOption, fieldNumber: 999) } @@ -3189,7 +4026,6 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes if _storage._ccGenericServices != rhs_storage._ccGenericServices {return false} if _storage._javaGenericServices != rhs_storage._javaGenericServices {return false} if _storage._pyGenericServices != rhs_storage._pyGenericServices {return false} - if _storage._phpGenericServices != rhs_storage._phpGenericServices {return false} if _storage._deprecated != rhs_storage._deprecated {return false} if _storage._ccEnableArenas != rhs_storage._ccEnableArenas {return false} if _storage._objcClassPrefix != rhs_storage._objcClassPrefix {return false} @@ -3199,6 +4035,260 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes if _storage._phpNamespace != rhs_storage._phpNamespace {return false} if _storage._phpMetadataNamespace != rhs_storage._phpMetadataNamespace {return false} if _storage._rubyPackage != rhs_storage._rubyPackage {return false} + if _storage._features != rhs_storage._features {return false} + if _storage._uninterpretedOption != rhs_storage._uninterpretedOption {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Google_Protobuf_FileOptions.OptimizeMode: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}SPEED\0\u{1}CODE_SIZE\0\u{1}LITE_RUNTIME\0") +} + +extension Google_Protobuf_MessageOptions: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MessageOptions" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}message_set_wire_format\0\u{3}no_standard_descriptor_accessor\0\u{1}deprecated\0\u{4}\u{4}map_entry\0\u{4}\u{4}deprecated_legacy_json_field_conflicts\0\u{1}features\0\u{4}[\u{f}uninterpreted_option\0\u{c}\u{4}\u{1}\u{c}\u{5}\u{1}\u{c}\u{6}\u{1}\u{c}\u{8}\u{1}\u{c}\u{9}\u{1}") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + if let v = self._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} + return true + } + + 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.decodeSingularBoolField(value: &self._messageSetWireFormat) }() + case 2: try { try decoder.decodeSingularBoolField(value: &self._noStandardDescriptorAccessor) }() + case 3: try { try decoder.decodeSingularBoolField(value: &self._deprecated) }() + case 7: try { try decoder.decodeSingularBoolField(value: &self._mapEntry) }() + case 11: try { try decoder.decodeSingularBoolField(value: &self._deprecatedLegacyJsonFieldConflicts) }() + case 12: try { try decoder.decodeSingularMessageField(value: &self._features) }() + case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_MessageOptions.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._messageSetWireFormat { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1) + } }() + try { if let v = self._noStandardDescriptorAccessor { + try visitor.visitSingularBoolField(value: v, fieldNumber: 2) + } }() + try { if let v = self._deprecated { + try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + } }() + try { if let v = self._mapEntry { + try visitor.visitSingularBoolField(value: v, fieldNumber: 7) + } }() + try { if let v = self._deprecatedLegacyJsonFieldConflicts { + try visitor.visitSingularBoolField(value: v, fieldNumber: 11) + } }() + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 12) + } }() + if !self.uninterpretedOption.isEmpty { + try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_MessageOptions, rhs: Google_Protobuf_MessageOptions) -> Bool { + if lhs._messageSetWireFormat != rhs._messageSetWireFormat {return false} + if lhs._noStandardDescriptorAccessor != rhs._noStandardDescriptorAccessor {return false} + if lhs._deprecated != rhs._deprecated {return false} + if lhs._mapEntry != rhs._mapEntry {return false} + if lhs._deprecatedLegacyJsonFieldConflicts != rhs._deprecatedLegacyJsonFieldConflicts {return false} + if lhs._features != rhs._features {return false} + if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Google_Protobuf_FieldOptions: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FieldOptions" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}ctype\0\u{1}packed\0\u{1}deprecated\0\u{2}\u{2}lazy\0\u{1}jstype\0\u{2}\u{4}weak\0\u{4}\u{5}unverified_lazy\0\u{3}debug_redact\0\u{1}retention\0\u{2}\u{2}targets\0\u{3}edition_defaults\0\u{1}features\0\u{3}feature_support\0\u{4}Q\u{f}uninterpreted_option\0\u{c}\u{4}\u{1}\u{c}\u{12}\u{1}") + + fileprivate class _StorageClass { + var _ctype: Google_Protobuf_FieldOptions.CType? = nil + var _packed: Bool? = nil + var _jstype: Google_Protobuf_FieldOptions.JSType? = nil + var _lazy: Bool? = nil + var _unverifiedLazy: Bool? = nil + var _deprecated: Bool? = nil + var _weak: Bool? = nil + var _debugRedact: Bool? = nil + var _retention: Google_Protobuf_FieldOptions.OptionRetention? = nil + var _targets: [Google_Protobuf_FieldOptions.OptionTargetType] = [] + var _editionDefaults: [Google_Protobuf_FieldOptions.EditionDefault] = [] + var _features: Google_Protobuf_FeatureSet? = nil + var _featureSupport: Google_Protobuf_FieldOptions.FeatureSupport? = nil + var _uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _ctype = source._ctype + _packed = source._packed + _jstype = source._jstype + _lazy = source._lazy + _unverifiedLazy = source._unverifiedLazy + _deprecated = source._deprecated + _weak = source._weak + _debugRedact = source._debugRedact + _retention = source._retention + _targets = source._targets + _editionDefaults = source._editionDefaults + _features = source._features + _featureSupport = source._featureSupport + _uninterpretedOption = source._uninterpretedOption + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(_storage._uninterpretedOption) {return false} + return true + } + } + + mutating func decodeMessage(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.decodeSingularEnumField(value: &_storage._ctype) }() + case 2: try { try decoder.decodeSingularBoolField(value: &_storage._packed) }() + case 3: try { try decoder.decodeSingularBoolField(value: &_storage._deprecated) }() + case 5: try { try decoder.decodeSingularBoolField(value: &_storage._lazy) }() + case 6: try { try decoder.decodeSingularEnumField(value: &_storage._jstype) }() + case 10: try { try decoder.decodeSingularBoolField(value: &_storage._weak) }() + case 15: try { try decoder.decodeSingularBoolField(value: &_storage._unverifiedLazy) }() + case 16: try { try decoder.decodeSingularBoolField(value: &_storage._debugRedact) }() + case 17: try { try decoder.decodeSingularEnumField(value: &_storage._retention) }() + case 19: try { try decoder.decodeRepeatedEnumField(value: &_storage._targets) }() + case 20: try { try decoder.decodeRepeatedMessageField(value: &_storage._editionDefaults) }() + case 21: try { try decoder.decodeSingularMessageField(value: &_storage._features) }() + case 22: try { try decoder.decodeSingularMessageField(value: &_storage._featureSupport) }() + case 999: try { try decoder.decodeRepeatedMessageField(value: &_storage._uninterpretedOption) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_FieldOptions.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._ctype { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._packed { + try visitor.visitSingularBoolField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._deprecated { + try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._lazy { + try visitor.visitSingularBoolField(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._jstype { + try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._weak { + try visitor.visitSingularBoolField(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._unverifiedLazy { + try visitor.visitSingularBoolField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._debugRedact { + try visitor.visitSingularBoolField(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._retention { + try visitor.visitSingularEnumField(value: v, fieldNumber: 17) + } }() + if !_storage._targets.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._targets, fieldNumber: 19) + } + if !_storage._editionDefaults.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._editionDefaults, fieldNumber: 20) + } + try { if let v = _storage._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._featureSupport { + try visitor.visitSingularMessageField(value: v, fieldNumber: 22) + } }() + if !_storage._uninterpretedOption.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._uninterpretedOption, fieldNumber: 999) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_FieldOptions, rhs: Google_Protobuf_FieldOptions) -> 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._ctype != rhs_storage._ctype {return false} + if _storage._packed != rhs_storage._packed {return false} + if _storage._jstype != rhs_storage._jstype {return false} + if _storage._lazy != rhs_storage._lazy {return false} + if _storage._unverifiedLazy != rhs_storage._unverifiedLazy {return false} + if _storage._deprecated != rhs_storage._deprecated {return false} + if _storage._weak != rhs_storage._weak {return false} + if _storage._debugRedact != rhs_storage._debugRedact {return false} + if _storage._retention != rhs_storage._retention {return false} + if _storage._targets != rhs_storage._targets {return false} + if _storage._editionDefaults != rhs_storage._editionDefaults {return false} + if _storage._features != rhs_storage._features {return false} + if _storage._featureSupport != rhs_storage._featureSupport {return false} if _storage._uninterpretedOption != rhs_storage._uninterpretedOption {return false} return true } @@ -3210,200 +4300,133 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes } } -extension Google_Protobuf_FileOptions.OptimizeMode: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "SPEED"), - 2: .same(proto: "CODE_SIZE"), - 3: .same(proto: "LITE_RUNTIME"), - ] +extension Google_Protobuf_FieldOptions.CType: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0STRING\0\u{1}CORD\0\u{1}STRING_PIECE\0") } -extension Google_Protobuf_MessageOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".MessageOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "message_set_wire_format"), - 2: .standard(proto: "no_standard_descriptor_accessor"), - 3: .same(proto: "deprecated"), - 7: .standard(proto: "map_entry"), - 999: .standard(proto: "uninterpreted_option"), - ] +extension Google_Protobuf_FieldOptions.JSType: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0JS_NORMAL\0\u{1}JS_STRING\0\u{1}JS_NUMBER\0") +} - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.uninterpretedOption) {return false} - return true - } +extension Google_Protobuf_FieldOptions.OptionRetention: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0RETENTION_UNKNOWN\0\u{1}RETENTION_RUNTIME\0\u{1}RETENTION_SOURCE\0") +} + +extension Google_Protobuf_FieldOptions.OptionTargetType: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0TARGET_TYPE_UNKNOWN\0\u{1}TARGET_TYPE_FILE\0\u{1}TARGET_TYPE_EXTENSION_RANGE\0\u{1}TARGET_TYPE_MESSAGE\0\u{1}TARGET_TYPE_FIELD\0\u{1}TARGET_TYPE_ONEOF\0\u{1}TARGET_TYPE_ENUM\0\u{1}TARGET_TYPE_ENUM_ENTRY\0\u{1}TARGET_TYPE_SERVICE\0\u{1}TARGET_TYPE_METHOD\0") +} + +extension Google_Protobuf_FieldOptions.EditionDefault: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = Google_Protobuf_FieldOptions.protoMessageName + ".EditionDefault" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\u{2}value\0\u{1}edition\0") - mutating func decodeMessage(decoder: inout D) throws { + 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.decodeSingularBoolField(value: &self._messageSetWireFormat) }() - case 2: try { try decoder.decodeSingularBoolField(value: &self._noStandardDescriptorAccessor) }() - case 3: try { try decoder.decodeSingularBoolField(value: &self._deprecated) }() - case 7: try { try decoder.decodeSingularBoolField(value: &self._mapEntry) }() - case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() - case 1000..<536870912: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_MessageOptions.self, fieldNumber: fieldNumber) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._value) }() + case 3: try { try decoder.decodeSingularEnumField(value: &self._edition) }() default: break } } } - func traverse(visitor: inout V) throws { + 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 - try { if let v = self._messageSetWireFormat { - try visitor.visitSingularBoolField(value: v, fieldNumber: 1) - } }() - try { if let v = self._noStandardDescriptorAccessor { - try visitor.visitSingularBoolField(value: v, fieldNumber: 2) - } }() - try { if let v = self._deprecated { - try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + try { if let v = self._value { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) } }() - try { if let v = self._mapEntry { - try visitor.visitSingularBoolField(value: v, fieldNumber: 7) + try { if let v = self._edition { + try visitor.visitSingularEnumField(value: v, fieldNumber: 3) } }() - if !self.uninterpretedOption.isEmpty { - try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) - } - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Google_Protobuf_MessageOptions, rhs: Google_Protobuf_MessageOptions) -> Bool { - if lhs._messageSetWireFormat != rhs._messageSetWireFormat {return false} - if lhs._noStandardDescriptorAccessor != rhs._noStandardDescriptorAccessor {return false} - if lhs._deprecated != rhs._deprecated {return false} - if lhs._mapEntry != rhs._mapEntry {return false} - if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} + static func ==(lhs: Google_Protobuf_FieldOptions.EditionDefault, rhs: Google_Protobuf_FieldOptions.EditionDefault) -> Bool { + if lhs._edition != rhs._edition {return false} + if lhs._value != rhs._value {return false} if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension Google_Protobuf_FieldOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".FieldOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ctype"), - 2: .same(proto: "packed"), - 6: .same(proto: "jstype"), - 5: .same(proto: "lazy"), - 3: .same(proto: "deprecated"), - 10: .same(proto: "weak"), - 999: .standard(proto: "uninterpreted_option"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.uninterpretedOption) {return false} - return true - } +extension Google_Protobuf_FieldOptions.FeatureSupport: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = Google_Protobuf_FieldOptions.protoMessageName + ".FeatureSupport" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}edition_introduced\0\u{3}edition_deprecated\0\u{3}deprecation_warning\0\u{3}edition_removed\0\u{3}removal_error\0") - mutating func decodeMessage(decoder: inout D) throws { + 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._ctype) }() - case 2: try { try decoder.decodeSingularBoolField(value: &self._packed) }() - case 3: try { try decoder.decodeSingularBoolField(value: &self._deprecated) }() - case 5: try { try decoder.decodeSingularBoolField(value: &self._lazy) }() - case 6: try { try decoder.decodeSingularEnumField(value: &self._jstype) }() - case 10: try { try decoder.decodeSingularBoolField(value: &self._weak) }() - case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() - case 1000..<536870912: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_FieldOptions.self, fieldNumber: fieldNumber) }() + case 1: try { try decoder.decodeSingularEnumField(value: &self._editionIntroduced) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self._editionDeprecated) }() + case 3: try { try decoder.decodeSingularStringField(value: &self._deprecationWarning) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._editionRemoved) }() + case 5: try { try decoder.decodeSingularStringField(value: &self._removalError) }() default: break } } } - func traverse(visitor: inout V) throws { + 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 - try { if let v = self._ctype { + try { if let v = self._editionIntroduced { try visitor.visitSingularEnumField(value: v, fieldNumber: 1) } }() - try { if let v = self._packed { - try visitor.visitSingularBoolField(value: v, fieldNumber: 2) - } }() - try { if let v = self._deprecated { - try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + try { if let v = self._editionDeprecated { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) } }() - try { if let v = self._lazy { - try visitor.visitSingularBoolField(value: v, fieldNumber: 5) + try { if let v = self._deprecationWarning { + try visitor.visitSingularStringField(value: v, fieldNumber: 3) } }() - try { if let v = self._jstype { - try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + try { if let v = self._editionRemoved { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) } }() - try { if let v = self._weak { - try visitor.visitSingularBoolField(value: v, fieldNumber: 10) + try { if let v = self._removalError { + try visitor.visitSingularStringField(value: v, fieldNumber: 5) } }() - if !self.uninterpretedOption.isEmpty { - try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) - } - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Google_Protobuf_FieldOptions, rhs: Google_Protobuf_FieldOptions) -> Bool { - if lhs._ctype != rhs._ctype {return false} - if lhs._packed != rhs._packed {return false} - if lhs._jstype != rhs._jstype {return false} - if lhs._lazy != rhs._lazy {return false} - if lhs._deprecated != rhs._deprecated {return false} - if lhs._weak != rhs._weak {return false} - if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} + static func ==(lhs: Google_Protobuf_FieldOptions.FeatureSupport, rhs: Google_Protobuf_FieldOptions.FeatureSupport) -> Bool { + if lhs._editionIntroduced != rhs._editionIntroduced {return false} + if lhs._editionDeprecated != rhs._editionDeprecated {return false} + if lhs._deprecationWarning != rhs._deprecationWarning {return false} + if lhs._editionRemoved != rhs._editionRemoved {return false} + if lhs._removalError != rhs._removalError {return false} if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension Google_Protobuf_FieldOptions.CType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "STRING"), - 1: .same(proto: "CORD"), - 2: .same(proto: "STRING_PIECE"), - ] -} - -extension Google_Protobuf_FieldOptions.JSType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "JS_NORMAL"), - 1: .same(proto: "JS_STRING"), - 2: .same(proto: "JS_NUMBER"), - ] -} - -extension Google_Protobuf_OneofOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_OneofOptions: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".OneofOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 999: .standard(proto: "uninterpreted_option"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}features\0\u{4}f\u{f}uninterpreted_option\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.uninterpretedOption) {return false} + if let v = self._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} return true } - mutating func decodeMessage(decoder: inout D) throws { + 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.decodeSingularMessageField(value: &self._features) }() case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() case 1000..<536870912: try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_OneofOptions.self, fieldNumber: fieldNumber) }() @@ -3412,7 +4435,14 @@ extension Google_Protobuf_OneofOptions: SwiftProtobuf.Message, SwiftProtobuf._Me } } - func traverse(visitor: inout V) throws { + 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 + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() if !self.uninterpretedOption.isEmpty { try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) } @@ -3421,6 +4451,7 @@ extension Google_Protobuf_OneofOptions: SwiftProtobuf.Message, SwiftProtobuf._Me } static func ==(lhs: Google_Protobuf_OneofOptions, rhs: Google_Protobuf_OneofOptions) -> Bool { + if lhs._features != rhs._features {return false} if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} @@ -3428,21 +4459,18 @@ extension Google_Protobuf_OneofOptions: SwiftProtobuf.Message, SwiftProtobuf._Me } } -extension Google_Protobuf_EnumOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_EnumOptions: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".EnumOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2: .standard(proto: "allow_alias"), - 3: .same(proto: "deprecated"), - 999: .standard(proto: "uninterpreted_option"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{4}\u{2}allow_alias\0\u{1}deprecated\0\u{4}\u{3}deprecated_legacy_json_field_conflicts\0\u{1}features\0\u{4}`\u{f}uninterpreted_option\0\u{c}\u{5}\u{1}") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.uninterpretedOption) {return false} + if let v = self._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} return true } - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -3450,6 +4478,8 @@ extension Google_Protobuf_EnumOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes switch fieldNumber { case 2: try { try decoder.decodeSingularBoolField(value: &self._allowAlias) }() case 3: try { try decoder.decodeSingularBoolField(value: &self._deprecated) }() + case 6: try { try decoder.decodeSingularBoolField(value: &self._deprecatedLegacyJsonFieldConflicts) }() + case 7: try { try decoder.decodeSingularMessageField(value: &self._features) }() case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() case 1000..<536870912: try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_EnumOptions.self, fieldNumber: fieldNumber) }() @@ -3458,7 +4488,7 @@ extension Google_Protobuf_EnumOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes } } - func traverse(visitor: inout V) throws { + 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 @@ -3469,6 +4499,12 @@ extension Google_Protobuf_EnumOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes try { if let v = self._deprecated { try visitor.visitSingularBoolField(value: v, fieldNumber: 3) } }() + try { if let v = self._deprecatedLegacyJsonFieldConflicts { + try visitor.visitSingularBoolField(value: v, fieldNumber: 6) + } }() + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 7) + } }() if !self.uninterpretedOption.isEmpty { try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) } @@ -3479,6 +4515,8 @@ extension Google_Protobuf_EnumOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes static func ==(lhs: Google_Protobuf_EnumOptions, rhs: Google_Protobuf_EnumOptions) -> Bool { if lhs._allowAlias != rhs._allowAlias {return false} if lhs._deprecated != rhs._deprecated {return false} + if lhs._deprecatedLegacyJsonFieldConflicts != rhs._deprecatedLegacyJsonFieldConflicts {return false} + if lhs._features != rhs._features {return false} if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} @@ -3486,26 +4524,27 @@ extension Google_Protobuf_EnumOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes } } -extension Google_Protobuf_EnumValueOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_EnumValueOptions: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".EnumValueOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "deprecated"), - 999: .standard(proto: "uninterpreted_option"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}deprecated\0\u{1}features\0\u{3}debug_redact\0\u{3}feature_support\0\u{4}c\u{f}uninterpreted_option\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.uninterpretedOption) {return false} + if let v = self._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} return true } - mutating func decodeMessage(decoder: inout D) throws { + 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.decodeSingularBoolField(value: &self._deprecated) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._features) }() + case 3: try { try decoder.decodeSingularBoolField(value: &self._debugRedact) }() + case 4: try { try decoder.decodeSingularMessageField(value: &self._featureSupport) }() case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() case 1000..<536870912: try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_EnumValueOptions.self, fieldNumber: fieldNumber) }() @@ -3514,7 +4553,7 @@ extension Google_Protobuf_EnumValueOptions: SwiftProtobuf.Message, SwiftProtobuf } } - func traverse(visitor: inout V) throws { + 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 @@ -3522,6 +4561,15 @@ extension Google_Protobuf_EnumValueOptions: SwiftProtobuf.Message, SwiftProtobuf try { if let v = self._deprecated { try visitor.visitSingularBoolField(value: v, fieldNumber: 1) } }() + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = self._debugRedact { + try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + } }() + try { if let v = self._featureSupport { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() if !self.uninterpretedOption.isEmpty { try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) } @@ -3531,6 +4579,9 @@ extension Google_Protobuf_EnumValueOptions: SwiftProtobuf.Message, SwiftProtobuf static func ==(lhs: Google_Protobuf_EnumValueOptions, rhs: Google_Protobuf_EnumValueOptions) -> Bool { if lhs._deprecated != rhs._deprecated {return false} + if lhs._features != rhs._features {return false} + if lhs._debugRedact != rhs._debugRedact {return false} + if lhs._featureSupport != rhs._featureSupport {return false} if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} @@ -3538,26 +4589,25 @@ extension Google_Protobuf_EnumValueOptions: SwiftProtobuf.Message, SwiftProtobuf } } -extension Google_Protobuf_ServiceOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_ServiceOptions: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ServiceOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 33: .same(proto: "deprecated"), - 999: .standard(proto: "uninterpreted_option"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}!deprecated\0\u{1}features\0\u{4}E\u{f}uninterpreted_option\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.uninterpretedOption) {return false} + if let v = self._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} return true } - mutating func decodeMessage(decoder: inout D) throws { + 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 33: try { try decoder.decodeSingularBoolField(value: &self._deprecated) }() + case 34: try { try decoder.decodeSingularMessageField(value: &self._features) }() case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() case 1000..<536870912: try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_ServiceOptions.self, fieldNumber: fieldNumber) }() @@ -3566,7 +4616,7 @@ extension Google_Protobuf_ServiceOptions: SwiftProtobuf.Message, SwiftProtobuf._ } } - func traverse(visitor: inout V) throws { + 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 @@ -3574,6 +4624,9 @@ extension Google_Protobuf_ServiceOptions: SwiftProtobuf.Message, SwiftProtobuf._ try { if let v = self._deprecated { try visitor.visitSingularBoolField(value: v, fieldNumber: 33) } }() + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 34) + } }() if !self.uninterpretedOption.isEmpty { try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) } @@ -3582,6 +4635,7 @@ extension Google_Protobuf_ServiceOptions: SwiftProtobuf.Message, SwiftProtobuf._ } static func ==(lhs: Google_Protobuf_ServiceOptions, rhs: Google_Protobuf_ServiceOptions) -> Bool { + if lhs._features != rhs._features {return false} if lhs._deprecated != rhs._deprecated {return false} if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -3590,21 +4644,18 @@ extension Google_Protobuf_ServiceOptions: SwiftProtobuf.Message, SwiftProtobuf._ } } -extension Google_Protobuf_MethodOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_MethodOptions: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MethodOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 33: .same(proto: "deprecated"), - 34: .standard(proto: "idempotency_level"), - 999: .standard(proto: "uninterpreted_option"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}!deprecated\0\u{3}idempotency_level\0\u{1}features\0\u{4}D\u{f}uninterpreted_option\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.uninterpretedOption) {return false} + if let v = self._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} return true } - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -3612,6 +4663,7 @@ extension Google_Protobuf_MethodOptions: SwiftProtobuf.Message, SwiftProtobuf._M switch fieldNumber { case 33: try { try decoder.decodeSingularBoolField(value: &self._deprecated) }() case 34: try { try decoder.decodeSingularEnumField(value: &self._idempotencyLevel) }() + case 35: try { try decoder.decodeSingularMessageField(value: &self._features) }() case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() case 1000..<536870912: try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_MethodOptions.self, fieldNumber: fieldNumber) }() @@ -3620,7 +4672,7 @@ extension Google_Protobuf_MethodOptions: SwiftProtobuf.Message, SwiftProtobuf._M } } - func traverse(visitor: inout V) throws { + 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 @@ -3631,6 +4683,9 @@ extension Google_Protobuf_MethodOptions: SwiftProtobuf.Message, SwiftProtobuf._M try { if let v = self._idempotencyLevel { try visitor.visitSingularEnumField(value: v, fieldNumber: 34) } }() + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 35) + } }() if !self.uninterpretedOption.isEmpty { try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) } @@ -3641,6 +4696,7 @@ extension Google_Protobuf_MethodOptions: SwiftProtobuf.Message, SwiftProtobuf._M static func ==(lhs: Google_Protobuf_MethodOptions, rhs: Google_Protobuf_MethodOptions) -> Bool { if lhs._deprecated != rhs._deprecated {return false} if lhs._idempotencyLevel != rhs._idempotencyLevel {return false} + if lhs._features != rhs._features {return false} if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} @@ -3648,32 +4704,20 @@ extension Google_Protobuf_MethodOptions: SwiftProtobuf.Message, SwiftProtobuf._M } } -extension Google_Protobuf_MethodOptions.IdempotencyLevel: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "IDEMPOTENCY_UNKNOWN"), - 1: .same(proto: "NO_SIDE_EFFECTS"), - 2: .same(proto: "IDEMPOTENT"), - ] +extension Google_Protobuf_MethodOptions.IdempotencyLevel: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0IDEMPOTENCY_UNKNOWN\0\u{1}NO_SIDE_EFFECTS\0\u{1}IDEMPOTENT\0") } -extension Google_Protobuf_UninterpretedOption: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_UninterpretedOption: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".UninterpretedOption" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2: .same(proto: "name"), - 3: .standard(proto: "identifier_value"), - 4: .standard(proto: "positive_int_value"), - 5: .standard(proto: "negative_int_value"), - 6: .standard(proto: "double_value"), - 7: .standard(proto: "string_value"), - 8: .standard(proto: "aggregate_value"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\u{2}name\0\u{3}identifier_value\0\u{3}positive_int_value\0\u{3}negative_int_value\0\u{3}double_value\0\u{3}string_value\0\u{3}aggregate_value\0") public var isInitialized: Bool { - if !SwiftProtobuf.Internal.areAllInitialized(self.name) {return false} + if !Internal.areAllInitialized(self.name) {return false} return true } - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -3691,7 +4735,7 @@ extension Google_Protobuf_UninterpretedOption: SwiftProtobuf.Message, SwiftProto } } - func traverse(visitor: inout V) throws { + 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 @@ -3733,12 +4777,9 @@ extension Google_Protobuf_UninterpretedOption: SwiftProtobuf.Message, SwiftProto } } -extension Google_Protobuf_UninterpretedOption.NamePart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_UninterpretedOption.NamePart: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = Google_Protobuf_UninterpretedOption.protoMessageName + ".NamePart" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "name_part"), - 2: .standard(proto: "is_extension"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}name_part\0\u{3}is_extension\0") public var isInitialized: Bool { if self._namePart == nil {return false} @@ -3746,7 +4787,7 @@ extension Google_Protobuf_UninterpretedOption.NamePart: SwiftProtobuf.Message, S return true } - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -3759,7 +4800,7 @@ extension Google_Protobuf_UninterpretedOption.NamePart: SwiftProtobuf.Message, S } } - func traverse(visitor: inout V) throws { + 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 @@ -3781,49 +4822,320 @@ extension Google_Protobuf_UninterpretedOption.NamePart: SwiftProtobuf.Message, S } } -extension Google_Protobuf_SourceCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_FeatureSet: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FeatureSet" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}field_presence\0\u{3}enum_type\0\u{3}repeated_field_encoding\0\u{3}utf8_validation\0\u{3}message_encoding\0\u{3}json_format\0\u{3}enforce_naming_style\0\u{3}default_symbol_visibility\0\u{c}g\u{f}\u{1}") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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._fieldPresence) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self._enumType) }() + case 3: try { try decoder.decodeSingularEnumField(value: &self._repeatedFieldEncoding) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._utf8Validation) }() + case 5: try { try decoder.decodeSingularEnumField(value: &self._messageEncoding) }() + case 6: try { try decoder.decodeSingularEnumField(value: &self._jsonFormat) }() + case 7: try { try decoder.decodeSingularEnumField(value: &self._enforceNamingStyle) }() + case 8: try { try decoder.decodeSingularEnumField(value: &self._defaultSymbolVisibility) }() + case 1000..<10001: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_FeatureSet.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._fieldPresence { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = self._enumType { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) + } }() + try { if let v = self._repeatedFieldEncoding { + try visitor.visitSingularEnumField(value: v, fieldNumber: 3) + } }() + try { if let v = self._utf8Validation { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + try { if let v = self._messageEncoding { + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + } }() + try { if let v = self._jsonFormat { + try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + } }() + try { if let v = self._enforceNamingStyle { + try visitor.visitSingularEnumField(value: v, fieldNumber: 7) + } }() + try { if let v = self._defaultSymbolVisibility { + try visitor.visitSingularEnumField(value: v, fieldNumber: 8) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 10001) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_FeatureSet, rhs: Google_Protobuf_FeatureSet) -> Bool { + if lhs._fieldPresence != rhs._fieldPresence {return false} + if lhs._enumType != rhs._enumType {return false} + if lhs._repeatedFieldEncoding != rhs._repeatedFieldEncoding {return false} + if lhs._utf8Validation != rhs._utf8Validation {return false} + if lhs._messageEncoding != rhs._messageEncoding {return false} + if lhs._jsonFormat != rhs._jsonFormat {return false} + if lhs._enforceNamingStyle != rhs._enforceNamingStyle {return false} + if lhs._defaultSymbolVisibility != rhs._defaultSymbolVisibility {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Google_Protobuf_FeatureSet.FieldPresence: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0FIELD_PRESENCE_UNKNOWN\0\u{1}EXPLICIT\0\u{1}IMPLICIT\0\u{1}LEGACY_REQUIRED\0") +} + +extension Google_Protobuf_FeatureSet.EnumType: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0ENUM_TYPE_UNKNOWN\0\u{1}OPEN\0\u{1}CLOSED\0") +} + +extension Google_Protobuf_FeatureSet.RepeatedFieldEncoding: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0REPEATED_FIELD_ENCODING_UNKNOWN\0\u{1}PACKED\0\u{1}EXPANDED\0") +} + +extension Google_Protobuf_FeatureSet.Utf8Validation: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0UTF8_VALIDATION_UNKNOWN\0\u{2}\u{2}VERIFY\0\u{1}NONE\0") +} + +extension Google_Protobuf_FeatureSet.MessageEncoding: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0MESSAGE_ENCODING_UNKNOWN\0\u{1}LENGTH_PREFIXED\0\u{1}DELIMITED\0") +} + +extension Google_Protobuf_FeatureSet.JsonFormat: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0JSON_FORMAT_UNKNOWN\0\u{1}ALLOW\0\u{1}LEGACY_BEST_EFFORT\0") +} + +extension Google_Protobuf_FeatureSet.EnforceNamingStyle: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0ENFORCE_NAMING_STYLE_UNKNOWN\0\u{1}STYLE2024\0\u{1}STYLE_LEGACY\0") +} + +extension Google_Protobuf_FeatureSet.VisibilityFeature: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = Google_Protobuf_FeatureSet.protoMessageName + ".VisibilityFeature" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{c}\u{1}\u{7f}\u{7f}\u{7f}\u{7f}\u{1f}") + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_FeatureSet.VisibilityFeature, rhs: Google_Protobuf_FeatureSet.VisibilityFeature) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_FeatureSet.VisibilityFeature.DefaultSymbolVisibility: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0DEFAULT_SYMBOL_VISIBILITY_UNKNOWN\0\u{1}EXPORT_ALL\0\u{1}EXPORT_TOP_LEVEL\0\u{1}LOCAL_ALL\0\u{1}STRICT\0") +} + +extension Google_Protobuf_FeatureSetDefaults: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FeatureSetDefaults" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}defaults\0\u{4}\u{3}minimum_edition\0\u{3}maximum_edition\0") + + public var isInitialized: Bool { + if !Internal.areAllInitialized(self.defaults) {return false} + return true + } + + 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.decodeRepeatedMessageField(value: &self.defaults) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._minimumEdition) }() + case 5: try { try decoder.decodeSingularEnumField(value: &self._maximumEdition) }() + 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 + if !self.defaults.isEmpty { + try visitor.visitRepeatedMessageField(value: self.defaults, fieldNumber: 1) + } + try { if let v = self._minimumEdition { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + try { if let v = self._maximumEdition { + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_FeatureSetDefaults, rhs: Google_Protobuf_FeatureSetDefaults) -> Bool { + if lhs.defaults != rhs.defaults {return false} + if lhs._minimumEdition != rhs._minimumEdition {return false} + if lhs._maximumEdition != rhs._maximumEdition {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_FeatureSetDefaults.FeatureSetEditionDefault: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = Google_Protobuf_FeatureSetDefaults.protoMessageName + ".FeatureSetEditionDefault" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\u{3}edition\0\u{3}overridable_features\0\u{3}fixed_features\0\u{b}features\0\u{c}\u{1}\u{1}\u{c}\u{2}\u{1}") + + fileprivate class _StorageClass { + var _edition: Google_Protobuf_Edition? = nil + var _overridableFeatures: Google_Protobuf_FeatureSet? = nil + var _fixedFeatures: Google_Protobuf_FeatureSet? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _edition = source._edition + _overridableFeatures = source._overridableFeatures + _fixedFeatures = source._fixedFeatures + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._overridableFeatures, !v.isInitialized {return false} + if let v = _storage._fixedFeatures, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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 3: try { try decoder.decodeSingularEnumField(value: &_storage._edition) }() + case 4: try { try decoder.decodeSingularMessageField(value: &_storage._overridableFeatures) }() + case 5: try { try decoder.decodeSingularMessageField(value: &_storage._fixedFeatures) }() + default: break + } + } + } + } + + func traverse(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._edition { + try visitor.visitSingularEnumField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._overridableFeatures { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._fixedFeatures { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_FeatureSetDefaults.FeatureSetEditionDefault, rhs: Google_Protobuf_FeatureSetDefaults.FeatureSetEditionDefault) -> 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._edition != rhs_storage._edition {return false} + if _storage._overridableFeatures != rhs_storage._overridableFeatures {return false} + if _storage._fixedFeatures != rhs_storage._fixedFeatures {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_SourceCodeInfo: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SourceCodeInfo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "location"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}location\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } - mutating func decodeMessage(decoder: inout D) throws { + 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.decodeRepeatedMessageField(value: &self.location) }() + case 536000000: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_SourceCodeInfo.self, fieldNumber: fieldNumber) }() default: break } } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if !self.location.isEmpty { try visitor.visitRepeatedMessageField(value: self.location, fieldNumber: 1) } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 536000000, end: 536000001) try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Google_Protobuf_SourceCodeInfo, rhs: Google_Protobuf_SourceCodeInfo) -> Bool { if lhs.location != rhs.location {return false} if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension Google_Protobuf_SourceCodeInfo.Location: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_SourceCodeInfo.Location: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = Google_Protobuf_SourceCodeInfo.protoMessageName + ".Location" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "path"), - 2: .same(proto: "span"), - 3: .standard(proto: "leading_comments"), - 4: .standard(proto: "trailing_comments"), - 6: .standard(proto: "leading_detached_comments"), - ] - - mutating func decodeMessage(decoder: inout D) throws { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}path\0\u{1}span\0\u{3}leading_comments\0\u{3}trailing_comments\0\u{4}\u{2}leading_detached_comments\0") + + 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 @@ -3839,7 +5151,7 @@ extension Google_Protobuf_SourceCodeInfo.Location: SwiftProtobuf.Message, SwiftP } } - func traverse(visitor: inout V) throws { + 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 @@ -3873,13 +5185,11 @@ extension Google_Protobuf_SourceCodeInfo.Location: SwiftProtobuf.Message, SwiftP } } -extension Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_GeneratedCodeInfo: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".GeneratedCodeInfo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "annotation"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}annotation\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -3891,7 +5201,7 @@ extension Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf.Message, SwiftProtobu } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if !self.annotation.isEmpty { try visitor.visitRepeatedMessageField(value: self.annotation, fieldNumber: 1) } @@ -3905,16 +5215,11 @@ extension Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf.Message, SwiftProtobu } } -extension Google_Protobuf_GeneratedCodeInfo.Annotation: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_GeneratedCodeInfo.Annotation: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = Google_Protobuf_GeneratedCodeInfo.protoMessageName + ".Annotation" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "path"), - 2: .standard(proto: "source_file"), - 3: .same(proto: "begin"), - 4: .same(proto: "end"), - ] - - mutating func decodeMessage(decoder: inout D) throws { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}path\0\u{3}source_file\0\u{1}begin\0\u{1}end\0\u{1}semantic\0") + + 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 @@ -3924,12 +5229,13 @@ extension Google_Protobuf_GeneratedCodeInfo.Annotation: SwiftProtobuf.Message, S case 2: try { try decoder.decodeSingularStringField(value: &self._sourceFile) }() case 3: try { try decoder.decodeSingularInt32Field(value: &self._begin) }() case 4: try { try decoder.decodeSingularInt32Field(value: &self._end) }() + case 5: try { try decoder.decodeSingularEnumField(value: &self._semantic) }() default: break } } } - func traverse(visitor: inout V) throws { + 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 @@ -3946,6 +5252,9 @@ extension Google_Protobuf_GeneratedCodeInfo.Annotation: SwiftProtobuf.Message, S try { if let v = self._end { try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) } }() + try { if let v = self._semantic { + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + } }() try unknownFields.traverse(visitor: &visitor) } @@ -3954,7 +5263,12 @@ extension Google_Protobuf_GeneratedCodeInfo.Annotation: SwiftProtobuf.Message, S if lhs._sourceFile != rhs._sourceFile {return false} if lhs._begin != rhs._begin {return false} if lhs._end != rhs._end {return false} + if lhs._semantic != rhs._semantic {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } + +extension Google_Protobuf_GeneratedCodeInfo.Annotation.Semantic: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0NONE\0\u{1}SET\0\u{1}ALIAS\0") +} diff --git a/Reference/google/protobuf/duration.pb.swift b/Reference/Sources/SwiftProtobuf/google/protobuf/duration.pb.swift similarity index 89% rename from Reference/google/protobuf/duration.pb.swift rename to Reference/Sources/SwiftProtobuf/google/protobuf/duration.pb.swift index 5d29bba1c..8bf22e67c 100644 --- a/Reference/google/protobuf/duration.pb.swift +++ b/Reference/Sources/SwiftProtobuf/google/protobuf/duration.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/duration.proto @@ -37,15 +38,15 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } @@ -107,7 +108,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should /// be expressed in JSON format as "3.000000001s", and 3 seconds and 1 /// microsecond should be expressed in JSON format as "3.000001s". -struct Google_Protobuf_Duration { +struct Google_Protobuf_Duration: Sendable { // 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. @@ -125,27 +126,20 @@ struct Google_Protobuf_Duration { /// to +999,999,999 inclusive. var nanos: Int32 = 0 - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_Duration: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_Duration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Duration: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Duration" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "seconds"), - 2: .same(proto: "nanos"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}seconds\0\u{1}nanos\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -158,7 +152,7 @@ extension Google_Protobuf_Duration: SwiftProtobuf.Message, SwiftProtobuf._Messag } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if self.seconds != 0 { try visitor.visitSingularInt64Field(value: self.seconds, fieldNumber: 1) } diff --git a/Reference/google/protobuf/empty.pb.swift b/Reference/Sources/SwiftProtobuf/google/protobuf/empty.pb.swift similarity index 79% rename from Reference/google/protobuf/empty.pb.swift rename to Reference/Sources/SwiftProtobuf/google/protobuf/empty.pb.swift index 63a9bde53..0d953467e 100644 --- a/Reference/google/protobuf/empty.pb.swift +++ b/Reference/Sources/SwiftProtobuf/google/protobuf/empty.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/empty.proto @@ -37,15 +38,15 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } @@ -56,36 +57,30 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// service Foo { /// rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); /// } -/// -/// The JSON representation for `Empty` is empty JSON object `{}`. -struct Google_Protobuf_Empty { +struct Google_Protobuf_Empty: Sendable { // 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() + var unknownFields = UnknownStorage() init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_Empty: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_Empty: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Empty: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Empty" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() + static let _protobuf_nameMap = _NameMap() - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } diff --git a/Reference/google/protobuf/field_mask.pb.swift b/Reference/Sources/SwiftProtobuf/google/protobuf/field_mask.pb.swift similarity index 92% rename from Reference/google/protobuf/field_mask.pb.swift rename to Reference/Sources/SwiftProtobuf/google/protobuf/field_mask.pb.swift index d99ed473c..6b75ef7a1 100644 --- a/Reference/google/protobuf/field_mask.pb.swift +++ b/Reference/Sources/SwiftProtobuf/google/protobuf/field_mask.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/field_mask.proto @@ -37,15 +38,15 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } @@ -248,7 +249,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// The implementation of any API method which has a FieldMask type field in the /// request should verify the included field paths, and return an /// `INVALID_ARGUMENT` error if any path is unmappable. -struct Google_Protobuf_FieldMask { +struct Google_Protobuf_FieldMask: Sendable { // 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. @@ -256,26 +257,20 @@ struct Google_Protobuf_FieldMask { /// The set of field mask paths. var paths: [String] = [] - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_FieldMask: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_FieldMask: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_FieldMask: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".FieldMask" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "paths"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}paths\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -287,7 +282,7 @@ extension Google_Protobuf_FieldMask: SwiftProtobuf.Message, SwiftProtobuf._Messa } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if !self.paths.isEmpty { try visitor.visitRepeatedStringField(value: self.paths, fieldNumber: 1) } diff --git a/Reference/google/protobuf/source_context.pb.swift b/Reference/Sources/SwiftProtobuf/google/protobuf/source_context.pb.swift similarity index 82% rename from Reference/google/protobuf/source_context.pb.swift rename to Reference/Sources/SwiftProtobuf/google/protobuf/source_context.pb.swift index 728a841e1..53b5753e2 100644 --- a/Reference/google/protobuf/source_context.pb.swift +++ b/Reference/Sources/SwiftProtobuf/google/protobuf/source_context.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/source_context.proto @@ -37,21 +38,21 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } /// `SourceContext` represents information about the source of a /// protobuf element, like the file in which it is defined. -struct Google_Protobuf_SourceContext { +struct Google_Protobuf_SourceContext: Sendable { // 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. @@ -60,26 +61,20 @@ struct Google_Protobuf_SourceContext { /// protobuf element. For example: `"google/protobuf/source_context.proto"`. var fileName: String = String() - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_SourceContext: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_SourceContext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_SourceContext: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SourceContext" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "file_name"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}file_name\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -91,7 +86,7 @@ extension Google_Protobuf_SourceContext: SwiftProtobuf.Message, SwiftProtobuf._M } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if !self.fileName.isEmpty { try visitor.visitSingularStringField(value: self.fileName, fieldNumber: 1) } diff --git a/Reference/google/protobuf/struct.pb.swift b/Reference/Sources/SwiftProtobuf/google/protobuf/struct.pb.swift similarity index 73% rename from Reference/google/protobuf/struct.pb.swift rename to Reference/Sources/SwiftProtobuf/google/protobuf/struct.pb.swift index 61bec6162..023b628b9 100644 --- a/Reference/google/protobuf/struct.pb.swift +++ b/Reference/Sources/SwiftProtobuf/google/protobuf/struct.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/struct.proto @@ -37,23 +38,23 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } /// `NullValue` is a singleton enumeration to represent the null value for the /// `Value` type union. /// -/// The JSON representation for `NullValue` is JSON `null`. -enum Google_Protobuf_NullValue: SwiftProtobuf.Enum { +/// The JSON representation for `NullValue` is JSON `null`. +enum Google_Protobuf_NullValue: Enum, Swift.CaseIterable { typealias RawValue = Int /// Null value. @@ -78,18 +79,12 @@ enum Google_Protobuf_NullValue: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension Google_Protobuf_NullValue: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Google_Protobuf_NullValue] = [ + static let allCases: [Google_Protobuf_NullValue] = [ .nullValue, ] -} -#endif // swift(>=4.2) +} /// `Struct` represents a structured data value, consisting of fields /// which map to dynamically typed values. In some languages, `Struct` @@ -99,7 +94,7 @@ extension Google_Protobuf_NullValue: CaseIterable { /// with the proto support for the language. /// /// The JSON representation for `Struct` is JSON object. -struct Google_Protobuf_Struct { +struct Google_Protobuf_Struct: Sendable { // 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. @@ -107,7 +102,7 @@ struct Google_Protobuf_Struct { /// Unordered map of dynamically typed values. var fields: Dictionary = [:] - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} } @@ -118,7 +113,7 @@ struct Google_Protobuf_Struct { /// variants. Absence of any variant indicates an error. /// /// The JSON representation for `Value` is JSON value. -struct Google_Protobuf_Value { +struct Google_Protobuf_Value: Sendable { // 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. @@ -180,10 +175,10 @@ struct Google_Protobuf_Value { set {kind = .listValue(newValue)} } - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() /// The kind of value. - enum OneOf_Kind: Equatable { + enum OneOf_Kind: Equatable, Sendable { /// Represents a null value. case nullValue(Google_Protobuf_NullValue) /// Represents a double value. @@ -197,40 +192,6 @@ struct Google_Protobuf_Value { /// Represents a repeated `Value`. case listValue(Google_Protobuf_ListValue) - #if !swift(>=4.1) - static func ==(lhs: Google_Protobuf_Value.OneOf_Kind, rhs: Google_Protobuf_Value.OneOf_Kind) -> 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 (.nullValue, .nullValue): return { - guard case .nullValue(let l) = lhs, case .nullValue(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.numberValue, .numberValue): return { - guard case .numberValue(let l) = lhs, case .numberValue(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.stringValue, .stringValue): return { - guard case .stringValue(let l) = lhs, case .stringValue(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.boolValue, .boolValue): return { - guard case .boolValue(let l) = lhs, case .boolValue(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.structValue, .structValue): return { - guard case .structValue(let l) = lhs, case .structValue(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.listValue, .listValue): return { - guard case .listValue(let l) = lhs, case .listValue(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } init() {} @@ -239,7 +200,7 @@ struct Google_Protobuf_Value { /// `ListValue` is a wrapper around a repeated field of values. /// /// The JSON representation for `ListValue` is JSON array. -struct Google_Protobuf_ListValue { +struct Google_Protobuf_ListValue: Sendable { // 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. @@ -247,50 +208,38 @@ struct Google_Protobuf_ListValue { /// Repeated field of dynamically typed values. var values: [Google_Protobuf_Value] = [] - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_NullValue: @unchecked Sendable {} -extension Google_Protobuf_Struct: @unchecked Sendable {} -extension Google_Protobuf_Value: @unchecked Sendable {} -extension Google_Protobuf_Value.OneOf_Kind: @unchecked Sendable {} -extension Google_Protobuf_ListValue: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_NullValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NULL_VALUE"), - ] +extension Google_Protobuf_NullValue: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0NULL_VALUE\0") } -extension Google_Protobuf_Struct: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Struct: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Struct" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fields"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}fields\0") - mutating func decodeMessage(decoder: inout D) throws { + 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.fields) }() + case 1: try { try decoder.decodeMapField(fieldType: _ProtobufMessageMap.self, value: &self.fields) }() default: break } } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if !self.fields.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.fields, fieldNumber: 1) + try visitor.visitMapField(fieldType: _ProtobufMessageMap.self, value: self.fields, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } @@ -302,18 +251,11 @@ extension Google_Protobuf_Struct: SwiftProtobuf.Message, SwiftProtobuf._MessageI } } -extension Google_Protobuf_Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Value: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "null_value"), - 2: .standard(proto: "number_value"), - 3: .standard(proto: "string_value"), - 4: .standard(proto: "bool_value"), - 5: .standard(proto: "struct_value"), - 6: .standard(proto: "list_value"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}null_value\0\u{3}number_value\0\u{3}string_value\0\u{3}bool_value\0\u{3}struct_value\0\u{3}list_value\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -382,7 +324,7 @@ extension Google_Protobuf_Value: SwiftProtobuf.Message, SwiftProtobuf._MessageIm } } - func traverse(visitor: inout V) throws { + 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 @@ -424,13 +366,11 @@ extension Google_Protobuf_Value: SwiftProtobuf.Message, SwiftProtobuf._MessageIm } } -extension Google_Protobuf_ListValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_ListValue: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ListValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "values"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}values\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -442,7 +382,7 @@ extension Google_Protobuf_ListValue: SwiftProtobuf.Message, SwiftProtobuf._Messa } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if !self.values.isEmpty { try visitor.visitRepeatedMessageField(value: self.values, fieldNumber: 1) } diff --git a/Reference/google/protobuf/timestamp.pb.swift b/Reference/Sources/SwiftProtobuf/google/protobuf/timestamp.pb.swift similarity index 84% rename from Reference/google/protobuf/timestamp.pb.swift rename to Reference/Sources/SwiftProtobuf/google/protobuf/timestamp.pb.swift index e711234dd..30f78ae5b 100644 --- a/Reference/google/protobuf/timestamp.pb.swift +++ b/Reference/Sources/SwiftProtobuf/google/protobuf/timestamp.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/timestamp.proto @@ -37,15 +38,15 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } @@ -99,7 +100,6 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) /// .setNanos((int) ((millis % 1000) * 1000000)).build(); /// -/// /// Example 5: Compute Timestamp from Java `Instant.now()`. /// /// Instant now = Instant.now(); @@ -108,7 +108,6 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// Timestamp.newBuilder().setSeconds(now.getEpochSecond()) /// .setNanos(now.getNano()).build(); /// -/// /// Example 6: Compute Timestamp from current time in Python. /// /// timestamp = Timestamp() @@ -123,8 +122,8 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional /// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), /// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone -/// is required. A proto3 JSON serializer should always use UTC (as indicated by -/// "Z") when printing the Timestamp type and a proto3 JSON parser should be +/// is required. A ProtoJSON serializer should always use UTC (as indicated by +/// "Z") when printing the Timestamp type and a ProtoJSON parser should be /// able to accept both UTC and other timezones (as indicated by an offset). /// /// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past @@ -138,45 +137,39 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with /// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use /// the Joda Time's [`ISODateTimeFormat.dateTime()`]( -/// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D +/// http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime() /// ) to obtain a formatter capable of generating timestamps in this format. -struct Google_Protobuf_Timestamp { +struct Google_Protobuf_Timestamp: Sendable { // 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. - /// Represents seconds of UTC time since Unix epoch - /// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to - /// 9999-12-31T23:59:59Z inclusive. + /// Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must + /// be between -62135596800 and 253402300799 inclusive (which corresponds to + /// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z). var seconds: Int64 = 0 - /// Non-negative fractions of a second at nanosecond resolution. Negative - /// second values with fractions must still have non-negative nanos values - /// that count forward in time. Must be from 0 to 999,999,999 + /// Non-negative fractions of a second at nanosecond resolution. This field is + /// the nanosecond portion of the duration, not an alternative to seconds. + /// Negative second values with fractions must still have non-negative nanos + /// values that count forward in time. Must be between 0 and 999,999,999 /// inclusive. var nanos: Int32 = 0 - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_Timestamp: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_Timestamp: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Timestamp: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Timestamp" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "seconds"), - 2: .same(proto: "nanos"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}seconds\0\u{1}nanos\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -189,7 +182,7 @@ extension Google_Protobuf_Timestamp: SwiftProtobuf.Message, SwiftProtobuf._Messa } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if self.seconds != 0 { try visitor.visitSingularInt64Field(value: self.seconds, fieldNumber: 1) } diff --git a/Reference/google/protobuf/type.pb.swift b/Reference/Sources/SwiftProtobuf/google/protobuf/type.pb.swift similarity index 76% rename from Reference/google/protobuf/type.pb.swift rename to Reference/Sources/SwiftProtobuf/google/protobuf/type.pb.swift index 299389bbc..429e57454 100644 --- a/Reference/google/protobuf/type.pb.swift +++ b/Reference/Sources/SwiftProtobuf/google/protobuf/type.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/type.proto @@ -37,20 +38,20 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } /// The syntax in which a protocol buffer element is defined. -enum Google_Protobuf_Syntax: SwiftProtobuf.Enum { +enum Google_Protobuf_Syntax: Enum, Swift.CaseIterable { typealias RawValue = Int /// Syntax `proto2`. @@ -58,6 +59,9 @@ enum Google_Protobuf_Syntax: SwiftProtobuf.Enum { /// Syntax `proto3`. case proto3 // = 1 + + /// Syntax `editions`. + case editions // = 2 case UNRECOGNIZED(Int) init() { @@ -68,6 +72,7 @@ enum Google_Protobuf_Syntax: SwiftProtobuf.Enum { switch rawValue { case 0: self = .proto2 case 1: self = .proto3 + case 2: self = .editions default: self = .UNRECOGNIZED(rawValue) } } @@ -76,26 +81,27 @@ enum Google_Protobuf_Syntax: SwiftProtobuf.Enum { switch self { case .proto2: return 0 case .proto3: return 1 + case .editions: return 2 case .UNRECOGNIZED(let i): return i } } -} - -#if swift(>=4.2) - -extension Google_Protobuf_Syntax: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Google_Protobuf_Syntax] = [ + static let allCases: [Google_Protobuf_Syntax] = [ .proto2, .proto3, + .editions, ] -} -#endif // swift(>=4.2) +} /// A protocol buffer message type. -struct Google_Protobuf_Type { +/// +/// New usages of this message as an alternative to DescriptorProto are strongly +/// discouraged. This message does not reliability preserve all information +/// necessary to model the schema and preserve semantics. Instead make use of +/// FileDescriptorSet which preserves the necessary information. +struct Google_Protobuf_Type: Sendable { // 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. @@ -114,18 +120,21 @@ struct Google_Protobuf_Type { /// The source context. var sourceContext: Google_Protobuf_SourceContext { - get {return _sourceContext ?? Google_Protobuf_SourceContext()} + get {_sourceContext ?? Google_Protobuf_SourceContext()} set {_sourceContext = newValue} } /// Returns true if `sourceContext` has been explicitly set. - var hasSourceContext: Bool {return self._sourceContext != nil} + var hasSourceContext: Bool {self._sourceContext != nil} /// Clears the value of `sourceContext`. Subsequent reads from it will return its default value. mutating func clearSourceContext() {self._sourceContext = nil} /// The source syntax. var syntax: Google_Protobuf_Syntax = .proto2 - var unknownFields = SwiftProtobuf.UnknownStorage() + /// The source edition string, only valid when syntax is SYNTAX_EDITIONS. + var edition: String = String() + + var unknownFields = UnknownStorage() init() {} @@ -133,7 +142,12 @@ struct Google_Protobuf_Type { } /// A single field of a message type. -struct Google_Protobuf_Field { +/// +/// New usages of this message as an alternative to FieldDescriptorProto are +/// strongly discouraged. This message does not reliability preserve all +/// information necessary to model the schema and preserve semantics. Instead +/// make use of FileDescriptorSet which preserves the necessary information. +struct Google_Protobuf_Field: Sendable { // 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. @@ -170,10 +184,10 @@ struct Google_Protobuf_Field { /// The string value of the default value of this field. Proto2 syntax only. var defaultValue: String = String() - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() /// Basic field types. - enum Kind: SwiftProtobuf.Enum { + enum Kind: Enum, Swift.CaseIterable { typealias RawValue = Int /// Field type unknown. @@ -288,10 +302,33 @@ struct Google_Protobuf_Field { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Google_Protobuf_Field.Kind] = [ + .typeUnknown, + .typeDouble, + .typeFloat, + .typeInt64, + .typeUint64, + .typeInt32, + .typeFixed64, + .typeFixed32, + .typeBool, + .typeString, + .typeGroup, + .typeMessage, + .typeBytes, + .typeUint32, + .typeEnum, + .typeSfixed32, + .typeSfixed64, + .typeSint32, + .typeSint64, + ] + } /// Whether a field is optional, required, or repeated. - enum Cardinality: SwiftProtobuf.Enum { + enum Cardinality: Enum, Swift.CaseIterable { typealias RawValue = Int /// For fields with unknown cardinality. @@ -331,52 +368,26 @@ struct Google_Protobuf_Field { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Google_Protobuf_Field.Cardinality] = [ + .unknown, + .optional, + .required, + .repeated, + ] + } init() {} } -#if swift(>=4.2) - -extension Google_Protobuf_Field.Kind: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Google_Protobuf_Field.Kind] = [ - .typeUnknown, - .typeDouble, - .typeFloat, - .typeInt64, - .typeUint64, - .typeInt32, - .typeFixed64, - .typeFixed32, - .typeBool, - .typeString, - .typeGroup, - .typeMessage, - .typeBytes, - .typeUint32, - .typeEnum, - .typeSfixed32, - .typeSfixed64, - .typeSint32, - .typeSint64, - ] -} - -extension Google_Protobuf_Field.Cardinality: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Google_Protobuf_Field.Cardinality] = [ - .unknown, - .optional, - .required, - .repeated, - ] -} - -#endif // swift(>=4.2) - /// Enum type definition. -struct Google_Protobuf_Enum { +/// +/// New usages of this message as an alternative to EnumDescriptorProto are +/// strongly discouraged. This message does not reliability preserve all +/// information necessary to model the schema and preserve semantics. Instead +/// make use of FileDescriptorSet which preserves the necessary information. +struct Google_Protobuf_Enum: Sendable { // 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. @@ -392,18 +403,21 @@ struct Google_Protobuf_Enum { /// The source context. var sourceContext: Google_Protobuf_SourceContext { - get {return _sourceContext ?? Google_Protobuf_SourceContext()} + get {_sourceContext ?? Google_Protobuf_SourceContext()} set {_sourceContext = newValue} } /// Returns true if `sourceContext` has been explicitly set. - var hasSourceContext: Bool {return self._sourceContext != nil} + var hasSourceContext: Bool {self._sourceContext != nil} /// Clears the value of `sourceContext`. Subsequent reads from it will return its default value. mutating func clearSourceContext() {self._sourceContext = nil} /// The source syntax. var syntax: Google_Protobuf_Syntax = .proto2 - var unknownFields = SwiftProtobuf.UnknownStorage() + /// The source edition string, only valid when syntax is SYNTAX_EDITIONS. + var edition: String = String() + + var unknownFields = UnknownStorage() init() {} @@ -411,7 +425,12 @@ struct Google_Protobuf_Enum { } /// Enum value definition. -struct Google_Protobuf_EnumValue { +/// +/// New usages of this message as an alternative to EnumValueDescriptorProto are +/// strongly discouraged. This message does not reliability preserve all +/// information necessary to model the schema and preserve semantics. Instead +/// make use of FileDescriptorSet which preserves the necessary information. +struct Google_Protobuf_EnumValue: Sendable { // 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. @@ -425,14 +444,18 @@ struct Google_Protobuf_EnumValue { /// Protocol buffer options. var options: [Google_Protobuf_Option] = [] - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} } /// A protocol buffer option, which can be attached to a message, field, /// enumeration, etc. -struct Google_Protobuf_Option { +/// +/// New usages of this message as an alternative to FileOptions, MessageOptions, +/// FieldOptions, EnumOptions, EnumValueOptions, ServiceOptions, or MethodOptions +/// are strongly discouraged. +struct Google_Protobuf_Option: Sendable { // 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. @@ -448,55 +471,34 @@ struct Google_Protobuf_Option { /// should be used. If the value is an enum, it should be stored as an int32 /// value using the google.protobuf.Int32Value type. var value: Google_Protobuf_Any { - get {return _value ?? Google_Protobuf_Any()} + get {_value ?? Google_Protobuf_Any()} set {_value = newValue} } /// Returns true if `value` has been explicitly set. - var hasValue: Bool {return self._value != nil} + var hasValue: Bool {self._value != nil} /// Clears the value of `value`. Subsequent reads from it will return its default value. mutating func clearValue() {self._value = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} fileprivate var _value: Google_Protobuf_Any? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_Syntax: @unchecked Sendable {} -extension Google_Protobuf_Type: @unchecked Sendable {} -extension Google_Protobuf_Field: @unchecked Sendable {} -extension Google_Protobuf_Field.Kind: @unchecked Sendable {} -extension Google_Protobuf_Field.Cardinality: @unchecked Sendable {} -extension Google_Protobuf_Enum: @unchecked Sendable {} -extension Google_Protobuf_EnumValue: @unchecked Sendable {} -extension Google_Protobuf_Option: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_Syntax: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "SYNTAX_PROTO2"), - 1: .same(proto: "SYNTAX_PROTO3"), - ] +extension Google_Protobuf_Syntax: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0SYNTAX_PROTO2\0\u{1}SYNTAX_PROTO3\0\u{1}SYNTAX_EDITIONS\0") } -extension Google_Protobuf_Type: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Type: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Type" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "fields"), - 3: .same(proto: "oneofs"), - 4: .same(proto: "options"), - 5: .standard(proto: "source_context"), - 6: .same(proto: "syntax"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}fields\0\u{1}oneofs\0\u{1}options\0\u{3}source_context\0\u{1}syntax\0\u{1}edition\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -508,12 +510,13 @@ extension Google_Protobuf_Type: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 4: try { try decoder.decodeRepeatedMessageField(value: &self.options) }() case 5: try { try decoder.decodeSingularMessageField(value: &self._sourceContext) }() case 6: try { try decoder.decodeSingularEnumField(value: &self.syntax) }() + case 7: try { try decoder.decodeSingularStringField(value: &self.edition) }() default: break } } } - func traverse(visitor: inout V) throws { + 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 @@ -536,6 +539,9 @@ extension Google_Protobuf_Type: SwiftProtobuf.Message, SwiftProtobuf._MessageImp if self.syntax != .proto2 { try visitor.visitSingularEnumField(value: self.syntax, fieldNumber: 6) } + if !self.edition.isEmpty { + try visitor.visitSingularStringField(value: self.edition, fieldNumber: 7) + } try unknownFields.traverse(visitor: &visitor) } @@ -546,27 +552,17 @@ extension Google_Protobuf_Type: SwiftProtobuf.Message, SwiftProtobuf._MessageImp if lhs.options != rhs.options {return false} if lhs._sourceContext != rhs._sourceContext {return false} if lhs.syntax != rhs.syntax {return false} + if lhs.edition != rhs.edition {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Field: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "kind"), - 2: .same(proto: "cardinality"), - 3: .same(proto: "number"), - 4: .same(proto: "name"), - 6: .standard(proto: "type_url"), - 7: .standard(proto: "oneof_index"), - 8: .same(proto: "packed"), - 9: .same(proto: "options"), - 10: .standard(proto: "json_name"), - 11: .standard(proto: "default_value"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}kind\0\u{1}cardinality\0\u{1}number\0\u{1}name\0\u{4}\u{2}type_url\0\u{3}oneof_index\0\u{1}packed\0\u{1}options\0\u{3}json_name\0\u{3}default_value\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -587,7 +583,7 @@ extension Google_Protobuf_Field: SwiftProtobuf.Message, SwiftProtobuf._MessageIm } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if self.kind != .typeUnknown { try visitor.visitSingularEnumField(value: self.kind, fieldNumber: 1) } @@ -637,50 +633,19 @@ extension Google_Protobuf_Field: SwiftProtobuf.Message, SwiftProtobuf._MessageIm } } -extension Google_Protobuf_Field.Kind: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "TYPE_UNKNOWN"), - 1: .same(proto: "TYPE_DOUBLE"), - 2: .same(proto: "TYPE_FLOAT"), - 3: .same(proto: "TYPE_INT64"), - 4: .same(proto: "TYPE_UINT64"), - 5: .same(proto: "TYPE_INT32"), - 6: .same(proto: "TYPE_FIXED64"), - 7: .same(proto: "TYPE_FIXED32"), - 8: .same(proto: "TYPE_BOOL"), - 9: .same(proto: "TYPE_STRING"), - 10: .same(proto: "TYPE_GROUP"), - 11: .same(proto: "TYPE_MESSAGE"), - 12: .same(proto: "TYPE_BYTES"), - 13: .same(proto: "TYPE_UINT32"), - 14: .same(proto: "TYPE_ENUM"), - 15: .same(proto: "TYPE_SFIXED32"), - 16: .same(proto: "TYPE_SFIXED64"), - 17: .same(proto: "TYPE_SINT32"), - 18: .same(proto: "TYPE_SINT64"), - ] +extension Google_Protobuf_Field.Kind: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0TYPE_UNKNOWN\0\u{1}TYPE_DOUBLE\0\u{1}TYPE_FLOAT\0\u{1}TYPE_INT64\0\u{1}TYPE_UINT64\0\u{1}TYPE_INT32\0\u{1}TYPE_FIXED64\0\u{1}TYPE_FIXED32\0\u{1}TYPE_BOOL\0\u{1}TYPE_STRING\0\u{1}TYPE_GROUP\0\u{1}TYPE_MESSAGE\0\u{1}TYPE_BYTES\0\u{1}TYPE_UINT32\0\u{1}TYPE_ENUM\0\u{1}TYPE_SFIXED32\0\u{1}TYPE_SFIXED64\0\u{1}TYPE_SINT32\0\u{1}TYPE_SINT64\0") } -extension Google_Protobuf_Field.Cardinality: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "CARDINALITY_UNKNOWN"), - 1: .same(proto: "CARDINALITY_OPTIONAL"), - 2: .same(proto: "CARDINALITY_REQUIRED"), - 3: .same(proto: "CARDINALITY_REPEATED"), - ] +extension Google_Protobuf_Field.Cardinality: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0CARDINALITY_UNKNOWN\0\u{1}CARDINALITY_OPTIONAL\0\u{1}CARDINALITY_REQUIRED\0\u{1}CARDINALITY_REPEATED\0") } -extension Google_Protobuf_Enum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Enum: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Enum" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "enumvalue"), - 3: .same(proto: "options"), - 4: .standard(proto: "source_context"), - 5: .same(proto: "syntax"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}enumvalue\0\u{1}options\0\u{3}source_context\0\u{1}syntax\0\u{1}edition\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -691,12 +656,13 @@ extension Google_Protobuf_Enum: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 3: try { try decoder.decodeRepeatedMessageField(value: &self.options) }() case 4: try { try decoder.decodeSingularMessageField(value: &self._sourceContext) }() case 5: try { try decoder.decodeSingularEnumField(value: &self.syntax) }() + case 6: try { try decoder.decodeSingularStringField(value: &self.edition) }() default: break } } } - func traverse(visitor: inout V) throws { + 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 @@ -716,6 +682,9 @@ extension Google_Protobuf_Enum: SwiftProtobuf.Message, SwiftProtobuf._MessageImp if self.syntax != .proto2 { try visitor.visitSingularEnumField(value: self.syntax, fieldNumber: 5) } + if !self.edition.isEmpty { + try visitor.visitSingularStringField(value: self.edition, fieldNumber: 6) + } try unknownFields.traverse(visitor: &visitor) } @@ -725,20 +694,17 @@ extension Google_Protobuf_Enum: SwiftProtobuf.Message, SwiftProtobuf._MessageImp if lhs.options != rhs.options {return false} if lhs._sourceContext != rhs._sourceContext {return false} if lhs.syntax != rhs.syntax {return false} + if lhs.edition != rhs.edition {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_EnumValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_EnumValue: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".EnumValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "number"), - 3: .same(proto: "options"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}number\0\u{1}options\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -752,7 +718,7 @@ extension Google_Protobuf_EnumValue: SwiftProtobuf.Message, SwiftProtobuf._Messa } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if !self.name.isEmpty { try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) } @@ -774,14 +740,11 @@ extension Google_Protobuf_EnumValue: SwiftProtobuf.Message, SwiftProtobuf._Messa } } -extension Google_Protobuf_Option: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Option: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Option" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "value"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}value\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -794,7 +757,7 @@ extension Google_Protobuf_Option: SwiftProtobuf.Message, SwiftProtobuf._MessageI } } - func traverse(visitor: inout V) throws { + 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 diff --git a/Reference/google/protobuf/wrappers.pb.swift b/Reference/Sources/SwiftProtobuf/google/protobuf/wrappers.pb.swift similarity index 72% rename from Reference/google/protobuf/wrappers.pb.swift rename to Reference/Sources/SwiftProtobuf/google/protobuf/wrappers.pb.swift index c3f1b3ae7..1c8a092e9 100644 --- a/Reference/google/protobuf/wrappers.pb.swift +++ b/Reference/Sources/SwiftProtobuf/google/protobuf/wrappers.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/wrappers.proto @@ -36,11 +37,18 @@ // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Wrappers for primitive (non-message) types. These types are useful -// for embedding primitives in the `google.protobuf.Any` type and for places -// where we need to distinguish between the absence of a primitive -// typed field and its default value. +// +// Wrappers for primitive (non-message) types. These types were needed +// for legacy reasons and are not recommended for use in new APIs. +// +// Historically these wrappers were useful to have presence on proto3 primitive +// fields, but proto3 syntax has been updated to support the `optional` keyword. +// Using that keyword is now the strongly preferred way to add presence to +// proto3 primitive fields. +// +// A secondary usecase was to embed primitives in the `google.protobuf.Any` +// type: it is now recommended that you embed your value in your own wrapper +// message which can be specifically documented. // // These wrappers have no meaningful use within repeated fields as they lack // the ability to detect presence on individual elements. @@ -48,21 +56,25 @@ // individual entries of a map or fields of a oneof can already detect presence. import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } /// Wrapper message for `double`. /// /// The JSON representation for `DoubleValue` is JSON number. -struct Google_Protobuf_DoubleValue { +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +struct Google_Protobuf_DoubleValue: Sendable { // 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. @@ -70,7 +82,7 @@ struct Google_Protobuf_DoubleValue { /// The double value. var value: Double = 0 - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} } @@ -78,7 +90,10 @@ struct Google_Protobuf_DoubleValue { /// Wrapper message for `float`. /// /// The JSON representation for `FloatValue` is JSON number. -struct Google_Protobuf_FloatValue { +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +struct Google_Protobuf_FloatValue: Sendable { // 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. @@ -86,7 +101,7 @@ struct Google_Protobuf_FloatValue { /// The float value. var value: Float = 0 - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} } @@ -94,7 +109,10 @@ struct Google_Protobuf_FloatValue { /// Wrapper message for `int64`. /// /// The JSON representation for `Int64Value` is JSON string. -struct Google_Protobuf_Int64Value { +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +struct Google_Protobuf_Int64Value: Sendable { // 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. @@ -102,7 +120,7 @@ struct Google_Protobuf_Int64Value { /// The int64 value. var value: Int64 = 0 - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} } @@ -110,7 +128,10 @@ struct Google_Protobuf_Int64Value { /// Wrapper message for `uint64`. /// /// The JSON representation for `UInt64Value` is JSON string. -struct Google_Protobuf_UInt64Value { +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +struct Google_Protobuf_UInt64Value: Sendable { // 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. @@ -118,7 +139,7 @@ struct Google_Protobuf_UInt64Value { /// The uint64 value. var value: UInt64 = 0 - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} } @@ -126,7 +147,10 @@ struct Google_Protobuf_UInt64Value { /// Wrapper message for `int32`. /// /// The JSON representation for `Int32Value` is JSON number. -struct Google_Protobuf_Int32Value { +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +struct Google_Protobuf_Int32Value: Sendable { // 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. @@ -134,7 +158,7 @@ struct Google_Protobuf_Int32Value { /// The int32 value. var value: Int32 = 0 - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} } @@ -142,7 +166,10 @@ struct Google_Protobuf_Int32Value { /// Wrapper message for `uint32`. /// /// The JSON representation for `UInt32Value` is JSON number. -struct Google_Protobuf_UInt32Value { +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +struct Google_Protobuf_UInt32Value: Sendable { // 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. @@ -150,7 +177,7 @@ struct Google_Protobuf_UInt32Value { /// The uint32 value. var value: UInt32 = 0 - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} } @@ -158,7 +185,10 @@ struct Google_Protobuf_UInt32Value { /// Wrapper message for `bool`. /// /// The JSON representation for `BoolValue` is JSON `true` and `false`. -struct Google_Protobuf_BoolValue { +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +struct Google_Protobuf_BoolValue: Sendable { // 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. @@ -166,7 +196,7 @@ struct Google_Protobuf_BoolValue { /// The bool value. var value: Bool = false - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} } @@ -174,7 +204,10 @@ struct Google_Protobuf_BoolValue { /// Wrapper message for `string`. /// /// The JSON representation for `StringValue` is JSON string. -struct Google_Protobuf_StringValue { +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +struct Google_Protobuf_StringValue: Sendable { // 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. @@ -182,7 +215,7 @@ struct Google_Protobuf_StringValue { /// The string value. var value: String = String() - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} } @@ -190,7 +223,10 @@ struct Google_Protobuf_StringValue { /// Wrapper message for `bytes`. /// /// The JSON representation for `BytesValue` is JSON string. -struct Google_Protobuf_BytesValue { +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +struct Google_Protobuf_BytesValue: Sendable { // 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. @@ -198,34 +234,20 @@ struct Google_Protobuf_BytesValue { /// The bytes value. var value: Data = Data() - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = UnknownStorage() init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_DoubleValue: @unchecked Sendable {} -extension Google_Protobuf_FloatValue: @unchecked Sendable {} -extension Google_Protobuf_Int64Value: @unchecked Sendable {} -extension Google_Protobuf_UInt64Value: @unchecked Sendable {} -extension Google_Protobuf_Int32Value: @unchecked Sendable {} -extension Google_Protobuf_UInt32Value: @unchecked Sendable {} -extension Google_Protobuf_BoolValue: @unchecked Sendable {} -extension Google_Protobuf_StringValue: @unchecked Sendable {} -extension Google_Protobuf_BytesValue: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_DoubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_DoubleValue: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".DoubleValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -237,8 +259,8 @@ extension Google_Protobuf_DoubleValue: SwiftProtobuf.Message, SwiftProtobuf._Mes } } - func traverse(visitor: inout V) throws { - if self.value != 0 { + func traverse(visitor: inout V) throws { + if self.value.bitPattern != 0 { try visitor.visitSingularDoubleField(value: self.value, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) @@ -251,13 +273,11 @@ extension Google_Protobuf_DoubleValue: SwiftProtobuf.Message, SwiftProtobuf._Mes } } -extension Google_Protobuf_FloatValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_FloatValue: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".FloatValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -269,8 +289,8 @@ extension Google_Protobuf_FloatValue: SwiftProtobuf.Message, SwiftProtobuf._Mess } } - func traverse(visitor: inout V) throws { - if self.value != 0 { + func traverse(visitor: inout V) throws { + if self.value.bitPattern != 0 { try visitor.visitSingularFloatField(value: self.value, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) @@ -283,13 +303,11 @@ extension Google_Protobuf_FloatValue: SwiftProtobuf.Message, SwiftProtobuf._Mess } } -extension Google_Protobuf_Int64Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Int64Value: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Int64Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -301,7 +319,7 @@ extension Google_Protobuf_Int64Value: SwiftProtobuf.Message, SwiftProtobuf._Mess } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if self.value != 0 { try visitor.visitSingularInt64Field(value: self.value, fieldNumber: 1) } @@ -315,13 +333,11 @@ extension Google_Protobuf_Int64Value: SwiftProtobuf.Message, SwiftProtobuf._Mess } } -extension Google_Protobuf_UInt64Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_UInt64Value: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".UInt64Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -333,7 +349,7 @@ extension Google_Protobuf_UInt64Value: SwiftProtobuf.Message, SwiftProtobuf._Mes } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if self.value != 0 { try visitor.visitSingularUInt64Field(value: self.value, fieldNumber: 1) } @@ -347,13 +363,11 @@ extension Google_Protobuf_UInt64Value: SwiftProtobuf.Message, SwiftProtobuf._Mes } } -extension Google_Protobuf_Int32Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Int32Value: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Int32Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -365,7 +379,7 @@ extension Google_Protobuf_Int32Value: SwiftProtobuf.Message, SwiftProtobuf._Mess } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if self.value != 0 { try visitor.visitSingularInt32Field(value: self.value, fieldNumber: 1) } @@ -379,13 +393,11 @@ extension Google_Protobuf_Int32Value: SwiftProtobuf.Message, SwiftProtobuf._Mess } } -extension Google_Protobuf_UInt32Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_UInt32Value: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".UInt32Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -397,7 +409,7 @@ extension Google_Protobuf_UInt32Value: SwiftProtobuf.Message, SwiftProtobuf._Mes } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if self.value != 0 { try visitor.visitSingularUInt32Field(value: self.value, fieldNumber: 1) } @@ -411,13 +423,11 @@ extension Google_Protobuf_UInt32Value: SwiftProtobuf.Message, SwiftProtobuf._Mes } } -extension Google_Protobuf_BoolValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_BoolValue: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".BoolValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -429,7 +439,7 @@ extension Google_Protobuf_BoolValue: SwiftProtobuf.Message, SwiftProtobuf._Messa } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if self.value != false { try visitor.visitSingularBoolField(value: self.value, fieldNumber: 1) } @@ -443,13 +453,11 @@ extension Google_Protobuf_BoolValue: SwiftProtobuf.Message, SwiftProtobuf._Messa } } -extension Google_Protobuf_StringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_StringValue: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".StringValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -461,7 +469,7 @@ extension Google_Protobuf_StringValue: SwiftProtobuf.Message, SwiftProtobuf._Mes } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if !self.value.isEmpty { try visitor.visitSingularStringField(value: self.value, fieldNumber: 1) } @@ -475,13 +483,11 @@ extension Google_Protobuf_StringValue: SwiftProtobuf.Message, SwiftProtobuf._Mes } } -extension Google_Protobuf_BytesValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_BytesValue: Message, _MessageImplementationBase, _ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".BytesValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") - mutating func decodeMessage(decoder: inout D) throws { + 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 @@ -493,7 +499,7 @@ extension Google_Protobuf_BytesValue: SwiftProtobuf.Message, SwiftProtobuf._Mess } } - func traverse(visitor: inout V) throws { + func traverse(visitor: inout V) throws { if !self.value.isEmpty { try visitor.visitSingularBytesField(value: self.value, fieldNumber: 1) } diff --git a/Reference/google/protobuf/compiler/plugin.pb.swift b/Reference/Sources/SwiftProtobufPluginLibrary/google/protobuf/compiler/plugin.pb.swift similarity index 80% rename from Reference/google/protobuf/compiler/plugin.pb.swift rename to Reference/Sources/SwiftProtobufPluginLibrary/google/protobuf/compiler/plugin.pb.swift index 6a0d1e78f..930d2c42c 100644 --- a/Reference/google/protobuf/compiler/plugin.pb.swift +++ b/Reference/Sources/SwiftProtobufPluginLibrary/google/protobuf/compiler/plugin.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/compiler/plugin.proto @@ -9,39 +10,13 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd // Author: kenton@google.com (Kenton Varda) // -// WARNING: The plugin interface is currently EXPERIMENTAL and is subject to -// change. -// // protoc (aka the Protocol Compiler) can be extended via plugins. A plugin is // just a program that reads a CodeGeneratorRequest from stdin and writes a // CodeGeneratorResponse to stdout. @@ -53,7 +28,6 @@ // plugin should be named "protoc-gen-$NAME", and will then be used when the // flag "--${NAME}_out" is passed to protoc. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -67,46 +41,46 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP } /// The version number of protocol compiler. -struct Google_Protobuf_Compiler_Version { +struct Google_Protobuf_Compiler_Version: Sendable { // 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 major: Int32 { - get {return _major ?? 0} + get {_major ?? 0} set {_major = newValue} } /// Returns true if `major` has been explicitly set. - var hasMajor: Bool {return self._major != nil} + var hasMajor: Bool {self._major != nil} /// Clears the value of `major`. Subsequent reads from it will return its default value. mutating func clearMajor() {self._major = nil} var minor: Int32 { - get {return _minor ?? 0} + get {_minor ?? 0} set {_minor = newValue} } /// Returns true if `minor` has been explicitly set. - var hasMinor: Bool {return self._minor != nil} + var hasMinor: Bool {self._minor != nil} /// Clears the value of `minor`. Subsequent reads from it will return its default value. mutating func clearMinor() {self._minor = nil} var patch: Int32 { - get {return _patch ?? 0} + get {_patch ?? 0} set {_patch = newValue} } /// Returns true if `patch` has been explicitly set. - var hasPatch: Bool {return self._patch != nil} + var hasPatch: Bool {self._patch != nil} /// Clears the value of `patch`. Subsequent reads from it will return its default value. mutating func clearPatch() {self._patch = nil} /// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should /// be empty for mainline stable releases. var suffix: String { - get {return _suffix ?? String()} + get {_suffix ?? String()} set {_suffix = newValue} } /// Returns true if `suffix` has been explicitly set. - var hasSuffix: Bool {return self._suffix != nil} + var hasSuffix: Bool {self._suffix != nil} /// Clears the value of `suffix`. Subsequent reads from it will return its default value. mutating func clearSuffix() {self._suffix = nil} @@ -121,7 +95,7 @@ struct Google_Protobuf_Compiler_Version { } /// An encoded CodeGeneratorRequest is written to the plugin's stdin. -struct Google_Protobuf_Compiler_CodeGeneratorRequest { +struct Google_Protobuf_Compiler_CodeGeneratorRequest: Sendable { // 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. @@ -133,11 +107,11 @@ struct Google_Protobuf_Compiler_CodeGeneratorRequest { /// The generator parameter passed on the command-line. var parameter: String { - get {return _parameter ?? String()} + get {_parameter ?? String()} set {_parameter = newValue} } /// Returns true if `parameter` has been explicitly set. - var hasParameter: Bool {return self._parameter != nil} + var hasParameter: Bool {self._parameter != nil} /// Clears the value of `parameter`. Subsequent reads from it will return its default value. mutating func clearParameter() {self._parameter = nil} @@ -145,6 +119,11 @@ struct Google_Protobuf_Compiler_CodeGeneratorRequest { /// they import. The files will appear in topological order, so each file /// appears before any file that imports it. /// + /// Note: the files listed in files_to_generate will include runtime-retention + /// options only, but all other files will include source-retention options. + /// The source_file_descriptors field below is available in case you need + /// source-retention options for files_to_generate. + /// /// protoc guarantees that all proto_files will be written after /// the fields above, even though this is not technically guaranteed by the /// protobuf wire format. This theoretically could allow a plugin to stream @@ -157,13 +136,18 @@ struct Google_Protobuf_Compiler_CodeGeneratorRequest { /// fully qualified. var protoFile: [SwiftProtobuf.Google_Protobuf_FileDescriptorProto] = [] + /// File descriptors with all options, including source-retention options. + /// These descriptors are only provided for the files listed in + /// files_to_generate. + var sourceFileDescriptors: [SwiftProtobuf.Google_Protobuf_FileDescriptorProto] = [] + /// The version number of protocol compiler. var compilerVersion: Google_Protobuf_Compiler_Version { - get {return _compilerVersion ?? Google_Protobuf_Compiler_Version()} + get {_compilerVersion ?? Google_Protobuf_Compiler_Version()} set {_compilerVersion = newValue} } /// Returns true if `compilerVersion` has been explicitly set. - var hasCompilerVersion: Bool {return self._compilerVersion != nil} + var hasCompilerVersion: Bool {self._compilerVersion != nil} /// Clears the value of `compilerVersion`. Subsequent reads from it will return its default value. mutating func clearCompilerVersion() {self._compilerVersion = nil} @@ -176,7 +160,7 @@ struct Google_Protobuf_Compiler_CodeGeneratorRequest { } /// The plugin writes an encoded CodeGeneratorResponse to stdout. -struct Google_Protobuf_Compiler_CodeGeneratorResponse { +struct Google_Protobuf_Compiler_CodeGeneratorResponse: Sendable { // 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. @@ -190,58 +174,69 @@ struct Google_Protobuf_Compiler_CodeGeneratorResponse { /// unparseable -- should be reported by writing a message to stderr and /// exiting with a non-zero status code. var error: String { - get {return _error ?? String()} + get {_error ?? String()} set {_error = newValue} } /// Returns true if `error` has been explicitly set. - var hasError: Bool {return self._error != nil} + var hasError: Bool {self._error != nil} /// Clears the value of `error`. Subsequent reads from it will return its default value. mutating func clearError() {self._error = nil} /// A bitmask of supported features that the code generator supports. /// This is a bitwise "or" of values from the Feature enum. var supportedFeatures: UInt64 { - get {return _supportedFeatures ?? 0} + get {_supportedFeatures ?? 0} set {_supportedFeatures = newValue} } /// Returns true if `supportedFeatures` has been explicitly set. - var hasSupportedFeatures: Bool {return self._supportedFeatures != nil} + var hasSupportedFeatures: Bool {self._supportedFeatures != nil} /// Clears the value of `supportedFeatures`. Subsequent reads from it will return its default value. mutating func clearSupportedFeatures() {self._supportedFeatures = nil} + /// The minimum edition this plugin supports. This will be treated as an + /// Edition enum, but we want to allow unknown values. It should be specified + /// according the edition enum value, *not* the edition number. Only takes + /// effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + var minimumEdition: Int32 { + get {_minimumEdition ?? 0} + set {_minimumEdition = newValue} + } + /// Returns true if `minimumEdition` has been explicitly set. + var hasMinimumEdition: Bool {self._minimumEdition != nil} + /// Clears the value of `minimumEdition`. Subsequent reads from it will return its default value. + mutating func clearMinimumEdition() {self._minimumEdition = nil} + + /// The maximum edition this plugin supports. This will be treated as an + /// Edition enum, but we want to allow unknown values. It should be specified + /// according the edition enum value, *not* the edition number. Only takes + /// effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + var maximumEdition: Int32 { + get {_maximumEdition ?? 0} + set {_maximumEdition = newValue} + } + /// Returns true if `maximumEdition` has been explicitly set. + var hasMaximumEdition: Bool {self._maximumEdition != nil} + /// Clears the value of `maximumEdition`. Subsequent reads from it will return its default value. + mutating func clearMaximumEdition() {self._maximumEdition = nil} + var file: [Google_Protobuf_Compiler_CodeGeneratorResponse.File] = [] var unknownFields = SwiftProtobuf.UnknownStorage() /// Sync with code_generator.h. - enum Feature: SwiftProtobuf.Enum { - typealias RawValue = Int - case none // = 0 - case proto3Optional // = 1 + enum Feature: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case none = 0 + case proto3Optional = 1 + case supportsEditions = 2 init() { self = .none } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .none - case 1: self = .proto3Optional - default: return nil - } - } - - var rawValue: Int { - switch self { - case .none: return 0 - case .proto3Optional: return 1 - } - } - } /// Represents a single generated file. - struct File { + struct File: Sendable { // 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. @@ -258,11 +253,11 @@ struct Google_Protobuf_Compiler_CodeGeneratorResponse { /// this writing protoc does not optimize for this -- it will read the entire /// CodeGeneratorResponse before writing files to disk. var name: String { - get {return _name ?? String()} + get {_name ?? String()} set {_name = newValue} } /// Returns true if `name` has been explicitly set. - var hasName: Bool {return self._name != nil} + var hasName: Bool {self._name != nil} /// Clears the value of `name`. Subsequent reads from it will return its default value. mutating func clearName() {self._name = nil} @@ -304,21 +299,21 @@ struct Google_Protobuf_Compiler_CodeGeneratorResponse { /// /// If |insertion_point| is present, |name| must also be present. var insertionPoint: String { - get {return _insertionPoint ?? String()} + get {_insertionPoint ?? String()} set {_insertionPoint = newValue} } /// Returns true if `insertionPoint` has been explicitly set. - var hasInsertionPoint: Bool {return self._insertionPoint != nil} + var hasInsertionPoint: Bool {self._insertionPoint != nil} /// Clears the value of `insertionPoint`. Subsequent reads from it will return its default value. mutating func clearInsertionPoint() {self._insertionPoint = nil} /// The file contents. var content: String { - get {return _content ?? String()} + get {_content ?? String()} set {_content = newValue} } /// Returns true if `content` has been explicitly set. - var hasContent: Bool {return self._content != nil} + var hasContent: Bool {self._content != nil} /// Clears the value of `content`. Subsequent reads from it will return its default value. mutating func clearContent() {self._content = nil} @@ -326,11 +321,11 @@ struct Google_Protobuf_Compiler_CodeGeneratorResponse { /// point is used, this information will be appropriately offset and inserted /// into the code generation metadata for the generated files. var generatedCodeInfo: SwiftProtobuf.Google_Protobuf_GeneratedCodeInfo { - get {return _generatedCodeInfo ?? SwiftProtobuf.Google_Protobuf_GeneratedCodeInfo()} + get {_generatedCodeInfo ?? SwiftProtobuf.Google_Protobuf_GeneratedCodeInfo()} set {_generatedCodeInfo = newValue} } /// Returns true if `generatedCodeInfo` has been explicitly set. - var hasGeneratedCodeInfo: Bool {return self._generatedCodeInfo != nil} + var hasGeneratedCodeInfo: Bool {self._generatedCodeInfo != nil} /// Clears the value of `generatedCodeInfo`. Subsequent reads from it will return its default value. mutating func clearGeneratedCodeInfo() {self._generatedCodeInfo = nil} @@ -348,36 +343,17 @@ struct Google_Protobuf_Compiler_CodeGeneratorResponse { fileprivate var _error: String? = nil fileprivate var _supportedFeatures: UInt64? = nil + fileprivate var _minimumEdition: Int32? = nil + fileprivate var _maximumEdition: Int32? = nil } -#if swift(>=4.2) - -extension Google_Protobuf_Compiler_CodeGeneratorResponse.Feature: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_Compiler_Version: @unchecked Sendable {} -extension Google_Protobuf_Compiler_CodeGeneratorRequest: @unchecked Sendable {} -extension Google_Protobuf_Compiler_CodeGeneratorResponse: @unchecked Sendable {} -extension Google_Protobuf_Compiler_CodeGeneratorResponse.Feature: @unchecked Sendable {} -extension Google_Protobuf_Compiler_CodeGeneratorResponse.File: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf.compiler" extension Google_Protobuf_Compiler_Version: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Version" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "major"), - 2: .same(proto: "minor"), - 3: .same(proto: "patch"), - 4: .same(proto: "suffix"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}major\0\u{1}minor\0\u{1}patch\0\u{1}suffix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -426,15 +402,11 @@ extension Google_Protobuf_Compiler_Version: SwiftProtobuf.Message, SwiftProtobuf extension Google_Protobuf_Compiler_CodeGeneratorRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".CodeGeneratorRequest" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "file_to_generate"), - 2: .same(proto: "parameter"), - 15: .standard(proto: "proto_file"), - 3: .standard(proto: "compiler_version"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}file_to_generate\0\u{1}parameter\0\u{3}compiler_version\0\u{4}\u{c}proto_file\0\u{4}\u{2}source_file_descriptors\0") public var isInitialized: Bool { if !SwiftProtobuf.Internal.areAllInitialized(self.protoFile) {return false} + if !SwiftProtobuf.Internal.areAllInitialized(self.sourceFileDescriptors) {return false} return true } @@ -448,6 +420,7 @@ extension Google_Protobuf_Compiler_CodeGeneratorRequest: SwiftProtobuf.Message, case 2: try { try decoder.decodeSingularStringField(value: &self._parameter) }() case 3: try { try decoder.decodeSingularMessageField(value: &self._compilerVersion) }() case 15: try { try decoder.decodeRepeatedMessageField(value: &self.protoFile) }() + case 17: try { try decoder.decodeRepeatedMessageField(value: &self.sourceFileDescriptors) }() default: break } } @@ -470,6 +443,9 @@ extension Google_Protobuf_Compiler_CodeGeneratorRequest: SwiftProtobuf.Message, if !self.protoFile.isEmpty { try visitor.visitRepeatedMessageField(value: self.protoFile, fieldNumber: 15) } + if !self.sourceFileDescriptors.isEmpty { + try visitor.visitRepeatedMessageField(value: self.sourceFileDescriptors, fieldNumber: 17) + } try unknownFields.traverse(visitor: &visitor) } @@ -477,6 +453,7 @@ extension Google_Protobuf_Compiler_CodeGeneratorRequest: SwiftProtobuf.Message, if lhs.fileToGenerate != rhs.fileToGenerate {return false} if lhs._parameter != rhs._parameter {return false} if lhs.protoFile != rhs.protoFile {return false} + if lhs.sourceFileDescriptors != rhs.sourceFileDescriptors {return false} if lhs._compilerVersion != rhs._compilerVersion {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true @@ -485,11 +462,7 @@ extension Google_Protobuf_Compiler_CodeGeneratorRequest: SwiftProtobuf.Message, extension Google_Protobuf_Compiler_CodeGeneratorResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".CodeGeneratorResponse" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "error"), - 2: .standard(proto: "supported_features"), - 15: .same(proto: "file"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}error\0\u{3}supported_features\0\u{3}minimum_edition\0\u{3}maximum_edition\0\u{2}\u{b}file\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -499,6 +472,8 @@ extension Google_Protobuf_Compiler_CodeGeneratorResponse: SwiftProtobuf.Message, switch fieldNumber { case 1: try { try decoder.decodeSingularStringField(value: &self._error) }() case 2: try { try decoder.decodeSingularUInt64Field(value: &self._supportedFeatures) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._minimumEdition) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &self._maximumEdition) }() case 15: try { try decoder.decodeRepeatedMessageField(value: &self.file) }() default: break } @@ -516,6 +491,12 @@ extension Google_Protobuf_Compiler_CodeGeneratorResponse: SwiftProtobuf.Message, try { if let v = self._supportedFeatures { try visitor.visitSingularUInt64Field(value: v, fieldNumber: 2) } }() + try { if let v = self._minimumEdition { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._maximumEdition { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() if !self.file.isEmpty { try visitor.visitRepeatedMessageField(value: self.file, fieldNumber: 15) } @@ -525,6 +506,8 @@ extension Google_Protobuf_Compiler_CodeGeneratorResponse: SwiftProtobuf.Message, static func ==(lhs: Google_Protobuf_Compiler_CodeGeneratorResponse, rhs: Google_Protobuf_Compiler_CodeGeneratorResponse) -> Bool { if lhs._error != rhs._error {return false} if lhs._supportedFeatures != rhs._supportedFeatures {return false} + if lhs._minimumEdition != rhs._minimumEdition {return false} + if lhs._maximumEdition != rhs._maximumEdition {return false} if lhs.file != rhs.file {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true @@ -532,20 +515,12 @@ extension Google_Protobuf_Compiler_CodeGeneratorResponse: SwiftProtobuf.Message, } extension Google_Protobuf_Compiler_CodeGeneratorResponse.Feature: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FEATURE_NONE"), - 1: .same(proto: "FEATURE_PROTO3_OPTIONAL"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FEATURE_NONE\0\u{1}FEATURE_PROTO3_OPTIONAL\0\u{1}FEATURE_SUPPORTS_EDITIONS\0") } extension Google_Protobuf_Compiler_CodeGeneratorResponse.File: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = Google_Protobuf_Compiler_CodeGeneratorResponse.protoMessageName + ".File" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .standard(proto: "insertion_point"), - 15: .same(proto: "content"), - 16: .standard(proto: "generated_code_info"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}name\0\u{3}insertion_point\0\u{2}\u{d}content\0\u{3}generated_code_info\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { diff --git a/Reference/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.pb.swift b/Reference/Sources/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.pb.swift similarity index 89% rename from Reference/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.pb.swift rename to Reference/Sources/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.pb.swift index 5ea9e7641..968dbe0e1 100644 --- a/Reference/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.pb.swift +++ b/Reference/Sources/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.proto +// Source: swift_protobuf_module_mappings.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -17,7 +18,6 @@ // See http://swift.org/LICENSE.txt for license information // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -32,7 +32,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// Configuration used to define the mappings for generated proto files /// to the Swift module they will be included in. -struct SwiftProtobuf_GenSwift_ModuleMappings { +struct SwiftProtobuf_GenSwift_ModuleMappings: Sendable { // 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. @@ -44,7 +44,7 @@ struct SwiftProtobuf_GenSwift_ModuleMappings { /// Individual listing of the module name and the files that will go /// into it. - struct Entry { + struct Entry: Sendable { // 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. @@ -67,20 +67,13 @@ struct SwiftProtobuf_GenSwift_ModuleMappings { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension SwiftProtobuf_GenSwift_ModuleMappings: @unchecked Sendable {} -extension SwiftProtobuf_GenSwift_ModuleMappings.Entry: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "swift_protobuf.gen_swift" extension SwiftProtobuf_GenSwift_ModuleMappings: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ModuleMappings" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mapping"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mapping\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -110,10 +103,7 @@ extension SwiftProtobuf_GenSwift_ModuleMappings: SwiftProtobuf.Message, SwiftPro extension SwiftProtobuf_GenSwift_ModuleMappings.Entry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = SwiftProtobuf_GenSwift_ModuleMappings.protoMessageName + ".Entry" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "module_name"), - 2: .standard(proto: "proto_file_path"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}module_name\0\u{3}proto_file_path\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { diff --git a/Reference/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_delimited.pb.swift b/Reference/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_delimited.pb.swift new file mode 100644 index 000000000..cc9c8b132 --- /dev/null +++ b/Reference/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_delimited.pb.swift @@ -0,0 +1,188 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: pluginlib_descriptor_delimited.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 - 2024 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 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 SwiftDescriptorTest_EditionsMessageForDelimited: @unchecked Sendable { + // 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 scalarField: Int32 { + get {_storage._scalarField ?? 0} + set {_uniqueStorage()._scalarField = newValue} + } + /// Returns true if `scalarField` has been explicitly set. + var hasScalarField: Bool {_storage._scalarField != nil} + /// Clears the value of `scalarField`. Subsequent reads from it will return its default value. + mutating func clearScalarField() {_uniqueStorage()._scalarField = nil} + + var mapField: Dictionary { + get {_storage._mapField} + set {_uniqueStorage()._mapField = newValue} + } + + var messageMapField: Dictionary { + get {_storage._messageMapField} + set {_uniqueStorage()._messageMapField = newValue} + } + + var delimitedField: SwiftDescriptorTest_EditionsMessageForDelimited { + get {_storage._delimitedField ?? SwiftDescriptorTest_EditionsMessageForDelimited()} + set {_uniqueStorage()._delimitedField = newValue} + } + /// Returns true if `delimitedField` has been explicitly set. + var hasDelimitedField: Bool {_storage._delimitedField != nil} + /// Clears the value of `delimitedField`. Subsequent reads from it will return its default value. + mutating func clearDelimitedField() {_uniqueStorage()._delimitedField = nil} + + var lengthPrefixedField: SwiftDescriptorTest_EditionsMessageForDelimited { + get {_storage._lengthPrefixedField ?? SwiftDescriptorTest_EditionsMessageForDelimited()} + set {_uniqueStorage()._lengthPrefixedField = newValue} + } + /// Returns true if `lengthPrefixedField` has been explicitly set. + var hasLengthPrefixedField: Bool {_storage._lengthPrefixedField != nil} + /// Clears the value of `lengthPrefixedField`. Subsequent reads from it will return its default value. + mutating func clearLengthPrefixedField() {_uniqueStorage()._lengthPrefixedField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_descriptor_test" + +extension SwiftDescriptorTest_EditionsMessageForDelimited: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EditionsMessageForDelimited" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}scalar_field\0\u{3}map_field\0\u{3}message_map_field\0\u{3}delimited_field\0\u{3}length_prefixed_field\0") + + fileprivate class _StorageClass { + var _scalarField: Int32? = nil + var _mapField: Dictionary = [:] + var _messageMapField: Dictionary = [:] + var _delimitedField: SwiftDescriptorTest_EditionsMessageForDelimited? = nil + var _lengthPrefixedField: SwiftDescriptorTest_EditionsMessageForDelimited? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _scalarField = source._scalarField + _mapField = source._mapField + _messageMapField = source._messageMapField + _delimitedField = source._delimitedField + _lengthPrefixedField = source._lengthPrefixedField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._scalarField) }() + case 2: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapField) }() + case 3: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._messageMapField) }() + case 4: try { try decoder.decodeSingularGroupField(value: &_storage._delimitedField) }() + case 5: try { try decoder.decodeSingularMessageField(value: &_storage._lengthPrefixedField) }() + default: break + } + } + } + } + + func traverse(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._scalarField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + if !_storage._mapField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapField, fieldNumber: 2) + } + if !_storage._messageMapField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._messageMapField, fieldNumber: 3) + } + try { if let v = _storage._delimitedField { + try visitor.visitSingularGroupField(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._lengthPrefixedField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftDescriptorTest_EditionsMessageForDelimited, rhs: SwiftDescriptorTest_EditionsMessageForDelimited) -> 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._scalarField != rhs_storage._scalarField {return false} + if _storage._mapField != rhs_storage._mapField {return false} + if _storage._messageMapField != rhs_storage._messageMapField {return false} + if _storage._delimitedField != rhs_storage._delimitedField {return false} + if _storage._lengthPrefixedField != rhs_storage._lengthPrefixedField {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/pluginlib_descriptor_test.pb.swift b/Reference/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test.pb.swift similarity index 57% rename from Reference/pluginlib_descriptor_test.pb.swift rename to Reference/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test.pb.swift index ba72c7f1e..0d4e2ee32 100644 --- a/Reference/pluginlib_descriptor_test.pb.swift +++ b/Reference/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: pluginlib_descriptor_test.proto @@ -23,7 +24,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -36,63 +36,37 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum SDTTopLevelEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case valueZero // = 0 - case valueOne // = 1 - case valueTwo // = 2 +enum SDTTopLevelEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + 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 { +struct SDTTopLevelMessage: @unchecked Sendable { // 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()} + get {_storage._field1 ?? String()} set {_uniqueStorage()._field1 = newValue} } /// Returns true if `field1` has been explicitly set. - var hasField1: Bool {return _storage._field1 != nil} + var hasField1: Bool {_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} + get {_storage._field2 ?? 0} set {_uniqueStorage()._field2 = newValue} } /// Returns true if `field2` has been explicitly set. - var hasField2: Bool {return _storage._field2 != nil} + var hasField2: Bool {_storage._field2 != nil} /// Clears the value of `field2`. Subsequent reads from it will return its default value. mutating func clearField2() {_uniqueStorage()._field2 = nil} @@ -135,98 +109,54 @@ struct SDTTopLevelMessage { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_O: Equatable { + enum OneOf_O: Equatable, Sendable { 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 + enum SubEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + 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 { + struct SubMessage: @unchecked Sendable { // 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} + get {_storage._field1 ?? 0} set {_uniqueStorage()._field1 = newValue} } /// Returns true if `field1` has been explicitly set. - var hasField1: Bool {return _storage._field1 != nil} + var hasField1: Bool {_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()} + get {_storage._field2 ?? String()} set {_uniqueStorage()._field2 = newValue} } /// Returns true if `field2` has been explicitly set. - var hasField2: Bool {return _storage._field2 != nil} + var hasField2: Bool {_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()} + get {_storage._field3 ?? SDTTopLevelMessage.SubMessage()} set {_uniqueStorage()._field3 = newValue} } /// Returns true if `field3` has been explicitly set. - var hasField3: Bool {return _storage._field3 != nil} + var hasField3: Bool {_storage._field3 != nil} /// Clears the value of `field3`. Subsequent reads from it will return its default value. mutating func clearField3() {_uniqueStorage()._field3 = nil} @@ -242,34 +172,26 @@ struct SDTTopLevelMessage { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension SDTTopLevelMessage.SubEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct SDTTopLevelMessage2 { +struct SDTTopLevelMessage2: @unchecked Sendable { // 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()} + get {_storage._left ?? SDTTopLevelMessage()} set {_uniqueStorage()._left = newValue} } /// Returns true if `left` has been explicitly set. - var hasLeft: Bool {return _storage._left != nil} + var hasLeft: Bool {_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()} + get {_storage._right ?? SDTTopLevelMessage2()} set {_uniqueStorage()._right = newValue} } /// Returns true if `right` has been explicitly set. - var hasRight: Bool {return _storage._right != nil} + var hasRight: Bool {_storage._right != nil} /// Clears the value of `right`. Subsequent reads from it will return its default value. mutating func clearRight() {_uniqueStorage()._right = nil} @@ -280,37 +202,38 @@ struct SDTTopLevelMessage2 { fileprivate var _storage = _StorageClass.defaultInstance } -struct SDTExternalRefs { +struct SDTExternalRefs: Sendable { // 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 _storage._desc ?? SwiftProtobuf.Google_Protobuf_DescriptorProto()} - set {_uniqueStorage()._desc = newValue} + var one: SwiftDescriptorTest_Import_ExtendableOne { + get {_one ?? SwiftDescriptorTest_Import_ExtendableOne()} + set {_one = newValue} } - /// Returns true if `desc` has been explicitly set. - var hasDesc: Bool {return _storage._desc != nil} - /// Clears the value of `desc`. Subsequent reads from it will return its default value. - mutating func clearDesc() {_uniqueStorage()._desc = nil} + /// Returns true if `one` has been explicitly set. + var hasOne: Bool {self._one != nil} + /// Clears the value of `one`. Subsequent reads from it will return its default value. + mutating func clearOne() {self._one = nil} - var ver: Google_Protobuf_Compiler_Version { - get {return _storage._ver ?? Google_Protobuf_Compiler_Version()} - set {_uniqueStorage()._ver = newValue} + var ver: SwiftDescriptorTest_Import_Version { + get {_ver ?? SwiftDescriptorTest_Import_Version()} + set {_ver = newValue} } /// Returns true if `ver` has been explicitly set. - var hasVer: Bool {return _storage._ver != nil} + var hasVer: Bool {self._ver != nil} /// Clears the value of `ver`. Subsequent reads from it will return its default value. - mutating func clearVer() {_uniqueStorage()._ver = nil} + mutating func clearVer() {self._ver = nil} var unknownFields = SwiftProtobuf.UnknownStorage() init() {} - fileprivate var _storage = _StorageClass.defaultInstance + fileprivate var _one: SwiftDescriptorTest_Import_ExtendableOne? = nil + fileprivate var _ver: SwiftDescriptorTest_Import_Version? = nil } -struct SDTScoperForExt { +struct SDTScoperForExt: Sendable { // 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. @@ -320,80 +243,80 @@ struct SDTScoperForExt { init() {} } -struct SDTProto2MessageForPresence { +struct SDTProto2MessageForPresence: Sendable { // 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()} + get {_reqStrField ?? String()} set {_reqStrField = newValue} } /// Returns true if `reqStrField` has been explicitly set. - var hasReqStrField: Bool {return self._reqStrField != nil} + var hasReqStrField: Bool {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} + get {_reqInt32Field ?? 0} set {_reqInt32Field = newValue} } /// Returns true if `reqInt32Field` has been explicitly set. - var hasReqInt32Field: Bool {return self._reqInt32Field != nil} + var hasReqInt32Field: Bool {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} + get {_reqEnumField ?? .valueZero} set {_reqEnumField = newValue} } /// Returns true if `reqEnumField` has been explicitly set. - var hasReqEnumField: Bool {return self._reqEnumField != nil} + var hasReqEnumField: Bool {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()} + get {_reqMessageField ?? SDTTopLevelMessage()} set {_reqMessageField = newValue} } /// Returns true if `reqMessageField` has been explicitly set. - var hasReqMessageField: Bool {return self._reqMessageField != nil} + var hasReqMessageField: Bool {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()} + get {_optStrField ?? String()} set {_optStrField = newValue} } /// Returns true if `optStrField` has been explicitly set. - var hasOptStrField: Bool {return self._optStrField != nil} + var hasOptStrField: Bool {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} + get {_optInt32Field ?? 0} set {_optInt32Field = newValue} } /// Returns true if `optInt32Field` has been explicitly set. - var hasOptInt32Field: Bool {return self._optInt32Field != nil} + var hasOptInt32Field: Bool {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} + get {_optEnumField ?? .valueZero} set {_optEnumField = newValue} } /// Returns true if `optEnumField` has been explicitly set. - var hasOptEnumField: Bool {return self._optEnumField != nil} + var hasOptEnumField: Bool {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()} + get {_optMessageField ?? SDTTopLevelMessage()} set {_optMessageField = newValue} } /// Returns true if `optMessageField` has been explicitly set. - var hasOptMessageField: Bool {return self._optMessageField != nil} + var hasOptMessageField: Bool {self._optMessageField != nil} /// Clears the value of `optMessageField`. Subsequent reads from it will return its default value. mutating func clearOptMessageField() {self._optMessageField = nil} @@ -441,38 +364,12 @@ struct SDTProto2MessageForPresence { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_O: Equatable { + enum OneOf_O: Equatable, Sendable { 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() {} @@ -487,172 +384,16 @@ struct SDTProto2MessageForPresence { 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 +// Swift Extensions on the extended 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 { +extension SwiftDescriptorTest_Import_ExtendableOne { var SDTextStr: String { get {return getExtensionValue(ext: SDTExtensions_ext_str) ?? String()} @@ -670,7 +411,7 @@ extension SwiftProtobuf.Google_Protobuf_FieldOptions { } } -extension SwiftProtobuf.Google_Protobuf_MessageOptions { +extension SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo { var SDTScoperForExt_extEnum: SDTTopLevelEnum { get {return getExtensionValue(ext: SDTScoperForExt.Extensions.ext_enum) ?? .valueZero} @@ -720,19 +461,19 @@ let SDTPluginlibDescriptorTest_Extensions: SwiftProtobuf.SimpleExtensionMap = [ // 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.Google_Protobuf_FieldOptions>( +let SDTExtensions_ext_str = SwiftProtobuf.MessageExtension, SwiftDescriptorTest_Import_ExtendableOne>( _protobuf_fieldNumber: 90000, fieldName: "swift_descriptor_test.ext_str" ) extension SDTScoperForExt { enum Extensions { - static let ext_enum = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + static let ext_enum = SwiftProtobuf.MessageExtension, SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo>( _protobuf_fieldNumber: 99001, fieldName: "swift_descriptor_test.ScoperForExt.ext_enum" ) - static let ext_msg = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + static let ext_msg = SwiftProtobuf.MessageExtension, SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo>( _protobuf_fieldNumber: 99002, fieldName: "swift_descriptor_test.ScoperForExt.ext_msg" ) @@ -744,30 +485,23 @@ extension SDTScoperForExt { 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"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0VALUE_ZERO\0\u{1}VALUE_ONE\0\u{1}VALUE_TWO\0") } 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"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field1\0\u{1}field2\0\u{1}field3\0\u{1}field4\0\u{1}field5\0\u{1}field6\0") fileprivate class _StorageClass { var _field1: String? = nil var _field2: Int32? = nil var _o: SDTTopLevelMessage.OneOf_O? - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -896,27 +630,23 @@ extension SDTTopLevelMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImple } 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"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0SUB_VALUE_0\0\u{1}SUB_VALUE_1\0\u{1}SUB_VALUE_2\0") } 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"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field1\0\u{1}field2\0\u{1}field3\0") fileprivate class _StorageClass { var _field1: Int32? = nil var _field2: String? = nil var _field3: SDTTopLevelMessage.SubMessage? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -989,16 +719,17 @@ extension SDTTopLevelMessage.SubMessage: SwiftProtobuf.Message, SwiftProtobuf._M 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"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}left\0\u{1}right\0") fileprivate class _StorageClass { var _left: SDTTopLevelMessage? = nil var _right: SDTTopLevelMessage2? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1065,82 +796,43 @@ extension SDTTopLevelMessage2: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl 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"), - ] - - fileprivate class _StorageClass { - var _desc: SwiftProtobuf.Google_Protobuf_DescriptorProto? = nil - var _ver: Google_Protobuf_Compiler_Version? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _desc = source._desc - _ver = source._ver - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}one\0\u{1}ver\0") public var isInitialized: Bool { - return withExtendedLifetime(_storage) { (_storage: _StorageClass) in - if let v = _storage._desc, !v.isInitialized {return false} - return true - } + if let v = self._one, !v.isInitialized {return false} + return true } mutating func decodeMessage(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._desc) }() - case 2: try { try decoder.decodeSingularMessageField(value: &_storage._ver) }() - default: break - } + 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._one) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._ver) }() + default: break } } } func traverse(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._desc { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._ver { - try visitor.visitSingularMessageField(value: v, fieldNumber: 2) - } }() - } + // 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._one { + 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._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._desc != rhs_storage._desc {return false} - if _storage._ver != rhs_storage._ver {return false} - return true - } - if !storagesAreEqual {return false} - } + if lhs._one != rhs._one {return false} + if lhs._ver != rhs._ver {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } @@ -1151,8 +843,8 @@ extension SDTScoperForExt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplemen static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { @@ -1167,24 +859,7 @@ extension SDTScoperForExt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplemen 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"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}req_str_field\0\u{3}req_int32_field\0\u{3}req_enum_field\0\u{3}req_message_field\0\u{4}\u{7}opt_str_field\0\u{3}opt_int32_field\0\u{3}opt_enum_field\0\u{3}opt_message_field\0\u{4}\u{7}repeat_str_field\0\u{3}repeat_int32_field\0\u{3}repeat_enum_field\0\u{3}repeat_message_field\0\u{4}\u{7}oneof_str_field\0\u{3}oneof_int32_field\0\u{3}oneof_enum_field\0\u{3}oneof_message_field\0") public var isInitialized: Bool { if self._reqStrField == nil {return false} @@ -1335,179 +1010,3 @@ extension SDTProto2MessageForPresence: SwiftProtobuf.Message, SwiftProtobuf._Mes 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(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(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(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(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(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(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 - } -} diff --git a/Reference/pluginlib_descriptor_test2.pb.swift b/Reference/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test2.pb.swift similarity index 78% rename from Reference/pluginlib_descriptor_test2.pb.swift rename to Reference/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test2.pb.swift index fcfb2606f..13075892e 100644 --- a/Reference/pluginlib_descriptor_test2.pb.swift +++ b/Reference/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test2.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: pluginlib_descriptor_test2.proto @@ -23,7 +24,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -36,7 +36,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct SwiftDescriptorTest_Proto3MessageForPresence { +struct SwiftDescriptorTest_Proto3MessageForPresence: Sendable { // 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. @@ -48,47 +48,47 @@ struct SwiftDescriptorTest_Proto3MessageForPresence { var enumField: SwiftDescriptorTest_Proto3MessageForPresence.SubEnum = .subValue0 var messageField: SwiftDescriptorTest_OtherMessage { - get {return _messageField ?? SwiftDescriptorTest_OtherMessage()} + get {_messageField ?? SwiftDescriptorTest_OtherMessage()} set {_messageField = newValue} } /// Returns true if `messageField` has been explicitly set. - var hasMessageField: Bool {return self._messageField != nil} + var hasMessageField: Bool {self._messageField != nil} /// Clears the value of `messageField`. Subsequent reads from it will return its default value. mutating func clearMessageField() {self._messageField = nil} var optStrField: String { - get {return _optStrField ?? String()} + get {_optStrField ?? String()} set {_optStrField = newValue} } /// Returns true if `optStrField` has been explicitly set. - var hasOptStrField: Bool {return self._optStrField != nil} + var hasOptStrField: Bool {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} + get {_optInt32Field ?? 0} set {_optInt32Field = newValue} } /// Returns true if `optInt32Field` has been explicitly set. - var hasOptInt32Field: Bool {return self._optInt32Field != nil} + var hasOptInt32Field: Bool {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: SwiftDescriptorTest_Proto3MessageForPresence.SubEnum { - get {return _optEnumField ?? .subValue0} + get {_optEnumField ?? .subValue0} set {_optEnumField = newValue} } /// Returns true if `optEnumField` has been explicitly set. - var hasOptEnumField: Bool {return self._optEnumField != nil} + var hasOptEnumField: Bool {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: SwiftDescriptorTest_OtherMessage { - get {return _optMessageField ?? SwiftDescriptorTest_OtherMessage()} + get {_optMessageField ?? SwiftDescriptorTest_OtherMessage()} set {_optMessageField = newValue} } /// Returns true if `optMessageField` has been explicitly set. - var hasOptMessageField: Bool {return self._optMessageField != nil} + var hasOptMessageField: Bool {self._optMessageField != nil} /// Clears the value of `optMessageField`. Subsequent reads from it will return its default value. mutating func clearOptMessageField() {self._optMessageField = nil} @@ -136,41 +136,15 @@ struct SwiftDescriptorTest_Proto3MessageForPresence { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_O: Equatable { + enum OneOf_O: Equatable, Sendable { case oneofStrField(String) case oneofInt32Field(Int32) case oneofEnumField(SwiftDescriptorTest_Proto3MessageForPresence.SubEnum) case oneofMessageField(SwiftDescriptorTest_OtherMessage) - #if !swift(>=4.1) - static func ==(lhs: SwiftDescriptorTest_Proto3MessageForPresence.OneOf_O, rhs: SwiftDescriptorTest_Proto3MessageForPresence.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 } - enum SubEnum: SwiftProtobuf.Enum { + enum SubEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case subValue0 // = 0 case subValue1 // = 1 @@ -199,6 +173,13 @@ struct SwiftDescriptorTest_Proto3MessageForPresence { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftDescriptorTest_Proto3MessageForPresence.SubEnum] = [ + .subValue0, + .subValue1, + .subValue2, + ] + } init() {} @@ -210,20 +191,7 @@ struct SwiftDescriptorTest_Proto3MessageForPresence { fileprivate var _optMessageField: SwiftDescriptorTest_OtherMessage? = nil } -#if swift(>=4.2) - -extension SwiftDescriptorTest_Proto3MessageForPresence.SubEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [SwiftDescriptorTest_Proto3MessageForPresence.SubEnum] = [ - .subValue0, - .subValue1, - .subValue2, - ] -} - -#endif // swift(>=4.2) - -struct SwiftDescriptorTest_OtherMessage { +struct SwiftDescriptorTest_OtherMessage: Sendable { // 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. @@ -235,37 +203,13 @@ struct SwiftDescriptorTest_OtherMessage { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension SwiftDescriptorTest_Proto3MessageForPresence: @unchecked Sendable {} -extension SwiftDescriptorTest_Proto3MessageForPresence.OneOf_O: @unchecked Sendable {} -extension SwiftDescriptorTest_Proto3MessageForPresence.SubEnum: @unchecked Sendable {} -extension SwiftDescriptorTest_OtherMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "swift_descriptor_test" extension SwiftDescriptorTest_Proto3MessageForPresence: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Proto3MessageForPresence" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "str_field"), - 2: .standard(proto: "int32_field"), - 3: .standard(proto: "enum_field"), - 4: .standard(proto: "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"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}str_field\0\u{3}int32_field\0\u{3}enum_field\0\u{3}message_field\0\u{4}\u{7}opt_str_field\0\u{3}opt_int32_field\0\u{3}opt_enum_field\0\u{3}opt_message_field\0\u{4}\u{7}repeat_str_field\0\u{3}repeat_int32_field\0\u{3}repeat_enum_field\0\u{3}repeat_message_field\0\u{4}\u{7}oneof_str_field\0\u{3}oneof_int32_field\0\u{3}oneof_enum_field\0\u{3}oneof_message_field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -410,18 +354,12 @@ extension SwiftDescriptorTest_Proto3MessageForPresence: SwiftProtobuf.Message, S } extension SwiftDescriptorTest_Proto3MessageForPresence.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"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0SUB_VALUE_0\0\u{1}SUB_VALUE_1\0\u{1}SUB_VALUE_2\0") } extension SwiftDescriptorTest_OtherMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".OtherMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { diff --git a/Reference/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test_import.pb.swift b/Reference/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test_import.pb.swift new file mode 100644 index 000000000..87529f161 --- /dev/null +++ b/Reference/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test_import.pb.swift @@ -0,0 +1,248 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: pluginlib_descriptor_test_import.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protos/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test_import.proto - test proto +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2024 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 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 SwiftDescriptorTest_Import_Version: Sendable { + // 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 major: Int32 { + get {_major ?? 0} + set {_major = newValue} + } + /// Returns true if `major` has been explicitly set. + var hasMajor: Bool {self._major != nil} + /// Clears the value of `major`. Subsequent reads from it will return its default value. + mutating func clearMajor() {self._major = nil} + + var minor: Int32 { + get {_minor ?? 0} + set {_minor = newValue} + } + /// Returns true if `minor` has been explicitly set. + var hasMinor: Bool {self._minor != nil} + /// Clears the value of `minor`. Subsequent reads from it will return its default value. + mutating func clearMinor() {self._minor = nil} + + var patch: Int32 { + get {_patch ?? 0} + set {_patch = newValue} + } + /// Returns true if `patch` has been explicitly set. + var hasPatch: Bool {self._patch != nil} + /// Clears the value of `patch`. Subsequent reads from it will return its default value. + mutating func clearPatch() {self._patch = nil} + + var suffix: String { + get {_suffix ?? String()} + set {_suffix = newValue} + } + /// Returns true if `suffix` has been explicitly set. + var hasSuffix: Bool {self._suffix != nil} + /// Clears the value of `suffix`. Subsequent reads from it will return its default value. + mutating func clearSuffix() {self._suffix = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _major: Int32? = nil + fileprivate var _minor: Int32? = nil + fileprivate var _patch: Int32? = nil + fileprivate var _suffix: String? = nil +} + +struct SwiftDescriptorTest_Import_ExtendableOne: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 subMsgField: SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo { + get {_subMsgField ?? SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo()} + set {_subMsgField = newValue} + } + /// Returns true if `subMsgField` has been explicitly set. + var hasSubMsgField: Bool {self._subMsgField != nil} + /// Clears the value of `subMsgField`. Subsequent reads from it will return its default value. + mutating func clearSubMsgField() {self._subMsgField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct ExtendableTwo: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _subMsgField: SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_descriptor_test.import" + +extension SwiftDescriptorTest_Import_Version: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Version" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}major\0\u{1}minor\0\u{1}patch\0\u{1}suffix\0") + + 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._major) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._minor) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._patch) }() + case 4: try { try decoder.decodeSingularStringField(value: &self._suffix) }() + 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 + try { if let v = self._major { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._minor { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._patch { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._suffix { + try visitor.visitSingularStringField(value: v, fieldNumber: 4) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftDescriptorTest_Import_Version, rhs: SwiftDescriptorTest_Import_Version) -> Bool { + if lhs._major != rhs._major {return false} + if lhs._minor != rhs._minor {return false} + if lhs._patch != rhs._patch {return false} + if lhs._suffix != rhs._suffix {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftDescriptorTest_Import_ExtendableOne: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ExtendableOne" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}sub_msg_field\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + if let v = self._subMsgField, !v.isInitialized {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._subMsgField) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftDescriptorTest_Import_ExtendableOne.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._subMsgField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftDescriptorTest_Import_ExtendableOne, rhs: SwiftDescriptorTest_Import_ExtendableOne) -> Bool { + if lhs._subMsgField != rhs._subMsgField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftDescriptorTest_Import_ExtendableOne.protoMessageName + ".ExtendableTwo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1000 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo, rhs: SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} diff --git a/Reference/Tests/SwiftProtobufPluginLibraryTests/test_features.pb.swift b/Reference/Tests/SwiftProtobufPluginLibraryTests/test_features.pb.swift new file mode 100644 index 000000000..de52d9b5f --- /dev/null +++ b/Reference/Tests/SwiftProtobufPluginLibraryTests/test_features.pb.swift @@ -0,0 +1,218 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: test_features.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protos/SwiftProtobufPluginLibraryTests/test_features.proto - test proto for Features +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2024 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 +// +// ----------------------------------------------------------------------------- + +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 SwiftFeatureTest_TestFeatures: Sendable { + // 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 feature1: SwiftFeatureTest_TestFeatures.EnumFeature { + get {_feature1 ?? .unknown} + set {_feature1 = newValue} + } + /// Returns true if `feature1` has been explicitly set. + var hasFeature1: Bool {self._feature1 != nil} + /// Clears the value of `feature1`. Subsequent reads from it will return its default value. + mutating func clearFeature1() {self._feature1 = nil} + + var feature2: SwiftFeatureTest_TestFeatures.EnumFeature { + get {_feature2 ?? .unknown} + set {_feature2 = newValue} + } + /// Returns true if `feature2` has been explicitly set. + var hasFeature2: Bool {self._feature2 != nil} + /// Clears the value of `feature2`. Subsequent reads from it will return its default value. + mutating func clearFeature2() {self._feature2 = nil} + + var feature3: SwiftFeatureTest_TestFeatures.EnumFeature { + get {_feature3 ?? .unknown} + set {_feature3 = newValue} + } + /// Returns true if `feature3` has been explicitly set. + var hasFeature3: Bool {self._feature3 != nil} + /// Clears the value of `feature3`. Subsequent reads from it will return its default value. + mutating func clearFeature3() {self._feature3 = nil} + + var feature4: SwiftFeatureTest_TestFeatures.EnumFeature { + get {_feature4 ?? .unknown} + set {_feature4 = newValue} + } + /// Returns true if `feature4` has been explicitly set. + var hasFeature4: Bool {self._feature4 != nil} + /// Clears the value of `feature4`. Subsequent reads from it will return its default value. + mutating func clearFeature4() {self._feature4 = nil} + + var feature5: SwiftFeatureTest_TestFeatures.EnumFeature { + get {_feature5 ?? .unknown} + set {_feature5 = newValue} + } + /// Returns true if `feature5` has been explicitly set. + var hasFeature5: Bool {self._feature5 != nil} + /// Clears the value of `feature5`. Subsequent reads from it will return its default value. + mutating func clearFeature5() {self._feature5 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum EnumFeature: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unknown = 0 + case value1 = 1 + case value2 = 2 + case value3 = 3 + case value4 = 4 + case value5 = 5 + case value6 = 6 + + init() { + self = .unknown + } + + } + + init() {} + + fileprivate var _feature1: SwiftFeatureTest_TestFeatures.EnumFeature? = nil + fileprivate var _feature2: SwiftFeatureTest_TestFeatures.EnumFeature? = nil + fileprivate var _feature3: SwiftFeatureTest_TestFeatures.EnumFeature? = nil + fileprivate var _feature4: SwiftFeatureTest_TestFeatures.EnumFeature? = nil + fileprivate var _feature5: SwiftFeatureTest_TestFeatures.EnumFeature? = nil +} + +// MARK: - Extension support defined in test_features.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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_FeatureSet { + + var SwiftFeatureTest_test: SwiftFeatureTest_TestFeatures { + get {return getExtensionValue(ext: SwiftFeatureTest_Extensions_test) ?? SwiftFeatureTest_TestFeatures()} + set {setExtensionValue(ext: SwiftFeatureTest_Extensions_test, value: newValue)} + } + /// Returns true if extension `SwiftFeatureTest_Extensions_test` + /// has been explicitly set. + var hasSwiftFeatureTest_test: Bool { + return hasExtensionValue(ext: SwiftFeatureTest_Extensions_test) + } + /// Clears the value of extension `SwiftFeatureTest_Extensions_test`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftFeatureTest_test() { + clearExtensionValue(ext: SwiftFeatureTest_Extensions_test) + } + +} + +// MARK: - File's ExtensionMap: SwiftFeatureTest_TestFeatures_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 SwiftFeatureTest_TestFeatures_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftFeatureTest_Extensions_test +] + +// 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 SwiftFeatureTest_Extensions_test = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FeatureSet>( + _protobuf_fieldNumber: 9999, + fieldName: "swift_feature_test.test" +) + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_feature_test" + +extension SwiftFeatureTest_TestFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}feature1\0\u{1}feature2\0\u{1}feature3\0\u{1}feature4\0\u{1}feature5\0") + + 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._feature1) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self._feature2) }() + case 3: try { try decoder.decodeSingularEnumField(value: &self._feature3) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._feature4) }() + case 5: try { try decoder.decodeSingularEnumField(value: &self._feature5) }() + 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 + try { if let v = self._feature1 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = self._feature2 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) + } }() + try { if let v = self._feature3 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 3) + } }() + try { if let v = self._feature4 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + try { if let v = self._feature5 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftFeatureTest_TestFeatures, rhs: SwiftFeatureTest_TestFeatures) -> Bool { + if lhs._feature1 != rhs._feature1 {return false} + if lhs._feature2 != rhs._feature2 {return false} + if lhs._feature3 != rhs._feature3 {return false} + if lhs._feature4 != rhs._feature4 {return false} + if lhs._feature5 != rhs._feature5 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftFeatureTest_TestFeatures.EnumFeature: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ENUM_FEATURE_UNKNOWN\0\u{1}ENUM_FEATURE_VALUE1\0\u{1}ENUM_FEATURE_VALUE2\0\u{1}ENUM_FEATURE_VALUE3\0\u{1}ENUM_FEATURE_VALUE4\0\u{1}ENUM_FEATURE_VALUE5\0\u{1}ENUM_FEATURE_VALUE6\0") +} diff --git a/Reference/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited.pb.swift b/Reference/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited.pb.swift new file mode 100644 index 000000000..bba777128 --- /dev/null +++ b/Reference/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited.pb.swift @@ -0,0 +1,706 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: unittest_delimited.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +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 EditionsUnittest_LengthPrefixed: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil +} + +struct EditionsUnittest_NotGroupLikeScope: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil +} + +struct EditionsUnittest_GroupLikeFileScope: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil +} + +struct EditionsUnittest_TestDelimited: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Non-delimited field that otherwise looks group-like. + var lengthprefixed: EditionsUnittest_TestDelimited.LengthPrefixed { + get {_storage._lengthprefixed ?? EditionsUnittest_TestDelimited.LengthPrefixed()} + set {_uniqueStorage()._lengthprefixed = newValue} + } + /// Returns true if `lengthprefixed` has been explicitly set. + var hasLengthprefixed: Bool {_storage._lengthprefixed != nil} + /// Clears the value of `lengthprefixed`. Subsequent reads from it will return its default value. + mutating func clearLengthprefixed() {_uniqueStorage()._lengthprefixed = nil} + + /// Nested field for nested tests. + var nested: EditionsUnittest_TestDelimited { + get {_storage._nested ?? EditionsUnittest_TestDelimited()} + set {_uniqueStorage()._nested = newValue} + } + /// Returns true if `nested` has been explicitly set. + var hasNested: Bool {_storage._nested != nil} + /// Clears the value of `nested`. Subsequent reads from it will return its default value. + mutating func clearNested() {_uniqueStorage()._nested = nil} + + /// Truly group-like field. + var groupLike: EditionsUnittest_TestDelimited.GroupLike { + get {_storage._groupLike ?? EditionsUnittest_TestDelimited.GroupLike()} + set {_uniqueStorage()._groupLike = newValue} + } + /// Returns true if `groupLike` has been explicitly set. + var hasGroupLike: Bool {_storage._groupLike != nil} + /// Clears the value of `groupLike`. Subsequent reads from it will return its default value. + mutating func clearGroupLike() {_uniqueStorage()._groupLike = nil} + + /// Delimited field that isn't group-like solely because of its name. + var notgrouplike: EditionsUnittest_TestDelimited.GroupLike { + get {_storage._notgrouplike ?? EditionsUnittest_TestDelimited.GroupLike()} + set {_uniqueStorage()._notgrouplike = newValue} + } + /// Returns true if `notgrouplike` has been explicitly set. + var hasNotgrouplike: Bool {_storage._notgrouplike != nil} + /// Clears the value of `notgrouplike`. Subsequent reads from it will return its default value. + mutating func clearNotgrouplike() {_uniqueStorage()._notgrouplike = nil} + + /// Delimited field that isn't group-like because of the scope of its type. + var notgrouplikescope: EditionsUnittest_NotGroupLikeScope { + get {_storage._notgrouplikescope ?? EditionsUnittest_NotGroupLikeScope()} + set {_uniqueStorage()._notgrouplikescope = newValue} + } + /// Returns true if `notgrouplikescope` has been explicitly set. + var hasNotgrouplikescope: Bool {_storage._notgrouplikescope != nil} + /// Clears the value of `notgrouplikescope`. Subsequent reads from it will return its default value. + mutating func clearNotgrouplikescope() {_uniqueStorage()._notgrouplikescope = nil} + + /// Delimited field that's grouplike except that it's an imported type. + var messageimport: EditionsUnittest_MessageImport { + get {_storage._messageimport ?? EditionsUnittest_MessageImport()} + set {_uniqueStorage()._messageimport = newValue} + } + /// Returns true if `messageimport` has been explicitly set. + var hasMessageimport: Bool {_storage._messageimport != nil} + /// Clears the value of `messageimport`. Subsequent reads from it will return its default value. + mutating func clearMessageimport() {_uniqueStorage()._messageimport = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct LengthPrefixed: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil + } + + struct GroupLike: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Extension support defined in unittest_delimited.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 EditionsUnittest_TestDelimited { + + /// Non-delimited field that otherwise looks group-like. + var EditionsUnittest_lengthprefixed: EditionsUnittest_LengthPrefixed { + get {return getExtensionValue(ext: EditionsUnittest_Extensions_lengthprefixed) ?? EditionsUnittest_LengthPrefixed()} + set {setExtensionValue(ext: EditionsUnittest_Extensions_lengthprefixed, value: newValue)} + } + /// Returns true if extension `EditionsUnittest_Extensions_lengthprefixed` + /// has been explicitly set. + var hasEditionsUnittest_lengthprefixed: Bool { + return hasExtensionValue(ext: EditionsUnittest_Extensions_lengthprefixed) + } + /// Clears the value of extension `EditionsUnittest_Extensions_lengthprefixed`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionsUnittest_lengthprefixed() { + clearExtensionValue(ext: EditionsUnittest_Extensions_lengthprefixed) + } + + /// Truly group-like extension. + var EditionsUnittest_groupLikeFileScope: EditionsUnittest_GroupLikeFileScope { + get {return getExtensionValue(ext: EditionsUnittest_Extensions_GroupLikeFileScope) ?? EditionsUnittest_GroupLikeFileScope()} + set {setExtensionValue(ext: EditionsUnittest_Extensions_GroupLikeFileScope, value: newValue)} + } + /// Returns true if extension `EditionsUnittest_Extensions_GroupLikeFileScope` + /// has been explicitly set. + var hasEditionsUnittest_groupLikeFileScope: Bool { + return hasExtensionValue(ext: EditionsUnittest_Extensions_GroupLikeFileScope) + } + /// Clears the value of extension `EditionsUnittest_Extensions_GroupLikeFileScope`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionsUnittest_groupLikeFileScope() { + clearExtensionValue(ext: EditionsUnittest_Extensions_GroupLikeFileScope) + } + + /// Delimited extension that isn't group-like because of its name. + var EditionsUnittest_notGroupLikeScope: EditionsUnittest_NotGroupLikeScope { + get {return getExtensionValue(ext: EditionsUnittest_Extensions_not_group_like_scope) ?? EditionsUnittest_NotGroupLikeScope()} + set {setExtensionValue(ext: EditionsUnittest_Extensions_not_group_like_scope, value: newValue)} + } + /// Returns true if extension `EditionsUnittest_Extensions_not_group_like_scope` + /// has been explicitly set. + var hasEditionsUnittest_notGroupLikeScope: Bool { + return hasExtensionValue(ext: EditionsUnittest_Extensions_not_group_like_scope) + } + /// Clears the value of extension `EditionsUnittest_Extensions_not_group_like_scope`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionsUnittest_notGroupLikeScope() { + clearExtensionValue(ext: EditionsUnittest_Extensions_not_group_like_scope) + } + + /// Delimited extension that isn't group-like because of the scope of its type. + var EditionsUnittest_grouplike: EditionsUnittest_TestDelimited.GroupLike { + get {return getExtensionValue(ext: EditionsUnittest_Extensions_grouplike) ?? EditionsUnittest_TestDelimited.GroupLike()} + set {setExtensionValue(ext: EditionsUnittest_Extensions_grouplike, value: newValue)} + } + /// Returns true if extension `EditionsUnittest_Extensions_grouplike` + /// has been explicitly set. + var hasEditionsUnittest_grouplike: Bool { + return hasExtensionValue(ext: EditionsUnittest_Extensions_grouplike) + } + /// Clears the value of extension `EditionsUnittest_Extensions_grouplike`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionsUnittest_grouplike() { + clearExtensionValue(ext: EditionsUnittest_Extensions_grouplike) + } + + /// Delimited extension that's grouplike except that it's an imported type. + var EditionsUnittest_messageimport: EditionsUnittest_MessageImport { + get {return getExtensionValue(ext: EditionsUnittest_Extensions_messageimport) ?? EditionsUnittest_MessageImport()} + set {setExtensionValue(ext: EditionsUnittest_Extensions_messageimport, value: newValue)} + } + /// Returns true if extension `EditionsUnittest_Extensions_messageimport` + /// has been explicitly set. + var hasEditionsUnittest_messageimport: Bool { + return hasExtensionValue(ext: EditionsUnittest_Extensions_messageimport) + } + /// Clears the value of extension `EditionsUnittest_Extensions_messageimport`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionsUnittest_messageimport() { + clearExtensionValue(ext: EditionsUnittest_Extensions_messageimport) + } + +} + +// MARK: - File's ExtensionMap: EditionsUnittest_UnittestDelimited_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 EditionsUnittest_UnittestDelimited_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + EditionsUnittest_Extensions_lengthprefixed, + EditionsUnittest_Extensions_GroupLikeFileScope, + EditionsUnittest_Extensions_not_group_like_scope, + EditionsUnittest_Extensions_grouplike, + EditionsUnittest_Extensions_messageimport +] + +// 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. + +/// Non-delimited field that otherwise looks group-like. +let EditionsUnittest_Extensions_lengthprefixed = SwiftProtobuf.MessageExtension, EditionsUnittest_TestDelimited>( + _protobuf_fieldNumber: 1004, + fieldName: "editions_unittest.lengthprefixed" +) + +/// Truly group-like extension. +let EditionsUnittest_Extensions_GroupLikeFileScope = SwiftProtobuf.MessageExtension, EditionsUnittest_TestDelimited>( + _protobuf_fieldNumber: 1000, + fieldName: "editions_unittest.grouplikefilescope" +) + +/// Delimited extension that isn't group-like because of its name. +let EditionsUnittest_Extensions_not_group_like_scope = SwiftProtobuf.MessageExtension, EditionsUnittest_TestDelimited>( + _protobuf_fieldNumber: 1001, + fieldName: "editions_unittest.not_group_like_scope" +) + +/// Delimited extension that isn't group-like because of the scope of its type. +let EditionsUnittest_Extensions_grouplike = SwiftProtobuf.MessageExtension, EditionsUnittest_TestDelimited>( + _protobuf_fieldNumber: 1002, + fieldName: "editions_unittest.grouplike" +) + +/// Delimited extension that's grouplike except that it's an imported type. +let EditionsUnittest_Extensions_messageimport = SwiftProtobuf.MessageExtension, EditionsUnittest_TestDelimited>( + _protobuf_fieldNumber: 1003, + fieldName: "editions_unittest.messageimport" +) + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "editions_unittest" + +extension EditionsUnittest_LengthPrefixed: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".LengthPrefixed" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_LengthPrefixed, rhs: EditionsUnittest_LengthPrefixed) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionsUnittest_NotGroupLikeScope: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NotGroupLikeScope" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_NotGroupLikeScope, rhs: EditionsUnittest_NotGroupLikeScope) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionsUnittest_GroupLikeFileScope: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GroupLikeFileScope" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_GroupLikeFileScope, rhs: EditionsUnittest_GroupLikeFileScope) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionsUnittest_TestDelimited: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestDelimited" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}lengthprefixed\0\u{1}nested\0\u{7}GroupLike\0\u{1}notgrouplike\0\u{1}notgrouplikescope\0\u{1}messageimport\0") + + fileprivate class _StorageClass { + var _lengthprefixed: EditionsUnittest_TestDelimited.LengthPrefixed? = nil + var _nested: EditionsUnittest_TestDelimited? = nil + var _groupLike: EditionsUnittest_TestDelimited.GroupLike? = nil + var _notgrouplike: EditionsUnittest_TestDelimited.GroupLike? = nil + var _notgrouplikescope: EditionsUnittest_NotGroupLikeScope? = nil + var _messageimport: EditionsUnittest_MessageImport? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _lengthprefixed = source._lengthprefixed + _nested = source._nested + _groupLike = source._groupLike + _notgrouplike = source._notgrouplike + _notgrouplikescope = source._notgrouplikescope + _messageimport = source._messageimport + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._nested, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._lengthprefixed) }() + case 2: try { try decoder.decodeSingularGroupField(value: &_storage._nested) }() + case 3: try { try decoder.decodeSingularGroupField(value: &_storage._groupLike) }() + case 4: try { try decoder.decodeSingularGroupField(value: &_storage._notgrouplike) }() + case 5: try { try decoder.decodeSingularGroupField(value: &_storage._notgrouplikescope) }() + case 6: try { try decoder.decodeSingularGroupField(value: &_storage._messageimport) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionsUnittest_TestDelimited.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._lengthprefixed { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._nested { + try visitor.visitSingularGroupField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._groupLike { + try visitor.visitSingularGroupField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._notgrouplike { + try visitor.visitSingularGroupField(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._notgrouplikescope { + try visitor.visitSingularGroupField(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._messageimport { + try visitor.visitSingularGroupField(value: v, fieldNumber: 6) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_TestDelimited, rhs: EditionsUnittest_TestDelimited) -> 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._lengthprefixed != rhs_storage._lengthprefixed {return false} + if _storage._nested != rhs_storage._nested {return false} + if _storage._groupLike != rhs_storage._groupLike {return false} + if _storage._notgrouplike != rhs_storage._notgrouplike {return false} + if _storage._notgrouplikescope != rhs_storage._notgrouplikescope {return false} + if _storage._messageimport != rhs_storage._messageimport {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionsUnittest_TestDelimited.LengthPrefixed: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionsUnittest_TestDelimited.protoMessageName + ".LengthPrefixed" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_TestDelimited.LengthPrefixed, rhs: EditionsUnittest_TestDelimited.LengthPrefixed) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionsUnittest_TestDelimited.GroupLike: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionsUnittest_TestDelimited.protoMessageName + ".GroupLike" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_TestDelimited.GroupLike, rhs: EditionsUnittest_TestDelimited.GroupLike) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited_import.pb.swift b/Reference/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited_import.pb.swift new file mode 100644 index 000000000..0e18e0afd --- /dev/null +++ b/Reference/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited_import.pb.swift @@ -0,0 +1,95 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: unittest_delimited_import.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +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 EditionsUnittest_MessageImport: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "editions_unittest" + +extension EditionsUnittest_MessageImport: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MessageImport" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_MessageImport, rhs: EditionsUnittest_MessageImport) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/google/protobuf/any_test.pb.swift b/Reference/Tests/SwiftProtobufTests/any_test.pb.swift similarity index 85% rename from Reference/google/protobuf/any_test.pb.swift rename to Reference/Tests/SwiftProtobufTests/any_test.pb.swift index dc142da9b..fd4633d3f 100644 --- a/Reference/google/protobuf/any_test.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/any_test.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/any_test.proto +// Source: any_test.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -37,7 +38,6 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -50,7 +50,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_TestAny { +struct SwiftProtoTesting_TestAny: Sendable { // 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. @@ -58,11 +58,11 @@ struct ProtobufUnittest_TestAny { var int32Value: Int32 = 0 var anyValue: SwiftProtobuf.Google_Protobuf_Any { - get {return _anyValue ?? SwiftProtobuf.Google_Protobuf_Any()} + get {_anyValue ?? SwiftProtobuf.Google_Protobuf_Any()} set {_anyValue = newValue} } /// Returns true if `anyValue` has been explicitly set. - var hasAnyValue: Bool {return self._anyValue != nil} + var hasAnyValue: Bool {self._anyValue != nil} /// Clears the value of `anyValue`. Subsequent reads from it will return its default value. mutating func clearAnyValue() {self._anyValue = nil} @@ -77,22 +77,13 @@ struct ProtobufUnittest_TestAny { fileprivate var _anyValue: SwiftProtobuf.Google_Protobuf_Any? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_TestAny: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_TestAny: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_TestAny: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestAny" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "int32_value"), - 2: .standard(proto: "any_value"), - 3: .standard(proto: "repeated_any_value"), - 4: .same(proto: "text"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}int32_value\0\u{3}any_value\0\u{3}repeated_any_value\0\u{1}text\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -129,7 +120,7 @@ extension ProtobufUnittest_TestAny: SwiftProtobuf.Message, SwiftProtobuf._Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestAny, rhs: ProtobufUnittest_TestAny) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestAny, rhs: SwiftProtoTesting_TestAny) -> Bool { if lhs.int32Value != rhs.int32Value {return false} if lhs._anyValue != rhs._anyValue {return false} if lhs.repeatedAnyValue != rhs.repeatedAnyValue {return false} diff --git a/Reference/fuzz_testing.pb.swift b/Reference/Tests/SwiftProtobufTests/fuzz_testing.pb.swift similarity index 68% rename from Reference/fuzz_testing.pb.swift rename to Reference/Tests/SwiftProtobufTests/fuzz_testing.pb.swift index 992e746d6..9184d28e4 100644 --- a/Reference/fuzz_testing.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/fuzz_testing.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: fuzz_testing.proto @@ -34,302 +35,274 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum Fuzz_Testing_AnEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case zero // = 0 - case one // = 1 - case two // = 2 - case three // = 3 +enum SwiftProtoTesting_Fuzz_AnEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case zero = 0 + case one = 1 + case two = 2 + case three = 3 init() { self = .zero } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .zero - case 1: self = .one - case 2: self = .two - case 3: self = .three - default: return nil - } - } - - var rawValue: Int { - switch self { - case .zero: return 0 - case .one: return 1 - case .two: return 2 - case .three: return 3 - } - } - -} - -#if swift(>=4.2) - -extension Fuzz_Testing_AnEnum: CaseIterable { - // Support synthesized by the compiler. } -#endif // swift(>=4.2) - -struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Fuzz_Message: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { // 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. /// Singular var singularInt32: Int32 { - get {return _storage._singularInt32 ?? 0} + get {_storage._singularInt32 ?? 0} set {_uniqueStorage()._singularInt32 = newValue} } /// Returns true if `singularInt32` has been explicitly set. - var hasSingularInt32: Bool {return _storage._singularInt32 != nil} + var hasSingularInt32: Bool {_storage._singularInt32 != nil} /// Clears the value of `singularInt32`. Subsequent reads from it will return its default value. mutating func clearSingularInt32() {_uniqueStorage()._singularInt32 = nil} var singularInt64: Int64 { - get {return _storage._singularInt64 ?? 0} + get {_storage._singularInt64 ?? 0} set {_uniqueStorage()._singularInt64 = newValue} } /// Returns true if `singularInt64` has been explicitly set. - var hasSingularInt64: Bool {return _storage._singularInt64 != nil} + var hasSingularInt64: Bool {_storage._singularInt64 != nil} /// Clears the value of `singularInt64`. Subsequent reads from it will return its default value. mutating func clearSingularInt64() {_uniqueStorage()._singularInt64 = nil} var singularUint32: UInt32 { - get {return _storage._singularUint32 ?? 0} + get {_storage._singularUint32 ?? 0} set {_uniqueStorage()._singularUint32 = newValue} } /// Returns true if `singularUint32` has been explicitly set. - var hasSingularUint32: Bool {return _storage._singularUint32 != nil} + var hasSingularUint32: Bool {_storage._singularUint32 != nil} /// Clears the value of `singularUint32`. Subsequent reads from it will return its default value. mutating func clearSingularUint32() {_uniqueStorage()._singularUint32 = nil} var singularUint64: UInt64 { - get {return _storage._singularUint64 ?? 0} + get {_storage._singularUint64 ?? 0} set {_uniqueStorage()._singularUint64 = newValue} } /// Returns true if `singularUint64` has been explicitly set. - var hasSingularUint64: Bool {return _storage._singularUint64 != nil} + var hasSingularUint64: Bool {_storage._singularUint64 != nil} /// Clears the value of `singularUint64`. Subsequent reads from it will return its default value. mutating func clearSingularUint64() {_uniqueStorage()._singularUint64 = nil} var singularSint32: Int32 { - get {return _storage._singularSint32 ?? 0} + get {_storage._singularSint32 ?? 0} set {_uniqueStorage()._singularSint32 = newValue} } /// Returns true if `singularSint32` has been explicitly set. - var hasSingularSint32: Bool {return _storage._singularSint32 != nil} + var hasSingularSint32: Bool {_storage._singularSint32 != nil} /// Clears the value of `singularSint32`. Subsequent reads from it will return its default value. mutating func clearSingularSint32() {_uniqueStorage()._singularSint32 = nil} var singularSint64: Int64 { - get {return _storage._singularSint64 ?? 0} + get {_storage._singularSint64 ?? 0} set {_uniqueStorage()._singularSint64 = newValue} } /// Returns true if `singularSint64` has been explicitly set. - var hasSingularSint64: Bool {return _storage._singularSint64 != nil} + var hasSingularSint64: Bool {_storage._singularSint64 != nil} /// Clears the value of `singularSint64`. Subsequent reads from it will return its default value. mutating func clearSingularSint64() {_uniqueStorage()._singularSint64 = nil} var singularFixed32: UInt32 { - get {return _storage._singularFixed32 ?? 0} + get {_storage._singularFixed32 ?? 0} set {_uniqueStorage()._singularFixed32 = newValue} } /// Returns true if `singularFixed32` has been explicitly set. - var hasSingularFixed32: Bool {return _storage._singularFixed32 != nil} + var hasSingularFixed32: Bool {_storage._singularFixed32 != nil} /// Clears the value of `singularFixed32`. Subsequent reads from it will return its default value. mutating func clearSingularFixed32() {_uniqueStorage()._singularFixed32 = nil} var singularFixed64: UInt64 { - get {return _storage._singularFixed64 ?? 0} + get {_storage._singularFixed64 ?? 0} set {_uniqueStorage()._singularFixed64 = newValue} } /// Returns true if `singularFixed64` has been explicitly set. - var hasSingularFixed64: Bool {return _storage._singularFixed64 != nil} + var hasSingularFixed64: Bool {_storage._singularFixed64 != nil} /// Clears the value of `singularFixed64`. Subsequent reads from it will return its default value. mutating func clearSingularFixed64() {_uniqueStorage()._singularFixed64 = nil} var singularSfixed32: Int32 { - get {return _storage._singularSfixed32 ?? 0} + get {_storage._singularSfixed32 ?? 0} set {_uniqueStorage()._singularSfixed32 = newValue} } /// Returns true if `singularSfixed32` has been explicitly set. - var hasSingularSfixed32: Bool {return _storage._singularSfixed32 != nil} + var hasSingularSfixed32: Bool {_storage._singularSfixed32 != nil} /// Clears the value of `singularSfixed32`. Subsequent reads from it will return its default value. mutating func clearSingularSfixed32() {_uniqueStorage()._singularSfixed32 = nil} var singularSfixed64: Int64 { - get {return _storage._singularSfixed64 ?? 0} + get {_storage._singularSfixed64 ?? 0} set {_uniqueStorage()._singularSfixed64 = newValue} } /// Returns true if `singularSfixed64` has been explicitly set. - var hasSingularSfixed64: Bool {return _storage._singularSfixed64 != nil} + var hasSingularSfixed64: Bool {_storage._singularSfixed64 != nil} /// Clears the value of `singularSfixed64`. Subsequent reads from it will return its default value. mutating func clearSingularSfixed64() {_uniqueStorage()._singularSfixed64 = nil} var singularFloat: Float { - get {return _storage._singularFloat ?? 0} + get {_storage._singularFloat ?? 0} set {_uniqueStorage()._singularFloat = newValue} } /// Returns true if `singularFloat` has been explicitly set. - var hasSingularFloat: Bool {return _storage._singularFloat != nil} + var hasSingularFloat: Bool {_storage._singularFloat != nil} /// Clears the value of `singularFloat`. Subsequent reads from it will return its default value. mutating func clearSingularFloat() {_uniqueStorage()._singularFloat = nil} var singularDouble: Double { - get {return _storage._singularDouble ?? 0} + get {_storage._singularDouble ?? 0} set {_uniqueStorage()._singularDouble = newValue} } /// Returns true if `singularDouble` has been explicitly set. - var hasSingularDouble: Bool {return _storage._singularDouble != nil} + var hasSingularDouble: Bool {_storage._singularDouble != nil} /// Clears the value of `singularDouble`. Subsequent reads from it will return its default value. mutating func clearSingularDouble() {_uniqueStorage()._singularDouble = nil} var singularBool: Bool { - get {return _storage._singularBool ?? false} + get {_storage._singularBool ?? false} set {_uniqueStorage()._singularBool = newValue} } /// Returns true if `singularBool` has been explicitly set. - var hasSingularBool: Bool {return _storage._singularBool != nil} + var hasSingularBool: Bool {_storage._singularBool != nil} /// Clears the value of `singularBool`. Subsequent reads from it will return its default value. mutating func clearSingularBool() {_uniqueStorage()._singularBool = nil} var singularString: String { - get {return _storage._singularString ?? String()} + get {_storage._singularString ?? String()} set {_uniqueStorage()._singularString = newValue} } /// Returns true if `singularString` has been explicitly set. - var hasSingularString: Bool {return _storage._singularString != nil} + var hasSingularString: Bool {_storage._singularString != nil} /// Clears the value of `singularString`. Subsequent reads from it will return its default value. mutating func clearSingularString() {_uniqueStorage()._singularString = nil} var singularBytes: Data { - get {return _storage._singularBytes ?? Data()} + get {_storage._singularBytes ?? Data()} set {_uniqueStorage()._singularBytes = newValue} } /// Returns true if `singularBytes` has been explicitly set. - var hasSingularBytes: Bool {return _storage._singularBytes != nil} + var hasSingularBytes: Bool {_storage._singularBytes != nil} /// Clears the value of `singularBytes`. Subsequent reads from it will return its default value. mutating func clearSingularBytes() {_uniqueStorage()._singularBytes = nil} - var singularEnum: Fuzz_Testing_AnEnum { - get {return _storage._singularEnum ?? .zero} + var singularEnum: SwiftProtoTesting_Fuzz_AnEnum { + get {_storage._singularEnum ?? .zero} set {_uniqueStorage()._singularEnum = newValue} } /// Returns true if `singularEnum` has been explicitly set. - var hasSingularEnum: Bool {return _storage._singularEnum != nil} + var hasSingularEnum: Bool {_storage._singularEnum != nil} /// Clears the value of `singularEnum`. Subsequent reads from it will return its default value. mutating func clearSingularEnum() {_uniqueStorage()._singularEnum = nil} - var singularGroup: Fuzz_Testing_Message.SingularGroup { - get {return _storage._singularGroup ?? Fuzz_Testing_Message.SingularGroup()} + var singularGroup: SwiftProtoTesting_Fuzz_Message.SingularGroup { + get {_storage._singularGroup ?? SwiftProtoTesting_Fuzz_Message.SingularGroup()} set {_uniqueStorage()._singularGroup = newValue} } /// Returns true if `singularGroup` has been explicitly set. - var hasSingularGroup: Bool {return _storage._singularGroup != nil} + var hasSingularGroup: Bool {_storage._singularGroup != nil} /// Clears the value of `singularGroup`. Subsequent reads from it will return its default value. mutating func clearSingularGroup() {_uniqueStorage()._singularGroup = nil} - var singularMessage: Fuzz_Testing_Message { - get {return _storage._singularMessage ?? Fuzz_Testing_Message()} + var singularMessage: SwiftProtoTesting_Fuzz_Message { + get {_storage._singularMessage ?? SwiftProtoTesting_Fuzz_Message()} set {_uniqueStorage()._singularMessage = newValue} } /// Returns true if `singularMessage` has been explicitly set. - var hasSingularMessage: Bool {return _storage._singularMessage != nil} + var hasSingularMessage: Bool {_storage._singularMessage != nil} /// Clears the value of `singularMessage`. Subsequent reads from it will return its default value. mutating func clearSingularMessage() {_uniqueStorage()._singularMessage = nil} /// Repeated var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } - var repeatedEnum: [Fuzz_Testing_AnEnum] { - get {return _storage._repeatedEnum} + var repeatedEnum: [SwiftProtoTesting_Fuzz_AnEnum] { + get {_storage._repeatedEnum} set {_uniqueStorage()._repeatedEnum = newValue} } - var repeatedGroup: [Fuzz_Testing_Message.RepeatedGroup] { - get {return _storage._repeatedGroup} + var repeatedGroup: [SwiftProtoTesting_Fuzz_Message.RepeatedGroup] { + get {_storage._repeatedGroup} set {_uniqueStorage()._repeatedGroup = newValue} } - var repeatedMessage: [Fuzz_Testing_Message] { - get {return _storage._repeatedMessage} + var repeatedMessage: [SwiftProtoTesting_Fuzz_Message] { + get {_storage._repeatedMessage} set {_uniqueStorage()._repeatedMessage = newValue} } @@ -459,7 +432,7 @@ struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { set {_uniqueStorage()._o = .oneofBytes(newValue)} } - var oneofEnum: Fuzz_Testing_AnEnum { + var oneofEnum: SwiftProtoTesting_Fuzz_AnEnum { get { if case .oneofEnum(let v)? = _storage._o {return v} return .zero @@ -467,1211 +440,1211 @@ struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { set {_uniqueStorage()._o = .oneofEnum(newValue)} } - var oneofGroup: Fuzz_Testing_Message.OneofGroup { + var oneofGroup: SwiftProtoTesting_Fuzz_Message.OneofGroup { get { if case .oneofGroup(let v)? = _storage._o {return v} - return Fuzz_Testing_Message.OneofGroup() + return SwiftProtoTesting_Fuzz_Message.OneofGroup() } set {_uniqueStorage()._o = .oneofGroup(newValue)} } - var oneofMessage: Fuzz_Testing_Message { + var oneofMessage: SwiftProtoTesting_Fuzz_Message { get { if case .oneofMessage(let v)? = _storage._o {return v} - return Fuzz_Testing_Message() + return SwiftProtoTesting_Fuzz_Message() } set {_uniqueStorage()._o = .oneofMessage(newValue)} } /// Repeated Packed var repeatedPackedInt32: [Int32] { - get {return _storage._repeatedPackedInt32} + get {_storage._repeatedPackedInt32} set {_uniqueStorage()._repeatedPackedInt32 = newValue} } var repeatedPackedInt64: [Int64] { - get {return _storage._repeatedPackedInt64} + get {_storage._repeatedPackedInt64} set {_uniqueStorage()._repeatedPackedInt64 = newValue} } var repeatedPackedUint32: [UInt32] { - get {return _storage._repeatedPackedUint32} + get {_storage._repeatedPackedUint32} set {_uniqueStorage()._repeatedPackedUint32 = newValue} } var repeatedPackedUint64: [UInt64] { - get {return _storage._repeatedPackedUint64} + get {_storage._repeatedPackedUint64} set {_uniqueStorage()._repeatedPackedUint64 = newValue} } var repeatedPackedSint32: [Int32] { - get {return _storage._repeatedPackedSint32} + get {_storage._repeatedPackedSint32} set {_uniqueStorage()._repeatedPackedSint32 = newValue} } var repeatedPackedSint64: [Int64] { - get {return _storage._repeatedPackedSint64} + get {_storage._repeatedPackedSint64} set {_uniqueStorage()._repeatedPackedSint64 = newValue} } var repeatedPackedFixed32: [UInt32] { - get {return _storage._repeatedPackedFixed32} + get {_storage._repeatedPackedFixed32} set {_uniqueStorage()._repeatedPackedFixed32 = newValue} } var repeatedPackedFixed64: [UInt64] { - get {return _storage._repeatedPackedFixed64} + get {_storage._repeatedPackedFixed64} set {_uniqueStorage()._repeatedPackedFixed64 = newValue} } var repeatedPackedSfixed32: [Int32] { - get {return _storage._repeatedPackedSfixed32} + get {_storage._repeatedPackedSfixed32} set {_uniqueStorage()._repeatedPackedSfixed32 = newValue} } var repeatedPackedSfixed64: [Int64] { - get {return _storage._repeatedPackedSfixed64} + get {_storage._repeatedPackedSfixed64} set {_uniqueStorage()._repeatedPackedSfixed64 = newValue} } var repeatedPackedFloat: [Float] { - get {return _storage._repeatedPackedFloat} + get {_storage._repeatedPackedFloat} set {_uniqueStorage()._repeatedPackedFloat = newValue} } var repeatedPackedDouble: [Double] { - get {return _storage._repeatedPackedDouble} + get {_storage._repeatedPackedDouble} set {_uniqueStorage()._repeatedPackedDouble = newValue} } var repeatedPackedBool: [Bool] { - get {return _storage._repeatedPackedBool} + get {_storage._repeatedPackedBool} set {_uniqueStorage()._repeatedPackedBool = newValue} } - var repeatedPackedEnum: [Fuzz_Testing_AnEnum] { - get {return _storage._repeatedPackedEnum} + var repeatedPackedEnum: [SwiftProtoTesting_Fuzz_AnEnum] { + get {_storage._repeatedPackedEnum} set {_uniqueStorage()._repeatedPackedEnum = newValue} } /// map<> var mapInt32Int32: Dictionary { - get {return _storage._mapInt32Int32} + get {_storage._mapInt32Int32} set {_uniqueStorage()._mapInt32Int32 = newValue} } var mapInt32Int64: Dictionary { - get {return _storage._mapInt32Int64} + get {_storage._mapInt32Int64} set {_uniqueStorage()._mapInt32Int64 = newValue} } var mapInt32Uint32: Dictionary { - get {return _storage._mapInt32Uint32} + get {_storage._mapInt32Uint32} set {_uniqueStorage()._mapInt32Uint32 = newValue} } var mapInt32Uint64: Dictionary { - get {return _storage._mapInt32Uint64} + get {_storage._mapInt32Uint64} set {_uniqueStorage()._mapInt32Uint64 = newValue} } var mapInt32Sint32: Dictionary { - get {return _storage._mapInt32Sint32} + get {_storage._mapInt32Sint32} set {_uniqueStorage()._mapInt32Sint32 = newValue} } var mapInt32Sint64: Dictionary { - get {return _storage._mapInt32Sint64} + get {_storage._mapInt32Sint64} set {_uniqueStorage()._mapInt32Sint64 = newValue} } var mapInt32Fixed32: Dictionary { - get {return _storage._mapInt32Fixed32} + get {_storage._mapInt32Fixed32} set {_uniqueStorage()._mapInt32Fixed32 = newValue} } var mapInt32Fixed64: Dictionary { - get {return _storage._mapInt32Fixed64} + get {_storage._mapInt32Fixed64} set {_uniqueStorage()._mapInt32Fixed64 = newValue} } var mapInt32Sfixed32: Dictionary { - get {return _storage._mapInt32Sfixed32} + get {_storage._mapInt32Sfixed32} set {_uniqueStorage()._mapInt32Sfixed32 = newValue} } var mapInt32Sfixed64: Dictionary { - get {return _storage._mapInt32Sfixed64} + get {_storage._mapInt32Sfixed64} set {_uniqueStorage()._mapInt32Sfixed64 = newValue} } var mapInt32Float: Dictionary { - get {return _storage._mapInt32Float} + get {_storage._mapInt32Float} set {_uniqueStorage()._mapInt32Float = newValue} } var mapInt32Double: Dictionary { - get {return _storage._mapInt32Double} + get {_storage._mapInt32Double} set {_uniqueStorage()._mapInt32Double = newValue} } var mapInt32Bool: Dictionary { - get {return _storage._mapInt32Bool} + get {_storage._mapInt32Bool} set {_uniqueStorage()._mapInt32Bool = newValue} } var mapInt32String: Dictionary { - get {return _storage._mapInt32String} + get {_storage._mapInt32String} set {_uniqueStorage()._mapInt32String = newValue} } var mapInt32Bytes: Dictionary { - get {return _storage._mapInt32Bytes} + get {_storage._mapInt32Bytes} set {_uniqueStorage()._mapInt32Bytes = newValue} } - var mapInt32AnEnum: Dictionary { - get {return _storage._mapInt32AnEnum} + var mapInt32AnEnum: Dictionary { + get {_storage._mapInt32AnEnum} set {_uniqueStorage()._mapInt32AnEnum = newValue} } - var mapInt32Message: Dictionary { - get {return _storage._mapInt32Message} + var mapInt32Message: Dictionary { + get {_storage._mapInt32Message} set {_uniqueStorage()._mapInt32Message = newValue} } var mapInt64Int32: Dictionary { - get {return _storage._mapInt64Int32} + get {_storage._mapInt64Int32} set {_uniqueStorage()._mapInt64Int32 = newValue} } var mapInt64Int64: Dictionary { - get {return _storage._mapInt64Int64} + get {_storage._mapInt64Int64} set {_uniqueStorage()._mapInt64Int64 = newValue} } var mapInt64Uint32: Dictionary { - get {return _storage._mapInt64Uint32} + get {_storage._mapInt64Uint32} set {_uniqueStorage()._mapInt64Uint32 = newValue} } var mapInt64Uint64: Dictionary { - get {return _storage._mapInt64Uint64} + get {_storage._mapInt64Uint64} set {_uniqueStorage()._mapInt64Uint64 = newValue} } var mapInt64Sint32: Dictionary { - get {return _storage._mapInt64Sint32} + get {_storage._mapInt64Sint32} set {_uniqueStorage()._mapInt64Sint32 = newValue} } var mapInt64Sint64: Dictionary { - get {return _storage._mapInt64Sint64} + get {_storage._mapInt64Sint64} set {_uniqueStorage()._mapInt64Sint64 = newValue} } var mapInt64Fixed32: Dictionary { - get {return _storage._mapInt64Fixed32} + get {_storage._mapInt64Fixed32} set {_uniqueStorage()._mapInt64Fixed32 = newValue} } var mapInt64Fixed64: Dictionary { - get {return _storage._mapInt64Fixed64} + get {_storage._mapInt64Fixed64} set {_uniqueStorage()._mapInt64Fixed64 = newValue} } var mapInt64Sfixed32: Dictionary { - get {return _storage._mapInt64Sfixed32} + get {_storage._mapInt64Sfixed32} set {_uniqueStorage()._mapInt64Sfixed32 = newValue} } var mapInt64Sfixed64: Dictionary { - get {return _storage._mapInt64Sfixed64} + get {_storage._mapInt64Sfixed64} set {_uniqueStorage()._mapInt64Sfixed64 = newValue} } var mapInt64Float: Dictionary { - get {return _storage._mapInt64Float} + get {_storage._mapInt64Float} set {_uniqueStorage()._mapInt64Float = newValue} } var mapInt64Double: Dictionary { - get {return _storage._mapInt64Double} + get {_storage._mapInt64Double} set {_uniqueStorage()._mapInt64Double = newValue} } var mapInt64Bool: Dictionary { - get {return _storage._mapInt64Bool} + get {_storage._mapInt64Bool} set {_uniqueStorage()._mapInt64Bool = newValue} } var mapInt64String: Dictionary { - get {return _storage._mapInt64String} + get {_storage._mapInt64String} set {_uniqueStorage()._mapInt64String = newValue} } var mapInt64Bytes: Dictionary { - get {return _storage._mapInt64Bytes} + get {_storage._mapInt64Bytes} set {_uniqueStorage()._mapInt64Bytes = newValue} } - var mapInt64AnEnum: Dictionary { - get {return _storage._mapInt64AnEnum} + var mapInt64AnEnum: Dictionary { + get {_storage._mapInt64AnEnum} set {_uniqueStorage()._mapInt64AnEnum = newValue} } - var mapInt64Message: Dictionary { - get {return _storage._mapInt64Message} + var mapInt64Message: Dictionary { + get {_storage._mapInt64Message} set {_uniqueStorage()._mapInt64Message = newValue} } var mapUint32Int32: Dictionary { - get {return _storage._mapUint32Int32} + get {_storage._mapUint32Int32} set {_uniqueStorage()._mapUint32Int32 = newValue} } var mapUint32Int64: Dictionary { - get {return _storage._mapUint32Int64} + get {_storage._mapUint32Int64} set {_uniqueStorage()._mapUint32Int64 = newValue} } var mapUint32Uint32: Dictionary { - get {return _storage._mapUint32Uint32} + get {_storage._mapUint32Uint32} set {_uniqueStorage()._mapUint32Uint32 = newValue} } var mapUint32Uint64: Dictionary { - get {return _storage._mapUint32Uint64} + get {_storage._mapUint32Uint64} set {_uniqueStorage()._mapUint32Uint64 = newValue} } var mapUint32Sint32: Dictionary { - get {return _storage._mapUint32Sint32} + get {_storage._mapUint32Sint32} set {_uniqueStorage()._mapUint32Sint32 = newValue} } var mapUint32Sint64: Dictionary { - get {return _storage._mapUint32Sint64} + get {_storage._mapUint32Sint64} set {_uniqueStorage()._mapUint32Sint64 = newValue} } var mapUint32Fixed32: Dictionary { - get {return _storage._mapUint32Fixed32} + get {_storage._mapUint32Fixed32} set {_uniqueStorage()._mapUint32Fixed32 = newValue} } var mapUint32Fixed64: Dictionary { - get {return _storage._mapUint32Fixed64} + get {_storage._mapUint32Fixed64} set {_uniqueStorage()._mapUint32Fixed64 = newValue} } var mapUint32Sfixed32: Dictionary { - get {return _storage._mapUint32Sfixed32} + get {_storage._mapUint32Sfixed32} set {_uniqueStorage()._mapUint32Sfixed32 = newValue} } var mapUint32Sfixed64: Dictionary { - get {return _storage._mapUint32Sfixed64} + get {_storage._mapUint32Sfixed64} set {_uniqueStorage()._mapUint32Sfixed64 = newValue} } var mapUint32Float: Dictionary { - get {return _storage._mapUint32Float} + get {_storage._mapUint32Float} set {_uniqueStorage()._mapUint32Float = newValue} } var mapUint32Double: Dictionary { - get {return _storage._mapUint32Double} + get {_storage._mapUint32Double} set {_uniqueStorage()._mapUint32Double = newValue} } var mapUint32Bool: Dictionary { - get {return _storage._mapUint32Bool} + get {_storage._mapUint32Bool} set {_uniqueStorage()._mapUint32Bool = newValue} } var mapUint32String: Dictionary { - get {return _storage._mapUint32String} + get {_storage._mapUint32String} set {_uniqueStorage()._mapUint32String = newValue} } var mapUint32Bytes: Dictionary { - get {return _storage._mapUint32Bytes} + get {_storage._mapUint32Bytes} set {_uniqueStorage()._mapUint32Bytes = newValue} } - var mapUint32AnEnum: Dictionary { - get {return _storage._mapUint32AnEnum} + var mapUint32AnEnum: Dictionary { + get {_storage._mapUint32AnEnum} set {_uniqueStorage()._mapUint32AnEnum = newValue} } - var mapUint32Message: Dictionary { - get {return _storage._mapUint32Message} + var mapUint32Message: Dictionary { + get {_storage._mapUint32Message} set {_uniqueStorage()._mapUint32Message = newValue} } var mapUint64Int32: Dictionary { - get {return _storage._mapUint64Int32} + get {_storage._mapUint64Int32} set {_uniqueStorage()._mapUint64Int32 = newValue} } var mapUint64Int64: Dictionary { - get {return _storage._mapUint64Int64} + get {_storage._mapUint64Int64} set {_uniqueStorage()._mapUint64Int64 = newValue} } var mapUint64Uint32: Dictionary { - get {return _storage._mapUint64Uint32} + get {_storage._mapUint64Uint32} set {_uniqueStorage()._mapUint64Uint32 = newValue} } var mapUint64Uint64: Dictionary { - get {return _storage._mapUint64Uint64} + get {_storage._mapUint64Uint64} set {_uniqueStorage()._mapUint64Uint64 = newValue} } var mapUint64Sint32: Dictionary { - get {return _storage._mapUint64Sint32} + get {_storage._mapUint64Sint32} set {_uniqueStorage()._mapUint64Sint32 = newValue} } var mapUint64Sint64: Dictionary { - get {return _storage._mapUint64Sint64} + get {_storage._mapUint64Sint64} set {_uniqueStorage()._mapUint64Sint64 = newValue} } var mapUint64Fixed32: Dictionary { - get {return _storage._mapUint64Fixed32} + get {_storage._mapUint64Fixed32} set {_uniqueStorage()._mapUint64Fixed32 = newValue} } var mapUint64Fixed64: Dictionary { - get {return _storage._mapUint64Fixed64} + get {_storage._mapUint64Fixed64} set {_uniqueStorage()._mapUint64Fixed64 = newValue} } var mapUint64Sfixed32: Dictionary { - get {return _storage._mapUint64Sfixed32} + get {_storage._mapUint64Sfixed32} set {_uniqueStorage()._mapUint64Sfixed32 = newValue} } var mapUint64Sfixed64: Dictionary { - get {return _storage._mapUint64Sfixed64} + get {_storage._mapUint64Sfixed64} set {_uniqueStorage()._mapUint64Sfixed64 = newValue} } var mapUint64Float: Dictionary { - get {return _storage._mapUint64Float} + get {_storage._mapUint64Float} set {_uniqueStorage()._mapUint64Float = newValue} } var mapUint64Double: Dictionary { - get {return _storage._mapUint64Double} + get {_storage._mapUint64Double} set {_uniqueStorage()._mapUint64Double = newValue} } var mapUint64Bool: Dictionary { - get {return _storage._mapUint64Bool} + get {_storage._mapUint64Bool} set {_uniqueStorage()._mapUint64Bool = newValue} } var mapUint64String: Dictionary { - get {return _storage._mapUint64String} + get {_storage._mapUint64String} set {_uniqueStorage()._mapUint64String = newValue} } var mapUint64Bytes: Dictionary { - get {return _storage._mapUint64Bytes} + get {_storage._mapUint64Bytes} set {_uniqueStorage()._mapUint64Bytes = newValue} } - var mapUint64AnEnum: Dictionary { - get {return _storage._mapUint64AnEnum} + var mapUint64AnEnum: Dictionary { + get {_storage._mapUint64AnEnum} set {_uniqueStorage()._mapUint64AnEnum = newValue} } - var mapUint64Message: Dictionary { - get {return _storage._mapUint64Message} + var mapUint64Message: Dictionary { + get {_storage._mapUint64Message} set {_uniqueStorage()._mapUint64Message = newValue} } var mapSint32Int32: Dictionary { - get {return _storage._mapSint32Int32} + get {_storage._mapSint32Int32} set {_uniqueStorage()._mapSint32Int32 = newValue} } var mapSint32Int64: Dictionary { - get {return _storage._mapSint32Int64} + get {_storage._mapSint32Int64} set {_uniqueStorage()._mapSint32Int64 = newValue} } var mapSint32Uint32: Dictionary { - get {return _storage._mapSint32Uint32} + get {_storage._mapSint32Uint32} set {_uniqueStorage()._mapSint32Uint32 = newValue} } var mapSint32Uint64: Dictionary { - get {return _storage._mapSint32Uint64} + get {_storage._mapSint32Uint64} set {_uniqueStorage()._mapSint32Uint64 = newValue} } var mapSint32Sint32: Dictionary { - get {return _storage._mapSint32Sint32} + get {_storage._mapSint32Sint32} set {_uniqueStorage()._mapSint32Sint32 = newValue} } var mapSint32Sint64: Dictionary { - get {return _storage._mapSint32Sint64} + get {_storage._mapSint32Sint64} set {_uniqueStorage()._mapSint32Sint64 = newValue} } var mapSint32Fixed32: Dictionary { - get {return _storage._mapSint32Fixed32} + get {_storage._mapSint32Fixed32} set {_uniqueStorage()._mapSint32Fixed32 = newValue} } var mapSint32Fixed64: Dictionary { - get {return _storage._mapSint32Fixed64} + get {_storage._mapSint32Fixed64} set {_uniqueStorage()._mapSint32Fixed64 = newValue} } var mapSint32Sfixed32: Dictionary { - get {return _storage._mapSint32Sfixed32} + get {_storage._mapSint32Sfixed32} set {_uniqueStorage()._mapSint32Sfixed32 = newValue} } var mapSint32Sfixed64: Dictionary { - get {return _storage._mapSint32Sfixed64} + get {_storage._mapSint32Sfixed64} set {_uniqueStorage()._mapSint32Sfixed64 = newValue} } var mapSint32Float: Dictionary { - get {return _storage._mapSint32Float} + get {_storage._mapSint32Float} set {_uniqueStorage()._mapSint32Float = newValue} } var mapSint32Double: Dictionary { - get {return _storage._mapSint32Double} + get {_storage._mapSint32Double} set {_uniqueStorage()._mapSint32Double = newValue} } var mapSint32Bool: Dictionary { - get {return _storage._mapSint32Bool} + get {_storage._mapSint32Bool} set {_uniqueStorage()._mapSint32Bool = newValue} } var mapSint32String: Dictionary { - get {return _storage._mapSint32String} + get {_storage._mapSint32String} set {_uniqueStorage()._mapSint32String = newValue} } var mapSint32Bytes: Dictionary { - get {return _storage._mapSint32Bytes} + get {_storage._mapSint32Bytes} set {_uniqueStorage()._mapSint32Bytes = newValue} } - var mapSint32AnEnum: Dictionary { - get {return _storage._mapSint32AnEnum} + var mapSint32AnEnum: Dictionary { + get {_storage._mapSint32AnEnum} set {_uniqueStorage()._mapSint32AnEnum = newValue} } - var mapSint32Message: Dictionary { - get {return _storage._mapSint32Message} + var mapSint32Message: Dictionary { + get {_storage._mapSint32Message} set {_uniqueStorage()._mapSint32Message = newValue} } var mapSint64Int32: Dictionary { - get {return _storage._mapSint64Int32} + get {_storage._mapSint64Int32} set {_uniqueStorage()._mapSint64Int32 = newValue} } var mapSint64Int64: Dictionary { - get {return _storage._mapSint64Int64} + get {_storage._mapSint64Int64} set {_uniqueStorage()._mapSint64Int64 = newValue} } var mapSint64Uint32: Dictionary { - get {return _storage._mapSint64Uint32} + get {_storage._mapSint64Uint32} set {_uniqueStorage()._mapSint64Uint32 = newValue} } var mapSint64Uint64: Dictionary { - get {return _storage._mapSint64Uint64} + get {_storage._mapSint64Uint64} set {_uniqueStorage()._mapSint64Uint64 = newValue} } var mapSint64Sint32: Dictionary { - get {return _storage._mapSint64Sint32} + get {_storage._mapSint64Sint32} set {_uniqueStorage()._mapSint64Sint32 = newValue} } var mapSint64Sint64: Dictionary { - get {return _storage._mapSint64Sint64} + get {_storage._mapSint64Sint64} set {_uniqueStorage()._mapSint64Sint64 = newValue} } var mapSint64Fixed32: Dictionary { - get {return _storage._mapSint64Fixed32} + get {_storage._mapSint64Fixed32} set {_uniqueStorage()._mapSint64Fixed32 = newValue} } var mapSint64Fixed64: Dictionary { - get {return _storage._mapSint64Fixed64} + get {_storage._mapSint64Fixed64} set {_uniqueStorage()._mapSint64Fixed64 = newValue} } var mapSint64Sfixed32: Dictionary { - get {return _storage._mapSint64Sfixed32} + get {_storage._mapSint64Sfixed32} set {_uniqueStorage()._mapSint64Sfixed32 = newValue} } var mapSint64Sfixed64: Dictionary { - get {return _storage._mapSint64Sfixed64} + get {_storage._mapSint64Sfixed64} set {_uniqueStorage()._mapSint64Sfixed64 = newValue} } var mapSint64Float: Dictionary { - get {return _storage._mapSint64Float} + get {_storage._mapSint64Float} set {_uniqueStorage()._mapSint64Float = newValue} } var mapSint64Double: Dictionary { - get {return _storage._mapSint64Double} + get {_storage._mapSint64Double} set {_uniqueStorage()._mapSint64Double = newValue} } var mapSint64Bool: Dictionary { - get {return _storage._mapSint64Bool} + get {_storage._mapSint64Bool} set {_uniqueStorage()._mapSint64Bool = newValue} } var mapSint64String: Dictionary { - get {return _storage._mapSint64String} + get {_storage._mapSint64String} set {_uniqueStorage()._mapSint64String = newValue} } var mapSint64Bytes: Dictionary { - get {return _storage._mapSint64Bytes} + get {_storage._mapSint64Bytes} set {_uniqueStorage()._mapSint64Bytes = newValue} } - var mapSint64AnEnum: Dictionary { - get {return _storage._mapSint64AnEnum} + var mapSint64AnEnum: Dictionary { + get {_storage._mapSint64AnEnum} set {_uniqueStorage()._mapSint64AnEnum = newValue} } - var mapSint64Message: Dictionary { - get {return _storage._mapSint64Message} + var mapSint64Message: Dictionary { + get {_storage._mapSint64Message} set {_uniqueStorage()._mapSint64Message = newValue} } var mapFixed32Int32: Dictionary { - get {return _storage._mapFixed32Int32} + get {_storage._mapFixed32Int32} set {_uniqueStorage()._mapFixed32Int32 = newValue} } var mapFixed32Int64: Dictionary { - get {return _storage._mapFixed32Int64} + get {_storage._mapFixed32Int64} set {_uniqueStorage()._mapFixed32Int64 = newValue} } var mapFixed32Uint32: Dictionary { - get {return _storage._mapFixed32Uint32} + get {_storage._mapFixed32Uint32} set {_uniqueStorage()._mapFixed32Uint32 = newValue} } var mapFixed32Uint64: Dictionary { - get {return _storage._mapFixed32Uint64} + get {_storage._mapFixed32Uint64} set {_uniqueStorage()._mapFixed32Uint64 = newValue} } var mapFixed32Sint32: Dictionary { - get {return _storage._mapFixed32Sint32} + get {_storage._mapFixed32Sint32} set {_uniqueStorage()._mapFixed32Sint32 = newValue} } var mapFixed32Sint64: Dictionary { - get {return _storage._mapFixed32Sint64} + get {_storage._mapFixed32Sint64} set {_uniqueStorage()._mapFixed32Sint64 = newValue} } var mapFixed32Fixed32: Dictionary { - get {return _storage._mapFixed32Fixed32} + get {_storage._mapFixed32Fixed32} set {_uniqueStorage()._mapFixed32Fixed32 = newValue} } var mapFixed32Fixed64: Dictionary { - get {return _storage._mapFixed32Fixed64} + get {_storage._mapFixed32Fixed64} set {_uniqueStorage()._mapFixed32Fixed64 = newValue} } var mapFixed32Sfixed32: Dictionary { - get {return _storage._mapFixed32Sfixed32} + get {_storage._mapFixed32Sfixed32} set {_uniqueStorage()._mapFixed32Sfixed32 = newValue} } var mapFixed32Sfixed64: Dictionary { - get {return _storage._mapFixed32Sfixed64} + get {_storage._mapFixed32Sfixed64} set {_uniqueStorage()._mapFixed32Sfixed64 = newValue} } var mapFixed32Float: Dictionary { - get {return _storage._mapFixed32Float} + get {_storage._mapFixed32Float} set {_uniqueStorage()._mapFixed32Float = newValue} } var mapFixed32Double: Dictionary { - get {return _storage._mapFixed32Double} + get {_storage._mapFixed32Double} set {_uniqueStorage()._mapFixed32Double = newValue} } var mapFixed32Bool: Dictionary { - get {return _storage._mapFixed32Bool} + get {_storage._mapFixed32Bool} set {_uniqueStorage()._mapFixed32Bool = newValue} } var mapFixed32String: Dictionary { - get {return _storage._mapFixed32String} + get {_storage._mapFixed32String} set {_uniqueStorage()._mapFixed32String = newValue} } var mapFixed32Bytes: Dictionary { - get {return _storage._mapFixed32Bytes} + get {_storage._mapFixed32Bytes} set {_uniqueStorage()._mapFixed32Bytes = newValue} } - var mapFixed32AnEnum: Dictionary { - get {return _storage._mapFixed32AnEnum} + var mapFixed32AnEnum: Dictionary { + get {_storage._mapFixed32AnEnum} set {_uniqueStorage()._mapFixed32AnEnum = newValue} } - var mapFixed32Message: Dictionary { - get {return _storage._mapFixed32Message} + var mapFixed32Message: Dictionary { + get {_storage._mapFixed32Message} set {_uniqueStorage()._mapFixed32Message = newValue} } var mapFixed64Int32: Dictionary { - get {return _storage._mapFixed64Int32} + get {_storage._mapFixed64Int32} set {_uniqueStorage()._mapFixed64Int32 = newValue} } var mapFixed64Int64: Dictionary { - get {return _storage._mapFixed64Int64} + get {_storage._mapFixed64Int64} set {_uniqueStorage()._mapFixed64Int64 = newValue} } var mapFixed64Uint32: Dictionary { - get {return _storage._mapFixed64Uint32} + get {_storage._mapFixed64Uint32} set {_uniqueStorage()._mapFixed64Uint32 = newValue} } var mapFixed64Uint64: Dictionary { - get {return _storage._mapFixed64Uint64} + get {_storage._mapFixed64Uint64} set {_uniqueStorage()._mapFixed64Uint64 = newValue} } var mapFixed64Sint32: Dictionary { - get {return _storage._mapFixed64Sint32} + get {_storage._mapFixed64Sint32} set {_uniqueStorage()._mapFixed64Sint32 = newValue} } var mapFixed64Sint64: Dictionary { - get {return _storage._mapFixed64Sint64} + get {_storage._mapFixed64Sint64} set {_uniqueStorage()._mapFixed64Sint64 = newValue} } var mapFixed64Fixed32: Dictionary { - get {return _storage._mapFixed64Fixed32} + get {_storage._mapFixed64Fixed32} set {_uniqueStorage()._mapFixed64Fixed32 = newValue} } var mapFixed64Fixed64: Dictionary { - get {return _storage._mapFixed64Fixed64} + get {_storage._mapFixed64Fixed64} set {_uniqueStorage()._mapFixed64Fixed64 = newValue} } var mapFixed64Sfixed32: Dictionary { - get {return _storage._mapFixed64Sfixed32} + get {_storage._mapFixed64Sfixed32} set {_uniqueStorage()._mapFixed64Sfixed32 = newValue} } var mapFixed64Sfixed64: Dictionary { - get {return _storage._mapFixed64Sfixed64} + get {_storage._mapFixed64Sfixed64} set {_uniqueStorage()._mapFixed64Sfixed64 = newValue} } var mapFixed64Float: Dictionary { - get {return _storage._mapFixed64Float} + get {_storage._mapFixed64Float} set {_uniqueStorage()._mapFixed64Float = newValue} } var mapFixed64Double: Dictionary { - get {return _storage._mapFixed64Double} + get {_storage._mapFixed64Double} set {_uniqueStorage()._mapFixed64Double = newValue} } var mapFixed64Bool: Dictionary { - get {return _storage._mapFixed64Bool} + get {_storage._mapFixed64Bool} set {_uniqueStorage()._mapFixed64Bool = newValue} } var mapFixed64String: Dictionary { - get {return _storage._mapFixed64String} + get {_storage._mapFixed64String} set {_uniqueStorage()._mapFixed64String = newValue} } var mapFixed64Bytes: Dictionary { - get {return _storage._mapFixed64Bytes} + get {_storage._mapFixed64Bytes} set {_uniqueStorage()._mapFixed64Bytes = newValue} } - var mapFixed64AnEnum: Dictionary { - get {return _storage._mapFixed64AnEnum} + var mapFixed64AnEnum: Dictionary { + get {_storage._mapFixed64AnEnum} set {_uniqueStorage()._mapFixed64AnEnum = newValue} } - var mapFixed64Message: Dictionary { - get {return _storage._mapFixed64Message} + var mapFixed64Message: Dictionary { + get {_storage._mapFixed64Message} set {_uniqueStorage()._mapFixed64Message = newValue} } var mapSfixed32Int32: Dictionary { - get {return _storage._mapSfixed32Int32} + get {_storage._mapSfixed32Int32} set {_uniqueStorage()._mapSfixed32Int32 = newValue} } var mapSfixed32Int64: Dictionary { - get {return _storage._mapSfixed32Int64} + get {_storage._mapSfixed32Int64} set {_uniqueStorage()._mapSfixed32Int64 = newValue} } var mapSfixed32Uint32: Dictionary { - get {return _storage._mapSfixed32Uint32} + get {_storage._mapSfixed32Uint32} set {_uniqueStorage()._mapSfixed32Uint32 = newValue} } var mapSfixed32Uint64: Dictionary { - get {return _storage._mapSfixed32Uint64} + get {_storage._mapSfixed32Uint64} set {_uniqueStorage()._mapSfixed32Uint64 = newValue} } var mapSfixed32Sint32: Dictionary { - get {return _storage._mapSfixed32Sint32} + get {_storage._mapSfixed32Sint32} set {_uniqueStorage()._mapSfixed32Sint32 = newValue} } var mapSfixed32Sint64: Dictionary { - get {return _storage._mapSfixed32Sint64} + get {_storage._mapSfixed32Sint64} set {_uniqueStorage()._mapSfixed32Sint64 = newValue} } var mapSfixed32Fixed32: Dictionary { - get {return _storage._mapSfixed32Fixed32} + get {_storage._mapSfixed32Fixed32} set {_uniqueStorage()._mapSfixed32Fixed32 = newValue} } var mapSfixed32Fixed64: Dictionary { - get {return _storage._mapSfixed32Fixed64} + get {_storage._mapSfixed32Fixed64} set {_uniqueStorage()._mapSfixed32Fixed64 = newValue} } var mapSfixed32Sfixed32: Dictionary { - get {return _storage._mapSfixed32Sfixed32} + get {_storage._mapSfixed32Sfixed32} set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} } var mapSfixed32Sfixed64: Dictionary { - get {return _storage._mapSfixed32Sfixed64} + get {_storage._mapSfixed32Sfixed64} set {_uniqueStorage()._mapSfixed32Sfixed64 = newValue} } var mapSfixed32Float: Dictionary { - get {return _storage._mapSfixed32Float} + get {_storage._mapSfixed32Float} set {_uniqueStorage()._mapSfixed32Float = newValue} } var mapSfixed32Double: Dictionary { - get {return _storage._mapSfixed32Double} + get {_storage._mapSfixed32Double} set {_uniqueStorage()._mapSfixed32Double = newValue} } var mapSfixed32Bool: Dictionary { - get {return _storage._mapSfixed32Bool} + get {_storage._mapSfixed32Bool} set {_uniqueStorage()._mapSfixed32Bool = newValue} } var mapSfixed32String: Dictionary { - get {return _storage._mapSfixed32String} + get {_storage._mapSfixed32String} set {_uniqueStorage()._mapSfixed32String = newValue} } var mapSfixed32Bytes: Dictionary { - get {return _storage._mapSfixed32Bytes} + get {_storage._mapSfixed32Bytes} set {_uniqueStorage()._mapSfixed32Bytes = newValue} } - var mapSfixed32AnEnum: Dictionary { - get {return _storage._mapSfixed32AnEnum} + var mapSfixed32AnEnum: Dictionary { + get {_storage._mapSfixed32AnEnum} set {_uniqueStorage()._mapSfixed32AnEnum = newValue} } - var mapSfixed32Message: Dictionary { - get {return _storage._mapSfixed32Message} + var mapSfixed32Message: Dictionary { + get {_storage._mapSfixed32Message} set {_uniqueStorage()._mapSfixed32Message = newValue} } var mapSfixed64Int32: Dictionary { - get {return _storage._mapSfixed64Int32} + get {_storage._mapSfixed64Int32} set {_uniqueStorage()._mapSfixed64Int32 = newValue} } var mapSfixed64Int64: Dictionary { - get {return _storage._mapSfixed64Int64} + get {_storage._mapSfixed64Int64} set {_uniqueStorage()._mapSfixed64Int64 = newValue} } var mapSfixed64Uint32: Dictionary { - get {return _storage._mapSfixed64Uint32} + get {_storage._mapSfixed64Uint32} set {_uniqueStorage()._mapSfixed64Uint32 = newValue} } var mapSfixed64Uint64: Dictionary { - get {return _storage._mapSfixed64Uint64} + get {_storage._mapSfixed64Uint64} set {_uniqueStorage()._mapSfixed64Uint64 = newValue} } var mapSfixed64Sint32: Dictionary { - get {return _storage._mapSfixed64Sint32} + get {_storage._mapSfixed64Sint32} set {_uniqueStorage()._mapSfixed64Sint32 = newValue} } var mapSfixed64Sint64: Dictionary { - get {return _storage._mapSfixed64Sint64} + get {_storage._mapSfixed64Sint64} set {_uniqueStorage()._mapSfixed64Sint64 = newValue} } var mapSfixed64Fixed32: Dictionary { - get {return _storage._mapSfixed64Fixed32} + get {_storage._mapSfixed64Fixed32} set {_uniqueStorage()._mapSfixed64Fixed32 = newValue} } var mapSfixed64Fixed64: Dictionary { - get {return _storage._mapSfixed64Fixed64} + get {_storage._mapSfixed64Fixed64} set {_uniqueStorage()._mapSfixed64Fixed64 = newValue} } var mapSfixed64Sfixed32: Dictionary { - get {return _storage._mapSfixed64Sfixed32} + get {_storage._mapSfixed64Sfixed32} set {_uniqueStorage()._mapSfixed64Sfixed32 = newValue} } var mapSfixed64Sfixed64: Dictionary { - get {return _storage._mapSfixed64Sfixed64} + get {_storage._mapSfixed64Sfixed64} set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} } var mapSfixed64Float: Dictionary { - get {return _storage._mapSfixed64Float} + get {_storage._mapSfixed64Float} set {_uniqueStorage()._mapSfixed64Float = newValue} } var mapSfixed64Double: Dictionary { - get {return _storage._mapSfixed64Double} + get {_storage._mapSfixed64Double} set {_uniqueStorage()._mapSfixed64Double = newValue} } var mapSfixed64Bool: Dictionary { - get {return _storage._mapSfixed64Bool} + get {_storage._mapSfixed64Bool} set {_uniqueStorage()._mapSfixed64Bool = newValue} } var mapSfixed64String: Dictionary { - get {return _storage._mapSfixed64String} + get {_storage._mapSfixed64String} set {_uniqueStorage()._mapSfixed64String = newValue} } var mapSfixed64Bytes: Dictionary { - get {return _storage._mapSfixed64Bytes} + get {_storage._mapSfixed64Bytes} set {_uniqueStorage()._mapSfixed64Bytes = newValue} } - var mapSfixed64AnEnum: Dictionary { - get {return _storage._mapSfixed64AnEnum} + var mapSfixed64AnEnum: Dictionary { + get {_storage._mapSfixed64AnEnum} set {_uniqueStorage()._mapSfixed64AnEnum = newValue} } - var mapSfixed64Message: Dictionary { - get {return _storage._mapSfixed64Message} + var mapSfixed64Message: Dictionary { + get {_storage._mapSfixed64Message} set {_uniqueStorage()._mapSfixed64Message = newValue} } var mapBoolInt32: Dictionary { - get {return _storage._mapBoolInt32} + get {_storage._mapBoolInt32} set {_uniqueStorage()._mapBoolInt32 = newValue} } var mapBoolInt64: Dictionary { - get {return _storage._mapBoolInt64} + get {_storage._mapBoolInt64} set {_uniqueStorage()._mapBoolInt64 = newValue} } var mapBoolUint32: Dictionary { - get {return _storage._mapBoolUint32} + get {_storage._mapBoolUint32} set {_uniqueStorage()._mapBoolUint32 = newValue} } var mapBoolUint64: Dictionary { - get {return _storage._mapBoolUint64} + get {_storage._mapBoolUint64} set {_uniqueStorage()._mapBoolUint64 = newValue} } var mapBoolSint32: Dictionary { - get {return _storage._mapBoolSint32} + get {_storage._mapBoolSint32} set {_uniqueStorage()._mapBoolSint32 = newValue} } var mapBoolSint64: Dictionary { - get {return _storage._mapBoolSint64} + get {_storage._mapBoolSint64} set {_uniqueStorage()._mapBoolSint64 = newValue} } var mapBoolFixed32: Dictionary { - get {return _storage._mapBoolFixed32} + get {_storage._mapBoolFixed32} set {_uniqueStorage()._mapBoolFixed32 = newValue} } var mapBoolFixed64: Dictionary { - get {return _storage._mapBoolFixed64} + get {_storage._mapBoolFixed64} set {_uniqueStorage()._mapBoolFixed64 = newValue} } var mapBoolSfixed32: Dictionary { - get {return _storage._mapBoolSfixed32} + get {_storage._mapBoolSfixed32} set {_uniqueStorage()._mapBoolSfixed32 = newValue} } var mapBoolSfixed64: Dictionary { - get {return _storage._mapBoolSfixed64} + get {_storage._mapBoolSfixed64} set {_uniqueStorage()._mapBoolSfixed64 = newValue} } var mapBoolFloat: Dictionary { - get {return _storage._mapBoolFloat} + get {_storage._mapBoolFloat} set {_uniqueStorage()._mapBoolFloat = newValue} } var mapBoolDouble: Dictionary { - get {return _storage._mapBoolDouble} + get {_storage._mapBoolDouble} set {_uniqueStorage()._mapBoolDouble = newValue} } var mapBoolBool: Dictionary { - get {return _storage._mapBoolBool} + get {_storage._mapBoolBool} set {_uniqueStorage()._mapBoolBool = newValue} } var mapBoolString: Dictionary { - get {return _storage._mapBoolString} + get {_storage._mapBoolString} set {_uniqueStorage()._mapBoolString = newValue} } var mapBoolBytes: Dictionary { - get {return _storage._mapBoolBytes} + get {_storage._mapBoolBytes} set {_uniqueStorage()._mapBoolBytes = newValue} } - var mapBoolAnEnum: Dictionary { - get {return _storage._mapBoolAnEnum} + var mapBoolAnEnum: Dictionary { + get {_storage._mapBoolAnEnum} set {_uniqueStorage()._mapBoolAnEnum = newValue} } - var mapBoolMessage: Dictionary { - get {return _storage._mapBoolMessage} + var mapBoolMessage: Dictionary { + get {_storage._mapBoolMessage} set {_uniqueStorage()._mapBoolMessage = newValue} } /// WKTs since some get special handing in JSON. var wktAny: SwiftProtobuf.Google_Protobuf_Any { - get {return _storage._wktAny ?? SwiftProtobuf.Google_Protobuf_Any()} + get {_storage._wktAny ?? SwiftProtobuf.Google_Protobuf_Any()} set {_uniqueStorage()._wktAny = newValue} } /// Returns true if `wktAny` has been explicitly set. - var hasWktAny: Bool {return _storage._wktAny != nil} + var hasWktAny: Bool {_storage._wktAny != nil} /// Clears the value of `wktAny`. Subsequent reads from it will return its default value. mutating func clearWktAny() {_uniqueStorage()._wktAny = nil} var wktApi: SwiftProtobuf.Google_Protobuf_Api { - get {return _storage._wktApi ?? SwiftProtobuf.Google_Protobuf_Api()} + get {_storage._wktApi ?? SwiftProtobuf.Google_Protobuf_Api()} set {_uniqueStorage()._wktApi = newValue} } /// Returns true if `wktApi` has been explicitly set. - var hasWktApi: Bool {return _storage._wktApi != nil} + var hasWktApi: Bool {_storage._wktApi != nil} /// Clears the value of `wktApi`. Subsequent reads from it will return its default value. mutating func clearWktApi() {_uniqueStorage()._wktApi = nil} var wktDuration: SwiftProtobuf.Google_Protobuf_Duration { - get {return _storage._wktDuration ?? SwiftProtobuf.Google_Protobuf_Duration()} + get {_storage._wktDuration ?? SwiftProtobuf.Google_Protobuf_Duration()} set {_uniqueStorage()._wktDuration = newValue} } /// Returns true if `wktDuration` has been explicitly set. - var hasWktDuration: Bool {return _storage._wktDuration != nil} + var hasWktDuration: Bool {_storage._wktDuration != nil} /// Clears the value of `wktDuration`. Subsequent reads from it will return its default value. mutating func clearWktDuration() {_uniqueStorage()._wktDuration = nil} var wktEmpty: SwiftProtobuf.Google_Protobuf_Empty { - get {return _storage._wktEmpty ?? SwiftProtobuf.Google_Protobuf_Empty()} + get {_storage._wktEmpty ?? SwiftProtobuf.Google_Protobuf_Empty()} set {_uniqueStorage()._wktEmpty = newValue} } /// Returns true if `wktEmpty` has been explicitly set. - var hasWktEmpty: Bool {return _storage._wktEmpty != nil} + var hasWktEmpty: Bool {_storage._wktEmpty != nil} /// Clears the value of `wktEmpty`. Subsequent reads from it will return its default value. mutating func clearWktEmpty() {_uniqueStorage()._wktEmpty = nil} var wktFieldMask: SwiftProtobuf.Google_Protobuf_FieldMask { - get {return _storage._wktFieldMask ?? SwiftProtobuf.Google_Protobuf_FieldMask()} + get {_storage._wktFieldMask ?? SwiftProtobuf.Google_Protobuf_FieldMask()} set {_uniqueStorage()._wktFieldMask = newValue} } /// Returns true if `wktFieldMask` has been explicitly set. - var hasWktFieldMask: Bool {return _storage._wktFieldMask != nil} + var hasWktFieldMask: Bool {_storage._wktFieldMask != nil} /// Clears the value of `wktFieldMask`. Subsequent reads from it will return its default value. mutating func clearWktFieldMask() {_uniqueStorage()._wktFieldMask = nil} var wktSourceContext: SwiftProtobuf.Google_Protobuf_SourceContext { - get {return _storage._wktSourceContext ?? SwiftProtobuf.Google_Protobuf_SourceContext()} + get {_storage._wktSourceContext ?? SwiftProtobuf.Google_Protobuf_SourceContext()} set {_uniqueStorage()._wktSourceContext = newValue} } /// Returns true if `wktSourceContext` has been explicitly set. - var hasWktSourceContext: Bool {return _storage._wktSourceContext != nil} + var hasWktSourceContext: Bool {_storage._wktSourceContext != nil} /// Clears the value of `wktSourceContext`. Subsequent reads from it will return its default value. mutating func clearWktSourceContext() {_uniqueStorage()._wktSourceContext = nil} var wktStruct: SwiftProtobuf.Google_Protobuf_Struct { - get {return _storage._wktStruct ?? SwiftProtobuf.Google_Protobuf_Struct()} + get {_storage._wktStruct ?? SwiftProtobuf.Google_Protobuf_Struct()} set {_uniqueStorage()._wktStruct = newValue} } /// Returns true if `wktStruct` has been explicitly set. - var hasWktStruct: Bool {return _storage._wktStruct != nil} + var hasWktStruct: Bool {_storage._wktStruct != nil} /// Clears the value of `wktStruct`. Subsequent reads from it will return its default value. mutating func clearWktStruct() {_uniqueStorage()._wktStruct = nil} var wktTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp { - get {return _storage._wktTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()} + get {_storage._wktTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()} set {_uniqueStorage()._wktTimestamp = newValue} } /// Returns true if `wktTimestamp` has been explicitly set. - var hasWktTimestamp: Bool {return _storage._wktTimestamp != nil} + var hasWktTimestamp: Bool {_storage._wktTimestamp != nil} /// Clears the value of `wktTimestamp`. Subsequent reads from it will return its default value. mutating func clearWktTimestamp() {_uniqueStorage()._wktTimestamp = nil} var wktType: SwiftProtobuf.Google_Protobuf_Type { - get {return _storage._wktType ?? SwiftProtobuf.Google_Protobuf_Type()} + get {_storage._wktType ?? SwiftProtobuf.Google_Protobuf_Type()} set {_uniqueStorage()._wktType = newValue} } /// Returns true if `wktType` has been explicitly set. - var hasWktType: Bool {return _storage._wktType != nil} + var hasWktType: Bool {_storage._wktType != nil} /// Clears the value of `wktType`. Subsequent reads from it will return its default value. mutating func clearWktType() {_uniqueStorage()._wktType = nil} var wktDoubleValue: SwiftProtobuf.Google_Protobuf_DoubleValue { - get {return _storage._wktDoubleValue ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} + get {_storage._wktDoubleValue ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} set {_uniqueStorage()._wktDoubleValue = newValue} } /// Returns true if `wktDoubleValue` has been explicitly set. - var hasWktDoubleValue: Bool {return _storage._wktDoubleValue != nil} + var hasWktDoubleValue: Bool {_storage._wktDoubleValue != nil} /// Clears the value of `wktDoubleValue`. Subsequent reads from it will return its default value. mutating func clearWktDoubleValue() {_uniqueStorage()._wktDoubleValue = nil} var wktFloatValue: SwiftProtobuf.Google_Protobuf_FloatValue { - get {return _storage._wktFloatValue ?? SwiftProtobuf.Google_Protobuf_FloatValue()} + get {_storage._wktFloatValue ?? SwiftProtobuf.Google_Protobuf_FloatValue()} set {_uniqueStorage()._wktFloatValue = newValue} } /// Returns true if `wktFloatValue` has been explicitly set. - var hasWktFloatValue: Bool {return _storage._wktFloatValue != nil} + var hasWktFloatValue: Bool {_storage._wktFloatValue != nil} /// Clears the value of `wktFloatValue`. Subsequent reads from it will return its default value. mutating func clearWktFloatValue() {_uniqueStorage()._wktFloatValue = nil} var wktInt64Value: SwiftProtobuf.Google_Protobuf_Int64Value { - get {return _storage._wktInt64Value ?? SwiftProtobuf.Google_Protobuf_Int64Value()} + get {_storage._wktInt64Value ?? SwiftProtobuf.Google_Protobuf_Int64Value()} set {_uniqueStorage()._wktInt64Value = newValue} } /// Returns true if `wktInt64Value` has been explicitly set. - var hasWktInt64Value: Bool {return _storage._wktInt64Value != nil} + var hasWktInt64Value: Bool {_storage._wktInt64Value != nil} /// Clears the value of `wktInt64Value`. Subsequent reads from it will return its default value. mutating func clearWktInt64Value() {_uniqueStorage()._wktInt64Value = nil} var wktUint64Value: SwiftProtobuf.Google_Protobuf_UInt64Value { - get {return _storage._wktUint64Value ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} + get {_storage._wktUint64Value ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} set {_uniqueStorage()._wktUint64Value = newValue} } /// Returns true if `wktUint64Value` has been explicitly set. - var hasWktUint64Value: Bool {return _storage._wktUint64Value != nil} + var hasWktUint64Value: Bool {_storage._wktUint64Value != nil} /// Clears the value of `wktUint64Value`. Subsequent reads from it will return its default value. mutating func clearWktUint64Value() {_uniqueStorage()._wktUint64Value = nil} var wktInt32Value: SwiftProtobuf.Google_Protobuf_Int32Value { - get {return _storage._wktInt32Value ?? SwiftProtobuf.Google_Protobuf_Int32Value()} + get {_storage._wktInt32Value ?? SwiftProtobuf.Google_Protobuf_Int32Value()} set {_uniqueStorage()._wktInt32Value = newValue} } /// Returns true if `wktInt32Value` has been explicitly set. - var hasWktInt32Value: Bool {return _storage._wktInt32Value != nil} + var hasWktInt32Value: Bool {_storage._wktInt32Value != nil} /// Clears the value of `wktInt32Value`. Subsequent reads from it will return its default value. mutating func clearWktInt32Value() {_uniqueStorage()._wktInt32Value = nil} var wktUint32Value: SwiftProtobuf.Google_Protobuf_UInt32Value { - get {return _storage._wktUint32Value ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} + get {_storage._wktUint32Value ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} set {_uniqueStorage()._wktUint32Value = newValue} } /// Returns true if `wktUint32Value` has been explicitly set. - var hasWktUint32Value: Bool {return _storage._wktUint32Value != nil} + var hasWktUint32Value: Bool {_storage._wktUint32Value != nil} /// Clears the value of `wktUint32Value`. Subsequent reads from it will return its default value. mutating func clearWktUint32Value() {_uniqueStorage()._wktUint32Value = nil} var wktBoolValue: SwiftProtobuf.Google_Protobuf_BoolValue { - get {return _storage._wktBoolValue ?? SwiftProtobuf.Google_Protobuf_BoolValue()} + get {_storage._wktBoolValue ?? SwiftProtobuf.Google_Protobuf_BoolValue()} set {_uniqueStorage()._wktBoolValue = newValue} } /// Returns true if `wktBoolValue` has been explicitly set. - var hasWktBoolValue: Bool {return _storage._wktBoolValue != nil} + var hasWktBoolValue: Bool {_storage._wktBoolValue != nil} /// Clears the value of `wktBoolValue`. Subsequent reads from it will return its default value. mutating func clearWktBoolValue() {_uniqueStorage()._wktBoolValue = nil} var wktStringValue: SwiftProtobuf.Google_Protobuf_StringValue { - get {return _storage._wktStringValue ?? SwiftProtobuf.Google_Protobuf_StringValue()} + get {_storage._wktStringValue ?? SwiftProtobuf.Google_Protobuf_StringValue()} set {_uniqueStorage()._wktStringValue = newValue} } /// Returns true if `wktStringValue` has been explicitly set. - var hasWktStringValue: Bool {return _storage._wktStringValue != nil} + var hasWktStringValue: Bool {_storage._wktStringValue != nil} /// Clears the value of `wktStringValue`. Subsequent reads from it will return its default value. mutating func clearWktStringValue() {_uniqueStorage()._wktStringValue = nil} var wktBytesValue: SwiftProtobuf.Google_Protobuf_BytesValue { - get {return _storage._wktBytesValue ?? SwiftProtobuf.Google_Protobuf_BytesValue()} + get {_storage._wktBytesValue ?? SwiftProtobuf.Google_Protobuf_BytesValue()} set {_uniqueStorage()._wktBytesValue = newValue} } /// Returns true if `wktBytesValue` has been explicitly set. - var hasWktBytesValue: Bool {return _storage._wktBytesValue != nil} + var hasWktBytesValue: Bool {_storage._wktBytesValue != nil} /// Clears the value of `wktBytesValue`. Subsequent reads from it will return its default value. mutating func clearWktBytesValue() {_uniqueStorage()._wktBytesValue = nil} /// Get some coverage for the special message_set_wire_format. - var singularMessageSet: Fuzz_Testing_AMessageSetMessage { - get {return _storage._singularMessageSet ?? Fuzz_Testing_AMessageSetMessage()} + var singularMessageSet: SwiftProtoTesting_Fuzz_AMessageSetMessage { + get {_storage._singularMessageSet ?? SwiftProtoTesting_Fuzz_AMessageSetMessage()} set {_uniqueStorage()._singularMessageSet = newValue} } /// Returns true if `singularMessageSet` has been explicitly set. - var hasSingularMessageSet: Bool {return _storage._singularMessageSet != nil} + var hasSingularMessageSet: Bool {_storage._singularMessageSet != nil} /// Clears the value of `singularMessageSet`. Subsequent reads from it will return its default value. mutating func clearSingularMessageSet() {_uniqueStorage()._singularMessageSet = nil} - var repeatedMessageSet: [Fuzz_Testing_AMessageSetMessage] { - get {return _storage._repeatedMessageSet} + var repeatedMessageSet: [SwiftProtoTesting_Fuzz_AMessageSetMessage] { + get {_storage._repeatedMessageSet} set {_uniqueStorage()._repeatedMessageSet = newValue} } var unknownFields = SwiftProtobuf.UnknownStorage() /// oneof - enum OneOf_O: Equatable { + enum OneOf_O: Equatable, Sendable { case oneofInt32(Int32) case oneofInt64(Int64) case oneofUint32(UInt32) @@ -1687,110 +1660,28 @@ struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { case oneofBool(Bool) case oneofString(String) case oneofBytes(Data) - case oneofEnum(Fuzz_Testing_AnEnum) - case oneofGroup(Fuzz_Testing_Message.OneofGroup) - case oneofMessage(Fuzz_Testing_Message) + case oneofEnum(SwiftProtoTesting_Fuzz_AnEnum) + case oneofGroup(SwiftProtoTesting_Fuzz_Message.OneofGroup) + case oneofMessage(SwiftProtoTesting_Fuzz_Message) fileprivate var isInitialized: Bool { guard case .oneofMessage(let v) = self else {return true} return v.isInitialized } - #if !swift(>=4.1) - static func ==(lhs: Fuzz_Testing_Message.OneOf_O, rhs: Fuzz_Testing_Message.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 (.oneofInt32, .oneofInt32): return { - guard case .oneofInt32(let l) = lhs, case .oneofInt32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofInt64, .oneofInt64): return { - guard case .oneofInt64(let l) = lhs, case .oneofInt64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint64, .oneofUint64): return { - guard case .oneofUint64(let l) = lhs, case .oneofUint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSint32, .oneofSint32): return { - guard case .oneofSint32(let l) = lhs, case .oneofSint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSint64, .oneofSint64): return { - guard case .oneofSint64(let l) = lhs, case .oneofSint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFixed32, .oneofFixed32): return { - guard case .oneofFixed32(let l) = lhs, case .oneofFixed32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFixed64, .oneofFixed64): return { - guard case .oneofFixed64(let l) = lhs, case .oneofFixed64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSfixed32, .oneofSfixed32): return { - guard case .oneofSfixed32(let l) = lhs, case .oneofSfixed32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSfixed64, .oneofSfixed64): return { - guard case .oneofSfixed64(let l) = lhs, case .oneofSfixed64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFloat, .oneofFloat): return { - guard case .oneofFloat(let l) = lhs, case .oneofFloat(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofDouble, .oneofDouble): return { - guard case .oneofDouble(let l) = lhs, case .oneofDouble(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBool, .oneofBool): return { - guard case .oneofBool(let l) = lhs, case .oneofBool(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofEnum, .oneofEnum): return { - guard case .oneofEnum(let l) = lhs, case .oneofEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofGroup, .oneofGroup): return { - guard case .oneofGroup(let l) = lhs, case .oneofGroup(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofMessage, .oneofMessage): return { - guard case .oneofMessage(let l) = lhs, case .oneofMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - struct SingularGroup { + struct SingularGroup: Sendable { // 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 groupField: Int32 { - get {return _groupField ?? 0} + get {_groupField ?? 0} set {_groupField = newValue} } /// Returns true if `groupField` has been explicitly set. - var hasGroupField: Bool {return self._groupField != nil} + var hasGroupField: Bool {self._groupField != nil} /// Clears the value of `groupField`. Subsequent reads from it will return its default value. mutating func clearGroupField() {self._groupField = nil} @@ -1801,17 +1692,17 @@ struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { fileprivate var _groupField: Int32? = nil } - struct RepeatedGroup { + struct RepeatedGroup: Sendable { // 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 groupField: Int32 { - get {return _groupField ?? 0} + get {_groupField ?? 0} set {_groupField = newValue} } /// Returns true if `groupField` has been explicitly set. - var hasGroupField: Bool {return self._groupField != nil} + var hasGroupField: Bool {self._groupField != nil} /// Clears the value of `groupField`. Subsequent reads from it will return its default value. mutating func clearGroupField() {self._groupField = nil} @@ -1822,17 +1713,17 @@ struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { fileprivate var _groupField: Int32? = nil } - struct OneofGroup { + struct OneofGroup: Sendable { // 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 groupField: Int32 { - get {return _groupField ?? 0} + get {_groupField ?? 0} set {_groupField = newValue} } /// Returns true if `groupField` has been explicitly set. - var hasGroupField: Bool {return self._groupField != nil} + var hasGroupField: Bool {self._groupField != nil} /// Clears the value of `groupField`. Subsequent reads from it will return its default value. mutating func clearGroupField() {self._groupField = nil} @@ -1850,7 +1741,7 @@ struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { } /// A message with message_set_wire_format. -struct Fuzz_Testing_AMessageSetMessage: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Fuzz_AMessageSetMessage: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -1862,17 +1753,60 @@ struct Fuzz_Testing_AMessageSetMessage: SwiftProtobuf.ExtensibleMessage { var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct Fuzz_Testing_SingularGroup_ext { +/// Two extensions to go with the message_set_wire_format testing. +struct SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1: Sendable { + // 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 aString: String { + get {_aString ?? String()} + set {_aString = newValue} + } + /// Returns true if `aString` has been explicitly set. + var hasAString: Bool {self._aString != nil} + /// Clears the value of `aString`. Subsequent reads from it will return its default value. + mutating func clearAString() {self._aString = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _aString: String? = nil +} + +struct SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2: Sendable { + // 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 anInt32: Int32 { + get {_anInt32 ?? 0} + set {_anInt32 = newValue} + } + /// Returns true if `anInt32` has been explicitly set. + var hasAnInt32: Bool {self._anInt32 != nil} + /// Clears the value of `anInt32`. Subsequent reads from it will return its default value. + mutating func clearAnInt32() {self._anInt32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _anInt32: Int32? = nil +} + +struct SwiftProtoTesting_Fuzz_SingularGroup_ext: Sendable { // 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 groupField: Int32 { - get {return _groupField ?? 0} + get {_groupField ?? 0} set {_groupField = newValue} } /// Returns true if `groupField` has been explicitly set. - var hasGroupField: Bool {return self._groupField != nil} + var hasGroupField: Bool {self._groupField != nil} /// Clears the value of `groupField`. Subsequent reads from it will return its default value. mutating func clearGroupField() {self._groupField = nil} @@ -1883,17 +1817,17 @@ struct Fuzz_Testing_SingularGroup_ext { fileprivate var _groupField: Int32? = nil } -struct Fuzz_Testing_RepeatedGroup_ext { +struct SwiftProtoTesting_Fuzz_RepeatedGroup_ext: Sendable { // 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 groupField: Int32 { - get {return _groupField ?? 0} + get {_groupField ?? 0} set {_groupField = newValue} } /// Returns true if `groupField` has been explicitly set. - var hasGroupField: Bool {return self._groupField != nil} + var hasGroupField: Bool {self._groupField != nil} /// Clears the value of `groupField`. Subsequent reads from it will return its default value. mutating func clearGroupField() {self._groupField = nil} @@ -1904,841 +1838,544 @@ struct Fuzz_Testing_RepeatedGroup_ext { fileprivate var _groupField: Int32? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension Fuzz_Testing_AnEnum: @unchecked Sendable {} -extension Fuzz_Testing_Message: @unchecked Sendable {} -extension Fuzz_Testing_Message.OneOf_O: @unchecked Sendable {} -extension Fuzz_Testing_Message.SingularGroup: @unchecked Sendable {} -extension Fuzz_Testing_Message.RepeatedGroup: @unchecked Sendable {} -extension Fuzz_Testing_Message.OneofGroup: @unchecked Sendable {} -extension Fuzz_Testing_AMessageSetMessage: @unchecked Sendable {} -extension Fuzz_Testing_SingularGroup_ext: @unchecked Sendable {} -extension Fuzz_Testing_RepeatedGroup_ext: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in fuzz_testing.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 Fuzz_Testing_Message { +extension SwiftProtoTesting_Fuzz_AMessageSetMessage { - /// Singular - var Fuzz_Testing_singularInt32Ext: Int32 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_int32_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_int32_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1_messageSetExtension: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension) ?? SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1()} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_int32_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension` /// has been explicitly set. - var hasFuzz_Testing_singularInt32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_int32_ext) + var hasSwiftProtoTesting_Fuzz_AMessageSetMessageExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_int32_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularInt32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_int32_ext) + mutating func clearSwiftProtoTesting_Fuzz_AMessageSetMessageExtension1_messageSetExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension) } - var Fuzz_Testing_singularInt64Ext: Int64 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_int64_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_int64_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2_messageSetExtension: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension) ?? SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2()} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_int64_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension` /// has been explicitly set. - var hasFuzz_Testing_singularInt64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_int64_ext) + var hasSwiftProtoTesting_Fuzz_AMessageSetMessageExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_int64_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularInt64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_int64_ext) + mutating func clearSwiftProtoTesting_Fuzz_AMessageSetMessageExtension2_messageSetExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension) } +} - var Fuzz_Testing_singularUint32Ext: UInt32 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint32_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_uint32_ext` - /// has been explicitly set. - var hasFuzz_Testing_singularUint32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_uint32_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularUint32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint32_ext) - } +extension SwiftProtoTesting_Fuzz_Message { - var Fuzz_Testing_singularUint64Ext: UInt64 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint64_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint64_ext, value: newValue)} + /// Singular + var SwiftProtoTesting_Fuzz_singularInt32Ext: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_uint64_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext` /// has been explicitly set. - var hasFuzz_Testing_singularUint64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint64_ext) + var hasSwiftProtoTesting_Fuzz_singularInt32Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_uint64_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularUint64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint64_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularInt32Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext) } - var Fuzz_Testing_singularSint32Ext: Int32 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint32_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint32_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularInt64Ext: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_sint32_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext` /// has been explicitly set. - var hasFuzz_Testing_singularSint32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint32_ext) + var hasSwiftProtoTesting_Fuzz_singularInt64Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_sint32_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularSint32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint32_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularInt64Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext) } - var Fuzz_Testing_singularSint64Ext: Int64 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint64_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint64_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularUint32Ext: UInt32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_sint64_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext` /// has been explicitly set. - var hasFuzz_Testing_singularSint64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint64_ext) + var hasSwiftProtoTesting_Fuzz_singularUint32Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_sint64_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularSint64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint64_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularUint32Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext) } - var Fuzz_Testing_singularFixed32Ext: UInt32 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed32_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed32_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularUint64Ext: UInt64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_fixed32_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext` /// has been explicitly set. - var hasFuzz_Testing_singularFixed32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed32_ext) + var hasSwiftProtoTesting_Fuzz_singularUint64Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_fixed32_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularFixed32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed32_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularUint64Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext) } - var Fuzz_Testing_singularFixed64Ext: UInt64 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed64_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed64_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularSint32Ext: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_fixed64_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext` /// has been explicitly set. - var hasFuzz_Testing_singularFixed64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed64_ext) + var hasSwiftProtoTesting_Fuzz_singularSint32Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_fixed64_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularFixed64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed64_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularSint32Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext) } - var Fuzz_Testing_singularSfixed32Ext: Int32 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed32_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed32_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularSint64Ext: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_sfixed32_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext` /// has been explicitly set. - var hasFuzz_Testing_singularSfixed32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed32_ext) + var hasSwiftProtoTesting_Fuzz_singularSint64Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_sfixed32_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularSfixed32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed32_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularSint64Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext) } - var Fuzz_Testing_singularSfixed64Ext: Int64 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed64_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed64_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularFixed32Ext: UInt32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_sfixed64_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext` /// has been explicitly set. - var hasFuzz_Testing_singularSfixed64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed64_ext) + var hasSwiftProtoTesting_Fuzz_singularFixed32Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_sfixed64_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularSfixed64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed64_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularFixed32Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext) } - var Fuzz_Testing_singularFloatExt: Float { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_float_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_float_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularFixed64Ext: UInt64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_float_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext` /// has been explicitly set. - var hasFuzz_Testing_singularFloatExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_float_ext) + var hasSwiftProtoTesting_Fuzz_singularFixed64Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_float_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularFloatExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_float_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularFixed64Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext) } - var Fuzz_Testing_singularDoubleExt: Double { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_double_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_double_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularSfixed32Ext: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_double_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext` /// has been explicitly set. - var hasFuzz_Testing_singularDoubleExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_double_ext) + var hasSwiftProtoTesting_Fuzz_singularSfixed32Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_double_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularDoubleExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_double_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularSfixed32Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext) } - var Fuzz_Testing_singularBoolExt: Bool { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_bool_ext) ?? false} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_bool_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularSfixed64Ext: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_bool_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext` /// has been explicitly set. - var hasFuzz_Testing_singularBoolExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_bool_ext) + var hasSwiftProtoTesting_Fuzz_singularSfixed64Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_bool_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularBoolExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_bool_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularSfixed64Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext) } - var Fuzz_Testing_singularStringExt: String { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_string_ext) ?? String()} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_string_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularFloatExt: Float { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_float_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_float_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_string_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_float_ext` /// has been explicitly set. - var hasFuzz_Testing_singularStringExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_string_ext) + var hasSwiftProtoTesting_Fuzz_singularFloatExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_float_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_string_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_float_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularStringExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_string_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularFloatExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_float_ext) } - var Fuzz_Testing_singularBytesExt: Data { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_bytes_ext) ?? Data()} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_bytes_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularDoubleExt: Double { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_double_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_double_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_bytes_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_double_ext` /// has been explicitly set. - var hasFuzz_Testing_singularBytesExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_bytes_ext) + var hasSwiftProtoTesting_Fuzz_singularDoubleExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_double_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_bytes_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_double_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularBytesExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_bytes_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularDoubleExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_double_ext) } - var Fuzz_Testing_singularEnumExt: Fuzz_Testing_AnEnum { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_enum_ext) ?? .zero} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_enum_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularBoolExt: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_enum_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext` /// has been explicitly set. - var hasFuzz_Testing_singularEnumExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_enum_ext) + var hasSwiftProtoTesting_Fuzz_singularBoolExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_enum_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularEnumExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_enum_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularBoolExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext) } - var Fuzz_Testing_singularGroupExt: Fuzz_Testing_SingularGroup_ext { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_SingularGroup_ext) ?? Fuzz_Testing_SingularGroup_ext()} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_SingularGroup_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularStringExt: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_string_ext) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_string_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_SingularGroup_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_string_ext` /// has been explicitly set. - var hasFuzz_Testing_singularGroupExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_SingularGroup_ext) + var hasSwiftProtoTesting_Fuzz_singularStringExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_string_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_SingularGroup_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_string_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularGroupExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_SingularGroup_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularStringExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_string_ext) } - var Fuzz_Testing_singularMessageExt: Fuzz_Testing_Message { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_message_ext) ?? Fuzz_Testing_Message()} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_message_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularBytesExt: Data { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext) ?? Data()} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_message_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext` /// has been explicitly set. - var hasFuzz_Testing_singularMessageExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_message_ext) + var hasSwiftProtoTesting_Fuzz_singularBytesExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_message_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularMessageExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_message_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularBytesExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext) } - /// Repeated - var Fuzz_Testing_repeatedInt32Ext: [Int32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int32_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularEnumExt: SwiftProtoTesting_Fuzz_AnEnum { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext) ?? .zero} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_int32_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext` /// has been explicitly set. - var hasFuzz_Testing_repeatedInt32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int32_ext) + var hasSwiftProtoTesting_Fuzz_singularEnumExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_int32_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedInt32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int32_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularEnumExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext) } - var Fuzz_Testing_repeatedInt64Ext: [Int64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int64_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularGroupExt: SwiftProtoTesting_Fuzz_SingularGroup_ext { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext) ?? SwiftProtoTesting_Fuzz_SingularGroup_ext()} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_int64_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext` /// has been explicitly set. - var hasFuzz_Testing_repeatedInt64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int64_ext) + var hasSwiftProtoTesting_Fuzz_singularGroupExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_int64_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedInt64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int64_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularGroupExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext) } - var Fuzz_Testing_repeatedUint32Ext: [UInt32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint32_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularMessageExt: SwiftProtoTesting_Fuzz_Message { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_message_ext) ?? SwiftProtoTesting_Fuzz_Message()} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_message_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_uint32_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_message_ext` /// has been explicitly set. - var hasFuzz_Testing_repeatedUint32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint32_ext) + var hasSwiftProtoTesting_Fuzz_singularMessageExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_message_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_uint32_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_message_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedUint32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint32_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularMessageExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_message_ext) } - var Fuzz_Testing_repeatedUint64Ext: [UInt64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_uint64_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedUint64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_uint64_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedUint64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint64_ext) + /// Repeated + var SwiftProtoTesting_Fuzz_repeatedInt32Ext: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_int32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_int32_ext, value: newValue)} } - var Fuzz_Testing_repeatedSint32Ext: [Int32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_sint32_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedSint32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_sint32_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedSint32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint32_ext) + var SwiftProtoTesting_Fuzz_repeatedInt64Ext: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_int64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_int64_ext, value: newValue)} } - var Fuzz_Testing_repeatedSint64Ext: [Int64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_sint64_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedSint64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_sint64_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedSint64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint64_ext) + var SwiftProtoTesting_Fuzz_repeatedUint32Ext: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_uint32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_uint32_ext, value: newValue)} } - var Fuzz_Testing_repeatedFixed32Ext: [UInt32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_fixed32_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedFixed32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_fixed32_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedFixed32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed32_ext) + var SwiftProtoTesting_Fuzz_repeatedUint64Ext: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_uint64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_uint64_ext, value: newValue)} } - var Fuzz_Testing_repeatedFixed64Ext: [UInt64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_fixed64_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedFixed64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_fixed64_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedFixed64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed64_ext) + var SwiftProtoTesting_Fuzz_repeatedSint32Ext: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sint32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sint32_ext, value: newValue)} } - var Fuzz_Testing_repeatedSfixed32Ext: [Int32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_sfixed32_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedSfixed32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_sfixed32_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedSfixed32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed32_ext) + var SwiftProtoTesting_Fuzz_repeatedSint64Ext: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sint64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sint64_ext, value: newValue)} } - var Fuzz_Testing_repeatedSfixed64Ext: [Int64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_sfixed64_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedSfixed64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_sfixed64_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedSfixed64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed64_ext) + var SwiftProtoTesting_Fuzz_repeatedFixed32Ext: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_fixed32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_fixed32_ext, value: newValue)} } - var Fuzz_Testing_repeatedFloatExt: [Float] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_float_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_float_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_float_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedFloatExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_float_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_float_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedFloatExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_float_ext) + var SwiftProtoTesting_Fuzz_repeatedFixed64Ext: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_fixed64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_fixed64_ext, value: newValue)} } - var Fuzz_Testing_repeatedDoubleExt: [Double] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_double_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_double_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_double_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedDoubleExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_double_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_double_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedDoubleExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_double_ext) + var SwiftProtoTesting_Fuzz_repeatedSfixed32Ext: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed32_ext, value: newValue)} } - var Fuzz_Testing_repeatedBoolExt: [Bool] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bool_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bool_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_bool_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedBoolExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bool_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_bool_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedBoolExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bool_ext) + var SwiftProtoTesting_Fuzz_repeatedSfixed64Ext: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed64_ext, value: newValue)} } - var Fuzz_Testing_repeatedStringExt: [String] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_string_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_string_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_string_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedStringExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_string_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_string_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedStringExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_string_ext) + var SwiftProtoTesting_Fuzz_repeatedFloatExt: [Float] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_float_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_float_ext, value: newValue)} } - var Fuzz_Testing_repeatedBytesExt: [Data] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bytes_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bytes_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_bytes_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedBytesExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bytes_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_bytes_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedBytesExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bytes_ext) + var SwiftProtoTesting_Fuzz_repeatedDoubleExt: [Double] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_double_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_double_ext, value: newValue)} } - var Fuzz_Testing_repeatedEnumExt: [Fuzz_Testing_AnEnum] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_enum_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_enum_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_enum_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedEnumExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_enum_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_enum_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedEnumExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_enum_ext) + var SwiftProtoTesting_Fuzz_repeatedBoolExt: [Bool] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_bool_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_bool_ext, value: newValue)} } - var Fuzz_Testing_repeatedGroupExt: [Fuzz_Testing_RepeatedGroup_ext] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_RepeatedGroup_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_RepeatedGroup_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_RepeatedGroup_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedGroupExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_RepeatedGroup_ext) + var SwiftProtoTesting_Fuzz_repeatedStringExt: [String] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_string_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_string_ext, value: newValue)} } - /// Clears the value of extension `Fuzz_Testing_Extensions_RepeatedGroup_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedGroupExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_RepeatedGroup_ext) + + var SwiftProtoTesting_Fuzz_repeatedBytesExt: [Data] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_bytes_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_bytes_ext, value: newValue)} } - var Fuzz_Testing_repeatedMessageExt: [Fuzz_Testing_Message] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_message_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_message_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_repeatedEnumExt: [SwiftProtoTesting_Fuzz_AnEnum] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_enum_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_enum_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_message_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedMessageExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_message_ext) + + var SwiftProtoTesting_Fuzz_repeatedGroupExt: [SwiftProtoTesting_Fuzz_RepeatedGroup_ext] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_RepeatedGroup_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_RepeatedGroup_ext, value: newValue)} } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_message_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedMessageExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_message_ext) + + var SwiftProtoTesting_Fuzz_repeatedMessageExt: [SwiftProtoTesting_Fuzz_Message] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_message_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_message_ext, value: newValue)} } /// Repeated Packed - var Fuzz_Testing_repeatedPackedInt32Ext: [Int32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_int32_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedInt32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_int32_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedInt32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int32_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedInt32Ext: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int32_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedInt64Ext: [Int64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_int64_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedInt64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_int64_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedInt64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int64_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedInt64Ext: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int64_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedUint32Ext: [UInt32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_uint32_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedUint32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_uint32_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedUint32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint32_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedUint32Ext: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint32_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedUint64Ext: [UInt64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_uint64_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedUint64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_uint64_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedUint64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint64_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedUint64Ext: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint64_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedSint32Ext: [Int32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_sint32_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedSint32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_sint32_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedSint32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint32_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedSint32Ext: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint32_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedSint64Ext: [Int64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_sint64_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedSint64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_sint64_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedSint64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint64_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedSint64Ext: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint64_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedFixed32Ext: [UInt32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_fixed32_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedFixed32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_fixed32_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedFixed32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed32_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedFixed32Ext: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed32_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedFixed64Ext: [UInt64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_fixed64_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedFixed64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_fixed64_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedFixed64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed64_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedFixed64Ext: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed64_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedSfixed32Ext: [Int32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedSfixed32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedSfixed32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedSfixed32Ext: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed32_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedSfixed64Ext: [Int64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedSfixed64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedSfixed64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedSfixed64Ext: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed64_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedFloatExt: [Float] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_float_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_float_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_float_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedFloatExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_float_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_float_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedFloatExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_float_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedFloatExt: [Float] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_float_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_float_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedDoubleExt: [Double] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_double_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_double_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_double_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedDoubleExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_double_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_double_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedDoubleExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_double_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedDoubleExt: [Double] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_double_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_double_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedBoolExt: [Bool] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_bool_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_bool_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_bool_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedBoolExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_bool_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_bool_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedBoolExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_bool_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedBoolExt: [Bool] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_bool_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_bool_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedEnumExt: [Fuzz_Testing_AnEnum] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_enum_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_enum_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_enum_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedEnumExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_enum_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_enum_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedEnumExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_enum_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedEnumExt: [SwiftProtoTesting_Fuzz_AnEnum] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_enum_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_enum_ext, value: newValue)} } } -// MARK: - File's ExtensionMap: Fuzz_Testing_FuzzTesting_Extensions +// MARK: - File's ExtensionMap: SwiftProtoTesting_Fuzz_FuzzTesting_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 Fuzz_Testing_FuzzTesting_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - Fuzz_Testing_Extensions_singular_int32_ext, - Fuzz_Testing_Extensions_singular_int64_ext, - Fuzz_Testing_Extensions_singular_uint32_ext, - Fuzz_Testing_Extensions_singular_uint64_ext, - Fuzz_Testing_Extensions_singular_sint32_ext, - Fuzz_Testing_Extensions_singular_sint64_ext, - Fuzz_Testing_Extensions_singular_fixed32_ext, - Fuzz_Testing_Extensions_singular_fixed64_ext, - Fuzz_Testing_Extensions_singular_sfixed32_ext, - Fuzz_Testing_Extensions_singular_sfixed64_ext, - Fuzz_Testing_Extensions_singular_float_ext, - Fuzz_Testing_Extensions_singular_double_ext, - Fuzz_Testing_Extensions_singular_bool_ext, - Fuzz_Testing_Extensions_singular_string_ext, - Fuzz_Testing_Extensions_singular_bytes_ext, - Fuzz_Testing_Extensions_singular_enum_ext, - Fuzz_Testing_Extensions_SingularGroup_ext, - Fuzz_Testing_Extensions_singular_message_ext, - Fuzz_Testing_Extensions_repeated_int32_ext, - Fuzz_Testing_Extensions_repeated_int64_ext, - Fuzz_Testing_Extensions_repeated_uint32_ext, - Fuzz_Testing_Extensions_repeated_uint64_ext, - Fuzz_Testing_Extensions_repeated_sint32_ext, - Fuzz_Testing_Extensions_repeated_sint64_ext, - Fuzz_Testing_Extensions_repeated_fixed32_ext, - Fuzz_Testing_Extensions_repeated_fixed64_ext, - Fuzz_Testing_Extensions_repeated_sfixed32_ext, - Fuzz_Testing_Extensions_repeated_sfixed64_ext, - Fuzz_Testing_Extensions_repeated_float_ext, - Fuzz_Testing_Extensions_repeated_double_ext, - Fuzz_Testing_Extensions_repeated_bool_ext, - Fuzz_Testing_Extensions_repeated_string_ext, - Fuzz_Testing_Extensions_repeated_bytes_ext, - Fuzz_Testing_Extensions_repeated_enum_ext, - Fuzz_Testing_Extensions_RepeatedGroup_ext, - Fuzz_Testing_Extensions_repeated_message_ext, - Fuzz_Testing_Extensions_repeated_packed_int32_ext, - Fuzz_Testing_Extensions_repeated_packed_int64_ext, - Fuzz_Testing_Extensions_repeated_packed_uint32_ext, - Fuzz_Testing_Extensions_repeated_packed_uint64_ext, - Fuzz_Testing_Extensions_repeated_packed_sint32_ext, - Fuzz_Testing_Extensions_repeated_packed_sint64_ext, - Fuzz_Testing_Extensions_repeated_packed_fixed32_ext, - Fuzz_Testing_Extensions_repeated_packed_fixed64_ext, - Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext, - Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext, - Fuzz_Testing_Extensions_repeated_packed_float_ext, - Fuzz_Testing_Extensions_repeated_packed_double_ext, - Fuzz_Testing_Extensions_repeated_packed_bool_ext, - Fuzz_Testing_Extensions_repeated_packed_enum_ext +let SwiftProtoTesting_Fuzz_FuzzTesting_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_float_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_double_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_string_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext, + SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_message_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_int32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_int64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_uint32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_uint64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_sint32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_sint64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_fixed32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_fixed64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_float_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_double_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_bool_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_string_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_bytes_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_enum_ext, + SwiftProtoTesting_Fuzz_Extensions_RepeatedGroup_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_message_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_float_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_double_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_bool_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_enum_ext, + SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension, + SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension ] // Extension Objects - The only reason these might be needed is when manually @@ -2746,550 +2383,287 @@ let Fuzz_Testing_FuzzTesting_Extensions: SwiftProtobuf.SimpleExtensionMap = [ // accessors for the extension fields on the messages directly. /// Singular -let Fuzz_Testing_Extensions_singular_int32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1001, - fieldName: "fuzz.testing.singular_int32_ext" + fieldName: "swift_proto_testing.fuzz.singular_int32_ext" ) -let Fuzz_Testing_Extensions_singular_int64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1002, - fieldName: "fuzz.testing.singular_int64_ext" + fieldName: "swift_proto_testing.fuzz.singular_int64_ext" ) -let Fuzz_Testing_Extensions_singular_uint32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1003, - fieldName: "fuzz.testing.singular_uint32_ext" + fieldName: "swift_proto_testing.fuzz.singular_uint32_ext" ) -let Fuzz_Testing_Extensions_singular_uint64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1004, - fieldName: "fuzz.testing.singular_uint64_ext" + fieldName: "swift_proto_testing.fuzz.singular_uint64_ext" ) -let Fuzz_Testing_Extensions_singular_sint32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1005, - fieldName: "fuzz.testing.singular_sint32_ext" + fieldName: "swift_proto_testing.fuzz.singular_sint32_ext" ) -let Fuzz_Testing_Extensions_singular_sint64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1006, - fieldName: "fuzz.testing.singular_sint64_ext" + fieldName: "swift_proto_testing.fuzz.singular_sint64_ext" ) -let Fuzz_Testing_Extensions_singular_fixed32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1007, - fieldName: "fuzz.testing.singular_fixed32_ext" + fieldName: "swift_proto_testing.fuzz.singular_fixed32_ext" ) -let Fuzz_Testing_Extensions_singular_fixed64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1008, - fieldName: "fuzz.testing.singular_fixed64_ext" + fieldName: "swift_proto_testing.fuzz.singular_fixed64_ext" ) -let Fuzz_Testing_Extensions_singular_sfixed32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1009, - fieldName: "fuzz.testing.singular_sfixed32_ext" + fieldName: "swift_proto_testing.fuzz.singular_sfixed32_ext" ) -let Fuzz_Testing_Extensions_singular_sfixed64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1010, - fieldName: "fuzz.testing.singular_sfixed64_ext" + fieldName: "swift_proto_testing.fuzz.singular_sfixed64_ext" ) -let Fuzz_Testing_Extensions_singular_float_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_float_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1011, - fieldName: "fuzz.testing.singular_float_ext" + fieldName: "swift_proto_testing.fuzz.singular_float_ext" ) -let Fuzz_Testing_Extensions_singular_double_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_double_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1012, - fieldName: "fuzz.testing.singular_double_ext" + fieldName: "swift_proto_testing.fuzz.singular_double_ext" ) -let Fuzz_Testing_Extensions_singular_bool_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1013, - fieldName: "fuzz.testing.singular_bool_ext" + fieldName: "swift_proto_testing.fuzz.singular_bool_ext" ) -let Fuzz_Testing_Extensions_singular_string_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_string_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1014, - fieldName: "fuzz.testing.singular_string_ext" + fieldName: "swift_proto_testing.fuzz.singular_string_ext" ) -let Fuzz_Testing_Extensions_singular_bytes_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1015, - fieldName: "fuzz.testing.singular_bytes_ext" + fieldName: "swift_proto_testing.fuzz.singular_bytes_ext" ) -let Fuzz_Testing_Extensions_singular_enum_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1016, - fieldName: "fuzz.testing.singular_enum_ext" + fieldName: "swift_proto_testing.fuzz.singular_enum_ext" ) -let Fuzz_Testing_Extensions_SingularGroup_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1017, - fieldName: "fuzz.testing.singulargroup_ext" + fieldName: "swift_proto_testing.fuzz.singulargroup_ext" ) -let Fuzz_Testing_Extensions_singular_message_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_message_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1019, - fieldName: "fuzz.testing.singular_message_ext" + fieldName: "swift_proto_testing.fuzz.singular_message_ext" ) /// Repeated -let Fuzz_Testing_Extensions_repeated_int32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_int32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1031, - fieldName: "fuzz.testing.repeated_int32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_int32_ext" ) -let Fuzz_Testing_Extensions_repeated_int64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_int64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1032, - fieldName: "fuzz.testing.repeated_int64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_int64_ext" ) -let Fuzz_Testing_Extensions_repeated_uint32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_uint32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1033, - fieldName: "fuzz.testing.repeated_uint32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_uint32_ext" ) -let Fuzz_Testing_Extensions_repeated_uint64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_uint64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1034, - fieldName: "fuzz.testing.repeated_uint64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_uint64_ext" ) -let Fuzz_Testing_Extensions_repeated_sint32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_sint32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1035, - fieldName: "fuzz.testing.repeated_sint32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_sint32_ext" ) -let Fuzz_Testing_Extensions_repeated_sint64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_sint64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1036, - fieldName: "fuzz.testing.repeated_sint64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_sint64_ext" ) -let Fuzz_Testing_Extensions_repeated_fixed32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_fixed32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1037, - fieldName: "fuzz.testing.repeated_fixed32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_fixed32_ext" ) -let Fuzz_Testing_Extensions_repeated_fixed64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_fixed64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1038, - fieldName: "fuzz.testing.repeated_fixed64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_fixed64_ext" ) -let Fuzz_Testing_Extensions_repeated_sfixed32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1039, - fieldName: "fuzz.testing.repeated_sfixed32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_sfixed32_ext" ) -let Fuzz_Testing_Extensions_repeated_sfixed64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1040, - fieldName: "fuzz.testing.repeated_sfixed64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_sfixed64_ext" ) -let Fuzz_Testing_Extensions_repeated_float_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_float_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1041, - fieldName: "fuzz.testing.repeated_float_ext" + fieldName: "swift_proto_testing.fuzz.repeated_float_ext" ) -let Fuzz_Testing_Extensions_repeated_double_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_double_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1042, - fieldName: "fuzz.testing.repeated_double_ext" + fieldName: "swift_proto_testing.fuzz.repeated_double_ext" ) -let Fuzz_Testing_Extensions_repeated_bool_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_bool_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1043, - fieldName: "fuzz.testing.repeated_bool_ext" + fieldName: "swift_proto_testing.fuzz.repeated_bool_ext" ) -let Fuzz_Testing_Extensions_repeated_string_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_string_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1044, - fieldName: "fuzz.testing.repeated_string_ext" + fieldName: "swift_proto_testing.fuzz.repeated_string_ext" ) -let Fuzz_Testing_Extensions_repeated_bytes_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_bytes_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1045, - fieldName: "fuzz.testing.repeated_bytes_ext" + fieldName: "swift_proto_testing.fuzz.repeated_bytes_ext" ) -let Fuzz_Testing_Extensions_repeated_enum_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_enum_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1046, - fieldName: "fuzz.testing.repeated_enum_ext" + fieldName: "swift_proto_testing.fuzz.repeated_enum_ext" ) -let Fuzz_Testing_Extensions_RepeatedGroup_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_RepeatedGroup_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1047, - fieldName: "fuzz.testing.repeatedgroup_ext" + fieldName: "swift_proto_testing.fuzz.repeatedgroup_ext" ) -let Fuzz_Testing_Extensions_repeated_message_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_message_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1049, - fieldName: "fuzz.testing.repeated_message_ext" + fieldName: "swift_proto_testing.fuzz.repeated_message_ext" ) /// Repeated Packed -let Fuzz_Testing_Extensions_repeated_packed_int32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1061, - fieldName: "fuzz.testing.repeated_packed_int32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_int32_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_int64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1062, - fieldName: "fuzz.testing.repeated_packed_int64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_int64_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_uint32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1063, - fieldName: "fuzz.testing.repeated_packed_uint32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_uint32_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_uint64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1064, - fieldName: "fuzz.testing.repeated_packed_uint64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_uint64_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_sint32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1065, - fieldName: "fuzz.testing.repeated_packed_sint32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_sint32_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_sint64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1066, - fieldName: "fuzz.testing.repeated_packed_sint64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_sint64_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_fixed32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1067, - fieldName: "fuzz.testing.repeated_packed_fixed32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_fixed32_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_fixed64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1068, - fieldName: "fuzz.testing.repeated_packed_fixed64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_fixed64_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1069, - fieldName: "fuzz.testing.repeated_packed_sfixed32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_sfixed32_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1070, - fieldName: "fuzz.testing.repeated_packed_sfixed64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_sfixed64_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_float_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_float_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1071, - fieldName: "fuzz.testing.repeated_packed_float_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_float_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_double_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_double_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1072, - fieldName: "fuzz.testing.repeated_packed_double_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_double_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_bool_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_bool_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1073, - fieldName: "fuzz.testing.repeated_packed_bool_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_bool_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_enum_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_enum_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1074, - fieldName: "fuzz.testing.repeated_packed_enum_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_enum_ext" ) +extension SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_AMessageSetMessage>( + _protobuf_fieldNumber: 1547769, + fieldName: "swift_proto_testing.fuzz.AMessageSetMessageExtension1" + ) + } +} + +extension SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_AMessageSetMessage>( + _protobuf_fieldNumber: 4135312, + fieldName: "swift_proto_testing.fuzz.AMessageSetMessageExtension2" + ) + } +} + // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "fuzz.testing" +fileprivate let _protobuf_package = "swift_proto_testing.fuzz" -extension Fuzz_Testing_AnEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ZERO"), - 1: .same(proto: "ONE"), - 2: .same(proto: "TWO"), - 3: .same(proto: "THREE"), - ] +extension SwiftProtoTesting_Fuzz_AnEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ZERO\0\u{1}ONE\0\u{1}TWO\0\u{1}THREE\0") } -extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Fuzz_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Message" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "singular_int32"), - 2: .standard(proto: "singular_int64"), - 3: .standard(proto: "singular_uint32"), - 4: .standard(proto: "singular_uint64"), - 5: .standard(proto: "singular_sint32"), - 6: .standard(proto: "singular_sint64"), - 7: .standard(proto: "singular_fixed32"), - 8: .standard(proto: "singular_fixed64"), - 9: .standard(proto: "singular_sfixed32"), - 10: .standard(proto: "singular_sfixed64"), - 11: .standard(proto: "singular_float"), - 12: .standard(proto: "singular_double"), - 13: .standard(proto: "singular_bool"), - 14: .standard(proto: "singular_string"), - 15: .standard(proto: "singular_bytes"), - 16: .standard(proto: "singular_enum"), - 17: .unique(proto: "SingularGroup", json: "singulargroup"), - 19: .standard(proto: "singular_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 46: .standard(proto: "repeated_enum"), - 47: .unique(proto: "RepeatedGroup", json: "repeatedgroup"), - 49: .standard(proto: "repeated_message"), - 61: .standard(proto: "oneof_int32"), - 62: .standard(proto: "oneof_int64"), - 63: .standard(proto: "oneof_uint32"), - 64: .standard(proto: "oneof_uint64"), - 65: .standard(proto: "oneof_sint32"), - 66: .standard(proto: "oneof_sint64"), - 67: .standard(proto: "oneof_fixed32"), - 68: .standard(proto: "oneof_fixed64"), - 69: .standard(proto: "oneof_sfixed32"), - 70: .standard(proto: "oneof_sfixed64"), - 71: .standard(proto: "oneof_float"), - 72: .standard(proto: "oneof_double"), - 73: .standard(proto: "oneof_bool"), - 74: .standard(proto: "oneof_string"), - 75: .standard(proto: "oneof_bytes"), - 76: .standard(proto: "oneof_enum"), - 77: .unique(proto: "OneofGroup", json: "oneofgroup"), - 79: .standard(proto: "oneof_message"), - 81: .standard(proto: "repeated_packed_int32"), - 82: .standard(proto: "repeated_packed_int64"), - 83: .standard(proto: "repeated_packed_uint32"), - 84: .standard(proto: "repeated_packed_uint64"), - 85: .standard(proto: "repeated_packed_sint32"), - 86: .standard(proto: "repeated_packed_sint64"), - 87: .standard(proto: "repeated_packed_fixed32"), - 88: .standard(proto: "repeated_packed_fixed64"), - 89: .standard(proto: "repeated_packed_sfixed32"), - 90: .standard(proto: "repeated_packed_sfixed64"), - 91: .standard(proto: "repeated_packed_float"), - 92: .standard(proto: "repeated_packed_double"), - 93: .standard(proto: "repeated_packed_bool"), - 94: .standard(proto: "repeated_packed_enum"), - 100: .standard(proto: "map_int32_int32"), - 101: .standard(proto: "map_int32_int64"), - 102: .standard(proto: "map_int32_uint32"), - 103: .standard(proto: "map_int32_uint64"), - 104: .standard(proto: "map_int32_sint32"), - 105: .standard(proto: "map_int32_sint64"), - 106: .standard(proto: "map_int32_fixed32"), - 107: .standard(proto: "map_int32_fixed64"), - 108: .standard(proto: "map_int32_sfixed32"), - 109: .standard(proto: "map_int32_sfixed64"), - 110: .standard(proto: "map_int32_float"), - 111: .standard(proto: "map_int32_double"), - 112: .standard(proto: "map_int32_bool"), - 113: .standard(proto: "map_int32_string"), - 114: .standard(proto: "map_int32_bytes"), - 115: .standard(proto: "map_int32_AnEnum"), - 116: .standard(proto: "map_int32_Message"), - 117: .standard(proto: "map_int64_int32"), - 118: .standard(proto: "map_int64_int64"), - 119: .standard(proto: "map_int64_uint32"), - 120: .standard(proto: "map_int64_uint64"), - 121: .standard(proto: "map_int64_sint32"), - 122: .standard(proto: "map_int64_sint64"), - 123: .standard(proto: "map_int64_fixed32"), - 124: .standard(proto: "map_int64_fixed64"), - 125: .standard(proto: "map_int64_sfixed32"), - 126: .standard(proto: "map_int64_sfixed64"), - 127: .standard(proto: "map_int64_float"), - 128: .standard(proto: "map_int64_double"), - 129: .standard(proto: "map_int64_bool"), - 130: .standard(proto: "map_int64_string"), - 131: .standard(proto: "map_int64_bytes"), - 132: .standard(proto: "map_int64_AnEnum"), - 133: .standard(proto: "map_int64_Message"), - 134: .standard(proto: "map_uint32_int32"), - 135: .standard(proto: "map_uint32_int64"), - 136: .standard(proto: "map_uint32_uint32"), - 137: .standard(proto: "map_uint32_uint64"), - 138: .standard(proto: "map_uint32_sint32"), - 139: .standard(proto: "map_uint32_sint64"), - 140: .standard(proto: "map_uint32_fixed32"), - 141: .standard(proto: "map_uint32_fixed64"), - 142: .standard(proto: "map_uint32_sfixed32"), - 143: .standard(proto: "map_uint32_sfixed64"), - 144: .standard(proto: "map_uint32_float"), - 145: .standard(proto: "map_uint32_double"), - 146: .standard(proto: "map_uint32_bool"), - 147: .standard(proto: "map_uint32_string"), - 148: .standard(proto: "map_uint32_bytes"), - 149: .standard(proto: "map_uint32_AnEnum"), - 150: .standard(proto: "map_uint32_Message"), - 151: .standard(proto: "map_uint64_int32"), - 152: .standard(proto: "map_uint64_int64"), - 153: .standard(proto: "map_uint64_uint32"), - 154: .standard(proto: "map_uint64_uint64"), - 155: .standard(proto: "map_uint64_sint32"), - 156: .standard(proto: "map_uint64_sint64"), - 157: .standard(proto: "map_uint64_fixed32"), - 158: .standard(proto: "map_uint64_fixed64"), - 159: .standard(proto: "map_uint64_sfixed32"), - 160: .standard(proto: "map_uint64_sfixed64"), - 161: .standard(proto: "map_uint64_float"), - 162: .standard(proto: "map_uint64_double"), - 163: .standard(proto: "map_uint64_bool"), - 164: .standard(proto: "map_uint64_string"), - 165: .standard(proto: "map_uint64_bytes"), - 166: .standard(proto: "map_uint64_AnEnum"), - 167: .standard(proto: "map_uint64_Message"), - 168: .standard(proto: "map_sint32_int32"), - 169: .standard(proto: "map_sint32_int64"), - 170: .standard(proto: "map_sint32_uint32"), - 171: .standard(proto: "map_sint32_uint64"), - 172: .standard(proto: "map_sint32_sint32"), - 173: .standard(proto: "map_sint32_sint64"), - 174: .standard(proto: "map_sint32_fixed32"), - 175: .standard(proto: "map_sint32_fixed64"), - 176: .standard(proto: "map_sint32_sfixed32"), - 177: .standard(proto: "map_sint32_sfixed64"), - 178: .standard(proto: "map_sint32_float"), - 179: .standard(proto: "map_sint32_double"), - 180: .standard(proto: "map_sint32_bool"), - 181: .standard(proto: "map_sint32_string"), - 182: .standard(proto: "map_sint32_bytes"), - 183: .standard(proto: "map_sint32_AnEnum"), - 184: .standard(proto: "map_sint32_Message"), - 185: .standard(proto: "map_sint64_int32"), - 186: .standard(proto: "map_sint64_int64"), - 187: .standard(proto: "map_sint64_uint32"), - 188: .standard(proto: "map_sint64_uint64"), - 189: .standard(proto: "map_sint64_sint32"), - 190: .standard(proto: "map_sint64_sint64"), - 191: .standard(proto: "map_sint64_fixed32"), - 192: .standard(proto: "map_sint64_fixed64"), - 193: .standard(proto: "map_sint64_sfixed32"), - 194: .standard(proto: "map_sint64_sfixed64"), - 195: .standard(proto: "map_sint64_float"), - 196: .standard(proto: "map_sint64_double"), - 197: .standard(proto: "map_sint64_bool"), - 198: .standard(proto: "map_sint64_string"), - 199: .standard(proto: "map_sint64_bytes"), - 200: .standard(proto: "map_sint64_AnEnum"), - 201: .standard(proto: "map_sint64_Message"), - 202: .standard(proto: "map_fixed32_int32"), - 203: .standard(proto: "map_fixed32_int64"), - 204: .standard(proto: "map_fixed32_uint32"), - 205: .standard(proto: "map_fixed32_uint64"), - 206: .standard(proto: "map_fixed32_sint32"), - 207: .standard(proto: "map_fixed32_sint64"), - 208: .standard(proto: "map_fixed32_fixed32"), - 209: .standard(proto: "map_fixed32_fixed64"), - 210: .standard(proto: "map_fixed32_sfixed32"), - 211: .standard(proto: "map_fixed32_sfixed64"), - 212: .standard(proto: "map_fixed32_float"), - 213: .standard(proto: "map_fixed32_double"), - 214: .standard(proto: "map_fixed32_bool"), - 215: .standard(proto: "map_fixed32_string"), - 216: .standard(proto: "map_fixed32_bytes"), - 217: .standard(proto: "map_fixed32_AnEnum"), - 218: .standard(proto: "map_fixed32_Message"), - 219: .standard(proto: "map_fixed64_int32"), - 220: .standard(proto: "map_fixed64_int64"), - 221: .standard(proto: "map_fixed64_uint32"), - 222: .standard(proto: "map_fixed64_uint64"), - 223: .standard(proto: "map_fixed64_sint32"), - 224: .standard(proto: "map_fixed64_sint64"), - 225: .standard(proto: "map_fixed64_fixed32"), - 226: .standard(proto: "map_fixed64_fixed64"), - 227: .standard(proto: "map_fixed64_sfixed32"), - 228: .standard(proto: "map_fixed64_sfixed64"), - 229: .standard(proto: "map_fixed64_float"), - 230: .standard(proto: "map_fixed64_double"), - 231: .standard(proto: "map_fixed64_bool"), - 232: .standard(proto: "map_fixed64_string"), - 233: .standard(proto: "map_fixed64_bytes"), - 234: .standard(proto: "map_fixed64_AnEnum"), - 235: .standard(proto: "map_fixed64_Message"), - 236: .standard(proto: "map_sfixed32_int32"), - 237: .standard(proto: "map_sfixed32_int64"), - 238: .standard(proto: "map_sfixed32_uint32"), - 239: .standard(proto: "map_sfixed32_uint64"), - 240: .standard(proto: "map_sfixed32_sint32"), - 241: .standard(proto: "map_sfixed32_sint64"), - 242: .standard(proto: "map_sfixed32_fixed32"), - 243: .standard(proto: "map_sfixed32_fixed64"), - 244: .standard(proto: "map_sfixed32_sfixed32"), - 245: .standard(proto: "map_sfixed32_sfixed64"), - 246: .standard(proto: "map_sfixed32_float"), - 247: .standard(proto: "map_sfixed32_double"), - 248: .standard(proto: "map_sfixed32_bool"), - 249: .standard(proto: "map_sfixed32_string"), - 250: .standard(proto: "map_sfixed32_bytes"), - 251: .standard(proto: "map_sfixed32_AnEnum"), - 252: .standard(proto: "map_sfixed32_Message"), - 253: .standard(proto: "map_sfixed64_int32"), - 254: .standard(proto: "map_sfixed64_int64"), - 255: .standard(proto: "map_sfixed64_uint32"), - 256: .standard(proto: "map_sfixed64_uint64"), - 257: .standard(proto: "map_sfixed64_sint32"), - 258: .standard(proto: "map_sfixed64_sint64"), - 259: .standard(proto: "map_sfixed64_fixed32"), - 260: .standard(proto: "map_sfixed64_fixed64"), - 261: .standard(proto: "map_sfixed64_sfixed32"), - 262: .standard(proto: "map_sfixed64_sfixed64"), - 263: .standard(proto: "map_sfixed64_float"), - 264: .standard(proto: "map_sfixed64_double"), - 265: .standard(proto: "map_sfixed64_bool"), - 266: .standard(proto: "map_sfixed64_string"), - 267: .standard(proto: "map_sfixed64_bytes"), - 268: .standard(proto: "map_sfixed64_AnEnum"), - 269: .standard(proto: "map_sfixed64_Message"), - 270: .standard(proto: "map_bool_int32"), - 271: .standard(proto: "map_bool_int64"), - 272: .standard(proto: "map_bool_uint32"), - 273: .standard(proto: "map_bool_uint64"), - 274: .standard(proto: "map_bool_sint32"), - 275: .standard(proto: "map_bool_sint64"), - 276: .standard(proto: "map_bool_fixed32"), - 277: .standard(proto: "map_bool_fixed64"), - 278: .standard(proto: "map_bool_sfixed32"), - 279: .standard(proto: "map_bool_sfixed64"), - 280: .standard(proto: "map_bool_float"), - 281: .standard(proto: "map_bool_double"), - 282: .standard(proto: "map_bool_bool"), - 283: .standard(proto: "map_bool_string"), - 284: .standard(proto: "map_bool_bytes"), - 285: .standard(proto: "map_bool_AnEnum"), - 286: .standard(proto: "map_bool_Message"), - 500: .standard(proto: "wkt_any"), - 501: .standard(proto: "wkt_api"), - 502: .standard(proto: "wkt_duration"), - 503: .standard(proto: "wkt_empty"), - 504: .standard(proto: "wkt_field_mask"), - 505: .standard(proto: "wkt_source_context"), - 506: .standard(proto: "wkt_struct"), - 507: .standard(proto: "wkt_timestamp"), - 508: .standard(proto: "wkt_type"), - 509: .standard(proto: "wkt_double_value"), - 510: .standard(proto: "wkt_float_value"), - 511: .standard(proto: "wkt_int64_value"), - 512: .standard(proto: "wkt_uint64_value"), - 513: .standard(proto: "wkt_int32_value"), - 514: .standard(proto: "wkt_uint32_value"), - 515: .standard(proto: "wkt_bool_value"), - 516: .standard(proto: "wkt_string_value"), - 517: .standard(proto: "wkt_bytes_value"), - 600: .standard(proto: "singular_message_set"), - 601: .standard(proto: "repeated_message_set"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}singular_int32\0\u{3}singular_int64\0\u{3}singular_uint32\0\u{3}singular_uint64\0\u{3}singular_sint32\0\u{3}singular_sint64\0\u{3}singular_fixed32\0\u{3}singular_fixed64\0\u{3}singular_sfixed32\0\u{3}singular_sfixed64\0\u{3}singular_float\0\u{3}singular_double\0\u{3}singular_bool\0\u{3}singular_string\0\u{3}singular_bytes\0\u{3}singular_enum\0\u{7}SingularGroup\0\u{4}\u{2}singular_message\0\u{4}\u{c}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{3}repeated_enum\0\u{7}RepeatedGroup\0\u{4}\u{2}repeated_message\0\u{4}\u{c}oneof_int32\0\u{3}oneof_int64\0\u{3}oneof_uint32\0\u{3}oneof_uint64\0\u{3}oneof_sint32\0\u{3}oneof_sint64\0\u{3}oneof_fixed32\0\u{3}oneof_fixed64\0\u{3}oneof_sfixed32\0\u{3}oneof_sfixed64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_bool\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_enum\0\u{7}OneofGroup\0\u{4}\u{2}oneof_message\0\u{4}\u{2}repeated_packed_int32\0\u{3}repeated_packed_int64\0\u{3}repeated_packed_uint32\0\u{3}repeated_packed_uint64\0\u{3}repeated_packed_sint32\0\u{3}repeated_packed_sint64\0\u{3}repeated_packed_fixed32\0\u{3}repeated_packed_fixed64\0\u{3}repeated_packed_sfixed32\0\u{3}repeated_packed_sfixed64\0\u{3}repeated_packed_float\0\u{3}repeated_packed_double\0\u{3}repeated_packed_bool\0\u{3}repeated_packed_enum\0\u{4}\u{6}map_int32_int32\0\u{3}map_int32_int64\0\u{3}map_int32_uint32\0\u{3}map_int32_uint64\0\u{3}map_int32_sint32\0\u{3}map_int32_sint64\0\u{3}map_int32_fixed32\0\u{3}map_int32_fixed64\0\u{3}map_int32_sfixed32\0\u{3}map_int32_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_int32_bool\0\u{3}map_int32_string\0\u{3}map_int32_bytes\0\u{3}map_int32_AnEnum\0\u{3}map_int32_Message\0\u{3}map_int64_int32\0\u{3}map_int64_int64\0\u{3}map_int64_uint32\0\u{3}map_int64_uint64\0\u{3}map_int64_sint32\0\u{3}map_int64_sint64\0\u{3}map_int64_fixed32\0\u{3}map_int64_fixed64\0\u{3}map_int64_sfixed32\0\u{3}map_int64_sfixed64\0\u{3}map_int64_float\0\u{3}map_int64_double\0\u{3}map_int64_bool\0\u{3}map_int64_string\0\u{3}map_int64_bytes\0\u{3}map_int64_AnEnum\0\u{3}map_int64_Message\0\u{3}map_uint32_int32\0\u{3}map_uint32_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint32_uint64\0\u{3}map_uint32_sint32\0\u{3}map_uint32_sint64\0\u{3}map_uint32_fixed32\0\u{3}map_uint32_fixed64\0\u{3}map_uint32_sfixed32\0\u{3}map_uint32_sfixed64\0\u{3}map_uint32_float\0\u{3}map_uint32_double\0\u{3}map_uint32_bool\0\u{3}map_uint32_string\0\u{3}map_uint32_bytes\0\u{3}map_uint32_AnEnum\0\u{3}map_uint32_Message\0\u{3}map_uint64_int32\0\u{3}map_uint64_int64\0\u{3}map_uint64_uint32\0\u{3}map_uint64_uint64\0\u{3}map_uint64_sint32\0\u{3}map_uint64_sint64\0\u{3}map_uint64_fixed32\0\u{3}map_uint64_fixed64\0\u{3}map_uint64_sfixed32\0\u{3}map_uint64_sfixed64\0\u{3}map_uint64_float\0\u{3}map_uint64_double\0\u{3}map_uint64_bool\0\u{3}map_uint64_string\0\u{3}map_uint64_bytes\0\u{3}map_uint64_AnEnum\0\u{3}map_uint64_Message\0\u{3}map_sint32_int32\0\u{3}map_sint32_int64\0\u{3}map_sint32_uint32\0\u{3}map_sint32_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint32_sint64\0\u{3}map_sint32_fixed32\0\u{3}map_sint32_fixed64\0\u{3}map_sint32_sfixed32\0\u{3}map_sint32_sfixed64\0\u{3}map_sint32_float\0\u{3}map_sint32_double\0\u{3}map_sint32_bool\0\u{3}map_sint32_string\0\u{3}map_sint32_bytes\0\u{3}map_sint32_AnEnum\0\u{3}map_sint32_Message\0\u{3}map_sint64_int32\0\u{3}map_sint64_int64\0\u{3}map_sint64_uint32\0\u{3}map_sint64_uint64\0\u{3}map_sint64_sint32\0\u{3}map_sint64_sint64\0\u{3}map_sint64_fixed32\0\u{3}map_sint64_fixed64\0\u{3}map_sint64_sfixed32\0\u{3}map_sint64_sfixed64\0\u{3}map_sint64_float\0\u{3}map_sint64_double\0\u{3}map_sint64_bool\0\u{3}map_sint64_string\0\u{3}map_sint64_bytes\0\u{3}map_sint64_AnEnum\0\u{3}map_sint64_Message\0\u{3}map_fixed32_int32\0\u{3}map_fixed32_int64\0\u{3}map_fixed32_uint32\0\u{3}map_fixed32_uint64\0\u{3}map_fixed32_sint32\0\u{3}map_fixed32_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed32_fixed64\0\u{3}map_fixed32_sfixed32\0\u{3}map_fixed32_sfixed64\0\u{3}map_fixed32_float\0\u{3}map_fixed32_double\0\u{3}map_fixed32_bool\0\u{3}map_fixed32_string\0\u{3}map_fixed32_bytes\0\u{3}map_fixed32_AnEnum\0\u{3}map_fixed32_Message\0\u{3}map_fixed64_int32\0\u{3}map_fixed64_int64\0\u{3}map_fixed64_uint32\0\u{3}map_fixed64_uint64\0\u{3}map_fixed64_sint32\0\u{3}map_fixed64_sint64\0\u{3}map_fixed64_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_fixed64_sfixed32\0\u{3}map_fixed64_sfixed64\0\u{3}map_fixed64_float\0\u{3}map_fixed64_double\0\u{3}map_fixed64_bool\0\u{3}map_fixed64_string\0\u{3}map_fixed64_bytes\0\u{3}map_fixed64_AnEnum\0\u{3}map_fixed64_Message\0\u{3}map_sfixed32_int32\0\u{3}map_sfixed32_int64\0\u{3}map_sfixed32_uint32\0\u{3}map_sfixed32_uint64\0\u{3}map_sfixed32_sint32\0\u{3}map_sfixed32_sint64\0\u{3}map_sfixed32_fixed32\0\u{3}map_sfixed32_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed32_sfixed64\0\u{3}map_sfixed32_float\0\u{3}map_sfixed32_double\0\u{3}map_sfixed32_bool\0\u{3}map_sfixed32_string\0\u{3}map_sfixed32_bytes\0\u{3}map_sfixed32_AnEnum\0\u{3}map_sfixed32_Message\0\u{3}map_sfixed64_int32\0\u{3}map_sfixed64_int64\0\u{3}map_sfixed64_uint32\0\u{3}map_sfixed64_uint64\0\u{3}map_sfixed64_sint32\0\u{3}map_sfixed64_sint64\0\u{3}map_sfixed64_fixed32\0\u{3}map_sfixed64_fixed64\0\u{3}map_sfixed64_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_sfixed64_float\0\u{3}map_sfixed64_double\0\u{3}map_sfixed64_bool\0\u{3}map_sfixed64_string\0\u{3}map_sfixed64_bytes\0\u{3}map_sfixed64_AnEnum\0\u{3}map_sfixed64_Message\0\u{3}map_bool_int32\0\u{3}map_bool_int64\0\u{3}map_bool_uint32\0\u{3}map_bool_uint64\0\u{3}map_bool_sint32\0\u{3}map_bool_sint64\0\u{3}map_bool_fixed32\0\u{3}map_bool_fixed64\0\u{3}map_bool_sfixed32\0\u{3}map_bool_sfixed64\0\u{3}map_bool_float\0\u{3}map_bool_double\0\u{3}map_bool_bool\0\u{3}map_bool_string\0\u{3}map_bool_bytes\0\u{3}map_bool_AnEnum\0\u{3}map_bool_Message\0\u{4}V\u{3}wkt_any\0\u{3}wkt_api\0\u{3}wkt_duration\0\u{3}wkt_empty\0\u{3}wkt_field_mask\0\u{3}wkt_source_context\0\u{3}wkt_struct\0\u{3}wkt_timestamp\0\u{3}wkt_type\0\u{3}wkt_double_value\0\u{3}wkt_float_value\0\u{3}wkt_int64_value\0\u{3}wkt_uint64_value\0\u{3}wkt_int32_value\0\u{3}wkt_uint32_value\0\u{3}wkt_bool_value\0\u{3}wkt_string_value\0\u{3}wkt_bytes_value\0\u{4}S\u{1}singular_message_set\0\u{3}repeated_message_set\0") fileprivate class _StorageClass { var _singularInt32: Int32? = nil @@ -3307,9 +2681,9 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _singularBool: Bool? = nil var _singularString: String? = nil var _singularBytes: Data? = nil - var _singularEnum: Fuzz_Testing_AnEnum? = nil - var _singularGroup: Fuzz_Testing_Message.SingularGroup? = nil - var _singularMessage: Fuzz_Testing_Message? = nil + var _singularEnum: SwiftProtoTesting_Fuzz_AnEnum? = nil + var _singularGroup: SwiftProtoTesting_Fuzz_Message.SingularGroup? = nil + var _singularMessage: SwiftProtoTesting_Fuzz_Message? = nil var _repeatedInt32: [Int32] = [] var _repeatedInt64: [Int64] = [] var _repeatedUint32: [UInt32] = [] @@ -3325,10 +2699,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _repeatedBool: [Bool] = [] var _repeatedString: [String] = [] var _repeatedBytes: [Data] = [] - var _repeatedEnum: [Fuzz_Testing_AnEnum] = [] - var _repeatedGroup: [Fuzz_Testing_Message.RepeatedGroup] = [] - var _repeatedMessage: [Fuzz_Testing_Message] = [] - var _o: Fuzz_Testing_Message.OneOf_O? + var _repeatedEnum: [SwiftProtoTesting_Fuzz_AnEnum] = [] + var _repeatedGroup: [SwiftProtoTesting_Fuzz_Message.RepeatedGroup] = [] + var _repeatedMessage: [SwiftProtoTesting_Fuzz_Message] = [] + var _o: SwiftProtoTesting_Fuzz_Message.OneOf_O? var _repeatedPackedInt32: [Int32] = [] var _repeatedPackedInt64: [Int64] = [] var _repeatedPackedUint32: [UInt32] = [] @@ -3342,7 +2716,7 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _repeatedPackedFloat: [Float] = [] var _repeatedPackedDouble: [Double] = [] var _repeatedPackedBool: [Bool] = [] - var _repeatedPackedEnum: [Fuzz_Testing_AnEnum] = [] + var _repeatedPackedEnum: [SwiftProtoTesting_Fuzz_AnEnum] = [] var _mapInt32Int32: Dictionary = [:] var _mapInt32Int64: Dictionary = [:] var _mapInt32Uint32: Dictionary = [:] @@ -3358,8 +2732,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapInt32Bool: Dictionary = [:] var _mapInt32String: Dictionary = [:] var _mapInt32Bytes: Dictionary = [:] - var _mapInt32AnEnum: Dictionary = [:] - var _mapInt32Message: Dictionary = [:] + var _mapInt32AnEnum: Dictionary = [:] + var _mapInt32Message: Dictionary = [:] var _mapInt64Int32: Dictionary = [:] var _mapInt64Int64: Dictionary = [:] var _mapInt64Uint32: Dictionary = [:] @@ -3375,8 +2749,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapInt64Bool: Dictionary = [:] var _mapInt64String: Dictionary = [:] var _mapInt64Bytes: Dictionary = [:] - var _mapInt64AnEnum: Dictionary = [:] - var _mapInt64Message: Dictionary = [:] + var _mapInt64AnEnum: Dictionary = [:] + var _mapInt64Message: Dictionary = [:] var _mapUint32Int32: Dictionary = [:] var _mapUint32Int64: Dictionary = [:] var _mapUint32Uint32: Dictionary = [:] @@ -3392,8 +2766,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapUint32Bool: Dictionary = [:] var _mapUint32String: Dictionary = [:] var _mapUint32Bytes: Dictionary = [:] - var _mapUint32AnEnum: Dictionary = [:] - var _mapUint32Message: Dictionary = [:] + var _mapUint32AnEnum: Dictionary = [:] + var _mapUint32Message: Dictionary = [:] var _mapUint64Int32: Dictionary = [:] var _mapUint64Int64: Dictionary = [:] var _mapUint64Uint32: Dictionary = [:] @@ -3409,8 +2783,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapUint64Bool: Dictionary = [:] var _mapUint64String: Dictionary = [:] var _mapUint64Bytes: Dictionary = [:] - var _mapUint64AnEnum: Dictionary = [:] - var _mapUint64Message: Dictionary = [:] + var _mapUint64AnEnum: Dictionary = [:] + var _mapUint64Message: Dictionary = [:] var _mapSint32Int32: Dictionary = [:] var _mapSint32Int64: Dictionary = [:] var _mapSint32Uint32: Dictionary = [:] @@ -3426,8 +2800,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapSint32Bool: Dictionary = [:] var _mapSint32String: Dictionary = [:] var _mapSint32Bytes: Dictionary = [:] - var _mapSint32AnEnum: Dictionary = [:] - var _mapSint32Message: Dictionary = [:] + var _mapSint32AnEnum: Dictionary = [:] + var _mapSint32Message: Dictionary = [:] var _mapSint64Int32: Dictionary = [:] var _mapSint64Int64: Dictionary = [:] var _mapSint64Uint32: Dictionary = [:] @@ -3443,8 +2817,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapSint64Bool: Dictionary = [:] var _mapSint64String: Dictionary = [:] var _mapSint64Bytes: Dictionary = [:] - var _mapSint64AnEnum: Dictionary = [:] - var _mapSint64Message: Dictionary = [:] + var _mapSint64AnEnum: Dictionary = [:] + var _mapSint64Message: Dictionary = [:] var _mapFixed32Int32: Dictionary = [:] var _mapFixed32Int64: Dictionary = [:] var _mapFixed32Uint32: Dictionary = [:] @@ -3460,8 +2834,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapFixed32Bool: Dictionary = [:] var _mapFixed32String: Dictionary = [:] var _mapFixed32Bytes: Dictionary = [:] - var _mapFixed32AnEnum: Dictionary = [:] - var _mapFixed32Message: Dictionary = [:] + var _mapFixed32AnEnum: Dictionary = [:] + var _mapFixed32Message: Dictionary = [:] var _mapFixed64Int32: Dictionary = [:] var _mapFixed64Int64: Dictionary = [:] var _mapFixed64Uint32: Dictionary = [:] @@ -3477,8 +2851,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapFixed64Bool: Dictionary = [:] var _mapFixed64String: Dictionary = [:] var _mapFixed64Bytes: Dictionary = [:] - var _mapFixed64AnEnum: Dictionary = [:] - var _mapFixed64Message: Dictionary = [:] + var _mapFixed64AnEnum: Dictionary = [:] + var _mapFixed64Message: Dictionary = [:] var _mapSfixed32Int32: Dictionary = [:] var _mapSfixed32Int64: Dictionary = [:] var _mapSfixed32Uint32: Dictionary = [:] @@ -3494,8 +2868,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapSfixed32Bool: Dictionary = [:] var _mapSfixed32String: Dictionary = [:] var _mapSfixed32Bytes: Dictionary = [:] - var _mapSfixed32AnEnum: Dictionary = [:] - var _mapSfixed32Message: Dictionary = [:] + var _mapSfixed32AnEnum: Dictionary = [:] + var _mapSfixed32Message: Dictionary = [:] var _mapSfixed64Int32: Dictionary = [:] var _mapSfixed64Int64: Dictionary = [:] var _mapSfixed64Uint32: Dictionary = [:] @@ -3511,8 +2885,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapSfixed64Bool: Dictionary = [:] var _mapSfixed64String: Dictionary = [:] var _mapSfixed64Bytes: Dictionary = [:] - var _mapSfixed64AnEnum: Dictionary = [:] - var _mapSfixed64Message: Dictionary = [:] + var _mapSfixed64AnEnum: Dictionary = [:] + var _mapSfixed64Message: Dictionary = [:] var _mapBoolInt32: Dictionary = [:] var _mapBoolInt64: Dictionary = [:] var _mapBoolUint32: Dictionary = [:] @@ -3528,8 +2902,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapBoolBool: Dictionary = [:] var _mapBoolString: Dictionary = [:] var _mapBoolBytes: Dictionary = [:] - var _mapBoolAnEnum: Dictionary = [:] - var _mapBoolMessage: Dictionary = [:] + var _mapBoolAnEnum: Dictionary = [:] + var _mapBoolMessage: Dictionary = [:] var _wktAny: SwiftProtobuf.Google_Protobuf_Any? = nil var _wktApi: SwiftProtobuf.Google_Protobuf_Api? = nil var _wktDuration: SwiftProtobuf.Google_Protobuf_Duration? = nil @@ -3548,10 +2922,14 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _wktBoolValue: SwiftProtobuf.Google_Protobuf_BoolValue? = nil var _wktStringValue: SwiftProtobuf.Google_Protobuf_StringValue? = nil var _wktBytesValue: SwiftProtobuf.Google_Protobuf_BytesValue? = nil - var _singularMessageSet: Fuzz_Testing_AMessageSetMessage? = nil - var _repeatedMessageSet: [Fuzz_Testing_AMessageSetMessage] = [] + var _singularMessageSet: SwiftProtoTesting_Fuzz_AMessageSetMessage? = nil + var _repeatedMessageSet: [SwiftProtoTesting_Fuzz_AMessageSetMessage] = [] - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -4012,7 +3390,7 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp } }() case 76: try { - var v: Fuzz_Testing_AnEnum? + var v: SwiftProtoTesting_Fuzz_AnEnum? try decoder.decodeSingularEnumField(value: &v) if let v = v { if _storage._o != nil {try decoder.handleConflictingOneOf()} @@ -4020,7 +3398,7 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp } }() case 77: try { - var v: Fuzz_Testing_Message.OneofGroup? + var v: SwiftProtoTesting_Fuzz_Message.OneofGroup? var hadOneofValue = false if let current = _storage._o { hadOneofValue = true @@ -4033,7 +3411,7 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp } }() case 79: try { - var v: Fuzz_Testing_Message? + var v: SwiftProtoTesting_Fuzz_Message? var hadOneofValue = false if let current = _storage._o { hadOneofValue = true @@ -4074,8 +3452,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 112: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bool) }() case 113: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32String) }() case 114: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bytes) }() - case 115: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32AnEnum) }() - case 116: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32Message) }() + case 115: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32AnEnum) }() + case 116: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32Message) }() case 117: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int32) }() case 118: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() case 119: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Uint32) }() @@ -4091,8 +3469,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 129: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Bool) }() case 130: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64String) }() case 131: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Bytes) }() - case 132: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt64AnEnum) }() - case 133: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt64Message) }() + case 132: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt64AnEnum) }() + case 133: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt64Message) }() case 134: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Int32) }() case 135: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Int64) }() case 136: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() @@ -4108,8 +3486,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 146: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Bool) }() case 147: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32String) }() case 148: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Bytes) }() - case 149: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapUint32AnEnum) }() - case 150: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapUint32Message) }() + case 149: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapUint32AnEnum) }() + case 150: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapUint32Message) }() case 151: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Int32) }() case 152: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Int64) }() case 153: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Uint32) }() @@ -4125,8 +3503,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 163: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Bool) }() case 164: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64String) }() case 165: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Bytes) }() - case 166: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapUint64AnEnum) }() - case 167: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapUint64Message) }() + case 166: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapUint64AnEnum) }() + case 167: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapUint64Message) }() case 168: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Int32) }() case 169: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Int64) }() case 170: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Uint32) }() @@ -4142,8 +3520,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 180: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Bool) }() case 181: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32String) }() case 182: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Bytes) }() - case 183: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSint32AnEnum) }() - case 184: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSint32Message) }() + case 183: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSint32AnEnum) }() + case 184: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSint32Message) }() case 185: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Int32) }() case 186: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Int64) }() case 187: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Uint32) }() @@ -4159,8 +3537,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 197: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Bool) }() case 198: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64String) }() case 199: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Bytes) }() - case 200: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSint64AnEnum) }() - case 201: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSint64Message) }() + case 200: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSint64AnEnum) }() + case 201: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSint64Message) }() case 202: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Int32) }() case 203: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Int64) }() case 204: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Uint32) }() @@ -4176,8 +3554,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 214: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Bool) }() case 215: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32String) }() case 216: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Bytes) }() - case 217: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapFixed32AnEnum) }() - case 218: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapFixed32Message) }() + case 217: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapFixed32AnEnum) }() + case 218: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapFixed32Message) }() case 219: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Int32) }() case 220: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Int64) }() case 221: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Uint32) }() @@ -4193,8 +3571,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 231: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Bool) }() case 232: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64String) }() case 233: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Bytes) }() - case 234: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapFixed64AnEnum) }() - case 235: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapFixed64Message) }() + case 234: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapFixed64AnEnum) }() + case 235: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapFixed64Message) }() case 236: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Int32) }() case 237: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Int64) }() case 238: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Uint32) }() @@ -4210,8 +3588,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 248: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Bool) }() case 249: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32String) }() case 250: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Bytes) }() - case 251: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSfixed32AnEnum) }() - case 252: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSfixed32Message) }() + case 251: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSfixed32AnEnum) }() + case 252: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSfixed32Message) }() case 253: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Int32) }() case 254: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Int64) }() case 255: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Uint32) }() @@ -4227,8 +3605,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 265: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Bool) }() case 266: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64String) }() case 267: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Bytes) }() - case 268: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSfixed64AnEnum) }() - case 269: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSfixed64Message) }() + case 268: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSfixed64AnEnum) }() + case 269: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSfixed64Message) }() case 270: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolInt32) }() case 271: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolInt64) }() case 272: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolUint32) }() @@ -4244,8 +3622,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 282: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() case 283: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolString) }() case 284: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBytes) }() - case 285: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapBoolAnEnum) }() - case 286: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapBoolMessage) }() + case 285: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapBoolAnEnum) }() + case 286: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapBoolMessage) }() case 500: try { try decoder.decodeSingularMessageField(value: &_storage._wktAny) }() case 501: try { try decoder.decodeSingularMessageField(value: &_storage._wktApi) }() case 502: try { try decoder.decodeSingularMessageField(value: &_storage._wktDuration) }() @@ -4267,7 +3645,7 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 600: try { try decoder.decodeSingularMessageField(value: &_storage._singularMessageSet) }() case 601: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedMessageSet) }() case 1000..<2001: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Fuzz_Testing_Message.self, fieldNumber: fieldNumber) }() + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Fuzz_Message.self, fieldNumber: fieldNumber) }() default: break } } @@ -4551,10 +3929,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bytes, fieldNumber: 114) } if !_storage._mapInt32AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32AnEnum, fieldNumber: 115) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32AnEnum, fieldNumber: 115) } if !_storage._mapInt32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32Message, fieldNumber: 116) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32Message, fieldNumber: 116) } if !_storage._mapInt64Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Int32, fieldNumber: 117) @@ -4602,10 +3980,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Bytes, fieldNumber: 131) } if !_storage._mapInt64AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt64AnEnum, fieldNumber: 132) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt64AnEnum, fieldNumber: 132) } if !_storage._mapInt64Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt64Message, fieldNumber: 133) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt64Message, fieldNumber: 133) } if !_storage._mapUint32Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Int32, fieldNumber: 134) @@ -4653,10 +4031,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Bytes, fieldNumber: 148) } if !_storage._mapUint32AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapUint32AnEnum, fieldNumber: 149) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapUint32AnEnum, fieldNumber: 149) } if !_storage._mapUint32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapUint32Message, fieldNumber: 150) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapUint32Message, fieldNumber: 150) } if !_storage._mapUint64Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Int32, fieldNumber: 151) @@ -4704,10 +4082,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Bytes, fieldNumber: 165) } if !_storage._mapUint64AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapUint64AnEnum, fieldNumber: 166) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapUint64AnEnum, fieldNumber: 166) } if !_storage._mapUint64Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapUint64Message, fieldNumber: 167) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapUint64Message, fieldNumber: 167) } if !_storage._mapSint32Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Int32, fieldNumber: 168) @@ -4755,10 +4133,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Bytes, fieldNumber: 182) } if !_storage._mapSint32AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSint32AnEnum, fieldNumber: 183) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSint32AnEnum, fieldNumber: 183) } if !_storage._mapSint32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSint32Message, fieldNumber: 184) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSint32Message, fieldNumber: 184) } if !_storage._mapSint64Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Int32, fieldNumber: 185) @@ -4806,10 +4184,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Bytes, fieldNumber: 199) } if !_storage._mapSint64AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSint64AnEnum, fieldNumber: 200) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSint64AnEnum, fieldNumber: 200) } if !_storage._mapSint64Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSint64Message, fieldNumber: 201) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSint64Message, fieldNumber: 201) } if !_storage._mapFixed32Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Int32, fieldNumber: 202) @@ -4857,10 +4235,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Bytes, fieldNumber: 216) } if !_storage._mapFixed32AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapFixed32AnEnum, fieldNumber: 217) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapFixed32AnEnum, fieldNumber: 217) } if !_storage._mapFixed32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapFixed32Message, fieldNumber: 218) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapFixed32Message, fieldNumber: 218) } if !_storage._mapFixed64Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Int32, fieldNumber: 219) @@ -4908,10 +4286,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Bytes, fieldNumber: 233) } if !_storage._mapFixed64AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapFixed64AnEnum, fieldNumber: 234) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapFixed64AnEnum, fieldNumber: 234) } if !_storage._mapFixed64Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapFixed64Message, fieldNumber: 235) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapFixed64Message, fieldNumber: 235) } if !_storage._mapSfixed32Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Int32, fieldNumber: 236) @@ -4959,10 +4337,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Bytes, fieldNumber: 250) } if !_storage._mapSfixed32AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSfixed32AnEnum, fieldNumber: 251) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSfixed32AnEnum, fieldNumber: 251) } if !_storage._mapSfixed32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSfixed32Message, fieldNumber: 252) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSfixed32Message, fieldNumber: 252) } if !_storage._mapSfixed64Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Int32, fieldNumber: 253) @@ -5010,10 +4388,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Bytes, fieldNumber: 267) } if !_storage._mapSfixed64AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSfixed64AnEnum, fieldNumber: 268) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSfixed64AnEnum, fieldNumber: 268) } if !_storage._mapSfixed64Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSfixed64Message, fieldNumber: 269) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSfixed64Message, fieldNumber: 269) } if !_storage._mapBoolInt32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolInt32, fieldNumber: 270) @@ -5061,10 +4439,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolBytes, fieldNumber: 284) } if !_storage._mapBoolAnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapBoolAnEnum, fieldNumber: 285) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapBoolAnEnum, fieldNumber: 285) } if !_storage._mapBoolMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapBoolMessage, fieldNumber: 286) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapBoolMessage, fieldNumber: 286) } try { if let v = _storage._wktAny { try visitor.visitSingularMessageField(value: v, fieldNumber: 500) @@ -5131,7 +4509,7 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Fuzz_Testing_Message, rhs: Fuzz_Testing_Message) -> Bool { + static func ==(lhs: SwiftProtoTesting_Fuzz_Message, rhs: SwiftProtoTesting_Fuzz_Message) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -5404,11 +4782,9 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp } } -extension Fuzz_Testing_Message.SingularGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = Fuzz_Testing_Message.protoMessageName + ".SingularGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 18: .standard(proto: "group_field"), - ] +extension SwiftProtoTesting_Fuzz_Message.SingularGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Fuzz_Message.protoMessageName + ".SingularGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{12}group_field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -5433,18 +4809,16 @@ extension Fuzz_Testing_Message.SingularGroup: SwiftProtobuf.Message, SwiftProtob try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Fuzz_Testing_Message.SingularGroup, rhs: Fuzz_Testing_Message.SingularGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_Fuzz_Message.SingularGroup, rhs: SwiftProtoTesting_Fuzz_Message.SingularGroup) -> Bool { if lhs._groupField != rhs._groupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Fuzz_Testing_Message.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = Fuzz_Testing_Message.protoMessageName + ".RepeatedGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 48: .standard(proto: "group_field"), - ] +extension SwiftProtoTesting_Fuzz_Message.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Fuzz_Message.protoMessageName + ".RepeatedGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}0group_field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -5469,18 +4843,16 @@ extension Fuzz_Testing_Message.RepeatedGroup: SwiftProtobuf.Message, SwiftProtob try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Fuzz_Testing_Message.RepeatedGroup, rhs: Fuzz_Testing_Message.RepeatedGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_Fuzz_Message.RepeatedGroup, rhs: SwiftProtoTesting_Fuzz_Message.RepeatedGroup) -> Bool { if lhs._groupField != rhs._groupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Fuzz_Testing_Message.OneofGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = Fuzz_Testing_Message.protoMessageName + ".OneofGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 78: .standard(proto: "group_field"), - ] +extension SwiftProtoTesting_Fuzz_Message.OneofGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Fuzz_Message.protoMessageName + ".OneofGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}N\u{1}group_field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -5505,14 +4877,14 @@ extension Fuzz_Testing_Message.OneofGroup: SwiftProtobuf.Message, SwiftProtobuf. try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Fuzz_Testing_Message.OneofGroup, rhs: Fuzz_Testing_Message.OneofGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_Fuzz_Message.OneofGroup, rhs: SwiftProtoTesting_Fuzz_Message.OneofGroup) -> Bool { if lhs._groupField != rhs._groupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Fuzz_Testing_AMessageSetMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Fuzz_AMessageSetMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".AMessageSetMessage" static let _protobuf_nameMap = SwiftProtobuf._NameMap() @@ -5522,7 +4894,7 @@ extension Fuzz_Testing_AMessageSetMessage: SwiftProtobuf.Message, SwiftProtobuf. } mutating func decodeMessage(decoder: inout D) throws { - try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: Fuzz_Testing_AMessageSetMessage.self) + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Fuzz_AMessageSetMessage.self) } func traverse(visitor: inout V) throws { @@ -5530,18 +4902,84 @@ extension Fuzz_Testing_AMessageSetMessage: SwiftProtobuf.Message, SwiftProtobuf. try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Fuzz_Testing_AMessageSetMessage, rhs: Fuzz_Testing_AMessageSetMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Fuzz_AMessageSetMessage, rhs: SwiftProtoTesting_Fuzz_AMessageSetMessage) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension Fuzz_Testing_SingularGroup_ext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".AMessageSetMessageExtension1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{a}a_string\0") + + 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 10: try { try decoder.decodeSingularStringField(value: &self._aString) }() + 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 + try { if let v = self._aString { + try visitor.visitSingularStringField(value: v, fieldNumber: 10) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1, rhs: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1) -> Bool { + if lhs._aString != rhs._aString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".AMessageSetMessageExtension2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{14}an_int32\0") + + 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 20: try { try decoder.decodeSingularInt32Field(value: &self._anInt32) }() + 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 + try { if let v = self._anInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 20) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2, rhs: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2) -> Bool { + if lhs._anInt32 != rhs._anInt32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Fuzz_SingularGroup_ext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SingularGroup_ext" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1018: .standard(proto: "group_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}z\u{f}group_field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -5566,18 +5004,16 @@ extension Fuzz_Testing_SingularGroup_ext: SwiftProtobuf.Message, SwiftProtobuf._ try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Fuzz_Testing_SingularGroup_ext, rhs: Fuzz_Testing_SingularGroup_ext) -> Bool { + static func ==(lhs: SwiftProtoTesting_Fuzz_SingularGroup_ext, rhs: SwiftProtoTesting_Fuzz_SingularGroup_ext) -> Bool { if lhs._groupField != rhs._groupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Fuzz_Testing_RepeatedGroup_ext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Fuzz_RepeatedGroup_ext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".RepeatedGroup_ext" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1048: .standard(proto: "group_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}X\u{10}group_field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -5602,7 +5038,7 @@ extension Fuzz_Testing_RepeatedGroup_ext: SwiftProtobuf.Message, SwiftProtobuf._ try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Fuzz_Testing_RepeatedGroup_ext, rhs: Fuzz_Testing_RepeatedGroup_ext) -> Bool { + static func ==(lhs: SwiftProtoTesting_Fuzz_RepeatedGroup_ext, rhs: SwiftProtoTesting_Fuzz_RepeatedGroup_ext) -> Bool { if lhs._groupField != rhs._groupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Reference/Tests/SwiftProtobufTests/generated_swift_names_enum_cases.pb.swift b/Reference/Tests/SwiftProtobufTests/generated_swift_names_enum_cases.pb.swift new file mode 100644 index 000000000..6698d859d --- /dev/null +++ b/Reference/Tests/SwiftProtobufTests/generated_swift_names_enum_cases.pb.swift @@ -0,0 +1,4180 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: generated_swift_names_enum_cases.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +/// See Makefile for the logic that generates this +/// Protoc errors imply this file is being generated incorrectly +/// Swift compile errors are probably bugs in protoc-gen-swift + +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 SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case none // = 0 + case addPath // = 1 + case adjusted // = 2 + case aggregateValue // = 3 + case allCases_ // = 4 + case allowAlias // = 5 + case alwaysPrintEnumsAsInts // = 6 + case alwaysPrintInt64SAsNumbers // = 7 + case annotation // = 8 + case any // = 9 + case anyExtensionField // = 10 + case anyMessageExtension // = 11 + case anyMessageStorage // = 12 + case anyUnpackError // = 13 + case append // = 14 + case appended // = 15 + case appendUintHex // = 16 + case appendUnknown // = 17 + case areAllInitialized // = 18 + case array // = 19 + case arrayDepth // = 20 + case arrayLiteral // = 21 + case arraySeparator // = 22 + case `as` // = 23 + case asciiOpenCurlyBracket // = 24 + case asciiZero // = 25 + case async // = 26 + case asyncIterator // = 27 + case asyncIteratorProtocol // = 28 + case asyncMessageSequence // = 29 + case available // = 30 + case b // = 31 + case base // = 32 + case base64Values // = 33 + case baseAddress // = 34 + case baseType // = 35 + case begin // = 36 + case binary // = 37 + case binaryDecoder // = 38 + case binaryDecoding // = 39 + case binaryDecodingError // = 40 + case binaryDecodingOptions // = 41 + case binaryDelimited // = 42 + case binaryEncoder // = 43 + case binaryEncodingError // = 44 + case binaryEncodingMessageSetSizeVisitor // = 45 + case binaryEncodingMessageSetVisitor // = 46 + case binaryEncodingOptions // = 47 + case binaryEncodingSizeVisitor // = 48 + case binaryEncodingVisitor // = 49 + case binaryOptions // = 50 + case binaryProtobufDelimitedMessages // = 51 + case binaryStreamDecoding // = 52 + case binaryStreamDecodingError // = 53 + case bitPattern // = 54 + case body // = 55 + case bool // = 56 + case booleanLiteral // = 57 + case booleanLiteralType // = 58 + case boolValue // = 59 + case buffer // = 60 + case byte // = 61 + case bytecode // = 62 + case bytecodeReader // = 63 + case bytes // = 64 + case bytesInGroup // = 65 + case bytesNeeded // = 66 + case bytesRead // = 67 + case c // = 68 + case canonical // = 69 + case capitalizeNext // = 70 + case cardinality // = 71 + case caseIterable // = 72 + case castedValue // = 73 + case ccEnableArenas // = 74 + case ccGenericServices // = 75 + case character // = 76 + case chars // = 77 + case checkProgramFormat // = 78 + case chunk // = 79 + case `class` // = 80 + case clearAggregateValue // = 81 + case clearAllowAlias // = 82 + case clearBegin // = 83 + case clearCcEnableArenas // = 84 + case clearCcGenericServices // = 85 + case clearClientStreaming // = 86 + case clearCsharpNamespace // = 87 + case clearCtype // = 88 + case clearDebugRedact // = 89 + case clearDefaultSymbolVisibility // = 90 + case clearDefaultValue // = 91 + case clearDeprecated // = 92 + case clearDeprecatedLegacyJsonFieldConflicts // = 93 + case clearDeprecationWarning // = 94 + case clearDoubleValue // = 95 + case clearEdition // = 96 + case clearEditionDeprecated // = 97 + case clearEditionIntroduced // = 98 + case clearEditionRemoved // = 99 + case clearEnd // = 100 + case clearEnforceNamingStyle // = 101 + case clearEnumType // = 102 + case clearExtendee // = 103 + case clearExtensionValue // = 104 + case clearFeatures // = 105 + case clearFeatureSupport // = 106 + case clearFieldPresence // = 107 + case clearFixedFeatures // = 108 + case clearFullName // = 109 + case clearGoPackage // = 110 + case clearIdempotencyLevel // = 111 + case clearIdentifierValue // = 112 + case clearInputType // = 113 + case clearIsExtension // = 114 + case clearJavaGenerateEqualsAndHash // = 115 + case clearJavaGenericServices // = 116 + case clearJavaMultipleFiles // = 117 + case clearJavaOuterClassname // = 118 + case clearJavaPackage // = 119 + case clearJavaStringCheckUtf8 // = 120 + case clearJsonFormat // = 121 + case clearJsonName // = 122 + case clearJstype // = 123 + case clearLabel // = 124 + case clearLazy // = 125 + case clearLeadingComments // = 126 + case clearMapEntry // = 127 + case clearMaximumEdition // = 128 + case clearMessageEncoding // = 129 + case clearMessageSetWireFormat // = 130 + case clearMinimumEdition // = 131 + case clearName // = 132 + case clearNamePart // = 133 + case clearNegativeIntValue // = 134 + case clearNoStandardDescriptorAccessor // = 135 + case clearNumber // = 136 + case clearObjcClassPrefix // = 137 + case clearOneofIndex // = 138 + case clearOptimizeFor // = 139 + case clearOptions // = 140 + case clearOutputType // = 141 + case clearOverridableFeatures // = 142 + case clearPackage // = 143 + case clearPacked // = 144 + case clearPhpClassPrefix // = 145 + case clearPhpMetadataNamespace // = 146 + case clearPhpNamespace // = 147 + case clearPositiveIntValue // = 148 + case clearProto3Optional // = 149 + case clearPyGenericServices // = 150 + case clearRemovalError // = 151 + case clearRepeated // = 152 + case clearRepeatedFieldEncoding // = 153 + case clearReserved // = 154 + case clearRetention // = 155 + case clearRubyPackage // = 156 + case clearSemantic // = 157 + case clearServerStreaming // = 158 + case clearSourceCodeInfo // = 159 + case clearSourceContext // = 160 + case clearSourceFile // = 161 + case clearStart // = 162 + case clearStringValue // = 163 + case clearSwiftPrefix // = 164 + case clearSyntax // = 165 + case clearTrailingComments // = 166 + case clearType // = 167 + case clearTypeName // = 168 + case clearUnverifiedLazy // = 169 + case clearUtf8Validation // = 170 + case clearValue // = 171 + case clearVerification // = 172 + case clearVisibility // = 173 + case clearWeak // = 174 + case clientStreaming // = 175 + case code // = 176 + case codePoint // = 177 + case codeUnits // = 178 + case collection // = 179 + case comma // = 180 + case consumedBytes // = 181 + case contains // = 182 + case contentsOf // = 183 + case contiguousBytes // = 184 + case copy // = 185 + case count // = 186 + case countVarintsInBuffer // = 187 + case csharpNamespace // = 188 + case ctype // = 189 + case customCodable // = 190 + case customDebugStringConvertible // = 191 + case customStringConvertible // = 192 + case d // = 193 + case data // = 194 + case dataResult // = 195 + case date // = 196 + case daySec // = 197 + case daysSinceEpoch // = 198 + case debugDescription_ // = 199 + case debugRedact // = 200 + case declaration // = 201 + case decoded // = 202 + case decodedFromJsonnull // = 203 + case decodeExtensionField // = 204 + case decodeExtensionFieldsAsMessageSet // = 205 + case decodeJson // = 206 + case decodeMapField // = 207 + case decodeMessage // = 208 + case decoder // = 209 + case decodeRepeated // = 210 + case decodeRepeatedBoolField // = 211 + case decodeRepeatedBytesField // = 212 + case decodeRepeatedDoubleField // = 213 + case decodeRepeatedEnumField // = 214 + case decodeRepeatedFixed32Field // = 215 + case decodeRepeatedFixed64Field // = 216 + case decodeRepeatedFloatField // = 217 + case decodeRepeatedGroupField // = 218 + case decodeRepeatedInt32Field // = 219 + case decodeRepeatedInt64Field // = 220 + case decodeRepeatedMessageField // = 221 + case decodeRepeatedSfixed32Field // = 222 + case decodeRepeatedSfixed64Field // = 223 + case decodeRepeatedSint32Field // = 224 + case decodeRepeatedSint64Field // = 225 + case decodeRepeatedStringField // = 226 + case decodeRepeatedUint32Field // = 227 + case decodeRepeatedUint64Field // = 228 + case decodeSingular // = 229 + case decodeSingularBoolField // = 230 + case decodeSingularBytesField // = 231 + case decodeSingularDoubleField // = 232 + case decodeSingularEnumField // = 233 + case decodeSingularFixed32Field // = 234 + case decodeSingularFixed64Field // = 235 + case decodeSingularFloatField // = 236 + case decodeSingularGroupField // = 237 + case decodeSingularInt32Field // = 238 + case decodeSingularInt64Field // = 239 + case decodeSingularMessageField // = 240 + case decodeSingularSfixed32Field // = 241 + case decodeSingularSfixed64Field // = 242 + case decodeSingularSint32Field // = 243 + case decodeSingularSint64Field // = 244 + case decodeSingularStringField // = 245 + case decodeSingularUint32Field // = 246 + case decodeSingularUint64Field // = 247 + case decodeTextFormat // = 248 + case defaultAnyTypeUrlprefix // = 249 + case defaults // = 250 + case defaultSymbolVisibility // = 251 + case defaultValue // = 252 + case dependency // = 253 + case deprecated // = 254 + case deprecatedLegacyJsonFieldConflicts // = 255 + case deprecationWarning // = 256 + case description_ // = 257 + case dictionary // = 258 + case dictionaryLiteral // = 259 + case digit // = 260 + case digit0 // = 261 + case digit1 // = 262 + case digitCount // = 263 + case digits // = 264 + case digitValue // = 265 + case discardableResult // = 266 + case discardUnknownFields // = 267 + case double // = 268 + case doubleValue // = 269 + case duration // = 270 + case e // = 271 + case edition // = 272 + case editionDefault // = 273 + case editionDefaults // = 274 + case editionDeprecated // = 275 + case editionIntroduced // = 276 + case editionRemoved // = 277 + case element // = 278 + case elements // = 279 + case `else` // = 280 + case emitExtensionFieldName // = 281 + case emitFieldName // = 282 + case emitFieldNumber // = 283 + case emptyAnyTypeURL // = 284 + case emptyData // = 285 + case encodeAsBytes // = 286 + case encoded // = 287 + case encodedJsonstring // = 288 + case encodedSize // = 289 + case encodeField // = 290 + case encoder // = 291 + case end // = 292 + case endArray // = 293 + case endMessageField // = 294 + case endObject // = 295 + case endRegularField // = 296 + case enforceNamingStyle // = 297 + case `enum` // = 298 + case enumReservedRange // = 299 + case enumType // = 300 + case enumvalue // = 301 + case equatable // = 302 + case error // = 303 + case execute // = 304 + case expressibleByArrayLiteral // = 305 + case expressibleByDictionaryLiteral // = 306 + case ext // = 307 + case extDecoder // = 308 + case extendedGraphemeClusterLiteral // = 309 + case extendedGraphemeClusterLiteralType // = 310 + case extendee // = 311 + case extensibleMessage // = 312 + case `extension` // = 313 + case extensionField // = 314 + case extensionFieldNumber // = 315 + case extensionFieldValueSet // = 316 + case extensionMap // = 317 + case extensionRange // = 318 + case extensions // = 319 + case extras // = 320 + case f // = 321 + case `false` // = 322 + case features // = 323 + case featureSetEditionDefault // = 324 + case featureSupport // = 325 + case field // = 326 + case fieldData // = 327 + case fieldMaskError // = 328 + case fieldName // = 329 + case fieldNameCount // = 330 + case fieldNum // = 331 + case fieldNumber // = 332 + case fieldNumberForProto // = 333 + case fieldPresence // = 334 + case fields // = 335 + case fieldSize // = 336 + case fieldTag // = 337 + case fieldType // = 338 + case file // = 339 + case fileName // = 340 + case filter // = 341 + case final // = 342 + case finiteOnly // = 343 + case first // = 344 + case firstItem // = 345 + case fixedFeatures // = 346 + case float // = 347 + case floatLiteral // = 348 + case floatLiteralType // = 349 + case `for` // = 350 + case forMessageName // = 351 + case formUnion // = 352 + case forReadingFrom // = 353 + case forTypeURL // = 354 + case forwardParser // = 355 + case forWritingInto // = 356 + case from // = 357 + case fromAscii2 // = 358 + case fromAscii4 // = 359 + case fromByteOffset // = 360 + case fromHexDigit // = 361 + case fullName // = 362 + case `func` // = 363 + case function // = 364 + case g // = 365 + case get // = 366 + case getExtensionValue // = 367 + case googleProtobufAny // = 368 + case googleProtobufApi // = 369 + case googleProtobufBoolValue // = 370 + case googleProtobufBytesValue // = 371 + case googleProtobufDescriptorProto // = 372 + case googleProtobufDoubleValue // = 373 + case googleProtobufDuration // = 374 + case googleProtobufEdition // = 375 + case googleProtobufEmpty // = 376 + case googleProtobufEnum // = 377 + case googleProtobufEnumDescriptorProto // = 378 + case googleProtobufEnumOptions // = 379 + case googleProtobufEnumValue // = 380 + case googleProtobufEnumValueDescriptorProto // = 381 + case googleProtobufEnumValueOptions // = 382 + case googleProtobufExtensionRangeOptions // = 383 + case googleProtobufFeatureSet // = 384 + case googleProtobufFeatureSetDefaults // = 385 + case googleProtobufField // = 386 + case googleProtobufFieldDescriptorProto // = 387 + case googleProtobufFieldMask // = 388 + case googleProtobufFieldOptions // = 389 + case googleProtobufFileDescriptorProto // = 390 + case googleProtobufFileDescriptorSet // = 391 + case googleProtobufFileOptions // = 392 + case googleProtobufFloatValue // = 393 + case googleProtobufGeneratedCodeInfo // = 394 + case googleProtobufInt32Value // = 395 + case googleProtobufInt64Value // = 396 + case googleProtobufListValue // = 397 + case googleProtobufMessageOptions // = 398 + case googleProtobufMethod // = 399 + case googleProtobufMethodDescriptorProto // = 400 + case googleProtobufMethodOptions // = 401 + case googleProtobufMixin // = 402 + case googleProtobufNullValue // = 403 + case googleProtobufOneofDescriptorProto // = 404 + case googleProtobufOneofOptions // = 405 + case googleProtobufOption // = 406 + case googleProtobufServiceDescriptorProto // = 407 + case googleProtobufServiceOptions // = 408 + case googleProtobufSourceCodeInfo // = 409 + case googleProtobufSourceContext // = 410 + case googleProtobufStringValue // = 411 + case googleProtobufStruct // = 412 + case googleProtobufSymbolVisibility // = 413 + case googleProtobufSyntax // = 414 + case googleProtobufTimestamp // = 415 + case googleProtobufType // = 416 + case googleProtobufUint32Value // = 417 + case googleProtobufUint64Value // = 418 + case googleProtobufUninterpretedOption // = 419 + case googleProtobufValue // = 420 + case goPackage // = 421 + case gotData // = 422 + case group // = 423 + case groupFieldNumberStack // = 424 + case groupSize // = 425 + case `guard` // = 426 + case hadOneofValue // = 427 + case handleConflictingOneOf // = 428 + case handleInstruction // = 429 + case hasAggregateValue // = 430 + case hasAllowAlias // = 431 + case hasBegin // = 432 + case hasCcEnableArenas // = 433 + case hasCcGenericServices // = 434 + case hasClientStreaming // = 435 + case hasCsharpNamespace // = 436 + case hasCtype // = 437 + case hasData // = 438 + case hasDebugRedact // = 439 + case hasDefaultSymbolVisibility // = 440 + case hasDefaultValue // = 441 + case hasDeprecated // = 442 + case hasDeprecatedLegacyJsonFieldConflicts // = 443 + case hasDeprecationWarning // = 444 + case hasDoubleValue // = 445 + case hasEdition // = 446 + case hasEditionDeprecated // = 447 + case hasEditionIntroduced // = 448 + case hasEditionRemoved // = 449 + case hasEnd // = 450 + case hasEnforceNamingStyle // = 451 + case hasEnumType // = 452 + case hasExplicitDelta // = 453 + case hasExtendee // = 454 + case hasExtensionValue // = 455 + case hasFeatures // = 456 + case hasFeatureSupport // = 457 + case hasFieldPresence // = 458 + case hasFixedFeatures // = 459 + case hasFullName // = 460 + case hasGoPackage // = 461 + case hash // = 462 + case hashable // = 463 + case hasher // = 464 + case hashVisitor // = 465 + case hasIdempotencyLevel // = 466 + case hasIdentifierValue // = 467 + case hasInputType // = 468 + case hasIsExtension // = 469 + case hasJavaGenerateEqualsAndHash // = 470 + case hasJavaGenericServices // = 471 + case hasJavaMultipleFiles // = 472 + case hasJavaOuterClassname // = 473 + case hasJavaPackage // = 474 + case hasJavaStringCheckUtf8 // = 475 + case hasJsonFormat // = 476 + case hasJsonName // = 477 + case hasJstype // = 478 + case hasLabel // = 479 + case hasLazy // = 480 + case hasLeadingComments // = 481 + case hasMapEntry // = 482 + case hasMaximumEdition // = 483 + case hasMessageEncoding // = 484 + case hasMessageSetWireFormat // = 485 + case hasMinimumEdition // = 486 + case hasName // = 487 + case hasNamePart // = 488 + case hasNegativeIntValue // = 489 + case hasNoStandardDescriptorAccessor // = 490 + case hasNumber // = 491 + case hasObjcClassPrefix // = 492 + case hasOneofIndex // = 493 + case hasOptimizeFor // = 494 + case hasOptions // = 495 + case hasOutputType // = 496 + case hasOverridableFeatures // = 497 + case hasPackage // = 498 + case hasPacked // = 499 + case hasPhpClassPrefix // = 500 + case hasPhpMetadataNamespace // = 501 + case hasPhpNamespace // = 502 + case hasPositiveIntValue // = 503 + case hasProto3Optional // = 504 + case hasPyGenericServices // = 505 + case hasRemovalError // = 506 + case hasRepeated // = 507 + case hasRepeatedFieldEncoding // = 508 + case hasReserved // = 509 + case hasRetention // = 510 + case hasRubyPackage // = 511 + case hasSemantic // = 512 + case hasServerStreaming // = 513 + case hasSourceCodeInfo // = 514 + case hasSourceContext // = 515 + case hasSourceFile // = 516 + case hasStart // = 517 + case hasStringValue // = 518 + case hasSwiftPrefix // = 519 + case hasSyntax // = 520 + case hasTrailingComments // = 521 + case hasType // = 522 + case hasTypeName // = 523 + case hasUnverifiedLazy // = 524 + case hasUtf8Validation // = 525 + case hasValue // = 526 + case hasVerification // = 527 + case hasVisibility // = 528 + case hasWeak // = 529 + case hour // = 530 + case i // = 531 + case idempotencyLevel // = 532 + case identifierValue // = 533 + case `if` // = 534 + case ignoreUnknownExtensionFields // = 535 + case ignoreUnknownFields // = 536 + case index // = 537 + case init_ // = 538 + case `inout` // = 539 + case inputType // = 540 + case insert // = 541 + case instruction // = 542 + case int // = 543 + case int32 // = 544 + case int64 // = 545 + case int8 // = 546 + case integerLiteral // = 547 + case integerLiteralType // = 548 + case intern // = 549 + case `internal` // = 550 + case internalState // = 551 + case intersect // = 552 + case into // = 553 + case ints // = 554 + case invalidAnyTypeURL // = 555 + case isA // = 556 + case isEqual // = 557 + case isEqualTo // = 558 + case isExtension // = 559 + case isInitialized // = 560 + case isNegative // = 561 + case isPathValid // = 562 + case isReserved // = 563 + case isValid // = 564 + case itemTagsEncodedSize // = 565 + case iterator // = 566 + case javaGenerateEqualsAndHash // = 567 + case javaGenericServices // = 568 + case javaMultipleFiles // = 569 + case javaOuterClassname // = 570 + case javaPackage // = 571 + case javaStringCheckUtf8 // = 572 + case jsondecoder // = 573 + case jsondecoding // = 574 + case jsondecodingError // = 575 + case jsondecodingOptions // = 576 + case jsonEncoder // = 577 + case jsonencoding // = 578 + case jsonencodingError // = 579 + case jsonencodingOptions // = 580 + case jsonencodingVisitor // = 581 + case jsonFormat // = 582 + case jsonmapEncodingVisitor // = 583 + case jsonName // = 584 + case jsonPath // = 585 + case jsonPaths // = 586 + case jsonscanner // = 587 + case jsonString // = 588 + case jsonText // = 589 + case jsonUtf8Bytes // = 590 + case jsonUtf8Data // = 591 + case jstype // = 592 + case k // = 593 + case kChunkSize // = 594 + case key // = 595 + case keyField // = 596 + case keyFieldOpt // = 597 + case keyType // = 598 + case kind // = 599 + case l // = 600 + case label // = 601 + case lazy // = 602 + case leadingComments // = 603 + case leadingDetachedComments // = 604 + case length // = 605 + case lessThan // = 606 + case `let` // = 607 + case lhs // = 608 + case line // = 609 + case list // = 610 + case listOfMessages // = 611 + case listValue // = 612 + case littleEndian // = 613 + case load // = 614 + case localHasher // = 615 + case location // = 616 + case m // = 617 + case major // = 618 + case makeAsyncIterator // = 619 + case makeIterator // = 620 + case malformedLength // = 621 + case mapEntry // = 622 + case mapKeyType // = 623 + case mapToMessages // = 624 + case mapValueType // = 625 + case mapVisitor // = 626 + case mask // = 627 + case maximumEdition // = 628 + case mdayStart // = 629 + case merge // = 630 + case mergeOptions // = 631 + case message // = 632 + case messageDepthLimit // = 633 + case messageEncoding // = 634 + case messageExtension // = 635 + case messageImplementationBase // = 636 + case messageSet // = 637 + case messageSetWireFormat // = 638 + case messageSize // = 639 + case messageType // = 640 + case method // = 641 + case methods // = 642 + case min // = 643 + case minimumEdition // = 644 + case minor // = 645 + case mixins // = 646 + case modify // = 647 + case month // = 648 + case msgExtension // = 649 + case mutating // = 650 + case n // = 651 + case name // = 652 + case nameDescription // = 653 + case nameMap // = 654 + case namePart // = 655 + case names // = 656 + case nanos // = 657 + case negativeIntValue // = 658 + case nestedType // = 659 + case newExtensible // = 660 + case newL // = 661 + case newList // = 662 + case newMessage // = 663 + case newValue // = 664 + case next // = 665 + case nextByte // = 666 + case nextFieldNumber // = 667 + case nextInstruction // = 668 + case nextInt32 // = 669 + case nextNullTerminatedString // = 670 + case nextNullTerminatedStringArray // = 671 + case nextNumber // = 672 + case nextUint64 // = 673 + case nextVarInt // = 674 + case `nil` // = 675 + case nilLiteral // = 676 + case noBytesAvailable // = 677 + case noStandardDescriptorAccessor // = 678 + case nullValue // = 679 + case number // = 680 + case numberValue // = 681 + case objcClassPrefix // = 682 + case of // = 683 + case oneOfKind // = 684 + case oneofDecl // = 685 + case oneofIndex // = 686 + case oneofs // = 687 + case optimizeFor // = 688 + case optimizeMode // = 689 + case optionalEnumExtensionField // = 690 + case optionalExtensionField // = 691 + case optionalGroupExtensionField // = 692 + case optionalMessageExtensionField // = 693 + case optionDependency // = 694 + case optionRetention // = 695 + case options // = 696 + case optionTargetType // = 697 + case other // = 698 + case others // = 699 + case out // = 700 + case outputType // = 701 + case overridableFeatures // = 702 + case p // = 703 + case package // = 704 + case packed // = 705 + case packedEnumExtensionField // = 706 + case packedExtensionField // = 707 + case padding // = 708 + case parent // = 709 + case parse // = 710 + case partial // = 711 + case path // = 712 + case pathDecoder // = 713 + case pathDecodingError // = 714 + case paths // = 715 + case pathVisitor // = 716 + case payload // = 717 + case payloadSize // = 718 + case phpClassPrefix // = 719 + case phpMetadataNamespace // = 720 + case phpNamespace // = 721 + case pos // = 722 + case positiveIntValue // = 723 + case prefix // = 724 + case preserveProtoFieldNames // = 725 + case preTraverse // = 726 + case previousNumber // = 727 + case prevPath // = 728 + case printUnknownFields // = 729 + case programBuffer // = 730 + case programFormat // = 731 + case proto2 // = 732 + case proto3DefaultValue // = 733 + case proto3Optional // = 734 + case protobufExtensionFieldValues // = 735 + case protobufFieldNumber // = 736 + case protobufGeneratedIsEqualTo // = 737 + case protobufNameMap // = 738 + case protobufNewField // = 739 + case protobufPackage // = 740 + case protobufApiversion2 // = 741 + case protobufApiversionCheck // = 742 + case protobufBool // = 743 + case protobufBytes // = 744 + case protobufData // = 745 + case protobufDouble // = 746 + case protobufEnumMap // = 747 + case protobufExtension // = 748 + case protobufFixed32 // = 749 + case protobufFixed64 // = 750 + case protobufFloat // = 751 + case protobufInt32 // = 752 + case protobufInt64 // = 753 + case protobufMap // = 754 + case protobufMessageMap // = 755 + case protobufSfixed32 // = 756 + case protobufSfixed64 // = 757 + case protobufSint32 // = 758 + case protobufSint64 // = 759 + case protobufString // = 760 + case protobufUint32 // = 761 + case protobufUint64 // = 762 + case `protocol` // = 763 + case protoFieldName // = 764 + case protoMessageName // = 765 + case protoNameProviding // = 766 + case protoPaths // = 767 + case `public` // = 768 + case publicDependency // = 769 + case putBoolValue // = 770 + case putBytesValue // = 771 + case putDoubleValue // = 772 + case putEnumValue // = 773 + case putFixedUint32 // = 774 + case putFixedUint64 // = 775 + case putFloatValue // = 776 + case putInt64 // = 777 + case putStringValue // = 778 + case putUint64 // = 779 + case putUint64Hex // = 780 + case putVarInt // = 781 + case putZigZagVarInt // = 782 + case pyGenericServices // = 783 + case r // = 784 + case rawChars // = 785 + case rawRepresentable // = 786 + case rawValue_ // = 787 + case read4HexDigits // = 788 + case readBytes // = 789 + case reader // = 790 + case register // = 791 + case remainingProgram // = 792 + case removalError // = 793 + case removingAllFieldsOf // = 794 + case repeated // = 795 + case repeatedEnumExtensionField // = 796 + case repeatedExtensionField // = 797 + case repeatedFieldEncoding // = 798 + case repeatedGroupExtensionField // = 799 + case repeatedMessageExtensionField // = 800 + case repeating // = 801 + case replaceRepeatedFields // = 802 + case requestStreaming // = 803 + case requestTypeURL // = 804 + case requiredSize // = 805 + case responseStreaming // = 806 + case responseTypeURL // = 807 + case result // = 808 + case retention // = 809 + case `rethrows` // = 810 + case returnType // = 811 + case revision // = 812 + case rhs // = 813 + case root // = 814 + case rubyPackage // = 815 + case s // = 816 + case sawBackslash // = 817 + case sawSection4Characters // = 818 + case sawSection5Characters // = 819 + case scalar // = 820 + case scan // = 821 + case scanner // = 822 + case seconds // = 823 + case self_ // = 824 + case semantic // = 825 + case sendable // = 826 + case separator // = 827 + case serialize // = 828 + case serializedBytes // = 829 + case serializedData // = 830 + case serializedSize // = 831 + case serverStreaming // = 832 + case service // = 833 + case set // = 834 + case setExtensionValue // = 835 + case shift // = 836 + case simpleExtensionMap // = 837 + case size // = 838 + case sizer // = 839 + case source // = 840 + case sourceCodeInfo // = 841 + case sourceContext // = 842 + case sourceEncoding // = 843 + case sourceFile // = 844 + case sourceLocation // = 845 + case span // = 846 + case split // = 847 + case start // = 848 + case startArray // = 849 + case startArrayObject // = 850 + case startField // = 851 + case startIndex // = 852 + case startMessageField // = 853 + case startObject // = 854 + case startRegularField // = 855 + case state // = 856 + case `static` // = 857 + case staticString // = 858 + case storage // = 859 + case string // = 860 + case stringLiteral // = 861 + case stringLiteralType // = 862 + case stringResult // = 863 + case stringValue // = 864 + case `struct` // = 865 + case structValue // = 866 + case subDecoder // = 867 + case `subscript` // = 868 + case subtract // = 869 + case subVisitor // = 870 + case swift // = 871 + case swiftPrefix // = 872 + case swiftProtobufContiguousBytes // = 873 + case swiftProtobufError // = 874 + case syntax // = 875 + case t // = 876 + case tag // = 877 + case targets // = 878 + case terminator // = 879 + case testDecoder // = 880 + case text // = 881 + case textDecoder // = 882 + case textFormatDecoder // = 883 + case textFormatDecodingError // = 884 + case textFormatDecodingOptions // = 885 + case textFormatEncodingOptions // = 886 + case textFormatEncodingVisitor // = 887 + case textFormatString // = 888 + case throwOrIgnore // = 889 + case `throws` // = 890 + case timeInterval // = 891 + case timeIntervalSince1970 // = 892 + case timeIntervalSinceReferenceDate // = 893 + case tmp // = 894 + case tooLarge // = 895 + case total // = 896 + case totalArrayDepth // = 897 + case totalSize // = 898 + case trailingComments // = 899 + case traverse // = 900 + case trim // = 901 + case `true` // = 902 + case `try` // = 903 + case type // = 904 + case `typealias` // = 905 + case typeEnum // = 906 + case typeName // = 907 + case typePrefix // = 908 + case typeStart // = 909 + case typeUnknown // = 910 + case typeURL // = 911 + case uint32 // = 912 + case uint64 // = 913 + case uint8 // = 914 + case unchecked // = 915 + case unicode // = 916 + case unicodeScalarLiteral // = 917 + case unicodeScalarLiteralType // = 918 + case unicodeScalars // = 919 + case unicodeScalarView // = 920 + case uninterpretedOption // = 921 + case union // = 922 + case uniqueStorage // = 923 + case unknown // = 924 + case unknownFields // = 925 + case unknownStorage // = 926 + case unpackTo // = 927 + case unsafeBufferPointer // = 928 + case unsafeMutablePointer // = 929 + case unsafeMutableRawBufferPointer // = 930 + case unsafeRawBufferPointer // = 931 + case unsafeRawPointer // = 932 + case unverifiedLazy // = 933 + case updatedOptions // = 934 + case uppercasedAssumingAscii // = 935 + case url // = 936 + case useDeterministicOrdering // = 937 + case utf8 // = 938 + case utf8Ptr // = 939 + case utf8ToDouble // = 940 + case utf8Validation // = 941 + case utf8View // = 942 + case v // = 943 + case value // = 944 + case valueField // = 945 + case values // = 946 + case valueType // = 947 + case `var` // = 948 + case verification // = 949 + case verificationState // = 950 + case version // = 951 + case versionString // = 952 + case visibility // = 953 + case visibilityFeature // = 954 + case visitExtensionFields // = 955 + case visitExtensionFieldsAsMessageSet // = 956 + case visitMapField // = 957 + case visitor // = 958 + case visitPacked // = 959 + case visitPackedBoolField // = 960 + case visitPackedDoubleField // = 961 + case visitPackedEnumField // = 962 + case visitPackedFixed32Field // = 963 + case visitPackedFixed64Field // = 964 + case visitPackedFloatField // = 965 + case visitPackedInt32Field // = 966 + case visitPackedInt64Field // = 967 + case visitPackedSfixed32Field // = 968 + case visitPackedSfixed64Field // = 969 + case visitPackedSint32Field // = 970 + case visitPackedSint64Field // = 971 + case visitPackedUint32Field // = 972 + case visitPackedUint64Field // = 973 + case visitRepeated // = 974 + case visitRepeatedBoolField // = 975 + case visitRepeatedBytesField // = 976 + case visitRepeatedDoubleField // = 977 + case visitRepeatedEnumField // = 978 + case visitRepeatedFixed32Field // = 979 + case visitRepeatedFixed64Field // = 980 + case visitRepeatedFloatField // = 981 + case visitRepeatedGroupField // = 982 + case visitRepeatedInt32Field // = 983 + case visitRepeatedInt64Field // = 984 + case visitRepeatedMessageField // = 985 + case visitRepeatedSfixed32Field // = 986 + case visitRepeatedSfixed64Field // = 987 + case visitRepeatedSint32Field // = 988 + case visitRepeatedSint64Field // = 989 + case visitRepeatedStringField // = 990 + case visitRepeatedUint32Field // = 991 + case visitRepeatedUint64Field // = 992 + case visitSingular // = 993 + case visitSingularBoolField // = 994 + case visitSingularBytesField // = 995 + case visitSingularDoubleField // = 996 + case visitSingularEnumField // = 997 + case visitSingularFixed32Field // = 998 + case visitSingularFixed64Field // = 999 + case visitSingularFloatField // = 1000 + case visitSingularGroupField // = 1001 + case visitSingularInt32Field // = 1002 + case visitSingularInt64Field // = 1003 + case visitSingularMessageField // = 1004 + case visitSingularSfixed32Field // = 1005 + case visitSingularSfixed64Field // = 1006 + case visitSingularSint32Field // = 1007 + case visitSingularSint64Field // = 1008 + case visitSingularStringField // = 1009 + case visitSingularUint32Field // = 1010 + case visitSingularUint64Field // = 1011 + case visitUnknown // = 1012 + case void // = 1013 + case wasDecoded // = 1014 + case weak // = 1015 + case weakDependency // = 1016 + case `where` // = 1017 + case wireFormat // = 1018 + case with // = 1019 + case withUnsafeBytes // = 1020 + case withUnsafeMutableBytes // = 1021 + case work // = 1022 + case wrapped // = 1023 + case wrappedType // = 1024 + case wrappedValue // = 1025 + case written // = 1026 + case yday // = 1027 + case UNRECOGNIZED(Int) + + init() { + self = .none + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .none + case 1: self = .addPath + case 2: self = .adjusted + case 3: self = .aggregateValue + case 4: self = .allCases_ + case 5: self = .allowAlias + case 6: self = .alwaysPrintEnumsAsInts + case 7: self = .alwaysPrintInt64SAsNumbers + case 8: self = .annotation + case 9: self = .any + case 10: self = .anyExtensionField + case 11: self = .anyMessageExtension + case 12: self = .anyMessageStorage + case 13: self = .anyUnpackError + case 14: self = .append + case 15: self = .appended + case 16: self = .appendUintHex + case 17: self = .appendUnknown + case 18: self = .areAllInitialized + case 19: self = .array + case 20: self = .arrayDepth + case 21: self = .arrayLiteral + case 22: self = .arraySeparator + case 23: self = .as + case 24: self = .asciiOpenCurlyBracket + case 25: self = .asciiZero + case 26: self = .async + case 27: self = .asyncIterator + case 28: self = .asyncIteratorProtocol + case 29: self = .asyncMessageSequence + case 30: self = .available + case 31: self = .b + case 32: self = .base + case 33: self = .base64Values + case 34: self = .baseAddress + case 35: self = .baseType + case 36: self = .begin + case 37: self = .binary + case 38: self = .binaryDecoder + case 39: self = .binaryDecoding + case 40: self = .binaryDecodingError + case 41: self = .binaryDecodingOptions + case 42: self = .binaryDelimited + case 43: self = .binaryEncoder + case 44: self = .binaryEncodingError + case 45: self = .binaryEncodingMessageSetSizeVisitor + case 46: self = .binaryEncodingMessageSetVisitor + case 47: self = .binaryEncodingOptions + case 48: self = .binaryEncodingSizeVisitor + case 49: self = .binaryEncodingVisitor + case 50: self = .binaryOptions + case 51: self = .binaryProtobufDelimitedMessages + case 52: self = .binaryStreamDecoding + case 53: self = .binaryStreamDecodingError + case 54: self = .bitPattern + case 55: self = .body + case 56: self = .bool + case 57: self = .booleanLiteral + case 58: self = .booleanLiteralType + case 59: self = .boolValue + case 60: self = .buffer + case 61: self = .byte + case 62: self = .bytecode + case 63: self = .bytecodeReader + case 64: self = .bytes + case 65: self = .bytesInGroup + case 66: self = .bytesNeeded + case 67: self = .bytesRead + case 68: self = .c + case 69: self = .canonical + case 70: self = .capitalizeNext + case 71: self = .cardinality + case 72: self = .caseIterable + case 73: self = .castedValue + case 74: self = .ccEnableArenas + case 75: self = .ccGenericServices + case 76: self = .character + case 77: self = .chars + case 78: self = .checkProgramFormat + case 79: self = .chunk + case 80: self = .class + case 81: self = .clearAggregateValue + case 82: self = .clearAllowAlias + case 83: self = .clearBegin + case 84: self = .clearCcEnableArenas + case 85: self = .clearCcGenericServices + case 86: self = .clearClientStreaming + case 87: self = .clearCsharpNamespace + case 88: self = .clearCtype + case 89: self = .clearDebugRedact + case 90: self = .clearDefaultSymbolVisibility + case 91: self = .clearDefaultValue + case 92: self = .clearDeprecated + case 93: self = .clearDeprecatedLegacyJsonFieldConflicts + case 94: self = .clearDeprecationWarning + case 95: self = .clearDoubleValue + case 96: self = .clearEdition + case 97: self = .clearEditionDeprecated + case 98: self = .clearEditionIntroduced + case 99: self = .clearEditionRemoved + case 100: self = .clearEnd + case 101: self = .clearEnforceNamingStyle + case 102: self = .clearEnumType + case 103: self = .clearExtendee + case 104: self = .clearExtensionValue + case 105: self = .clearFeatures + case 106: self = .clearFeatureSupport + case 107: self = .clearFieldPresence + case 108: self = .clearFixedFeatures + case 109: self = .clearFullName + case 110: self = .clearGoPackage + case 111: self = .clearIdempotencyLevel + case 112: self = .clearIdentifierValue + case 113: self = .clearInputType + case 114: self = .clearIsExtension + case 115: self = .clearJavaGenerateEqualsAndHash + case 116: self = .clearJavaGenericServices + case 117: self = .clearJavaMultipleFiles + case 118: self = .clearJavaOuterClassname + case 119: self = .clearJavaPackage + case 120: self = .clearJavaStringCheckUtf8 + case 121: self = .clearJsonFormat + case 122: self = .clearJsonName + case 123: self = .clearJstype + case 124: self = .clearLabel + case 125: self = .clearLazy + case 126: self = .clearLeadingComments + case 127: self = .clearMapEntry + case 128: self = .clearMaximumEdition + case 129: self = .clearMessageEncoding + case 130: self = .clearMessageSetWireFormat + case 131: self = .clearMinimumEdition + case 132: self = .clearName + case 133: self = .clearNamePart + case 134: self = .clearNegativeIntValue + case 135: self = .clearNoStandardDescriptorAccessor + case 136: self = .clearNumber + case 137: self = .clearObjcClassPrefix + case 138: self = .clearOneofIndex + case 139: self = .clearOptimizeFor + case 140: self = .clearOptions + case 141: self = .clearOutputType + case 142: self = .clearOverridableFeatures + case 143: self = .clearPackage + case 144: self = .clearPacked + case 145: self = .clearPhpClassPrefix + case 146: self = .clearPhpMetadataNamespace + case 147: self = .clearPhpNamespace + case 148: self = .clearPositiveIntValue + case 149: self = .clearProto3Optional + case 150: self = .clearPyGenericServices + case 151: self = .clearRemovalError + case 152: self = .clearRepeated + case 153: self = .clearRepeatedFieldEncoding + case 154: self = .clearReserved + case 155: self = .clearRetention + case 156: self = .clearRubyPackage + case 157: self = .clearSemantic + case 158: self = .clearServerStreaming + case 159: self = .clearSourceCodeInfo + case 160: self = .clearSourceContext + case 161: self = .clearSourceFile + case 162: self = .clearStart + case 163: self = .clearStringValue + case 164: self = .clearSwiftPrefix + case 165: self = .clearSyntax + case 166: self = .clearTrailingComments + case 167: self = .clearType + case 168: self = .clearTypeName + case 169: self = .clearUnverifiedLazy + case 170: self = .clearUtf8Validation + case 171: self = .clearValue + case 172: self = .clearVerification + case 173: self = .clearVisibility + case 174: self = .clearWeak + case 175: self = .clientStreaming + case 176: self = .code + case 177: self = .codePoint + case 178: self = .codeUnits + case 179: self = .collection + case 180: self = .comma + case 181: self = .consumedBytes + case 182: self = .contains + case 183: self = .contentsOf + case 184: self = .contiguousBytes + case 185: self = .copy + case 186: self = .count + case 187: self = .countVarintsInBuffer + case 188: self = .csharpNamespace + case 189: self = .ctype + case 190: self = .customCodable + case 191: self = .customDebugStringConvertible + case 192: self = .customStringConvertible + case 193: self = .d + case 194: self = .data + case 195: self = .dataResult + case 196: self = .date + case 197: self = .daySec + case 198: self = .daysSinceEpoch + case 199: self = .debugDescription_ + case 200: self = .debugRedact + case 201: self = .declaration + case 202: self = .decoded + case 203: self = .decodedFromJsonnull + case 204: self = .decodeExtensionField + case 205: self = .decodeExtensionFieldsAsMessageSet + case 206: self = .decodeJson + case 207: self = .decodeMapField + case 208: self = .decodeMessage + case 209: self = .decoder + case 210: self = .decodeRepeated + case 211: self = .decodeRepeatedBoolField + case 212: self = .decodeRepeatedBytesField + case 213: self = .decodeRepeatedDoubleField + case 214: self = .decodeRepeatedEnumField + case 215: self = .decodeRepeatedFixed32Field + case 216: self = .decodeRepeatedFixed64Field + case 217: self = .decodeRepeatedFloatField + case 218: self = .decodeRepeatedGroupField + case 219: self = .decodeRepeatedInt32Field + case 220: self = .decodeRepeatedInt64Field + case 221: self = .decodeRepeatedMessageField + case 222: self = .decodeRepeatedSfixed32Field + case 223: self = .decodeRepeatedSfixed64Field + case 224: self = .decodeRepeatedSint32Field + case 225: self = .decodeRepeatedSint64Field + case 226: self = .decodeRepeatedStringField + case 227: self = .decodeRepeatedUint32Field + case 228: self = .decodeRepeatedUint64Field + case 229: self = .decodeSingular + case 230: self = .decodeSingularBoolField + case 231: self = .decodeSingularBytesField + case 232: self = .decodeSingularDoubleField + case 233: self = .decodeSingularEnumField + case 234: self = .decodeSingularFixed32Field + case 235: self = .decodeSingularFixed64Field + case 236: self = .decodeSingularFloatField + case 237: self = .decodeSingularGroupField + case 238: self = .decodeSingularInt32Field + case 239: self = .decodeSingularInt64Field + case 240: self = .decodeSingularMessageField + case 241: self = .decodeSingularSfixed32Field + case 242: self = .decodeSingularSfixed64Field + case 243: self = .decodeSingularSint32Field + case 244: self = .decodeSingularSint64Field + case 245: self = .decodeSingularStringField + case 246: self = .decodeSingularUint32Field + case 247: self = .decodeSingularUint64Field + case 248: self = .decodeTextFormat + case 249: self = .defaultAnyTypeUrlprefix + case 250: self = .defaults + case 251: self = .defaultSymbolVisibility + case 252: self = .defaultValue + case 253: self = .dependency + case 254: self = .deprecated + case 255: self = .deprecatedLegacyJsonFieldConflicts + case 256: self = .deprecationWarning + case 257: self = .description_ + case 258: self = .dictionary + case 259: self = .dictionaryLiteral + case 260: self = .digit + case 261: self = .digit0 + case 262: self = .digit1 + case 263: self = .digitCount + case 264: self = .digits + case 265: self = .digitValue + case 266: self = .discardableResult + case 267: self = .discardUnknownFields + case 268: self = .double + case 269: self = .doubleValue + case 270: self = .duration + case 271: self = .e + case 272: self = .edition + case 273: self = .editionDefault + case 274: self = .editionDefaults + case 275: self = .editionDeprecated + case 276: self = .editionIntroduced + case 277: self = .editionRemoved + case 278: self = .element + case 279: self = .elements + case 280: self = .else + case 281: self = .emitExtensionFieldName + case 282: self = .emitFieldName + case 283: self = .emitFieldNumber + case 284: self = .emptyAnyTypeURL + case 285: self = .emptyData + case 286: self = .encodeAsBytes + case 287: self = .encoded + case 288: self = .encodedJsonstring + case 289: self = .encodedSize + case 290: self = .encodeField + case 291: self = .encoder + case 292: self = .end + case 293: self = .endArray + case 294: self = .endMessageField + case 295: self = .endObject + case 296: self = .endRegularField + case 297: self = .enforceNamingStyle + case 298: self = .enum + case 299: self = .enumReservedRange + case 300: self = .enumType + case 301: self = .enumvalue + case 302: self = .equatable + case 303: self = .error + case 304: self = .execute + case 305: self = .expressibleByArrayLiteral + case 306: self = .expressibleByDictionaryLiteral + case 307: self = .ext + case 308: self = .extDecoder + case 309: self = .extendedGraphemeClusterLiteral + case 310: self = .extendedGraphemeClusterLiteralType + case 311: self = .extendee + case 312: self = .extensibleMessage + case 313: self = .extension + case 314: self = .extensionField + case 315: self = .extensionFieldNumber + case 316: self = .extensionFieldValueSet + case 317: self = .extensionMap + case 318: self = .extensionRange + case 319: self = .extensions + case 320: self = .extras + case 321: self = .f + case 322: self = .false + case 323: self = .features + case 324: self = .featureSetEditionDefault + case 325: self = .featureSupport + case 326: self = .field + case 327: self = .fieldData + case 328: self = .fieldMaskError + case 329: self = .fieldName + case 330: self = .fieldNameCount + case 331: self = .fieldNum + case 332: self = .fieldNumber + case 333: self = .fieldNumberForProto + case 334: self = .fieldPresence + case 335: self = .fields + case 336: self = .fieldSize + case 337: self = .fieldTag + case 338: self = .fieldType + case 339: self = .file + case 340: self = .fileName + case 341: self = .filter + case 342: self = .final + case 343: self = .finiteOnly + case 344: self = .first + case 345: self = .firstItem + case 346: self = .fixedFeatures + case 347: self = .float + case 348: self = .floatLiteral + case 349: self = .floatLiteralType + case 350: self = .for + case 351: self = .forMessageName + case 352: self = .formUnion + case 353: self = .forReadingFrom + case 354: self = .forTypeURL + case 355: self = .forwardParser + case 356: self = .forWritingInto + case 357: self = .from + case 358: self = .fromAscii2 + case 359: self = .fromAscii4 + case 360: self = .fromByteOffset + case 361: self = .fromHexDigit + case 362: self = .fullName + case 363: self = .func + case 364: self = .function + case 365: self = .g + case 366: self = .get + case 367: self = .getExtensionValue + case 368: self = .googleProtobufAny + case 369: self = .googleProtobufApi + case 370: self = .googleProtobufBoolValue + case 371: self = .googleProtobufBytesValue + case 372: self = .googleProtobufDescriptorProto + case 373: self = .googleProtobufDoubleValue + case 374: self = .googleProtobufDuration + case 375: self = .googleProtobufEdition + case 376: self = .googleProtobufEmpty + case 377: self = .googleProtobufEnum + case 378: self = .googleProtobufEnumDescriptorProto + case 379: self = .googleProtobufEnumOptions + case 380: self = .googleProtobufEnumValue + case 381: self = .googleProtobufEnumValueDescriptorProto + case 382: self = .googleProtobufEnumValueOptions + case 383: self = .googleProtobufExtensionRangeOptions + case 384: self = .googleProtobufFeatureSet + case 385: self = .googleProtobufFeatureSetDefaults + case 386: self = .googleProtobufField + case 387: self = .googleProtobufFieldDescriptorProto + case 388: self = .googleProtobufFieldMask + case 389: self = .googleProtobufFieldOptions + case 390: self = .googleProtobufFileDescriptorProto + case 391: self = .googleProtobufFileDescriptorSet + case 392: self = .googleProtobufFileOptions + case 393: self = .googleProtobufFloatValue + case 394: self = .googleProtobufGeneratedCodeInfo + case 395: self = .googleProtobufInt32Value + case 396: self = .googleProtobufInt64Value + case 397: self = .googleProtobufListValue + case 398: self = .googleProtobufMessageOptions + case 399: self = .googleProtobufMethod + case 400: self = .googleProtobufMethodDescriptorProto + case 401: self = .googleProtobufMethodOptions + case 402: self = .googleProtobufMixin + case 403: self = .googleProtobufNullValue + case 404: self = .googleProtobufOneofDescriptorProto + case 405: self = .googleProtobufOneofOptions + case 406: self = .googleProtobufOption + case 407: self = .googleProtobufServiceDescriptorProto + case 408: self = .googleProtobufServiceOptions + case 409: self = .googleProtobufSourceCodeInfo + case 410: self = .googleProtobufSourceContext + case 411: self = .googleProtobufStringValue + case 412: self = .googleProtobufStruct + case 413: self = .googleProtobufSymbolVisibility + case 414: self = .googleProtobufSyntax + case 415: self = .googleProtobufTimestamp + case 416: self = .googleProtobufType + case 417: self = .googleProtobufUint32Value + case 418: self = .googleProtobufUint64Value + case 419: self = .googleProtobufUninterpretedOption + case 420: self = .googleProtobufValue + case 421: self = .goPackage + case 422: self = .gotData + case 423: self = .group + case 424: self = .groupFieldNumberStack + case 425: self = .groupSize + case 426: self = .guard + case 427: self = .hadOneofValue + case 428: self = .handleConflictingOneOf + case 429: self = .handleInstruction + case 430: self = .hasAggregateValue + case 431: self = .hasAllowAlias + case 432: self = .hasBegin + case 433: self = .hasCcEnableArenas + case 434: self = .hasCcGenericServices + case 435: self = .hasClientStreaming + case 436: self = .hasCsharpNamespace + case 437: self = .hasCtype + case 438: self = .hasData + case 439: self = .hasDebugRedact + case 440: self = .hasDefaultSymbolVisibility + case 441: self = .hasDefaultValue + case 442: self = .hasDeprecated + case 443: self = .hasDeprecatedLegacyJsonFieldConflicts + case 444: self = .hasDeprecationWarning + case 445: self = .hasDoubleValue + case 446: self = .hasEdition + case 447: self = .hasEditionDeprecated + case 448: self = .hasEditionIntroduced + case 449: self = .hasEditionRemoved + case 450: self = .hasEnd + case 451: self = .hasEnforceNamingStyle + case 452: self = .hasEnumType + case 453: self = .hasExplicitDelta + case 454: self = .hasExtendee + case 455: self = .hasExtensionValue + case 456: self = .hasFeatures + case 457: self = .hasFeatureSupport + case 458: self = .hasFieldPresence + case 459: self = .hasFixedFeatures + case 460: self = .hasFullName + case 461: self = .hasGoPackage + case 462: self = .hash + case 463: self = .hashable + case 464: self = .hasher + case 465: self = .hashVisitor + case 466: self = .hasIdempotencyLevel + case 467: self = .hasIdentifierValue + case 468: self = .hasInputType + case 469: self = .hasIsExtension + case 470: self = .hasJavaGenerateEqualsAndHash + case 471: self = .hasJavaGenericServices + case 472: self = .hasJavaMultipleFiles + case 473: self = .hasJavaOuterClassname + case 474: self = .hasJavaPackage + case 475: self = .hasJavaStringCheckUtf8 + case 476: self = .hasJsonFormat + case 477: self = .hasJsonName + case 478: self = .hasJstype + case 479: self = .hasLabel + case 480: self = .hasLazy + case 481: self = .hasLeadingComments + case 482: self = .hasMapEntry + case 483: self = .hasMaximumEdition + case 484: self = .hasMessageEncoding + case 485: self = .hasMessageSetWireFormat + case 486: self = .hasMinimumEdition + case 487: self = .hasName + case 488: self = .hasNamePart + case 489: self = .hasNegativeIntValue + case 490: self = .hasNoStandardDescriptorAccessor + case 491: self = .hasNumber + case 492: self = .hasObjcClassPrefix + case 493: self = .hasOneofIndex + case 494: self = .hasOptimizeFor + case 495: self = .hasOptions + case 496: self = .hasOutputType + case 497: self = .hasOverridableFeatures + case 498: self = .hasPackage + case 499: self = .hasPacked + case 500: self = .hasPhpClassPrefix + case 501: self = .hasPhpMetadataNamespace + case 502: self = .hasPhpNamespace + case 503: self = .hasPositiveIntValue + case 504: self = .hasProto3Optional + case 505: self = .hasPyGenericServices + case 506: self = .hasRemovalError + case 507: self = .hasRepeated + case 508: self = .hasRepeatedFieldEncoding + case 509: self = .hasReserved + case 510: self = .hasRetention + case 511: self = .hasRubyPackage + case 512: self = .hasSemantic + case 513: self = .hasServerStreaming + case 514: self = .hasSourceCodeInfo + case 515: self = .hasSourceContext + case 516: self = .hasSourceFile + case 517: self = .hasStart + case 518: self = .hasStringValue + case 519: self = .hasSwiftPrefix + case 520: self = .hasSyntax + case 521: self = .hasTrailingComments + case 522: self = .hasType + case 523: self = .hasTypeName + case 524: self = .hasUnverifiedLazy + case 525: self = .hasUtf8Validation + case 526: self = .hasValue + case 527: self = .hasVerification + case 528: self = .hasVisibility + case 529: self = .hasWeak + case 530: self = .hour + case 531: self = .i + case 532: self = .idempotencyLevel + case 533: self = .identifierValue + case 534: self = .if + case 535: self = .ignoreUnknownExtensionFields + case 536: self = .ignoreUnknownFields + case 537: self = .index + case 538: self = .init_ + case 539: self = .inout + case 540: self = .inputType + case 541: self = .insert + case 542: self = .instruction + case 543: self = .int + case 544: self = .int32 + case 545: self = .int64 + case 546: self = .int8 + case 547: self = .integerLiteral + case 548: self = .integerLiteralType + case 549: self = .intern + case 550: self = .internal + case 551: self = .internalState + case 552: self = .intersect + case 553: self = .into + case 554: self = .ints + case 555: self = .invalidAnyTypeURL + case 556: self = .isA + case 557: self = .isEqual + case 558: self = .isEqualTo + case 559: self = .isExtension + case 560: self = .isInitialized + case 561: self = .isNegative + case 562: self = .isPathValid + case 563: self = .isReserved + case 564: self = .isValid + case 565: self = .itemTagsEncodedSize + case 566: self = .iterator + case 567: self = .javaGenerateEqualsAndHash + case 568: self = .javaGenericServices + case 569: self = .javaMultipleFiles + case 570: self = .javaOuterClassname + case 571: self = .javaPackage + case 572: self = .javaStringCheckUtf8 + case 573: self = .jsondecoder + case 574: self = .jsondecoding + case 575: self = .jsondecodingError + case 576: self = .jsondecodingOptions + case 577: self = .jsonEncoder + case 578: self = .jsonencoding + case 579: self = .jsonencodingError + case 580: self = .jsonencodingOptions + case 581: self = .jsonencodingVisitor + case 582: self = .jsonFormat + case 583: self = .jsonmapEncodingVisitor + case 584: self = .jsonName + case 585: self = .jsonPath + case 586: self = .jsonPaths + case 587: self = .jsonscanner + case 588: self = .jsonString + case 589: self = .jsonText + case 590: self = .jsonUtf8Bytes + case 591: self = .jsonUtf8Data + case 592: self = .jstype + case 593: self = .k + case 594: self = .kChunkSize + case 595: self = .key + case 596: self = .keyField + case 597: self = .keyFieldOpt + case 598: self = .keyType + case 599: self = .kind + case 600: self = .l + case 601: self = .label + case 602: self = .lazy + case 603: self = .leadingComments + case 604: self = .leadingDetachedComments + case 605: self = .length + case 606: self = .lessThan + case 607: self = .let + case 608: self = .lhs + case 609: self = .line + case 610: self = .list + case 611: self = .listOfMessages + case 612: self = .listValue + case 613: self = .littleEndian + case 614: self = .load + case 615: self = .localHasher + case 616: self = .location + case 617: self = .m + case 618: self = .major + case 619: self = .makeAsyncIterator + case 620: self = .makeIterator + case 621: self = .malformedLength + case 622: self = .mapEntry + case 623: self = .mapKeyType + case 624: self = .mapToMessages + case 625: self = .mapValueType + case 626: self = .mapVisitor + case 627: self = .mask + case 628: self = .maximumEdition + case 629: self = .mdayStart + case 630: self = .merge + case 631: self = .mergeOptions + case 632: self = .message + case 633: self = .messageDepthLimit + case 634: self = .messageEncoding + case 635: self = .messageExtension + case 636: self = .messageImplementationBase + case 637: self = .messageSet + case 638: self = .messageSetWireFormat + case 639: self = .messageSize + case 640: self = .messageType + case 641: self = .method + case 642: self = .methods + case 643: self = .min + case 644: self = .minimumEdition + case 645: self = .minor + case 646: self = .mixins + case 647: self = .modify + case 648: self = .month + case 649: self = .msgExtension + case 650: self = .mutating + case 651: self = .n + case 652: self = .name + case 653: self = .nameDescription + case 654: self = .nameMap + case 655: self = .namePart + case 656: self = .names + case 657: self = .nanos + case 658: self = .negativeIntValue + case 659: self = .nestedType + case 660: self = .newExtensible + case 661: self = .newL + case 662: self = .newList + case 663: self = .newMessage + case 664: self = .newValue + case 665: self = .next + case 666: self = .nextByte + case 667: self = .nextFieldNumber + case 668: self = .nextInstruction + case 669: self = .nextInt32 + case 670: self = .nextNullTerminatedString + case 671: self = .nextNullTerminatedStringArray + case 672: self = .nextNumber + case 673: self = .nextUint64 + case 674: self = .nextVarInt + case 675: self = .nil + case 676: self = .nilLiteral + case 677: self = .noBytesAvailable + case 678: self = .noStandardDescriptorAccessor + case 679: self = .nullValue + case 680: self = .number + case 681: self = .numberValue + case 682: self = .objcClassPrefix + case 683: self = .of + case 684: self = .oneOfKind + case 685: self = .oneofDecl + case 686: self = .oneofIndex + case 687: self = .oneofs + case 688: self = .optimizeFor + case 689: self = .optimizeMode + case 690: self = .optionalEnumExtensionField + case 691: self = .optionalExtensionField + case 692: self = .optionalGroupExtensionField + case 693: self = .optionalMessageExtensionField + case 694: self = .optionDependency + case 695: self = .optionRetention + case 696: self = .options + case 697: self = .optionTargetType + case 698: self = .other + case 699: self = .others + case 700: self = .out + case 701: self = .outputType + case 702: self = .overridableFeatures + case 703: self = .p + case 704: self = .package + case 705: self = .packed + case 706: self = .packedEnumExtensionField + case 707: self = .packedExtensionField + case 708: self = .padding + case 709: self = .parent + case 710: self = .parse + case 711: self = .partial + case 712: self = .path + case 713: self = .pathDecoder + case 714: self = .pathDecodingError + case 715: self = .paths + case 716: self = .pathVisitor + case 717: self = .payload + case 718: self = .payloadSize + case 719: self = .phpClassPrefix + case 720: self = .phpMetadataNamespace + case 721: self = .phpNamespace + case 722: self = .pos + case 723: self = .positiveIntValue + case 724: self = .prefix + case 725: self = .preserveProtoFieldNames + case 726: self = .preTraverse + case 727: self = .previousNumber + case 728: self = .prevPath + case 729: self = .printUnknownFields + case 730: self = .programBuffer + case 731: self = .programFormat + case 732: self = .proto2 + case 733: self = .proto3DefaultValue + case 734: self = .proto3Optional + case 735: self = .protobufExtensionFieldValues + case 736: self = .protobufFieldNumber + case 737: self = .protobufGeneratedIsEqualTo + case 738: self = .protobufNameMap + case 739: self = .protobufNewField + case 740: self = .protobufPackage + case 741: self = .protobufApiversion2 + case 742: self = .protobufApiversionCheck + case 743: self = .protobufBool + case 744: self = .protobufBytes + case 745: self = .protobufData + case 746: self = .protobufDouble + case 747: self = .protobufEnumMap + case 748: self = .protobufExtension + case 749: self = .protobufFixed32 + case 750: self = .protobufFixed64 + case 751: self = .protobufFloat + case 752: self = .protobufInt32 + case 753: self = .protobufInt64 + case 754: self = .protobufMap + case 755: self = .protobufMessageMap + case 756: self = .protobufSfixed32 + case 757: self = .protobufSfixed64 + case 758: self = .protobufSint32 + case 759: self = .protobufSint64 + case 760: self = .protobufString + case 761: self = .protobufUint32 + case 762: self = .protobufUint64 + case 763: self = .protocol + case 764: self = .protoFieldName + case 765: self = .protoMessageName + case 766: self = .protoNameProviding + case 767: self = .protoPaths + case 768: self = .public + case 769: self = .publicDependency + case 770: self = .putBoolValue + case 771: self = .putBytesValue + case 772: self = .putDoubleValue + case 773: self = .putEnumValue + case 774: self = .putFixedUint32 + case 775: self = .putFixedUint64 + case 776: self = .putFloatValue + case 777: self = .putInt64 + case 778: self = .putStringValue + case 779: self = .putUint64 + case 780: self = .putUint64Hex + case 781: self = .putVarInt + case 782: self = .putZigZagVarInt + case 783: self = .pyGenericServices + case 784: self = .r + case 785: self = .rawChars + case 786: self = .rawRepresentable + case 787: self = .rawValue_ + case 788: self = .read4HexDigits + case 789: self = .readBytes + case 790: self = .reader + case 791: self = .register + case 792: self = .remainingProgram + case 793: self = .removalError + case 794: self = .removingAllFieldsOf + case 795: self = .repeated + case 796: self = .repeatedEnumExtensionField + case 797: self = .repeatedExtensionField + case 798: self = .repeatedFieldEncoding + case 799: self = .repeatedGroupExtensionField + case 800: self = .repeatedMessageExtensionField + case 801: self = .repeating + case 802: self = .replaceRepeatedFields + case 803: self = .requestStreaming + case 804: self = .requestTypeURL + case 805: self = .requiredSize + case 806: self = .responseStreaming + case 807: self = .responseTypeURL + case 808: self = .result + case 809: self = .retention + case 810: self = .rethrows + case 811: self = .returnType + case 812: self = .revision + case 813: self = .rhs + case 814: self = .root + case 815: self = .rubyPackage + case 816: self = .s + case 817: self = .sawBackslash + case 818: self = .sawSection4Characters + case 819: self = .sawSection5Characters + case 820: self = .scalar + case 821: self = .scan + case 822: self = .scanner + case 823: self = .seconds + case 824: self = .self_ + case 825: self = .semantic + case 826: self = .sendable + case 827: self = .separator + case 828: self = .serialize + case 829: self = .serializedBytes + case 830: self = .serializedData + case 831: self = .serializedSize + case 832: self = .serverStreaming + case 833: self = .service + case 834: self = .set + case 835: self = .setExtensionValue + case 836: self = .shift + case 837: self = .simpleExtensionMap + case 838: self = .size + case 839: self = .sizer + case 840: self = .source + case 841: self = .sourceCodeInfo + case 842: self = .sourceContext + case 843: self = .sourceEncoding + case 844: self = .sourceFile + case 845: self = .sourceLocation + case 846: self = .span + case 847: self = .split + case 848: self = .start + case 849: self = .startArray + case 850: self = .startArrayObject + case 851: self = .startField + case 852: self = .startIndex + case 853: self = .startMessageField + case 854: self = .startObject + case 855: self = .startRegularField + case 856: self = .state + case 857: self = .static + case 858: self = .staticString + case 859: self = .storage + case 860: self = .string + case 861: self = .stringLiteral + case 862: self = .stringLiteralType + case 863: self = .stringResult + case 864: self = .stringValue + case 865: self = .struct + case 866: self = .structValue + case 867: self = .subDecoder + case 868: self = .subscript + case 869: self = .subtract + case 870: self = .subVisitor + case 871: self = .swift + case 872: self = .swiftPrefix + case 873: self = .swiftProtobufContiguousBytes + case 874: self = .swiftProtobufError + case 875: self = .syntax + case 876: self = .t + case 877: self = .tag + case 878: self = .targets + case 879: self = .terminator + case 880: self = .testDecoder + case 881: self = .text + case 882: self = .textDecoder + case 883: self = .textFormatDecoder + case 884: self = .textFormatDecodingError + case 885: self = .textFormatDecodingOptions + case 886: self = .textFormatEncodingOptions + case 887: self = .textFormatEncodingVisitor + case 888: self = .textFormatString + case 889: self = .throwOrIgnore + case 890: self = .throws + case 891: self = .timeInterval + case 892: self = .timeIntervalSince1970 + case 893: self = .timeIntervalSinceReferenceDate + case 894: self = .tmp + case 895: self = .tooLarge + case 896: self = .total + case 897: self = .totalArrayDepth + case 898: self = .totalSize + case 899: self = .trailingComments + case 900: self = .traverse + case 901: self = .trim + case 902: self = .true + case 903: self = .try + case 904: self = .type + case 905: self = .typealias + case 906: self = .typeEnum + case 907: self = .typeName + case 908: self = .typePrefix + case 909: self = .typeStart + case 910: self = .typeUnknown + case 911: self = .typeURL + case 912: self = .uint32 + case 913: self = .uint64 + case 914: self = .uint8 + case 915: self = .unchecked + case 916: self = .unicode + case 917: self = .unicodeScalarLiteral + case 918: self = .unicodeScalarLiteralType + case 919: self = .unicodeScalars + case 920: self = .unicodeScalarView + case 921: self = .uninterpretedOption + case 922: self = .union + case 923: self = .uniqueStorage + case 924: self = .unknown + case 925: self = .unknownFields + case 926: self = .unknownStorage + case 927: self = .unpackTo + case 928: self = .unsafeBufferPointer + case 929: self = .unsafeMutablePointer + case 930: self = .unsafeMutableRawBufferPointer + case 931: self = .unsafeRawBufferPointer + case 932: self = .unsafeRawPointer + case 933: self = .unverifiedLazy + case 934: self = .updatedOptions + case 935: self = .uppercasedAssumingAscii + case 936: self = .url + case 937: self = .useDeterministicOrdering + case 938: self = .utf8 + case 939: self = .utf8Ptr + case 940: self = .utf8ToDouble + case 941: self = .utf8Validation + case 942: self = .utf8View + case 943: self = .v + case 944: self = .value + case 945: self = .valueField + case 946: self = .values + case 947: self = .valueType + case 948: self = .var + case 949: self = .verification + case 950: self = .verificationState + case 951: self = .version + case 952: self = .versionString + case 953: self = .visibility + case 954: self = .visibilityFeature + case 955: self = .visitExtensionFields + case 956: self = .visitExtensionFieldsAsMessageSet + case 957: self = .visitMapField + case 958: self = .visitor + case 959: self = .visitPacked + case 960: self = .visitPackedBoolField + case 961: self = .visitPackedDoubleField + case 962: self = .visitPackedEnumField + case 963: self = .visitPackedFixed32Field + case 964: self = .visitPackedFixed64Field + case 965: self = .visitPackedFloatField + case 966: self = .visitPackedInt32Field + case 967: self = .visitPackedInt64Field + case 968: self = .visitPackedSfixed32Field + case 969: self = .visitPackedSfixed64Field + case 970: self = .visitPackedSint32Field + case 971: self = .visitPackedSint64Field + case 972: self = .visitPackedUint32Field + case 973: self = .visitPackedUint64Field + case 974: self = .visitRepeated + case 975: self = .visitRepeatedBoolField + case 976: self = .visitRepeatedBytesField + case 977: self = .visitRepeatedDoubleField + case 978: self = .visitRepeatedEnumField + case 979: self = .visitRepeatedFixed32Field + case 980: self = .visitRepeatedFixed64Field + case 981: self = .visitRepeatedFloatField + case 982: self = .visitRepeatedGroupField + case 983: self = .visitRepeatedInt32Field + case 984: self = .visitRepeatedInt64Field + case 985: self = .visitRepeatedMessageField + case 986: self = .visitRepeatedSfixed32Field + case 987: self = .visitRepeatedSfixed64Field + case 988: self = .visitRepeatedSint32Field + case 989: self = .visitRepeatedSint64Field + case 990: self = .visitRepeatedStringField + case 991: self = .visitRepeatedUint32Field + case 992: self = .visitRepeatedUint64Field + case 993: self = .visitSingular + case 994: self = .visitSingularBoolField + case 995: self = .visitSingularBytesField + case 996: self = .visitSingularDoubleField + case 997: self = .visitSingularEnumField + case 998: self = .visitSingularFixed32Field + case 999: self = .visitSingularFixed64Field + case 1000: self = .visitSingularFloatField + case 1001: self = .visitSingularGroupField + case 1002: self = .visitSingularInt32Field + case 1003: self = .visitSingularInt64Field + case 1004: self = .visitSingularMessageField + case 1005: self = .visitSingularSfixed32Field + case 1006: self = .visitSingularSfixed64Field + case 1007: self = .visitSingularSint32Field + case 1008: self = .visitSingularSint64Field + case 1009: self = .visitSingularStringField + case 1010: self = .visitSingularUint32Field + case 1011: self = .visitSingularUint64Field + case 1012: self = .visitUnknown + case 1013: self = .void + case 1014: self = .wasDecoded + case 1015: self = .weak + case 1016: self = .weakDependency + case 1017: self = .where + case 1018: self = .wireFormat + case 1019: self = .with + case 1020: self = .withUnsafeBytes + case 1021: self = .withUnsafeMutableBytes + case 1022: self = .work + case 1023: self = .wrapped + case 1024: self = .wrappedType + case 1025: self = .wrappedValue + case 1026: self = .written + case 1027: self = .yday + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .none: return 0 + case .addPath: return 1 + case .adjusted: return 2 + case .aggregateValue: return 3 + case .allCases_: return 4 + case .allowAlias: return 5 + case .alwaysPrintEnumsAsInts: return 6 + case .alwaysPrintInt64SAsNumbers: return 7 + case .annotation: return 8 + case .any: return 9 + case .anyExtensionField: return 10 + case .anyMessageExtension: return 11 + case .anyMessageStorage: return 12 + case .anyUnpackError: return 13 + case .append: return 14 + case .appended: return 15 + case .appendUintHex: return 16 + case .appendUnknown: return 17 + case .areAllInitialized: return 18 + case .array: return 19 + case .arrayDepth: return 20 + case .arrayLiteral: return 21 + case .arraySeparator: return 22 + case .as: return 23 + case .asciiOpenCurlyBracket: return 24 + case .asciiZero: return 25 + case .async: return 26 + case .asyncIterator: return 27 + case .asyncIteratorProtocol: return 28 + case .asyncMessageSequence: return 29 + case .available: return 30 + case .b: return 31 + case .base: return 32 + case .base64Values: return 33 + case .baseAddress: return 34 + case .baseType: return 35 + case .begin: return 36 + case .binary: return 37 + case .binaryDecoder: return 38 + case .binaryDecoding: return 39 + case .binaryDecodingError: return 40 + case .binaryDecodingOptions: return 41 + case .binaryDelimited: return 42 + case .binaryEncoder: return 43 + case .binaryEncodingError: return 44 + case .binaryEncodingMessageSetSizeVisitor: return 45 + case .binaryEncodingMessageSetVisitor: return 46 + case .binaryEncodingOptions: return 47 + case .binaryEncodingSizeVisitor: return 48 + case .binaryEncodingVisitor: return 49 + case .binaryOptions: return 50 + case .binaryProtobufDelimitedMessages: return 51 + case .binaryStreamDecoding: return 52 + case .binaryStreamDecodingError: return 53 + case .bitPattern: return 54 + case .body: return 55 + case .bool: return 56 + case .booleanLiteral: return 57 + case .booleanLiteralType: return 58 + case .boolValue: return 59 + case .buffer: return 60 + case .byte: return 61 + case .bytecode: return 62 + case .bytecodeReader: return 63 + case .bytes: return 64 + case .bytesInGroup: return 65 + case .bytesNeeded: return 66 + case .bytesRead: return 67 + case .c: return 68 + case .canonical: return 69 + case .capitalizeNext: return 70 + case .cardinality: return 71 + case .caseIterable: return 72 + case .castedValue: return 73 + case .ccEnableArenas: return 74 + case .ccGenericServices: return 75 + case .character: return 76 + case .chars: return 77 + case .checkProgramFormat: return 78 + case .chunk: return 79 + case .class: return 80 + case .clearAggregateValue: return 81 + case .clearAllowAlias: return 82 + case .clearBegin: return 83 + case .clearCcEnableArenas: return 84 + case .clearCcGenericServices: return 85 + case .clearClientStreaming: return 86 + case .clearCsharpNamespace: return 87 + case .clearCtype: return 88 + case .clearDebugRedact: return 89 + case .clearDefaultSymbolVisibility: return 90 + case .clearDefaultValue: return 91 + case .clearDeprecated: return 92 + case .clearDeprecatedLegacyJsonFieldConflicts: return 93 + case .clearDeprecationWarning: return 94 + case .clearDoubleValue: return 95 + case .clearEdition: return 96 + case .clearEditionDeprecated: return 97 + case .clearEditionIntroduced: return 98 + case .clearEditionRemoved: return 99 + case .clearEnd: return 100 + case .clearEnforceNamingStyle: return 101 + case .clearEnumType: return 102 + case .clearExtendee: return 103 + case .clearExtensionValue: return 104 + case .clearFeatures: return 105 + case .clearFeatureSupport: return 106 + case .clearFieldPresence: return 107 + case .clearFixedFeatures: return 108 + case .clearFullName: return 109 + case .clearGoPackage: return 110 + case .clearIdempotencyLevel: return 111 + case .clearIdentifierValue: return 112 + case .clearInputType: return 113 + case .clearIsExtension: return 114 + case .clearJavaGenerateEqualsAndHash: return 115 + case .clearJavaGenericServices: return 116 + case .clearJavaMultipleFiles: return 117 + case .clearJavaOuterClassname: return 118 + case .clearJavaPackage: return 119 + case .clearJavaStringCheckUtf8: return 120 + case .clearJsonFormat: return 121 + case .clearJsonName: return 122 + case .clearJstype: return 123 + case .clearLabel: return 124 + case .clearLazy: return 125 + case .clearLeadingComments: return 126 + case .clearMapEntry: return 127 + case .clearMaximumEdition: return 128 + case .clearMessageEncoding: return 129 + case .clearMessageSetWireFormat: return 130 + case .clearMinimumEdition: return 131 + case .clearName: return 132 + case .clearNamePart: return 133 + case .clearNegativeIntValue: return 134 + case .clearNoStandardDescriptorAccessor: return 135 + case .clearNumber: return 136 + case .clearObjcClassPrefix: return 137 + case .clearOneofIndex: return 138 + case .clearOptimizeFor: return 139 + case .clearOptions: return 140 + case .clearOutputType: return 141 + case .clearOverridableFeatures: return 142 + case .clearPackage: return 143 + case .clearPacked: return 144 + case .clearPhpClassPrefix: return 145 + case .clearPhpMetadataNamespace: return 146 + case .clearPhpNamespace: return 147 + case .clearPositiveIntValue: return 148 + case .clearProto3Optional: return 149 + case .clearPyGenericServices: return 150 + case .clearRemovalError: return 151 + case .clearRepeated: return 152 + case .clearRepeatedFieldEncoding: return 153 + case .clearReserved: return 154 + case .clearRetention: return 155 + case .clearRubyPackage: return 156 + case .clearSemantic: return 157 + case .clearServerStreaming: return 158 + case .clearSourceCodeInfo: return 159 + case .clearSourceContext: return 160 + case .clearSourceFile: return 161 + case .clearStart: return 162 + case .clearStringValue: return 163 + case .clearSwiftPrefix: return 164 + case .clearSyntax: return 165 + case .clearTrailingComments: return 166 + case .clearType: return 167 + case .clearTypeName: return 168 + case .clearUnverifiedLazy: return 169 + case .clearUtf8Validation: return 170 + case .clearValue: return 171 + case .clearVerification: return 172 + case .clearVisibility: return 173 + case .clearWeak: return 174 + case .clientStreaming: return 175 + case .code: return 176 + case .codePoint: return 177 + case .codeUnits: return 178 + case .collection: return 179 + case .comma: return 180 + case .consumedBytes: return 181 + case .contains: return 182 + case .contentsOf: return 183 + case .contiguousBytes: return 184 + case .copy: return 185 + case .count: return 186 + case .countVarintsInBuffer: return 187 + case .csharpNamespace: return 188 + case .ctype: return 189 + case .customCodable: return 190 + case .customDebugStringConvertible: return 191 + case .customStringConvertible: return 192 + case .d: return 193 + case .data: return 194 + case .dataResult: return 195 + case .date: return 196 + case .daySec: return 197 + case .daysSinceEpoch: return 198 + case .debugDescription_: return 199 + case .debugRedact: return 200 + case .declaration: return 201 + case .decoded: return 202 + case .decodedFromJsonnull: return 203 + case .decodeExtensionField: return 204 + case .decodeExtensionFieldsAsMessageSet: return 205 + case .decodeJson: return 206 + case .decodeMapField: return 207 + case .decodeMessage: return 208 + case .decoder: return 209 + case .decodeRepeated: return 210 + case .decodeRepeatedBoolField: return 211 + case .decodeRepeatedBytesField: return 212 + case .decodeRepeatedDoubleField: return 213 + case .decodeRepeatedEnumField: return 214 + case .decodeRepeatedFixed32Field: return 215 + case .decodeRepeatedFixed64Field: return 216 + case .decodeRepeatedFloatField: return 217 + case .decodeRepeatedGroupField: return 218 + case .decodeRepeatedInt32Field: return 219 + case .decodeRepeatedInt64Field: return 220 + case .decodeRepeatedMessageField: return 221 + case .decodeRepeatedSfixed32Field: return 222 + case .decodeRepeatedSfixed64Field: return 223 + case .decodeRepeatedSint32Field: return 224 + case .decodeRepeatedSint64Field: return 225 + case .decodeRepeatedStringField: return 226 + case .decodeRepeatedUint32Field: return 227 + case .decodeRepeatedUint64Field: return 228 + case .decodeSingular: return 229 + case .decodeSingularBoolField: return 230 + case .decodeSingularBytesField: return 231 + case .decodeSingularDoubleField: return 232 + case .decodeSingularEnumField: return 233 + case .decodeSingularFixed32Field: return 234 + case .decodeSingularFixed64Field: return 235 + case .decodeSingularFloatField: return 236 + case .decodeSingularGroupField: return 237 + case .decodeSingularInt32Field: return 238 + case .decodeSingularInt64Field: return 239 + case .decodeSingularMessageField: return 240 + case .decodeSingularSfixed32Field: return 241 + case .decodeSingularSfixed64Field: return 242 + case .decodeSingularSint32Field: return 243 + case .decodeSingularSint64Field: return 244 + case .decodeSingularStringField: return 245 + case .decodeSingularUint32Field: return 246 + case .decodeSingularUint64Field: return 247 + case .decodeTextFormat: return 248 + case .defaultAnyTypeUrlprefix: return 249 + case .defaults: return 250 + case .defaultSymbolVisibility: return 251 + case .defaultValue: return 252 + case .dependency: return 253 + case .deprecated: return 254 + case .deprecatedLegacyJsonFieldConflicts: return 255 + case .deprecationWarning: return 256 + case .description_: return 257 + case .dictionary: return 258 + case .dictionaryLiteral: return 259 + case .digit: return 260 + case .digit0: return 261 + case .digit1: return 262 + case .digitCount: return 263 + case .digits: return 264 + case .digitValue: return 265 + case .discardableResult: return 266 + case .discardUnknownFields: return 267 + case .double: return 268 + case .doubleValue: return 269 + case .duration: return 270 + case .e: return 271 + case .edition: return 272 + case .editionDefault: return 273 + case .editionDefaults: return 274 + case .editionDeprecated: return 275 + case .editionIntroduced: return 276 + case .editionRemoved: return 277 + case .element: return 278 + case .elements: return 279 + case .else: return 280 + case .emitExtensionFieldName: return 281 + case .emitFieldName: return 282 + case .emitFieldNumber: return 283 + case .emptyAnyTypeURL: return 284 + case .emptyData: return 285 + case .encodeAsBytes: return 286 + case .encoded: return 287 + case .encodedJsonstring: return 288 + case .encodedSize: return 289 + case .encodeField: return 290 + case .encoder: return 291 + case .end: return 292 + case .endArray: return 293 + case .endMessageField: return 294 + case .endObject: return 295 + case .endRegularField: return 296 + case .enforceNamingStyle: return 297 + case .enum: return 298 + case .enumReservedRange: return 299 + case .enumType: return 300 + case .enumvalue: return 301 + case .equatable: return 302 + case .error: return 303 + case .execute: return 304 + case .expressibleByArrayLiteral: return 305 + case .expressibleByDictionaryLiteral: return 306 + case .ext: return 307 + case .extDecoder: return 308 + case .extendedGraphemeClusterLiteral: return 309 + case .extendedGraphemeClusterLiteralType: return 310 + case .extendee: return 311 + case .extensibleMessage: return 312 + case .extension: return 313 + case .extensionField: return 314 + case .extensionFieldNumber: return 315 + case .extensionFieldValueSet: return 316 + case .extensionMap: return 317 + case .extensionRange: return 318 + case .extensions: return 319 + case .extras: return 320 + case .f: return 321 + case .false: return 322 + case .features: return 323 + case .featureSetEditionDefault: return 324 + case .featureSupport: return 325 + case .field: return 326 + case .fieldData: return 327 + case .fieldMaskError: return 328 + case .fieldName: return 329 + case .fieldNameCount: return 330 + case .fieldNum: return 331 + case .fieldNumber: return 332 + case .fieldNumberForProto: return 333 + case .fieldPresence: return 334 + case .fields: return 335 + case .fieldSize: return 336 + case .fieldTag: return 337 + case .fieldType: return 338 + case .file: return 339 + case .fileName: return 340 + case .filter: return 341 + case .final: return 342 + case .finiteOnly: return 343 + case .first: return 344 + case .firstItem: return 345 + case .fixedFeatures: return 346 + case .float: return 347 + case .floatLiteral: return 348 + case .floatLiteralType: return 349 + case .for: return 350 + case .forMessageName: return 351 + case .formUnion: return 352 + case .forReadingFrom: return 353 + case .forTypeURL: return 354 + case .forwardParser: return 355 + case .forWritingInto: return 356 + case .from: return 357 + case .fromAscii2: return 358 + case .fromAscii4: return 359 + case .fromByteOffset: return 360 + case .fromHexDigit: return 361 + case .fullName: return 362 + case .func: return 363 + case .function: return 364 + case .g: return 365 + case .get: return 366 + case .getExtensionValue: return 367 + case .googleProtobufAny: return 368 + case .googleProtobufApi: return 369 + case .googleProtobufBoolValue: return 370 + case .googleProtobufBytesValue: return 371 + case .googleProtobufDescriptorProto: return 372 + case .googleProtobufDoubleValue: return 373 + case .googleProtobufDuration: return 374 + case .googleProtobufEdition: return 375 + case .googleProtobufEmpty: return 376 + case .googleProtobufEnum: return 377 + case .googleProtobufEnumDescriptorProto: return 378 + case .googleProtobufEnumOptions: return 379 + case .googleProtobufEnumValue: return 380 + case .googleProtobufEnumValueDescriptorProto: return 381 + case .googleProtobufEnumValueOptions: return 382 + case .googleProtobufExtensionRangeOptions: return 383 + case .googleProtobufFeatureSet: return 384 + case .googleProtobufFeatureSetDefaults: return 385 + case .googleProtobufField: return 386 + case .googleProtobufFieldDescriptorProto: return 387 + case .googleProtobufFieldMask: return 388 + case .googleProtobufFieldOptions: return 389 + case .googleProtobufFileDescriptorProto: return 390 + case .googleProtobufFileDescriptorSet: return 391 + case .googleProtobufFileOptions: return 392 + case .googleProtobufFloatValue: return 393 + case .googleProtobufGeneratedCodeInfo: return 394 + case .googleProtobufInt32Value: return 395 + case .googleProtobufInt64Value: return 396 + case .googleProtobufListValue: return 397 + case .googleProtobufMessageOptions: return 398 + case .googleProtobufMethod: return 399 + case .googleProtobufMethodDescriptorProto: return 400 + case .googleProtobufMethodOptions: return 401 + case .googleProtobufMixin: return 402 + case .googleProtobufNullValue: return 403 + case .googleProtobufOneofDescriptorProto: return 404 + case .googleProtobufOneofOptions: return 405 + case .googleProtobufOption: return 406 + case .googleProtobufServiceDescriptorProto: return 407 + case .googleProtobufServiceOptions: return 408 + case .googleProtobufSourceCodeInfo: return 409 + case .googleProtobufSourceContext: return 410 + case .googleProtobufStringValue: return 411 + case .googleProtobufStruct: return 412 + case .googleProtobufSymbolVisibility: return 413 + case .googleProtobufSyntax: return 414 + case .googleProtobufTimestamp: return 415 + case .googleProtobufType: return 416 + case .googleProtobufUint32Value: return 417 + case .googleProtobufUint64Value: return 418 + case .googleProtobufUninterpretedOption: return 419 + case .googleProtobufValue: return 420 + case .goPackage: return 421 + case .gotData: return 422 + case .group: return 423 + case .groupFieldNumberStack: return 424 + case .groupSize: return 425 + case .guard: return 426 + case .hadOneofValue: return 427 + case .handleConflictingOneOf: return 428 + case .handleInstruction: return 429 + case .hasAggregateValue: return 430 + case .hasAllowAlias: return 431 + case .hasBegin: return 432 + case .hasCcEnableArenas: return 433 + case .hasCcGenericServices: return 434 + case .hasClientStreaming: return 435 + case .hasCsharpNamespace: return 436 + case .hasCtype: return 437 + case .hasData: return 438 + case .hasDebugRedact: return 439 + case .hasDefaultSymbolVisibility: return 440 + case .hasDefaultValue: return 441 + case .hasDeprecated: return 442 + case .hasDeprecatedLegacyJsonFieldConflicts: return 443 + case .hasDeprecationWarning: return 444 + case .hasDoubleValue: return 445 + case .hasEdition: return 446 + case .hasEditionDeprecated: return 447 + case .hasEditionIntroduced: return 448 + case .hasEditionRemoved: return 449 + case .hasEnd: return 450 + case .hasEnforceNamingStyle: return 451 + case .hasEnumType: return 452 + case .hasExplicitDelta: return 453 + case .hasExtendee: return 454 + case .hasExtensionValue: return 455 + case .hasFeatures: return 456 + case .hasFeatureSupport: return 457 + case .hasFieldPresence: return 458 + case .hasFixedFeatures: return 459 + case .hasFullName: return 460 + case .hasGoPackage: return 461 + case .hash: return 462 + case .hashable: return 463 + case .hasher: return 464 + case .hashVisitor: return 465 + case .hasIdempotencyLevel: return 466 + case .hasIdentifierValue: return 467 + case .hasInputType: return 468 + case .hasIsExtension: return 469 + case .hasJavaGenerateEqualsAndHash: return 470 + case .hasJavaGenericServices: return 471 + case .hasJavaMultipleFiles: return 472 + case .hasJavaOuterClassname: return 473 + case .hasJavaPackage: return 474 + case .hasJavaStringCheckUtf8: return 475 + case .hasJsonFormat: return 476 + case .hasJsonName: return 477 + case .hasJstype: return 478 + case .hasLabel: return 479 + case .hasLazy: return 480 + case .hasLeadingComments: return 481 + case .hasMapEntry: return 482 + case .hasMaximumEdition: return 483 + case .hasMessageEncoding: return 484 + case .hasMessageSetWireFormat: return 485 + case .hasMinimumEdition: return 486 + case .hasName: return 487 + case .hasNamePart: return 488 + case .hasNegativeIntValue: return 489 + case .hasNoStandardDescriptorAccessor: return 490 + case .hasNumber: return 491 + case .hasObjcClassPrefix: return 492 + case .hasOneofIndex: return 493 + case .hasOptimizeFor: return 494 + case .hasOptions: return 495 + case .hasOutputType: return 496 + case .hasOverridableFeatures: return 497 + case .hasPackage: return 498 + case .hasPacked: return 499 + default: break + } + switch self { + case .hasPhpClassPrefix: return 500 + case .hasPhpMetadataNamespace: return 501 + case .hasPhpNamespace: return 502 + case .hasPositiveIntValue: return 503 + case .hasProto3Optional: return 504 + case .hasPyGenericServices: return 505 + case .hasRemovalError: return 506 + case .hasRepeated: return 507 + case .hasRepeatedFieldEncoding: return 508 + case .hasReserved: return 509 + case .hasRetention: return 510 + case .hasRubyPackage: return 511 + case .hasSemantic: return 512 + case .hasServerStreaming: return 513 + case .hasSourceCodeInfo: return 514 + case .hasSourceContext: return 515 + case .hasSourceFile: return 516 + case .hasStart: return 517 + case .hasStringValue: return 518 + case .hasSwiftPrefix: return 519 + case .hasSyntax: return 520 + case .hasTrailingComments: return 521 + case .hasType: return 522 + case .hasTypeName: return 523 + case .hasUnverifiedLazy: return 524 + case .hasUtf8Validation: return 525 + case .hasValue: return 526 + case .hasVerification: return 527 + case .hasVisibility: return 528 + case .hasWeak: return 529 + case .hour: return 530 + case .i: return 531 + case .idempotencyLevel: return 532 + case .identifierValue: return 533 + case .if: return 534 + case .ignoreUnknownExtensionFields: return 535 + case .ignoreUnknownFields: return 536 + case .index: return 537 + case .init_: return 538 + case .inout: return 539 + case .inputType: return 540 + case .insert: return 541 + case .instruction: return 542 + case .int: return 543 + case .int32: return 544 + case .int64: return 545 + case .int8: return 546 + case .integerLiteral: return 547 + case .integerLiteralType: return 548 + case .intern: return 549 + case .internal: return 550 + case .internalState: return 551 + case .intersect: return 552 + case .into: return 553 + case .ints: return 554 + case .invalidAnyTypeURL: return 555 + case .isA: return 556 + case .isEqual: return 557 + case .isEqualTo: return 558 + case .isExtension: return 559 + case .isInitialized: return 560 + case .isNegative: return 561 + case .isPathValid: return 562 + case .isReserved: return 563 + case .isValid: return 564 + case .itemTagsEncodedSize: return 565 + case .iterator: return 566 + case .javaGenerateEqualsAndHash: return 567 + case .javaGenericServices: return 568 + case .javaMultipleFiles: return 569 + case .javaOuterClassname: return 570 + case .javaPackage: return 571 + case .javaStringCheckUtf8: return 572 + case .jsondecoder: return 573 + case .jsondecoding: return 574 + case .jsondecodingError: return 575 + case .jsondecodingOptions: return 576 + case .jsonEncoder: return 577 + case .jsonencoding: return 578 + case .jsonencodingError: return 579 + case .jsonencodingOptions: return 580 + case .jsonencodingVisitor: return 581 + case .jsonFormat: return 582 + case .jsonmapEncodingVisitor: return 583 + case .jsonName: return 584 + case .jsonPath: return 585 + case .jsonPaths: return 586 + case .jsonscanner: return 587 + case .jsonString: return 588 + case .jsonText: return 589 + case .jsonUtf8Bytes: return 590 + case .jsonUtf8Data: return 591 + case .jstype: return 592 + case .k: return 593 + case .kChunkSize: return 594 + case .key: return 595 + case .keyField: return 596 + case .keyFieldOpt: return 597 + case .keyType: return 598 + case .kind: return 599 + case .l: return 600 + case .label: return 601 + case .lazy: return 602 + case .leadingComments: return 603 + case .leadingDetachedComments: return 604 + case .length: return 605 + case .lessThan: return 606 + case .let: return 607 + case .lhs: return 608 + case .line: return 609 + case .list: return 610 + case .listOfMessages: return 611 + case .listValue: return 612 + case .littleEndian: return 613 + case .load: return 614 + case .localHasher: return 615 + case .location: return 616 + case .m: return 617 + case .major: return 618 + case .makeAsyncIterator: return 619 + case .makeIterator: return 620 + case .malformedLength: return 621 + case .mapEntry: return 622 + case .mapKeyType: return 623 + case .mapToMessages: return 624 + case .mapValueType: return 625 + case .mapVisitor: return 626 + case .mask: return 627 + case .maximumEdition: return 628 + case .mdayStart: return 629 + case .merge: return 630 + case .mergeOptions: return 631 + case .message: return 632 + case .messageDepthLimit: return 633 + case .messageEncoding: return 634 + case .messageExtension: return 635 + case .messageImplementationBase: return 636 + case .messageSet: return 637 + case .messageSetWireFormat: return 638 + case .messageSize: return 639 + case .messageType: return 640 + case .method: return 641 + case .methods: return 642 + case .min: return 643 + case .minimumEdition: return 644 + case .minor: return 645 + case .mixins: return 646 + case .modify: return 647 + case .month: return 648 + case .msgExtension: return 649 + case .mutating: return 650 + case .n: return 651 + case .name: return 652 + case .nameDescription: return 653 + case .nameMap: return 654 + case .namePart: return 655 + case .names: return 656 + case .nanos: return 657 + case .negativeIntValue: return 658 + case .nestedType: return 659 + case .newExtensible: return 660 + case .newL: return 661 + case .newList: return 662 + case .newMessage: return 663 + case .newValue: return 664 + case .next: return 665 + case .nextByte: return 666 + case .nextFieldNumber: return 667 + case .nextInstruction: return 668 + case .nextInt32: return 669 + case .nextNullTerminatedString: return 670 + case .nextNullTerminatedStringArray: return 671 + case .nextNumber: return 672 + case .nextUint64: return 673 + case .nextVarInt: return 674 + case .nil: return 675 + case .nilLiteral: return 676 + case .noBytesAvailable: return 677 + case .noStandardDescriptorAccessor: return 678 + case .nullValue: return 679 + case .number: return 680 + case .numberValue: return 681 + case .objcClassPrefix: return 682 + case .of: return 683 + case .oneOfKind: return 684 + case .oneofDecl: return 685 + case .oneofIndex: return 686 + case .oneofs: return 687 + case .optimizeFor: return 688 + case .optimizeMode: return 689 + case .optionalEnumExtensionField: return 690 + case .optionalExtensionField: return 691 + case .optionalGroupExtensionField: return 692 + case .optionalMessageExtensionField: return 693 + case .optionDependency: return 694 + case .optionRetention: return 695 + case .options: return 696 + case .optionTargetType: return 697 + case .other: return 698 + case .others: return 699 + case .out: return 700 + case .outputType: return 701 + case .overridableFeatures: return 702 + case .p: return 703 + case .package: return 704 + case .packed: return 705 + case .packedEnumExtensionField: return 706 + case .packedExtensionField: return 707 + case .padding: return 708 + case .parent: return 709 + case .parse: return 710 + case .partial: return 711 + case .path: return 712 + case .pathDecoder: return 713 + case .pathDecodingError: return 714 + case .paths: return 715 + case .pathVisitor: return 716 + case .payload: return 717 + case .payloadSize: return 718 + case .phpClassPrefix: return 719 + case .phpMetadataNamespace: return 720 + case .phpNamespace: return 721 + case .pos: return 722 + case .positiveIntValue: return 723 + case .prefix: return 724 + case .preserveProtoFieldNames: return 725 + case .preTraverse: return 726 + case .previousNumber: return 727 + case .prevPath: return 728 + case .printUnknownFields: return 729 + case .programBuffer: return 730 + case .programFormat: return 731 + case .proto2: return 732 + case .proto3DefaultValue: return 733 + case .proto3Optional: return 734 + case .protobufExtensionFieldValues: return 735 + case .protobufFieldNumber: return 736 + case .protobufGeneratedIsEqualTo: return 737 + case .protobufNameMap: return 738 + case .protobufNewField: return 739 + case .protobufPackage: return 740 + case .protobufApiversion2: return 741 + case .protobufApiversionCheck: return 742 + case .protobufBool: return 743 + case .protobufBytes: return 744 + case .protobufData: return 745 + case .protobufDouble: return 746 + case .protobufEnumMap: return 747 + case .protobufExtension: return 748 + case .protobufFixed32: return 749 + case .protobufFixed64: return 750 + case .protobufFloat: return 751 + case .protobufInt32: return 752 + case .protobufInt64: return 753 + case .protobufMap: return 754 + case .protobufMessageMap: return 755 + case .protobufSfixed32: return 756 + case .protobufSfixed64: return 757 + case .protobufSint32: return 758 + case .protobufSint64: return 759 + case .protobufString: return 760 + case .protobufUint32: return 761 + case .protobufUint64: return 762 + case .protocol: return 763 + case .protoFieldName: return 764 + case .protoMessageName: return 765 + case .protoNameProviding: return 766 + case .protoPaths: return 767 + case .public: return 768 + case .publicDependency: return 769 + case .putBoolValue: return 770 + case .putBytesValue: return 771 + case .putDoubleValue: return 772 + case .putEnumValue: return 773 + case .putFixedUint32: return 774 + case .putFixedUint64: return 775 + case .putFloatValue: return 776 + case .putInt64: return 777 + case .putStringValue: return 778 + case .putUint64: return 779 + case .putUint64Hex: return 780 + case .putVarInt: return 781 + case .putZigZagVarInt: return 782 + case .pyGenericServices: return 783 + case .r: return 784 + case .rawChars: return 785 + case .rawRepresentable: return 786 + case .rawValue_: return 787 + case .read4HexDigits: return 788 + case .readBytes: return 789 + case .reader: return 790 + case .register: return 791 + case .remainingProgram: return 792 + case .removalError: return 793 + case .removingAllFieldsOf: return 794 + case .repeated: return 795 + case .repeatedEnumExtensionField: return 796 + case .repeatedExtensionField: return 797 + case .repeatedFieldEncoding: return 798 + case .repeatedGroupExtensionField: return 799 + case .repeatedMessageExtensionField: return 800 + case .repeating: return 801 + case .replaceRepeatedFields: return 802 + case .requestStreaming: return 803 + case .requestTypeURL: return 804 + case .requiredSize: return 805 + case .responseStreaming: return 806 + case .responseTypeURL: return 807 + case .result: return 808 + case .retention: return 809 + case .rethrows: return 810 + case .returnType: return 811 + case .revision: return 812 + case .rhs: return 813 + case .root: return 814 + case .rubyPackage: return 815 + case .s: return 816 + case .sawBackslash: return 817 + case .sawSection4Characters: return 818 + case .sawSection5Characters: return 819 + case .scalar: return 820 + case .scan: return 821 + case .scanner: return 822 + case .seconds: return 823 + case .self_: return 824 + case .semantic: return 825 + case .sendable: return 826 + case .separator: return 827 + case .serialize: return 828 + case .serializedBytes: return 829 + case .serializedData: return 830 + case .serializedSize: return 831 + case .serverStreaming: return 832 + case .service: return 833 + case .set: return 834 + case .setExtensionValue: return 835 + case .shift: return 836 + case .simpleExtensionMap: return 837 + case .size: return 838 + case .sizer: return 839 + case .source: return 840 + case .sourceCodeInfo: return 841 + case .sourceContext: return 842 + case .sourceEncoding: return 843 + case .sourceFile: return 844 + case .sourceLocation: return 845 + case .span: return 846 + case .split: return 847 + case .start: return 848 + case .startArray: return 849 + case .startArrayObject: return 850 + case .startField: return 851 + case .startIndex: return 852 + case .startMessageField: return 853 + case .startObject: return 854 + case .startRegularField: return 855 + case .state: return 856 + case .static: return 857 + case .staticString: return 858 + case .storage: return 859 + case .string: return 860 + case .stringLiteral: return 861 + case .stringLiteralType: return 862 + case .stringResult: return 863 + case .stringValue: return 864 + case .struct: return 865 + case .structValue: return 866 + case .subDecoder: return 867 + case .subscript: return 868 + case .subtract: return 869 + case .subVisitor: return 870 + case .swift: return 871 + case .swiftPrefix: return 872 + case .swiftProtobufContiguousBytes: return 873 + case .swiftProtobufError: return 874 + case .syntax: return 875 + case .t: return 876 + case .tag: return 877 + case .targets: return 878 + case .terminator: return 879 + case .testDecoder: return 880 + case .text: return 881 + case .textDecoder: return 882 + case .textFormatDecoder: return 883 + case .textFormatDecodingError: return 884 + case .textFormatDecodingOptions: return 885 + case .textFormatEncodingOptions: return 886 + case .textFormatEncodingVisitor: return 887 + case .textFormatString: return 888 + case .throwOrIgnore: return 889 + case .throws: return 890 + case .timeInterval: return 891 + case .timeIntervalSince1970: return 892 + case .timeIntervalSinceReferenceDate: return 893 + case .tmp: return 894 + case .tooLarge: return 895 + case .total: return 896 + case .totalArrayDepth: return 897 + case .totalSize: return 898 + case .trailingComments: return 899 + case .traverse: return 900 + case .trim: return 901 + case .true: return 902 + case .try: return 903 + case .type: return 904 + case .typealias: return 905 + case .typeEnum: return 906 + case .typeName: return 907 + case .typePrefix: return 908 + case .typeStart: return 909 + case .typeUnknown: return 910 + case .typeURL: return 911 + case .uint32: return 912 + case .uint64: return 913 + case .uint8: return 914 + case .unchecked: return 915 + case .unicode: return 916 + case .unicodeScalarLiteral: return 917 + case .unicodeScalarLiteralType: return 918 + case .unicodeScalars: return 919 + case .unicodeScalarView: return 920 + case .uninterpretedOption: return 921 + case .union: return 922 + case .uniqueStorage: return 923 + case .unknown: return 924 + case .unknownFields: return 925 + case .unknownStorage: return 926 + case .unpackTo: return 927 + case .unsafeBufferPointer: return 928 + case .unsafeMutablePointer: return 929 + case .unsafeMutableRawBufferPointer: return 930 + case .unsafeRawBufferPointer: return 931 + case .unsafeRawPointer: return 932 + case .unverifiedLazy: return 933 + case .updatedOptions: return 934 + case .uppercasedAssumingAscii: return 935 + case .url: return 936 + case .useDeterministicOrdering: return 937 + case .utf8: return 938 + case .utf8Ptr: return 939 + case .utf8ToDouble: return 940 + case .utf8Validation: return 941 + case .utf8View: return 942 + case .v: return 943 + case .value: return 944 + case .valueField: return 945 + case .values: return 946 + case .valueType: return 947 + case .var: return 948 + case .verification: return 949 + case .verificationState: return 950 + case .version: return 951 + case .versionString: return 952 + case .visibility: return 953 + case .visibilityFeature: return 954 + case .visitExtensionFields: return 955 + case .visitExtensionFieldsAsMessageSet: return 956 + case .visitMapField: return 957 + case .visitor: return 958 + case .visitPacked: return 959 + case .visitPackedBoolField: return 960 + case .visitPackedDoubleField: return 961 + case .visitPackedEnumField: return 962 + case .visitPackedFixed32Field: return 963 + case .visitPackedFixed64Field: return 964 + case .visitPackedFloatField: return 965 + case .visitPackedInt32Field: return 966 + case .visitPackedInt64Field: return 967 + case .visitPackedSfixed32Field: return 968 + case .visitPackedSfixed64Field: return 969 + case .visitPackedSint32Field: return 970 + case .visitPackedSint64Field: return 971 + case .visitPackedUint32Field: return 972 + case .visitPackedUint64Field: return 973 + case .visitRepeated: return 974 + case .visitRepeatedBoolField: return 975 + case .visitRepeatedBytesField: return 976 + case .visitRepeatedDoubleField: return 977 + case .visitRepeatedEnumField: return 978 + case .visitRepeatedFixed32Field: return 979 + case .visitRepeatedFixed64Field: return 980 + case .visitRepeatedFloatField: return 981 + case .visitRepeatedGroupField: return 982 + case .visitRepeatedInt32Field: return 983 + case .visitRepeatedInt64Field: return 984 + case .visitRepeatedMessageField: return 985 + case .visitRepeatedSfixed32Field: return 986 + case .visitRepeatedSfixed64Field: return 987 + case .visitRepeatedSint32Field: return 988 + case .visitRepeatedSint64Field: return 989 + case .visitRepeatedStringField: return 990 + case .visitRepeatedUint32Field: return 991 + case .visitRepeatedUint64Field: return 992 + case .visitSingular: return 993 + case .visitSingularBoolField: return 994 + case .visitSingularBytesField: return 995 + case .visitSingularDoubleField: return 996 + case .visitSingularEnumField: return 997 + case .visitSingularFixed32Field: return 998 + case .visitSingularFixed64Field: return 999 + default: break + } + switch self { + case .visitSingularFloatField: return 1000 + case .visitSingularGroupField: return 1001 + case .visitSingularInt32Field: return 1002 + case .visitSingularInt64Field: return 1003 + case .visitSingularMessageField: return 1004 + case .visitSingularSfixed32Field: return 1005 + case .visitSingularSfixed64Field: return 1006 + case .visitSingularSint32Field: return 1007 + case .visitSingularSint64Field: return 1008 + case .visitSingularStringField: return 1009 + case .visitSingularUint32Field: return 1010 + case .visitSingularUint64Field: return 1011 + case .visitUnknown: return 1012 + case .void: return 1013 + case .wasDecoded: return 1014 + case .weak: return 1015 + case .weakDependency: return 1016 + case .where: return 1017 + case .wireFormat: return 1018 + case .with: return 1019 + case .withUnsafeBytes: return 1020 + case .withUnsafeMutableBytes: return 1021 + case .work: return 1022 + case .wrapped: return 1023 + case .wrappedType: return 1024 + case .wrappedValue: return 1025 + case .written: return 1026 + case .yday: return 1027 + case .UNRECOGNIZED(let i): return i + default: break + } + + // Can't get here, all the cases are listed in the above switches. + // See https://github.com/apple/swift-protobuf/issues/904 for more details. + fatalError() + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum] = [ + .none, + .addPath, + .adjusted, + .aggregateValue, + .allCases_, + .allowAlias, + .alwaysPrintEnumsAsInts, + .alwaysPrintInt64SAsNumbers, + .annotation, + .any, + .anyExtensionField, + .anyMessageExtension, + .anyMessageStorage, + .anyUnpackError, + .append, + .appended, + .appendUintHex, + .appendUnknown, + .areAllInitialized, + .array, + .arrayDepth, + .arrayLiteral, + .arraySeparator, + .as, + .asciiOpenCurlyBracket, + .asciiZero, + .async, + .asyncIterator, + .asyncIteratorProtocol, + .asyncMessageSequence, + .available, + .b, + .base, + .base64Values, + .baseAddress, + .baseType, + .begin, + .binary, + .binaryDecoder, + .binaryDecoding, + .binaryDecodingError, + .binaryDecodingOptions, + .binaryDelimited, + .binaryEncoder, + .binaryEncodingError, + .binaryEncodingMessageSetSizeVisitor, + .binaryEncodingMessageSetVisitor, + .binaryEncodingOptions, + .binaryEncodingSizeVisitor, + .binaryEncodingVisitor, + .binaryOptions, + .binaryProtobufDelimitedMessages, + .binaryStreamDecoding, + .binaryStreamDecodingError, + .bitPattern, + .body, + .bool, + .booleanLiteral, + .booleanLiteralType, + .boolValue, + .buffer, + .byte, + .bytecode, + .bytecodeReader, + .bytes, + .bytesInGroup, + .bytesNeeded, + .bytesRead, + .c, + .canonical, + .capitalizeNext, + .cardinality, + .caseIterable, + .castedValue, + .ccEnableArenas, + .ccGenericServices, + .character, + .chars, + .checkProgramFormat, + .chunk, + .class, + .clearAggregateValue, + .clearAllowAlias, + .clearBegin, + .clearCcEnableArenas, + .clearCcGenericServices, + .clearClientStreaming, + .clearCsharpNamespace, + .clearCtype, + .clearDebugRedact, + .clearDefaultSymbolVisibility, + .clearDefaultValue, + .clearDeprecated, + .clearDeprecatedLegacyJsonFieldConflicts, + .clearDeprecationWarning, + .clearDoubleValue, + .clearEdition, + .clearEditionDeprecated, + .clearEditionIntroduced, + .clearEditionRemoved, + .clearEnd, + .clearEnforceNamingStyle, + .clearEnumType, + .clearExtendee, + .clearExtensionValue, + .clearFeatures, + .clearFeatureSupport, + .clearFieldPresence, + .clearFixedFeatures, + .clearFullName, + .clearGoPackage, + .clearIdempotencyLevel, + .clearIdentifierValue, + .clearInputType, + .clearIsExtension, + .clearJavaGenerateEqualsAndHash, + .clearJavaGenericServices, + .clearJavaMultipleFiles, + .clearJavaOuterClassname, + .clearJavaPackage, + .clearJavaStringCheckUtf8, + .clearJsonFormat, + .clearJsonName, + .clearJstype, + .clearLabel, + .clearLazy, + .clearLeadingComments, + .clearMapEntry, + .clearMaximumEdition, + .clearMessageEncoding, + .clearMessageSetWireFormat, + .clearMinimumEdition, + .clearName, + .clearNamePart, + .clearNegativeIntValue, + .clearNoStandardDescriptorAccessor, + .clearNumber, + .clearObjcClassPrefix, + .clearOneofIndex, + .clearOptimizeFor, + .clearOptions, + .clearOutputType, + .clearOverridableFeatures, + .clearPackage, + .clearPacked, + .clearPhpClassPrefix, + .clearPhpMetadataNamespace, + .clearPhpNamespace, + .clearPositiveIntValue, + .clearProto3Optional, + .clearPyGenericServices, + .clearRemovalError, + .clearRepeated, + .clearRepeatedFieldEncoding, + .clearReserved, + .clearRetention, + .clearRubyPackage, + .clearSemantic, + .clearServerStreaming, + .clearSourceCodeInfo, + .clearSourceContext, + .clearSourceFile, + .clearStart, + .clearStringValue, + .clearSwiftPrefix, + .clearSyntax, + .clearTrailingComments, + .clearType, + .clearTypeName, + .clearUnverifiedLazy, + .clearUtf8Validation, + .clearValue, + .clearVerification, + .clearVisibility, + .clearWeak, + .clientStreaming, + .code, + .codePoint, + .codeUnits, + .collection, + .comma, + .consumedBytes, + .contains, + .contentsOf, + .contiguousBytes, + .copy, + .count, + .countVarintsInBuffer, + .csharpNamespace, + .ctype, + .customCodable, + .customDebugStringConvertible, + .customStringConvertible, + .d, + .data, + .dataResult, + .date, + .daySec, + .daysSinceEpoch, + .debugDescription_, + .debugRedact, + .declaration, + .decoded, + .decodedFromJsonnull, + .decodeExtensionField, + .decodeExtensionFieldsAsMessageSet, + .decodeJson, + .decodeMapField, + .decodeMessage, + .decoder, + .decodeRepeated, + .decodeRepeatedBoolField, + .decodeRepeatedBytesField, + .decodeRepeatedDoubleField, + .decodeRepeatedEnumField, + .decodeRepeatedFixed32Field, + .decodeRepeatedFixed64Field, + .decodeRepeatedFloatField, + .decodeRepeatedGroupField, + .decodeRepeatedInt32Field, + .decodeRepeatedInt64Field, + .decodeRepeatedMessageField, + .decodeRepeatedSfixed32Field, + .decodeRepeatedSfixed64Field, + .decodeRepeatedSint32Field, + .decodeRepeatedSint64Field, + .decodeRepeatedStringField, + .decodeRepeatedUint32Field, + .decodeRepeatedUint64Field, + .decodeSingular, + .decodeSingularBoolField, + .decodeSingularBytesField, + .decodeSingularDoubleField, + .decodeSingularEnumField, + .decodeSingularFixed32Field, + .decodeSingularFixed64Field, + .decodeSingularFloatField, + .decodeSingularGroupField, + .decodeSingularInt32Field, + .decodeSingularInt64Field, + .decodeSingularMessageField, + .decodeSingularSfixed32Field, + .decodeSingularSfixed64Field, + .decodeSingularSint32Field, + .decodeSingularSint64Field, + .decodeSingularStringField, + .decodeSingularUint32Field, + .decodeSingularUint64Field, + .decodeTextFormat, + .defaultAnyTypeUrlprefix, + .defaults, + .defaultSymbolVisibility, + .defaultValue, + .dependency, + .deprecated, + .deprecatedLegacyJsonFieldConflicts, + .deprecationWarning, + .description_, + .dictionary, + .dictionaryLiteral, + .digit, + .digit0, + .digit1, + .digitCount, + .digits, + .digitValue, + .discardableResult, + .discardUnknownFields, + .double, + .doubleValue, + .duration, + .e, + .edition, + .editionDefault, + .editionDefaults, + .editionDeprecated, + .editionIntroduced, + .editionRemoved, + .element, + .elements, + .else, + .emitExtensionFieldName, + .emitFieldName, + .emitFieldNumber, + .emptyAnyTypeURL, + .emptyData, + .encodeAsBytes, + .encoded, + .encodedJsonstring, + .encodedSize, + .encodeField, + .encoder, + .end, + .endArray, + .endMessageField, + .endObject, + .endRegularField, + .enforceNamingStyle, + .enum, + .enumReservedRange, + .enumType, + .enumvalue, + .equatable, + .error, + .execute, + .expressibleByArrayLiteral, + .expressibleByDictionaryLiteral, + .ext, + .extDecoder, + .extendedGraphemeClusterLiteral, + .extendedGraphemeClusterLiteralType, + .extendee, + .extensibleMessage, + .extension, + .extensionField, + .extensionFieldNumber, + .extensionFieldValueSet, + .extensionMap, + .extensionRange, + .extensions, + .extras, + .f, + .false, + .features, + .featureSetEditionDefault, + .featureSupport, + .field, + .fieldData, + .fieldMaskError, + .fieldName, + .fieldNameCount, + .fieldNum, + .fieldNumber, + .fieldNumberForProto, + .fieldPresence, + .fields, + .fieldSize, + .fieldTag, + .fieldType, + .file, + .fileName, + .filter, + .final, + .finiteOnly, + .first, + .firstItem, + .fixedFeatures, + .float, + .floatLiteral, + .floatLiteralType, + .for, + .forMessageName, + .formUnion, + .forReadingFrom, + .forTypeURL, + .forwardParser, + .forWritingInto, + .from, + .fromAscii2, + .fromAscii4, + .fromByteOffset, + .fromHexDigit, + .fullName, + .func, + .function, + .g, + .get, + .getExtensionValue, + .googleProtobufAny, + .googleProtobufApi, + .googleProtobufBoolValue, + .googleProtobufBytesValue, + .googleProtobufDescriptorProto, + .googleProtobufDoubleValue, + .googleProtobufDuration, + .googleProtobufEdition, + .googleProtobufEmpty, + .googleProtobufEnum, + .googleProtobufEnumDescriptorProto, + .googleProtobufEnumOptions, + .googleProtobufEnumValue, + .googleProtobufEnumValueDescriptorProto, + .googleProtobufEnumValueOptions, + .googleProtobufExtensionRangeOptions, + .googleProtobufFeatureSet, + .googleProtobufFeatureSetDefaults, + .googleProtobufField, + .googleProtobufFieldDescriptorProto, + .googleProtobufFieldMask, + .googleProtobufFieldOptions, + .googleProtobufFileDescriptorProto, + .googleProtobufFileDescriptorSet, + .googleProtobufFileOptions, + .googleProtobufFloatValue, + .googleProtobufGeneratedCodeInfo, + .googleProtobufInt32Value, + .googleProtobufInt64Value, + .googleProtobufListValue, + .googleProtobufMessageOptions, + .googleProtobufMethod, + .googleProtobufMethodDescriptorProto, + .googleProtobufMethodOptions, + .googleProtobufMixin, + .googleProtobufNullValue, + .googleProtobufOneofDescriptorProto, + .googleProtobufOneofOptions, + .googleProtobufOption, + .googleProtobufServiceDescriptorProto, + .googleProtobufServiceOptions, + .googleProtobufSourceCodeInfo, + .googleProtobufSourceContext, + .googleProtobufStringValue, + .googleProtobufStruct, + .googleProtobufSymbolVisibility, + .googleProtobufSyntax, + .googleProtobufTimestamp, + .googleProtobufType, + .googleProtobufUint32Value, + .googleProtobufUint64Value, + .googleProtobufUninterpretedOption, + .googleProtobufValue, + .goPackage, + .gotData, + .group, + .groupFieldNumberStack, + .groupSize, + .guard, + .hadOneofValue, + .handleConflictingOneOf, + .handleInstruction, + .hasAggregateValue, + .hasAllowAlias, + .hasBegin, + .hasCcEnableArenas, + .hasCcGenericServices, + .hasClientStreaming, + .hasCsharpNamespace, + .hasCtype, + .hasData, + .hasDebugRedact, + .hasDefaultSymbolVisibility, + .hasDefaultValue, + .hasDeprecated, + .hasDeprecatedLegacyJsonFieldConflicts, + .hasDeprecationWarning, + .hasDoubleValue, + .hasEdition, + .hasEditionDeprecated, + .hasEditionIntroduced, + .hasEditionRemoved, + .hasEnd, + .hasEnforceNamingStyle, + .hasEnumType, + .hasExplicitDelta, + .hasExtendee, + .hasExtensionValue, + .hasFeatures, + .hasFeatureSupport, + .hasFieldPresence, + .hasFixedFeatures, + .hasFullName, + .hasGoPackage, + .hash, + .hashable, + .hasher, + .hashVisitor, + .hasIdempotencyLevel, + .hasIdentifierValue, + .hasInputType, + .hasIsExtension, + .hasJavaGenerateEqualsAndHash, + .hasJavaGenericServices, + .hasJavaMultipleFiles, + .hasJavaOuterClassname, + .hasJavaPackage, + .hasJavaStringCheckUtf8, + .hasJsonFormat, + .hasJsonName, + .hasJstype, + .hasLabel, + .hasLazy, + .hasLeadingComments, + .hasMapEntry, + .hasMaximumEdition, + .hasMessageEncoding, + .hasMessageSetWireFormat, + .hasMinimumEdition, + .hasName, + .hasNamePart, + .hasNegativeIntValue, + .hasNoStandardDescriptorAccessor, + .hasNumber, + .hasObjcClassPrefix, + .hasOneofIndex, + .hasOptimizeFor, + .hasOptions, + .hasOutputType, + .hasOverridableFeatures, + .hasPackage, + .hasPacked, + .hasPhpClassPrefix, + .hasPhpMetadataNamespace, + .hasPhpNamespace, + .hasPositiveIntValue, + .hasProto3Optional, + .hasPyGenericServices, + .hasRemovalError, + .hasRepeated, + .hasRepeatedFieldEncoding, + .hasReserved, + .hasRetention, + .hasRubyPackage, + .hasSemantic, + .hasServerStreaming, + .hasSourceCodeInfo, + .hasSourceContext, + .hasSourceFile, + .hasStart, + .hasStringValue, + .hasSwiftPrefix, + .hasSyntax, + .hasTrailingComments, + .hasType, + .hasTypeName, + .hasUnverifiedLazy, + .hasUtf8Validation, + .hasValue, + .hasVerification, + .hasVisibility, + .hasWeak, + .hour, + .i, + .idempotencyLevel, + .identifierValue, + .if, + .ignoreUnknownExtensionFields, + .ignoreUnknownFields, + .index, + .init_, + .inout, + .inputType, + .insert, + .instruction, + .int, + .int32, + .int64, + .int8, + .integerLiteral, + .integerLiteralType, + .intern, + .internal, + .internalState, + .intersect, + .into, + .ints, + .invalidAnyTypeURL, + .isA, + .isEqual, + .isEqualTo, + .isExtension, + .isInitialized, + .isNegative, + .isPathValid, + .isReserved, + .isValid, + .itemTagsEncodedSize, + .iterator, + .javaGenerateEqualsAndHash, + .javaGenericServices, + .javaMultipleFiles, + .javaOuterClassname, + .javaPackage, + .javaStringCheckUtf8, + .jsondecoder, + .jsondecoding, + .jsondecodingError, + .jsondecodingOptions, + .jsonEncoder, + .jsonencoding, + .jsonencodingError, + .jsonencodingOptions, + .jsonencodingVisitor, + .jsonFormat, + .jsonmapEncodingVisitor, + .jsonName, + .jsonPath, + .jsonPaths, + .jsonscanner, + .jsonString, + .jsonText, + .jsonUtf8Bytes, + .jsonUtf8Data, + .jstype, + .k, + .kChunkSize, + .key, + .keyField, + .keyFieldOpt, + .keyType, + .kind, + .l, + .label, + .lazy, + .leadingComments, + .leadingDetachedComments, + .length, + .lessThan, + .let, + .lhs, + .line, + .list, + .listOfMessages, + .listValue, + .littleEndian, + .load, + .localHasher, + .location, + .m, + .major, + .makeAsyncIterator, + .makeIterator, + .malformedLength, + .mapEntry, + .mapKeyType, + .mapToMessages, + .mapValueType, + .mapVisitor, + .mask, + .maximumEdition, + .mdayStart, + .merge, + .mergeOptions, + .message, + .messageDepthLimit, + .messageEncoding, + .messageExtension, + .messageImplementationBase, + .messageSet, + .messageSetWireFormat, + .messageSize, + .messageType, + .method, + .methods, + .min, + .minimumEdition, + .minor, + .mixins, + .modify, + .month, + .msgExtension, + .mutating, + .n, + .name, + .nameDescription, + .nameMap, + .namePart, + .names, + .nanos, + .negativeIntValue, + .nestedType, + .newExtensible, + .newL, + .newList, + .newMessage, + .newValue, + .next, + .nextByte, + .nextFieldNumber, + .nextInstruction, + .nextInt32, + .nextNullTerminatedString, + .nextNullTerminatedStringArray, + .nextNumber, + .nextUint64, + .nextVarInt, + .nil, + .nilLiteral, + .noBytesAvailable, + .noStandardDescriptorAccessor, + .nullValue, + .number, + .numberValue, + .objcClassPrefix, + .of, + .oneOfKind, + .oneofDecl, + .oneofIndex, + .oneofs, + .optimizeFor, + .optimizeMode, + .optionalEnumExtensionField, + .optionalExtensionField, + .optionalGroupExtensionField, + .optionalMessageExtensionField, + .optionDependency, + .optionRetention, + .options, + .optionTargetType, + .other, + .others, + .out, + .outputType, + .overridableFeatures, + .p, + .package, + .packed, + .packedEnumExtensionField, + .packedExtensionField, + .padding, + .parent, + .parse, + .partial, + .path, + .pathDecoder, + .pathDecodingError, + .paths, + .pathVisitor, + .payload, + .payloadSize, + .phpClassPrefix, + .phpMetadataNamespace, + .phpNamespace, + .pos, + .positiveIntValue, + .prefix, + .preserveProtoFieldNames, + .preTraverse, + .previousNumber, + .prevPath, + .printUnknownFields, + .programBuffer, + .programFormat, + .proto2, + .proto3DefaultValue, + .proto3Optional, + .protobufExtensionFieldValues, + .protobufFieldNumber, + .protobufGeneratedIsEqualTo, + .protobufNameMap, + .protobufNewField, + .protobufPackage, + .protobufApiversion2, + .protobufApiversionCheck, + .protobufBool, + .protobufBytes, + .protobufData, + .protobufDouble, + .protobufEnumMap, + .protobufExtension, + .protobufFixed32, + .protobufFixed64, + .protobufFloat, + .protobufInt32, + .protobufInt64, + .protobufMap, + .protobufMessageMap, + .protobufSfixed32, + .protobufSfixed64, + .protobufSint32, + .protobufSint64, + .protobufString, + .protobufUint32, + .protobufUint64, + .protocol, + .protoFieldName, + .protoMessageName, + .protoNameProviding, + .protoPaths, + .public, + .publicDependency, + .putBoolValue, + .putBytesValue, + .putDoubleValue, + .putEnumValue, + .putFixedUint32, + .putFixedUint64, + .putFloatValue, + .putInt64, + .putStringValue, + .putUint64, + .putUint64Hex, + .putVarInt, + .putZigZagVarInt, + .pyGenericServices, + .r, + .rawChars, + .rawRepresentable, + .rawValue_, + .read4HexDigits, + .readBytes, + .reader, + .register, + .remainingProgram, + .removalError, + .removingAllFieldsOf, + .repeated, + .repeatedEnumExtensionField, + .repeatedExtensionField, + .repeatedFieldEncoding, + .repeatedGroupExtensionField, + .repeatedMessageExtensionField, + .repeating, + .replaceRepeatedFields, + .requestStreaming, + .requestTypeURL, + .requiredSize, + .responseStreaming, + .responseTypeURL, + .result, + .retention, + .rethrows, + .returnType, + .revision, + .rhs, + .root, + .rubyPackage, + .s, + .sawBackslash, + .sawSection4Characters, + .sawSection5Characters, + .scalar, + .scan, + .scanner, + .seconds, + .self_, + .semantic, + .sendable, + .separator, + .serialize, + .serializedBytes, + .serializedData, + .serializedSize, + .serverStreaming, + .service, + .set, + .setExtensionValue, + .shift, + .simpleExtensionMap, + .size, + .sizer, + .source, + .sourceCodeInfo, + .sourceContext, + .sourceEncoding, + .sourceFile, + .sourceLocation, + .span, + .split, + .start, + .startArray, + .startArrayObject, + .startField, + .startIndex, + .startMessageField, + .startObject, + .startRegularField, + .state, + .static, + .staticString, + .storage, + .string, + .stringLiteral, + .stringLiteralType, + .stringResult, + .stringValue, + .struct, + .structValue, + .subDecoder, + .subscript, + .subtract, + .subVisitor, + .swift, + .swiftPrefix, + .swiftProtobufContiguousBytes, + .swiftProtobufError, + .syntax, + .t, + .tag, + .targets, + .terminator, + .testDecoder, + .text, + .textDecoder, + .textFormatDecoder, + .textFormatDecodingError, + .textFormatDecodingOptions, + .textFormatEncodingOptions, + .textFormatEncodingVisitor, + .textFormatString, + .throwOrIgnore, + .throws, + .timeInterval, + .timeIntervalSince1970, + .timeIntervalSinceReferenceDate, + .tmp, + .tooLarge, + .total, + .totalArrayDepth, + .totalSize, + .trailingComments, + .traverse, + .trim, + .true, + .try, + .type, + .typealias, + .typeEnum, + .typeName, + .typePrefix, + .typeStart, + .typeUnknown, + .typeURL, + .uint32, + .uint64, + .uint8, + .unchecked, + .unicode, + .unicodeScalarLiteral, + .unicodeScalarLiteralType, + .unicodeScalars, + .unicodeScalarView, + .uninterpretedOption, + .union, + .uniqueStorage, + .unknown, + .unknownFields, + .unknownStorage, + .unpackTo, + .unsafeBufferPointer, + .unsafeMutablePointer, + .unsafeMutableRawBufferPointer, + .unsafeRawBufferPointer, + .unsafeRawPointer, + .unverifiedLazy, + .updatedOptions, + .uppercasedAssumingAscii, + .url, + .useDeterministicOrdering, + .utf8, + .utf8Ptr, + .utf8ToDouble, + .utf8Validation, + .utf8View, + .v, + .value, + .valueField, + .values, + .valueType, + .var, + .verification, + .verificationState, + .version, + .versionString, + .visibility, + .visibilityFeature, + .visitExtensionFields, + .visitExtensionFieldsAsMessageSet, + .visitMapField, + .visitor, + .visitPacked, + .visitPackedBoolField, + .visitPackedDoubleField, + .visitPackedEnumField, + .visitPackedFixed32Field, + .visitPackedFixed64Field, + .visitPackedFloatField, + .visitPackedInt32Field, + .visitPackedInt64Field, + .visitPackedSfixed32Field, + .visitPackedSfixed64Field, + .visitPackedSint32Field, + .visitPackedSint64Field, + .visitPackedUint32Field, + .visitPackedUint64Field, + .visitRepeated, + .visitRepeatedBoolField, + .visitRepeatedBytesField, + .visitRepeatedDoubleField, + .visitRepeatedEnumField, + .visitRepeatedFixed32Field, + .visitRepeatedFixed64Field, + .visitRepeatedFloatField, + .visitRepeatedGroupField, + .visitRepeatedInt32Field, + .visitRepeatedInt64Field, + .visitRepeatedMessageField, + .visitRepeatedSfixed32Field, + .visitRepeatedSfixed64Field, + .visitRepeatedSint32Field, + .visitRepeatedSint64Field, + .visitRepeatedStringField, + .visitRepeatedUint32Field, + .visitRepeatedUint64Field, + .visitSingular, + .visitSingularBoolField, + .visitSingularBytesField, + .visitSingularDoubleField, + .visitSingularEnumField, + .visitSingularFixed32Field, + .visitSingularFixed64Field, + .visitSingularFloatField, + .visitSingularGroupField, + .visitSingularInt32Field, + .visitSingularInt64Field, + .visitSingularMessageField, + .visitSingularSfixed32Field, + .visitSingularSfixed64Field, + .visitSingularSint32Field, + .visitSingularSint64Field, + .visitSingularStringField, + .visitSingularUint32Field, + .visitSingularUint64Field, + .visitUnknown, + .void, + .wasDecoded, + .weak, + .weakDependency, + .where, + .wireFormat, + .with, + .withUnsafeBytes, + .withUnsafeMutableBytes, + .work, + .wrapped, + .wrappedType, + .wrappedValue, + .written, + .yday, + ] + +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE\0\u{1}addPath\0\u{1}adjusted\0\u{1}aggregateValue\0\u{1}allCases\0\u{1}allowAlias\0\u{1}alwaysPrintEnumsAsInts\0\u{1}alwaysPrintInt64sAsNumbers\0\u{1}annotation\0\u{1}any\0\u{1}AnyExtensionField\0\u{1}AnyMessageExtension\0\u{1}AnyMessageStorage\0\u{1}AnyUnpackError\0\u{1}append\0\u{1}appended\0\u{1}appendUIntHex\0\u{1}appendUnknown\0\u{1}areAllInitialized\0\u{1}Array\0\u{1}arrayDepth\0\u{1}arrayLiteral\0\u{1}arraySeparator\0\u{1}as\0\u{1}asciiOpenCurlyBracket\0\u{1}asciiZero\0\u{1}async\0\u{1}AsyncIterator\0\u{1}AsyncIteratorProtocol\0\u{1}AsyncMessageSequence\0\u{1}available\0\u{1}b\0\u{1}Base\0\u{1}base64Values\0\u{1}baseAddress\0\u{1}BaseType\0\u{1}begin\0\u{1}binary\0\u{1}BinaryDecoder\0\u{1}BinaryDecoding\0\u{1}BinaryDecodingError\0\u{1}BinaryDecodingOptions\0\u{1}BinaryDelimited\0\u{1}BinaryEncoder\0\u{1}BinaryEncodingError\0\u{1}BinaryEncodingMessageSetSizeVisitor\0\u{1}BinaryEncodingMessageSetVisitor\0\u{1}BinaryEncodingOptions\0\u{1}BinaryEncodingSizeVisitor\0\u{1}BinaryEncodingVisitor\0\u{1}binaryOptions\0\u{1}binaryProtobufDelimitedMessages\0\u{1}BinaryStreamDecoding\0\u{1}binaryStreamDecodingError\0\u{1}bitPattern\0\u{1}body\0\u{1}Bool\0\u{1}booleanLiteral\0\u{1}BooleanLiteralType\0\u{1}boolValue\0\u{1}buffer\0\u{1}byte\0\u{1}bytecode\0\u{1}BytecodeReader\0\u{1}bytes\0\u{1}bytesInGroup\0\u{1}bytesNeeded\0\u{1}bytesRead\0\u{1}c\0\u{1}canonical\0\u{1}capitalizeNext\0\u{1}cardinality\0\u{1}CaseIterable\0\u{1}castedValue\0\u{1}ccEnableArenas\0\u{1}ccGenericServices\0\u{1}Character\0\u{1}chars\0\u{1}checkProgramFormat\0\u{1}chunk\0\u{1}class\0\u{1}clearAggregateValue\0\u{1}clearAllowAlias\0\u{1}clearBegin\0\u{1}clearCcEnableArenas\0\u{1}clearCcGenericServices\0\u{1}clearClientStreaming\0\u{1}clearCsharpNamespace\0\u{1}clearCtype\0\u{1}clearDebugRedact\0\u{1}clearDefaultSymbolVisibility\0\u{1}clearDefaultValue\0\u{1}clearDeprecated\0\u{1}clearDeprecatedLegacyJsonFieldConflicts\0\u{1}clearDeprecationWarning\0\u{1}clearDoubleValue\0\u{1}clearEdition\0\u{1}clearEditionDeprecated\0\u{1}clearEditionIntroduced\0\u{1}clearEditionRemoved\0\u{1}clearEnd\0\u{1}clearEnforceNamingStyle\0\u{1}clearEnumType\0\u{1}clearExtendee\0\u{1}clearExtensionValue\0\u{1}clearFeatures\0\u{1}clearFeatureSupport\0\u{1}clearFieldPresence\0\u{1}clearFixedFeatures\0\u{1}clearFullName\0\u{1}clearGoPackage\0\u{1}clearIdempotencyLevel\0\u{1}clearIdentifierValue\0\u{1}clearInputType\0\u{1}clearIsExtension\0\u{1}clearJavaGenerateEqualsAndHash\0\u{1}clearJavaGenericServices\0\u{1}clearJavaMultipleFiles\0\u{1}clearJavaOuterClassname\0\u{1}clearJavaPackage\0\u{1}clearJavaStringCheckUtf8\0\u{1}clearJsonFormat\0\u{1}clearJsonName\0\u{1}clearJstype\0\u{1}clearLabel\0\u{1}clearLazy\0\u{1}clearLeadingComments\0\u{1}clearMapEntry\0\u{1}clearMaximumEdition\0\u{1}clearMessageEncoding\0\u{1}clearMessageSetWireFormat\0\u{1}clearMinimumEdition\0\u{1}clearName\0\u{1}clearNamePart\0\u{1}clearNegativeIntValue\0\u{1}clearNoStandardDescriptorAccessor\0\u{1}clearNumber\0\u{1}clearObjcClassPrefix\0\u{1}clearOneofIndex\0\u{1}clearOptimizeFor\0\u{1}clearOptions\0\u{1}clearOutputType\0\u{1}clearOverridableFeatures\0\u{1}clearPackage\0\u{1}clearPacked\0\u{1}clearPhpClassPrefix\0\u{1}clearPhpMetadataNamespace\0\u{1}clearPhpNamespace\0\u{1}clearPositiveIntValue\0\u{1}clearProto3Optional\0\u{1}clearPyGenericServices\0\u{1}clearRemovalError\0\u{1}clearRepeated\0\u{1}clearRepeatedFieldEncoding\0\u{1}clearReserved\0\u{1}clearRetention\0\u{1}clearRubyPackage\0\u{1}clearSemantic\0\u{1}clearServerStreaming\0\u{1}clearSourceCodeInfo\0\u{1}clearSourceContext\0\u{1}clearSourceFile\0\u{1}clearStart\0\u{1}clearStringValue\0\u{1}clearSwiftPrefix\0\u{1}clearSyntax\0\u{1}clearTrailingComments\0\u{1}clearType\0\u{1}clearTypeName\0\u{1}clearUnverifiedLazy\0\u{1}clearUtf8Validation\0\u{1}clearValue\0\u{1}clearVerification\0\u{1}clearVisibility\0\u{1}clearWeak\0\u{1}clientStreaming\0\u{1}code\0\u{1}codePoint\0\u{1}codeUnits\0\u{1}Collection\0\u{1}comma\0\u{1}consumedBytes\0\u{1}contains\0\u{1}contentsOf\0\u{1}ContiguousBytes\0\u{1}copy\0\u{1}count\0\u{1}countVarintsInBuffer\0\u{1}csharpNamespace\0\u{1}ctype\0\u{1}customCodable\0\u{1}CustomDebugStringConvertible\0\u{1}CustomStringConvertible\0\u{1}D\0\u{1}Data\0\u{1}dataResult\0\u{1}date\0\u{1}daySec\0\u{1}daysSinceEpoch\0\u{1}debugDescription\0\u{1}debugRedact\0\u{1}declaration\0\u{1}decoded\0\u{1}decodedFromJSONNull\0\u{1}decodeExtensionField\0\u{1}decodeExtensionFieldsAsMessageSet\0\u{1}decodeJSON\0\u{1}decodeMapField\0\u{1}decodeMessage\0\u{1}Decoder\0\u{1}decodeRepeated\0\u{1}decodeRepeatedBoolField\0\u{1}decodeRepeatedBytesField\0\u{1}decodeRepeatedDoubleField\0\u{1}decodeRepeatedEnumField\0\u{1}decodeRepeatedFixed32Field\0\u{1}decodeRepeatedFixed64Field\0\u{1}decodeRepeatedFloatField\0\u{1}decodeRepeatedGroupField\0\u{1}decodeRepeatedInt32Field\0\u{1}decodeRepeatedInt64Field\0\u{1}decodeRepeatedMessageField\0\u{1}decodeRepeatedSFixed32Field\0\u{1}decodeRepeatedSFixed64Field\0\u{1}decodeRepeatedSInt32Field\0\u{1}decodeRepeatedSInt64Field\0\u{1}decodeRepeatedStringField\0\u{1}decodeRepeatedUInt32Field\0\u{1}decodeRepeatedUInt64Field\0\u{1}decodeSingular\0\u{1}decodeSingularBoolField\0\u{1}decodeSingularBytesField\0\u{1}decodeSingularDoubleField\0\u{1}decodeSingularEnumField\0\u{1}decodeSingularFixed32Field\0\u{1}decodeSingularFixed64Field\0\u{1}decodeSingularFloatField\0\u{1}decodeSingularGroupField\0\u{1}decodeSingularInt32Field\0\u{1}decodeSingularInt64Field\0\u{1}decodeSingularMessageField\0\u{1}decodeSingularSFixed32Field\0\u{1}decodeSingularSFixed64Field\0\u{1}decodeSingularSInt32Field\0\u{1}decodeSingularSInt64Field\0\u{1}decodeSingularStringField\0\u{1}decodeSingularUInt32Field\0\u{1}decodeSingularUInt64Field\0\u{1}decodeTextFormat\0\u{1}defaultAnyTypeURLPrefix\0\u{1}defaults\0\u{1}defaultSymbolVisibility\0\u{1}defaultValue\0\u{1}dependency\0\u{1}deprecated\0\u{1}deprecatedLegacyJsonFieldConflicts\0\u{1}deprecationWarning\0\u{1}description\0\u{1}Dictionary\0\u{1}dictionaryLiteral\0\u{1}digit\0\u{1}digit0\0\u{1}digit1\0\u{1}digitCount\0\u{1}digits\0\u{1}digitValue\0\u{1}discardableResult\0\u{1}discardUnknownFields\0\u{1}Double\0\u{1}doubleValue\0\u{1}duration\0\u{1}E\0\u{1}edition\0\u{1}EditionDefault\0\u{1}editionDefaults\0\u{1}editionDeprecated\0\u{1}editionIntroduced\0\u{1}editionRemoved\0\u{1}Element\0\u{1}elements\0\u{1}else\0\u{1}emitExtensionFieldName\0\u{1}emitFieldName\0\u{1}emitFieldNumber\0\u{1}emptyAnyTypeURL\0\u{1}emptyData\0\u{1}encodeAsBytes\0\u{1}encoded\0\u{1}encodedJSONString\0\u{1}encodedSize\0\u{1}encodeField\0\u{1}encoder\0\u{1}end\0\u{1}endArray\0\u{1}endMessageField\0\u{1}endObject\0\u{1}endRegularField\0\u{1}enforceNamingStyle\0\u{1}enum\0\u{1}EnumReservedRange\0\u{1}enumType\0\u{1}enumvalue\0\u{1}Equatable\0\u{1}Error\0\u{1}execute\0\u{1}ExpressibleByArrayLiteral\0\u{1}ExpressibleByDictionaryLiteral\0\u{1}ext\0\u{1}extDecoder\0\u{1}extendedGraphemeClusterLiteral\0\u{1}ExtendedGraphemeClusterLiteralType\0\u{1}extendee\0\u{1}ExtensibleMessage\0\u{1}extension\0\u{1}ExtensionField\0\u{1}extensionFieldNumber\0\u{1}ExtensionFieldValueSet\0\u{1}ExtensionMap\0\u{1}extensionRange\0\u{1}extensions\0\u{1}extras\0\u{1}F\0\u{1}false\0\u{1}features\0\u{1}FeatureSetEditionDefault\0\u{1}featureSupport\0\u{1}field\0\u{1}fieldData\0\u{1}FieldMaskError\0\u{1}fieldName\0\u{1}fieldNameCount\0\u{1}fieldNum\0\u{1}fieldNumber\0\u{1}fieldNumberForProto\0\u{1}fieldPresence\0\u{1}fields\0\u{1}fieldSize\0\u{1}FieldTag\0\u{1}FieldType\0\u{1}file\0\u{1}fileName\0\u{1}filter\0\u{1}final\0\u{1}finiteOnly\0\u{1}first\0\u{1}firstItem\0\u{1}fixedFeatures\0\u{1}Float\0\u{1}floatLiteral\0\u{1}FloatLiteralType\0\u{1}for\0\u{1}forMessageName\0\u{1}formUnion\0\u{1}forReadingFrom\0\u{1}forTypeURL\0\u{1}ForwardParser\0\u{1}forWritingInto\0\u{1}from\0\u{1}fromAscii2\0\u{1}fromAscii4\0\u{1}fromByteOffset\0\u{1}fromHexDigit\0\u{1}fullName\0\u{1}func\0\u{1}function\0\u{1}G\0\u{1}get\0\u{1}getExtensionValue\0\u{1}Google_Protobuf_Any\0\u{1}Google_Protobuf_Api\0\u{1}Google_Protobuf_BoolValue\0\u{1}Google_Protobuf_BytesValue\0\u{1}Google_Protobuf_DescriptorProto\0\u{1}Google_Protobuf_DoubleValue\0\u{1}Google_Protobuf_Duration\0\u{1}Google_Protobuf_Edition\0\u{1}Google_Protobuf_Empty\0\u{1}Google_Protobuf_Enum\0\u{1}Google_Protobuf_EnumDescriptorProto\0\u{1}Google_Protobuf_EnumOptions\0\u{1}Google_Protobuf_EnumValue\0\u{1}Google_Protobuf_EnumValueDescriptorProto\0\u{1}Google_Protobuf_EnumValueOptions\0\u{1}Google_Protobuf_ExtensionRangeOptions\0\u{1}Google_Protobuf_FeatureSet\0\u{1}Google_Protobuf_FeatureSetDefaults\0\u{1}Google_Protobuf_Field\0\u{1}Google_Protobuf_FieldDescriptorProto\0\u{1}Google_Protobuf_FieldMask\0\u{1}Google_Protobuf_FieldOptions\0\u{1}Google_Protobuf_FileDescriptorProto\0\u{1}Google_Protobuf_FileDescriptorSet\0\u{1}Google_Protobuf_FileOptions\0\u{1}Google_Protobuf_FloatValue\0\u{1}Google_Protobuf_GeneratedCodeInfo\0\u{1}Google_Protobuf_Int32Value\0\u{1}Google_Protobuf_Int64Value\0\u{1}Google_Protobuf_ListValue\0\u{1}Google_Protobuf_MessageOptions\0\u{1}Google_Protobuf_Method\0\u{1}Google_Protobuf_MethodDescriptorProto\0\u{1}Google_Protobuf_MethodOptions\0\u{1}Google_Protobuf_Mixin\0\u{1}Google_Protobuf_NullValue\0\u{1}Google_Protobuf_OneofDescriptorProto\0\u{1}Google_Protobuf_OneofOptions\0\u{1}Google_Protobuf_Option\0\u{1}Google_Protobuf_ServiceDescriptorProto\0\u{1}Google_Protobuf_ServiceOptions\0\u{1}Google_Protobuf_SourceCodeInfo\0\u{1}Google_Protobuf_SourceContext\0\u{1}Google_Protobuf_StringValue\0\u{1}Google_Protobuf_Struct\0\u{1}Google_Protobuf_SymbolVisibility\0\u{1}Google_Protobuf_Syntax\0\u{1}Google_Protobuf_Timestamp\0\u{1}Google_Protobuf_Type\0\u{1}Google_Protobuf_UInt32Value\0\u{1}Google_Protobuf_UInt64Value\0\u{1}Google_Protobuf_UninterpretedOption\0\u{1}Google_Protobuf_Value\0\u{1}goPackage\0\u{1}gotData\0\u{1}group\0\u{1}groupFieldNumberStack\0\u{1}groupSize\0\u{1}guard\0\u{1}hadOneofValue\0\u{1}handleConflictingOneOf\0\u{1}handleInstruction\0\u{1}hasAggregateValue\0\u{1}hasAllowAlias\0\u{1}hasBegin\0\u{1}hasCcEnableArenas\0\u{1}hasCcGenericServices\0\u{1}hasClientStreaming\0\u{1}hasCsharpNamespace\0\u{1}hasCtype\0\u{1}hasData\0\u{1}hasDebugRedact\0\u{1}hasDefaultSymbolVisibility\0\u{1}hasDefaultValue\0\u{1}hasDeprecated\0\u{1}hasDeprecatedLegacyJsonFieldConflicts\0\u{1}hasDeprecationWarning\0\u{1}hasDoubleValue\0\u{1}hasEdition\0\u{1}hasEditionDeprecated\0\u{1}hasEditionIntroduced\0\u{1}hasEditionRemoved\0\u{1}hasEnd\0\u{1}hasEnforceNamingStyle\0\u{1}hasEnumType\0\u{1}hasExplicitDelta\0\u{1}hasExtendee\0\u{1}hasExtensionValue\0\u{1}hasFeatures\0\u{1}hasFeatureSupport\0\u{1}hasFieldPresence\0\u{1}hasFixedFeatures\0\u{1}hasFullName\0\u{1}hasGoPackage\0\u{1}hash\0\u{1}Hashable\0\u{1}hasher\0\u{1}HashVisitor\0\u{1}hasIdempotencyLevel\0\u{1}hasIdentifierValue\0\u{1}hasInputType\0\u{1}hasIsExtension\0\u{1}hasJavaGenerateEqualsAndHash\0\u{1}hasJavaGenericServices\0\u{1}hasJavaMultipleFiles\0\u{1}hasJavaOuterClassname\0\u{1}hasJavaPackage\0\u{1}hasJavaStringCheckUtf8\0\u{1}hasJsonFormat\0\u{1}hasJsonName\0\u{1}hasJstype\0\u{1}hasLabel\0\u{1}hasLazy\0\u{1}hasLeadingComments\0\u{1}hasMapEntry\0\u{1}hasMaximumEdition\0\u{1}hasMessageEncoding\0\u{1}hasMessageSetWireFormat\0\u{1}hasMinimumEdition\0\u{1}hasName\0\u{1}hasNamePart\0\u{1}hasNegativeIntValue\0\u{1}hasNoStandardDescriptorAccessor\0\u{1}hasNumber\0\u{1}hasObjcClassPrefix\0\u{1}hasOneofIndex\0\u{1}hasOptimizeFor\0\u{1}hasOptions\0\u{1}hasOutputType\0\u{1}hasOverridableFeatures\0\u{1}hasPackage\0\u{1}hasPacked\0\u{1}hasPhpClassPrefix\0\u{1}hasPhpMetadataNamespace\0\u{1}hasPhpNamespace\0\u{1}hasPositiveIntValue\0\u{1}hasProto3Optional\0\u{1}hasPyGenericServices\0\u{1}hasRemovalError\0\u{1}hasRepeated\0\u{1}hasRepeatedFieldEncoding\0\u{1}hasReserved\0\u{1}hasRetention\0\u{1}hasRubyPackage\0\u{1}hasSemantic\0\u{1}hasServerStreaming\0\u{1}hasSourceCodeInfo\0\u{1}hasSourceContext\0\u{1}hasSourceFile\0\u{1}hasStart\0\u{1}hasStringValue\0\u{1}hasSwiftPrefix\0\u{1}hasSyntax\0\u{1}hasTrailingComments\0\u{1}hasType\0\u{1}hasTypeName\0\u{1}hasUnverifiedLazy\0\u{1}hasUtf8Validation\0\u{1}hasValue\0\u{1}hasVerification\0\u{1}hasVisibility\0\u{1}hasWeak\0\u{1}hour\0\u{1}i\0\u{1}idempotencyLevel\0\u{1}identifierValue\0\u{1}if\0\u{1}ignoreUnknownExtensionFields\0\u{1}ignoreUnknownFields\0\u{1}index\0\u{1}init\0\u{1}inout\0\u{1}inputType\0\u{1}insert\0\u{1}Instruction\0\u{1}Int\0\u{1}Int32\0\u{1}Int64\0\u{1}Int8\0\u{1}integerLiteral\0\u{1}IntegerLiteralType\0\u{1}intern\0\u{1}Internal\0\u{1}InternalState\0\u{1}intersect\0\u{1}into\0\u{1}ints\0\u{1}invalidAnyTypeURL\0\u{1}isA\0\u{1}isEqual\0\u{1}isEqualTo\0\u{1}isExtension\0\u{1}isInitialized\0\u{1}isNegative\0\u{1}isPathValid\0\u{1}isReserved\0\u{1}isValid\0\u{1}itemTagsEncodedSize\0\u{1}iterator\0\u{1}javaGenerateEqualsAndHash\0\u{1}javaGenericServices\0\u{1}javaMultipleFiles\0\u{1}javaOuterClassname\0\u{1}javaPackage\0\u{1}javaStringCheckUtf8\0\u{1}JSONDecoder\0\u{1}JSONDecoding\0\u{1}JSONDecodingError\0\u{1}JSONDecodingOptions\0\u{1}jsonEncoder\0\u{1}JSONEncoding\0\u{1}JSONEncodingError\0\u{1}JSONEncodingOptions\0\u{1}JSONEncodingVisitor\0\u{1}jsonFormat\0\u{1}JSONMapEncodingVisitor\0\u{1}jsonName\0\u{1}jsonPath\0\u{1}jsonPaths\0\u{1}JSONScanner\0\u{1}jsonString\0\u{1}jsonText\0\u{1}jsonUTF8Bytes\0\u{1}jsonUTF8Data\0\u{1}jstype\0\u{1}k\0\u{1}kChunkSize\0\u{1}Key\0\u{1}keyField\0\u{1}keyFieldOpt\0\u{1}KeyType\0\u{1}kind\0\u{1}l\0\u{1}label\0\u{1}lazy\0\u{1}leadingComments\0\u{1}leadingDetachedComments\0\u{1}length\0\u{1}lessThan\0\u{1}let\0\u{1}lhs\0\u{1}line\0\u{1}list\0\u{1}listOfMessages\0\u{1}listValue\0\u{1}littleEndian\0\u{1}load\0\u{1}localHasher\0\u{1}location\0\u{1}M\0\u{1}major\0\u{1}makeAsyncIterator\0\u{1}makeIterator\0\u{1}malformedLength\0\u{1}mapEntry\0\u{1}MapKeyType\0\u{1}mapToMessages\0\u{1}MapValueType\0\u{1}mapVisitor\0\u{1}mask\0\u{1}maximumEdition\0\u{1}mdayStart\0\u{1}merge\0\u{1}MergeOptions\0\u{1}message\0\u{1}messageDepthLimit\0\u{1}messageEncoding\0\u{1}MessageExtension\0\u{1}MessageImplementationBase\0\u{1}MessageSet\0\u{1}messageSetWireFormat\0\u{1}messageSize\0\u{1}messageType\0\u{1}method\0\u{1}methods\0\u{1}min\0\u{1}minimumEdition\0\u{1}minor\0\u{1}mixins\0\u{1}modify\0\u{1}month\0\u{1}msgExtension\0\u{1}mutating\0\u{1}n\0\u{1}name\0\u{1}NameDescription\0\u{1}NameMap\0\u{1}NamePart\0\u{1}names\0\u{1}nanos\0\u{1}negativeIntValue\0\u{1}nestedType\0\u{1}newExtensible\0\u{1}newL\0\u{1}newList\0\u{1}newMessage\0\u{1}newValue\0\u{1}next\0\u{1}nextByte\0\u{1}nextFieldNumber\0\u{1}nextInstruction\0\u{1}nextInt32\0\u{1}nextNullTerminatedString\0\u{1}nextNullTerminatedStringArray\0\u{1}nextNumber\0\u{1}nextUInt64\0\u{1}nextVarInt\0\u{1}nil\0\u{1}nilLiteral\0\u{1}noBytesAvailable\0\u{1}noStandardDescriptorAccessor\0\u{1}nullValue\0\u{1}number\0\u{1}numberValue\0\u{1}objcClassPrefix\0\u{1}of\0\u{1}OneOf_Kind\0\u{1}oneofDecl\0\u{1}oneofIndex\0\u{1}oneofs\0\u{1}optimizeFor\0\u{1}OptimizeMode\0\u{1}OptionalEnumExtensionField\0\u{1}OptionalExtensionField\0\u{1}OptionalGroupExtensionField\0\u{1}OptionalMessageExtensionField\0\u{1}optionDependency\0\u{1}OptionRetention\0\u{1}options\0\u{1}OptionTargetType\0\u{1}other\0\u{1}others\0\u{1}out\0\u{1}outputType\0\u{1}overridableFeatures\0\u{1}p\0\u{1}package\0\u{1}packed\0\u{1}PackedEnumExtensionField\0\u{1}PackedExtensionField\0\u{1}padding\0\u{1}parent\0\u{1}parse\0\u{1}partial\0\u{1}path\0\u{1}PathDecoder\0\u{1}PathDecodingError\0\u{1}paths\0\u{1}PathVisitor\0\u{1}payload\0\u{1}payloadSize\0\u{1}phpClassPrefix\0\u{1}phpMetadataNamespace\0\u{1}phpNamespace\0\u{1}pos\0\u{1}positiveIntValue\0\u{1}prefix\0\u{1}preserveProtoFieldNames\0\u{1}preTraverse\0\u{1}previousNumber\0\u{1}prevPath\0\u{1}printUnknownFields\0\u{1}programBuffer\0\u{1}programFormat\0\u{1}proto2\0\u{1}proto3DefaultValue\0\u{1}proto3Optional\0\u{1}protobuf_extensionFieldValues\0\u{1}protobuf_fieldNumber\0\u{1}protobuf_generated_isEqualTo\0\u{1}protobuf_nameMap\0\u{1}protobuf_newField\0\u{1}protobuf_package\0\u{1}ProtobufAPIVersion_2\0\u{1}ProtobufAPIVersionCheck\0\u{1}ProtobufBool\0\u{1}ProtobufBytes\0\u{1}protobufData\0\u{1}ProtobufDouble\0\u{1}ProtobufEnumMap\0\u{1}protobufExtension\0\u{1}ProtobufFixed32\0\u{1}ProtobufFixed64\0\u{1}ProtobufFloat\0\u{1}ProtobufInt32\0\u{1}ProtobufInt64\0\u{1}ProtobufMap\0\u{1}ProtobufMessageMap\0\u{1}ProtobufSFixed32\0\u{1}ProtobufSFixed64\0\u{1}ProtobufSInt32\0\u{1}ProtobufSInt64\0\u{1}ProtobufString\0\u{1}ProtobufUInt32\0\u{1}ProtobufUInt64\0\u{1}protocol\0\u{1}protoFieldName\0\u{1}protoMessageName\0\u{1}ProtoNameProviding\0\u{1}protoPaths\0\u{1}public\0\u{1}publicDependency\0\u{1}putBoolValue\0\u{1}putBytesValue\0\u{1}putDoubleValue\0\u{1}putEnumValue\0\u{1}putFixedUInt32\0\u{1}putFixedUInt64\0\u{1}putFloatValue\0\u{1}putInt64\0\u{1}putStringValue\0\u{1}putUInt64\0\u{1}putUInt64Hex\0\u{1}putVarInt\0\u{1}putZigZagVarInt\0\u{1}pyGenericServices\0\u{1}R\0\u{1}rawChars\0\u{1}RawRepresentable\0\u{1}RawValue\0\u{1}read4HexDigits\0\u{1}readBytes\0\u{1}reader\0\u{1}register\0\u{1}remainingProgram\0\u{1}removalError\0\u{1}removingAllFieldsOf\0\u{1}repeated\0\u{1}RepeatedEnumExtensionField\0\u{1}RepeatedExtensionField\0\u{1}repeatedFieldEncoding\0\u{1}RepeatedGroupExtensionField\0\u{1}RepeatedMessageExtensionField\0\u{1}repeating\0\u{1}replaceRepeatedFields\0\u{1}requestStreaming\0\u{1}requestTypeURL\0\u{1}requiredSize\0\u{1}responseStreaming\0\u{1}responseTypeURL\0\u{1}result\0\u{1}retention\0\u{1}rethrows\0\u{1}ReturnType\0\u{1}revision\0\u{1}rhs\0\u{1}root\0\u{1}rubyPackage\0\u{1}s\0\u{1}sawBackslash\0\u{1}sawSection4Characters\0\u{1}sawSection5Characters\0\u{1}Scalar\0\u{1}scan\0\u{1}scanner\0\u{1}seconds\0\u{1}self\0\u{1}semantic\0\u{1}Sendable\0\u{1}separator\0\u{1}serialize\0\u{1}serializedBytes\0\u{1}serializedData\0\u{1}serializedSize\0\u{1}serverStreaming\0\u{1}service\0\u{1}set\0\u{1}setExtensionValue\0\u{1}shift\0\u{1}SimpleExtensionMap\0\u{1}size\0\u{1}sizer\0\u{1}source\0\u{1}sourceCodeInfo\0\u{1}sourceContext\0\u{1}sourceEncoding\0\u{1}sourceFile\0\u{1}SourceLocation\0\u{1}span\0\u{1}split\0\u{1}start\0\u{1}startArray\0\u{1}startArrayObject\0\u{1}startField\0\u{1}startIndex\0\u{1}startMessageField\0\u{1}startObject\0\u{1}startRegularField\0\u{1}state\0\u{1}static\0\u{1}StaticString\0\u{1}storage\0\u{1}String\0\u{1}stringLiteral\0\u{1}StringLiteralType\0\u{1}stringResult\0\u{1}stringValue\0\u{1}struct\0\u{1}structValue\0\u{1}subDecoder\0\u{1}subscript\0\u{1}subtract\0\u{1}subVisitor\0\u{1}Swift\0\u{1}swiftPrefix\0\u{1}SwiftProtobufContiguousBytes\0\u{1}SwiftProtobufError\0\u{1}syntax\0\u{1}T\0\u{1}tag\0\u{1}targets\0\u{1}terminator\0\u{1}testDecoder\0\u{1}text\0\u{1}textDecoder\0\u{1}TextFormatDecoder\0\u{1}TextFormatDecodingError\0\u{1}TextFormatDecodingOptions\0\u{1}TextFormatEncodingOptions\0\u{1}TextFormatEncodingVisitor\0\u{1}textFormatString\0\u{1}throwOrIgnore\0\u{1}throws\0\u{1}timeInterval\0\u{1}timeIntervalSince1970\0\u{1}timeIntervalSinceReferenceDate\0\u{1}tmp\0\u{1}tooLarge\0\u{1}total\0\u{1}totalArrayDepth\0\u{1}totalSize\0\u{1}trailingComments\0\u{1}traverse\0\u{1}trim\0\u{1}true\0\u{1}try\0\u{1}type\0\u{1}typealias\0\u{1}TypeEnum\0\u{1}typeName\0\u{1}typePrefix\0\u{1}typeStart\0\u{1}typeUnknown\0\u{1}typeURL\0\u{1}UInt32\0\u{1}UInt64\0\u{1}UInt8\0\u{1}unchecked\0\u{1}Unicode\0\u{1}unicodeScalarLiteral\0\u{1}UnicodeScalarLiteralType\0\u{1}unicodeScalars\0\u{1}UnicodeScalarView\0\u{1}uninterpretedOption\0\u{1}union\0\u{1}uniqueStorage\0\u{1}unknown\0\u{1}unknownFields\0\u{1}UnknownStorage\0\u{1}unpackTo\0\u{1}UnsafeBufferPointer\0\u{1}UnsafeMutablePointer\0\u{1}UnsafeMutableRawBufferPointer\0\u{1}UnsafeRawBufferPointer\0\u{1}UnsafeRawPointer\0\u{1}unverifiedLazy\0\u{1}updatedOptions\0\u{1}uppercasedAssumingASCII\0\u{1}url\0\u{1}useDeterministicOrdering\0\u{1}utf8\0\u{1}utf8Ptr\0\u{1}utf8ToDouble\0\u{1}utf8Validation\0\u{1}UTF8View\0\u{1}V\0\u{1}value\0\u{1}valueField\0\u{1}values\0\u{1}ValueType\0\u{1}var\0\u{1}verification\0\u{1}VerificationState\0\u{1}version\0\u{1}versionString\0\u{1}visibility\0\u{1}VisibilityFeature\0\u{1}visitExtensionFields\0\u{1}visitExtensionFieldsAsMessageSet\0\u{1}visitMapField\0\u{1}Visitor\0\u{1}visitPacked\0\u{1}visitPackedBoolField\0\u{1}visitPackedDoubleField\0\u{1}visitPackedEnumField\0\u{1}visitPackedFixed32Field\0\u{1}visitPackedFixed64Field\0\u{1}visitPackedFloatField\0\u{1}visitPackedInt32Field\0\u{1}visitPackedInt64Field\0\u{1}visitPackedSFixed32Field\0\u{1}visitPackedSFixed64Field\0\u{1}visitPackedSInt32Field\0\u{1}visitPackedSInt64Field\0\u{1}visitPackedUInt32Field\0\u{1}visitPackedUInt64Field\0\u{1}visitRepeated\0\u{1}visitRepeatedBoolField\0\u{1}visitRepeatedBytesField\0\u{1}visitRepeatedDoubleField\0\u{1}visitRepeatedEnumField\0\u{1}visitRepeatedFixed32Field\0\u{1}visitRepeatedFixed64Field\0\u{1}visitRepeatedFloatField\0\u{1}visitRepeatedGroupField\0\u{1}visitRepeatedInt32Field\0\u{1}visitRepeatedInt64Field\0\u{1}visitRepeatedMessageField\0\u{1}visitRepeatedSFixed32Field\0\u{1}visitRepeatedSFixed64Field\0\u{1}visitRepeatedSInt32Field\0\u{1}visitRepeatedSInt64Field\0\u{1}visitRepeatedStringField\0\u{1}visitRepeatedUInt32Field\0\u{1}visitRepeatedUInt64Field\0\u{1}visitSingular\0\u{1}visitSingularBoolField\0\u{1}visitSingularBytesField\0\u{1}visitSingularDoubleField\0\u{1}visitSingularEnumField\0\u{1}visitSingularFixed32Field\0\u{1}visitSingularFixed64Field\0\u{1}visitSingularFloatField\0\u{1}visitSingularGroupField\0\u{1}visitSingularInt32Field\0\u{1}visitSingularInt64Field\0\u{1}visitSingularMessageField\0\u{1}visitSingularSFixed32Field\0\u{1}visitSingularSFixed64Field\0\u{1}visitSingularSInt32Field\0\u{1}visitSingularSInt64Field\0\u{1}visitSingularStringField\0\u{1}visitSingularUInt32Field\0\u{1}visitSingularUInt64Field\0\u{1}visitUnknown\0\u{1}Void\0\u{1}wasDecoded\0\u{1}weak\0\u{1}weakDependency\0\u{1}where\0\u{1}wireFormat\0\u{1}with\0\u{1}withUnsafeBytes\0\u{1}withUnsafeMutableBytes\0\u{1}work\0\u{1}Wrapped\0\u{1}WrappedType\0\u{1}wrappedValue\0\u{1}written\0\u{1}yday\0") +} diff --git a/Reference/Tests/SwiftProtobufTests/generated_swift_names_enums.pb.swift b/Reference/Tests/SwiftProtobufTests/generated_swift_names_enums.pb.swift new file mode 100644 index 000000000..bd944f898 --- /dev/null +++ b/Reference/Tests/SwiftProtobufTests/generated_swift_names_enums.pb.swift @@ -0,0 +1,34976 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: generated_swift_names_enums.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +/// See Makefile for the logic that generates this +/// Protoc errors imply this file is being generated incorrectly +/// Swift compile errors are probably bugs in protoc-gen-swift + +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 SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums: Sendable { + // 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() + + enum addPath: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAddPath // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAddPath + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAddPath + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAddPath: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.addPath] = [ + .noneAddPath, + ] + + } + + enum adjusted: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAdjusted // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAdjusted + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAdjusted + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAdjusted: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.adjusted] = [ + .noneAdjusted, + ] + + } + + enum aggregateValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAggregateValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAggregateValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAggregateValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAggregateValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.aggregateValue] = [ + .noneAggregateValue, + ] + + } + + enum allCases: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAllCases // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAllCases + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAllCases + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAllCases: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.allCases] = [ + .noneAllCases, + ] + + } + + enum allowAlias: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAllowAlias // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAllowAlias + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAllowAlias + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAllowAlias: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.allowAlias] = [ + .noneAllowAlias, + ] + + } + + enum alwaysPrintEnumsAsInts: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAlwaysPrintEnumsAsInts // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAlwaysPrintEnumsAsInts + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAlwaysPrintEnumsAsInts + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAlwaysPrintEnumsAsInts: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.alwaysPrintEnumsAsInts] = [ + .noneAlwaysPrintEnumsAsInts, + ] + + } + + enum alwaysPrintInt64sAsNumbers: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAlwaysPrintInt64SAsNumbers // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAlwaysPrintInt64SAsNumbers + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAlwaysPrintInt64SAsNumbers + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAlwaysPrintInt64SAsNumbers: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.alwaysPrintInt64sAsNumbers] = [ + .noneAlwaysPrintInt64SAsNumbers, + ] + + } + + enum annotation: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAnnotation // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAnnotation + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAnnotation + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAnnotation: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.annotation] = [ + .noneAnnotation, + ] + + } + + enum any: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAny // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAny + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAny + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAny: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.any] = [ + .noneAny, + ] + + } + + enum AnyExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAnyExtensionField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAnyExtensionField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAnyExtensionField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAnyExtensionField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyExtensionField] = [ + .noneAnyExtensionField, + ] + + } + + enum AnyMessageExtension: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAnyMessageExtension // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAnyMessageExtension + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAnyMessageExtension + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAnyMessageExtension: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyMessageExtension] = [ + .noneAnyMessageExtension, + ] + + } + + enum AnyMessageStorage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAnyMessageStorage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAnyMessageStorage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAnyMessageStorage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAnyMessageStorage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyMessageStorage] = [ + .noneAnyMessageStorage, + ] + + } + + enum AnyUnpackError: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAnyUnpackError // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAnyUnpackError + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAnyUnpackError + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAnyUnpackError: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyUnpackError] = [ + .noneAnyUnpackError, + ] + + } + + enum append: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAppend // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAppend + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAppend + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAppend: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.append] = [ + .noneAppend, + ] + + } + + enum appended: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAppended // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAppended + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAppended + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAppended: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.appended] = [ + .noneAppended, + ] + + } + + enum appendUIntHex: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAppendUintHex // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAppendUintHex + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAppendUintHex + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAppendUintHex: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.appendUIntHex] = [ + .noneAppendUintHex, + ] + + } + + enum appendUnknown: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAppendUnknown // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAppendUnknown + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAppendUnknown + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAppendUnknown: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.appendUnknown] = [ + .noneAppendUnknown, + ] + + } + + enum areAllInitialized: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAreAllInitialized // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAreAllInitialized + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAreAllInitialized + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAreAllInitialized: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.areAllInitialized] = [ + .noneAreAllInitialized, + ] + + } + + enum Array: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneArray // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneArray + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneArray + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneArray: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Array] = [ + .noneArray, + ] + + } + + enum arrayDepth: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneArrayDepth // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneArrayDepth + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneArrayDepth + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneArrayDepth: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.arrayDepth] = [ + .noneArrayDepth, + ] + + } + + enum arrayLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneArrayLiteral // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneArrayLiteral + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneArrayLiteral + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneArrayLiteral: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.arrayLiteral] = [ + .noneArrayLiteral, + ] + + } + + enum arraySeparator: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneArraySeparator // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneArraySeparator + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneArraySeparator + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneArraySeparator: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.arraySeparator] = [ + .noneArraySeparator, + ] + + } + + enum asEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAs // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAs + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAs + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAs: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.asEnum] = [ + .noneAs, + ] + + } + + enum asciiOpenCurlyBracket: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAsciiOpenCurlyBracket // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAsciiOpenCurlyBracket + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAsciiOpenCurlyBracket + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAsciiOpenCurlyBracket: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.asciiOpenCurlyBracket] = [ + .noneAsciiOpenCurlyBracket, + ] + + } + + enum asciiZero: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAsciiZero // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAsciiZero + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAsciiZero + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAsciiZero: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.asciiZero] = [ + .noneAsciiZero, + ] + + } + + enum async: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAsync // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAsync + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAsync + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAsync: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.async] = [ + .noneAsync, + ] + + } + + enum AsyncIterator: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAsyncIterator // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAsyncIterator + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAsyncIterator + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAsyncIterator: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AsyncIterator] = [ + .noneAsyncIterator, + ] + + } + + enum AsyncIteratorProtocol: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAsyncIteratorProtocol // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAsyncIteratorProtocol + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAsyncIteratorProtocol + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAsyncIteratorProtocol: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AsyncIteratorProtocol] = [ + .noneAsyncIteratorProtocol, + ] + + } + + enum AsyncMessageSequence: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAsyncMessageSequence // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAsyncMessageSequence + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAsyncMessageSequence + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAsyncMessageSequence: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AsyncMessageSequence] = [ + .noneAsyncMessageSequence, + ] + + } + + enum available: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAvailable // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAvailable + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAvailable + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAvailable: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.available] = [ + .noneAvailable, + ] + + } + + enum b: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneB // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneB + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneB + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneB: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.b] = [ + .noneB, + ] + + } + + enum Base: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBase // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBase + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBase + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBase: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Base] = [ + .noneBase, + ] + + } + + enum base64Values: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBase64Values // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBase64Values + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBase64Values + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBase64Values: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.base64Values] = [ + .noneBase64Values, + ] + + } + + enum baseAddress: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBaseAddress // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBaseAddress + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBaseAddress + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBaseAddress: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.baseAddress] = [ + .noneBaseAddress, + ] + + } + + enum BaseType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBaseType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBaseType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBaseType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBaseType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BaseType] = [ + .noneBaseType, + ] + + } + + enum begin: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBegin // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBegin + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBegin + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBegin: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.begin] = [ + .noneBegin, + ] + + } + + enum binary: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinary // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinary + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinary + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinary: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binary] = [ + .noneBinary, + ] + + } + + enum BinaryDecoder: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinaryDecoder // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinaryDecoder + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinaryDecoder + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinaryDecoder: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecoder] = [ + .noneBinaryDecoder, + ] + + } + + enum BinaryDecoding: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinaryDecoding // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinaryDecoding + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinaryDecoding + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinaryDecoding: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecoding] = [ + .noneBinaryDecoding, + ] + + } + + enum BinaryDecodingError: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinaryDecodingError // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinaryDecodingError + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinaryDecodingError + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinaryDecodingError: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecodingError] = [ + .noneBinaryDecodingError, + ] + + } + + enum BinaryDecodingOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinaryDecodingOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinaryDecodingOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinaryDecodingOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinaryDecodingOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecodingOptions] = [ + .noneBinaryDecodingOptions, + ] + + } + + enum BinaryDelimited: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinaryDelimited // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinaryDelimited + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinaryDelimited + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinaryDelimited: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDelimited] = [ + .noneBinaryDelimited, + ] + + } + + enum BinaryEncoder: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinaryEncoder // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinaryEncoder + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinaryEncoder + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinaryEncoder: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncoder] = [ + .noneBinaryEncoder, + ] + + } + + enum BinaryEncodingError: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinaryEncodingError // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinaryEncodingError + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinaryEncodingError + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinaryEncodingError: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingError] = [ + .noneBinaryEncodingError, + ] + + } + + enum BinaryEncodingMessageSetSizeVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinaryEncodingMessageSetSizeVisitor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinaryEncodingMessageSetSizeVisitor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinaryEncodingMessageSetSizeVisitor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinaryEncodingMessageSetSizeVisitor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetSizeVisitor] = [ + .noneBinaryEncodingMessageSetSizeVisitor, + ] + + } + + enum BinaryEncodingMessageSetVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinaryEncodingMessageSetVisitor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinaryEncodingMessageSetVisitor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinaryEncodingMessageSetVisitor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinaryEncodingMessageSetVisitor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetVisitor] = [ + .noneBinaryEncodingMessageSetVisitor, + ] + + } + + enum BinaryEncodingOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinaryEncodingOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinaryEncodingOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinaryEncodingOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinaryEncodingOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingOptions] = [ + .noneBinaryEncodingOptions, + ] + + } + + enum BinaryEncodingSizeVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinaryEncodingSizeVisitor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinaryEncodingSizeVisitor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinaryEncodingSizeVisitor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinaryEncodingSizeVisitor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingSizeVisitor] = [ + .noneBinaryEncodingSizeVisitor, + ] + + } + + enum BinaryEncodingVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinaryEncodingVisitor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinaryEncodingVisitor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinaryEncodingVisitor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinaryEncodingVisitor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingVisitor] = [ + .noneBinaryEncodingVisitor, + ] + + } + + enum binaryOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinaryOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinaryOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinaryOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinaryOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binaryOptions] = [ + .noneBinaryOptions, + ] + + } + + enum binaryProtobufDelimitedMessages: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinaryProtobufDelimitedMessages // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinaryProtobufDelimitedMessages + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinaryProtobufDelimitedMessages + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinaryProtobufDelimitedMessages: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binaryProtobufDelimitedMessages] = [ + .noneBinaryProtobufDelimitedMessages, + ] + + } + + enum BinaryStreamDecoding: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinaryStreamDecoding // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinaryStreamDecoding + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinaryStreamDecoding + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinaryStreamDecoding: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryStreamDecoding] = [ + .noneBinaryStreamDecoding, + ] + + } + + enum binaryStreamDecodingError: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinaryStreamDecodingError // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinaryStreamDecodingError + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinaryStreamDecodingError + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinaryStreamDecodingError: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binaryStreamDecodingError] = [ + .noneBinaryStreamDecodingError, + ] + + } + + enum bitPattern: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBitPattern // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBitPattern + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBitPattern + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBitPattern: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bitPattern] = [ + .noneBitPattern, + ] + + } + + enum body: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBody // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBody + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBody + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBody: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.body] = [ + .noneBody, + ] + + } + + enum BoolEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBool // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBool + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBool + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBool: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BoolEnum] = [ + .noneBool, + ] + + } + + enum booleanLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBooleanLiteral // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBooleanLiteral + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBooleanLiteral + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBooleanLiteral: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.booleanLiteral] = [ + .noneBooleanLiteral, + ] + + } + + enum BooleanLiteralType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBooleanLiteralType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBooleanLiteralType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBooleanLiteralType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBooleanLiteralType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BooleanLiteralType] = [ + .noneBooleanLiteralType, + ] + + } + + enum boolValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBoolValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBoolValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBoolValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBoolValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.boolValue] = [ + .noneBoolValue, + ] + + } + + enum buffer: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBuffer // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBuffer + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBuffer + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBuffer: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.buffer] = [ + .noneBuffer, + ] + + } + + enum byte: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneByte // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneByte + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneByte + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneByte: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.byte] = [ + .noneByte, + ] + + } + + enum bytecode: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBytecode // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBytecode + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBytecode + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBytecode: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytecode] = [ + .noneBytecode, + ] + + } + + enum BytecodeReader: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBytecodeReader // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBytecodeReader + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBytecodeReader + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBytecodeReader: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BytecodeReader] = [ + .noneBytecodeReader, + ] + + } + + enum bytes: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBytes // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBytes + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBytes + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBytes: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytes] = [ + .noneBytes, + ] + + } + + enum bytesInGroup: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBytesInGroup // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBytesInGroup + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBytesInGroup + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBytesInGroup: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytesInGroup] = [ + .noneBytesInGroup, + ] + + } + + enum bytesNeeded: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBytesNeeded // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBytesNeeded + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBytesNeeded + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBytesNeeded: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytesNeeded] = [ + .noneBytesNeeded, + ] + + } + + enum bytesRead: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBytesRead // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBytesRead + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBytesRead + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBytesRead: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytesRead] = [ + .noneBytesRead, + ] + + } + + enum c: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneC // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneC + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneC + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneC: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.c] = [ + .noneC, + ] + + } + + enum canonical: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCanonical // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCanonical + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCanonical + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCanonical: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.canonical] = [ + .noneCanonical, + ] + + } + + enum capitalizeNext: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCapitalizeNext // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCapitalizeNext + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCapitalizeNext + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCapitalizeNext: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.capitalizeNext] = [ + .noneCapitalizeNext, + ] + + } + + enum cardinality: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCardinality // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCardinality + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCardinality + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCardinality: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.cardinality] = [ + .noneCardinality, + ] + + } + + enum CaseIterable: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCaseIterable // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCaseIterable + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCaseIterable + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCaseIterable: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.CaseIterable] = [ + .noneCaseIterable, + ] + + } + + enum castedValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCastedValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCastedValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCastedValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCastedValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.castedValue] = [ + .noneCastedValue, + ] + + } + + enum ccEnableArenas: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCcEnableArenas // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCcEnableArenas + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCcEnableArenas + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCcEnableArenas: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ccEnableArenas] = [ + .noneCcEnableArenas, + ] + + } + + enum ccGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCcGenericServices // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCcGenericServices + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCcGenericServices + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCcGenericServices: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ccGenericServices] = [ + .noneCcGenericServices, + ] + + } + + enum Character: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCharacter // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCharacter + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCharacter + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCharacter: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Character] = [ + .noneCharacter, + ] + + } + + enum chars: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneChars // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneChars + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneChars + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneChars: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.chars] = [ + .noneChars, + ] + + } + + enum checkProgramFormat: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCheckProgramFormat // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCheckProgramFormat + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCheckProgramFormat + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCheckProgramFormat: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.checkProgramFormat] = [ + .noneCheckProgramFormat, + ] + + } + + enum chunk: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneChunk // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneChunk + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneChunk + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneChunk: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.chunk] = [ + .noneChunk, + ] + + } + + enum classEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClass // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClass + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClass + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClass: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.classEnum] = [ + .noneClass, + ] + + } + + enum clearAggregateValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearAggregateValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearAggregateValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearAggregateValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearAggregateValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearAggregateValue] = [ + .noneClearAggregateValue, + ] + + } + + enum clearAllowAlias: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearAllowAlias // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearAllowAlias + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearAllowAlias + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearAllowAlias: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearAllowAlias] = [ + .noneClearAllowAlias, + ] + + } + + enum clearBegin: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearBegin // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearBegin + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearBegin + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearBegin: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearBegin] = [ + .noneClearBegin, + ] + + } + + enum clearCcEnableArenas: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearCcEnableArenas // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearCcEnableArenas + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearCcEnableArenas + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearCcEnableArenas: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCcEnableArenas] = [ + .noneClearCcEnableArenas, + ] + + } + + enum clearCcGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearCcGenericServices // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearCcGenericServices + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearCcGenericServices + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearCcGenericServices: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCcGenericServices] = [ + .noneClearCcGenericServices, + ] + + } + + enum clearClientStreaming: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearClientStreaming // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearClientStreaming + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearClientStreaming + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearClientStreaming: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearClientStreaming] = [ + .noneClearClientStreaming, + ] + + } + + enum clearCsharpNamespace: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearCsharpNamespace // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearCsharpNamespace + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearCsharpNamespace + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearCsharpNamespace: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCsharpNamespace] = [ + .noneClearCsharpNamespace, + ] + + } + + enum clearCtype: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearCtype // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearCtype + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearCtype + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearCtype: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCtype] = [ + .noneClearCtype, + ] + + } + + enum clearDebugRedact: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearDebugRedact // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearDebugRedact + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearDebugRedact + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearDebugRedact: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDebugRedact] = [ + .noneClearDebugRedact, + ] + + } + + enum clearDefaultSymbolVisibility: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearDefaultSymbolVisibility // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearDefaultSymbolVisibility + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearDefaultSymbolVisibility + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearDefaultSymbolVisibility: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDefaultSymbolVisibility] = [ + .noneClearDefaultSymbolVisibility, + ] + + } + + enum clearDefaultValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearDefaultValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearDefaultValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearDefaultValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearDefaultValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDefaultValue] = [ + .noneClearDefaultValue, + ] + + } + + enum clearDeprecated: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearDeprecated // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearDeprecated + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearDeprecated + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearDeprecated: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDeprecated] = [ + .noneClearDeprecated, + ] + + } + + enum clearDeprecatedLegacyJsonFieldConflicts: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearDeprecatedLegacyJsonFieldConflicts // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearDeprecatedLegacyJsonFieldConflicts + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearDeprecatedLegacyJsonFieldConflicts + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearDeprecatedLegacyJsonFieldConflicts: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDeprecatedLegacyJsonFieldConflicts] = [ + .noneClearDeprecatedLegacyJsonFieldConflicts, + ] + + } + + enum clearDeprecationWarning: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearDeprecationWarning // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearDeprecationWarning + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearDeprecationWarning + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearDeprecationWarning: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDeprecationWarning] = [ + .noneClearDeprecationWarning, + ] + + } + + enum clearDoubleValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearDoubleValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearDoubleValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearDoubleValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearDoubleValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDoubleValue] = [ + .noneClearDoubleValue, + ] + + } + + enum clearEdition: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearEdition // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearEdition + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearEdition + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearEdition: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEdition] = [ + .noneClearEdition, + ] + + } + + enum clearEditionDeprecated: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearEditionDeprecated // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearEditionDeprecated + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearEditionDeprecated + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearEditionDeprecated: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEditionDeprecated] = [ + .noneClearEditionDeprecated, + ] + + } + + enum clearEditionIntroduced: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearEditionIntroduced // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearEditionIntroduced + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearEditionIntroduced + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearEditionIntroduced: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEditionIntroduced] = [ + .noneClearEditionIntroduced, + ] + + } + + enum clearEditionRemoved: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearEditionRemoved // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearEditionRemoved + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearEditionRemoved + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearEditionRemoved: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEditionRemoved] = [ + .noneClearEditionRemoved, + ] + + } + + enum clearEnd: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearEnd // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearEnd + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearEnd + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearEnd: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEnd] = [ + .noneClearEnd, + ] + + } + + enum clearEnforceNamingStyle: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearEnforceNamingStyle // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearEnforceNamingStyle + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearEnforceNamingStyle + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearEnforceNamingStyle: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEnforceNamingStyle] = [ + .noneClearEnforceNamingStyle, + ] + + } + + enum clearEnumType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearEnumType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearEnumType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearEnumType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearEnumType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEnumType] = [ + .noneClearEnumType, + ] + + } + + enum clearExtendee: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearExtendee // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearExtendee + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearExtendee + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearExtendee: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearExtendee] = [ + .noneClearExtendee, + ] + + } + + enum clearExtensionValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearExtensionValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearExtensionValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearExtensionValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearExtensionValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearExtensionValue] = [ + .noneClearExtensionValue, + ] + + } + + enum clearFeatures: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearFeatures // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearFeatures + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearFeatures + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearFeatures: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFeatures] = [ + .noneClearFeatures, + ] + + } + + enum clearFeatureSupport: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearFeatureSupport // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearFeatureSupport + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearFeatureSupport + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearFeatureSupport: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFeatureSupport] = [ + .noneClearFeatureSupport, + ] + + } + + enum clearFieldPresence: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearFieldPresence // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearFieldPresence + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearFieldPresence + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearFieldPresence: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFieldPresence] = [ + .noneClearFieldPresence, + ] + + } + + enum clearFixedFeatures: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearFixedFeatures // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearFixedFeatures + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearFixedFeatures + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearFixedFeatures: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFixedFeatures] = [ + .noneClearFixedFeatures, + ] + + } + + enum clearFullName: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearFullName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearFullName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearFullName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearFullName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFullName] = [ + .noneClearFullName, + ] + + } + + enum clearGoPackage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearGoPackage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearGoPackage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearGoPackage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearGoPackage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearGoPackage] = [ + .noneClearGoPackage, + ] + + } + + enum clearIdempotencyLevel: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearIdempotencyLevel // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearIdempotencyLevel + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearIdempotencyLevel + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearIdempotencyLevel: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearIdempotencyLevel] = [ + .noneClearIdempotencyLevel, + ] + + } + + enum clearIdentifierValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearIdentifierValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearIdentifierValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearIdentifierValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearIdentifierValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearIdentifierValue] = [ + .noneClearIdentifierValue, + ] + + } + + enum clearInputType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearInputType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearInputType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearInputType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearInputType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearInputType] = [ + .noneClearInputType, + ] + + } + + enum clearIsExtension: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearIsExtension // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearIsExtension + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearIsExtension + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearIsExtension: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearIsExtension] = [ + .noneClearIsExtension, + ] + + } + + enum clearJavaGenerateEqualsAndHash: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearJavaGenerateEqualsAndHash // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearJavaGenerateEqualsAndHash + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearJavaGenerateEqualsAndHash + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearJavaGenerateEqualsAndHash: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaGenerateEqualsAndHash] = [ + .noneClearJavaGenerateEqualsAndHash, + ] + + } + + enum clearJavaGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearJavaGenericServices // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearJavaGenericServices + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearJavaGenericServices + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearJavaGenericServices: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaGenericServices] = [ + .noneClearJavaGenericServices, + ] + + } + + enum clearJavaMultipleFiles: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearJavaMultipleFiles // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearJavaMultipleFiles + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearJavaMultipleFiles + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearJavaMultipleFiles: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaMultipleFiles] = [ + .noneClearJavaMultipleFiles, + ] + + } + + enum clearJavaOuterClassname: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearJavaOuterClassname // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearJavaOuterClassname + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearJavaOuterClassname + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearJavaOuterClassname: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaOuterClassname] = [ + .noneClearJavaOuterClassname, + ] + + } + + enum clearJavaPackage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearJavaPackage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearJavaPackage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearJavaPackage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearJavaPackage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaPackage] = [ + .noneClearJavaPackage, + ] + + } + + enum clearJavaStringCheckUtf8: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearJavaStringCheckUtf8 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearJavaStringCheckUtf8 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearJavaStringCheckUtf8 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearJavaStringCheckUtf8: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaStringCheckUtf8] = [ + .noneClearJavaStringCheckUtf8, + ] + + } + + enum clearJsonFormat: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearJsonFormat // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearJsonFormat + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearJsonFormat + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearJsonFormat: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJsonFormat] = [ + .noneClearJsonFormat, + ] + + } + + enum clearJsonName: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearJsonName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearJsonName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearJsonName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearJsonName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJsonName] = [ + .noneClearJsonName, + ] + + } + + enum clearJstype: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearJstype // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearJstype + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearJstype + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearJstype: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJstype] = [ + .noneClearJstype, + ] + + } + + enum clearLabel: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearLabel // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearLabel + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearLabel + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearLabel: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearLabel] = [ + .noneClearLabel, + ] + + } + + enum clearLazy: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearLazy // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearLazy + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearLazy + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearLazy: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearLazy] = [ + .noneClearLazy, + ] + + } + + enum clearLeadingComments: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearLeadingComments // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearLeadingComments + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearLeadingComments + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearLeadingComments: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearLeadingComments] = [ + .noneClearLeadingComments, + ] + + } + + enum clearMapEntry: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearMapEntry // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearMapEntry + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearMapEntry + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearMapEntry: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMapEntry] = [ + .noneClearMapEntry, + ] + + } + + enum clearMaximumEdition: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearMaximumEdition // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearMaximumEdition + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearMaximumEdition + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearMaximumEdition: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMaximumEdition] = [ + .noneClearMaximumEdition, + ] + + } + + enum clearMessageEncoding: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearMessageEncoding // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearMessageEncoding + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearMessageEncoding + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearMessageEncoding: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMessageEncoding] = [ + .noneClearMessageEncoding, + ] + + } + + enum clearMessageSetWireFormat: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearMessageSetWireFormat // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearMessageSetWireFormat + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearMessageSetWireFormat + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearMessageSetWireFormat: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMessageSetWireFormat] = [ + .noneClearMessageSetWireFormat, + ] + + } + + enum clearMinimumEdition: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearMinimumEdition // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearMinimumEdition + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearMinimumEdition + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearMinimumEdition: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMinimumEdition] = [ + .noneClearMinimumEdition, + ] + + } + + enum clearName: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearName] = [ + .noneClearName, + ] + + } + + enum clearNamePart: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearNamePart // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearNamePart + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearNamePart + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearNamePart: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNamePart] = [ + .noneClearNamePart, + ] + + } + + enum clearNegativeIntValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearNegativeIntValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearNegativeIntValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearNegativeIntValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearNegativeIntValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNegativeIntValue] = [ + .noneClearNegativeIntValue, + ] + + } + + enum clearNoStandardDescriptorAccessor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearNoStandardDescriptorAccessor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearNoStandardDescriptorAccessor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearNoStandardDescriptorAccessor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearNoStandardDescriptorAccessor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNoStandardDescriptorAccessor] = [ + .noneClearNoStandardDescriptorAccessor, + ] + + } + + enum clearNumber: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearNumber // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearNumber + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearNumber + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearNumber: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNumber] = [ + .noneClearNumber, + ] + + } + + enum clearObjcClassPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearObjcClassPrefix // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearObjcClassPrefix + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearObjcClassPrefix + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearObjcClassPrefix: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearObjcClassPrefix] = [ + .noneClearObjcClassPrefix, + ] + + } + + enum clearOneofIndex: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearOneofIndex // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearOneofIndex + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearOneofIndex + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearOneofIndex: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOneofIndex] = [ + .noneClearOneofIndex, + ] + + } + + enum clearOptimizeFor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearOptimizeFor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearOptimizeFor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearOptimizeFor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearOptimizeFor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOptimizeFor] = [ + .noneClearOptimizeFor, + ] + + } + + enum clearOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOptions] = [ + .noneClearOptions, + ] + + } + + enum clearOutputType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearOutputType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearOutputType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearOutputType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearOutputType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOutputType] = [ + .noneClearOutputType, + ] + + } + + enum clearOverridableFeatures: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearOverridableFeatures // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearOverridableFeatures + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearOverridableFeatures + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearOverridableFeatures: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOverridableFeatures] = [ + .noneClearOverridableFeatures, + ] + + } + + enum clearPackage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearPackage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearPackage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearPackage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearPackage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPackage] = [ + .noneClearPackage, + ] + + } + + enum clearPacked: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearPacked // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearPacked + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearPacked + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearPacked: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPacked] = [ + .noneClearPacked, + ] + + } + + enum clearPhpClassPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearPhpClassPrefix // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearPhpClassPrefix + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearPhpClassPrefix + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearPhpClassPrefix: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPhpClassPrefix] = [ + .noneClearPhpClassPrefix, + ] + + } + + enum clearPhpMetadataNamespace: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearPhpMetadataNamespace // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearPhpMetadataNamespace + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearPhpMetadataNamespace + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearPhpMetadataNamespace: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPhpMetadataNamespace] = [ + .noneClearPhpMetadataNamespace, + ] + + } + + enum clearPhpNamespace: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearPhpNamespace // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearPhpNamespace + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearPhpNamespace + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearPhpNamespace: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPhpNamespace] = [ + .noneClearPhpNamespace, + ] + + } + + enum clearPositiveIntValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearPositiveIntValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearPositiveIntValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearPositiveIntValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearPositiveIntValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPositiveIntValue] = [ + .noneClearPositiveIntValue, + ] + + } + + enum clearProto3Optional: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearProto3Optional // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearProto3Optional + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearProto3Optional + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearProto3Optional: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearProto3Optional] = [ + .noneClearProto3Optional, + ] + + } + + enum clearPyGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearPyGenericServices // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearPyGenericServices + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearPyGenericServices + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearPyGenericServices: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPyGenericServices] = [ + .noneClearPyGenericServices, + ] + + } + + enum clearRemovalError: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearRemovalError // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearRemovalError + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearRemovalError + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearRemovalError: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRemovalError] = [ + .noneClearRemovalError, + ] + + } + + enum clearRepeated: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearRepeated // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearRepeated + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearRepeated + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearRepeated: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRepeated] = [ + .noneClearRepeated, + ] + + } + + enum clearRepeatedFieldEncoding: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearRepeatedFieldEncoding // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearRepeatedFieldEncoding + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearRepeatedFieldEncoding + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearRepeatedFieldEncoding: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRepeatedFieldEncoding] = [ + .noneClearRepeatedFieldEncoding, + ] + + } + + enum clearReserved: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearReserved // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearReserved + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearReserved + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearReserved: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearReserved] = [ + .noneClearReserved, + ] + + } + + enum clearRetention: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearRetention // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearRetention + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearRetention + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearRetention: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRetention] = [ + .noneClearRetention, + ] + + } + + enum clearRubyPackage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearRubyPackage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearRubyPackage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearRubyPackage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearRubyPackage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRubyPackage] = [ + .noneClearRubyPackage, + ] + + } + + enum clearSemantic: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearSemantic // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearSemantic + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearSemantic + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearSemantic: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSemantic] = [ + .noneClearSemantic, + ] + + } + + enum clearServerStreaming: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearServerStreaming // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearServerStreaming + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearServerStreaming + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearServerStreaming: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearServerStreaming] = [ + .noneClearServerStreaming, + ] + + } + + enum clearSourceCodeInfo: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearSourceCodeInfo // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearSourceCodeInfo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearSourceCodeInfo + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearSourceCodeInfo: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSourceCodeInfo] = [ + .noneClearSourceCodeInfo, + ] + + } + + enum clearSourceContext: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearSourceContext // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearSourceContext + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearSourceContext + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearSourceContext: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSourceContext] = [ + .noneClearSourceContext, + ] + + } + + enum clearSourceFile: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearSourceFile // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearSourceFile + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearSourceFile + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearSourceFile: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSourceFile] = [ + .noneClearSourceFile, + ] + + } + + enum clearStart: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearStart // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearStart + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearStart + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearStart: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearStart] = [ + .noneClearStart, + ] + + } + + enum clearStringValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearStringValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearStringValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearStringValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearStringValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearStringValue] = [ + .noneClearStringValue, + ] + + } + + enum clearSwiftPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearSwiftPrefix // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearSwiftPrefix + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearSwiftPrefix + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearSwiftPrefix: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSwiftPrefix] = [ + .noneClearSwiftPrefix, + ] + + } + + enum clearSyntax: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearSyntax // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearSyntax + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearSyntax + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearSyntax: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSyntax] = [ + .noneClearSyntax, + ] + + } + + enum clearTrailingComments: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearTrailingComments // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearTrailingComments + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearTrailingComments + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearTrailingComments: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearTrailingComments] = [ + .noneClearTrailingComments, + ] + + } + + enum clearType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearType] = [ + .noneClearType, + ] + + } + + enum clearTypeName: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearTypeName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearTypeName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearTypeName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearTypeName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearTypeName] = [ + .noneClearTypeName, + ] + + } + + enum clearUnverifiedLazy: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearUnverifiedLazy // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearUnverifiedLazy + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearUnverifiedLazy + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearUnverifiedLazy: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearUnverifiedLazy] = [ + .noneClearUnverifiedLazy, + ] + + } + + enum clearUtf8Validation: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearUtf8Validation // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearUtf8Validation + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearUtf8Validation + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearUtf8Validation: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearUtf8Validation] = [ + .noneClearUtf8Validation, + ] + + } + + enum clearValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearValue] = [ + .noneClearValue, + ] + + } + + enum clearVerification: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearVerification // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearVerification + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearVerification + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearVerification: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearVerification] = [ + .noneClearVerification, + ] + + } + + enum clearVisibility: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearVisibility // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearVisibility + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearVisibility + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearVisibility: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearVisibility] = [ + .noneClearVisibility, + ] + + } + + enum clearWeak: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClearWeak // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClearWeak + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClearWeak + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClearWeak: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearWeak] = [ + .noneClearWeak, + ] + + } + + enum clientStreaming: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneClientStreaming // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneClientStreaming + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneClientStreaming + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneClientStreaming: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clientStreaming] = [ + .noneClientStreaming, + ] + + } + + enum code: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCode // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCode + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCode + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCode: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.code] = [ + .noneCode, + ] + + } + + enum codePoint: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCodePoint // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCodePoint + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCodePoint + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCodePoint: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.codePoint] = [ + .noneCodePoint, + ] + + } + + enum codeUnits: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCodeUnits // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCodeUnits + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCodeUnits + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCodeUnits: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.codeUnits] = [ + .noneCodeUnits, + ] + + } + + enum Collection: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCollection // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCollection + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCollection + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCollection: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Collection] = [ + .noneCollection, + ] + + } + + enum comma: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneComma // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneComma + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneComma + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneComma: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.comma] = [ + .noneComma, + ] + + } + + enum consumedBytes: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneConsumedBytes // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneConsumedBytes + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneConsumedBytes + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneConsumedBytes: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.consumedBytes] = [ + .noneConsumedBytes, + ] + + } + + enum contains: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneContains // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneContains + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneContains + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneContains: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.contains] = [ + .noneContains, + ] + + } + + enum contentsOf: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneContentsOf // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneContentsOf + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneContentsOf + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneContentsOf: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.contentsOf] = [ + .noneContentsOf, + ] + + } + + enum ContiguousBytes: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneContiguousBytes // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneContiguousBytes + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneContiguousBytes + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneContiguousBytes: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ContiguousBytes] = [ + .noneContiguousBytes, + ] + + } + + enum copy: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCopy // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCopy + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCopy + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCopy: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.copy] = [ + .noneCopy, + ] + + } + + enum count: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCount // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCount + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCount + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCount: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.count] = [ + .noneCount, + ] + + } + + enum countVarintsInBuffer: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCountVarintsInBuffer // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCountVarintsInBuffer + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCountVarintsInBuffer + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCountVarintsInBuffer: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.countVarintsInBuffer] = [ + .noneCountVarintsInBuffer, + ] + + } + + enum csharpNamespace: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCsharpNamespace // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCsharpNamespace + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCsharpNamespace + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCsharpNamespace: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.csharpNamespace] = [ + .noneCsharpNamespace, + ] + + } + + enum ctype: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCtype // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCtype + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCtype + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCtype: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ctype] = [ + .noneCtype, + ] + + } + + enum customCodable: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCustomCodable // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCustomCodable + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCustomCodable + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCustomCodable: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.customCodable] = [ + .noneCustomCodable, + ] + + } + + enum CustomDebugStringConvertible: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCustomDebugStringConvertible // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCustomDebugStringConvertible + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCustomDebugStringConvertible + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCustomDebugStringConvertible: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.CustomDebugStringConvertible] = [ + .noneCustomDebugStringConvertible, + ] + + } + + enum CustomStringConvertible: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneCustomStringConvertible // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneCustomStringConvertible + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneCustomStringConvertible + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneCustomStringConvertible: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.CustomStringConvertible] = [ + .noneCustomStringConvertible, + ] + + } + + enum D: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneD // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneD + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneD + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneD: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.D] = [ + .noneD, + ] + + } + + enum DataEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneData // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneData + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneData + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneData: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.DataEnum] = [ + .noneData, + ] + + } + + enum dataResult: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDataResult // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDataResult + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDataResult + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDataResult: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.dataResult] = [ + .noneDataResult, + ] + + } + + enum date: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDate // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDate + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDate + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDate: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.date] = [ + .noneDate, + ] + + } + + enum daySec: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDaySec // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDaySec + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDaySec + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDaySec: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.daySec] = [ + .noneDaySec, + ] + + } + + enum daysSinceEpoch: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDaysSinceEpoch // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDaysSinceEpoch + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDaysSinceEpoch + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDaysSinceEpoch: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.daysSinceEpoch] = [ + .noneDaysSinceEpoch, + ] + + } + + enum debugDescriptionEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDebugDescription // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDebugDescription + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDebugDescription + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDebugDescription: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.debugDescriptionEnum] = [ + .noneDebugDescription, + ] + + } + + enum debugRedact: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDebugRedact // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDebugRedact + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDebugRedact + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDebugRedact: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.debugRedact] = [ + .noneDebugRedact, + ] + + } + + enum declaration: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDeclaration // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDeclaration + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDeclaration + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDeclaration: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.declaration] = [ + .noneDeclaration, + ] + + } + + enum decoded: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecoded // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecoded + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecoded + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecoded: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decoded] = [ + .noneDecoded, + ] + + } + + enum decodedFromJSONNull: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodedFromJsonnull // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodedFromJsonnull + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodedFromJsonnull + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodedFromJsonnull: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodedFromJSONNull] = [ + .noneDecodedFromJsonnull, + ] + + } + + enum decodeExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeExtensionField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeExtensionField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeExtensionField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeExtensionField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeExtensionField] = [ + .noneDecodeExtensionField, + ] + + } + + enum decodeExtensionFieldsAsMessageSet: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeExtensionFieldsAsMessageSet // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeExtensionFieldsAsMessageSet + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeExtensionFieldsAsMessageSet + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeExtensionFieldsAsMessageSet: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeExtensionFieldsAsMessageSet] = [ + .noneDecodeExtensionFieldsAsMessageSet, + ] + + } + + enum decodeJSON: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeJson // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeJson + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeJson + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeJson: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeJSON] = [ + .noneDecodeJson, + ] + + } + + enum decodeMapField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeMapField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeMapField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeMapField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeMapField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeMapField] = [ + .noneDecodeMapField, + ] + + } + + enum decodeMessageEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeMessage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeMessage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeMessage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeMessage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeMessageEnum] = [ + .noneDecodeMessage, + ] + + } + + enum Decoder: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecoder // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecoder + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecoder + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecoder: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Decoder] = [ + .noneDecoder, + ] + + } + + enum decodeRepeated: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeated // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeated + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeated + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeated: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeated] = [ + .noneDecodeRepeated, + ] + + } + + enum decodeRepeatedBoolField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeatedBoolField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeatedBoolField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeatedBoolField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeatedBoolField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedBoolField] = [ + .noneDecodeRepeatedBoolField, + ] + + } + + enum decodeRepeatedBytesField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeatedBytesField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeatedBytesField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeatedBytesField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeatedBytesField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedBytesField] = [ + .noneDecodeRepeatedBytesField, + ] + + } + + enum decodeRepeatedDoubleField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeatedDoubleField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeatedDoubleField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeatedDoubleField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeatedDoubleField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedDoubleField] = [ + .noneDecodeRepeatedDoubleField, + ] + + } + + enum decodeRepeatedEnumField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeatedEnumField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeatedEnumField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeatedEnumField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeatedEnumField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedEnumField] = [ + .noneDecodeRepeatedEnumField, + ] + + } + + enum decodeRepeatedFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeatedFixed32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeatedFixed32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeatedFixed32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeatedFixed32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedFixed32Field] = [ + .noneDecodeRepeatedFixed32Field, + ] + + } + + enum decodeRepeatedFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeatedFixed64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeatedFixed64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeatedFixed64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeatedFixed64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedFixed64Field] = [ + .noneDecodeRepeatedFixed64Field, + ] + + } + + enum decodeRepeatedFloatField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeatedFloatField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeatedFloatField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeatedFloatField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeatedFloatField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedFloatField] = [ + .noneDecodeRepeatedFloatField, + ] + + } + + enum decodeRepeatedGroupField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeatedGroupField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeatedGroupField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeatedGroupField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeatedGroupField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedGroupField] = [ + .noneDecodeRepeatedGroupField, + ] + + } + + enum decodeRepeatedInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeatedInt32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeatedInt32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeatedInt32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeatedInt32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedInt32Field] = [ + .noneDecodeRepeatedInt32Field, + ] + + } + + enum decodeRepeatedInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeatedInt64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeatedInt64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeatedInt64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeatedInt64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedInt64Field] = [ + .noneDecodeRepeatedInt64Field, + ] + + } + + enum decodeRepeatedMessageField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeatedMessageField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeatedMessageField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeatedMessageField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeatedMessageField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedMessageField] = [ + .noneDecodeRepeatedMessageField, + ] + + } + + enum decodeRepeatedSFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeatedSfixed32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeatedSfixed32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeatedSfixed32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeatedSfixed32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed32Field] = [ + .noneDecodeRepeatedSfixed32Field, + ] + + } + + enum decodeRepeatedSFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeatedSfixed64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeatedSfixed64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeatedSfixed64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeatedSfixed64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed64Field] = [ + .noneDecodeRepeatedSfixed64Field, + ] + + } + + enum decodeRepeatedSInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeatedSint32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeatedSint32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeatedSint32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeatedSint32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSInt32Field] = [ + .noneDecodeRepeatedSint32Field, + ] + + } + + enum decodeRepeatedSInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeatedSint64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeatedSint64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeatedSint64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeatedSint64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSInt64Field] = [ + .noneDecodeRepeatedSint64Field, + ] + + } + + enum decodeRepeatedStringField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeatedStringField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeatedStringField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeatedStringField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeatedStringField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedStringField] = [ + .noneDecodeRepeatedStringField, + ] + + } + + enum decodeRepeatedUInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeatedUint32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeatedUint32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeatedUint32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeatedUint32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedUInt32Field] = [ + .noneDecodeRepeatedUint32Field, + ] + + } + + enum decodeRepeatedUInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeRepeatedUint64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeRepeatedUint64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeRepeatedUint64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeRepeatedUint64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedUInt64Field] = [ + .noneDecodeRepeatedUint64Field, + ] + + } + + enum decodeSingular: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingular // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingular + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingular + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingular: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingular] = [ + .noneDecodeSingular, + ] + + } + + enum decodeSingularBoolField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingularBoolField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingularBoolField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingularBoolField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingularBoolField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularBoolField] = [ + .noneDecodeSingularBoolField, + ] + + } + + enum decodeSingularBytesField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingularBytesField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingularBytesField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingularBytesField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingularBytesField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularBytesField] = [ + .noneDecodeSingularBytesField, + ] + + } + + enum decodeSingularDoubleField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingularDoubleField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingularDoubleField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingularDoubleField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingularDoubleField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularDoubleField] = [ + .noneDecodeSingularDoubleField, + ] + + } + + enum decodeSingularEnumField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingularEnumField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingularEnumField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingularEnumField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingularEnumField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularEnumField] = [ + .noneDecodeSingularEnumField, + ] + + } + + enum decodeSingularFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingularFixed32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingularFixed32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingularFixed32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingularFixed32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularFixed32Field] = [ + .noneDecodeSingularFixed32Field, + ] + + } + + enum decodeSingularFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingularFixed64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingularFixed64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingularFixed64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingularFixed64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularFixed64Field] = [ + .noneDecodeSingularFixed64Field, + ] + + } + + enum decodeSingularFloatField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingularFloatField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingularFloatField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingularFloatField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingularFloatField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularFloatField] = [ + .noneDecodeSingularFloatField, + ] + + } + + enum decodeSingularGroupField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingularGroupField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingularGroupField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingularGroupField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingularGroupField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularGroupField] = [ + .noneDecodeSingularGroupField, + ] + + } + + enum decodeSingularInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingularInt32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingularInt32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingularInt32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingularInt32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularInt32Field] = [ + .noneDecodeSingularInt32Field, + ] + + } + + enum decodeSingularInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingularInt64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingularInt64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingularInt64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingularInt64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularInt64Field] = [ + .noneDecodeSingularInt64Field, + ] + + } + + enum decodeSingularMessageField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingularMessageField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingularMessageField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingularMessageField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingularMessageField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularMessageField] = [ + .noneDecodeSingularMessageField, + ] + + } + + enum decodeSingularSFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingularSfixed32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingularSfixed32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingularSfixed32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingularSfixed32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSFixed32Field] = [ + .noneDecodeSingularSfixed32Field, + ] + + } + + enum decodeSingularSFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingularSfixed64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingularSfixed64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingularSfixed64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingularSfixed64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSFixed64Field] = [ + .noneDecodeSingularSfixed64Field, + ] + + } + + enum decodeSingularSInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingularSint32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingularSint32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingularSint32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingularSint32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSInt32Field] = [ + .noneDecodeSingularSint32Field, + ] + + } + + enum decodeSingularSInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingularSint64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingularSint64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingularSint64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingularSint64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSInt64Field] = [ + .noneDecodeSingularSint64Field, + ] + + } + + enum decodeSingularStringField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingularStringField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingularStringField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingularStringField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingularStringField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularStringField] = [ + .noneDecodeSingularStringField, + ] + + } + + enum decodeSingularUInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingularUint32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingularUint32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingularUint32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingularUint32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularUInt32Field] = [ + .noneDecodeSingularUint32Field, + ] + + } + + enum decodeSingularUInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeSingularUint64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeSingularUint64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeSingularUint64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeSingularUint64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularUInt64Field] = [ + .noneDecodeSingularUint64Field, + ] + + } + + enum decodeTextFormat: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDecodeTextFormat // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDecodeTextFormat + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDecodeTextFormat + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDecodeTextFormat: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeTextFormat] = [ + .noneDecodeTextFormat, + ] + + } + + enum defaultAnyTypeURLPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDefaultAnyTypeUrlprefix // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDefaultAnyTypeUrlprefix + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDefaultAnyTypeUrlprefix + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDefaultAnyTypeUrlprefix: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaultAnyTypeURLPrefix] = [ + .noneDefaultAnyTypeUrlprefix, + ] + + } + + enum defaults: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDefaults // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDefaults + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDefaults + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDefaults: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaults] = [ + .noneDefaults, + ] + + } + + enum defaultSymbolVisibility: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDefaultSymbolVisibility // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDefaultSymbolVisibility + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDefaultSymbolVisibility + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDefaultSymbolVisibility: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaultSymbolVisibility] = [ + .noneDefaultSymbolVisibility, + ] + + } + + enum defaultValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDefaultValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDefaultValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDefaultValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDefaultValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaultValue] = [ + .noneDefaultValue, + ] + + } + + enum dependency: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDependency // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDependency + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDependency + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDependency: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.dependency] = [ + .noneDependency, + ] + + } + + enum deprecated: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDeprecated // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDeprecated + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDeprecated + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDeprecated: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.deprecated] = [ + .noneDeprecated, + ] + + } + + enum deprecatedLegacyJsonFieldConflicts: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDeprecatedLegacyJsonFieldConflicts // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDeprecatedLegacyJsonFieldConflicts + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDeprecatedLegacyJsonFieldConflicts + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDeprecatedLegacyJsonFieldConflicts: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.deprecatedLegacyJsonFieldConflicts] = [ + .noneDeprecatedLegacyJsonFieldConflicts, + ] + + } + + enum deprecationWarning: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDeprecationWarning // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDeprecationWarning + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDeprecationWarning + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDeprecationWarning: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.deprecationWarning] = [ + .noneDeprecationWarning, + ] + + } + + enum descriptionEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDescription // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDescription + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDescription + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDescription: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.descriptionEnum] = [ + .noneDescription, + ] + + } + + enum Dictionary: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDictionary // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDictionary + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDictionary + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDictionary: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Dictionary] = [ + .noneDictionary, + ] + + } + + enum dictionaryLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDictionaryLiteral // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDictionaryLiteral + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDictionaryLiteral + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDictionaryLiteral: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.dictionaryLiteral] = [ + .noneDictionaryLiteral, + ] + + } + + enum digit: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDigit // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDigit + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDigit + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDigit: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digit] = [ + .noneDigit, + ] + + } + + enum digit0: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDigit0 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDigit0 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDigit0 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDigit0: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digit0] = [ + .noneDigit0, + ] + + } + + enum digit1: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDigit1 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDigit1 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDigit1 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDigit1: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digit1] = [ + .noneDigit1, + ] + + } + + enum digitCount: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDigitCount // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDigitCount + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDigitCount + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDigitCount: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digitCount] = [ + .noneDigitCount, + ] + + } + + enum digits: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDigits // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDigits + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDigits + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDigits: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digits] = [ + .noneDigits, + ] + + } + + enum digitValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDigitValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDigitValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDigitValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDigitValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digitValue] = [ + .noneDigitValue, + ] + + } + + enum discardableResult: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDiscardableResult // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDiscardableResult + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDiscardableResult + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDiscardableResult: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.discardableResult] = [ + .noneDiscardableResult, + ] + + } + + enum discardUnknownFields: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDiscardUnknownFields // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDiscardUnknownFields + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDiscardUnknownFields + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDiscardUnknownFields: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.discardUnknownFields] = [ + .noneDiscardUnknownFields, + ] + + } + + enum DoubleEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDouble // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDouble + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDouble + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDouble: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.DoubleEnum] = [ + .noneDouble, + ] + + } + + enum doubleValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDoubleValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDoubleValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDoubleValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDoubleValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.doubleValue] = [ + .noneDoubleValue, + ] + + } + + enum duration: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneDuration // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneDuration + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneDuration + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneDuration: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.duration] = [ + .noneDuration, + ] + + } + + enum E: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneE // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneE + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneE + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneE: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.E] = [ + .noneE, + ] + + } + + enum edition: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEdition // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEdition + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEdition + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEdition: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.edition] = [ + .noneEdition, + ] + + } + + enum EditionDefault: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEditionDefault // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEditionDefault + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEditionDefault + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEditionDefault: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.EditionDefault] = [ + .noneEditionDefault, + ] + + } + + enum editionDefaults: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEditionDefaults // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEditionDefaults + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEditionDefaults + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEditionDefaults: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionDefaults] = [ + .noneEditionDefaults, + ] + + } + + enum editionDeprecated: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEditionDeprecated // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEditionDeprecated + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEditionDeprecated + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEditionDeprecated: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionDeprecated] = [ + .noneEditionDeprecated, + ] + + } + + enum editionIntroduced: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEditionIntroduced // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEditionIntroduced + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEditionIntroduced + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEditionIntroduced: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionIntroduced] = [ + .noneEditionIntroduced, + ] + + } + + enum editionRemoved: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEditionRemoved // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEditionRemoved + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEditionRemoved + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEditionRemoved: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionRemoved] = [ + .noneEditionRemoved, + ] + + } + + enum Element: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneElement // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneElement + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneElement + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneElement: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Element] = [ + .noneElement, + ] + + } + + enum elements: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneElements // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneElements + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneElements + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneElements: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.elements] = [ + .noneElements, + ] + + } + + enum elseEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneElse // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneElse + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneElse + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneElse: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.elseEnum] = [ + .noneElse, + ] + + } + + enum emitExtensionFieldName: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEmitExtensionFieldName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEmitExtensionFieldName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEmitExtensionFieldName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEmitExtensionFieldName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emitExtensionFieldName] = [ + .noneEmitExtensionFieldName, + ] + + } + + enum emitFieldName: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEmitFieldName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEmitFieldName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEmitFieldName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEmitFieldName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emitFieldName] = [ + .noneEmitFieldName, + ] + + } + + enum emitFieldNumber: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEmitFieldNumber // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEmitFieldNumber + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEmitFieldNumber + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEmitFieldNumber: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emitFieldNumber] = [ + .noneEmitFieldNumber, + ] + + } + + enum emptyAnyTypeURL: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEmptyAnyTypeURL // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEmptyAnyTypeURL + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEmptyAnyTypeURL + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEmptyAnyTypeURL: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emptyAnyTypeURL] = [ + .noneEmptyAnyTypeURL, + ] + + } + + enum emptyData: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEmptyData // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEmptyData + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEmptyData + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEmptyData: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emptyData] = [ + .noneEmptyData, + ] + + } + + enum encodeAsBytes: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEncodeAsBytes // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEncodeAsBytes + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEncodeAsBytes + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEncodeAsBytes: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodeAsBytes] = [ + .noneEncodeAsBytes, + ] + + } + + enum encoded: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEncoded // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEncoded + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEncoded + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEncoded: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encoded] = [ + .noneEncoded, + ] + + } + + enum encodedJSONString: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEncodedJsonstring // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEncodedJsonstring + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEncodedJsonstring + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEncodedJsonstring: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodedJSONString] = [ + .noneEncodedJsonstring, + ] + + } + + enum encodedSize: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEncodedSize // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEncodedSize + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEncodedSize + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEncodedSize: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodedSize] = [ + .noneEncodedSize, + ] + + } + + enum encodeField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEncodeField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEncodeField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEncodeField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEncodeField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodeField] = [ + .noneEncodeField, + ] + + } + + enum encoder: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEncoder // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEncoder + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEncoder + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEncoder: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encoder] = [ + .noneEncoder, + ] + + } + + enum end: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEnd // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEnd + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEnd + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEnd: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.end] = [ + .noneEnd, + ] + + } + + enum endArray: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEndArray // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEndArray + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEndArray + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEndArray: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endArray] = [ + .noneEndArray, + ] + + } + + enum endMessageField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEndMessageField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEndMessageField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEndMessageField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEndMessageField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endMessageField] = [ + .noneEndMessageField, + ] + + } + + enum endObject: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEndObject // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEndObject + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEndObject + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEndObject: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endObject] = [ + .noneEndObject, + ] + + } + + enum endRegularField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEndRegularField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEndRegularField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEndRegularField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEndRegularField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endRegularField] = [ + .noneEndRegularField, + ] + + } + + enum enforceNamingStyle: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEnforceNamingStyle // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEnforceNamingStyle + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEnforceNamingStyle + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEnforceNamingStyle: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enforceNamingStyle] = [ + .noneEnforceNamingStyle, + ] + + } + + enum enumEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEnum // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEnum + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEnum + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEnum: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enumEnum] = [ + .noneEnum, + ] + + } + + enum EnumReservedRange: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEnumReservedRange // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEnumReservedRange + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEnumReservedRange + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEnumReservedRange: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.EnumReservedRange] = [ + .noneEnumReservedRange, + ] + + } + + enum enumType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEnumType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEnumType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEnumType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEnumType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enumType] = [ + .noneEnumType, + ] + + } + + enum enumvalue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEnumvalue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEnumvalue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEnumvalue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEnumvalue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enumvalue] = [ + .noneEnumvalue, + ] + + } + + enum EquatableEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneEquatable // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneEquatable + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneEquatable + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneEquatable: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.EquatableEnum] = [ + .noneEquatable, + ] + + } + + enum Error: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneError // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneError + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneError + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneError: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Error] = [ + .noneError, + ] + + } + + enum execute: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneExecute // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneExecute + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneExecute + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneExecute: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.execute] = [ + .noneExecute, + ] + + } + + enum ExpressibleByArrayLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneExpressibleByArrayLiteral // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneExpressibleByArrayLiteral + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneExpressibleByArrayLiteral + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneExpressibleByArrayLiteral: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExpressibleByArrayLiteral] = [ + .noneExpressibleByArrayLiteral, + ] + + } + + enum ExpressibleByDictionaryLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneExpressibleByDictionaryLiteral // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneExpressibleByDictionaryLiteral + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneExpressibleByDictionaryLiteral + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneExpressibleByDictionaryLiteral: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExpressibleByDictionaryLiteral] = [ + .noneExpressibleByDictionaryLiteral, + ] + + } + + enum ext: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneExt // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneExt + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneExt + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneExt: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ext] = [ + .noneExt, + ] + + } + + enum extDecoder: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneExtDecoder // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneExtDecoder + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneExtDecoder + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneExtDecoder: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extDecoder] = [ + .noneExtDecoder, + ] + + } + + enum extendedGraphemeClusterLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneExtendedGraphemeClusterLiteral // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneExtendedGraphemeClusterLiteral + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneExtendedGraphemeClusterLiteral + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneExtendedGraphemeClusterLiteral: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extendedGraphemeClusterLiteral] = [ + .noneExtendedGraphemeClusterLiteral, + ] + + } + + enum ExtendedGraphemeClusterLiteralType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneExtendedGraphemeClusterLiteralType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneExtendedGraphemeClusterLiteralType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneExtendedGraphemeClusterLiteralType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneExtendedGraphemeClusterLiteralType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtendedGraphemeClusterLiteralType] = [ + .noneExtendedGraphemeClusterLiteralType, + ] + + } + + enum extendee: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneExtendee // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneExtendee + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneExtendee + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneExtendee: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extendee] = [ + .noneExtendee, + ] + + } + + enum ExtensibleMessage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneExtensibleMessage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneExtensibleMessage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneExtensibleMessage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneExtensibleMessage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensibleMessage] = [ + .noneExtensibleMessage, + ] + + } + + enum extensionEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneExtension // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneExtension + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneExtension + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneExtension: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionEnum] = [ + .noneExtension, + ] + + } + + enum ExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneExtensionField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneExtensionField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneExtensionField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneExtensionField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionField] = [ + .noneExtensionField, + ] + + } + + enum extensionFieldNumber: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneExtensionFieldNumber // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneExtensionFieldNumber + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneExtensionFieldNumber + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneExtensionFieldNumber: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionFieldNumber] = [ + .noneExtensionFieldNumber, + ] + + } + + enum ExtensionFieldValueSet: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneExtensionFieldValueSet // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneExtensionFieldValueSet + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneExtensionFieldValueSet + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneExtensionFieldValueSet: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionFieldValueSet] = [ + .noneExtensionFieldValueSet, + ] + + } + + enum ExtensionMap: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneExtensionMap // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneExtensionMap + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneExtensionMap + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneExtensionMap: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionMap] = [ + .noneExtensionMap, + ] + + } + + enum extensionRange: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneExtensionRange // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneExtensionRange + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneExtensionRange + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneExtensionRange: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionRange] = [ + .noneExtensionRange, + ] + + } + + enum extensions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneExtensions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneExtensions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneExtensions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneExtensions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensions] = [ + .noneExtensions, + ] + + } + + enum extras: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneExtras // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneExtras + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneExtras + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneExtras: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extras] = [ + .noneExtras, + ] + + } + + enum F: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneF // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneF + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneF + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneF: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.F] = [ + .noneF, + ] + + } + + enum falseEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFalse // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFalse + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFalse + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFalse: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.falseEnum] = [ + .noneFalse, + ] + + } + + enum features: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFeatures // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFeatures + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFeatures + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFeatures: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.features] = [ + .noneFeatures, + ] + + } + + enum FeatureSetEditionDefault: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFeatureSetEditionDefault // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFeatureSetEditionDefault + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFeatureSetEditionDefault + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFeatureSetEditionDefault: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FeatureSetEditionDefault] = [ + .noneFeatureSetEditionDefault, + ] + + } + + enum featureSupport: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFeatureSupport // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFeatureSupport + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFeatureSupport + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFeatureSupport: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.featureSupport] = [ + .noneFeatureSupport, + ] + + } + + enum field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.field] = [ + .noneField, + ] + + } + + enum fieldData: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFieldData // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFieldData + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFieldData + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFieldData: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldData] = [ + .noneFieldData, + ] + + } + + enum FieldMaskError: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFieldMaskError // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFieldMaskError + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFieldMaskError + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFieldMaskError: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FieldMaskError] = [ + .noneFieldMaskError, + ] + + } + + enum fieldName: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFieldName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFieldName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFieldName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFieldName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldName] = [ + .noneFieldName, + ] + + } + + enum fieldNameCount: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFieldNameCount // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFieldNameCount + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFieldNameCount + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFieldNameCount: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNameCount] = [ + .noneFieldNameCount, + ] + + } + + enum fieldNum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFieldNum // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFieldNum + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFieldNum + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFieldNum: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNum] = [ + .noneFieldNum, + ] + + } + + enum fieldNumber: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFieldNumber // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFieldNumber + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFieldNumber + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFieldNumber: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNumber] = [ + .noneFieldNumber, + ] + + } + + enum fieldNumberForProto: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFieldNumberForProto // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFieldNumberForProto + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFieldNumberForProto + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFieldNumberForProto: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNumberForProto] = [ + .noneFieldNumberForProto, + ] + + } + + enum fieldPresence: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFieldPresence // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFieldPresence + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFieldPresence + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFieldPresence: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldPresence] = [ + .noneFieldPresence, + ] + + } + + enum fields: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFields // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFields + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFields + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFields: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fields] = [ + .noneFields, + ] + + } + + enum fieldSize: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFieldSize // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFieldSize + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFieldSize + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFieldSize: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldSize] = [ + .noneFieldSize, + ] + + } + + enum FieldTag: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFieldTag // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFieldTag + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFieldTag + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFieldTag: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FieldTag] = [ + .noneFieldTag, + ] + + } + + enum FieldType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFieldType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFieldType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFieldType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFieldType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FieldType] = [ + .noneFieldType, + ] + + } + + enum file: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFile // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFile + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFile + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFile: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.file] = [ + .noneFile, + ] + + } + + enum fileName: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFileName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFileName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFileName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFileName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fileName] = [ + .noneFileName, + ] + + } + + enum filter: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFilter // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFilter + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFilter + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFilter: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.filter] = [ + .noneFilter, + ] + + } + + enum final: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFinal // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFinal + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFinal + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFinal: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.final] = [ + .noneFinal, + ] + + } + + enum finiteOnly: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFiniteOnly // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFiniteOnly + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFiniteOnly + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFiniteOnly: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.finiteOnly] = [ + .noneFiniteOnly, + ] + + } + + enum first: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFirst // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFirst + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFirst + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFirst: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.first] = [ + .noneFirst, + ] + + } + + enum firstItem: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFirstItem // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFirstItem + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFirstItem + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFirstItem: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.firstItem] = [ + .noneFirstItem, + ] + + } + + enum fixedFeatures: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFixedFeatures // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFixedFeatures + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFixedFeatures + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFixedFeatures: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fixedFeatures] = [ + .noneFixedFeatures, + ] + + } + + enum FloatEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFloat // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFloat + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFloat + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFloat: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FloatEnum] = [ + .noneFloat, + ] + + } + + enum floatLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFloatLiteral // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFloatLiteral + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFloatLiteral + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFloatLiteral: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.floatLiteral] = [ + .noneFloatLiteral, + ] + + } + + enum FloatLiteralType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFloatLiteralType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFloatLiteralType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFloatLiteralType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFloatLiteralType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FloatLiteralType] = [ + .noneFloatLiteralType, + ] + + } + + enum forEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forEnum] = [ + .noneFor, + ] + + } + + enum forMessageName: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneForMessageName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneForMessageName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneForMessageName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneForMessageName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forMessageName] = [ + .noneForMessageName, + ] + + } + + enum formUnion: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFormUnion // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFormUnion + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFormUnion + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFormUnion: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.formUnion] = [ + .noneFormUnion, + ] + + } + + enum forReadingFrom: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneForReadingFrom // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneForReadingFrom + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneForReadingFrom + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneForReadingFrom: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forReadingFrom] = [ + .noneForReadingFrom, + ] + + } + + enum forTypeURL: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneForTypeURL // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneForTypeURL + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneForTypeURL + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneForTypeURL: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forTypeURL] = [ + .noneForTypeURL, + ] + + } + + enum ForwardParser: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneForwardParser // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneForwardParser + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneForwardParser + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneForwardParser: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ForwardParser] = [ + .noneForwardParser, + ] + + } + + enum forWritingInto: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneForWritingInto // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneForWritingInto + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneForWritingInto + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneForWritingInto: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forWritingInto] = [ + .noneForWritingInto, + ] + + } + + enum from: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFrom // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFrom + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFrom + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFrom: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.from] = [ + .noneFrom, + ] + + } + + enum fromAscii2: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFromAscii2 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFromAscii2 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFromAscii2 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFromAscii2: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromAscii2] = [ + .noneFromAscii2, + ] + + } + + enum fromAscii4: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFromAscii4 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFromAscii4 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFromAscii4 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFromAscii4: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromAscii4] = [ + .noneFromAscii4, + ] + + } + + enum fromByteOffset: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFromByteOffset // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFromByteOffset + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFromByteOffset + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFromByteOffset: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromByteOffset] = [ + .noneFromByteOffset, + ] + + } + + enum fromHexDigit: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFromHexDigit // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFromHexDigit + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFromHexDigit + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFromHexDigit: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromHexDigit] = [ + .noneFromHexDigit, + ] + + } + + enum fullName: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFullName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFullName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFullName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFullName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fullName] = [ + .noneFullName, + ] + + } + + enum funcEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFunc // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFunc + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFunc + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFunc: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.funcEnum] = [ + .noneFunc, + ] + + } + + enum function: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneFunction // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneFunction + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneFunction + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneFunction: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.function] = [ + .noneFunction, + ] + + } + + enum G: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneG // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneG + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneG + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneG: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.G] = [ + .noneG, + ] + + } + + enum get: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGet // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGet + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGet + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGet: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.get] = [ + .noneGet, + ] + + } + + enum getExtensionValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGetExtensionValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGetExtensionValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGetExtensionValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGetExtensionValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.getExtensionValue] = [ + .noneGetExtensionValue, + ] + + } + + enum Google_Protobuf_Any: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufAny // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufAny + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufAny + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufAny: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Any] = [ + .noneGoogleProtobufAny, + ] + + } + + enum Google_Protobuf_Api: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufApi // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufApi + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufApi + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufApi: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Api] = [ + .noneGoogleProtobufApi, + ] + + } + + enum Google_Protobuf_BoolValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufBoolValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufBoolValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufBoolValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufBoolValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_BoolValue] = [ + .noneGoogleProtobufBoolValue, + ] + + } + + enum Google_Protobuf_BytesValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufBytesValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufBytesValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufBytesValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufBytesValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_BytesValue] = [ + .noneGoogleProtobufBytesValue, + ] + + } + + enum Google_Protobuf_DescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufDescriptorProto // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufDescriptorProto + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufDescriptorProto + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufDescriptorProto: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_DescriptorProto] = [ + .noneGoogleProtobufDescriptorProto, + ] + + } + + enum Google_Protobuf_DoubleValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufDoubleValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufDoubleValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufDoubleValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufDoubleValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_DoubleValue] = [ + .noneGoogleProtobufDoubleValue, + ] + + } + + enum Google_Protobuf_Duration: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufDuration // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufDuration + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufDuration + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufDuration: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Duration] = [ + .noneGoogleProtobufDuration, + ] + + } + + enum Google_Protobuf_Edition: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufEdition // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufEdition + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufEdition + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufEdition: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Edition] = [ + .noneGoogleProtobufEdition, + ] + + } + + enum Google_Protobuf_Empty: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufEmpty // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufEmpty + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufEmpty + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufEmpty: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Empty] = [ + .noneGoogleProtobufEmpty, + ] + + } + + enum Google_Protobuf_Enum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufEnum // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufEnum + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufEnum + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufEnum: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Enum] = [ + .noneGoogleProtobufEnum, + ] + + } + + enum Google_Protobuf_EnumDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufEnumDescriptorProto // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufEnumDescriptorProto + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufEnumDescriptorProto + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufEnumDescriptorProto: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumDescriptorProto] = [ + .noneGoogleProtobufEnumDescriptorProto, + ] + + } + + enum Google_Protobuf_EnumOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufEnumOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufEnumOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufEnumOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufEnumOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumOptions] = [ + .noneGoogleProtobufEnumOptions, + ] + + } + + enum Google_Protobuf_EnumValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufEnumValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufEnumValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufEnumValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufEnumValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValue] = [ + .noneGoogleProtobufEnumValue, + ] + + } + + enum Google_Protobuf_EnumValueDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufEnumValueDescriptorProto // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufEnumValueDescriptorProto + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufEnumValueDescriptorProto + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufEnumValueDescriptorProto: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueDescriptorProto] = [ + .noneGoogleProtobufEnumValueDescriptorProto, + ] + + } + + enum Google_Protobuf_EnumValueOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufEnumValueOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufEnumValueOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufEnumValueOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufEnumValueOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueOptions] = [ + .noneGoogleProtobufEnumValueOptions, + ] + + } + + enum Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufExtensionRangeOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufExtensionRangeOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufExtensionRangeOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufExtensionRangeOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ExtensionRangeOptions] = [ + .noneGoogleProtobufExtensionRangeOptions, + ] + + } + + enum Google_Protobuf_FeatureSet: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufFeatureSet // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufFeatureSet + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufFeatureSet + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufFeatureSet: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FeatureSet] = [ + .noneGoogleProtobufFeatureSet, + ] + + } + + enum Google_Protobuf_FeatureSetDefaults: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufFeatureSetDefaults // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufFeatureSetDefaults + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufFeatureSetDefaults + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufFeatureSetDefaults: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FeatureSetDefaults] = [ + .noneGoogleProtobufFeatureSetDefaults, + ] + + } + + enum Google_Protobuf_Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Field] = [ + .noneGoogleProtobufField, + ] + + } + + enum Google_Protobuf_FieldDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufFieldDescriptorProto // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufFieldDescriptorProto + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufFieldDescriptorProto + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufFieldDescriptorProto: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldDescriptorProto] = [ + .noneGoogleProtobufFieldDescriptorProto, + ] + + } + + enum Google_Protobuf_FieldMask: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufFieldMask // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufFieldMask + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufFieldMask + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufFieldMask: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldMask] = [ + .noneGoogleProtobufFieldMask, + ] + + } + + enum Google_Protobuf_FieldOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufFieldOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufFieldOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufFieldOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufFieldOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldOptions] = [ + .noneGoogleProtobufFieldOptions, + ] + + } + + enum Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufFileDescriptorProto // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufFileDescriptorProto + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufFileDescriptorProto + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufFileDescriptorProto: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorProto] = [ + .noneGoogleProtobufFileDescriptorProto, + ] + + } + + enum Google_Protobuf_FileDescriptorSet: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufFileDescriptorSet // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufFileDescriptorSet + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufFileDescriptorSet + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufFileDescriptorSet: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorSet] = [ + .noneGoogleProtobufFileDescriptorSet, + ] + + } + + enum Google_Protobuf_FileOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufFileOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufFileOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufFileOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufFileOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FileOptions] = [ + .noneGoogleProtobufFileOptions, + ] + + } + + enum Google_Protobuf_FloatValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufFloatValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufFloatValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufFloatValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufFloatValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FloatValue] = [ + .noneGoogleProtobufFloatValue, + ] + + } + + enum Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufGeneratedCodeInfo // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufGeneratedCodeInfo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufGeneratedCodeInfo + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufGeneratedCodeInfo: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_GeneratedCodeInfo] = [ + .noneGoogleProtobufGeneratedCodeInfo, + ] + + } + + enum Google_Protobuf_Int32Value: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufInt32Value // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufInt32Value + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufInt32Value + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufInt32Value: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Int32Value] = [ + .noneGoogleProtobufInt32Value, + ] + + } + + enum Google_Protobuf_Int64Value: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufInt64Value // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufInt64Value + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufInt64Value + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufInt64Value: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Int64Value] = [ + .noneGoogleProtobufInt64Value, + ] + + } + + enum Google_Protobuf_ListValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufListValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufListValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufListValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufListValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ListValue] = [ + .noneGoogleProtobufListValue, + ] + + } + + enum Google_Protobuf_MessageOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufMessageOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufMessageOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufMessageOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufMessageOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_MessageOptions] = [ + .noneGoogleProtobufMessageOptions, + ] + + } + + enum Google_Protobuf_Method: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufMethod // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufMethod + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufMethod + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufMethod: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Method] = [ + .noneGoogleProtobufMethod, + ] + + } + + enum Google_Protobuf_MethodDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufMethodDescriptorProto // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufMethodDescriptorProto + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufMethodDescriptorProto + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufMethodDescriptorProto: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodDescriptorProto] = [ + .noneGoogleProtobufMethodDescriptorProto, + ] + + } + + enum Google_Protobuf_MethodOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufMethodOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufMethodOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufMethodOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufMethodOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodOptions] = [ + .noneGoogleProtobufMethodOptions, + ] + + } + + enum Google_Protobuf_Mixin: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufMixin // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufMixin + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufMixin + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufMixin: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Mixin] = [ + .noneGoogleProtobufMixin, + ] + + } + + enum Google_Protobuf_NullValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufNullValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufNullValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufNullValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufNullValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_NullValue] = [ + .noneGoogleProtobufNullValue, + ] + + } + + enum Google_Protobuf_OneofDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufOneofDescriptorProto // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufOneofDescriptorProto + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufOneofDescriptorProto + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufOneofDescriptorProto: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofDescriptorProto] = [ + .noneGoogleProtobufOneofDescriptorProto, + ] + + } + + enum Google_Protobuf_OneofOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufOneofOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufOneofOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufOneofOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufOneofOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofOptions] = [ + .noneGoogleProtobufOneofOptions, + ] + + } + + enum Google_Protobuf_Option: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufOption // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufOption + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufOption + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufOption: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Option] = [ + .noneGoogleProtobufOption, + ] + + } + + enum Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufServiceDescriptorProto // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufServiceDescriptorProto + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufServiceDescriptorProto + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufServiceDescriptorProto: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceDescriptorProto] = [ + .noneGoogleProtobufServiceDescriptorProto, + ] + + } + + enum Google_Protobuf_ServiceOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufServiceOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufServiceOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufServiceOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufServiceOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceOptions] = [ + .noneGoogleProtobufServiceOptions, + ] + + } + + enum Google_Protobuf_SourceCodeInfo: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufSourceCodeInfo // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufSourceCodeInfo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufSourceCodeInfo + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufSourceCodeInfo: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceCodeInfo] = [ + .noneGoogleProtobufSourceCodeInfo, + ] + + } + + enum Google_Protobuf_SourceContext: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufSourceContext // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufSourceContext + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufSourceContext + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufSourceContext: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceContext] = [ + .noneGoogleProtobufSourceContext, + ] + + } + + enum Google_Protobuf_StringValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufStringValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufStringValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufStringValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufStringValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_StringValue] = [ + .noneGoogleProtobufStringValue, + ] + + } + + enum Google_Protobuf_Struct: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufStruct // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufStruct + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufStruct + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufStruct: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Struct] = [ + .noneGoogleProtobufStruct, + ] + + } + + enum Google_Protobuf_SymbolVisibility: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufSymbolVisibility // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufSymbolVisibility + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufSymbolVisibility + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufSymbolVisibility: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_SymbolVisibility] = [ + .noneGoogleProtobufSymbolVisibility, + ] + + } + + enum Google_Protobuf_Syntax: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufSyntax // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufSyntax + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufSyntax + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufSyntax: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Syntax] = [ + .noneGoogleProtobufSyntax, + ] + + } + + enum Google_Protobuf_Timestamp: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufTimestamp // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufTimestamp + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufTimestamp + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufTimestamp: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Timestamp] = [ + .noneGoogleProtobufTimestamp, + ] + + } + + enum Google_Protobuf_Type: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Type] = [ + .noneGoogleProtobufType, + ] + + } + + enum Google_Protobuf_UInt32Value: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufUint32Value // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufUint32Value + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufUint32Value + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufUint32Value: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt32Value] = [ + .noneGoogleProtobufUint32Value, + ] + + } + + enum Google_Protobuf_UInt64Value: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufUint64Value // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufUint64Value + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufUint64Value + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufUint64Value: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt64Value] = [ + .noneGoogleProtobufUint64Value, + ] + + } + + enum Google_Protobuf_UninterpretedOption: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufUninterpretedOption // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufUninterpretedOption + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufUninterpretedOption + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufUninterpretedOption: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_UninterpretedOption] = [ + .noneGoogleProtobufUninterpretedOption, + ] + + } + + enum Google_Protobuf_Value: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoogleProtobufValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoogleProtobufValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoogleProtobufValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoogleProtobufValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Value] = [ + .noneGoogleProtobufValue, + ] + + } + + enum goPackage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGoPackage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGoPackage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGoPackage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGoPackage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.goPackage] = [ + .noneGoPackage, + ] + + } + + enum gotData: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGotData // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGotData + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGotData + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGotData: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.gotData] = [ + .noneGotData, + ] + + } + + enum group: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGroup // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGroup + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGroup + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGroup: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.group] = [ + .noneGroup, + ] + + } + + enum groupFieldNumberStack: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGroupFieldNumberStack // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGroupFieldNumberStack + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGroupFieldNumberStack + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGroupFieldNumberStack: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.groupFieldNumberStack] = [ + .noneGroupFieldNumberStack, + ] + + } + + enum groupSize: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGroupSize // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGroupSize + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGroupSize + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGroupSize: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.groupSize] = [ + .noneGroupSize, + ] + + } + + enum guardEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneGuard // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneGuard + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneGuard + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneGuard: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.guardEnum] = [ + .noneGuard, + ] + + } + + enum hadOneofValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHadOneofValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHadOneofValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHadOneofValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHadOneofValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hadOneofValue] = [ + .noneHadOneofValue, + ] + + } + + enum handleConflictingOneOf: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHandleConflictingOneOf // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHandleConflictingOneOf + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHandleConflictingOneOf + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHandleConflictingOneOf: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.handleConflictingOneOf] = [ + .noneHandleConflictingOneOf, + ] + + } + + enum handleInstruction: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHandleInstruction // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHandleInstruction + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHandleInstruction + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHandleInstruction: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.handleInstruction] = [ + .noneHandleInstruction, + ] + + } + + enum hasAggregateValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasAggregateValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasAggregateValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasAggregateValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasAggregateValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasAggregateValue] = [ + .noneHasAggregateValue, + ] + + } + + enum hasAllowAlias: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasAllowAlias // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasAllowAlias + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasAllowAlias + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasAllowAlias: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasAllowAlias] = [ + .noneHasAllowAlias, + ] + + } + + enum hasBegin: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasBegin // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasBegin + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasBegin + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasBegin: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasBegin] = [ + .noneHasBegin, + ] + + } + + enum hasCcEnableArenas: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasCcEnableArenas // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasCcEnableArenas + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasCcEnableArenas + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasCcEnableArenas: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCcEnableArenas] = [ + .noneHasCcEnableArenas, + ] + + } + + enum hasCcGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasCcGenericServices // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasCcGenericServices + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasCcGenericServices + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasCcGenericServices: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCcGenericServices] = [ + .noneHasCcGenericServices, + ] + + } + + enum hasClientStreaming: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasClientStreaming // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasClientStreaming + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasClientStreaming + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasClientStreaming: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasClientStreaming] = [ + .noneHasClientStreaming, + ] + + } + + enum hasCsharpNamespace: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasCsharpNamespace // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasCsharpNamespace + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasCsharpNamespace + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasCsharpNamespace: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCsharpNamespace] = [ + .noneHasCsharpNamespace, + ] + + } + + enum hasCtype: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasCtype // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasCtype + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasCtype + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasCtype: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCtype] = [ + .noneHasCtype, + ] + + } + + enum hasData: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasData // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasData + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasData + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasData: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasData] = [ + .noneHasData, + ] + + } + + enum hasDebugRedact: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasDebugRedact // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasDebugRedact + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasDebugRedact + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasDebugRedact: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDebugRedact] = [ + .noneHasDebugRedact, + ] + + } + + enum hasDefaultSymbolVisibility: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasDefaultSymbolVisibility // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasDefaultSymbolVisibility + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasDefaultSymbolVisibility + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasDefaultSymbolVisibility: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDefaultSymbolVisibility] = [ + .noneHasDefaultSymbolVisibility, + ] + + } + + enum hasDefaultValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasDefaultValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasDefaultValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasDefaultValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasDefaultValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDefaultValue] = [ + .noneHasDefaultValue, + ] + + } + + enum hasDeprecated: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasDeprecated // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasDeprecated + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasDeprecated + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasDeprecated: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDeprecated] = [ + .noneHasDeprecated, + ] + + } + + enum hasDeprecatedLegacyJsonFieldConflicts: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasDeprecatedLegacyJsonFieldConflicts // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasDeprecatedLegacyJsonFieldConflicts + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasDeprecatedLegacyJsonFieldConflicts + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasDeprecatedLegacyJsonFieldConflicts: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDeprecatedLegacyJsonFieldConflicts] = [ + .noneHasDeprecatedLegacyJsonFieldConflicts, + ] + + } + + enum hasDeprecationWarning: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasDeprecationWarning // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasDeprecationWarning + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasDeprecationWarning + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasDeprecationWarning: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDeprecationWarning] = [ + .noneHasDeprecationWarning, + ] + + } + + enum hasDoubleValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasDoubleValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasDoubleValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasDoubleValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasDoubleValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDoubleValue] = [ + .noneHasDoubleValue, + ] + + } + + enum hasEdition: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasEdition // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasEdition + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasEdition + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasEdition: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEdition] = [ + .noneHasEdition, + ] + + } + + enum hasEditionDeprecated: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasEditionDeprecated // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasEditionDeprecated + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasEditionDeprecated + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasEditionDeprecated: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEditionDeprecated] = [ + .noneHasEditionDeprecated, + ] + + } + + enum hasEditionIntroduced: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasEditionIntroduced // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasEditionIntroduced + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasEditionIntroduced + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasEditionIntroduced: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEditionIntroduced] = [ + .noneHasEditionIntroduced, + ] + + } + + enum hasEditionRemoved: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasEditionRemoved // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasEditionRemoved + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasEditionRemoved + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasEditionRemoved: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEditionRemoved] = [ + .noneHasEditionRemoved, + ] + + } + + enum hasEnd: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasEnd // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasEnd + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasEnd + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasEnd: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEnd] = [ + .noneHasEnd, + ] + + } + + enum hasEnforceNamingStyle: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasEnforceNamingStyle // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasEnforceNamingStyle + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasEnforceNamingStyle + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasEnforceNamingStyle: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEnforceNamingStyle] = [ + .noneHasEnforceNamingStyle, + ] + + } + + enum hasEnumType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasEnumType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasEnumType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasEnumType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasEnumType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEnumType] = [ + .noneHasEnumType, + ] + + } + + enum hasExplicitDelta: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasExplicitDelta // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasExplicitDelta + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasExplicitDelta + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasExplicitDelta: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasExplicitDelta] = [ + .noneHasExplicitDelta, + ] + + } + + enum hasExtendee: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasExtendee // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasExtendee + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasExtendee + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasExtendee: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasExtendee] = [ + .noneHasExtendee, + ] + + } + + enum hasExtensionValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasExtensionValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasExtensionValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasExtensionValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasExtensionValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasExtensionValue] = [ + .noneHasExtensionValue, + ] + + } + + enum hasFeatures: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasFeatures // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasFeatures + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasFeatures + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasFeatures: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFeatures] = [ + .noneHasFeatures, + ] + + } + + enum hasFeatureSupport: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasFeatureSupport // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasFeatureSupport + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasFeatureSupport + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasFeatureSupport: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFeatureSupport] = [ + .noneHasFeatureSupport, + ] + + } + + enum hasFieldPresence: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasFieldPresence // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasFieldPresence + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasFieldPresence + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasFieldPresence: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFieldPresence] = [ + .noneHasFieldPresence, + ] + + } + + enum hasFixedFeatures: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasFixedFeatures // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasFixedFeatures + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasFixedFeatures + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasFixedFeatures: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFixedFeatures] = [ + .noneHasFixedFeatures, + ] + + } + + enum hasFullName: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasFullName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasFullName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasFullName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasFullName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFullName] = [ + .noneHasFullName, + ] + + } + + enum hasGoPackage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasGoPackage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasGoPackage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasGoPackage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasGoPackage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasGoPackage] = [ + .noneHasGoPackage, + ] + + } + + enum hash: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHash // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHash + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHash + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHash: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hash] = [ + .noneHash, + ] + + } + + enum HashableEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHashable // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHashable + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHashable + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHashable: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.HashableEnum] = [ + .noneHashable, + ] + + } + + enum hasher: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasher // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasher + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasher + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasher: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasher] = [ + .noneHasher, + ] + + } + + enum HashVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHashVisitor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHashVisitor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHashVisitor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHashVisitor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.HashVisitor] = [ + .noneHashVisitor, + ] + + } + + enum hasIdempotencyLevel: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasIdempotencyLevel // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasIdempotencyLevel + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasIdempotencyLevel + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasIdempotencyLevel: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasIdempotencyLevel] = [ + .noneHasIdempotencyLevel, + ] + + } + + enum hasIdentifierValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasIdentifierValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasIdentifierValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasIdentifierValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasIdentifierValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasIdentifierValue] = [ + .noneHasIdentifierValue, + ] + + } + + enum hasInputType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasInputType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasInputType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasInputType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasInputType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasInputType] = [ + .noneHasInputType, + ] + + } + + enum hasIsExtension: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasIsExtension // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasIsExtension + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasIsExtension + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasIsExtension: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasIsExtension] = [ + .noneHasIsExtension, + ] + + } + + enum hasJavaGenerateEqualsAndHash: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasJavaGenerateEqualsAndHash // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasJavaGenerateEqualsAndHash + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasJavaGenerateEqualsAndHash + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasJavaGenerateEqualsAndHash: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaGenerateEqualsAndHash] = [ + .noneHasJavaGenerateEqualsAndHash, + ] + + } + + enum hasJavaGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasJavaGenericServices // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasJavaGenericServices + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasJavaGenericServices + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasJavaGenericServices: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaGenericServices] = [ + .noneHasJavaGenericServices, + ] + + } + + enum hasJavaMultipleFiles: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasJavaMultipleFiles // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasJavaMultipleFiles + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasJavaMultipleFiles + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasJavaMultipleFiles: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaMultipleFiles] = [ + .noneHasJavaMultipleFiles, + ] + + } + + enum hasJavaOuterClassname: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasJavaOuterClassname // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasJavaOuterClassname + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasJavaOuterClassname + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasJavaOuterClassname: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaOuterClassname] = [ + .noneHasJavaOuterClassname, + ] + + } + + enum hasJavaPackage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasJavaPackage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasJavaPackage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasJavaPackage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasJavaPackage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaPackage] = [ + .noneHasJavaPackage, + ] + + } + + enum hasJavaStringCheckUtf8: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasJavaStringCheckUtf8 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasJavaStringCheckUtf8 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasJavaStringCheckUtf8 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasJavaStringCheckUtf8: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaStringCheckUtf8] = [ + .noneHasJavaStringCheckUtf8, + ] + + } + + enum hasJsonFormat: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasJsonFormat // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasJsonFormat + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasJsonFormat + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasJsonFormat: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJsonFormat] = [ + .noneHasJsonFormat, + ] + + } + + enum hasJsonName: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasJsonName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasJsonName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasJsonName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasJsonName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJsonName] = [ + .noneHasJsonName, + ] + + } + + enum hasJstype: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasJstype // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasJstype + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasJstype + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasJstype: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJstype] = [ + .noneHasJstype, + ] + + } + + enum hasLabel: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasLabel // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasLabel + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasLabel + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasLabel: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasLabel] = [ + .noneHasLabel, + ] + + } + + enum hasLazy: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasLazy // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasLazy + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasLazy + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasLazy: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasLazy] = [ + .noneHasLazy, + ] + + } + + enum hasLeadingComments: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasLeadingComments // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasLeadingComments + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasLeadingComments + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasLeadingComments: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasLeadingComments] = [ + .noneHasLeadingComments, + ] + + } + + enum hasMapEntry: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasMapEntry // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasMapEntry + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasMapEntry + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasMapEntry: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMapEntry] = [ + .noneHasMapEntry, + ] + + } + + enum hasMaximumEdition: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasMaximumEdition // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasMaximumEdition + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasMaximumEdition + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasMaximumEdition: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMaximumEdition] = [ + .noneHasMaximumEdition, + ] + + } + + enum hasMessageEncoding: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasMessageEncoding // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasMessageEncoding + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasMessageEncoding + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasMessageEncoding: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMessageEncoding] = [ + .noneHasMessageEncoding, + ] + + } + + enum hasMessageSetWireFormat: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasMessageSetWireFormat // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasMessageSetWireFormat + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasMessageSetWireFormat + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasMessageSetWireFormat: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMessageSetWireFormat] = [ + .noneHasMessageSetWireFormat, + ] + + } + + enum hasMinimumEdition: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasMinimumEdition // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasMinimumEdition + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasMinimumEdition + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasMinimumEdition: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMinimumEdition] = [ + .noneHasMinimumEdition, + ] + + } + + enum hasName: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasName] = [ + .noneHasName, + ] + + } + + enum hasNamePart: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasNamePart // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasNamePart + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasNamePart + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasNamePart: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNamePart] = [ + .noneHasNamePart, + ] + + } + + enum hasNegativeIntValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasNegativeIntValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasNegativeIntValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasNegativeIntValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasNegativeIntValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNegativeIntValue] = [ + .noneHasNegativeIntValue, + ] + + } + + enum hasNoStandardDescriptorAccessor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasNoStandardDescriptorAccessor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasNoStandardDescriptorAccessor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasNoStandardDescriptorAccessor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasNoStandardDescriptorAccessor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNoStandardDescriptorAccessor] = [ + .noneHasNoStandardDescriptorAccessor, + ] + + } + + enum hasNumber: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasNumber // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasNumber + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasNumber + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasNumber: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNumber] = [ + .noneHasNumber, + ] + + } + + enum hasObjcClassPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasObjcClassPrefix // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasObjcClassPrefix + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasObjcClassPrefix + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasObjcClassPrefix: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasObjcClassPrefix] = [ + .noneHasObjcClassPrefix, + ] + + } + + enum hasOneofIndex: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasOneofIndex // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasOneofIndex + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasOneofIndex + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasOneofIndex: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOneofIndex] = [ + .noneHasOneofIndex, + ] + + } + + enum hasOptimizeFor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasOptimizeFor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasOptimizeFor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasOptimizeFor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasOptimizeFor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOptimizeFor] = [ + .noneHasOptimizeFor, + ] + + } + + enum hasOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOptions] = [ + .noneHasOptions, + ] + + } + + enum hasOutputType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasOutputType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasOutputType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasOutputType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasOutputType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOutputType] = [ + .noneHasOutputType, + ] + + } + + enum hasOverridableFeatures: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasOverridableFeatures // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasOverridableFeatures + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasOverridableFeatures + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasOverridableFeatures: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOverridableFeatures] = [ + .noneHasOverridableFeatures, + ] + + } + + enum hasPackage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasPackage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasPackage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasPackage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasPackage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPackage] = [ + .noneHasPackage, + ] + + } + + enum hasPacked: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasPacked // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasPacked + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasPacked + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasPacked: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPacked] = [ + .noneHasPacked, + ] + + } + + enum hasPhpClassPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasPhpClassPrefix // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasPhpClassPrefix + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasPhpClassPrefix + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasPhpClassPrefix: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPhpClassPrefix] = [ + .noneHasPhpClassPrefix, + ] + + } + + enum hasPhpMetadataNamespace: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasPhpMetadataNamespace // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasPhpMetadataNamespace + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasPhpMetadataNamespace + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasPhpMetadataNamespace: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPhpMetadataNamespace] = [ + .noneHasPhpMetadataNamespace, + ] + + } + + enum hasPhpNamespace: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasPhpNamespace // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasPhpNamespace + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasPhpNamespace + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasPhpNamespace: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPhpNamespace] = [ + .noneHasPhpNamespace, + ] + + } + + enum hasPositiveIntValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasPositiveIntValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasPositiveIntValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasPositiveIntValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasPositiveIntValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPositiveIntValue] = [ + .noneHasPositiveIntValue, + ] + + } + + enum hasProto3Optional: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasProto3Optional // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasProto3Optional + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasProto3Optional + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasProto3Optional: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasProto3Optional] = [ + .noneHasProto3Optional, + ] + + } + + enum hasPyGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasPyGenericServices // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasPyGenericServices + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasPyGenericServices + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasPyGenericServices: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPyGenericServices] = [ + .noneHasPyGenericServices, + ] + + } + + enum hasRemovalError: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasRemovalError // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasRemovalError + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasRemovalError + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasRemovalError: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRemovalError] = [ + .noneHasRemovalError, + ] + + } + + enum hasRepeated: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasRepeated // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasRepeated + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasRepeated + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasRepeated: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRepeated] = [ + .noneHasRepeated, + ] + + } + + enum hasRepeatedFieldEncoding: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasRepeatedFieldEncoding // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasRepeatedFieldEncoding + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasRepeatedFieldEncoding + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasRepeatedFieldEncoding: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRepeatedFieldEncoding] = [ + .noneHasRepeatedFieldEncoding, + ] + + } + + enum hasReserved: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasReserved // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasReserved + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasReserved + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasReserved: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasReserved] = [ + .noneHasReserved, + ] + + } + + enum hasRetention: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasRetention // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasRetention + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasRetention + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasRetention: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRetention] = [ + .noneHasRetention, + ] + + } + + enum hasRubyPackage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasRubyPackage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasRubyPackage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasRubyPackage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasRubyPackage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRubyPackage] = [ + .noneHasRubyPackage, + ] + + } + + enum hasSemantic: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasSemantic // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasSemantic + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasSemantic + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasSemantic: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSemantic] = [ + .noneHasSemantic, + ] + + } + + enum hasServerStreaming: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasServerStreaming // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasServerStreaming + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasServerStreaming + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasServerStreaming: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasServerStreaming] = [ + .noneHasServerStreaming, + ] + + } + + enum hasSourceCodeInfo: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasSourceCodeInfo // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasSourceCodeInfo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasSourceCodeInfo + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasSourceCodeInfo: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSourceCodeInfo] = [ + .noneHasSourceCodeInfo, + ] + + } + + enum hasSourceContext: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasSourceContext // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasSourceContext + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasSourceContext + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasSourceContext: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSourceContext] = [ + .noneHasSourceContext, + ] + + } + + enum hasSourceFile: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasSourceFile // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasSourceFile + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasSourceFile + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasSourceFile: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSourceFile] = [ + .noneHasSourceFile, + ] + + } + + enum hasStart: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasStart // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasStart + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasStart + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasStart: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasStart] = [ + .noneHasStart, + ] + + } + + enum hasStringValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasStringValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasStringValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasStringValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasStringValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasStringValue] = [ + .noneHasStringValue, + ] + + } + + enum hasSwiftPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasSwiftPrefix // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasSwiftPrefix + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasSwiftPrefix + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasSwiftPrefix: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSwiftPrefix] = [ + .noneHasSwiftPrefix, + ] + + } + + enum hasSyntax: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasSyntax // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasSyntax + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasSyntax + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasSyntax: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSyntax] = [ + .noneHasSyntax, + ] + + } + + enum hasTrailingComments: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasTrailingComments // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasTrailingComments + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasTrailingComments + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasTrailingComments: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasTrailingComments] = [ + .noneHasTrailingComments, + ] + + } + + enum hasType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasType] = [ + .noneHasType, + ] + + } + + enum hasTypeName: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasTypeName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasTypeName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasTypeName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasTypeName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasTypeName] = [ + .noneHasTypeName, + ] + + } + + enum hasUnverifiedLazy: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasUnverifiedLazy // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasUnverifiedLazy + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasUnverifiedLazy + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasUnverifiedLazy: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasUnverifiedLazy] = [ + .noneHasUnverifiedLazy, + ] + + } + + enum hasUtf8Validation: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasUtf8Validation // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasUtf8Validation + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasUtf8Validation + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasUtf8Validation: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasUtf8Validation] = [ + .noneHasUtf8Validation, + ] + + } + + enum hasValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasValue] = [ + .noneHasValue, + ] + + } + + enum hasVerification: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasVerification // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasVerification + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasVerification + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasVerification: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasVerification] = [ + .noneHasVerification, + ] + + } + + enum hasVisibility: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasVisibility // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasVisibility + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasVisibility + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasVisibility: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasVisibility] = [ + .noneHasVisibility, + ] + + } + + enum hasWeak: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHasWeak // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHasWeak + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHasWeak + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHasWeak: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasWeak] = [ + .noneHasWeak, + ] + + } + + enum hour: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneHour // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneHour + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneHour + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneHour: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hour] = [ + .noneHour, + ] + + } + + enum i: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneI // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneI + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneI + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneI: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.i] = [ + .noneI, + ] + + } + + enum idempotencyLevel: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIdempotencyLevel // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIdempotencyLevel + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIdempotencyLevel + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIdempotencyLevel: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.idempotencyLevel] = [ + .noneIdempotencyLevel, + ] + + } + + enum identifierValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIdentifierValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIdentifierValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIdentifierValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIdentifierValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.identifierValue] = [ + .noneIdentifierValue, + ] + + } + + enum ifEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIf // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIf + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIf + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIf: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ifEnum] = [ + .noneIf, + ] + + } + + enum ignoreUnknownExtensionFields: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIgnoreUnknownExtensionFields // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIgnoreUnknownExtensionFields + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIgnoreUnknownExtensionFields + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIgnoreUnknownExtensionFields: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ignoreUnknownExtensionFields] = [ + .noneIgnoreUnknownExtensionFields, + ] + + } + + enum ignoreUnknownFields: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIgnoreUnknownFields // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIgnoreUnknownFields + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIgnoreUnknownFields + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIgnoreUnknownFields: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ignoreUnknownFields] = [ + .noneIgnoreUnknownFields, + ] + + } + + enum index: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIndex // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIndex + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIndex + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIndex: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.index] = [ + .noneIndex, + ] + + } + + enum initEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneInit // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneInit + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneInit + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneInit: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.initEnum] = [ + .noneInit, + ] + + } + + enum inoutEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneInout // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneInout + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneInout + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneInout: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.inoutEnum] = [ + .noneInout, + ] + + } + + enum inputType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneInputType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneInputType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneInputType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneInputType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.inputType] = [ + .noneInputType, + ] + + } + + enum insert: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneInsert // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneInsert + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneInsert + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneInsert: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.insert] = [ + .noneInsert, + ] + + } + + enum Instruction: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneInstruction // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneInstruction + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneInstruction + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneInstruction: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Instruction] = [ + .noneInstruction, + ] + + } + + enum IntEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneInt // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneInt + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneInt + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneInt: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.IntEnum] = [ + .noneInt, + ] + + } + + enum Int32Enum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneInt32 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneInt32 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneInt32 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneInt32: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Int32Enum] = [ + .noneInt32, + ] + + } + + enum Int64Enum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneInt64 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneInt64 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneInt64 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneInt64: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Int64Enum] = [ + .noneInt64, + ] + + } + + enum Int8: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneInt8 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneInt8 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneInt8 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneInt8: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Int8] = [ + .noneInt8, + ] + + } + + enum integerLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIntegerLiteral // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIntegerLiteral + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIntegerLiteral + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIntegerLiteral: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.integerLiteral] = [ + .noneIntegerLiteral, + ] + + } + + enum IntegerLiteralType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIntegerLiteralType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIntegerLiteralType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIntegerLiteralType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIntegerLiteralType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.IntegerLiteralType] = [ + .noneIntegerLiteralType, + ] + + } + + enum intern: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIntern // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIntern + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIntern + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIntern: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.intern] = [ + .noneIntern, + ] + + } + + enum Internal: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneInternal // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneInternal + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneInternal + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneInternal: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Internal] = [ + .noneInternal, + ] + + } + + enum InternalState: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneInternalState // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneInternalState + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneInternalState + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneInternalState: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.InternalState] = [ + .noneInternalState, + ] + + } + + enum intersect: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIntersect // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIntersect + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIntersect + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIntersect: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.intersect] = [ + .noneIntersect, + ] + + } + + enum into: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneInto // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneInto + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneInto + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneInto: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.into] = [ + .noneInto, + ] + + } + + enum ints: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneInts // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneInts + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneInts + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneInts: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ints] = [ + .noneInts, + ] + + } + + enum invalidAnyTypeURL: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneInvalidAnyTypeURL // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneInvalidAnyTypeURL + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneInvalidAnyTypeURL + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneInvalidAnyTypeURL: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.invalidAnyTypeURL] = [ + .noneInvalidAnyTypeURL, + ] + + } + + enum isA: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIsA // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIsA + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIsA + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIsA: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isA] = [ + .noneIsA, + ] + + } + + enum isEqual: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIsEqual // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIsEqual + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIsEqual + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIsEqual: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isEqual] = [ + .noneIsEqual, + ] + + } + + enum isEqualTo: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIsEqualTo // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIsEqualTo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIsEqualTo + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIsEqualTo: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isEqualTo] = [ + .noneIsEqualTo, + ] + + } + + enum isExtension: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIsExtension // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIsExtension + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIsExtension + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIsExtension: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isExtension] = [ + .noneIsExtension, + ] + + } + + enum isInitializedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIsInitialized // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIsInitialized + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIsInitialized + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIsInitialized: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isInitializedEnum] = [ + .noneIsInitialized, + ] + + } + + enum isNegative: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIsNegative // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIsNegative + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIsNegative + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIsNegative: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isNegative] = [ + .noneIsNegative, + ] + + } + + enum isPathValid: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIsPathValid // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIsPathValid + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIsPathValid + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIsPathValid: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isPathValid] = [ + .noneIsPathValid, + ] + + } + + enum isReserved: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIsReserved // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIsReserved + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIsReserved + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIsReserved: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isReserved] = [ + .noneIsReserved, + ] + + } + + enum isValid: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIsValid // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIsValid + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIsValid + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIsValid: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isValid] = [ + .noneIsValid, + ] + + } + + enum itemTagsEncodedSize: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneItemTagsEncodedSize // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneItemTagsEncodedSize + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneItemTagsEncodedSize + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneItemTagsEncodedSize: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.itemTagsEncodedSize] = [ + .noneItemTagsEncodedSize, + ] + + } + + enum iterator: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneIterator // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneIterator + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneIterator + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneIterator: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.iterator] = [ + .noneIterator, + ] + + } + + enum javaGenerateEqualsAndHash: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJavaGenerateEqualsAndHash // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJavaGenerateEqualsAndHash + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJavaGenerateEqualsAndHash + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJavaGenerateEqualsAndHash: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaGenerateEqualsAndHash] = [ + .noneJavaGenerateEqualsAndHash, + ] + + } + + enum javaGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJavaGenericServices // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJavaGenericServices + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJavaGenericServices + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJavaGenericServices: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaGenericServices] = [ + .noneJavaGenericServices, + ] + + } + + enum javaMultipleFiles: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJavaMultipleFiles // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJavaMultipleFiles + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJavaMultipleFiles + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJavaMultipleFiles: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaMultipleFiles] = [ + .noneJavaMultipleFiles, + ] + + } + + enum javaOuterClassname: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJavaOuterClassname // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJavaOuterClassname + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJavaOuterClassname + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJavaOuterClassname: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaOuterClassname] = [ + .noneJavaOuterClassname, + ] + + } + + enum javaPackage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJavaPackage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJavaPackage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJavaPackage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJavaPackage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaPackage] = [ + .noneJavaPackage, + ] + + } + + enum javaStringCheckUtf8: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJavaStringCheckUtf8 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJavaStringCheckUtf8 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJavaStringCheckUtf8 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJavaStringCheckUtf8: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaStringCheckUtf8] = [ + .noneJavaStringCheckUtf8, + ] + + } + + enum JSONDecoder: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsondecoder // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsondecoder + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsondecoder + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsondecoder: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecoder] = [ + .noneJsondecoder, + ] + + } + + enum JSONDecoding: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsondecoding // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsondecoding + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsondecoding + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsondecoding: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecoding] = [ + .noneJsondecoding, + ] + + } + + enum JSONDecodingError: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsondecodingError // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsondecodingError + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsondecodingError + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsondecodingError: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecodingError] = [ + .noneJsondecodingError, + ] + + } + + enum JSONDecodingOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsondecodingOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsondecodingOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsondecodingOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsondecodingOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecodingOptions] = [ + .noneJsondecodingOptions, + ] + + } + + enum jsonEncoder: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsonEncoder // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsonEncoder + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsonEncoder + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsonEncoder: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonEncoder] = [ + .noneJsonEncoder, + ] + + } + + enum JSONEncoding: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsonencoding // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsonencoding + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsonencoding + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsonencoding: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncoding] = [ + .noneJsonencoding, + ] + + } + + enum JSONEncodingError: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsonencodingError // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsonencodingError + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsonencodingError + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsonencodingError: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncodingError] = [ + .noneJsonencodingError, + ] + + } + + enum JSONEncodingOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsonencodingOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsonencodingOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsonencodingOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsonencodingOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncodingOptions] = [ + .noneJsonencodingOptions, + ] + + } + + enum JSONEncodingVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsonencodingVisitor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsonencodingVisitor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsonencodingVisitor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsonencodingVisitor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncodingVisitor] = [ + .noneJsonencodingVisitor, + ] + + } + + enum jsonFormat: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsonFormat // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsonFormat + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsonFormat + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsonFormat: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonFormat] = [ + .noneJsonFormat, + ] + + } + + enum JSONMapEncodingVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsonmapEncodingVisitor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsonmapEncodingVisitor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsonmapEncodingVisitor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsonmapEncodingVisitor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONMapEncodingVisitor] = [ + .noneJsonmapEncodingVisitor, + ] + + } + + enum jsonName: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsonName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsonName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsonName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsonName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonName] = [ + .noneJsonName, + ] + + } + + enum jsonPath: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsonPath // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsonPath + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsonPath + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsonPath: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonPath] = [ + .noneJsonPath, + ] + + } + + enum jsonPaths: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsonPaths // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsonPaths + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsonPaths + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsonPaths: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonPaths] = [ + .noneJsonPaths, + ] + + } + + enum JSONScanner: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsonscanner // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsonscanner + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsonscanner + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsonscanner: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONScanner] = [ + .noneJsonscanner, + ] + + } + + enum jsonString: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsonString // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsonString + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsonString + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsonString: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonString] = [ + .noneJsonString, + ] + + } + + enum jsonText: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsonText // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsonText + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsonText + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsonText: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonText] = [ + .noneJsonText, + ] + + } + + enum jsonUTF8Bytes: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsonUtf8Bytes // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsonUtf8Bytes + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsonUtf8Bytes + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsonUtf8Bytes: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonUTF8Bytes] = [ + .noneJsonUtf8Bytes, + ] + + } + + enum jsonUTF8Data: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJsonUtf8Data // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJsonUtf8Data + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJsonUtf8Data + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJsonUtf8Data: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonUTF8Data] = [ + .noneJsonUtf8Data, + ] + + } + + enum jstype: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneJstype // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneJstype + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneJstype + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneJstype: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jstype] = [ + .noneJstype, + ] + + } + + enum k: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneK // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneK + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneK + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneK: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.k] = [ + .noneK, + ] + + } + + enum kChunkSize: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneKChunkSize // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneKChunkSize + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneKChunkSize + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneKChunkSize: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.kChunkSize] = [ + .noneKChunkSize, + ] + + } + + enum Key: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneKey // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneKey + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneKey + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneKey: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Key] = [ + .noneKey, + ] + + } + + enum keyField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneKeyField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneKeyField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneKeyField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneKeyField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.keyField] = [ + .noneKeyField, + ] + + } + + enum keyFieldOpt: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneKeyFieldOpt // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneKeyFieldOpt + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneKeyFieldOpt + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneKeyFieldOpt: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.keyFieldOpt] = [ + .noneKeyFieldOpt, + ] + + } + + enum KeyType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneKeyType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneKeyType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneKeyType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneKeyType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.KeyType] = [ + .noneKeyType, + ] + + } + + enum kind: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneKind // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneKind + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneKind + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneKind: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.kind] = [ + .noneKind, + ] + + } + + enum l: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneL // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneL + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneL + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneL: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.l] = [ + .noneL, + ] + + } + + enum label: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneLabel // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneLabel + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneLabel + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneLabel: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.label] = [ + .noneLabel, + ] + + } + + enum lazy: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneLazy // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneLazy + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneLazy + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneLazy: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.lazy] = [ + .noneLazy, + ] + + } + + enum leadingComments: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneLeadingComments // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneLeadingComments + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneLeadingComments + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneLeadingComments: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.leadingComments] = [ + .noneLeadingComments, + ] + + } + + enum leadingDetachedComments: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneLeadingDetachedComments // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneLeadingDetachedComments + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneLeadingDetachedComments + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneLeadingDetachedComments: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.leadingDetachedComments] = [ + .noneLeadingDetachedComments, + ] + + } + + enum length: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneLength // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneLength + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneLength + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneLength: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.length] = [ + .noneLength, + ] + + } + + enum lessThan: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneLessThan // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneLessThan + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneLessThan + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneLessThan: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.lessThan] = [ + .noneLessThan, + ] + + } + + enum letEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneLet // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneLet + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneLet + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneLet: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.letEnum] = [ + .noneLet, + ] + + } + + enum lhs: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneLhs // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneLhs + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneLhs + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneLhs: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.lhs] = [ + .noneLhs, + ] + + } + + enum line: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneLine // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneLine + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneLine + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneLine: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.line] = [ + .noneLine, + ] + + } + + enum list: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneList // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneList + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneList + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneList: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.list] = [ + .noneList, + ] + + } + + enum listOfMessages: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneListOfMessages // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneListOfMessages + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneListOfMessages + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneListOfMessages: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.listOfMessages] = [ + .noneListOfMessages, + ] + + } + + enum listValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneListValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneListValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneListValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneListValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.listValue] = [ + .noneListValue, + ] + + } + + enum littleEndian: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneLittleEndian // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneLittleEndian + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneLittleEndian + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneLittleEndian: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.littleEndian] = [ + .noneLittleEndian, + ] + + } + + enum load: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneLoad // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneLoad + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneLoad + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneLoad: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.load] = [ + .noneLoad, + ] + + } + + enum localHasher: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneLocalHasher // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneLocalHasher + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneLocalHasher + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneLocalHasher: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.localHasher] = [ + .noneLocalHasher, + ] + + } + + enum location: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneLocation // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneLocation + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneLocation + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneLocation: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.location] = [ + .noneLocation, + ] + + } + + enum M: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneM // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneM + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneM + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneM: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.M] = [ + .noneM, + ] + + } + + enum major: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMajor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMajor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMajor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMajor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.major] = [ + .noneMajor, + ] + + } + + enum makeAsyncIterator: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMakeAsyncIterator // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMakeAsyncIterator + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMakeAsyncIterator + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMakeAsyncIterator: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.makeAsyncIterator] = [ + .noneMakeAsyncIterator, + ] + + } + + enum makeIterator: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMakeIterator // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMakeIterator + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMakeIterator + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMakeIterator: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.makeIterator] = [ + .noneMakeIterator, + ] + + } + + enum malformedLength: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMalformedLength // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMalformedLength + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMalformedLength + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMalformedLength: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.malformedLength] = [ + .noneMalformedLength, + ] + + } + + enum mapEntry: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMapEntry // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMapEntry + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMapEntry + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMapEntry: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapEntry] = [ + .noneMapEntry, + ] + + } + + enum MapKeyType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMapKeyType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMapKeyType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMapKeyType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMapKeyType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MapKeyType] = [ + .noneMapKeyType, + ] + + } + + enum mapToMessages: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMapToMessages // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMapToMessages + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMapToMessages + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMapToMessages: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapToMessages] = [ + .noneMapToMessages, + ] + + } + + enum MapValueType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMapValueType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMapValueType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMapValueType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMapValueType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MapValueType] = [ + .noneMapValueType, + ] + + } + + enum mapVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMapVisitor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMapVisitor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMapVisitor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMapVisitor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapVisitor] = [ + .noneMapVisitor, + ] + + } + + enum mask: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMask // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMask + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMask + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMask: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mask] = [ + .noneMask, + ] + + } + + enum maximumEdition: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMaximumEdition // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMaximumEdition + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMaximumEdition + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMaximumEdition: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.maximumEdition] = [ + .noneMaximumEdition, + ] + + } + + enum mdayStart: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMdayStart // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMdayStart + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMdayStart + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMdayStart: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mdayStart] = [ + .noneMdayStart, + ] + + } + + enum merge: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMerge // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMerge + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMerge + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMerge: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.merge] = [ + .noneMerge, + ] + + } + + enum MergeOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMergeOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMergeOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMergeOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMergeOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MergeOptions] = [ + .noneMergeOptions, + ] + + } + + enum message: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMessage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMessage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMessage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMessage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.message] = [ + .noneMessage, + ] + + } + + enum messageDepthLimit: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMessageDepthLimit // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMessageDepthLimit + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMessageDepthLimit + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMessageDepthLimit: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageDepthLimit] = [ + .noneMessageDepthLimit, + ] + + } + + enum messageEncoding: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMessageEncoding // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMessageEncoding + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMessageEncoding + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMessageEncoding: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageEncoding] = [ + .noneMessageEncoding, + ] + + } + + enum MessageExtension: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMessageExtension // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMessageExtension + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMessageExtension + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMessageExtension: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MessageExtension] = [ + .noneMessageExtension, + ] + + } + + enum MessageImplementationBase: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMessageImplementationBase // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMessageImplementationBase + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMessageImplementationBase + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMessageImplementationBase: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MessageImplementationBase] = [ + .noneMessageImplementationBase, + ] + + } + + enum MessageSet: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMessageSet // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMessageSet + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMessageSet + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMessageSet: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MessageSet] = [ + .noneMessageSet, + ] + + } + + enum messageSetWireFormat: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMessageSetWireFormat // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMessageSetWireFormat + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMessageSetWireFormat + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMessageSetWireFormat: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageSetWireFormat] = [ + .noneMessageSetWireFormat, + ] + + } + + enum messageSize: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMessageSize // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMessageSize + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMessageSize + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMessageSize: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageSize] = [ + .noneMessageSize, + ] + + } + + enum messageType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMessageType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMessageType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMessageType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMessageType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageType] = [ + .noneMessageType, + ] + + } + + enum method: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMethod // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMethod + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMethod + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMethod: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.method] = [ + .noneMethod, + ] + + } + + enum methods: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMethods // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMethods + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMethods + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMethods: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.methods] = [ + .noneMethods, + ] + + } + + enum min: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMin // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMin + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMin + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMin: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.min] = [ + .noneMin, + ] + + } + + enum minimumEdition: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMinimumEdition // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMinimumEdition + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMinimumEdition + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMinimumEdition: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.minimumEdition] = [ + .noneMinimumEdition, + ] + + } + + enum minor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMinor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMinor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMinor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMinor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.minor] = [ + .noneMinor, + ] + + } + + enum mixins: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMixins // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMixins + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMixins + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMixins: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mixins] = [ + .noneMixins, + ] + + } + + enum modify: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneModify // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneModify + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneModify + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneModify: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.modify] = [ + .noneModify, + ] + + } + + enum month: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMonth // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMonth + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMonth + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMonth: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.month] = [ + .noneMonth, + ] + + } + + enum msgExtension: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMsgExtension // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMsgExtension + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMsgExtension + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMsgExtension: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.msgExtension] = [ + .noneMsgExtension, + ] + + } + + enum mutating: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneMutating // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneMutating + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneMutating + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneMutating: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mutating] = [ + .noneMutating, + ] + + } + + enum n: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case oneN // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .oneN + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .oneN + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .oneN: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.n] = [ + .oneN, + ] + + } + + enum name: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.name] = [ + .noneName, + ] + + } + + enum NameDescription: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNameDescription // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNameDescription + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNameDescription + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNameDescription: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.NameDescription] = [ + .noneNameDescription, + ] + + } + + enum NameMap: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNameMap // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNameMap + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNameMap + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNameMap: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.NameMap] = [ + .noneNameMap, + ] + + } + + enum NamePart: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNamePart // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNamePart + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNamePart + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNamePart: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.NamePart] = [ + .noneNamePart, + ] + + } + + enum names: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNames // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNames + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNames + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNames: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.names] = [ + .noneNames, + ] + + } + + enum nanos: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNanos // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNanos + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNanos + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNanos: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nanos] = [ + .noneNanos, + ] + + } + + enum negativeIntValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNegativeIntValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNegativeIntValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNegativeIntValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNegativeIntValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.negativeIntValue] = [ + .noneNegativeIntValue, + ] + + } + + enum nestedType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNestedType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNestedType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNestedType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNestedType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nestedType] = [ + .noneNestedType, + ] + + } + + enum newExtensible: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNewExtensible // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNewExtensible + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNewExtensible + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNewExtensible: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newExtensible] = [ + .noneNewExtensible, + ] + + } + + enum newL: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNewL // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNewL + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNewL + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNewL: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newL] = [ + .noneNewL, + ] + + } + + enum newList: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNewList // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNewList + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNewList + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNewList: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newList] = [ + .noneNewList, + ] + + } + + enum newMessage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNewMessage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNewMessage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNewMessage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNewMessage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newMessage] = [ + .noneNewMessage, + ] + + } + + enum newValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNewValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNewValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNewValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNewValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newValue] = [ + .noneNewValue, + ] + + } + + enum next: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNext // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNext + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNext + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNext: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.next] = [ + .noneNext, + ] + + } + + enum nextByte: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNextByte // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNextByte + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNextByte + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNextByte: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextByte] = [ + .noneNextByte, + ] + + } + + enum nextFieldNumber: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNextFieldNumber // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNextFieldNumber + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNextFieldNumber + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNextFieldNumber: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextFieldNumber] = [ + .noneNextFieldNumber, + ] + + } + + enum nextInstruction: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNextInstruction // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNextInstruction + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNextInstruction + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNextInstruction: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextInstruction] = [ + .noneNextInstruction, + ] + + } + + enum nextInt32: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNextInt32 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNextInt32 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNextInt32 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNextInt32: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextInt32] = [ + .noneNextInt32, + ] + + } + + enum nextNullTerminatedString: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNextNullTerminatedString // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNextNullTerminatedString + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNextNullTerminatedString + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNextNullTerminatedString: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextNullTerminatedString] = [ + .noneNextNullTerminatedString, + ] + + } + + enum nextNullTerminatedStringArray: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNextNullTerminatedStringArray // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNextNullTerminatedStringArray + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNextNullTerminatedStringArray + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNextNullTerminatedStringArray: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextNullTerminatedStringArray] = [ + .noneNextNullTerminatedStringArray, + ] + + } + + enum nextNumber: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNextNumber // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNextNumber + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNextNumber + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNextNumber: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextNumber] = [ + .noneNextNumber, + ] + + } + + enum nextUInt64: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNextUint64 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNextUint64 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNextUint64 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNextUint64: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextUInt64] = [ + .noneNextUint64, + ] + + } + + enum nextVarInt: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNextVarInt // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNextVarInt + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNextVarInt + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNextVarInt: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextVarInt] = [ + .noneNextVarInt, + ] + + } + + enum nilEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNil // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNil + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNil + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNil: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nilEnum] = [ + .noneNil, + ] + + } + + enum nilLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNilLiteral // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNilLiteral + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNilLiteral + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNilLiteral: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nilLiteral] = [ + .noneNilLiteral, + ] + + } + + enum noBytesAvailable: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNoBytesAvailable // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNoBytesAvailable + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNoBytesAvailable + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNoBytesAvailable: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.noBytesAvailable] = [ + .noneNoBytesAvailable, + ] + + } + + enum noStandardDescriptorAccessor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNoStandardDescriptorAccessor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNoStandardDescriptorAccessor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNoStandardDescriptorAccessor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNoStandardDescriptorAccessor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.noStandardDescriptorAccessor] = [ + .noneNoStandardDescriptorAccessor, + ] + + } + + enum nullValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNullValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNullValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNullValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNullValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nullValue] = [ + .noneNullValue, + ] + + } + + enum number: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNumber // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNumber + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNumber + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNumber: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.number] = [ + .noneNumber, + ] + + } + + enum numberValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneNumberValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneNumberValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneNumberValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneNumberValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.numberValue] = [ + .noneNumberValue, + ] + + } + + enum objcClassPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneObjcClassPrefix // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneObjcClassPrefix + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneObjcClassPrefix + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneObjcClassPrefix: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.objcClassPrefix] = [ + .noneObjcClassPrefix, + ] + + } + + enum of: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOf // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOf + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOf + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOf: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.of] = [ + .noneOf, + ] + + } + + enum OneOf_Kind: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOneOfKind // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOneOfKind + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOneOfKind + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOneOfKind: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OneOf_Kind] = [ + .noneOneOfKind, + ] + + } + + enum oneofDecl: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOneofDecl // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOneofDecl + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOneofDecl + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOneofDecl: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofDecl] = [ + .noneOneofDecl, + ] + + } + + enum oneofIndex: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOneofIndex // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOneofIndex + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOneofIndex + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOneofIndex: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofIndex] = [ + .noneOneofIndex, + ] + + } + + enum oneofs: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOneofs // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOneofs + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOneofs + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOneofs: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofs] = [ + .noneOneofs, + ] + + } + + enum optimizeFor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOptimizeFor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOptimizeFor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOptimizeFor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOptimizeFor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.optimizeFor] = [ + .noneOptimizeFor, + ] + + } + + enum OptimizeMode: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOptimizeMode // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOptimizeMode + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOptimizeMode + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOptimizeMode: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptimizeMode] = [ + .noneOptimizeMode, + ] + + } + + enum OptionalEnumExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOptionalEnumExtensionField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOptionalEnumExtensionField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOptionalEnumExtensionField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOptionalEnumExtensionField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalEnumExtensionField] = [ + .noneOptionalEnumExtensionField, + ] + + } + + enum OptionalExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOptionalExtensionField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOptionalExtensionField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOptionalExtensionField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOptionalExtensionField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalExtensionField] = [ + .noneOptionalExtensionField, + ] + + } + + enum OptionalGroupExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOptionalGroupExtensionField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOptionalGroupExtensionField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOptionalGroupExtensionField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOptionalGroupExtensionField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalGroupExtensionField] = [ + .noneOptionalGroupExtensionField, + ] + + } + + enum OptionalMessageExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOptionalMessageExtensionField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOptionalMessageExtensionField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOptionalMessageExtensionField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOptionalMessageExtensionField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalMessageExtensionField] = [ + .noneOptionalMessageExtensionField, + ] + + } + + enum optionDependency: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOptionDependency // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOptionDependency + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOptionDependency + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOptionDependency: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.optionDependency] = [ + .noneOptionDependency, + ] + + } + + enum OptionRetention: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOptionRetention // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOptionRetention + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOptionRetention + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOptionRetention: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionRetention] = [ + .noneOptionRetention, + ] + + } + + enum options: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.options] = [ + .noneOptions, + ] + + } + + enum OptionTargetType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOptionTargetType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOptionTargetType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOptionTargetType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOptionTargetType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionTargetType] = [ + .noneOptionTargetType, + ] + + } + + enum other: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOther // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOther + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOther + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOther: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.other] = [ + .noneOther, + ] + + } + + enum others: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOthers // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOthers + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOthers + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOthers: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.others] = [ + .noneOthers, + ] + + } + + enum out: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOut // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOut + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOut + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOut: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.out] = [ + .noneOut, + ] + + } + + enum outputType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOutputType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOutputType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOutputType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOutputType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.outputType] = [ + .noneOutputType, + ] + + } + + enum overridableFeatures: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneOverridableFeatures // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneOverridableFeatures + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneOverridableFeatures + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneOverridableFeatures: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.overridableFeatures] = [ + .noneOverridableFeatures, + ] + + } + + enum p: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneP // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneP + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneP + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneP: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.p] = [ + .noneP, + ] + + } + + enum package: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePackage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePackage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePackage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePackage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.package] = [ + .nonePackage, + ] + + } + + enum packed: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePacked // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePacked + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePacked + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePacked: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packed] = [ + .nonePacked, + ] + + } + + enum PackedEnumExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePackedEnumExtensionField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePackedEnumExtensionField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePackedEnumExtensionField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePackedEnumExtensionField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PackedEnumExtensionField] = [ + .nonePackedEnumExtensionField, + ] + + } + + enum PackedExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePackedExtensionField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePackedExtensionField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePackedExtensionField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePackedExtensionField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PackedExtensionField] = [ + .nonePackedExtensionField, + ] + + } + + enum padding: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePadding // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePadding + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePadding + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePadding: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.padding] = [ + .nonePadding, + ] + + } + + enum parent: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneParent // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneParent + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneParent + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneParent: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.parent] = [ + .noneParent, + ] + + } + + enum parse: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneParse // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneParse + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneParse + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneParse: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.parse] = [ + .noneParse, + ] + + } + + enum partial: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePartial // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePartial + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePartial + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePartial: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.partial] = [ + .nonePartial, + ] + + } + + enum path: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePath // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePath + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePath + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePath: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.path] = [ + .nonePath, + ] + + } + + enum PathDecoder: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePathDecoder // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePathDecoder + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePathDecoder + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePathDecoder: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PathDecoder] = [ + .nonePathDecoder, + ] + + } + + enum PathDecodingError: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePathDecodingError // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePathDecodingError + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePathDecodingError + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePathDecodingError: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PathDecodingError] = [ + .nonePathDecodingError, + ] + + } + + enum paths: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePaths // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePaths + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePaths + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePaths: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.paths] = [ + .nonePaths, + ] + + } + + enum PathVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePathVisitor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePathVisitor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePathVisitor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePathVisitor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PathVisitor] = [ + .nonePathVisitor, + ] + + } + + enum payload: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePayload // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePayload + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePayload + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePayload: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.payload] = [ + .nonePayload, + ] + + } + + enum payloadSize: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePayloadSize // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePayloadSize + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePayloadSize + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePayloadSize: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.payloadSize] = [ + .nonePayloadSize, + ] + + } + + enum phpClassPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePhpClassPrefix // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePhpClassPrefix + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePhpClassPrefix + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePhpClassPrefix: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpClassPrefix] = [ + .nonePhpClassPrefix, + ] + + } + + enum phpMetadataNamespace: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePhpMetadataNamespace // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePhpMetadataNamespace + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePhpMetadataNamespace + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePhpMetadataNamespace: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpMetadataNamespace] = [ + .nonePhpMetadataNamespace, + ] + + } + + enum phpNamespace: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePhpNamespace // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePhpNamespace + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePhpNamespace + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePhpNamespace: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpNamespace] = [ + .nonePhpNamespace, + ] + + } + + enum pos: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePos // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePos + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePos + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePos: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.pos] = [ + .nonePos, + ] + + } + + enum positiveIntValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePositiveIntValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePositiveIntValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePositiveIntValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePositiveIntValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.positiveIntValue] = [ + .nonePositiveIntValue, + ] + + } + + enum prefix: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePrefix // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePrefix + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePrefix + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePrefix: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.prefix] = [ + .nonePrefix, + ] + + } + + enum preserveProtoFieldNames: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePreserveProtoFieldNames // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePreserveProtoFieldNames + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePreserveProtoFieldNames + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePreserveProtoFieldNames: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.preserveProtoFieldNames] = [ + .nonePreserveProtoFieldNames, + ] + + } + + enum preTraverse: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePreTraverse // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePreTraverse + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePreTraverse + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePreTraverse: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.preTraverse] = [ + .nonePreTraverse, + ] + + } + + enum previousNumber: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePreviousNumber // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePreviousNumber + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePreviousNumber + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePreviousNumber: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.previousNumber] = [ + .nonePreviousNumber, + ] + + } + + enum prevPath: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePrevPath // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePrevPath + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePrevPath + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePrevPath: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.prevPath] = [ + .nonePrevPath, + ] + + } + + enum printUnknownFields: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePrintUnknownFields // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePrintUnknownFields + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePrintUnknownFields + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePrintUnknownFields: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.printUnknownFields] = [ + .nonePrintUnknownFields, + ] + + } + + enum programBuffer: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProgramBuffer // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProgramBuffer + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProgramBuffer + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProgramBuffer: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.programBuffer] = [ + .noneProgramBuffer, + ] + + } + + enum programFormat: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProgramFormat // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProgramFormat + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProgramFormat + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProgramFormat: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.programFormat] = [ + .noneProgramFormat, + ] + + } + + enum proto2: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProto2 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProto2 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProto2 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProto2: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto2] = [ + .noneProto2, + ] + + } + + enum proto3DefaultValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProto3DefaultValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProto3DefaultValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProto3DefaultValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProto3DefaultValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto3DefaultValue] = [ + .noneProto3DefaultValue, + ] + + } + + enum proto3Optional: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProto3Optional // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProto3Optional + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProto3Optional + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProto3Optional: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto3Optional] = [ + .noneProto3Optional, + ] + + } + + enum protobuf_extensionFieldValues: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufExtensionFieldValues // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufExtensionFieldValues + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufExtensionFieldValues + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufExtensionFieldValues: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues] = [ + .noneProtobufExtensionFieldValues, + ] + + } + + enum protobuf_fieldNumber: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufFieldNumber // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufFieldNumber + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufFieldNumber + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufFieldNumber: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_fieldNumber] = [ + .noneProtobufFieldNumber, + ] + + } + + enum protobuf_generated_isEqualTo: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufGeneratedIsEqualTo // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufGeneratedIsEqualTo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufGeneratedIsEqualTo + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufGeneratedIsEqualTo: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo] = [ + .noneProtobufGeneratedIsEqualTo, + ] + + } + + enum protobuf_nameMap: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufNameMap // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufNameMap + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufNameMap + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufNameMap: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_nameMap] = [ + .noneProtobufNameMap, + ] + + } + + enum protobuf_newField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufNewField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufNewField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufNewField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufNewField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_newField] = [ + .noneProtobufNewField, + ] + + } + + enum protobuf_package: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufPackage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufPackage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufPackage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufPackage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_package] = [ + .noneProtobufPackage, + ] + + } + + enum ProtobufAPIVersion_2: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufApiversion2 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufApiversion2 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufApiversion2 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufApiversion2: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_2] = [ + .noneProtobufApiversion2, + ] + + } + + enum ProtobufAPIVersionCheck: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufApiversionCheck // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufApiversionCheck + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufApiversionCheck + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufApiversionCheck: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck] = [ + .noneProtobufApiversionCheck, + ] + + } + + enum ProtobufBool: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufBool // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufBool + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufBool + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufBool: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufBool] = [ + .noneProtobufBool, + ] + + } + + enum ProtobufBytes: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufBytes // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufBytes + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufBytes + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufBytes: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufBytes] = [ + .noneProtobufBytes, + ] + + } + + enum protobufData: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufData // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufData + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufData + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufData: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobufData] = [ + .noneProtobufData, + ] + + } + + enum ProtobufDouble: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufDouble // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufDouble + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufDouble + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufDouble: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufDouble] = [ + .noneProtobufDouble, + ] + + } + + enum ProtobufEnumMap: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufEnumMap // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufEnumMap + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufEnumMap + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufEnumMap: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufEnumMap] = [ + .noneProtobufEnumMap, + ] + + } + + enum protobufExtension: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufExtension // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufExtension + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufExtension + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufExtension: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobufExtension] = [ + .noneProtobufExtension, + ] + + } + + enum ProtobufFixed32: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufFixed32 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufFixed32 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufFixed32 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufFixed32: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFixed32] = [ + .noneProtobufFixed32, + ] + + } + + enum ProtobufFixed64: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufFixed64 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufFixed64 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufFixed64 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufFixed64: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFixed64] = [ + .noneProtobufFixed64, + ] + + } + + enum ProtobufFloat: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufFloat // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufFloat + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufFloat + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufFloat: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFloat] = [ + .noneProtobufFloat, + ] + + } + + enum ProtobufInt32: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufInt32 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufInt32 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufInt32 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufInt32: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufInt32] = [ + .noneProtobufInt32, + ] + + } + + enum ProtobufInt64: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufInt64 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufInt64 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufInt64 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufInt64: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufInt64] = [ + .noneProtobufInt64, + ] + + } + + enum ProtobufMap: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufMap // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufMap + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufMap + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufMap: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufMap] = [ + .noneProtobufMap, + ] + + } + + enum ProtobufMessageMap: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufMessageMap // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufMessageMap + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufMessageMap + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufMessageMap: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufMessageMap] = [ + .noneProtobufMessageMap, + ] + + } + + enum ProtobufSFixed32: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufSfixed32 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufSfixed32 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufSfixed32 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufSfixed32: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSFixed32] = [ + .noneProtobufSfixed32, + ] + + } + + enum ProtobufSFixed64: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufSfixed64 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufSfixed64 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufSfixed64 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufSfixed64: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSFixed64] = [ + .noneProtobufSfixed64, + ] + + } + + enum ProtobufSInt32: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufSint32 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufSint32 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufSint32 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufSint32: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSInt32] = [ + .noneProtobufSint32, + ] + + } + + enum ProtobufSInt64: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufSint64 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufSint64 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufSint64 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufSint64: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSInt64] = [ + .noneProtobufSint64, + ] + + } + + enum ProtobufString: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufString // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufString + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufString + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufString: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufString] = [ + .noneProtobufString, + ] + + } + + enum ProtobufUInt32: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufUint32 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufUint32 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufUint32 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufUint32: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufUInt32] = [ + .noneProtobufUint32, + ] + + } + + enum ProtobufUInt64: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtobufUint64 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtobufUint64 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtobufUint64 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtobufUint64: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufUInt64] = [ + .noneProtobufUint64, + ] + + } + + enum protocolEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtocol // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtocol + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtocol + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtocol: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protocolEnum] = [ + .noneProtocol, + ] + + } + + enum protoFieldName: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtoFieldName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtoFieldName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtoFieldName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtoFieldName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoFieldName] = [ + .noneProtoFieldName, + ] + + } + + enum protoMessageNameEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtoMessageName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtoMessageName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtoMessageName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtoMessageName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoMessageNameEnum] = [ + .noneProtoMessageName, + ] + + } + + enum ProtoNameProviding: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtoNameProviding // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtoNameProviding + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtoNameProviding + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtoNameProviding: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtoNameProviding] = [ + .noneProtoNameProviding, + ] + + } + + enum protoPaths: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneProtoPaths // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneProtoPaths + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneProtoPaths + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneProtoPaths: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoPaths] = [ + .noneProtoPaths, + ] + + } + + enum publicEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePublic // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePublic + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePublic + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePublic: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.publicEnum] = [ + .nonePublic, + ] + + } + + enum publicDependency: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePublicDependency // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePublicDependency + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePublicDependency + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePublicDependency: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.publicDependency] = [ + .nonePublicDependency, + ] + + } + + enum putBoolValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePutBoolValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePutBoolValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePutBoolValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePutBoolValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putBoolValue] = [ + .nonePutBoolValue, + ] + + } + + enum putBytesValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePutBytesValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePutBytesValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePutBytesValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePutBytesValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putBytesValue] = [ + .nonePutBytesValue, + ] + + } + + enum putDoubleValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePutDoubleValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePutDoubleValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePutDoubleValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePutDoubleValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putDoubleValue] = [ + .nonePutDoubleValue, + ] + + } + + enum putEnumValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePutEnumValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePutEnumValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePutEnumValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePutEnumValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putEnumValue] = [ + .nonePutEnumValue, + ] + + } + + enum putFixedUInt32: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePutFixedUint32 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePutFixedUint32 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePutFixedUint32 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePutFixedUint32: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFixedUInt32] = [ + .nonePutFixedUint32, + ] + + } + + enum putFixedUInt64: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePutFixedUint64 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePutFixedUint64 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePutFixedUint64 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePutFixedUint64: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFixedUInt64] = [ + .nonePutFixedUint64, + ] + + } + + enum putFloatValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePutFloatValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePutFloatValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePutFloatValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePutFloatValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFloatValue] = [ + .nonePutFloatValue, + ] + + } + + enum putInt64: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePutInt64 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePutInt64 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePutInt64 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePutInt64: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putInt64] = [ + .nonePutInt64, + ] + + } + + enum putStringValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePutStringValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePutStringValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePutStringValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePutStringValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putStringValue] = [ + .nonePutStringValue, + ] + + } + + enum putUInt64: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePutUint64 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePutUint64 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePutUint64 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePutUint64: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putUInt64] = [ + .nonePutUint64, + ] + + } + + enum putUInt64Hex: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePutUint64Hex // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePutUint64Hex + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePutUint64Hex + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePutUint64Hex: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putUInt64Hex] = [ + .nonePutUint64Hex, + ] + + } + + enum putVarInt: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePutVarInt // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePutVarInt + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePutVarInt + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePutVarInt: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putVarInt] = [ + .nonePutVarInt, + ] + + } + + enum putZigZagVarInt: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePutZigZagVarInt // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePutZigZagVarInt + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePutZigZagVarInt + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePutZigZagVarInt: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putZigZagVarInt] = [ + .nonePutZigZagVarInt, + ] + + } + + enum pyGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case nonePyGenericServices // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nonePyGenericServices + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nonePyGenericServices + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nonePyGenericServices: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.pyGenericServices] = [ + .nonePyGenericServices, + ] + + } + + enum R: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneR // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneR + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneR + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneR: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.R] = [ + .noneR, + ] + + } + + enum rawChars: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRawChars // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRawChars + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRawChars + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRawChars: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rawChars] = [ + .noneRawChars, + ] + + } + + enum RawRepresentable: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRawRepresentable // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRawRepresentable + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRawRepresentable + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRawRepresentable: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RawRepresentable] = [ + .noneRawRepresentable, + ] + + } + + enum RawValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRawValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRawValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRawValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRawValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RawValue] = [ + .noneRawValue, + ] + + } + + enum read4HexDigits: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRead4HexDigits // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRead4HexDigits + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRead4HexDigits + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRead4HexDigits: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.read4HexDigits] = [ + .noneRead4HexDigits, + ] + + } + + enum readBytes: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneReadBytes // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneReadBytes + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneReadBytes + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneReadBytes: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.readBytes] = [ + .noneReadBytes, + ] + + } + + enum reader: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneReader // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneReader + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneReader + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneReader: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.reader] = [ + .noneReader, + ] + + } + + enum register: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRegister // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRegister + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRegister + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRegister: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.register] = [ + .noneRegister, + ] + + } + + enum remainingProgram: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRemainingProgram // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRemainingProgram + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRemainingProgram + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRemainingProgram: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.remainingProgram] = [ + .noneRemainingProgram, + ] + + } + + enum removalError: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRemovalError // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRemovalError + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRemovalError + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRemovalError: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.removalError] = [ + .noneRemovalError, + ] + + } + + enum removingAllFieldsOf: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRemovingAllFieldsOf // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRemovingAllFieldsOf + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRemovingAllFieldsOf + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRemovingAllFieldsOf: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.removingAllFieldsOf] = [ + .noneRemovingAllFieldsOf, + ] + + } + + enum repeated: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRepeated // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRepeated + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRepeated + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRepeated: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeated] = [ + .noneRepeated, + ] + + } + + enum RepeatedEnumExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRepeatedEnumExtensionField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRepeatedEnumExtensionField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRepeatedEnumExtensionField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRepeatedEnumExtensionField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField] = [ + .noneRepeatedEnumExtensionField, + ] + + } + + enum RepeatedExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRepeatedExtensionField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRepeatedExtensionField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRepeatedExtensionField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRepeatedExtensionField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedExtensionField] = [ + .noneRepeatedExtensionField, + ] + + } + + enum repeatedFieldEncoding: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRepeatedFieldEncoding // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRepeatedFieldEncoding + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRepeatedFieldEncoding + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRepeatedFieldEncoding: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedFieldEncoding] = [ + .noneRepeatedFieldEncoding, + ] + + } + + enum RepeatedGroupExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRepeatedGroupExtensionField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRepeatedGroupExtensionField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRepeatedGroupExtensionField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRepeatedGroupExtensionField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField] = [ + .noneRepeatedGroupExtensionField, + ] + + } + + enum RepeatedMessageExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRepeatedMessageExtensionField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRepeatedMessageExtensionField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRepeatedMessageExtensionField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRepeatedMessageExtensionField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField] = [ + .noneRepeatedMessageExtensionField, + ] + + } + + enum repeating: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRepeating // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRepeating + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRepeating + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRepeating: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeating] = [ + .noneRepeating, + ] + + } + + enum replaceRepeatedFields: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneReplaceRepeatedFields // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneReplaceRepeatedFields + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneReplaceRepeatedFields + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneReplaceRepeatedFields: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.replaceRepeatedFields] = [ + .noneReplaceRepeatedFields, + ] + + } + + enum requestStreaming: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRequestStreaming // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRequestStreaming + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRequestStreaming + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRequestStreaming: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requestStreaming] = [ + .noneRequestStreaming, + ] + + } + + enum requestTypeURL: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRequestTypeURL // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRequestTypeURL + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRequestTypeURL + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRequestTypeURL: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requestTypeURL] = [ + .noneRequestTypeURL, + ] + + } + + enum requiredSize: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRequiredSize // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRequiredSize + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRequiredSize + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRequiredSize: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requiredSize] = [ + .noneRequiredSize, + ] + + } + + enum responseStreaming: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneResponseStreaming // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneResponseStreaming + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneResponseStreaming + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneResponseStreaming: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.responseStreaming] = [ + .noneResponseStreaming, + ] + + } + + enum responseTypeURL: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneResponseTypeURL // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneResponseTypeURL + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneResponseTypeURL + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneResponseTypeURL: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.responseTypeURL] = [ + .noneResponseTypeURL, + ] + + } + + enum result: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneResult // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneResult + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneResult + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneResult: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.result] = [ + .noneResult, + ] + + } + + enum retention: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRetention // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRetention + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRetention + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRetention: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.retention] = [ + .noneRetention, + ] + + } + + enum rethrowsEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRethrows // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRethrows + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRethrows + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRethrows: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rethrowsEnum] = [ + .noneRethrows, + ] + + } + + enum ReturnType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneReturnType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneReturnType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneReturnType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneReturnType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ReturnType] = [ + .noneReturnType, + ] + + } + + enum revision: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRevision // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRevision + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRevision + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRevision: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.revision] = [ + .noneRevision, + ] + + } + + enum rhs: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRhs // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRhs + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRhs + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRhs: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rhs] = [ + .noneRhs, + ] + + } + + enum root: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRoot // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRoot + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRoot + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRoot: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.root] = [ + .noneRoot, + ] + + } + + enum rubyPackage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneRubyPackage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneRubyPackage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneRubyPackage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneRubyPackage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rubyPackage] = [ + .noneRubyPackage, + ] + + } + + enum s: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneS // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneS + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneS + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneS: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.s] = [ + .noneS, + ] + + } + + enum sawBackslash: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSawBackslash // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSawBackslash + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSawBackslash + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSawBackslash: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawBackslash] = [ + .noneSawBackslash, + ] + + } + + enum sawSection4Characters: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSawSection4Characters // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSawSection4Characters + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSawSection4Characters + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSawSection4Characters: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawSection4Characters] = [ + .noneSawSection4Characters, + ] + + } + + enum sawSection5Characters: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSawSection5Characters // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSawSection5Characters + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSawSection5Characters + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSawSection5Characters: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawSection5Characters] = [ + .noneSawSection5Characters, + ] + + } + + enum Scalar: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneScalar // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneScalar + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneScalar + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneScalar: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Scalar] = [ + .noneScalar, + ] + + } + + enum scan: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneScan // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneScan + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneScan + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneScan: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.scan] = [ + .noneScan, + ] + + } + + enum scanner: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneScanner // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneScanner + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneScanner + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneScanner: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.scanner] = [ + .noneScanner, + ] + + } + + enum seconds: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSeconds // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSeconds + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSeconds + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSeconds: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.seconds] = [ + .noneSeconds, + ] + + } + + enum selfEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSelf // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSelf + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSelf + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSelf: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.selfEnum] = [ + .noneSelf, + ] + + } + + enum semantic: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSemantic // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSemantic + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSemantic + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSemantic: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.semantic] = [ + .noneSemantic, + ] + + } + + enum SendableEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSendable // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSendable + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSendable + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSendable: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SendableEnum] = [ + .noneSendable, + ] + + } + + enum separator: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSeparator // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSeparator + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSeparator + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSeparator: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.separator] = [ + .noneSeparator, + ] + + } + + enum serialize: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSerialize // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSerialize + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSerialize + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSerialize: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serialize] = [ + .noneSerialize, + ] + + } + + enum serializedBytes: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSerializedBytes // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSerializedBytes + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSerializedBytes + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSerializedBytes: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedBytes] = [ + .noneSerializedBytes, + ] + + } + + enum serializedData: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSerializedData // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSerializedData + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSerializedData + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSerializedData: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedData] = [ + .noneSerializedData, + ] + + } + + enum serializedSize: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSerializedSize // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSerializedSize + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSerializedSize + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSerializedSize: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedSize] = [ + .noneSerializedSize, + ] + + } + + enum serverStreaming: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneServerStreaming // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneServerStreaming + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneServerStreaming + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneServerStreaming: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serverStreaming] = [ + .noneServerStreaming, + ] + + } + + enum service: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneService // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneService + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneService + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneService: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.service] = [ + .noneService, + ] + + } + + enum set: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSet // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSet + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSet + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSet: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.set] = [ + .noneSet, + ] + + } + + enum setExtensionValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSetExtensionValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSetExtensionValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSetExtensionValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSetExtensionValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.setExtensionValue] = [ + .noneSetExtensionValue, + ] + + } + + enum shift: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneShift // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneShift + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneShift + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneShift: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.shift] = [ + .noneShift, + ] + + } + + enum SimpleExtensionMap: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSimpleExtensionMap // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSimpleExtensionMap + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSimpleExtensionMap + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSimpleExtensionMap: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SimpleExtensionMap] = [ + .noneSimpleExtensionMap, + ] + + } + + enum size: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSize // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSize + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSize + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSize: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.size] = [ + .noneSize, + ] + + } + + enum sizer: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSizer // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSizer + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSizer + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSizer: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sizer] = [ + .noneSizer, + ] + + } + + enum source: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSource // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSource + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSource + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSource: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.source] = [ + .noneSource, + ] + + } + + enum sourceCodeInfo: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSourceCodeInfo // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSourceCodeInfo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSourceCodeInfo + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSourceCodeInfo: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceCodeInfo] = [ + .noneSourceCodeInfo, + ] + + } + + enum sourceContext: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSourceContext // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSourceContext + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSourceContext + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSourceContext: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceContext] = [ + .noneSourceContext, + ] + + } + + enum sourceEncoding: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSourceEncoding // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSourceEncoding + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSourceEncoding + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSourceEncoding: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceEncoding] = [ + .noneSourceEncoding, + ] + + } + + enum sourceFile: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSourceFile // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSourceFile + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSourceFile + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSourceFile: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceFile] = [ + .noneSourceFile, + ] + + } + + enum SourceLocation: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSourceLocation // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSourceLocation + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSourceLocation + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSourceLocation: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SourceLocation] = [ + .noneSourceLocation, + ] + + } + + enum span: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSpan // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSpan + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSpan + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSpan: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.span] = [ + .noneSpan, + ] + + } + + enum split: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSplit // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSplit + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSplit + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSplit: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.split] = [ + .noneSplit, + ] + + } + + enum start: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneStart // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneStart + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneStart + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneStart: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.start] = [ + .noneStart, + ] + + } + + enum startArray: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneStartArray // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneStartArray + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneStartArray + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneStartArray: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startArray] = [ + .noneStartArray, + ] + + } + + enum startArrayObject: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneStartArrayObject // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneStartArrayObject + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneStartArrayObject + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneStartArrayObject: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startArrayObject] = [ + .noneStartArrayObject, + ] + + } + + enum startField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneStartField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneStartField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneStartField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneStartField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startField] = [ + .noneStartField, + ] + + } + + enum startIndex: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneStartIndex // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneStartIndex + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneStartIndex + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneStartIndex: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startIndex] = [ + .noneStartIndex, + ] + + } + + enum startMessageField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneStartMessageField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneStartMessageField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneStartMessageField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneStartMessageField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startMessageField] = [ + .noneStartMessageField, + ] + + } + + enum startObject: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneStartObject // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneStartObject + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneStartObject + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneStartObject: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startObject] = [ + .noneStartObject, + ] + + } + + enum startRegularField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneStartRegularField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneStartRegularField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneStartRegularField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneStartRegularField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startRegularField] = [ + .noneStartRegularField, + ] + + } + + enum state: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneState // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneState + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneState + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneState: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.state] = [ + .noneState, + ] + + } + + enum staticEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneStatic // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneStatic + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneStatic + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneStatic: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.staticEnum] = [ + .noneStatic, + ] + + } + + enum StaticString: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneStaticString // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneStaticString + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneStaticString + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneStaticString: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.StaticString] = [ + .noneStaticString, + ] + + } + + enum storage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneStorage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneStorage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneStorage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneStorage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.storage] = [ + .noneStorage, + ] + + } + + enum StringEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneString // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneString + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneString + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneString: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.StringEnum] = [ + .noneString, + ] + + } + + enum stringLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneStringLiteral // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneStringLiteral + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneStringLiteral + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneStringLiteral: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.stringLiteral] = [ + .noneStringLiteral, + ] + + } + + enum StringLiteralType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneStringLiteralType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneStringLiteralType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneStringLiteralType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneStringLiteralType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.StringLiteralType] = [ + .noneStringLiteralType, + ] + + } + + enum stringResult: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneStringResult // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneStringResult + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneStringResult + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneStringResult: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.stringResult] = [ + .noneStringResult, + ] + + } + + enum stringValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneStringValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneStringValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneStringValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneStringValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.stringValue] = [ + .noneStringValue, + ] + + } + + enum structEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneStruct // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneStruct + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneStruct + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneStruct: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.structEnum] = [ + .noneStruct, + ] + + } + + enum structValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneStructValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneStructValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneStructValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneStructValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.structValue] = [ + .noneStructValue, + ] + + } + + enum subDecoder: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSubDecoder // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSubDecoder + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSubDecoder + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSubDecoder: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subDecoder] = [ + .noneSubDecoder, + ] + + } + + enum subscriptEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSubscript // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSubscript + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSubscript + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSubscript: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subscriptEnum] = [ + .noneSubscript, + ] + + } + + enum subtract: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSubtract // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSubtract + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSubtract + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSubtract: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subtract] = [ + .noneSubtract, + ] + + } + + enum subVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSubVisitor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSubVisitor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSubVisitor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSubVisitor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subVisitor] = [ + .noneSubVisitor, + ] + + } + + enum SwiftEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSwift // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSwift + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSwift + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSwift: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SwiftEnum] = [ + .noneSwift, + ] + + } + + enum swiftPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSwiftPrefix // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSwiftPrefix + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSwiftPrefix + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSwiftPrefix: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.swiftPrefix] = [ + .noneSwiftPrefix, + ] + + } + + enum SwiftProtobufContiguousBytes: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSwiftProtobufContiguousBytes // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSwiftProtobufContiguousBytes + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSwiftProtobufContiguousBytes + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSwiftProtobufContiguousBytes: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SwiftProtobufContiguousBytes] = [ + .noneSwiftProtobufContiguousBytes, + ] + + } + + enum SwiftProtobufError: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSwiftProtobufError // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSwiftProtobufError + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSwiftProtobufError + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSwiftProtobufError: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SwiftProtobufError] = [ + .noneSwiftProtobufError, + ] + + } + + enum syntax: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneSyntax // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneSyntax + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneSyntax + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneSyntax: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.syntax] = [ + .noneSyntax, + ] + + } + + enum T: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneT // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneT + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneT + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneT: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.T] = [ + .noneT, + ] + + } + + enum tag: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTag // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTag + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTag + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTag: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tag] = [ + .noneTag, + ] + + } + + enum targets: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTargets // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTargets + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTargets + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTargets: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.targets] = [ + .noneTargets, + ] + + } + + enum terminator: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTerminator // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTerminator + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTerminator + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTerminator: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.terminator] = [ + .noneTerminator, + ] + + } + + enum testDecoder: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTestDecoder // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTestDecoder + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTestDecoder + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTestDecoder: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.testDecoder] = [ + .noneTestDecoder, + ] + + } + + enum text: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneText // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneText + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneText + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneText: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.text] = [ + .noneText, + ] + + } + + enum textDecoder: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTextDecoder // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTextDecoder + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTextDecoder + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTextDecoder: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.textDecoder] = [ + .noneTextDecoder, + ] + + } + + enum TextFormatDecoder: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTextFormatDecoder // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTextFormatDecoder + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTextFormatDecoder + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTextFormatDecoder: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatDecoder] = [ + .noneTextFormatDecoder, + ] + + } + + enum TextFormatDecodingError: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTextFormatDecodingError // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTextFormatDecodingError + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTextFormatDecodingError + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTextFormatDecodingError: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatDecodingError] = [ + .noneTextFormatDecodingError, + ] + + } + + enum TextFormatDecodingOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTextFormatDecodingOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTextFormatDecodingOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTextFormatDecodingOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTextFormatDecodingOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatDecodingOptions] = [ + .noneTextFormatDecodingOptions, + ] + + } + + enum TextFormatEncodingOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTextFormatEncodingOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTextFormatEncodingOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTextFormatEncodingOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTextFormatEncodingOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatEncodingOptions] = [ + .noneTextFormatEncodingOptions, + ] + + } + + enum TextFormatEncodingVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTextFormatEncodingVisitor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTextFormatEncodingVisitor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTextFormatEncodingVisitor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTextFormatEncodingVisitor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatEncodingVisitor] = [ + .noneTextFormatEncodingVisitor, + ] + + } + + enum textFormatString: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTextFormatString // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTextFormatString + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTextFormatString + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTextFormatString: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.textFormatString] = [ + .noneTextFormatString, + ] + + } + + enum throwOrIgnore: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneThrowOrIgnore // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneThrowOrIgnore + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneThrowOrIgnore + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneThrowOrIgnore: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.throwOrIgnore] = [ + .noneThrowOrIgnore, + ] + + } + + enum throwsEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneThrows // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneThrows + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneThrows + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneThrows: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.throwsEnum] = [ + .noneThrows, + ] + + } + + enum timeInterval: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTimeInterval // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTimeInterval + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTimeInterval + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTimeInterval: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeInterval] = [ + .noneTimeInterval, + ] + + } + + enum timeIntervalSince1970: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTimeIntervalSince1970 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTimeIntervalSince1970 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTimeIntervalSince1970 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTimeIntervalSince1970: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeIntervalSince1970] = [ + .noneTimeIntervalSince1970, + ] + + } + + enum timeIntervalSinceReferenceDate: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTimeIntervalSinceReferenceDate // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTimeIntervalSinceReferenceDate + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTimeIntervalSinceReferenceDate + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTimeIntervalSinceReferenceDate: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate] = [ + .noneTimeIntervalSinceReferenceDate, + ] + + } + + enum tmp: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTmp // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTmp + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTmp + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTmp: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tmp] = [ + .noneTmp, + ] + + } + + enum tooLarge: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTooLarge // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTooLarge + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTooLarge + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTooLarge: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tooLarge] = [ + .noneTooLarge, + ] + + } + + enum total: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTotal // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTotal + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTotal + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTotal: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.total] = [ + .noneTotal, + ] + + } + + enum totalArrayDepth: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTotalArrayDepth // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTotalArrayDepth + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTotalArrayDepth + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTotalArrayDepth: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.totalArrayDepth] = [ + .noneTotalArrayDepth, + ] + + } + + enum totalSize: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTotalSize // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTotalSize + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTotalSize + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTotalSize: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.totalSize] = [ + .noneTotalSize, + ] + + } + + enum trailingComments: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTrailingComments // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTrailingComments + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTrailingComments + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTrailingComments: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.trailingComments] = [ + .noneTrailingComments, + ] + + } + + enum traverseEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTraverse // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTraverse + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTraverse + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTraverse: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.traverseEnum] = [ + .noneTraverse, + ] + + } + + enum trim: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTrim // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTrim + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTrim + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTrim: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.trim] = [ + .noneTrim, + ] + + } + + enum trueEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTrue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTrue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTrue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTrue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.trueEnum] = [ + .noneTrue, + ] + + } + + enum tryEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTry // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTry + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTry + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTry: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tryEnum] = [ + .noneTry, + ] + + } + + enum type: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.type] = [ + .noneType, + ] + + } + + enum typealiasEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTypealias // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTypealias + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTypealias + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTypealias: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typealiasEnum] = [ + .noneTypealias, + ] + + } + + enum TypeEnumEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTypeEnum // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTypeEnum + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTypeEnum + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTypeEnum: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TypeEnumEnum] = [ + .noneTypeEnum, + ] + + } + + enum typeName: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTypeName // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTypeName + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTypeName + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTypeName: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeName] = [ + .noneTypeName, + ] + + } + + enum typePrefix: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTypePrefix // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTypePrefix + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTypePrefix + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTypePrefix: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typePrefix] = [ + .noneTypePrefix, + ] + + } + + enum typeStart: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTypeStart // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTypeStart + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTypeStart + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTypeStart: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeStart] = [ + .noneTypeStart, + ] + + } + + enum typeUnknown: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTypeUnknown // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTypeUnknown + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTypeUnknown + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTypeUnknown: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeUnknown] = [ + .noneTypeUnknown, + ] + + } + + enum typeURL: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTypeURL // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneTypeURL + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTypeURL + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneTypeURL: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeURL] = [ + .noneTypeURL, + ] + + } + + enum UInt32Enum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUint32 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUint32 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUint32 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUint32: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UInt32Enum] = [ + .noneUint32, + ] + + } + + enum UInt64Enum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUint64 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUint64 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUint64 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUint64: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UInt64Enum] = [ + .noneUint64, + ] + + } + + enum UInt8: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUint8 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUint8 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUint8 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUint8: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UInt8] = [ + .noneUint8, + ] + + } + + enum unchecked: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnchecked // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnchecked + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnchecked + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnchecked: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unchecked] = [ + .noneUnchecked, + ] + + } + + enum Unicode: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnicode // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnicode + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnicode + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnicode: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Unicode] = [ + .noneUnicode, + ] + + } + + enum unicodeScalarLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnicodeScalarLiteral // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnicodeScalarLiteral + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnicodeScalarLiteral + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnicodeScalarLiteral: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unicodeScalarLiteral] = [ + .noneUnicodeScalarLiteral, + ] + + } + + enum UnicodeScalarLiteralType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnicodeScalarLiteralType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnicodeScalarLiteralType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnicodeScalarLiteralType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnicodeScalarLiteralType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnicodeScalarLiteralType] = [ + .noneUnicodeScalarLiteralType, + ] + + } + + enum unicodeScalars: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnicodeScalars // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnicodeScalars + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnicodeScalars + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnicodeScalars: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unicodeScalars] = [ + .noneUnicodeScalars, + ] + + } + + enum UnicodeScalarView: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnicodeScalarView // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnicodeScalarView + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnicodeScalarView + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnicodeScalarView: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnicodeScalarView] = [ + .noneUnicodeScalarView, + ] + + } + + enum uninterpretedOption: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUninterpretedOption // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUninterpretedOption + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUninterpretedOption + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUninterpretedOption: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.uninterpretedOption] = [ + .noneUninterpretedOption, + ] + + } + + enum union: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnion // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnion + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnion + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnion: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.union] = [ + .noneUnion, + ] + + } + + enum uniqueStorage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUniqueStorage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUniqueStorage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUniqueStorage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUniqueStorage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.uniqueStorage] = [ + .noneUniqueStorage, + ] + + } + + enum unknown: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnknown // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnknown + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnknown + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnknown: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unknown] = [ + .noneUnknown, + ] + + } + + enum unknownFieldsEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnknownFields // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnknownFields + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnknownFields + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnknownFields: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unknownFieldsEnum] = [ + .noneUnknownFields, + ] + + } + + enum UnknownStorage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnknownStorage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnknownStorage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnknownStorage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnknownStorage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnknownStorage] = [ + .noneUnknownStorage, + ] + + } + + enum unpackTo: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnpackTo // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnpackTo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnpackTo + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnpackTo: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unpackTo] = [ + .noneUnpackTo, + ] + + } + + enum UnsafeBufferPointer: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnsafeBufferPointer // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnsafeBufferPointer + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnsafeBufferPointer + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnsafeBufferPointer: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeBufferPointer] = [ + .noneUnsafeBufferPointer, + ] + + } + + enum UnsafeMutablePointer: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnsafeMutablePointer // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnsafeMutablePointer + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnsafeMutablePointer + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnsafeMutablePointer: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeMutablePointer] = [ + .noneUnsafeMutablePointer, + ] + + } + + enum UnsafeMutableRawBufferPointer: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnsafeMutableRawBufferPointer // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnsafeMutableRawBufferPointer + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnsafeMutableRawBufferPointer + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnsafeMutableRawBufferPointer: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeMutableRawBufferPointer] = [ + .noneUnsafeMutableRawBufferPointer, + ] + + } + + enum UnsafeRawBufferPointer: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnsafeRawBufferPointer // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnsafeRawBufferPointer + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnsafeRawBufferPointer + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnsafeRawBufferPointer: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeRawBufferPointer] = [ + .noneUnsafeRawBufferPointer, + ] + + } + + enum UnsafeRawPointer: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnsafeRawPointer // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnsafeRawPointer + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnsafeRawPointer + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnsafeRawPointer: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeRawPointer] = [ + .noneUnsafeRawPointer, + ] + + } + + enum unverifiedLazy: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnverifiedLazy // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnverifiedLazy + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnverifiedLazy + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnverifiedLazy: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unverifiedLazy] = [ + .noneUnverifiedLazy, + ] + + } + + enum updatedOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUpdatedOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUpdatedOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUpdatedOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUpdatedOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.updatedOptions] = [ + .noneUpdatedOptions, + ] + + } + + enum uppercasedAssumingASCII: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUppercasedAssumingAscii // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUppercasedAssumingAscii + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUppercasedAssumingAscii + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUppercasedAssumingAscii: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.uppercasedAssumingASCII] = [ + .noneUppercasedAssumingAscii, + ] + + } + + enum url: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneURL // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneURL + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneURL + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneURL: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.url] = [ + .noneURL, + ] + + } + + enum useDeterministicOrdering: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUseDeterministicOrdering // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUseDeterministicOrdering + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUseDeterministicOrdering + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUseDeterministicOrdering: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.useDeterministicOrdering] = [ + .noneUseDeterministicOrdering, + ] + + } + + enum utf8: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUtf8 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUtf8 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUtf8 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUtf8: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8] = [ + .noneUtf8, + ] + + } + + enum utf8Ptr: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUtf8Ptr // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUtf8Ptr + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUtf8Ptr + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUtf8Ptr: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8Ptr] = [ + .noneUtf8Ptr, + ] + + } + + enum utf8ToDouble: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUtf8ToDouble // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUtf8ToDouble + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUtf8ToDouble + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUtf8ToDouble: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8ToDouble] = [ + .noneUtf8ToDouble, + ] + + } + + enum utf8Validation: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUtf8Validation // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUtf8Validation + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUtf8Validation + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUtf8Validation: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8Validation] = [ + .noneUtf8Validation, + ] + + } + + enum UTF8View: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUtf8View // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUtf8View + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUtf8View + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUtf8View: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UTF8View] = [ + .noneUtf8View, + ] + + } + + enum V: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneV // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneV + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneV + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneV: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.V] = [ + .noneV, + ] + + } + + enum value: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.value] = [ + .noneValue, + ] + + } + + enum valueField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneValueField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneValueField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneValueField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneValueField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.valueField] = [ + .noneValueField, + ] + + } + + enum values: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneValues // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneValues + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneValues + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneValues: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.values] = [ + .noneValues, + ] + + } + + enum ValueType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneValueType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneValueType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneValueType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneValueType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ValueType] = [ + .noneValueType, + ] + + } + + enum varEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVar // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVar + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVar + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVar: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.varEnum] = [ + .noneVar, + ] + + } + + enum verification: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVerification // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVerification + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVerification + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVerification: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.verification] = [ + .noneVerification, + ] + + } + + enum VerificationState: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVerificationState // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVerificationState + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVerificationState + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVerificationState: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.VerificationState] = [ + .noneVerificationState, + ] + + } + + enum version: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVersion // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVersion + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVersion + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVersion: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.version] = [ + .noneVersion, + ] + + } + + enum versionString: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVersionString // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVersionString + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVersionString + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVersionString: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.versionString] = [ + .noneVersionString, + ] + + } + + enum visibility: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisibility // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisibility + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisibility + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisibility: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visibility] = [ + .noneVisibility, + ] + + } + + enum VisibilityFeature: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisibilityFeature // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisibilityFeature + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisibilityFeature + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisibilityFeature: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.VisibilityFeature] = [ + .noneVisibilityFeature, + ] + + } + + enum visitExtensionFields: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitExtensionFields // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitExtensionFields + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitExtensionFields + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitExtensionFields: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitExtensionFields] = [ + .noneVisitExtensionFields, + ] + + } + + enum visitExtensionFieldsAsMessageSet: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitExtensionFieldsAsMessageSet // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitExtensionFieldsAsMessageSet + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitExtensionFieldsAsMessageSet + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitExtensionFieldsAsMessageSet: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitExtensionFieldsAsMessageSet] = [ + .noneVisitExtensionFieldsAsMessageSet, + ] + + } + + enum visitMapField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitMapField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitMapField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitMapField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitMapField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitMapField] = [ + .noneVisitMapField, + ] + + } + + enum Visitor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitor // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitor + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitor + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitor: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Visitor] = [ + .noneVisitor, + ] + + } + + enum visitPacked: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPacked // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitPacked + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPacked + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitPacked: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPacked] = [ + .noneVisitPacked, + ] + + } + + enum visitPackedBoolField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedBoolField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitPackedBoolField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedBoolField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitPackedBoolField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedBoolField] = [ + .noneVisitPackedBoolField, + ] + + } + + enum visitPackedDoubleField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedDoubleField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitPackedDoubleField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedDoubleField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitPackedDoubleField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedDoubleField] = [ + .noneVisitPackedDoubleField, + ] + + } + + enum visitPackedEnumField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedEnumField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitPackedEnumField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedEnumField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitPackedEnumField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedEnumField] = [ + .noneVisitPackedEnumField, + ] + + } + + enum visitPackedFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedFixed32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitPackedFixed32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedFixed32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitPackedFixed32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedFixed32Field] = [ + .noneVisitPackedFixed32Field, + ] + + } + + enum visitPackedFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedFixed64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitPackedFixed64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedFixed64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitPackedFixed64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedFixed64Field] = [ + .noneVisitPackedFixed64Field, + ] + + } + + enum visitPackedFloatField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedFloatField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitPackedFloatField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedFloatField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitPackedFloatField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedFloatField] = [ + .noneVisitPackedFloatField, + ] + + } + + enum visitPackedInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedInt32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitPackedInt32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedInt32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitPackedInt32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedInt32Field] = [ + .noneVisitPackedInt32Field, + ] + + } + + enum visitPackedInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedInt64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitPackedInt64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedInt64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitPackedInt64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedInt64Field] = [ + .noneVisitPackedInt64Field, + ] + + } + + enum visitPackedSFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedSfixed32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitPackedSfixed32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedSfixed32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitPackedSfixed32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSFixed32Field] = [ + .noneVisitPackedSfixed32Field, + ] + + } + + enum visitPackedSFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedSfixed64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitPackedSfixed64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedSfixed64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitPackedSfixed64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSFixed64Field] = [ + .noneVisitPackedSfixed64Field, + ] + + } + + enum visitPackedSInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedSint32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitPackedSint32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedSint32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitPackedSint32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSInt32Field] = [ + .noneVisitPackedSint32Field, + ] + + } + + enum visitPackedSInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedSint64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitPackedSint64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedSint64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitPackedSint64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSInt64Field] = [ + .noneVisitPackedSint64Field, + ] + + } + + enum visitPackedUInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedUint32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitPackedUint32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedUint32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitPackedUint32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedUInt32Field] = [ + .noneVisitPackedUint32Field, + ] + + } + + enum visitPackedUInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedUint64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitPackedUint64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedUint64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitPackedUint64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedUInt64Field] = [ + .noneVisitPackedUint64Field, + ] + + } + + enum visitRepeated: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeated // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeated + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeated + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeated: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeated] = [ + .noneVisitRepeated, + ] + + } + + enum visitRepeatedBoolField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedBoolField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeatedBoolField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedBoolField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeatedBoolField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedBoolField] = [ + .noneVisitRepeatedBoolField, + ] + + } + + enum visitRepeatedBytesField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedBytesField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeatedBytesField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedBytesField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeatedBytesField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedBytesField] = [ + .noneVisitRepeatedBytesField, + ] + + } + + enum visitRepeatedDoubleField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedDoubleField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeatedDoubleField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedDoubleField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeatedDoubleField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedDoubleField] = [ + .noneVisitRepeatedDoubleField, + ] + + } + + enum visitRepeatedEnumField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedEnumField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeatedEnumField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedEnumField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeatedEnumField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedEnumField] = [ + .noneVisitRepeatedEnumField, + ] + + } + + enum visitRepeatedFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedFixed32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeatedFixed32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedFixed32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeatedFixed32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedFixed32Field] = [ + .noneVisitRepeatedFixed32Field, + ] + + } + + enum visitRepeatedFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedFixed64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeatedFixed64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedFixed64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeatedFixed64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedFixed64Field] = [ + .noneVisitRepeatedFixed64Field, + ] + + } + + enum visitRepeatedFloatField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedFloatField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeatedFloatField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedFloatField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeatedFloatField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedFloatField] = [ + .noneVisitRepeatedFloatField, + ] + + } + + enum visitRepeatedGroupField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedGroupField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeatedGroupField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedGroupField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeatedGroupField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedGroupField] = [ + .noneVisitRepeatedGroupField, + ] + + } + + enum visitRepeatedInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedInt32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeatedInt32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedInt32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeatedInt32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedInt32Field] = [ + .noneVisitRepeatedInt32Field, + ] + + } + + enum visitRepeatedInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedInt64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeatedInt64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedInt64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeatedInt64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedInt64Field] = [ + .noneVisitRepeatedInt64Field, + ] + + } + + enum visitRepeatedMessageField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedMessageField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeatedMessageField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedMessageField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeatedMessageField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedMessageField] = [ + .noneVisitRepeatedMessageField, + ] + + } + + enum visitRepeatedSFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedSfixed32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeatedSfixed32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedSfixed32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeatedSfixed32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSFixed32Field] = [ + .noneVisitRepeatedSfixed32Field, + ] + + } + + enum visitRepeatedSFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedSfixed64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeatedSfixed64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedSfixed64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeatedSfixed64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSFixed64Field] = [ + .noneVisitRepeatedSfixed64Field, + ] + + } + + enum visitRepeatedSInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedSint32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeatedSint32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedSint32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeatedSint32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSInt32Field] = [ + .noneVisitRepeatedSint32Field, + ] + + } + + enum visitRepeatedSInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedSint64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeatedSint64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedSint64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeatedSint64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSInt64Field] = [ + .noneVisitRepeatedSint64Field, + ] + + } + + enum visitRepeatedStringField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedStringField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeatedStringField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedStringField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeatedStringField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedStringField] = [ + .noneVisitRepeatedStringField, + ] + + } + + enum visitRepeatedUInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedUint32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeatedUint32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedUint32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeatedUint32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedUInt32Field] = [ + .noneVisitRepeatedUint32Field, + ] + + } + + enum visitRepeatedUInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedUint64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitRepeatedUint64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedUint64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitRepeatedUint64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedUInt64Field] = [ + .noneVisitRepeatedUint64Field, + ] + + } + + enum visitSingular: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingular // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingular + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingular + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingular: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingular] = [ + .noneVisitSingular, + ] + + } + + enum visitSingularBoolField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularBoolField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingularBoolField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularBoolField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingularBoolField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularBoolField] = [ + .noneVisitSingularBoolField, + ] + + } + + enum visitSingularBytesField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularBytesField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingularBytesField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularBytesField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingularBytesField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularBytesField] = [ + .noneVisitSingularBytesField, + ] + + } + + enum visitSingularDoubleField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularDoubleField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingularDoubleField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularDoubleField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingularDoubleField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularDoubleField] = [ + .noneVisitSingularDoubleField, + ] + + } + + enum visitSingularEnumField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularEnumField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingularEnumField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularEnumField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingularEnumField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularEnumField] = [ + .noneVisitSingularEnumField, + ] + + } + + enum visitSingularFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularFixed32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingularFixed32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularFixed32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingularFixed32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularFixed32Field] = [ + .noneVisitSingularFixed32Field, + ] + + } + + enum visitSingularFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularFixed64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingularFixed64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularFixed64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingularFixed64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularFixed64Field] = [ + .noneVisitSingularFixed64Field, + ] + + } + + enum visitSingularFloatField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularFloatField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingularFloatField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularFloatField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingularFloatField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularFloatField] = [ + .noneVisitSingularFloatField, + ] + + } + + enum visitSingularGroupField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularGroupField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingularGroupField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularGroupField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingularGroupField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularGroupField] = [ + .noneVisitSingularGroupField, + ] + + } + + enum visitSingularInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularInt32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingularInt32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularInt32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingularInt32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularInt32Field] = [ + .noneVisitSingularInt32Field, + ] + + } + + enum visitSingularInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularInt64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingularInt64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularInt64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingularInt64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularInt64Field] = [ + .noneVisitSingularInt64Field, + ] + + } + + enum visitSingularMessageField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularMessageField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingularMessageField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularMessageField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingularMessageField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularMessageField] = [ + .noneVisitSingularMessageField, + ] + + } + + enum visitSingularSFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularSfixed32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingularSfixed32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularSfixed32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingularSfixed32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSFixed32Field] = [ + .noneVisitSingularSfixed32Field, + ] + + } + + enum visitSingularSFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularSfixed64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingularSfixed64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularSfixed64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingularSfixed64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSFixed64Field] = [ + .noneVisitSingularSfixed64Field, + ] + + } + + enum visitSingularSInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularSint32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingularSint32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularSint32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingularSint32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSInt32Field] = [ + .noneVisitSingularSint32Field, + ] + + } + + enum visitSingularSInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularSint64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingularSint64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularSint64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingularSint64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSInt64Field] = [ + .noneVisitSingularSint64Field, + ] + + } + + enum visitSingularStringField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularStringField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingularStringField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularStringField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingularStringField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularStringField] = [ + .noneVisitSingularStringField, + ] + + } + + enum visitSingularUInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularUint32Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingularUint32Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularUint32Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingularUint32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularUInt32Field] = [ + .noneVisitSingularUint32Field, + ] + + } + + enum visitSingularUInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularUint64Field // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitSingularUint64Field + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularUint64Field + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitSingularUint64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularUInt64Field] = [ + .noneVisitSingularUint64Field, + ] + + } + + enum visitUnknown: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitUnknown // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitUnknown + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitUnknown + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitUnknown: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitUnknown] = [ + .noneVisitUnknown, + ] + + } + + enum Void: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVoid // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVoid + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVoid + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVoid: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Void] = [ + .noneVoid, + ] + + } + + enum wasDecoded: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWasDecoded // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneWasDecoded + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWasDecoded + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneWasDecoded: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.wasDecoded] = [ + .noneWasDecoded, + ] + + } + + enum weak: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWeak // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneWeak + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWeak + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneWeak: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.weak] = [ + .noneWeak, + ] + + } + + enum weakDependency: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWeakDependency // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneWeakDependency + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWeakDependency + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneWeakDependency: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.weakDependency] = [ + .noneWeakDependency, + ] + + } + + enum whereEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWhere // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneWhere + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWhere + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneWhere: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.whereEnum] = [ + .noneWhere, + ] + + } + + enum wireFormat: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWireFormat // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneWireFormat + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWireFormat + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneWireFormat: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.wireFormat] = [ + .noneWireFormat, + ] + + } + + enum with: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWith // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneWith + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWith + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneWith: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.with] = [ + .noneWith, + ] + + } + + enum withUnsafeBytes: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWithUnsafeBytes // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneWithUnsafeBytes + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWithUnsafeBytes + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneWithUnsafeBytes: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.withUnsafeBytes] = [ + .noneWithUnsafeBytes, + ] + + } + + enum withUnsafeMutableBytes: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWithUnsafeMutableBytes // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneWithUnsafeMutableBytes + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWithUnsafeMutableBytes + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneWithUnsafeMutableBytes: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.withUnsafeMutableBytes] = [ + .noneWithUnsafeMutableBytes, + ] + + } + + enum work: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWork // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneWork + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWork + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneWork: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.work] = [ + .noneWork, + ] + + } + + enum Wrapped: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWrapped // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneWrapped + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWrapped + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneWrapped: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Wrapped] = [ + .noneWrapped, + ] + + } + + enum WrappedType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWrappedType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneWrappedType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWrappedType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneWrappedType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.WrappedType] = [ + .noneWrappedType, + ] + + } + + enum wrappedValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWrappedValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneWrappedValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWrappedValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneWrappedValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.wrappedValue] = [ + .noneWrappedValue, + ] + + } + + enum written: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWritten // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneWritten + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWritten + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneWritten: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.written] = [ + .noneWritten, + ] + + } + + enum yday: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneYday // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneYday + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneYday + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneYday: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.yday] = [ + .noneYday, + ] + + } + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_proto_testing.generated" + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GeneratedSwiftReservedEnums" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.addPath: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_addPath\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.adjusted: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_adjusted\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.aggregateValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_aggregateValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.allCases: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_allCases\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.allowAlias: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_allowAlias\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.alwaysPrintEnumsAsInts: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_alwaysPrintEnumsAsInts\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.alwaysPrintInt64sAsNumbers: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_alwaysPrintInt64sAsNumbers\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.annotation: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_annotation\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.any: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_any\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AnyExtensionField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyMessageExtension: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AnyMessageExtension\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyMessageStorage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AnyMessageStorage\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyUnpackError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AnyUnpackError\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.append: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_append\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.appended: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_appended\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.appendUIntHex: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_appendUIntHex\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.appendUnknown: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_appendUnknown\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.areAllInitialized: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_areAllInitialized\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Array: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Array\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.arrayDepth: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_arrayDepth\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.arrayLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_arrayLiteral\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.arraySeparator: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_arraySeparator\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.asEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_as\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.asciiOpenCurlyBracket: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_asciiOpenCurlyBracket\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.asciiZero: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_asciiZero\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.async: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_async\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AsyncIterator: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AsyncIterator\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AsyncIteratorProtocol: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AsyncIteratorProtocol\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AsyncMessageSequence: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AsyncMessageSequence\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.available: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_available\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.b: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_b\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Base: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Base\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.base64Values: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_base64Values\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.baseAddress: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_baseAddress\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BaseType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BaseType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.begin: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_begin\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binary: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_binary\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryDecoder\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryDecoding\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecodingError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryDecodingError\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecodingOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryDecodingOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDelimited: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryDelimited\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncoder\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncodingError\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetSizeVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncodingMessageSetSizeVisitor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncodingMessageSetVisitor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncodingOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingSizeVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncodingSizeVisitor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncodingVisitor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binaryOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_binaryOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binaryProtobufDelimitedMessages: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_binaryProtobufDelimitedMessages\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryStreamDecoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryStreamDecoding\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binaryStreamDecodingError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_binaryStreamDecodingError\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bitPattern: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_bitPattern\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.body: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_body\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BoolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Bool\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.booleanLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_booleanLiteral\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BooleanLiteralType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BooleanLiteralType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.boolValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_boolValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.buffer: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_buffer\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.byte: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_byte\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytecode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_bytecode\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BytecodeReader: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BytecodeReader\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_bytes\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytesInGroup: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_bytesInGroup\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytesNeeded: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_bytesNeeded\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytesRead: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_bytesRead\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.c: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_c\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.canonical: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_canonical\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.capitalizeNext: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_capitalizeNext\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.cardinality: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_cardinality\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.CaseIterable: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_CaseIterable\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.castedValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_castedValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ccEnableArenas: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ccEnableArenas\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ccGenericServices: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ccGenericServices\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Character: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Character\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.chars: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_chars\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.checkProgramFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_checkProgramFormat\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.chunk: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_chunk\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.classEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_class\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearAggregateValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearAggregateValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearAllowAlias: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearAllowAlias\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearBegin: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearBegin\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCcEnableArenas: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearCcEnableArenas\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCcGenericServices: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearCcGenericServices\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearClientStreaming: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearClientStreaming\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCsharpNamespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearCsharpNamespace\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCtype: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearCtype\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDebugRedact: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDebugRedact\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDefaultSymbolVisibility: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDefaultSymbolVisibility\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDefaultValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDefaultValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDeprecated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDeprecated\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDeprecatedLegacyJsonFieldConflicts: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDeprecatedLegacyJsonFieldConflicts\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDeprecationWarning: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDeprecationWarning\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDoubleValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDoubleValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEdition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEdition\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEditionDeprecated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEditionDeprecated\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEditionIntroduced: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEditionIntroduced\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEditionRemoved: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEditionRemoved\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEnd: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEnd\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEnforceNamingStyle: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEnforceNamingStyle\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEnumType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEnumType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearExtendee: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearExtendee\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearExtensionValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearExtensionValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFeatures: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearFeatures\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFeatureSupport: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearFeatureSupport\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFieldPresence: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearFieldPresence\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFixedFeatures: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearFixedFeatures\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFullName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearFullName\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearGoPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearGoPackage\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearIdempotencyLevel: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearIdempotencyLevel\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearIdentifierValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearIdentifierValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearInputType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearInputType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearIsExtension: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearIsExtension\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaGenerateEqualsAndHash: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJavaGenerateEqualsAndHash\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaGenericServices: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJavaGenericServices\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaMultipleFiles: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJavaMultipleFiles\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaOuterClassname: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJavaOuterClassname\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJavaPackage\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaStringCheckUtf8: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJavaStringCheckUtf8\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJsonFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJsonFormat\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJsonName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJsonName\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJstype: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJstype\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearLabel: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearLabel\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearLazy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearLazy\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearLeadingComments: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearLeadingComments\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMapEntry: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearMapEntry\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMaximumEdition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearMaximumEdition\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMessageEncoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearMessageEncoding\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMessageSetWireFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearMessageSetWireFormat\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMinimumEdition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearMinimumEdition\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearName\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNamePart: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearNamePart\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNegativeIntValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearNegativeIntValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNoStandardDescriptorAccessor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearNoStandardDescriptorAccessor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearNumber\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearObjcClassPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearObjcClassPrefix\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOneofIndex: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearOneofIndex\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOptimizeFor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearOptimizeFor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOutputType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearOutputType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOverridableFeatures: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearOverridableFeatures\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPackage\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPacked: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPacked\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPhpClassPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPhpClassPrefix\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPhpMetadataNamespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPhpMetadataNamespace\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPhpNamespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPhpNamespace\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPositiveIntValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPositiveIntValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearProto3Optional: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearProto3Optional\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPyGenericServices: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPyGenericServices\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRemovalError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearRemovalError\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRepeated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearRepeated\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRepeatedFieldEncoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearRepeatedFieldEncoding\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearReserved: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearReserved\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRetention: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearRetention\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRubyPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearRubyPackage\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSemantic: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearSemantic\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearServerStreaming: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearServerStreaming\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSourceCodeInfo: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearSourceCodeInfo\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSourceContext: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearSourceContext\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSourceFile: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearSourceFile\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearStart: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearStart\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearStringValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearStringValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSwiftPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearSwiftPrefix\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSyntax: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearSyntax\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearTrailingComments: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearTrailingComments\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearTypeName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearTypeName\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearUnverifiedLazy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearUnverifiedLazy\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearUtf8Validation: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearUtf8Validation\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearVerification: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearVerification\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearVisibility: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearVisibility\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearWeak: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearWeak\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clientStreaming: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clientStreaming\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.code: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_code\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.codePoint: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_codePoint\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.codeUnits: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_codeUnits\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Collection: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Collection\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.comma: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_comma\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.consumedBytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_consumedBytes\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.contains: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_contains\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.contentsOf: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_contentsOf\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ContiguousBytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ContiguousBytes\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.copy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_copy\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.count: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_count\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.countVarintsInBuffer: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_countVarintsInBuffer\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.csharpNamespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_csharpNamespace\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ctype: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ctype\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.customCodable: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_customCodable\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.CustomDebugStringConvertible: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_CustomDebugStringConvertible\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.CustomStringConvertible: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_CustomStringConvertible\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.D: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_D\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.DataEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Data\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.dataResult: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_dataResult\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.date: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_date\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.daySec: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_daySec\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.daysSinceEpoch: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_daysSinceEpoch\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.debugDescriptionEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_debugDescription\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.debugRedact: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_debugRedact\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.declaration: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_declaration\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decoded: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decoded\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodedFromJSONNull: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodedFromJSONNull\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeExtensionField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeExtensionFieldsAsMessageSet: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeExtensionFieldsAsMessageSet\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeJSON: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeJSON\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeMapField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeMapField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeMessageEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeMessage\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Decoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Decoder\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeated\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedBoolField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedBoolField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedBytesField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedBytesField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedDoubleField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedDoubleField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedEnumField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedEnumField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedFixed32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedFixed64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedFloatField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedFloatField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedGroupField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedGroupField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedInt32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedInt64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedMessageField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedMessageField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedSFixed32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedSFixed64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedSInt32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedSInt64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedStringField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedStringField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedUInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedUInt32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedUInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedUInt64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingular: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingular\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularBoolField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularBoolField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularBytesField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularBytesField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularDoubleField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularDoubleField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularEnumField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularEnumField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularFixed32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularFixed64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularFloatField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularFloatField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularGroupField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularGroupField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularInt32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularInt64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularMessageField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularMessageField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularSFixed32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularSFixed64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularSInt32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularSInt64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularStringField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularStringField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularUInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularUInt32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularUInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularUInt64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeTextFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeTextFormat\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaultAnyTypeURLPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_defaultAnyTypeURLPrefix\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaults: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_defaults\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaultSymbolVisibility: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_defaultSymbolVisibility\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaultValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_defaultValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.dependency: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_dependency\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.deprecated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_deprecated\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.deprecatedLegacyJsonFieldConflicts: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_deprecatedLegacyJsonFieldConflicts\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.deprecationWarning: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_deprecationWarning\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.descriptionEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_description\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Dictionary: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Dictionary\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.dictionaryLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_dictionaryLiteral\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digit: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_digit\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digit0: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_digit0\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digit1: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_digit1\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digitCount: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_digitCount\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digits: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_digits\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digitValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_digitValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.discardableResult: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_discardableResult\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.discardUnknownFields: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_discardUnknownFields\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.DoubleEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Double\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.doubleValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_doubleValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.duration: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_duration\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.E: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_E\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.edition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_edition\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.EditionDefault: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_EditionDefault\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionDefaults: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_editionDefaults\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionDeprecated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_editionDeprecated\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionIntroduced: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_editionIntroduced\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionRemoved: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_editionRemoved\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Element: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Element\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.elements: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_elements\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.elseEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_else\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emitExtensionFieldName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_emitExtensionFieldName\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emitFieldName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_emitFieldName\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emitFieldNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_emitFieldNumber\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emptyAnyTypeURL: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_emptyAnyTypeURL\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emptyData: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_emptyData\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodeAsBytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_encodeAsBytes\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encoded: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_encoded\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodedJSONString: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_encodedJSONString\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodedSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_encodedSize\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodeField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_encodeField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_encoder\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.end: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_end\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endArray: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_endArray\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endMessageField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_endMessageField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endObject: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_endObject\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endRegularField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_endRegularField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enforceNamingStyle: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_enforceNamingStyle\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enumEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_enum\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.EnumReservedRange: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_EnumReservedRange\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enumType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_enumType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enumvalue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_enumvalue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.EquatableEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Equatable\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Error: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Error\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.execute: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_execute\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExpressibleByArrayLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExpressibleByArrayLiteral\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExpressibleByDictionaryLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExpressibleByDictionaryLiteral\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ext: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ext\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extDecoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extDecoder\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extendedGraphemeClusterLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extendedGraphemeClusterLiteral\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtendedGraphemeClusterLiteralType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExtendedGraphemeClusterLiteralType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extendee: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extendee\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensibleMessage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExtensibleMessage\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extension\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExtensionField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionFieldNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extensionFieldNumber\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionFieldValueSet: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExtensionFieldValueSet\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionMap: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExtensionMap\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionRange: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extensionRange\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extensions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extras: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extras\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.F: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_F\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.falseEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_false\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.features: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_features\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FeatureSetEditionDefault: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_FeatureSetEditionDefault\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.featureSupport: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_featureSupport\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldData: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldData\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FieldMaskError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_FieldMaskError\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldName\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNameCount: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldNameCount\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldNum\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldNumber\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNumberForProto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldNumberForProto\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldPresence: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldPresence\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fields: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fields\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldSize\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FieldTag: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_FieldTag\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FieldType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_FieldType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.file: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_file\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fileName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fileName\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.filter: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_filter\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.final: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_final\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.finiteOnly: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_finiteOnly\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.first: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_first\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.firstItem: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_firstItem\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fixedFeatures: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fixedFeatures\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FloatEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Float\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.floatLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_floatLiteral\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FloatLiteralType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_FloatLiteralType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_for\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forMessageName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_forMessageName\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.formUnion: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_formUnion\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forReadingFrom: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_forReadingFrom\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forTypeURL: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_forTypeURL\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ForwardParser: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ForwardParser\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forWritingInto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_forWritingInto\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.from: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_from\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromAscii2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fromAscii2\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromAscii4: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fromAscii4\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromByteOffset: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fromByteOffset\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromHexDigit: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fromHexDigit\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fullName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fullName\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.funcEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_func\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.function: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_function\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.G: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_G\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.get: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_get\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.getExtensionValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_getExtensionValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Any: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Any\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Api: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Api\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_BoolValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_BoolValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_BytesValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_BytesValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_DescriptorProto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_DescriptorProto\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_DoubleValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_DoubleValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Duration: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Duration\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Edition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Edition\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Empty: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Empty\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Enum\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumDescriptorProto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_EnumDescriptorProto\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_EnumOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_EnumValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueDescriptorProto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_EnumValueDescriptorProto\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_EnumValueOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_ExtensionRangeOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FeatureSet: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FeatureSet\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FeatureSetDefaults: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FeatureSetDefaults\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldDescriptorProto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FieldDescriptorProto\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldMask: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FieldMask\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FieldOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorProto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FileDescriptorProto\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorSet: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FileDescriptorSet\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FileOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FileOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FloatValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FloatValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_GeneratedCodeInfo\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Int32Value: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Int32Value\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Int64Value: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Int64Value\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ListValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_ListValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_MessageOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_MessageOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Method: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Method\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodDescriptorProto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_MethodDescriptorProto\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_MethodOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Mixin: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Mixin\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_NullValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_NullValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofDescriptorProto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_OneofDescriptorProto\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_OneofOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Option: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Option\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_ServiceDescriptorProto\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_ServiceOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceCodeInfo: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_SourceCodeInfo\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceContext: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_SourceContext\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_StringValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_StringValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Struct: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Struct\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_SymbolVisibility: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_SymbolVisibility\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Syntax: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Syntax\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Timestamp: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Timestamp\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Type: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Type\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt32Value: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_UInt32Value\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt64Value: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_UInt64Value\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_UninterpretedOption: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_UninterpretedOption\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Value: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Value\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.goPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_goPackage\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.gotData: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_gotData\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.group: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_group\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.groupFieldNumberStack: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_groupFieldNumberStack\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.groupSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_groupSize\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.guardEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_guard\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hadOneofValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hadOneofValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.handleConflictingOneOf: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_handleConflictingOneOf\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.handleInstruction: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_handleInstruction\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasAggregateValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasAggregateValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasAllowAlias: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasAllowAlias\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasBegin: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasBegin\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCcEnableArenas: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasCcEnableArenas\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCcGenericServices: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasCcGenericServices\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasClientStreaming: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasClientStreaming\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCsharpNamespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasCsharpNamespace\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCtype: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasCtype\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasData: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasData\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDebugRedact: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDebugRedact\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDefaultSymbolVisibility: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDefaultSymbolVisibility\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDefaultValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDefaultValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDeprecated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDeprecated\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDeprecatedLegacyJsonFieldConflicts: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDeprecatedLegacyJsonFieldConflicts\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDeprecationWarning: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDeprecationWarning\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDoubleValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDoubleValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEdition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEdition\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEditionDeprecated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEditionDeprecated\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEditionIntroduced: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEditionIntroduced\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEditionRemoved: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEditionRemoved\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEnd: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEnd\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEnforceNamingStyle: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEnforceNamingStyle\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEnumType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEnumType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasExplicitDelta: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasExplicitDelta\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasExtendee: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasExtendee\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasExtensionValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasExtensionValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFeatures: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasFeatures\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFeatureSupport: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasFeatureSupport\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFieldPresence: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasFieldPresence\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFixedFeatures: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasFixedFeatures\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFullName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasFullName\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasGoPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasGoPackage\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hash: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hash\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.HashableEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Hashable\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasher: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasher\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.HashVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_HashVisitor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasIdempotencyLevel: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasIdempotencyLevel\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasIdentifierValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasIdentifierValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasInputType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasInputType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasIsExtension: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasIsExtension\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaGenerateEqualsAndHash: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJavaGenerateEqualsAndHash\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaGenericServices: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJavaGenericServices\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaMultipleFiles: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJavaMultipleFiles\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaOuterClassname: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJavaOuterClassname\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJavaPackage\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaStringCheckUtf8: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJavaStringCheckUtf8\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJsonFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJsonFormat\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJsonName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJsonName\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJstype: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJstype\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasLabel: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasLabel\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasLazy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasLazy\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasLeadingComments: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasLeadingComments\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMapEntry: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasMapEntry\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMaximumEdition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasMaximumEdition\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMessageEncoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasMessageEncoding\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMessageSetWireFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasMessageSetWireFormat\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMinimumEdition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasMinimumEdition\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasName\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNamePart: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasNamePart\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNegativeIntValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasNegativeIntValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNoStandardDescriptorAccessor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasNoStandardDescriptorAccessor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasNumber\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasObjcClassPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasObjcClassPrefix\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOneofIndex: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasOneofIndex\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOptimizeFor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasOptimizeFor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOutputType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasOutputType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOverridableFeatures: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasOverridableFeatures\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPackage\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPacked: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPacked\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPhpClassPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPhpClassPrefix\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPhpMetadataNamespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPhpMetadataNamespace\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPhpNamespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPhpNamespace\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPositiveIntValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPositiveIntValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasProto3Optional: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasProto3Optional\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPyGenericServices: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPyGenericServices\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRemovalError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasRemovalError\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRepeated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasRepeated\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRepeatedFieldEncoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasRepeatedFieldEncoding\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasReserved: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasReserved\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRetention: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasRetention\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRubyPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasRubyPackage\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSemantic: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasSemantic\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasServerStreaming: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasServerStreaming\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSourceCodeInfo: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasSourceCodeInfo\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSourceContext: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasSourceContext\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSourceFile: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasSourceFile\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasStart: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasStart\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasStringValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasStringValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSwiftPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasSwiftPrefix\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSyntax: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasSyntax\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasTrailingComments: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasTrailingComments\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasTypeName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasTypeName\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasUnverifiedLazy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasUnverifiedLazy\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasUtf8Validation: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasUtf8Validation\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasVerification: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasVerification\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasVisibility: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasVisibility\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasWeak: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasWeak\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hour: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hour\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.i: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_i\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.idempotencyLevel: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_idempotencyLevel\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.identifierValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_identifierValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ifEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_if\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ignoreUnknownExtensionFields: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ignoreUnknownExtensionFields\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ignoreUnknownFields: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ignoreUnknownFields\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.index: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_index\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.initEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_init\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.inoutEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_inout\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.inputType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_inputType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.insert: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_insert\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Instruction: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Instruction\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.IntEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Int\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Int32Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Int32\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Int64Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Int64\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Int8: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Int8\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.integerLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_integerLiteral\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.IntegerLiteralType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_IntegerLiteralType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.intern: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_intern\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Internal: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Internal\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.InternalState: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_InternalState\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.intersect: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_intersect\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.into: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_into\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ints: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ints\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.invalidAnyTypeURL: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_invalidAnyTypeURL\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isA: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isA\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isEqual: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isEqual\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isEqualTo: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isEqualTo\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isExtension: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isExtension\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isInitializedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isInitialized\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isNegative: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isNegative\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isPathValid: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isPathValid\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isReserved: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isReserved\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isValid: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isValid\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.itemTagsEncodedSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_itemTagsEncodedSize\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.iterator: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_iterator\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaGenerateEqualsAndHash: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_javaGenerateEqualsAndHash\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaGenericServices: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_javaGenericServices\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaMultipleFiles: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_javaMultipleFiles\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaOuterClassname: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_javaOuterClassname\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_javaPackage\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaStringCheckUtf8: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_javaStringCheckUtf8\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONDecoder\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONDecoding\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecodingError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONDecodingError\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecodingOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONDecodingOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonEncoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonEncoder\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONEncoding\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncodingError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONEncodingError\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncodingOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONEncodingOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncodingVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONEncodingVisitor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonFormat\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONMapEncodingVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONMapEncodingVisitor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonName\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonPath: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonPath\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonPaths: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonPaths\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONScanner: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONScanner\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonString: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonString\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonText: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonText\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonUTF8Bytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonUTF8Bytes\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonUTF8Data: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonUTF8Data\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jstype: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jstype\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.k: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_k\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.kChunkSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_kChunkSize\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Key: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Key\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.keyField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_keyField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.keyFieldOpt: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_keyFieldOpt\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.KeyType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_KeyType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.kind: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_kind\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.l: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_l\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.label: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_label\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.lazy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_lazy\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.leadingComments: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_leadingComments\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.leadingDetachedComments: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_leadingDetachedComments\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.length: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_length\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.lessThan: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_lessThan\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.letEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_let\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.lhs: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_lhs\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.line: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_line\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.list: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_list\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.listOfMessages: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_listOfMessages\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.listValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_listValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.littleEndian: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_littleEndian\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.load: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_load\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.localHasher: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_localHasher\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.location: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_location\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.M: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_M\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.major: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_major\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.makeAsyncIterator: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_makeAsyncIterator\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.makeIterator: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_makeIterator\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.malformedLength: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_malformedLength\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapEntry: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mapEntry\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MapKeyType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_MapKeyType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapToMessages: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mapToMessages\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MapValueType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_MapValueType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mapVisitor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mask: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mask\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.maximumEdition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_maximumEdition\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mdayStart: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mdayStart\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.merge: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_merge\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MergeOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_MergeOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.message: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_message\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageDepthLimit: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_messageDepthLimit\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageEncoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_messageEncoding\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MessageExtension: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_MessageExtension\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MessageImplementationBase: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_MessageImplementationBase\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MessageSet: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_MessageSet\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageSetWireFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_messageSetWireFormat\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_messageSize\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_messageType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.method: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_method\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.methods: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_methods\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.min: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_min\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.minimumEdition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_minimumEdition\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.minor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_minor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mixins: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mixins\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.modify: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_modify\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.month: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_month\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.msgExtension: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_msgExtension\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mutating: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mutating\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.n: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_n\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.name: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_name\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.NameDescription: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_NameDescription\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.NameMap: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_NameMap\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.NamePart: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_NamePart\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.names: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_names\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nanos: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nanos\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.negativeIntValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_negativeIntValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nestedType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nestedType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newExtensible: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_newExtensible\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newL: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_newL\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newList: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_newList\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newMessage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_newMessage\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_newValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.next: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_next\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextByte: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextByte\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextFieldNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextFieldNumber\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextInstruction: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextInstruction\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextInt32: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextInt32\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextNullTerminatedString: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextNullTerminatedString\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextNullTerminatedStringArray: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextNullTerminatedStringArray\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextNumber\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextUInt64: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextUInt64\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextVarInt: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextVarInt\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nilEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nil\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nilLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nilLiteral\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.noBytesAvailable: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_noBytesAvailable\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.noStandardDescriptorAccessor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_noStandardDescriptorAccessor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nullValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nullValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.number: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_number\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.numberValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_numberValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.objcClassPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_objcClassPrefix\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.of: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_of\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OneOf_Kind: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OneOf_Kind\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofDecl: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_oneofDecl\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofIndex: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_oneofIndex\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofs: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_oneofs\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.optimizeFor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_optimizeFor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptimizeMode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptimizeMode\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalEnumExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptionalEnumExtensionField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptionalExtensionField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalGroupExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptionalGroupExtensionField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalMessageExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptionalMessageExtensionField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.optionDependency: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_optionDependency\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionRetention: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptionRetention\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.options: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_options\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionTargetType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptionTargetType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.other: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_other\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.others: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_others\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.out: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_out\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.outputType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_outputType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.overridableFeatures: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_overridableFeatures\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.p: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_p\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.package: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_package\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packed: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_packed\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PackedEnumExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_PackedEnumExtensionField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PackedExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_PackedExtensionField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.padding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_padding\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.parent: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_parent\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.parse: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_parse\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.partial: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_partial\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.path: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_path\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PathDecoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_PathDecoder\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PathDecodingError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_PathDecodingError\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.paths: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_paths\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PathVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_PathVisitor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.payload: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_payload\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.payloadSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_payloadSize\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpClassPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_phpClassPrefix\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpMetadataNamespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_phpMetadataNamespace\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpNamespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_phpNamespace\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.pos: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_pos\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.positiveIntValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_positiveIntValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.prefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_prefix\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.preserveProtoFieldNames: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_preserveProtoFieldNames\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.preTraverse: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_preTraverse\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.previousNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_previousNumber\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.prevPath: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_prevPath\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.printUnknownFields: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_printUnknownFields\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.programBuffer: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_programBuffer\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.programFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_programFormat\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_proto2\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto3DefaultValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_proto3DefaultValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto3Optional: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_proto3Optional\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobuf_extensionFieldValues\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_fieldNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobuf_fieldNumber\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobuf_generated_isEqualTo\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_nameMap: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobuf_nameMap\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_newField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobuf_newField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_package: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobuf_package\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufAPIVersion_2\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufAPIVersionCheck\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufBool: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufBool\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufBytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufBytes\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobufData: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobufData\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufDouble: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufDouble\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufEnumMap: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufEnumMap\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobufExtension: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobufExtension\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFixed32: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufFixed32\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFixed64: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufFixed64\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFloat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufFloat\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufInt32: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufInt32\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufInt64: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufInt64\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufMap: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufMap\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufMessageMap: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufMessageMap\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSFixed32: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufSFixed32\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSFixed64: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufSFixed64\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSInt32: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufSInt32\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSInt64: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufSInt64\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufString: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufString\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufUInt32: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufUInt32\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufUInt64: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufUInt64\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protocolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protocol\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoFieldName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protoFieldName\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoMessageNameEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protoMessageName\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtoNameProviding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtoNameProviding\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoPaths: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protoPaths\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.publicEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_public\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.publicDependency: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_publicDependency\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putBoolValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putBoolValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putBytesValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putBytesValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putDoubleValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putDoubleValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putEnumValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putEnumValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFixedUInt32: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putFixedUInt32\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFixedUInt64: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putFixedUInt64\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFloatValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putFloatValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putInt64: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putInt64\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putStringValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putStringValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putUInt64: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putUInt64\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putUInt64Hex: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putUInt64Hex\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putVarInt: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putVarInt\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putZigZagVarInt: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putZigZagVarInt\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.pyGenericServices: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_pyGenericServices\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.R: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_R\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rawChars: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_rawChars\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RawRepresentable: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_RawRepresentable\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RawValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_RawValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.read4HexDigits: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_read4HexDigits\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.readBytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_readBytes\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.reader: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_reader\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.register: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_register\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.remainingProgram: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_remainingProgram\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.removalError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_removalError\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.removingAllFieldsOf: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_removingAllFieldsOf\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_repeated\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_RepeatedEnumExtensionField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_RepeatedExtensionField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedFieldEncoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_repeatedFieldEncoding\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_RepeatedGroupExtensionField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_RepeatedMessageExtensionField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeating: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_repeating\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.replaceRepeatedFields: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_replaceRepeatedFields\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requestStreaming: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_requestStreaming\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requestTypeURL: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_requestTypeURL\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requiredSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_requiredSize\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.responseStreaming: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_responseStreaming\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.responseTypeURL: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_responseTypeURL\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.result: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_result\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.retention: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_retention\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rethrowsEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_rethrows\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ReturnType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ReturnType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.revision: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_revision\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rhs: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_rhs\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.root: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_root\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rubyPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_rubyPackage\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.s: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_s\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawBackslash: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sawBackslash\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawSection4Characters: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sawSection4Characters\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawSection5Characters: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sawSection5Characters\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Scalar: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Scalar\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.scan: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_scan\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.scanner: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_scanner\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.seconds: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_seconds\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.selfEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_self\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.semantic: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_semantic\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SendableEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Sendable\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.separator: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_separator\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serialize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_serialize\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedBytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_serializedBytes\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedData: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_serializedData\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_serializedSize\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serverStreaming: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_serverStreaming\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.service: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_service\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.set: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_set\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.setExtensionValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_setExtensionValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.shift: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_shift\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SimpleExtensionMap: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_SimpleExtensionMap\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.size: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_size\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sizer: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sizer\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.source: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_source\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceCodeInfo: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sourceCodeInfo\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceContext: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sourceContext\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceEncoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sourceEncoding\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceFile: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sourceFile\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SourceLocation: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_SourceLocation\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.span: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_span\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.split: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_split\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.start: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_start\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startArray: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startArray\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startArrayObject: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startArrayObject\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startIndex: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startIndex\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startMessageField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startMessageField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startObject: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startObject\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startRegularField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startRegularField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.state: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_state\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.staticEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_static\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.StaticString: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_StaticString\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.storage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_storage\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.StringEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_String\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.stringLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_stringLiteral\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.StringLiteralType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_StringLiteralType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.stringResult: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_stringResult\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.stringValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_stringValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.structEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_struct\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.structValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_structValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subDecoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_subDecoder\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subscriptEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_subscript\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subtract: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_subtract\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_subVisitor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SwiftEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Swift\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.swiftPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_swiftPrefix\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SwiftProtobufContiguousBytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_SwiftProtobufContiguousBytes\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SwiftProtobufError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_SwiftProtobufError\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.syntax: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_syntax\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.T: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_T\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tag: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_tag\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.targets: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_targets\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.terminator: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_terminator\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.testDecoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_testDecoder\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.text: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_text\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.textDecoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_textDecoder\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatDecoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_TextFormatDecoder\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatDecodingError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_TextFormatDecodingError\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatDecodingOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_TextFormatDecodingOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatEncodingOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_TextFormatEncodingOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatEncodingVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_TextFormatEncodingVisitor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.textFormatString: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_textFormatString\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.throwOrIgnore: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_throwOrIgnore\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.throwsEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_throws\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeInterval: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_timeInterval\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeIntervalSince1970: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_timeIntervalSince1970\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_timeIntervalSinceReferenceDate\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tmp: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_tmp\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tooLarge: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_tooLarge\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.total: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_total\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.totalArrayDepth: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_totalArrayDepth\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.totalSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_totalSize\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.trailingComments: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_trailingComments\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.traverseEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_traverse\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.trim: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_trim\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.trueEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_true\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tryEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_try\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.type: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_type\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typealiasEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_typealias\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TypeEnumEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_TypeEnum\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_typeName\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typePrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_typePrefix\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeStart: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_typeStart\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeUnknown: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_typeUnknown\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeURL: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_typeURL\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UInt32Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UInt32\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UInt64Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UInt64\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UInt8: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UInt8\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unchecked: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unchecked\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Unicode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Unicode\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unicodeScalarLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unicodeScalarLiteral\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnicodeScalarLiteralType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnicodeScalarLiteralType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unicodeScalars: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unicodeScalars\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnicodeScalarView: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnicodeScalarView\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.uninterpretedOption: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_uninterpretedOption\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.union: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_union\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.uniqueStorage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_uniqueStorage\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unknown: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unknown\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unknownFieldsEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unknownFields\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnknownStorage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnknownStorage\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unpackTo: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unpackTo\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeBufferPointer: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnsafeBufferPointer\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeMutablePointer: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnsafeMutablePointer\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeMutableRawBufferPointer: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnsafeMutableRawBufferPointer\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeRawBufferPointer: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnsafeRawBufferPointer\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeRawPointer: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnsafeRawPointer\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unverifiedLazy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unverifiedLazy\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.updatedOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_updatedOptions\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.uppercasedAssumingASCII: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_uppercasedAssumingASCII\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.url: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_url\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.useDeterministicOrdering: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_useDeterministicOrdering\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_utf8\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8Ptr: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_utf8Ptr\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8ToDouble: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_utf8ToDouble\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8Validation: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_utf8Validation\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UTF8View: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UTF8View\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.V: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_V\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.value: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_value\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.valueField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_valueField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.values: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_values\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ValueType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ValueType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.varEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_var\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.verification: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_verification\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.VerificationState: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_VerificationState\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.version: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_version\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.versionString: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_versionString\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visibility: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visibility\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.VisibilityFeature: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_VisibilityFeature\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitExtensionFields: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitExtensionFields\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitExtensionFieldsAsMessageSet: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitExtensionFieldsAsMessageSet\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitMapField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitMapField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Visitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Visitor\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPacked: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPacked\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedBoolField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedBoolField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedDoubleField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedDoubleField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedEnumField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedEnumField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedFixed32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedFixed64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedFloatField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedFloatField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedInt32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedInt64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedSFixed32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedSFixed64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedSInt32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedSInt64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedUInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedUInt32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedUInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedUInt64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeated\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedBoolField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedBoolField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedBytesField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedBytesField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedDoubleField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedDoubleField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedEnumField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedEnumField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedFixed32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedFixed64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedFloatField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedFloatField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedGroupField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedGroupField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedInt32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedInt64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedMessageField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedMessageField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedSFixed32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedSFixed64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedSInt32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedSInt64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedStringField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedStringField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedUInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedUInt32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedUInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedUInt64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingular: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingular\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularBoolField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularBoolField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularBytesField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularBytesField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularDoubleField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularDoubleField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularEnumField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularEnumField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularFixed32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularFixed64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularFloatField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularFloatField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularGroupField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularGroupField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularInt32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularInt64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularMessageField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularMessageField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularSFixed32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularSFixed64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularSInt32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularSInt64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularStringField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularStringField\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularUInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularUInt32Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularUInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularUInt64Field\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitUnknown: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitUnknown\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Void: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Void\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.wasDecoded: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_wasDecoded\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.weak: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_weak\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.weakDependency: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_weakDependency\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.whereEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_where\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.wireFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_wireFormat\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.with: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_with\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.withUnsafeBytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_withUnsafeBytes\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.withUnsafeMutableBytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_withUnsafeMutableBytes\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.work: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_work\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Wrapped: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Wrapped\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.WrappedType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_WrappedType\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.wrappedValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_wrappedValue\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.written: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_written\0") +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.yday: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_yday\0") +} diff --git a/Reference/generated_swift_names_fields.pb.swift b/Reference/Tests/SwiftProtobufTests/generated_swift_names_fields.pb.swift similarity index 68% rename from Reference/generated_swift_names_fields.pb.swift rename to Reference/Tests/SwiftProtobufTests/generated_swift_names_fields.pb.swift index b2769c8e1..815e18951 100644 --- a/Reference/generated_swift_names_fields.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/generated_swift_names_fields.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: generated_swift_names_fields.proto @@ -11,7 +12,6 @@ /// Protoc errors imply this file is being generated incorrectly /// Swift compile errors are probably bugs in protoc-gen-swift -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -24,4353 +24,5143 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittestGenerated_GeneratedSwiftReservedFields { +struct SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: @unchecked Sendable { // 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 addPath: Int32 { + get {_storage._addPath} + set {_uniqueStorage()._addPath = newValue} + } + var adjusted: Int32 { - get {return _storage._adjusted} + get {_storage._adjusted} set {_uniqueStorage()._adjusted = newValue} } var aggregateValue: Int32 { - get {return _storage._aggregateValue} + get {_storage._aggregateValue} set {_uniqueStorage()._aggregateValue = newValue} } var allCases: Int32 { - get {return _storage._allCases} + get {_storage._allCases} set {_uniqueStorage()._allCases = newValue} } var allowAlias: Int32 { - get {return _storage._allowAlias} + get {_storage._allowAlias} set {_uniqueStorage()._allowAlias = newValue} } var alwaysPrintEnumsAsInts: Int32 { - get {return _storage._alwaysPrintEnumsAsInts} + get {_storage._alwaysPrintEnumsAsInts} set {_uniqueStorage()._alwaysPrintEnumsAsInts = newValue} } + var alwaysPrintInt64SAsNumbers: Int32 { + get {_storage._alwaysPrintInt64SAsNumbers} + set {_uniqueStorage()._alwaysPrintInt64SAsNumbers = newValue} + } + var annotation: Int32 { - get {return _storage._annotation} + get {_storage._annotation} set {_uniqueStorage()._annotation = newValue} } var any: Int32 { - get {return _storage._any} + get {_storage._any} set {_uniqueStorage()._any = newValue} } var anyExtensionField: Int32 { - get {return _storage._anyExtensionField} + get {_storage._anyExtensionField} set {_uniqueStorage()._anyExtensionField = newValue} } var anyMessageExtension: Int32 { - get {return _storage._anyMessageExtension} + get {_storage._anyMessageExtension} set {_uniqueStorage()._anyMessageExtension = newValue} } var anyMessageStorage: Int32 { - get {return _storage._anyMessageStorage} + get {_storage._anyMessageStorage} set {_uniqueStorage()._anyMessageStorage = newValue} } var anyUnpackError: Int32 { - get {return _storage._anyUnpackError} + get {_storage._anyUnpackError} set {_uniqueStorage()._anyUnpackError = newValue} } - var api: Int32 { - get {return _storage._api} - set {_uniqueStorage()._api = newValue} + var append: Int32 { + get {_storage._append} + set {_uniqueStorage()._append = newValue} } var appended: Int32 { - get {return _storage._appended} + get {_storage._appended} set {_uniqueStorage()._appended = newValue} } var appendUintHex: Int32 { - get {return _storage._appendUintHex} + get {_storage._appendUintHex} set {_uniqueStorage()._appendUintHex = newValue} } var appendUnknown: Int32 { - get {return _storage._appendUnknown} + get {_storage._appendUnknown} set {_uniqueStorage()._appendUnknown = newValue} } var areAllInitialized: Int32 { - get {return _storage._areAllInitialized} + get {_storage._areAllInitialized} set {_uniqueStorage()._areAllInitialized = newValue} } var array: Int32 { - get {return _storage._array} + get {_storage._array} set {_uniqueStorage()._array = newValue} } var arrayDepth: Int32 { - get {return _storage._arrayDepth} + get {_storage._arrayDepth} set {_uniqueStorage()._arrayDepth = newValue} } var arrayLiteral: Int32 { - get {return _storage._arrayLiteral} + get {_storage._arrayLiteral} set {_uniqueStorage()._arrayLiteral = newValue} } var arraySeparator: Int32 { - get {return _storage._arraySeparator} + get {_storage._arraySeparator} set {_uniqueStorage()._arraySeparator = newValue} } var `as`: Int32 { - get {return _storage._as} + get {_storage._as} set {_uniqueStorage()._as = newValue} } var asciiOpenCurlyBracket: Int32 { - get {return _storage._asciiOpenCurlyBracket} + get {_storage._asciiOpenCurlyBracket} set {_uniqueStorage()._asciiOpenCurlyBracket = newValue} } var asciiZero: Int32 { - get {return _storage._asciiZero} + get {_storage._asciiZero} set {_uniqueStorage()._asciiZero = newValue} } + var async: Int32 { + get {_storage._async} + set {_uniqueStorage()._async = newValue} + } + + var asyncIterator: Int32 { + get {_storage._asyncIterator} + set {_uniqueStorage()._asyncIterator = newValue} + } + + var asyncIteratorProtocol: Int32 { + get {_storage._asyncIteratorProtocol} + set {_uniqueStorage()._asyncIteratorProtocol = newValue} + } + + var asyncMessageSequence: Int32 { + get {_storage._asyncMessageSequence} + set {_uniqueStorage()._asyncMessageSequence = newValue} + } + var available: Int32 { - get {return _storage._available} + get {_storage._available} set {_uniqueStorage()._available = newValue} } var b: Int32 { - get {return _storage._b} + get {_storage._b} set {_uniqueStorage()._b = newValue} } + var base: Int32 { + get {_storage._base} + set {_uniqueStorage()._base = newValue} + } + var base64Values: Int32 { - get {return _storage._base64Values} + get {_storage._base64Values} set {_uniqueStorage()._base64Values = newValue} } var baseAddress: Int32 { - get {return _storage._baseAddress} + get {_storage._baseAddress} set {_uniqueStorage()._baseAddress = newValue} } var baseType: Int32 { - get {return _storage._baseType} + get {_storage._baseType} set {_uniqueStorage()._baseType = newValue} } var begin: Int32 { - get {return _storage._begin} + get {_storage._begin} set {_uniqueStorage()._begin = newValue} } var binary: Int32 { - get {return _storage._binary} + get {_storage._binary} set {_uniqueStorage()._binary = newValue} } var binaryDecoder: Int32 { - get {return _storage._binaryDecoder} + get {_storage._binaryDecoder} set {_uniqueStorage()._binaryDecoder = newValue} } + var binaryDecoding: Int32 { + get {_storage._binaryDecoding} + set {_uniqueStorage()._binaryDecoding = newValue} + } + var binaryDecodingError: Int32 { - get {return _storage._binaryDecodingError} + get {_storage._binaryDecodingError} set {_uniqueStorage()._binaryDecodingError = newValue} } var binaryDecodingOptions: Int32 { - get {return _storage._binaryDecodingOptions} + get {_storage._binaryDecodingOptions} set {_uniqueStorage()._binaryDecodingOptions = newValue} } var binaryDelimited: Int32 { - get {return _storage._binaryDelimited} + get {_storage._binaryDelimited} set {_uniqueStorage()._binaryDelimited = newValue} } var binaryEncoder: Int32 { - get {return _storage._binaryEncoder} + get {_storage._binaryEncoder} set {_uniqueStorage()._binaryEncoder = newValue} } var binaryEncodingError: Int32 { - get {return _storage._binaryEncodingError} + get {_storage._binaryEncodingError} set {_uniqueStorage()._binaryEncodingError = newValue} } var binaryEncodingMessageSetSizeVisitor: Int32 { - get {return _storage._binaryEncodingMessageSetSizeVisitor} + get {_storage._binaryEncodingMessageSetSizeVisitor} set {_uniqueStorage()._binaryEncodingMessageSetSizeVisitor = newValue} } var binaryEncodingMessageSetVisitor: Int32 { - get {return _storage._binaryEncodingMessageSetVisitor} + get {_storage._binaryEncodingMessageSetVisitor} set {_uniqueStorage()._binaryEncodingMessageSetVisitor = newValue} } + var binaryEncodingOptions: Int32 { + get {_storage._binaryEncodingOptions} + set {_uniqueStorage()._binaryEncodingOptions = newValue} + } + var binaryEncodingSizeVisitor: Int32 { - get {return _storage._binaryEncodingSizeVisitor} + get {_storage._binaryEncodingSizeVisitor} set {_uniqueStorage()._binaryEncodingSizeVisitor = newValue} } var binaryEncodingVisitor: Int32 { - get {return _storage._binaryEncodingVisitor} + get {_storage._binaryEncodingVisitor} set {_uniqueStorage()._binaryEncodingVisitor = newValue} } var binaryOptions: Int32 { - get {return _storage._binaryOptions} + get {_storage._binaryOptions} set {_uniqueStorage()._binaryOptions = newValue} } + var binaryProtobufDelimitedMessages: Int32 { + get {_storage._binaryProtobufDelimitedMessages} + set {_uniqueStorage()._binaryProtobufDelimitedMessages = newValue} + } + + var binaryStreamDecoding: Int32 { + get {_storage._binaryStreamDecoding} + set {_uniqueStorage()._binaryStreamDecoding = newValue} + } + + var binaryStreamDecodingError: Int32 { + get {_storage._binaryStreamDecodingError} + set {_uniqueStorage()._binaryStreamDecodingError = newValue} + } + + var bitPattern: Int32 { + get {_storage._bitPattern} + set {_uniqueStorage()._bitPattern = newValue} + } + var body: Int32 { - get {return _storage._body} + get {_storage._body} set {_uniqueStorage()._body = newValue} } var bool: Int32 { - get {return _storage._bool} + get {_storage._bool} set {_uniqueStorage()._bool = newValue} } var booleanLiteral: Int32 { - get {return _storage._booleanLiteral} + get {_storage._booleanLiteral} set {_uniqueStorage()._booleanLiteral = newValue} } var booleanLiteralType: Int32 { - get {return _storage._booleanLiteralType} + get {_storage._booleanLiteralType} set {_uniqueStorage()._booleanLiteralType = newValue} } var boolValue: Int32 { - get {return _storage._boolValue} + get {_storage._boolValue} set {_uniqueStorage()._boolValue = newValue} } + var buffer: Int32 { + get {_storage._buffer} + set {_uniqueStorage()._buffer = newValue} + } + + var byte: Int32 { + get {_storage._byte} + set {_uniqueStorage()._byte = newValue} + } + + var bytecode: Int32 { + get {_storage._bytecode} + set {_uniqueStorage()._bytecode = newValue} + } + + var bytecodeReader: Int32 { + get {_storage._bytecodeReader} + set {_uniqueStorage()._bytecodeReader = newValue} + } + var bytes: Int32 { - get {return _storage._bytes} + get {_storage._bytes} set {_uniqueStorage()._bytes = newValue} } var bytesInGroup: Int32 { - get {return _storage._bytesInGroup} + get {_storage._bytesInGroup} set {_uniqueStorage()._bytesInGroup = newValue} } - var bytesRead: Int32 { - get {return _storage._bytesRead} - set {_uniqueStorage()._bytesRead = newValue} + var bytesNeeded: Int32 { + get {_storage._bytesNeeded} + set {_uniqueStorage()._bytesNeeded = newValue} } - var bytesValue: Int32 { - get {return _storage._bytesValue} - set {_uniqueStorage()._bytesValue = newValue} + var bytesRead: Int32 { + get {_storage._bytesRead} + set {_uniqueStorage()._bytesRead = newValue} } var c: Int32 { - get {return _storage._c} + get {_storage._c} set {_uniqueStorage()._c = newValue} } + var canonical: Int32 { + get {_storage._canonical} + set {_uniqueStorage()._canonical = newValue} + } + var capitalizeNext: Int32 { - get {return _storage._capitalizeNext} + get {_storage._capitalizeNext} set {_uniqueStorage()._capitalizeNext = newValue} } var cardinality: Int32 { - get {return _storage._cardinality} + get {_storage._cardinality} set {_uniqueStorage()._cardinality = newValue} } + var caseIterable: Int32 { + get {_storage._caseIterable} + set {_uniqueStorage()._caseIterable = newValue} + } + + var castedValue: Int32 { + get {_storage._castedValue} + set {_uniqueStorage()._castedValue = newValue} + } + var ccEnableArenas: Int32 { - get {return _storage._ccEnableArenas} + get {_storage._ccEnableArenas} set {_uniqueStorage()._ccEnableArenas = newValue} } var ccGenericServices: Int32 { - get {return _storage._ccGenericServices} + get {_storage._ccGenericServices} set {_uniqueStorage()._ccGenericServices = newValue} } var character: Int32 { - get {return _storage._character} + get {_storage._character} set {_uniqueStorage()._character = newValue} } var chars: Int32 { - get {return _storage._chars} + get {_storage._chars} set {_uniqueStorage()._chars = newValue} } + var checkProgramFormat: Int32 { + get {_storage._checkProgramFormat} + set {_uniqueStorage()._checkProgramFormat = newValue} + } + + var chunk: Int32 { + get {_storage._chunk} + set {_uniqueStorage()._chunk = newValue} + } + var `class`: Int32 { - get {return _storage._class} + get {_storage._class} set {_uniqueStorage()._class = newValue} } var clearAggregateValue_p: Int32 { - get {return _storage._clearAggregateValue_p} + get {_storage._clearAggregateValue_p} set {_uniqueStorage()._clearAggregateValue_p = newValue} } var clearAllowAlias_p: Int32 { - get {return _storage._clearAllowAlias_p} + get {_storage._clearAllowAlias_p} set {_uniqueStorage()._clearAllowAlias_p = newValue} } var clearBegin_p: Int32 { - get {return _storage._clearBegin_p} + get {_storage._clearBegin_p} set {_uniqueStorage()._clearBegin_p = newValue} } var clearCcEnableArenas_p: Int32 { - get {return _storage._clearCcEnableArenas_p} + get {_storage._clearCcEnableArenas_p} set {_uniqueStorage()._clearCcEnableArenas_p = newValue} } var clearCcGenericServices_p: Int32 { - get {return _storage._clearCcGenericServices_p} + get {_storage._clearCcGenericServices_p} set {_uniqueStorage()._clearCcGenericServices_p = newValue} } var clearClientStreaming_p: Int32 { - get {return _storage._clearClientStreaming_p} + get {_storage._clearClientStreaming_p} set {_uniqueStorage()._clearClientStreaming_p = newValue} } var clearCsharpNamespace_p: Int32 { - get {return _storage._clearCsharpNamespace_p} + get {_storage._clearCsharpNamespace_p} set {_uniqueStorage()._clearCsharpNamespace_p = newValue} } var clearCtype_p: Int32 { - get {return _storage._clearCtype_p} + get {_storage._clearCtype_p} set {_uniqueStorage()._clearCtype_p = newValue} } + var clearDebugRedact_p: Int32 { + get {_storage._clearDebugRedact_p} + set {_uniqueStorage()._clearDebugRedact_p = newValue} + } + + var clearDefaultSymbolVisibility_p: Int32 { + get {_storage._clearDefaultSymbolVisibility_p} + set {_uniqueStorage()._clearDefaultSymbolVisibility_p = newValue} + } + var clearDefaultValue_p: Int32 { - get {return _storage._clearDefaultValue_p} + get {_storage._clearDefaultValue_p} set {_uniqueStorage()._clearDefaultValue_p = newValue} } var clearDeprecated_p: Int32 { - get {return _storage._clearDeprecated_p} + get {_storage._clearDeprecated_p} set {_uniqueStorage()._clearDeprecated_p = newValue} } + var clearDeprecatedLegacyJsonFieldConflicts_p: Int32 { + get {_storage._clearDeprecatedLegacyJsonFieldConflicts_p} + set {_uniqueStorage()._clearDeprecatedLegacyJsonFieldConflicts_p = newValue} + } + + var clearDeprecationWarning_p: Int32 { + get {_storage._clearDeprecationWarning_p} + set {_uniqueStorage()._clearDeprecationWarning_p = newValue} + } + var clearDoubleValue_p: Int32 { - get {return _storage._clearDoubleValue_p} + get {_storage._clearDoubleValue_p} set {_uniqueStorage()._clearDoubleValue_p = newValue} } + var clearEdition_p: Int32 { + get {_storage._clearEdition_p} + set {_uniqueStorage()._clearEdition_p = newValue} + } + + var clearEditionDeprecated_p: Int32 { + get {_storage._clearEditionDeprecated_p} + set {_uniqueStorage()._clearEditionDeprecated_p = newValue} + } + + var clearEditionIntroduced_p: Int32 { + get {_storage._clearEditionIntroduced_p} + set {_uniqueStorage()._clearEditionIntroduced_p = newValue} + } + + var clearEditionRemoved_p: Int32 { + get {_storage._clearEditionRemoved_p} + set {_uniqueStorage()._clearEditionRemoved_p = newValue} + } + var clearEnd_p: Int32 { - get {return _storage._clearEnd_p} + get {_storage._clearEnd_p} set {_uniqueStorage()._clearEnd_p = newValue} } + var clearEnforceNamingStyle_p: Int32 { + get {_storage._clearEnforceNamingStyle_p} + set {_uniqueStorage()._clearEnforceNamingStyle_p = newValue} + } + + var clearEnumType_p: Int32 { + get {_storage._clearEnumType_p} + set {_uniqueStorage()._clearEnumType_p = newValue} + } + var clearExtendee_p: Int32 { - get {return _storage._clearExtendee_p} + get {_storage._clearExtendee_p} set {_uniqueStorage()._clearExtendee_p = newValue} } var clearExtensionValue_p: Int32 { - get {return _storage._clearExtensionValue_p} + get {_storage._clearExtensionValue_p} set {_uniqueStorage()._clearExtensionValue_p = newValue} } + var clearFeatures_p: Int32 { + get {_storage._clearFeatures_p} + set {_uniqueStorage()._clearFeatures_p = newValue} + } + + var clearFeatureSupport_p: Int32 { + get {_storage._clearFeatureSupport_p} + set {_uniqueStorage()._clearFeatureSupport_p = newValue} + } + + var clearFieldPresence_p: Int32 { + get {_storage._clearFieldPresence_p} + set {_uniqueStorage()._clearFieldPresence_p = newValue} + } + + var clearFixedFeatures_p: Int32 { + get {_storage._clearFixedFeatures_p} + set {_uniqueStorage()._clearFixedFeatures_p = newValue} + } + + var clearFullName_p: Int32 { + get {_storage._clearFullName_p} + set {_uniqueStorage()._clearFullName_p = newValue} + } + var clearGoPackage_p: Int32 { - get {return _storage._clearGoPackage_p} + get {_storage._clearGoPackage_p} set {_uniqueStorage()._clearGoPackage_p = newValue} } var clearIdempotencyLevel_p: Int32 { - get {return _storage._clearIdempotencyLevel_p} + get {_storage._clearIdempotencyLevel_p} set {_uniqueStorage()._clearIdempotencyLevel_p = newValue} } var clearIdentifierValue_p: Int32 { - get {return _storage._clearIdentifierValue_p} + get {_storage._clearIdentifierValue_p} set {_uniqueStorage()._clearIdentifierValue_p = newValue} } var clearInputType_p: Int32 { - get {return _storage._clearInputType_p} + get {_storage._clearInputType_p} set {_uniqueStorage()._clearInputType_p = newValue} } var clearIsExtension_p: Int32 { - get {return _storage._clearIsExtension_p} + get {_storage._clearIsExtension_p} set {_uniqueStorage()._clearIsExtension_p = newValue} } var clearJavaGenerateEqualsAndHash_p: Int32 { - get {return _storage._clearJavaGenerateEqualsAndHash_p} + get {_storage._clearJavaGenerateEqualsAndHash_p} set {_uniqueStorage()._clearJavaGenerateEqualsAndHash_p = newValue} } var clearJavaGenericServices_p: Int32 { - get {return _storage._clearJavaGenericServices_p} + get {_storage._clearJavaGenericServices_p} set {_uniqueStorage()._clearJavaGenericServices_p = newValue} } var clearJavaMultipleFiles_p: Int32 { - get {return _storage._clearJavaMultipleFiles_p} + get {_storage._clearJavaMultipleFiles_p} set {_uniqueStorage()._clearJavaMultipleFiles_p = newValue} } var clearJavaOuterClassname_p: Int32 { - get {return _storage._clearJavaOuterClassname_p} + get {_storage._clearJavaOuterClassname_p} set {_uniqueStorage()._clearJavaOuterClassname_p = newValue} } var clearJavaPackage_p: Int32 { - get {return _storage._clearJavaPackage_p} + get {_storage._clearJavaPackage_p} set {_uniqueStorage()._clearJavaPackage_p = newValue} } var clearJavaStringCheckUtf8_p: Int32 { - get {return _storage._clearJavaStringCheckUtf8_p} + get {_storage._clearJavaStringCheckUtf8_p} set {_uniqueStorage()._clearJavaStringCheckUtf8_p = newValue} } + var clearJsonFormat_p: Int32 { + get {_storage._clearJsonFormat_p} + set {_uniqueStorage()._clearJsonFormat_p = newValue} + } + var clearJsonName_p: Int32 { - get {return _storage._clearJsonName_p} + get {_storage._clearJsonName_p} set {_uniqueStorage()._clearJsonName_p = newValue} } var clearJstype_p: Int32 { - get {return _storage._clearJstype_p} + get {_storage._clearJstype_p} set {_uniqueStorage()._clearJstype_p = newValue} } var clearLabel_p: Int32 { - get {return _storage._clearLabel_p} + get {_storage._clearLabel_p} set {_uniqueStorage()._clearLabel_p = newValue} } var clearLazy_p: Int32 { - get {return _storage._clearLazy_p} + get {_storage._clearLazy_p} set {_uniqueStorage()._clearLazy_p = newValue} } var clearLeadingComments_p: Int32 { - get {return _storage._clearLeadingComments_p} + get {_storage._clearLeadingComments_p} set {_uniqueStorage()._clearLeadingComments_p = newValue} } var clearMapEntry_p: Int32 { - get {return _storage._clearMapEntry_p} + get {_storage._clearMapEntry_p} set {_uniqueStorage()._clearMapEntry_p = newValue} } + var clearMaximumEdition_p: Int32 { + get {_storage._clearMaximumEdition_p} + set {_uniqueStorage()._clearMaximumEdition_p = newValue} + } + + var clearMessageEncoding_p: Int32 { + get {_storage._clearMessageEncoding_p} + set {_uniqueStorage()._clearMessageEncoding_p = newValue} + } + var clearMessageSetWireFormat_p: Int32 { - get {return _storage._clearMessageSetWireFormat_p} + get {_storage._clearMessageSetWireFormat_p} set {_uniqueStorage()._clearMessageSetWireFormat_p = newValue} } + var clearMinimumEdition_p: Int32 { + get {_storage._clearMinimumEdition_p} + set {_uniqueStorage()._clearMinimumEdition_p = newValue} + } + var clearName_p: Int32 { - get {return _storage._clearName_p} + get {_storage._clearName_p} set {_uniqueStorage()._clearName_p = newValue} } var clearNamePart_p: Int32 { - get {return _storage._clearNamePart_p} + get {_storage._clearNamePart_p} set {_uniqueStorage()._clearNamePart_p = newValue} } var clearNegativeIntValue_p: Int32 { - get {return _storage._clearNegativeIntValue_p} + get {_storage._clearNegativeIntValue_p} set {_uniqueStorage()._clearNegativeIntValue_p = newValue} } var clearNoStandardDescriptorAccessor_p: Int32 { - get {return _storage._clearNoStandardDescriptorAccessor_p} + get {_storage._clearNoStandardDescriptorAccessor_p} set {_uniqueStorage()._clearNoStandardDescriptorAccessor_p = newValue} } var clearNumber_p: Int32 { - get {return _storage._clearNumber_p} + get {_storage._clearNumber_p} set {_uniqueStorage()._clearNumber_p = newValue} } var clearObjcClassPrefix_p: Int32 { - get {return _storage._clearObjcClassPrefix_p} + get {_storage._clearObjcClassPrefix_p} set {_uniqueStorage()._clearObjcClassPrefix_p = newValue} } var clearOneofIndex_p: Int32 { - get {return _storage._clearOneofIndex_p} + get {_storage._clearOneofIndex_p} set {_uniqueStorage()._clearOneofIndex_p = newValue} } var clearOptimizeFor_p: Int32 { - get {return _storage._clearOptimizeFor_p} + get {_storage._clearOptimizeFor_p} set {_uniqueStorage()._clearOptimizeFor_p = newValue} } var clearOptions_p: Int32 { - get {return _storage._clearOptions_p} + get {_storage._clearOptions_p} set {_uniqueStorage()._clearOptions_p = newValue} } var clearOutputType_p: Int32 { - get {return _storage._clearOutputType_p} + get {_storage._clearOutputType_p} set {_uniqueStorage()._clearOutputType_p = newValue} } + var clearOverridableFeatures_p: Int32 { + get {_storage._clearOverridableFeatures_p} + set {_uniqueStorage()._clearOverridableFeatures_p = newValue} + } + var clearPackage_p: Int32 { - get {return _storage._clearPackage_p} + get {_storage._clearPackage_p} set {_uniqueStorage()._clearPackage_p = newValue} } var clearPacked_p: Int32 { - get {return _storage._clearPacked_p} + get {_storage._clearPacked_p} set {_uniqueStorage()._clearPacked_p = newValue} } var clearPhpClassPrefix_p: Int32 { - get {return _storage._clearPhpClassPrefix_p} + get {_storage._clearPhpClassPrefix_p} set {_uniqueStorage()._clearPhpClassPrefix_p = newValue} } - var clearPhpGenericServices_p: Int32 { - get {return _storage._clearPhpGenericServices_p} - set {_uniqueStorage()._clearPhpGenericServices_p = newValue} - } - var clearPhpMetadataNamespace_p: Int32 { - get {return _storage._clearPhpMetadataNamespace_p} + get {_storage._clearPhpMetadataNamespace_p} set {_uniqueStorage()._clearPhpMetadataNamespace_p = newValue} } var clearPhpNamespace_p: Int32 { - get {return _storage._clearPhpNamespace_p} + get {_storage._clearPhpNamespace_p} set {_uniqueStorage()._clearPhpNamespace_p = newValue} } var clearPositiveIntValue_p: Int32 { - get {return _storage._clearPositiveIntValue_p} + get {_storage._clearPositiveIntValue_p} set {_uniqueStorage()._clearPositiveIntValue_p = newValue} } var clearProto3Optional_p: Int32 { - get {return _storage._clearProto3Optional_p} + get {_storage._clearProto3Optional_p} set {_uniqueStorage()._clearProto3Optional_p = newValue} } var clearPyGenericServices_p: Int32 { - get {return _storage._clearPyGenericServices_p} + get {_storage._clearPyGenericServices_p} set {_uniqueStorage()._clearPyGenericServices_p = newValue} } + var clearRemovalError_p: Int32 { + get {_storage._clearRemovalError_p} + set {_uniqueStorage()._clearRemovalError_p = newValue} + } + + var clearRepeated_p: Int32 { + get {_storage._clearRepeated_p} + set {_uniqueStorage()._clearRepeated_p = newValue} + } + + var clearRepeatedFieldEncoding_p: Int32 { + get {_storage._clearRepeatedFieldEncoding_p} + set {_uniqueStorage()._clearRepeatedFieldEncoding_p = newValue} + } + + var clearReserved_p: Int32 { + get {_storage._clearReserved_p} + set {_uniqueStorage()._clearReserved_p = newValue} + } + + var clearRetention_p: Int32 { + get {_storage._clearRetention_p} + set {_uniqueStorage()._clearRetention_p = newValue} + } + var clearRubyPackage_p: Int32 { - get {return _storage._clearRubyPackage_p} + get {_storage._clearRubyPackage_p} set {_uniqueStorage()._clearRubyPackage_p = newValue} } + var clearSemantic_p: Int32 { + get {_storage._clearSemantic_p} + set {_uniqueStorage()._clearSemantic_p = newValue} + } + var clearServerStreaming_p: Int32 { - get {return _storage._clearServerStreaming_p} + get {_storage._clearServerStreaming_p} set {_uniqueStorage()._clearServerStreaming_p = newValue} } var clearSourceCodeInfo_p: Int32 { - get {return _storage._clearSourceCodeInfo_p} + get {_storage._clearSourceCodeInfo_p} set {_uniqueStorage()._clearSourceCodeInfo_p = newValue} } var clearSourceContext_p: Int32 { - get {return _storage._clearSourceContext_p} + get {_storage._clearSourceContext_p} set {_uniqueStorage()._clearSourceContext_p = newValue} } var clearSourceFile_p: Int32 { - get {return _storage._clearSourceFile_p} + get {_storage._clearSourceFile_p} set {_uniqueStorage()._clearSourceFile_p = newValue} } var clearStart_p: Int32 { - get {return _storage._clearStart_p} + get {_storage._clearStart_p} set {_uniqueStorage()._clearStart_p = newValue} } var clearStringValue_p: Int32 { - get {return _storage._clearStringValue_p} + get {_storage._clearStringValue_p} set {_uniqueStorage()._clearStringValue_p = newValue} } var clearSwiftPrefix_p: Int32 { - get {return _storage._clearSwiftPrefix_p} + get {_storage._clearSwiftPrefix_p} set {_uniqueStorage()._clearSwiftPrefix_p = newValue} } var clearSyntax_p: Int32 { - get {return _storage._clearSyntax_p} + get {_storage._clearSyntax_p} set {_uniqueStorage()._clearSyntax_p = newValue} } var clearTrailingComments_p: Int32 { - get {return _storage._clearTrailingComments_p} + get {_storage._clearTrailingComments_p} set {_uniqueStorage()._clearTrailingComments_p = newValue} } var clearType_p: Int32 { - get {return _storage._clearType_p} + get {_storage._clearType_p} set {_uniqueStorage()._clearType_p = newValue} } var clearTypeName_p: Int32 { - get {return _storage._clearTypeName_p} + get {_storage._clearTypeName_p} set {_uniqueStorage()._clearTypeName_p = newValue} } + var clearUnverifiedLazy_p: Int32 { + get {_storage._clearUnverifiedLazy_p} + set {_uniqueStorage()._clearUnverifiedLazy_p = newValue} + } + + var clearUtf8Validation_p: Int32 { + get {_storage._clearUtf8Validation_p} + set {_uniqueStorage()._clearUtf8Validation_p = newValue} + } + var clearValue_p: Int32 { - get {return _storage._clearValue_p} + get {_storage._clearValue_p} set {_uniqueStorage()._clearValue_p = newValue} } + var clearVerification_p: Int32 { + get {_storage._clearVerification_p} + set {_uniqueStorage()._clearVerification_p = newValue} + } + + var clearVisibility_p: Int32 { + get {_storage._clearVisibility_p} + set {_uniqueStorage()._clearVisibility_p = newValue} + } + var clearWeak_p: Int32 { - get {return _storage._clearWeak_p} + get {_storage._clearWeak_p} set {_uniqueStorage()._clearWeak_p = newValue} } var clientStreaming: Int32 { - get {return _storage._clientStreaming} + get {_storage._clientStreaming} set {_uniqueStorage()._clientStreaming = newValue} } + var code: Int32 { + get {_storage._code} + set {_uniqueStorage()._code = newValue} + } + var codePoint: Int32 { - get {return _storage._codePoint} + get {_storage._codePoint} set {_uniqueStorage()._codePoint = newValue} } var codeUnits: Int32 { - get {return _storage._codeUnits} + get {_storage._codeUnits} set {_uniqueStorage()._codeUnits = newValue} } var collection: Int32 { - get {return _storage._collection} + get {_storage._collection} set {_uniqueStorage()._collection = newValue} } - var com: Int32 { - get {return _storage._com} - set {_uniqueStorage()._com = newValue} - } - var comma: Int32 { - get {return _storage._comma} + get {_storage._comma} set {_uniqueStorage()._comma = newValue} } + var consumedBytes: Int32 { + get {_storage._consumedBytes} + set {_uniqueStorage()._consumedBytes = newValue} + } + + var contains: Int32 { + get {_storage._contains} + set {_uniqueStorage()._contains = newValue} + } + var contentsOf: Int32 { - get {return _storage._contentsOf} + get {_storage._contentsOf} set {_uniqueStorage()._contentsOf = newValue} } var contiguousBytes: Int32 { - get {return _storage._contiguousBytes} + get {_storage._contiguousBytes} set {_uniqueStorage()._contiguousBytes = newValue} } + var copy: Int32 { + get {_storage._copy} + set {_uniqueStorage()._copy = newValue} + } + var count: Int32 { - get {return _storage._count} + get {_storage._count} set {_uniqueStorage()._count = newValue} } var countVarintsInBuffer: Int32 { - get {return _storage._countVarintsInBuffer} + get {_storage._countVarintsInBuffer} set {_uniqueStorage()._countVarintsInBuffer = newValue} } var csharpNamespace: Int32 { - get {return _storage._csharpNamespace} + get {_storage._csharpNamespace} set {_uniqueStorage()._csharpNamespace = newValue} } var ctype: Int32 { - get {return _storage._ctype} + get {_storage._ctype} set {_uniqueStorage()._ctype = newValue} } var customCodable: Int32 { - get {return _storage._customCodable} + get {_storage._customCodable} set {_uniqueStorage()._customCodable = newValue} } var customDebugStringConvertible: Int32 { - get {return _storage._customDebugStringConvertible} + get {_storage._customDebugStringConvertible} set {_uniqueStorage()._customDebugStringConvertible = newValue} } + var customStringConvertible: Int32 { + get {_storage._customStringConvertible} + set {_uniqueStorage()._customStringConvertible = newValue} + } + var d: Int32 { - get {return _storage._d} + get {_storage._d} set {_uniqueStorage()._d = newValue} } var data: Int32 { - get {return _storage._data} + get {_storage._data} set {_uniqueStorage()._data = newValue} } var dataResult: Int32 { - get {return _storage._dataResult} + get {_storage._dataResult} set {_uniqueStorage()._dataResult = newValue} } var date: Int32 { - get {return _storage._date} + get {_storage._date} set {_uniqueStorage()._date = newValue} } var daySec: Int32 { - get {return _storage._daySec} + get {_storage._daySec} set {_uniqueStorage()._daySec = newValue} } var daysSinceEpoch: Int32 { - get {return _storage._daysSinceEpoch} + get {_storage._daysSinceEpoch} set {_uniqueStorage()._daysSinceEpoch = newValue} } var debugDescription_p: Int32 { - get {return _storage._debugDescription_p} + get {_storage._debugDescription_p} set {_uniqueStorage()._debugDescription_p = newValue} } + var debugRedact: Int32 { + get {_storage._debugRedact} + set {_uniqueStorage()._debugRedact = newValue} + } + + var declaration: Int32 { + get {_storage._declaration} + set {_uniqueStorage()._declaration = newValue} + } + var decoded: Int32 { - get {return _storage._decoded} + get {_storage._decoded} set {_uniqueStorage()._decoded = newValue} } var decodedFromJsonnull: Int32 { - get {return _storage._decodedFromJsonnull} + get {_storage._decodedFromJsonnull} set {_uniqueStorage()._decodedFromJsonnull = newValue} } var decodeExtensionField: Int32 { - get {return _storage._decodeExtensionField} + get {_storage._decodeExtensionField} set {_uniqueStorage()._decodeExtensionField = newValue} } var decodeExtensionFieldsAsMessageSet: Int32 { - get {return _storage._decodeExtensionFieldsAsMessageSet} + get {_storage._decodeExtensionFieldsAsMessageSet} set {_uniqueStorage()._decodeExtensionFieldsAsMessageSet = newValue} } var decodeJson: Int32 { - get {return _storage._decodeJson} + get {_storage._decodeJson} set {_uniqueStorage()._decodeJson = newValue} } var decodeMapField: Int32 { - get {return _storage._decodeMapField} + get {_storage._decodeMapField} set {_uniqueStorage()._decodeMapField = newValue} } var decodeMessage: Int32 { - get {return _storage._decodeMessage} + get {_storage._decodeMessage} set {_uniqueStorage()._decodeMessage = newValue} } var decoder: Int32 { - get {return _storage._decoder} + get {_storage._decoder} set {_uniqueStorage()._decoder = newValue} } var decodeRepeated: Int32 { - get {return _storage._decodeRepeated} + get {_storage._decodeRepeated} set {_uniqueStorage()._decodeRepeated = newValue} } var decodeRepeatedBoolField: Int32 { - get {return _storage._decodeRepeatedBoolField} + get {_storage._decodeRepeatedBoolField} set {_uniqueStorage()._decodeRepeatedBoolField = newValue} } var decodeRepeatedBytesField: Int32 { - get {return _storage._decodeRepeatedBytesField} + get {_storage._decodeRepeatedBytesField} set {_uniqueStorage()._decodeRepeatedBytesField = newValue} } var decodeRepeatedDoubleField: Int32 { - get {return _storage._decodeRepeatedDoubleField} + get {_storage._decodeRepeatedDoubleField} set {_uniqueStorage()._decodeRepeatedDoubleField = newValue} } var decodeRepeatedEnumField: Int32 { - get {return _storage._decodeRepeatedEnumField} + get {_storage._decodeRepeatedEnumField} set {_uniqueStorage()._decodeRepeatedEnumField = newValue} } var decodeRepeatedFixed32Field: Int32 { - get {return _storage._decodeRepeatedFixed32Field} + get {_storage._decodeRepeatedFixed32Field} set {_uniqueStorage()._decodeRepeatedFixed32Field = newValue} } var decodeRepeatedFixed64Field: Int32 { - get {return _storage._decodeRepeatedFixed64Field} + get {_storage._decodeRepeatedFixed64Field} set {_uniqueStorage()._decodeRepeatedFixed64Field = newValue} } var decodeRepeatedFloatField: Int32 { - get {return _storage._decodeRepeatedFloatField} + get {_storage._decodeRepeatedFloatField} set {_uniqueStorage()._decodeRepeatedFloatField = newValue} } var decodeRepeatedGroupField: Int32 { - get {return _storage._decodeRepeatedGroupField} + get {_storage._decodeRepeatedGroupField} set {_uniqueStorage()._decodeRepeatedGroupField = newValue} } var decodeRepeatedInt32Field: Int32 { - get {return _storage._decodeRepeatedInt32Field} + get {_storage._decodeRepeatedInt32Field} set {_uniqueStorage()._decodeRepeatedInt32Field = newValue} } var decodeRepeatedInt64Field: Int32 { - get {return _storage._decodeRepeatedInt64Field} + get {_storage._decodeRepeatedInt64Field} set {_uniqueStorage()._decodeRepeatedInt64Field = newValue} } var decodeRepeatedMessageField: Int32 { - get {return _storage._decodeRepeatedMessageField} + get {_storage._decodeRepeatedMessageField} set {_uniqueStorage()._decodeRepeatedMessageField = newValue} } var decodeRepeatedSfixed32Field: Int32 { - get {return _storage._decodeRepeatedSfixed32Field} + get {_storage._decodeRepeatedSfixed32Field} set {_uniqueStorage()._decodeRepeatedSfixed32Field = newValue} } var decodeRepeatedSfixed64Field: Int32 { - get {return _storage._decodeRepeatedSfixed64Field} + get {_storage._decodeRepeatedSfixed64Field} set {_uniqueStorage()._decodeRepeatedSfixed64Field = newValue} } var decodeRepeatedSint32Field: Int32 { - get {return _storage._decodeRepeatedSint32Field} + get {_storage._decodeRepeatedSint32Field} set {_uniqueStorage()._decodeRepeatedSint32Field = newValue} } var decodeRepeatedSint64Field: Int32 { - get {return _storage._decodeRepeatedSint64Field} + get {_storage._decodeRepeatedSint64Field} set {_uniqueStorage()._decodeRepeatedSint64Field = newValue} } var decodeRepeatedStringField: Int32 { - get {return _storage._decodeRepeatedStringField} + get {_storage._decodeRepeatedStringField} set {_uniqueStorage()._decodeRepeatedStringField = newValue} } var decodeRepeatedUint32Field: Int32 { - get {return _storage._decodeRepeatedUint32Field} + get {_storage._decodeRepeatedUint32Field} set {_uniqueStorage()._decodeRepeatedUint32Field = newValue} } var decodeRepeatedUint64Field: Int32 { - get {return _storage._decodeRepeatedUint64Field} + get {_storage._decodeRepeatedUint64Field} set {_uniqueStorage()._decodeRepeatedUint64Field = newValue} } var decodeSingular: Int32 { - get {return _storage._decodeSingular} + get {_storage._decodeSingular} set {_uniqueStorage()._decodeSingular = newValue} } var decodeSingularBoolField: Int32 { - get {return _storage._decodeSingularBoolField} + get {_storage._decodeSingularBoolField} set {_uniqueStorage()._decodeSingularBoolField = newValue} } var decodeSingularBytesField: Int32 { - get {return _storage._decodeSingularBytesField} + get {_storage._decodeSingularBytesField} set {_uniqueStorage()._decodeSingularBytesField = newValue} } var decodeSingularDoubleField: Int32 { - get {return _storage._decodeSingularDoubleField} + get {_storage._decodeSingularDoubleField} set {_uniqueStorage()._decodeSingularDoubleField = newValue} } var decodeSingularEnumField: Int32 { - get {return _storage._decodeSingularEnumField} + get {_storage._decodeSingularEnumField} set {_uniqueStorage()._decodeSingularEnumField = newValue} } var decodeSingularFixed32Field: Int32 { - get {return _storage._decodeSingularFixed32Field} + get {_storage._decodeSingularFixed32Field} set {_uniqueStorage()._decodeSingularFixed32Field = newValue} } var decodeSingularFixed64Field: Int32 { - get {return _storage._decodeSingularFixed64Field} + get {_storage._decodeSingularFixed64Field} set {_uniqueStorage()._decodeSingularFixed64Field = newValue} } var decodeSingularFloatField: Int32 { - get {return _storage._decodeSingularFloatField} + get {_storage._decodeSingularFloatField} set {_uniqueStorage()._decodeSingularFloatField = newValue} } var decodeSingularGroupField: Int32 { - get {return _storage._decodeSingularGroupField} + get {_storage._decodeSingularGroupField} set {_uniqueStorage()._decodeSingularGroupField = newValue} } var decodeSingularInt32Field: Int32 { - get {return _storage._decodeSingularInt32Field} + get {_storage._decodeSingularInt32Field} set {_uniqueStorage()._decodeSingularInt32Field = newValue} } var decodeSingularInt64Field: Int32 { - get {return _storage._decodeSingularInt64Field} + get {_storage._decodeSingularInt64Field} set {_uniqueStorage()._decodeSingularInt64Field = newValue} } var decodeSingularMessageField: Int32 { - get {return _storage._decodeSingularMessageField} + get {_storage._decodeSingularMessageField} set {_uniqueStorage()._decodeSingularMessageField = newValue} } var decodeSingularSfixed32Field: Int32 { - get {return _storage._decodeSingularSfixed32Field} + get {_storage._decodeSingularSfixed32Field} set {_uniqueStorage()._decodeSingularSfixed32Field = newValue} } var decodeSingularSfixed64Field: Int32 { - get {return _storage._decodeSingularSfixed64Field} + get {_storage._decodeSingularSfixed64Field} set {_uniqueStorage()._decodeSingularSfixed64Field = newValue} } var decodeSingularSint32Field: Int32 { - get {return _storage._decodeSingularSint32Field} + get {_storage._decodeSingularSint32Field} set {_uniqueStorage()._decodeSingularSint32Field = newValue} } var decodeSingularSint64Field: Int32 { - get {return _storage._decodeSingularSint64Field} + get {_storage._decodeSingularSint64Field} set {_uniqueStorage()._decodeSingularSint64Field = newValue} } var decodeSingularStringField: Int32 { - get {return _storage._decodeSingularStringField} + get {_storage._decodeSingularStringField} set {_uniqueStorage()._decodeSingularStringField = newValue} } var decodeSingularUint32Field: Int32 { - get {return _storage._decodeSingularUint32Field} + get {_storage._decodeSingularUint32Field} set {_uniqueStorage()._decodeSingularUint32Field = newValue} } var decodeSingularUint64Field: Int32 { - get {return _storage._decodeSingularUint64Field} + get {_storage._decodeSingularUint64Field} set {_uniqueStorage()._decodeSingularUint64Field = newValue} } var decodeTextFormat: Int32 { - get {return _storage._decodeTextFormat} + get {_storage._decodeTextFormat} set {_uniqueStorage()._decodeTextFormat = newValue} } var defaultAnyTypeUrlprefix: Int32 { - get {return _storage._defaultAnyTypeUrlprefix} + get {_storage._defaultAnyTypeUrlprefix} set {_uniqueStorage()._defaultAnyTypeUrlprefix = newValue} } + var defaults: Int32 { + get {_storage._defaults} + set {_uniqueStorage()._defaults = newValue} + } + + var defaultSymbolVisibility: Int32 { + get {_storage._defaultSymbolVisibility} + set {_uniqueStorage()._defaultSymbolVisibility = newValue} + } + var defaultValue: Int32 { - get {return _storage._defaultValue} + get {_storage._defaultValue} set {_uniqueStorage()._defaultValue = newValue} } var dependency: Int32 { - get {return _storage._dependency} + get {_storage._dependency} set {_uniqueStorage()._dependency = newValue} } var deprecated: Int32 { - get {return _storage._deprecated} + get {_storage._deprecated} set {_uniqueStorage()._deprecated = newValue} } - var description_p: Int32 { - get {return _storage._description_p} - set {_uniqueStorage()._description_p = newValue} + var deprecatedLegacyJsonFieldConflicts: Int32 { + get {_storage._deprecatedLegacyJsonFieldConflicts} + set {_uniqueStorage()._deprecatedLegacyJsonFieldConflicts = newValue} } - var descriptorProto: Int32 { - get {return _storage._descriptorProto} - set {_uniqueStorage()._descriptorProto = newValue} + var deprecationWarning: Int32 { + get {_storage._deprecationWarning} + set {_uniqueStorage()._deprecationWarning = newValue} + } + + var description_p: Int32 { + get {_storage._description_p} + set {_uniqueStorage()._description_p = newValue} } var dictionary: Int32 { - get {return _storage._dictionary} + get {_storage._dictionary} set {_uniqueStorage()._dictionary = newValue} } var dictionaryLiteral: Int32 { - get {return _storage._dictionaryLiteral} + get {_storage._dictionaryLiteral} set {_uniqueStorage()._dictionaryLiteral = newValue} } var digit: Int32 { - get {return _storage._digit} + get {_storage._digit} set {_uniqueStorage()._digit = newValue} } var digit0: Int32 { - get {return _storage._digit0} + get {_storage._digit0} set {_uniqueStorage()._digit0 = newValue} } var digit1: Int32 { - get {return _storage._digit1} + get {_storage._digit1} set {_uniqueStorage()._digit1 = newValue} } var digitCount: Int32 { - get {return _storage._digitCount} + get {_storage._digitCount} set {_uniqueStorage()._digitCount = newValue} } var digits: Int32 { - get {return _storage._digits} + get {_storage._digits} set {_uniqueStorage()._digits = newValue} } var digitValue: Int32 { - get {return _storage._digitValue} + get {_storage._digitValue} set {_uniqueStorage()._digitValue = newValue} } var discardableResult: Int32 { - get {return _storage._discardableResult} + get {_storage._discardableResult} set {_uniqueStorage()._discardableResult = newValue} } var discardUnknownFields: Int32 { - get {return _storage._discardUnknownFields} + get {_storage._discardUnknownFields} set {_uniqueStorage()._discardUnknownFields = newValue} } - var distance: Int32 { - get {return _storage._distance} - set {_uniqueStorage()._distance = newValue} - } - var double: Int32 { - get {return _storage._double} + get {_storage._double} set {_uniqueStorage()._double = newValue} } var doubleValue: Int32 { - get {return _storage._doubleValue} + get {_storage._doubleValue} set {_uniqueStorage()._doubleValue = newValue} } var duration: Int32 { - get {return _storage._duration} + get {_storage._duration} set {_uniqueStorage()._duration = newValue} } var e: Int32 { - get {return _storage._e} + get {_storage._e} set {_uniqueStorage()._e = newValue} } + var edition: Int32 { + get {_storage._edition} + set {_uniqueStorage()._edition = newValue} + } + + var editionDefault: Int32 { + get {_storage._editionDefault} + set {_uniqueStorage()._editionDefault = newValue} + } + + var editionDefaults: Int32 { + get {_storage._editionDefaults} + set {_uniqueStorage()._editionDefaults = newValue} + } + + var editionDeprecated: Int32 { + get {_storage._editionDeprecated} + set {_uniqueStorage()._editionDeprecated = newValue} + } + + var editionIntroduced: Int32 { + get {_storage._editionIntroduced} + set {_uniqueStorage()._editionIntroduced = newValue} + } + + var editionRemoved: Int32 { + get {_storage._editionRemoved} + set {_uniqueStorage()._editionRemoved = newValue} + } + var element: Int32 { - get {return _storage._element} + get {_storage._element} set {_uniqueStorage()._element = newValue} } var elements: Int32 { - get {return _storage._elements} + get {_storage._elements} set {_uniqueStorage()._elements = newValue} } + var `else`: Int32 { + get {_storage._else} + set {_uniqueStorage()._else = newValue} + } + var emitExtensionFieldName: Int32 { - get {return _storage._emitExtensionFieldName} + get {_storage._emitExtensionFieldName} set {_uniqueStorage()._emitExtensionFieldName = newValue} } var emitFieldName: Int32 { - get {return _storage._emitFieldName} + get {_storage._emitFieldName} set {_uniqueStorage()._emitFieldName = newValue} } var emitFieldNumber: Int32 { - get {return _storage._emitFieldNumber} + get {_storage._emitFieldNumber} set {_uniqueStorage()._emitFieldNumber = newValue} } - var empty: Int32 { - get {return _storage._empty} - set {_uniqueStorage()._empty = newValue} + var emptyAnyTypeURL: Int32 { + get {_storage._emptyAnyTypeURL} + set {_uniqueStorage()._emptyAnyTypeURL = newValue} } var emptyData: Int32 { - get {return _storage._emptyData} + get {_storage._emptyData} set {_uniqueStorage()._emptyData = newValue} } var encodeAsBytes: Int32 { - get {return _storage._encodeAsBytes} + get {_storage._encodeAsBytes} set {_uniqueStorage()._encodeAsBytes = newValue} } var encoded: Int32 { - get {return _storage._encoded} + get {_storage._encoded} set {_uniqueStorage()._encoded = newValue} } var encodedJsonstring: Int32 { - get {return _storage._encodedJsonstring} + get {_storage._encodedJsonstring} set {_uniqueStorage()._encodedJsonstring = newValue} } var encodedSize: Int32 { - get {return _storage._encodedSize} + get {_storage._encodedSize} set {_uniqueStorage()._encodedSize = newValue} } var encodeField: Int32 { - get {return _storage._encodeField} + get {_storage._encodeField} set {_uniqueStorage()._encodeField = newValue} } var encoder: Int32 { - get {return _storage._encoder} + get {_storage._encoder} set {_uniqueStorage()._encoder = newValue} } var end: Int32 { - get {return _storage._end} + get {_storage._end} set {_uniqueStorage()._end = newValue} } var endArray: Int32 { - get {return _storage._endArray} + get {_storage._endArray} set {_uniqueStorage()._endArray = newValue} } var endMessageField: Int32 { - get {return _storage._endMessageField} + get {_storage._endMessageField} set {_uniqueStorage()._endMessageField = newValue} } var endObject: Int32 { - get {return _storage._endObject} + get {_storage._endObject} set {_uniqueStorage()._endObject = newValue} } var endRegularField: Int32 { - get {return _storage._endRegularField} + get {_storage._endRegularField} set {_uniqueStorage()._endRegularField = newValue} } - var `enum`: Int32 { - get {return _storage._enum} - set {_uniqueStorage()._enum = newValue} - } - - var enumDescriptorProto: Int32 { - get {return _storage._enumDescriptorProto} - set {_uniqueStorage()._enumDescriptorProto = newValue} + var enforceNamingStyle: Int32 { + get {_storage._enforceNamingStyle} + set {_uniqueStorage()._enforceNamingStyle = newValue} } - var enumOptions: Int32 { - get {return _storage._enumOptions} - set {_uniqueStorage()._enumOptions = newValue} + var `enum`: Int32 { + get {_storage._enum} + set {_uniqueStorage()._enum = newValue} } var enumReservedRange: Int32 { - get {return _storage._enumReservedRange} + get {_storage._enumReservedRange} set {_uniqueStorage()._enumReservedRange = newValue} } var enumType: Int32 { - get {return _storage._enumType} + get {_storage._enumType} set {_uniqueStorage()._enumType = newValue} } var enumvalue: Int32 { - get {return _storage._enumvalue} + get {_storage._enumvalue} set {_uniqueStorage()._enumvalue = newValue} } - var enumValueDescriptorProto: Int32 { - get {return _storage._enumValueDescriptorProto} - set {_uniqueStorage()._enumValueDescriptorProto = newValue} - } - - var enumValueOptions: Int32 { - get {return _storage._enumValueOptions} - set {_uniqueStorage()._enumValueOptions = newValue} - } - var equatable: Int32 { - get {return _storage._equatable} + get {_storage._equatable} set {_uniqueStorage()._equatable = newValue} } var error: Int32 { - get {return _storage._error} + get {_storage._error} set {_uniqueStorage()._error = newValue} } + var execute: Int32 { + get {_storage._execute} + set {_uniqueStorage()._execute = newValue} + } + var expressibleByArrayLiteral: Int32 { - get {return _storage._expressibleByArrayLiteral} + get {_storage._expressibleByArrayLiteral} set {_uniqueStorage()._expressibleByArrayLiteral = newValue} } var expressibleByDictionaryLiteral: Int32 { - get {return _storage._expressibleByDictionaryLiteral} + get {_storage._expressibleByDictionaryLiteral} set {_uniqueStorage()._expressibleByDictionaryLiteral = newValue} } var ext: Int32 { - get {return _storage._ext} + get {_storage._ext} set {_uniqueStorage()._ext = newValue} } var extDecoder: Int32 { - get {return _storage._extDecoder} + get {_storage._extDecoder} set {_uniqueStorage()._extDecoder = newValue} } var extendedGraphemeClusterLiteral: Int32 { - get {return _storage._extendedGraphemeClusterLiteral} + get {_storage._extendedGraphemeClusterLiteral} set {_uniqueStorage()._extendedGraphemeClusterLiteral = newValue} } var extendedGraphemeClusterLiteralType: Int32 { - get {return _storage._extendedGraphemeClusterLiteralType} + get {_storage._extendedGraphemeClusterLiteralType} set {_uniqueStorage()._extendedGraphemeClusterLiteralType = newValue} } var extendee: Int32 { - get {return _storage._extendee} + get {_storage._extendee} set {_uniqueStorage()._extendee = newValue} } var extensibleMessage: Int32 { - get {return _storage._extensibleMessage} + get {_storage._extensibleMessage} set {_uniqueStorage()._extensibleMessage = newValue} } var `extension`: Int32 { - get {return _storage._extension} + get {_storage._extension} set {_uniqueStorage()._extension = newValue} } var extensionField: Int32 { - get {return _storage._extensionField} + get {_storage._extensionField} set {_uniqueStorage()._extensionField = newValue} } var extensionFieldNumber: Int32 { - get {return _storage._extensionFieldNumber} + get {_storage._extensionFieldNumber} set {_uniqueStorage()._extensionFieldNumber = newValue} } var extensionFieldValueSet: Int32 { - get {return _storage._extensionFieldValueSet} + get {_storage._extensionFieldValueSet} set {_uniqueStorage()._extensionFieldValueSet = newValue} } var extensionMap: Int32 { - get {return _storage._extensionMap} + get {_storage._extensionMap} set {_uniqueStorage()._extensionMap = newValue} } var extensionRange: Int32 { - get {return _storage._extensionRange} + get {_storage._extensionRange} set {_uniqueStorage()._extensionRange = newValue} } - var extensionRangeOptions: Int32 { - get {return _storage._extensionRangeOptions} - set {_uniqueStorage()._extensionRangeOptions = newValue} - } - var extensions: Int32 { - get {return _storage._extensions} + get {_storage._extensions} set {_uniqueStorage()._extensions = newValue} } var extras: Int32 { - get {return _storage._extras} + get {_storage._extras} set {_uniqueStorage()._extras = newValue} } var f: Int32 { - get {return _storage._f} + get {_storage._f} set {_uniqueStorage()._f = newValue} } var `false`: Int32 { - get {return _storage._false} + get {_storage._false} set {_uniqueStorage()._false = newValue} } + var features: Int32 { + get {_storage._features} + set {_uniqueStorage()._features = newValue} + } + + var featureSetEditionDefault: Int32 { + get {_storage._featureSetEditionDefault} + set {_uniqueStorage()._featureSetEditionDefault = newValue} + } + + var featureSupport: Int32 { + get {_storage._featureSupport} + set {_uniqueStorage()._featureSupport = newValue} + } + var field: Int32 { - get {return _storage._field} + get {_storage._field} set {_uniqueStorage()._field = newValue} } var fieldData: Int32 { - get {return _storage._fieldData} + get {_storage._fieldData} set {_uniqueStorage()._fieldData = newValue} } - var fieldDescriptorProto: Int32 { - get {return _storage._fieldDescriptorProto} - set {_uniqueStorage()._fieldDescriptorProto = newValue} - } - - var fieldMask: Int32 { - get {return _storage._fieldMask} - set {_uniqueStorage()._fieldMask = newValue} + var fieldMaskError: Int32 { + get {_storage._fieldMaskError} + set {_uniqueStorage()._fieldMaskError = newValue} } var fieldName: Int32 { - get {return _storage._fieldName} + get {_storage._fieldName} set {_uniqueStorage()._fieldName = newValue} } var fieldNameCount: Int32 { - get {return _storage._fieldNameCount} + get {_storage._fieldNameCount} set {_uniqueStorage()._fieldNameCount = newValue} } var fieldNum: Int32 { - get {return _storage._fieldNum} + get {_storage._fieldNum} set {_uniqueStorage()._fieldNum = newValue} } var fieldNumber: Int32 { - get {return _storage._fieldNumber} + get {_storage._fieldNumber} set {_uniqueStorage()._fieldNumber = newValue} } var fieldNumberForProto: Int32 { - get {return _storage._fieldNumberForProto} + get {_storage._fieldNumberForProto} set {_uniqueStorage()._fieldNumberForProto = newValue} } - var fieldOptions: Int32 { - get {return _storage._fieldOptions} - set {_uniqueStorage()._fieldOptions = newValue} + var fieldPresence: Int32 { + get {_storage._fieldPresence} + set {_uniqueStorage()._fieldPresence = newValue} } var fields: Int32 { - get {return _storage._fields} + get {_storage._fields} set {_uniqueStorage()._fields = newValue} } var fieldSize: Int32 { - get {return _storage._fieldSize} + get {_storage._fieldSize} set {_uniqueStorage()._fieldSize = newValue} } var fieldTag: Int32 { - get {return _storage._fieldTag} + get {_storage._fieldTag} set {_uniqueStorage()._fieldTag = newValue} } var fieldType: Int32 { - get {return _storage._fieldType} + get {_storage._fieldType} set {_uniqueStorage()._fieldType = newValue} } var file: Int32 { - get {return _storage._file} + get {_storage._file} set {_uniqueStorage()._file = newValue} } - var fileDescriptorProto: Int32 { - get {return _storage._fileDescriptorProto} - set {_uniqueStorage()._fileDescriptorProto = newValue} - } - - var fileDescriptorSet: Int32 { - get {return _storage._fileDescriptorSet} - set {_uniqueStorage()._fileDescriptorSet = newValue} - } - var fileName: Int32 { - get {return _storage._fileName} + get {_storage._fileName} set {_uniqueStorage()._fileName = newValue} } - var fileOptions: Int32 { - get {return _storage._fileOptions} - set {_uniqueStorage()._fileOptions = newValue} - } - var filter: Int32 { - get {return _storage._filter} + get {_storage._filter} set {_uniqueStorage()._filter = newValue} } + var final: Int32 { + get {_storage._final} + set {_uniqueStorage()._final = newValue} + } + + var finiteOnly: Int32 { + get {_storage._finiteOnly} + set {_uniqueStorage()._finiteOnly = newValue} + } + var first: Int32 { - get {return _storage._first} + get {_storage._first} set {_uniqueStorage()._first = newValue} } var firstItem: Int32 { - get {return _storage._firstItem} + get {_storage._firstItem} set {_uniqueStorage()._firstItem = newValue} } + var fixedFeatures: Int32 { + get {_storage._fixedFeatures} + set {_uniqueStorage()._fixedFeatures = newValue} + } + var float: Int32 { - get {return _storage._float} + get {_storage._float} set {_uniqueStorage()._float = newValue} } var floatLiteral: Int32 { - get {return _storage._floatLiteral} + get {_storage._floatLiteral} set {_uniqueStorage()._floatLiteral = newValue} } var floatLiteralType: Int32 { - get {return _storage._floatLiteralType} + get {_storage._floatLiteralType} set {_uniqueStorage()._floatLiteralType = newValue} } - var floatValue: Int32 { - get {return _storage._floatValue} - set {_uniqueStorage()._floatValue = newValue} + var `for`: Int32 { + get {_storage._for} + set {_uniqueStorage()._for = newValue} } var forMessageName: Int32 { - get {return _storage._forMessageName} + get {_storage._forMessageName} set {_uniqueStorage()._forMessageName = newValue} } var formUnion: Int32 { - get {return _storage._formUnion} + get {_storage._formUnion} set {_uniqueStorage()._formUnion = newValue} } var forReadingFrom: Int32 { - get {return _storage._forReadingFrom} + get {_storage._forReadingFrom} set {_uniqueStorage()._forReadingFrom = newValue} } var forTypeURL: Int32 { - get {return _storage._forTypeURL} + get {_storage._forTypeURL} set {_uniqueStorage()._forTypeURL = newValue} } var forwardParser: Int32 { - get {return _storage._forwardParser} + get {_storage._forwardParser} set {_uniqueStorage()._forwardParser = newValue} } var forWritingInto: Int32 { - get {return _storage._forWritingInto} + get {_storage._forWritingInto} set {_uniqueStorage()._forWritingInto = newValue} } var from: Int32 { - get {return _storage._from} + get {_storage._from} set {_uniqueStorage()._from = newValue} } var fromAscii2: Int32 { - get {return _storage._fromAscii2} + get {_storage._fromAscii2} set {_uniqueStorage()._fromAscii2 = newValue} } var fromAscii4: Int32 { - get {return _storage._fromAscii4} + get {_storage._fromAscii4} set {_uniqueStorage()._fromAscii4 = newValue} } var fromByteOffset: Int32 { - get {return _storage._fromByteOffset} + get {_storage._fromByteOffset} set {_uniqueStorage()._fromByteOffset = newValue} } var fromHexDigit: Int32 { - get {return _storage._fromHexDigit} + get {_storage._fromHexDigit} set {_uniqueStorage()._fromHexDigit = newValue} } + var fullName: Int32 { + get {_storage._fullName} + set {_uniqueStorage()._fullName = newValue} + } + var `func`: Int32 { - get {return _storage._func} + get {_storage._func} set {_uniqueStorage()._func = newValue} } - var g: Int32 { - get {return _storage._g} - set {_uniqueStorage()._g = newValue} + var function: Int32 { + get {_storage._function} + set {_uniqueStorage()._function = newValue} } - var generatedCodeInfo: Int32 { - get {return _storage._generatedCodeInfo} - set {_uniqueStorage()._generatedCodeInfo = newValue} + var g: Int32 { + get {_storage._g} + set {_uniqueStorage()._g = newValue} } var get: Int32 { - get {return _storage._get} + get {_storage._get} set {_uniqueStorage()._get = newValue} } var getExtensionValue: Int32 { - get {return _storage._getExtensionValue} + get {_storage._getExtensionValue} set {_uniqueStorage()._getExtensionValue = newValue} } - var googleapis: Int32 { - get {return _storage._googleapis} - set {_uniqueStorage()._googleapis = newValue} - } - var googleProtobufAny: Int32 { - get {return _storage._googleProtobufAny} + get {_storage._googleProtobufAny} set {_uniqueStorage()._googleProtobufAny = newValue} } var googleProtobufApi: Int32 { - get {return _storage._googleProtobufApi} + get {_storage._googleProtobufApi} set {_uniqueStorage()._googleProtobufApi = newValue} } var googleProtobufBoolValue: Int32 { - get {return _storage._googleProtobufBoolValue} + get {_storage._googleProtobufBoolValue} set {_uniqueStorage()._googleProtobufBoolValue = newValue} } var googleProtobufBytesValue: Int32 { - get {return _storage._googleProtobufBytesValue} + get {_storage._googleProtobufBytesValue} set {_uniqueStorage()._googleProtobufBytesValue = newValue} } var googleProtobufDescriptorProto: Int32 { - get {return _storage._googleProtobufDescriptorProto} + get {_storage._googleProtobufDescriptorProto} set {_uniqueStorage()._googleProtobufDescriptorProto = newValue} } var googleProtobufDoubleValue: Int32 { - get {return _storage._googleProtobufDoubleValue} + get {_storage._googleProtobufDoubleValue} set {_uniqueStorage()._googleProtobufDoubleValue = newValue} } var googleProtobufDuration: Int32 { - get {return _storage._googleProtobufDuration} + get {_storage._googleProtobufDuration} set {_uniqueStorage()._googleProtobufDuration = newValue} } + var googleProtobufEdition: Int32 { + get {_storage._googleProtobufEdition} + set {_uniqueStorage()._googleProtobufEdition = newValue} + } + var googleProtobufEmpty: Int32 { - get {return _storage._googleProtobufEmpty} + get {_storage._googleProtobufEmpty} set {_uniqueStorage()._googleProtobufEmpty = newValue} } var googleProtobufEnum: Int32 { - get {return _storage._googleProtobufEnum} + get {_storage._googleProtobufEnum} set {_uniqueStorage()._googleProtobufEnum = newValue} } var googleProtobufEnumDescriptorProto: Int32 { - get {return _storage._googleProtobufEnumDescriptorProto} + get {_storage._googleProtobufEnumDescriptorProto} set {_uniqueStorage()._googleProtobufEnumDescriptorProto = newValue} } var googleProtobufEnumOptions: Int32 { - get {return _storage._googleProtobufEnumOptions} + get {_storage._googleProtobufEnumOptions} set {_uniqueStorage()._googleProtobufEnumOptions = newValue} } var googleProtobufEnumValue: Int32 { - get {return _storage._googleProtobufEnumValue} + get {_storage._googleProtobufEnumValue} set {_uniqueStorage()._googleProtobufEnumValue = newValue} } var googleProtobufEnumValueDescriptorProto: Int32 { - get {return _storage._googleProtobufEnumValueDescriptorProto} + get {_storage._googleProtobufEnumValueDescriptorProto} set {_uniqueStorage()._googleProtobufEnumValueDescriptorProto = newValue} } var googleProtobufEnumValueOptions: Int32 { - get {return _storage._googleProtobufEnumValueOptions} + get {_storage._googleProtobufEnumValueOptions} set {_uniqueStorage()._googleProtobufEnumValueOptions = newValue} } var googleProtobufExtensionRangeOptions: Int32 { - get {return _storage._googleProtobufExtensionRangeOptions} + get {_storage._googleProtobufExtensionRangeOptions} set {_uniqueStorage()._googleProtobufExtensionRangeOptions = newValue} } + var googleProtobufFeatureSet: Int32 { + get {_storage._googleProtobufFeatureSet} + set {_uniqueStorage()._googleProtobufFeatureSet = newValue} + } + + var googleProtobufFeatureSetDefaults: Int32 { + get {_storage._googleProtobufFeatureSetDefaults} + set {_uniqueStorage()._googleProtobufFeatureSetDefaults = newValue} + } + var googleProtobufField: Int32 { - get {return _storage._googleProtobufField} + get {_storage._googleProtobufField} set {_uniqueStorage()._googleProtobufField = newValue} } var googleProtobufFieldDescriptorProto: Int32 { - get {return _storage._googleProtobufFieldDescriptorProto} + get {_storage._googleProtobufFieldDescriptorProto} set {_uniqueStorage()._googleProtobufFieldDescriptorProto = newValue} } var googleProtobufFieldMask: Int32 { - get {return _storage._googleProtobufFieldMask} + get {_storage._googleProtobufFieldMask} set {_uniqueStorage()._googleProtobufFieldMask = newValue} } var googleProtobufFieldOptions: Int32 { - get {return _storage._googleProtobufFieldOptions} + get {_storage._googleProtobufFieldOptions} set {_uniqueStorage()._googleProtobufFieldOptions = newValue} } var googleProtobufFileDescriptorProto: Int32 { - get {return _storage._googleProtobufFileDescriptorProto} + get {_storage._googleProtobufFileDescriptorProto} set {_uniqueStorage()._googleProtobufFileDescriptorProto = newValue} } var googleProtobufFileDescriptorSet: Int32 { - get {return _storage._googleProtobufFileDescriptorSet} + get {_storage._googleProtobufFileDescriptorSet} set {_uniqueStorage()._googleProtobufFileDescriptorSet = newValue} } var googleProtobufFileOptions: Int32 { - get {return _storage._googleProtobufFileOptions} + get {_storage._googleProtobufFileOptions} set {_uniqueStorage()._googleProtobufFileOptions = newValue} } var googleProtobufFloatValue: Int32 { - get {return _storage._googleProtobufFloatValue} + get {_storage._googleProtobufFloatValue} set {_uniqueStorage()._googleProtobufFloatValue = newValue} } var googleProtobufGeneratedCodeInfo: Int32 { - get {return _storage._googleProtobufGeneratedCodeInfo} + get {_storage._googleProtobufGeneratedCodeInfo} set {_uniqueStorage()._googleProtobufGeneratedCodeInfo = newValue} } var googleProtobufInt32Value: Int32 { - get {return _storage._googleProtobufInt32Value} + get {_storage._googleProtobufInt32Value} set {_uniqueStorage()._googleProtobufInt32Value = newValue} } var googleProtobufInt64Value: Int32 { - get {return _storage._googleProtobufInt64Value} + get {_storage._googleProtobufInt64Value} set {_uniqueStorage()._googleProtobufInt64Value = newValue} } var googleProtobufListValue: Int32 { - get {return _storage._googleProtobufListValue} + get {_storage._googleProtobufListValue} set {_uniqueStorage()._googleProtobufListValue = newValue} } var googleProtobufMessageOptions: Int32 { - get {return _storage._googleProtobufMessageOptions} + get {_storage._googleProtobufMessageOptions} set {_uniqueStorage()._googleProtobufMessageOptions = newValue} } var googleProtobufMethod: Int32 { - get {return _storage._googleProtobufMethod} + get {_storage._googleProtobufMethod} set {_uniqueStorage()._googleProtobufMethod = newValue} } var googleProtobufMethodDescriptorProto: Int32 { - get {return _storage._googleProtobufMethodDescriptorProto} + get {_storage._googleProtobufMethodDescriptorProto} set {_uniqueStorage()._googleProtobufMethodDescriptorProto = newValue} } var googleProtobufMethodOptions: Int32 { - get {return _storage._googleProtobufMethodOptions} + get {_storage._googleProtobufMethodOptions} set {_uniqueStorage()._googleProtobufMethodOptions = newValue} } var googleProtobufMixin: Int32 { - get {return _storage._googleProtobufMixin} + get {_storage._googleProtobufMixin} set {_uniqueStorage()._googleProtobufMixin = newValue} } var googleProtobufNullValue: Int32 { - get {return _storage._googleProtobufNullValue} + get {_storage._googleProtobufNullValue} set {_uniqueStorage()._googleProtobufNullValue = newValue} } var googleProtobufOneofDescriptorProto: Int32 { - get {return _storage._googleProtobufOneofDescriptorProto} + get {_storage._googleProtobufOneofDescriptorProto} set {_uniqueStorage()._googleProtobufOneofDescriptorProto = newValue} } var googleProtobufOneofOptions: Int32 { - get {return _storage._googleProtobufOneofOptions} + get {_storage._googleProtobufOneofOptions} set {_uniqueStorage()._googleProtobufOneofOptions = newValue} } var googleProtobufOption: Int32 { - get {return _storage._googleProtobufOption} + get {_storage._googleProtobufOption} set {_uniqueStorage()._googleProtobufOption = newValue} } var googleProtobufServiceDescriptorProto: Int32 { - get {return _storage._googleProtobufServiceDescriptorProto} + get {_storage._googleProtobufServiceDescriptorProto} set {_uniqueStorage()._googleProtobufServiceDescriptorProto = newValue} } var googleProtobufServiceOptions: Int32 { - get {return _storage._googleProtobufServiceOptions} + get {_storage._googleProtobufServiceOptions} set {_uniqueStorage()._googleProtobufServiceOptions = newValue} } var googleProtobufSourceCodeInfo: Int32 { - get {return _storage._googleProtobufSourceCodeInfo} + get {_storage._googleProtobufSourceCodeInfo} set {_uniqueStorage()._googleProtobufSourceCodeInfo = newValue} } var googleProtobufSourceContext: Int32 { - get {return _storage._googleProtobufSourceContext} + get {_storage._googleProtobufSourceContext} set {_uniqueStorage()._googleProtobufSourceContext = newValue} } var googleProtobufStringValue: Int32 { - get {return _storage._googleProtobufStringValue} + get {_storage._googleProtobufStringValue} set {_uniqueStorage()._googleProtobufStringValue = newValue} } var googleProtobufStruct: Int32 { - get {return _storage._googleProtobufStruct} + get {_storage._googleProtobufStruct} set {_uniqueStorage()._googleProtobufStruct = newValue} } + var googleProtobufSymbolVisibility: Int32 { + get {_storage._googleProtobufSymbolVisibility} + set {_uniqueStorage()._googleProtobufSymbolVisibility = newValue} + } + var googleProtobufSyntax: Int32 { - get {return _storage._googleProtobufSyntax} + get {_storage._googleProtobufSyntax} set {_uniqueStorage()._googleProtobufSyntax = newValue} } var googleProtobufTimestamp: Int32 { - get {return _storage._googleProtobufTimestamp} + get {_storage._googleProtobufTimestamp} set {_uniqueStorage()._googleProtobufTimestamp = newValue} } var googleProtobufType: Int32 { - get {return _storage._googleProtobufType} + get {_storage._googleProtobufType} set {_uniqueStorage()._googleProtobufType = newValue} } var googleProtobufUint32Value: Int32 { - get {return _storage._googleProtobufUint32Value} + get {_storage._googleProtobufUint32Value} set {_uniqueStorage()._googleProtobufUint32Value = newValue} } var googleProtobufUint64Value: Int32 { - get {return _storage._googleProtobufUint64Value} + get {_storage._googleProtobufUint64Value} set {_uniqueStorage()._googleProtobufUint64Value = newValue} } var googleProtobufUninterpretedOption: Int32 { - get {return _storage._googleProtobufUninterpretedOption} + get {_storage._googleProtobufUninterpretedOption} set {_uniqueStorage()._googleProtobufUninterpretedOption = newValue} } var googleProtobufValue: Int32 { - get {return _storage._googleProtobufValue} + get {_storage._googleProtobufValue} set {_uniqueStorage()._googleProtobufValue = newValue} } var goPackage: Int32 { - get {return _storage._goPackage} + get {_storage._goPackage} set {_uniqueStorage()._goPackage = newValue} } + var gotData: Int32 { + get {_storage._gotData} + set {_uniqueStorage()._gotData = newValue} + } + var group: Int32 { - get {return _storage._group} + get {_storage._group} set {_uniqueStorage()._group = newValue} } var groupFieldNumberStack: Int32 { - get {return _storage._groupFieldNumberStack} + get {_storage._groupFieldNumberStack} set {_uniqueStorage()._groupFieldNumberStack = newValue} } var groupSize: Int32 { - get {return _storage._groupSize} + get {_storage._groupSize} set {_uniqueStorage()._groupSize = newValue} } - var h: Int32 { - get {return _storage._h} - set {_uniqueStorage()._h = newValue} + var `guard`: Int32 { + get {_storage._guard} + set {_uniqueStorage()._guard = newValue} } var hadOneofValue: Int32 { - get {return _storage._hadOneofValue} + get {_storage._hadOneofValue} set {_uniqueStorage()._hadOneofValue = newValue} } var handleConflictingOneOf: Int32 { - get {return _storage._handleConflictingOneOf} + get {_storage._handleConflictingOneOf} set {_uniqueStorage()._handleConflictingOneOf = newValue} } + var handleInstruction: Int32 { + get {_storage._handleInstruction} + set {_uniqueStorage()._handleInstruction = newValue} + } + var hasAggregateValue_p: Int32 { - get {return _storage._hasAggregateValue_p} + get {_storage._hasAggregateValue_p} set {_uniqueStorage()._hasAggregateValue_p = newValue} } var hasAllowAlias_p: Int32 { - get {return _storage._hasAllowAlias_p} + get {_storage._hasAllowAlias_p} set {_uniqueStorage()._hasAllowAlias_p = newValue} } var hasBegin_p: Int32 { - get {return _storage._hasBegin_p} + get {_storage._hasBegin_p} set {_uniqueStorage()._hasBegin_p = newValue} } var hasCcEnableArenas_p: Int32 { - get {return _storage._hasCcEnableArenas_p} + get {_storage._hasCcEnableArenas_p} set {_uniqueStorage()._hasCcEnableArenas_p = newValue} } var hasCcGenericServices_p: Int32 { - get {return _storage._hasCcGenericServices_p} + get {_storage._hasCcGenericServices_p} set {_uniqueStorage()._hasCcGenericServices_p = newValue} } var hasClientStreaming_p: Int32 { - get {return _storage._hasClientStreaming_p} + get {_storage._hasClientStreaming_p} set {_uniqueStorage()._hasClientStreaming_p = newValue} } var hasCsharpNamespace_p: Int32 { - get {return _storage._hasCsharpNamespace_p} + get {_storage._hasCsharpNamespace_p} set {_uniqueStorage()._hasCsharpNamespace_p = newValue} } var hasCtype_p: Int32 { - get {return _storage._hasCtype_p} + get {_storage._hasCtype_p} set {_uniqueStorage()._hasCtype_p = newValue} } + var hasData_p: Int32 { + get {_storage._hasData_p} + set {_uniqueStorage()._hasData_p = newValue} + } + + var hasDebugRedact_p: Int32 { + get {_storage._hasDebugRedact_p} + set {_uniqueStorage()._hasDebugRedact_p = newValue} + } + + var hasDefaultSymbolVisibility_p: Int32 { + get {_storage._hasDefaultSymbolVisibility_p} + set {_uniqueStorage()._hasDefaultSymbolVisibility_p = newValue} + } + var hasDefaultValue_p: Int32 { - get {return _storage._hasDefaultValue_p} + get {_storage._hasDefaultValue_p} set {_uniqueStorage()._hasDefaultValue_p = newValue} } var hasDeprecated_p: Int32 { - get {return _storage._hasDeprecated_p} + get {_storage._hasDeprecated_p} set {_uniqueStorage()._hasDeprecated_p = newValue} } + var hasDeprecatedLegacyJsonFieldConflicts_p: Int32 { + get {_storage._hasDeprecatedLegacyJsonFieldConflicts_p} + set {_uniqueStorage()._hasDeprecatedLegacyJsonFieldConflicts_p = newValue} + } + + var hasDeprecationWarning_p: Int32 { + get {_storage._hasDeprecationWarning_p} + set {_uniqueStorage()._hasDeprecationWarning_p = newValue} + } + var hasDoubleValue_p: Int32 { - get {return _storage._hasDoubleValue_p} + get {_storage._hasDoubleValue_p} set {_uniqueStorage()._hasDoubleValue_p = newValue} } + var hasEdition_p: Int32 { + get {_storage._hasEdition_p} + set {_uniqueStorage()._hasEdition_p = newValue} + } + + var hasEditionDeprecated_p: Int32 { + get {_storage._hasEditionDeprecated_p} + set {_uniqueStorage()._hasEditionDeprecated_p = newValue} + } + + var hasEditionIntroduced_p: Int32 { + get {_storage._hasEditionIntroduced_p} + set {_uniqueStorage()._hasEditionIntroduced_p = newValue} + } + + var hasEditionRemoved_p: Int32 { + get {_storage._hasEditionRemoved_p} + set {_uniqueStorage()._hasEditionRemoved_p = newValue} + } + var hasEnd_p: Int32 { - get {return _storage._hasEnd_p} + get {_storage._hasEnd_p} set {_uniqueStorage()._hasEnd_p = newValue} } + var hasEnforceNamingStyle_p: Int32 { + get {_storage._hasEnforceNamingStyle_p} + set {_uniqueStorage()._hasEnforceNamingStyle_p = newValue} + } + + var hasEnumType_p: Int32 { + get {_storage._hasEnumType_p} + set {_uniqueStorage()._hasEnumType_p = newValue} + } + + var hasExplicitDelta_p: Int32 { + get {_storage._hasExplicitDelta_p} + set {_uniqueStorage()._hasExplicitDelta_p = newValue} + } + var hasExtendee_p: Int32 { - get {return _storage._hasExtendee_p} + get {_storage._hasExtendee_p} set {_uniqueStorage()._hasExtendee_p = newValue} } var hasExtensionValue_p: Int32 { - get {return _storage._hasExtensionValue_p} + get {_storage._hasExtensionValue_p} set {_uniqueStorage()._hasExtensionValue_p = newValue} } + var hasFeatures_p: Int32 { + get {_storage._hasFeatures_p} + set {_uniqueStorage()._hasFeatures_p = newValue} + } + + var hasFeatureSupport_p: Int32 { + get {_storage._hasFeatureSupport_p} + set {_uniqueStorage()._hasFeatureSupport_p = newValue} + } + + var hasFieldPresence_p: Int32 { + get {_storage._hasFieldPresence_p} + set {_uniqueStorage()._hasFieldPresence_p = newValue} + } + + var hasFixedFeatures_p: Int32 { + get {_storage._hasFixedFeatures_p} + set {_uniqueStorage()._hasFixedFeatures_p = newValue} + } + + var hasFullName_p: Int32 { + get {_storage._hasFullName_p} + set {_uniqueStorage()._hasFullName_p = newValue} + } + var hasGoPackage_p: Int32 { - get {return _storage._hasGoPackage_p} + get {_storage._hasGoPackage_p} set {_uniqueStorage()._hasGoPackage_p = newValue} } var hash: Int32 { - get {return _storage._hash} + get {_storage._hash} set {_uniqueStorage()._hash = newValue} } var hashable: Int32 { - get {return _storage._hashable} + get {_storage._hashable} set {_uniqueStorage()._hashable = newValue} } var hasher: Int32 { - get {return _storage._hasher} + get {_storage._hasher} set {_uniqueStorage()._hasher = newValue} } - var hashValue_p: Int32 { - get {return _storage._hashValue_p} - set {_uniqueStorage()._hashValue_p = newValue} - } - var hashVisitor: Int32 { - get {return _storage._hashVisitor} + get {_storage._hashVisitor} set {_uniqueStorage()._hashVisitor = newValue} } var hasIdempotencyLevel_p: Int32 { - get {return _storage._hasIdempotencyLevel_p} + get {_storage._hasIdempotencyLevel_p} set {_uniqueStorage()._hasIdempotencyLevel_p = newValue} } var hasIdentifierValue_p: Int32 { - get {return _storage._hasIdentifierValue_p} + get {_storage._hasIdentifierValue_p} set {_uniqueStorage()._hasIdentifierValue_p = newValue} } var hasInputType_p: Int32 { - get {return _storage._hasInputType_p} + get {_storage._hasInputType_p} set {_uniqueStorage()._hasInputType_p = newValue} } var hasIsExtension_p: Int32 { - get {return _storage._hasIsExtension_p} + get {_storage._hasIsExtension_p} set {_uniqueStorage()._hasIsExtension_p = newValue} } var hasJavaGenerateEqualsAndHash_p: Int32 { - get {return _storage._hasJavaGenerateEqualsAndHash_p} + get {_storage._hasJavaGenerateEqualsAndHash_p} set {_uniqueStorage()._hasJavaGenerateEqualsAndHash_p = newValue} } var hasJavaGenericServices_p: Int32 { - get {return _storage._hasJavaGenericServices_p} + get {_storage._hasJavaGenericServices_p} set {_uniqueStorage()._hasJavaGenericServices_p = newValue} } var hasJavaMultipleFiles_p: Int32 { - get {return _storage._hasJavaMultipleFiles_p} + get {_storage._hasJavaMultipleFiles_p} set {_uniqueStorage()._hasJavaMultipleFiles_p = newValue} } var hasJavaOuterClassname_p: Int32 { - get {return _storage._hasJavaOuterClassname_p} + get {_storage._hasJavaOuterClassname_p} set {_uniqueStorage()._hasJavaOuterClassname_p = newValue} } var hasJavaPackage_p: Int32 { - get {return _storage._hasJavaPackage_p} + get {_storage._hasJavaPackage_p} set {_uniqueStorage()._hasJavaPackage_p = newValue} } var hasJavaStringCheckUtf8_p: Int32 { - get {return _storage._hasJavaStringCheckUtf8_p} + get {_storage._hasJavaStringCheckUtf8_p} set {_uniqueStorage()._hasJavaStringCheckUtf8_p = newValue} } + var hasJsonFormat_p: Int32 { + get {_storage._hasJsonFormat_p} + set {_uniqueStorage()._hasJsonFormat_p = newValue} + } + var hasJsonName_p: Int32 { - get {return _storage._hasJsonName_p} + get {_storage._hasJsonName_p} set {_uniqueStorage()._hasJsonName_p = newValue} } var hasJstype_p: Int32 { - get {return _storage._hasJstype_p} + get {_storage._hasJstype_p} set {_uniqueStorage()._hasJstype_p = newValue} } var hasLabel_p: Int32 { - get {return _storage._hasLabel_p} + get {_storage._hasLabel_p} set {_uniqueStorage()._hasLabel_p = newValue} } var hasLazy_p: Int32 { - get {return _storage._hasLazy_p} + get {_storage._hasLazy_p} set {_uniqueStorage()._hasLazy_p = newValue} } var hasLeadingComments_p: Int32 { - get {return _storage._hasLeadingComments_p} + get {_storage._hasLeadingComments_p} set {_uniqueStorage()._hasLeadingComments_p = newValue} } var hasMapEntry_p: Int32 { - get {return _storage._hasMapEntry_p} + get {_storage._hasMapEntry_p} set {_uniqueStorage()._hasMapEntry_p = newValue} } + var hasMaximumEdition_p: Int32 { + get {_storage._hasMaximumEdition_p} + set {_uniqueStorage()._hasMaximumEdition_p = newValue} + } + + var hasMessageEncoding_p: Int32 { + get {_storage._hasMessageEncoding_p} + set {_uniqueStorage()._hasMessageEncoding_p = newValue} + } + var hasMessageSetWireFormat_p: Int32 { - get {return _storage._hasMessageSetWireFormat_p} + get {_storage._hasMessageSetWireFormat_p} set {_uniqueStorage()._hasMessageSetWireFormat_p = newValue} } + var hasMinimumEdition_p: Int32 { + get {_storage._hasMinimumEdition_p} + set {_uniqueStorage()._hasMinimumEdition_p = newValue} + } + var hasName_p: Int32 { - get {return _storage._hasName_p} + get {_storage._hasName_p} set {_uniqueStorage()._hasName_p = newValue} } var hasNamePart_p: Int32 { - get {return _storage._hasNamePart_p} + get {_storage._hasNamePart_p} set {_uniqueStorage()._hasNamePart_p = newValue} } var hasNegativeIntValue_p: Int32 { - get {return _storage._hasNegativeIntValue_p} + get {_storage._hasNegativeIntValue_p} set {_uniqueStorage()._hasNegativeIntValue_p = newValue} } var hasNoStandardDescriptorAccessor_p: Int32 { - get {return _storage._hasNoStandardDescriptorAccessor_p} + get {_storage._hasNoStandardDescriptorAccessor_p} set {_uniqueStorage()._hasNoStandardDescriptorAccessor_p = newValue} } var hasNumber_p: Int32 { - get {return _storage._hasNumber_p} + get {_storage._hasNumber_p} set {_uniqueStorage()._hasNumber_p = newValue} } var hasObjcClassPrefix_p: Int32 { - get {return _storage._hasObjcClassPrefix_p} + get {_storage._hasObjcClassPrefix_p} set {_uniqueStorage()._hasObjcClassPrefix_p = newValue} } var hasOneofIndex_p: Int32 { - get {return _storage._hasOneofIndex_p} + get {_storage._hasOneofIndex_p} set {_uniqueStorage()._hasOneofIndex_p = newValue} } var hasOptimizeFor_p: Int32 { - get {return _storage._hasOptimizeFor_p} + get {_storage._hasOptimizeFor_p} set {_uniqueStorage()._hasOptimizeFor_p = newValue} } var hasOptions_p: Int32 { - get {return _storage._hasOptions_p} + get {_storage._hasOptions_p} set {_uniqueStorage()._hasOptions_p = newValue} } var hasOutputType_p: Int32 { - get {return _storage._hasOutputType_p} + get {_storage._hasOutputType_p} set {_uniqueStorage()._hasOutputType_p = newValue} } + var hasOverridableFeatures_p: Int32 { + get {_storage._hasOverridableFeatures_p} + set {_uniqueStorage()._hasOverridableFeatures_p = newValue} + } + var hasPackage_p: Int32 { - get {return _storage._hasPackage_p} + get {_storage._hasPackage_p} set {_uniqueStorage()._hasPackage_p = newValue} } var hasPacked_p: Int32 { - get {return _storage._hasPacked_p} + get {_storage._hasPacked_p} set {_uniqueStorage()._hasPacked_p = newValue} } var hasPhpClassPrefix_p: Int32 { - get {return _storage._hasPhpClassPrefix_p} + get {_storage._hasPhpClassPrefix_p} set {_uniqueStorage()._hasPhpClassPrefix_p = newValue} } - var hasPhpGenericServices_p: Int32 { - get {return _storage._hasPhpGenericServices_p} - set {_uniqueStorage()._hasPhpGenericServices_p = newValue} - } - var hasPhpMetadataNamespace_p: Int32 { - get {return _storage._hasPhpMetadataNamespace_p} + get {_storage._hasPhpMetadataNamespace_p} set {_uniqueStorage()._hasPhpMetadataNamespace_p = newValue} } var hasPhpNamespace_p: Int32 { - get {return _storage._hasPhpNamespace_p} + get {_storage._hasPhpNamespace_p} set {_uniqueStorage()._hasPhpNamespace_p = newValue} } var hasPositiveIntValue_p: Int32 { - get {return _storage._hasPositiveIntValue_p} + get {_storage._hasPositiveIntValue_p} set {_uniqueStorage()._hasPositiveIntValue_p = newValue} } var hasProto3Optional_p: Int32 { - get {return _storage._hasProto3Optional_p} + get {_storage._hasProto3Optional_p} set {_uniqueStorage()._hasProto3Optional_p = newValue} } var hasPyGenericServices_p: Int32 { - get {return _storage._hasPyGenericServices_p} + get {_storage._hasPyGenericServices_p} set {_uniqueStorage()._hasPyGenericServices_p = newValue} } + var hasRemovalError_p: Int32 { + get {_storage._hasRemovalError_p} + set {_uniqueStorage()._hasRemovalError_p = newValue} + } + + var hasRepeated_p: Int32 { + get {_storage._hasRepeated_p} + set {_uniqueStorage()._hasRepeated_p = newValue} + } + + var hasRepeatedFieldEncoding_p: Int32 { + get {_storage._hasRepeatedFieldEncoding_p} + set {_uniqueStorage()._hasRepeatedFieldEncoding_p = newValue} + } + + var hasReserved_p: Int32 { + get {_storage._hasReserved_p} + set {_uniqueStorage()._hasReserved_p = newValue} + } + + var hasRetention_p: Int32 { + get {_storage._hasRetention_p} + set {_uniqueStorage()._hasRetention_p = newValue} + } + var hasRubyPackage_p: Int32 { - get {return _storage._hasRubyPackage_p} + get {_storage._hasRubyPackage_p} set {_uniqueStorage()._hasRubyPackage_p = newValue} } + var hasSemantic_p: Int32 { + get {_storage._hasSemantic_p} + set {_uniqueStorage()._hasSemantic_p = newValue} + } + var hasServerStreaming_p: Int32 { - get {return _storage._hasServerStreaming_p} + get {_storage._hasServerStreaming_p} set {_uniqueStorage()._hasServerStreaming_p = newValue} } var hasSourceCodeInfo_p: Int32 { - get {return _storage._hasSourceCodeInfo_p} + get {_storage._hasSourceCodeInfo_p} set {_uniqueStorage()._hasSourceCodeInfo_p = newValue} } var hasSourceContext_p: Int32 { - get {return _storage._hasSourceContext_p} + get {_storage._hasSourceContext_p} set {_uniqueStorage()._hasSourceContext_p = newValue} } var hasSourceFile_p: Int32 { - get {return _storage._hasSourceFile_p} + get {_storage._hasSourceFile_p} set {_uniqueStorage()._hasSourceFile_p = newValue} } var hasStart_p: Int32 { - get {return _storage._hasStart_p} + get {_storage._hasStart_p} set {_uniqueStorage()._hasStart_p = newValue} } var hasStringValue_p: Int32 { - get {return _storage._hasStringValue_p} + get {_storage._hasStringValue_p} set {_uniqueStorage()._hasStringValue_p = newValue} } var hasSwiftPrefix_p: Int32 { - get {return _storage._hasSwiftPrefix_p} + get {_storage._hasSwiftPrefix_p} set {_uniqueStorage()._hasSwiftPrefix_p = newValue} } var hasSyntax_p: Int32 { - get {return _storage._hasSyntax_p} + get {_storage._hasSyntax_p} set {_uniqueStorage()._hasSyntax_p = newValue} } var hasTrailingComments_p: Int32 { - get {return _storage._hasTrailingComments_p} + get {_storage._hasTrailingComments_p} set {_uniqueStorage()._hasTrailingComments_p = newValue} } var hasType_p: Int32 { - get {return _storage._hasType_p} + get {_storage._hasType_p} set {_uniqueStorage()._hasType_p = newValue} } var hasTypeName_p: Int32 { - get {return _storage._hasTypeName_p} + get {_storage._hasTypeName_p} set {_uniqueStorage()._hasTypeName_p = newValue} } + var hasUnverifiedLazy_p: Int32 { + get {_storage._hasUnverifiedLazy_p} + set {_uniqueStorage()._hasUnverifiedLazy_p = newValue} + } + + var hasUtf8Validation_p: Int32 { + get {_storage._hasUtf8Validation_p} + set {_uniqueStorage()._hasUtf8Validation_p = newValue} + } + var hasValue_p: Int32 { - get {return _storage._hasValue_p} + get {_storage._hasValue_p} set {_uniqueStorage()._hasValue_p = newValue} } + var hasVerification_p: Int32 { + get {_storage._hasVerification_p} + set {_uniqueStorage()._hasVerification_p = newValue} + } + + var hasVisibility_p: Int32 { + get {_storage._hasVisibility_p} + set {_uniqueStorage()._hasVisibility_p = newValue} + } + var hasWeak_p: Int32 { - get {return _storage._hasWeak_p} + get {_storage._hasWeak_p} set {_uniqueStorage()._hasWeak_p = newValue} } var hour: Int32 { - get {return _storage._hour} + get {_storage._hour} set {_uniqueStorage()._hour = newValue} } var i: Int32 { - get {return _storage._i} + get {_storage._i} set {_uniqueStorage()._i = newValue} } var idempotencyLevel: Int32 { - get {return _storage._idempotencyLevel} + get {_storage._idempotencyLevel} set {_uniqueStorage()._idempotencyLevel = newValue} } var identifierValue: Int32 { - get {return _storage._identifierValue} + get {_storage._identifierValue} set {_uniqueStorage()._identifierValue = newValue} } var `if`: Int32 { - get {return _storage._if} + get {_storage._if} set {_uniqueStorage()._if = newValue} } + var ignoreUnknownExtensionFields: Int32 { + get {_storage._ignoreUnknownExtensionFields} + set {_uniqueStorage()._ignoreUnknownExtensionFields = newValue} + } + var ignoreUnknownFields: Int32 { - get {return _storage._ignoreUnknownFields} + get {_storage._ignoreUnknownFields} set {_uniqueStorage()._ignoreUnknownFields = newValue} } var index: Int32 { - get {return _storage._index} + get {_storage._index} set {_uniqueStorage()._index = newValue} } var init_p: Int32 { - get {return _storage._init_p} + get {_storage._init_p} set {_uniqueStorage()._init_p = newValue} } var `inout`: Int32 { - get {return _storage._inout} + get {_storage._inout} set {_uniqueStorage()._inout = newValue} } var inputType: Int32 { - get {return _storage._inputType} + get {_storage._inputType} set {_uniqueStorage()._inputType = newValue} } var insert: Int32 { - get {return _storage._insert} + get {_storage._insert} set {_uniqueStorage()._insert = newValue} } + var instruction: Int32 { + get {_storage._instruction} + set {_uniqueStorage()._instruction = newValue} + } + var int: Int32 { - get {return _storage._int} + get {_storage._int} set {_uniqueStorage()._int = newValue} } var int32: Int32 { - get {return _storage._int32} + get {_storage._int32} set {_uniqueStorage()._int32 = newValue} } - var int32Value: Int32 { - get {return _storage._int32Value} - set {_uniqueStorage()._int32Value = newValue} - } - var int64: Int32 { - get {return _storage._int64} + get {_storage._int64} set {_uniqueStorage()._int64 = newValue} } - var int64Value: Int32 { - get {return _storage._int64Value} - set {_uniqueStorage()._int64Value = newValue} - } - var int8: Int32 { - get {return _storage._int8} + get {_storage._int8} set {_uniqueStorage()._int8 = newValue} } var integerLiteral: Int32 { - get {return _storage._integerLiteral} + get {_storage._integerLiteral} set {_uniqueStorage()._integerLiteral = newValue} } var integerLiteralType: Int32 { - get {return _storage._integerLiteralType} + get {_storage._integerLiteralType} set {_uniqueStorage()._integerLiteralType = newValue} } var intern: Int32 { - get {return _storage._intern} + get {_storage._intern} set {_uniqueStorage()._intern = newValue} } var `internal`: Int32 { - get {return _storage._internal} + get {_storage._internal} set {_uniqueStorage()._internal = newValue} } var internalState: Int32 { - get {return _storage._internalState} + get {_storage._internalState} set {_uniqueStorage()._internalState = newValue} } + var intersect: Int32 { + get {_storage._intersect} + set {_uniqueStorage()._intersect = newValue} + } + var into: Int32 { - get {return _storage._into} + get {_storage._into} set {_uniqueStorage()._into = newValue} } var ints: Int32 { - get {return _storage._ints} + get {_storage._ints} set {_uniqueStorage()._ints = newValue} } + var invalidAnyTypeURL: Int32 { + get {_storage._invalidAnyTypeURL} + set {_uniqueStorage()._invalidAnyTypeURL = newValue} + } + var isA: Int32 { - get {return _storage._isA} + get {_storage._isA} set {_uniqueStorage()._isA = newValue} } var isEqual: Int32 { - get {return _storage._isEqual} + get {_storage._isEqual} set {_uniqueStorage()._isEqual = newValue} } var isEqualTo: Int32 { - get {return _storage._isEqualTo} + get {_storage._isEqualTo} set {_uniqueStorage()._isEqualTo = newValue} } var isExtension: Int32 { - get {return _storage._isExtension} + get {_storage._isExtension} set {_uniqueStorage()._isExtension = newValue} } var isInitialized_p: Int32 { - get {return _storage._isInitialized_p} + get {_storage._isInitialized_p} set {_uniqueStorage()._isInitialized_p = newValue} } + var isNegative: Int32 { + get {_storage._isNegative} + set {_uniqueStorage()._isNegative = newValue} + } + + var isPathValid: Int32 { + get {_storage._isPathValid} + set {_uniqueStorage()._isPathValid = newValue} + } + + var isReserved: Int32 { + get {_storage._isReserved} + set {_uniqueStorage()._isReserved = newValue} + } + + var isValid: Int32 { + get {_storage._isValid} + set {_uniqueStorage()._isValid = newValue} + } + var itemTagsEncodedSize: Int32 { - get {return _storage._itemTagsEncodedSize} + get {_storage._itemTagsEncodedSize} set {_uniqueStorage()._itemTagsEncodedSize = newValue} } var iterator: Int32 { - get {return _storage._iterator} + get {_storage._iterator} set {_uniqueStorage()._iterator = newValue} } - var i2166136261: Int32 { - get {return _storage._i2166136261} - set {_uniqueStorage()._i2166136261 = newValue} - } - var javaGenerateEqualsAndHash: Int32 { - get {return _storage._javaGenerateEqualsAndHash} + get {_storage._javaGenerateEqualsAndHash} set {_uniqueStorage()._javaGenerateEqualsAndHash = newValue} } var javaGenericServices: Int32 { - get {return _storage._javaGenericServices} + get {_storage._javaGenericServices} set {_uniqueStorage()._javaGenericServices = newValue} } var javaMultipleFiles: Int32 { - get {return _storage._javaMultipleFiles} + get {_storage._javaMultipleFiles} set {_uniqueStorage()._javaMultipleFiles = newValue} } var javaOuterClassname: Int32 { - get {return _storage._javaOuterClassname} + get {_storage._javaOuterClassname} set {_uniqueStorage()._javaOuterClassname = newValue} } var javaPackage: Int32 { - get {return _storage._javaPackage} + get {_storage._javaPackage} set {_uniqueStorage()._javaPackage = newValue} } var javaStringCheckUtf8: Int32 { - get {return _storage._javaStringCheckUtf8} + get {_storage._javaStringCheckUtf8} set {_uniqueStorage()._javaStringCheckUtf8 = newValue} } var jsondecoder: Int32 { - get {return _storage._jsondecoder} + get {_storage._jsondecoder} set {_uniqueStorage()._jsondecoder = newValue} } + var jsondecoding: Int32 { + get {_storage._jsondecoding} + set {_uniqueStorage()._jsondecoding = newValue} + } + var jsondecodingError: Int32 { - get {return _storage._jsondecodingError} + get {_storage._jsondecodingError} set {_uniqueStorage()._jsondecodingError = newValue} } var jsondecodingOptions: Int32 { - get {return _storage._jsondecodingOptions} + get {_storage._jsondecodingOptions} set {_uniqueStorage()._jsondecodingOptions = newValue} } var jsonEncoder: Int32 { - get {return _storage._jsonEncoder} + get {_storage._jsonEncoder} set {_uniqueStorage()._jsonEncoder = newValue} } + var jsonencoding: Int32 { + get {_storage._jsonencoding} + set {_uniqueStorage()._jsonencoding = newValue} + } + var jsonencodingError: Int32 { - get {return _storage._jsonencodingError} + get {_storage._jsonencodingError} set {_uniqueStorage()._jsonencodingError = newValue} } var jsonencodingOptions: Int32 { - get {return _storage._jsonencodingOptions} + get {_storage._jsonencodingOptions} set {_uniqueStorage()._jsonencodingOptions = newValue} } var jsonencodingVisitor: Int32 { - get {return _storage._jsonencodingVisitor} + get {_storage._jsonencodingVisitor} set {_uniqueStorage()._jsonencodingVisitor = newValue} } + var jsonFormat: Int32 { + get {_storage._jsonFormat} + set {_uniqueStorage()._jsonFormat = newValue} + } + var jsonmapEncodingVisitor: Int32 { - get {return _storage._jsonmapEncodingVisitor} + get {_storage._jsonmapEncodingVisitor} set {_uniqueStorage()._jsonmapEncodingVisitor = newValue} } var jsonName: Int32 { - get {return _storage._jsonName} + get {_storage._jsonName} set {_uniqueStorage()._jsonName = newValue} } var jsonPath: Int32 { - get {return _storage._jsonPath} + get {_storage._jsonPath} set {_uniqueStorage()._jsonPath = newValue} } var jsonPaths: Int32 { - get {return _storage._jsonPaths} + get {_storage._jsonPaths} set {_uniqueStorage()._jsonPaths = newValue} } var jsonscanner: Int32 { - get {return _storage._jsonscanner} + get {_storage._jsonscanner} set {_uniqueStorage()._jsonscanner = newValue} } var jsonString: Int32 { - get {return _storage._jsonString} + get {_storage._jsonString} set {_uniqueStorage()._jsonString = newValue} } var jsonText: Int32 { - get {return _storage._jsonText} + get {_storage._jsonText} set {_uniqueStorage()._jsonText = newValue} } + var jsonUtf8Bytes: Int32 { + get {_storage._jsonUtf8Bytes} + set {_uniqueStorage()._jsonUtf8Bytes = newValue} + } + var jsonUtf8Data: Int32 { - get {return _storage._jsonUtf8Data} + get {_storage._jsonUtf8Data} set {_uniqueStorage()._jsonUtf8Data = newValue} } var jstype: Int32 { - get {return _storage._jstype} + get {_storage._jstype} set {_uniqueStorage()._jstype = newValue} } var k: Int32 { - get {return _storage._k} + get {_storage._k} set {_uniqueStorage()._k = newValue} } + var kChunkSize: Int32 { + get {_storage._kChunkSize} + set {_uniqueStorage()._kChunkSize = newValue} + } + var key: Int32 { - get {return _storage._key} + get {_storage._key} set {_uniqueStorage()._key = newValue} } var keyField: Int32 { - get {return _storage._keyField} + get {_storage._keyField} set {_uniqueStorage()._keyField = newValue} } + var keyFieldOpt: Int32 { + get {_storage._keyFieldOpt} + set {_uniqueStorage()._keyFieldOpt = newValue} + } + var keyType: Int32 { - get {return _storage._keyType} + get {_storage._keyType} set {_uniqueStorage()._keyType = newValue} } var kind: Int32 { - get {return _storage._kind} + get {_storage._kind} set {_uniqueStorage()._kind = newValue} } var l: Int32 { - get {return _storage._l} + get {_storage._l} set {_uniqueStorage()._l = newValue} } var label: Int32 { - get {return _storage._label} + get {_storage._label} set {_uniqueStorage()._label = newValue} } var lazy: Int32 { - get {return _storage._lazy} + get {_storage._lazy} set {_uniqueStorage()._lazy = newValue} } var leadingComments: Int32 { - get {return _storage._leadingComments} + get {_storage._leadingComments} set {_uniqueStorage()._leadingComments = newValue} } var leadingDetachedComments: Int32 { - get {return _storage._leadingDetachedComments} + get {_storage._leadingDetachedComments} set {_uniqueStorage()._leadingDetachedComments = newValue} } var length: Int32 { - get {return _storage._length} + get {_storage._length} set {_uniqueStorage()._length = newValue} } var lessThan: Int32 { - get {return _storage._lessThan} + get {_storage._lessThan} set {_uniqueStorage()._lessThan = newValue} } var `let`: Int32 { - get {return _storage._let} + get {_storage._let} set {_uniqueStorage()._let = newValue} } var lhs: Int32 { - get {return _storage._lhs} + get {_storage._lhs} set {_uniqueStorage()._lhs = newValue} } + var line: Int32 { + get {_storage._line} + set {_uniqueStorage()._line = newValue} + } + var list: Int32 { - get {return _storage._list} + get {_storage._list} set {_uniqueStorage()._list = newValue} } var listOfMessages: Int32 { - get {return _storage._listOfMessages} + get {_storage._listOfMessages} set {_uniqueStorage()._listOfMessages = newValue} } var listValue: Int32 { - get {return _storage._listValue} + get {_storage._listValue} set {_uniqueStorage()._listValue = newValue} } var littleEndian: Int32 { - get {return _storage._littleEndian} + get {_storage._littleEndian} set {_uniqueStorage()._littleEndian = newValue} } - var littleEndianBytes: Int32 { - get {return _storage._littleEndianBytes} - set {_uniqueStorage()._littleEndianBytes = newValue} - } - var load: Int32 { - get {return _storage._load} + get {_storage._load} set {_uniqueStorage()._load = newValue} } var localHasher: Int32 { - get {return _storage._localHasher} + get {_storage._localHasher} set {_uniqueStorage()._localHasher = newValue} } var location: Int32 { - get {return _storage._location} + get {_storage._location} set {_uniqueStorage()._location = newValue} } var m: Int32 { - get {return _storage._m} + get {_storage._m} set {_uniqueStorage()._m = newValue} } var major: Int32 { - get {return _storage._major} + get {_storage._major} set {_uniqueStorage()._major = newValue} } + var makeAsyncIterator: Int32 { + get {_storage._makeAsyncIterator} + set {_uniqueStorage()._makeAsyncIterator = newValue} + } + var makeIterator: Int32 { - get {return _storage._makeIterator} + get {_storage._makeIterator} set {_uniqueStorage()._makeIterator = newValue} } - var mapEntry: Int32 { - get {return _storage._mapEntry} - set {_uniqueStorage()._mapEntry = newValue} + var malformedLength: Int32 { + get {_storage._malformedLength} + set {_uniqueStorage()._malformedLength = newValue} } - var mapHash: Int32 { - get {return _storage._mapHash} - set {_uniqueStorage()._mapHash = newValue} + var mapEntry: Int32 { + get {_storage._mapEntry} + set {_uniqueStorage()._mapEntry = newValue} } var mapKeyType: Int32 { - get {return _storage._mapKeyType} + get {_storage._mapKeyType} set {_uniqueStorage()._mapKeyType = newValue} } - var mapNameResolver: Int32 { - get {return _storage._mapNameResolver} - set {_uniqueStorage()._mapNameResolver = newValue} - } - var mapToMessages: Int32 { - get {return _storage._mapToMessages} + get {_storage._mapToMessages} set {_uniqueStorage()._mapToMessages = newValue} } var mapValueType: Int32 { - get {return _storage._mapValueType} + get {_storage._mapValueType} set {_uniqueStorage()._mapValueType = newValue} } var mapVisitor: Int32 { - get {return _storage._mapVisitor} + get {_storage._mapVisitor} set {_uniqueStorage()._mapVisitor = newValue} } + var mask: Int32 { + get {_storage._mask} + set {_uniqueStorage()._mask = newValue} + } + + var maximumEdition: Int32 { + get {_storage._maximumEdition} + set {_uniqueStorage()._maximumEdition = newValue} + } + var mdayStart: Int32 { - get {return _storage._mdayStart} + get {_storage._mdayStart} set {_uniqueStorage()._mdayStart = newValue} } var merge: Int32 { - get {return _storage._merge} + get {_storage._merge} set {_uniqueStorage()._merge = newValue} } + var mergeOptions: Int32 { + get {_storage._mergeOptions} + set {_uniqueStorage()._mergeOptions = newValue} + } + var message: Int32 { - get {return _storage._message} + get {_storage._message} set {_uniqueStorage()._message = newValue} } var messageDepthLimit: Int32 { - get {return _storage._messageDepthLimit} + get {_storage._messageDepthLimit} set {_uniqueStorage()._messageDepthLimit = newValue} } + var messageEncoding: Int32 { + get {_storage._messageEncoding} + set {_uniqueStorage()._messageEncoding = newValue} + } + var messageExtension: Int32 { - get {return _storage._messageExtension} + get {_storage._messageExtension} set {_uniqueStorage()._messageExtension = newValue} } var messageImplementationBase: Int32 { - get {return _storage._messageImplementationBase} + get {_storage._messageImplementationBase} set {_uniqueStorage()._messageImplementationBase = newValue} } - var messageOptions: Int32 { - get {return _storage._messageOptions} - set {_uniqueStorage()._messageOptions = newValue} - } - var messageSet: Int32 { - get {return _storage._messageSet} + get {_storage._messageSet} set {_uniqueStorage()._messageSet = newValue} } var messageSetWireFormat: Int32 { - get {return _storage._messageSetWireFormat} + get {_storage._messageSetWireFormat} set {_uniqueStorage()._messageSetWireFormat = newValue} } + var messageSize: Int32 { + get {_storage._messageSize} + set {_uniqueStorage()._messageSize = newValue} + } + var messageType: Int32 { - get {return _storage._messageType} + get {_storage._messageType} set {_uniqueStorage()._messageType = newValue} } var method: Int32 { - get {return _storage._method} + get {_storage._method} set {_uniqueStorage()._method = newValue} } - var methodDescriptorProto: Int32 { - get {return _storage._methodDescriptorProto} - set {_uniqueStorage()._methodDescriptorProto = newValue} + var methods: Int32 { + get {_storage._methods} + set {_uniqueStorage()._methods = newValue} } - var methodOptions: Int32 { - get {return _storage._methodOptions} - set {_uniqueStorage()._methodOptions = newValue} + var min: Int32 { + get {_storage._min} + set {_uniqueStorage()._min = newValue} } - var methods: Int32 { - get {return _storage._methods} - set {_uniqueStorage()._methods = newValue} + var minimumEdition: Int32 { + get {_storage._minimumEdition} + set {_uniqueStorage()._minimumEdition = newValue} } var minor: Int32 { - get {return _storage._minor} + get {_storage._minor} set {_uniqueStorage()._minor = newValue} } - var mixin: Int32 { - get {return _storage._mixin} - set {_uniqueStorage()._mixin = newValue} - } - var mixins: Int32 { - get {return _storage._mixins} + get {_storage._mixins} set {_uniqueStorage()._mixins = newValue} } - var modifier: Int32 { - get {return _storage._modifier} - set {_uniqueStorage()._modifier = newValue} - } - var modify: Int32 { - get {return _storage._modify} + get {_storage._modify} set {_uniqueStorage()._modify = newValue} } var month: Int32 { - get {return _storage._month} + get {_storage._month} set {_uniqueStorage()._month = newValue} } var msgExtension: Int32 { - get {return _storage._msgExtension} + get {_storage._msgExtension} set {_uniqueStorage()._msgExtension = newValue} } var mutating: Int32 { - get {return _storage._mutating} + get {_storage._mutating} set {_uniqueStorage()._mutating = newValue} } var n: Int32 { - get {return _storage._n} + get {_storage._n} set {_uniqueStorage()._n = newValue} } var name: Int32 { - get {return _storage._name} + get {_storage._name} set {_uniqueStorage()._name = newValue} } var nameDescription: Int32 { - get {return _storage._nameDescription} + get {_storage._nameDescription} set {_uniqueStorage()._nameDescription = newValue} } var nameMap: Int32 { - get {return _storage._nameMap} + get {_storage._nameMap} set {_uniqueStorage()._nameMap = newValue} } var namePart: Int32 { - get {return _storage._namePart} + get {_storage._namePart} set {_uniqueStorage()._namePart = newValue} } - var nameResolver: Int32 { - get {return _storage._nameResolver} - set {_uniqueStorage()._nameResolver = newValue} - } - var names: Int32 { - get {return _storage._names} + get {_storage._names} set {_uniqueStorage()._names = newValue} } var nanos: Int32 { - get {return _storage._nanos} + get {_storage._nanos} set {_uniqueStorage()._nanos = newValue} } - var nativeBytes: Int32 { - get {return _storage._nativeBytes} - set {_uniqueStorage()._nativeBytes = newValue} - } - - var nativeEndianBytes: Int32 { - get {return _storage._nativeEndianBytes} - set {_uniqueStorage()._nativeEndianBytes = newValue} - } - var negativeIntValue: Int32 { - get {return _storage._negativeIntValue} + get {_storage._negativeIntValue} set {_uniqueStorage()._negativeIntValue = newValue} } var nestedType: Int32 { - get {return _storage._nestedType} + get {_storage._nestedType} set {_uniqueStorage()._nestedType = newValue} } + var newExtensible: Int32 { + get {_storage._newExtensible} + set {_uniqueStorage()._newExtensible = newValue} + } + var newL: Int32 { - get {return _storage._newL} + get {_storage._newL} set {_uniqueStorage()._newL = newValue} } var newList: Int32 { - get {return _storage._newList} + get {_storage._newList} set {_uniqueStorage()._newList = newValue} } + var newMessage: Int32 { + get {_storage._newMessage} + set {_uniqueStorage()._newMessage = newValue} + } + var newValue: Int32 { - get {return _storage._newValue} + get {_storage._newValue} set {_uniqueStorage()._newValue = newValue} } + var next: Int32 { + get {_storage._next} + set {_uniqueStorage()._next = newValue} + } + var nextByte: Int32 { - get {return _storage._nextByte} + get {_storage._nextByte} set {_uniqueStorage()._nextByte = newValue} } var nextFieldNumber: Int32 { - get {return _storage._nextFieldNumber} + get {_storage._nextFieldNumber} set {_uniqueStorage()._nextFieldNumber = newValue} } + var nextInstruction: Int32 { + get {_storage._nextInstruction} + set {_uniqueStorage()._nextInstruction = newValue} + } + + var nextInt32: Int32 { + get {_storage._nextInt32} + set {_uniqueStorage()._nextInt32 = newValue} + } + + var nextNullTerminatedString: Int32 { + get {_storage._nextNullTerminatedString} + set {_uniqueStorage()._nextNullTerminatedString = newValue} + } + + var nextNullTerminatedStringArray: Int32 { + get {_storage._nextNullTerminatedStringArray} + set {_uniqueStorage()._nextNullTerminatedStringArray = newValue} + } + + var nextNumber: Int32 { + get {_storage._nextNumber} + set {_uniqueStorage()._nextNumber = newValue} + } + + var nextUint64: Int32 { + get {_storage._nextUint64} + set {_uniqueStorage()._nextUint64 = newValue} + } + + var nextVarInt: Int32 { + get {_storage._nextVarInt} + set {_uniqueStorage()._nextVarInt = newValue} + } + var `nil`: Int32 { - get {return _storage._nil} + get {_storage._nil} set {_uniqueStorage()._nil = newValue} } var nilLiteral: Int32 { - get {return _storage._nilLiteral} + get {_storage._nilLiteral} set {_uniqueStorage()._nilLiteral = newValue} } + var noBytesAvailable: Int32 { + get {_storage._noBytesAvailable} + set {_uniqueStorage()._noBytesAvailable = newValue} + } + var noStandardDescriptorAccessor: Int32 { - get {return _storage._noStandardDescriptorAccessor} + get {_storage._noStandardDescriptorAccessor} set {_uniqueStorage()._noStandardDescriptorAccessor = newValue} } var nullValue: Int32 { - get {return _storage._nullValue} + get {_storage._nullValue} set {_uniqueStorage()._nullValue = newValue} } var number: Int32 { - get {return _storage._number} + get {_storage._number} set {_uniqueStorage()._number = newValue} } var numberValue: Int32 { - get {return _storage._numberValue} + get {_storage._numberValue} set {_uniqueStorage()._numberValue = newValue} } var objcClassPrefix: Int32 { - get {return _storage._objcClassPrefix} + get {_storage._objcClassPrefix} set {_uniqueStorage()._objcClassPrefix = newValue} } var of: Int32 { - get {return _storage._of} + get {_storage._of} set {_uniqueStorage()._of = newValue} } + var oneOfKind: Int32 { + get {_storage._oneOfKind} + set {_uniqueStorage()._oneOfKind = newValue} + } + var oneofDecl: Int32 { - get {return _storage._oneofDecl} + get {_storage._oneofDecl} set {_uniqueStorage()._oneofDecl = newValue} } - var oneofDescriptorProto: Int32 { - get {return _storage._oneofDescriptorProto} - set {_uniqueStorage()._oneofDescriptorProto = newValue} - } - var oneofIndex: Int32 { - get {return _storage._oneofIndex} + get {_storage._oneofIndex} set {_uniqueStorage()._oneofIndex = newValue} } - var oneofOptions: Int32 { - get {return _storage._oneofOptions} - set {_uniqueStorage()._oneofOptions = newValue} - } - var oneofs: Int32 { - get {return _storage._oneofs} + get {_storage._oneofs} set {_uniqueStorage()._oneofs = newValue} } - var oneOfKind: Int32 { - get {return _storage._oneOfKind} - set {_uniqueStorage()._oneOfKind = newValue} - } - var optimizeFor: Int32 { - get {return _storage._optimizeFor} + get {_storage._optimizeFor} set {_uniqueStorage()._optimizeFor = newValue} } var optimizeMode: Int32 { - get {return _storage._optimizeMode} + get {_storage._optimizeMode} set {_uniqueStorage()._optimizeMode = newValue} } - var option: Int32 { - get {return _storage._option} - set {_uniqueStorage()._option = newValue} - } - var optionalEnumExtensionField: Int32 { - get {return _storage._optionalEnumExtensionField} + get {_storage._optionalEnumExtensionField} set {_uniqueStorage()._optionalEnumExtensionField = newValue} } var optionalExtensionField: Int32 { - get {return _storage._optionalExtensionField} + get {_storage._optionalExtensionField} set {_uniqueStorage()._optionalExtensionField = newValue} } var optionalGroupExtensionField: Int32 { - get {return _storage._optionalGroupExtensionField} + get {_storage._optionalGroupExtensionField} set {_uniqueStorage()._optionalGroupExtensionField = newValue} } var optionalMessageExtensionField: Int32 { - get {return _storage._optionalMessageExtensionField} + get {_storage._optionalMessageExtensionField} set {_uniqueStorage()._optionalMessageExtensionField = newValue} } + var optionDependency: Int32 { + get {_storage._optionDependency} + set {_uniqueStorage()._optionDependency = newValue} + } + + var optionRetention: Int32 { + get {_storage._optionRetention} + set {_uniqueStorage()._optionRetention = newValue} + } + var options: Int32 { - get {return _storage._options} + get {_storage._options} set {_uniqueStorage()._options = newValue} } + var optionTargetType: Int32 { + get {_storage._optionTargetType} + set {_uniqueStorage()._optionTargetType = newValue} + } + var other: Int32 { - get {return _storage._other} + get {_storage._other} set {_uniqueStorage()._other = newValue} } var others: Int32 { - get {return _storage._others} + get {_storage._others} set {_uniqueStorage()._others = newValue} } var out: Int32 { - get {return _storage._out} + get {_storage._out} set {_uniqueStorage()._out = newValue} } var outputType: Int32 { - get {return _storage._outputType} + get {_storage._outputType} set {_uniqueStorage()._outputType = newValue} } + var overridableFeatures: Int32 { + get {_storage._overridableFeatures} + set {_uniqueStorage()._overridableFeatures = newValue} + } + var p: Int32 { - get {return _storage._p} + get {_storage._p} set {_uniqueStorage()._p = newValue} } var package: Int32 { - get {return _storage._package} + get {_storage._package} set {_uniqueStorage()._package = newValue} } var packed: Int32 { - get {return _storage._packed} + get {_storage._packed} set {_uniqueStorage()._packed = newValue} } var packedEnumExtensionField: Int32 { - get {return _storage._packedEnumExtensionField} + get {_storage._packedEnumExtensionField} set {_uniqueStorage()._packedEnumExtensionField = newValue} } var packedExtensionField: Int32 { - get {return _storage._packedExtensionField} + get {_storage._packedExtensionField} set {_uniqueStorage()._packedExtensionField = newValue} } var padding: Int32 { - get {return _storage._padding} + get {_storage._padding} set {_uniqueStorage()._padding = newValue} } var parent: Int32 { - get {return _storage._parent} + get {_storage._parent} set {_uniqueStorage()._parent = newValue} } var parse: Int32 { - get {return _storage._parse} + get {_storage._parse} set {_uniqueStorage()._parse = newValue} } var partial: Int32 { - get {return _storage._partial} + get {_storage._partial} set {_uniqueStorage()._partial = newValue} } var path: Int32 { - get {return _storage._path} + get {_storage._path} set {_uniqueStorage()._path = newValue} } + var pathDecoder: Int32 { + get {_storage._pathDecoder} + set {_uniqueStorage()._pathDecoder = newValue} + } + + var pathDecodingError: Int32 { + get {_storage._pathDecodingError} + set {_uniqueStorage()._pathDecodingError = newValue} + } + var paths: Int32 { - get {return _storage._paths} + get {_storage._paths} set {_uniqueStorage()._paths = newValue} } + var pathVisitor: Int32 { + get {_storage._pathVisitor} + set {_uniqueStorage()._pathVisitor = newValue} + } + var payload: Int32 { - get {return _storage._payload} + get {_storage._payload} set {_uniqueStorage()._payload = newValue} } var payloadSize: Int32 { - get {return _storage._payloadSize} + get {_storage._payloadSize} set {_uniqueStorage()._payloadSize = newValue} } var phpClassPrefix: Int32 { - get {return _storage._phpClassPrefix} + get {_storage._phpClassPrefix} set {_uniqueStorage()._phpClassPrefix = newValue} } - var phpGenericServices: Int32 { - get {return _storage._phpGenericServices} - set {_uniqueStorage()._phpGenericServices = newValue} - } - var phpMetadataNamespace: Int32 { - get {return _storage._phpMetadataNamespace} + get {_storage._phpMetadataNamespace} set {_uniqueStorage()._phpMetadataNamespace = newValue} } var phpNamespace: Int32 { - get {return _storage._phpNamespace} + get {_storage._phpNamespace} set {_uniqueStorage()._phpNamespace = newValue} } - var pointer: Int32 { - get {return _storage._pointer} - set {_uniqueStorage()._pointer = newValue} - } - var pos: Int32 { - get {return _storage._pos} + get {_storage._pos} set {_uniqueStorage()._pos = newValue} } var positiveIntValue: Int32 { - get {return _storage._positiveIntValue} + get {_storage._positiveIntValue} set {_uniqueStorage()._positiveIntValue = newValue} } var prefix: Int32 { - get {return _storage._prefix} + get {_storage._prefix} set {_uniqueStorage()._prefix = newValue} } var preserveProtoFieldNames: Int32 { - get {return _storage._preserveProtoFieldNames} + get {_storage._preserveProtoFieldNames} set {_uniqueStorage()._preserveProtoFieldNames = newValue} } var preTraverse: Int32 { - get {return _storage._preTraverse} + get {_storage._preTraverse} set {_uniqueStorage()._preTraverse = newValue} } + var previousNumber: Int32 { + get {_storage._previousNumber} + set {_uniqueStorage()._previousNumber = newValue} + } + + var prevPath: Int32 { + get {_storage._prevPath} + set {_uniqueStorage()._prevPath = newValue} + } + var printUnknownFields: Int32 { - get {return _storage._printUnknownFields} + get {_storage._printUnknownFields} set {_uniqueStorage()._printUnknownFields = newValue} } + var programBuffer: Int32 { + get {_storage._programBuffer} + set {_uniqueStorage()._programBuffer = newValue} + } + + var programFormat: Int32 { + get {_storage._programFormat} + set {_uniqueStorage()._programFormat = newValue} + } + var proto2: Int32 { - get {return _storage._proto2} + get {_storage._proto2} set {_uniqueStorage()._proto2 = newValue} } var proto3DefaultValue: Int32 { - get {return _storage._proto3DefaultValue} + get {_storage._proto3DefaultValue} set {_uniqueStorage()._proto3DefaultValue = newValue} } var proto3Optional: Int32 { - get {return _storage._proto3Optional} + get {_storage._proto3Optional} set {_uniqueStorage()._proto3Optional = newValue} } - var protobufApiversionCheck: Int32 { - get {return _storage._protobufApiversionCheck} - set {_uniqueStorage()._protobufApiversionCheck = newValue} + var protobufExtensionFieldValues: Int32 { + get {_storage._protobufExtensionFieldValues} + set {_uniqueStorage()._protobufExtensionFieldValues = newValue} + } + + var protobufFieldNumber: Int32 { + get {_storage._protobufFieldNumber} + set {_uniqueStorage()._protobufFieldNumber = newValue} + } + + var protobufGeneratedIsEqualTo: Int32 { + get {_storage._protobufGeneratedIsEqualTo} + set {_uniqueStorage()._protobufGeneratedIsEqualTo = newValue} + } + + var protobufNameMap: Int32 { + get {_storage._protobufNameMap} + set {_uniqueStorage()._protobufNameMap = newValue} + } + + var protobufNewField: Int32 { + get {_storage._protobufNewField} + set {_uniqueStorage()._protobufNewField = newValue} + } + + var protobufPackage: Int32 { + get {_storage._protobufPackage} + set {_uniqueStorage()._protobufPackage = newValue} } var protobufApiversion2: Int32 { - get {return _storage._protobufApiversion2} + get {_storage._protobufApiversion2} set {_uniqueStorage()._protobufApiversion2 = newValue} } + var protobufApiversionCheck: Int32 { + get {_storage._protobufApiversionCheck} + set {_uniqueStorage()._protobufApiversionCheck = newValue} + } + var protobufBool: Int32 { - get {return _storage._protobufBool} + get {_storage._protobufBool} set {_uniqueStorage()._protobufBool = newValue} } var protobufBytes: Int32 { - get {return _storage._protobufBytes} + get {_storage._protobufBytes} set {_uniqueStorage()._protobufBytes = newValue} } + var protobufData: Int32 { + get {_storage._protobufData} + set {_uniqueStorage()._protobufData = newValue} + } + var protobufDouble: Int32 { - get {return _storage._protobufDouble} + get {_storage._protobufDouble} set {_uniqueStorage()._protobufDouble = newValue} } var protobufEnumMap: Int32 { - get {return _storage._protobufEnumMap} + get {_storage._protobufEnumMap} set {_uniqueStorage()._protobufEnumMap = newValue} } var protobufExtension: Int32 { - get {return _storage._protobufExtension} + get {_storage._protobufExtension} set {_uniqueStorage()._protobufExtension = newValue} } var protobufFixed32: Int32 { - get {return _storage._protobufFixed32} + get {_storage._protobufFixed32} set {_uniqueStorage()._protobufFixed32 = newValue} } var protobufFixed64: Int32 { - get {return _storage._protobufFixed64} + get {_storage._protobufFixed64} set {_uniqueStorage()._protobufFixed64 = newValue} } var protobufFloat: Int32 { - get {return _storage._protobufFloat} + get {_storage._protobufFloat} set {_uniqueStorage()._protobufFloat = newValue} } var protobufInt32: Int32 { - get {return _storage._protobufInt32} + get {_storage._protobufInt32} set {_uniqueStorage()._protobufInt32 = newValue} } var protobufInt64: Int32 { - get {return _storage._protobufInt64} + get {_storage._protobufInt64} set {_uniqueStorage()._protobufInt64 = newValue} } var protobufMap: Int32 { - get {return _storage._protobufMap} + get {_storage._protobufMap} set {_uniqueStorage()._protobufMap = newValue} } var protobufMessageMap: Int32 { - get {return _storage._protobufMessageMap} + get {_storage._protobufMessageMap} set {_uniqueStorage()._protobufMessageMap = newValue} } var protobufSfixed32: Int32 { - get {return _storage._protobufSfixed32} + get {_storage._protobufSfixed32} set {_uniqueStorage()._protobufSfixed32 = newValue} } var protobufSfixed64: Int32 { - get {return _storage._protobufSfixed64} + get {_storage._protobufSfixed64} set {_uniqueStorage()._protobufSfixed64 = newValue} } var protobufSint32: Int32 { - get {return _storage._protobufSint32} + get {_storage._protobufSint32} set {_uniqueStorage()._protobufSint32 = newValue} } var protobufSint64: Int32 { - get {return _storage._protobufSint64} + get {_storage._protobufSint64} set {_uniqueStorage()._protobufSint64 = newValue} } var protobufString: Int32 { - get {return _storage._protobufString} + get {_storage._protobufString} set {_uniqueStorage()._protobufString = newValue} } var protobufUint32: Int32 { - get {return _storage._protobufUint32} + get {_storage._protobufUint32} set {_uniqueStorage()._protobufUint32 = newValue} } var protobufUint64: Int32 { - get {return _storage._protobufUint64} + get {_storage._protobufUint64} set {_uniqueStorage()._protobufUint64 = newValue} } - var protobufExtensionFieldValues: Int32 { - get {return _storage._protobufExtensionFieldValues} - set {_uniqueStorage()._protobufExtensionFieldValues = newValue} - } - - var protobufFieldNumber: Int32 { - get {return _storage._protobufFieldNumber} - set {_uniqueStorage()._protobufFieldNumber = newValue} - } - - var protobufGeneratedIsEqualTo: Int32 { - get {return _storage._protobufGeneratedIsEqualTo} - set {_uniqueStorage()._protobufGeneratedIsEqualTo = newValue} - } - - var protobufNameMap: Int32 { - get {return _storage._protobufNameMap} - set {_uniqueStorage()._protobufNameMap = newValue} - } - - var protobufNewField: Int32 { - get {return _storage._protobufNewField} - set {_uniqueStorage()._protobufNewField = newValue} - } - - var protobufPackage: Int32 { - get {return _storage._protobufPackage} - set {_uniqueStorage()._protobufPackage = newValue} - } - var `protocol`: Int32 { - get {return _storage._protocol} + get {_storage._protocol} set {_uniqueStorage()._protocol = newValue} } var protoFieldName: Int32 { - get {return _storage._protoFieldName} + get {_storage._protoFieldName} set {_uniqueStorage()._protoFieldName = newValue} } var protoMessageName: Int32 { - get {return _storage._protoMessageName} + get {_storage._protoMessageName} set {_uniqueStorage()._protoMessageName = newValue} } var protoNameProviding: Int32 { - get {return _storage._protoNameProviding} + get {_storage._protoNameProviding} set {_uniqueStorage()._protoNameProviding = newValue} } var protoPaths: Int32 { - get {return _storage._protoPaths} + get {_storage._protoPaths} set {_uniqueStorage()._protoPaths = newValue} } var `public`: Int32 { - get {return _storage._public} + get {_storage._public} set {_uniqueStorage()._public = newValue} } var publicDependency: Int32 { - get {return _storage._publicDependency} + get {_storage._publicDependency} set {_uniqueStorage()._publicDependency = newValue} } var putBoolValue: Int32 { - get {return _storage._putBoolValue} + get {_storage._putBoolValue} set {_uniqueStorage()._putBoolValue = newValue} } var putBytesValue: Int32 { - get {return _storage._putBytesValue} + get {_storage._putBytesValue} set {_uniqueStorage()._putBytesValue = newValue} } var putDoubleValue: Int32 { - get {return _storage._putDoubleValue} + get {_storage._putDoubleValue} set {_uniqueStorage()._putDoubleValue = newValue} } var putEnumValue: Int32 { - get {return _storage._putEnumValue} + get {_storage._putEnumValue} set {_uniqueStorage()._putEnumValue = newValue} } var putFixedUint32: Int32 { - get {return _storage._putFixedUint32} + get {_storage._putFixedUint32} set {_uniqueStorage()._putFixedUint32 = newValue} } var putFixedUint64: Int32 { - get {return _storage._putFixedUint64} + get {_storage._putFixedUint64} set {_uniqueStorage()._putFixedUint64 = newValue} } var putFloatValue: Int32 { - get {return _storage._putFloatValue} + get {_storage._putFloatValue} set {_uniqueStorage()._putFloatValue = newValue} } var putInt64: Int32 { - get {return _storage._putInt64} + get {_storage._putInt64} set {_uniqueStorage()._putInt64 = newValue} } var putStringValue: Int32 { - get {return _storage._putStringValue} + get {_storage._putStringValue} set {_uniqueStorage()._putStringValue = newValue} } var putUint64: Int32 { - get {return _storage._putUint64} + get {_storage._putUint64} set {_uniqueStorage()._putUint64 = newValue} } var putUint64Hex: Int32 { - get {return _storage._putUint64Hex} + get {_storage._putUint64Hex} set {_uniqueStorage()._putUint64Hex = newValue} } var putVarInt: Int32 { - get {return _storage._putVarInt} + get {_storage._putVarInt} set {_uniqueStorage()._putVarInt = newValue} } var putZigZagVarInt: Int32 { - get {return _storage._putZigZagVarInt} + get {_storage._putZigZagVarInt} set {_uniqueStorage()._putZigZagVarInt = newValue} } var pyGenericServices: Int32 { - get {return _storage._pyGenericServices} + get {_storage._pyGenericServices} set {_uniqueStorage()._pyGenericServices = newValue} } + var r: Int32 { + get {_storage._r} + set {_uniqueStorage()._r = newValue} + } + var rawChars: Int32 { - get {return _storage._rawChars} + get {_storage._rawChars} set {_uniqueStorage()._rawChars = newValue} } var rawRepresentable: Int32 { - get {return _storage._rawRepresentable} + get {_storage._rawRepresentable} set {_uniqueStorage()._rawRepresentable = newValue} } var rawValue: Int32 { - get {return _storage._rawValue} + get {_storage._rawValue} set {_uniqueStorage()._rawValue = newValue} } var read4HexDigits: Int32 { - get {return _storage._read4HexDigits} + get {_storage._read4HexDigits} set {_uniqueStorage()._read4HexDigits = newValue} } + var readBytes: Int32 { + get {_storage._readBytes} + set {_uniqueStorage()._readBytes = newValue} + } + + var reader: Int32 { + get {_storage._reader} + set {_uniqueStorage()._reader = newValue} + } + var register: Int32 { - get {return _storage._register} + get {_storage._register} set {_uniqueStorage()._register = newValue} } + var remainingProgram: Int32 { + get {_storage._remainingProgram} + set {_uniqueStorage()._remainingProgram = newValue} + } + + var removalError: Int32 { + get {_storage._removalError} + set {_uniqueStorage()._removalError = newValue} + } + + var removingAllFieldsOf: Int32 { + get {_storage._removingAllFieldsOf} + set {_uniqueStorage()._removingAllFieldsOf = newValue} + } + + var repeated: Int32 { + get {_storage._repeated} + set {_uniqueStorage()._repeated = newValue} + } + var repeatedEnumExtensionField: Int32 { - get {return _storage._repeatedEnumExtensionField} + get {_storage._repeatedEnumExtensionField} set {_uniqueStorage()._repeatedEnumExtensionField = newValue} } var repeatedExtensionField: Int32 { - get {return _storage._repeatedExtensionField} + get {_storage._repeatedExtensionField} set {_uniqueStorage()._repeatedExtensionField = newValue} } + var repeatedFieldEncoding: Int32 { + get {_storage._repeatedFieldEncoding} + set {_uniqueStorage()._repeatedFieldEncoding = newValue} + } + var repeatedGroupExtensionField: Int32 { - get {return _storage._repeatedGroupExtensionField} + get {_storage._repeatedGroupExtensionField} set {_uniqueStorage()._repeatedGroupExtensionField = newValue} } var repeatedMessageExtensionField: Int32 { - get {return _storage._repeatedMessageExtensionField} + get {_storage._repeatedMessageExtensionField} set {_uniqueStorage()._repeatedMessageExtensionField = newValue} } + var repeating: Int32 { + get {_storage._repeating} + set {_uniqueStorage()._repeating = newValue} + } + + var replaceRepeatedFields: Int32 { + get {_storage._replaceRepeatedFields} + set {_uniqueStorage()._replaceRepeatedFields = newValue} + } + var requestStreaming: Int32 { - get {return _storage._requestStreaming} + get {_storage._requestStreaming} set {_uniqueStorage()._requestStreaming = newValue} } var requestTypeURL: Int32 { - get {return _storage._requestTypeURL} + get {_storage._requestTypeURL} set {_uniqueStorage()._requestTypeURL = newValue} } var requiredSize: Int32 { - get {return _storage._requiredSize} + get {_storage._requiredSize} set {_uniqueStorage()._requiredSize = newValue} } - var reservedName: Int32 { - get {return _storage._reservedName} - set {_uniqueStorage()._reservedName = newValue} - } - - var reservedRange: Int32 { - get {return _storage._reservedRange} - set {_uniqueStorage()._reservedRange = newValue} - } - var responseStreaming: Int32 { - get {return _storage._responseStreaming} + get {_storage._responseStreaming} set {_uniqueStorage()._responseStreaming = newValue} } var responseTypeURL: Int32 { - get {return _storage._responseTypeURL} + get {_storage._responseTypeURL} set {_uniqueStorage()._responseTypeURL = newValue} } var result: Int32 { - get {return _storage._result} + get {_storage._result} set {_uniqueStorage()._result = newValue} } - var `rethrows`: Int32 { - get {return _storage._rethrows} - set {_uniqueStorage()._rethrows = newValue} + var retention: Int32 { + get {_storage._retention} + set {_uniqueStorage()._retention = newValue} } - var `return`: Int32 { - get {return _storage._return} - set {_uniqueStorage()._return = newValue} + var `rethrows`: Int32 { + get {_storage._rethrows} + set {_uniqueStorage()._rethrows = newValue} } var returnType: Int32 { - get {return _storage._returnType} + get {_storage._returnType} set {_uniqueStorage()._returnType = newValue} } var revision: Int32 { - get {return _storage._revision} + get {_storage._revision} set {_uniqueStorage()._revision = newValue} } var rhs: Int32 { - get {return _storage._rhs} + get {_storage._rhs} set {_uniqueStorage()._rhs = newValue} } var root: Int32 { - get {return _storage._root} + get {_storage._root} set {_uniqueStorage()._root = newValue} } var rubyPackage: Int32 { - get {return _storage._rubyPackage} + get {_storage._rubyPackage} set {_uniqueStorage()._rubyPackage = newValue} } var s: Int32 { - get {return _storage._s} + get {_storage._s} set {_uniqueStorage()._s = newValue} } var sawBackslash: Int32 { - get {return _storage._sawBackslash} + get {_storage._sawBackslash} set {_uniqueStorage()._sawBackslash = newValue} } var sawSection4Characters: Int32 { - get {return _storage._sawSection4Characters} + get {_storage._sawSection4Characters} set {_uniqueStorage()._sawSection4Characters = newValue} } var sawSection5Characters: Int32 { - get {return _storage._sawSection5Characters} + get {_storage._sawSection5Characters} set {_uniqueStorage()._sawSection5Characters = newValue} } + var scalar: Int32 { + get {_storage._scalar} + set {_uniqueStorage()._scalar = newValue} + } + + var scan: Int32 { + get {_storage._scan} + set {_uniqueStorage()._scan = newValue} + } + var scanner: Int32 { - get {return _storage._scanner} + get {_storage._scanner} set {_uniqueStorage()._scanner = newValue} } var seconds: Int32 { - get {return _storage._seconds} + get {_storage._seconds} set {_uniqueStorage()._seconds = newValue} } var self_p: Int32 { - get {return _storage._self_p} + get {_storage._self_p} set {_uniqueStorage()._self_p = newValue} } + var semantic: Int32 { + get {_storage._semantic} + set {_uniqueStorage()._semantic = newValue} + } + + var sendable: Int32 { + get {_storage._sendable} + set {_uniqueStorage()._sendable = newValue} + } + var separator: Int32 { - get {return _storage._separator} + get {_storage._separator} set {_uniqueStorage()._separator = newValue} } var serialize: Int32 { - get {return _storage._serialize} + get {_storage._serialize} set {_uniqueStorage()._serialize = newValue} } + var serializedBytes: Int32 { + get {_storage._serializedBytes} + set {_uniqueStorage()._serializedBytes = newValue} + } + var serializedData: Int32 { - get {return _storage._serializedData} + get {_storage._serializedData} set {_uniqueStorage()._serializedData = newValue} } var serializedSize: Int32 { - get {return _storage._serializedSize} + get {_storage._serializedSize} set {_uniqueStorage()._serializedSize = newValue} } var serverStreaming: Int32 { - get {return _storage._serverStreaming} + get {_storage._serverStreaming} set {_uniqueStorage()._serverStreaming = newValue} } var service: Int32 { - get {return _storage._service} + get {_storage._service} set {_uniqueStorage()._service = newValue} } - var serviceDescriptorProto: Int32 { - get {return _storage._serviceDescriptorProto} - set {_uniqueStorage()._serviceDescriptorProto = newValue} - } - - var serviceOptions: Int32 { - get {return _storage._serviceOptions} - set {_uniqueStorage()._serviceOptions = newValue} - } - var set: Int32 { - get {return _storage._set} + get {_storage._set} set {_uniqueStorage()._set = newValue} } var setExtensionValue: Int32 { - get {return _storage._setExtensionValue} + get {_storage._setExtensionValue} set {_uniqueStorage()._setExtensionValue = newValue} } var shift: Int32 { - get {return _storage._shift} + get {_storage._shift} set {_uniqueStorage()._shift = newValue} } var simpleExtensionMap: Int32 { - get {return _storage._simpleExtensionMap} + get {_storage._simpleExtensionMap} set {_uniqueStorage()._simpleExtensionMap = newValue} } + var size: Int32 { + get {_storage._size} + set {_uniqueStorage()._size = newValue} + } + var sizer: Int32 { - get {return _storage._sizer} + get {_storage._sizer} set {_uniqueStorage()._sizer = newValue} } var source: Int32 { - get {return _storage._source} + get {_storage._source} set {_uniqueStorage()._source = newValue} } var sourceCodeInfo: Int32 { - get {return _storage._sourceCodeInfo} + get {_storage._sourceCodeInfo} set {_uniqueStorage()._sourceCodeInfo = newValue} } var sourceContext: Int32 { - get {return _storage._sourceContext} + get {_storage._sourceContext} set {_uniqueStorage()._sourceContext = newValue} } var sourceEncoding: Int32 { - get {return _storage._sourceEncoding} + get {_storage._sourceEncoding} set {_uniqueStorage()._sourceEncoding = newValue} } var sourceFile: Int32 { - get {return _storage._sourceFile} + get {_storage._sourceFile} set {_uniqueStorage()._sourceFile = newValue} } + var sourceLocation: Int32 { + get {_storage._sourceLocation} + set {_uniqueStorage()._sourceLocation = newValue} + } + var span: Int32 { - get {return _storage._span} + get {_storage._span} set {_uniqueStorage()._span = newValue} } var split: Int32 { - get {return _storage._split} + get {_storage._split} set {_uniqueStorage()._split = newValue} } var start: Int32 { - get {return _storage._start} + get {_storage._start} set {_uniqueStorage()._start = newValue} } var startArray: Int32 { - get {return _storage._startArray} + get {_storage._startArray} set {_uniqueStorage()._startArray = newValue} } var startArrayObject: Int32 { - get {return _storage._startArrayObject} + get {_storage._startArrayObject} set {_uniqueStorage()._startArrayObject = newValue} } var startField: Int32 { - get {return _storage._startField} + get {_storage._startField} set {_uniqueStorage()._startField = newValue} } var startIndex: Int32 { - get {return _storage._startIndex} + get {_storage._startIndex} set {_uniqueStorage()._startIndex = newValue} } var startMessageField: Int32 { - get {return _storage._startMessageField} + get {_storage._startMessageField} set {_uniqueStorage()._startMessageField = newValue} } var startObject: Int32 { - get {return _storage._startObject} + get {_storage._startObject} set {_uniqueStorage()._startObject = newValue} } var startRegularField: Int32 { - get {return _storage._startRegularField} + get {_storage._startRegularField} set {_uniqueStorage()._startRegularField = newValue} } var state: Int32 { - get {return _storage._state} + get {_storage._state} set {_uniqueStorage()._state = newValue} } var `static`: Int32 { - get {return _storage._static} + get {_storage._static} set {_uniqueStorage()._static = newValue} } var staticString: Int32 { - get {return _storage._staticString} + get {_storage._staticString} set {_uniqueStorage()._staticString = newValue} } var storage: Int32 { - get {return _storage._storage} + get {_storage._storage} set {_uniqueStorage()._storage = newValue} } var string: Int32 { - get {return _storage._string} + get {_storage._string} set {_uniqueStorage()._string = newValue} } var stringLiteral: Int32 { - get {return _storage._stringLiteral} + get {_storage._stringLiteral} set {_uniqueStorage()._stringLiteral = newValue} } var stringLiteralType: Int32 { - get {return _storage._stringLiteralType} + get {_storage._stringLiteralType} set {_uniqueStorage()._stringLiteralType = newValue} } var stringResult: Int32 { - get {return _storage._stringResult} + get {_storage._stringResult} set {_uniqueStorage()._stringResult = newValue} } var stringValue: Int32 { - get {return _storage._stringValue} + get {_storage._stringValue} set {_uniqueStorage()._stringValue = newValue} } var `struct`: Int32 { - get {return _storage._struct} + get {_storage._struct} set {_uniqueStorage()._struct = newValue} } var structValue: Int32 { - get {return _storage._structValue} + get {_storage._structValue} set {_uniqueStorage()._structValue = newValue} } var subDecoder: Int32 { - get {return _storage._subDecoder} + get {_storage._subDecoder} set {_uniqueStorage()._subDecoder = newValue} } var `subscript`: Int32 { - get {return _storage._subscript} + get {_storage._subscript} set {_uniqueStorage()._subscript = newValue} } + var subtract: Int32 { + get {_storage._subtract} + set {_uniqueStorage()._subtract = newValue} + } + var subVisitor: Int32 { - get {return _storage._subVisitor} + get {_storage._subVisitor} set {_uniqueStorage()._subVisitor = newValue} } var swift: Int32 { - get {return _storage._swift} + get {_storage._swift} set {_uniqueStorage()._swift = newValue} } var swiftPrefix: Int32 { - get {return _storage._swiftPrefix} + get {_storage._swiftPrefix} set {_uniqueStorage()._swiftPrefix = newValue} } - var swiftProtobuf: Int32 { - get {return _storage._swiftProtobuf} - set {_uniqueStorage()._swiftProtobuf = newValue} + var swiftProtobufContiguousBytes: Int32 { + get {_storage._swiftProtobufContiguousBytes} + set {_uniqueStorage()._swiftProtobufContiguousBytes = newValue} + } + + var swiftProtobufError: Int32 { + get {_storage._swiftProtobufError} + set {_uniqueStorage()._swiftProtobufError = newValue} } var syntax: Int32 { - get {return _storage._syntax} + get {_storage._syntax} set {_uniqueStorage()._syntax = newValue} } var t: Int32 { - get {return _storage._t} + get {_storage._t} set {_uniqueStorage()._t = newValue} } var tag: Int32 { - get {return _storage._tag} + get {_storage._tag} set {_uniqueStorage()._tag = newValue} } + var targets: Int32 { + get {_storage._targets} + set {_uniqueStorage()._targets = newValue} + } + var terminator: Int32 { - get {return _storage._terminator} + get {_storage._terminator} set {_uniqueStorage()._terminator = newValue} } var testDecoder: Int32 { - get {return _storage._testDecoder} + get {_storage._testDecoder} set {_uniqueStorage()._testDecoder = newValue} } var text: Int32 { - get {return _storage._text} + get {_storage._text} set {_uniqueStorage()._text = newValue} } var textDecoder: Int32 { - get {return _storage._textDecoder} + get {_storage._textDecoder} set {_uniqueStorage()._textDecoder = newValue} } var textFormatDecoder: Int32 { - get {return _storage._textFormatDecoder} + get {_storage._textFormatDecoder} set {_uniqueStorage()._textFormatDecoder = newValue} } var textFormatDecodingError: Int32 { - get {return _storage._textFormatDecodingError} + get {_storage._textFormatDecodingError} set {_uniqueStorage()._textFormatDecodingError = newValue} } var textFormatDecodingOptions: Int32 { - get {return _storage._textFormatDecodingOptions} + get {_storage._textFormatDecodingOptions} set {_uniqueStorage()._textFormatDecodingOptions = newValue} } var textFormatEncodingOptions: Int32 { - get {return _storage._textFormatEncodingOptions} + get {_storage._textFormatEncodingOptions} set {_uniqueStorage()._textFormatEncodingOptions = newValue} } var textFormatEncodingVisitor: Int32 { - get {return _storage._textFormatEncodingVisitor} + get {_storage._textFormatEncodingVisitor} set {_uniqueStorage()._textFormatEncodingVisitor = newValue} } var textFormatString: Int32 { - get {return _storage._textFormatString} + get {_storage._textFormatString} set {_uniqueStorage()._textFormatString = newValue} } + var throwOrIgnore: Int32 { + get {_storage._throwOrIgnore} + set {_uniqueStorage()._throwOrIgnore = newValue} + } + var `throws`: Int32 { - get {return _storage._throws} + get {_storage._throws} set {_uniqueStorage()._throws = newValue} } var timeInterval: Int32 { - get {return _storage._timeInterval} + get {_storage._timeInterval} set {_uniqueStorage()._timeInterval = newValue} } var timeIntervalSince1970: Int32 { - get {return _storage._timeIntervalSince1970} + get {_storage._timeIntervalSince1970} set {_uniqueStorage()._timeIntervalSince1970 = newValue} } var timeIntervalSinceReferenceDate: Int32 { - get {return _storage._timeIntervalSinceReferenceDate} + get {_storage._timeIntervalSinceReferenceDate} set {_uniqueStorage()._timeIntervalSinceReferenceDate = newValue} } - var timestamp: Int32 { - get {return _storage._timestamp} - set {_uniqueStorage()._timestamp = newValue} + var tmp: Int32 { + get {_storage._tmp} + set {_uniqueStorage()._tmp = newValue} + } + + var tooLarge: Int32 { + get {_storage._tooLarge} + set {_uniqueStorage()._tooLarge = newValue} } var total: Int32 { - get {return _storage._total} + get {_storage._total} set {_uniqueStorage()._total = newValue} } var totalArrayDepth: Int32 { - get {return _storage._totalArrayDepth} + get {_storage._totalArrayDepth} set {_uniqueStorage()._totalArrayDepth = newValue} } var totalSize: Int32 { - get {return _storage._totalSize} + get {_storage._totalSize} set {_uniqueStorage()._totalSize = newValue} } var trailingComments: Int32 { - get {return _storage._trailingComments} + get {_storage._trailingComments} set {_uniqueStorage()._trailingComments = newValue} } var traverse: Int32 { - get {return _storage._traverse} + get {_storage._traverse} set {_uniqueStorage()._traverse = newValue} } + var trim: Int32 { + get {_storage._trim} + set {_uniqueStorage()._trim = newValue} + } + var `true`: Int32 { - get {return _storage._true} + get {_storage._true} set {_uniqueStorage()._true = newValue} } var `try`: Int32 { - get {return _storage._try} + get {_storage._try} set {_uniqueStorage()._try = newValue} } var type: Int32 { - get {return _storage._type} + get {_storage._type} set {_uniqueStorage()._type = newValue} } var `typealias`: Int32 { - get {return _storage._typealias} + get {_storage._typealias} set {_uniqueStorage()._typealias = newValue} } var typeEnum: Int32 { - get {return _storage._typeEnum} + get {_storage._typeEnum} set {_uniqueStorage()._typeEnum = newValue} } var typeName: Int32 { - get {return _storage._typeName} + get {_storage._typeName} set {_uniqueStorage()._typeName = newValue} } var typePrefix: Int32 { - get {return _storage._typePrefix} + get {_storage._typePrefix} set {_uniqueStorage()._typePrefix = newValue} } var typeStart: Int32 { - get {return _storage._typeStart} + get {_storage._typeStart} set {_uniqueStorage()._typeStart = newValue} } var typeUnknown: Int32 { - get {return _storage._typeUnknown} + get {_storage._typeUnknown} set {_uniqueStorage()._typeUnknown = newValue} } var typeURL: Int32 { - get {return _storage._typeURL} + get {_storage._typeURL} set {_uniqueStorage()._typeURL = newValue} } var uint32: Int32 { - get {return _storage._uint32} + get {_storage._uint32} set {_uniqueStorage()._uint32 = newValue} } - var uint32Value: Int32 { - get {return _storage._uint32Value} - set {_uniqueStorage()._uint32Value = newValue} - } - var uint64: Int32 { - get {return _storage._uint64} + get {_storage._uint64} set {_uniqueStorage()._uint64 = newValue} } - var uint64Value: Int32 { - get {return _storage._uint64Value} - set {_uniqueStorage()._uint64Value = newValue} - } - var uint8: Int32 { - get {return _storage._uint8} + get {_storage._uint8} set {_uniqueStorage()._uint8 = newValue} } + var unchecked: Int32 { + get {_storage._unchecked} + set {_uniqueStorage()._unchecked = newValue} + } + + var unicode: Int32 { + get {_storage._unicode} + set {_uniqueStorage()._unicode = newValue} + } + var unicodeScalarLiteral: Int32 { - get {return _storage._unicodeScalarLiteral} + get {_storage._unicodeScalarLiteral} set {_uniqueStorage()._unicodeScalarLiteral = newValue} } var unicodeScalarLiteralType: Int32 { - get {return _storage._unicodeScalarLiteralType} + get {_storage._unicodeScalarLiteralType} set {_uniqueStorage()._unicodeScalarLiteralType = newValue} } var unicodeScalars: Int32 { - get {return _storage._unicodeScalars} + get {_storage._unicodeScalars} set {_uniqueStorage()._unicodeScalars = newValue} } var unicodeScalarView: Int32 { - get {return _storage._unicodeScalarView} + get {_storage._unicodeScalarView} set {_uniqueStorage()._unicodeScalarView = newValue} } var uninterpretedOption: Int32 { - get {return _storage._uninterpretedOption} + get {_storage._uninterpretedOption} set {_uniqueStorage()._uninterpretedOption = newValue} } var union: Int32 { - get {return _storage._union} + get {_storage._union} set {_uniqueStorage()._union = newValue} } var uniqueStorage: Int32 { - get {return _storage._uniqueStorage} + get {_storage._uniqueStorage} set {_uniqueStorage()._uniqueStorage = newValue} } var unknown: Int32 { - get {return _storage._unknown} + get {_storage._unknown} set {_uniqueStorage()._unknown = newValue} } var unknownFields_p: Int32 { - get {return _storage._unknownFields_p} + get {_storage._unknownFields_p} set {_uniqueStorage()._unknownFields_p = newValue} } var unknownStorage: Int32 { - get {return _storage._unknownStorage} + get {_storage._unknownStorage} set {_uniqueStorage()._unknownStorage = newValue} } var unpackTo: Int32 { - get {return _storage._unpackTo} + get {_storage._unpackTo} set {_uniqueStorage()._unpackTo = newValue} } var unsafeBufferPointer: Int32 { - get {return _storage._unsafeBufferPointer} + get {_storage._unsafeBufferPointer} set {_uniqueStorage()._unsafeBufferPointer = newValue} } var unsafeMutablePointer: Int32 { - get {return _storage._unsafeMutablePointer} + get {_storage._unsafeMutablePointer} set {_uniqueStorage()._unsafeMutablePointer = newValue} } var unsafeMutableRawBufferPointer: Int32 { - get {return _storage._unsafeMutableRawBufferPointer} + get {_storage._unsafeMutableRawBufferPointer} set {_uniqueStorage()._unsafeMutableRawBufferPointer = newValue} } - var unsafeMutableRawPointer: Int32 { - get {return _storage._unsafeMutableRawPointer} - set {_uniqueStorage()._unsafeMutableRawPointer = newValue} - } - var unsafeRawBufferPointer: Int32 { - get {return _storage._unsafeRawBufferPointer} + get {_storage._unsafeRawBufferPointer} set {_uniqueStorage()._unsafeRawBufferPointer = newValue} } var unsafeRawPointer: Int32 { - get {return _storage._unsafeRawPointer} + get {_storage._unsafeRawPointer} set {_uniqueStorage()._unsafeRawPointer = newValue} } + var unverifiedLazy: Int32 { + get {_storage._unverifiedLazy} + set {_uniqueStorage()._unverifiedLazy = newValue} + } + var updatedOptions: Int32 { - get {return _storage._updatedOptions} + get {_storage._updatedOptions} set {_uniqueStorage()._updatedOptions = newValue} } + var uppercasedAssumingAscii: Int32 { + get {_storage._uppercasedAssumingAscii} + set {_uniqueStorage()._uppercasedAssumingAscii = newValue} + } + var url: Int32 { - get {return _storage._url} + get {_storage._url} set {_uniqueStorage()._url = newValue} } + var useDeterministicOrdering: Int32 { + get {_storage._useDeterministicOrdering} + set {_uniqueStorage()._useDeterministicOrdering = newValue} + } + var utf8: Int32 { - get {return _storage._utf8} + get {_storage._utf8} set {_uniqueStorage()._utf8 = newValue} } var utf8Ptr: Int32 { - get {return _storage._utf8Ptr} + get {_storage._utf8Ptr} set {_uniqueStorage()._utf8Ptr = newValue} } var utf8ToDouble: Int32 { - get {return _storage._utf8ToDouble} + get {_storage._utf8ToDouble} set {_uniqueStorage()._utf8ToDouble = newValue} } + var utf8Validation: Int32 { + get {_storage._utf8Validation} + set {_uniqueStorage()._utf8Validation = newValue} + } + var utf8View: Int32 { - get {return _storage._utf8View} + get {_storage._utf8View} set {_uniqueStorage()._utf8View = newValue} } var v: Int32 { - get {return _storage._v} + get {_storage._v} set {_uniqueStorage()._v = newValue} } var value: Int32 { - get {return _storage._value} + get {_storage._value} set {_uniqueStorage()._value = newValue} } var valueField: Int32 { - get {return _storage._valueField} + get {_storage._valueField} set {_uniqueStorage()._valueField = newValue} } var values: Int32 { - get {return _storage._values} + get {_storage._values} set {_uniqueStorage()._values = newValue} } var valueType: Int32 { - get {return _storage._valueType} + get {_storage._valueType} set {_uniqueStorage()._valueType = newValue} } var `var`: Int32 { - get {return _storage._var} + get {_storage._var} set {_uniqueStorage()._var = newValue} } + var verification: Int32 { + get {_storage._verification} + set {_uniqueStorage()._verification = newValue} + } + + var verificationState: Int32 { + get {_storage._verificationState} + set {_uniqueStorage()._verificationState = newValue} + } + var version: Int32 { - get {return _storage._version} + get {_storage._version} set {_uniqueStorage()._version = newValue} } var versionString: Int32 { - get {return _storage._versionString} + get {_storage._versionString} set {_uniqueStorage()._versionString = newValue} } + var visibility: Int32 { + get {_storage._visibility} + set {_uniqueStorage()._visibility = newValue} + } + + var visibilityFeature: Int32 { + get {_storage._visibilityFeature} + set {_uniqueStorage()._visibilityFeature = newValue} + } + var visitExtensionFields: Int32 { - get {return _storage._visitExtensionFields} + get {_storage._visitExtensionFields} set {_uniqueStorage()._visitExtensionFields = newValue} } var visitExtensionFieldsAsMessageSet: Int32 { - get {return _storage._visitExtensionFieldsAsMessageSet} + get {_storage._visitExtensionFieldsAsMessageSet} set {_uniqueStorage()._visitExtensionFieldsAsMessageSet = newValue} } var visitMapField: Int32 { - get {return _storage._visitMapField} + get {_storage._visitMapField} set {_uniqueStorage()._visitMapField = newValue} } var visitor: Int32 { - get {return _storage._visitor} + get {_storage._visitor} set {_uniqueStorage()._visitor = newValue} } var visitPacked: Int32 { - get {return _storage._visitPacked} + get {_storage._visitPacked} set {_uniqueStorage()._visitPacked = newValue} } var visitPackedBoolField: Int32 { - get {return _storage._visitPackedBoolField} + get {_storage._visitPackedBoolField} set {_uniqueStorage()._visitPackedBoolField = newValue} } var visitPackedDoubleField: Int32 { - get {return _storage._visitPackedDoubleField} + get {_storage._visitPackedDoubleField} set {_uniqueStorage()._visitPackedDoubleField = newValue} } var visitPackedEnumField: Int32 { - get {return _storage._visitPackedEnumField} + get {_storage._visitPackedEnumField} set {_uniqueStorage()._visitPackedEnumField = newValue} } var visitPackedFixed32Field: Int32 { - get {return _storage._visitPackedFixed32Field} + get {_storage._visitPackedFixed32Field} set {_uniqueStorage()._visitPackedFixed32Field = newValue} } var visitPackedFixed64Field: Int32 { - get {return _storage._visitPackedFixed64Field} + get {_storage._visitPackedFixed64Field} set {_uniqueStorage()._visitPackedFixed64Field = newValue} } var visitPackedFloatField: Int32 { - get {return _storage._visitPackedFloatField} + get {_storage._visitPackedFloatField} set {_uniqueStorage()._visitPackedFloatField = newValue} } var visitPackedInt32Field: Int32 { - get {return _storage._visitPackedInt32Field} + get {_storage._visitPackedInt32Field} set {_uniqueStorage()._visitPackedInt32Field = newValue} } var visitPackedInt64Field: Int32 { - get {return _storage._visitPackedInt64Field} + get {_storage._visitPackedInt64Field} set {_uniqueStorage()._visitPackedInt64Field = newValue} } var visitPackedSfixed32Field: Int32 { - get {return _storage._visitPackedSfixed32Field} + get {_storage._visitPackedSfixed32Field} set {_uniqueStorage()._visitPackedSfixed32Field = newValue} } var visitPackedSfixed64Field: Int32 { - get {return _storage._visitPackedSfixed64Field} + get {_storage._visitPackedSfixed64Field} set {_uniqueStorage()._visitPackedSfixed64Field = newValue} } var visitPackedSint32Field: Int32 { - get {return _storage._visitPackedSint32Field} + get {_storage._visitPackedSint32Field} set {_uniqueStorage()._visitPackedSint32Field = newValue} } var visitPackedSint64Field: Int32 { - get {return _storage._visitPackedSint64Field} + get {_storage._visitPackedSint64Field} set {_uniqueStorage()._visitPackedSint64Field = newValue} } var visitPackedUint32Field: Int32 { - get {return _storage._visitPackedUint32Field} + get {_storage._visitPackedUint32Field} set {_uniqueStorage()._visitPackedUint32Field = newValue} } var visitPackedUint64Field: Int32 { - get {return _storage._visitPackedUint64Field} + get {_storage._visitPackedUint64Field} set {_uniqueStorage()._visitPackedUint64Field = newValue} } var visitRepeated: Int32 { - get {return _storage._visitRepeated} + get {_storage._visitRepeated} set {_uniqueStorage()._visitRepeated = newValue} } var visitRepeatedBoolField: Int32 { - get {return _storage._visitRepeatedBoolField} + get {_storage._visitRepeatedBoolField} set {_uniqueStorage()._visitRepeatedBoolField = newValue} } var visitRepeatedBytesField: Int32 { - get {return _storage._visitRepeatedBytesField} + get {_storage._visitRepeatedBytesField} set {_uniqueStorage()._visitRepeatedBytesField = newValue} } var visitRepeatedDoubleField: Int32 { - get {return _storage._visitRepeatedDoubleField} + get {_storage._visitRepeatedDoubleField} set {_uniqueStorage()._visitRepeatedDoubleField = newValue} } var visitRepeatedEnumField: Int32 { - get {return _storage._visitRepeatedEnumField} + get {_storage._visitRepeatedEnumField} set {_uniqueStorage()._visitRepeatedEnumField = newValue} } var visitRepeatedFixed32Field: Int32 { - get {return _storage._visitRepeatedFixed32Field} + get {_storage._visitRepeatedFixed32Field} set {_uniqueStorage()._visitRepeatedFixed32Field = newValue} } var visitRepeatedFixed64Field: Int32 { - get {return _storage._visitRepeatedFixed64Field} + get {_storage._visitRepeatedFixed64Field} set {_uniqueStorage()._visitRepeatedFixed64Field = newValue} } var visitRepeatedFloatField: Int32 { - get {return _storage._visitRepeatedFloatField} + get {_storage._visitRepeatedFloatField} set {_uniqueStorage()._visitRepeatedFloatField = newValue} } var visitRepeatedGroupField: Int32 { - get {return _storage._visitRepeatedGroupField} + get {_storage._visitRepeatedGroupField} set {_uniqueStorage()._visitRepeatedGroupField = newValue} } var visitRepeatedInt32Field: Int32 { - get {return _storage._visitRepeatedInt32Field} + get {_storage._visitRepeatedInt32Field} set {_uniqueStorage()._visitRepeatedInt32Field = newValue} } var visitRepeatedInt64Field: Int32 { - get {return _storage._visitRepeatedInt64Field} + get {_storage._visitRepeatedInt64Field} set {_uniqueStorage()._visitRepeatedInt64Field = newValue} } var visitRepeatedMessageField: Int32 { - get {return _storage._visitRepeatedMessageField} + get {_storage._visitRepeatedMessageField} set {_uniqueStorage()._visitRepeatedMessageField = newValue} } var visitRepeatedSfixed32Field: Int32 { - get {return _storage._visitRepeatedSfixed32Field} + get {_storage._visitRepeatedSfixed32Field} set {_uniqueStorage()._visitRepeatedSfixed32Field = newValue} } var visitRepeatedSfixed64Field: Int32 { - get {return _storage._visitRepeatedSfixed64Field} + get {_storage._visitRepeatedSfixed64Field} set {_uniqueStorage()._visitRepeatedSfixed64Field = newValue} } var visitRepeatedSint32Field: Int32 { - get {return _storage._visitRepeatedSint32Field} + get {_storage._visitRepeatedSint32Field} set {_uniqueStorage()._visitRepeatedSint32Field = newValue} } var visitRepeatedSint64Field: Int32 { - get {return _storage._visitRepeatedSint64Field} + get {_storage._visitRepeatedSint64Field} set {_uniqueStorage()._visitRepeatedSint64Field = newValue} } var visitRepeatedStringField: Int32 { - get {return _storage._visitRepeatedStringField} + get {_storage._visitRepeatedStringField} set {_uniqueStorage()._visitRepeatedStringField = newValue} } var visitRepeatedUint32Field: Int32 { - get {return _storage._visitRepeatedUint32Field} + get {_storage._visitRepeatedUint32Field} set {_uniqueStorage()._visitRepeatedUint32Field = newValue} } var visitRepeatedUint64Field: Int32 { - get {return _storage._visitRepeatedUint64Field} + get {_storage._visitRepeatedUint64Field} set {_uniqueStorage()._visitRepeatedUint64Field = newValue} } var visitSingular: Int32 { - get {return _storage._visitSingular} + get {_storage._visitSingular} set {_uniqueStorage()._visitSingular = newValue} } var visitSingularBoolField: Int32 { - get {return _storage._visitSingularBoolField} + get {_storage._visitSingularBoolField} set {_uniqueStorage()._visitSingularBoolField = newValue} } var visitSingularBytesField: Int32 { - get {return _storage._visitSingularBytesField} + get {_storage._visitSingularBytesField} set {_uniqueStorage()._visitSingularBytesField = newValue} } var visitSingularDoubleField: Int32 { - get {return _storage._visitSingularDoubleField} + get {_storage._visitSingularDoubleField} set {_uniqueStorage()._visitSingularDoubleField = newValue} } var visitSingularEnumField: Int32 { - get {return _storage._visitSingularEnumField} + get {_storage._visitSingularEnumField} set {_uniqueStorage()._visitSingularEnumField = newValue} } var visitSingularFixed32Field: Int32 { - get {return _storage._visitSingularFixed32Field} + get {_storage._visitSingularFixed32Field} set {_uniqueStorage()._visitSingularFixed32Field = newValue} } var visitSingularFixed64Field: Int32 { - get {return _storage._visitSingularFixed64Field} + get {_storage._visitSingularFixed64Field} set {_uniqueStorage()._visitSingularFixed64Field = newValue} } var visitSingularFloatField: Int32 { - get {return _storage._visitSingularFloatField} + get {_storage._visitSingularFloatField} set {_uniqueStorage()._visitSingularFloatField = newValue} } var visitSingularGroupField: Int32 { - get {return _storage._visitSingularGroupField} + get {_storage._visitSingularGroupField} set {_uniqueStorage()._visitSingularGroupField = newValue} } var visitSingularInt32Field: Int32 { - get {return _storage._visitSingularInt32Field} + get {_storage._visitSingularInt32Field} set {_uniqueStorage()._visitSingularInt32Field = newValue} } var visitSingularInt64Field: Int32 { - get {return _storage._visitSingularInt64Field} + get {_storage._visitSingularInt64Field} set {_uniqueStorage()._visitSingularInt64Field = newValue} } var visitSingularMessageField: Int32 { - get {return _storage._visitSingularMessageField} + get {_storage._visitSingularMessageField} set {_uniqueStorage()._visitSingularMessageField = newValue} } var visitSingularSfixed32Field: Int32 { - get {return _storage._visitSingularSfixed32Field} + get {_storage._visitSingularSfixed32Field} set {_uniqueStorage()._visitSingularSfixed32Field = newValue} } var visitSingularSfixed64Field: Int32 { - get {return _storage._visitSingularSfixed64Field} + get {_storage._visitSingularSfixed64Field} set {_uniqueStorage()._visitSingularSfixed64Field = newValue} } var visitSingularSint32Field: Int32 { - get {return _storage._visitSingularSint32Field} + get {_storage._visitSingularSint32Field} set {_uniqueStorage()._visitSingularSint32Field = newValue} } var visitSingularSint64Field: Int32 { - get {return _storage._visitSingularSint64Field} + get {_storage._visitSingularSint64Field} set {_uniqueStorage()._visitSingularSint64Field = newValue} } var visitSingularStringField: Int32 { - get {return _storage._visitSingularStringField} + get {_storage._visitSingularStringField} set {_uniqueStorage()._visitSingularStringField = newValue} } var visitSingularUint32Field: Int32 { - get {return _storage._visitSingularUint32Field} + get {_storage._visitSingularUint32Field} set {_uniqueStorage()._visitSingularUint32Field = newValue} } var visitSingularUint64Field: Int32 { - get {return _storage._visitSingularUint64Field} + get {_storage._visitSingularUint64Field} set {_uniqueStorage()._visitSingularUint64Field = newValue} } var visitUnknown: Int32 { - get {return _storage._visitUnknown} + get {_storage._visitUnknown} set {_uniqueStorage()._visitUnknown = newValue} } + var void: Int32 { + get {_storage._void} + set {_uniqueStorage()._void = newValue} + } + var wasDecoded: Int32 { - get {return _storage._wasDecoded} + get {_storage._wasDecoded} set {_uniqueStorage()._wasDecoded = newValue} } var weak: Int32 { - get {return _storage._weak} + get {_storage._weak} set {_uniqueStorage()._weak = newValue} } var weakDependency: Int32 { - get {return _storage._weakDependency} + get {_storage._weakDependency} set {_uniqueStorage()._weakDependency = newValue} } var `where`: Int32 { - get {return _storage._where} + get {_storage._where} set {_uniqueStorage()._where = newValue} } var wireFormat: Int32 { - get {return _storage._wireFormat} + get {_storage._wireFormat} set {_uniqueStorage()._wireFormat = newValue} } var with: Int32 { - get {return _storage._with} + get {_storage._with} set {_uniqueStorage()._with = newValue} } var withUnsafeBytes: Int32 { - get {return _storage._withUnsafeBytes} + get {_storage._withUnsafeBytes} set {_uniqueStorage()._withUnsafeBytes = newValue} } var withUnsafeMutableBytes: Int32 { - get {return _storage._withUnsafeMutableBytes} + get {_storage._withUnsafeMutableBytes} set {_uniqueStorage()._withUnsafeMutableBytes = newValue} } var work: Int32 { - get {return _storage._work} + get {_storage._work} set {_uniqueStorage()._work = newValue} } + var wrapped: Int32 { + get {_storage._wrapped} + set {_uniqueStorage()._wrapped = newValue} + } + var wrappedType: Int32 { - get {return _storage._wrappedType} + get {_storage._wrappedType} set {_uniqueStorage()._wrappedType = newValue} } + var wrappedValue: Int32 { + get {_storage._wrappedValue} + set {_uniqueStorage()._wrappedValue = newValue} + } + var written: Int32 { - get {return _storage._written} + get {_storage._written} set {_uniqueStorage()._written = newValue} } var yday: Int32 { - get {return _storage._yday} + get {_storage._yday} set {_uniqueStorage()._yday = newValue} } @@ -4381,901 +5171,29 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedFields { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest_generated" +fileprivate let _protobuf_package = "swift_proto_testing.generated" -extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".GeneratedSwiftReservedFields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "adjusted"), - 2: .same(proto: "aggregateValue"), - 3: .same(proto: "allCases"), - 4: .same(proto: "allowAlias"), - 5: .same(proto: "alwaysPrintEnumsAsInts"), - 6: .same(proto: "annotation"), - 7: .same(proto: "any"), - 8: .same(proto: "AnyExtensionField"), - 9: .same(proto: "AnyMessageExtension"), - 10: .same(proto: "AnyMessageStorage"), - 11: .same(proto: "AnyUnpackError"), - 12: .same(proto: "Api"), - 13: .same(proto: "appended"), - 14: .same(proto: "appendUIntHex"), - 15: .same(proto: "appendUnknown"), - 16: .same(proto: "areAllInitialized"), - 17: .same(proto: "array"), - 18: .same(proto: "arrayDepth"), - 19: .same(proto: "arrayLiteral"), - 20: .same(proto: "arraySeparator"), - 21: .same(proto: "as"), - 22: .same(proto: "asciiOpenCurlyBracket"), - 23: .same(proto: "asciiZero"), - 24: .same(proto: "available"), - 25: .same(proto: "b"), - 26: .same(proto: "base64Values"), - 27: .same(proto: "baseAddress"), - 28: .same(proto: "BaseType"), - 29: .same(proto: "begin"), - 30: .same(proto: "binary"), - 31: .same(proto: "BinaryDecoder"), - 32: .same(proto: "BinaryDecodingError"), - 33: .same(proto: "BinaryDecodingOptions"), - 34: .same(proto: "BinaryDelimited"), - 35: .same(proto: "BinaryEncoder"), - 36: .same(proto: "BinaryEncodingError"), - 37: .same(proto: "BinaryEncodingMessageSetSizeVisitor"), - 38: .same(proto: "BinaryEncodingMessageSetVisitor"), - 39: .same(proto: "BinaryEncodingSizeVisitor"), - 40: .same(proto: "BinaryEncodingVisitor"), - 41: .same(proto: "binaryOptions"), - 42: .same(proto: "body"), - 43: .same(proto: "Bool"), - 44: .same(proto: "booleanLiteral"), - 45: .same(proto: "BooleanLiteralType"), - 46: .same(proto: "boolValue"), - 47: .same(proto: "bytes"), - 48: .same(proto: "bytesInGroup"), - 49: .same(proto: "bytesRead"), - 50: .same(proto: "BytesValue"), - 51: .same(proto: "c"), - 52: .same(proto: "capitalizeNext"), - 53: .same(proto: "cardinality"), - 54: .same(proto: "ccEnableArenas"), - 55: .same(proto: "ccGenericServices"), - 56: .same(proto: "Character"), - 57: .same(proto: "chars"), - 58: .same(proto: "class"), - 59: .same(proto: "clearAggregateValue"), - 60: .same(proto: "clearAllowAlias"), - 61: .same(proto: "clearBegin"), - 62: .same(proto: "clearCcEnableArenas"), - 63: .same(proto: "clearCcGenericServices"), - 64: .same(proto: "clearClientStreaming"), - 65: .same(proto: "clearCsharpNamespace"), - 66: .same(proto: "clearCtype"), - 67: .same(proto: "clearDefaultValue"), - 68: .same(proto: "clearDeprecated"), - 69: .same(proto: "clearDoubleValue"), - 70: .same(proto: "clearEnd"), - 71: .same(proto: "clearExtendee"), - 72: .same(proto: "clearExtensionValue"), - 73: .same(proto: "clearGoPackage"), - 74: .same(proto: "clearIdempotencyLevel"), - 75: .same(proto: "clearIdentifierValue"), - 76: .same(proto: "clearInputType"), - 77: .same(proto: "clearIsExtension"), - 78: .same(proto: "clearJavaGenerateEqualsAndHash"), - 79: .same(proto: "clearJavaGenericServices"), - 80: .same(proto: "clearJavaMultipleFiles"), - 81: .same(proto: "clearJavaOuterClassname"), - 82: .same(proto: "clearJavaPackage"), - 83: .same(proto: "clearJavaStringCheckUtf8"), - 84: .same(proto: "clearJsonName"), - 85: .same(proto: "clearJstype"), - 86: .same(proto: "clearLabel"), - 87: .same(proto: "clearLazy"), - 88: .same(proto: "clearLeadingComments"), - 89: .same(proto: "clearMapEntry"), - 90: .same(proto: "clearMessageSetWireFormat"), - 91: .same(proto: "clearName"), - 92: .same(proto: "clearNamePart"), - 93: .same(proto: "clearNegativeIntValue"), - 94: .same(proto: "clearNoStandardDescriptorAccessor"), - 95: .same(proto: "clearNumber"), - 96: .same(proto: "clearObjcClassPrefix"), - 97: .same(proto: "clearOneofIndex"), - 98: .same(proto: "clearOptimizeFor"), - 99: .same(proto: "clearOptions"), - 100: .same(proto: "clearOutputType"), - 101: .same(proto: "clearPackage"), - 102: .same(proto: "clearPacked"), - 103: .same(proto: "clearPhpClassPrefix"), - 104: .same(proto: "clearPhpGenericServices"), - 105: .same(proto: "clearPhpMetadataNamespace"), - 106: .same(proto: "clearPhpNamespace"), - 107: .same(proto: "clearPositiveIntValue"), - 108: .same(proto: "clearProto3Optional"), - 109: .same(proto: "clearPyGenericServices"), - 110: .same(proto: "clearRubyPackage"), - 111: .same(proto: "clearServerStreaming"), - 112: .same(proto: "clearSourceCodeInfo"), - 113: .same(proto: "clearSourceContext"), - 114: .same(proto: "clearSourceFile"), - 115: .same(proto: "clearStart"), - 116: .same(proto: "clearStringValue"), - 117: .same(proto: "clearSwiftPrefix"), - 118: .same(proto: "clearSyntax"), - 119: .same(proto: "clearTrailingComments"), - 120: .same(proto: "clearType"), - 121: .same(proto: "clearTypeName"), - 122: .same(proto: "clearValue"), - 123: .same(proto: "clearWeak"), - 124: .same(proto: "clientStreaming"), - 125: .same(proto: "codePoint"), - 126: .same(proto: "codeUnits"), - 127: .same(proto: "Collection"), - 128: .same(proto: "com"), - 129: .same(proto: "comma"), - 130: .same(proto: "contentsOf"), - 131: .same(proto: "ContiguousBytes"), - 132: .same(proto: "count"), - 133: .same(proto: "countVarintsInBuffer"), - 134: .same(proto: "csharpNamespace"), - 135: .same(proto: "ctype"), - 136: .same(proto: "customCodable"), - 137: .same(proto: "CustomDebugStringConvertible"), - 138: .same(proto: "d"), - 139: .same(proto: "Data"), - 140: .same(proto: "dataResult"), - 141: .same(proto: "date"), - 142: .same(proto: "daySec"), - 143: .same(proto: "daysSinceEpoch"), - 144: .same(proto: "debugDescription"), - 145: .same(proto: "decoded"), - 146: .same(proto: "decodedFromJSONNull"), - 147: .same(proto: "decodeExtensionField"), - 148: .same(proto: "decodeExtensionFieldsAsMessageSet"), - 149: .same(proto: "decodeJSON"), - 150: .same(proto: "decodeMapField"), - 151: .same(proto: "decodeMessage"), - 152: .same(proto: "decoder"), - 153: .same(proto: "decodeRepeated"), - 154: .same(proto: "decodeRepeatedBoolField"), - 155: .same(proto: "decodeRepeatedBytesField"), - 156: .same(proto: "decodeRepeatedDoubleField"), - 157: .same(proto: "decodeRepeatedEnumField"), - 158: .same(proto: "decodeRepeatedFixed32Field"), - 159: .same(proto: "decodeRepeatedFixed64Field"), - 160: .same(proto: "decodeRepeatedFloatField"), - 161: .same(proto: "decodeRepeatedGroupField"), - 162: .same(proto: "decodeRepeatedInt32Field"), - 163: .same(proto: "decodeRepeatedInt64Field"), - 164: .same(proto: "decodeRepeatedMessageField"), - 165: .same(proto: "decodeRepeatedSFixed32Field"), - 166: .same(proto: "decodeRepeatedSFixed64Field"), - 167: .same(proto: "decodeRepeatedSInt32Field"), - 168: .same(proto: "decodeRepeatedSInt64Field"), - 169: .same(proto: "decodeRepeatedStringField"), - 170: .same(proto: "decodeRepeatedUInt32Field"), - 171: .same(proto: "decodeRepeatedUInt64Field"), - 172: .same(proto: "decodeSingular"), - 173: .same(proto: "decodeSingularBoolField"), - 174: .same(proto: "decodeSingularBytesField"), - 175: .same(proto: "decodeSingularDoubleField"), - 176: .same(proto: "decodeSingularEnumField"), - 177: .same(proto: "decodeSingularFixed32Field"), - 178: .same(proto: "decodeSingularFixed64Field"), - 179: .same(proto: "decodeSingularFloatField"), - 180: .same(proto: "decodeSingularGroupField"), - 181: .same(proto: "decodeSingularInt32Field"), - 182: .same(proto: "decodeSingularInt64Field"), - 183: .same(proto: "decodeSingularMessageField"), - 184: .same(proto: "decodeSingularSFixed32Field"), - 185: .same(proto: "decodeSingularSFixed64Field"), - 186: .same(proto: "decodeSingularSInt32Field"), - 187: .same(proto: "decodeSingularSInt64Field"), - 188: .same(proto: "decodeSingularStringField"), - 189: .same(proto: "decodeSingularUInt32Field"), - 190: .same(proto: "decodeSingularUInt64Field"), - 191: .same(proto: "decodeTextFormat"), - 192: .same(proto: "defaultAnyTypeURLPrefix"), - 193: .same(proto: "defaultValue"), - 194: .same(proto: "dependency"), - 195: .same(proto: "deprecated"), - 196: .same(proto: "description"), - 197: .same(proto: "DescriptorProto"), - 198: .same(proto: "Dictionary"), - 199: .same(proto: "dictionaryLiteral"), - 200: .same(proto: "digit"), - 201: .same(proto: "digit0"), - 202: .same(proto: "digit1"), - 203: .same(proto: "digitCount"), - 204: .same(proto: "digits"), - 205: .same(proto: "digitValue"), - 206: .same(proto: "discardableResult"), - 207: .same(proto: "discardUnknownFields"), - 208: .same(proto: "distance"), - 209: .same(proto: "double"), - 210: .same(proto: "doubleValue"), - 211: .same(proto: "Duration"), - 212: .same(proto: "E"), - 213: .same(proto: "Element"), - 214: .same(proto: "elements"), - 215: .same(proto: "emitExtensionFieldName"), - 216: .same(proto: "emitFieldName"), - 217: .same(proto: "emitFieldNumber"), - 218: .same(proto: "Empty"), - 219: .same(proto: "emptyData"), - 220: .same(proto: "encodeAsBytes"), - 221: .same(proto: "encoded"), - 222: .same(proto: "encodedJSONString"), - 223: .same(proto: "encodedSize"), - 224: .same(proto: "encodeField"), - 225: .same(proto: "encoder"), - 226: .same(proto: "end"), - 227: .same(proto: "endArray"), - 228: .same(proto: "endMessageField"), - 229: .same(proto: "endObject"), - 230: .same(proto: "endRegularField"), - 231: .same(proto: "enum"), - 232: .same(proto: "EnumDescriptorProto"), - 233: .same(proto: "EnumOptions"), - 234: .same(proto: "EnumReservedRange"), - 235: .same(proto: "enumType"), - 236: .same(proto: "enumvalue"), - 237: .same(proto: "EnumValueDescriptorProto"), - 238: .same(proto: "EnumValueOptions"), - 239: .same(proto: "Equatable"), - 240: .same(proto: "Error"), - 241: .same(proto: "ExpressibleByArrayLiteral"), - 242: .same(proto: "ExpressibleByDictionaryLiteral"), - 243: .same(proto: "ext"), - 244: .same(proto: "extDecoder"), - 245: .same(proto: "extendedGraphemeClusterLiteral"), - 246: .same(proto: "ExtendedGraphemeClusterLiteralType"), - 247: .same(proto: "extendee"), - 248: .same(proto: "ExtensibleMessage"), - 249: .same(proto: "extension"), - 250: .same(proto: "ExtensionField"), - 251: .same(proto: "extensionFieldNumber"), - 252: .same(proto: "ExtensionFieldValueSet"), - 253: .same(proto: "ExtensionMap"), - 254: .same(proto: "extensionRange"), - 255: .same(proto: "ExtensionRangeOptions"), - 256: .same(proto: "extensions"), - 257: .same(proto: "extras"), - 258: .same(proto: "F"), - 259: .same(proto: "false"), - 260: .same(proto: "field"), - 261: .same(proto: "fieldData"), - 262: .same(proto: "FieldDescriptorProto"), - 263: .same(proto: "FieldMask"), - 264: .same(proto: "fieldName"), - 265: .same(proto: "fieldNameCount"), - 266: .same(proto: "fieldNum"), - 267: .same(proto: "fieldNumber"), - 268: .same(proto: "fieldNumberForProto"), - 269: .same(proto: "FieldOptions"), - 270: .same(proto: "fields"), - 271: .same(proto: "fieldSize"), - 272: .same(proto: "FieldTag"), - 273: .same(proto: "fieldType"), - 274: .same(proto: "file"), - 275: .same(proto: "FileDescriptorProto"), - 276: .same(proto: "FileDescriptorSet"), - 277: .same(proto: "fileName"), - 278: .same(proto: "FileOptions"), - 279: .same(proto: "filter"), - 280: .same(proto: "first"), - 281: .same(proto: "firstItem"), - 282: .same(proto: "float"), - 283: .same(proto: "floatLiteral"), - 284: .same(proto: "FloatLiteralType"), - 285: .same(proto: "FloatValue"), - 286: .same(proto: "forMessageName"), - 287: .same(proto: "formUnion"), - 288: .same(proto: "forReadingFrom"), - 289: .same(proto: "forTypeURL"), - 290: .same(proto: "ForwardParser"), - 291: .same(proto: "forWritingInto"), - 292: .same(proto: "from"), - 293: .same(proto: "fromAscii2"), - 294: .same(proto: "fromAscii4"), - 295: .same(proto: "fromByteOffset"), - 296: .same(proto: "fromHexDigit"), - 297: .same(proto: "func"), - 298: .same(proto: "G"), - 299: .same(proto: "GeneratedCodeInfo"), - 300: .same(proto: "get"), - 301: .same(proto: "getExtensionValue"), - 302: .same(proto: "googleapis"), - 303: .standard(proto: "Google_Protobuf_Any"), - 304: .standard(proto: "Google_Protobuf_Api"), - 305: .standard(proto: "Google_Protobuf_BoolValue"), - 306: .standard(proto: "Google_Protobuf_BytesValue"), - 307: .standard(proto: "Google_Protobuf_DescriptorProto"), - 308: .standard(proto: "Google_Protobuf_DoubleValue"), - 309: .standard(proto: "Google_Protobuf_Duration"), - 310: .standard(proto: "Google_Protobuf_Empty"), - 311: .standard(proto: "Google_Protobuf_Enum"), - 312: .standard(proto: "Google_Protobuf_EnumDescriptorProto"), - 313: .standard(proto: "Google_Protobuf_EnumOptions"), - 314: .standard(proto: "Google_Protobuf_EnumValue"), - 315: .standard(proto: "Google_Protobuf_EnumValueDescriptorProto"), - 316: .standard(proto: "Google_Protobuf_EnumValueOptions"), - 317: .standard(proto: "Google_Protobuf_ExtensionRangeOptions"), - 318: .standard(proto: "Google_Protobuf_Field"), - 319: .standard(proto: "Google_Protobuf_FieldDescriptorProto"), - 320: .standard(proto: "Google_Protobuf_FieldMask"), - 321: .standard(proto: "Google_Protobuf_FieldOptions"), - 322: .standard(proto: "Google_Protobuf_FileDescriptorProto"), - 323: .standard(proto: "Google_Protobuf_FileDescriptorSet"), - 324: .standard(proto: "Google_Protobuf_FileOptions"), - 325: .standard(proto: "Google_Protobuf_FloatValue"), - 326: .standard(proto: "Google_Protobuf_GeneratedCodeInfo"), - 327: .standard(proto: "Google_Protobuf_Int32Value"), - 328: .standard(proto: "Google_Protobuf_Int64Value"), - 329: .standard(proto: "Google_Protobuf_ListValue"), - 330: .standard(proto: "Google_Protobuf_MessageOptions"), - 331: .standard(proto: "Google_Protobuf_Method"), - 332: .standard(proto: "Google_Protobuf_MethodDescriptorProto"), - 333: .standard(proto: "Google_Protobuf_MethodOptions"), - 334: .standard(proto: "Google_Protobuf_Mixin"), - 335: .standard(proto: "Google_Protobuf_NullValue"), - 336: .standard(proto: "Google_Protobuf_OneofDescriptorProto"), - 337: .standard(proto: "Google_Protobuf_OneofOptions"), - 338: .standard(proto: "Google_Protobuf_Option"), - 339: .standard(proto: "Google_Protobuf_ServiceDescriptorProto"), - 340: .standard(proto: "Google_Protobuf_ServiceOptions"), - 341: .standard(proto: "Google_Protobuf_SourceCodeInfo"), - 342: .standard(proto: "Google_Protobuf_SourceContext"), - 343: .standard(proto: "Google_Protobuf_StringValue"), - 344: .standard(proto: "Google_Protobuf_Struct"), - 345: .standard(proto: "Google_Protobuf_Syntax"), - 346: .standard(proto: "Google_Protobuf_Timestamp"), - 347: .standard(proto: "Google_Protobuf_Type"), - 348: .standard(proto: "Google_Protobuf_UInt32Value"), - 349: .standard(proto: "Google_Protobuf_UInt64Value"), - 350: .standard(proto: "Google_Protobuf_UninterpretedOption"), - 351: .standard(proto: "Google_Protobuf_Value"), - 352: .same(proto: "goPackage"), - 353: .same(proto: "group"), - 354: .same(proto: "groupFieldNumberStack"), - 355: .same(proto: "groupSize"), - 356: .same(proto: "h"), - 357: .same(proto: "hadOneofValue"), - 358: .same(proto: "handleConflictingOneOf"), - 359: .same(proto: "hasAggregateValue"), - 360: .same(proto: "hasAllowAlias"), - 361: .same(proto: "hasBegin"), - 362: .same(proto: "hasCcEnableArenas"), - 363: .same(proto: "hasCcGenericServices"), - 364: .same(proto: "hasClientStreaming"), - 365: .same(proto: "hasCsharpNamespace"), - 366: .same(proto: "hasCtype"), - 367: .same(proto: "hasDefaultValue"), - 368: .same(proto: "hasDeprecated"), - 369: .same(proto: "hasDoubleValue"), - 370: .same(proto: "hasEnd"), - 371: .same(proto: "hasExtendee"), - 372: .same(proto: "hasExtensionValue"), - 373: .same(proto: "hasGoPackage"), - 374: .same(proto: "hash"), - 375: .same(proto: "Hashable"), - 376: .same(proto: "hasher"), - 377: .same(proto: "hashValue"), - 378: .same(proto: "HashVisitor"), - 379: .same(proto: "hasIdempotencyLevel"), - 380: .same(proto: "hasIdentifierValue"), - 381: .same(proto: "hasInputType"), - 382: .same(proto: "hasIsExtension"), - 383: .same(proto: "hasJavaGenerateEqualsAndHash"), - 384: .same(proto: "hasJavaGenericServices"), - 385: .same(proto: "hasJavaMultipleFiles"), - 386: .same(proto: "hasJavaOuterClassname"), - 387: .same(proto: "hasJavaPackage"), - 388: .same(proto: "hasJavaStringCheckUtf8"), - 389: .same(proto: "hasJsonName"), - 390: .same(proto: "hasJstype"), - 391: .same(proto: "hasLabel"), - 392: .same(proto: "hasLazy"), - 393: .same(proto: "hasLeadingComments"), - 394: .same(proto: "hasMapEntry"), - 395: .same(proto: "hasMessageSetWireFormat"), - 396: .same(proto: "hasName"), - 397: .same(proto: "hasNamePart"), - 398: .same(proto: "hasNegativeIntValue"), - 399: .same(proto: "hasNoStandardDescriptorAccessor"), - 400: .same(proto: "hasNumber"), - 401: .same(proto: "hasObjcClassPrefix"), - 402: .same(proto: "hasOneofIndex"), - 403: .same(proto: "hasOptimizeFor"), - 404: .same(proto: "hasOptions"), - 405: .same(proto: "hasOutputType"), - 406: .same(proto: "hasPackage"), - 407: .same(proto: "hasPacked"), - 408: .same(proto: "hasPhpClassPrefix"), - 409: .same(proto: "hasPhpGenericServices"), - 410: .same(proto: "hasPhpMetadataNamespace"), - 411: .same(proto: "hasPhpNamespace"), - 412: .same(proto: "hasPositiveIntValue"), - 413: .same(proto: "hasProto3Optional"), - 414: .same(proto: "hasPyGenericServices"), - 415: .same(proto: "hasRubyPackage"), - 416: .same(proto: "hasServerStreaming"), - 417: .same(proto: "hasSourceCodeInfo"), - 418: .same(proto: "hasSourceContext"), - 419: .same(proto: "hasSourceFile"), - 420: .same(proto: "hasStart"), - 421: .same(proto: "hasStringValue"), - 422: .same(proto: "hasSwiftPrefix"), - 423: .same(proto: "hasSyntax"), - 424: .same(proto: "hasTrailingComments"), - 425: .same(proto: "hasType"), - 426: .same(proto: "hasTypeName"), - 427: .same(proto: "hasValue"), - 428: .same(proto: "hasWeak"), - 429: .same(proto: "hour"), - 430: .same(proto: "i"), - 431: .same(proto: "idempotencyLevel"), - 432: .same(proto: "identifierValue"), - 433: .same(proto: "if"), - 434: .same(proto: "ignoreUnknownFields"), - 435: .same(proto: "index"), - 436: .same(proto: "init"), - 437: .same(proto: "inout"), - 438: .same(proto: "inputType"), - 439: .same(proto: "insert"), - 440: .same(proto: "Int"), - 441: .same(proto: "Int32"), - 442: .same(proto: "Int32Value"), - 443: .same(proto: "Int64"), - 444: .same(proto: "Int64Value"), - 445: .same(proto: "Int8"), - 446: .same(proto: "integerLiteral"), - 447: .same(proto: "IntegerLiteralType"), - 448: .same(proto: "intern"), - 449: .same(proto: "Internal"), - 450: .same(proto: "InternalState"), - 451: .same(proto: "into"), - 452: .same(proto: "ints"), - 453: .same(proto: "isA"), - 454: .same(proto: "isEqual"), - 455: .same(proto: "isEqualTo"), - 456: .same(proto: "isExtension"), - 457: .same(proto: "isInitialized"), - 458: .same(proto: "itemTagsEncodedSize"), - 459: .same(proto: "Iterator"), - 460: .standard(proto: "i_2166136261"), - 461: .same(proto: "javaGenerateEqualsAndHash"), - 462: .same(proto: "javaGenericServices"), - 463: .same(proto: "javaMultipleFiles"), - 464: .same(proto: "javaOuterClassname"), - 465: .same(proto: "javaPackage"), - 466: .same(proto: "javaStringCheckUtf8"), - 467: .same(proto: "JSONDecoder"), - 468: .same(proto: "JSONDecodingError"), - 469: .same(proto: "JSONDecodingOptions"), - 470: .same(proto: "jsonEncoder"), - 471: .same(proto: "JSONEncodingError"), - 472: .same(proto: "JSONEncodingOptions"), - 473: .same(proto: "JSONEncodingVisitor"), - 474: .same(proto: "JSONMapEncodingVisitor"), - 475: .same(proto: "jsonName"), - 476: .same(proto: "jsonPath"), - 477: .same(proto: "jsonPaths"), - 478: .same(proto: "JSONScanner"), - 479: .same(proto: "jsonString"), - 480: .same(proto: "jsonText"), - 481: .same(proto: "jsonUTF8Data"), - 482: .same(proto: "jstype"), - 483: .same(proto: "k"), - 484: .same(proto: "Key"), - 485: .same(proto: "keyField"), - 486: .same(proto: "KeyType"), - 487: .same(proto: "kind"), - 488: .same(proto: "l"), - 489: .same(proto: "label"), - 490: .same(proto: "lazy"), - 491: .same(proto: "leadingComments"), - 492: .same(proto: "leadingDetachedComments"), - 493: .same(proto: "length"), - 494: .same(proto: "lessThan"), - 495: .same(proto: "let"), - 496: .same(proto: "lhs"), - 497: .same(proto: "list"), - 498: .same(proto: "listOfMessages"), - 499: .same(proto: "listValue"), - 500: .same(proto: "littleEndian"), - 501: .same(proto: "littleEndianBytes"), - 502: .same(proto: "load"), - 503: .same(proto: "localHasher"), - 504: .same(proto: "location"), - 505: .same(proto: "M"), - 506: .same(proto: "major"), - 507: .same(proto: "makeIterator"), - 508: .same(proto: "mapEntry"), - 509: .same(proto: "mapHash"), - 510: .same(proto: "MapKeyType"), - 511: .same(proto: "mapNameResolver"), - 512: .same(proto: "mapToMessages"), - 513: .same(proto: "MapValueType"), - 514: .same(proto: "mapVisitor"), - 515: .same(proto: "mdayStart"), - 516: .same(proto: "merge"), - 517: .same(proto: "message"), - 518: .same(proto: "messageDepthLimit"), - 519: .same(proto: "MessageExtension"), - 520: .same(proto: "MessageImplementationBase"), - 521: .same(proto: "MessageOptions"), - 522: .same(proto: "MessageSet"), - 523: .same(proto: "messageSetWireFormat"), - 524: .same(proto: "messageType"), - 525: .same(proto: "Method"), - 526: .same(proto: "MethodDescriptorProto"), - 527: .same(proto: "MethodOptions"), - 528: .same(proto: "methods"), - 529: .same(proto: "minor"), - 530: .same(proto: "Mixin"), - 531: .same(proto: "mixins"), - 532: .same(proto: "modifier"), - 533: .same(proto: "modify"), - 534: .same(proto: "month"), - 535: .same(proto: "msgExtension"), - 536: .same(proto: "mutating"), - 537: .same(proto: "n"), - 538: .same(proto: "name"), - 539: .same(proto: "NameDescription"), - 540: .same(proto: "NameMap"), - 541: .same(proto: "NamePart"), - 542: .same(proto: "nameResolver"), - 543: .same(proto: "names"), - 544: .same(proto: "nanos"), - 545: .same(proto: "nativeBytes"), - 546: .same(proto: "nativeEndianBytes"), - 547: .same(proto: "negativeIntValue"), - 548: .same(proto: "nestedType"), - 549: .same(proto: "newL"), - 550: .same(proto: "newList"), - 551: .same(proto: "newValue"), - 552: .same(proto: "nextByte"), - 553: .same(proto: "nextFieldNumber"), - 554: .same(proto: "nil"), - 555: .same(proto: "nilLiteral"), - 556: .same(proto: "noStandardDescriptorAccessor"), - 557: .same(proto: "nullValue"), - 558: .same(proto: "number"), - 559: .same(proto: "numberValue"), - 560: .same(proto: "objcClassPrefix"), - 561: .same(proto: "of"), - 562: .same(proto: "oneofDecl"), - 563: .same(proto: "OneofDescriptorProto"), - 564: .same(proto: "oneofIndex"), - 565: .same(proto: "OneofOptions"), - 566: .same(proto: "oneofs"), - 567: .standard(proto: "OneOf_Kind"), - 568: .same(proto: "optimizeFor"), - 569: .same(proto: "OptimizeMode"), - 570: .same(proto: "Option"), - 571: .same(proto: "OptionalEnumExtensionField"), - 572: .same(proto: "OptionalExtensionField"), - 573: .same(proto: "OptionalGroupExtensionField"), - 574: .same(proto: "OptionalMessageExtensionField"), - 575: .same(proto: "options"), - 576: .same(proto: "other"), - 577: .same(proto: "others"), - 578: .same(proto: "out"), - 579: .same(proto: "outputType"), - 580: .same(proto: "p"), - 581: .same(proto: "package"), - 582: .same(proto: "packed"), - 583: .same(proto: "PackedEnumExtensionField"), - 584: .same(proto: "PackedExtensionField"), - 585: .same(proto: "padding"), - 586: .same(proto: "parent"), - 587: .same(proto: "parse"), - 588: .same(proto: "partial"), - 589: .same(proto: "path"), - 590: .same(proto: "paths"), - 591: .same(proto: "payload"), - 592: .same(proto: "payloadSize"), - 593: .same(proto: "phpClassPrefix"), - 594: .same(proto: "phpGenericServices"), - 595: .same(proto: "phpMetadataNamespace"), - 596: .same(proto: "phpNamespace"), - 597: .same(proto: "pointer"), - 598: .same(proto: "pos"), - 599: .same(proto: "positiveIntValue"), - 600: .same(proto: "prefix"), - 601: .same(proto: "preserveProtoFieldNames"), - 602: .same(proto: "preTraverse"), - 603: .same(proto: "printUnknownFields"), - 604: .same(proto: "proto2"), - 605: .same(proto: "proto3DefaultValue"), - 606: .same(proto: "proto3Optional"), - 607: .same(proto: "ProtobufAPIVersionCheck"), - 608: .standard(proto: "ProtobufAPIVersion_2"), - 609: .same(proto: "ProtobufBool"), - 610: .same(proto: "ProtobufBytes"), - 611: .same(proto: "ProtobufDouble"), - 612: .same(proto: "ProtobufEnumMap"), - 613: .same(proto: "protobufExtension"), - 614: .same(proto: "ProtobufFixed32"), - 615: .same(proto: "ProtobufFixed64"), - 616: .same(proto: "ProtobufFloat"), - 617: .same(proto: "ProtobufInt32"), - 618: .same(proto: "ProtobufInt64"), - 619: .same(proto: "ProtobufMap"), - 620: .same(proto: "ProtobufMessageMap"), - 621: .same(proto: "ProtobufSFixed32"), - 622: .same(proto: "ProtobufSFixed64"), - 623: .same(proto: "ProtobufSInt32"), - 624: .same(proto: "ProtobufSInt64"), - 625: .same(proto: "ProtobufString"), - 626: .same(proto: "ProtobufUInt32"), - 627: .same(proto: "ProtobufUInt64"), - 628: .standard(proto: "protobuf_extensionFieldValues"), - 629: .standard(proto: "protobuf_fieldNumber"), - 630: .standard(proto: "protobuf_generated_isEqualTo"), - 631: .standard(proto: "protobuf_nameMap"), - 632: .standard(proto: "protobuf_newField"), - 633: .standard(proto: "protobuf_package"), - 634: .same(proto: "protocol"), - 635: .same(proto: "protoFieldName"), - 636: .same(proto: "protoMessageName"), - 637: .same(proto: "ProtoNameProviding"), - 638: .same(proto: "protoPaths"), - 639: .same(proto: "public"), - 640: .same(proto: "publicDependency"), - 641: .same(proto: "putBoolValue"), - 642: .same(proto: "putBytesValue"), - 643: .same(proto: "putDoubleValue"), - 644: .same(proto: "putEnumValue"), - 645: .same(proto: "putFixedUInt32"), - 646: .same(proto: "putFixedUInt64"), - 647: .same(proto: "putFloatValue"), - 648: .same(proto: "putInt64"), - 649: .same(proto: "putStringValue"), - 650: .same(proto: "putUInt64"), - 651: .same(proto: "putUInt64Hex"), - 652: .same(proto: "putVarInt"), - 653: .same(proto: "putZigZagVarInt"), - 654: .same(proto: "pyGenericServices"), - 655: .same(proto: "rawChars"), - 656: .same(proto: "RawRepresentable"), - 657: .same(proto: "RawValue"), - 658: .same(proto: "read4HexDigits"), - 659: .same(proto: "register"), - 660: .same(proto: "RepeatedEnumExtensionField"), - 661: .same(proto: "RepeatedExtensionField"), - 662: .same(proto: "RepeatedGroupExtensionField"), - 663: .same(proto: "RepeatedMessageExtensionField"), - 664: .same(proto: "requestStreaming"), - 665: .same(proto: "requestTypeURL"), - 666: .same(proto: "requiredSize"), - 667: .same(proto: "reservedName"), - 668: .same(proto: "reservedRange"), - 669: .same(proto: "responseStreaming"), - 670: .same(proto: "responseTypeURL"), - 671: .same(proto: "result"), - 672: .same(proto: "rethrows"), - 673: .same(proto: "return"), - 674: .same(proto: "ReturnType"), - 675: .same(proto: "revision"), - 676: .same(proto: "rhs"), - 677: .same(proto: "root"), - 678: .same(proto: "rubyPackage"), - 679: .same(proto: "s"), - 680: .same(proto: "sawBackslash"), - 681: .same(proto: "sawSection4Characters"), - 682: .same(proto: "sawSection5Characters"), - 683: .same(proto: "scanner"), - 684: .same(proto: "seconds"), - 685: .same(proto: "self"), - 686: .same(proto: "separator"), - 687: .same(proto: "serialize"), - 688: .same(proto: "serializedData"), - 689: .same(proto: "serializedSize"), - 690: .same(proto: "serverStreaming"), - 691: .same(proto: "service"), - 692: .same(proto: "ServiceDescriptorProto"), - 693: .same(proto: "ServiceOptions"), - 694: .same(proto: "set"), - 695: .same(proto: "setExtensionValue"), - 696: .same(proto: "shift"), - 697: .same(proto: "SimpleExtensionMap"), - 698: .same(proto: "sizer"), - 699: .same(proto: "source"), - 700: .same(proto: "sourceCodeInfo"), - 701: .same(proto: "sourceContext"), - 702: .same(proto: "sourceEncoding"), - 703: .same(proto: "sourceFile"), - 704: .same(proto: "span"), - 705: .same(proto: "split"), - 706: .same(proto: "start"), - 707: .same(proto: "startArray"), - 708: .same(proto: "startArrayObject"), - 709: .same(proto: "startField"), - 710: .same(proto: "startIndex"), - 711: .same(proto: "startMessageField"), - 712: .same(proto: "startObject"), - 713: .same(proto: "startRegularField"), - 714: .same(proto: "state"), - 715: .same(proto: "static"), - 716: .same(proto: "StaticString"), - 717: .same(proto: "storage"), - 718: .same(proto: "String"), - 719: .same(proto: "stringLiteral"), - 720: .same(proto: "StringLiteralType"), - 721: .same(proto: "stringResult"), - 722: .same(proto: "stringValue"), - 723: .same(proto: "struct"), - 724: .same(proto: "structValue"), - 725: .same(proto: "subDecoder"), - 726: .same(proto: "subscript"), - 727: .same(proto: "subVisitor"), - 728: .same(proto: "Swift"), - 729: .same(proto: "swiftPrefix"), - 730: .same(proto: "SwiftProtobuf"), - 731: .same(proto: "syntax"), - 732: .same(proto: "T"), - 733: .same(proto: "tag"), - 734: .same(proto: "terminator"), - 735: .same(proto: "testDecoder"), - 736: .same(proto: "text"), - 737: .same(proto: "textDecoder"), - 738: .same(proto: "TextFormatDecoder"), - 739: .same(proto: "TextFormatDecodingError"), - 740: .same(proto: "TextFormatDecodingOptions"), - 741: .same(proto: "TextFormatEncodingOptions"), - 742: .same(proto: "TextFormatEncodingVisitor"), - 743: .same(proto: "textFormatString"), - 744: .same(proto: "throws"), - 745: .same(proto: "timeInterval"), - 746: .same(proto: "timeIntervalSince1970"), - 747: .same(proto: "timeIntervalSinceReferenceDate"), - 748: .same(proto: "Timestamp"), - 749: .same(proto: "total"), - 750: .same(proto: "totalArrayDepth"), - 751: .same(proto: "totalSize"), - 752: .same(proto: "trailingComments"), - 753: .same(proto: "traverse"), - 754: .same(proto: "true"), - 755: .same(proto: "try"), - 756: .same(proto: "type"), - 757: .same(proto: "typealias"), - 758: .same(proto: "TypeEnum"), - 759: .same(proto: "typeName"), - 760: .same(proto: "typePrefix"), - 761: .same(proto: "typeStart"), - 762: .same(proto: "typeUnknown"), - 763: .same(proto: "typeURL"), - 764: .same(proto: "UInt32"), - 765: .same(proto: "UInt32Value"), - 766: .same(proto: "UInt64"), - 767: .same(proto: "UInt64Value"), - 768: .same(proto: "UInt8"), - 769: .same(proto: "unicodeScalarLiteral"), - 770: .same(proto: "UnicodeScalarLiteralType"), - 771: .same(proto: "unicodeScalars"), - 772: .same(proto: "UnicodeScalarView"), - 773: .same(proto: "uninterpretedOption"), - 774: .same(proto: "union"), - 775: .same(proto: "uniqueStorage"), - 776: .same(proto: "unknown"), - 777: .same(proto: "unknownFields"), - 778: .same(proto: "UnknownStorage"), - 779: .same(proto: "unpackTo"), - 780: .same(proto: "UnsafeBufferPointer"), - 781: .same(proto: "UnsafeMutablePointer"), - 782: .same(proto: "UnsafeMutableRawBufferPointer"), - 783: .same(proto: "UnsafeMutableRawPointer"), - 784: .same(proto: "UnsafeRawBufferPointer"), - 785: .same(proto: "UnsafeRawPointer"), - 786: .same(proto: "updatedOptions"), - 787: .same(proto: "url"), - 788: .same(proto: "utf8"), - 789: .same(proto: "utf8Ptr"), - 790: .same(proto: "utf8ToDouble"), - 791: .same(proto: "UTF8View"), - 792: .same(proto: "v"), - 793: .same(proto: "value"), - 794: .same(proto: "valueField"), - 795: .same(proto: "values"), - 796: .same(proto: "ValueType"), - 797: .same(proto: "var"), - 798: .same(proto: "Version"), - 799: .same(proto: "versionString"), - 800: .same(proto: "visitExtensionFields"), - 801: .same(proto: "visitExtensionFieldsAsMessageSet"), - 802: .same(proto: "visitMapField"), - 803: .same(proto: "visitor"), - 804: .same(proto: "visitPacked"), - 805: .same(proto: "visitPackedBoolField"), - 806: .same(proto: "visitPackedDoubleField"), - 807: .same(proto: "visitPackedEnumField"), - 808: .same(proto: "visitPackedFixed32Field"), - 809: .same(proto: "visitPackedFixed64Field"), - 810: .same(proto: "visitPackedFloatField"), - 811: .same(proto: "visitPackedInt32Field"), - 812: .same(proto: "visitPackedInt64Field"), - 813: .same(proto: "visitPackedSFixed32Field"), - 814: .same(proto: "visitPackedSFixed64Field"), - 815: .same(proto: "visitPackedSInt32Field"), - 816: .same(proto: "visitPackedSInt64Field"), - 817: .same(proto: "visitPackedUInt32Field"), - 818: .same(proto: "visitPackedUInt64Field"), - 819: .same(proto: "visitRepeated"), - 820: .same(proto: "visitRepeatedBoolField"), - 821: .same(proto: "visitRepeatedBytesField"), - 822: .same(proto: "visitRepeatedDoubleField"), - 823: .same(proto: "visitRepeatedEnumField"), - 824: .same(proto: "visitRepeatedFixed32Field"), - 825: .same(proto: "visitRepeatedFixed64Field"), - 826: .same(proto: "visitRepeatedFloatField"), - 827: .same(proto: "visitRepeatedGroupField"), - 828: .same(proto: "visitRepeatedInt32Field"), - 829: .same(proto: "visitRepeatedInt64Field"), - 830: .same(proto: "visitRepeatedMessageField"), - 831: .same(proto: "visitRepeatedSFixed32Field"), - 832: .same(proto: "visitRepeatedSFixed64Field"), - 833: .same(proto: "visitRepeatedSInt32Field"), - 834: .same(proto: "visitRepeatedSInt64Field"), - 835: .same(proto: "visitRepeatedStringField"), - 836: .same(proto: "visitRepeatedUInt32Field"), - 837: .same(proto: "visitRepeatedUInt64Field"), - 838: .same(proto: "visitSingular"), - 839: .same(proto: "visitSingularBoolField"), - 840: .same(proto: "visitSingularBytesField"), - 841: .same(proto: "visitSingularDoubleField"), - 842: .same(proto: "visitSingularEnumField"), - 843: .same(proto: "visitSingularFixed32Field"), - 844: .same(proto: "visitSingularFixed64Field"), - 845: .same(proto: "visitSingularFloatField"), - 846: .same(proto: "visitSingularGroupField"), - 847: .same(proto: "visitSingularInt32Field"), - 848: .same(proto: "visitSingularInt64Field"), - 849: .same(proto: "visitSingularMessageField"), - 850: .same(proto: "visitSingularSFixed32Field"), - 851: .same(proto: "visitSingularSFixed64Field"), - 852: .same(proto: "visitSingularSInt32Field"), - 853: .same(proto: "visitSingularSInt64Field"), - 854: .same(proto: "visitSingularStringField"), - 855: .same(proto: "visitSingularUInt32Field"), - 856: .same(proto: "visitSingularUInt64Field"), - 857: .same(proto: "visitUnknown"), - 858: .same(proto: "wasDecoded"), - 859: .same(proto: "weak"), - 860: .same(proto: "weakDependency"), - 861: .same(proto: "where"), - 862: .same(proto: "wireFormat"), - 863: .same(proto: "with"), - 864: .same(proto: "withUnsafeBytes"), - 865: .same(proto: "withUnsafeMutableBytes"), - 866: .same(proto: "work"), - 867: .same(proto: "WrappedType"), - 868: .same(proto: "written"), - 869: .same(proto: "yday"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}addPath\0\u{1}adjusted\0\u{1}aggregateValue\0\u{1}allCases\0\u{1}allowAlias\0\u{1}alwaysPrintEnumsAsInts\0\u{1}alwaysPrintInt64sAsNumbers\0\u{1}annotation\0\u{1}any\0\u{1}AnyExtensionField\0\u{1}AnyMessageExtension\0\u{1}AnyMessageStorage\0\u{1}AnyUnpackError\0\u{1}append\0\u{1}appended\0\u{1}appendUIntHex\0\u{1}appendUnknown\0\u{1}areAllInitialized\0\u{1}Array\0\u{1}arrayDepth\0\u{1}arrayLiteral\0\u{1}arraySeparator\0\u{1}as\0\u{1}asciiOpenCurlyBracket\0\u{1}asciiZero\0\u{1}async\0\u{1}AsyncIterator\0\u{1}AsyncIteratorProtocol\0\u{1}AsyncMessageSequence\0\u{1}available\0\u{1}b\0\u{1}Base\0\u{1}base64Values\0\u{1}baseAddress\0\u{1}BaseType\0\u{1}begin\0\u{1}binary\0\u{1}BinaryDecoder\0\u{1}BinaryDecoding\0\u{1}BinaryDecodingError\0\u{1}BinaryDecodingOptions\0\u{1}BinaryDelimited\0\u{1}BinaryEncoder\0\u{1}BinaryEncodingError\0\u{1}BinaryEncodingMessageSetSizeVisitor\0\u{1}BinaryEncodingMessageSetVisitor\0\u{1}BinaryEncodingOptions\0\u{1}BinaryEncodingSizeVisitor\0\u{1}BinaryEncodingVisitor\0\u{1}binaryOptions\0\u{1}binaryProtobufDelimitedMessages\0\u{1}BinaryStreamDecoding\0\u{1}binaryStreamDecodingError\0\u{1}bitPattern\0\u{1}body\0\u{1}Bool\0\u{1}booleanLiteral\0\u{1}BooleanLiteralType\0\u{1}boolValue\0\u{1}buffer\0\u{1}byte\0\u{1}bytecode\0\u{1}BytecodeReader\0\u{1}bytes\0\u{1}bytesInGroup\0\u{1}bytesNeeded\0\u{1}bytesRead\0\u{1}c\0\u{1}canonical\0\u{1}capitalizeNext\0\u{1}cardinality\0\u{1}CaseIterable\0\u{1}castedValue\0\u{1}ccEnableArenas\0\u{1}ccGenericServices\0\u{1}Character\0\u{1}chars\0\u{1}checkProgramFormat\0\u{1}chunk\0\u{1}class\0\u{1}clearAggregateValue\0\u{1}clearAllowAlias\0\u{1}clearBegin\0\u{1}clearCcEnableArenas\0\u{1}clearCcGenericServices\0\u{1}clearClientStreaming\0\u{1}clearCsharpNamespace\0\u{1}clearCtype\0\u{1}clearDebugRedact\0\u{1}clearDefaultSymbolVisibility\0\u{1}clearDefaultValue\0\u{1}clearDeprecated\0\u{1}clearDeprecatedLegacyJsonFieldConflicts\0\u{1}clearDeprecationWarning\0\u{1}clearDoubleValue\0\u{1}clearEdition\0\u{1}clearEditionDeprecated\0\u{1}clearEditionIntroduced\0\u{1}clearEditionRemoved\0\u{1}clearEnd\0\u{1}clearEnforceNamingStyle\0\u{1}clearEnumType\0\u{1}clearExtendee\0\u{1}clearExtensionValue\0\u{1}clearFeatures\0\u{1}clearFeatureSupport\0\u{1}clearFieldPresence\0\u{1}clearFixedFeatures\0\u{1}clearFullName\0\u{1}clearGoPackage\0\u{1}clearIdempotencyLevel\0\u{1}clearIdentifierValue\0\u{1}clearInputType\0\u{1}clearIsExtension\0\u{1}clearJavaGenerateEqualsAndHash\0\u{1}clearJavaGenericServices\0\u{1}clearJavaMultipleFiles\0\u{1}clearJavaOuterClassname\0\u{1}clearJavaPackage\0\u{1}clearJavaStringCheckUtf8\0\u{1}clearJsonFormat\0\u{1}clearJsonName\0\u{1}clearJstype\0\u{1}clearLabel\0\u{1}clearLazy\0\u{1}clearLeadingComments\0\u{1}clearMapEntry\0\u{1}clearMaximumEdition\0\u{1}clearMessageEncoding\0\u{1}clearMessageSetWireFormat\0\u{1}clearMinimumEdition\0\u{1}clearName\0\u{1}clearNamePart\0\u{1}clearNegativeIntValue\0\u{1}clearNoStandardDescriptorAccessor\0\u{1}clearNumber\0\u{1}clearObjcClassPrefix\0\u{1}clearOneofIndex\0\u{1}clearOptimizeFor\0\u{1}clearOptions\0\u{1}clearOutputType\0\u{1}clearOverridableFeatures\0\u{1}clearPackage\0\u{1}clearPacked\0\u{1}clearPhpClassPrefix\0\u{1}clearPhpMetadataNamespace\0\u{1}clearPhpNamespace\0\u{1}clearPositiveIntValue\0\u{1}clearProto3Optional\0\u{1}clearPyGenericServices\0\u{1}clearRemovalError\0\u{1}clearRepeated\0\u{1}clearRepeatedFieldEncoding\0\u{1}clearReserved\0\u{1}clearRetention\0\u{1}clearRubyPackage\0\u{1}clearSemantic\0\u{1}clearServerStreaming\0\u{1}clearSourceCodeInfo\0\u{1}clearSourceContext\0\u{1}clearSourceFile\0\u{1}clearStart\0\u{1}clearStringValue\0\u{1}clearSwiftPrefix\0\u{1}clearSyntax\0\u{1}clearTrailingComments\0\u{1}clearType\0\u{1}clearTypeName\0\u{1}clearUnverifiedLazy\0\u{1}clearUtf8Validation\0\u{1}clearValue\0\u{1}clearVerification\0\u{1}clearVisibility\0\u{1}clearWeak\0\u{1}clientStreaming\0\u{1}code\0\u{1}codePoint\0\u{1}codeUnits\0\u{1}Collection\0\u{1}comma\0\u{1}consumedBytes\0\u{1}contains\0\u{1}contentsOf\0\u{1}ContiguousBytes\0\u{1}copy\0\u{1}count\0\u{1}countVarintsInBuffer\0\u{1}csharpNamespace\0\u{1}ctype\0\u{1}customCodable\0\u{1}CustomDebugStringConvertible\0\u{1}CustomStringConvertible\0\u{1}D\0\u{1}Data\0\u{1}dataResult\0\u{1}date\0\u{1}daySec\0\u{1}daysSinceEpoch\0\u{1}debugDescription\0\u{1}debugRedact\0\u{1}declaration\0\u{1}decoded\0\u{1}decodedFromJSONNull\0\u{1}decodeExtensionField\0\u{1}decodeExtensionFieldsAsMessageSet\0\u{1}decodeJSON\0\u{1}decodeMapField\0\u{1}decodeMessage\0\u{1}Decoder\0\u{1}decodeRepeated\0\u{1}decodeRepeatedBoolField\0\u{1}decodeRepeatedBytesField\0\u{1}decodeRepeatedDoubleField\0\u{1}decodeRepeatedEnumField\0\u{1}decodeRepeatedFixed32Field\0\u{1}decodeRepeatedFixed64Field\0\u{1}decodeRepeatedFloatField\0\u{1}decodeRepeatedGroupField\0\u{1}decodeRepeatedInt32Field\0\u{1}decodeRepeatedInt64Field\0\u{1}decodeRepeatedMessageField\0\u{1}decodeRepeatedSFixed32Field\0\u{1}decodeRepeatedSFixed64Field\0\u{1}decodeRepeatedSInt32Field\0\u{1}decodeRepeatedSInt64Field\0\u{1}decodeRepeatedStringField\0\u{1}decodeRepeatedUInt32Field\0\u{1}decodeRepeatedUInt64Field\0\u{1}decodeSingular\0\u{1}decodeSingularBoolField\0\u{1}decodeSingularBytesField\0\u{1}decodeSingularDoubleField\0\u{1}decodeSingularEnumField\0\u{1}decodeSingularFixed32Field\0\u{1}decodeSingularFixed64Field\0\u{1}decodeSingularFloatField\0\u{1}decodeSingularGroupField\0\u{1}decodeSingularInt32Field\0\u{1}decodeSingularInt64Field\0\u{1}decodeSingularMessageField\0\u{1}decodeSingularSFixed32Field\0\u{1}decodeSingularSFixed64Field\0\u{1}decodeSingularSInt32Field\0\u{1}decodeSingularSInt64Field\0\u{1}decodeSingularStringField\0\u{1}decodeSingularUInt32Field\0\u{1}decodeSingularUInt64Field\0\u{1}decodeTextFormat\0\u{1}defaultAnyTypeURLPrefix\0\u{1}defaults\0\u{1}defaultSymbolVisibility\0\u{1}defaultValue\0\u{1}dependency\0\u{1}deprecated\0\u{1}deprecatedLegacyJsonFieldConflicts\0\u{1}deprecationWarning\0\u{1}description\0\u{1}Dictionary\0\u{1}dictionaryLiteral\0\u{1}digit\0\u{1}digit0\0\u{1}digit1\0\u{1}digitCount\0\u{1}digits\0\u{1}digitValue\0\u{1}discardableResult\0\u{1}discardUnknownFields\0\u{1}Double\0\u{1}doubleValue\0\u{1}duration\0\u{1}E\0\u{1}edition\0\u{1}EditionDefault\0\u{1}editionDefaults\0\u{1}editionDeprecated\0\u{1}editionIntroduced\0\u{1}editionRemoved\0\u{1}Element\0\u{1}elements\0\u{1}else\0\u{1}emitExtensionFieldName\0\u{1}emitFieldName\0\u{1}emitFieldNumber\0\u{1}emptyAnyTypeURL\0\u{1}emptyData\0\u{1}encodeAsBytes\0\u{1}encoded\0\u{1}encodedJSONString\0\u{1}encodedSize\0\u{1}encodeField\0\u{1}encoder\0\u{1}end\0\u{1}endArray\0\u{1}endMessageField\0\u{1}endObject\0\u{1}endRegularField\0\u{1}enforceNamingStyle\0\u{1}enum\0\u{1}EnumReservedRange\0\u{1}enumType\0\u{1}enumvalue\0\u{1}Equatable\0\u{1}Error\0\u{1}execute\0\u{1}ExpressibleByArrayLiteral\0\u{1}ExpressibleByDictionaryLiteral\0\u{1}ext\0\u{1}extDecoder\0\u{1}extendedGraphemeClusterLiteral\0\u{1}ExtendedGraphemeClusterLiteralType\0\u{1}extendee\0\u{1}ExtensibleMessage\0\u{1}extension\0\u{1}ExtensionField\0\u{1}extensionFieldNumber\0\u{1}ExtensionFieldValueSet\0\u{1}ExtensionMap\0\u{1}extensionRange\0\u{1}extensions\0\u{1}extras\0\u{1}F\0\u{1}false\0\u{1}features\0\u{1}FeatureSetEditionDefault\0\u{1}featureSupport\0\u{1}field\0\u{1}fieldData\0\u{1}FieldMaskError\0\u{1}fieldName\0\u{1}fieldNameCount\0\u{1}fieldNum\0\u{1}fieldNumber\0\u{1}fieldNumberForProto\0\u{1}fieldPresence\0\u{1}fields\0\u{1}fieldSize\0\u{1}FieldTag\0\u{1}FieldType\0\u{1}file\0\u{1}fileName\0\u{1}filter\0\u{1}final\0\u{1}finiteOnly\0\u{1}first\0\u{1}firstItem\0\u{1}fixedFeatures\0\u{1}Float\0\u{1}floatLiteral\0\u{1}FloatLiteralType\0\u{1}for\0\u{1}forMessageName\0\u{1}formUnion\0\u{1}forReadingFrom\0\u{1}forTypeURL\0\u{1}ForwardParser\0\u{1}forWritingInto\0\u{1}from\0\u{1}fromAscii2\0\u{1}fromAscii4\0\u{1}fromByteOffset\0\u{1}fromHexDigit\0\u{1}fullName\0\u{1}func\0\u{1}function\0\u{1}G\0\u{1}get\0\u{1}getExtensionValue\0\u{3}Google_Protobuf_Any\0\u{3}Google_Protobuf_Api\0\u{3}Google_Protobuf_BoolValue\0\u{3}Google_Protobuf_BytesValue\0\u{3}Google_Protobuf_DescriptorProto\0\u{3}Google_Protobuf_DoubleValue\0\u{3}Google_Protobuf_Duration\0\u{3}Google_Protobuf_Edition\0\u{3}Google_Protobuf_Empty\0\u{3}Google_Protobuf_Enum\0\u{3}Google_Protobuf_EnumDescriptorProto\0\u{3}Google_Protobuf_EnumOptions\0\u{3}Google_Protobuf_EnumValue\0\u{3}Google_Protobuf_EnumValueDescriptorProto\0\u{3}Google_Protobuf_EnumValueOptions\0\u{3}Google_Protobuf_ExtensionRangeOptions\0\u{3}Google_Protobuf_FeatureSet\0\u{3}Google_Protobuf_FeatureSetDefaults\0\u{3}Google_Protobuf_Field\0\u{3}Google_Protobuf_FieldDescriptorProto\0\u{3}Google_Protobuf_FieldMask\0\u{3}Google_Protobuf_FieldOptions\0\u{3}Google_Protobuf_FileDescriptorProto\0\u{3}Google_Protobuf_FileDescriptorSet\0\u{3}Google_Protobuf_FileOptions\0\u{3}Google_Protobuf_FloatValue\0\u{3}Google_Protobuf_GeneratedCodeInfo\0\u{3}Google_Protobuf_Int32Value\0\u{3}Google_Protobuf_Int64Value\0\u{3}Google_Protobuf_ListValue\0\u{3}Google_Protobuf_MessageOptions\0\u{3}Google_Protobuf_Method\0\u{3}Google_Protobuf_MethodDescriptorProto\0\u{3}Google_Protobuf_MethodOptions\0\u{3}Google_Protobuf_Mixin\0\u{3}Google_Protobuf_NullValue\0\u{3}Google_Protobuf_OneofDescriptorProto\0\u{3}Google_Protobuf_OneofOptions\0\u{3}Google_Protobuf_Option\0\u{3}Google_Protobuf_ServiceDescriptorProto\0\u{3}Google_Protobuf_ServiceOptions\0\u{3}Google_Protobuf_SourceCodeInfo\0\u{3}Google_Protobuf_SourceContext\0\u{3}Google_Protobuf_StringValue\0\u{3}Google_Protobuf_Struct\0\u{3}Google_Protobuf_SymbolVisibility\0\u{3}Google_Protobuf_Syntax\0\u{3}Google_Protobuf_Timestamp\0\u{3}Google_Protobuf_Type\0\u{3}Google_Protobuf_UInt32Value\0\u{3}Google_Protobuf_UInt64Value\0\u{3}Google_Protobuf_UninterpretedOption\0\u{3}Google_Protobuf_Value\0\u{1}goPackage\0\u{1}gotData\0\u{1}group\0\u{1}groupFieldNumberStack\0\u{1}groupSize\0\u{1}guard\0\u{1}hadOneofValue\0\u{1}handleConflictingOneOf\0\u{1}handleInstruction\0\u{1}hasAggregateValue\0\u{1}hasAllowAlias\0\u{1}hasBegin\0\u{1}hasCcEnableArenas\0\u{1}hasCcGenericServices\0\u{1}hasClientStreaming\0\u{1}hasCsharpNamespace\0\u{1}hasCtype\0\u{1}hasData\0\u{1}hasDebugRedact\0\u{1}hasDefaultSymbolVisibility\0\u{1}hasDefaultValue\0\u{1}hasDeprecated\0\u{1}hasDeprecatedLegacyJsonFieldConflicts\0\u{1}hasDeprecationWarning\0\u{1}hasDoubleValue\0\u{1}hasEdition\0\u{1}hasEditionDeprecated\0\u{1}hasEditionIntroduced\0\u{1}hasEditionRemoved\0\u{1}hasEnd\0\u{1}hasEnforceNamingStyle\0\u{1}hasEnumType\0\u{1}hasExplicitDelta\0\u{1}hasExtendee\0\u{1}hasExtensionValue\0\u{1}hasFeatures\0\u{1}hasFeatureSupport\0\u{1}hasFieldPresence\0\u{1}hasFixedFeatures\0\u{1}hasFullName\0\u{1}hasGoPackage\0\u{1}hash\0\u{1}Hashable\0\u{1}hasher\0\u{1}HashVisitor\0\u{1}hasIdempotencyLevel\0\u{1}hasIdentifierValue\0\u{1}hasInputType\0\u{1}hasIsExtension\0\u{1}hasJavaGenerateEqualsAndHash\0\u{1}hasJavaGenericServices\0\u{1}hasJavaMultipleFiles\0\u{1}hasJavaOuterClassname\0\u{1}hasJavaPackage\0\u{1}hasJavaStringCheckUtf8\0\u{1}hasJsonFormat\0\u{1}hasJsonName\0\u{1}hasJstype\0\u{1}hasLabel\0\u{1}hasLazy\0\u{1}hasLeadingComments\0\u{1}hasMapEntry\0\u{1}hasMaximumEdition\0\u{1}hasMessageEncoding\0\u{1}hasMessageSetWireFormat\0\u{1}hasMinimumEdition\0\u{1}hasName\0\u{1}hasNamePart\0\u{1}hasNegativeIntValue\0\u{1}hasNoStandardDescriptorAccessor\0\u{1}hasNumber\0\u{1}hasObjcClassPrefix\0\u{1}hasOneofIndex\0\u{1}hasOptimizeFor\0\u{1}hasOptions\0\u{1}hasOutputType\0\u{1}hasOverridableFeatures\0\u{1}hasPackage\0\u{1}hasPacked\0\u{1}hasPhpClassPrefix\0\u{1}hasPhpMetadataNamespace\0\u{1}hasPhpNamespace\0\u{1}hasPositiveIntValue\0\u{1}hasProto3Optional\0\u{1}hasPyGenericServices\0\u{1}hasRemovalError\0\u{1}hasRepeated\0\u{1}hasRepeatedFieldEncoding\0\u{1}hasReserved\0\u{1}hasRetention\0\u{1}hasRubyPackage\0\u{1}hasSemantic\0\u{1}hasServerStreaming\0\u{1}hasSourceCodeInfo\0\u{1}hasSourceContext\0\u{1}hasSourceFile\0\u{1}hasStart\0\u{1}hasStringValue\0\u{1}hasSwiftPrefix\0\u{1}hasSyntax\0\u{1}hasTrailingComments\0\u{1}hasType\0\u{1}hasTypeName\0\u{1}hasUnverifiedLazy\0\u{1}hasUtf8Validation\0\u{1}hasValue\0\u{1}hasVerification\0\u{1}hasVisibility\0\u{1}hasWeak\0\u{1}hour\0\u{1}i\0\u{1}idempotencyLevel\0\u{1}identifierValue\0\u{1}if\0\u{1}ignoreUnknownExtensionFields\0\u{1}ignoreUnknownFields\0\u{1}index\0\u{1}init\0\u{1}inout\0\u{1}inputType\0\u{1}insert\0\u{1}Instruction\0\u{1}Int\0\u{1}Int32\0\u{1}Int64\0\u{1}Int8\0\u{1}integerLiteral\0\u{1}IntegerLiteralType\0\u{1}intern\0\u{1}Internal\0\u{1}InternalState\0\u{1}intersect\0\u{1}into\0\u{1}ints\0\u{1}invalidAnyTypeURL\0\u{1}isA\0\u{1}isEqual\0\u{1}isEqualTo\0\u{1}isExtension\0\u{1}isInitialized\0\u{1}isNegative\0\u{1}isPathValid\0\u{1}isReserved\0\u{1}isValid\0\u{1}itemTagsEncodedSize\0\u{1}iterator\0\u{1}javaGenerateEqualsAndHash\0\u{1}javaGenericServices\0\u{1}javaMultipleFiles\0\u{1}javaOuterClassname\0\u{1}javaPackage\0\u{1}javaStringCheckUtf8\0\u{1}JSONDecoder\0\u{1}JSONDecoding\0\u{1}JSONDecodingError\0\u{1}JSONDecodingOptions\0\u{1}jsonEncoder\0\u{1}JSONEncoding\0\u{1}JSONEncodingError\0\u{1}JSONEncodingOptions\0\u{1}JSONEncodingVisitor\0\u{1}jsonFormat\0\u{1}JSONMapEncodingVisitor\0\u{1}jsonName\0\u{1}jsonPath\0\u{1}jsonPaths\0\u{1}JSONScanner\0\u{1}jsonString\0\u{1}jsonText\0\u{1}jsonUTF8Bytes\0\u{1}jsonUTF8Data\0\u{1}jstype\0\u{1}k\0\u{1}kChunkSize\0\u{1}Key\0\u{1}keyField\0\u{1}keyFieldOpt\0\u{1}KeyType\0\u{1}kind\0\u{1}l\0\u{1}label\0\u{1}lazy\0\u{1}leadingComments\0\u{1}leadingDetachedComments\0\u{1}length\0\u{1}lessThan\0\u{1}let\0\u{1}lhs\0\u{1}line\0\u{1}list\0\u{1}listOfMessages\0\u{1}listValue\0\u{1}littleEndian\0\u{1}load\0\u{1}localHasher\0\u{1}location\0\u{1}M\0\u{1}major\0\u{1}makeAsyncIterator\0\u{1}makeIterator\0\u{1}malformedLength\0\u{1}mapEntry\0\u{1}MapKeyType\0\u{1}mapToMessages\0\u{1}MapValueType\0\u{1}mapVisitor\0\u{1}mask\0\u{1}maximumEdition\0\u{1}mdayStart\0\u{1}merge\0\u{1}MergeOptions\0\u{1}message\0\u{1}messageDepthLimit\0\u{1}messageEncoding\0\u{1}MessageExtension\0\u{1}MessageImplementationBase\0\u{1}MessageSet\0\u{1}messageSetWireFormat\0\u{1}messageSize\0\u{1}messageType\0\u{1}method\0\u{1}methods\0\u{1}min\0\u{1}minimumEdition\0\u{1}minor\0\u{1}mixins\0\u{1}modify\0\u{1}month\0\u{1}msgExtension\0\u{1}mutating\0\u{1}n\0\u{1}name\0\u{1}NameDescription\0\u{1}NameMap\0\u{1}NamePart\0\u{1}names\0\u{1}nanos\0\u{1}negativeIntValue\0\u{1}nestedType\0\u{1}newExtensible\0\u{1}newL\0\u{1}newList\0\u{1}newMessage\0\u{1}newValue\0\u{1}next\0\u{1}nextByte\0\u{1}nextFieldNumber\0\u{1}nextInstruction\0\u{1}nextInt32\0\u{1}nextNullTerminatedString\0\u{1}nextNullTerminatedStringArray\0\u{1}nextNumber\0\u{1}nextUInt64\0\u{1}nextVarInt\0\u{1}nil\0\u{1}nilLiteral\0\u{1}noBytesAvailable\0\u{1}noStandardDescriptorAccessor\0\u{1}nullValue\0\u{1}number\0\u{1}numberValue\0\u{1}objcClassPrefix\0\u{1}of\0\u{3}OneOf_Kind\0\u{1}oneofDecl\0\u{1}oneofIndex\0\u{1}oneofs\0\u{1}optimizeFor\0\u{1}OptimizeMode\0\u{1}OptionalEnumExtensionField\0\u{1}OptionalExtensionField\0\u{1}OptionalGroupExtensionField\0\u{1}OptionalMessageExtensionField\0\u{1}optionDependency\0\u{1}OptionRetention\0\u{1}options\0\u{1}OptionTargetType\0\u{1}other\0\u{1}others\0\u{1}out\0\u{1}outputType\0\u{1}overridableFeatures\0\u{1}p\0\u{1}package\0\u{1}packed\0\u{1}PackedEnumExtensionField\0\u{1}PackedExtensionField\0\u{1}padding\0\u{1}parent\0\u{1}parse\0\u{1}partial\0\u{1}path\0\u{1}PathDecoder\0\u{1}PathDecodingError\0\u{1}paths\0\u{1}PathVisitor\0\u{1}payload\0\u{1}payloadSize\0\u{1}phpClassPrefix\0\u{1}phpMetadataNamespace\0\u{1}phpNamespace\0\u{1}pos\0\u{1}positiveIntValue\0\u{1}prefix\0\u{1}preserveProtoFieldNames\0\u{1}preTraverse\0\u{1}previousNumber\0\u{1}prevPath\0\u{1}printUnknownFields\0\u{1}programBuffer\0\u{1}programFormat\0\u{1}proto2\0\u{1}proto3DefaultValue\0\u{1}proto3Optional\0\u{3}protobuf_extensionFieldValues\0\u{3}protobuf_fieldNumber\0\u{3}protobuf_generated_isEqualTo\0\u{3}protobuf_nameMap\0\u{3}protobuf_newField\0\u{3}protobuf_package\0\u{3}ProtobufAPIVersion_2\0\u{1}ProtobufAPIVersionCheck\0\u{1}ProtobufBool\0\u{1}ProtobufBytes\0\u{1}protobufData\0\u{1}ProtobufDouble\0\u{1}ProtobufEnumMap\0\u{1}protobufExtension\0\u{1}ProtobufFixed32\0\u{1}ProtobufFixed64\0\u{1}ProtobufFloat\0\u{1}ProtobufInt32\0\u{1}ProtobufInt64\0\u{1}ProtobufMap\0\u{1}ProtobufMessageMap\0\u{1}ProtobufSFixed32\0\u{1}ProtobufSFixed64\0\u{1}ProtobufSInt32\0\u{1}ProtobufSInt64\0\u{1}ProtobufString\0\u{1}ProtobufUInt32\0\u{1}ProtobufUInt64\0\u{1}protocol\0\u{1}protoFieldName\0\u{1}protoMessageName\0\u{1}ProtoNameProviding\0\u{1}protoPaths\0\u{1}public\0\u{1}publicDependency\0\u{1}putBoolValue\0\u{1}putBytesValue\0\u{1}putDoubleValue\0\u{1}putEnumValue\0\u{1}putFixedUInt32\0\u{1}putFixedUInt64\0\u{1}putFloatValue\0\u{1}putInt64\0\u{1}putStringValue\0\u{1}putUInt64\0\u{1}putUInt64Hex\0\u{1}putVarInt\0\u{1}putZigZagVarInt\0\u{1}pyGenericServices\0\u{1}R\0\u{1}rawChars\0\u{1}RawRepresentable\0\u{1}RawValue\0\u{1}read4HexDigits\0\u{1}readBytes\0\u{1}reader\0\u{1}register\0\u{1}remainingProgram\0\u{1}removalError\0\u{1}removingAllFieldsOf\0\u{1}repeated\0\u{1}RepeatedEnumExtensionField\0\u{1}RepeatedExtensionField\0\u{1}repeatedFieldEncoding\0\u{1}RepeatedGroupExtensionField\0\u{1}RepeatedMessageExtensionField\0\u{1}repeating\0\u{1}replaceRepeatedFields\0\u{1}requestStreaming\0\u{1}requestTypeURL\0\u{1}requiredSize\0\u{1}responseStreaming\0\u{1}responseTypeURL\0\u{1}result\0\u{1}retention\0\u{1}rethrows\0\u{1}ReturnType\0\u{1}revision\0\u{1}rhs\0\u{1}root\0\u{1}rubyPackage\0\u{1}s\0\u{1}sawBackslash\0\u{1}sawSection4Characters\0\u{1}sawSection5Characters\0\u{1}Scalar\0\u{1}scan\0\u{1}scanner\0\u{1}seconds\0\u{1}self\0\u{1}semantic\0\u{1}Sendable\0\u{1}separator\0\u{1}serialize\0\u{1}serializedBytes\0\u{1}serializedData\0\u{1}serializedSize\0\u{1}serverStreaming\0\u{1}service\0\u{1}set\0\u{1}setExtensionValue\0\u{1}shift\0\u{1}SimpleExtensionMap\0\u{1}size\0\u{1}sizer\0\u{1}source\0\u{1}sourceCodeInfo\0\u{1}sourceContext\0\u{1}sourceEncoding\0\u{1}sourceFile\0\u{1}SourceLocation\0\u{1}span\0\u{1}split\0\u{1}start\0\u{1}startArray\0\u{1}startArrayObject\0\u{1}startField\0\u{1}startIndex\0\u{1}startMessageField\0\u{1}startObject\0\u{1}startRegularField\0\u{1}state\0\u{1}static\0\u{1}StaticString\0\u{1}storage\0\u{1}String\0\u{1}stringLiteral\0\u{1}StringLiteralType\0\u{1}stringResult\0\u{1}stringValue\0\u{1}struct\0\u{1}structValue\0\u{1}subDecoder\0\u{1}subscript\0\u{1}subtract\0\u{1}subVisitor\0\u{1}Swift\0\u{1}swiftPrefix\0\u{1}SwiftProtobufContiguousBytes\0\u{1}SwiftProtobufError\0\u{1}syntax\0\u{1}T\0\u{1}tag\0\u{1}targets\0\u{1}terminator\0\u{1}testDecoder\0\u{1}text\0\u{1}textDecoder\0\u{1}TextFormatDecoder\0\u{1}TextFormatDecodingError\0\u{1}TextFormatDecodingOptions\0\u{1}TextFormatEncodingOptions\0\u{1}TextFormatEncodingVisitor\0\u{1}textFormatString\0\u{1}throwOrIgnore\0\u{1}throws\0\u{1}timeInterval\0\u{1}timeIntervalSince1970\0\u{1}timeIntervalSinceReferenceDate\0\u{1}tmp\0\u{1}tooLarge\0\u{1}total\0\u{1}totalArrayDepth\0\u{1}totalSize\0\u{1}trailingComments\0\u{1}traverse\0\u{1}trim\0\u{1}true\0\u{1}try\0\u{1}type\0\u{1}typealias\0\u{1}TypeEnum\0\u{1}typeName\0\u{1}typePrefix\0\u{1}typeStart\0\u{1}typeUnknown\0\u{1}typeURL\0\u{1}UInt32\0\u{1}UInt64\0\u{1}UInt8\0\u{1}unchecked\0\u{1}Unicode\0\u{1}unicodeScalarLiteral\0\u{1}UnicodeScalarLiteralType\0\u{1}unicodeScalars\0\u{1}UnicodeScalarView\0\u{1}uninterpretedOption\0\u{1}union\0\u{1}uniqueStorage\0\u{1}unknown\0\u{1}unknownFields\0\u{1}UnknownStorage\0\u{1}unpackTo\0\u{1}UnsafeBufferPointer\0\u{1}UnsafeMutablePointer\0\u{1}UnsafeMutableRawBufferPointer\0\u{1}UnsafeRawBufferPointer\0\u{1}UnsafeRawPointer\0\u{1}unverifiedLazy\0\u{1}updatedOptions\0\u{1}uppercasedAssumingASCII\0\u{1}url\0\u{1}useDeterministicOrdering\0\u{1}utf8\0\u{1}utf8Ptr\0\u{1}utf8ToDouble\0\u{1}utf8Validation\0\u{1}UTF8View\0\u{1}V\0\u{1}value\0\u{1}valueField\0\u{1}values\0\u{1}ValueType\0\u{1}var\0\u{1}verification\0\u{1}VerificationState\0\u{1}version\0\u{1}versionString\0\u{1}visibility\0\u{1}VisibilityFeature\0\u{1}visitExtensionFields\0\u{1}visitExtensionFieldsAsMessageSet\0\u{1}visitMapField\0\u{1}Visitor\0\u{1}visitPacked\0\u{1}visitPackedBoolField\0\u{1}visitPackedDoubleField\0\u{1}visitPackedEnumField\0\u{1}visitPackedFixed32Field\0\u{1}visitPackedFixed64Field\0\u{1}visitPackedFloatField\0\u{1}visitPackedInt32Field\0\u{1}visitPackedInt64Field\0\u{1}visitPackedSFixed32Field\0\u{1}visitPackedSFixed64Field\0\u{1}visitPackedSInt32Field\0\u{1}visitPackedSInt64Field\0\u{1}visitPackedUInt32Field\0\u{1}visitPackedUInt64Field\0\u{1}visitRepeated\0\u{1}visitRepeatedBoolField\0\u{1}visitRepeatedBytesField\0\u{1}visitRepeatedDoubleField\0\u{1}visitRepeatedEnumField\0\u{1}visitRepeatedFixed32Field\0\u{1}visitRepeatedFixed64Field\0\u{1}visitRepeatedFloatField\0\u{1}visitRepeatedGroupField\0\u{1}visitRepeatedInt32Field\0\u{1}visitRepeatedInt64Field\0\u{1}visitRepeatedMessageField\0\u{1}visitRepeatedSFixed32Field\0\u{1}visitRepeatedSFixed64Field\0\u{1}visitRepeatedSInt32Field\0\u{1}visitRepeatedSInt64Field\0\u{1}visitRepeatedStringField\0\u{1}visitRepeatedUInt32Field\0\u{1}visitRepeatedUInt64Field\0\u{1}visitSingular\0\u{1}visitSingularBoolField\0\u{1}visitSingularBytesField\0\u{1}visitSingularDoubleField\0\u{1}visitSingularEnumField\0\u{1}visitSingularFixed32Field\0\u{1}visitSingularFixed64Field\0\u{1}visitSingularFloatField\0\u{1}visitSingularGroupField\0\u{1}visitSingularInt32Field\0\u{1}visitSingularInt64Field\0\u{1}visitSingularMessageField\0\u{1}visitSingularSFixed32Field\0\u{1}visitSingularSFixed64Field\0\u{1}visitSingularSInt32Field\0\u{1}visitSingularSInt64Field\0\u{1}visitSingularStringField\0\u{1}visitSingularUInt32Field\0\u{1}visitSingularUInt64Field\0\u{1}visitUnknown\0\u{1}Void\0\u{1}wasDecoded\0\u{1}weak\0\u{1}weakDependency\0\u{1}where\0\u{1}wireFormat\0\u{1}with\0\u{1}withUnsafeBytes\0\u{1}withUnsafeMutableBytes\0\u{1}work\0\u{1}Wrapped\0\u{1}WrappedType\0\u{1}wrappedValue\0\u{1}written\0\u{1}yday\0") fileprivate class _StorageClass { + var _addPath: Int32 = 0 var _adjusted: Int32 = 0 var _aggregateValue: Int32 = 0 var _allCases: Int32 = 0 var _allowAlias: Int32 = 0 var _alwaysPrintEnumsAsInts: Int32 = 0 + var _alwaysPrintInt64SAsNumbers: Int32 = 0 var _annotation: Int32 = 0 var _any: Int32 = 0 var _anyExtensionField: Int32 = 0 var _anyMessageExtension: Int32 = 0 var _anyMessageStorage: Int32 = 0 var _anyUnpackError: Int32 = 0 - var _api: Int32 = 0 + var _append: Int32 = 0 var _appended: Int32 = 0 var _appendUintHex: Int32 = 0 var _appendUnknown: Int32 = 0 @@ -5287,14 +5205,20 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _as: Int32 = 0 var _asciiOpenCurlyBracket: Int32 = 0 var _asciiZero: Int32 = 0 + var _async: Int32 = 0 + var _asyncIterator: Int32 = 0 + var _asyncIteratorProtocol: Int32 = 0 + var _asyncMessageSequence: Int32 = 0 var _available: Int32 = 0 var _b: Int32 = 0 + var _base: Int32 = 0 var _base64Values: Int32 = 0 var _baseAddress: Int32 = 0 var _baseType: Int32 = 0 var _begin: Int32 = 0 var _binary: Int32 = 0 var _binaryDecoder: Int32 = 0 + var _binaryDecoding: Int32 = 0 var _binaryDecodingError: Int32 = 0 var _binaryDecodingOptions: Int32 = 0 var _binaryDelimited: Int32 = 0 @@ -5302,25 +5226,39 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _binaryEncodingError: Int32 = 0 var _binaryEncodingMessageSetSizeVisitor: Int32 = 0 var _binaryEncodingMessageSetVisitor: Int32 = 0 + var _binaryEncodingOptions: Int32 = 0 var _binaryEncodingSizeVisitor: Int32 = 0 var _binaryEncodingVisitor: Int32 = 0 var _binaryOptions: Int32 = 0 + var _binaryProtobufDelimitedMessages: Int32 = 0 + var _binaryStreamDecoding: Int32 = 0 + var _binaryStreamDecodingError: Int32 = 0 + var _bitPattern: Int32 = 0 var _body: Int32 = 0 var _bool: Int32 = 0 var _booleanLiteral: Int32 = 0 var _booleanLiteralType: Int32 = 0 var _boolValue: Int32 = 0 + var _buffer: Int32 = 0 + var _byte: Int32 = 0 + var _bytecode: Int32 = 0 + var _bytecodeReader: Int32 = 0 var _bytes: Int32 = 0 var _bytesInGroup: Int32 = 0 + var _bytesNeeded: Int32 = 0 var _bytesRead: Int32 = 0 - var _bytesValue: Int32 = 0 var _c: Int32 = 0 + var _canonical: Int32 = 0 var _capitalizeNext: Int32 = 0 var _cardinality: Int32 = 0 + var _caseIterable: Int32 = 0 + var _castedValue: Int32 = 0 var _ccEnableArenas: Int32 = 0 var _ccGenericServices: Int32 = 0 var _character: Int32 = 0 var _chars: Int32 = 0 + var _checkProgramFormat: Int32 = 0 + var _chunk: Int32 = 0 var _class: Int32 = 0 var _clearAggregateValue_p: Int32 = 0 var _clearAllowAlias_p: Int32 = 0 @@ -5330,12 +5268,27 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _clearClientStreaming_p: Int32 = 0 var _clearCsharpNamespace_p: Int32 = 0 var _clearCtype_p: Int32 = 0 + var _clearDebugRedact_p: Int32 = 0 + var _clearDefaultSymbolVisibility_p: Int32 = 0 var _clearDefaultValue_p: Int32 = 0 var _clearDeprecated_p: Int32 = 0 + var _clearDeprecatedLegacyJsonFieldConflicts_p: Int32 = 0 + var _clearDeprecationWarning_p: Int32 = 0 var _clearDoubleValue_p: Int32 = 0 + var _clearEdition_p: Int32 = 0 + var _clearEditionDeprecated_p: Int32 = 0 + var _clearEditionIntroduced_p: Int32 = 0 + var _clearEditionRemoved_p: Int32 = 0 var _clearEnd_p: Int32 = 0 + var _clearEnforceNamingStyle_p: Int32 = 0 + var _clearEnumType_p: Int32 = 0 var _clearExtendee_p: Int32 = 0 var _clearExtensionValue_p: Int32 = 0 + var _clearFeatures_p: Int32 = 0 + var _clearFeatureSupport_p: Int32 = 0 + var _clearFieldPresence_p: Int32 = 0 + var _clearFixedFeatures_p: Int32 = 0 + var _clearFullName_p: Int32 = 0 var _clearGoPackage_p: Int32 = 0 var _clearIdempotencyLevel_p: Int32 = 0 var _clearIdentifierValue_p: Int32 = 0 @@ -5347,13 +5300,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _clearJavaOuterClassname_p: Int32 = 0 var _clearJavaPackage_p: Int32 = 0 var _clearJavaStringCheckUtf8_p: Int32 = 0 + var _clearJsonFormat_p: Int32 = 0 var _clearJsonName_p: Int32 = 0 var _clearJstype_p: Int32 = 0 var _clearLabel_p: Int32 = 0 var _clearLazy_p: Int32 = 0 var _clearLeadingComments_p: Int32 = 0 var _clearMapEntry_p: Int32 = 0 + var _clearMaximumEdition_p: Int32 = 0 + var _clearMessageEncoding_p: Int32 = 0 var _clearMessageSetWireFormat_p: Int32 = 0 + var _clearMinimumEdition_p: Int32 = 0 var _clearName_p: Int32 = 0 var _clearNamePart_p: Int32 = 0 var _clearNegativeIntValue_p: Int32 = 0 @@ -5364,16 +5321,22 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _clearOptimizeFor_p: Int32 = 0 var _clearOptions_p: Int32 = 0 var _clearOutputType_p: Int32 = 0 + var _clearOverridableFeatures_p: Int32 = 0 var _clearPackage_p: Int32 = 0 var _clearPacked_p: Int32 = 0 var _clearPhpClassPrefix_p: Int32 = 0 - var _clearPhpGenericServices_p: Int32 = 0 var _clearPhpMetadataNamespace_p: Int32 = 0 var _clearPhpNamespace_p: Int32 = 0 var _clearPositiveIntValue_p: Int32 = 0 var _clearProto3Optional_p: Int32 = 0 var _clearPyGenericServices_p: Int32 = 0 + var _clearRemovalError_p: Int32 = 0 + var _clearRepeated_p: Int32 = 0 + var _clearRepeatedFieldEncoding_p: Int32 = 0 + var _clearReserved_p: Int32 = 0 + var _clearRetention_p: Int32 = 0 var _clearRubyPackage_p: Int32 = 0 + var _clearSemantic_p: Int32 = 0 var _clearServerStreaming_p: Int32 = 0 var _clearSourceCodeInfo_p: Int32 = 0 var _clearSourceContext_p: Int32 = 0 @@ -5385,22 +5348,30 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _clearTrailingComments_p: Int32 = 0 var _clearType_p: Int32 = 0 var _clearTypeName_p: Int32 = 0 + var _clearUnverifiedLazy_p: Int32 = 0 + var _clearUtf8Validation_p: Int32 = 0 var _clearValue_p: Int32 = 0 + var _clearVerification_p: Int32 = 0 + var _clearVisibility_p: Int32 = 0 var _clearWeak_p: Int32 = 0 var _clientStreaming: Int32 = 0 + var _code: Int32 = 0 var _codePoint: Int32 = 0 var _codeUnits: Int32 = 0 var _collection: Int32 = 0 - var _com: Int32 = 0 var _comma: Int32 = 0 + var _consumedBytes: Int32 = 0 + var _contains: Int32 = 0 var _contentsOf: Int32 = 0 var _contiguousBytes: Int32 = 0 + var _copy: Int32 = 0 var _count: Int32 = 0 var _countVarintsInBuffer: Int32 = 0 var _csharpNamespace: Int32 = 0 var _ctype: Int32 = 0 var _customCodable: Int32 = 0 var _customDebugStringConvertible: Int32 = 0 + var _customStringConvertible: Int32 = 0 var _d: Int32 = 0 var _data: Int32 = 0 var _dataResult: Int32 = 0 @@ -5408,6 +5379,8 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _daySec: Int32 = 0 var _daysSinceEpoch: Int32 = 0 var _debugDescription_p: Int32 = 0 + var _debugRedact: Int32 = 0 + var _declaration: Int32 = 0 var _decoded: Int32 = 0 var _decodedFromJsonnull: Int32 = 0 var _decodeExtensionField: Int32 = 0 @@ -5456,11 +5429,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _decodeSingularUint64Field: Int32 = 0 var _decodeTextFormat: Int32 = 0 var _defaultAnyTypeUrlprefix: Int32 = 0 + var _defaults: Int32 = 0 + var _defaultSymbolVisibility: Int32 = 0 var _defaultValue: Int32 = 0 var _dependency: Int32 = 0 var _deprecated: Int32 = 0 + var _deprecatedLegacyJsonFieldConflicts: Int32 = 0 + var _deprecationWarning: Int32 = 0 var _description_p: Int32 = 0 - var _descriptorProto: Int32 = 0 var _dictionary: Int32 = 0 var _dictionaryLiteral: Int32 = 0 var _digit: Int32 = 0 @@ -5471,17 +5447,23 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _digitValue: Int32 = 0 var _discardableResult: Int32 = 0 var _discardUnknownFields: Int32 = 0 - var _distance: Int32 = 0 var _double: Int32 = 0 var _doubleValue: Int32 = 0 var _duration: Int32 = 0 var _e: Int32 = 0 + var _edition: Int32 = 0 + var _editionDefault: Int32 = 0 + var _editionDefaults: Int32 = 0 + var _editionDeprecated: Int32 = 0 + var _editionIntroduced: Int32 = 0 + var _editionRemoved: Int32 = 0 var _element: Int32 = 0 var _elements: Int32 = 0 + var _else: Int32 = 0 var _emitExtensionFieldName: Int32 = 0 var _emitFieldName: Int32 = 0 var _emitFieldNumber: Int32 = 0 - var _empty: Int32 = 0 + var _emptyAnyTypeURL: Int32 = 0 var _emptyData: Int32 = 0 var _encodeAsBytes: Int32 = 0 var _encoded: Int32 = 0 @@ -5494,16 +5476,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _endMessageField: Int32 = 0 var _endObject: Int32 = 0 var _endRegularField: Int32 = 0 + var _enforceNamingStyle: Int32 = 0 var _enum: Int32 = 0 - var _enumDescriptorProto: Int32 = 0 - var _enumOptions: Int32 = 0 var _enumReservedRange: Int32 = 0 var _enumType: Int32 = 0 var _enumvalue: Int32 = 0 - var _enumValueDescriptorProto: Int32 = 0 - var _enumValueOptions: Int32 = 0 var _equatable: Int32 = 0 var _error: Int32 = 0 + var _execute: Int32 = 0 var _expressibleByArrayLiteral: Int32 = 0 var _expressibleByDictionaryLiteral: Int32 = 0 var _ext: Int32 = 0 @@ -5518,37 +5498,38 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _extensionFieldValueSet: Int32 = 0 var _extensionMap: Int32 = 0 var _extensionRange: Int32 = 0 - var _extensionRangeOptions: Int32 = 0 var _extensions: Int32 = 0 var _extras: Int32 = 0 var _f: Int32 = 0 var _false: Int32 = 0 + var _features: Int32 = 0 + var _featureSetEditionDefault: Int32 = 0 + var _featureSupport: Int32 = 0 var _field: Int32 = 0 var _fieldData: Int32 = 0 - var _fieldDescriptorProto: Int32 = 0 - var _fieldMask: Int32 = 0 + var _fieldMaskError: Int32 = 0 var _fieldName: Int32 = 0 var _fieldNameCount: Int32 = 0 var _fieldNum: Int32 = 0 var _fieldNumber: Int32 = 0 var _fieldNumberForProto: Int32 = 0 - var _fieldOptions: Int32 = 0 + var _fieldPresence: Int32 = 0 var _fields: Int32 = 0 var _fieldSize: Int32 = 0 var _fieldTag: Int32 = 0 var _fieldType: Int32 = 0 var _file: Int32 = 0 - var _fileDescriptorProto: Int32 = 0 - var _fileDescriptorSet: Int32 = 0 var _fileName: Int32 = 0 - var _fileOptions: Int32 = 0 var _filter: Int32 = 0 + var _final: Int32 = 0 + var _finiteOnly: Int32 = 0 var _first: Int32 = 0 var _firstItem: Int32 = 0 + var _fixedFeatures: Int32 = 0 var _float: Int32 = 0 var _floatLiteral: Int32 = 0 var _floatLiteralType: Int32 = 0 - var _floatValue: Int32 = 0 + var _for: Int32 = 0 var _forMessageName: Int32 = 0 var _formUnion: Int32 = 0 var _forReadingFrom: Int32 = 0 @@ -5560,12 +5541,12 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _fromAscii4: Int32 = 0 var _fromByteOffset: Int32 = 0 var _fromHexDigit: Int32 = 0 + var _fullName: Int32 = 0 var _func: Int32 = 0 + var _function: Int32 = 0 var _g: Int32 = 0 - var _generatedCodeInfo: Int32 = 0 var _get: Int32 = 0 var _getExtensionValue: Int32 = 0 - var _googleapis: Int32 = 0 var _googleProtobufAny: Int32 = 0 var _googleProtobufApi: Int32 = 0 var _googleProtobufBoolValue: Int32 = 0 @@ -5573,6 +5554,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _googleProtobufDescriptorProto: Int32 = 0 var _googleProtobufDoubleValue: Int32 = 0 var _googleProtobufDuration: Int32 = 0 + var _googleProtobufEdition: Int32 = 0 var _googleProtobufEmpty: Int32 = 0 var _googleProtobufEnum: Int32 = 0 var _googleProtobufEnumDescriptorProto: Int32 = 0 @@ -5581,6 +5563,8 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _googleProtobufEnumValueDescriptorProto: Int32 = 0 var _googleProtobufEnumValueOptions: Int32 = 0 var _googleProtobufExtensionRangeOptions: Int32 = 0 + var _googleProtobufFeatureSet: Int32 = 0 + var _googleProtobufFeatureSetDefaults: Int32 = 0 var _googleProtobufField: Int32 = 0 var _googleProtobufFieldDescriptorProto: Int32 = 0 var _googleProtobufFieldMask: Int32 = 0 @@ -5608,6 +5592,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _googleProtobufSourceContext: Int32 = 0 var _googleProtobufStringValue: Int32 = 0 var _googleProtobufStruct: Int32 = 0 + var _googleProtobufSymbolVisibility: Int32 = 0 var _googleProtobufSyntax: Int32 = 0 var _googleProtobufTimestamp: Int32 = 0 var _googleProtobufType: Int32 = 0 @@ -5616,12 +5601,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _googleProtobufUninterpretedOption: Int32 = 0 var _googleProtobufValue: Int32 = 0 var _goPackage: Int32 = 0 + var _gotData: Int32 = 0 var _group: Int32 = 0 var _groupFieldNumberStack: Int32 = 0 var _groupSize: Int32 = 0 - var _h: Int32 = 0 + var _guard: Int32 = 0 var _hadOneofValue: Int32 = 0 var _handleConflictingOneOf: Int32 = 0 + var _handleInstruction: Int32 = 0 var _hasAggregateValue_p: Int32 = 0 var _hasAllowAlias_p: Int32 = 0 var _hasBegin_p: Int32 = 0 @@ -5630,17 +5617,33 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _hasClientStreaming_p: Int32 = 0 var _hasCsharpNamespace_p: Int32 = 0 var _hasCtype_p: Int32 = 0 + var _hasData_p: Int32 = 0 + var _hasDebugRedact_p: Int32 = 0 + var _hasDefaultSymbolVisibility_p: Int32 = 0 var _hasDefaultValue_p: Int32 = 0 var _hasDeprecated_p: Int32 = 0 + var _hasDeprecatedLegacyJsonFieldConflicts_p: Int32 = 0 + var _hasDeprecationWarning_p: Int32 = 0 var _hasDoubleValue_p: Int32 = 0 + var _hasEdition_p: Int32 = 0 + var _hasEditionDeprecated_p: Int32 = 0 + var _hasEditionIntroduced_p: Int32 = 0 + var _hasEditionRemoved_p: Int32 = 0 var _hasEnd_p: Int32 = 0 + var _hasEnforceNamingStyle_p: Int32 = 0 + var _hasEnumType_p: Int32 = 0 + var _hasExplicitDelta_p: Int32 = 0 var _hasExtendee_p: Int32 = 0 var _hasExtensionValue_p: Int32 = 0 + var _hasFeatures_p: Int32 = 0 + var _hasFeatureSupport_p: Int32 = 0 + var _hasFieldPresence_p: Int32 = 0 + var _hasFixedFeatures_p: Int32 = 0 + var _hasFullName_p: Int32 = 0 var _hasGoPackage_p: Int32 = 0 var _hash: Int32 = 0 var _hashable: Int32 = 0 var _hasher: Int32 = 0 - var _hashValue_p: Int32 = 0 var _hashVisitor: Int32 = 0 var _hasIdempotencyLevel_p: Int32 = 0 var _hasIdentifierValue_p: Int32 = 0 @@ -5652,13 +5655,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _hasJavaOuterClassname_p: Int32 = 0 var _hasJavaPackage_p: Int32 = 0 var _hasJavaStringCheckUtf8_p: Int32 = 0 + var _hasJsonFormat_p: Int32 = 0 var _hasJsonName_p: Int32 = 0 var _hasJstype_p: Int32 = 0 var _hasLabel_p: Int32 = 0 var _hasLazy_p: Int32 = 0 var _hasLeadingComments_p: Int32 = 0 var _hasMapEntry_p: Int32 = 0 + var _hasMaximumEdition_p: Int32 = 0 + var _hasMessageEncoding_p: Int32 = 0 var _hasMessageSetWireFormat_p: Int32 = 0 + var _hasMinimumEdition_p: Int32 = 0 var _hasName_p: Int32 = 0 var _hasNamePart_p: Int32 = 0 var _hasNegativeIntValue_p: Int32 = 0 @@ -5669,16 +5676,22 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _hasOptimizeFor_p: Int32 = 0 var _hasOptions_p: Int32 = 0 var _hasOutputType_p: Int32 = 0 + var _hasOverridableFeatures_p: Int32 = 0 var _hasPackage_p: Int32 = 0 var _hasPacked_p: Int32 = 0 var _hasPhpClassPrefix_p: Int32 = 0 - var _hasPhpGenericServices_p: Int32 = 0 var _hasPhpMetadataNamespace_p: Int32 = 0 var _hasPhpNamespace_p: Int32 = 0 var _hasPositiveIntValue_p: Int32 = 0 var _hasProto3Optional_p: Int32 = 0 var _hasPyGenericServices_p: Int32 = 0 + var _hasRemovalError_p: Int32 = 0 + var _hasRepeated_p: Int32 = 0 + var _hasRepeatedFieldEncoding_p: Int32 = 0 + var _hasReserved_p: Int32 = 0 + var _hasRetention_p: Int32 = 0 var _hasRubyPackage_p: Int32 = 0 + var _hasSemantic_p: Int32 = 0 var _hasServerStreaming_p: Int32 = 0 var _hasSourceCodeInfo_p: Int32 = 0 var _hasSourceContext_p: Int32 = 0 @@ -5690,40 +5703,49 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _hasTrailingComments_p: Int32 = 0 var _hasType_p: Int32 = 0 var _hasTypeName_p: Int32 = 0 + var _hasUnverifiedLazy_p: Int32 = 0 + var _hasUtf8Validation_p: Int32 = 0 var _hasValue_p: Int32 = 0 + var _hasVerification_p: Int32 = 0 + var _hasVisibility_p: Int32 = 0 var _hasWeak_p: Int32 = 0 var _hour: Int32 = 0 var _i: Int32 = 0 var _idempotencyLevel: Int32 = 0 var _identifierValue: Int32 = 0 var _if: Int32 = 0 + var _ignoreUnknownExtensionFields: Int32 = 0 var _ignoreUnknownFields: Int32 = 0 var _index: Int32 = 0 var _init_p: Int32 = 0 var _inout: Int32 = 0 var _inputType: Int32 = 0 var _insert: Int32 = 0 + var _instruction: Int32 = 0 var _int: Int32 = 0 var _int32: Int32 = 0 - var _int32Value: Int32 = 0 var _int64: Int32 = 0 - var _int64Value: Int32 = 0 var _int8: Int32 = 0 var _integerLiteral: Int32 = 0 var _integerLiteralType: Int32 = 0 var _intern: Int32 = 0 var _internal: Int32 = 0 var _internalState: Int32 = 0 + var _intersect: Int32 = 0 var _into: Int32 = 0 var _ints: Int32 = 0 + var _invalidAnyTypeURL: Int32 = 0 var _isA: Int32 = 0 var _isEqual: Int32 = 0 var _isEqualTo: Int32 = 0 var _isExtension: Int32 = 0 var _isInitialized_p: Int32 = 0 + var _isNegative: Int32 = 0 + var _isPathValid: Int32 = 0 + var _isReserved: Int32 = 0 + var _isValid: Int32 = 0 var _itemTagsEncodedSize: Int32 = 0 var _iterator: Int32 = 0 - var _i2166136261: Int32 = 0 var _javaGenerateEqualsAndHash: Int32 = 0 var _javaGenericServices: Int32 = 0 var _javaMultipleFiles: Int32 = 0 @@ -5731,12 +5753,15 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _javaPackage: Int32 = 0 var _javaStringCheckUtf8: Int32 = 0 var _jsondecoder: Int32 = 0 + var _jsondecoding: Int32 = 0 var _jsondecodingError: Int32 = 0 var _jsondecodingOptions: Int32 = 0 var _jsonEncoder: Int32 = 0 + var _jsonencoding: Int32 = 0 var _jsonencodingError: Int32 = 0 var _jsonencodingOptions: Int32 = 0 var _jsonencodingVisitor: Int32 = 0 + var _jsonFormat: Int32 = 0 var _jsonmapEncodingVisitor: Int32 = 0 var _jsonName: Int32 = 0 var _jsonPath: Int32 = 0 @@ -5744,11 +5769,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _jsonscanner: Int32 = 0 var _jsonString: Int32 = 0 var _jsonText: Int32 = 0 + var _jsonUtf8Bytes: Int32 = 0 var _jsonUtf8Data: Int32 = 0 var _jstype: Int32 = 0 var _k: Int32 = 0 + var _kChunkSize: Int32 = 0 var _key: Int32 = 0 var _keyField: Int32 = 0 + var _keyFieldOpt: Int32 = 0 var _keyType: Int32 = 0 var _kind: Int32 = 0 var _l: Int32 = 0 @@ -5760,42 +5788,44 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _lessThan: Int32 = 0 var _let: Int32 = 0 var _lhs: Int32 = 0 + var _line: Int32 = 0 var _list: Int32 = 0 var _listOfMessages: Int32 = 0 var _listValue: Int32 = 0 var _littleEndian: Int32 = 0 - var _littleEndianBytes: Int32 = 0 var _load: Int32 = 0 var _localHasher: Int32 = 0 var _location: Int32 = 0 var _m: Int32 = 0 var _major: Int32 = 0 + var _makeAsyncIterator: Int32 = 0 var _makeIterator: Int32 = 0 + var _malformedLength: Int32 = 0 var _mapEntry: Int32 = 0 - var _mapHash: Int32 = 0 var _mapKeyType: Int32 = 0 - var _mapNameResolver: Int32 = 0 var _mapToMessages: Int32 = 0 var _mapValueType: Int32 = 0 var _mapVisitor: Int32 = 0 + var _mask: Int32 = 0 + var _maximumEdition: Int32 = 0 var _mdayStart: Int32 = 0 var _merge: Int32 = 0 + var _mergeOptions: Int32 = 0 var _message: Int32 = 0 var _messageDepthLimit: Int32 = 0 + var _messageEncoding: Int32 = 0 var _messageExtension: Int32 = 0 var _messageImplementationBase: Int32 = 0 - var _messageOptions: Int32 = 0 var _messageSet: Int32 = 0 var _messageSetWireFormat: Int32 = 0 + var _messageSize: Int32 = 0 var _messageType: Int32 = 0 var _method: Int32 = 0 - var _methodDescriptorProto: Int32 = 0 - var _methodOptions: Int32 = 0 var _methods: Int32 = 0 + var _min: Int32 = 0 + var _minimumEdition: Int32 = 0 var _minor: Int32 = 0 - var _mixin: Int32 = 0 var _mixins: Int32 = 0 - var _modifier: Int32 = 0 var _modify: Int32 = 0 var _month: Int32 = 0 var _msgExtension: Int32 = 0 @@ -5805,44 +5835,53 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _nameDescription: Int32 = 0 var _nameMap: Int32 = 0 var _namePart: Int32 = 0 - var _nameResolver: Int32 = 0 var _names: Int32 = 0 var _nanos: Int32 = 0 - var _nativeBytes: Int32 = 0 - var _nativeEndianBytes: Int32 = 0 var _negativeIntValue: Int32 = 0 var _nestedType: Int32 = 0 + var _newExtensible: Int32 = 0 var _newL: Int32 = 0 var _newList: Int32 = 0 + var _newMessage: Int32 = 0 var _newValue: Int32 = 0 + var _next: Int32 = 0 var _nextByte: Int32 = 0 var _nextFieldNumber: Int32 = 0 + var _nextInstruction: Int32 = 0 + var _nextInt32: Int32 = 0 + var _nextNullTerminatedString: Int32 = 0 + var _nextNullTerminatedStringArray: Int32 = 0 + var _nextNumber: Int32 = 0 + var _nextUint64: Int32 = 0 + var _nextVarInt: Int32 = 0 var _nil: Int32 = 0 var _nilLiteral: Int32 = 0 + var _noBytesAvailable: Int32 = 0 var _noStandardDescriptorAccessor: Int32 = 0 var _nullValue: Int32 = 0 var _number: Int32 = 0 var _numberValue: Int32 = 0 var _objcClassPrefix: Int32 = 0 var _of: Int32 = 0 + var _oneOfKind: Int32 = 0 var _oneofDecl: Int32 = 0 - var _oneofDescriptorProto: Int32 = 0 var _oneofIndex: Int32 = 0 - var _oneofOptions: Int32 = 0 var _oneofs: Int32 = 0 - var _oneOfKind: Int32 = 0 var _optimizeFor: Int32 = 0 var _optimizeMode: Int32 = 0 - var _option: Int32 = 0 var _optionalEnumExtensionField: Int32 = 0 var _optionalExtensionField: Int32 = 0 var _optionalGroupExtensionField: Int32 = 0 var _optionalMessageExtensionField: Int32 = 0 + var _optionDependency: Int32 = 0 + var _optionRetention: Int32 = 0 var _options: Int32 = 0 + var _optionTargetType: Int32 = 0 var _other: Int32 = 0 var _others: Int32 = 0 var _out: Int32 = 0 var _outputType: Int32 = 0 + var _overridableFeatures: Int32 = 0 var _p: Int32 = 0 var _package: Int32 = 0 var _packed: Int32 = 0 @@ -5853,27 +5892,39 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _parse: Int32 = 0 var _partial: Int32 = 0 var _path: Int32 = 0 + var _pathDecoder: Int32 = 0 + var _pathDecodingError: Int32 = 0 var _paths: Int32 = 0 + var _pathVisitor: Int32 = 0 var _payload: Int32 = 0 var _payloadSize: Int32 = 0 var _phpClassPrefix: Int32 = 0 - var _phpGenericServices: Int32 = 0 var _phpMetadataNamespace: Int32 = 0 var _phpNamespace: Int32 = 0 - var _pointer: Int32 = 0 var _pos: Int32 = 0 var _positiveIntValue: Int32 = 0 var _prefix: Int32 = 0 var _preserveProtoFieldNames: Int32 = 0 var _preTraverse: Int32 = 0 + var _previousNumber: Int32 = 0 + var _prevPath: Int32 = 0 var _printUnknownFields: Int32 = 0 + var _programBuffer: Int32 = 0 + var _programFormat: Int32 = 0 var _proto2: Int32 = 0 var _proto3DefaultValue: Int32 = 0 var _proto3Optional: Int32 = 0 - var _protobufApiversionCheck: Int32 = 0 + var _protobufExtensionFieldValues: Int32 = 0 + var _protobufFieldNumber: Int32 = 0 + var _protobufGeneratedIsEqualTo: Int32 = 0 + var _protobufNameMap: Int32 = 0 + var _protobufNewField: Int32 = 0 + var _protobufPackage: Int32 = 0 var _protobufApiversion2: Int32 = 0 + var _protobufApiversionCheck: Int32 = 0 var _protobufBool: Int32 = 0 var _protobufBytes: Int32 = 0 + var _protobufData: Int32 = 0 var _protobufDouble: Int32 = 0 var _protobufEnumMap: Int32 = 0 var _protobufExtension: Int32 = 0 @@ -5891,12 +5942,6 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _protobufString: Int32 = 0 var _protobufUint32: Int32 = 0 var _protobufUint64: Int32 = 0 - var _protobufExtensionFieldValues: Int32 = 0 - var _protobufFieldNumber: Int32 = 0 - var _protobufGeneratedIsEqualTo: Int32 = 0 - var _protobufNameMap: Int32 = 0 - var _protobufNewField: Int32 = 0 - var _protobufPackage: Int32 = 0 var _protocol: Int32 = 0 var _protoFieldName: Int32 = 0 var _protoMessageName: Int32 = 0 @@ -5918,25 +5963,33 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _putVarInt: Int32 = 0 var _putZigZagVarInt: Int32 = 0 var _pyGenericServices: Int32 = 0 + var _r: Int32 = 0 var _rawChars: Int32 = 0 var _rawRepresentable: Int32 = 0 var _rawValue: Int32 = 0 var _read4HexDigits: Int32 = 0 + var _readBytes: Int32 = 0 + var _reader: Int32 = 0 var _register: Int32 = 0 + var _remainingProgram: Int32 = 0 + var _removalError: Int32 = 0 + var _removingAllFieldsOf: Int32 = 0 + var _repeated: Int32 = 0 var _repeatedEnumExtensionField: Int32 = 0 var _repeatedExtensionField: Int32 = 0 + var _repeatedFieldEncoding: Int32 = 0 var _repeatedGroupExtensionField: Int32 = 0 var _repeatedMessageExtensionField: Int32 = 0 + var _repeating: Int32 = 0 + var _replaceRepeatedFields: Int32 = 0 var _requestStreaming: Int32 = 0 var _requestTypeURL: Int32 = 0 var _requiredSize: Int32 = 0 - var _reservedName: Int32 = 0 - var _reservedRange: Int32 = 0 var _responseStreaming: Int32 = 0 var _responseTypeURL: Int32 = 0 var _result: Int32 = 0 + var _retention: Int32 = 0 var _rethrows: Int32 = 0 - var _return: Int32 = 0 var _returnType: Int32 = 0 var _revision: Int32 = 0 var _rhs: Int32 = 0 @@ -5946,27 +5999,32 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _sawBackslash: Int32 = 0 var _sawSection4Characters: Int32 = 0 var _sawSection5Characters: Int32 = 0 + var _scalar: Int32 = 0 + var _scan: Int32 = 0 var _scanner: Int32 = 0 var _seconds: Int32 = 0 var _self_p: Int32 = 0 + var _semantic: Int32 = 0 + var _sendable: Int32 = 0 var _separator: Int32 = 0 var _serialize: Int32 = 0 + var _serializedBytes: Int32 = 0 var _serializedData: Int32 = 0 var _serializedSize: Int32 = 0 var _serverStreaming: Int32 = 0 var _service: Int32 = 0 - var _serviceDescriptorProto: Int32 = 0 - var _serviceOptions: Int32 = 0 var _set: Int32 = 0 var _setExtensionValue: Int32 = 0 var _shift: Int32 = 0 var _simpleExtensionMap: Int32 = 0 + var _size: Int32 = 0 var _sizer: Int32 = 0 var _source: Int32 = 0 var _sourceCodeInfo: Int32 = 0 var _sourceContext: Int32 = 0 var _sourceEncoding: Int32 = 0 var _sourceFile: Int32 = 0 + var _sourceLocation: Int32 = 0 var _span: Int32 = 0 var _split: Int32 = 0 var _start: Int32 = 0 @@ -5990,13 +6048,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _structValue: Int32 = 0 var _subDecoder: Int32 = 0 var _subscript: Int32 = 0 + var _subtract: Int32 = 0 var _subVisitor: Int32 = 0 var _swift: Int32 = 0 var _swiftPrefix: Int32 = 0 - var _swiftProtobuf: Int32 = 0 + var _swiftProtobufContiguousBytes: Int32 = 0 + var _swiftProtobufError: Int32 = 0 var _syntax: Int32 = 0 var _t: Int32 = 0 var _tag: Int32 = 0 + var _targets: Int32 = 0 var _terminator: Int32 = 0 var _testDecoder: Int32 = 0 var _text: Int32 = 0 @@ -6007,16 +6068,19 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _textFormatEncodingOptions: Int32 = 0 var _textFormatEncodingVisitor: Int32 = 0 var _textFormatString: Int32 = 0 + var _throwOrIgnore: Int32 = 0 var _throws: Int32 = 0 var _timeInterval: Int32 = 0 var _timeIntervalSince1970: Int32 = 0 var _timeIntervalSinceReferenceDate: Int32 = 0 - var _timestamp: Int32 = 0 + var _tmp: Int32 = 0 + var _tooLarge: Int32 = 0 var _total: Int32 = 0 var _totalArrayDepth: Int32 = 0 var _totalSize: Int32 = 0 var _trailingComments: Int32 = 0 var _traverse: Int32 = 0 + var _trim: Int32 = 0 var _true: Int32 = 0 var _try: Int32 = 0 var _type: Int32 = 0 @@ -6028,10 +6092,10 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _typeUnknown: Int32 = 0 var _typeURL: Int32 = 0 var _uint32: Int32 = 0 - var _uint32Value: Int32 = 0 var _uint64: Int32 = 0 - var _uint64Value: Int32 = 0 var _uint8: Int32 = 0 + var _unchecked: Int32 = 0 + var _unicode: Int32 = 0 var _unicodeScalarLiteral: Int32 = 0 var _unicodeScalarLiteralType: Int32 = 0 var _unicodeScalars: Int32 = 0 @@ -6046,14 +6110,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _unsafeBufferPointer: Int32 = 0 var _unsafeMutablePointer: Int32 = 0 var _unsafeMutableRawBufferPointer: Int32 = 0 - var _unsafeMutableRawPointer: Int32 = 0 var _unsafeRawBufferPointer: Int32 = 0 var _unsafeRawPointer: Int32 = 0 + var _unverifiedLazy: Int32 = 0 var _updatedOptions: Int32 = 0 + var _uppercasedAssumingAscii: Int32 = 0 var _url: Int32 = 0 + var _useDeterministicOrdering: Int32 = 0 var _utf8: Int32 = 0 var _utf8Ptr: Int32 = 0 var _utf8ToDouble: Int32 = 0 + var _utf8Validation: Int32 = 0 var _utf8View: Int32 = 0 var _v: Int32 = 0 var _value: Int32 = 0 @@ -6061,8 +6128,12 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _values: Int32 = 0 var _valueType: Int32 = 0 var _var: Int32 = 0 + var _verification: Int32 = 0 + var _verificationState: Int32 = 0 var _version: Int32 = 0 var _versionString: Int32 = 0 + var _visibility: Int32 = 0 + var _visibilityFeature: Int32 = 0 var _visitExtensionFields: Int32 = 0 var _visitExtensionFieldsAsMessageSet: Int32 = 0 var _visitMapField: Int32 = 0 @@ -6121,6 +6192,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _visitSingularUint32Field: Int32 = 0 var _visitSingularUint64Field: Int32 = 0 var _visitUnknown: Int32 = 0 + var _void: Int32 = 0 var _wasDecoded: Int32 = 0 var _weak: Int32 = 0 var _weakDependency: Int32 = 0 @@ -6130,27 +6202,35 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _withUnsafeBytes: Int32 = 0 var _withUnsafeMutableBytes: Int32 = 0 var _work: Int32 = 0 + var _wrapped: Int32 = 0 var _wrappedType: Int32 = 0 + var _wrappedValue: Int32 = 0 var _written: Int32 = 0 var _yday: Int32 = 0 - static let defaultInstance = _StorageClass() + // 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() private init() {} init(copying source: _StorageClass) { + _addPath = source._addPath _adjusted = source._adjusted _aggregateValue = source._aggregateValue _allCases = source._allCases _allowAlias = source._allowAlias _alwaysPrintEnumsAsInts = source._alwaysPrintEnumsAsInts + _alwaysPrintInt64SAsNumbers = source._alwaysPrintInt64SAsNumbers _annotation = source._annotation _any = source._any _anyExtensionField = source._anyExtensionField _anyMessageExtension = source._anyMessageExtension _anyMessageStorage = source._anyMessageStorage _anyUnpackError = source._anyUnpackError - _api = source._api + _append = source._append _appended = source._appended _appendUintHex = source._appendUintHex _appendUnknown = source._appendUnknown @@ -6162,14 +6242,20 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _as = source._as _asciiOpenCurlyBracket = source._asciiOpenCurlyBracket _asciiZero = source._asciiZero + _async = source._async + _asyncIterator = source._asyncIterator + _asyncIteratorProtocol = source._asyncIteratorProtocol + _asyncMessageSequence = source._asyncMessageSequence _available = source._available _b = source._b + _base = source._base _base64Values = source._base64Values _baseAddress = source._baseAddress _baseType = source._baseType _begin = source._begin _binary = source._binary _binaryDecoder = source._binaryDecoder + _binaryDecoding = source._binaryDecoding _binaryDecodingError = source._binaryDecodingError _binaryDecodingOptions = source._binaryDecodingOptions _binaryDelimited = source._binaryDelimited @@ -6177,25 +6263,39 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _binaryEncodingError = source._binaryEncodingError _binaryEncodingMessageSetSizeVisitor = source._binaryEncodingMessageSetSizeVisitor _binaryEncodingMessageSetVisitor = source._binaryEncodingMessageSetVisitor + _binaryEncodingOptions = source._binaryEncodingOptions _binaryEncodingSizeVisitor = source._binaryEncodingSizeVisitor _binaryEncodingVisitor = source._binaryEncodingVisitor _binaryOptions = source._binaryOptions + _binaryProtobufDelimitedMessages = source._binaryProtobufDelimitedMessages + _binaryStreamDecoding = source._binaryStreamDecoding + _binaryStreamDecodingError = source._binaryStreamDecodingError + _bitPattern = source._bitPattern _body = source._body _bool = source._bool _booleanLiteral = source._booleanLiteral _booleanLiteralType = source._booleanLiteralType _boolValue = source._boolValue + _buffer = source._buffer + _byte = source._byte + _bytecode = source._bytecode + _bytecodeReader = source._bytecodeReader _bytes = source._bytes _bytesInGroup = source._bytesInGroup + _bytesNeeded = source._bytesNeeded _bytesRead = source._bytesRead - _bytesValue = source._bytesValue _c = source._c + _canonical = source._canonical _capitalizeNext = source._capitalizeNext _cardinality = source._cardinality + _caseIterable = source._caseIterable + _castedValue = source._castedValue _ccEnableArenas = source._ccEnableArenas _ccGenericServices = source._ccGenericServices _character = source._character _chars = source._chars + _checkProgramFormat = source._checkProgramFormat + _chunk = source._chunk _class = source._class _clearAggregateValue_p = source._clearAggregateValue_p _clearAllowAlias_p = source._clearAllowAlias_p @@ -6205,12 +6305,27 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _clearClientStreaming_p = source._clearClientStreaming_p _clearCsharpNamespace_p = source._clearCsharpNamespace_p _clearCtype_p = source._clearCtype_p + _clearDebugRedact_p = source._clearDebugRedact_p + _clearDefaultSymbolVisibility_p = source._clearDefaultSymbolVisibility_p _clearDefaultValue_p = source._clearDefaultValue_p _clearDeprecated_p = source._clearDeprecated_p + _clearDeprecatedLegacyJsonFieldConflicts_p = source._clearDeprecatedLegacyJsonFieldConflicts_p + _clearDeprecationWarning_p = source._clearDeprecationWarning_p _clearDoubleValue_p = source._clearDoubleValue_p + _clearEdition_p = source._clearEdition_p + _clearEditionDeprecated_p = source._clearEditionDeprecated_p + _clearEditionIntroduced_p = source._clearEditionIntroduced_p + _clearEditionRemoved_p = source._clearEditionRemoved_p _clearEnd_p = source._clearEnd_p + _clearEnforceNamingStyle_p = source._clearEnforceNamingStyle_p + _clearEnumType_p = source._clearEnumType_p _clearExtendee_p = source._clearExtendee_p _clearExtensionValue_p = source._clearExtensionValue_p + _clearFeatures_p = source._clearFeatures_p + _clearFeatureSupport_p = source._clearFeatureSupport_p + _clearFieldPresence_p = source._clearFieldPresence_p + _clearFixedFeatures_p = source._clearFixedFeatures_p + _clearFullName_p = source._clearFullName_p _clearGoPackage_p = source._clearGoPackage_p _clearIdempotencyLevel_p = source._clearIdempotencyLevel_p _clearIdentifierValue_p = source._clearIdentifierValue_p @@ -6222,13 +6337,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _clearJavaOuterClassname_p = source._clearJavaOuterClassname_p _clearJavaPackage_p = source._clearJavaPackage_p _clearJavaStringCheckUtf8_p = source._clearJavaStringCheckUtf8_p + _clearJsonFormat_p = source._clearJsonFormat_p _clearJsonName_p = source._clearJsonName_p _clearJstype_p = source._clearJstype_p _clearLabel_p = source._clearLabel_p _clearLazy_p = source._clearLazy_p _clearLeadingComments_p = source._clearLeadingComments_p _clearMapEntry_p = source._clearMapEntry_p + _clearMaximumEdition_p = source._clearMaximumEdition_p + _clearMessageEncoding_p = source._clearMessageEncoding_p _clearMessageSetWireFormat_p = source._clearMessageSetWireFormat_p + _clearMinimumEdition_p = source._clearMinimumEdition_p _clearName_p = source._clearName_p _clearNamePart_p = source._clearNamePart_p _clearNegativeIntValue_p = source._clearNegativeIntValue_p @@ -6239,16 +6358,22 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _clearOptimizeFor_p = source._clearOptimizeFor_p _clearOptions_p = source._clearOptions_p _clearOutputType_p = source._clearOutputType_p + _clearOverridableFeatures_p = source._clearOverridableFeatures_p _clearPackage_p = source._clearPackage_p _clearPacked_p = source._clearPacked_p _clearPhpClassPrefix_p = source._clearPhpClassPrefix_p - _clearPhpGenericServices_p = source._clearPhpGenericServices_p _clearPhpMetadataNamespace_p = source._clearPhpMetadataNamespace_p _clearPhpNamespace_p = source._clearPhpNamespace_p _clearPositiveIntValue_p = source._clearPositiveIntValue_p _clearProto3Optional_p = source._clearProto3Optional_p _clearPyGenericServices_p = source._clearPyGenericServices_p + _clearRemovalError_p = source._clearRemovalError_p + _clearRepeated_p = source._clearRepeated_p + _clearRepeatedFieldEncoding_p = source._clearRepeatedFieldEncoding_p + _clearReserved_p = source._clearReserved_p + _clearRetention_p = source._clearRetention_p _clearRubyPackage_p = source._clearRubyPackage_p + _clearSemantic_p = source._clearSemantic_p _clearServerStreaming_p = source._clearServerStreaming_p _clearSourceCodeInfo_p = source._clearSourceCodeInfo_p _clearSourceContext_p = source._clearSourceContext_p @@ -6260,22 +6385,30 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _clearTrailingComments_p = source._clearTrailingComments_p _clearType_p = source._clearType_p _clearTypeName_p = source._clearTypeName_p + _clearUnverifiedLazy_p = source._clearUnverifiedLazy_p + _clearUtf8Validation_p = source._clearUtf8Validation_p _clearValue_p = source._clearValue_p + _clearVerification_p = source._clearVerification_p + _clearVisibility_p = source._clearVisibility_p _clearWeak_p = source._clearWeak_p _clientStreaming = source._clientStreaming + _code = source._code _codePoint = source._codePoint _codeUnits = source._codeUnits _collection = source._collection - _com = source._com _comma = source._comma + _consumedBytes = source._consumedBytes + _contains = source._contains _contentsOf = source._contentsOf _contiguousBytes = source._contiguousBytes + _copy = source._copy _count = source._count _countVarintsInBuffer = source._countVarintsInBuffer _csharpNamespace = source._csharpNamespace _ctype = source._ctype _customCodable = source._customCodable _customDebugStringConvertible = source._customDebugStringConvertible + _customStringConvertible = source._customStringConvertible _d = source._d _data = source._data _dataResult = source._dataResult @@ -6283,6 +6416,8 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _daySec = source._daySec _daysSinceEpoch = source._daysSinceEpoch _debugDescription_p = source._debugDescription_p + _debugRedact = source._debugRedact + _declaration = source._declaration _decoded = source._decoded _decodedFromJsonnull = source._decodedFromJsonnull _decodeExtensionField = source._decodeExtensionField @@ -6331,11 +6466,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _decodeSingularUint64Field = source._decodeSingularUint64Field _decodeTextFormat = source._decodeTextFormat _defaultAnyTypeUrlprefix = source._defaultAnyTypeUrlprefix + _defaults = source._defaults + _defaultSymbolVisibility = source._defaultSymbolVisibility _defaultValue = source._defaultValue _dependency = source._dependency _deprecated = source._deprecated + _deprecatedLegacyJsonFieldConflicts = source._deprecatedLegacyJsonFieldConflicts + _deprecationWarning = source._deprecationWarning _description_p = source._description_p - _descriptorProto = source._descriptorProto _dictionary = source._dictionary _dictionaryLiteral = source._dictionaryLiteral _digit = source._digit @@ -6346,17 +6484,23 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _digitValue = source._digitValue _discardableResult = source._discardableResult _discardUnknownFields = source._discardUnknownFields - _distance = source._distance _double = source._double _doubleValue = source._doubleValue _duration = source._duration _e = source._e + _edition = source._edition + _editionDefault = source._editionDefault + _editionDefaults = source._editionDefaults + _editionDeprecated = source._editionDeprecated + _editionIntroduced = source._editionIntroduced + _editionRemoved = source._editionRemoved _element = source._element _elements = source._elements + _else = source._else _emitExtensionFieldName = source._emitExtensionFieldName _emitFieldName = source._emitFieldName _emitFieldNumber = source._emitFieldNumber - _empty = source._empty + _emptyAnyTypeURL = source._emptyAnyTypeURL _emptyData = source._emptyData _encodeAsBytes = source._encodeAsBytes _encoded = source._encoded @@ -6369,16 +6513,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _endMessageField = source._endMessageField _endObject = source._endObject _endRegularField = source._endRegularField + _enforceNamingStyle = source._enforceNamingStyle _enum = source._enum - _enumDescriptorProto = source._enumDescriptorProto - _enumOptions = source._enumOptions _enumReservedRange = source._enumReservedRange _enumType = source._enumType _enumvalue = source._enumvalue - _enumValueDescriptorProto = source._enumValueDescriptorProto - _enumValueOptions = source._enumValueOptions _equatable = source._equatable _error = source._error + _execute = source._execute _expressibleByArrayLiteral = source._expressibleByArrayLiteral _expressibleByDictionaryLiteral = source._expressibleByDictionaryLiteral _ext = source._ext @@ -6393,37 +6535,38 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _extensionFieldValueSet = source._extensionFieldValueSet _extensionMap = source._extensionMap _extensionRange = source._extensionRange - _extensionRangeOptions = source._extensionRangeOptions _extensions = source._extensions _extras = source._extras _f = source._f _false = source._false + _features = source._features + _featureSetEditionDefault = source._featureSetEditionDefault + _featureSupport = source._featureSupport _field = source._field _fieldData = source._fieldData - _fieldDescriptorProto = source._fieldDescriptorProto - _fieldMask = source._fieldMask + _fieldMaskError = source._fieldMaskError _fieldName = source._fieldName _fieldNameCount = source._fieldNameCount _fieldNum = source._fieldNum _fieldNumber = source._fieldNumber _fieldNumberForProto = source._fieldNumberForProto - _fieldOptions = source._fieldOptions + _fieldPresence = source._fieldPresence _fields = source._fields _fieldSize = source._fieldSize _fieldTag = source._fieldTag _fieldType = source._fieldType _file = source._file - _fileDescriptorProto = source._fileDescriptorProto - _fileDescriptorSet = source._fileDescriptorSet _fileName = source._fileName - _fileOptions = source._fileOptions _filter = source._filter + _final = source._final + _finiteOnly = source._finiteOnly _first = source._first _firstItem = source._firstItem + _fixedFeatures = source._fixedFeatures _float = source._float _floatLiteral = source._floatLiteral _floatLiteralType = source._floatLiteralType - _floatValue = source._floatValue + _for = source._for _forMessageName = source._forMessageName _formUnion = source._formUnion _forReadingFrom = source._forReadingFrom @@ -6435,12 +6578,12 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _fromAscii4 = source._fromAscii4 _fromByteOffset = source._fromByteOffset _fromHexDigit = source._fromHexDigit + _fullName = source._fullName _func = source._func + _function = source._function _g = source._g - _generatedCodeInfo = source._generatedCodeInfo _get = source._get _getExtensionValue = source._getExtensionValue - _googleapis = source._googleapis _googleProtobufAny = source._googleProtobufAny _googleProtobufApi = source._googleProtobufApi _googleProtobufBoolValue = source._googleProtobufBoolValue @@ -6448,6 +6591,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _googleProtobufDescriptorProto = source._googleProtobufDescriptorProto _googleProtobufDoubleValue = source._googleProtobufDoubleValue _googleProtobufDuration = source._googleProtobufDuration + _googleProtobufEdition = source._googleProtobufEdition _googleProtobufEmpty = source._googleProtobufEmpty _googleProtobufEnum = source._googleProtobufEnum _googleProtobufEnumDescriptorProto = source._googleProtobufEnumDescriptorProto @@ -6456,6 +6600,8 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _googleProtobufEnumValueDescriptorProto = source._googleProtobufEnumValueDescriptorProto _googleProtobufEnumValueOptions = source._googleProtobufEnumValueOptions _googleProtobufExtensionRangeOptions = source._googleProtobufExtensionRangeOptions + _googleProtobufFeatureSet = source._googleProtobufFeatureSet + _googleProtobufFeatureSetDefaults = source._googleProtobufFeatureSetDefaults _googleProtobufField = source._googleProtobufField _googleProtobufFieldDescriptorProto = source._googleProtobufFieldDescriptorProto _googleProtobufFieldMask = source._googleProtobufFieldMask @@ -6483,6 +6629,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _googleProtobufSourceContext = source._googleProtobufSourceContext _googleProtobufStringValue = source._googleProtobufStringValue _googleProtobufStruct = source._googleProtobufStruct + _googleProtobufSymbolVisibility = source._googleProtobufSymbolVisibility _googleProtobufSyntax = source._googleProtobufSyntax _googleProtobufTimestamp = source._googleProtobufTimestamp _googleProtobufType = source._googleProtobufType @@ -6491,12 +6638,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _googleProtobufUninterpretedOption = source._googleProtobufUninterpretedOption _googleProtobufValue = source._googleProtobufValue _goPackage = source._goPackage + _gotData = source._gotData _group = source._group _groupFieldNumberStack = source._groupFieldNumberStack _groupSize = source._groupSize - _h = source._h + _guard = source._guard _hadOneofValue = source._hadOneofValue _handleConflictingOneOf = source._handleConflictingOneOf + _handleInstruction = source._handleInstruction _hasAggregateValue_p = source._hasAggregateValue_p _hasAllowAlias_p = source._hasAllowAlias_p _hasBegin_p = source._hasBegin_p @@ -6505,17 +6654,33 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _hasClientStreaming_p = source._hasClientStreaming_p _hasCsharpNamespace_p = source._hasCsharpNamespace_p _hasCtype_p = source._hasCtype_p + _hasData_p = source._hasData_p + _hasDebugRedact_p = source._hasDebugRedact_p + _hasDefaultSymbolVisibility_p = source._hasDefaultSymbolVisibility_p _hasDefaultValue_p = source._hasDefaultValue_p _hasDeprecated_p = source._hasDeprecated_p + _hasDeprecatedLegacyJsonFieldConflicts_p = source._hasDeprecatedLegacyJsonFieldConflicts_p + _hasDeprecationWarning_p = source._hasDeprecationWarning_p _hasDoubleValue_p = source._hasDoubleValue_p + _hasEdition_p = source._hasEdition_p + _hasEditionDeprecated_p = source._hasEditionDeprecated_p + _hasEditionIntroduced_p = source._hasEditionIntroduced_p + _hasEditionRemoved_p = source._hasEditionRemoved_p _hasEnd_p = source._hasEnd_p + _hasEnforceNamingStyle_p = source._hasEnforceNamingStyle_p + _hasEnumType_p = source._hasEnumType_p + _hasExplicitDelta_p = source._hasExplicitDelta_p _hasExtendee_p = source._hasExtendee_p _hasExtensionValue_p = source._hasExtensionValue_p + _hasFeatures_p = source._hasFeatures_p + _hasFeatureSupport_p = source._hasFeatureSupport_p + _hasFieldPresence_p = source._hasFieldPresence_p + _hasFixedFeatures_p = source._hasFixedFeatures_p + _hasFullName_p = source._hasFullName_p _hasGoPackage_p = source._hasGoPackage_p _hash = source._hash _hashable = source._hashable _hasher = source._hasher - _hashValue_p = source._hashValue_p _hashVisitor = source._hashVisitor _hasIdempotencyLevel_p = source._hasIdempotencyLevel_p _hasIdentifierValue_p = source._hasIdentifierValue_p @@ -6527,13 +6692,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _hasJavaOuterClassname_p = source._hasJavaOuterClassname_p _hasJavaPackage_p = source._hasJavaPackage_p _hasJavaStringCheckUtf8_p = source._hasJavaStringCheckUtf8_p + _hasJsonFormat_p = source._hasJsonFormat_p _hasJsonName_p = source._hasJsonName_p _hasJstype_p = source._hasJstype_p _hasLabel_p = source._hasLabel_p _hasLazy_p = source._hasLazy_p _hasLeadingComments_p = source._hasLeadingComments_p _hasMapEntry_p = source._hasMapEntry_p + _hasMaximumEdition_p = source._hasMaximumEdition_p + _hasMessageEncoding_p = source._hasMessageEncoding_p _hasMessageSetWireFormat_p = source._hasMessageSetWireFormat_p + _hasMinimumEdition_p = source._hasMinimumEdition_p _hasName_p = source._hasName_p _hasNamePart_p = source._hasNamePart_p _hasNegativeIntValue_p = source._hasNegativeIntValue_p @@ -6544,16 +6713,22 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _hasOptimizeFor_p = source._hasOptimizeFor_p _hasOptions_p = source._hasOptions_p _hasOutputType_p = source._hasOutputType_p + _hasOverridableFeatures_p = source._hasOverridableFeatures_p _hasPackage_p = source._hasPackage_p _hasPacked_p = source._hasPacked_p _hasPhpClassPrefix_p = source._hasPhpClassPrefix_p - _hasPhpGenericServices_p = source._hasPhpGenericServices_p _hasPhpMetadataNamespace_p = source._hasPhpMetadataNamespace_p _hasPhpNamespace_p = source._hasPhpNamespace_p _hasPositiveIntValue_p = source._hasPositiveIntValue_p _hasProto3Optional_p = source._hasProto3Optional_p _hasPyGenericServices_p = source._hasPyGenericServices_p + _hasRemovalError_p = source._hasRemovalError_p + _hasRepeated_p = source._hasRepeated_p + _hasRepeatedFieldEncoding_p = source._hasRepeatedFieldEncoding_p + _hasReserved_p = source._hasReserved_p + _hasRetention_p = source._hasRetention_p _hasRubyPackage_p = source._hasRubyPackage_p + _hasSemantic_p = source._hasSemantic_p _hasServerStreaming_p = source._hasServerStreaming_p _hasSourceCodeInfo_p = source._hasSourceCodeInfo_p _hasSourceContext_p = source._hasSourceContext_p @@ -6565,40 +6740,49 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _hasTrailingComments_p = source._hasTrailingComments_p _hasType_p = source._hasType_p _hasTypeName_p = source._hasTypeName_p + _hasUnverifiedLazy_p = source._hasUnverifiedLazy_p + _hasUtf8Validation_p = source._hasUtf8Validation_p _hasValue_p = source._hasValue_p + _hasVerification_p = source._hasVerification_p + _hasVisibility_p = source._hasVisibility_p _hasWeak_p = source._hasWeak_p _hour = source._hour _i = source._i _idempotencyLevel = source._idempotencyLevel _identifierValue = source._identifierValue _if = source._if + _ignoreUnknownExtensionFields = source._ignoreUnknownExtensionFields _ignoreUnknownFields = source._ignoreUnknownFields _index = source._index _init_p = source._init_p _inout = source._inout _inputType = source._inputType _insert = source._insert + _instruction = source._instruction _int = source._int _int32 = source._int32 - _int32Value = source._int32Value _int64 = source._int64 - _int64Value = source._int64Value _int8 = source._int8 _integerLiteral = source._integerLiteral _integerLiteralType = source._integerLiteralType _intern = source._intern _internal = source._internal _internalState = source._internalState + _intersect = source._intersect _into = source._into _ints = source._ints + _invalidAnyTypeURL = source._invalidAnyTypeURL _isA = source._isA _isEqual = source._isEqual _isEqualTo = source._isEqualTo _isExtension = source._isExtension _isInitialized_p = source._isInitialized_p + _isNegative = source._isNegative + _isPathValid = source._isPathValid + _isReserved = source._isReserved + _isValid = source._isValid _itemTagsEncodedSize = source._itemTagsEncodedSize _iterator = source._iterator - _i2166136261 = source._i2166136261 _javaGenerateEqualsAndHash = source._javaGenerateEqualsAndHash _javaGenericServices = source._javaGenericServices _javaMultipleFiles = source._javaMultipleFiles @@ -6606,12 +6790,15 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _javaPackage = source._javaPackage _javaStringCheckUtf8 = source._javaStringCheckUtf8 _jsondecoder = source._jsondecoder + _jsondecoding = source._jsondecoding _jsondecodingError = source._jsondecodingError _jsondecodingOptions = source._jsondecodingOptions _jsonEncoder = source._jsonEncoder + _jsonencoding = source._jsonencoding _jsonencodingError = source._jsonencodingError _jsonencodingOptions = source._jsonencodingOptions _jsonencodingVisitor = source._jsonencodingVisitor + _jsonFormat = source._jsonFormat _jsonmapEncodingVisitor = source._jsonmapEncodingVisitor _jsonName = source._jsonName _jsonPath = source._jsonPath @@ -6619,11 +6806,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _jsonscanner = source._jsonscanner _jsonString = source._jsonString _jsonText = source._jsonText + _jsonUtf8Bytes = source._jsonUtf8Bytes _jsonUtf8Data = source._jsonUtf8Data _jstype = source._jstype _k = source._k + _kChunkSize = source._kChunkSize _key = source._key _keyField = source._keyField + _keyFieldOpt = source._keyFieldOpt _keyType = source._keyType _kind = source._kind _l = source._l @@ -6635,42 +6825,44 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _lessThan = source._lessThan _let = source._let _lhs = source._lhs + _line = source._line _list = source._list _listOfMessages = source._listOfMessages _listValue = source._listValue _littleEndian = source._littleEndian - _littleEndianBytes = source._littleEndianBytes _load = source._load _localHasher = source._localHasher _location = source._location _m = source._m _major = source._major + _makeAsyncIterator = source._makeAsyncIterator _makeIterator = source._makeIterator + _malformedLength = source._malformedLength _mapEntry = source._mapEntry - _mapHash = source._mapHash _mapKeyType = source._mapKeyType - _mapNameResolver = source._mapNameResolver _mapToMessages = source._mapToMessages _mapValueType = source._mapValueType _mapVisitor = source._mapVisitor + _mask = source._mask + _maximumEdition = source._maximumEdition _mdayStart = source._mdayStart _merge = source._merge + _mergeOptions = source._mergeOptions _message = source._message _messageDepthLimit = source._messageDepthLimit + _messageEncoding = source._messageEncoding _messageExtension = source._messageExtension _messageImplementationBase = source._messageImplementationBase - _messageOptions = source._messageOptions _messageSet = source._messageSet _messageSetWireFormat = source._messageSetWireFormat + _messageSize = source._messageSize _messageType = source._messageType _method = source._method - _methodDescriptorProto = source._methodDescriptorProto - _methodOptions = source._methodOptions _methods = source._methods + _min = source._min + _minimumEdition = source._minimumEdition _minor = source._minor - _mixin = source._mixin _mixins = source._mixins - _modifier = source._modifier _modify = source._modify _month = source._month _msgExtension = source._msgExtension @@ -6680,44 +6872,53 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _nameDescription = source._nameDescription _nameMap = source._nameMap _namePart = source._namePart - _nameResolver = source._nameResolver _names = source._names _nanos = source._nanos - _nativeBytes = source._nativeBytes - _nativeEndianBytes = source._nativeEndianBytes _negativeIntValue = source._negativeIntValue _nestedType = source._nestedType + _newExtensible = source._newExtensible _newL = source._newL _newList = source._newList + _newMessage = source._newMessage _newValue = source._newValue + _next = source._next _nextByte = source._nextByte _nextFieldNumber = source._nextFieldNumber + _nextInstruction = source._nextInstruction + _nextInt32 = source._nextInt32 + _nextNullTerminatedString = source._nextNullTerminatedString + _nextNullTerminatedStringArray = source._nextNullTerminatedStringArray + _nextNumber = source._nextNumber + _nextUint64 = source._nextUint64 + _nextVarInt = source._nextVarInt _nil = source._nil _nilLiteral = source._nilLiteral + _noBytesAvailable = source._noBytesAvailable _noStandardDescriptorAccessor = source._noStandardDescriptorAccessor _nullValue = source._nullValue _number = source._number _numberValue = source._numberValue _objcClassPrefix = source._objcClassPrefix _of = source._of + _oneOfKind = source._oneOfKind _oneofDecl = source._oneofDecl - _oneofDescriptorProto = source._oneofDescriptorProto _oneofIndex = source._oneofIndex - _oneofOptions = source._oneofOptions _oneofs = source._oneofs - _oneOfKind = source._oneOfKind _optimizeFor = source._optimizeFor _optimizeMode = source._optimizeMode - _option = source._option _optionalEnumExtensionField = source._optionalEnumExtensionField _optionalExtensionField = source._optionalExtensionField _optionalGroupExtensionField = source._optionalGroupExtensionField _optionalMessageExtensionField = source._optionalMessageExtensionField + _optionDependency = source._optionDependency + _optionRetention = source._optionRetention _options = source._options + _optionTargetType = source._optionTargetType _other = source._other _others = source._others _out = source._out _outputType = source._outputType + _overridableFeatures = source._overridableFeatures _p = source._p _package = source._package _packed = source._packed @@ -6728,27 +6929,39 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _parse = source._parse _partial = source._partial _path = source._path + _pathDecoder = source._pathDecoder + _pathDecodingError = source._pathDecodingError _paths = source._paths + _pathVisitor = source._pathVisitor _payload = source._payload _payloadSize = source._payloadSize _phpClassPrefix = source._phpClassPrefix - _phpGenericServices = source._phpGenericServices _phpMetadataNamespace = source._phpMetadataNamespace _phpNamespace = source._phpNamespace - _pointer = source._pointer _pos = source._pos _positiveIntValue = source._positiveIntValue _prefix = source._prefix _preserveProtoFieldNames = source._preserveProtoFieldNames _preTraverse = source._preTraverse + _previousNumber = source._previousNumber + _prevPath = source._prevPath _printUnknownFields = source._printUnknownFields + _programBuffer = source._programBuffer + _programFormat = source._programFormat _proto2 = source._proto2 _proto3DefaultValue = source._proto3DefaultValue _proto3Optional = source._proto3Optional - _protobufApiversionCheck = source._protobufApiversionCheck + _protobufExtensionFieldValues = source._protobufExtensionFieldValues + _protobufFieldNumber = source._protobufFieldNumber + _protobufGeneratedIsEqualTo = source._protobufGeneratedIsEqualTo + _protobufNameMap = source._protobufNameMap + _protobufNewField = source._protobufNewField + _protobufPackage = source._protobufPackage _protobufApiversion2 = source._protobufApiversion2 + _protobufApiversionCheck = source._protobufApiversionCheck _protobufBool = source._protobufBool _protobufBytes = source._protobufBytes + _protobufData = source._protobufData _protobufDouble = source._protobufDouble _protobufEnumMap = source._protobufEnumMap _protobufExtension = source._protobufExtension @@ -6766,12 +6979,6 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _protobufString = source._protobufString _protobufUint32 = source._protobufUint32 _protobufUint64 = source._protobufUint64 - _protobufExtensionFieldValues = source._protobufExtensionFieldValues - _protobufFieldNumber = source._protobufFieldNumber - _protobufGeneratedIsEqualTo = source._protobufGeneratedIsEqualTo - _protobufNameMap = source._protobufNameMap - _protobufNewField = source._protobufNewField - _protobufPackage = source._protobufPackage _protocol = source._protocol _protoFieldName = source._protoFieldName _protoMessageName = source._protoMessageName @@ -6793,25 +7000,33 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _putVarInt = source._putVarInt _putZigZagVarInt = source._putZigZagVarInt _pyGenericServices = source._pyGenericServices + _r = source._r _rawChars = source._rawChars _rawRepresentable = source._rawRepresentable _rawValue = source._rawValue _read4HexDigits = source._read4HexDigits + _readBytes = source._readBytes + _reader = source._reader _register = source._register + _remainingProgram = source._remainingProgram + _removalError = source._removalError + _removingAllFieldsOf = source._removingAllFieldsOf + _repeated = source._repeated _repeatedEnumExtensionField = source._repeatedEnumExtensionField _repeatedExtensionField = source._repeatedExtensionField + _repeatedFieldEncoding = source._repeatedFieldEncoding _repeatedGroupExtensionField = source._repeatedGroupExtensionField _repeatedMessageExtensionField = source._repeatedMessageExtensionField + _repeating = source._repeating + _replaceRepeatedFields = source._replaceRepeatedFields _requestStreaming = source._requestStreaming _requestTypeURL = source._requestTypeURL _requiredSize = source._requiredSize - _reservedName = source._reservedName - _reservedRange = source._reservedRange _responseStreaming = source._responseStreaming _responseTypeURL = source._responseTypeURL _result = source._result + _retention = source._retention _rethrows = source._rethrows - _return = source._return _returnType = source._returnType _revision = source._revision _rhs = source._rhs @@ -6821,27 +7036,32 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _sawBackslash = source._sawBackslash _sawSection4Characters = source._sawSection4Characters _sawSection5Characters = source._sawSection5Characters + _scalar = source._scalar + _scan = source._scan _scanner = source._scanner _seconds = source._seconds _self_p = source._self_p + _semantic = source._semantic + _sendable = source._sendable _separator = source._separator _serialize = source._serialize + _serializedBytes = source._serializedBytes _serializedData = source._serializedData _serializedSize = source._serializedSize _serverStreaming = source._serverStreaming _service = source._service - _serviceDescriptorProto = source._serviceDescriptorProto - _serviceOptions = source._serviceOptions _set = source._set _setExtensionValue = source._setExtensionValue _shift = source._shift _simpleExtensionMap = source._simpleExtensionMap + _size = source._size _sizer = source._sizer _source = source._source _sourceCodeInfo = source._sourceCodeInfo _sourceContext = source._sourceContext _sourceEncoding = source._sourceEncoding _sourceFile = source._sourceFile + _sourceLocation = source._sourceLocation _span = source._span _split = source._split _start = source._start @@ -6865,13 +7085,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _structValue = source._structValue _subDecoder = source._subDecoder _subscript = source._subscript + _subtract = source._subtract _subVisitor = source._subVisitor _swift = source._swift _swiftPrefix = source._swiftPrefix - _swiftProtobuf = source._swiftProtobuf + _swiftProtobufContiguousBytes = source._swiftProtobufContiguousBytes + _swiftProtobufError = source._swiftProtobufError _syntax = source._syntax _t = source._t _tag = source._tag + _targets = source._targets _terminator = source._terminator _testDecoder = source._testDecoder _text = source._text @@ -6882,16 +7105,19 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _textFormatEncodingOptions = source._textFormatEncodingOptions _textFormatEncodingVisitor = source._textFormatEncodingVisitor _textFormatString = source._textFormatString + _throwOrIgnore = source._throwOrIgnore _throws = source._throws _timeInterval = source._timeInterval _timeIntervalSince1970 = source._timeIntervalSince1970 _timeIntervalSinceReferenceDate = source._timeIntervalSinceReferenceDate - _timestamp = source._timestamp + _tmp = source._tmp + _tooLarge = source._tooLarge _total = source._total _totalArrayDepth = source._totalArrayDepth _totalSize = source._totalSize _trailingComments = source._trailingComments _traverse = source._traverse + _trim = source._trim _true = source._true _try = source._try _type = source._type @@ -6903,10 +7129,10 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _typeUnknown = source._typeUnknown _typeURL = source._typeURL _uint32 = source._uint32 - _uint32Value = source._uint32Value _uint64 = source._uint64 - _uint64Value = source._uint64Value _uint8 = source._uint8 + _unchecked = source._unchecked + _unicode = source._unicode _unicodeScalarLiteral = source._unicodeScalarLiteral _unicodeScalarLiteralType = source._unicodeScalarLiteralType _unicodeScalars = source._unicodeScalars @@ -6921,14 +7147,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _unsafeBufferPointer = source._unsafeBufferPointer _unsafeMutablePointer = source._unsafeMutablePointer _unsafeMutableRawBufferPointer = source._unsafeMutableRawBufferPointer - _unsafeMutableRawPointer = source._unsafeMutableRawPointer _unsafeRawBufferPointer = source._unsafeRawBufferPointer _unsafeRawPointer = source._unsafeRawPointer + _unverifiedLazy = source._unverifiedLazy _updatedOptions = source._updatedOptions + _uppercasedAssumingAscii = source._uppercasedAssumingAscii _url = source._url + _useDeterministicOrdering = source._useDeterministicOrdering _utf8 = source._utf8 _utf8Ptr = source._utf8Ptr _utf8ToDouble = source._utf8ToDouble + _utf8Validation = source._utf8Validation _utf8View = source._utf8View _v = source._v _value = source._value @@ -6936,8 +7165,12 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _values = source._values _valueType = source._valueType _var = source._var + _verification = source._verification + _verificationState = source._verificationState _version = source._version _versionString = source._versionString + _visibility = source._visibility + _visibilityFeature = source._visibilityFeature _visitExtensionFields = source._visitExtensionFields _visitExtensionFieldsAsMessageSet = source._visitExtensionFieldsAsMessageSet _visitMapField = source._visitMapField @@ -6996,6 +7229,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _visitSingularUint32Field = source._visitSingularUint32Field _visitSingularUint64Field = source._visitSingularUint64Field _visitUnknown = source._visitUnknown + _void = source._void _wasDecoded = source._wasDecoded _weak = source._weak _weakDependency = source._weakDependency @@ -7005,7 +7239,9 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _withUnsafeBytes = source._withUnsafeBytes _withUnsafeMutableBytes = source._withUnsafeMutableBytes _work = source._work + _wrapped = source._wrapped _wrappedType = source._wrappedType + _wrappedValue = source._wrappedValue _written = source._written _yday = source._yday } @@ -7026,875 +7262,1033 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. // 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._adjusted) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._aggregateValue) }() - case 3: try { try decoder.decodeSingularInt32Field(value: &_storage._allCases) }() - case 4: try { try decoder.decodeSingularInt32Field(value: &_storage._allowAlias) }() - case 5: try { try decoder.decodeSingularInt32Field(value: &_storage._alwaysPrintEnumsAsInts) }() - case 6: try { try decoder.decodeSingularInt32Field(value: &_storage._annotation) }() - case 7: try { try decoder.decodeSingularInt32Field(value: &_storage._any) }() - case 8: try { try decoder.decodeSingularInt32Field(value: &_storage._anyExtensionField) }() - case 9: try { try decoder.decodeSingularInt32Field(value: &_storage._anyMessageExtension) }() - case 10: try { try decoder.decodeSingularInt32Field(value: &_storage._anyMessageStorage) }() - case 11: try { try decoder.decodeSingularInt32Field(value: &_storage._anyUnpackError) }() - case 12: try { try decoder.decodeSingularInt32Field(value: &_storage._api) }() - case 13: try { try decoder.decodeSingularInt32Field(value: &_storage._appended) }() - case 14: try { try decoder.decodeSingularInt32Field(value: &_storage._appendUintHex) }() - case 15: try { try decoder.decodeSingularInt32Field(value: &_storage._appendUnknown) }() - case 16: try { try decoder.decodeSingularInt32Field(value: &_storage._areAllInitialized) }() - case 17: try { try decoder.decodeSingularInt32Field(value: &_storage._array) }() - case 18: try { try decoder.decodeSingularInt32Field(value: &_storage._arrayDepth) }() - case 19: try { try decoder.decodeSingularInt32Field(value: &_storage._arrayLiteral) }() - case 20: try { try decoder.decodeSingularInt32Field(value: &_storage._arraySeparator) }() - case 21: try { try decoder.decodeSingularInt32Field(value: &_storage._as) }() - case 22: try { try decoder.decodeSingularInt32Field(value: &_storage._asciiOpenCurlyBracket) }() - case 23: try { try decoder.decodeSingularInt32Field(value: &_storage._asciiZero) }() - case 24: try { try decoder.decodeSingularInt32Field(value: &_storage._available) }() - case 25: try { try decoder.decodeSingularInt32Field(value: &_storage._b) }() - case 26: try { try decoder.decodeSingularInt32Field(value: &_storage._base64Values) }() - case 27: try { try decoder.decodeSingularInt32Field(value: &_storage._baseAddress) }() - case 28: try { try decoder.decodeSingularInt32Field(value: &_storage._baseType) }() - case 29: try { try decoder.decodeSingularInt32Field(value: &_storage._begin) }() - case 30: try { try decoder.decodeSingularInt32Field(value: &_storage._binary) }() - case 31: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryDecoder) }() - case 32: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryDecodingError) }() - case 33: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryDecodingOptions) }() - case 34: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryDelimited) }() - case 35: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncoder) }() - case 36: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingError) }() - case 37: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingMessageSetSizeVisitor) }() - case 38: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingMessageSetVisitor) }() - case 39: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingSizeVisitor) }() - case 40: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingVisitor) }() - case 41: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryOptions) }() - case 42: try { try decoder.decodeSingularInt32Field(value: &_storage._body) }() - case 43: try { try decoder.decodeSingularInt32Field(value: &_storage._bool) }() - case 44: try { try decoder.decodeSingularInt32Field(value: &_storage._booleanLiteral) }() - case 45: try { try decoder.decodeSingularInt32Field(value: &_storage._booleanLiteralType) }() - case 46: try { try decoder.decodeSingularInt32Field(value: &_storage._boolValue) }() - case 47: try { try decoder.decodeSingularInt32Field(value: &_storage._bytes) }() - case 48: try { try decoder.decodeSingularInt32Field(value: &_storage._bytesInGroup) }() - case 49: try { try decoder.decodeSingularInt32Field(value: &_storage._bytesRead) }() - case 50: try { try decoder.decodeSingularInt32Field(value: &_storage._bytesValue) }() - case 51: try { try decoder.decodeSingularInt32Field(value: &_storage._c) }() - case 52: try { try decoder.decodeSingularInt32Field(value: &_storage._capitalizeNext) }() - case 53: try { try decoder.decodeSingularInt32Field(value: &_storage._cardinality) }() - case 54: try { try decoder.decodeSingularInt32Field(value: &_storage._ccEnableArenas) }() - case 55: try { try decoder.decodeSingularInt32Field(value: &_storage._ccGenericServices) }() - case 56: try { try decoder.decodeSingularInt32Field(value: &_storage._character) }() - case 57: try { try decoder.decodeSingularInt32Field(value: &_storage._chars) }() - case 58: try { try decoder.decodeSingularInt32Field(value: &_storage._class) }() - case 59: try { try decoder.decodeSingularInt32Field(value: &_storage._clearAggregateValue_p) }() - case 60: try { try decoder.decodeSingularInt32Field(value: &_storage._clearAllowAlias_p) }() - case 61: try { try decoder.decodeSingularInt32Field(value: &_storage._clearBegin_p) }() - case 62: try { try decoder.decodeSingularInt32Field(value: &_storage._clearCcEnableArenas_p) }() - case 63: try { try decoder.decodeSingularInt32Field(value: &_storage._clearCcGenericServices_p) }() - case 64: try { try decoder.decodeSingularInt32Field(value: &_storage._clearClientStreaming_p) }() - case 65: try { try decoder.decodeSingularInt32Field(value: &_storage._clearCsharpNamespace_p) }() - case 66: try { try decoder.decodeSingularInt32Field(value: &_storage._clearCtype_p) }() - case 67: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDefaultValue_p) }() - case 68: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDeprecated_p) }() - case 69: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDoubleValue_p) }() - case 70: try { try decoder.decodeSingularInt32Field(value: &_storage._clearEnd_p) }() - case 71: try { try decoder.decodeSingularInt32Field(value: &_storage._clearExtendee_p) }() - case 72: try { try decoder.decodeSingularInt32Field(value: &_storage._clearExtensionValue_p) }() - case 73: try { try decoder.decodeSingularInt32Field(value: &_storage._clearGoPackage_p) }() - case 74: try { try decoder.decodeSingularInt32Field(value: &_storage._clearIdempotencyLevel_p) }() - case 75: try { try decoder.decodeSingularInt32Field(value: &_storage._clearIdentifierValue_p) }() - case 76: try { try decoder.decodeSingularInt32Field(value: &_storage._clearInputType_p) }() - case 77: try { try decoder.decodeSingularInt32Field(value: &_storage._clearIsExtension_p) }() - case 78: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaGenerateEqualsAndHash_p) }() - case 79: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaGenericServices_p) }() - case 80: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaMultipleFiles_p) }() - case 81: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaOuterClassname_p) }() - case 82: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaPackage_p) }() - case 83: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaStringCheckUtf8_p) }() - case 84: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJsonName_p) }() - case 85: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJstype_p) }() - case 86: try { try decoder.decodeSingularInt32Field(value: &_storage._clearLabel_p) }() - case 87: try { try decoder.decodeSingularInt32Field(value: &_storage._clearLazy_p) }() - case 88: try { try decoder.decodeSingularInt32Field(value: &_storage._clearLeadingComments_p) }() - case 89: try { try decoder.decodeSingularInt32Field(value: &_storage._clearMapEntry_p) }() - case 90: try { try decoder.decodeSingularInt32Field(value: &_storage._clearMessageSetWireFormat_p) }() - case 91: try { try decoder.decodeSingularInt32Field(value: &_storage._clearName_p) }() - case 92: try { try decoder.decodeSingularInt32Field(value: &_storage._clearNamePart_p) }() - case 93: try { try decoder.decodeSingularInt32Field(value: &_storage._clearNegativeIntValue_p) }() - case 94: try { try decoder.decodeSingularInt32Field(value: &_storage._clearNoStandardDescriptorAccessor_p) }() - case 95: try { try decoder.decodeSingularInt32Field(value: &_storage._clearNumber_p) }() - case 96: try { try decoder.decodeSingularInt32Field(value: &_storage._clearObjcClassPrefix_p) }() - case 97: try { try decoder.decodeSingularInt32Field(value: &_storage._clearOneofIndex_p) }() - case 98: try { try decoder.decodeSingularInt32Field(value: &_storage._clearOptimizeFor_p) }() - case 99: try { try decoder.decodeSingularInt32Field(value: &_storage._clearOptions_p) }() - case 100: try { try decoder.decodeSingularInt32Field(value: &_storage._clearOutputType_p) }() - case 101: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPackage_p) }() - case 102: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPacked_p) }() - case 103: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPhpClassPrefix_p) }() - case 104: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPhpGenericServices_p) }() - case 105: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPhpMetadataNamespace_p) }() - case 106: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPhpNamespace_p) }() - case 107: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPositiveIntValue_p) }() - case 108: try { try decoder.decodeSingularInt32Field(value: &_storage._clearProto3Optional_p) }() - case 109: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPyGenericServices_p) }() - case 110: try { try decoder.decodeSingularInt32Field(value: &_storage._clearRubyPackage_p) }() - case 111: try { try decoder.decodeSingularInt32Field(value: &_storage._clearServerStreaming_p) }() - case 112: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSourceCodeInfo_p) }() - case 113: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSourceContext_p) }() - case 114: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSourceFile_p) }() - case 115: try { try decoder.decodeSingularInt32Field(value: &_storage._clearStart_p) }() - case 116: try { try decoder.decodeSingularInt32Field(value: &_storage._clearStringValue_p) }() - case 117: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSwiftPrefix_p) }() - case 118: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSyntax_p) }() - case 119: try { try decoder.decodeSingularInt32Field(value: &_storage._clearTrailingComments_p) }() - case 120: try { try decoder.decodeSingularInt32Field(value: &_storage._clearType_p) }() - case 121: try { try decoder.decodeSingularInt32Field(value: &_storage._clearTypeName_p) }() - case 122: try { try decoder.decodeSingularInt32Field(value: &_storage._clearValue_p) }() - case 123: try { try decoder.decodeSingularInt32Field(value: &_storage._clearWeak_p) }() - case 124: try { try decoder.decodeSingularInt32Field(value: &_storage._clientStreaming) }() - case 125: try { try decoder.decodeSingularInt32Field(value: &_storage._codePoint) }() - case 126: try { try decoder.decodeSingularInt32Field(value: &_storage._codeUnits) }() - case 127: try { try decoder.decodeSingularInt32Field(value: &_storage._collection) }() - case 128: try { try decoder.decodeSingularInt32Field(value: &_storage._com) }() - case 129: try { try decoder.decodeSingularInt32Field(value: &_storage._comma) }() - case 130: try { try decoder.decodeSingularInt32Field(value: &_storage._contentsOf) }() - case 131: try { try decoder.decodeSingularInt32Field(value: &_storage._contiguousBytes) }() - case 132: try { try decoder.decodeSingularInt32Field(value: &_storage._count) }() - case 133: try { try decoder.decodeSingularInt32Field(value: &_storage._countVarintsInBuffer) }() - case 134: try { try decoder.decodeSingularInt32Field(value: &_storage._csharpNamespace) }() - case 135: try { try decoder.decodeSingularInt32Field(value: &_storage._ctype) }() - case 136: try { try decoder.decodeSingularInt32Field(value: &_storage._customCodable) }() - case 137: try { try decoder.decodeSingularInt32Field(value: &_storage._customDebugStringConvertible) }() - case 138: try { try decoder.decodeSingularInt32Field(value: &_storage._d) }() - case 139: try { try decoder.decodeSingularInt32Field(value: &_storage._data) }() - case 140: try { try decoder.decodeSingularInt32Field(value: &_storage._dataResult) }() - case 141: try { try decoder.decodeSingularInt32Field(value: &_storage._date) }() - case 142: try { try decoder.decodeSingularInt32Field(value: &_storage._daySec) }() - case 143: try { try decoder.decodeSingularInt32Field(value: &_storage._daysSinceEpoch) }() - case 144: try { try decoder.decodeSingularInt32Field(value: &_storage._debugDescription_p) }() - case 145: try { try decoder.decodeSingularInt32Field(value: &_storage._decoded) }() - case 146: try { try decoder.decodeSingularInt32Field(value: &_storage._decodedFromJsonnull) }() - case 147: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeExtensionField) }() - case 148: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeExtensionFieldsAsMessageSet) }() - case 149: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeJson) }() - case 150: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeMapField) }() - case 151: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeMessage) }() - case 152: try { try decoder.decodeSingularInt32Field(value: &_storage._decoder) }() - case 153: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeated) }() - case 154: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedBoolField) }() - case 155: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedBytesField) }() - case 156: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedDoubleField) }() - case 157: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedEnumField) }() - case 158: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedFixed32Field) }() - case 159: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedFixed64Field) }() - case 160: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedFloatField) }() - case 161: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedGroupField) }() - case 162: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedInt32Field) }() - case 163: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedInt64Field) }() - case 164: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedMessageField) }() - case 165: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedSfixed32Field) }() - case 166: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedSfixed64Field) }() - case 167: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedSint32Field) }() - case 168: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedSint64Field) }() - case 169: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedStringField) }() - case 170: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedUint32Field) }() - case 171: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedUint64Field) }() - case 172: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingular) }() - case 173: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularBoolField) }() - case 174: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularBytesField) }() - case 175: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularDoubleField) }() - case 176: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularEnumField) }() - case 177: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularFixed32Field) }() - case 178: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularFixed64Field) }() - case 179: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularFloatField) }() - case 180: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularGroupField) }() - case 181: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularInt32Field) }() - case 182: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularInt64Field) }() - case 183: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularMessageField) }() - case 184: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularSfixed32Field) }() - case 185: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularSfixed64Field) }() - case 186: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularSint32Field) }() - case 187: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularSint64Field) }() - case 188: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularStringField) }() - case 189: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularUint32Field) }() - case 190: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularUint64Field) }() - case 191: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeTextFormat) }() - case 192: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultAnyTypeUrlprefix) }() - case 193: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultValue) }() - case 194: try { try decoder.decodeSingularInt32Field(value: &_storage._dependency) }() - case 195: try { try decoder.decodeSingularInt32Field(value: &_storage._deprecated) }() - case 196: try { try decoder.decodeSingularInt32Field(value: &_storage._description_p) }() - case 197: try { try decoder.decodeSingularInt32Field(value: &_storage._descriptorProto) }() - case 198: try { try decoder.decodeSingularInt32Field(value: &_storage._dictionary) }() - case 199: try { try decoder.decodeSingularInt32Field(value: &_storage._dictionaryLiteral) }() - case 200: try { try decoder.decodeSingularInt32Field(value: &_storage._digit) }() - case 201: try { try decoder.decodeSingularInt32Field(value: &_storage._digit0) }() - case 202: try { try decoder.decodeSingularInt32Field(value: &_storage._digit1) }() - case 203: try { try decoder.decodeSingularInt32Field(value: &_storage._digitCount) }() - case 204: try { try decoder.decodeSingularInt32Field(value: &_storage._digits) }() - case 205: try { try decoder.decodeSingularInt32Field(value: &_storage._digitValue) }() - case 206: try { try decoder.decodeSingularInt32Field(value: &_storage._discardableResult) }() - case 207: try { try decoder.decodeSingularInt32Field(value: &_storage._discardUnknownFields) }() - case 208: try { try decoder.decodeSingularInt32Field(value: &_storage._distance) }() - case 209: try { try decoder.decodeSingularInt32Field(value: &_storage._double) }() - case 210: try { try decoder.decodeSingularInt32Field(value: &_storage._doubleValue) }() - case 211: try { try decoder.decodeSingularInt32Field(value: &_storage._duration) }() - case 212: try { try decoder.decodeSingularInt32Field(value: &_storage._e) }() - case 213: try { try decoder.decodeSingularInt32Field(value: &_storage._element) }() - case 214: try { try decoder.decodeSingularInt32Field(value: &_storage._elements) }() - case 215: try { try decoder.decodeSingularInt32Field(value: &_storage._emitExtensionFieldName) }() - case 216: try { try decoder.decodeSingularInt32Field(value: &_storage._emitFieldName) }() - case 217: try { try decoder.decodeSingularInt32Field(value: &_storage._emitFieldNumber) }() - case 218: try { try decoder.decodeSingularInt32Field(value: &_storage._empty) }() - case 219: try { try decoder.decodeSingularInt32Field(value: &_storage._emptyData) }() - case 220: try { try decoder.decodeSingularInt32Field(value: &_storage._encodeAsBytes) }() - case 221: try { try decoder.decodeSingularInt32Field(value: &_storage._encoded) }() - case 222: try { try decoder.decodeSingularInt32Field(value: &_storage._encodedJsonstring) }() - case 223: try { try decoder.decodeSingularInt32Field(value: &_storage._encodedSize) }() - case 224: try { try decoder.decodeSingularInt32Field(value: &_storage._encodeField) }() - case 225: try { try decoder.decodeSingularInt32Field(value: &_storage._encoder) }() - case 226: try { try decoder.decodeSingularInt32Field(value: &_storage._end) }() - case 227: try { try decoder.decodeSingularInt32Field(value: &_storage._endArray) }() - case 228: try { try decoder.decodeSingularInt32Field(value: &_storage._endMessageField) }() - case 229: try { try decoder.decodeSingularInt32Field(value: &_storage._endObject) }() - case 230: try { try decoder.decodeSingularInt32Field(value: &_storage._endRegularField) }() - case 231: try { try decoder.decodeSingularInt32Field(value: &_storage._enum) }() - case 232: try { try decoder.decodeSingularInt32Field(value: &_storage._enumDescriptorProto) }() - case 233: try { try decoder.decodeSingularInt32Field(value: &_storage._enumOptions) }() - case 234: try { try decoder.decodeSingularInt32Field(value: &_storage._enumReservedRange) }() - case 235: try { try decoder.decodeSingularInt32Field(value: &_storage._enumType) }() - case 236: try { try decoder.decodeSingularInt32Field(value: &_storage._enumvalue) }() - case 237: try { try decoder.decodeSingularInt32Field(value: &_storage._enumValueDescriptorProto) }() - case 238: try { try decoder.decodeSingularInt32Field(value: &_storage._enumValueOptions) }() - case 239: try { try decoder.decodeSingularInt32Field(value: &_storage._equatable) }() - case 240: try { try decoder.decodeSingularInt32Field(value: &_storage._error) }() - case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._expressibleByArrayLiteral) }() - case 242: try { try decoder.decodeSingularInt32Field(value: &_storage._expressibleByDictionaryLiteral) }() - case 243: try { try decoder.decodeSingularInt32Field(value: &_storage._ext) }() - case 244: try { try decoder.decodeSingularInt32Field(value: &_storage._extDecoder) }() - case 245: try { try decoder.decodeSingularInt32Field(value: &_storage._extendedGraphemeClusterLiteral) }() - case 246: try { try decoder.decodeSingularInt32Field(value: &_storage._extendedGraphemeClusterLiteralType) }() - case 247: try { try decoder.decodeSingularInt32Field(value: &_storage._extendee) }() - case 248: try { try decoder.decodeSingularInt32Field(value: &_storage._extensibleMessage) }() - case 249: try { try decoder.decodeSingularInt32Field(value: &_storage._extension) }() - case 250: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionField) }() - case 251: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionFieldNumber) }() - case 252: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionFieldValueSet) }() - case 253: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionMap) }() - case 254: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionRange) }() - case 255: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionRangeOptions) }() - case 256: try { try decoder.decodeSingularInt32Field(value: &_storage._extensions) }() - case 257: try { try decoder.decodeSingularInt32Field(value: &_storage._extras) }() - case 258: try { try decoder.decodeSingularInt32Field(value: &_storage._f) }() - case 259: try { try decoder.decodeSingularInt32Field(value: &_storage._false) }() - case 260: try { try decoder.decodeSingularInt32Field(value: &_storage._field) }() - case 261: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldData) }() - case 262: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldDescriptorProto) }() - case 263: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldMask) }() - case 264: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName) }() - case 265: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNameCount) }() - case 266: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNum) }() - case 267: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNumber) }() - case 268: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNumberForProto) }() - case 269: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldOptions) }() - case 270: try { try decoder.decodeSingularInt32Field(value: &_storage._fields) }() - case 271: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldSize) }() - case 272: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldTag) }() - case 273: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldType) }() - case 274: try { try decoder.decodeSingularInt32Field(value: &_storage._file) }() - case 275: try { try decoder.decodeSingularInt32Field(value: &_storage._fileDescriptorProto) }() - case 276: try { try decoder.decodeSingularInt32Field(value: &_storage._fileDescriptorSet) }() - case 277: try { try decoder.decodeSingularInt32Field(value: &_storage._fileName) }() - case 278: try { try decoder.decodeSingularInt32Field(value: &_storage._fileOptions) }() - case 279: try { try decoder.decodeSingularInt32Field(value: &_storage._filter) }() - case 280: try { try decoder.decodeSingularInt32Field(value: &_storage._first) }() - case 281: try { try decoder.decodeSingularInt32Field(value: &_storage._firstItem) }() - case 282: try { try decoder.decodeSingularInt32Field(value: &_storage._float) }() - case 283: try { try decoder.decodeSingularInt32Field(value: &_storage._floatLiteral) }() - case 284: try { try decoder.decodeSingularInt32Field(value: &_storage._floatLiteralType) }() - case 285: try { try decoder.decodeSingularInt32Field(value: &_storage._floatValue) }() - case 286: try { try decoder.decodeSingularInt32Field(value: &_storage._forMessageName) }() - case 287: try { try decoder.decodeSingularInt32Field(value: &_storage._formUnion) }() - case 288: try { try decoder.decodeSingularInt32Field(value: &_storage._forReadingFrom) }() - case 289: try { try decoder.decodeSingularInt32Field(value: &_storage._forTypeURL) }() - case 290: try { try decoder.decodeSingularInt32Field(value: &_storage._forwardParser) }() - case 291: try { try decoder.decodeSingularInt32Field(value: &_storage._forWritingInto) }() - case 292: try { try decoder.decodeSingularInt32Field(value: &_storage._from) }() - case 293: try { try decoder.decodeSingularInt32Field(value: &_storage._fromAscii2) }() - case 294: try { try decoder.decodeSingularInt32Field(value: &_storage._fromAscii4) }() - case 295: try { try decoder.decodeSingularInt32Field(value: &_storage._fromByteOffset) }() - case 296: try { try decoder.decodeSingularInt32Field(value: &_storage._fromHexDigit) }() - case 297: try { try decoder.decodeSingularInt32Field(value: &_storage._func) }() - case 298: try { try decoder.decodeSingularInt32Field(value: &_storage._g) }() - case 299: try { try decoder.decodeSingularInt32Field(value: &_storage._generatedCodeInfo) }() - case 300: try { try decoder.decodeSingularInt32Field(value: &_storage._get) }() - case 301: try { try decoder.decodeSingularInt32Field(value: &_storage._getExtensionValue) }() - case 302: try { try decoder.decodeSingularInt32Field(value: &_storage._googleapis) }() - case 303: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufAny) }() - case 304: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufApi) }() - case 305: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufBoolValue) }() - case 306: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufBytesValue) }() - case 307: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufDescriptorProto) }() - case 308: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufDoubleValue) }() - case 309: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufDuration) }() - case 310: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEmpty) }() - case 311: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnum) }() - case 312: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumDescriptorProto) }() - case 313: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumOptions) }() - case 314: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumValue) }() - case 315: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumValueDescriptorProto) }() - case 316: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumValueOptions) }() - case 317: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufExtensionRangeOptions) }() - case 318: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufField) }() - case 319: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFieldDescriptorProto) }() - case 320: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFieldMask) }() - case 321: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFieldOptions) }() - case 322: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFileDescriptorProto) }() - case 323: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFileDescriptorSet) }() - case 324: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFileOptions) }() - case 325: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFloatValue) }() - case 326: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufGeneratedCodeInfo) }() - case 327: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufInt32Value) }() - case 328: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufInt64Value) }() - case 329: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufListValue) }() - case 330: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMessageOptions) }() - case 331: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMethod) }() - case 332: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMethodDescriptorProto) }() - case 333: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMethodOptions) }() - case 334: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMixin) }() - case 335: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufNullValue) }() - case 336: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufOneofDescriptorProto) }() - case 337: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufOneofOptions) }() - case 338: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufOption) }() - case 339: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufServiceDescriptorProto) }() - case 340: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufServiceOptions) }() - case 341: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSourceCodeInfo) }() - case 342: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSourceContext) }() - case 343: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufStringValue) }() - case 344: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufStruct) }() - case 345: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSyntax) }() - case 346: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufTimestamp) }() - case 347: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufType) }() - case 348: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufUint32Value) }() - case 349: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufUint64Value) }() - case 350: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufUninterpretedOption) }() - case 351: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufValue) }() - case 352: try { try decoder.decodeSingularInt32Field(value: &_storage._goPackage) }() - case 353: try { try decoder.decodeSingularInt32Field(value: &_storage._group) }() - case 354: try { try decoder.decodeSingularInt32Field(value: &_storage._groupFieldNumberStack) }() - case 355: try { try decoder.decodeSingularInt32Field(value: &_storage._groupSize) }() - case 356: try { try decoder.decodeSingularInt32Field(value: &_storage._h) }() - case 357: try { try decoder.decodeSingularInt32Field(value: &_storage._hadOneofValue) }() - case 358: try { try decoder.decodeSingularInt32Field(value: &_storage._handleConflictingOneOf) }() - case 359: try { try decoder.decodeSingularInt32Field(value: &_storage._hasAggregateValue_p) }() - case 360: try { try decoder.decodeSingularInt32Field(value: &_storage._hasAllowAlias_p) }() - case 361: try { try decoder.decodeSingularInt32Field(value: &_storage._hasBegin_p) }() - case 362: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCcEnableArenas_p) }() - case 363: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCcGenericServices_p) }() - case 364: try { try decoder.decodeSingularInt32Field(value: &_storage._hasClientStreaming_p) }() - case 365: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCsharpNamespace_p) }() - case 366: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCtype_p) }() - case 367: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDefaultValue_p) }() - case 368: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDeprecated_p) }() - case 369: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDoubleValue_p) }() - case 370: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEnd_p) }() - case 371: try { try decoder.decodeSingularInt32Field(value: &_storage._hasExtendee_p) }() - case 372: try { try decoder.decodeSingularInt32Field(value: &_storage._hasExtensionValue_p) }() - case 373: try { try decoder.decodeSingularInt32Field(value: &_storage._hasGoPackage_p) }() - case 374: try { try decoder.decodeSingularInt32Field(value: &_storage._hash) }() - case 375: try { try decoder.decodeSingularInt32Field(value: &_storage._hashable) }() - case 376: try { try decoder.decodeSingularInt32Field(value: &_storage._hasher) }() - case 377: try { try decoder.decodeSingularInt32Field(value: &_storage._hashValue_p) }() - case 378: try { try decoder.decodeSingularInt32Field(value: &_storage._hashVisitor) }() - case 379: try { try decoder.decodeSingularInt32Field(value: &_storage._hasIdempotencyLevel_p) }() - case 380: try { try decoder.decodeSingularInt32Field(value: &_storage._hasIdentifierValue_p) }() - case 381: try { try decoder.decodeSingularInt32Field(value: &_storage._hasInputType_p) }() - case 382: try { try decoder.decodeSingularInt32Field(value: &_storage._hasIsExtension_p) }() - case 383: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaGenerateEqualsAndHash_p) }() - case 384: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaGenericServices_p) }() - case 385: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaMultipleFiles_p) }() - case 386: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaOuterClassname_p) }() - case 387: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaPackage_p) }() - case 388: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaStringCheckUtf8_p) }() - case 389: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJsonName_p) }() - case 390: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJstype_p) }() - case 391: try { try decoder.decodeSingularInt32Field(value: &_storage._hasLabel_p) }() - case 392: try { try decoder.decodeSingularInt32Field(value: &_storage._hasLazy_p) }() - case 393: try { try decoder.decodeSingularInt32Field(value: &_storage._hasLeadingComments_p) }() - case 394: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMapEntry_p) }() - case 395: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMessageSetWireFormat_p) }() - case 396: try { try decoder.decodeSingularInt32Field(value: &_storage._hasName_p) }() - case 397: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNamePart_p) }() - case 398: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNegativeIntValue_p) }() - case 399: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNoStandardDescriptorAccessor_p) }() - case 400: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNumber_p) }() - case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._hasObjcClassPrefix_p) }() - case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOneofIndex_p) }() - case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOptimizeFor_p) }() - case 404: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOptions_p) }() - case 405: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOutputType_p) }() - case 406: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPackage_p) }() - case 407: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPacked_p) }() - case 408: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpClassPrefix_p) }() - case 409: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpGenericServices_p) }() - case 410: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpMetadataNamespace_p) }() - case 411: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpNamespace_p) }() - case 412: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPositiveIntValue_p) }() - case 413: try { try decoder.decodeSingularInt32Field(value: &_storage._hasProto3Optional_p) }() - case 414: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPyGenericServices_p) }() - case 415: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRubyPackage_p) }() - case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._hasServerStreaming_p) }() - case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSourceCodeInfo_p) }() - case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSourceContext_p) }() - case 419: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSourceFile_p) }() - case 420: try { try decoder.decodeSingularInt32Field(value: &_storage._hasStart_p) }() - case 421: try { try decoder.decodeSingularInt32Field(value: &_storage._hasStringValue_p) }() - case 422: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSwiftPrefix_p) }() - case 423: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSyntax_p) }() - case 424: try { try decoder.decodeSingularInt32Field(value: &_storage._hasTrailingComments_p) }() - case 425: try { try decoder.decodeSingularInt32Field(value: &_storage._hasType_p) }() - case 426: try { try decoder.decodeSingularInt32Field(value: &_storage._hasTypeName_p) }() - case 427: try { try decoder.decodeSingularInt32Field(value: &_storage._hasValue_p) }() - case 428: try { try decoder.decodeSingularInt32Field(value: &_storage._hasWeak_p) }() - case 429: try { try decoder.decodeSingularInt32Field(value: &_storage._hour) }() - case 430: try { try decoder.decodeSingularInt32Field(value: &_storage._i) }() - case 431: try { try decoder.decodeSingularInt32Field(value: &_storage._idempotencyLevel) }() - case 432: try { try decoder.decodeSingularInt32Field(value: &_storage._identifierValue) }() - case 433: try { try decoder.decodeSingularInt32Field(value: &_storage._if) }() - case 434: try { try decoder.decodeSingularInt32Field(value: &_storage._ignoreUnknownFields) }() - case 435: try { try decoder.decodeSingularInt32Field(value: &_storage._index) }() - case 436: try { try decoder.decodeSingularInt32Field(value: &_storage._init_p) }() - case 437: try { try decoder.decodeSingularInt32Field(value: &_storage._inout) }() - case 438: try { try decoder.decodeSingularInt32Field(value: &_storage._inputType) }() - case 439: try { try decoder.decodeSingularInt32Field(value: &_storage._insert) }() - case 440: try { try decoder.decodeSingularInt32Field(value: &_storage._int) }() - case 441: try { try decoder.decodeSingularInt32Field(value: &_storage._int32) }() - case 442: try { try decoder.decodeSingularInt32Field(value: &_storage._int32Value) }() - case 443: try { try decoder.decodeSingularInt32Field(value: &_storage._int64) }() - case 444: try { try decoder.decodeSingularInt32Field(value: &_storage._int64Value) }() - case 445: try { try decoder.decodeSingularInt32Field(value: &_storage._int8) }() - case 446: try { try decoder.decodeSingularInt32Field(value: &_storage._integerLiteral) }() - case 447: try { try decoder.decodeSingularInt32Field(value: &_storage._integerLiteralType) }() - case 448: try { try decoder.decodeSingularInt32Field(value: &_storage._intern) }() - case 449: try { try decoder.decodeSingularInt32Field(value: &_storage._internal) }() - case 450: try { try decoder.decodeSingularInt32Field(value: &_storage._internalState) }() - case 451: try { try decoder.decodeSingularInt32Field(value: &_storage._into) }() - case 452: try { try decoder.decodeSingularInt32Field(value: &_storage._ints) }() - case 453: try { try decoder.decodeSingularInt32Field(value: &_storage._isA) }() - case 454: try { try decoder.decodeSingularInt32Field(value: &_storage._isEqual) }() - case 455: try { try decoder.decodeSingularInt32Field(value: &_storage._isEqualTo) }() - case 456: try { try decoder.decodeSingularInt32Field(value: &_storage._isExtension) }() - case 457: try { try decoder.decodeSingularInt32Field(value: &_storage._isInitialized_p) }() - case 458: try { try decoder.decodeSingularInt32Field(value: &_storage._itemTagsEncodedSize) }() - case 459: try { try decoder.decodeSingularInt32Field(value: &_storage._iterator) }() - case 460: try { try decoder.decodeSingularInt32Field(value: &_storage._i2166136261) }() - case 461: try { try decoder.decodeSingularInt32Field(value: &_storage._javaGenerateEqualsAndHash) }() - case 462: try { try decoder.decodeSingularInt32Field(value: &_storage._javaGenericServices) }() - case 463: try { try decoder.decodeSingularInt32Field(value: &_storage._javaMultipleFiles) }() - case 464: try { try decoder.decodeSingularInt32Field(value: &_storage._javaOuterClassname) }() - case 465: try { try decoder.decodeSingularInt32Field(value: &_storage._javaPackage) }() - case 466: try { try decoder.decodeSingularInt32Field(value: &_storage._javaStringCheckUtf8) }() - case 467: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecoder) }() - case 468: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecodingError) }() - case 469: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecodingOptions) }() - case 470: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonEncoder) }() - case 471: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencodingError) }() - case 472: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencodingOptions) }() - case 473: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencodingVisitor) }() - case 474: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonmapEncodingVisitor) }() - case 475: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonName) }() - case 476: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonPath) }() - case 477: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonPaths) }() - case 478: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonscanner) }() - case 479: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonString) }() - case 480: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonText) }() - case 481: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonUtf8Data) }() - case 482: try { try decoder.decodeSingularInt32Field(value: &_storage._jstype) }() - case 483: try { try decoder.decodeSingularInt32Field(value: &_storage._k) }() - case 484: try { try decoder.decodeSingularInt32Field(value: &_storage._key) }() - case 485: try { try decoder.decodeSingularInt32Field(value: &_storage._keyField) }() - case 486: try { try decoder.decodeSingularInt32Field(value: &_storage._keyType) }() - case 487: try { try decoder.decodeSingularInt32Field(value: &_storage._kind) }() - case 488: try { try decoder.decodeSingularInt32Field(value: &_storage._l) }() - case 489: try { try decoder.decodeSingularInt32Field(value: &_storage._label) }() - case 490: try { try decoder.decodeSingularInt32Field(value: &_storage._lazy) }() - case 491: try { try decoder.decodeSingularInt32Field(value: &_storage._leadingComments) }() - case 492: try { try decoder.decodeSingularInt32Field(value: &_storage._leadingDetachedComments) }() - case 493: try { try decoder.decodeSingularInt32Field(value: &_storage._length) }() - case 494: try { try decoder.decodeSingularInt32Field(value: &_storage._lessThan) }() - case 495: try { try decoder.decodeSingularInt32Field(value: &_storage._let) }() - case 496: try { try decoder.decodeSingularInt32Field(value: &_storage._lhs) }() - case 497: try { try decoder.decodeSingularInt32Field(value: &_storage._list) }() - case 498: try { try decoder.decodeSingularInt32Field(value: &_storage._listOfMessages) }() - case 499: try { try decoder.decodeSingularInt32Field(value: &_storage._listValue) }() - case 500: try { try decoder.decodeSingularInt32Field(value: &_storage._littleEndian) }() - case 501: try { try decoder.decodeSingularInt32Field(value: &_storage._littleEndianBytes) }() - case 502: try { try decoder.decodeSingularInt32Field(value: &_storage._load) }() - case 503: try { try decoder.decodeSingularInt32Field(value: &_storage._localHasher) }() - case 504: try { try decoder.decodeSingularInt32Field(value: &_storage._location) }() - case 505: try { try decoder.decodeSingularInt32Field(value: &_storage._m) }() - case 506: try { try decoder.decodeSingularInt32Field(value: &_storage._major) }() - case 507: try { try decoder.decodeSingularInt32Field(value: &_storage._makeIterator) }() - case 508: try { try decoder.decodeSingularInt32Field(value: &_storage._mapEntry) }() - case 509: try { try decoder.decodeSingularInt32Field(value: &_storage._mapHash) }() - case 510: try { try decoder.decodeSingularInt32Field(value: &_storage._mapKeyType) }() - case 511: try { try decoder.decodeSingularInt32Field(value: &_storage._mapNameResolver) }() - case 512: try { try decoder.decodeSingularInt32Field(value: &_storage._mapToMessages) }() - case 513: try { try decoder.decodeSingularInt32Field(value: &_storage._mapValueType) }() - case 514: try { try decoder.decodeSingularInt32Field(value: &_storage._mapVisitor) }() - case 515: try { try decoder.decodeSingularInt32Field(value: &_storage._mdayStart) }() - case 516: try { try decoder.decodeSingularInt32Field(value: &_storage._merge) }() - case 517: try { try decoder.decodeSingularInt32Field(value: &_storage._message) }() - case 518: try { try decoder.decodeSingularInt32Field(value: &_storage._messageDepthLimit) }() - case 519: try { try decoder.decodeSingularInt32Field(value: &_storage._messageExtension) }() - case 520: try { try decoder.decodeSingularInt32Field(value: &_storage._messageImplementationBase) }() - case 521: try { try decoder.decodeSingularInt32Field(value: &_storage._messageOptions) }() - case 522: try { try decoder.decodeSingularInt32Field(value: &_storage._messageSet) }() - case 523: try { try decoder.decodeSingularInt32Field(value: &_storage._messageSetWireFormat) }() - case 524: try { try decoder.decodeSingularInt32Field(value: &_storage._messageType) }() - case 525: try { try decoder.decodeSingularInt32Field(value: &_storage._method) }() - case 526: try { try decoder.decodeSingularInt32Field(value: &_storage._methodDescriptorProto) }() - case 527: try { try decoder.decodeSingularInt32Field(value: &_storage._methodOptions) }() - case 528: try { try decoder.decodeSingularInt32Field(value: &_storage._methods) }() - case 529: try { try decoder.decodeSingularInt32Field(value: &_storage._minor) }() - case 530: try { try decoder.decodeSingularInt32Field(value: &_storage._mixin) }() - case 531: try { try decoder.decodeSingularInt32Field(value: &_storage._mixins) }() - case 532: try { try decoder.decodeSingularInt32Field(value: &_storage._modifier) }() - case 533: try { try decoder.decodeSingularInt32Field(value: &_storage._modify) }() - case 534: try { try decoder.decodeSingularInt32Field(value: &_storage._month) }() - case 535: try { try decoder.decodeSingularInt32Field(value: &_storage._msgExtension) }() - case 536: try { try decoder.decodeSingularInt32Field(value: &_storage._mutating) }() - case 537: try { try decoder.decodeSingularInt32Field(value: &_storage._n) }() - case 538: try { try decoder.decodeSingularInt32Field(value: &_storage._name) }() - case 539: try { try decoder.decodeSingularInt32Field(value: &_storage._nameDescription) }() - case 540: try { try decoder.decodeSingularInt32Field(value: &_storage._nameMap) }() - case 541: try { try decoder.decodeSingularInt32Field(value: &_storage._namePart) }() - case 542: try { try decoder.decodeSingularInt32Field(value: &_storage._nameResolver) }() - case 543: try { try decoder.decodeSingularInt32Field(value: &_storage._names) }() - case 544: try { try decoder.decodeSingularInt32Field(value: &_storage._nanos) }() - case 545: try { try decoder.decodeSingularInt32Field(value: &_storage._nativeBytes) }() - case 546: try { try decoder.decodeSingularInt32Field(value: &_storage._nativeEndianBytes) }() - case 547: try { try decoder.decodeSingularInt32Field(value: &_storage._negativeIntValue) }() - case 548: try { try decoder.decodeSingularInt32Field(value: &_storage._nestedType) }() - case 549: try { try decoder.decodeSingularInt32Field(value: &_storage._newL) }() - case 550: try { try decoder.decodeSingularInt32Field(value: &_storage._newList) }() - case 551: try { try decoder.decodeSingularInt32Field(value: &_storage._newValue) }() - case 552: try { try decoder.decodeSingularInt32Field(value: &_storage._nextByte) }() - case 553: try { try decoder.decodeSingularInt32Field(value: &_storage._nextFieldNumber) }() - case 554: try { try decoder.decodeSingularInt32Field(value: &_storage._nil) }() - case 555: try { try decoder.decodeSingularInt32Field(value: &_storage._nilLiteral) }() - case 556: try { try decoder.decodeSingularInt32Field(value: &_storage._noStandardDescriptorAccessor) }() - case 557: try { try decoder.decodeSingularInt32Field(value: &_storage._nullValue) }() - case 558: try { try decoder.decodeSingularInt32Field(value: &_storage._number) }() - case 559: try { try decoder.decodeSingularInt32Field(value: &_storage._numberValue) }() - case 560: try { try decoder.decodeSingularInt32Field(value: &_storage._objcClassPrefix) }() - case 561: try { try decoder.decodeSingularInt32Field(value: &_storage._of) }() - case 562: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofDecl) }() - case 563: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofDescriptorProto) }() - case 564: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofIndex) }() - case 565: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofOptions) }() - case 566: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofs) }() - case 567: try { try decoder.decodeSingularInt32Field(value: &_storage._oneOfKind) }() - case 568: try { try decoder.decodeSingularInt32Field(value: &_storage._optimizeFor) }() - case 569: try { try decoder.decodeSingularInt32Field(value: &_storage._optimizeMode) }() - case 570: try { try decoder.decodeSingularInt32Field(value: &_storage._option) }() - case 571: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalEnumExtensionField) }() - case 572: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalExtensionField) }() - case 573: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalGroupExtensionField) }() - case 574: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalMessageExtensionField) }() - case 575: try { try decoder.decodeSingularInt32Field(value: &_storage._options) }() - case 576: try { try decoder.decodeSingularInt32Field(value: &_storage._other) }() - case 577: try { try decoder.decodeSingularInt32Field(value: &_storage._others) }() - case 578: try { try decoder.decodeSingularInt32Field(value: &_storage._out) }() - case 579: try { try decoder.decodeSingularInt32Field(value: &_storage._outputType) }() - case 580: try { try decoder.decodeSingularInt32Field(value: &_storage._p) }() - case 581: try { try decoder.decodeSingularInt32Field(value: &_storage._package) }() - case 582: try { try decoder.decodeSingularInt32Field(value: &_storage._packed) }() - case 583: try { try decoder.decodeSingularInt32Field(value: &_storage._packedEnumExtensionField) }() - case 584: try { try decoder.decodeSingularInt32Field(value: &_storage._packedExtensionField) }() - case 585: try { try decoder.decodeSingularInt32Field(value: &_storage._padding) }() - case 586: try { try decoder.decodeSingularInt32Field(value: &_storage._parent) }() - case 587: try { try decoder.decodeSingularInt32Field(value: &_storage._parse) }() - case 588: try { try decoder.decodeSingularInt32Field(value: &_storage._partial) }() - case 589: try { try decoder.decodeSingularInt32Field(value: &_storage._path) }() - case 590: try { try decoder.decodeSingularInt32Field(value: &_storage._paths) }() - case 591: try { try decoder.decodeSingularInt32Field(value: &_storage._payload) }() - case 592: try { try decoder.decodeSingularInt32Field(value: &_storage._payloadSize) }() - case 593: try { try decoder.decodeSingularInt32Field(value: &_storage._phpClassPrefix) }() - case 594: try { try decoder.decodeSingularInt32Field(value: &_storage._phpGenericServices) }() - case 595: try { try decoder.decodeSingularInt32Field(value: &_storage._phpMetadataNamespace) }() - case 596: try { try decoder.decodeSingularInt32Field(value: &_storage._phpNamespace) }() - case 597: try { try decoder.decodeSingularInt32Field(value: &_storage._pointer) }() - case 598: try { try decoder.decodeSingularInt32Field(value: &_storage._pos) }() - case 599: try { try decoder.decodeSingularInt32Field(value: &_storage._positiveIntValue) }() - case 600: try { try decoder.decodeSingularInt32Field(value: &_storage._prefix) }() - case 601: try { try decoder.decodeSingularInt32Field(value: &_storage._preserveProtoFieldNames) }() - case 602: try { try decoder.decodeSingularInt32Field(value: &_storage._preTraverse) }() - case 603: try { try decoder.decodeSingularInt32Field(value: &_storage._printUnknownFields) }() - case 604: try { try decoder.decodeSingularInt32Field(value: &_storage._proto2) }() - case 605: try { try decoder.decodeSingularInt32Field(value: &_storage._proto3DefaultValue) }() - case 606: try { try decoder.decodeSingularInt32Field(value: &_storage._proto3Optional) }() - case 607: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufApiversionCheck) }() - case 608: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufApiversion2) }() - case 609: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufBool) }() - case 610: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufBytes) }() - case 611: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufDouble) }() - case 612: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufEnumMap) }() - case 613: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufExtension) }() - case 614: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFixed32) }() - case 615: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFixed64) }() - case 616: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFloat) }() - case 617: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufInt32) }() - case 618: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufInt64) }() - case 619: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufMap) }() - case 620: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufMessageMap) }() - case 621: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSfixed32) }() - case 622: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSfixed64) }() - case 623: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSint32) }() - case 624: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSint64) }() - case 625: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufString) }() - case 626: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufUint32) }() - case 627: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufUint64) }() - case 628: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufExtensionFieldValues) }() - case 629: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFieldNumber) }() - case 630: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufGeneratedIsEqualTo) }() - case 631: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufNameMap) }() - case 632: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufNewField) }() - case 633: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufPackage) }() - case 634: try { try decoder.decodeSingularInt32Field(value: &_storage._protocol) }() - case 635: try { try decoder.decodeSingularInt32Field(value: &_storage._protoFieldName) }() - case 636: try { try decoder.decodeSingularInt32Field(value: &_storage._protoMessageName) }() - case 637: try { try decoder.decodeSingularInt32Field(value: &_storage._protoNameProviding) }() - case 638: try { try decoder.decodeSingularInt32Field(value: &_storage._protoPaths) }() - case 639: try { try decoder.decodeSingularInt32Field(value: &_storage._public) }() - case 640: try { try decoder.decodeSingularInt32Field(value: &_storage._publicDependency) }() - case 641: try { try decoder.decodeSingularInt32Field(value: &_storage._putBoolValue) }() - case 642: try { try decoder.decodeSingularInt32Field(value: &_storage._putBytesValue) }() - case 643: try { try decoder.decodeSingularInt32Field(value: &_storage._putDoubleValue) }() - case 644: try { try decoder.decodeSingularInt32Field(value: &_storage._putEnumValue) }() - case 645: try { try decoder.decodeSingularInt32Field(value: &_storage._putFixedUint32) }() - case 646: try { try decoder.decodeSingularInt32Field(value: &_storage._putFixedUint64) }() - case 647: try { try decoder.decodeSingularInt32Field(value: &_storage._putFloatValue) }() - case 648: try { try decoder.decodeSingularInt32Field(value: &_storage._putInt64) }() - case 649: try { try decoder.decodeSingularInt32Field(value: &_storage._putStringValue) }() - case 650: try { try decoder.decodeSingularInt32Field(value: &_storage._putUint64) }() - case 651: try { try decoder.decodeSingularInt32Field(value: &_storage._putUint64Hex) }() - case 652: try { try decoder.decodeSingularInt32Field(value: &_storage._putVarInt) }() - case 653: try { try decoder.decodeSingularInt32Field(value: &_storage._putZigZagVarInt) }() - case 654: try { try decoder.decodeSingularInt32Field(value: &_storage._pyGenericServices) }() - case 655: try { try decoder.decodeSingularInt32Field(value: &_storage._rawChars) }() - case 656: try { try decoder.decodeSingularInt32Field(value: &_storage._rawRepresentable) }() - case 657: try { try decoder.decodeSingularInt32Field(value: &_storage._rawValue) }() - case 658: try { try decoder.decodeSingularInt32Field(value: &_storage._read4HexDigits) }() - case 659: try { try decoder.decodeSingularInt32Field(value: &_storage._register) }() - case 660: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedEnumExtensionField) }() - case 661: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedExtensionField) }() - case 662: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedGroupExtensionField) }() - case 663: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedMessageExtensionField) }() - case 664: try { try decoder.decodeSingularInt32Field(value: &_storage._requestStreaming) }() - case 665: try { try decoder.decodeSingularInt32Field(value: &_storage._requestTypeURL) }() - case 666: try { try decoder.decodeSingularInt32Field(value: &_storage._requiredSize) }() - case 667: try { try decoder.decodeSingularInt32Field(value: &_storage._reservedName) }() - case 668: try { try decoder.decodeSingularInt32Field(value: &_storage._reservedRange) }() - case 669: try { try decoder.decodeSingularInt32Field(value: &_storage._responseStreaming) }() - case 670: try { try decoder.decodeSingularInt32Field(value: &_storage._responseTypeURL) }() - case 671: try { try decoder.decodeSingularInt32Field(value: &_storage._result) }() - case 672: try { try decoder.decodeSingularInt32Field(value: &_storage._rethrows) }() - case 673: try { try decoder.decodeSingularInt32Field(value: &_storage._return) }() - case 674: try { try decoder.decodeSingularInt32Field(value: &_storage._returnType) }() - case 675: try { try decoder.decodeSingularInt32Field(value: &_storage._revision) }() - case 676: try { try decoder.decodeSingularInt32Field(value: &_storage._rhs) }() - case 677: try { try decoder.decodeSingularInt32Field(value: &_storage._root) }() - case 678: try { try decoder.decodeSingularInt32Field(value: &_storage._rubyPackage) }() - case 679: try { try decoder.decodeSingularInt32Field(value: &_storage._s) }() - case 680: try { try decoder.decodeSingularInt32Field(value: &_storage._sawBackslash) }() - case 681: try { try decoder.decodeSingularInt32Field(value: &_storage._sawSection4Characters) }() - case 682: try { try decoder.decodeSingularInt32Field(value: &_storage._sawSection5Characters) }() - case 683: try { try decoder.decodeSingularInt32Field(value: &_storage._scanner) }() - case 684: try { try decoder.decodeSingularInt32Field(value: &_storage._seconds) }() - case 685: try { try decoder.decodeSingularInt32Field(value: &_storage._self_p) }() - case 686: try { try decoder.decodeSingularInt32Field(value: &_storage._separator) }() - case 687: try { try decoder.decodeSingularInt32Field(value: &_storage._serialize) }() - case 688: try { try decoder.decodeSingularInt32Field(value: &_storage._serializedData) }() - case 689: try { try decoder.decodeSingularInt32Field(value: &_storage._serializedSize) }() - case 690: try { try decoder.decodeSingularInt32Field(value: &_storage._serverStreaming) }() - case 691: try { try decoder.decodeSingularInt32Field(value: &_storage._service) }() - case 692: try { try decoder.decodeSingularInt32Field(value: &_storage._serviceDescriptorProto) }() - case 693: try { try decoder.decodeSingularInt32Field(value: &_storage._serviceOptions) }() - case 694: try { try decoder.decodeSingularInt32Field(value: &_storage._set) }() - case 695: try { try decoder.decodeSingularInt32Field(value: &_storage._setExtensionValue) }() - case 696: try { try decoder.decodeSingularInt32Field(value: &_storage._shift) }() - case 697: try { try decoder.decodeSingularInt32Field(value: &_storage._simpleExtensionMap) }() - case 698: try { try decoder.decodeSingularInt32Field(value: &_storage._sizer) }() - case 699: try { try decoder.decodeSingularInt32Field(value: &_storage._source) }() - case 700: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceCodeInfo) }() - case 701: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceContext) }() - case 702: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceEncoding) }() - case 703: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceFile) }() - case 704: try { try decoder.decodeSingularInt32Field(value: &_storage._span) }() - case 705: try { try decoder.decodeSingularInt32Field(value: &_storage._split) }() - case 706: try { try decoder.decodeSingularInt32Field(value: &_storage._start) }() - case 707: try { try decoder.decodeSingularInt32Field(value: &_storage._startArray) }() - case 708: try { try decoder.decodeSingularInt32Field(value: &_storage._startArrayObject) }() - case 709: try { try decoder.decodeSingularInt32Field(value: &_storage._startField) }() - case 710: try { try decoder.decodeSingularInt32Field(value: &_storage._startIndex) }() - case 711: try { try decoder.decodeSingularInt32Field(value: &_storage._startMessageField) }() - case 712: try { try decoder.decodeSingularInt32Field(value: &_storage._startObject) }() - case 713: try { try decoder.decodeSingularInt32Field(value: &_storage._startRegularField) }() - case 714: try { try decoder.decodeSingularInt32Field(value: &_storage._state) }() - case 715: try { try decoder.decodeSingularInt32Field(value: &_storage._static) }() - case 716: try { try decoder.decodeSingularInt32Field(value: &_storage._staticString) }() - case 717: try { try decoder.decodeSingularInt32Field(value: &_storage._storage) }() - case 718: try { try decoder.decodeSingularInt32Field(value: &_storage._string) }() - case 719: try { try decoder.decodeSingularInt32Field(value: &_storage._stringLiteral) }() - case 720: try { try decoder.decodeSingularInt32Field(value: &_storage._stringLiteralType) }() - case 721: try { try decoder.decodeSingularInt32Field(value: &_storage._stringResult) }() - case 722: try { try decoder.decodeSingularInt32Field(value: &_storage._stringValue) }() - case 723: try { try decoder.decodeSingularInt32Field(value: &_storage._struct) }() - case 724: try { try decoder.decodeSingularInt32Field(value: &_storage._structValue) }() - case 725: try { try decoder.decodeSingularInt32Field(value: &_storage._subDecoder) }() - case 726: try { try decoder.decodeSingularInt32Field(value: &_storage._subscript) }() - case 727: try { try decoder.decodeSingularInt32Field(value: &_storage._subVisitor) }() - case 728: try { try decoder.decodeSingularInt32Field(value: &_storage._swift) }() - case 729: try { try decoder.decodeSingularInt32Field(value: &_storage._swiftPrefix) }() - case 730: try { try decoder.decodeSingularInt32Field(value: &_storage._swiftProtobuf) }() - case 731: try { try decoder.decodeSingularInt32Field(value: &_storage._syntax) }() - case 732: try { try decoder.decodeSingularInt32Field(value: &_storage._t) }() - case 733: try { try decoder.decodeSingularInt32Field(value: &_storage._tag) }() - case 734: try { try decoder.decodeSingularInt32Field(value: &_storage._terminator) }() - case 735: try { try decoder.decodeSingularInt32Field(value: &_storage._testDecoder) }() - case 736: try { try decoder.decodeSingularInt32Field(value: &_storage._text) }() - case 737: try { try decoder.decodeSingularInt32Field(value: &_storage._textDecoder) }() - case 738: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatDecoder) }() - case 739: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatDecodingError) }() - case 740: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatDecodingOptions) }() - case 741: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatEncodingOptions) }() - case 742: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatEncodingVisitor) }() - case 743: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatString) }() - case 744: try { try decoder.decodeSingularInt32Field(value: &_storage._throws) }() - case 745: try { try decoder.decodeSingularInt32Field(value: &_storage._timeInterval) }() - case 746: try { try decoder.decodeSingularInt32Field(value: &_storage._timeIntervalSince1970) }() - case 747: try { try decoder.decodeSingularInt32Field(value: &_storage._timeIntervalSinceReferenceDate) }() - case 748: try { try decoder.decodeSingularInt32Field(value: &_storage._timestamp) }() - case 749: try { try decoder.decodeSingularInt32Field(value: &_storage._total) }() - case 750: try { try decoder.decodeSingularInt32Field(value: &_storage._totalArrayDepth) }() - case 751: try { try decoder.decodeSingularInt32Field(value: &_storage._totalSize) }() - case 752: try { try decoder.decodeSingularInt32Field(value: &_storage._trailingComments) }() - case 753: try { try decoder.decodeSingularInt32Field(value: &_storage._traverse) }() - case 754: try { try decoder.decodeSingularInt32Field(value: &_storage._true) }() - case 755: try { try decoder.decodeSingularInt32Field(value: &_storage._try) }() - case 756: try { try decoder.decodeSingularInt32Field(value: &_storage._type) }() - case 757: try { try decoder.decodeSingularInt32Field(value: &_storage._typealias) }() - case 758: try { try decoder.decodeSingularInt32Field(value: &_storage._typeEnum) }() - case 759: try { try decoder.decodeSingularInt32Field(value: &_storage._typeName) }() - case 760: try { try decoder.decodeSingularInt32Field(value: &_storage._typePrefix) }() - case 761: try { try decoder.decodeSingularInt32Field(value: &_storage._typeStart) }() - case 762: try { try decoder.decodeSingularInt32Field(value: &_storage._typeUnknown) }() - case 763: try { try decoder.decodeSingularInt32Field(value: &_storage._typeURL) }() - case 764: try { try decoder.decodeSingularInt32Field(value: &_storage._uint32) }() - case 765: try { try decoder.decodeSingularInt32Field(value: &_storage._uint32Value) }() - case 766: try { try decoder.decodeSingularInt32Field(value: &_storage._uint64) }() - case 767: try { try decoder.decodeSingularInt32Field(value: &_storage._uint64Value) }() - case 768: try { try decoder.decodeSingularInt32Field(value: &_storage._uint8) }() - case 769: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalarLiteral) }() - case 770: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalarLiteralType) }() - case 771: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalars) }() - case 772: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalarView) }() - case 773: try { try decoder.decodeSingularInt32Field(value: &_storage._uninterpretedOption) }() - case 774: try { try decoder.decodeSingularInt32Field(value: &_storage._union) }() - case 775: try { try decoder.decodeSingularInt32Field(value: &_storage._uniqueStorage) }() - case 776: try { try decoder.decodeSingularInt32Field(value: &_storage._unknown) }() - case 777: try { try decoder.decodeSingularInt32Field(value: &_storage._unknownFields_p) }() - case 778: try { try decoder.decodeSingularInt32Field(value: &_storage._unknownStorage) }() - case 779: try { try decoder.decodeSingularInt32Field(value: &_storage._unpackTo) }() - case 780: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeBufferPointer) }() - case 781: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeMutablePointer) }() - case 782: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeMutableRawBufferPointer) }() - case 783: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeMutableRawPointer) }() - case 784: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeRawBufferPointer) }() - case 785: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeRawPointer) }() - case 786: try { try decoder.decodeSingularInt32Field(value: &_storage._updatedOptions) }() - case 787: try { try decoder.decodeSingularInt32Field(value: &_storage._url) }() - case 788: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8) }() - case 789: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8Ptr) }() - case 790: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8ToDouble) }() - case 791: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8View) }() - case 792: try { try decoder.decodeSingularInt32Field(value: &_storage._v) }() - case 793: try { try decoder.decodeSingularInt32Field(value: &_storage._value) }() - case 794: try { try decoder.decodeSingularInt32Field(value: &_storage._valueField) }() - case 795: try { try decoder.decodeSingularInt32Field(value: &_storage._values) }() - case 796: try { try decoder.decodeSingularInt32Field(value: &_storage._valueType) }() - case 797: try { try decoder.decodeSingularInt32Field(value: &_storage._var) }() - case 798: try { try decoder.decodeSingularInt32Field(value: &_storage._version) }() - case 799: try { try decoder.decodeSingularInt32Field(value: &_storage._versionString) }() - case 800: try { try decoder.decodeSingularInt32Field(value: &_storage._visitExtensionFields) }() - case 801: try { try decoder.decodeSingularInt32Field(value: &_storage._visitExtensionFieldsAsMessageSet) }() - case 802: try { try decoder.decodeSingularInt32Field(value: &_storage._visitMapField) }() - case 803: try { try decoder.decodeSingularInt32Field(value: &_storage._visitor) }() - case 804: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPacked) }() - case 805: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedBoolField) }() - case 806: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedDoubleField) }() - case 807: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedEnumField) }() - case 808: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedFixed32Field) }() - case 809: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedFixed64Field) }() - case 810: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedFloatField) }() - case 811: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedInt32Field) }() - case 812: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedInt64Field) }() - case 813: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSfixed32Field) }() - case 814: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSfixed64Field) }() - case 815: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSint32Field) }() - case 816: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSint64Field) }() - case 817: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedUint32Field) }() - case 818: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedUint64Field) }() - case 819: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeated) }() - case 820: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedBoolField) }() - case 821: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedBytesField) }() - case 822: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedDoubleField) }() - case 823: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedEnumField) }() - case 824: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedFixed32Field) }() - case 825: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedFixed64Field) }() - case 826: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedFloatField) }() - case 827: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedGroupField) }() - case 828: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedInt32Field) }() - case 829: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedInt64Field) }() - case 830: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedMessageField) }() - case 831: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSfixed32Field) }() - case 832: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSfixed64Field) }() - case 833: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSint32Field) }() - case 834: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSint64Field) }() - case 835: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedStringField) }() - case 836: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedUint32Field) }() - case 837: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedUint64Field) }() - case 838: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingular) }() - case 839: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularBoolField) }() - case 840: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularBytesField) }() - case 841: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularDoubleField) }() - case 842: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularEnumField) }() - case 843: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularFixed32Field) }() - case 844: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularFixed64Field) }() - case 845: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularFloatField) }() - case 846: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularGroupField) }() - case 847: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularInt32Field) }() - case 848: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularInt64Field) }() - case 849: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularMessageField) }() - case 850: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSfixed32Field) }() - case 851: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSfixed64Field) }() - case 852: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSint32Field) }() - case 853: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSint64Field) }() - case 854: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularStringField) }() - case 855: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularUint32Field) }() - case 856: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularUint64Field) }() - case 857: try { try decoder.decodeSingularInt32Field(value: &_storage._visitUnknown) }() - case 858: try { try decoder.decodeSingularInt32Field(value: &_storage._wasDecoded) }() - case 859: try { try decoder.decodeSingularInt32Field(value: &_storage._weak) }() - case 860: try { try decoder.decodeSingularInt32Field(value: &_storage._weakDependency) }() - case 861: try { try decoder.decodeSingularInt32Field(value: &_storage._where) }() - case 862: try { try decoder.decodeSingularInt32Field(value: &_storage._wireFormat) }() - case 863: try { try decoder.decodeSingularInt32Field(value: &_storage._with) }() - case 864: try { try decoder.decodeSingularInt32Field(value: &_storage._withUnsafeBytes) }() - case 865: try { try decoder.decodeSingularInt32Field(value: &_storage._withUnsafeMutableBytes) }() - case 866: try { try decoder.decodeSingularInt32Field(value: &_storage._work) }() - case 867: try { try decoder.decodeSingularInt32Field(value: &_storage._wrappedType) }() - case 868: try { try decoder.decodeSingularInt32Field(value: &_storage._written) }() - case 869: try { try decoder.decodeSingularInt32Field(value: &_storage._yday) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &_storage._addPath) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._adjusted) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &_storage._aggregateValue) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &_storage._allCases) }() + case 5: try { try decoder.decodeSingularInt32Field(value: &_storage._allowAlias) }() + case 6: try { try decoder.decodeSingularInt32Field(value: &_storage._alwaysPrintEnumsAsInts) }() + case 7: try { try decoder.decodeSingularInt32Field(value: &_storage._alwaysPrintInt64SAsNumbers) }() + case 8: try { try decoder.decodeSingularInt32Field(value: &_storage._annotation) }() + case 9: try { try decoder.decodeSingularInt32Field(value: &_storage._any) }() + case 10: try { try decoder.decodeSingularInt32Field(value: &_storage._anyExtensionField) }() + case 11: try { try decoder.decodeSingularInt32Field(value: &_storage._anyMessageExtension) }() + case 12: try { try decoder.decodeSingularInt32Field(value: &_storage._anyMessageStorage) }() + case 13: try { try decoder.decodeSingularInt32Field(value: &_storage._anyUnpackError) }() + case 14: try { try decoder.decodeSingularInt32Field(value: &_storage._append) }() + case 15: try { try decoder.decodeSingularInt32Field(value: &_storage._appended) }() + case 16: try { try decoder.decodeSingularInt32Field(value: &_storage._appendUintHex) }() + case 17: try { try decoder.decodeSingularInt32Field(value: &_storage._appendUnknown) }() + case 18: try { try decoder.decodeSingularInt32Field(value: &_storage._areAllInitialized) }() + case 19: try { try decoder.decodeSingularInt32Field(value: &_storage._array) }() + case 20: try { try decoder.decodeSingularInt32Field(value: &_storage._arrayDepth) }() + case 21: try { try decoder.decodeSingularInt32Field(value: &_storage._arrayLiteral) }() + case 22: try { try decoder.decodeSingularInt32Field(value: &_storage._arraySeparator) }() + case 23: try { try decoder.decodeSingularInt32Field(value: &_storage._as) }() + case 24: try { try decoder.decodeSingularInt32Field(value: &_storage._asciiOpenCurlyBracket) }() + case 25: try { try decoder.decodeSingularInt32Field(value: &_storage._asciiZero) }() + case 26: try { try decoder.decodeSingularInt32Field(value: &_storage._async) }() + case 27: try { try decoder.decodeSingularInt32Field(value: &_storage._asyncIterator) }() + case 28: try { try decoder.decodeSingularInt32Field(value: &_storage._asyncIteratorProtocol) }() + case 29: try { try decoder.decodeSingularInt32Field(value: &_storage._asyncMessageSequence) }() + case 30: try { try decoder.decodeSingularInt32Field(value: &_storage._available) }() + case 31: try { try decoder.decodeSingularInt32Field(value: &_storage._b) }() + case 32: try { try decoder.decodeSingularInt32Field(value: &_storage._base) }() + case 33: try { try decoder.decodeSingularInt32Field(value: &_storage._base64Values) }() + case 34: try { try decoder.decodeSingularInt32Field(value: &_storage._baseAddress) }() + case 35: try { try decoder.decodeSingularInt32Field(value: &_storage._baseType) }() + case 36: try { try decoder.decodeSingularInt32Field(value: &_storage._begin) }() + case 37: try { try decoder.decodeSingularInt32Field(value: &_storage._binary) }() + case 38: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryDecoder) }() + case 39: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryDecoding) }() + case 40: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryDecodingError) }() + case 41: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryDecodingOptions) }() + case 42: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryDelimited) }() + case 43: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncoder) }() + case 44: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingError) }() + case 45: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingMessageSetSizeVisitor) }() + case 46: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingMessageSetVisitor) }() + case 47: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingOptions) }() + case 48: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingSizeVisitor) }() + case 49: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingVisitor) }() + case 50: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryOptions) }() + case 51: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryProtobufDelimitedMessages) }() + case 52: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryStreamDecoding) }() + case 53: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryStreamDecodingError) }() + case 54: try { try decoder.decodeSingularInt32Field(value: &_storage._bitPattern) }() + case 55: try { try decoder.decodeSingularInt32Field(value: &_storage._body) }() + case 56: try { try decoder.decodeSingularInt32Field(value: &_storage._bool) }() + case 57: try { try decoder.decodeSingularInt32Field(value: &_storage._booleanLiteral) }() + case 58: try { try decoder.decodeSingularInt32Field(value: &_storage._booleanLiteralType) }() + case 59: try { try decoder.decodeSingularInt32Field(value: &_storage._boolValue) }() + case 60: try { try decoder.decodeSingularInt32Field(value: &_storage._buffer) }() + case 61: try { try decoder.decodeSingularInt32Field(value: &_storage._byte) }() + case 62: try { try decoder.decodeSingularInt32Field(value: &_storage._bytecode) }() + case 63: try { try decoder.decodeSingularInt32Field(value: &_storage._bytecodeReader) }() + case 64: try { try decoder.decodeSingularInt32Field(value: &_storage._bytes) }() + case 65: try { try decoder.decodeSingularInt32Field(value: &_storage._bytesInGroup) }() + case 66: try { try decoder.decodeSingularInt32Field(value: &_storage._bytesNeeded) }() + case 67: try { try decoder.decodeSingularInt32Field(value: &_storage._bytesRead) }() + case 68: try { try decoder.decodeSingularInt32Field(value: &_storage._c) }() + case 69: try { try decoder.decodeSingularInt32Field(value: &_storage._canonical) }() + case 70: try { try decoder.decodeSingularInt32Field(value: &_storage._capitalizeNext) }() + case 71: try { try decoder.decodeSingularInt32Field(value: &_storage._cardinality) }() + case 72: try { try decoder.decodeSingularInt32Field(value: &_storage._caseIterable) }() + case 73: try { try decoder.decodeSingularInt32Field(value: &_storage._castedValue) }() + case 74: try { try decoder.decodeSingularInt32Field(value: &_storage._ccEnableArenas) }() + case 75: try { try decoder.decodeSingularInt32Field(value: &_storage._ccGenericServices) }() + case 76: try { try decoder.decodeSingularInt32Field(value: &_storage._character) }() + case 77: try { try decoder.decodeSingularInt32Field(value: &_storage._chars) }() + case 78: try { try decoder.decodeSingularInt32Field(value: &_storage._checkProgramFormat) }() + case 79: try { try decoder.decodeSingularInt32Field(value: &_storage._chunk) }() + case 80: try { try decoder.decodeSingularInt32Field(value: &_storage._class) }() + case 81: try { try decoder.decodeSingularInt32Field(value: &_storage._clearAggregateValue_p) }() + case 82: try { try decoder.decodeSingularInt32Field(value: &_storage._clearAllowAlias_p) }() + case 83: try { try decoder.decodeSingularInt32Field(value: &_storage._clearBegin_p) }() + case 84: try { try decoder.decodeSingularInt32Field(value: &_storage._clearCcEnableArenas_p) }() + case 85: try { try decoder.decodeSingularInt32Field(value: &_storage._clearCcGenericServices_p) }() + case 86: try { try decoder.decodeSingularInt32Field(value: &_storage._clearClientStreaming_p) }() + case 87: try { try decoder.decodeSingularInt32Field(value: &_storage._clearCsharpNamespace_p) }() + case 88: try { try decoder.decodeSingularInt32Field(value: &_storage._clearCtype_p) }() + case 89: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDebugRedact_p) }() + case 90: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDefaultSymbolVisibility_p) }() + case 91: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDefaultValue_p) }() + case 92: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDeprecated_p) }() + case 93: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDeprecatedLegacyJsonFieldConflicts_p) }() + case 94: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDeprecationWarning_p) }() + case 95: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDoubleValue_p) }() + case 96: try { try decoder.decodeSingularInt32Field(value: &_storage._clearEdition_p) }() + case 97: try { try decoder.decodeSingularInt32Field(value: &_storage._clearEditionDeprecated_p) }() + case 98: try { try decoder.decodeSingularInt32Field(value: &_storage._clearEditionIntroduced_p) }() + case 99: try { try decoder.decodeSingularInt32Field(value: &_storage._clearEditionRemoved_p) }() + case 100: try { try decoder.decodeSingularInt32Field(value: &_storage._clearEnd_p) }() + case 101: try { try decoder.decodeSingularInt32Field(value: &_storage._clearEnforceNamingStyle_p) }() + case 102: try { try decoder.decodeSingularInt32Field(value: &_storage._clearEnumType_p) }() + case 103: try { try decoder.decodeSingularInt32Field(value: &_storage._clearExtendee_p) }() + case 104: try { try decoder.decodeSingularInt32Field(value: &_storage._clearExtensionValue_p) }() + case 105: try { try decoder.decodeSingularInt32Field(value: &_storage._clearFeatures_p) }() + case 106: try { try decoder.decodeSingularInt32Field(value: &_storage._clearFeatureSupport_p) }() + case 107: try { try decoder.decodeSingularInt32Field(value: &_storage._clearFieldPresence_p) }() + case 108: try { try decoder.decodeSingularInt32Field(value: &_storage._clearFixedFeatures_p) }() + case 109: try { try decoder.decodeSingularInt32Field(value: &_storage._clearFullName_p) }() + case 110: try { try decoder.decodeSingularInt32Field(value: &_storage._clearGoPackage_p) }() + case 111: try { try decoder.decodeSingularInt32Field(value: &_storage._clearIdempotencyLevel_p) }() + case 112: try { try decoder.decodeSingularInt32Field(value: &_storage._clearIdentifierValue_p) }() + case 113: try { try decoder.decodeSingularInt32Field(value: &_storage._clearInputType_p) }() + case 114: try { try decoder.decodeSingularInt32Field(value: &_storage._clearIsExtension_p) }() + case 115: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaGenerateEqualsAndHash_p) }() + case 116: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaGenericServices_p) }() + case 117: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaMultipleFiles_p) }() + case 118: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaOuterClassname_p) }() + case 119: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaPackage_p) }() + case 120: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaStringCheckUtf8_p) }() + case 121: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJsonFormat_p) }() + case 122: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJsonName_p) }() + case 123: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJstype_p) }() + case 124: try { try decoder.decodeSingularInt32Field(value: &_storage._clearLabel_p) }() + case 125: try { try decoder.decodeSingularInt32Field(value: &_storage._clearLazy_p) }() + case 126: try { try decoder.decodeSingularInt32Field(value: &_storage._clearLeadingComments_p) }() + case 127: try { try decoder.decodeSingularInt32Field(value: &_storage._clearMapEntry_p) }() + case 128: try { try decoder.decodeSingularInt32Field(value: &_storage._clearMaximumEdition_p) }() + case 129: try { try decoder.decodeSingularInt32Field(value: &_storage._clearMessageEncoding_p) }() + case 130: try { try decoder.decodeSingularInt32Field(value: &_storage._clearMessageSetWireFormat_p) }() + case 131: try { try decoder.decodeSingularInt32Field(value: &_storage._clearMinimumEdition_p) }() + case 132: try { try decoder.decodeSingularInt32Field(value: &_storage._clearName_p) }() + case 133: try { try decoder.decodeSingularInt32Field(value: &_storage._clearNamePart_p) }() + case 134: try { try decoder.decodeSingularInt32Field(value: &_storage._clearNegativeIntValue_p) }() + case 135: try { try decoder.decodeSingularInt32Field(value: &_storage._clearNoStandardDescriptorAccessor_p) }() + case 136: try { try decoder.decodeSingularInt32Field(value: &_storage._clearNumber_p) }() + case 137: try { try decoder.decodeSingularInt32Field(value: &_storage._clearObjcClassPrefix_p) }() + case 138: try { try decoder.decodeSingularInt32Field(value: &_storage._clearOneofIndex_p) }() + case 139: try { try decoder.decodeSingularInt32Field(value: &_storage._clearOptimizeFor_p) }() + case 140: try { try decoder.decodeSingularInt32Field(value: &_storage._clearOptions_p) }() + case 141: try { try decoder.decodeSingularInt32Field(value: &_storage._clearOutputType_p) }() + case 142: try { try decoder.decodeSingularInt32Field(value: &_storage._clearOverridableFeatures_p) }() + case 143: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPackage_p) }() + case 144: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPacked_p) }() + case 145: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPhpClassPrefix_p) }() + case 146: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPhpMetadataNamespace_p) }() + case 147: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPhpNamespace_p) }() + case 148: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPositiveIntValue_p) }() + case 149: try { try decoder.decodeSingularInt32Field(value: &_storage._clearProto3Optional_p) }() + case 150: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPyGenericServices_p) }() + case 151: try { try decoder.decodeSingularInt32Field(value: &_storage._clearRemovalError_p) }() + case 152: try { try decoder.decodeSingularInt32Field(value: &_storage._clearRepeated_p) }() + case 153: try { try decoder.decodeSingularInt32Field(value: &_storage._clearRepeatedFieldEncoding_p) }() + case 154: try { try decoder.decodeSingularInt32Field(value: &_storage._clearReserved_p) }() + case 155: try { try decoder.decodeSingularInt32Field(value: &_storage._clearRetention_p) }() + case 156: try { try decoder.decodeSingularInt32Field(value: &_storage._clearRubyPackage_p) }() + case 157: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSemantic_p) }() + case 158: try { try decoder.decodeSingularInt32Field(value: &_storage._clearServerStreaming_p) }() + case 159: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSourceCodeInfo_p) }() + case 160: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSourceContext_p) }() + case 161: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSourceFile_p) }() + case 162: try { try decoder.decodeSingularInt32Field(value: &_storage._clearStart_p) }() + case 163: try { try decoder.decodeSingularInt32Field(value: &_storage._clearStringValue_p) }() + case 164: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSwiftPrefix_p) }() + case 165: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSyntax_p) }() + case 166: try { try decoder.decodeSingularInt32Field(value: &_storage._clearTrailingComments_p) }() + case 167: try { try decoder.decodeSingularInt32Field(value: &_storage._clearType_p) }() + case 168: try { try decoder.decodeSingularInt32Field(value: &_storage._clearTypeName_p) }() + case 169: try { try decoder.decodeSingularInt32Field(value: &_storage._clearUnverifiedLazy_p) }() + case 170: try { try decoder.decodeSingularInt32Field(value: &_storage._clearUtf8Validation_p) }() + case 171: try { try decoder.decodeSingularInt32Field(value: &_storage._clearValue_p) }() + case 172: try { try decoder.decodeSingularInt32Field(value: &_storage._clearVerification_p) }() + case 173: try { try decoder.decodeSingularInt32Field(value: &_storage._clearVisibility_p) }() + case 174: try { try decoder.decodeSingularInt32Field(value: &_storage._clearWeak_p) }() + case 175: try { try decoder.decodeSingularInt32Field(value: &_storage._clientStreaming) }() + case 176: try { try decoder.decodeSingularInt32Field(value: &_storage._code) }() + case 177: try { try decoder.decodeSingularInt32Field(value: &_storage._codePoint) }() + case 178: try { try decoder.decodeSingularInt32Field(value: &_storage._codeUnits) }() + case 179: try { try decoder.decodeSingularInt32Field(value: &_storage._collection) }() + case 180: try { try decoder.decodeSingularInt32Field(value: &_storage._comma) }() + case 181: try { try decoder.decodeSingularInt32Field(value: &_storage._consumedBytes) }() + case 182: try { try decoder.decodeSingularInt32Field(value: &_storage._contains) }() + case 183: try { try decoder.decodeSingularInt32Field(value: &_storage._contentsOf) }() + case 184: try { try decoder.decodeSingularInt32Field(value: &_storage._contiguousBytes) }() + case 185: try { try decoder.decodeSingularInt32Field(value: &_storage._copy) }() + case 186: try { try decoder.decodeSingularInt32Field(value: &_storage._count) }() + case 187: try { try decoder.decodeSingularInt32Field(value: &_storage._countVarintsInBuffer) }() + case 188: try { try decoder.decodeSingularInt32Field(value: &_storage._csharpNamespace) }() + case 189: try { try decoder.decodeSingularInt32Field(value: &_storage._ctype) }() + case 190: try { try decoder.decodeSingularInt32Field(value: &_storage._customCodable) }() + case 191: try { try decoder.decodeSingularInt32Field(value: &_storage._customDebugStringConvertible) }() + case 192: try { try decoder.decodeSingularInt32Field(value: &_storage._customStringConvertible) }() + case 193: try { try decoder.decodeSingularInt32Field(value: &_storage._d) }() + case 194: try { try decoder.decodeSingularInt32Field(value: &_storage._data) }() + case 195: try { try decoder.decodeSingularInt32Field(value: &_storage._dataResult) }() + case 196: try { try decoder.decodeSingularInt32Field(value: &_storage._date) }() + case 197: try { try decoder.decodeSingularInt32Field(value: &_storage._daySec) }() + case 198: try { try decoder.decodeSingularInt32Field(value: &_storage._daysSinceEpoch) }() + case 199: try { try decoder.decodeSingularInt32Field(value: &_storage._debugDescription_p) }() + case 200: try { try decoder.decodeSingularInt32Field(value: &_storage._debugRedact) }() + case 201: try { try decoder.decodeSingularInt32Field(value: &_storage._declaration) }() + case 202: try { try decoder.decodeSingularInt32Field(value: &_storage._decoded) }() + case 203: try { try decoder.decodeSingularInt32Field(value: &_storage._decodedFromJsonnull) }() + case 204: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeExtensionField) }() + case 205: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeExtensionFieldsAsMessageSet) }() + case 206: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeJson) }() + case 207: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeMapField) }() + case 208: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeMessage) }() + case 209: try { try decoder.decodeSingularInt32Field(value: &_storage._decoder) }() + case 210: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeated) }() + case 211: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedBoolField) }() + case 212: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedBytesField) }() + case 213: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedDoubleField) }() + case 214: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedEnumField) }() + case 215: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedFixed32Field) }() + case 216: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedFixed64Field) }() + case 217: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedFloatField) }() + case 218: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedGroupField) }() + case 219: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedInt32Field) }() + case 220: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedInt64Field) }() + case 221: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedMessageField) }() + case 222: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedSfixed32Field) }() + case 223: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedSfixed64Field) }() + case 224: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedSint32Field) }() + case 225: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedSint64Field) }() + case 226: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedStringField) }() + case 227: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedUint32Field) }() + case 228: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedUint64Field) }() + case 229: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingular) }() + case 230: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularBoolField) }() + case 231: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularBytesField) }() + case 232: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularDoubleField) }() + case 233: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularEnumField) }() + case 234: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularFixed32Field) }() + case 235: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularFixed64Field) }() + case 236: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularFloatField) }() + case 237: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularGroupField) }() + case 238: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularInt32Field) }() + case 239: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularInt64Field) }() + case 240: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularMessageField) }() + case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularSfixed32Field) }() + case 242: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularSfixed64Field) }() + case 243: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularSint32Field) }() + case 244: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularSint64Field) }() + case 245: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularStringField) }() + case 246: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularUint32Field) }() + case 247: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularUint64Field) }() + case 248: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeTextFormat) }() + case 249: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultAnyTypeUrlprefix) }() + case 250: try { try decoder.decodeSingularInt32Field(value: &_storage._defaults) }() + case 251: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultSymbolVisibility) }() + case 252: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultValue) }() + case 253: try { try decoder.decodeSingularInt32Field(value: &_storage._dependency) }() + case 254: try { try decoder.decodeSingularInt32Field(value: &_storage._deprecated) }() + case 255: try { try decoder.decodeSingularInt32Field(value: &_storage._deprecatedLegacyJsonFieldConflicts) }() + case 256: try { try decoder.decodeSingularInt32Field(value: &_storage._deprecationWarning) }() + case 257: try { try decoder.decodeSingularInt32Field(value: &_storage._description_p) }() + case 258: try { try decoder.decodeSingularInt32Field(value: &_storage._dictionary) }() + case 259: try { try decoder.decodeSingularInt32Field(value: &_storage._dictionaryLiteral) }() + case 260: try { try decoder.decodeSingularInt32Field(value: &_storage._digit) }() + case 261: try { try decoder.decodeSingularInt32Field(value: &_storage._digit0) }() + case 262: try { try decoder.decodeSingularInt32Field(value: &_storage._digit1) }() + case 263: try { try decoder.decodeSingularInt32Field(value: &_storage._digitCount) }() + case 264: try { try decoder.decodeSingularInt32Field(value: &_storage._digits) }() + case 265: try { try decoder.decodeSingularInt32Field(value: &_storage._digitValue) }() + case 266: try { try decoder.decodeSingularInt32Field(value: &_storage._discardableResult) }() + case 267: try { try decoder.decodeSingularInt32Field(value: &_storage._discardUnknownFields) }() + case 268: try { try decoder.decodeSingularInt32Field(value: &_storage._double) }() + case 269: try { try decoder.decodeSingularInt32Field(value: &_storage._doubleValue) }() + case 270: try { try decoder.decodeSingularInt32Field(value: &_storage._duration) }() + case 271: try { try decoder.decodeSingularInt32Field(value: &_storage._e) }() + case 272: try { try decoder.decodeSingularInt32Field(value: &_storage._edition) }() + case 273: try { try decoder.decodeSingularInt32Field(value: &_storage._editionDefault) }() + case 274: try { try decoder.decodeSingularInt32Field(value: &_storage._editionDefaults) }() + case 275: try { try decoder.decodeSingularInt32Field(value: &_storage._editionDeprecated) }() + case 276: try { try decoder.decodeSingularInt32Field(value: &_storage._editionIntroduced) }() + case 277: try { try decoder.decodeSingularInt32Field(value: &_storage._editionRemoved) }() + case 278: try { try decoder.decodeSingularInt32Field(value: &_storage._element) }() + case 279: try { try decoder.decodeSingularInt32Field(value: &_storage._elements) }() + case 280: try { try decoder.decodeSingularInt32Field(value: &_storage._else) }() + case 281: try { try decoder.decodeSingularInt32Field(value: &_storage._emitExtensionFieldName) }() + case 282: try { try decoder.decodeSingularInt32Field(value: &_storage._emitFieldName) }() + case 283: try { try decoder.decodeSingularInt32Field(value: &_storage._emitFieldNumber) }() + case 284: try { try decoder.decodeSingularInt32Field(value: &_storage._emptyAnyTypeURL) }() + case 285: try { try decoder.decodeSingularInt32Field(value: &_storage._emptyData) }() + case 286: try { try decoder.decodeSingularInt32Field(value: &_storage._encodeAsBytes) }() + case 287: try { try decoder.decodeSingularInt32Field(value: &_storage._encoded) }() + case 288: try { try decoder.decodeSingularInt32Field(value: &_storage._encodedJsonstring) }() + case 289: try { try decoder.decodeSingularInt32Field(value: &_storage._encodedSize) }() + case 290: try { try decoder.decodeSingularInt32Field(value: &_storage._encodeField) }() + case 291: try { try decoder.decodeSingularInt32Field(value: &_storage._encoder) }() + case 292: try { try decoder.decodeSingularInt32Field(value: &_storage._end) }() + case 293: try { try decoder.decodeSingularInt32Field(value: &_storage._endArray) }() + case 294: try { try decoder.decodeSingularInt32Field(value: &_storage._endMessageField) }() + case 295: try { try decoder.decodeSingularInt32Field(value: &_storage._endObject) }() + case 296: try { try decoder.decodeSingularInt32Field(value: &_storage._endRegularField) }() + case 297: try { try decoder.decodeSingularInt32Field(value: &_storage._enforceNamingStyle) }() + case 298: try { try decoder.decodeSingularInt32Field(value: &_storage._enum) }() + case 299: try { try decoder.decodeSingularInt32Field(value: &_storage._enumReservedRange) }() + case 300: try { try decoder.decodeSingularInt32Field(value: &_storage._enumType) }() + case 301: try { try decoder.decodeSingularInt32Field(value: &_storage._enumvalue) }() + case 302: try { try decoder.decodeSingularInt32Field(value: &_storage._equatable) }() + case 303: try { try decoder.decodeSingularInt32Field(value: &_storage._error) }() + case 304: try { try decoder.decodeSingularInt32Field(value: &_storage._execute) }() + case 305: try { try decoder.decodeSingularInt32Field(value: &_storage._expressibleByArrayLiteral) }() + case 306: try { try decoder.decodeSingularInt32Field(value: &_storage._expressibleByDictionaryLiteral) }() + case 307: try { try decoder.decodeSingularInt32Field(value: &_storage._ext) }() + case 308: try { try decoder.decodeSingularInt32Field(value: &_storage._extDecoder) }() + case 309: try { try decoder.decodeSingularInt32Field(value: &_storage._extendedGraphemeClusterLiteral) }() + case 310: try { try decoder.decodeSingularInt32Field(value: &_storage._extendedGraphemeClusterLiteralType) }() + case 311: try { try decoder.decodeSingularInt32Field(value: &_storage._extendee) }() + case 312: try { try decoder.decodeSingularInt32Field(value: &_storage._extensibleMessage) }() + case 313: try { try decoder.decodeSingularInt32Field(value: &_storage._extension) }() + case 314: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionField) }() + case 315: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionFieldNumber) }() + case 316: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionFieldValueSet) }() + case 317: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionMap) }() + case 318: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionRange) }() + case 319: try { try decoder.decodeSingularInt32Field(value: &_storage._extensions) }() + case 320: try { try decoder.decodeSingularInt32Field(value: &_storage._extras) }() + case 321: try { try decoder.decodeSingularInt32Field(value: &_storage._f) }() + case 322: try { try decoder.decodeSingularInt32Field(value: &_storage._false) }() + case 323: try { try decoder.decodeSingularInt32Field(value: &_storage._features) }() + case 324: try { try decoder.decodeSingularInt32Field(value: &_storage._featureSetEditionDefault) }() + case 325: try { try decoder.decodeSingularInt32Field(value: &_storage._featureSupport) }() + case 326: try { try decoder.decodeSingularInt32Field(value: &_storage._field) }() + case 327: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldData) }() + case 328: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldMaskError) }() + case 329: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName) }() + case 330: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNameCount) }() + case 331: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNum) }() + case 332: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNumber) }() + case 333: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNumberForProto) }() + case 334: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldPresence) }() + case 335: try { try decoder.decodeSingularInt32Field(value: &_storage._fields) }() + case 336: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldSize) }() + case 337: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldTag) }() + case 338: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldType) }() + case 339: try { try decoder.decodeSingularInt32Field(value: &_storage._file) }() + case 340: try { try decoder.decodeSingularInt32Field(value: &_storage._fileName) }() + case 341: try { try decoder.decodeSingularInt32Field(value: &_storage._filter) }() + case 342: try { try decoder.decodeSingularInt32Field(value: &_storage._final) }() + case 343: try { try decoder.decodeSingularInt32Field(value: &_storage._finiteOnly) }() + case 344: try { try decoder.decodeSingularInt32Field(value: &_storage._first) }() + case 345: try { try decoder.decodeSingularInt32Field(value: &_storage._firstItem) }() + case 346: try { try decoder.decodeSingularInt32Field(value: &_storage._fixedFeatures) }() + case 347: try { try decoder.decodeSingularInt32Field(value: &_storage._float) }() + case 348: try { try decoder.decodeSingularInt32Field(value: &_storage._floatLiteral) }() + case 349: try { try decoder.decodeSingularInt32Field(value: &_storage._floatLiteralType) }() + case 350: try { try decoder.decodeSingularInt32Field(value: &_storage._for) }() + case 351: try { try decoder.decodeSingularInt32Field(value: &_storage._forMessageName) }() + case 352: try { try decoder.decodeSingularInt32Field(value: &_storage._formUnion) }() + case 353: try { try decoder.decodeSingularInt32Field(value: &_storage._forReadingFrom) }() + case 354: try { try decoder.decodeSingularInt32Field(value: &_storage._forTypeURL) }() + case 355: try { try decoder.decodeSingularInt32Field(value: &_storage._forwardParser) }() + case 356: try { try decoder.decodeSingularInt32Field(value: &_storage._forWritingInto) }() + case 357: try { try decoder.decodeSingularInt32Field(value: &_storage._from) }() + case 358: try { try decoder.decodeSingularInt32Field(value: &_storage._fromAscii2) }() + case 359: try { try decoder.decodeSingularInt32Field(value: &_storage._fromAscii4) }() + case 360: try { try decoder.decodeSingularInt32Field(value: &_storage._fromByteOffset) }() + case 361: try { try decoder.decodeSingularInt32Field(value: &_storage._fromHexDigit) }() + case 362: try { try decoder.decodeSingularInt32Field(value: &_storage._fullName) }() + case 363: try { try decoder.decodeSingularInt32Field(value: &_storage._func) }() + case 364: try { try decoder.decodeSingularInt32Field(value: &_storage._function) }() + case 365: try { try decoder.decodeSingularInt32Field(value: &_storage._g) }() + case 366: try { try decoder.decodeSingularInt32Field(value: &_storage._get) }() + case 367: try { try decoder.decodeSingularInt32Field(value: &_storage._getExtensionValue) }() + case 368: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufAny) }() + case 369: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufApi) }() + case 370: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufBoolValue) }() + case 371: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufBytesValue) }() + case 372: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufDescriptorProto) }() + case 373: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufDoubleValue) }() + case 374: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufDuration) }() + case 375: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEdition) }() + case 376: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEmpty) }() + case 377: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnum) }() + case 378: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumDescriptorProto) }() + case 379: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumOptions) }() + case 380: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumValue) }() + case 381: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumValueDescriptorProto) }() + case 382: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumValueOptions) }() + case 383: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufExtensionRangeOptions) }() + case 384: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFeatureSet) }() + case 385: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFeatureSetDefaults) }() + case 386: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufField) }() + case 387: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFieldDescriptorProto) }() + case 388: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFieldMask) }() + case 389: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFieldOptions) }() + case 390: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFileDescriptorProto) }() + case 391: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFileDescriptorSet) }() + case 392: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFileOptions) }() + case 393: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFloatValue) }() + case 394: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufGeneratedCodeInfo) }() + case 395: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufInt32Value) }() + case 396: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufInt64Value) }() + case 397: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufListValue) }() + case 398: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMessageOptions) }() + case 399: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMethod) }() + case 400: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMethodDescriptorProto) }() + case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMethodOptions) }() + case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMixin) }() + case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufNullValue) }() + case 404: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufOneofDescriptorProto) }() + case 405: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufOneofOptions) }() + case 406: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufOption) }() + case 407: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufServiceDescriptorProto) }() + case 408: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufServiceOptions) }() + case 409: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSourceCodeInfo) }() + case 410: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSourceContext) }() + case 411: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufStringValue) }() + case 412: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufStruct) }() + case 413: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSymbolVisibility) }() + case 414: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSyntax) }() + case 415: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufTimestamp) }() + case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufType) }() + case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufUint32Value) }() + case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufUint64Value) }() + case 419: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufUninterpretedOption) }() + case 420: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufValue) }() + case 421: try { try decoder.decodeSingularInt32Field(value: &_storage._goPackage) }() + case 422: try { try decoder.decodeSingularInt32Field(value: &_storage._gotData) }() + case 423: try { try decoder.decodeSingularInt32Field(value: &_storage._group) }() + case 424: try { try decoder.decodeSingularInt32Field(value: &_storage._groupFieldNumberStack) }() + case 425: try { try decoder.decodeSingularInt32Field(value: &_storage._groupSize) }() + case 426: try { try decoder.decodeSingularInt32Field(value: &_storage._guard) }() + case 427: try { try decoder.decodeSingularInt32Field(value: &_storage._hadOneofValue) }() + case 428: try { try decoder.decodeSingularInt32Field(value: &_storage._handleConflictingOneOf) }() + case 429: try { try decoder.decodeSingularInt32Field(value: &_storage._handleInstruction) }() + case 430: try { try decoder.decodeSingularInt32Field(value: &_storage._hasAggregateValue_p) }() + case 431: try { try decoder.decodeSingularInt32Field(value: &_storage._hasAllowAlias_p) }() + case 432: try { try decoder.decodeSingularInt32Field(value: &_storage._hasBegin_p) }() + case 433: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCcEnableArenas_p) }() + case 434: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCcGenericServices_p) }() + case 435: try { try decoder.decodeSingularInt32Field(value: &_storage._hasClientStreaming_p) }() + case 436: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCsharpNamespace_p) }() + case 437: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCtype_p) }() + case 438: try { try decoder.decodeSingularInt32Field(value: &_storage._hasData_p) }() + case 439: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDebugRedact_p) }() + case 440: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDefaultSymbolVisibility_p) }() + case 441: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDefaultValue_p) }() + case 442: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDeprecated_p) }() + case 443: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDeprecatedLegacyJsonFieldConflicts_p) }() + case 444: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDeprecationWarning_p) }() + case 445: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDoubleValue_p) }() + case 446: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEdition_p) }() + case 447: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEditionDeprecated_p) }() + case 448: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEditionIntroduced_p) }() + case 449: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEditionRemoved_p) }() + case 450: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEnd_p) }() + case 451: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEnforceNamingStyle_p) }() + case 452: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEnumType_p) }() + case 453: try { try decoder.decodeSingularInt32Field(value: &_storage._hasExplicitDelta_p) }() + case 454: try { try decoder.decodeSingularInt32Field(value: &_storage._hasExtendee_p) }() + case 455: try { try decoder.decodeSingularInt32Field(value: &_storage._hasExtensionValue_p) }() + case 456: try { try decoder.decodeSingularInt32Field(value: &_storage._hasFeatures_p) }() + case 457: try { try decoder.decodeSingularInt32Field(value: &_storage._hasFeatureSupport_p) }() + case 458: try { try decoder.decodeSingularInt32Field(value: &_storage._hasFieldPresence_p) }() + case 459: try { try decoder.decodeSingularInt32Field(value: &_storage._hasFixedFeatures_p) }() + case 460: try { try decoder.decodeSingularInt32Field(value: &_storage._hasFullName_p) }() + case 461: try { try decoder.decodeSingularInt32Field(value: &_storage._hasGoPackage_p) }() + case 462: try { try decoder.decodeSingularInt32Field(value: &_storage._hash) }() + case 463: try { try decoder.decodeSingularInt32Field(value: &_storage._hashable) }() + case 464: try { try decoder.decodeSingularInt32Field(value: &_storage._hasher) }() + case 465: try { try decoder.decodeSingularInt32Field(value: &_storage._hashVisitor) }() + case 466: try { try decoder.decodeSingularInt32Field(value: &_storage._hasIdempotencyLevel_p) }() + case 467: try { try decoder.decodeSingularInt32Field(value: &_storage._hasIdentifierValue_p) }() + case 468: try { try decoder.decodeSingularInt32Field(value: &_storage._hasInputType_p) }() + case 469: try { try decoder.decodeSingularInt32Field(value: &_storage._hasIsExtension_p) }() + case 470: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaGenerateEqualsAndHash_p) }() + case 471: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaGenericServices_p) }() + case 472: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaMultipleFiles_p) }() + case 473: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaOuterClassname_p) }() + case 474: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaPackage_p) }() + case 475: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaStringCheckUtf8_p) }() + case 476: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJsonFormat_p) }() + case 477: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJsonName_p) }() + case 478: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJstype_p) }() + case 479: try { try decoder.decodeSingularInt32Field(value: &_storage._hasLabel_p) }() + case 480: try { try decoder.decodeSingularInt32Field(value: &_storage._hasLazy_p) }() + case 481: try { try decoder.decodeSingularInt32Field(value: &_storage._hasLeadingComments_p) }() + case 482: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMapEntry_p) }() + case 483: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMaximumEdition_p) }() + case 484: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMessageEncoding_p) }() + case 485: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMessageSetWireFormat_p) }() + case 486: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMinimumEdition_p) }() + case 487: try { try decoder.decodeSingularInt32Field(value: &_storage._hasName_p) }() + case 488: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNamePart_p) }() + case 489: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNegativeIntValue_p) }() + case 490: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNoStandardDescriptorAccessor_p) }() + case 491: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNumber_p) }() + case 492: try { try decoder.decodeSingularInt32Field(value: &_storage._hasObjcClassPrefix_p) }() + case 493: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOneofIndex_p) }() + case 494: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOptimizeFor_p) }() + case 495: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOptions_p) }() + case 496: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOutputType_p) }() + case 497: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOverridableFeatures_p) }() + case 498: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPackage_p) }() + case 499: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPacked_p) }() + case 500: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpClassPrefix_p) }() + case 501: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpMetadataNamespace_p) }() + case 502: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpNamespace_p) }() + case 503: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPositiveIntValue_p) }() + case 504: try { try decoder.decodeSingularInt32Field(value: &_storage._hasProto3Optional_p) }() + case 505: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPyGenericServices_p) }() + case 506: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRemovalError_p) }() + case 507: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRepeated_p) }() + case 508: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRepeatedFieldEncoding_p) }() + case 509: try { try decoder.decodeSingularInt32Field(value: &_storage._hasReserved_p) }() + case 510: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRetention_p) }() + case 511: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRubyPackage_p) }() + case 512: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSemantic_p) }() + case 513: try { try decoder.decodeSingularInt32Field(value: &_storage._hasServerStreaming_p) }() + case 514: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSourceCodeInfo_p) }() + case 515: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSourceContext_p) }() + case 516: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSourceFile_p) }() + case 517: try { try decoder.decodeSingularInt32Field(value: &_storage._hasStart_p) }() + case 518: try { try decoder.decodeSingularInt32Field(value: &_storage._hasStringValue_p) }() + case 519: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSwiftPrefix_p) }() + case 520: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSyntax_p) }() + case 521: try { try decoder.decodeSingularInt32Field(value: &_storage._hasTrailingComments_p) }() + case 522: try { try decoder.decodeSingularInt32Field(value: &_storage._hasType_p) }() + case 523: try { try decoder.decodeSingularInt32Field(value: &_storage._hasTypeName_p) }() + case 524: try { try decoder.decodeSingularInt32Field(value: &_storage._hasUnverifiedLazy_p) }() + case 525: try { try decoder.decodeSingularInt32Field(value: &_storage._hasUtf8Validation_p) }() + case 526: try { try decoder.decodeSingularInt32Field(value: &_storage._hasValue_p) }() + case 527: try { try decoder.decodeSingularInt32Field(value: &_storage._hasVerification_p) }() + case 528: try { try decoder.decodeSingularInt32Field(value: &_storage._hasVisibility_p) }() + case 529: try { try decoder.decodeSingularInt32Field(value: &_storage._hasWeak_p) }() + case 530: try { try decoder.decodeSingularInt32Field(value: &_storage._hour) }() + case 531: try { try decoder.decodeSingularInt32Field(value: &_storage._i) }() + case 532: try { try decoder.decodeSingularInt32Field(value: &_storage._idempotencyLevel) }() + case 533: try { try decoder.decodeSingularInt32Field(value: &_storage._identifierValue) }() + case 534: try { try decoder.decodeSingularInt32Field(value: &_storage._if) }() + case 535: try { try decoder.decodeSingularInt32Field(value: &_storage._ignoreUnknownExtensionFields) }() + case 536: try { try decoder.decodeSingularInt32Field(value: &_storage._ignoreUnknownFields) }() + case 537: try { try decoder.decodeSingularInt32Field(value: &_storage._index) }() + case 538: try { try decoder.decodeSingularInt32Field(value: &_storage._init_p) }() + case 539: try { try decoder.decodeSingularInt32Field(value: &_storage._inout) }() + case 540: try { try decoder.decodeSingularInt32Field(value: &_storage._inputType) }() + case 541: try { try decoder.decodeSingularInt32Field(value: &_storage._insert) }() + case 542: try { try decoder.decodeSingularInt32Field(value: &_storage._instruction) }() + case 543: try { try decoder.decodeSingularInt32Field(value: &_storage._int) }() + case 544: try { try decoder.decodeSingularInt32Field(value: &_storage._int32) }() + case 545: try { try decoder.decodeSingularInt32Field(value: &_storage._int64) }() + case 546: try { try decoder.decodeSingularInt32Field(value: &_storage._int8) }() + case 547: try { try decoder.decodeSingularInt32Field(value: &_storage._integerLiteral) }() + case 548: try { try decoder.decodeSingularInt32Field(value: &_storage._integerLiteralType) }() + case 549: try { try decoder.decodeSingularInt32Field(value: &_storage._intern) }() + case 550: try { try decoder.decodeSingularInt32Field(value: &_storage._internal) }() + case 551: try { try decoder.decodeSingularInt32Field(value: &_storage._internalState) }() + case 552: try { try decoder.decodeSingularInt32Field(value: &_storage._intersect) }() + case 553: try { try decoder.decodeSingularInt32Field(value: &_storage._into) }() + case 554: try { try decoder.decodeSingularInt32Field(value: &_storage._ints) }() + case 555: try { try decoder.decodeSingularInt32Field(value: &_storage._invalidAnyTypeURL) }() + case 556: try { try decoder.decodeSingularInt32Field(value: &_storage._isA) }() + case 557: try { try decoder.decodeSingularInt32Field(value: &_storage._isEqual) }() + case 558: try { try decoder.decodeSingularInt32Field(value: &_storage._isEqualTo) }() + case 559: try { try decoder.decodeSingularInt32Field(value: &_storage._isExtension) }() + case 560: try { try decoder.decodeSingularInt32Field(value: &_storage._isInitialized_p) }() + case 561: try { try decoder.decodeSingularInt32Field(value: &_storage._isNegative) }() + case 562: try { try decoder.decodeSingularInt32Field(value: &_storage._isPathValid) }() + case 563: try { try decoder.decodeSingularInt32Field(value: &_storage._isReserved) }() + case 564: try { try decoder.decodeSingularInt32Field(value: &_storage._isValid) }() + case 565: try { try decoder.decodeSingularInt32Field(value: &_storage._itemTagsEncodedSize) }() + case 566: try { try decoder.decodeSingularInt32Field(value: &_storage._iterator) }() + case 567: try { try decoder.decodeSingularInt32Field(value: &_storage._javaGenerateEqualsAndHash) }() + case 568: try { try decoder.decodeSingularInt32Field(value: &_storage._javaGenericServices) }() + case 569: try { try decoder.decodeSingularInt32Field(value: &_storage._javaMultipleFiles) }() + case 570: try { try decoder.decodeSingularInt32Field(value: &_storage._javaOuterClassname) }() + case 571: try { try decoder.decodeSingularInt32Field(value: &_storage._javaPackage) }() + case 572: try { try decoder.decodeSingularInt32Field(value: &_storage._javaStringCheckUtf8) }() + case 573: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecoder) }() + case 574: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecoding) }() + case 575: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecodingError) }() + case 576: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecodingOptions) }() + case 577: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonEncoder) }() + case 578: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencoding) }() + case 579: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencodingError) }() + case 580: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencodingOptions) }() + case 581: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencodingVisitor) }() + case 582: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonFormat) }() + case 583: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonmapEncodingVisitor) }() + case 584: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonName) }() + case 585: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonPath) }() + case 586: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonPaths) }() + case 587: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonscanner) }() + case 588: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonString) }() + case 589: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonText) }() + case 590: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonUtf8Bytes) }() + case 591: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonUtf8Data) }() + case 592: try { try decoder.decodeSingularInt32Field(value: &_storage._jstype) }() + case 593: try { try decoder.decodeSingularInt32Field(value: &_storage._k) }() + case 594: try { try decoder.decodeSingularInt32Field(value: &_storage._kChunkSize) }() + case 595: try { try decoder.decodeSingularInt32Field(value: &_storage._key) }() + case 596: try { try decoder.decodeSingularInt32Field(value: &_storage._keyField) }() + case 597: try { try decoder.decodeSingularInt32Field(value: &_storage._keyFieldOpt) }() + case 598: try { try decoder.decodeSingularInt32Field(value: &_storage._keyType) }() + case 599: try { try decoder.decodeSingularInt32Field(value: &_storage._kind) }() + case 600: try { try decoder.decodeSingularInt32Field(value: &_storage._l) }() + case 601: try { try decoder.decodeSingularInt32Field(value: &_storage._label) }() + case 602: try { try decoder.decodeSingularInt32Field(value: &_storage._lazy) }() + case 603: try { try decoder.decodeSingularInt32Field(value: &_storage._leadingComments) }() + case 604: try { try decoder.decodeSingularInt32Field(value: &_storage._leadingDetachedComments) }() + case 605: try { try decoder.decodeSingularInt32Field(value: &_storage._length) }() + case 606: try { try decoder.decodeSingularInt32Field(value: &_storage._lessThan) }() + case 607: try { try decoder.decodeSingularInt32Field(value: &_storage._let) }() + case 608: try { try decoder.decodeSingularInt32Field(value: &_storage._lhs) }() + case 609: try { try decoder.decodeSingularInt32Field(value: &_storage._line) }() + case 610: try { try decoder.decodeSingularInt32Field(value: &_storage._list) }() + case 611: try { try decoder.decodeSingularInt32Field(value: &_storage._listOfMessages) }() + case 612: try { try decoder.decodeSingularInt32Field(value: &_storage._listValue) }() + case 613: try { try decoder.decodeSingularInt32Field(value: &_storage._littleEndian) }() + case 614: try { try decoder.decodeSingularInt32Field(value: &_storage._load) }() + case 615: try { try decoder.decodeSingularInt32Field(value: &_storage._localHasher) }() + case 616: try { try decoder.decodeSingularInt32Field(value: &_storage._location) }() + case 617: try { try decoder.decodeSingularInt32Field(value: &_storage._m) }() + case 618: try { try decoder.decodeSingularInt32Field(value: &_storage._major) }() + case 619: try { try decoder.decodeSingularInt32Field(value: &_storage._makeAsyncIterator) }() + case 620: try { try decoder.decodeSingularInt32Field(value: &_storage._makeIterator) }() + case 621: try { try decoder.decodeSingularInt32Field(value: &_storage._malformedLength) }() + case 622: try { try decoder.decodeSingularInt32Field(value: &_storage._mapEntry) }() + case 623: try { try decoder.decodeSingularInt32Field(value: &_storage._mapKeyType) }() + case 624: try { try decoder.decodeSingularInt32Field(value: &_storage._mapToMessages) }() + case 625: try { try decoder.decodeSingularInt32Field(value: &_storage._mapValueType) }() + case 626: try { try decoder.decodeSingularInt32Field(value: &_storage._mapVisitor) }() + case 627: try { try decoder.decodeSingularInt32Field(value: &_storage._mask) }() + case 628: try { try decoder.decodeSingularInt32Field(value: &_storage._maximumEdition) }() + case 629: try { try decoder.decodeSingularInt32Field(value: &_storage._mdayStart) }() + case 630: try { try decoder.decodeSingularInt32Field(value: &_storage._merge) }() + case 631: try { try decoder.decodeSingularInt32Field(value: &_storage._mergeOptions) }() + case 632: try { try decoder.decodeSingularInt32Field(value: &_storage._message) }() + case 633: try { try decoder.decodeSingularInt32Field(value: &_storage._messageDepthLimit) }() + case 634: try { try decoder.decodeSingularInt32Field(value: &_storage._messageEncoding) }() + case 635: try { try decoder.decodeSingularInt32Field(value: &_storage._messageExtension) }() + case 636: try { try decoder.decodeSingularInt32Field(value: &_storage._messageImplementationBase) }() + case 637: try { try decoder.decodeSingularInt32Field(value: &_storage._messageSet) }() + case 638: try { try decoder.decodeSingularInt32Field(value: &_storage._messageSetWireFormat) }() + case 639: try { try decoder.decodeSingularInt32Field(value: &_storage._messageSize) }() + case 640: try { try decoder.decodeSingularInt32Field(value: &_storage._messageType) }() + case 641: try { try decoder.decodeSingularInt32Field(value: &_storage._method) }() + case 642: try { try decoder.decodeSingularInt32Field(value: &_storage._methods) }() + case 643: try { try decoder.decodeSingularInt32Field(value: &_storage._min) }() + case 644: try { try decoder.decodeSingularInt32Field(value: &_storage._minimumEdition) }() + case 645: try { try decoder.decodeSingularInt32Field(value: &_storage._minor) }() + case 646: try { try decoder.decodeSingularInt32Field(value: &_storage._mixins) }() + case 647: try { try decoder.decodeSingularInt32Field(value: &_storage._modify) }() + case 648: try { try decoder.decodeSingularInt32Field(value: &_storage._month) }() + case 649: try { try decoder.decodeSingularInt32Field(value: &_storage._msgExtension) }() + case 650: try { try decoder.decodeSingularInt32Field(value: &_storage._mutating) }() + case 651: try { try decoder.decodeSingularInt32Field(value: &_storage._n) }() + case 652: try { try decoder.decodeSingularInt32Field(value: &_storage._name) }() + case 653: try { try decoder.decodeSingularInt32Field(value: &_storage._nameDescription) }() + case 654: try { try decoder.decodeSingularInt32Field(value: &_storage._nameMap) }() + case 655: try { try decoder.decodeSingularInt32Field(value: &_storage._namePart) }() + case 656: try { try decoder.decodeSingularInt32Field(value: &_storage._names) }() + case 657: try { try decoder.decodeSingularInt32Field(value: &_storage._nanos) }() + case 658: try { try decoder.decodeSingularInt32Field(value: &_storage._negativeIntValue) }() + case 659: try { try decoder.decodeSingularInt32Field(value: &_storage._nestedType) }() + case 660: try { try decoder.decodeSingularInt32Field(value: &_storage._newExtensible) }() + case 661: try { try decoder.decodeSingularInt32Field(value: &_storage._newL) }() + case 662: try { try decoder.decodeSingularInt32Field(value: &_storage._newList) }() + case 663: try { try decoder.decodeSingularInt32Field(value: &_storage._newMessage) }() + case 664: try { try decoder.decodeSingularInt32Field(value: &_storage._newValue) }() + case 665: try { try decoder.decodeSingularInt32Field(value: &_storage._next) }() + case 666: try { try decoder.decodeSingularInt32Field(value: &_storage._nextByte) }() + case 667: try { try decoder.decodeSingularInt32Field(value: &_storage._nextFieldNumber) }() + case 668: try { try decoder.decodeSingularInt32Field(value: &_storage._nextInstruction) }() + case 669: try { try decoder.decodeSingularInt32Field(value: &_storage._nextInt32) }() + case 670: try { try decoder.decodeSingularInt32Field(value: &_storage._nextNullTerminatedString) }() + case 671: try { try decoder.decodeSingularInt32Field(value: &_storage._nextNullTerminatedStringArray) }() + case 672: try { try decoder.decodeSingularInt32Field(value: &_storage._nextNumber) }() + case 673: try { try decoder.decodeSingularInt32Field(value: &_storage._nextUint64) }() + case 674: try { try decoder.decodeSingularInt32Field(value: &_storage._nextVarInt) }() + case 675: try { try decoder.decodeSingularInt32Field(value: &_storage._nil) }() + case 676: try { try decoder.decodeSingularInt32Field(value: &_storage._nilLiteral) }() + case 677: try { try decoder.decodeSingularInt32Field(value: &_storage._noBytesAvailable) }() + case 678: try { try decoder.decodeSingularInt32Field(value: &_storage._noStandardDescriptorAccessor) }() + case 679: try { try decoder.decodeSingularInt32Field(value: &_storage._nullValue) }() + case 680: try { try decoder.decodeSingularInt32Field(value: &_storage._number) }() + case 681: try { try decoder.decodeSingularInt32Field(value: &_storage._numberValue) }() + case 682: try { try decoder.decodeSingularInt32Field(value: &_storage._objcClassPrefix) }() + case 683: try { try decoder.decodeSingularInt32Field(value: &_storage._of) }() + case 684: try { try decoder.decodeSingularInt32Field(value: &_storage._oneOfKind) }() + case 685: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofDecl) }() + case 686: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofIndex) }() + case 687: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofs) }() + case 688: try { try decoder.decodeSingularInt32Field(value: &_storage._optimizeFor) }() + case 689: try { try decoder.decodeSingularInt32Field(value: &_storage._optimizeMode) }() + case 690: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalEnumExtensionField) }() + case 691: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalExtensionField) }() + case 692: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalGroupExtensionField) }() + case 693: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalMessageExtensionField) }() + case 694: try { try decoder.decodeSingularInt32Field(value: &_storage._optionDependency) }() + case 695: try { try decoder.decodeSingularInt32Field(value: &_storage._optionRetention) }() + case 696: try { try decoder.decodeSingularInt32Field(value: &_storage._options) }() + case 697: try { try decoder.decodeSingularInt32Field(value: &_storage._optionTargetType) }() + case 698: try { try decoder.decodeSingularInt32Field(value: &_storage._other) }() + case 699: try { try decoder.decodeSingularInt32Field(value: &_storage._others) }() + case 700: try { try decoder.decodeSingularInt32Field(value: &_storage._out) }() + case 701: try { try decoder.decodeSingularInt32Field(value: &_storage._outputType) }() + case 702: try { try decoder.decodeSingularInt32Field(value: &_storage._overridableFeatures) }() + case 703: try { try decoder.decodeSingularInt32Field(value: &_storage._p) }() + case 704: try { try decoder.decodeSingularInt32Field(value: &_storage._package) }() + case 705: try { try decoder.decodeSingularInt32Field(value: &_storage._packed) }() + case 706: try { try decoder.decodeSingularInt32Field(value: &_storage._packedEnumExtensionField) }() + case 707: try { try decoder.decodeSingularInt32Field(value: &_storage._packedExtensionField) }() + case 708: try { try decoder.decodeSingularInt32Field(value: &_storage._padding) }() + case 709: try { try decoder.decodeSingularInt32Field(value: &_storage._parent) }() + case 710: try { try decoder.decodeSingularInt32Field(value: &_storage._parse) }() + case 711: try { try decoder.decodeSingularInt32Field(value: &_storage._partial) }() + case 712: try { try decoder.decodeSingularInt32Field(value: &_storage._path) }() + case 713: try { try decoder.decodeSingularInt32Field(value: &_storage._pathDecoder) }() + case 714: try { try decoder.decodeSingularInt32Field(value: &_storage._pathDecodingError) }() + case 715: try { try decoder.decodeSingularInt32Field(value: &_storage._paths) }() + case 716: try { try decoder.decodeSingularInt32Field(value: &_storage._pathVisitor) }() + case 717: try { try decoder.decodeSingularInt32Field(value: &_storage._payload) }() + case 718: try { try decoder.decodeSingularInt32Field(value: &_storage._payloadSize) }() + case 719: try { try decoder.decodeSingularInt32Field(value: &_storage._phpClassPrefix) }() + case 720: try { try decoder.decodeSingularInt32Field(value: &_storage._phpMetadataNamespace) }() + case 721: try { try decoder.decodeSingularInt32Field(value: &_storage._phpNamespace) }() + case 722: try { try decoder.decodeSingularInt32Field(value: &_storage._pos) }() + case 723: try { try decoder.decodeSingularInt32Field(value: &_storage._positiveIntValue) }() + case 724: try { try decoder.decodeSingularInt32Field(value: &_storage._prefix) }() + case 725: try { try decoder.decodeSingularInt32Field(value: &_storage._preserveProtoFieldNames) }() + case 726: try { try decoder.decodeSingularInt32Field(value: &_storage._preTraverse) }() + case 727: try { try decoder.decodeSingularInt32Field(value: &_storage._previousNumber) }() + case 728: try { try decoder.decodeSingularInt32Field(value: &_storage._prevPath) }() + case 729: try { try decoder.decodeSingularInt32Field(value: &_storage._printUnknownFields) }() + case 730: try { try decoder.decodeSingularInt32Field(value: &_storage._programBuffer) }() + case 731: try { try decoder.decodeSingularInt32Field(value: &_storage._programFormat) }() + case 732: try { try decoder.decodeSingularInt32Field(value: &_storage._proto2) }() + case 733: try { try decoder.decodeSingularInt32Field(value: &_storage._proto3DefaultValue) }() + case 734: try { try decoder.decodeSingularInt32Field(value: &_storage._proto3Optional) }() + case 735: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufExtensionFieldValues) }() + case 736: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFieldNumber) }() + case 737: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufGeneratedIsEqualTo) }() + case 738: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufNameMap) }() + case 739: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufNewField) }() + case 740: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufPackage) }() + case 741: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufApiversion2) }() + case 742: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufApiversionCheck) }() + case 743: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufBool) }() + case 744: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufBytes) }() + case 745: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufData) }() + case 746: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufDouble) }() + case 747: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufEnumMap) }() + case 748: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufExtension) }() + case 749: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFixed32) }() + case 750: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFixed64) }() + case 751: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFloat) }() + case 752: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufInt32) }() + case 753: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufInt64) }() + case 754: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufMap) }() + case 755: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufMessageMap) }() + case 756: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSfixed32) }() + case 757: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSfixed64) }() + case 758: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSint32) }() + case 759: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSint64) }() + case 760: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufString) }() + case 761: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufUint32) }() + case 762: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufUint64) }() + case 763: try { try decoder.decodeSingularInt32Field(value: &_storage._protocol) }() + case 764: try { try decoder.decodeSingularInt32Field(value: &_storage._protoFieldName) }() + case 765: try { try decoder.decodeSingularInt32Field(value: &_storage._protoMessageName) }() + case 766: try { try decoder.decodeSingularInt32Field(value: &_storage._protoNameProviding) }() + case 767: try { try decoder.decodeSingularInt32Field(value: &_storage._protoPaths) }() + case 768: try { try decoder.decodeSingularInt32Field(value: &_storage._public) }() + case 769: try { try decoder.decodeSingularInt32Field(value: &_storage._publicDependency) }() + case 770: try { try decoder.decodeSingularInt32Field(value: &_storage._putBoolValue) }() + case 771: try { try decoder.decodeSingularInt32Field(value: &_storage._putBytesValue) }() + case 772: try { try decoder.decodeSingularInt32Field(value: &_storage._putDoubleValue) }() + case 773: try { try decoder.decodeSingularInt32Field(value: &_storage._putEnumValue) }() + case 774: try { try decoder.decodeSingularInt32Field(value: &_storage._putFixedUint32) }() + case 775: try { try decoder.decodeSingularInt32Field(value: &_storage._putFixedUint64) }() + case 776: try { try decoder.decodeSingularInt32Field(value: &_storage._putFloatValue) }() + case 777: try { try decoder.decodeSingularInt32Field(value: &_storage._putInt64) }() + case 778: try { try decoder.decodeSingularInt32Field(value: &_storage._putStringValue) }() + case 779: try { try decoder.decodeSingularInt32Field(value: &_storage._putUint64) }() + case 780: try { try decoder.decodeSingularInt32Field(value: &_storage._putUint64Hex) }() + case 781: try { try decoder.decodeSingularInt32Field(value: &_storage._putVarInt) }() + case 782: try { try decoder.decodeSingularInt32Field(value: &_storage._putZigZagVarInt) }() + case 783: try { try decoder.decodeSingularInt32Field(value: &_storage._pyGenericServices) }() + case 784: try { try decoder.decodeSingularInt32Field(value: &_storage._r) }() + case 785: try { try decoder.decodeSingularInt32Field(value: &_storage._rawChars) }() + case 786: try { try decoder.decodeSingularInt32Field(value: &_storage._rawRepresentable) }() + case 787: try { try decoder.decodeSingularInt32Field(value: &_storage._rawValue) }() + case 788: try { try decoder.decodeSingularInt32Field(value: &_storage._read4HexDigits) }() + case 789: try { try decoder.decodeSingularInt32Field(value: &_storage._readBytes) }() + case 790: try { try decoder.decodeSingularInt32Field(value: &_storage._reader) }() + case 791: try { try decoder.decodeSingularInt32Field(value: &_storage._register) }() + case 792: try { try decoder.decodeSingularInt32Field(value: &_storage._remainingProgram) }() + case 793: try { try decoder.decodeSingularInt32Field(value: &_storage._removalError) }() + case 794: try { try decoder.decodeSingularInt32Field(value: &_storage._removingAllFieldsOf) }() + case 795: try { try decoder.decodeSingularInt32Field(value: &_storage._repeated) }() + case 796: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedEnumExtensionField) }() + case 797: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedExtensionField) }() + case 798: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedFieldEncoding) }() + case 799: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedGroupExtensionField) }() + case 800: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedMessageExtensionField) }() + case 801: try { try decoder.decodeSingularInt32Field(value: &_storage._repeating) }() + case 802: try { try decoder.decodeSingularInt32Field(value: &_storage._replaceRepeatedFields) }() + case 803: try { try decoder.decodeSingularInt32Field(value: &_storage._requestStreaming) }() + case 804: try { try decoder.decodeSingularInt32Field(value: &_storage._requestTypeURL) }() + case 805: try { try decoder.decodeSingularInt32Field(value: &_storage._requiredSize) }() + case 806: try { try decoder.decodeSingularInt32Field(value: &_storage._responseStreaming) }() + case 807: try { try decoder.decodeSingularInt32Field(value: &_storage._responseTypeURL) }() + case 808: try { try decoder.decodeSingularInt32Field(value: &_storage._result) }() + case 809: try { try decoder.decodeSingularInt32Field(value: &_storage._retention) }() + case 810: try { try decoder.decodeSingularInt32Field(value: &_storage._rethrows) }() + case 811: try { try decoder.decodeSingularInt32Field(value: &_storage._returnType) }() + case 812: try { try decoder.decodeSingularInt32Field(value: &_storage._revision) }() + case 813: try { try decoder.decodeSingularInt32Field(value: &_storage._rhs) }() + case 814: try { try decoder.decodeSingularInt32Field(value: &_storage._root) }() + case 815: try { try decoder.decodeSingularInt32Field(value: &_storage._rubyPackage) }() + case 816: try { try decoder.decodeSingularInt32Field(value: &_storage._s) }() + case 817: try { try decoder.decodeSingularInt32Field(value: &_storage._sawBackslash) }() + case 818: try { try decoder.decodeSingularInt32Field(value: &_storage._sawSection4Characters) }() + case 819: try { try decoder.decodeSingularInt32Field(value: &_storage._sawSection5Characters) }() + case 820: try { try decoder.decodeSingularInt32Field(value: &_storage._scalar) }() + case 821: try { try decoder.decodeSingularInt32Field(value: &_storage._scan) }() + case 822: try { try decoder.decodeSingularInt32Field(value: &_storage._scanner) }() + case 823: try { try decoder.decodeSingularInt32Field(value: &_storage._seconds) }() + case 824: try { try decoder.decodeSingularInt32Field(value: &_storage._self_p) }() + case 825: try { try decoder.decodeSingularInt32Field(value: &_storage._semantic) }() + case 826: try { try decoder.decodeSingularInt32Field(value: &_storage._sendable) }() + case 827: try { try decoder.decodeSingularInt32Field(value: &_storage._separator) }() + case 828: try { try decoder.decodeSingularInt32Field(value: &_storage._serialize) }() + case 829: try { try decoder.decodeSingularInt32Field(value: &_storage._serializedBytes) }() + case 830: try { try decoder.decodeSingularInt32Field(value: &_storage._serializedData) }() + case 831: try { try decoder.decodeSingularInt32Field(value: &_storage._serializedSize) }() + case 832: try { try decoder.decodeSingularInt32Field(value: &_storage._serverStreaming) }() + case 833: try { try decoder.decodeSingularInt32Field(value: &_storage._service) }() + case 834: try { try decoder.decodeSingularInt32Field(value: &_storage._set) }() + case 835: try { try decoder.decodeSingularInt32Field(value: &_storage._setExtensionValue) }() + case 836: try { try decoder.decodeSingularInt32Field(value: &_storage._shift) }() + case 837: try { try decoder.decodeSingularInt32Field(value: &_storage._simpleExtensionMap) }() + case 838: try { try decoder.decodeSingularInt32Field(value: &_storage._size) }() + case 839: try { try decoder.decodeSingularInt32Field(value: &_storage._sizer) }() + case 840: try { try decoder.decodeSingularInt32Field(value: &_storage._source) }() + case 841: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceCodeInfo) }() + case 842: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceContext) }() + case 843: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceEncoding) }() + case 844: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceFile) }() + case 845: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceLocation) }() + case 846: try { try decoder.decodeSingularInt32Field(value: &_storage._span) }() + case 847: try { try decoder.decodeSingularInt32Field(value: &_storage._split) }() + case 848: try { try decoder.decodeSingularInt32Field(value: &_storage._start) }() + case 849: try { try decoder.decodeSingularInt32Field(value: &_storage._startArray) }() + case 850: try { try decoder.decodeSingularInt32Field(value: &_storage._startArrayObject) }() + case 851: try { try decoder.decodeSingularInt32Field(value: &_storage._startField) }() + case 852: try { try decoder.decodeSingularInt32Field(value: &_storage._startIndex) }() + case 853: try { try decoder.decodeSingularInt32Field(value: &_storage._startMessageField) }() + case 854: try { try decoder.decodeSingularInt32Field(value: &_storage._startObject) }() + case 855: try { try decoder.decodeSingularInt32Field(value: &_storage._startRegularField) }() + case 856: try { try decoder.decodeSingularInt32Field(value: &_storage._state) }() + case 857: try { try decoder.decodeSingularInt32Field(value: &_storage._static) }() + case 858: try { try decoder.decodeSingularInt32Field(value: &_storage._staticString) }() + case 859: try { try decoder.decodeSingularInt32Field(value: &_storage._storage) }() + case 860: try { try decoder.decodeSingularInt32Field(value: &_storage._string) }() + case 861: try { try decoder.decodeSingularInt32Field(value: &_storage._stringLiteral) }() + case 862: try { try decoder.decodeSingularInt32Field(value: &_storage._stringLiteralType) }() + case 863: try { try decoder.decodeSingularInt32Field(value: &_storage._stringResult) }() + case 864: try { try decoder.decodeSingularInt32Field(value: &_storage._stringValue) }() + case 865: try { try decoder.decodeSingularInt32Field(value: &_storage._struct) }() + case 866: try { try decoder.decodeSingularInt32Field(value: &_storage._structValue) }() + case 867: try { try decoder.decodeSingularInt32Field(value: &_storage._subDecoder) }() + case 868: try { try decoder.decodeSingularInt32Field(value: &_storage._subscript) }() + case 869: try { try decoder.decodeSingularInt32Field(value: &_storage._subtract) }() + case 870: try { try decoder.decodeSingularInt32Field(value: &_storage._subVisitor) }() + case 871: try { try decoder.decodeSingularInt32Field(value: &_storage._swift) }() + case 872: try { try decoder.decodeSingularInt32Field(value: &_storage._swiftPrefix) }() + case 873: try { try decoder.decodeSingularInt32Field(value: &_storage._swiftProtobufContiguousBytes) }() + case 874: try { try decoder.decodeSingularInt32Field(value: &_storage._swiftProtobufError) }() + case 875: try { try decoder.decodeSingularInt32Field(value: &_storage._syntax) }() + case 876: try { try decoder.decodeSingularInt32Field(value: &_storage._t) }() + case 877: try { try decoder.decodeSingularInt32Field(value: &_storage._tag) }() + case 878: try { try decoder.decodeSingularInt32Field(value: &_storage._targets) }() + case 879: try { try decoder.decodeSingularInt32Field(value: &_storage._terminator) }() + case 880: try { try decoder.decodeSingularInt32Field(value: &_storage._testDecoder) }() + case 881: try { try decoder.decodeSingularInt32Field(value: &_storage._text) }() + case 882: try { try decoder.decodeSingularInt32Field(value: &_storage._textDecoder) }() + case 883: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatDecoder) }() + case 884: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatDecodingError) }() + case 885: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatDecodingOptions) }() + case 886: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatEncodingOptions) }() + case 887: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatEncodingVisitor) }() + case 888: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatString) }() + case 889: try { try decoder.decodeSingularInt32Field(value: &_storage._throwOrIgnore) }() + case 890: try { try decoder.decodeSingularInt32Field(value: &_storage._throws) }() + case 891: try { try decoder.decodeSingularInt32Field(value: &_storage._timeInterval) }() + case 892: try { try decoder.decodeSingularInt32Field(value: &_storage._timeIntervalSince1970) }() + case 893: try { try decoder.decodeSingularInt32Field(value: &_storage._timeIntervalSinceReferenceDate) }() + case 894: try { try decoder.decodeSingularInt32Field(value: &_storage._tmp) }() + case 895: try { try decoder.decodeSingularInt32Field(value: &_storage._tooLarge) }() + case 896: try { try decoder.decodeSingularInt32Field(value: &_storage._total) }() + case 897: try { try decoder.decodeSingularInt32Field(value: &_storage._totalArrayDepth) }() + case 898: try { try decoder.decodeSingularInt32Field(value: &_storage._totalSize) }() + case 899: try { try decoder.decodeSingularInt32Field(value: &_storage._trailingComments) }() + case 900: try { try decoder.decodeSingularInt32Field(value: &_storage._traverse) }() + case 901: try { try decoder.decodeSingularInt32Field(value: &_storage._trim) }() + case 902: try { try decoder.decodeSingularInt32Field(value: &_storage._true) }() + case 903: try { try decoder.decodeSingularInt32Field(value: &_storage._try) }() + case 904: try { try decoder.decodeSingularInt32Field(value: &_storage._type) }() + case 905: try { try decoder.decodeSingularInt32Field(value: &_storage._typealias) }() + case 906: try { try decoder.decodeSingularInt32Field(value: &_storage._typeEnum) }() + case 907: try { try decoder.decodeSingularInt32Field(value: &_storage._typeName) }() + case 908: try { try decoder.decodeSingularInt32Field(value: &_storage._typePrefix) }() + case 909: try { try decoder.decodeSingularInt32Field(value: &_storage._typeStart) }() + case 910: try { try decoder.decodeSingularInt32Field(value: &_storage._typeUnknown) }() + case 911: try { try decoder.decodeSingularInt32Field(value: &_storage._typeURL) }() + case 912: try { try decoder.decodeSingularInt32Field(value: &_storage._uint32) }() + case 913: try { try decoder.decodeSingularInt32Field(value: &_storage._uint64) }() + case 914: try { try decoder.decodeSingularInt32Field(value: &_storage._uint8) }() + case 915: try { try decoder.decodeSingularInt32Field(value: &_storage._unchecked) }() + case 916: try { try decoder.decodeSingularInt32Field(value: &_storage._unicode) }() + case 917: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalarLiteral) }() + case 918: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalarLiteralType) }() + case 919: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalars) }() + case 920: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalarView) }() + case 921: try { try decoder.decodeSingularInt32Field(value: &_storage._uninterpretedOption) }() + case 922: try { try decoder.decodeSingularInt32Field(value: &_storage._union) }() + case 923: try { try decoder.decodeSingularInt32Field(value: &_storage._uniqueStorage) }() + case 924: try { try decoder.decodeSingularInt32Field(value: &_storage._unknown) }() + case 925: try { try decoder.decodeSingularInt32Field(value: &_storage._unknownFields_p) }() + case 926: try { try decoder.decodeSingularInt32Field(value: &_storage._unknownStorage) }() + case 927: try { try decoder.decodeSingularInt32Field(value: &_storage._unpackTo) }() + case 928: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeBufferPointer) }() + case 929: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeMutablePointer) }() + case 930: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeMutableRawBufferPointer) }() + case 931: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeRawBufferPointer) }() + case 932: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeRawPointer) }() + case 933: try { try decoder.decodeSingularInt32Field(value: &_storage._unverifiedLazy) }() + case 934: try { try decoder.decodeSingularInt32Field(value: &_storage._updatedOptions) }() + case 935: try { try decoder.decodeSingularInt32Field(value: &_storage._uppercasedAssumingAscii) }() + case 936: try { try decoder.decodeSingularInt32Field(value: &_storage._url) }() + case 937: try { try decoder.decodeSingularInt32Field(value: &_storage._useDeterministicOrdering) }() + case 938: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8) }() + case 939: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8Ptr) }() + case 940: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8ToDouble) }() + case 941: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8Validation) }() + case 942: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8View) }() + case 943: try { try decoder.decodeSingularInt32Field(value: &_storage._v) }() + case 944: try { try decoder.decodeSingularInt32Field(value: &_storage._value) }() + case 945: try { try decoder.decodeSingularInt32Field(value: &_storage._valueField) }() + case 946: try { try decoder.decodeSingularInt32Field(value: &_storage._values) }() + case 947: try { try decoder.decodeSingularInt32Field(value: &_storage._valueType) }() + case 948: try { try decoder.decodeSingularInt32Field(value: &_storage._var) }() + case 949: try { try decoder.decodeSingularInt32Field(value: &_storage._verification) }() + case 950: try { try decoder.decodeSingularInt32Field(value: &_storage._verificationState) }() + case 951: try { try decoder.decodeSingularInt32Field(value: &_storage._version) }() + case 952: try { try decoder.decodeSingularInt32Field(value: &_storage._versionString) }() + case 953: try { try decoder.decodeSingularInt32Field(value: &_storage._visibility) }() + case 954: try { try decoder.decodeSingularInt32Field(value: &_storage._visibilityFeature) }() + case 955: try { try decoder.decodeSingularInt32Field(value: &_storage._visitExtensionFields) }() + case 956: try { try decoder.decodeSingularInt32Field(value: &_storage._visitExtensionFieldsAsMessageSet) }() + case 957: try { try decoder.decodeSingularInt32Field(value: &_storage._visitMapField) }() + case 958: try { try decoder.decodeSingularInt32Field(value: &_storage._visitor) }() + case 959: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPacked) }() + case 960: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedBoolField) }() + case 961: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedDoubleField) }() + case 962: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedEnumField) }() + case 963: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedFixed32Field) }() + case 964: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedFixed64Field) }() + case 965: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedFloatField) }() + case 966: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedInt32Field) }() + case 967: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedInt64Field) }() + case 968: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSfixed32Field) }() + case 969: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSfixed64Field) }() + case 970: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSint32Field) }() + case 971: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSint64Field) }() + case 972: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedUint32Field) }() + case 973: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedUint64Field) }() + case 974: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeated) }() + case 975: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedBoolField) }() + case 976: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedBytesField) }() + case 977: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedDoubleField) }() + case 978: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedEnumField) }() + case 979: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedFixed32Field) }() + case 980: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedFixed64Field) }() + case 981: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedFloatField) }() + case 982: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedGroupField) }() + case 983: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedInt32Field) }() + case 984: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedInt64Field) }() + case 985: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedMessageField) }() + case 986: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSfixed32Field) }() + case 987: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSfixed64Field) }() + case 988: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSint32Field) }() + case 989: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSint64Field) }() + case 990: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedStringField) }() + case 991: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedUint32Field) }() + case 992: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedUint64Field) }() + case 993: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingular) }() + case 994: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularBoolField) }() + case 995: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularBytesField) }() + case 996: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularDoubleField) }() + case 997: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularEnumField) }() + case 998: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularFixed32Field) }() + case 999: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularFixed64Field) }() + case 1000: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularFloatField) }() + case 1001: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularGroupField) }() + case 1002: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularInt32Field) }() + case 1003: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularInt64Field) }() + case 1004: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularMessageField) }() + case 1005: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSfixed32Field) }() + case 1006: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSfixed64Field) }() + case 1007: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSint32Field) }() + case 1008: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSint64Field) }() + case 1009: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularStringField) }() + case 1010: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularUint32Field) }() + case 1011: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularUint64Field) }() + case 1012: try { try decoder.decodeSingularInt32Field(value: &_storage._visitUnknown) }() + case 1013: try { try decoder.decodeSingularInt32Field(value: &_storage._void) }() + case 1014: try { try decoder.decodeSingularInt32Field(value: &_storage._wasDecoded) }() + case 1015: try { try decoder.decodeSingularInt32Field(value: &_storage._weak) }() + case 1016: try { try decoder.decodeSingularInt32Field(value: &_storage._weakDependency) }() + case 1017: try { try decoder.decodeSingularInt32Field(value: &_storage._where) }() + case 1018: try { try decoder.decodeSingularInt32Field(value: &_storage._wireFormat) }() + case 1019: try { try decoder.decodeSingularInt32Field(value: &_storage._with) }() + case 1020: try { try decoder.decodeSingularInt32Field(value: &_storage._withUnsafeBytes) }() + case 1021: try { try decoder.decodeSingularInt32Field(value: &_storage._withUnsafeMutableBytes) }() + case 1022: try { try decoder.decodeSingularInt32Field(value: &_storage._work) }() + case 1023: try { try decoder.decodeSingularInt32Field(value: &_storage._wrapped) }() + case 1024: try { try decoder.decodeSingularInt32Field(value: &_storage._wrappedType) }() + case 1025: try { try decoder.decodeSingularInt32Field(value: &_storage._wrappedValue) }() + case 1026: try { try decoder.decodeSingularInt32Field(value: &_storage._written) }() + case 1027: try { try decoder.decodeSingularInt32Field(value: &_storage._yday) }() default: break } } @@ -7903,2634 +8297,3110 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. func traverse(visitor: inout V) throws { try withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._addPath != 0 { + try visitor.visitSingularInt32Field(value: _storage._addPath, fieldNumber: 1) + } if _storage._adjusted != 0 { - try visitor.visitSingularInt32Field(value: _storage._adjusted, fieldNumber: 1) + try visitor.visitSingularInt32Field(value: _storage._adjusted, fieldNumber: 2) } if _storage._aggregateValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._aggregateValue, fieldNumber: 2) + try visitor.visitSingularInt32Field(value: _storage._aggregateValue, fieldNumber: 3) } if _storage._allCases != 0 { - try visitor.visitSingularInt32Field(value: _storage._allCases, fieldNumber: 3) + try visitor.visitSingularInt32Field(value: _storage._allCases, fieldNumber: 4) } if _storage._allowAlias != 0 { - try visitor.visitSingularInt32Field(value: _storage._allowAlias, fieldNumber: 4) + try visitor.visitSingularInt32Field(value: _storage._allowAlias, fieldNumber: 5) } if _storage._alwaysPrintEnumsAsInts != 0 { - try visitor.visitSingularInt32Field(value: _storage._alwaysPrintEnumsAsInts, fieldNumber: 5) + try visitor.visitSingularInt32Field(value: _storage._alwaysPrintEnumsAsInts, fieldNumber: 6) + } + if _storage._alwaysPrintInt64SAsNumbers != 0 { + try visitor.visitSingularInt32Field(value: _storage._alwaysPrintInt64SAsNumbers, fieldNumber: 7) } if _storage._annotation != 0 { - try visitor.visitSingularInt32Field(value: _storage._annotation, fieldNumber: 6) + try visitor.visitSingularInt32Field(value: _storage._annotation, fieldNumber: 8) } if _storage._any != 0 { - try visitor.visitSingularInt32Field(value: _storage._any, fieldNumber: 7) + try visitor.visitSingularInt32Field(value: _storage._any, fieldNumber: 9) } if _storage._anyExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._anyExtensionField, fieldNumber: 8) + try visitor.visitSingularInt32Field(value: _storage._anyExtensionField, fieldNumber: 10) } if _storage._anyMessageExtension != 0 { - try visitor.visitSingularInt32Field(value: _storage._anyMessageExtension, fieldNumber: 9) + try visitor.visitSingularInt32Field(value: _storage._anyMessageExtension, fieldNumber: 11) } if _storage._anyMessageStorage != 0 { - try visitor.visitSingularInt32Field(value: _storage._anyMessageStorage, fieldNumber: 10) + try visitor.visitSingularInt32Field(value: _storage._anyMessageStorage, fieldNumber: 12) } if _storage._anyUnpackError != 0 { - try visitor.visitSingularInt32Field(value: _storage._anyUnpackError, fieldNumber: 11) + try visitor.visitSingularInt32Field(value: _storage._anyUnpackError, fieldNumber: 13) } - if _storage._api != 0 { - try visitor.visitSingularInt32Field(value: _storage._api, fieldNumber: 12) + if _storage._append != 0 { + try visitor.visitSingularInt32Field(value: _storage._append, fieldNumber: 14) } if _storage._appended != 0 { - try visitor.visitSingularInt32Field(value: _storage._appended, fieldNumber: 13) + try visitor.visitSingularInt32Field(value: _storage._appended, fieldNumber: 15) } if _storage._appendUintHex != 0 { - try visitor.visitSingularInt32Field(value: _storage._appendUintHex, fieldNumber: 14) + try visitor.visitSingularInt32Field(value: _storage._appendUintHex, fieldNumber: 16) } if _storage._appendUnknown != 0 { - try visitor.visitSingularInt32Field(value: _storage._appendUnknown, fieldNumber: 15) + try visitor.visitSingularInt32Field(value: _storage._appendUnknown, fieldNumber: 17) } if _storage._areAllInitialized != 0 { - try visitor.visitSingularInt32Field(value: _storage._areAllInitialized, fieldNumber: 16) + try visitor.visitSingularInt32Field(value: _storage._areAllInitialized, fieldNumber: 18) } if _storage._array != 0 { - try visitor.visitSingularInt32Field(value: _storage._array, fieldNumber: 17) + try visitor.visitSingularInt32Field(value: _storage._array, fieldNumber: 19) } if _storage._arrayDepth != 0 { - try visitor.visitSingularInt32Field(value: _storage._arrayDepth, fieldNumber: 18) + try visitor.visitSingularInt32Field(value: _storage._arrayDepth, fieldNumber: 20) } if _storage._arrayLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._arrayLiteral, fieldNumber: 19) + try visitor.visitSingularInt32Field(value: _storage._arrayLiteral, fieldNumber: 21) } if _storage._arraySeparator != 0 { - try visitor.visitSingularInt32Field(value: _storage._arraySeparator, fieldNumber: 20) + try visitor.visitSingularInt32Field(value: _storage._arraySeparator, fieldNumber: 22) } if _storage._as != 0 { - try visitor.visitSingularInt32Field(value: _storage._as, fieldNumber: 21) + try visitor.visitSingularInt32Field(value: _storage._as, fieldNumber: 23) } if _storage._asciiOpenCurlyBracket != 0 { - try visitor.visitSingularInt32Field(value: _storage._asciiOpenCurlyBracket, fieldNumber: 22) + try visitor.visitSingularInt32Field(value: _storage._asciiOpenCurlyBracket, fieldNumber: 24) } if _storage._asciiZero != 0 { - try visitor.visitSingularInt32Field(value: _storage._asciiZero, fieldNumber: 23) + try visitor.visitSingularInt32Field(value: _storage._asciiZero, fieldNumber: 25) + } + if _storage._async != 0 { + try visitor.visitSingularInt32Field(value: _storage._async, fieldNumber: 26) + } + if _storage._asyncIterator != 0 { + try visitor.visitSingularInt32Field(value: _storage._asyncIterator, fieldNumber: 27) + } + if _storage._asyncIteratorProtocol != 0 { + try visitor.visitSingularInt32Field(value: _storage._asyncIteratorProtocol, fieldNumber: 28) + } + if _storage._asyncMessageSequence != 0 { + try visitor.visitSingularInt32Field(value: _storage._asyncMessageSequence, fieldNumber: 29) } if _storage._available != 0 { - try visitor.visitSingularInt32Field(value: _storage._available, fieldNumber: 24) + try visitor.visitSingularInt32Field(value: _storage._available, fieldNumber: 30) } if _storage._b != 0 { - try visitor.visitSingularInt32Field(value: _storage._b, fieldNumber: 25) + try visitor.visitSingularInt32Field(value: _storage._b, fieldNumber: 31) + } + if _storage._base != 0 { + try visitor.visitSingularInt32Field(value: _storage._base, fieldNumber: 32) } if _storage._base64Values != 0 { - try visitor.visitSingularInt32Field(value: _storage._base64Values, fieldNumber: 26) + try visitor.visitSingularInt32Field(value: _storage._base64Values, fieldNumber: 33) } if _storage._baseAddress != 0 { - try visitor.visitSingularInt32Field(value: _storage._baseAddress, fieldNumber: 27) + try visitor.visitSingularInt32Field(value: _storage._baseAddress, fieldNumber: 34) } if _storage._baseType != 0 { - try visitor.visitSingularInt32Field(value: _storage._baseType, fieldNumber: 28) + try visitor.visitSingularInt32Field(value: _storage._baseType, fieldNumber: 35) } if _storage._begin != 0 { - try visitor.visitSingularInt32Field(value: _storage._begin, fieldNumber: 29) + try visitor.visitSingularInt32Field(value: _storage._begin, fieldNumber: 36) } if _storage._binary != 0 { - try visitor.visitSingularInt32Field(value: _storage._binary, fieldNumber: 30) + try visitor.visitSingularInt32Field(value: _storage._binary, fieldNumber: 37) } if _storage._binaryDecoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryDecoder, fieldNumber: 31) + try visitor.visitSingularInt32Field(value: _storage._binaryDecoder, fieldNumber: 38) + } + if _storage._binaryDecoding != 0 { + try visitor.visitSingularInt32Field(value: _storage._binaryDecoding, fieldNumber: 39) } if _storage._binaryDecodingError != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryDecodingError, fieldNumber: 32) + try visitor.visitSingularInt32Field(value: _storage._binaryDecodingError, fieldNumber: 40) } if _storage._binaryDecodingOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryDecodingOptions, fieldNumber: 33) + try visitor.visitSingularInt32Field(value: _storage._binaryDecodingOptions, fieldNumber: 41) } if _storage._binaryDelimited != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryDelimited, fieldNumber: 34) + try visitor.visitSingularInt32Field(value: _storage._binaryDelimited, fieldNumber: 42) } if _storage._binaryEncoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryEncoder, fieldNumber: 35) + try visitor.visitSingularInt32Field(value: _storage._binaryEncoder, fieldNumber: 43) } if _storage._binaryEncodingError != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryEncodingError, fieldNumber: 36) + try visitor.visitSingularInt32Field(value: _storage._binaryEncodingError, fieldNumber: 44) } if _storage._binaryEncodingMessageSetSizeVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryEncodingMessageSetSizeVisitor, fieldNumber: 37) + try visitor.visitSingularInt32Field(value: _storage._binaryEncodingMessageSetSizeVisitor, fieldNumber: 45) } if _storage._binaryEncodingMessageSetVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryEncodingMessageSetVisitor, fieldNumber: 38) + try visitor.visitSingularInt32Field(value: _storage._binaryEncodingMessageSetVisitor, fieldNumber: 46) + } + if _storage._binaryEncodingOptions != 0 { + try visitor.visitSingularInt32Field(value: _storage._binaryEncodingOptions, fieldNumber: 47) } if _storage._binaryEncodingSizeVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryEncodingSizeVisitor, fieldNumber: 39) + try visitor.visitSingularInt32Field(value: _storage._binaryEncodingSizeVisitor, fieldNumber: 48) } if _storage._binaryEncodingVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryEncodingVisitor, fieldNumber: 40) + try visitor.visitSingularInt32Field(value: _storage._binaryEncodingVisitor, fieldNumber: 49) } if _storage._binaryOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryOptions, fieldNumber: 41) + try visitor.visitSingularInt32Field(value: _storage._binaryOptions, fieldNumber: 50) + } + if _storage._binaryProtobufDelimitedMessages != 0 { + try visitor.visitSingularInt32Field(value: _storage._binaryProtobufDelimitedMessages, fieldNumber: 51) + } + if _storage._binaryStreamDecoding != 0 { + try visitor.visitSingularInt32Field(value: _storage._binaryStreamDecoding, fieldNumber: 52) + } + if _storage._binaryStreamDecodingError != 0 { + try visitor.visitSingularInt32Field(value: _storage._binaryStreamDecodingError, fieldNumber: 53) + } + if _storage._bitPattern != 0 { + try visitor.visitSingularInt32Field(value: _storage._bitPattern, fieldNumber: 54) } if _storage._body != 0 { - try visitor.visitSingularInt32Field(value: _storage._body, fieldNumber: 42) + try visitor.visitSingularInt32Field(value: _storage._body, fieldNumber: 55) } if _storage._bool != 0 { - try visitor.visitSingularInt32Field(value: _storage._bool, fieldNumber: 43) + try visitor.visitSingularInt32Field(value: _storage._bool, fieldNumber: 56) } if _storage._booleanLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._booleanLiteral, fieldNumber: 44) + try visitor.visitSingularInt32Field(value: _storage._booleanLiteral, fieldNumber: 57) } if _storage._booleanLiteralType != 0 { - try visitor.visitSingularInt32Field(value: _storage._booleanLiteralType, fieldNumber: 45) + try visitor.visitSingularInt32Field(value: _storage._booleanLiteralType, fieldNumber: 58) } if _storage._boolValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._boolValue, fieldNumber: 46) + try visitor.visitSingularInt32Field(value: _storage._boolValue, fieldNumber: 59) + } + if _storage._buffer != 0 { + try visitor.visitSingularInt32Field(value: _storage._buffer, fieldNumber: 60) + } + if _storage._byte != 0 { + try visitor.visitSingularInt32Field(value: _storage._byte, fieldNumber: 61) + } + if _storage._bytecode != 0 { + try visitor.visitSingularInt32Field(value: _storage._bytecode, fieldNumber: 62) + } + if _storage._bytecodeReader != 0 { + try visitor.visitSingularInt32Field(value: _storage._bytecodeReader, fieldNumber: 63) } if _storage._bytes != 0 { - try visitor.visitSingularInt32Field(value: _storage._bytes, fieldNumber: 47) + try visitor.visitSingularInt32Field(value: _storage._bytes, fieldNumber: 64) } if _storage._bytesInGroup != 0 { - try visitor.visitSingularInt32Field(value: _storage._bytesInGroup, fieldNumber: 48) + try visitor.visitSingularInt32Field(value: _storage._bytesInGroup, fieldNumber: 65) } - if _storage._bytesRead != 0 { - try visitor.visitSingularInt32Field(value: _storage._bytesRead, fieldNumber: 49) + if _storage._bytesNeeded != 0 { + try visitor.visitSingularInt32Field(value: _storage._bytesNeeded, fieldNumber: 66) } - if _storage._bytesValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._bytesValue, fieldNumber: 50) + if _storage._bytesRead != 0 { + try visitor.visitSingularInt32Field(value: _storage._bytesRead, fieldNumber: 67) } if _storage._c != 0 { - try visitor.visitSingularInt32Field(value: _storage._c, fieldNumber: 51) + try visitor.visitSingularInt32Field(value: _storage._c, fieldNumber: 68) + } + if _storage._canonical != 0 { + try visitor.visitSingularInt32Field(value: _storage._canonical, fieldNumber: 69) } if _storage._capitalizeNext != 0 { - try visitor.visitSingularInt32Field(value: _storage._capitalizeNext, fieldNumber: 52) + try visitor.visitSingularInt32Field(value: _storage._capitalizeNext, fieldNumber: 70) } if _storage._cardinality != 0 { - try visitor.visitSingularInt32Field(value: _storage._cardinality, fieldNumber: 53) + try visitor.visitSingularInt32Field(value: _storage._cardinality, fieldNumber: 71) + } + if _storage._caseIterable != 0 { + try visitor.visitSingularInt32Field(value: _storage._caseIterable, fieldNumber: 72) + } + if _storage._castedValue != 0 { + try visitor.visitSingularInt32Field(value: _storage._castedValue, fieldNumber: 73) } if _storage._ccEnableArenas != 0 { - try visitor.visitSingularInt32Field(value: _storage._ccEnableArenas, fieldNumber: 54) + try visitor.visitSingularInt32Field(value: _storage._ccEnableArenas, fieldNumber: 74) } if _storage._ccGenericServices != 0 { - try visitor.visitSingularInt32Field(value: _storage._ccGenericServices, fieldNumber: 55) + try visitor.visitSingularInt32Field(value: _storage._ccGenericServices, fieldNumber: 75) } if _storage._character != 0 { - try visitor.visitSingularInt32Field(value: _storage._character, fieldNumber: 56) + try visitor.visitSingularInt32Field(value: _storage._character, fieldNumber: 76) } if _storage._chars != 0 { - try visitor.visitSingularInt32Field(value: _storage._chars, fieldNumber: 57) + try visitor.visitSingularInt32Field(value: _storage._chars, fieldNumber: 77) + } + if _storage._checkProgramFormat != 0 { + try visitor.visitSingularInt32Field(value: _storage._checkProgramFormat, fieldNumber: 78) + } + if _storage._chunk != 0 { + try visitor.visitSingularInt32Field(value: _storage._chunk, fieldNumber: 79) } if _storage._class != 0 { - try visitor.visitSingularInt32Field(value: _storage._class, fieldNumber: 58) + try visitor.visitSingularInt32Field(value: _storage._class, fieldNumber: 80) } if _storage._clearAggregateValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearAggregateValue_p, fieldNumber: 59) + try visitor.visitSingularInt32Field(value: _storage._clearAggregateValue_p, fieldNumber: 81) } if _storage._clearAllowAlias_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearAllowAlias_p, fieldNumber: 60) + try visitor.visitSingularInt32Field(value: _storage._clearAllowAlias_p, fieldNumber: 82) } if _storage._clearBegin_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearBegin_p, fieldNumber: 61) + try visitor.visitSingularInt32Field(value: _storage._clearBegin_p, fieldNumber: 83) } if _storage._clearCcEnableArenas_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearCcEnableArenas_p, fieldNumber: 62) + try visitor.visitSingularInt32Field(value: _storage._clearCcEnableArenas_p, fieldNumber: 84) } if _storage._clearCcGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearCcGenericServices_p, fieldNumber: 63) + try visitor.visitSingularInt32Field(value: _storage._clearCcGenericServices_p, fieldNumber: 85) } if _storage._clearClientStreaming_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearClientStreaming_p, fieldNumber: 64) + try visitor.visitSingularInt32Field(value: _storage._clearClientStreaming_p, fieldNumber: 86) } if _storage._clearCsharpNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearCsharpNamespace_p, fieldNumber: 65) + try visitor.visitSingularInt32Field(value: _storage._clearCsharpNamespace_p, fieldNumber: 87) } if _storage._clearCtype_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearCtype_p, fieldNumber: 66) + try visitor.visitSingularInt32Field(value: _storage._clearCtype_p, fieldNumber: 88) + } + if _storage._clearDebugRedact_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearDebugRedact_p, fieldNumber: 89) + } + if _storage._clearDefaultSymbolVisibility_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearDefaultSymbolVisibility_p, fieldNumber: 90) } if _storage._clearDefaultValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearDefaultValue_p, fieldNumber: 67) + try visitor.visitSingularInt32Field(value: _storage._clearDefaultValue_p, fieldNumber: 91) } if _storage._clearDeprecated_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearDeprecated_p, fieldNumber: 68) + try visitor.visitSingularInt32Field(value: _storage._clearDeprecated_p, fieldNumber: 92) + } + if _storage._clearDeprecatedLegacyJsonFieldConflicts_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearDeprecatedLegacyJsonFieldConflicts_p, fieldNumber: 93) + } + if _storage._clearDeprecationWarning_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearDeprecationWarning_p, fieldNumber: 94) } if _storage._clearDoubleValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearDoubleValue_p, fieldNumber: 69) + try visitor.visitSingularInt32Field(value: _storage._clearDoubleValue_p, fieldNumber: 95) + } + if _storage._clearEdition_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearEdition_p, fieldNumber: 96) + } + if _storage._clearEditionDeprecated_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearEditionDeprecated_p, fieldNumber: 97) + } + if _storage._clearEditionIntroduced_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearEditionIntroduced_p, fieldNumber: 98) + } + if _storage._clearEditionRemoved_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearEditionRemoved_p, fieldNumber: 99) + } + if _storage._clearEnd_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearEnd_p, fieldNumber: 100) + } + if _storage._clearEnforceNamingStyle_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearEnforceNamingStyle_p, fieldNumber: 101) + } + if _storage._clearEnumType_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearEnumType_p, fieldNumber: 102) + } + if _storage._clearExtendee_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearExtendee_p, fieldNumber: 103) + } + if _storage._clearExtensionValue_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearExtensionValue_p, fieldNumber: 104) + } + if _storage._clearFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearFeatures_p, fieldNumber: 105) + } + if _storage._clearFeatureSupport_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearFeatureSupport_p, fieldNumber: 106) } - if _storage._clearEnd_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearEnd_p, fieldNumber: 70) + if _storage._clearFieldPresence_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearFieldPresence_p, fieldNumber: 107) } - if _storage._clearExtendee_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearExtendee_p, fieldNumber: 71) + if _storage._clearFixedFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearFixedFeatures_p, fieldNumber: 108) } - if _storage._clearExtensionValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearExtensionValue_p, fieldNumber: 72) + if _storage._clearFullName_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearFullName_p, fieldNumber: 109) } if _storage._clearGoPackage_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearGoPackage_p, fieldNumber: 73) + try visitor.visitSingularInt32Field(value: _storage._clearGoPackage_p, fieldNumber: 110) } if _storage._clearIdempotencyLevel_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearIdempotencyLevel_p, fieldNumber: 74) + try visitor.visitSingularInt32Field(value: _storage._clearIdempotencyLevel_p, fieldNumber: 111) } if _storage._clearIdentifierValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearIdentifierValue_p, fieldNumber: 75) + try visitor.visitSingularInt32Field(value: _storage._clearIdentifierValue_p, fieldNumber: 112) } if _storage._clearInputType_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearInputType_p, fieldNumber: 76) + try visitor.visitSingularInt32Field(value: _storage._clearInputType_p, fieldNumber: 113) } if _storage._clearIsExtension_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearIsExtension_p, fieldNumber: 77) + try visitor.visitSingularInt32Field(value: _storage._clearIsExtension_p, fieldNumber: 114) } if _storage._clearJavaGenerateEqualsAndHash_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearJavaGenerateEqualsAndHash_p, fieldNumber: 78) + try visitor.visitSingularInt32Field(value: _storage._clearJavaGenerateEqualsAndHash_p, fieldNumber: 115) } if _storage._clearJavaGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearJavaGenericServices_p, fieldNumber: 79) + try visitor.visitSingularInt32Field(value: _storage._clearJavaGenericServices_p, fieldNumber: 116) } if _storage._clearJavaMultipleFiles_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearJavaMultipleFiles_p, fieldNumber: 80) + try visitor.visitSingularInt32Field(value: _storage._clearJavaMultipleFiles_p, fieldNumber: 117) } if _storage._clearJavaOuterClassname_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearJavaOuterClassname_p, fieldNumber: 81) + try visitor.visitSingularInt32Field(value: _storage._clearJavaOuterClassname_p, fieldNumber: 118) } if _storage._clearJavaPackage_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearJavaPackage_p, fieldNumber: 82) + try visitor.visitSingularInt32Field(value: _storage._clearJavaPackage_p, fieldNumber: 119) } if _storage._clearJavaStringCheckUtf8_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearJavaStringCheckUtf8_p, fieldNumber: 83) + try visitor.visitSingularInt32Field(value: _storage._clearJavaStringCheckUtf8_p, fieldNumber: 120) + } + if _storage._clearJsonFormat_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearJsonFormat_p, fieldNumber: 121) } if _storage._clearJsonName_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearJsonName_p, fieldNumber: 84) + try visitor.visitSingularInt32Field(value: _storage._clearJsonName_p, fieldNumber: 122) } if _storage._clearJstype_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearJstype_p, fieldNumber: 85) + try visitor.visitSingularInt32Field(value: _storage._clearJstype_p, fieldNumber: 123) } if _storage._clearLabel_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearLabel_p, fieldNumber: 86) + try visitor.visitSingularInt32Field(value: _storage._clearLabel_p, fieldNumber: 124) } if _storage._clearLazy_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearLazy_p, fieldNumber: 87) + try visitor.visitSingularInt32Field(value: _storage._clearLazy_p, fieldNumber: 125) } if _storage._clearLeadingComments_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearLeadingComments_p, fieldNumber: 88) + try visitor.visitSingularInt32Field(value: _storage._clearLeadingComments_p, fieldNumber: 126) } if _storage._clearMapEntry_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearMapEntry_p, fieldNumber: 89) + try visitor.visitSingularInt32Field(value: _storage._clearMapEntry_p, fieldNumber: 127) + } + if _storage._clearMaximumEdition_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearMaximumEdition_p, fieldNumber: 128) + } + if _storage._clearMessageEncoding_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearMessageEncoding_p, fieldNumber: 129) } if _storage._clearMessageSetWireFormat_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearMessageSetWireFormat_p, fieldNumber: 90) + try visitor.visitSingularInt32Field(value: _storage._clearMessageSetWireFormat_p, fieldNumber: 130) + } + if _storage._clearMinimumEdition_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearMinimumEdition_p, fieldNumber: 131) } if _storage._clearName_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearName_p, fieldNumber: 91) + try visitor.visitSingularInt32Field(value: _storage._clearName_p, fieldNumber: 132) } if _storage._clearNamePart_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearNamePart_p, fieldNumber: 92) + try visitor.visitSingularInt32Field(value: _storage._clearNamePart_p, fieldNumber: 133) } if _storage._clearNegativeIntValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearNegativeIntValue_p, fieldNumber: 93) + try visitor.visitSingularInt32Field(value: _storage._clearNegativeIntValue_p, fieldNumber: 134) } if _storage._clearNoStandardDescriptorAccessor_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearNoStandardDescriptorAccessor_p, fieldNumber: 94) + try visitor.visitSingularInt32Field(value: _storage._clearNoStandardDescriptorAccessor_p, fieldNumber: 135) } if _storage._clearNumber_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearNumber_p, fieldNumber: 95) + try visitor.visitSingularInt32Field(value: _storage._clearNumber_p, fieldNumber: 136) } if _storage._clearObjcClassPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearObjcClassPrefix_p, fieldNumber: 96) + try visitor.visitSingularInt32Field(value: _storage._clearObjcClassPrefix_p, fieldNumber: 137) } if _storage._clearOneofIndex_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearOneofIndex_p, fieldNumber: 97) + try visitor.visitSingularInt32Field(value: _storage._clearOneofIndex_p, fieldNumber: 138) } if _storage._clearOptimizeFor_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearOptimizeFor_p, fieldNumber: 98) + try visitor.visitSingularInt32Field(value: _storage._clearOptimizeFor_p, fieldNumber: 139) } if _storage._clearOptions_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearOptions_p, fieldNumber: 99) + try visitor.visitSingularInt32Field(value: _storage._clearOptions_p, fieldNumber: 140) } if _storage._clearOutputType_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearOutputType_p, fieldNumber: 100) + try visitor.visitSingularInt32Field(value: _storage._clearOutputType_p, fieldNumber: 141) + } + if _storage._clearOverridableFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearOverridableFeatures_p, fieldNumber: 142) } if _storage._clearPackage_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearPackage_p, fieldNumber: 101) + try visitor.visitSingularInt32Field(value: _storage._clearPackage_p, fieldNumber: 143) } if _storage._clearPacked_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearPacked_p, fieldNumber: 102) + try visitor.visitSingularInt32Field(value: _storage._clearPacked_p, fieldNumber: 144) } if _storage._clearPhpClassPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearPhpClassPrefix_p, fieldNumber: 103) - } - if _storage._clearPhpGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearPhpGenericServices_p, fieldNumber: 104) + try visitor.visitSingularInt32Field(value: _storage._clearPhpClassPrefix_p, fieldNumber: 145) } if _storage._clearPhpMetadataNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearPhpMetadataNamespace_p, fieldNumber: 105) + try visitor.visitSingularInt32Field(value: _storage._clearPhpMetadataNamespace_p, fieldNumber: 146) } if _storage._clearPhpNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearPhpNamespace_p, fieldNumber: 106) + try visitor.visitSingularInt32Field(value: _storage._clearPhpNamespace_p, fieldNumber: 147) } if _storage._clearPositiveIntValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearPositiveIntValue_p, fieldNumber: 107) + try visitor.visitSingularInt32Field(value: _storage._clearPositiveIntValue_p, fieldNumber: 148) } if _storage._clearProto3Optional_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearProto3Optional_p, fieldNumber: 108) + try visitor.visitSingularInt32Field(value: _storage._clearProto3Optional_p, fieldNumber: 149) } if _storage._clearPyGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearPyGenericServices_p, fieldNumber: 109) + try visitor.visitSingularInt32Field(value: _storage._clearPyGenericServices_p, fieldNumber: 150) + } + if _storage._clearRemovalError_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearRemovalError_p, fieldNumber: 151) + } + if _storage._clearRepeated_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearRepeated_p, fieldNumber: 152) + } + if _storage._clearRepeatedFieldEncoding_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearRepeatedFieldEncoding_p, fieldNumber: 153) + } + if _storage._clearReserved_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearReserved_p, fieldNumber: 154) + } + if _storage._clearRetention_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearRetention_p, fieldNumber: 155) } if _storage._clearRubyPackage_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearRubyPackage_p, fieldNumber: 110) + try visitor.visitSingularInt32Field(value: _storage._clearRubyPackage_p, fieldNumber: 156) + } + if _storage._clearSemantic_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearSemantic_p, fieldNumber: 157) } if _storage._clearServerStreaming_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearServerStreaming_p, fieldNumber: 111) + try visitor.visitSingularInt32Field(value: _storage._clearServerStreaming_p, fieldNumber: 158) } if _storage._clearSourceCodeInfo_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearSourceCodeInfo_p, fieldNumber: 112) + try visitor.visitSingularInt32Field(value: _storage._clearSourceCodeInfo_p, fieldNumber: 159) } if _storage._clearSourceContext_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearSourceContext_p, fieldNumber: 113) + try visitor.visitSingularInt32Field(value: _storage._clearSourceContext_p, fieldNumber: 160) } if _storage._clearSourceFile_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearSourceFile_p, fieldNumber: 114) + try visitor.visitSingularInt32Field(value: _storage._clearSourceFile_p, fieldNumber: 161) } if _storage._clearStart_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearStart_p, fieldNumber: 115) + try visitor.visitSingularInt32Field(value: _storage._clearStart_p, fieldNumber: 162) } if _storage._clearStringValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearStringValue_p, fieldNumber: 116) + try visitor.visitSingularInt32Field(value: _storage._clearStringValue_p, fieldNumber: 163) } if _storage._clearSwiftPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearSwiftPrefix_p, fieldNumber: 117) + try visitor.visitSingularInt32Field(value: _storage._clearSwiftPrefix_p, fieldNumber: 164) } if _storage._clearSyntax_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearSyntax_p, fieldNumber: 118) + try visitor.visitSingularInt32Field(value: _storage._clearSyntax_p, fieldNumber: 165) } if _storage._clearTrailingComments_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearTrailingComments_p, fieldNumber: 119) + try visitor.visitSingularInt32Field(value: _storage._clearTrailingComments_p, fieldNumber: 166) } if _storage._clearType_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearType_p, fieldNumber: 120) + try visitor.visitSingularInt32Field(value: _storage._clearType_p, fieldNumber: 167) } if _storage._clearTypeName_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearTypeName_p, fieldNumber: 121) + try visitor.visitSingularInt32Field(value: _storage._clearTypeName_p, fieldNumber: 168) + } + if _storage._clearUnverifiedLazy_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearUnverifiedLazy_p, fieldNumber: 169) + } + if _storage._clearUtf8Validation_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearUtf8Validation_p, fieldNumber: 170) } if _storage._clearValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearValue_p, fieldNumber: 122) + try visitor.visitSingularInt32Field(value: _storage._clearValue_p, fieldNumber: 171) + } + if _storage._clearVerification_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearVerification_p, fieldNumber: 172) + } + if _storage._clearVisibility_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearVisibility_p, fieldNumber: 173) } if _storage._clearWeak_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearWeak_p, fieldNumber: 123) + try visitor.visitSingularInt32Field(value: _storage._clearWeak_p, fieldNumber: 174) } if _storage._clientStreaming != 0 { - try visitor.visitSingularInt32Field(value: _storage._clientStreaming, fieldNumber: 124) + try visitor.visitSingularInt32Field(value: _storage._clientStreaming, fieldNumber: 175) + } + if _storage._code != 0 { + try visitor.visitSingularInt32Field(value: _storage._code, fieldNumber: 176) } if _storage._codePoint != 0 { - try visitor.visitSingularInt32Field(value: _storage._codePoint, fieldNumber: 125) + try visitor.visitSingularInt32Field(value: _storage._codePoint, fieldNumber: 177) } if _storage._codeUnits != 0 { - try visitor.visitSingularInt32Field(value: _storage._codeUnits, fieldNumber: 126) + try visitor.visitSingularInt32Field(value: _storage._codeUnits, fieldNumber: 178) } if _storage._collection != 0 { - try visitor.visitSingularInt32Field(value: _storage._collection, fieldNumber: 127) - } - if _storage._com != 0 { - try visitor.visitSingularInt32Field(value: _storage._com, fieldNumber: 128) + try visitor.visitSingularInt32Field(value: _storage._collection, fieldNumber: 179) } if _storage._comma != 0 { - try visitor.visitSingularInt32Field(value: _storage._comma, fieldNumber: 129) + try visitor.visitSingularInt32Field(value: _storage._comma, fieldNumber: 180) + } + if _storage._consumedBytes != 0 { + try visitor.visitSingularInt32Field(value: _storage._consumedBytes, fieldNumber: 181) + } + if _storage._contains != 0 { + try visitor.visitSingularInt32Field(value: _storage._contains, fieldNumber: 182) } if _storage._contentsOf != 0 { - try visitor.visitSingularInt32Field(value: _storage._contentsOf, fieldNumber: 130) + try visitor.visitSingularInt32Field(value: _storage._contentsOf, fieldNumber: 183) } if _storage._contiguousBytes != 0 { - try visitor.visitSingularInt32Field(value: _storage._contiguousBytes, fieldNumber: 131) + try visitor.visitSingularInt32Field(value: _storage._contiguousBytes, fieldNumber: 184) + } + if _storage._copy != 0 { + try visitor.visitSingularInt32Field(value: _storage._copy, fieldNumber: 185) } if _storage._count != 0 { - try visitor.visitSingularInt32Field(value: _storage._count, fieldNumber: 132) + try visitor.visitSingularInt32Field(value: _storage._count, fieldNumber: 186) } if _storage._countVarintsInBuffer != 0 { - try visitor.visitSingularInt32Field(value: _storage._countVarintsInBuffer, fieldNumber: 133) + try visitor.visitSingularInt32Field(value: _storage._countVarintsInBuffer, fieldNumber: 187) } if _storage._csharpNamespace != 0 { - try visitor.visitSingularInt32Field(value: _storage._csharpNamespace, fieldNumber: 134) + try visitor.visitSingularInt32Field(value: _storage._csharpNamespace, fieldNumber: 188) } if _storage._ctype != 0 { - try visitor.visitSingularInt32Field(value: _storage._ctype, fieldNumber: 135) + try visitor.visitSingularInt32Field(value: _storage._ctype, fieldNumber: 189) } if _storage._customCodable != 0 { - try visitor.visitSingularInt32Field(value: _storage._customCodable, fieldNumber: 136) + try visitor.visitSingularInt32Field(value: _storage._customCodable, fieldNumber: 190) } if _storage._customDebugStringConvertible != 0 { - try visitor.visitSingularInt32Field(value: _storage._customDebugStringConvertible, fieldNumber: 137) + try visitor.visitSingularInt32Field(value: _storage._customDebugStringConvertible, fieldNumber: 191) + } + if _storage._customStringConvertible != 0 { + try visitor.visitSingularInt32Field(value: _storage._customStringConvertible, fieldNumber: 192) } if _storage._d != 0 { - try visitor.visitSingularInt32Field(value: _storage._d, fieldNumber: 138) + try visitor.visitSingularInt32Field(value: _storage._d, fieldNumber: 193) } if _storage._data != 0 { - try visitor.visitSingularInt32Field(value: _storage._data, fieldNumber: 139) + try visitor.visitSingularInt32Field(value: _storage._data, fieldNumber: 194) } if _storage._dataResult != 0 { - try visitor.visitSingularInt32Field(value: _storage._dataResult, fieldNumber: 140) + try visitor.visitSingularInt32Field(value: _storage._dataResult, fieldNumber: 195) } if _storage._date != 0 { - try visitor.visitSingularInt32Field(value: _storage._date, fieldNumber: 141) + try visitor.visitSingularInt32Field(value: _storage._date, fieldNumber: 196) } if _storage._daySec != 0 { - try visitor.visitSingularInt32Field(value: _storage._daySec, fieldNumber: 142) + try visitor.visitSingularInt32Field(value: _storage._daySec, fieldNumber: 197) } if _storage._daysSinceEpoch != 0 { - try visitor.visitSingularInt32Field(value: _storage._daysSinceEpoch, fieldNumber: 143) + try visitor.visitSingularInt32Field(value: _storage._daysSinceEpoch, fieldNumber: 198) } if _storage._debugDescription_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._debugDescription_p, fieldNumber: 144) + try visitor.visitSingularInt32Field(value: _storage._debugDescription_p, fieldNumber: 199) + } + if _storage._debugRedact != 0 { + try visitor.visitSingularInt32Field(value: _storage._debugRedact, fieldNumber: 200) + } + if _storage._declaration != 0 { + try visitor.visitSingularInt32Field(value: _storage._declaration, fieldNumber: 201) } if _storage._decoded != 0 { - try visitor.visitSingularInt32Field(value: _storage._decoded, fieldNumber: 145) + try visitor.visitSingularInt32Field(value: _storage._decoded, fieldNumber: 202) } if _storage._decodedFromJsonnull != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodedFromJsonnull, fieldNumber: 146) + try visitor.visitSingularInt32Field(value: _storage._decodedFromJsonnull, fieldNumber: 203) } if _storage._decodeExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeExtensionField, fieldNumber: 147) + try visitor.visitSingularInt32Field(value: _storage._decodeExtensionField, fieldNumber: 204) } if _storage._decodeExtensionFieldsAsMessageSet != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeExtensionFieldsAsMessageSet, fieldNumber: 148) + try visitor.visitSingularInt32Field(value: _storage._decodeExtensionFieldsAsMessageSet, fieldNumber: 205) } if _storage._decodeJson != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeJson, fieldNumber: 149) + try visitor.visitSingularInt32Field(value: _storage._decodeJson, fieldNumber: 206) } if _storage._decodeMapField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeMapField, fieldNumber: 150) + try visitor.visitSingularInt32Field(value: _storage._decodeMapField, fieldNumber: 207) } if _storage._decodeMessage != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeMessage, fieldNumber: 151) + try visitor.visitSingularInt32Field(value: _storage._decodeMessage, fieldNumber: 208) } if _storage._decoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._decoder, fieldNumber: 152) + try visitor.visitSingularInt32Field(value: _storage._decoder, fieldNumber: 209) } if _storage._decodeRepeated != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeated, fieldNumber: 153) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeated, fieldNumber: 210) } if _storage._decodeRepeatedBoolField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedBoolField, fieldNumber: 154) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedBoolField, fieldNumber: 211) } if _storage._decodeRepeatedBytesField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedBytesField, fieldNumber: 155) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedBytesField, fieldNumber: 212) } if _storage._decodeRepeatedDoubleField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedDoubleField, fieldNumber: 156) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedDoubleField, fieldNumber: 213) } if _storage._decodeRepeatedEnumField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedEnumField, fieldNumber: 157) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedEnumField, fieldNumber: 214) } if _storage._decodeRepeatedFixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedFixed32Field, fieldNumber: 158) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedFixed32Field, fieldNumber: 215) } if _storage._decodeRepeatedFixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedFixed64Field, fieldNumber: 159) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedFixed64Field, fieldNumber: 216) } if _storage._decodeRepeatedFloatField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedFloatField, fieldNumber: 160) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedFloatField, fieldNumber: 217) } if _storage._decodeRepeatedGroupField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedGroupField, fieldNumber: 161) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedGroupField, fieldNumber: 218) } if _storage._decodeRepeatedInt32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedInt32Field, fieldNumber: 162) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedInt32Field, fieldNumber: 219) } if _storage._decodeRepeatedInt64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedInt64Field, fieldNumber: 163) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedInt64Field, fieldNumber: 220) } if _storage._decodeRepeatedMessageField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedMessageField, fieldNumber: 164) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedMessageField, fieldNumber: 221) } if _storage._decodeRepeatedSfixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSfixed32Field, fieldNumber: 165) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSfixed32Field, fieldNumber: 222) } if _storage._decodeRepeatedSfixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSfixed64Field, fieldNumber: 166) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSfixed64Field, fieldNumber: 223) } if _storage._decodeRepeatedSint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSint32Field, fieldNumber: 167) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSint32Field, fieldNumber: 224) } if _storage._decodeRepeatedSint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSint64Field, fieldNumber: 168) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSint64Field, fieldNumber: 225) } if _storage._decodeRepeatedStringField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedStringField, fieldNumber: 169) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedStringField, fieldNumber: 226) } if _storage._decodeRepeatedUint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedUint32Field, fieldNumber: 170) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedUint32Field, fieldNumber: 227) } if _storage._decodeRepeatedUint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedUint64Field, fieldNumber: 171) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedUint64Field, fieldNumber: 228) } if _storage._decodeSingular != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingular, fieldNumber: 172) + try visitor.visitSingularInt32Field(value: _storage._decodeSingular, fieldNumber: 229) } if _storage._decodeSingularBoolField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularBoolField, fieldNumber: 173) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularBoolField, fieldNumber: 230) } if _storage._decodeSingularBytesField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularBytesField, fieldNumber: 174) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularBytesField, fieldNumber: 231) } if _storage._decodeSingularDoubleField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularDoubleField, fieldNumber: 175) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularDoubleField, fieldNumber: 232) } if _storage._decodeSingularEnumField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularEnumField, fieldNumber: 176) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularEnumField, fieldNumber: 233) } if _storage._decodeSingularFixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularFixed32Field, fieldNumber: 177) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularFixed32Field, fieldNumber: 234) } if _storage._decodeSingularFixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularFixed64Field, fieldNumber: 178) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularFixed64Field, fieldNumber: 235) } if _storage._decodeSingularFloatField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularFloatField, fieldNumber: 179) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularFloatField, fieldNumber: 236) } if _storage._decodeSingularGroupField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularGroupField, fieldNumber: 180) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularGroupField, fieldNumber: 237) } if _storage._decodeSingularInt32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularInt32Field, fieldNumber: 181) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularInt32Field, fieldNumber: 238) } if _storage._decodeSingularInt64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularInt64Field, fieldNumber: 182) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularInt64Field, fieldNumber: 239) } if _storage._decodeSingularMessageField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularMessageField, fieldNumber: 183) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularMessageField, fieldNumber: 240) } if _storage._decodeSingularSfixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularSfixed32Field, fieldNumber: 184) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularSfixed32Field, fieldNumber: 241) } if _storage._decodeSingularSfixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularSfixed64Field, fieldNumber: 185) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularSfixed64Field, fieldNumber: 242) } if _storage._decodeSingularSint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularSint32Field, fieldNumber: 186) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularSint32Field, fieldNumber: 243) } if _storage._decodeSingularSint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularSint64Field, fieldNumber: 187) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularSint64Field, fieldNumber: 244) } if _storage._decodeSingularStringField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularStringField, fieldNumber: 188) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularStringField, fieldNumber: 245) } if _storage._decodeSingularUint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularUint32Field, fieldNumber: 189) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularUint32Field, fieldNumber: 246) } if _storage._decodeSingularUint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularUint64Field, fieldNumber: 190) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularUint64Field, fieldNumber: 247) } if _storage._decodeTextFormat != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeTextFormat, fieldNumber: 191) + try visitor.visitSingularInt32Field(value: _storage._decodeTextFormat, fieldNumber: 248) } if _storage._defaultAnyTypeUrlprefix != 0 { - try visitor.visitSingularInt32Field(value: _storage._defaultAnyTypeUrlprefix, fieldNumber: 192) + try visitor.visitSingularInt32Field(value: _storage._defaultAnyTypeUrlprefix, fieldNumber: 249) + } + if _storage._defaults != 0 { + try visitor.visitSingularInt32Field(value: _storage._defaults, fieldNumber: 250) + } + if _storage._defaultSymbolVisibility != 0 { + try visitor.visitSingularInt32Field(value: _storage._defaultSymbolVisibility, fieldNumber: 251) } if _storage._defaultValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._defaultValue, fieldNumber: 193) + try visitor.visitSingularInt32Field(value: _storage._defaultValue, fieldNumber: 252) } if _storage._dependency != 0 { - try visitor.visitSingularInt32Field(value: _storage._dependency, fieldNumber: 194) + try visitor.visitSingularInt32Field(value: _storage._dependency, fieldNumber: 253) } if _storage._deprecated != 0 { - try visitor.visitSingularInt32Field(value: _storage._deprecated, fieldNumber: 195) + try visitor.visitSingularInt32Field(value: _storage._deprecated, fieldNumber: 254) } - if _storage._description_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._description_p, fieldNumber: 196) + if _storage._deprecatedLegacyJsonFieldConflicts != 0 { + try visitor.visitSingularInt32Field(value: _storage._deprecatedLegacyJsonFieldConflicts, fieldNumber: 255) } - if _storage._descriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._descriptorProto, fieldNumber: 197) + if _storage._deprecationWarning != 0 { + try visitor.visitSingularInt32Field(value: _storage._deprecationWarning, fieldNumber: 256) + } + if _storage._description_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._description_p, fieldNumber: 257) } if _storage._dictionary != 0 { - try visitor.visitSingularInt32Field(value: _storage._dictionary, fieldNumber: 198) + try visitor.visitSingularInt32Field(value: _storage._dictionary, fieldNumber: 258) } if _storage._dictionaryLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._dictionaryLiteral, fieldNumber: 199) + try visitor.visitSingularInt32Field(value: _storage._dictionaryLiteral, fieldNumber: 259) } if _storage._digit != 0 { - try visitor.visitSingularInt32Field(value: _storage._digit, fieldNumber: 200) + try visitor.visitSingularInt32Field(value: _storage._digit, fieldNumber: 260) } if _storage._digit0 != 0 { - try visitor.visitSingularInt32Field(value: _storage._digit0, fieldNumber: 201) + try visitor.visitSingularInt32Field(value: _storage._digit0, fieldNumber: 261) } if _storage._digit1 != 0 { - try visitor.visitSingularInt32Field(value: _storage._digit1, fieldNumber: 202) + try visitor.visitSingularInt32Field(value: _storage._digit1, fieldNumber: 262) } if _storage._digitCount != 0 { - try visitor.visitSingularInt32Field(value: _storage._digitCount, fieldNumber: 203) + try visitor.visitSingularInt32Field(value: _storage._digitCount, fieldNumber: 263) } if _storage._digits != 0 { - try visitor.visitSingularInt32Field(value: _storage._digits, fieldNumber: 204) + try visitor.visitSingularInt32Field(value: _storage._digits, fieldNumber: 264) } if _storage._digitValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._digitValue, fieldNumber: 205) + try visitor.visitSingularInt32Field(value: _storage._digitValue, fieldNumber: 265) } if _storage._discardableResult != 0 { - try visitor.visitSingularInt32Field(value: _storage._discardableResult, fieldNumber: 206) + try visitor.visitSingularInt32Field(value: _storage._discardableResult, fieldNumber: 266) } if _storage._discardUnknownFields != 0 { - try visitor.visitSingularInt32Field(value: _storage._discardUnknownFields, fieldNumber: 207) - } - if _storage._distance != 0 { - try visitor.visitSingularInt32Field(value: _storage._distance, fieldNumber: 208) + try visitor.visitSingularInt32Field(value: _storage._discardUnknownFields, fieldNumber: 267) } if _storage._double != 0 { - try visitor.visitSingularInt32Field(value: _storage._double, fieldNumber: 209) + try visitor.visitSingularInt32Field(value: _storage._double, fieldNumber: 268) } if _storage._doubleValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._doubleValue, fieldNumber: 210) + try visitor.visitSingularInt32Field(value: _storage._doubleValue, fieldNumber: 269) } if _storage._duration != 0 { - try visitor.visitSingularInt32Field(value: _storage._duration, fieldNumber: 211) + try visitor.visitSingularInt32Field(value: _storage._duration, fieldNumber: 270) } if _storage._e != 0 { - try visitor.visitSingularInt32Field(value: _storage._e, fieldNumber: 212) + try visitor.visitSingularInt32Field(value: _storage._e, fieldNumber: 271) + } + if _storage._edition != 0 { + try visitor.visitSingularInt32Field(value: _storage._edition, fieldNumber: 272) + } + if _storage._editionDefault != 0 { + try visitor.visitSingularInt32Field(value: _storage._editionDefault, fieldNumber: 273) + } + if _storage._editionDefaults != 0 { + try visitor.visitSingularInt32Field(value: _storage._editionDefaults, fieldNumber: 274) + } + if _storage._editionDeprecated != 0 { + try visitor.visitSingularInt32Field(value: _storage._editionDeprecated, fieldNumber: 275) + } + if _storage._editionIntroduced != 0 { + try visitor.visitSingularInt32Field(value: _storage._editionIntroduced, fieldNumber: 276) + } + if _storage._editionRemoved != 0 { + try visitor.visitSingularInt32Field(value: _storage._editionRemoved, fieldNumber: 277) } if _storage._element != 0 { - try visitor.visitSingularInt32Field(value: _storage._element, fieldNumber: 213) + try visitor.visitSingularInt32Field(value: _storage._element, fieldNumber: 278) } if _storage._elements != 0 { - try visitor.visitSingularInt32Field(value: _storage._elements, fieldNumber: 214) + try visitor.visitSingularInt32Field(value: _storage._elements, fieldNumber: 279) + } + if _storage._else != 0 { + try visitor.visitSingularInt32Field(value: _storage._else, fieldNumber: 280) } if _storage._emitExtensionFieldName != 0 { - try visitor.visitSingularInt32Field(value: _storage._emitExtensionFieldName, fieldNumber: 215) + try visitor.visitSingularInt32Field(value: _storage._emitExtensionFieldName, fieldNumber: 281) } if _storage._emitFieldName != 0 { - try visitor.visitSingularInt32Field(value: _storage._emitFieldName, fieldNumber: 216) + try visitor.visitSingularInt32Field(value: _storage._emitFieldName, fieldNumber: 282) } if _storage._emitFieldNumber != 0 { - try visitor.visitSingularInt32Field(value: _storage._emitFieldNumber, fieldNumber: 217) + try visitor.visitSingularInt32Field(value: _storage._emitFieldNumber, fieldNumber: 283) } - if _storage._empty != 0 { - try visitor.visitSingularInt32Field(value: _storage._empty, fieldNumber: 218) + if _storage._emptyAnyTypeURL != 0 { + try visitor.visitSingularInt32Field(value: _storage._emptyAnyTypeURL, fieldNumber: 284) } if _storage._emptyData != 0 { - try visitor.visitSingularInt32Field(value: _storage._emptyData, fieldNumber: 219) + try visitor.visitSingularInt32Field(value: _storage._emptyData, fieldNumber: 285) } if _storage._encodeAsBytes != 0 { - try visitor.visitSingularInt32Field(value: _storage._encodeAsBytes, fieldNumber: 220) + try visitor.visitSingularInt32Field(value: _storage._encodeAsBytes, fieldNumber: 286) } if _storage._encoded != 0 { - try visitor.visitSingularInt32Field(value: _storage._encoded, fieldNumber: 221) + try visitor.visitSingularInt32Field(value: _storage._encoded, fieldNumber: 287) } if _storage._encodedJsonstring != 0 { - try visitor.visitSingularInt32Field(value: _storage._encodedJsonstring, fieldNumber: 222) + try visitor.visitSingularInt32Field(value: _storage._encodedJsonstring, fieldNumber: 288) } if _storage._encodedSize != 0 { - try visitor.visitSingularInt32Field(value: _storage._encodedSize, fieldNumber: 223) + try visitor.visitSingularInt32Field(value: _storage._encodedSize, fieldNumber: 289) } if _storage._encodeField != 0 { - try visitor.visitSingularInt32Field(value: _storage._encodeField, fieldNumber: 224) + try visitor.visitSingularInt32Field(value: _storage._encodeField, fieldNumber: 290) } if _storage._encoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._encoder, fieldNumber: 225) + try visitor.visitSingularInt32Field(value: _storage._encoder, fieldNumber: 291) } if _storage._end != 0 { - try visitor.visitSingularInt32Field(value: _storage._end, fieldNumber: 226) + try visitor.visitSingularInt32Field(value: _storage._end, fieldNumber: 292) } if _storage._endArray != 0 { - try visitor.visitSingularInt32Field(value: _storage._endArray, fieldNumber: 227) + try visitor.visitSingularInt32Field(value: _storage._endArray, fieldNumber: 293) } if _storage._endMessageField != 0 { - try visitor.visitSingularInt32Field(value: _storage._endMessageField, fieldNumber: 228) + try visitor.visitSingularInt32Field(value: _storage._endMessageField, fieldNumber: 294) } if _storage._endObject != 0 { - try visitor.visitSingularInt32Field(value: _storage._endObject, fieldNumber: 229) + try visitor.visitSingularInt32Field(value: _storage._endObject, fieldNumber: 295) } if _storage._endRegularField != 0 { - try visitor.visitSingularInt32Field(value: _storage._endRegularField, fieldNumber: 230) + try visitor.visitSingularInt32Field(value: _storage._endRegularField, fieldNumber: 296) } - if _storage._enum != 0 { - try visitor.visitSingularInt32Field(value: _storage._enum, fieldNumber: 231) - } - if _storage._enumDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._enumDescriptorProto, fieldNumber: 232) + if _storage._enforceNamingStyle != 0 { + try visitor.visitSingularInt32Field(value: _storage._enforceNamingStyle, fieldNumber: 297) } - if _storage._enumOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._enumOptions, fieldNumber: 233) + if _storage._enum != 0 { + try visitor.visitSingularInt32Field(value: _storage._enum, fieldNumber: 298) } if _storage._enumReservedRange != 0 { - try visitor.visitSingularInt32Field(value: _storage._enumReservedRange, fieldNumber: 234) + try visitor.visitSingularInt32Field(value: _storage._enumReservedRange, fieldNumber: 299) } if _storage._enumType != 0 { - try visitor.visitSingularInt32Field(value: _storage._enumType, fieldNumber: 235) + try visitor.visitSingularInt32Field(value: _storage._enumType, fieldNumber: 300) } if _storage._enumvalue != 0 { - try visitor.visitSingularInt32Field(value: _storage._enumvalue, fieldNumber: 236) - } - if _storage._enumValueDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._enumValueDescriptorProto, fieldNumber: 237) - } - if _storage._enumValueOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._enumValueOptions, fieldNumber: 238) + try visitor.visitSingularInt32Field(value: _storage._enumvalue, fieldNumber: 301) } if _storage._equatable != 0 { - try visitor.visitSingularInt32Field(value: _storage._equatable, fieldNumber: 239) + try visitor.visitSingularInt32Field(value: _storage._equatable, fieldNumber: 302) } if _storage._error != 0 { - try visitor.visitSingularInt32Field(value: _storage._error, fieldNumber: 240) + try visitor.visitSingularInt32Field(value: _storage._error, fieldNumber: 303) + } + if _storage._execute != 0 { + try visitor.visitSingularInt32Field(value: _storage._execute, fieldNumber: 304) } if _storage._expressibleByArrayLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._expressibleByArrayLiteral, fieldNumber: 241) + try visitor.visitSingularInt32Field(value: _storage._expressibleByArrayLiteral, fieldNumber: 305) } if _storage._expressibleByDictionaryLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._expressibleByDictionaryLiteral, fieldNumber: 242) + try visitor.visitSingularInt32Field(value: _storage._expressibleByDictionaryLiteral, fieldNumber: 306) } if _storage._ext != 0 { - try visitor.visitSingularInt32Field(value: _storage._ext, fieldNumber: 243) + try visitor.visitSingularInt32Field(value: _storage._ext, fieldNumber: 307) } if _storage._extDecoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._extDecoder, fieldNumber: 244) + try visitor.visitSingularInt32Field(value: _storage._extDecoder, fieldNumber: 308) } if _storage._extendedGraphemeClusterLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._extendedGraphemeClusterLiteral, fieldNumber: 245) + try visitor.visitSingularInt32Field(value: _storage._extendedGraphemeClusterLiteral, fieldNumber: 309) } if _storage._extendedGraphemeClusterLiteralType != 0 { - try visitor.visitSingularInt32Field(value: _storage._extendedGraphemeClusterLiteralType, fieldNumber: 246) + try visitor.visitSingularInt32Field(value: _storage._extendedGraphemeClusterLiteralType, fieldNumber: 310) } if _storage._extendee != 0 { - try visitor.visitSingularInt32Field(value: _storage._extendee, fieldNumber: 247) + try visitor.visitSingularInt32Field(value: _storage._extendee, fieldNumber: 311) } if _storage._extensibleMessage != 0 { - try visitor.visitSingularInt32Field(value: _storage._extensibleMessage, fieldNumber: 248) + try visitor.visitSingularInt32Field(value: _storage._extensibleMessage, fieldNumber: 312) } if _storage._extension != 0 { - try visitor.visitSingularInt32Field(value: _storage._extension, fieldNumber: 249) + try visitor.visitSingularInt32Field(value: _storage._extension, fieldNumber: 313) } if _storage._extensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._extensionField, fieldNumber: 250) + try visitor.visitSingularInt32Field(value: _storage._extensionField, fieldNumber: 314) } if _storage._extensionFieldNumber != 0 { - try visitor.visitSingularInt32Field(value: _storage._extensionFieldNumber, fieldNumber: 251) + try visitor.visitSingularInt32Field(value: _storage._extensionFieldNumber, fieldNumber: 315) } if _storage._extensionFieldValueSet != 0 { - try visitor.visitSingularInt32Field(value: _storage._extensionFieldValueSet, fieldNumber: 252) + try visitor.visitSingularInt32Field(value: _storage._extensionFieldValueSet, fieldNumber: 316) } if _storage._extensionMap != 0 { - try visitor.visitSingularInt32Field(value: _storage._extensionMap, fieldNumber: 253) + try visitor.visitSingularInt32Field(value: _storage._extensionMap, fieldNumber: 317) } if _storage._extensionRange != 0 { - try visitor.visitSingularInt32Field(value: _storage._extensionRange, fieldNumber: 254) - } - if _storage._extensionRangeOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._extensionRangeOptions, fieldNumber: 255) + try visitor.visitSingularInt32Field(value: _storage._extensionRange, fieldNumber: 318) } if _storage._extensions != 0 { - try visitor.visitSingularInt32Field(value: _storage._extensions, fieldNumber: 256) + try visitor.visitSingularInt32Field(value: _storage._extensions, fieldNumber: 319) } if _storage._extras != 0 { - try visitor.visitSingularInt32Field(value: _storage._extras, fieldNumber: 257) + try visitor.visitSingularInt32Field(value: _storage._extras, fieldNumber: 320) } if _storage._f != 0 { - try visitor.visitSingularInt32Field(value: _storage._f, fieldNumber: 258) + try visitor.visitSingularInt32Field(value: _storage._f, fieldNumber: 321) } if _storage._false != 0 { - try visitor.visitSingularInt32Field(value: _storage._false, fieldNumber: 259) + try visitor.visitSingularInt32Field(value: _storage._false, fieldNumber: 322) + } + if _storage._features != 0 { + try visitor.visitSingularInt32Field(value: _storage._features, fieldNumber: 323) + } + if _storage._featureSetEditionDefault != 0 { + try visitor.visitSingularInt32Field(value: _storage._featureSetEditionDefault, fieldNumber: 324) + } + if _storage._featureSupport != 0 { + try visitor.visitSingularInt32Field(value: _storage._featureSupport, fieldNumber: 325) } if _storage._field != 0 { - try visitor.visitSingularInt32Field(value: _storage._field, fieldNumber: 260) + try visitor.visitSingularInt32Field(value: _storage._field, fieldNumber: 326) } if _storage._fieldData != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldData, fieldNumber: 261) + try visitor.visitSingularInt32Field(value: _storage._fieldData, fieldNumber: 327) } - if _storage._fieldDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldDescriptorProto, fieldNumber: 262) - } - if _storage._fieldMask != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldMask, fieldNumber: 263) + if _storage._fieldMaskError != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldMaskError, fieldNumber: 328) } if _storage._fieldName != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldName, fieldNumber: 264) + try visitor.visitSingularInt32Field(value: _storage._fieldName, fieldNumber: 329) } if _storage._fieldNameCount != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldNameCount, fieldNumber: 265) + try visitor.visitSingularInt32Field(value: _storage._fieldNameCount, fieldNumber: 330) } if _storage._fieldNum != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldNum, fieldNumber: 266) + try visitor.visitSingularInt32Field(value: _storage._fieldNum, fieldNumber: 331) } if _storage._fieldNumber != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldNumber, fieldNumber: 267) + try visitor.visitSingularInt32Field(value: _storage._fieldNumber, fieldNumber: 332) } if _storage._fieldNumberForProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldNumberForProto, fieldNumber: 268) + try visitor.visitSingularInt32Field(value: _storage._fieldNumberForProto, fieldNumber: 333) } - if _storage._fieldOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldOptions, fieldNumber: 269) + if _storage._fieldPresence != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldPresence, fieldNumber: 334) } if _storage._fields != 0 { - try visitor.visitSingularInt32Field(value: _storage._fields, fieldNumber: 270) + try visitor.visitSingularInt32Field(value: _storage._fields, fieldNumber: 335) } if _storage._fieldSize != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldSize, fieldNumber: 271) + try visitor.visitSingularInt32Field(value: _storage._fieldSize, fieldNumber: 336) } if _storage._fieldTag != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldTag, fieldNumber: 272) + try visitor.visitSingularInt32Field(value: _storage._fieldTag, fieldNumber: 337) } if _storage._fieldType != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldType, fieldNumber: 273) + try visitor.visitSingularInt32Field(value: _storage._fieldType, fieldNumber: 338) } if _storage._file != 0 { - try visitor.visitSingularInt32Field(value: _storage._file, fieldNumber: 274) - } - if _storage._fileDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._fileDescriptorProto, fieldNumber: 275) - } - if _storage._fileDescriptorSet != 0 { - try visitor.visitSingularInt32Field(value: _storage._fileDescriptorSet, fieldNumber: 276) + try visitor.visitSingularInt32Field(value: _storage._file, fieldNumber: 339) } if _storage._fileName != 0 { - try visitor.visitSingularInt32Field(value: _storage._fileName, fieldNumber: 277) - } - if _storage._fileOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._fileOptions, fieldNumber: 278) + try visitor.visitSingularInt32Field(value: _storage._fileName, fieldNumber: 340) } if _storage._filter != 0 { - try visitor.visitSingularInt32Field(value: _storage._filter, fieldNumber: 279) + try visitor.visitSingularInt32Field(value: _storage._filter, fieldNumber: 341) + } + if _storage._final != 0 { + try visitor.visitSingularInt32Field(value: _storage._final, fieldNumber: 342) + } + if _storage._finiteOnly != 0 { + try visitor.visitSingularInt32Field(value: _storage._finiteOnly, fieldNumber: 343) } if _storage._first != 0 { - try visitor.visitSingularInt32Field(value: _storage._first, fieldNumber: 280) + try visitor.visitSingularInt32Field(value: _storage._first, fieldNumber: 344) } if _storage._firstItem != 0 { - try visitor.visitSingularInt32Field(value: _storage._firstItem, fieldNumber: 281) + try visitor.visitSingularInt32Field(value: _storage._firstItem, fieldNumber: 345) + } + if _storage._fixedFeatures != 0 { + try visitor.visitSingularInt32Field(value: _storage._fixedFeatures, fieldNumber: 346) } if _storage._float != 0 { - try visitor.visitSingularInt32Field(value: _storage._float, fieldNumber: 282) + try visitor.visitSingularInt32Field(value: _storage._float, fieldNumber: 347) } if _storage._floatLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._floatLiteral, fieldNumber: 283) + try visitor.visitSingularInt32Field(value: _storage._floatLiteral, fieldNumber: 348) } if _storage._floatLiteralType != 0 { - try visitor.visitSingularInt32Field(value: _storage._floatLiteralType, fieldNumber: 284) + try visitor.visitSingularInt32Field(value: _storage._floatLiteralType, fieldNumber: 349) } - if _storage._floatValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._floatValue, fieldNumber: 285) + if _storage._for != 0 { + try visitor.visitSingularInt32Field(value: _storage._for, fieldNumber: 350) } if _storage._forMessageName != 0 { - try visitor.visitSingularInt32Field(value: _storage._forMessageName, fieldNumber: 286) + try visitor.visitSingularInt32Field(value: _storage._forMessageName, fieldNumber: 351) } if _storage._formUnion != 0 { - try visitor.visitSingularInt32Field(value: _storage._formUnion, fieldNumber: 287) + try visitor.visitSingularInt32Field(value: _storage._formUnion, fieldNumber: 352) } if _storage._forReadingFrom != 0 { - try visitor.visitSingularInt32Field(value: _storage._forReadingFrom, fieldNumber: 288) + try visitor.visitSingularInt32Field(value: _storage._forReadingFrom, fieldNumber: 353) } if _storage._forTypeURL != 0 { - try visitor.visitSingularInt32Field(value: _storage._forTypeURL, fieldNumber: 289) + try visitor.visitSingularInt32Field(value: _storage._forTypeURL, fieldNumber: 354) } if _storage._forwardParser != 0 { - try visitor.visitSingularInt32Field(value: _storage._forwardParser, fieldNumber: 290) + try visitor.visitSingularInt32Field(value: _storage._forwardParser, fieldNumber: 355) } if _storage._forWritingInto != 0 { - try visitor.visitSingularInt32Field(value: _storage._forWritingInto, fieldNumber: 291) + try visitor.visitSingularInt32Field(value: _storage._forWritingInto, fieldNumber: 356) } if _storage._from != 0 { - try visitor.visitSingularInt32Field(value: _storage._from, fieldNumber: 292) + try visitor.visitSingularInt32Field(value: _storage._from, fieldNumber: 357) } if _storage._fromAscii2 != 0 { - try visitor.visitSingularInt32Field(value: _storage._fromAscii2, fieldNumber: 293) + try visitor.visitSingularInt32Field(value: _storage._fromAscii2, fieldNumber: 358) } if _storage._fromAscii4 != 0 { - try visitor.visitSingularInt32Field(value: _storage._fromAscii4, fieldNumber: 294) + try visitor.visitSingularInt32Field(value: _storage._fromAscii4, fieldNumber: 359) } if _storage._fromByteOffset != 0 { - try visitor.visitSingularInt32Field(value: _storage._fromByteOffset, fieldNumber: 295) + try visitor.visitSingularInt32Field(value: _storage._fromByteOffset, fieldNumber: 360) } if _storage._fromHexDigit != 0 { - try visitor.visitSingularInt32Field(value: _storage._fromHexDigit, fieldNumber: 296) + try visitor.visitSingularInt32Field(value: _storage._fromHexDigit, fieldNumber: 361) + } + if _storage._fullName != 0 { + try visitor.visitSingularInt32Field(value: _storage._fullName, fieldNumber: 362) } if _storage._func != 0 { - try visitor.visitSingularInt32Field(value: _storage._func, fieldNumber: 297) + try visitor.visitSingularInt32Field(value: _storage._func, fieldNumber: 363) } - if _storage._g != 0 { - try visitor.visitSingularInt32Field(value: _storage._g, fieldNumber: 298) + if _storage._function != 0 { + try visitor.visitSingularInt32Field(value: _storage._function, fieldNumber: 364) } - if _storage._generatedCodeInfo != 0 { - try visitor.visitSingularInt32Field(value: _storage._generatedCodeInfo, fieldNumber: 299) + if _storage._g != 0 { + try visitor.visitSingularInt32Field(value: _storage._g, fieldNumber: 365) } if _storage._get != 0 { - try visitor.visitSingularInt32Field(value: _storage._get, fieldNumber: 300) + try visitor.visitSingularInt32Field(value: _storage._get, fieldNumber: 366) } if _storage._getExtensionValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._getExtensionValue, fieldNumber: 301) - } - if _storage._googleapis != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleapis, fieldNumber: 302) + try visitor.visitSingularInt32Field(value: _storage._getExtensionValue, fieldNumber: 367) } if _storage._googleProtobufAny != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufAny, fieldNumber: 303) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufAny, fieldNumber: 368) } if _storage._googleProtobufApi != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufApi, fieldNumber: 304) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufApi, fieldNumber: 369) } if _storage._googleProtobufBoolValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufBoolValue, fieldNumber: 305) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufBoolValue, fieldNumber: 370) } if _storage._googleProtobufBytesValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufBytesValue, fieldNumber: 306) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufBytesValue, fieldNumber: 371) } if _storage._googleProtobufDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufDescriptorProto, fieldNumber: 307) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufDescriptorProto, fieldNumber: 372) } if _storage._googleProtobufDoubleValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufDoubleValue, fieldNumber: 308) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufDoubleValue, fieldNumber: 373) } if _storage._googleProtobufDuration != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufDuration, fieldNumber: 309) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufDuration, fieldNumber: 374) + } + if _storage._googleProtobufEdition != 0 { + try visitor.visitSingularInt32Field(value: _storage._googleProtobufEdition, fieldNumber: 375) } if _storage._googleProtobufEmpty != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufEmpty, fieldNumber: 310) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufEmpty, fieldNumber: 376) } if _storage._googleProtobufEnum != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnum, fieldNumber: 311) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnum, fieldNumber: 377) } if _storage._googleProtobufEnumDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumDescriptorProto, fieldNumber: 312) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumDescriptorProto, fieldNumber: 378) } if _storage._googleProtobufEnumOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumOptions, fieldNumber: 313) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumOptions, fieldNumber: 379) } if _storage._googleProtobufEnumValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumValue, fieldNumber: 314) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumValue, fieldNumber: 380) } if _storage._googleProtobufEnumValueDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumValueDescriptorProto, fieldNumber: 315) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumValueDescriptorProto, fieldNumber: 381) } if _storage._googleProtobufEnumValueOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumValueOptions, fieldNumber: 316) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumValueOptions, fieldNumber: 382) } if _storage._googleProtobufExtensionRangeOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufExtensionRangeOptions, fieldNumber: 317) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufExtensionRangeOptions, fieldNumber: 383) + } + if _storage._googleProtobufFeatureSet != 0 { + try visitor.visitSingularInt32Field(value: _storage._googleProtobufFeatureSet, fieldNumber: 384) + } + if _storage._googleProtobufFeatureSetDefaults != 0 { + try visitor.visitSingularInt32Field(value: _storage._googleProtobufFeatureSetDefaults, fieldNumber: 385) } if _storage._googleProtobufField != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufField, fieldNumber: 318) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufField, fieldNumber: 386) } if _storage._googleProtobufFieldDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufFieldDescriptorProto, fieldNumber: 319) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufFieldDescriptorProto, fieldNumber: 387) } if _storage._googleProtobufFieldMask != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufFieldMask, fieldNumber: 320) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufFieldMask, fieldNumber: 388) } if _storage._googleProtobufFieldOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufFieldOptions, fieldNumber: 321) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufFieldOptions, fieldNumber: 389) } if _storage._googleProtobufFileDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufFileDescriptorProto, fieldNumber: 322) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufFileDescriptorProto, fieldNumber: 390) } if _storage._googleProtobufFileDescriptorSet != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufFileDescriptorSet, fieldNumber: 323) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufFileDescriptorSet, fieldNumber: 391) } if _storage._googleProtobufFileOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufFileOptions, fieldNumber: 324) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufFileOptions, fieldNumber: 392) } if _storage._googleProtobufFloatValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufFloatValue, fieldNumber: 325) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufFloatValue, fieldNumber: 393) } if _storage._googleProtobufGeneratedCodeInfo != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufGeneratedCodeInfo, fieldNumber: 326) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufGeneratedCodeInfo, fieldNumber: 394) } if _storage._googleProtobufInt32Value != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufInt32Value, fieldNumber: 327) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufInt32Value, fieldNumber: 395) } if _storage._googleProtobufInt64Value != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufInt64Value, fieldNumber: 328) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufInt64Value, fieldNumber: 396) } if _storage._googleProtobufListValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufListValue, fieldNumber: 329) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufListValue, fieldNumber: 397) } if _storage._googleProtobufMessageOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufMessageOptions, fieldNumber: 330) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufMessageOptions, fieldNumber: 398) } if _storage._googleProtobufMethod != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufMethod, fieldNumber: 331) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufMethod, fieldNumber: 399) } if _storage._googleProtobufMethodDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufMethodDescriptorProto, fieldNumber: 332) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufMethodDescriptorProto, fieldNumber: 400) } if _storage._googleProtobufMethodOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufMethodOptions, fieldNumber: 333) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufMethodOptions, fieldNumber: 401) } if _storage._googleProtobufMixin != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufMixin, fieldNumber: 334) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufMixin, fieldNumber: 402) } if _storage._googleProtobufNullValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufNullValue, fieldNumber: 335) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufNullValue, fieldNumber: 403) } if _storage._googleProtobufOneofDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufOneofDescriptorProto, fieldNumber: 336) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufOneofDescriptorProto, fieldNumber: 404) } if _storage._googleProtobufOneofOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufOneofOptions, fieldNumber: 337) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufOneofOptions, fieldNumber: 405) } if _storage._googleProtobufOption != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufOption, fieldNumber: 338) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufOption, fieldNumber: 406) } if _storage._googleProtobufServiceDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufServiceDescriptorProto, fieldNumber: 339) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufServiceDescriptorProto, fieldNumber: 407) } if _storage._googleProtobufServiceOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufServiceOptions, fieldNumber: 340) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufServiceOptions, fieldNumber: 408) } if _storage._googleProtobufSourceCodeInfo != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufSourceCodeInfo, fieldNumber: 341) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufSourceCodeInfo, fieldNumber: 409) } if _storage._googleProtobufSourceContext != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufSourceContext, fieldNumber: 342) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufSourceContext, fieldNumber: 410) } if _storage._googleProtobufStringValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufStringValue, fieldNumber: 343) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufStringValue, fieldNumber: 411) } if _storage._googleProtobufStruct != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufStruct, fieldNumber: 344) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufStruct, fieldNumber: 412) + } + if _storage._googleProtobufSymbolVisibility != 0 { + try visitor.visitSingularInt32Field(value: _storage._googleProtobufSymbolVisibility, fieldNumber: 413) } if _storage._googleProtobufSyntax != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufSyntax, fieldNumber: 345) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufSyntax, fieldNumber: 414) } if _storage._googleProtobufTimestamp != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufTimestamp, fieldNumber: 346) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufTimestamp, fieldNumber: 415) } if _storage._googleProtobufType != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufType, fieldNumber: 347) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufType, fieldNumber: 416) } if _storage._googleProtobufUint32Value != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufUint32Value, fieldNumber: 348) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufUint32Value, fieldNumber: 417) } if _storage._googleProtobufUint64Value != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufUint64Value, fieldNumber: 349) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufUint64Value, fieldNumber: 418) } if _storage._googleProtobufUninterpretedOption != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufUninterpretedOption, fieldNumber: 350) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufUninterpretedOption, fieldNumber: 419) } if _storage._googleProtobufValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufValue, fieldNumber: 351) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufValue, fieldNumber: 420) } if _storage._goPackage != 0 { - try visitor.visitSingularInt32Field(value: _storage._goPackage, fieldNumber: 352) + try visitor.visitSingularInt32Field(value: _storage._goPackage, fieldNumber: 421) + } + if _storage._gotData != 0 { + try visitor.visitSingularInt32Field(value: _storage._gotData, fieldNumber: 422) } if _storage._group != 0 { - try visitor.visitSingularInt32Field(value: _storage._group, fieldNumber: 353) + try visitor.visitSingularInt32Field(value: _storage._group, fieldNumber: 423) } if _storage._groupFieldNumberStack != 0 { - try visitor.visitSingularInt32Field(value: _storage._groupFieldNumberStack, fieldNumber: 354) + try visitor.visitSingularInt32Field(value: _storage._groupFieldNumberStack, fieldNumber: 424) } if _storage._groupSize != 0 { - try visitor.visitSingularInt32Field(value: _storage._groupSize, fieldNumber: 355) + try visitor.visitSingularInt32Field(value: _storage._groupSize, fieldNumber: 425) } - if _storage._h != 0 { - try visitor.visitSingularInt32Field(value: _storage._h, fieldNumber: 356) + if _storage._guard != 0 { + try visitor.visitSingularInt32Field(value: _storage._guard, fieldNumber: 426) } if _storage._hadOneofValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._hadOneofValue, fieldNumber: 357) + try visitor.visitSingularInt32Field(value: _storage._hadOneofValue, fieldNumber: 427) } if _storage._handleConflictingOneOf != 0 { - try visitor.visitSingularInt32Field(value: _storage._handleConflictingOneOf, fieldNumber: 358) + try visitor.visitSingularInt32Field(value: _storage._handleConflictingOneOf, fieldNumber: 428) + } + if _storage._handleInstruction != 0 { + try visitor.visitSingularInt32Field(value: _storage._handleInstruction, fieldNumber: 429) } if _storage._hasAggregateValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasAggregateValue_p, fieldNumber: 359) + try visitor.visitSingularInt32Field(value: _storage._hasAggregateValue_p, fieldNumber: 430) } if _storage._hasAllowAlias_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasAllowAlias_p, fieldNumber: 360) + try visitor.visitSingularInt32Field(value: _storage._hasAllowAlias_p, fieldNumber: 431) } if _storage._hasBegin_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasBegin_p, fieldNumber: 361) + try visitor.visitSingularInt32Field(value: _storage._hasBegin_p, fieldNumber: 432) } if _storage._hasCcEnableArenas_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasCcEnableArenas_p, fieldNumber: 362) + try visitor.visitSingularInt32Field(value: _storage._hasCcEnableArenas_p, fieldNumber: 433) } if _storage._hasCcGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasCcGenericServices_p, fieldNumber: 363) + try visitor.visitSingularInt32Field(value: _storage._hasCcGenericServices_p, fieldNumber: 434) } if _storage._hasClientStreaming_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasClientStreaming_p, fieldNumber: 364) + try visitor.visitSingularInt32Field(value: _storage._hasClientStreaming_p, fieldNumber: 435) } if _storage._hasCsharpNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasCsharpNamespace_p, fieldNumber: 365) + try visitor.visitSingularInt32Field(value: _storage._hasCsharpNamespace_p, fieldNumber: 436) } if _storage._hasCtype_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasCtype_p, fieldNumber: 366) + try visitor.visitSingularInt32Field(value: _storage._hasCtype_p, fieldNumber: 437) + } + if _storage._hasData_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasData_p, fieldNumber: 438) + } + if _storage._hasDebugRedact_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasDebugRedact_p, fieldNumber: 439) + } + if _storage._hasDefaultSymbolVisibility_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasDefaultSymbolVisibility_p, fieldNumber: 440) } if _storage._hasDefaultValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasDefaultValue_p, fieldNumber: 367) + try visitor.visitSingularInt32Field(value: _storage._hasDefaultValue_p, fieldNumber: 441) } if _storage._hasDeprecated_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasDeprecated_p, fieldNumber: 368) + try visitor.visitSingularInt32Field(value: _storage._hasDeprecated_p, fieldNumber: 442) + } + if _storage._hasDeprecatedLegacyJsonFieldConflicts_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasDeprecatedLegacyJsonFieldConflicts_p, fieldNumber: 443) + } + if _storage._hasDeprecationWarning_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasDeprecationWarning_p, fieldNumber: 444) } if _storage._hasDoubleValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasDoubleValue_p, fieldNumber: 369) + try visitor.visitSingularInt32Field(value: _storage._hasDoubleValue_p, fieldNumber: 445) + } + if _storage._hasEdition_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasEdition_p, fieldNumber: 446) + } + if _storage._hasEditionDeprecated_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasEditionDeprecated_p, fieldNumber: 447) + } + if _storage._hasEditionIntroduced_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasEditionIntroduced_p, fieldNumber: 448) + } + if _storage._hasEditionRemoved_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasEditionRemoved_p, fieldNumber: 449) } if _storage._hasEnd_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasEnd_p, fieldNumber: 370) + try visitor.visitSingularInt32Field(value: _storage._hasEnd_p, fieldNumber: 450) + } + if _storage._hasEnforceNamingStyle_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasEnforceNamingStyle_p, fieldNumber: 451) + } + if _storage._hasEnumType_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasEnumType_p, fieldNumber: 452) + } + if _storage._hasExplicitDelta_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasExplicitDelta_p, fieldNumber: 453) } if _storage._hasExtendee_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasExtendee_p, fieldNumber: 371) + try visitor.visitSingularInt32Field(value: _storage._hasExtendee_p, fieldNumber: 454) } if _storage._hasExtensionValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasExtensionValue_p, fieldNumber: 372) + try visitor.visitSingularInt32Field(value: _storage._hasExtensionValue_p, fieldNumber: 455) + } + if _storage._hasFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasFeatures_p, fieldNumber: 456) + } + if _storage._hasFeatureSupport_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasFeatureSupport_p, fieldNumber: 457) + } + if _storage._hasFieldPresence_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasFieldPresence_p, fieldNumber: 458) + } + if _storage._hasFixedFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasFixedFeatures_p, fieldNumber: 459) + } + if _storage._hasFullName_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasFullName_p, fieldNumber: 460) } if _storage._hasGoPackage_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasGoPackage_p, fieldNumber: 373) + try visitor.visitSingularInt32Field(value: _storage._hasGoPackage_p, fieldNumber: 461) } if _storage._hash != 0 { - try visitor.visitSingularInt32Field(value: _storage._hash, fieldNumber: 374) + try visitor.visitSingularInt32Field(value: _storage._hash, fieldNumber: 462) } if _storage._hashable != 0 { - try visitor.visitSingularInt32Field(value: _storage._hashable, fieldNumber: 375) + try visitor.visitSingularInt32Field(value: _storage._hashable, fieldNumber: 463) } if _storage._hasher != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasher, fieldNumber: 376) - } - if _storage._hashValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hashValue_p, fieldNumber: 377) + try visitor.visitSingularInt32Field(value: _storage._hasher, fieldNumber: 464) } if _storage._hashVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._hashVisitor, fieldNumber: 378) + try visitor.visitSingularInt32Field(value: _storage._hashVisitor, fieldNumber: 465) } if _storage._hasIdempotencyLevel_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasIdempotencyLevel_p, fieldNumber: 379) + try visitor.visitSingularInt32Field(value: _storage._hasIdempotencyLevel_p, fieldNumber: 466) } if _storage._hasIdentifierValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasIdentifierValue_p, fieldNumber: 380) + try visitor.visitSingularInt32Field(value: _storage._hasIdentifierValue_p, fieldNumber: 467) } if _storage._hasInputType_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasInputType_p, fieldNumber: 381) + try visitor.visitSingularInt32Field(value: _storage._hasInputType_p, fieldNumber: 468) } if _storage._hasIsExtension_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasIsExtension_p, fieldNumber: 382) + try visitor.visitSingularInt32Field(value: _storage._hasIsExtension_p, fieldNumber: 469) } if _storage._hasJavaGenerateEqualsAndHash_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasJavaGenerateEqualsAndHash_p, fieldNumber: 383) + try visitor.visitSingularInt32Field(value: _storage._hasJavaGenerateEqualsAndHash_p, fieldNumber: 470) } if _storage._hasJavaGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasJavaGenericServices_p, fieldNumber: 384) + try visitor.visitSingularInt32Field(value: _storage._hasJavaGenericServices_p, fieldNumber: 471) } if _storage._hasJavaMultipleFiles_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasJavaMultipleFiles_p, fieldNumber: 385) + try visitor.visitSingularInt32Field(value: _storage._hasJavaMultipleFiles_p, fieldNumber: 472) } if _storage._hasJavaOuterClassname_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasJavaOuterClassname_p, fieldNumber: 386) + try visitor.visitSingularInt32Field(value: _storage._hasJavaOuterClassname_p, fieldNumber: 473) } if _storage._hasJavaPackage_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasJavaPackage_p, fieldNumber: 387) + try visitor.visitSingularInt32Field(value: _storage._hasJavaPackage_p, fieldNumber: 474) } if _storage._hasJavaStringCheckUtf8_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasJavaStringCheckUtf8_p, fieldNumber: 388) + try visitor.visitSingularInt32Field(value: _storage._hasJavaStringCheckUtf8_p, fieldNumber: 475) + } + if _storage._hasJsonFormat_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasJsonFormat_p, fieldNumber: 476) } if _storage._hasJsonName_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasJsonName_p, fieldNumber: 389) + try visitor.visitSingularInt32Field(value: _storage._hasJsonName_p, fieldNumber: 477) } if _storage._hasJstype_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasJstype_p, fieldNumber: 390) + try visitor.visitSingularInt32Field(value: _storage._hasJstype_p, fieldNumber: 478) } if _storage._hasLabel_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasLabel_p, fieldNumber: 391) + try visitor.visitSingularInt32Field(value: _storage._hasLabel_p, fieldNumber: 479) } if _storage._hasLazy_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasLazy_p, fieldNumber: 392) + try visitor.visitSingularInt32Field(value: _storage._hasLazy_p, fieldNumber: 480) } if _storage._hasLeadingComments_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasLeadingComments_p, fieldNumber: 393) + try visitor.visitSingularInt32Field(value: _storage._hasLeadingComments_p, fieldNumber: 481) } if _storage._hasMapEntry_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasMapEntry_p, fieldNumber: 394) + try visitor.visitSingularInt32Field(value: _storage._hasMapEntry_p, fieldNumber: 482) + } + if _storage._hasMaximumEdition_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasMaximumEdition_p, fieldNumber: 483) + } + if _storage._hasMessageEncoding_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasMessageEncoding_p, fieldNumber: 484) } if _storage._hasMessageSetWireFormat_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasMessageSetWireFormat_p, fieldNumber: 395) + try visitor.visitSingularInt32Field(value: _storage._hasMessageSetWireFormat_p, fieldNumber: 485) + } + if _storage._hasMinimumEdition_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasMinimumEdition_p, fieldNumber: 486) } if _storage._hasName_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasName_p, fieldNumber: 396) + try visitor.visitSingularInt32Field(value: _storage._hasName_p, fieldNumber: 487) } if _storage._hasNamePart_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasNamePart_p, fieldNumber: 397) + try visitor.visitSingularInt32Field(value: _storage._hasNamePart_p, fieldNumber: 488) } if _storage._hasNegativeIntValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasNegativeIntValue_p, fieldNumber: 398) + try visitor.visitSingularInt32Field(value: _storage._hasNegativeIntValue_p, fieldNumber: 489) } if _storage._hasNoStandardDescriptorAccessor_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasNoStandardDescriptorAccessor_p, fieldNumber: 399) + try visitor.visitSingularInt32Field(value: _storage._hasNoStandardDescriptorAccessor_p, fieldNumber: 490) } if _storage._hasNumber_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasNumber_p, fieldNumber: 400) + try visitor.visitSingularInt32Field(value: _storage._hasNumber_p, fieldNumber: 491) } if _storage._hasObjcClassPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasObjcClassPrefix_p, fieldNumber: 401) + try visitor.visitSingularInt32Field(value: _storage._hasObjcClassPrefix_p, fieldNumber: 492) } if _storage._hasOneofIndex_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasOneofIndex_p, fieldNumber: 402) + try visitor.visitSingularInt32Field(value: _storage._hasOneofIndex_p, fieldNumber: 493) } if _storage._hasOptimizeFor_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasOptimizeFor_p, fieldNumber: 403) + try visitor.visitSingularInt32Field(value: _storage._hasOptimizeFor_p, fieldNumber: 494) } if _storage._hasOptions_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasOptions_p, fieldNumber: 404) + try visitor.visitSingularInt32Field(value: _storage._hasOptions_p, fieldNumber: 495) } if _storage._hasOutputType_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasOutputType_p, fieldNumber: 405) + try visitor.visitSingularInt32Field(value: _storage._hasOutputType_p, fieldNumber: 496) + } + if _storage._hasOverridableFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasOverridableFeatures_p, fieldNumber: 497) } if _storage._hasPackage_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasPackage_p, fieldNumber: 406) + try visitor.visitSingularInt32Field(value: _storage._hasPackage_p, fieldNumber: 498) } if _storage._hasPacked_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasPacked_p, fieldNumber: 407) + try visitor.visitSingularInt32Field(value: _storage._hasPacked_p, fieldNumber: 499) } if _storage._hasPhpClassPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasPhpClassPrefix_p, fieldNumber: 408) - } - if _storage._hasPhpGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasPhpGenericServices_p, fieldNumber: 409) + try visitor.visitSingularInt32Field(value: _storage._hasPhpClassPrefix_p, fieldNumber: 500) } if _storage._hasPhpMetadataNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasPhpMetadataNamespace_p, fieldNumber: 410) + try visitor.visitSingularInt32Field(value: _storage._hasPhpMetadataNamespace_p, fieldNumber: 501) } if _storage._hasPhpNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasPhpNamespace_p, fieldNumber: 411) + try visitor.visitSingularInt32Field(value: _storage._hasPhpNamespace_p, fieldNumber: 502) } if _storage._hasPositiveIntValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasPositiveIntValue_p, fieldNumber: 412) + try visitor.visitSingularInt32Field(value: _storage._hasPositiveIntValue_p, fieldNumber: 503) } if _storage._hasProto3Optional_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasProto3Optional_p, fieldNumber: 413) + try visitor.visitSingularInt32Field(value: _storage._hasProto3Optional_p, fieldNumber: 504) } if _storage._hasPyGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasPyGenericServices_p, fieldNumber: 414) + try visitor.visitSingularInt32Field(value: _storage._hasPyGenericServices_p, fieldNumber: 505) + } + if _storage._hasRemovalError_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasRemovalError_p, fieldNumber: 506) + } + if _storage._hasRepeated_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasRepeated_p, fieldNumber: 507) + } + if _storage._hasRepeatedFieldEncoding_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasRepeatedFieldEncoding_p, fieldNumber: 508) + } + if _storage._hasReserved_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasReserved_p, fieldNumber: 509) + } + if _storage._hasRetention_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasRetention_p, fieldNumber: 510) } if _storage._hasRubyPackage_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasRubyPackage_p, fieldNumber: 415) + try visitor.visitSingularInt32Field(value: _storage._hasRubyPackage_p, fieldNumber: 511) + } + if _storage._hasSemantic_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasSemantic_p, fieldNumber: 512) } if _storage._hasServerStreaming_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasServerStreaming_p, fieldNumber: 416) + try visitor.visitSingularInt32Field(value: _storage._hasServerStreaming_p, fieldNumber: 513) } if _storage._hasSourceCodeInfo_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasSourceCodeInfo_p, fieldNumber: 417) + try visitor.visitSingularInt32Field(value: _storage._hasSourceCodeInfo_p, fieldNumber: 514) } if _storage._hasSourceContext_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasSourceContext_p, fieldNumber: 418) + try visitor.visitSingularInt32Field(value: _storage._hasSourceContext_p, fieldNumber: 515) } if _storage._hasSourceFile_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasSourceFile_p, fieldNumber: 419) + try visitor.visitSingularInt32Field(value: _storage._hasSourceFile_p, fieldNumber: 516) } if _storage._hasStart_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasStart_p, fieldNumber: 420) + try visitor.visitSingularInt32Field(value: _storage._hasStart_p, fieldNumber: 517) } if _storage._hasStringValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasStringValue_p, fieldNumber: 421) + try visitor.visitSingularInt32Field(value: _storage._hasStringValue_p, fieldNumber: 518) } if _storage._hasSwiftPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasSwiftPrefix_p, fieldNumber: 422) + try visitor.visitSingularInt32Field(value: _storage._hasSwiftPrefix_p, fieldNumber: 519) } if _storage._hasSyntax_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasSyntax_p, fieldNumber: 423) + try visitor.visitSingularInt32Field(value: _storage._hasSyntax_p, fieldNumber: 520) } if _storage._hasTrailingComments_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasTrailingComments_p, fieldNumber: 424) + try visitor.visitSingularInt32Field(value: _storage._hasTrailingComments_p, fieldNumber: 521) } if _storage._hasType_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasType_p, fieldNumber: 425) + try visitor.visitSingularInt32Field(value: _storage._hasType_p, fieldNumber: 522) } if _storage._hasTypeName_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasTypeName_p, fieldNumber: 426) + try visitor.visitSingularInt32Field(value: _storage._hasTypeName_p, fieldNumber: 523) + } + if _storage._hasUnverifiedLazy_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasUnverifiedLazy_p, fieldNumber: 524) + } + if _storage._hasUtf8Validation_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasUtf8Validation_p, fieldNumber: 525) } if _storage._hasValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasValue_p, fieldNumber: 427) + try visitor.visitSingularInt32Field(value: _storage._hasValue_p, fieldNumber: 526) + } + if _storage._hasVerification_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasVerification_p, fieldNumber: 527) + } + if _storage._hasVisibility_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasVisibility_p, fieldNumber: 528) } if _storage._hasWeak_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasWeak_p, fieldNumber: 428) + try visitor.visitSingularInt32Field(value: _storage._hasWeak_p, fieldNumber: 529) } if _storage._hour != 0 { - try visitor.visitSingularInt32Field(value: _storage._hour, fieldNumber: 429) + try visitor.visitSingularInt32Field(value: _storage._hour, fieldNumber: 530) } if _storage._i != 0 { - try visitor.visitSingularInt32Field(value: _storage._i, fieldNumber: 430) + try visitor.visitSingularInt32Field(value: _storage._i, fieldNumber: 531) } if _storage._idempotencyLevel != 0 { - try visitor.visitSingularInt32Field(value: _storage._idempotencyLevel, fieldNumber: 431) + try visitor.visitSingularInt32Field(value: _storage._idempotencyLevel, fieldNumber: 532) } if _storage._identifierValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._identifierValue, fieldNumber: 432) + try visitor.visitSingularInt32Field(value: _storage._identifierValue, fieldNumber: 533) } if _storage._if != 0 { - try visitor.visitSingularInt32Field(value: _storage._if, fieldNumber: 433) + try visitor.visitSingularInt32Field(value: _storage._if, fieldNumber: 534) + } + if _storage._ignoreUnknownExtensionFields != 0 { + try visitor.visitSingularInt32Field(value: _storage._ignoreUnknownExtensionFields, fieldNumber: 535) } if _storage._ignoreUnknownFields != 0 { - try visitor.visitSingularInt32Field(value: _storage._ignoreUnknownFields, fieldNumber: 434) + try visitor.visitSingularInt32Field(value: _storage._ignoreUnknownFields, fieldNumber: 536) } if _storage._index != 0 { - try visitor.visitSingularInt32Field(value: _storage._index, fieldNumber: 435) + try visitor.visitSingularInt32Field(value: _storage._index, fieldNumber: 537) } if _storage._init_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._init_p, fieldNumber: 436) + try visitor.visitSingularInt32Field(value: _storage._init_p, fieldNumber: 538) } if _storage._inout != 0 { - try visitor.visitSingularInt32Field(value: _storage._inout, fieldNumber: 437) + try visitor.visitSingularInt32Field(value: _storage._inout, fieldNumber: 539) } if _storage._inputType != 0 { - try visitor.visitSingularInt32Field(value: _storage._inputType, fieldNumber: 438) + try visitor.visitSingularInt32Field(value: _storage._inputType, fieldNumber: 540) } if _storage._insert != 0 { - try visitor.visitSingularInt32Field(value: _storage._insert, fieldNumber: 439) + try visitor.visitSingularInt32Field(value: _storage._insert, fieldNumber: 541) + } + if _storage._instruction != 0 { + try visitor.visitSingularInt32Field(value: _storage._instruction, fieldNumber: 542) } if _storage._int != 0 { - try visitor.visitSingularInt32Field(value: _storage._int, fieldNumber: 440) + try visitor.visitSingularInt32Field(value: _storage._int, fieldNumber: 543) } if _storage._int32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._int32, fieldNumber: 441) - } - if _storage._int32Value != 0 { - try visitor.visitSingularInt32Field(value: _storage._int32Value, fieldNumber: 442) + try visitor.visitSingularInt32Field(value: _storage._int32, fieldNumber: 544) } if _storage._int64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._int64, fieldNumber: 443) - } - if _storage._int64Value != 0 { - try visitor.visitSingularInt32Field(value: _storage._int64Value, fieldNumber: 444) + try visitor.visitSingularInt32Field(value: _storage._int64, fieldNumber: 545) } if _storage._int8 != 0 { - try visitor.visitSingularInt32Field(value: _storage._int8, fieldNumber: 445) + try visitor.visitSingularInt32Field(value: _storage._int8, fieldNumber: 546) } if _storage._integerLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._integerLiteral, fieldNumber: 446) + try visitor.visitSingularInt32Field(value: _storage._integerLiteral, fieldNumber: 547) } if _storage._integerLiteralType != 0 { - try visitor.visitSingularInt32Field(value: _storage._integerLiteralType, fieldNumber: 447) + try visitor.visitSingularInt32Field(value: _storage._integerLiteralType, fieldNumber: 548) } if _storage._intern != 0 { - try visitor.visitSingularInt32Field(value: _storage._intern, fieldNumber: 448) + try visitor.visitSingularInt32Field(value: _storage._intern, fieldNumber: 549) } if _storage._internal != 0 { - try visitor.visitSingularInt32Field(value: _storage._internal, fieldNumber: 449) + try visitor.visitSingularInt32Field(value: _storage._internal, fieldNumber: 550) } if _storage._internalState != 0 { - try visitor.visitSingularInt32Field(value: _storage._internalState, fieldNumber: 450) + try visitor.visitSingularInt32Field(value: _storage._internalState, fieldNumber: 551) + } + if _storage._intersect != 0 { + try visitor.visitSingularInt32Field(value: _storage._intersect, fieldNumber: 552) } if _storage._into != 0 { - try visitor.visitSingularInt32Field(value: _storage._into, fieldNumber: 451) + try visitor.visitSingularInt32Field(value: _storage._into, fieldNumber: 553) } if _storage._ints != 0 { - try visitor.visitSingularInt32Field(value: _storage._ints, fieldNumber: 452) + try visitor.visitSingularInt32Field(value: _storage._ints, fieldNumber: 554) + } + if _storage._invalidAnyTypeURL != 0 { + try visitor.visitSingularInt32Field(value: _storage._invalidAnyTypeURL, fieldNumber: 555) } if _storage._isA != 0 { - try visitor.visitSingularInt32Field(value: _storage._isA, fieldNumber: 453) + try visitor.visitSingularInt32Field(value: _storage._isA, fieldNumber: 556) } if _storage._isEqual != 0 { - try visitor.visitSingularInt32Field(value: _storage._isEqual, fieldNumber: 454) + try visitor.visitSingularInt32Field(value: _storage._isEqual, fieldNumber: 557) } if _storage._isEqualTo != 0 { - try visitor.visitSingularInt32Field(value: _storage._isEqualTo, fieldNumber: 455) + try visitor.visitSingularInt32Field(value: _storage._isEqualTo, fieldNumber: 558) } if _storage._isExtension != 0 { - try visitor.visitSingularInt32Field(value: _storage._isExtension, fieldNumber: 456) + try visitor.visitSingularInt32Field(value: _storage._isExtension, fieldNumber: 559) } if _storage._isInitialized_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._isInitialized_p, fieldNumber: 457) + try visitor.visitSingularInt32Field(value: _storage._isInitialized_p, fieldNumber: 560) + } + if _storage._isNegative != 0 { + try visitor.visitSingularInt32Field(value: _storage._isNegative, fieldNumber: 561) + } + if _storage._isPathValid != 0 { + try visitor.visitSingularInt32Field(value: _storage._isPathValid, fieldNumber: 562) + } + if _storage._isReserved != 0 { + try visitor.visitSingularInt32Field(value: _storage._isReserved, fieldNumber: 563) + } + if _storage._isValid != 0 { + try visitor.visitSingularInt32Field(value: _storage._isValid, fieldNumber: 564) } if _storage._itemTagsEncodedSize != 0 { - try visitor.visitSingularInt32Field(value: _storage._itemTagsEncodedSize, fieldNumber: 458) + try visitor.visitSingularInt32Field(value: _storage._itemTagsEncodedSize, fieldNumber: 565) } if _storage._iterator != 0 { - try visitor.visitSingularInt32Field(value: _storage._iterator, fieldNumber: 459) - } - if _storage._i2166136261 != 0 { - try visitor.visitSingularInt32Field(value: _storage._i2166136261, fieldNumber: 460) + try visitor.visitSingularInt32Field(value: _storage._iterator, fieldNumber: 566) } if _storage._javaGenerateEqualsAndHash != 0 { - try visitor.visitSingularInt32Field(value: _storage._javaGenerateEqualsAndHash, fieldNumber: 461) + try visitor.visitSingularInt32Field(value: _storage._javaGenerateEqualsAndHash, fieldNumber: 567) } if _storage._javaGenericServices != 0 { - try visitor.visitSingularInt32Field(value: _storage._javaGenericServices, fieldNumber: 462) + try visitor.visitSingularInt32Field(value: _storage._javaGenericServices, fieldNumber: 568) } if _storage._javaMultipleFiles != 0 { - try visitor.visitSingularInt32Field(value: _storage._javaMultipleFiles, fieldNumber: 463) + try visitor.visitSingularInt32Field(value: _storage._javaMultipleFiles, fieldNumber: 569) } if _storage._javaOuterClassname != 0 { - try visitor.visitSingularInt32Field(value: _storage._javaOuterClassname, fieldNumber: 464) + try visitor.visitSingularInt32Field(value: _storage._javaOuterClassname, fieldNumber: 570) } if _storage._javaPackage != 0 { - try visitor.visitSingularInt32Field(value: _storage._javaPackage, fieldNumber: 465) + try visitor.visitSingularInt32Field(value: _storage._javaPackage, fieldNumber: 571) } if _storage._javaStringCheckUtf8 != 0 { - try visitor.visitSingularInt32Field(value: _storage._javaStringCheckUtf8, fieldNumber: 466) + try visitor.visitSingularInt32Field(value: _storage._javaStringCheckUtf8, fieldNumber: 572) } if _storage._jsondecoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsondecoder, fieldNumber: 467) + try visitor.visitSingularInt32Field(value: _storage._jsondecoder, fieldNumber: 573) + } + if _storage._jsondecoding != 0 { + try visitor.visitSingularInt32Field(value: _storage._jsondecoding, fieldNumber: 574) } if _storage._jsondecodingError != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsondecodingError, fieldNumber: 468) + try visitor.visitSingularInt32Field(value: _storage._jsondecodingError, fieldNumber: 575) } if _storage._jsondecodingOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsondecodingOptions, fieldNumber: 469) + try visitor.visitSingularInt32Field(value: _storage._jsondecodingOptions, fieldNumber: 576) } if _storage._jsonEncoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonEncoder, fieldNumber: 470) + try visitor.visitSingularInt32Field(value: _storage._jsonEncoder, fieldNumber: 577) + } + if _storage._jsonencoding != 0 { + try visitor.visitSingularInt32Field(value: _storage._jsonencoding, fieldNumber: 578) } if _storage._jsonencodingError != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonencodingError, fieldNumber: 471) + try visitor.visitSingularInt32Field(value: _storage._jsonencodingError, fieldNumber: 579) } if _storage._jsonencodingOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonencodingOptions, fieldNumber: 472) + try visitor.visitSingularInt32Field(value: _storage._jsonencodingOptions, fieldNumber: 580) } if _storage._jsonencodingVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonencodingVisitor, fieldNumber: 473) + try visitor.visitSingularInt32Field(value: _storage._jsonencodingVisitor, fieldNumber: 581) + } + if _storage._jsonFormat != 0 { + try visitor.visitSingularInt32Field(value: _storage._jsonFormat, fieldNumber: 582) } if _storage._jsonmapEncodingVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonmapEncodingVisitor, fieldNumber: 474) + try visitor.visitSingularInt32Field(value: _storage._jsonmapEncodingVisitor, fieldNumber: 583) } if _storage._jsonName != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonName, fieldNumber: 475) + try visitor.visitSingularInt32Field(value: _storage._jsonName, fieldNumber: 584) } if _storage._jsonPath != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonPath, fieldNumber: 476) + try visitor.visitSingularInt32Field(value: _storage._jsonPath, fieldNumber: 585) } if _storage._jsonPaths != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonPaths, fieldNumber: 477) + try visitor.visitSingularInt32Field(value: _storage._jsonPaths, fieldNumber: 586) } if _storage._jsonscanner != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonscanner, fieldNumber: 478) + try visitor.visitSingularInt32Field(value: _storage._jsonscanner, fieldNumber: 587) } if _storage._jsonString != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonString, fieldNumber: 479) + try visitor.visitSingularInt32Field(value: _storage._jsonString, fieldNumber: 588) } if _storage._jsonText != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonText, fieldNumber: 480) + try visitor.visitSingularInt32Field(value: _storage._jsonText, fieldNumber: 589) + } + if _storage._jsonUtf8Bytes != 0 { + try visitor.visitSingularInt32Field(value: _storage._jsonUtf8Bytes, fieldNumber: 590) } if _storage._jsonUtf8Data != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonUtf8Data, fieldNumber: 481) + try visitor.visitSingularInt32Field(value: _storage._jsonUtf8Data, fieldNumber: 591) } if _storage._jstype != 0 { - try visitor.visitSingularInt32Field(value: _storage._jstype, fieldNumber: 482) + try visitor.visitSingularInt32Field(value: _storage._jstype, fieldNumber: 592) } if _storage._k != 0 { - try visitor.visitSingularInt32Field(value: _storage._k, fieldNumber: 483) + try visitor.visitSingularInt32Field(value: _storage._k, fieldNumber: 593) + } + if _storage._kChunkSize != 0 { + try visitor.visitSingularInt32Field(value: _storage._kChunkSize, fieldNumber: 594) } if _storage._key != 0 { - try visitor.visitSingularInt32Field(value: _storage._key, fieldNumber: 484) + try visitor.visitSingularInt32Field(value: _storage._key, fieldNumber: 595) } if _storage._keyField != 0 { - try visitor.visitSingularInt32Field(value: _storage._keyField, fieldNumber: 485) + try visitor.visitSingularInt32Field(value: _storage._keyField, fieldNumber: 596) + } + if _storage._keyFieldOpt != 0 { + try visitor.visitSingularInt32Field(value: _storage._keyFieldOpt, fieldNumber: 597) } if _storage._keyType != 0 { - try visitor.visitSingularInt32Field(value: _storage._keyType, fieldNumber: 486) + try visitor.visitSingularInt32Field(value: _storage._keyType, fieldNumber: 598) } if _storage._kind != 0 { - try visitor.visitSingularInt32Field(value: _storage._kind, fieldNumber: 487) + try visitor.visitSingularInt32Field(value: _storage._kind, fieldNumber: 599) } if _storage._l != 0 { - try visitor.visitSingularInt32Field(value: _storage._l, fieldNumber: 488) + try visitor.visitSingularInt32Field(value: _storage._l, fieldNumber: 600) } if _storage._label != 0 { - try visitor.visitSingularInt32Field(value: _storage._label, fieldNumber: 489) + try visitor.visitSingularInt32Field(value: _storage._label, fieldNumber: 601) } if _storage._lazy != 0 { - try visitor.visitSingularInt32Field(value: _storage._lazy, fieldNumber: 490) + try visitor.visitSingularInt32Field(value: _storage._lazy, fieldNumber: 602) } if _storage._leadingComments != 0 { - try visitor.visitSingularInt32Field(value: _storage._leadingComments, fieldNumber: 491) + try visitor.visitSingularInt32Field(value: _storage._leadingComments, fieldNumber: 603) } if _storage._leadingDetachedComments != 0 { - try visitor.visitSingularInt32Field(value: _storage._leadingDetachedComments, fieldNumber: 492) + try visitor.visitSingularInt32Field(value: _storage._leadingDetachedComments, fieldNumber: 604) } if _storage._length != 0 { - try visitor.visitSingularInt32Field(value: _storage._length, fieldNumber: 493) + try visitor.visitSingularInt32Field(value: _storage._length, fieldNumber: 605) } if _storage._lessThan != 0 { - try visitor.visitSingularInt32Field(value: _storage._lessThan, fieldNumber: 494) + try visitor.visitSingularInt32Field(value: _storage._lessThan, fieldNumber: 606) } if _storage._let != 0 { - try visitor.visitSingularInt32Field(value: _storage._let, fieldNumber: 495) + try visitor.visitSingularInt32Field(value: _storage._let, fieldNumber: 607) } if _storage._lhs != 0 { - try visitor.visitSingularInt32Field(value: _storage._lhs, fieldNumber: 496) + try visitor.visitSingularInt32Field(value: _storage._lhs, fieldNumber: 608) + } + if _storage._line != 0 { + try visitor.visitSingularInt32Field(value: _storage._line, fieldNumber: 609) } if _storage._list != 0 { - try visitor.visitSingularInt32Field(value: _storage._list, fieldNumber: 497) + try visitor.visitSingularInt32Field(value: _storage._list, fieldNumber: 610) } if _storage._listOfMessages != 0 { - try visitor.visitSingularInt32Field(value: _storage._listOfMessages, fieldNumber: 498) + try visitor.visitSingularInt32Field(value: _storage._listOfMessages, fieldNumber: 611) } if _storage._listValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._listValue, fieldNumber: 499) + try visitor.visitSingularInt32Field(value: _storage._listValue, fieldNumber: 612) } if _storage._littleEndian != 0 { - try visitor.visitSingularInt32Field(value: _storage._littleEndian, fieldNumber: 500) - } - if _storage._littleEndianBytes != 0 { - try visitor.visitSingularInt32Field(value: _storage._littleEndianBytes, fieldNumber: 501) + try visitor.visitSingularInt32Field(value: _storage._littleEndian, fieldNumber: 613) } if _storage._load != 0 { - try visitor.visitSingularInt32Field(value: _storage._load, fieldNumber: 502) + try visitor.visitSingularInt32Field(value: _storage._load, fieldNumber: 614) } if _storage._localHasher != 0 { - try visitor.visitSingularInt32Field(value: _storage._localHasher, fieldNumber: 503) + try visitor.visitSingularInt32Field(value: _storage._localHasher, fieldNumber: 615) } if _storage._location != 0 { - try visitor.visitSingularInt32Field(value: _storage._location, fieldNumber: 504) + try visitor.visitSingularInt32Field(value: _storage._location, fieldNumber: 616) } if _storage._m != 0 { - try visitor.visitSingularInt32Field(value: _storage._m, fieldNumber: 505) + try visitor.visitSingularInt32Field(value: _storage._m, fieldNumber: 617) } if _storage._major != 0 { - try visitor.visitSingularInt32Field(value: _storage._major, fieldNumber: 506) + try visitor.visitSingularInt32Field(value: _storage._major, fieldNumber: 618) + } + if _storage._makeAsyncIterator != 0 { + try visitor.visitSingularInt32Field(value: _storage._makeAsyncIterator, fieldNumber: 619) } if _storage._makeIterator != 0 { - try visitor.visitSingularInt32Field(value: _storage._makeIterator, fieldNumber: 507) + try visitor.visitSingularInt32Field(value: _storage._makeIterator, fieldNumber: 620) } - if _storage._mapEntry != 0 { - try visitor.visitSingularInt32Field(value: _storage._mapEntry, fieldNumber: 508) + if _storage._malformedLength != 0 { + try visitor.visitSingularInt32Field(value: _storage._malformedLength, fieldNumber: 621) } - if _storage._mapHash != 0 { - try visitor.visitSingularInt32Field(value: _storage._mapHash, fieldNumber: 509) + if _storage._mapEntry != 0 { + try visitor.visitSingularInt32Field(value: _storage._mapEntry, fieldNumber: 622) } if _storage._mapKeyType != 0 { - try visitor.visitSingularInt32Field(value: _storage._mapKeyType, fieldNumber: 510) - } - if _storage._mapNameResolver != 0 { - try visitor.visitSingularInt32Field(value: _storage._mapNameResolver, fieldNumber: 511) + try visitor.visitSingularInt32Field(value: _storage._mapKeyType, fieldNumber: 623) } if _storage._mapToMessages != 0 { - try visitor.visitSingularInt32Field(value: _storage._mapToMessages, fieldNumber: 512) + try visitor.visitSingularInt32Field(value: _storage._mapToMessages, fieldNumber: 624) } if _storage._mapValueType != 0 { - try visitor.visitSingularInt32Field(value: _storage._mapValueType, fieldNumber: 513) + try visitor.visitSingularInt32Field(value: _storage._mapValueType, fieldNumber: 625) } if _storage._mapVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._mapVisitor, fieldNumber: 514) + try visitor.visitSingularInt32Field(value: _storage._mapVisitor, fieldNumber: 626) + } + if _storage._mask != 0 { + try visitor.visitSingularInt32Field(value: _storage._mask, fieldNumber: 627) + } + if _storage._maximumEdition != 0 { + try visitor.visitSingularInt32Field(value: _storage._maximumEdition, fieldNumber: 628) } if _storage._mdayStart != 0 { - try visitor.visitSingularInt32Field(value: _storage._mdayStart, fieldNumber: 515) + try visitor.visitSingularInt32Field(value: _storage._mdayStart, fieldNumber: 629) } if _storage._merge != 0 { - try visitor.visitSingularInt32Field(value: _storage._merge, fieldNumber: 516) + try visitor.visitSingularInt32Field(value: _storage._merge, fieldNumber: 630) + } + if _storage._mergeOptions != 0 { + try visitor.visitSingularInt32Field(value: _storage._mergeOptions, fieldNumber: 631) } if _storage._message != 0 { - try visitor.visitSingularInt32Field(value: _storage._message, fieldNumber: 517) + try visitor.visitSingularInt32Field(value: _storage._message, fieldNumber: 632) } if _storage._messageDepthLimit != 0 { - try visitor.visitSingularInt32Field(value: _storage._messageDepthLimit, fieldNumber: 518) + try visitor.visitSingularInt32Field(value: _storage._messageDepthLimit, fieldNumber: 633) + } + if _storage._messageEncoding != 0 { + try visitor.visitSingularInt32Field(value: _storage._messageEncoding, fieldNumber: 634) } if _storage._messageExtension != 0 { - try visitor.visitSingularInt32Field(value: _storage._messageExtension, fieldNumber: 519) + try visitor.visitSingularInt32Field(value: _storage._messageExtension, fieldNumber: 635) } if _storage._messageImplementationBase != 0 { - try visitor.visitSingularInt32Field(value: _storage._messageImplementationBase, fieldNumber: 520) - } - if _storage._messageOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._messageOptions, fieldNumber: 521) + try visitor.visitSingularInt32Field(value: _storage._messageImplementationBase, fieldNumber: 636) } if _storage._messageSet != 0 { - try visitor.visitSingularInt32Field(value: _storage._messageSet, fieldNumber: 522) + try visitor.visitSingularInt32Field(value: _storage._messageSet, fieldNumber: 637) } if _storage._messageSetWireFormat != 0 { - try visitor.visitSingularInt32Field(value: _storage._messageSetWireFormat, fieldNumber: 523) + try visitor.visitSingularInt32Field(value: _storage._messageSetWireFormat, fieldNumber: 638) + } + if _storage._messageSize != 0 { + try visitor.visitSingularInt32Field(value: _storage._messageSize, fieldNumber: 639) } if _storage._messageType != 0 { - try visitor.visitSingularInt32Field(value: _storage._messageType, fieldNumber: 524) + try visitor.visitSingularInt32Field(value: _storage._messageType, fieldNumber: 640) } if _storage._method != 0 { - try visitor.visitSingularInt32Field(value: _storage._method, fieldNumber: 525) + try visitor.visitSingularInt32Field(value: _storage._method, fieldNumber: 641) } - if _storage._methodDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._methodDescriptorProto, fieldNumber: 526) + if _storage._methods != 0 { + try visitor.visitSingularInt32Field(value: _storage._methods, fieldNumber: 642) } - if _storage._methodOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._methodOptions, fieldNumber: 527) + if _storage._min != 0 { + try visitor.visitSingularInt32Field(value: _storage._min, fieldNumber: 643) } - if _storage._methods != 0 { - try visitor.visitSingularInt32Field(value: _storage._methods, fieldNumber: 528) + if _storage._minimumEdition != 0 { + try visitor.visitSingularInt32Field(value: _storage._minimumEdition, fieldNumber: 644) } if _storage._minor != 0 { - try visitor.visitSingularInt32Field(value: _storage._minor, fieldNumber: 529) - } - if _storage._mixin != 0 { - try visitor.visitSingularInt32Field(value: _storage._mixin, fieldNumber: 530) + try visitor.visitSingularInt32Field(value: _storage._minor, fieldNumber: 645) } if _storage._mixins != 0 { - try visitor.visitSingularInt32Field(value: _storage._mixins, fieldNumber: 531) - } - if _storage._modifier != 0 { - try visitor.visitSingularInt32Field(value: _storage._modifier, fieldNumber: 532) + try visitor.visitSingularInt32Field(value: _storage._mixins, fieldNumber: 646) } if _storage._modify != 0 { - try visitor.visitSingularInt32Field(value: _storage._modify, fieldNumber: 533) + try visitor.visitSingularInt32Field(value: _storage._modify, fieldNumber: 647) } if _storage._month != 0 { - try visitor.visitSingularInt32Field(value: _storage._month, fieldNumber: 534) + try visitor.visitSingularInt32Field(value: _storage._month, fieldNumber: 648) } if _storage._msgExtension != 0 { - try visitor.visitSingularInt32Field(value: _storage._msgExtension, fieldNumber: 535) + try visitor.visitSingularInt32Field(value: _storage._msgExtension, fieldNumber: 649) } if _storage._mutating != 0 { - try visitor.visitSingularInt32Field(value: _storage._mutating, fieldNumber: 536) + try visitor.visitSingularInt32Field(value: _storage._mutating, fieldNumber: 650) } if _storage._n != 0 { - try visitor.visitSingularInt32Field(value: _storage._n, fieldNumber: 537) + try visitor.visitSingularInt32Field(value: _storage._n, fieldNumber: 651) } if _storage._name != 0 { - try visitor.visitSingularInt32Field(value: _storage._name, fieldNumber: 538) + try visitor.visitSingularInt32Field(value: _storage._name, fieldNumber: 652) } if _storage._nameDescription != 0 { - try visitor.visitSingularInt32Field(value: _storage._nameDescription, fieldNumber: 539) + try visitor.visitSingularInt32Field(value: _storage._nameDescription, fieldNumber: 653) } if _storage._nameMap != 0 { - try visitor.visitSingularInt32Field(value: _storage._nameMap, fieldNumber: 540) + try visitor.visitSingularInt32Field(value: _storage._nameMap, fieldNumber: 654) } if _storage._namePart != 0 { - try visitor.visitSingularInt32Field(value: _storage._namePart, fieldNumber: 541) - } - if _storage._nameResolver != 0 { - try visitor.visitSingularInt32Field(value: _storage._nameResolver, fieldNumber: 542) + try visitor.visitSingularInt32Field(value: _storage._namePart, fieldNumber: 655) } if _storage._names != 0 { - try visitor.visitSingularInt32Field(value: _storage._names, fieldNumber: 543) + try visitor.visitSingularInt32Field(value: _storage._names, fieldNumber: 656) } if _storage._nanos != 0 { - try visitor.visitSingularInt32Field(value: _storage._nanos, fieldNumber: 544) - } - if _storage._nativeBytes != 0 { - try visitor.visitSingularInt32Field(value: _storage._nativeBytes, fieldNumber: 545) - } - if _storage._nativeEndianBytes != 0 { - try visitor.visitSingularInt32Field(value: _storage._nativeEndianBytes, fieldNumber: 546) + try visitor.visitSingularInt32Field(value: _storage._nanos, fieldNumber: 657) } if _storage._negativeIntValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._negativeIntValue, fieldNumber: 547) + try visitor.visitSingularInt32Field(value: _storage._negativeIntValue, fieldNumber: 658) } if _storage._nestedType != 0 { - try visitor.visitSingularInt32Field(value: _storage._nestedType, fieldNumber: 548) + try visitor.visitSingularInt32Field(value: _storage._nestedType, fieldNumber: 659) + } + if _storage._newExtensible != 0 { + try visitor.visitSingularInt32Field(value: _storage._newExtensible, fieldNumber: 660) } if _storage._newL != 0 { - try visitor.visitSingularInt32Field(value: _storage._newL, fieldNumber: 549) + try visitor.visitSingularInt32Field(value: _storage._newL, fieldNumber: 661) } if _storage._newList != 0 { - try visitor.visitSingularInt32Field(value: _storage._newList, fieldNumber: 550) + try visitor.visitSingularInt32Field(value: _storage._newList, fieldNumber: 662) + } + if _storage._newMessage != 0 { + try visitor.visitSingularInt32Field(value: _storage._newMessage, fieldNumber: 663) } if _storage._newValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._newValue, fieldNumber: 551) + try visitor.visitSingularInt32Field(value: _storage._newValue, fieldNumber: 664) + } + if _storage._next != 0 { + try visitor.visitSingularInt32Field(value: _storage._next, fieldNumber: 665) } if _storage._nextByte != 0 { - try visitor.visitSingularInt32Field(value: _storage._nextByte, fieldNumber: 552) + try visitor.visitSingularInt32Field(value: _storage._nextByte, fieldNumber: 666) } if _storage._nextFieldNumber != 0 { - try visitor.visitSingularInt32Field(value: _storage._nextFieldNumber, fieldNumber: 553) + try visitor.visitSingularInt32Field(value: _storage._nextFieldNumber, fieldNumber: 667) + } + if _storage._nextInstruction != 0 { + try visitor.visitSingularInt32Field(value: _storage._nextInstruction, fieldNumber: 668) + } + if _storage._nextInt32 != 0 { + try visitor.visitSingularInt32Field(value: _storage._nextInt32, fieldNumber: 669) + } + if _storage._nextNullTerminatedString != 0 { + try visitor.visitSingularInt32Field(value: _storage._nextNullTerminatedString, fieldNumber: 670) + } + if _storage._nextNullTerminatedStringArray != 0 { + try visitor.visitSingularInt32Field(value: _storage._nextNullTerminatedStringArray, fieldNumber: 671) + } + if _storage._nextNumber != 0 { + try visitor.visitSingularInt32Field(value: _storage._nextNumber, fieldNumber: 672) + } + if _storage._nextUint64 != 0 { + try visitor.visitSingularInt32Field(value: _storage._nextUint64, fieldNumber: 673) + } + if _storage._nextVarInt != 0 { + try visitor.visitSingularInt32Field(value: _storage._nextVarInt, fieldNumber: 674) } if _storage._nil != 0 { - try visitor.visitSingularInt32Field(value: _storage._nil, fieldNumber: 554) + try visitor.visitSingularInt32Field(value: _storage._nil, fieldNumber: 675) } if _storage._nilLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._nilLiteral, fieldNumber: 555) + try visitor.visitSingularInt32Field(value: _storage._nilLiteral, fieldNumber: 676) + } + if _storage._noBytesAvailable != 0 { + try visitor.visitSingularInt32Field(value: _storage._noBytesAvailable, fieldNumber: 677) } if _storage._noStandardDescriptorAccessor != 0 { - try visitor.visitSingularInt32Field(value: _storage._noStandardDescriptorAccessor, fieldNumber: 556) + try visitor.visitSingularInt32Field(value: _storage._noStandardDescriptorAccessor, fieldNumber: 678) } if _storage._nullValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._nullValue, fieldNumber: 557) + try visitor.visitSingularInt32Field(value: _storage._nullValue, fieldNumber: 679) } if _storage._number != 0 { - try visitor.visitSingularInt32Field(value: _storage._number, fieldNumber: 558) + try visitor.visitSingularInt32Field(value: _storage._number, fieldNumber: 680) } if _storage._numberValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._numberValue, fieldNumber: 559) + try visitor.visitSingularInt32Field(value: _storage._numberValue, fieldNumber: 681) } if _storage._objcClassPrefix != 0 { - try visitor.visitSingularInt32Field(value: _storage._objcClassPrefix, fieldNumber: 560) + try visitor.visitSingularInt32Field(value: _storage._objcClassPrefix, fieldNumber: 682) } if _storage._of != 0 { - try visitor.visitSingularInt32Field(value: _storage._of, fieldNumber: 561) + try visitor.visitSingularInt32Field(value: _storage._of, fieldNumber: 683) } - if _storage._oneofDecl != 0 { - try visitor.visitSingularInt32Field(value: _storage._oneofDecl, fieldNumber: 562) + if _storage._oneOfKind != 0 { + try visitor.visitSingularInt32Field(value: _storage._oneOfKind, fieldNumber: 684) } - if _storage._oneofDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._oneofDescriptorProto, fieldNumber: 563) + if _storage._oneofDecl != 0 { + try visitor.visitSingularInt32Field(value: _storage._oneofDecl, fieldNumber: 685) } if _storage._oneofIndex != 0 { - try visitor.visitSingularInt32Field(value: _storage._oneofIndex, fieldNumber: 564) - } - if _storage._oneofOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._oneofOptions, fieldNumber: 565) + try visitor.visitSingularInt32Field(value: _storage._oneofIndex, fieldNumber: 686) } if _storage._oneofs != 0 { - try visitor.visitSingularInt32Field(value: _storage._oneofs, fieldNumber: 566) - } - if _storage._oneOfKind != 0 { - try visitor.visitSingularInt32Field(value: _storage._oneOfKind, fieldNumber: 567) + try visitor.visitSingularInt32Field(value: _storage._oneofs, fieldNumber: 687) } if _storage._optimizeFor != 0 { - try visitor.visitSingularInt32Field(value: _storage._optimizeFor, fieldNumber: 568) + try visitor.visitSingularInt32Field(value: _storage._optimizeFor, fieldNumber: 688) } if _storage._optimizeMode != 0 { - try visitor.visitSingularInt32Field(value: _storage._optimizeMode, fieldNumber: 569) - } - if _storage._option != 0 { - try visitor.visitSingularInt32Field(value: _storage._option, fieldNumber: 570) + try visitor.visitSingularInt32Field(value: _storage._optimizeMode, fieldNumber: 689) } if _storage._optionalEnumExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._optionalEnumExtensionField, fieldNumber: 571) + try visitor.visitSingularInt32Field(value: _storage._optionalEnumExtensionField, fieldNumber: 690) } if _storage._optionalExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._optionalExtensionField, fieldNumber: 572) + try visitor.visitSingularInt32Field(value: _storage._optionalExtensionField, fieldNumber: 691) } if _storage._optionalGroupExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._optionalGroupExtensionField, fieldNumber: 573) + try visitor.visitSingularInt32Field(value: _storage._optionalGroupExtensionField, fieldNumber: 692) } if _storage._optionalMessageExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._optionalMessageExtensionField, fieldNumber: 574) + try visitor.visitSingularInt32Field(value: _storage._optionalMessageExtensionField, fieldNumber: 693) + } + if _storage._optionDependency != 0 { + try visitor.visitSingularInt32Field(value: _storage._optionDependency, fieldNumber: 694) + } + if _storage._optionRetention != 0 { + try visitor.visitSingularInt32Field(value: _storage._optionRetention, fieldNumber: 695) } if _storage._options != 0 { - try visitor.visitSingularInt32Field(value: _storage._options, fieldNumber: 575) + try visitor.visitSingularInt32Field(value: _storage._options, fieldNumber: 696) + } + if _storage._optionTargetType != 0 { + try visitor.visitSingularInt32Field(value: _storage._optionTargetType, fieldNumber: 697) } if _storage._other != 0 { - try visitor.visitSingularInt32Field(value: _storage._other, fieldNumber: 576) + try visitor.visitSingularInt32Field(value: _storage._other, fieldNumber: 698) } if _storage._others != 0 { - try visitor.visitSingularInt32Field(value: _storage._others, fieldNumber: 577) + try visitor.visitSingularInt32Field(value: _storage._others, fieldNumber: 699) } if _storage._out != 0 { - try visitor.visitSingularInt32Field(value: _storage._out, fieldNumber: 578) + try visitor.visitSingularInt32Field(value: _storage._out, fieldNumber: 700) } if _storage._outputType != 0 { - try visitor.visitSingularInt32Field(value: _storage._outputType, fieldNumber: 579) + try visitor.visitSingularInt32Field(value: _storage._outputType, fieldNumber: 701) + } + if _storage._overridableFeatures != 0 { + try visitor.visitSingularInt32Field(value: _storage._overridableFeatures, fieldNumber: 702) } if _storage._p != 0 { - try visitor.visitSingularInt32Field(value: _storage._p, fieldNumber: 580) + try visitor.visitSingularInt32Field(value: _storage._p, fieldNumber: 703) } if _storage._package != 0 { - try visitor.visitSingularInt32Field(value: _storage._package, fieldNumber: 581) + try visitor.visitSingularInt32Field(value: _storage._package, fieldNumber: 704) } if _storage._packed != 0 { - try visitor.visitSingularInt32Field(value: _storage._packed, fieldNumber: 582) + try visitor.visitSingularInt32Field(value: _storage._packed, fieldNumber: 705) } if _storage._packedEnumExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._packedEnumExtensionField, fieldNumber: 583) + try visitor.visitSingularInt32Field(value: _storage._packedEnumExtensionField, fieldNumber: 706) } if _storage._packedExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._packedExtensionField, fieldNumber: 584) + try visitor.visitSingularInt32Field(value: _storage._packedExtensionField, fieldNumber: 707) } if _storage._padding != 0 { - try visitor.visitSingularInt32Field(value: _storage._padding, fieldNumber: 585) + try visitor.visitSingularInt32Field(value: _storage._padding, fieldNumber: 708) } if _storage._parent != 0 { - try visitor.visitSingularInt32Field(value: _storage._parent, fieldNumber: 586) + try visitor.visitSingularInt32Field(value: _storage._parent, fieldNumber: 709) } if _storage._parse != 0 { - try visitor.visitSingularInt32Field(value: _storage._parse, fieldNumber: 587) + try visitor.visitSingularInt32Field(value: _storage._parse, fieldNumber: 710) } if _storage._partial != 0 { - try visitor.visitSingularInt32Field(value: _storage._partial, fieldNumber: 588) + try visitor.visitSingularInt32Field(value: _storage._partial, fieldNumber: 711) } if _storage._path != 0 { - try visitor.visitSingularInt32Field(value: _storage._path, fieldNumber: 589) + try visitor.visitSingularInt32Field(value: _storage._path, fieldNumber: 712) + } + if _storage._pathDecoder != 0 { + try visitor.visitSingularInt32Field(value: _storage._pathDecoder, fieldNumber: 713) + } + if _storage._pathDecodingError != 0 { + try visitor.visitSingularInt32Field(value: _storage._pathDecodingError, fieldNumber: 714) } if _storage._paths != 0 { - try visitor.visitSingularInt32Field(value: _storage._paths, fieldNumber: 590) + try visitor.visitSingularInt32Field(value: _storage._paths, fieldNumber: 715) + } + if _storage._pathVisitor != 0 { + try visitor.visitSingularInt32Field(value: _storage._pathVisitor, fieldNumber: 716) } if _storage._payload != 0 { - try visitor.visitSingularInt32Field(value: _storage._payload, fieldNumber: 591) + try visitor.visitSingularInt32Field(value: _storage._payload, fieldNumber: 717) } if _storage._payloadSize != 0 { - try visitor.visitSingularInt32Field(value: _storage._payloadSize, fieldNumber: 592) + try visitor.visitSingularInt32Field(value: _storage._payloadSize, fieldNumber: 718) } if _storage._phpClassPrefix != 0 { - try visitor.visitSingularInt32Field(value: _storage._phpClassPrefix, fieldNumber: 593) - } - if _storage._phpGenericServices != 0 { - try visitor.visitSingularInt32Field(value: _storage._phpGenericServices, fieldNumber: 594) + try visitor.visitSingularInt32Field(value: _storage._phpClassPrefix, fieldNumber: 719) } if _storage._phpMetadataNamespace != 0 { - try visitor.visitSingularInt32Field(value: _storage._phpMetadataNamespace, fieldNumber: 595) + try visitor.visitSingularInt32Field(value: _storage._phpMetadataNamespace, fieldNumber: 720) } if _storage._phpNamespace != 0 { - try visitor.visitSingularInt32Field(value: _storage._phpNamespace, fieldNumber: 596) - } - if _storage._pointer != 0 { - try visitor.visitSingularInt32Field(value: _storage._pointer, fieldNumber: 597) + try visitor.visitSingularInt32Field(value: _storage._phpNamespace, fieldNumber: 721) } if _storage._pos != 0 { - try visitor.visitSingularInt32Field(value: _storage._pos, fieldNumber: 598) + try visitor.visitSingularInt32Field(value: _storage._pos, fieldNumber: 722) } if _storage._positiveIntValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._positiveIntValue, fieldNumber: 599) + try visitor.visitSingularInt32Field(value: _storage._positiveIntValue, fieldNumber: 723) } if _storage._prefix != 0 { - try visitor.visitSingularInt32Field(value: _storage._prefix, fieldNumber: 600) + try visitor.visitSingularInt32Field(value: _storage._prefix, fieldNumber: 724) } if _storage._preserveProtoFieldNames != 0 { - try visitor.visitSingularInt32Field(value: _storage._preserveProtoFieldNames, fieldNumber: 601) + try visitor.visitSingularInt32Field(value: _storage._preserveProtoFieldNames, fieldNumber: 725) } if _storage._preTraverse != 0 { - try visitor.visitSingularInt32Field(value: _storage._preTraverse, fieldNumber: 602) + try visitor.visitSingularInt32Field(value: _storage._preTraverse, fieldNumber: 726) + } + if _storage._previousNumber != 0 { + try visitor.visitSingularInt32Field(value: _storage._previousNumber, fieldNumber: 727) + } + if _storage._prevPath != 0 { + try visitor.visitSingularInt32Field(value: _storage._prevPath, fieldNumber: 728) } if _storage._printUnknownFields != 0 { - try visitor.visitSingularInt32Field(value: _storage._printUnknownFields, fieldNumber: 603) + try visitor.visitSingularInt32Field(value: _storage._printUnknownFields, fieldNumber: 729) + } + if _storage._programBuffer != 0 { + try visitor.visitSingularInt32Field(value: _storage._programBuffer, fieldNumber: 730) + } + if _storage._programFormat != 0 { + try visitor.visitSingularInt32Field(value: _storage._programFormat, fieldNumber: 731) } if _storage._proto2 != 0 { - try visitor.visitSingularInt32Field(value: _storage._proto2, fieldNumber: 604) + try visitor.visitSingularInt32Field(value: _storage._proto2, fieldNumber: 732) } if _storage._proto3DefaultValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._proto3DefaultValue, fieldNumber: 605) + try visitor.visitSingularInt32Field(value: _storage._proto3DefaultValue, fieldNumber: 733) } if _storage._proto3Optional != 0 { - try visitor.visitSingularInt32Field(value: _storage._proto3Optional, fieldNumber: 606) + try visitor.visitSingularInt32Field(value: _storage._proto3Optional, fieldNumber: 734) } - if _storage._protobufApiversionCheck != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufApiversionCheck, fieldNumber: 607) + if _storage._protobufExtensionFieldValues != 0 { + try visitor.visitSingularInt32Field(value: _storage._protobufExtensionFieldValues, fieldNumber: 735) + } + if _storage._protobufFieldNumber != 0 { + try visitor.visitSingularInt32Field(value: _storage._protobufFieldNumber, fieldNumber: 736) + } + if _storage._protobufGeneratedIsEqualTo != 0 { + try visitor.visitSingularInt32Field(value: _storage._protobufGeneratedIsEqualTo, fieldNumber: 737) + } + if _storage._protobufNameMap != 0 { + try visitor.visitSingularInt32Field(value: _storage._protobufNameMap, fieldNumber: 738) + } + if _storage._protobufNewField != 0 { + try visitor.visitSingularInt32Field(value: _storage._protobufNewField, fieldNumber: 739) + } + if _storage._protobufPackage != 0 { + try visitor.visitSingularInt32Field(value: _storage._protobufPackage, fieldNumber: 740) } if _storage._protobufApiversion2 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufApiversion2, fieldNumber: 608) + try visitor.visitSingularInt32Field(value: _storage._protobufApiversion2, fieldNumber: 741) + } + if _storage._protobufApiversionCheck != 0 { + try visitor.visitSingularInt32Field(value: _storage._protobufApiversionCheck, fieldNumber: 742) } if _storage._protobufBool != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufBool, fieldNumber: 609) + try visitor.visitSingularInt32Field(value: _storage._protobufBool, fieldNumber: 743) } if _storage._protobufBytes != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufBytes, fieldNumber: 610) + try visitor.visitSingularInt32Field(value: _storage._protobufBytes, fieldNumber: 744) + } + if _storage._protobufData != 0 { + try visitor.visitSingularInt32Field(value: _storage._protobufData, fieldNumber: 745) } if _storage._protobufDouble != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufDouble, fieldNumber: 611) + try visitor.visitSingularInt32Field(value: _storage._protobufDouble, fieldNumber: 746) } if _storage._protobufEnumMap != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufEnumMap, fieldNumber: 612) + try visitor.visitSingularInt32Field(value: _storage._protobufEnumMap, fieldNumber: 747) } if _storage._protobufExtension != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufExtension, fieldNumber: 613) + try visitor.visitSingularInt32Field(value: _storage._protobufExtension, fieldNumber: 748) } if _storage._protobufFixed32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufFixed32, fieldNumber: 614) + try visitor.visitSingularInt32Field(value: _storage._protobufFixed32, fieldNumber: 749) } if _storage._protobufFixed64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufFixed64, fieldNumber: 615) + try visitor.visitSingularInt32Field(value: _storage._protobufFixed64, fieldNumber: 750) } if _storage._protobufFloat != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufFloat, fieldNumber: 616) + try visitor.visitSingularInt32Field(value: _storage._protobufFloat, fieldNumber: 751) } if _storage._protobufInt32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufInt32, fieldNumber: 617) + try visitor.visitSingularInt32Field(value: _storage._protobufInt32, fieldNumber: 752) } if _storage._protobufInt64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufInt64, fieldNumber: 618) + try visitor.visitSingularInt32Field(value: _storage._protobufInt64, fieldNumber: 753) } if _storage._protobufMap != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufMap, fieldNumber: 619) + try visitor.visitSingularInt32Field(value: _storage._protobufMap, fieldNumber: 754) } if _storage._protobufMessageMap != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufMessageMap, fieldNumber: 620) + try visitor.visitSingularInt32Field(value: _storage._protobufMessageMap, fieldNumber: 755) } if _storage._protobufSfixed32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufSfixed32, fieldNumber: 621) + try visitor.visitSingularInt32Field(value: _storage._protobufSfixed32, fieldNumber: 756) } if _storage._protobufSfixed64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufSfixed64, fieldNumber: 622) + try visitor.visitSingularInt32Field(value: _storage._protobufSfixed64, fieldNumber: 757) } if _storage._protobufSint32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufSint32, fieldNumber: 623) + try visitor.visitSingularInt32Field(value: _storage._protobufSint32, fieldNumber: 758) } if _storage._protobufSint64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufSint64, fieldNumber: 624) + try visitor.visitSingularInt32Field(value: _storage._protobufSint64, fieldNumber: 759) } if _storage._protobufString != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufString, fieldNumber: 625) + try visitor.visitSingularInt32Field(value: _storage._protobufString, fieldNumber: 760) } if _storage._protobufUint32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufUint32, fieldNumber: 626) + try visitor.visitSingularInt32Field(value: _storage._protobufUint32, fieldNumber: 761) } if _storage._protobufUint64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufUint64, fieldNumber: 627) - } - if _storage._protobufExtensionFieldValues != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufExtensionFieldValues, fieldNumber: 628) - } - if _storage._protobufFieldNumber != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufFieldNumber, fieldNumber: 629) - } - if _storage._protobufGeneratedIsEqualTo != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufGeneratedIsEqualTo, fieldNumber: 630) - } - if _storage._protobufNameMap != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufNameMap, fieldNumber: 631) - } - if _storage._protobufNewField != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufNewField, fieldNumber: 632) - } - if _storage._protobufPackage != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufPackage, fieldNumber: 633) + try visitor.visitSingularInt32Field(value: _storage._protobufUint64, fieldNumber: 762) } if _storage._protocol != 0 { - try visitor.visitSingularInt32Field(value: _storage._protocol, fieldNumber: 634) + try visitor.visitSingularInt32Field(value: _storage._protocol, fieldNumber: 763) } if _storage._protoFieldName != 0 { - try visitor.visitSingularInt32Field(value: _storage._protoFieldName, fieldNumber: 635) + try visitor.visitSingularInt32Field(value: _storage._protoFieldName, fieldNumber: 764) } if _storage._protoMessageName != 0 { - try visitor.visitSingularInt32Field(value: _storage._protoMessageName, fieldNumber: 636) + try visitor.visitSingularInt32Field(value: _storage._protoMessageName, fieldNumber: 765) } if _storage._protoNameProviding != 0 { - try visitor.visitSingularInt32Field(value: _storage._protoNameProviding, fieldNumber: 637) + try visitor.visitSingularInt32Field(value: _storage._protoNameProviding, fieldNumber: 766) } if _storage._protoPaths != 0 { - try visitor.visitSingularInt32Field(value: _storage._protoPaths, fieldNumber: 638) + try visitor.visitSingularInt32Field(value: _storage._protoPaths, fieldNumber: 767) } if _storage._public != 0 { - try visitor.visitSingularInt32Field(value: _storage._public, fieldNumber: 639) + try visitor.visitSingularInt32Field(value: _storage._public, fieldNumber: 768) } if _storage._publicDependency != 0 { - try visitor.visitSingularInt32Field(value: _storage._publicDependency, fieldNumber: 640) + try visitor.visitSingularInt32Field(value: _storage._publicDependency, fieldNumber: 769) } if _storage._putBoolValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._putBoolValue, fieldNumber: 641) + try visitor.visitSingularInt32Field(value: _storage._putBoolValue, fieldNumber: 770) } if _storage._putBytesValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._putBytesValue, fieldNumber: 642) + try visitor.visitSingularInt32Field(value: _storage._putBytesValue, fieldNumber: 771) } if _storage._putDoubleValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._putDoubleValue, fieldNumber: 643) + try visitor.visitSingularInt32Field(value: _storage._putDoubleValue, fieldNumber: 772) } if _storage._putEnumValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._putEnumValue, fieldNumber: 644) + try visitor.visitSingularInt32Field(value: _storage._putEnumValue, fieldNumber: 773) } if _storage._putFixedUint32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._putFixedUint32, fieldNumber: 645) + try visitor.visitSingularInt32Field(value: _storage._putFixedUint32, fieldNumber: 774) } if _storage._putFixedUint64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._putFixedUint64, fieldNumber: 646) + try visitor.visitSingularInt32Field(value: _storage._putFixedUint64, fieldNumber: 775) } if _storage._putFloatValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._putFloatValue, fieldNumber: 647) + try visitor.visitSingularInt32Field(value: _storage._putFloatValue, fieldNumber: 776) } if _storage._putInt64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._putInt64, fieldNumber: 648) + try visitor.visitSingularInt32Field(value: _storage._putInt64, fieldNumber: 777) } if _storage._putStringValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._putStringValue, fieldNumber: 649) + try visitor.visitSingularInt32Field(value: _storage._putStringValue, fieldNumber: 778) } if _storage._putUint64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._putUint64, fieldNumber: 650) + try visitor.visitSingularInt32Field(value: _storage._putUint64, fieldNumber: 779) } if _storage._putUint64Hex != 0 { - try visitor.visitSingularInt32Field(value: _storage._putUint64Hex, fieldNumber: 651) + try visitor.visitSingularInt32Field(value: _storage._putUint64Hex, fieldNumber: 780) } if _storage._putVarInt != 0 { - try visitor.visitSingularInt32Field(value: _storage._putVarInt, fieldNumber: 652) + try visitor.visitSingularInt32Field(value: _storage._putVarInt, fieldNumber: 781) } if _storage._putZigZagVarInt != 0 { - try visitor.visitSingularInt32Field(value: _storage._putZigZagVarInt, fieldNumber: 653) + try visitor.visitSingularInt32Field(value: _storage._putZigZagVarInt, fieldNumber: 782) } if _storage._pyGenericServices != 0 { - try visitor.visitSingularInt32Field(value: _storage._pyGenericServices, fieldNumber: 654) + try visitor.visitSingularInt32Field(value: _storage._pyGenericServices, fieldNumber: 783) + } + if _storage._r != 0 { + try visitor.visitSingularInt32Field(value: _storage._r, fieldNumber: 784) } if _storage._rawChars != 0 { - try visitor.visitSingularInt32Field(value: _storage._rawChars, fieldNumber: 655) + try visitor.visitSingularInt32Field(value: _storage._rawChars, fieldNumber: 785) } if _storage._rawRepresentable != 0 { - try visitor.visitSingularInt32Field(value: _storage._rawRepresentable, fieldNumber: 656) + try visitor.visitSingularInt32Field(value: _storage._rawRepresentable, fieldNumber: 786) } if _storage._rawValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._rawValue, fieldNumber: 657) + try visitor.visitSingularInt32Field(value: _storage._rawValue, fieldNumber: 787) } if _storage._read4HexDigits != 0 { - try visitor.visitSingularInt32Field(value: _storage._read4HexDigits, fieldNumber: 658) + try visitor.visitSingularInt32Field(value: _storage._read4HexDigits, fieldNumber: 788) + } + if _storage._readBytes != 0 { + try visitor.visitSingularInt32Field(value: _storage._readBytes, fieldNumber: 789) + } + if _storage._reader != 0 { + try visitor.visitSingularInt32Field(value: _storage._reader, fieldNumber: 790) } if _storage._register != 0 { - try visitor.visitSingularInt32Field(value: _storage._register, fieldNumber: 659) + try visitor.visitSingularInt32Field(value: _storage._register, fieldNumber: 791) + } + if _storage._remainingProgram != 0 { + try visitor.visitSingularInt32Field(value: _storage._remainingProgram, fieldNumber: 792) + } + if _storage._removalError != 0 { + try visitor.visitSingularInt32Field(value: _storage._removalError, fieldNumber: 793) + } + if _storage._removingAllFieldsOf != 0 { + try visitor.visitSingularInt32Field(value: _storage._removingAllFieldsOf, fieldNumber: 794) + } + if _storage._repeated != 0 { + try visitor.visitSingularInt32Field(value: _storage._repeated, fieldNumber: 795) } if _storage._repeatedEnumExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._repeatedEnumExtensionField, fieldNumber: 660) + try visitor.visitSingularInt32Field(value: _storage._repeatedEnumExtensionField, fieldNumber: 796) } if _storage._repeatedExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._repeatedExtensionField, fieldNumber: 661) + try visitor.visitSingularInt32Field(value: _storage._repeatedExtensionField, fieldNumber: 797) + } + if _storage._repeatedFieldEncoding != 0 { + try visitor.visitSingularInt32Field(value: _storage._repeatedFieldEncoding, fieldNumber: 798) } if _storage._repeatedGroupExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._repeatedGroupExtensionField, fieldNumber: 662) + try visitor.visitSingularInt32Field(value: _storage._repeatedGroupExtensionField, fieldNumber: 799) } if _storage._repeatedMessageExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._repeatedMessageExtensionField, fieldNumber: 663) + try visitor.visitSingularInt32Field(value: _storage._repeatedMessageExtensionField, fieldNumber: 800) + } + if _storage._repeating != 0 { + try visitor.visitSingularInt32Field(value: _storage._repeating, fieldNumber: 801) + } + if _storage._replaceRepeatedFields != 0 { + try visitor.visitSingularInt32Field(value: _storage._replaceRepeatedFields, fieldNumber: 802) } if _storage._requestStreaming != 0 { - try visitor.visitSingularInt32Field(value: _storage._requestStreaming, fieldNumber: 664) + try visitor.visitSingularInt32Field(value: _storage._requestStreaming, fieldNumber: 803) } if _storage._requestTypeURL != 0 { - try visitor.visitSingularInt32Field(value: _storage._requestTypeURL, fieldNumber: 665) + try visitor.visitSingularInt32Field(value: _storage._requestTypeURL, fieldNumber: 804) } if _storage._requiredSize != 0 { - try visitor.visitSingularInt32Field(value: _storage._requiredSize, fieldNumber: 666) - } - if _storage._reservedName != 0 { - try visitor.visitSingularInt32Field(value: _storage._reservedName, fieldNumber: 667) - } - if _storage._reservedRange != 0 { - try visitor.visitSingularInt32Field(value: _storage._reservedRange, fieldNumber: 668) + try visitor.visitSingularInt32Field(value: _storage._requiredSize, fieldNumber: 805) } if _storage._responseStreaming != 0 { - try visitor.visitSingularInt32Field(value: _storage._responseStreaming, fieldNumber: 669) + try visitor.visitSingularInt32Field(value: _storage._responseStreaming, fieldNumber: 806) } if _storage._responseTypeURL != 0 { - try visitor.visitSingularInt32Field(value: _storage._responseTypeURL, fieldNumber: 670) + try visitor.visitSingularInt32Field(value: _storage._responseTypeURL, fieldNumber: 807) } if _storage._result != 0 { - try visitor.visitSingularInt32Field(value: _storage._result, fieldNumber: 671) + try visitor.visitSingularInt32Field(value: _storage._result, fieldNumber: 808) } - if _storage._rethrows != 0 { - try visitor.visitSingularInt32Field(value: _storage._rethrows, fieldNumber: 672) + if _storage._retention != 0 { + try visitor.visitSingularInt32Field(value: _storage._retention, fieldNumber: 809) } - if _storage._return != 0 { - try visitor.visitSingularInt32Field(value: _storage._return, fieldNumber: 673) + if _storage._rethrows != 0 { + try visitor.visitSingularInt32Field(value: _storage._rethrows, fieldNumber: 810) } if _storage._returnType != 0 { - try visitor.visitSingularInt32Field(value: _storage._returnType, fieldNumber: 674) + try visitor.visitSingularInt32Field(value: _storage._returnType, fieldNumber: 811) } if _storage._revision != 0 { - try visitor.visitSingularInt32Field(value: _storage._revision, fieldNumber: 675) + try visitor.visitSingularInt32Field(value: _storage._revision, fieldNumber: 812) } if _storage._rhs != 0 { - try visitor.visitSingularInt32Field(value: _storage._rhs, fieldNumber: 676) + try visitor.visitSingularInt32Field(value: _storage._rhs, fieldNumber: 813) } if _storage._root != 0 { - try visitor.visitSingularInt32Field(value: _storage._root, fieldNumber: 677) + try visitor.visitSingularInt32Field(value: _storage._root, fieldNumber: 814) } if _storage._rubyPackage != 0 { - try visitor.visitSingularInt32Field(value: _storage._rubyPackage, fieldNumber: 678) + try visitor.visitSingularInt32Field(value: _storage._rubyPackage, fieldNumber: 815) } if _storage._s != 0 { - try visitor.visitSingularInt32Field(value: _storage._s, fieldNumber: 679) + try visitor.visitSingularInt32Field(value: _storage._s, fieldNumber: 816) } if _storage._sawBackslash != 0 { - try visitor.visitSingularInt32Field(value: _storage._sawBackslash, fieldNumber: 680) + try visitor.visitSingularInt32Field(value: _storage._sawBackslash, fieldNumber: 817) } if _storage._sawSection4Characters != 0 { - try visitor.visitSingularInt32Field(value: _storage._sawSection4Characters, fieldNumber: 681) + try visitor.visitSingularInt32Field(value: _storage._sawSection4Characters, fieldNumber: 818) } if _storage._sawSection5Characters != 0 { - try visitor.visitSingularInt32Field(value: _storage._sawSection5Characters, fieldNumber: 682) + try visitor.visitSingularInt32Field(value: _storage._sawSection5Characters, fieldNumber: 819) + } + if _storage._scalar != 0 { + try visitor.visitSingularInt32Field(value: _storage._scalar, fieldNumber: 820) + } + if _storage._scan != 0 { + try visitor.visitSingularInt32Field(value: _storage._scan, fieldNumber: 821) } if _storage._scanner != 0 { - try visitor.visitSingularInt32Field(value: _storage._scanner, fieldNumber: 683) + try visitor.visitSingularInt32Field(value: _storage._scanner, fieldNumber: 822) } if _storage._seconds != 0 { - try visitor.visitSingularInt32Field(value: _storage._seconds, fieldNumber: 684) + try visitor.visitSingularInt32Field(value: _storage._seconds, fieldNumber: 823) } if _storage._self_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._self_p, fieldNumber: 685) + try visitor.visitSingularInt32Field(value: _storage._self_p, fieldNumber: 824) + } + if _storage._semantic != 0 { + try visitor.visitSingularInt32Field(value: _storage._semantic, fieldNumber: 825) + } + if _storage._sendable != 0 { + try visitor.visitSingularInt32Field(value: _storage._sendable, fieldNumber: 826) } if _storage._separator != 0 { - try visitor.visitSingularInt32Field(value: _storage._separator, fieldNumber: 686) + try visitor.visitSingularInt32Field(value: _storage._separator, fieldNumber: 827) } if _storage._serialize != 0 { - try visitor.visitSingularInt32Field(value: _storage._serialize, fieldNumber: 687) + try visitor.visitSingularInt32Field(value: _storage._serialize, fieldNumber: 828) + } + if _storage._serializedBytes != 0 { + try visitor.visitSingularInt32Field(value: _storage._serializedBytes, fieldNumber: 829) } if _storage._serializedData != 0 { - try visitor.visitSingularInt32Field(value: _storage._serializedData, fieldNumber: 688) + try visitor.visitSingularInt32Field(value: _storage._serializedData, fieldNumber: 830) } if _storage._serializedSize != 0 { - try visitor.visitSingularInt32Field(value: _storage._serializedSize, fieldNumber: 689) + try visitor.visitSingularInt32Field(value: _storage._serializedSize, fieldNumber: 831) } if _storage._serverStreaming != 0 { - try visitor.visitSingularInt32Field(value: _storage._serverStreaming, fieldNumber: 690) + try visitor.visitSingularInt32Field(value: _storage._serverStreaming, fieldNumber: 832) } if _storage._service != 0 { - try visitor.visitSingularInt32Field(value: _storage._service, fieldNumber: 691) - } - if _storage._serviceDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._serviceDescriptorProto, fieldNumber: 692) - } - if _storage._serviceOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._serviceOptions, fieldNumber: 693) + try visitor.visitSingularInt32Field(value: _storage._service, fieldNumber: 833) } if _storage._set != 0 { - try visitor.visitSingularInt32Field(value: _storage._set, fieldNumber: 694) + try visitor.visitSingularInt32Field(value: _storage._set, fieldNumber: 834) } if _storage._setExtensionValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._setExtensionValue, fieldNumber: 695) + try visitor.visitSingularInt32Field(value: _storage._setExtensionValue, fieldNumber: 835) } if _storage._shift != 0 { - try visitor.visitSingularInt32Field(value: _storage._shift, fieldNumber: 696) + try visitor.visitSingularInt32Field(value: _storage._shift, fieldNumber: 836) } if _storage._simpleExtensionMap != 0 { - try visitor.visitSingularInt32Field(value: _storage._simpleExtensionMap, fieldNumber: 697) + try visitor.visitSingularInt32Field(value: _storage._simpleExtensionMap, fieldNumber: 837) + } + if _storage._size != 0 { + try visitor.visitSingularInt32Field(value: _storage._size, fieldNumber: 838) } if _storage._sizer != 0 { - try visitor.visitSingularInt32Field(value: _storage._sizer, fieldNumber: 698) + try visitor.visitSingularInt32Field(value: _storage._sizer, fieldNumber: 839) } if _storage._source != 0 { - try visitor.visitSingularInt32Field(value: _storage._source, fieldNumber: 699) + try visitor.visitSingularInt32Field(value: _storage._source, fieldNumber: 840) } if _storage._sourceCodeInfo != 0 { - try visitor.visitSingularInt32Field(value: _storage._sourceCodeInfo, fieldNumber: 700) + try visitor.visitSingularInt32Field(value: _storage._sourceCodeInfo, fieldNumber: 841) } if _storage._sourceContext != 0 { - try visitor.visitSingularInt32Field(value: _storage._sourceContext, fieldNumber: 701) + try visitor.visitSingularInt32Field(value: _storage._sourceContext, fieldNumber: 842) } if _storage._sourceEncoding != 0 { - try visitor.visitSingularInt32Field(value: _storage._sourceEncoding, fieldNumber: 702) + try visitor.visitSingularInt32Field(value: _storage._sourceEncoding, fieldNumber: 843) } if _storage._sourceFile != 0 { - try visitor.visitSingularInt32Field(value: _storage._sourceFile, fieldNumber: 703) + try visitor.visitSingularInt32Field(value: _storage._sourceFile, fieldNumber: 844) + } + if _storage._sourceLocation != 0 { + try visitor.visitSingularInt32Field(value: _storage._sourceLocation, fieldNumber: 845) } if _storage._span != 0 { - try visitor.visitSingularInt32Field(value: _storage._span, fieldNumber: 704) + try visitor.visitSingularInt32Field(value: _storage._span, fieldNumber: 846) } if _storage._split != 0 { - try visitor.visitSingularInt32Field(value: _storage._split, fieldNumber: 705) + try visitor.visitSingularInt32Field(value: _storage._split, fieldNumber: 847) } if _storage._start != 0 { - try visitor.visitSingularInt32Field(value: _storage._start, fieldNumber: 706) + try visitor.visitSingularInt32Field(value: _storage._start, fieldNumber: 848) } if _storage._startArray != 0 { - try visitor.visitSingularInt32Field(value: _storage._startArray, fieldNumber: 707) + try visitor.visitSingularInt32Field(value: _storage._startArray, fieldNumber: 849) } if _storage._startArrayObject != 0 { - try visitor.visitSingularInt32Field(value: _storage._startArrayObject, fieldNumber: 708) + try visitor.visitSingularInt32Field(value: _storage._startArrayObject, fieldNumber: 850) } if _storage._startField != 0 { - try visitor.visitSingularInt32Field(value: _storage._startField, fieldNumber: 709) + try visitor.visitSingularInt32Field(value: _storage._startField, fieldNumber: 851) } if _storage._startIndex != 0 { - try visitor.visitSingularInt32Field(value: _storage._startIndex, fieldNumber: 710) + try visitor.visitSingularInt32Field(value: _storage._startIndex, fieldNumber: 852) } if _storage._startMessageField != 0 { - try visitor.visitSingularInt32Field(value: _storage._startMessageField, fieldNumber: 711) + try visitor.visitSingularInt32Field(value: _storage._startMessageField, fieldNumber: 853) } if _storage._startObject != 0 { - try visitor.visitSingularInt32Field(value: _storage._startObject, fieldNumber: 712) + try visitor.visitSingularInt32Field(value: _storage._startObject, fieldNumber: 854) } if _storage._startRegularField != 0 { - try visitor.visitSingularInt32Field(value: _storage._startRegularField, fieldNumber: 713) + try visitor.visitSingularInt32Field(value: _storage._startRegularField, fieldNumber: 855) } if _storage._state != 0 { - try visitor.visitSingularInt32Field(value: _storage._state, fieldNumber: 714) + try visitor.visitSingularInt32Field(value: _storage._state, fieldNumber: 856) } if _storage._static != 0 { - try visitor.visitSingularInt32Field(value: _storage._static, fieldNumber: 715) + try visitor.visitSingularInt32Field(value: _storage._static, fieldNumber: 857) } if _storage._staticString != 0 { - try visitor.visitSingularInt32Field(value: _storage._staticString, fieldNumber: 716) + try visitor.visitSingularInt32Field(value: _storage._staticString, fieldNumber: 858) } if _storage._storage != 0 { - try visitor.visitSingularInt32Field(value: _storage._storage, fieldNumber: 717) + try visitor.visitSingularInt32Field(value: _storage._storage, fieldNumber: 859) } if _storage._string != 0 { - try visitor.visitSingularInt32Field(value: _storage._string, fieldNumber: 718) + try visitor.visitSingularInt32Field(value: _storage._string, fieldNumber: 860) } if _storage._stringLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._stringLiteral, fieldNumber: 719) + try visitor.visitSingularInt32Field(value: _storage._stringLiteral, fieldNumber: 861) } if _storage._stringLiteralType != 0 { - try visitor.visitSingularInt32Field(value: _storage._stringLiteralType, fieldNumber: 720) + try visitor.visitSingularInt32Field(value: _storage._stringLiteralType, fieldNumber: 862) } if _storage._stringResult != 0 { - try visitor.visitSingularInt32Field(value: _storage._stringResult, fieldNumber: 721) + try visitor.visitSingularInt32Field(value: _storage._stringResult, fieldNumber: 863) } if _storage._stringValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._stringValue, fieldNumber: 722) + try visitor.visitSingularInt32Field(value: _storage._stringValue, fieldNumber: 864) } if _storage._struct != 0 { - try visitor.visitSingularInt32Field(value: _storage._struct, fieldNumber: 723) + try visitor.visitSingularInt32Field(value: _storage._struct, fieldNumber: 865) } if _storage._structValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._structValue, fieldNumber: 724) + try visitor.visitSingularInt32Field(value: _storage._structValue, fieldNumber: 866) } if _storage._subDecoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._subDecoder, fieldNumber: 725) + try visitor.visitSingularInt32Field(value: _storage._subDecoder, fieldNumber: 867) } if _storage._subscript != 0 { - try visitor.visitSingularInt32Field(value: _storage._subscript, fieldNumber: 726) + try visitor.visitSingularInt32Field(value: _storage._subscript, fieldNumber: 868) + } + if _storage._subtract != 0 { + try visitor.visitSingularInt32Field(value: _storage._subtract, fieldNumber: 869) } if _storage._subVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._subVisitor, fieldNumber: 727) + try visitor.visitSingularInt32Field(value: _storage._subVisitor, fieldNumber: 870) } if _storage._swift != 0 { - try visitor.visitSingularInt32Field(value: _storage._swift, fieldNumber: 728) + try visitor.visitSingularInt32Field(value: _storage._swift, fieldNumber: 871) } if _storage._swiftPrefix != 0 { - try visitor.visitSingularInt32Field(value: _storage._swiftPrefix, fieldNumber: 729) + try visitor.visitSingularInt32Field(value: _storage._swiftPrefix, fieldNumber: 872) + } + if _storage._swiftProtobufContiguousBytes != 0 { + try visitor.visitSingularInt32Field(value: _storage._swiftProtobufContiguousBytes, fieldNumber: 873) } - if _storage._swiftProtobuf != 0 { - try visitor.visitSingularInt32Field(value: _storage._swiftProtobuf, fieldNumber: 730) + if _storage._swiftProtobufError != 0 { + try visitor.visitSingularInt32Field(value: _storage._swiftProtobufError, fieldNumber: 874) } if _storage._syntax != 0 { - try visitor.visitSingularInt32Field(value: _storage._syntax, fieldNumber: 731) + try visitor.visitSingularInt32Field(value: _storage._syntax, fieldNumber: 875) } if _storage._t != 0 { - try visitor.visitSingularInt32Field(value: _storage._t, fieldNumber: 732) + try visitor.visitSingularInt32Field(value: _storage._t, fieldNumber: 876) } if _storage._tag != 0 { - try visitor.visitSingularInt32Field(value: _storage._tag, fieldNumber: 733) + try visitor.visitSingularInt32Field(value: _storage._tag, fieldNumber: 877) + } + if _storage._targets != 0 { + try visitor.visitSingularInt32Field(value: _storage._targets, fieldNumber: 878) } if _storage._terminator != 0 { - try visitor.visitSingularInt32Field(value: _storage._terminator, fieldNumber: 734) + try visitor.visitSingularInt32Field(value: _storage._terminator, fieldNumber: 879) } if _storage._testDecoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._testDecoder, fieldNumber: 735) + try visitor.visitSingularInt32Field(value: _storage._testDecoder, fieldNumber: 880) } if _storage._text != 0 { - try visitor.visitSingularInt32Field(value: _storage._text, fieldNumber: 736) + try visitor.visitSingularInt32Field(value: _storage._text, fieldNumber: 881) } if _storage._textDecoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._textDecoder, fieldNumber: 737) + try visitor.visitSingularInt32Field(value: _storage._textDecoder, fieldNumber: 882) } if _storage._textFormatDecoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._textFormatDecoder, fieldNumber: 738) + try visitor.visitSingularInt32Field(value: _storage._textFormatDecoder, fieldNumber: 883) } if _storage._textFormatDecodingError != 0 { - try visitor.visitSingularInt32Field(value: _storage._textFormatDecodingError, fieldNumber: 739) + try visitor.visitSingularInt32Field(value: _storage._textFormatDecodingError, fieldNumber: 884) } if _storage._textFormatDecodingOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._textFormatDecodingOptions, fieldNumber: 740) + try visitor.visitSingularInt32Field(value: _storage._textFormatDecodingOptions, fieldNumber: 885) } if _storage._textFormatEncodingOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._textFormatEncodingOptions, fieldNumber: 741) + try visitor.visitSingularInt32Field(value: _storage._textFormatEncodingOptions, fieldNumber: 886) } if _storage._textFormatEncodingVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._textFormatEncodingVisitor, fieldNumber: 742) + try visitor.visitSingularInt32Field(value: _storage._textFormatEncodingVisitor, fieldNumber: 887) } if _storage._textFormatString != 0 { - try visitor.visitSingularInt32Field(value: _storage._textFormatString, fieldNumber: 743) + try visitor.visitSingularInt32Field(value: _storage._textFormatString, fieldNumber: 888) + } + if _storage._throwOrIgnore != 0 { + try visitor.visitSingularInt32Field(value: _storage._throwOrIgnore, fieldNumber: 889) } if _storage._throws != 0 { - try visitor.visitSingularInt32Field(value: _storage._throws, fieldNumber: 744) + try visitor.visitSingularInt32Field(value: _storage._throws, fieldNumber: 890) } if _storage._timeInterval != 0 { - try visitor.visitSingularInt32Field(value: _storage._timeInterval, fieldNumber: 745) + try visitor.visitSingularInt32Field(value: _storage._timeInterval, fieldNumber: 891) } if _storage._timeIntervalSince1970 != 0 { - try visitor.visitSingularInt32Field(value: _storage._timeIntervalSince1970, fieldNumber: 746) + try visitor.visitSingularInt32Field(value: _storage._timeIntervalSince1970, fieldNumber: 892) } if _storage._timeIntervalSinceReferenceDate != 0 { - try visitor.visitSingularInt32Field(value: _storage._timeIntervalSinceReferenceDate, fieldNumber: 747) + try visitor.visitSingularInt32Field(value: _storage._timeIntervalSinceReferenceDate, fieldNumber: 893) } - if _storage._timestamp != 0 { - try visitor.visitSingularInt32Field(value: _storage._timestamp, fieldNumber: 748) + if _storage._tmp != 0 { + try visitor.visitSingularInt32Field(value: _storage._tmp, fieldNumber: 894) + } + if _storage._tooLarge != 0 { + try visitor.visitSingularInt32Field(value: _storage._tooLarge, fieldNumber: 895) } if _storage._total != 0 { - try visitor.visitSingularInt32Field(value: _storage._total, fieldNumber: 749) + try visitor.visitSingularInt32Field(value: _storage._total, fieldNumber: 896) } if _storage._totalArrayDepth != 0 { - try visitor.visitSingularInt32Field(value: _storage._totalArrayDepth, fieldNumber: 750) + try visitor.visitSingularInt32Field(value: _storage._totalArrayDepth, fieldNumber: 897) } if _storage._totalSize != 0 { - try visitor.visitSingularInt32Field(value: _storage._totalSize, fieldNumber: 751) + try visitor.visitSingularInt32Field(value: _storage._totalSize, fieldNumber: 898) } if _storage._trailingComments != 0 { - try visitor.visitSingularInt32Field(value: _storage._trailingComments, fieldNumber: 752) + try visitor.visitSingularInt32Field(value: _storage._trailingComments, fieldNumber: 899) } if _storage._traverse != 0 { - try visitor.visitSingularInt32Field(value: _storage._traverse, fieldNumber: 753) + try visitor.visitSingularInt32Field(value: _storage._traverse, fieldNumber: 900) + } + if _storage._trim != 0 { + try visitor.visitSingularInt32Field(value: _storage._trim, fieldNumber: 901) } if _storage._true != 0 { - try visitor.visitSingularInt32Field(value: _storage._true, fieldNumber: 754) + try visitor.visitSingularInt32Field(value: _storage._true, fieldNumber: 902) } if _storage._try != 0 { - try visitor.visitSingularInt32Field(value: _storage._try, fieldNumber: 755) + try visitor.visitSingularInt32Field(value: _storage._try, fieldNumber: 903) } if _storage._type != 0 { - try visitor.visitSingularInt32Field(value: _storage._type, fieldNumber: 756) + try visitor.visitSingularInt32Field(value: _storage._type, fieldNumber: 904) } if _storage._typealias != 0 { - try visitor.visitSingularInt32Field(value: _storage._typealias, fieldNumber: 757) + try visitor.visitSingularInt32Field(value: _storage._typealias, fieldNumber: 905) } if _storage._typeEnum != 0 { - try visitor.visitSingularInt32Field(value: _storage._typeEnum, fieldNumber: 758) + try visitor.visitSingularInt32Field(value: _storage._typeEnum, fieldNumber: 906) } if _storage._typeName != 0 { - try visitor.visitSingularInt32Field(value: _storage._typeName, fieldNumber: 759) + try visitor.visitSingularInt32Field(value: _storage._typeName, fieldNumber: 907) } if _storage._typePrefix != 0 { - try visitor.visitSingularInt32Field(value: _storage._typePrefix, fieldNumber: 760) + try visitor.visitSingularInt32Field(value: _storage._typePrefix, fieldNumber: 908) } if _storage._typeStart != 0 { - try visitor.visitSingularInt32Field(value: _storage._typeStart, fieldNumber: 761) + try visitor.visitSingularInt32Field(value: _storage._typeStart, fieldNumber: 909) } if _storage._typeUnknown != 0 { - try visitor.visitSingularInt32Field(value: _storage._typeUnknown, fieldNumber: 762) + try visitor.visitSingularInt32Field(value: _storage._typeUnknown, fieldNumber: 910) } if _storage._typeURL != 0 { - try visitor.visitSingularInt32Field(value: _storage._typeURL, fieldNumber: 763) + try visitor.visitSingularInt32Field(value: _storage._typeURL, fieldNumber: 911) } if _storage._uint32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._uint32, fieldNumber: 764) - } - if _storage._uint32Value != 0 { - try visitor.visitSingularInt32Field(value: _storage._uint32Value, fieldNumber: 765) + try visitor.visitSingularInt32Field(value: _storage._uint32, fieldNumber: 912) } if _storage._uint64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._uint64, fieldNumber: 766) - } - if _storage._uint64Value != 0 { - try visitor.visitSingularInt32Field(value: _storage._uint64Value, fieldNumber: 767) + try visitor.visitSingularInt32Field(value: _storage._uint64, fieldNumber: 913) } if _storage._uint8 != 0 { - try visitor.visitSingularInt32Field(value: _storage._uint8, fieldNumber: 768) + try visitor.visitSingularInt32Field(value: _storage._uint8, fieldNumber: 914) + } + if _storage._unchecked != 0 { + try visitor.visitSingularInt32Field(value: _storage._unchecked, fieldNumber: 915) + } + if _storage._unicode != 0 { + try visitor.visitSingularInt32Field(value: _storage._unicode, fieldNumber: 916) } if _storage._unicodeScalarLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._unicodeScalarLiteral, fieldNumber: 769) + try visitor.visitSingularInt32Field(value: _storage._unicodeScalarLiteral, fieldNumber: 917) } if _storage._unicodeScalarLiteralType != 0 { - try visitor.visitSingularInt32Field(value: _storage._unicodeScalarLiteralType, fieldNumber: 770) + try visitor.visitSingularInt32Field(value: _storage._unicodeScalarLiteralType, fieldNumber: 918) } if _storage._unicodeScalars != 0 { - try visitor.visitSingularInt32Field(value: _storage._unicodeScalars, fieldNumber: 771) + try visitor.visitSingularInt32Field(value: _storage._unicodeScalars, fieldNumber: 919) } if _storage._unicodeScalarView != 0 { - try visitor.visitSingularInt32Field(value: _storage._unicodeScalarView, fieldNumber: 772) + try visitor.visitSingularInt32Field(value: _storage._unicodeScalarView, fieldNumber: 920) } if _storage._uninterpretedOption != 0 { - try visitor.visitSingularInt32Field(value: _storage._uninterpretedOption, fieldNumber: 773) + try visitor.visitSingularInt32Field(value: _storage._uninterpretedOption, fieldNumber: 921) } if _storage._union != 0 { - try visitor.visitSingularInt32Field(value: _storage._union, fieldNumber: 774) + try visitor.visitSingularInt32Field(value: _storage._union, fieldNumber: 922) } if _storage._uniqueStorage != 0 { - try visitor.visitSingularInt32Field(value: _storage._uniqueStorage, fieldNumber: 775) + try visitor.visitSingularInt32Field(value: _storage._uniqueStorage, fieldNumber: 923) } if _storage._unknown != 0 { - try visitor.visitSingularInt32Field(value: _storage._unknown, fieldNumber: 776) + try visitor.visitSingularInt32Field(value: _storage._unknown, fieldNumber: 924) } if _storage._unknownFields_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._unknownFields_p, fieldNumber: 777) + try visitor.visitSingularInt32Field(value: _storage._unknownFields_p, fieldNumber: 925) } if _storage._unknownStorage != 0 { - try visitor.visitSingularInt32Field(value: _storage._unknownStorage, fieldNumber: 778) + try visitor.visitSingularInt32Field(value: _storage._unknownStorage, fieldNumber: 926) } if _storage._unpackTo != 0 { - try visitor.visitSingularInt32Field(value: _storage._unpackTo, fieldNumber: 779) + try visitor.visitSingularInt32Field(value: _storage._unpackTo, fieldNumber: 927) } if _storage._unsafeBufferPointer != 0 { - try visitor.visitSingularInt32Field(value: _storage._unsafeBufferPointer, fieldNumber: 780) + try visitor.visitSingularInt32Field(value: _storage._unsafeBufferPointer, fieldNumber: 928) } if _storage._unsafeMutablePointer != 0 { - try visitor.visitSingularInt32Field(value: _storage._unsafeMutablePointer, fieldNumber: 781) + try visitor.visitSingularInt32Field(value: _storage._unsafeMutablePointer, fieldNumber: 929) } if _storage._unsafeMutableRawBufferPointer != 0 { - try visitor.visitSingularInt32Field(value: _storage._unsafeMutableRawBufferPointer, fieldNumber: 782) - } - if _storage._unsafeMutableRawPointer != 0 { - try visitor.visitSingularInt32Field(value: _storage._unsafeMutableRawPointer, fieldNumber: 783) + try visitor.visitSingularInt32Field(value: _storage._unsafeMutableRawBufferPointer, fieldNumber: 930) } if _storage._unsafeRawBufferPointer != 0 { - try visitor.visitSingularInt32Field(value: _storage._unsafeRawBufferPointer, fieldNumber: 784) + try visitor.visitSingularInt32Field(value: _storage._unsafeRawBufferPointer, fieldNumber: 931) } if _storage._unsafeRawPointer != 0 { - try visitor.visitSingularInt32Field(value: _storage._unsafeRawPointer, fieldNumber: 785) + try visitor.visitSingularInt32Field(value: _storage._unsafeRawPointer, fieldNumber: 932) + } + if _storage._unverifiedLazy != 0 { + try visitor.visitSingularInt32Field(value: _storage._unverifiedLazy, fieldNumber: 933) } if _storage._updatedOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._updatedOptions, fieldNumber: 786) + try visitor.visitSingularInt32Field(value: _storage._updatedOptions, fieldNumber: 934) + } + if _storage._uppercasedAssumingAscii != 0 { + try visitor.visitSingularInt32Field(value: _storage._uppercasedAssumingAscii, fieldNumber: 935) } if _storage._url != 0 { - try visitor.visitSingularInt32Field(value: _storage._url, fieldNumber: 787) + try visitor.visitSingularInt32Field(value: _storage._url, fieldNumber: 936) + } + if _storage._useDeterministicOrdering != 0 { + try visitor.visitSingularInt32Field(value: _storage._useDeterministicOrdering, fieldNumber: 937) } if _storage._utf8 != 0 { - try visitor.visitSingularInt32Field(value: _storage._utf8, fieldNumber: 788) + try visitor.visitSingularInt32Field(value: _storage._utf8, fieldNumber: 938) } if _storage._utf8Ptr != 0 { - try visitor.visitSingularInt32Field(value: _storage._utf8Ptr, fieldNumber: 789) + try visitor.visitSingularInt32Field(value: _storage._utf8Ptr, fieldNumber: 939) } if _storage._utf8ToDouble != 0 { - try visitor.visitSingularInt32Field(value: _storage._utf8ToDouble, fieldNumber: 790) + try visitor.visitSingularInt32Field(value: _storage._utf8ToDouble, fieldNumber: 940) + } + if _storage._utf8Validation != 0 { + try visitor.visitSingularInt32Field(value: _storage._utf8Validation, fieldNumber: 941) } if _storage._utf8View != 0 { - try visitor.visitSingularInt32Field(value: _storage._utf8View, fieldNumber: 791) + try visitor.visitSingularInt32Field(value: _storage._utf8View, fieldNumber: 942) } if _storage._v != 0 { - try visitor.visitSingularInt32Field(value: _storage._v, fieldNumber: 792) + try visitor.visitSingularInt32Field(value: _storage._v, fieldNumber: 943) } if _storage._value != 0 { - try visitor.visitSingularInt32Field(value: _storage._value, fieldNumber: 793) + try visitor.visitSingularInt32Field(value: _storage._value, fieldNumber: 944) } if _storage._valueField != 0 { - try visitor.visitSingularInt32Field(value: _storage._valueField, fieldNumber: 794) + try visitor.visitSingularInt32Field(value: _storage._valueField, fieldNumber: 945) } if _storage._values != 0 { - try visitor.visitSingularInt32Field(value: _storage._values, fieldNumber: 795) + try visitor.visitSingularInt32Field(value: _storage._values, fieldNumber: 946) } if _storage._valueType != 0 { - try visitor.visitSingularInt32Field(value: _storage._valueType, fieldNumber: 796) + try visitor.visitSingularInt32Field(value: _storage._valueType, fieldNumber: 947) } if _storage._var != 0 { - try visitor.visitSingularInt32Field(value: _storage._var, fieldNumber: 797) + try visitor.visitSingularInt32Field(value: _storage._var, fieldNumber: 948) + } + if _storage._verification != 0 { + try visitor.visitSingularInt32Field(value: _storage._verification, fieldNumber: 949) + } + if _storage._verificationState != 0 { + try visitor.visitSingularInt32Field(value: _storage._verificationState, fieldNumber: 950) } if _storage._version != 0 { - try visitor.visitSingularInt32Field(value: _storage._version, fieldNumber: 798) + try visitor.visitSingularInt32Field(value: _storage._version, fieldNumber: 951) } if _storage._versionString != 0 { - try visitor.visitSingularInt32Field(value: _storage._versionString, fieldNumber: 799) + try visitor.visitSingularInt32Field(value: _storage._versionString, fieldNumber: 952) + } + if _storage._visibility != 0 { + try visitor.visitSingularInt32Field(value: _storage._visibility, fieldNumber: 953) + } + if _storage._visibilityFeature != 0 { + try visitor.visitSingularInt32Field(value: _storage._visibilityFeature, fieldNumber: 954) } if _storage._visitExtensionFields != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitExtensionFields, fieldNumber: 800) + try visitor.visitSingularInt32Field(value: _storage._visitExtensionFields, fieldNumber: 955) } if _storage._visitExtensionFieldsAsMessageSet != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitExtensionFieldsAsMessageSet, fieldNumber: 801) + try visitor.visitSingularInt32Field(value: _storage._visitExtensionFieldsAsMessageSet, fieldNumber: 956) } if _storage._visitMapField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitMapField, fieldNumber: 802) + try visitor.visitSingularInt32Field(value: _storage._visitMapField, fieldNumber: 957) } if _storage._visitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitor, fieldNumber: 803) + try visitor.visitSingularInt32Field(value: _storage._visitor, fieldNumber: 958) } if _storage._visitPacked != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPacked, fieldNumber: 804) + try visitor.visitSingularInt32Field(value: _storage._visitPacked, fieldNumber: 959) } if _storage._visitPackedBoolField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedBoolField, fieldNumber: 805) + try visitor.visitSingularInt32Field(value: _storage._visitPackedBoolField, fieldNumber: 960) } if _storage._visitPackedDoubleField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedDoubleField, fieldNumber: 806) + try visitor.visitSingularInt32Field(value: _storage._visitPackedDoubleField, fieldNumber: 961) } if _storage._visitPackedEnumField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedEnumField, fieldNumber: 807) + try visitor.visitSingularInt32Field(value: _storage._visitPackedEnumField, fieldNumber: 962) } if _storage._visitPackedFixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedFixed32Field, fieldNumber: 808) + try visitor.visitSingularInt32Field(value: _storage._visitPackedFixed32Field, fieldNumber: 963) } if _storage._visitPackedFixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedFixed64Field, fieldNumber: 809) + try visitor.visitSingularInt32Field(value: _storage._visitPackedFixed64Field, fieldNumber: 964) } if _storage._visitPackedFloatField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedFloatField, fieldNumber: 810) + try visitor.visitSingularInt32Field(value: _storage._visitPackedFloatField, fieldNumber: 965) } if _storage._visitPackedInt32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedInt32Field, fieldNumber: 811) + try visitor.visitSingularInt32Field(value: _storage._visitPackedInt32Field, fieldNumber: 966) } if _storage._visitPackedInt64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedInt64Field, fieldNumber: 812) + try visitor.visitSingularInt32Field(value: _storage._visitPackedInt64Field, fieldNumber: 967) } if _storage._visitPackedSfixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedSfixed32Field, fieldNumber: 813) + try visitor.visitSingularInt32Field(value: _storage._visitPackedSfixed32Field, fieldNumber: 968) } if _storage._visitPackedSfixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedSfixed64Field, fieldNumber: 814) + try visitor.visitSingularInt32Field(value: _storage._visitPackedSfixed64Field, fieldNumber: 969) } if _storage._visitPackedSint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedSint32Field, fieldNumber: 815) + try visitor.visitSingularInt32Field(value: _storage._visitPackedSint32Field, fieldNumber: 970) } if _storage._visitPackedSint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedSint64Field, fieldNumber: 816) + try visitor.visitSingularInt32Field(value: _storage._visitPackedSint64Field, fieldNumber: 971) } if _storage._visitPackedUint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedUint32Field, fieldNumber: 817) + try visitor.visitSingularInt32Field(value: _storage._visitPackedUint32Field, fieldNumber: 972) } if _storage._visitPackedUint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedUint64Field, fieldNumber: 818) + try visitor.visitSingularInt32Field(value: _storage._visitPackedUint64Field, fieldNumber: 973) } if _storage._visitRepeated != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeated, fieldNumber: 819) + try visitor.visitSingularInt32Field(value: _storage._visitRepeated, fieldNumber: 974) } if _storage._visitRepeatedBoolField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedBoolField, fieldNumber: 820) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedBoolField, fieldNumber: 975) } if _storage._visitRepeatedBytesField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedBytesField, fieldNumber: 821) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedBytesField, fieldNumber: 976) } if _storage._visitRepeatedDoubleField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedDoubleField, fieldNumber: 822) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedDoubleField, fieldNumber: 977) } if _storage._visitRepeatedEnumField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedEnumField, fieldNumber: 823) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedEnumField, fieldNumber: 978) } if _storage._visitRepeatedFixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedFixed32Field, fieldNumber: 824) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedFixed32Field, fieldNumber: 979) } if _storage._visitRepeatedFixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedFixed64Field, fieldNumber: 825) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedFixed64Field, fieldNumber: 980) } if _storage._visitRepeatedFloatField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedFloatField, fieldNumber: 826) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedFloatField, fieldNumber: 981) } if _storage._visitRepeatedGroupField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedGroupField, fieldNumber: 827) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedGroupField, fieldNumber: 982) } if _storage._visitRepeatedInt32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedInt32Field, fieldNumber: 828) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedInt32Field, fieldNumber: 983) } if _storage._visitRepeatedInt64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedInt64Field, fieldNumber: 829) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedInt64Field, fieldNumber: 984) } if _storage._visitRepeatedMessageField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedMessageField, fieldNumber: 830) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedMessageField, fieldNumber: 985) } if _storage._visitRepeatedSfixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSfixed32Field, fieldNumber: 831) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSfixed32Field, fieldNumber: 986) } if _storage._visitRepeatedSfixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSfixed64Field, fieldNumber: 832) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSfixed64Field, fieldNumber: 987) } if _storage._visitRepeatedSint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSint32Field, fieldNumber: 833) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSint32Field, fieldNumber: 988) } if _storage._visitRepeatedSint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSint64Field, fieldNumber: 834) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSint64Field, fieldNumber: 989) } if _storage._visitRepeatedStringField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedStringField, fieldNumber: 835) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedStringField, fieldNumber: 990) } if _storage._visitRepeatedUint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedUint32Field, fieldNumber: 836) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedUint32Field, fieldNumber: 991) } if _storage._visitRepeatedUint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedUint64Field, fieldNumber: 837) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedUint64Field, fieldNumber: 992) } if _storage._visitSingular != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingular, fieldNumber: 838) + try visitor.visitSingularInt32Field(value: _storage._visitSingular, fieldNumber: 993) } if _storage._visitSingularBoolField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularBoolField, fieldNumber: 839) + try visitor.visitSingularInt32Field(value: _storage._visitSingularBoolField, fieldNumber: 994) } if _storage._visitSingularBytesField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularBytesField, fieldNumber: 840) + try visitor.visitSingularInt32Field(value: _storage._visitSingularBytesField, fieldNumber: 995) } if _storage._visitSingularDoubleField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularDoubleField, fieldNumber: 841) + try visitor.visitSingularInt32Field(value: _storage._visitSingularDoubleField, fieldNumber: 996) } if _storage._visitSingularEnumField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularEnumField, fieldNumber: 842) + try visitor.visitSingularInt32Field(value: _storage._visitSingularEnumField, fieldNumber: 997) } if _storage._visitSingularFixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularFixed32Field, fieldNumber: 843) + try visitor.visitSingularInt32Field(value: _storage._visitSingularFixed32Field, fieldNumber: 998) } if _storage._visitSingularFixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularFixed64Field, fieldNumber: 844) + try visitor.visitSingularInt32Field(value: _storage._visitSingularFixed64Field, fieldNumber: 999) } if _storage._visitSingularFloatField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularFloatField, fieldNumber: 845) + try visitor.visitSingularInt32Field(value: _storage._visitSingularFloatField, fieldNumber: 1000) } if _storage._visitSingularGroupField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularGroupField, fieldNumber: 846) + try visitor.visitSingularInt32Field(value: _storage._visitSingularGroupField, fieldNumber: 1001) } if _storage._visitSingularInt32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularInt32Field, fieldNumber: 847) + try visitor.visitSingularInt32Field(value: _storage._visitSingularInt32Field, fieldNumber: 1002) } if _storage._visitSingularInt64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularInt64Field, fieldNumber: 848) + try visitor.visitSingularInt32Field(value: _storage._visitSingularInt64Field, fieldNumber: 1003) } if _storage._visitSingularMessageField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularMessageField, fieldNumber: 849) + try visitor.visitSingularInt32Field(value: _storage._visitSingularMessageField, fieldNumber: 1004) } if _storage._visitSingularSfixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularSfixed32Field, fieldNumber: 850) + try visitor.visitSingularInt32Field(value: _storage._visitSingularSfixed32Field, fieldNumber: 1005) } if _storage._visitSingularSfixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularSfixed64Field, fieldNumber: 851) + try visitor.visitSingularInt32Field(value: _storage._visitSingularSfixed64Field, fieldNumber: 1006) } if _storage._visitSingularSint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularSint32Field, fieldNumber: 852) + try visitor.visitSingularInt32Field(value: _storage._visitSingularSint32Field, fieldNumber: 1007) } if _storage._visitSingularSint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularSint64Field, fieldNumber: 853) + try visitor.visitSingularInt32Field(value: _storage._visitSingularSint64Field, fieldNumber: 1008) } if _storage._visitSingularStringField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularStringField, fieldNumber: 854) + try visitor.visitSingularInt32Field(value: _storage._visitSingularStringField, fieldNumber: 1009) } if _storage._visitSingularUint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularUint32Field, fieldNumber: 855) + try visitor.visitSingularInt32Field(value: _storage._visitSingularUint32Field, fieldNumber: 1010) } if _storage._visitSingularUint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularUint64Field, fieldNumber: 856) + try visitor.visitSingularInt32Field(value: _storage._visitSingularUint64Field, fieldNumber: 1011) } if _storage._visitUnknown != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitUnknown, fieldNumber: 857) + try visitor.visitSingularInt32Field(value: _storage._visitUnknown, fieldNumber: 1012) + } + if _storage._void != 0 { + try visitor.visitSingularInt32Field(value: _storage._void, fieldNumber: 1013) } if _storage._wasDecoded != 0 { - try visitor.visitSingularInt32Field(value: _storage._wasDecoded, fieldNumber: 858) + try visitor.visitSingularInt32Field(value: _storage._wasDecoded, fieldNumber: 1014) } if _storage._weak != 0 { - try visitor.visitSingularInt32Field(value: _storage._weak, fieldNumber: 859) + try visitor.visitSingularInt32Field(value: _storage._weak, fieldNumber: 1015) } if _storage._weakDependency != 0 { - try visitor.visitSingularInt32Field(value: _storage._weakDependency, fieldNumber: 860) + try visitor.visitSingularInt32Field(value: _storage._weakDependency, fieldNumber: 1016) } if _storage._where != 0 { - try visitor.visitSingularInt32Field(value: _storage._where, fieldNumber: 861) + try visitor.visitSingularInt32Field(value: _storage._where, fieldNumber: 1017) } if _storage._wireFormat != 0 { - try visitor.visitSingularInt32Field(value: _storage._wireFormat, fieldNumber: 862) + try visitor.visitSingularInt32Field(value: _storage._wireFormat, fieldNumber: 1018) } if _storage._with != 0 { - try visitor.visitSingularInt32Field(value: _storage._with, fieldNumber: 863) + try visitor.visitSingularInt32Field(value: _storage._with, fieldNumber: 1019) } if _storage._withUnsafeBytes != 0 { - try visitor.visitSingularInt32Field(value: _storage._withUnsafeBytes, fieldNumber: 864) + try visitor.visitSingularInt32Field(value: _storage._withUnsafeBytes, fieldNumber: 1020) } if _storage._withUnsafeMutableBytes != 0 { - try visitor.visitSingularInt32Field(value: _storage._withUnsafeMutableBytes, fieldNumber: 865) + try visitor.visitSingularInt32Field(value: _storage._withUnsafeMutableBytes, fieldNumber: 1021) } if _storage._work != 0 { - try visitor.visitSingularInt32Field(value: _storage._work, fieldNumber: 866) + try visitor.visitSingularInt32Field(value: _storage._work, fieldNumber: 1022) + } + if _storage._wrapped != 0 { + try visitor.visitSingularInt32Field(value: _storage._wrapped, fieldNumber: 1023) } if _storage._wrappedType != 0 { - try visitor.visitSingularInt32Field(value: _storage._wrappedType, fieldNumber: 867) + try visitor.visitSingularInt32Field(value: _storage._wrappedType, fieldNumber: 1024) + } + if _storage._wrappedValue != 0 { + try visitor.visitSingularInt32Field(value: _storage._wrappedValue, fieldNumber: 1025) } if _storage._written != 0 { - try visitor.visitSingularInt32Field(value: _storage._written, fieldNumber: 868) + try visitor.visitSingularInt32Field(value: _storage._written, fieldNumber: 1026) } if _storage._yday != 0 { - try visitor.visitSingularInt32Field(value: _storage._yday, fieldNumber: 869) + try visitor.visitSingularInt32Field(value: _storage._yday, fieldNumber: 1027) } } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedFields, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedFields) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedFields) -> 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._addPath != rhs_storage._addPath {return false} if _storage._adjusted != rhs_storage._adjusted {return false} if _storage._aggregateValue != rhs_storage._aggregateValue {return false} if _storage._allCases != rhs_storage._allCases {return false} if _storage._allowAlias != rhs_storage._allowAlias {return false} if _storage._alwaysPrintEnumsAsInts != rhs_storage._alwaysPrintEnumsAsInts {return false} + if _storage._alwaysPrintInt64SAsNumbers != rhs_storage._alwaysPrintInt64SAsNumbers {return false} if _storage._annotation != rhs_storage._annotation {return false} if _storage._any != rhs_storage._any {return false} if _storage._anyExtensionField != rhs_storage._anyExtensionField {return false} if _storage._anyMessageExtension != rhs_storage._anyMessageExtension {return false} if _storage._anyMessageStorage != rhs_storage._anyMessageStorage {return false} if _storage._anyUnpackError != rhs_storage._anyUnpackError {return false} - if _storage._api != rhs_storage._api {return false} + if _storage._append != rhs_storage._append {return false} if _storage._appended != rhs_storage._appended {return false} if _storage._appendUintHex != rhs_storage._appendUintHex {return false} if _storage._appendUnknown != rhs_storage._appendUnknown {return false} @@ -10542,14 +11412,20 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._as != rhs_storage._as {return false} if _storage._asciiOpenCurlyBracket != rhs_storage._asciiOpenCurlyBracket {return false} if _storage._asciiZero != rhs_storage._asciiZero {return false} + if _storage._async != rhs_storage._async {return false} + if _storage._asyncIterator != rhs_storage._asyncIterator {return false} + if _storage._asyncIteratorProtocol != rhs_storage._asyncIteratorProtocol {return false} + if _storage._asyncMessageSequence != rhs_storage._asyncMessageSequence {return false} if _storage._available != rhs_storage._available {return false} if _storage._b != rhs_storage._b {return false} + if _storage._base != rhs_storage._base {return false} if _storage._base64Values != rhs_storage._base64Values {return false} if _storage._baseAddress != rhs_storage._baseAddress {return false} if _storage._baseType != rhs_storage._baseType {return false} if _storage._begin != rhs_storage._begin {return false} if _storage._binary != rhs_storage._binary {return false} if _storage._binaryDecoder != rhs_storage._binaryDecoder {return false} + if _storage._binaryDecoding != rhs_storage._binaryDecoding {return false} if _storage._binaryDecodingError != rhs_storage._binaryDecodingError {return false} if _storage._binaryDecodingOptions != rhs_storage._binaryDecodingOptions {return false} if _storage._binaryDelimited != rhs_storage._binaryDelimited {return false} @@ -10557,25 +11433,39 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._binaryEncodingError != rhs_storage._binaryEncodingError {return false} if _storage._binaryEncodingMessageSetSizeVisitor != rhs_storage._binaryEncodingMessageSetSizeVisitor {return false} if _storage._binaryEncodingMessageSetVisitor != rhs_storage._binaryEncodingMessageSetVisitor {return false} + if _storage._binaryEncodingOptions != rhs_storage._binaryEncodingOptions {return false} if _storage._binaryEncodingSizeVisitor != rhs_storage._binaryEncodingSizeVisitor {return false} if _storage._binaryEncodingVisitor != rhs_storage._binaryEncodingVisitor {return false} if _storage._binaryOptions != rhs_storage._binaryOptions {return false} + if _storage._binaryProtobufDelimitedMessages != rhs_storage._binaryProtobufDelimitedMessages {return false} + if _storage._binaryStreamDecoding != rhs_storage._binaryStreamDecoding {return false} + if _storage._binaryStreamDecodingError != rhs_storage._binaryStreamDecodingError {return false} + if _storage._bitPattern != rhs_storage._bitPattern {return false} if _storage._body != rhs_storage._body {return false} if _storage._bool != rhs_storage._bool {return false} if _storage._booleanLiteral != rhs_storage._booleanLiteral {return false} if _storage._booleanLiteralType != rhs_storage._booleanLiteralType {return false} if _storage._boolValue != rhs_storage._boolValue {return false} + if _storage._buffer != rhs_storage._buffer {return false} + if _storage._byte != rhs_storage._byte {return false} + if _storage._bytecode != rhs_storage._bytecode {return false} + if _storage._bytecodeReader != rhs_storage._bytecodeReader {return false} if _storage._bytes != rhs_storage._bytes {return false} if _storage._bytesInGroup != rhs_storage._bytesInGroup {return false} + if _storage._bytesNeeded != rhs_storage._bytesNeeded {return false} if _storage._bytesRead != rhs_storage._bytesRead {return false} - if _storage._bytesValue != rhs_storage._bytesValue {return false} if _storage._c != rhs_storage._c {return false} + if _storage._canonical != rhs_storage._canonical {return false} if _storage._capitalizeNext != rhs_storage._capitalizeNext {return false} if _storage._cardinality != rhs_storage._cardinality {return false} + if _storage._caseIterable != rhs_storage._caseIterable {return false} + if _storage._castedValue != rhs_storage._castedValue {return false} if _storage._ccEnableArenas != rhs_storage._ccEnableArenas {return false} if _storage._ccGenericServices != rhs_storage._ccGenericServices {return false} if _storage._character != rhs_storage._character {return false} if _storage._chars != rhs_storage._chars {return false} + if _storage._checkProgramFormat != rhs_storage._checkProgramFormat {return false} + if _storage._chunk != rhs_storage._chunk {return false} if _storage._class != rhs_storage._class {return false} if _storage._clearAggregateValue_p != rhs_storage._clearAggregateValue_p {return false} if _storage._clearAllowAlias_p != rhs_storage._clearAllowAlias_p {return false} @@ -10585,12 +11475,27 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._clearClientStreaming_p != rhs_storage._clearClientStreaming_p {return false} if _storage._clearCsharpNamespace_p != rhs_storage._clearCsharpNamespace_p {return false} if _storage._clearCtype_p != rhs_storage._clearCtype_p {return false} + if _storage._clearDebugRedact_p != rhs_storage._clearDebugRedact_p {return false} + if _storage._clearDefaultSymbolVisibility_p != rhs_storage._clearDefaultSymbolVisibility_p {return false} if _storage._clearDefaultValue_p != rhs_storage._clearDefaultValue_p {return false} if _storage._clearDeprecated_p != rhs_storage._clearDeprecated_p {return false} + if _storage._clearDeprecatedLegacyJsonFieldConflicts_p != rhs_storage._clearDeprecatedLegacyJsonFieldConflicts_p {return false} + if _storage._clearDeprecationWarning_p != rhs_storage._clearDeprecationWarning_p {return false} if _storage._clearDoubleValue_p != rhs_storage._clearDoubleValue_p {return false} + if _storage._clearEdition_p != rhs_storage._clearEdition_p {return false} + if _storage._clearEditionDeprecated_p != rhs_storage._clearEditionDeprecated_p {return false} + if _storage._clearEditionIntroduced_p != rhs_storage._clearEditionIntroduced_p {return false} + if _storage._clearEditionRemoved_p != rhs_storage._clearEditionRemoved_p {return false} if _storage._clearEnd_p != rhs_storage._clearEnd_p {return false} + if _storage._clearEnforceNamingStyle_p != rhs_storage._clearEnforceNamingStyle_p {return false} + if _storage._clearEnumType_p != rhs_storage._clearEnumType_p {return false} if _storage._clearExtendee_p != rhs_storage._clearExtendee_p {return false} if _storage._clearExtensionValue_p != rhs_storage._clearExtensionValue_p {return false} + if _storage._clearFeatures_p != rhs_storage._clearFeatures_p {return false} + if _storage._clearFeatureSupport_p != rhs_storage._clearFeatureSupport_p {return false} + if _storage._clearFieldPresence_p != rhs_storage._clearFieldPresence_p {return false} + if _storage._clearFixedFeatures_p != rhs_storage._clearFixedFeatures_p {return false} + if _storage._clearFullName_p != rhs_storage._clearFullName_p {return false} if _storage._clearGoPackage_p != rhs_storage._clearGoPackage_p {return false} if _storage._clearIdempotencyLevel_p != rhs_storage._clearIdempotencyLevel_p {return false} if _storage._clearIdentifierValue_p != rhs_storage._clearIdentifierValue_p {return false} @@ -10602,13 +11507,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._clearJavaOuterClassname_p != rhs_storage._clearJavaOuterClassname_p {return false} if _storage._clearJavaPackage_p != rhs_storage._clearJavaPackage_p {return false} if _storage._clearJavaStringCheckUtf8_p != rhs_storage._clearJavaStringCheckUtf8_p {return false} + if _storage._clearJsonFormat_p != rhs_storage._clearJsonFormat_p {return false} if _storage._clearJsonName_p != rhs_storage._clearJsonName_p {return false} if _storage._clearJstype_p != rhs_storage._clearJstype_p {return false} if _storage._clearLabel_p != rhs_storage._clearLabel_p {return false} if _storage._clearLazy_p != rhs_storage._clearLazy_p {return false} if _storage._clearLeadingComments_p != rhs_storage._clearLeadingComments_p {return false} if _storage._clearMapEntry_p != rhs_storage._clearMapEntry_p {return false} + if _storage._clearMaximumEdition_p != rhs_storage._clearMaximumEdition_p {return false} + if _storage._clearMessageEncoding_p != rhs_storage._clearMessageEncoding_p {return false} if _storage._clearMessageSetWireFormat_p != rhs_storage._clearMessageSetWireFormat_p {return false} + if _storage._clearMinimumEdition_p != rhs_storage._clearMinimumEdition_p {return false} if _storage._clearName_p != rhs_storage._clearName_p {return false} if _storage._clearNamePart_p != rhs_storage._clearNamePart_p {return false} if _storage._clearNegativeIntValue_p != rhs_storage._clearNegativeIntValue_p {return false} @@ -10619,16 +11528,22 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._clearOptimizeFor_p != rhs_storage._clearOptimizeFor_p {return false} if _storage._clearOptions_p != rhs_storage._clearOptions_p {return false} if _storage._clearOutputType_p != rhs_storage._clearOutputType_p {return false} + if _storage._clearOverridableFeatures_p != rhs_storage._clearOverridableFeatures_p {return false} if _storage._clearPackage_p != rhs_storage._clearPackage_p {return false} if _storage._clearPacked_p != rhs_storage._clearPacked_p {return false} if _storage._clearPhpClassPrefix_p != rhs_storage._clearPhpClassPrefix_p {return false} - if _storage._clearPhpGenericServices_p != rhs_storage._clearPhpGenericServices_p {return false} if _storage._clearPhpMetadataNamespace_p != rhs_storage._clearPhpMetadataNamespace_p {return false} if _storage._clearPhpNamespace_p != rhs_storage._clearPhpNamespace_p {return false} if _storage._clearPositiveIntValue_p != rhs_storage._clearPositiveIntValue_p {return false} if _storage._clearProto3Optional_p != rhs_storage._clearProto3Optional_p {return false} if _storage._clearPyGenericServices_p != rhs_storage._clearPyGenericServices_p {return false} + if _storage._clearRemovalError_p != rhs_storage._clearRemovalError_p {return false} + if _storage._clearRepeated_p != rhs_storage._clearRepeated_p {return false} + if _storage._clearRepeatedFieldEncoding_p != rhs_storage._clearRepeatedFieldEncoding_p {return false} + if _storage._clearReserved_p != rhs_storage._clearReserved_p {return false} + if _storage._clearRetention_p != rhs_storage._clearRetention_p {return false} if _storage._clearRubyPackage_p != rhs_storage._clearRubyPackage_p {return false} + if _storage._clearSemantic_p != rhs_storage._clearSemantic_p {return false} if _storage._clearServerStreaming_p != rhs_storage._clearServerStreaming_p {return false} if _storage._clearSourceCodeInfo_p != rhs_storage._clearSourceCodeInfo_p {return false} if _storage._clearSourceContext_p != rhs_storage._clearSourceContext_p {return false} @@ -10640,22 +11555,30 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._clearTrailingComments_p != rhs_storage._clearTrailingComments_p {return false} if _storage._clearType_p != rhs_storage._clearType_p {return false} if _storage._clearTypeName_p != rhs_storage._clearTypeName_p {return false} + if _storage._clearUnverifiedLazy_p != rhs_storage._clearUnverifiedLazy_p {return false} + if _storage._clearUtf8Validation_p != rhs_storage._clearUtf8Validation_p {return false} if _storage._clearValue_p != rhs_storage._clearValue_p {return false} + if _storage._clearVerification_p != rhs_storage._clearVerification_p {return false} + if _storage._clearVisibility_p != rhs_storage._clearVisibility_p {return false} if _storage._clearWeak_p != rhs_storage._clearWeak_p {return false} if _storage._clientStreaming != rhs_storage._clientStreaming {return false} + if _storage._code != rhs_storage._code {return false} if _storage._codePoint != rhs_storage._codePoint {return false} if _storage._codeUnits != rhs_storage._codeUnits {return false} if _storage._collection != rhs_storage._collection {return false} - if _storage._com != rhs_storage._com {return false} if _storage._comma != rhs_storage._comma {return false} + if _storage._consumedBytes != rhs_storage._consumedBytes {return false} + if _storage._contains != rhs_storage._contains {return false} if _storage._contentsOf != rhs_storage._contentsOf {return false} if _storage._contiguousBytes != rhs_storage._contiguousBytes {return false} + if _storage._copy != rhs_storage._copy {return false} if _storage._count != rhs_storage._count {return false} if _storage._countVarintsInBuffer != rhs_storage._countVarintsInBuffer {return false} if _storage._csharpNamespace != rhs_storage._csharpNamespace {return false} if _storage._ctype != rhs_storage._ctype {return false} if _storage._customCodable != rhs_storage._customCodable {return false} if _storage._customDebugStringConvertible != rhs_storage._customDebugStringConvertible {return false} + if _storage._customStringConvertible != rhs_storage._customStringConvertible {return false} if _storage._d != rhs_storage._d {return false} if _storage._data != rhs_storage._data {return false} if _storage._dataResult != rhs_storage._dataResult {return false} @@ -10663,6 +11586,8 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._daySec != rhs_storage._daySec {return false} if _storage._daysSinceEpoch != rhs_storage._daysSinceEpoch {return false} if _storage._debugDescription_p != rhs_storage._debugDescription_p {return false} + if _storage._debugRedact != rhs_storage._debugRedact {return false} + if _storage._declaration != rhs_storage._declaration {return false} if _storage._decoded != rhs_storage._decoded {return false} if _storage._decodedFromJsonnull != rhs_storage._decodedFromJsonnull {return false} if _storage._decodeExtensionField != rhs_storage._decodeExtensionField {return false} @@ -10711,11 +11636,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._decodeSingularUint64Field != rhs_storage._decodeSingularUint64Field {return false} if _storage._decodeTextFormat != rhs_storage._decodeTextFormat {return false} if _storage._defaultAnyTypeUrlprefix != rhs_storage._defaultAnyTypeUrlprefix {return false} + if _storage._defaults != rhs_storage._defaults {return false} + if _storage._defaultSymbolVisibility != rhs_storage._defaultSymbolVisibility {return false} if _storage._defaultValue != rhs_storage._defaultValue {return false} if _storage._dependency != rhs_storage._dependency {return false} if _storage._deprecated != rhs_storage._deprecated {return false} + if _storage._deprecatedLegacyJsonFieldConflicts != rhs_storage._deprecatedLegacyJsonFieldConflicts {return false} + if _storage._deprecationWarning != rhs_storage._deprecationWarning {return false} if _storage._description_p != rhs_storage._description_p {return false} - if _storage._descriptorProto != rhs_storage._descriptorProto {return false} if _storage._dictionary != rhs_storage._dictionary {return false} if _storage._dictionaryLiteral != rhs_storage._dictionaryLiteral {return false} if _storage._digit != rhs_storage._digit {return false} @@ -10726,17 +11654,23 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._digitValue != rhs_storage._digitValue {return false} if _storage._discardableResult != rhs_storage._discardableResult {return false} if _storage._discardUnknownFields != rhs_storage._discardUnknownFields {return false} - if _storage._distance != rhs_storage._distance {return false} if _storage._double != rhs_storage._double {return false} if _storage._doubleValue != rhs_storage._doubleValue {return false} if _storage._duration != rhs_storage._duration {return false} if _storage._e != rhs_storage._e {return false} + if _storage._edition != rhs_storage._edition {return false} + if _storage._editionDefault != rhs_storage._editionDefault {return false} + if _storage._editionDefaults != rhs_storage._editionDefaults {return false} + if _storage._editionDeprecated != rhs_storage._editionDeprecated {return false} + if _storage._editionIntroduced != rhs_storage._editionIntroduced {return false} + if _storage._editionRemoved != rhs_storage._editionRemoved {return false} if _storage._element != rhs_storage._element {return false} if _storage._elements != rhs_storage._elements {return false} + if _storage._else != rhs_storage._else {return false} if _storage._emitExtensionFieldName != rhs_storage._emitExtensionFieldName {return false} if _storage._emitFieldName != rhs_storage._emitFieldName {return false} if _storage._emitFieldNumber != rhs_storage._emitFieldNumber {return false} - if _storage._empty != rhs_storage._empty {return false} + if _storage._emptyAnyTypeURL != rhs_storage._emptyAnyTypeURL {return false} if _storage._emptyData != rhs_storage._emptyData {return false} if _storage._encodeAsBytes != rhs_storage._encodeAsBytes {return false} if _storage._encoded != rhs_storage._encoded {return false} @@ -10749,16 +11683,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._endMessageField != rhs_storage._endMessageField {return false} if _storage._endObject != rhs_storage._endObject {return false} if _storage._endRegularField != rhs_storage._endRegularField {return false} + if _storage._enforceNamingStyle != rhs_storage._enforceNamingStyle {return false} if _storage._enum != rhs_storage._enum {return false} - if _storage._enumDescriptorProto != rhs_storage._enumDescriptorProto {return false} - if _storage._enumOptions != rhs_storage._enumOptions {return false} if _storage._enumReservedRange != rhs_storage._enumReservedRange {return false} if _storage._enumType != rhs_storage._enumType {return false} if _storage._enumvalue != rhs_storage._enumvalue {return false} - if _storage._enumValueDescriptorProto != rhs_storage._enumValueDescriptorProto {return false} - if _storage._enumValueOptions != rhs_storage._enumValueOptions {return false} if _storage._equatable != rhs_storage._equatable {return false} if _storage._error != rhs_storage._error {return false} + if _storage._execute != rhs_storage._execute {return false} if _storage._expressibleByArrayLiteral != rhs_storage._expressibleByArrayLiteral {return false} if _storage._expressibleByDictionaryLiteral != rhs_storage._expressibleByDictionaryLiteral {return false} if _storage._ext != rhs_storage._ext {return false} @@ -10773,37 +11705,38 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._extensionFieldValueSet != rhs_storage._extensionFieldValueSet {return false} if _storage._extensionMap != rhs_storage._extensionMap {return false} if _storage._extensionRange != rhs_storage._extensionRange {return false} - if _storage._extensionRangeOptions != rhs_storage._extensionRangeOptions {return false} if _storage._extensions != rhs_storage._extensions {return false} if _storage._extras != rhs_storage._extras {return false} if _storage._f != rhs_storage._f {return false} if _storage._false != rhs_storage._false {return false} + if _storage._features != rhs_storage._features {return false} + if _storage._featureSetEditionDefault != rhs_storage._featureSetEditionDefault {return false} + if _storage._featureSupport != rhs_storage._featureSupport {return false} if _storage._field != rhs_storage._field {return false} if _storage._fieldData != rhs_storage._fieldData {return false} - if _storage._fieldDescriptorProto != rhs_storage._fieldDescriptorProto {return false} - if _storage._fieldMask != rhs_storage._fieldMask {return false} + if _storage._fieldMaskError != rhs_storage._fieldMaskError {return false} if _storage._fieldName != rhs_storage._fieldName {return false} if _storage._fieldNameCount != rhs_storage._fieldNameCount {return false} if _storage._fieldNum != rhs_storage._fieldNum {return false} if _storage._fieldNumber != rhs_storage._fieldNumber {return false} if _storage._fieldNumberForProto != rhs_storage._fieldNumberForProto {return false} - if _storage._fieldOptions != rhs_storage._fieldOptions {return false} + if _storage._fieldPresence != rhs_storage._fieldPresence {return false} if _storage._fields != rhs_storage._fields {return false} if _storage._fieldSize != rhs_storage._fieldSize {return false} if _storage._fieldTag != rhs_storage._fieldTag {return false} if _storage._fieldType != rhs_storage._fieldType {return false} if _storage._file != rhs_storage._file {return false} - if _storage._fileDescriptorProto != rhs_storage._fileDescriptorProto {return false} - if _storage._fileDescriptorSet != rhs_storage._fileDescriptorSet {return false} if _storage._fileName != rhs_storage._fileName {return false} - if _storage._fileOptions != rhs_storage._fileOptions {return false} if _storage._filter != rhs_storage._filter {return false} + if _storage._final != rhs_storage._final {return false} + if _storage._finiteOnly != rhs_storage._finiteOnly {return false} if _storage._first != rhs_storage._first {return false} if _storage._firstItem != rhs_storage._firstItem {return false} + if _storage._fixedFeatures != rhs_storage._fixedFeatures {return false} if _storage._float != rhs_storage._float {return false} if _storage._floatLiteral != rhs_storage._floatLiteral {return false} if _storage._floatLiteralType != rhs_storage._floatLiteralType {return false} - if _storage._floatValue != rhs_storage._floatValue {return false} + if _storage._for != rhs_storage._for {return false} if _storage._forMessageName != rhs_storage._forMessageName {return false} if _storage._formUnion != rhs_storage._formUnion {return false} if _storage._forReadingFrom != rhs_storage._forReadingFrom {return false} @@ -10815,12 +11748,12 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._fromAscii4 != rhs_storage._fromAscii4 {return false} if _storage._fromByteOffset != rhs_storage._fromByteOffset {return false} if _storage._fromHexDigit != rhs_storage._fromHexDigit {return false} + if _storage._fullName != rhs_storage._fullName {return false} if _storage._func != rhs_storage._func {return false} + if _storage._function != rhs_storage._function {return false} if _storage._g != rhs_storage._g {return false} - if _storage._generatedCodeInfo != rhs_storage._generatedCodeInfo {return false} if _storage._get != rhs_storage._get {return false} if _storage._getExtensionValue != rhs_storage._getExtensionValue {return false} - if _storage._googleapis != rhs_storage._googleapis {return false} if _storage._googleProtobufAny != rhs_storage._googleProtobufAny {return false} if _storage._googleProtobufApi != rhs_storage._googleProtobufApi {return false} if _storage._googleProtobufBoolValue != rhs_storage._googleProtobufBoolValue {return false} @@ -10828,6 +11761,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._googleProtobufDescriptorProto != rhs_storage._googleProtobufDescriptorProto {return false} if _storage._googleProtobufDoubleValue != rhs_storage._googleProtobufDoubleValue {return false} if _storage._googleProtobufDuration != rhs_storage._googleProtobufDuration {return false} + if _storage._googleProtobufEdition != rhs_storage._googleProtobufEdition {return false} if _storage._googleProtobufEmpty != rhs_storage._googleProtobufEmpty {return false} if _storage._googleProtobufEnum != rhs_storage._googleProtobufEnum {return false} if _storage._googleProtobufEnumDescriptorProto != rhs_storage._googleProtobufEnumDescriptorProto {return false} @@ -10836,6 +11770,8 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._googleProtobufEnumValueDescriptorProto != rhs_storage._googleProtobufEnumValueDescriptorProto {return false} if _storage._googleProtobufEnumValueOptions != rhs_storage._googleProtobufEnumValueOptions {return false} if _storage._googleProtobufExtensionRangeOptions != rhs_storage._googleProtobufExtensionRangeOptions {return false} + if _storage._googleProtobufFeatureSet != rhs_storage._googleProtobufFeatureSet {return false} + if _storage._googleProtobufFeatureSetDefaults != rhs_storage._googleProtobufFeatureSetDefaults {return false} if _storage._googleProtobufField != rhs_storage._googleProtobufField {return false} if _storage._googleProtobufFieldDescriptorProto != rhs_storage._googleProtobufFieldDescriptorProto {return false} if _storage._googleProtobufFieldMask != rhs_storage._googleProtobufFieldMask {return false} @@ -10863,6 +11799,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._googleProtobufSourceContext != rhs_storage._googleProtobufSourceContext {return false} if _storage._googleProtobufStringValue != rhs_storage._googleProtobufStringValue {return false} if _storage._googleProtobufStruct != rhs_storage._googleProtobufStruct {return false} + if _storage._googleProtobufSymbolVisibility != rhs_storage._googleProtobufSymbolVisibility {return false} if _storage._googleProtobufSyntax != rhs_storage._googleProtobufSyntax {return false} if _storage._googleProtobufTimestamp != rhs_storage._googleProtobufTimestamp {return false} if _storage._googleProtobufType != rhs_storage._googleProtobufType {return false} @@ -10871,12 +11808,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._googleProtobufUninterpretedOption != rhs_storage._googleProtobufUninterpretedOption {return false} if _storage._googleProtobufValue != rhs_storage._googleProtobufValue {return false} if _storage._goPackage != rhs_storage._goPackage {return false} + if _storage._gotData != rhs_storage._gotData {return false} if _storage._group != rhs_storage._group {return false} if _storage._groupFieldNumberStack != rhs_storage._groupFieldNumberStack {return false} if _storage._groupSize != rhs_storage._groupSize {return false} - if _storage._h != rhs_storage._h {return false} + if _storage._guard != rhs_storage._guard {return false} if _storage._hadOneofValue != rhs_storage._hadOneofValue {return false} if _storage._handleConflictingOneOf != rhs_storage._handleConflictingOneOf {return false} + if _storage._handleInstruction != rhs_storage._handleInstruction {return false} if _storage._hasAggregateValue_p != rhs_storage._hasAggregateValue_p {return false} if _storage._hasAllowAlias_p != rhs_storage._hasAllowAlias_p {return false} if _storage._hasBegin_p != rhs_storage._hasBegin_p {return false} @@ -10885,17 +11824,33 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._hasClientStreaming_p != rhs_storage._hasClientStreaming_p {return false} if _storage._hasCsharpNamespace_p != rhs_storage._hasCsharpNamespace_p {return false} if _storage._hasCtype_p != rhs_storage._hasCtype_p {return false} + if _storage._hasData_p != rhs_storage._hasData_p {return false} + if _storage._hasDebugRedact_p != rhs_storage._hasDebugRedact_p {return false} + if _storage._hasDefaultSymbolVisibility_p != rhs_storage._hasDefaultSymbolVisibility_p {return false} if _storage._hasDefaultValue_p != rhs_storage._hasDefaultValue_p {return false} if _storage._hasDeprecated_p != rhs_storage._hasDeprecated_p {return false} + if _storage._hasDeprecatedLegacyJsonFieldConflicts_p != rhs_storage._hasDeprecatedLegacyJsonFieldConflicts_p {return false} + if _storage._hasDeprecationWarning_p != rhs_storage._hasDeprecationWarning_p {return false} if _storage._hasDoubleValue_p != rhs_storage._hasDoubleValue_p {return false} + if _storage._hasEdition_p != rhs_storage._hasEdition_p {return false} + if _storage._hasEditionDeprecated_p != rhs_storage._hasEditionDeprecated_p {return false} + if _storage._hasEditionIntroduced_p != rhs_storage._hasEditionIntroduced_p {return false} + if _storage._hasEditionRemoved_p != rhs_storage._hasEditionRemoved_p {return false} if _storage._hasEnd_p != rhs_storage._hasEnd_p {return false} + if _storage._hasEnforceNamingStyle_p != rhs_storage._hasEnforceNamingStyle_p {return false} + if _storage._hasEnumType_p != rhs_storage._hasEnumType_p {return false} + if _storage._hasExplicitDelta_p != rhs_storage._hasExplicitDelta_p {return false} if _storage._hasExtendee_p != rhs_storage._hasExtendee_p {return false} if _storage._hasExtensionValue_p != rhs_storage._hasExtensionValue_p {return false} + if _storage._hasFeatures_p != rhs_storage._hasFeatures_p {return false} + if _storage._hasFeatureSupport_p != rhs_storage._hasFeatureSupport_p {return false} + if _storage._hasFieldPresence_p != rhs_storage._hasFieldPresence_p {return false} + if _storage._hasFixedFeatures_p != rhs_storage._hasFixedFeatures_p {return false} + if _storage._hasFullName_p != rhs_storage._hasFullName_p {return false} if _storage._hasGoPackage_p != rhs_storage._hasGoPackage_p {return false} if _storage._hash != rhs_storage._hash {return false} if _storage._hashable != rhs_storage._hashable {return false} if _storage._hasher != rhs_storage._hasher {return false} - if _storage._hashValue_p != rhs_storage._hashValue_p {return false} if _storage._hashVisitor != rhs_storage._hashVisitor {return false} if _storage._hasIdempotencyLevel_p != rhs_storage._hasIdempotencyLevel_p {return false} if _storage._hasIdentifierValue_p != rhs_storage._hasIdentifierValue_p {return false} @@ -10907,13 +11862,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._hasJavaOuterClassname_p != rhs_storage._hasJavaOuterClassname_p {return false} if _storage._hasJavaPackage_p != rhs_storage._hasJavaPackage_p {return false} if _storage._hasJavaStringCheckUtf8_p != rhs_storage._hasJavaStringCheckUtf8_p {return false} + if _storage._hasJsonFormat_p != rhs_storage._hasJsonFormat_p {return false} if _storage._hasJsonName_p != rhs_storage._hasJsonName_p {return false} if _storage._hasJstype_p != rhs_storage._hasJstype_p {return false} if _storage._hasLabel_p != rhs_storage._hasLabel_p {return false} if _storage._hasLazy_p != rhs_storage._hasLazy_p {return false} if _storage._hasLeadingComments_p != rhs_storage._hasLeadingComments_p {return false} if _storage._hasMapEntry_p != rhs_storage._hasMapEntry_p {return false} + if _storage._hasMaximumEdition_p != rhs_storage._hasMaximumEdition_p {return false} + if _storage._hasMessageEncoding_p != rhs_storage._hasMessageEncoding_p {return false} if _storage._hasMessageSetWireFormat_p != rhs_storage._hasMessageSetWireFormat_p {return false} + if _storage._hasMinimumEdition_p != rhs_storage._hasMinimumEdition_p {return false} if _storage._hasName_p != rhs_storage._hasName_p {return false} if _storage._hasNamePart_p != rhs_storage._hasNamePart_p {return false} if _storage._hasNegativeIntValue_p != rhs_storage._hasNegativeIntValue_p {return false} @@ -10924,16 +11883,22 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._hasOptimizeFor_p != rhs_storage._hasOptimizeFor_p {return false} if _storage._hasOptions_p != rhs_storage._hasOptions_p {return false} if _storage._hasOutputType_p != rhs_storage._hasOutputType_p {return false} + if _storage._hasOverridableFeatures_p != rhs_storage._hasOverridableFeatures_p {return false} if _storage._hasPackage_p != rhs_storage._hasPackage_p {return false} if _storage._hasPacked_p != rhs_storage._hasPacked_p {return false} if _storage._hasPhpClassPrefix_p != rhs_storage._hasPhpClassPrefix_p {return false} - if _storage._hasPhpGenericServices_p != rhs_storage._hasPhpGenericServices_p {return false} if _storage._hasPhpMetadataNamespace_p != rhs_storage._hasPhpMetadataNamespace_p {return false} if _storage._hasPhpNamespace_p != rhs_storage._hasPhpNamespace_p {return false} if _storage._hasPositiveIntValue_p != rhs_storage._hasPositiveIntValue_p {return false} if _storage._hasProto3Optional_p != rhs_storage._hasProto3Optional_p {return false} if _storage._hasPyGenericServices_p != rhs_storage._hasPyGenericServices_p {return false} + if _storage._hasRemovalError_p != rhs_storage._hasRemovalError_p {return false} + if _storage._hasRepeated_p != rhs_storage._hasRepeated_p {return false} + if _storage._hasRepeatedFieldEncoding_p != rhs_storage._hasRepeatedFieldEncoding_p {return false} + if _storage._hasReserved_p != rhs_storage._hasReserved_p {return false} + if _storage._hasRetention_p != rhs_storage._hasRetention_p {return false} if _storage._hasRubyPackage_p != rhs_storage._hasRubyPackage_p {return false} + if _storage._hasSemantic_p != rhs_storage._hasSemantic_p {return false} if _storage._hasServerStreaming_p != rhs_storage._hasServerStreaming_p {return false} if _storage._hasSourceCodeInfo_p != rhs_storage._hasSourceCodeInfo_p {return false} if _storage._hasSourceContext_p != rhs_storage._hasSourceContext_p {return false} @@ -10945,40 +11910,49 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._hasTrailingComments_p != rhs_storage._hasTrailingComments_p {return false} if _storage._hasType_p != rhs_storage._hasType_p {return false} if _storage._hasTypeName_p != rhs_storage._hasTypeName_p {return false} + if _storage._hasUnverifiedLazy_p != rhs_storage._hasUnverifiedLazy_p {return false} + if _storage._hasUtf8Validation_p != rhs_storage._hasUtf8Validation_p {return false} if _storage._hasValue_p != rhs_storage._hasValue_p {return false} + if _storage._hasVerification_p != rhs_storage._hasVerification_p {return false} + if _storage._hasVisibility_p != rhs_storage._hasVisibility_p {return false} if _storage._hasWeak_p != rhs_storage._hasWeak_p {return false} if _storage._hour != rhs_storage._hour {return false} if _storage._i != rhs_storage._i {return false} if _storage._idempotencyLevel != rhs_storage._idempotencyLevel {return false} if _storage._identifierValue != rhs_storage._identifierValue {return false} if _storage._if != rhs_storage._if {return false} + if _storage._ignoreUnknownExtensionFields != rhs_storage._ignoreUnknownExtensionFields {return false} if _storage._ignoreUnknownFields != rhs_storage._ignoreUnknownFields {return false} if _storage._index != rhs_storage._index {return false} if _storage._init_p != rhs_storage._init_p {return false} if _storage._inout != rhs_storage._inout {return false} if _storage._inputType != rhs_storage._inputType {return false} if _storage._insert != rhs_storage._insert {return false} + if _storage._instruction != rhs_storage._instruction {return false} if _storage._int != rhs_storage._int {return false} if _storage._int32 != rhs_storage._int32 {return false} - if _storage._int32Value != rhs_storage._int32Value {return false} if _storage._int64 != rhs_storage._int64 {return false} - if _storage._int64Value != rhs_storage._int64Value {return false} if _storage._int8 != rhs_storage._int8 {return false} if _storage._integerLiteral != rhs_storage._integerLiteral {return false} if _storage._integerLiteralType != rhs_storage._integerLiteralType {return false} if _storage._intern != rhs_storage._intern {return false} if _storage._internal != rhs_storage._internal {return false} if _storage._internalState != rhs_storage._internalState {return false} + if _storage._intersect != rhs_storage._intersect {return false} if _storage._into != rhs_storage._into {return false} if _storage._ints != rhs_storage._ints {return false} + if _storage._invalidAnyTypeURL != rhs_storage._invalidAnyTypeURL {return false} if _storage._isA != rhs_storage._isA {return false} if _storage._isEqual != rhs_storage._isEqual {return false} if _storage._isEqualTo != rhs_storage._isEqualTo {return false} if _storage._isExtension != rhs_storage._isExtension {return false} if _storage._isInitialized_p != rhs_storage._isInitialized_p {return false} + if _storage._isNegative != rhs_storage._isNegative {return false} + if _storage._isPathValid != rhs_storage._isPathValid {return false} + if _storage._isReserved != rhs_storage._isReserved {return false} + if _storage._isValid != rhs_storage._isValid {return false} if _storage._itemTagsEncodedSize != rhs_storage._itemTagsEncodedSize {return false} if _storage._iterator != rhs_storage._iterator {return false} - if _storage._i2166136261 != rhs_storage._i2166136261 {return false} if _storage._javaGenerateEqualsAndHash != rhs_storage._javaGenerateEqualsAndHash {return false} if _storage._javaGenericServices != rhs_storage._javaGenericServices {return false} if _storage._javaMultipleFiles != rhs_storage._javaMultipleFiles {return false} @@ -10986,12 +11960,15 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._javaPackage != rhs_storage._javaPackage {return false} if _storage._javaStringCheckUtf8 != rhs_storage._javaStringCheckUtf8 {return false} if _storage._jsondecoder != rhs_storage._jsondecoder {return false} + if _storage._jsondecoding != rhs_storage._jsondecoding {return false} if _storage._jsondecodingError != rhs_storage._jsondecodingError {return false} if _storage._jsondecodingOptions != rhs_storage._jsondecodingOptions {return false} if _storage._jsonEncoder != rhs_storage._jsonEncoder {return false} + if _storage._jsonencoding != rhs_storage._jsonencoding {return false} if _storage._jsonencodingError != rhs_storage._jsonencodingError {return false} if _storage._jsonencodingOptions != rhs_storage._jsonencodingOptions {return false} if _storage._jsonencodingVisitor != rhs_storage._jsonencodingVisitor {return false} + if _storage._jsonFormat != rhs_storage._jsonFormat {return false} if _storage._jsonmapEncodingVisitor != rhs_storage._jsonmapEncodingVisitor {return false} if _storage._jsonName != rhs_storage._jsonName {return false} if _storage._jsonPath != rhs_storage._jsonPath {return false} @@ -10999,11 +11976,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._jsonscanner != rhs_storage._jsonscanner {return false} if _storage._jsonString != rhs_storage._jsonString {return false} if _storage._jsonText != rhs_storage._jsonText {return false} + if _storage._jsonUtf8Bytes != rhs_storage._jsonUtf8Bytes {return false} if _storage._jsonUtf8Data != rhs_storage._jsonUtf8Data {return false} if _storage._jstype != rhs_storage._jstype {return false} if _storage._k != rhs_storage._k {return false} + if _storage._kChunkSize != rhs_storage._kChunkSize {return false} if _storage._key != rhs_storage._key {return false} if _storage._keyField != rhs_storage._keyField {return false} + if _storage._keyFieldOpt != rhs_storage._keyFieldOpt {return false} if _storage._keyType != rhs_storage._keyType {return false} if _storage._kind != rhs_storage._kind {return false} if _storage._l != rhs_storage._l {return false} @@ -11015,42 +11995,44 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._lessThan != rhs_storage._lessThan {return false} if _storage._let != rhs_storage._let {return false} if _storage._lhs != rhs_storage._lhs {return false} + if _storage._line != rhs_storage._line {return false} if _storage._list != rhs_storage._list {return false} if _storage._listOfMessages != rhs_storage._listOfMessages {return false} if _storage._listValue != rhs_storage._listValue {return false} if _storage._littleEndian != rhs_storage._littleEndian {return false} - if _storage._littleEndianBytes != rhs_storage._littleEndianBytes {return false} if _storage._load != rhs_storage._load {return false} if _storage._localHasher != rhs_storage._localHasher {return false} if _storage._location != rhs_storage._location {return false} if _storage._m != rhs_storage._m {return false} if _storage._major != rhs_storage._major {return false} + if _storage._makeAsyncIterator != rhs_storage._makeAsyncIterator {return false} if _storage._makeIterator != rhs_storage._makeIterator {return false} + if _storage._malformedLength != rhs_storage._malformedLength {return false} if _storage._mapEntry != rhs_storage._mapEntry {return false} - if _storage._mapHash != rhs_storage._mapHash {return false} if _storage._mapKeyType != rhs_storage._mapKeyType {return false} - if _storage._mapNameResolver != rhs_storage._mapNameResolver {return false} if _storage._mapToMessages != rhs_storage._mapToMessages {return false} if _storage._mapValueType != rhs_storage._mapValueType {return false} if _storage._mapVisitor != rhs_storage._mapVisitor {return false} + if _storage._mask != rhs_storage._mask {return false} + if _storage._maximumEdition != rhs_storage._maximumEdition {return false} if _storage._mdayStart != rhs_storage._mdayStart {return false} if _storage._merge != rhs_storage._merge {return false} + if _storage._mergeOptions != rhs_storage._mergeOptions {return false} if _storage._message != rhs_storage._message {return false} if _storage._messageDepthLimit != rhs_storage._messageDepthLimit {return false} + if _storage._messageEncoding != rhs_storage._messageEncoding {return false} if _storage._messageExtension != rhs_storage._messageExtension {return false} if _storage._messageImplementationBase != rhs_storage._messageImplementationBase {return false} - if _storage._messageOptions != rhs_storage._messageOptions {return false} if _storage._messageSet != rhs_storage._messageSet {return false} if _storage._messageSetWireFormat != rhs_storage._messageSetWireFormat {return false} + if _storage._messageSize != rhs_storage._messageSize {return false} if _storage._messageType != rhs_storage._messageType {return false} if _storage._method != rhs_storage._method {return false} - if _storage._methodDescriptorProto != rhs_storage._methodDescriptorProto {return false} - if _storage._methodOptions != rhs_storage._methodOptions {return false} if _storage._methods != rhs_storage._methods {return false} + if _storage._min != rhs_storage._min {return false} + if _storage._minimumEdition != rhs_storage._minimumEdition {return false} if _storage._minor != rhs_storage._minor {return false} - if _storage._mixin != rhs_storage._mixin {return false} if _storage._mixins != rhs_storage._mixins {return false} - if _storage._modifier != rhs_storage._modifier {return false} if _storage._modify != rhs_storage._modify {return false} if _storage._month != rhs_storage._month {return false} if _storage._msgExtension != rhs_storage._msgExtension {return false} @@ -11060,44 +12042,53 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._nameDescription != rhs_storage._nameDescription {return false} if _storage._nameMap != rhs_storage._nameMap {return false} if _storage._namePart != rhs_storage._namePart {return false} - if _storage._nameResolver != rhs_storage._nameResolver {return false} if _storage._names != rhs_storage._names {return false} if _storage._nanos != rhs_storage._nanos {return false} - if _storage._nativeBytes != rhs_storage._nativeBytes {return false} - if _storage._nativeEndianBytes != rhs_storage._nativeEndianBytes {return false} if _storage._negativeIntValue != rhs_storage._negativeIntValue {return false} if _storage._nestedType != rhs_storage._nestedType {return false} + if _storage._newExtensible != rhs_storage._newExtensible {return false} if _storage._newL != rhs_storage._newL {return false} if _storage._newList != rhs_storage._newList {return false} + if _storage._newMessage != rhs_storage._newMessage {return false} if _storage._newValue != rhs_storage._newValue {return false} + if _storage._next != rhs_storage._next {return false} if _storage._nextByte != rhs_storage._nextByte {return false} if _storage._nextFieldNumber != rhs_storage._nextFieldNumber {return false} + if _storage._nextInstruction != rhs_storage._nextInstruction {return false} + if _storage._nextInt32 != rhs_storage._nextInt32 {return false} + if _storage._nextNullTerminatedString != rhs_storage._nextNullTerminatedString {return false} + if _storage._nextNullTerminatedStringArray != rhs_storage._nextNullTerminatedStringArray {return false} + if _storage._nextNumber != rhs_storage._nextNumber {return false} + if _storage._nextUint64 != rhs_storage._nextUint64 {return false} + if _storage._nextVarInt != rhs_storage._nextVarInt {return false} if _storage._nil != rhs_storage._nil {return false} if _storage._nilLiteral != rhs_storage._nilLiteral {return false} + if _storage._noBytesAvailable != rhs_storage._noBytesAvailable {return false} if _storage._noStandardDescriptorAccessor != rhs_storage._noStandardDescriptorAccessor {return false} if _storage._nullValue != rhs_storage._nullValue {return false} if _storage._number != rhs_storage._number {return false} if _storage._numberValue != rhs_storage._numberValue {return false} if _storage._objcClassPrefix != rhs_storage._objcClassPrefix {return false} if _storage._of != rhs_storage._of {return false} + if _storage._oneOfKind != rhs_storage._oneOfKind {return false} if _storage._oneofDecl != rhs_storage._oneofDecl {return false} - if _storage._oneofDescriptorProto != rhs_storage._oneofDescriptorProto {return false} if _storage._oneofIndex != rhs_storage._oneofIndex {return false} - if _storage._oneofOptions != rhs_storage._oneofOptions {return false} if _storage._oneofs != rhs_storage._oneofs {return false} - if _storage._oneOfKind != rhs_storage._oneOfKind {return false} if _storage._optimizeFor != rhs_storage._optimizeFor {return false} if _storage._optimizeMode != rhs_storage._optimizeMode {return false} - if _storage._option != rhs_storage._option {return false} if _storage._optionalEnumExtensionField != rhs_storage._optionalEnumExtensionField {return false} if _storage._optionalExtensionField != rhs_storage._optionalExtensionField {return false} if _storage._optionalGroupExtensionField != rhs_storage._optionalGroupExtensionField {return false} if _storage._optionalMessageExtensionField != rhs_storage._optionalMessageExtensionField {return false} + if _storage._optionDependency != rhs_storage._optionDependency {return false} + if _storage._optionRetention != rhs_storage._optionRetention {return false} if _storage._options != rhs_storage._options {return false} + if _storage._optionTargetType != rhs_storage._optionTargetType {return false} if _storage._other != rhs_storage._other {return false} if _storage._others != rhs_storage._others {return false} if _storage._out != rhs_storage._out {return false} if _storage._outputType != rhs_storage._outputType {return false} + if _storage._overridableFeatures != rhs_storage._overridableFeatures {return false} if _storage._p != rhs_storage._p {return false} if _storage._package != rhs_storage._package {return false} if _storage._packed != rhs_storage._packed {return false} @@ -11108,27 +12099,39 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._parse != rhs_storage._parse {return false} if _storage._partial != rhs_storage._partial {return false} if _storage._path != rhs_storage._path {return false} + if _storage._pathDecoder != rhs_storage._pathDecoder {return false} + if _storage._pathDecodingError != rhs_storage._pathDecodingError {return false} if _storage._paths != rhs_storage._paths {return false} + if _storage._pathVisitor != rhs_storage._pathVisitor {return false} if _storage._payload != rhs_storage._payload {return false} if _storage._payloadSize != rhs_storage._payloadSize {return false} if _storage._phpClassPrefix != rhs_storage._phpClassPrefix {return false} - if _storage._phpGenericServices != rhs_storage._phpGenericServices {return false} if _storage._phpMetadataNamespace != rhs_storage._phpMetadataNamespace {return false} if _storage._phpNamespace != rhs_storage._phpNamespace {return false} - if _storage._pointer != rhs_storage._pointer {return false} if _storage._pos != rhs_storage._pos {return false} if _storage._positiveIntValue != rhs_storage._positiveIntValue {return false} if _storage._prefix != rhs_storage._prefix {return false} if _storage._preserveProtoFieldNames != rhs_storage._preserveProtoFieldNames {return false} if _storage._preTraverse != rhs_storage._preTraverse {return false} + if _storage._previousNumber != rhs_storage._previousNumber {return false} + if _storage._prevPath != rhs_storage._prevPath {return false} if _storage._printUnknownFields != rhs_storage._printUnknownFields {return false} + if _storage._programBuffer != rhs_storage._programBuffer {return false} + if _storage._programFormat != rhs_storage._programFormat {return false} if _storage._proto2 != rhs_storage._proto2 {return false} if _storage._proto3DefaultValue != rhs_storage._proto3DefaultValue {return false} if _storage._proto3Optional != rhs_storage._proto3Optional {return false} - if _storage._protobufApiversionCheck != rhs_storage._protobufApiversionCheck {return false} + if _storage._protobufExtensionFieldValues != rhs_storage._protobufExtensionFieldValues {return false} + if _storage._protobufFieldNumber != rhs_storage._protobufFieldNumber {return false} + if _storage._protobufGeneratedIsEqualTo != rhs_storage._protobufGeneratedIsEqualTo {return false} + if _storage._protobufNameMap != rhs_storage._protobufNameMap {return false} + if _storage._protobufNewField != rhs_storage._protobufNewField {return false} + if _storage._protobufPackage != rhs_storage._protobufPackage {return false} if _storage._protobufApiversion2 != rhs_storage._protobufApiversion2 {return false} + if _storage._protobufApiversionCheck != rhs_storage._protobufApiversionCheck {return false} if _storage._protobufBool != rhs_storage._protobufBool {return false} if _storage._protobufBytes != rhs_storage._protobufBytes {return false} + if _storage._protobufData != rhs_storage._protobufData {return false} if _storage._protobufDouble != rhs_storage._protobufDouble {return false} if _storage._protobufEnumMap != rhs_storage._protobufEnumMap {return false} if _storage._protobufExtension != rhs_storage._protobufExtension {return false} @@ -11146,12 +12149,6 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._protobufString != rhs_storage._protobufString {return false} if _storage._protobufUint32 != rhs_storage._protobufUint32 {return false} if _storage._protobufUint64 != rhs_storage._protobufUint64 {return false} - if _storage._protobufExtensionFieldValues != rhs_storage._protobufExtensionFieldValues {return false} - if _storage._protobufFieldNumber != rhs_storage._protobufFieldNumber {return false} - if _storage._protobufGeneratedIsEqualTo != rhs_storage._protobufGeneratedIsEqualTo {return false} - if _storage._protobufNameMap != rhs_storage._protobufNameMap {return false} - if _storage._protobufNewField != rhs_storage._protobufNewField {return false} - if _storage._protobufPackage != rhs_storage._protobufPackage {return false} if _storage._protocol != rhs_storage._protocol {return false} if _storage._protoFieldName != rhs_storage._protoFieldName {return false} if _storage._protoMessageName != rhs_storage._protoMessageName {return false} @@ -11173,25 +12170,33 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._putVarInt != rhs_storage._putVarInt {return false} if _storage._putZigZagVarInt != rhs_storage._putZigZagVarInt {return false} if _storage._pyGenericServices != rhs_storage._pyGenericServices {return false} + if _storage._r != rhs_storage._r {return false} if _storage._rawChars != rhs_storage._rawChars {return false} if _storage._rawRepresentable != rhs_storage._rawRepresentable {return false} if _storage._rawValue != rhs_storage._rawValue {return false} if _storage._read4HexDigits != rhs_storage._read4HexDigits {return false} + if _storage._readBytes != rhs_storage._readBytes {return false} + if _storage._reader != rhs_storage._reader {return false} if _storage._register != rhs_storage._register {return false} + if _storage._remainingProgram != rhs_storage._remainingProgram {return false} + if _storage._removalError != rhs_storage._removalError {return false} + if _storage._removingAllFieldsOf != rhs_storage._removingAllFieldsOf {return false} + if _storage._repeated != rhs_storage._repeated {return false} if _storage._repeatedEnumExtensionField != rhs_storage._repeatedEnumExtensionField {return false} if _storage._repeatedExtensionField != rhs_storage._repeatedExtensionField {return false} + if _storage._repeatedFieldEncoding != rhs_storage._repeatedFieldEncoding {return false} if _storage._repeatedGroupExtensionField != rhs_storage._repeatedGroupExtensionField {return false} if _storage._repeatedMessageExtensionField != rhs_storage._repeatedMessageExtensionField {return false} + if _storage._repeating != rhs_storage._repeating {return false} + if _storage._replaceRepeatedFields != rhs_storage._replaceRepeatedFields {return false} if _storage._requestStreaming != rhs_storage._requestStreaming {return false} if _storage._requestTypeURL != rhs_storage._requestTypeURL {return false} if _storage._requiredSize != rhs_storage._requiredSize {return false} - if _storage._reservedName != rhs_storage._reservedName {return false} - if _storage._reservedRange != rhs_storage._reservedRange {return false} if _storage._responseStreaming != rhs_storage._responseStreaming {return false} if _storage._responseTypeURL != rhs_storage._responseTypeURL {return false} if _storage._result != rhs_storage._result {return false} + if _storage._retention != rhs_storage._retention {return false} if _storage._rethrows != rhs_storage._rethrows {return false} - if _storage._return != rhs_storage._return {return false} if _storage._returnType != rhs_storage._returnType {return false} if _storage._revision != rhs_storage._revision {return false} if _storage._rhs != rhs_storage._rhs {return false} @@ -11201,27 +12206,32 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._sawBackslash != rhs_storage._sawBackslash {return false} if _storage._sawSection4Characters != rhs_storage._sawSection4Characters {return false} if _storage._sawSection5Characters != rhs_storage._sawSection5Characters {return false} + if _storage._scalar != rhs_storage._scalar {return false} + if _storage._scan != rhs_storage._scan {return false} if _storage._scanner != rhs_storage._scanner {return false} if _storage._seconds != rhs_storage._seconds {return false} if _storage._self_p != rhs_storage._self_p {return false} + if _storage._semantic != rhs_storage._semantic {return false} + if _storage._sendable != rhs_storage._sendable {return false} if _storage._separator != rhs_storage._separator {return false} if _storage._serialize != rhs_storage._serialize {return false} + if _storage._serializedBytes != rhs_storage._serializedBytes {return false} if _storage._serializedData != rhs_storage._serializedData {return false} if _storage._serializedSize != rhs_storage._serializedSize {return false} if _storage._serverStreaming != rhs_storage._serverStreaming {return false} if _storage._service != rhs_storage._service {return false} - if _storage._serviceDescriptorProto != rhs_storage._serviceDescriptorProto {return false} - if _storage._serviceOptions != rhs_storage._serviceOptions {return false} if _storage._set != rhs_storage._set {return false} if _storage._setExtensionValue != rhs_storage._setExtensionValue {return false} if _storage._shift != rhs_storage._shift {return false} if _storage._simpleExtensionMap != rhs_storage._simpleExtensionMap {return false} + if _storage._size != rhs_storage._size {return false} if _storage._sizer != rhs_storage._sizer {return false} if _storage._source != rhs_storage._source {return false} if _storage._sourceCodeInfo != rhs_storage._sourceCodeInfo {return false} if _storage._sourceContext != rhs_storage._sourceContext {return false} if _storage._sourceEncoding != rhs_storage._sourceEncoding {return false} if _storage._sourceFile != rhs_storage._sourceFile {return false} + if _storage._sourceLocation != rhs_storage._sourceLocation {return false} if _storage._span != rhs_storage._span {return false} if _storage._split != rhs_storage._split {return false} if _storage._start != rhs_storage._start {return false} @@ -11245,13 +12255,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._structValue != rhs_storage._structValue {return false} if _storage._subDecoder != rhs_storage._subDecoder {return false} if _storage._subscript != rhs_storage._subscript {return false} + if _storage._subtract != rhs_storage._subtract {return false} if _storage._subVisitor != rhs_storage._subVisitor {return false} if _storage._swift != rhs_storage._swift {return false} if _storage._swiftPrefix != rhs_storage._swiftPrefix {return false} - if _storage._swiftProtobuf != rhs_storage._swiftProtobuf {return false} + if _storage._swiftProtobufContiguousBytes != rhs_storage._swiftProtobufContiguousBytes {return false} + if _storage._swiftProtobufError != rhs_storage._swiftProtobufError {return false} if _storage._syntax != rhs_storage._syntax {return false} if _storage._t != rhs_storage._t {return false} if _storage._tag != rhs_storage._tag {return false} + if _storage._targets != rhs_storage._targets {return false} if _storage._terminator != rhs_storage._terminator {return false} if _storage._testDecoder != rhs_storage._testDecoder {return false} if _storage._text != rhs_storage._text {return false} @@ -11262,16 +12275,19 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._textFormatEncodingOptions != rhs_storage._textFormatEncodingOptions {return false} if _storage._textFormatEncodingVisitor != rhs_storage._textFormatEncodingVisitor {return false} if _storage._textFormatString != rhs_storage._textFormatString {return false} + if _storage._throwOrIgnore != rhs_storage._throwOrIgnore {return false} if _storage._throws != rhs_storage._throws {return false} if _storage._timeInterval != rhs_storage._timeInterval {return false} if _storage._timeIntervalSince1970 != rhs_storage._timeIntervalSince1970 {return false} if _storage._timeIntervalSinceReferenceDate != rhs_storage._timeIntervalSinceReferenceDate {return false} - if _storage._timestamp != rhs_storage._timestamp {return false} + if _storage._tmp != rhs_storage._tmp {return false} + if _storage._tooLarge != rhs_storage._tooLarge {return false} if _storage._total != rhs_storage._total {return false} if _storage._totalArrayDepth != rhs_storage._totalArrayDepth {return false} if _storage._totalSize != rhs_storage._totalSize {return false} if _storage._trailingComments != rhs_storage._trailingComments {return false} if _storage._traverse != rhs_storage._traverse {return false} + if _storage._trim != rhs_storage._trim {return false} if _storage._true != rhs_storage._true {return false} if _storage._try != rhs_storage._try {return false} if _storage._type != rhs_storage._type {return false} @@ -11283,10 +12299,10 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._typeUnknown != rhs_storage._typeUnknown {return false} if _storage._typeURL != rhs_storage._typeURL {return false} if _storage._uint32 != rhs_storage._uint32 {return false} - if _storage._uint32Value != rhs_storage._uint32Value {return false} if _storage._uint64 != rhs_storage._uint64 {return false} - if _storage._uint64Value != rhs_storage._uint64Value {return false} if _storage._uint8 != rhs_storage._uint8 {return false} + if _storage._unchecked != rhs_storage._unchecked {return false} + if _storage._unicode != rhs_storage._unicode {return false} if _storage._unicodeScalarLiteral != rhs_storage._unicodeScalarLiteral {return false} if _storage._unicodeScalarLiteralType != rhs_storage._unicodeScalarLiteralType {return false} if _storage._unicodeScalars != rhs_storage._unicodeScalars {return false} @@ -11301,14 +12317,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._unsafeBufferPointer != rhs_storage._unsafeBufferPointer {return false} if _storage._unsafeMutablePointer != rhs_storage._unsafeMutablePointer {return false} if _storage._unsafeMutableRawBufferPointer != rhs_storage._unsafeMutableRawBufferPointer {return false} - if _storage._unsafeMutableRawPointer != rhs_storage._unsafeMutableRawPointer {return false} if _storage._unsafeRawBufferPointer != rhs_storage._unsafeRawBufferPointer {return false} if _storage._unsafeRawPointer != rhs_storage._unsafeRawPointer {return false} + if _storage._unverifiedLazy != rhs_storage._unverifiedLazy {return false} if _storage._updatedOptions != rhs_storage._updatedOptions {return false} + if _storage._uppercasedAssumingAscii != rhs_storage._uppercasedAssumingAscii {return false} if _storage._url != rhs_storage._url {return false} + if _storage._useDeterministicOrdering != rhs_storage._useDeterministicOrdering {return false} if _storage._utf8 != rhs_storage._utf8 {return false} if _storage._utf8Ptr != rhs_storage._utf8Ptr {return false} if _storage._utf8ToDouble != rhs_storage._utf8ToDouble {return false} + if _storage._utf8Validation != rhs_storage._utf8Validation {return false} if _storage._utf8View != rhs_storage._utf8View {return false} if _storage._v != rhs_storage._v {return false} if _storage._value != rhs_storage._value {return false} @@ -11316,8 +12335,12 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._values != rhs_storage._values {return false} if _storage._valueType != rhs_storage._valueType {return false} if _storage._var != rhs_storage._var {return false} + if _storage._verification != rhs_storage._verification {return false} + if _storage._verificationState != rhs_storage._verificationState {return false} if _storage._version != rhs_storage._version {return false} if _storage._versionString != rhs_storage._versionString {return false} + if _storage._visibility != rhs_storage._visibility {return false} + if _storage._visibilityFeature != rhs_storage._visibilityFeature {return false} if _storage._visitExtensionFields != rhs_storage._visitExtensionFields {return false} if _storage._visitExtensionFieldsAsMessageSet != rhs_storage._visitExtensionFieldsAsMessageSet {return false} if _storage._visitMapField != rhs_storage._visitMapField {return false} @@ -11376,6 +12399,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._visitSingularUint32Field != rhs_storage._visitSingularUint32Field {return false} if _storage._visitSingularUint64Field != rhs_storage._visitSingularUint64Field {return false} if _storage._visitUnknown != rhs_storage._visitUnknown {return false} + if _storage._void != rhs_storage._void {return false} if _storage._wasDecoded != rhs_storage._wasDecoded {return false} if _storage._weak != rhs_storage._weak {return false} if _storage._weakDependency != rhs_storage._weakDependency {return false} @@ -11385,7 +12409,9 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._withUnsafeBytes != rhs_storage._withUnsafeBytes {return false} if _storage._withUnsafeMutableBytes != rhs_storage._withUnsafeMutableBytes {return false} if _storage._work != rhs_storage._work {return false} + if _storage._wrapped != rhs_storage._wrapped {return false} if _storage._wrappedType != rhs_storage._wrappedType {return false} + if _storage._wrappedValue != rhs_storage._wrappedValue {return false} if _storage._written != rhs_storage._written {return false} if _storage._yday != rhs_storage._yday {return false} return true diff --git a/Reference/generated_swift_names_messages.pb.swift b/Reference/Tests/SwiftProtobufTests/generated_swift_names_messages.pb.swift similarity index 58% rename from Reference/generated_swift_names_messages.pb.swift rename to Reference/Tests/SwiftProtobufTests/generated_swift_names_messages.pb.swift index 3253d43d4..b772dbc59 100644 --- a/Reference/generated_swift_names_messages.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/generated_swift_names_messages.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: generated_swift_names_messages.proto @@ -11,7 +12,6 @@ /// Protoc errors imply this file is being generated incorrectly /// Swift compile errors are probably bugs in protoc-gen-swift -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -24,14 +24,26 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { +struct SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: Sendable { // 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() - struct adjusted { + struct addPath: Sendable { + // 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 addPath: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct adjusted: Sendable { // 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. @@ -43,7 +55,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct aggregateValue { + struct aggregateValue: Sendable { // 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. @@ -55,7 +67,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct allCases { + struct allCases: Sendable { // 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. @@ -67,7 +79,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct allowAlias { + struct allowAlias: Sendable { // 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. @@ -79,7 +91,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct alwaysPrintEnumsAsInts { + struct alwaysPrintEnumsAsInts: Sendable { // 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. @@ -91,7 +103,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct annotation { + struct alwaysPrintInt64sAsNumbers: Sendable { + // 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 alwaysPrintInt64SAsNumbers: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct annotation: Sendable { // 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. @@ -103,7 +127,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct any { + struct any: Sendable { // 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. @@ -115,7 +139,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct AnyExtensionField { + struct AnyExtensionField: Sendable { // 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. @@ -127,7 +151,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct AnyMessageExtension { + struct AnyMessageExtension: Sendable { // 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. @@ -139,7 +163,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct AnyMessageStorage { + struct AnyMessageStorage: Sendable { // 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. @@ -151,7 +175,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct AnyUnpackError { + struct AnyUnpackError: Sendable { // 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. @@ -163,19 +187,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Api { + struct append: Sendable { // 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 api: Int32 = 0 + var append: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct appended { + struct appended: Sendable { // 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. @@ -187,7 +211,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct appendUIntHex { + struct appendUIntHex: Sendable { // 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. @@ -199,7 +223,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct appendUnknown { + struct appendUnknown: Sendable { // 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. @@ -211,7 +235,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct areAllInitialized { + struct areAllInitialized: Sendable { // 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. @@ -223,7 +247,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct array { + struct Array: Sendable { // 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. @@ -235,7 +259,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct arrayDepth { + struct arrayDepth: Sendable { // 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. @@ -247,7 +271,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct arrayLiteral { + struct arrayLiteral: Sendable { // 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. @@ -259,7 +283,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct arraySeparator { + struct arraySeparator: Sendable { // 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. @@ -271,7 +295,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct asMessage { + struct asMessage: Sendable { // 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. @@ -283,7 +307,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct asciiOpenCurlyBracket { + struct asciiOpenCurlyBracket: Sendable { // 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. @@ -295,7 +319,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct asciiZero { + struct asciiZero: Sendable { // 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. @@ -307,7 +331,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct available { + struct async: Sendable { + // 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 async: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct AsyncIterator: Sendable { + // 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 asyncIterator: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct AsyncIteratorProtocol: Sendable { + // 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 asyncIteratorProtocol: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct AsyncMessageSequence: Sendable { + // 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 asyncMessageSequence: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct available: Sendable { // 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. @@ -319,7 +391,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct b { + struct b: Sendable { // 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. @@ -331,7 +403,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct base64Values { + struct Base: Sendable { + // 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 base: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct base64Values: Sendable { // 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. @@ -343,7 +427,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct baseAddress { + struct baseAddress: Sendable { // 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. @@ -355,7 +439,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BaseType { + struct BaseType: Sendable { // 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. @@ -367,7 +451,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct begin { + struct begin: Sendable { // 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. @@ -379,7 +463,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct binary { + struct binary: Sendable { // 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. @@ -391,7 +475,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryDecoder { + struct BinaryDecoder: Sendable { // 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. @@ -403,7 +487,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryDecodingError { + struct BinaryDecoding: Sendable { + // 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 binaryDecoding: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct BinaryDecodingError: Sendable { // 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. @@ -415,7 +511,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryDecodingOptions { + struct BinaryDecodingOptions: Sendable { // 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. @@ -427,7 +523,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryDelimited { + struct BinaryDelimited: Sendable { // 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. @@ -439,7 +535,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryEncoder { + struct BinaryEncoder: Sendable { // 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. @@ -451,7 +547,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryEncodingError { + struct BinaryEncodingError: Sendable { // 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. @@ -463,7 +559,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryEncodingMessageSetSizeVisitor { + struct BinaryEncodingMessageSetSizeVisitor: Sendable { // 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. @@ -475,7 +571,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryEncodingMessageSetVisitor { + struct BinaryEncodingMessageSetVisitor: Sendable { // 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. @@ -487,7 +583,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryEncodingSizeVisitor { + struct BinaryEncodingOptions: Sendable { + // 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 binaryEncodingOptions: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct BinaryEncodingSizeVisitor: Sendable { // 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. @@ -499,7 +607,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryEncodingVisitor { + struct BinaryEncodingVisitor: Sendable { // 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. @@ -511,7 +619,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct binaryOptions { + struct binaryOptions: Sendable { // 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. @@ -523,7 +631,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct body { + struct binaryProtobufDelimitedMessages: Sendable { + // 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 binaryProtobufDelimitedMessages: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct BinaryStreamDecoding: Sendable { + // 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 binaryStreamDecoding: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct binaryStreamDecodingError: Sendable { + // 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 binaryStreamDecodingError: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct bitPattern: Sendable { + // 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 bitPattern: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct body: Sendable { // 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. @@ -535,7 +691,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BoolMessage { + struct BoolMessage: Sendable { // 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. @@ -547,7 +703,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct booleanLiteral { + struct booleanLiteral: Sendable { // 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. @@ -559,7 +715,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BooleanLiteralType { + struct BooleanLiteralType: Sendable { // 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. @@ -571,7 +727,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct boolValue { + struct boolValue: Sendable { // 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. @@ -583,7 +739,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct bytes { + struct buffer: Sendable { + // 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 buffer: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct byte: Sendable { + // 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 byte: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct bytecode: Sendable { + // 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 bytecode: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct BytecodeReader: Sendable { + // 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 bytecodeReader: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct bytes: Sendable { // 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. @@ -595,7 +799,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct bytesInGroup { + struct bytesInGroup: Sendable { // 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. @@ -607,31 +811,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct bytesRead { + struct bytesNeeded: Sendable { // 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 bytesRead: Int32 = 0 + var bytesNeeded: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct BytesValue { + struct bytesRead: Sendable { // 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 bytesValue: Int32 = 0 + var bytesRead: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct c { + struct c: Sendable { // 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. @@ -643,7 +847,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct capitalizeNext { + struct canonical: Sendable { + // 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 canonical: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct capitalizeNext: Sendable { // 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. @@ -655,7 +871,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct cardinality { + struct cardinality: Sendable { // 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. @@ -667,7 +883,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ccEnableArenas { + struct CaseIterable: Sendable { + // 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 caseIterable: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct castedValue: Sendable { + // 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 castedValue: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct ccEnableArenas: Sendable { // 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. @@ -679,7 +919,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ccGenericServices { + struct ccGenericServices: Sendable { // 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. @@ -691,7 +931,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Character { + struct Character: Sendable { // 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. @@ -703,7 +943,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct chars { + struct chars: Sendable { // 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. @@ -715,7 +955,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct classMessage { + struct checkProgramFormat: Sendable { + // 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 checkProgramFormat: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct chunk: Sendable { + // 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 chunk: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct classMessage: Sendable { // 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. @@ -727,7 +991,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearAggregateValue { + struct clearAggregateValue: Sendable { // 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. @@ -739,7 +1003,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearAllowAlias { + struct clearAllowAlias: Sendable { // 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. @@ -751,7 +1015,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearBegin { + struct clearBegin: Sendable { // 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. @@ -763,7 +1027,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearCcEnableArenas { + struct clearCcEnableArenas: Sendable { // 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. @@ -775,7 +1039,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearCcGenericServices { + struct clearCcGenericServices: Sendable { // 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. @@ -787,7 +1051,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearClientStreaming { + struct clearClientStreaming: Sendable { // 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. @@ -799,7 +1063,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearCsharpNamespace { + struct clearCsharpNamespace: Sendable { // 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. @@ -811,7 +1075,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearCtype { + struct clearCtype: Sendable { // 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. @@ -823,7 +1087,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearDefaultValue { + struct clearDebugRedact: Sendable { + // 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 clearDebugRedact_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearDefaultSymbolVisibility: Sendable { + // 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 clearDefaultSymbolVisibility_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearDefaultValue: Sendable { // 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. @@ -835,7 +1123,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearDeprecated { + struct clearDeprecated: Sendable { // 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. @@ -847,7 +1135,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearDoubleValue { + struct clearDeprecatedLegacyJsonFieldConflicts: Sendable { + // 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 clearDeprecatedLegacyJsonFieldConflicts_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearDeprecationWarning: Sendable { + // 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 clearDeprecationWarning_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearDoubleValue: Sendable { // 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. @@ -859,7 +1171,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearEnd { + struct clearEdition: Sendable { + // 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 clearEdition_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearEditionDeprecated: Sendable { + // 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 clearEditionDeprecated_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearEditionIntroduced: Sendable { + // 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 clearEditionIntroduced_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearEditionRemoved: Sendable { + // 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 clearEditionRemoved_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearEnd: Sendable { // 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. @@ -871,7 +1231,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearExtendee { + struct clearEnforceNamingStyle: Sendable { + // 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 clearEnforceNamingStyle_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearEnumType: Sendable { + // 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 clearEnumType_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearExtendee: Sendable { // 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. @@ -883,7 +1267,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearExtensionValue { + struct clearExtensionValue: Sendable { // 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. @@ -895,7 +1279,67 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearGoPackage { + struct clearFeatures: Sendable { + // 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 clearFeatures_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearFeatureSupport: Sendable { + // 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 clearFeatureSupport_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearFieldPresence: Sendable { + // 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 clearFieldPresence_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearFixedFeatures: Sendable { + // 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 clearFixedFeatures_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearFullName: Sendable { + // 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 clearFullName_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearGoPackage: Sendable { // 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. @@ -907,7 +1351,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearIdempotencyLevel { + struct clearIdempotencyLevel: Sendable { // 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. @@ -919,7 +1363,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearIdentifierValue { + struct clearIdentifierValue: Sendable { // 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. @@ -931,7 +1375,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearInputType { + struct clearInputType: Sendable { // 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. @@ -943,7 +1387,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearIsExtension { + struct clearIsExtension: Sendable { // 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. @@ -955,7 +1399,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearJavaGenerateEqualsAndHash { + struct clearJavaGenerateEqualsAndHash: Sendable { // 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. @@ -967,7 +1411,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearJavaGenericServices { + struct clearJavaGenericServices: Sendable { // 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. @@ -979,7 +1423,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearJavaMultipleFiles { + struct clearJavaMultipleFiles: Sendable { // 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. @@ -991,7 +1435,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearJavaOuterClassname { + struct clearJavaOuterClassname: Sendable { // 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. @@ -1003,7 +1447,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearJavaPackage { + struct clearJavaPackage: Sendable { // 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. @@ -1015,7 +1459,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearJavaStringCheckUtf8 { + struct clearJavaStringCheckUtf8: Sendable { // 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. @@ -1027,7 +1471,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearJsonName { + struct clearJsonFormat: Sendable { + // 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 clearJsonFormat_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearJsonName: Sendable { // 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. @@ -1039,7 +1495,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearJstype { + struct clearJstype: Sendable { // 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. @@ -1051,7 +1507,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearLabel { + struct clearLabel: Sendable { // 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. @@ -1063,7 +1519,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearLazy { + struct clearLazy: Sendable { // 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. @@ -1075,7 +1531,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearLeadingComments { + struct clearLeadingComments: Sendable { // 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. @@ -1087,7 +1543,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearMapEntry { + struct clearMapEntry: Sendable { // 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. @@ -1099,7 +1555,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearMessageSetWireFormat { + struct clearMaximumEdition: Sendable { + // 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 clearMaximumEdition_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearMessageEncoding: Sendable { + // 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 clearMessageEncoding_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearMessageSetWireFormat: Sendable { // 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. @@ -1111,7 +1591,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearName { + struct clearMinimumEdition: Sendable { + // 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 clearMinimumEdition_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearName: Sendable { // 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. @@ -1123,7 +1615,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearNamePart { + struct clearNamePart: Sendable { // 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. @@ -1135,7 +1627,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearNegativeIntValue { + struct clearNegativeIntValue: Sendable { // 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. @@ -1147,7 +1639,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearNoStandardDescriptorAccessor { + struct clearNoStandardDescriptorAccessor: Sendable { // 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. @@ -1159,7 +1651,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearNumber { + struct clearNumber: Sendable { // 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. @@ -1171,7 +1663,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearObjcClassPrefix { + struct clearObjcClassPrefix: Sendable { // 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. @@ -1183,7 +1675,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearOneofIndex { + struct clearOneofIndex: Sendable { // 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. @@ -1195,7 +1687,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearOptimizeFor { + struct clearOptimizeFor: Sendable { // 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. @@ -1207,7 +1699,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearOptions { + struct clearOptions: Sendable { // 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. @@ -1219,7 +1711,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearOutputType { + struct clearOutputType: Sendable { // 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. @@ -1231,55 +1723,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearPackage { + struct clearOverridableFeatures: Sendable { // 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 clearPackage_p: Int32 = 0 + var clearOverridableFeatures_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct clearPacked { + struct clearPackage: Sendable { // 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 clearPacked_p: Int32 = 0 + var clearPackage_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct clearPhpClassPrefix { + struct clearPacked: Sendable { // 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 clearPhpClassPrefix_p: Int32 = 0 + var clearPacked_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct clearPhpGenericServices { + struct clearPhpClassPrefix: Sendable { // 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 clearPhpGenericServices_p: Int32 = 0 + var clearPhpClassPrefix_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct clearPhpMetadataNamespace { + struct clearPhpMetadataNamespace: Sendable { // 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. @@ -1291,7 +1783,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearPhpNamespace { + struct clearPhpNamespace: Sendable { // 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. @@ -1303,7 +1795,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearPositiveIntValue { + struct clearPositiveIntValue: Sendable { // 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. @@ -1315,7 +1807,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearProto3Optional { + struct clearProto3Optional: Sendable { // 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. @@ -1327,7 +1819,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearPyGenericServices { + struct clearPyGenericServices: Sendable { // 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. @@ -1339,7 +1831,67 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearRubyPackage { + struct clearRemovalError: Sendable { + // 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 clearRemovalError_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearRepeated: Sendable { + // 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 clearRepeated_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearRepeatedFieldEncoding: Sendable { + // 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 clearRepeatedFieldEncoding_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearReserved: Sendable { + // 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 clearReserved_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearRetention: Sendable { + // 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 clearRetention_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearRubyPackage: Sendable { // 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. @@ -1351,7 +1903,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearServerStreaming { + struct clearSemantic: Sendable { + // 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 clearSemantic_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearServerStreaming: Sendable { // 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. @@ -1363,7 +1927,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearSourceCodeInfo { + struct clearSourceCodeInfo: Sendable { // 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. @@ -1375,7 +1939,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearSourceContext { + struct clearSourceContext: Sendable { // 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. @@ -1387,7 +1951,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearSourceFile { + struct clearSourceFile: Sendable { // 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. @@ -1399,7 +1963,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearStart { + struct clearStart: Sendable { // 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. @@ -1411,7 +1975,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearStringValue { + struct clearStringValue: Sendable { // 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. @@ -1423,7 +1987,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearSwiftPrefix { + struct clearSwiftPrefix: Sendable { // 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. @@ -1435,7 +1999,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearSyntax { + struct clearSyntax: Sendable { // 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. @@ -1447,7 +2011,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearTrailingComments { + struct clearTrailingComments: Sendable { // 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. @@ -1459,7 +2023,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearType { + struct clearType: Sendable { // 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. @@ -1471,7 +2035,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearTypeName { + struct clearTypeName: Sendable { // 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. @@ -1483,7 +2047,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearValue { + struct clearUnverifiedLazy: Sendable { + // 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 clearUnverifiedLazy_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearUtf8Validation: Sendable { + // 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 clearUtf8Validation_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearValue: Sendable { // 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. @@ -1495,7 +2083,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearWeak { + struct clearVerification: Sendable { + // 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 clearVerification_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearVisibility: Sendable { + // 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 clearVisibility_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearWeak: Sendable { // 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. @@ -1507,7 +2119,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clientStreaming { + struct clientStreaming: Sendable { // 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. @@ -1519,7 +2131,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct codePoint { + struct code: Sendable { + // 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 code: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct codePoint: Sendable { // 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. @@ -1531,7 +2155,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct codeUnits { + struct codeUnits: Sendable { // 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. @@ -1543,7 +2167,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Collection { + struct Collection: Sendable { // 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. @@ -1555,31 +2179,43 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct com { + struct comma: Sendable { // 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 com: Int32 = 0 + var comma: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct comma { + struct consumedBytes: Sendable { // 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 comma: Int32 = 0 + var consumedBytes: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct contains: Sendable { + // 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 contains: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct contentsOf { + struct contentsOf: Sendable { // 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. @@ -1591,7 +2227,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ContiguousBytes { + struct ContiguousBytes: Sendable { // 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. @@ -1603,7 +2239,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct count { + struct copy: Sendable { + // 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 copy: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct count: Sendable { // 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. @@ -1615,7 +2263,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct countVarintsInBuffer { + struct countVarintsInBuffer: Sendable { // 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. @@ -1627,7 +2275,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct csharpNamespace { + struct csharpNamespace: Sendable { // 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. @@ -1639,7 +2287,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ctype { + struct ctype: Sendable { // 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. @@ -1651,7 +2299,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct customCodable { + struct customCodable: Sendable { // 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. @@ -1663,7 +2311,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct CustomDebugStringConvertible { + struct CustomDebugStringConvertible: Sendable { // 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. @@ -1675,7 +2323,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct d { + struct CustomStringConvertible: Sendable { + // 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 customStringConvertible: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct D: Sendable { // 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. @@ -1687,7 +2347,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct DataMessage { + struct DataMessage: Sendable { // 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. @@ -1699,7 +2359,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct dataResult { + struct dataResult: Sendable { // 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. @@ -1711,7 +2371,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct date { + struct date: Sendable { // 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. @@ -1723,7 +2383,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct daySec { + struct daySec: Sendable { // 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. @@ -1735,7 +2395,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct daysSinceEpoch { + struct daysSinceEpoch: Sendable { // 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. @@ -1747,7 +2407,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct debugDescriptionMessage { + struct debugDescriptionMessage: Sendable { // 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. @@ -1759,7 +2419,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decoded { + struct debugRedact: Sendable { + // 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 debugRedact: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct declaration: Sendable { + // 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 declaration: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct decoded: Sendable { // 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. @@ -1771,7 +2455,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodedFromJSONNull { + struct decodedFromJSONNull: Sendable { // 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. @@ -1783,7 +2467,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeExtensionField { + struct decodeExtensionField: Sendable { // 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. @@ -1795,7 +2479,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeExtensionFieldsAsMessageSet { + struct decodeExtensionFieldsAsMessageSet: Sendable { // 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. @@ -1807,7 +2491,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeJSON { + struct decodeJSON: Sendable { // 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. @@ -1819,7 +2503,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeMapField { + struct decodeMapField: Sendable { // 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. @@ -1831,7 +2515,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeMessageMessage { + struct decodeMessageMessage: Sendable { // 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. @@ -1843,7 +2527,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decoder { + struct Decoder: Sendable { // 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. @@ -1855,7 +2539,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeated { + struct decodeRepeated: Sendable { // 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. @@ -1867,7 +2551,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedBoolField { + struct decodeRepeatedBoolField: Sendable { // 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. @@ -1879,7 +2563,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedBytesField { + struct decodeRepeatedBytesField: Sendable { // 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. @@ -1891,7 +2575,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedDoubleField { + struct decodeRepeatedDoubleField: Sendable { // 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. @@ -1903,7 +2587,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedEnumField { + struct decodeRepeatedEnumField: Sendable { // 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. @@ -1915,7 +2599,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedFixed32Field { + struct decodeRepeatedFixed32Field: Sendable { // 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. @@ -1927,7 +2611,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedFixed64Field { + struct decodeRepeatedFixed64Field: Sendable { // 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. @@ -1939,7 +2623,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedFloatField { + struct decodeRepeatedFloatField: Sendable { // 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. @@ -1951,7 +2635,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedGroupField { + struct decodeRepeatedGroupField: Sendable { // 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. @@ -1963,7 +2647,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedInt32Field { + struct decodeRepeatedInt32Field: Sendable { // 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. @@ -1975,7 +2659,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedInt64Field { + struct decodeRepeatedInt64Field: Sendable { // 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. @@ -1987,7 +2671,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedMessageField { + struct decodeRepeatedMessageField: Sendable { // 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. @@ -1999,7 +2683,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedSFixed32Field { + struct decodeRepeatedSFixed32Field: Sendable { // 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. @@ -2011,7 +2695,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedSFixed64Field { + struct decodeRepeatedSFixed64Field: Sendable { // 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. @@ -2023,7 +2707,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedSInt32Field { + struct decodeRepeatedSInt32Field: Sendable { // 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. @@ -2035,7 +2719,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedSInt64Field { + struct decodeRepeatedSInt64Field: Sendable { // 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. @@ -2047,7 +2731,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedStringField { + struct decodeRepeatedStringField: Sendable { // 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. @@ -2059,7 +2743,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedUInt32Field { + struct decodeRepeatedUInt32Field: Sendable { // 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. @@ -2071,7 +2755,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedUInt64Field { + struct decodeRepeatedUInt64Field: Sendable { // 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. @@ -2083,7 +2767,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingular { + struct decodeSingular: Sendable { // 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. @@ -2095,7 +2779,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularBoolField { + struct decodeSingularBoolField: Sendable { // 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. @@ -2107,7 +2791,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularBytesField { + struct decodeSingularBytesField: Sendable { // 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. @@ -2119,7 +2803,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularDoubleField { + struct decodeSingularDoubleField: Sendable { // 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. @@ -2131,7 +2815,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularEnumField { + struct decodeSingularEnumField: Sendable { // 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. @@ -2143,7 +2827,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularFixed32Field { + struct decodeSingularFixed32Field: Sendable { // 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. @@ -2155,7 +2839,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularFixed64Field { + struct decodeSingularFixed64Field: Sendable { // 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. @@ -2167,7 +2851,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularFloatField { + struct decodeSingularFloatField: Sendable { // 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. @@ -2179,7 +2863,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularGroupField { + struct decodeSingularGroupField: Sendable { // 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. @@ -2191,7 +2875,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularInt32Field { + struct decodeSingularInt32Field: Sendable { // 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. @@ -2203,7 +2887,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularInt64Field { + struct decodeSingularInt64Field: Sendable { // 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. @@ -2215,7 +2899,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularMessageField { + struct decodeSingularMessageField: Sendable { // 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. @@ -2227,7 +2911,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularSFixed32Field { + struct decodeSingularSFixed32Field: Sendable { // 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. @@ -2239,7 +2923,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularSFixed64Field { + struct decodeSingularSFixed64Field: Sendable { // 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. @@ -2251,7 +2935,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularSInt32Field { + struct decodeSingularSInt32Field: Sendable { // 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. @@ -2263,7 +2947,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularSInt64Field { + struct decodeSingularSInt64Field: Sendable { // 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. @@ -2275,7 +2959,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularStringField { + struct decodeSingularStringField: Sendable { // 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. @@ -2287,7 +2971,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularUInt32Field { + struct decodeSingularUInt32Field: Sendable { // 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. @@ -2299,7 +2983,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularUInt64Field { + struct decodeSingularUInt64Field: Sendable { // 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. @@ -2311,7 +2995,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeTextFormat { + struct decodeTextFormat: Sendable { // 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. @@ -2323,7 +3007,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct defaultAnyTypeURLPrefix { + struct defaultAnyTypeURLPrefix: Sendable { // 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. @@ -2335,7 +3019,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct defaultValue { + struct defaults: Sendable { + // 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 defaults: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct defaultSymbolVisibility: Sendable { + // 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 defaultSymbolVisibility: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct defaultValue: Sendable { // 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. @@ -2347,7 +3055,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct dependency { + struct dependency: Sendable { // 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. @@ -2359,7 +3067,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct deprecated { + struct deprecated: Sendable { // 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. @@ -2371,31 +3079,43 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct descriptionMessage { + struct deprecatedLegacyJsonFieldConflicts: Sendable { // 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 description_p: Int32 = 0 + var deprecatedLegacyJsonFieldConflicts: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct DescriptorProto { + struct deprecationWarning: Sendable { // 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 descriptorProto: Int32 = 0 + var deprecationWarning: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Dictionary { + struct descriptionMessage: Sendable { + // 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 description_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct Dictionary: Sendable { // 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. @@ -2407,7 +3127,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct dictionaryLiteral { + struct dictionaryLiteral: Sendable { // 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. @@ -2419,7 +3139,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct digit { + struct digit: Sendable { // 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. @@ -2431,7 +3151,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct digit0 { + struct digit0: Sendable { // 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. @@ -2443,7 +3163,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct digit1 { + struct digit1: Sendable { // 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. @@ -2455,7 +3175,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct digitCount { + struct digitCount: Sendable { // 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. @@ -2467,7 +3187,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct digits { + struct digits: Sendable { // 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. @@ -2479,7 +3199,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct digitValue { + struct digitValue: Sendable { // 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. @@ -2491,7 +3211,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct discardableResult { + struct discardableResult: Sendable { // 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. @@ -2503,7 +3223,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct discardUnknownFields { + struct discardUnknownFields: Sendable { // 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. @@ -2515,379 +3235,415 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct distance { + struct DoubleMessage: Sendable { // 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 distance: Int32 = 0 + var double: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct double { + struct doubleValue: Sendable { // 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 double: Int32 = 0 + var doubleValue: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct doubleValue { + struct duration: Sendable { // 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 doubleValue: Int32 = 0 + var duration: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Duration { + struct E: Sendable { // 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 duration: Int32 = 0 + var e: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct E { + struct edition: Sendable { // 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 e: Int32 = 0 + var edition: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Element { + struct EditionDefault: Sendable { // 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 element: Int32 = 0 + var editionDefault: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct elements { + struct editionDefaults: Sendable { // 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 elements: Int32 = 0 + var editionDefaults: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct emitExtensionFieldName { + struct editionDeprecated: Sendable { // 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 emitExtensionFieldName: Int32 = 0 + var editionDeprecated: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct emitFieldName { + struct editionIntroduced: Sendable { // 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 emitFieldName: Int32 = 0 + var editionIntroduced: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct emitFieldNumber { + struct editionRemoved: Sendable { // 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 emitFieldNumber: Int32 = 0 + var editionRemoved: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Empty { + struct Element: Sendable { // 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 empty: Int32 = 0 + var element: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct emptyData { + struct elements: Sendable { // 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 emptyData: Int32 = 0 + var elements: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct encodeAsBytes { + struct elseMessage: Sendable { // 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 encodeAsBytes: Int32 = 0 + var `else`: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct encoded { + struct emitExtensionFieldName: Sendable { // 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 encoded: Int32 = 0 + var emitExtensionFieldName: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct encodedJSONString { + struct emitFieldName: Sendable { // 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 encodedJsonstring: Int32 = 0 + var emitFieldName: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct encodedSize { + struct emitFieldNumber: Sendable { // 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 encodedSize: Int32 = 0 + var emitFieldNumber: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct encodeField { + struct emptyAnyTypeURL: Sendable { // 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 encodeField: Int32 = 0 + var emptyAnyTypeURL: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct encoder { + struct emptyData: Sendable { // 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 encoder: Int32 = 0 + var emptyData: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct end { + struct encodeAsBytes: Sendable { // 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 end: Int32 = 0 + var encodeAsBytes: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct endArray { + struct encoded: Sendable { // 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 endArray: Int32 = 0 + var encoded: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct endMessageField { + struct encodedJSONString: Sendable { // 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 endMessageField: Int32 = 0 + var encodedJsonstring: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct endObject { + struct encodedSize: Sendable { // 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 endObject: Int32 = 0 + var encodedSize: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct endRegularField { + struct encodeField: Sendable { // 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 endRegularField: Int32 = 0 + var encodeField: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct enumMessage { + struct encoder: Sendable { // 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 `enum`: Int32 = 0 + var encoder: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct EnumDescriptorProto { + struct end: Sendable { // 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 enumDescriptorProto: Int32 = 0 + var end: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct EnumOptions { + struct endArray: Sendable { // 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 enumOptions: Int32 = 0 + var endArray: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct EnumReservedRange { + struct endMessageField: Sendable { // 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 enumReservedRange: Int32 = 0 + var endMessageField: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct enumType { + struct endObject: Sendable { // 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 enumType: Int32 = 0 + var endObject: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct enumvalue { + struct endRegularField: Sendable { // 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 enumvalue: Int32 = 0 + var endRegularField: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct enforceNamingStyle: Sendable { + // 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 enforceNamingStyle: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct enumMessage: Sendable { + // 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 `enum`: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct EnumValueDescriptorProto { + struct EnumReservedRange: Sendable { // 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 enumValueDescriptorProto: Int32 = 0 + var enumReservedRange: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct EnumValueOptions { + struct enumType: Sendable { // 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 enumValueOptions: Int32 = 0 + var enumType: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Equatable { + struct enumvalue: Sendable { + // 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 enumvalue: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct EquatableMessage: Sendable { // 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. @@ -2899,7 +3655,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Error { + struct Error: Sendable { // 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. @@ -2911,7 +3667,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ExpressibleByArrayLiteral { + struct execute: Sendable { + // 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 execute: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct ExpressibleByArrayLiteral: Sendable { // 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. @@ -2923,7 +3691,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ExpressibleByDictionaryLiteral { + struct ExpressibleByDictionaryLiteral: Sendable { // 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. @@ -2935,7 +3703,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ext { + struct ext: Sendable { // 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. @@ -2947,7 +3715,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct extDecoder { + struct extDecoder: Sendable { // 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. @@ -2959,7 +3727,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct extendedGraphemeClusterLiteral { + struct extendedGraphemeClusterLiteral: Sendable { // 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. @@ -2971,7 +3739,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ExtendedGraphemeClusterLiteralType { + struct ExtendedGraphemeClusterLiteralType: Sendable { // 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. @@ -2983,7 +3751,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct extendee { + struct extendee: Sendable { // 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. @@ -2995,7 +3763,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ExtensibleMessage { + struct ExtensibleMessage: Sendable { // 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. @@ -3007,7 +3775,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct extensionMessage { + struct extensionMessage: Sendable { // 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. @@ -3019,7 +3787,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ExtensionField { + struct ExtensionField: Sendable { // 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. @@ -3031,7 +3799,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct extensionFieldNumber { + struct extensionFieldNumber: Sendable { // 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. @@ -3043,7 +3811,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ExtensionFieldValueSet { + struct ExtensionFieldValueSet: Sendable { // 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. @@ -3055,7 +3823,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ExtensionMap { + struct ExtensionMap: Sendable { // 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. @@ -3067,7 +3835,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct extensionRange { + struct extensionRange: Sendable { // 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. @@ -3079,115 +3847,127 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ExtensionRangeOptions { + struct extensions: Sendable { // 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 extensionRangeOptions: Int32 = 0 + var extensions: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct extensions { + struct extras: Sendable { // 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 extensions: Int32 = 0 + var extras: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct extras { + struct F: Sendable { // 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 extras: Int32 = 0 + var f: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct F { + struct falseMessage: Sendable { // 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 f: Int32 = 0 + var `false`: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct falseMessage { + struct features: Sendable { // 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 `false`: Int32 = 0 + var features: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct field { + struct FeatureSetEditionDefault: Sendable { // 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 field: Int32 = 0 + var featureSetEditionDefault: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct fieldData { + struct featureSupport: Sendable { // 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 fieldData: Int32 = 0 + var featureSupport: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct FieldDescriptorProto { + struct field: Sendable { // 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 fieldDescriptorProto: Int32 = 0 + var field: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct FieldMask { + struct fieldData: Sendable { // 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 fieldMask: Int32 = 0 + var fieldData: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct fieldName { + struct FieldMaskError: Sendable { + // 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 fieldMaskError: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct fieldName: Sendable { // 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. @@ -3199,7 +3979,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fieldNameCount { + struct fieldNameCount: Sendable { // 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. @@ -3211,7 +3991,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fieldNum { + struct fieldNum: Sendable { // 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. @@ -3223,7 +4003,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fieldNumber { + struct fieldNumber: Sendable { // 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. @@ -3235,7 +4015,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fieldNumberForProto { + struct fieldNumberForProto: Sendable { // 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. @@ -3247,19 +4027,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct FieldOptions { + struct fieldPresence: Sendable { // 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 fieldOptions: Int32 = 0 + var fieldPresence: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct fields { + struct fields: Sendable { // 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. @@ -3271,7 +4051,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fieldSize { + struct fieldSize: Sendable { // 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. @@ -3283,7 +4063,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct FieldTag { + struct FieldTag: Sendable { // 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. @@ -3295,7 +4075,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fieldType { + struct FieldType: Sendable { // 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. @@ -3307,7 +4087,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct file { + struct file: Sendable { // 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. @@ -3319,91 +4099,91 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct FileDescriptorProto { + struct fileName: Sendable { // 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 fileDescriptorProto: Int32 = 0 + var fileName: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct FileDescriptorSet { + struct filter: Sendable { // 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 fileDescriptorSet: Int32 = 0 + var filter: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct fileName { + struct final: Sendable { // 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 fileName: Int32 = 0 + var final: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct FileOptions { + struct finiteOnly: Sendable { // 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 fileOptions: Int32 = 0 + var finiteOnly: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct filter { + struct first: Sendable { // 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 filter: Int32 = 0 + var first: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct first { + struct firstItem: Sendable { // 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 first: Int32 = 0 + var firstItem: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct firstItem { + struct fixedFeatures: Sendable { // 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 firstItem: Int32 = 0 + var fixedFeatures: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct float { + struct FloatMessage: Sendable { // 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. @@ -3415,7 +4195,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct floatLiteral { + struct floatLiteral: Sendable { // 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. @@ -3427,7 +4207,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct FloatLiteralType { + struct FloatLiteralType: Sendable { // 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. @@ -3439,19 +4219,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct FloatValue { + struct forMessage: Sendable { // 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 floatValue: Int32 = 0 + var `for`: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct forMessageName { + struct forMessageName: Sendable { // 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. @@ -3463,7 +4243,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct formUnion { + struct formUnion: Sendable { // 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. @@ -3475,7 +4255,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct forReadingFrom { + struct forReadingFrom: Sendable { // 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. @@ -3487,7 +4267,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct forTypeURL { + struct forTypeURL: Sendable { // 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. @@ -3499,7 +4279,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ForwardParser { + struct ForwardParser: Sendable { // 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. @@ -3511,7 +4291,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct forWritingInto { + struct forWritingInto: Sendable { // 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. @@ -3523,7 +4303,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct from { + struct from: Sendable { // 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. @@ -3535,7 +4315,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fromAscii2 { + struct fromAscii2: Sendable { // 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. @@ -3547,7 +4327,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fromAscii4 { + struct fromAscii4: Sendable { // 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. @@ -3559,7 +4339,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fromByteOffset { + struct fromByteOffset: Sendable { // 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. @@ -3571,7 +4351,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fromHexDigit { + struct fromHexDigit: Sendable { // 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. @@ -3583,79 +4363,79 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct funcMessage { + struct fullName: Sendable { // 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 `func`: Int32 = 0 + var fullName: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct G { + struct funcMessage: Sendable { // 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 g: Int32 = 0 + var `func`: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct GeneratedCodeInfo { + struct function: Sendable { // 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 generatedCodeInfo: Int32 = 0 + var function: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct get { + struct G: Sendable { // 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 get: Int32 = 0 + var g: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct getExtensionValue { + struct get: Sendable { // 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 getExtensionValue: Int32 = 0 + var get: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct googleapis { + struct getExtensionValue: Sendable { // 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 googleapis: Int32 = 0 + var getExtensionValue: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Google_Protobuf_Any { + struct Google_Protobuf_Any: Sendable { // 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. @@ -3667,7 +4447,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Api { + struct Google_Protobuf_Api: Sendable { // 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. @@ -3679,7 +4459,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_BoolValue { + struct Google_Protobuf_BoolValue: Sendable { // 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. @@ -3691,7 +4471,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_BytesValue { + struct Google_Protobuf_BytesValue: Sendable { // 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. @@ -3703,7 +4483,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_DescriptorProto { + struct Google_Protobuf_DescriptorProto: Sendable { // 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. @@ -3715,7 +4495,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_DoubleValue { + struct Google_Protobuf_DoubleValue: Sendable { // 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. @@ -3727,7 +4507,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Duration { + struct Google_Protobuf_Duration: Sendable { // 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. @@ -3739,7 +4519,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Empty { + struct Google_Protobuf_Edition: Sendable { + // 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 googleProtobufEdition: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct Google_Protobuf_Empty: Sendable { // 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. @@ -3751,7 +4543,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Enum { + struct Google_Protobuf_Enum: Sendable { // 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. @@ -3763,7 +4555,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_EnumDescriptorProto { + struct Google_Protobuf_EnumDescriptorProto: Sendable { // 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. @@ -3775,7 +4567,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_EnumOptions { + struct Google_Protobuf_EnumOptions: Sendable { // 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. @@ -3787,7 +4579,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_EnumValue { + struct Google_Protobuf_EnumValue: Sendable { // 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. @@ -3799,7 +4591,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_EnumValueDescriptorProto { + struct Google_Protobuf_EnumValueDescriptorProto: Sendable { // 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. @@ -3811,7 +4603,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_EnumValueOptions { + struct Google_Protobuf_EnumValueOptions: Sendable { // 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. @@ -3823,7 +4615,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_ExtensionRangeOptions { + struct Google_Protobuf_ExtensionRangeOptions: Sendable { // 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. @@ -3835,7 +4627,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Field { + struct Google_Protobuf_FeatureSet: Sendable { + // 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 googleProtobufFeatureSet: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct Google_Protobuf_FeatureSetDefaults: Sendable { + // 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 googleProtobufFeatureSetDefaults: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct Google_Protobuf_Field: Sendable { // 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. @@ -3847,7 +4663,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_FieldDescriptorProto { + struct Google_Protobuf_FieldDescriptorProto: Sendable { // 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. @@ -3859,7 +4675,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_FieldMask { + struct Google_Protobuf_FieldMask: Sendable { // 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. @@ -3871,7 +4687,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_FieldOptions { + struct Google_Protobuf_FieldOptions: Sendable { // 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. @@ -3883,7 +4699,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_FileDescriptorProto { + struct Google_Protobuf_FileDescriptorProto: Sendable { // 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. @@ -3895,7 +4711,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_FileDescriptorSet { + struct Google_Protobuf_FileDescriptorSet: Sendable { // 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. @@ -3907,7 +4723,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_FileOptions { + struct Google_Protobuf_FileOptions: Sendable { // 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. @@ -3919,7 +4735,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_FloatValue { + struct Google_Protobuf_FloatValue: Sendable { // 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. @@ -3931,7 +4747,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_GeneratedCodeInfo { + struct Google_Protobuf_GeneratedCodeInfo: Sendable { // 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. @@ -3943,7 +4759,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Int32Value { + struct Google_Protobuf_Int32Value: Sendable { // 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. @@ -3955,7 +4771,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Int64Value { + struct Google_Protobuf_Int64Value: Sendable { // 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. @@ -3967,7 +4783,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_ListValue { + struct Google_Protobuf_ListValue: Sendable { // 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. @@ -3979,7 +4795,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_MessageOptions { + struct Google_Protobuf_MessageOptions: Sendable { // 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. @@ -3991,7 +4807,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Method { + struct Google_Protobuf_Method: Sendable { // 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. @@ -4003,7 +4819,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_MethodDescriptorProto { + struct Google_Protobuf_MethodDescriptorProto: Sendable { // 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. @@ -4015,7 +4831,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_MethodOptions { + struct Google_Protobuf_MethodOptions: Sendable { // 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. @@ -4027,7 +4843,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Mixin { + struct Google_Protobuf_Mixin: Sendable { // 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. @@ -4039,7 +4855,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_NullValue { + struct Google_Protobuf_NullValue: Sendable { // 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. @@ -4051,7 +4867,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_OneofDescriptorProto { + struct Google_Protobuf_OneofDescriptorProto: Sendable { // 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. @@ -4063,7 +4879,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_OneofOptions { + struct Google_Protobuf_OneofOptions: Sendable { // 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. @@ -4075,7 +4891,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Option { + struct Google_Protobuf_Option: Sendable { // 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. @@ -4087,7 +4903,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_ServiceDescriptorProto { + struct Google_Protobuf_ServiceDescriptorProto: Sendable { // 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. @@ -4099,7 +4915,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_ServiceOptions { + struct Google_Protobuf_ServiceOptions: Sendable { // 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. @@ -4111,7 +4927,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_SourceCodeInfo { + struct Google_Protobuf_SourceCodeInfo: Sendable { // 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. @@ -4123,7 +4939,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_SourceContext { + struct Google_Protobuf_SourceContext: Sendable { // 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. @@ -4135,7 +4951,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_StringValue { + struct Google_Protobuf_StringValue: Sendable { // 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. @@ -4147,7 +4963,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Struct { + struct Google_Protobuf_Struct: Sendable { // 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. @@ -4159,7 +4975,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Syntax { + struct Google_Protobuf_SymbolVisibility: Sendable { + // 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 googleProtobufSymbolVisibility: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct Google_Protobuf_Syntax: Sendable { // 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. @@ -4171,7 +4999,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Timestamp { + struct Google_Protobuf_Timestamp: Sendable { // 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. @@ -4183,7 +5011,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Type { + struct Google_Protobuf_Type: Sendable { // 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. @@ -4195,7 +5023,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_UInt32Value { + struct Google_Protobuf_UInt32Value: Sendable { // 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. @@ -4207,7 +5035,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_UInt64Value { + struct Google_Protobuf_UInt64Value: Sendable { // 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. @@ -4219,7 +5047,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_UninterpretedOption { + struct Google_Protobuf_UninterpretedOption: Sendable { // 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. @@ -4231,7 +5059,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Value { + struct Google_Protobuf_Value: Sendable { // 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. @@ -4243,7 +5071,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct goPackage { + struct goPackage: Sendable { // 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. @@ -4255,7 +5083,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct group { + struct gotData: Sendable { + // 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 gotData: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct group: Sendable { // 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. @@ -4267,7 +5107,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct groupFieldNumberStack { + struct groupFieldNumberStack: Sendable { // 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. @@ -4279,7 +5119,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct groupSize { + struct groupSize: Sendable { // 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. @@ -4291,19 +5131,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct h { + struct guardMessage: Sendable { // 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 h: Int32 = 0 + var `guard`: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct hadOneofValue { + struct hadOneofValue: Sendable { // 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. @@ -4315,7 +5155,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct handleConflictingOneOf { + struct handleConflictingOneOf: Sendable { // 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. @@ -4327,7 +5167,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasAggregateValue { + struct handleInstruction: Sendable { + // 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 handleInstruction: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasAggregateValue: Sendable { // 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. @@ -4339,7 +5191,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasAllowAlias { + struct hasAllowAlias: Sendable { // 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. @@ -4351,7 +5203,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasBegin { + struct hasBegin: Sendable { // 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. @@ -4363,7 +5215,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasCcEnableArenas { + struct hasCcEnableArenas: Sendable { // 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. @@ -4375,7 +5227,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasCcGenericServices { + struct hasCcGenericServices: Sendable { // 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. @@ -4387,7 +5239,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasClientStreaming { + struct hasClientStreaming: Sendable { // 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. @@ -4399,7 +5251,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasCsharpNamespace { + struct hasCsharpNamespace: Sendable { // 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. @@ -4411,7 +5263,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasCtype { + struct hasCtype: Sendable { // 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. @@ -4423,7 +5275,43 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasDefaultValue { + struct hasData: Sendable { + // 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 hasData_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasDebugRedact: Sendable { + // 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 hasDebugRedact_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasDefaultSymbolVisibility: Sendable { + // 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 hasDefaultSymbolVisibility_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasDefaultValue: Sendable { // 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. @@ -4435,7 +5323,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasDeprecated { + struct hasDeprecated: Sendable { // 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. @@ -4447,7 +5335,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasDoubleValue { + struct hasDeprecatedLegacyJsonFieldConflicts: Sendable { + // 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 hasDeprecatedLegacyJsonFieldConflicts_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasDeprecationWarning: Sendable { + // 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 hasDeprecationWarning_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasDoubleValue: Sendable { // 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. @@ -4459,7 +5371,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasEnd { + struct hasEdition: Sendable { + // 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 hasEdition_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasEditionDeprecated: Sendable { + // 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 hasEditionDeprecated_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasEditionIntroduced: Sendable { + // 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 hasEditionIntroduced_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasEditionRemoved: Sendable { + // 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 hasEditionRemoved_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasEnd: Sendable { // 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. @@ -4471,7 +5431,43 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasExtendee { + struct hasEnforceNamingStyle: Sendable { + // 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 hasEnforceNamingStyle_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasEnumType: Sendable { + // 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 hasEnumType_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasExplicitDelta: Sendable { + // 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 hasExplicitDelta_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasExtendee: Sendable { // 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. @@ -4483,7 +5479,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasExtensionValue { + struct hasExtensionValue: Sendable { // 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. @@ -4495,67 +5491,115 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasGoPackage { + struct hasFeatures: Sendable { // 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 hasGoPackage_p: Int32 = 0 + var hasFeatures_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct hash { + struct hasFeatureSupport: Sendable { // 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 hash: Int32 = 0 + var hasFeatureSupport_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Hashable { + struct hasFieldPresence: Sendable { // 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 hashable: Int32 = 0 + var hasFieldPresence_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct hasher { + struct hasFixedFeatures: Sendable { // 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 hasher: Int32 = 0 + var hasFixedFeatures_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasFullName: Sendable { + // 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 hasFullName_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasGoPackage: Sendable { + // 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 hasGoPackage_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hash: Sendable { + // 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 hash: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct hashValueMessage { + struct HashableMessage: Sendable { // 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 hashValue_p: Int32 = 0 + var hashable: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct HashVisitor { + struct hasher: Sendable { + // 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 hasher: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct HashVisitor: Sendable { // 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. @@ -4567,7 +5611,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasIdempotencyLevel { + struct hasIdempotencyLevel: Sendable { // 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. @@ -4579,7 +5623,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasIdentifierValue { + struct hasIdentifierValue: Sendable { // 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. @@ -4591,7 +5635,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasInputType { + struct hasInputType: Sendable { // 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. @@ -4603,7 +5647,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasIsExtension { + struct hasIsExtension: Sendable { // 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. @@ -4615,7 +5659,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasJavaGenerateEqualsAndHash { + struct hasJavaGenerateEqualsAndHash: Sendable { // 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. @@ -4627,7 +5671,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasJavaGenericServices { + struct hasJavaGenericServices: Sendable { // 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. @@ -4639,7 +5683,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasJavaMultipleFiles { + struct hasJavaMultipleFiles: Sendable { // 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. @@ -4651,7 +5695,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasJavaOuterClassname { + struct hasJavaOuterClassname: Sendable { // 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. @@ -4663,7 +5707,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasJavaPackage { + struct hasJavaPackage: Sendable { // 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. @@ -4675,7 +5719,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasJavaStringCheckUtf8 { + struct hasJavaStringCheckUtf8: Sendable { // 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. @@ -4687,7 +5731,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasJsonName { + struct hasJsonFormat: Sendable { + // 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 hasJsonFormat_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasJsonName: Sendable { // 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. @@ -4699,7 +5755,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasJstype { + struct hasJstype: Sendable { // 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. @@ -4711,7 +5767,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasLabel { + struct hasLabel: Sendable { // 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. @@ -4723,7 +5779,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasLazy { + struct hasLazy: Sendable { // 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. @@ -4735,7 +5791,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasLeadingComments { + struct hasLeadingComments: Sendable { // 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. @@ -4747,7 +5803,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasMapEntry { + struct hasMapEntry: Sendable { // 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. @@ -4759,7 +5815,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasMessageSetWireFormat { + struct hasMaximumEdition: Sendable { + // 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 hasMaximumEdition_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasMessageEncoding: Sendable { + // 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 hasMessageEncoding_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasMessageSetWireFormat: Sendable { // 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. @@ -4771,7 +5851,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasName { + struct hasMinimumEdition: Sendable { + // 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 hasMinimumEdition_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasName: Sendable { // 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. @@ -4783,7 +5875,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasNamePart { + struct hasNamePart: Sendable { // 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. @@ -4795,7 +5887,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasNegativeIntValue { + struct hasNegativeIntValue: Sendable { // 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. @@ -4807,7 +5899,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasNoStandardDescriptorAccessor { + struct hasNoStandardDescriptorAccessor: Sendable { // 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. @@ -4819,7 +5911,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasNumber { + struct hasNumber: Sendable { // 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. @@ -4831,7 +5923,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasObjcClassPrefix { + struct hasObjcClassPrefix: Sendable { // 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. @@ -4843,7 +5935,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasOneofIndex { + struct hasOneofIndex: Sendable { // 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. @@ -4855,7 +5947,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasOptimizeFor { + struct hasOptimizeFor: Sendable { // 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. @@ -4867,7 +5959,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasOptions { + struct hasOptions: Sendable { // 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. @@ -4879,7 +5971,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasOutputType { + struct hasOutputType: Sendable { // 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. @@ -4891,55 +5983,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasPackage { + struct hasOverridableFeatures: Sendable { // 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 hasPackage_p: Int32 = 0 + var hasOverridableFeatures_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct hasPacked { + struct hasPackage: Sendable { // 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 hasPacked_p: Int32 = 0 + var hasPackage_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct hasPhpClassPrefix { + struct hasPacked: Sendable { // 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 hasPhpClassPrefix_p: Int32 = 0 + var hasPacked_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct hasPhpGenericServices { + struct hasPhpClassPrefix: Sendable { // 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 hasPhpGenericServices_p: Int32 = 0 + var hasPhpClassPrefix_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct hasPhpMetadataNamespace { + struct hasPhpMetadataNamespace: Sendable { // 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. @@ -4951,7 +6043,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasPhpNamespace { + struct hasPhpNamespace: Sendable { // 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. @@ -4963,7 +6055,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasPositiveIntValue { + struct hasPositiveIntValue: Sendable { // 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. @@ -4975,7 +6067,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasProto3Optional { + struct hasProto3Optional: Sendable { // 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. @@ -4987,7 +6079,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasPyGenericServices { + struct hasPyGenericServices: Sendable { // 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. @@ -4999,7 +6091,67 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasRubyPackage { + struct hasRemovalError: Sendable { + // 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 hasRemovalError_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasRepeated: Sendable { + // 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 hasRepeated_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasRepeatedFieldEncoding: Sendable { + // 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 hasRepeatedFieldEncoding_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasReserved: Sendable { + // 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 hasReserved_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasRetention: Sendable { + // 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 hasRetention_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasRubyPackage: Sendable { // 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. @@ -5011,7 +6163,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasServerStreaming { + struct hasSemantic: Sendable { + // 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 hasSemantic_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasServerStreaming: Sendable { // 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. @@ -5023,7 +6187,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasSourceCodeInfo { + struct hasSourceCodeInfo: Sendable { // 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. @@ -5035,7 +6199,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasSourceContext { + struct hasSourceContext: Sendable { // 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. @@ -5047,7 +6211,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasSourceFile { + struct hasSourceFile: Sendable { // 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. @@ -5059,7 +6223,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasStart { + struct hasStart: Sendable { // 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. @@ -5071,7 +6235,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasStringValue { + struct hasStringValue: Sendable { // 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. @@ -5083,7 +6247,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasSwiftPrefix { + struct hasSwiftPrefix: Sendable { // 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. @@ -5095,7 +6259,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasSyntax { + struct hasSyntax: Sendable { // 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. @@ -5107,7 +6271,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasTrailingComments { + struct hasTrailingComments: Sendable { // 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. @@ -5119,7 +6283,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasType { + struct hasType: Sendable { // 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. @@ -5131,7 +6295,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasTypeName { + struct hasTypeName: Sendable { // 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. @@ -5143,7 +6307,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasValue { + struct hasUnverifiedLazy: Sendable { + // 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 hasUnverifiedLazy_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasUtf8Validation: Sendable { + // 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 hasUtf8Validation_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasValue: Sendable { // 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. @@ -5155,7 +6343,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasWeak { + struct hasVerification: Sendable { + // 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 hasVerification_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasVisibility: Sendable { + // 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 hasVisibility_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasWeak: Sendable { // 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. @@ -5167,7 +6379,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hour { + struct hour: Sendable { // 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. @@ -5179,7 +6391,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct i { + struct i: Sendable { // 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. @@ -5191,7 +6403,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct idempotencyLevel { + struct idempotencyLevel: Sendable { // 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. @@ -5203,7 +6415,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct identifierValue { + struct identifierValue: Sendable { // 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. @@ -5215,7 +6427,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ifMessage { + struct ifMessage: Sendable { // 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. @@ -5227,7 +6439,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ignoreUnknownFields { + struct ignoreUnknownExtensionFields: Sendable { + // 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 ignoreUnknownExtensionFields: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct ignoreUnknownFields: Sendable { // 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. @@ -5239,7 +6463,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct index { + struct index: Sendable { // 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. @@ -5251,7 +6475,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct initMessage { + struct initMessage: Sendable { // 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. @@ -5263,7 +6487,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct inoutMessage { + struct inoutMessage: Sendable { // 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. @@ -5275,7 +6499,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct inputType { + struct inputType: Sendable { // 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. @@ -5287,7 +6511,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct insert { + struct insert: Sendable { // 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. @@ -5299,43 +6523,43 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct IntMessage { + struct Instruction: Sendable { // 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 int: Int32 = 0 + var instruction: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Int32Message { + struct IntMessage: Sendable { // 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 int32: Int32 = 0 + var int: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Int32Value { + struct Int32Message: Sendable { // 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 int32Value: Int32 = 0 + var int32: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Int64Message { + struct Int64Message: Sendable { // 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. @@ -5347,91 +6571,91 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Int64Value { + struct Int8: Sendable { // 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 int64Value: Int32 = 0 + var int8: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Int8 { + struct integerLiteral: Sendable { // 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 int8: Int32 = 0 + var integerLiteral: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct integerLiteral { + struct IntegerLiteralType: Sendable { // 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 integerLiteral: Int32 = 0 + var integerLiteralType: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct IntegerLiteralType { + struct intern: Sendable { // 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 integerLiteralType: Int32 = 0 + var intern: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct intern { + struct Internal: Sendable { // 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 intern: Int32 = 0 + var `internal`: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Internal { + struct InternalState: Sendable { // 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 `internal`: Int32 = 0 + var internalState: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct InternalState { + struct intersect: Sendable { // 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 internalState: Int32 = 0 + var intersect: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct into { + struct into: Sendable { // 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. @@ -5443,7 +6667,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ints { + struct ints: Sendable { // 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. @@ -5455,7 +6679,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct isA { + struct invalidAnyTypeURL: Sendable { + // 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 invalidAnyTypeURL: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct isA: Sendable { // 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. @@ -5467,7 +6703,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct isEqual { + struct isEqual: Sendable { // 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. @@ -5479,7 +6715,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct isEqualTo { + struct isEqualTo: Sendable { // 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. @@ -5491,7 +6727,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct isExtension { + struct isExtension: Sendable { // 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. @@ -5503,7 +6739,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct isInitializedMessage { + struct isInitializedMessage: Sendable { // 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. @@ -5515,43 +6751,79 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct itemTagsEncodedSize { + struct isNegative: Sendable { // 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 itemTagsEncodedSize: Int32 = 0 + var isNegative: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Iterator { + struct isPathValid: Sendable { // 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 iterator: Int32 = 0 + var isPathValid: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct i_2166136261 { + struct isReserved: Sendable { // 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 i2166136261: Int32 = 0 + var isReserved: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct isValid: Sendable { + // 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 isValid: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct itemTagsEncodedSize: Sendable { + // 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 itemTagsEncodedSize: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct iterator: Sendable { + // 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 iterator: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct javaGenerateEqualsAndHash { + struct javaGenerateEqualsAndHash: Sendable { // 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. @@ -5563,7 +6835,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct javaGenericServices { + struct javaGenericServices: Sendable { // 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. @@ -5575,7 +6847,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct javaMultipleFiles { + struct javaMultipleFiles: Sendable { // 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. @@ -5587,7 +6859,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct javaOuterClassname { + struct javaOuterClassname: Sendable { // 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. @@ -5599,7 +6871,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct javaPackage { + struct javaPackage: Sendable { // 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. @@ -5611,7 +6883,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct javaStringCheckUtf8 { + struct javaStringCheckUtf8: Sendable { // 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. @@ -5623,7 +6895,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct JSONDecoder { + struct JSONDecoder: Sendable { // 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. @@ -5635,7 +6907,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct JSONDecodingError { + struct JSONDecoding: Sendable { + // 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 jsondecoding: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct JSONDecodingError: Sendable { // 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. @@ -5647,7 +6931,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct JSONDecodingOptions { + struct JSONDecodingOptions: Sendable { // 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. @@ -5659,7 +6943,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct jsonEncoder { + struct jsonEncoder: Sendable { // 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. @@ -5671,7 +6955,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct JSONEncodingError { + struct JSONEncoding: Sendable { + // 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 jsonencoding: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct JSONEncodingError: Sendable { // 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. @@ -5683,7 +6979,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct JSONEncodingOptions { + struct JSONEncodingOptions: Sendable { // 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. @@ -5695,7 +6991,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct JSONEncodingVisitor { + struct JSONEncodingVisitor: Sendable { // 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. @@ -5707,7 +7003,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct JSONMapEncodingVisitor { + struct jsonFormat: Sendable { + // 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 jsonFormat: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct JSONMapEncodingVisitor: Sendable { // 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. @@ -5719,7 +7027,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct jsonName { + struct jsonName: Sendable { // 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. @@ -5731,7 +7039,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct jsonPath { + struct jsonPath: Sendable { // 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. @@ -5743,7 +7051,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct jsonPaths { + struct jsonPaths: Sendable { // 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. @@ -5755,7 +7063,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct JSONScanner { + struct JSONScanner: Sendable { // 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. @@ -5767,7 +7075,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct jsonString { + struct jsonString: Sendable { // 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. @@ -5779,7 +7087,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct jsonText { + struct jsonText: Sendable { // 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. @@ -5791,7 +7099,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct jsonUTF8Data { + struct jsonUTF8Bytes: Sendable { + // 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 jsonUtf8Bytes: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct jsonUTF8Data: Sendable { // 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. @@ -5803,7 +7123,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct jstype { + struct jstype: Sendable { // 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. @@ -5815,7 +7135,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct k { + struct k: Sendable { // 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. @@ -5827,7 +7147,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Key { + struct kChunkSize: Sendable { + // 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 kChunkSize: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct Key: Sendable { // 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. @@ -5839,7 +7171,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct keyField { + struct keyField: Sendable { // 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. @@ -5851,7 +7183,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct KeyType { + struct keyFieldOpt: Sendable { + // 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 keyFieldOpt: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct KeyType: Sendable { // 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. @@ -5863,7 +7207,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct kind { + struct kind: Sendable { // 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. @@ -5875,7 +7219,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct l { + struct l: Sendable { // 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. @@ -5887,7 +7231,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct label { + struct label: Sendable { // 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. @@ -5899,7 +7243,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct lazy { + struct lazy: Sendable { // 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. @@ -5911,7 +7255,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct leadingComments { + struct leadingComments: Sendable { // 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. @@ -5923,7 +7267,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct leadingDetachedComments { + struct leadingDetachedComments: Sendable { // 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. @@ -5935,7 +7279,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct length { + struct length: Sendable { // 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. @@ -5947,7 +7291,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct lessThan { + struct lessThan: Sendable { // 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. @@ -5959,7 +7303,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct letMessage { + struct letMessage: Sendable { // 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. @@ -5971,7 +7315,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct lhs { + struct lhs: Sendable { // 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. @@ -5983,67 +7327,67 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct list { + struct line: Sendable { // 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 list: Int32 = 0 + var line: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct listOfMessages { + struct list: Sendable { // 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 listOfMessages: Int32 = 0 + var list: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct listValue { + struct listOfMessages: Sendable { // 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 listValue: Int32 = 0 + var listOfMessages: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct littleEndian { + struct listValue: Sendable { // 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 littleEndian: Int32 = 0 + var listValue: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct littleEndianBytes { + struct littleEndian: Sendable { // 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 littleEndianBytes: Int32 = 0 + var littleEndian: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct load { + struct load: Sendable { // 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. @@ -6055,7 +7399,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct localHasher { + struct localHasher: Sendable { // 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. @@ -6067,7 +7411,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct location { + struct location: Sendable { // 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. @@ -6079,7 +7423,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct M { + struct M: Sendable { // 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. @@ -6091,7 +7435,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct major { + struct major: Sendable { // 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. @@ -6103,67 +7447,67 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct makeIterator { + struct makeAsyncIterator: Sendable { // 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 makeIterator: Int32 = 0 + var makeAsyncIterator: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct mapEntry { + struct makeIterator: Sendable { // 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 mapEntry: Int32 = 0 + var makeIterator: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct mapHash { + struct malformedLength: Sendable { // 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 mapHash: Int32 = 0 + var malformedLength: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct MapKeyType { + struct mapEntry: Sendable { // 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 mapKeyType: Int32 = 0 + var mapEntry: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct mapNameResolver { + struct MapKeyType: Sendable { // 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 mapNameResolver: Int32 = 0 + var mapKeyType: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct mapToMessages { + struct mapToMessages: Sendable { // 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. @@ -6175,7 +7519,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct MapValueType { + struct MapValueType: Sendable { // 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. @@ -6187,7 +7531,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct mapVisitor { + struct mapVisitor: Sendable { // 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. @@ -6199,7 +7543,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct mdayStart { + struct mask: Sendable { + // 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 mask: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct maximumEdition: Sendable { + // 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 maximumEdition: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct mdayStart: Sendable { // 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. @@ -6211,7 +7579,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct merge { + struct merge: Sendable { // 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. @@ -6223,139 +7591,139 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct message { + struct MergeOptions: Sendable { // 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 message: Int32 = 0 + var mergeOptions: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct messageDepthLimit { + struct message: Sendable { // 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 messageDepthLimit: Int32 = 0 + var message: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct MessageExtension { + struct messageDepthLimit: Sendable { // 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 messageExtension: Int32 = 0 + var messageDepthLimit: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct MessageImplementationBase { + struct messageEncoding: Sendable { // 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 messageImplementationBase: Int32 = 0 + var messageEncoding: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct MessageOptions { + struct MessageExtension: Sendable { // 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 messageOptions: Int32 = 0 + var messageExtension: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct MessageSet { + struct MessageImplementationBase: Sendable { // 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 messageSet: Int32 = 0 + var messageImplementationBase: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct messageSetWireFormat { + struct MessageSet: Sendable { // 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 messageSetWireFormat: Int32 = 0 + var messageSet: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct messageType { + struct messageSetWireFormat: Sendable { // 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 messageType: Int32 = 0 + var messageSetWireFormat: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Method { + struct messageSize: Sendable { // 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 method: Int32 = 0 + var messageSize: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct MethodDescriptorProto { + struct messageType: Sendable { // 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 methodDescriptorProto: Int32 = 0 + var messageType: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct MethodOptions { + struct method: Sendable { // 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 methodOptions: Int32 = 0 + var method: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct methods { + struct methods: Sendable { // 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. @@ -6367,55 +7735,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct minor { + struct min: Sendable { // 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 minor: Int32 = 0 + var min: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Mixin { + struct minimumEdition: Sendable { // 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 mixin: Int32 = 0 + var minimumEdition: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct mixins { + struct minor: Sendable { // 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 mixins: Int32 = 0 + var minor: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct modifier { + struct mixins: Sendable { // 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 modifier: Int32 = 0 + var mixins: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct modify { + struct modify: Sendable { // 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. @@ -6427,7 +7795,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct month { + struct month: Sendable { // 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. @@ -6439,7 +7807,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct msgExtension { + struct msgExtension: Sendable { // 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. @@ -6451,7 +7819,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct mutating { + struct mutating: Sendable { // 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. @@ -6463,7 +7831,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct n { + struct n: Sendable { // 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. @@ -6475,7 +7843,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct name { + struct name: Sendable { // 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. @@ -6487,7 +7855,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct NameDescription { + struct NameDescription: Sendable { // 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. @@ -6499,7 +7867,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct NameMap { + struct NameMap: Sendable { // 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. @@ -6511,7 +7879,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct NamePart { + struct NamePart: Sendable { // 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. @@ -6523,127 +7891,127 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct nameResolver { + struct names: Sendable { // 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 nameResolver: Int32 = 0 + var names: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct names { + struct nanos: Sendable { // 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 names: Int32 = 0 + var nanos: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct nanos { + struct negativeIntValue: Sendable { // 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 nanos: Int32 = 0 + var negativeIntValue: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct nativeBytes { + struct nestedType: Sendable { // 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 nativeBytes: Int32 = 0 + var nestedType: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct nativeEndianBytes { + struct newExtensible: Sendable { // 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 nativeEndianBytes: Int32 = 0 + var newExtensible: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct negativeIntValue { + struct newL: Sendable { // 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 negativeIntValue: Int32 = 0 + var newL: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct nestedType { + struct newList: Sendable { // 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 nestedType: Int32 = 0 + var newList: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct newL { + struct newMessage: Sendable { // 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 newL: Int32 = 0 + var newMessage: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct newList { + struct newValue: Sendable { // 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 newList: Int32 = 0 + var newValue: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct newValue { + struct next: Sendable { // 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 newValue: Int32 = 0 + var next: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct nextByte { + struct nextByte: Sendable { // 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. @@ -6655,7 +8023,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct nextFieldNumber { + struct nextFieldNumber: Sendable { // 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. @@ -6667,7 +8035,91 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct nilMessage { + struct nextInstruction: Sendable { + // 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 nextInstruction: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct nextInt32: Sendable { + // 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 nextInt32: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct nextNullTerminatedString: Sendable { + // 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 nextNullTerminatedString: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct nextNullTerminatedStringArray: Sendable { + // 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 nextNullTerminatedStringArray: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct nextNumber: Sendable { + // 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 nextNumber: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct nextUInt64: Sendable { + // 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 nextUint64: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct nextVarInt: Sendable { + // 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 nextVarInt: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct nilMessage: Sendable { // 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. @@ -6679,7 +8131,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct nilLiteral { + struct nilLiteral: Sendable { // 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. @@ -6691,7 +8143,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct noStandardDescriptorAccessor { + struct noBytesAvailable: Sendable { + // 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 noBytesAvailable: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct noStandardDescriptorAccessor: Sendable { // 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. @@ -6703,7 +8167,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct nullValue { + struct nullValue: Sendable { // 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. @@ -6715,7 +8179,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct number { + struct number: Sendable { // 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. @@ -6727,7 +8191,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct numberValue { + struct numberValue: Sendable { // 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. @@ -6739,7 +8203,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct objcClassPrefix { + struct objcClassPrefix: Sendable { // 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. @@ -6751,7 +8215,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct of { + struct of: Sendable { // 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. @@ -6763,31 +8227,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct oneofDecl { + struct OneOf_Kind: Sendable { // 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 oneofDecl: Int32 = 0 + var oneOfKind: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct OneofDescriptorProto { + struct oneofDecl: Sendable { // 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 oneofDescriptorProto: Int32 = 0 + var oneofDecl: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct oneofIndex { + struct oneofIndex: Sendable { // 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. @@ -6799,139 +8263,139 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct OneofOptions { + struct oneofs: Sendable { // 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 oneofOptions: Int32 = 0 + var oneofs: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct oneofs { + struct optimizeFor: Sendable { // 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 oneofs: Int32 = 0 + var optimizeFor: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct OneOf_Kind { + struct OptimizeMode: Sendable { // 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 oneOfKind: Int32 = 0 + var optimizeMode: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct optimizeFor { + struct OptionalEnumExtensionField: Sendable { // 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 optimizeFor: Int32 = 0 + var optionalEnumExtensionField: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct OptimizeMode { + struct OptionalExtensionField: Sendable { // 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 optimizeMode: Int32 = 0 + var optionalExtensionField: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Option { + struct OptionalGroupExtensionField: Sendable { // 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 option: Int32 = 0 + var optionalGroupExtensionField: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct OptionalEnumExtensionField { + struct OptionalMessageExtensionField: Sendable { // 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 optionalEnumExtensionField: Int32 = 0 + var optionalMessageExtensionField: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct OptionalExtensionField { + struct optionDependency: Sendable { // 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 optionalExtensionField: Int32 = 0 + var optionDependency: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct OptionalGroupExtensionField { + struct OptionRetention: Sendable { // 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 optionalGroupExtensionField: Int32 = 0 + var optionRetention: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct OptionalMessageExtensionField { + struct options: Sendable { // 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 optionalMessageExtensionField: Int32 = 0 + var options: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct options { + struct OptionTargetType: Sendable { // 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 options: Int32 = 0 + var optionTargetType: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct other { + struct other: Sendable { // 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. @@ -6943,7 +8407,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct others { + struct others: Sendable { // 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. @@ -6955,7 +8419,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct out { + struct out: Sendable { // 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. @@ -6967,7 +8431,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct outputType { + struct outputType: Sendable { // 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. @@ -6979,7 +8443,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct p { + struct overridableFeatures: Sendable { + // 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 overridableFeatures: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct p: Sendable { // 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. @@ -6991,7 +8467,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct package { + struct package: Sendable { // 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. @@ -7003,7 +8479,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct packed { + struct packed: Sendable { // 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. @@ -7015,7 +8491,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct PackedEnumExtensionField { + struct PackedEnumExtensionField: Sendable { // 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. @@ -7027,7 +8503,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct PackedExtensionField { + struct PackedExtensionField: Sendable { // 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. @@ -7039,7 +8515,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct padding { + struct padding: Sendable { // 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. @@ -7051,7 +8527,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct parent { + struct parent: Sendable { // 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. @@ -7063,7 +8539,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct parse { + struct parse: Sendable { // 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. @@ -7075,7 +8551,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct partial { + struct partial: Sendable { // 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. @@ -7087,7 +8563,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct path { + struct path: Sendable { // 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. @@ -7099,103 +8575,115 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct paths { + struct PathDecoder: Sendable { // 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 paths: Int32 = 0 + var pathDecoder: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct payload { + struct PathDecodingError: Sendable { // 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 payload: Int32 = 0 + var pathDecodingError: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct payloadSize { + struct paths: Sendable { // 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 payloadSize: Int32 = 0 + var paths: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct phpClassPrefix { + struct PathVisitor: Sendable { // 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 phpClassPrefix: Int32 = 0 + var pathVisitor: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct payload: Sendable { + // 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 payload: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct phpGenericServices { + struct payloadSize: Sendable { // 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 phpGenericServices: Int32 = 0 + var payloadSize: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct phpMetadataNamespace { + struct phpClassPrefix: Sendable { // 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 phpMetadataNamespace: Int32 = 0 + var phpClassPrefix: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct phpNamespace { + struct phpMetadataNamespace: Sendable { // 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 phpNamespace: Int32 = 0 + var phpMetadataNamespace: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct pointer { + struct phpNamespace: Sendable { // 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 pointer: Int32 = 0 + var phpNamespace: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct pos { + struct pos: Sendable { // 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. @@ -7207,7 +8695,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct positiveIntValue { + struct positiveIntValue: Sendable { // 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. @@ -7219,7 +8707,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct prefix { + struct prefix: Sendable { // 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. @@ -7231,7 +8719,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct preserveProtoFieldNames { + struct preserveProtoFieldNames: Sendable { // 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. @@ -7243,7 +8731,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct preTraverse { + struct preTraverse: Sendable { // 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. @@ -7255,7 +8743,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct printUnknownFields { + struct previousNumber: Sendable { + // 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 previousNumber: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct prevPath: Sendable { + // 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 prevPath: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct printUnknownFields: Sendable { // 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. @@ -7267,7 +8779,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct proto2 { + struct programBuffer: Sendable { + // 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 programBuffer: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct programFormat: Sendable { + // 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 programFormat: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct proto2: Sendable { // 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. @@ -7279,7 +8815,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct proto3DefaultValue { + struct proto3DefaultValue: Sendable { // 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. @@ -7291,7 +8827,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct proto3Optional { + struct proto3Optional: Sendable { // 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. @@ -7303,331 +8839,343 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ProtobufAPIVersionCheck { + struct protobuf_extensionFieldValues: Sendable { // 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 protobufApiversionCheck: Int32 = 0 + var protobufExtensionFieldValues: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufAPIVersion_2 { + struct protobuf_fieldNumber: Sendable { // 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 protobufApiversion2: Int32 = 0 + var protobufFieldNumber: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufBool { + struct protobuf_generated_isEqualTo: Sendable { // 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 protobufBool: Int32 = 0 + var protobufGeneratedIsEqualTo: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufBytes { + struct protobuf_nameMap: Sendable { // 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 protobufBytes: Int32 = 0 + var protobufNameMap: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufDouble { + struct protobuf_newField: Sendable { // 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 protobufDouble: Int32 = 0 + var protobufNewField: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufEnumMap { + struct protobuf_package: Sendable { // 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 protobufEnumMap: Int32 = 0 + var protobufPackage: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct protobufExtension { + struct ProtobufAPIVersion_2: Sendable { // 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 protobufExtension: Int32 = 0 + var protobufApiversion2: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufFixed32 { + struct ProtobufAPIVersionCheck: Sendable { // 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 protobufFixed32: Int32 = 0 + var protobufApiversionCheck: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufFixed64 { + struct ProtobufBool: Sendable { // 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 protobufFixed64: Int32 = 0 + var protobufBool: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufFloat { + struct ProtobufBytes: Sendable { // 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 protobufFloat: Int32 = 0 + var protobufBytes: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufInt32 { + struct protobufData: Sendable { // 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 protobufInt32: Int32 = 0 + var protobufData: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufInt64 { + struct ProtobufDouble: Sendable { // 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 protobufInt64: Int32 = 0 + var protobufDouble: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufMap { + struct ProtobufEnumMap: Sendable { // 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 protobufMap: Int32 = 0 + var protobufEnumMap: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufMessageMap { + struct protobufExtension: Sendable { // 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 protobufMessageMap: Int32 = 0 + var protobufExtension: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufSFixed32 { + struct ProtobufFixed32: Sendable { // 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 protobufSfixed32: Int32 = 0 + var protobufFixed32: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufSFixed64 { + struct ProtobufFixed64: Sendable { // 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 protobufSfixed64: Int32 = 0 + var protobufFixed64: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufSInt32 { + struct ProtobufFloat: Sendable { // 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 protobufSint32: Int32 = 0 + var protobufFloat: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufSInt64 { + struct ProtobufInt32: Sendable { // 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 protobufSint64: Int32 = 0 + var protobufInt32: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufString { + struct ProtobufInt64: Sendable { // 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 protobufString: Int32 = 0 + var protobufInt64: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufUInt32 { + struct ProtobufMap: Sendable { // 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 protobufUint32: Int32 = 0 + var protobufMap: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufUInt64 { + struct ProtobufMessageMap: Sendable { // 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 protobufUint64: Int32 = 0 + var protobufMessageMap: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct protobuf_extensionFieldValues { + struct ProtobufSFixed32: Sendable { // 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 protobufExtensionFieldValues: Int32 = 0 + var protobufSfixed32: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct protobuf_fieldNumber { + struct ProtobufSFixed64: Sendable { // 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 protobufFieldNumber: Int32 = 0 + var protobufSfixed64: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct protobuf_generated_isEqualTo { + struct ProtobufSInt32: Sendable { // 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 protobufGeneratedIsEqualTo: Int32 = 0 + var protobufSint32: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct protobuf_nameMap { + struct ProtobufSInt64: Sendable { // 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 protobufNameMap: Int32 = 0 + var protobufSint64: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct protobuf_newField { + struct ProtobufString: Sendable { // 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 protobufNewField: Int32 = 0 + var protobufString: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct protobuf_package { + struct ProtobufUInt32: Sendable { // 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 protobufPackage: Int32 = 0 + var protobufUint32: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct ProtobufUInt64: Sendable { + // 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 protobufUint64: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct protocolMessage { + struct protocolMessage: Sendable { // 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. @@ -7639,7 +9187,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct protoFieldName { + struct protoFieldName: Sendable { // 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. @@ -7651,7 +9199,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct protoMessageNameMessage { + struct protoMessageNameMessage: Sendable { // 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. @@ -7663,7 +9211,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ProtoNameProviding { + struct ProtoNameProviding: Sendable { // 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. @@ -7675,7 +9223,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct protoPaths { + struct protoPaths: Sendable { // 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. @@ -7687,7 +9235,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct publicMessage { + struct publicMessage: Sendable { // 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. @@ -7699,7 +9247,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct publicDependency { + struct publicDependency: Sendable { // 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. @@ -7711,7 +9259,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putBoolValue { + struct putBoolValue: Sendable { // 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. @@ -7723,7 +9271,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putBytesValue { + struct putBytesValue: Sendable { // 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. @@ -7735,7 +9283,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putDoubleValue { + struct putDoubleValue: Sendable { // 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. @@ -7747,7 +9295,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putEnumValue { + struct putEnumValue: Sendable { // 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. @@ -7759,7 +9307,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putFixedUInt32 { + struct putFixedUInt32: Sendable { // 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. @@ -7771,7 +9319,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putFixedUInt64 { + struct putFixedUInt64: Sendable { // 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. @@ -7783,7 +9331,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putFloatValue { + struct putFloatValue: Sendable { // 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. @@ -7795,7 +9343,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putInt64 { + struct putInt64: Sendable { // 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. @@ -7807,7 +9355,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putStringValue { + struct putStringValue: Sendable { // 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. @@ -7819,7 +9367,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putUInt64 { + struct putUInt64: Sendable { // 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. @@ -7831,7 +9379,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putUInt64Hex { + struct putUInt64Hex: Sendable { // 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. @@ -7843,7 +9391,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putVarInt { + struct putVarInt: Sendable { // 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. @@ -7855,7 +9403,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putZigZagVarInt { + struct putZigZagVarInt: Sendable { // 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. @@ -7867,7 +9415,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct pyGenericServices { + struct pyGenericServices: Sendable { // 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. @@ -7879,7 +9427,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct rawChars { + struct R: Sendable { + // 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 r: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct rawChars: Sendable { // 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. @@ -7891,7 +9451,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct RawRepresentable { + struct RawRepresentable: Sendable { // 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. @@ -7903,7 +9463,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct RawValue { + struct RawValue: Sendable { // 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. @@ -7915,7 +9475,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct read4HexDigits { + struct read4HexDigits: Sendable { // 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. @@ -7927,7 +9487,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct register { + struct readBytes: Sendable { + // 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 readBytes: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct reader: Sendable { + // 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 reader: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct register: Sendable { // 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. @@ -7939,7 +9523,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct RepeatedEnumExtensionField { + struct remainingProgram: Sendable { + // 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 remainingProgram: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct removalError: Sendable { + // 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 removalError: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct removingAllFieldsOf: Sendable { + // 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 removingAllFieldsOf: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct repeated: Sendable { + // 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 repeated: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct RepeatedEnumExtensionField: Sendable { // 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. @@ -7951,7 +9583,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct RepeatedExtensionField { + struct RepeatedExtensionField: Sendable { // 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. @@ -7963,7 +9595,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct RepeatedGroupExtensionField { + struct repeatedFieldEncoding: Sendable { + // 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 repeatedFieldEncoding: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct RepeatedGroupExtensionField: Sendable { // 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. @@ -7975,7 +9619,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct RepeatedMessageExtensionField { + struct RepeatedMessageExtensionField: Sendable { // 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. @@ -7987,67 +9631,67 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct requestStreaming { + struct repeating: Sendable { // 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 requestStreaming: Int32 = 0 + var repeating: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct requestTypeURL { + struct replaceRepeatedFields: Sendable { // 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 requestTypeURL: Int32 = 0 + var replaceRepeatedFields: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct requiredSize { + struct requestStreaming: Sendable { // 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 requiredSize: Int32 = 0 + var requestStreaming: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct reservedName { + struct requestTypeURL: Sendable { // 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 reservedName: Int32 = 0 + var requestTypeURL: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct reservedRange { + struct requiredSize: Sendable { // 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 reservedRange: Int32 = 0 + var requiredSize: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct responseStreaming { + struct responseStreaming: Sendable { // 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. @@ -8059,7 +9703,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct responseTypeURL { + struct responseTypeURL: Sendable { // 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. @@ -8071,7 +9715,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct result { + struct result: Sendable { // 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. @@ -8083,31 +9727,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct rethrowsMessage { + struct retention: Sendable { // 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 `rethrows`: Int32 = 0 + var retention: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct returnMessage { + struct rethrowsMessage: Sendable { // 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 `return`: Int32 = 0 + var `rethrows`: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ReturnType { + struct ReturnType: Sendable { // 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. @@ -8119,7 +9763,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct revision { + struct revision: Sendable { // 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. @@ -8131,7 +9775,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct rhs { + struct rhs: Sendable { // 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. @@ -8143,7 +9787,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct root { + struct root: Sendable { // 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. @@ -8155,7 +9799,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct rubyPackage { + struct rubyPackage: Sendable { // 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. @@ -8167,7 +9811,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct s { + struct s: Sendable { // 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. @@ -8179,7 +9823,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct sawBackslash { + struct sawBackslash: Sendable { // 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. @@ -8191,7 +9835,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct sawSection4Characters { + struct sawSection4Characters: Sendable { // 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. @@ -8203,7 +9847,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct sawSection5Characters { + struct sawSection5Characters: Sendable { // 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. @@ -8215,7 +9859,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct scanner { + struct Scalar: Sendable { + // 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 scalar: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct scan: Sendable { + // 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 scan: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct scanner: Sendable { // 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. @@ -8227,7 +9895,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct seconds { + struct seconds: Sendable { // 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. @@ -8239,7 +9907,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct selfMessage { + struct selfMessage: Sendable { // 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. @@ -8251,103 +9919,115 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct separator { + struct semantic: Sendable { // 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 separator: Int32 = 0 + var semantic: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct serialize { + struct SendableMessage: Sendable { // 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 serialize: Int32 = 0 + var sendable: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct serializedData { + struct separator: Sendable { // 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 serializedData: Int32 = 0 + var separator: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct serializedSize { + struct serialize: Sendable { // 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 serializedSize: Int32 = 0 + var serialize: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct serverStreaming { + struct serializedBytes: Sendable { // 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 serverStreaming: Int32 = 0 + var serializedBytes: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct service { + struct serializedData: Sendable { // 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 service: Int32 = 0 + var serializedData: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct serializedSize: Sendable { + // 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 serializedSize: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ServiceDescriptorProto { + struct serverStreaming: Sendable { // 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 serviceDescriptorProto: Int32 = 0 + var serverStreaming: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ServiceOptions { + struct service: Sendable { // 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 serviceOptions: Int32 = 0 + var service: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct set { + struct set: Sendable { // 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. @@ -8359,7 +10039,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct setExtensionValue { + struct setExtensionValue: Sendable { // 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. @@ -8371,7 +10051,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct shift { + struct shift: Sendable { // 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. @@ -8383,7 +10063,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct SimpleExtensionMap { + struct SimpleExtensionMap: Sendable { // 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. @@ -8395,7 +10075,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct sizer { + struct size: Sendable { + // 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 size: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct sizer: Sendable { // 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. @@ -8407,7 +10099,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct source { + struct source: Sendable { // 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. @@ -8419,7 +10111,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct sourceCodeInfo { + struct sourceCodeInfo: Sendable { // 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. @@ -8431,7 +10123,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct sourceContext { + struct sourceContext: Sendable { // 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. @@ -8443,7 +10135,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct sourceEncoding { + struct sourceEncoding: Sendable { // 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. @@ -8455,7 +10147,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct sourceFile { + struct sourceFile: Sendable { // 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. @@ -8467,7 +10159,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct span { + struct SourceLocation: Sendable { + // 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 sourceLocation: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct span: Sendable { // 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. @@ -8479,7 +10183,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct split { + struct split: Sendable { // 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. @@ -8491,7 +10195,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct start { + struct start: Sendable { // 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. @@ -8503,7 +10207,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct startArray { + struct startArray: Sendable { // 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. @@ -8515,7 +10219,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct startArrayObject { + struct startArrayObject: Sendable { // 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. @@ -8527,7 +10231,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct startField { + struct startField: Sendable { // 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. @@ -8539,7 +10243,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct startIndex { + struct startIndex: Sendable { // 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. @@ -8551,7 +10255,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct startMessageField { + struct startMessageField: Sendable { // 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. @@ -8563,7 +10267,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct startObject { + struct startObject: Sendable { // 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. @@ -8575,7 +10279,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct startRegularField { + struct startRegularField: Sendable { // 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. @@ -8587,7 +10291,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct state { + struct state: Sendable { // 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. @@ -8599,7 +10303,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct staticMessage { + struct staticMessage: Sendable { // 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. @@ -8611,7 +10315,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct StaticString { + struct StaticString: Sendable { // 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. @@ -8623,7 +10327,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct storage { + struct storage: Sendable { // 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. @@ -8635,7 +10339,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct StringMessage { + struct StringMessage: Sendable { // 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. @@ -8647,7 +10351,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct stringLiteral { + struct stringLiteral: Sendable { // 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. @@ -8659,7 +10363,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct StringLiteralType { + struct StringLiteralType: Sendable { // 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. @@ -8671,7 +10375,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct stringResult { + struct stringResult: Sendable { // 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. @@ -8683,7 +10387,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct stringValue { + struct stringValue: Sendable { // 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. @@ -8695,7 +10399,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct structMessage { + struct structMessage: Sendable { // 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. @@ -8707,7 +10411,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct structValue { + struct structValue: Sendable { // 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. @@ -8719,7 +10423,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct subDecoder { + struct subDecoder: Sendable { // 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. @@ -8731,7 +10435,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct subscriptMessage { + struct subscriptMessage: Sendable { // 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. @@ -8743,7 +10447,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct subVisitor { + struct subtract: Sendable { + // 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 subtract: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct subVisitor: Sendable { // 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. @@ -8755,7 +10471,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Swift { + struct SwiftMessage: Sendable { // 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. @@ -8767,7 +10483,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct swiftPrefix { + struct swiftPrefix: Sendable { // 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. @@ -8779,19 +10495,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct SwiftProtobufMessage { + struct SwiftProtobufContiguousBytes: Sendable { // 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 swiftProtobuf: Int32 = 0 + var swiftProtobufContiguousBytes: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct syntax { + struct SwiftProtobufError: Sendable { + // 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 swiftProtobufError: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct syntax: Sendable { // 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. @@ -8803,7 +10531,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct T { + struct T: Sendable { // 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. @@ -8815,7 +10543,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct tag { + struct tag: Sendable { // 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. @@ -8827,7 +10555,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct terminator { + struct targets: Sendable { + // 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 targets: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct terminator: Sendable { // 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. @@ -8839,7 +10579,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct testDecoder { + struct testDecoder: Sendable { // 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. @@ -8851,7 +10591,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct text { + struct text: Sendable { // 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. @@ -8863,7 +10603,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct textDecoder { + struct textDecoder: Sendable { // 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. @@ -8875,7 +10615,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct TextFormatDecoder { + struct TextFormatDecoder: Sendable { // 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. @@ -8887,7 +10627,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct TextFormatDecodingError { + struct TextFormatDecodingError: Sendable { // 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. @@ -8899,7 +10639,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct TextFormatDecodingOptions { + struct TextFormatDecodingOptions: Sendable { // 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. @@ -8911,7 +10651,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct TextFormatEncodingOptions { + struct TextFormatEncodingOptions: Sendable { // 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. @@ -8923,7 +10663,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct TextFormatEncodingVisitor { + struct TextFormatEncodingVisitor: Sendable { // 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. @@ -8935,7 +10675,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct textFormatString { + struct textFormatString: Sendable { // 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. @@ -8947,7 +10687,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct throwsMessage { + struct throwOrIgnore: Sendable { + // 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 throwOrIgnore: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct throwsMessage: Sendable { // 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. @@ -8959,7 +10711,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct timeInterval { + struct timeInterval: Sendable { // 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. @@ -8971,7 +10723,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct timeIntervalSince1970 { + struct timeIntervalSince1970: Sendable { // 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. @@ -8983,7 +10735,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct timeIntervalSinceReferenceDate { + struct timeIntervalSinceReferenceDate: Sendable { // 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. @@ -8995,19 +10747,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Timestamp { + struct tmp: Sendable { // 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 timestamp: Int32 = 0 + var tmp: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct total { + struct tooLarge: Sendable { + // 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 tooLarge: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct total: Sendable { // 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. @@ -9019,7 +10783,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct totalArrayDepth { + struct totalArrayDepth: Sendable { // 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. @@ -9031,7 +10795,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct totalSize { + struct totalSize: Sendable { // 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. @@ -9043,7 +10807,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct trailingComments { + struct trailingComments: Sendable { // 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. @@ -9055,7 +10819,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct traverseMessage { + struct traverseMessage: Sendable { // 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. @@ -9067,7 +10831,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct trueMessage { + struct trim: Sendable { + // 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 trim: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct trueMessage: Sendable { // 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. @@ -9079,7 +10855,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct tryMessage { + struct tryMessage: Sendable { // 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. @@ -9091,7 +10867,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct type { + struct type: Sendable { // 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. @@ -9103,7 +10879,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct typealiasMessage { + struct typealiasMessage: Sendable { // 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. @@ -9115,7 +10891,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct TypeEnum { + struct TypeEnum: Sendable { // 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. @@ -9127,7 +10903,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct typeName { + struct typeName: Sendable { // 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. @@ -9139,7 +10915,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct typePrefix { + struct typePrefix: Sendable { // 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. @@ -9151,7 +10927,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct typeStart { + struct typeStart: Sendable { // 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. @@ -9163,7 +10939,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct typeUnknown { + struct typeUnknown: Sendable { // 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. @@ -9175,7 +10951,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct typeURL { + struct typeURL: Sendable { // 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. @@ -9187,7 +10963,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UInt32Message { + struct UInt32Message: Sendable { // 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. @@ -9199,55 +10975,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UInt32Value { + struct UInt64Message: Sendable { // 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 uint32Value: Int32 = 0 + var uint64: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct UInt64Message { + struct UInt8: Sendable { // 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 uint64: Int32 = 0 + var uint8: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct UInt64Value { + struct unchecked: Sendable { // 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 uint64Value: Int32 = 0 + var unchecked: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct UInt8 { + struct Unicode: Sendable { // 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 uint8: Int32 = 0 + var unicode: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct unicodeScalarLiteral { + struct unicodeScalarLiteral: Sendable { // 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. @@ -9259,7 +11035,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UnicodeScalarLiteralType { + struct UnicodeScalarLiteralType: Sendable { // 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. @@ -9271,7 +11047,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct unicodeScalars { + struct unicodeScalars: Sendable { // 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. @@ -9283,7 +11059,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UnicodeScalarView { + struct UnicodeScalarView: Sendable { // 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. @@ -9295,7 +11071,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct uninterpretedOption { + struct uninterpretedOption: Sendable { // 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. @@ -9307,7 +11083,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct union { + struct union: Sendable { // 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. @@ -9319,7 +11095,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct uniqueStorage { + struct uniqueStorage: Sendable { // 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. @@ -9331,7 +11107,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct unknown { + struct unknown: Sendable { // 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. @@ -9343,7 +11119,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct unknownFieldsMessage { + struct unknownFieldsMessage: Sendable { // 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. @@ -9355,7 +11131,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UnknownStorage { + struct UnknownStorage: Sendable { // 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. @@ -9367,7 +11143,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct unpackTo { + struct unpackTo: Sendable { // 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. @@ -9379,7 +11155,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UnsafeBufferPointer { + struct UnsafeBufferPointer: Sendable { // 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. @@ -9391,7 +11167,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UnsafeMutablePointer { + struct UnsafeMutablePointer: Sendable { // 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. @@ -9403,7 +11179,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UnsafeMutableRawBufferPointer { + struct UnsafeMutableRawBufferPointer: Sendable { // 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. @@ -9415,43 +11191,43 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UnsafeMutableRawPointer { + struct UnsafeRawBufferPointer: Sendable { // 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 unsafeMutableRawPointer: Int32 = 0 + var unsafeRawBufferPointer: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct UnsafeRawBufferPointer { + struct UnsafeRawPointer: Sendable { // 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 unsafeRawBufferPointer: Int32 = 0 + var unsafeRawPointer: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct UnsafeRawPointer { + struct unverifiedLazy: Sendable { // 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 unsafeRawPointer: Int32 = 0 + var unverifiedLazy: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct updatedOptions { + struct updatedOptions: Sendable { // 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. @@ -9463,7 +11239,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct url { + struct uppercasedAssumingASCII: Sendable { + // 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 uppercasedAssumingAscii: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct url: Sendable { // 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. @@ -9475,7 +11263,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct utf8 { + struct useDeterministicOrdering: Sendable { + // 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 useDeterministicOrdering: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct utf8: Sendable { // 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. @@ -9487,7 +11287,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct utf8Ptr { + struct utf8Ptr: Sendable { // 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. @@ -9499,7 +11299,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct utf8ToDouble { + struct utf8ToDouble: Sendable { // 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. @@ -9511,7 +11311,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UTF8View { + struct utf8Validation: Sendable { + // 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 utf8Validation: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct UTF8View: Sendable { // 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. @@ -9523,7 +11335,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct v { + struct V: Sendable { // 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. @@ -9535,7 +11347,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct value { + struct value: Sendable { // 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. @@ -9547,7 +11359,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct valueField { + struct valueField: Sendable { // 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. @@ -9559,7 +11371,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct values { + struct values: Sendable { // 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. @@ -9571,7 +11383,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ValueType { + struct ValueType: Sendable { // 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. @@ -9583,7 +11395,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct varMessage { + struct varMessage: Sendable { // 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. @@ -9595,7 +11407,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Version { + struct verification: Sendable { + // 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 verification: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct VerificationState: Sendable { + // 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 verificationState: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct version: Sendable { // 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. @@ -9607,7 +11443,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct versionString { + struct versionString: Sendable { // 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. @@ -9619,7 +11455,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitExtensionFields { + struct visibility: Sendable { + // 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 visibility: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct VisibilityFeature: Sendable { + // 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 visibilityFeature: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct visitExtensionFields: Sendable { // 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. @@ -9631,7 +11491,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitExtensionFieldsAsMessageSet { + struct visitExtensionFieldsAsMessageSet: Sendable { // 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. @@ -9643,7 +11503,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitMapField { + struct visitMapField: Sendable { // 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. @@ -9655,7 +11515,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitor { + struct Visitor: Sendable { // 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. @@ -9667,7 +11527,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPacked { + struct visitPacked: Sendable { // 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. @@ -9679,7 +11539,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedBoolField { + struct visitPackedBoolField: Sendable { // 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. @@ -9691,7 +11551,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedDoubleField { + struct visitPackedDoubleField: Sendable { // 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. @@ -9703,7 +11563,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedEnumField { + struct visitPackedEnumField: Sendable { // 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. @@ -9715,7 +11575,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedFixed32Field { + struct visitPackedFixed32Field: Sendable { // 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. @@ -9727,7 +11587,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedFixed64Field { + struct visitPackedFixed64Field: Sendable { // 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. @@ -9739,7 +11599,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedFloatField { + struct visitPackedFloatField: Sendable { // 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. @@ -9751,7 +11611,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedInt32Field { + struct visitPackedInt32Field: Sendable { // 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. @@ -9763,7 +11623,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedInt64Field { + struct visitPackedInt64Field: Sendable { // 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. @@ -9775,7 +11635,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedSFixed32Field { + struct visitPackedSFixed32Field: Sendable { // 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. @@ -9787,7 +11647,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedSFixed64Field { + struct visitPackedSFixed64Field: Sendable { // 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. @@ -9799,7 +11659,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedSInt32Field { + struct visitPackedSInt32Field: Sendable { // 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. @@ -9811,7 +11671,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedSInt64Field { + struct visitPackedSInt64Field: Sendable { // 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. @@ -9823,7 +11683,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedUInt32Field { + struct visitPackedUInt32Field: Sendable { // 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. @@ -9835,7 +11695,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedUInt64Field { + struct visitPackedUInt64Field: Sendable { // 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. @@ -9847,7 +11707,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeated { + struct visitRepeated: Sendable { // 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. @@ -9859,7 +11719,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedBoolField { + struct visitRepeatedBoolField: Sendable { // 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. @@ -9871,7 +11731,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedBytesField { + struct visitRepeatedBytesField: Sendable { // 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. @@ -9883,7 +11743,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedDoubleField { + struct visitRepeatedDoubleField: Sendable { // 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. @@ -9895,7 +11755,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedEnumField { + struct visitRepeatedEnumField: Sendable { // 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. @@ -9907,7 +11767,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedFixed32Field { + struct visitRepeatedFixed32Field: Sendable { // 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. @@ -9919,7 +11779,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedFixed64Field { + struct visitRepeatedFixed64Field: Sendable { // 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. @@ -9931,7 +11791,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedFloatField { + struct visitRepeatedFloatField: Sendable { // 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. @@ -9943,7 +11803,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedGroupField { + struct visitRepeatedGroupField: Sendable { // 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. @@ -9955,7 +11815,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedInt32Field { + struct visitRepeatedInt32Field: Sendable { // 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. @@ -9967,7 +11827,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedInt64Field { + struct visitRepeatedInt64Field: Sendable { // 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. @@ -9979,7 +11839,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedMessageField { + struct visitRepeatedMessageField: Sendable { // 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. @@ -9991,7 +11851,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedSFixed32Field { + struct visitRepeatedSFixed32Field: Sendable { // 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. @@ -10003,7 +11863,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedSFixed64Field { + struct visitRepeatedSFixed64Field: Sendable { // 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. @@ -10015,7 +11875,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedSInt32Field { + struct visitRepeatedSInt32Field: Sendable { // 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. @@ -10027,7 +11887,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedSInt64Field { + struct visitRepeatedSInt64Field: Sendable { // 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. @@ -10039,7 +11899,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedStringField { + struct visitRepeatedStringField: Sendable { // 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. @@ -10051,7 +11911,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedUInt32Field { + struct visitRepeatedUInt32Field: Sendable { // 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. @@ -10063,7 +11923,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedUInt64Field { + struct visitRepeatedUInt64Field: Sendable { // 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. @@ -10075,7 +11935,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingular { + struct visitSingular: Sendable { // 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. @@ -10087,7 +11947,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularBoolField { + struct visitSingularBoolField: Sendable { // 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. @@ -10099,7 +11959,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularBytesField { + struct visitSingularBytesField: Sendable { // 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. @@ -10111,7 +11971,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularDoubleField { + struct visitSingularDoubleField: Sendable { // 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. @@ -10123,7 +11983,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularEnumField { + struct visitSingularEnumField: Sendable { // 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. @@ -10135,7 +11995,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularFixed32Field { + struct visitSingularFixed32Field: Sendable { // 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. @@ -10147,7 +12007,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularFixed64Field { + struct visitSingularFixed64Field: Sendable { // 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. @@ -10159,7 +12019,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularFloatField { + struct visitSingularFloatField: Sendable { // 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. @@ -10171,7 +12031,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularGroupField { + struct visitSingularGroupField: Sendable { // 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. @@ -10183,7 +12043,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularInt32Field { + struct visitSingularInt32Field: Sendable { // 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. @@ -10195,7 +12055,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularInt64Field { + struct visitSingularInt64Field: Sendable { // 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. @@ -10207,7 +12067,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularMessageField { + struct visitSingularMessageField: Sendable { // 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. @@ -10219,7 +12079,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularSFixed32Field { + struct visitSingularSFixed32Field: Sendable { // 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. @@ -10231,7 +12091,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularSFixed64Field { + struct visitSingularSFixed64Field: Sendable { // 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. @@ -10243,7 +12103,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularSInt32Field { + struct visitSingularSInt32Field: Sendable { // 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. @@ -10255,7 +12115,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularSInt64Field { + struct visitSingularSInt64Field: Sendable { // 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. @@ -10267,7 +12127,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularStringField { + struct visitSingularStringField: Sendable { // 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. @@ -10279,7 +12139,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularUInt32Field { + struct visitSingularUInt32Field: Sendable { // 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. @@ -10291,7 +12151,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularUInt64Field { + struct visitSingularUInt64Field: Sendable { // 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. @@ -10303,7 +12163,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitUnknown { + struct visitUnknown: Sendable { // 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. @@ -10315,7 +12175,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct wasDecoded { + struct Void: Sendable { + // 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 void: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct wasDecoded: Sendable { // 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. @@ -10327,7 +12199,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct weak { + struct weak: Sendable { // 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. @@ -10339,7 +12211,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct weakDependency { + struct weakDependency: Sendable { // 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. @@ -10351,7 +12223,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct whereMessage { + struct whereMessage: Sendable { // 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. @@ -10363,7 +12235,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct wireFormat { + struct wireFormat: Sendable { // 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. @@ -10375,7 +12247,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct with { + struct with: Sendable { // 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. @@ -10387,7 +12259,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct withUnsafeBytes { + struct withUnsafeBytes: Sendable { // 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. @@ -10399,7 +12271,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct withUnsafeMutableBytes { + struct withUnsafeMutableBytes: Sendable { // 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. @@ -10411,7 +12283,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct work { + struct work: Sendable { // 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. @@ -10423,7 +12295,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct WrappedType { + struct Wrapped: Sendable { + // 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 wrapped: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct WrappedType: Sendable { // 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. @@ -10435,7 +12319,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct written { + struct wrappedValue: Sendable { + // 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 wrappedValue: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct written: Sendable { // 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. @@ -10447,7 +12343,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct yday { + struct yday: Sendable { // 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. @@ -10462,907 +12358,62 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.adjusted: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.aggregateValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allCases: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allowAlias: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.alwaysPrintEnumsAsInts: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.annotation: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.any: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageStorage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyUnpackError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Api: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appended: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUIntHex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUnknown: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.areAllInitialized: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.array: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayDepth: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arraySeparator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiOpenCurlyBracket: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiZero: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.available: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.b: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.base64Values: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.baseAddress: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BaseType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.begin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binary: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDelimited: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetSizeVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingSizeVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binaryOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.body: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BoolMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.booleanLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BooleanLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.boolValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesInGroup: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesRead: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BytesValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.c: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.capitalizeNext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.cardinality: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccEnableArenas: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Character: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.chars: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.classMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAggregateValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAllowAlias: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearBegin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcEnableArenas: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearClientStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCsharpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCtype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDefaultValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDeprecated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDoubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearEnd: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtendee: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtensionValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearGoPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdempotencyLevel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdentifierValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearInputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIsExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGenerateEqualsAndHash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaMultipleFiles: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaOuterClassname: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaStringCheckUtf8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJsonName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJstype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLabel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLazy: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLeadingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMapEntry: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMessageSetWireFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNamePart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNegativeIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNoStandardDescriptorAccessor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearObjcClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOneofIndex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptimizeFor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOutputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPacked: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpMetadataNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPositiveIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearProto3Optional: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPyGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearRubyPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearServerStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceContext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceFile: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSwiftPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSyntax: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTrailingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTypeName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearWeak: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clientStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codePoint: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codeUnits: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Collection: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.com: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.comma: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.contentsOf: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ContiguousBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.count: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.countVarintsInBuffer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.csharpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ctype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.customCodable: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.CustomDebugStringConvertible: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.d: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DataMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dataResult: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.date: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daySec: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daysSinceEpoch: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.debugDescriptionMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoded: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodedFromJSONNull: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensionFieldsAsMessageSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeJSON: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMapField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMessageMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedBytesField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedGroupField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedStringField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingular: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularBytesField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularGroupField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularStringField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeTextFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultAnyTypeURLPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dependency: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.deprecated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.descriptionMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Dictionary: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dictionaryLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit0: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit1: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitCount: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digits: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardableResult: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardUnknownFields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.distance: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.double: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.doubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Duration: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.E: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Element: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.elements: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitExtensionFieldName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Empty: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emptyData: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeAsBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoded: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedJSONString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.end: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endArray: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endObject: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endRegularField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumReservedRange: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumvalue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Equatable: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Error: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleByArrayLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleByDictionaryLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendedGraphemeClusterLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtendedGraphemeClusterLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendee: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensibleMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionFieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionFieldValueSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionRange: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionRangeOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extras: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.F: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.falseMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldData: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldMask: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNameCount: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumberForProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldTag: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.file: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescriptorSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fileName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.filter: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.first: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.firstItem: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.float: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.floatLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forMessageName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.formUnion: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forReadingFrom: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forTypeURL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ForwardParser: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forWritingInto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.from: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii2: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii4: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromByteOffset: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromHexDigit: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.funcMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.G: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.GeneratedCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.get: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.getExtensionValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.googleapis: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Any: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Api: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_BoolValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_BytesValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_DescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_DoubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Duration: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Empty: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Enum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ExtensionRangeOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldMask: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FloatValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_GeneratedCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Int32Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Int64Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ListValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MessageOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Method: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Mixin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_NullValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Option: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceContext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_StringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Struct: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Syntax: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Timestamp: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Type: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt32Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt64Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UninterpretedOption: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.goPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.group: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupFieldNumberStack: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.h: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hadOneofValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.handleConflictingOneOf: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAggregateValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAllowAlias: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasBegin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcEnableArenas: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasClientStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCsharpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCtype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDefaultValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDeprecated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDoubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasEnd: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtendee: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtensionValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasGoPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Hashable: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasher: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hashValueMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.HashVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdempotencyLevel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdentifierValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasInputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIsExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGenerateEqualsAndHash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaMultipleFiles: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaOuterClassname: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaStringCheckUtf8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJsonName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJstype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLabel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLazy: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLeadingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMapEntry: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMessageSetWireFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNamePart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNegativeIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNoStandardDescriptorAccessor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasObjcClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOneofIndex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptimizeFor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOutputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPacked: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpMetadataNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPositiveIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasProto3Optional: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPyGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasRubyPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasServerStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceContext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceFile: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSwiftPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSyntax: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTrailingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTypeName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasWeak: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hour: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.idempotencyLevel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.identifierValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ifMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ignoreUnknownFields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.index: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.initMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inoutMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.insert: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Message: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Message: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.integerLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntegerLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.intern: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Internal: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.InternalState: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.into: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ints: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isA: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqual: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqualTo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isInitializedMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.itemTagsEncodedSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Iterator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i_2166136261: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenerateEqualsAndHash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaMultipleFiles: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaOuterClassname: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaStringCheckUtf8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonEncoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONMapEncodingVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPath: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPaths: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONScanner: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonText: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonUTF8Data: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jstype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.k: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Key: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.keyField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.KeyType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.kind: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.l: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.label: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lazy: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingDetachedComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.length: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lessThan: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.letMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lhs: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.list: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listOfMessages: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndian: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndianBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.load: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.localHasher: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.location: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.M: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.major: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.makeIterator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapEntry: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapHash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapKeyType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapNameResolver: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapToMessages: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapValueType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mdayStart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.merge: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.message: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageDepthLimit: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageImplementationBase: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageSetWireFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Method: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.methods: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.minor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Mixin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mixins: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modifier: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modify: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.month: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.msgExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mutating: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.n: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.name: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameDescription: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NamePart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nameResolver: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.names: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nanos: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeEndianBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.negativeIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nestedType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newList: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextByte: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextFieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.noStandardDescriptorAccessor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nullValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.number: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.numberValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.objcClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.of: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofDecl: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofIndex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofs: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneOf_Kind: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.optimizeFor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptimizeMode: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Option: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalEnumExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalGroupExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalMessageExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.options: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.other: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.others: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.out: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.outputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.p: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.package: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.packed: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedEnumExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.padding: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parent: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parse: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.partial: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.path: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.paths: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payload: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payloadSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpMetadataNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pos: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.positiveIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.prefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preserveProtoFieldNames: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preTraverse: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.printUnknownFields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto2: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3DefaultValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3Optional: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVersionCheck: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVersion_2: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBool: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufDouble: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufEnumMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobufExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFloat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMessageMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixed32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixed64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_extensionFieldValues: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_fieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_generated_isEqualTo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_nameMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_newField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_package: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protocolMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoFieldName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageNameMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtoNameProviding: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoPaths: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicDependency: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBoolValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBytesValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putDoubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putEnumValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFloatValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putStringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64Hex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putVarInt: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putZigZagVarInt: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pyGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rawChars: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawRepresentable: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.read4HexDigits: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.register: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedEnumExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedGroupExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedMessageExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestTypeURL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requiredSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedRange: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseTypeURL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.result: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rethrowsMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.returnMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ReturnType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.revision: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rhs: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.root: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rubyPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.s: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawBackslash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection4Characters: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection5Characters: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.scanner: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.seconds: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.selfMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.separator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serialize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedData: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serverStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.service: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.set: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.setExtensionValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.shift: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SimpleExtensionMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sizer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.source: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceContext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceEncoding: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceFile: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.span: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.split: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.start: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArray: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArrayObject: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startIndex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startObject: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startRegularField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.state: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.staticMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StaticString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.storage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringResult: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subscriptMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Swift: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.swiftPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SwiftProtobufMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.syntax: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.T: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tag: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.terminator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.testDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.text: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEncodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEncodingVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textFormatString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.throwsMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeInterval: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalSince1970: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalSinceReferenceDate: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Timestamp: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.total: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalArrayDepth: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trailingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.traverseMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trueMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tryMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.type: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typealiasMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TypeEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typePrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeStart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeUnknown: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeURL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt32Message: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt32Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Message: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalarLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalarLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalars: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalarView: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uninterpretedOption: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.union: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uniqueStorage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknown: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknownFieldsMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnknownStorage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unpackTo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeBufferPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutablePointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutableRawBufferPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutableRawPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawBufferPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.updatedOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.url: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8Ptr: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8ToDouble: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UTF8View: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.v: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.valueField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.values: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ValueType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.varMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Version: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.versionString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensionFields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensionFieldsAsMessageSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitMapField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPacked: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedBytesField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedGroupField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedStringField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularBytesField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularGroupField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularStringField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitUnknown: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wasDecoded: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weak: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weakDependency: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.whereMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wireFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.with: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeMutableBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.work: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.WrappedType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.written: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.yday: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest_generated" +fileprivate let _protobuf_package = "swift_proto_testing.generated" -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".GeneratedSwiftReservedMessages" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.addPath: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".addPath" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}addPath\0") + + 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.addPath) }() + default: break + } } } func traverse(visitor: inout V) throws { + if self.addPath != 0 { + try visitor.visitSingularInt32Field(value: self.addPath, fieldNumber: 1) + } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.addPath, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.addPath) -> Bool { + if lhs.addPath != rhs.addPath {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.adjusted: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".adjusted" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "adjusted"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.adjusted: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".adjusted" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}adjusted\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11383,18 +12434,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.adjusted: Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.adjusted, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.adjusted) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.adjusted, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.adjusted) -> Bool { if lhs.adjusted != rhs.adjusted {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.aggregateValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".aggregateValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "aggregateValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.aggregateValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".aggregateValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}aggregateValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11415,18 +12464,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.aggregateValu try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.aggregateValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.aggregateValue) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.aggregateValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.aggregateValue) -> Bool { if lhs.aggregateValue != rhs.aggregateValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allCases: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".allCases" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "allCases"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.allCases: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".allCases" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}allCases\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11447,18 +12494,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allCases: Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allCases, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allCases) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.allCases, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.allCases) -> Bool { if lhs.allCases != rhs.allCases {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allowAlias: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".allowAlias" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "allowAlias"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.allowAlias: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".allowAlias" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}allowAlias\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11479,18 +12524,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allowAlias: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allowAlias, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allowAlias) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.allowAlias, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.allowAlias) -> Bool { if lhs.allowAlias != rhs.allowAlias {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.alwaysPrintEnumsAsInts: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".alwaysPrintEnumsAsInts" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "alwaysPrintEnumsAsInts"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.alwaysPrintEnumsAsInts: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".alwaysPrintEnumsAsInts" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}alwaysPrintEnumsAsInts\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11511,18 +12554,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.alwaysPrintEn try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.alwaysPrintEnumsAsInts, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.alwaysPrintEnumsAsInts) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.alwaysPrintEnumsAsInts, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.alwaysPrintEnumsAsInts) -> Bool { if lhs.alwaysPrintEnumsAsInts != rhs.alwaysPrintEnumsAsInts {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.annotation: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".annotation" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "annotation"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.alwaysPrintInt64sAsNumbers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".alwaysPrintInt64sAsNumbers" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}alwaysPrintInt64sAsNumbers\0") + + 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.alwaysPrintInt64SAsNumbers) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.alwaysPrintInt64SAsNumbers != 0 { + try visitor.visitSingularInt32Field(value: self.alwaysPrintInt64SAsNumbers, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.alwaysPrintInt64sAsNumbers, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.alwaysPrintInt64sAsNumbers) -> Bool { + if lhs.alwaysPrintInt64SAsNumbers != rhs.alwaysPrintInt64SAsNumbers {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.annotation: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".annotation" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}annotation\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11543,18 +12614,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.annotation: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.annotation, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.annotation) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.annotation, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.annotation) -> Bool { if lhs.annotation != rhs.annotation {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.any: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".any" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "any"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.any: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".any" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}any\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11575,18 +12644,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.any: SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.any, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.any) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.any, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.any) -> Bool { if lhs.any != rhs.any {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".AnyExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "AnyExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".AnyExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}AnyExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11607,18 +12674,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyExtensionF try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyExtensionField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyExtensionField) -> Bool { if lhs.anyExtensionField != rhs.anyExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".AnyMessageExtension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "AnyMessageExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyMessageExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".AnyMessageExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}AnyMessageExtension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11639,18 +12704,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageExt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageExtension, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageExtension) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyMessageExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyMessageExtension) -> Bool { if lhs.anyMessageExtension != rhs.anyMessageExtension {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".AnyMessageStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "AnyMessageStorage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyMessageStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".AnyMessageStorage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}AnyMessageStorage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11671,18 +12734,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageSto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageStorage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyMessageStorage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyMessageStorage) -> Bool { if lhs.anyMessageStorage != rhs.anyMessageStorage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyUnpackError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".AnyUnpackError" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "AnyUnpackError"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyUnpackError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".AnyUnpackError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}AnyUnpackError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11703,18 +12764,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyUnpackErro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyUnpackError, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyUnpackError) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyUnpackError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyUnpackError) -> Bool { if lhs.anyUnpackError != rhs.anyUnpackError {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Api: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Api" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Api"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.append: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".append" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}append\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11722,31 +12781,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Api: SwiftPro // 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.api) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.append) }() default: break } } } func traverse(visitor: inout V) throws { - if self.api != 0 { - try visitor.visitSingularInt32Field(value: self.api, fieldNumber: 1) + if self.append != 0 { + try visitor.visitSingularInt32Field(value: self.append, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Api, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Api) -> Bool { - if lhs.api != rhs.api {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.append, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.append) -> Bool { + if lhs.append != rhs.append {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appended: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".appended" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "appended"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appended: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".appended" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}appended\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11767,18 +12824,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appended: Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appended, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appended) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appended, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appended) -> Bool { if lhs.appended != rhs.appended {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUIntHex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".appendUIntHex" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "appendUIntHex"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appendUIntHex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".appendUIntHex" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}appendUIntHex\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11799,18 +12854,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUIntHex try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUIntHex, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUIntHex) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appendUIntHex, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appendUIntHex) -> Bool { if lhs.appendUintHex != rhs.appendUintHex {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUnknown: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".appendUnknown" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "appendUnknown"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appendUnknown: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".appendUnknown" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}appendUnknown\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11831,18 +12884,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUnknown try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUnknown, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUnknown) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appendUnknown, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appendUnknown) -> Bool { if lhs.appendUnknown != rhs.appendUnknown {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.areAllInitialized: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".areAllInitialized" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "areAllInitialized"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.areAllInitialized: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".areAllInitialized" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}areAllInitialized\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11863,18 +12914,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.areAllInitial try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.areAllInitialized, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.areAllInitialized) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.areAllInitialized, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.areAllInitialized) -> Bool { if lhs.areAllInitialized != rhs.areAllInitialized {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.array: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".array" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "array"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Array: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Array" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Array\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11895,18 +12944,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.array: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.array, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.array) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Array, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Array) -> Bool { if lhs.array != rhs.array {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayDepth: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".arrayDepth" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "arrayDepth"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arrayDepth: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".arrayDepth" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}arrayDepth\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11927,18 +12974,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayDepth: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayDepth, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayDepth) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arrayDepth, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arrayDepth) -> Bool { if lhs.arrayDepth != rhs.arrayDepth {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".arrayLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "arrayLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arrayLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".arrayLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}arrayLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11959,18 +13004,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayLiteral: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayLiteral) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arrayLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arrayLiteral) -> Bool { if lhs.arrayLiteral != rhs.arrayLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arraySeparator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".arraySeparator" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "arraySeparator"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arraySeparator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".arraySeparator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}arraySeparator\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11991,18 +13034,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arraySeparato try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arraySeparator, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arraySeparator) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arraySeparator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arraySeparator) -> Bool { if lhs.arraySeparator != rhs.arraySeparator {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".as" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "as"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".as" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}as\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12023,18 +13064,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asMessage: Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asMessage) -> Bool { if lhs.`as` != rhs.`as` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiOpenCurlyBracket: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".asciiOpenCurlyBracket" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "asciiOpenCurlyBracket"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asciiOpenCurlyBracket: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".asciiOpenCurlyBracket" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}asciiOpenCurlyBracket\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12055,18 +13094,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiOpenCurl try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiOpenCurlyBracket, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiOpenCurlyBracket) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asciiOpenCurlyBracket, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asciiOpenCurlyBracket) -> Bool { if lhs.asciiOpenCurlyBracket != rhs.asciiOpenCurlyBracket {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiZero: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".asciiZero" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "asciiZero"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asciiZero: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".asciiZero" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}asciiZero\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12087,18 +13124,136 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiZero: Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiZero, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiZero) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asciiZero, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asciiZero) -> Bool { if lhs.asciiZero != rhs.asciiZero {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.available: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".available" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "available"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.async: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".async" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}async\0") + + 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.async) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.async != 0 { + try visitor.visitSingularInt32Field(value: self.async, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.async, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.async) -> Bool { + if lhs.async != rhs.async {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncIterator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".AsyncIterator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}AsyncIterator\0") + + 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.asyncIterator) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.asyncIterator != 0 { + try visitor.visitSingularInt32Field(value: self.asyncIterator, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncIterator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncIterator) -> Bool { + if lhs.asyncIterator != rhs.asyncIterator {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncIteratorProtocol: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".AsyncIteratorProtocol" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}AsyncIteratorProtocol\0") + + 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.asyncIteratorProtocol) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.asyncIteratorProtocol != 0 { + try visitor.visitSingularInt32Field(value: self.asyncIteratorProtocol, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncIteratorProtocol, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncIteratorProtocol) -> Bool { + if lhs.asyncIteratorProtocol != rhs.asyncIteratorProtocol {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncMessageSequence: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".AsyncMessageSequence" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}AsyncMessageSequence\0") + + 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.asyncMessageSequence) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.asyncMessageSequence != 0 { + try visitor.visitSingularInt32Field(value: self.asyncMessageSequence, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncMessageSequence, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncMessageSequence) -> Bool { + if lhs.asyncMessageSequence != rhs.asyncMessageSequence {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.available: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".available" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}available\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12119,18 +13274,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.available: Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.available, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.available) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.available, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.available) -> Bool { if lhs.available != rhs.available {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.b: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".b" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "b"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.b: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".b" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}b\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12151,18 +13304,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.b: SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.b, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.b) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.b, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.b) -> Bool { if lhs.b != rhs.b {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.base64Values: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".base64Values" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "base64Values"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Base: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Base" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Base\0") + + 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.base) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.base != 0 { + try visitor.visitSingularInt32Field(value: self.base, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Base, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Base) -> Bool { + if lhs.base != rhs.base {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.base64Values: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".base64Values" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}base64Values\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12183,18 +13364,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.base64Values: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.base64Values, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.base64Values) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.base64Values, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.base64Values) -> Bool { if lhs.base64Values != rhs.base64Values {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.baseAddress: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".baseAddress" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "baseAddress"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.baseAddress: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".baseAddress" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}baseAddress\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12215,18 +13394,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.baseAddress: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.baseAddress, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.baseAddress) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.baseAddress, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.baseAddress) -> Bool { if lhs.baseAddress != rhs.baseAddress {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BaseType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BaseType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BaseType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BaseType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BaseType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BaseType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12247,18 +13424,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BaseType: Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BaseType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BaseType) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BaseType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BaseType) -> Bool { if lhs.baseType != rhs.baseType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.begin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".begin" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "begin"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.begin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".begin" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}begin\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12279,18 +13454,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.begin: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.begin, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.begin) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.begin, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.begin) -> Bool { if lhs.begin != rhs.begin {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binary: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".binary" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "binary"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binary: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".binary" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}binary\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12311,18 +13484,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binary: Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binary, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binary) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binary, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binary) -> Bool { if lhs.binary != rhs.binary {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryDecoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryDecoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryDecoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12343,18 +13514,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecoder try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecoder) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecoder) -> Bool { if lhs.binaryDecoder != rhs.binaryDecoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryDecodingError" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryDecodingError"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryDecoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryDecoding\0") + + 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.binaryDecoding) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.binaryDecoding != 0 { + try visitor.visitSingularInt32Field(value: self.binaryDecoding, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecoding) -> Bool { + if lhs.binaryDecoding != rhs.binaryDecoding {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryDecodingError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryDecodingError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12375,18 +13574,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodin try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodingError, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodingError) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecodingError) -> Bool { if lhs.binaryDecodingError != rhs.binaryDecodingError {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryDecodingOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryDecodingOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryDecodingOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryDecodingOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12407,18 +13604,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodin try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodingOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodingOptions) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecodingOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecodingOptions) -> Bool { if lhs.binaryDecodingOptions != rhs.binaryDecodingOptions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDelimited: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryDelimited" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryDelimited"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDelimited: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryDelimited" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryDelimited\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12439,18 +13634,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDelimit try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDelimited, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDelimited) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDelimited, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDelimited) -> Bool { if lhs.binaryDelimited != rhs.binaryDelimited {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryEncoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryEncoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12471,18 +13664,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncoder try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncoder) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncoder) -> Bool { if lhs.binaryEncoder != rhs.binaryEncoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingError" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryEncodingError"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryEncodingError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12503,18 +13694,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodin try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingError, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingError) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingError) -> Bool { if lhs.binaryEncodingError != rhs.binaryEncodingError {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetSizeVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingMessageSetSizeVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryEncodingMessageSetSizeVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetSizeVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingMessageSetSizeVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryEncodingMessageSetSizeVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12535,18 +13724,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodin try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetSizeVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetSizeVisitor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetSizeVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetSizeVisitor) -> Bool { if lhs.binaryEncodingMessageSetSizeVisitor != rhs.binaryEncodingMessageSetSizeVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingMessageSetVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryEncodingMessageSetVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingMessageSetVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryEncodingMessageSetVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12567,18 +13754,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodin try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetVisitor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetVisitor) -> Bool { if lhs.binaryEncodingMessageSetVisitor != rhs.binaryEncodingMessageSetVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingSizeVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingSizeVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryEncodingSizeVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryEncodingOptions\0") + + 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.binaryEncodingOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.binaryEncodingOptions != 0 { + try visitor.visitSingularInt32Field(value: self.binaryEncodingOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingOptions) -> Bool { + if lhs.binaryEncodingOptions != rhs.binaryEncodingOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingSizeVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingSizeVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryEncodingSizeVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12599,18 +13814,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodin try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingSizeVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingSizeVisitor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingSizeVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingSizeVisitor) -> Bool { if lhs.binaryEncodingSizeVisitor != rhs.binaryEncodingSizeVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryEncodingVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryEncodingVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12631,18 +13844,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodin try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingVisitor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingVisitor) -> Bool { if lhs.binaryEncodingVisitor != rhs.binaryEncodingVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binaryOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".binaryOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "binaryOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".binaryOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}binaryOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12663,18 +13874,136 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binaryOptions try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binaryOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binaryOptions) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryOptions) -> Bool { if lhs.binaryOptions != rhs.binaryOptions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.body: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".body" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "body"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryProtobufDelimitedMessages: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".binaryProtobufDelimitedMessages" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}binaryProtobufDelimitedMessages\0") + + 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.binaryProtobufDelimitedMessages) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.binaryProtobufDelimitedMessages != 0 { + try visitor.visitSingularInt32Field(value: self.binaryProtobufDelimitedMessages, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryProtobufDelimitedMessages, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryProtobufDelimitedMessages) -> Bool { + if lhs.binaryProtobufDelimitedMessages != rhs.binaryProtobufDelimitedMessages {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryStreamDecoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryStreamDecoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryStreamDecoding\0") + + 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.binaryStreamDecoding) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.binaryStreamDecoding != 0 { + try visitor.visitSingularInt32Field(value: self.binaryStreamDecoding, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryStreamDecoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryStreamDecoding) -> Bool { + if lhs.binaryStreamDecoding != rhs.binaryStreamDecoding {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryStreamDecodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".binaryStreamDecodingError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}binaryStreamDecodingError\0") + + 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.binaryStreamDecodingError) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.binaryStreamDecodingError != 0 { + try visitor.visitSingularInt32Field(value: self.binaryStreamDecodingError, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryStreamDecodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryStreamDecodingError) -> Bool { + if lhs.binaryStreamDecodingError != rhs.binaryStreamDecodingError {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bitPattern: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".bitPattern" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bitPattern\0") + + 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.bitPattern) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.bitPattern != 0 { + try visitor.visitSingularInt32Field(value: self.bitPattern, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bitPattern, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bitPattern) -> Bool { + if lhs.bitPattern != rhs.bitPattern {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.body: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".body" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}body\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12695,18 +14024,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.body: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.body, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.body) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.body, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.body) -> Bool { if lhs.body != rhs.body {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BoolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Bool" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Bool"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BoolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Bool" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Bool\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12727,18 +14054,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BoolMessage: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BoolMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BoolMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BoolMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BoolMessage) -> Bool { if lhs.bool != rhs.bool {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.booleanLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".booleanLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "booleanLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.booleanLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".booleanLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}booleanLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12759,18 +14084,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.booleanLitera try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.booleanLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.booleanLiteral) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.booleanLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.booleanLiteral) -> Bool { if lhs.booleanLiteral != rhs.booleanLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BooleanLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BooleanLiteralType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BooleanLiteralType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BooleanLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BooleanLiteralType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BooleanLiteralType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12791,18 +14114,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BooleanLitera try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BooleanLiteralType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BooleanLiteralType) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BooleanLiteralType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BooleanLiteralType) -> Bool { if lhs.booleanLiteralType != rhs.booleanLiteralType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.boolValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".boolValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "boolValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.boolValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".boolValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}boolValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12823,18 +14144,136 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.boolValue: Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.boolValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.boolValue) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.boolValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.boolValue) -> Bool { if lhs.boolValue != rhs.boolValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".bytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.buffer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".buffer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}buffer\0") + + 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.buffer) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.buffer != 0 { + try visitor.visitSingularInt32Field(value: self.buffer, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.buffer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.buffer) -> Bool { + if lhs.buffer != rhs.buffer {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.byte: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".byte" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}byte\0") + + 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.byte) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.byte != 0 { + try visitor.visitSingularInt32Field(value: self.byte, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.byte, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.byte) -> Bool { + if lhs.byte != rhs.byte {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytecode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".bytecode" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bytecode\0") + + 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.bytecode) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.bytecode != 0 { + try visitor.visitSingularInt32Field(value: self.bytecode, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytecode, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytecode) -> Bool { + if lhs.bytecode != rhs.bytecode {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BytecodeReader: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BytecodeReader" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BytecodeReader\0") + + 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.bytecodeReader) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.bytecodeReader != 0 { + try visitor.visitSingularInt32Field(value: self.bytecodeReader, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BytecodeReader, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BytecodeReader) -> Bool { + if lhs.bytecodeReader != rhs.bytecodeReader {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".bytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12855,18 +14294,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytes: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytes, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytes) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytes) -> Bool { if lhs.bytes != rhs.bytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesInGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".bytesInGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bytesInGroup"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesInGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".bytesInGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bytesInGroup\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12887,18 +14324,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesInGroup: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesInGroup, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesInGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesInGroup, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesInGroup) -> Bool { if lhs.bytesInGroup != rhs.bytesInGroup {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesRead: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".bytesRead" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bytesRead"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesNeeded: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".bytesNeeded" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bytesNeeded\0") + + 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.bytesNeeded) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.bytesNeeded != 0 { + try visitor.visitSingularInt32Field(value: self.bytesNeeded, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesNeeded, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesNeeded) -> Bool { + if lhs.bytesNeeded != rhs.bytesNeeded {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesRead: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".bytesRead" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bytesRead\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12919,18 +14384,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesRead: Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesRead, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesRead) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesRead, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesRead) -> Bool { if lhs.bytesRead != rhs.bytesRead {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BytesValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BytesValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BytesValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.c: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".c" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12938,31 +14401,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BytesValue: S // 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.bytesValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.c) }() default: break } } } func traverse(visitor: inout V) throws { - if self.bytesValue != 0 { - try visitor.visitSingularInt32Field(value: self.bytesValue, fieldNumber: 1) + if self.c != 0 { + try visitor.visitSingularInt32Field(value: self.c, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BytesValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BytesValue) -> Bool { - if lhs.bytesValue != rhs.bytesValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.c, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.c) -> Bool { + if lhs.c != rhs.c {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.c: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".c" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.canonical: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".canonical" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}canonical\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12970,31 +14431,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.c: SwiftProto // 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.c) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.canonical) }() default: break } } } func traverse(visitor: inout V) throws { - if self.c != 0 { - try visitor.visitSingularInt32Field(value: self.c, fieldNumber: 1) + if self.canonical != 0 { + try visitor.visitSingularInt32Field(value: self.canonical, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.c, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.c) -> Bool { - if lhs.c != rhs.c {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.canonical, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.canonical) -> Bool { + if lhs.canonical != rhs.canonical {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.capitalizeNext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".capitalizeNext" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "capitalizeNext"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.capitalizeNext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".capitalizeNext" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}capitalizeNext\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13015,18 +14474,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.capitalizeNex try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.capitalizeNext, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.capitalizeNext) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.capitalizeNext, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.capitalizeNext) -> Bool { if lhs.capitalizeNext != rhs.capitalizeNext {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.cardinality: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".cardinality" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "cardinality"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.cardinality: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".cardinality" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}cardinality\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13047,18 +14504,76 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.cardinality: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.cardinality, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.cardinality) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.cardinality, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.cardinality) -> Bool { if lhs.cardinality != rhs.cardinality {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccEnableArenas: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ccEnableArenas" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ccEnableArenas"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CaseIterable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".CaseIterable" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}CaseIterable\0") + + 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.caseIterable) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.caseIterable != 0 { + try visitor.visitSingularInt32Field(value: self.caseIterable, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CaseIterable, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CaseIterable) -> Bool { + if lhs.caseIterable != rhs.caseIterable {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.castedValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".castedValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}castedValue\0") + + 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.castedValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.castedValue != 0 { + try visitor.visitSingularInt32Field(value: self.castedValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.castedValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.castedValue) -> Bool { + if lhs.castedValue != rhs.castedValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ccEnableArenas: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ccEnableArenas" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ccEnableArenas\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13079,18 +14594,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccEnableArena try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccEnableArenas, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccEnableArenas) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ccEnableArenas, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ccEnableArenas) -> Bool { if lhs.ccEnableArenas != rhs.ccEnableArenas {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ccGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ccGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ccGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ccGenericServices" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ccGenericServices\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13111,18 +14624,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccGenericServ try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccGenericServices) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ccGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ccGenericServices) -> Bool { if lhs.ccGenericServices != rhs.ccGenericServices {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Character: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Character" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Character"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Character: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Character" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Character\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13143,18 +14654,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Character: Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Character, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Character) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Character, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Character) -> Bool { if lhs.character != rhs.character {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.chars: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".chars" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "chars"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.chars: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".chars" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}chars\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13175,18 +14684,76 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.chars: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.chars, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.chars) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.chars, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.chars) -> Bool { if lhs.chars != rhs.chars {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.classMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".class" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "class"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.checkProgramFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".checkProgramFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}checkProgramFormat\0") + + 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.checkProgramFormat) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.checkProgramFormat != 0 { + try visitor.visitSingularInt32Field(value: self.checkProgramFormat, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.checkProgramFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.checkProgramFormat) -> Bool { + if lhs.checkProgramFormat != rhs.checkProgramFormat {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.chunk: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".chunk" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}chunk\0") + + 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.chunk) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.chunk != 0 { + try visitor.visitSingularInt32Field(value: self.chunk, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.chunk, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.chunk) -> Bool { + if lhs.chunk != rhs.chunk {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.classMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".class" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}class\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13207,18 +14774,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.classMessage: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.classMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.classMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.classMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.classMessage) -> Bool { if lhs.`class` != rhs.`class` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAggregateValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearAggregateValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearAggregateValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearAggregateValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearAggregateValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearAggregateValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13239,18 +14804,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAggregat try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAggregateValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAggregateValue) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearAggregateValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearAggregateValue) -> Bool { if lhs.clearAggregateValue_p != rhs.clearAggregateValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAllowAlias: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearAllowAlias" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearAllowAlias"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearAllowAlias: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearAllowAlias" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearAllowAlias\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13271,18 +14834,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAllowAli try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAllowAlias, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAllowAlias) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearAllowAlias, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearAllowAlias) -> Bool { if lhs.clearAllowAlias_p != rhs.clearAllowAlias_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearBegin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearBegin" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearBegin"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearBegin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearBegin" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearBegin\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13303,18 +14864,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearBegin: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearBegin, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearBegin) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearBegin, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearBegin) -> Bool { if lhs.clearBegin_p != rhs.clearBegin_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcEnableArenas: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearCcEnableArenas" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearCcEnableArenas"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCcEnableArenas: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearCcEnableArenas" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearCcEnableArenas\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13335,18 +14894,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcEnable try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcEnableArenas, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcEnableArenas) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCcEnableArenas, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCcEnableArenas) -> Bool { if lhs.clearCcEnableArenas_p != rhs.clearCcEnableArenas_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearCcGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearCcGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCcGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearCcGenericServices" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearCcGenericServices\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13367,18 +14924,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcGeneri try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcGenericServices) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCcGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCcGenericServices) -> Bool { if lhs.clearCcGenericServices_p != rhs.clearCcGenericServices_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearClientStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearClientStreaming" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearClientStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearClientStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearClientStreaming" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearClientStreaming\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13399,18 +14954,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearClientSt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearClientStreaming, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearClientStreaming) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearClientStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearClientStreaming) -> Bool { if lhs.clearClientStreaming_p != rhs.clearClientStreaming_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCsharpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearCsharpNamespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearCsharpNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCsharpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearCsharpNamespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearCsharpNamespace\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13431,18 +14984,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCsharpNa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCsharpNamespace, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCsharpNamespace) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCsharpNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCsharpNamespace) -> Bool { if lhs.clearCsharpNamespace_p != rhs.clearCsharpNamespace_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCtype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearCtype" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearCtype"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCtype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearCtype" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearCtype\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13463,18 +15014,76 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCtype: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCtype, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCtype) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCtype, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCtype) -> Bool { if lhs.clearCtype_p != rhs.clearCtype_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDefaultValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDefaultValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearDefaultValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDebugRedact: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDebugRedact" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearDebugRedact\0") + + 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.clearDebugRedact_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.clearDebugRedact_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearDebugRedact_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDebugRedact, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDebugRedact) -> Bool { + if lhs.clearDebugRedact_p != rhs.clearDebugRedact_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDefaultSymbolVisibility: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDefaultSymbolVisibility" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearDefaultSymbolVisibility\0") + + 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.clearDefaultSymbolVisibility_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.clearDefaultSymbolVisibility_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearDefaultSymbolVisibility_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDefaultSymbolVisibility, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDefaultSymbolVisibility) -> Bool { + if lhs.clearDefaultSymbolVisibility_p != rhs.clearDefaultSymbolVisibility_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDefaultValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDefaultValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearDefaultValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13495,18 +15104,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDefaultV try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDefaultValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDefaultValue) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDefaultValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDefaultValue) -> Bool { if lhs.clearDefaultValue_p != rhs.clearDefaultValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDeprecated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDeprecated" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearDeprecated"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDeprecated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearDeprecated\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13527,18 +15134,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDeprecat try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDeprecated, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDeprecated) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecated) -> Bool { if lhs.clearDeprecated_p != rhs.clearDeprecated_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDoubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDoubleValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearDoubleValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecatedLegacyJsonFieldConflicts: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDeprecatedLegacyJsonFieldConflicts" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearDeprecatedLegacyJsonFieldConflicts\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13546,31 +15151,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDoubleVa // 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.clearDoubleValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearDeprecatedLegacyJsonFieldConflicts_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearDoubleValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearDoubleValue_p, fieldNumber: 1) + if self.clearDeprecatedLegacyJsonFieldConflicts_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearDeprecatedLegacyJsonFieldConflicts_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDoubleValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDoubleValue) -> Bool { - if lhs.clearDoubleValue_p != rhs.clearDoubleValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecatedLegacyJsonFieldConflicts, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecatedLegacyJsonFieldConflicts) -> Bool { + if lhs.clearDeprecatedLegacyJsonFieldConflicts_p != rhs.clearDeprecatedLegacyJsonFieldConflicts_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearEnd: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearEnd" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearEnd"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecationWarning: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDeprecationWarning" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearDeprecationWarning\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13578,31 +15181,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearEnd: Swi // 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.clearEnd_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearDeprecationWarning_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearEnd_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearEnd_p, fieldNumber: 1) + if self.clearDeprecationWarning_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearDeprecationWarning_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearEnd, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearEnd) -> Bool { - if lhs.clearEnd_p != rhs.clearEnd_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecationWarning, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecationWarning) -> Bool { + if lhs.clearDeprecationWarning_p != rhs.clearDeprecationWarning_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtendee: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearExtendee" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearExtendee"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDoubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDoubleValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearDoubleValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13610,31 +15211,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtendee // 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.clearExtendee_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearDoubleValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearExtendee_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearExtendee_p, fieldNumber: 1) + if self.clearDoubleValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearDoubleValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtendee, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtendee) -> Bool { - if lhs.clearExtendee_p != rhs.clearExtendee_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDoubleValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDoubleValue) -> Bool { + if lhs.clearDoubleValue_p != rhs.clearDoubleValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtensionValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearExtensionValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearExtensionValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearEdition\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13642,31 +15241,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtensio // 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.clearExtensionValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearEdition_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearExtensionValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearExtensionValue_p, fieldNumber: 1) + if self.clearEdition_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearEdition_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtensionValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtensionValue) -> Bool { - if lhs.clearExtensionValue_p != rhs.clearExtensionValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEdition) -> Bool { + if lhs.clearEdition_p != rhs.clearEdition_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearGoPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearGoPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearGoPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditionDeprecated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearEditionDeprecated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearEditionDeprecated\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13674,31 +15271,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearGoPackag // 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.clearGoPackage_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearEditionDeprecated_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearGoPackage_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearGoPackage_p, fieldNumber: 1) + if self.clearEditionDeprecated_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearEditionDeprecated_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearGoPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearGoPackage) -> Bool { - if lhs.clearGoPackage_p != rhs.clearGoPackage_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditionDeprecated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditionDeprecated) -> Bool { + if lhs.clearEditionDeprecated_p != rhs.clearEditionDeprecated_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdempotencyLevel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearIdempotencyLevel" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearIdempotencyLevel"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditionIntroduced: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearEditionIntroduced" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearEditionIntroduced\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13706,31 +15301,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdempote // 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.clearIdempotencyLevel_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearEditionIntroduced_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearIdempotencyLevel_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearIdempotencyLevel_p, fieldNumber: 1) + if self.clearEditionIntroduced_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearEditionIntroduced_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdempotencyLevel, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdempotencyLevel) -> Bool { - if lhs.clearIdempotencyLevel_p != rhs.clearIdempotencyLevel_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditionIntroduced, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditionIntroduced) -> Bool { + if lhs.clearEditionIntroduced_p != rhs.clearEditionIntroduced_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdentifierValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearIdentifierValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearIdentifierValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditionRemoved: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearEditionRemoved" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearEditionRemoved\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13738,31 +15331,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdentifi // 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.clearIdentifierValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearEditionRemoved_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearIdentifierValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearIdentifierValue_p, fieldNumber: 1) + if self.clearEditionRemoved_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearEditionRemoved_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdentifierValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdentifierValue) -> Bool { - if lhs.clearIdentifierValue_p != rhs.clearIdentifierValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditionRemoved, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditionRemoved) -> Bool { + if lhs.clearEditionRemoved_p != rhs.clearEditionRemoved_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearInputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearInputType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearInputType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnd: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearEnd" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearEnd\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13770,31 +15361,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearInputTyp // 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.clearInputType_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearEnd_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearInputType_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearInputType_p, fieldNumber: 1) + if self.clearEnd_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearEnd_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearInputType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearInputType) -> Bool { - if lhs.clearInputType_p != rhs.clearInputType_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnd, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnd) -> Bool { + if lhs.clearEnd_p != rhs.clearEnd_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIsExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearIsExtension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearIsExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnforceNamingStyle: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearEnforceNamingStyle" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearEnforceNamingStyle\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13802,31 +15391,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIsExtens // 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.clearIsExtension_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearEnforceNamingStyle_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearIsExtension_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearIsExtension_p, fieldNumber: 1) + if self.clearEnforceNamingStyle_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearEnforceNamingStyle_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIsExtension, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIsExtension) -> Bool { - if lhs.clearIsExtension_p != rhs.clearIsExtension_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnforceNamingStyle, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnforceNamingStyle) -> Bool { + if lhs.clearEnforceNamingStyle_p != rhs.clearEnforceNamingStyle_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGenerateEqualsAndHash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaGenerateEqualsAndHash" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearJavaGenerateEqualsAndHash"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnumType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearEnumType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearEnumType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13834,31 +15421,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGene // 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.clearJavaGenerateEqualsAndHash_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearEnumType_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearJavaGenerateEqualsAndHash_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearJavaGenerateEqualsAndHash_p, fieldNumber: 1) + if self.clearEnumType_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearEnumType_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGenerateEqualsAndHash, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGenerateEqualsAndHash) -> Bool { - if lhs.clearJavaGenerateEqualsAndHash_p != rhs.clearJavaGenerateEqualsAndHash_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnumType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnumType) -> Bool { + if lhs.clearEnumType_p != rhs.clearEnumType_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearJavaGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearExtendee: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearExtendee" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearExtendee\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13866,31 +15451,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGene // 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.clearJavaGenericServices_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearExtendee_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearJavaGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearJavaGenericServices_p, fieldNumber: 1) + if self.clearExtendee_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearExtendee_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGenericServices) -> Bool { - if lhs.clearJavaGenericServices_p != rhs.clearJavaGenericServices_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearExtendee, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearExtendee) -> Bool { + if lhs.clearExtendee_p != rhs.clearExtendee_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaMultipleFiles: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaMultipleFiles" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearJavaMultipleFiles"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearExtensionValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearExtensionValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearExtensionValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13898,31 +15481,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaMult // 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.clearJavaMultipleFiles_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearExtensionValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearJavaMultipleFiles_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearJavaMultipleFiles_p, fieldNumber: 1) + if self.clearExtensionValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearExtensionValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaMultipleFiles, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaMultipleFiles) -> Bool { - if lhs.clearJavaMultipleFiles_p != rhs.clearJavaMultipleFiles_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearExtensionValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearExtensionValue) -> Bool { + if lhs.clearExtensionValue_p != rhs.clearExtensionValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaOuterClassname: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaOuterClassname" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearJavaOuterClassname"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearFeatures\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13930,31 +15511,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaOute // 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.clearJavaOuterClassname_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearFeatures_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearJavaOuterClassname_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearJavaOuterClassname_p, fieldNumber: 1) + if self.clearFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearFeatures_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaOuterClassname, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaOuterClassname) -> Bool { - if lhs.clearJavaOuterClassname_p != rhs.clearJavaOuterClassname_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFeatures, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFeatures) -> Bool { + if lhs.clearFeatures_p != rhs.clearFeatures_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearJavaPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFeatureSupport: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearFeatureSupport" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearFeatureSupport\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13962,31 +15541,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaPack // 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.clearJavaPackage_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearFeatureSupport_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearJavaPackage_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearJavaPackage_p, fieldNumber: 1) + if self.clearFeatureSupport_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearFeatureSupport_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaPackage) -> Bool { - if lhs.clearJavaPackage_p != rhs.clearJavaPackage_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFeatureSupport, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFeatureSupport) -> Bool { + if lhs.clearFeatureSupport_p != rhs.clearFeatureSupport_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaStringCheckUtf8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaStringCheckUtf8" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearJavaStringCheckUtf8"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFieldPresence: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearFieldPresence" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearFieldPresence\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13994,31 +15571,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaStri // 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.clearJavaStringCheckUtf8_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearFieldPresence_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearJavaStringCheckUtf8_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearJavaStringCheckUtf8_p, fieldNumber: 1) + if self.clearFieldPresence_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearFieldPresence_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaStringCheckUtf8, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaStringCheckUtf8) -> Bool { - if lhs.clearJavaStringCheckUtf8_p != rhs.clearJavaStringCheckUtf8_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFieldPresence, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFieldPresence) -> Bool { + if lhs.clearFieldPresence_p != rhs.clearFieldPresence_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJsonName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJsonName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearJsonName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFixedFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearFixedFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearFixedFeatures\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14026,31 +15601,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJsonName // 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.clearJsonName_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearFixedFeatures_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearJsonName_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearJsonName_p, fieldNumber: 1) + if self.clearFixedFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearFixedFeatures_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJsonName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJsonName) -> Bool { - if lhs.clearJsonName_p != rhs.clearJsonName_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFixedFeatures, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFixedFeatures) -> Bool { + if lhs.clearFixedFeatures_p != rhs.clearFixedFeatures_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJstype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJstype" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearJstype"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFullName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearFullName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearFullName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14058,31 +15631,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJstype: // 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.clearJstype_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearFullName_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearJstype_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearJstype_p, fieldNumber: 1) + if self.clearFullName_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearFullName_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJstype, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJstype) -> Bool { - if lhs.clearJstype_p != rhs.clearJstype_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFullName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFullName) -> Bool { + if lhs.clearFullName_p != rhs.clearFullName_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLabel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearLabel" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearLabel"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearGoPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearGoPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearGoPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14090,31 +15661,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLabel: S // 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.clearLabel_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearGoPackage_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearLabel_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearLabel_p, fieldNumber: 1) + if self.clearGoPackage_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearGoPackage_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLabel, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLabel) -> Bool { - if lhs.clearLabel_p != rhs.clearLabel_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearGoPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearGoPackage) -> Bool { + if lhs.clearGoPackage_p != rhs.clearGoPackage_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearLazy" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearLazy"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIdempotencyLevel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearIdempotencyLevel" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearIdempotencyLevel\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14122,31 +15691,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLazy: Sw // 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.clearLazy_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearIdempotencyLevel_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearLazy_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearLazy_p, fieldNumber: 1) + if self.clearIdempotencyLevel_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearIdempotencyLevel_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLazy, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLazy) -> Bool { - if lhs.clearLazy_p != rhs.clearLazy_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIdempotencyLevel, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIdempotencyLevel) -> Bool { + if lhs.clearIdempotencyLevel_p != rhs.clearIdempotencyLevel_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLeadingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearLeadingComments" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearLeadingComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIdentifierValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearIdentifierValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearIdentifierValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14154,31 +15721,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLeadingC // 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.clearLeadingComments_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearIdentifierValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearLeadingComments_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearLeadingComments_p, fieldNumber: 1) + if self.clearIdentifierValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearIdentifierValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLeadingComments, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLeadingComments) -> Bool { - if lhs.clearLeadingComments_p != rhs.clearLeadingComments_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIdentifierValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIdentifierValue) -> Bool { + if lhs.clearIdentifierValue_p != rhs.clearIdentifierValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMapEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearMapEntry" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearMapEntry"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearInputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearInputType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearInputType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14186,31 +15751,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMapEntry // 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.clearMapEntry_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearInputType_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearMapEntry_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearMapEntry_p, fieldNumber: 1) + if self.clearInputType_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearInputType_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMapEntry, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMapEntry) -> Bool { - if lhs.clearMapEntry_p != rhs.clearMapEntry_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearInputType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearInputType) -> Bool { + if lhs.clearInputType_p != rhs.clearInputType_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMessageSetWireFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearMessageSetWireFormat" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearMessageSetWireFormat"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIsExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearIsExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearIsExtension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14218,31 +15781,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMessageS // 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.clearMessageSetWireFormat_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearIsExtension_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearMessageSetWireFormat_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearMessageSetWireFormat_p, fieldNumber: 1) + if self.clearIsExtension_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearIsExtension_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMessageSetWireFormat, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMessageSetWireFormat) -> Bool { - if lhs.clearMessageSetWireFormat_p != rhs.clearMessageSetWireFormat_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIsExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIsExtension) -> Bool { + if lhs.clearIsExtension_p != rhs.clearIsExtension_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaGenerateEqualsAndHash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaGenerateEqualsAndHash" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearJavaGenerateEqualsAndHash\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14250,31 +15811,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearName: Sw // 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.clearName_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearJavaGenerateEqualsAndHash_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearName_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearName_p, fieldNumber: 1) + if self.clearJavaGenerateEqualsAndHash_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearJavaGenerateEqualsAndHash_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearName) -> Bool { - if lhs.clearName_p != rhs.clearName_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaGenerateEqualsAndHash, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaGenerateEqualsAndHash) -> Bool { + if lhs.clearJavaGenerateEqualsAndHash_p != rhs.clearJavaGenerateEqualsAndHash_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNamePart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearNamePart" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearNamePart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaGenericServices" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearJavaGenericServices\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14282,31 +15841,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNamePart // 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.clearNamePart_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearJavaGenericServices_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearNamePart_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearNamePart_p, fieldNumber: 1) + if self.clearJavaGenericServices_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearJavaGenericServices_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNamePart, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNamePart) -> Bool { - if lhs.clearNamePart_p != rhs.clearNamePart_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaGenericServices) -> Bool { + if lhs.clearJavaGenericServices_p != rhs.clearJavaGenericServices_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNegativeIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearNegativeIntValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearNegativeIntValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaMultipleFiles: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaMultipleFiles" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearJavaMultipleFiles\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14314,31 +15871,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNegative // 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.clearNegativeIntValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearJavaMultipleFiles_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearNegativeIntValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearNegativeIntValue_p, fieldNumber: 1) + if self.clearJavaMultipleFiles_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearJavaMultipleFiles_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNegativeIntValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNegativeIntValue) -> Bool { - if lhs.clearNegativeIntValue_p != rhs.clearNegativeIntValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaMultipleFiles, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaMultipleFiles) -> Bool { + if lhs.clearJavaMultipleFiles_p != rhs.clearJavaMultipleFiles_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNoStandardDescriptorAccessor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearNoStandardDescriptorAccessor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearNoStandardDescriptorAccessor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaOuterClassname: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaOuterClassname" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearJavaOuterClassname\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14346,31 +15901,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNoStanda // 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.clearNoStandardDescriptorAccessor_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearJavaOuterClassname_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearNoStandardDescriptorAccessor_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearNoStandardDescriptorAccessor_p, fieldNumber: 1) + if self.clearJavaOuterClassname_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearJavaOuterClassname_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNoStandardDescriptorAccessor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNoStandardDescriptorAccessor) -> Bool { - if lhs.clearNoStandardDescriptorAccessor_p != rhs.clearNoStandardDescriptorAccessor_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaOuterClassname, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaOuterClassname) -> Bool { + if lhs.clearJavaOuterClassname_p != rhs.clearJavaOuterClassname_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearJavaPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14378,31 +15931,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNumber: // 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.clearNumber_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearJavaPackage_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearNumber_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearNumber_p, fieldNumber: 1) + if self.clearJavaPackage_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearJavaPackage_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNumber, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNumber) -> Bool { - if lhs.clearNumber_p != rhs.clearNumber_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaPackage) -> Bool { + if lhs.clearJavaPackage_p != rhs.clearJavaPackage_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearObjcClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearObjcClassPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearObjcClassPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaStringCheckUtf8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaStringCheckUtf8" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearJavaStringCheckUtf8\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14410,31 +15961,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearObjcClas // 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.clearObjcClassPrefix_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearJavaStringCheckUtf8_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearObjcClassPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearObjcClassPrefix_p, fieldNumber: 1) + if self.clearJavaStringCheckUtf8_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearJavaStringCheckUtf8_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearObjcClassPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearObjcClassPrefix) -> Bool { - if lhs.clearObjcClassPrefix_p != rhs.clearObjcClassPrefix_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaStringCheckUtf8, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaStringCheckUtf8) -> Bool { + if lhs.clearJavaStringCheckUtf8_p != rhs.clearJavaStringCheckUtf8_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOneofIndex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearOneofIndex" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearOneofIndex"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJsonFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJsonFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearJsonFormat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14442,31 +15991,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOneofInd // 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.clearOneofIndex_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearJsonFormat_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearOneofIndex_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearOneofIndex_p, fieldNumber: 1) + if self.clearJsonFormat_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearJsonFormat_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOneofIndex, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOneofIndex) -> Bool { - if lhs.clearOneofIndex_p != rhs.clearOneofIndex_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJsonFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJsonFormat) -> Bool { + if lhs.clearJsonFormat_p != rhs.clearJsonFormat_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptimizeFor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearOptimizeFor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearOptimizeFor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJsonName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJsonName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearJsonName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14474,31 +16021,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptimize // 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.clearOptimizeFor_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearJsonName_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearOptimizeFor_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearOptimizeFor_p, fieldNumber: 1) + if self.clearJsonName_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearJsonName_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptimizeFor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptimizeFor) -> Bool { - if lhs.clearOptimizeFor_p != rhs.clearOptimizeFor_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJsonName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJsonName) -> Bool { + if lhs.clearJsonName_p != rhs.clearJsonName_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJstype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJstype" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearJstype\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14506,31 +16051,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptions: // 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.clearOptions_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearJstype_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearOptions_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearOptions_p, fieldNumber: 1) + if self.clearJstype_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearJstype_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptions) -> Bool { - if lhs.clearOptions_p != rhs.clearOptions_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJstype, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJstype) -> Bool { + if lhs.clearJstype_p != rhs.clearJstype_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOutputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearOutputType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearOutputType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLabel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearLabel" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearLabel\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14538,31 +16081,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOutputTy // 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.clearOutputType_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearLabel_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearOutputType_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearOutputType_p, fieldNumber: 1) + if self.clearLabel_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearLabel_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOutputType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOutputType) -> Bool { - if lhs.clearOutputType_p != rhs.clearOutputType_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLabel, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLabel) -> Bool { + if lhs.clearLabel_p != rhs.clearLabel_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearLazy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearLazy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14570,31 +16111,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPackage: // 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.clearPackage_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearLazy_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearPackage_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearPackage_p, fieldNumber: 1) + if self.clearLazy_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearLazy_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPackage) -> Bool { - if lhs.clearPackage_p != rhs.clearPackage_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLazy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLazy) -> Bool { + if lhs.clearLazy_p != rhs.clearLazy_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPacked: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPacked" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearPacked"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLeadingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearLeadingComments" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearLeadingComments\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14602,31 +16141,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPacked: // 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.clearPacked_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearLeadingComments_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearPacked_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearPacked_p, fieldNumber: 1) + if self.clearLeadingComments_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearLeadingComments_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPacked, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPacked) -> Bool { - if lhs.clearPacked_p != rhs.clearPacked_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLeadingComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLeadingComments) -> Bool { + if lhs.clearLeadingComments_p != rhs.clearLeadingComments_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPhpClassPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearPhpClassPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMapEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearMapEntry" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearMapEntry\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14634,31 +16171,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpClass // 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.clearPhpClassPrefix_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearMapEntry_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearPhpClassPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearPhpClassPrefix_p, fieldNumber: 1) + if self.clearMapEntry_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearMapEntry_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpClassPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpClassPrefix) -> Bool { - if lhs.clearPhpClassPrefix_p != rhs.clearPhpClassPrefix_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMapEntry, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMapEntry) -> Bool { + if lhs.clearMapEntry_p != rhs.clearMapEntry_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPhpGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearPhpGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMaximumEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearMaximumEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearMaximumEdition\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14666,31 +16201,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpGener // 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.clearPhpGenericServices_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearMaximumEdition_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearPhpGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearPhpGenericServices_p, fieldNumber: 1) + if self.clearMaximumEdition_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearMaximumEdition_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpGenericServices) -> Bool { - if lhs.clearPhpGenericServices_p != rhs.clearPhpGenericServices_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMaximumEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMaximumEdition) -> Bool { + if lhs.clearMaximumEdition_p != rhs.clearMaximumEdition_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpMetadataNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPhpMetadataNamespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearPhpMetadataNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMessageEncoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearMessageEncoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearMessageEncoding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14698,31 +16231,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpMetad // 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.clearPhpMetadataNamespace_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearMessageEncoding_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearPhpMetadataNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearPhpMetadataNamespace_p, fieldNumber: 1) + if self.clearMessageEncoding_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearMessageEncoding_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpMetadataNamespace, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpMetadataNamespace) -> Bool { - if lhs.clearPhpMetadataNamespace_p != rhs.clearPhpMetadataNamespace_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMessageEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMessageEncoding) -> Bool { + if lhs.clearMessageEncoding_p != rhs.clearMessageEncoding_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPhpNamespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearPhpNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMessageSetWireFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearMessageSetWireFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearMessageSetWireFormat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14730,31 +16261,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpNames // 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.clearPhpNamespace_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearMessageSetWireFormat_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearPhpNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearPhpNamespace_p, fieldNumber: 1) + if self.clearMessageSetWireFormat_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearMessageSetWireFormat_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpNamespace, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpNamespace) -> Bool { - if lhs.clearPhpNamespace_p != rhs.clearPhpNamespace_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMessageSetWireFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMessageSetWireFormat) -> Bool { + if lhs.clearMessageSetWireFormat_p != rhs.clearMessageSetWireFormat_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPositiveIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPositiveIntValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearPositiveIntValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMinimumEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearMinimumEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearMinimumEdition\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14762,31 +16291,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPositive // 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.clearPositiveIntValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearMinimumEdition_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearPositiveIntValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearPositiveIntValue_p, fieldNumber: 1) + if self.clearMinimumEdition_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearMinimumEdition_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPositiveIntValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPositiveIntValue) -> Bool { - if lhs.clearPositiveIntValue_p != rhs.clearPositiveIntValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMinimumEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMinimumEdition) -> Bool { + if lhs.clearMinimumEdition_p != rhs.clearMinimumEdition_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearProto3Optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearProto3Optional" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearProto3Optional"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14794,31 +16321,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearProto3Op // 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.clearProto3Optional_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearName_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearProto3Optional_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearProto3Optional_p, fieldNumber: 1) + if self.clearName_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearName_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearProto3Optional, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearProto3Optional) -> Bool { - if lhs.clearProto3Optional_p != rhs.clearProto3Optional_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearName) -> Bool { + if lhs.clearName_p != rhs.clearName_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPyGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPyGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearPyGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNamePart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearNamePart" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearNamePart\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14826,31 +16351,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPyGeneri // 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.clearPyGenericServices_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearNamePart_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearPyGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearPyGenericServices_p, fieldNumber: 1) + if self.clearNamePart_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearNamePart_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPyGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPyGenericServices) -> Bool { - if lhs.clearPyGenericServices_p != rhs.clearPyGenericServices_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNamePart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNamePart) -> Bool { + if lhs.clearNamePart_p != rhs.clearNamePart_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearRubyPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearRubyPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearRubyPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNegativeIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearNegativeIntValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearNegativeIntValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14858,31 +16381,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearRubyPack // 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.clearRubyPackage_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearNegativeIntValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearRubyPackage_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearRubyPackage_p, fieldNumber: 1) + if self.clearNegativeIntValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearNegativeIntValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearRubyPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearRubyPackage) -> Bool { - if lhs.clearRubyPackage_p != rhs.clearRubyPackage_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNegativeIntValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNegativeIntValue) -> Bool { + if lhs.clearNegativeIntValue_p != rhs.clearNegativeIntValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearServerStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearServerStreaming" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearServerStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNoStandardDescriptorAccessor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearNoStandardDescriptorAccessor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearNoStandardDescriptorAccessor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14890,31 +16411,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearServerSt // 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.clearServerStreaming_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearNoStandardDescriptorAccessor_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearServerStreaming_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearServerStreaming_p, fieldNumber: 1) + if self.clearNoStandardDescriptorAccessor_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearNoStandardDescriptorAccessor_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearServerStreaming, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearServerStreaming) -> Bool { - if lhs.clearServerStreaming_p != rhs.clearServerStreaming_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNoStandardDescriptorAccessor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNoStandardDescriptorAccessor) -> Bool { + if lhs.clearNoStandardDescriptorAccessor_p != rhs.clearNoStandardDescriptorAccessor_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSourceCodeInfo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearSourceCodeInfo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearNumber\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14922,31 +16441,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceCo // 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.clearSourceCodeInfo_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearNumber_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearSourceCodeInfo_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearSourceCodeInfo_p, fieldNumber: 1) + if self.clearNumber_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearNumber_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceCodeInfo, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceCodeInfo) -> Bool { - if lhs.clearSourceCodeInfo_p != rhs.clearSourceCodeInfo_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNumber) -> Bool { + if lhs.clearNumber_p != rhs.clearNumber_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceContext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSourceContext" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearSourceContext"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearObjcClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearObjcClassPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearObjcClassPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14954,31 +16471,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceCo // 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.clearSourceContext_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearObjcClassPrefix_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearSourceContext_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearSourceContext_p, fieldNumber: 1) + if self.clearObjcClassPrefix_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearObjcClassPrefix_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceContext, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceContext) -> Bool { - if lhs.clearSourceContext_p != rhs.clearSourceContext_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearObjcClassPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearObjcClassPrefix) -> Bool { + if lhs.clearObjcClassPrefix_p != rhs.clearObjcClassPrefix_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceFile: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSourceFile" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearSourceFile"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOneofIndex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearOneofIndex" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearOneofIndex\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14986,31 +16501,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceFi // 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.clearSourceFile_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearOneofIndex_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearSourceFile_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearSourceFile_p, fieldNumber: 1) + if self.clearOneofIndex_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearOneofIndex_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceFile, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceFile) -> Bool { - if lhs.clearSourceFile_p != rhs.clearSourceFile_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOneofIndex, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOneofIndex) -> Bool { + if lhs.clearOneofIndex_p != rhs.clearOneofIndex_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearStart" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearStart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOptimizeFor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearOptimizeFor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearOptimizeFor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15018,31 +16531,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStart: S // 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.clearStart_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearOptimizeFor_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearStart_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearStart_p, fieldNumber: 1) + if self.clearOptimizeFor_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearOptimizeFor_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStart, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStart) -> Bool { - if lhs.clearStart_p != rhs.clearStart_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOptimizeFor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOptimizeFor) -> Bool { + if lhs.clearOptimizeFor_p != rhs.clearOptimizeFor_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearStringValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearStringValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15050,31 +16561,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStringVa // 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.clearStringValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearOptions_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearStringValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearStringValue_p, fieldNumber: 1) + if self.clearOptions_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearOptions_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStringValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStringValue) -> Bool { - if lhs.clearStringValue_p != rhs.clearStringValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOptions) -> Bool { + if lhs.clearOptions_p != rhs.clearOptions_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSwiftPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSwiftPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearSwiftPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOutputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearOutputType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearOutputType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15082,31 +16591,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSwiftPre // 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.clearSwiftPrefix_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearOutputType_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearSwiftPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearSwiftPrefix_p, fieldNumber: 1) + if self.clearOutputType_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearOutputType_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSwiftPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSwiftPrefix) -> Bool { - if lhs.clearSwiftPrefix_p != rhs.clearSwiftPrefix_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOutputType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOutputType) -> Bool { + if lhs.clearOutputType_p != rhs.clearOutputType_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSyntax: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSyntax" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearSyntax"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOverridableFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearOverridableFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearOverridableFeatures\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15114,31 +16621,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSyntax: // 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.clearSyntax_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearOverridableFeatures_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearSyntax_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearSyntax_p, fieldNumber: 1) + if self.clearOverridableFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearOverridableFeatures_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSyntax, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSyntax) -> Bool { - if lhs.clearSyntax_p != rhs.clearSyntax_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOverridableFeatures, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOverridableFeatures) -> Bool { + if lhs.clearOverridableFeatures_p != rhs.clearOverridableFeatures_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTrailingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearTrailingComments" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearTrailingComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15146,31 +16651,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTrailing // 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.clearTrailingComments_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearPackage_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearTrailingComments_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearTrailingComments_p, fieldNumber: 1) + if self.clearPackage_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearPackage_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTrailingComments, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTrailingComments) -> Bool { - if lhs.clearTrailingComments_p != rhs.clearTrailingComments_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPackage) -> Bool { + if lhs.clearPackage_p != rhs.clearPackage_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPacked: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPacked" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearPacked\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15178,31 +16681,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearType: Sw // 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.clearType_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearPacked_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearType_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearType_p, fieldNumber: 1) + if self.clearPacked_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearPacked_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearType) -> Bool { - if lhs.clearType_p != rhs.clearType_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPacked, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPacked) -> Bool { + if lhs.clearPacked_p != rhs.clearPacked_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTypeName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearTypeName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearTypeName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPhpClassPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearPhpClassPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15210,31 +16711,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTypeName // 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.clearTypeName_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearPhpClassPrefix_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearTypeName_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearTypeName_p, fieldNumber: 1) + if self.clearPhpClassPrefix_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearPhpClassPrefix_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTypeName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTypeName) -> Bool { - if lhs.clearTypeName_p != rhs.clearTypeName_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpClassPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpClassPrefix) -> Bool { + if lhs.clearPhpClassPrefix_p != rhs.clearPhpClassPrefix_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpMetadataNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPhpMetadataNamespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearPhpMetadataNamespace\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15242,31 +16741,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearValue: S // 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.clearValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearPhpMetadataNamespace_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearValue_p, fieldNumber: 1) + if self.clearPhpMetadataNamespace_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearPhpMetadataNamespace_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearValue) -> Bool { - if lhs.clearValue_p != rhs.clearValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpMetadataNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpMetadataNamespace) -> Bool { + if lhs.clearPhpMetadataNamespace_p != rhs.clearPhpMetadataNamespace_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearWeak: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearWeak" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearWeak"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPhpNamespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearPhpNamespace\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15274,31 +16771,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearWeak: Sw // 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.clearWeak_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearPhpNamespace_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearWeak_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearWeak_p, fieldNumber: 1) + if self.clearPhpNamespace_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearPhpNamespace_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearWeak, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearWeak) -> Bool { - if lhs.clearWeak_p != rhs.clearWeak_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpNamespace) -> Bool { + if lhs.clearPhpNamespace_p != rhs.clearPhpNamespace_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clientStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clientStreaming" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clientStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPositiveIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPositiveIntValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearPositiveIntValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15306,31 +16801,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clientStreami // 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.clientStreaming) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearPositiveIntValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clientStreaming != 0 { - try visitor.visitSingularInt32Field(value: self.clientStreaming, fieldNumber: 1) + if self.clearPositiveIntValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearPositiveIntValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clientStreaming, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clientStreaming) -> Bool { - if lhs.clientStreaming != rhs.clientStreaming {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPositiveIntValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPositiveIntValue) -> Bool { + if lhs.clearPositiveIntValue_p != rhs.clearPositiveIntValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codePoint: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".codePoint" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "codePoint"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearProto3Optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearProto3Optional" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearProto3Optional\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15338,31 +16831,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codePoint: Sw // 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.codePoint) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearProto3Optional_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.codePoint != 0 { - try visitor.visitSingularInt32Field(value: self.codePoint, fieldNumber: 1) + if self.clearProto3Optional_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearProto3Optional_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codePoint, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codePoint) -> Bool { - if lhs.codePoint != rhs.codePoint {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearProto3Optional, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearProto3Optional) -> Bool { + if lhs.clearProto3Optional_p != rhs.clearProto3Optional_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codeUnits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".codeUnits" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "codeUnits"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPyGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPyGenericServices" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearPyGenericServices\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15370,31 +16861,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codeUnits: Sw // 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.codeUnits) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearPyGenericServices_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.codeUnits != 0 { - try visitor.visitSingularInt32Field(value: self.codeUnits, fieldNumber: 1) + if self.clearPyGenericServices_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearPyGenericServices_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codeUnits, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codeUnits) -> Bool { - if lhs.codeUnits != rhs.codeUnits {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPyGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPyGenericServices) -> Bool { + if lhs.clearPyGenericServices_p != rhs.clearPyGenericServices_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Collection: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Collection" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Collection"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRemovalError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearRemovalError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearRemovalError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15402,31 +16891,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Collection: S // 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.collection) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearRemovalError_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.collection != 0 { - try visitor.visitSingularInt32Field(value: self.collection, fieldNumber: 1) + if self.clearRemovalError_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearRemovalError_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Collection, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Collection) -> Bool { - if lhs.collection != rhs.collection {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRemovalError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRemovalError) -> Bool { + if lhs.clearRemovalError_p != rhs.clearRemovalError_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.com: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".com" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "com"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRepeated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearRepeated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearRepeated\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15434,31 +16921,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.com: SwiftPro // 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.com) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearRepeated_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.com != 0 { - try visitor.visitSingularInt32Field(value: self.com, fieldNumber: 1) + if self.clearRepeated_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearRepeated_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.com, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.com) -> Bool { - if lhs.com != rhs.com {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRepeated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRepeated) -> Bool { + if lhs.clearRepeated_p != rhs.clearRepeated_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.comma: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".comma" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "comma"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRepeatedFieldEncoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearRepeatedFieldEncoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearRepeatedFieldEncoding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15466,31 +16951,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.comma: SwiftP // 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.comma) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearRepeatedFieldEncoding_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.comma != 0 { - try visitor.visitSingularInt32Field(value: self.comma, fieldNumber: 1) + if self.clearRepeatedFieldEncoding_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearRepeatedFieldEncoding_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.comma, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.comma) -> Bool { - if lhs.comma != rhs.comma {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRepeatedFieldEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRepeatedFieldEncoding) -> Bool { + if lhs.clearRepeatedFieldEncoding_p != rhs.clearRepeatedFieldEncoding_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.contentsOf: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".contentsOf" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "contentsOf"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearReserved: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearReserved" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearReserved\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15498,31 +16981,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.contentsOf: S // 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.contentsOf) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearReserved_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.contentsOf != 0 { - try visitor.visitSingularInt32Field(value: self.contentsOf, fieldNumber: 1) + if self.clearReserved_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearReserved_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.contentsOf, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.contentsOf) -> Bool { - if lhs.contentsOf != rhs.contentsOf {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearReserved, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearReserved) -> Bool { + if lhs.clearReserved_p != rhs.clearReserved_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ContiguousBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ContiguousBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ContiguousBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRetention: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearRetention" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearRetention\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15530,31 +17011,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ContiguousByt // 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.contiguousBytes) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearRetention_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.contiguousBytes != 0 { - try visitor.visitSingularInt32Field(value: self.contiguousBytes, fieldNumber: 1) + if self.clearRetention_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearRetention_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ContiguousBytes, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ContiguousBytes) -> Bool { - if lhs.contiguousBytes != rhs.contiguousBytes {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRetention, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRetention) -> Bool { + if lhs.clearRetention_p != rhs.clearRetention_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.count: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".count" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "count"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRubyPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearRubyPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearRubyPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15562,31 +17041,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.count: SwiftP // 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.count) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearRubyPackage_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.count != 0 { - try visitor.visitSingularInt32Field(value: self.count, fieldNumber: 1) + if self.clearRubyPackage_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearRubyPackage_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.count, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.count) -> Bool { - if lhs.count != rhs.count {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRubyPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRubyPackage) -> Bool { + if lhs.clearRubyPackage_p != rhs.clearRubyPackage_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.countVarintsInBuffer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".countVarintsInBuffer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "countVarintsInBuffer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSemantic: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSemantic" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearSemantic\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15594,31 +17071,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.countVarintsI // 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.countVarintsInBuffer) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearSemantic_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.countVarintsInBuffer != 0 { - try visitor.visitSingularInt32Field(value: self.countVarintsInBuffer, fieldNumber: 1) + if self.clearSemantic_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearSemantic_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.countVarintsInBuffer, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.countVarintsInBuffer) -> Bool { - if lhs.countVarintsInBuffer != rhs.countVarintsInBuffer {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSemantic, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSemantic) -> Bool { + if lhs.clearSemantic_p != rhs.clearSemantic_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.csharpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".csharpNamespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "csharpNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearServerStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearServerStreaming" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearServerStreaming\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15626,31 +17101,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.csharpNamespa // 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.csharpNamespace) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearServerStreaming_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.csharpNamespace != 0 { - try visitor.visitSingularInt32Field(value: self.csharpNamespace, fieldNumber: 1) + if self.clearServerStreaming_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearServerStreaming_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.csharpNamespace, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.csharpNamespace) -> Bool { - if lhs.csharpNamespace != rhs.csharpNamespace {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearServerStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearServerStreaming) -> Bool { + if lhs.clearServerStreaming_p != rhs.clearServerStreaming_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ctype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ctype" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ctype"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSourceCodeInfo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearSourceCodeInfo\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15658,31 +17131,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ctype: SwiftP // 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.ctype) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearSourceCodeInfo_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.ctype != 0 { - try visitor.visitSingularInt32Field(value: self.ctype, fieldNumber: 1) + if self.clearSourceCodeInfo_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearSourceCodeInfo_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ctype, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ctype) -> Bool { - if lhs.ctype != rhs.ctype {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceCodeInfo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceCodeInfo) -> Bool { + if lhs.clearSourceCodeInfo_p != rhs.clearSourceCodeInfo_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.customCodable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".customCodable" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "customCodable"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceContext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSourceContext" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearSourceContext\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15690,31 +17161,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.customCodable // 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.customCodable) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearSourceContext_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.customCodable != 0 { - try visitor.visitSingularInt32Field(value: self.customCodable, fieldNumber: 1) + if self.clearSourceContext_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearSourceContext_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.customCodable, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.customCodable) -> Bool { - if lhs.customCodable != rhs.customCodable {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceContext, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceContext) -> Bool { + if lhs.clearSourceContext_p != rhs.clearSourceContext_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.CustomDebugStringConvertible: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".CustomDebugStringConvertible" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "CustomDebugStringConvertible"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceFile: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSourceFile" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearSourceFile\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15722,31 +17191,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.CustomDebugSt // 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.customDebugStringConvertible) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearSourceFile_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.customDebugStringConvertible != 0 { - try visitor.visitSingularInt32Field(value: self.customDebugStringConvertible, fieldNumber: 1) + if self.clearSourceFile_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearSourceFile_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.CustomDebugStringConvertible, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.CustomDebugStringConvertible) -> Bool { - if lhs.customDebugStringConvertible != rhs.customDebugStringConvertible {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceFile, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceFile) -> Bool { + if lhs.clearSourceFile_p != rhs.clearSourceFile_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.d: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".d" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "d"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearStart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearStart" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearStart\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15754,31 +17221,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.d: SwiftProto // 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.d) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearStart_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.d != 0 { - try visitor.visitSingularInt32Field(value: self.d, fieldNumber: 1) + if self.clearStart_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearStart_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.d, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.d) -> Bool { - if lhs.d != rhs.d {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearStart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearStart) -> Bool { + if lhs.clearStart_p != rhs.clearStart_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Data" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Data"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearStringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearStringValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearStringValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15786,31 +17251,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DataMessage: // 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.data) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearStringValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.data != 0 { - try visitor.visitSingularInt32Field(value: self.data, fieldNumber: 1) + if self.clearStringValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearStringValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DataMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DataMessage) -> Bool { - if lhs.data != rhs.data {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearStringValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearStringValue) -> Bool { + if lhs.clearStringValue_p != rhs.clearStringValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dataResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".dataResult" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "dataResult"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSwiftPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSwiftPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearSwiftPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15818,31 +17281,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dataResult: S // 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.dataResult) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearSwiftPrefix_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.dataResult != 0 { - try visitor.visitSingularInt32Field(value: self.dataResult, fieldNumber: 1) + if self.clearSwiftPrefix_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearSwiftPrefix_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dataResult, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dataResult) -> Bool { - if lhs.dataResult != rhs.dataResult {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSwiftPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSwiftPrefix) -> Bool { + if lhs.clearSwiftPrefix_p != rhs.clearSwiftPrefix_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.date: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".date" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "date"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSyntax: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSyntax" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearSyntax\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15850,31 +17311,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.date: SwiftPr // 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.date) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearSyntax_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.date != 0 { - try visitor.visitSingularInt32Field(value: self.date, fieldNumber: 1) + if self.clearSyntax_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearSyntax_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.date, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.date) -> Bool { - if lhs.date != rhs.date {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSyntax, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSyntax) -> Bool { + if lhs.clearSyntax_p != rhs.clearSyntax_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daySec: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".daySec" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "daySec"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearTrailingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearTrailingComments" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearTrailingComments\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15882,31 +17341,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daySec: Swift // 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.daySec) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearTrailingComments_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.daySec != 0 { - try visitor.visitSingularInt32Field(value: self.daySec, fieldNumber: 1) + if self.clearTrailingComments_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearTrailingComments_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daySec, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daySec) -> Bool { - if lhs.daySec != rhs.daySec {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearTrailingComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearTrailingComments) -> Bool { + if lhs.clearTrailingComments_p != rhs.clearTrailingComments_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daysSinceEpoch: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".daysSinceEpoch" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "daysSinceEpoch"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15914,31 +17371,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daysSinceEpoc // 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.daysSinceEpoch) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearType_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.daysSinceEpoch != 0 { - try visitor.visitSingularInt32Field(value: self.daysSinceEpoch, fieldNumber: 1) + if self.clearType_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearType_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daysSinceEpoch, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daysSinceEpoch) -> Bool { - if lhs.daysSinceEpoch != rhs.daysSinceEpoch {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearType) -> Bool { + if lhs.clearType_p != rhs.clearType_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.debugDescriptionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".debugDescription" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "debugDescription"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearTypeName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearTypeName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearTypeName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15946,31 +17401,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.debugDescript // 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.debugDescription_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearTypeName_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.debugDescription_p != 0 { - try visitor.visitSingularInt32Field(value: self.debugDescription_p, fieldNumber: 1) + if self.clearTypeName_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearTypeName_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.debugDescriptionMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.debugDescriptionMessage) -> Bool { - if lhs.debugDescription_p != rhs.debugDescription_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearTypeName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearTypeName) -> Bool { + if lhs.clearTypeName_p != rhs.clearTypeName_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoded: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decoded" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decoded"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearUnverifiedLazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearUnverifiedLazy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearUnverifiedLazy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15978,31 +17431,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoded: Swif // 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.decoded) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearUnverifiedLazy_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decoded != 0 { - try visitor.visitSingularInt32Field(value: self.decoded, fieldNumber: 1) + if self.clearUnverifiedLazy_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearUnverifiedLazy_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoded, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoded) -> Bool { - if lhs.decoded != rhs.decoded {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearUnverifiedLazy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearUnverifiedLazy) -> Bool { + if lhs.clearUnverifiedLazy_p != rhs.clearUnverifiedLazy_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodedFromJSONNull: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodedFromJSONNull" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodedFromJSONNull"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearUtf8Validation: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearUtf8Validation" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearUtf8Validation\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16010,31 +17461,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodedFromJS // 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.decodedFromJsonnull) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearUtf8Validation_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodedFromJsonnull != 0 { - try visitor.visitSingularInt32Field(value: self.decodedFromJsonnull, fieldNumber: 1) + if self.clearUtf8Validation_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearUtf8Validation_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodedFromJSONNull, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodedFromJSONNull) -> Bool { - if lhs.decodedFromJsonnull != rhs.decodedFromJsonnull {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearUtf8Validation, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearUtf8Validation) -> Bool { + if lhs.clearUtf8Validation_p != rhs.clearUtf8Validation_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16042,31 +17491,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensi // 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.decodeExtensionField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeExtensionField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeExtensionField, fieldNumber: 1) + if self.clearValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensionField) -> Bool { - if lhs.decodeExtensionField != rhs.decodeExtensionField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearValue) -> Bool { + if lhs.clearValue_p != rhs.clearValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensionFieldsAsMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeExtensionFieldsAsMessageSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeExtensionFieldsAsMessageSet"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearVerification: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearVerification" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearVerification\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16074,31 +17521,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensi // 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.decodeExtensionFieldsAsMessageSet) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearVerification_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeExtensionFieldsAsMessageSet != 0 { - try visitor.visitSingularInt32Field(value: self.decodeExtensionFieldsAsMessageSet, fieldNumber: 1) + if self.clearVerification_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearVerification_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensionFieldsAsMessageSet, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensionFieldsAsMessageSet) -> Bool { - if lhs.decodeExtensionFieldsAsMessageSet != rhs.decodeExtensionFieldsAsMessageSet {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearVerification, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearVerification) -> Bool { + if lhs.clearVerification_p != rhs.clearVerification_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeJSON: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeJSON" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeJSON"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearVisibility: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearVisibility" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearVisibility\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16106,31 +17551,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeJSON: S // 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.decodeJson) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearVisibility_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeJson != 0 { - try visitor.visitSingularInt32Field(value: self.decodeJson, fieldNumber: 1) + if self.clearVisibility_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearVisibility_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeJSON, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeJSON) -> Bool { - if lhs.decodeJson != rhs.decodeJson {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearVisibility, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearVisibility) -> Bool { + if lhs.clearVisibility_p != rhs.clearVisibility_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMapField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeMapField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeMapField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearWeak: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearWeak" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearWeak\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16138,31 +17581,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMapFiel // 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.decodeMapField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearWeak_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeMapField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeMapField, fieldNumber: 1) + if self.clearWeak_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearWeak_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMapField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMapField) -> Bool { - if lhs.decodeMapField != rhs.decodeMapField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearWeak, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearWeak) -> Bool { + if lhs.clearWeak_p != rhs.clearWeak_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMessageMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeMessage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clientStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clientStreaming" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clientStreaming\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16170,31 +17611,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMessage // 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.decodeMessage) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clientStreaming) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeMessage != 0 { - try visitor.visitSingularInt32Field(value: self.decodeMessage, fieldNumber: 1) + if self.clientStreaming != 0 { + try visitor.visitSingularInt32Field(value: self.clientStreaming, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMessageMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMessageMessage) -> Bool { - if lhs.decodeMessage != rhs.decodeMessage {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clientStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clientStreaming) -> Bool { + if lhs.clientStreaming != rhs.clientStreaming {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.code: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".code" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}code\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16202,31 +17641,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoder: Swif // 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.decoder) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.code) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decoder != 0 { - try visitor.visitSingularInt32Field(value: self.decoder, fieldNumber: 1) + if self.code != 0 { + try visitor.visitSingularInt32Field(value: self.code, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoder) -> Bool { - if lhs.decoder != rhs.decoder {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.code, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.code) -> Bool { + if lhs.code != rhs.code {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeated" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeated"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.codePoint: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".codePoint" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}codePoint\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16234,31 +17671,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeated) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.codePoint) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeated != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeated, fieldNumber: 1) + if self.codePoint != 0 { + try visitor.visitSingularInt32Field(value: self.codePoint, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeated, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeated) -> Bool { - if lhs.decodeRepeated != rhs.decodeRepeated {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.codePoint, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.codePoint) -> Bool { + if lhs.codePoint != rhs.codePoint {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedBoolField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedBoolField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.codeUnits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".codeUnits" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}codeUnits\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16266,31 +17701,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedBoolField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.codeUnits) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedBoolField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedBoolField, fieldNumber: 1) + if self.codeUnits != 0 { + try visitor.visitSingularInt32Field(value: self.codeUnits, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedBoolField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedBoolField) -> Bool { - if lhs.decodeRepeatedBoolField != rhs.decodeRepeatedBoolField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.codeUnits, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.codeUnits) -> Bool { + if lhs.codeUnits != rhs.codeUnits {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedBytesField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedBytesField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedBytesField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Collection: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Collection" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Collection\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16298,31 +17731,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedBytesField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.collection) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedBytesField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedBytesField, fieldNumber: 1) + if self.collection != 0 { + try visitor.visitSingularInt32Field(value: self.collection, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedBytesField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedBytesField) -> Bool { - if lhs.decodeRepeatedBytesField != rhs.decodeRepeatedBytesField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Collection, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Collection) -> Bool { + if lhs.collection != rhs.collection {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedDoubleField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedDoubleField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.comma: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".comma" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}comma\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16330,31 +17761,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedDoubleField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.comma) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedDoubleField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedDoubleField, fieldNumber: 1) + if self.comma != 0 { + try visitor.visitSingularInt32Field(value: self.comma, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedDoubleField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedDoubleField) -> Bool { - if lhs.decodeRepeatedDoubleField != rhs.decodeRepeatedDoubleField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.comma, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.comma) -> Bool { + if lhs.comma != rhs.comma {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedEnumField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedEnumField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.consumedBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".consumedBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}consumedBytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16362,31 +17791,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedEnumField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.consumedBytes) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedEnumField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedEnumField, fieldNumber: 1) + if self.consumedBytes != 0 { + try visitor.visitSingularInt32Field(value: self.consumedBytes, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedEnumField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedEnumField) -> Bool { - if lhs.decodeRepeatedEnumField != rhs.decodeRepeatedEnumField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.consumedBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.consumedBytes) -> Bool { + if lhs.consumedBytes != rhs.consumedBytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.contains: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".contains" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}contains\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16394,31 +17821,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedFixed32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.contains) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedFixed32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedFixed32Field, fieldNumber: 1) + if self.contains != 0 { + try visitor.visitSingularInt32Field(value: self.contains, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFixed32Field) -> Bool { - if lhs.decodeRepeatedFixed32Field != rhs.decodeRepeatedFixed32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.contains, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.contains) -> Bool { + if lhs.contains != rhs.contains {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.contentsOf: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".contentsOf" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}contentsOf\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16426,31 +17851,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedFixed64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.contentsOf) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedFixed64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedFixed64Field, fieldNumber: 1) + if self.contentsOf != 0 { + try visitor.visitSingularInt32Field(value: self.contentsOf, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFixed64Field) -> Bool { - if lhs.decodeRepeatedFixed64Field != rhs.decodeRepeatedFixed64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.contentsOf, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.contentsOf) -> Bool { + if lhs.contentsOf != rhs.contentsOf {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedFloatField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedFloatField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ContiguousBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ContiguousBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ContiguousBytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16458,31 +17881,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedFloatField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.contiguousBytes) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedFloatField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedFloatField, fieldNumber: 1) + if self.contiguousBytes != 0 { + try visitor.visitSingularInt32Field(value: self.contiguousBytes, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFloatField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFloatField) -> Bool { - if lhs.decodeRepeatedFloatField != rhs.decodeRepeatedFloatField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ContiguousBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ContiguousBytes) -> Bool { + if lhs.contiguousBytes != rhs.contiguousBytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedGroupField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedGroupField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.copy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".copy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}copy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16490,31 +17911,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedGroupField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.copy) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedGroupField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedGroupField, fieldNumber: 1) + if self.copy != 0 { + try visitor.visitSingularInt32Field(value: self.copy, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedGroupField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedGroupField) -> Bool { - if lhs.decodeRepeatedGroupField != rhs.decodeRepeatedGroupField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.copy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.copy) -> Bool { + if lhs.copy != rhs.copy {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.count: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".count" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}count\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16522,31 +17941,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedInt32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.count) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedInt32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedInt32Field, fieldNumber: 1) + if self.count != 0 { + try visitor.visitSingularInt32Field(value: self.count, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedInt32Field) -> Bool { - if lhs.decodeRepeatedInt32Field != rhs.decodeRepeatedInt32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.count, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.count) -> Bool { + if lhs.count != rhs.count {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.countVarintsInBuffer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".countVarintsInBuffer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}countVarintsInBuffer\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16554,31 +17971,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedInt64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.countVarintsInBuffer) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedInt64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedInt64Field, fieldNumber: 1) + if self.countVarintsInBuffer != 0 { + try visitor.visitSingularInt32Field(value: self.countVarintsInBuffer, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedInt64Field) -> Bool { - if lhs.decodeRepeatedInt64Field != rhs.decodeRepeatedInt64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.countVarintsInBuffer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.countVarintsInBuffer) -> Bool { + if lhs.countVarintsInBuffer != rhs.countVarintsInBuffer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedMessageField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedMessageField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.csharpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".csharpNamespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}csharpNamespace\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16586,31 +18001,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedMessageField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.csharpNamespace) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedMessageField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedMessageField, fieldNumber: 1) + if self.csharpNamespace != 0 { + try visitor.visitSingularInt32Field(value: self.csharpNamespace, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedMessageField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedMessageField) -> Bool { - if lhs.decodeRepeatedMessageField != rhs.decodeRepeatedMessageField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.csharpNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.csharpNamespace) -> Bool { + if lhs.csharpNamespace != rhs.csharpNamespace {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedSFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedSFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ctype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ctype" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ctype\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16618,31 +18031,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedSfixed32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.ctype) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedSfixed32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedSfixed32Field, fieldNumber: 1) + if self.ctype != 0 { + try visitor.visitSingularInt32Field(value: self.ctype, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed32Field) -> Bool { - if lhs.decodeRepeatedSfixed32Field != rhs.decodeRepeatedSfixed32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ctype, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ctype) -> Bool { + if lhs.ctype != rhs.ctype {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedSFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedSFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.customCodable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".customCodable" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}customCodable\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16650,31 +18061,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedSfixed64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.customCodable) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedSfixed64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedSfixed64Field, fieldNumber: 1) + if self.customCodable != 0 { + try visitor.visitSingularInt32Field(value: self.customCodable, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed64Field) -> Bool { - if lhs.decodeRepeatedSfixed64Field != rhs.decodeRepeatedSfixed64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.customCodable, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.customCodable) -> Bool { + if lhs.customCodable != rhs.customCodable {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedSInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedSInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CustomDebugStringConvertible: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".CustomDebugStringConvertible" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}CustomDebugStringConvertible\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16682,31 +18091,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedSint32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.customDebugStringConvertible) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedSint32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedSint32Field, fieldNumber: 1) + if self.customDebugStringConvertible != 0 { + try visitor.visitSingularInt32Field(value: self.customDebugStringConvertible, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSInt32Field) -> Bool { - if lhs.decodeRepeatedSint32Field != rhs.decodeRepeatedSint32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CustomDebugStringConvertible, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CustomDebugStringConvertible) -> Bool { + if lhs.customDebugStringConvertible != rhs.customDebugStringConvertible {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedSInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedSInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CustomStringConvertible: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".CustomStringConvertible" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}CustomStringConvertible\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16714,31 +18121,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedSint64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.customStringConvertible) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedSint64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedSint64Field, fieldNumber: 1) + if self.customStringConvertible != 0 { + try visitor.visitSingularInt32Field(value: self.customStringConvertible, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSInt64Field) -> Bool { - if lhs.decodeRepeatedSint64Field != rhs.decodeRepeatedSint64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CustomStringConvertible, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CustomStringConvertible) -> Bool { + if lhs.customStringConvertible != rhs.customStringConvertible {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedStringField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedStringField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedStringField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.D: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".D" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}D\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16746,31 +18151,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedStringField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.d) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedStringField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedStringField, fieldNumber: 1) + if self.d != 0 { + try visitor.visitSingularInt32Field(value: self.d, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedStringField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedStringField) -> Bool { - if lhs.decodeRepeatedStringField != rhs.decodeRepeatedStringField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.D, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.D) -> Bool { + if lhs.d != rhs.d {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedUInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedUInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Data\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16778,31 +18181,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedUint32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.data) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedUint32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedUint32Field, fieldNumber: 1) + if self.data != 0 { + try visitor.visitSingularInt32Field(value: self.data, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedUInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedUInt32Field) -> Bool { - if lhs.decodeRepeatedUint32Field != rhs.decodeRepeatedUint32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DataMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DataMessage) -> Bool { + if lhs.data != rhs.data {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedUInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedUInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dataResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".dataResult" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}dataResult\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16810,31 +18211,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedUint64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.dataResult) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedUint64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedUint64Field, fieldNumber: 1) + if self.dataResult != 0 { + try visitor.visitSingularInt32Field(value: self.dataResult, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedUInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedUInt64Field) -> Bool { - if lhs.decodeRepeatedUint64Field != rhs.decodeRepeatedUint64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dataResult, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dataResult) -> Bool { + if lhs.dataResult != rhs.dataResult {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingular: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingular" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingular"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.date: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".date" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}date\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16842,31 +18241,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingular) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.date) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingular != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingular, fieldNumber: 1) + if self.date != 0 { + try visitor.visitSingularInt32Field(value: self.date, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingular, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingular) -> Bool { - if lhs.decodeSingular != rhs.decodeSingular {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.date, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.date) -> Bool { + if lhs.date != rhs.date {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularBoolField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularBoolField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.daySec: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".daySec" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}daySec\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16874,31 +18271,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularBoolField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.daySec) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularBoolField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularBoolField, fieldNumber: 1) + if self.daySec != 0 { + try visitor.visitSingularInt32Field(value: self.daySec, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularBoolField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularBoolField) -> Bool { - if lhs.decodeSingularBoolField != rhs.decodeSingularBoolField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.daySec, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.daySec) -> Bool { + if lhs.daySec != rhs.daySec {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularBytesField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularBytesField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularBytesField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.daysSinceEpoch: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".daysSinceEpoch" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}daysSinceEpoch\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16906,31 +18301,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularBytesField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.daysSinceEpoch) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularBytesField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularBytesField, fieldNumber: 1) + if self.daysSinceEpoch != 0 { + try visitor.visitSingularInt32Field(value: self.daysSinceEpoch, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularBytesField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularBytesField) -> Bool { - if lhs.decodeSingularBytesField != rhs.decodeSingularBytesField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.daysSinceEpoch, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.daysSinceEpoch) -> Bool { + if lhs.daysSinceEpoch != rhs.daysSinceEpoch {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularDoubleField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularDoubleField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.debugDescriptionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".debugDescription" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}debugDescription\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16938,31 +18331,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularDoubleField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.debugDescription_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularDoubleField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularDoubleField, fieldNumber: 1) + if self.debugDescription_p != 0 { + try visitor.visitSingularInt32Field(value: self.debugDescription_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularDoubleField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularDoubleField) -> Bool { - if lhs.decodeSingularDoubleField != rhs.decodeSingularDoubleField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.debugDescriptionMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.debugDescriptionMessage) -> Bool { + if lhs.debugDescription_p != rhs.debugDescription_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularEnumField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularEnumField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.debugRedact: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".debugRedact" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}debugRedact\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16970,31 +18361,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularEnumField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.debugRedact) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularEnumField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularEnumField, fieldNumber: 1) + if self.debugRedact != 0 { + try visitor.visitSingularInt32Field(value: self.debugRedact, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularEnumField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularEnumField) -> Bool { - if lhs.decodeSingularEnumField != rhs.decodeSingularEnumField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.debugRedact, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.debugRedact) -> Bool { + if lhs.debugRedact != rhs.debugRedact {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.declaration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".declaration" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}declaration\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17002,31 +18391,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularFixed32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.declaration) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularFixed32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularFixed32Field, fieldNumber: 1) + if self.declaration != 0 { + try visitor.visitSingularInt32Field(value: self.declaration, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFixed32Field) -> Bool { - if lhs.decodeSingularFixed32Field != rhs.decodeSingularFixed32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.declaration, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.declaration) -> Bool { + if lhs.declaration != rhs.declaration {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decoded: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decoded" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decoded\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17034,31 +18421,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularFixed64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decoded) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularFixed64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularFixed64Field, fieldNumber: 1) + if self.decoded != 0 { + try visitor.visitSingularInt32Field(value: self.decoded, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFixed64Field) -> Bool { - if lhs.decodeSingularFixed64Field != rhs.decodeSingularFixed64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decoded, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decoded) -> Bool { + if lhs.decoded != rhs.decoded {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularFloatField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularFloatField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodedFromJSONNull: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodedFromJSONNull" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodedFromJSONNull\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17066,31 +18451,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularFloatField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodedFromJsonnull) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularFloatField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularFloatField, fieldNumber: 1) + if self.decodedFromJsonnull != 0 { + try visitor.visitSingularInt32Field(value: self.decodedFromJsonnull, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFloatField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFloatField) -> Bool { - if lhs.decodeSingularFloatField != rhs.decodeSingularFloatField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodedFromJSONNull, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodedFromJSONNull) -> Bool { + if lhs.decodedFromJsonnull != rhs.decodedFromJsonnull {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularGroupField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularGroupField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17098,31 +18481,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularGroupField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeExtensionField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularGroupField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularGroupField, fieldNumber: 1) + if self.decodeExtensionField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeExtensionField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularGroupField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularGroupField) -> Bool { - if lhs.decodeSingularGroupField != rhs.decodeSingularGroupField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeExtensionField) -> Bool { + if lhs.decodeExtensionField != rhs.decodeExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeExtensionFieldsAsMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeExtensionFieldsAsMessageSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeExtensionFieldsAsMessageSet\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17130,31 +18511,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularInt32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeExtensionFieldsAsMessageSet) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularInt32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularInt32Field, fieldNumber: 1) + if self.decodeExtensionFieldsAsMessageSet != 0 { + try visitor.visitSingularInt32Field(value: self.decodeExtensionFieldsAsMessageSet, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularInt32Field) -> Bool { - if lhs.decodeSingularInt32Field != rhs.decodeSingularInt32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeExtensionFieldsAsMessageSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeExtensionFieldsAsMessageSet) -> Bool { + if lhs.decodeExtensionFieldsAsMessageSet != rhs.decodeExtensionFieldsAsMessageSet {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeJSON: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeJSON" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeJSON\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17162,31 +18541,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularInt64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeJson) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularInt64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularInt64Field, fieldNumber: 1) + if self.decodeJson != 0 { + try visitor.visitSingularInt32Field(value: self.decodeJson, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularInt64Field) -> Bool { - if lhs.decodeSingularInt64Field != rhs.decodeSingularInt64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeJSON, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeJSON) -> Bool { + if lhs.decodeJson != rhs.decodeJson {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularMessageField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularMessageField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeMapField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeMapField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeMapField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17194,31 +18571,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularMessageField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeMapField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularMessageField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularMessageField, fieldNumber: 1) + if self.decodeMapField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeMapField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularMessageField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularMessageField) -> Bool { - if lhs.decodeSingularMessageField != rhs.decodeSingularMessageField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeMapField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeMapField) -> Bool { + if lhs.decodeMapField != rhs.decodeMapField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularSFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularSFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeMessageMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeMessage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17226,31 +18601,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularSfixed32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeMessage) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularSfixed32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularSfixed32Field, fieldNumber: 1) + if self.decodeMessage != 0 { + try visitor.visitSingularInt32Field(value: self.decodeMessage, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSFixed32Field) -> Bool { - if lhs.decodeSingularSfixed32Field != rhs.decodeSingularSfixed32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeMessageMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeMessageMessage) -> Bool { + if lhs.decodeMessage != rhs.decodeMessage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularSFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularSFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Decoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Decoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Decoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17258,31 +18631,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularSfixed64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decoder) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularSfixed64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularSfixed64Field, fieldNumber: 1) + if self.decoder != 0 { + try visitor.visitSingularInt32Field(value: self.decoder, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSFixed64Field) -> Bool { - if lhs.decodeSingularSfixed64Field != rhs.decodeSingularSfixed64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Decoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Decoder) -> Bool { + if lhs.decoder != rhs.decoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularSInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularSInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeated\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17290,31 +18661,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularSint32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeated) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularSint32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularSint32Field, fieldNumber: 1) + if self.decodeRepeated != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeated, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSInt32Field) -> Bool { - if lhs.decodeSingularSint32Field != rhs.decodeSingularSint32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeated) -> Bool { + if lhs.decodeRepeated != rhs.decodeRepeated {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularSInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularSInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedBoolField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedBoolField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17322,31 +18691,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularSint64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedBoolField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularSint64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularSint64Field, fieldNumber: 1) + if self.decodeRepeatedBoolField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedBoolField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSInt64Field) -> Bool { - if lhs.decodeSingularSint64Field != rhs.decodeSingularSint64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedBoolField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedBoolField) -> Bool { + if lhs.decodeRepeatedBoolField != rhs.decodeRepeatedBoolField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularStringField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularStringField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularStringField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedBytesField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedBytesField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedBytesField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17354,31 +18721,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularStringField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedBytesField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularStringField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularStringField, fieldNumber: 1) + if self.decodeRepeatedBytesField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedBytesField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularStringField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularStringField) -> Bool { - if lhs.decodeSingularStringField != rhs.decodeSingularStringField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedBytesField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedBytesField) -> Bool { + if lhs.decodeRepeatedBytesField != rhs.decodeRepeatedBytesField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularUInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularUInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedDoubleField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedDoubleField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17386,31 +18751,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularUint32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedDoubleField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularUint32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularUint32Field, fieldNumber: 1) + if self.decodeRepeatedDoubleField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedDoubleField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularUInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularUInt32Field) -> Bool { - if lhs.decodeSingularUint32Field != rhs.decodeSingularUint32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedDoubleField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedDoubleField) -> Bool { + if lhs.decodeRepeatedDoubleField != rhs.decodeRepeatedDoubleField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularUInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularUInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedEnumField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedEnumField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17418,31 +18781,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularUint64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedEnumField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularUint64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularUint64Field, fieldNumber: 1) + if self.decodeRepeatedEnumField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedEnumField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularUInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularUInt64Field) -> Bool { - if lhs.decodeSingularUint64Field != rhs.decodeSingularUint64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedEnumField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedEnumField) -> Bool { + if lhs.decodeRepeatedEnumField != rhs.decodeRepeatedEnumField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeTextFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeTextFormat" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeTextFormat"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17450,31 +18811,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeTextFor // 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.decodeTextFormat) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedFixed32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeTextFormat != 0 { - try visitor.visitSingularInt32Field(value: self.decodeTextFormat, fieldNumber: 1) + if self.decodeRepeatedFixed32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedFixed32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeTextFormat, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeTextFormat) -> Bool { - if lhs.decodeTextFormat != rhs.decodeTextFormat {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFixed32Field) -> Bool { + if lhs.decodeRepeatedFixed32Field != rhs.decodeRepeatedFixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultAnyTypeURLPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".defaultAnyTypeURLPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "defaultAnyTypeURLPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17482,31 +18841,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultAnyTyp // 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.defaultAnyTypeUrlprefix) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedFixed64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.defaultAnyTypeUrlprefix != 0 { - try visitor.visitSingularInt32Field(value: self.defaultAnyTypeUrlprefix, fieldNumber: 1) + if self.decodeRepeatedFixed64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedFixed64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultAnyTypeURLPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultAnyTypeURLPrefix) -> Bool { - if lhs.defaultAnyTypeUrlprefix != rhs.defaultAnyTypeUrlprefix {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFixed64Field) -> Bool { + if lhs.decodeRepeatedFixed64Field != rhs.decodeRepeatedFixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".defaultValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "defaultValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedFloatField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedFloatField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17514,31 +18871,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultValue: // 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.defaultValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedFloatField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.defaultValue != 0 { - try visitor.visitSingularInt32Field(value: self.defaultValue, fieldNumber: 1) + if self.decodeRepeatedFloatField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedFloatField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultValue) -> Bool { - if lhs.defaultValue != rhs.defaultValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFloatField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFloatField) -> Bool { + if lhs.decodeRepeatedFloatField != rhs.decodeRepeatedFloatField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dependency: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".dependency" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "dependency"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedGroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedGroupField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17546,31 +18901,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dependency: S // 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.dependency) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedGroupField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.dependency != 0 { - try visitor.visitSingularInt32Field(value: self.dependency, fieldNumber: 1) + if self.decodeRepeatedGroupField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedGroupField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dependency, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dependency) -> Bool { - if lhs.dependency != rhs.dependency {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedGroupField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedGroupField) -> Bool { + if lhs.decodeRepeatedGroupField != rhs.decodeRepeatedGroupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.deprecated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".deprecated" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "deprecated"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17578,31 +18931,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.deprecated: S // 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.deprecated) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedInt32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.deprecated != 0 { - try visitor.visitSingularInt32Field(value: self.deprecated, fieldNumber: 1) + if self.decodeRepeatedInt32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedInt32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.deprecated, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.deprecated) -> Bool { - if lhs.deprecated != rhs.deprecated {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedInt32Field) -> Bool { + if lhs.decodeRepeatedInt32Field != rhs.decodeRepeatedInt32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.descriptionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".description" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "description"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17610,31 +18961,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.descriptionMe // 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.description_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedInt64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.description_p != 0 { - try visitor.visitSingularInt32Field(value: self.description_p, fieldNumber: 1) + if self.decodeRepeatedInt64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedInt64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.descriptionMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.descriptionMessage) -> Bool { - if lhs.description_p != rhs.description_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedInt64Field) -> Bool { + if lhs.decodeRepeatedInt64Field != rhs.decodeRepeatedInt64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".DescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "DescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedMessageField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedMessageField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17642,31 +18991,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DescriptorPro // 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.descriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedMessageField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.descriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.descriptorProto, fieldNumber: 1) + if self.decodeRepeatedMessageField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedMessageField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DescriptorProto) -> Bool { - if lhs.descriptorProto != rhs.descriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedMessageField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedMessageField) -> Bool { + if lhs.decodeRepeatedMessageField != rhs.decodeRepeatedMessageField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Dictionary: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Dictionary" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Dictionary"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedSFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedSFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17674,31 +19021,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Dictionary: S // 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.dictionary) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedSfixed32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.dictionary != 0 { - try visitor.visitSingularInt32Field(value: self.dictionary, fieldNumber: 1) + if self.decodeRepeatedSfixed32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedSfixed32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Dictionary, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Dictionary) -> Bool { - if lhs.dictionary != rhs.dictionary {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed32Field) -> Bool { + if lhs.decodeRepeatedSfixed32Field != rhs.decodeRepeatedSfixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dictionaryLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".dictionaryLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "dictionaryLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedSFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedSFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17706,31 +19051,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dictionaryLit // 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.dictionaryLiteral) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedSfixed64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.dictionaryLiteral != 0 { - try visitor.visitSingularInt32Field(value: self.dictionaryLiteral, fieldNumber: 1) + if self.decodeRepeatedSfixed64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedSfixed64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dictionaryLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dictionaryLiteral) -> Bool { - if lhs.dictionaryLiteral != rhs.dictionaryLiteral {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed64Field) -> Bool { + if lhs.decodeRepeatedSfixed64Field != rhs.decodeRepeatedSfixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".digit" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "digit"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedSInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedSInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17738,31 +19081,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit: SwiftP // 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.digit) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedSint32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.digit != 0 { - try visitor.visitSingularInt32Field(value: self.digit, fieldNumber: 1) + if self.decodeRepeatedSint32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedSint32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit) -> Bool { - if lhs.digit != rhs.digit {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSInt32Field) -> Bool { + if lhs.decodeRepeatedSint32Field != rhs.decodeRepeatedSint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit0: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".digit0" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "digit0"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedSInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedSInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17770,31 +19111,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit0: Swift // 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.digit0) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedSint64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.digit0 != 0 { - try visitor.visitSingularInt32Field(value: self.digit0, fieldNumber: 1) + if self.decodeRepeatedSint64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedSint64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit0, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit0) -> Bool { - if lhs.digit0 != rhs.digit0 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSInt64Field) -> Bool { + if lhs.decodeRepeatedSint64Field != rhs.decodeRepeatedSint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".digit1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "digit1"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedStringField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedStringField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedStringField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17802,31 +19141,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit1: Swift // 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.digit1) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedStringField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.digit1 != 0 { - try visitor.visitSingularInt32Field(value: self.digit1, fieldNumber: 1) + if self.decodeRepeatedStringField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedStringField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit1, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit1) -> Bool { - if lhs.digit1 != rhs.digit1 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedStringField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedStringField) -> Bool { + if lhs.decodeRepeatedStringField != rhs.decodeRepeatedStringField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".digitCount" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "digitCount"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedUInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedUInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17834,31 +19171,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitCount: S // 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.digitCount) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedUint32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.digitCount != 0 { - try visitor.visitSingularInt32Field(value: self.digitCount, fieldNumber: 1) + if self.decodeRepeatedUint32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedUint32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitCount, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitCount) -> Bool { - if lhs.digitCount != rhs.digitCount {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedUInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedUInt32Field) -> Bool { + if lhs.decodeRepeatedUint32Field != rhs.decodeRepeatedUint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".digits" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "digits"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedUInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedUInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17866,31 +19201,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digits: Swift // 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.digits) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedUint64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.digits != 0 { - try visitor.visitSingularInt32Field(value: self.digits, fieldNumber: 1) + if self.decodeRepeatedUint64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedUint64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digits, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digits) -> Bool { - if lhs.digits != rhs.digits {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedUInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedUInt64Field) -> Bool { + if lhs.decodeRepeatedUint64Field != rhs.decodeRepeatedUint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".digitValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "digitValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingular: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingular" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingular\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17898,31 +19231,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitValue: S // 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.digitValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingular) }() default: break } } } func traverse(visitor: inout V) throws { - if self.digitValue != 0 { - try visitor.visitSingularInt32Field(value: self.digitValue, fieldNumber: 1) + if self.decodeSingular != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingular, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitValue) -> Bool { - if lhs.digitValue != rhs.digitValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingular, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingular) -> Bool { + if lhs.decodeSingular != rhs.decodeSingular {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardableResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".discardableResult" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "discardableResult"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularBoolField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularBoolField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17930,31 +19261,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardableRe // 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.discardableResult) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularBoolField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.discardableResult != 0 { - try visitor.visitSingularInt32Field(value: self.discardableResult, fieldNumber: 1) + if self.decodeSingularBoolField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularBoolField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardableResult, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardableResult) -> Bool { - if lhs.discardableResult != rhs.discardableResult {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularBoolField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularBoolField) -> Bool { + if lhs.decodeSingularBoolField != rhs.decodeSingularBoolField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardUnknownFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".discardUnknownFields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "discardUnknownFields"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularBytesField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularBytesField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularBytesField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17962,31 +19291,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardUnknow // 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.discardUnknownFields) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularBytesField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.discardUnknownFields != 0 { - try visitor.visitSingularInt32Field(value: self.discardUnknownFields, fieldNumber: 1) + if self.decodeSingularBytesField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularBytesField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardUnknownFields, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardUnknownFields) -> Bool { - if lhs.discardUnknownFields != rhs.discardUnknownFields {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularBytesField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularBytesField) -> Bool { + if lhs.decodeSingularBytesField != rhs.decodeSingularBytesField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.distance: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".distance" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "distance"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularDoubleField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularDoubleField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17994,31 +19321,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.distance: Swi // 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.distance) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularDoubleField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.distance != 0 { - try visitor.visitSingularInt32Field(value: self.distance, fieldNumber: 1) + if self.decodeSingularDoubleField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularDoubleField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.distance, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.distance) -> Bool { - if lhs.distance != rhs.distance {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularDoubleField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularDoubleField) -> Bool { + if lhs.decodeSingularDoubleField != rhs.decodeSingularDoubleField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.double: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".double" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "double"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularEnumField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularEnumField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18026,31 +19351,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.double: Swift // 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.double) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularEnumField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.double != 0 { - try visitor.visitSingularInt32Field(value: self.double, fieldNumber: 1) + if self.decodeSingularEnumField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularEnumField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.double, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.double) -> Bool { - if lhs.double != rhs.double {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularEnumField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularEnumField) -> Bool { + if lhs.decodeSingularEnumField != rhs.decodeSingularEnumField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.doubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".doubleValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "doubleValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18058,31 +19381,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.doubleValue: // 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.doubleValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularFixed32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.doubleValue != 0 { - try visitor.visitSingularInt32Field(value: self.doubleValue, fieldNumber: 1) + if self.decodeSingularFixed32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularFixed32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.doubleValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.doubleValue) -> Bool { - if lhs.doubleValue != rhs.doubleValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFixed32Field) -> Bool { + if lhs.decodeSingularFixed32Field != rhs.decodeSingularFixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Duration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Duration" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Duration"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18090,31 +19411,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Duration: Swi // 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.duration) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularFixed64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.duration != 0 { - try visitor.visitSingularInt32Field(value: self.duration, fieldNumber: 1) + if self.decodeSingularFixed64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularFixed64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Duration, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Duration) -> Bool { - if lhs.duration != rhs.duration {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFixed64Field) -> Bool { + if lhs.decodeSingularFixed64Field != rhs.decodeSingularFixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.E: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".E" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "E"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularFloatField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularFloatField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18122,31 +19441,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.E: SwiftProto // 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.e) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularFloatField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.e != 0 { - try visitor.visitSingularInt32Field(value: self.e, fieldNumber: 1) + if self.decodeSingularFloatField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularFloatField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.E, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.E) -> Bool { - if lhs.e != rhs.e {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFloatField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFloatField) -> Bool { + if lhs.decodeSingularFloatField != rhs.decodeSingularFloatField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Element: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Element" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Element"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularGroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularGroupField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18154,31 +19471,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Element: Swif // 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.element) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularGroupField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.element != 0 { - try visitor.visitSingularInt32Field(value: self.element, fieldNumber: 1) + if self.decodeSingularGroupField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularGroupField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Element, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Element) -> Bool { - if lhs.element != rhs.element {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularGroupField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularGroupField) -> Bool { + if lhs.decodeSingularGroupField != rhs.decodeSingularGroupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.elements: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".elements" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "elements"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18186,31 +19501,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.elements: Swi // 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.elements) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularInt32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.elements != 0 { - try visitor.visitSingularInt32Field(value: self.elements, fieldNumber: 1) + if self.decodeSingularInt32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularInt32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.elements, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.elements) -> Bool { - if lhs.elements != rhs.elements {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularInt32Field) -> Bool { + if lhs.decodeSingularInt32Field != rhs.decodeSingularInt32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitExtensionFieldName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".emitExtensionFieldName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "emitExtensionFieldName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18218,31 +19531,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitExtension // 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.emitExtensionFieldName) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularInt64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.emitExtensionFieldName != 0 { - try visitor.visitSingularInt32Field(value: self.emitExtensionFieldName, fieldNumber: 1) + if self.decodeSingularInt64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularInt64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitExtensionFieldName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitExtensionFieldName) -> Bool { - if lhs.emitExtensionFieldName != rhs.emitExtensionFieldName {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularInt64Field) -> Bool { + if lhs.decodeSingularInt64Field != rhs.decodeSingularInt64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".emitFieldName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "emitFieldName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularMessageField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularMessageField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18250,31 +19561,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldName // 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.emitFieldName) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularMessageField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.emitFieldName != 0 { - try visitor.visitSingularInt32Field(value: self.emitFieldName, fieldNumber: 1) + if self.decodeSingularMessageField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularMessageField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldName) -> Bool { - if lhs.emitFieldName != rhs.emitFieldName {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularMessageField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularMessageField) -> Bool { + if lhs.decodeSingularMessageField != rhs.decodeSingularMessageField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".emitFieldNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "emitFieldNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularSFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularSFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18282,31 +19591,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldNumb // 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.emitFieldNumber) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularSfixed32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.emitFieldNumber != 0 { - try visitor.visitSingularInt32Field(value: self.emitFieldNumber, fieldNumber: 1) + if self.decodeSingularSfixed32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularSfixed32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldNumber, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldNumber) -> Bool { - if lhs.emitFieldNumber != rhs.emitFieldNumber {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSFixed32Field) -> Bool { + if lhs.decodeSingularSfixed32Field != rhs.decodeSingularSfixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Empty: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Empty" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Empty"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularSFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularSFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18314,31 +19621,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Empty: SwiftP // 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.empty) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularSfixed64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.empty != 0 { - try visitor.visitSingularInt32Field(value: self.empty, fieldNumber: 1) + if self.decodeSingularSfixed64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularSfixed64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Empty, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Empty) -> Bool { - if lhs.empty != rhs.empty {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSFixed64Field) -> Bool { + if lhs.decodeSingularSfixed64Field != rhs.decodeSingularSfixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emptyData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".emptyData" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "emptyData"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularSInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularSInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18346,31 +19651,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emptyData: Sw // 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.emptyData) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularSint32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.emptyData != 0 { - try visitor.visitSingularInt32Field(value: self.emptyData, fieldNumber: 1) + if self.decodeSingularSint32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularSint32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emptyData, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emptyData) -> Bool { - if lhs.emptyData != rhs.emptyData {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSInt32Field) -> Bool { + if lhs.decodeSingularSint32Field != rhs.decodeSingularSint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeAsBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".encodeAsBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "encodeAsBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularSInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularSInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18378,31 +19681,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeAsBytes // 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.encodeAsBytes) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularSint64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.encodeAsBytes != 0 { - try visitor.visitSingularInt32Field(value: self.encodeAsBytes, fieldNumber: 1) + if self.decodeSingularSint64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularSint64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeAsBytes, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeAsBytes) -> Bool { - if lhs.encodeAsBytes != rhs.encodeAsBytes {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSInt64Field) -> Bool { + if lhs.decodeSingularSint64Field != rhs.decodeSingularSint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoded: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".encoded" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "encoded"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularStringField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularStringField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularStringField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18410,31 +19711,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoded: Swif // 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.encoded) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularStringField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.encoded != 0 { - try visitor.visitSingularInt32Field(value: self.encoded, fieldNumber: 1) + if self.decodeSingularStringField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularStringField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoded, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoded) -> Bool { - if lhs.encoded != rhs.encoded {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularStringField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularStringField) -> Bool { + if lhs.decodeSingularStringField != rhs.decodeSingularStringField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedJSONString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".encodedJSONString" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "encodedJSONString"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularUInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularUInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18442,31 +19741,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedJSONSt // 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.encodedJsonstring) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularUint32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.encodedJsonstring != 0 { - try visitor.visitSingularInt32Field(value: self.encodedJsonstring, fieldNumber: 1) + if self.decodeSingularUint32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularUint32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedJSONString, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedJSONString) -> Bool { - if lhs.encodedJsonstring != rhs.encodedJsonstring {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularUInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularUInt32Field) -> Bool { + if lhs.decodeSingularUint32Field != rhs.decodeSingularUint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".encodedSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "encodedSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularUInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularUInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18474,31 +19771,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedSize: // 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.encodedSize) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularUint64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.encodedSize != 0 { - try visitor.visitSingularInt32Field(value: self.encodedSize, fieldNumber: 1) + if self.decodeSingularUint64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularUint64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedSize, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedSize) -> Bool { - if lhs.encodedSize != rhs.encodedSize {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularUInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularUInt64Field) -> Bool { + if lhs.decodeSingularUint64Field != rhs.decodeSingularUint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".encodeField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "encodeField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeTextFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeTextFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeTextFormat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18506,31 +19801,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeField: // 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.encodeField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeTextFormat) }() default: break } } } func traverse(visitor: inout V) throws { - if self.encodeField != 0 { - try visitor.visitSingularInt32Field(value: self.encodeField, fieldNumber: 1) + if self.decodeTextFormat != 0 { + try visitor.visitSingularInt32Field(value: self.decodeTextFormat, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeField) -> Bool { - if lhs.encodeField != rhs.encodeField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeTextFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeTextFormat) -> Bool { + if lhs.decodeTextFormat != rhs.decodeTextFormat {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".encoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "encoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultAnyTypeURLPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".defaultAnyTypeURLPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}defaultAnyTypeURLPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18538,31 +19831,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoder: Swif // 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.encoder) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.defaultAnyTypeUrlprefix) }() default: break } } } func traverse(visitor: inout V) throws { - if self.encoder != 0 { - try visitor.visitSingularInt32Field(value: self.encoder, fieldNumber: 1) + if self.defaultAnyTypeUrlprefix != 0 { + try visitor.visitSingularInt32Field(value: self.defaultAnyTypeUrlprefix, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoder) -> Bool { - if lhs.encoder != rhs.encoder {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultAnyTypeURLPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultAnyTypeURLPrefix) -> Bool { + if lhs.defaultAnyTypeUrlprefix != rhs.defaultAnyTypeUrlprefix {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.end: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".end" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "end"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaults: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".defaults" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}defaults\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18570,31 +19861,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.end: SwiftPro // 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.end) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.defaults) }() default: break } } } func traverse(visitor: inout V) throws { - if self.end != 0 { - try visitor.visitSingularInt32Field(value: self.end, fieldNumber: 1) + if self.defaults != 0 { + try visitor.visitSingularInt32Field(value: self.defaults, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.end, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.end) -> Bool { - if lhs.end != rhs.end {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaults, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaults) -> Bool { + if lhs.defaults != rhs.defaults {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endArray: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".endArray" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "endArray"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultSymbolVisibility: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".defaultSymbolVisibility" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}defaultSymbolVisibility\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18602,31 +19891,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endArray: Swi // 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.endArray) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.defaultSymbolVisibility) }() default: break } } } func traverse(visitor: inout V) throws { - if self.endArray != 0 { - try visitor.visitSingularInt32Field(value: self.endArray, fieldNumber: 1) + if self.defaultSymbolVisibility != 0 { + try visitor.visitSingularInt32Field(value: self.defaultSymbolVisibility, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endArray, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endArray) -> Bool { - if lhs.endArray != rhs.endArray {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultSymbolVisibility, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultSymbolVisibility) -> Bool { + if lhs.defaultSymbolVisibility != rhs.defaultSymbolVisibility {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".endMessageField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "endMessageField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".defaultValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}defaultValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18634,31 +19921,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endMessageFie // 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.endMessageField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.defaultValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.endMessageField != 0 { - try visitor.visitSingularInt32Field(value: self.endMessageField, fieldNumber: 1) + if self.defaultValue != 0 { + try visitor.visitSingularInt32Field(value: self.defaultValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endMessageField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endMessageField) -> Bool { - if lhs.endMessageField != rhs.endMessageField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultValue) -> Bool { + if lhs.defaultValue != rhs.defaultValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endObject: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".endObject" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "endObject"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dependency: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".dependency" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}dependency\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18666,31 +19951,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endObject: Sw // 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.endObject) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.dependency) }() default: break } } } func traverse(visitor: inout V) throws { - if self.endObject != 0 { - try visitor.visitSingularInt32Field(value: self.endObject, fieldNumber: 1) + if self.dependency != 0 { + try visitor.visitSingularInt32Field(value: self.dependency, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endObject, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endObject) -> Bool { - if lhs.endObject != rhs.endObject {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dependency, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dependency) -> Bool { + if lhs.dependency != rhs.dependency {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endRegularField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".endRegularField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "endRegularField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".deprecated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}deprecated\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18698,31 +19981,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endRegularFie // 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.endRegularField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.deprecated) }() default: break } } } func traverse(visitor: inout V) throws { - if self.endRegularField != 0 { - try visitor.visitSingularInt32Field(value: self.endRegularField, fieldNumber: 1) + if self.deprecated != 0 { + try visitor.visitSingularInt32Field(value: self.deprecated, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endRegularField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endRegularField) -> Bool { - if lhs.endRegularField != rhs.endRegularField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecated) -> Bool { + if lhs.deprecated != rhs.deprecated {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".enum" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "enum"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecatedLegacyJsonFieldConflicts: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".deprecatedLegacyJsonFieldConflicts" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}deprecatedLegacyJsonFieldConflicts\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18730,31 +20011,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumMessage: // 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.`enum`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.deprecatedLegacyJsonFieldConflicts) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`enum` != 0 { - try visitor.visitSingularInt32Field(value: self.`enum`, fieldNumber: 1) + if self.deprecatedLegacyJsonFieldConflicts != 0 { + try visitor.visitSingularInt32Field(value: self.deprecatedLegacyJsonFieldConflicts, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumMessage) -> Bool { - if lhs.`enum` != rhs.`enum` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecatedLegacyJsonFieldConflicts, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecatedLegacyJsonFieldConflicts) -> Bool { + if lhs.deprecatedLegacyJsonFieldConflicts != rhs.deprecatedLegacyJsonFieldConflicts {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".EnumDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "EnumDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecationWarning: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".deprecationWarning" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}deprecationWarning\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18762,31 +20041,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumDescripto // 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.enumDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.deprecationWarning) }() default: break } } } func traverse(visitor: inout V) throws { - if self.enumDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.enumDescriptorProto, fieldNumber: 1) + if self.deprecationWarning != 0 { + try visitor.visitSingularInt32Field(value: self.deprecationWarning, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumDescriptorProto) -> Bool { - if lhs.enumDescriptorProto != rhs.enumDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecationWarning, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecationWarning) -> Bool { + if lhs.deprecationWarning != rhs.deprecationWarning {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".EnumOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "EnumOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.descriptionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".description" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}description\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18794,31 +20071,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumOptions: // 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.enumOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.description_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.enumOptions != 0 { - try visitor.visitSingularInt32Field(value: self.enumOptions, fieldNumber: 1) + if self.description_p != 0 { + try visitor.visitSingularInt32Field(value: self.description_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumOptions) -> Bool { - if lhs.enumOptions != rhs.enumOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.descriptionMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.descriptionMessage) -> Bool { + if lhs.description_p != rhs.description_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumReservedRange: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".EnumReservedRange" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "EnumReservedRange"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Dictionary: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Dictionary" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Dictionary\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18826,31 +20101,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumReservedR // 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.enumReservedRange) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.dictionary) }() default: break } } } func traverse(visitor: inout V) throws { - if self.enumReservedRange != 0 { - try visitor.visitSingularInt32Field(value: self.enumReservedRange, fieldNumber: 1) + if self.dictionary != 0 { + try visitor.visitSingularInt32Field(value: self.dictionary, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumReservedRange, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumReservedRange) -> Bool { - if lhs.enumReservedRange != rhs.enumReservedRange {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Dictionary, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Dictionary) -> Bool { + if lhs.dictionary != rhs.dictionary {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".enumType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "enumType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dictionaryLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".dictionaryLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}dictionaryLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18858,31 +20131,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumType: Swi // 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.enumType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.dictionaryLiteral) }() default: break } } } func traverse(visitor: inout V) throws { - if self.enumType != 0 { - try visitor.visitSingularInt32Field(value: self.enumType, fieldNumber: 1) + if self.dictionaryLiteral != 0 { + try visitor.visitSingularInt32Field(value: self.dictionaryLiteral, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumType) -> Bool { - if lhs.enumType != rhs.enumType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dictionaryLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dictionaryLiteral) -> Bool { + if lhs.dictionaryLiteral != rhs.dictionaryLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumvalue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".enumvalue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "enumvalue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".digit" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}digit\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18890,31 +20161,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumvalue: Sw // 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.enumvalue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.digit) }() default: break } } } func traverse(visitor: inout V) throws { - if self.enumvalue != 0 { - try visitor.visitSingularInt32Field(value: self.enumvalue, fieldNumber: 1) + if self.digit != 0 { + try visitor.visitSingularInt32Field(value: self.digit, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumvalue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumvalue) -> Bool { - if lhs.enumvalue != rhs.enumvalue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit) -> Bool { + if lhs.digit != rhs.digit {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".EnumValueDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "EnumValueDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit0: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".digit0" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}digit0\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18922,31 +20191,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueDesc // 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.enumValueDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.digit0) }() default: break } } } func traverse(visitor: inout V) throws { - if self.enumValueDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.enumValueDescriptorProto, fieldNumber: 1) + if self.digit0 != 0 { + try visitor.visitSingularInt32Field(value: self.digit0, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueDescriptorProto) -> Bool { - if lhs.enumValueDescriptorProto != rhs.enumValueDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit0, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit0) -> Bool { + if lhs.digit0 != rhs.digit0 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".EnumValueOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "EnumValueOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".digit1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}digit1\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18954,31 +20221,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueOpti // 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.enumValueOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.digit1) }() default: break } } } func traverse(visitor: inout V) throws { - if self.enumValueOptions != 0 { - try visitor.visitSingularInt32Field(value: self.enumValueOptions, fieldNumber: 1) + if self.digit1 != 0 { + try visitor.visitSingularInt32Field(value: self.digit1, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueOptions) -> Bool { - if lhs.enumValueOptions != rhs.enumValueOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit1, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit1) -> Bool { + if lhs.digit1 != rhs.digit1 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Equatable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Equatable" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Equatable"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digitCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".digitCount" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}digitCount\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18986,31 +20251,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Equatable: Sw // 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.equatable) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.digitCount) }() default: break } } } func traverse(visitor: inout V) throws { - if self.equatable != 0 { - try visitor.visitSingularInt32Field(value: self.equatable, fieldNumber: 1) + if self.digitCount != 0 { + try visitor.visitSingularInt32Field(value: self.digitCount, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Equatable, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Equatable) -> Bool { - if lhs.equatable != rhs.equatable {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digitCount, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digitCount) -> Bool { + if lhs.digitCount != rhs.digitCount {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Error: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Error" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Error"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".digits" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}digits\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19018,31 +20281,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Error: SwiftP // 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.error) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.digits) }() default: break } } } func traverse(visitor: inout V) throws { - if self.error != 0 { - try visitor.visitSingularInt32Field(value: self.error, fieldNumber: 1) + if self.digits != 0 { + try visitor.visitSingularInt32Field(value: self.digits, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Error, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Error) -> Bool { - if lhs.error != rhs.error {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digits, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digits) -> Bool { + if lhs.digits != rhs.digits {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleByArrayLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ExpressibleByArrayLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ExpressibleByArrayLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digitValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".digitValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}digitValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19050,31 +20311,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleBy // 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.expressibleByArrayLiteral) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.digitValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.expressibleByArrayLiteral != 0 { - try visitor.visitSingularInt32Field(value: self.expressibleByArrayLiteral, fieldNumber: 1) + if self.digitValue != 0 { + try visitor.visitSingularInt32Field(value: self.digitValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleByArrayLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleByArrayLiteral) -> Bool { - if lhs.expressibleByArrayLiteral != rhs.expressibleByArrayLiteral {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digitValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digitValue) -> Bool { + if lhs.digitValue != rhs.digitValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleByDictionaryLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ExpressibleByDictionaryLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ExpressibleByDictionaryLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.discardableResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".discardableResult" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}discardableResult\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19082,31 +20341,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleBy // 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.expressibleByDictionaryLiteral) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.discardableResult) }() default: break } } } func traverse(visitor: inout V) throws { - if self.expressibleByDictionaryLiteral != 0 { - try visitor.visitSingularInt32Field(value: self.expressibleByDictionaryLiteral, fieldNumber: 1) + if self.discardableResult != 0 { + try visitor.visitSingularInt32Field(value: self.discardableResult, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleByDictionaryLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleByDictionaryLiteral) -> Bool { - if lhs.expressibleByDictionaryLiteral != rhs.expressibleByDictionaryLiteral {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.discardableResult, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.discardableResult) -> Bool { + if lhs.discardableResult != rhs.discardableResult {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ext" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ext"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.discardUnknownFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".discardUnknownFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}discardUnknownFields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19114,31 +20371,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ext: SwiftPro // 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.ext) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.discardUnknownFields) }() default: break } } } func traverse(visitor: inout V) throws { - if self.ext != 0 { - try visitor.visitSingularInt32Field(value: self.ext, fieldNumber: 1) + if self.discardUnknownFields != 0 { + try visitor.visitSingularInt32Field(value: self.discardUnknownFields, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ext, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ext) -> Bool { - if lhs.ext != rhs.ext {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.discardUnknownFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.discardUnknownFields) -> Bool { + if lhs.discardUnknownFields != rhs.discardUnknownFields {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".extDecoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DoubleMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Double" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Double\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19146,31 +20401,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extDecoder: S // 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.extDecoder) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.double) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extDecoder != 0 { - try visitor.visitSingularInt32Field(value: self.extDecoder, fieldNumber: 1) + if self.double != 0 { + try visitor.visitSingularInt32Field(value: self.double, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extDecoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extDecoder) -> Bool { - if lhs.extDecoder != rhs.extDecoder {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DoubleMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DoubleMessage) -> Bool { + if lhs.double != rhs.double {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendedGraphemeClusterLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".extendedGraphemeClusterLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extendedGraphemeClusterLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.doubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".doubleValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}doubleValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19178,31 +20431,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendedGraph // 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.extendedGraphemeClusterLiteral) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.doubleValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extendedGraphemeClusterLiteral != 0 { - try visitor.visitSingularInt32Field(value: self.extendedGraphemeClusterLiteral, fieldNumber: 1) + if self.doubleValue != 0 { + try visitor.visitSingularInt32Field(value: self.doubleValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendedGraphemeClusterLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendedGraphemeClusterLiteral) -> Bool { - if lhs.extendedGraphemeClusterLiteral != rhs.extendedGraphemeClusterLiteral {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.doubleValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.doubleValue) -> Bool { + if lhs.doubleValue != rhs.doubleValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtendedGraphemeClusterLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtendedGraphemeClusterLiteralType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ExtendedGraphemeClusterLiteralType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.duration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".duration" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}duration\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19210,31 +20461,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtendedGraph // 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.extendedGraphemeClusterLiteralType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.duration) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extendedGraphemeClusterLiteralType != 0 { - try visitor.visitSingularInt32Field(value: self.extendedGraphemeClusterLiteralType, fieldNumber: 1) + if self.duration != 0 { + try visitor.visitSingularInt32Field(value: self.duration, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtendedGraphemeClusterLiteralType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtendedGraphemeClusterLiteralType) -> Bool { - if lhs.extendedGraphemeClusterLiteralType != rhs.extendedGraphemeClusterLiteralType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.duration, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.duration) -> Bool { + if lhs.duration != rhs.duration {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendee: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".extendee" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extendee"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.E: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".E" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}E\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19242,31 +20491,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendee: Swi // 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.extendee) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.e) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extendee != 0 { - try visitor.visitSingularInt32Field(value: self.extendee, fieldNumber: 1) + if self.e != 0 { + try visitor.visitSingularInt32Field(value: self.e, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendee, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendee) -> Bool { - if lhs.extendee != rhs.extendee {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.E, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.E) -> Bool { + if lhs.e != rhs.e {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensibleMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensibleMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ExtensibleMessage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.edition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".edition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}edition\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19274,31 +20521,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensibleMes // 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.extensibleMessage) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.edition) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extensibleMessage != 0 { - try visitor.visitSingularInt32Field(value: self.extensibleMessage, fieldNumber: 1) + if self.edition != 0 { + try visitor.visitSingularInt32Field(value: self.edition, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensibleMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensibleMessage) -> Bool { - if lhs.extensibleMessage != rhs.extensibleMessage {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.edition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.edition) -> Bool { + if lhs.edition != rhs.edition {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".extension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EditionDefault: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".EditionDefault" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}EditionDefault\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19306,31 +20551,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionMess // 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.`extension`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.editionDefault) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`extension` != 0 { - try visitor.visitSingularInt32Field(value: self.`extension`, fieldNumber: 1) + if self.editionDefault != 0 { + try visitor.visitSingularInt32Field(value: self.editionDefault, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionMessage) -> Bool { - if lhs.`extension` != rhs.`extension` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EditionDefault, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EditionDefault) -> Bool { + if lhs.editionDefault != rhs.editionDefault {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionDefaults: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".editionDefaults" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}editionDefaults\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19338,31 +20581,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionFiel // 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.extensionField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.editionDefaults) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extensionField != 0 { - try visitor.visitSingularInt32Field(value: self.extensionField, fieldNumber: 1) + if self.editionDefaults != 0 { + try visitor.visitSingularInt32Field(value: self.editionDefaults, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionField) -> Bool { - if lhs.extensionField != rhs.extensionField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionDefaults, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionDefaults) -> Bool { + if lhs.editionDefaults != rhs.editionDefaults {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".extensionFieldNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extensionFieldNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionDeprecated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".editionDeprecated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}editionDeprecated\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19370,31 +20611,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionFiel // 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.extensionFieldNumber) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.editionDeprecated) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extensionFieldNumber != 0 { - try visitor.visitSingularInt32Field(value: self.extensionFieldNumber, fieldNumber: 1) + if self.editionDeprecated != 0 { + try visitor.visitSingularInt32Field(value: self.editionDeprecated, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionFieldNumber, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionFieldNumber) -> Bool { - if lhs.extensionFieldNumber != rhs.extensionFieldNumber {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionDeprecated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionDeprecated) -> Bool { + if lhs.editionDeprecated != rhs.editionDeprecated {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionFieldValueSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensionFieldValueSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ExtensionFieldValueSet"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionIntroduced: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".editionIntroduced" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}editionIntroduced\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19402,31 +20641,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionFiel // 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.extensionFieldValueSet) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.editionIntroduced) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extensionFieldValueSet != 0 { - try visitor.visitSingularInt32Field(value: self.extensionFieldValueSet, fieldNumber: 1) + if self.editionIntroduced != 0 { + try visitor.visitSingularInt32Field(value: self.editionIntroduced, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionFieldValueSet, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionFieldValueSet) -> Bool { - if lhs.extensionFieldValueSet != rhs.extensionFieldValueSet {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionIntroduced, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionIntroduced) -> Bool { + if lhs.editionIntroduced != rhs.editionIntroduced {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensionMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ExtensionMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionRemoved: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".editionRemoved" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}editionRemoved\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19434,31 +20671,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionMap: // 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.extensionMap) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.editionRemoved) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extensionMap != 0 { - try visitor.visitSingularInt32Field(value: self.extensionMap, fieldNumber: 1) + if self.editionRemoved != 0 { + try visitor.visitSingularInt32Field(value: self.editionRemoved, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionMap, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionMap) -> Bool { - if lhs.extensionMap != rhs.extensionMap {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionRemoved, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionRemoved) -> Bool { + if lhs.editionRemoved != rhs.editionRemoved {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionRange: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".extensionRange" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extensionRange"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Element: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Element" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Element\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19466,31 +20701,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionRang // 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.extensionRange) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.element) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extensionRange != 0 { - try visitor.visitSingularInt32Field(value: self.extensionRange, fieldNumber: 1) + if self.element != 0 { + try visitor.visitSingularInt32Field(value: self.element, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionRange, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionRange) -> Bool { - if lhs.extensionRange != rhs.extensionRange {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Element, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Element) -> Bool { + if lhs.element != rhs.element {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionRangeOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensionRangeOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ExtensionRangeOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.elements: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".elements" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}elements\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19498,31 +20731,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionRang // 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.extensionRangeOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.elements) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extensionRangeOptions != 0 { - try visitor.visitSingularInt32Field(value: self.extensionRangeOptions, fieldNumber: 1) + if self.elements != 0 { + try visitor.visitSingularInt32Field(value: self.elements, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionRangeOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionRangeOptions) -> Bool { - if lhs.extensionRangeOptions != rhs.extensionRangeOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.elements, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.elements) -> Bool { + if lhs.elements != rhs.elements {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".extensions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extensions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.elseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".else" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}else\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19530,31 +20761,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensions: S // 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.extensions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`else`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extensions != 0 { - try visitor.visitSingularInt32Field(value: self.extensions, fieldNumber: 1) + if self.`else` != 0 { + try visitor.visitSingularInt32Field(value: self.`else`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensions) -> Bool { - if lhs.extensions != rhs.extensions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.elseMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.elseMessage) -> Bool { + if lhs.`else` != rhs.`else` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extras: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".extras" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extras"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitExtensionFieldName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".emitExtensionFieldName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}emitExtensionFieldName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19562,31 +20791,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extras: Swift // 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.extras) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.emitExtensionFieldName) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extras != 0 { - try visitor.visitSingularInt32Field(value: self.extras, fieldNumber: 1) + if self.emitExtensionFieldName != 0 { + try visitor.visitSingularInt32Field(value: self.emitExtensionFieldName, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extras, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extras) -> Bool { - if lhs.extras != rhs.extras {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitExtensionFieldName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitExtensionFieldName) -> Bool { + if lhs.emitExtensionFieldName != rhs.emitExtensionFieldName {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.F: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".F" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "F"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitFieldName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".emitFieldName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}emitFieldName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19594,31 +20821,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.F: SwiftProto // 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.f) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.emitFieldName) }() default: break } } } func traverse(visitor: inout V) throws { - if self.f != 0 { - try visitor.visitSingularInt32Field(value: self.f, fieldNumber: 1) + if self.emitFieldName != 0 { + try visitor.visitSingularInt32Field(value: self.emitFieldName, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.F, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.F) -> Bool { - if lhs.f != rhs.f {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitFieldName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitFieldName) -> Bool { + if lhs.emitFieldName != rhs.emitFieldName {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.falseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".false" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "false"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".emitFieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}emitFieldNumber\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19626,31 +20851,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.falseMessage: // 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.`false`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.emitFieldNumber) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`false` != 0 { - try visitor.visitSingularInt32Field(value: self.`false`, fieldNumber: 1) + if self.emitFieldNumber != 0 { + try visitor.visitSingularInt32Field(value: self.emitFieldNumber, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.falseMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.falseMessage) -> Bool { - if lhs.`false` != rhs.`false` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitFieldNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitFieldNumber) -> Bool { + if lhs.emitFieldNumber != rhs.emitFieldNumber {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emptyAnyTypeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".emptyAnyTypeURL" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}emptyAnyTypeURL\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19658,31 +20881,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.field: SwiftP // 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.field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.emptyAnyTypeURL) }() default: break } } } func traverse(visitor: inout V) throws { - if self.field != 0 { - try visitor.visitSingularInt32Field(value: self.field, fieldNumber: 1) + if self.emptyAnyTypeURL != 0 { + try visitor.visitSingularInt32Field(value: self.emptyAnyTypeURL, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.field) -> Bool { - if lhs.field != rhs.field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emptyAnyTypeURL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emptyAnyTypeURL) -> Bool { + if lhs.emptyAnyTypeURL != rhs.emptyAnyTypeURL {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldData" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fieldData"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emptyData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".emptyData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}emptyData\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19690,31 +20911,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldData: Sw // 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.fieldData) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.emptyData) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldData != 0 { - try visitor.visitSingularInt32Field(value: self.fieldData, fieldNumber: 1) + if self.emptyData != 0 { + try visitor.visitSingularInt32Field(value: self.emptyData, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldData, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldData) -> Bool { - if lhs.fieldData != rhs.fieldData {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emptyData, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emptyData) -> Bool { + if lhs.emptyData != rhs.emptyData {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".FieldDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FieldDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodeAsBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".encodeAsBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}encodeAsBytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19722,31 +20941,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldDescript // 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.fieldDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.encodeAsBytes) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.fieldDescriptorProto, fieldNumber: 1) + if self.encodeAsBytes != 0 { + try visitor.visitSingularInt32Field(value: self.encodeAsBytes, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldDescriptorProto) -> Bool { - if lhs.fieldDescriptorProto != rhs.fieldDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodeAsBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodeAsBytes) -> Bool { + if lhs.encodeAsBytes != rhs.encodeAsBytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldMask: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".FieldMask" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FieldMask"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encoded: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".encoded" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}encoded\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19754,31 +20971,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldMask: Sw // 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.fieldMask) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.encoded) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldMask != 0 { - try visitor.visitSingularInt32Field(value: self.fieldMask, fieldNumber: 1) + if self.encoded != 0 { + try visitor.visitSingularInt32Field(value: self.encoded, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldMask, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldMask) -> Bool { - if lhs.fieldMask != rhs.fieldMask {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encoded, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encoded) -> Bool { + if lhs.encoded != rhs.encoded {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fieldName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodedJSONString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".encodedJSONString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}encodedJSONString\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19786,31 +21001,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldName: Sw // 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.fieldName) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.encodedJsonstring) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldName != 0 { - try visitor.visitSingularInt32Field(value: self.fieldName, fieldNumber: 1) + if self.encodedJsonstring != 0 { + try visitor.visitSingularInt32Field(value: self.encodedJsonstring, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldName) -> Bool { - if lhs.fieldName != rhs.fieldName {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodedJSONString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodedJSONString) -> Bool { + if lhs.encodedJsonstring != rhs.encodedJsonstring {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNameCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldNameCount" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fieldNameCount"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".encodedSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}encodedSize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19818,31 +21031,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNameCoun // 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.fieldNameCount) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.encodedSize) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldNameCount != 0 { - try visitor.visitSingularInt32Field(value: self.fieldNameCount, fieldNumber: 1) + if self.encodedSize != 0 { + try visitor.visitSingularInt32Field(value: self.encodedSize, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNameCount, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNameCount) -> Bool { - if lhs.fieldNameCount != rhs.fieldNameCount {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodedSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodedSize) -> Bool { + if lhs.encodedSize != rhs.encodedSize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldNum" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fieldNum"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodeField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".encodeField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}encodeField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19850,31 +21061,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNum: Swi // 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.fieldNum) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.encodeField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldNum != 0 { - try visitor.visitSingularInt32Field(value: self.fieldNum, fieldNumber: 1) + if self.encodeField != 0 { + try visitor.visitSingularInt32Field(value: self.encodeField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNum, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNum) -> Bool { - if lhs.fieldNum != rhs.fieldNum {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodeField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodeField) -> Bool { + if lhs.encodeField != rhs.encodeField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fieldNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".encoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}encoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19882,31 +21091,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumber: // 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.fieldNumber) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.encoder) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldNumber != 0 { - try visitor.visitSingularInt32Field(value: self.fieldNumber, fieldNumber: 1) + if self.encoder != 0 { + try visitor.visitSingularInt32Field(value: self.encoder, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumber, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumber) -> Bool { - if lhs.fieldNumber != rhs.fieldNumber {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encoder) -> Bool { + if lhs.encoder != rhs.encoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumberForProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldNumberForProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fieldNumberForProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.end: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".end" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}end\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19914,31 +21121,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumberFo // 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.fieldNumberForProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.end) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldNumberForProto != 0 { - try visitor.visitSingularInt32Field(value: self.fieldNumberForProto, fieldNumber: 1) + if self.end != 0 { + try visitor.visitSingularInt32Field(value: self.end, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumberForProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumberForProto) -> Bool { - if lhs.fieldNumberForProto != rhs.fieldNumberForProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.end, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.end) -> Bool { + if lhs.end != rhs.end {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".FieldOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FieldOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endArray: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".endArray" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}endArray\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19946,31 +21151,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldOptions: // 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.fieldOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.endArray) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldOptions != 0 { - try visitor.visitSingularInt32Field(value: self.fieldOptions, fieldNumber: 1) + if self.endArray != 0 { + try visitor.visitSingularInt32Field(value: self.endArray, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldOptions) -> Bool { - if lhs.fieldOptions != rhs.fieldOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endArray, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endArray) -> Bool { + if lhs.endArray != rhs.endArray {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fields"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".endMessageField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}endMessageField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19978,31 +21181,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fields: Swift // 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.fields) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.endMessageField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fields != 0 { - try visitor.visitSingularInt32Field(value: self.fields, fieldNumber: 1) + if self.endMessageField != 0 { + try visitor.visitSingularInt32Field(value: self.endMessageField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fields, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fields) -> Bool { - if lhs.fields != rhs.fields {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endMessageField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endMessageField) -> Bool { + if lhs.endMessageField != rhs.endMessageField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fieldSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endObject: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".endObject" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}endObject\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20010,31 +21211,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldSize: Sw // 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.fieldSize) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.endObject) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldSize != 0 { - try visitor.visitSingularInt32Field(value: self.fieldSize, fieldNumber: 1) + if self.endObject != 0 { + try visitor.visitSingularInt32Field(value: self.endObject, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldSize, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldSize) -> Bool { - if lhs.fieldSize != rhs.fieldSize {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endObject, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endObject) -> Bool { + if lhs.endObject != rhs.endObject {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldTag: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".FieldTag" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FieldTag"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endRegularField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".endRegularField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}endRegularField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20042,31 +21241,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldTag: Swi // 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.fieldTag) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.endRegularField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldTag != 0 { - try visitor.visitSingularInt32Field(value: self.fieldTag, fieldNumber: 1) + if self.endRegularField != 0 { + try visitor.visitSingularInt32Field(value: self.endRegularField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldTag, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldTag) -> Bool { - if lhs.fieldTag != rhs.fieldTag {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endRegularField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endRegularField) -> Bool { + if lhs.endRegularField != rhs.endRegularField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fieldType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enforceNamingStyle: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".enforceNamingStyle" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}enforceNamingStyle\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20074,31 +21271,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldType: Sw // 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.fieldType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.enforceNamingStyle) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldType != 0 { - try visitor.visitSingularInt32Field(value: self.fieldType, fieldNumber: 1) + if self.enforceNamingStyle != 0 { + try visitor.visitSingularInt32Field(value: self.enforceNamingStyle, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldType) -> Bool { - if lhs.fieldType != rhs.fieldType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enforceNamingStyle, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enforceNamingStyle) -> Bool { + if lhs.enforceNamingStyle != rhs.enforceNamingStyle {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.file: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".file" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "file"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".enum" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20106,31 +21301,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.file: SwiftPr // 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.file) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`enum`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.file != 0 { - try visitor.visitSingularInt32Field(value: self.file, fieldNumber: 1) + if self.`enum` != 0 { + try visitor.visitSingularInt32Field(value: self.`enum`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.file, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.file) -> Bool { - if lhs.file != rhs.file {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumMessage) -> Bool { + if lhs.`enum` != rhs.`enum` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".FileDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FileDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumReservedRange: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".EnumReservedRange" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}EnumReservedRange\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20138,31 +21331,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescripto // 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.fileDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.enumReservedRange) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fileDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.fileDescriptorProto, fieldNumber: 1) + if self.enumReservedRange != 0 { + try visitor.visitSingularInt32Field(value: self.enumReservedRange, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescriptorProto) -> Bool { - if lhs.fileDescriptorProto != rhs.fileDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumReservedRange, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumReservedRange) -> Bool { + if lhs.enumReservedRange != rhs.enumReservedRange {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescriptorSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".FileDescriptorSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FileDescriptorSet"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".enumType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}enumType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20170,31 +21361,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescripto // 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.fileDescriptorSet) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.enumType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fileDescriptorSet != 0 { - try visitor.visitSingularInt32Field(value: self.fileDescriptorSet, fieldNumber: 1) + if self.enumType != 0 { + try visitor.visitSingularInt32Field(value: self.enumType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescriptorSet, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescriptorSet) -> Bool { - if lhs.fileDescriptorSet != rhs.fileDescriptorSet {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumType) -> Bool { + if lhs.enumType != rhs.enumType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fileName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fileName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fileName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumvalue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".enumvalue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}enumvalue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20202,31 +21391,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fileName: Swi // 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.fileName) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.enumvalue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fileName != 0 { - try visitor.visitSingularInt32Field(value: self.fileName, fieldNumber: 1) + if self.enumvalue != 0 { + try visitor.visitSingularInt32Field(value: self.enumvalue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fileName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fileName) -> Bool { - if lhs.fileName != rhs.fileName {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumvalue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumvalue) -> Bool { + if lhs.enumvalue != rhs.enumvalue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".FileOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FileOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EquatableMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Equatable" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Equatable\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20234,31 +21421,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileOptions: // 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.fileOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.equatable) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fileOptions != 0 { - try visitor.visitSingularInt32Field(value: self.fileOptions, fieldNumber: 1) + if self.equatable != 0 { + try visitor.visitSingularInt32Field(value: self.equatable, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileOptions) -> Bool { - if lhs.fileOptions != rhs.fileOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EquatableMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EquatableMessage) -> Bool { + if lhs.equatable != rhs.equatable {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.filter: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".filter" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "filter"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Error: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Error" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Error\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20266,31 +21451,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.filter: Swift // 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.filter) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.error) }() default: break } } } func traverse(visitor: inout V) throws { - if self.filter != 0 { - try visitor.visitSingularInt32Field(value: self.filter, fieldNumber: 1) + if self.error != 0 { + try visitor.visitSingularInt32Field(value: self.error, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.filter, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.filter) -> Bool { - if lhs.filter != rhs.filter {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Error, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Error) -> Bool { + if lhs.error != rhs.error {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.first: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".first" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "first"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.execute: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".execute" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}execute\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20298,31 +21481,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.first: SwiftP // 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.first) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.execute) }() default: break } } } func traverse(visitor: inout V) throws { - if self.first != 0 { - try visitor.visitSingularInt32Field(value: self.first, fieldNumber: 1) + if self.execute != 0 { + try visitor.visitSingularInt32Field(value: self.execute, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.first, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.first) -> Bool { - if lhs.first != rhs.first {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.execute, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.execute) -> Bool { + if lhs.execute != rhs.execute {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.firstItem: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".firstItem" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "firstItem"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExpressibleByArrayLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ExpressibleByArrayLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ExpressibleByArrayLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20330,31 +21511,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.firstItem: Sw // 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.firstItem) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.expressibleByArrayLiteral) }() default: break } } } func traverse(visitor: inout V) throws { - if self.firstItem != 0 { - try visitor.visitSingularInt32Field(value: self.firstItem, fieldNumber: 1) + if self.expressibleByArrayLiteral != 0 { + try visitor.visitSingularInt32Field(value: self.expressibleByArrayLiteral, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.firstItem, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.firstItem) -> Bool { - if lhs.firstItem != rhs.firstItem {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExpressibleByArrayLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExpressibleByArrayLiteral) -> Bool { + if lhs.expressibleByArrayLiteral != rhs.expressibleByArrayLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.float: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".float" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "float"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExpressibleByDictionaryLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ExpressibleByDictionaryLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ExpressibleByDictionaryLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20362,31 +21541,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.float: SwiftP // 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.float) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.expressibleByDictionaryLiteral) }() default: break } } } func traverse(visitor: inout V) throws { - if self.float != 0 { - try visitor.visitSingularInt32Field(value: self.float, fieldNumber: 1) + if self.expressibleByDictionaryLiteral != 0 { + try visitor.visitSingularInt32Field(value: self.expressibleByDictionaryLiteral, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.float, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.float) -> Bool { - if lhs.float != rhs.float {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExpressibleByDictionaryLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExpressibleByDictionaryLiteral) -> Bool { + if lhs.expressibleByDictionaryLiteral != rhs.expressibleByDictionaryLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.floatLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".floatLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "floatLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ext" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ext\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20394,31 +21571,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.floatLiteral: // 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.floatLiteral) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.ext) }() default: break } } } func traverse(visitor: inout V) throws { - if self.floatLiteral != 0 { - try visitor.visitSingularInt32Field(value: self.floatLiteral, fieldNumber: 1) + if self.ext != 0 { + try visitor.visitSingularInt32Field(value: self.ext, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.floatLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.floatLiteral) -> Bool { - if lhs.floatLiteral != rhs.floatLiteral {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ext, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ext) -> Bool { + if lhs.ext != rhs.ext {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".FloatLiteralType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FloatLiteralType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".extDecoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extDecoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20426,31 +21601,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatLiteralT // 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.floatLiteralType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extDecoder) }() default: break } } } func traverse(visitor: inout V) throws { - if self.floatLiteralType != 0 { - try visitor.visitSingularInt32Field(value: self.floatLiteralType, fieldNumber: 1) + if self.extDecoder != 0 { + try visitor.visitSingularInt32Field(value: self.extDecoder, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatLiteralType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatLiteralType) -> Bool { - if lhs.floatLiteralType != rhs.floatLiteralType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extDecoder) -> Bool { + if lhs.extDecoder != rhs.extDecoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".FloatValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FloatValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extendedGraphemeClusterLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".extendedGraphemeClusterLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extendedGraphemeClusterLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20458,31 +21631,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatValue: S // 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.floatValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extendedGraphemeClusterLiteral) }() default: break } } } func traverse(visitor: inout V) throws { - if self.floatValue != 0 { - try visitor.visitSingularInt32Field(value: self.floatValue, fieldNumber: 1) + if self.extendedGraphemeClusterLiteral != 0 { + try visitor.visitSingularInt32Field(value: self.extendedGraphemeClusterLiteral, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatValue) -> Bool { - if lhs.floatValue != rhs.floatValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extendedGraphemeClusterLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extendedGraphemeClusterLiteral) -> Bool { + if lhs.extendedGraphemeClusterLiteral != rhs.extendedGraphemeClusterLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forMessageName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".forMessageName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "forMessageName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtendedGraphemeClusterLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtendedGraphemeClusterLiteralType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ExtendedGraphemeClusterLiteralType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20490,31 +21661,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forMessageNam // 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.forMessageName) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extendedGraphemeClusterLiteralType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.forMessageName != 0 { - try visitor.visitSingularInt32Field(value: self.forMessageName, fieldNumber: 1) + if self.extendedGraphemeClusterLiteralType != 0 { + try visitor.visitSingularInt32Field(value: self.extendedGraphemeClusterLiteralType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forMessageName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forMessageName) -> Bool { - if lhs.forMessageName != rhs.forMessageName {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtendedGraphemeClusterLiteralType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtendedGraphemeClusterLiteralType) -> Bool { + if lhs.extendedGraphemeClusterLiteralType != rhs.extendedGraphemeClusterLiteralType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.formUnion: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".formUnion" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "formUnion"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extendee: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".extendee" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extendee\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20522,31 +21691,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.formUnion: Sw // 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.formUnion) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extendee) }() default: break } } } func traverse(visitor: inout V) throws { - if self.formUnion != 0 { - try visitor.visitSingularInt32Field(value: self.formUnion, fieldNumber: 1) + if self.extendee != 0 { + try visitor.visitSingularInt32Field(value: self.extendee, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.formUnion, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.formUnion) -> Bool { - if lhs.formUnion != rhs.formUnion {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extendee, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extendee) -> Bool { + if lhs.extendee != rhs.extendee {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forReadingFrom: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".forReadingFrom" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "forReadingFrom"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensibleMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensibleMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ExtensibleMessage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20554,31 +21721,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forReadingFro // 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.forReadingFrom) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extensibleMessage) }() default: break } } } func traverse(visitor: inout V) throws { - if self.forReadingFrom != 0 { - try visitor.visitSingularInt32Field(value: self.forReadingFrom, fieldNumber: 1) + if self.extensibleMessage != 0 { + try visitor.visitSingularInt32Field(value: self.extensibleMessage, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forReadingFrom, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forReadingFrom) -> Bool { - if lhs.forReadingFrom != rhs.forReadingFrom {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensibleMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensibleMessage) -> Bool { + if lhs.extensibleMessage != rhs.extensibleMessage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forTypeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".forTypeURL" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "forTypeURL"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".extension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20586,31 +21751,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forTypeURL: S // 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.forTypeURL) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`extension`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.forTypeURL != 0 { - try visitor.visitSingularInt32Field(value: self.forTypeURL, fieldNumber: 1) + if self.`extension` != 0 { + try visitor.visitSingularInt32Field(value: self.`extension`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forTypeURL, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forTypeURL) -> Bool { - if lhs.forTypeURL != rhs.forTypeURL {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionMessage) -> Bool { + if lhs.`extension` != rhs.`extension` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ForwardParser: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ForwardParser" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ForwardParser"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20618,31 +21781,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ForwardParser // 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.forwardParser) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extensionField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.forwardParser != 0 { - try visitor.visitSingularInt32Field(value: self.forwardParser, fieldNumber: 1) + if self.extensionField != 0 { + try visitor.visitSingularInt32Field(value: self.extensionField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ForwardParser, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ForwardParser) -> Bool { - if lhs.forwardParser != rhs.forwardParser {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionField) -> Bool { + if lhs.extensionField != rhs.extensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forWritingInto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".forWritingInto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "forWritingInto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".extensionFieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extensionFieldNumber\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20650,31 +21811,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forWritingInt // 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.forWritingInto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extensionFieldNumber) }() default: break } } } func traverse(visitor: inout V) throws { - if self.forWritingInto != 0 { - try visitor.visitSingularInt32Field(value: self.forWritingInto, fieldNumber: 1) + if self.extensionFieldNumber != 0 { + try visitor.visitSingularInt32Field(value: self.extensionFieldNumber, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forWritingInto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forWritingInto) -> Bool { - if lhs.forWritingInto != rhs.forWritingInto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionFieldNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionFieldNumber) -> Bool { + if lhs.extensionFieldNumber != rhs.extensionFieldNumber {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.from: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".from" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "from"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionFieldValueSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensionFieldValueSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ExtensionFieldValueSet\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20682,31 +21841,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.from: SwiftPr // 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.from) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extensionFieldValueSet) }() default: break } } } func traverse(visitor: inout V) throws { - if self.from != 0 { - try visitor.visitSingularInt32Field(value: self.from, fieldNumber: 1) + if self.extensionFieldValueSet != 0 { + try visitor.visitSingularInt32Field(value: self.extensionFieldValueSet, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.from, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.from) -> Bool { - if lhs.from != rhs.from {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionFieldValueSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionFieldValueSet) -> Bool { + if lhs.extensionFieldValueSet != rhs.extensionFieldValueSet {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fromAscii2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fromAscii2"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensionMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ExtensionMap\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20714,31 +21871,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii2: S // 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.fromAscii2) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extensionMap) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fromAscii2 != 0 { - try visitor.visitSingularInt32Field(value: self.fromAscii2, fieldNumber: 1) + if self.extensionMap != 0 { + try visitor.visitSingularInt32Field(value: self.extensionMap, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii2, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii2) -> Bool { - if lhs.fromAscii2 != rhs.fromAscii2 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionMap) -> Bool { + if lhs.extensionMap != rhs.extensionMap {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fromAscii4" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fromAscii4"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionRange: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".extensionRange" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extensionRange\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20746,31 +21901,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii4: S // 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.fromAscii4) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extensionRange) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fromAscii4 != 0 { - try visitor.visitSingularInt32Field(value: self.fromAscii4, fieldNumber: 1) + if self.extensionRange != 0 { + try visitor.visitSingularInt32Field(value: self.extensionRange, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii4, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii4) -> Bool { - if lhs.fromAscii4 != rhs.fromAscii4 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionRange, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionRange) -> Bool { + if lhs.extensionRange != rhs.extensionRange {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromByteOffset: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fromByteOffset" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fromByteOffset"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".extensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extensions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20778,31 +21931,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromByteOffse // 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.fromByteOffset) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extensions) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fromByteOffset != 0 { - try visitor.visitSingularInt32Field(value: self.fromByteOffset, fieldNumber: 1) + if self.extensions != 0 { + try visitor.visitSingularInt32Field(value: self.extensions, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromByteOffset, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromByteOffset) -> Bool { - if lhs.fromByteOffset != rhs.fromByteOffset {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensions) -> Bool { + if lhs.extensions != rhs.extensions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromHexDigit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fromHexDigit" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fromHexDigit"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extras: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".extras" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extras\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20810,31 +21961,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromHexDigit: // 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.fromHexDigit) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extras) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fromHexDigit != 0 { - try visitor.visitSingularInt32Field(value: self.fromHexDigit, fieldNumber: 1) + if self.extras != 0 { + try visitor.visitSingularInt32Field(value: self.extras, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromHexDigit, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromHexDigit) -> Bool { - if lhs.fromHexDigit != rhs.fromHexDigit {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extras, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extras) -> Bool { + if lhs.extras != rhs.extras {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.funcMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".func" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "func"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.F: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".F" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}F\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20842,31 +21991,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.funcMessage: // 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.`func`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.f) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`func` != 0 { - try visitor.visitSingularInt32Field(value: self.`func`, fieldNumber: 1) + if self.f != 0 { + try visitor.visitSingularInt32Field(value: self.f, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.funcMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.funcMessage) -> Bool { - if lhs.`func` != rhs.`func` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.F, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.F) -> Bool { + if lhs.f != rhs.f {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.G: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".G" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "G"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.falseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".false" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}false\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20874,31 +22021,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.G: SwiftProto // 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.g) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`false`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.g != 0 { - try visitor.visitSingularInt32Field(value: self.g, fieldNumber: 1) + if self.`false` != 0 { + try visitor.visitSingularInt32Field(value: self.`false`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.G, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.G) -> Bool { - if lhs.g != rhs.g {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.falseMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.falseMessage) -> Bool { + if lhs.`false` != rhs.`false` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.GeneratedCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".GeneratedCodeInfo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "GeneratedCodeInfo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.features: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".features" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}features\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20906,31 +22051,1289 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.GeneratedCode // 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.generatedCodeInfo) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.features) }() default: break } } } func traverse(visitor: inout V) throws { - if self.generatedCodeInfo != 0 { - try visitor.visitSingularInt32Field(value: self.generatedCodeInfo, fieldNumber: 1) + if self.features != 0 { + try visitor.visitSingularInt32Field(value: self.features, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.GeneratedCodeInfo, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.GeneratedCodeInfo) -> Bool { - if lhs.generatedCodeInfo != rhs.generatedCodeInfo {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.features, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.features) -> Bool { + if lhs.features != rhs.features {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.get: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".get" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "get"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FeatureSetEditionDefault: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".FeatureSetEditionDefault" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FeatureSetEditionDefault\0") + + 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.featureSetEditionDefault) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.featureSetEditionDefault != 0 { + try visitor.visitSingularInt32Field(value: self.featureSetEditionDefault, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FeatureSetEditionDefault, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FeatureSetEditionDefault) -> Bool { + if lhs.featureSetEditionDefault != rhs.featureSetEditionDefault {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.featureSupport: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".featureSupport" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}featureSupport\0") + + 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.featureSupport) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.featureSupport != 0 { + try visitor.visitSingularInt32Field(value: self.featureSupport, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.featureSupport, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.featureSupport) -> Bool { + if lhs.featureSupport != rhs.featureSupport {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field\0") + + 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.field) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.field != 0 { + try visitor.visitSingularInt32Field(value: self.field, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.field) -> Bool { + if lhs.field != rhs.field {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fieldData\0") + + 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.fieldData) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldData != 0 { + try visitor.visitSingularInt32Field(value: self.fieldData, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldData, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldData) -> Bool { + if lhs.fieldData != rhs.fieldData {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldMaskError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".FieldMaskError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FieldMaskError\0") + + 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.fieldMaskError) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldMaskError != 0 { + try visitor.visitSingularInt32Field(value: self.fieldMaskError, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldMaskError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldMaskError) -> Bool { + if lhs.fieldMaskError != rhs.fieldMaskError {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fieldName\0") + + 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.fieldName) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldName != 0 { + try visitor.visitSingularInt32Field(value: self.fieldName, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldName) -> Bool { + if lhs.fieldName != rhs.fieldName {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNameCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldNameCount" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fieldNameCount\0") + + 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.fieldNameCount) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldNameCount != 0 { + try visitor.visitSingularInt32Field(value: self.fieldNameCount, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNameCount, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNameCount) -> Bool { + if lhs.fieldNameCount != rhs.fieldNameCount {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldNum" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fieldNum\0") + + 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.fieldNum) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldNum != 0 { + try visitor.visitSingularInt32Field(value: self.fieldNum, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNum, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNum) -> Bool { + if lhs.fieldNum != rhs.fieldNum {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fieldNumber\0") + + 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.fieldNumber) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldNumber != 0 { + try visitor.visitSingularInt32Field(value: self.fieldNumber, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNumber) -> Bool { + if lhs.fieldNumber != rhs.fieldNumber {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNumberForProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldNumberForProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fieldNumberForProto\0") + + 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.fieldNumberForProto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldNumberForProto != 0 { + try visitor.visitSingularInt32Field(value: self.fieldNumberForProto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNumberForProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNumberForProto) -> Bool { + if lhs.fieldNumberForProto != rhs.fieldNumberForProto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldPresence: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldPresence" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fieldPresence\0") + + 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.fieldPresence) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldPresence != 0 { + try visitor.visitSingularInt32Field(value: self.fieldPresence, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldPresence, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldPresence) -> Bool { + if lhs.fieldPresence != rhs.fieldPresence {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fields\0") + + 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.fields) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fields != 0 { + try visitor.visitSingularInt32Field(value: self.fields, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fields) -> Bool { + if lhs.fields != rhs.fields {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fieldSize\0") + + 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.fieldSize) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldSize != 0 { + try visitor.visitSingularInt32Field(value: self.fieldSize, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldSize) -> Bool { + if lhs.fieldSize != rhs.fieldSize {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldTag: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".FieldTag" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FieldTag\0") + + 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.fieldTag) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldTag != 0 { + try visitor.visitSingularInt32Field(value: self.fieldTag, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldTag, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldTag) -> Bool { + if lhs.fieldTag != rhs.fieldTag {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".FieldType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FieldType\0") + + 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.fieldType) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldType != 0 { + try visitor.visitSingularInt32Field(value: self.fieldType, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldType) -> Bool { + if lhs.fieldType != rhs.fieldType {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.file: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".file" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}file\0") + + 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.file) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.file != 0 { + try visitor.visitSingularInt32Field(value: self.file, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.file, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.file) -> Bool { + if lhs.file != rhs.file {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fileName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fileName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fileName\0") + + 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.fileName) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fileName != 0 { + try visitor.visitSingularInt32Field(value: self.fileName, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fileName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fileName) -> Bool { + if lhs.fileName != rhs.fileName {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.filter: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".filter" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}filter\0") + + 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.filter) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.filter != 0 { + try visitor.visitSingularInt32Field(value: self.filter, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.filter, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.filter) -> Bool { + if lhs.filter != rhs.filter {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.final: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".final" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}final\0") + + 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.final) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.final != 0 { + try visitor.visitSingularInt32Field(value: self.final, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.final, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.final) -> Bool { + if lhs.final != rhs.final {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.finiteOnly: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".finiteOnly" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}finiteOnly\0") + + 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.finiteOnly) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.finiteOnly != 0 { + try visitor.visitSingularInt32Field(value: self.finiteOnly, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.finiteOnly, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.finiteOnly) -> Bool { + if lhs.finiteOnly != rhs.finiteOnly {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.first: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".first" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}first\0") + + 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.first) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.first != 0 { + try visitor.visitSingularInt32Field(value: self.first, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.first, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.first) -> Bool { + if lhs.first != rhs.first {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.firstItem: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".firstItem" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}firstItem\0") + + 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.firstItem) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.firstItem != 0 { + try visitor.visitSingularInt32Field(value: self.firstItem, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.firstItem, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.firstItem) -> Bool { + if lhs.firstItem != rhs.firstItem {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fixedFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fixedFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fixedFeatures\0") + + 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.fixedFeatures) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fixedFeatures != 0 { + try visitor.visitSingularInt32Field(value: self.fixedFeatures, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fixedFeatures, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fixedFeatures) -> Bool { + if lhs.fixedFeatures != rhs.fixedFeatures {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Float" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Float\0") + + 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.float) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.float != 0 { + try visitor.visitSingularInt32Field(value: self.float, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatMessage) -> Bool { + if lhs.float != rhs.float {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.floatLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".floatLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}floatLiteral\0") + + 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.floatLiteral) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.floatLiteral != 0 { + try visitor.visitSingularInt32Field(value: self.floatLiteral, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.floatLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.floatLiteral) -> Bool { + if lhs.floatLiteral != rhs.floatLiteral {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".FloatLiteralType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FloatLiteralType\0") + + 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.floatLiteralType) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.floatLiteralType != 0 { + try visitor.visitSingularInt32Field(value: self.floatLiteralType, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatLiteralType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatLiteralType) -> Bool { + if lhs.floatLiteralType != rhs.floatLiteralType {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".for" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}for\0") + + 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.`for`) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.`for` != 0 { + try visitor.visitSingularInt32Field(value: self.`for`, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forMessage) -> Bool { + if lhs.`for` != rhs.`for` {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forMessageName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".forMessageName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}forMessageName\0") + + 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.forMessageName) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.forMessageName != 0 { + try visitor.visitSingularInt32Field(value: self.forMessageName, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forMessageName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forMessageName) -> Bool { + if lhs.forMessageName != rhs.forMessageName {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.formUnion: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".formUnion" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}formUnion\0") + + 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.formUnion) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.formUnion != 0 { + try visitor.visitSingularInt32Field(value: self.formUnion, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.formUnion, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.formUnion) -> Bool { + if lhs.formUnion != rhs.formUnion {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forReadingFrom: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".forReadingFrom" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}forReadingFrom\0") + + 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.forReadingFrom) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.forReadingFrom != 0 { + try visitor.visitSingularInt32Field(value: self.forReadingFrom, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forReadingFrom, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forReadingFrom) -> Bool { + if lhs.forReadingFrom != rhs.forReadingFrom {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forTypeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".forTypeURL" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}forTypeURL\0") + + 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.forTypeURL) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.forTypeURL != 0 { + try visitor.visitSingularInt32Field(value: self.forTypeURL, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forTypeURL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forTypeURL) -> Bool { + if lhs.forTypeURL != rhs.forTypeURL {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ForwardParser: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ForwardParser" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ForwardParser\0") + + 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.forwardParser) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.forwardParser != 0 { + try visitor.visitSingularInt32Field(value: self.forwardParser, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ForwardParser, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ForwardParser) -> Bool { + if lhs.forwardParser != rhs.forwardParser {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forWritingInto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".forWritingInto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}forWritingInto\0") + + 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.forWritingInto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.forWritingInto != 0 { + try visitor.visitSingularInt32Field(value: self.forWritingInto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forWritingInto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forWritingInto) -> Bool { + if lhs.forWritingInto != rhs.forWritingInto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.from: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".from" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}from\0") + + 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.from) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.from != 0 { + try visitor.visitSingularInt32Field(value: self.from, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.from, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.from) -> Bool { + if lhs.from != rhs.from {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromAscii2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fromAscii2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fromAscii2\0") + + 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.fromAscii2) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fromAscii2 != 0 { + try visitor.visitSingularInt32Field(value: self.fromAscii2, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromAscii2, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromAscii2) -> Bool { + if lhs.fromAscii2 != rhs.fromAscii2 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromAscii4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fromAscii4" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fromAscii4\0") + + 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.fromAscii4) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fromAscii4 != 0 { + try visitor.visitSingularInt32Field(value: self.fromAscii4, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromAscii4, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromAscii4) -> Bool { + if lhs.fromAscii4 != rhs.fromAscii4 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromByteOffset: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fromByteOffset" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fromByteOffset\0") + + 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.fromByteOffset) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fromByteOffset != 0 { + try visitor.visitSingularInt32Field(value: self.fromByteOffset, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromByteOffset, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromByteOffset) -> Bool { + if lhs.fromByteOffset != rhs.fromByteOffset {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromHexDigit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fromHexDigit" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fromHexDigit\0") + + 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.fromHexDigit) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fromHexDigit != 0 { + try visitor.visitSingularInt32Field(value: self.fromHexDigit, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromHexDigit, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromHexDigit) -> Bool { + if lhs.fromHexDigit != rhs.fromHexDigit {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fullName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fullName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fullName\0") + + 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.fullName) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fullName != 0 { + try visitor.visitSingularInt32Field(value: self.fullName, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fullName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fullName) -> Bool { + if lhs.fullName != rhs.fullName {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.funcMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".func" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}func\0") + + 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.`func`) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.`func` != 0 { + try visitor.visitSingularInt32Field(value: self.`func`, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.funcMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.funcMessage) -> Bool { + if lhs.`func` != rhs.`func` {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.function: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".function" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}function\0") + + 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.function) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.function != 0 { + try visitor.visitSingularInt32Field(value: self.function, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.function, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.function) -> Bool { + if lhs.function != rhs.function {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.G: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".G" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}G\0") + + 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.g) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.g != 0 { + try visitor.visitSingularInt32Field(value: self.g, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.G, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.G) -> Bool { + if lhs.g != rhs.g {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.get: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".get" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}get\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20945,24 +23348,1522 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.get: SwiftPro } func traverse(visitor: inout V) throws { - if self.get != 0 { - try visitor.visitSingularInt32Field(value: self.get, fieldNumber: 1) + if self.get != 0 { + try visitor.visitSingularInt32Field(value: self.get, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.get, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.get) -> Bool { + if lhs.get != rhs.get {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.getExtensionValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".getExtensionValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}getExtensionValue\0") + + 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.getExtensionValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.getExtensionValue != 0 { + try visitor.visitSingularInt32Field(value: self.getExtensionValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.getExtensionValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.getExtensionValue) -> Bool { + if lhs.getExtensionValue != rhs.getExtensionValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Any: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Any" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Any\0") + + 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.googleProtobufAny) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufAny != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufAny, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Any, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Any) -> Bool { + if lhs.googleProtobufAny != rhs.googleProtobufAny {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Api: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Api" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Api\0") + + 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.googleProtobufApi) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufApi != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufApi, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Api, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Api) -> Bool { + if lhs.googleProtobufApi != rhs.googleProtobufApi {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_BoolValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_BoolValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_BoolValue\0") + + 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.googleProtobufBoolValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufBoolValue != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufBoolValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_BoolValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_BoolValue) -> Bool { + if lhs.googleProtobufBoolValue != rhs.googleProtobufBoolValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_BytesValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_BytesValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_BytesValue\0") + + 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.googleProtobufBytesValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufBytesValue != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufBytesValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_BytesValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_BytesValue) -> Bool { + if lhs.googleProtobufBytesValue != rhs.googleProtobufBytesValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_DescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_DescriptorProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_DescriptorProto\0") + + 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.googleProtobufDescriptorProto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufDescriptorProto != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufDescriptorProto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_DescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_DescriptorProto) -> Bool { + if lhs.googleProtobufDescriptorProto != rhs.googleProtobufDescriptorProto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_DoubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_DoubleValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_DoubleValue\0") + + 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.googleProtobufDoubleValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufDoubleValue != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufDoubleValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_DoubleValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_DoubleValue) -> Bool { + if lhs.googleProtobufDoubleValue != rhs.googleProtobufDoubleValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Duration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Duration" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Duration\0") + + 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.googleProtobufDuration) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufDuration != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufDuration, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Duration, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Duration) -> Bool { + if lhs.googleProtobufDuration != rhs.googleProtobufDuration {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Edition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Edition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Edition\0") + + 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.googleProtobufEdition) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufEdition != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufEdition, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Edition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Edition) -> Bool { + if lhs.googleProtobufEdition != rhs.googleProtobufEdition {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Empty: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Empty" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Empty\0") + + 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.googleProtobufEmpty) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufEmpty != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufEmpty, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Empty, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Empty) -> Bool { + if lhs.googleProtobufEmpty != rhs.googleProtobufEmpty {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Enum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Enum" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Enum\0") + + 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.googleProtobufEnum) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufEnum != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufEnum, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Enum, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Enum) -> Bool { + if lhs.googleProtobufEnum != rhs.googleProtobufEnum {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumDescriptorProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_EnumDescriptorProto\0") + + 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.googleProtobufEnumDescriptorProto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufEnumDescriptorProto != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufEnumDescriptorProto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumDescriptorProto) -> Bool { + if lhs.googleProtobufEnumDescriptorProto != rhs.googleProtobufEnumDescriptorProto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_EnumOptions\0") + + 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.googleProtobufEnumOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufEnumOptions != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufEnumOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumOptions) -> Bool { + if lhs.googleProtobufEnumOptions != rhs.googleProtobufEnumOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_EnumValue\0") + + 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.googleProtobufEnumValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufEnumValue != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufEnumValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValue) -> Bool { + if lhs.googleProtobufEnumValue != rhs.googleProtobufEnumValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumValueDescriptorProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_EnumValueDescriptorProto\0") + + 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.googleProtobufEnumValueDescriptorProto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufEnumValueDescriptorProto != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufEnumValueDescriptorProto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueDescriptorProto) -> Bool { + if lhs.googleProtobufEnumValueDescriptorProto != rhs.googleProtobufEnumValueDescriptorProto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumValueOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_EnumValueOptions\0") + + 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.googleProtobufEnumValueOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufEnumValueOptions != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufEnumValueOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueOptions) -> Bool { + if lhs.googleProtobufEnumValueOptions != rhs.googleProtobufEnumValueOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_ExtensionRangeOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_ExtensionRangeOptions\0") + + 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.googleProtobufExtensionRangeOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufExtensionRangeOptions != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufExtensionRangeOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ExtensionRangeOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ExtensionRangeOptions) -> Bool { + if lhs.googleProtobufExtensionRangeOptions != rhs.googleProtobufExtensionRangeOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FeatureSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FeatureSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_FeatureSet\0") + + 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.googleProtobufFeatureSet) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufFeatureSet != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufFeatureSet, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FeatureSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FeatureSet) -> Bool { + if lhs.googleProtobufFeatureSet != rhs.googleProtobufFeatureSet {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FeatureSetDefaults: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FeatureSetDefaults" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_FeatureSetDefaults\0") + + 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.googleProtobufFeatureSetDefaults) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufFeatureSetDefaults != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufFeatureSetDefaults, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FeatureSetDefaults, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FeatureSetDefaults) -> Bool { + if lhs.googleProtobufFeatureSetDefaults != rhs.googleProtobufFeatureSetDefaults {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Field\0") + + 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.googleProtobufField) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufField != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufField, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Field) -> Bool { + if lhs.googleProtobufField != rhs.googleProtobufField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FieldDescriptorProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_FieldDescriptorProto\0") + + 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.googleProtobufFieldDescriptorProto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufFieldDescriptorProto != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufFieldDescriptorProto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldDescriptorProto) -> Bool { + if lhs.googleProtobufFieldDescriptorProto != rhs.googleProtobufFieldDescriptorProto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldMask: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FieldMask" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_FieldMask\0") + + 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.googleProtobufFieldMask) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufFieldMask != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufFieldMask, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldMask, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldMask) -> Bool { + if lhs.googleProtobufFieldMask != rhs.googleProtobufFieldMask {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FieldOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_FieldOptions\0") + + 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.googleProtobufFieldOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufFieldOptions != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufFieldOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldOptions) -> Bool { + if lhs.googleProtobufFieldOptions != rhs.googleProtobufFieldOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FileDescriptorProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_FileDescriptorProto\0") + + 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.googleProtobufFileDescriptorProto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufFileDescriptorProto != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufFileDescriptorProto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorProto) -> Bool { + if lhs.googleProtobufFileDescriptorProto != rhs.googleProtobufFileDescriptorProto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FileDescriptorSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_FileDescriptorSet\0") + + 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.googleProtobufFileDescriptorSet) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufFileDescriptorSet != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufFileDescriptorSet, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorSet) -> Bool { + if lhs.googleProtobufFileDescriptorSet != rhs.googleProtobufFileDescriptorSet {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FileOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_FileOptions\0") + + 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.googleProtobufFileOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufFileOptions != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufFileOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileOptions) -> Bool { + if lhs.googleProtobufFileOptions != rhs.googleProtobufFileOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FloatValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FloatValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_FloatValue\0") + + 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.googleProtobufFloatValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufFloatValue != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufFloatValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FloatValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FloatValue) -> Bool { + if lhs.googleProtobufFloatValue != rhs.googleProtobufFloatValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_GeneratedCodeInfo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_GeneratedCodeInfo\0") + + 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.googleProtobufGeneratedCodeInfo) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufGeneratedCodeInfo != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufGeneratedCodeInfo, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_GeneratedCodeInfo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_GeneratedCodeInfo) -> Bool { + if lhs.googleProtobufGeneratedCodeInfo != rhs.googleProtobufGeneratedCodeInfo {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Int32Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Int32Value" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Int32Value\0") + + 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.googleProtobufInt32Value) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufInt32Value != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufInt32Value, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Int32Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Int32Value) -> Bool { + if lhs.googleProtobufInt32Value != rhs.googleProtobufInt32Value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Int64Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Int64Value" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Int64Value\0") + + 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.googleProtobufInt64Value) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufInt64Value != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufInt64Value, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Int64Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Int64Value) -> Bool { + if lhs.googleProtobufInt64Value != rhs.googleProtobufInt64Value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ListValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_ListValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_ListValue\0") + + 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.googleProtobufListValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufListValue != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufListValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ListValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ListValue) -> Bool { + if lhs.googleProtobufListValue != rhs.googleProtobufListValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MessageOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_MessageOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_MessageOptions\0") + + 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.googleProtobufMessageOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufMessageOptions != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufMessageOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MessageOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MessageOptions) -> Bool { + if lhs.googleProtobufMessageOptions != rhs.googleProtobufMessageOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Method: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Method" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Method\0") + + 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.googleProtobufMethod) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufMethod != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufMethod, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Method, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Method) -> Bool { + if lhs.googleProtobufMethod != rhs.googleProtobufMethod {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_MethodDescriptorProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_MethodDescriptorProto\0") + + 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.googleProtobufMethodDescriptorProto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufMethodDescriptorProto != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufMethodDescriptorProto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodDescriptorProto) -> Bool { + if lhs.googleProtobufMethodDescriptorProto != rhs.googleProtobufMethodDescriptorProto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_MethodOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_MethodOptions\0") + + 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.googleProtobufMethodOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufMethodOptions != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufMethodOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodOptions) -> Bool { + if lhs.googleProtobufMethodOptions != rhs.googleProtobufMethodOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Mixin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Mixin" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Mixin\0") + + 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.googleProtobufMixin) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufMixin != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufMixin, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Mixin, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Mixin) -> Bool { + if lhs.googleProtobufMixin != rhs.googleProtobufMixin {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_NullValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_NullValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_NullValue\0") + + 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.googleProtobufNullValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufNullValue != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufNullValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_NullValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_NullValue) -> Bool { + if lhs.googleProtobufNullValue != rhs.googleProtobufNullValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_OneofDescriptorProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_OneofDescriptorProto\0") + + 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.googleProtobufOneofDescriptorProto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufOneofDescriptorProto != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufOneofDescriptorProto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofDescriptorProto) -> Bool { + if lhs.googleProtobufOneofDescriptorProto != rhs.googleProtobufOneofDescriptorProto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_OneofOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_OneofOptions\0") + + 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.googleProtobufOneofOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufOneofOptions != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufOneofOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofOptions) -> Bool { + if lhs.googleProtobufOneofOptions != rhs.googleProtobufOneofOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Option: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Option" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Option\0") + + 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.googleProtobufOption) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufOption != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufOption, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Option, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Option) -> Bool { + if lhs.googleProtobufOption != rhs.googleProtobufOption {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_ServiceDescriptorProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_ServiceDescriptorProto\0") + + 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.googleProtobufServiceDescriptorProto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufServiceDescriptorProto != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufServiceDescriptorProto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceDescriptorProto) -> Bool { + if lhs.googleProtobufServiceDescriptorProto != rhs.googleProtobufServiceDescriptorProto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_ServiceOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_ServiceOptions\0") + + 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.googleProtobufServiceOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufServiceOptions != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufServiceOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceOptions) -> Bool { + if lhs.googleProtobufServiceOptions != rhs.googleProtobufServiceOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_SourceCodeInfo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_SourceCodeInfo\0") + + 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.googleProtobufSourceCodeInfo) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufSourceCodeInfo != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufSourceCodeInfo, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceCodeInfo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceCodeInfo) -> Bool { + if lhs.googleProtobufSourceCodeInfo != rhs.googleProtobufSourceCodeInfo {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceContext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_SourceContext" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_SourceContext\0") + + 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.googleProtobufSourceContext) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufSourceContext != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufSourceContext, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceContext, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceContext) -> Bool { + if lhs.googleProtobufSourceContext != rhs.googleProtobufSourceContext {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_StringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_StringValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_StringValue\0") + + 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.googleProtobufStringValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufStringValue != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufStringValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_StringValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_StringValue) -> Bool { + if lhs.googleProtobufStringValue != rhs.googleProtobufStringValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Struct: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Struct" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Struct\0") + + 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.googleProtobufStruct) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufStruct != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufStruct, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Struct, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Struct) -> Bool { + if lhs.googleProtobufStruct != rhs.googleProtobufStruct {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SymbolVisibility: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_SymbolVisibility" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_SymbolVisibility\0") + + 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.googleProtobufSymbolVisibility) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufSymbolVisibility != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufSymbolVisibility, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SymbolVisibility, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SymbolVisibility) -> Bool { + if lhs.googleProtobufSymbolVisibility != rhs.googleProtobufSymbolVisibility {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Syntax: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Syntax" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Syntax\0") + + 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.googleProtobufSyntax) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufSyntax != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufSyntax, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Syntax, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Syntax) -> Bool { + if lhs.googleProtobufSyntax != rhs.googleProtobufSyntax {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Timestamp: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Timestamp" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Timestamp\0") + + 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.googleProtobufTimestamp) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufTimestamp != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufTimestamp, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Timestamp, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Timestamp) -> Bool { + if lhs.googleProtobufTimestamp != rhs.googleProtobufTimestamp {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Type: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Type" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Type\0") + + 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.googleProtobufType) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufType != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.get, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.get) -> Bool { - if lhs.get != rhs.get {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Type, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Type) -> Bool { + if lhs.googleProtobufType != rhs.googleProtobufType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.getExtensionValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".getExtensionValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "getExtensionValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt32Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_UInt32Value" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_UInt32Value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20970,31 +24871,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.getExtensionV // 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.getExtensionValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.googleProtobufUint32Value) }() default: break } } } func traverse(visitor: inout V) throws { - if self.getExtensionValue != 0 { - try visitor.visitSingularInt32Field(value: self.getExtensionValue, fieldNumber: 1) + if self.googleProtobufUint32Value != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufUint32Value, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.getExtensionValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.getExtensionValue) -> Bool { - if lhs.getExtensionValue != rhs.getExtensionValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt32Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt32Value) -> Bool { + if lhs.googleProtobufUint32Value != rhs.googleProtobufUint32Value {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.googleapis: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".googleapis" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "googleapis"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt64Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_UInt64Value" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_UInt64Value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21002,31 +24901,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.googleapis: S // 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.googleapis) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.googleProtobufUint64Value) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleapis != 0 { - try visitor.visitSingularInt32Field(value: self.googleapis, fieldNumber: 1) + if self.googleProtobufUint64Value != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufUint64Value, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.googleapis, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.googleapis) -> Bool { - if lhs.googleapis != rhs.googleapis {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt64Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt64Value) -> Bool { + if lhs.googleProtobufUint64Value != rhs.googleProtobufUint64Value {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Any: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Any" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Any"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UninterpretedOption: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_UninterpretedOption" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_UninterpretedOption\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21034,31 +24931,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufAny) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.googleProtobufUninterpretedOption) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufAny != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufAny, fieldNumber: 1) + if self.googleProtobufUninterpretedOption != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufUninterpretedOption, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Any, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Any) -> Bool { - if lhs.googleProtobufAny != rhs.googleProtobufAny {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UninterpretedOption, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UninterpretedOption) -> Bool { + if lhs.googleProtobufUninterpretedOption != rhs.googleProtobufUninterpretedOption {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Api: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Api" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Api"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Value" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21066,31 +24961,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufApi) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.googleProtobufValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufApi != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufApi, fieldNumber: 1) + if self.googleProtobufValue != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Api, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Api) -> Bool { - if lhs.googleProtobufApi != rhs.googleProtobufApi {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Value) -> Bool { + if lhs.googleProtobufValue != rhs.googleProtobufValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_BoolValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_BoolValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_BoolValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.goPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".goPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}goPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21098,31 +24991,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufBoolValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.goPackage) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufBoolValue != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufBoolValue, fieldNumber: 1) + if self.goPackage != 0 { + try visitor.visitSingularInt32Field(value: self.goPackage, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_BoolValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_BoolValue) -> Bool { - if lhs.googleProtobufBoolValue != rhs.googleProtobufBoolValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.goPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.goPackage) -> Bool { + if lhs.goPackage != rhs.goPackage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_BytesValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_BytesValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_BytesValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.gotData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".gotData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}gotData\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21130,31 +25021,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufBytesValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.gotData) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufBytesValue != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufBytesValue, fieldNumber: 1) + if self.gotData != 0 { + try visitor.visitSingularInt32Field(value: self.gotData, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_BytesValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_BytesValue) -> Bool { - if lhs.googleProtobufBytesValue != rhs.googleProtobufBytesValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.gotData, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.gotData) -> Bool { + if lhs.gotData != rhs.gotData {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_DescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_DescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_DescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.group: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".group" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}group\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21162,31 +25051,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.group) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufDescriptorProto, fieldNumber: 1) + if self.group != 0 { + try visitor.visitSingularInt32Field(value: self.group, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_DescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_DescriptorProto) -> Bool { - if lhs.googleProtobufDescriptorProto != rhs.googleProtobufDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.group, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.group) -> Bool { + if lhs.group != rhs.group {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_DoubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_DoubleValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_DoubleValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.groupFieldNumberStack: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".groupFieldNumberStack" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}groupFieldNumberStack\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21194,31 +25081,569 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufDoubleValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.groupFieldNumberStack) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufDoubleValue != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufDoubleValue, fieldNumber: 1) + if self.groupFieldNumberStack != 0 { + try visitor.visitSingularInt32Field(value: self.groupFieldNumberStack, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_DoubleValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_DoubleValue) -> Bool { - if lhs.googleProtobufDoubleValue != rhs.googleProtobufDoubleValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.groupFieldNumberStack, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.groupFieldNumberStack) -> Bool { + if lhs.groupFieldNumberStack != rhs.groupFieldNumberStack {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.groupSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".groupSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}groupSize\0") + + 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.groupSize) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.groupSize != 0 { + try visitor.visitSingularInt32Field(value: self.groupSize, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.groupSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.groupSize) -> Bool { + if lhs.groupSize != rhs.groupSize {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.guardMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".guard" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}guard\0") + + 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.`guard`) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.`guard` != 0 { + try visitor.visitSingularInt32Field(value: self.`guard`, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.guardMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.guardMessage) -> Bool { + if lhs.`guard` != rhs.`guard` {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hadOneofValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hadOneofValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hadOneofValue\0") + + 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.hadOneofValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hadOneofValue != 0 { + try visitor.visitSingularInt32Field(value: self.hadOneofValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hadOneofValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hadOneofValue) -> Bool { + if lhs.hadOneofValue != rhs.hadOneofValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.handleConflictingOneOf: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".handleConflictingOneOf" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}handleConflictingOneOf\0") + + 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.handleConflictingOneOf) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.handleConflictingOneOf != 0 { + try visitor.visitSingularInt32Field(value: self.handleConflictingOneOf, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.handleConflictingOneOf, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.handleConflictingOneOf) -> Bool { + if lhs.handleConflictingOneOf != rhs.handleConflictingOneOf {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.handleInstruction: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".handleInstruction" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}handleInstruction\0") + + 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.handleInstruction) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.handleInstruction != 0 { + try visitor.visitSingularInt32Field(value: self.handleInstruction, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.handleInstruction, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.handleInstruction) -> Bool { + if lhs.handleInstruction != rhs.handleInstruction {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasAggregateValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasAggregateValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasAggregateValue\0") + + 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.hasAggregateValue_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasAggregateValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasAggregateValue_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasAggregateValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasAggregateValue) -> Bool { + if lhs.hasAggregateValue_p != rhs.hasAggregateValue_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasAllowAlias: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasAllowAlias" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasAllowAlias\0") + + 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.hasAllowAlias_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasAllowAlias_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasAllowAlias_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasAllowAlias, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasAllowAlias) -> Bool { + if lhs.hasAllowAlias_p != rhs.hasAllowAlias_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasBegin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasBegin" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasBegin\0") + + 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.hasBegin_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasBegin_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasBegin_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasBegin, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasBegin) -> Bool { + if lhs.hasBegin_p != rhs.hasBegin_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCcEnableArenas: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasCcEnableArenas" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasCcEnableArenas\0") + + 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.hasCcEnableArenas_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasCcEnableArenas_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasCcEnableArenas_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCcEnableArenas, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCcEnableArenas) -> Bool { + if lhs.hasCcEnableArenas_p != rhs.hasCcEnableArenas_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCcGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasCcGenericServices" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasCcGenericServices\0") + + 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.hasCcGenericServices_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasCcGenericServices_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasCcGenericServices_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCcGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCcGenericServices) -> Bool { + if lhs.hasCcGenericServices_p != rhs.hasCcGenericServices_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasClientStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasClientStreaming" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasClientStreaming\0") + + 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.hasClientStreaming_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasClientStreaming_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasClientStreaming_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasClientStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasClientStreaming) -> Bool { + if lhs.hasClientStreaming_p != rhs.hasClientStreaming_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCsharpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasCsharpNamespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasCsharpNamespace\0") + + 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.hasCsharpNamespace_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasCsharpNamespace_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasCsharpNamespace_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCsharpNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCsharpNamespace) -> Bool { + if lhs.hasCsharpNamespace_p != rhs.hasCsharpNamespace_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCtype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasCtype" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasCtype\0") + + 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.hasCtype_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasCtype_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasCtype_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCtype, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCtype) -> Bool { + if lhs.hasCtype_p != rhs.hasCtype_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasData\0") + + 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.hasData_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasData_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasData_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasData, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasData) -> Bool { + if lhs.hasData_p != rhs.hasData_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDebugRedact: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDebugRedact" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasDebugRedact\0") + + 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.hasDebugRedact_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasDebugRedact_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasDebugRedact_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDebugRedact, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDebugRedact) -> Bool { + if lhs.hasDebugRedact_p != rhs.hasDebugRedact_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDefaultSymbolVisibility: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDefaultSymbolVisibility" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasDefaultSymbolVisibility\0") + + 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.hasDefaultSymbolVisibility_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasDefaultSymbolVisibility_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasDefaultSymbolVisibility_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDefaultSymbolVisibility, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDefaultSymbolVisibility) -> Bool { + if lhs.hasDefaultSymbolVisibility_p != rhs.hasDefaultSymbolVisibility_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDefaultValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDefaultValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasDefaultValue\0") + + 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.hasDefaultValue_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasDefaultValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasDefaultValue_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDefaultValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDefaultValue) -> Bool { + if lhs.hasDefaultValue_p != rhs.hasDefaultValue_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDeprecated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasDeprecated\0") + + 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.hasDeprecated_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasDeprecated_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasDeprecated_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecated) -> Bool { + if lhs.hasDeprecated_p != rhs.hasDeprecated_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Duration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Duration" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Duration"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecatedLegacyJsonFieldConflicts: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDeprecatedLegacyJsonFieldConflicts" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasDeprecatedLegacyJsonFieldConflicts\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21226,31 +25651,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufDuration) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasDeprecatedLegacyJsonFieldConflicts_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufDuration != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufDuration, fieldNumber: 1) + if self.hasDeprecatedLegacyJsonFieldConflicts_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasDeprecatedLegacyJsonFieldConflicts_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Duration, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Duration) -> Bool { - if lhs.googleProtobufDuration != rhs.googleProtobufDuration {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecatedLegacyJsonFieldConflicts, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecatedLegacyJsonFieldConflicts) -> Bool { + if lhs.hasDeprecatedLegacyJsonFieldConflicts_p != rhs.hasDeprecatedLegacyJsonFieldConflicts_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Empty: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Empty" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Empty"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecationWarning: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDeprecationWarning" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasDeprecationWarning\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21258,31 +25681,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufEmpty) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasDeprecationWarning_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufEmpty != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufEmpty, fieldNumber: 1) + if self.hasDeprecationWarning_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasDeprecationWarning_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Empty, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Empty) -> Bool { - if lhs.googleProtobufEmpty != rhs.googleProtobufEmpty {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecationWarning, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecationWarning) -> Bool { + if lhs.hasDeprecationWarning_p != rhs.hasDeprecationWarning_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Enum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Enum" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Enum"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDoubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDoubleValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasDoubleValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21290,31 +25711,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufEnum) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasDoubleValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufEnum != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufEnum, fieldNumber: 1) + if self.hasDoubleValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasDoubleValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Enum, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Enum) -> Bool { - if lhs.googleProtobufEnum != rhs.googleProtobufEnum {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDoubleValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDoubleValue) -> Bool { + if lhs.hasDoubleValue_p != rhs.hasDoubleValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_EnumDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasEdition\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21322,31 +25741,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufEnumDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasEdition_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufEnumDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufEnumDescriptorProto, fieldNumber: 1) + if self.hasEdition_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasEdition_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumDescriptorProto) -> Bool { - if lhs.googleProtobufEnumDescriptorProto != rhs.googleProtobufEnumDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEdition) -> Bool { + if lhs.hasEdition_p != rhs.hasEdition_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_EnumOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEditionDeprecated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasEditionDeprecated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasEditionDeprecated\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21354,31 +25771,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufEnumOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasEditionDeprecated_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufEnumOptions != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufEnumOptions, fieldNumber: 1) + if self.hasEditionDeprecated_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasEditionDeprecated_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumOptions) -> Bool { - if lhs.googleProtobufEnumOptions != rhs.googleProtobufEnumOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEditionDeprecated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEditionDeprecated) -> Bool { + if lhs.hasEditionDeprecated_p != rhs.hasEditionDeprecated_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_EnumValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEditionIntroduced: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasEditionIntroduced" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasEditionIntroduced\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21386,31 +25801,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufEnumValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasEditionIntroduced_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufEnumValue != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufEnumValue, fieldNumber: 1) + if self.hasEditionIntroduced_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasEditionIntroduced_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValue) -> Bool { - if lhs.googleProtobufEnumValue != rhs.googleProtobufEnumValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEditionIntroduced, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEditionIntroduced) -> Bool { + if lhs.hasEditionIntroduced_p != rhs.hasEditionIntroduced_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumValueDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_EnumValueDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEditionRemoved: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasEditionRemoved" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasEditionRemoved\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21418,31 +25831,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufEnumValueDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasEditionRemoved_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufEnumValueDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufEnumValueDescriptorProto, fieldNumber: 1) + if self.hasEditionRemoved_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasEditionRemoved_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueDescriptorProto) -> Bool { - if lhs.googleProtobufEnumValueDescriptorProto != rhs.googleProtobufEnumValueDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEditionRemoved, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEditionRemoved) -> Bool { + if lhs.hasEditionRemoved_p != rhs.hasEditionRemoved_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumValueOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_EnumValueOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnd: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasEnd" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasEnd\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21450,31 +25861,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufEnumValueOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasEnd_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufEnumValueOptions != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufEnumValueOptions, fieldNumber: 1) + if self.hasEnd_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasEnd_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueOptions) -> Bool { - if lhs.googleProtobufEnumValueOptions != rhs.googleProtobufEnumValueOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnd, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnd) -> Bool { + if lhs.hasEnd_p != rhs.hasEnd_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_ExtensionRangeOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_ExtensionRangeOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnforceNamingStyle: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasEnforceNamingStyle" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasEnforceNamingStyle\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21482,31 +25891,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufExtensionRangeOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasEnforceNamingStyle_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufExtensionRangeOptions != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufExtensionRangeOptions, fieldNumber: 1) + if self.hasEnforceNamingStyle_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasEnforceNamingStyle_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ExtensionRangeOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ExtensionRangeOptions) -> Bool { - if lhs.googleProtobufExtensionRangeOptions != rhs.googleProtobufExtensionRangeOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnforceNamingStyle, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnforceNamingStyle) -> Bool { + if lhs.hasEnforceNamingStyle_p != rhs.hasEnforceNamingStyle_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnumType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasEnumType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasEnumType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21514,31 +25921,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasEnumType_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufField != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufField, fieldNumber: 1) + if self.hasEnumType_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasEnumType_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Field) -> Bool { - if lhs.googleProtobufField != rhs.googleProtobufField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnumType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnumType) -> Bool { + if lhs.hasEnumType_p != rhs.hasEnumType_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FieldDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_FieldDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExplicitDelta: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasExplicitDelta" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasExplicitDelta\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21546,31 +25951,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufFieldDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasExplicitDelta_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufFieldDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufFieldDescriptorProto, fieldNumber: 1) + if self.hasExplicitDelta_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasExplicitDelta_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldDescriptorProto) -> Bool { - if lhs.googleProtobufFieldDescriptorProto != rhs.googleProtobufFieldDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExplicitDelta, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExplicitDelta) -> Bool { + if lhs.hasExplicitDelta_p != rhs.hasExplicitDelta_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldMask: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FieldMask" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_FieldMask"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExtendee: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasExtendee" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasExtendee\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21578,31 +25981,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufFieldMask) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasExtendee_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufFieldMask != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufFieldMask, fieldNumber: 1) + if self.hasExtendee_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasExtendee_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldMask, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldMask) -> Bool { - if lhs.googleProtobufFieldMask != rhs.googleProtobufFieldMask {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExtendee, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExtendee) -> Bool { + if lhs.hasExtendee_p != rhs.hasExtendee_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FieldOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_FieldOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExtensionValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasExtensionValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasExtensionValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21610,31 +26011,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufFieldOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasExtensionValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufFieldOptions != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufFieldOptions, fieldNumber: 1) + if self.hasExtensionValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasExtensionValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldOptions) -> Bool { - if lhs.googleProtobufFieldOptions != rhs.googleProtobufFieldOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExtensionValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExtensionValue) -> Bool { + if lhs.hasExtensionValue_p != rhs.hasExtensionValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FileDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_FileDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasFeatures\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21642,31 +26041,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufFileDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasFeatures_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufFileDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufFileDescriptorProto, fieldNumber: 1) + if self.hasFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasFeatures_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorProto) -> Bool { - if lhs.googleProtobufFileDescriptorProto != rhs.googleProtobufFileDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFeatures, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFeatures) -> Bool { + if lhs.hasFeatures_p != rhs.hasFeatures_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FileDescriptorSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_FileDescriptorSet"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFeatureSupport: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasFeatureSupport" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasFeatureSupport\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21674,31 +26071,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufFileDescriptorSet) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasFeatureSupport_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufFileDescriptorSet != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufFileDescriptorSet, fieldNumber: 1) + if self.hasFeatureSupport_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasFeatureSupport_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorSet, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorSet) -> Bool { - if lhs.googleProtobufFileDescriptorSet != rhs.googleProtobufFileDescriptorSet {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFeatureSupport, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFeatureSupport) -> Bool { + if lhs.hasFeatureSupport_p != rhs.hasFeatureSupport_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FileOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_FileOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFieldPresence: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasFieldPresence" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasFieldPresence\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21706,31 +26101,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufFileOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasFieldPresence_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufFileOptions != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufFileOptions, fieldNumber: 1) + if self.hasFieldPresence_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasFieldPresence_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileOptions) -> Bool { - if lhs.googleProtobufFileOptions != rhs.googleProtobufFileOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFieldPresence, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFieldPresence) -> Bool { + if lhs.hasFieldPresence_p != rhs.hasFieldPresence_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FloatValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FloatValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_FloatValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFixedFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasFixedFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasFixedFeatures\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21738,31 +26131,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufFloatValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasFixedFeatures_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufFloatValue != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufFloatValue, fieldNumber: 1) + if self.hasFixedFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasFixedFeatures_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FloatValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FloatValue) -> Bool { - if lhs.googleProtobufFloatValue != rhs.googleProtobufFloatValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFixedFeatures, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFixedFeatures) -> Bool { + if lhs.hasFixedFeatures_p != rhs.hasFixedFeatures_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_GeneratedCodeInfo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_GeneratedCodeInfo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFullName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasFullName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasFullName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21770,31 +26161,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufGeneratedCodeInfo) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasFullName_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufGeneratedCodeInfo != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufGeneratedCodeInfo, fieldNumber: 1) + if self.hasFullName_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasFullName_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_GeneratedCodeInfo, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_GeneratedCodeInfo) -> Bool { - if lhs.googleProtobufGeneratedCodeInfo != rhs.googleProtobufGeneratedCodeInfo {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFullName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFullName) -> Bool { + if lhs.hasFullName_p != rhs.hasFullName_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Int32Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Int32Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Int32Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasGoPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasGoPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasGoPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21802,31 +26191,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufInt32Value) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasGoPackage_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufInt32Value != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufInt32Value, fieldNumber: 1) + if self.hasGoPackage_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasGoPackage_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Int32Value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Int32Value) -> Bool { - if lhs.googleProtobufInt32Value != rhs.googleProtobufInt32Value {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasGoPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasGoPackage) -> Bool { + if lhs.hasGoPackage_p != rhs.hasGoPackage_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Int64Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Int64Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Int64Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hash" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hash\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21834,31 +26221,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufInt64Value) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hash) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufInt64Value != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufInt64Value, fieldNumber: 1) + if self.hash != 0 { + try visitor.visitSingularInt32Field(value: self.hash, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Int64Value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Int64Value) -> Bool { - if lhs.googleProtobufInt64Value != rhs.googleProtobufInt64Value {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hash, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hash) -> Bool { + if lhs.hash != rhs.hash {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ListValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_ListValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_ListValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.HashableMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Hashable" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Hashable\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21866,31 +26251,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufListValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hashable) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufListValue != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufListValue, fieldNumber: 1) + if self.hashable != 0 { + try visitor.visitSingularInt32Field(value: self.hashable, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ListValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ListValue) -> Bool { - if lhs.googleProtobufListValue != rhs.googleProtobufListValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.HashableMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.HashableMessage) -> Bool { + if lhs.hashable != rhs.hashable {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MessageOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_MessageOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_MessageOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasher: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasher" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasher\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21898,31 +26281,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufMessageOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasher) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufMessageOptions != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufMessageOptions, fieldNumber: 1) + if self.hasher != 0 { + try visitor.visitSingularInt32Field(value: self.hasher, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MessageOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MessageOptions) -> Bool { - if lhs.googleProtobufMessageOptions != rhs.googleProtobufMessageOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasher, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasher) -> Bool { + if lhs.hasher != rhs.hasher {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Method: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Method" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Method"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.HashVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".HashVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}HashVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21930,31 +26311,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufMethod) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hashVisitor) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufMethod != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufMethod, fieldNumber: 1) + if self.hashVisitor != 0 { + try visitor.visitSingularInt32Field(value: self.hashVisitor, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Method, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Method) -> Bool { - if lhs.googleProtobufMethod != rhs.googleProtobufMethod {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.HashVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.HashVisitor) -> Bool { + if lhs.hashVisitor != rhs.hashVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_MethodDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_MethodDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIdempotencyLevel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasIdempotencyLevel" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasIdempotencyLevel\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21962,31 +26341,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufMethodDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasIdempotencyLevel_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufMethodDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufMethodDescriptorProto, fieldNumber: 1) + if self.hasIdempotencyLevel_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasIdempotencyLevel_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodDescriptorProto) -> Bool { - if lhs.googleProtobufMethodDescriptorProto != rhs.googleProtobufMethodDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIdempotencyLevel, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIdempotencyLevel) -> Bool { + if lhs.hasIdempotencyLevel_p != rhs.hasIdempotencyLevel_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_MethodOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_MethodOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIdentifierValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasIdentifierValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasIdentifierValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21994,31 +26371,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufMethodOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasIdentifierValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufMethodOptions != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufMethodOptions, fieldNumber: 1) + if self.hasIdentifierValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasIdentifierValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodOptions) -> Bool { - if lhs.googleProtobufMethodOptions != rhs.googleProtobufMethodOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIdentifierValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIdentifierValue) -> Bool { + if lhs.hasIdentifierValue_p != rhs.hasIdentifierValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Mixin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Mixin" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Mixin"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasInputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasInputType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasInputType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22026,31 +26401,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufMixin) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasInputType_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufMixin != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufMixin, fieldNumber: 1) + if self.hasInputType_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasInputType_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Mixin, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Mixin) -> Bool { - if lhs.googleProtobufMixin != rhs.googleProtobufMixin {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasInputType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasInputType) -> Bool { + if lhs.hasInputType_p != rhs.hasInputType_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_NullValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_NullValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_NullValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIsExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasIsExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasIsExtension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22058,31 +26431,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufNullValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasIsExtension_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufNullValue != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufNullValue, fieldNumber: 1) + if self.hasIsExtension_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasIsExtension_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_NullValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_NullValue) -> Bool { - if lhs.googleProtobufNullValue != rhs.googleProtobufNullValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIsExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIsExtension) -> Bool { + if lhs.hasIsExtension_p != rhs.hasIsExtension_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_OneofDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_OneofDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaGenerateEqualsAndHash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaGenerateEqualsAndHash" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasJavaGenerateEqualsAndHash\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22090,31 +26461,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufOneofDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasJavaGenerateEqualsAndHash_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufOneofDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufOneofDescriptorProto, fieldNumber: 1) + if self.hasJavaGenerateEqualsAndHash_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasJavaGenerateEqualsAndHash_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofDescriptorProto) -> Bool { - if lhs.googleProtobufOneofDescriptorProto != rhs.googleProtobufOneofDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaGenerateEqualsAndHash, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaGenerateEqualsAndHash) -> Bool { + if lhs.hasJavaGenerateEqualsAndHash_p != rhs.hasJavaGenerateEqualsAndHash_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_OneofOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_OneofOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaGenericServices" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasJavaGenericServices\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22122,31 +26491,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufOneofOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasJavaGenericServices_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufOneofOptions != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufOneofOptions, fieldNumber: 1) + if self.hasJavaGenericServices_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasJavaGenericServices_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofOptions) -> Bool { - if lhs.googleProtobufOneofOptions != rhs.googleProtobufOneofOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaGenericServices) -> Bool { + if lhs.hasJavaGenericServices_p != rhs.hasJavaGenericServices_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Option: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Option" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Option"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaMultipleFiles: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaMultipleFiles" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasJavaMultipleFiles\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22154,31 +26521,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufOption) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasJavaMultipleFiles_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufOption != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufOption, fieldNumber: 1) + if self.hasJavaMultipleFiles_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasJavaMultipleFiles_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Option, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Option) -> Bool { - if lhs.googleProtobufOption != rhs.googleProtobufOption {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaMultipleFiles, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaMultipleFiles) -> Bool { + if lhs.hasJavaMultipleFiles_p != rhs.hasJavaMultipleFiles_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_ServiceDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_ServiceDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaOuterClassname: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaOuterClassname" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasJavaOuterClassname\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22186,31 +26551,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufServiceDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasJavaOuterClassname_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufServiceDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufServiceDescriptorProto, fieldNumber: 1) + if self.hasJavaOuterClassname_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasJavaOuterClassname_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceDescriptorProto) -> Bool { - if lhs.googleProtobufServiceDescriptorProto != rhs.googleProtobufServiceDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaOuterClassname, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaOuterClassname) -> Bool { + if lhs.hasJavaOuterClassname_p != rhs.hasJavaOuterClassname_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_ServiceOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_ServiceOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasJavaPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22218,31 +26581,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufServiceOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasJavaPackage_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufServiceOptions != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufServiceOptions, fieldNumber: 1) + if self.hasJavaPackage_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasJavaPackage_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceOptions) -> Bool { - if lhs.googleProtobufServiceOptions != rhs.googleProtobufServiceOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaPackage) -> Bool { + if lhs.hasJavaPackage_p != rhs.hasJavaPackage_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_SourceCodeInfo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_SourceCodeInfo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaStringCheckUtf8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaStringCheckUtf8" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasJavaStringCheckUtf8\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22250,31 +26611,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufSourceCodeInfo) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasJavaStringCheckUtf8_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufSourceCodeInfo != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufSourceCodeInfo, fieldNumber: 1) + if self.hasJavaStringCheckUtf8_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasJavaStringCheckUtf8_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceCodeInfo, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceCodeInfo) -> Bool { - if lhs.googleProtobufSourceCodeInfo != rhs.googleProtobufSourceCodeInfo {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaStringCheckUtf8, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaStringCheckUtf8) -> Bool { + if lhs.hasJavaStringCheckUtf8_p != rhs.hasJavaStringCheckUtf8_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceContext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_SourceContext" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_SourceContext"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJsonFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJsonFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasJsonFormat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22282,31 +26641,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufSourceContext) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasJsonFormat_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufSourceContext != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufSourceContext, fieldNumber: 1) + if self.hasJsonFormat_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasJsonFormat_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceContext, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceContext) -> Bool { - if lhs.googleProtobufSourceContext != rhs.googleProtobufSourceContext {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJsonFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJsonFormat) -> Bool { + if lhs.hasJsonFormat_p != rhs.hasJsonFormat_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_StringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_StringValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_StringValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJsonName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJsonName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasJsonName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22314,31 +26671,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufStringValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasJsonName_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufStringValue != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufStringValue, fieldNumber: 1) + if self.hasJsonName_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasJsonName_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_StringValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_StringValue) -> Bool { - if lhs.googleProtobufStringValue != rhs.googleProtobufStringValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJsonName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJsonName) -> Bool { + if lhs.hasJsonName_p != rhs.hasJsonName_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Struct: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Struct" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Struct"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJstype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJstype" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasJstype\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22346,31 +26701,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufStruct) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasJstype_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufStruct != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufStruct, fieldNumber: 1) + if self.hasJstype_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasJstype_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Struct, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Struct) -> Bool { - if lhs.googleProtobufStruct != rhs.googleProtobufStruct {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJstype, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJstype) -> Bool { + if lhs.hasJstype_p != rhs.hasJstype_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Syntax: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Syntax" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Syntax"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLabel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasLabel" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasLabel\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22378,31 +26731,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufSyntax) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasLabel_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufSyntax != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufSyntax, fieldNumber: 1) + if self.hasLabel_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasLabel_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Syntax, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Syntax) -> Bool { - if lhs.googleProtobufSyntax != rhs.googleProtobufSyntax {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLabel, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLabel) -> Bool { + if lhs.hasLabel_p != rhs.hasLabel_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Timestamp: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Timestamp" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Timestamp"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasLazy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasLazy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22410,31 +26761,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufTimestamp) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasLazy_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufTimestamp != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufTimestamp, fieldNumber: 1) + if self.hasLazy_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasLazy_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Timestamp, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Timestamp) -> Bool { - if lhs.googleProtobufTimestamp != rhs.googleProtobufTimestamp {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLazy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLazy) -> Bool { + if lhs.hasLazy_p != rhs.hasLazy_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Type: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Type" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Type"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLeadingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasLeadingComments" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasLeadingComments\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22442,31 +26791,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasLeadingComments_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufType != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufType, fieldNumber: 1) + if self.hasLeadingComments_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasLeadingComments_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Type, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Type) -> Bool { - if lhs.googleProtobufType != rhs.googleProtobufType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLeadingComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLeadingComments) -> Bool { + if lhs.hasLeadingComments_p != rhs.hasLeadingComments_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt32Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_UInt32Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_UInt32Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMapEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasMapEntry" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasMapEntry\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22474,31 +26821,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufUint32Value) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasMapEntry_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufUint32Value != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufUint32Value, fieldNumber: 1) + if self.hasMapEntry_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasMapEntry_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt32Value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt32Value) -> Bool { - if lhs.googleProtobufUint32Value != rhs.googleProtobufUint32Value {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMapEntry, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMapEntry) -> Bool { + if lhs.hasMapEntry_p != rhs.hasMapEntry_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt64Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_UInt64Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_UInt64Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMaximumEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasMaximumEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasMaximumEdition\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22506,31 +26851,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufUint64Value) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasMaximumEdition_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufUint64Value != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufUint64Value, fieldNumber: 1) + if self.hasMaximumEdition_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasMaximumEdition_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt64Value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt64Value) -> Bool { - if lhs.googleProtobufUint64Value != rhs.googleProtobufUint64Value {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMaximumEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMaximumEdition) -> Bool { + if lhs.hasMaximumEdition_p != rhs.hasMaximumEdition_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UninterpretedOption: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_UninterpretedOption" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_UninterpretedOption"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMessageEncoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasMessageEncoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasMessageEncoding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22538,31 +26881,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufUninterpretedOption) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasMessageEncoding_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufUninterpretedOption != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufUninterpretedOption, fieldNumber: 1) + if self.hasMessageEncoding_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasMessageEncoding_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UninterpretedOption, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UninterpretedOption) -> Bool { - if lhs.googleProtobufUninterpretedOption != rhs.googleProtobufUninterpretedOption {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMessageEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMessageEncoding) -> Bool { + if lhs.hasMessageEncoding_p != rhs.hasMessageEncoding_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMessageSetWireFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasMessageSetWireFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasMessageSetWireFormat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22570,31 +26911,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasMessageSetWireFormat_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufValue != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufValue, fieldNumber: 1) + if self.hasMessageSetWireFormat_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasMessageSetWireFormat_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Value) -> Bool { - if lhs.googleProtobufValue != rhs.googleProtobufValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMessageSetWireFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMessageSetWireFormat) -> Bool { + if lhs.hasMessageSetWireFormat_p != rhs.hasMessageSetWireFormat_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.goPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".goPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "goPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMinimumEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasMinimumEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasMinimumEdition\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22602,31 +26941,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.goPackage: Sw // 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.goPackage) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasMinimumEdition_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.goPackage != 0 { - try visitor.visitSingularInt32Field(value: self.goPackage, fieldNumber: 1) + if self.hasMinimumEdition_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasMinimumEdition_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.goPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.goPackage) -> Bool { - if lhs.goPackage != rhs.goPackage {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMinimumEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMinimumEdition) -> Bool { + if lhs.hasMinimumEdition_p != rhs.hasMinimumEdition_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.group: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".group" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "group"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22634,31 +26971,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.group: SwiftP // 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.group) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasName_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.group != 0 { - try visitor.visitSingularInt32Field(value: self.group, fieldNumber: 1) + if self.hasName_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasName_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.group, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.group) -> Bool { - if lhs.group != rhs.group {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasName) -> Bool { + if lhs.hasName_p != rhs.hasName_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupFieldNumberStack: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".groupFieldNumberStack" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "groupFieldNumberStack"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNamePart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasNamePart" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasNamePart\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22666,31 +27001,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupFieldNum // 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.groupFieldNumberStack) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasNamePart_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.groupFieldNumberStack != 0 { - try visitor.visitSingularInt32Field(value: self.groupFieldNumberStack, fieldNumber: 1) + if self.hasNamePart_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasNamePart_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupFieldNumberStack, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupFieldNumberStack) -> Bool { - if lhs.groupFieldNumberStack != rhs.groupFieldNumberStack {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNamePart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNamePart) -> Bool { + if lhs.hasNamePart_p != rhs.hasNamePart_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".groupSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "groupSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNegativeIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasNegativeIntValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasNegativeIntValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22698,31 +27031,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupSize: Sw // 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.groupSize) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasNegativeIntValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.groupSize != 0 { - try visitor.visitSingularInt32Field(value: self.groupSize, fieldNumber: 1) + if self.hasNegativeIntValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasNegativeIntValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupSize, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupSize) -> Bool { - if lhs.groupSize != rhs.groupSize {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNegativeIntValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNegativeIntValue) -> Bool { + if lhs.hasNegativeIntValue_p != rhs.hasNegativeIntValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.h: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".h" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "h"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNoStandardDescriptorAccessor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasNoStandardDescriptorAccessor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasNoStandardDescriptorAccessor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22730,31 +27061,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.h: SwiftProto // 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.h) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasNoStandardDescriptorAccessor_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.h != 0 { - try visitor.visitSingularInt32Field(value: self.h, fieldNumber: 1) + if self.hasNoStandardDescriptorAccessor_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasNoStandardDescriptorAccessor_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.h, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.h) -> Bool { - if lhs.h != rhs.h {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNoStandardDescriptorAccessor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNoStandardDescriptorAccessor) -> Bool { + if lhs.hasNoStandardDescriptorAccessor_p != rhs.hasNoStandardDescriptorAccessor_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hadOneofValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hadOneofValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hadOneofValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasNumber\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22762,31 +27091,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hadOneofValue // 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.hadOneofValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasNumber_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hadOneofValue != 0 { - try visitor.visitSingularInt32Field(value: self.hadOneofValue, fieldNumber: 1) + if self.hasNumber_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasNumber_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hadOneofValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hadOneofValue) -> Bool { - if lhs.hadOneofValue != rhs.hadOneofValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNumber) -> Bool { + if lhs.hasNumber_p != rhs.hasNumber_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.handleConflictingOneOf: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".handleConflictingOneOf" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "handleConflictingOneOf"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasObjcClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasObjcClassPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasObjcClassPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22794,31 +27121,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.handleConflic // 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.handleConflictingOneOf) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasObjcClassPrefix_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.handleConflictingOneOf != 0 { - try visitor.visitSingularInt32Field(value: self.handleConflictingOneOf, fieldNumber: 1) + if self.hasObjcClassPrefix_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasObjcClassPrefix_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.handleConflictingOneOf, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.handleConflictingOneOf) -> Bool { - if lhs.handleConflictingOneOf != rhs.handleConflictingOneOf {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasObjcClassPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasObjcClassPrefix) -> Bool { + if lhs.hasObjcClassPrefix_p != rhs.hasObjcClassPrefix_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAggregateValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasAggregateValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasAggregateValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOneofIndex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasOneofIndex" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasOneofIndex\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22826,31 +27151,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAggregateV // 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.hasAggregateValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasOneofIndex_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasAggregateValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasAggregateValue_p, fieldNumber: 1) + if self.hasOneofIndex_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasOneofIndex_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAggregateValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAggregateValue) -> Bool { - if lhs.hasAggregateValue_p != rhs.hasAggregateValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOneofIndex, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOneofIndex) -> Bool { + if lhs.hasOneofIndex_p != rhs.hasOneofIndex_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAllowAlias: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasAllowAlias" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasAllowAlias"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOptimizeFor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasOptimizeFor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasOptimizeFor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22858,31 +27181,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAllowAlias // 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.hasAllowAlias_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasOptimizeFor_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasAllowAlias_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasAllowAlias_p, fieldNumber: 1) + if self.hasOptimizeFor_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasOptimizeFor_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAllowAlias, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAllowAlias) -> Bool { - if lhs.hasAllowAlias_p != rhs.hasAllowAlias_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOptimizeFor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOptimizeFor) -> Bool { + if lhs.hasOptimizeFor_p != rhs.hasOptimizeFor_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasBegin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasBegin" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasBegin"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22890,31 +27211,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasBegin: Swi // 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.hasBegin_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasOptions_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasBegin_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasBegin_p, fieldNumber: 1) + if self.hasOptions_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasOptions_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasBegin, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasBegin) -> Bool { - if lhs.hasBegin_p != rhs.hasBegin_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOptions) -> Bool { + if lhs.hasOptions_p != rhs.hasOptions_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcEnableArenas: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasCcEnableArenas" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasCcEnableArenas"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOutputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasOutputType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasOutputType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22922,31 +27241,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcEnableAr // 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.hasCcEnableArenas_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasOutputType_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasCcEnableArenas_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasCcEnableArenas_p, fieldNumber: 1) + if self.hasOutputType_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasOutputType_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcEnableArenas, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcEnableArenas) -> Bool { - if lhs.hasCcEnableArenas_p != rhs.hasCcEnableArenas_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOutputType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOutputType) -> Bool { + if lhs.hasOutputType_p != rhs.hasOutputType_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasCcGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasCcGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOverridableFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasOverridableFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasOverridableFeatures\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22954,31 +27271,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcGenericS // 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.hasCcGenericServices_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasOverridableFeatures_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasCcGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasCcGenericServices_p, fieldNumber: 1) + if self.hasOverridableFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasOverridableFeatures_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcGenericServices) -> Bool { - if lhs.hasCcGenericServices_p != rhs.hasCcGenericServices_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOverridableFeatures, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOverridableFeatures) -> Bool { + if lhs.hasOverridableFeatures_p != rhs.hasOverridableFeatures_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasClientStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasClientStreaming" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasClientStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22986,31 +27301,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasClientStre // 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.hasClientStreaming_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasPackage_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasClientStreaming_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasClientStreaming_p, fieldNumber: 1) + if self.hasPackage_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasPackage_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasClientStreaming, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasClientStreaming) -> Bool { - if lhs.hasClientStreaming_p != rhs.hasClientStreaming_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPackage) -> Bool { + if lhs.hasPackage_p != rhs.hasPackage_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCsharpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasCsharpNamespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasCsharpNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPacked: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPacked" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasPacked\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23018,31 +27331,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCsharpName // 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.hasCsharpNamespace_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasPacked_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasCsharpNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasCsharpNamespace_p, fieldNumber: 1) + if self.hasPacked_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasPacked_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCsharpNamespace, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCsharpNamespace) -> Bool { - if lhs.hasCsharpNamespace_p != rhs.hasCsharpNamespace_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPacked, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPacked) -> Bool { + if lhs.hasPacked_p != rhs.hasPacked_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCtype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasCtype" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasCtype"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPhpClassPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasPhpClassPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23050,31 +27361,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCtype: Swi // 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.hasCtype_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasPhpClassPrefix_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasCtype_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasCtype_p, fieldNumber: 1) + if self.hasPhpClassPrefix_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasPhpClassPrefix_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCtype, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCtype) -> Bool { - if lhs.hasCtype_p != rhs.hasCtype_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpClassPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpClassPrefix) -> Bool { + if lhs.hasPhpClassPrefix_p != rhs.hasPhpClassPrefix_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDefaultValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDefaultValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasDefaultValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpMetadataNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPhpMetadataNamespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasPhpMetadataNamespace\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23082,31 +27391,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDefaultVal // 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.hasDefaultValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasPhpMetadataNamespace_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasDefaultValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasDefaultValue_p, fieldNumber: 1) + if self.hasPhpMetadataNamespace_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasPhpMetadataNamespace_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDefaultValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDefaultValue) -> Bool { - if lhs.hasDefaultValue_p != rhs.hasDefaultValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpMetadataNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpMetadataNamespace) -> Bool { + if lhs.hasPhpMetadataNamespace_p != rhs.hasPhpMetadataNamespace_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDeprecated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDeprecated" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasDeprecated"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPhpNamespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasPhpNamespace\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23114,31 +27421,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDeprecated // 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.hasDeprecated_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasPhpNamespace_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasDeprecated_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasDeprecated_p, fieldNumber: 1) + if self.hasPhpNamespace_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasPhpNamespace_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDeprecated, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDeprecated) -> Bool { - if lhs.hasDeprecated_p != rhs.hasDeprecated_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpNamespace) -> Bool { + if lhs.hasPhpNamespace_p != rhs.hasPhpNamespace_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDoubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDoubleValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasDoubleValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPositiveIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPositiveIntValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasPositiveIntValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23146,31 +27451,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDoubleValu // 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.hasDoubleValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasPositiveIntValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasDoubleValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasDoubleValue_p, fieldNumber: 1) + if self.hasPositiveIntValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasPositiveIntValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDoubleValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDoubleValue) -> Bool { - if lhs.hasDoubleValue_p != rhs.hasDoubleValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPositiveIntValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPositiveIntValue) -> Bool { + if lhs.hasPositiveIntValue_p != rhs.hasPositiveIntValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasEnd: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasEnd" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasEnd"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasProto3Optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasProto3Optional" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasProto3Optional\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23178,31 +27481,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasEnd: Swift // 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.hasEnd_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasProto3Optional_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasEnd_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasEnd_p, fieldNumber: 1) + if self.hasProto3Optional_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasProto3Optional_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasEnd, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasEnd) -> Bool { - if lhs.hasEnd_p != rhs.hasEnd_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasProto3Optional, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasProto3Optional) -> Bool { + if lhs.hasProto3Optional_p != rhs.hasProto3Optional_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtendee: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasExtendee" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasExtendee"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPyGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPyGenericServices" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasPyGenericServices\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23210,31 +27511,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtendee: // 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.hasExtendee_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasPyGenericServices_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasExtendee_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasExtendee_p, fieldNumber: 1) + if self.hasPyGenericServices_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasPyGenericServices_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtendee, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtendee) -> Bool { - if lhs.hasExtendee_p != rhs.hasExtendee_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPyGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPyGenericServices) -> Bool { + if lhs.hasPyGenericServices_p != rhs.hasPyGenericServices_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtensionValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasExtensionValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasExtensionValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRemovalError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasRemovalError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasRemovalError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23242,31 +27541,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtensionV // 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.hasExtensionValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasRemovalError_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasExtensionValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasExtensionValue_p, fieldNumber: 1) + if self.hasRemovalError_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasRemovalError_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtensionValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtensionValue) -> Bool { - if lhs.hasExtensionValue_p != rhs.hasExtensionValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRemovalError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRemovalError) -> Bool { + if lhs.hasRemovalError_p != rhs.hasRemovalError_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasGoPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasGoPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasGoPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRepeated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasRepeated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasRepeated\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23274,31 +27571,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasGoPackage: // 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.hasGoPackage_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasRepeated_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasGoPackage_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasGoPackage_p, fieldNumber: 1) + if self.hasRepeated_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasRepeated_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasGoPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasGoPackage) -> Bool { - if lhs.hasGoPackage_p != rhs.hasGoPackage_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRepeated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRepeated) -> Bool { + if lhs.hasRepeated_p != rhs.hasRepeated_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hash" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hash"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRepeatedFieldEncoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasRepeatedFieldEncoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasRepeatedFieldEncoding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23306,31 +27601,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hash: SwiftPr // 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.hash) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasRepeatedFieldEncoding_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hash != 0 { - try visitor.visitSingularInt32Field(value: self.hash, fieldNumber: 1) + if self.hasRepeatedFieldEncoding_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasRepeatedFieldEncoding_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hash, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hash) -> Bool { - if lhs.hash != rhs.hash {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRepeatedFieldEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRepeatedFieldEncoding) -> Bool { + if lhs.hasRepeatedFieldEncoding_p != rhs.hasRepeatedFieldEncoding_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Hashable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Hashable" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Hashable"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasReserved: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasReserved" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasReserved\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23338,31 +27631,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Hashable: Swi // 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.hashable) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasReserved_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hashable != 0 { - try visitor.visitSingularInt32Field(value: self.hashable, fieldNumber: 1) + if self.hasReserved_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasReserved_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Hashable, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Hashable) -> Bool { - if lhs.hashable != rhs.hashable {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasReserved, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasReserved) -> Bool { + if lhs.hasReserved_p != rhs.hasReserved_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasher: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasher" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasher"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRetention: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasRetention" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasRetention\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23370,31 +27661,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasher: Swift // 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.hasher) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasRetention_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasher != 0 { - try visitor.visitSingularInt32Field(value: self.hasher, fieldNumber: 1) + if self.hasRetention_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasRetention_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasher, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasher) -> Bool { - if lhs.hasher != rhs.hasher {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRetention, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRetention) -> Bool { + if lhs.hasRetention_p != rhs.hasRetention_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hashValueMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hashValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hashValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRubyPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasRubyPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasRubyPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23402,31 +27691,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hashValueMess // 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.hashValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasRubyPackage_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hashValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hashValue_p, fieldNumber: 1) + if self.hasRubyPackage_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasRubyPackage_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hashValueMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hashValueMessage) -> Bool { - if lhs.hashValue_p != rhs.hashValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRubyPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRubyPackage) -> Bool { + if lhs.hasRubyPackage_p != rhs.hasRubyPackage_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.HashVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".HashVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "HashVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSemantic: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSemantic" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasSemantic\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23434,31 +27721,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.HashVisitor: // 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.hashVisitor) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasSemantic_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hashVisitor != 0 { - try visitor.visitSingularInt32Field(value: self.hashVisitor, fieldNumber: 1) + if self.hasSemantic_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasSemantic_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.HashVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.HashVisitor) -> Bool { - if lhs.hashVisitor != rhs.hashVisitor {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSemantic, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSemantic) -> Bool { + if lhs.hasSemantic_p != rhs.hasSemantic_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdempotencyLevel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasIdempotencyLevel" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasIdempotencyLevel"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasServerStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasServerStreaming" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasServerStreaming\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23466,31 +27751,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdempotenc // 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.hasIdempotencyLevel_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasServerStreaming_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasIdempotencyLevel_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasIdempotencyLevel_p, fieldNumber: 1) + if self.hasServerStreaming_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasServerStreaming_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdempotencyLevel, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdempotencyLevel) -> Bool { - if lhs.hasIdempotencyLevel_p != rhs.hasIdempotencyLevel_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasServerStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasServerStreaming) -> Bool { + if lhs.hasServerStreaming_p != rhs.hasServerStreaming_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdentifierValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasIdentifierValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasIdentifierValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSourceCodeInfo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasSourceCodeInfo\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23498,31 +27781,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdentifier // 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.hasIdentifierValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasSourceCodeInfo_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasIdentifierValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasIdentifierValue_p, fieldNumber: 1) + if self.hasSourceCodeInfo_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasSourceCodeInfo_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdentifierValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdentifierValue) -> Bool { - if lhs.hasIdentifierValue_p != rhs.hasIdentifierValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceCodeInfo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceCodeInfo) -> Bool { + if lhs.hasSourceCodeInfo_p != rhs.hasSourceCodeInfo_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasInputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasInputType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasInputType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceContext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSourceContext" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasSourceContext\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23530,31 +27811,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasInputType: // 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.hasInputType_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasSourceContext_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasInputType_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasInputType_p, fieldNumber: 1) + if self.hasSourceContext_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasSourceContext_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasInputType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasInputType) -> Bool { - if lhs.hasInputType_p != rhs.hasInputType_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceContext, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceContext) -> Bool { + if lhs.hasSourceContext_p != rhs.hasSourceContext_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIsExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasIsExtension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasIsExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceFile: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSourceFile" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasSourceFile\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23562,31 +27841,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIsExtensio // 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.hasIsExtension_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasSourceFile_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasIsExtension_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasIsExtension_p, fieldNumber: 1) + if self.hasSourceFile_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasSourceFile_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIsExtension, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIsExtension) -> Bool { - if lhs.hasIsExtension_p != rhs.hasIsExtension_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceFile, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceFile) -> Bool { + if lhs.hasSourceFile_p != rhs.hasSourceFile_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGenerateEqualsAndHash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaGenerateEqualsAndHash" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasJavaGenerateEqualsAndHash"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasStart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasStart" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasStart\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23594,31 +27871,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGenera // 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.hasJavaGenerateEqualsAndHash_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasStart_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasJavaGenerateEqualsAndHash_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasJavaGenerateEqualsAndHash_p, fieldNumber: 1) + if self.hasStart_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasStart_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGenerateEqualsAndHash, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGenerateEqualsAndHash) -> Bool { - if lhs.hasJavaGenerateEqualsAndHash_p != rhs.hasJavaGenerateEqualsAndHash_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasStart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasStart) -> Bool { + if lhs.hasStart_p != rhs.hasStart_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasJavaGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasStringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasStringValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasStringValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23626,31 +27901,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGeneri // 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.hasJavaGenericServices_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasStringValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasJavaGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasJavaGenericServices_p, fieldNumber: 1) + if self.hasStringValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasStringValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGenericServices) -> Bool { - if lhs.hasJavaGenericServices_p != rhs.hasJavaGenericServices_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasStringValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasStringValue) -> Bool { + if lhs.hasStringValue_p != rhs.hasStringValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaMultipleFiles: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaMultipleFiles" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasJavaMultipleFiles"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSwiftPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSwiftPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasSwiftPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23658,31 +27931,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaMultip // 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.hasJavaMultipleFiles_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasSwiftPrefix_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasJavaMultipleFiles_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasJavaMultipleFiles_p, fieldNumber: 1) + if self.hasSwiftPrefix_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasSwiftPrefix_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaMultipleFiles, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaMultipleFiles) -> Bool { - if lhs.hasJavaMultipleFiles_p != rhs.hasJavaMultipleFiles_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSwiftPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSwiftPrefix) -> Bool { + if lhs.hasSwiftPrefix_p != rhs.hasSwiftPrefix_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaOuterClassname: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaOuterClassname" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasJavaOuterClassname"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSyntax: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSyntax" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasSyntax\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23690,31 +27961,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaOuterC // 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.hasJavaOuterClassname_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasSyntax_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasJavaOuterClassname_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasJavaOuterClassname_p, fieldNumber: 1) + if self.hasSyntax_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasSyntax_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaOuterClassname, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaOuterClassname) -> Bool { - if lhs.hasJavaOuterClassname_p != rhs.hasJavaOuterClassname_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSyntax, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSyntax) -> Bool { + if lhs.hasSyntax_p != rhs.hasSyntax_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasJavaPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasTrailingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasTrailingComments" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasTrailingComments\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23722,31 +27991,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaPackag // 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.hasJavaPackage_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasTrailingComments_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasJavaPackage_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasJavaPackage_p, fieldNumber: 1) + if self.hasTrailingComments_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasTrailingComments_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaPackage) -> Bool { - if lhs.hasJavaPackage_p != rhs.hasJavaPackage_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasTrailingComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasTrailingComments) -> Bool { + if lhs.hasTrailingComments_p != rhs.hasTrailingComments_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaStringCheckUtf8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaStringCheckUtf8" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasJavaStringCheckUtf8"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23754,31 +28021,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaString // 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.hasJavaStringCheckUtf8_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasType_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasJavaStringCheckUtf8_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasJavaStringCheckUtf8_p, fieldNumber: 1) + if self.hasType_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasType_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaStringCheckUtf8, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaStringCheckUtf8) -> Bool { - if lhs.hasJavaStringCheckUtf8_p != rhs.hasJavaStringCheckUtf8_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasType) -> Bool { + if lhs.hasType_p != rhs.hasType_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJsonName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJsonName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasJsonName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasTypeName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasTypeName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasTypeName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23786,31 +28051,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJsonName: // 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.hasJsonName_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasTypeName_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasJsonName_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasJsonName_p, fieldNumber: 1) + if self.hasTypeName_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasTypeName_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJsonName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJsonName) -> Bool { - if lhs.hasJsonName_p != rhs.hasJsonName_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasTypeName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasTypeName) -> Bool { + if lhs.hasTypeName_p != rhs.hasTypeName_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJstype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJstype" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasJstype"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasUnverifiedLazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasUnverifiedLazy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasUnverifiedLazy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23818,31 +28081,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJstype: Sw // 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.hasJstype_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasUnverifiedLazy_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasJstype_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasJstype_p, fieldNumber: 1) + if self.hasUnverifiedLazy_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasUnverifiedLazy_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJstype, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJstype) -> Bool { - if lhs.hasJstype_p != rhs.hasJstype_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasUnverifiedLazy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasUnverifiedLazy) -> Bool { + if lhs.hasUnverifiedLazy_p != rhs.hasUnverifiedLazy_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLabel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasLabel" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasLabel"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasUtf8Validation: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasUtf8Validation" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasUtf8Validation\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23850,31 +28111,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLabel: Swi // 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.hasLabel_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasUtf8Validation_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasLabel_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasLabel_p, fieldNumber: 1) + if self.hasUtf8Validation_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasUtf8Validation_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLabel, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLabel) -> Bool { - if lhs.hasLabel_p != rhs.hasLabel_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasUtf8Validation, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasUtf8Validation) -> Bool { + if lhs.hasUtf8Validation_p != rhs.hasUtf8Validation_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasLazy" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasLazy"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23882,31 +28141,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLazy: Swif // 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.hasLazy_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasLazy_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasLazy_p, fieldNumber: 1) + if self.hasValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLazy, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLazy) -> Bool { - if lhs.hasLazy_p != rhs.hasLazy_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasValue) -> Bool { + if lhs.hasValue_p != rhs.hasValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLeadingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasLeadingComments" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasLeadingComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasVerification: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasVerification" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasVerification\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23914,31 +28171,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLeadingCom // 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.hasLeadingComments_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasVerification_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasLeadingComments_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasLeadingComments_p, fieldNumber: 1) + if self.hasVerification_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasVerification_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLeadingComments, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLeadingComments) -> Bool { - if lhs.hasLeadingComments_p != rhs.hasLeadingComments_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasVerification, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasVerification) -> Bool { + if lhs.hasVerification_p != rhs.hasVerification_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMapEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasMapEntry" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasMapEntry"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasVisibility: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasVisibility" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasVisibility\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23946,31 +28201,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMapEntry: // 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.hasMapEntry_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasVisibility_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasMapEntry_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasMapEntry_p, fieldNumber: 1) + if self.hasVisibility_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasVisibility_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMapEntry, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMapEntry) -> Bool { - if lhs.hasMapEntry_p != rhs.hasMapEntry_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasVisibility, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasVisibility) -> Bool { + if lhs.hasVisibility_p != rhs.hasVisibility_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMessageSetWireFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasMessageSetWireFormat" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasMessageSetWireFormat"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasWeak: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasWeak" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasWeak\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23978,31 +28231,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMessageSet // 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.hasMessageSetWireFormat_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasWeak_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasMessageSetWireFormat_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasMessageSetWireFormat_p, fieldNumber: 1) + if self.hasWeak_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasWeak_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMessageSetWireFormat, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMessageSetWireFormat) -> Bool { - if lhs.hasMessageSetWireFormat_p != rhs.hasMessageSetWireFormat_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasWeak, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasWeak) -> Bool { + if lhs.hasWeak_p != rhs.hasWeak_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hour: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hour" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hour\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24010,31 +28261,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasName: Swif // 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.hasName_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hour) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasName_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasName_p, fieldNumber: 1) + if self.hour != 0 { + try visitor.visitSingularInt32Field(value: self.hour, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasName) -> Bool { - if lhs.hasName_p != rhs.hasName_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hour, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hour) -> Bool { + if lhs.hour != rhs.hour {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNamePart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasNamePart" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasNamePart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.i: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".i" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}i\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24042,31 +28291,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNamePart: // 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.hasNamePart_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.i) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasNamePart_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasNamePart_p, fieldNumber: 1) + if self.i != 0 { + try visitor.visitSingularInt32Field(value: self.i, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNamePart, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNamePart) -> Bool { - if lhs.hasNamePart_p != rhs.hasNamePart_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.i, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.i) -> Bool { + if lhs.i != rhs.i {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNegativeIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasNegativeIntValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasNegativeIntValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.idempotencyLevel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".idempotencyLevel" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}idempotencyLevel\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24074,31 +28321,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNegativeIn // 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.hasNegativeIntValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.idempotencyLevel) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasNegativeIntValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasNegativeIntValue_p, fieldNumber: 1) + if self.idempotencyLevel != 0 { + try visitor.visitSingularInt32Field(value: self.idempotencyLevel, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNegativeIntValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNegativeIntValue) -> Bool { - if lhs.hasNegativeIntValue_p != rhs.hasNegativeIntValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.idempotencyLevel, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.idempotencyLevel) -> Bool { + if lhs.idempotencyLevel != rhs.idempotencyLevel {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNoStandardDescriptorAccessor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasNoStandardDescriptorAccessor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasNoStandardDescriptorAccessor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.identifierValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".identifierValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}identifierValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24106,31 +28351,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNoStandard // 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.hasNoStandardDescriptorAccessor_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.identifierValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasNoStandardDescriptorAccessor_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasNoStandardDescriptorAccessor_p, fieldNumber: 1) + if self.identifierValue != 0 { + try visitor.visitSingularInt32Field(value: self.identifierValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNoStandardDescriptorAccessor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNoStandardDescriptorAccessor) -> Bool { - if lhs.hasNoStandardDescriptorAccessor_p != rhs.hasNoStandardDescriptorAccessor_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.identifierValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.identifierValue) -> Bool { + if lhs.identifierValue != rhs.identifierValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ifMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".if" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}if\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24138,31 +28381,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNumber: Sw // 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.hasNumber_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`if`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasNumber_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasNumber_p, fieldNumber: 1) + if self.`if` != 0 { + try visitor.visitSingularInt32Field(value: self.`if`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNumber, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNumber) -> Bool { - if lhs.hasNumber_p != rhs.hasNumber_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ifMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ifMessage) -> Bool { + if lhs.`if` != rhs.`if` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasObjcClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasObjcClassPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasObjcClassPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ignoreUnknownExtensionFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ignoreUnknownExtensionFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ignoreUnknownExtensionFields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24170,31 +28411,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasObjcClassP // 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.hasObjcClassPrefix_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.ignoreUnknownExtensionFields) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasObjcClassPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasObjcClassPrefix_p, fieldNumber: 1) + if self.ignoreUnknownExtensionFields != 0 { + try visitor.visitSingularInt32Field(value: self.ignoreUnknownExtensionFields, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasObjcClassPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasObjcClassPrefix) -> Bool { - if lhs.hasObjcClassPrefix_p != rhs.hasObjcClassPrefix_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ignoreUnknownExtensionFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ignoreUnknownExtensionFields) -> Bool { + if lhs.ignoreUnknownExtensionFields != rhs.ignoreUnknownExtensionFields {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOneofIndex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasOneofIndex" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasOneofIndex"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ignoreUnknownFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ignoreUnknownFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ignoreUnknownFields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24202,31 +28441,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOneofIndex // 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.hasOneofIndex_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.ignoreUnknownFields) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasOneofIndex_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasOneofIndex_p, fieldNumber: 1) + if self.ignoreUnknownFields != 0 { + try visitor.visitSingularInt32Field(value: self.ignoreUnknownFields, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOneofIndex, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOneofIndex) -> Bool { - if lhs.hasOneofIndex_p != rhs.hasOneofIndex_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ignoreUnknownFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ignoreUnknownFields) -> Bool { + if lhs.ignoreUnknownFields != rhs.ignoreUnknownFields {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptimizeFor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasOptimizeFor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasOptimizeFor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.index: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".index" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}index\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24234,31 +28471,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptimizeFo // 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.hasOptimizeFor_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.index) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasOptimizeFor_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasOptimizeFor_p, fieldNumber: 1) + if self.index != 0 { + try visitor.visitSingularInt32Field(value: self.index, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptimizeFor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptimizeFor) -> Bool { - if lhs.hasOptimizeFor_p != rhs.hasOptimizeFor_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.index, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.index) -> Bool { + if lhs.index != rhs.index {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.initMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".init" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}init\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24266,31 +28501,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptions: S // 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.hasOptions_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.init_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasOptions_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasOptions_p, fieldNumber: 1) + if self.init_p != 0 { + try visitor.visitSingularInt32Field(value: self.init_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptions) -> Bool { - if lhs.hasOptions_p != rhs.hasOptions_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.initMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.initMessage) -> Bool { + if lhs.init_p != rhs.init_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOutputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasOutputType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasOutputType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.inoutMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".inout" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}inout\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24298,31 +28531,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOutputType // 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.hasOutputType_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`inout`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasOutputType_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasOutputType_p, fieldNumber: 1) + if self.`inout` != 0 { + try visitor.visitSingularInt32Field(value: self.`inout`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOutputType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOutputType) -> Bool { - if lhs.hasOutputType_p != rhs.hasOutputType_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.inoutMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.inoutMessage) -> Bool { + if lhs.`inout` != rhs.`inout` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.inputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".inputType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}inputType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24330,31 +28561,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPackage: S // 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.hasPackage_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.inputType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasPackage_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasPackage_p, fieldNumber: 1) + if self.inputType != 0 { + try visitor.visitSingularInt32Field(value: self.inputType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPackage) -> Bool { - if lhs.hasPackage_p != rhs.hasPackage_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.inputType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.inputType) -> Bool { + if lhs.inputType != rhs.inputType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPacked: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPacked" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasPacked"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.insert: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".insert" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}insert\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24362,31 +28591,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPacked: Sw // 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.hasPacked_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.insert) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasPacked_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasPacked_p, fieldNumber: 1) + if self.insert != 0 { + try visitor.visitSingularInt32Field(value: self.insert, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPacked, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPacked) -> Bool { - if lhs.hasPacked_p != rhs.hasPacked_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.insert, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.insert) -> Bool { + if lhs.insert != rhs.insert {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPhpClassPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasPhpClassPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Instruction: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Instruction" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Instruction\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24394,31 +28621,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpClassPr // 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.hasPhpClassPrefix_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.instruction) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasPhpClassPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasPhpClassPrefix_p, fieldNumber: 1) + if self.instruction != 0 { + try visitor.visitSingularInt32Field(value: self.instruction, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpClassPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpClassPrefix) -> Bool { - if lhs.hasPhpClassPrefix_p != rhs.hasPhpClassPrefix_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Instruction, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Instruction) -> Bool { + if lhs.instruction != rhs.instruction {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPhpGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasPhpGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.IntMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Int" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Int\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24426,31 +28651,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpGeneric // 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.hasPhpGenericServices_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.int) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasPhpGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasPhpGenericServices_p, fieldNumber: 1) + if self.int != 0 { + try visitor.visitSingularInt32Field(value: self.int, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpGenericServices) -> Bool { - if lhs.hasPhpGenericServices_p != rhs.hasPhpGenericServices_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.IntMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.IntMessage) -> Bool { + if lhs.int != rhs.int {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpMetadataNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPhpMetadataNamespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasPhpMetadataNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int32Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Int32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Int32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24458,31 +28681,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpMetadat // 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.hasPhpMetadataNamespace_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.int32) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasPhpMetadataNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasPhpMetadataNamespace_p, fieldNumber: 1) + if self.int32 != 0 { + try visitor.visitSingularInt32Field(value: self.int32, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpMetadataNamespace, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpMetadataNamespace) -> Bool { - if lhs.hasPhpMetadataNamespace_p != rhs.hasPhpMetadataNamespace_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int32Message, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int32Message) -> Bool { + if lhs.int32 != rhs.int32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPhpNamespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasPhpNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int64Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Int64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Int64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24490,31 +28711,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpNamespa // 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.hasPhpNamespace_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.int64) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasPhpNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasPhpNamespace_p, fieldNumber: 1) + if self.int64 != 0 { + try visitor.visitSingularInt32Field(value: self.int64, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpNamespace, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpNamespace) -> Bool { - if lhs.hasPhpNamespace_p != rhs.hasPhpNamespace_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int64Message, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int64Message) -> Bool { + if lhs.int64 != rhs.int64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPositiveIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPositiveIntValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasPositiveIntValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Int8" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Int8\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24522,31 +28741,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPositiveIn // 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.hasPositiveIntValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.int8) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasPositiveIntValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasPositiveIntValue_p, fieldNumber: 1) + if self.int8 != 0 { + try visitor.visitSingularInt32Field(value: self.int8, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPositiveIntValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPositiveIntValue) -> Bool { - if lhs.hasPositiveIntValue_p != rhs.hasPositiveIntValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int8, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int8) -> Bool { + if lhs.int8 != rhs.int8 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasProto3Optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasProto3Optional" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasProto3Optional"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.integerLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".integerLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}integerLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24554,31 +28771,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasProto3Opti // 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.hasProto3Optional_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.integerLiteral) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasProto3Optional_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasProto3Optional_p, fieldNumber: 1) + if self.integerLiteral != 0 { + try visitor.visitSingularInt32Field(value: self.integerLiteral, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasProto3Optional, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasProto3Optional) -> Bool { - if lhs.hasProto3Optional_p != rhs.hasProto3Optional_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.integerLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.integerLiteral) -> Bool { + if lhs.integerLiteral != rhs.integerLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPyGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPyGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasPyGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.IntegerLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".IntegerLiteralType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}IntegerLiteralType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24586,31 +28801,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPyGenericS // 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.hasPyGenericServices_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.integerLiteralType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasPyGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasPyGenericServices_p, fieldNumber: 1) + if self.integerLiteralType != 0 { + try visitor.visitSingularInt32Field(value: self.integerLiteralType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPyGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPyGenericServices) -> Bool { - if lhs.hasPyGenericServices_p != rhs.hasPyGenericServices_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.IntegerLiteralType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.IntegerLiteralType) -> Bool { + if lhs.integerLiteralType != rhs.integerLiteralType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasRubyPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasRubyPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasRubyPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.intern: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".intern" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}intern\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24618,31 +28831,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasRubyPackag // 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.hasRubyPackage_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.intern) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasRubyPackage_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasRubyPackage_p, fieldNumber: 1) + if self.intern != 0 { + try visitor.visitSingularInt32Field(value: self.intern, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasRubyPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasRubyPackage) -> Bool { - if lhs.hasRubyPackage_p != rhs.hasRubyPackage_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.intern, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.intern) -> Bool { + if lhs.intern != rhs.intern {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasServerStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasServerStreaming" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasServerStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Internal: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Internal" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Internal\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24650,31 +28861,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasServerStre // 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.hasServerStreaming_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`internal`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasServerStreaming_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasServerStreaming_p, fieldNumber: 1) + if self.`internal` != 0 { + try visitor.visitSingularInt32Field(value: self.`internal`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasServerStreaming, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasServerStreaming) -> Bool { - if lhs.hasServerStreaming_p != rhs.hasServerStreaming_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Internal, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Internal) -> Bool { + if lhs.`internal` != rhs.`internal` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSourceCodeInfo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasSourceCodeInfo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.InternalState: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".InternalState" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}InternalState\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24682,31 +28891,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceCode // 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.hasSourceCodeInfo_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.internalState) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasSourceCodeInfo_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasSourceCodeInfo_p, fieldNumber: 1) + if self.internalState != 0 { + try visitor.visitSingularInt32Field(value: self.internalState, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceCodeInfo, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceCodeInfo) -> Bool { - if lhs.hasSourceCodeInfo_p != rhs.hasSourceCodeInfo_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.InternalState, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.InternalState) -> Bool { + if lhs.internalState != rhs.internalState {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceContext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSourceContext" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasSourceContext"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.intersect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".intersect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}intersect\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24714,31 +28921,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceCont // 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.hasSourceContext_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.intersect) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasSourceContext_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasSourceContext_p, fieldNumber: 1) + if self.intersect != 0 { + try visitor.visitSingularInt32Field(value: self.intersect, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceContext, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceContext) -> Bool { - if lhs.hasSourceContext_p != rhs.hasSourceContext_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.intersect, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.intersect) -> Bool { + if lhs.intersect != rhs.intersect {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceFile: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSourceFile" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasSourceFile"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.into: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".into" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}into\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24746,31 +28951,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceFile // 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.hasSourceFile_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.into) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasSourceFile_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasSourceFile_p, fieldNumber: 1) + if self.into != 0 { + try visitor.visitSingularInt32Field(value: self.into, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceFile, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceFile) -> Bool { - if lhs.hasSourceFile_p != rhs.hasSourceFile_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.into, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.into) -> Bool { + if lhs.into != rhs.into {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasStart" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasStart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ints: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ints" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ints\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24778,31 +28981,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStart: Swi // 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.hasStart_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.ints) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasStart_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasStart_p, fieldNumber: 1) + if self.ints != 0 { + try visitor.visitSingularInt32Field(value: self.ints, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStart, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStart) -> Bool { - if lhs.hasStart_p != rhs.hasStart_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ints, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ints) -> Bool { + if lhs.ints != rhs.ints {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasStringValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasStringValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.invalidAnyTypeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".invalidAnyTypeURL" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}invalidAnyTypeURL\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24810,31 +29011,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStringValu // 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.hasStringValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.invalidAnyTypeURL) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasStringValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasStringValue_p, fieldNumber: 1) + if self.invalidAnyTypeURL != 0 { + try visitor.visitSingularInt32Field(value: self.invalidAnyTypeURL, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStringValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStringValue) -> Bool { - if lhs.hasStringValue_p != rhs.hasStringValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.invalidAnyTypeURL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.invalidAnyTypeURL) -> Bool { + if lhs.invalidAnyTypeURL != rhs.invalidAnyTypeURL {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSwiftPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSwiftPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasSwiftPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isA: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isA" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isA\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24842,31 +29041,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSwiftPrefi // 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.hasSwiftPrefix_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.isA) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasSwiftPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasSwiftPrefix_p, fieldNumber: 1) + if self.isA != 0 { + try visitor.visitSingularInt32Field(value: self.isA, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSwiftPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSwiftPrefix) -> Bool { - if lhs.hasSwiftPrefix_p != rhs.hasSwiftPrefix_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isA, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isA) -> Bool { + if lhs.isA != rhs.isA {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSyntax: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSyntax" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasSyntax"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isEqual: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isEqual" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isEqual\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24874,31 +29071,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSyntax: Sw // 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.hasSyntax_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.isEqual) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasSyntax_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasSyntax_p, fieldNumber: 1) + if self.isEqual != 0 { + try visitor.visitSingularInt32Field(value: self.isEqual, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSyntax, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSyntax) -> Bool { - if lhs.hasSyntax_p != rhs.hasSyntax_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isEqual, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isEqual) -> Bool { + if lhs.isEqual != rhs.isEqual {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTrailingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasTrailingComments" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasTrailingComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isEqualTo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isEqualTo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isEqualTo\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24906,31 +29101,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTrailingCo // 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.hasTrailingComments_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.isEqualTo) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasTrailingComments_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasTrailingComments_p, fieldNumber: 1) + if self.isEqualTo != 0 { + try visitor.visitSingularInt32Field(value: self.isEqualTo, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTrailingComments, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTrailingComments) -> Bool { - if lhs.hasTrailingComments_p != rhs.hasTrailingComments_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isEqualTo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isEqualTo) -> Bool { + if lhs.isEqualTo != rhs.isEqualTo {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isExtension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24938,31 +29131,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasType: Swif // 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.hasType_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.isExtension) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasType_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasType_p, fieldNumber: 1) + if self.isExtension != 0 { + try visitor.visitSingularInt32Field(value: self.isExtension, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasType) -> Bool { - if lhs.hasType_p != rhs.hasType_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isExtension) -> Bool { + if lhs.isExtension != rhs.isExtension {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTypeName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasTypeName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasTypeName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isInitializedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isInitialized" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isInitialized\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24970,31 +29161,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTypeName: // 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.hasTypeName_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.isInitialized_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasTypeName_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasTypeName_p, fieldNumber: 1) + if self.isInitialized_p != 0 { + try visitor.visitSingularInt32Field(value: self.isInitialized_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTypeName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTypeName) -> Bool { - if lhs.hasTypeName_p != rhs.hasTypeName_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isInitializedMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isInitializedMessage) -> Bool { + if lhs.isInitialized_p != rhs.isInitialized_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isNegative: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isNegative" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isNegative\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25002,31 +29191,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasValue: Swi // 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.hasValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.isNegative) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasValue_p, fieldNumber: 1) + if self.isNegative != 0 { + try visitor.visitSingularInt32Field(value: self.isNegative, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasValue) -> Bool { - if lhs.hasValue_p != rhs.hasValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isNegative, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isNegative) -> Bool { + if lhs.isNegative != rhs.isNegative {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasWeak: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasWeak" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasWeak"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isPathValid: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isPathValid" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isPathValid\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25034,31 +29221,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasWeak: Swif // 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.hasWeak_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.isPathValid) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasWeak_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasWeak_p, fieldNumber: 1) + if self.isPathValid != 0 { + try visitor.visitSingularInt32Field(value: self.isPathValid, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasWeak, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasWeak) -> Bool { - if lhs.hasWeak_p != rhs.hasWeak_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isPathValid, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isPathValid) -> Bool { + if lhs.isPathValid != rhs.isPathValid {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hour: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hour" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hour"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isReserved: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isReserved" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isReserved\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25066,31 +29251,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hour: SwiftPr // 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.hour) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.isReserved) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hour != 0 { - try visitor.visitSingularInt32Field(value: self.hour, fieldNumber: 1) + if self.isReserved != 0 { + try visitor.visitSingularInt32Field(value: self.isReserved, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hour, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hour) -> Bool { - if lhs.hour != rhs.hour {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isReserved, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isReserved) -> Bool { + if lhs.isReserved != rhs.isReserved {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".i" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "i"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isValid: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isValid" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isValid\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25098,31 +29281,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i: SwiftProto // 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.i) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.isValid) }() default: break } } } func traverse(visitor: inout V) throws { - if self.i != 0 { - try visitor.visitSingularInt32Field(value: self.i, fieldNumber: 1) + if self.isValid != 0 { + try visitor.visitSingularInt32Field(value: self.isValid, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i) -> Bool { - if lhs.i != rhs.i {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isValid, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isValid) -> Bool { + if lhs.isValid != rhs.isValid {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.idempotencyLevel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".idempotencyLevel" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "idempotencyLevel"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.itemTagsEncodedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".itemTagsEncodedSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}itemTagsEncodedSize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25130,31 +29311,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.idempotencyLe // 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.idempotencyLevel) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.itemTagsEncodedSize) }() default: break } } } func traverse(visitor: inout V) throws { - if self.idempotencyLevel != 0 { - try visitor.visitSingularInt32Field(value: self.idempotencyLevel, fieldNumber: 1) + if self.itemTagsEncodedSize != 0 { + try visitor.visitSingularInt32Field(value: self.itemTagsEncodedSize, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.idempotencyLevel, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.idempotencyLevel) -> Bool { - if lhs.idempotencyLevel != rhs.idempotencyLevel {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.itemTagsEncodedSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.itemTagsEncodedSize) -> Bool { + if lhs.itemTagsEncodedSize != rhs.itemTagsEncodedSize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.identifierValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".identifierValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "identifierValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.iterator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".iterator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}iterator\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25162,31 +29341,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.identifierVal // 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.identifierValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.iterator) }() default: break } } } func traverse(visitor: inout V) throws { - if self.identifierValue != 0 { - try visitor.visitSingularInt32Field(value: self.identifierValue, fieldNumber: 1) + if self.iterator != 0 { + try visitor.visitSingularInt32Field(value: self.iterator, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.identifierValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.identifierValue) -> Bool { - if lhs.identifierValue != rhs.identifierValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.iterator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.iterator) -> Bool { + if lhs.iterator != rhs.iterator {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ifMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".if" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "if"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaGenerateEqualsAndHash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".javaGenerateEqualsAndHash" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}javaGenerateEqualsAndHash\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25194,31 +29371,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ifMessage: Sw // 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.`if`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.javaGenerateEqualsAndHash) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`if` != 0 { - try visitor.visitSingularInt32Field(value: self.`if`, fieldNumber: 1) + if self.javaGenerateEqualsAndHash != 0 { + try visitor.visitSingularInt32Field(value: self.javaGenerateEqualsAndHash, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ifMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ifMessage) -> Bool { - if lhs.`if` != rhs.`if` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaGenerateEqualsAndHash, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaGenerateEqualsAndHash) -> Bool { + if lhs.javaGenerateEqualsAndHash != rhs.javaGenerateEqualsAndHash {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ignoreUnknownFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ignoreUnknownFields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ignoreUnknownFields"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".javaGenericServices" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}javaGenericServices\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25226,31 +29401,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ignoreUnknown // 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.ignoreUnknownFields) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.javaGenericServices) }() default: break } } } func traverse(visitor: inout V) throws { - if self.ignoreUnknownFields != 0 { - try visitor.visitSingularInt32Field(value: self.ignoreUnknownFields, fieldNumber: 1) + if self.javaGenericServices != 0 { + try visitor.visitSingularInt32Field(value: self.javaGenericServices, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ignoreUnknownFields, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ignoreUnknownFields) -> Bool { - if lhs.ignoreUnknownFields != rhs.ignoreUnknownFields {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaGenericServices) -> Bool { + if lhs.javaGenericServices != rhs.javaGenericServices {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.index: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".index" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "index"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaMultipleFiles: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".javaMultipleFiles" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}javaMultipleFiles\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25258,31 +29431,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.index: SwiftP // 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.index) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.javaMultipleFiles) }() default: break } } } func traverse(visitor: inout V) throws { - if self.index != 0 { - try visitor.visitSingularInt32Field(value: self.index, fieldNumber: 1) + if self.javaMultipleFiles != 0 { + try visitor.visitSingularInt32Field(value: self.javaMultipleFiles, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.index, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.index) -> Bool { - if lhs.index != rhs.index {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaMultipleFiles, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaMultipleFiles) -> Bool { + if lhs.javaMultipleFiles != rhs.javaMultipleFiles {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.initMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".init" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "init"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaOuterClassname: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".javaOuterClassname" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}javaOuterClassname\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25290,31 +29461,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.initMessage: // 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.init_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.javaOuterClassname) }() default: break } } } func traverse(visitor: inout V) throws { - if self.init_p != 0 { - try visitor.visitSingularInt32Field(value: self.init_p, fieldNumber: 1) + if self.javaOuterClassname != 0 { + try visitor.visitSingularInt32Field(value: self.javaOuterClassname, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.initMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.initMessage) -> Bool { - if lhs.init_p != rhs.init_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaOuterClassname, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaOuterClassname) -> Bool { + if lhs.javaOuterClassname != rhs.javaOuterClassname {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inoutMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".inout" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "inout"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".javaPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}javaPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25322,31 +29491,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inoutMessage: // 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.`inout`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.javaPackage) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`inout` != 0 { - try visitor.visitSingularInt32Field(value: self.`inout`, fieldNumber: 1) + if self.javaPackage != 0 { + try visitor.visitSingularInt32Field(value: self.javaPackage, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inoutMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inoutMessage) -> Bool { - if lhs.`inout` != rhs.`inout` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaPackage) -> Bool { + if lhs.javaPackage != rhs.javaPackage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".inputType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "inputType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaStringCheckUtf8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".javaStringCheckUtf8" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}javaStringCheckUtf8\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25354,31 +29521,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inputType: Sw // 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.inputType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.javaStringCheckUtf8) }() default: break } } } func traverse(visitor: inout V) throws { - if self.inputType != 0 { - try visitor.visitSingularInt32Field(value: self.inputType, fieldNumber: 1) + if self.javaStringCheckUtf8 != 0 { + try visitor.visitSingularInt32Field(value: self.javaStringCheckUtf8, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inputType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inputType) -> Bool { - if lhs.inputType != rhs.inputType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaStringCheckUtf8, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaStringCheckUtf8) -> Bool { + if lhs.javaStringCheckUtf8 != rhs.javaStringCheckUtf8 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.insert: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".insert" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "insert"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONDecoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONDecoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25386,31 +29551,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.insert: Swift // 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.insert) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsondecoder) }() default: break } } } func traverse(visitor: inout V) throws { - if self.insert != 0 { - try visitor.visitSingularInt32Field(value: self.insert, fieldNumber: 1) + if self.jsondecoder != 0 { + try visitor.visitSingularInt32Field(value: self.jsondecoder, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.insert, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.insert) -> Bool { - if lhs.insert != rhs.insert {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecoder) -> Bool { + if lhs.jsondecoder != rhs.jsondecoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Int" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Int"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONDecoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONDecoding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25418,31 +29581,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntMessage: S // 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.int) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsondecoding) }() default: break } } } func traverse(visitor: inout V) throws { - if self.int != 0 { - try visitor.visitSingularInt32Field(value: self.int, fieldNumber: 1) + if self.jsondecoding != 0 { + try visitor.visitSingularInt32Field(value: self.jsondecoding, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntMessage) -> Bool { - if lhs.int != rhs.int {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecoding) -> Bool { + if lhs.jsondecoding != rhs.jsondecoding {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Int32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Int32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONDecodingError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONDecodingError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25450,31 +29611,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Message: // 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.int32) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsondecodingError) }() default: break } } } func traverse(visitor: inout V) throws { - if self.int32 != 0 { - try visitor.visitSingularInt32Field(value: self.int32, fieldNumber: 1) + if self.jsondecodingError != 0 { + try visitor.visitSingularInt32Field(value: self.jsondecodingError, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Message, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Message) -> Bool { - if lhs.int32 != rhs.int32 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecodingError) -> Bool { + if lhs.jsondecodingError != rhs.jsondecodingError {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Int32Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Int32Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONDecodingOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONDecodingOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25482,31 +29641,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Value: S // 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.int32Value) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsondecodingOptions) }() default: break } } } func traverse(visitor: inout V) throws { - if self.int32Value != 0 { - try visitor.visitSingularInt32Field(value: self.int32Value, fieldNumber: 1) + if self.jsondecodingOptions != 0 { + try visitor.visitSingularInt32Field(value: self.jsondecodingOptions, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Value) -> Bool { - if lhs.int32Value != rhs.int32Value {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecodingOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecodingOptions) -> Bool { + if lhs.jsondecodingOptions != rhs.jsondecodingOptions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Int64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Int64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonEncoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonEncoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonEncoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25514,31 +29671,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Message: // 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.int64) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonEncoder) }() default: break } } } func traverse(visitor: inout V) throws { - if self.int64 != 0 { - try visitor.visitSingularInt32Field(value: self.int64, fieldNumber: 1) + if self.jsonEncoder != 0 { + try visitor.visitSingularInt32Field(value: self.jsonEncoder, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Message, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Message) -> Bool { - if lhs.int64 != rhs.int64 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonEncoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonEncoder) -> Bool { + if lhs.jsonEncoder != rhs.jsonEncoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Int64Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Int64Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONEncoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONEncoding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25546,31 +29701,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Value: S // 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.int64Value) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonencoding) }() default: break } } } func traverse(visitor: inout V) throws { - if self.int64Value != 0 { - try visitor.visitSingularInt32Field(value: self.int64Value, fieldNumber: 1) + if self.jsonencoding != 0 { + try visitor.visitSingularInt32Field(value: self.jsonencoding, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Value) -> Bool { - if lhs.int64Value != rhs.int64Value {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncoding) -> Bool { + if lhs.jsonencoding != rhs.jsonencoding {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Int8" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Int8"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONEncodingError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONEncodingError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25578,31 +29731,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int8: SwiftPr // 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.int8) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonencodingError) }() default: break } } } func traverse(visitor: inout V) throws { - if self.int8 != 0 { - try visitor.visitSingularInt32Field(value: self.int8, fieldNumber: 1) + if self.jsonencodingError != 0 { + try visitor.visitSingularInt32Field(value: self.jsonencodingError, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int8, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int8) -> Bool { - if lhs.int8 != rhs.int8 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingError) -> Bool { + if lhs.jsonencodingError != rhs.jsonencodingError {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.integerLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".integerLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "integerLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONEncodingOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONEncodingOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25610,31 +29761,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.integerLitera // 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.integerLiteral) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonencodingOptions) }() default: break } } } func traverse(visitor: inout V) throws { - if self.integerLiteral != 0 { - try visitor.visitSingularInt32Field(value: self.integerLiteral, fieldNumber: 1) + if self.jsonencodingOptions != 0 { + try visitor.visitSingularInt32Field(value: self.jsonencodingOptions, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.integerLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.integerLiteral) -> Bool { - if lhs.integerLiteral != rhs.integerLiteral {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingOptions) -> Bool { + if lhs.jsonencodingOptions != rhs.jsonencodingOptions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntegerLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".IntegerLiteralType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "IntegerLiteralType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONEncodingVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONEncodingVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25642,31 +29791,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntegerLitera // 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.integerLiteralType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonencodingVisitor) }() default: break } } } func traverse(visitor: inout V) throws { - if self.integerLiteralType != 0 { - try visitor.visitSingularInt32Field(value: self.integerLiteralType, fieldNumber: 1) + if self.jsonencodingVisitor != 0 { + try visitor.visitSingularInt32Field(value: self.jsonencodingVisitor, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntegerLiteralType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntegerLiteralType) -> Bool { - if lhs.integerLiteralType != rhs.integerLiteralType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingVisitor) -> Bool { + if lhs.jsonencodingVisitor != rhs.jsonencodingVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.intern: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".intern" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "intern"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonFormat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25674,31 +29821,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.intern: Swift // 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.intern) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonFormat) }() default: break } } } func traverse(visitor: inout V) throws { - if self.intern != 0 { - try visitor.visitSingularInt32Field(value: self.intern, fieldNumber: 1) + if self.jsonFormat != 0 { + try visitor.visitSingularInt32Field(value: self.jsonFormat, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.intern, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.intern) -> Bool { - if lhs.intern != rhs.intern {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonFormat) -> Bool { + if lhs.jsonFormat != rhs.jsonFormat {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Internal: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Internal" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Internal"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONMapEncodingVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONMapEncodingVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONMapEncodingVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25706,31 +29851,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Internal: Swi // 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.`internal`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonmapEncodingVisitor) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`internal` != 0 { - try visitor.visitSingularInt32Field(value: self.`internal`, fieldNumber: 1) + if self.jsonmapEncodingVisitor != 0 { + try visitor.visitSingularInt32Field(value: self.jsonmapEncodingVisitor, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Internal, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Internal) -> Bool { - if lhs.`internal` != rhs.`internal` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONMapEncodingVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONMapEncodingVisitor) -> Bool { + if lhs.jsonmapEncodingVisitor != rhs.jsonmapEncodingVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.InternalState: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".InternalState" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "InternalState"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25738,31 +29881,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.InternalState // 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.internalState) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonName) }() default: break } } } func traverse(visitor: inout V) throws { - if self.internalState != 0 { - try visitor.visitSingularInt32Field(value: self.internalState, fieldNumber: 1) + if self.jsonName != 0 { + try visitor.visitSingularInt32Field(value: self.jsonName, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.InternalState, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.InternalState) -> Bool { - if lhs.internalState != rhs.internalState {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonName) -> Bool { + if lhs.jsonName != rhs.jsonName {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.into: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".into" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "into"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonPath: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonPath" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonPath\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25770,31 +29911,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.into: SwiftPr // 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.into) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonPath) }() default: break } } } func traverse(visitor: inout V) throws { - if self.into != 0 { - try visitor.visitSingularInt32Field(value: self.into, fieldNumber: 1) + if self.jsonPath != 0 { + try visitor.visitSingularInt32Field(value: self.jsonPath, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.into, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.into) -> Bool { - if lhs.into != rhs.into {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonPath, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonPath) -> Bool { + if lhs.jsonPath != rhs.jsonPath {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ints: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ints" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ints"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonPaths: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonPaths" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonPaths\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25802,31 +29941,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ints: SwiftPr // 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.ints) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonPaths) }() default: break } } } func traverse(visitor: inout V) throws { - if self.ints != 0 { - try visitor.visitSingularInt32Field(value: self.ints, fieldNumber: 1) + if self.jsonPaths != 0 { + try visitor.visitSingularInt32Field(value: self.jsonPaths, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ints, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ints) -> Bool { - if lhs.ints != rhs.ints {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonPaths, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonPaths) -> Bool { + if lhs.jsonPaths != rhs.jsonPaths {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isA: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".isA" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "isA"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONScanner: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONScanner" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONScanner\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25834,31 +29971,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isA: SwiftPro // 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.isA) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonscanner) }() default: break } } } func traverse(visitor: inout V) throws { - if self.isA != 0 { - try visitor.visitSingularInt32Field(value: self.isA, fieldNumber: 1) + if self.jsonscanner != 0 { + try visitor.visitSingularInt32Field(value: self.jsonscanner, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isA, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isA) -> Bool { - if lhs.isA != rhs.isA {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONScanner, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONScanner) -> Bool { + if lhs.jsonscanner != rhs.jsonscanner {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqual: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".isEqual" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "isEqual"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonString\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25866,31 +30001,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqual: Swif // 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.isEqual) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonString) }() default: break } } } func traverse(visitor: inout V) throws { - if self.isEqual != 0 { - try visitor.visitSingularInt32Field(value: self.isEqual, fieldNumber: 1) + if self.jsonString != 0 { + try visitor.visitSingularInt32Field(value: self.jsonString, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqual, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqual) -> Bool { - if lhs.isEqual != rhs.isEqual {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonString) -> Bool { + if lhs.jsonString != rhs.jsonString {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqualTo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".isEqualTo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "isEqualTo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonText: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonText" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonText\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25898,31 +30031,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqualTo: Sw // 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.isEqualTo) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonText) }() default: break } } } func traverse(visitor: inout V) throws { - if self.isEqualTo != 0 { - try visitor.visitSingularInt32Field(value: self.isEqualTo, fieldNumber: 1) + if self.jsonText != 0 { + try visitor.visitSingularInt32Field(value: self.jsonText, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqualTo, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqualTo) -> Bool { - if lhs.isEqualTo != rhs.isEqualTo {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonText, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonText) -> Bool { + if lhs.jsonText != rhs.jsonText {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".isExtension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "isExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonUTF8Bytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonUTF8Bytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonUTF8Bytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25930,31 +30061,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isExtension: // 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.isExtension) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonUtf8Bytes) }() default: break } } } func traverse(visitor: inout V) throws { - if self.isExtension != 0 { - try visitor.visitSingularInt32Field(value: self.isExtension, fieldNumber: 1) + if self.jsonUtf8Bytes != 0 { + try visitor.visitSingularInt32Field(value: self.jsonUtf8Bytes, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isExtension, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isExtension) -> Bool { - if lhs.isExtension != rhs.isExtension {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonUTF8Bytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonUTF8Bytes) -> Bool { + if lhs.jsonUtf8Bytes != rhs.jsonUtf8Bytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isInitializedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".isInitialized" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "isInitialized"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonUTF8Data: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonUTF8Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonUTF8Data\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25962,31 +30091,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isInitialized // 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.isInitialized_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonUtf8Data) }() default: break } } } func traverse(visitor: inout V) throws { - if self.isInitialized_p != 0 { - try visitor.visitSingularInt32Field(value: self.isInitialized_p, fieldNumber: 1) + if self.jsonUtf8Data != 0 { + try visitor.visitSingularInt32Field(value: self.jsonUtf8Data, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isInitializedMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isInitializedMessage) -> Bool { - if lhs.isInitialized_p != rhs.isInitialized_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonUTF8Data, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonUTF8Data) -> Bool { + if lhs.jsonUtf8Data != rhs.jsonUtf8Data {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.itemTagsEncodedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".itemTagsEncodedSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "itemTagsEncodedSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jstype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jstype" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jstype\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25994,31 +30121,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.itemTagsEncod // 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.itemTagsEncodedSize) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jstype) }() default: break } } } func traverse(visitor: inout V) throws { - if self.itemTagsEncodedSize != 0 { - try visitor.visitSingularInt32Field(value: self.itemTagsEncodedSize, fieldNumber: 1) + if self.jstype != 0 { + try visitor.visitSingularInt32Field(value: self.jstype, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.itemTagsEncodedSize, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.itemTagsEncodedSize) -> Bool { - if lhs.itemTagsEncodedSize != rhs.itemTagsEncodedSize {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jstype, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jstype) -> Bool { + if lhs.jstype != rhs.jstype {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Iterator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Iterator" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Iterator"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.k: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".k" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}k\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26026,31 +30151,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Iterator: Swi // 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.iterator) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.k) }() default: break } } } func traverse(visitor: inout V) throws { - if self.iterator != 0 { - try visitor.visitSingularInt32Field(value: self.iterator, fieldNumber: 1) + if self.k != 0 { + try visitor.visitSingularInt32Field(value: self.k, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Iterator, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Iterator) -> Bool { - if lhs.iterator != rhs.iterator {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.k, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.k) -> Bool { + if lhs.k != rhs.k {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i_2166136261: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".i_2166136261" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "i_2166136261"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.kChunkSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".kChunkSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}kChunkSize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26058,31 +30181,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i_2166136261: // 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.i2166136261) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.kChunkSize) }() default: break } } } func traverse(visitor: inout V) throws { - if self.i2166136261 != 0 { - try visitor.visitSingularInt32Field(value: self.i2166136261, fieldNumber: 1) + if self.kChunkSize != 0 { + try visitor.visitSingularInt32Field(value: self.kChunkSize, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i_2166136261, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i_2166136261) -> Bool { - if lhs.i2166136261 != rhs.i2166136261 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.kChunkSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.kChunkSize) -> Bool { + if lhs.kChunkSize != rhs.kChunkSize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenerateEqualsAndHash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".javaGenerateEqualsAndHash" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "javaGenerateEqualsAndHash"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Key: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Key" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Key\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26090,31 +30211,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenerateE // 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.javaGenerateEqualsAndHash) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.key) }() default: break } } } func traverse(visitor: inout V) throws { - if self.javaGenerateEqualsAndHash != 0 { - try visitor.visitSingularInt32Field(value: self.javaGenerateEqualsAndHash, fieldNumber: 1) + if self.key != 0 { + try visitor.visitSingularInt32Field(value: self.key, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenerateEqualsAndHash, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenerateEqualsAndHash) -> Bool { - if lhs.javaGenerateEqualsAndHash != rhs.javaGenerateEqualsAndHash {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Key, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Key) -> Bool { + if lhs.key != rhs.key {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".javaGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "javaGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.keyField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".keyField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}keyField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26122,31 +30241,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenericSe // 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.javaGenericServices) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.keyField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.javaGenericServices != 0 { - try visitor.visitSingularInt32Field(value: self.javaGenericServices, fieldNumber: 1) + if self.keyField != 0 { + try visitor.visitSingularInt32Field(value: self.keyField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenericServices) -> Bool { - if lhs.javaGenericServices != rhs.javaGenericServices {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.keyField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.keyField) -> Bool { + if lhs.keyField != rhs.keyField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaMultipleFiles: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".javaMultipleFiles" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "javaMultipleFiles"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.keyFieldOpt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".keyFieldOpt" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}keyFieldOpt\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26154,31 +30271,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaMultipleF // 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.javaMultipleFiles) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.keyFieldOpt) }() default: break } } } func traverse(visitor: inout V) throws { - if self.javaMultipleFiles != 0 { - try visitor.visitSingularInt32Field(value: self.javaMultipleFiles, fieldNumber: 1) + if self.keyFieldOpt != 0 { + try visitor.visitSingularInt32Field(value: self.keyFieldOpt, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaMultipleFiles, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaMultipleFiles) -> Bool { - if lhs.javaMultipleFiles != rhs.javaMultipleFiles {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.keyFieldOpt, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.keyFieldOpt) -> Bool { + if lhs.keyFieldOpt != rhs.keyFieldOpt {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaOuterClassname: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".javaOuterClassname" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "javaOuterClassname"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.KeyType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".KeyType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}KeyType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26186,31 +30301,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaOuterClas // 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.javaOuterClassname) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.keyType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.javaOuterClassname != 0 { - try visitor.visitSingularInt32Field(value: self.javaOuterClassname, fieldNumber: 1) + if self.keyType != 0 { + try visitor.visitSingularInt32Field(value: self.keyType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaOuterClassname, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaOuterClassname) -> Bool { - if lhs.javaOuterClassname != rhs.javaOuterClassname {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.KeyType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.KeyType) -> Bool { + if lhs.keyType != rhs.keyType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".javaPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "javaPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.kind: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".kind" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}kind\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26218,31 +30331,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaPackage: // 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.javaPackage) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.kind) }() default: break } } } func traverse(visitor: inout V) throws { - if self.javaPackage != 0 { - try visitor.visitSingularInt32Field(value: self.javaPackage, fieldNumber: 1) + if self.kind != 0 { + try visitor.visitSingularInt32Field(value: self.kind, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaPackage) -> Bool { - if lhs.javaPackage != rhs.javaPackage {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.kind, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.kind) -> Bool { + if lhs.kind != rhs.kind {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaStringCheckUtf8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".javaStringCheckUtf8" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "javaStringCheckUtf8"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.l: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".l" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}l\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26250,31 +30361,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaStringChe // 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.javaStringCheckUtf8) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.l) }() default: break } } } func traverse(visitor: inout V) throws { - if self.javaStringCheckUtf8 != 0 { - try visitor.visitSingularInt32Field(value: self.javaStringCheckUtf8, fieldNumber: 1) + if self.l != 0 { + try visitor.visitSingularInt32Field(value: self.l, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaStringCheckUtf8, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaStringCheckUtf8) -> Bool { - if lhs.javaStringCheckUtf8 != rhs.javaStringCheckUtf8 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.l, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.l) -> Bool { + if lhs.l != rhs.l {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONDecoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "JSONDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.label: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".label" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}label\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26282,31 +30391,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecoder: // 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.jsondecoder) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.label) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsondecoder != 0 { - try visitor.visitSingularInt32Field(value: self.jsondecoder, fieldNumber: 1) + if self.label != 0 { + try visitor.visitSingularInt32Field(value: self.label, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecoder) -> Bool { - if lhs.jsondecoder != rhs.jsondecoder {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.label, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.label) -> Bool { + if lhs.label != rhs.label {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONDecodingError" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "JSONDecodingError"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".lazy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}lazy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26314,31 +30421,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingE // 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.jsondecodingError) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.lazy) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsondecodingError != 0 { - try visitor.visitSingularInt32Field(value: self.jsondecodingError, fieldNumber: 1) + if self.lazy != 0 { + try visitor.visitSingularInt32Field(value: self.lazy, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingError, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingError) -> Bool { - if lhs.jsondecodingError != rhs.jsondecodingError {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lazy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lazy) -> Bool { + if lhs.lazy != rhs.lazy {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONDecodingOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "JSONDecodingOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.leadingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".leadingComments" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}leadingComments\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26346,31 +30451,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingO // 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.jsondecodingOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.leadingComments) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsondecodingOptions != 0 { - try visitor.visitSingularInt32Field(value: self.jsondecodingOptions, fieldNumber: 1) + if self.leadingComments != 0 { + try visitor.visitSingularInt32Field(value: self.leadingComments, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingOptions) -> Bool { - if lhs.jsondecodingOptions != rhs.jsondecodingOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.leadingComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.leadingComments) -> Bool { + if lhs.leadingComments != rhs.leadingComments {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonEncoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonEncoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jsonEncoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.leadingDetachedComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".leadingDetachedComments" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}leadingDetachedComments\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26378,31 +30481,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonEncoder: // 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.jsonEncoder) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.leadingDetachedComments) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonEncoder != 0 { - try visitor.visitSingularInt32Field(value: self.jsonEncoder, fieldNumber: 1) + if self.leadingDetachedComments != 0 { + try visitor.visitSingularInt32Field(value: self.leadingDetachedComments, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonEncoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonEncoder) -> Bool { - if lhs.jsonEncoder != rhs.jsonEncoder {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.leadingDetachedComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.leadingDetachedComments) -> Bool { + if lhs.leadingDetachedComments != rhs.leadingDetachedComments {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONEncodingError" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "JSONEncodingError"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.length: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".length" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}length\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26410,31 +30511,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingE // 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.jsonencodingError) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.length) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonencodingError != 0 { - try visitor.visitSingularInt32Field(value: self.jsonencodingError, fieldNumber: 1) + if self.length != 0 { + try visitor.visitSingularInt32Field(value: self.length, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingError, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingError) -> Bool { - if lhs.jsonencodingError != rhs.jsonencodingError {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.length, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.length) -> Bool { + if lhs.length != rhs.length {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONEncodingOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "JSONEncodingOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lessThan: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".lessThan" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}lessThan\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26442,31 +30541,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingO // 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.jsonencodingOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.lessThan) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonencodingOptions != 0 { - try visitor.visitSingularInt32Field(value: self.jsonencodingOptions, fieldNumber: 1) + if self.lessThan != 0 { + try visitor.visitSingularInt32Field(value: self.lessThan, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingOptions) -> Bool { - if lhs.jsonencodingOptions != rhs.jsonencodingOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lessThan, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lessThan) -> Bool { + if lhs.lessThan != rhs.lessThan {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONEncodingVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "JSONEncodingVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.letMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".let" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}let\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26474,31 +30571,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingV // 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.jsonencodingVisitor) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`let`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonencodingVisitor != 0 { - try visitor.visitSingularInt32Field(value: self.jsonencodingVisitor, fieldNumber: 1) + if self.`let` != 0 { + try visitor.visitSingularInt32Field(value: self.`let`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingVisitor) -> Bool { - if lhs.jsonencodingVisitor != rhs.jsonencodingVisitor {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.letMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.letMessage) -> Bool { + if lhs.`let` != rhs.`let` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONMapEncodingVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONMapEncodingVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "JSONMapEncodingVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lhs: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".lhs" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}lhs\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26506,31 +30601,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONMapEncodi // 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.jsonmapEncodingVisitor) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.lhs) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonmapEncodingVisitor != 0 { - try visitor.visitSingularInt32Field(value: self.jsonmapEncodingVisitor, fieldNumber: 1) + if self.lhs != 0 { + try visitor.visitSingularInt32Field(value: self.lhs, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONMapEncodingVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONMapEncodingVisitor) -> Bool { - if lhs.jsonmapEncodingVisitor != rhs.jsonmapEncodingVisitor {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lhs, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lhs) -> Bool { + if lhs.lhs != rhs.lhs {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jsonName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.line: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".line" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}line\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26538,31 +30631,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonName: Swi // 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.jsonName) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.line) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonName != 0 { - try visitor.visitSingularInt32Field(value: self.jsonName, fieldNumber: 1) + if self.line != 0 { + try visitor.visitSingularInt32Field(value: self.line, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonName) -> Bool { - if lhs.jsonName != rhs.jsonName {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.line, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.line) -> Bool { + if lhs.line != rhs.line {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPath: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonPath" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jsonPath"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.list: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".list" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}list\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26570,31 +30661,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPath: Swi // 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.jsonPath) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.list) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonPath != 0 { - try visitor.visitSingularInt32Field(value: self.jsonPath, fieldNumber: 1) + if self.list != 0 { + try visitor.visitSingularInt32Field(value: self.list, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPath, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPath) -> Bool { - if lhs.jsonPath != rhs.jsonPath {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.list, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.list) -> Bool { + if lhs.list != rhs.list {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPaths: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonPaths" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jsonPaths"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.listOfMessages: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".listOfMessages" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}listOfMessages\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26602,31 +30691,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPaths: Sw // 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.jsonPaths) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.listOfMessages) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonPaths != 0 { - try visitor.visitSingularInt32Field(value: self.jsonPaths, fieldNumber: 1) + if self.listOfMessages != 0 { + try visitor.visitSingularInt32Field(value: self.listOfMessages, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPaths, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPaths) -> Bool { - if lhs.jsonPaths != rhs.jsonPaths {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.listOfMessages, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.listOfMessages) -> Bool { + if lhs.listOfMessages != rhs.listOfMessages {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONScanner: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONScanner" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "JSONScanner"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.listValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".listValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}listValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26634,31 +30721,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONScanner: // 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.jsonscanner) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.listValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonscanner != 0 { - try visitor.visitSingularInt32Field(value: self.jsonscanner, fieldNumber: 1) + if self.listValue != 0 { + try visitor.visitSingularInt32Field(value: self.listValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONScanner, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONScanner) -> Bool { - if lhs.jsonscanner != rhs.jsonscanner {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.listValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.listValue) -> Bool { + if lhs.listValue != rhs.listValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonString" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jsonString"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.littleEndian: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".littleEndian" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}littleEndian\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26666,31 +30751,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonString: S // 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.jsonString) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.littleEndian) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonString != 0 { - try visitor.visitSingularInt32Field(value: self.jsonString, fieldNumber: 1) + if self.littleEndian != 0 { + try visitor.visitSingularInt32Field(value: self.littleEndian, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonString, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonString) -> Bool { - if lhs.jsonString != rhs.jsonString {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.littleEndian, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.littleEndian) -> Bool { + if lhs.littleEndian != rhs.littleEndian {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonText: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonText" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jsonText"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.load: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".load" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}load\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26698,31 +30781,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonText: Swi // 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.jsonText) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.load) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonText != 0 { - try visitor.visitSingularInt32Field(value: self.jsonText, fieldNumber: 1) + if self.load != 0 { + try visitor.visitSingularInt32Field(value: self.load, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonText, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonText) -> Bool { - if lhs.jsonText != rhs.jsonText {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.load, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.load) -> Bool { + if lhs.load != rhs.load {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonUTF8Data: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonUTF8Data" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jsonUTF8Data"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.localHasher: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".localHasher" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}localHasher\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26730,31 +30811,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonUTF8Data: // 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.jsonUtf8Data) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.localHasher) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonUtf8Data != 0 { - try visitor.visitSingularInt32Field(value: self.jsonUtf8Data, fieldNumber: 1) + if self.localHasher != 0 { + try visitor.visitSingularInt32Field(value: self.localHasher, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonUTF8Data, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonUTF8Data) -> Bool { - if lhs.jsonUtf8Data != rhs.jsonUtf8Data {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.localHasher, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.localHasher) -> Bool { + if lhs.localHasher != rhs.localHasher {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jstype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".jstype" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jstype"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.location: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".location" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}location\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26762,31 +30841,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jstype: Swift // 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.jstype) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.location) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jstype != 0 { - try visitor.visitSingularInt32Field(value: self.jstype, fieldNumber: 1) + if self.location != 0 { + try visitor.visitSingularInt32Field(value: self.location, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jstype, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jstype) -> Bool { - if lhs.jstype != rhs.jstype {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.location, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.location) -> Bool { + if lhs.location != rhs.location {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.k: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".k" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "k"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.M: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".M" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}M\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26794,31 +30871,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.k: SwiftProto // 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.k) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.m) }() default: break } } } func traverse(visitor: inout V) throws { - if self.k != 0 { - try visitor.visitSingularInt32Field(value: self.k, fieldNumber: 1) + if self.m != 0 { + try visitor.visitSingularInt32Field(value: self.m, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.k, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.k) -> Bool { - if lhs.k != rhs.k {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.M, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.M) -> Bool { + if lhs.m != rhs.m {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Key: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Key" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Key"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.major: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".major" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}major\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26826,31 +30901,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Key: SwiftPro // 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.key) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.major) }() default: break } } } func traverse(visitor: inout V) throws { - if self.key != 0 { - try visitor.visitSingularInt32Field(value: self.key, fieldNumber: 1) + if self.major != 0 { + try visitor.visitSingularInt32Field(value: self.major, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Key, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Key) -> Bool { - if lhs.key != rhs.key {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.major, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.major) -> Bool { + if lhs.major != rhs.major {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.keyField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".keyField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "keyField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeAsyncIterator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".makeAsyncIterator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}makeAsyncIterator\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26858,31 +30931,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.keyField: Swi // 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.keyField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.makeAsyncIterator) }() default: break } } } func traverse(visitor: inout V) throws { - if self.keyField != 0 { - try visitor.visitSingularInt32Field(value: self.keyField, fieldNumber: 1) + if self.makeAsyncIterator != 0 { + try visitor.visitSingularInt32Field(value: self.makeAsyncIterator, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.keyField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.keyField) -> Bool { - if lhs.keyField != rhs.keyField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeAsyncIterator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeAsyncIterator) -> Bool { + if lhs.makeAsyncIterator != rhs.makeAsyncIterator {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.KeyType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".KeyType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "KeyType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeIterator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".makeIterator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}makeIterator\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26890,31 +30961,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.KeyType: Swif // 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.keyType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.makeIterator) }() default: break } } } func traverse(visitor: inout V) throws { - if self.keyType != 0 { - try visitor.visitSingularInt32Field(value: self.keyType, fieldNumber: 1) + if self.makeIterator != 0 { + try visitor.visitSingularInt32Field(value: self.makeIterator, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.KeyType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.KeyType) -> Bool { - if lhs.keyType != rhs.keyType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeIterator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeIterator) -> Bool { + if lhs.makeIterator != rhs.makeIterator {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.kind: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".kind" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "kind"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.malformedLength: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".malformedLength" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}malformedLength\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26922,31 +30991,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.kind: SwiftPr // 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.kind) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.malformedLength) }() default: break } } } func traverse(visitor: inout V) throws { - if self.kind != 0 { - try visitor.visitSingularInt32Field(value: self.kind, fieldNumber: 1) + if self.malformedLength != 0 { + try visitor.visitSingularInt32Field(value: self.malformedLength, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.kind, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.kind) -> Bool { - if lhs.kind != rhs.kind {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.malformedLength, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.malformedLength) -> Bool { + if lhs.malformedLength != rhs.malformedLength {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.l: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".l" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "l"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".mapEntry" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mapEntry\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26954,31 +31021,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.l: SwiftProto // 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.l) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mapEntry) }() default: break } } } func traverse(visitor: inout V) throws { - if self.l != 0 { - try visitor.visitSingularInt32Field(value: self.l, fieldNumber: 1) + if self.mapEntry != 0 { + try visitor.visitSingularInt32Field(value: self.mapEntry, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.l, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.l) -> Bool { - if lhs.l != rhs.l {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapEntry, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapEntry) -> Bool { + if lhs.mapEntry != rhs.mapEntry {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.label: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".label" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "label"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MapKeyType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".MapKeyType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}MapKeyType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26986,31 +31051,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.label: SwiftP // 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.label) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mapKeyType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.label != 0 { - try visitor.visitSingularInt32Field(value: self.label, fieldNumber: 1) + if self.mapKeyType != 0 { + try visitor.visitSingularInt32Field(value: self.mapKeyType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.label, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.label) -> Bool { - if lhs.label != rhs.label {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MapKeyType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MapKeyType) -> Bool { + if lhs.mapKeyType != rhs.mapKeyType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".lazy" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "lazy"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapToMessages: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".mapToMessages" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mapToMessages\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27018,31 +31081,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lazy: SwiftPr // 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.lazy) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mapToMessages) }() default: break } } } func traverse(visitor: inout V) throws { - if self.lazy != 0 { - try visitor.visitSingularInt32Field(value: self.lazy, fieldNumber: 1) + if self.mapToMessages != 0 { + try visitor.visitSingularInt32Field(value: self.mapToMessages, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lazy, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lazy) -> Bool { - if lhs.lazy != rhs.lazy {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapToMessages, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapToMessages) -> Bool { + if lhs.mapToMessages != rhs.mapToMessages {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".leadingComments" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "leadingComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MapValueType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".MapValueType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}MapValueType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27050,31 +31111,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingCommen // 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.leadingComments) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mapValueType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.leadingComments != 0 { - try visitor.visitSingularInt32Field(value: self.leadingComments, fieldNumber: 1) + if self.mapValueType != 0 { + try visitor.visitSingularInt32Field(value: self.mapValueType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingComments, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingComments) -> Bool { - if lhs.leadingComments != rhs.leadingComments {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MapValueType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MapValueType) -> Bool { + if lhs.mapValueType != rhs.mapValueType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingDetachedComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".leadingDetachedComments" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "leadingDetachedComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".mapVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mapVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27082,31 +31141,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingDetach // 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.leadingDetachedComments) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mapVisitor) }() default: break } } } func traverse(visitor: inout V) throws { - if self.leadingDetachedComments != 0 { - try visitor.visitSingularInt32Field(value: self.leadingDetachedComments, fieldNumber: 1) + if self.mapVisitor != 0 { + try visitor.visitSingularInt32Field(value: self.mapVisitor, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingDetachedComments, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingDetachedComments) -> Bool { - if lhs.leadingDetachedComments != rhs.leadingDetachedComments {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapVisitor) -> Bool { + if lhs.mapVisitor != rhs.mapVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.length: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".length" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "length"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mask: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".mask" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mask\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27114,31 +31171,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.length: Swift // 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.length) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mask) }() default: break } } } func traverse(visitor: inout V) throws { - if self.length != 0 { - try visitor.visitSingularInt32Field(value: self.length, fieldNumber: 1) + if self.mask != 0 { + try visitor.visitSingularInt32Field(value: self.mask, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.length, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.length) -> Bool { - if lhs.length != rhs.length {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mask, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mask) -> Bool { + if lhs.mask != rhs.mask {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lessThan: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".lessThan" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "lessThan"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.maximumEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".maximumEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}maximumEdition\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27146,31 +31201,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lessThan: Swi // 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.lessThan) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.maximumEdition) }() default: break } } } func traverse(visitor: inout V) throws { - if self.lessThan != 0 { - try visitor.visitSingularInt32Field(value: self.lessThan, fieldNumber: 1) + if self.maximumEdition != 0 { + try visitor.visitSingularInt32Field(value: self.maximumEdition, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lessThan, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lessThan) -> Bool { - if lhs.lessThan != rhs.lessThan {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.maximumEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.maximumEdition) -> Bool { + if lhs.maximumEdition != rhs.maximumEdition {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.letMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".let" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "let"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mdayStart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".mdayStart" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mdayStart\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27178,31 +31231,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.letMessage: S // 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.`let`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mdayStart) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`let` != 0 { - try visitor.visitSingularInt32Field(value: self.`let`, fieldNumber: 1) + if self.mdayStart != 0 { + try visitor.visitSingularInt32Field(value: self.mdayStart, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.letMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.letMessage) -> Bool { - if lhs.`let` != rhs.`let` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mdayStart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mdayStart) -> Bool { + if lhs.mdayStart != rhs.mdayStart {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lhs: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".lhs" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "lhs"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.merge: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".merge" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}merge\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27210,31 +31261,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lhs: SwiftPro // 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.lhs) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.merge) }() default: break } } } func traverse(visitor: inout V) throws { - if self.lhs != 0 { - try visitor.visitSingularInt32Field(value: self.lhs, fieldNumber: 1) + if self.merge != 0 { + try visitor.visitSingularInt32Field(value: self.merge, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lhs, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lhs) -> Bool { - if lhs.lhs != rhs.lhs {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.merge, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.merge) -> Bool { + if lhs.merge != rhs.merge {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.list: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".list" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "list"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MergeOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".MergeOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}MergeOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27242,31 +31291,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.list: SwiftPr // 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.list) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mergeOptions) }() default: break } } } func traverse(visitor: inout V) throws { - if self.list != 0 { - try visitor.visitSingularInt32Field(value: self.list, fieldNumber: 1) + if self.mergeOptions != 0 { + try visitor.visitSingularInt32Field(value: self.mergeOptions, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.list, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.list) -> Bool { - if lhs.list != rhs.list {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MergeOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MergeOptions) -> Bool { + if lhs.mergeOptions != rhs.mergeOptions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listOfMessages: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".listOfMessages" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "listOfMessages"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".message" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}message\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27274,31 +31321,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listOfMessage // 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.listOfMessages) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.message) }() default: break } } } func traverse(visitor: inout V) throws { - if self.listOfMessages != 0 { - try visitor.visitSingularInt32Field(value: self.listOfMessages, fieldNumber: 1) + if self.message != 0 { + try visitor.visitSingularInt32Field(value: self.message, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listOfMessages, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listOfMessages) -> Bool { - if lhs.listOfMessages != rhs.listOfMessages {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.message, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.message) -> Bool { + if lhs.message != rhs.message {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".listValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "listValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageDepthLimit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".messageDepthLimit" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}messageDepthLimit\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27306,31 +31351,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listValue: Sw // 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.listValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.messageDepthLimit) }() default: break } } } func traverse(visitor: inout V) throws { - if self.listValue != 0 { - try visitor.visitSingularInt32Field(value: self.listValue, fieldNumber: 1) + if self.messageDepthLimit != 0 { + try visitor.visitSingularInt32Field(value: self.messageDepthLimit, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listValue) -> Bool { - if lhs.listValue != rhs.listValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageDepthLimit, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageDepthLimit) -> Bool { + if lhs.messageDepthLimit != rhs.messageDepthLimit {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndian: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".littleEndian" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "littleEndian"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageEncoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".messageEncoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}messageEncoding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27338,31 +31381,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndian: // 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.littleEndian) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.messageEncoding) }() default: break } } } func traverse(visitor: inout V) throws { - if self.littleEndian != 0 { - try visitor.visitSingularInt32Field(value: self.littleEndian, fieldNumber: 1) + if self.messageEncoding != 0 { + try visitor.visitSingularInt32Field(value: self.messageEncoding, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndian, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndian) -> Bool { - if lhs.littleEndian != rhs.littleEndian {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageEncoding) -> Bool { + if lhs.messageEncoding != rhs.messageEncoding {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndianBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".littleEndianBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "littleEndianBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".MessageExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}MessageExtension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27370,31 +31411,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndianB // 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.littleEndianBytes) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.messageExtension) }() default: break } } } func traverse(visitor: inout V) throws { - if self.littleEndianBytes != 0 { - try visitor.visitSingularInt32Field(value: self.littleEndianBytes, fieldNumber: 1) + if self.messageExtension != 0 { + try visitor.visitSingularInt32Field(value: self.messageExtension, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndianBytes, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndianBytes) -> Bool { - if lhs.littleEndianBytes != rhs.littleEndianBytes {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageExtension) -> Bool { + if lhs.messageExtension != rhs.messageExtension {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.load: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".load" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "load"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageImplementationBase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".MessageImplementationBase" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}MessageImplementationBase\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27402,31 +31441,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.load: SwiftPr // 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.load) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.messageImplementationBase) }() default: break } } } func traverse(visitor: inout V) throws { - if self.load != 0 { - try visitor.visitSingularInt32Field(value: self.load, fieldNumber: 1) + if self.messageImplementationBase != 0 { + try visitor.visitSingularInt32Field(value: self.messageImplementationBase, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.load, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.load) -> Bool { - if lhs.load != rhs.load {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageImplementationBase, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageImplementationBase) -> Bool { + if lhs.messageImplementationBase != rhs.messageImplementationBase {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.localHasher: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".localHasher" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "localHasher"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".MessageSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}MessageSet\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27434,31 +31471,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.localHasher: // 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.localHasher) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.messageSet) }() default: break } } } func traverse(visitor: inout V) throws { - if self.localHasher != 0 { - try visitor.visitSingularInt32Field(value: self.localHasher, fieldNumber: 1) + if self.messageSet != 0 { + try visitor.visitSingularInt32Field(value: self.messageSet, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.localHasher, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.localHasher) -> Bool { - if lhs.localHasher != rhs.localHasher {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageSet) -> Bool { + if lhs.messageSet != rhs.messageSet {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.location: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".location" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "location"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageSetWireFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".messageSetWireFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}messageSetWireFormat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27466,31 +31501,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.location: Swi // 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.location) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.messageSetWireFormat) }() default: break } } } func traverse(visitor: inout V) throws { - if self.location != 0 { - try visitor.visitSingularInt32Field(value: self.location, fieldNumber: 1) + if self.messageSetWireFormat != 0 { + try visitor.visitSingularInt32Field(value: self.messageSetWireFormat, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.location, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.location) -> Bool { - if lhs.location != rhs.location {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageSetWireFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageSetWireFormat) -> Bool { + if lhs.messageSetWireFormat != rhs.messageSetWireFormat {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.M: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".M" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "M"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".messageSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}messageSize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27498,31 +31531,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.M: SwiftProto // 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.m) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.messageSize) }() default: break } } } func traverse(visitor: inout V) throws { - if self.m != 0 { - try visitor.visitSingularInt32Field(value: self.m, fieldNumber: 1) + if self.messageSize != 0 { + try visitor.visitSingularInt32Field(value: self.messageSize, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.M, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.M) -> Bool { - if lhs.m != rhs.m {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageSize) -> Bool { + if lhs.messageSize != rhs.messageSize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.major: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".major" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "major"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".messageType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}messageType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27530,31 +31561,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.major: SwiftP // 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.major) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.messageType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.major != 0 { - try visitor.visitSingularInt32Field(value: self.major, fieldNumber: 1) + if self.messageType != 0 { + try visitor.visitSingularInt32Field(value: self.messageType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.major, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.major) -> Bool { - if lhs.major != rhs.major {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageType) -> Bool { + if lhs.messageType != rhs.messageType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.makeIterator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".makeIterator" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "makeIterator"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.method: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".method" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}method\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27562,31 +31591,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.makeIterator: // 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.makeIterator) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.method) }() default: break } } } func traverse(visitor: inout V) throws { - if self.makeIterator != 0 { - try visitor.visitSingularInt32Field(value: self.makeIterator, fieldNumber: 1) + if self.method != 0 { + try visitor.visitSingularInt32Field(value: self.method, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.makeIterator, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.makeIterator) -> Bool { - if lhs.makeIterator != rhs.makeIterator {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.method, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.method) -> Bool { + if lhs.method != rhs.method {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".mapEntry" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mapEntry"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.methods: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".methods" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}methods\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27594,31 +31621,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapEntry: Swi // 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.mapEntry) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.methods) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mapEntry != 0 { - try visitor.visitSingularInt32Field(value: self.mapEntry, fieldNumber: 1) + if self.methods != 0 { + try visitor.visitSingularInt32Field(value: self.methods, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapEntry, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapEntry) -> Bool { - if lhs.mapEntry != rhs.mapEntry {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.methods, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.methods) -> Bool { + if lhs.methods != rhs.methods {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapHash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".mapHash" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mapHash"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.min: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".min" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}min\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27626,31 +31651,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapHash: Swif // 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.mapHash) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.min) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mapHash != 0 { - try visitor.visitSingularInt32Field(value: self.mapHash, fieldNumber: 1) + if self.min != 0 { + try visitor.visitSingularInt32Field(value: self.min, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapHash, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapHash) -> Bool { - if lhs.mapHash != rhs.mapHash {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.min, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.min) -> Bool { + if lhs.min != rhs.min {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapKeyType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".MapKeyType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "MapKeyType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.minimumEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".minimumEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}minimumEdition\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27658,31 +31681,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapKeyType: S // 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.mapKeyType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.minimumEdition) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mapKeyType != 0 { - try visitor.visitSingularInt32Field(value: self.mapKeyType, fieldNumber: 1) + if self.minimumEdition != 0 { + try visitor.visitSingularInt32Field(value: self.minimumEdition, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapKeyType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapKeyType) -> Bool { - if lhs.mapKeyType != rhs.mapKeyType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.minimumEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.minimumEdition) -> Bool { + if lhs.minimumEdition != rhs.minimumEdition {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapNameResolver: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".mapNameResolver" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mapNameResolver"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.minor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".minor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}minor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27690,31 +31711,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapNameResolv // 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.mapNameResolver) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.minor) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mapNameResolver != 0 { - try visitor.visitSingularInt32Field(value: self.mapNameResolver, fieldNumber: 1) + if self.minor != 0 { + try visitor.visitSingularInt32Field(value: self.minor, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapNameResolver, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapNameResolver) -> Bool { - if lhs.mapNameResolver != rhs.mapNameResolver {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.minor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.minor) -> Bool { + if lhs.minor != rhs.minor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapToMessages: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".mapToMessages" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mapToMessages"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mixins: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".mixins" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mixins\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27722,31 +31741,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapToMessages // 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.mapToMessages) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mixins) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mapToMessages != 0 { - try visitor.visitSingularInt32Field(value: self.mapToMessages, fieldNumber: 1) + if self.mixins != 0 { + try visitor.visitSingularInt32Field(value: self.mixins, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapToMessages, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapToMessages) -> Bool { - if lhs.mapToMessages != rhs.mapToMessages {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mixins, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mixins) -> Bool { + if lhs.mixins != rhs.mixins {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapValueType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".MapValueType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "MapValueType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.modify: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".modify" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}modify\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27754,31 +31771,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapValueType: // 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.mapValueType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.modify) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mapValueType != 0 { - try visitor.visitSingularInt32Field(value: self.mapValueType, fieldNumber: 1) + if self.modify != 0 { + try visitor.visitSingularInt32Field(value: self.modify, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapValueType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapValueType) -> Bool { - if lhs.mapValueType != rhs.mapValueType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.modify, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.modify) -> Bool { + if lhs.modify != rhs.modify {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".mapVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mapVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.month: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".month" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}month\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27786,31 +31801,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapVisitor: S // 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.mapVisitor) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.month) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mapVisitor != 0 { - try visitor.visitSingularInt32Field(value: self.mapVisitor, fieldNumber: 1) + if self.month != 0 { + try visitor.visitSingularInt32Field(value: self.month, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapVisitor) -> Bool { - if lhs.mapVisitor != rhs.mapVisitor {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.month, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.month) -> Bool { + if lhs.month != rhs.month {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mdayStart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".mdayStart" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mdayStart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.msgExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".msgExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}msgExtension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27818,31 +31831,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mdayStart: Sw // 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.mdayStart) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.msgExtension) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mdayStart != 0 { - try visitor.visitSingularInt32Field(value: self.mdayStart, fieldNumber: 1) + if self.msgExtension != 0 { + try visitor.visitSingularInt32Field(value: self.msgExtension, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mdayStart, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mdayStart) -> Bool { - if lhs.mdayStart != rhs.mdayStart {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.msgExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.msgExtension) -> Bool { + if lhs.msgExtension != rhs.msgExtension {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.merge: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".merge" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "merge"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mutating: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".mutating" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mutating\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27850,31 +31861,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.merge: SwiftP // 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.merge) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mutating) }() default: break } } } func traverse(visitor: inout V) throws { - if self.merge != 0 { - try visitor.visitSingularInt32Field(value: self.merge, fieldNumber: 1) + if self.mutating != 0 { + try visitor.visitSingularInt32Field(value: self.mutating, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.merge, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.merge) -> Bool { - if lhs.merge != rhs.merge {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mutating, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mutating) -> Bool { + if lhs.mutating != rhs.mutating {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".message" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "message"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.n: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".n" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}n\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27882,31 +31891,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.message: Swif // 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.message) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.n) }() default: break } } } func traverse(visitor: inout V) throws { - if self.message != 0 { - try visitor.visitSingularInt32Field(value: self.message, fieldNumber: 1) + if self.n != 0 { + try visitor.visitSingularInt32Field(value: self.n, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.message, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.message) -> Bool { - if lhs.message != rhs.message {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.n, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.n) -> Bool { + if lhs.n != rhs.n {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageDepthLimit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".messageDepthLimit" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "messageDepthLimit"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.name: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".name" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}name\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27914,31 +31921,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageDepthL // 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.messageDepthLimit) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.name) }() default: break } } } func traverse(visitor: inout V) throws { - if self.messageDepthLimit != 0 { - try visitor.visitSingularInt32Field(value: self.messageDepthLimit, fieldNumber: 1) + if self.name != 0 { + try visitor.visitSingularInt32Field(value: self.name, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageDepthLimit, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageDepthLimit) -> Bool { - if lhs.messageDepthLimit != rhs.messageDepthLimit {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.name, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.name) -> Bool { + if lhs.name != rhs.name {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".MessageExtension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "MessageExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NameDescription: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".NameDescription" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}NameDescription\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27946,31 +31951,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageExtens // 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.messageExtension) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nameDescription) }() default: break } } } func traverse(visitor: inout V) throws { - if self.messageExtension != 0 { - try visitor.visitSingularInt32Field(value: self.messageExtension, fieldNumber: 1) + if self.nameDescription != 0 { + try visitor.visitSingularInt32Field(value: self.nameDescription, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageExtension, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageExtension) -> Bool { - if lhs.messageExtension != rhs.messageExtension {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NameDescription, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NameDescription) -> Bool { + if lhs.nameDescription != rhs.nameDescription {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageImplementationBase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".MessageImplementationBase" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "MessageImplementationBase"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NameMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".NameMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}NameMap\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27978,31 +31981,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageImplem // 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.messageImplementationBase) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nameMap) }() default: break } } } func traverse(visitor: inout V) throws { - if self.messageImplementationBase != 0 { - try visitor.visitSingularInt32Field(value: self.messageImplementationBase, fieldNumber: 1) + if self.nameMap != 0 { + try visitor.visitSingularInt32Field(value: self.nameMap, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageImplementationBase, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageImplementationBase) -> Bool { - if lhs.messageImplementationBase != rhs.messageImplementationBase {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NameMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NameMap) -> Bool { + if lhs.nameMap != rhs.nameMap {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".MessageOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "MessageOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NamePart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".NamePart" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}NamePart\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28010,31 +32011,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageOption // 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.messageOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.namePart) }() default: break } } } func traverse(visitor: inout V) throws { - if self.messageOptions != 0 { - try visitor.visitSingularInt32Field(value: self.messageOptions, fieldNumber: 1) + if self.namePart != 0 { + try visitor.visitSingularInt32Field(value: self.namePart, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageOptions) -> Bool { - if lhs.messageOptions != rhs.messageOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NamePart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NamePart) -> Bool { + if lhs.namePart != rhs.namePart {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".MessageSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "MessageSet"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.names: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".names" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}names\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28042,31 +32041,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageSet: S // 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.messageSet) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.names) }() default: break } } } func traverse(visitor: inout V) throws { - if self.messageSet != 0 { - try visitor.visitSingularInt32Field(value: self.messageSet, fieldNumber: 1) + if self.names != 0 { + try visitor.visitSingularInt32Field(value: self.names, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageSet, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageSet) -> Bool { - if lhs.messageSet != rhs.messageSet {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.names, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.names) -> Bool { + if lhs.names != rhs.names {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageSetWireFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".messageSetWireFormat" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "messageSetWireFormat"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nanos: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nanos" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nanos\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28074,31 +32071,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageSetWir // 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.messageSetWireFormat) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nanos) }() default: break } } } func traverse(visitor: inout V) throws { - if self.messageSetWireFormat != 0 { - try visitor.visitSingularInt32Field(value: self.messageSetWireFormat, fieldNumber: 1) + if self.nanos != 0 { + try visitor.visitSingularInt32Field(value: self.nanos, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageSetWireFormat, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageSetWireFormat) -> Bool { - if lhs.messageSetWireFormat != rhs.messageSetWireFormat {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nanos, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nanos) -> Bool { + if lhs.nanos != rhs.nanos {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".messageType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "messageType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.negativeIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".negativeIntValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}negativeIntValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28106,31 +32101,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageType: // 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.messageType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.negativeIntValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.messageType != 0 { - try visitor.visitSingularInt32Field(value: self.messageType, fieldNumber: 1) + if self.negativeIntValue != 0 { + try visitor.visitSingularInt32Field(value: self.negativeIntValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageType) -> Bool { - if lhs.messageType != rhs.messageType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.negativeIntValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.negativeIntValue) -> Bool { + if lhs.negativeIntValue != rhs.negativeIntValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Method: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Method" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Method"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nestedType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nestedType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nestedType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28138,31 +32131,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Method: Swift // 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.method) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nestedType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.method != 0 { - try visitor.visitSingularInt32Field(value: self.method, fieldNumber: 1) + if self.nestedType != 0 { + try visitor.visitSingularInt32Field(value: self.nestedType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Method, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Method) -> Bool { - if lhs.method != rhs.method {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nestedType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nestedType) -> Bool { + if lhs.nestedType != rhs.nestedType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".MethodDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "MethodDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newExtensible: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".newExtensible" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}newExtensible\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28170,31 +32161,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodDescrip // 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.methodDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.newExtensible) }() default: break } } } func traverse(visitor: inout V) throws { - if self.methodDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.methodDescriptorProto, fieldNumber: 1) + if self.newExtensible != 0 { + try visitor.visitSingularInt32Field(value: self.newExtensible, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodDescriptorProto) -> Bool { - if lhs.methodDescriptorProto != rhs.methodDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newExtensible, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newExtensible) -> Bool { + if lhs.newExtensible != rhs.newExtensible {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".MethodOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "MethodOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".newL" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}newL\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28202,31 +32191,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodOptions // 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.methodOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.newL) }() default: break } } } func traverse(visitor: inout V) throws { - if self.methodOptions != 0 { - try visitor.visitSingularInt32Field(value: self.methodOptions, fieldNumber: 1) + if self.newL != 0 { + try visitor.visitSingularInt32Field(value: self.newL, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodOptions) -> Bool { - if lhs.methodOptions != rhs.methodOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newL) -> Bool { + if lhs.newL != rhs.newL {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.methods: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".methods" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "methods"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newList: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".newList" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}newList\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28234,31 +32221,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.methods: Swif // 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.methods) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.newList) }() default: break } } } func traverse(visitor: inout V) throws { - if self.methods != 0 { - try visitor.visitSingularInt32Field(value: self.methods, fieldNumber: 1) + if self.newList != 0 { + try visitor.visitSingularInt32Field(value: self.newList, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.methods, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.methods) -> Bool { - if lhs.methods != rhs.methods {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newList, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newList) -> Bool { + if lhs.newList != rhs.newList {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.minor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".minor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "minor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".newMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}newMessage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28266,31 +32251,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.minor: SwiftP // 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.minor) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.newMessage) }() default: break } } } func traverse(visitor: inout V) throws { - if self.minor != 0 { - try visitor.visitSingularInt32Field(value: self.minor, fieldNumber: 1) + if self.newMessage != 0 { + try visitor.visitSingularInt32Field(value: self.newMessage, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.minor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.minor) -> Bool { - if lhs.minor != rhs.minor {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newMessage) -> Bool { + if lhs.newMessage != rhs.newMessage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Mixin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Mixin" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Mixin"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".newValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}newValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28298,31 +32281,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Mixin: SwiftP // 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.mixin) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.newValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mixin != 0 { - try visitor.visitSingularInt32Field(value: self.mixin, fieldNumber: 1) + if self.newValue != 0 { + try visitor.visitSingularInt32Field(value: self.newValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Mixin, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Mixin) -> Bool { - if lhs.mixin != rhs.mixin {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newValue) -> Bool { + if lhs.newValue != rhs.newValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mixins: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".mixins" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mixins"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.next: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".next" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}next\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28330,31 +32311,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mixins: Swift // 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.mixins) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.next) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mixins != 0 { - try visitor.visitSingularInt32Field(value: self.mixins, fieldNumber: 1) + if self.next != 0 { + try visitor.visitSingularInt32Field(value: self.next, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mixins, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mixins) -> Bool { - if lhs.mixins != rhs.mixins {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.next, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.next) -> Bool { + if lhs.next != rhs.next {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modifier: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".modifier" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "modifier"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextByte: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nextByte" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nextByte\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28362,31 +32341,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modifier: Swi // 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.modifier) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nextByte) }() default: break } } } func traverse(visitor: inout V) throws { - if self.modifier != 0 { - try visitor.visitSingularInt32Field(value: self.modifier, fieldNumber: 1) + if self.nextByte != 0 { + try visitor.visitSingularInt32Field(value: self.nextByte, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modifier, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modifier) -> Bool { - if lhs.modifier != rhs.modifier {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextByte, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextByte) -> Bool { + if lhs.nextByte != rhs.nextByte {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modify: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".modify" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "modify"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nextFieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nextFieldNumber\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28394,31 +32371,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modify: Swift // 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.modify) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nextFieldNumber) }() default: break } } } func traverse(visitor: inout V) throws { - if self.modify != 0 { - try visitor.visitSingularInt32Field(value: self.modify, fieldNumber: 1) + if self.nextFieldNumber != 0 { + try visitor.visitSingularInt32Field(value: self.nextFieldNumber, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modify, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modify) -> Bool { - if lhs.modify != rhs.modify {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextFieldNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextFieldNumber) -> Bool { + if lhs.nextFieldNumber != rhs.nextFieldNumber {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.month: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".month" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "month"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextInstruction: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nextInstruction" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nextInstruction\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28426,31 +32401,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.month: SwiftP // 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.month) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nextInstruction) }() default: break } } } func traverse(visitor: inout V) throws { - if self.month != 0 { - try visitor.visitSingularInt32Field(value: self.month, fieldNumber: 1) + if self.nextInstruction != 0 { + try visitor.visitSingularInt32Field(value: self.nextInstruction, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.month, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.month) -> Bool { - if lhs.month != rhs.month {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextInstruction, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextInstruction) -> Bool { + if lhs.nextInstruction != rhs.nextInstruction {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.msgExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".msgExtension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "msgExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nextInt32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nextInt32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28458,31 +32431,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.msgExtension: // 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.msgExtension) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nextInt32) }() default: break } } } func traverse(visitor: inout V) throws { - if self.msgExtension != 0 { - try visitor.visitSingularInt32Field(value: self.msgExtension, fieldNumber: 1) + if self.nextInt32 != 0 { + try visitor.visitSingularInt32Field(value: self.nextInt32, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.msgExtension, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.msgExtension) -> Bool { - if lhs.msgExtension != rhs.msgExtension {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextInt32) -> Bool { + if lhs.nextInt32 != rhs.nextInt32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mutating: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".mutating" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mutating"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextNullTerminatedString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nextNullTerminatedString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nextNullTerminatedString\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28490,31 +32461,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mutating: Swi // 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.mutating) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nextNullTerminatedString) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mutating != 0 { - try visitor.visitSingularInt32Field(value: self.mutating, fieldNumber: 1) + if self.nextNullTerminatedString != 0 { + try visitor.visitSingularInt32Field(value: self.nextNullTerminatedString, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mutating, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mutating) -> Bool { - if lhs.mutating != rhs.mutating {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextNullTerminatedString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextNullTerminatedString) -> Bool { + if lhs.nextNullTerminatedString != rhs.nextNullTerminatedString {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.n: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".n" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "n"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextNullTerminatedStringArray: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nextNullTerminatedStringArray" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nextNullTerminatedStringArray\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28522,31 +32491,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.n: SwiftProto // 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.n) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nextNullTerminatedStringArray) }() default: break } } } func traverse(visitor: inout V) throws { - if self.n != 0 { - try visitor.visitSingularInt32Field(value: self.n, fieldNumber: 1) + if self.nextNullTerminatedStringArray != 0 { + try visitor.visitSingularInt32Field(value: self.nextNullTerminatedStringArray, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.n, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.n) -> Bool { - if lhs.n != rhs.n {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextNullTerminatedStringArray, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextNullTerminatedStringArray) -> Bool { + if lhs.nextNullTerminatedStringArray != rhs.nextNullTerminatedStringArray {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.name: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".name" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nextNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nextNumber\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28554,31 +32521,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.name: SwiftPr // 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.name) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nextNumber) }() default: break } } } func traverse(visitor: inout V) throws { - if self.name != 0 { - try visitor.visitSingularInt32Field(value: self.name, fieldNumber: 1) + if self.nextNumber != 0 { + try visitor.visitSingularInt32Field(value: self.nextNumber, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.name, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.name) -> Bool { - if lhs.name != rhs.name {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextNumber) -> Bool { + if lhs.nextNumber != rhs.nextNumber {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameDescription: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".NameDescription" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "NameDescription"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextUInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nextUInt64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nextUInt64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28586,31 +32551,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameDescripti // 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.nameDescription) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nextUint64) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nameDescription != 0 { - try visitor.visitSingularInt32Field(value: self.nameDescription, fieldNumber: 1) + if self.nextUint64 != 0 { + try visitor.visitSingularInt32Field(value: self.nextUint64, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameDescription, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameDescription) -> Bool { - if lhs.nameDescription != rhs.nameDescription {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextUInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextUInt64) -> Bool { + if lhs.nextUint64 != rhs.nextUint64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".NameMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "NameMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextVarInt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nextVarInt" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nextVarInt\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28618,31 +32581,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameMap: Swif // 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.nameMap) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nextVarInt) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nameMap != 0 { - try visitor.visitSingularInt32Field(value: self.nameMap, fieldNumber: 1) + if self.nextVarInt != 0 { + try visitor.visitSingularInt32Field(value: self.nextVarInt, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameMap, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameMap) -> Bool { - if lhs.nameMap != rhs.nameMap {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextVarInt, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextVarInt) -> Bool { + if lhs.nextVarInt != rhs.nextVarInt {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NamePart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".NamePart" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "NamePart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nilMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nil" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nil\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28650,31 +32611,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NamePart: Swi // 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.namePart) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`nil`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.namePart != 0 { - try visitor.visitSingularInt32Field(value: self.namePart, fieldNumber: 1) + if self.`nil` != 0 { + try visitor.visitSingularInt32Field(value: self.`nil`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NamePart, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NamePart) -> Bool { - if lhs.namePart != rhs.namePart {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nilMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nilMessage) -> Bool { + if lhs.`nil` != rhs.`nil` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nameResolver: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nameResolver" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nameResolver"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nilLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nilLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nilLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28682,31 +32641,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nameResolver: // 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.nameResolver) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nilLiteral) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nameResolver != 0 { - try visitor.visitSingularInt32Field(value: self.nameResolver, fieldNumber: 1) + if self.nilLiteral != 0 { + try visitor.visitSingularInt32Field(value: self.nilLiteral, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nameResolver, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nameResolver) -> Bool { - if lhs.nameResolver != rhs.nameResolver {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nilLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nilLiteral) -> Bool { + if lhs.nilLiteral != rhs.nilLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.names: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".names" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "names"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.noBytesAvailable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".noBytesAvailable" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}noBytesAvailable\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28714,31 +32671,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.names: SwiftP // 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.names) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.noBytesAvailable) }() default: break } } } func traverse(visitor: inout V) throws { - if self.names != 0 { - try visitor.visitSingularInt32Field(value: self.names, fieldNumber: 1) + if self.noBytesAvailable != 0 { + try visitor.visitSingularInt32Field(value: self.noBytesAvailable, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.names, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.names) -> Bool { - if lhs.names != rhs.names {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.noBytesAvailable, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.noBytesAvailable) -> Bool { + if lhs.noBytesAvailable != rhs.noBytesAvailable {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nanos: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nanos" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nanos"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.noStandardDescriptorAccessor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".noStandardDescriptorAccessor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}noStandardDescriptorAccessor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28746,31 +32701,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nanos: SwiftP // 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.nanos) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.noStandardDescriptorAccessor) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nanos != 0 { - try visitor.visitSingularInt32Field(value: self.nanos, fieldNumber: 1) + if self.noStandardDescriptorAccessor != 0 { + try visitor.visitSingularInt32Field(value: self.noStandardDescriptorAccessor, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nanos, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nanos) -> Bool { - if lhs.nanos != rhs.nanos {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.noStandardDescriptorAccessor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.noStandardDescriptorAccessor) -> Bool { + if lhs.noStandardDescriptorAccessor != rhs.noStandardDescriptorAccessor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nativeBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nativeBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nullValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nullValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nullValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28778,31 +32731,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeBytes: // 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.nativeBytes) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nullValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nativeBytes != 0 { - try visitor.visitSingularInt32Field(value: self.nativeBytes, fieldNumber: 1) + if self.nullValue != 0 { + try visitor.visitSingularInt32Field(value: self.nullValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeBytes, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeBytes) -> Bool { - if lhs.nativeBytes != rhs.nativeBytes {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nullValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nullValue) -> Bool { + if lhs.nullValue != rhs.nullValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeEndianBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nativeEndianBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nativeEndianBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.number: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".number" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}number\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28810,31 +32761,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeEndianB // 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.nativeEndianBytes) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.number) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nativeEndianBytes != 0 { - try visitor.visitSingularInt32Field(value: self.nativeEndianBytes, fieldNumber: 1) + if self.number != 0 { + try visitor.visitSingularInt32Field(value: self.number, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeEndianBytes, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeEndianBytes) -> Bool { - if lhs.nativeEndianBytes != rhs.nativeEndianBytes {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.number, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.number) -> Bool { + if lhs.number != rhs.number {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.negativeIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".negativeIntValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "negativeIntValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.numberValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".numberValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}numberValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28842,31 +32791,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.negativeIntVa // 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.negativeIntValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.numberValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.negativeIntValue != 0 { - try visitor.visitSingularInt32Field(value: self.negativeIntValue, fieldNumber: 1) + if self.numberValue != 0 { + try visitor.visitSingularInt32Field(value: self.numberValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.negativeIntValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.negativeIntValue) -> Bool { - if lhs.negativeIntValue != rhs.negativeIntValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.numberValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.numberValue) -> Bool { + if lhs.numberValue != rhs.numberValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nestedType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nestedType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nestedType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.objcClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".objcClassPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}objcClassPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28874,31 +32821,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nestedType: S // 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.nestedType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.objcClassPrefix) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nestedType != 0 { - try visitor.visitSingularInt32Field(value: self.nestedType, fieldNumber: 1) + if self.objcClassPrefix != 0 { + try visitor.visitSingularInt32Field(value: self.objcClassPrefix, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nestedType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nestedType) -> Bool { - if lhs.nestedType != rhs.nestedType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.objcClassPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.objcClassPrefix) -> Bool { + if lhs.objcClassPrefix != rhs.objcClassPrefix {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".newL" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "newL"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.of: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".of" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}of\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28906,31 +32851,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newL: SwiftPr // 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.newL) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.of) }() default: break } } } func traverse(visitor: inout V) throws { - if self.newL != 0 { - try visitor.visitSingularInt32Field(value: self.newL, fieldNumber: 1) + if self.of != 0 { + try visitor.visitSingularInt32Field(value: self.of, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newL, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newL) -> Bool { - if lhs.newL != rhs.newL {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.of, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.of) -> Bool { + if lhs.of != rhs.of {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newList: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".newList" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "newList"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OneOf_Kind: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".OneOf_Kind" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}OneOf_Kind\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28938,31 +32881,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newList: Swif // 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.newList) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.oneOfKind) }() default: break } } } func traverse(visitor: inout V) throws { - if self.newList != 0 { - try visitor.visitSingularInt32Field(value: self.newList, fieldNumber: 1) + if self.oneOfKind != 0 { + try visitor.visitSingularInt32Field(value: self.oneOfKind, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newList, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newList) -> Bool { - if lhs.newList != rhs.newList {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OneOf_Kind, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OneOf_Kind) -> Bool { + if lhs.oneOfKind != rhs.oneOfKind {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".newValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "newValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofDecl: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".oneofDecl" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}oneofDecl\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28970,31 +32911,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newValue: Swi // 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.newValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.oneofDecl) }() default: break } } } func traverse(visitor: inout V) throws { - if self.newValue != 0 { - try visitor.visitSingularInt32Field(value: self.newValue, fieldNumber: 1) + if self.oneofDecl != 0 { + try visitor.visitSingularInt32Field(value: self.oneofDecl, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newValue) -> Bool { - if lhs.newValue != rhs.newValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofDecl, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofDecl) -> Bool { + if lhs.oneofDecl != rhs.oneofDecl {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextByte: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nextByte" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nextByte"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofIndex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".oneofIndex" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}oneofIndex\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29002,31 +32941,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextByte: Swi // 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.nextByte) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.oneofIndex) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nextByte != 0 { - try visitor.visitSingularInt32Field(value: self.nextByte, fieldNumber: 1) + if self.oneofIndex != 0 { + try visitor.visitSingularInt32Field(value: self.oneofIndex, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextByte, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextByte) -> Bool { - if lhs.nextByte != rhs.nextByte {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofIndex, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofIndex) -> Bool { + if lhs.oneofIndex != rhs.oneofIndex {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nextFieldNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nextFieldNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofs: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".oneofs" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}oneofs\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29034,31 +32971,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextFieldNumb // 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.nextFieldNumber) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.oneofs) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nextFieldNumber != 0 { - try visitor.visitSingularInt32Field(value: self.nextFieldNumber, fieldNumber: 1) + if self.oneofs != 0 { + try visitor.visitSingularInt32Field(value: self.oneofs, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextFieldNumber, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextFieldNumber) -> Bool { - if lhs.nextFieldNumber != rhs.nextFieldNumber {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofs, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofs) -> Bool { + if lhs.oneofs != rhs.oneofs {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nil" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nil"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.optimizeFor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".optimizeFor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}optimizeFor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29066,31 +33001,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilMessage: S // 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.`nil`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.optimizeFor) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`nil` != 0 { - try visitor.visitSingularInt32Field(value: self.`nil`, fieldNumber: 1) + if self.optimizeFor != 0 { + try visitor.visitSingularInt32Field(value: self.optimizeFor, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilMessage) -> Bool { - if lhs.`nil` != rhs.`nil` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.optimizeFor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.optimizeFor) -> Bool { + if lhs.optimizeFor != rhs.optimizeFor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nilLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nilLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptimizeMode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".OptimizeMode" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OptimizeMode\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29098,31 +33031,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilLiteral: S // 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.nilLiteral) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.optimizeMode) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nilLiteral != 0 { - try visitor.visitSingularInt32Field(value: self.nilLiteral, fieldNumber: 1) + if self.optimizeMode != 0 { + try visitor.visitSingularInt32Field(value: self.optimizeMode, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilLiteral) -> Bool { - if lhs.nilLiteral != rhs.nilLiteral {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptimizeMode, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptimizeMode) -> Bool { + if lhs.optimizeMode != rhs.optimizeMode {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.noStandardDescriptorAccessor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".noStandardDescriptorAccessor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "noStandardDescriptorAccessor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalEnumExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionalEnumExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OptionalEnumExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29130,31 +33061,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.noStandardDes // 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.noStandardDescriptorAccessor) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.optionalEnumExtensionField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.noStandardDescriptorAccessor != 0 { - try visitor.visitSingularInt32Field(value: self.noStandardDescriptorAccessor, fieldNumber: 1) + if self.optionalEnumExtensionField != 0 { + try visitor.visitSingularInt32Field(value: self.optionalEnumExtensionField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.noStandardDescriptorAccessor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.noStandardDescriptorAccessor) -> Bool { - if lhs.noStandardDescriptorAccessor != rhs.noStandardDescriptorAccessor {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalEnumExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalEnumExtensionField) -> Bool { + if lhs.optionalEnumExtensionField != rhs.optionalEnumExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nullValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nullValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nullValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionalExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OptionalExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29162,31 +33091,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nullValue: Sw // 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.nullValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.optionalExtensionField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nullValue != 0 { - try visitor.visitSingularInt32Field(value: self.nullValue, fieldNumber: 1) + if self.optionalExtensionField != 0 { + try visitor.visitSingularInt32Field(value: self.optionalExtensionField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nullValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nullValue) -> Bool { - if lhs.nullValue != rhs.nullValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalExtensionField) -> Bool { + if lhs.optionalExtensionField != rhs.optionalExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.number: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".number" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "number"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalGroupExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionalGroupExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OptionalGroupExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29194,31 +33121,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.number: Swift // 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.number) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.optionalGroupExtensionField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.number != 0 { - try visitor.visitSingularInt32Field(value: self.number, fieldNumber: 1) + if self.optionalGroupExtensionField != 0 { + try visitor.visitSingularInt32Field(value: self.optionalGroupExtensionField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.number, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.number) -> Bool { - if lhs.number != rhs.number {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalGroupExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalGroupExtensionField) -> Bool { + if lhs.optionalGroupExtensionField != rhs.optionalGroupExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.numberValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".numberValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "numberValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalMessageExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionalMessageExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OptionalMessageExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29226,31 +33151,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.numberValue: // 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.numberValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.optionalMessageExtensionField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.numberValue != 0 { - try visitor.visitSingularInt32Field(value: self.numberValue, fieldNumber: 1) + if self.optionalMessageExtensionField != 0 { + try visitor.visitSingularInt32Field(value: self.optionalMessageExtensionField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.numberValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.numberValue) -> Bool { - if lhs.numberValue != rhs.numberValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalMessageExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalMessageExtensionField) -> Bool { + if lhs.optionalMessageExtensionField != rhs.optionalMessageExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.objcClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".objcClassPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "objcClassPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.optionDependency: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".optionDependency" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}optionDependency\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29258,31 +33181,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.objcClassPref // 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.objcClassPrefix) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.optionDependency) }() default: break } } } func traverse(visitor: inout V) throws { - if self.objcClassPrefix != 0 { - try visitor.visitSingularInt32Field(value: self.objcClassPrefix, fieldNumber: 1) + if self.optionDependency != 0 { + try visitor.visitSingularInt32Field(value: self.optionDependency, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.objcClassPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.objcClassPrefix) -> Bool { - if lhs.objcClassPrefix != rhs.objcClassPrefix {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.optionDependency, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.optionDependency) -> Bool { + if lhs.optionDependency != rhs.optionDependency {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.of: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".of" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "of"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionRetention: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionRetention" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OptionRetention\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29290,31 +33211,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.of: SwiftProt // 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.of) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.optionRetention) }() default: break } } } func traverse(visitor: inout V) throws { - if self.of != 0 { - try visitor.visitSingularInt32Field(value: self.of, fieldNumber: 1) + if self.optionRetention != 0 { + try visitor.visitSingularInt32Field(value: self.optionRetention, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.of, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.of) -> Bool { - if lhs.of != rhs.of {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionRetention, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionRetention) -> Bool { + if lhs.optionRetention != rhs.optionRetention {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofDecl: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".oneofDecl" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "oneofDecl"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.options: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".options" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}options\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29322,31 +33241,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofDecl: Sw // 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.oneofDecl) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.options) }() default: break } } } func traverse(visitor: inout V) throws { - if self.oneofDecl != 0 { - try visitor.visitSingularInt32Field(value: self.oneofDecl, fieldNumber: 1) + if self.options != 0 { + try visitor.visitSingularInt32Field(value: self.options, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofDecl, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofDecl) -> Bool { - if lhs.oneofDecl != rhs.oneofDecl {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.options, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.options) -> Bool { + if lhs.options != rhs.options {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".OneofDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "OneofDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionTargetType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionTargetType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OptionTargetType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29354,31 +33271,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofDescript // 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.oneofDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.optionTargetType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.oneofDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.oneofDescriptorProto, fieldNumber: 1) + if self.optionTargetType != 0 { + try visitor.visitSingularInt32Field(value: self.optionTargetType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofDescriptorProto) -> Bool { - if lhs.oneofDescriptorProto != rhs.oneofDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionTargetType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionTargetType) -> Bool { + if lhs.optionTargetType != rhs.optionTargetType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofIndex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".oneofIndex" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "oneofIndex"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.other: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".other" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}other\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29386,31 +33301,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofIndex: S // 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.oneofIndex) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.other) }() default: break } } } func traverse(visitor: inout V) throws { - if self.oneofIndex != 0 { - try visitor.visitSingularInt32Field(value: self.oneofIndex, fieldNumber: 1) + if self.other != 0 { + try visitor.visitSingularInt32Field(value: self.other, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofIndex, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofIndex) -> Bool { - if lhs.oneofIndex != rhs.oneofIndex {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.other, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.other) -> Bool { + if lhs.other != rhs.other {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".OneofOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "OneofOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.others: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".others" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}others\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29418,31 +33331,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofOptions: // 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.oneofOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.others) }() default: break } } } func traverse(visitor: inout V) throws { - if self.oneofOptions != 0 { - try visitor.visitSingularInt32Field(value: self.oneofOptions, fieldNumber: 1) + if self.others != 0 { + try visitor.visitSingularInt32Field(value: self.others, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofOptions) -> Bool { - if lhs.oneofOptions != rhs.oneofOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.others, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.others) -> Bool { + if lhs.others != rhs.others {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofs: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".oneofs" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "oneofs"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.out: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".out" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}out\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29450,31 +33361,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofs: Swift // 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.oneofs) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.out) }() default: break } } } func traverse(visitor: inout V) throws { - if self.oneofs != 0 { - try visitor.visitSingularInt32Field(value: self.oneofs, fieldNumber: 1) + if self.out != 0 { + try visitor.visitSingularInt32Field(value: self.out, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofs, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofs) -> Bool { - if lhs.oneofs != rhs.oneofs {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.out, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.out) -> Bool { + if lhs.out != rhs.out {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneOf_Kind: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".OneOf_Kind" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "OneOf_Kind"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.outputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".outputType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}outputType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29482,31 +33391,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneOf_Kind: S // 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.oneOfKind) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.outputType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.oneOfKind != 0 { - try visitor.visitSingularInt32Field(value: self.oneOfKind, fieldNumber: 1) + if self.outputType != 0 { + try visitor.visitSingularInt32Field(value: self.outputType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneOf_Kind, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneOf_Kind) -> Bool { - if lhs.oneOfKind != rhs.oneOfKind {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.outputType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.outputType) -> Bool { + if lhs.outputType != rhs.outputType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.optimizeFor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".optimizeFor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "optimizeFor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.overridableFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".overridableFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}overridableFeatures\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29514,31 +33421,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.optimizeFor: // 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.optimizeFor) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.overridableFeatures) }() default: break } } } func traverse(visitor: inout V) throws { - if self.optimizeFor != 0 { - try visitor.visitSingularInt32Field(value: self.optimizeFor, fieldNumber: 1) + if self.overridableFeatures != 0 { + try visitor.visitSingularInt32Field(value: self.overridableFeatures, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.optimizeFor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.optimizeFor) -> Bool { - if lhs.optimizeFor != rhs.optimizeFor {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.overridableFeatures, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.overridableFeatures) -> Bool { + if lhs.overridableFeatures != rhs.overridableFeatures {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptimizeMode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".OptimizeMode" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "OptimizeMode"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.p: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".p" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}p\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29546,31 +33451,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptimizeMode: // 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.optimizeMode) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.optimizeMode != 0 { - try visitor.visitSingularInt32Field(value: self.optimizeMode, fieldNumber: 1) + if self.p != 0 { + try visitor.visitSingularInt32Field(value: self.p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptimizeMode, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptimizeMode) -> Bool { - if lhs.optimizeMode != rhs.optimizeMode {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.p, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.p) -> Bool { + if lhs.p != rhs.p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Option: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Option" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Option"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.package: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".package" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}package\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29578,31 +33481,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Option: Swift // 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.option) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.package) }() default: break } } } func traverse(visitor: inout V) throws { - if self.option != 0 { - try visitor.visitSingularInt32Field(value: self.option, fieldNumber: 1) + if self.package != 0 { + try visitor.visitSingularInt32Field(value: self.package, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Option, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Option) -> Bool { - if lhs.option != rhs.option {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.package, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.package) -> Bool { + if lhs.package != rhs.package {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalEnumExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionalEnumExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "OptionalEnumExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packed: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".packed" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}packed\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29610,31 +33511,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalEnumE // 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.optionalEnumExtensionField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.packed) }() default: break } } } func traverse(visitor: inout V) throws { - if self.optionalEnumExtensionField != 0 { - try visitor.visitSingularInt32Field(value: self.optionalEnumExtensionField, fieldNumber: 1) + if self.packed != 0 { + try visitor.visitSingularInt32Field(value: self.packed, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalEnumExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalEnumExtensionField) -> Bool { - if lhs.optionalEnumExtensionField != rhs.optionalEnumExtensionField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packed, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packed) -> Bool { + if lhs.packed != rhs.packed {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionalExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "OptionalExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedEnumExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".PackedEnumExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}PackedEnumExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29642,31 +33541,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalExten // 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.optionalExtensionField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.packedEnumExtensionField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.optionalExtensionField != 0 { - try visitor.visitSingularInt32Field(value: self.optionalExtensionField, fieldNumber: 1) + if self.packedEnumExtensionField != 0 { + try visitor.visitSingularInt32Field(value: self.packedEnumExtensionField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalExtensionField) -> Bool { - if lhs.optionalExtensionField != rhs.optionalExtensionField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedEnumExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedEnumExtensionField) -> Bool { + if lhs.packedEnumExtensionField != rhs.packedEnumExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalGroupExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionalGroupExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "OptionalGroupExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".PackedExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}PackedExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29674,31 +33571,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalGroup // 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.optionalGroupExtensionField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.packedExtensionField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.optionalGroupExtensionField != 0 { - try visitor.visitSingularInt32Field(value: self.optionalGroupExtensionField, fieldNumber: 1) + if self.packedExtensionField != 0 { + try visitor.visitSingularInt32Field(value: self.packedExtensionField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalGroupExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalGroupExtensionField) -> Bool { - if lhs.optionalGroupExtensionField != rhs.optionalGroupExtensionField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedExtensionField) -> Bool { + if lhs.packedExtensionField != rhs.packedExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalMessageExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionalMessageExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "OptionalMessageExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.padding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".padding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}padding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29706,31 +33601,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalMessa // 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.optionalMessageExtensionField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.padding) }() default: break } } } func traverse(visitor: inout V) throws { - if self.optionalMessageExtensionField != 0 { - try visitor.visitSingularInt32Field(value: self.optionalMessageExtensionField, fieldNumber: 1) + if self.padding != 0 { + try visitor.visitSingularInt32Field(value: self.padding, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalMessageExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalMessageExtensionField) -> Bool { - if lhs.optionalMessageExtensionField != rhs.optionalMessageExtensionField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.padding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.padding) -> Bool { + if lhs.padding != rhs.padding {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.options: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".options" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "options"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.parent: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".parent" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}parent\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29738,31 +33631,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.options: Swif // 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.options) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.parent) }() default: break } } } func traverse(visitor: inout V) throws { - if self.options != 0 { - try visitor.visitSingularInt32Field(value: self.options, fieldNumber: 1) + if self.parent != 0 { + try visitor.visitSingularInt32Field(value: self.parent, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.options, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.options) -> Bool { - if lhs.options != rhs.options {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.parent, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.parent) -> Bool { + if lhs.parent != rhs.parent {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.other: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".other" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "other"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.parse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".parse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}parse\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29770,31 +33661,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.other: SwiftP // 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.other) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.parse) }() default: break } } } func traverse(visitor: inout V) throws { - if self.other != 0 { - try visitor.visitSingularInt32Field(value: self.other, fieldNumber: 1) + if self.parse != 0 { + try visitor.visitSingularInt32Field(value: self.parse, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.other, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.other) -> Bool { - if lhs.other != rhs.other {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.parse, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.parse) -> Bool { + if lhs.parse != rhs.parse {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.others: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".others" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "others"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.partial: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".partial" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}partial\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29802,31 +33691,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.others: Swift // 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.others) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.partial) }() default: break } } } func traverse(visitor: inout V) throws { - if self.others != 0 { - try visitor.visitSingularInt32Field(value: self.others, fieldNumber: 1) + if self.partial != 0 { + try visitor.visitSingularInt32Field(value: self.partial, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.others, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.others) -> Bool { - if lhs.others != rhs.others {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.partial, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.partial) -> Bool { + if lhs.partial != rhs.partial {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.out: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".out" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "out"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.path: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".path" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}path\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29834,31 +33721,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.out: SwiftPro // 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.out) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.path) }() default: break } } } func traverse(visitor: inout V) throws { - if self.out != 0 { - try visitor.visitSingularInt32Field(value: self.out, fieldNumber: 1) + if self.path != 0 { + try visitor.visitSingularInt32Field(value: self.path, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.out, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.out) -> Bool { - if lhs.out != rhs.out {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.path, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.path) -> Bool { + if lhs.path != rhs.path {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.outputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".outputType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "outputType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PathDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".PathDecoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}PathDecoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29866,31 +33751,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.outputType: S // 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.outputType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.pathDecoder) }() default: break } } } func traverse(visitor: inout V) throws { - if self.outputType != 0 { - try visitor.visitSingularInt32Field(value: self.outputType, fieldNumber: 1) + if self.pathDecoder != 0 { + try visitor.visitSingularInt32Field(value: self.pathDecoder, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.outputType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.outputType) -> Bool { - if lhs.outputType != rhs.outputType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PathDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PathDecoder) -> Bool { + if lhs.pathDecoder != rhs.pathDecoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.p: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".p" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "p"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PathDecodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".PathDecodingError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}PathDecodingError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29898,31 +33781,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.p: SwiftProto // 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.p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.pathDecodingError) }() default: break } } } func traverse(visitor: inout V) throws { - if self.p != 0 { - try visitor.visitSingularInt32Field(value: self.p, fieldNumber: 1) + if self.pathDecodingError != 0 { + try visitor.visitSingularInt32Field(value: self.pathDecodingError, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.p, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.p) -> Bool { - if lhs.p != rhs.p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PathDecodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PathDecodingError) -> Bool { + if lhs.pathDecodingError != rhs.pathDecodingError {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.package: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".package" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "package"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.paths: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".paths" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}paths\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29930,31 +33811,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.package: Swif // 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.package) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.paths) }() default: break } } } func traverse(visitor: inout V) throws { - if self.package != 0 { - try visitor.visitSingularInt32Field(value: self.package, fieldNumber: 1) + if self.paths != 0 { + try visitor.visitSingularInt32Field(value: self.paths, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.package, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.package) -> Bool { - if lhs.package != rhs.package {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.paths, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.paths) -> Bool { + if lhs.paths != rhs.paths {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.packed: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".packed" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "packed"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PathVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".PathVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}PathVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29962,31 +33841,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.packed: Swift // 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.packed) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.pathVisitor) }() default: break } } } func traverse(visitor: inout V) throws { - if self.packed != 0 { - try visitor.visitSingularInt32Field(value: self.packed, fieldNumber: 1) + if self.pathVisitor != 0 { + try visitor.visitSingularInt32Field(value: self.pathVisitor, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.packed, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.packed) -> Bool { - if lhs.packed != rhs.packed {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PathVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PathVisitor) -> Bool { + if lhs.pathVisitor != rhs.pathVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedEnumExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".PackedEnumExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "PackedEnumExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.payload: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".payload" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}payload\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29994,31 +33871,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedEnumExt // 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.packedEnumExtensionField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.payload) }() default: break } } } func traverse(visitor: inout V) throws { - if self.packedEnumExtensionField != 0 { - try visitor.visitSingularInt32Field(value: self.packedEnumExtensionField, fieldNumber: 1) + if self.payload != 0 { + try visitor.visitSingularInt32Field(value: self.payload, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedEnumExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedEnumExtensionField) -> Bool { - if lhs.packedEnumExtensionField != rhs.packedEnumExtensionField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.payload, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.payload) -> Bool { + if lhs.payload != rhs.payload {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".PackedExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "PackedExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.payloadSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".payloadSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}payloadSize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30026,31 +33901,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedExtensi // 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.packedExtensionField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.payloadSize) }() default: break } } } func traverse(visitor: inout V) throws { - if self.packedExtensionField != 0 { - try visitor.visitSingularInt32Field(value: self.packedExtensionField, fieldNumber: 1) + if self.payloadSize != 0 { + try visitor.visitSingularInt32Field(value: self.payloadSize, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedExtensionField) -> Bool { - if lhs.packedExtensionField != rhs.packedExtensionField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.payloadSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.payloadSize) -> Bool { + if lhs.payloadSize != rhs.payloadSize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.padding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".padding" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "padding"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".phpClassPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}phpClassPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30058,31 +33931,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.padding: Swif // 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.padding) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.phpClassPrefix) }() default: break } } } func traverse(visitor: inout V) throws { - if self.padding != 0 { - try visitor.visitSingularInt32Field(value: self.padding, fieldNumber: 1) + if self.phpClassPrefix != 0 { + try visitor.visitSingularInt32Field(value: self.phpClassPrefix, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.padding, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.padding) -> Bool { - if lhs.padding != rhs.padding {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpClassPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpClassPrefix) -> Bool { + if lhs.phpClassPrefix != rhs.phpClassPrefix {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parent: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".parent" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "parent"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpMetadataNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".phpMetadataNamespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}phpMetadataNamespace\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30090,31 +33961,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parent: Swift // 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.parent) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.phpMetadataNamespace) }() default: break } } } func traverse(visitor: inout V) throws { - if self.parent != 0 { - try visitor.visitSingularInt32Field(value: self.parent, fieldNumber: 1) + if self.phpMetadataNamespace != 0 { + try visitor.visitSingularInt32Field(value: self.phpMetadataNamespace, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parent, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parent) -> Bool { - if lhs.parent != rhs.parent {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpMetadataNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpMetadataNamespace) -> Bool { + if lhs.phpMetadataNamespace != rhs.phpMetadataNamespace {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".parse" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "parse"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".phpNamespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}phpNamespace\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30122,31 +33991,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parse: SwiftP // 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.parse) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.phpNamespace) }() default: break } } } func traverse(visitor: inout V) throws { - if self.parse != 0 { - try visitor.visitSingularInt32Field(value: self.parse, fieldNumber: 1) + if self.phpNamespace != 0 { + try visitor.visitSingularInt32Field(value: self.phpNamespace, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parse, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parse) -> Bool { - if lhs.parse != rhs.parse {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpNamespace) -> Bool { + if lhs.phpNamespace != rhs.phpNamespace {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.partial: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".partial" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "partial"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.pos: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".pos" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}pos\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30154,31 +34021,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.partial: Swif // 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.partial) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.pos) }() default: break } } } func traverse(visitor: inout V) throws { - if self.partial != 0 { - try visitor.visitSingularInt32Field(value: self.partial, fieldNumber: 1) + if self.pos != 0 { + try visitor.visitSingularInt32Field(value: self.pos, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.partial, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.partial) -> Bool { - if lhs.partial != rhs.partial {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.pos, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.pos) -> Bool { + if lhs.pos != rhs.pos {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.path: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".path" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "path"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.positiveIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".positiveIntValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}positiveIntValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30186,31 +34051,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.path: SwiftPr // 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.path) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.positiveIntValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.path != 0 { - try visitor.visitSingularInt32Field(value: self.path, fieldNumber: 1) + if self.positiveIntValue != 0 { + try visitor.visitSingularInt32Field(value: self.positiveIntValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.path, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.path) -> Bool { - if lhs.path != rhs.path {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.positiveIntValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.positiveIntValue) -> Bool { + if lhs.positiveIntValue != rhs.positiveIntValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.paths: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".paths" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "paths"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.prefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".prefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}prefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30218,31 +34081,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.paths: SwiftP // 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.paths) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.prefix) }() default: break } } } func traverse(visitor: inout V) throws { - if self.paths != 0 { - try visitor.visitSingularInt32Field(value: self.paths, fieldNumber: 1) + if self.prefix != 0 { + try visitor.visitSingularInt32Field(value: self.prefix, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.paths, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.paths) -> Bool { - if lhs.paths != rhs.paths {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.prefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.prefix) -> Bool { + if lhs.prefix != rhs.prefix {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payload: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".payload" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "payload"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.preserveProtoFieldNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".preserveProtoFieldNames" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}preserveProtoFieldNames\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30250,31 +34111,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payload: Swif // 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.payload) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.preserveProtoFieldNames) }() default: break } } } func traverse(visitor: inout V) throws { - if self.payload != 0 { - try visitor.visitSingularInt32Field(value: self.payload, fieldNumber: 1) + if self.preserveProtoFieldNames != 0 { + try visitor.visitSingularInt32Field(value: self.preserveProtoFieldNames, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payload, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payload) -> Bool { - if lhs.payload != rhs.payload {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.preserveProtoFieldNames, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.preserveProtoFieldNames) -> Bool { + if lhs.preserveProtoFieldNames != rhs.preserveProtoFieldNames {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payloadSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".payloadSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "payloadSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.preTraverse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".preTraverse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}preTraverse\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30282,31 +34141,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payloadSize: // 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.payloadSize) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.preTraverse) }() default: break } } } func traverse(visitor: inout V) throws { - if self.payloadSize != 0 { - try visitor.visitSingularInt32Field(value: self.payloadSize, fieldNumber: 1) + if self.preTraverse != 0 { + try visitor.visitSingularInt32Field(value: self.preTraverse, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payloadSize, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payloadSize) -> Bool { - if lhs.payloadSize != rhs.payloadSize {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.preTraverse, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.preTraverse) -> Bool { + if lhs.preTraverse != rhs.preTraverse {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".phpClassPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "phpClassPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.previousNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".previousNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}previousNumber\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30314,31 +34171,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpClassPrefi // 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.phpClassPrefix) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.previousNumber) }() default: break } } } func traverse(visitor: inout V) throws { - if self.phpClassPrefix != 0 { - try visitor.visitSingularInt32Field(value: self.phpClassPrefix, fieldNumber: 1) + if self.previousNumber != 0 { + try visitor.visitSingularInt32Field(value: self.previousNumber, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpClassPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpClassPrefix) -> Bool { - if lhs.phpClassPrefix != rhs.phpClassPrefix {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.previousNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.previousNumber) -> Bool { + if lhs.previousNumber != rhs.previousNumber {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".phpGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "phpGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.prevPath: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".prevPath" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}prevPath\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30346,31 +34201,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpGenericSer // 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.phpGenericServices) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.prevPath) }() default: break } } } func traverse(visitor: inout V) throws { - if self.phpGenericServices != 0 { - try visitor.visitSingularInt32Field(value: self.phpGenericServices, fieldNumber: 1) + if self.prevPath != 0 { + try visitor.visitSingularInt32Field(value: self.prevPath, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpGenericServices) -> Bool { - if lhs.phpGenericServices != rhs.phpGenericServices {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.prevPath, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.prevPath) -> Bool { + if lhs.prevPath != rhs.prevPath {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpMetadataNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".phpMetadataNamespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "phpMetadataNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.printUnknownFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".printUnknownFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}printUnknownFields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30378,31 +34231,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpMetadataNa // 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.phpMetadataNamespace) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.printUnknownFields) }() default: break } } } func traverse(visitor: inout V) throws { - if self.phpMetadataNamespace != 0 { - try visitor.visitSingularInt32Field(value: self.phpMetadataNamespace, fieldNumber: 1) + if self.printUnknownFields != 0 { + try visitor.visitSingularInt32Field(value: self.printUnknownFields, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpMetadataNamespace, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpMetadataNamespace) -> Bool { - if lhs.phpMetadataNamespace != rhs.phpMetadataNamespace {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.printUnknownFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.printUnknownFields) -> Bool { + if lhs.printUnknownFields != rhs.printUnknownFields {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".phpNamespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "phpNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.programBuffer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".programBuffer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}programBuffer\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30410,31 +34261,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpNamespace: // 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.phpNamespace) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.programBuffer) }() default: break } } } func traverse(visitor: inout V) throws { - if self.phpNamespace != 0 { - try visitor.visitSingularInt32Field(value: self.phpNamespace, fieldNumber: 1) + if self.programBuffer != 0 { + try visitor.visitSingularInt32Field(value: self.programBuffer, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpNamespace, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpNamespace) -> Bool { - if lhs.phpNamespace != rhs.phpNamespace {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.programBuffer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.programBuffer) -> Bool { + if lhs.programBuffer != rhs.programBuffer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".pointer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "pointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.programFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".programFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}programFormat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30442,31 +34291,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pointer: Swif // 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.pointer) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.programFormat) }() default: break } } } func traverse(visitor: inout V) throws { - if self.pointer != 0 { - try visitor.visitSingularInt32Field(value: self.pointer, fieldNumber: 1) + if self.programFormat != 0 { + try visitor.visitSingularInt32Field(value: self.programFormat, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pointer, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pointer) -> Bool { - if lhs.pointer != rhs.pointer {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.programFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.programFormat) -> Bool { + if lhs.programFormat != rhs.programFormat {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pos: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".pos" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "pos"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".proto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}proto2\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30474,31 +34321,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pos: SwiftPro // 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.pos) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.proto2) }() default: break } } } func traverse(visitor: inout V) throws { - if self.pos != 0 { - try visitor.visitSingularInt32Field(value: self.pos, fieldNumber: 1) + if self.proto2 != 0 { + try visitor.visitSingularInt32Field(value: self.proto2, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pos, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pos) -> Bool { - if lhs.pos != rhs.pos {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto2, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto2) -> Bool { + if lhs.proto2 != rhs.proto2 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.positiveIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".positiveIntValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "positiveIntValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto3DefaultValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".proto3DefaultValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}proto3DefaultValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30506,31 +34351,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.positiveIntVa // 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.positiveIntValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.proto3DefaultValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.positiveIntValue != 0 { - try visitor.visitSingularInt32Field(value: self.positiveIntValue, fieldNumber: 1) + if self.proto3DefaultValue != 0 { + try visitor.visitSingularInt32Field(value: self.proto3DefaultValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.positiveIntValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.positiveIntValue) -> Bool { - if lhs.positiveIntValue != rhs.positiveIntValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto3DefaultValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto3DefaultValue) -> Bool { + if lhs.proto3DefaultValue != rhs.proto3DefaultValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.prefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".prefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "prefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto3Optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".proto3Optional" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}proto3Optional\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30538,31 +34381,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.prefix: Swift // 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.prefix) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.proto3Optional) }() default: break } } } func traverse(visitor: inout V) throws { - if self.prefix != 0 { - try visitor.visitSingularInt32Field(value: self.prefix, fieldNumber: 1) + if self.proto3Optional != 0 { + try visitor.visitSingularInt32Field(value: self.proto3Optional, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.prefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.prefix) -> Bool { - if lhs.prefix != rhs.prefix {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto3Optional, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto3Optional) -> Bool { + if lhs.proto3Optional != rhs.proto3Optional {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preserveProtoFieldNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".preserveProtoFieldNames" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "preserveProtoFieldNames"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_extensionFieldValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_extensionFieldValues" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}protobuf_extensionFieldValues\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30570,31 +34411,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preserveProto // 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.preserveProtoFieldNames) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protobufExtensionFieldValues) }() default: break } } } func traverse(visitor: inout V) throws { - if self.preserveProtoFieldNames != 0 { - try visitor.visitSingularInt32Field(value: self.preserveProtoFieldNames, fieldNumber: 1) + if self.protobufExtensionFieldValues != 0 { + try visitor.visitSingularInt32Field(value: self.protobufExtensionFieldValues, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preserveProtoFieldNames, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preserveProtoFieldNames) -> Bool { - if lhs.preserveProtoFieldNames != rhs.preserveProtoFieldNames {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_extensionFieldValues, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_extensionFieldValues) -> Bool { + if lhs.protobufExtensionFieldValues != rhs.protobufExtensionFieldValues {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preTraverse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".preTraverse" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "preTraverse"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_fieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_fieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}protobuf_fieldNumber\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30602,31 +34441,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preTraverse: // 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.preTraverse) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protobufFieldNumber) }() default: break } } } func traverse(visitor: inout V) throws { - if self.preTraverse != 0 { - try visitor.visitSingularInt32Field(value: self.preTraverse, fieldNumber: 1) + if self.protobufFieldNumber != 0 { + try visitor.visitSingularInt32Field(value: self.protobufFieldNumber, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preTraverse, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preTraverse) -> Bool { - if lhs.preTraverse != rhs.preTraverse {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_fieldNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_fieldNumber) -> Bool { + if lhs.protobufFieldNumber != rhs.protobufFieldNumber {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.printUnknownFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".printUnknownFields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "printUnknownFields"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_generated_isEqualTo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_generated_isEqualTo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}protobuf_generated_isEqualTo\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30634,31 +34471,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.printUnknownF // 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.printUnknownFields) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protobufGeneratedIsEqualTo) }() default: break } } } func traverse(visitor: inout V) throws { - if self.printUnknownFields != 0 { - try visitor.visitSingularInt32Field(value: self.printUnknownFields, fieldNumber: 1) + if self.protobufGeneratedIsEqualTo != 0 { + try visitor.visitSingularInt32Field(value: self.protobufGeneratedIsEqualTo, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.printUnknownFields, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.printUnknownFields) -> Bool { - if lhs.printUnknownFields != rhs.printUnknownFields {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_generated_isEqualTo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_generated_isEqualTo) -> Bool { + if lhs.protobufGeneratedIsEqualTo != rhs.protobufGeneratedIsEqualTo {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".proto2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "proto2"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_nameMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_nameMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}protobuf_nameMap\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30666,31 +34501,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto2: Swift // 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.proto2) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protobufNameMap) }() default: break } } } func traverse(visitor: inout V) throws { - if self.proto2 != 0 { - try visitor.visitSingularInt32Field(value: self.proto2, fieldNumber: 1) + if self.protobufNameMap != 0 { + try visitor.visitSingularInt32Field(value: self.protobufNameMap, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto2, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto2) -> Bool { - if lhs.proto2 != rhs.proto2 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_nameMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_nameMap) -> Bool { + if lhs.protobufNameMap != rhs.protobufNameMap {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3DefaultValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".proto3DefaultValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "proto3DefaultValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_newField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_newField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}protobuf_newField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30698,31 +34531,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3Default // 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.proto3DefaultValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protobufNewField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.proto3DefaultValue != 0 { - try visitor.visitSingularInt32Field(value: self.proto3DefaultValue, fieldNumber: 1) + if self.protobufNewField != 0 { + try visitor.visitSingularInt32Field(value: self.protobufNewField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3DefaultValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3DefaultValue) -> Bool { - if lhs.proto3DefaultValue != rhs.proto3DefaultValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_newField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_newField) -> Bool { + if lhs.protobufNewField != rhs.protobufNewField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3Optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".proto3Optional" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "proto3Optional"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_package: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_package" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}protobuf_package\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30730,31 +34561,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3Optiona // 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.proto3Optional) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protobufPackage) }() default: break } } } func traverse(visitor: inout V) throws { - if self.proto3Optional != 0 { - try visitor.visitSingularInt32Field(value: self.proto3Optional, fieldNumber: 1) + if self.protobufPackage != 0 { + try visitor.visitSingularInt32Field(value: self.protobufPackage, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3Optional, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3Optional) -> Bool { - if lhs.proto3Optional != rhs.proto3Optional {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_package, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_package) -> Bool { + if lhs.protobufPackage != rhs.protobufPackage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVersionCheck: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufAPIVersionCheck" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufAPIVersionCheck"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufAPIVersion_2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufAPIVersion_2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}ProtobufAPIVersion_2\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30762,31 +34591,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVe // 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.protobufApiversionCheck) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protobufApiversion2) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protobufApiversionCheck != 0 { - try visitor.visitSingularInt32Field(value: self.protobufApiversionCheck, fieldNumber: 1) + if self.protobufApiversion2 != 0 { + try visitor.visitSingularInt32Field(value: self.protobufApiversion2, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVersionCheck, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVersionCheck) -> Bool { - if lhs.protobufApiversionCheck != rhs.protobufApiversionCheck {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufAPIVersion_2, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufAPIVersion_2) -> Bool { + if lhs.protobufApiversion2 != rhs.protobufApiversion2 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVersion_2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufAPIVersion_2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "ProtobufAPIVersion_2"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufAPIVersionCheck: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufAPIVersionCheck" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufAPIVersionCheck\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30794,31 +34621,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVe // 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.protobufApiversion2) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protobufApiversionCheck) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protobufApiversion2 != 0 { - try visitor.visitSingularInt32Field(value: self.protobufApiversion2, fieldNumber: 1) + if self.protobufApiversionCheck != 0 { + try visitor.visitSingularInt32Field(value: self.protobufApiversionCheck, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVersion_2, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVersion_2) -> Bool { - if lhs.protobufApiversion2 != rhs.protobufApiversion2 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufAPIVersionCheck, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufAPIVersionCheck) -> Bool { + if lhs.protobufApiversionCheck != rhs.protobufApiversionCheck {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBool: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufBool" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufBool"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufBool: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufBool" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufBool\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30839,18 +34664,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBool: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBool, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBool) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufBool, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufBool) -> Bool { if lhs.protobufBool != rhs.protobufBool {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufBytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30871,18 +34694,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBytes try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBytes, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBytes) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufBytes) -> Bool { if lhs.protobufBytes != rhs.protobufBytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufDouble: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufDouble" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufDouble"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobufData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protobufData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}protobufData\0") + + 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.protobufData) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.protobufData != 0 { + try visitor.visitSingularInt32Field(value: self.protobufData, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobufData, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobufData) -> Bool { + if lhs.protobufData != rhs.protobufData {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufDouble: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufDouble" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufDouble\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30903,18 +34754,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufDoubl try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufDouble, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufDouble) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufDouble, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufDouble) -> Bool { if lhs.protobufDouble != rhs.protobufDouble {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufEnumMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufEnumMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufEnumMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufEnumMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufEnumMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufEnumMap\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30935,18 +34784,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufEnumM try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufEnumMap, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufEnumMap) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufEnumMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufEnumMap) -> Bool { if lhs.protobufEnumMap != rhs.protobufEnumMap {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobufExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protobufExtension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "protobufExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobufExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protobufExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}protobufExtension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30967,18 +34814,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobufExten try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobufExtension, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobufExtension) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobufExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobufExtension) -> Bool { if lhs.protobufExtension != rhs.protobufExtension {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufFixed32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufFixed32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufFixed32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufFixed32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30999,18 +34844,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed32, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed32) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFixed32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFixed32) -> Bool { if lhs.protobufFixed32 != rhs.protobufFixed32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufFixed64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufFixed64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFixed64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufFixed64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufFixed64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31031,18 +34874,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed64, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed64) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFixed64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFixed64) -> Bool { if lhs.protobufFixed64 != rhs.protobufFixed64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFloat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufFloat" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufFloat"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFloat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufFloat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufFloat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31063,18 +34904,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFloat try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFloat, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFloat) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFloat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFloat) -> Bool { if lhs.protobufFloat != rhs.protobufFloat {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufInt32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufInt32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufInt32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufInt32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31095,18 +34934,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt32 try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt32, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt32) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufInt32) -> Bool { if lhs.protobufInt32 != rhs.protobufInt32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufInt64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufInt64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufInt64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31127,18 +34964,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt64 try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt64, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt64) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufInt64) -> Bool { if lhs.protobufInt64 != rhs.protobufInt64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufMap\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31159,18 +34994,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMap: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMap, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMap) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufMap) -> Bool { if lhs.protobufMap != rhs.protobufMap {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMessageMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufMessageMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufMessageMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufMessageMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufMessageMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufMessageMap\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31191,18 +35024,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMessa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMessageMap, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMessageMap) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufMessageMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufMessageMap) -> Bool { if lhs.protobufMessageMap != rhs.protobufMessageMap {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufSFixed32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufSFixed32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufSFixed32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufSFixed32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31223,18 +35054,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixe try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixed32, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixed32) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSFixed32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSFixed32) -> Bool { if lhs.protobufSfixed32 != rhs.protobufSfixed32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixed64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufSFixed64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufSFixed64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSFixed64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufSFixed64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufSFixed64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31255,18 +35084,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixe try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixed64, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixed64) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSFixed64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSFixed64) -> Bool { if lhs.protobufSfixed64 != rhs.protobufSfixed64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufSInt32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufSInt32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufSInt32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufSInt32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31287,18 +35114,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt3 try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt32, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt32) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSInt32) -> Bool { if lhs.protobufSint32 != rhs.protobufSint32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufSInt64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufSInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufSInt64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufSInt64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31319,18 +35144,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt6 try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt64, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt64) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSInt64) -> Bool { if lhs.protobufSint64 != rhs.protobufSint64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufString" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufString"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufString\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31351,18 +35174,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufStrin try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufString, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufString) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufString) -> Bool { if lhs.protobufString != rhs.protobufString {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufUInt32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufUInt32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufUInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufUInt32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufUInt32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31383,18 +35204,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt3 try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt32, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt32) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufUInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufUInt32) -> Bool { if lhs.protobufUint32 != rhs.protobufUint32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufUInt64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufUInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufUInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufUInt64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufUInt64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31415,18 +35234,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt6 try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt64, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt64) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufUInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufUInt64) -> Bool { if lhs.protobufUint64 != rhs.protobufUint64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_extensionFieldValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_extensionFieldValues" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "protobuf_extensionFieldValues"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protocolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protocol" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}protocol\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31434,31 +35251,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_exte // 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.protobufExtensionFieldValues) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`protocol`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protobufExtensionFieldValues != 0 { - try visitor.visitSingularInt32Field(value: self.protobufExtensionFieldValues, fieldNumber: 1) + if self.`protocol` != 0 { + try visitor.visitSingularInt32Field(value: self.`protocol`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_extensionFieldValues, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_extensionFieldValues) -> Bool { - if lhs.protobufExtensionFieldValues != rhs.protobufExtensionFieldValues {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protocolMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protocolMessage) -> Bool { + if lhs.`protocol` != rhs.`protocol` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_fieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_fieldNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "protobuf_fieldNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoFieldName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protoFieldName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}protoFieldName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31466,31 +35281,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_fiel // 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.protobufFieldNumber) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protoFieldName) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protobufFieldNumber != 0 { - try visitor.visitSingularInt32Field(value: self.protobufFieldNumber, fieldNumber: 1) + if self.protoFieldName != 0 { + try visitor.visitSingularInt32Field(value: self.protoFieldName, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_fieldNumber, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_fieldNumber) -> Bool { - if lhs.protobufFieldNumber != rhs.protobufFieldNumber {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoFieldName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoFieldName) -> Bool { + if lhs.protoFieldName != rhs.protoFieldName {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_generated_isEqualTo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_generated_isEqualTo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "protobuf_generated_isEqualTo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageNameMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protoMessageName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}protoMessageName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31498,31 +35311,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_gene // 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.protobufGeneratedIsEqualTo) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protoMessageName) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protobufGeneratedIsEqualTo != 0 { - try visitor.visitSingularInt32Field(value: self.protobufGeneratedIsEqualTo, fieldNumber: 1) + if self.protoMessageName != 0 { + try visitor.visitSingularInt32Field(value: self.protoMessageName, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_generated_isEqualTo, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_generated_isEqualTo) -> Bool { - if lhs.protobufGeneratedIsEqualTo != rhs.protobufGeneratedIsEqualTo {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageNameMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageNameMessage) -> Bool { + if lhs.protoMessageName != rhs.protoMessageName {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_nameMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_nameMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "protobuf_nameMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtoNameProviding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtoNameProviding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtoNameProviding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31530,31 +35341,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_name // 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.protobufNameMap) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protoNameProviding) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protobufNameMap != 0 { - try visitor.visitSingularInt32Field(value: self.protobufNameMap, fieldNumber: 1) + if self.protoNameProviding != 0 { + try visitor.visitSingularInt32Field(value: self.protoNameProviding, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_nameMap, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_nameMap) -> Bool { - if lhs.protobufNameMap != rhs.protobufNameMap {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtoNameProviding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtoNameProviding) -> Bool { + if lhs.protoNameProviding != rhs.protoNameProviding {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_newField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_newField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "protobuf_newField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoPaths: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protoPaths" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}protoPaths\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31562,31 +35371,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_newF // 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.protobufNewField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protoPaths) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protobufNewField != 0 { - try visitor.visitSingularInt32Field(value: self.protobufNewField, fieldNumber: 1) + if self.protoPaths != 0 { + try visitor.visitSingularInt32Field(value: self.protoPaths, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_newField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_newField) -> Bool { - if lhs.protobufNewField != rhs.protobufNewField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoPaths, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoPaths) -> Bool { + if lhs.protoPaths != rhs.protoPaths {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_package: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_package" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "protobuf_package"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.publicMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".public" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}public\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31594,31 +35401,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_pack // 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.protobufPackage) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`public`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protobufPackage != 0 { - try visitor.visitSingularInt32Field(value: self.protobufPackage, fieldNumber: 1) + if self.`public` != 0 { + try visitor.visitSingularInt32Field(value: self.`public`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_package, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_package) -> Bool { - if lhs.protobufPackage != rhs.protobufPackage {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.publicMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.publicMessage) -> Bool { + if lhs.`public` != rhs.`public` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protocolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protocol" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "protocol"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.publicDependency: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".publicDependency" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}publicDependency\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31626,31 +35431,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protocolMessa // 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.`protocol`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.publicDependency) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`protocol` != 0 { - try visitor.visitSingularInt32Field(value: self.`protocol`, fieldNumber: 1) + if self.publicDependency != 0 { + try visitor.visitSingularInt32Field(value: self.publicDependency, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protocolMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protocolMessage) -> Bool { - if lhs.`protocol` != rhs.`protocol` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.publicDependency, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.publicDependency) -> Bool { + if lhs.publicDependency != rhs.publicDependency {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoFieldName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protoFieldName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "protoFieldName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putBoolValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putBoolValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putBoolValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31658,31 +35461,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoFieldNam // 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.protoFieldName) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putBoolValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protoFieldName != 0 { - try visitor.visitSingularInt32Field(value: self.protoFieldName, fieldNumber: 1) + if self.putBoolValue != 0 { + try visitor.visitSingularInt32Field(value: self.putBoolValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoFieldName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoFieldName) -> Bool { - if lhs.protoFieldName != rhs.protoFieldName {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putBoolValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putBoolValue) -> Bool { + if lhs.putBoolValue != rhs.putBoolValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageNameMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protoMessageName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "protoMessageName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putBytesValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putBytesValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putBytesValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31690,31 +35491,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageN // 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.protoMessageName) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putBytesValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protoMessageName != 0 { - try visitor.visitSingularInt32Field(value: self.protoMessageName, fieldNumber: 1) + if self.putBytesValue != 0 { + try visitor.visitSingularInt32Field(value: self.putBytesValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageNameMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageNameMessage) -> Bool { - if lhs.protoMessageName != rhs.protoMessageName {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putBytesValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putBytesValue) -> Bool { + if lhs.putBytesValue != rhs.putBytesValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtoNameProviding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtoNameProviding" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtoNameProviding"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putDoubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putDoubleValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putDoubleValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31722,31 +35521,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtoNameProv // 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.protoNameProviding) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putDoubleValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protoNameProviding != 0 { - try visitor.visitSingularInt32Field(value: self.protoNameProviding, fieldNumber: 1) + if self.putDoubleValue != 0 { + try visitor.visitSingularInt32Field(value: self.putDoubleValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtoNameProviding, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtoNameProviding) -> Bool { - if lhs.protoNameProviding != rhs.protoNameProviding {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putDoubleValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putDoubleValue) -> Bool { + if lhs.putDoubleValue != rhs.putDoubleValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoPaths: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protoPaths" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "protoPaths"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putEnumValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putEnumValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putEnumValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31754,31 +35551,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoPaths: S // 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.protoPaths) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putEnumValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protoPaths != 0 { - try visitor.visitSingularInt32Field(value: self.protoPaths, fieldNumber: 1) + if self.putEnumValue != 0 { + try visitor.visitSingularInt32Field(value: self.putEnumValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoPaths, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoPaths) -> Bool { - if lhs.protoPaths != rhs.protoPaths {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putEnumValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putEnumValue) -> Bool { + if lhs.putEnumValue != rhs.putEnumValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".public" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "public"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFixedUInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putFixedUInt32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putFixedUInt32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31786,31 +35581,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicMessage // 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.`public`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putFixedUint32) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`public` != 0 { - try visitor.visitSingularInt32Field(value: self.`public`, fieldNumber: 1) + if self.putFixedUint32 != 0 { + try visitor.visitSingularInt32Field(value: self.putFixedUint32, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicMessage) -> Bool { - if lhs.`public` != rhs.`public` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFixedUInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFixedUInt32) -> Bool { + if lhs.putFixedUint32 != rhs.putFixedUint32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicDependency: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".publicDependency" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "publicDependency"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFixedUInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putFixedUInt64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putFixedUInt64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31818,31 +35611,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicDepende // 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.publicDependency) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putFixedUint64) }() default: break } } } func traverse(visitor: inout V) throws { - if self.publicDependency != 0 { - try visitor.visitSingularInt32Field(value: self.publicDependency, fieldNumber: 1) + if self.putFixedUint64 != 0 { + try visitor.visitSingularInt32Field(value: self.putFixedUint64, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicDependency, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicDependency) -> Bool { - if lhs.publicDependency != rhs.publicDependency {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFixedUInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFixedUInt64) -> Bool { + if lhs.putFixedUint64 != rhs.putFixedUint64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBoolValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putBoolValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putBoolValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFloatValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putFloatValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putFloatValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31850,31 +35641,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBoolValue: // 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.putBoolValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putFloatValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putBoolValue != 0 { - try visitor.visitSingularInt32Field(value: self.putBoolValue, fieldNumber: 1) + if self.putFloatValue != 0 { + try visitor.visitSingularInt32Field(value: self.putFloatValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBoolValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBoolValue) -> Bool { - if lhs.putBoolValue != rhs.putBoolValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFloatValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFloatValue) -> Bool { + if lhs.putFloatValue != rhs.putFloatValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBytesValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putBytesValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putBytesValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putInt64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putInt64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31882,31 +35671,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBytesValue // 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.putBytesValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putInt64) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putBytesValue != 0 { - try visitor.visitSingularInt32Field(value: self.putBytesValue, fieldNumber: 1) + if self.putInt64 != 0 { + try visitor.visitSingularInt32Field(value: self.putInt64, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBytesValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBytesValue) -> Bool { - if lhs.putBytesValue != rhs.putBytesValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putInt64) -> Bool { + if lhs.putInt64 != rhs.putInt64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putDoubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putDoubleValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putDoubleValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putStringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putStringValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putStringValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31914,31 +35701,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putDoubleValu // 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.putDoubleValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putStringValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putDoubleValue != 0 { - try visitor.visitSingularInt32Field(value: self.putDoubleValue, fieldNumber: 1) + if self.putStringValue != 0 { + try visitor.visitSingularInt32Field(value: self.putStringValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putDoubleValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putDoubleValue) -> Bool { - if lhs.putDoubleValue != rhs.putDoubleValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putStringValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putStringValue) -> Bool { + if lhs.putStringValue != rhs.putStringValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putEnumValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putEnumValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putEnumValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putUInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putUInt64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putUInt64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31946,31 +35731,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putEnumValue: // 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.putEnumValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putUint64) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putEnumValue != 0 { - try visitor.visitSingularInt32Field(value: self.putEnumValue, fieldNumber: 1) + if self.putUint64 != 0 { + try visitor.visitSingularInt32Field(value: self.putUint64, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putEnumValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putEnumValue) -> Bool { - if lhs.putEnumValue != rhs.putEnumValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putUInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putUInt64) -> Bool { + if lhs.putUint64 != rhs.putUint64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putFixedUInt32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putFixedUInt32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putUInt64Hex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putUInt64Hex" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putUInt64Hex\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31978,31 +35761,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt3 // 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.putFixedUint32) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putUint64Hex) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putFixedUint32 != 0 { - try visitor.visitSingularInt32Field(value: self.putFixedUint32, fieldNumber: 1) + if self.putUint64Hex != 0 { + try visitor.visitSingularInt32Field(value: self.putUint64Hex, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt32, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt32) -> Bool { - if lhs.putFixedUint32 != rhs.putFixedUint32 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putUInt64Hex, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putUInt64Hex) -> Bool { + if lhs.putUint64Hex != rhs.putUint64Hex {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putFixedUInt64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putFixedUInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putVarInt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putVarInt" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putVarInt\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32010,31 +35791,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt6 // 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.putFixedUint64) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putVarInt) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putFixedUint64 != 0 { - try visitor.visitSingularInt32Field(value: self.putFixedUint64, fieldNumber: 1) + if self.putVarInt != 0 { + try visitor.visitSingularInt32Field(value: self.putVarInt, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt64, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt64) -> Bool { - if lhs.putFixedUint64 != rhs.putFixedUint64 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putVarInt, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putVarInt) -> Bool { + if lhs.putVarInt != rhs.putVarInt {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFloatValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putFloatValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putFloatValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putZigZagVarInt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putZigZagVarInt" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putZigZagVarInt\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32042,31 +35821,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFloatValue // 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.putFloatValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putZigZagVarInt) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putFloatValue != 0 { - try visitor.visitSingularInt32Field(value: self.putFloatValue, fieldNumber: 1) + if self.putZigZagVarInt != 0 { + try visitor.visitSingularInt32Field(value: self.putZigZagVarInt, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFloatValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFloatValue) -> Bool { - if lhs.putFloatValue != rhs.putFloatValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putZigZagVarInt, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putZigZagVarInt) -> Bool { + if lhs.putZigZagVarInt != rhs.putZigZagVarInt {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putInt64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.pyGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".pyGenericServices" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}pyGenericServices\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32074,31 +35851,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putInt64: Swi // 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.putInt64) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.pyGenericServices) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putInt64 != 0 { - try visitor.visitSingularInt32Field(value: self.putInt64, fieldNumber: 1) + if self.pyGenericServices != 0 { + try visitor.visitSingularInt32Field(value: self.pyGenericServices, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putInt64, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putInt64) -> Bool { - if lhs.putInt64 != rhs.putInt64 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.pyGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.pyGenericServices) -> Bool { + if lhs.pyGenericServices != rhs.pyGenericServices {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putStringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putStringValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putStringValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.R: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".R" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}R\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32106,31 +35881,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putStringValu // 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.putStringValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.r) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putStringValue != 0 { - try visitor.visitSingularInt32Field(value: self.putStringValue, fieldNumber: 1) + if self.r != 0 { + try visitor.visitSingularInt32Field(value: self.r, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putStringValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putStringValue) -> Bool { - if lhs.putStringValue != rhs.putStringValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.R, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.R) -> Bool { + if lhs.r != rhs.r {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putUInt64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putUInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rawChars: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".rawChars" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}rawChars\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32138,31 +35911,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64: Sw // 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.putUint64) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.rawChars) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putUint64 != 0 { - try visitor.visitSingularInt32Field(value: self.putUint64, fieldNumber: 1) + if self.rawChars != 0 { + try visitor.visitSingularInt32Field(value: self.rawChars, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64) -> Bool { - if lhs.putUint64 != rhs.putUint64 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rawChars, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rawChars) -> Bool { + if lhs.rawChars != rhs.rawChars {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64Hex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putUInt64Hex" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putUInt64Hex"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RawRepresentable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".RawRepresentable" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}RawRepresentable\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32170,31 +35941,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64Hex: // 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.putUint64Hex) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.rawRepresentable) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putUint64Hex != 0 { - try visitor.visitSingularInt32Field(value: self.putUint64Hex, fieldNumber: 1) + if self.rawRepresentable != 0 { + try visitor.visitSingularInt32Field(value: self.rawRepresentable, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64Hex, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64Hex) -> Bool { - if lhs.putUint64Hex != rhs.putUint64Hex {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RawRepresentable, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RawRepresentable) -> Bool { + if lhs.rawRepresentable != rhs.rawRepresentable {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putVarInt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putVarInt" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putVarInt"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RawValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".RawValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}RawValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32202,31 +35971,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putVarInt: Sw // 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.putVarInt) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.rawValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putVarInt != 0 { - try visitor.visitSingularInt32Field(value: self.putVarInt, fieldNumber: 1) + if self.rawValue != 0 { + try visitor.visitSingularInt32Field(value: self.rawValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putVarInt, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putVarInt) -> Bool { - if lhs.putVarInt != rhs.putVarInt {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RawValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RawValue) -> Bool { + if lhs.rawValue != rhs.rawValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putZigZagVarInt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putZigZagVarInt" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putZigZagVarInt"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.read4HexDigits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".read4HexDigits" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}read4HexDigits\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32234,31 +36001,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putZigZagVarI // 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.putZigZagVarInt) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.read4HexDigits) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putZigZagVarInt != 0 { - try visitor.visitSingularInt32Field(value: self.putZigZagVarInt, fieldNumber: 1) + if self.read4HexDigits != 0 { + try visitor.visitSingularInt32Field(value: self.read4HexDigits, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putZigZagVarInt, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putZigZagVarInt) -> Bool { - if lhs.putZigZagVarInt != rhs.putZigZagVarInt {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.read4HexDigits, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.read4HexDigits) -> Bool { + if lhs.read4HexDigits != rhs.read4HexDigits {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pyGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".pyGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "pyGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.readBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".readBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}readBytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32266,31 +36031,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pyGenericServ // 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.pyGenericServices) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.readBytes) }() default: break } } } func traverse(visitor: inout V) throws { - if self.pyGenericServices != 0 { - try visitor.visitSingularInt32Field(value: self.pyGenericServices, fieldNumber: 1) + if self.readBytes != 0 { + try visitor.visitSingularInt32Field(value: self.readBytes, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pyGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pyGenericServices) -> Bool { - if lhs.pyGenericServices != rhs.pyGenericServices {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.readBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.readBytes) -> Bool { + if lhs.readBytes != rhs.readBytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rawChars: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".rawChars" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "rawChars"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.reader: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".reader" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}reader\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32298,31 +36061,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rawChars: Swi // 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.rawChars) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.reader) }() default: break } } } func traverse(visitor: inout V) throws { - if self.rawChars != 0 { - try visitor.visitSingularInt32Field(value: self.rawChars, fieldNumber: 1) + if self.reader != 0 { + try visitor.visitSingularInt32Field(value: self.reader, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rawChars, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rawChars) -> Bool { - if lhs.rawChars != rhs.rawChars {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.reader, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.reader) -> Bool { + if lhs.reader != rhs.reader {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawRepresentable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".RawRepresentable" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "RawRepresentable"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.register: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".register" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}register\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32330,31 +36091,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawRepresenta // 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.rawRepresentable) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.register) }() default: break } } } func traverse(visitor: inout V) throws { - if self.rawRepresentable != 0 { - try visitor.visitSingularInt32Field(value: self.rawRepresentable, fieldNumber: 1) + if self.register != 0 { + try visitor.visitSingularInt32Field(value: self.register, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawRepresentable, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawRepresentable) -> Bool { - if lhs.rawRepresentable != rhs.rawRepresentable {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.register, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.register) -> Bool { + if lhs.register != rhs.register {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".RawValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "RawValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.remainingProgram: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".remainingProgram" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}remainingProgram\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32362,31 +36121,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawValue: Swi // 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.rawValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.remainingProgram) }() default: break } } } func traverse(visitor: inout V) throws { - if self.rawValue != 0 { - try visitor.visitSingularInt32Field(value: self.rawValue, fieldNumber: 1) + if self.remainingProgram != 0 { + try visitor.visitSingularInt32Field(value: self.remainingProgram, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawValue) -> Bool { - if lhs.rawValue != rhs.rawValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.remainingProgram, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.remainingProgram) -> Bool { + if lhs.remainingProgram != rhs.remainingProgram {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.read4HexDigits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".read4HexDigits" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "read4HexDigits"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.removalError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".removalError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}removalError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32394,31 +36151,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.read4HexDigit // 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.read4HexDigits) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.removalError) }() default: break } } } func traverse(visitor: inout V) throws { - if self.read4HexDigits != 0 { - try visitor.visitSingularInt32Field(value: self.read4HexDigits, fieldNumber: 1) + if self.removalError != 0 { + try visitor.visitSingularInt32Field(value: self.removalError, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.read4HexDigits, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.read4HexDigits) -> Bool { - if lhs.read4HexDigits != rhs.read4HexDigits {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.removalError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.removalError) -> Bool { + if lhs.removalError != rhs.removalError {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.register: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".register" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "register"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.removingAllFieldsOf: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".removingAllFieldsOf" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}removingAllFieldsOf\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32426,31 +36181,59 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.register: Swi // 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.register) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.removingAllFieldsOf) }() default: break } } } func traverse(visitor: inout V) throws { - if self.register != 0 { - try visitor.visitSingularInt32Field(value: self.register, fieldNumber: 1) + if self.removingAllFieldsOf != 0 { + try visitor.visitSingularInt32Field(value: self.removingAllFieldsOf, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.register, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.register) -> Bool { - if lhs.register != rhs.register {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.removingAllFieldsOf, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.removingAllFieldsOf) -> Bool { + if lhs.removingAllFieldsOf != rhs.removingAllFieldsOf {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}repeated\0") + + 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.repeated) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.repeated != 0 { + try visitor.visitSingularInt32Field(value: self.repeated, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeated) -> Bool { + if lhs.repeated != rhs.repeated {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedEnumExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedEnumExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "RepeatedEnumExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedEnumExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedEnumExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}RepeatedEnumExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32471,18 +36254,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedEnumE try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedEnumExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedEnumExtensionField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedEnumExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedEnumExtensionField) -> Bool { if lhs.repeatedEnumExtensionField != rhs.repeatedEnumExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "RepeatedExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}RepeatedExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32503,18 +36284,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedExten try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedExtensionField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedExtensionField) -> Bool { if lhs.repeatedExtensionField != rhs.repeatedExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedGroupExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedGroupExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "RepeatedGroupExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFieldEncoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedFieldEncoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}repeatedFieldEncoding\0") + + 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.repeatedFieldEncoding) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.repeatedFieldEncoding != 0 { + try visitor.visitSingularInt32Field(value: self.repeatedFieldEncoding, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFieldEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFieldEncoding) -> Bool { + if lhs.repeatedFieldEncoding != rhs.repeatedFieldEncoding {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedGroupExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedGroupExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}RepeatedGroupExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32535,18 +36344,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedGroup try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedGroupExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedGroupExtensionField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedGroupExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedGroupExtensionField) -> Bool { if lhs.repeatedGroupExtensionField != rhs.repeatedGroupExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedMessageExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedMessageExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "RepeatedMessageExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedMessageExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedMessageExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}RepeatedMessageExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32567,18 +36374,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedMessa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedMessageExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedMessageExtensionField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedMessageExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedMessageExtensionField) -> Bool { if lhs.repeatedMessageExtensionField != rhs.repeatedMessageExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".requestStreaming" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "requestStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeating: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeating" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}repeating\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32586,31 +36391,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestStream // 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.requestStreaming) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeating) }() default: break } } } func traverse(visitor: inout V) throws { - if self.requestStreaming != 0 { - try visitor.visitSingularInt32Field(value: self.requestStreaming, fieldNumber: 1) + if self.repeating != 0 { + try visitor.visitSingularInt32Field(value: self.repeating, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestStreaming, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestStreaming) -> Bool { - if lhs.requestStreaming != rhs.requestStreaming {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeating, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeating) -> Bool { + if lhs.repeating != rhs.repeating {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestTypeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".requestTypeURL" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "requestTypeURL"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.replaceRepeatedFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".replaceRepeatedFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}replaceRepeatedFields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32618,31 +36421,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestTypeUR // 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.requestTypeURL) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.replaceRepeatedFields) }() default: break } } } func traverse(visitor: inout V) throws { - if self.requestTypeURL != 0 { - try visitor.visitSingularInt32Field(value: self.requestTypeURL, fieldNumber: 1) + if self.replaceRepeatedFields != 0 { + try visitor.visitSingularInt32Field(value: self.replaceRepeatedFields, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestTypeURL, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestTypeURL) -> Bool { - if lhs.requestTypeURL != rhs.requestTypeURL {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.replaceRepeatedFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.replaceRepeatedFields) -> Bool { + if lhs.replaceRepeatedFields != rhs.replaceRepeatedFields {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requiredSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".requiredSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "requiredSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requestStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".requestStreaming" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}requestStreaming\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32650,31 +36451,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requiredSize: // 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.requiredSize) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.requestStreaming) }() default: break } } } func traverse(visitor: inout V) throws { - if self.requiredSize != 0 { - try visitor.visitSingularInt32Field(value: self.requiredSize, fieldNumber: 1) + if self.requestStreaming != 0 { + try visitor.visitSingularInt32Field(value: self.requestStreaming, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requiredSize, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requiredSize) -> Bool { - if lhs.requiredSize != rhs.requiredSize {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requestStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requestStreaming) -> Bool { + if lhs.requestStreaming != rhs.requestStreaming {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".reservedName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "reservedName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requestTypeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".requestTypeURL" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}requestTypeURL\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32682,31 +36481,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedName: // 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.reservedName) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.requestTypeURL) }() default: break } } } func traverse(visitor: inout V) throws { - if self.reservedName != 0 { - try visitor.visitSingularInt32Field(value: self.reservedName, fieldNumber: 1) + if self.requestTypeURL != 0 { + try visitor.visitSingularInt32Field(value: self.requestTypeURL, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedName) -> Bool { - if lhs.reservedName != rhs.reservedName {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requestTypeURL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requestTypeURL) -> Bool { + if lhs.requestTypeURL != rhs.requestTypeURL {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedRange: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".reservedRange" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "reservedRange"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requiredSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".requiredSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}requiredSize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32714,31 +36511,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedRange // 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.reservedRange) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.requiredSize) }() default: break } } } func traverse(visitor: inout V) throws { - if self.reservedRange != 0 { - try visitor.visitSingularInt32Field(value: self.reservedRange, fieldNumber: 1) + if self.requiredSize != 0 { + try visitor.visitSingularInt32Field(value: self.requiredSize, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedRange, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedRange) -> Bool { - if lhs.reservedRange != rhs.reservedRange {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requiredSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requiredSize) -> Bool { + if lhs.requiredSize != rhs.requiredSize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".responseStreaming" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "responseStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.responseStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".responseStreaming" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}responseStreaming\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32759,18 +36554,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseStrea try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseStreaming, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseStreaming) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.responseStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.responseStreaming) -> Bool { if lhs.responseStreaming != rhs.responseStreaming {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseTypeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".responseTypeURL" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "responseTypeURL"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.responseTypeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".responseTypeURL" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}responseTypeURL\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32791,18 +36584,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseTypeU try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseTypeURL, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseTypeURL) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.responseTypeURL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.responseTypeURL) -> Bool { if lhs.responseTypeURL != rhs.responseTypeURL {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.result: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".result" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "result"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.result: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".result" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}result\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32823,18 +36614,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.result: Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.result, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.result) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.result, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.result) -> Bool { if lhs.result != rhs.result {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rethrowsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".rethrows" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "rethrows"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.retention: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".retention" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}retention\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32842,31 +36631,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rethrowsMessa // 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.`rethrows`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.retention) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`rethrows` != 0 { - try visitor.visitSingularInt32Field(value: self.`rethrows`, fieldNumber: 1) + if self.retention != 0 { + try visitor.visitSingularInt32Field(value: self.retention, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rethrowsMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rethrowsMessage) -> Bool { - if lhs.`rethrows` != rhs.`rethrows` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.retention, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.retention) -> Bool { + if lhs.retention != rhs.retention {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.returnMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".return" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "return"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rethrowsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".rethrows" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}rethrows\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32874,31 +36661,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.returnMessage // 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.`return`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`rethrows`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`return` != 0 { - try visitor.visitSingularInt32Field(value: self.`return`, fieldNumber: 1) + if self.`rethrows` != 0 { + try visitor.visitSingularInt32Field(value: self.`rethrows`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.returnMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.returnMessage) -> Bool { - if lhs.`return` != rhs.`return` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rethrowsMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rethrowsMessage) -> Bool { + if lhs.`rethrows` != rhs.`rethrows` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ReturnType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ReturnType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ReturnType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ReturnType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ReturnType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ReturnType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32919,18 +36704,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ReturnType: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ReturnType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ReturnType) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ReturnType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ReturnType) -> Bool { if lhs.returnType != rhs.returnType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.revision: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".revision" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "revision"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.revision: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".revision" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}revision\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32951,18 +36734,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.revision: Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.revision, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.revision) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.revision, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.revision) -> Bool { if lhs.revision != rhs.revision {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rhs: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".rhs" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "rhs"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rhs: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".rhs" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}rhs\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32983,18 +36764,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rhs: SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rhs, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rhs) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rhs, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rhs) -> Bool { if lhs.rhs != rhs.rhs {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.root: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".root" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "root"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.root: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".root" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}root\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33015,18 +36794,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.root: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.root, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.root) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.root, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.root) -> Bool { if lhs.root != rhs.root {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rubyPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".rubyPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "rubyPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rubyPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".rubyPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}rubyPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33047,18 +36824,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rubyPackage: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rubyPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rubyPackage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rubyPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rubyPackage) -> Bool { if lhs.rubyPackage != rhs.rubyPackage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.s: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".s" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "s"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.s: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".s" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}s\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33079,18 +36854,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.s: SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.s, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.s) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.s, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.s) -> Bool { if lhs.s != rhs.s {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawBackslash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".sawBackslash" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sawBackslash"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawBackslash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sawBackslash" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sawBackslash\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33111,18 +36884,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawBackslash: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawBackslash, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawBackslash) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawBackslash, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawBackslash) -> Bool { if lhs.sawBackslash != rhs.sawBackslash {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection4Characters: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".sawSection4Characters" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sawSection4Characters"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection4Characters: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sawSection4Characters" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sawSection4Characters\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33143,18 +36914,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection4Ch try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection4Characters, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection4Characters) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection4Characters, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection4Characters) -> Bool { if lhs.sawSection4Characters != rhs.sawSection4Characters {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection5Characters: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".sawSection5Characters" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sawSection5Characters"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection5Characters: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sawSection5Characters" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sawSection5Characters\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33175,18 +36944,76 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection5Ch try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection5Characters, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection5Characters) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection5Characters, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection5Characters) -> Bool { if lhs.sawSection5Characters != rhs.sawSection5Characters {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.scanner: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".scanner" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "scanner"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Scalar: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Scalar" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Scalar\0") + + 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.scalar) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.scalar != 0 { + try visitor.visitSingularInt32Field(value: self.scalar, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Scalar, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Scalar) -> Bool { + if lhs.scalar != rhs.scalar {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scan: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".scan" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}scan\0") + + 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.scan) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.scan != 0 { + try visitor.visitSingularInt32Field(value: self.scan, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scan, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scan) -> Bool { + if lhs.scan != rhs.scan {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scanner: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".scanner" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}scanner\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33207,18 +37034,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.scanner: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.scanner, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.scanner) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scanner, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scanner) -> Bool { if lhs.scanner != rhs.scanner {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.seconds: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".seconds" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "seconds"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.seconds: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".seconds" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}seconds\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33239,18 +37064,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.seconds: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.seconds, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.seconds) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.seconds, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.seconds) -> Bool { if lhs.seconds != rhs.seconds {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.selfMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".self" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "self"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.selfMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".self" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}self\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33271,18 +37094,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.selfMessage: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.selfMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.selfMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.selfMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.selfMessage) -> Bool { if lhs.self_p != rhs.self_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.separator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".separator" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "separator"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.semantic: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".semantic" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}semantic\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33290,31 +37111,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.separator: Sw // 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.separator) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.semantic) }() default: break } } } func traverse(visitor: inout V) throws { - if self.separator != 0 { - try visitor.visitSingularInt32Field(value: self.separator, fieldNumber: 1) + if self.semantic != 0 { + try visitor.visitSingularInt32Field(value: self.semantic, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.separator, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.separator) -> Bool { - if lhs.separator != rhs.separator {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.semantic, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.semantic) -> Bool { + if lhs.semantic != rhs.semantic {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serialize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".serialize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "serialize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SendableMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Sendable" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Sendable\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33322,31 +37141,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serialize: Sw // 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.serialize) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.sendable) }() default: break } } } func traverse(visitor: inout V) throws { - if self.serialize != 0 { - try visitor.visitSingularInt32Field(value: self.serialize, fieldNumber: 1) + if self.sendable != 0 { + try visitor.visitSingularInt32Field(value: self.sendable, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serialize, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serialize) -> Bool { - if lhs.serialize != rhs.serialize {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SendableMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SendableMessage) -> Bool { + if lhs.sendable != rhs.sendable {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".serializedData" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "serializedData"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.separator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".separator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}separator\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33354,31 +37171,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedDat // 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.serializedData) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.separator) }() default: break } } } func traverse(visitor: inout V) throws { - if self.serializedData != 0 { - try visitor.visitSingularInt32Field(value: self.serializedData, fieldNumber: 1) + if self.separator != 0 { + try visitor.visitSingularInt32Field(value: self.separator, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedData, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedData) -> Bool { - if lhs.serializedData != rhs.serializedData {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.separator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.separator) -> Bool { + if lhs.separator != rhs.separator {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".serializedSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "serializedSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serialize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serialize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}serialize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33386,31 +37201,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedSiz // 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.serializedSize) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.serialize) }() default: break } } } func traverse(visitor: inout V) throws { - if self.serializedSize != 0 { - try visitor.visitSingularInt32Field(value: self.serializedSize, fieldNumber: 1) + if self.serialize != 0 { + try visitor.visitSingularInt32Field(value: self.serialize, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedSize, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedSize) -> Bool { - if lhs.serializedSize != rhs.serializedSize {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serialize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serialize) -> Bool { + if lhs.serialize != rhs.serialize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serverStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".serverStreaming" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "serverStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serializedBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}serializedBytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33418,31 +37231,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serverStreami // 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.serverStreaming) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.serializedBytes) }() default: break } } } func traverse(visitor: inout V) throws { - if self.serverStreaming != 0 { - try visitor.visitSingularInt32Field(value: self.serverStreaming, fieldNumber: 1) + if self.serializedBytes != 0 { + try visitor.visitSingularInt32Field(value: self.serializedBytes, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serverStreaming, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serverStreaming) -> Bool { - if lhs.serverStreaming != rhs.serverStreaming {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedBytes) -> Bool { + if lhs.serializedBytes != rhs.serializedBytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.service: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".service" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "service"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serializedData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}serializedData\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33450,31 +37261,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.service: Swif // 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.service) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.serializedData) }() default: break } } } func traverse(visitor: inout V) throws { - if self.service != 0 { - try visitor.visitSingularInt32Field(value: self.service, fieldNumber: 1) + if self.serializedData != 0 { + try visitor.visitSingularInt32Field(value: self.serializedData, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.service, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.service) -> Bool { - if lhs.service != rhs.service {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedData, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedData) -> Bool { + if lhs.serializedData != rhs.serializedData {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ServiceDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ServiceDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serializedSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}serializedSize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33482,31 +37291,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceDescri // 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.serviceDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.serializedSize) }() default: break } } } func traverse(visitor: inout V) throws { - if self.serviceDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.serviceDescriptorProto, fieldNumber: 1) + if self.serializedSize != 0 { + try visitor.visitSingularInt32Field(value: self.serializedSize, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceDescriptorProto) -> Bool { - if lhs.serviceDescriptorProto != rhs.serviceDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedSize) -> Bool { + if lhs.serializedSize != rhs.serializedSize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ServiceOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ServiceOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serverStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serverStreaming" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}serverStreaming\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33514,31 +37321,59 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceOption // 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.serviceOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.serverStreaming) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.serverStreaming != 0 { + try visitor.visitSingularInt32Field(value: self.serverStreaming, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serverStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serverStreaming) -> Bool { + if lhs.serverStreaming != rhs.serverStreaming {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.service: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".service" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}service\0") + + 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.service) }() default: break } } } func traverse(visitor: inout V) throws { - if self.serviceOptions != 0 { - try visitor.visitSingularInt32Field(value: self.serviceOptions, fieldNumber: 1) + if self.service != 0 { + try visitor.visitSingularInt32Field(value: self.service, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceOptions) -> Bool { - if lhs.serviceOptions != rhs.serviceOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.service, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.service) -> Bool { + if lhs.service != rhs.service {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.set: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".set" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "set"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.set: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".set" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}set\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33559,18 +37394,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.set: SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.set, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.set) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.set, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.set) -> Bool { if lhs.set != rhs.set {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.setExtensionValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".setExtensionValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "setExtensionValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.setExtensionValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".setExtensionValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}setExtensionValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33591,18 +37424,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.setExtensionV try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.setExtensionValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.setExtensionValue) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.setExtensionValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.setExtensionValue) -> Bool { if lhs.setExtensionValue != rhs.setExtensionValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.shift: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".shift" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "shift"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.shift: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".shift" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}shift\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33623,18 +37454,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.shift: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.shift, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.shift) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.shift, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.shift) -> Bool { if lhs.shift != rhs.shift {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SimpleExtensionMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".SimpleExtensionMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "SimpleExtensionMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SimpleExtensionMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".SimpleExtensionMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}SimpleExtensionMap\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33655,18 +37484,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SimpleExtensi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SimpleExtensionMap, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SimpleExtensionMap) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SimpleExtensionMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SimpleExtensionMap) -> Bool { if lhs.simpleExtensionMap != rhs.simpleExtensionMap {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sizer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".sizer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sizer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.size: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".size" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}size\0") + + 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.size) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.size != 0 { + try visitor.visitSingularInt32Field(value: self.size, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.size, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.size) -> Bool { + if lhs.size != rhs.size {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sizer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sizer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sizer\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33687,18 +37544,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sizer: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sizer, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sizer) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sizer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sizer) -> Bool { if lhs.sizer != rhs.sizer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.source: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".source" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "source"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.source: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".source" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}source\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33719,18 +37574,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.source: Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.source, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.source) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.source, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.source) -> Bool { if lhs.source != rhs.source {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".sourceCodeInfo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sourceCodeInfo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sourceCodeInfo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sourceCodeInfo\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33751,18 +37604,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceCodeInf try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceCodeInfo, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceCodeInfo) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceCodeInfo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceCodeInfo) -> Bool { if lhs.sourceCodeInfo != rhs.sourceCodeInfo {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceContext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".sourceContext" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sourceContext"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceContext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sourceContext" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sourceContext\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33783,18 +37634,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceContext try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceContext, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceContext) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceContext, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceContext) -> Bool { if lhs.sourceContext != rhs.sourceContext {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceEncoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".sourceEncoding" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sourceEncoding"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceEncoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sourceEncoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sourceEncoding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33815,18 +37664,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceEncodin try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceEncoding, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceEncoding) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceEncoding) -> Bool { if lhs.sourceEncoding != rhs.sourceEncoding {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceFile: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".sourceFile" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sourceFile"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceFile: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sourceFile" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sourceFile\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33847,18 +37694,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceFile: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceFile, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceFile) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceFile, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceFile) -> Bool { if lhs.sourceFile != rhs.sourceFile {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.span: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".span" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "span"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SourceLocation: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".SourceLocation" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}SourceLocation\0") + + 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.sourceLocation) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.sourceLocation != 0 { + try visitor.visitSingularInt32Field(value: self.sourceLocation, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SourceLocation, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SourceLocation) -> Bool { + if lhs.sourceLocation != rhs.sourceLocation {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.span: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".span" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}span\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33879,18 +37754,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.span: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.span, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.span) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.span, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.span) -> Bool { if lhs.span != rhs.span {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.split: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".split" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "split"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.split: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".split" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}split\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33911,18 +37784,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.split: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.split, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.split) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.split, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.split) -> Bool { if lhs.split != rhs.split {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.start: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".start" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "start"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.start: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".start" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}start\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33943,18 +37814,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.start: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.start, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.start) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.start, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.start) -> Bool { if lhs.start != rhs.start {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArray: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".startArray" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "startArray"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startArray: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".startArray" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}startArray\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33975,18 +37844,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArray: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArray, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArray) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startArray, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startArray) -> Bool { if lhs.startArray != rhs.startArray {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArrayObject: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".startArrayObject" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "startArrayObject"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startArrayObject: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".startArrayObject" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}startArrayObject\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34007,18 +37874,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArrayObj try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArrayObject, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArrayObject) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startArrayObject, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startArrayObject) -> Bool { if lhs.startArrayObject != rhs.startArrayObject {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".startField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "startField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".startField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}startField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34039,18 +37904,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startField: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startField) -> Bool { if lhs.startField != rhs.startField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startIndex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".startIndex" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "startIndex"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startIndex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".startIndex" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}startIndex\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34071,18 +37934,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startIndex: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startIndex, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startIndex) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startIndex, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startIndex) -> Bool { if lhs.startIndex != rhs.startIndex {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".startMessageField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "startMessageField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".startMessageField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}startMessageField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34103,18 +37964,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startMessageF try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startMessageField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startMessageField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startMessageField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startMessageField) -> Bool { if lhs.startMessageField != rhs.startMessageField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startObject: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".startObject" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "startObject"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startObject: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".startObject" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}startObject\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34135,18 +37994,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startObject: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startObject, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startObject) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startObject, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startObject) -> Bool { if lhs.startObject != rhs.startObject {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startRegularField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".startRegularField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "startRegularField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startRegularField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".startRegularField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}startRegularField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34167,18 +38024,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startRegularF try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startRegularField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startRegularField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startRegularField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startRegularField) -> Bool { if lhs.startRegularField != rhs.startRegularField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.state: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".state" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "state"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.state: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".state" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}state\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34199,18 +38054,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.state: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.state, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.state) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.state, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.state) -> Bool { if lhs.state != rhs.state {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.staticMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".static" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "static"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.staticMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".static" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}static\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34231,18 +38084,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.staticMessage try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.staticMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.staticMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.staticMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.staticMessage) -> Bool { if lhs.`static` != rhs.`static` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StaticString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".StaticString" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "StaticString"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StaticString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".StaticString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}StaticString\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34263,18 +38114,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StaticString: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StaticString, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StaticString) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StaticString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StaticString) -> Bool { if lhs.staticString != rhs.staticString {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.storage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".storage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "storage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.storage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".storage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}storage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34295,18 +38144,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.storage: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.storage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.storage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.storage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.storage) -> Bool { if lhs.storage != rhs.storage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".String" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "String"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StringMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".String" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}String\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34327,18 +38174,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringMessage try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StringMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StringMessage) -> Bool { if lhs.string != rhs.string {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".stringLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "stringLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".stringLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}stringLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34359,18 +38204,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringLiteral try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringLiteral) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringLiteral) -> Bool { if lhs.stringLiteral != rhs.stringLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".StringLiteralType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "StringLiteralType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StringLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".StringLiteralType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}StringLiteralType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34391,18 +38234,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringLiteral try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringLiteralType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringLiteralType) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StringLiteralType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StringLiteralType) -> Bool { if lhs.stringLiteralType != rhs.stringLiteralType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".stringResult" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "stringResult"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".stringResult" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}stringResult\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34423,18 +38264,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringResult: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringResult, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringResult) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringResult, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringResult) -> Bool { if lhs.stringResult != rhs.stringResult {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".stringValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "stringValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".stringValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}stringValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34455,18 +38294,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringValue: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringValue) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringValue) -> Bool { if lhs.stringValue != rhs.stringValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".struct" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "struct"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.structMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".struct" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}struct\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34487,18 +38324,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structMessage try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.structMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.structMessage) -> Bool { if lhs.`struct` != rhs.`struct` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".structValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "structValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.structValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".structValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}structValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34519,18 +38354,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structValue: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structValue) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.structValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.structValue) -> Bool { if lhs.structValue != rhs.structValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".subDecoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "subDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".subDecoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}subDecoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34551,18 +38384,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subDecoder: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subDecoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subDecoder) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subDecoder) -> Bool { if lhs.subDecoder != rhs.subDecoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subscriptMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".subscript" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "subscript"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subscriptMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".subscript" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}subscript\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34583,18 +38414,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subscriptMess try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subscriptMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subscriptMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subscriptMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subscriptMessage) -> Bool { if lhs.`subscript` != rhs.`subscript` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".subVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "subVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subtract: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".subtract" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}subtract\0") + + 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.subtract) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.subtract != 0 { + try visitor.visitSingularInt32Field(value: self.subtract, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subtract, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subtract) -> Bool { + if lhs.subtract != rhs.subtract {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".subVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}subVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34615,18 +38474,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subVisitor: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subVisitor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subVisitor) -> Bool { if lhs.subVisitor != rhs.subVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Swift: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Swift" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Swift"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Swift" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Swift\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34647,18 +38504,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Swift: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Swift, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Swift) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftMessage) -> Bool { if lhs.swift != rhs.swift {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.swiftPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".swiftPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "swiftPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.swiftPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".swiftPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}swiftPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34679,18 +38534,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.swiftPrefix: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.swiftPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.swiftPrefix) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.swiftPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.swiftPrefix) -> Bool { if lhs.swiftPrefix != rhs.swiftPrefix {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SwiftProtobufMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".SwiftProtobuf" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "SwiftProtobuf"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftProtobufContiguousBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".SwiftProtobufContiguousBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}SwiftProtobufContiguousBytes\0") + + 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.swiftProtobufContiguousBytes) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.swiftProtobufContiguousBytes != 0 { + try visitor.visitSingularInt32Field(value: self.swiftProtobufContiguousBytes, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftProtobufContiguousBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftProtobufContiguousBytes) -> Bool { + if lhs.swiftProtobufContiguousBytes != rhs.swiftProtobufContiguousBytes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftProtobufError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".SwiftProtobufError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}SwiftProtobufError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34698,31 +38581,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SwiftProtobuf // 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.swiftProtobuf) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.swiftProtobufError) }() default: break } } } func traverse(visitor: inout V) throws { - if self.swiftProtobuf != 0 { - try visitor.visitSingularInt32Field(value: self.swiftProtobuf, fieldNumber: 1) + if self.swiftProtobufError != 0 { + try visitor.visitSingularInt32Field(value: self.swiftProtobufError, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SwiftProtobufMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SwiftProtobufMessage) -> Bool { - if lhs.swiftProtobuf != rhs.swiftProtobuf {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftProtobufError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftProtobufError) -> Bool { + if lhs.swiftProtobufError != rhs.swiftProtobufError {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.syntax: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".syntax" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "syntax"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.syntax: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".syntax" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}syntax\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34743,18 +38624,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.syntax: Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.syntax, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.syntax) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.syntax, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.syntax) -> Bool { if lhs.syntax != rhs.syntax {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.T: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".T" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "T"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.T: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".T" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}T\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34775,18 +38654,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.T: SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.T, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.T) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.T, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.T) -> Bool { if lhs.t != rhs.t {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tag: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".tag" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "tag"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tag: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".tag" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}tag\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34807,18 +38684,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tag: SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tag, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tag) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tag, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tag) -> Bool { if lhs.tag != rhs.tag {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.terminator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".terminator" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "terminator"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.targets: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".targets" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}targets\0") + + 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.targets) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.targets != 0 { + try visitor.visitSingularInt32Field(value: self.targets, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.targets, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.targets) -> Bool { + if lhs.targets != rhs.targets {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.terminator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".terminator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}terminator\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34839,18 +38744,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.terminator: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.terminator, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.terminator) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.terminator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.terminator) -> Bool { if lhs.terminator != rhs.terminator {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.testDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".testDecoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "testDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.testDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".testDecoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}testDecoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34871,18 +38774,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.testDecoder: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.testDecoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.testDecoder) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.testDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.testDecoder) -> Bool { if lhs.testDecoder != rhs.testDecoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.text: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".text" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "text"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.text: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".text" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}text\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34903,18 +38804,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.text: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.text, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.text) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.text, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.text) -> Bool { if lhs.text != rhs.text {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".textDecoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "textDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.textDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".textDecoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}textDecoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34935,18 +38834,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textDecoder: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textDecoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textDecoder) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.textDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.textDecoder) -> Bool { if lhs.textDecoder != rhs.textDecoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatDecoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TextFormatDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatDecoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}TextFormatDecoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34967,18 +38864,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDec try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecoder) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecoder) -> Bool { if lhs.textFormatDecoder != rhs.textFormatDecoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatDecodingError" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TextFormatDecodingError"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatDecodingError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}TextFormatDecodingError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34999,18 +38894,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDec try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecodingError, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecodingError) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecodingError) -> Bool { if lhs.textFormatDecodingError != rhs.textFormatDecodingError {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatDecodingOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TextFormatDecodingOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatDecodingOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}TextFormatDecodingOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35031,18 +38924,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDec try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecodingOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecodingOptions) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecodingOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecodingOptions) -> Bool { if lhs.textFormatDecodingOptions != rhs.textFormatDecodingOptions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEncodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatEncodingOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TextFormatEncodingOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatEncodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatEncodingOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}TextFormatEncodingOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35063,18 +38954,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEnc try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEncodingOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEncodingOptions) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatEncodingOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatEncodingOptions) -> Bool { if lhs.textFormatEncodingOptions != rhs.textFormatEncodingOptions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEncodingVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatEncodingVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TextFormatEncodingVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatEncodingVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatEncodingVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}TextFormatEncodingVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35095,18 +38984,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEnc try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEncodingVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEncodingVisitor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatEncodingVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatEncodingVisitor) -> Bool { if lhs.textFormatEncodingVisitor != rhs.textFormatEncodingVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textFormatString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".textFormatString" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "textFormatString"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.textFormatString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".textFormatString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}textFormatString\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35127,18 +39014,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textFormatStr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textFormatString, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textFormatString) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.textFormatString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.textFormatString) -> Bool { if lhs.textFormatString != rhs.textFormatString {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.throwsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".throws" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "throws"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.throwOrIgnore: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".throwOrIgnore" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}throwOrIgnore\0") + + 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.throwOrIgnore) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.throwOrIgnore != 0 { + try visitor.visitSingularInt32Field(value: self.throwOrIgnore, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.throwOrIgnore, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.throwOrIgnore) -> Bool { + if lhs.throwOrIgnore != rhs.throwOrIgnore {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.throwsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".throws" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}throws\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35159,18 +39074,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.throwsMessage try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.throwsMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.throwsMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.throwsMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.throwsMessage) -> Bool { if lhs.`throws` != rhs.`throws` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeInterval: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".timeInterval" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "timeInterval"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeInterval: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".timeInterval" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}timeInterval\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35191,18 +39104,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeInterval: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeInterval, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeInterval) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeInterval, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeInterval) -> Bool { if lhs.timeInterval != rhs.timeInterval {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalSince1970: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".timeIntervalSince1970" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "timeIntervalSince1970"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeIntervalSince1970: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".timeIntervalSince1970" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}timeIntervalSince1970\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35223,18 +39134,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalS try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalSince1970, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalSince1970) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeIntervalSince1970, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeIntervalSince1970) -> Bool { if lhs.timeIntervalSince1970 != rhs.timeIntervalSince1970 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalSinceReferenceDate: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".timeIntervalSinceReferenceDate" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "timeIntervalSinceReferenceDate"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeIntervalSinceReferenceDate: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".timeIntervalSinceReferenceDate" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}timeIntervalSinceReferenceDate\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35255,18 +39164,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalS try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalSinceReferenceDate, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalSinceReferenceDate) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeIntervalSinceReferenceDate, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeIntervalSinceReferenceDate) -> Bool { if lhs.timeIntervalSinceReferenceDate != rhs.timeIntervalSinceReferenceDate {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Timestamp: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Timestamp" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Timestamp"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tmp: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".tmp" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}tmp\0") + + 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.tmp) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.tmp != 0 { + try visitor.visitSingularInt32Field(value: self.tmp, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tmp, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tmp) -> Bool { + if lhs.tmp != rhs.tmp {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tooLarge: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".tooLarge" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}tooLarge\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35274,31 +39211,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Timestamp: Sw // 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.timestamp) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.tooLarge) }() default: break } } } func traverse(visitor: inout V) throws { - if self.timestamp != 0 { - try visitor.visitSingularInt32Field(value: self.timestamp, fieldNumber: 1) + if self.tooLarge != 0 { + try visitor.visitSingularInt32Field(value: self.tooLarge, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Timestamp, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Timestamp) -> Bool { - if lhs.timestamp != rhs.timestamp {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tooLarge, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tooLarge) -> Bool { + if lhs.tooLarge != rhs.tooLarge {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.total: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".total" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "total"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.total: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".total" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}total\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35319,18 +39254,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.total: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.total, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.total) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.total, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.total) -> Bool { if lhs.total != rhs.total {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalArrayDepth: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".totalArrayDepth" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "totalArrayDepth"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.totalArrayDepth: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".totalArrayDepth" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}totalArrayDepth\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35351,18 +39284,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalArrayDep try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalArrayDepth, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalArrayDepth) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.totalArrayDepth, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.totalArrayDepth) -> Bool { if lhs.totalArrayDepth != rhs.totalArrayDepth {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".totalSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "totalSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.totalSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".totalSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}totalSize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35383,18 +39314,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalSize: Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalSize, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalSize) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.totalSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.totalSize) -> Bool { if lhs.totalSize != rhs.totalSize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trailingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".trailingComments" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "trailingComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trailingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".trailingComments" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}trailingComments\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35415,18 +39344,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trailingComme try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trailingComments, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trailingComments) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trailingComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trailingComments) -> Bool { if lhs.trailingComments != rhs.trailingComments {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.traverseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".traverse" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "traverse"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.traverseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".traverse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}traverse\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35447,18 +39374,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.traverseMessa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.traverseMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.traverseMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.traverseMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.traverseMessage) -> Bool { if lhs.traverse != rhs.traverse {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trueMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".true" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "true"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trim: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".trim" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}trim\0") + + 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.trim) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.trim != 0 { + try visitor.visitSingularInt32Field(value: self.trim, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trim, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trim) -> Bool { + if lhs.trim != rhs.trim {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trueMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".true" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}true\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35479,18 +39434,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trueMessage: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trueMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trueMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trueMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trueMessage) -> Bool { if lhs.`true` != rhs.`true` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tryMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".try" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "try"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tryMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".try" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}try\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35511,18 +39464,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tryMessage: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tryMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tryMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tryMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tryMessage) -> Bool { if lhs.`try` != rhs.`try` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.type: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".type" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "type"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.type: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".type" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}type\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35543,18 +39494,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.type: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.type, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.type) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.type, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.type) -> Bool { if lhs.type != rhs.type {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typealiasMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".typealias" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typealias"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typealiasMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".typealias" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typealias\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35575,18 +39524,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typealiasMess try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typealiasMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typealiasMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typealiasMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typealiasMessage) -> Bool { if lhs.`typealias` != rhs.`typealias` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TypeEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".TypeEnum" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TypeEnum"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TypeEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".TypeEnum" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}TypeEnum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35607,18 +39554,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TypeEnum: Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TypeEnum, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TypeEnum) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TypeEnum, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TypeEnum) -> Bool { if lhs.typeEnum != rhs.typeEnum {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".typeName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typeName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".typeName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typeName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35639,18 +39584,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeName: Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeName) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeName) -> Bool { if lhs.typeName != rhs.typeName {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typePrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".typePrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typePrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typePrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".typePrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typePrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35671,18 +39614,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typePrefix: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typePrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typePrefix) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typePrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typePrefix) -> Bool { if lhs.typePrefix != rhs.typePrefix {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeStart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".typeStart" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typeStart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeStart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".typeStart" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typeStart\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35703,18 +39644,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeStart: Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeStart, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeStart) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeStart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeStart) -> Bool { if lhs.typeStart != rhs.typeStart {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeUnknown: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".typeUnknown" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typeUnknown"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeUnknown: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".typeUnknown" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typeUnknown\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35735,18 +39674,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeUnknown: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeUnknown, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeUnknown) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeUnknown, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeUnknown) -> Bool { if lhs.typeUnknown != rhs.typeUnknown {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".typeURL" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typeURL"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".typeURL" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typeURL\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35767,18 +39704,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeURL: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeURL, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeURL) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeURL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeURL) -> Bool { if lhs.typeURL != rhs.typeURL {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt32Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UInt32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UInt32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt32Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UInt32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UInt32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35799,50 +39734,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt32Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt32Message, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt32Message) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt32Message, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt32Message) -> Bool { if lhs.uint32 != rhs.uint32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt32Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UInt32Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UInt32Value"), - ] - - 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.uint32Value) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if self.uint32Value != 0 { - try visitor.visitSingularInt32Field(value: self.uint32Value, fieldNumber: 1) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt32Value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt32Value) -> Bool { - if lhs.uint32Value != rhs.uint32Value {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UInt64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt64Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UInt64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UInt64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35863,18 +39764,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Message, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Message) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt64Message, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt64Message) -> Bool { if lhs.uint64 != rhs.uint64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UInt64Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UInt64Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UInt8" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UInt8\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35882,31 +39781,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Value: // 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.uint64Value) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.uint8) }() default: break } } } func traverse(visitor: inout V) throws { - if self.uint64Value != 0 { - try visitor.visitSingularInt32Field(value: self.uint64Value, fieldNumber: 1) + if self.uint8 != 0 { + try visitor.visitSingularInt32Field(value: self.uint8, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Value) -> Bool { - if lhs.uint64Value != rhs.uint64Value {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt8, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt8) -> Bool { + if lhs.uint8 != rhs.uint8 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UInt8" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UInt8"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unchecked: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".unchecked" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unchecked\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35914,31 +39811,59 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt8: SwiftP // 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.uint8) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.unchecked) }() default: break } } } func traverse(visitor: inout V) throws { - if self.uint8 != 0 { - try visitor.visitSingularInt32Field(value: self.uint8, fieldNumber: 1) + if self.unchecked != 0 { + try visitor.visitSingularInt32Field(value: self.unchecked, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt8, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt8) -> Bool { - if lhs.uint8 != rhs.uint8 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unchecked, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unchecked) -> Bool { + if lhs.unchecked != rhs.unchecked {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Unicode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Unicode" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Unicode\0") + + 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.unicode) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.unicode != 0 { + try visitor.visitSingularInt32Field(value: self.unicode, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Unicode, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Unicode) -> Bool { + if lhs.unicode != rhs.unicode {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalarLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".unicodeScalarLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "unicodeScalarLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unicodeScalarLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".unicodeScalarLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unicodeScalarLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35959,18 +39884,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalar try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalarLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalarLiteral) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unicodeScalarLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unicodeScalarLiteral) -> Bool { if lhs.unicodeScalarLiteral != rhs.unicodeScalarLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalarLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UnicodeScalarLiteralType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UnicodeScalarLiteralType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnicodeScalarLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UnicodeScalarLiteralType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UnicodeScalarLiteralType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35991,18 +39914,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalar try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalarLiteralType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalarLiteralType) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnicodeScalarLiteralType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnicodeScalarLiteralType) -> Bool { if lhs.unicodeScalarLiteralType != rhs.unicodeScalarLiteralType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalars: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".unicodeScalars" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "unicodeScalars"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unicodeScalars: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".unicodeScalars" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unicodeScalars\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36023,18 +39944,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalar try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalars, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalars) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unicodeScalars, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unicodeScalars) -> Bool { if lhs.unicodeScalars != rhs.unicodeScalars {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalarView: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UnicodeScalarView" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UnicodeScalarView"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnicodeScalarView: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UnicodeScalarView" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UnicodeScalarView\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36055,18 +39974,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalar try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalarView, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalarView) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnicodeScalarView, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnicodeScalarView) -> Bool { if lhs.unicodeScalarView != rhs.unicodeScalarView {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uninterpretedOption: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".uninterpretedOption" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "uninterpretedOption"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uninterpretedOption: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".uninterpretedOption" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}uninterpretedOption\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36087,18 +40004,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uninterpreted try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uninterpretedOption, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uninterpretedOption) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uninterpretedOption, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uninterpretedOption) -> Bool { if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.union: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".union" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "union"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.union: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".union" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}union\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36119,18 +40034,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.union: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.union, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.union) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.union, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.union) -> Bool { if lhs.union != rhs.union {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uniqueStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".uniqueStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "uniqueStorage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uniqueStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".uniqueStorage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}uniqueStorage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36151,18 +40064,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uniqueStorage try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uniqueStorage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uniqueStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uniqueStorage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uniqueStorage) -> Bool { if lhs.uniqueStorage != rhs.uniqueStorage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknown: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".unknown" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "unknown"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unknown: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".unknown" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unknown\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36183,18 +40094,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknown: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknown, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknown) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unknown, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unknown) -> Bool { if lhs.unknown != rhs.unknown {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknownFieldsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".unknownFields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "unknownFields"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unknownFieldsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".unknownFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unknownFields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36215,18 +40124,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknownFields try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknownFieldsMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknownFieldsMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unknownFieldsMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unknownFieldsMessage) -> Bool { if lhs.unknownFields_p != rhs.unknownFields_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnknownStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UnknownStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UnknownStorage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnknownStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UnknownStorage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UnknownStorage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36247,18 +40154,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnknownStorag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnknownStorage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnknownStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnknownStorage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnknownStorage) -> Bool { if lhs.unknownStorage != rhs.unknownStorage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unpackTo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".unpackTo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "unpackTo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unpackTo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".unpackTo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unpackTo\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36279,18 +40184,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unpackTo: Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unpackTo, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unpackTo) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unpackTo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unpackTo) -> Bool { if lhs.unpackTo != rhs.unpackTo {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeBufferPointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeBufferPointer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UnsafeBufferPointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeBufferPointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeBufferPointer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UnsafeBufferPointer\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36311,18 +40214,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeBufferP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeBufferPointer, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeBufferPointer) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeBufferPointer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeBufferPointer) -> Bool { if lhs.unsafeBufferPointer != rhs.unsafeBufferPointer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutablePointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeMutablePointer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UnsafeMutablePointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeMutablePointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeMutablePointer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UnsafeMutablePointer\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36343,18 +40244,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutable try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutablePointer, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutablePointer) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeMutablePointer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeMutablePointer) -> Bool { if lhs.unsafeMutablePointer != rhs.unsafeMutablePointer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutableRawBufferPointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeMutableRawBufferPointer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UnsafeMutableRawBufferPointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeMutableRawBufferPointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeMutableRawBufferPointer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UnsafeMutableRawBufferPointer\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36375,18 +40274,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutable try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutableRawBufferPointer, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutableRawBufferPointer) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeMutableRawBufferPointer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeMutableRawBufferPointer) -> Bool { if lhs.unsafeMutableRawBufferPointer != rhs.unsafeMutableRawBufferPointer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutableRawPointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeMutableRawPointer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UnsafeMutableRawPointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeRawBufferPointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeRawBufferPointer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UnsafeRawBufferPointer\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36394,31 +40291,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutable // 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.unsafeMutableRawPointer) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.unsafeRawBufferPointer) }() default: break } } } func traverse(visitor: inout V) throws { - if self.unsafeMutableRawPointer != 0 { - try visitor.visitSingularInt32Field(value: self.unsafeMutableRawPointer, fieldNumber: 1) + if self.unsafeRawBufferPointer != 0 { + try visitor.visitSingularInt32Field(value: self.unsafeRawBufferPointer, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutableRawPointer, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutableRawPointer) -> Bool { - if lhs.unsafeMutableRawPointer != rhs.unsafeMutableRawPointer {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeRawBufferPointer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeRawBufferPointer) -> Bool { + if lhs.unsafeRawBufferPointer != rhs.unsafeRawBufferPointer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawBufferPointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeRawBufferPointer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UnsafeRawBufferPointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeRawPointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeRawPointer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UnsafeRawPointer\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36426,31 +40321,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawBuff // 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.unsafeRawBufferPointer) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.unsafeRawPointer) }() default: break } } } func traverse(visitor: inout V) throws { - if self.unsafeRawBufferPointer != 0 { - try visitor.visitSingularInt32Field(value: self.unsafeRawBufferPointer, fieldNumber: 1) + if self.unsafeRawPointer != 0 { + try visitor.visitSingularInt32Field(value: self.unsafeRawPointer, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawBufferPointer, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawBufferPointer) -> Bool { - if lhs.unsafeRawBufferPointer != rhs.unsafeRawBufferPointer {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeRawPointer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeRawPointer) -> Bool { + if lhs.unsafeRawPointer != rhs.unsafeRawPointer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawPointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeRawPointer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UnsafeRawPointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unverifiedLazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".unverifiedLazy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unverifiedLazy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36458,31 +40351,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawPoin // 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.unsafeRawPointer) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.unverifiedLazy) }() default: break } } } func traverse(visitor: inout V) throws { - if self.unsafeRawPointer != 0 { - try visitor.visitSingularInt32Field(value: self.unsafeRawPointer, fieldNumber: 1) + if self.unverifiedLazy != 0 { + try visitor.visitSingularInt32Field(value: self.unverifiedLazy, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawPointer, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawPointer) -> Bool { - if lhs.unsafeRawPointer != rhs.unsafeRawPointer {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unverifiedLazy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unverifiedLazy) -> Bool { + if lhs.unverifiedLazy != rhs.unverifiedLazy {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.updatedOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".updatedOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "updatedOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.updatedOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".updatedOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}updatedOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36503,18 +40394,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.updatedOption try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.updatedOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.updatedOptions) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.updatedOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.updatedOptions) -> Bool { if lhs.updatedOptions != rhs.updatedOptions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.url: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".url" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "url"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uppercasedAssumingASCII: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".uppercasedAssumingASCII" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}uppercasedAssumingASCII\0") + + 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.uppercasedAssumingAscii) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.uppercasedAssumingAscii != 0 { + try visitor.visitSingularInt32Field(value: self.uppercasedAssumingAscii, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uppercasedAssumingASCII, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uppercasedAssumingASCII) -> Bool { + if lhs.uppercasedAssumingAscii != rhs.uppercasedAssumingAscii {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.url: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".url" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}url\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36535,18 +40454,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.url: SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.url, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.url) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.url, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.url) -> Bool { if lhs.url != rhs.url {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".utf8" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "utf8"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.useDeterministicOrdering: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".useDeterministicOrdering" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}useDeterministicOrdering\0") + + 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.useDeterministicOrdering) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.useDeterministicOrdering != 0 { + try visitor.visitSingularInt32Field(value: self.useDeterministicOrdering, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.useDeterministicOrdering, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.useDeterministicOrdering) -> Bool { + if lhs.useDeterministicOrdering != rhs.useDeterministicOrdering {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".utf8" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}utf8\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36567,18 +40514,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8) -> Bool { if lhs.utf8 != rhs.utf8 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8Ptr: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".utf8Ptr" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "utf8Ptr"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8Ptr: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".utf8Ptr" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}utf8Ptr\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36599,18 +40544,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8Ptr: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8Ptr, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8Ptr) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8Ptr, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8Ptr) -> Bool { if lhs.utf8Ptr != rhs.utf8Ptr {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8ToDouble: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".utf8ToDouble" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "utf8ToDouble"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8ToDouble: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".utf8ToDouble" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}utf8ToDouble\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36631,18 +40574,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8ToDouble: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8ToDouble, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8ToDouble) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8ToDouble, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8ToDouble) -> Bool { if lhs.utf8ToDouble != rhs.utf8ToDouble {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UTF8View: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UTF8View" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UTF8View"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8Validation: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".utf8Validation" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}utf8Validation\0") + + 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.utf8Validation) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.utf8Validation != 0 { + try visitor.visitSingularInt32Field(value: self.utf8Validation, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8Validation, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8Validation) -> Bool { + if lhs.utf8Validation != rhs.utf8Validation {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UTF8View: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UTF8View" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UTF8View\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36663,18 +40634,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UTF8View: Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UTF8View, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UTF8View) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UTF8View, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UTF8View) -> Bool { if lhs.utf8View != rhs.utf8View {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.v: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".v" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "v"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.V: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".V" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}V\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36695,18 +40664,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.v: SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.v, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.v) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.V, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.V) -> Bool { if lhs.v != rhs.v {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".value" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36727,18 +40694,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.value: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.value) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.value) -> Bool { if lhs.value != rhs.value {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.valueField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".valueField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "valueField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.valueField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".valueField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}valueField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36759,18 +40724,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.valueField: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.valueField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.valueField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.valueField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.valueField) -> Bool { if lhs.valueField != rhs.valueField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.values: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".values" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "values"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.values: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".values" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}values\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36791,18 +40754,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.values: Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.values, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.values) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.values, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.values) -> Bool { if lhs.values != rhs.values {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ValueType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ValueType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ValueType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ValueType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ValueType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ValueType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36823,18 +40784,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ValueType: Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ValueType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ValueType) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ValueType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ValueType) -> Bool { if lhs.valueType != rhs.valueType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.varMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".var" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "var"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.varMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".var" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}var\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36855,18 +40814,76 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.varMessage: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.varMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.varMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.varMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.varMessage) -> Bool { if lhs.`var` != rhs.`var` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Version: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Version" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Version"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.verification: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".verification" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}verification\0") + + 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.verification) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.verification != 0 { + try visitor.visitSingularInt32Field(value: self.verification, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.verification, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.verification) -> Bool { + if lhs.verification != rhs.verification {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.VerificationState: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".VerificationState" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}VerificationState\0") + + 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.verificationState) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.verificationState != 0 { + try visitor.visitSingularInt32Field(value: self.verificationState, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.VerificationState, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.VerificationState) -> Bool { + if lhs.verificationState != rhs.verificationState {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.version: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".version" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}version\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36887,18 +40904,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Version: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Version, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Version) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.version, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.version) -> Bool { if lhs.version != rhs.version {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.versionString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".versionString" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "versionString"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.versionString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".versionString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}versionString\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36919,18 +40934,76 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.versionString try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.versionString, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.versionString) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.versionString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.versionString) -> Bool { if lhs.versionString != rhs.versionString {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensionFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitExtensionFields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitExtensionFields"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visibility: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visibility" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visibility\0") + + 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.visibility) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.visibility != 0 { + try visitor.visitSingularInt32Field(value: self.visibility, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visibility, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visibility) -> Bool { + if lhs.visibility != rhs.visibility {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.VisibilityFeature: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".VisibilityFeature" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}VisibilityFeature\0") + + 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.visibilityFeature) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.visibilityFeature != 0 { + try visitor.visitSingularInt32Field(value: self.visibilityFeature, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.VisibilityFeature, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.VisibilityFeature) -> Bool { + if lhs.visibilityFeature != rhs.visibilityFeature {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitExtensionFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitExtensionFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitExtensionFields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36951,18 +41024,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensio try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensionFields, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensionFields) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitExtensionFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitExtensionFields) -> Bool { if lhs.visitExtensionFields != rhs.visitExtensionFields {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensionFieldsAsMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitExtensionFieldsAsMessageSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitExtensionFieldsAsMessageSet"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitExtensionFieldsAsMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitExtensionFieldsAsMessageSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitExtensionFieldsAsMessageSet\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36983,18 +41054,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensio try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensionFieldsAsMessageSet, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensionFieldsAsMessageSet) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitExtensionFieldsAsMessageSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitExtensionFieldsAsMessageSet) -> Bool { if lhs.visitExtensionFieldsAsMessageSet != rhs.visitExtensionFieldsAsMessageSet {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitMapField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitMapField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitMapField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitMapField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitMapField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitMapField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37015,18 +41084,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitMapField try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitMapField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitMapField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitMapField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitMapField) -> Bool { if lhs.visitMapField != rhs.visitMapField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Visitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Visitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Visitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37047,18 +41114,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitor: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Visitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Visitor) -> Bool { if lhs.visitor != rhs.visitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPacked: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPacked" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPacked"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPacked" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPacked\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37079,18 +41144,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPacked: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPacked, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPacked) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked) -> Bool { if lhs.visitPacked != rhs.visitPacked {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedBoolField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedBoolField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedBoolField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedBoolField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37111,18 +41174,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedBo try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedBoolField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedBoolField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedBoolField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedBoolField) -> Bool { if lhs.visitPackedBoolField != rhs.visitPackedBoolField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedDoubleField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedDoubleField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedDoubleField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedDoubleField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37143,18 +41204,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedDo try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedDoubleField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedDoubleField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedDoubleField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedDoubleField) -> Bool { if lhs.visitPackedDoubleField != rhs.visitPackedDoubleField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedEnumField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedEnumField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedEnumField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedEnumField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37175,18 +41234,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedEn try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedEnumField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedEnumField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedEnumField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedEnumField) -> Bool { if lhs.visitPackedEnumField != rhs.visitPackedEnumField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37207,18 +41264,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFixed32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFixed32Field) -> Bool { if lhs.visitPackedFixed32Field != rhs.visitPackedFixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37239,18 +41294,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFixed64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFixed64Field) -> Bool { if lhs.visitPackedFixed64Field != rhs.visitPackedFixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedFloatField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedFloatField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedFloatField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedFloatField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37271,18 +41324,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFl try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFloatField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFloatField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFloatField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFloatField) -> Bool { if lhs.visitPackedFloatField != rhs.visitPackedFloatField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37303,18 +41354,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedIn try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedInt32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedInt32Field) -> Bool { if lhs.visitPackedInt32Field != rhs.visitPackedInt32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37335,18 +41384,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedIn try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedInt64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedInt64Field) -> Bool { if lhs.visitPackedInt64Field != rhs.visitPackedInt64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedSFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedSFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedSFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedSFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37367,18 +41414,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSF try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSFixed32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSFixed32Field) -> Bool { if lhs.visitPackedSfixed32Field != rhs.visitPackedSfixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedSFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedSFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedSFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedSFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37399,18 +41444,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSF try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSFixed64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSFixed64Field) -> Bool { if lhs.visitPackedSfixed64Field != rhs.visitPackedSfixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedSInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedSInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedSInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedSInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37431,18 +41474,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSI try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSInt32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSInt32Field) -> Bool { if lhs.visitPackedSint32Field != rhs.visitPackedSint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedSInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedSInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedSInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedSInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37463,18 +41504,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSI try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSInt64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSInt64Field) -> Bool { if lhs.visitPackedSint64Field != rhs.visitPackedSint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedUInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedUInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedUInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedUInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37495,18 +41534,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUI try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUInt32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedUInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedUInt32Field) -> Bool { if lhs.visitPackedUint32Field != rhs.visitPackedUint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedUInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedUInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedUInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedUInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37527,18 +41564,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUI try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUInt64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedUInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedUInt64Field) -> Bool { if lhs.visitPackedUint64Field != rhs.visitPackedUint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeated" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeated"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeated\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37559,18 +41594,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeated) -> Bool { if lhs.visitRepeated != rhs.visitRepeated {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedBoolField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedBoolField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedBoolField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedBoolField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37591,18 +41624,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedBoolField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedBoolField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedBoolField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedBoolField) -> Bool { if lhs.visitRepeatedBoolField != rhs.visitRepeatedBoolField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedBytesField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedBytesField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedBytesField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedBytesField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedBytesField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedBytesField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37623,18 +41654,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedBytesField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedBytesField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedBytesField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedBytesField) -> Bool { if lhs.visitRepeatedBytesField != rhs.visitRepeatedBytesField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedDoubleField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedDoubleField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedDoubleField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedDoubleField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37655,18 +41684,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedDoubleField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedDoubleField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedDoubleField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedDoubleField) -> Bool { if lhs.visitRepeatedDoubleField != rhs.visitRepeatedDoubleField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedEnumField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedEnumField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedEnumField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedEnumField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37687,18 +41714,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedEnumField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedEnumField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedEnumField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedEnumField) -> Bool { if lhs.visitRepeatedEnumField != rhs.visitRepeatedEnumField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37719,18 +41744,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFixed32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFixed32Field) -> Bool { if lhs.visitRepeatedFixed32Field != rhs.visitRepeatedFixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37751,18 +41774,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFixed64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFixed64Field) -> Bool { if lhs.visitRepeatedFixed64Field != rhs.visitRepeatedFixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedFloatField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedFloatField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedFloatField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedFloatField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37783,18 +41804,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFloatField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFloatField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFloatField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFloatField) -> Bool { if lhs.visitRepeatedFloatField != rhs.visitRepeatedFloatField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedGroupField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedGroupField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedGroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedGroupField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37815,18 +41834,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedGroupField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedGroupField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedGroupField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedGroupField) -> Bool { if lhs.visitRepeatedGroupField != rhs.visitRepeatedGroupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37847,18 +41864,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedInt32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedInt32Field) -> Bool { if lhs.visitRepeatedInt32Field != rhs.visitRepeatedInt32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37879,18 +41894,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedInt64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedInt64Field) -> Bool { if lhs.visitRepeatedInt64Field != rhs.visitRepeatedInt64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedMessageField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedMessageField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedMessageField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedMessageField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37911,18 +41924,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedMessageField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedMessageField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedMessageField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedMessageField) -> Bool { if lhs.visitRepeatedMessageField != rhs.visitRepeatedMessageField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedSFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedSFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedSFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedSFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37943,18 +41954,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSFixed32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSFixed32Field) -> Bool { if lhs.visitRepeatedSfixed32Field != rhs.visitRepeatedSfixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedSFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedSFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedSFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedSFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37975,18 +41984,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSFixed64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSFixed64Field) -> Bool { if lhs.visitRepeatedSfixed64Field != rhs.visitRepeatedSfixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedSInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedSInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedSInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedSInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38007,18 +42014,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSInt32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSInt32Field) -> Bool { if lhs.visitRepeatedSint32Field != rhs.visitRepeatedSint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedSInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedSInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedSInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedSInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38039,18 +42044,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSInt64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSInt64Field) -> Bool { if lhs.visitRepeatedSint64Field != rhs.visitRepeatedSint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedStringField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedStringField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedStringField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedStringField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedStringField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedStringField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38071,18 +42074,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedStringField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedStringField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedStringField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedStringField) -> Bool { if lhs.visitRepeatedStringField != rhs.visitRepeatedStringField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedUInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedUInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedUInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedUInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38103,18 +42104,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedUInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedUInt32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedUInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedUInt32Field) -> Bool { if lhs.visitRepeatedUint32Field != rhs.visitRepeatedUint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedUInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedUInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedUInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedUInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38135,18 +42134,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedUInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedUInt64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedUInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedUInt64Field) -> Bool { if lhs.visitRepeatedUint64Field != rhs.visitRepeatedUint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingular" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingular"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingular: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingular" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingular\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38167,18 +42164,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingular, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingular) -> Bool { if lhs.visitSingular != rhs.visitSingular {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularBoolField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularBoolField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularBoolField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularBoolField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38199,18 +42194,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularBoolField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularBoolField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularBoolField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularBoolField) -> Bool { if lhs.visitSingularBoolField != rhs.visitSingularBoolField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularBytesField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularBytesField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularBytesField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularBytesField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularBytesField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularBytesField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38231,18 +42224,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularBytesField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularBytesField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularBytesField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularBytesField) -> Bool { if lhs.visitSingularBytesField != rhs.visitSingularBytesField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularDoubleField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularDoubleField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularDoubleField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularDoubleField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38263,18 +42254,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularDoubleField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularDoubleField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularDoubleField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularDoubleField) -> Bool { if lhs.visitSingularDoubleField != rhs.visitSingularDoubleField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularEnumField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularEnumField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularEnumField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularEnumField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38295,18 +42284,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularEnumField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularEnumField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularEnumField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularEnumField) -> Bool { if lhs.visitSingularEnumField != rhs.visitSingularEnumField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38327,18 +42314,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFixed32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFixed32Field) -> Bool { if lhs.visitSingularFixed32Field != rhs.visitSingularFixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38359,18 +42344,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFixed64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFixed64Field) -> Bool { if lhs.visitSingularFixed64Field != rhs.visitSingularFixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularFloatField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularFloatField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularFloatField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularFloatField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38391,18 +42374,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFloatField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFloatField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFloatField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFloatField) -> Bool { if lhs.visitSingularFloatField != rhs.visitSingularFloatField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularGroupField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularGroupField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularGroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularGroupField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38423,18 +42404,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularGroupField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularGroupField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularGroupField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularGroupField) -> Bool { if lhs.visitSingularGroupField != rhs.visitSingularGroupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38455,18 +42434,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularInt32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularInt32Field) -> Bool { if lhs.visitSingularInt32Field != rhs.visitSingularInt32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38487,18 +42464,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularInt64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularInt64Field) -> Bool { if lhs.visitSingularInt64Field != rhs.visitSingularInt64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularMessageField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularMessageField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularMessageField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularMessageField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38519,18 +42494,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularMessageField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularMessageField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularMessageField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularMessageField) -> Bool { if lhs.visitSingularMessageField != rhs.visitSingularMessageField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularSFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularSFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularSFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularSFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38551,18 +42524,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSFixed32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSFixed32Field) -> Bool { if lhs.visitSingularSfixed32Field != rhs.visitSingularSfixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularSFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularSFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularSFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularSFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38583,18 +42554,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSFixed64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSFixed64Field) -> Bool { if lhs.visitSingularSfixed64Field != rhs.visitSingularSfixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularSInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularSInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularSInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularSInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38615,18 +42584,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSInt32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSInt32Field) -> Bool { if lhs.visitSingularSint32Field != rhs.visitSingularSint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularSInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularSInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularSInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularSInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38647,18 +42614,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSInt64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSInt64Field) -> Bool { if lhs.visitSingularSint64Field != rhs.visitSingularSint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularStringField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularStringField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularStringField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularStringField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularStringField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularStringField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38679,18 +42644,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularStringField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularStringField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularStringField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularStringField) -> Bool { if lhs.visitSingularStringField != rhs.visitSingularStringField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularUInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularUInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularUInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularUInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38711,18 +42674,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularUInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularUInt32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularUInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularUInt32Field) -> Bool { if lhs.visitSingularUint32Field != rhs.visitSingularUint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularUInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularUInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularUInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularUInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38743,18 +42704,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularUInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularUInt64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularUInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularUInt64Field) -> Bool { if lhs.visitSingularUint64Field != rhs.visitSingularUint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitUnknown: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitUnknown" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitUnknown"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitUnknown: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitUnknown" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitUnknown\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38775,18 +42734,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitUnknown: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitUnknown, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitUnknown) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitUnknown, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitUnknown) -> Bool { if lhs.visitUnknown != rhs.visitUnknown {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wasDecoded: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".wasDecoded" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "wasDecoded"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Void: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Void" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Void\0") + + 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.void) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.void != 0 { + try visitor.visitSingularInt32Field(value: self.void, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Void, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Void) -> Bool { + if lhs.void != rhs.void {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wasDecoded: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".wasDecoded" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}wasDecoded\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38807,18 +42794,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wasDecoded: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wasDecoded, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wasDecoded) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wasDecoded, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wasDecoded) -> Bool { if lhs.wasDecoded != rhs.wasDecoded {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weak: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".weak" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "weak"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.weak: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".weak" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}weak\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38839,18 +42824,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weak: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weak, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weak) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.weak, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.weak) -> Bool { if lhs.weak != rhs.weak {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weakDependency: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".weakDependency" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "weakDependency"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.weakDependency: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".weakDependency" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}weakDependency\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38871,18 +42854,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weakDependenc try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weakDependency, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weakDependency) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.weakDependency, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.weakDependency) -> Bool { if lhs.weakDependency != rhs.weakDependency {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.whereMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".where" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "where"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.whereMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".where" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}where\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38903,18 +42884,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.whereMessage: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.whereMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.whereMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.whereMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.whereMessage) -> Bool { if lhs.`where` != rhs.`where` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wireFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".wireFormat" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "wireFormat"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wireFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".wireFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}wireFormat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38935,18 +42914,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wireFormat: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wireFormat, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wireFormat) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wireFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wireFormat) -> Bool { if lhs.wireFormat != rhs.wireFormat {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.with: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".with" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "with"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.with: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".with" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}with\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38967,18 +42944,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.with: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.with, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.with) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.with, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.with) -> Bool { if lhs.with != rhs.with {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".withUnsafeBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "withUnsafeBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.withUnsafeBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".withUnsafeBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}withUnsafeBytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38999,18 +42974,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeByt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeBytes, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeBytes) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.withUnsafeBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.withUnsafeBytes) -> Bool { if lhs.withUnsafeBytes != rhs.withUnsafeBytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeMutableBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".withUnsafeMutableBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "withUnsafeMutableBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.withUnsafeMutableBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".withUnsafeMutableBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}withUnsafeMutableBytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -39031,18 +43004,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeMut try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeMutableBytes, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeMutableBytes) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.withUnsafeMutableBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.withUnsafeMutableBytes) -> Bool { if lhs.withUnsafeMutableBytes != rhs.withUnsafeMutableBytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.work: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".work" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "work"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.work: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".work" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}work\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -39063,18 +43034,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.work: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.work, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.work) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.work, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.work) -> Bool { if lhs.work != rhs.work {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.WrappedType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".WrappedType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "WrappedType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Wrapped: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Wrapped" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Wrapped\0") + + 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.wrapped) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.wrapped != 0 { + try visitor.visitSingularInt32Field(value: self.wrapped, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Wrapped, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Wrapped) -> Bool { + if lhs.wrapped != rhs.wrapped {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.WrappedType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".WrappedType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}WrappedType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -39095,18 +43094,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.WrappedType: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.WrappedType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.WrappedType) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.WrappedType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.WrappedType) -> Bool { if lhs.wrappedType != rhs.wrappedType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.written: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".written" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "written"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wrappedValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".wrappedValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}wrappedValue\0") + + 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.wrappedValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.wrappedValue != 0 { + try visitor.visitSingularInt32Field(value: self.wrappedValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wrappedValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wrappedValue) -> Bool { + if lhs.wrappedValue != rhs.wrappedValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.written: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".written" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}written\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -39127,18 +43154,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.written: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.written, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.written) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.written, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.written) -> Bool { if lhs.written != rhs.written {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.yday: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".yday" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "yday"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.yday: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".yday" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}yday\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -39159,7 +43184,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.yday: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.yday, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.yday) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.yday, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.yday) -> Bool { if lhs.yday != rhs.yday {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Reference/Tests/SwiftProtobufTests/map_proto2_unittest.pb.swift b/Reference/Tests/SwiftProtobufTests/map_proto2_unittest.pb.swift new file mode 100644 index 000000000..dd462caed --- /dev/null +++ b/Reference/Tests/SwiftProtobufTests/map_proto2_unittest.pb.swift @@ -0,0 +1,354 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: map_proto2_unittest.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +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 SwiftProtoTesting_Proto2MapEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 + + init() { + self = .foo + } + +} + +enum SwiftProtoTesting_Proto2MapEnumPlusExtra: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case eProto2MapEnumFoo = 0 + case eProto2MapEnumBar = 1 + case eProto2MapEnumBaz = 2 + case eProto2MapEnumExtra = 3 + + init() { + self = .eProto2MapEnumFoo + } + +} + +struct SwiftProtoTesting_TestEnumMap: Sendable { + // 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 knownMapField: Dictionary = [:] + + var unknownMapField: Dictionary = [:] + + /// Other maps with all key types to test the unknown entry serialization + var unknownMapFieldInt64: Dictionary = [:] + + var unknownMapFieldUint64: Dictionary = [:] + + var unknownMapFieldInt32: Dictionary = [:] + + var unknownMapFieldUint32: Dictionary = [:] + + var unknownMapFieldFixed32: Dictionary = [:] + + var unknownMapFieldFixed64: Dictionary = [:] + + var unknownMapFieldBool: Dictionary = [:] + + var unknownMapFieldString: Dictionary = [:] + + var unknownMapFieldSint32: Dictionary = [:] + + var unknownMapFieldSint64: Dictionary = [:] + + var unknownMapFieldSfixed32: Dictionary = [:] + + var unknownMapFieldSfixed64: Dictionary = [:] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct SwiftProtoTesting_TestEnumMapPlusExtra: Sendable { + // 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 knownMapField: Dictionary = [:] + + var unknownMapField: Dictionary = [:] + + /// Other maps with all key types to test the unknown entry serialization + var unknownMapFieldInt64: Dictionary = [:] + + var unknownMapFieldUint64: Dictionary = [:] + + var unknownMapFieldInt32: Dictionary = [:] + + var unknownMapFieldUint32: Dictionary = [:] + + var unknownMapFieldFixed32: Dictionary = [:] + + var unknownMapFieldFixed64: Dictionary = [:] + + var unknownMapFieldBool: Dictionary = [:] + + var unknownMapFieldString: Dictionary = [:] + + var unknownMapFieldSint32: Dictionary = [:] + + var unknownMapFieldSint64: Dictionary = [:] + + var unknownMapFieldSfixed32: Dictionary = [:] + + var unknownMapFieldSfixed64: Dictionary = [:] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_proto_testing" + +extension SwiftProtoTesting_Proto2MapEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0PROTO2_MAP_ENUM_FOO\0\u{1}PROTO2_MAP_ENUM_BAR\0\u{1}PROTO2_MAP_ENUM_BAZ\0") +} + +extension SwiftProtoTesting_Proto2MapEnumPlusExtra: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0E_PROTO2_MAP_ENUM_FOO\0\u{1}E_PROTO2_MAP_ENUM_BAR\0\u{1}E_PROTO2_MAP_ENUM_BAZ\0\u{1}E_PROTO2_MAP_ENUM_EXTRA\0") +} + +extension SwiftProtoTesting_TestEnumMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEnumMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}e\u{1}known_map_field\0\u{3}unknown_map_field\0\u{4}b\u{1}unknown_map_field_int64\0\u{3}unknown_map_field_uint64\0\u{3}unknown_map_field_int32\0\u{3}unknown_map_field_uint32\0\u{3}unknown_map_field_fixed32\0\u{3}unknown_map_field_fixed64\0\u{3}unknown_map_field_bool\0\u{3}unknown_map_field_string\0\u{3}unknown_map_field_sint32\0\u{3}unknown_map_field_sint64\0\u{3}unknown_map_field_sfixed32\0\u{3}unknown_map_field_sfixed64\0") + + 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 101: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.knownMapField) }() + case 102: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapField) }() + case 200: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldInt64) }() + case 201: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldUint64) }() + case 202: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldInt32) }() + case 203: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldUint32) }() + case 204: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldFixed32) }() + case 205: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldFixed64) }() + case 206: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldBool) }() + case 207: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldString) }() + case 208: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSint32) }() + case 209: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSint64) }() + case 210: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSfixed32) }() + case 211: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSfixed64) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.knownMapField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.knownMapField, fieldNumber: 101) + } + if !self.unknownMapField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapField, fieldNumber: 102) + } + if !self.unknownMapFieldInt64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldInt64, fieldNumber: 200) + } + if !self.unknownMapFieldUint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldUint64, fieldNumber: 201) + } + if !self.unknownMapFieldInt32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldInt32, fieldNumber: 202) + } + if !self.unknownMapFieldUint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldUint32, fieldNumber: 203) + } + if !self.unknownMapFieldFixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldFixed32, fieldNumber: 204) + } + if !self.unknownMapFieldFixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldFixed64, fieldNumber: 205) + } + if !self.unknownMapFieldBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldBool, fieldNumber: 206) + } + if !self.unknownMapFieldString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldString, fieldNumber: 207) + } + if !self.unknownMapFieldSint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSint32, fieldNumber: 208) + } + if !self.unknownMapFieldSint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSint64, fieldNumber: 209) + } + if !self.unknownMapFieldSfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSfixed32, fieldNumber: 210) + } + if !self.unknownMapFieldSfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSfixed64, fieldNumber: 211) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestEnumMap, rhs: SwiftProtoTesting_TestEnumMap) -> Bool { + if lhs.knownMapField != rhs.knownMapField {return false} + if lhs.unknownMapField != rhs.unknownMapField {return false} + if lhs.unknownMapFieldInt64 != rhs.unknownMapFieldInt64 {return false} + if lhs.unknownMapFieldUint64 != rhs.unknownMapFieldUint64 {return false} + if lhs.unknownMapFieldInt32 != rhs.unknownMapFieldInt32 {return false} + if lhs.unknownMapFieldUint32 != rhs.unknownMapFieldUint32 {return false} + if lhs.unknownMapFieldFixed32 != rhs.unknownMapFieldFixed32 {return false} + if lhs.unknownMapFieldFixed64 != rhs.unknownMapFieldFixed64 {return false} + if lhs.unknownMapFieldBool != rhs.unknownMapFieldBool {return false} + if lhs.unknownMapFieldString != rhs.unknownMapFieldString {return false} + if lhs.unknownMapFieldSint32 != rhs.unknownMapFieldSint32 {return false} + if lhs.unknownMapFieldSint64 != rhs.unknownMapFieldSint64 {return false} + if lhs.unknownMapFieldSfixed32 != rhs.unknownMapFieldSfixed32 {return false} + if lhs.unknownMapFieldSfixed64 != rhs.unknownMapFieldSfixed64 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestEnumMapPlusExtra: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEnumMapPlusExtra" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}e\u{1}known_map_field\0\u{3}unknown_map_field\0\u{4}b\u{1}unknown_map_field_int64\0\u{3}unknown_map_field_uint64\0\u{3}unknown_map_field_int32\0\u{3}unknown_map_field_uint32\0\u{3}unknown_map_field_fixed32\0\u{3}unknown_map_field_fixed64\0\u{3}unknown_map_field_bool\0\u{3}unknown_map_field_string\0\u{3}unknown_map_field_sint32\0\u{3}unknown_map_field_sint64\0\u{3}unknown_map_field_sfixed32\0\u{3}unknown_map_field_sfixed64\0") + + 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 101: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.knownMapField) }() + case 102: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapField) }() + case 200: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldInt64) }() + case 201: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldUint64) }() + case 202: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldInt32) }() + case 203: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldUint32) }() + case 204: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldFixed32) }() + case 205: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldFixed64) }() + case 206: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldBool) }() + case 207: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldString) }() + case 208: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSint32) }() + case 209: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSint64) }() + case 210: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSfixed32) }() + case 211: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSfixed64) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.knownMapField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.knownMapField, fieldNumber: 101) + } + if !self.unknownMapField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapField, fieldNumber: 102) + } + if !self.unknownMapFieldInt64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldInt64, fieldNumber: 200) + } + if !self.unknownMapFieldUint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldUint64, fieldNumber: 201) + } + if !self.unknownMapFieldInt32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldInt32, fieldNumber: 202) + } + if !self.unknownMapFieldUint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldUint32, fieldNumber: 203) + } + if !self.unknownMapFieldFixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldFixed32, fieldNumber: 204) + } + if !self.unknownMapFieldFixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldFixed64, fieldNumber: 205) + } + if !self.unknownMapFieldBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldBool, fieldNumber: 206) + } + if !self.unknownMapFieldString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldString, fieldNumber: 207) + } + if !self.unknownMapFieldSint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSint32, fieldNumber: 208) + } + if !self.unknownMapFieldSint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSint64, fieldNumber: 209) + } + if !self.unknownMapFieldSfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSfixed32, fieldNumber: 210) + } + if !self.unknownMapFieldSfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSfixed64, fieldNumber: 211) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestEnumMapPlusExtra, rhs: SwiftProtoTesting_TestEnumMapPlusExtra) -> Bool { + if lhs.knownMapField != rhs.knownMapField {return false} + if lhs.unknownMapField != rhs.unknownMapField {return false} + if lhs.unknownMapFieldInt64 != rhs.unknownMapFieldInt64 {return false} + if lhs.unknownMapFieldUint64 != rhs.unknownMapFieldUint64 {return false} + if lhs.unknownMapFieldInt32 != rhs.unknownMapFieldInt32 {return false} + if lhs.unknownMapFieldUint32 != rhs.unknownMapFieldUint32 {return false} + if lhs.unknownMapFieldFixed32 != rhs.unknownMapFieldFixed32 {return false} + if lhs.unknownMapFieldFixed64 != rhs.unknownMapFieldFixed64 {return false} + if lhs.unknownMapFieldBool != rhs.unknownMapFieldBool {return false} + if lhs.unknownMapFieldString != rhs.unknownMapFieldString {return false} + if lhs.unknownMapFieldSint32 != rhs.unknownMapFieldSint32 {return false} + if lhs.unknownMapFieldSint64 != rhs.unknownMapFieldSint64 {return false} + if lhs.unknownMapFieldSfixed32 != rhs.unknownMapFieldSfixed32 {return false} + if lhs.unknownMapFieldSfixed64 != rhs.unknownMapFieldSfixed64 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/Tests/SwiftProtobufTests/map_unittest.pb.swift b/Reference/Tests/SwiftProtobufTests/map_unittest.pb.swift new file mode 100644 index 000000000..5e8d3423b --- /dev/null +++ b/Reference/Tests/SwiftProtobufTests/map_unittest.pb.swift @@ -0,0 +1,488 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: map_unittest.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +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 SwiftProtoTesting_MapEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foo // = 0 + case bar // = 1 + case baz // = 2 + case UNRECOGNIZED(Int) + + init() { + self = .foo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .foo + case 1: self = .bar + case 2: self = .baz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .foo: return 0 + case .bar: return 1 + case .baz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_MapEnum] = [ + .foo, + .bar, + .baz, + ] + +} + +/// Tests maps. +struct SwiftProtoTesting_TestMap: @unchecked Sendable { + // 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 mapInt32Int32: Dictionary { + get {_storage._mapInt32Int32} + set {_uniqueStorage()._mapInt32Int32 = newValue} + } + + var mapInt64Int64: Dictionary { + get {_storage._mapInt64Int64} + set {_uniqueStorage()._mapInt64Int64 = newValue} + } + + var mapUint32Uint32: Dictionary { + get {_storage._mapUint32Uint32} + set {_uniqueStorage()._mapUint32Uint32 = newValue} + } + + var mapUint64Uint64: Dictionary { + get {_storage._mapUint64Uint64} + set {_uniqueStorage()._mapUint64Uint64 = newValue} + } + + var mapSint32Sint32: Dictionary { + get {_storage._mapSint32Sint32} + set {_uniqueStorage()._mapSint32Sint32 = newValue} + } + + var mapSint64Sint64: Dictionary { + get {_storage._mapSint64Sint64} + set {_uniqueStorage()._mapSint64Sint64 = newValue} + } + + var mapFixed32Fixed32: Dictionary { + get {_storage._mapFixed32Fixed32} + set {_uniqueStorage()._mapFixed32Fixed32 = newValue} + } + + var mapFixed64Fixed64: Dictionary { + get {_storage._mapFixed64Fixed64} + set {_uniqueStorage()._mapFixed64Fixed64 = newValue} + } + + var mapSfixed32Sfixed32: Dictionary { + get {_storage._mapSfixed32Sfixed32} + set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} + } + + var mapSfixed64Sfixed64: Dictionary { + get {_storage._mapSfixed64Sfixed64} + set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} + } + + var mapInt32Float: Dictionary { + get {_storage._mapInt32Float} + set {_uniqueStorage()._mapInt32Float = newValue} + } + + var mapInt32Double: Dictionary { + get {_storage._mapInt32Double} + set {_uniqueStorage()._mapInt32Double = newValue} + } + + var mapBoolBool: Dictionary { + get {_storage._mapBoolBool} + set {_uniqueStorage()._mapBoolBool = newValue} + } + + var mapStringString: Dictionary { + get {_storage._mapStringString} + set {_uniqueStorage()._mapStringString = newValue} + } + + var mapInt32Bytes: Dictionary { + get {_storage._mapInt32Bytes} + set {_uniqueStorage()._mapInt32Bytes = newValue} + } + + var mapInt32Enum: Dictionary { + get {_storage._mapInt32Enum} + set {_uniqueStorage()._mapInt32Enum = newValue} + } + + var mapInt32ForeignMessage: Dictionary { + get {_storage._mapInt32ForeignMessage} + set {_uniqueStorage()._mapInt32ForeignMessage = newValue} + } + + var mapStringForeignMessage: Dictionary { + get {_storage._mapStringForeignMessage} + set {_uniqueStorage()._mapStringForeignMessage = newValue} + } + + var mapInt32AllTypes: Dictionary { + get {_storage._mapInt32AllTypes} + set {_uniqueStorage()._mapInt32AllTypes = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// Test embedded message with required fields +struct SwiftProtoTesting_TestRequiredMessageMap: Sendable { + // 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 mapField: Dictionary = [:] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct SwiftProtoTesting_TestRecursiveMapMessage: Sendable { + // 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 a: Dictionary = [:] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_proto_testing" + +extension SwiftProtoTesting_MapEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0MAP_ENUM_FOO\0\u{1}MAP_ENUM_BAR\0\u{1}MAP_ENUM_BAZ\0") +} + +extension SwiftProtoTesting_TestMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_int32_bytes\0\u{3}map_int32_enum\0\u{3}map_int32_foreign_message\0\u{3}map_string_foreign_message\0\u{3}map_int32_all_types\0") + + fileprivate class _StorageClass { + var _mapInt32Int32: Dictionary = [:] + var _mapInt64Int64: Dictionary = [:] + var _mapUint32Uint32: Dictionary = [:] + var _mapUint64Uint64: Dictionary = [:] + var _mapSint32Sint32: Dictionary = [:] + var _mapSint64Sint64: Dictionary = [:] + var _mapFixed32Fixed32: Dictionary = [:] + var _mapFixed64Fixed64: Dictionary = [:] + var _mapSfixed32Sfixed32: Dictionary = [:] + var _mapSfixed64Sfixed64: Dictionary = [:] + var _mapInt32Float: Dictionary = [:] + var _mapInt32Double: Dictionary = [:] + var _mapBoolBool: Dictionary = [:] + var _mapStringString: Dictionary = [:] + var _mapInt32Bytes: Dictionary = [:] + var _mapInt32Enum: Dictionary = [:] + var _mapInt32ForeignMessage: Dictionary = [:] + var _mapStringForeignMessage: Dictionary = [:] + var _mapInt32AllTypes: Dictionary = [:] + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _mapInt32Int32 = source._mapInt32Int32 + _mapInt64Int64 = source._mapInt64Int64 + _mapUint32Uint32 = source._mapUint32Uint32 + _mapUint64Uint64 = source._mapUint64Uint64 + _mapSint32Sint32 = source._mapSint32Sint32 + _mapSint64Sint64 = source._mapSint64Sint64 + _mapFixed32Fixed32 = source._mapFixed32Fixed32 + _mapFixed64Fixed64 = source._mapFixed64Fixed64 + _mapSfixed32Sfixed32 = source._mapSfixed32Sfixed32 + _mapSfixed64Sfixed64 = source._mapSfixed64Sfixed64 + _mapInt32Float = source._mapInt32Float + _mapInt32Double = source._mapInt32Double + _mapBoolBool = source._mapBoolBool + _mapStringString = source._mapStringString + _mapInt32Bytes = source._mapInt32Bytes + _mapInt32Enum = source._mapInt32Enum + _mapInt32ForeignMessage = source._mapInt32ForeignMessage + _mapStringForeignMessage = source._mapStringForeignMessage + _mapInt32AllTypes = source._mapInt32AllTypes + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Int32) }() + case 2: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() + case 3: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() + case 4: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Uint64) }() + case 5: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Sint32) }() + case 6: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Sint64) }() + case 7: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Fixed32) }() + case 8: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Fixed64) }() + case 9: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Sfixed32) }() + case 10: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Sfixed64) }() + case 11: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Float) }() + case 12: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Double) }() + case 13: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() + case 14: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() + case 15: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bytes) }() + case 16: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() + case 17: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32ForeignMessage) }() + case 18: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() + case 19: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32AllTypes) }() + default: break + } + } + } + } + + func traverse(visitor: inout V) throws { + try withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if !_storage._mapInt32Int32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Int32, fieldNumber: 1) + } + if !_storage._mapInt64Int64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Int64, fieldNumber: 2) + } + if !_storage._mapUint32Uint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Uint32, fieldNumber: 3) + } + if !_storage._mapUint64Uint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Uint64, fieldNumber: 4) + } + if !_storage._mapSint32Sint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Sint32, fieldNumber: 5) + } + if !_storage._mapSint64Sint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Sint64, fieldNumber: 6) + } + if !_storage._mapFixed32Fixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Fixed32, fieldNumber: 7) + } + if !_storage._mapFixed64Fixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Fixed64, fieldNumber: 8) + } + if !_storage._mapSfixed32Sfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 9) + } + if !_storage._mapSfixed64Sfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 10) + } + if !_storage._mapInt32Float.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Float, fieldNumber: 11) + } + if !_storage._mapInt32Double.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Double, fieldNumber: 12) + } + if !_storage._mapBoolBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolBool, fieldNumber: 13) + } + if !_storage._mapStringString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringString, fieldNumber: 14) + } + if !_storage._mapInt32Bytes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bytes, fieldNumber: 15) + } + if !_storage._mapInt32Enum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 16) + } + if !_storage._mapInt32ForeignMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32ForeignMessage, fieldNumber: 17) + } + if !_storage._mapStringForeignMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 18) + } + if !_storage._mapInt32AllTypes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32AllTypes, fieldNumber: 19) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestMap, rhs: SwiftProtoTesting_TestMap) -> 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._mapInt32Int32 != rhs_storage._mapInt32Int32 {return false} + if _storage._mapInt64Int64 != rhs_storage._mapInt64Int64 {return false} + if _storage._mapUint32Uint32 != rhs_storage._mapUint32Uint32 {return false} + if _storage._mapUint64Uint64 != rhs_storage._mapUint64Uint64 {return false} + if _storage._mapSint32Sint32 != rhs_storage._mapSint32Sint32 {return false} + if _storage._mapSint64Sint64 != rhs_storage._mapSint64Sint64 {return false} + if _storage._mapFixed32Fixed32 != rhs_storage._mapFixed32Fixed32 {return false} + if _storage._mapFixed64Fixed64 != rhs_storage._mapFixed64Fixed64 {return false} + if _storage._mapSfixed32Sfixed32 != rhs_storage._mapSfixed32Sfixed32 {return false} + if _storage._mapSfixed64Sfixed64 != rhs_storage._mapSfixed64Sfixed64 {return false} + if _storage._mapInt32Float != rhs_storage._mapInt32Float {return false} + if _storage._mapInt32Double != rhs_storage._mapInt32Double {return false} + if _storage._mapBoolBool != rhs_storage._mapBoolBool {return false} + if _storage._mapStringString != rhs_storage._mapStringString {return false} + if _storage._mapInt32Bytes != rhs_storage._mapInt32Bytes {return false} + if _storage._mapInt32Enum != rhs_storage._mapInt32Enum {return false} + if _storage._mapInt32ForeignMessage != rhs_storage._mapInt32ForeignMessage {return false} + if _storage._mapStringForeignMessage != rhs_storage._mapStringForeignMessage {return false} + if _storage._mapInt32AllTypes != rhs_storage._mapInt32AllTypes {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestRequiredMessageMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredMessageMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}map_field\0") + + public var isInitialized: Bool { + if !SwiftProtobuf.Internal.areAllInitialized(self.mapField) {return false} + return true + } + + 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapField) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.mapField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapField, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestRequiredMessageMap, rhs: SwiftProtoTesting_TestRequiredMessageMap) -> Bool { + if lhs.mapField != rhs.mapField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestRecursiveMapMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRecursiveMapMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") + + 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.a) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.a.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.a, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestRecursiveMapMessage, rhs: SwiftProtoTesting_TestRecursiveMapMessage) -> Bool { + if lhs.a != rhs.a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/Tests/SwiftProtobufTests/test_messages_proto3.pb.swift b/Reference/Tests/SwiftProtobufTests/test_messages_proto3.pb.swift new file mode 100644 index 000000000..e23805db1 --- /dev/null +++ b/Reference/Tests/SwiftProtobufTests/test_messages_proto3.pb.swift @@ -0,0 +1,1801 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: test_messages_proto3.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +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 +} + +/// This proto includes every type of field in both singular and repeated +/// forms. +/// +/// Also, crucially, all messages and enums in this file are eventually +/// submessages of this message. So for example, a fuzz test of TestAllTypes +/// could trigger bugs that occur in any message type in this file. We verify +/// this stays true in a unit test. +struct SwiftProtoTesting_Test3_TestAllTypesProto3: @unchecked Sendable { + // 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. + + /// Singular + var optionalInt32: Int32 { + get {_storage._optionalInt32} + set {_uniqueStorage()._optionalInt32 = newValue} + } + + var optionalInt64: Int64 { + get {_storage._optionalInt64} + set {_uniqueStorage()._optionalInt64 = newValue} + } + + var optionalUint32: UInt32 { + get {_storage._optionalUint32} + set {_uniqueStorage()._optionalUint32 = newValue} + } + + var optionalUint64: UInt64 { + get {_storage._optionalUint64} + set {_uniqueStorage()._optionalUint64 = newValue} + } + + var optionalSint32: Int32 { + get {_storage._optionalSint32} + set {_uniqueStorage()._optionalSint32 = newValue} + } + + var optionalSint64: Int64 { + get {_storage._optionalSint64} + set {_uniqueStorage()._optionalSint64 = newValue} + } + + var optionalFixed32: UInt32 { + get {_storage._optionalFixed32} + set {_uniqueStorage()._optionalFixed32 = newValue} + } + + var optionalFixed64: UInt64 { + get {_storage._optionalFixed64} + set {_uniqueStorage()._optionalFixed64 = newValue} + } + + var optionalSfixed32: Int32 { + get {_storage._optionalSfixed32} + set {_uniqueStorage()._optionalSfixed32 = newValue} + } + + var optionalSfixed64: Int64 { + get {_storage._optionalSfixed64} + set {_uniqueStorage()._optionalSfixed64 = newValue} + } + + var optionalFloat: Float { + get {_storage._optionalFloat} + set {_uniqueStorage()._optionalFloat = newValue} + } + + var optionalDouble: Double { + get {_storage._optionalDouble} + set {_uniqueStorage()._optionalDouble = newValue} + } + + var optionalBool: Bool { + get {_storage._optionalBool} + set {_uniqueStorage()._optionalBool = newValue} + } + + var optionalString: String { + get {_storage._optionalString} + set {_uniqueStorage()._optionalString = newValue} + } + + var optionalBytes: Data { + get {_storage._optionalBytes} + set {_uniqueStorage()._optionalBytes = newValue} + } + + var optionalNestedMessage: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage { + get {_storage._optionalNestedMessage ?? SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage()} + set {_uniqueStorage()._optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} + + var optionalNestedEnum: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum { + get {_storage._optionalNestedEnum} + set {_uniqueStorage()._optionalNestedEnum = newValue} + } + + /// Repeated + var repeatedInt32: [Int32] { + get {_storage._repeatedInt32} + set {_uniqueStorage()._repeatedInt32 = newValue} + } + + var repeatedInt64: [Int64] { + get {_storage._repeatedInt64} + set {_uniqueStorage()._repeatedInt64 = newValue} + } + + var repeatedUint32: [UInt32] { + get {_storage._repeatedUint32} + set {_uniqueStorage()._repeatedUint32 = newValue} + } + + var repeatedUint64: [UInt64] { + get {_storage._repeatedUint64} + set {_uniqueStorage()._repeatedUint64 = newValue} + } + + var repeatedSint32: [Int32] { + get {_storage._repeatedSint32} + set {_uniqueStorage()._repeatedSint32 = newValue} + } + + var repeatedSint64: [Int64] { + get {_storage._repeatedSint64} + set {_uniqueStorage()._repeatedSint64 = newValue} + } + + var repeatedFixed32: [UInt32] { + get {_storage._repeatedFixed32} + set {_uniqueStorage()._repeatedFixed32 = newValue} + } + + var repeatedFixed64: [UInt64] { + get {_storage._repeatedFixed64} + set {_uniqueStorage()._repeatedFixed64 = newValue} + } + + var repeatedSfixed32: [Int32] { + get {_storage._repeatedSfixed32} + set {_uniqueStorage()._repeatedSfixed32 = newValue} + } + + var repeatedSfixed64: [Int64] { + get {_storage._repeatedSfixed64} + set {_uniqueStorage()._repeatedSfixed64 = newValue} + } + + var repeatedFloat: [Float] { + get {_storage._repeatedFloat} + set {_uniqueStorage()._repeatedFloat = newValue} + } + + var repeatedDouble: [Double] { + get {_storage._repeatedDouble} + set {_uniqueStorage()._repeatedDouble = newValue} + } + + var repeatedBool: [Bool] { + get {_storage._repeatedBool} + set {_uniqueStorage()._repeatedBool = newValue} + } + + var repeatedString: [String] { + get {_storage._repeatedString} + set {_uniqueStorage()._repeatedString = newValue} + } + + var repeatedBytes: [Data] { + get {_storage._repeatedBytes} + set {_uniqueStorage()._repeatedBytes = newValue} + } + + var repeatedNestedMessage: [SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage] { + get {_storage._repeatedNestedMessage} + set {_uniqueStorage()._repeatedNestedMessage = newValue} + } + + var repeatedNestedEnum: [SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum] { + get {_storage._repeatedNestedEnum} + set {_uniqueStorage()._repeatedNestedEnum = newValue} + } + + /// Map + var mapInt32Int32: Dictionary { + get {_storage._mapInt32Int32} + set {_uniqueStorage()._mapInt32Int32 = newValue} + } + + var mapInt64Int64: Dictionary { + get {_storage._mapInt64Int64} + set {_uniqueStorage()._mapInt64Int64 = newValue} + } + + var mapUint32Uint32: Dictionary { + get {_storage._mapUint32Uint32} + set {_uniqueStorage()._mapUint32Uint32 = newValue} + } + + var mapUint64Uint64: Dictionary { + get {_storage._mapUint64Uint64} + set {_uniqueStorage()._mapUint64Uint64 = newValue} + } + + var mapSint32Sint32: Dictionary { + get {_storage._mapSint32Sint32} + set {_uniqueStorage()._mapSint32Sint32 = newValue} + } + + var mapSint64Sint64: Dictionary { + get {_storage._mapSint64Sint64} + set {_uniqueStorage()._mapSint64Sint64 = newValue} + } + + var mapFixed32Fixed32: Dictionary { + get {_storage._mapFixed32Fixed32} + set {_uniqueStorage()._mapFixed32Fixed32 = newValue} + } + + var mapFixed64Fixed64: Dictionary { + get {_storage._mapFixed64Fixed64} + set {_uniqueStorage()._mapFixed64Fixed64 = newValue} + } + + var mapSfixed32Sfixed32: Dictionary { + get {_storage._mapSfixed32Sfixed32} + set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} + } + + var mapSfixed64Sfixed64: Dictionary { + get {_storage._mapSfixed64Sfixed64} + set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} + } + + var mapInt32Float: Dictionary { + get {_storage._mapInt32Float} + set {_uniqueStorage()._mapInt32Float = newValue} + } + + var mapInt32Double: Dictionary { + get {_storage._mapInt32Double} + set {_uniqueStorage()._mapInt32Double = newValue} + } + + var mapBoolBool: Dictionary { + get {_storage._mapBoolBool} + set {_uniqueStorage()._mapBoolBool = newValue} + } + + var mapStringString: Dictionary { + get {_storage._mapStringString} + set {_uniqueStorage()._mapStringString = newValue} + } + + var mapStringBytes: Dictionary { + get {_storage._mapStringBytes} + set {_uniqueStorage()._mapStringBytes = newValue} + } + + var mapStringNestedMessage: Dictionary { + get {_storage._mapStringNestedMessage} + set {_uniqueStorage()._mapStringNestedMessage = newValue} + } + + var mapStringNestedEnum: Dictionary { + get {_storage._mapStringNestedEnum} + set {_uniqueStorage()._mapStringNestedEnum = newValue} + } + + var oneofField: OneOf_OneofField? { + get {return _storage._oneofField} + set {_uniqueStorage()._oneofField = newValue} + } + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} + } + + var oneofNestedMessage: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage { + get { + if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} + return SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = _storage._oneofField {return v} + return Data() + } + set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} + } + + var oneofBool: Bool { + get { + if case .oneofBool(let v)? = _storage._oneofField {return v} + return false + } + set {_uniqueStorage()._oneofField = .oneofBool(newValue)} + } + + var oneofUint64: UInt64 { + get { + if case .oneofUint64(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint64(newValue)} + } + + var oneofFloat: Float { + get { + if case .oneofFloat(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofFloat(newValue)} + } + + var oneofDouble: Double { + get { + if case .oneofDouble(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofDouble(newValue)} + } + + var oneofEnum: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum { + get { + if case .oneofEnum(let v)? = _storage._oneofField {return v} + return .foo + } + set {_uniqueStorage()._oneofField = .oneofEnum(newValue)} + } + + var oneofNullValue: SwiftProtobuf.Google_Protobuf_NullValue { + get { + if case .oneofNullValue(let v)? = _storage._oneofField {return v} + return .nullValue + } + set {_uniqueStorage()._oneofField = .oneofNullValue(newValue)} + } + + /// Well-known types + var optionalBoolWrapper: SwiftProtobuf.Google_Protobuf_BoolValue { + get {_storage._optionalBoolWrapper ?? SwiftProtobuf.Google_Protobuf_BoolValue()} + set {_uniqueStorage()._optionalBoolWrapper = newValue} + } + /// Returns true if `optionalBoolWrapper` has been explicitly set. + var hasOptionalBoolWrapper: Bool {_storage._optionalBoolWrapper != nil} + /// Clears the value of `optionalBoolWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalBoolWrapper() {_uniqueStorage()._optionalBoolWrapper = nil} + + var optionalInt32Wrapper: SwiftProtobuf.Google_Protobuf_Int32Value { + get {_storage._optionalInt32Wrapper ?? SwiftProtobuf.Google_Protobuf_Int32Value()} + set {_uniqueStorage()._optionalInt32Wrapper = newValue} + } + /// Returns true if `optionalInt32Wrapper` has been explicitly set. + var hasOptionalInt32Wrapper: Bool {_storage._optionalInt32Wrapper != nil} + /// Clears the value of `optionalInt32Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32Wrapper() {_uniqueStorage()._optionalInt32Wrapper = nil} + + var optionalInt64Wrapper: SwiftProtobuf.Google_Protobuf_Int64Value { + get {_storage._optionalInt64Wrapper ?? SwiftProtobuf.Google_Protobuf_Int64Value()} + set {_uniqueStorage()._optionalInt64Wrapper = newValue} + } + /// Returns true if `optionalInt64Wrapper` has been explicitly set. + var hasOptionalInt64Wrapper: Bool {_storage._optionalInt64Wrapper != nil} + /// Clears the value of `optionalInt64Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64Wrapper() {_uniqueStorage()._optionalInt64Wrapper = nil} + + var optionalUint32Wrapper: SwiftProtobuf.Google_Protobuf_UInt32Value { + get {_storage._optionalUint32Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} + set {_uniqueStorage()._optionalUint32Wrapper = newValue} + } + /// Returns true if `optionalUint32Wrapper` has been explicitly set. + var hasOptionalUint32Wrapper: Bool {_storage._optionalUint32Wrapper != nil} + /// Clears the value of `optionalUint32Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint32Wrapper() {_uniqueStorage()._optionalUint32Wrapper = nil} + + var optionalUint64Wrapper: SwiftProtobuf.Google_Protobuf_UInt64Value { + get {_storage._optionalUint64Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} + set {_uniqueStorage()._optionalUint64Wrapper = newValue} + } + /// Returns true if `optionalUint64Wrapper` has been explicitly set. + var hasOptionalUint64Wrapper: Bool {_storage._optionalUint64Wrapper != nil} + /// Clears the value of `optionalUint64Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint64Wrapper() {_uniqueStorage()._optionalUint64Wrapper = nil} + + var optionalFloatWrapper: SwiftProtobuf.Google_Protobuf_FloatValue { + get {_storage._optionalFloatWrapper ?? SwiftProtobuf.Google_Protobuf_FloatValue()} + set {_uniqueStorage()._optionalFloatWrapper = newValue} + } + /// Returns true if `optionalFloatWrapper` has been explicitly set. + var hasOptionalFloatWrapper: Bool {_storage._optionalFloatWrapper != nil} + /// Clears the value of `optionalFloatWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloatWrapper() {_uniqueStorage()._optionalFloatWrapper = nil} + + var optionalDoubleWrapper: SwiftProtobuf.Google_Protobuf_DoubleValue { + get {_storage._optionalDoubleWrapper ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} + set {_uniqueStorage()._optionalDoubleWrapper = newValue} + } + /// Returns true if `optionalDoubleWrapper` has been explicitly set. + var hasOptionalDoubleWrapper: Bool {_storage._optionalDoubleWrapper != nil} + /// Clears the value of `optionalDoubleWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalDoubleWrapper() {_uniqueStorage()._optionalDoubleWrapper = nil} + + var optionalStringWrapper: SwiftProtobuf.Google_Protobuf_StringValue { + get {_storage._optionalStringWrapper ?? SwiftProtobuf.Google_Protobuf_StringValue()} + set {_uniqueStorage()._optionalStringWrapper = newValue} + } + /// Returns true if `optionalStringWrapper` has been explicitly set. + var hasOptionalStringWrapper: Bool {_storage._optionalStringWrapper != nil} + /// Clears the value of `optionalStringWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringWrapper() {_uniqueStorage()._optionalStringWrapper = nil} + + var optionalBytesWrapper: SwiftProtobuf.Google_Protobuf_BytesValue { + get {_storage._optionalBytesWrapper ?? SwiftProtobuf.Google_Protobuf_BytesValue()} + set {_uniqueStorage()._optionalBytesWrapper = newValue} + } + /// Returns true if `optionalBytesWrapper` has been explicitly set. + var hasOptionalBytesWrapper: Bool {_storage._optionalBytesWrapper != nil} + /// Clears the value of `optionalBytesWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytesWrapper() {_uniqueStorage()._optionalBytesWrapper = nil} + + var repeatedBoolWrapper: [SwiftProtobuf.Google_Protobuf_BoolValue] { + get {_storage._repeatedBoolWrapper} + set {_uniqueStorage()._repeatedBoolWrapper = newValue} + } + + var repeatedInt32Wrapper: [SwiftProtobuf.Google_Protobuf_Int32Value] { + get {_storage._repeatedInt32Wrapper} + set {_uniqueStorage()._repeatedInt32Wrapper = newValue} + } + + var repeatedInt64Wrapper: [SwiftProtobuf.Google_Protobuf_Int64Value] { + get {_storage._repeatedInt64Wrapper} + set {_uniqueStorage()._repeatedInt64Wrapper = newValue} + } + + var repeatedUint32Wrapper: [SwiftProtobuf.Google_Protobuf_UInt32Value] { + get {_storage._repeatedUint32Wrapper} + set {_uniqueStorage()._repeatedUint32Wrapper = newValue} + } + + var repeatedUint64Wrapper: [SwiftProtobuf.Google_Protobuf_UInt64Value] { + get {_storage._repeatedUint64Wrapper} + set {_uniqueStorage()._repeatedUint64Wrapper = newValue} + } + + var repeatedFloatWrapper: [SwiftProtobuf.Google_Protobuf_FloatValue] { + get {_storage._repeatedFloatWrapper} + set {_uniqueStorage()._repeatedFloatWrapper = newValue} + } + + var repeatedDoubleWrapper: [SwiftProtobuf.Google_Protobuf_DoubleValue] { + get {_storage._repeatedDoubleWrapper} + set {_uniqueStorage()._repeatedDoubleWrapper = newValue} + } + + var repeatedStringWrapper: [SwiftProtobuf.Google_Protobuf_StringValue] { + get {_storage._repeatedStringWrapper} + set {_uniqueStorage()._repeatedStringWrapper = newValue} + } + + var repeatedBytesWrapper: [SwiftProtobuf.Google_Protobuf_BytesValue] { + get {_storage._repeatedBytesWrapper} + set {_uniqueStorage()._repeatedBytesWrapper = newValue} + } + + var optionalDuration: SwiftProtobuf.Google_Protobuf_Duration { + get {_storage._optionalDuration ?? SwiftProtobuf.Google_Protobuf_Duration()} + set {_uniqueStorage()._optionalDuration = newValue} + } + /// Returns true if `optionalDuration` has been explicitly set. + var hasOptionalDuration: Bool {_storage._optionalDuration != nil} + /// Clears the value of `optionalDuration`. Subsequent reads from it will return its default value. + mutating func clearOptionalDuration() {_uniqueStorage()._optionalDuration = nil} + + var optionalTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp { + get {_storage._optionalTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()} + set {_uniqueStorage()._optionalTimestamp = newValue} + } + /// Returns true if `optionalTimestamp` has been explicitly set. + var hasOptionalTimestamp: Bool {_storage._optionalTimestamp != nil} + /// Clears the value of `optionalTimestamp`. Subsequent reads from it will return its default value. + mutating func clearOptionalTimestamp() {_uniqueStorage()._optionalTimestamp = nil} + + var optionalFieldMask: SwiftProtobuf.Google_Protobuf_FieldMask { + get {_storage._optionalFieldMask ?? SwiftProtobuf.Google_Protobuf_FieldMask()} + set {_uniqueStorage()._optionalFieldMask = newValue} + } + /// Returns true if `optionalFieldMask` has been explicitly set. + var hasOptionalFieldMask: Bool {_storage._optionalFieldMask != nil} + /// Clears the value of `optionalFieldMask`. Subsequent reads from it will return its default value. + mutating func clearOptionalFieldMask() {_uniqueStorage()._optionalFieldMask = nil} + + var optionalStruct: SwiftProtobuf.Google_Protobuf_Struct { + get {_storage._optionalStruct ?? SwiftProtobuf.Google_Protobuf_Struct()} + set {_uniqueStorage()._optionalStruct = newValue} + } + /// Returns true if `optionalStruct` has been explicitly set. + var hasOptionalStruct: Bool {_storage._optionalStruct != nil} + /// Clears the value of `optionalStruct`. Subsequent reads from it will return its default value. + mutating func clearOptionalStruct() {_uniqueStorage()._optionalStruct = nil} + + var optionalAny: SwiftProtobuf.Google_Protobuf_Any { + get {_storage._optionalAny ?? SwiftProtobuf.Google_Protobuf_Any()} + set {_uniqueStorage()._optionalAny = newValue} + } + /// Returns true if `optionalAny` has been explicitly set. + var hasOptionalAny: Bool {_storage._optionalAny != nil} + /// Clears the value of `optionalAny`. Subsequent reads from it will return its default value. + mutating func clearOptionalAny() {_uniqueStorage()._optionalAny = nil} + + var optionalValue: SwiftProtobuf.Google_Protobuf_Value { + get {_storage._optionalValue ?? SwiftProtobuf.Google_Protobuf_Value()} + set {_uniqueStorage()._optionalValue = newValue} + } + /// Returns true if `optionalValue` has been explicitly set. + var hasOptionalValue: Bool {_storage._optionalValue != nil} + /// Clears the value of `optionalValue`. Subsequent reads from it will return its default value. + mutating func clearOptionalValue() {_uniqueStorage()._optionalValue = nil} + + var optionalNullValue: SwiftProtobuf.Google_Protobuf_NullValue { + get {_storage._optionalNullValue} + set {_uniqueStorage()._optionalNullValue = newValue} + } + + var repeatedDuration: [SwiftProtobuf.Google_Protobuf_Duration] { + get {_storage._repeatedDuration} + set {_uniqueStorage()._repeatedDuration = newValue} + } + + var repeatedTimestamp: [SwiftProtobuf.Google_Protobuf_Timestamp] { + get {_storage._repeatedTimestamp} + set {_uniqueStorage()._repeatedTimestamp = newValue} + } + + var repeatedFieldmask: [SwiftProtobuf.Google_Protobuf_FieldMask] { + get {_storage._repeatedFieldmask} + set {_uniqueStorage()._repeatedFieldmask = newValue} + } + + var repeatedStruct: [SwiftProtobuf.Google_Protobuf_Struct] { + get {_storage._repeatedStruct} + set {_uniqueStorage()._repeatedStruct = newValue} + } + + var repeatedAny: [SwiftProtobuf.Google_Protobuf_Any] { + get {_storage._repeatedAny} + set {_uniqueStorage()._repeatedAny = newValue} + } + + var repeatedValue: [SwiftProtobuf.Google_Protobuf_Value] { + get {_storage._repeatedValue} + set {_uniqueStorage()._repeatedValue = newValue} + } + + var repeatedListValue: [SwiftProtobuf.Google_Protobuf_ListValue] { + get {_storage._repeatedListValue} + set {_uniqueStorage()._repeatedListValue = newValue} + } + + /// Test field-name-to-JSON-name convention. + /// (protobuf says names can be any valid C/C++ identifier.) + var fieldname1: Int32 { + get {_storage._fieldname1} + set {_uniqueStorage()._fieldname1 = newValue} + } + + var fieldName2: Int32 { + get {_storage._fieldName2} + set {_uniqueStorage()._fieldName2 = newValue} + } + + var fieldName3: Int32 { + get {_storage._fieldName3} + set {_uniqueStorage()._fieldName3 = newValue} + } + + var field_Name4_: Int32 { + get {_storage._field_Name4_} + set {_uniqueStorage()._field_Name4_ = newValue} + } + + var field0Name5: Int32 { + get {_storage._field0Name5} + set {_uniqueStorage()._field0Name5 = newValue} + } + + var field0Name6: Int32 { + get {_storage._field0Name6} + set {_uniqueStorage()._field0Name6 = newValue} + } + + var fieldName7: Int32 { + get {_storage._fieldName7} + set {_uniqueStorage()._fieldName7 = newValue} + } + + var fieldName8: Int32 { + get {_storage._fieldName8} + set {_uniqueStorage()._fieldName8 = newValue} + } + + var fieldName9: Int32 { + get {_storage._fieldName9} + set {_uniqueStorage()._fieldName9 = newValue} + } + + var fieldName10: Int32 { + get {_storage._fieldName10} + set {_uniqueStorage()._fieldName10 = newValue} + } + + var fieldName11: Int32 { + get {_storage._fieldName11} + set {_uniqueStorage()._fieldName11 = newValue} + } + + var fieldName12: Int32 { + get {_storage._fieldName12} + set {_uniqueStorage()._fieldName12 = newValue} + } + + var _FieldName13: Int32 { + get {_storage.__FieldName13} + set {_uniqueStorage().__FieldName13 = newValue} + } + + var _FieldName14: Int32 { + get {_storage.__FieldName14} + set {_uniqueStorage().__FieldName14 = newValue} + } + + var field_Name15: Int32 { + get {_storage._field_Name15} + set {_uniqueStorage()._field_Name15 = newValue} + } + + var field_Name16: Int32 { + get {_storage._field_Name16} + set {_uniqueStorage()._field_Name16 = newValue} + } + + var fieldName17__: Int32 { + get {_storage._fieldName17__} + set {_uniqueStorage()._fieldName17__ = newValue} + } + + var fieldName18__: Int32 { + get {_storage._fieldName18__} + set {_uniqueStorage()._fieldName18__ = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofNestedMessage(SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage) + case oneofString(String) + case oneofBytes(Data) + case oneofBool(Bool) + case oneofUint64(UInt64) + case oneofFloat(Float) + case oneofDouble(Double) + case oneofEnum(SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum) + case oneofNullValue(SwiftProtobuf.Google_Protobuf_NullValue) + + } + + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foo // = 0 + case bar // = 1 + case baz // = 2 + + /// Intentionally negative. + case neg // = -1 + case UNRECOGNIZED(Int) + + init() { + self = .foo + } + + init?(rawValue: Int) { + switch rawValue { + case -1: self = .neg + case 0: self = .foo + case 1: self = .bar + case 2: self = .baz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .neg: return -1 + case .foo: return 0 + case .bar: return 1 + case .baz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum] = [ + .foo, + .bar, + .baz, + .neg, + ] + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a} + set {_uniqueStorage()._a = newValue} + } + + var corecursive: SwiftProtoTesting_Test3_TestAllTypesProto3 { + get {_storage._corecursive ?? SwiftProtoTesting_Test3_TestAllTypesProto3()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_proto_testing.test3" + +extension SwiftProtoTesting_Test3_TestAllTypesProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypesProto3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{4}\u{3}optional_nested_enum\0\u{4}\u{a}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{4}\u{3}repeated_nested_enum\0\u{4}\u{5}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_nested_message\0\u{4}\u{2}map_string_nested_enum\0\u{4}&oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_bool\0\u{3}oneof_uint64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_enum\0\u{3}oneof_null_value\0\u{4}Q\u{1}optional_bool_wrapper\0\u{3}optional_int32_wrapper\0\u{3}optional_int64_wrapper\0\u{3}optional_uint32_wrapper\0\u{3}optional_uint64_wrapper\0\u{3}optional_float_wrapper\0\u{3}optional_double_wrapper\0\u{3}optional_string_wrapper\0\u{3}optional_bytes_wrapper\0\u{4}\u{2}repeated_bool_wrapper\0\u{3}repeated_int32_wrapper\0\u{3}repeated_int64_wrapper\0\u{3}repeated_uint32_wrapper\0\u{3}repeated_uint64_wrapper\0\u{3}repeated_float_wrapper\0\u{3}repeated_double_wrapper\0\u{3}repeated_string_wrapper\0\u{3}repeated_bytes_wrapper\0\u{4}R\u{1}optional_duration\0\u{3}optional_timestamp\0\u{3}optional_field_mask\0\u{3}optional_struct\0\u{3}optional_any\0\u{3}optional_value\0\u{3}optional_null_value\0\u{4}\u{4}repeated_duration\0\u{3}repeated_timestamp\0\u{3}repeated_fieldmask\0\u{4}\u{2}repeated_any\0\u{3}repeated_value\0\u{3}repeated_list_value\0\u{4}\u{7}repeated_struct\0\u{2}M\u{1}fieldname1\0\u{3}field_name2\0\u{3}_field_name3\0\u{3}field__name4_\0\u{1}field0name5\0\u{3}field_0_name6\0\u{1}fieldName7\0\u{1}FieldName8\0\u{3}field_Name9\0\u{3}Field_Name10\0\u{3}FIELD_NAME11\0\u{3}FIELD_name12\0\u{3}__field_name13\0\u{3}__Field_name14\0\u{3}field__name15\0\u{3}field__Name16\0\u{3}field_name17__\0\u{3}Field_name18__\0\u{c}u\u{7}\u{a}") + + fileprivate class _StorageClass { + var _optionalInt32: Int32 = 0 + var _optionalInt64: Int64 = 0 + var _optionalUint32: UInt32 = 0 + var _optionalUint64: UInt64 = 0 + var _optionalSint32: Int32 = 0 + var _optionalSint64: Int64 = 0 + var _optionalFixed32: UInt32 = 0 + var _optionalFixed64: UInt64 = 0 + var _optionalSfixed32: Int32 = 0 + var _optionalSfixed64: Int64 = 0 + var _optionalFloat: Float = 0 + var _optionalDouble: Double = 0 + var _optionalBool: Bool = false + var _optionalString: String = String() + var _optionalBytes: Data = Data() + var _optionalNestedMessage: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage? = nil + var _optionalNestedEnum: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum = .foo + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedNestedMessage: [SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage] = [] + var _repeatedNestedEnum: [SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum] = [] + var _mapInt32Int32: Dictionary = [:] + var _mapInt64Int64: Dictionary = [:] + var _mapUint32Uint32: Dictionary = [:] + var _mapUint64Uint64: Dictionary = [:] + var _mapSint32Sint32: Dictionary = [:] + var _mapSint64Sint64: Dictionary = [:] + var _mapFixed32Fixed32: Dictionary = [:] + var _mapFixed64Fixed64: Dictionary = [:] + var _mapSfixed32Sfixed32: Dictionary = [:] + var _mapSfixed64Sfixed64: Dictionary = [:] + var _mapInt32Float: Dictionary = [:] + var _mapInt32Double: Dictionary = [:] + var _mapBoolBool: Dictionary = [:] + var _mapStringString: Dictionary = [:] + var _mapStringBytes: Dictionary = [:] + var _mapStringNestedMessage: Dictionary = [:] + var _mapStringNestedEnum: Dictionary = [:] + var _oneofField: SwiftProtoTesting_Test3_TestAllTypesProto3.OneOf_OneofField? + var _optionalBoolWrapper: SwiftProtobuf.Google_Protobuf_BoolValue? = nil + var _optionalInt32Wrapper: SwiftProtobuf.Google_Protobuf_Int32Value? = nil + var _optionalInt64Wrapper: SwiftProtobuf.Google_Protobuf_Int64Value? = nil + var _optionalUint32Wrapper: SwiftProtobuf.Google_Protobuf_UInt32Value? = nil + var _optionalUint64Wrapper: SwiftProtobuf.Google_Protobuf_UInt64Value? = nil + var _optionalFloatWrapper: SwiftProtobuf.Google_Protobuf_FloatValue? = nil + var _optionalDoubleWrapper: SwiftProtobuf.Google_Protobuf_DoubleValue? = nil + var _optionalStringWrapper: SwiftProtobuf.Google_Protobuf_StringValue? = nil + var _optionalBytesWrapper: SwiftProtobuf.Google_Protobuf_BytesValue? = nil + var _repeatedBoolWrapper: [SwiftProtobuf.Google_Protobuf_BoolValue] = [] + var _repeatedInt32Wrapper: [SwiftProtobuf.Google_Protobuf_Int32Value] = [] + var _repeatedInt64Wrapper: [SwiftProtobuf.Google_Protobuf_Int64Value] = [] + var _repeatedUint32Wrapper: [SwiftProtobuf.Google_Protobuf_UInt32Value] = [] + var _repeatedUint64Wrapper: [SwiftProtobuf.Google_Protobuf_UInt64Value] = [] + var _repeatedFloatWrapper: [SwiftProtobuf.Google_Protobuf_FloatValue] = [] + var _repeatedDoubleWrapper: [SwiftProtobuf.Google_Protobuf_DoubleValue] = [] + var _repeatedStringWrapper: [SwiftProtobuf.Google_Protobuf_StringValue] = [] + var _repeatedBytesWrapper: [SwiftProtobuf.Google_Protobuf_BytesValue] = [] + var _optionalDuration: SwiftProtobuf.Google_Protobuf_Duration? = nil + var _optionalTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp? = nil + var _optionalFieldMask: SwiftProtobuf.Google_Protobuf_FieldMask? = nil + var _optionalStruct: SwiftProtobuf.Google_Protobuf_Struct? = nil + var _optionalAny: SwiftProtobuf.Google_Protobuf_Any? = nil + var _optionalValue: SwiftProtobuf.Google_Protobuf_Value? = nil + var _optionalNullValue: SwiftProtobuf.Google_Protobuf_NullValue = .nullValue + var _repeatedDuration: [SwiftProtobuf.Google_Protobuf_Duration] = [] + var _repeatedTimestamp: [SwiftProtobuf.Google_Protobuf_Timestamp] = [] + var _repeatedFieldmask: [SwiftProtobuf.Google_Protobuf_FieldMask] = [] + var _repeatedStruct: [SwiftProtobuf.Google_Protobuf_Struct] = [] + var _repeatedAny: [SwiftProtobuf.Google_Protobuf_Any] = [] + var _repeatedValue: [SwiftProtobuf.Google_Protobuf_Value] = [] + var _repeatedListValue: [SwiftProtobuf.Google_Protobuf_ListValue] = [] + var _fieldname1: Int32 = 0 + var _fieldName2: Int32 = 0 + var _fieldName3: Int32 = 0 + var _field_Name4_: Int32 = 0 + var _field0Name5: Int32 = 0 + var _field0Name6: Int32 = 0 + var _fieldName7: Int32 = 0 + var _fieldName8: Int32 = 0 + var _fieldName9: Int32 = 0 + var _fieldName10: Int32 = 0 + var _fieldName11: Int32 = 0 + var _fieldName12: Int32 = 0 + var __FieldName13: Int32 = 0 + var __FieldName14: Int32 = 0 + var _field_Name15: Int32 = 0 + var _field_Name16: Int32 = 0 + var _fieldName17__: Int32 = 0 + var _fieldName18__: Int32 = 0 + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalNestedMessage = source._optionalNestedMessage + _optionalNestedEnum = source._optionalNestedEnum + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _mapInt32Int32 = source._mapInt32Int32 + _mapInt64Int64 = source._mapInt64Int64 + _mapUint32Uint32 = source._mapUint32Uint32 + _mapUint64Uint64 = source._mapUint64Uint64 + _mapSint32Sint32 = source._mapSint32Sint32 + _mapSint64Sint64 = source._mapSint64Sint64 + _mapFixed32Fixed32 = source._mapFixed32Fixed32 + _mapFixed64Fixed64 = source._mapFixed64Fixed64 + _mapSfixed32Sfixed32 = source._mapSfixed32Sfixed32 + _mapSfixed64Sfixed64 = source._mapSfixed64Sfixed64 + _mapInt32Float = source._mapInt32Float + _mapInt32Double = source._mapInt32Double + _mapBoolBool = source._mapBoolBool + _mapStringString = source._mapStringString + _mapStringBytes = source._mapStringBytes + _mapStringNestedMessage = source._mapStringNestedMessage + _mapStringNestedEnum = source._mapStringNestedEnum + _oneofField = source._oneofField + _optionalBoolWrapper = source._optionalBoolWrapper + _optionalInt32Wrapper = source._optionalInt32Wrapper + _optionalInt64Wrapper = source._optionalInt64Wrapper + _optionalUint32Wrapper = source._optionalUint32Wrapper + _optionalUint64Wrapper = source._optionalUint64Wrapper + _optionalFloatWrapper = source._optionalFloatWrapper + _optionalDoubleWrapper = source._optionalDoubleWrapper + _optionalStringWrapper = source._optionalStringWrapper + _optionalBytesWrapper = source._optionalBytesWrapper + _repeatedBoolWrapper = source._repeatedBoolWrapper + _repeatedInt32Wrapper = source._repeatedInt32Wrapper + _repeatedInt64Wrapper = source._repeatedInt64Wrapper + _repeatedUint32Wrapper = source._repeatedUint32Wrapper + _repeatedUint64Wrapper = source._repeatedUint64Wrapper + _repeatedFloatWrapper = source._repeatedFloatWrapper + _repeatedDoubleWrapper = source._repeatedDoubleWrapper + _repeatedStringWrapper = source._repeatedStringWrapper + _repeatedBytesWrapper = source._repeatedBytesWrapper + _optionalDuration = source._optionalDuration + _optionalTimestamp = source._optionalTimestamp + _optionalFieldMask = source._optionalFieldMask + _optionalStruct = source._optionalStruct + _optionalAny = source._optionalAny + _optionalValue = source._optionalValue + _optionalNullValue = source._optionalNullValue + _repeatedDuration = source._repeatedDuration + _repeatedTimestamp = source._repeatedTimestamp + _repeatedFieldmask = source._repeatedFieldmask + _repeatedStruct = source._repeatedStruct + _repeatedAny = source._repeatedAny + _repeatedValue = source._repeatedValue + _repeatedListValue = source._repeatedListValue + _fieldname1 = source._fieldname1 + _fieldName2 = source._fieldName2 + _fieldName3 = source._fieldName3 + _field_Name4_ = source._field_Name4_ + _field0Name5 = source._field0Name5 + _field0Name6 = source._field0Name6 + _fieldName7 = source._fieldName7 + _fieldName8 = source._fieldName8 + _fieldName9 = source._fieldName9 + _fieldName10 = source._fieldName10 + _fieldName11 = source._fieldName11 + _fieldName12 = source._fieldName12 + __FieldName13 = source.__FieldName13 + __FieldName14 = source.__FieldName14 + _field_Name15 = source._field_Name15 + _field_Name16 = source._field_Name16 + _fieldName17__ = source._fieldName17__ + _fieldName18__ = source._fieldName18__ + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() + case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() + case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() + case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() + case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() + case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() + case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() + case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() + case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() + case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() + case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() + case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() + case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() + case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() + case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() + case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() + case 56: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Int32) }() + case 57: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() + case 58: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() + case 59: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Uint64) }() + case 60: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Sint32) }() + case 61: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Sint64) }() + case 62: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Fixed32) }() + case 63: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Fixed64) }() + case 64: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Sfixed32) }() + case 65: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Sfixed64) }() + case 66: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Float) }() + case 67: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Double) }() + case 68: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() + case 69: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() + case 70: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() + case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringNestedMessage) }() + case 73: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringNestedEnum) }() + case 111: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 112: try { + var v: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage(v) + } + }() + case 113: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 114: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() + case 115: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBool(v) + } + }() + case 116: try { + var v: UInt64? + try decoder.decodeSingularUInt64Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint64(v) + } + }() + case 117: try { + var v: Float? + try decoder.decodeSingularFloatField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofFloat(v) + } + }() + case 118: try { + var v: Double? + try decoder.decodeSingularDoubleField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofDouble(v) + } + }() + case 119: try { + var v: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofEnum(v) + } + }() + case 120: try { + var v: SwiftProtobuf.Google_Protobuf_NullValue? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNullValue(v) + } + }() + case 201: try { try decoder.decodeSingularMessageField(value: &_storage._optionalBoolWrapper) }() + case 202: try { try decoder.decodeSingularMessageField(value: &_storage._optionalInt32Wrapper) }() + case 203: try { try decoder.decodeSingularMessageField(value: &_storage._optionalInt64Wrapper) }() + case 204: try { try decoder.decodeSingularMessageField(value: &_storage._optionalUint32Wrapper) }() + case 205: try { try decoder.decodeSingularMessageField(value: &_storage._optionalUint64Wrapper) }() + case 206: try { try decoder.decodeSingularMessageField(value: &_storage._optionalFloatWrapper) }() + case 207: try { try decoder.decodeSingularMessageField(value: &_storage._optionalDoubleWrapper) }() + case 208: try { try decoder.decodeSingularMessageField(value: &_storage._optionalStringWrapper) }() + case 209: try { try decoder.decodeSingularMessageField(value: &_storage._optionalBytesWrapper) }() + case 211: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedBoolWrapper) }() + case 212: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedInt32Wrapper) }() + case 213: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedInt64Wrapper) }() + case 214: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedUint32Wrapper) }() + case 215: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedUint64Wrapper) }() + case 216: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedFloatWrapper) }() + case 217: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedDoubleWrapper) }() + case 218: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedStringWrapper) }() + case 219: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedBytesWrapper) }() + case 301: try { try decoder.decodeSingularMessageField(value: &_storage._optionalDuration) }() + case 302: try { try decoder.decodeSingularMessageField(value: &_storage._optionalTimestamp) }() + case 303: try { try decoder.decodeSingularMessageField(value: &_storage._optionalFieldMask) }() + case 304: try { try decoder.decodeSingularMessageField(value: &_storage._optionalStruct) }() + case 305: try { try decoder.decodeSingularMessageField(value: &_storage._optionalAny) }() + case 306: try { try decoder.decodeSingularMessageField(value: &_storage._optionalValue) }() + case 307: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNullValue) }() + case 311: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedDuration) }() + case 312: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedTimestamp) }() + case 313: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedFieldmask) }() + case 315: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedAny) }() + case 316: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedValue) }() + case 317: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedListValue) }() + case 324: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedStruct) }() + case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldname1) }() + case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName2) }() + case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName3) }() + case 404: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name4_) }() + case 405: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name5) }() + case 406: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name6) }() + case 407: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName7) }() + case 408: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName8) }() + case 409: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName9) }() + case 410: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName10) }() + case 411: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName11) }() + case 412: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName12) }() + case 413: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName13) }() + case 414: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName14) }() + case 415: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name15) }() + case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name16) }() + case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName17__) }() + case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName18__) }() + default: break + } + } + } + } + + func traverse(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 + if _storage._optionalInt32 != 0 { + try visitor.visitSingularInt32Field(value: _storage._optionalInt32, fieldNumber: 1) + } + if _storage._optionalInt64 != 0 { + try visitor.visitSingularInt64Field(value: _storage._optionalInt64, fieldNumber: 2) + } + if _storage._optionalUint32 != 0 { + try visitor.visitSingularUInt32Field(value: _storage._optionalUint32, fieldNumber: 3) + } + if _storage._optionalUint64 != 0 { + try visitor.visitSingularUInt64Field(value: _storage._optionalUint64, fieldNumber: 4) + } + if _storage._optionalSint32 != 0 { + try visitor.visitSingularSInt32Field(value: _storage._optionalSint32, fieldNumber: 5) + } + if _storage._optionalSint64 != 0 { + try visitor.visitSingularSInt64Field(value: _storage._optionalSint64, fieldNumber: 6) + } + if _storage._optionalFixed32 != 0 { + try visitor.visitSingularFixed32Field(value: _storage._optionalFixed32, fieldNumber: 7) + } + if _storage._optionalFixed64 != 0 { + try visitor.visitSingularFixed64Field(value: _storage._optionalFixed64, fieldNumber: 8) + } + if _storage._optionalSfixed32 != 0 { + try visitor.visitSingularSFixed32Field(value: _storage._optionalSfixed32, fieldNumber: 9) + } + if _storage._optionalSfixed64 != 0 { + try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) + } + if _storage._optionalFloat.bitPattern != 0 { + try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) + } + if _storage._optionalDouble.bitPattern != 0 { + try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) + } + if _storage._optionalBool != false { + try visitor.visitSingularBoolField(value: _storage._optionalBool, fieldNumber: 13) + } + if !_storage._optionalString.isEmpty { + try visitor.visitSingularStringField(value: _storage._optionalString, fieldNumber: 14) + } + if !_storage._optionalBytes.isEmpty { + try visitor.visitSingularBytesField(value: _storage._optionalBytes, fieldNumber: 15) + } + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + if _storage._optionalNestedEnum != .foo { + try visitor.visitSingularEnumField(value: _storage._optionalNestedEnum, fieldNumber: 21) + } + if !_storage._repeatedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + } + if !_storage._repeatedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + } + if !_storage._repeatedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + } + if !_storage._repeatedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + } + if !_storage._repeatedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + } + if !_storage._repeatedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + } + if !_storage._repeatedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + } + if !_storage._repeatedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + } + if !_storage._repeatedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + } + if !_storage._repeatedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + } + if !_storage._repeatedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + } + if !_storage._repeatedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + } + if !_storage._repeatedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + } + if !_storage._repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) + } + if !_storage._repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) + } + if !_storage._repeatedNestedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) + } + if !_storage._repeatedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + } + if !_storage._mapInt32Int32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Int32, fieldNumber: 56) + } + if !_storage._mapInt64Int64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Int64, fieldNumber: 57) + } + if !_storage._mapUint32Uint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Uint32, fieldNumber: 58) + } + if !_storage._mapUint64Uint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Uint64, fieldNumber: 59) + } + if !_storage._mapSint32Sint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Sint32, fieldNumber: 60) + } + if !_storage._mapSint64Sint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Sint64, fieldNumber: 61) + } + if !_storage._mapFixed32Fixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Fixed32, fieldNumber: 62) + } + if !_storage._mapFixed64Fixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Fixed64, fieldNumber: 63) + } + if !_storage._mapSfixed32Sfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 64) + } + if !_storage._mapSfixed64Sfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 65) + } + if !_storage._mapInt32Float.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Float, fieldNumber: 66) + } + if !_storage._mapInt32Double.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Double, fieldNumber: 67) + } + if !_storage._mapBoolBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolBool, fieldNumber: 68) + } + if !_storage._mapStringString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringString, fieldNumber: 69) + } + if !_storage._mapStringBytes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 70) + } + if !_storage._mapStringNestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringNestedMessage, fieldNumber: 71) + } + if !_storage._mapStringNestedEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringNestedEnum, fieldNumber: 73) + } + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case .oneofBool?: try { + guard case .oneofBool(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 115) + }() + case .oneofUint64?: try { + guard case .oneofUint64(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 116) + }() + case .oneofFloat?: try { + guard case .oneofFloat(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularFloatField(value: v, fieldNumber: 117) + }() + case .oneofDouble?: try { + guard case .oneofDouble(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularDoubleField(value: v, fieldNumber: 118) + }() + case .oneofEnum?: try { + guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 119) + }() + case .oneofNullValue?: try { + guard case .oneofNullValue(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 120) + }() + case nil: break + } + try { if let v = _storage._optionalBoolWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._optionalInt32Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 202) + } }() + try { if let v = _storage._optionalInt64Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 203) + } }() + try { if let v = _storage._optionalUint32Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 204) + } }() + try { if let v = _storage._optionalUint64Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 205) + } }() + try { if let v = _storage._optionalFloatWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 206) + } }() + try { if let v = _storage._optionalDoubleWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 207) + } }() + try { if let v = _storage._optionalStringWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 208) + } }() + try { if let v = _storage._optionalBytesWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 209) + } }() + if !_storage._repeatedBoolWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedBoolWrapper, fieldNumber: 211) + } + if !_storage._repeatedInt32Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedInt32Wrapper, fieldNumber: 212) + } + if !_storage._repeatedInt64Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedInt64Wrapper, fieldNumber: 213) + } + if !_storage._repeatedUint32Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedUint32Wrapper, fieldNumber: 214) + } + if !_storage._repeatedUint64Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedUint64Wrapper, fieldNumber: 215) + } + if !_storage._repeatedFloatWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedFloatWrapper, fieldNumber: 216) + } + if !_storage._repeatedDoubleWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedDoubleWrapper, fieldNumber: 217) + } + if !_storage._repeatedStringWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedStringWrapper, fieldNumber: 218) + } + if !_storage._repeatedBytesWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedBytesWrapper, fieldNumber: 219) + } + try { if let v = _storage._optionalDuration { + try visitor.visitSingularMessageField(value: v, fieldNumber: 301) + } }() + try { if let v = _storage._optionalTimestamp { + try visitor.visitSingularMessageField(value: v, fieldNumber: 302) + } }() + try { if let v = _storage._optionalFieldMask { + try visitor.visitSingularMessageField(value: v, fieldNumber: 303) + } }() + try { if let v = _storage._optionalStruct { + try visitor.visitSingularMessageField(value: v, fieldNumber: 304) + } }() + try { if let v = _storage._optionalAny { + try visitor.visitSingularMessageField(value: v, fieldNumber: 305) + } }() + try { if let v = _storage._optionalValue { + try visitor.visitSingularMessageField(value: v, fieldNumber: 306) + } }() + if _storage._optionalNullValue != .nullValue { + try visitor.visitSingularEnumField(value: _storage._optionalNullValue, fieldNumber: 307) + } + if !_storage._repeatedDuration.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedDuration, fieldNumber: 311) + } + if !_storage._repeatedTimestamp.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedTimestamp, fieldNumber: 312) + } + if !_storage._repeatedFieldmask.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedFieldmask, fieldNumber: 313) + } + if !_storage._repeatedAny.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedAny, fieldNumber: 315) + } + if !_storage._repeatedValue.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedValue, fieldNumber: 316) + } + if !_storage._repeatedListValue.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedListValue, fieldNumber: 317) + } + if !_storage._repeatedStruct.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedStruct, fieldNumber: 324) + } + if _storage._fieldname1 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldname1, fieldNumber: 401) + } + if _storage._fieldName2 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName2, fieldNumber: 402) + } + if _storage._fieldName3 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName3, fieldNumber: 403) + } + if _storage._field_Name4_ != 0 { + try visitor.visitSingularInt32Field(value: _storage._field_Name4_, fieldNumber: 404) + } + if _storage._field0Name5 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field0Name5, fieldNumber: 405) + } + if _storage._field0Name6 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field0Name6, fieldNumber: 406) + } + if _storage._fieldName7 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName7, fieldNumber: 407) + } + if _storage._fieldName8 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName8, fieldNumber: 408) + } + if _storage._fieldName9 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName9, fieldNumber: 409) + } + if _storage._fieldName10 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName10, fieldNumber: 410) + } + if _storage._fieldName11 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName11, fieldNumber: 411) + } + if _storage._fieldName12 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName12, fieldNumber: 412) + } + if _storage.__FieldName13 != 0 { + try visitor.visitSingularInt32Field(value: _storage.__FieldName13, fieldNumber: 413) + } + if _storage.__FieldName14 != 0 { + try visitor.visitSingularInt32Field(value: _storage.__FieldName14, fieldNumber: 414) + } + if _storage._field_Name15 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field_Name15, fieldNumber: 415) + } + if _storage._field_Name16 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field_Name16, fieldNumber: 416) + } + if _storage._fieldName17__ != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName17__, fieldNumber: 417) + } + if _storage._fieldName18__ != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName18__, fieldNumber: 418) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Test3_TestAllTypesProto3, rhs: SwiftProtoTesting_Test3_TestAllTypesProto3) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._mapInt32Int32 != rhs_storage._mapInt32Int32 {return false} + if _storage._mapInt64Int64 != rhs_storage._mapInt64Int64 {return false} + if _storage._mapUint32Uint32 != rhs_storage._mapUint32Uint32 {return false} + if _storage._mapUint64Uint64 != rhs_storage._mapUint64Uint64 {return false} + if _storage._mapSint32Sint32 != rhs_storage._mapSint32Sint32 {return false} + if _storage._mapSint64Sint64 != rhs_storage._mapSint64Sint64 {return false} + if _storage._mapFixed32Fixed32 != rhs_storage._mapFixed32Fixed32 {return false} + if _storage._mapFixed64Fixed64 != rhs_storage._mapFixed64Fixed64 {return false} + if _storage._mapSfixed32Sfixed32 != rhs_storage._mapSfixed32Sfixed32 {return false} + if _storage._mapSfixed64Sfixed64 != rhs_storage._mapSfixed64Sfixed64 {return false} + if _storage._mapInt32Float != rhs_storage._mapInt32Float {return false} + if _storage._mapInt32Double != rhs_storage._mapInt32Double {return false} + if _storage._mapBoolBool != rhs_storage._mapBoolBool {return false} + if _storage._mapStringString != rhs_storage._mapStringString {return false} + if _storage._mapStringBytes != rhs_storage._mapStringBytes {return false} + if _storage._mapStringNestedMessage != rhs_storage._mapStringNestedMessage {return false} + if _storage._mapStringNestedEnum != rhs_storage._mapStringNestedEnum {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + if _storage._optionalBoolWrapper != rhs_storage._optionalBoolWrapper {return false} + if _storage._optionalInt32Wrapper != rhs_storage._optionalInt32Wrapper {return false} + if _storage._optionalInt64Wrapper != rhs_storage._optionalInt64Wrapper {return false} + if _storage._optionalUint32Wrapper != rhs_storage._optionalUint32Wrapper {return false} + if _storage._optionalUint64Wrapper != rhs_storage._optionalUint64Wrapper {return false} + if _storage._optionalFloatWrapper != rhs_storage._optionalFloatWrapper {return false} + if _storage._optionalDoubleWrapper != rhs_storage._optionalDoubleWrapper {return false} + if _storage._optionalStringWrapper != rhs_storage._optionalStringWrapper {return false} + if _storage._optionalBytesWrapper != rhs_storage._optionalBytesWrapper {return false} + if _storage._repeatedBoolWrapper != rhs_storage._repeatedBoolWrapper {return false} + if _storage._repeatedInt32Wrapper != rhs_storage._repeatedInt32Wrapper {return false} + if _storage._repeatedInt64Wrapper != rhs_storage._repeatedInt64Wrapper {return false} + if _storage._repeatedUint32Wrapper != rhs_storage._repeatedUint32Wrapper {return false} + if _storage._repeatedUint64Wrapper != rhs_storage._repeatedUint64Wrapper {return false} + if _storage._repeatedFloatWrapper != rhs_storage._repeatedFloatWrapper {return false} + if _storage._repeatedDoubleWrapper != rhs_storage._repeatedDoubleWrapper {return false} + if _storage._repeatedStringWrapper != rhs_storage._repeatedStringWrapper {return false} + if _storage._repeatedBytesWrapper != rhs_storage._repeatedBytesWrapper {return false} + if _storage._optionalDuration != rhs_storage._optionalDuration {return false} + if _storage._optionalTimestamp != rhs_storage._optionalTimestamp {return false} + if _storage._optionalFieldMask != rhs_storage._optionalFieldMask {return false} + if _storage._optionalStruct != rhs_storage._optionalStruct {return false} + if _storage._optionalAny != rhs_storage._optionalAny {return false} + if _storage._optionalValue != rhs_storage._optionalValue {return false} + if _storage._optionalNullValue != rhs_storage._optionalNullValue {return false} + if _storage._repeatedDuration != rhs_storage._repeatedDuration {return false} + if _storage._repeatedTimestamp != rhs_storage._repeatedTimestamp {return false} + if _storage._repeatedFieldmask != rhs_storage._repeatedFieldmask {return false} + if _storage._repeatedStruct != rhs_storage._repeatedStruct {return false} + if _storage._repeatedAny != rhs_storage._repeatedAny {return false} + if _storage._repeatedValue != rhs_storage._repeatedValue {return false} + if _storage._repeatedListValue != rhs_storage._repeatedListValue {return false} + if _storage._fieldname1 != rhs_storage._fieldname1 {return false} + if _storage._fieldName2 != rhs_storage._fieldName2 {return false} + if _storage._fieldName3 != rhs_storage._fieldName3 {return false} + if _storage._field_Name4_ != rhs_storage._field_Name4_ {return false} + if _storage._field0Name5 != rhs_storage._field0Name5 {return false} + if _storage._field0Name6 != rhs_storage._field0Name6 {return false} + if _storage._fieldName7 != rhs_storage._fieldName7 {return false} + if _storage._fieldName8 != rhs_storage._fieldName8 {return false} + if _storage._fieldName9 != rhs_storage._fieldName9 {return false} + if _storage._fieldName10 != rhs_storage._fieldName10 {return false} + if _storage._fieldName11 != rhs_storage._fieldName11 {return false} + if _storage._fieldName12 != rhs_storage._fieldName12 {return false} + if _storage.__FieldName13 != rhs_storage.__FieldName13 {return false} + if _storage.__FieldName14 != rhs_storage.__FieldName14 {return false} + if _storage._field_Name15 != rhs_storage._field_Name15 {return false} + if _storage._field_Name16 != rhs_storage._field_Name16 {return false} + if _storage._fieldName17__ != rhs_storage._fieldName17__ {return false} + if _storage._fieldName18__ != rhs_storage._fieldName18__ {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Test3_TestAllTypesProto3.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32 = 0 + var _corecursive: SwiftProtoTesting_Test3_TestAllTypesProto3? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + default: break + } + } + } + } + + func traverse(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 + if _storage._a != 0 { + try visitor.visitSingularInt32Field(value: _storage._a, fieldNumber: 1) + } + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage, rhs: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/Tests/SwiftProtobufTests/unittest.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest.pb.swift new file mode 100644 index 000000000..025b39a54 --- /dev/null +++ b/Reference/Tests/SwiftProtobufTests/unittest.pb.swift @@ -0,0 +1,6131 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: unittest.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// A proto file we will use for unit testing. +// +// LINT: ALLOW_GROUPS, LEGACY_NAMES + +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 SwiftProtoTesting_ForeignEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foreignFoo = 4 + case foreignBar = 5 + case foreignBaz = 6 + + init() { + self = .foreignFoo + } + +} + +/// Test an enum that has multiple values with the same number. +enum SwiftProtoTesting_TestEnumWithDupValue: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo1 = 1 + case bar1 = 2 + case baz = 3 + static let foo2 = foo1 + static let bar2 = bar1 + + init() { + self = .foo1 + } + +} + +/// This proto includes every type of field in both singular and repeated +/// forms. +struct SwiftProtoTesting_TestAllTypes: @unchecked Sendable { + // 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. + + /// Singular + var optionalInt32: Int32 { + get {_storage._optionalInt32 ?? 0} + set {_uniqueStorage()._optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} + + var optionalInt64: Int64 { + get {_storage._optionalInt64 ?? 0} + set {_uniqueStorage()._optionalInt64 = newValue} + } + /// Returns true if `optionalInt64` has been explicitly set. + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} + /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} + + var optionalUint32: UInt32 { + get {_storage._optionalUint32 ?? 0} + set {_uniqueStorage()._optionalUint32 = newValue} + } + /// Returns true if `optionalUint32` has been explicitly set. + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} + /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} + + var optionalUint64: UInt64 { + get {_storage._optionalUint64 ?? 0} + set {_uniqueStorage()._optionalUint64 = newValue} + } + /// Returns true if `optionalUint64` has been explicitly set. + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} + /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} + + var optionalSint32: Int32 { + get {_storage._optionalSint32 ?? 0} + set {_uniqueStorage()._optionalSint32 = newValue} + } + /// Returns true if `optionalSint32` has been explicitly set. + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} + /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} + + var optionalSint64: Int64 { + get {_storage._optionalSint64 ?? 0} + set {_uniqueStorage()._optionalSint64 = newValue} + } + /// Returns true if `optionalSint64` has been explicitly set. + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} + /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} + + var optionalFixed32: UInt32 { + get {_storage._optionalFixed32 ?? 0} + set {_uniqueStorage()._optionalFixed32 = newValue} + } + /// Returns true if `optionalFixed32` has been explicitly set. + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} + /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} + + var optionalFixed64: UInt64 { + get {_storage._optionalFixed64 ?? 0} + set {_uniqueStorage()._optionalFixed64 = newValue} + } + /// Returns true if `optionalFixed64` has been explicitly set. + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} + /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} + + var optionalSfixed32: Int32 { + get {_storage._optionalSfixed32 ?? 0} + set {_uniqueStorage()._optionalSfixed32 = newValue} + } + /// Returns true if `optionalSfixed32` has been explicitly set. + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} + /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} + + var optionalSfixed64: Int64 { + get {_storage._optionalSfixed64 ?? 0} + set {_uniqueStorage()._optionalSfixed64 = newValue} + } + /// Returns true if `optionalSfixed64` has been explicitly set. + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} + /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} + + var optionalFloat: Float { + get {_storage._optionalFloat ?? 0} + set {_uniqueStorage()._optionalFloat = newValue} + } + /// Returns true if `optionalFloat` has been explicitly set. + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} + /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} + + var optionalDouble: Double { + get {_storage._optionalDouble ?? 0} + set {_uniqueStorage()._optionalDouble = newValue} + } + /// Returns true if `optionalDouble` has been explicitly set. + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} + /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. + mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} + + var optionalBool: Bool { + get {_storage._optionalBool ?? false} + set {_uniqueStorage()._optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {_storage._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} + + var optionalString: String { + get {_storage._optionalString ?? String()} + set {_uniqueStorage()._optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {_storage._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} + + var optionalBytes: Data { + get {_storage._optionalBytes ?? Data()} + set {_uniqueStorage()._optionalBytes = newValue} + } + /// Returns true if `optionalBytes` has been explicitly set. + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} + /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} + + var optionalGroup: SwiftProtoTesting_TestAllTypes.OptionalGroup { + get {_storage._optionalGroup ?? SwiftProtoTesting_TestAllTypes.OptionalGroup()} + set {_uniqueStorage()._optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {_storage._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {_uniqueStorage()._optionalGroup = nil} + + var optionalNestedMessage: SwiftProtoTesting_TestAllTypes.NestedMessage { + get {_storage._optionalNestedMessage ?? SwiftProtoTesting_TestAllTypes.NestedMessage()} + set {_uniqueStorage()._optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} + + var optionalForeignMessage: SwiftProtoTesting_ForeignMessage { + get {_storage._optionalForeignMessage ?? SwiftProtoTesting_ForeignMessage()} + set {_uniqueStorage()._optionalForeignMessage = newValue} + } + /// Returns true if `optionalForeignMessage` has been explicitly set. + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} + /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} + + var optionalImportMessage: SwiftProtoTesting_Import_ImportMessage { + get {_storage._optionalImportMessage ?? SwiftProtoTesting_Import_ImportMessage()} + set {_uniqueStorage()._optionalImportMessage = newValue} + } + /// Returns true if `optionalImportMessage` has been explicitly set. + var hasOptionalImportMessage: Bool {_storage._optionalImportMessage != nil} + /// Clears the value of `optionalImportMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalImportMessage() {_uniqueStorage()._optionalImportMessage = nil} + + var optionalNestedEnum: SwiftProtoTesting_TestAllTypes.NestedEnum { + get {_storage._optionalNestedEnum ?? .foo} + set {_uniqueStorage()._optionalNestedEnum = newValue} + } + /// Returns true if `optionalNestedEnum` has been explicitly set. + var hasOptionalNestedEnum: Bool {_storage._optionalNestedEnum != nil} + /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} + + var optionalForeignEnum: SwiftProtoTesting_ForeignEnum { + get {_storage._optionalForeignEnum ?? .foreignFoo} + set {_uniqueStorage()._optionalForeignEnum = newValue} + } + /// Returns true if `optionalForeignEnum` has been explicitly set. + var hasOptionalForeignEnum: Bool {_storage._optionalForeignEnum != nil} + /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignEnum() {_uniqueStorage()._optionalForeignEnum = nil} + + var optionalImportEnum: SwiftProtoTesting_Import_ImportEnum { + get {_storage._optionalImportEnum ?? .importFoo} + set {_uniqueStorage()._optionalImportEnum = newValue} + } + /// Returns true if `optionalImportEnum` has been explicitly set. + var hasOptionalImportEnum: Bool {_storage._optionalImportEnum != nil} + /// Clears the value of `optionalImportEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalImportEnum() {_uniqueStorage()._optionalImportEnum = nil} + + /// Defined in unittest_import_public.proto + var optionalPublicImportMessage: SwiftProtoTesting_Import_PublicImportMessage { + get {_storage._optionalPublicImportMessage ?? SwiftProtoTesting_Import_PublicImportMessage()} + set {_uniqueStorage()._optionalPublicImportMessage = newValue} + } + /// Returns true if `optionalPublicImportMessage` has been explicitly set. + var hasOptionalPublicImportMessage: Bool {_storage._optionalPublicImportMessage != nil} + /// Clears the value of `optionalPublicImportMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalPublicImportMessage() {_uniqueStorage()._optionalPublicImportMessage = nil} + + /// Repeated + var repeatedInt32: [Int32] { + get {_storage._repeatedInt32} + set {_uniqueStorage()._repeatedInt32 = newValue} + } + + var repeatedInt64: [Int64] { + get {_storage._repeatedInt64} + set {_uniqueStorage()._repeatedInt64 = newValue} + } + + var repeatedUint32: [UInt32] { + get {_storage._repeatedUint32} + set {_uniqueStorage()._repeatedUint32 = newValue} + } + + var repeatedUint64: [UInt64] { + get {_storage._repeatedUint64} + set {_uniqueStorage()._repeatedUint64 = newValue} + } + + var repeatedSint32: [Int32] { + get {_storage._repeatedSint32} + set {_uniqueStorage()._repeatedSint32 = newValue} + } + + var repeatedSint64: [Int64] { + get {_storage._repeatedSint64} + set {_uniqueStorage()._repeatedSint64 = newValue} + } + + var repeatedFixed32: [UInt32] { + get {_storage._repeatedFixed32} + set {_uniqueStorage()._repeatedFixed32 = newValue} + } + + var repeatedFixed64: [UInt64] { + get {_storage._repeatedFixed64} + set {_uniqueStorage()._repeatedFixed64 = newValue} + } + + var repeatedSfixed32: [Int32] { + get {_storage._repeatedSfixed32} + set {_uniqueStorage()._repeatedSfixed32 = newValue} + } + + var repeatedSfixed64: [Int64] { + get {_storage._repeatedSfixed64} + set {_uniqueStorage()._repeatedSfixed64 = newValue} + } + + var repeatedFloat: [Float] { + get {_storage._repeatedFloat} + set {_uniqueStorage()._repeatedFloat = newValue} + } + + var repeatedDouble: [Double] { + get {_storage._repeatedDouble} + set {_uniqueStorage()._repeatedDouble = newValue} + } + + var repeatedBool: [Bool] { + get {_storage._repeatedBool} + set {_uniqueStorage()._repeatedBool = newValue} + } + + var repeatedString: [String] { + get {_storage._repeatedString} + set {_uniqueStorage()._repeatedString = newValue} + } + + var repeatedBytes: [Data] { + get {_storage._repeatedBytes} + set {_uniqueStorage()._repeatedBytes = newValue} + } + + var repeatedGroup: [SwiftProtoTesting_TestAllTypes.RepeatedGroup] { + get {_storage._repeatedGroup} + set {_uniqueStorage()._repeatedGroup = newValue} + } + + var repeatedNestedMessage: [SwiftProtoTesting_TestAllTypes.NestedMessage] { + get {_storage._repeatedNestedMessage} + set {_uniqueStorage()._repeatedNestedMessage = newValue} + } + + var repeatedForeignMessage: [SwiftProtoTesting_ForeignMessage] { + get {_storage._repeatedForeignMessage} + set {_uniqueStorage()._repeatedForeignMessage = newValue} + } + + var repeatedImportMessage: [SwiftProtoTesting_Import_ImportMessage] { + get {_storage._repeatedImportMessage} + set {_uniqueStorage()._repeatedImportMessage = newValue} + } + + var repeatedNestedEnum: [SwiftProtoTesting_TestAllTypes.NestedEnum] { + get {_storage._repeatedNestedEnum} + set {_uniqueStorage()._repeatedNestedEnum = newValue} + } + + var repeatedForeignEnum: [SwiftProtoTesting_ForeignEnum] { + get {_storage._repeatedForeignEnum} + set {_uniqueStorage()._repeatedForeignEnum = newValue} + } + + var repeatedImportEnum: [SwiftProtoTesting_Import_ImportEnum] { + get {_storage._repeatedImportEnum} + set {_uniqueStorage()._repeatedImportEnum = newValue} + } + + /// Singular with defaults + var defaultInt32: Int32 { + get {_storage._defaultInt32 ?? 41} + set {_uniqueStorage()._defaultInt32 = newValue} + } + /// Returns true if `defaultInt32` has been explicitly set. + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} + /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} + + var defaultInt64: Int64 { + get {_storage._defaultInt64 ?? 42} + set {_uniqueStorage()._defaultInt64 = newValue} + } + /// Returns true if `defaultInt64` has been explicitly set. + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} + /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} + + var defaultUint32: UInt32 { + get {_storage._defaultUint32 ?? 43} + set {_uniqueStorage()._defaultUint32 = newValue} + } + /// Returns true if `defaultUint32` has been explicitly set. + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} + /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} + + var defaultUint64: UInt64 { + get {_storage._defaultUint64 ?? 44} + set {_uniqueStorage()._defaultUint64 = newValue} + } + /// Returns true if `defaultUint64` has been explicitly set. + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} + /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} + + var defaultSint32: Int32 { + get {_storage._defaultSint32 ?? -45} + set {_uniqueStorage()._defaultSint32 = newValue} + } + /// Returns true if `defaultSint32` has been explicitly set. + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} + /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} + + var defaultSint64: Int64 { + get {_storage._defaultSint64 ?? 46} + set {_uniqueStorage()._defaultSint64 = newValue} + } + /// Returns true if `defaultSint64` has been explicitly set. + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} + /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} + + var defaultFixed32: UInt32 { + get {_storage._defaultFixed32 ?? 47} + set {_uniqueStorage()._defaultFixed32 = newValue} + } + /// Returns true if `defaultFixed32` has been explicitly set. + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} + /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} + + var defaultFixed64: UInt64 { + get {_storage._defaultFixed64 ?? 48} + set {_uniqueStorage()._defaultFixed64 = newValue} + } + /// Returns true if `defaultFixed64` has been explicitly set. + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} + /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} + + var defaultSfixed32: Int32 { + get {_storage._defaultSfixed32 ?? 49} + set {_uniqueStorage()._defaultSfixed32 = newValue} + } + /// Returns true if `defaultSfixed32` has been explicitly set. + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} + /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} + + var defaultSfixed64: Int64 { + get {_storage._defaultSfixed64 ?? -50} + set {_uniqueStorage()._defaultSfixed64 = newValue} + } + /// Returns true if `defaultSfixed64` has been explicitly set. + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} + /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} + + var defaultFloat: Float { + get {_storage._defaultFloat ?? 51.5} + set {_uniqueStorage()._defaultFloat = newValue} + } + /// Returns true if `defaultFloat` has been explicitly set. + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} + /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. + mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} + + var defaultDouble: Double { + get {_storage._defaultDouble ?? 52000} + set {_uniqueStorage()._defaultDouble = newValue} + } + /// Returns true if `defaultDouble` has been explicitly set. + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} + /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. + mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} + + var defaultBool: Bool { + get {_storage._defaultBool ?? true} + set {_uniqueStorage()._defaultBool = newValue} + } + /// Returns true if `defaultBool` has been explicitly set. + var hasDefaultBool: Bool {_storage._defaultBool != nil} + /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. + mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} + + var defaultString: String { + get {_storage._defaultString ?? "hello"} + set {_uniqueStorage()._defaultString = newValue} + } + /// Returns true if `defaultString` has been explicitly set. + var hasDefaultString: Bool {_storage._defaultString != nil} + /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. + mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} + + var defaultBytes: Data { + get {_storage._defaultBytes ?? Data([119, 111, 114, 108, 100])} + set {_uniqueStorage()._defaultBytes = newValue} + } + /// Returns true if `defaultBytes` has been explicitly set. + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} + /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. + mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} + + var defaultNestedEnum: SwiftProtoTesting_TestAllTypes.NestedEnum { + get {_storage._defaultNestedEnum ?? .bar} + set {_uniqueStorage()._defaultNestedEnum = newValue} + } + /// Returns true if `defaultNestedEnum` has been explicitly set. + var hasDefaultNestedEnum: Bool {_storage._defaultNestedEnum != nil} + /// Clears the value of `defaultNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearDefaultNestedEnum() {_uniqueStorage()._defaultNestedEnum = nil} + + var defaultForeignEnum: SwiftProtoTesting_ForeignEnum { + get {_storage._defaultForeignEnum ?? .foreignBar} + set {_uniqueStorage()._defaultForeignEnum = newValue} + } + /// Returns true if `defaultForeignEnum` has been explicitly set. + var hasDefaultForeignEnum: Bool {_storage._defaultForeignEnum != nil} + /// Clears the value of `defaultForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearDefaultForeignEnum() {_uniqueStorage()._defaultForeignEnum = nil} + + var defaultImportEnum: SwiftProtoTesting_Import_ImportEnum { + get {_storage._defaultImportEnum ?? .importBar} + set {_uniqueStorage()._defaultImportEnum = newValue} + } + /// Returns true if `defaultImportEnum` has been explicitly set. + var hasDefaultImportEnum: Bool {_storage._defaultImportEnum != nil} + /// Clears the value of `defaultImportEnum`. Subsequent reads from it will return its default value. + mutating func clearDefaultImportEnum() {_uniqueStorage()._defaultImportEnum = nil} + + /// For oneof test + var oneofField: OneOf_OneofField? { + get {return _storage._oneofField} + set {_uniqueStorage()._oneofField = newValue} + } + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} + } + + var oneofNestedMessage: SwiftProtoTesting_TestAllTypes.NestedMessage { + get { + if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} + return SwiftProtoTesting_TestAllTypes.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = _storage._oneofField {return v} + return Data() + } + set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + /// For oneof test + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofNestedMessage(SwiftProtoTesting_TestAllTypes.NestedMessage) + case oneofString(String) + case oneofBytes(Data) + + } + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 1 + case bar = 2 + case baz = 3 + + /// Intentionally negative. + case neg = -1 + + init() { + self = .foo + } + + } + + struct NestedMessage: Sendable { + // 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. + + /// The field name "b" fails to compile in proto1 because it conflicts with + /// a local variable named "b" in one of the generated methods. Doh. + /// This file needs to compile in proto1 to test backwards-compatibility. + var bb: Int32 { + get {_bb ?? 0} + set {_bb = newValue} + } + /// Returns true if `bb` has been explicitly set. + var hasBb: Bool {self._bb != nil} + /// Clears the value of `bb`. Subsequent reads from it will return its default value. + mutating func clearBb() {self._bb = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _bb: Int32? = nil + } + + struct OptionalGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + struct RepeatedGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// This proto includes a recursively nested message. +struct SwiftProtoTesting_NestedTestAllTypes: @unchecked Sendable { + // 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 child: SwiftProtoTesting_NestedTestAllTypes { + get {_storage._child ?? SwiftProtoTesting_NestedTestAllTypes()} + set {_uniqueStorage()._child = newValue} + } + /// Returns true if `child` has been explicitly set. + var hasChild: Bool {_storage._child != nil} + /// Clears the value of `child`. Subsequent reads from it will return its default value. + mutating func clearChild() {_uniqueStorage()._child = nil} + + var payload: SwiftProtoTesting_TestAllTypes { + get {_storage._payload ?? SwiftProtoTesting_TestAllTypes()} + set {_uniqueStorage()._payload = newValue} + } + /// Returns true if `payload` has been explicitly set. + var hasPayload: Bool {_storage._payload != nil} + /// Clears the value of `payload`. Subsequent reads from it will return its default value. + mutating func clearPayload() {_uniqueStorage()._payload = nil} + + var repeatedChild: [SwiftProtoTesting_NestedTestAllTypes] { + get {_storage._repeatedChild} + set {_uniqueStorage()._repeatedChild = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// Define these after TestAllTypes to make sure the compiler can handle +/// that. +struct SwiftProtoTesting_ForeignMessage: Sendable { + // 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 c: Int32 { + get {_c ?? 0} + set {_c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {self._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {self._c = nil} + + var d: Int32 { + get {_d ?? 0} + set {_d = newValue} + } + /// Returns true if `d` has been explicitly set. + var hasD: Bool {self._d != nil} + /// Clears the value of `d`. Subsequent reads from it will return its default value. + mutating func clearD() {self._d = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _c: Int32? = nil + fileprivate var _d: Int32? = nil +} + +struct SwiftProtoTesting_TestAllExtensions: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +struct SwiftProtoTesting_OptionalGroup_extension: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil +} + +struct SwiftProtoTesting_RepeatedGroup_extension: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil +} + +struct SwiftProtoTesting_TestNestedExtension: Sendable { + // 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() {} +} + +/// We have separate messages for testing required fields because it's +/// annoying to have to fill in required fields in TestProto in order to +/// do anything with it. Note that we don't need to test every type of +/// required filed because the code output is basically identical to +/// optional fields for all types. +struct SwiftProtoTesting_TestRequired: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var dummy2: Int32 { + get {_storage._dummy2 ?? 0} + set {_uniqueStorage()._dummy2 = newValue} + } + /// Returns true if `dummy2` has been explicitly set. + var hasDummy2: Bool {_storage._dummy2 != nil} + /// Clears the value of `dummy2`. Subsequent reads from it will return its default value. + mutating func clearDummy2() {_uniqueStorage()._dummy2 = nil} + + var b: Int32 { + get {_storage._b ?? 0} + set {_uniqueStorage()._b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {_storage._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {_uniqueStorage()._b = nil} + + /// Pad the field count to 32 so that we can test that IsInitialized() + /// properly checks multiple elements of has_bits_. + var dummy4: Int32 { + get {_storage._dummy4 ?? 0} + set {_uniqueStorage()._dummy4 = newValue} + } + /// Returns true if `dummy4` has been explicitly set. + var hasDummy4: Bool {_storage._dummy4 != nil} + /// Clears the value of `dummy4`. Subsequent reads from it will return its default value. + mutating func clearDummy4() {_uniqueStorage()._dummy4 = nil} + + var dummy5: Int32 { + get {_storage._dummy5 ?? 0} + set {_uniqueStorage()._dummy5 = newValue} + } + /// Returns true if `dummy5` has been explicitly set. + var hasDummy5: Bool {_storage._dummy5 != nil} + /// Clears the value of `dummy5`. Subsequent reads from it will return its default value. + mutating func clearDummy5() {_uniqueStorage()._dummy5 = nil} + + var dummy6: Int32 { + get {_storage._dummy6 ?? 0} + set {_uniqueStorage()._dummy6 = newValue} + } + /// Returns true if `dummy6` has been explicitly set. + var hasDummy6: Bool {_storage._dummy6 != nil} + /// Clears the value of `dummy6`. Subsequent reads from it will return its default value. + mutating func clearDummy6() {_uniqueStorage()._dummy6 = nil} + + var dummy7: Int32 { + get {_storage._dummy7 ?? 0} + set {_uniqueStorage()._dummy7 = newValue} + } + /// Returns true if `dummy7` has been explicitly set. + var hasDummy7: Bool {_storage._dummy7 != nil} + /// Clears the value of `dummy7`. Subsequent reads from it will return its default value. + mutating func clearDummy7() {_uniqueStorage()._dummy7 = nil} + + var dummy8: Int32 { + get {_storage._dummy8 ?? 0} + set {_uniqueStorage()._dummy8 = newValue} + } + /// Returns true if `dummy8` has been explicitly set. + var hasDummy8: Bool {_storage._dummy8 != nil} + /// Clears the value of `dummy8`. Subsequent reads from it will return its default value. + mutating func clearDummy8() {_uniqueStorage()._dummy8 = nil} + + var dummy9: Int32 { + get {_storage._dummy9 ?? 0} + set {_uniqueStorage()._dummy9 = newValue} + } + /// Returns true if `dummy9` has been explicitly set. + var hasDummy9: Bool {_storage._dummy9 != nil} + /// Clears the value of `dummy9`. Subsequent reads from it will return its default value. + mutating func clearDummy9() {_uniqueStorage()._dummy9 = nil} + + var dummy10: Int32 { + get {_storage._dummy10 ?? 0} + set {_uniqueStorage()._dummy10 = newValue} + } + /// Returns true if `dummy10` has been explicitly set. + var hasDummy10: Bool {_storage._dummy10 != nil} + /// Clears the value of `dummy10`. Subsequent reads from it will return its default value. + mutating func clearDummy10() {_uniqueStorage()._dummy10 = nil} + + var dummy11: Int32 { + get {_storage._dummy11 ?? 0} + set {_uniqueStorage()._dummy11 = newValue} + } + /// Returns true if `dummy11` has been explicitly set. + var hasDummy11: Bool {_storage._dummy11 != nil} + /// Clears the value of `dummy11`. Subsequent reads from it will return its default value. + mutating func clearDummy11() {_uniqueStorage()._dummy11 = nil} + + var dummy12: Int32 { + get {_storage._dummy12 ?? 0} + set {_uniqueStorage()._dummy12 = newValue} + } + /// Returns true if `dummy12` has been explicitly set. + var hasDummy12: Bool {_storage._dummy12 != nil} + /// Clears the value of `dummy12`. Subsequent reads from it will return its default value. + mutating func clearDummy12() {_uniqueStorage()._dummy12 = nil} + + var dummy13: Int32 { + get {_storage._dummy13 ?? 0} + set {_uniqueStorage()._dummy13 = newValue} + } + /// Returns true if `dummy13` has been explicitly set. + var hasDummy13: Bool {_storage._dummy13 != nil} + /// Clears the value of `dummy13`. Subsequent reads from it will return its default value. + mutating func clearDummy13() {_uniqueStorage()._dummy13 = nil} + + var dummy14: Int32 { + get {_storage._dummy14 ?? 0} + set {_uniqueStorage()._dummy14 = newValue} + } + /// Returns true if `dummy14` has been explicitly set. + var hasDummy14: Bool {_storage._dummy14 != nil} + /// Clears the value of `dummy14`. Subsequent reads from it will return its default value. + mutating func clearDummy14() {_uniqueStorage()._dummy14 = nil} + + var dummy15: Int32 { + get {_storage._dummy15 ?? 0} + set {_uniqueStorage()._dummy15 = newValue} + } + /// Returns true if `dummy15` has been explicitly set. + var hasDummy15: Bool {_storage._dummy15 != nil} + /// Clears the value of `dummy15`. Subsequent reads from it will return its default value. + mutating func clearDummy15() {_uniqueStorage()._dummy15 = nil} + + var dummy16: Int32 { + get {_storage._dummy16 ?? 0} + set {_uniqueStorage()._dummy16 = newValue} + } + /// Returns true if `dummy16` has been explicitly set. + var hasDummy16: Bool {_storage._dummy16 != nil} + /// Clears the value of `dummy16`. Subsequent reads from it will return its default value. + mutating func clearDummy16() {_uniqueStorage()._dummy16 = nil} + + var dummy17: Int32 { + get {_storage._dummy17 ?? 0} + set {_uniqueStorage()._dummy17 = newValue} + } + /// Returns true if `dummy17` has been explicitly set. + var hasDummy17: Bool {_storage._dummy17 != nil} + /// Clears the value of `dummy17`. Subsequent reads from it will return its default value. + mutating func clearDummy17() {_uniqueStorage()._dummy17 = nil} + + var dummy18: Int32 { + get {_storage._dummy18 ?? 0} + set {_uniqueStorage()._dummy18 = newValue} + } + /// Returns true if `dummy18` has been explicitly set. + var hasDummy18: Bool {_storage._dummy18 != nil} + /// Clears the value of `dummy18`. Subsequent reads from it will return its default value. + mutating func clearDummy18() {_uniqueStorage()._dummy18 = nil} + + var dummy19: Int32 { + get {_storage._dummy19 ?? 0} + set {_uniqueStorage()._dummy19 = newValue} + } + /// Returns true if `dummy19` has been explicitly set. + var hasDummy19: Bool {_storage._dummy19 != nil} + /// Clears the value of `dummy19`. Subsequent reads from it will return its default value. + mutating func clearDummy19() {_uniqueStorage()._dummy19 = nil} + + var dummy20: Int32 { + get {_storage._dummy20 ?? 0} + set {_uniqueStorage()._dummy20 = newValue} + } + /// Returns true if `dummy20` has been explicitly set. + var hasDummy20: Bool {_storage._dummy20 != nil} + /// Clears the value of `dummy20`. Subsequent reads from it will return its default value. + mutating func clearDummy20() {_uniqueStorage()._dummy20 = nil} + + var dummy21: Int32 { + get {_storage._dummy21 ?? 0} + set {_uniqueStorage()._dummy21 = newValue} + } + /// Returns true if `dummy21` has been explicitly set. + var hasDummy21: Bool {_storage._dummy21 != nil} + /// Clears the value of `dummy21`. Subsequent reads from it will return its default value. + mutating func clearDummy21() {_uniqueStorage()._dummy21 = nil} + + var dummy22: Int32 { + get {_storage._dummy22 ?? 0} + set {_uniqueStorage()._dummy22 = newValue} + } + /// Returns true if `dummy22` has been explicitly set. + var hasDummy22: Bool {_storage._dummy22 != nil} + /// Clears the value of `dummy22`. Subsequent reads from it will return its default value. + mutating func clearDummy22() {_uniqueStorage()._dummy22 = nil} + + var dummy23: Int32 { + get {_storage._dummy23 ?? 0} + set {_uniqueStorage()._dummy23 = newValue} + } + /// Returns true if `dummy23` has been explicitly set. + var hasDummy23: Bool {_storage._dummy23 != nil} + /// Clears the value of `dummy23`. Subsequent reads from it will return its default value. + mutating func clearDummy23() {_uniqueStorage()._dummy23 = nil} + + var dummy24: Int32 { + get {_storage._dummy24 ?? 0} + set {_uniqueStorage()._dummy24 = newValue} + } + /// Returns true if `dummy24` has been explicitly set. + var hasDummy24: Bool {_storage._dummy24 != nil} + /// Clears the value of `dummy24`. Subsequent reads from it will return its default value. + mutating func clearDummy24() {_uniqueStorage()._dummy24 = nil} + + var dummy25: Int32 { + get {_storage._dummy25 ?? 0} + set {_uniqueStorage()._dummy25 = newValue} + } + /// Returns true if `dummy25` has been explicitly set. + var hasDummy25: Bool {_storage._dummy25 != nil} + /// Clears the value of `dummy25`. Subsequent reads from it will return its default value. + mutating func clearDummy25() {_uniqueStorage()._dummy25 = nil} + + var dummy26: Int32 { + get {_storage._dummy26 ?? 0} + set {_uniqueStorage()._dummy26 = newValue} + } + /// Returns true if `dummy26` has been explicitly set. + var hasDummy26: Bool {_storage._dummy26 != nil} + /// Clears the value of `dummy26`. Subsequent reads from it will return its default value. + mutating func clearDummy26() {_uniqueStorage()._dummy26 = nil} + + var dummy27: Int32 { + get {_storage._dummy27 ?? 0} + set {_uniqueStorage()._dummy27 = newValue} + } + /// Returns true if `dummy27` has been explicitly set. + var hasDummy27: Bool {_storage._dummy27 != nil} + /// Clears the value of `dummy27`. Subsequent reads from it will return its default value. + mutating func clearDummy27() {_uniqueStorage()._dummy27 = nil} + + var dummy28: Int32 { + get {_storage._dummy28 ?? 0} + set {_uniqueStorage()._dummy28 = newValue} + } + /// Returns true if `dummy28` has been explicitly set. + var hasDummy28: Bool {_storage._dummy28 != nil} + /// Clears the value of `dummy28`. Subsequent reads from it will return its default value. + mutating func clearDummy28() {_uniqueStorage()._dummy28 = nil} + + var dummy29: Int32 { + get {_storage._dummy29 ?? 0} + set {_uniqueStorage()._dummy29 = newValue} + } + /// Returns true if `dummy29` has been explicitly set. + var hasDummy29: Bool {_storage._dummy29 != nil} + /// Clears the value of `dummy29`. Subsequent reads from it will return its default value. + mutating func clearDummy29() {_uniqueStorage()._dummy29 = nil} + + var dummy30: Int32 { + get {_storage._dummy30 ?? 0} + set {_uniqueStorage()._dummy30 = newValue} + } + /// Returns true if `dummy30` has been explicitly set. + var hasDummy30: Bool {_storage._dummy30 != nil} + /// Clears the value of `dummy30`. Subsequent reads from it will return its default value. + mutating func clearDummy30() {_uniqueStorage()._dummy30 = nil} + + var dummy31: Int32 { + get {_storage._dummy31 ?? 0} + set {_uniqueStorage()._dummy31 = newValue} + } + /// Returns true if `dummy31` has been explicitly set. + var hasDummy31: Bool {_storage._dummy31 != nil} + /// Clears the value of `dummy31`. Subsequent reads from it will return its default value. + mutating func clearDummy31() {_uniqueStorage()._dummy31 = nil} + + var dummy32: Int32 { + get {_storage._dummy32 ?? 0} + set {_uniqueStorage()._dummy32 = newValue} + } + /// Returns true if `dummy32` has been explicitly set. + var hasDummy32: Bool {_storage._dummy32 != nil} + /// Clears the value of `dummy32`. Subsequent reads from it will return its default value. + mutating func clearDummy32() {_uniqueStorage()._dummy32 = nil} + + var c: Int32 { + get {_storage._c ?? 0} + set {_uniqueStorage()._c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {_storage._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {_uniqueStorage()._c = nil} + + var optionalForeign: SwiftProtoTesting_ForeignMessage { + get {_storage._optionalForeign ?? SwiftProtoTesting_ForeignMessage()} + set {_uniqueStorage()._optionalForeign = newValue} + } + /// Returns true if `optionalForeign` has been explicitly set. + var hasOptionalForeign: Bool {_storage._optionalForeign != nil} + /// Clears the value of `optionalForeign`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeign() {_uniqueStorage()._optionalForeign = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct SwiftProtoTesting_TestRequiredForeign: Sendable { + // 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 optionalMessage: SwiftProtoTesting_TestRequired { + get {_optionalMessage ?? SwiftProtoTesting_TestRequired()} + set {_optionalMessage = newValue} + } + /// Returns true if `optionalMessage` has been explicitly set. + var hasOptionalMessage: Bool {self._optionalMessage != nil} + /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalMessage() {self._optionalMessage = nil} + + var repeatedMessage: [SwiftProtoTesting_TestRequired] = [] + + var dummy: Int32 { + get {_dummy ?? 0} + set {_dummy = newValue} + } + /// Returns true if `dummy` has been explicitly set. + var hasDummy: Bool {self._dummy != nil} + /// Clears the value of `dummy`. Subsequent reads from it will return its default value. + mutating func clearDummy() {self._dummy = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalMessage: SwiftProtoTesting_TestRequired? = nil + fileprivate var _dummy: Int32? = nil +} + +struct SwiftProtoTesting_TestRequiredMessage: Sendable { + // 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 optionalMessage: SwiftProtoTesting_TestRequired { + get {_optionalMessage ?? SwiftProtoTesting_TestRequired()} + set {_optionalMessage = newValue} + } + /// Returns true if `optionalMessage` has been explicitly set. + var hasOptionalMessage: Bool {self._optionalMessage != nil} + /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalMessage() {self._optionalMessage = nil} + + var repeatedMessage: [SwiftProtoTesting_TestRequired] = [] + + var requiredMessage: SwiftProtoTesting_TestRequired { + get {_requiredMessage ?? SwiftProtoTesting_TestRequired()} + set {_requiredMessage = newValue} + } + /// Returns true if `requiredMessage` has been explicitly set. + var hasRequiredMessage: Bool {self._requiredMessage != nil} + /// Clears the value of `requiredMessage`. Subsequent reads from it will return its default value. + mutating func clearRequiredMessage() {self._requiredMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalMessage: SwiftProtoTesting_TestRequired? = nil + fileprivate var _requiredMessage: SwiftProtoTesting_TestRequired? = nil +} + +/// TestEmptyMessage is used to test unknown field support. +struct SwiftProtoTesting_TestEmptyMessage: Sendable { + // 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() {} +} + +/// Test that really large tag numbers don't break anything. +struct SwiftProtoTesting_TestReallyLargeTagNumber: Sendable { + // 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. + + /// The largest possible tag number is 2^28 - 1, since the wire format uses + /// three bits to communicate wire type. + var a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var bb: Int32 { + get {_bb ?? 0} + set {_bb = newValue} + } + /// Returns true if `bb` has been explicitly set. + var hasBb: Bool {self._bb != nil} + /// Clears the value of `bb`. Subsequent reads from it will return its default value. + mutating func clearBb() {self._bb = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _bb: Int32? = nil +} + +struct SwiftProtoTesting_TestRecursiveMessage: @unchecked Sendable { + // 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 a: SwiftProtoTesting_TestRecursiveMessage { + get {_storage._a ?? SwiftProtoTesting_TestRecursiveMessage()} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var i: Int32 { + get {_storage._i ?? 0} + set {_uniqueStorage()._i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {_storage._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {_uniqueStorage()._i = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// We list fields out of order, to ensure that we're using field number and not +/// field index to determine serialization order. +struct SwiftProtoTesting_TestFieldOrderings: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 myString: String { + get {_myString ?? String()} + set {_myString = newValue} + } + /// Returns true if `myString` has been explicitly set. + var hasMyString: Bool {self._myString != nil} + /// Clears the value of `myString`. Subsequent reads from it will return its default value. + mutating func clearMyString() {self._myString = nil} + + var myInt: Int64 { + get {_myInt ?? 0} + set {_myInt = newValue} + } + /// Returns true if `myInt` has been explicitly set. + var hasMyInt: Bool {self._myInt != nil} + /// Clears the value of `myInt`. Subsequent reads from it will return its default value. + mutating func clearMyInt() {self._myInt = nil} + + var myFloat: Float { + get {_myFloat ?? 0} + set {_myFloat = newValue} + } + /// Returns true if `myFloat` has been explicitly set. + var hasMyFloat: Bool {self._myFloat != nil} + /// Clears the value of `myFloat`. Subsequent reads from it will return its default value. + mutating func clearMyFloat() {self._myFloat = nil} + + var optionalNestedMessage: SwiftProtoTesting_TestFieldOrderings.NestedMessage { + get {_optionalNestedMessage ?? SwiftProtoTesting_TestFieldOrderings.NestedMessage()} + set {_optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {self._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {self._optionalNestedMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct NestedMessage: Sendable { + // 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 oo: Int64 { + get {_oo ?? 0} + set {_oo = newValue} + } + /// Returns true if `oo` has been explicitly set. + var hasOo: Bool {self._oo != nil} + /// Clears the value of `oo`. Subsequent reads from it will return its default value. + mutating func clearOo() {self._oo = nil} + + /// The field name "b" fails to compile in proto1 because it conflicts with + /// a local variable named "b" in one of the generated methods. Doh. + /// This file needs to compile in proto1 to test backwards-compatibility. + var bb: Int32 { + get {_bb ?? 0} + set {_bb = newValue} + } + /// Returns true if `bb` has been explicitly set. + var hasBb: Bool {self._bb != nil} + /// Clears the value of `bb`. Subsequent reads from it will return its default value. + mutating func clearBb() {self._bb = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _oo: Int64? = nil + fileprivate var _bb: Int32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _myString: String? = nil + fileprivate var _myInt: Int64? = nil + fileprivate var _myFloat: Float? = nil + fileprivate var _optionalNestedMessage: SwiftProtoTesting_TestFieldOrderings.NestedMessage? = nil +} + +struct SwiftProtoTesting_TestExtremeDefaultValues: @unchecked Sendable { + // 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 escapedBytes: Data { + get {_storage._escapedBytes ?? Data([0, 1, 7, 8, 12, 10, 13, 9, 11, 92, 39, 34, 254])} + set {_uniqueStorage()._escapedBytes = newValue} + } + /// Returns true if `escapedBytes` has been explicitly set. + var hasEscapedBytes: Bool {_storage._escapedBytes != nil} + /// Clears the value of `escapedBytes`. Subsequent reads from it will return its default value. + mutating func clearEscapedBytes() {_uniqueStorage()._escapedBytes = nil} + + var largeUint32: UInt32 { + get {_storage._largeUint32 ?? 4294967295} + set {_uniqueStorage()._largeUint32 = newValue} + } + /// Returns true if `largeUint32` has been explicitly set. + var hasLargeUint32: Bool {_storage._largeUint32 != nil} + /// Clears the value of `largeUint32`. Subsequent reads from it will return its default value. + mutating func clearLargeUint32() {_uniqueStorage()._largeUint32 = nil} + + var largeUint64: UInt64 { + get {_storage._largeUint64 ?? 18446744073709551615} + set {_uniqueStorage()._largeUint64 = newValue} + } + /// Returns true if `largeUint64` has been explicitly set. + var hasLargeUint64: Bool {_storage._largeUint64 != nil} + /// Clears the value of `largeUint64`. Subsequent reads from it will return its default value. + mutating func clearLargeUint64() {_uniqueStorage()._largeUint64 = nil} + + var smallInt32: Int32 { + get {_storage._smallInt32 ?? -2147483647} + set {_uniqueStorage()._smallInt32 = newValue} + } + /// Returns true if `smallInt32` has been explicitly set. + var hasSmallInt32: Bool {_storage._smallInt32 != nil} + /// Clears the value of `smallInt32`. Subsequent reads from it will return its default value. + mutating func clearSmallInt32() {_uniqueStorage()._smallInt32 = nil} + + var smallInt64: Int64 { + get {_storage._smallInt64 ?? -9223372036854775807} + set {_uniqueStorage()._smallInt64 = newValue} + } + /// Returns true if `smallInt64` has been explicitly set. + var hasSmallInt64: Bool {_storage._smallInt64 != nil} + /// Clears the value of `smallInt64`. Subsequent reads from it will return its default value. + mutating func clearSmallInt64() {_uniqueStorage()._smallInt64 = nil} + + var reallySmallInt32: Int32 { + get {_storage._reallySmallInt32 ?? -2147483648} + set {_uniqueStorage()._reallySmallInt32 = newValue} + } + /// Returns true if `reallySmallInt32` has been explicitly set. + var hasReallySmallInt32: Bool {_storage._reallySmallInt32 != nil} + /// Clears the value of `reallySmallInt32`. Subsequent reads from it will return its default value. + mutating func clearReallySmallInt32() {_uniqueStorage()._reallySmallInt32 = nil} + + var reallySmallInt64: Int64 { + get {_storage._reallySmallInt64 ?? -9223372036854775808} + set {_uniqueStorage()._reallySmallInt64 = newValue} + } + /// Returns true if `reallySmallInt64` has been explicitly set. + var hasReallySmallInt64: Bool {_storage._reallySmallInt64 != nil} + /// Clears the value of `reallySmallInt64`. Subsequent reads from it will return its default value. + mutating func clearReallySmallInt64() {_uniqueStorage()._reallySmallInt64 = nil} + + /// The default value here is UTF-8 for "\u1234". (We could also just type + /// the UTF-8 text directly into this text file rather than escape it, but + /// lots of people use editors that would be confused by this.) + var utf8String: String { + get {_storage._utf8String ?? "ሴ"} + set {_uniqueStorage()._utf8String = newValue} + } + /// Returns true if `utf8String` has been explicitly set. + var hasUtf8String: Bool {_storage._utf8String != nil} + /// Clears the value of `utf8String`. Subsequent reads from it will return its default value. + mutating func clearUtf8String() {_uniqueStorage()._utf8String = nil} + + /// Tests for single-precision floating-point values. + var zeroFloat: Float { + get {_storage._zeroFloat ?? 0} + set {_uniqueStorage()._zeroFloat = newValue} + } + /// Returns true if `zeroFloat` has been explicitly set. + var hasZeroFloat: Bool {_storage._zeroFloat != nil} + /// Clears the value of `zeroFloat`. Subsequent reads from it will return its default value. + mutating func clearZeroFloat() {_uniqueStorage()._zeroFloat = nil} + + var oneFloat: Float { + get {_storage._oneFloat ?? 1} + set {_uniqueStorage()._oneFloat = newValue} + } + /// Returns true if `oneFloat` has been explicitly set. + var hasOneFloat: Bool {_storage._oneFloat != nil} + /// Clears the value of `oneFloat`. Subsequent reads from it will return its default value. + mutating func clearOneFloat() {_uniqueStorage()._oneFloat = nil} + + var smallFloat: Float { + get {_storage._smallFloat ?? 1.5} + set {_uniqueStorage()._smallFloat = newValue} + } + /// Returns true if `smallFloat` has been explicitly set. + var hasSmallFloat: Bool {_storage._smallFloat != nil} + /// Clears the value of `smallFloat`. Subsequent reads from it will return its default value. + mutating func clearSmallFloat() {_uniqueStorage()._smallFloat = nil} + + var negativeOneFloat: Float { + get {_storage._negativeOneFloat ?? -1} + set {_uniqueStorage()._negativeOneFloat = newValue} + } + /// Returns true if `negativeOneFloat` has been explicitly set. + var hasNegativeOneFloat: Bool {_storage._negativeOneFloat != nil} + /// Clears the value of `negativeOneFloat`. Subsequent reads from it will return its default value. + mutating func clearNegativeOneFloat() {_uniqueStorage()._negativeOneFloat = nil} + + var negativeFloat: Float { + get {_storage._negativeFloat ?? -1.5} + set {_uniqueStorage()._negativeFloat = newValue} + } + /// Returns true if `negativeFloat` has been explicitly set. + var hasNegativeFloat: Bool {_storage._negativeFloat != nil} + /// Clears the value of `negativeFloat`. Subsequent reads from it will return its default value. + mutating func clearNegativeFloat() {_uniqueStorage()._negativeFloat = nil} + + /// Using exponents + var largeFloat: Float { + get {_storage._largeFloat ?? 2e+08} + set {_uniqueStorage()._largeFloat = newValue} + } + /// Returns true if `largeFloat` has been explicitly set. + var hasLargeFloat: Bool {_storage._largeFloat != nil} + /// Clears the value of `largeFloat`. Subsequent reads from it will return its default value. + mutating func clearLargeFloat() {_uniqueStorage()._largeFloat = nil} + + var smallNegativeFloat: Float { + get {_storage._smallNegativeFloat ?? -8e-28} + set {_uniqueStorage()._smallNegativeFloat = newValue} + } + /// Returns true if `smallNegativeFloat` has been explicitly set. + var hasSmallNegativeFloat: Bool {_storage._smallNegativeFloat != nil} + /// Clears the value of `smallNegativeFloat`. Subsequent reads from it will return its default value. + mutating func clearSmallNegativeFloat() {_uniqueStorage()._smallNegativeFloat = nil} + + /// Text for nonfinite floating-point values. + var infDouble: Double { + get {_storage._infDouble ?? Double.infinity} + set {_uniqueStorage()._infDouble = newValue} + } + /// Returns true if `infDouble` has been explicitly set. + var hasInfDouble: Bool {_storage._infDouble != nil} + /// Clears the value of `infDouble`. Subsequent reads from it will return its default value. + mutating func clearInfDouble() {_uniqueStorage()._infDouble = nil} + + var negInfDouble: Double { + get {_storage._negInfDouble ?? -Double.infinity} + set {_uniqueStorage()._negInfDouble = newValue} + } + /// Returns true if `negInfDouble` has been explicitly set. + var hasNegInfDouble: Bool {_storage._negInfDouble != nil} + /// Clears the value of `negInfDouble`. Subsequent reads from it will return its default value. + mutating func clearNegInfDouble() {_uniqueStorage()._negInfDouble = nil} + + var nanDouble: Double { + get {_storage._nanDouble ?? Double.nan} + set {_uniqueStorage()._nanDouble = newValue} + } + /// Returns true if `nanDouble` has been explicitly set. + var hasNanDouble: Bool {_storage._nanDouble != nil} + /// Clears the value of `nanDouble`. Subsequent reads from it will return its default value. + mutating func clearNanDouble() {_uniqueStorage()._nanDouble = nil} + + var infFloat: Float { + get {_storage._infFloat ?? Float.infinity} + set {_uniqueStorage()._infFloat = newValue} + } + /// Returns true if `infFloat` has been explicitly set. + var hasInfFloat: Bool {_storage._infFloat != nil} + /// Clears the value of `infFloat`. Subsequent reads from it will return its default value. + mutating func clearInfFloat() {_uniqueStorage()._infFloat = nil} + + var negInfFloat: Float { + get {_storage._negInfFloat ?? -Float.infinity} + set {_uniqueStorage()._negInfFloat = newValue} + } + /// Returns true if `negInfFloat` has been explicitly set. + var hasNegInfFloat: Bool {_storage._negInfFloat != nil} + /// Clears the value of `negInfFloat`. Subsequent reads from it will return its default value. + mutating func clearNegInfFloat() {_uniqueStorage()._negInfFloat = nil} + + var nanFloat: Float { + get {_storage._nanFloat ?? Float.nan} + set {_uniqueStorage()._nanFloat = newValue} + } + /// Returns true if `nanFloat` has been explicitly set. + var hasNanFloat: Bool {_storage._nanFloat != nil} + /// Clears the value of `nanFloat`. Subsequent reads from it will return its default value. + mutating func clearNanFloat() {_uniqueStorage()._nanFloat = nil} + + /// Tests for C++ trigraphs. + /// Trigraphs should be escaped in C++ generated files, but they should not be + /// escaped for other languages. + /// Note that in .proto file, "\?" is a valid way to escape ? in string + /// literals. + var cppTrigraph: String { + get {_storage._cppTrigraph ?? "? ? ?? ?? ??? ??/ ??-"} + set {_uniqueStorage()._cppTrigraph = newValue} + } + /// Returns true if `cppTrigraph` has been explicitly set. + var hasCppTrigraph: Bool {_storage._cppTrigraph != nil} + /// Clears the value of `cppTrigraph`. Subsequent reads from it will return its default value. + mutating func clearCppTrigraph() {_uniqueStorage()._cppTrigraph = nil} + + /// String defaults containing the character '\000' + var stringWithZero: String { + get {_storage._stringWithZero ?? "hel\0lo"} + set {_uniqueStorage()._stringWithZero = newValue} + } + /// Returns true if `stringWithZero` has been explicitly set. + var hasStringWithZero: Bool {_storage._stringWithZero != nil} + /// Clears the value of `stringWithZero`. Subsequent reads from it will return its default value. + mutating func clearStringWithZero() {_uniqueStorage()._stringWithZero = nil} + + var bytesWithZero: Data { + get {_storage._bytesWithZero ?? Data([119, 111, 114, 0, 108, 100])} + set {_uniqueStorage()._bytesWithZero = newValue} + } + /// Returns true if `bytesWithZero` has been explicitly set. + var hasBytesWithZero: Bool {_storage._bytesWithZero != nil} + /// Clears the value of `bytesWithZero`. Subsequent reads from it will return its default value. + mutating func clearBytesWithZero() {_uniqueStorage()._bytesWithZero = nil} + + var replacementString: String { + get {_storage._replacementString ?? "${unknown}"} + set {_uniqueStorage()._replacementString = newValue} + } + /// Returns true if `replacementString` has been explicitly set. + var hasReplacementString: Bool {_storage._replacementString != nil} + /// Clears the value of `replacementString`. Subsequent reads from it will return its default value. + mutating func clearReplacementString() {_uniqueStorage()._replacementString = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// Test oneofs. +struct SwiftProtoTesting_TestOneof: Sendable { + // 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 foo: SwiftProtoTesting_TestOneof.OneOf_Foo? = nil + + var fooInt: Int32 { + get { + if case .fooInt(let v)? = foo {return v} + return 0 + } + set {foo = .fooInt(newValue)} + } + + var fooString: String { + get { + if case .fooString(let v)? = foo {return v} + return String() + } + set {foo = .fooString(newValue)} + } + + var fooMessage: SwiftProtoTesting_TestAllTypes { + get { + if case .fooMessage(let v)? = foo {return v} + return SwiftProtoTesting_TestAllTypes() + } + set {foo = .fooMessage(newValue)} + } + + var fooGroup: SwiftProtoTesting_TestOneof.FooGroup { + get { + if case .fooGroup(let v)? = foo {return v} + return SwiftProtoTesting_TestOneof.FooGroup() + } + set {foo = .fooGroup(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_Foo: Equatable, Sendable { + case fooInt(Int32) + case fooString(String) + case fooMessage(SwiftProtoTesting_TestAllTypes) + case fooGroup(SwiftProtoTesting_TestOneof.FooGroup) + + } + + struct FooGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: String { + get {_b ?? String()} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: String? = nil + } + + init() {} +} + +struct SwiftProtoTesting_TestRequiredOneof: Sendable { + // 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 foo: SwiftProtoTesting_TestRequiredOneof.OneOf_Foo? = nil + + var fooInt: Int32 { + get { + if case .fooInt(let v)? = foo {return v} + return 0 + } + set {foo = .fooInt(newValue)} + } + + var fooString: String { + get { + if case .fooString(let v)? = foo {return v} + return String() + } + set {foo = .fooString(newValue)} + } + + var fooMessage: SwiftProtoTesting_TestRequiredOneof.NestedMessage { + get { + if case .fooMessage(let v)? = foo {return v} + return SwiftProtoTesting_TestRequiredOneof.NestedMessage() + } + set {foo = .fooMessage(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_Foo: Equatable, Sendable { + case fooInt(Int32) + case fooString(String) + case fooMessage(SwiftProtoTesting_TestRequiredOneof.NestedMessage) + + fileprivate var isInitialized: Bool { + guard case .fooMessage(let v) = self else {return true} + return v.isInitialized + } + + } + + struct NestedMessage: Sendable { + // 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 requiredDouble: Double { + get {_requiredDouble ?? 0} + set {_requiredDouble = newValue} + } + /// Returns true if `requiredDouble` has been explicitly set. + var hasRequiredDouble: Bool {self._requiredDouble != nil} + /// Clears the value of `requiredDouble`. Subsequent reads from it will return its default value. + mutating func clearRequiredDouble() {self._requiredDouble = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _requiredDouble: Double? = nil + } + + init() {} +} + +struct SwiftProtoTesting_TestPackedTypes: Sendable { + // 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 packedInt32: [Int32] = [] + + var packedInt64: [Int64] = [] + + var packedUint32: [UInt32] = [] + + var packedUint64: [UInt64] = [] + + var packedSint32: [Int32] = [] + + var packedSint64: [Int64] = [] + + var packedFixed32: [UInt32] = [] + + var packedFixed64: [UInt64] = [] + + var packedSfixed32: [Int32] = [] + + var packedSfixed64: [Int64] = [] + + var packedFloat: [Float] = [] + + var packedDouble: [Double] = [] + + var packedBool: [Bool] = [] + + var packedEnum: [SwiftProtoTesting_ForeignEnum] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +/// A message with the same fields as TestPackedTypes, but without packing. Used +/// to test packed <-> unpacked wire compatibility. +struct SwiftProtoTesting_TestUnpackedTypes: Sendable { + // 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 unpackedInt32: [Int32] = [] + + var unpackedInt64: [Int64] = [] + + var unpackedUint32: [UInt32] = [] + + var unpackedUint64: [UInt64] = [] + + var unpackedSint32: [Int32] = [] + + var unpackedSint64: [Int64] = [] + + var unpackedFixed32: [UInt32] = [] + + var unpackedFixed64: [UInt64] = [] + + var unpackedSfixed32: [Int32] = [] + + var unpackedSfixed64: [Int64] = [] + + var unpackedFloat: [Float] = [] + + var unpackedDouble: [Double] = [] + + var unpackedBool: [Bool] = [] + + var unpackedEnum: [SwiftProtoTesting_ForeignEnum] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct SwiftProtoTesting_TestPackedExtensions: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +/// Test that if an optional or required message/group field appears multiple +/// times in the input, they need to be merged. +struct SwiftProtoTesting_TestParsingMerge: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 requiredAllTypes: SwiftProtoTesting_TestAllTypes { + get {_requiredAllTypes ?? SwiftProtoTesting_TestAllTypes()} + set {_requiredAllTypes = newValue} + } + /// Returns true if `requiredAllTypes` has been explicitly set. + var hasRequiredAllTypes: Bool {self._requiredAllTypes != nil} + /// Clears the value of `requiredAllTypes`. Subsequent reads from it will return its default value. + mutating func clearRequiredAllTypes() {self._requiredAllTypes = nil} + + var optionalAllTypes: SwiftProtoTesting_TestAllTypes { + get {_optionalAllTypes ?? SwiftProtoTesting_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [SwiftProtoTesting_TestAllTypes] = [] + + var optionalGroup: SwiftProtoTesting_TestParsingMerge.OptionalGroup { + get {_optionalGroup ?? SwiftProtoTesting_TestParsingMerge.OptionalGroup()} + set {_optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {self._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {self._optionalGroup = nil} + + var repeatedGroup: [SwiftProtoTesting_TestParsingMerge.RepeatedGroup] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + /// RepeatedFieldsGenerator defines matching field types as TestParsingMerge, + /// except that all fields are repeated. In the tests, we will serialize the + /// RepeatedFieldsGenerator to bytes, and parse the bytes to TestParsingMerge. + /// Repeated fields in RepeatedFieldsGenerator are expected to be merged into + /// the corresponding required/optional fields in TestParsingMerge. + struct RepeatedFieldsGenerator: Sendable { + // 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: [SwiftProtoTesting_TestAllTypes] = [] + + var field2: [SwiftProtoTesting_TestAllTypes] = [] + + var field3: [SwiftProtoTesting_TestAllTypes] = [] + + var group1: [SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group1] = [] + + var group2: [SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group2] = [] + + var ext1: [SwiftProtoTesting_TestAllTypes] = [] + + var ext2: [SwiftProtoTesting_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct Group1: Sendable { + // 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: SwiftProtoTesting_TestAllTypes { + get {_field1 ?? SwiftProtoTesting_TestAllTypes()} + set {_field1 = newValue} + } + /// Returns true if `field1` has been explicitly set. + var hasField1: Bool {self._field1 != nil} + /// Clears the value of `field1`. Subsequent reads from it will return its default value. + mutating func clearField1() {self._field1 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _field1: SwiftProtoTesting_TestAllTypes? = nil + } + + struct Group2: Sendable { + // 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: SwiftProtoTesting_TestAllTypes { + get {_field1 ?? SwiftProtoTesting_TestAllTypes()} + set {_field1 = newValue} + } + /// Returns true if `field1` has been explicitly set. + var hasField1: Bool {self._field1 != nil} + /// Clears the value of `field1`. Subsequent reads from it will return its default value. + mutating func clearField1() {self._field1 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _field1: SwiftProtoTesting_TestAllTypes? = nil + } + + init() {} + } + + struct OptionalGroup: Sendable { + // 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 optionalGroupAllTypes: SwiftProtoTesting_TestAllTypes { + get {_optionalGroupAllTypes ?? SwiftProtoTesting_TestAllTypes()} + set {_optionalGroupAllTypes = newValue} + } + /// Returns true if `optionalGroupAllTypes` has been explicitly set. + var hasOptionalGroupAllTypes: Bool {self._optionalGroupAllTypes != nil} + /// Clears the value of `optionalGroupAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroupAllTypes() {self._optionalGroupAllTypes = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalGroupAllTypes: SwiftProtoTesting_TestAllTypes? = nil + } + + struct RepeatedGroup: Sendable { + // 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 repeatedGroupAllTypes: SwiftProtoTesting_TestAllTypes { + get {_repeatedGroupAllTypes ?? SwiftProtoTesting_TestAllTypes()} + set {_repeatedGroupAllTypes = newValue} + } + /// Returns true if `repeatedGroupAllTypes` has been explicitly set. + var hasRepeatedGroupAllTypes: Bool {self._repeatedGroupAllTypes != nil} + /// Clears the value of `repeatedGroupAllTypes`. Subsequent reads from it will return its default value. + mutating func clearRepeatedGroupAllTypes() {self._repeatedGroupAllTypes = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _repeatedGroupAllTypes: SwiftProtoTesting_TestAllTypes? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _requiredAllTypes: SwiftProtoTesting_TestAllTypes? = nil + fileprivate var _optionalAllTypes: SwiftProtoTesting_TestAllTypes? = nil + fileprivate var _optionalGroup: SwiftProtoTesting_TestParsingMerge.OptionalGroup? = nil +} + +// MARK: - Extension support defined in unittest.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 SwiftProtoTesting_TestAllExtensions { + + /// Singular + var SwiftProtoTesting_optionalInt32Extension: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_int32_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_int32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_int32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalInt32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_int32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_int32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalInt32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_int32_extension) + } + + var SwiftProtoTesting_optionalInt64Extension: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_int64_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_int64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_int64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalInt64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_int64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_int64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalInt64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_int64_extension) + } + + var SwiftProtoTesting_optionalUint32Extension: UInt32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_uint32_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_uint32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_uint32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalUint32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_uint32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_uint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalUint32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_uint32_extension) + } + + var SwiftProtoTesting_optionalUint64Extension: UInt64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_uint64_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_uint64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_uint64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalUint64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_uint64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_uint64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalUint64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_uint64_extension) + } + + var SwiftProtoTesting_optionalSint32Extension: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sint32_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sint32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_sint32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalSint32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sint32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_sint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalSint32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sint32_extension) + } + + var SwiftProtoTesting_optionalSint64Extension: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sint64_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sint64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_sint64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalSint64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sint64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_sint64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalSint64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sint64_extension) + } + + var SwiftProtoTesting_optionalFixed32Extension: UInt32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_fixed32_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_fixed32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_fixed32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalFixed32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_fixed32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_fixed32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalFixed32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_fixed32_extension) + } + + var SwiftProtoTesting_optionalFixed64Extension: UInt64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_fixed64_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_fixed64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_fixed64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalFixed64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_fixed64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_fixed64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalFixed64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_fixed64_extension) + } + + var SwiftProtoTesting_optionalSfixed32Extension: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sfixed32_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sfixed32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_sfixed32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalSfixed32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sfixed32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_sfixed32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalSfixed32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sfixed32_extension) + } + + var SwiftProtoTesting_optionalSfixed64Extension: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sfixed64_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sfixed64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_sfixed64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalSfixed64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sfixed64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_sfixed64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalSfixed64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sfixed64_extension) + } + + var SwiftProtoTesting_optionalFloatExtension: Float { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_float_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_float_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_float_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalFloatExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_float_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_float_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalFloatExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_float_extension) + } + + var SwiftProtoTesting_optionalDoubleExtension: Double { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_double_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_double_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_double_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalDoubleExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_double_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_double_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalDoubleExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_double_extension) + } + + var SwiftProtoTesting_optionalBoolExtension: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_bool_extension) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_bool_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_bool_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalBoolExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_bool_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_bool_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalBoolExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_bool_extension) + } + + var SwiftProtoTesting_optionalStringExtension: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_string_extension) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_string_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_string_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalStringExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_string_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_string_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalStringExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_string_extension) + } + + var SwiftProtoTesting_optionalBytesExtension: Data { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_bytes_extension) ?? Data()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_bytes_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_bytes_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalBytesExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_bytes_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_bytes_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalBytesExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_bytes_extension) + } + + var SwiftProtoTesting_optionalGroupExtension: SwiftProtoTesting_OptionalGroup_extension { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_OptionalGroup_extension) ?? SwiftProtoTesting_OptionalGroup_extension()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_OptionalGroup_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_OptionalGroup_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalGroupExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_OptionalGroup_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_OptionalGroup_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalGroupExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_OptionalGroup_extension) + } + + var SwiftProtoTesting_optionalNestedMessageExtension: SwiftProtoTesting_TestAllTypes.NestedMessage { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_nested_message_extension) ?? SwiftProtoTesting_TestAllTypes.NestedMessage()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_nested_message_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_nested_message_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalNestedMessageExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_nested_message_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_nested_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalNestedMessageExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_nested_message_extension) + } + + var SwiftProtoTesting_optionalForeignMessageExtension: SwiftProtoTesting_ForeignMessage { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_foreign_message_extension) ?? SwiftProtoTesting_ForeignMessage()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_foreign_message_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_foreign_message_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalForeignMessageExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_foreign_message_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_foreign_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalForeignMessageExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_foreign_message_extension) + } + + var SwiftProtoTesting_optionalImportMessageExtension: SwiftProtoTesting_Import_ImportMessage { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_import_message_extension) ?? SwiftProtoTesting_Import_ImportMessage()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_import_message_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_import_message_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalImportMessageExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_import_message_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_import_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalImportMessageExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_import_message_extension) + } + + var SwiftProtoTesting_optionalNestedEnumExtension: SwiftProtoTesting_TestAllTypes.NestedEnum { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_nested_enum_extension) ?? .foo} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_nested_enum_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_nested_enum_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalNestedEnumExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_nested_enum_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_nested_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalNestedEnumExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_nested_enum_extension) + } + + var SwiftProtoTesting_optionalForeignEnumExtension: SwiftProtoTesting_ForeignEnum { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_foreign_enum_extension) ?? .foreignFoo} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_foreign_enum_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_foreign_enum_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalForeignEnumExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_foreign_enum_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_foreign_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalForeignEnumExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_foreign_enum_extension) + } + + var SwiftProtoTesting_optionalImportEnumExtension: SwiftProtoTesting_Import_ImportEnum { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_import_enum_extension) ?? .importFoo} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_import_enum_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_import_enum_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalImportEnumExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_import_enum_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_import_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalImportEnumExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_import_enum_extension) + } + + var SwiftProtoTesting_optionalPublicImportMessageExtension: SwiftProtoTesting_Import_PublicImportMessage { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_public_import_message_extension) ?? SwiftProtoTesting_Import_PublicImportMessage()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_public_import_message_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_public_import_message_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalPublicImportMessageExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_public_import_message_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_public_import_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalPublicImportMessageExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_public_import_message_extension) + } + + /// Repeated + var SwiftProtoTesting_repeatedInt32Extension: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_int32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_int32_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedInt64Extension: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_int64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_int64_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedUint32Extension: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_uint32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_uint32_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedUint64Extension: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_uint64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_uint64_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedSint32Extension: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_sint32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_sint32_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedSint64Extension: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_sint64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_sint64_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedFixed32Extension: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_fixed32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_fixed32_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedFixed64Extension: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_fixed64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_fixed64_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedSfixed32Extension: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_sfixed32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_sfixed32_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedSfixed64Extension: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_sfixed64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_sfixed64_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedFloatExtension: [Float] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_float_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_float_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedDoubleExtension: [Double] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_double_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_double_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedBoolExtension: [Bool] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_bool_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_bool_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedStringExtension: [String] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_string_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_string_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedBytesExtension: [Data] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_bytes_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_bytes_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedGroupExtension: [SwiftProtoTesting_RepeatedGroup_extension] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_RepeatedGroup_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_RepeatedGroup_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedNestedMessageExtension: [SwiftProtoTesting_TestAllTypes.NestedMessage] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_nested_message_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_nested_message_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedForeignMessageExtension: [SwiftProtoTesting_ForeignMessage] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_foreign_message_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_foreign_message_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedImportMessageExtension: [SwiftProtoTesting_Import_ImportMessage] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_import_message_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_import_message_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedNestedEnumExtension: [SwiftProtoTesting_TestAllTypes.NestedEnum] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_nested_enum_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_nested_enum_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedForeignEnumExtension: [SwiftProtoTesting_ForeignEnum] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_foreign_enum_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_foreign_enum_extension, value: newValue)} + } + + var SwiftProtoTesting_repeatedImportEnumExtension: [SwiftProtoTesting_Import_ImportEnum] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_import_enum_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_import_enum_extension, value: newValue)} + } + + /// Singular with defaults + var SwiftProtoTesting_defaultInt32Extension: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_int32_extension) ?? 41} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_int32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_int32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultInt32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_int32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_int32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultInt32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_int32_extension) + } + + var SwiftProtoTesting_defaultInt64Extension: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_int64_extension) ?? 42} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_int64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_int64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultInt64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_int64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_int64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultInt64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_int64_extension) + } + + var SwiftProtoTesting_defaultUint32Extension: UInt32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_uint32_extension) ?? 43} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_uint32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_uint32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultUint32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_uint32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_uint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultUint32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_uint32_extension) + } + + var SwiftProtoTesting_defaultUint64Extension: UInt64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_uint64_extension) ?? 44} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_uint64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_uint64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultUint64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_uint64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_uint64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultUint64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_uint64_extension) + } + + var SwiftProtoTesting_defaultSint32Extension: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_sint32_extension) ?? -45} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_sint32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_sint32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultSint32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_sint32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_sint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultSint32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_sint32_extension) + } + + var SwiftProtoTesting_defaultSint64Extension: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_sint64_extension) ?? 46} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_sint64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_sint64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultSint64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_sint64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_sint64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultSint64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_sint64_extension) + } + + var SwiftProtoTesting_defaultFixed32Extension: UInt32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_fixed32_extension) ?? 47} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_fixed32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_fixed32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultFixed32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_fixed32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_fixed32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultFixed32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_fixed32_extension) + } + + var SwiftProtoTesting_defaultFixed64Extension: UInt64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_fixed64_extension) ?? 48} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_fixed64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_fixed64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultFixed64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_fixed64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_fixed64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultFixed64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_fixed64_extension) + } + + var SwiftProtoTesting_defaultSfixed32Extension: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_sfixed32_extension) ?? 49} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_sfixed32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_sfixed32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultSfixed32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_sfixed32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_sfixed32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultSfixed32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_sfixed32_extension) + } + + var SwiftProtoTesting_defaultSfixed64Extension: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_sfixed64_extension) ?? -50} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_sfixed64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_sfixed64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultSfixed64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_sfixed64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_sfixed64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultSfixed64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_sfixed64_extension) + } + + var SwiftProtoTesting_defaultFloatExtension: Float { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_float_extension) ?? 51.5} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_float_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_float_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultFloatExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_float_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_float_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultFloatExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_float_extension) + } + + var SwiftProtoTesting_defaultDoubleExtension: Double { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_double_extension) ?? 52000} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_double_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_double_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultDoubleExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_double_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_double_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultDoubleExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_double_extension) + } + + var SwiftProtoTesting_defaultBoolExtension: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_bool_extension) ?? true} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_bool_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_bool_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultBoolExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_bool_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_bool_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultBoolExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_bool_extension) + } + + var SwiftProtoTesting_defaultStringExtension: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_string_extension) ?? "hello"} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_string_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_string_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultStringExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_string_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_string_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultStringExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_string_extension) + } + + var SwiftProtoTesting_defaultBytesExtension: Data { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_bytes_extension) ?? Data([119, 111, 114, 108, 100])} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_bytes_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_bytes_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultBytesExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_bytes_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_bytes_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultBytesExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_bytes_extension) + } + + var SwiftProtoTesting_defaultNestedEnumExtension: SwiftProtoTesting_TestAllTypes.NestedEnum { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_nested_enum_extension) ?? .bar} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_nested_enum_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_nested_enum_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultNestedEnumExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_nested_enum_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_nested_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultNestedEnumExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_nested_enum_extension) + } + + var SwiftProtoTesting_defaultForeignEnumExtension: SwiftProtoTesting_ForeignEnum { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_foreign_enum_extension) ?? .foreignBar} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_foreign_enum_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_foreign_enum_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultForeignEnumExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_foreign_enum_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_foreign_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultForeignEnumExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_foreign_enum_extension) + } + + var SwiftProtoTesting_defaultImportEnumExtension: SwiftProtoTesting_Import_ImportEnum { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_import_enum_extension) ?? .importBar} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_import_enum_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_import_enum_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultImportEnumExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_import_enum_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_import_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultImportEnumExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_import_enum_extension) + } + + /// For oneof test + var SwiftProtoTesting_oneofUint32Extension: UInt32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_uint32_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_uint32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_oneof_uint32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_oneofUint32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_uint32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_oneof_uint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_oneofUint32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_uint32_extension) + } + + var SwiftProtoTesting_oneofNestedMessageExtension: SwiftProtoTesting_TestAllTypes.NestedMessage { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_nested_message_extension) ?? SwiftProtoTesting_TestAllTypes.NestedMessage()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_nested_message_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_oneof_nested_message_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_oneofNestedMessageExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_nested_message_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_oneof_nested_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_oneofNestedMessageExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_nested_message_extension) + } + + var SwiftProtoTesting_oneofStringExtension: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_string_extension) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_string_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_oneof_string_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_oneofStringExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_string_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_oneof_string_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_oneofStringExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_string_extension) + } + + var SwiftProtoTesting_oneofBytesExtension: Data { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_bytes_extension) ?? Data()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_bytes_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_oneof_bytes_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_oneofBytesExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_bytes_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_oneof_bytes_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_oneofBytesExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_bytes_extension) + } + + /// Check for bug where string extensions declared in tested scope did not + /// compile. + var SwiftProtoTesting_TestNestedExtension_test: String { + get {return getExtensionValue(ext: SwiftProtoTesting_TestNestedExtension.Extensions.test) ?? "test"} + set {setExtensionValue(ext: SwiftProtoTesting_TestNestedExtension.Extensions.test, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_TestNestedExtension.Extensions.test` + /// has been explicitly set. + var hasSwiftProtoTesting_TestNestedExtension_test: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_TestNestedExtension.Extensions.test) + } + /// Clears the value of extension `SwiftProtoTesting_TestNestedExtension.Extensions.test`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_TestNestedExtension_test() { + clearExtensionValue(ext: SwiftProtoTesting_TestNestedExtension.Extensions.test) + } + + /// Used to test if generated extension name is correct when there are + /// underscores. + var SwiftProtoTesting_TestNestedExtension_nestedStringExtension: String { + get {return getExtensionValue(ext: SwiftProtoTesting_TestNestedExtension.Extensions.nested_string_extension) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_TestNestedExtension.Extensions.nested_string_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_TestNestedExtension.Extensions.nested_string_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_TestNestedExtension_nestedStringExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_TestNestedExtension.Extensions.nested_string_extension) + } + /// Clears the value of extension `SwiftProtoTesting_TestNestedExtension.Extensions.nested_string_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_TestNestedExtension_nestedStringExtension() { + clearExtensionValue(ext: SwiftProtoTesting_TestNestedExtension.Extensions.nested_string_extension) + } + + var SwiftProtoTesting_TestRequired_single: SwiftProtoTesting_TestRequired { + get {return getExtensionValue(ext: SwiftProtoTesting_TestRequired.Extensions.single) ?? SwiftProtoTesting_TestRequired()} + set {setExtensionValue(ext: SwiftProtoTesting_TestRequired.Extensions.single, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_TestRequired.Extensions.single` + /// has been explicitly set. + var hasSwiftProtoTesting_TestRequired_single: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_TestRequired.Extensions.single) + } + /// Clears the value of extension `SwiftProtoTesting_TestRequired.Extensions.single`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_TestRequired_single() { + clearExtensionValue(ext: SwiftProtoTesting_TestRequired.Extensions.single) + } + + var SwiftProtoTesting_TestRequired_multi: [SwiftProtoTesting_TestRequired] { + get {return getExtensionValue(ext: SwiftProtoTesting_TestRequired.Extensions.multi) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_TestRequired.Extensions.multi, value: newValue)} + } +} + +extension SwiftProtoTesting_TestFieldOrderings { + + var SwiftProtoTesting_myExtensionString: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_my_extension_string) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_my_extension_string, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_my_extension_string` + /// has been explicitly set. + var hasSwiftProtoTesting_myExtensionString: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_my_extension_string) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_my_extension_string`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_myExtensionString() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_my_extension_string) + } + + var SwiftProtoTesting_myExtensionInt: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_my_extension_int) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_my_extension_int, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_my_extension_int` + /// has been explicitly set. + var hasSwiftProtoTesting_myExtensionInt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_my_extension_int) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_my_extension_int`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_myExtensionInt() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_my_extension_int) + } +} + +extension SwiftProtoTesting_TestPackedExtensions { + + var SwiftProtoTesting_packedInt32Extension: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_int32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_int32_extension, value: newValue)} + } + + var SwiftProtoTesting_packedInt64Extension: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_int64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_int64_extension, value: newValue)} + } + + var SwiftProtoTesting_packedUint32Extension: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_uint32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_uint32_extension, value: newValue)} + } + + var SwiftProtoTesting_packedUint64Extension: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_uint64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_uint64_extension, value: newValue)} + } + + var SwiftProtoTesting_packedSint32Extension: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_sint32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_sint32_extension, value: newValue)} + } + + var SwiftProtoTesting_packedSint64Extension: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_sint64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_sint64_extension, value: newValue)} + } + + var SwiftProtoTesting_packedFixed32Extension: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_fixed32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_fixed32_extension, value: newValue)} + } + + var SwiftProtoTesting_packedFixed64Extension: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_fixed64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_fixed64_extension, value: newValue)} + } + + var SwiftProtoTesting_packedSfixed32Extension: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_sfixed32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_sfixed32_extension, value: newValue)} + } + + var SwiftProtoTesting_packedSfixed64Extension: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_sfixed64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_sfixed64_extension, value: newValue)} + } + + var SwiftProtoTesting_packedFloatExtension: [Float] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_float_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_float_extension, value: newValue)} + } + + var SwiftProtoTesting_packedDoubleExtension: [Double] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_double_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_double_extension, value: newValue)} + } + + var SwiftProtoTesting_packedBoolExtension: [Bool] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_bool_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_bool_extension, value: newValue)} + } + + var SwiftProtoTesting_packedEnumExtension: [SwiftProtoTesting_ForeignEnum] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_enum_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_enum_extension, value: newValue)} + } +} + +extension SwiftProtoTesting_TestParsingMerge { + + var SwiftProtoTesting_TestParsingMerge_optionalExt: SwiftProtoTesting_TestAllTypes { + get {return getExtensionValue(ext: SwiftProtoTesting_TestParsingMerge.Extensions.optional_ext) ?? SwiftProtoTesting_TestAllTypes()} + set {setExtensionValue(ext: SwiftProtoTesting_TestParsingMerge.Extensions.optional_ext, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_TestParsingMerge.Extensions.optional_ext` + /// has been explicitly set. + var hasSwiftProtoTesting_TestParsingMerge_optionalExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_TestParsingMerge.Extensions.optional_ext) + } + /// Clears the value of extension `SwiftProtoTesting_TestParsingMerge.Extensions.optional_ext`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_TestParsingMerge_optionalExt() { + clearExtensionValue(ext: SwiftProtoTesting_TestParsingMerge.Extensions.optional_ext) + } + + var SwiftProtoTesting_TestParsingMerge_repeatedExt: [SwiftProtoTesting_TestAllTypes] { + get {return getExtensionValue(ext: SwiftProtoTesting_TestParsingMerge.Extensions.repeated_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_TestParsingMerge.Extensions.repeated_ext, value: newValue)} + } + +} + +// MARK: - File's ExtensionMap: SwiftProtoTesting_Unittest_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 SwiftProtoTesting_Unittest_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Extensions_optional_int32_extension, + SwiftProtoTesting_Extensions_optional_int64_extension, + SwiftProtoTesting_Extensions_optional_uint32_extension, + SwiftProtoTesting_Extensions_optional_uint64_extension, + SwiftProtoTesting_Extensions_optional_sint32_extension, + SwiftProtoTesting_Extensions_optional_sint64_extension, + SwiftProtoTesting_Extensions_optional_fixed32_extension, + SwiftProtoTesting_Extensions_optional_fixed64_extension, + SwiftProtoTesting_Extensions_optional_sfixed32_extension, + SwiftProtoTesting_Extensions_optional_sfixed64_extension, + SwiftProtoTesting_Extensions_optional_float_extension, + SwiftProtoTesting_Extensions_optional_double_extension, + SwiftProtoTesting_Extensions_optional_bool_extension, + SwiftProtoTesting_Extensions_optional_string_extension, + SwiftProtoTesting_Extensions_optional_bytes_extension, + SwiftProtoTesting_Extensions_OptionalGroup_extension, + SwiftProtoTesting_Extensions_optional_nested_message_extension, + SwiftProtoTesting_Extensions_optional_foreign_message_extension, + SwiftProtoTesting_Extensions_optional_import_message_extension, + SwiftProtoTesting_Extensions_optional_nested_enum_extension, + SwiftProtoTesting_Extensions_optional_foreign_enum_extension, + SwiftProtoTesting_Extensions_optional_import_enum_extension, + SwiftProtoTesting_Extensions_optional_public_import_message_extension, + SwiftProtoTesting_Extensions_repeated_int32_extension, + SwiftProtoTesting_Extensions_repeated_int64_extension, + SwiftProtoTesting_Extensions_repeated_uint32_extension, + SwiftProtoTesting_Extensions_repeated_uint64_extension, + SwiftProtoTesting_Extensions_repeated_sint32_extension, + SwiftProtoTesting_Extensions_repeated_sint64_extension, + SwiftProtoTesting_Extensions_repeated_fixed32_extension, + SwiftProtoTesting_Extensions_repeated_fixed64_extension, + SwiftProtoTesting_Extensions_repeated_sfixed32_extension, + SwiftProtoTesting_Extensions_repeated_sfixed64_extension, + SwiftProtoTesting_Extensions_repeated_float_extension, + SwiftProtoTesting_Extensions_repeated_double_extension, + SwiftProtoTesting_Extensions_repeated_bool_extension, + SwiftProtoTesting_Extensions_repeated_string_extension, + SwiftProtoTesting_Extensions_repeated_bytes_extension, + SwiftProtoTesting_Extensions_RepeatedGroup_extension, + SwiftProtoTesting_Extensions_repeated_nested_message_extension, + SwiftProtoTesting_Extensions_repeated_foreign_message_extension, + SwiftProtoTesting_Extensions_repeated_import_message_extension, + SwiftProtoTesting_Extensions_repeated_nested_enum_extension, + SwiftProtoTesting_Extensions_repeated_foreign_enum_extension, + SwiftProtoTesting_Extensions_repeated_import_enum_extension, + SwiftProtoTesting_Extensions_default_int32_extension, + SwiftProtoTesting_Extensions_default_int64_extension, + SwiftProtoTesting_Extensions_default_uint32_extension, + SwiftProtoTesting_Extensions_default_uint64_extension, + SwiftProtoTesting_Extensions_default_sint32_extension, + SwiftProtoTesting_Extensions_default_sint64_extension, + SwiftProtoTesting_Extensions_default_fixed32_extension, + SwiftProtoTesting_Extensions_default_fixed64_extension, + SwiftProtoTesting_Extensions_default_sfixed32_extension, + SwiftProtoTesting_Extensions_default_sfixed64_extension, + SwiftProtoTesting_Extensions_default_float_extension, + SwiftProtoTesting_Extensions_default_double_extension, + SwiftProtoTesting_Extensions_default_bool_extension, + SwiftProtoTesting_Extensions_default_string_extension, + SwiftProtoTesting_Extensions_default_bytes_extension, + SwiftProtoTesting_Extensions_default_nested_enum_extension, + SwiftProtoTesting_Extensions_default_foreign_enum_extension, + SwiftProtoTesting_Extensions_default_import_enum_extension, + SwiftProtoTesting_Extensions_oneof_uint32_extension, + SwiftProtoTesting_Extensions_oneof_nested_message_extension, + SwiftProtoTesting_Extensions_oneof_string_extension, + SwiftProtoTesting_Extensions_oneof_bytes_extension, + SwiftProtoTesting_Extensions_my_extension_string, + SwiftProtoTesting_Extensions_my_extension_int, + SwiftProtoTesting_Extensions_packed_int32_extension, + SwiftProtoTesting_Extensions_packed_int64_extension, + SwiftProtoTesting_Extensions_packed_uint32_extension, + SwiftProtoTesting_Extensions_packed_uint64_extension, + SwiftProtoTesting_Extensions_packed_sint32_extension, + SwiftProtoTesting_Extensions_packed_sint64_extension, + SwiftProtoTesting_Extensions_packed_fixed32_extension, + SwiftProtoTesting_Extensions_packed_fixed64_extension, + SwiftProtoTesting_Extensions_packed_sfixed32_extension, + SwiftProtoTesting_Extensions_packed_sfixed64_extension, + SwiftProtoTesting_Extensions_packed_float_extension, + SwiftProtoTesting_Extensions_packed_double_extension, + SwiftProtoTesting_Extensions_packed_bool_extension, + SwiftProtoTesting_Extensions_packed_enum_extension, + SwiftProtoTesting_TestNestedExtension.Extensions.test, + SwiftProtoTesting_TestNestedExtension.Extensions.nested_string_extension, + SwiftProtoTesting_TestRequired.Extensions.single, + SwiftProtoTesting_TestRequired.Extensions.multi, + SwiftProtoTesting_TestParsingMerge.Extensions.optional_ext, + SwiftProtoTesting_TestParsingMerge.Extensions.repeated_ext +] + +// 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. + +/// Singular +let SwiftProtoTesting_Extensions_optional_int32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 1, + fieldName: "swift_proto_testing.optional_int32_extension" +) + +let SwiftProtoTesting_Extensions_optional_int64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 2, + fieldName: "swift_proto_testing.optional_int64_extension" +) + +let SwiftProtoTesting_Extensions_optional_uint32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 3, + fieldName: "swift_proto_testing.optional_uint32_extension" +) + +let SwiftProtoTesting_Extensions_optional_uint64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 4, + fieldName: "swift_proto_testing.optional_uint64_extension" +) + +let SwiftProtoTesting_Extensions_optional_sint32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 5, + fieldName: "swift_proto_testing.optional_sint32_extension" +) + +let SwiftProtoTesting_Extensions_optional_sint64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 6, + fieldName: "swift_proto_testing.optional_sint64_extension" +) + +let SwiftProtoTesting_Extensions_optional_fixed32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 7, + fieldName: "swift_proto_testing.optional_fixed32_extension" +) + +let SwiftProtoTesting_Extensions_optional_fixed64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 8, + fieldName: "swift_proto_testing.optional_fixed64_extension" +) + +let SwiftProtoTesting_Extensions_optional_sfixed32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 9, + fieldName: "swift_proto_testing.optional_sfixed32_extension" +) + +let SwiftProtoTesting_Extensions_optional_sfixed64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 10, + fieldName: "swift_proto_testing.optional_sfixed64_extension" +) + +let SwiftProtoTesting_Extensions_optional_float_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 11, + fieldName: "swift_proto_testing.optional_float_extension" +) + +let SwiftProtoTesting_Extensions_optional_double_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 12, + fieldName: "swift_proto_testing.optional_double_extension" +) + +let SwiftProtoTesting_Extensions_optional_bool_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 13, + fieldName: "swift_proto_testing.optional_bool_extension" +) + +let SwiftProtoTesting_Extensions_optional_string_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 14, + fieldName: "swift_proto_testing.optional_string_extension" +) + +let SwiftProtoTesting_Extensions_optional_bytes_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 15, + fieldName: "swift_proto_testing.optional_bytes_extension" +) + +let SwiftProtoTesting_Extensions_OptionalGroup_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 16, + fieldName: "swift_proto_testing.optionalgroup_extension" +) + +let SwiftProtoTesting_Extensions_optional_nested_message_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 18, + fieldName: "swift_proto_testing.optional_nested_message_extension" +) + +let SwiftProtoTesting_Extensions_optional_foreign_message_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 19, + fieldName: "swift_proto_testing.optional_foreign_message_extension" +) + +let SwiftProtoTesting_Extensions_optional_import_message_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 20, + fieldName: "swift_proto_testing.optional_import_message_extension" +) + +let SwiftProtoTesting_Extensions_optional_nested_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 21, + fieldName: "swift_proto_testing.optional_nested_enum_extension" +) + +let SwiftProtoTesting_Extensions_optional_foreign_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 22, + fieldName: "swift_proto_testing.optional_foreign_enum_extension" +) + +let SwiftProtoTesting_Extensions_optional_import_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 23, + fieldName: "swift_proto_testing.optional_import_enum_extension" +) + +let SwiftProtoTesting_Extensions_optional_public_import_message_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 26, + fieldName: "swift_proto_testing.optional_public_import_message_extension" +) + +/// Repeated +let SwiftProtoTesting_Extensions_repeated_int32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 31, + fieldName: "swift_proto_testing.repeated_int32_extension" +) + +let SwiftProtoTesting_Extensions_repeated_int64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 32, + fieldName: "swift_proto_testing.repeated_int64_extension" +) + +let SwiftProtoTesting_Extensions_repeated_uint32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 33, + fieldName: "swift_proto_testing.repeated_uint32_extension" +) + +let SwiftProtoTesting_Extensions_repeated_uint64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 34, + fieldName: "swift_proto_testing.repeated_uint64_extension" +) + +let SwiftProtoTesting_Extensions_repeated_sint32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 35, + fieldName: "swift_proto_testing.repeated_sint32_extension" +) + +let SwiftProtoTesting_Extensions_repeated_sint64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 36, + fieldName: "swift_proto_testing.repeated_sint64_extension" +) + +let SwiftProtoTesting_Extensions_repeated_fixed32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 37, + fieldName: "swift_proto_testing.repeated_fixed32_extension" +) + +let SwiftProtoTesting_Extensions_repeated_fixed64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 38, + fieldName: "swift_proto_testing.repeated_fixed64_extension" +) + +let SwiftProtoTesting_Extensions_repeated_sfixed32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 39, + fieldName: "swift_proto_testing.repeated_sfixed32_extension" +) + +let SwiftProtoTesting_Extensions_repeated_sfixed64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 40, + fieldName: "swift_proto_testing.repeated_sfixed64_extension" +) + +let SwiftProtoTesting_Extensions_repeated_float_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 41, + fieldName: "swift_proto_testing.repeated_float_extension" +) + +let SwiftProtoTesting_Extensions_repeated_double_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 42, + fieldName: "swift_proto_testing.repeated_double_extension" +) + +let SwiftProtoTesting_Extensions_repeated_bool_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 43, + fieldName: "swift_proto_testing.repeated_bool_extension" +) + +let SwiftProtoTesting_Extensions_repeated_string_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 44, + fieldName: "swift_proto_testing.repeated_string_extension" +) + +let SwiftProtoTesting_Extensions_repeated_bytes_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 45, + fieldName: "swift_proto_testing.repeated_bytes_extension" +) + +let SwiftProtoTesting_Extensions_RepeatedGroup_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 46, + fieldName: "swift_proto_testing.repeatedgroup_extension" +) + +let SwiftProtoTesting_Extensions_repeated_nested_message_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 48, + fieldName: "swift_proto_testing.repeated_nested_message_extension" +) + +let SwiftProtoTesting_Extensions_repeated_foreign_message_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 49, + fieldName: "swift_proto_testing.repeated_foreign_message_extension" +) + +let SwiftProtoTesting_Extensions_repeated_import_message_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 50, + fieldName: "swift_proto_testing.repeated_import_message_extension" +) + +let SwiftProtoTesting_Extensions_repeated_nested_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 51, + fieldName: "swift_proto_testing.repeated_nested_enum_extension" +) + +let SwiftProtoTesting_Extensions_repeated_foreign_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 52, + fieldName: "swift_proto_testing.repeated_foreign_enum_extension" +) + +let SwiftProtoTesting_Extensions_repeated_import_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 53, + fieldName: "swift_proto_testing.repeated_import_enum_extension" +) + +/// Singular with defaults +let SwiftProtoTesting_Extensions_default_int32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 61, + fieldName: "swift_proto_testing.default_int32_extension" +) + +let SwiftProtoTesting_Extensions_default_int64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 62, + fieldName: "swift_proto_testing.default_int64_extension" +) + +let SwiftProtoTesting_Extensions_default_uint32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 63, + fieldName: "swift_proto_testing.default_uint32_extension" +) + +let SwiftProtoTesting_Extensions_default_uint64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 64, + fieldName: "swift_proto_testing.default_uint64_extension" +) + +let SwiftProtoTesting_Extensions_default_sint32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 65, + fieldName: "swift_proto_testing.default_sint32_extension" +) + +let SwiftProtoTesting_Extensions_default_sint64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 66, + fieldName: "swift_proto_testing.default_sint64_extension" +) + +let SwiftProtoTesting_Extensions_default_fixed32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 67, + fieldName: "swift_proto_testing.default_fixed32_extension" +) + +let SwiftProtoTesting_Extensions_default_fixed64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 68, + fieldName: "swift_proto_testing.default_fixed64_extension" +) + +let SwiftProtoTesting_Extensions_default_sfixed32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 69, + fieldName: "swift_proto_testing.default_sfixed32_extension" +) + +let SwiftProtoTesting_Extensions_default_sfixed64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 70, + fieldName: "swift_proto_testing.default_sfixed64_extension" +) + +let SwiftProtoTesting_Extensions_default_float_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 71, + fieldName: "swift_proto_testing.default_float_extension" +) + +let SwiftProtoTesting_Extensions_default_double_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 72, + fieldName: "swift_proto_testing.default_double_extension" +) + +let SwiftProtoTesting_Extensions_default_bool_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 73, + fieldName: "swift_proto_testing.default_bool_extension" +) + +let SwiftProtoTesting_Extensions_default_string_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 74, + fieldName: "swift_proto_testing.default_string_extension" +) + +let SwiftProtoTesting_Extensions_default_bytes_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 75, + fieldName: "swift_proto_testing.default_bytes_extension" +) + +let SwiftProtoTesting_Extensions_default_nested_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 81, + fieldName: "swift_proto_testing.default_nested_enum_extension" +) + +let SwiftProtoTesting_Extensions_default_foreign_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 82, + fieldName: "swift_proto_testing.default_foreign_enum_extension" +) + +let SwiftProtoTesting_Extensions_default_import_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 83, + fieldName: "swift_proto_testing.default_import_enum_extension" +) + +/// For oneof test +let SwiftProtoTesting_Extensions_oneof_uint32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 111, + fieldName: "swift_proto_testing.oneof_uint32_extension" +) + +let SwiftProtoTesting_Extensions_oneof_nested_message_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 112, + fieldName: "swift_proto_testing.oneof_nested_message_extension" +) + +let SwiftProtoTesting_Extensions_oneof_string_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 113, + fieldName: "swift_proto_testing.oneof_string_extension" +) + +let SwiftProtoTesting_Extensions_oneof_bytes_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 114, + fieldName: "swift_proto_testing.oneof_bytes_extension" +) + +let SwiftProtoTesting_Extensions_my_extension_string = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestFieldOrderings>( + _protobuf_fieldNumber: 50, + fieldName: "swift_proto_testing.my_extension_string" +) + +let SwiftProtoTesting_Extensions_my_extension_int = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestFieldOrderings>( + _protobuf_fieldNumber: 5, + fieldName: "swift_proto_testing.my_extension_int" +) + +let SwiftProtoTesting_Extensions_packed_int32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 90, + fieldName: "swift_proto_testing.packed_int32_extension" +) + +let SwiftProtoTesting_Extensions_packed_int64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 91, + fieldName: "swift_proto_testing.packed_int64_extension" +) + +let SwiftProtoTesting_Extensions_packed_uint32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 92, + fieldName: "swift_proto_testing.packed_uint32_extension" +) + +let SwiftProtoTesting_Extensions_packed_uint64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 93, + fieldName: "swift_proto_testing.packed_uint64_extension" +) + +let SwiftProtoTesting_Extensions_packed_sint32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 94, + fieldName: "swift_proto_testing.packed_sint32_extension" +) + +let SwiftProtoTesting_Extensions_packed_sint64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 95, + fieldName: "swift_proto_testing.packed_sint64_extension" +) + +let SwiftProtoTesting_Extensions_packed_fixed32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 96, + fieldName: "swift_proto_testing.packed_fixed32_extension" +) + +let SwiftProtoTesting_Extensions_packed_fixed64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 97, + fieldName: "swift_proto_testing.packed_fixed64_extension" +) + +let SwiftProtoTesting_Extensions_packed_sfixed32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 98, + fieldName: "swift_proto_testing.packed_sfixed32_extension" +) + +let SwiftProtoTesting_Extensions_packed_sfixed64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 99, + fieldName: "swift_proto_testing.packed_sfixed64_extension" +) + +let SwiftProtoTesting_Extensions_packed_float_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 100, + fieldName: "swift_proto_testing.packed_float_extension" +) + +let SwiftProtoTesting_Extensions_packed_double_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 101, + fieldName: "swift_proto_testing.packed_double_extension" +) + +let SwiftProtoTesting_Extensions_packed_bool_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 102, + fieldName: "swift_proto_testing.packed_bool_extension" +) + +let SwiftProtoTesting_Extensions_packed_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 103, + fieldName: "swift_proto_testing.packed_enum_extension" +) + +extension SwiftProtoTesting_TestNestedExtension { + enum Extensions { + /// Check for bug where string extensions declared in tested scope did not + /// compile. + static let test = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 1002, + fieldName: "swift_proto_testing.TestNestedExtension.test" + ) + + /// Used to test if generated extension name is correct when there are + /// underscores. + static let nested_string_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 1003, + fieldName: "swift_proto_testing.TestNestedExtension.nested_string_extension" + ) + } +} + +extension SwiftProtoTesting_TestRequired { + enum Extensions { + static let single = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 1000, + fieldName: "swift_proto_testing.TestRequired.single" + ) + + static let multi = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 1001, + fieldName: "swift_proto_testing.TestRequired.multi" + ) + } +} + +extension SwiftProtoTesting_TestParsingMerge { + enum Extensions { + static let optional_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestParsingMerge>( + _protobuf_fieldNumber: 1000, + fieldName: "swift_proto_testing.TestParsingMerge.optional_ext" + ) + + static let repeated_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestParsingMerge>( + _protobuf_fieldNumber: 1001, + fieldName: "swift_proto_testing.TestParsingMerge.repeated_ext" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_proto_testing" + +extension SwiftProtoTesting_ForeignEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{4}FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") +} + +extension SwiftProtoTesting_TestEnumWithDupValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{9}FOO1\0\u{1}FOO2\0\u{9}BAR1\0\u{1}BAR2\0\u{1}BAZ\0") +} + +extension SwiftProtoTesting_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{7}OptionalGroup\0\u{4}\u{2}optional_nested_message\0\u{3}optional_foreign_message\0\u{3}optional_import_message\0\u{3}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{3}optional_import_enum\0\u{4}\u{3}optional_public_import_message\0\u{4}\u{5}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{7}RepeatedGroup\0\u{4}\u{2}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{3}repeated_import_message\0\u{3}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{3}repeated_import_enum\0\u{4}\u{8}default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{4}\u{6}default_nested_enum\0\u{3}default_foreign_enum\0\u{3}default_import_enum\0\u{4}\u{1c}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{b}something_old\0\u{b}reserved_field\0\u{b}something_long_gone\0\u{c}JIt\u{3}\u{1}\u{c}LIt\u{3}\u{1}\u{c}lHt\u{3}\u{a}\u{c}~Ht\u{3}\u{2}\u{c}KIt\u{3}\u{1}") + + fileprivate class _StorageClass { + var _optionalInt32: Int32? = nil + var _optionalInt64: Int64? = nil + var _optionalUint32: UInt32? = nil + var _optionalUint64: UInt64? = nil + var _optionalSint32: Int32? = nil + var _optionalSint64: Int64? = nil + var _optionalFixed32: UInt32? = nil + var _optionalFixed64: UInt64? = nil + var _optionalSfixed32: Int32? = nil + var _optionalSfixed64: Int64? = nil + var _optionalFloat: Float? = nil + var _optionalDouble: Double? = nil + var _optionalBool: Bool? = nil + var _optionalString: String? = nil + var _optionalBytes: Data? = nil + var _optionalGroup: SwiftProtoTesting_TestAllTypes.OptionalGroup? = nil + var _optionalNestedMessage: SwiftProtoTesting_TestAllTypes.NestedMessage? = nil + var _optionalForeignMessage: SwiftProtoTesting_ForeignMessage? = nil + var _optionalImportMessage: SwiftProtoTesting_Import_ImportMessage? = nil + var _optionalNestedEnum: SwiftProtoTesting_TestAllTypes.NestedEnum? = nil + var _optionalForeignEnum: SwiftProtoTesting_ForeignEnum? = nil + var _optionalImportEnum: SwiftProtoTesting_Import_ImportEnum? = nil + var _optionalPublicImportMessage: SwiftProtoTesting_Import_PublicImportMessage? = nil + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedGroup: [SwiftProtoTesting_TestAllTypes.RepeatedGroup] = [] + var _repeatedNestedMessage: [SwiftProtoTesting_TestAllTypes.NestedMessage] = [] + var _repeatedForeignMessage: [SwiftProtoTesting_ForeignMessage] = [] + var _repeatedImportMessage: [SwiftProtoTesting_Import_ImportMessage] = [] + var _repeatedNestedEnum: [SwiftProtoTesting_TestAllTypes.NestedEnum] = [] + var _repeatedForeignEnum: [SwiftProtoTesting_ForeignEnum] = [] + var _repeatedImportEnum: [SwiftProtoTesting_Import_ImportEnum] = [] + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + var _defaultNestedEnum: SwiftProtoTesting_TestAllTypes.NestedEnum? = nil + var _defaultForeignEnum: SwiftProtoTesting_ForeignEnum? = nil + var _defaultImportEnum: SwiftProtoTesting_Import_ImportEnum? = nil + var _oneofField: SwiftProtoTesting_TestAllTypes.OneOf_OneofField? + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalGroup = source._optionalGroup + _optionalNestedMessage = source._optionalNestedMessage + _optionalForeignMessage = source._optionalForeignMessage + _optionalImportMessage = source._optionalImportMessage + _optionalNestedEnum = source._optionalNestedEnum + _optionalForeignEnum = source._optionalForeignEnum + _optionalImportEnum = source._optionalImportEnum + _optionalPublicImportMessage = source._optionalPublicImportMessage + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedGroup = source._repeatedGroup + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedForeignMessage = source._repeatedForeignMessage + _repeatedImportMessage = source._repeatedImportMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _repeatedForeignEnum = source._repeatedForeignEnum + _repeatedImportEnum = source._repeatedImportEnum + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + _defaultNestedEnum = source._defaultNestedEnum + _defaultForeignEnum = source._defaultForeignEnum + _defaultImportEnum = source._defaultImportEnum + _oneofField = source._oneofField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 16: try { try decoder.decodeSingularGroupField(value: &_storage._optionalGroup) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() + case 20: try { try decoder.decodeSingularMessageField(value: &_storage._optionalImportMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() + case 23: try { try decoder.decodeSingularEnumField(value: &_storage._optionalImportEnum) }() + case 26: try { try decoder.decodeSingularMessageField(value: &_storage._optionalPublicImportMessage) }() + case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() + case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() + case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() + case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() + case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() + case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() + case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() + case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() + case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() + case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() + case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() + case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() + case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() + case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() + case 46: try { try decoder.decodeRepeatedGroupField(value: &_storage._repeatedGroup) }() + case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() + case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() + case 50: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedImportMessage) }() + case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() + case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() + case 53: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedImportEnum) }() + case 61: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 62: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 63: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 64: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 65: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 66: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 67: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 68: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 69: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 70: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 71: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 72: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 73: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 74: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 75: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() + case 81: try { try decoder.decodeSingularEnumField(value: &_storage._defaultNestedEnum) }() + case 82: try { try decoder.decodeSingularEnumField(value: &_storage._defaultForeignEnum) }() + case 83: try { try decoder.decodeSingularEnumField(value: &_storage._defaultImportEnum) }() + case 111: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 112: try { + var v: SwiftProtoTesting_TestAllTypes.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage(v) + } + }() + case 113: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 114: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() + default: break + } + } + } + } + + func traverse(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._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._optionalInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._optionalUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._optionalSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._optionalSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._optionalFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._optionalFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._optionalSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._optionalSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._optionalFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._optionalDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._optionalBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._optionalForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._optionalImportMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 20) + } }() + try { if let v = _storage._optionalNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._optionalForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._optionalImportEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 23) + } }() + try { if let v = _storage._optionalPublicImportMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 26) + } }() + if !_storage._repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + } + if !_storage._repeatedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + } + if !_storage._repeatedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + } + if !_storage._repeatedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + } + if !_storage._repeatedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + } + if !_storage._repeatedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + } + if !_storage._repeatedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + } + if !_storage._repeatedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + } + if !_storage._repeatedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + } + if !_storage._repeatedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + } + if !_storage._repeatedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + } + if !_storage._repeatedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + } + if !_storage._repeatedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + } + if !_storage._repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) + } + if !_storage._repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) + } + if !_storage._repeatedGroup.isEmpty { + try visitor.visitRepeatedGroupField(value: _storage._repeatedGroup, fieldNumber: 46) + } + if !_storage._repeatedNestedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) + } + if !_storage._repeatedForeignMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) + } + if !_storage._repeatedImportMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedImportMessage, fieldNumber: 50) + } + if !_storage._repeatedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + } + if !_storage._repeatedForeignEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) + } + if !_storage._repeatedImportEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedImportEnum, fieldNumber: 53) + } + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 61) + } }() + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 62) + } }() + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 64) + } }() + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 65) + } }() + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 66) + } }() + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 67) + } }() + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 68) + } }() + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 69) + } }() + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 70) + } }() + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 71) + } }() + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 72) + } }() + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 73) + } }() + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 74) + } }() + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 75) + } }() + try { if let v = _storage._defaultNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 81) + } }() + try { if let v = _storage._defaultForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 82) + } }() + try { if let v = _storage._defaultImportEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 83) + } }() + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case nil: break + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestAllTypes, rhs: SwiftProtoTesting_TestAllTypes) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalGroup != rhs_storage._optionalGroup {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} + if _storage._optionalImportMessage != rhs_storage._optionalImportMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} + if _storage._optionalImportEnum != rhs_storage._optionalImportEnum {return false} + if _storage._optionalPublicImportMessage != rhs_storage._optionalPublicImportMessage {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedGroup != rhs_storage._repeatedGroup {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} + if _storage._repeatedImportMessage != rhs_storage._repeatedImportMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} + if _storage._repeatedImportEnum != rhs_storage._repeatedImportEnum {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} + if _storage._defaultNestedEnum != rhs_storage._defaultNestedEnum {return false} + if _storage._defaultForeignEnum != rhs_storage._defaultForeignEnum {return false} + if _storage._defaultImportEnum != rhs_storage._defaultImportEnum {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestAllTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{2}\u{2}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension SwiftProtoTesting_TestAllTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestAllTypes.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") + + 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._bb) }() + 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 + try { if let v = self._bb { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestAllTypes.NestedMessage, rhs: SwiftProtoTesting_TestAllTypes.NestedMessage) -> Bool { + if lhs._bb != rhs._bb {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestAllTypes.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestAllTypes.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{11}a\0") + + 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestAllTypes.OptionalGroup, rhs: SwiftProtoTesting_TestAllTypes.OptionalGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestAllTypes.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestAllTypes.protoMessageName + ".RepeatedGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}/a\0") + + 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 47: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestAllTypes.RepeatedGroup, rhs: SwiftProtoTesting_TestAllTypes.RepeatedGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NestedTestAllTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}child\0\u{1}payload\0\u{3}repeated_child\0") + + fileprivate class _StorageClass { + var _child: SwiftProtoTesting_NestedTestAllTypes? = nil + var _payload: SwiftProtoTesting_TestAllTypes? = nil + var _repeatedChild: [SwiftProtoTesting_NestedTestAllTypes] = [] + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _child = source._child + _payload = source._payload + _repeatedChild = source._repeatedChild + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._child) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._payload) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedChild) }() + default: break + } + } + } + } + + func traverse(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._child { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._payload { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + if !_storage._repeatedChild.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedChild, fieldNumber: 3) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_NestedTestAllTypes, rhs: SwiftProtoTesting_NestedTestAllTypes) -> 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._child != rhs_storage._child {return false} + if _storage._payload != rhs_storage._payload {return false} + if _storage._repeatedChild != rhs_storage._repeatedChild {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0\u{1}d\0") + + 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._c) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._d) }() + 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 + try { if let v = self._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._d { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_ForeignMessage, rhs: SwiftProtoTesting_ForeignMessage) -> Bool { + if lhs._c != rhs._c {return false} + if lhs._d != rhs._d {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestAllExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_TestAllExtensions.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestAllExtensions, rhs: SwiftProtoTesting_TestAllExtensions) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension SwiftProtoTesting_OptionalGroup_extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OptionalGroup_extension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{11}a\0") + + 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_OptionalGroup_extension, rhs: SwiftProtoTesting_OptionalGroup_extension) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_RepeatedGroup_extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".RepeatedGroup_extension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}/a\0") + + 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 47: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_RepeatedGroup_extension, rhs: SwiftProtoTesting_RepeatedGroup_extension) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestNestedExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestNestedExtension, rhs: SwiftProtoTesting_TestNestedExtension) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestRequired: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequired" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}dummy2\0\u{1}b\0\u{1}dummy4\0\u{1}dummy5\0\u{1}dummy6\0\u{1}dummy7\0\u{1}dummy8\0\u{1}dummy9\0\u{1}dummy10\0\u{1}dummy11\0\u{1}dummy12\0\u{1}dummy13\0\u{1}dummy14\0\u{1}dummy15\0\u{1}dummy16\0\u{1}dummy17\0\u{1}dummy18\0\u{1}dummy19\0\u{1}dummy20\0\u{1}dummy21\0\u{1}dummy22\0\u{1}dummy23\0\u{1}dummy24\0\u{1}dummy25\0\u{1}dummy26\0\u{1}dummy27\0\u{1}dummy28\0\u{1}dummy29\0\u{1}dummy30\0\u{1}dummy31\0\u{1}dummy32\0\u{1}c\0\u{3}optional_foreign\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _dummy2: Int32? = nil + var _b: Int32? = nil + var _dummy4: Int32? = nil + var _dummy5: Int32? = nil + var _dummy6: Int32? = nil + var _dummy7: Int32? = nil + var _dummy8: Int32? = nil + var _dummy9: Int32? = nil + var _dummy10: Int32? = nil + var _dummy11: Int32? = nil + var _dummy12: Int32? = nil + var _dummy13: Int32? = nil + var _dummy14: Int32? = nil + var _dummy15: Int32? = nil + var _dummy16: Int32? = nil + var _dummy17: Int32? = nil + var _dummy18: Int32? = nil + var _dummy19: Int32? = nil + var _dummy20: Int32? = nil + var _dummy21: Int32? = nil + var _dummy22: Int32? = nil + var _dummy23: Int32? = nil + var _dummy24: Int32? = nil + var _dummy25: Int32? = nil + var _dummy26: Int32? = nil + var _dummy27: Int32? = nil + var _dummy28: Int32? = nil + var _dummy29: Int32? = nil + var _dummy30: Int32? = nil + var _dummy31: Int32? = nil + var _dummy32: Int32? = nil + var _c: Int32? = nil + var _optionalForeign: SwiftProtoTesting_ForeignMessage? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _dummy2 = source._dummy2 + _b = source._b + _dummy4 = source._dummy4 + _dummy5 = source._dummy5 + _dummy6 = source._dummy6 + _dummy7 = source._dummy7 + _dummy8 = source._dummy8 + _dummy9 = source._dummy9 + _dummy10 = source._dummy10 + _dummy11 = source._dummy11 + _dummy12 = source._dummy12 + _dummy13 = source._dummy13 + _dummy14 = source._dummy14 + _dummy15 = source._dummy15 + _dummy16 = source._dummy16 + _dummy17 = source._dummy17 + _dummy18 = source._dummy18 + _dummy19 = source._dummy19 + _dummy20 = source._dummy20 + _dummy21 = source._dummy21 + _dummy22 = source._dummy22 + _dummy23 = source._dummy23 + _dummy24 = source._dummy24 + _dummy25 = source._dummy25 + _dummy26 = source._dummy26 + _dummy27 = source._dummy27 + _dummy28 = source._dummy28 + _dummy29 = source._dummy29 + _dummy30 = source._dummy30 + _dummy31 = source._dummy31 + _dummy32 = source._dummy32 + _c = source._c + _optionalForeign = source._optionalForeign + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._a == nil {return false} + if _storage._b == nil {return false} + if _storage._c == nil {return false} + return true + } + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy2) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &_storage._b) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy4) }() + case 5: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy5) }() + case 6: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy6) }() + case 7: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy7) }() + case 8: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy8) }() + case 9: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy9) }() + case 10: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy10) }() + case 11: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy11) }() + case 12: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy12) }() + case 13: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy13) }() + case 14: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy14) }() + case 15: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy15) }() + case 16: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy16) }() + case 17: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy17) }() + case 18: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy18) }() + case 19: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy19) }() + case 20: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy20) }() + case 21: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy21) }() + case 22: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy22) }() + case 23: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy23) }() + case 24: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy24) }() + case 25: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy25) }() + case 26: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy26) }() + case 27: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy27) }() + case 28: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy28) }() + case 29: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy29) }() + case 30: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy30) }() + case 31: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy31) }() + case 32: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy32) }() + case 33: try { try decoder.decodeSingularInt32Field(value: &_storage._c) }() + case 34: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeign) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._dummy2 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._dummy4 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._dummy5 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._dummy6 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._dummy7 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._dummy8 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._dummy9 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._dummy10 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._dummy11 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._dummy12 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._dummy13 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._dummy14 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._dummy15 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._dummy16 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._dummy17 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) + } }() + try { if let v = _storage._dummy18 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._dummy19 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._dummy20 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 20) + } }() + try { if let v = _storage._dummy21 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._dummy22 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._dummy23 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 23) + } }() + try { if let v = _storage._dummy24 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._dummy25 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._dummy26 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 26) + } }() + try { if let v = _storage._dummy27 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 27) + } }() + try { if let v = _storage._dummy28 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 28) + } }() + try { if let v = _storage._dummy29 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 29) + } }() + try { if let v = _storage._dummy30 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 30) + } }() + try { if let v = _storage._dummy31 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 31) + } }() + try { if let v = _storage._dummy32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 32) + } }() + try { if let v = _storage._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 33) + } }() + try { if let v = _storage._optionalForeign { + try visitor.visitSingularMessageField(value: v, fieldNumber: 34) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestRequired, rhs: SwiftProtoTesting_TestRequired) -> 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._a != rhs_storage._a {return false} + if _storage._dummy2 != rhs_storage._dummy2 {return false} + if _storage._b != rhs_storage._b {return false} + if _storage._dummy4 != rhs_storage._dummy4 {return false} + if _storage._dummy5 != rhs_storage._dummy5 {return false} + if _storage._dummy6 != rhs_storage._dummy6 {return false} + if _storage._dummy7 != rhs_storage._dummy7 {return false} + if _storage._dummy8 != rhs_storage._dummy8 {return false} + if _storage._dummy9 != rhs_storage._dummy9 {return false} + if _storage._dummy10 != rhs_storage._dummy10 {return false} + if _storage._dummy11 != rhs_storage._dummy11 {return false} + if _storage._dummy12 != rhs_storage._dummy12 {return false} + if _storage._dummy13 != rhs_storage._dummy13 {return false} + if _storage._dummy14 != rhs_storage._dummy14 {return false} + if _storage._dummy15 != rhs_storage._dummy15 {return false} + if _storage._dummy16 != rhs_storage._dummy16 {return false} + if _storage._dummy17 != rhs_storage._dummy17 {return false} + if _storage._dummy18 != rhs_storage._dummy18 {return false} + if _storage._dummy19 != rhs_storage._dummy19 {return false} + if _storage._dummy20 != rhs_storage._dummy20 {return false} + if _storage._dummy21 != rhs_storage._dummy21 {return false} + if _storage._dummy22 != rhs_storage._dummy22 {return false} + if _storage._dummy23 != rhs_storage._dummy23 {return false} + if _storage._dummy24 != rhs_storage._dummy24 {return false} + if _storage._dummy25 != rhs_storage._dummy25 {return false} + if _storage._dummy26 != rhs_storage._dummy26 {return false} + if _storage._dummy27 != rhs_storage._dummy27 {return false} + if _storage._dummy28 != rhs_storage._dummy28 {return false} + if _storage._dummy29 != rhs_storage._dummy29 {return false} + if _storage._dummy30 != rhs_storage._dummy30 {return false} + if _storage._dummy31 != rhs_storage._dummy31 {return false} + if _storage._dummy32 != rhs_storage._dummy32 {return false} + if _storage._c != rhs_storage._c {return false} + if _storage._optionalForeign != rhs_storage._optionalForeign {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestRequiredForeign: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredForeign" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_message\0\u{3}repeated_message\0\u{1}dummy\0") + + public var isInitialized: Bool { + if let v = self._optionalMessage, !v.isInitialized {return false} + if !SwiftProtobuf.Internal.areAllInitialized(self.repeatedMessage) {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._optionalMessage) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedMessage) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._dummy) }() + 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 + try { if let v = self._optionalMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + if !self.repeatedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedMessage, fieldNumber: 2) + } + try { if let v = self._dummy { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestRequiredForeign, rhs: SwiftProtoTesting_TestRequiredForeign) -> Bool { + if lhs._optionalMessage != rhs._optionalMessage {return false} + if lhs.repeatedMessage != rhs.repeatedMessage {return false} + if lhs._dummy != rhs._dummy {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestRequiredMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_message\0\u{3}repeated_message\0\u{3}required_message\0") + + public var isInitialized: Bool { + if self._requiredMessage == nil {return false} + if let v = self._optionalMessage, !v.isInitialized {return false} + if !SwiftProtobuf.Internal.areAllInitialized(self.repeatedMessage) {return false} + if let v = self._requiredMessage, !v.isInitialized {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._optionalMessage) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedMessage) }() + case 3: try { try decoder.decodeSingularMessageField(value: &self._requiredMessage) }() + 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 + try { if let v = self._optionalMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + if !self.repeatedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedMessage, fieldNumber: 2) + } + try { if let v = self._requiredMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestRequiredMessage, rhs: SwiftProtoTesting_TestRequiredMessage) -> Bool { + if lhs._optionalMessage != rhs._optionalMessage {return false} + if lhs.repeatedMessage != rhs.repeatedMessage {return false} + if lhs._requiredMessage != rhs._requiredMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestEmptyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEmptyMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestEmptyMessage, rhs: SwiftProtoTesting_TestEmptyMessage) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestReallyLargeTagNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestReallyLargeTagNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{2}~\u{7f}\u{7f}\u{7f}\u{f}bb\0") + + 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._a) }() + case 268435455: try { try decoder.decodeSingularInt32Field(value: &self._bb) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._bb { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 268435455) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestReallyLargeTagNumber, rhs: SwiftProtoTesting_TestReallyLargeTagNumber) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._bb != rhs._bb {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestRecursiveMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRecursiveMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}i\0") + + fileprivate class _StorageClass { + var _a: SwiftProtoTesting_TestRecursiveMessage? = nil + var _i: Int32? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _i = source._i + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._i) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestRecursiveMessage, rhs: SwiftProtoTesting_TestRecursiveMessage) -> 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._a != rhs_storage._a {return false} + if _storage._i != rhs_storage._i {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestFieldOrderings: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestFieldOrderings" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}my_int\0\u{4}\u{a}my_string\0\u{4}Z\u{1}my_float\0\u{4}c\u{1}optional_nested_message\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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.decodeSingularInt64Field(value: &self._myInt) }() + case 11: try { try decoder.decodeSingularStringField(value: &self._myString) }() + case 101: try { try decoder.decodeSingularFloatField(value: &self._myFloat) }() + case 200: try { try decoder.decodeSingularMessageField(value: &self._optionalNestedMessage) }() + case 2..<11, 12..<101: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_TestFieldOrderings.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._myInt { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 1) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2, end: 11) + try { if let v = self._myString { + try visitor.visitSingularStringField(value: v, fieldNumber: 11) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 12, end: 101) + try { if let v = self._myFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 101) + } }() + try { if let v = self._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 200) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestFieldOrderings, rhs: SwiftProtoTesting_TestFieldOrderings) -> Bool { + if lhs._myString != rhs._myString {return false} + if lhs._myInt != rhs._myInt {return false} + if lhs._myFloat != rhs._myFloat {return false} + if lhs._optionalNestedMessage != rhs._optionalNestedMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension SwiftProtoTesting_TestFieldOrderings.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestFieldOrderings.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0\u{1}oo\0") + + 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._bb) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &self._oo) }() + 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 + try { if let v = self._bb { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._oo { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestFieldOrderings.NestedMessage, rhs: SwiftProtoTesting_TestFieldOrderings.NestedMessage) -> Bool { + if lhs._oo != rhs._oo {return false} + if lhs._bb != rhs._bb {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestExtremeDefaultValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestExtremeDefaultValues" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}escaped_bytes\0\u{3}large_uint32\0\u{3}large_uint64\0\u{3}small_int32\0\u{3}small_int64\0\u{3}utf8_string\0\u{3}zero_float\0\u{3}one_float\0\u{3}small_float\0\u{3}negative_one_float\0\u{3}negative_float\0\u{3}large_float\0\u{3}small_negative_float\0\u{3}inf_double\0\u{3}neg_inf_double\0\u{3}nan_double\0\u{3}inf_float\0\u{3}neg_inf_float\0\u{3}nan_float\0\u{3}cpp_trigraph\0\u{3}really_small_int32\0\u{3}really_small_int64\0\u{3}string_with_zero\0\u{3}bytes_with_zero\0\u{4}\u{3}replacement_string\0") + + fileprivate class _StorageClass { + var _escapedBytes: Data? = nil + var _largeUint32: UInt32? = nil + var _largeUint64: UInt64? = nil + var _smallInt32: Int32? = nil + var _smallInt64: Int64? = nil + var _reallySmallInt32: Int32? = nil + var _reallySmallInt64: Int64? = nil + var _utf8String: String? = nil + var _zeroFloat: Float? = nil + var _oneFloat: Float? = nil + var _smallFloat: Float? = nil + var _negativeOneFloat: Float? = nil + var _negativeFloat: Float? = nil + var _largeFloat: Float? = nil + var _smallNegativeFloat: Float? = nil + var _infDouble: Double? = nil + var _negInfDouble: Double? = nil + var _nanDouble: Double? = nil + var _infFloat: Float? = nil + var _negInfFloat: Float? = nil + var _nanFloat: Float? = nil + var _cppTrigraph: String? = nil + var _stringWithZero: String? = nil + var _bytesWithZero: Data? = nil + var _replacementString: String? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _escapedBytes = source._escapedBytes + _largeUint32 = source._largeUint32 + _largeUint64 = source._largeUint64 + _smallInt32 = source._smallInt32 + _smallInt64 = source._smallInt64 + _reallySmallInt32 = source._reallySmallInt32 + _reallySmallInt64 = source._reallySmallInt64 + _utf8String = source._utf8String + _zeroFloat = source._zeroFloat + _oneFloat = source._oneFloat + _smallFloat = source._smallFloat + _negativeOneFloat = source._negativeOneFloat + _negativeFloat = source._negativeFloat + _largeFloat = source._largeFloat + _smallNegativeFloat = source._smallNegativeFloat + _infDouble = source._infDouble + _negInfDouble = source._negInfDouble + _nanDouble = source._nanDouble + _infFloat = source._infFloat + _negInfFloat = source._negInfFloat + _nanFloat = source._nanFloat + _cppTrigraph = source._cppTrigraph + _stringWithZero = source._stringWithZero + _bytesWithZero = source._bytesWithZero + _replacementString = source._replacementString + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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.decodeSingularBytesField(value: &_storage._escapedBytes) }() + case 2: try { try decoder.decodeSingularUInt32Field(value: &_storage._largeUint32) }() + case 3: try { try decoder.decodeSingularUInt64Field(value: &_storage._largeUint64) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &_storage._smallInt32) }() + case 5: try { try decoder.decodeSingularInt64Field(value: &_storage._smallInt64) }() + case 6: try { try decoder.decodeSingularStringField(value: &_storage._utf8String) }() + case 7: try { try decoder.decodeSingularFloatField(value: &_storage._zeroFloat) }() + case 8: try { try decoder.decodeSingularFloatField(value: &_storage._oneFloat) }() + case 9: try { try decoder.decodeSingularFloatField(value: &_storage._smallFloat) }() + case 10: try { try decoder.decodeSingularFloatField(value: &_storage._negativeOneFloat) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._negativeFloat) }() + case 12: try { try decoder.decodeSingularFloatField(value: &_storage._largeFloat) }() + case 13: try { try decoder.decodeSingularFloatField(value: &_storage._smallNegativeFloat) }() + case 14: try { try decoder.decodeSingularDoubleField(value: &_storage._infDouble) }() + case 15: try { try decoder.decodeSingularDoubleField(value: &_storage._negInfDouble) }() + case 16: try { try decoder.decodeSingularDoubleField(value: &_storage._nanDouble) }() + case 17: try { try decoder.decodeSingularFloatField(value: &_storage._infFloat) }() + case 18: try { try decoder.decodeSingularFloatField(value: &_storage._negInfFloat) }() + case 19: try { try decoder.decodeSingularFloatField(value: &_storage._nanFloat) }() + case 20: try { try decoder.decodeSingularStringField(value: &_storage._cppTrigraph) }() + case 21: try { try decoder.decodeSingularInt32Field(value: &_storage._reallySmallInt32) }() + case 22: try { try decoder.decodeSingularInt64Field(value: &_storage._reallySmallInt64) }() + case 23: try { try decoder.decodeSingularStringField(value: &_storage._stringWithZero) }() + case 24: try { try decoder.decodeSingularBytesField(value: &_storage._bytesWithZero) }() + case 27: try { try decoder.decodeSingularStringField(value: &_storage._replacementString) }() + default: break + } + } + } + } + + func traverse(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._escapedBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._largeUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._largeUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._smallInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._smallInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._utf8String { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._zeroFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._oneFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._smallFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._negativeOneFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._negativeFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._largeFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._smallNegativeFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._infDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._negInfDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._nanDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._infFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 17) + } }() + try { if let v = _storage._negInfFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._nanFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._cppTrigraph { + try visitor.visitSingularStringField(value: v, fieldNumber: 20) + } }() + try { if let v = _storage._reallySmallInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._reallySmallInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._stringWithZero { + try visitor.visitSingularStringField(value: v, fieldNumber: 23) + } }() + try { if let v = _storage._bytesWithZero { + try visitor.visitSingularBytesField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._replacementString { + try visitor.visitSingularStringField(value: v, fieldNumber: 27) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestExtremeDefaultValues, rhs: SwiftProtoTesting_TestExtremeDefaultValues) -> 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._escapedBytes != rhs_storage._escapedBytes {return false} + if _storage._largeUint32 != rhs_storage._largeUint32 {return false} + if _storage._largeUint64 != rhs_storage._largeUint64 {return false} + if _storage._smallInt32 != rhs_storage._smallInt32 {return false} + if _storage._smallInt64 != rhs_storage._smallInt64 {return false} + if _storage._reallySmallInt32 != rhs_storage._reallySmallInt32 {return false} + if _storage._reallySmallInt64 != rhs_storage._reallySmallInt64 {return false} + if _storage._utf8String != rhs_storage._utf8String {return false} + if _storage._zeroFloat != rhs_storage._zeroFloat {return false} + if _storage._oneFloat != rhs_storage._oneFloat {return false} + if _storage._smallFloat != rhs_storage._smallFloat {return false} + if _storage._negativeOneFloat != rhs_storage._negativeOneFloat {return false} + if _storage._negativeFloat != rhs_storage._negativeFloat {return false} + if _storage._largeFloat != rhs_storage._largeFloat {return false} + if _storage._smallNegativeFloat != rhs_storage._smallNegativeFloat {return false} + if _storage._infDouble != rhs_storage._infDouble {return false} + if _storage._negInfDouble != rhs_storage._negInfDouble {return false} + if _storage._nanDouble != rhs_storage._nanDouble {return false} + if _storage._infFloat != rhs_storage._infFloat {return false} + if _storage._negInfFloat != rhs_storage._negInfFloat {return false} + if _storage._nanFloat != rhs_storage._nanFloat {return false} + if _storage._cppTrigraph != rhs_storage._cppTrigraph {return false} + if _storage._stringWithZero != rhs_storage._stringWithZero {return false} + if _storage._bytesWithZero != rhs_storage._bytesWithZero {return false} + if _storage._replacementString != rhs_storage._replacementString {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}foo_int\0\u{3}foo_string\0\u{3}foo_message\0\u{7}FooGroup\0") + + 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: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooInt(v) + } + }() + case 2: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooString(v) + } + }() + case 3: try { + var v: SwiftProtoTesting_TestAllTypes? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooMessage(v) + } + }() + case 4: try { + var v: SwiftProtoTesting_TestOneof.FooGroup? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooGroup(let m) = current {v = m} + } + try decoder.decodeSingularGroupField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooGroup(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.foo { + case .fooInt?: try { + guard case .fooInt(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + }() + case .fooString?: try { + guard case .fooString(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + }() + case .fooMessage?: try { + guard case .fooMessage(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + }() + case .fooGroup?: try { + guard case .fooGroup(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularGroupField(value: v, fieldNumber: 4) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestOneof, rhs: SwiftProtoTesting_TestOneof) -> Bool { + if lhs.foo != rhs.foo {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestOneof.FooGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestOneof.protoMessageName + ".FooGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{5}a\0\u{1}b\0") + + 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 5: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + case 6: try { try decoder.decodeSingularStringField(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = self._b { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestOneof.FooGroup, rhs: SwiftProtoTesting_TestOneof.FooGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestRequiredOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}foo_int\0\u{3}foo_string\0\u{3}foo_message\0") + + public var isInitialized: Bool { + if let v = self.foo, !v.isInitialized {return false} + return true + } + + 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: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooInt(v) + } + }() + case 2: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooString(v) + } + }() + case 3: try { + var v: SwiftProtoTesting_TestRequiredOneof.NestedMessage? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooMessage(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.foo { + case .fooInt?: try { + guard case .fooInt(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + }() + case .fooString?: try { + guard case .fooString(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + }() + case .fooMessage?: try { + guard case .fooMessage(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestRequiredOneof, rhs: SwiftProtoTesting_TestRequiredOneof) -> Bool { + if lhs.foo != rhs.foo {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestRequiredOneof.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestRequiredOneof.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_double\0") + + public var isInitialized: Bool { + if self._requiredDouble == nil {return false} + return true + } + + 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.decodeSingularDoubleField(value: &self._requiredDouble) }() + 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 + try { if let v = self._requiredDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestRequiredOneof.NestedMessage, rhs: SwiftProtoTesting_TestRequiredOneof.NestedMessage) -> Bool { + if lhs._requiredDouble != rhs._requiredDouble {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestPackedTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}Z\u{1}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_enum\0") + + 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 90: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32) }() + case 91: try { try decoder.decodeRepeatedInt64Field(value: &self.packedInt64) }() + case 92: try { try decoder.decodeRepeatedUInt32Field(value: &self.packedUint32) }() + case 93: try { try decoder.decodeRepeatedUInt64Field(value: &self.packedUint64) }() + case 94: try { try decoder.decodeRepeatedSInt32Field(value: &self.packedSint32) }() + case 95: try { try decoder.decodeRepeatedSInt64Field(value: &self.packedSint64) }() + case 96: try { try decoder.decodeRepeatedFixed32Field(value: &self.packedFixed32) }() + case 97: try { try decoder.decodeRepeatedFixed64Field(value: &self.packedFixed64) }() + case 98: try { try decoder.decodeRepeatedSFixed32Field(value: &self.packedSfixed32) }() + case 99: try { try decoder.decodeRepeatedSFixed64Field(value: &self.packedSfixed64) }() + case 100: try { try decoder.decodeRepeatedFloatField(value: &self.packedFloat) }() + case 101: try { try decoder.decodeRepeatedDoubleField(value: &self.packedDouble) }() + case 102: try { try decoder.decodeRepeatedBoolField(value: &self.packedBool) }() + case 103: try { try decoder.decodeRepeatedEnumField(value: &self.packedEnum) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: self.packedInt32, fieldNumber: 90) + } + if !self.packedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: self.packedInt64, fieldNumber: 91) + } + if !self.packedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: self.packedUint32, fieldNumber: 92) + } + if !self.packedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: self.packedUint64, fieldNumber: 93) + } + if !self.packedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: self.packedSint32, fieldNumber: 94) + } + if !self.packedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: self.packedSint64, fieldNumber: 95) + } + if !self.packedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: self.packedFixed32, fieldNumber: 96) + } + if !self.packedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: self.packedFixed64, fieldNumber: 97) + } + if !self.packedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: self.packedSfixed32, fieldNumber: 98) + } + if !self.packedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: self.packedSfixed64, fieldNumber: 99) + } + if !self.packedFloat.isEmpty { + try visitor.visitPackedFloatField(value: self.packedFloat, fieldNumber: 100) + } + if !self.packedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: self.packedDouble, fieldNumber: 101) + } + if !self.packedBool.isEmpty { + try visitor.visitPackedBoolField(value: self.packedBool, fieldNumber: 102) + } + if !self.packedEnum.isEmpty { + try visitor.visitPackedEnumField(value: self.packedEnum, fieldNumber: 103) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestPackedTypes, rhs: SwiftProtoTesting_TestPackedTypes) -> Bool { + if lhs.packedInt32 != rhs.packedInt32 {return false} + if lhs.packedInt64 != rhs.packedInt64 {return false} + if lhs.packedUint32 != rhs.packedUint32 {return false} + if lhs.packedUint64 != rhs.packedUint64 {return false} + if lhs.packedSint32 != rhs.packedSint32 {return false} + if lhs.packedSint64 != rhs.packedSint64 {return false} + if lhs.packedFixed32 != rhs.packedFixed32 {return false} + if lhs.packedFixed64 != rhs.packedFixed64 {return false} + if lhs.packedSfixed32 != rhs.packedSfixed32 {return false} + if lhs.packedSfixed64 != rhs.packedSfixed64 {return false} + if lhs.packedFloat != rhs.packedFloat {return false} + if lhs.packedDouble != rhs.packedDouble {return false} + if lhs.packedBool != rhs.packedBool {return false} + if lhs.packedEnum != rhs.packedEnum {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestUnpackedTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}Z\u{1}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_enum\0") + + 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 90: try { try decoder.decodeRepeatedInt32Field(value: &self.unpackedInt32) }() + case 91: try { try decoder.decodeRepeatedInt64Field(value: &self.unpackedInt64) }() + case 92: try { try decoder.decodeRepeatedUInt32Field(value: &self.unpackedUint32) }() + case 93: try { try decoder.decodeRepeatedUInt64Field(value: &self.unpackedUint64) }() + case 94: try { try decoder.decodeRepeatedSInt32Field(value: &self.unpackedSint32) }() + case 95: try { try decoder.decodeRepeatedSInt64Field(value: &self.unpackedSint64) }() + case 96: try { try decoder.decodeRepeatedFixed32Field(value: &self.unpackedFixed32) }() + case 97: try { try decoder.decodeRepeatedFixed64Field(value: &self.unpackedFixed64) }() + case 98: try { try decoder.decodeRepeatedSFixed32Field(value: &self.unpackedSfixed32) }() + case 99: try { try decoder.decodeRepeatedSFixed64Field(value: &self.unpackedSfixed64) }() + case 100: try { try decoder.decodeRepeatedFloatField(value: &self.unpackedFloat) }() + case 101: try { try decoder.decodeRepeatedDoubleField(value: &self.unpackedDouble) }() + case 102: try { try decoder.decodeRepeatedBoolField(value: &self.unpackedBool) }() + case 103: try { try decoder.decodeRepeatedEnumField(value: &self.unpackedEnum) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.unpackedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.unpackedInt32, fieldNumber: 90) + } + if !self.unpackedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: self.unpackedInt64, fieldNumber: 91) + } + if !self.unpackedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: self.unpackedUint32, fieldNumber: 92) + } + if !self.unpackedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: self.unpackedUint64, fieldNumber: 93) + } + if !self.unpackedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: self.unpackedSint32, fieldNumber: 94) + } + if !self.unpackedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: self.unpackedSint64, fieldNumber: 95) + } + if !self.unpackedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: self.unpackedFixed32, fieldNumber: 96) + } + if !self.unpackedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: self.unpackedFixed64, fieldNumber: 97) + } + if !self.unpackedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: self.unpackedSfixed32, fieldNumber: 98) + } + if !self.unpackedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: self.unpackedSfixed64, fieldNumber: 99) + } + if !self.unpackedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: self.unpackedFloat, fieldNumber: 100) + } + if !self.unpackedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: self.unpackedDouble, fieldNumber: 101) + } + if !self.unpackedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: self.unpackedBool, fieldNumber: 102) + } + if !self.unpackedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: self.unpackedEnum, fieldNumber: 103) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestUnpackedTypes, rhs: SwiftProtoTesting_TestUnpackedTypes) -> Bool { + if lhs.unpackedInt32 != rhs.unpackedInt32 {return false} + if lhs.unpackedInt64 != rhs.unpackedInt64 {return false} + if lhs.unpackedUint32 != rhs.unpackedUint32 {return false} + if lhs.unpackedUint64 != rhs.unpackedUint64 {return false} + if lhs.unpackedSint32 != rhs.unpackedSint32 {return false} + if lhs.unpackedSint64 != rhs.unpackedSint64 {return false} + if lhs.unpackedFixed32 != rhs.unpackedFixed32 {return false} + if lhs.unpackedFixed64 != rhs.unpackedFixed64 {return false} + if lhs.unpackedSfixed32 != rhs.unpackedSfixed32 {return false} + if lhs.unpackedSfixed64 != rhs.unpackedSfixed64 {return false} + if lhs.unpackedFloat != rhs.unpackedFloat {return false} + if lhs.unpackedDouble != rhs.unpackedDouble {return false} + if lhs.unpackedBool != rhs.unpackedBool {return false} + if lhs.unpackedEnum != rhs.unpackedEnum {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestPackedExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestPackedExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_TestPackedExtensions.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestPackedExtensions, rhs: SwiftProtoTesting_TestPackedExtensions) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension SwiftProtoTesting_TestParsingMerge: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestParsingMerge" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_all_types\0\u{3}optional_all_types\0\u{3}repeated_all_types\0\u{8}\u{7}OptionalGroup\0\u{8}\u{a}RepeatedGroup\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + if self._requiredAllTypes == nil {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._requiredAllTypes) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 10: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() + case 20: try { try decoder.decodeRepeatedGroupField(value: &self.repeatedGroup) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_TestParsingMerge.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._requiredAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 3) + } + try { if let v = self._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 10) + } }() + if !self.repeatedGroup.isEmpty { + try visitor.visitRepeatedGroupField(value: self.repeatedGroup, fieldNumber: 20) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestParsingMerge, rhs: SwiftProtoTesting_TestParsingMerge) -> Bool { + if lhs._requiredAllTypes != rhs._requiredAllTypes {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs._optionalGroup != rhs._optionalGroup {return false} + if lhs.repeatedGroup != rhs.repeatedGroup {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestParsingMerge.protoMessageName + ".RepeatedFieldsGenerator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field1\0\u{1}field2\0\u{1}field3\0\u{8}\u{7}Group1\0\u{8}\u{a}Group2\0\u{2}T\u{f}ext1\0\u{1}ext2\0") + + 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.decodeRepeatedMessageField(value: &self.field1) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.field2) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &self.field3) }() + case 10: try { try decoder.decodeRepeatedGroupField(value: &self.group1) }() + case 20: try { try decoder.decodeRepeatedGroupField(value: &self.group2) }() + case 1000: try { try decoder.decodeRepeatedMessageField(value: &self.ext1) }() + case 1001: try { try decoder.decodeRepeatedMessageField(value: &self.ext2) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.field1.isEmpty { + try visitor.visitRepeatedMessageField(value: self.field1, fieldNumber: 1) + } + if !self.field2.isEmpty { + try visitor.visitRepeatedMessageField(value: self.field2, fieldNumber: 2) + } + if !self.field3.isEmpty { + try visitor.visitRepeatedMessageField(value: self.field3, fieldNumber: 3) + } + if !self.group1.isEmpty { + try visitor.visitRepeatedGroupField(value: self.group1, fieldNumber: 10) + } + if !self.group2.isEmpty { + try visitor.visitRepeatedGroupField(value: self.group2, fieldNumber: 20) + } + if !self.ext1.isEmpty { + try visitor.visitRepeatedMessageField(value: self.ext1, fieldNumber: 1000) + } + if !self.ext2.isEmpty { + try visitor.visitRepeatedMessageField(value: self.ext2, fieldNumber: 1001) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator, rhs: SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator) -> Bool { + if lhs.field1 != rhs.field1 {return false} + if lhs.field2 != rhs.field2 {return false} + if lhs.field3 != rhs.field3 {return false} + if lhs.group1 != rhs.group1 {return false} + if lhs.group2 != rhs.group2 {return false} + if lhs.ext1 != rhs.ext1 {return false} + if lhs.ext2 != rhs.ext2 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.protoMessageName + ".Group1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{b}field1\0") + + 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 11: try { try decoder.decodeSingularMessageField(value: &self._field1) }() + 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 + try { if let v = self._field1 { + try visitor.visitSingularMessageField(value: v, fieldNumber: 11) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group1, rhs: SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group1) -> Bool { + if lhs._field1 != rhs._field1 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.protoMessageName + ".Group2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{15}field1\0") + + 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 21: try { try decoder.decodeSingularMessageField(value: &self._field1) }() + 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 + try { if let v = self._field1 { + try visitor.visitSingularMessageField(value: v, fieldNumber: 21) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group2, rhs: SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group2) -> Bool { + if lhs._field1 != rhs._field1 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestParsingMerge.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestParsingMerge.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{b}optional_group_all_types\0") + + 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 11: try { try decoder.decodeSingularMessageField(value: &self._optionalGroupAllTypes) }() + 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 + try { if let v = self._optionalGroupAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 11) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestParsingMerge.OptionalGroup, rhs: SwiftProtoTesting_TestParsingMerge.OptionalGroup) -> Bool { + if lhs._optionalGroupAllTypes != rhs._optionalGroupAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestParsingMerge.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestParsingMerge.protoMessageName + ".RepeatedGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{15}repeated_group_all_types\0") + + 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 21: try { try decoder.decodeSingularMessageField(value: &self._repeatedGroupAllTypes) }() + 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 + try { if let v = self._repeatedGroupAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 21) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestParsingMerge.RepeatedGroup, rhs: SwiftProtoTesting_TestParsingMerge.RepeatedGroup) -> Bool { + if lhs._repeatedGroupAllTypes != rhs._repeatedGroupAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/google/protobuf/unittest_import_public_lite.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_import.pb.swift similarity index 71% rename from Reference/google/protobuf/unittest_import_public_lite.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_import.pb.swift index b4f9c4699..a682a26cd 100644 --- a/Reference/google/protobuf/unittest_import_public_lite.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_import.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_import_public_lite.proto +// Source: unittest_import.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -37,9 +38,12 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Author: liujisi@google.com (Pherl Liu) +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// A proto file which is imported by unittest.proto to test importing. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -52,40 +56,49 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittestImport_PublicImportMessageLite { +enum SwiftProtoTesting_Import_ImportEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case importFoo = 7 + case importBar = 8 + case importBaz = 9 + + init() { + self = .importFoo + } + +} + +struct SwiftProtoTesting_Import_ImportMessage: Sendable { // 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 e: Int32 { - get {return _e ?? 0} - set {_e = newValue} + var d: Int32 { + get {_d ?? 0} + set {_d = newValue} } - /// Returns true if `e` has been explicitly set. - var hasE: Bool {return self._e != nil} - /// Clears the value of `e`. Subsequent reads from it will return its default value. - mutating func clearE() {self._e = nil} + /// Returns true if `d` has been explicitly set. + var hasD: Bool {self._d != nil} + /// Clears the value of `d`. Subsequent reads from it will return its default value. + mutating func clearD() {self._d = nil} var unknownFields = SwiftProtobuf.UnknownStorage() init() {} - fileprivate var _e: Int32? = nil + fileprivate var _d: Int32? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittestImport_PublicImportMessageLite: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest_import" +fileprivate let _protobuf_package = "swift_proto_testing.import" + +extension SwiftProtoTesting_Import_ImportEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7}IMPORT_FOO\0\u{1}IMPORT_BAR\0\u{1}IMPORT_BAZ\0") +} -extension ProtobufUnittestImport_PublicImportMessageLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".PublicImportMessageLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "e"), - ] +extension SwiftProtoTesting_Import_ImportMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ImportMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}d\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -93,7 +106,7 @@ extension ProtobufUnittestImport_PublicImportMessageLite: SwiftProtobuf.Message, // 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._e) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self._d) }() default: break } } @@ -104,14 +117,14 @@ extension ProtobufUnittestImport_PublicImportMessageLite: SwiftProtobuf.Message, // 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._e { + try { if let v = self._d { try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestImport_PublicImportMessageLite, rhs: ProtobufUnittestImport_PublicImportMessageLite) -> Bool { - if lhs._e != rhs._e {return false} + static func ==(lhs: SwiftProtoTesting_Import_ImportMessage, rhs: SwiftProtoTesting_Import_ImportMessage) -> Bool { + if lhs._d != rhs._d {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } diff --git a/Reference/google/protobuf/unittest_import_public.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_import_public.pb.swift similarity index 84% rename from Reference/google/protobuf/unittest_import_public.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_import_public.pb.swift index d049db08c..f1008d656 100644 --- a/Reference/google/protobuf/unittest_import_public.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_import_public.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_import_public.proto +// Source: unittest_import_public.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -39,7 +40,6 @@ // Author: liujisi@google.com (Pherl Liu) -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -52,17 +52,17 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittestImport_PublicImportMessage { +struct SwiftProtoTesting_Import_PublicImportMessage: Sendable { // 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 e: Int32 { - get {return _e ?? 0} + get {_e ?? 0} set {_e = newValue} } /// Returns true if `e` has been explicitly set. - var hasE: Bool {return self._e != nil} + var hasE: Bool {self._e != nil} /// Clears the value of `e`. Subsequent reads from it will return its default value. mutating func clearE() {self._e = nil} @@ -73,19 +73,13 @@ struct ProtobufUnittestImport_PublicImportMessage { fileprivate var _e: Int32? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittestImport_PublicImportMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest_import" +fileprivate let _protobuf_package = "swift_proto_testing.import" -extension ProtobufUnittestImport_PublicImportMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Import_PublicImportMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".PublicImportMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "e"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}e\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -110,7 +104,7 @@ extension ProtobufUnittestImport_PublicImportMessage: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestImport_PublicImportMessage, rhs: ProtobufUnittestImport_PublicImportMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Import_PublicImportMessage, rhs: SwiftProtoTesting_Import_PublicImportMessage) -> Bool { if lhs._e != rhs._e {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Reference/Tests/SwiftProtobufTests/unittest_mset.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_mset.pb.swift new file mode 100644 index 000000000..b2edf38ae --- /dev/null +++ b/Reference/Tests/SwiftProtobufTests/unittest_mset.pb.swift @@ -0,0 +1,695 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: unittest_mset.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// This file is similar to unittest_mset_wire_format.proto, but does not +// have a TestMessageSet, so it can be downgraded to proto1. + +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 SwiftProtoTesting_TestMessageSetContainer: Sendable { + // 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 messageSet: SwiftProtoTesting_WireFormat_TestMessageSet { + get {_messageSet ?? SwiftProtoTesting_WireFormat_TestMessageSet()} + set {_messageSet = newValue} + } + /// Returns true if `messageSet` has been explicitly set. + var hasMessageSet: Bool {self._messageSet != nil} + /// Clears the value of `messageSet`. Subsequent reads from it will return its default value. + mutating func clearMessageSet() {self._messageSet = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _messageSet: SwiftProtoTesting_WireFormat_TestMessageSet? = nil +} + +/// A message without the message_set_wire_format option but still supports +/// extensions. +struct SwiftProtoTesting_MessageEx: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +struct SwiftProtoTesting_TestMessageSetExtension1: Sendable { + // 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 i: Int32 { + get {_i ?? 0} + set {_i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {self._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {self._i = nil} + + var recursive: SwiftProtoTesting_WireFormat_TestMessageSet { + get {_recursive ?? SwiftProtoTesting_WireFormat_TestMessageSet()} + set {_recursive = newValue} + } + /// Returns true if `recursive` has been explicitly set. + var hasRecursive: Bool {self._recursive != nil} + /// Clears the value of `recursive`. Subsequent reads from it will return its default value. + mutating func clearRecursive() {self._recursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _i: Int32? = nil + fileprivate var _recursive: SwiftProtoTesting_WireFormat_TestMessageSet? = nil +} + +struct SwiftProtoTesting_TestMessageSetExtension2: Sendable { + // 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 str: String { + get {_str ?? String()} + set {_str = newValue} + } + /// Returns true if `str` has been explicitly set. + var hasStr: Bool {self._str != nil} + /// Clears the value of `str`. Subsequent reads from it will return its default value. + mutating func clearStr() {self._str = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _str: String? = nil +} + +/// This isn't on swift_proto_testing.wire_format.TestMessageSet, so it will be unknown +/// when parsing there. +struct SwiftProtoTesting_TestMessageSetExtension3: Sendable { + // 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 x: Int32 { + get {_x ?? 0} + set {_x = newValue} + } + /// Returns true if `x` has been explicitly set. + var hasX: Bool {self._x != nil} + /// Clears the value of `x`. Subsequent reads from it will return its default value. + mutating func clearX() {self._x = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _x: Int32? = nil +} + +/// MessageSet wire format is equivalent to this. +struct SwiftProtoTesting_RawMessageSet: Sendable { + // 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 item: [SwiftProtoTesting_RawMessageSet.Item] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct Item: Sendable { + // 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 typeID: Int32 { + get {_typeID ?? 0} + set {_typeID = newValue} + } + /// Returns true if `typeID` has been explicitly set. + var hasTypeID: Bool {self._typeID != nil} + /// Clears the value of `typeID`. Subsequent reads from it will return its default value. + mutating func clearTypeID() {self._typeID = nil} + + var message: Data { + get {_message ?? Data()} + set {_message = newValue} + } + /// Returns true if `message` has been explicitly set. + var hasMessage: Bool {self._message != nil} + /// Clears the value of `message`. Subsequent reads from it will return its default value. + mutating func clearMessage() {self._message = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _typeID: Int32? = nil + fileprivate var _message: Data? = nil + } + + init() {} +} + +/// MessageSet wire format is equivalent to this but since the fields +/// are repeated they can be left off or over present to testing. +struct SwiftProtoTesting_RawBreakableMessageSet: Sendable { + // 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 item: [SwiftProtoTesting_RawBreakableMessageSet.Item] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct Item: Sendable { + // 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 typeID: [Int32] = [] + + var message: [Data] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + init() {} +} + +// MARK: - Extension support defined in unittest_mset.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 SwiftProtoTesting_MessageEx { + + var SwiftProtoTesting_TestMessageSetExtension1_doppelgangerMessageSetExtension: SwiftProtoTesting_TestMessageSetExtension1 { + get {return getExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension1.Extensions.doppelganger_message_set_extension) ?? SwiftProtoTesting_TestMessageSetExtension1()} + set {setExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension1.Extensions.doppelganger_message_set_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_TestMessageSetExtension1.Extensions.doppelganger_message_set_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_TestMessageSetExtension1_doppelgangerMessageSetExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension1.Extensions.doppelganger_message_set_extension) + } + /// Clears the value of extension `SwiftProtoTesting_TestMessageSetExtension1.Extensions.doppelganger_message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_TestMessageSetExtension1_doppelgangerMessageSetExtension() { + clearExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension1.Extensions.doppelganger_message_set_extension) + } + + var SwiftProtoTesting_TestMessageSetExtension3_doppelgangerMessageSetExtension: SwiftProtoTesting_TestMessageSetExtension3 { + get {return getExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension3.Extensions.doppelganger_message_set_extension) ?? SwiftProtoTesting_TestMessageSetExtension3()} + set {setExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension3.Extensions.doppelganger_message_set_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_TestMessageSetExtension3.Extensions.doppelganger_message_set_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_TestMessageSetExtension3_doppelgangerMessageSetExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension3.Extensions.doppelganger_message_set_extension) + } + /// Clears the value of extension `SwiftProtoTesting_TestMessageSetExtension3.Extensions.doppelganger_message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_TestMessageSetExtension3_doppelgangerMessageSetExtension() { + clearExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension3.Extensions.doppelganger_message_set_extension) + } +} + +extension SwiftProtoTesting_WireFormat_TestMessageSet { + + var SwiftProtoTesting_TestMessageSetExtension1_messageSetExtension: SwiftProtoTesting_TestMessageSetExtension1 { + get {return getExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension) ?? SwiftProtoTesting_TestMessageSetExtension1()} + set {setExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_TestMessageSetExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension) + } + /// Clears the value of extension `SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_TestMessageSetExtension1_messageSetExtension() { + clearExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension) + } + + var SwiftProtoTesting_TestMessageSetExtension2_messageSetExtension: SwiftProtoTesting_TestMessageSetExtension2 { + get {return getExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension) ?? SwiftProtoTesting_TestMessageSetExtension2()} + set {setExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_TestMessageSetExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension) + } + /// Clears the value of extension `SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_TestMessageSetExtension2_messageSetExtension() { + clearExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension) + } + +} + +// MARK: - File's ExtensionMap: SwiftProtoTesting_UnittestMset_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 SwiftProtoTesting_UnittestMset_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension, + SwiftProtoTesting_TestMessageSetExtension1.Extensions.doppelganger_message_set_extension, + SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension, + SwiftProtoTesting_TestMessageSetExtension3.Extensions.doppelganger_message_set_extension +] + +// 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. + +extension SwiftProtoTesting_TestMessageSetExtension1 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_WireFormat_TestMessageSet>( + _protobuf_fieldNumber: 1545008, + fieldName: "swift_proto_testing.TestMessageSetExtension1" + ) + + static let doppelganger_message_set_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_MessageEx>( + _protobuf_fieldNumber: 1545008, + fieldName: "swift_proto_testing.TestMessageSetExtension1.doppelganger_message_set_extension" + ) + } +} + +extension SwiftProtoTesting_TestMessageSetExtension2 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_WireFormat_TestMessageSet>( + _protobuf_fieldNumber: 1547769, + fieldName: "swift_proto_testing.TestMessageSetExtension2" + ) + } +} + +extension SwiftProtoTesting_TestMessageSetExtension3 { + enum Extensions { + static let doppelganger_message_set_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_MessageEx>( + _protobuf_fieldNumber: 1547770, + fieldName: "swift_proto_testing.TestMessageSetExtension3.doppelganger_message_set_extension" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_proto_testing" + +extension SwiftProtoTesting_TestMessageSetContainer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageSetContainer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}message_set\0") + + public var isInitialized: Bool { + if let v = self._messageSet, !v.isInitialized {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._messageSet) }() + 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 + try { if let v = self._messageSet { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestMessageSetContainer, rhs: SwiftProtoTesting_TestMessageSetContainer) -> Bool { + if lhs._messageSet != rhs._messageSet {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_MessageEx: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MessageEx" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (4 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_MessageEx.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 4, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_MessageEx, rhs: SwiftProtoTesting_MessageEx) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension SwiftProtoTesting_TestMessageSetExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageSetExtension1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{f}i\0\u{1}recursive\0") + + public var isInitialized: Bool { + if let v = self._recursive, !v.isInitialized {return false} + return true + } + + 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 15: try { try decoder.decodeSingularInt32Field(value: &self._i) }() + case 16: try { try decoder.decodeSingularMessageField(value: &self._recursive) }() + 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 + try { if let v = self._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 15) + } }() + try { if let v = self._recursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 16) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestMessageSetExtension1, rhs: SwiftProtoTesting_TestMessageSetExtension1) -> Bool { + if lhs._i != rhs._i {return false} + if lhs._recursive != rhs._recursive {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestMessageSetExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageSetExtension2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{19}str\0") + + 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 25: try { try decoder.decodeSingularStringField(value: &self._str) }() + 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 + try { if let v = self._str { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestMessageSetExtension2, rhs: SwiftProtoTesting_TestMessageSetExtension2) -> Bool { + if lhs._str != rhs._str {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestMessageSetExtension3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageSetExtension3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{1a}x\0") + + 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 26: try { try decoder.decodeSingularInt32Field(value: &self._x) }() + 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 + try { if let v = self._x { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 26) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestMessageSetExtension3, rhs: SwiftProtoTesting_TestMessageSetExtension3) -> Bool { + if lhs._x != rhs._x {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_RawMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".RawMessageSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{7}Item\0") + + public var isInitialized: Bool { + if !SwiftProtobuf.Internal.areAllInitialized(self.item) {return false} + return true + } + + 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.decodeRepeatedGroupField(value: &self.item) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.item.isEmpty { + try visitor.visitRepeatedGroupField(value: self.item, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_RawMessageSet, rhs: SwiftProtoTesting_RawMessageSet) -> Bool { + if lhs.item != rhs.item {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_RawMessageSet.Item: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_RawMessageSet.protoMessageName + ".Item" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{2}type_id\0\u{1}message\0") + + public var isInitialized: Bool { + if self._typeID == nil {return false} + if self._message == nil {return false} + return true + } + + 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 2: try { try decoder.decodeSingularInt32Field(value: &self._typeID) }() + case 3: try { try decoder.decodeSingularBytesField(value: &self._message) }() + 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 + try { if let v = self._typeID { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._message { + try visitor.visitSingularBytesField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_RawMessageSet.Item, rhs: SwiftProtoTesting_RawMessageSet.Item) -> Bool { + if lhs._typeID != rhs._typeID {return false} + if lhs._message != rhs._message {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_RawBreakableMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".RawBreakableMessageSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{7}Item\0") + + 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.decodeRepeatedGroupField(value: &self.item) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.item.isEmpty { + try visitor.visitRepeatedGroupField(value: self.item, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_RawBreakableMessageSet, rhs: SwiftProtoTesting_RawBreakableMessageSet) -> Bool { + if lhs.item != rhs.item {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_RawBreakableMessageSet.Item: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_RawBreakableMessageSet.protoMessageName + ".Item" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{2}type_id\0\u{1}message\0") + + 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 2: try { try decoder.decodeRepeatedInt32Field(value: &self.typeID) }() + case 3: try { try decoder.decodeRepeatedBytesField(value: &self.message) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.typeID.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.typeID, fieldNumber: 2) + } + if !self.message.isEmpty { + try visitor.visitRepeatedBytesField(value: self.message, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_RawBreakableMessageSet.Item, rhs: SwiftProtoTesting_RawBreakableMessageSet.Item) -> Bool { + if lhs.typeID != rhs.typeID {return false} + if lhs.message != rhs.message {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/Tests/SwiftProtobufTests/unittest_mset_wire_format.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_mset_wire_format.pb.swift new file mode 100644 index 000000000..0f94f6c9d --- /dev/null +++ b/Reference/Tests/SwiftProtobufTests/unittest_mset_wire_format.pb.swift @@ -0,0 +1,99 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: unittest_mset_wire_format.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// This file contains messages for testing message_set_wire_format. + +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 +} + +/// A message with message_set_wire_format. +struct SwiftProtoTesting_WireFormat_TestMessageSet: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_proto_testing.wire_format" + +extension SwiftProtoTesting_WireFormat_TestMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_WireFormat_TestMessageSet.self) + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_WireFormat_TestMessageSet, rhs: SwiftProtoTesting_WireFormat_TestMessageSet) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} diff --git a/Reference/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum.pb.swift new file mode 100644 index 000000000..a2b0d5e2a --- /dev/null +++ b/Reference/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum.pb.swift @@ -0,0 +1,382 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: unittest_preserve_unknown_enum.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +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 SwiftProtoTesting_UnknownEnum_Proto3_MyEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foo // = 0 + case bar // = 1 + case baz // = 2 + case UNRECOGNIZED(Int) + + init() { + self = .foo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .foo + case 1: self = .bar + case 2: self = .baz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .foo: return 0 + case .bar: return 1 + case .baz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_UnknownEnum_Proto3_MyEnum] = [ + .foo, + .bar, + .baz, + ] + +} + +enum SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case eFoo // = 0 + case eBar // = 1 + case eBaz // = 2 + case eExtra // = 3 + case UNRECOGNIZED(Int) + + init() { + self = .eFoo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .eFoo + case 1: self = .eBar + case 2: self = .eBaz + case 3: self = .eExtra + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .eFoo: return 0 + case .eBar: return 1 + case .eBaz: return 2 + case .eExtra: return 3 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra] = [ + .eFoo, + .eBar, + .eBaz, + .eExtra, + ] + +} + +struct SwiftProtoTesting_UnknownEnum_Proto3_MyMessage: Sendable { + // 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 e: SwiftProtoTesting_UnknownEnum_Proto3_MyEnum = .foo + + var repeatedE: [SwiftProtoTesting_UnknownEnum_Proto3_MyEnum] = [] + + var repeatedPackedE: [SwiftProtoTesting_UnknownEnum_Proto3_MyEnum] = [] + + /// not packed + var repeatedPackedUnexpectedE: [SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra] = [] + + var o: SwiftProtoTesting_UnknownEnum_Proto3_MyMessage.OneOf_O? = nil + + var oneofE1: SwiftProtoTesting_UnknownEnum_Proto3_MyEnum { + get { + if case .oneofE1(let v)? = o {return v} + return .foo + } + set {o = .oneofE1(newValue)} + } + + var oneofE2: SwiftProtoTesting_UnknownEnum_Proto3_MyEnum { + get { + if case .oneofE2(let v)? = o {return v} + return .foo + } + set {o = .oneofE2(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_O: Equatable, Sendable { + case oneofE1(SwiftProtoTesting_UnknownEnum_Proto3_MyEnum) + case oneofE2(SwiftProtoTesting_UnknownEnum_Proto3_MyEnum) + + } + + init() {} +} + +struct SwiftProtoTesting_UnknownEnum_Proto3_MyMessagePlusExtra: Sendable { + // 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 e: SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra = .eFoo + + var repeatedE: [SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra] = [] + + var repeatedPackedE: [SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra] = [] + + var repeatedPackedUnexpectedE: [SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra] = [] + + var o: SwiftProtoTesting_UnknownEnum_Proto3_MyMessagePlusExtra.OneOf_O? = nil + + var oneofE1: SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra { + get { + if case .oneofE1(let v)? = o {return v} + return .eFoo + } + set {o = .oneofE1(newValue)} + } + + var oneofE2: SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra { + get { + if case .oneofE2(let v)? = o {return v} + return .eFoo + } + set {o = .oneofE2(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_O: Equatable, Sendable { + case oneofE1(SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra) + case oneofE2(SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra) + + } + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_proto_testing.unknown_enum.proto3" + +extension SwiftProtoTesting_UnknownEnum_Proto3_MyEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0E_FOO\0\u{1}E_BAR\0\u{1}E_BAZ\0\u{1}E_EXTRA\0") +} + +extension SwiftProtoTesting_UnknownEnum_Proto3_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MyMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}e\0\u{3}repeated_e\0\u{3}repeated_packed_e\0\u{3}repeated_packed_unexpected_e\0\u{3}oneof_e_1\0\u{3}oneof_e_2\0") + + 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.e) }() + case 2: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedE) }() + case 3: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedPackedE) }() + case 4: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedPackedUnexpectedE) }() + case 5: try { + var v: SwiftProtoTesting_UnknownEnum_Proto3_MyEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if self.o != nil {try decoder.handleConflictingOneOf()} + self.o = .oneofE1(v) + } + }() + case 6: try { + var v: SwiftProtoTesting_UnknownEnum_Proto3_MyEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if self.o != nil {try decoder.handleConflictingOneOf()} + self.o = .oneofE2(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 + if self.e != .foo { + try visitor.visitSingularEnumField(value: self.e, fieldNumber: 1) + } + if !self.repeatedE.isEmpty { + try visitor.visitPackedEnumField(value: self.repeatedE, fieldNumber: 2) + } + if !self.repeatedPackedE.isEmpty { + try visitor.visitPackedEnumField(value: self.repeatedPackedE, fieldNumber: 3) + } + if !self.repeatedPackedUnexpectedE.isEmpty { + try visitor.visitPackedEnumField(value: self.repeatedPackedUnexpectedE, fieldNumber: 4) + } + switch self.o { + case .oneofE1?: try { + guard case .oneofE1(let v)? = self.o else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + }() + case .oneofE2?: try { + guard case .oneofE2(let v)? = self.o else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_UnknownEnum_Proto3_MyMessage, rhs: SwiftProtoTesting_UnknownEnum_Proto3_MyMessage) -> Bool { + if lhs.e != rhs.e {return false} + if lhs.repeatedE != rhs.repeatedE {return false} + if lhs.repeatedPackedE != rhs.repeatedPackedE {return false} + if lhs.repeatedPackedUnexpectedE != rhs.repeatedPackedUnexpectedE {return false} + if lhs.o != rhs.o {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_UnknownEnum_Proto3_MyMessagePlusExtra: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MyMessagePlusExtra" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}e\0\u{3}repeated_e\0\u{3}repeated_packed_e\0\u{3}repeated_packed_unexpected_e\0\u{3}oneof_e_1\0\u{3}oneof_e_2\0") + + 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.e) }() + case 2: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedE) }() + case 3: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedPackedE) }() + case 4: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedPackedUnexpectedE) }() + case 5: try { + var v: SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if self.o != nil {try decoder.handleConflictingOneOf()} + self.o = .oneofE1(v) + } + }() + case 6: try { + var v: SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if self.o != nil {try decoder.handleConflictingOneOf()} + self.o = .oneofE2(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 + if self.e != .eFoo { + try visitor.visitSingularEnumField(value: self.e, fieldNumber: 1) + } + if !self.repeatedE.isEmpty { + try visitor.visitPackedEnumField(value: self.repeatedE, fieldNumber: 2) + } + if !self.repeatedPackedE.isEmpty { + try visitor.visitPackedEnumField(value: self.repeatedPackedE, fieldNumber: 3) + } + if !self.repeatedPackedUnexpectedE.isEmpty { + try visitor.visitPackedEnumField(value: self.repeatedPackedUnexpectedE, fieldNumber: 4) + } + switch self.o { + case .oneofE1?: try { + guard case .oneofE1(let v)? = self.o else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + }() + case .oneofE2?: try { + guard case .oneofE2(let v)? = self.o else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_UnknownEnum_Proto3_MyMessagePlusExtra, rhs: SwiftProtoTesting_UnknownEnum_Proto3_MyMessagePlusExtra) -> Bool { + if lhs.e != rhs.e {return false} + if lhs.repeatedE != rhs.repeatedE {return false} + if lhs.repeatedPackedE != rhs.repeatedPackedE {return false} + if lhs.repeatedPackedUnexpectedE != rhs.repeatedPackedUnexpectedE {return false} + if lhs.o != rhs.o {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/google/protobuf/unittest_preserve_unknown_enum2.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum2.pb.swift similarity index 63% rename from Reference/google/protobuf/unittest_preserve_unknown_enum2.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum2.pb.swift index afa3f8b27..87e2ba7ec 100644 --- a/Reference/google/protobuf/unittest_preserve_unknown_enum2.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum2.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_preserve_unknown_enum2.proto +// Source: unittest_preserve_unknown_enum2.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -37,7 +38,6 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -50,67 +50,41 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum Proto2PreserveUnknownEnumUnittest_MyEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 0 - case bar // = 1 - case baz // = 2 +enum SwiftProtoTesting_UnknownEnum_Proto2_MyEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 init() { self = .foo } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .foo - case 1: self = .bar - case 2: self = .baz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo: return 0 - case .bar: return 1 - case .baz: return 2 - } - } - -} - -#if swift(>=4.2) - -extension Proto2PreserveUnknownEnumUnittest_MyEnum: CaseIterable { - // Support synthesized by the compiler. } -#endif // swift(>=4.2) - -struct Proto2PreserveUnknownEnumUnittest_MyMessage { +struct SwiftProtoTesting_UnknownEnum_Proto2_MyMessage: Sendable { // 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 e: Proto2PreserveUnknownEnumUnittest_MyEnum { - get {return _e ?? .foo} + var e: SwiftProtoTesting_UnknownEnum_Proto2_MyEnum { + get {_e ?? .foo} set {_e = newValue} } /// Returns true if `e` has been explicitly set. - var hasE: Bool {return self._e != nil} + var hasE: Bool {self._e != nil} /// Clears the value of `e`. Subsequent reads from it will return its default value. mutating func clearE() {self._e = nil} - var repeatedE: [Proto2PreserveUnknownEnumUnittest_MyEnum] = [] + var repeatedE: [SwiftProtoTesting_UnknownEnum_Proto2_MyEnum] = [] - var repeatedPackedE: [Proto2PreserveUnknownEnumUnittest_MyEnum] = [] + var repeatedPackedE: [SwiftProtoTesting_UnknownEnum_Proto2_MyEnum] = [] /// not packed - var repeatedPackedUnexpectedE: [Proto2PreserveUnknownEnumUnittest_MyEnum] = [] + var repeatedPackedUnexpectedE: [SwiftProtoTesting_UnknownEnum_Proto2_MyEnum] = [] - var o: Proto2PreserveUnknownEnumUnittest_MyMessage.OneOf_O? = nil + var o: SwiftProtoTesting_UnknownEnum_Proto2_MyMessage.OneOf_O? = nil - var oneofE1: Proto2PreserveUnknownEnumUnittest_MyEnum { + var oneofE1: SwiftProtoTesting_UnknownEnum_Proto2_MyEnum { get { if case .oneofE1(let v)? = o {return v} return .foo @@ -118,7 +92,7 @@ struct Proto2PreserveUnknownEnumUnittest_MyMessage { set {o = .oneofE1(newValue)} } - var oneofE2: Proto2PreserveUnknownEnumUnittest_MyEnum { + var oneofE2: SwiftProtoTesting_UnknownEnum_Proto2_MyEnum { get { if case .oneofE2(let v)? = o {return v} return .foo @@ -128,63 +102,28 @@ struct Proto2PreserveUnknownEnumUnittest_MyMessage { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_O: Equatable { - case oneofE1(Proto2PreserveUnknownEnumUnittest_MyEnum) - case oneofE2(Proto2PreserveUnknownEnumUnittest_MyEnum) + enum OneOf_O: Equatable, Sendable { + case oneofE1(SwiftProtoTesting_UnknownEnum_Proto2_MyEnum) + case oneofE2(SwiftProtoTesting_UnknownEnum_Proto2_MyEnum) - #if !swift(>=4.1) - static func ==(lhs: Proto2PreserveUnknownEnumUnittest_MyMessage.OneOf_O, rhs: Proto2PreserveUnknownEnumUnittest_MyMessage.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 (.oneofE1, .oneofE1): return { - guard case .oneofE1(let l) = lhs, case .oneofE1(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofE2, .oneofE2): return { - guard case .oneofE2(let l) = lhs, case .oneofE2(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } init() {} - fileprivate var _e: Proto2PreserveUnknownEnumUnittest_MyEnum? = nil + fileprivate var _e: SwiftProtoTesting_UnknownEnum_Proto2_MyEnum? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension Proto2PreserveUnknownEnumUnittest_MyEnum: @unchecked Sendable {} -extension Proto2PreserveUnknownEnumUnittest_MyMessage: @unchecked Sendable {} -extension Proto2PreserveUnknownEnumUnittest_MyMessage.OneOf_O: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "proto2_preserve_unknown_enum_unittest" +fileprivate let _protobuf_package = "swift_proto_testing.unknown_enum.proto2" -extension Proto2PreserveUnknownEnumUnittest_MyEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - ] +extension SwiftProtoTesting_UnknownEnum_Proto2_MyEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOO\0\u{1}BAR\0\u{1}BAZ\0") } -extension Proto2PreserveUnknownEnumUnittest_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_UnknownEnum_Proto2_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MyMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "e"), - 2: .standard(proto: "repeated_e"), - 3: .standard(proto: "repeated_packed_e"), - 4: .standard(proto: "repeated_packed_unexpected_e"), - 5: .standard(proto: "oneof_e_1"), - 6: .standard(proto: "oneof_e_2"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}e\0\u{3}repeated_e\0\u{3}repeated_packed_e\0\u{3}repeated_packed_unexpected_e\0\u{3}oneof_e_1\0\u{3}oneof_e_2\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -197,7 +136,7 @@ extension Proto2PreserveUnknownEnumUnittest_MyMessage: SwiftProtobuf.Message, Sw case 3: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedPackedE) }() case 4: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedPackedUnexpectedE) }() case 5: try { - var v: Proto2PreserveUnknownEnumUnittest_MyEnum? + var v: SwiftProtoTesting_UnknownEnum_Proto2_MyEnum? try decoder.decodeSingularEnumField(value: &v) if let v = v { if self.o != nil {try decoder.handleConflictingOneOf()} @@ -205,7 +144,7 @@ extension Proto2PreserveUnknownEnumUnittest_MyMessage: SwiftProtobuf.Message, Sw } }() case 6: try { - var v: Proto2PreserveUnknownEnumUnittest_MyEnum? + var v: SwiftProtoTesting_UnknownEnum_Proto2_MyEnum? try decoder.decodeSingularEnumField(value: &v) if let v = v { if self.o != nil {try decoder.handleConflictingOneOf()} @@ -248,7 +187,7 @@ extension Proto2PreserveUnknownEnumUnittest_MyMessage: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto2PreserveUnknownEnumUnittest_MyMessage, rhs: Proto2PreserveUnknownEnumUnittest_MyMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_UnknownEnum_Proto2_MyMessage, rhs: SwiftProtoTesting_UnknownEnum_Proto2_MyMessage) -> Bool { if lhs._e != rhs._e {return false} if lhs.repeatedE != rhs.repeatedE {return false} if lhs.repeatedPackedE != rhs.repeatedPackedE {return false} diff --git a/Reference/google/protobuf/unittest_proto3.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_proto3.pb.swift similarity index 67% rename from Reference/google/protobuf/unittest_proto3.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_proto3.pb.swift index d847df7fc..b27fa0d4d 100644 --- a/Reference/google/protobuf/unittest_proto3.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_proto3.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_proto3.proto +// Source: unittest_proto3.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -50,7 +51,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum Proto3Unittest_ForeignEnum: SwiftProtobuf.Enum { +enum SwiftProtoTesting_Proto3_ForeignEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foreignZero // = 0 case foreignFoo // = 4 @@ -82,296 +83,247 @@ enum Proto3Unittest_ForeignEnum: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension Proto3Unittest_ForeignEnum: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto3Unittest_ForeignEnum] = [ + static let allCases: [SwiftProtoTesting_Proto3_ForeignEnum] = [ .foreignZero, .foreignFoo, .foreignBar, .foreignBaz, ] -} -#endif // swift(>=4.2) +} /// This proto includes every type of field in both singular and repeated /// forms. -struct Proto3Unittest_TestAllTypes { +struct SwiftProtoTesting_Proto3_TestAllTypes: @unchecked Sendable { // 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. /// Singular var optionalInt32: Int32 { - get {return _storage._optionalInt32} + get {_storage._optionalInt32} set {_uniqueStorage()._optionalInt32 = newValue} } var optionalInt64: Int64 { - get {return _storage._optionalInt64} + get {_storage._optionalInt64} set {_uniqueStorage()._optionalInt64 = newValue} } var optionalUint32: UInt32 { - get {return _storage._optionalUint32} + get {_storage._optionalUint32} set {_uniqueStorage()._optionalUint32 = newValue} } var optionalUint64: UInt64 { - get {return _storage._optionalUint64} + get {_storage._optionalUint64} set {_uniqueStorage()._optionalUint64 = newValue} } var optionalSint32: Int32 { - get {return _storage._optionalSint32} + get {_storage._optionalSint32} set {_uniqueStorage()._optionalSint32 = newValue} } var optionalSint64: Int64 { - get {return _storage._optionalSint64} + get {_storage._optionalSint64} set {_uniqueStorage()._optionalSint64 = newValue} } var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32} + get {_storage._optionalFixed32} set {_uniqueStorage()._optionalFixed32 = newValue} } var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64} + get {_storage._optionalFixed64} set {_uniqueStorage()._optionalFixed64 = newValue} } var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32} + get {_storage._optionalSfixed32} set {_uniqueStorage()._optionalSfixed32 = newValue} } var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64} + get {_storage._optionalSfixed64} set {_uniqueStorage()._optionalSfixed64 = newValue} } var optionalFloat: Float { - get {return _storage._optionalFloat} + get {_storage._optionalFloat} set {_uniqueStorage()._optionalFloat = newValue} } var optionalDouble: Double { - get {return _storage._optionalDouble} + get {_storage._optionalDouble} set {_uniqueStorage()._optionalDouble = newValue} } var optionalBool: Bool { - get {return _storage._optionalBool} + get {_storage._optionalBool} set {_uniqueStorage()._optionalBool = newValue} } var optionalString: String { - get {return _storage._optionalString} + get {_storage._optionalString} set {_uniqueStorage()._optionalString = newValue} } var optionalBytes: Data { - get {return _storage._optionalBytes} + get {_storage._optionalBytes} set {_uniqueStorage()._optionalBytes = newValue} } - var optionalNestedMessage: Proto3Unittest_TestAllTypes.NestedMessage { - get {return _storage._optionalNestedMessage ?? Proto3Unittest_TestAllTypes.NestedMessage()} + var optionalNestedMessage: SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage { + get {_storage._optionalNestedMessage ?? SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage()} set {_uniqueStorage()._optionalNestedMessage = newValue} } /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} - var optionalForeignMessage: Proto3Unittest_ForeignMessage { - get {return _storage._optionalForeignMessage ?? Proto3Unittest_ForeignMessage()} + var optionalForeignMessage: SwiftProtoTesting_Proto3_ForeignMessage { + get {_storage._optionalForeignMessage ?? SwiftProtoTesting_Proto3_ForeignMessage()} set {_uniqueStorage()._optionalForeignMessage = newValue} } /// Returns true if `optionalForeignMessage` has been explicitly set. - var hasOptionalForeignMessage: Bool {return _storage._optionalForeignMessage != nil} + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} - var optionalImportMessage: ProtobufUnittestImport_ImportMessage { - get {return _storage._optionalImportMessage ?? ProtobufUnittestImport_ImportMessage()} + var optionalImportMessage: SwiftProtoTesting_Import_ImportMessage { + get {_storage._optionalImportMessage ?? SwiftProtoTesting_Import_ImportMessage()} set {_uniqueStorage()._optionalImportMessage = newValue} } /// Returns true if `optionalImportMessage` has been explicitly set. - var hasOptionalImportMessage: Bool {return _storage._optionalImportMessage != nil} + var hasOptionalImportMessage: Bool {_storage._optionalImportMessage != nil} /// Clears the value of `optionalImportMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalImportMessage() {_uniqueStorage()._optionalImportMessage = nil} - var optionalNestedEnum: Proto3Unittest_TestAllTypes.NestedEnum { - get {return _storage._optionalNestedEnum} + var optionalNestedEnum: SwiftProtoTesting_Proto3_TestAllTypes.NestedEnum { + get {_storage._optionalNestedEnum} set {_uniqueStorage()._optionalNestedEnum = newValue} } - var optionalForeignEnum: Proto3Unittest_ForeignEnum { - get {return _storage._optionalForeignEnum} + var optionalForeignEnum: SwiftProtoTesting_Proto3_ForeignEnum { + get {_storage._optionalForeignEnum} set {_uniqueStorage()._optionalForeignEnum = newValue} } - var optionalStringPiece: String { - get {return _storage._optionalStringPiece} - set {_uniqueStorage()._optionalStringPiece = newValue} - } - - var optionalCord: String { - get {return _storage._optionalCord} - set {_uniqueStorage()._optionalCord = newValue} - } - /// Defined in unittest_import_public.proto - var optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessage { - get {return _storage._optionalPublicImportMessage ?? ProtobufUnittestImport_PublicImportMessage()} + var optionalPublicImportMessage: SwiftProtoTesting_Import_PublicImportMessage { + get {_storage._optionalPublicImportMessage ?? SwiftProtoTesting_Import_PublicImportMessage()} set {_uniqueStorage()._optionalPublicImportMessage = newValue} } /// Returns true if `optionalPublicImportMessage` has been explicitly set. - var hasOptionalPublicImportMessage: Bool {return _storage._optionalPublicImportMessage != nil} + var hasOptionalPublicImportMessage: Bool {_storage._optionalPublicImportMessage != nil} /// Clears the value of `optionalPublicImportMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalPublicImportMessage() {_uniqueStorage()._optionalPublicImportMessage = nil} - var optionalLazyMessage: Proto3Unittest_TestAllTypes.NestedMessage { - get {return _storage._optionalLazyMessage ?? Proto3Unittest_TestAllTypes.NestedMessage()} - set {_uniqueStorage()._optionalLazyMessage = newValue} - } - /// Returns true if `optionalLazyMessage` has been explicitly set. - var hasOptionalLazyMessage: Bool {return _storage._optionalLazyMessage != nil} - /// Clears the value of `optionalLazyMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalLazyMessage() {_uniqueStorage()._optionalLazyMessage = nil} - - var optionalLazyImportMessage: ProtobufUnittestImport_ImportMessage { - get {return _storage._optionalLazyImportMessage ?? ProtobufUnittestImport_ImportMessage()} - set {_uniqueStorage()._optionalLazyImportMessage = newValue} - } - /// Returns true if `optionalLazyImportMessage` has been explicitly set. - var hasOptionalLazyImportMessage: Bool {return _storage._optionalLazyImportMessage != nil} - /// Clears the value of `optionalLazyImportMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalLazyImportMessage() {_uniqueStorage()._optionalLazyImportMessage = nil} - /// Repeated var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } - var repeatedNestedMessage: [Proto3Unittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedNestedMessage} + var repeatedNestedMessage: [SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage] { + get {_storage._repeatedNestedMessage} set {_uniqueStorage()._repeatedNestedMessage = newValue} } - var repeatedForeignMessage: [Proto3Unittest_ForeignMessage] { - get {return _storage._repeatedForeignMessage} + var repeatedForeignMessage: [SwiftProtoTesting_Proto3_ForeignMessage] { + get {_storage._repeatedForeignMessage} set {_uniqueStorage()._repeatedForeignMessage = newValue} } - var repeatedImportMessage: [ProtobufUnittestImport_ImportMessage] { - get {return _storage._repeatedImportMessage} + var repeatedImportMessage: [SwiftProtoTesting_Import_ImportMessage] { + get {_storage._repeatedImportMessage} set {_uniqueStorage()._repeatedImportMessage = newValue} } - var repeatedNestedEnum: [Proto3Unittest_TestAllTypes.NestedEnum] { - get {return _storage._repeatedNestedEnum} + var repeatedNestedEnum: [SwiftProtoTesting_Proto3_TestAllTypes.NestedEnum] { + get {_storage._repeatedNestedEnum} set {_uniqueStorage()._repeatedNestedEnum = newValue} } - var repeatedForeignEnum: [Proto3Unittest_ForeignEnum] { - get {return _storage._repeatedForeignEnum} + var repeatedForeignEnum: [SwiftProtoTesting_Proto3_ForeignEnum] { + get {_storage._repeatedForeignEnum} set {_uniqueStorage()._repeatedForeignEnum = newValue} } - var repeatedStringPiece: [String] { - get {return _storage._repeatedStringPiece} - set {_uniqueStorage()._repeatedStringPiece = newValue} - } - - var repeatedCord: [String] { - get {return _storage._repeatedCord} - set {_uniqueStorage()._repeatedCord = newValue} - } - - var repeatedLazyMessage: [Proto3Unittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedLazyMessage} - set {_uniqueStorage()._repeatedLazyMessage = newValue} - } - var oneofField: OneOf_OneofField? { get {return _storage._oneofField} set {_uniqueStorage()._oneofField = newValue} @@ -385,10 +337,10 @@ struct Proto3Unittest_TestAllTypes { set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} } - var oneofNestedMessage: Proto3Unittest_TestAllTypes.NestedMessage { + var oneofNestedMessage: SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage { get { if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} - return Proto3Unittest_TestAllTypes.NestedMessage() + return SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage() } set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} } @@ -411,41 +363,15 @@ struct Proto3Unittest_TestAllTypes { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case oneofUint32(UInt32) - case oneofNestedMessage(Proto3Unittest_TestAllTypes.NestedMessage) + case oneofNestedMessage(SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage) case oneofString(String) case oneofBytes(Data) - #if !swift(>=4.1) - static func ==(lhs: Proto3Unittest_TestAllTypes.OneOf_OneofField, rhs: Proto3Unittest_TestAllTypes.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum NestedEnum: SwiftProtobuf.Enum { + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case zero // = 0 case foo // = 1 @@ -482,9 +408,18 @@ struct Proto3Unittest_TestAllTypes { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Proto3_TestAllTypes.NestedEnum] = [ + .zero, + .foo, + .bar, + .baz, + .neg, + ] + } - struct NestedMessage { + struct NestedMessage: Sendable { // 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. @@ -504,22 +439,7 @@ struct Proto3Unittest_TestAllTypes { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension Proto3Unittest_TestAllTypes.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto3Unittest_TestAllTypes.NestedEnum] = [ - .zero, - .foo, - .bar, - .baz, - .neg, - ] -} - -#endif // swift(>=4.2) - -struct Proto3Unittest_TestPackedTypes { +struct SwiftProtoTesting_Proto3_TestPackedTypes: Sendable { // 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. @@ -550,7 +470,7 @@ struct Proto3Unittest_TestPackedTypes { var packedBool: [Bool] = [] - var packedEnum: [Proto3Unittest_ForeignEnum] = [] + var packedEnum: [SwiftProtoTesting_Proto3_ForeignEnum] = [] var unknownFields = SwiftProtobuf.UnknownStorage() @@ -558,7 +478,7 @@ struct Proto3Unittest_TestPackedTypes { } /// Explicitly set packed to false -struct Proto3Unittest_TestUnpackedTypes { +struct SwiftProtoTesting_Proto3_TestUnpackedTypes: Sendable { // 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. @@ -589,7 +509,7 @@ struct Proto3Unittest_TestUnpackedTypes { var repeatedBool: [Bool] = [] - var repeatedNestedEnum: [Proto3Unittest_TestAllTypes.NestedEnum] = [] + var repeatedNestedEnum: [SwiftProtoTesting_Proto3_TestAllTypes.NestedEnum] = [] var unknownFields = SwiftProtobuf.UnknownStorage() @@ -597,26 +517,26 @@ struct Proto3Unittest_TestUnpackedTypes { } /// This proto includes a recursively nested message. -struct Proto3Unittest_NestedTestAllTypes { +struct SwiftProtoTesting_Proto3_NestedTestAllTypes: @unchecked Sendable { // 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 child: Proto3Unittest_NestedTestAllTypes { - get {return _storage._child ?? Proto3Unittest_NestedTestAllTypes()} + var child: SwiftProtoTesting_Proto3_NestedTestAllTypes { + get {_storage._child ?? SwiftProtoTesting_Proto3_NestedTestAllTypes()} set {_uniqueStorage()._child = newValue} } /// Returns true if `child` has been explicitly set. - var hasChild: Bool {return _storage._child != nil} + var hasChild: Bool {_storage._child != nil} /// Clears the value of `child`. Subsequent reads from it will return its default value. mutating func clearChild() {_uniqueStorage()._child = nil} - var payload: Proto3Unittest_TestAllTypes { - get {return _storage._payload ?? Proto3Unittest_TestAllTypes()} + var payload: SwiftProtoTesting_Proto3_TestAllTypes { + get {_storage._payload ?? SwiftProtoTesting_Proto3_TestAllTypes()} set {_uniqueStorage()._payload = newValue} } /// Returns true if `payload` has been explicitly set. - var hasPayload: Bool {return _storage._payload != nil} + var hasPayload: Bool {_storage._payload != nil} /// Clears the value of `payload`. Subsequent reads from it will return its default value. mutating func clearPayload() {_uniqueStorage()._payload = nil} @@ -629,7 +549,7 @@ struct Proto3Unittest_NestedTestAllTypes { /// Define these after TestAllTypes to make sure the compiler can handle /// that. -struct Proto3Unittest_ForeignMessage { +struct SwiftProtoTesting_Proto3_ForeignMessage: Sendable { // 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. @@ -642,7 +562,7 @@ struct Proto3Unittest_ForeignMessage { } /// TestEmptyMessage is used to test behavior of unknown fields. -struct Proto3Unittest_TestEmptyMessage { +struct SwiftProtoTesting_Proto3_TestEmptyMessage: Sendable { // 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. @@ -652,195 +572,39 @@ struct Proto3Unittest_TestEmptyMessage { init() {} } -/// TestMessageWithDummy is also used to test behavior of unknown fields. -struct Proto3Unittest_TestMessageWithDummy { +/// Test a proto3 defined message with a proto2 as a field that has required fields. +struct SwiftProtoTesting_Proto3_TestProto2Required: Sendable { // 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. - /// This field is only here for triggering copy-on-write; it's not intended to - /// be serialized. - var dummy: Bool = false - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -/// Same layout as TestOneof2 in unittest.proto to test unknown enum value -/// parsing behavior in oneof. -struct Proto3Unittest_TestOneof2 { - // 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 foo: Proto3Unittest_TestOneof2.OneOf_Foo? = nil - - var fooEnum: Proto3Unittest_TestOneof2.NestedEnum { - get { - if case .fooEnum(let v)? = foo {return v} - return .unknown - } - set {foo = .fooEnum(newValue)} + var proto2: SwiftProtoTesting_TestRequired { + get {_proto2 ?? SwiftProtoTesting_TestRequired()} + set {_proto2 = newValue} } + /// Returns true if `proto2` has been explicitly set. + var hasProto2: Bool {self._proto2 != nil} + /// Clears the value of `proto2`. Subsequent reads from it will return its default value. + mutating func clearProto2() {self._proto2 = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_Foo: Equatable { - case fooEnum(Proto3Unittest_TestOneof2.NestedEnum) - - #if !swift(>=4.1) - static func ==(lhs: Proto3Unittest_TestOneof2.OneOf_Foo, rhs: Proto3Unittest_TestOneof2.OneOf_Foo) -> 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 (.fooEnum, .fooEnum): return { - guard case .fooEnum(let l) = lhs, case .fooEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - } - } - #endif - } - - enum NestedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case unknown // = 0 - case foo // = 1 - case bar // = 2 - case baz // = 3 - case UNRECOGNIZED(Int) - - init() { - self = .unknown - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .unknown - case 1: self = .foo - case 2: self = .bar - case 3: self = .baz - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .unknown: return 0 - case .foo: return 1 - case .bar: return 2 - case .baz: return 3 - case .UNRECOGNIZED(let i): return i - } - } - - } - init() {} -} - -#if swift(>=4.2) -extension Proto3Unittest_TestOneof2.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto3Unittest_TestOneof2.NestedEnum] = [ - .unknown, - .foo, - .bar, - .baz, - ] + fileprivate var _proto2: SwiftProtoTesting_TestRequired? = nil } -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension Proto3Unittest_ForeignEnum: @unchecked Sendable {} -extension Proto3Unittest_TestAllTypes: @unchecked Sendable {} -extension Proto3Unittest_TestAllTypes.OneOf_OneofField: @unchecked Sendable {} -extension Proto3Unittest_TestAllTypes.NestedEnum: @unchecked Sendable {} -extension Proto3Unittest_TestAllTypes.NestedMessage: @unchecked Sendable {} -extension Proto3Unittest_TestPackedTypes: @unchecked Sendable {} -extension Proto3Unittest_TestUnpackedTypes: @unchecked Sendable {} -extension Proto3Unittest_NestedTestAllTypes: @unchecked Sendable {} -extension Proto3Unittest_ForeignMessage: @unchecked Sendable {} -extension Proto3Unittest_TestEmptyMessage: @unchecked Sendable {} -extension Proto3Unittest_TestMessageWithDummy: @unchecked Sendable {} -extension Proto3Unittest_TestOneof2: @unchecked Sendable {} -extension Proto3Unittest_TestOneof2.OneOf_Foo: @unchecked Sendable {} -extension Proto3Unittest_TestOneof2.NestedEnum: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "proto3_unittest" +fileprivate let _protobuf_package = "swift_proto_testing.proto3" -extension Proto3Unittest_ForeignEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOREIGN_ZERO"), - 4: .same(proto: "FOREIGN_FOO"), - 5: .same(proto: "FOREIGN_BAR"), - 6: .same(proto: "FOREIGN_BAZ"), - ] +extension SwiftProtoTesting_Proto3_ForeignEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_ZERO\0\u{2}\u{4}FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") } -extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Proto3_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "optional_foreign_message"), - 20: .standard(proto: "optional_import_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "optional_foreign_enum"), - 24: .standard(proto: "optional_string_piece"), - 25: .standard(proto: "optional_cord"), - 26: .standard(proto: "optional_public_import_message"), - 27: .standard(proto: "optional_lazy_message"), - 115: .standard(proto: "optional_lazy_import_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 48: .standard(proto: "repeated_nested_message"), - 49: .standard(proto: "repeated_foreign_message"), - 50: .standard(proto: "repeated_import_message"), - 51: .standard(proto: "repeated_nested_enum"), - 52: .standard(proto: "repeated_foreign_enum"), - 54: .standard(proto: "repeated_string_piece"), - 55: .standard(proto: "repeated_cord"), - 57: .standard(proto: "repeated_lazy_message"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{3}optional_import_message\0\u{3}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{4}\u{4}optional_public_import_message\0\u{4}\u{5}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{3}repeated_import_message\0\u{3}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4};oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0") fileprivate class _StorageClass { var _optionalInt32: Int32 = 0 @@ -858,16 +622,12 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes var _optionalBool: Bool = false var _optionalString: String = String() var _optionalBytes: Data = Data() - var _optionalNestedMessage: Proto3Unittest_TestAllTypes.NestedMessage? = nil - var _optionalForeignMessage: Proto3Unittest_ForeignMessage? = nil - var _optionalImportMessage: ProtobufUnittestImport_ImportMessage? = nil - var _optionalNestedEnum: Proto3Unittest_TestAllTypes.NestedEnum = .zero - var _optionalForeignEnum: Proto3Unittest_ForeignEnum = .foreignZero - var _optionalStringPiece: String = String() - var _optionalCord: String = String() - var _optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessage? = nil - var _optionalLazyMessage: Proto3Unittest_TestAllTypes.NestedMessage? = nil - var _optionalLazyImportMessage: ProtobufUnittestImport_ImportMessage? = nil + var _optionalNestedMessage: SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage? = nil + var _optionalForeignMessage: SwiftProtoTesting_Proto3_ForeignMessage? = nil + var _optionalImportMessage: SwiftProtoTesting_Import_ImportMessage? = nil + var _optionalNestedEnum: SwiftProtoTesting_Proto3_TestAllTypes.NestedEnum = .zero + var _optionalForeignEnum: SwiftProtoTesting_Proto3_ForeignEnum = .foreignZero + var _optionalPublicImportMessage: SwiftProtoTesting_Import_PublicImportMessage? = nil var _repeatedInt32: [Int32] = [] var _repeatedInt64: [Int64] = [] var _repeatedUint32: [UInt32] = [] @@ -883,17 +643,18 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes var _repeatedBool: [Bool] = [] var _repeatedString: [String] = [] var _repeatedBytes: [Data] = [] - var _repeatedNestedMessage: [Proto3Unittest_TestAllTypes.NestedMessage] = [] - var _repeatedForeignMessage: [Proto3Unittest_ForeignMessage] = [] - var _repeatedImportMessage: [ProtobufUnittestImport_ImportMessage] = [] - var _repeatedNestedEnum: [Proto3Unittest_TestAllTypes.NestedEnum] = [] - var _repeatedForeignEnum: [Proto3Unittest_ForeignEnum] = [] - var _repeatedStringPiece: [String] = [] - var _repeatedCord: [String] = [] - var _repeatedLazyMessage: [Proto3Unittest_TestAllTypes.NestedMessage] = [] - var _oneofField: Proto3Unittest_TestAllTypes.OneOf_OneofField? - - static let defaultInstance = _StorageClass() + var _repeatedNestedMessage: [SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage] = [] + var _repeatedForeignMessage: [SwiftProtoTesting_Proto3_ForeignMessage] = [] + var _repeatedImportMessage: [SwiftProtoTesting_Import_ImportMessage] = [] + var _repeatedNestedEnum: [SwiftProtoTesting_Proto3_TestAllTypes.NestedEnum] = [] + var _repeatedForeignEnum: [SwiftProtoTesting_Proto3_ForeignEnum] = [] + var _oneofField: SwiftProtoTesting_Proto3_TestAllTypes.OneOf_OneofField? + + // 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() private init() {} @@ -918,11 +679,7 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes _optionalImportMessage = source._optionalImportMessage _optionalNestedEnum = source._optionalNestedEnum _optionalForeignEnum = source._optionalForeignEnum - _optionalStringPiece = source._optionalStringPiece - _optionalCord = source._optionalCord _optionalPublicImportMessage = source._optionalPublicImportMessage - _optionalLazyMessage = source._optionalLazyMessage - _optionalLazyImportMessage = source._optionalLazyImportMessage _repeatedInt32 = source._repeatedInt32 _repeatedInt64 = source._repeatedInt64 _repeatedUint32 = source._repeatedUint32 @@ -943,9 +700,6 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes _repeatedImportMessage = source._repeatedImportMessage _repeatedNestedEnum = source._repeatedNestedEnum _repeatedForeignEnum = source._repeatedForeignEnum - _repeatedStringPiece = source._repeatedStringPiece - _repeatedCord = source._repeatedCord - _repeatedLazyMessage = source._repeatedLazyMessage _oneofField = source._oneofField } } @@ -985,10 +739,7 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes case 20: try { try decoder.decodeSingularMessageField(value: &_storage._optionalImportMessage) }() case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() - case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() - case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() case 26: try { try decoder.decodeSingularMessageField(value: &_storage._optionalPublicImportMessage) }() - case 27: try { try decoder.decodeSingularMessageField(value: &_storage._optionalLazyMessage) }() case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() @@ -1009,9 +760,6 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes case 50: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedImportMessage) }() case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() - case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() - case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() - case 57: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedLazyMessage) }() case 111: try { var v: UInt32? try decoder.decodeSingularUInt32Field(value: &v) @@ -1021,7 +769,7 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes } }() case 112: try { - var v: Proto3Unittest_TestAllTypes.NestedMessage? + var v: SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage? var hadOneofValue = false if let current = _storage._oneofField { hadOneofValue = true @@ -1049,7 +797,6 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes _storage._oneofField = .oneofBytes(v) } }() - case 115: try { try decoder.decodeSingularMessageField(value: &_storage._optionalLazyImportMessage) }() default: break } } @@ -1092,10 +839,10 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes if _storage._optionalSfixed64 != 0 { try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) } - if _storage._optionalFloat != 0 { + if _storage._optionalFloat.bitPattern != 0 { try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) } - if _storage._optionalDouble != 0 { + if _storage._optionalDouble.bitPattern != 0 { try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) } if _storage._optionalBool != false { @@ -1122,18 +869,9 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes if _storage._optionalForeignEnum != .foreignZero { try visitor.visitSingularEnumField(value: _storage._optionalForeignEnum, fieldNumber: 22) } - if !_storage._optionalStringPiece.isEmpty { - try visitor.visitSingularStringField(value: _storage._optionalStringPiece, fieldNumber: 24) - } - if !_storage._optionalCord.isEmpty { - try visitor.visitSingularStringField(value: _storage._optionalCord, fieldNumber: 25) - } try { if let v = _storage._optionalPublicImportMessage { try visitor.visitSingularMessageField(value: v, fieldNumber: 26) } }() - try { if let v = _storage._optionalLazyMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 27) - } }() if !_storage._repeatedInt32.isEmpty { try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) } @@ -1194,15 +932,6 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes if !_storage._repeatedForeignEnum.isEmpty { try visitor.visitPackedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) } - if !_storage._repeatedStringPiece.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) - } - if !_storage._repeatedCord.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) - } - if !_storage._repeatedLazyMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedLazyMessage, fieldNumber: 57) - } switch _storage._oneofField { case .oneofUint32?: try { guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } @@ -1222,14 +951,11 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes }() case nil: break } - try { if let v = _storage._optionalLazyImportMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 115) - } }() } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3Unittest_TestAllTypes, rhs: Proto3Unittest_TestAllTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_Proto3_TestAllTypes, rhs: SwiftProtoTesting_Proto3_TestAllTypes) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -1254,11 +980,7 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes if _storage._optionalImportMessage != rhs_storage._optionalImportMessage {return false} if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} - if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} - if _storage._optionalCord != rhs_storage._optionalCord {return false} if _storage._optionalPublicImportMessage != rhs_storage._optionalPublicImportMessage {return false} - if _storage._optionalLazyMessage != rhs_storage._optionalLazyMessage {return false} - if _storage._optionalLazyImportMessage != rhs_storage._optionalLazyImportMessage {return false} if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} @@ -1279,9 +1001,6 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes if _storage._repeatedImportMessage != rhs_storage._repeatedImportMessage {return false} if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} - if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} - if _storage._repeatedCord != rhs_storage._repeatedCord {return false} - if _storage._repeatedLazyMessage != rhs_storage._repeatedLazyMessage {return false} if _storage._oneofField != rhs_storage._oneofField {return false} return true } @@ -1292,21 +1011,13 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes } } -extension Proto3Unittest_TestAllTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -1: .same(proto: "NEG"), - 0: .same(proto: "ZERO"), - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - 3: .same(proto: "BAZ"), - ] +extension SwiftProtoTesting_Proto3_TestAllTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}ZERO\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") } -extension Proto3Unittest_TestAllTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = Proto3Unittest_TestAllTypes.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - ] +extension SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Proto3_TestAllTypes.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1327,31 +1038,16 @@ extension Proto3Unittest_TestAllTypes.NestedMessage: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3Unittest_TestAllTypes.NestedMessage, rhs: Proto3Unittest_TestAllTypes.NestedMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage, rhs: SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage) -> Bool { if lhs.bb != rhs.bb {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Proto3Unittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Proto3_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestPackedTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 90: .standard(proto: "packed_int32"), - 91: .standard(proto: "packed_int64"), - 92: .standard(proto: "packed_uint32"), - 93: .standard(proto: "packed_uint64"), - 94: .standard(proto: "packed_sint32"), - 95: .standard(proto: "packed_sint64"), - 96: .standard(proto: "packed_fixed32"), - 97: .standard(proto: "packed_fixed64"), - 98: .standard(proto: "packed_sfixed32"), - 99: .standard(proto: "packed_sfixed64"), - 100: .standard(proto: "packed_float"), - 101: .standard(proto: "packed_double"), - 102: .standard(proto: "packed_bool"), - 103: .standard(proto: "packed_enum"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}Z\u{1}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1424,7 +1120,7 @@ extension Proto3Unittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._ try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3Unittest_TestPackedTypes, rhs: Proto3Unittest_TestPackedTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_Proto3_TestPackedTypes, rhs: SwiftProtoTesting_Proto3_TestPackedTypes) -> Bool { if lhs.packedInt32 != rhs.packedInt32 {return false} if lhs.packedInt64 != rhs.packedInt64 {return false} if lhs.packedUint32 != rhs.packedUint32 {return false} @@ -1444,24 +1140,9 @@ extension Proto3Unittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._ } } -extension Proto3Unittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Proto3_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestUnpackedTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "repeated_int32"), - 2: .standard(proto: "repeated_int64"), - 3: .standard(proto: "repeated_uint32"), - 4: .standard(proto: "repeated_uint64"), - 5: .standard(proto: "repeated_sint32"), - 6: .standard(proto: "repeated_sint64"), - 7: .standard(proto: "repeated_fixed32"), - 8: .standard(proto: "repeated_fixed64"), - 9: .standard(proto: "repeated_sfixed32"), - 10: .standard(proto: "repeated_sfixed64"), - 11: .standard(proto: "repeated_float"), - 12: .standard(proto: "repeated_double"), - 13: .standard(proto: "repeated_bool"), - 14: .standard(proto: "repeated_nested_enum"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_nested_enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1534,7 +1215,7 @@ extension Proto3Unittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3Unittest_TestUnpackedTypes, rhs: Proto3Unittest_TestUnpackedTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_Proto3_TestUnpackedTypes, rhs: SwiftProtoTesting_Proto3_TestUnpackedTypes) -> Bool { if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} if lhs.repeatedInt64 != rhs.repeatedInt64 {return false} if lhs.repeatedUint32 != rhs.repeatedUint32 {return false} @@ -1554,18 +1235,19 @@ extension Proto3Unittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf } } -extension Proto3Unittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Proto3_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".NestedTestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "child"), - 2: .same(proto: "payload"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}child\0\u{1}payload\0") fileprivate class _StorageClass { - var _child: Proto3Unittest_NestedTestAllTypes? = nil - var _payload: Proto3Unittest_TestAllTypes? = nil + var _child: SwiftProtoTesting_Proto3_NestedTestAllTypes? = nil + var _payload: SwiftProtoTesting_Proto3_TestAllTypes? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1614,7 +1296,7 @@ extension Proto3Unittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobu try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3Unittest_NestedTestAllTypes, rhs: Proto3Unittest_NestedTestAllTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_Proto3_NestedTestAllTypes, rhs: SwiftProtoTesting_Proto3_NestedTestAllTypes) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -1630,11 +1312,9 @@ extension Proto3Unittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobu } } -extension Proto3Unittest_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Proto3_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ForeignMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1655,69 +1335,40 @@ extension Proto3Unittest_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._M try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3Unittest_ForeignMessage, rhs: Proto3Unittest_ForeignMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Proto3_ForeignMessage, rhs: SwiftProtoTesting_Proto3_ForeignMessage) -> Bool { if lhs.c != rhs.c {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Proto3Unittest_TestEmptyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Proto3_TestEmptyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestEmptyMessage" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3Unittest_TestEmptyMessage, rhs: Proto3Unittest_TestEmptyMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Proto3_TestEmptyMessage, rhs: SwiftProtoTesting_Proto3_TestEmptyMessage) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Proto3Unittest_TestMessageWithDummy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMessageWithDummy" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 536870911: .same(proto: "dummy"), - ] +extension SwiftProtoTesting_Proto3_TestProto2Required: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestProto2Required" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}proto2\0") - 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 536870911: try { try decoder.decodeSingularBoolField(value: &self.dummy) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if self.dummy != false { - try visitor.visitSingularBoolField(value: self.dummy, fieldNumber: 536870911) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: Proto3Unittest_TestMessageWithDummy, rhs: Proto3Unittest_TestMessageWithDummy) -> Bool { - if lhs.dummy != rhs.dummy {return false} - if lhs.unknownFields != rhs.unknownFields {return false} + public var isInitialized: Bool { + if let v = self._proto2, !v.isInitialized {return false} return true } -} - -extension Proto3Unittest_TestOneof2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestOneof2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 6: .standard(proto: "foo_enum"), - ] mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1725,14 +1376,7 @@ extension Proto3Unittest_TestOneof2: SwiftProtobuf.Message, SwiftProtobuf._Messa // 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 { - var v: Proto3Unittest_TestOneof2.NestedEnum? - try decoder.decodeSingularEnumField(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooEnum(v) - } - }() + case 1: try { try decoder.decodeSingularMessageField(value: &self._proto2) }() default: break } } @@ -1743,24 +1387,15 @@ extension Proto3Unittest_TestOneof2: SwiftProtobuf.Message, SwiftProtobuf._Messa // 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 case .fooEnum(let v)? = self.foo { - try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + try { if let v = self._proto2 { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3Unittest_TestOneof2, rhs: Proto3Unittest_TestOneof2) -> Bool { - if lhs.foo != rhs.foo {return false} + static func ==(lhs: SwiftProtoTesting_Proto3_TestProto2Required, rhs: SwiftProtoTesting_Proto3_TestProto2Required) -> Bool { + if lhs._proto2 != rhs._proto2 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } - -extension Proto3Unittest_TestOneof2.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "UNKNOWN"), - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - 3: .same(proto: "BAZ"), - ] -} diff --git a/Reference/Tests/SwiftProtobufTests/unittest_proto3_optional.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_proto3_optional.pb.swift new file mode 100644 index 000000000..f49518041 --- /dev/null +++ b/Reference/Tests/SwiftProtobufTests/unittest_proto3_optional.pb.swift @@ -0,0 +1,539 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: unittest_proto3_optional.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +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 SwiftProtoTesting_TestProto3Optional: @unchecked Sendable { + // 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. + + /// Singular + var optionalInt32: Int32 { + get {_storage._optionalInt32 ?? 0} + set {_uniqueStorage()._optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} + + var optionalInt64: Int64 { + get {_storage._optionalInt64 ?? 0} + set {_uniqueStorage()._optionalInt64 = newValue} + } + /// Returns true if `optionalInt64` has been explicitly set. + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} + /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} + + var optionalUint32: UInt32 { + get {_storage._optionalUint32 ?? 0} + set {_uniqueStorage()._optionalUint32 = newValue} + } + /// Returns true if `optionalUint32` has been explicitly set. + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} + /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} + + var optionalUint64: UInt64 { + get {_storage._optionalUint64 ?? 0} + set {_uniqueStorage()._optionalUint64 = newValue} + } + /// Returns true if `optionalUint64` has been explicitly set. + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} + /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} + + var optionalSint32: Int32 { + get {_storage._optionalSint32 ?? 0} + set {_uniqueStorage()._optionalSint32 = newValue} + } + /// Returns true if `optionalSint32` has been explicitly set. + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} + /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} + + var optionalSint64: Int64 { + get {_storage._optionalSint64 ?? 0} + set {_uniqueStorage()._optionalSint64 = newValue} + } + /// Returns true if `optionalSint64` has been explicitly set. + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} + /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} + + var optionalFixed32: UInt32 { + get {_storage._optionalFixed32 ?? 0} + set {_uniqueStorage()._optionalFixed32 = newValue} + } + /// Returns true if `optionalFixed32` has been explicitly set. + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} + /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} + + var optionalFixed64: UInt64 { + get {_storage._optionalFixed64 ?? 0} + set {_uniqueStorage()._optionalFixed64 = newValue} + } + /// Returns true if `optionalFixed64` has been explicitly set. + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} + /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} + + var optionalSfixed32: Int32 { + get {_storage._optionalSfixed32 ?? 0} + set {_uniqueStorage()._optionalSfixed32 = newValue} + } + /// Returns true if `optionalSfixed32` has been explicitly set. + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} + /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} + + var optionalSfixed64: Int64 { + get {_storage._optionalSfixed64 ?? 0} + set {_uniqueStorage()._optionalSfixed64 = newValue} + } + /// Returns true if `optionalSfixed64` has been explicitly set. + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} + /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} + + var optionalFloat: Float { + get {_storage._optionalFloat ?? 0} + set {_uniqueStorage()._optionalFloat = newValue} + } + /// Returns true if `optionalFloat` has been explicitly set. + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} + /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} + + var optionalDouble: Double { + get {_storage._optionalDouble ?? 0} + set {_uniqueStorage()._optionalDouble = newValue} + } + /// Returns true if `optionalDouble` has been explicitly set. + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} + /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. + mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} + + var optionalBool: Bool { + get {_storage._optionalBool ?? false} + set {_uniqueStorage()._optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {_storage._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} + + var optionalString: String { + get {_storage._optionalString ?? String()} + set {_uniqueStorage()._optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {_storage._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} + + var optionalBytes: Data { + get {_storage._optionalBytes ?? Data()} + set {_uniqueStorage()._optionalBytes = newValue} + } + /// Returns true if `optionalBytes` has been explicitly set. + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} + /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} + + var optionalNestedMessage: SwiftProtoTesting_TestProto3Optional.NestedMessage { + get {_storage._optionalNestedMessage ?? SwiftProtoTesting_TestProto3Optional.NestedMessage()} + set {_uniqueStorage()._optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} + + var optionalNestedEnum: SwiftProtoTesting_TestProto3Optional.NestedEnum { + get {_storage._optionalNestedEnum ?? .unspecified} + set {_uniqueStorage()._optionalNestedEnum = newValue} + } + /// Returns true if `optionalNestedEnum` has been explicitly set. + var hasOptionalNestedEnum: Bool {_storage._optionalNestedEnum != nil} + /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} + + /// Add some non-optional fields to verify we can mix them. + var singularInt32: Int32 { + get {_storage._singularInt32} + set {_uniqueStorage()._singularInt32 = newValue} + } + + var singularInt64: Int64 { + get {_storage._singularInt64} + set {_uniqueStorage()._singularInt64 = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case unspecified // = 0 + case foo // = 1 + case bar // = 2 + case baz // = 3 + + /// Intentionally negative. + case neg // = -1 + case UNRECOGNIZED(Int) + + init() { + self = .unspecified + } + + init?(rawValue: Int) { + switch rawValue { + case -1: self = .neg + case 0: self = .unspecified + case 1: self = .foo + case 2: self = .bar + case 3: self = .baz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .neg: return -1 + case .unspecified: return 0 + case .foo: return 1 + case .bar: return 2 + case .baz: return 3 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_TestProto3Optional.NestedEnum] = [ + .unspecified, + .foo, + .bar, + .baz, + .neg, + ] + + } + + struct NestedMessage: Sendable { + // 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. + + /// The field name "b" fails to compile in proto1 because it conflicts with + /// a local variable named "b" in one of the generated methods. Doh. + /// This file needs to compile in proto1 to test backwards-compatibility. + var bb: Int32 { + get {_bb ?? 0} + set {_bb = newValue} + } + /// Returns true if `bb` has been explicitly set. + var hasBb: Bool {self._bb != nil} + /// Clears the value of `bb`. Subsequent reads from it will return its default value. + mutating func clearBb() {self._bb = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _bb: Int32? = nil + } + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_proto_testing" + +extension SwiftProtoTesting_TestProto3Optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestProto3Optional" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{4}\u{3}optional_nested_enum\0\u{3}singular_int32\0\u{3}singular_int64\0") + + fileprivate class _StorageClass { + var _optionalInt32: Int32? = nil + var _optionalInt64: Int64? = nil + var _optionalUint32: UInt32? = nil + var _optionalUint64: UInt64? = nil + var _optionalSint32: Int32? = nil + var _optionalSint64: Int64? = nil + var _optionalFixed32: UInt32? = nil + var _optionalFixed64: UInt64? = nil + var _optionalSfixed32: Int32? = nil + var _optionalSfixed64: Int64? = nil + var _optionalFloat: Float? = nil + var _optionalDouble: Double? = nil + var _optionalBool: Bool? = nil + var _optionalString: String? = nil + var _optionalBytes: Data? = nil + var _optionalNestedMessage: SwiftProtoTesting_TestProto3Optional.NestedMessage? = nil + var _optionalNestedEnum: SwiftProtoTesting_TestProto3Optional.NestedEnum? = nil + var _singularInt32: Int32 = 0 + var _singularInt64: Int64 = 0 + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalNestedMessage = source._optionalNestedMessage + _optionalNestedEnum = source._optionalNestedEnum + _singularInt32 = source._singularInt32 + _singularInt64 = source._singularInt64 + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 22: try { try decoder.decodeSingularInt32Field(value: &_storage._singularInt32) }() + case 23: try { try decoder.decodeSingularInt64Field(value: &_storage._singularInt64) }() + default: break + } + } + } + } + + func traverse(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._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._optionalInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._optionalUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._optionalSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._optionalSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._optionalFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._optionalFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._optionalSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._optionalSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._optionalFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._optionalDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._optionalBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._optionalNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + if _storage._singularInt32 != 0 { + try visitor.visitSingularInt32Field(value: _storage._singularInt32, fieldNumber: 22) + } + if _storage._singularInt64 != 0 { + try visitor.visitSingularInt64Field(value: _storage._singularInt64, fieldNumber: 23) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestProto3Optional, rhs: SwiftProtoTesting_TestProto3Optional) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._singularInt32 != rhs_storage._singularInt32 {return false} + if _storage._singularInt64 != rhs_storage._singularInt64 {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestProto3Optional.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}UNSPECIFIED\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension SwiftProtoTesting_TestProto3Optional.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestProto3Optional.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") + + 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._bb) }() + 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 + try { if let v = self._bb { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestProto3Optional.NestedMessage, rhs: SwiftProtoTesting_TestProto3Optional.NestedMessage) -> Bool { + if lhs._bb != rhs._bb {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/unittest_swift_all_required_types.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_all_required_types.pb.swift similarity index 70% rename from Reference/unittest_swift_all_required_types.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_all_required_types.pb.swift index 8100bd2ad..747fc46d3 100644 --- a/Reference/unittest_swift_all_required_types.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_all_required_types.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_all_required_types.proto @@ -52,428 +53,383 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_TestAllRequiredTypes { +struct SwiftProtoTesting_TestAllRequiredTypes: @unchecked Sendable { // 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. /// Singular var requiredInt32: Int32 { - get {return _storage._requiredInt32 ?? 0} + get {_storage._requiredInt32 ?? 0} set {_uniqueStorage()._requiredInt32 = newValue} } /// Returns true if `requiredInt32` has been explicitly set. - var hasRequiredInt32: Bool {return _storage._requiredInt32 != nil} + var hasRequiredInt32: Bool {_storage._requiredInt32 != nil} /// Clears the value of `requiredInt32`. Subsequent reads from it will return its default value. mutating func clearRequiredInt32() {_uniqueStorage()._requiredInt32 = nil} var requiredInt64: Int64 { - get {return _storage._requiredInt64 ?? 0} + get {_storage._requiredInt64 ?? 0} set {_uniqueStorage()._requiredInt64 = newValue} } /// Returns true if `requiredInt64` has been explicitly set. - var hasRequiredInt64: Bool {return _storage._requiredInt64 != nil} + var hasRequiredInt64: Bool {_storage._requiredInt64 != nil} /// Clears the value of `requiredInt64`. Subsequent reads from it will return its default value. mutating func clearRequiredInt64() {_uniqueStorage()._requiredInt64 = nil} var requiredUint32: UInt32 { - get {return _storage._requiredUint32 ?? 0} + get {_storage._requiredUint32 ?? 0} set {_uniqueStorage()._requiredUint32 = newValue} } /// Returns true if `requiredUint32` has been explicitly set. - var hasRequiredUint32: Bool {return _storage._requiredUint32 != nil} + var hasRequiredUint32: Bool {_storage._requiredUint32 != nil} /// Clears the value of `requiredUint32`. Subsequent reads from it will return its default value. mutating func clearRequiredUint32() {_uniqueStorage()._requiredUint32 = nil} var requiredUint64: UInt64 { - get {return _storage._requiredUint64 ?? 0} + get {_storage._requiredUint64 ?? 0} set {_uniqueStorage()._requiredUint64 = newValue} } /// Returns true if `requiredUint64` has been explicitly set. - var hasRequiredUint64: Bool {return _storage._requiredUint64 != nil} + var hasRequiredUint64: Bool {_storage._requiredUint64 != nil} /// Clears the value of `requiredUint64`. Subsequent reads from it will return its default value. mutating func clearRequiredUint64() {_uniqueStorage()._requiredUint64 = nil} var requiredSint32: Int32 { - get {return _storage._requiredSint32 ?? 0} + get {_storage._requiredSint32 ?? 0} set {_uniqueStorage()._requiredSint32 = newValue} } /// Returns true if `requiredSint32` has been explicitly set. - var hasRequiredSint32: Bool {return _storage._requiredSint32 != nil} + var hasRequiredSint32: Bool {_storage._requiredSint32 != nil} /// Clears the value of `requiredSint32`. Subsequent reads from it will return its default value. mutating func clearRequiredSint32() {_uniqueStorage()._requiredSint32 = nil} var requiredSint64: Int64 { - get {return _storage._requiredSint64 ?? 0} + get {_storage._requiredSint64 ?? 0} set {_uniqueStorage()._requiredSint64 = newValue} } /// Returns true if `requiredSint64` has been explicitly set. - var hasRequiredSint64: Bool {return _storage._requiredSint64 != nil} + var hasRequiredSint64: Bool {_storage._requiredSint64 != nil} /// Clears the value of `requiredSint64`. Subsequent reads from it will return its default value. mutating func clearRequiredSint64() {_uniqueStorage()._requiredSint64 = nil} var requiredFixed32: UInt32 { - get {return _storage._requiredFixed32 ?? 0} + get {_storage._requiredFixed32 ?? 0} set {_uniqueStorage()._requiredFixed32 = newValue} } /// Returns true if `requiredFixed32` has been explicitly set. - var hasRequiredFixed32: Bool {return _storage._requiredFixed32 != nil} + var hasRequiredFixed32: Bool {_storage._requiredFixed32 != nil} /// Clears the value of `requiredFixed32`. Subsequent reads from it will return its default value. mutating func clearRequiredFixed32() {_uniqueStorage()._requiredFixed32 = nil} var requiredFixed64: UInt64 { - get {return _storage._requiredFixed64 ?? 0} + get {_storage._requiredFixed64 ?? 0} set {_uniqueStorage()._requiredFixed64 = newValue} } /// Returns true if `requiredFixed64` has been explicitly set. - var hasRequiredFixed64: Bool {return _storage._requiredFixed64 != nil} + var hasRequiredFixed64: Bool {_storage._requiredFixed64 != nil} /// Clears the value of `requiredFixed64`. Subsequent reads from it will return its default value. mutating func clearRequiredFixed64() {_uniqueStorage()._requiredFixed64 = nil} var requiredSfixed32: Int32 { - get {return _storage._requiredSfixed32 ?? 0} + get {_storage._requiredSfixed32 ?? 0} set {_uniqueStorage()._requiredSfixed32 = newValue} } /// Returns true if `requiredSfixed32` has been explicitly set. - var hasRequiredSfixed32: Bool {return _storage._requiredSfixed32 != nil} + var hasRequiredSfixed32: Bool {_storage._requiredSfixed32 != nil} /// Clears the value of `requiredSfixed32`. Subsequent reads from it will return its default value. mutating func clearRequiredSfixed32() {_uniqueStorage()._requiredSfixed32 = nil} var requiredSfixed64: Int64 { - get {return _storage._requiredSfixed64 ?? 0} + get {_storage._requiredSfixed64 ?? 0} set {_uniqueStorage()._requiredSfixed64 = newValue} } /// Returns true if `requiredSfixed64` has been explicitly set. - var hasRequiredSfixed64: Bool {return _storage._requiredSfixed64 != nil} + var hasRequiredSfixed64: Bool {_storage._requiredSfixed64 != nil} /// Clears the value of `requiredSfixed64`. Subsequent reads from it will return its default value. mutating func clearRequiredSfixed64() {_uniqueStorage()._requiredSfixed64 = nil} var requiredFloat: Float { - get {return _storage._requiredFloat ?? 0} + get {_storage._requiredFloat ?? 0} set {_uniqueStorage()._requiredFloat = newValue} } /// Returns true if `requiredFloat` has been explicitly set. - var hasRequiredFloat: Bool {return _storage._requiredFloat != nil} + var hasRequiredFloat: Bool {_storage._requiredFloat != nil} /// Clears the value of `requiredFloat`. Subsequent reads from it will return its default value. mutating func clearRequiredFloat() {_uniqueStorage()._requiredFloat = nil} var requiredDouble: Double { - get {return _storage._requiredDouble ?? 0} + get {_storage._requiredDouble ?? 0} set {_uniqueStorage()._requiredDouble = newValue} } /// Returns true if `requiredDouble` has been explicitly set. - var hasRequiredDouble: Bool {return _storage._requiredDouble != nil} + var hasRequiredDouble: Bool {_storage._requiredDouble != nil} /// Clears the value of `requiredDouble`. Subsequent reads from it will return its default value. mutating func clearRequiredDouble() {_uniqueStorage()._requiredDouble = nil} var requiredBool: Bool { - get {return _storage._requiredBool ?? false} + get {_storage._requiredBool ?? false} set {_uniqueStorage()._requiredBool = newValue} } /// Returns true if `requiredBool` has been explicitly set. - var hasRequiredBool: Bool {return _storage._requiredBool != nil} + var hasRequiredBool: Bool {_storage._requiredBool != nil} /// Clears the value of `requiredBool`. Subsequent reads from it will return its default value. mutating func clearRequiredBool() {_uniqueStorage()._requiredBool = nil} var requiredString: String { - get {return _storage._requiredString ?? String()} + get {_storage._requiredString ?? String()} set {_uniqueStorage()._requiredString = newValue} } /// Returns true if `requiredString` has been explicitly set. - var hasRequiredString: Bool {return _storage._requiredString != nil} + var hasRequiredString: Bool {_storage._requiredString != nil} /// Clears the value of `requiredString`. Subsequent reads from it will return its default value. mutating func clearRequiredString() {_uniqueStorage()._requiredString = nil} var requiredBytes: Data { - get {return _storage._requiredBytes ?? Data()} + get {_storage._requiredBytes ?? Data()} set {_uniqueStorage()._requiredBytes = newValue} } /// Returns true if `requiredBytes` has been explicitly set. - var hasRequiredBytes: Bool {return _storage._requiredBytes != nil} + var hasRequiredBytes: Bool {_storage._requiredBytes != nil} /// Clears the value of `requiredBytes`. Subsequent reads from it will return its default value. mutating func clearRequiredBytes() {_uniqueStorage()._requiredBytes = nil} - var requiredGroup: ProtobufUnittest_TestAllRequiredTypes.RequiredGroup { - get {return _storage._requiredGroup ?? ProtobufUnittest_TestAllRequiredTypes.RequiredGroup()} + var requiredGroup: SwiftProtoTesting_TestAllRequiredTypes.RequiredGroup { + get {_storage._requiredGroup ?? SwiftProtoTesting_TestAllRequiredTypes.RequiredGroup()} set {_uniqueStorage()._requiredGroup = newValue} } /// Returns true if `requiredGroup` has been explicitly set. - var hasRequiredGroup: Bool {return _storage._requiredGroup != nil} + var hasRequiredGroup: Bool {_storage._requiredGroup != nil} /// Clears the value of `requiredGroup`. Subsequent reads from it will return its default value. mutating func clearRequiredGroup() {_uniqueStorage()._requiredGroup = nil} - var requiredNestedMessage: ProtobufUnittest_TestAllRequiredTypes.NestedMessage { - get {return _storage._requiredNestedMessage ?? ProtobufUnittest_TestAllRequiredTypes.NestedMessage()} + var requiredNestedMessage: SwiftProtoTesting_TestAllRequiredTypes.NestedMessage { + get {_storage._requiredNestedMessage ?? SwiftProtoTesting_TestAllRequiredTypes.NestedMessage()} set {_uniqueStorage()._requiredNestedMessage = newValue} } /// Returns true if `requiredNestedMessage` has been explicitly set. - var hasRequiredNestedMessage: Bool {return _storage._requiredNestedMessage != nil} + var hasRequiredNestedMessage: Bool {_storage._requiredNestedMessage != nil} /// Clears the value of `requiredNestedMessage`. Subsequent reads from it will return its default value. mutating func clearRequiredNestedMessage() {_uniqueStorage()._requiredNestedMessage = nil} - var requiredForeignMessage: ProtobufUnittest_ForeignMessage { - get {return _storage._requiredForeignMessage ?? ProtobufUnittest_ForeignMessage()} + var requiredForeignMessage: SwiftProtoTesting_ForeignMessage { + get {_storage._requiredForeignMessage ?? SwiftProtoTesting_ForeignMessage()} set {_uniqueStorage()._requiredForeignMessage = newValue} } /// Returns true if `requiredForeignMessage` has been explicitly set. - var hasRequiredForeignMessage: Bool {return _storage._requiredForeignMessage != nil} + var hasRequiredForeignMessage: Bool {_storage._requiredForeignMessage != nil} /// Clears the value of `requiredForeignMessage`. Subsequent reads from it will return its default value. mutating func clearRequiredForeignMessage() {_uniqueStorage()._requiredForeignMessage = nil} - var requiredImportMessage: ProtobufUnittestImport_ImportMessage { - get {return _storage._requiredImportMessage ?? ProtobufUnittestImport_ImportMessage()} + var requiredImportMessage: SwiftProtoTesting_Import_ImportMessage { + get {_storage._requiredImportMessage ?? SwiftProtoTesting_Import_ImportMessage()} set {_uniqueStorage()._requiredImportMessage = newValue} } /// Returns true if `requiredImportMessage` has been explicitly set. - var hasRequiredImportMessage: Bool {return _storage._requiredImportMessage != nil} + var hasRequiredImportMessage: Bool {_storage._requiredImportMessage != nil} /// Clears the value of `requiredImportMessage`. Subsequent reads from it will return its default value. mutating func clearRequiredImportMessage() {_uniqueStorage()._requiredImportMessage = nil} - var requiredNestedEnum: ProtobufUnittest_TestAllRequiredTypes.NestedEnum { - get {return _storage._requiredNestedEnum ?? .foo} + var requiredNestedEnum: SwiftProtoTesting_TestAllRequiredTypes.NestedEnum { + get {_storage._requiredNestedEnum ?? .foo} set {_uniqueStorage()._requiredNestedEnum = newValue} } /// Returns true if `requiredNestedEnum` has been explicitly set. - var hasRequiredNestedEnum: Bool {return _storage._requiredNestedEnum != nil} + var hasRequiredNestedEnum: Bool {_storage._requiredNestedEnum != nil} /// Clears the value of `requiredNestedEnum`. Subsequent reads from it will return its default value. mutating func clearRequiredNestedEnum() {_uniqueStorage()._requiredNestedEnum = nil} - var requiredForeignEnum: ProtobufUnittest_ForeignEnum { - get {return _storage._requiredForeignEnum ?? .foreignFoo} + var requiredForeignEnum: SwiftProtoTesting_ForeignEnum { + get {_storage._requiredForeignEnum ?? .foreignFoo} set {_uniqueStorage()._requiredForeignEnum = newValue} } /// Returns true if `requiredForeignEnum` has been explicitly set. - var hasRequiredForeignEnum: Bool {return _storage._requiredForeignEnum != nil} + var hasRequiredForeignEnum: Bool {_storage._requiredForeignEnum != nil} /// Clears the value of `requiredForeignEnum`. Subsequent reads from it will return its default value. mutating func clearRequiredForeignEnum() {_uniqueStorage()._requiredForeignEnum = nil} - var requiredImportEnum: ProtobufUnittestImport_ImportEnum { - get {return _storage._requiredImportEnum ?? .importFoo} + var requiredImportEnum: SwiftProtoTesting_Import_ImportEnum { + get {_storage._requiredImportEnum ?? .importFoo} set {_uniqueStorage()._requiredImportEnum = newValue} } /// Returns true if `requiredImportEnum` has been explicitly set. - var hasRequiredImportEnum: Bool {return _storage._requiredImportEnum != nil} + var hasRequiredImportEnum: Bool {_storage._requiredImportEnum != nil} /// Clears the value of `requiredImportEnum`. Subsequent reads from it will return its default value. mutating func clearRequiredImportEnum() {_uniqueStorage()._requiredImportEnum = nil} - var requiredStringPiece: String { - get {return _storage._requiredStringPiece ?? String()} - set {_uniqueStorage()._requiredStringPiece = newValue} - } - /// Returns true if `requiredStringPiece` has been explicitly set. - var hasRequiredStringPiece: Bool {return _storage._requiredStringPiece != nil} - /// Clears the value of `requiredStringPiece`. Subsequent reads from it will return its default value. - mutating func clearRequiredStringPiece() {_uniqueStorage()._requiredStringPiece = nil} - - var requiredCord: String { - get {return _storage._requiredCord ?? String()} - set {_uniqueStorage()._requiredCord = newValue} - } - /// Returns true if `requiredCord` has been explicitly set. - var hasRequiredCord: Bool {return _storage._requiredCord != nil} - /// Clears the value of `requiredCord`. Subsequent reads from it will return its default value. - mutating func clearRequiredCord() {_uniqueStorage()._requiredCord = nil} - /// Defined in unittest_import_public.proto - var requiredPublicImportMessage: ProtobufUnittestImport_PublicImportMessage { - get {return _storage._requiredPublicImportMessage ?? ProtobufUnittestImport_PublicImportMessage()} + var requiredPublicImportMessage: SwiftProtoTesting_Import_PublicImportMessage { + get {_storage._requiredPublicImportMessage ?? SwiftProtoTesting_Import_PublicImportMessage()} set {_uniqueStorage()._requiredPublicImportMessage = newValue} } /// Returns true if `requiredPublicImportMessage` has been explicitly set. - var hasRequiredPublicImportMessage: Bool {return _storage._requiredPublicImportMessage != nil} + var hasRequiredPublicImportMessage: Bool {_storage._requiredPublicImportMessage != nil} /// Clears the value of `requiredPublicImportMessage`. Subsequent reads from it will return its default value. mutating func clearRequiredPublicImportMessage() {_uniqueStorage()._requiredPublicImportMessage = nil} - var requiredLazyMessage: ProtobufUnittest_TestAllRequiredTypes.NestedMessage { - get {return _storage._requiredLazyMessage ?? ProtobufUnittest_TestAllRequiredTypes.NestedMessage()} - set {_uniqueStorage()._requiredLazyMessage = newValue} - } - /// Returns true if `requiredLazyMessage` has been explicitly set. - var hasRequiredLazyMessage: Bool {return _storage._requiredLazyMessage != nil} - /// Clears the value of `requiredLazyMessage`. Subsequent reads from it will return its default value. - mutating func clearRequiredLazyMessage() {_uniqueStorage()._requiredLazyMessage = nil} - /// Singular with defaults var defaultInt32: Int32 { - get {return _storage._defaultInt32 ?? 41} + get {_storage._defaultInt32 ?? 41} set {_uniqueStorage()._defaultInt32 = newValue} } /// Returns true if `defaultInt32` has been explicitly set. - var hasDefaultInt32: Bool {return _storage._defaultInt32 != nil} + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} var defaultInt64: Int64 { - get {return _storage._defaultInt64 ?? 42} + get {_storage._defaultInt64 ?? 42} set {_uniqueStorage()._defaultInt64 = newValue} } /// Returns true if `defaultInt64` has been explicitly set. - var hasDefaultInt64: Bool {return _storage._defaultInt64 != nil} + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} var defaultUint32: UInt32 { - get {return _storage._defaultUint32 ?? 43} + get {_storage._defaultUint32 ?? 43} set {_uniqueStorage()._defaultUint32 = newValue} } /// Returns true if `defaultUint32` has been explicitly set. - var hasDefaultUint32: Bool {return _storage._defaultUint32 != nil} + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} var defaultUint64: UInt64 { - get {return _storage._defaultUint64 ?? 44} + get {_storage._defaultUint64 ?? 44} set {_uniqueStorage()._defaultUint64 = newValue} } /// Returns true if `defaultUint64` has been explicitly set. - var hasDefaultUint64: Bool {return _storage._defaultUint64 != nil} + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} var defaultSint32: Int32 { - get {return _storage._defaultSint32 ?? -45} + get {_storage._defaultSint32 ?? -45} set {_uniqueStorage()._defaultSint32 = newValue} } /// Returns true if `defaultSint32` has been explicitly set. - var hasDefaultSint32: Bool {return _storage._defaultSint32 != nil} + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} var defaultSint64: Int64 { - get {return _storage._defaultSint64 ?? 46} + get {_storage._defaultSint64 ?? 46} set {_uniqueStorage()._defaultSint64 = newValue} } /// Returns true if `defaultSint64` has been explicitly set. - var hasDefaultSint64: Bool {return _storage._defaultSint64 != nil} + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} var defaultFixed32: UInt32 { - get {return _storage._defaultFixed32 ?? 47} + get {_storage._defaultFixed32 ?? 47} set {_uniqueStorage()._defaultFixed32 = newValue} } /// Returns true if `defaultFixed32` has been explicitly set. - var hasDefaultFixed32: Bool {return _storage._defaultFixed32 != nil} + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} var defaultFixed64: UInt64 { - get {return _storage._defaultFixed64 ?? 48} + get {_storage._defaultFixed64 ?? 48} set {_uniqueStorage()._defaultFixed64 = newValue} } /// Returns true if `defaultFixed64` has been explicitly set. - var hasDefaultFixed64: Bool {return _storage._defaultFixed64 != nil} + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} var defaultSfixed32: Int32 { - get {return _storage._defaultSfixed32 ?? 49} + get {_storage._defaultSfixed32 ?? 49} set {_uniqueStorage()._defaultSfixed32 = newValue} } /// Returns true if `defaultSfixed32` has been explicitly set. - var hasDefaultSfixed32: Bool {return _storage._defaultSfixed32 != nil} + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} var defaultSfixed64: Int64 { - get {return _storage._defaultSfixed64 ?? -50} + get {_storage._defaultSfixed64 ?? -50} set {_uniqueStorage()._defaultSfixed64 = newValue} } /// Returns true if `defaultSfixed64` has been explicitly set. - var hasDefaultSfixed64: Bool {return _storage._defaultSfixed64 != nil} + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} var defaultFloat: Float { - get {return _storage._defaultFloat ?? 51.5} + get {_storage._defaultFloat ?? 51.5} set {_uniqueStorage()._defaultFloat = newValue} } /// Returns true if `defaultFloat` has been explicitly set. - var hasDefaultFloat: Bool {return _storage._defaultFloat != nil} + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} var defaultDouble: Double { - get {return _storage._defaultDouble ?? 52000} + get {_storage._defaultDouble ?? 52000} set {_uniqueStorage()._defaultDouble = newValue} } /// Returns true if `defaultDouble` has been explicitly set. - var hasDefaultDouble: Bool {return _storage._defaultDouble != nil} + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} var defaultBool: Bool { - get {return _storage._defaultBool ?? true} + get {_storage._defaultBool ?? true} set {_uniqueStorage()._defaultBool = newValue} } /// Returns true if `defaultBool` has been explicitly set. - var hasDefaultBool: Bool {return _storage._defaultBool != nil} + var hasDefaultBool: Bool {_storage._defaultBool != nil} /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} var defaultString: String { - get {return _storage._defaultString ?? "hello"} + get {_storage._defaultString ?? "hello"} set {_uniqueStorage()._defaultString = newValue} } /// Returns true if `defaultString` has been explicitly set. - var hasDefaultString: Bool {return _storage._defaultString != nil} + var hasDefaultString: Bool {_storage._defaultString != nil} /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} var defaultBytes: Data { - get {return _storage._defaultBytes ?? Data([119, 111, 114, 108, 100])} + get {_storage._defaultBytes ?? Data([119, 111, 114, 108, 100])} set {_uniqueStorage()._defaultBytes = newValue} } /// Returns true if `defaultBytes` has been explicitly set. - var hasDefaultBytes: Bool {return _storage._defaultBytes != nil} + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} - var defaultNestedEnum: ProtobufUnittest_TestAllRequiredTypes.NestedEnum { - get {return _storage._defaultNestedEnum ?? .bar} + var defaultNestedEnum: SwiftProtoTesting_TestAllRequiredTypes.NestedEnum { + get {_storage._defaultNestedEnum ?? .bar} set {_uniqueStorage()._defaultNestedEnum = newValue} } /// Returns true if `defaultNestedEnum` has been explicitly set. - var hasDefaultNestedEnum: Bool {return _storage._defaultNestedEnum != nil} + var hasDefaultNestedEnum: Bool {_storage._defaultNestedEnum != nil} /// Clears the value of `defaultNestedEnum`. Subsequent reads from it will return its default value. mutating func clearDefaultNestedEnum() {_uniqueStorage()._defaultNestedEnum = nil} - var defaultForeignEnum: ProtobufUnittest_ForeignEnum { - get {return _storage._defaultForeignEnum ?? .foreignBar} + var defaultForeignEnum: SwiftProtoTesting_ForeignEnum { + get {_storage._defaultForeignEnum ?? .foreignBar} set {_uniqueStorage()._defaultForeignEnum = newValue} } /// Returns true if `defaultForeignEnum` has been explicitly set. - var hasDefaultForeignEnum: Bool {return _storage._defaultForeignEnum != nil} + var hasDefaultForeignEnum: Bool {_storage._defaultForeignEnum != nil} /// Clears the value of `defaultForeignEnum`. Subsequent reads from it will return its default value. mutating func clearDefaultForeignEnum() {_uniqueStorage()._defaultForeignEnum = nil} - var defaultImportEnum: ProtobufUnittestImport_ImportEnum { - get {return _storage._defaultImportEnum ?? .importBar} + var defaultImportEnum: SwiftProtoTesting_Import_ImportEnum { + get {_storage._defaultImportEnum ?? .importBar} set {_uniqueStorage()._defaultImportEnum = newValue} } /// Returns true if `defaultImportEnum` has been explicitly set. - var hasDefaultImportEnum: Bool {return _storage._defaultImportEnum != nil} + var hasDefaultImportEnum: Bool {_storage._defaultImportEnum != nil} /// Clears the value of `defaultImportEnum`. Subsequent reads from it will return its default value. mutating func clearDefaultImportEnum() {_uniqueStorage()._defaultImportEnum = nil} - var defaultStringPiece: String { - get {return _storage._defaultStringPiece ?? "abc"} - set {_uniqueStorage()._defaultStringPiece = newValue} - } - /// Returns true if `defaultStringPiece` has been explicitly set. - var hasDefaultStringPiece: Bool {return _storage._defaultStringPiece != nil} - /// Clears the value of `defaultStringPiece`. Subsequent reads from it will return its default value. - mutating func clearDefaultStringPiece() {_uniqueStorage()._defaultStringPiece = nil} - - var defaultCord: String { - get {return _storage._defaultCord ?? "123"} - set {_uniqueStorage()._defaultCord = newValue} - } - /// Returns true if `defaultCord` has been explicitly set. - var hasDefaultCord: Bool {return _storage._defaultCord != nil} - /// Clears the value of `defaultCord`. Subsequent reads from it will return its default value. - mutating func clearDefaultCord() {_uniqueStorage()._defaultCord = nil} - /// For oneof test var oneofField: OneOf_OneofField? { get {return _storage._oneofField} @@ -488,10 +444,10 @@ struct ProtobufUnittest_TestAllRequiredTypes { set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} } - var oneofNestedMessage: ProtobufUnittest_TestAllRequiredTypes.NestedMessage { + var oneofNestedMessage: SwiftProtoTesting_TestAllRequiredTypes.NestedMessage { get { if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} - return ProtobufUnittest_TestAllRequiredTypes.NestedMessage() + return SwiftProtoTesting_TestAllRequiredTypes.NestedMessage() } set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} } @@ -515,9 +471,9 @@ struct ProtobufUnittest_TestAllRequiredTypes { var unknownFields = SwiftProtobuf.UnknownStorage() /// For oneof test - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case oneofUint32(UInt32) - case oneofNestedMessage(ProtobufUnittest_TestAllRequiredTypes.NestedMessage) + case oneofNestedMessage(SwiftProtoTesting_TestAllRequiredTypes.NestedMessage) case oneofString(String) case oneofBytes(Data) @@ -526,69 +482,23 @@ struct ProtobufUnittest_TestAllRequiredTypes { return v.isInitialized } - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestAllRequiredTypes.OneOf_OneofField, rhs: ProtobufUnittest_TestAllRequiredTypes.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum NestedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 1 - case bar // = 2 - case baz // = 3 + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 1 + case bar = 2 + case baz = 3 /// Intentionally negative. - case neg // = -1 + case neg = -1 init() { self = .foo } - init?(rawValue: Int) { - switch rawValue { - case -1: self = .neg - case 1: self = .foo - case 2: self = .bar - case 3: self = .baz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .neg: return -1 - case .foo: return 1 - case .bar: return 2 - case .baz: return 3 - } - } - } - struct NestedMessage { + struct NestedMessage: Sendable { // 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. @@ -597,11 +507,11 @@ struct ProtobufUnittest_TestAllRequiredTypes { /// a local variable named "b" in one of the generated methods. Doh. /// This file needs to compile in proto1 to test backwards-compatibility. var bb: Int32 { - get {return _bb ?? 0} + get {_bb ?? 0} set {_bb = newValue} } /// Returns true if `bb` has been explicitly set. - var hasBb: Bool {return self._bb != nil} + var hasBb: Bool {self._bb != nil} /// Clears the value of `bb`. Subsequent reads from it will return its default value. mutating func clearBb() {self._bb = nil} @@ -612,17 +522,17 @@ struct ProtobufUnittest_TestAllRequiredTypes { fileprivate var _bb: Int32? = nil } - struct RequiredGroup { + struct RequiredGroup: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -638,97 +548,75 @@ struct ProtobufUnittest_TestAllRequiredTypes { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension ProtobufUnittest_TestAllRequiredTypes.NestedEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_TestSomeRequiredTypes { +struct SwiftProtoTesting_TestSomeRequiredTypes: Sendable { // 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. /// Singular var requiredInt32: Int32 { - get {return _requiredInt32 ?? 0} + get {_requiredInt32 ?? 0} set {_requiredInt32 = newValue} } /// Returns true if `requiredInt32` has been explicitly set. - var hasRequiredInt32: Bool {return self._requiredInt32 != nil} + var hasRequiredInt32: Bool {self._requiredInt32 != nil} /// Clears the value of `requiredInt32`. Subsequent reads from it will return its default value. mutating func clearRequiredInt32() {self._requiredInt32 = nil} var requiredFloat: Float { - get {return _requiredFloat ?? 0} + get {_requiredFloat ?? 0} set {_requiredFloat = newValue} } /// Returns true if `requiredFloat` has been explicitly set. - var hasRequiredFloat: Bool {return self._requiredFloat != nil} + var hasRequiredFloat: Bool {self._requiredFloat != nil} /// Clears the value of `requiredFloat`. Subsequent reads from it will return its default value. mutating func clearRequiredFloat() {self._requiredFloat = nil} var requiredBool: Bool { - get {return _requiredBool ?? false} + get {_requiredBool ?? false} set {_requiredBool = newValue} } /// Returns true if `requiredBool` has been explicitly set. - var hasRequiredBool: Bool {return self._requiredBool != nil} + var hasRequiredBool: Bool {self._requiredBool != nil} /// Clears the value of `requiredBool`. Subsequent reads from it will return its default value. mutating func clearRequiredBool() {self._requiredBool = nil} var requiredString: String { - get {return _requiredString ?? String()} + get {_requiredString ?? String()} set {_requiredString = newValue} } /// Returns true if `requiredString` has been explicitly set. - var hasRequiredString: Bool {return self._requiredString != nil} + var hasRequiredString: Bool {self._requiredString != nil} /// Clears the value of `requiredString`. Subsequent reads from it will return its default value. mutating func clearRequiredString() {self._requiredString = nil} var requiredBytes: Data { - get {return _requiredBytes ?? Data()} + get {_requiredBytes ?? Data()} set {_requiredBytes = newValue} } /// Returns true if `requiredBytes` has been explicitly set. - var hasRequiredBytes: Bool {return self._requiredBytes != nil} + var hasRequiredBytes: Bool {self._requiredBytes != nil} /// Clears the value of `requiredBytes`. Subsequent reads from it will return its default value. mutating func clearRequiredBytes() {self._requiredBytes = nil} - var requiredNestedEnum: ProtobufUnittest_TestSomeRequiredTypes.NestedEnum { - get {return _requiredNestedEnum ?? .foo} + var requiredNestedEnum: SwiftProtoTesting_TestSomeRequiredTypes.NestedEnum { + get {_requiredNestedEnum ?? .foo} set {_requiredNestedEnum = newValue} } /// Returns true if `requiredNestedEnum` has been explicitly set. - var hasRequiredNestedEnum: Bool {return self._requiredNestedEnum != nil} + var hasRequiredNestedEnum: Bool {self._requiredNestedEnum != nil} /// Clears the value of `requiredNestedEnum`. Subsequent reads from it will return its default value. mutating func clearRequiredNestedEnum() {self._requiredNestedEnum = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - enum NestedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 1 + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 1 init() { self = .foo } - init?(rawValue: Int) { - switch rawValue { - case 1: self = .foo - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo: return 1 - } - } - } init() {} @@ -738,85 +626,16 @@ struct ProtobufUnittest_TestSomeRequiredTypes { fileprivate var _requiredBool: Bool? = nil fileprivate var _requiredString: String? = nil fileprivate var _requiredBytes: Data? = nil - fileprivate var _requiredNestedEnum: ProtobufUnittest_TestSomeRequiredTypes.NestedEnum? = nil -} - -#if swift(>=4.2) - -extension ProtobufUnittest_TestSomeRequiredTypes.NestedEnum: CaseIterable { - // Support synthesized by the compiler. + fileprivate var _requiredNestedEnum: SwiftProtoTesting_TestSomeRequiredTypes.NestedEnum? = nil } -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_TestAllRequiredTypes: @unchecked Sendable {} -extension ProtobufUnittest_TestAllRequiredTypes.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufUnittest_TestAllRequiredTypes.NestedEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestAllRequiredTypes.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestAllRequiredTypes.RequiredGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestSomeRequiredTypes: @unchecked Sendable {} -extension ProtobufUnittest_TestSomeRequiredTypes.NestedEnum: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestAllRequiredTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "required_int32"), - 2: .standard(proto: "required_int64"), - 3: .standard(proto: "required_uint32"), - 4: .standard(proto: "required_uint64"), - 5: .standard(proto: "required_sint32"), - 6: .standard(proto: "required_sint64"), - 7: .standard(proto: "required_fixed32"), - 8: .standard(proto: "required_fixed64"), - 9: .standard(proto: "required_sfixed32"), - 10: .standard(proto: "required_sfixed64"), - 11: .standard(proto: "required_float"), - 12: .standard(proto: "required_double"), - 13: .standard(proto: "required_bool"), - 14: .standard(proto: "required_string"), - 15: .standard(proto: "required_bytes"), - 16: .unique(proto: "RequiredGroup", json: "requiredgroup"), - 18: .standard(proto: "required_nested_message"), - 19: .standard(proto: "required_foreign_message"), - 20: .standard(proto: "required_import_message"), - 21: .standard(proto: "required_nested_enum"), - 22: .standard(proto: "required_foreign_enum"), - 23: .standard(proto: "required_import_enum"), - 24: .standard(proto: "required_string_piece"), - 25: .standard(proto: "required_cord"), - 26: .standard(proto: "required_public_import_message"), - 27: .standard(proto: "required_lazy_message"), - 61: .standard(proto: "default_int32"), - 62: .standard(proto: "default_int64"), - 63: .standard(proto: "default_uint32"), - 64: .standard(proto: "default_uint64"), - 65: .standard(proto: "default_sint32"), - 66: .standard(proto: "default_sint64"), - 67: .standard(proto: "default_fixed32"), - 68: .standard(proto: "default_fixed64"), - 69: .standard(proto: "default_sfixed32"), - 70: .standard(proto: "default_sfixed64"), - 71: .standard(proto: "default_float"), - 72: .standard(proto: "default_double"), - 73: .standard(proto: "default_bool"), - 74: .standard(proto: "default_string"), - 75: .standard(proto: "default_bytes"), - 81: .standard(proto: "default_nested_enum"), - 82: .standard(proto: "default_foreign_enum"), - 83: .standard(proto: "default_import_enum"), - 84: .standard(proto: "default_string_piece"), - 85: .standard(proto: "default_cord"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_int32\0\u{3}required_int64\0\u{3}required_uint32\0\u{3}required_uint64\0\u{3}required_sint32\0\u{3}required_sint64\0\u{3}required_fixed32\0\u{3}required_fixed64\0\u{3}required_sfixed32\0\u{3}required_sfixed64\0\u{3}required_float\0\u{3}required_double\0\u{3}required_bool\0\u{3}required_string\0\u{3}required_bytes\0\u{7}RequiredGroup\0\u{4}\u{2}required_nested_message\0\u{3}required_foreign_message\0\u{3}required_import_message\0\u{3}required_nested_enum\0\u{3}required_foreign_enum\0\u{3}required_import_enum\0\u{4}\u{3}required_public_import_message\0\u{4}#default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{4}\u{6}default_nested_enum\0\u{3}default_foreign_enum\0\u{3}default_import_enum\0\u{4}\u{1c}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0") fileprivate class _StorageClass { var _requiredInt32: Int32? = nil @@ -834,17 +653,14 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro var _requiredBool: Bool? = nil var _requiredString: String? = nil var _requiredBytes: Data? = nil - var _requiredGroup: ProtobufUnittest_TestAllRequiredTypes.RequiredGroup? = nil - var _requiredNestedMessage: ProtobufUnittest_TestAllRequiredTypes.NestedMessage? = nil - var _requiredForeignMessage: ProtobufUnittest_ForeignMessage? = nil - var _requiredImportMessage: ProtobufUnittestImport_ImportMessage? = nil - var _requiredNestedEnum: ProtobufUnittest_TestAllRequiredTypes.NestedEnum? = nil - var _requiredForeignEnum: ProtobufUnittest_ForeignEnum? = nil - var _requiredImportEnum: ProtobufUnittestImport_ImportEnum? = nil - var _requiredStringPiece: String? = nil - var _requiredCord: String? = nil - var _requiredPublicImportMessage: ProtobufUnittestImport_PublicImportMessage? = nil - var _requiredLazyMessage: ProtobufUnittest_TestAllRequiredTypes.NestedMessage? = nil + var _requiredGroup: SwiftProtoTesting_TestAllRequiredTypes.RequiredGroup? = nil + var _requiredNestedMessage: SwiftProtoTesting_TestAllRequiredTypes.NestedMessage? = nil + var _requiredForeignMessage: SwiftProtoTesting_ForeignMessage? = nil + var _requiredImportMessage: SwiftProtoTesting_Import_ImportMessage? = nil + var _requiredNestedEnum: SwiftProtoTesting_TestAllRequiredTypes.NestedEnum? = nil + var _requiredForeignEnum: SwiftProtoTesting_ForeignEnum? = nil + var _requiredImportEnum: SwiftProtoTesting_Import_ImportEnum? = nil + var _requiredPublicImportMessage: SwiftProtoTesting_Import_PublicImportMessage? = nil var _defaultInt32: Int32? = nil var _defaultInt64: Int64? = nil var _defaultUint32: UInt32? = nil @@ -860,14 +676,16 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro var _defaultBool: Bool? = nil var _defaultString: String? = nil var _defaultBytes: Data? = nil - var _defaultNestedEnum: ProtobufUnittest_TestAllRequiredTypes.NestedEnum? = nil - var _defaultForeignEnum: ProtobufUnittest_ForeignEnum? = nil - var _defaultImportEnum: ProtobufUnittestImport_ImportEnum? = nil - var _defaultStringPiece: String? = nil - var _defaultCord: String? = nil - var _oneofField: ProtobufUnittest_TestAllRequiredTypes.OneOf_OneofField? + var _defaultNestedEnum: SwiftProtoTesting_TestAllRequiredTypes.NestedEnum? = nil + var _defaultForeignEnum: SwiftProtoTesting_ForeignEnum? = nil + var _defaultImportEnum: SwiftProtoTesting_Import_ImportEnum? = nil + var _oneofField: SwiftProtoTesting_TestAllRequiredTypes.OneOf_OneofField? - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -894,10 +712,7 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro _requiredNestedEnum = source._requiredNestedEnum _requiredForeignEnum = source._requiredForeignEnum _requiredImportEnum = source._requiredImportEnum - _requiredStringPiece = source._requiredStringPiece - _requiredCord = source._requiredCord _requiredPublicImportMessage = source._requiredPublicImportMessage - _requiredLazyMessage = source._requiredLazyMessage _defaultInt32 = source._defaultInt32 _defaultInt64 = source._defaultInt64 _defaultUint32 = source._defaultUint32 @@ -916,8 +731,6 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro _defaultNestedEnum = source._defaultNestedEnum _defaultForeignEnum = source._defaultForeignEnum _defaultImportEnum = source._defaultImportEnum - _defaultStringPiece = source._defaultStringPiece - _defaultCord = source._defaultCord _oneofField = source._oneofField } } @@ -953,10 +766,7 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro if _storage._requiredNestedEnum == nil {return false} if _storage._requiredForeignEnum == nil {return false} if _storage._requiredImportEnum == nil {return false} - if _storage._requiredStringPiece == nil {return false} - if _storage._requiredCord == nil {return false} if _storage._requiredPublicImportMessage == nil {return false} - if _storage._requiredLazyMessage == nil {return false} if _storage._defaultInt32 == nil {return false} if _storage._defaultInt64 == nil {return false} if _storage._defaultUint32 == nil {return false} @@ -975,11 +785,8 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro if _storage._defaultNestedEnum == nil {return false} if _storage._defaultForeignEnum == nil {return false} if _storage._defaultImportEnum == nil {return false} - if _storage._defaultStringPiece == nil {return false} - if _storage._defaultCord == nil {return false} if let v = _storage._requiredGroup, !v.isInitialized {return false} if let v = _storage._requiredNestedMessage, !v.isInitialized {return false} - if let v = _storage._requiredLazyMessage, !v.isInitialized {return false} if let v = _storage._oneofField, !v.isInitialized {return false} return true } @@ -1015,10 +822,7 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro case 21: try { try decoder.decodeSingularEnumField(value: &_storage._requiredNestedEnum) }() case 22: try { try decoder.decodeSingularEnumField(value: &_storage._requiredForeignEnum) }() case 23: try { try decoder.decodeSingularEnumField(value: &_storage._requiredImportEnum) }() - case 24: try { try decoder.decodeSingularStringField(value: &_storage._requiredStringPiece) }() - case 25: try { try decoder.decodeSingularStringField(value: &_storage._requiredCord) }() case 26: try { try decoder.decodeSingularMessageField(value: &_storage._requiredPublicImportMessage) }() - case 27: try { try decoder.decodeSingularMessageField(value: &_storage._requiredLazyMessage) }() case 61: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() case 62: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() case 63: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() @@ -1037,8 +841,6 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro case 81: try { try decoder.decodeSingularEnumField(value: &_storage._defaultNestedEnum) }() case 82: try { try decoder.decodeSingularEnumField(value: &_storage._defaultForeignEnum) }() case 83: try { try decoder.decodeSingularEnumField(value: &_storage._defaultImportEnum) }() - case 84: try { try decoder.decodeSingularStringField(value: &_storage._defaultStringPiece) }() - case 85: try { try decoder.decodeSingularStringField(value: &_storage._defaultCord) }() case 111: try { var v: UInt32? try decoder.decodeSingularUInt32Field(value: &v) @@ -1048,7 +850,7 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro } }() case 112: try { - var v: ProtobufUnittest_TestAllRequiredTypes.NestedMessage? + var v: SwiftProtoTesting_TestAllRequiredTypes.NestedMessage? var hadOneofValue = false if let current = _storage._oneofField { hadOneofValue = true @@ -1154,18 +956,9 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro try { if let v = _storage._requiredImportEnum { try visitor.visitSingularEnumField(value: v, fieldNumber: 23) } }() - try { if let v = _storage._requiredStringPiece { - try visitor.visitSingularStringField(value: v, fieldNumber: 24) - } }() - try { if let v = _storage._requiredCord { - try visitor.visitSingularStringField(value: v, fieldNumber: 25) - } }() try { if let v = _storage._requiredPublicImportMessage { try visitor.visitSingularMessageField(value: v, fieldNumber: 26) } }() - try { if let v = _storage._requiredLazyMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 27) - } }() try { if let v = _storage._defaultInt32 { try visitor.visitSingularInt32Field(value: v, fieldNumber: 61) } }() @@ -1220,12 +1013,6 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro try { if let v = _storage._defaultImportEnum { try visitor.visitSingularEnumField(value: v, fieldNumber: 83) } }() - try { if let v = _storage._defaultStringPiece { - try visitor.visitSingularStringField(value: v, fieldNumber: 84) - } }() - try { if let v = _storage._defaultCord { - try visitor.visitSingularStringField(value: v, fieldNumber: 85) - } }() switch _storage._oneofField { case .oneofUint32?: try { guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } @@ -1249,7 +1036,7 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestAllRequiredTypes, rhs: ProtobufUnittest_TestAllRequiredTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestAllRequiredTypes, rhs: SwiftProtoTesting_TestAllRequiredTypes) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -1276,10 +1063,7 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro if _storage._requiredNestedEnum != rhs_storage._requiredNestedEnum {return false} if _storage._requiredForeignEnum != rhs_storage._requiredForeignEnum {return false} if _storage._requiredImportEnum != rhs_storage._requiredImportEnum {return false} - if _storage._requiredStringPiece != rhs_storage._requiredStringPiece {return false} - if _storage._requiredCord != rhs_storage._requiredCord {return false} if _storage._requiredPublicImportMessage != rhs_storage._requiredPublicImportMessage {return false} - if _storage._requiredLazyMessage != rhs_storage._requiredLazyMessage {return false} if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} @@ -1298,8 +1082,6 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro if _storage._defaultNestedEnum != rhs_storage._defaultNestedEnum {return false} if _storage._defaultForeignEnum != rhs_storage._defaultForeignEnum {return false} if _storage._defaultImportEnum != rhs_storage._defaultImportEnum {return false} - if _storage._defaultStringPiece != rhs_storage._defaultStringPiece {return false} - if _storage._defaultCord != rhs_storage._defaultCord {return false} if _storage._oneofField != rhs_storage._oneofField {return false} return true } @@ -1310,20 +1092,13 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro } } -extension ProtobufUnittest_TestAllRequiredTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -1: .same(proto: "NEG"), - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - 3: .same(proto: "BAZ"), - ] +extension SwiftProtoTesting_TestAllRequiredTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{2}\u{2}FOO\0\u{1}BAR\0\u{1}BAZ\0") } -extension ProtobufUnittest_TestAllRequiredTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestAllRequiredTypes.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - ] +extension SwiftProtoTesting_TestAllRequiredTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestAllRequiredTypes.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") public var isInitialized: Bool { if self._bb == nil {return false} @@ -1353,18 +1128,16 @@ extension ProtobufUnittest_TestAllRequiredTypes.NestedMessage: SwiftProtobuf.Mes try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestAllRequiredTypes.NestedMessage, rhs: ProtobufUnittest_TestAllRequiredTypes.NestedMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestAllRequiredTypes.NestedMessage, rhs: SwiftProtoTesting_TestAllRequiredTypes.NestedMessage) -> Bool { if lhs._bb != rhs._bb {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestAllRequiredTypes.RequiredGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestAllRequiredTypes.protoMessageName + ".RequiredGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 17: .same(proto: "a"), - ] +extension SwiftProtoTesting_TestAllRequiredTypes.RequiredGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestAllRequiredTypes.protoMessageName + ".RequiredGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{11}a\0") public var isInitialized: Bool { if self._a == nil {return false} @@ -1394,23 +1167,16 @@ extension ProtobufUnittest_TestAllRequiredTypes.RequiredGroup: SwiftProtobuf.Mes try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestAllRequiredTypes.RequiredGroup, rhs: ProtobufUnittest_TestAllRequiredTypes.RequiredGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestAllRequiredTypes.RequiredGroup, rhs: SwiftProtoTesting_TestAllRequiredTypes.RequiredGroup) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestSomeRequiredTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_TestSomeRequiredTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestSomeRequiredTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "required_int32"), - 2: .standard(proto: "required_float"), - 3: .standard(proto: "required_bool"), - 4: .standard(proto: "required_string"), - 5: .standard(proto: "required_bytes"), - 6: .standard(proto: "required_nested_enum"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_int32\0\u{3}required_float\0\u{3}required_bool\0\u{3}required_string\0\u{3}required_bytes\0\u{3}required_nested_enum\0") public var isInitialized: Bool { if self._requiredInt32 == nil {return false} @@ -1465,7 +1231,7 @@ extension ProtobufUnittest_TestSomeRequiredTypes: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestSomeRequiredTypes, rhs: ProtobufUnittest_TestSomeRequiredTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestSomeRequiredTypes, rhs: SwiftProtoTesting_TestSomeRequiredTypes) -> Bool { if lhs._requiredInt32 != rhs._requiredInt32 {return false} if lhs._requiredFloat != rhs._requiredFloat {return false} if lhs._requiredBool != rhs._requiredBool {return false} @@ -1477,8 +1243,6 @@ extension ProtobufUnittest_TestSomeRequiredTypes: SwiftProtobuf.Message, SwiftPr } } -extension ProtobufUnittest_TestSomeRequiredTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FOO"), - ] +extension SwiftProtoTesting_TestSomeRequiredTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FOO\0") } diff --git a/Reference/unittest_swift_cycle.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_cycle.pb.swift similarity index 76% rename from Reference/unittest_swift_cycle.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_cycle.pb.swift index 87145ef2b..b8af04e6c 100644 --- a/Reference/unittest_swift_cycle.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_cycle.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_cycle.proto @@ -36,7 +37,6 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -49,35 +49,35 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_CycleFoo { +struct SwiftProtoTesting_CycleFoo: @unchecked Sendable { // 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 aFoo: ProtobufUnittest_CycleFoo { - get {return _storage._aFoo ?? ProtobufUnittest_CycleFoo()} + var aFoo: SwiftProtoTesting_CycleFoo { + get {_storage._aFoo ?? SwiftProtoTesting_CycleFoo()} set {_uniqueStorage()._aFoo = newValue} } /// Returns true if `aFoo` has been explicitly set. - var hasAFoo: Bool {return _storage._aFoo != nil} + var hasAFoo: Bool {_storage._aFoo != nil} /// Clears the value of `aFoo`. Subsequent reads from it will return its default value. mutating func clearAFoo() {_uniqueStorage()._aFoo = nil} - var aBar: ProtobufUnittest_CycleBar { - get {return _storage._aBar ?? ProtobufUnittest_CycleBar()} + var aBar: SwiftProtoTesting_CycleBar { + get {_storage._aBar ?? SwiftProtoTesting_CycleBar()} set {_uniqueStorage()._aBar = newValue} } /// Returns true if `aBar` has been explicitly set. - var hasABar: Bool {return _storage._aBar != nil} + var hasABar: Bool {_storage._aBar != nil} /// Clears the value of `aBar`. Subsequent reads from it will return its default value. mutating func clearABar() {_uniqueStorage()._aBar = nil} - var aBaz: ProtobufUnittest_CycleBaz { - get {return _storage._aBaz ?? ProtobufUnittest_CycleBaz()} + var aBaz: SwiftProtoTesting_CycleBaz { + get {_storage._aBaz ?? SwiftProtoTesting_CycleBaz()} set {_uniqueStorage()._aBaz = newValue} } /// Returns true if `aBaz` has been explicitly set. - var hasABaz: Bool {return _storage._aBaz != nil} + var hasABaz: Bool {_storage._aBaz != nil} /// Clears the value of `aBaz`. Subsequent reads from it will return its default value. mutating func clearABaz() {_uniqueStorage()._aBaz = nil} @@ -88,35 +88,35 @@ struct ProtobufUnittest_CycleFoo { fileprivate var _storage = _StorageClass.defaultInstance } -struct ProtobufUnittest_CycleBar { +struct SwiftProtoTesting_CycleBar: @unchecked Sendable { // 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 aBar: ProtobufUnittest_CycleBar { - get {return _storage._aBar ?? ProtobufUnittest_CycleBar()} + var aBar: SwiftProtoTesting_CycleBar { + get {_storage._aBar ?? SwiftProtoTesting_CycleBar()} set {_uniqueStorage()._aBar = newValue} } /// Returns true if `aBar` has been explicitly set. - var hasABar: Bool {return _storage._aBar != nil} + var hasABar: Bool {_storage._aBar != nil} /// Clears the value of `aBar`. Subsequent reads from it will return its default value. mutating func clearABar() {_uniqueStorage()._aBar = nil} - var aBaz: ProtobufUnittest_CycleBaz { - get {return _storage._aBaz ?? ProtobufUnittest_CycleBaz()} + var aBaz: SwiftProtoTesting_CycleBaz { + get {_storage._aBaz ?? SwiftProtoTesting_CycleBaz()} set {_uniqueStorage()._aBaz = newValue} } /// Returns true if `aBaz` has been explicitly set. - var hasABaz: Bool {return _storage._aBaz != nil} + var hasABaz: Bool {_storage._aBaz != nil} /// Clears the value of `aBaz`. Subsequent reads from it will return its default value. mutating func clearABaz() {_uniqueStorage()._aBaz = nil} - var aFoo: ProtobufUnittest_CycleFoo { - get {return _storage._aFoo ?? ProtobufUnittest_CycleFoo()} + var aFoo: SwiftProtoTesting_CycleFoo { + get {_storage._aFoo ?? SwiftProtoTesting_CycleFoo()} set {_uniqueStorage()._aFoo = newValue} } /// Returns true if `aFoo` has been explicitly set. - var hasAFoo: Bool {return _storage._aFoo != nil} + var hasAFoo: Bool {_storage._aFoo != nil} /// Clears the value of `aFoo`. Subsequent reads from it will return its default value. mutating func clearAFoo() {_uniqueStorage()._aFoo = nil} @@ -127,35 +127,35 @@ struct ProtobufUnittest_CycleBar { fileprivate var _storage = _StorageClass.defaultInstance } -struct ProtobufUnittest_CycleBaz { +struct SwiftProtoTesting_CycleBaz: @unchecked Sendable { // 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 aBaz: ProtobufUnittest_CycleBaz { - get {return _storage._aBaz ?? ProtobufUnittest_CycleBaz()} + var aBaz: SwiftProtoTesting_CycleBaz { + get {_storage._aBaz ?? SwiftProtoTesting_CycleBaz()} set {_uniqueStorage()._aBaz = newValue} } /// Returns true if `aBaz` has been explicitly set. - var hasABaz: Bool {return _storage._aBaz != nil} + var hasABaz: Bool {_storage._aBaz != nil} /// Clears the value of `aBaz`. Subsequent reads from it will return its default value. mutating func clearABaz() {_uniqueStorage()._aBaz = nil} - var aFoo: ProtobufUnittest_CycleFoo { - get {return _storage._aFoo ?? ProtobufUnittest_CycleFoo()} + var aFoo: SwiftProtoTesting_CycleFoo { + get {_storage._aFoo ?? SwiftProtoTesting_CycleFoo()} set {_uniqueStorage()._aFoo = newValue} } /// Returns true if `aFoo` has been explicitly set. - var hasAFoo: Bool {return _storage._aFoo != nil} + var hasAFoo: Bool {_storage._aFoo != nil} /// Clears the value of `aFoo`. Subsequent reads from it will return its default value. mutating func clearAFoo() {_uniqueStorage()._aFoo = nil} - var aBar: ProtobufUnittest_CycleBar { - get {return _storage._aBar ?? ProtobufUnittest_CycleBar()} + var aBar: SwiftProtoTesting_CycleBar { + get {_storage._aBar ?? SwiftProtoTesting_CycleBar()} set {_uniqueStorage()._aBar = newValue} } /// Returns true if `aBar` has been explicitly set. - var hasABar: Bool {return _storage._aBar != nil} + var hasABar: Bool {_storage._aBar != nil} /// Clears the value of `aBar`. Subsequent reads from it will return its default value. mutating func clearABar() {_uniqueStorage()._aBar = nil} @@ -166,30 +166,24 @@ struct ProtobufUnittest_CycleBaz { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_CycleFoo: @unchecked Sendable {} -extension ProtobufUnittest_CycleBar: @unchecked Sendable {} -extension ProtobufUnittest_CycleBaz: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_CycleFoo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_CycleFoo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".CycleFoo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "a_foo"), - 2: .standard(proto: "a_bar"), - 3: .standard(proto: "a_baz"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}a_foo\0\u{3}a_bar\0\u{3}a_baz\0") fileprivate class _StorageClass { - var _aFoo: ProtobufUnittest_CycleFoo? = nil - var _aBar: ProtobufUnittest_CycleBar? = nil - var _aBaz: ProtobufUnittest_CycleBaz? = nil + var _aFoo: SwiftProtoTesting_CycleFoo? = nil + var _aBar: SwiftProtoTesting_CycleBar? = nil + var _aBaz: SwiftProtoTesting_CycleBaz? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -243,7 +237,7 @@ extension ProtobufUnittest_CycleFoo: SwiftProtobuf.Message, SwiftProtobuf._Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_CycleFoo, rhs: ProtobufUnittest_CycleFoo) -> Bool { + static func ==(lhs: SwiftProtoTesting_CycleFoo, rhs: SwiftProtoTesting_CycleFoo) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -260,20 +254,20 @@ extension ProtobufUnittest_CycleFoo: SwiftProtobuf.Message, SwiftProtobuf._Messa } } -extension ProtobufUnittest_CycleBar: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_CycleBar: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".CycleBar" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "a_bar"), - 2: .standard(proto: "a_baz"), - 3: .standard(proto: "a_foo"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}a_bar\0\u{3}a_baz\0\u{3}a_foo\0") fileprivate class _StorageClass { - var _aBar: ProtobufUnittest_CycleBar? = nil - var _aBaz: ProtobufUnittest_CycleBaz? = nil - var _aFoo: ProtobufUnittest_CycleFoo? = nil + var _aBar: SwiftProtoTesting_CycleBar? = nil + var _aBaz: SwiftProtoTesting_CycleBaz? = nil + var _aFoo: SwiftProtoTesting_CycleFoo? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -327,7 +321,7 @@ extension ProtobufUnittest_CycleBar: SwiftProtobuf.Message, SwiftProtobuf._Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_CycleBar, rhs: ProtobufUnittest_CycleBar) -> Bool { + static func ==(lhs: SwiftProtoTesting_CycleBar, rhs: SwiftProtoTesting_CycleBar) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -344,20 +338,20 @@ extension ProtobufUnittest_CycleBar: SwiftProtobuf.Message, SwiftProtobuf._Messa } } -extension ProtobufUnittest_CycleBaz: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_CycleBaz: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".CycleBaz" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "a_baz"), - 2: .standard(proto: "a_foo"), - 3: .standard(proto: "a_bar"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}a_baz\0\u{3}a_foo\0\u{3}a_bar\0") fileprivate class _StorageClass { - var _aBaz: ProtobufUnittest_CycleBaz? = nil - var _aFoo: ProtobufUnittest_CycleFoo? = nil - var _aBar: ProtobufUnittest_CycleBar? = nil + var _aBaz: SwiftProtoTesting_CycleBaz? = nil + var _aFoo: SwiftProtoTesting_CycleFoo? = nil + var _aBar: SwiftProtoTesting_CycleBar? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -411,7 +405,7 @@ extension ProtobufUnittest_CycleBaz: SwiftProtobuf.Message, SwiftProtobuf._Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_CycleBaz, rhs: ProtobufUnittest_CycleBaz) -> Bool { + static func ==(lhs: SwiftProtoTesting_CycleBaz, rhs: SwiftProtoTesting_CycleBaz) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 diff --git a/Reference/Tests/SwiftProtobufTests/unittest_swift_deprecated.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_deprecated.pb.swift new file mode 100644 index 000000000..d9ddca6e6 --- /dev/null +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_deprecated.pb.swift @@ -0,0 +1,615 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: unittest_swift_deprecated.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protos/unittest_swift_deprecated.proto - test proto +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2023 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 generation support of deprecated attributes. +/// +// ----------------------------------------------------------------------------- + +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 +} + +/// An enum value marked as deprecated. +enum SwiftProtoTesting_Deprecated_MyEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case one = 1 + + /// Enum comment + /// + /// NOTE: This enum value was marked as deprecated in the .proto file + case two = 2 + + /// NOTE: This enum value was marked as deprecated in the .proto file + case three = 3 + + init() { + self = .one + } + +} + +/// Whole enum marked as deprecated. +/// +/// NOTE: This enum was marked as deprecated in the .proto file. +enum SwiftProtoTesting_Deprecated_MyEnum2: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case one = 1 + case two = 2 + case three = 3 + + init() { + self = .one + } + +} + +/// Marking fields as deprecated. +struct SwiftProtoTesting_Deprecated_MyMsg: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Field comment + /// + /// NOTE: This field was marked as deprecated in the .proto file. + var stringField: String { + get {_storage._stringField ?? String()} + set {_uniqueStorage()._stringField = newValue} + } + /// Returns true if `stringField` has been explicitly set. + var hasStringField: Bool {_storage._stringField != nil} + /// Clears the value of `stringField`. Subsequent reads from it will return its default value. + mutating func clearStringField() {_uniqueStorage()._stringField = nil} + + /// NOTE: This field was marked as deprecated in the .proto file. + var intField: Int32 { + get {_storage._intField ?? 0} + set {_uniqueStorage()._intField = newValue} + } + /// Returns true if `intField` has been explicitly set. + var hasIntField: Bool {_storage._intField != nil} + /// Clears the value of `intField`. Subsequent reads from it will return its default value. + mutating func clearIntField() {_uniqueStorage()._intField = nil} + + /// NOTE: This field was marked as deprecated in the .proto file. + var fixedField: [UInt32] { + get {_storage._fixedField} + set {_uniqueStorage()._fixedField = newValue} + } + + /// NOTE: This field was marked as deprecated in the .proto file. + var msgField: SwiftProtoTesting_Deprecated_MyMsg { + get {_storage._msgField ?? SwiftProtoTesting_Deprecated_MyMsg()} + set {_uniqueStorage()._msgField = newValue} + } + /// Returns true if `msgField` has been explicitly set. + var hasMsgField: Bool {_storage._msgField != nil} + /// Clears the value of `msgField`. Subsequent reads from it will return its default value. + mutating func clearMsgField() {_uniqueStorage()._msgField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// Marking extension fields (scoped to a message) as deprecated. +struct SwiftProtoTesting_Deprecated_MsgScope: Sendable { + // 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() {} +} + +/// Whole message marked as deprecated. +/// +/// NOTE: This message was marked as deprecated in the .proto file. +struct SwiftProtoTesting_Deprecated_MyMsg2: @unchecked Sendable { + // 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 stringField: String { + get {_storage._stringField ?? String()} + set {_uniqueStorage()._stringField = newValue} + } + /// Returns true if `stringField` has been explicitly set. + var hasStringField: Bool {_storage._stringField != nil} + /// Clears the value of `stringField`. Subsequent reads from it will return its default value. + mutating func clearStringField() {_uniqueStorage()._stringField = nil} + + var intField: Int32 { + get {_storage._intField ?? 0} + set {_uniqueStorage()._intField = newValue} + } + /// Returns true if `intField` has been explicitly set. + var hasIntField: Bool {_storage._intField != nil} + /// Clears the value of `intField`. Subsequent reads from it will return its default value. + mutating func clearIntField() {_uniqueStorage()._intField = nil} + + var fixedField: [UInt32] { + get {_storage._fixedField} + set {_uniqueStorage()._fixedField = newValue} + } + + var msgField: SwiftProtoTesting_Deprecated_MyMsg2 { + get {_storage._msgField ?? SwiftProtoTesting_Deprecated_MyMsg2()} + set {_uniqueStorage()._msgField = newValue} + } + /// Returns true if `msgField` has been explicitly set. + var hasMsgField: Bool {_storage._msgField != nil} + /// Clears the value of `msgField`. Subsequent reads from it will return its default value. + mutating func clearMsgField() {_uniqueStorage()._msgField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Extension support defined in unittest_swift_deprecated.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 SwiftProtoTesting_Deprecated_MyMsg { + + /// Extension field comment + /// + /// NOTE: This extension field was marked as deprecated in the .proto file. + var SwiftProtoTesting_Deprecated_stringExtField: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_string_ext_field) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_string_ext_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Deprecated_Extensions_string_ext_field` + /// has been explicitly set. + var hasSwiftProtoTesting_Deprecated_stringExtField: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_string_ext_field) + } + /// Clears the value of extension `SwiftProtoTesting_Deprecated_Extensions_string_ext_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_Deprecated_stringExtField() { + clearExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_string_ext_field) + } + + /// NOTE: This extension field was marked as deprecated in the .proto file. + var SwiftProtoTesting_Deprecated_intExtField: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_int_ext_field) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_int_ext_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Deprecated_Extensions_int_ext_field` + /// has been explicitly set. + var hasSwiftProtoTesting_Deprecated_intExtField: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_int_ext_field) + } + /// Clears the value of extension `SwiftProtoTesting_Deprecated_Extensions_int_ext_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_Deprecated_intExtField() { + clearExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_int_ext_field) + } + + /// NOTE: This extension field was marked as deprecated in the .proto file. + var SwiftProtoTesting_Deprecated_fixedExtField: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_fixed_ext_field) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_fixed_ext_field, value: newValue)} + } + + /// NOTE: This extension field was marked as deprecated in the .proto file. + var SwiftProtoTesting_Deprecated_msgExtField: SwiftProtoTesting_Deprecated_MyMsg { + get {return getExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_msg_ext_field) ?? SwiftProtoTesting_Deprecated_MyMsg()} + set {setExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_msg_ext_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Deprecated_Extensions_msg_ext_field` + /// has been explicitly set. + var hasSwiftProtoTesting_Deprecated_msgExtField: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_msg_ext_field) + } + /// Clears the value of extension `SwiftProtoTesting_Deprecated_Extensions_msg_ext_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_Deprecated_msgExtField() { + clearExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_msg_ext_field) + } + + /// Another extension field comment + /// + /// NOTE: This extension field was marked as deprecated in the .proto file. + var SwiftProtoTesting_Deprecated_MsgScope_stringExt2Field: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.string_ext2_field) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.string_ext2_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Deprecated_MsgScope.Extensions.string_ext2_field` + /// has been explicitly set. + var hasSwiftProtoTesting_Deprecated_MsgScope_stringExt2Field: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.string_ext2_field) + } + /// Clears the value of extension `SwiftProtoTesting_Deprecated_MsgScope.Extensions.string_ext2_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_Deprecated_MsgScope_stringExt2Field() { + clearExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.string_ext2_field) + } + + /// NOTE: This extension field was marked as deprecated in the .proto file. + var SwiftProtoTesting_Deprecated_MsgScope_intExt2Field: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.int_ext2_field) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.int_ext2_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Deprecated_MsgScope.Extensions.int_ext2_field` + /// has been explicitly set. + var hasSwiftProtoTesting_Deprecated_MsgScope_intExt2Field: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.int_ext2_field) + } + /// Clears the value of extension `SwiftProtoTesting_Deprecated_MsgScope.Extensions.int_ext2_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_Deprecated_MsgScope_intExt2Field() { + clearExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.int_ext2_field) + } + + /// NOTE: This extension field was marked as deprecated in the .proto file. + var SwiftProtoTesting_Deprecated_MsgScope_fixedExt2Field: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.fixed_ext2_field) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.fixed_ext2_field, value: newValue)} + } + + /// NOTE: This extension field was marked as deprecated in the .proto file. + var SwiftProtoTesting_Deprecated_MsgScope_msgExt2Field: SwiftProtoTesting_Deprecated_MyMsg { + get {return getExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.msg_ext2_field) ?? SwiftProtoTesting_Deprecated_MyMsg()} + set {setExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.msg_ext2_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Deprecated_MsgScope.Extensions.msg_ext2_field` + /// has been explicitly set. + var hasSwiftProtoTesting_Deprecated_MsgScope_msgExt2Field: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.msg_ext2_field) + } + /// Clears the value of extension `SwiftProtoTesting_Deprecated_MsgScope.Extensions.msg_ext2_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_Deprecated_MsgScope_msgExt2Field() { + clearExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.msg_ext2_field) + } + +} + +// MARK: - File's ExtensionMap: SwiftProtoTesting_Deprecated_UnittestSwiftDeprecated_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 SwiftProtoTesting_Deprecated_UnittestSwiftDeprecated_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Deprecated_Extensions_string_ext_field, + SwiftProtoTesting_Deprecated_Extensions_int_ext_field, + SwiftProtoTesting_Deprecated_Extensions_fixed_ext_field, + SwiftProtoTesting_Deprecated_Extensions_msg_ext_field, + SwiftProtoTesting_Deprecated_MsgScope.Extensions.string_ext2_field, + SwiftProtoTesting_Deprecated_MsgScope.Extensions.int_ext2_field, + SwiftProtoTesting_Deprecated_MsgScope.Extensions.fixed_ext2_field, + SwiftProtoTesting_Deprecated_MsgScope.Extensions.msg_ext2_field +] + +// 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. + +/// Extension field comment +/// +/// NOTE: This extension field was marked as deprecated in the .proto file. +let SwiftProtoTesting_Deprecated_Extensions_string_ext_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Deprecated_MyMsg>( + _protobuf_fieldNumber: 101, + fieldName: "swift_proto_testing.deprecated.string_ext_field" +) + +/// NOTE: This extension field was marked as deprecated in the .proto file. +let SwiftProtoTesting_Deprecated_Extensions_int_ext_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Deprecated_MyMsg>( + _protobuf_fieldNumber: 102, + fieldName: "swift_proto_testing.deprecated.int_ext_field" +) + +/// NOTE: This extension field was marked as deprecated in the .proto file. +let SwiftProtoTesting_Deprecated_Extensions_fixed_ext_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Deprecated_MyMsg>( + _protobuf_fieldNumber: 103, + fieldName: "swift_proto_testing.deprecated.fixed_ext_field" +) + +/// NOTE: This extension field was marked as deprecated in the .proto file. +let SwiftProtoTesting_Deprecated_Extensions_msg_ext_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Deprecated_MyMsg>( + _protobuf_fieldNumber: 104, + fieldName: "swift_proto_testing.deprecated.msg_ext_field" +) + +extension SwiftProtoTesting_Deprecated_MsgScope { + enum Extensions { + /// Another extension field comment + /// + /// NOTE: This extension field was marked as deprecated in the .proto file. + static let string_ext2_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Deprecated_MyMsg>( + _protobuf_fieldNumber: 201, + fieldName: "swift_proto_testing.deprecated.MsgScope.string_ext2_field" + ) + + /// NOTE: This extension field was marked as deprecated in the .proto file. + static let int_ext2_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Deprecated_MyMsg>( + _protobuf_fieldNumber: 202, + fieldName: "swift_proto_testing.deprecated.MsgScope.int_ext2_field" + ) + + /// NOTE: This extension field was marked as deprecated in the .proto file. + static let fixed_ext2_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Deprecated_MyMsg>( + _protobuf_fieldNumber: 203, + fieldName: "swift_proto_testing.deprecated.MsgScope.fixed_ext2_field" + ) + + /// NOTE: This extension field was marked as deprecated in the .proto file. + static let msg_ext2_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Deprecated_MyMsg>( + _protobuf_fieldNumber: 204, + fieldName: "swift_proto_testing.deprecated.MsgScope.msg_ext2_field" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_proto_testing.deprecated" + +extension SwiftProtoTesting_Deprecated_MyEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}MYENUM_ONE\0\u{1}MYENUM_TWO\0\u{1}MYENUM_THREE\0") +} + +extension SwiftProtoTesting_Deprecated_MyEnum2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}MYENUM2_ONE\0\u{1}MYENUM2_TWO\0\u{1}MYENUM2_THREE\0") +} + +extension SwiftProtoTesting_Deprecated_MyMsg: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MyMsg" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}string_field\0\u{3}int_field\0\u{3}fixed_field\0\u{3}msg_field\0") + + fileprivate class _StorageClass { + var _stringField: String? = nil + var _intField: Int32? = nil + var _fixedField: [UInt32] = [] + var _msgField: SwiftProtoTesting_Deprecated_MyMsg? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _stringField = source._stringField + _intField = source._intField + _fixedField = source._fixedField + _msgField = source._msgField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._intField == nil {return false} + if let v = _storage._msgField, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._stringField) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._intField) }() + case 3: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._fixedField) }() + case 4: try { try decoder.decodeSingularMessageField(value: &_storage._msgField) }() + case 100..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Deprecated_MyMsg.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._stringField { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._intField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + if !_storage._fixedField.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._fixedField, fieldNumber: 3) + } + try { if let v = _storage._msgField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 100, end: 536870912) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Deprecated_MyMsg, rhs: SwiftProtoTesting_Deprecated_MyMsg) -> 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._stringField != rhs_storage._stringField {return false} + if _storage._intField != rhs_storage._intField {return false} + if _storage._fixedField != rhs_storage._fixedField {return false} + if _storage._msgField != rhs_storage._msgField {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension SwiftProtoTesting_Deprecated_MsgScope: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MsgScope" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Deprecated_MsgScope, rhs: SwiftProtoTesting_Deprecated_MsgScope) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Deprecated_MyMsg2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MyMsg2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}string_field\0\u{3}int_field\0\u{3}fixed_field\0\u{3}msg_field\0") + + fileprivate class _StorageClass { + var _stringField: String? = nil + var _intField: Int32? = nil + var _fixedField: [UInt32] = [] + var _msgField: SwiftProtoTesting_Deprecated_MyMsg2? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _stringField = source._stringField + _intField = source._intField + _fixedField = source._fixedField + _msgField = source._msgField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._intField == nil {return false} + if let v = _storage._msgField, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._stringField) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._intField) }() + case 3: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._fixedField) }() + case 4: try { try decoder.decodeSingularMessageField(value: &_storage._msgField) }() + default: break + } + } + } + } + + func traverse(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._stringField { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._intField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + if !_storage._fixedField.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._fixedField, fieldNumber: 3) + } + try { if let v = _storage._msgField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Deprecated_MyMsg2, rhs: SwiftProtoTesting_Deprecated_MyMsg2) -> 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._stringField != rhs_storage._stringField {return false} + if _storage._intField != rhs_storage._intField {return false} + if _storage._fixedField != rhs_storage._fixedField {return false} + if _storage._msgField != rhs_storage._msgField {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/Tests/SwiftProtobufTests/unittest_swift_deprecated_file.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_deprecated_file.pb.swift new file mode 100644 index 000000000..ced4ce578 --- /dev/null +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_deprecated_file.pb.swift @@ -0,0 +1,357 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: unittest_swift_deprecated_file.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protos/unittest_swift_deprecated_file.proto - test proto +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2023 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 generation support of deprecated attributes. +/// +// ----------------------------------------------------------------------------- + +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 +} + +/// NOTE: The whole .proto file that defined this enum was marked as deprecated. +enum SwiftProtoTesting_DeprecatedFile_MyEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case one = 1 + case two = 2 + case three = 3 + + init() { + self = .one + } + +} + +/// Message comment +/// +/// NOTE: The whole .proto file that defined this message was marked as deprecated. +struct SwiftProtoTesting_DeprecatedFile_MyMsg: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 stringField: String { + get {_stringField ?? String()} + set {_stringField = newValue} + } + /// Returns true if `stringField` has been explicitly set. + var hasStringField: Bool {self._stringField != nil} + /// Clears the value of `stringField`. Subsequent reads from it will return its default value. + mutating func clearStringField() {self._stringField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _stringField: String? = nil +} + +/// NOTE: The whole .proto file that defined this message was marked as deprecated. +struct SwiftProtoTesting_DeprecatedFile_MsgScope: Sendable { + // 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() {} +} + +// MARK: - Extension support defined in unittest_swift_deprecated_file.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 SwiftProtoTesting_DeprecatedFile_MyMsg { + + /// Extension field comment + /// + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + var SwiftProtoTesting_DeprecatedFile_stringExtField: String { + get {return getExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_string_ext_field) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_string_ext_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_DeprecatedFile_Extensions_string_ext_field` + /// has been explicitly set. + var hasSwiftProtoTesting_DeprecatedFile_stringExtField: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_string_ext_field) + } + /// Clears the value of extension `SwiftProtoTesting_DeprecatedFile_Extensions_string_ext_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_DeprecatedFile_stringExtField() { + clearExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_string_ext_field) + } + + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + var SwiftProtoTesting_DeprecatedFile_intExtField: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_int_ext_field) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_int_ext_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_DeprecatedFile_Extensions_int_ext_field` + /// has been explicitly set. + var hasSwiftProtoTesting_DeprecatedFile_intExtField: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_int_ext_field) + } + /// Clears the value of extension `SwiftProtoTesting_DeprecatedFile_Extensions_int_ext_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_DeprecatedFile_intExtField() { + clearExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_int_ext_field) + } + + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + var SwiftProtoTesting_DeprecatedFile_fixedExtField: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_fixed_ext_field) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_fixed_ext_field, value: newValue)} + } + + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + var SwiftProtoTesting_DeprecatedFile_msgExtField: SwiftProtoTesting_DeprecatedFile_MyMsg { + get {return getExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_msg_ext_field) ?? SwiftProtoTesting_DeprecatedFile_MyMsg()} + set {setExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_msg_ext_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_DeprecatedFile_Extensions_msg_ext_field` + /// has been explicitly set. + var hasSwiftProtoTesting_DeprecatedFile_msgExtField: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_msg_ext_field) + } + /// Clears the value of extension `SwiftProtoTesting_DeprecatedFile_Extensions_msg_ext_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_DeprecatedFile_msgExtField() { + clearExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_msg_ext_field) + } + + /// Another extension field comment + /// + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + var SwiftProtoTesting_DeprecatedFile_MsgScope_stringExt2Field: String { + get {return getExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.string_ext2_field) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.string_ext2_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.string_ext2_field` + /// has been explicitly set. + var hasSwiftProtoTesting_DeprecatedFile_MsgScope_stringExt2Field: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.string_ext2_field) + } + /// Clears the value of extension `SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.string_ext2_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_DeprecatedFile_MsgScope_stringExt2Field() { + clearExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.string_ext2_field) + } + + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + var SwiftProtoTesting_DeprecatedFile_MsgScope_intExt2Field: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.int_ext2_field) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.int_ext2_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.int_ext2_field` + /// has been explicitly set. + var hasSwiftProtoTesting_DeprecatedFile_MsgScope_intExt2Field: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.int_ext2_field) + } + /// Clears the value of extension `SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.int_ext2_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_DeprecatedFile_MsgScope_intExt2Field() { + clearExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.int_ext2_field) + } + + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + var SwiftProtoTesting_DeprecatedFile_MsgScope_fixedExt2Field: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.fixed_ext2_field) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.fixed_ext2_field, value: newValue)} + } + + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + var SwiftProtoTesting_DeprecatedFile_MsgScope_msgExt2Field: SwiftProtoTesting_DeprecatedFile_MyMsg { + get {return getExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.msg_ext2_field) ?? SwiftProtoTesting_DeprecatedFile_MyMsg()} + set {setExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.msg_ext2_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.msg_ext2_field` + /// has been explicitly set. + var hasSwiftProtoTesting_DeprecatedFile_MsgScope_msgExt2Field: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.msg_ext2_field) + } + /// Clears the value of extension `SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.msg_ext2_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_DeprecatedFile_MsgScope_msgExt2Field() { + clearExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.msg_ext2_field) + } + +} + +// MARK: - File's ExtensionMap: SwiftProtoTesting_DeprecatedFile_UnittestSwiftDeprecatedFile_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 SwiftProtoTesting_DeprecatedFile_UnittestSwiftDeprecatedFile_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_DeprecatedFile_Extensions_string_ext_field, + SwiftProtoTesting_DeprecatedFile_Extensions_int_ext_field, + SwiftProtoTesting_DeprecatedFile_Extensions_fixed_ext_field, + SwiftProtoTesting_DeprecatedFile_Extensions_msg_ext_field, + SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.string_ext2_field, + SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.int_ext2_field, + SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.fixed_ext2_field, + SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.msg_ext2_field +] + +// 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. + +/// Extension field comment +/// +/// NOTE: The whole .proto file that defined this extension field was marked as deprecated. +let SwiftProtoTesting_DeprecatedFile_Extensions_string_ext_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_DeprecatedFile_MyMsg>( + _protobuf_fieldNumber: 101, + fieldName: "swift_proto_testing.deprecated_file.string_ext_field" +) + +/// NOTE: The whole .proto file that defined this extension field was marked as deprecated. +let SwiftProtoTesting_DeprecatedFile_Extensions_int_ext_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_DeprecatedFile_MyMsg>( + _protobuf_fieldNumber: 102, + fieldName: "swift_proto_testing.deprecated_file.int_ext_field" +) + +/// NOTE: The whole .proto file that defined this extension field was marked as deprecated. +let SwiftProtoTesting_DeprecatedFile_Extensions_fixed_ext_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_DeprecatedFile_MyMsg>( + _protobuf_fieldNumber: 103, + fieldName: "swift_proto_testing.deprecated_file.fixed_ext_field" +) + +/// NOTE: The whole .proto file that defined this extension field was marked as deprecated. +let SwiftProtoTesting_DeprecatedFile_Extensions_msg_ext_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_DeprecatedFile_MyMsg>( + _protobuf_fieldNumber: 104, + fieldName: "swift_proto_testing.deprecated_file.msg_ext_field" +) + +extension SwiftProtoTesting_DeprecatedFile_MsgScope { + enum Extensions { + /// Another extension field comment + /// + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + static let string_ext2_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_DeprecatedFile_MyMsg>( + _protobuf_fieldNumber: 201, + fieldName: "swift_proto_testing.deprecated_file.MsgScope.string_ext2_field" + ) + + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + static let int_ext2_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_DeprecatedFile_MyMsg>( + _protobuf_fieldNumber: 202, + fieldName: "swift_proto_testing.deprecated_file.MsgScope.int_ext2_field" + ) + + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + static let fixed_ext2_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_DeprecatedFile_MyMsg>( + _protobuf_fieldNumber: 203, + fieldName: "swift_proto_testing.deprecated_file.MsgScope.fixed_ext2_field" + ) + + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + static let msg_ext2_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_DeprecatedFile_MyMsg>( + _protobuf_fieldNumber: 204, + fieldName: "swift_proto_testing.deprecated_file.MsgScope.msg_ext2_field" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_proto_testing.deprecated_file" + +extension SwiftProtoTesting_DeprecatedFile_MyEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}MYENUM_ONE\0\u{1}MYENUM_TWO\0\u{1}MYENUM_THREE\0") +} + +extension SwiftProtoTesting_DeprecatedFile_MyMsg: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MyMsg" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}string_field\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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._stringField) }() + case 100..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_DeprecatedFile_MyMsg.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._stringField { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 100, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_DeprecatedFile_MyMsg, rhs: SwiftProtoTesting_DeprecatedFile_MyMsg) -> Bool { + if lhs._stringField != rhs._stringField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension SwiftProtoTesting_DeprecatedFile_MsgScope: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MsgScope" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_DeprecatedFile_MsgScope, rhs: SwiftProtoTesting_DeprecatedFile_MsgScope) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/unittest_swift_enum_optional_default.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_enum_optional_default.pb.swift similarity index 63% rename from Reference/unittest_swift_enum_optional_default.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_enum_optional_default.pb.swift index b731aa90c..14acd40f2 100644 --- a/Reference/unittest_swift_enum_optional_default.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_enum_optional_default.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_enum_optional_default.proto @@ -23,7 +24,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -36,61 +36,47 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_Extend_EnumOptionalDefault { +struct SwiftProtoTesting_Extend_EnumOptionalDefault: Sendable { // 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() - struct NestedMessage { + struct NestedMessage: @unchecked Sendable { // 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. /// The circular reference here forces the generator to /// implement heap-backed storage. - var message: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage { - get {return _storage._message ?? ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage()} + var message: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage { + get {_storage._message ?? SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage()} set {_uniqueStorage()._message = newValue} } /// Returns true if `message` has been explicitly set. - var hasMessage: Bool {return _storage._message != nil} + var hasMessage: Bool {_storage._message != nil} /// Clears the value of `message`. Subsequent reads from it will return its default value. mutating func clearMessage() {_uniqueStorage()._message = nil} - var optionalEnum: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage.Enum { - get {return _storage._optionalEnum ?? .foo} + var optionalEnum: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage.Enum { + get {_storage._optionalEnum ?? .foo} set {_uniqueStorage()._optionalEnum = newValue} } /// Returns true if `optionalEnum` has been explicitly set. - var hasOptionalEnum: Bool {return _storage._optionalEnum != nil} + var hasOptionalEnum: Bool {_storage._optionalEnum != nil} /// Clears the value of `optionalEnum`. Subsequent reads from it will return its default value. mutating func clearOptionalEnum() {_uniqueStorage()._optionalEnum = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - enum Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 0 + enum Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 init() { self = .foo } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .foo - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo: return 0 - } - } - } init() {} @@ -98,108 +84,75 @@ struct ProtobufUnittest_Extend_EnumOptionalDefault { fileprivate var _storage = _StorageClass.defaultInstance } - struct NestedMessage2 { + struct NestedMessage2: Sendable { // 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 optionalEnum: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2.Enum { - get {return _optionalEnum ?? .foo} + var optionalEnum: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage2.Enum { + get {_optionalEnum ?? .foo} set {_optionalEnum = newValue} } /// Returns true if `optionalEnum` has been explicitly set. - var hasOptionalEnum: Bool {return self._optionalEnum != nil} + var hasOptionalEnum: Bool {self._optionalEnum != nil} /// Clears the value of `optionalEnum`. Subsequent reads from it will return its default value. mutating func clearOptionalEnum() {self._optionalEnum = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - enum Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 0 + enum Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 init() { self = .foo } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .foo - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo: return 0 - } - } - } init() {} - fileprivate var _optionalEnum: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2.Enum? = nil + fileprivate var _optionalEnum: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage2.Enum? = nil } init() {} } -#if swift(>=4.2) - -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage.Enum: CaseIterable { - // Support synthesized by the compiler. -} - -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2.Enum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_Extend_EnumOptionalDefault: @unchecked Sendable {} -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage.Enum: @unchecked Sendable {} -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2: @unchecked Sendable {} -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2.Enum: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest.extend" +fileprivate let _protobuf_package = "swift_proto_testing.extend" -extension ProtobufUnittest_Extend_EnumOptionalDefault: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend_EnumOptionalDefault: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".EnumOptionalDefault" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_EnumOptionalDefault, rhs: ProtobufUnittest_Extend_EnumOptionalDefault) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_EnumOptionalDefault, rhs: SwiftProtoTesting_Extend_EnumOptionalDefault) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_Extend_EnumOptionalDefault.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "message"), - 17: .standard(proto: "optional_enum"), - ] +extension SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Extend_EnumOptionalDefault.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}message\0\u{4}\u{10}optional_enum\0") fileprivate class _StorageClass { - var _message: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage? = nil - var _optionalEnum: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage.Enum? = nil + var _message: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage? = nil + var _optionalEnum: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage.Enum? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -248,7 +201,7 @@ extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage: SwiftProtob try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage, rhs: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage, rhs: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -264,17 +217,13 @@ extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage: SwiftProtob } } -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage.Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOO"), - ] +extension SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage.Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOO\0") } -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_Extend_EnumOptionalDefault.protoMessageName + ".NestedMessage2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 17: .standard(proto: "optional_enum"), - ] +extension SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Extend_EnumOptionalDefault.protoMessageName + ".NestedMessage2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{11}optional_enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -299,15 +248,13 @@ extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2: SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2, rhs: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage2, rhs: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage2) -> Bool { if lhs._optionalEnum != rhs._optionalEnum {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2.Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOO"), - ] +extension SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage2.Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOO\0") } diff --git a/Tests/SwiftProtobufTests/unittest_swift_enum.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_enum_proto2.pb.swift similarity index 50% rename from Tests/SwiftProtobufTests/unittest_swift_enum.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_enum_proto2.pb.swift index 638298ced..f31aa1d97 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_enum.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_enum_proto2.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: unittest_swift_enum.proto +// Source: unittest_swift_enum_proto2.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -37,7 +38,6 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -50,223 +50,98 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_SwiftEnumTest { +struct SwiftProtoTesting_Enum2_SwiftEnumTest: Sendable { // 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 values1: [ProtobufUnittest_SwiftEnumTest.EnumTest1] = [] + var values1: [SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTest1] = [] - var values2: [ProtobufUnittest_SwiftEnumTest.EnumTest2] = [] + var values2: [SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTest2] = [] - var values3: [ProtobufUnittest_SwiftEnumTest.EnumTestNoStem] = [] + var values3: [SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTestNoStem] = [] - var values4: [ProtobufUnittest_SwiftEnumTest.EnumTestReservedWord] = [] + var values4: [SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTestReservedWord] = [] var unknownFields = SwiftProtobuf.UnknownStorage() - enum EnumTest1: SwiftProtobuf.Enum { - typealias RawValue = Int - case firstValue // = 1 - case secondValue // = 2 + enum EnumTest1: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case firstValue = 1 + case secondValue = 2 init() { self = .firstValue } - init?(rawValue: Int) { - switch rawValue { - case 1: self = .firstValue - case 2: self = .secondValue - default: return nil - } - } - - var rawValue: Int { - switch self { - case .firstValue: return 1 - case .secondValue: return 2 - } - } - } - enum EnumTest2: SwiftProtobuf.Enum { - typealias RawValue = Int - case firstValue // = 1 - case secondValue // = 2 + enum EnumTest2: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case firstValue = 1 + case secondValue = 2 init() { self = .firstValue } - init?(rawValue: Int) { - switch rawValue { - case 1: self = .firstValue - case 2: self = .secondValue - default: return nil - } - } - - var rawValue: Int { - switch self { - case .firstValue: return 1 - case .secondValue: return 2 - } - } - } - enum EnumTestNoStem: SwiftProtobuf.Enum { - typealias RawValue = Int - case enumTestNoStem1 // = 1 - case enumTestNoStem2 // = 2 + enum EnumTestNoStem: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case enumTestNoStem1 = 1 + case enumTestNoStem2 = 2 init() { self = .enumTestNoStem1 } - init?(rawValue: Int) { - switch rawValue { - case 1: self = .enumTestNoStem1 - case 2: self = .enumTestNoStem2 - default: return nil - } - } - - var rawValue: Int { - switch self { - case .enumTestNoStem1: return 1 - case .enumTestNoStem2: return 2 - } - } - } - enum EnumTestReservedWord: SwiftProtobuf.Enum { - typealias RawValue = Int - case `var` // = 1 - case notReserved // = 2 + enum EnumTestReservedWord: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case `var` = 1 + case notReserved = 2 init() { self = .var } - init?(rawValue: Int) { - switch rawValue { - case 1: self = .var - case 2: self = .notReserved - default: return nil - } - } - - var rawValue: Int { - switch self { - case .var: return 1 - case .notReserved: return 2 - } - } - } init() {} } -#if swift(>=4.2) - -extension ProtobufUnittest_SwiftEnumTest.EnumTest1: CaseIterable { - // Support synthesized by the compiler. -} - -extension ProtobufUnittest_SwiftEnumTest.EnumTest2: CaseIterable { - // Support synthesized by the compiler. -} - -extension ProtobufUnittest_SwiftEnumTest.EnumTestNoStem: CaseIterable { - // Support synthesized by the compiler. -} - -extension ProtobufUnittest_SwiftEnumTest.EnumTestReservedWord: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_SwiftEnumWithAliasTest { +struct SwiftProtoTesting_Enum2_SwiftEnumWithAliasTest: Sendable { // 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 values: [ProtobufUnittest_SwiftEnumWithAliasTest.EnumWithAlias] = [] + var values: [SwiftProtoTesting_Enum2_SwiftEnumWithAliasTest.EnumWithAlias] = [] var unknownFields = SwiftProtobuf.UnknownStorage() - enum EnumWithAlias: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo1 // = 1 + enum EnumWithAlias: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo1 = 1 static let foo2 = foo1 /// out of value order to test allCases - case baz1 // = 3 - case bar1 // = 2 + case baz1 = 3 + case bar1 = 2 static let bar2 = bar1 init() { self = .foo1 } - init?(rawValue: Int) { - switch rawValue { - case 1: self = .foo1 - case 2: self = .bar1 - case 3: self = .baz1 - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo1: return 1 - case .bar1: return 2 - case .baz1: return 3 - } - } - } init() {} } -#if swift(>=4.2) - -extension ProtobufUnittest_SwiftEnumWithAliasTest.EnumWithAlias: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_SwiftEnumTest: @unchecked Sendable {} -extension ProtobufUnittest_SwiftEnumTest.EnumTest1: @unchecked Sendable {} -extension ProtobufUnittest_SwiftEnumTest.EnumTest2: @unchecked Sendable {} -extension ProtobufUnittest_SwiftEnumTest.EnumTestNoStem: @unchecked Sendable {} -extension ProtobufUnittest_SwiftEnumTest.EnumTestReservedWord: @unchecked Sendable {} -extension ProtobufUnittest_SwiftEnumWithAliasTest: @unchecked Sendable {} -extension ProtobufUnittest_SwiftEnumWithAliasTest.EnumWithAlias: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing.enum2" -extension ProtobufUnittest_SwiftEnumTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Enum2_SwiftEnumTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SwiftEnumTest" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "values1"), - 2: .same(proto: "values2"), - 3: .same(proto: "values3"), - 4: .same(proto: "values4"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}values1\0\u{1}values2\0\u{1}values3\0\u{1}values4\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -299,7 +174,7 @@ extension ProtobufUnittest_SwiftEnumTest: SwiftProtobuf.Message, SwiftProtobuf._ try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_SwiftEnumTest, rhs: ProtobufUnittest_SwiftEnumTest) -> Bool { + static func ==(lhs: SwiftProtoTesting_Enum2_SwiftEnumTest, rhs: SwiftProtoTesting_Enum2_SwiftEnumTest) -> Bool { if lhs.values1 != rhs.values1 {return false} if lhs.values2 != rhs.values2 {return false} if lhs.values3 != rhs.values3 {return false} @@ -309,39 +184,25 @@ extension ProtobufUnittest_SwiftEnumTest: SwiftProtobuf.Message, SwiftProtobuf._ } } -extension ProtobufUnittest_SwiftEnumTest.EnumTest1: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ENUM_TEST_1_FIRST_VALUE"), - 2: .same(proto: "ENUM_TEST_1_SECOND_VALUE"), - ] +extension SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTest1: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ENUM_TEST_1_FIRST_VALUE\0\u{1}ENUM_TEST_1_SECOND_VALUE\0") } -extension ProtobufUnittest_SwiftEnumTest.EnumTest2: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ENUM_TEST_2_FIRST_VALUE"), - 2: .same(proto: "SECOND_VALUE"), - ] +extension SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTest2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ENUM_TEST_2_FIRST_VALUE\0\u{1}SECOND_VALUE\0") } -extension ProtobufUnittest_SwiftEnumTest.EnumTestNoStem: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ENUM_TEST_NO_STEM_1"), - 2: .same(proto: "ENUM_TEST_NO_STEM_2"), - ] +extension SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTestNoStem: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ENUM_TEST_NO_STEM_1\0\u{1}ENUM_TEST_NO_STEM_2\0") } -extension ProtobufUnittest_SwiftEnumTest.EnumTestReservedWord: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ENUM_TEST_RESERVED_WORD_VAR"), - 2: .same(proto: "ENUM_TEST_RESERVED_WORD_NOT_RESERVED"), - ] +extension SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTestReservedWord: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ENUM_TEST_RESERVED_WORD_VAR\0\u{1}ENUM_TEST_RESERVED_WORD_NOT_RESERVED\0") } -extension ProtobufUnittest_SwiftEnumWithAliasTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Enum2_SwiftEnumWithAliasTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SwiftEnumWithAliasTest" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "values"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}values\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -362,17 +223,13 @@ extension ProtobufUnittest_SwiftEnumWithAliasTest: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_SwiftEnumWithAliasTest, rhs: ProtobufUnittest_SwiftEnumWithAliasTest) -> Bool { + static func ==(lhs: SwiftProtoTesting_Enum2_SwiftEnumWithAliasTest, rhs: SwiftProtoTesting_Enum2_SwiftEnumWithAliasTest) -> Bool { if lhs.values != rhs.values {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_SwiftEnumWithAliasTest.EnumWithAlias: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .aliased(proto: "FOO1", aliases: ["FOO2"]), - 2: .aliased(proto: "BAR1", aliases: ["BAR2"]), - 3: .same(proto: "BAZ1"), - ] +extension SwiftProtoTesting_Enum2_SwiftEnumWithAliasTest.EnumWithAlias: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{9}FOO1\0\u{1}FOO2\0\u{9}BAR1\0\u{1}BAR2\0\u{1}BAZ1\0") } diff --git a/Reference/unittest_swift_enum_proto3.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_enum_proto3.pb.swift similarity index 63% rename from Reference/unittest_swift_enum_proto3.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_enum_proto3.pb.swift index 1733eb031..cb14ffe62 100644 --- a/Reference/unittest_swift_enum_proto3.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_enum_proto3.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_enum_proto3.proto @@ -37,7 +38,6 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -50,22 +50,22 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct Protobuf3Unittest_SwiftEnumTest { +struct SwiftProtoTesting_Enum3_SwiftEnumTest: Sendable { // 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 values1: [Protobuf3Unittest_SwiftEnumTest.EnumTest1] = [] + var values1: [SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTest1] = [] - var values2: [Protobuf3Unittest_SwiftEnumTest.EnumTest2] = [] + var values2: [SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTest2] = [] - var values3: [Protobuf3Unittest_SwiftEnumTest.EnumTestNoStem] = [] + var values3: [SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTestNoStem] = [] - var values4: [Protobuf3Unittest_SwiftEnumTest.EnumTestReservedWord] = [] + var values4: [SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTestReservedWord] = [] var unknownFields = SwiftProtobuf.UnknownStorage() - enum EnumTest1: SwiftProtobuf.Enum { + enum EnumTest1: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case firstValue // = 0 case secondValue // = 2 @@ -91,9 +91,15 @@ struct Protobuf3Unittest_SwiftEnumTest { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTest1] = [ + .firstValue, + .secondValue, + ] + } - enum EnumTest2: SwiftProtobuf.Enum { + enum EnumTest2: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case firstValue // = 0 case secondValue // = 2 @@ -119,9 +125,15 @@ struct Protobuf3Unittest_SwiftEnumTest { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTest2] = [ + .firstValue, + .secondValue, + ] + } - enum EnumTestNoStem: SwiftProtobuf.Enum { + enum EnumTestNoStem: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case enumTestNoStem1 // = 0 case enumTestNoStem2 // = 2 @@ -147,9 +159,15 @@ struct Protobuf3Unittest_SwiftEnumTest { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTestNoStem] = [ + .enumTestNoStem1, + .enumTestNoStem2, + ] + } - enum EnumTestReservedWord: SwiftProtobuf.Enum { + enum EnumTestReservedWord: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case `var` // = 0 case notReserved // = 2 @@ -175,57 +193,27 @@ struct Protobuf3Unittest_SwiftEnumTest { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTestReservedWord] = [ + .var, + .notReserved, + ] + } init() {} } -#if swift(>=4.2) - -extension Protobuf3Unittest_SwiftEnumTest.EnumTest1: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Protobuf3Unittest_SwiftEnumTest.EnumTest1] = [ - .firstValue, - .secondValue, - ] -} - -extension Protobuf3Unittest_SwiftEnumTest.EnumTest2: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Protobuf3Unittest_SwiftEnumTest.EnumTest2] = [ - .firstValue, - .secondValue, - ] -} - -extension Protobuf3Unittest_SwiftEnumTest.EnumTestNoStem: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Protobuf3Unittest_SwiftEnumTest.EnumTestNoStem] = [ - .enumTestNoStem1, - .enumTestNoStem2, - ] -} - -extension Protobuf3Unittest_SwiftEnumTest.EnumTestReservedWord: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Protobuf3Unittest_SwiftEnumTest.EnumTestReservedWord] = [ - .var, - .notReserved, - ] -} - -#endif // swift(>=4.2) - -struct Protobuf3Unittest_SwiftEnumWithAliasTest { +struct SwiftProtoTesting_Enum3_SwiftEnumWithAliasTest: Sendable { // 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 values: [Protobuf3Unittest_SwiftEnumWithAliasTest.EnumWithAlias] = [] + var values: [SwiftProtoTesting_Enum3_SwiftEnumWithAliasTest.EnumWithAlias] = [] var unknownFields = SwiftProtobuf.UnknownStorage() - enum EnumWithAlias: SwiftProtobuf.Enum { + enum EnumWithAlias: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foo1 // = 0 static let foo2 = foo1 @@ -258,46 +246,25 @@ struct Protobuf3Unittest_SwiftEnumWithAliasTest { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Enum3_SwiftEnumWithAliasTest.EnumWithAlias] = [ + .foo1, + .baz1, + .bar1, + ] + } init() {} } -#if swift(>=4.2) - -extension Protobuf3Unittest_SwiftEnumWithAliasTest.EnumWithAlias: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Protobuf3Unittest_SwiftEnumWithAliasTest.EnumWithAlias] = [ - .foo1, - .baz1, - .bar1, - ] -} - -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension Protobuf3Unittest_SwiftEnumTest: @unchecked Sendable {} -extension Protobuf3Unittest_SwiftEnumTest.EnumTest1: @unchecked Sendable {} -extension Protobuf3Unittest_SwiftEnumTest.EnumTest2: @unchecked Sendable {} -extension Protobuf3Unittest_SwiftEnumTest.EnumTestNoStem: @unchecked Sendable {} -extension Protobuf3Unittest_SwiftEnumTest.EnumTestReservedWord: @unchecked Sendable {} -extension Protobuf3Unittest_SwiftEnumWithAliasTest: @unchecked Sendable {} -extension Protobuf3Unittest_SwiftEnumWithAliasTest.EnumWithAlias: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf3_unittest" +fileprivate let _protobuf_package = "swift_proto_testing.enum3" -extension Protobuf3Unittest_SwiftEnumTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Enum3_SwiftEnumTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SwiftEnumTest" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "values1"), - 2: .same(proto: "values2"), - 3: .same(proto: "values3"), - 4: .same(proto: "values4"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}values1\0\u{1}values2\0\u{1}values3\0\u{1}values4\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -330,7 +297,7 @@ extension Protobuf3Unittest_SwiftEnumTest: SwiftProtobuf.Message, SwiftProtobuf. try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Protobuf3Unittest_SwiftEnumTest, rhs: Protobuf3Unittest_SwiftEnumTest) -> Bool { + static func ==(lhs: SwiftProtoTesting_Enum3_SwiftEnumTest, rhs: SwiftProtoTesting_Enum3_SwiftEnumTest) -> Bool { if lhs.values1 != rhs.values1 {return false} if lhs.values2 != rhs.values2 {return false} if lhs.values3 != rhs.values3 {return false} @@ -340,39 +307,25 @@ extension Protobuf3Unittest_SwiftEnumTest: SwiftProtobuf.Message, SwiftProtobuf. } } -extension Protobuf3Unittest_SwiftEnumTest.EnumTest1: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ENUM_TEST_1_FIRST_VALUE"), - 2: .same(proto: "ENUM_TEST_1_SECOND_VALUE"), - ] +extension SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTest1: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ENUM_TEST_1_FIRST_VALUE\0\u{2}\u{2}ENUM_TEST_1_SECOND_VALUE\0") } -extension Protobuf3Unittest_SwiftEnumTest.EnumTest2: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ENUM_TEST_2_FIRST_VALUE"), - 2: .same(proto: "SECOND_VALUE"), - ] +extension SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTest2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ENUM_TEST_2_FIRST_VALUE\0\u{2}\u{2}SECOND_VALUE\0") } -extension Protobuf3Unittest_SwiftEnumTest.EnumTestNoStem: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ENUM_TEST_NO_STEM_1"), - 2: .same(proto: "ENUM_TEST_NO_STEM_2"), - ] +extension SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTestNoStem: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ENUM_TEST_NO_STEM_1\0\u{2}\u{2}ENUM_TEST_NO_STEM_2\0") } -extension Protobuf3Unittest_SwiftEnumTest.EnumTestReservedWord: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ENUM_TEST_RESERVED_WORD_VAR"), - 2: .same(proto: "ENUM_TEST_RESERVED_WORD_NOT_RESERVED"), - ] +extension SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTestReservedWord: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ENUM_TEST_RESERVED_WORD_VAR\0\u{2}\u{2}ENUM_TEST_RESERVED_WORD_NOT_RESERVED\0") } -extension Protobuf3Unittest_SwiftEnumWithAliasTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Enum3_SwiftEnumWithAliasTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SwiftEnumWithAliasTest" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "values"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}values\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -393,17 +346,13 @@ extension Protobuf3Unittest_SwiftEnumWithAliasTest: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Protobuf3Unittest_SwiftEnumWithAliasTest, rhs: Protobuf3Unittest_SwiftEnumWithAliasTest) -> Bool { + static func ==(lhs: SwiftProtoTesting_Enum3_SwiftEnumWithAliasTest, rhs: SwiftProtoTesting_Enum3_SwiftEnumWithAliasTest) -> Bool { if lhs.values != rhs.values {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Protobuf3Unittest_SwiftEnumWithAliasTest.EnumWithAlias: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .aliased(proto: "FOO1", aliases: ["FOO2"]), - 2: .aliased(proto: "BAR1", aliases: ["BAR2"]), - 3: .same(proto: "BAZ1"), - ] +extension SwiftProtoTesting_Enum3_SwiftEnumWithAliasTest.EnumWithAlias: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{a}\0FOO1\0\u{1}FOO2\0\u{a}\u{2}BAR1\0\u{1}BAR2\0\u{1}BAZ1\0") } diff --git a/Reference/unittest_swift_extension.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_extension.pb.swift similarity index 57% rename from Reference/unittest_swift_extension.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_extension.pb.swift index 3783af78a..0389f7b4f 100644 --- a/Reference/unittest_swift_extension.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_extension.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_extension.proto @@ -23,7 +24,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -36,31 +36,31 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_Extend_Foo { +struct SwiftProtoTesting_Extend_Foo: Sendable { // 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() - struct Bar { + struct Bar: Sendable { // 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() - struct Baz: SwiftProtobuf.ExtensibleMessage { + struct Baz: SwiftProtobuf.ExtensibleMessage, Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -78,18 +78,18 @@ struct ProtobufUnittest_Extend_Foo { init() {} } -struct ProtobufUnittest_Extend_C { +struct SwiftProtoTesting_Extend_C: Sendable { // 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. /// extensions 10 to 20; var c: Int64 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -100,7 +100,7 @@ struct ProtobufUnittest_Extend_C { fileprivate var _c: Int64? = nil } -struct ProtobufUnittest_Extend_Msg1: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Extend_Msg1: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -112,7 +112,7 @@ struct ProtobufUnittest_Extend_Msg1: SwiftProtobuf.ExtensibleMessage { var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct ProtobufUnittest_Extend_Msg2: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Extend_Msg2: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -124,17 +124,17 @@ struct ProtobufUnittest_Extend_Msg2: SwiftProtobuf.ExtensibleMessage { var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct ProtobufUnittest_Extend_MsgNoStorage: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Extend_MsgNoStorage: SwiftProtobuf.ExtensibleMessage, Sendable { // 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 x: Int32 { - get {return _x ?? 0} + get {_x ?? 0} set {_x = newValue} } /// Returns true if `x` has been explicitly set. - var hasX: Bool {return self._x != nil} + var hasX: Bool {self._x != nil} /// Clears the value of `x`. Subsequent reads from it will return its default value. mutating func clearX() {self._x = nil} @@ -146,27 +146,27 @@ struct ProtobufUnittest_Extend_MsgNoStorage: SwiftProtobuf.ExtensibleMessage { fileprivate var _x: Int32? = nil } -struct ProtobufUnittest_Extend_MsgUsesStorage: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Extend_MsgUsesStorage: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { // 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 x: Int32 { - get {return _storage._x ?? 0} + get {_storage._x ?? 0} set {_uniqueStorage()._x = newValue} } /// Returns true if `x` has been explicitly set. - var hasX: Bool {return _storage._x != nil} + var hasX: Bool {_storage._x != nil} /// Clears the value of `x`. Subsequent reads from it will return its default value. mutating func clearX() {_uniqueStorage()._x = nil} /// Recursive class (i.e. - can build a graph), forces _StorageClass. - var y: ProtobufUnittest_Extend_MsgUsesStorage { - get {return _storage._y ?? ProtobufUnittest_Extend_MsgUsesStorage()} + var y: SwiftProtoTesting_Extend_MsgUsesStorage { + get {_storage._y ?? SwiftProtoTesting_Extend_MsgUsesStorage()} set {_uniqueStorage()._y = newValue} } /// Returns true if `y` has been explicitly set. - var hasY: Bool {return _storage._y != nil} + var hasY: Bool {_storage._y != nil} /// Clears the value of `y`. Subsequent reads from it will return its default value. mutating func clearY() {_uniqueStorage()._y = nil} @@ -178,291 +178,278 @@ struct ProtobufUnittest_Extend_MsgUsesStorage: SwiftProtobuf.ExtensibleMessage { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_Extend_Foo: @unchecked Sendable {} -extension ProtobufUnittest_Extend_Foo.Bar: @unchecked Sendable {} -extension ProtobufUnittest_Extend_Foo.Bar.Baz: @unchecked Sendable {} -extension ProtobufUnittest_Extend_C: @unchecked Sendable {} -extension ProtobufUnittest_Extend_Msg1: @unchecked Sendable {} -extension ProtobufUnittest_Extend_Msg2: @unchecked Sendable {} -extension ProtobufUnittest_Extend_MsgNoStorage: @unchecked Sendable {} -extension ProtobufUnittest_Extend_MsgUsesStorage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_extension.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 ProtobufUnittest_Extend_Foo.Bar.Baz { +extension SwiftProtoTesting_Extend_Foo.Bar.Baz { - var ProtobufUnittest_Extend_b: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extend_Extensions_b) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extend_Extensions_b, value: newValue)} + var SwiftProtoTesting_Extend_b: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_b) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_b, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend_Extensions_b` + /// Returns true if extension `SwiftProtoTesting_Extend_Extensions_b` /// has been explicitly set. - var hasProtobufUnittest_Extend_b: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend_Extensions_b) + var hasSwiftProtoTesting_Extend_b: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_b) } - /// Clears the value of extension `ProtobufUnittest_Extend_Extensions_b`. + /// Clears the value of extension `SwiftProtoTesting_Extend_Extensions_b`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend_b() { - clearExtensionValue(ext: ProtobufUnittest_Extend_Extensions_b) + mutating func clearSwiftProtoTesting_Extend_b() { + clearExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_b) } - var ProtobufUnittest_Extend_c: ProtobufUnittest_Extend_C { - get {return getExtensionValue(ext: ProtobufUnittest_Extend_Extensions_C) ?? ProtobufUnittest_Extend_C()} - set {setExtensionValue(ext: ProtobufUnittest_Extend_Extensions_C, value: newValue)} + var SwiftProtoTesting_Extend_c: SwiftProtoTesting_Extend_C { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_C) ?? SwiftProtoTesting_Extend_C()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_C, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend_Extensions_C` + /// Returns true if extension `SwiftProtoTesting_Extend_Extensions_C` /// has been explicitly set. - var hasProtobufUnittest_Extend_c: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend_Extensions_C) + var hasSwiftProtoTesting_Extend_c: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_C) } - /// Clears the value of extension `ProtobufUnittest_Extend_Extensions_C`. + /// Clears the value of extension `SwiftProtoTesting_Extend_Extensions_C`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend_c() { - clearExtensionValue(ext: ProtobufUnittest_Extend_Extensions_C) + mutating func clearSwiftProtoTesting_Extend_c() { + clearExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_C) } } -extension ProtobufUnittest_Extend_Msg1 { +extension SwiftProtoTesting_Extend_Msg1 { - var ProtobufUnittest_Extend_aB: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extend_Extensions_a_b) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extend_Extensions_a_b, value: newValue)} + var SwiftProtoTesting_Extend_aB: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_a_b) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_a_b, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend_Extensions_a_b` + /// Returns true if extension `SwiftProtoTesting_Extend_Extensions_a_b` /// has been explicitly set. - var hasProtobufUnittest_Extend_aB: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend_Extensions_a_b) + var hasSwiftProtoTesting_Extend_aB: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_a_b) } - /// Clears the value of extension `ProtobufUnittest_Extend_Extensions_a_b`. + /// Clears the value of extension `SwiftProtoTesting_Extend_Extensions_a_b`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend_aB() { - clearExtensionValue(ext: ProtobufUnittest_Extend_Extensions_a_b) + mutating func clearSwiftProtoTesting_Extend_aB() { + clearExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_a_b) } - var ProtobufUnittest_Extend_m2: ProtobufUnittest_Extend_Msg2 { - get {return getExtensionValue(ext: ProtobufUnittest_Extend_Extensions_m2) ?? ProtobufUnittest_Extend_Msg2()} - set {setExtensionValue(ext: ProtobufUnittest_Extend_Extensions_m2, value: newValue)} + var SwiftProtoTesting_Extend_m2: SwiftProtoTesting_Extend_Msg2 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_m2) ?? SwiftProtoTesting_Extend_Msg2()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_m2, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend_Extensions_m2` + /// Returns true if extension `SwiftProtoTesting_Extend_Extensions_m2` /// has been explicitly set. - var hasProtobufUnittest_Extend_m2: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend_Extensions_m2) + var hasSwiftProtoTesting_Extend_m2: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_m2) } - /// Clears the value of extension `ProtobufUnittest_Extend_Extensions_m2`. + /// Clears the value of extension `SwiftProtoTesting_Extend_Extensions_m2`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend_m2() { - clearExtensionValue(ext: ProtobufUnittest_Extend_Extensions_m2) + mutating func clearSwiftProtoTesting_Extend_m2() { + clearExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_m2) } } -extension ProtobufUnittest_Extend_Msg2 { +extension SwiftProtoTesting_Extend_Msg2 { - var ProtobufUnittest_Extend_aB: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extend_Extensions_aB) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extend_Extensions_aB, value: newValue)} + var SwiftProtoTesting_Extend_aB: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_aB) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_aB, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend_Extensions_aB` + /// Returns true if extension `SwiftProtoTesting_Extend_Extensions_aB` /// has been explicitly set. - var hasProtobufUnittest_Extend_aB: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend_Extensions_aB) + var hasSwiftProtoTesting_Extend_aB: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_aB) } - /// Clears the value of extension `ProtobufUnittest_Extend_Extensions_aB`. + /// Clears the value of extension `SwiftProtoTesting_Extend_Extensions_aB`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend_aB() { - clearExtensionValue(ext: ProtobufUnittest_Extend_Extensions_aB) + mutating func clearSwiftProtoTesting_Extend_aB() { + clearExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_aB) } } -extension ProtobufUnittest_Extend_MsgNoStorage { +extension SwiftProtoTesting_Extend_MsgNoStorage { - var ProtobufUnittest_Extend_extA: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_a) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_a, value: newValue)} + var SwiftProtoTesting_Extend_extA: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_a) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_a, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend_Extensions_ext_a` + /// Returns true if extension `SwiftProtoTesting_Extend_Extensions_ext_a` /// has been explicitly set. - var hasProtobufUnittest_Extend_extA: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_a) + var hasSwiftProtoTesting_Extend_extA: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_a) } - /// Clears the value of extension `ProtobufUnittest_Extend_Extensions_ext_a`. + /// Clears the value of extension `SwiftProtoTesting_Extend_Extensions_ext_a`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend_extA() { - clearExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_a) + mutating func clearSwiftProtoTesting_Extend_extA() { + clearExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_a) } - var ProtobufUnittest_Extend_extB: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_b) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_b, value: newValue)} + var SwiftProtoTesting_Extend_extB: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_b) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_b, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend_Extensions_ext_b` + /// Returns true if extension `SwiftProtoTesting_Extend_Extensions_ext_b` /// has been explicitly set. - var hasProtobufUnittest_Extend_extB: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_b) + var hasSwiftProtoTesting_Extend_extB: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_b) } - /// Clears the value of extension `ProtobufUnittest_Extend_Extensions_ext_b`. + /// Clears the value of extension `SwiftProtoTesting_Extend_Extensions_ext_b`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend_extB() { - clearExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_b) + mutating func clearSwiftProtoTesting_Extend_extB() { + clearExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_b) } } -extension ProtobufUnittest_Extend_MsgUsesStorage { +extension SwiftProtoTesting_Extend_MsgUsesStorage { - var ProtobufUnittest_Extend_extC: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_c) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_c, value: newValue)} + var SwiftProtoTesting_Extend_extC: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_c) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_c, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend_Extensions_ext_c` + /// Returns true if extension `SwiftProtoTesting_Extend_Extensions_ext_c` /// has been explicitly set. - var hasProtobufUnittest_Extend_extC: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_c) + var hasSwiftProtoTesting_Extend_extC: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_c) } - /// Clears the value of extension `ProtobufUnittest_Extend_Extensions_ext_c`. + /// Clears the value of extension `SwiftProtoTesting_Extend_Extensions_ext_c`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend_extC() { - clearExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_c) + mutating func clearSwiftProtoTesting_Extend_extC() { + clearExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_c) } - var ProtobufUnittest_Extend_extD: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_d) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_d, value: newValue)} + var SwiftProtoTesting_Extend_extD: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_d) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_d, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend_Extensions_ext_d` + /// Returns true if extension `SwiftProtoTesting_Extend_Extensions_ext_d` /// has been explicitly set. - var hasProtobufUnittest_Extend_extD: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_d) + var hasSwiftProtoTesting_Extend_extD: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_d) } - /// Clears the value of extension `ProtobufUnittest_Extend_Extensions_ext_d`. + /// Clears the value of extension `SwiftProtoTesting_Extend_Extensions_ext_d`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend_extD() { - clearExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_d) + mutating func clearSwiftProtoTesting_Extend_extD() { + clearExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_d) } } -// MARK: - File's ExtensionMap: ProtobufUnittest_Extend_UnittestSwiftExtension_Extensions +// MARK: - File's ExtensionMap: SwiftProtoTesting_Extend_UnittestSwiftExtension_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 ProtobufUnittest_Extend_UnittestSwiftExtension_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_Extend_Extensions_b, - ProtobufUnittest_Extend_Extensions_C, - ProtobufUnittest_Extend_Extensions_a_b, - ProtobufUnittest_Extend_Extensions_m2, - ProtobufUnittest_Extend_Extensions_aB, - ProtobufUnittest_Extend_Extensions_ext_a, - ProtobufUnittest_Extend_Extensions_ext_b, - ProtobufUnittest_Extend_Extensions_ext_c, - ProtobufUnittest_Extend_Extensions_ext_d +let SwiftProtoTesting_Extend_UnittestSwiftExtension_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Extend_Extensions_b, + SwiftProtoTesting_Extend_Extensions_C, + SwiftProtoTesting_Extend_Extensions_a_b, + SwiftProtoTesting_Extend_Extensions_m2, + SwiftProtoTesting_Extend_Extensions_aB, + SwiftProtoTesting_Extend_Extensions_ext_a, + SwiftProtoTesting_Extend_Extensions_ext_b, + SwiftProtoTesting_Extend_Extensions_ext_c, + SwiftProtoTesting_Extend_Extensions_ext_d ] // 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 ProtobufUnittest_Extend_Extensions_b = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( +let SwiftProtoTesting_Extend_Extensions_b = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 100, - fieldName: "protobuf_unittest.extend.b" + fieldName: "swift_proto_testing.extend.b" ) -let ProtobufUnittest_Extend_Extensions_C = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( +let SwiftProtoTesting_Extend_Extensions_C = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 101, - fieldName: "protobuf_unittest.extend.c" + fieldName: "swift_proto_testing.extend.c" ) -let ProtobufUnittest_Extend_Extensions_a_b = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Msg1>( +let SwiftProtoTesting_Extend_Extensions_a_b = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Msg1>( _protobuf_fieldNumber: 1, - fieldName: "protobuf_unittest.extend.a_b" + fieldName: "swift_proto_testing.extend.a_b" ) -let ProtobufUnittest_Extend_Extensions_m2 = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Msg1>( +let SwiftProtoTesting_Extend_Extensions_m2 = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Msg1>( _protobuf_fieldNumber: 2, - fieldName: "protobuf_unittest.extend.m2" + fieldName: "swift_proto_testing.extend.m2" ) -let ProtobufUnittest_Extend_Extensions_aB = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Msg2>( +let SwiftProtoTesting_Extend_Extensions_aB = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Msg2>( _protobuf_fieldNumber: 1, - fieldName: "protobuf_unittest.extend.aB" + fieldName: "swift_proto_testing.extend.aB" ) -let ProtobufUnittest_Extend_Extensions_ext_a = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_MsgNoStorage>( +let SwiftProtoTesting_Extend_Extensions_ext_a = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_MsgNoStorage>( _protobuf_fieldNumber: 100, - fieldName: "protobuf_unittest.extend.ext_a" + fieldName: "swift_proto_testing.extend.ext_a" ) -let ProtobufUnittest_Extend_Extensions_ext_b = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_MsgNoStorage>( +let SwiftProtoTesting_Extend_Extensions_ext_b = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_MsgNoStorage>( _protobuf_fieldNumber: 101, - fieldName: "protobuf_unittest.extend.ext_b" + fieldName: "swift_proto_testing.extend.ext_b" ) -let ProtobufUnittest_Extend_Extensions_ext_c = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_MsgUsesStorage>( +let SwiftProtoTesting_Extend_Extensions_ext_c = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_MsgUsesStorage>( _protobuf_fieldNumber: 100, - fieldName: "protobuf_unittest.extend.ext_c" + fieldName: "swift_proto_testing.extend.ext_c" ) -let ProtobufUnittest_Extend_Extensions_ext_d = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_MsgUsesStorage>( +let SwiftProtoTesting_Extend_Extensions_ext_d = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_MsgUsesStorage>( _protobuf_fieldNumber: 101, - fieldName: "protobuf_unittest.extend.ext_d" + fieldName: "swift_proto_testing.extend.ext_d" ) // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest.extend" +fileprivate let _protobuf_package = "swift_proto_testing.extend" -extension ProtobufUnittest_Extend_Foo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend_Foo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Foo" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_Foo, rhs: ProtobufUnittest_Extend_Foo) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_Foo, rhs: SwiftProtoTesting_Extend_Foo) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Extend_Foo.Bar: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_Extend_Foo.protoMessageName + ".Bar" +extension SwiftProtoTesting_Extend_Foo.Bar: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Extend_Foo.protoMessageName + ".Bar" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_Foo.Bar, rhs: ProtobufUnittest_Extend_Foo.Bar) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_Foo.Bar, rhs: SwiftProtoTesting_Extend_Foo.Bar) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Extend_Foo.Bar.Baz: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_Extend_Foo.Bar.protoMessageName + ".Baz" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] +extension SwiftProtoTesting_Extend_Foo.Bar.Baz: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Extend_Foo.Bar.protoMessageName + ".Baz" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} @@ -477,7 +464,7 @@ extension ProtobufUnittest_Extend_Foo.Bar.Baz: SwiftProtobuf.Message, SwiftProto switch fieldNumber { case 1: try { try decoder.decodeSingularInt32Field(value: &self._a) }() case 100..<1001: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_Extend_Foo.Bar.Baz.self, fieldNumber: fieldNumber) }() + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Extend_Foo.Bar.Baz.self, fieldNumber: fieldNumber) }() default: break } } @@ -495,7 +482,7 @@ extension ProtobufUnittest_Extend_Foo.Bar.Baz: SwiftProtobuf.Message, SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_Foo.Bar.Baz, rhs: ProtobufUnittest_Extend_Foo.Bar.Baz) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_Foo.Bar.Baz, rhs: SwiftProtoTesting_Extend_Foo.Bar.Baz) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} @@ -503,11 +490,9 @@ extension ProtobufUnittest_Extend_Foo.Bar.Baz: SwiftProtobuf.Message, SwiftProto } } -extension ProtobufUnittest_Extend_C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend_C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".C" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 999: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}g\u{f}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -532,14 +517,14 @@ extension ProtobufUnittest_Extend_C: SwiftProtobuf.Message, SwiftProtobuf._Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_C, rhs: ProtobufUnittest_Extend_C) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_C, rhs: SwiftProtoTesting_Extend_C) -> Bool { if lhs._c != rhs._c {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Extend_Msg1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend_Msg1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg1" static let _protobuf_nameMap = SwiftProtobuf._NameMap() @@ -551,7 +536,7 @@ extension ProtobufUnittest_Extend_Msg1: SwiftProtobuf.Message, SwiftProtobuf._Me mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { if (1 <= fieldNumber && fieldNumber < 1001) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_Extend_Msg1.self, fieldNumber: fieldNumber) + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Extend_Msg1.self, fieldNumber: fieldNumber) } } } @@ -561,14 +546,14 @@ extension ProtobufUnittest_Extend_Msg1: SwiftProtobuf.Message, SwiftProtobuf._Me try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_Msg1, rhs: ProtobufUnittest_Extend_Msg1) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_Msg1, rhs: SwiftProtoTesting_Extend_Msg1) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension ProtobufUnittest_Extend_Msg2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend_Msg2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg2" static let _protobuf_nameMap = SwiftProtobuf._NameMap() @@ -580,7 +565,7 @@ extension ProtobufUnittest_Extend_Msg2: SwiftProtobuf.Message, SwiftProtobuf._Me mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { if (1 <= fieldNumber && fieldNumber < 1001) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_Extend_Msg2.self, fieldNumber: fieldNumber) + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Extend_Msg2.self, fieldNumber: fieldNumber) } } } @@ -590,18 +575,16 @@ extension ProtobufUnittest_Extend_Msg2: SwiftProtobuf.Message, SwiftProtobuf._Me try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_Msg2, rhs: ProtobufUnittest_Extend_Msg2) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_Msg2, rhs: SwiftProtoTesting_Extend_Msg2) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension ProtobufUnittest_Extend_MsgNoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend_MsgNoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MsgNoStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "x"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}x\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} @@ -616,7 +599,7 @@ extension ProtobufUnittest_Extend_MsgNoStorage: SwiftProtobuf.Message, SwiftProt switch fieldNumber { case 1: try { try decoder.decodeSingularInt32Field(value: &self._x) }() case 100..<201: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_Extend_MsgNoStorage.self, fieldNumber: fieldNumber) }() + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Extend_MsgNoStorage.self, fieldNumber: fieldNumber) }() default: break } } @@ -634,7 +617,7 @@ extension ProtobufUnittest_Extend_MsgNoStorage: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_MsgNoStorage, rhs: ProtobufUnittest_Extend_MsgNoStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_MsgNoStorage, rhs: SwiftProtoTesting_Extend_MsgNoStorage) -> Bool { if lhs._x != rhs._x {return false} if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} @@ -642,18 +625,19 @@ extension ProtobufUnittest_Extend_MsgNoStorage: SwiftProtobuf.Message, SwiftProt } } -extension ProtobufUnittest_Extend_MsgUsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend_MsgUsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MsgUsesStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "x"), - 2: .same(proto: "y"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}x\0\u{1}y\0") fileprivate class _StorageClass { var _x: Int32? = nil - var _y: ProtobufUnittest_Extend_MsgUsesStorage? = nil + var _y: SwiftProtoTesting_Extend_MsgUsesStorage? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -689,7 +673,7 @@ extension ProtobufUnittest_Extend_MsgUsesStorage: SwiftProtobuf.Message, SwiftPr case 1: try { try decoder.decodeSingularInt32Field(value: &_storage._x) }() case 2: try { try decoder.decodeSingularMessageField(value: &_storage._y) }() case 100..<201: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_Extend_MsgUsesStorage.self, fieldNumber: fieldNumber) }() + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Extend_MsgUsesStorage.self, fieldNumber: fieldNumber) }() default: break } } @@ -713,7 +697,7 @@ extension ProtobufUnittest_Extend_MsgUsesStorage: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_MsgUsesStorage, rhs: ProtobufUnittest_Extend_MsgUsesStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_MsgUsesStorage, rhs: SwiftProtoTesting_Extend_MsgUsesStorage) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 diff --git a/Reference/unittest_swift_extension2.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_extension2.pb.swift similarity index 56% rename from Reference/unittest_swift_extension2.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_extension2.pb.swift index b7be0dc6a..ae118afb2 100644 --- a/Reference/unittest_swift_extension2.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_extension2.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_extension2.proto @@ -25,7 +26,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -38,24 +38,24 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_Extend2_MyMessage { +struct SwiftProtoTesting_Extend2_MyMessage: Sendable { // 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() - struct C { + struct C: Sendable { // 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 c: Int64 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -69,17 +69,17 @@ struct ProtobufUnittest_Extend2_MyMessage { init() {} } -struct ProtobufUnittest_Extend2_C { +struct SwiftProtoTesting_Extend2_C: Sendable { // 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 c: Int64 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -90,154 +90,146 @@ struct ProtobufUnittest_Extend2_C { fileprivate var _c: Int64? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_Extend2_MyMessage: @unchecked Sendable {} -extension ProtobufUnittest_Extend2_MyMessage.C: @unchecked Sendable {} -extension ProtobufUnittest_Extend2_C: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_extension2.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 ProtobufUnittest_Extend_Foo.Bar.Baz { +extension SwiftProtoTesting_Extend_Foo.Bar.Baz { - var ProtobufUnittest_Extend2_b: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extend2_Extensions_b) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extend2_Extensions_b, value: newValue)} + var SwiftProtoTesting_Extend2_b: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend2_Extensions_b) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend2_Extensions_b, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend2_Extensions_b` + /// Returns true if extension `SwiftProtoTesting_Extend2_Extensions_b` /// has been explicitly set. - var hasProtobufUnittest_Extend2_b: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend2_Extensions_b) + var hasSwiftProtoTesting_Extend2_b: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend2_Extensions_b) } - /// Clears the value of extension `ProtobufUnittest_Extend2_Extensions_b`. + /// Clears the value of extension `SwiftProtoTesting_Extend2_Extensions_b`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend2_b() { - clearExtensionValue(ext: ProtobufUnittest_Extend2_Extensions_b) + mutating func clearSwiftProtoTesting_Extend2_b() { + clearExtensionValue(ext: SwiftProtoTesting_Extend2_Extensions_b) } - var ProtobufUnittest_Extend2_c: ProtobufUnittest_Extend2_C { - get {return getExtensionValue(ext: ProtobufUnittest_Extend2_Extensions_C) ?? ProtobufUnittest_Extend2_C()} - set {setExtensionValue(ext: ProtobufUnittest_Extend2_Extensions_C, value: newValue)} + var SwiftProtoTesting_Extend2_c: SwiftProtoTesting_Extend2_C { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend2_Extensions_C) ?? SwiftProtoTesting_Extend2_C()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend2_Extensions_C, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend2_Extensions_C` + /// Returns true if extension `SwiftProtoTesting_Extend2_Extensions_C` /// has been explicitly set. - var hasProtobufUnittest_Extend2_c: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend2_Extensions_C) + var hasSwiftProtoTesting_Extend2_c: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend2_Extensions_C) } - /// Clears the value of extension `ProtobufUnittest_Extend2_Extensions_C`. + /// Clears the value of extension `SwiftProtoTesting_Extend2_Extensions_C`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend2_c() { - clearExtensionValue(ext: ProtobufUnittest_Extend2_Extensions_C) + mutating func clearSwiftProtoTesting_Extend2_c() { + clearExtensionValue(ext: SwiftProtoTesting_Extend2_Extensions_C) } - var ProtobufUnittest_Extend2_MyMessage_b: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extend2_MyMessage.Extensions.b) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extend2_MyMessage.Extensions.b, value: newValue)} + var SwiftProtoTesting_Extend2_MyMessage_b: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend2_MyMessage.Extensions.b) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend2_MyMessage.Extensions.b, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend2_MyMessage.Extensions.b` + /// Returns true if extension `SwiftProtoTesting_Extend2_MyMessage.Extensions.b` /// has been explicitly set. - var hasProtobufUnittest_Extend2_MyMessage_b: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend2_MyMessage.Extensions.b) + var hasSwiftProtoTesting_Extend2_MyMessage_b: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend2_MyMessage.Extensions.b) } - /// Clears the value of extension `ProtobufUnittest_Extend2_MyMessage.Extensions.b`. + /// Clears the value of extension `SwiftProtoTesting_Extend2_MyMessage.Extensions.b`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend2_MyMessage_b() { - clearExtensionValue(ext: ProtobufUnittest_Extend2_MyMessage.Extensions.b) + mutating func clearSwiftProtoTesting_Extend2_MyMessage_b() { + clearExtensionValue(ext: SwiftProtoTesting_Extend2_MyMessage.Extensions.b) } - var ProtobufUnittest_Extend2_MyMessage_c: ProtobufUnittest_Extend2_MyMessage.C { - get {return getExtensionValue(ext: ProtobufUnittest_Extend2_MyMessage.Extensions.C) ?? ProtobufUnittest_Extend2_MyMessage.C()} - set {setExtensionValue(ext: ProtobufUnittest_Extend2_MyMessage.Extensions.C, value: newValue)} + var SwiftProtoTesting_Extend2_MyMessage_c: SwiftProtoTesting_Extend2_MyMessage.C { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend2_MyMessage.Extensions.C) ?? SwiftProtoTesting_Extend2_MyMessage.C()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend2_MyMessage.Extensions.C, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend2_MyMessage.Extensions.C` + /// Returns true if extension `SwiftProtoTesting_Extend2_MyMessage.Extensions.C` /// has been explicitly set. - var hasProtobufUnittest_Extend2_MyMessage_c: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend2_MyMessage.Extensions.C) + var hasSwiftProtoTesting_Extend2_MyMessage_c: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend2_MyMessage.Extensions.C) } - /// Clears the value of extension `ProtobufUnittest_Extend2_MyMessage.Extensions.C`. + /// Clears the value of extension `SwiftProtoTesting_Extend2_MyMessage.Extensions.C`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend2_MyMessage_c() { - clearExtensionValue(ext: ProtobufUnittest_Extend2_MyMessage.Extensions.C) + mutating func clearSwiftProtoTesting_Extend2_MyMessage_c() { + clearExtensionValue(ext: SwiftProtoTesting_Extend2_MyMessage.Extensions.C) } } -// MARK: - File's ExtensionMap: ProtobufUnittest_Extend2_UnittestSwiftExtension2_Extensions +// MARK: - File's ExtensionMap: SwiftProtoTesting_Extend2_UnittestSwiftExtension2_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 ProtobufUnittest_Extend2_UnittestSwiftExtension2_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_Extend2_Extensions_b, - ProtobufUnittest_Extend2_Extensions_C, - ProtobufUnittest_Extend2_MyMessage.Extensions.b, - ProtobufUnittest_Extend2_MyMessage.Extensions.C +let SwiftProtoTesting_Extend2_UnittestSwiftExtension2_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Extend2_Extensions_b, + SwiftProtoTesting_Extend2_Extensions_C, + SwiftProtoTesting_Extend2_MyMessage.Extensions.b, + SwiftProtoTesting_Extend2_MyMessage.Extensions.C ] // 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 ProtobufUnittest_Extend2_Extensions_b = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( +let SwiftProtoTesting_Extend2_Extensions_b = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 220, - fieldName: "protobuf_unittest.extend2.b" + fieldName: "swift_proto_testing.extend2.b" ) -let ProtobufUnittest_Extend2_Extensions_C = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( +let SwiftProtoTesting_Extend2_Extensions_C = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 221, - fieldName: "protobuf_unittest.extend2.c" + fieldName: "swift_proto_testing.extend2.c" ) -extension ProtobufUnittest_Extend2_MyMessage { +extension SwiftProtoTesting_Extend2_MyMessage { enum Extensions { - static let b = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( + static let b = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 210, - fieldName: "protobuf_unittest.extend2.MyMessage.b" + fieldName: "swift_proto_testing.extend2.MyMessage.b" ) - static let C = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( + static let C = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 211, - fieldName: "protobuf_unittest.extend2.MyMessage.c" + fieldName: "swift_proto_testing.extend2.MyMessage.c" ) } } // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest.extend2" +fileprivate let _protobuf_package = "swift_proto_testing.extend2" -extension ProtobufUnittest_Extend2_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend2_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MyMessage" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend2_MyMessage, rhs: ProtobufUnittest_Extend2_MyMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend2_MyMessage, rhs: SwiftProtoTesting_Extend2_MyMessage) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Extend2_MyMessage.C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_Extend2_MyMessage.protoMessageName + ".C" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1210: .same(proto: "c"), - ] +extension SwiftProtoTesting_Extend2_MyMessage.C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Extend2_MyMessage.protoMessageName + ".C" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}z\u{12}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -262,18 +254,16 @@ extension ProtobufUnittest_Extend2_MyMessage.C: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend2_MyMessage.C, rhs: ProtobufUnittest_Extend2_MyMessage.C) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend2_MyMessage.C, rhs: SwiftProtoTesting_Extend2_MyMessage.C) -> Bool { if lhs._c != rhs._c {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Extend2_C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend2_C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".C" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1220: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}D\u{13}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -298,7 +288,7 @@ extension ProtobufUnittest_Extend2_C: SwiftProtobuf.Message, SwiftProtobuf._Mess try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend2_C, rhs: ProtobufUnittest_Extend2_C) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend2_C, rhs: SwiftProtoTesting_Extend2_C) -> Bool { if lhs._c != rhs._c {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Reference/unittest_swift_extension3.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_extension3.pb.swift similarity index 56% rename from Reference/unittest_swift_extension3.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_extension3.pb.swift index 565d776f3..9d784d6cc 100644 --- a/Reference/unittest_swift_extension3.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_extension3.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_extension3.proto @@ -25,7 +26,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -38,24 +38,24 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_Extend3_MyMessage { +struct SwiftProtoTesting_Extend3_MyMessage: Sendable { // 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() - struct C { + struct C: Sendable { // 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 c: Int64 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -69,17 +69,17 @@ struct ProtobufUnittest_Extend3_MyMessage { init() {} } -struct ProtobufUnittest_Extend3_C { +struct SwiftProtoTesting_Extend3_C: Sendable { // 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 c: Int64 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -90,154 +90,146 @@ struct ProtobufUnittest_Extend3_C { fileprivate var _c: Int64? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_Extend3_MyMessage: @unchecked Sendable {} -extension ProtobufUnittest_Extend3_MyMessage.C: @unchecked Sendable {} -extension ProtobufUnittest_Extend3_C: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_extension3.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 ProtobufUnittest_Extend_Foo.Bar.Baz { +extension SwiftProtoTesting_Extend_Foo.Bar.Baz { - var ProtobufUnittest_Extend3_b: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extend3_Extensions_b) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extend3_Extensions_b, value: newValue)} + var SwiftProtoTesting_Extend3_b: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend3_Extensions_b) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend3_Extensions_b, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend3_Extensions_b` + /// Returns true if extension `SwiftProtoTesting_Extend3_Extensions_b` /// has been explicitly set. - var hasProtobufUnittest_Extend3_b: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend3_Extensions_b) + var hasSwiftProtoTesting_Extend3_b: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend3_Extensions_b) } - /// Clears the value of extension `ProtobufUnittest_Extend3_Extensions_b`. + /// Clears the value of extension `SwiftProtoTesting_Extend3_Extensions_b`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend3_b() { - clearExtensionValue(ext: ProtobufUnittest_Extend3_Extensions_b) + mutating func clearSwiftProtoTesting_Extend3_b() { + clearExtensionValue(ext: SwiftProtoTesting_Extend3_Extensions_b) } - var ProtobufUnittest_Extend3_c: ProtobufUnittest_Extend3_C { - get {return getExtensionValue(ext: ProtobufUnittest_Extend3_Extensions_C) ?? ProtobufUnittest_Extend3_C()} - set {setExtensionValue(ext: ProtobufUnittest_Extend3_Extensions_C, value: newValue)} + var SwiftProtoTesting_Extend3_c: SwiftProtoTesting_Extend3_C { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend3_Extensions_C) ?? SwiftProtoTesting_Extend3_C()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend3_Extensions_C, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend3_Extensions_C` + /// Returns true if extension `SwiftProtoTesting_Extend3_Extensions_C` /// has been explicitly set. - var hasProtobufUnittest_Extend3_c: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend3_Extensions_C) + var hasSwiftProtoTesting_Extend3_c: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend3_Extensions_C) } - /// Clears the value of extension `ProtobufUnittest_Extend3_Extensions_C`. + /// Clears the value of extension `SwiftProtoTesting_Extend3_Extensions_C`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend3_c() { - clearExtensionValue(ext: ProtobufUnittest_Extend3_Extensions_C) + mutating func clearSwiftProtoTesting_Extend3_c() { + clearExtensionValue(ext: SwiftProtoTesting_Extend3_Extensions_C) } - var ProtobufUnittest_Extend3_MyMessage_b: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extend3_MyMessage.Extensions.b) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extend3_MyMessage.Extensions.b, value: newValue)} + var SwiftProtoTesting_Extend3_MyMessage_b: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend3_MyMessage.Extensions.b) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend3_MyMessage.Extensions.b, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend3_MyMessage.Extensions.b` + /// Returns true if extension `SwiftProtoTesting_Extend3_MyMessage.Extensions.b` /// has been explicitly set. - var hasProtobufUnittest_Extend3_MyMessage_b: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend3_MyMessage.Extensions.b) + var hasSwiftProtoTesting_Extend3_MyMessage_b: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend3_MyMessage.Extensions.b) } - /// Clears the value of extension `ProtobufUnittest_Extend3_MyMessage.Extensions.b`. + /// Clears the value of extension `SwiftProtoTesting_Extend3_MyMessage.Extensions.b`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend3_MyMessage_b() { - clearExtensionValue(ext: ProtobufUnittest_Extend3_MyMessage.Extensions.b) + mutating func clearSwiftProtoTesting_Extend3_MyMessage_b() { + clearExtensionValue(ext: SwiftProtoTesting_Extend3_MyMessage.Extensions.b) } - var ProtobufUnittest_Extend3_MyMessage_c: ProtobufUnittest_Extend3_MyMessage.C { - get {return getExtensionValue(ext: ProtobufUnittest_Extend3_MyMessage.Extensions.C) ?? ProtobufUnittest_Extend3_MyMessage.C()} - set {setExtensionValue(ext: ProtobufUnittest_Extend3_MyMessage.Extensions.C, value: newValue)} + var SwiftProtoTesting_Extend3_MyMessage_c: SwiftProtoTesting_Extend3_MyMessage.C { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend3_MyMessage.Extensions.C) ?? SwiftProtoTesting_Extend3_MyMessage.C()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend3_MyMessage.Extensions.C, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend3_MyMessage.Extensions.C` + /// Returns true if extension `SwiftProtoTesting_Extend3_MyMessage.Extensions.C` /// has been explicitly set. - var hasProtobufUnittest_Extend3_MyMessage_c: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend3_MyMessage.Extensions.C) + var hasSwiftProtoTesting_Extend3_MyMessage_c: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend3_MyMessage.Extensions.C) } - /// Clears the value of extension `ProtobufUnittest_Extend3_MyMessage.Extensions.C`. + /// Clears the value of extension `SwiftProtoTesting_Extend3_MyMessage.Extensions.C`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend3_MyMessage_c() { - clearExtensionValue(ext: ProtobufUnittest_Extend3_MyMessage.Extensions.C) + mutating func clearSwiftProtoTesting_Extend3_MyMessage_c() { + clearExtensionValue(ext: SwiftProtoTesting_Extend3_MyMessage.Extensions.C) } } -// MARK: - File's ExtensionMap: ProtobufUnittest_Extend3_UnittestSwiftExtension3_Extensions +// MARK: - File's ExtensionMap: SwiftProtoTesting_Extend3_UnittestSwiftExtension3_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 ProtobufUnittest_Extend3_UnittestSwiftExtension3_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_Extend3_Extensions_b, - ProtobufUnittest_Extend3_Extensions_C, - ProtobufUnittest_Extend3_MyMessage.Extensions.b, - ProtobufUnittest_Extend3_MyMessage.Extensions.C +let SwiftProtoTesting_Extend3_UnittestSwiftExtension3_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Extend3_Extensions_b, + SwiftProtoTesting_Extend3_Extensions_C, + SwiftProtoTesting_Extend3_MyMessage.Extensions.b, + SwiftProtoTesting_Extend3_MyMessage.Extensions.C ] // 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 ProtobufUnittest_Extend3_Extensions_b = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( +let SwiftProtoTesting_Extend3_Extensions_b = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 320, - fieldName: "protobuf_unittest.extend3.b" + fieldName: "swift_proto_testing.extend3.b" ) -let ProtobufUnittest_Extend3_Extensions_C = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( +let SwiftProtoTesting_Extend3_Extensions_C = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 321, - fieldName: "protobuf_unittest.extend3.c" + fieldName: "swift_proto_testing.extend3.c" ) -extension ProtobufUnittest_Extend3_MyMessage { +extension SwiftProtoTesting_Extend3_MyMessage { enum Extensions { - static let b = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( + static let b = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 310, - fieldName: "protobuf_unittest.extend3.MyMessage.b" + fieldName: "swift_proto_testing.extend3.MyMessage.b" ) - static let C = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( + static let C = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 311, - fieldName: "protobuf_unittest.extend3.MyMessage.c" + fieldName: "swift_proto_testing.extend3.MyMessage.c" ) } } // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest.extend3" +fileprivate let _protobuf_package = "swift_proto_testing.extend3" -extension ProtobufUnittest_Extend3_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend3_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MyMessage" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend3_MyMessage, rhs: ProtobufUnittest_Extend3_MyMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend3_MyMessage, rhs: SwiftProtoTesting_Extend3_MyMessage) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Extend3_MyMessage.C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_Extend3_MyMessage.protoMessageName + ".C" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1310: .same(proto: "c"), - ] +extension SwiftProtoTesting_Extend3_MyMessage.C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Extend3_MyMessage.protoMessageName + ".C" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}^\u{14}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -262,18 +254,16 @@ extension ProtobufUnittest_Extend3_MyMessage.C: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend3_MyMessage.C, rhs: ProtobufUnittest_Extend3_MyMessage.C) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend3_MyMessage.C, rhs: SwiftProtoTesting_Extend3_MyMessage.C) -> Bool { if lhs._c != rhs._c {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Extend3_C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend3_C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".C" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1320: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}h\u{14}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -298,7 +288,7 @@ extension ProtobufUnittest_Extend3_C: SwiftProtobuf.Message, SwiftProtobuf._Mess try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend3_C, rhs: ProtobufUnittest_Extend3_C) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend3_C, rhs: SwiftProtoTesting_Extend3_C) -> Bool { if lhs._c != rhs._c {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Reference/unittest_swift_extension4.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_extension4.pb.swift similarity index 87% rename from Reference/unittest_swift_extension4.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_extension4.pb.swift index 99074cc4e..221d20ff8 100644 --- a/Reference/unittest_swift_extension4.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_extension4.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_extension4.proto @@ -25,7 +26,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -38,24 +38,24 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct Ext4MyMessage { +struct Ext4MyMessage: Sendable { // 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() - struct C { + struct C: Sendable { // 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 c: Int64 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -69,17 +69,17 @@ struct Ext4MyMessage { init() {} } -struct Ext4C { +struct Ext4C: Sendable { // 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 c: Int64 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -90,22 +90,16 @@ struct Ext4C { fileprivate var _c: Int64? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension Ext4MyMessage: @unchecked Sendable {} -extension Ext4MyMessage.C: @unchecked Sendable {} -extension Ext4C: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_extension4.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 ProtobufUnittest_Extend_Foo.Bar.Baz { +extension SwiftProtoTesting_Extend_Foo.Bar.Baz { var Ext4b: String { get {return getExtensionValue(ext: Ext4Extensions_b) ?? String()} @@ -186,41 +180,41 @@ let Ext4UnittestSwiftExtension4_Extensions: SwiftProtobuf.SimpleExtensionMap = [ // constructing a `SimpleExtensionMap`, otherwise, use the above _Extension Properties_ // accessors for the extension fields on the messages directly. -let Ext4Extensions_b = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( +let Ext4Extensions_b = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 420, - fieldName: "protobuf_unittest.extend4.b" + fieldName: "swift_proto_testing.extend4.b" ) -let Ext4Extensions_C = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( +let Ext4Extensions_C = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 421, - fieldName: "protobuf_unittest.extend4.c" + fieldName: "swift_proto_testing.extend4.c" ) extension Ext4MyMessage { enum Extensions { - static let b = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( + static let b = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 410, - fieldName: "protobuf_unittest.extend4.MyMessage.b" + fieldName: "swift_proto_testing.extend4.MyMessage.b" ) - static let C = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( + static let C = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 411, - fieldName: "protobuf_unittest.extend4.MyMessage.c" + fieldName: "swift_proto_testing.extend4.MyMessage.c" ) } } // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest.extend4" +fileprivate let _protobuf_package = "swift_proto_testing.extend4" extension Ext4MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MyMessage" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { @@ -235,9 +229,7 @@ extension Ext4MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementa extension Ext4MyMessage.C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = Ext4MyMessage.protoMessageName + ".C" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1410: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}B\u{16}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -271,9 +263,7 @@ extension Ext4MyMessage.C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplemen extension Ext4C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".C" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1420: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}L\u{16}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { diff --git a/Reference/unittest_swift_fieldorder.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_fieldorder.pb.swift similarity index 64% rename from Reference/unittest_swift_fieldorder.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_fieldorder.pb.swift index a32539341..491060e03 100644 --- a/Reference/unittest_swift_fieldorder.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_fieldorder.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_fieldorder.proto @@ -23,7 +24,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -36,39 +36,39 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct Swift_Protobuf_TestFieldOrderings: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Order_TestFieldOrderings: SwiftProtobuf.ExtensibleMessage, Sendable { // 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 myString: String { - get {return _myString ?? String()} + get {_myString ?? String()} set {_myString = newValue} } /// Returns true if `myString` has been explicitly set. - var hasMyString: Bool {return self._myString != nil} + var hasMyString: Bool {self._myString != nil} /// Clears the value of `myString`. Subsequent reads from it will return its default value. mutating func clearMyString() {self._myString = nil} var myInt: Int64 { - get {return _myInt ?? 0} + get {_myInt ?? 0} set {_myInt = newValue} } /// Returns true if `myInt` has been explicitly set. - var hasMyInt: Bool {return self._myInt != nil} + var hasMyInt: Bool {self._myInt != nil} /// Clears the value of `myInt`. Subsequent reads from it will return its default value. mutating func clearMyInt() {self._myInt = nil} var myFloat: Float { - get {return _myFloat ?? 0} + get {_myFloat ?? 0} set {_myFloat = newValue} } /// Returns true if `myFloat` has been explicitly set. - var hasMyFloat: Bool {return self._myFloat != nil} + var hasMyFloat: Bool {self._myFloat != nil} /// Clears the value of `myFloat`. Subsequent reads from it will return its default value. mutating func clearMyFloat() {self._myFloat = nil} - var options: Swift_Protobuf_TestFieldOrderings.OneOf_Options? = nil + var options: SwiftProtoTesting_Order_TestFieldOrderings.OneOf_Options? = nil var oneofInt64: Int64 { get { @@ -102,71 +102,45 @@ struct Swift_Protobuf_TestFieldOrderings: SwiftProtobuf.ExtensibleMessage { set {options = .oneofInt32(newValue)} } - var optionalNestedMessage: Swift_Protobuf_TestFieldOrderings.NestedMessage { - get {return _optionalNestedMessage ?? Swift_Protobuf_TestFieldOrderings.NestedMessage()} + var optionalNestedMessage: SwiftProtoTesting_Order_TestFieldOrderings.NestedMessage { + get {_optionalNestedMessage ?? SwiftProtoTesting_Order_TestFieldOrderings.NestedMessage()} set {_optionalNestedMessage = newValue} } /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return self._optionalNestedMessage != nil} + var hasOptionalNestedMessage: Bool {self._optionalNestedMessage != nil} /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedMessage() {self._optionalNestedMessage = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_Options: Equatable { + enum OneOf_Options: Equatable, Sendable { case oneofInt64(Int64) case oneofBool(Bool) case oneofString(String) case oneofInt32(Int32) - #if !swift(>=4.1) - static func ==(lhs: Swift_Protobuf_TestFieldOrderings.OneOf_Options, rhs: Swift_Protobuf_TestFieldOrderings.OneOf_Options) -> 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 (.oneofInt64, .oneofInt64): return { - guard case .oneofInt64(let l) = lhs, case .oneofInt64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBool, .oneofBool): return { - guard case .oneofBool(let l) = lhs, case .oneofBool(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofInt32, .oneofInt32): return { - guard case .oneofInt32(let l) = lhs, case .oneofInt32(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - struct NestedMessage { + struct NestedMessage: Sendable { // 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 oo: Int64 { - get {return _oo ?? 0} + get {_oo ?? 0} set {_oo = newValue} } /// Returns true if `oo` has been explicitly set. - var hasOo: Bool {return self._oo != nil} + var hasOo: Bool {self._oo != nil} /// Clears the value of `oo`. Subsequent reads from it will return its default value. mutating func clearOo() {self._oo = nil} var bb: Int32 { - get {return _bb ?? 0} + get {_bb ?? 0} set {_bb = newValue} } /// Returns true if `bb` has been explicitly set. - var hasBb: Bool {return self._bb != nil} + var hasBb: Bool {self._bb != nil} /// Clears the value of `bb`. Subsequent reads from it will return its default value. mutating func clearBb() {self._bb = nil} @@ -184,18 +158,18 @@ struct Swift_Protobuf_TestFieldOrderings: SwiftProtobuf.ExtensibleMessage { fileprivate var _myString: String? = nil fileprivate var _myInt: Int64? = nil fileprivate var _myFloat: Float? = nil - fileprivate var _optionalNestedMessage: Swift_Protobuf_TestFieldOrderings.NestedMessage? = nil + fileprivate var _optionalNestedMessage: SwiftProtoTesting_Order_TestFieldOrderings.NestedMessage? = nil } /// These checks how the traverse() generated for a oneof /// deals with field orders. Currently requires inspecting the code. -struct Swift_Protobuf_OneofTraversalGeneration: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Order_OneofTraversalGeneration: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. /// Gaps, not no issues, no start:end: on traverse(). - var oGood: Swift_Protobuf_OneofTraversalGeneration.OneOf_OGood? = nil + var oGood: SwiftProtoTesting_Order_OneofTraversalGeneration.OneOf_OGood? = nil var a: Int32 { get { @@ -214,7 +188,7 @@ struct Swift_Protobuf_OneofTraversalGeneration: SwiftProtobuf.ExtensibleMessage } /// Gaps with a field in the middle of the range. - var oConflictField: Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictField? = nil + var oConflictField: SwiftProtoTesting_Order_OneofTraversalGeneration.OneOf_OConflictField? = nil var a2: Int32 { get { @@ -234,16 +208,16 @@ struct Swift_Protobuf_OneofTraversalGeneration: SwiftProtobuf.ExtensibleMessage /// In the middle of previous oneof field ranges. var m: Int32 { - get {return _m ?? 0} + get {_m ?? 0} set {_m = newValue} } /// Returns true if `m` has been explicitly set. - var hasM: Bool {return self._m != nil} + var hasM: Bool {self._m != nil} /// Clears the value of `m`. Subsequent reads from it will return its default value. mutating func clearM() {self._m = nil} /// Gaps with an extension range in the middle of the range. - var oConflictExtensionsStart: Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictExtensionsStart? = nil + var oConflictExtensionsStart: SwiftProtoTesting_Order_OneofTraversalGeneration.OneOf_OConflictExtensionsStart? = nil var a3: Int32 { get { @@ -262,7 +236,7 @@ struct Swift_Protobuf_OneofTraversalGeneration: SwiftProtobuf.ExtensibleMessage } /// Gaps with an extension range in the middle of the range. - var oConflictExtensionsEnd: Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictExtensionsEnd? = nil + var oConflictExtensionsEnd: SwiftProtoTesting_Order_OneofTraversalGeneration.OneOf_OConflictExtensionsEnd? = nil var a4: Int32 { get { @@ -283,103 +257,31 @@ struct Swift_Protobuf_OneofTraversalGeneration: SwiftProtobuf.ExtensibleMessage var unknownFields = SwiftProtobuf.UnknownStorage() /// Gaps, not no issues, no start:end: on traverse(). - enum OneOf_OGood: Equatable { + enum OneOf_OGood: Equatable, Sendable { case a(Int32) case b(Int32) - #if !swift(>=4.1) - static func ==(lhs: Swift_Protobuf_OneofTraversalGeneration.OneOf_OGood, rhs: Swift_Protobuf_OneofTraversalGeneration.OneOf_OGood) -> 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 (.a, .a): return { - guard case .a(let l) = lhs, case .a(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.b, .b): return { - guard case .b(let l) = lhs, case .b(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } /// Gaps with a field in the middle of the range. - enum OneOf_OConflictField: Equatable { + enum OneOf_OConflictField: Equatable, Sendable { case a2(Int32) case b2(Int32) - #if !swift(>=4.1) - static func ==(lhs: Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictField, rhs: Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictField) -> 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 (.a2, .a2): return { - guard case .a2(let l) = lhs, case .a2(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.b2, .b2): return { - guard case .b2(let l) = lhs, case .b2(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } /// Gaps with an extension range in the middle of the range. - enum OneOf_OConflictExtensionsStart: Equatable { + enum OneOf_OConflictExtensionsStart: Equatable, Sendable { case a3(Int32) case b3(Int32) - #if !swift(>=4.1) - static func ==(lhs: Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictExtensionsStart, rhs: Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictExtensionsStart) -> 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 (.a3, .a3): return { - guard case .a3(let l) = lhs, case .a3(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.b3, .b3): return { - guard case .b3(let l) = lhs, case .b3(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } /// Gaps with an extension range in the middle of the range. - enum OneOf_OConflictExtensionsEnd: Equatable { + enum OneOf_OConflictExtensionsEnd: Equatable, Sendable { case a4(Int32) case b4(Int32) - #if !swift(>=4.1) - static func ==(lhs: Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictExtensionsEnd, rhs: Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictExtensionsEnd) -> 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 (.a4, .a4): return { - guard case .a4(let l) = lhs, case .a4(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.b4, .b4): return { - guard case .b4(let l) = lhs, case .b4(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } init() {} @@ -388,101 +290,81 @@ struct Swift_Protobuf_OneofTraversalGeneration: SwiftProtobuf.ExtensibleMessage fileprivate var _m: Int32? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension Swift_Protobuf_TestFieldOrderings: @unchecked Sendable {} -extension Swift_Protobuf_TestFieldOrderings.OneOf_Options: @unchecked Sendable {} -extension Swift_Protobuf_TestFieldOrderings.NestedMessage: @unchecked Sendable {} -extension Swift_Protobuf_OneofTraversalGeneration: @unchecked Sendable {} -extension Swift_Protobuf_OneofTraversalGeneration.OneOf_OGood: @unchecked Sendable {} -extension Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictField: @unchecked Sendable {} -extension Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictExtensionsStart: @unchecked Sendable {} -extension Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictExtensionsEnd: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_fieldorder.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 Swift_Protobuf_TestFieldOrderings { +extension SwiftProtoTesting_Order_TestFieldOrderings { - var Swift_Protobuf_myExtensionString: String { - get {return getExtensionValue(ext: Swift_Protobuf_Extensions_my_extension_string) ?? String()} - set {setExtensionValue(ext: Swift_Protobuf_Extensions_my_extension_string, value: newValue)} + var SwiftProtoTesting_Order_myExtensionString: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Order_Extensions_my_extension_string) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Order_Extensions_my_extension_string, value: newValue)} } - /// Returns true if extension `Swift_Protobuf_Extensions_my_extension_string` + /// Returns true if extension `SwiftProtoTesting_Order_Extensions_my_extension_string` /// has been explicitly set. - var hasSwift_Protobuf_myExtensionString: Bool { - return hasExtensionValue(ext: Swift_Protobuf_Extensions_my_extension_string) + var hasSwiftProtoTesting_Order_myExtensionString: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Order_Extensions_my_extension_string) } - /// Clears the value of extension `Swift_Protobuf_Extensions_my_extension_string`. + /// Clears the value of extension `SwiftProtoTesting_Order_Extensions_my_extension_string`. /// Subsequent reads from it will return its default value. - mutating func clearSwift_Protobuf_myExtensionString() { - clearExtensionValue(ext: Swift_Protobuf_Extensions_my_extension_string) + mutating func clearSwiftProtoTesting_Order_myExtensionString() { + clearExtensionValue(ext: SwiftProtoTesting_Order_Extensions_my_extension_string) } - var Swift_Protobuf_myExtensionInt: Int32 { - get {return getExtensionValue(ext: Swift_Protobuf_Extensions_my_extension_int) ?? 0} - set {setExtensionValue(ext: Swift_Protobuf_Extensions_my_extension_int, value: newValue)} + var SwiftProtoTesting_Order_myExtensionInt: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Order_Extensions_my_extension_int) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Order_Extensions_my_extension_int, value: newValue)} } - /// Returns true if extension `Swift_Protobuf_Extensions_my_extension_int` + /// Returns true if extension `SwiftProtoTesting_Order_Extensions_my_extension_int` /// has been explicitly set. - var hasSwift_Protobuf_myExtensionInt: Bool { - return hasExtensionValue(ext: Swift_Protobuf_Extensions_my_extension_int) + var hasSwiftProtoTesting_Order_myExtensionInt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Order_Extensions_my_extension_int) } - /// Clears the value of extension `Swift_Protobuf_Extensions_my_extension_int`. + /// Clears the value of extension `SwiftProtoTesting_Order_Extensions_my_extension_int`. /// Subsequent reads from it will return its default value. - mutating func clearSwift_Protobuf_myExtensionInt() { - clearExtensionValue(ext: Swift_Protobuf_Extensions_my_extension_int) + mutating func clearSwiftProtoTesting_Order_myExtensionInt() { + clearExtensionValue(ext: SwiftProtoTesting_Order_Extensions_my_extension_int) } } -// MARK: - File's ExtensionMap: Swift_Protobuf_UnittestSwiftFieldorder_Extensions +// MARK: - File's ExtensionMap: SwiftProtoTesting_Order_UnittestSwiftFieldorder_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 Swift_Protobuf_UnittestSwiftFieldorder_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - Swift_Protobuf_Extensions_my_extension_string, - Swift_Protobuf_Extensions_my_extension_int +let SwiftProtoTesting_Order_UnittestSwiftFieldorder_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Order_Extensions_my_extension_string, + SwiftProtoTesting_Order_Extensions_my_extension_int ] // 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 Swift_Protobuf_Extensions_my_extension_string = SwiftProtobuf.MessageExtension, Swift_Protobuf_TestFieldOrderings>( +let SwiftProtoTesting_Order_Extensions_my_extension_string = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Order_TestFieldOrderings>( _protobuf_fieldNumber: 50, - fieldName: "swift.protobuf.my_extension_string" + fieldName: "swift_proto_testing.order.my_extension_string" ) -let Swift_Protobuf_Extensions_my_extension_int = SwiftProtobuf.MessageExtension, Swift_Protobuf_TestFieldOrderings>( +let SwiftProtoTesting_Order_Extensions_my_extension_int = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Order_TestFieldOrderings>( _protobuf_fieldNumber: 5, - fieldName: "swift.protobuf.my_extension_int" + fieldName: "swift_proto_testing.order.my_extension_int" ) // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "swift.protobuf" +fileprivate let _protobuf_package = "swift_proto_testing.order" -extension Swift_Protobuf_TestFieldOrderings: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Order_TestFieldOrderings: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestFieldOrderings" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 11: .standard(proto: "my_string"), - 1: .standard(proto: "my_int"), - 101: .standard(proto: "my_float"), - 60: .standard(proto: "oneof_int64"), - 9: .standard(proto: "oneof_bool"), - 150: .standard(proto: "oneof_string"), - 10: .standard(proto: "oneof_int32"), - 200: .standard(proto: "optional_nested_message"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}my_int\0\u{4}\u{8}oneof_bool\0\u{3}oneof_int32\0\u{3}my_string\0\u{4}1oneof_int64\0\u{4})my_float\0\u{4}1oneof_string\0\u{4}2optional_nested_message\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} @@ -532,7 +414,7 @@ extension Swift_Protobuf_TestFieldOrderings: SwiftProtobuf.Message, SwiftProtobu }() case 200: try { try decoder.decodeSingularMessageField(value: &self._optionalNestedMessage) }() case 2..<9, 12..<56: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Swift_Protobuf_TestFieldOrderings.self, fieldNumber: fieldNumber) }() + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Order_TestFieldOrderings.self, fieldNumber: fieldNumber) }() default: break } } @@ -577,7 +459,7 @@ extension Swift_Protobuf_TestFieldOrderings: SwiftProtobuf.Message, SwiftProtobu try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Swift_Protobuf_TestFieldOrderings, rhs: Swift_Protobuf_TestFieldOrderings) -> Bool { + static func ==(lhs: SwiftProtoTesting_Order_TestFieldOrderings, rhs: SwiftProtoTesting_Order_TestFieldOrderings) -> Bool { if lhs._myString != rhs._myString {return false} if lhs._myInt != rhs._myInt {return false} if lhs._myFloat != rhs._myFloat {return false} @@ -589,12 +471,9 @@ extension Swift_Protobuf_TestFieldOrderings: SwiftProtobuf.Message, SwiftProtobu } } -extension Swift_Protobuf_TestFieldOrderings.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = Swift_Protobuf_TestFieldOrderings.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2: .same(proto: "oo"), - 1: .same(proto: "bb"), - ] +extension SwiftProtoTesting_Order_TestFieldOrderings.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Order_TestFieldOrderings.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0\u{1}oo\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -623,7 +502,7 @@ extension Swift_Protobuf_TestFieldOrderings.NestedMessage: SwiftProtobuf.Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Swift_Protobuf_TestFieldOrderings.NestedMessage, rhs: Swift_Protobuf_TestFieldOrderings.NestedMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Order_TestFieldOrderings.NestedMessage, rhs: SwiftProtoTesting_Order_TestFieldOrderings.NestedMessage) -> Bool { if lhs._oo != rhs._oo {return false} if lhs._bb != rhs._bb {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -631,19 +510,9 @@ extension Swift_Protobuf_TestFieldOrderings.NestedMessage: SwiftProtobuf.Message } } -extension Swift_Protobuf_OneofTraversalGeneration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Order_OneofTraversalGeneration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".OneofTraversalGeneration" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 26: .same(proto: "b"), - 101: .same(proto: "a2"), - 126: .same(proto: "b2"), - 113: .same(proto: "m"), - 201: .same(proto: "a3"), - 226: .same(proto: "b3"), - 301: .same(proto: "a4"), - 326: .same(proto: "b4"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{2}\u{19}b\0\u{2}K\u{1}a2\0\u{2}\u{c}m\0\u{2}\u{d}b2\0\u{2}K\u{1}a3\0\u{2}\u{19}b3\0\u{2}K\u{1}a4\0\u{2}\u{19}b4\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} @@ -722,7 +591,7 @@ extension Swift_Protobuf_OneofTraversalGeneration: SwiftProtobuf.Message, SwiftP } }() case 202, 325: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Swift_Protobuf_OneofTraversalGeneration.self, fieldNumber: fieldNumber) }() + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Order_OneofTraversalGeneration.self, fieldNumber: fieldNumber) }() default: break } } @@ -770,7 +639,7 @@ extension Swift_Protobuf_OneofTraversalGeneration: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Swift_Protobuf_OneofTraversalGeneration, rhs: Swift_Protobuf_OneofTraversalGeneration) -> Bool { + static func ==(lhs: SwiftProtoTesting_Order_OneofTraversalGeneration, rhs: SwiftProtoTesting_Order_OneofTraversalGeneration) -> Bool { if lhs.oGood != rhs.oGood {return false} if lhs.oConflictField != rhs.oConflictField {return false} if lhs._m != rhs._m {return false} diff --git a/Reference/unittest_swift_groups.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_groups.pb.swift similarity index 71% rename from Reference/unittest_swift_groups.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_groups.pb.swift index 79c852988..6f52ff8da 100644 --- a/Reference/unittest_swift_groups.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_groups.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_groups.proto @@ -37,7 +38,6 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -51,17 +51,17 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP } /// Same field number appears inside and outside of the group. -struct SwiftTestGroupExtensions: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_GroupExtensions: SwiftProtobuf.ExtensibleMessage, Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -73,17 +73,17 @@ struct SwiftTestGroupExtensions: SwiftProtobuf.ExtensibleMessage { fileprivate var _a: Int32? = nil } -struct ExtensionGroup { +struct SwiftProtoTesting_ExtensionGroup: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -94,17 +94,17 @@ struct ExtensionGroup { fileprivate var _a: Int32? = nil } -struct RepeatedExtensionGroup { +struct SwiftProtoTesting_RepeatedExtensionGroup: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -115,17 +115,17 @@ struct RepeatedExtensionGroup { fileprivate var _a: Int32? = nil } -struct SwiftTestGroupUnextended { +struct SwiftProtoTesting_GroupUnextended: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -136,69 +136,69 @@ struct SwiftTestGroupUnextended { fileprivate var _a: Int32? = nil } -struct SwiftTestNestingGroupsMessage { +struct SwiftProtoTesting_NestingGroupsMessage: Sendable { // 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 outerA: Int32 { - get {return _outerA ?? 0} + get {_outerA ?? 0} set {_outerA = newValue} } /// Returns true if `outerA` has been explicitly set. - var hasOuterA: Bool {return self._outerA != nil} + var hasOuterA: Bool {self._outerA != nil} /// Clears the value of `outerA`. Subsequent reads from it will return its default value. mutating func clearOuterA() {self._outerA = nil} - var subGroup1: SwiftTestNestingGroupsMessage.SubGroup1 { - get {return _subGroup1 ?? SwiftTestNestingGroupsMessage.SubGroup1()} + var subGroup1: SwiftProtoTesting_NestingGroupsMessage.SubGroup1 { + get {_subGroup1 ?? SwiftProtoTesting_NestingGroupsMessage.SubGroup1()} set {_subGroup1 = newValue} } /// Returns true if `subGroup1` has been explicitly set. - var hasSubGroup1: Bool {return self._subGroup1 != nil} + var hasSubGroup1: Bool {self._subGroup1 != nil} /// Clears the value of `subGroup1`. Subsequent reads from it will return its default value. mutating func clearSubGroup1() {self._subGroup1 = nil} - var subGroup3: [SwiftTestNestingGroupsMessage.SubGroup3] = [] + var subGroup3: [SwiftProtoTesting_NestingGroupsMessage.SubGroup3] = [] var unknownFields = SwiftProtobuf.UnknownStorage() - struct SubGroup1 { + struct SubGroup1: Sendable { // 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 sub1A: Int32 { - get {return _sub1A ?? 0} + get {_sub1A ?? 0} set {_sub1A = newValue} } /// Returns true if `sub1A` has been explicitly set. - var hasSub1A: Bool {return self._sub1A != nil} + var hasSub1A: Bool {self._sub1A != nil} /// Clears the value of `sub1A`. Subsequent reads from it will return its default value. mutating func clearSub1A() {self._sub1A = nil} - var subGroup2: SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2 { - get {return _subGroup2 ?? SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2()} + var subGroup2: SwiftProtoTesting_NestingGroupsMessage.SubGroup1.SubGroup2 { + get {_subGroup2 ?? SwiftProtoTesting_NestingGroupsMessage.SubGroup1.SubGroup2()} set {_subGroup2 = newValue} } /// Returns true if `subGroup2` has been explicitly set. - var hasSubGroup2: Bool {return self._subGroup2 != nil} + var hasSubGroup2: Bool {self._subGroup2 != nil} /// Clears the value of `subGroup2`. Subsequent reads from it will return its default value. mutating func clearSubGroup2() {self._subGroup2 = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - struct SubGroup2 { + struct SubGroup2: Sendable { // 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 sub2A: Int32 { - get {return _sub2A ?? 0} + get {_sub2A ?? 0} set {_sub2A = newValue} } /// Returns true if `sub2A` has been explicitly set. - var hasSub2A: Bool {return self._sub2A != nil} + var hasSub2A: Bool {self._sub2A != nil} /// Clears the value of `sub2A`. Subsequent reads from it will return its default value. mutating func clearSub2A() {self._sub2A = nil} @@ -212,38 +212,38 @@ struct SwiftTestNestingGroupsMessage { init() {} fileprivate var _sub1A: Int32? = nil - fileprivate var _subGroup2: SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2? = nil + fileprivate var _subGroup2: SwiftProtoTesting_NestingGroupsMessage.SubGroup1.SubGroup2? = nil } - struct SubGroup3 { + struct SubGroup3: Sendable { // 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 sub3A: Int32 { - get {return _sub3A ?? 0} + get {_sub3A ?? 0} set {_sub3A = newValue} } /// Returns true if `sub3A` has been explicitly set. - var hasSub3A: Bool {return self._sub3A != nil} + var hasSub3A: Bool {self._sub3A != nil} /// Clears the value of `sub3A`. Subsequent reads from it will return its default value. mutating func clearSub3A() {self._sub3A = nil} - var subGroup4: [SwiftTestNestingGroupsMessage.SubGroup3.SubGroup4] = [] + var subGroup4: [SwiftProtoTesting_NestingGroupsMessage.SubGroup3.SubGroup4] = [] var unknownFields = SwiftProtobuf.UnknownStorage() - struct SubGroup4 { + struct SubGroup4: Sendable { // 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 sub4A: Int32 { - get {return _sub4A ?? 0} + get {_sub4A ?? 0} set {_sub4A = newValue} } /// Returns true if `sub4A` has been explicitly set. - var hasSub4A: Bool {return self._sub4A != nil} + var hasSub4A: Bool {self._sub4A != nil} /// Clears the value of `sub4A`. Subsequent reads from it will return its default value. mutating func clearSub4A() {self._sub4A = nil} @@ -262,96 +262,74 @@ struct SwiftTestNestingGroupsMessage { init() {} fileprivate var _outerA: Int32? = nil - fileprivate var _subGroup1: SwiftTestNestingGroupsMessage.SubGroup1? = nil + fileprivate var _subGroup1: SwiftProtoTesting_NestingGroupsMessage.SubGroup1? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension SwiftTestGroupExtensions: @unchecked Sendable {} -extension ExtensionGroup: @unchecked Sendable {} -extension RepeatedExtensionGroup: @unchecked Sendable {} -extension SwiftTestGroupUnextended: @unchecked Sendable {} -extension SwiftTestNestingGroupsMessage: @unchecked Sendable {} -extension SwiftTestNestingGroupsMessage.SubGroup1: @unchecked Sendable {} -extension SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2: @unchecked Sendable {} -extension SwiftTestNestingGroupsMessage.SubGroup3: @unchecked Sendable {} -extension SwiftTestNestingGroupsMessage.SubGroup3.SubGroup4: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_groups.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 SwiftTestGroupExtensions { +extension SwiftProtoTesting_GroupExtensions { - var extensionGroup: ExtensionGroup { - get {return getExtensionValue(ext: Extensions_ExtensionGroup) ?? ExtensionGroup()} - set {setExtensionValue(ext: Extensions_ExtensionGroup, value: newValue)} + var SwiftProtoTesting_extensionGroup: SwiftProtoTesting_ExtensionGroup { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_ExtensionGroup) ?? SwiftProtoTesting_ExtensionGroup()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_ExtensionGroup, value: newValue)} } - /// Returns true if extension `Extensions_ExtensionGroup` + /// Returns true if extension `SwiftProtoTesting_Extensions_ExtensionGroup` /// has been explicitly set. - var hasExtensionGroup: Bool { - return hasExtensionValue(ext: Extensions_ExtensionGroup) + var hasSwiftProtoTesting_extensionGroup: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_ExtensionGroup) } - /// Clears the value of extension `Extensions_ExtensionGroup`. + /// Clears the value of extension `SwiftProtoTesting_Extensions_ExtensionGroup`. /// Subsequent reads from it will return its default value. - mutating func clearExtensionGroup() { - clearExtensionValue(ext: Extensions_ExtensionGroup) + mutating func clearSwiftProtoTesting_extensionGroup() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_ExtensionGroup) } - var repeatedExtensionGroup: [RepeatedExtensionGroup] { - get {return getExtensionValue(ext: Extensions_RepeatedExtensionGroup) ?? []} - set {setExtensionValue(ext: Extensions_RepeatedExtensionGroup, value: newValue)} - } - /// Returns true if extension `Extensions_RepeatedExtensionGroup` - /// has been explicitly set. - var hasRepeatedExtensionGroup: Bool { - return hasExtensionValue(ext: Extensions_RepeatedExtensionGroup) - } - /// Clears the value of extension `Extensions_RepeatedExtensionGroup`. - /// Subsequent reads from it will return its default value. - mutating func clearRepeatedExtensionGroup() { - clearExtensionValue(ext: Extensions_RepeatedExtensionGroup) + var SwiftProtoTesting_repeatedExtensionGroup: [SwiftProtoTesting_RepeatedExtensionGroup] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_RepeatedExtensionGroup) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_RepeatedExtensionGroup, value: newValue)} } } -// MARK: - File's ExtensionMap: UnittestSwiftGroups_Extensions +// MARK: - File's ExtensionMap: SwiftProtoTesting_UnittestSwiftGroups_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 UnittestSwiftGroups_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - Extensions_ExtensionGroup, - Extensions_RepeatedExtensionGroup +let SwiftProtoTesting_UnittestSwiftGroups_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Extensions_ExtensionGroup, + SwiftProtoTesting_Extensions_RepeatedExtensionGroup ] // 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 Extensions_ExtensionGroup = SwiftProtobuf.MessageExtension, SwiftTestGroupExtensions>( +let SwiftProtoTesting_Extensions_ExtensionGroup = SwiftProtobuf.MessageExtension, SwiftProtoTesting_GroupExtensions>( _protobuf_fieldNumber: 2, - fieldName: "extensiongroup" + fieldName: "swift_proto_testing.extensiongroup" ) -let Extensions_RepeatedExtensionGroup = SwiftProtobuf.MessageExtension, SwiftTestGroupExtensions>( +let SwiftProtoTesting_Extensions_RepeatedExtensionGroup = SwiftProtobuf.MessageExtension, SwiftProtoTesting_GroupExtensions>( _protobuf_fieldNumber: 3, - fieldName: "repeatedextensiongroup" + fieldName: "swift_proto_testing.repeatedextensiongroup" ) // MARK: - Code below here is support for the SwiftProtobuf runtime. -extension SwiftTestGroupExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = "SwiftTestGroupExtensions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] +fileprivate let _protobuf_package = "swift_proto_testing" + +extension SwiftProtoTesting_GroupExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GroupExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} @@ -366,7 +344,7 @@ extension SwiftTestGroupExtensions: SwiftProtobuf.Message, SwiftProtobuf._Messag switch fieldNumber { case 1: try { try decoder.decodeSingularInt32Field(value: &self._a) }() case 2..<11: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftTestGroupExtensions.self, fieldNumber: fieldNumber) }() + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_GroupExtensions.self, fieldNumber: fieldNumber) }() default: break } } @@ -384,7 +362,7 @@ extension SwiftTestGroupExtensions: SwiftProtobuf.Message, SwiftProtobuf._Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftTestGroupExtensions, rhs: SwiftTestGroupExtensions) -> Bool { + static func ==(lhs: SwiftProtoTesting_GroupExtensions, rhs: SwiftProtoTesting_GroupExtensions) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} @@ -392,11 +370,9 @@ extension SwiftTestGroupExtensions: SwiftProtobuf.Message, SwiftProtobuf._Messag } } -extension ExtensionGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = "ExtensionGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] +extension SwiftProtoTesting_ExtensionGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ExtensionGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -421,18 +397,16 @@ extension ExtensionGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplement try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ExtensionGroup, rhs: ExtensionGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_ExtensionGroup, rhs: SwiftProtoTesting_ExtensionGroup) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension RepeatedExtensionGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = "RepeatedExtensionGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] +extension SwiftProtoTesting_RepeatedExtensionGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".RepeatedExtensionGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -457,18 +431,16 @@ extension RepeatedExtensionGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageI try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: RepeatedExtensionGroup, rhs: RepeatedExtensionGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_RepeatedExtensionGroup, rhs: SwiftProtoTesting_RepeatedExtensionGroup) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftTestGroupUnextended: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = "SwiftTestGroupUnextended" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] +extension SwiftProtoTesting_GroupUnextended: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GroupUnextended" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -493,20 +465,16 @@ extension SwiftTestGroupUnextended: SwiftProtobuf.Message, SwiftProtobuf._Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftTestGroupUnextended, rhs: SwiftTestGroupUnextended) -> Bool { + static func ==(lhs: SwiftProtoTesting_GroupUnextended, rhs: SwiftProtoTesting_GroupUnextended) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftTestNestingGroupsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = "SwiftTestNestingGroupsMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "outer_a"), - 2: .unique(proto: "SubGroup1", json: "subgroup1"), - 3: .unique(proto: "SubGroup3", json: "subgroup3"), - ] +extension SwiftProtoTesting_NestingGroupsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NestingGroupsMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}outer_a\0\u{7}SubGroup1\0\u{7}SubGroup3\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -539,7 +507,7 @@ extension SwiftTestNestingGroupsMessage: SwiftProtobuf.Message, SwiftProtobuf._M try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftTestNestingGroupsMessage, rhs: SwiftTestNestingGroupsMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_NestingGroupsMessage, rhs: SwiftProtoTesting_NestingGroupsMessage) -> Bool { if lhs._outerA != rhs._outerA {return false} if lhs._subGroup1 != rhs._subGroup1 {return false} if lhs.subGroup3 != rhs.subGroup3 {return false} @@ -548,12 +516,9 @@ extension SwiftTestNestingGroupsMessage: SwiftProtobuf.Message, SwiftProtobuf._M } } -extension SwiftTestNestingGroupsMessage.SubGroup1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftTestNestingGroupsMessage.protoMessageName + ".SubGroup1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "sub1_a"), - 2: .unique(proto: "SubGroup2", json: "subgroup2"), - ] +extension SwiftProtoTesting_NestingGroupsMessage.SubGroup1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_NestingGroupsMessage.protoMessageName + ".SubGroup1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}sub1_a\0\u{7}SubGroup2\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -582,7 +547,7 @@ extension SwiftTestNestingGroupsMessage.SubGroup1: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftTestNestingGroupsMessage.SubGroup1, rhs: SwiftTestNestingGroupsMessage.SubGroup1) -> Bool { + static func ==(lhs: SwiftProtoTesting_NestingGroupsMessage.SubGroup1, rhs: SwiftProtoTesting_NestingGroupsMessage.SubGroup1) -> Bool { if lhs._sub1A != rhs._sub1A {return false} if lhs._subGroup2 != rhs._subGroup2 {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -590,11 +555,9 @@ extension SwiftTestNestingGroupsMessage.SubGroup1: SwiftProtobuf.Message, SwiftP } } -extension SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftTestNestingGroupsMessage.SubGroup1.protoMessageName + ".SubGroup2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "sub2_a"), - ] +extension SwiftProtoTesting_NestingGroupsMessage.SubGroup1.SubGroup2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_NestingGroupsMessage.SubGroup1.protoMessageName + ".SubGroup2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}sub2_a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -619,19 +582,16 @@ extension SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2, rhs: SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2) -> Bool { + static func ==(lhs: SwiftProtoTesting_NestingGroupsMessage.SubGroup1.SubGroup2, rhs: SwiftProtoTesting_NestingGroupsMessage.SubGroup1.SubGroup2) -> Bool { if lhs._sub2A != rhs._sub2A {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftTestNestingGroupsMessage.SubGroup3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftTestNestingGroupsMessage.protoMessageName + ".SubGroup3" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "sub3_a"), - 2: .unique(proto: "SubGroup4", json: "subgroup4"), - ] +extension SwiftProtoTesting_NestingGroupsMessage.SubGroup3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_NestingGroupsMessage.protoMessageName + ".SubGroup3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}sub3_a\0\u{7}SubGroup4\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -660,7 +620,7 @@ extension SwiftTestNestingGroupsMessage.SubGroup3: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftTestNestingGroupsMessage.SubGroup3, rhs: SwiftTestNestingGroupsMessage.SubGroup3) -> Bool { + static func ==(lhs: SwiftProtoTesting_NestingGroupsMessage.SubGroup3, rhs: SwiftProtoTesting_NestingGroupsMessage.SubGroup3) -> Bool { if lhs._sub3A != rhs._sub3A {return false} if lhs.subGroup4 != rhs.subGroup4 {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -668,11 +628,9 @@ extension SwiftTestNestingGroupsMessage.SubGroup3: SwiftProtobuf.Message, SwiftP } } -extension SwiftTestNestingGroupsMessage.SubGroup3.SubGroup4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftTestNestingGroupsMessage.SubGroup3.protoMessageName + ".SubGroup4" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "sub4_a"), - ] +extension SwiftProtoTesting_NestingGroupsMessage.SubGroup3.SubGroup4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_NestingGroupsMessage.SubGroup3.protoMessageName + ".SubGroup4" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}sub4_a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -697,7 +655,7 @@ extension SwiftTestNestingGroupsMessage.SubGroup3.SubGroup4: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftTestNestingGroupsMessage.SubGroup3.SubGroup4, rhs: SwiftTestNestingGroupsMessage.SubGroup3.SubGroup4) -> Bool { + static func ==(lhs: SwiftProtoTesting_NestingGroupsMessage.SubGroup3.SubGroup4, rhs: SwiftProtoTesting_NestingGroupsMessage.SubGroup3.SubGroup4) -> Bool { if lhs._sub4A != rhs._sub4A {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Reference/unittest_swift_json.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_json.pb.swift similarity index 80% rename from Reference/unittest_swift_json.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_json.pb.swift index 36e6d685f..afd415b8d 100644 --- a/Reference/unittest_swift_json.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_json.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_json.proto @@ -16,7 +17,6 @@ // See http://swift.org/LICENSE.txt for license information // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -29,7 +29,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_SwiftJSONTest { +struct SwiftProtoTesting_SwiftJSONTest: Sendable { // 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. @@ -42,19 +42,13 @@ struct ProtobufUnittest_SwiftJSONTest { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_SwiftJSONTest: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_SwiftJSONTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_SwiftJSONTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SwiftJSONTest" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 318: .standard(proto: "repeated_null_value"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}~\u{4}repeated_null_value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -75,7 +69,7 @@ extension ProtobufUnittest_SwiftJSONTest: SwiftProtobuf.Message, SwiftProtobuf._ try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_SwiftJSONTest, rhs: ProtobufUnittest_SwiftJSONTest) -> Bool { + static func ==(lhs: SwiftProtoTesting_SwiftJSONTest, rhs: SwiftProtoTesting_SwiftJSONTest) -> Bool { if lhs.repeatedNullValue != rhs.repeatedNullValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Reference/unittest_swift_naming.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_naming.pb.swift similarity index 60% rename from Reference/unittest_swift_naming.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_naming.pb.swift index c55c0afab..2ab44a455 100644 --- a/Reference/unittest_swift_naming.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_naming.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_naming.proto @@ -25,7 +26,6 @@ /// proto2 syntax is used so the has*/clear* names also get generated. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -38,663 +38,226 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum SwiftUnittest_Names_EnumFieldNames: SwiftProtobuf.Enum { - typealias RawValue = Int - case a // = 0 - case string // = 1 - case int // = 2 - case double // = 3 - case float // = 4 - case uint // = 5 - case hashValue_ // = 6 - case description_ // = 7 - case debugDescription_ // = 8 - case swift // = 9 - case unrecognized // = 10 - case `class` // = 11 - case `deinit` // = 12 - case `enum` // = 13 - case `extension` // = 14 - case `func` // = 15 - case `import` // = 16 - case init_ // = 17 - case `inout` // = 18 - case `internal` // = 19 - case `let` // = 20 - case `operator` // = 21 - case `private` // = 22 - case `protocol` // = 23 - case `public` // = 24 - case `static` // = 25 - case `struct` // = 26 - case `subscript` // = 27 - case `typealias` // = 28 - case `var` // = 29 - case `break` // = 30 - case `case` // = 31 - case `continue` // = 32 - case `default` // = 33 - case `defer` // = 34 - case `do` // = 35 - case `else` // = 36 - case `fallthrough` // = 37 - case `for` // = 38 - case `guard` // = 39 - case `if` // = 40 - case `in` // = 41 - case `repeat` // = 42 - case `return` // = 43 - case `switch` // = 44 - case `where` // = 45 - case `while` // = 46 - case `as` // = 47 - case `catch` // = 48 - case dynamicType_ // = 49 - case `false` // = 50 - case `is` // = 51 - case `nil` // = 52 - case `rethrows` // = 53 - case `super` // = 54 - case self_ // = 55 - case `throw` // = 57 - case `throws` // = 58 - case `true` // = 59 - case `try` // = 60 - case _Column__ // = 61 - case _File__ // = 62 - case _Function__ // = 63 - case _Line__ // = 64 - case ___ // = 65 - case `associativity` // = 66 - case convenience // = 67 - case dynamic // = 68 - case didSet // = 69 - case final // = 70 - case get // = 71 - case infix // = 72 - case indirect // = 73 - case lazy // = 74 - case left // = 75 - case mutating // = 76 - case none // = 77 - case nonmutating // = 78 - case `optional` // = 79 - case override // = 80 - case postfix // = 81 - case precedence // = 82 - case prefix // = 83 - case `required` // = 85 - case right // = 86 - case set // = 87 - case type // = 88 - case unowned // = 89 - case weak // = 90 - case willSet // = 91 +enum SwiftProtoTesting_Names_EnumFieldNames: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case a = 0 + case string = 1 + case int = 2 + case double = 3 + case float = 4 + case uint = 5 + case hashValue_ = 6 + case description_ = 7 + case debugDescription_ = 8 + case swift = 9 + case unrecognized = 10 + case `class` = 11 + case `deinit` = 12 + case `enum` = 13 + case `extension` = 14 + case `func` = 15 + case `import` = 16 + case init_ = 17 + case `inout` = 18 + case `internal` = 19 + case `let` = 20 + case `operator` = 21 + case `private` = 22 + case `protocol` = 23 + case `public` = 24 + case `static` = 25 + case `struct` = 26 + case `subscript` = 27 + case `typealias` = 28 + case `var` = 29 + case `break` = 30 + case `case` = 31 + case `continue` = 32 + case `default` = 33 + case `defer` = 34 + case `do` = 35 + case `else` = 36 + case `fallthrough` = 37 + case `for` = 38 + case `guard` = 39 + case `if` = 40 + case `in` = 41 + case `repeat` = 42 + case `return` = 43 + case `switch` = 44 + case `where` = 45 + case `while` = 46 + case `as` = 47 + case `catch` = 48 + case dynamicType_ = 49 + case `false` = 50 + case `is` = 51 + case `nil` = 52 + case `rethrows` = 53 + case `super` = 54 + case self_ = 55 + case `throw` = 57 + case `throws` = 58 + case `true` = 59 + case `try` = 60 + case _Column__ = 61 + case _File__ = 62 + case _Function__ = 63 + case _Line__ = 64 + case ___ = 65 + case `associativity` = 66 + case convenience = 67 + case dynamic = 68 + case didSet = 69 + case final = 70 + case get = 71 + case infix = 72 + case indirect = 73 + case lazy = 74 + case left = 75 + case mutating = 76 + case none = 77 + case nonmutating = 78 + case `optional` = 79 + case override = 80 + case postfix = 81 + case precedence = 82 + case prefix = 83 + case `required` = 85 + case right = 86 + case set = 87 + case type = 88 + case unowned = 89 + case weak = 90 + case willSet = 91 /// id = 92; - case cmd // = 93 - case out // = 96 - case bycopy // = 98 - case byref // = 99 - case oneway // = 100 - case and // = 102 - case andEq // = 103 - case alignas // = 104 - case alignof // = 105 - case asm // = 106 - case auto // = 107 - case bitand // = 108 - case bitor // = 109 - case bool // = 110 - case char // = 114 - case char16T // = 115 - case char32T // = 116 - case compl // = 118 - case const // = 119 - case constexpr // = 120 - case constCast // = 121 - case decltype // = 123 - case delete // = 125 - case dynamicCast // = 127 - case explicit // = 130 - case export // = 131 - case extern // = 132 - case friend // = 136 - case goto // = 137 - case inline // = 139 - case long // = 141 - case mutable // = 142 - case namespace // = 143 - case new // = 144 - case noexcept // = 145 - case not // = 146 - case notEq // = 147 - case nullptr // = 148 - case or // = 150 - case orEq // = 151 - case protected // = 153 - case register // = 155 - case reinterpretCast // = 156 - case short // = 158 - case signed // = 159 - case sizeof // = 160 - case staticAssert // = 162 - case staticCast // = 163 - case template // = 166 - case this // = 167 - case threadLocal // = 168 - case typedef // = 172 - case typeid // = 173 - case typename // = 174 - case union // = 175 - case unsigned // = 176 - case using // = 177 - case virtual // = 178 - case void // = 179 - case volatile // = 180 - case wcharT // = 181 - case xor // = 183 - case xorEq // = 184 - case restrict // = 185 - case category // = 186 - case ivar // = 187 - case method // = 188 - case finalize // = 192 - case hash // = 193 - case dealloc // = 194 - case superclass // = 197 - case retain // = 198 - case release // = 199 - case autorelease // = 200 - case retainCount // = 201 - case zone // = 202 - case isProxy // = 203 - case copy // = 204 - case mutableCopy // = 205 - case classForCoder // = 206 - case clear // = 207 - case data // = 208 - case delimitedData // = 209 - case descriptor // = 210 - case extensionRegistry // = 211 - case extensionsCurrentlySet // = 212 - case isInitialized // = 213 - case serializedSize // = 214 - case sortedExtensionsInUse // = 215 - case unknownFields // = 216 - case fixed // = 217 - case fract // = 218 - case size // = 219 - case logicalAddress // = 220 - case physicalAddress // = 221 - case byteCount // = 222 - case byteOffset // = 223 - case duration // = 224 - case absoluteTime // = 225 - case optionBits // = 226 - case itemCount // = 227 - case pbversion // = 228 - case scriptCode // = 229 - case langCode // = 230 - case regionCode // = 231 - case ostype // = 232 - case processSerialNumber // = 233 - case point // = 234 - case rect // = 235 - case fixedPoint // = 236 - case fixedRect // = 237 - case style // = 238 - case styleParameter // = 239 - case styleField // = 240 - case timeScale // = 241 - case timeBase // = 242 - case timeRecord // = 243 - case extensions // = 244 + case cmd = 93 + case out = 96 + case bycopy = 98 + case byref = 99 + case oneway = 100 + case and = 102 + case andEq = 103 + case alignas = 104 + case alignof = 105 + case asm = 106 + case auto = 107 + case bitand = 108 + case bitor = 109 + case bool = 110 + case char = 114 + case char16T = 115 + case char32T = 116 + case compl = 118 + case const = 119 + case constexpr = 120 + case constCast = 121 + case decltype = 123 + case delete = 125 + case dynamicCast = 127 + case explicit = 130 + case export = 131 + case extern = 132 + case friend = 136 + case goto = 137 + case inline = 139 + case long = 141 + case mutable = 142 + case namespace = 143 + case new = 144 + case noexcept = 145 + case not = 146 + case notEq = 147 + case nullptr = 148 + case or = 150 + case orEq = 151 + case protected = 153 + case register = 155 + case reinterpretCast = 156 + case short = 158 + case signed = 159 + case sizeof = 160 + case staticAssert = 162 + case staticCast = 163 + case template = 166 + case this = 167 + case threadLocal = 168 + case typedef = 172 + case typeid = 173 + case typename = 174 + case union = 175 + case unsigned = 176 + case using = 177 + case virtual = 178 + case void = 179 + case volatile = 180 + case wcharT = 181 + case xor = 183 + case xorEq = 184 + case restrict = 185 + case category = 186 + case ivar = 187 + case method = 188 + case finalize = 192 + case hash = 193 + case dealloc = 194 + case superclass = 197 + case retain = 198 + case release = 199 + case autorelease = 200 + case retainCount = 201 + case zone = 202 + case isProxy = 203 + case copy = 204 + case mutableCopy = 205 + case classForCoder = 206 + case clear = 207 + case data = 208 + case delimitedData = 209 + case descriptor = 210 + case extensionRegistry = 211 + case extensionsCurrentlySet = 212 + case isInitialized = 213 + case serializedSize = 214 + case sortedExtensionsInUse = 215 + case unknownFields = 216 + case fixed = 217 + case fract = 218 + case size = 219 + case logicalAddress = 220 + case physicalAddress = 221 + case byteCount = 222 + case byteOffset = 223 + case duration = 224 + case absoluteTime = 225 + case optionBits = 226 + case itemCount = 227 + case pbversion = 228 + case scriptCode = 229 + case langCode = 230 + case regionCode = 231 + case ostype = 232 + case processSerialNumber = 233 + case point = 234 + case rect = 235 + case fixedPoint = 236 + case fixedRect = 237 + case style = 238 + case styleParameter = 239 + case styleField = 240 + case timeScale = 241 + case timeBase = 242 + case timeRecord = 243 + case extensions = 244 init() { self = .a } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .a - case 1: self = .string - case 2: self = .int - case 3: self = .double - case 4: self = .float - case 5: self = .uint - case 6: self = .hashValue_ - case 7: self = .description_ - case 8: self = .debugDescription_ - case 9: self = .swift - case 10: self = .unrecognized - case 11: self = .class - case 12: self = .deinit - case 13: self = .enum - case 14: self = .extension - case 15: self = .func - case 16: self = .import - case 17: self = .init_ - case 18: self = .inout - case 19: self = .internal - case 20: self = .let - case 21: self = .operator - case 22: self = .private - case 23: self = .protocol - case 24: self = .public - case 25: self = .static - case 26: self = .struct - case 27: self = .subscript - case 28: self = .typealias - case 29: self = .var - case 30: self = .break - case 31: self = .case - case 32: self = .continue - case 33: self = .default - case 34: self = .defer - case 35: self = .do - case 36: self = .else - case 37: self = .fallthrough - case 38: self = .for - case 39: self = .guard - case 40: self = .if - case 41: self = .in - case 42: self = .repeat - case 43: self = .return - case 44: self = .switch - case 45: self = .where - case 46: self = .while - case 47: self = .as - case 48: self = .catch - case 49: self = .dynamicType_ - case 50: self = .false - case 51: self = .is - case 52: self = .nil - case 53: self = .rethrows - case 54: self = .super - case 55: self = .self_ - case 57: self = .throw - case 58: self = .throws - case 59: self = .true - case 60: self = .try - case 61: self = ._Column__ - case 62: self = ._File__ - case 63: self = ._Function__ - case 64: self = ._Line__ - case 65: self = .___ - case 66: self = .associativity - case 67: self = .convenience - case 68: self = .dynamic - case 69: self = .didSet - case 70: self = .final - case 71: self = .get - case 72: self = .infix - case 73: self = .indirect - case 74: self = .lazy - case 75: self = .left - case 76: self = .mutating - case 77: self = .none - case 78: self = .nonmutating - case 79: self = .optional - case 80: self = .override - case 81: self = .postfix - case 82: self = .precedence - case 83: self = .prefix - case 85: self = .required - case 86: self = .right - case 87: self = .set - case 88: self = .type - case 89: self = .unowned - case 90: self = .weak - case 91: self = .willSet - case 93: self = .cmd - case 96: self = .out - case 98: self = .bycopy - case 99: self = .byref - case 100: self = .oneway - case 102: self = .and - case 103: self = .andEq - case 104: self = .alignas - case 105: self = .alignof - case 106: self = .asm - case 107: self = .auto - case 108: self = .bitand - case 109: self = .bitor - case 110: self = .bool - case 114: self = .char - case 115: self = .char16T - case 116: self = .char32T - case 118: self = .compl - case 119: self = .const - case 120: self = .constexpr - case 121: self = .constCast - case 123: self = .decltype - case 125: self = .delete - case 127: self = .dynamicCast - case 130: self = .explicit - case 131: self = .export - case 132: self = .extern - case 136: self = .friend - case 137: self = .goto - case 139: self = .inline - case 141: self = .long - case 142: self = .mutable - case 143: self = .namespace - case 144: self = .new - case 145: self = .noexcept - case 146: self = .not - case 147: self = .notEq - case 148: self = .nullptr - case 150: self = .or - case 151: self = .orEq - case 153: self = .protected - case 155: self = .register - case 156: self = .reinterpretCast - case 158: self = .short - case 159: self = .signed - case 160: self = .sizeof - case 162: self = .staticAssert - case 163: self = .staticCast - case 166: self = .template - case 167: self = .this - case 168: self = .threadLocal - case 172: self = .typedef - case 173: self = .typeid - case 174: self = .typename - case 175: self = .union - case 176: self = .unsigned - case 177: self = .using - case 178: self = .virtual - case 179: self = .void - case 180: self = .volatile - case 181: self = .wcharT - case 183: self = .xor - case 184: self = .xorEq - case 185: self = .restrict - case 186: self = .category - case 187: self = .ivar - case 188: self = .method - case 192: self = .finalize - case 193: self = .hash - case 194: self = .dealloc - case 197: self = .superclass - case 198: self = .retain - case 199: self = .release - case 200: self = .autorelease - case 201: self = .retainCount - case 202: self = .zone - case 203: self = .isProxy - case 204: self = .copy - case 205: self = .mutableCopy - case 206: self = .classForCoder - case 207: self = .clear - case 208: self = .data - case 209: self = .delimitedData - case 210: self = .descriptor - case 211: self = .extensionRegistry - case 212: self = .extensionsCurrentlySet - case 213: self = .isInitialized - case 214: self = .serializedSize - case 215: self = .sortedExtensionsInUse - case 216: self = .unknownFields - case 217: self = .fixed - case 218: self = .fract - case 219: self = .size - case 220: self = .logicalAddress - case 221: self = .physicalAddress - case 222: self = .byteCount - case 223: self = .byteOffset - case 224: self = .duration - case 225: self = .absoluteTime - case 226: self = .optionBits - case 227: self = .itemCount - case 228: self = .pbversion - case 229: self = .scriptCode - case 230: self = .langCode - case 231: self = .regionCode - case 232: self = .ostype - case 233: self = .processSerialNumber - case 234: self = .point - case 235: self = .rect - case 236: self = .fixedPoint - case 237: self = .fixedRect - case 238: self = .style - case 239: self = .styleParameter - case 240: self = .styleField - case 241: self = .timeScale - case 242: self = .timeBase - case 243: self = .timeRecord - case 244: self = .extensions - default: return nil - } - } - - var rawValue: Int { - switch self { - case .a: return 0 - case .string: return 1 - case .int: return 2 - case .double: return 3 - case .float: return 4 - case .uint: return 5 - case .hashValue_: return 6 - case .description_: return 7 - case .debugDescription_: return 8 - case .swift: return 9 - case .unrecognized: return 10 - case .class: return 11 - case .deinit: return 12 - case .enum: return 13 - case .extension: return 14 - case .func: return 15 - case .import: return 16 - case .init_: return 17 - case .inout: return 18 - case .internal: return 19 - case .let: return 20 - case .operator: return 21 - case .private: return 22 - case .protocol: return 23 - case .public: return 24 - case .static: return 25 - case .struct: return 26 - case .subscript: return 27 - case .typealias: return 28 - case .var: return 29 - case .break: return 30 - case .case: return 31 - case .continue: return 32 - case .default: return 33 - case .defer: return 34 - case .do: return 35 - case .else: return 36 - case .fallthrough: return 37 - case .for: return 38 - case .guard: return 39 - case .if: return 40 - case .in: return 41 - case .repeat: return 42 - case .return: return 43 - case .switch: return 44 - case .where: return 45 - case .while: return 46 - case .as: return 47 - case .catch: return 48 - case .dynamicType_: return 49 - case .false: return 50 - case .is: return 51 - case .nil: return 52 - case .rethrows: return 53 - case .super: return 54 - case .self_: return 55 - case .throw: return 57 - case .throws: return 58 - case .true: return 59 - case .try: return 60 - case ._Column__: return 61 - case ._File__: return 62 - case ._Function__: return 63 - case ._Line__: return 64 - case .___: return 65 - case .associativity: return 66 - case .convenience: return 67 - case .dynamic: return 68 - case .didSet: return 69 - case .final: return 70 - case .get: return 71 - case .infix: return 72 - case .indirect: return 73 - case .lazy: return 74 - case .left: return 75 - case .mutating: return 76 - case .none: return 77 - case .nonmutating: return 78 - case .optional: return 79 - case .override: return 80 - case .postfix: return 81 - case .precedence: return 82 - case .prefix: return 83 - case .required: return 85 - case .right: return 86 - case .set: return 87 - case .type: return 88 - case .unowned: return 89 - case .weak: return 90 - case .willSet: return 91 - case .cmd: return 93 - case .out: return 96 - case .bycopy: return 98 - case .byref: return 99 - case .oneway: return 100 - case .and: return 102 - case .andEq: return 103 - case .alignas: return 104 - case .alignof: return 105 - case .asm: return 106 - case .auto: return 107 - case .bitand: return 108 - case .bitor: return 109 - case .bool: return 110 - case .char: return 114 - case .char16T: return 115 - case .char32T: return 116 - case .compl: return 118 - case .const: return 119 - case .constexpr: return 120 - case .constCast: return 121 - case .decltype: return 123 - case .delete: return 125 - case .dynamicCast: return 127 - case .explicit: return 130 - case .export: return 131 - case .extern: return 132 - case .friend: return 136 - case .goto: return 137 - case .inline: return 139 - case .long: return 141 - case .mutable: return 142 - case .namespace: return 143 - case .new: return 144 - case .noexcept: return 145 - case .not: return 146 - case .notEq: return 147 - case .nullptr: return 148 - case .or: return 150 - case .orEq: return 151 - case .protected: return 153 - case .register: return 155 - case .reinterpretCast: return 156 - case .short: return 158 - case .signed: return 159 - case .sizeof: return 160 - case .staticAssert: return 162 - case .staticCast: return 163 - case .template: return 166 - case .this: return 167 - case .threadLocal: return 168 - case .typedef: return 172 - case .typeid: return 173 - case .typename: return 174 - case .union: return 175 - case .unsigned: return 176 - case .using: return 177 - case .virtual: return 178 - case .void: return 179 - case .volatile: return 180 - case .wcharT: return 181 - case .xor: return 183 - case .xorEq: return 184 - case .restrict: return 185 - case .category: return 186 - case .ivar: return 187 - case .method: return 188 - case .finalize: return 192 - case .hash: return 193 - case .dealloc: return 194 - case .superclass: return 197 - case .retain: return 198 - case .release: return 199 - case .autorelease: return 200 - case .retainCount: return 201 - case .zone: return 202 - case .isProxy: return 203 - case .copy: return 204 - case .mutableCopy: return 205 - case .classForCoder: return 206 - case .clear: return 207 - case .data: return 208 - case .delimitedData: return 209 - case .descriptor: return 210 - case .extensionRegistry: return 211 - case .extensionsCurrentlySet: return 212 - case .isInitialized: return 213 - case .serializedSize: return 214 - case .sortedExtensionsInUse: return 215 - case .unknownFields: return 216 - case .fixed: return 217 - case .fract: return 218 - case .size: return 219 - case .logicalAddress: return 220 - case .physicalAddress: return 221 - case .byteCount: return 222 - case .byteOffset: return 223 - case .duration: return 224 - case .absoluteTime: return 225 - case .optionBits: return 226 - case .itemCount: return 227 - case .pbversion: return 228 - case .scriptCode: return 229 - case .langCode: return 230 - case .regionCode: return 231 - case .ostype: return 232 - case .processSerialNumber: return 233 - case .point: return 234 - case .rect: return 235 - case .fixedPoint: return 236 - case .fixedRect: return 237 - case .style: return 238 - case .styleParameter: return 239 - case .styleField: return 240 - case .timeScale: return 241 - case .timeBase: return 242 - case .timeRecord: return 243 - case .extensions: return 244 - } - } - -} - -#if swift(>=4.2) - -extension SwiftUnittest_Names_EnumFieldNames: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -enum SwiftUnittest_Names_EnumFieldNames2: SwiftProtobuf.Enum { - typealias RawValue = Int - case aa // = 0 +} + +enum SwiftProtoTesting_Names_EnumFieldNames2: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aa = 0 /// protoc no longer allows enum naming that would differ only in underscores. /// Initial commit: @@ -703,38 +266,15 @@ enum SwiftUnittest_Names_EnumFieldNames2: SwiftProtobuf.Enum { /// https://github.com/protocolbuffers/protobuf/pull/2204 /// So this is in a second enum so it won't cause issues with the '_' one; /// but still ensure things generator correctly. - case ____ // = 1065 + case ____ = 1065 init() { self = .aa } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aa - case 1065: self = .____ - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aa: return 0 - case .____: return 1065 - } - } - } -#if swift(>=4.2) - -extension SwiftUnittest_Names_EnumFieldNames2: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct SwiftUnittest_Names_Foo: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Names_Foo: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -746,2006 +286,2006 @@ struct SwiftUnittest_Names_Foo: SwiftProtobuf.ExtensibleMessage { var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct SwiftUnittest_Names_FieldNames { +struct SwiftProtoTesting_Names_FieldNames: @unchecked Sendable { // 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 string: Int32 { - get {return _storage._string ?? 0} + get {_storage._string ?? 0} set {_uniqueStorage()._string = newValue} } /// Returns true if `string` has been explicitly set. - var hasString: Bool {return _storage._string != nil} + var hasString: Bool {_storage._string != nil} /// Clears the value of `string`. Subsequent reads from it will return its default value. mutating func clearString() {_uniqueStorage()._string = nil} var int: Int32 { - get {return _storage._int ?? 0} + get {_storage._int ?? 0} set {_uniqueStorage()._int = newValue} } /// Returns true if `int` has been explicitly set. - var hasInt: Bool {return _storage._int != nil} + var hasInt: Bool {_storage._int != nil} /// Clears the value of `int`. Subsequent reads from it will return its default value. mutating func clearInt() {_uniqueStorage()._int = nil} var double: Int32 { - get {return _storage._double ?? 0} + get {_storage._double ?? 0} set {_uniqueStorage()._double = newValue} } /// Returns true if `double` has been explicitly set. - var hasDouble: Bool {return _storage._double != nil} + var hasDouble: Bool {_storage._double != nil} /// Clears the value of `double`. Subsequent reads from it will return its default value. mutating func clearDouble() {_uniqueStorage()._double = nil} var float: Int32 { - get {return _storage._float ?? 0} + get {_storage._float ?? 0} set {_uniqueStorage()._float = newValue} } /// Returns true if `float` has been explicitly set. - var hasFloat: Bool {return _storage._float != nil} + var hasFloat: Bool {_storage._float != nil} /// Clears the value of `float`. Subsequent reads from it will return its default value. mutating func clearFloat() {_uniqueStorage()._float = nil} var uint: Int32 { - get {return _storage._uint ?? 0} + get {_storage._uint ?? 0} set {_uniqueStorage()._uint = newValue} } /// Returns true if `uint` has been explicitly set. - var hasUint: Bool {return _storage._uint != nil} + var hasUint: Bool {_storage._uint != nil} /// Clears the value of `uint`. Subsequent reads from it will return its default value. mutating func clearUint() {_uniqueStorage()._uint = nil} var hashValue_p: Int32 { - get {return _storage._hashValue_p ?? 0} + get {_storage._hashValue_p ?? 0} set {_uniqueStorage()._hashValue_p = newValue} } /// Returns true if `hashValue_p` has been explicitly set. - var hasHashValue_p: Bool {return _storage._hashValue_p != nil} + var hasHashValue_p: Bool {_storage._hashValue_p != nil} /// Clears the value of `hashValue_p`. Subsequent reads from it will return its default value. mutating func clearHashValue_p() {_uniqueStorage()._hashValue_p = nil} var description_p: Int32 { - get {return _storage._description_p ?? 0} + get {_storage._description_p ?? 0} set {_uniqueStorage()._description_p = newValue} } /// Returns true if `description_p` has been explicitly set. - var hasDescription_p: Bool {return _storage._description_p != nil} + var hasDescription_p: Bool {_storage._description_p != nil} /// Clears the value of `description_p`. Subsequent reads from it will return its default value. mutating func clearDescription_p() {_uniqueStorage()._description_p = nil} var debugDescription_p: Int32 { - get {return _storage._debugDescription_p ?? 0} + get {_storage._debugDescription_p ?? 0} set {_uniqueStorage()._debugDescription_p = newValue} } /// Returns true if `debugDescription_p` has been explicitly set. - var hasDebugDescription_p: Bool {return _storage._debugDescription_p != nil} + var hasDebugDescription_p: Bool {_storage._debugDescription_p != nil} /// Clears the value of `debugDescription_p`. Subsequent reads from it will return its default value. mutating func clearDebugDescription_p() {_uniqueStorage()._debugDescription_p = nil} var swift: Int32 { - get {return _storage._swift ?? 0} + get {_storage._swift ?? 0} set {_uniqueStorage()._swift = newValue} } /// Returns true if `swift` has been explicitly set. - var hasSwift: Bool {return _storage._swift != nil} + var hasSwift: Bool {_storage._swift != nil} /// Clears the value of `swift`. Subsequent reads from it will return its default value. mutating func clearSwift() {_uniqueStorage()._swift = nil} var unrecognized: Int32 { - get {return _storage._unrecognized ?? 0} + get {_storage._unrecognized ?? 0} set {_uniqueStorage()._unrecognized = newValue} } /// Returns true if `unrecognized` has been explicitly set. - var hasUnrecognized: Bool {return _storage._unrecognized != nil} + var hasUnrecognized: Bool {_storage._unrecognized != nil} /// Clears the value of `unrecognized`. Subsequent reads from it will return its default value. mutating func clearUnrecognized() {_uniqueStorage()._unrecognized = nil} var `class`: Int32 { - get {return _storage._class ?? 0} + get {_storage._class ?? 0} set {_uniqueStorage()._class = newValue} } /// Returns true if ``class`` has been explicitly set. - var hasClass: Bool {return _storage._class != nil} + var hasClass: Bool {_storage._class != nil} /// Clears the value of ``class``. Subsequent reads from it will return its default value. mutating func clearClass() {_uniqueStorage()._class = nil} var `deinit`: Int32 { - get {return _storage._deinit ?? 0} + get {_storage._deinit ?? 0} set {_uniqueStorage()._deinit = newValue} } /// Returns true if ``deinit`` has been explicitly set. - var hasDeinit: Bool {return _storage._deinit != nil} + var hasDeinit: Bool {_storage._deinit != nil} /// Clears the value of ``deinit``. Subsequent reads from it will return its default value. mutating func clearDeinit() {_uniqueStorage()._deinit = nil} var `enum`: Int32 { - get {return _storage._enum ?? 0} + get {_storage._enum ?? 0} set {_uniqueStorage()._enum = newValue} } /// Returns true if ``enum`` has been explicitly set. - var hasEnum: Bool {return _storage._enum != nil} + var hasEnum: Bool {_storage._enum != nil} /// Clears the value of ``enum``. Subsequent reads from it will return its default value. mutating func clearEnum() {_uniqueStorage()._enum = nil} var `func`: Int32 { - get {return _storage._func ?? 0} + get {_storage._func ?? 0} set {_uniqueStorage()._func = newValue} } /// Returns true if ``func`` has been explicitly set. - var hasFunc: Bool {return _storage._func != nil} + var hasFunc: Bool {_storage._func != nil} /// Clears the value of ``func``. Subsequent reads from it will return its default value. mutating func clearFunc() {_uniqueStorage()._func = nil} var `import`: Int32 { - get {return _storage._import ?? 0} + get {_storage._import ?? 0} set {_uniqueStorage()._import = newValue} } /// Returns true if ``import`` has been explicitly set. - var hasImport: Bool {return _storage._import != nil} + var hasImport: Bool {_storage._import != nil} /// Clears the value of ``import``. Subsequent reads from it will return its default value. mutating func clearImport() {_uniqueStorage()._import = nil} var init_p: Int32 { - get {return _storage._init_p ?? 0} + get {_storage._init_p ?? 0} set {_uniqueStorage()._init_p = newValue} } /// Returns true if `init_p` has been explicitly set. - var hasInit_p: Bool {return _storage._init_p != nil} + var hasInit_p: Bool {_storage._init_p != nil} /// Clears the value of `init_p`. Subsequent reads from it will return its default value. mutating func clearInit_p() {_uniqueStorage()._init_p = nil} var `inout`: Int32 { - get {return _storage._inout ?? 0} + get {_storage._inout ?? 0} set {_uniqueStorage()._inout = newValue} } /// Returns true if ``inout`` has been explicitly set. - var hasInout: Bool {return _storage._inout != nil} + var hasInout: Bool {_storage._inout != nil} /// Clears the value of ``inout``. Subsequent reads from it will return its default value. mutating func clearInout() {_uniqueStorage()._inout = nil} var `internal`: Int32 { - get {return _storage._internal ?? 0} + get {_storage._internal ?? 0} set {_uniqueStorage()._internal = newValue} } /// Returns true if ``internal`` has been explicitly set. - var hasInternal: Bool {return _storage._internal != nil} + var hasInternal: Bool {_storage._internal != nil} /// Clears the value of ``internal``. Subsequent reads from it will return its default value. mutating func clearInternal() {_uniqueStorage()._internal = nil} var `let`: Int32 { - get {return _storage._let ?? 0} + get {_storage._let ?? 0} set {_uniqueStorage()._let = newValue} } /// Returns true if ``let`` has been explicitly set. - var hasLet: Bool {return _storage._let != nil} + var hasLet: Bool {_storage._let != nil} /// Clears the value of ``let``. Subsequent reads from it will return its default value. mutating func clearLet() {_uniqueStorage()._let = nil} var `operator`: Int32 { - get {return _storage._operator ?? 0} + get {_storage._operator ?? 0} set {_uniqueStorage()._operator = newValue} } /// Returns true if ``operator`` has been explicitly set. - var hasOperator: Bool {return _storage._operator != nil} + var hasOperator: Bool {_storage._operator != nil} /// Clears the value of ``operator``. Subsequent reads from it will return its default value. mutating func clearOperator() {_uniqueStorage()._operator = nil} var `private`: Int32 { - get {return _storage._private ?? 0} + get {_storage._private ?? 0} set {_uniqueStorage()._private = newValue} } /// Returns true if ``private`` has been explicitly set. - var hasPrivate: Bool {return _storage._private != nil} + var hasPrivate: Bool {_storage._private != nil} /// Clears the value of ``private``. Subsequent reads from it will return its default value. mutating func clearPrivate() {_uniqueStorage()._private = nil} var `protocol`: Int32 { - get {return _storage._protocol ?? 0} + get {_storage._protocol ?? 0} set {_uniqueStorage()._protocol = newValue} } /// Returns true if ``protocol`` has been explicitly set. - var hasProtocol: Bool {return _storage._protocol != nil} + var hasProtocol: Bool {_storage._protocol != nil} /// Clears the value of ``protocol``. Subsequent reads from it will return its default value. mutating func clearProtocol() {_uniqueStorage()._protocol = nil} var `public`: Int32 { - get {return _storage._public ?? 0} + get {_storage._public ?? 0} set {_uniqueStorage()._public = newValue} } /// Returns true if ``public`` has been explicitly set. - var hasPublic: Bool {return _storage._public != nil} + var hasPublic: Bool {_storage._public != nil} /// Clears the value of ``public``. Subsequent reads from it will return its default value. mutating func clearPublic() {_uniqueStorage()._public = nil} var `static`: Int32 { - get {return _storage._static ?? 0} + get {_storage._static ?? 0} set {_uniqueStorage()._static = newValue} } /// Returns true if ``static`` has been explicitly set. - var hasStatic: Bool {return _storage._static != nil} + var hasStatic: Bool {_storage._static != nil} /// Clears the value of ``static``. Subsequent reads from it will return its default value. mutating func clearStatic() {_uniqueStorage()._static = nil} var `struct`: Int32 { - get {return _storage._struct ?? 0} + get {_storage._struct ?? 0} set {_uniqueStorage()._struct = newValue} } /// Returns true if ``struct`` has been explicitly set. - var hasStruct: Bool {return _storage._struct != nil} + var hasStruct: Bool {_storage._struct != nil} /// Clears the value of ``struct``. Subsequent reads from it will return its default value. mutating func clearStruct() {_uniqueStorage()._struct = nil} var `subscript`: Int32 { - get {return _storage._subscript ?? 0} + get {_storage._subscript ?? 0} set {_uniqueStorage()._subscript = newValue} } /// Returns true if ``subscript`` has been explicitly set. - var hasSubscript: Bool {return _storage._subscript != nil} + var hasSubscript: Bool {_storage._subscript != nil} /// Clears the value of ``subscript``. Subsequent reads from it will return its default value. mutating func clearSubscript() {_uniqueStorage()._subscript = nil} var `typealias`: Int32 { - get {return _storage._typealias ?? 0} + get {_storage._typealias ?? 0} set {_uniqueStorage()._typealias = newValue} } /// Returns true if ``typealias`` has been explicitly set. - var hasTypealias: Bool {return _storage._typealias != nil} + var hasTypealias: Bool {_storage._typealias != nil} /// Clears the value of ``typealias``. Subsequent reads from it will return its default value. mutating func clearTypealias() {_uniqueStorage()._typealias = nil} var `var`: Int32 { - get {return _storage._var ?? 0} + get {_storage._var ?? 0} set {_uniqueStorage()._var = newValue} } /// Returns true if ``var`` has been explicitly set. - var hasVar: Bool {return _storage._var != nil} + var hasVar: Bool {_storage._var != nil} /// Clears the value of ``var``. Subsequent reads from it will return its default value. mutating func clearVar() {_uniqueStorage()._var = nil} var `break`: Int32 { - get {return _storage._break ?? 0} + get {_storage._break ?? 0} set {_uniqueStorage()._break = newValue} } /// Returns true if ``break`` has been explicitly set. - var hasBreak: Bool {return _storage._break != nil} + var hasBreak: Bool {_storage._break != nil} /// Clears the value of ``break``. Subsequent reads from it will return its default value. mutating func clearBreak() {_uniqueStorage()._break = nil} var `case`: Int32 { - get {return _storage._case ?? 0} + get {_storage._case ?? 0} set {_uniqueStorage()._case = newValue} } /// Returns true if ``case`` has been explicitly set. - var hasCase: Bool {return _storage._case != nil} + var hasCase: Bool {_storage._case != nil} /// Clears the value of ``case``. Subsequent reads from it will return its default value. mutating func clearCase() {_uniqueStorage()._case = nil} var `continue`: Int32 { - get {return _storage._continue ?? 0} + get {_storage._continue ?? 0} set {_uniqueStorage()._continue = newValue} } /// Returns true if ``continue`` has been explicitly set. - var hasContinue: Bool {return _storage._continue != nil} + var hasContinue: Bool {_storage._continue != nil} /// Clears the value of ``continue``. Subsequent reads from it will return its default value. mutating func clearContinue() {_uniqueStorage()._continue = nil} var `default`: Int32 { - get {return _storage._default ?? 0} + get {_storage._default ?? 0} set {_uniqueStorage()._default = newValue} } /// Returns true if ``default`` has been explicitly set. - var hasDefault: Bool {return _storage._default != nil} + var hasDefault: Bool {_storage._default != nil} /// Clears the value of ``default``. Subsequent reads from it will return its default value. mutating func clearDefault() {_uniqueStorage()._default = nil} var `defer`: Int32 { - get {return _storage._defer ?? 0} + get {_storage._defer ?? 0} set {_uniqueStorage()._defer = newValue} } /// Returns true if ``defer`` has been explicitly set. - var hasDefer: Bool {return _storage._defer != nil} + var hasDefer: Bool {_storage._defer != nil} /// Clears the value of ``defer``. Subsequent reads from it will return its default value. mutating func clearDefer() {_uniqueStorage()._defer = nil} var `do`: Int32 { - get {return _storage._do ?? 0} + get {_storage._do ?? 0} set {_uniqueStorage()._do = newValue} } /// Returns true if ``do`` has been explicitly set. - var hasDo: Bool {return _storage._do != nil} + var hasDo: Bool {_storage._do != nil} /// Clears the value of ``do``. Subsequent reads from it will return its default value. mutating func clearDo() {_uniqueStorage()._do = nil} var `else`: Int32 { - get {return _storage._else ?? 0} + get {_storage._else ?? 0} set {_uniqueStorage()._else = newValue} } /// Returns true if ``else`` has been explicitly set. - var hasElse: Bool {return _storage._else != nil} + var hasElse: Bool {_storage._else != nil} /// Clears the value of ``else``. Subsequent reads from it will return its default value. mutating func clearElse() {_uniqueStorage()._else = nil} var `fallthrough`: Int32 { - get {return _storage._fallthrough ?? 0} + get {_storage._fallthrough ?? 0} set {_uniqueStorage()._fallthrough = newValue} } /// Returns true if ``fallthrough`` has been explicitly set. - var hasFallthrough: Bool {return _storage._fallthrough != nil} + var hasFallthrough: Bool {_storage._fallthrough != nil} /// Clears the value of ``fallthrough``. Subsequent reads from it will return its default value. mutating func clearFallthrough() {_uniqueStorage()._fallthrough = nil} var `for`: Int32 { - get {return _storage._for ?? 0} + get {_storage._for ?? 0} set {_uniqueStorage()._for = newValue} } /// Returns true if ``for`` has been explicitly set. - var hasFor: Bool {return _storage._for != nil} + var hasFor: Bool {_storage._for != nil} /// Clears the value of ``for``. Subsequent reads from it will return its default value. mutating func clearFor() {_uniqueStorage()._for = nil} var `guard`: Int32 { - get {return _storage._guard ?? 0} + get {_storage._guard ?? 0} set {_uniqueStorage()._guard = newValue} } /// Returns true if ``guard`` has been explicitly set. - var hasGuard: Bool {return _storage._guard != nil} + var hasGuard: Bool {_storage._guard != nil} /// Clears the value of ``guard``. Subsequent reads from it will return its default value. mutating func clearGuard() {_uniqueStorage()._guard = nil} var `if`: Int32 { - get {return _storage._if ?? 0} + get {_storage._if ?? 0} set {_uniqueStorage()._if = newValue} } /// Returns true if ``if`` has been explicitly set. - var hasIf: Bool {return _storage._if != nil} + var hasIf: Bool {_storage._if != nil} /// Clears the value of ``if``. Subsequent reads from it will return its default value. mutating func clearIf() {_uniqueStorage()._if = nil} var `in`: Int32 { - get {return _storage._in ?? 0} + get {_storage._in ?? 0} set {_uniqueStorage()._in = newValue} } /// Returns true if ``in`` has been explicitly set. - var hasIn: Bool {return _storage._in != nil} + var hasIn: Bool {_storage._in != nil} /// Clears the value of ``in``. Subsequent reads from it will return its default value. mutating func clearIn() {_uniqueStorage()._in = nil} var `repeat`: Int32 { - get {return _storage._repeat ?? 0} + get {_storage._repeat ?? 0} set {_uniqueStorage()._repeat = newValue} } /// Returns true if ``repeat`` has been explicitly set. - var hasRepeat: Bool {return _storage._repeat != nil} + var hasRepeat: Bool {_storage._repeat != nil} /// Clears the value of ``repeat``. Subsequent reads from it will return its default value. mutating func clearRepeat() {_uniqueStorage()._repeat = nil} var `return`: Int32 { - get {return _storage._return ?? 0} + get {_storage._return ?? 0} set {_uniqueStorage()._return = newValue} } /// Returns true if ``return`` has been explicitly set. - var hasReturn: Bool {return _storage._return != nil} + var hasReturn: Bool {_storage._return != nil} /// Clears the value of ``return``. Subsequent reads from it will return its default value. mutating func clearReturn() {_uniqueStorage()._return = nil} var `switch`: Int32 { - get {return _storage._switch ?? 0} + get {_storage._switch ?? 0} set {_uniqueStorage()._switch = newValue} } /// Returns true if ``switch`` has been explicitly set. - var hasSwitch: Bool {return _storage._switch != nil} + var hasSwitch: Bool {_storage._switch != nil} /// Clears the value of ``switch``. Subsequent reads from it will return its default value. mutating func clearSwitch() {_uniqueStorage()._switch = nil} var `where`: Int32 { - get {return _storage._where ?? 0} + get {_storage._where ?? 0} set {_uniqueStorage()._where = newValue} } /// Returns true if ``where`` has been explicitly set. - var hasWhere: Bool {return _storage._where != nil} + var hasWhere: Bool {_storage._where != nil} /// Clears the value of ``where``. Subsequent reads from it will return its default value. mutating func clearWhere() {_uniqueStorage()._where = nil} var `while`: Int32 { - get {return _storage._while ?? 0} + get {_storage._while ?? 0} set {_uniqueStorage()._while = newValue} } /// Returns true if ``while`` has been explicitly set. - var hasWhile: Bool {return _storage._while != nil} + var hasWhile: Bool {_storage._while != nil} /// Clears the value of ``while``. Subsequent reads from it will return its default value. mutating func clearWhile() {_uniqueStorage()._while = nil} var `as`: Int32 { - get {return _storage._as ?? 0} + get {_storage._as ?? 0} set {_uniqueStorage()._as = newValue} } /// Returns true if ``as`` has been explicitly set. - var hasAs: Bool {return _storage._as != nil} + var hasAs: Bool {_storage._as != nil} /// Clears the value of ``as``. Subsequent reads from it will return its default value. mutating func clearAs() {_uniqueStorage()._as = nil} var `catch`: Int32 { - get {return _storage._catch ?? 0} + get {_storage._catch ?? 0} set {_uniqueStorage()._catch = newValue} } /// Returns true if ``catch`` has been explicitly set. - var hasCatch: Bool {return _storage._catch != nil} + var hasCatch: Bool {_storage._catch != nil} /// Clears the value of ``catch``. Subsequent reads from it will return its default value. mutating func clearCatch() {_uniqueStorage()._catch = nil} var dynamicType_p: Int32 { - get {return _storage._dynamicType_p ?? 0} + get {_storage._dynamicType_p ?? 0} set {_uniqueStorage()._dynamicType_p = newValue} } /// Returns true if `dynamicType_p` has been explicitly set. - var hasDynamicType_p: Bool {return _storage._dynamicType_p != nil} + var hasDynamicType_p: Bool {_storage._dynamicType_p != nil} /// Clears the value of `dynamicType_p`. Subsequent reads from it will return its default value. mutating func clearDynamicType_p() {_uniqueStorage()._dynamicType_p = nil} var `false`: Int32 { - get {return _storage._false ?? 0} + get {_storage._false ?? 0} set {_uniqueStorage()._false = newValue} } /// Returns true if ``false`` has been explicitly set. - var hasFalse: Bool {return _storage._false != nil} + var hasFalse: Bool {_storage._false != nil} /// Clears the value of ``false``. Subsequent reads from it will return its default value. mutating func clearFalse() {_uniqueStorage()._false = nil} var `is`: Int32 { - get {return _storage._is ?? 0} + get {_storage._is ?? 0} set {_uniqueStorage()._is = newValue} } /// Returns true if ``is`` has been explicitly set. - var hasIs: Bool {return _storage._is != nil} + var hasIs: Bool {_storage._is != nil} /// Clears the value of ``is``. Subsequent reads from it will return its default value. mutating func clearIs() {_uniqueStorage()._is = nil} var `nil`: Int32 { - get {return _storage._nil ?? 0} + get {_storage._nil ?? 0} set {_uniqueStorage()._nil = newValue} } /// Returns true if ``nil`` has been explicitly set. - var hasNil: Bool {return _storage._nil != nil} + var hasNil: Bool {_storage._nil != nil} /// Clears the value of ``nil``. Subsequent reads from it will return its default value. mutating func clearNil() {_uniqueStorage()._nil = nil} var `rethrows`: Int32 { - get {return _storage._rethrows ?? 0} + get {_storage._rethrows ?? 0} set {_uniqueStorage()._rethrows = newValue} } /// Returns true if ``rethrows`` has been explicitly set. - var hasRethrows: Bool {return _storage._rethrows != nil} + var hasRethrows: Bool {_storage._rethrows != nil} /// Clears the value of ``rethrows``. Subsequent reads from it will return its default value. mutating func clearRethrows() {_uniqueStorage()._rethrows = nil} var `super`: Int32 { - get {return _storage._super ?? 0} + get {_storage._super ?? 0} set {_uniqueStorage()._super = newValue} } /// Returns true if ``super`` has been explicitly set. - var hasSuper: Bool {return _storage._super != nil} + var hasSuper: Bool {_storage._super != nil} /// Clears the value of ``super``. Subsequent reads from it will return its default value. mutating func clearSuper() {_uniqueStorage()._super = nil} var self_p: Int32 { - get {return _storage._self_p ?? 0} + get {_storage._self_p ?? 0} set {_uniqueStorage()._self_p = newValue} } /// Returns true if `self_p` has been explicitly set. - var hasSelf_p: Bool {return _storage._self_p != nil} + var hasSelf_p: Bool {_storage._self_p != nil} /// Clears the value of `self_p`. Subsequent reads from it will return its default value. mutating func clearSelf_p() {_uniqueStorage()._self_p = nil} var `throw`: Int32 { - get {return _storage._throw ?? 0} + get {_storage._throw ?? 0} set {_uniqueStorage()._throw = newValue} } /// Returns true if ``throw`` has been explicitly set. - var hasThrow: Bool {return _storage._throw != nil} + var hasThrow: Bool {_storage._throw != nil} /// Clears the value of ``throw``. Subsequent reads from it will return its default value. mutating func clearThrow() {_uniqueStorage()._throw = nil} var `throws`: Int32 { - get {return _storage._throws ?? 0} + get {_storage._throws ?? 0} set {_uniqueStorage()._throws = newValue} } /// Returns true if ``throws`` has been explicitly set. - var hasThrows: Bool {return _storage._throws != nil} + var hasThrows: Bool {_storage._throws != nil} /// Clears the value of ``throws``. Subsequent reads from it will return its default value. mutating func clearThrows() {_uniqueStorage()._throws = nil} var `true`: Int32 { - get {return _storage._true ?? 0} + get {_storage._true ?? 0} set {_uniqueStorage()._true = newValue} } /// Returns true if ``true`` has been explicitly set. - var hasTrue: Bool {return _storage._true != nil} + var hasTrue: Bool {_storage._true != nil} /// Clears the value of ``true``. Subsequent reads from it will return its default value. mutating func clearTrue() {_uniqueStorage()._true = nil} var `try`: Int32 { - get {return _storage._try ?? 0} + get {_storage._try ?? 0} set {_uniqueStorage()._try = newValue} } /// Returns true if ``try`` has been explicitly set. - var hasTry: Bool {return _storage._try != nil} + var hasTry: Bool {_storage._try != nil} /// Clears the value of ``try``. Subsequent reads from it will return its default value. mutating func clearTry() {_uniqueStorage()._try = nil} var _Column__: Int32 { - get {return _storage.__Column__ ?? 0} + get {_storage.__Column__ ?? 0} set {_uniqueStorage().__Column__ = newValue} } /// Returns true if `_Column__` has been explicitly set. - var has_Column__: Bool {return _storage.__Column__ != nil} + var has_Column__: Bool {_storage.__Column__ != nil} /// Clears the value of `_Column__`. Subsequent reads from it will return its default value. mutating func clear_Column__() {_uniqueStorage().__Column__ = nil} var _File__: Int32 { - get {return _storage.__File__ ?? 0} + get {_storage.__File__ ?? 0} set {_uniqueStorage().__File__ = newValue} } /// Returns true if `_File__` has been explicitly set. - var has_File__: Bool {return _storage.__File__ != nil} + var has_File__: Bool {_storage.__File__ != nil} /// Clears the value of `_File__`. Subsequent reads from it will return its default value. mutating func clear_File__() {_uniqueStorage().__File__ = nil} var _Function__: Int32 { - get {return _storage.__Function__ ?? 0} + get {_storage.__Function__ ?? 0} set {_uniqueStorage().__Function__ = newValue} } /// Returns true if `_Function__` has been explicitly set. - var has_Function__: Bool {return _storage.__Function__ != nil} + var has_Function__: Bool {_storage.__Function__ != nil} /// Clears the value of `_Function__`. Subsequent reads from it will return its default value. mutating func clear_Function__() {_uniqueStorage().__Function__ = nil} var _Line__: Int32 { - get {return _storage.__Line__ ?? 0} + get {_storage.__Line__ ?? 0} set {_uniqueStorage().__Line__ = newValue} } /// Returns true if `_Line__` has been explicitly set. - var has_Line__: Bool {return _storage.__Line__ != nil} + var has_Line__: Bool {_storage.__Line__ != nil} /// Clears the value of `_Line__`. Subsequent reads from it will return its default value. mutating func clear_Line__() {_uniqueStorage().__Line__ = nil} var ___: Int32 { - get {return _storage.____ ?? 0} + get {_storage.____ ?? 0} set {_uniqueStorage().____ = newValue} } /// Returns true if `___` has been explicitly set. - var has___: Bool {return _storage.____ != nil} + var has___: Bool {_storage.____ != nil} /// Clears the value of `___`. Subsequent reads from it will return its default value. mutating func clear___() {_uniqueStorage().____ = nil} var associativity: Int32 { - get {return _storage._associativity ?? 0} + get {_storage._associativity ?? 0} set {_uniqueStorage()._associativity = newValue} } /// Returns true if `associativity` has been explicitly set. - var hasAssociativity: Bool {return _storage._associativity != nil} + var hasAssociativity: Bool {_storage._associativity != nil} /// Clears the value of `associativity`. Subsequent reads from it will return its default value. mutating func clearAssociativity() {_uniqueStorage()._associativity = nil} var convenience: Int32 { - get {return _storage._convenience ?? 0} + get {_storage._convenience ?? 0} set {_uniqueStorage()._convenience = newValue} } /// Returns true if `convenience` has been explicitly set. - var hasConvenience: Bool {return _storage._convenience != nil} + var hasConvenience: Bool {_storage._convenience != nil} /// Clears the value of `convenience`. Subsequent reads from it will return its default value. mutating func clearConvenience() {_uniqueStorage()._convenience = nil} var dynamic: Int32 { - get {return _storage._dynamic ?? 0} + get {_storage._dynamic ?? 0} set {_uniqueStorage()._dynamic = newValue} } /// Returns true if `dynamic` has been explicitly set. - var hasDynamic: Bool {return _storage._dynamic != nil} + var hasDynamic: Bool {_storage._dynamic != nil} /// Clears the value of `dynamic`. Subsequent reads from it will return its default value. mutating func clearDynamic() {_uniqueStorage()._dynamic = nil} var didSet: Int32 { - get {return _storage._didSet ?? 0} + get {_storage._didSet ?? 0} set {_uniqueStorage()._didSet = newValue} } /// Returns true if `didSet` has been explicitly set. - var hasDidSet: Bool {return _storage._didSet != nil} + var hasDidSet: Bool {_storage._didSet != nil} /// Clears the value of `didSet`. Subsequent reads from it will return its default value. mutating func clearDidSet() {_uniqueStorage()._didSet = nil} var final: Int32 { - get {return _storage._final ?? 0} + get {_storage._final ?? 0} set {_uniqueStorage()._final = newValue} } /// Returns true if `final` has been explicitly set. - var hasFinal: Bool {return _storage._final != nil} + var hasFinal: Bool {_storage._final != nil} /// Clears the value of `final`. Subsequent reads from it will return its default value. mutating func clearFinal() {_uniqueStorage()._final = nil} var get: Int32 { - get {return _storage._get ?? 0} + get {_storage._get ?? 0} set {_uniqueStorage()._get = newValue} } /// Returns true if `get` has been explicitly set. - var hasGet: Bool {return _storage._get != nil} + var hasGet: Bool {_storage._get != nil} /// Clears the value of `get`. Subsequent reads from it will return its default value. mutating func clearGet() {_uniqueStorage()._get = nil} var infix: Int32 { - get {return _storage._infix ?? 0} + get {_storage._infix ?? 0} set {_uniqueStorage()._infix = newValue} } /// Returns true if `infix` has been explicitly set. - var hasInfix: Bool {return _storage._infix != nil} + var hasInfix: Bool {_storage._infix != nil} /// Clears the value of `infix`. Subsequent reads from it will return its default value. mutating func clearInfix() {_uniqueStorage()._infix = nil} var indirect: Int32 { - get {return _storage._indirect ?? 0} + get {_storage._indirect ?? 0} set {_uniqueStorage()._indirect = newValue} } /// Returns true if `indirect` has been explicitly set. - var hasIndirect: Bool {return _storage._indirect != nil} + var hasIndirect: Bool {_storage._indirect != nil} /// Clears the value of `indirect`. Subsequent reads from it will return its default value. mutating func clearIndirect() {_uniqueStorage()._indirect = nil} var lazy: Int32 { - get {return _storage._lazy ?? 0} + get {_storage._lazy ?? 0} set {_uniqueStorage()._lazy = newValue} } /// Returns true if `lazy` has been explicitly set. - var hasLazy: Bool {return _storage._lazy != nil} + var hasLazy: Bool {_storage._lazy != nil} /// Clears the value of `lazy`. Subsequent reads from it will return its default value. mutating func clearLazy() {_uniqueStorage()._lazy = nil} var left: Int32 { - get {return _storage._left ?? 0} + get {_storage._left ?? 0} set {_uniqueStorage()._left = newValue} } /// Returns true if `left` has been explicitly set. - var hasLeft: Bool {return _storage._left != nil} + var hasLeft: Bool {_storage._left != nil} /// Clears the value of `left`. Subsequent reads from it will return its default value. mutating func clearLeft() {_uniqueStorage()._left = nil} var mutating: Int32 { - get {return _storage._mutating ?? 0} + get {_storage._mutating ?? 0} set {_uniqueStorage()._mutating = newValue} } /// Returns true if `mutating` has been explicitly set. - var hasMutating: Bool {return _storage._mutating != nil} + var hasMutating: Bool {_storage._mutating != nil} /// Clears the value of `mutating`. Subsequent reads from it will return its default value. mutating func clearMutating() {_uniqueStorage()._mutating = nil} var none: Int32 { - get {return _storage._none ?? 0} + get {_storage._none ?? 0} set {_uniqueStorage()._none = newValue} } /// Returns true if `none` has been explicitly set. - var hasNone: Bool {return _storage._none != nil} + var hasNone: Bool {_storage._none != nil} /// Clears the value of `none`. Subsequent reads from it will return its default value. mutating func clearNone() {_uniqueStorage()._none = nil} var nonmutating: Int32 { - get {return _storage._nonmutating ?? 0} + get {_storage._nonmutating ?? 0} set {_uniqueStorage()._nonmutating = newValue} } /// Returns true if `nonmutating` has been explicitly set. - var hasNonmutating: Bool {return _storage._nonmutating != nil} + var hasNonmutating: Bool {_storage._nonmutating != nil} /// Clears the value of `nonmutating`. Subsequent reads from it will return its default value. mutating func clearNonmutating() {_uniqueStorage()._nonmutating = nil} var optional: Int32 { - get {return _storage._optional ?? 0} + get {_storage._optional ?? 0} set {_uniqueStorage()._optional = newValue} } /// Returns true if `optional` has been explicitly set. - var hasOptional: Bool {return _storage._optional != nil} + var hasOptional: Bool {_storage._optional != nil} /// Clears the value of `optional`. Subsequent reads from it will return its default value. mutating func clearOptional() {_uniqueStorage()._optional = nil} var override: Int32 { - get {return _storage._override ?? 0} + get {_storage._override ?? 0} set {_uniqueStorage()._override = newValue} } /// Returns true if `override` has been explicitly set. - var hasOverride: Bool {return _storage._override != nil} + var hasOverride: Bool {_storage._override != nil} /// Clears the value of `override`. Subsequent reads from it will return its default value. mutating func clearOverride() {_uniqueStorage()._override = nil} var postfix: Int32 { - get {return _storage._postfix ?? 0} + get {_storage._postfix ?? 0} set {_uniqueStorage()._postfix = newValue} } /// Returns true if `postfix` has been explicitly set. - var hasPostfix: Bool {return _storage._postfix != nil} + var hasPostfix: Bool {_storage._postfix != nil} /// Clears the value of `postfix`. Subsequent reads from it will return its default value. mutating func clearPostfix() {_uniqueStorage()._postfix = nil} var precedence: Int32 { - get {return _storage._precedence ?? 0} + get {_storage._precedence ?? 0} set {_uniqueStorage()._precedence = newValue} } /// Returns true if `precedence` has been explicitly set. - var hasPrecedence: Bool {return _storage._precedence != nil} + var hasPrecedence: Bool {_storage._precedence != nil} /// Clears the value of `precedence`. Subsequent reads from it will return its default value. mutating func clearPrecedence() {_uniqueStorage()._precedence = nil} var prefix: Int32 { - get {return _storage._prefix ?? 0} + get {_storage._prefix ?? 0} set {_uniqueStorage()._prefix = newValue} } /// Returns true if `prefix` has been explicitly set. - var hasPrefix: Bool {return _storage._prefix != nil} + var hasPrefix: Bool {_storage._prefix != nil} /// Clears the value of `prefix`. Subsequent reads from it will return its default value. mutating func clearPrefix() {_uniqueStorage()._prefix = nil} var required: Int32 { - get {return _storage._required ?? 0} + get {_storage._required ?? 0} set {_uniqueStorage()._required = newValue} } /// Returns true if `required` has been explicitly set. - var hasRequired: Bool {return _storage._required != nil} + var hasRequired: Bool {_storage._required != nil} /// Clears the value of `required`. Subsequent reads from it will return its default value. mutating func clearRequired() {_uniqueStorage()._required = nil} var right: Int32 { - get {return _storage._right ?? 0} + get {_storage._right ?? 0} set {_uniqueStorage()._right = newValue} } /// Returns true if `right` has been explicitly set. - var hasRight: Bool {return _storage._right != nil} + var hasRight: Bool {_storage._right != nil} /// Clears the value of `right`. Subsequent reads from it will return its default value. mutating func clearRight() {_uniqueStorage()._right = nil} var set: Int32 { - get {return _storage._set ?? 0} + get {_storage._set ?? 0} set {_uniqueStorage()._set = newValue} } /// Returns true if `set` has been explicitly set. - var hasSet: Bool {return _storage._set != nil} + var hasSet: Bool {_storage._set != nil} /// Clears the value of `set`. Subsequent reads from it will return its default value. mutating func clearSet() {_uniqueStorage()._set = nil} var type: Int32 { - get {return _storage._type ?? 0} + get {_storage._type ?? 0} set {_uniqueStorage()._type = newValue} } /// Returns true if `type` has been explicitly set. - var hasType: Bool {return _storage._type != nil} + var hasType: Bool {_storage._type != nil} /// Clears the value of `type`. Subsequent reads from it will return its default value. mutating func clearType() {_uniqueStorage()._type = nil} var unowned: Int32 { - get {return _storage._unowned ?? 0} + get {_storage._unowned ?? 0} set {_uniqueStorage()._unowned = newValue} } /// Returns true if `unowned` has been explicitly set. - var hasUnowned: Bool {return _storage._unowned != nil} + var hasUnowned: Bool {_storage._unowned != nil} /// Clears the value of `unowned`. Subsequent reads from it will return its default value. mutating func clearUnowned() {_uniqueStorage()._unowned = nil} var weak: Int32 { - get {return _storage._weak ?? 0} + get {_storage._weak ?? 0} set {_uniqueStorage()._weak = newValue} } /// Returns true if `weak` has been explicitly set. - var hasWeak: Bool {return _storage._weak != nil} + var hasWeak: Bool {_storage._weak != nil} /// Clears the value of `weak`. Subsequent reads from it will return its default value. mutating func clearWeak() {_uniqueStorage()._weak = nil} var willSet: Int32 { - get {return _storage._willSet ?? 0} + get {_storage._willSet ?? 0} set {_uniqueStorage()._willSet = newValue} } /// Returns true if `willSet` has been explicitly set. - var hasWillSet: Bool {return _storage._willSet != nil} + var hasWillSet: Bool {_storage._willSet != nil} /// Clears the value of `willSet`. Subsequent reads from it will return its default value. mutating func clearWillSet() {_uniqueStorage()._willSet = nil} var id: Int32 { - get {return _storage._id ?? 0} + get {_storage._id ?? 0} set {_uniqueStorage()._id = newValue} } /// Returns true if `id` has been explicitly set. - var hasID: Bool {return _storage._id != nil} + var hasID: Bool {_storage._id != nil} /// Clears the value of `id`. Subsequent reads from it will return its default value. mutating func clearID() {_uniqueStorage()._id = nil} var cmd: Int32 { - get {return _storage._cmd ?? 0} + get {_storage._cmd ?? 0} set {_uniqueStorage()._cmd = newValue} } /// Returns true if `cmd` has been explicitly set. - var hasCmd: Bool {return _storage._cmd != nil} + var hasCmd: Bool {_storage._cmd != nil} /// Clears the value of `cmd`. Subsequent reads from it will return its default value. mutating func clearCmd() {_uniqueStorage()._cmd = nil} var out: Int32 { - get {return _storage._out ?? 0} + get {_storage._out ?? 0} set {_uniqueStorage()._out = newValue} } /// Returns true if `out` has been explicitly set. - var hasOut: Bool {return _storage._out != nil} + var hasOut: Bool {_storage._out != nil} /// Clears the value of `out`. Subsequent reads from it will return its default value. mutating func clearOut() {_uniqueStorage()._out = nil} var bycopy: Int32 { - get {return _storage._bycopy ?? 0} + get {_storage._bycopy ?? 0} set {_uniqueStorage()._bycopy = newValue} } /// Returns true if `bycopy` has been explicitly set. - var hasBycopy: Bool {return _storage._bycopy != nil} + var hasBycopy: Bool {_storage._bycopy != nil} /// Clears the value of `bycopy`. Subsequent reads from it will return its default value. mutating func clearBycopy() {_uniqueStorage()._bycopy = nil} var byref: Int32 { - get {return _storage._byref ?? 0} + get {_storage._byref ?? 0} set {_uniqueStorage()._byref = newValue} } /// Returns true if `byref` has been explicitly set. - var hasByref: Bool {return _storage._byref != nil} + var hasByref: Bool {_storage._byref != nil} /// Clears the value of `byref`. Subsequent reads from it will return its default value. mutating func clearByref() {_uniqueStorage()._byref = nil} var oneway: Int32 { - get {return _storage._oneway ?? 0} + get {_storage._oneway ?? 0} set {_uniqueStorage()._oneway = newValue} } /// Returns true if `oneway` has been explicitly set. - var hasOneway: Bool {return _storage._oneway != nil} + var hasOneway: Bool {_storage._oneway != nil} /// Clears the value of `oneway`. Subsequent reads from it will return its default value. mutating func clearOneway() {_uniqueStorage()._oneway = nil} var and: Int32 { - get {return _storage._and ?? 0} + get {_storage._and ?? 0} set {_uniqueStorage()._and = newValue} } /// Returns true if `and` has been explicitly set. - var hasAnd: Bool {return _storage._and != nil} + var hasAnd: Bool {_storage._and != nil} /// Clears the value of `and`. Subsequent reads from it will return its default value. mutating func clearAnd() {_uniqueStorage()._and = nil} var andEq: Int32 { - get {return _storage._andEq ?? 0} + get {_storage._andEq ?? 0} set {_uniqueStorage()._andEq = newValue} } /// Returns true if `andEq` has been explicitly set. - var hasAndEq: Bool {return _storage._andEq != nil} + var hasAndEq: Bool {_storage._andEq != nil} /// Clears the value of `andEq`. Subsequent reads from it will return its default value. mutating func clearAndEq() {_uniqueStorage()._andEq = nil} var alignas: Int32 { - get {return _storage._alignas ?? 0} + get {_storage._alignas ?? 0} set {_uniqueStorage()._alignas = newValue} } /// Returns true if `alignas` has been explicitly set. - var hasAlignas: Bool {return _storage._alignas != nil} + var hasAlignas: Bool {_storage._alignas != nil} /// Clears the value of `alignas`. Subsequent reads from it will return its default value. mutating func clearAlignas() {_uniqueStorage()._alignas = nil} var alignof: Int32 { - get {return _storage._alignof ?? 0} + get {_storage._alignof ?? 0} set {_uniqueStorage()._alignof = newValue} } /// Returns true if `alignof` has been explicitly set. - var hasAlignof: Bool {return _storage._alignof != nil} + var hasAlignof: Bool {_storage._alignof != nil} /// Clears the value of `alignof`. Subsequent reads from it will return its default value. mutating func clearAlignof() {_uniqueStorage()._alignof = nil} var asm: Int32 { - get {return _storage._asm ?? 0} + get {_storage._asm ?? 0} set {_uniqueStorage()._asm = newValue} } /// Returns true if `asm` has been explicitly set. - var hasAsm: Bool {return _storage._asm != nil} + var hasAsm: Bool {_storage._asm != nil} /// Clears the value of `asm`. Subsequent reads from it will return its default value. mutating func clearAsm() {_uniqueStorage()._asm = nil} var auto: Int32 { - get {return _storage._auto ?? 0} + get {_storage._auto ?? 0} set {_uniqueStorage()._auto = newValue} } /// Returns true if `auto` has been explicitly set. - var hasAuto: Bool {return _storage._auto != nil} + var hasAuto: Bool {_storage._auto != nil} /// Clears the value of `auto`. Subsequent reads from it will return its default value. mutating func clearAuto() {_uniqueStorage()._auto = nil} var bitand: Int32 { - get {return _storage._bitand ?? 0} + get {_storage._bitand ?? 0} set {_uniqueStorage()._bitand = newValue} } /// Returns true if `bitand` has been explicitly set. - var hasBitand: Bool {return _storage._bitand != nil} + var hasBitand: Bool {_storage._bitand != nil} /// Clears the value of `bitand`. Subsequent reads from it will return its default value. mutating func clearBitand() {_uniqueStorage()._bitand = nil} var bitor: Int32 { - get {return _storage._bitor ?? 0} + get {_storage._bitor ?? 0} set {_uniqueStorage()._bitor = newValue} } /// Returns true if `bitor` has been explicitly set. - var hasBitor: Bool {return _storage._bitor != nil} + var hasBitor: Bool {_storage._bitor != nil} /// Clears the value of `bitor`. Subsequent reads from it will return its default value. mutating func clearBitor() {_uniqueStorage()._bitor = nil} var bool: Int32 { - get {return _storage._bool ?? 0} + get {_storage._bool ?? 0} set {_uniqueStorage()._bool = newValue} } /// Returns true if `bool` has been explicitly set. - var hasBool: Bool {return _storage._bool != nil} + var hasBool: Bool {_storage._bool != nil} /// Clears the value of `bool`. Subsequent reads from it will return its default value. mutating func clearBool() {_uniqueStorage()._bool = nil} var char: Int32 { - get {return _storage._char ?? 0} + get {_storage._char ?? 0} set {_uniqueStorage()._char = newValue} } /// Returns true if `char` has been explicitly set. - var hasChar: Bool {return _storage._char != nil} + var hasChar: Bool {_storage._char != nil} /// Clears the value of `char`. Subsequent reads from it will return its default value. mutating func clearChar() {_uniqueStorage()._char = nil} var char16T: Int32 { - get {return _storage._char16T ?? 0} + get {_storage._char16T ?? 0} set {_uniqueStorage()._char16T = newValue} } /// Returns true if `char16T` has been explicitly set. - var hasChar16T: Bool {return _storage._char16T != nil} + var hasChar16T: Bool {_storage._char16T != nil} /// Clears the value of `char16T`. Subsequent reads from it will return its default value. mutating func clearChar16T() {_uniqueStorage()._char16T = nil} var char32T: Int32 { - get {return _storage._char32T ?? 0} + get {_storage._char32T ?? 0} set {_uniqueStorage()._char32T = newValue} } /// Returns true if `char32T` has been explicitly set. - var hasChar32T: Bool {return _storage._char32T != nil} + var hasChar32T: Bool {_storage._char32T != nil} /// Clears the value of `char32T`. Subsequent reads from it will return its default value. mutating func clearChar32T() {_uniqueStorage()._char32T = nil} var compl: Int32 { - get {return _storage._compl ?? 0} + get {_storage._compl ?? 0} set {_uniqueStorage()._compl = newValue} } /// Returns true if `compl` has been explicitly set. - var hasCompl: Bool {return _storage._compl != nil} + var hasCompl: Bool {_storage._compl != nil} /// Clears the value of `compl`. Subsequent reads from it will return its default value. mutating func clearCompl() {_uniqueStorage()._compl = nil} var const: Int32 { - get {return _storage._const ?? 0} + get {_storage._const ?? 0} set {_uniqueStorage()._const = newValue} } /// Returns true if `const` has been explicitly set. - var hasConst: Bool {return _storage._const != nil} + var hasConst: Bool {_storage._const != nil} /// Clears the value of `const`. Subsequent reads from it will return its default value. mutating func clearConst() {_uniqueStorage()._const = nil} var constexpr: Int32 { - get {return _storage._constexpr ?? 0} + get {_storage._constexpr ?? 0} set {_uniqueStorage()._constexpr = newValue} } /// Returns true if `constexpr` has been explicitly set. - var hasConstexpr: Bool {return _storage._constexpr != nil} + var hasConstexpr: Bool {_storage._constexpr != nil} /// Clears the value of `constexpr`. Subsequent reads from it will return its default value. mutating func clearConstexpr() {_uniqueStorage()._constexpr = nil} var constCast: Int32 { - get {return _storage._constCast ?? 0} + get {_storage._constCast ?? 0} set {_uniqueStorage()._constCast = newValue} } /// Returns true if `constCast` has been explicitly set. - var hasConstCast: Bool {return _storage._constCast != nil} + var hasConstCast: Bool {_storage._constCast != nil} /// Clears the value of `constCast`. Subsequent reads from it will return its default value. mutating func clearConstCast() {_uniqueStorage()._constCast = nil} var decltype: Int32 { - get {return _storage._decltype ?? 0} + get {_storage._decltype ?? 0} set {_uniqueStorage()._decltype = newValue} } /// Returns true if `decltype` has been explicitly set. - var hasDecltype: Bool {return _storage._decltype != nil} + var hasDecltype: Bool {_storage._decltype != nil} /// Clears the value of `decltype`. Subsequent reads from it will return its default value. mutating func clearDecltype() {_uniqueStorage()._decltype = nil} var delete: Int32 { - get {return _storage._delete ?? 0} + get {_storage._delete ?? 0} set {_uniqueStorage()._delete = newValue} } /// Returns true if `delete` has been explicitly set. - var hasDelete: Bool {return _storage._delete != nil} + var hasDelete: Bool {_storage._delete != nil} /// Clears the value of `delete`. Subsequent reads from it will return its default value. mutating func clearDelete() {_uniqueStorage()._delete = nil} var dynamicCast: Int32 { - get {return _storage._dynamicCast ?? 0} + get {_storage._dynamicCast ?? 0} set {_uniqueStorage()._dynamicCast = newValue} } /// Returns true if `dynamicCast` has been explicitly set. - var hasDynamicCast: Bool {return _storage._dynamicCast != nil} + var hasDynamicCast: Bool {_storage._dynamicCast != nil} /// Clears the value of `dynamicCast`. Subsequent reads from it will return its default value. mutating func clearDynamicCast() {_uniqueStorage()._dynamicCast = nil} var explicit: Int32 { - get {return _storage._explicit ?? 0} + get {_storage._explicit ?? 0} set {_uniqueStorage()._explicit = newValue} } /// Returns true if `explicit` has been explicitly set. - var hasExplicit: Bool {return _storage._explicit != nil} + var hasExplicit: Bool {_storage._explicit != nil} /// Clears the value of `explicit`. Subsequent reads from it will return its default value. mutating func clearExplicit() {_uniqueStorage()._explicit = nil} var export: Int32 { - get {return _storage._export ?? 0} + get {_storage._export ?? 0} set {_uniqueStorage()._export = newValue} } /// Returns true if `export` has been explicitly set. - var hasExport: Bool {return _storage._export != nil} + var hasExport: Bool {_storage._export != nil} /// Clears the value of `export`. Subsequent reads from it will return its default value. mutating func clearExport() {_uniqueStorage()._export = nil} var extern: Int32 { - get {return _storage._extern ?? 0} + get {_storage._extern ?? 0} set {_uniqueStorage()._extern = newValue} } /// Returns true if `extern` has been explicitly set. - var hasExtern: Bool {return _storage._extern != nil} + var hasExtern: Bool {_storage._extern != nil} /// Clears the value of `extern`. Subsequent reads from it will return its default value. mutating func clearExtern() {_uniqueStorage()._extern = nil} var friend: Int32 { - get {return _storage._friend ?? 0} + get {_storage._friend ?? 0} set {_uniqueStorage()._friend = newValue} } /// Returns true if `friend` has been explicitly set. - var hasFriend: Bool {return _storage._friend != nil} + var hasFriend: Bool {_storage._friend != nil} /// Clears the value of `friend`. Subsequent reads from it will return its default value. mutating func clearFriend() {_uniqueStorage()._friend = nil} var goto: Int32 { - get {return _storage._goto ?? 0} + get {_storage._goto ?? 0} set {_uniqueStorage()._goto = newValue} } /// Returns true if `goto` has been explicitly set. - var hasGoto: Bool {return _storage._goto != nil} + var hasGoto: Bool {_storage._goto != nil} /// Clears the value of `goto`. Subsequent reads from it will return its default value. mutating func clearGoto() {_uniqueStorage()._goto = nil} var inline: Int32 { - get {return _storage._inline ?? 0} + get {_storage._inline ?? 0} set {_uniqueStorage()._inline = newValue} } /// Returns true if `inline` has been explicitly set. - var hasInline: Bool {return _storage._inline != nil} + var hasInline: Bool {_storage._inline != nil} /// Clears the value of `inline`. Subsequent reads from it will return its default value. mutating func clearInline() {_uniqueStorage()._inline = nil} var long: Int32 { - get {return _storage._long ?? 0} + get {_storage._long ?? 0} set {_uniqueStorage()._long = newValue} } /// Returns true if `long` has been explicitly set. - var hasLong: Bool {return _storage._long != nil} + var hasLong: Bool {_storage._long != nil} /// Clears the value of `long`. Subsequent reads from it will return its default value. mutating func clearLong() {_uniqueStorage()._long = nil} var mutable: Int32 { - get {return _storage._mutable ?? 0} + get {_storage._mutable ?? 0} set {_uniqueStorage()._mutable = newValue} } /// Returns true if `mutable` has been explicitly set. - var hasMutable: Bool {return _storage._mutable != nil} + var hasMutable: Bool {_storage._mutable != nil} /// Clears the value of `mutable`. Subsequent reads from it will return its default value. mutating func clearMutable() {_uniqueStorage()._mutable = nil} var namespace: Int32 { - get {return _storage._namespace ?? 0} + get {_storage._namespace ?? 0} set {_uniqueStorage()._namespace = newValue} } /// Returns true if `namespace` has been explicitly set. - var hasNamespace: Bool {return _storage._namespace != nil} + var hasNamespace: Bool {_storage._namespace != nil} /// Clears the value of `namespace`. Subsequent reads from it will return its default value. mutating func clearNamespace() {_uniqueStorage()._namespace = nil} var new: Int32 { - get {return _storage._new ?? 0} + get {_storage._new ?? 0} set {_uniqueStorage()._new = newValue} } /// Returns true if `new` has been explicitly set. - var hasNew: Bool {return _storage._new != nil} + var hasNew: Bool {_storage._new != nil} /// Clears the value of `new`. Subsequent reads from it will return its default value. mutating func clearNew() {_uniqueStorage()._new = nil} var noexcept: Int32 { - get {return _storage._noexcept ?? 0} + get {_storage._noexcept ?? 0} set {_uniqueStorage()._noexcept = newValue} } /// Returns true if `noexcept` has been explicitly set. - var hasNoexcept: Bool {return _storage._noexcept != nil} + var hasNoexcept: Bool {_storage._noexcept != nil} /// Clears the value of `noexcept`. Subsequent reads from it will return its default value. mutating func clearNoexcept() {_uniqueStorage()._noexcept = nil} var not: Int32 { - get {return _storage._not ?? 0} + get {_storage._not ?? 0} set {_uniqueStorage()._not = newValue} } /// Returns true if `not` has been explicitly set. - var hasNot: Bool {return _storage._not != nil} + var hasNot: Bool {_storage._not != nil} /// Clears the value of `not`. Subsequent reads from it will return its default value. mutating func clearNot() {_uniqueStorage()._not = nil} var notEq: Int32 { - get {return _storage._notEq ?? 0} + get {_storage._notEq ?? 0} set {_uniqueStorage()._notEq = newValue} } /// Returns true if `notEq` has been explicitly set. - var hasNotEq: Bool {return _storage._notEq != nil} + var hasNotEq: Bool {_storage._notEq != nil} /// Clears the value of `notEq`. Subsequent reads from it will return its default value. mutating func clearNotEq() {_uniqueStorage()._notEq = nil} var nullptr: Int32 { - get {return _storage._nullptr ?? 0} + get {_storage._nullptr ?? 0} set {_uniqueStorage()._nullptr = newValue} } /// Returns true if `nullptr` has been explicitly set. - var hasNullptr: Bool {return _storage._nullptr != nil} + var hasNullptr: Bool {_storage._nullptr != nil} /// Clears the value of `nullptr`. Subsequent reads from it will return its default value. mutating func clearNullptr() {_uniqueStorage()._nullptr = nil} var or: Int32 { - get {return _storage._or ?? 0} + get {_storage._or ?? 0} set {_uniqueStorage()._or = newValue} } /// Returns true if `or` has been explicitly set. - var hasOr: Bool {return _storage._or != nil} + var hasOr: Bool {_storage._or != nil} /// Clears the value of `or`. Subsequent reads from it will return its default value. mutating func clearOr() {_uniqueStorage()._or = nil} var orEq: Int32 { - get {return _storage._orEq ?? 0} + get {_storage._orEq ?? 0} set {_uniqueStorage()._orEq = newValue} } /// Returns true if `orEq` has been explicitly set. - var hasOrEq: Bool {return _storage._orEq != nil} + var hasOrEq: Bool {_storage._orEq != nil} /// Clears the value of `orEq`. Subsequent reads from it will return its default value. mutating func clearOrEq() {_uniqueStorage()._orEq = nil} var protected: Int32 { - get {return _storage._protected ?? 0} + get {_storage._protected ?? 0} set {_uniqueStorage()._protected = newValue} } /// Returns true if `protected` has been explicitly set. - var hasProtected: Bool {return _storage._protected != nil} + var hasProtected: Bool {_storage._protected != nil} /// Clears the value of `protected`. Subsequent reads from it will return its default value. mutating func clearProtected() {_uniqueStorage()._protected = nil} var register: Int32 { - get {return _storage._register ?? 0} + get {_storage._register ?? 0} set {_uniqueStorage()._register = newValue} } /// Returns true if `register` has been explicitly set. - var hasRegister: Bool {return _storage._register != nil} + var hasRegister: Bool {_storage._register != nil} /// Clears the value of `register`. Subsequent reads from it will return its default value. mutating func clearRegister() {_uniqueStorage()._register = nil} var reinterpretCast: Int32 { - get {return _storage._reinterpretCast ?? 0} + get {_storage._reinterpretCast ?? 0} set {_uniqueStorage()._reinterpretCast = newValue} } /// Returns true if `reinterpretCast` has been explicitly set. - var hasReinterpretCast: Bool {return _storage._reinterpretCast != nil} + var hasReinterpretCast: Bool {_storage._reinterpretCast != nil} /// Clears the value of `reinterpretCast`. Subsequent reads from it will return its default value. mutating func clearReinterpretCast() {_uniqueStorage()._reinterpretCast = nil} var short: Int32 { - get {return _storage._short ?? 0} + get {_storage._short ?? 0} set {_uniqueStorage()._short = newValue} } /// Returns true if `short` has been explicitly set. - var hasShort: Bool {return _storage._short != nil} + var hasShort: Bool {_storage._short != nil} /// Clears the value of `short`. Subsequent reads from it will return its default value. mutating func clearShort() {_uniqueStorage()._short = nil} var signed: Int32 { - get {return _storage._signed ?? 0} + get {_storage._signed ?? 0} set {_uniqueStorage()._signed = newValue} } /// Returns true if `signed` has been explicitly set. - var hasSigned: Bool {return _storage._signed != nil} + var hasSigned: Bool {_storage._signed != nil} /// Clears the value of `signed`. Subsequent reads from it will return its default value. mutating func clearSigned() {_uniqueStorage()._signed = nil} var sizeof: Int32 { - get {return _storage._sizeof ?? 0} + get {_storage._sizeof ?? 0} set {_uniqueStorage()._sizeof = newValue} } /// Returns true if `sizeof` has been explicitly set. - var hasSizeof: Bool {return _storage._sizeof != nil} + var hasSizeof: Bool {_storage._sizeof != nil} /// Clears the value of `sizeof`. Subsequent reads from it will return its default value. mutating func clearSizeof() {_uniqueStorage()._sizeof = nil} var staticAssert: Int32 { - get {return _storage._staticAssert ?? 0} + get {_storage._staticAssert ?? 0} set {_uniqueStorage()._staticAssert = newValue} } /// Returns true if `staticAssert` has been explicitly set. - var hasStaticAssert: Bool {return _storage._staticAssert != nil} + var hasStaticAssert: Bool {_storage._staticAssert != nil} /// Clears the value of `staticAssert`. Subsequent reads from it will return its default value. mutating func clearStaticAssert() {_uniqueStorage()._staticAssert = nil} var staticCast: Int32 { - get {return _storage._staticCast ?? 0} + get {_storage._staticCast ?? 0} set {_uniqueStorage()._staticCast = newValue} } /// Returns true if `staticCast` has been explicitly set. - var hasStaticCast: Bool {return _storage._staticCast != nil} + var hasStaticCast: Bool {_storage._staticCast != nil} /// Clears the value of `staticCast`. Subsequent reads from it will return its default value. mutating func clearStaticCast() {_uniqueStorage()._staticCast = nil} var template: Int32 { - get {return _storage._template ?? 0} + get {_storage._template ?? 0} set {_uniqueStorage()._template = newValue} } /// Returns true if `template` has been explicitly set. - var hasTemplate: Bool {return _storage._template != nil} + var hasTemplate: Bool {_storage._template != nil} /// Clears the value of `template`. Subsequent reads from it will return its default value. mutating func clearTemplate() {_uniqueStorage()._template = nil} var this: Int32 { - get {return _storage._this ?? 0} + get {_storage._this ?? 0} set {_uniqueStorage()._this = newValue} } /// Returns true if `this` has been explicitly set. - var hasThis: Bool {return _storage._this != nil} + var hasThis: Bool {_storage._this != nil} /// Clears the value of `this`. Subsequent reads from it will return its default value. mutating func clearThis() {_uniqueStorage()._this = nil} var threadLocal: Int32 { - get {return _storage._threadLocal ?? 0} + get {_storage._threadLocal ?? 0} set {_uniqueStorage()._threadLocal = newValue} } /// Returns true if `threadLocal` has been explicitly set. - var hasThreadLocal: Bool {return _storage._threadLocal != nil} + var hasThreadLocal: Bool {_storage._threadLocal != nil} /// Clears the value of `threadLocal`. Subsequent reads from it will return its default value. mutating func clearThreadLocal() {_uniqueStorage()._threadLocal = nil} var typedef: Int32 { - get {return _storage._typedef ?? 0} + get {_storage._typedef ?? 0} set {_uniqueStorage()._typedef = newValue} } /// Returns true if `typedef` has been explicitly set. - var hasTypedef: Bool {return _storage._typedef != nil} + var hasTypedef: Bool {_storage._typedef != nil} /// Clears the value of `typedef`. Subsequent reads from it will return its default value. mutating func clearTypedef() {_uniqueStorage()._typedef = nil} var typeid: Int32 { - get {return _storage._typeid ?? 0} + get {_storage._typeid ?? 0} set {_uniqueStorage()._typeid = newValue} } /// Returns true if `typeid` has been explicitly set. - var hasTypeid: Bool {return _storage._typeid != nil} + var hasTypeid: Bool {_storage._typeid != nil} /// Clears the value of `typeid`. Subsequent reads from it will return its default value. mutating func clearTypeid() {_uniqueStorage()._typeid = nil} var typename: Int32 { - get {return _storage._typename ?? 0} + get {_storage._typename ?? 0} set {_uniqueStorage()._typename = newValue} } /// Returns true if `typename` has been explicitly set. - var hasTypename: Bool {return _storage._typename != nil} + var hasTypename: Bool {_storage._typename != nil} /// Clears the value of `typename`. Subsequent reads from it will return its default value. mutating func clearTypename() {_uniqueStorage()._typename = nil} var union: Int32 { - get {return _storage._union ?? 0} + get {_storage._union ?? 0} set {_uniqueStorage()._union = newValue} } /// Returns true if `union` has been explicitly set. - var hasUnion: Bool {return _storage._union != nil} + var hasUnion: Bool {_storage._union != nil} /// Clears the value of `union`. Subsequent reads from it will return its default value. mutating func clearUnion() {_uniqueStorage()._union = nil} var unsigned: Int32 { - get {return _storage._unsigned ?? 0} + get {_storage._unsigned ?? 0} set {_uniqueStorage()._unsigned = newValue} } /// Returns true if `unsigned` has been explicitly set. - var hasUnsigned: Bool {return _storage._unsigned != nil} + var hasUnsigned: Bool {_storage._unsigned != nil} /// Clears the value of `unsigned`. Subsequent reads from it will return its default value. mutating func clearUnsigned() {_uniqueStorage()._unsigned = nil} var using: Int32 { - get {return _storage._using ?? 0} + get {_storage._using ?? 0} set {_uniqueStorage()._using = newValue} } /// Returns true if `using` has been explicitly set. - var hasUsing: Bool {return _storage._using != nil} + var hasUsing: Bool {_storage._using != nil} /// Clears the value of `using`. Subsequent reads from it will return its default value. mutating func clearUsing() {_uniqueStorage()._using = nil} var virtual: Int32 { - get {return _storage._virtual ?? 0} + get {_storage._virtual ?? 0} set {_uniqueStorage()._virtual = newValue} } /// Returns true if `virtual` has been explicitly set. - var hasVirtual: Bool {return _storage._virtual != nil} + var hasVirtual: Bool {_storage._virtual != nil} /// Clears the value of `virtual`. Subsequent reads from it will return its default value. mutating func clearVirtual() {_uniqueStorage()._virtual = nil} var void: Int32 { - get {return _storage._void ?? 0} + get {_storage._void ?? 0} set {_uniqueStorage()._void = newValue} } /// Returns true if `void` has been explicitly set. - var hasVoid: Bool {return _storage._void != nil} + var hasVoid: Bool {_storage._void != nil} /// Clears the value of `void`. Subsequent reads from it will return its default value. mutating func clearVoid() {_uniqueStorage()._void = nil} var volatile: Int32 { - get {return _storage._volatile ?? 0} + get {_storage._volatile ?? 0} set {_uniqueStorage()._volatile = newValue} } /// Returns true if `volatile` has been explicitly set. - var hasVolatile: Bool {return _storage._volatile != nil} + var hasVolatile: Bool {_storage._volatile != nil} /// Clears the value of `volatile`. Subsequent reads from it will return its default value. mutating func clearVolatile() {_uniqueStorage()._volatile = nil} var wcharT: Int32 { - get {return _storage._wcharT ?? 0} + get {_storage._wcharT ?? 0} set {_uniqueStorage()._wcharT = newValue} } /// Returns true if `wcharT` has been explicitly set. - var hasWcharT: Bool {return _storage._wcharT != nil} + var hasWcharT: Bool {_storage._wcharT != nil} /// Clears the value of `wcharT`. Subsequent reads from it will return its default value. mutating func clearWcharT() {_uniqueStorage()._wcharT = nil} var xor: Int32 { - get {return _storage._xor ?? 0} + get {_storage._xor ?? 0} set {_uniqueStorage()._xor = newValue} } /// Returns true if `xor` has been explicitly set. - var hasXor: Bool {return _storage._xor != nil} + var hasXor: Bool {_storage._xor != nil} /// Clears the value of `xor`. Subsequent reads from it will return its default value. mutating func clearXor() {_uniqueStorage()._xor = nil} var xorEq: Int32 { - get {return _storage._xorEq ?? 0} + get {_storage._xorEq ?? 0} set {_uniqueStorage()._xorEq = newValue} } /// Returns true if `xorEq` has been explicitly set. - var hasXorEq: Bool {return _storage._xorEq != nil} + var hasXorEq: Bool {_storage._xorEq != nil} /// Clears the value of `xorEq`. Subsequent reads from it will return its default value. mutating func clearXorEq() {_uniqueStorage()._xorEq = nil} var restrict: Int32 { - get {return _storage._restrict ?? 0} + get {_storage._restrict ?? 0} set {_uniqueStorage()._restrict = newValue} } /// Returns true if `restrict` has been explicitly set. - var hasRestrict: Bool {return _storage._restrict != nil} + var hasRestrict: Bool {_storage._restrict != nil} /// Clears the value of `restrict`. Subsequent reads from it will return its default value. mutating func clearRestrict() {_uniqueStorage()._restrict = nil} var category: Int32 { - get {return _storage._category ?? 0} + get {_storage._category ?? 0} set {_uniqueStorage()._category = newValue} } /// Returns true if `category` has been explicitly set. - var hasCategory: Bool {return _storage._category != nil} + var hasCategory: Bool {_storage._category != nil} /// Clears the value of `category`. Subsequent reads from it will return its default value. mutating func clearCategory() {_uniqueStorage()._category = nil} var ivar: Int32 { - get {return _storage._ivar ?? 0} + get {_storage._ivar ?? 0} set {_uniqueStorage()._ivar = newValue} } /// Returns true if `ivar` has been explicitly set. - var hasIvar: Bool {return _storage._ivar != nil} + var hasIvar: Bool {_storage._ivar != nil} /// Clears the value of `ivar`. Subsequent reads from it will return its default value. mutating func clearIvar() {_uniqueStorage()._ivar = nil} var method: Int32 { - get {return _storage._method ?? 0} + get {_storage._method ?? 0} set {_uniqueStorage()._method = newValue} } /// Returns true if `method` has been explicitly set. - var hasMethod: Bool {return _storage._method != nil} + var hasMethod: Bool {_storage._method != nil} /// Clears the value of `method`. Subsequent reads from it will return its default value. mutating func clearMethod() {_uniqueStorage()._method = nil} var finalize: Int32 { - get {return _storage._finalize ?? 0} + get {_storage._finalize ?? 0} set {_uniqueStorage()._finalize = newValue} } /// Returns true if `finalize` has been explicitly set. - var hasFinalize: Bool {return _storage._finalize != nil} + var hasFinalize: Bool {_storage._finalize != nil} /// Clears the value of `finalize`. Subsequent reads from it will return its default value. mutating func clearFinalize() {_uniqueStorage()._finalize = nil} var hash: Int32 { - get {return _storage._hash ?? 0} + get {_storage._hash ?? 0} set {_uniqueStorage()._hash = newValue} } /// Returns true if `hash` has been explicitly set. - var hasHash: Bool {return _storage._hash != nil} + var hasHash: Bool {_storage._hash != nil} /// Clears the value of `hash`. Subsequent reads from it will return its default value. mutating func clearHash() {_uniqueStorage()._hash = nil} var dealloc: Int32 { - get {return _storage._dealloc ?? 0} + get {_storage._dealloc ?? 0} set {_uniqueStorage()._dealloc = newValue} } /// Returns true if `dealloc` has been explicitly set. - var hasDealloc: Bool {return _storage._dealloc != nil} + var hasDealloc: Bool {_storage._dealloc != nil} /// Clears the value of `dealloc`. Subsequent reads from it will return its default value. mutating func clearDealloc() {_uniqueStorage()._dealloc = nil} var superclass: Int32 { - get {return _storage._superclass ?? 0} + get {_storage._superclass ?? 0} set {_uniqueStorage()._superclass = newValue} } /// Returns true if `superclass` has been explicitly set. - var hasSuperclass: Bool {return _storage._superclass != nil} + var hasSuperclass: Bool {_storage._superclass != nil} /// Clears the value of `superclass`. Subsequent reads from it will return its default value. mutating func clearSuperclass() {_uniqueStorage()._superclass = nil} var retain: Int32 { - get {return _storage._retain ?? 0} + get {_storage._retain ?? 0} set {_uniqueStorage()._retain = newValue} } /// Returns true if `retain` has been explicitly set. - var hasRetain: Bool {return _storage._retain != nil} + var hasRetain: Bool {_storage._retain != nil} /// Clears the value of `retain`. Subsequent reads from it will return its default value. mutating func clearRetain() {_uniqueStorage()._retain = nil} var release: Int32 { - get {return _storage._release ?? 0} + get {_storage._release ?? 0} set {_uniqueStorage()._release = newValue} } /// Returns true if `release` has been explicitly set. - var hasRelease: Bool {return _storage._release != nil} + var hasRelease: Bool {_storage._release != nil} /// Clears the value of `release`. Subsequent reads from it will return its default value. mutating func clearRelease() {_uniqueStorage()._release = nil} var autorelease: Int32 { - get {return _storage._autorelease ?? 0} + get {_storage._autorelease ?? 0} set {_uniqueStorage()._autorelease = newValue} } /// Returns true if `autorelease` has been explicitly set. - var hasAutorelease: Bool {return _storage._autorelease != nil} + var hasAutorelease: Bool {_storage._autorelease != nil} /// Clears the value of `autorelease`. Subsequent reads from it will return its default value. mutating func clearAutorelease() {_uniqueStorage()._autorelease = nil} var retainCount: Int32 { - get {return _storage._retainCount ?? 0} + get {_storage._retainCount ?? 0} set {_uniqueStorage()._retainCount = newValue} } /// Returns true if `retainCount` has been explicitly set. - var hasRetainCount: Bool {return _storage._retainCount != nil} + var hasRetainCount: Bool {_storage._retainCount != nil} /// Clears the value of `retainCount`. Subsequent reads from it will return its default value. mutating func clearRetainCount() {_uniqueStorage()._retainCount = nil} var zone: Int32 { - get {return _storage._zone ?? 0} + get {_storage._zone ?? 0} set {_uniqueStorage()._zone = newValue} } /// Returns true if `zone` has been explicitly set. - var hasZone: Bool {return _storage._zone != nil} + var hasZone: Bool {_storage._zone != nil} /// Clears the value of `zone`. Subsequent reads from it will return its default value. mutating func clearZone() {_uniqueStorage()._zone = nil} var isProxy: Int32 { - get {return _storage._isProxy ?? 0} + get {_storage._isProxy ?? 0} set {_uniqueStorage()._isProxy = newValue} } /// Returns true if `isProxy` has been explicitly set. - var hasIsProxy: Bool {return _storage._isProxy != nil} + var hasIsProxy: Bool {_storage._isProxy != nil} /// Clears the value of `isProxy`. Subsequent reads from it will return its default value. mutating func clearIsProxy() {_uniqueStorage()._isProxy = nil} var copy: Int32 { - get {return _storage._copy ?? 0} + get {_storage._copy ?? 0} set {_uniqueStorage()._copy = newValue} } /// Returns true if `copy` has been explicitly set. - var hasCopy: Bool {return _storage._copy != nil} + var hasCopy: Bool {_storage._copy != nil} /// Clears the value of `copy`. Subsequent reads from it will return its default value. mutating func clearCopy() {_uniqueStorage()._copy = nil} var mutableCopy: Int32 { - get {return _storage._mutableCopy ?? 0} + get {_storage._mutableCopy ?? 0} set {_uniqueStorage()._mutableCopy = newValue} } /// Returns true if `mutableCopy` has been explicitly set. - var hasMutableCopy: Bool {return _storage._mutableCopy != nil} + var hasMutableCopy: Bool {_storage._mutableCopy != nil} /// Clears the value of `mutableCopy`. Subsequent reads from it will return its default value. mutating func clearMutableCopy() {_uniqueStorage()._mutableCopy = nil} var classForCoder: Int32 { - get {return _storage._classForCoder ?? 0} + get {_storage._classForCoder ?? 0} set {_uniqueStorage()._classForCoder = newValue} } /// Returns true if `classForCoder` has been explicitly set. - var hasClassForCoder: Bool {return _storage._classForCoder != nil} + var hasClassForCoder: Bool {_storage._classForCoder != nil} /// Clears the value of `classForCoder`. Subsequent reads from it will return its default value. mutating func clearClassForCoder() {_uniqueStorage()._classForCoder = nil} var clear: Int32 { - get {return _storage._clear ?? 0} + get {_storage._clear ?? 0} set {_uniqueStorage()._clear = newValue} } /// Returns true if `clear` has been explicitly set. - var hasClear: Bool {return _storage._clear != nil} + var hasClear: Bool {_storage._clear != nil} /// Clears the value of `clear`. Subsequent reads from it will return its default value. mutating func clearClear() {_uniqueStorage()._clear = nil} var data: Int32 { - get {return _storage._data ?? 0} + get {_storage._data ?? 0} set {_uniqueStorage()._data = newValue} } /// Returns true if `data` has been explicitly set. - var hasData: Bool {return _storage._data != nil} + var hasData: Bool {_storage._data != nil} /// Clears the value of `data`. Subsequent reads from it will return its default value. mutating func clearData() {_uniqueStorage()._data = nil} var delimitedData: Int32 { - get {return _storage._delimitedData ?? 0} + get {_storage._delimitedData ?? 0} set {_uniqueStorage()._delimitedData = newValue} } /// Returns true if `delimitedData` has been explicitly set. - var hasDelimitedData: Bool {return _storage._delimitedData != nil} + var hasDelimitedData: Bool {_storage._delimitedData != nil} /// Clears the value of `delimitedData`. Subsequent reads from it will return its default value. mutating func clearDelimitedData() {_uniqueStorage()._delimitedData = nil} var descriptor: Int32 { - get {return _storage._descriptor ?? 0} + get {_storage._descriptor ?? 0} set {_uniqueStorage()._descriptor = newValue} } /// Returns true if `descriptor` has been explicitly set. - var hasDescriptor: Bool {return _storage._descriptor != nil} + var hasDescriptor: Bool {_storage._descriptor != nil} /// Clears the value of `descriptor`. Subsequent reads from it will return its default value. mutating func clearDescriptor() {_uniqueStorage()._descriptor = nil} var extensionRegistry: Int32 { - get {return _storage._extensionRegistry ?? 0} + get {_storage._extensionRegistry ?? 0} set {_uniqueStorage()._extensionRegistry = newValue} } /// Returns true if `extensionRegistry` has been explicitly set. - var hasExtensionRegistry: Bool {return _storage._extensionRegistry != nil} + var hasExtensionRegistry: Bool {_storage._extensionRegistry != nil} /// Clears the value of `extensionRegistry`. Subsequent reads from it will return its default value. mutating func clearExtensionRegistry() {_uniqueStorage()._extensionRegistry = nil} var extensionsCurrentlySet: Int32 { - get {return _storage._extensionsCurrentlySet ?? 0} + get {_storage._extensionsCurrentlySet ?? 0} set {_uniqueStorage()._extensionsCurrentlySet = newValue} } /// Returns true if `extensionsCurrentlySet` has been explicitly set. - var hasExtensionsCurrentlySet: Bool {return _storage._extensionsCurrentlySet != nil} + var hasExtensionsCurrentlySet: Bool {_storage._extensionsCurrentlySet != nil} /// Clears the value of `extensionsCurrentlySet`. Subsequent reads from it will return its default value. mutating func clearExtensionsCurrentlySet() {_uniqueStorage()._extensionsCurrentlySet = nil} var isInitialized_p: Int32 { - get {return _storage._isInitialized_p ?? 0} + get {_storage._isInitialized_p ?? 0} set {_uniqueStorage()._isInitialized_p = newValue} } /// Returns true if `isInitialized_p` has been explicitly set. - var hasIsInitialized_p: Bool {return _storage._isInitialized_p != nil} + var hasIsInitialized_p: Bool {_storage._isInitialized_p != nil} /// Clears the value of `isInitialized_p`. Subsequent reads from it will return its default value. mutating func clearIsInitialized_p() {_uniqueStorage()._isInitialized_p = nil} var serializedSize: Int32 { - get {return _storage._serializedSize ?? 0} + get {_storage._serializedSize ?? 0} set {_uniqueStorage()._serializedSize = newValue} } /// Returns true if `serializedSize` has been explicitly set. - var hasSerializedSize: Bool {return _storage._serializedSize != nil} + var hasSerializedSize: Bool {_storage._serializedSize != nil} /// Clears the value of `serializedSize`. Subsequent reads from it will return its default value. mutating func clearSerializedSize() {_uniqueStorage()._serializedSize = nil} var sortedExtensionsInUse: Int32 { - get {return _storage._sortedExtensionsInUse ?? 0} + get {_storage._sortedExtensionsInUse ?? 0} set {_uniqueStorage()._sortedExtensionsInUse = newValue} } /// Returns true if `sortedExtensionsInUse` has been explicitly set. - var hasSortedExtensionsInUse: Bool {return _storage._sortedExtensionsInUse != nil} + var hasSortedExtensionsInUse: Bool {_storage._sortedExtensionsInUse != nil} /// Clears the value of `sortedExtensionsInUse`. Subsequent reads from it will return its default value. mutating func clearSortedExtensionsInUse() {_uniqueStorage()._sortedExtensionsInUse = nil} var unknownFields_p: Int32 { - get {return _storage._unknownFields_p ?? 0} + get {_storage._unknownFields_p ?? 0} set {_uniqueStorage()._unknownFields_p = newValue} } /// Returns true if `unknownFields_p` has been explicitly set. - var hasUnknownFields_p: Bool {return _storage._unknownFields_p != nil} + var hasUnknownFields_p: Bool {_storage._unknownFields_p != nil} /// Clears the value of `unknownFields_p`. Subsequent reads from it will return its default value. mutating func clearUnknownFields_p() {_uniqueStorage()._unknownFields_p = nil} var fixed: Int32 { - get {return _storage._fixed ?? 0} + get {_storage._fixed ?? 0} set {_uniqueStorage()._fixed = newValue} } /// Returns true if `fixed` has been explicitly set. - var hasFixed: Bool {return _storage._fixed != nil} + var hasFixed: Bool {_storage._fixed != nil} /// Clears the value of `fixed`. Subsequent reads from it will return its default value. mutating func clearFixed() {_uniqueStorage()._fixed = nil} var fract: Int32 { - get {return _storage._fract ?? 0} + get {_storage._fract ?? 0} set {_uniqueStorage()._fract = newValue} } /// Returns true if `fract` has been explicitly set. - var hasFract: Bool {return _storage._fract != nil} + var hasFract: Bool {_storage._fract != nil} /// Clears the value of `fract`. Subsequent reads from it will return its default value. mutating func clearFract() {_uniqueStorage()._fract = nil} var size: Int32 { - get {return _storage._size ?? 0} + get {_storage._size ?? 0} set {_uniqueStorage()._size = newValue} } /// Returns true if `size` has been explicitly set. - var hasSize: Bool {return _storage._size != nil} + var hasSize: Bool {_storage._size != nil} /// Clears the value of `size`. Subsequent reads from it will return its default value. mutating func clearSize() {_uniqueStorage()._size = nil} var logicalAddress: Int32 { - get {return _storage._logicalAddress ?? 0} + get {_storage._logicalAddress ?? 0} set {_uniqueStorage()._logicalAddress = newValue} } /// Returns true if `logicalAddress` has been explicitly set. - var hasLogicalAddress: Bool {return _storage._logicalAddress != nil} + var hasLogicalAddress: Bool {_storage._logicalAddress != nil} /// Clears the value of `logicalAddress`. Subsequent reads from it will return its default value. mutating func clearLogicalAddress() {_uniqueStorage()._logicalAddress = nil} var physicalAddress: Int32 { - get {return _storage._physicalAddress ?? 0} + get {_storage._physicalAddress ?? 0} set {_uniqueStorage()._physicalAddress = newValue} } /// Returns true if `physicalAddress` has been explicitly set. - var hasPhysicalAddress: Bool {return _storage._physicalAddress != nil} + var hasPhysicalAddress: Bool {_storage._physicalAddress != nil} /// Clears the value of `physicalAddress`. Subsequent reads from it will return its default value. mutating func clearPhysicalAddress() {_uniqueStorage()._physicalAddress = nil} var byteCount: Int32 { - get {return _storage._byteCount ?? 0} + get {_storage._byteCount ?? 0} set {_uniqueStorage()._byteCount = newValue} } /// Returns true if `byteCount` has been explicitly set. - var hasByteCount: Bool {return _storage._byteCount != nil} + var hasByteCount: Bool {_storage._byteCount != nil} /// Clears the value of `byteCount`. Subsequent reads from it will return its default value. mutating func clearByteCount() {_uniqueStorage()._byteCount = nil} var byteOffset: Int32 { - get {return _storage._byteOffset ?? 0} + get {_storage._byteOffset ?? 0} set {_uniqueStorage()._byteOffset = newValue} } /// Returns true if `byteOffset` has been explicitly set. - var hasByteOffset: Bool {return _storage._byteOffset != nil} + var hasByteOffset: Bool {_storage._byteOffset != nil} /// Clears the value of `byteOffset`. Subsequent reads from it will return its default value. mutating func clearByteOffset() {_uniqueStorage()._byteOffset = nil} var duration: Int32 { - get {return _storage._duration ?? 0} + get {_storage._duration ?? 0} set {_uniqueStorage()._duration = newValue} } /// Returns true if `duration` has been explicitly set. - var hasDuration: Bool {return _storage._duration != nil} + var hasDuration: Bool {_storage._duration != nil} /// Clears the value of `duration`. Subsequent reads from it will return its default value. mutating func clearDuration() {_uniqueStorage()._duration = nil} var absoluteTime: Int32 { - get {return _storage._absoluteTime ?? 0} + get {_storage._absoluteTime ?? 0} set {_uniqueStorage()._absoluteTime = newValue} } /// Returns true if `absoluteTime` has been explicitly set. - var hasAbsoluteTime: Bool {return _storage._absoluteTime != nil} + var hasAbsoluteTime: Bool {_storage._absoluteTime != nil} /// Clears the value of `absoluteTime`. Subsequent reads from it will return its default value. mutating func clearAbsoluteTime() {_uniqueStorage()._absoluteTime = nil} var optionBits: Int32 { - get {return _storage._optionBits ?? 0} + get {_storage._optionBits ?? 0} set {_uniqueStorage()._optionBits = newValue} } /// Returns true if `optionBits` has been explicitly set. - var hasOptionBits: Bool {return _storage._optionBits != nil} + var hasOptionBits: Bool {_storage._optionBits != nil} /// Clears the value of `optionBits`. Subsequent reads from it will return its default value. mutating func clearOptionBits() {_uniqueStorage()._optionBits = nil} var itemCount: Int32 { - get {return _storage._itemCount ?? 0} + get {_storage._itemCount ?? 0} set {_uniqueStorage()._itemCount = newValue} } /// Returns true if `itemCount` has been explicitly set. - var hasItemCount: Bool {return _storage._itemCount != nil} + var hasItemCount: Bool {_storage._itemCount != nil} /// Clears the value of `itemCount`. Subsequent reads from it will return its default value. mutating func clearItemCount() {_uniqueStorage()._itemCount = nil} var pbversion: Int32 { - get {return _storage._pbversion ?? 0} + get {_storage._pbversion ?? 0} set {_uniqueStorage()._pbversion = newValue} } /// Returns true if `pbversion` has been explicitly set. - var hasPbversion: Bool {return _storage._pbversion != nil} + var hasPbversion: Bool {_storage._pbversion != nil} /// Clears the value of `pbversion`. Subsequent reads from it will return its default value. mutating func clearPbversion() {_uniqueStorage()._pbversion = nil} var scriptCode: Int32 { - get {return _storage._scriptCode ?? 0} + get {_storage._scriptCode ?? 0} set {_uniqueStorage()._scriptCode = newValue} } /// Returns true if `scriptCode` has been explicitly set. - var hasScriptCode: Bool {return _storage._scriptCode != nil} + var hasScriptCode: Bool {_storage._scriptCode != nil} /// Clears the value of `scriptCode`. Subsequent reads from it will return its default value. mutating func clearScriptCode() {_uniqueStorage()._scriptCode = nil} var langCode: Int32 { - get {return _storage._langCode ?? 0} + get {_storage._langCode ?? 0} set {_uniqueStorage()._langCode = newValue} } /// Returns true if `langCode` has been explicitly set. - var hasLangCode: Bool {return _storage._langCode != nil} + var hasLangCode: Bool {_storage._langCode != nil} /// Clears the value of `langCode`. Subsequent reads from it will return its default value. mutating func clearLangCode() {_uniqueStorage()._langCode = nil} var regionCode: Int32 { - get {return _storage._regionCode ?? 0} + get {_storage._regionCode ?? 0} set {_uniqueStorage()._regionCode = newValue} } /// Returns true if `regionCode` has been explicitly set. - var hasRegionCode: Bool {return _storage._regionCode != nil} + var hasRegionCode: Bool {_storage._regionCode != nil} /// Clears the value of `regionCode`. Subsequent reads from it will return its default value. mutating func clearRegionCode() {_uniqueStorage()._regionCode = nil} var ostype: Int32 { - get {return _storage._ostype ?? 0} + get {_storage._ostype ?? 0} set {_uniqueStorage()._ostype = newValue} } /// Returns true if `ostype` has been explicitly set. - var hasOstype: Bool {return _storage._ostype != nil} + var hasOstype: Bool {_storage._ostype != nil} /// Clears the value of `ostype`. Subsequent reads from it will return its default value. mutating func clearOstype() {_uniqueStorage()._ostype = nil} var processSerialNumber: Int32 { - get {return _storage._processSerialNumber ?? 0} + get {_storage._processSerialNumber ?? 0} set {_uniqueStorage()._processSerialNumber = newValue} } /// Returns true if `processSerialNumber` has been explicitly set. - var hasProcessSerialNumber: Bool {return _storage._processSerialNumber != nil} + var hasProcessSerialNumber: Bool {_storage._processSerialNumber != nil} /// Clears the value of `processSerialNumber`. Subsequent reads from it will return its default value. mutating func clearProcessSerialNumber() {_uniqueStorage()._processSerialNumber = nil} var point: Int32 { - get {return _storage._point ?? 0} + get {_storage._point ?? 0} set {_uniqueStorage()._point = newValue} } /// Returns true if `point` has been explicitly set. - var hasPoint: Bool {return _storage._point != nil} + var hasPoint: Bool {_storage._point != nil} /// Clears the value of `point`. Subsequent reads from it will return its default value. mutating func clearPoint() {_uniqueStorage()._point = nil} var rect: Int32 { - get {return _storage._rect ?? 0} + get {_storage._rect ?? 0} set {_uniqueStorage()._rect = newValue} } /// Returns true if `rect` has been explicitly set. - var hasRect: Bool {return _storage._rect != nil} + var hasRect: Bool {_storage._rect != nil} /// Clears the value of `rect`. Subsequent reads from it will return its default value. mutating func clearRect() {_uniqueStorage()._rect = nil} var fixedPoint: Int32 { - get {return _storage._fixedPoint ?? 0} + get {_storage._fixedPoint ?? 0} set {_uniqueStorage()._fixedPoint = newValue} } /// Returns true if `fixedPoint` has been explicitly set. - var hasFixedPoint: Bool {return _storage._fixedPoint != nil} + var hasFixedPoint: Bool {_storage._fixedPoint != nil} /// Clears the value of `fixedPoint`. Subsequent reads from it will return its default value. mutating func clearFixedPoint() {_uniqueStorage()._fixedPoint = nil} var fixedRect: Int32 { - get {return _storage._fixedRect ?? 0} + get {_storage._fixedRect ?? 0} set {_uniqueStorage()._fixedRect = newValue} } /// Returns true if `fixedRect` has been explicitly set. - var hasFixedRect: Bool {return _storage._fixedRect != nil} + var hasFixedRect: Bool {_storage._fixedRect != nil} /// Clears the value of `fixedRect`. Subsequent reads from it will return its default value. mutating func clearFixedRect() {_uniqueStorage()._fixedRect = nil} var style: Int32 { - get {return _storage._style ?? 0} + get {_storage._style ?? 0} set {_uniqueStorage()._style = newValue} } /// Returns true if `style` has been explicitly set. - var hasStyle: Bool {return _storage._style != nil} + var hasStyle: Bool {_storage._style != nil} /// Clears the value of `style`. Subsequent reads from it will return its default value. mutating func clearStyle() {_uniqueStorage()._style = nil} var styleParameter: Int32 { - get {return _storage._styleParameter ?? 0} + get {_storage._styleParameter ?? 0} set {_uniqueStorage()._styleParameter = newValue} } /// Returns true if `styleParameter` has been explicitly set. - var hasStyleParameter: Bool {return _storage._styleParameter != nil} + var hasStyleParameter: Bool {_storage._styleParameter != nil} /// Clears the value of `styleParameter`. Subsequent reads from it will return its default value. mutating func clearStyleParameter() {_uniqueStorage()._styleParameter = nil} var styleField: Int32 { - get {return _storage._styleField ?? 0} + get {_storage._styleField ?? 0} set {_uniqueStorage()._styleField = newValue} } /// Returns true if `styleField` has been explicitly set. - var hasStyleField: Bool {return _storage._styleField != nil} + var hasStyleField: Bool {_storage._styleField != nil} /// Clears the value of `styleField`. Subsequent reads from it will return its default value. mutating func clearStyleField() {_uniqueStorage()._styleField = nil} var timeScale: Int32 { - get {return _storage._timeScale ?? 0} + get {_storage._timeScale ?? 0} set {_uniqueStorage()._timeScale = newValue} } /// Returns true if `timeScale` has been explicitly set. - var hasTimeScale: Bool {return _storage._timeScale != nil} + var hasTimeScale: Bool {_storage._timeScale != nil} /// Clears the value of `timeScale`. Subsequent reads from it will return its default value. mutating func clearTimeScale() {_uniqueStorage()._timeScale = nil} var timeBase: Int32 { - get {return _storage._timeBase ?? 0} + get {_storage._timeBase ?? 0} set {_uniqueStorage()._timeBase = newValue} } /// Returns true if `timeBase` has been explicitly set. - var hasTimeBase: Bool {return _storage._timeBase != nil} + var hasTimeBase: Bool {_storage._timeBase != nil} /// Clears the value of `timeBase`. Subsequent reads from it will return its default value. mutating func clearTimeBase() {_uniqueStorage()._timeBase = nil} var timeRecord: Int32 { - get {return _storage._timeRecord ?? 0} + get {_storage._timeRecord ?? 0} set {_uniqueStorage()._timeRecord = newValue} } /// Returns true if `timeRecord` has been explicitly set. - var hasTimeRecord: Bool {return _storage._timeRecord != nil} + var hasTimeRecord: Bool {_storage._timeRecord != nil} /// Clears the value of `timeRecord`. Subsequent reads from it will return its default value. mutating func clearTimeRecord() {_uniqueStorage()._timeRecord = nil} - var jsonShouldBeOverriden: Int32 { - get {return _storage._jsonShouldBeOverriden ?? 0} - set {_uniqueStorage()._jsonShouldBeOverriden = newValue} + var jsonShouldBeOverridden: Int32 { + get {_storage._jsonShouldBeOverridden ?? 0} + set {_uniqueStorage()._jsonShouldBeOverridden = newValue} } - /// Returns true if `jsonShouldBeOverriden` has been explicitly set. - var hasJsonShouldBeOverriden: Bool {return _storage._jsonShouldBeOverriden != nil} - /// Clears the value of `jsonShouldBeOverriden`. Subsequent reads from it will return its default value. - mutating func clearJsonShouldBeOverriden() {_uniqueStorage()._jsonShouldBeOverriden = nil} + /// Returns true if `jsonShouldBeOverridden` has been explicitly set. + var hasJsonShouldBeOverridden: Bool {_storage._jsonShouldBeOverridden != nil} + /// Clears the value of `jsonShouldBeOverridden`. Subsequent reads from it will return its default value. + mutating func clearJsonShouldBeOverridden() {_uniqueStorage()._jsonShouldBeOverridden = nil} var any: Int32 { - get {return _storage._any ?? 0} + get {_storage._any ?? 0} set {_uniqueStorage()._any = newValue} } /// Returns true if `any` has been explicitly set. - var hasAny: Bool {return _storage._any != nil} + var hasAny: Bool {_storage._any != nil} /// Clears the value of `any`. Subsequent reads from it will return its default value. mutating func clearAny() {_uniqueStorage()._any = nil} var int32: Int32 { - get {return _storage._int32 ?? 0} + get {_storage._int32 ?? 0} set {_uniqueStorage()._int32 = newValue} } /// Returns true if `int32` has been explicitly set. - var hasInt32: Bool {return _storage._int32 != nil} + var hasInt32: Bool {_storage._int32 != nil} /// Clears the value of `int32`. Subsequent reads from it will return its default value. mutating func clearInt32() {_uniqueStorage()._int32 = nil} var int64: Int32 { - get {return _storage._int64 ?? 0} + get {_storage._int64 ?? 0} set {_uniqueStorage()._int64 = newValue} } /// Returns true if `int64` has been explicitly set. - var hasInt64: Bool {return _storage._int64 != nil} + var hasInt64: Bool {_storage._int64 != nil} /// Clears the value of `int64`. Subsequent reads from it will return its default value. mutating func clearInt64() {_uniqueStorage()._int64 = nil} var uint32: Int32 { - get {return _storage._uint32 ?? 0} + get {_storage._uint32 ?? 0} set {_uniqueStorage()._uint32 = newValue} } /// Returns true if `uint32` has been explicitly set. - var hasUint32: Bool {return _storage._uint32 != nil} + var hasUint32: Bool {_storage._uint32 != nil} /// Clears the value of `uint32`. Subsequent reads from it will return its default value. mutating func clearUint32() {_uniqueStorage()._uint32 = nil} var uint64: Int32 { - get {return _storage._uint64 ?? 0} + get {_storage._uint64 ?? 0} set {_uniqueStorage()._uint64 = newValue} } /// Returns true if `uint64` has been explicitly set. - var hasUint64: Bool {return _storage._uint64 != nil} + var hasUint64: Bool {_storage._uint64 != nil} /// Clears the value of `uint64`. Subsequent reads from it will return its default value. mutating func clearUint64() {_uniqueStorage()._uint64 = nil} var `associatedtype`: Int32 { - get {return _storage._associatedtype ?? 0} + get {_storage._associatedtype ?? 0} set {_uniqueStorage()._associatedtype = newValue} } /// Returns true if ``associatedtype`` has been explicitly set. - var hasAssociatedtype: Bool {return _storage._associatedtype != nil} + var hasAssociatedtype: Bool {_storage._associatedtype != nil} /// Clears the value of ``associatedtype``. Subsequent reads from it will return its default value. mutating func clearAssociatedtype() {_uniqueStorage()._associatedtype = nil} var `fileprivate`: Int32 { - get {return _storage._fileprivate ?? 0} + get {_storage._fileprivate ?? 0} set {_uniqueStorage()._fileprivate = newValue} } /// Returns true if ``fileprivate`` has been explicitly set. - var hasFileprivate: Bool {return _storage._fileprivate != nil} + var hasFileprivate: Bool {_storage._fileprivate != nil} /// Clears the value of ``fileprivate``. Subsequent reads from it will return its default value. mutating func clearFileprivate() {_uniqueStorage()._fileprivate = nil} var `open`: Int32 { - get {return _storage._open ?? 0} + get {_storage._open ?? 0} set {_uniqueStorage()._open = newValue} } /// Returns true if ``open`` has been explicitly set. - var hasOpen: Bool {return _storage._open != nil} + var hasOpen: Bool {_storage._open != nil} /// Clears the value of ``open``. Subsequent reads from it will return its default value. mutating func clearOpen() {_uniqueStorage()._open = nil} var serializedData: Int32 { - get {return _storage._serializedData ?? 0} + get {_storage._serializedData ?? 0} set {_uniqueStorage()._serializedData = newValue} } /// Returns true if `serializedData` has been explicitly set. - var hasSerializedData: Bool {return _storage._serializedData != nil} + var hasSerializedData: Bool {_storage._serializedData != nil} /// Clears the value of `serializedData`. Subsequent reads from it will return its default value. mutating func clearSerializedData() {_uniqueStorage()._serializedData = nil} var hasSerializedData_p: Int32 { - get {return _storage._hasSerializedData_p ?? 0} + get {_storage._hasSerializedData_p ?? 0} set {_uniqueStorage()._hasSerializedData_p = newValue} } /// Returns true if `hasSerializedData_p` has been explicitly set. - var hasHasSerializedData_p: Bool {return _storage._hasSerializedData_p != nil} + var hasHasSerializedData_p: Bool {_storage._hasSerializedData_p != nil} /// Clears the value of `hasSerializedData_p`. Subsequent reads from it will return its default value. mutating func clearHasSerializedData_p() {_uniqueStorage()._hasSerializedData_p = nil} var clearSerializedData_p: Int32 { - get {return _storage._clearSerializedData_p ?? 0} + get {_storage._clearSerializedData_p ?? 0} set {_uniqueStorage()._clearSerializedData_p = newValue} } /// Returns true if `clearSerializedData_p` has been explicitly set. - var hasClearSerializedData_p: Bool {return _storage._clearSerializedData_p != nil} + var hasClearSerializedData_p: Bool {_storage._clearSerializedData_p != nil} /// Clears the value of `clearSerializedData_p`. Subsequent reads from it will return its default value. mutating func clearClearSerializedData_p() {_uniqueStorage()._clearSerializedData_p = nil} var jsonUtf8Data: Int32 { - get {return _storage._jsonUtf8Data ?? 0} + get {_storage._jsonUtf8Data ?? 0} set {_uniqueStorage()._jsonUtf8Data = newValue} } /// Returns true if `jsonUtf8Data` has been explicitly set. - var hasJsonUtf8Data: Bool {return _storage._jsonUtf8Data != nil} + var hasJsonUtf8Data: Bool {_storage._jsonUtf8Data != nil} /// Clears the value of `jsonUtf8Data`. Subsequent reads from it will return its default value. mutating func clearJsonUtf8Data() {_uniqueStorage()._jsonUtf8Data = nil} var jsonString: Int32 { - get {return _storage._jsonString ?? 0} + get {_storage._jsonString ?? 0} set {_uniqueStorage()._jsonString = newValue} } /// Returns true if `jsonString` has been explicitly set. - var hasJsonString: Bool {return _storage._jsonString != nil} + var hasJsonString: Bool {_storage._jsonString != nil} /// Clears the value of `jsonString`. Subsequent reads from it will return its default value. mutating func clearJsonString() {_uniqueStorage()._jsonString = nil} var `extension`: Int32 { - get {return _storage._extension ?? 0} + get {_storage._extension ?? 0} set {_uniqueStorage()._extension = newValue} } /// Returns true if ``extension`` has been explicitly set. - var hasExtension: Bool {return _storage._extension != nil} + var hasExtension: Bool {_storage._extension != nil} /// Clears the value of ``extension``. Subsequent reads from it will return its default value. mutating func clearExtension() {_uniqueStorage()._extension = nil} var extensions: Int32 { - get {return _storage._extensions ?? 0} + get {_storage._extensions ?? 0} set {_uniqueStorage()._extensions = newValue} } /// Returns true if `extensions` has been explicitly set. - var hasExtensions: Bool {return _storage._extensions != nil} + var hasExtensions: Bool {_storage._extensions != nil} /// Clears the value of `extensions`. Subsequent reads from it will return its default value. mutating func clearExtensions() {_uniqueStorage()._extensions = nil} @@ -2756,24 +2296,24 @@ struct SwiftUnittest_Names_FieldNames { fileprivate var _storage = _StorageClass.defaultInstance } -struct SwiftUnittest_Names_MessageNames { +struct SwiftProtoTesting_Names_MessageNames: Sendable { // 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() - struct StringMessage { + struct StringMessage: Sendable { // 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 string: Int32 { - get {return _string ?? 0} + get {_string ?? 0} set {_string = newValue} } /// Returns true if `string` has been explicitly set. - var hasString: Bool {return self._string != nil} + var hasString: Bool {self._string != nil} /// Clears the value of `string`. Subsequent reads from it will return its default value. mutating func clearString() {self._string = nil} @@ -2784,17 +2324,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _string: Int32? = nil } - struct ProtocolMessage { + struct ProtocolMessage: Sendable { // 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 `protocol`: Int32 { - get {return _protocol ?? 0} + get {_protocol ?? 0} set {_protocol = newValue} } /// Returns true if ``protocol`` has been explicitly set. - var hasProtocol: Bool {return self._protocol != nil} + var hasProtocol: Bool {self._protocol != nil} /// Clears the value of ``protocol``. Subsequent reads from it will return its default value. mutating func clearProtocol() {self._protocol = nil} @@ -2805,17 +2345,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _protocol: Int32? = nil } - struct IntMessage { + struct IntMessage: Sendable { // 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 int: Int32 { - get {return _int ?? 0} + get {_int ?? 0} set {_int = newValue} } /// Returns true if `int` has been explicitly set. - var hasInt: Bool {return self._int != nil} + var hasInt: Bool {self._int != nil} /// Clears the value of `int`. Subsequent reads from it will return its default value. mutating func clearInt() {self._int = nil} @@ -2826,17 +2366,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _int: Int32? = nil } - struct DoubleMessage { + struct DoubleMessage: Sendable { // 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 double: Int32 { - get {return _double ?? 0} + get {_double ?? 0} set {_double = newValue} } /// Returns true if `double` has been explicitly set. - var hasDouble: Bool {return self._double != nil} + var hasDouble: Bool {self._double != nil} /// Clears the value of `double`. Subsequent reads from it will return its default value. mutating func clearDouble() {self._double = nil} @@ -2847,17 +2387,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _double: Int32? = nil } - struct FloatMessage { + struct FloatMessage: Sendable { // 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 float: Int32 { - get {return _float ?? 0} + get {_float ?? 0} set {_float = newValue} } /// Returns true if `float` has been explicitly set. - var hasFloat: Bool {return self._float != nil} + var hasFloat: Bool {self._float != nil} /// Clears the value of `float`. Subsequent reads from it will return its default value. mutating func clearFloat() {self._float = nil} @@ -2868,17 +2408,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _float: Int32? = nil } - struct UIntMessage { + struct UIntMessage: Sendable { // 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 uint: Int32 { - get {return _uint ?? 0} + get {_uint ?? 0} set {_uint = newValue} } /// Returns true if `uint` has been explicitly set. - var hasUint: Bool {return self._uint != nil} + var hasUint: Bool {self._uint != nil} /// Clears the value of `uint`. Subsequent reads from it will return its default value. mutating func clearUint() {self._uint = nil} @@ -2889,17 +2429,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _uint: Int32? = nil } - struct hashValueMessage { + struct hashValueMessage: Sendable { // 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 hashValue_p: Int32 { - get {return _hashValue_p ?? 0} + get {_hashValue_p ?? 0} set {_hashValue_p = newValue} } /// Returns true if `hashValue_p` has been explicitly set. - var hasHashValue_p: Bool {return self._hashValue_p != nil} + var hasHashValue_p: Bool {self._hashValue_p != nil} /// Clears the value of `hashValue_p`. Subsequent reads from it will return its default value. mutating func clearHashValue_p() {self._hashValue_p = nil} @@ -2910,17 +2450,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _hashValue_p: Int32? = nil } - struct descriptionMessage { + struct descriptionMessage: Sendable { // 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 description_p: Int32 { - get {return _description_p ?? 0} + get {_description_p ?? 0} set {_description_p = newValue} } /// Returns true if `description_p` has been explicitly set. - var hasDescription_p: Bool {return self._description_p != nil} + var hasDescription_p: Bool {self._description_p != nil} /// Clears the value of `description_p`. Subsequent reads from it will return its default value. mutating func clearDescription_p() {self._description_p = nil} @@ -2931,17 +2471,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _description_p: Int32? = nil } - struct debugDescriptionMessage { + struct debugDescriptionMessage: Sendable { // 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 debugDescription_p: Int32 { - get {return _debugDescription_p ?? 0} + get {_debugDescription_p ?? 0} set {_debugDescription_p = newValue} } /// Returns true if `debugDescription_p` has been explicitly set. - var hasDebugDescription_p: Bool {return self._debugDescription_p != nil} + var hasDebugDescription_p: Bool {self._debugDescription_p != nil} /// Clears the value of `debugDescription_p`. Subsequent reads from it will return its default value. mutating func clearDebugDescription_p() {self._debugDescription_p = nil} @@ -2952,17 +2492,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _debugDescription_p: Int32? = nil } - struct Swift { + struct SwiftMessage: Sendable { // 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 swift: Int32 { - get {return _swift ?? 0} + get {_swift ?? 0} set {_swift = newValue} } /// Returns true if `swift` has been explicitly set. - var hasSwift: Bool {return self._swift != nil} + var hasSwift: Bool {self._swift != nil} /// Clears the value of `swift`. Subsequent reads from it will return its default value. mutating func clearSwift() {self._swift = nil} @@ -2973,17 +2513,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _swift: Int32? = nil } - struct UNRECOGNIZED { + struct UNRECOGNIZED: Sendable { // 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 unrecognized: Int32 { - get {return _unrecognized ?? 0} + get {_unrecognized ?? 0} set {_unrecognized = newValue} } /// Returns true if `unrecognized` has been explicitly set. - var hasUnrecognized: Bool {return self._unrecognized != nil} + var hasUnrecognized: Bool {self._unrecognized != nil} /// Clears the value of `unrecognized`. Subsequent reads from it will return its default value. mutating func clearUnrecognized() {self._unrecognized = nil} @@ -2994,17 +2534,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _unrecognized: Int32? = nil } - struct classMessage { + struct classMessage: Sendable { // 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 `class`: Int32 { - get {return _class ?? 0} + get {_class ?? 0} set {_class = newValue} } /// Returns true if ``class`` has been explicitly set. - var hasClass: Bool {return self._class != nil} + var hasClass: Bool {self._class != nil} /// Clears the value of ``class``. Subsequent reads from it will return its default value. mutating func clearClass() {self._class = nil} @@ -3015,17 +2555,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _class: Int32? = nil } - struct deinitMessage { + struct deinitMessage: Sendable { // 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 `deinit`: Int32 { - get {return _deinit ?? 0} + get {_deinit ?? 0} set {_deinit = newValue} } /// Returns true if ``deinit`` has been explicitly set. - var hasDeinit: Bool {return self._deinit != nil} + var hasDeinit: Bool {self._deinit != nil} /// Clears the value of ``deinit``. Subsequent reads from it will return its default value. mutating func clearDeinit() {self._deinit = nil} @@ -3036,17 +2576,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _deinit: Int32? = nil } - struct enumMessage { + struct enumMessage: Sendable { // 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 `enum`: Int32 { - get {return _enum ?? 0} + get {_enum ?? 0} set {_enum = newValue} } /// Returns true if ``enum`` has been explicitly set. - var hasEnum: Bool {return self._enum != nil} + var hasEnum: Bool {self._enum != nil} /// Clears the value of ``enum``. Subsequent reads from it will return its default value. mutating func clearEnum() {self._enum = nil} @@ -3057,17 +2597,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _enum: Int32? = nil } - struct extensionMessage { + struct extensionMessage: Sendable { // 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 `extension`: Int32 { - get {return _extension ?? 0} + get {_extension ?? 0} set {_extension = newValue} } /// Returns true if ``extension`` has been explicitly set. - var hasExtension: Bool {return self._extension != nil} + var hasExtension: Bool {self._extension != nil} /// Clears the value of ``extension``. Subsequent reads from it will return its default value. mutating func clearExtension() {self._extension = nil} @@ -3078,17 +2618,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _extension: Int32? = nil } - struct funcMessage { + struct funcMessage: Sendable { // 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 `func`: Int32 { - get {return _func ?? 0} + get {_func ?? 0} set {_func = newValue} } /// Returns true if ``func`` has been explicitly set. - var hasFunc: Bool {return self._func != nil} + var hasFunc: Bool {self._func != nil} /// Clears the value of ``func``. Subsequent reads from it will return its default value. mutating func clearFunc() {self._func = nil} @@ -3099,17 +2639,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _func: Int32? = nil } - struct importMessage { + struct importMessage: Sendable { // 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 `import`: Int32 { - get {return _import ?? 0} + get {_import ?? 0} set {_import = newValue} } /// Returns true if ``import`` has been explicitly set. - var hasImport: Bool {return self._import != nil} + var hasImport: Bool {self._import != nil} /// Clears the value of ``import``. Subsequent reads from it will return its default value. mutating func clearImport() {self._import = nil} @@ -3120,17 +2660,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _import: Int32? = nil } - struct initMessage { + struct initMessage: Sendable { // 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 init_p: Int32 { - get {return _init_p ?? 0} + get {_init_p ?? 0} set {_init_p = newValue} } /// Returns true if `init_p` has been explicitly set. - var hasInit_p: Bool {return self._init_p != nil} + var hasInit_p: Bool {self._init_p != nil} /// Clears the value of `init_p`. Subsequent reads from it will return its default value. mutating func clearInit_p() {self._init_p = nil} @@ -3141,17 +2681,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _init_p: Int32? = nil } - struct inoutMessage { + struct inoutMessage: Sendable { // 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 `inout`: Int32 { - get {return _inout ?? 0} + get {_inout ?? 0} set {_inout = newValue} } /// Returns true if ``inout`` has been explicitly set. - var hasInout: Bool {return self._inout != nil} + var hasInout: Bool {self._inout != nil} /// Clears the value of ``inout``. Subsequent reads from it will return its default value. mutating func clearInout() {self._inout = nil} @@ -3162,17 +2702,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _inout: Int32? = nil } - struct internalMessage { + struct internalMessage: Sendable { // 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 `internal`: Int32 { - get {return _internal ?? 0} + get {_internal ?? 0} set {_internal = newValue} } /// Returns true if ``internal`` has been explicitly set. - var hasInternal: Bool {return self._internal != nil} + var hasInternal: Bool {self._internal != nil} /// Clears the value of ``internal``. Subsequent reads from it will return its default value. mutating func clearInternal() {self._internal = nil} @@ -3183,17 +2723,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _internal: Int32? = nil } - struct letMessage { + struct letMessage: Sendable { // 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 `let`: Int32 { - get {return _let ?? 0} + get {_let ?? 0} set {_let = newValue} } /// Returns true if ``let`` has been explicitly set. - var hasLet: Bool {return self._let != nil} + var hasLet: Bool {self._let != nil} /// Clears the value of ``let``. Subsequent reads from it will return its default value. mutating func clearLet() {self._let = nil} @@ -3204,17 +2744,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _let: Int32? = nil } - struct operatorMessage { + struct operatorMessage: Sendable { // 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 `operator`: Int32 { - get {return _operator ?? 0} + get {_operator ?? 0} set {_operator = newValue} } /// Returns true if ``operator`` has been explicitly set. - var hasOperator: Bool {return self._operator != nil} + var hasOperator: Bool {self._operator != nil} /// Clears the value of ``operator``. Subsequent reads from it will return its default value. mutating func clearOperator() {self._operator = nil} @@ -3225,17 +2765,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _operator: Int32? = nil } - struct privateMessage { + struct privateMessage: Sendable { // 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 `private`: Int32 { - get {return _private ?? 0} + get {_private ?? 0} set {_private = newValue} } /// Returns true if ``private`` has been explicitly set. - var hasPrivate: Bool {return self._private != nil} + var hasPrivate: Bool {self._private != nil} /// Clears the value of ``private``. Subsequent reads from it will return its default value. mutating func clearPrivate() {self._private = nil} @@ -3246,17 +2786,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _private: Int32? = nil } - struct protocolMessage { + struct protocolMessage: Sendable { // 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 `protocol`: Int32 { - get {return _protocol ?? 0} + get {_protocol ?? 0} set {_protocol = newValue} } /// Returns true if ``protocol`` has been explicitly set. - var hasProtocol: Bool {return self._protocol != nil} + var hasProtocol: Bool {self._protocol != nil} /// Clears the value of ``protocol``. Subsequent reads from it will return its default value. mutating func clearProtocol() {self._protocol = nil} @@ -3267,17 +2807,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _protocol: Int32? = nil } - struct publicMessage { + struct publicMessage: Sendable { // 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 `public`: Int32 { - get {return _public ?? 0} + get {_public ?? 0} set {_public = newValue} } /// Returns true if ``public`` has been explicitly set. - var hasPublic: Bool {return self._public != nil} + var hasPublic: Bool {self._public != nil} /// Clears the value of ``public``. Subsequent reads from it will return its default value. mutating func clearPublic() {self._public = nil} @@ -3288,17 +2828,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _public: Int32? = nil } - struct staticMessage { + struct staticMessage: Sendable { // 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 `static`: Int32 { - get {return _static ?? 0} + get {_static ?? 0} set {_static = newValue} } /// Returns true if ``static`` has been explicitly set. - var hasStatic: Bool {return self._static != nil} + var hasStatic: Bool {self._static != nil} /// Clears the value of ``static``. Subsequent reads from it will return its default value. mutating func clearStatic() {self._static = nil} @@ -3309,17 +2849,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _static: Int32? = nil } - struct structMessage { + struct structMessage: Sendable { // 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 `struct`: Int32 { - get {return _struct ?? 0} + get {_struct ?? 0} set {_struct = newValue} } /// Returns true if ``struct`` has been explicitly set. - var hasStruct: Bool {return self._struct != nil} + var hasStruct: Bool {self._struct != nil} /// Clears the value of ``struct``. Subsequent reads from it will return its default value. mutating func clearStruct() {self._struct = nil} @@ -3330,17 +2870,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _struct: Int32? = nil } - struct subscriptMessage { + struct subscriptMessage: Sendable { // 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 `subscript`: Int32 { - get {return _subscript ?? 0} + get {_subscript ?? 0} set {_subscript = newValue} } /// Returns true if ``subscript`` has been explicitly set. - var hasSubscript: Bool {return self._subscript != nil} + var hasSubscript: Bool {self._subscript != nil} /// Clears the value of ``subscript``. Subsequent reads from it will return its default value. mutating func clearSubscript() {self._subscript = nil} @@ -3351,17 +2891,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _subscript: Int32? = nil } - struct typealiasMessage { + struct typealiasMessage: Sendable { // 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 `typealias`: Int32 { - get {return _typealias ?? 0} + get {_typealias ?? 0} set {_typealias = newValue} } /// Returns true if ``typealias`` has been explicitly set. - var hasTypealias: Bool {return self._typealias != nil} + var hasTypealias: Bool {self._typealias != nil} /// Clears the value of ``typealias``. Subsequent reads from it will return its default value. mutating func clearTypealias() {self._typealias = nil} @@ -3372,17 +2912,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _typealias: Int32? = nil } - struct varMessage { + struct varMessage: Sendable { // 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 `var`: Int32 { - get {return _var ?? 0} + get {_var ?? 0} set {_var = newValue} } /// Returns true if ``var`` has been explicitly set. - var hasVar: Bool {return self._var != nil} + var hasVar: Bool {self._var != nil} /// Clears the value of ``var``. Subsequent reads from it will return its default value. mutating func clearVar() {self._var = nil} @@ -3393,17 +2933,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _var: Int32? = nil } - struct breakMessage { + struct breakMessage: Sendable { // 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 `break`: Int32 { - get {return _break ?? 0} + get {_break ?? 0} set {_break = newValue} } /// Returns true if ``break`` has been explicitly set. - var hasBreak: Bool {return self._break != nil} + var hasBreak: Bool {self._break != nil} /// Clears the value of ``break``. Subsequent reads from it will return its default value. mutating func clearBreak() {self._break = nil} @@ -3414,17 +2954,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _break: Int32? = nil } - struct caseMessage { + struct caseMessage: Sendable { // 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 `case`: Int32 { - get {return _case ?? 0} + get {_case ?? 0} set {_case = newValue} } /// Returns true if ``case`` has been explicitly set. - var hasCase: Bool {return self._case != nil} + var hasCase: Bool {self._case != nil} /// Clears the value of ``case``. Subsequent reads from it will return its default value. mutating func clearCase() {self._case = nil} @@ -3435,17 +2975,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _case: Int32? = nil } - struct continueMessage { + struct continueMessage: Sendable { // 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 `continue`: Int32 { - get {return _continue ?? 0} + get {_continue ?? 0} set {_continue = newValue} } /// Returns true if ``continue`` has been explicitly set. - var hasContinue: Bool {return self._continue != nil} + var hasContinue: Bool {self._continue != nil} /// Clears the value of ``continue``. Subsequent reads from it will return its default value. mutating func clearContinue() {self._continue = nil} @@ -3456,17 +2996,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _continue: Int32? = nil } - struct defaultMessage { + struct defaultMessage: Sendable { // 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 `default`: Int32 { - get {return _default ?? 0} + get {_default ?? 0} set {_default = newValue} } /// Returns true if ``default`` has been explicitly set. - var hasDefault: Bool {return self._default != nil} + var hasDefault: Bool {self._default != nil} /// Clears the value of ``default``. Subsequent reads from it will return its default value. mutating func clearDefault() {self._default = nil} @@ -3477,17 +3017,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _default: Int32? = nil } - struct deferMessage { + struct deferMessage: Sendable { // 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 `defer`: Int32 { - get {return _defer ?? 0} + get {_defer ?? 0} set {_defer = newValue} } /// Returns true if ``defer`` has been explicitly set. - var hasDefer: Bool {return self._defer != nil} + var hasDefer: Bool {self._defer != nil} /// Clears the value of ``defer``. Subsequent reads from it will return its default value. mutating func clearDefer() {self._defer = nil} @@ -3498,17 +3038,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _defer: Int32? = nil } - struct doMessage { + struct doMessage: Sendable { // 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 `do`: Int32 { - get {return _do ?? 0} + get {_do ?? 0} set {_do = newValue} } /// Returns true if ``do`` has been explicitly set. - var hasDo: Bool {return self._do != nil} + var hasDo: Bool {self._do != nil} /// Clears the value of ``do``. Subsequent reads from it will return its default value. mutating func clearDo() {self._do = nil} @@ -3519,17 +3059,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _do: Int32? = nil } - struct elseMessage { + struct elseMessage: Sendable { // 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 `else`: Int32 { - get {return _else ?? 0} + get {_else ?? 0} set {_else = newValue} } /// Returns true if ``else`` has been explicitly set. - var hasElse: Bool {return self._else != nil} + var hasElse: Bool {self._else != nil} /// Clears the value of ``else``. Subsequent reads from it will return its default value. mutating func clearElse() {self._else = nil} @@ -3540,17 +3080,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _else: Int32? = nil } - struct fallthroughMessage { + struct fallthroughMessage: Sendable { // 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 `fallthrough`: Int32 { - get {return _fallthrough ?? 0} + get {_fallthrough ?? 0} set {_fallthrough = newValue} } /// Returns true if ``fallthrough`` has been explicitly set. - var hasFallthrough: Bool {return self._fallthrough != nil} + var hasFallthrough: Bool {self._fallthrough != nil} /// Clears the value of ``fallthrough``. Subsequent reads from it will return its default value. mutating func clearFallthrough() {self._fallthrough = nil} @@ -3561,17 +3101,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _fallthrough: Int32? = nil } - struct forMessage { + struct forMessage: Sendable { // 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 `for`: Int32 { - get {return _for ?? 0} + get {_for ?? 0} set {_for = newValue} } /// Returns true if ``for`` has been explicitly set. - var hasFor: Bool {return self._for != nil} + var hasFor: Bool {self._for != nil} /// Clears the value of ``for``. Subsequent reads from it will return its default value. mutating func clearFor() {self._for = nil} @@ -3582,17 +3122,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _for: Int32? = nil } - struct guardMessage { + struct guardMessage: Sendable { // 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 `guard`: Int32 { - get {return _guard ?? 0} + get {_guard ?? 0} set {_guard = newValue} } /// Returns true if ``guard`` has been explicitly set. - var hasGuard: Bool {return self._guard != nil} + var hasGuard: Bool {self._guard != nil} /// Clears the value of ``guard``. Subsequent reads from it will return its default value. mutating func clearGuard() {self._guard = nil} @@ -3603,17 +3143,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _guard: Int32? = nil } - struct ifMessage { + struct ifMessage: Sendable { // 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 `if`: Int32 { - get {return _if ?? 0} + get {_if ?? 0} set {_if = newValue} } /// Returns true if ``if`` has been explicitly set. - var hasIf: Bool {return self._if != nil} + var hasIf: Bool {self._if != nil} /// Clears the value of ``if``. Subsequent reads from it will return its default value. mutating func clearIf() {self._if = nil} @@ -3624,17 +3164,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _if: Int32? = nil } - struct inMessage { + struct inMessage: Sendable { // 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 `in`: Int32 { - get {return _in ?? 0} + get {_in ?? 0} set {_in = newValue} } /// Returns true if ``in`` has been explicitly set. - var hasIn: Bool {return self._in != nil} + var hasIn: Bool {self._in != nil} /// Clears the value of ``in``. Subsequent reads from it will return its default value. mutating func clearIn() {self._in = nil} @@ -3645,17 +3185,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _in: Int32? = nil } - struct repeatMessage { + struct repeatMessage: Sendable { // 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 `repeat`: Int32 { - get {return _repeat ?? 0} + get {_repeat ?? 0} set {_repeat = newValue} } /// Returns true if ``repeat`` has been explicitly set. - var hasRepeat: Bool {return self._repeat != nil} + var hasRepeat: Bool {self._repeat != nil} /// Clears the value of ``repeat``. Subsequent reads from it will return its default value. mutating func clearRepeat() {self._repeat = nil} @@ -3666,17 +3206,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _repeat: Int32? = nil } - struct returnMessage { + struct returnMessage: Sendable { // 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 `return`: Int32 { - get {return _return ?? 0} + get {_return ?? 0} set {_return = newValue} } /// Returns true if ``return`` has been explicitly set. - var hasReturn: Bool {return self._return != nil} + var hasReturn: Bool {self._return != nil} /// Clears the value of ``return``. Subsequent reads from it will return its default value. mutating func clearReturn() {self._return = nil} @@ -3687,17 +3227,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _return: Int32? = nil } - struct switchMessage { + struct switchMessage: Sendable { // 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 `switch`: Int32 { - get {return _switch ?? 0} + get {_switch ?? 0} set {_switch = newValue} } /// Returns true if ``switch`` has been explicitly set. - var hasSwitch: Bool {return self._switch != nil} + var hasSwitch: Bool {self._switch != nil} /// Clears the value of ``switch``. Subsequent reads from it will return its default value. mutating func clearSwitch() {self._switch = nil} @@ -3708,17 +3248,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _switch: Int32? = nil } - struct whereMessage { + struct whereMessage: Sendable { // 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 `where`: Int32 { - get {return _where ?? 0} + get {_where ?? 0} set {_where = newValue} } /// Returns true if ``where`` has been explicitly set. - var hasWhere: Bool {return self._where != nil} + var hasWhere: Bool {self._where != nil} /// Clears the value of ``where``. Subsequent reads from it will return its default value. mutating func clearWhere() {self._where = nil} @@ -3729,17 +3269,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _where: Int32? = nil } - struct whileMessage { + struct whileMessage: Sendable { // 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 `while`: Int32 { - get {return _while ?? 0} + get {_while ?? 0} set {_while = newValue} } /// Returns true if ``while`` has been explicitly set. - var hasWhile: Bool {return self._while != nil} + var hasWhile: Bool {self._while != nil} /// Clears the value of ``while``. Subsequent reads from it will return its default value. mutating func clearWhile() {self._while = nil} @@ -3750,17 +3290,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _while: Int32? = nil } - struct asMessage { + struct asMessage: Sendable { // 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 `as`: Int32 { - get {return _as ?? 0} + get {_as ?? 0} set {_as = newValue} } /// Returns true if ``as`` has been explicitly set. - var hasAs: Bool {return self._as != nil} + var hasAs: Bool {self._as != nil} /// Clears the value of ``as``. Subsequent reads from it will return its default value. mutating func clearAs() {self._as = nil} @@ -3771,17 +3311,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _as: Int32? = nil } - struct catchMessage { + struct catchMessage: Sendable { // 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 `catch`: Int32 { - get {return _catch ?? 0} + get {_catch ?? 0} set {_catch = newValue} } /// Returns true if ``catch`` has been explicitly set. - var hasCatch: Bool {return self._catch != nil} + var hasCatch: Bool {self._catch != nil} /// Clears the value of ``catch``. Subsequent reads from it will return its default value. mutating func clearCatch() {self._catch = nil} @@ -3792,17 +3332,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _catch: Int32? = nil } - struct dynamicTypeMessage { + struct dynamicTypeMessage: Sendable { // 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 dynamicType_p: Int32 { - get {return _dynamicType_p ?? 0} + get {_dynamicType_p ?? 0} set {_dynamicType_p = newValue} } /// Returns true if `dynamicType_p` has been explicitly set. - var hasDynamicType_p: Bool {return self._dynamicType_p != nil} + var hasDynamicType_p: Bool {self._dynamicType_p != nil} /// Clears the value of `dynamicType_p`. Subsequent reads from it will return its default value. mutating func clearDynamicType_p() {self._dynamicType_p = nil} @@ -3813,17 +3353,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _dynamicType_p: Int32? = nil } - struct falseMessage { + struct falseMessage: Sendable { // 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 `false`: Int32 { - get {return _false ?? 0} + get {_false ?? 0} set {_false = newValue} } /// Returns true if ``false`` has been explicitly set. - var hasFalse: Bool {return self._false != nil} + var hasFalse: Bool {self._false != nil} /// Clears the value of ``false``. Subsequent reads from it will return its default value. mutating func clearFalse() {self._false = nil} @@ -3834,17 +3374,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _false: Int32? = nil } - struct isMessage { + struct isMessage: Sendable { // 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 `is`: Int32 { - get {return _is ?? 0} + get {_is ?? 0} set {_is = newValue} } /// Returns true if ``is`` has been explicitly set. - var hasIs: Bool {return self._is != nil} + var hasIs: Bool {self._is != nil} /// Clears the value of ``is``. Subsequent reads from it will return its default value. mutating func clearIs() {self._is = nil} @@ -3855,17 +3395,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _is: Int32? = nil } - struct nilMessage { + struct nilMessage: Sendable { // 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 `nil`: Int32 { - get {return _nil ?? 0} + get {_nil ?? 0} set {_nil = newValue} } /// Returns true if ``nil`` has been explicitly set. - var hasNil: Bool {return self._nil != nil} + var hasNil: Bool {self._nil != nil} /// Clears the value of ``nil``. Subsequent reads from it will return its default value. mutating func clearNil() {self._nil = nil} @@ -3876,17 +3416,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _nil: Int32? = nil } - struct rethrowsMessage { + struct rethrowsMessage: Sendable { // 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 `rethrows`: Int32 { - get {return _rethrows ?? 0} + get {_rethrows ?? 0} set {_rethrows = newValue} } /// Returns true if ``rethrows`` has been explicitly set. - var hasRethrows: Bool {return self._rethrows != nil} + var hasRethrows: Bool {self._rethrows != nil} /// Clears the value of ``rethrows``. Subsequent reads from it will return its default value. mutating func clearRethrows() {self._rethrows = nil} @@ -3897,17 +3437,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _rethrows: Int32? = nil } - struct superMessage { + struct superMessage: Sendable { // 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 `super`: Int32 { - get {return _super ?? 0} + get {_super ?? 0} set {_super = newValue} } /// Returns true if ``super`` has been explicitly set. - var hasSuper: Bool {return self._super != nil} + var hasSuper: Bool {self._super != nil} /// Clears the value of ``super``. Subsequent reads from it will return its default value. mutating func clearSuper() {self._super = nil} @@ -3918,17 +3458,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _super: Int32? = nil } - struct selfMessage { + struct selfMessage: Sendable { // 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 self_p: Int32 { - get {return _self_p ?? 0} + get {_self_p ?? 0} set {_self_p = newValue} } /// Returns true if `self_p` has been explicitly set. - var hasSelf_p: Bool {return self._self_p != nil} + var hasSelf_p: Bool {self._self_p != nil} /// Clears the value of `self_p`. Subsequent reads from it will return its default value. mutating func clearSelf_p() {self._self_p = nil} @@ -3939,17 +3479,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _self_p: Int32? = nil } - struct throwMessage { + struct throwMessage: Sendable { // 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 `throw`: Int32 { - get {return _throw ?? 0} + get {_throw ?? 0} set {_throw = newValue} } /// Returns true if ``throw`` has been explicitly set. - var hasThrow: Bool {return self._throw != nil} + var hasThrow: Bool {self._throw != nil} /// Clears the value of ``throw``. Subsequent reads from it will return its default value. mutating func clearThrow() {self._throw = nil} @@ -3960,17 +3500,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _throw: Int32? = nil } - struct throwsMessage { + struct throwsMessage: Sendable { // 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 `throws`: Int32 { - get {return _throws ?? 0} + get {_throws ?? 0} set {_throws = newValue} } /// Returns true if ``throws`` has been explicitly set. - var hasThrows: Bool {return self._throws != nil} + var hasThrows: Bool {self._throws != nil} /// Clears the value of ``throws``. Subsequent reads from it will return its default value. mutating func clearThrows() {self._throws = nil} @@ -3981,17 +3521,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _throws: Int32? = nil } - struct trueMessage { + struct trueMessage: Sendable { // 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 `true`: Int32 { - get {return _true ?? 0} + get {_true ?? 0} set {_true = newValue} } /// Returns true if ``true`` has been explicitly set. - var hasTrue: Bool {return self._true != nil} + var hasTrue: Bool {self._true != nil} /// Clears the value of ``true``. Subsequent reads from it will return its default value. mutating func clearTrue() {self._true = nil} @@ -4002,17 +3542,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _true: Int32? = nil } - struct tryMessage { + struct tryMessage: Sendable { // 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 `try`: Int32 { - get {return _try ?? 0} + get {_try ?? 0} set {_try = newValue} } /// Returns true if ``try`` has been explicitly set. - var hasTry: Bool {return self._try != nil} + var hasTry: Bool {self._try != nil} /// Clears the value of ``try``. Subsequent reads from it will return its default value. mutating func clearTry() {self._try = nil} @@ -4023,17 +3563,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _try: Int32? = nil } - struct __COLUMN__Message { + struct __COLUMN__Message: Sendable { // 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 _Column__: Int32 { - get {return __Column__ ?? 0} + get {__Column__ ?? 0} set {__Column__ = newValue} } /// Returns true if `_Column__` has been explicitly set. - var has_Column__: Bool {return self.__Column__ != nil} + var has_Column__: Bool {self.__Column__ != nil} /// Clears the value of `_Column__`. Subsequent reads from it will return its default value. mutating func clear_Column__() {self.__Column__ = nil} @@ -4044,17 +3584,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var __Column__: Int32? = nil } - struct __FILE__Message { + struct __FILE__Message: Sendable { // 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 _File__: Int32 { - get {return __File__ ?? 0} + get {__File__ ?? 0} set {__File__ = newValue} } /// Returns true if `_File__` has been explicitly set. - var has_File__: Bool {return self.__File__ != nil} + var has_File__: Bool {self.__File__ != nil} /// Clears the value of `_File__`. Subsequent reads from it will return its default value. mutating func clear_File__() {self.__File__ = nil} @@ -4065,17 +3605,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var __File__: Int32? = nil } - struct __FUNCTION__Message { + struct __FUNCTION__Message: Sendable { // 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 _Function__: Int32 { - get {return __Function__ ?? 0} + get {__Function__ ?? 0} set {__Function__ = newValue} } /// Returns true if `_Function__` has been explicitly set. - var has_Function__: Bool {return self.__Function__ != nil} + var has_Function__: Bool {self.__Function__ != nil} /// Clears the value of `_Function__`. Subsequent reads from it will return its default value. mutating func clear_Function__() {self.__Function__ = nil} @@ -4086,17 +3626,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var __Function__: Int32? = nil } - struct __LINE__Message { + struct __LINE__Message: Sendable { // 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 _Line__: Int32 { - get {return __Line__ ?? 0} + get {__Line__ ?? 0} set {__Line__ = newValue} } /// Returns true if `_Line__` has been explicitly set. - var has_Line__: Bool {return self.__Line__ != nil} + var has_Line__: Bool {self.__Line__ != nil} /// Clears the value of `_Line__`. Subsequent reads from it will return its default value. mutating func clear_Line__() {self.__Line__ = nil} @@ -4107,17 +3647,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var __Line__: Int32? = nil } - struct _Message { + struct _Message: Sendable { // 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 ___: Int32 { - get {return ____ ?? 0} + get {____ ?? 0} set {____ = newValue} } /// Returns true if `___` has been explicitly set. - var has___: Bool {return self.____ != nil} + var has___: Bool {self.____ != nil} /// Clears the value of `___`. Subsequent reads from it will return its default value. mutating func clear___() {self.____ = nil} @@ -4128,17 +3668,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var ____: Int32? = nil } - struct __Message { + struct __Message: Sendable { // 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 ____: Int32 { - get {return _____ ?? 0} + get {_____ ?? 0} set {_____ = newValue} } /// Returns true if `____` has been explicitly set. - var has____: Bool {return self._____ != nil} + var has____: Bool {self._____ != nil} /// Clears the value of `____`. Subsequent reads from it will return its default value. mutating func clear____() {self._____ = nil} @@ -4149,17 +3689,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _____: Int32? = nil } - struct associativity { + struct associativity: Sendable { // 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 associativity: Int32 { - get {return _associativity ?? 0} + get {_associativity ?? 0} set {_associativity = newValue} } /// Returns true if `associativity` has been explicitly set. - var hasAssociativity: Bool {return self._associativity != nil} + var hasAssociativity: Bool {self._associativity != nil} /// Clears the value of `associativity`. Subsequent reads from it will return its default value. mutating func clearAssociativity() {self._associativity = nil} @@ -4170,17 +3710,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _associativity: Int32? = nil } - struct convenience { + struct convenience: Sendable { // 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 convenience: Int32 { - get {return _convenience ?? 0} + get {_convenience ?? 0} set {_convenience = newValue} } /// Returns true if `convenience` has been explicitly set. - var hasConvenience: Bool {return self._convenience != nil} + var hasConvenience: Bool {self._convenience != nil} /// Clears the value of `convenience`. Subsequent reads from it will return its default value. mutating func clearConvenience() {self._convenience = nil} @@ -4191,17 +3731,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _convenience: Int32? = nil } - struct dynamic { + struct dynamic: Sendable { // 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 dynamic: Int32 { - get {return _dynamic ?? 0} + get {_dynamic ?? 0} set {_dynamic = newValue} } /// Returns true if `dynamic` has been explicitly set. - var hasDynamic: Bool {return self._dynamic != nil} + var hasDynamic: Bool {self._dynamic != nil} /// Clears the value of `dynamic`. Subsequent reads from it will return its default value. mutating func clearDynamic() {self._dynamic = nil} @@ -4212,17 +3752,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _dynamic: Int32? = nil } - struct didSet { + struct didSet: Sendable { // 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 didSet: Int32 { - get {return _didSet ?? 0} + get {_didSet ?? 0} set {_didSet = newValue} } /// Returns true if `didSet` has been explicitly set. - var hasDidSet: Bool {return self._didSet != nil} + var hasDidSet: Bool {self._didSet != nil} /// Clears the value of `didSet`. Subsequent reads from it will return its default value. mutating func clearDidSet() {self._didSet = nil} @@ -4233,17 +3773,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _didSet: Int32? = nil } - struct final { + struct final: Sendable { // 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 final: Int32 { - get {return _final ?? 0} + get {_final ?? 0} set {_final = newValue} } /// Returns true if `final` has been explicitly set. - var hasFinal: Bool {return self._final != nil} + var hasFinal: Bool {self._final != nil} /// Clears the value of `final`. Subsequent reads from it will return its default value. mutating func clearFinal() {self._final = nil} @@ -4254,17 +3794,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _final: Int32? = nil } - struct get { + struct get: Sendable { // 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 get: Int32 { - get {return _get ?? 0} + get {_get ?? 0} set {_get = newValue} } /// Returns true if `get` has been explicitly set. - var hasGet: Bool {return self._get != nil} + var hasGet: Bool {self._get != nil} /// Clears the value of `get`. Subsequent reads from it will return its default value. mutating func clearGet() {self._get = nil} @@ -4275,17 +3815,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _get: Int32? = nil } - struct infix { + struct infix: Sendable { // 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 infix: Int32 { - get {return _infix ?? 0} + get {_infix ?? 0} set {_infix = newValue} } /// Returns true if `infix` has been explicitly set. - var hasInfix: Bool {return self._infix != nil} + var hasInfix: Bool {self._infix != nil} /// Clears the value of `infix`. Subsequent reads from it will return its default value. mutating func clearInfix() {self._infix = nil} @@ -4296,17 +3836,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _infix: Int32? = nil } - struct indirect { + struct indirect: Sendable { // 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 indirect: Int32 { - get {return _indirect ?? 0} + get {_indirect ?? 0} set {_indirect = newValue} } /// Returns true if `indirect` has been explicitly set. - var hasIndirect: Bool {return self._indirect != nil} + var hasIndirect: Bool {self._indirect != nil} /// Clears the value of `indirect`. Subsequent reads from it will return its default value. mutating func clearIndirect() {self._indirect = nil} @@ -4317,17 +3857,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _indirect: Int32? = nil } - struct lazy { + struct lazy: Sendable { // 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 lazy: Int32 { - get {return _lazy ?? 0} + get {_lazy ?? 0} set {_lazy = newValue} } /// Returns true if `lazy` has been explicitly set. - var hasLazy: Bool {return self._lazy != nil} + var hasLazy: Bool {self._lazy != nil} /// Clears the value of `lazy`. Subsequent reads from it will return its default value. mutating func clearLazy() {self._lazy = nil} @@ -4338,17 +3878,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _lazy: Int32? = nil } - struct left { + struct left: Sendable { // 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: Int32 { - get {return _left ?? 0} + get {_left ?? 0} set {_left = newValue} } /// Returns true if `left` has been explicitly set. - var hasLeft: Bool {return self._left != nil} + var hasLeft: Bool {self._left != nil} /// Clears the value of `left`. Subsequent reads from it will return its default value. mutating func clearLeft() {self._left = nil} @@ -4359,17 +3899,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _left: Int32? = nil } - struct mutating { + struct mutating: Sendable { // 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 mutating: Int32 { - get {return _mutating ?? 0} + get {_mutating ?? 0} set {_mutating = newValue} } /// Returns true if `mutating` has been explicitly set. - var hasMutating: Bool {return self._mutating != nil} + var hasMutating: Bool {self._mutating != nil} /// Clears the value of `mutating`. Subsequent reads from it will return its default value. mutating func clearMutating() {self._mutating = nil} @@ -4380,17 +3920,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _mutating: Int32? = nil } - struct none { + struct none: Sendable { // 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 none: Int32 { - get {return _none ?? 0} + get {_none ?? 0} set {_none = newValue} } /// Returns true if `none` has been explicitly set. - var hasNone: Bool {return self._none != nil} + var hasNone: Bool {self._none != nil} /// Clears the value of `none`. Subsequent reads from it will return its default value. mutating func clearNone() {self._none = nil} @@ -4401,17 +3941,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _none: Int32? = nil } - struct nonmutating { + struct nonmutating: Sendable { // 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 nonmutating: Int32 { - get {return _nonmutating ?? 0} + get {_nonmutating ?? 0} set {_nonmutating = newValue} } /// Returns true if `nonmutating` has been explicitly set. - var hasNonmutating: Bool {return self._nonmutating != nil} + var hasNonmutating: Bool {self._nonmutating != nil} /// Clears the value of `nonmutating`. Subsequent reads from it will return its default value. mutating func clearNonmutating() {self._nonmutating = nil} @@ -4422,17 +3962,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _nonmutating: Int32? = nil } - struct optional { + struct optional: Sendable { // 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 optional: Int32 { - get {return _optional ?? 0} + get {_optional ?? 0} set {_optional = newValue} } /// Returns true if `optional` has been explicitly set. - var hasOptional: Bool {return self._optional != nil} + var hasOptional: Bool {self._optional != nil} /// Clears the value of `optional`. Subsequent reads from it will return its default value. mutating func clearOptional() {self._optional = nil} @@ -4443,17 +3983,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _optional: Int32? = nil } - struct override { + struct override: Sendable { // 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 override: Int32 { - get {return _override ?? 0} + get {_override ?? 0} set {_override = newValue} } /// Returns true if `override` has been explicitly set. - var hasOverride: Bool {return self._override != nil} + var hasOverride: Bool {self._override != nil} /// Clears the value of `override`. Subsequent reads from it will return its default value. mutating func clearOverride() {self._override = nil} @@ -4464,17 +4004,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _override: Int32? = nil } - struct postfix { + struct postfix: Sendable { // 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 postfix: Int32 { - get {return _postfix ?? 0} + get {_postfix ?? 0} set {_postfix = newValue} } /// Returns true if `postfix` has been explicitly set. - var hasPostfix: Bool {return self._postfix != nil} + var hasPostfix: Bool {self._postfix != nil} /// Clears the value of `postfix`. Subsequent reads from it will return its default value. mutating func clearPostfix() {self._postfix = nil} @@ -4485,17 +4025,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _postfix: Int32? = nil } - struct precedence { + struct precedence: Sendable { // 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 precedence: Int32 { - get {return _precedence ?? 0} + get {_precedence ?? 0} set {_precedence = newValue} } /// Returns true if `precedence` has been explicitly set. - var hasPrecedence: Bool {return self._precedence != nil} + var hasPrecedence: Bool {self._precedence != nil} /// Clears the value of `precedence`. Subsequent reads from it will return its default value. mutating func clearPrecedence() {self._precedence = nil} @@ -4506,17 +4046,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _precedence: Int32? = nil } - struct prefix { + struct prefix: Sendable { // 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 prefix: Int32 { - get {return _prefix ?? 0} + get {_prefix ?? 0} set {_prefix = newValue} } /// Returns true if `prefix` has been explicitly set. - var hasPrefix: Bool {return self._prefix != nil} + var hasPrefix: Bool {self._prefix != nil} /// Clears the value of `prefix`. Subsequent reads from it will return its default value. mutating func clearPrefix() {self._prefix = nil} @@ -4527,17 +4067,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _prefix: Int32? = nil } - struct required { + struct required: Sendable { // 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 required: Int32 { - get {return _required ?? 0} + get {_required ?? 0} set {_required = newValue} } /// Returns true if `required` has been explicitly set. - var hasRequired: Bool {return self._required != nil} + var hasRequired: Bool {self._required != nil} /// Clears the value of `required`. Subsequent reads from it will return its default value. mutating func clearRequired() {self._required = nil} @@ -4548,17 +4088,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _required: Int32? = nil } - struct right { + struct right: Sendable { // 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 right: Int32 { - get {return _right ?? 0} + get {_right ?? 0} set {_right = newValue} } /// Returns true if `right` has been explicitly set. - var hasRight: Bool {return self._right != nil} + var hasRight: Bool {self._right != nil} /// Clears the value of `right`. Subsequent reads from it will return its default value. mutating func clearRight() {self._right = nil} @@ -4569,17 +4109,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _right: Int32? = nil } - struct set { + struct set: Sendable { // 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 set: Int32 { - get {return _set ?? 0} + get {_set ?? 0} set {_set = newValue} } /// Returns true if `set` has been explicitly set. - var hasSet: Bool {return self._set != nil} + var hasSet: Bool {self._set != nil} /// Clears the value of `set`. Subsequent reads from it will return its default value. mutating func clearSet() {self._set = nil} @@ -4590,17 +4130,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _set: Int32? = nil } - struct TypeMessage { + struct TypeMessage: Sendable { // 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 type: Int32 { - get {return _type ?? 0} + get {_type ?? 0} set {_type = newValue} } /// Returns true if `type` has been explicitly set. - var hasType: Bool {return self._type != nil} + var hasType: Bool {self._type != nil} /// Clears the value of `type`. Subsequent reads from it will return its default value. mutating func clearType() {self._type = nil} @@ -4611,17 +4151,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _type: Int32? = nil } - struct unowned { + struct unowned: Sendable { // 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 unowned: Int32 { - get {return _unowned ?? 0} + get {_unowned ?? 0} set {_unowned = newValue} } /// Returns true if `unowned` has been explicitly set. - var hasUnowned: Bool {return self._unowned != nil} + var hasUnowned: Bool {self._unowned != nil} /// Clears the value of `unowned`. Subsequent reads from it will return its default value. mutating func clearUnowned() {self._unowned = nil} @@ -4632,17 +4172,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _unowned: Int32? = nil } - struct weak { + struct weak: Sendable { // 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 weak: Int32 { - get {return _weak ?? 0} + get {_weak ?? 0} set {_weak = newValue} } /// Returns true if `weak` has been explicitly set. - var hasWeak: Bool {return self._weak != nil} + var hasWeak: Bool {self._weak != nil} /// Clears the value of `weak`. Subsequent reads from it will return its default value. mutating func clearWeak() {self._weak = nil} @@ -4653,17 +4193,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _weak: Int32? = nil } - struct willSet { + struct willSet: Sendable { // 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 willSet: Int32 { - get {return _willSet ?? 0} + get {_willSet ?? 0} set {_willSet = newValue} } /// Returns true if `willSet` has been explicitly set. - var hasWillSet: Bool {return self._willSet != nil} + var hasWillSet: Bool {self._willSet != nil} /// Clears the value of `willSet`. Subsequent reads from it will return its default value. mutating func clearWillSet() {self._willSet = nil} @@ -4674,17 +4214,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _willSet: Int32? = nil } - struct id { + struct id: Sendable { // 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 id: Int32 { - get {return _id ?? 0} + get {_id ?? 0} set {_id = newValue} } /// Returns true if `id` has been explicitly set. - var hasID: Bool {return self._id != nil} + var hasID: Bool {self._id != nil} /// Clears the value of `id`. Subsequent reads from it will return its default value. mutating func clearID() {self._id = nil} @@ -4695,17 +4235,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _id: Int32? = nil } - struct _cmd { + struct _cmd: Sendable { // 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 cmd: Int32 { - get {return _cmd ?? 0} + get {_cmd ?? 0} set {_cmd = newValue} } /// Returns true if `cmd` has been explicitly set. - var hasCmd: Bool {return self._cmd != nil} + var hasCmd: Bool {self._cmd != nil} /// Clears the value of `cmd`. Subsequent reads from it will return its default value. mutating func clearCmd() {self._cmd = nil} @@ -4716,17 +4256,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _cmd: Int32? = nil } - struct out { + struct out: Sendable { // 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 out: Int32 { - get {return _out ?? 0} + get {_out ?? 0} set {_out = newValue} } /// Returns true if `out` has been explicitly set. - var hasOut: Bool {return self._out != nil} + var hasOut: Bool {self._out != nil} /// Clears the value of `out`. Subsequent reads from it will return its default value. mutating func clearOut() {self._out = nil} @@ -4737,17 +4277,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _out: Int32? = nil } - struct bycopy { + struct bycopy: Sendable { // 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 bycopy: Int32 { - get {return _bycopy ?? 0} + get {_bycopy ?? 0} set {_bycopy = newValue} } /// Returns true if `bycopy` has been explicitly set. - var hasBycopy: Bool {return self._bycopy != nil} + var hasBycopy: Bool {self._bycopy != nil} /// Clears the value of `bycopy`. Subsequent reads from it will return its default value. mutating func clearBycopy() {self._bycopy = nil} @@ -4758,17 +4298,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _bycopy: Int32? = nil } - struct byref { + struct byref: Sendable { // 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 byref: Int32 { - get {return _byref ?? 0} + get {_byref ?? 0} set {_byref = newValue} } /// Returns true if `byref` has been explicitly set. - var hasByref: Bool {return self._byref != nil} + var hasByref: Bool {self._byref != nil} /// Clears the value of `byref`. Subsequent reads from it will return its default value. mutating func clearByref() {self._byref = nil} @@ -4779,17 +4319,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _byref: Int32? = nil } - struct oneway { + struct oneway: Sendable { // 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 oneway: Int32 { - get {return _oneway ?? 0} + get {_oneway ?? 0} set {_oneway = newValue} } /// Returns true if `oneway` has been explicitly set. - var hasOneway: Bool {return self._oneway != nil} + var hasOneway: Bool {self._oneway != nil} /// Clears the value of `oneway`. Subsequent reads from it will return its default value. mutating func clearOneway() {self._oneway = nil} @@ -4800,17 +4340,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _oneway: Int32? = nil } - struct and { + struct and: Sendable { // 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 and: Int32 { - get {return _and ?? 0} + get {_and ?? 0} set {_and = newValue} } /// Returns true if `and` has been explicitly set. - var hasAnd: Bool {return self._and != nil} + var hasAnd: Bool {self._and != nil} /// Clears the value of `and`. Subsequent reads from it will return its default value. mutating func clearAnd() {self._and = nil} @@ -4821,17 +4361,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _and: Int32? = nil } - struct and_eq { + struct and_eq: Sendable { // 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 andEq: Int32 { - get {return _andEq ?? 0} + get {_andEq ?? 0} set {_andEq = newValue} } /// Returns true if `andEq` has been explicitly set. - var hasAndEq: Bool {return self._andEq != nil} + var hasAndEq: Bool {self._andEq != nil} /// Clears the value of `andEq`. Subsequent reads from it will return its default value. mutating func clearAndEq() {self._andEq = nil} @@ -4842,17 +4382,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _andEq: Int32? = nil } - struct alignas { + struct alignas: Sendable { // 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 alignas: Int32 { - get {return _alignas ?? 0} + get {_alignas ?? 0} set {_alignas = newValue} } /// Returns true if `alignas` has been explicitly set. - var hasAlignas: Bool {return self._alignas != nil} + var hasAlignas: Bool {self._alignas != nil} /// Clears the value of `alignas`. Subsequent reads from it will return its default value. mutating func clearAlignas() {self._alignas = nil} @@ -4863,17 +4403,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _alignas: Int32? = nil } - struct alignof { + struct alignof: Sendable { // 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 alignof: Int32 { - get {return _alignof ?? 0} + get {_alignof ?? 0} set {_alignof = newValue} } /// Returns true if `alignof` has been explicitly set. - var hasAlignof: Bool {return self._alignof != nil} + var hasAlignof: Bool {self._alignof != nil} /// Clears the value of `alignof`. Subsequent reads from it will return its default value. mutating func clearAlignof() {self._alignof = nil} @@ -4884,17 +4424,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _alignof: Int32? = nil } - struct asm { + struct asm: Sendable { // 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 asm: Int32 { - get {return _asm ?? 0} + get {_asm ?? 0} set {_asm = newValue} } /// Returns true if `asm` has been explicitly set. - var hasAsm: Bool {return self._asm != nil} + var hasAsm: Bool {self._asm != nil} /// Clears the value of `asm`. Subsequent reads from it will return its default value. mutating func clearAsm() {self._asm = nil} @@ -4905,17 +4445,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _asm: Int32? = nil } - struct auto { + struct auto: Sendable { // 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 auto: Int32 { - get {return _auto ?? 0} + get {_auto ?? 0} set {_auto = newValue} } /// Returns true if `auto` has been explicitly set. - var hasAuto: Bool {return self._auto != nil} + var hasAuto: Bool {self._auto != nil} /// Clears the value of `auto`. Subsequent reads from it will return its default value. mutating func clearAuto() {self._auto = nil} @@ -4926,17 +4466,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _auto: Int32? = nil } - struct bitand { + struct bitand: Sendable { // 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 bitand: Int32 { - get {return _bitand ?? 0} + get {_bitand ?? 0} set {_bitand = newValue} } /// Returns true if `bitand` has been explicitly set. - var hasBitand: Bool {return self._bitand != nil} + var hasBitand: Bool {self._bitand != nil} /// Clears the value of `bitand`. Subsequent reads from it will return its default value. mutating func clearBitand() {self._bitand = nil} @@ -4947,17 +4487,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _bitand: Int32? = nil } - struct bitor { + struct bitor: Sendable { // 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 bitor: Int32 { - get {return _bitor ?? 0} + get {_bitor ?? 0} set {_bitor = newValue} } /// Returns true if `bitor` has been explicitly set. - var hasBitor: Bool {return self._bitor != nil} + var hasBitor: Bool {self._bitor != nil} /// Clears the value of `bitor`. Subsequent reads from it will return its default value. mutating func clearBitor() {self._bitor = nil} @@ -4968,17 +4508,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _bitor: Int32? = nil } - struct bool { + struct bool: Sendable { // 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 bool: Int32 { - get {return _bool ?? 0} + get {_bool ?? 0} set {_bool = newValue} } /// Returns true if `bool` has been explicitly set. - var hasBool: Bool {return self._bool != nil} + var hasBool: Bool {self._bool != nil} /// Clears the value of `bool`. Subsequent reads from it will return its default value. mutating func clearBool() {self._bool = nil} @@ -4989,17 +4529,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _bool: Int32? = nil } - struct char { + struct char: Sendable { // 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 char: Int32 { - get {return _char ?? 0} + get {_char ?? 0} set {_char = newValue} } /// Returns true if `char` has been explicitly set. - var hasChar: Bool {return self._char != nil} + var hasChar: Bool {self._char != nil} /// Clears the value of `char`. Subsequent reads from it will return its default value. mutating func clearChar() {self._char = nil} @@ -5010,17 +4550,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _char: Int32? = nil } - struct char16_t { + struct char16_t: Sendable { // 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 char16T: Int32 { - get {return _char16T ?? 0} + get {_char16T ?? 0} set {_char16T = newValue} } /// Returns true if `char16T` has been explicitly set. - var hasChar16T: Bool {return self._char16T != nil} + var hasChar16T: Bool {self._char16T != nil} /// Clears the value of `char16T`. Subsequent reads from it will return its default value. mutating func clearChar16T() {self._char16T = nil} @@ -5031,17 +4571,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _char16T: Int32? = nil } - struct char32_t { + struct char32_t: Sendable { // 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 char32T: Int32 { - get {return _char32T ?? 0} + get {_char32T ?? 0} set {_char32T = newValue} } /// Returns true if `char32T` has been explicitly set. - var hasChar32T: Bool {return self._char32T != nil} + var hasChar32T: Bool {self._char32T != nil} /// Clears the value of `char32T`. Subsequent reads from it will return its default value. mutating func clearChar32T() {self._char32T = nil} @@ -5052,17 +4592,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _char32T: Int32? = nil } - struct compl { + struct compl: Sendable { // 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 compl: Int32 { - get {return _compl ?? 0} + get {_compl ?? 0} set {_compl = newValue} } /// Returns true if `compl` has been explicitly set. - var hasCompl: Bool {return self._compl != nil} + var hasCompl: Bool {self._compl != nil} /// Clears the value of `compl`. Subsequent reads from it will return its default value. mutating func clearCompl() {self._compl = nil} @@ -5073,17 +4613,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _compl: Int32? = nil } - struct const { + struct const: Sendable { // 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 const: Int32 { - get {return _const ?? 0} + get {_const ?? 0} set {_const = newValue} } /// Returns true if `const` has been explicitly set. - var hasConst: Bool {return self._const != nil} + var hasConst: Bool {self._const != nil} /// Clears the value of `const`. Subsequent reads from it will return its default value. mutating func clearConst() {self._const = nil} @@ -5094,17 +4634,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _const: Int32? = nil } - struct constexpr { + struct constexpr: Sendable { // 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 constexpr: Int32 { - get {return _constexpr ?? 0} + get {_constexpr ?? 0} set {_constexpr = newValue} } /// Returns true if `constexpr` has been explicitly set. - var hasConstexpr: Bool {return self._constexpr != nil} + var hasConstexpr: Bool {self._constexpr != nil} /// Clears the value of `constexpr`. Subsequent reads from it will return its default value. mutating func clearConstexpr() {self._constexpr = nil} @@ -5115,17 +4655,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _constexpr: Int32? = nil } - struct const_cast { + struct const_cast: Sendable { // 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 constCast: Int32 { - get {return _constCast ?? 0} + get {_constCast ?? 0} set {_constCast = newValue} } /// Returns true if `constCast` has been explicitly set. - var hasConstCast: Bool {return self._constCast != nil} + var hasConstCast: Bool {self._constCast != nil} /// Clears the value of `constCast`. Subsequent reads from it will return its default value. mutating func clearConstCast() {self._constCast = nil} @@ -5136,17 +4676,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _constCast: Int32? = nil } - struct decltype { + struct decltype: Sendable { // 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 decltype: Int32 { - get {return _decltype ?? 0} + get {_decltype ?? 0} set {_decltype = newValue} } /// Returns true if `decltype` has been explicitly set. - var hasDecltype: Bool {return self._decltype != nil} + var hasDecltype: Bool {self._decltype != nil} /// Clears the value of `decltype`. Subsequent reads from it will return its default value. mutating func clearDecltype() {self._decltype = nil} @@ -5157,17 +4697,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _decltype: Int32? = nil } - struct delete { + struct delete: Sendable { // 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 delete: Int32 { - get {return _delete ?? 0} + get {_delete ?? 0} set {_delete = newValue} } /// Returns true if `delete` has been explicitly set. - var hasDelete: Bool {return self._delete != nil} + var hasDelete: Bool {self._delete != nil} /// Clears the value of `delete`. Subsequent reads from it will return its default value. mutating func clearDelete() {self._delete = nil} @@ -5178,17 +4718,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _delete: Int32? = nil } - struct dynamic_cast { + struct dynamic_cast: Sendable { // 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 dynamicCast: Int32 { - get {return _dynamicCast ?? 0} + get {_dynamicCast ?? 0} set {_dynamicCast = newValue} } /// Returns true if `dynamicCast` has been explicitly set. - var hasDynamicCast: Bool {return self._dynamicCast != nil} + var hasDynamicCast: Bool {self._dynamicCast != nil} /// Clears the value of `dynamicCast`. Subsequent reads from it will return its default value. mutating func clearDynamicCast() {self._dynamicCast = nil} @@ -5199,17 +4739,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _dynamicCast: Int32? = nil } - struct explicit { + struct explicit: Sendable { // 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 explicit: Int32 { - get {return _explicit ?? 0} + get {_explicit ?? 0} set {_explicit = newValue} } /// Returns true if `explicit` has been explicitly set. - var hasExplicit: Bool {return self._explicit != nil} + var hasExplicit: Bool {self._explicit != nil} /// Clears the value of `explicit`. Subsequent reads from it will return its default value. mutating func clearExplicit() {self._explicit = nil} @@ -5220,17 +4760,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _explicit: Int32? = nil } - struct export { + struct export: Sendable { // 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 export: Int32 { - get {return _export ?? 0} + get {_export ?? 0} set {_export = newValue} } /// Returns true if `export` has been explicitly set. - var hasExport: Bool {return self._export != nil} + var hasExport: Bool {self._export != nil} /// Clears the value of `export`. Subsequent reads from it will return its default value. mutating func clearExport() {self._export = nil} @@ -5241,17 +4781,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _export: Int32? = nil } - struct extern { + struct extern: Sendable { // 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 extern: Int32 { - get {return _extern ?? 0} + get {_extern ?? 0} set {_extern = newValue} } /// Returns true if `extern` has been explicitly set. - var hasExtern: Bool {return self._extern != nil} + var hasExtern: Bool {self._extern != nil} /// Clears the value of `extern`. Subsequent reads from it will return its default value. mutating func clearExtern() {self._extern = nil} @@ -5262,17 +4802,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _extern: Int32? = nil } - struct friend { + struct friend: Sendable { // 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 friend: Int32 { - get {return _friend ?? 0} + get {_friend ?? 0} set {_friend = newValue} } /// Returns true if `friend` has been explicitly set. - var hasFriend: Bool {return self._friend != nil} + var hasFriend: Bool {self._friend != nil} /// Clears the value of `friend`. Subsequent reads from it will return its default value. mutating func clearFriend() {self._friend = nil} @@ -5283,17 +4823,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _friend: Int32? = nil } - struct goto { + struct goto: Sendable { // 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 goto: Int32 { - get {return _goto ?? 0} + get {_goto ?? 0} set {_goto = newValue} } /// Returns true if `goto` has been explicitly set. - var hasGoto: Bool {return self._goto != nil} + var hasGoto: Bool {self._goto != nil} /// Clears the value of `goto`. Subsequent reads from it will return its default value. mutating func clearGoto() {self._goto = nil} @@ -5304,17 +4844,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _goto: Int32? = nil } - struct inline { + struct inline: Sendable { // 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 inline: Int32 { - get {return _inline ?? 0} + get {_inline ?? 0} set {_inline = newValue} } /// Returns true if `inline` has been explicitly set. - var hasInline: Bool {return self._inline != nil} + var hasInline: Bool {self._inline != nil} /// Clears the value of `inline`. Subsequent reads from it will return its default value. mutating func clearInline() {self._inline = nil} @@ -5325,17 +4865,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _inline: Int32? = nil } - struct long { + struct long: Sendable { // 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 long: Int32 { - get {return _long ?? 0} + get {_long ?? 0} set {_long = newValue} } /// Returns true if `long` has been explicitly set. - var hasLong: Bool {return self._long != nil} + var hasLong: Bool {self._long != nil} /// Clears the value of `long`. Subsequent reads from it will return its default value. mutating func clearLong() {self._long = nil} @@ -5346,17 +4886,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _long: Int32? = nil } - struct mutable { + struct mutable: Sendable { // 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 mutable: Int32 { - get {return _mutable ?? 0} + get {_mutable ?? 0} set {_mutable = newValue} } /// Returns true if `mutable` has been explicitly set. - var hasMutable: Bool {return self._mutable != nil} + var hasMutable: Bool {self._mutable != nil} /// Clears the value of `mutable`. Subsequent reads from it will return its default value. mutating func clearMutable() {self._mutable = nil} @@ -5367,17 +4907,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _mutable: Int32? = nil } - struct namespace { + struct namespace: Sendable { // 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 namespace: Int32 { - get {return _namespace ?? 0} + get {_namespace ?? 0} set {_namespace = newValue} } /// Returns true if `namespace` has been explicitly set. - var hasNamespace: Bool {return self._namespace != nil} + var hasNamespace: Bool {self._namespace != nil} /// Clears the value of `namespace`. Subsequent reads from it will return its default value. mutating func clearNamespace() {self._namespace = nil} @@ -5388,17 +4928,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _namespace: Int32? = nil } - struct new { + struct new: Sendable { // 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 new: Int32 { - get {return _new ?? 0} + get {_new ?? 0} set {_new = newValue} } /// Returns true if `new` has been explicitly set. - var hasNew: Bool {return self._new != nil} + var hasNew: Bool {self._new != nil} /// Clears the value of `new`. Subsequent reads from it will return its default value. mutating func clearNew() {self._new = nil} @@ -5409,17 +4949,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _new: Int32? = nil } - struct noexcept { + struct noexcept: Sendable { // 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 noexcept: Int32 { - get {return _noexcept ?? 0} + get {_noexcept ?? 0} set {_noexcept = newValue} } /// Returns true if `noexcept` has been explicitly set. - var hasNoexcept: Bool {return self._noexcept != nil} + var hasNoexcept: Bool {self._noexcept != nil} /// Clears the value of `noexcept`. Subsequent reads from it will return its default value. mutating func clearNoexcept() {self._noexcept = nil} @@ -5430,17 +4970,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _noexcept: Int32? = nil } - struct not { + struct not: Sendable { // 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 not: Int32 { - get {return _not ?? 0} + get {_not ?? 0} set {_not = newValue} } /// Returns true if `not` has been explicitly set. - var hasNot: Bool {return self._not != nil} + var hasNot: Bool {self._not != nil} /// Clears the value of `not`. Subsequent reads from it will return its default value. mutating func clearNot() {self._not = nil} @@ -5451,17 +4991,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _not: Int32? = nil } - struct not_eq { + struct not_eq: Sendable { // 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 notEq: Int32 { - get {return _notEq ?? 0} + get {_notEq ?? 0} set {_notEq = newValue} } /// Returns true if `notEq` has been explicitly set. - var hasNotEq: Bool {return self._notEq != nil} + var hasNotEq: Bool {self._notEq != nil} /// Clears the value of `notEq`. Subsequent reads from it will return its default value. mutating func clearNotEq() {self._notEq = nil} @@ -5472,17 +5012,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _notEq: Int32? = nil } - struct nullptr { + struct nullptr: Sendable { // 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 nullptr: Int32 { - get {return _nullptr ?? 0} + get {_nullptr ?? 0} set {_nullptr = newValue} } /// Returns true if `nullptr` has been explicitly set. - var hasNullptr: Bool {return self._nullptr != nil} + var hasNullptr: Bool {self._nullptr != nil} /// Clears the value of `nullptr`. Subsequent reads from it will return its default value. mutating func clearNullptr() {self._nullptr = nil} @@ -5493,17 +5033,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _nullptr: Int32? = nil } - struct or { + struct or: Sendable { // 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 or: Int32 { - get {return _or ?? 0} + get {_or ?? 0} set {_or = newValue} } /// Returns true if `or` has been explicitly set. - var hasOr: Bool {return self._or != nil} + var hasOr: Bool {self._or != nil} /// Clears the value of `or`. Subsequent reads from it will return its default value. mutating func clearOr() {self._or = nil} @@ -5514,17 +5054,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _or: Int32? = nil } - struct or_eq { + struct or_eq: Sendable { // 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 orEq: Int32 { - get {return _orEq ?? 0} + get {_orEq ?? 0} set {_orEq = newValue} } /// Returns true if `orEq` has been explicitly set. - var hasOrEq: Bool {return self._orEq != nil} + var hasOrEq: Bool {self._orEq != nil} /// Clears the value of `orEq`. Subsequent reads from it will return its default value. mutating func clearOrEq() {self._orEq = nil} @@ -5535,17 +5075,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _orEq: Int32? = nil } - struct protected { + struct protected: Sendable { // 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 protected: Int32 { - get {return _protected ?? 0} + get {_protected ?? 0} set {_protected = newValue} } /// Returns true if `protected` has been explicitly set. - var hasProtected: Bool {return self._protected != nil} + var hasProtected: Bool {self._protected != nil} /// Clears the value of `protected`. Subsequent reads from it will return its default value. mutating func clearProtected() {self._protected = nil} @@ -5556,17 +5096,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _protected: Int32? = nil } - struct register { + struct register: Sendable { // 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 register: Int32 { - get {return _register ?? 0} + get {_register ?? 0} set {_register = newValue} } /// Returns true if `register` has been explicitly set. - var hasRegister: Bool {return self._register != nil} + var hasRegister: Bool {self._register != nil} /// Clears the value of `register`. Subsequent reads from it will return its default value. mutating func clearRegister() {self._register = nil} @@ -5577,17 +5117,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _register: Int32? = nil } - struct reinterpret_cast { + struct reinterpret_cast: Sendable { // 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 reinterpretCast: Int32 { - get {return _reinterpretCast ?? 0} + get {_reinterpretCast ?? 0} set {_reinterpretCast = newValue} } /// Returns true if `reinterpretCast` has been explicitly set. - var hasReinterpretCast: Bool {return self._reinterpretCast != nil} + var hasReinterpretCast: Bool {self._reinterpretCast != nil} /// Clears the value of `reinterpretCast`. Subsequent reads from it will return its default value. mutating func clearReinterpretCast() {self._reinterpretCast = nil} @@ -5598,17 +5138,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _reinterpretCast: Int32? = nil } - struct short { + struct short: Sendable { // 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 short: Int32 { - get {return _short ?? 0} + get {_short ?? 0} set {_short = newValue} } /// Returns true if `short` has been explicitly set. - var hasShort: Bool {return self._short != nil} + var hasShort: Bool {self._short != nil} /// Clears the value of `short`. Subsequent reads from it will return its default value. mutating func clearShort() {self._short = nil} @@ -5619,17 +5159,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _short: Int32? = nil } - struct signed { + struct signed: Sendable { // 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 signed: Int32 { - get {return _signed ?? 0} + get {_signed ?? 0} set {_signed = newValue} } /// Returns true if `signed` has been explicitly set. - var hasSigned: Bool {return self._signed != nil} + var hasSigned: Bool {self._signed != nil} /// Clears the value of `signed`. Subsequent reads from it will return its default value. mutating func clearSigned() {self._signed = nil} @@ -5640,17 +5180,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _signed: Int32? = nil } - struct sizeof { + struct sizeof: Sendable { // 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 sizeof: Int32 { - get {return _sizeof ?? 0} + get {_sizeof ?? 0} set {_sizeof = newValue} } /// Returns true if `sizeof` has been explicitly set. - var hasSizeof: Bool {return self._sizeof != nil} + var hasSizeof: Bool {self._sizeof != nil} /// Clears the value of `sizeof`. Subsequent reads from it will return its default value. mutating func clearSizeof() {self._sizeof = nil} @@ -5661,17 +5201,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _sizeof: Int32? = nil } - struct static_assert { + struct static_assert: Sendable { // 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 staticAssert: Int32 { - get {return _staticAssert ?? 0} + get {_staticAssert ?? 0} set {_staticAssert = newValue} } /// Returns true if `staticAssert` has been explicitly set. - var hasStaticAssert: Bool {return self._staticAssert != nil} + var hasStaticAssert: Bool {self._staticAssert != nil} /// Clears the value of `staticAssert`. Subsequent reads from it will return its default value. mutating func clearStaticAssert() {self._staticAssert = nil} @@ -5682,17 +5222,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _staticAssert: Int32? = nil } - struct static_cast { + struct static_cast: Sendable { // 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 staticCast: Int32 { - get {return _staticCast ?? 0} + get {_staticCast ?? 0} set {_staticCast = newValue} } /// Returns true if `staticCast` has been explicitly set. - var hasStaticCast: Bool {return self._staticCast != nil} + var hasStaticCast: Bool {self._staticCast != nil} /// Clears the value of `staticCast`. Subsequent reads from it will return its default value. mutating func clearStaticCast() {self._staticCast = nil} @@ -5703,17 +5243,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _staticCast: Int32? = nil } - struct template { + struct template: Sendable { // 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 template: Int32 { - get {return _template ?? 0} + get {_template ?? 0} set {_template = newValue} } /// Returns true if `template` has been explicitly set. - var hasTemplate: Bool {return self._template != nil} + var hasTemplate: Bool {self._template != nil} /// Clears the value of `template`. Subsequent reads from it will return its default value. mutating func clearTemplate() {self._template = nil} @@ -5724,17 +5264,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _template: Int32? = nil } - struct this { + struct this: Sendable { // 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 this: Int32 { - get {return _this ?? 0} + get {_this ?? 0} set {_this = newValue} } /// Returns true if `this` has been explicitly set. - var hasThis: Bool {return self._this != nil} + var hasThis: Bool {self._this != nil} /// Clears the value of `this`. Subsequent reads from it will return its default value. mutating func clearThis() {self._this = nil} @@ -5745,17 +5285,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _this: Int32? = nil } - struct thread_local { + struct thread_local: Sendable { // 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 threadLocal: Int32 { - get {return _threadLocal ?? 0} + get {_threadLocal ?? 0} set {_threadLocal = newValue} } /// Returns true if `threadLocal` has been explicitly set. - var hasThreadLocal: Bool {return self._threadLocal != nil} + var hasThreadLocal: Bool {self._threadLocal != nil} /// Clears the value of `threadLocal`. Subsequent reads from it will return its default value. mutating func clearThreadLocal() {self._threadLocal = nil} @@ -5766,17 +5306,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _threadLocal: Int32? = nil } - struct typedef { + struct typedef: Sendable { // 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 typedef: Int32 { - get {return _typedef ?? 0} + get {_typedef ?? 0} set {_typedef = newValue} } /// Returns true if `typedef` has been explicitly set. - var hasTypedef: Bool {return self._typedef != nil} + var hasTypedef: Bool {self._typedef != nil} /// Clears the value of `typedef`. Subsequent reads from it will return its default value. mutating func clearTypedef() {self._typedef = nil} @@ -5787,17 +5327,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _typedef: Int32? = nil } - struct typeid { + struct typeid: Sendable { // 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 typeid: Int32 { - get {return _typeid ?? 0} + get {_typeid ?? 0} set {_typeid = newValue} } /// Returns true if `typeid` has been explicitly set. - var hasTypeid: Bool {return self._typeid != nil} + var hasTypeid: Bool {self._typeid != nil} /// Clears the value of `typeid`. Subsequent reads from it will return its default value. mutating func clearTypeid() {self._typeid = nil} @@ -5808,17 +5348,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _typeid: Int32? = nil } - struct typename { + struct typename: Sendable { // 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 typename: Int32 { - get {return _typename ?? 0} + get {_typename ?? 0} set {_typename = newValue} } /// Returns true if `typename` has been explicitly set. - var hasTypename: Bool {return self._typename != nil} + var hasTypename: Bool {self._typename != nil} /// Clears the value of `typename`. Subsequent reads from it will return its default value. mutating func clearTypename() {self._typename = nil} @@ -5829,17 +5369,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _typename: Int32? = nil } - struct union { + struct union: Sendable { // 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 union: Int32 { - get {return _union ?? 0} + get {_union ?? 0} set {_union = newValue} } /// Returns true if `union` has been explicitly set. - var hasUnion: Bool {return self._union != nil} + var hasUnion: Bool {self._union != nil} /// Clears the value of `union`. Subsequent reads from it will return its default value. mutating func clearUnion() {self._union = nil} @@ -5850,17 +5390,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _union: Int32? = nil } - struct unsigned { + struct unsigned: Sendable { // 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 unsigned: Int32 { - get {return _unsigned ?? 0} + get {_unsigned ?? 0} set {_unsigned = newValue} } /// Returns true if `unsigned` has been explicitly set. - var hasUnsigned: Bool {return self._unsigned != nil} + var hasUnsigned: Bool {self._unsigned != nil} /// Clears the value of `unsigned`. Subsequent reads from it will return its default value. mutating func clearUnsigned() {self._unsigned = nil} @@ -5871,17 +5411,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _unsigned: Int32? = nil } - struct using { + struct using: Sendable { // 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 using: Int32 { - get {return _using ?? 0} + get {_using ?? 0} set {_using = newValue} } /// Returns true if `using` has been explicitly set. - var hasUsing: Bool {return self._using != nil} + var hasUsing: Bool {self._using != nil} /// Clears the value of `using`. Subsequent reads from it will return its default value. mutating func clearUsing() {self._using = nil} @@ -5892,17 +5432,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _using: Int32? = nil } - struct virtual { + struct virtual: Sendable { // 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 virtual: Int32 { - get {return _virtual ?? 0} + get {_virtual ?? 0} set {_virtual = newValue} } /// Returns true if `virtual` has been explicitly set. - var hasVirtual: Bool {return self._virtual != nil} + var hasVirtual: Bool {self._virtual != nil} /// Clears the value of `virtual`. Subsequent reads from it will return its default value. mutating func clearVirtual() {self._virtual = nil} @@ -5913,17 +5453,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _virtual: Int32? = nil } - struct void { + struct void: Sendable { // 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 void: Int32 { - get {return _void ?? 0} + get {_void ?? 0} set {_void = newValue} } /// Returns true if `void` has been explicitly set. - var hasVoid: Bool {return self._void != nil} + var hasVoid: Bool {self._void != nil} /// Clears the value of `void`. Subsequent reads from it will return its default value. mutating func clearVoid() {self._void = nil} @@ -5934,17 +5474,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _void: Int32? = nil } - struct volatile { + struct volatile: Sendable { // 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 volatile: Int32 { - get {return _volatile ?? 0} + get {_volatile ?? 0} set {_volatile = newValue} } /// Returns true if `volatile` has been explicitly set. - var hasVolatile: Bool {return self._volatile != nil} + var hasVolatile: Bool {self._volatile != nil} /// Clears the value of `volatile`. Subsequent reads from it will return its default value. mutating func clearVolatile() {self._volatile = nil} @@ -5955,17 +5495,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _volatile: Int32? = nil } - struct wchar_t { + struct wchar_t: Sendable { // 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 wcharT: Int32 { - get {return _wcharT ?? 0} + get {_wcharT ?? 0} set {_wcharT = newValue} } /// Returns true if `wcharT` has been explicitly set. - var hasWcharT: Bool {return self._wcharT != nil} + var hasWcharT: Bool {self._wcharT != nil} /// Clears the value of `wcharT`. Subsequent reads from it will return its default value. mutating func clearWcharT() {self._wcharT = nil} @@ -5976,17 +5516,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _wcharT: Int32? = nil } - struct xor { + struct xor: Sendable { // 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 xor: Int32 { - get {return _xor ?? 0} + get {_xor ?? 0} set {_xor = newValue} } /// Returns true if `xor` has been explicitly set. - var hasXor: Bool {return self._xor != nil} + var hasXor: Bool {self._xor != nil} /// Clears the value of `xor`. Subsequent reads from it will return its default value. mutating func clearXor() {self._xor = nil} @@ -5997,17 +5537,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _xor: Int32? = nil } - struct xor_eq { + struct xor_eq: Sendable { // 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 xorEq: Int32 { - get {return _xorEq ?? 0} + get {_xorEq ?? 0} set {_xorEq = newValue} } /// Returns true if `xorEq` has been explicitly set. - var hasXorEq: Bool {return self._xorEq != nil} + var hasXorEq: Bool {self._xorEq != nil} /// Clears the value of `xorEq`. Subsequent reads from it will return its default value. mutating func clearXorEq() {self._xorEq = nil} @@ -6018,17 +5558,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _xorEq: Int32? = nil } - struct restrict { + struct restrict: Sendable { // 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 restrict: Int32 { - get {return _restrict ?? 0} + get {_restrict ?? 0} set {_restrict = newValue} } /// Returns true if `restrict` has been explicitly set. - var hasRestrict: Bool {return self._restrict != nil} + var hasRestrict: Bool {self._restrict != nil} /// Clears the value of `restrict`. Subsequent reads from it will return its default value. mutating func clearRestrict() {self._restrict = nil} @@ -6039,17 +5579,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _restrict: Int32? = nil } - struct Category { + struct Category: Sendable { // 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 category: Int32 { - get {return _category ?? 0} + get {_category ?? 0} set {_category = newValue} } /// Returns true if `category` has been explicitly set. - var hasCategory: Bool {return self._category != nil} + var hasCategory: Bool {self._category != nil} /// Clears the value of `category`. Subsequent reads from it will return its default value. mutating func clearCategory() {self._category = nil} @@ -6060,17 +5600,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _category: Int32? = nil } - struct Ivar { + struct Ivar: Sendable { // 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 ivar: Int32 { - get {return _ivar ?? 0} + get {_ivar ?? 0} set {_ivar = newValue} } /// Returns true if `ivar` has been explicitly set. - var hasIvar: Bool {return self._ivar != nil} + var hasIvar: Bool {self._ivar != nil} /// Clears the value of `ivar`. Subsequent reads from it will return its default value. mutating func clearIvar() {self._ivar = nil} @@ -6081,17 +5621,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _ivar: Int32? = nil } - struct Method { + struct Method: Sendable { // 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 method: Int32 { - get {return _method ?? 0} + get {_method ?? 0} set {_method = newValue} } /// Returns true if `method` has been explicitly set. - var hasMethod: Bool {return self._method != nil} + var hasMethod: Bool {self._method != nil} /// Clears the value of `method`. Subsequent reads from it will return its default value. mutating func clearMethod() {self._method = nil} @@ -6102,17 +5642,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _method: Int32? = nil } - struct finalize { + struct finalize: Sendable { // 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 finalize: Int32 { - get {return _finalize ?? 0} + get {_finalize ?? 0} set {_finalize = newValue} } /// Returns true if `finalize` has been explicitly set. - var hasFinalize: Bool {return self._finalize != nil} + var hasFinalize: Bool {self._finalize != nil} /// Clears the value of `finalize`. Subsequent reads from it will return its default value. mutating func clearFinalize() {self._finalize = nil} @@ -6123,17 +5663,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _finalize: Int32? = nil } - struct hash { + struct hash: Sendable { // 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 hash: Int32 { - get {return _hash ?? 0} + get {_hash ?? 0} set {_hash = newValue} } /// Returns true if `hash` has been explicitly set. - var hasHash: Bool {return self._hash != nil} + var hasHash: Bool {self._hash != nil} /// Clears the value of `hash`. Subsequent reads from it will return its default value. mutating func clearHash() {self._hash = nil} @@ -6144,17 +5684,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _hash: Int32? = nil } - struct dealloc { + struct dealloc: Sendable { // 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 dealloc: Int32 { - get {return _dealloc ?? 0} + get {_dealloc ?? 0} set {_dealloc = newValue} } /// Returns true if `dealloc` has been explicitly set. - var hasDealloc: Bool {return self._dealloc != nil} + var hasDealloc: Bool {self._dealloc != nil} /// Clears the value of `dealloc`. Subsequent reads from it will return its default value. mutating func clearDealloc() {self._dealloc = nil} @@ -6165,17 +5705,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _dealloc: Int32? = nil } - struct superclass { + struct superclass: Sendable { // 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 superclass: Int32 { - get {return _superclass ?? 0} + get {_superclass ?? 0} set {_superclass = newValue} } /// Returns true if `superclass` has been explicitly set. - var hasSuperclass: Bool {return self._superclass != nil} + var hasSuperclass: Bool {self._superclass != nil} /// Clears the value of `superclass`. Subsequent reads from it will return its default value. mutating func clearSuperclass() {self._superclass = nil} @@ -6186,17 +5726,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _superclass: Int32? = nil } - struct retain { + struct retain: Sendable { // 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 retain: Int32 { - get {return _retain ?? 0} + get {_retain ?? 0} set {_retain = newValue} } /// Returns true if `retain` has been explicitly set. - var hasRetain: Bool {return self._retain != nil} + var hasRetain: Bool {self._retain != nil} /// Clears the value of `retain`. Subsequent reads from it will return its default value. mutating func clearRetain() {self._retain = nil} @@ -6207,17 +5747,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _retain: Int32? = nil } - struct release { + struct release: Sendable { // 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 release: Int32 { - get {return _release ?? 0} + get {_release ?? 0} set {_release = newValue} } /// Returns true if `release` has been explicitly set. - var hasRelease: Bool {return self._release != nil} + var hasRelease: Bool {self._release != nil} /// Clears the value of `release`. Subsequent reads from it will return its default value. mutating func clearRelease() {self._release = nil} @@ -6228,17 +5768,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _release: Int32? = nil } - struct autorelease { + struct autorelease: Sendable { // 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 autorelease: Int32 { - get {return _autorelease ?? 0} + get {_autorelease ?? 0} set {_autorelease = newValue} } /// Returns true if `autorelease` has been explicitly set. - var hasAutorelease: Bool {return self._autorelease != nil} + var hasAutorelease: Bool {self._autorelease != nil} /// Clears the value of `autorelease`. Subsequent reads from it will return its default value. mutating func clearAutorelease() {self._autorelease = nil} @@ -6249,17 +5789,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _autorelease: Int32? = nil } - struct retainCount { + struct retainCount: Sendable { // 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 retainCount: Int32 { - get {return _retainCount ?? 0} + get {_retainCount ?? 0} set {_retainCount = newValue} } /// Returns true if `retainCount` has been explicitly set. - var hasRetainCount: Bool {return self._retainCount != nil} + var hasRetainCount: Bool {self._retainCount != nil} /// Clears the value of `retainCount`. Subsequent reads from it will return its default value. mutating func clearRetainCount() {self._retainCount = nil} @@ -6270,17 +5810,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _retainCount: Int32? = nil } - struct zone { + struct zone: Sendable { // 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 zone: Int32 { - get {return _zone ?? 0} + get {_zone ?? 0} set {_zone = newValue} } /// Returns true if `zone` has been explicitly set. - var hasZone: Bool {return self._zone != nil} + var hasZone: Bool {self._zone != nil} /// Clears the value of `zone`. Subsequent reads from it will return its default value. mutating func clearZone() {self._zone = nil} @@ -6291,17 +5831,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _zone: Int32? = nil } - struct isProxy { + struct isProxy: Sendable { // 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 isProxy: Int32 { - get {return _isProxy ?? 0} + get {_isProxy ?? 0} set {_isProxy = newValue} } /// Returns true if `isProxy` has been explicitly set. - var hasIsProxy: Bool {return self._isProxy != nil} + var hasIsProxy: Bool {self._isProxy != nil} /// Clears the value of `isProxy`. Subsequent reads from it will return its default value. mutating func clearIsProxy() {self._isProxy = nil} @@ -6312,17 +5852,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _isProxy: Int32? = nil } - struct copy { + struct copy: Sendable { // 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 copy: Int32 { - get {return _copy ?? 0} + get {_copy ?? 0} set {_copy = newValue} } /// Returns true if `copy` has been explicitly set. - var hasCopy: Bool {return self._copy != nil} + var hasCopy: Bool {self._copy != nil} /// Clears the value of `copy`. Subsequent reads from it will return its default value. mutating func clearCopy() {self._copy = nil} @@ -6333,17 +5873,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _copy: Int32? = nil } - struct mutableCopy { + struct mutableCopy: Sendable { // 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 mutableCopy: Int32 { - get {return _mutableCopy ?? 0} + get {_mutableCopy ?? 0} set {_mutableCopy = newValue} } /// Returns true if `mutableCopy` has been explicitly set. - var hasMutableCopy: Bool {return self._mutableCopy != nil} + var hasMutableCopy: Bool {self._mutableCopy != nil} /// Clears the value of `mutableCopy`. Subsequent reads from it will return its default value. mutating func clearMutableCopy() {self._mutableCopy = nil} @@ -6354,17 +5894,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _mutableCopy: Int32? = nil } - struct classForCoder { + struct classForCoder: Sendable { // 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 classForCoder: Int32 { - get {return _classForCoder ?? 0} + get {_classForCoder ?? 0} set {_classForCoder = newValue} } /// Returns true if `classForCoder` has been explicitly set. - var hasClassForCoder: Bool {return self._classForCoder != nil} + var hasClassForCoder: Bool {self._classForCoder != nil} /// Clears the value of `classForCoder`. Subsequent reads from it will return its default value. mutating func clearClassForCoder() {self._classForCoder = nil} @@ -6375,17 +5915,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _classForCoder: Int32? = nil } - struct clear { + struct clear: Sendable { // 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 clear: Int32 { - get {return _clear ?? 0} + get {_clear ?? 0} set {_clear = newValue} } /// Returns true if `clear` has been explicitly set. - var hasClear: Bool {return self._clear != nil} + var hasClear: Bool {self._clear != nil} /// Clears the value of `clear`. Subsequent reads from it will return its default value. mutating func clearClear() {self._clear = nil} @@ -6396,17 +5936,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _clear: Int32? = nil } - struct data { + struct data: Sendable { // 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 data: Int32 { - get {return _data ?? 0} + get {_data ?? 0} set {_data = newValue} } /// Returns true if `data` has been explicitly set. - var hasData: Bool {return self._data != nil} + var hasData: Bool {self._data != nil} /// Clears the value of `data`. Subsequent reads from it will return its default value. mutating func clearData() {self._data = nil} @@ -6417,17 +5957,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _data: Int32? = nil } - struct delimitedData { + struct delimitedData: Sendable { // 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 delimitedData: Int32 { - get {return _delimitedData ?? 0} + get {_delimitedData ?? 0} set {_delimitedData = newValue} } /// Returns true if `delimitedData` has been explicitly set. - var hasDelimitedData: Bool {return self._delimitedData != nil} + var hasDelimitedData: Bool {self._delimitedData != nil} /// Clears the value of `delimitedData`. Subsequent reads from it will return its default value. mutating func clearDelimitedData() {self._delimitedData = nil} @@ -6438,17 +5978,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _delimitedData: Int32? = nil } - struct descriptor { + struct descriptor: Sendable { // 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 descriptor: Int32 { - get {return _descriptor ?? 0} + get {_descriptor ?? 0} set {_descriptor = newValue} } /// Returns true if `descriptor` has been explicitly set. - var hasDescriptor: Bool {return self._descriptor != nil} + var hasDescriptor: Bool {self._descriptor != nil} /// Clears the value of `descriptor`. Subsequent reads from it will return its default value. mutating func clearDescriptor() {self._descriptor = nil} @@ -6459,17 +5999,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _descriptor: Int32? = nil } - struct extensionRegistry { + struct extensionRegistry: Sendable { // 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 extensionRegistry: Int32 { - get {return _extensionRegistry ?? 0} + get {_extensionRegistry ?? 0} set {_extensionRegistry = newValue} } /// Returns true if `extensionRegistry` has been explicitly set. - var hasExtensionRegistry: Bool {return self._extensionRegistry != nil} + var hasExtensionRegistry: Bool {self._extensionRegistry != nil} /// Clears the value of `extensionRegistry`. Subsequent reads from it will return its default value. mutating func clearExtensionRegistry() {self._extensionRegistry = nil} @@ -6480,17 +6020,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _extensionRegistry: Int32? = nil } - struct extensionsCurrentlySet { + struct extensionsCurrentlySet: Sendable { // 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 extensionsCurrentlySet: Int32 { - get {return _extensionsCurrentlySet ?? 0} + get {_extensionsCurrentlySet ?? 0} set {_extensionsCurrentlySet = newValue} } /// Returns true if `extensionsCurrentlySet` has been explicitly set. - var hasExtensionsCurrentlySet: Bool {return self._extensionsCurrentlySet != nil} + var hasExtensionsCurrentlySet: Bool {self._extensionsCurrentlySet != nil} /// Clears the value of `extensionsCurrentlySet`. Subsequent reads from it will return its default value. mutating func clearExtensionsCurrentlySet() {self._extensionsCurrentlySet = nil} @@ -6501,17 +6041,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _extensionsCurrentlySet: Int32? = nil } - struct isInitializedMessage { + struct isInitializedMessage: Sendable { // 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 isInitialized_p: Int32 { - get {return _isInitialized_p ?? 0} + get {_isInitialized_p ?? 0} set {_isInitialized_p = newValue} } /// Returns true if `isInitialized_p` has been explicitly set. - var hasIsInitialized_p: Bool {return self._isInitialized_p != nil} + var hasIsInitialized_p: Bool {self._isInitialized_p != nil} /// Clears the value of `isInitialized_p`. Subsequent reads from it will return its default value. mutating func clearIsInitialized_p() {self._isInitialized_p = nil} @@ -6522,17 +6062,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _isInitialized_p: Int32? = nil } - struct serializedSize { + struct serializedSize: Sendable { // 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 serializedSize: Int32 { - get {return _serializedSize ?? 0} + get {_serializedSize ?? 0} set {_serializedSize = newValue} } /// Returns true if `serializedSize` has been explicitly set. - var hasSerializedSize: Bool {return self._serializedSize != nil} + var hasSerializedSize: Bool {self._serializedSize != nil} /// Clears the value of `serializedSize`. Subsequent reads from it will return its default value. mutating func clearSerializedSize() {self._serializedSize = nil} @@ -6543,17 +6083,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _serializedSize: Int32? = nil } - struct sortedExtensionsInUse { + struct sortedExtensionsInUse: Sendable { // 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 sortedExtensionsInUse: Int32 { - get {return _sortedExtensionsInUse ?? 0} + get {_sortedExtensionsInUse ?? 0} set {_sortedExtensionsInUse = newValue} } /// Returns true if `sortedExtensionsInUse` has been explicitly set. - var hasSortedExtensionsInUse: Bool {return self._sortedExtensionsInUse != nil} + var hasSortedExtensionsInUse: Bool {self._sortedExtensionsInUse != nil} /// Clears the value of `sortedExtensionsInUse`. Subsequent reads from it will return its default value. mutating func clearSortedExtensionsInUse() {self._sortedExtensionsInUse = nil} @@ -6564,17 +6104,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _sortedExtensionsInUse: Int32? = nil } - struct unknownFieldsMessage { + struct unknownFieldsMessage: Sendable { // 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_p: Int32 { - get {return _unknownFields_p ?? 0} + get {_unknownFields_p ?? 0} set {_unknownFields_p = newValue} } /// Returns true if `unknownFields_p` has been explicitly set. - var hasUnknownFields_p: Bool {return self._unknownFields_p != nil} + var hasUnknownFields_p: Bool {self._unknownFields_p != nil} /// Clears the value of `unknownFields_p`. Subsequent reads from it will return its default value. mutating func clearUnknownFields_p() {self._unknownFields_p = nil} @@ -6585,17 +6125,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _unknownFields_p: Int32? = nil } - struct Fixed { + struct Fixed: Sendable { // 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 fixed: Int32 { - get {return _fixed ?? 0} + get {_fixed ?? 0} set {_fixed = newValue} } /// Returns true if `fixed` has been explicitly set. - var hasFixed: Bool {return self._fixed != nil} + var hasFixed: Bool {self._fixed != nil} /// Clears the value of `fixed`. Subsequent reads from it will return its default value. mutating func clearFixed() {self._fixed = nil} @@ -6606,17 +6146,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _fixed: Int32? = nil } - struct Fract { + struct Fract: Sendable { // 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 fract: Int32 { - get {return _fract ?? 0} + get {_fract ?? 0} set {_fract = newValue} } /// Returns true if `fract` has been explicitly set. - var hasFract: Bool {return self._fract != nil} + var hasFract: Bool {self._fract != nil} /// Clears the value of `fract`. Subsequent reads from it will return its default value. mutating func clearFract() {self._fract = nil} @@ -6627,17 +6167,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _fract: Int32? = nil } - struct Size { + struct Size: Sendable { // 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 size: Int32 { - get {return _size ?? 0} + get {_size ?? 0} set {_size = newValue} } /// Returns true if `size` has been explicitly set. - var hasSize: Bool {return self._size != nil} + var hasSize: Bool {self._size != nil} /// Clears the value of `size`. Subsequent reads from it will return its default value. mutating func clearSize() {self._size = nil} @@ -6648,17 +6188,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _size: Int32? = nil } - struct LogicalAddress { + struct LogicalAddress: Sendable { // 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 logicalAddress: Int32 { - get {return _logicalAddress ?? 0} + get {_logicalAddress ?? 0} set {_logicalAddress = newValue} } /// Returns true if `logicalAddress` has been explicitly set. - var hasLogicalAddress: Bool {return self._logicalAddress != nil} + var hasLogicalAddress: Bool {self._logicalAddress != nil} /// Clears the value of `logicalAddress`. Subsequent reads from it will return its default value. mutating func clearLogicalAddress() {self._logicalAddress = nil} @@ -6669,17 +6209,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _logicalAddress: Int32? = nil } - struct PhysicalAddress { + struct PhysicalAddress: Sendable { // 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 physicalAddress: Int32 { - get {return _physicalAddress ?? 0} + get {_physicalAddress ?? 0} set {_physicalAddress = newValue} } /// Returns true if `physicalAddress` has been explicitly set. - var hasPhysicalAddress: Bool {return self._physicalAddress != nil} + var hasPhysicalAddress: Bool {self._physicalAddress != nil} /// Clears the value of `physicalAddress`. Subsequent reads from it will return its default value. mutating func clearPhysicalAddress() {self._physicalAddress = nil} @@ -6690,17 +6230,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _physicalAddress: Int32? = nil } - struct ByteCount { + struct ByteCount: Sendable { // 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 byteCount: Int32 { - get {return _byteCount ?? 0} + get {_byteCount ?? 0} set {_byteCount = newValue} } /// Returns true if `byteCount` has been explicitly set. - var hasByteCount: Bool {return self._byteCount != nil} + var hasByteCount: Bool {self._byteCount != nil} /// Clears the value of `byteCount`. Subsequent reads from it will return its default value. mutating func clearByteCount() {self._byteCount = nil} @@ -6711,17 +6251,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _byteCount: Int32? = nil } - struct ByteOffset { + struct ByteOffset: Sendable { // 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 byteOffset: Int32 { - get {return _byteOffset ?? 0} + get {_byteOffset ?? 0} set {_byteOffset = newValue} } /// Returns true if `byteOffset` has been explicitly set. - var hasByteOffset: Bool {return self._byteOffset != nil} + var hasByteOffset: Bool {self._byteOffset != nil} /// Clears the value of `byteOffset`. Subsequent reads from it will return its default value. mutating func clearByteOffset() {self._byteOffset = nil} @@ -6732,17 +6272,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _byteOffset: Int32? = nil } - struct Duration { + struct Duration: Sendable { // 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 duration: Int32 { - get {return _duration ?? 0} + get {_duration ?? 0} set {_duration = newValue} } /// Returns true if `duration` has been explicitly set. - var hasDuration: Bool {return self._duration != nil} + var hasDuration: Bool {self._duration != nil} /// Clears the value of `duration`. Subsequent reads from it will return its default value. mutating func clearDuration() {self._duration = nil} @@ -6753,17 +6293,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _duration: Int32? = nil } - struct AbsoluteTime { + struct AbsoluteTime: Sendable { // 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 absoluteTime: Int32 { - get {return _absoluteTime ?? 0} + get {_absoluteTime ?? 0} set {_absoluteTime = newValue} } /// Returns true if `absoluteTime` has been explicitly set. - var hasAbsoluteTime: Bool {return self._absoluteTime != nil} + var hasAbsoluteTime: Bool {self._absoluteTime != nil} /// Clears the value of `absoluteTime`. Subsequent reads from it will return its default value. mutating func clearAbsoluteTime() {self._absoluteTime = nil} @@ -6774,17 +6314,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _absoluteTime: Int32? = nil } - struct OptionBits { + struct OptionBits: Sendable { // 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 optionBits: Int32 { - get {return _optionBits ?? 0} + get {_optionBits ?? 0} set {_optionBits = newValue} } /// Returns true if `optionBits` has been explicitly set. - var hasOptionBits: Bool {return self._optionBits != nil} + var hasOptionBits: Bool {self._optionBits != nil} /// Clears the value of `optionBits`. Subsequent reads from it will return its default value. mutating func clearOptionBits() {self._optionBits = nil} @@ -6795,17 +6335,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _optionBits: Int32? = nil } - struct ItemCount { + struct ItemCount: Sendable { // 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 itemCount: Int32 { - get {return _itemCount ?? 0} + get {_itemCount ?? 0} set {_itemCount = newValue} } /// Returns true if `itemCount` has been explicitly set. - var hasItemCount: Bool {return self._itemCount != nil} + var hasItemCount: Bool {self._itemCount != nil} /// Clears the value of `itemCount`. Subsequent reads from it will return its default value. mutating func clearItemCount() {self._itemCount = nil} @@ -6816,17 +6356,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _itemCount: Int32? = nil } - struct PBVersion { + struct PBVersion: Sendable { // 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 pbversion: Int32 { - get {return _pbversion ?? 0} + get {_pbversion ?? 0} set {_pbversion = newValue} } /// Returns true if `pbversion` has been explicitly set. - var hasPbversion: Bool {return self._pbversion != nil} + var hasPbversion: Bool {self._pbversion != nil} /// Clears the value of `pbversion`. Subsequent reads from it will return its default value. mutating func clearPbversion() {self._pbversion = nil} @@ -6837,17 +6377,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _pbversion: Int32? = nil } - struct ScriptCode { + struct ScriptCode: Sendable { // 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 scriptCode: Int32 { - get {return _scriptCode ?? 0} + get {_scriptCode ?? 0} set {_scriptCode = newValue} } /// Returns true if `scriptCode` has been explicitly set. - var hasScriptCode: Bool {return self._scriptCode != nil} + var hasScriptCode: Bool {self._scriptCode != nil} /// Clears the value of `scriptCode`. Subsequent reads from it will return its default value. mutating func clearScriptCode() {self._scriptCode = nil} @@ -6858,17 +6398,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _scriptCode: Int32? = nil } - struct LangCode { + struct LangCode: Sendable { // 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 langCode: Int32 { - get {return _langCode ?? 0} + get {_langCode ?? 0} set {_langCode = newValue} } /// Returns true if `langCode` has been explicitly set. - var hasLangCode: Bool {return self._langCode != nil} + var hasLangCode: Bool {self._langCode != nil} /// Clears the value of `langCode`. Subsequent reads from it will return its default value. mutating func clearLangCode() {self._langCode = nil} @@ -6879,17 +6419,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _langCode: Int32? = nil } - struct RegionCode { + struct RegionCode: Sendable { // 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 regionCode: Int32 { - get {return _regionCode ?? 0} + get {_regionCode ?? 0} set {_regionCode = newValue} } /// Returns true if `regionCode` has been explicitly set. - var hasRegionCode: Bool {return self._regionCode != nil} + var hasRegionCode: Bool {self._regionCode != nil} /// Clears the value of `regionCode`. Subsequent reads from it will return its default value. mutating func clearRegionCode() {self._regionCode = nil} @@ -6900,17 +6440,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _regionCode: Int32? = nil } - struct OSType { + struct OSType: Sendable { // 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 ostype: Int32 { - get {return _ostype ?? 0} + get {_ostype ?? 0} set {_ostype = newValue} } /// Returns true if `ostype` has been explicitly set. - var hasOstype: Bool {return self._ostype != nil} + var hasOstype: Bool {self._ostype != nil} /// Clears the value of `ostype`. Subsequent reads from it will return its default value. mutating func clearOstype() {self._ostype = nil} @@ -6921,17 +6461,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _ostype: Int32? = nil } - struct ProcessSerialNumber { + struct ProcessSerialNumber: Sendable { // 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 processSerialNumber: Int32 { - get {return _processSerialNumber ?? 0} + get {_processSerialNumber ?? 0} set {_processSerialNumber = newValue} } /// Returns true if `processSerialNumber` has been explicitly set. - var hasProcessSerialNumber: Bool {return self._processSerialNumber != nil} + var hasProcessSerialNumber: Bool {self._processSerialNumber != nil} /// Clears the value of `processSerialNumber`. Subsequent reads from it will return its default value. mutating func clearProcessSerialNumber() {self._processSerialNumber = nil} @@ -6942,17 +6482,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _processSerialNumber: Int32? = nil } - struct Point { + struct Point: Sendable { // 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 point: Int32 { - get {return _point ?? 0} + get {_point ?? 0} set {_point = newValue} } /// Returns true if `point` has been explicitly set. - var hasPoint: Bool {return self._point != nil} + var hasPoint: Bool {self._point != nil} /// Clears the value of `point`. Subsequent reads from it will return its default value. mutating func clearPoint() {self._point = nil} @@ -6963,17 +6503,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _point: Int32? = nil } - struct Rect { + struct Rect: Sendable { // 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 rect: Int32 { - get {return _rect ?? 0} + get {_rect ?? 0} set {_rect = newValue} } /// Returns true if `rect` has been explicitly set. - var hasRect: Bool {return self._rect != nil} + var hasRect: Bool {self._rect != nil} /// Clears the value of `rect`. Subsequent reads from it will return its default value. mutating func clearRect() {self._rect = nil} @@ -6984,17 +6524,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _rect: Int32? = nil } - struct FixedPoint { + struct FixedPoint: Sendable { // 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 fixedPoint: Int32 { - get {return _fixedPoint ?? 0} + get {_fixedPoint ?? 0} set {_fixedPoint = newValue} } /// Returns true if `fixedPoint` has been explicitly set. - var hasFixedPoint: Bool {return self._fixedPoint != nil} + var hasFixedPoint: Bool {self._fixedPoint != nil} /// Clears the value of `fixedPoint`. Subsequent reads from it will return its default value. mutating func clearFixedPoint() {self._fixedPoint = nil} @@ -7005,17 +6545,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _fixedPoint: Int32? = nil } - struct FixedRect { + struct FixedRect: Sendable { // 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 fixedRect: Int32 { - get {return _fixedRect ?? 0} + get {_fixedRect ?? 0} set {_fixedRect = newValue} } /// Returns true if `fixedRect` has been explicitly set. - var hasFixedRect: Bool {return self._fixedRect != nil} + var hasFixedRect: Bool {self._fixedRect != nil} /// Clears the value of `fixedRect`. Subsequent reads from it will return its default value. mutating func clearFixedRect() {self._fixedRect = nil} @@ -7026,17 +6566,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _fixedRect: Int32? = nil } - struct Style { + struct Style: Sendable { // 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 style: Int32 { - get {return _style ?? 0} + get {_style ?? 0} set {_style = newValue} } /// Returns true if `style` has been explicitly set. - var hasStyle: Bool {return self._style != nil} + var hasStyle: Bool {self._style != nil} /// Clears the value of `style`. Subsequent reads from it will return its default value. mutating func clearStyle() {self._style = nil} @@ -7047,17 +6587,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _style: Int32? = nil } - struct StyleParameter { + struct StyleParameter: Sendable { // 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 styleParameter: Int32 { - get {return _styleParameter ?? 0} + get {_styleParameter ?? 0} set {_styleParameter = newValue} } /// Returns true if `styleParameter` has been explicitly set. - var hasStyleParameter: Bool {return self._styleParameter != nil} + var hasStyleParameter: Bool {self._styleParameter != nil} /// Clears the value of `styleParameter`. Subsequent reads from it will return its default value. mutating func clearStyleParameter() {self._styleParameter = nil} @@ -7068,17 +6608,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _styleParameter: Int32? = nil } - struct StyleField { + struct StyleField: Sendable { // 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 styleField: Int32 { - get {return _styleField ?? 0} + get {_styleField ?? 0} set {_styleField = newValue} } /// Returns true if `styleField` has been explicitly set. - var hasStyleField: Bool {return self._styleField != nil} + var hasStyleField: Bool {self._styleField != nil} /// Clears the value of `styleField`. Subsequent reads from it will return its default value. mutating func clearStyleField() {self._styleField = nil} @@ -7089,17 +6629,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _styleField: Int32? = nil } - struct TimeScale { + struct TimeScale: Sendable { // 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 timeScale: Int32 { - get {return _timeScale ?? 0} + get {_timeScale ?? 0} set {_timeScale = newValue} } /// Returns true if `timeScale` has been explicitly set. - var hasTimeScale: Bool {return self._timeScale != nil} + var hasTimeScale: Bool {self._timeScale != nil} /// Clears the value of `timeScale`. Subsequent reads from it will return its default value. mutating func clearTimeScale() {self._timeScale = nil} @@ -7110,17 +6650,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _timeScale: Int32? = nil } - struct TimeBase { + struct TimeBase: Sendable { // 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 timeBase: Int32 { - get {return _timeBase ?? 0} + get {_timeBase ?? 0} set {_timeBase = newValue} } /// Returns true if `timeBase` has been explicitly set. - var hasTimeBase: Bool {return self._timeBase != nil} + var hasTimeBase: Bool {self._timeBase != nil} /// Clears the value of `timeBase`. Subsequent reads from it will return its default value. mutating func clearTimeBase() {self._timeBase = nil} @@ -7131,17 +6671,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _timeBase: Int32? = nil } - struct TimeRecord { + struct TimeRecord: Sendable { // 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 timeRecord: Int32 { - get {return _timeRecord ?? 0} + get {_timeRecord ?? 0} set {_timeRecord = newValue} } /// Returns true if `timeRecord` has been explicitly set. - var hasTimeRecord: Bool {return self._timeRecord != nil} + var hasTimeRecord: Bool {self._timeRecord != nil} /// Clears the value of `timeRecord`. Subsequent reads from it will return its default value. mutating func clearTimeRecord() {self._timeRecord = nil} @@ -7152,17 +6692,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _timeRecord: Int32? = nil } - struct serializedData { + struct serializedData: Sendable { // 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 serializedData: Int32 { - get {return _serializedData ?? 0} + get {_serializedData ?? 0} set {_serializedData = newValue} } /// Returns true if `serializedData` has been explicitly set. - var hasSerializedData: Bool {return self._serializedData != nil} + var hasSerializedData: Bool {self._serializedData != nil} /// Clears the value of `serializedData`. Subsequent reads from it will return its default value. mutating func clearSerializedData() {self._serializedData = nil} @@ -7173,17 +6713,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _serializedData: Int32? = nil } - struct jsonUTF8Data { + struct jsonUTF8Data: Sendable { // 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 jsonUtf8Data: Int32 { - get {return _jsonUtf8Data ?? 0} + get {_jsonUtf8Data ?? 0} set {_jsonUtf8Data = newValue} } /// Returns true if `jsonUtf8Data` has been explicitly set. - var hasJsonUtf8Data: Bool {return self._jsonUtf8Data != nil} + var hasJsonUtf8Data: Bool {self._jsonUtf8Data != nil} /// Clears the value of `jsonUtf8Data`. Subsequent reads from it will return its default value. mutating func clearJsonUtf8Data() {self._jsonUtf8Data = nil} @@ -7194,17 +6734,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _jsonUtf8Data: Int32? = nil } - struct jsonString { + struct jsonString: Sendable { // 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 jsonString: Int32 { - get {return _jsonString ?? 0} + get {_jsonString ?? 0} set {_jsonString = newValue} } /// Returns true if `jsonString` has been explicitly set. - var hasJsonString: Bool {return self._jsonString != nil} + var hasJsonString: Bool {self._jsonString != nil} /// Clears the value of `jsonString`. Subsequent reads from it will return its default value. mutating func clearJsonString() {self._jsonString = nil} @@ -7215,17 +6755,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _jsonString: Int32? = nil } - struct Extension { + struct Extension: Sendable { // 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 `extension`: Int32 { - get {return _extension ?? 0} + get {_extension ?? 0} set {_extension = newValue} } /// Returns true if ``extension`` has been explicitly set. - var hasExtension: Bool {return self._extension != nil} + var hasExtension: Bool {self._extension != nil} /// Clears the value of ``extension``. Subsequent reads from it will return its default value. mutating func clearExtension() {self._extension = nil} @@ -7236,17 +6776,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _extension: Int32? = nil } - struct ExtensionsMessage { + struct ExtensionsMessage: Sendable { // 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 extensions: Int32 { - get {return _extensions ?? 0} + get {_extensions ?? 0} set {_extensions = newValue} } /// Returns true if `extensions` has been explicitly set. - var hasExtensions: Bool {return self._extensions != nil} + var hasExtensions: Bool {self._extensions != nil} /// Clears the value of `extensions`. Subsequent reads from it will return its default value. mutating func clearExtensions() {self._extensions = nil} @@ -7260,5879 +6800,2077 @@ struct SwiftUnittest_Names_MessageNames { init() {} } -struct SwiftUnittest_Names_EnumNames { +struct SwiftProtoTesting_Names_EnumNames: Sendable { // 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() - enum StringEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aString // = 0 + enum StringEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aString = 0 init() { self = .aString } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aString - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aString: return 0 - } - } - } - enum ProtocolEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aProtocol // = 0 + enum ProtocolEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aProtocol = 0 init() { self = .aProtocol } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aProtocol - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aProtocol: return 0 - } - } - } - enum IntEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aInt // = 0 + enum IntEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aInt = 0 init() { self = .aInt } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aInt - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aInt: return 0 - } - } - } - enum DoubleEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aDouble // = 0 + enum DoubleEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aDouble = 0 init() { self = .aDouble } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aDouble - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aDouble: return 0 - } - } - } - enum FloatEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aFloat // = 0 + enum FloatEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aFloat = 0 init() { self = .aFloat } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aFloat - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aFloat: return 0 - } - } - } - enum UIntEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aUint // = 0 + enum UIntEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aUint = 0 init() { self = .aUint } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aUint - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aUint: return 0 - } - } - } - enum hashValueEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case ahashValue // = 0 + enum hashValueEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ahashValue = 0 init() { self = .ahashValue } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ahashValue - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ahashValue: return 0 - } - } - } - enum descriptionEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case adescription // = 0 + enum descriptionEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adescription = 0 init() { self = .adescription } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adescription - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adescription: return 0 - } - } - } - enum debugDescriptionEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case adebugDescription // = 0 + enum debugDescriptionEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adebugDescription = 0 init() { self = .adebugDescription } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adebugDescription - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adebugDescription: return 0 - } - } - } - enum Swift: SwiftProtobuf.Enum { - typealias RawValue = Int - case aSwift // = 0 + enum SwiftEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aSwift = 0 init() { self = .aSwift } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aSwift - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aSwift: return 0 - } - } - } - enum UNRECOGNIZED: SwiftProtobuf.Enum { - typealias RawValue = Int - case aUnrecognized // = 0 + enum UNRECOGNIZED: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aUnrecognized = 0 init() { self = .aUnrecognized } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aUnrecognized - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aUnrecognized: return 0 - } - } - } - enum classEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aclass // = 0 + enum classEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aclass = 0 init() { self = .aclass } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aclass - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aclass: return 0 - } - } - } - enum deinitEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case adeinit // = 0 + enum deinitEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adeinit = 0 init() { self = .adeinit } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adeinit - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adeinit: return 0 - } - } - } - enum enumEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aenum // = 0 + enum enumEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aenum = 0 init() { self = .aenum } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aenum - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aenum: return 0 - } - } - } - enum extensionEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aextension // = 0 + enum extensionEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aextension = 0 init() { self = .aextension } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aextension - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aextension: return 0 - } - } - } - enum funcEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case afunc // = 0 + enum funcEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case afunc = 0 init() { self = .afunc } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .afunc - default: return nil - } - } - - var rawValue: Int { - switch self { - case .afunc: return 0 - } - } - } - enum importEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aimport // = 0 + enum importEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aimport = 0 init() { self = .aimport } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aimport - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aimport: return 0 - } - } - } - enum initEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case ainit // = 0 + enum initEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ainit = 0 init() { self = .ainit } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ainit - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ainit: return 0 - } - } - } - enum inoutEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case ainout // = 0 + enum inoutEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ainout = 0 init() { self = .ainout } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ainout - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ainout: return 0 - } - } - } - enum internalEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case ainternal // = 0 + enum internalEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ainternal = 0 init() { self = .ainternal } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ainternal - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ainternal: return 0 - } - } - } - enum letEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case alet // = 0 + enum letEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case alet = 0 init() { self = .alet } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .alet - default: return nil - } - } - - var rawValue: Int { - switch self { - case .alet: return 0 - } - } - } - enum operatorEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aoperator // = 0 + enum operatorEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aoperator = 0 init() { self = .aoperator } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aoperator - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aoperator: return 0 - } - } - } - enum privateEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aprivate // = 0 + enum privateEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aprivate = 0 init() { self = .aprivate } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aprivate - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aprivate: return 0 - } - } - } - enum protocolEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aprotocol // = 0 + enum protocolEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aprotocol = 0 init() { self = .aprotocol } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aprotocol - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aprotocol: return 0 - } - } - } - enum publicEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case apublic // = 0 + enum publicEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case apublic = 0 init() { self = .apublic } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .apublic - default: return nil - } - } - - var rawValue: Int { - switch self { - case .apublic: return 0 - } - } - } - enum staticEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case astatic // = 0 + enum staticEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case astatic = 0 init() { self = .astatic } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .astatic - default: return nil - } - } - - var rawValue: Int { - switch self { - case .astatic: return 0 - } - } - } - enum structEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case astruct // = 0 + enum structEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case astruct = 0 init() { self = .astruct } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .astruct - default: return nil - } - } - - var rawValue: Int { - switch self { - case .astruct: return 0 - } - } - } - enum subscriptEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case asubscript // = 0 + enum subscriptEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case asubscript = 0 init() { self = .asubscript } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .asubscript - default: return nil - } - } - - var rawValue: Int { - switch self { - case .asubscript: return 0 - } - } - } - enum typealiasEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case atypealias // = 0 + enum typealiasEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case atypealias = 0 init() { self = .atypealias } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .atypealias - default: return nil - } - } - - var rawValue: Int { - switch self { - case .atypealias: return 0 - } - } - } - enum varEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case avar // = 0 + enum varEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case avar = 0 init() { self = .avar } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .avar - default: return nil - } - } - - var rawValue: Int { - switch self { - case .avar: return 0 - } - } - } - enum breakEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case abreak // = 0 + enum breakEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case abreak = 0 init() { self = .abreak } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .abreak - default: return nil - } - } - - var rawValue: Int { - switch self { - case .abreak: return 0 - } - } - } - enum caseEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case acase // = 0 + enum caseEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case acase = 0 init() { self = .acase } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .acase - default: return nil - } - } - - var rawValue: Int { - switch self { - case .acase: return 0 - } - } - } - enum continueEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case acontinue // = 0 + enum continueEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case acontinue = 0 init() { self = .acontinue } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .acontinue - default: return nil - } - } - - var rawValue: Int { - switch self { - case .acontinue: return 0 - } - } - } - enum defaultEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case adefault // = 0 + enum defaultEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adefault = 0 init() { self = .adefault } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adefault - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adefault: return 0 - } - } - } - enum deferEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case adefer // = 0 + enum deferEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adefer = 0 init() { self = .adefer } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adefer - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adefer: return 0 - } - } - } - enum doEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case ado // = 0 + enum doEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ado = 0 init() { self = .ado } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ado - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ado: return 0 - } - } - } - enum elseEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aelse // = 0 + enum elseEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aelse = 0 init() { self = .aelse } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aelse - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aelse: return 0 - } - } - } - enum fallthroughEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case afallthrough // = 0 + enum fallthroughEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case afallthrough = 0 init() { self = .afallthrough } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .afallthrough - default: return nil - } - } - - var rawValue: Int { - switch self { - case .afallthrough: return 0 - } - } - } - enum forEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case afor // = 0 + enum forEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case afor = 0 init() { self = .afor } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .afor - default: return nil - } - } - - var rawValue: Int { - switch self { - case .afor: return 0 - } - } - } - enum guardEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aguard // = 0 + enum guardEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aguard = 0 init() { self = .aguard } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aguard - default: return nil - } - } + } - var rawValue: Int { - switch self { - case .aguard: return 0 - } + enum ifEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aif = 0 + + init() { + self = .aif } } - enum ifEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aif // = 0 + enum inEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ain = 0 init() { - self = .aif - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aif - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aif: return 0 - } - } - - } - - enum inEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case ain // = 0 - - init() { - self = .ain - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ain - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ain: return 0 - } + self = .ain } } - enum repeatEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case arepeat // = 0 + enum repeatEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case arepeat = 0 init() { self = .arepeat } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .arepeat - default: return nil - } - } - - var rawValue: Int { - switch self { - case .arepeat: return 0 - } - } - } - enum returnEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case areturn // = 0 + enum returnEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case areturn = 0 init() { self = .areturn } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .areturn - default: return nil - } - } - - var rawValue: Int { - switch self { - case .areturn: return 0 - } - } - } - enum switchEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aswitch // = 0 + enum switchEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aswitch = 0 init() { self = .aswitch } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aswitch - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aswitch: return 0 - } - } - } - enum whereEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case awhere // = 0 + enum whereEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case awhere = 0 init() { self = .awhere } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .awhere - default: return nil - } - } - - var rawValue: Int { - switch self { - case .awhere: return 0 - } - } - } - enum whileEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case awhile // = 0 + enum whileEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case awhile = 0 init() { self = .awhile } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .awhile - default: return nil - } - } - - var rawValue: Int { - switch self { - case .awhile: return 0 - } - } - } - enum asEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aas // = 0 + enum asEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aas = 0 init() { self = .aas } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aas - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aas: return 0 - } - } - } - enum catchEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case acatch // = 0 + enum catchEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case acatch = 0 init() { self = .acatch } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .acatch - default: return nil - } - } - - var rawValue: Int { - switch self { - case .acatch: return 0 - } - } - } - enum dynamicTypeEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case adynamicType // = 0 + enum dynamicTypeEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adynamicType = 0 init() { self = .adynamicType } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adynamicType - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adynamicType: return 0 - } - } - } - enum falseEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case afalse // = 0 + enum falseEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case afalse = 0 init() { self = .afalse } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .afalse - default: return nil - } - } - - var rawValue: Int { - switch self { - case .afalse: return 0 - } - } - } - enum isEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case ais // = 0 + enum isEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ais = 0 init() { self = .ais } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ais - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ais: return 0 - } - } - } - enum nilEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case anil // = 0 + enum nilEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case anil = 0 init() { self = .anil } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .anil - default: return nil - } - } - - var rawValue: Int { - switch self { - case .anil: return 0 - } - } - } - enum rethrowsEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case arethrows // = 0 + enum rethrowsEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case arethrows = 0 init() { self = .arethrows } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .arethrows - default: return nil - } - } - - var rawValue: Int { - switch self { - case .arethrows: return 0 - } - } - } - enum superEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case asuper // = 0 + enum superEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case asuper = 0 init() { self = .asuper } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .asuper - default: return nil - } - } - - var rawValue: Int { - switch self { - case .asuper: return 0 - } - } - } - enum selfEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aself // = 0 + enum selfEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aself = 0 init() { self = .aself } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aself - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aself: return 0 - } - } - } - enum throwEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case athrow // = 0 + enum throwEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case athrow = 0 init() { self = .athrow } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .athrow - default: return nil - } - } - - var rawValue: Int { - switch self { - case .athrow: return 0 - } - } - } - enum throwsEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case athrows // = 0 + enum throwsEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case athrows = 0 init() { self = .athrows } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .athrows - default: return nil - } - } - - var rawValue: Int { - switch self { - case .athrows: return 0 - } - } - } - enum trueEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case atrue // = 0 + enum trueEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case atrue = 0 init() { self = .atrue } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .atrue - default: return nil - } - } - - var rawValue: Int { - switch self { - case .atrue: return 0 - } - } - } - enum tryEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case atry // = 0 + enum tryEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case atry = 0 init() { self = .atry } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .atry - default: return nil - } - } - - var rawValue: Int { - switch self { - case .atry: return 0 - } - } - } - enum __COLUMN__Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case a_Column__ // = 0 + enum __COLUMN__Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case a_Column__ = 0 init() { self = .a_Column__ } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .a_Column__ - default: return nil - } - } - - var rawValue: Int { - switch self { - case .a_Column__: return 0 - } - } - } - enum __FILE__Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case a_File__ // = 0 + enum __FILE__Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case a_File__ = 0 init() { self = .a_File__ } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .a_File__ - default: return nil - } - } - - var rawValue: Int { - switch self { - case .a_File__: return 0 - } - } - } - enum __FUNCTION__Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case a_Function__ // = 0 + enum __FUNCTION__Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case a_Function__ = 0 init() { self = .a_Function__ } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .a_Function__ - default: return nil - } - } - - var rawValue: Int { - switch self { - case .a_Function__: return 0 - } - } - } - enum __LINE__Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case a_Line__ // = 0 + enum __LINE__Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case a_Line__ = 0 init() { self = .a_Line__ } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .a_Line__ - default: return nil - } - } - - var rawValue: Int { - switch self { - case .a_Line__: return 0 - } - } - } - enum _Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case a_ // = 0 + enum _Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case a_ = 0 init() { self = .a_ } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .a_ - default: return nil - } - } - - var rawValue: Int { - switch self { - case .a_: return 0 - } - } - } - enum __Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case a__ // = 0 + enum __Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case a__ = 0 init() { self = .a__ } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .a__ - default: return nil - } - } - - var rawValue: Int { - switch self { - case .a__: return 0 - } - } - } - enum associativity: SwiftProtobuf.Enum { - typealias RawValue = Int - case aassociativity // = 0 + enum associativity: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aassociativity = 0 init() { self = .aassociativity } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aassociativity - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aassociativity: return 0 - } - } - } - enum convenience: SwiftProtobuf.Enum { - typealias RawValue = Int - case aconvenience // = 0 + enum convenience: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aconvenience = 0 init() { self = .aconvenience } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aconvenience - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aconvenience: return 0 - } - } - } - enum dynamic: SwiftProtobuf.Enum { - typealias RawValue = Int - case adynamic // = 0 + enum dynamic: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adynamic = 0 init() { self = .adynamic } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adynamic - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adynamic: return 0 - } - } - } - enum didSet: SwiftProtobuf.Enum { - typealias RawValue = Int - case adidSet // = 0 + enum didSet: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adidSet = 0 init() { self = .adidSet } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adidSet - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adidSet: return 0 - } - } - } - enum final: SwiftProtobuf.Enum { - typealias RawValue = Int - case afinal // = 0 + enum final: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case afinal = 0 init() { self = .afinal } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .afinal - default: return nil - } - } - - var rawValue: Int { - switch self { - case .afinal: return 0 - } - } - } - enum get: SwiftProtobuf.Enum { - typealias RawValue = Int - case aget // = 0 + enum get: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aget = 0 init() { self = .aget } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aget - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aget: return 0 - } - } - } - enum infix: SwiftProtobuf.Enum { - typealias RawValue = Int - case ainfix // = 0 + enum infix: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ainfix = 0 init() { self = .ainfix } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ainfix - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ainfix: return 0 - } - } - } - enum indirect: SwiftProtobuf.Enum { - typealias RawValue = Int - case aindirect // = 0 + enum indirect: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aindirect = 0 init() { self = .aindirect } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aindirect - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aindirect: return 0 - } - } - } - enum lazy: SwiftProtobuf.Enum { - typealias RawValue = Int - case alazy // = 0 + enum lazy: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case alazy = 0 init() { self = .alazy } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .alazy - default: return nil - } - } - - var rawValue: Int { - switch self { - case .alazy: return 0 - } - } - } - enum left: SwiftProtobuf.Enum { - typealias RawValue = Int - case aleft // = 0 + enum left: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aleft = 0 init() { self = .aleft } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aleft - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aleft: return 0 - } - } - } - enum mutating: SwiftProtobuf.Enum { - typealias RawValue = Int - case amutating // = 0 + enum mutating: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case amutating = 0 init() { self = .amutating } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .amutating - default: return nil - } - } - - var rawValue: Int { - switch self { - case .amutating: return 0 - } - } - } - enum none: SwiftProtobuf.Enum { - typealias RawValue = Int - case anone // = 0 + enum none: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case anone = 0 init() { self = .anone } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .anone - default: return nil - } - } - - var rawValue: Int { - switch self { - case .anone: return 0 - } - } - } - enum nonmutating: SwiftProtobuf.Enum { - typealias RawValue = Int - case anonmutating // = 0 + enum nonmutating: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case anonmutating = 0 init() { self = .anonmutating } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .anonmutating - default: return nil - } - } - - var rawValue: Int { - switch self { - case .anonmutating: return 0 - } - } - } - enum optional: SwiftProtobuf.Enum { - typealias RawValue = Int - case aoptional // = 0 + enum optional: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aoptional = 0 init() { self = .aoptional } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aoptional - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aoptional: return 0 - } - } - } - enum override: SwiftProtobuf.Enum { - typealias RawValue = Int - case aoverride // = 0 + enum override: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aoverride = 0 init() { self = .aoverride } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aoverride - default: return nil - } - } + } - var rawValue: Int { - switch self { - case .aoverride: return 0 - } + enum postfix: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case apostfix = 0 + + init() { + self = .apostfix } } - enum postfix: SwiftProtobuf.Enum { - typealias RawValue = Int - case apostfix // = 0 + enum precedence: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aprecedence = 0 init() { - self = .apostfix - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .apostfix - default: return nil - } - } - - var rawValue: Int { - switch self { - case .apostfix: return 0 - } - } - - } - - enum precedence: SwiftProtobuf.Enum { - typealias RawValue = Int - case aprecedence // = 0 - - init() { - self = .aprecedence - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aprecedence - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aprecedence: return 0 - } + self = .aprecedence } } - enum prefix: SwiftProtobuf.Enum { - typealias RawValue = Int - case aprefix // = 0 + enum prefix: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aprefix = 0 init() { self = .aprefix } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aprefix - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aprefix: return 0 - } - } - } - enum required: SwiftProtobuf.Enum { - typealias RawValue = Int - case arequired // = 0 + enum required: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case arequired = 0 init() { self = .arequired } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .arequired - default: return nil - } - } - - var rawValue: Int { - switch self { - case .arequired: return 0 - } - } - } - enum right: SwiftProtobuf.Enum { - typealias RawValue = Int - case aright // = 0 + enum right: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aright = 0 init() { self = .aright } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aright - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aright: return 0 - } - } - } - enum set: SwiftProtobuf.Enum { - typealias RawValue = Int - case aset // = 0 + enum set: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aset = 0 init() { self = .aset } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aset - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aset: return 0 - } - } - } - enum TypeEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aType // = 0 + enum TypeEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aType = 0 init() { self = .aType } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aType - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aType: return 0 - } - } - } - enum unowned: SwiftProtobuf.Enum { - typealias RawValue = Int - case aunowned // = 0 + enum unowned: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aunowned = 0 init() { self = .aunowned } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aunowned - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aunowned: return 0 - } - } - } - enum weak: SwiftProtobuf.Enum { - typealias RawValue = Int - case aweak // = 0 + enum weak: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aweak = 0 init() { self = .aweak } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aweak - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aweak: return 0 - } - } - } - enum willSet: SwiftProtobuf.Enum { - typealias RawValue = Int - case awillSet // = 0 + enum willSet: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case awillSet = 0 init() { self = .awillSet } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .awillSet - default: return nil - } - } - - var rawValue: Int { - switch self { - case .awillSet: return 0 - } - } - } - enum id: SwiftProtobuf.Enum { - typealias RawValue = Int - case aid // = 0 + enum id: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aid = 0 init() { self = .aid } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aid - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aid: return 0 - } - } - } - enum _cmd: SwiftProtobuf.Enum { - typealias RawValue = Int - case aCmd // = 0 + enum _cmd: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aCmd = 0 init() { self = .aCmd } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aCmd - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aCmd: return 0 - } - } - } - enum out: SwiftProtobuf.Enum { - typealias RawValue = Int - case aout // = 0 + enum out: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aout = 0 init() { self = .aout } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aout - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aout: return 0 - } - } - } - enum bycopy: SwiftProtobuf.Enum { - typealias RawValue = Int - case abycopy // = 0 + enum bycopy: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case abycopy = 0 init() { self = .abycopy } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .abycopy - default: return nil - } - } - - var rawValue: Int { - switch self { - case .abycopy: return 0 - } - } - } - enum byref: SwiftProtobuf.Enum { - typealias RawValue = Int - case abyref // = 0 + enum byref: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case abyref = 0 init() { self = .abyref } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .abyref - default: return nil - } - } - - var rawValue: Int { - switch self { - case .abyref: return 0 - } - } - } - enum oneway: SwiftProtobuf.Enum { - typealias RawValue = Int - case aoneway // = 0 + enum oneway: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aoneway = 0 init() { self = .aoneway } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aoneway - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aoneway: return 0 - } - } - } - enum and: SwiftProtobuf.Enum { - typealias RawValue = Int - case aand // = 0 + enum and: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aand = 0 init() { self = .aand } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aand - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aand: return 0 - } - } - } - enum and_eq: SwiftProtobuf.Enum { - typealias RawValue = Int - case aandEq // = 0 + enum and_eq: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aandEq = 0 init() { self = .aandEq } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aandEq - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aandEq: return 0 - } - } - } - enum alignas: SwiftProtobuf.Enum { - typealias RawValue = Int - case aalignas // = 0 + enum alignas: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aalignas = 0 init() { self = .aalignas } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aalignas - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aalignas: return 0 - } - } - } - enum alignof: SwiftProtobuf.Enum { - typealias RawValue = Int - case aalignof // = 0 + enum alignof: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aalignof = 0 init() { self = .aalignof } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aalignof - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aalignof: return 0 - } - } - } - enum asm: SwiftProtobuf.Enum { - typealias RawValue = Int - case aasm // = 0 + enum asm: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aasm = 0 init() { self = .aasm } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aasm - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aasm: return 0 - } - } - } - enum auto: SwiftProtobuf.Enum { - typealias RawValue = Int - case aauto // = 0 + enum auto: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aauto = 0 init() { self = .aauto } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aauto - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aauto: return 0 - } - } - } - enum bitand: SwiftProtobuf.Enum { - typealias RawValue = Int - case abitand // = 0 + enum bitand: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case abitand = 0 init() { self = .abitand } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .abitand - default: return nil - } - } - - var rawValue: Int { - switch self { - case .abitand: return 0 - } - } - } - enum bitor: SwiftProtobuf.Enum { - typealias RawValue = Int - case abitor // = 0 + enum bitor: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case abitor = 0 init() { self = .abitor } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .abitor - default: return nil - } - } - - var rawValue: Int { - switch self { - case .abitor: return 0 - } - } - } - enum bool: SwiftProtobuf.Enum { - typealias RawValue = Int - case abool // = 0 + enum bool: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case abool = 0 init() { self = .abool } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .abool - default: return nil - } - } - - var rawValue: Int { - switch self { - case .abool: return 0 - } - } - } - enum char: SwiftProtobuf.Enum { - typealias RawValue = Int - case achar // = 0 + enum char: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case achar = 0 init() { self = .achar } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .achar - default: return nil - } - } - - var rawValue: Int { - switch self { - case .achar: return 0 - } - } - } - enum char16_t: SwiftProtobuf.Enum { - typealias RawValue = Int - case achar16T // = 0 + enum char16_t: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case achar16T = 0 init() { self = .achar16T } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .achar16T - default: return nil - } - } - - var rawValue: Int { - switch self { - case .achar16T: return 0 - } - } - } - enum char32_t: SwiftProtobuf.Enum { - typealias RawValue = Int - case achar32T // = 0 + enum char32_t: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case achar32T = 0 init() { self = .achar32T } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .achar32T - default: return nil - } - } - - var rawValue: Int { - switch self { - case .achar32T: return 0 - } - } - } - enum compl: SwiftProtobuf.Enum { - typealias RawValue = Int - case acompl // = 0 + enum compl: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case acompl = 0 init() { self = .acompl } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .acompl - default: return nil - } - } - - var rawValue: Int { - switch self { - case .acompl: return 0 - } - } - } - enum const: SwiftProtobuf.Enum { - typealias RawValue = Int - case aconst // = 0 + enum const: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aconst = 0 init() { self = .aconst } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aconst - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aconst: return 0 - } - } - } - enum constexpr: SwiftProtobuf.Enum { - typealias RawValue = Int - case aconstexpr // = 0 + enum constexpr: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aconstexpr = 0 init() { self = .aconstexpr } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aconstexpr - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aconstexpr: return 0 - } - } - } - enum const_cast: SwiftProtobuf.Enum { - typealias RawValue = Int - case aconstCast // = 0 + enum const_cast: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aconstCast = 0 init() { self = .aconstCast } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aconstCast - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aconstCast: return 0 - } - } - } - enum decltype: SwiftProtobuf.Enum { - typealias RawValue = Int - case adecltype // = 0 + enum decltype: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adecltype = 0 init() { self = .adecltype } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adecltype - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adecltype: return 0 - } - } - } - enum delete: SwiftProtobuf.Enum { - typealias RawValue = Int - case adelete // = 0 + enum delete: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adelete = 0 init() { self = .adelete } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adelete - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adelete: return 0 - } - } - } - enum dynamic_cast: SwiftProtobuf.Enum { - typealias RawValue = Int - case adynamicCast // = 0 + enum dynamic_cast: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adynamicCast = 0 init() { self = .adynamicCast } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adynamicCast - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adynamicCast: return 0 - } - } - } - enum explicit: SwiftProtobuf.Enum { - typealias RawValue = Int - case aexplicit // = 0 + enum explicit: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aexplicit = 0 init() { self = .aexplicit } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aexplicit - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aexplicit: return 0 - } - } - } - enum export: SwiftProtobuf.Enum { - typealias RawValue = Int - case aexport // = 0 + enum export: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aexport = 0 init() { self = .aexport } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aexport - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aexport: return 0 - } - } - } - enum extern: SwiftProtobuf.Enum { - typealias RawValue = Int - case aextern // = 0 + enum extern: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aextern = 0 init() { self = .aextern } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aextern - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aextern: return 0 - } - } - } - enum friend: SwiftProtobuf.Enum { - typealias RawValue = Int - case afriend // = 0 + enum friend: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case afriend = 0 init() { self = .afriend } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .afriend - default: return nil - } - } - - var rawValue: Int { - switch self { - case .afriend: return 0 - } - } - } - enum goto: SwiftProtobuf.Enum { - typealias RawValue = Int - case agoto // = 0 + enum goto: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case agoto = 0 init() { self = .agoto } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .agoto - default: return nil - } - } - - var rawValue: Int { - switch self { - case .agoto: return 0 - } - } - } - enum inline: SwiftProtobuf.Enum { - typealias RawValue = Int - case ainline // = 0 + enum inline: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ainline = 0 init() { self = .ainline } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ainline - default: return nil - } - } + } - var rawValue: Int { - switch self { - case .ainline: return 0 - } + enum long: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case along = 0 + + init() { + self = .along } } - enum long: SwiftProtobuf.Enum { - typealias RawValue = Int - case along // = 0 + enum mutable: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case amutable = 0 init() { - self = .along - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .along - default: return nil - } - } - - var rawValue: Int { - switch self { - case .along: return 0 - } - } - - } - - enum mutable: SwiftProtobuf.Enum { - typealias RawValue = Int - case amutable // = 0 - - init() { - self = .amutable - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .amutable - default: return nil - } - } - - var rawValue: Int { - switch self { - case .amutable: return 0 - } + self = .amutable } } - enum namespace: SwiftProtobuf.Enum { - typealias RawValue = Int - case anamespace // = 0 + enum namespace: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case anamespace = 0 init() { self = .anamespace } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .anamespace - default: return nil - } - } - - var rawValue: Int { - switch self { - case .anamespace: return 0 - } - } - } - enum new: SwiftProtobuf.Enum { - typealias RawValue = Int - case anew // = 0 + enum new: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case anew = 0 init() { self = .anew } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .anew - default: return nil - } - } - - var rawValue: Int { - switch self { - case .anew: return 0 - } - } - } - enum noexcept: SwiftProtobuf.Enum { - typealias RawValue = Int - case anoexcept // = 0 + enum noexcept: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case anoexcept = 0 init() { self = .anoexcept } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .anoexcept - default: return nil - } - } - - var rawValue: Int { - switch self { - case .anoexcept: return 0 - } - } - } - enum not: SwiftProtobuf.Enum { - typealias RawValue = Int - case anot // = 0 + enum not: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case anot = 0 init() { self = .anot } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .anot - default: return nil - } - } - - var rawValue: Int { - switch self { - case .anot: return 0 - } - } - } - enum not_eq: SwiftProtobuf.Enum { - typealias RawValue = Int - case anotEq // = 0 + enum not_eq: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case anotEq = 0 init() { self = .anotEq } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .anotEq - default: return nil - } - } - - var rawValue: Int { - switch self { - case .anotEq: return 0 - } - } - } - enum nullptr: SwiftProtobuf.Enum { - typealias RawValue = Int - case anullptr // = 0 + enum nullptr: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case anullptr = 0 init() { self = .anullptr } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .anullptr - default: return nil - } - } - - var rawValue: Int { - switch self { - case .anullptr: return 0 - } - } - } - enum or: SwiftProtobuf.Enum { - typealias RawValue = Int - case aor // = 0 + enum or: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aor = 0 init() { self = .aor } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aor - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aor: return 0 - } - } - } - enum or_eq: SwiftProtobuf.Enum { - typealias RawValue = Int - case aorEq // = 0 + enum or_eq: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aorEq = 0 init() { self = .aorEq } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aorEq - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aorEq: return 0 - } - } - } - enum protected: SwiftProtobuf.Enum { - typealias RawValue = Int - case aprotected // = 0 + enum protected: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aprotected = 0 init() { self = .aprotected } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aprotected - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aprotected: return 0 - } - } - } - enum register: SwiftProtobuf.Enum { - typealias RawValue = Int - case aregister // = 0 + enum register: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aregister = 0 init() { self = .aregister } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aregister - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aregister: return 0 - } - } - } - enum reinterpret_cast: SwiftProtobuf.Enum { - typealias RawValue = Int - case areinterpretCast // = 0 + enum reinterpret_cast: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case areinterpretCast = 0 init() { self = .areinterpretCast } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .areinterpretCast - default: return nil - } - } - - var rawValue: Int { - switch self { - case .areinterpretCast: return 0 - } - } - } - enum short: SwiftProtobuf.Enum { - typealias RawValue = Int - case ashort // = 0 + enum short: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ashort = 0 init() { self = .ashort } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ashort - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ashort: return 0 - } - } - } - enum signed: SwiftProtobuf.Enum { - typealias RawValue = Int - case asigned // = 0 + enum signed: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case asigned = 0 init() { self = .asigned } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .asigned - default: return nil - } - } - - var rawValue: Int { - switch self { - case .asigned: return 0 - } - } - } - enum sizeof: SwiftProtobuf.Enum { - typealias RawValue = Int - case asizeof // = 0 + enum sizeof: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case asizeof = 0 init() { self = .asizeof } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .asizeof - default: return nil - } - } - - var rawValue: Int { - switch self { - case .asizeof: return 0 - } - } - } - enum static_assert: SwiftProtobuf.Enum { - typealias RawValue = Int - case astaticAssert // = 0 + enum static_assert: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case astaticAssert = 0 init() { self = .astaticAssert } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .astaticAssert - default: return nil - } - } - - var rawValue: Int { - switch self { - case .astaticAssert: return 0 - } - } - } - enum static_cast: SwiftProtobuf.Enum { - typealias RawValue = Int - case astaticCast // = 0 + enum static_cast: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case astaticCast = 0 init() { self = .astaticCast } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .astaticCast - default: return nil - } - } - - var rawValue: Int { - switch self { - case .astaticCast: return 0 - } - } - } - enum template: SwiftProtobuf.Enum { - typealias RawValue = Int - case atemplate // = 0 + enum template: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case atemplate = 0 init() { self = .atemplate } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .atemplate - default: return nil - } - } - - var rawValue: Int { - switch self { - case .atemplate: return 0 - } - } - } - enum this: SwiftProtobuf.Enum { - typealias RawValue = Int - case athis // = 0 + enum this: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case athis = 0 init() { self = .athis } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .athis - default: return nil - } - } - - var rawValue: Int { - switch self { - case .athis: return 0 - } - } - } - enum thread_local: SwiftProtobuf.Enum { - typealias RawValue = Int - case athreadLocal // = 0 + enum thread_local: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case athreadLocal = 0 init() { self = .athreadLocal } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .athreadLocal - default: return nil - } - } - - var rawValue: Int { - switch self { - case .athreadLocal: return 0 - } - } - } - enum typedef: SwiftProtobuf.Enum { - typealias RawValue = Int - case atypedef // = 0 + enum typedef: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case atypedef = 0 init() { self = .atypedef } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .atypedef - default: return nil - } - } - - var rawValue: Int { - switch self { - case .atypedef: return 0 - } - } - } - enum typeid: SwiftProtobuf.Enum { - typealias RawValue = Int - case atypeid // = 0 + enum typeid: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case atypeid = 0 init() { self = .atypeid } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .atypeid - default: return nil - } - } - - var rawValue: Int { - switch self { - case .atypeid: return 0 - } - } - } - enum typename: SwiftProtobuf.Enum { - typealias RawValue = Int - case atypename // = 0 + enum typename: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case atypename = 0 init() { self = .atypename } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .atypename - default: return nil - } - } - - var rawValue: Int { - switch self { - case .atypename: return 0 - } - } - } - enum union: SwiftProtobuf.Enum { - typealias RawValue = Int - case aunion // = 0 + enum union: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aunion = 0 init() { self = .aunion } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aunion - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aunion: return 0 - } - } - } - enum unsigned: SwiftProtobuf.Enum { - typealias RawValue = Int - case aunsigned // = 0 + enum unsigned: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aunsigned = 0 init() { self = .aunsigned } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aunsigned - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aunsigned: return 0 - } - } - } - enum using: SwiftProtobuf.Enum { - typealias RawValue = Int - case ausing // = 0 + enum using: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ausing = 0 init() { self = .ausing } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ausing - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ausing: return 0 - } - } - } - enum virtual: SwiftProtobuf.Enum { - typealias RawValue = Int - case avirtual // = 0 + enum virtual: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case avirtual = 0 init() { self = .avirtual } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .avirtual - default: return nil - } - } - - var rawValue: Int { - switch self { - case .avirtual: return 0 - } - } - } - enum void: SwiftProtobuf.Enum { - typealias RawValue = Int - case avoid // = 0 + enum void: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case avoid = 0 init() { self = .avoid } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .avoid - default: return nil - } - } - - var rawValue: Int { - switch self { - case .avoid: return 0 - } - } - } - enum volatile: SwiftProtobuf.Enum { - typealias RawValue = Int - case avolatile // = 0 + enum volatile: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case avolatile = 0 init() { self = .avolatile } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .avolatile - default: return nil - } - } - - var rawValue: Int { - switch self { - case .avolatile: return 0 - } - } - } - enum wchar_t: SwiftProtobuf.Enum { - typealias RawValue = Int - case awcharT // = 0 + enum wchar_t: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case awcharT = 0 init() { self = .awcharT } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .awcharT - default: return nil - } - } - - var rawValue: Int { - switch self { - case .awcharT: return 0 - } - } - } - enum xor: SwiftProtobuf.Enum { - typealias RawValue = Int - case axor // = 0 + enum xor: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case axor = 0 init() { self = .axor } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .axor - default: return nil - } - } - - var rawValue: Int { - switch self { - case .axor: return 0 - } - } - } - enum xor_eq: SwiftProtobuf.Enum { - typealias RawValue = Int - case axorEq // = 0 + enum xor_eq: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case axorEq = 0 init() { self = .axorEq } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .axorEq - default: return nil - } - } - - var rawValue: Int { - switch self { - case .axorEq: return 0 - } - } - } - enum restrict: SwiftProtobuf.Enum { - typealias RawValue = Int - case arestrict // = 0 + enum restrict: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case arestrict = 0 init() { self = .arestrict } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .arestrict - default: return nil - } - } - - var rawValue: Int { - switch self { - case .arestrict: return 0 - } - } - } - enum Category: SwiftProtobuf.Enum { - typealias RawValue = Int - case aCategory // = 0 + enum Category: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aCategory = 0 init() { self = .aCategory } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aCategory - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aCategory: return 0 - } - } - } - enum Ivar: SwiftProtobuf.Enum { - typealias RawValue = Int - case aIvar // = 0 + enum Ivar: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aIvar = 0 init() { self = .aIvar } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aIvar - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aIvar: return 0 - } - } - } - enum Method: SwiftProtobuf.Enum { - typealias RawValue = Int - case aMethod // = 0 + enum Method: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aMethod = 0 init() { self = .aMethod } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aMethod - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aMethod: return 0 - } - } - } - enum finalize: SwiftProtobuf.Enum { - typealias RawValue = Int - case afinalize // = 0 + enum finalize: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case afinalize = 0 init() { self = .afinalize } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .afinalize - default: return nil - } - } - - var rawValue: Int { - switch self { - case .afinalize: return 0 - } - } - } - enum hash: SwiftProtobuf.Enum { - typealias RawValue = Int - case ahash // = 0 + enum hash: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ahash = 0 init() { self = .ahash } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ahash - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ahash: return 0 - } - } - } - enum dealloc: SwiftProtobuf.Enum { - typealias RawValue = Int - case adealloc // = 0 + enum dealloc: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adealloc = 0 init() { self = .adealloc } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adealloc - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adealloc: return 0 - } - } - } - enum superclass: SwiftProtobuf.Enum { - typealias RawValue = Int - case asuperclass // = 0 + enum superclass: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case asuperclass = 0 init() { self = .asuperclass } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .asuperclass - default: return nil - } - } + } - var rawValue: Int { - switch self { - case .asuperclass: return 0 - } + enum retain: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aretain = 0 + + init() { + self = .aretain } } - enum retain: SwiftProtobuf.Enum { - typealias RawValue = Int - case aretain // = 0 + enum release: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case arelease = 0 init() { - self = .aretain - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aretain - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aretain: return 0 - } - } - - } - - enum release: SwiftProtobuf.Enum { - typealias RawValue = Int - case arelease // = 0 - - init() { - self = .arelease - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .arelease - default: return nil - } - } - - var rawValue: Int { - switch self { - case .arelease: return 0 - } + self = .arelease } } - enum autorelease: SwiftProtobuf.Enum { - typealias RawValue = Int - case aautorelease // = 0 + enum autorelease: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aautorelease = 0 init() { self = .aautorelease } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aautorelease - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aautorelease: return 0 - } - } - } - enum retainCount: SwiftProtobuf.Enum { - typealias RawValue = Int - case aretainCount // = 0 + enum retainCount: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aretainCount = 0 init() { self = .aretainCount } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aretainCount - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aretainCount: return 0 - } - } - } - enum zone: SwiftProtobuf.Enum { - typealias RawValue = Int - case azone // = 0 + enum zone: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case azone = 0 init() { self = .azone } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .azone - default: return nil - } - } - - var rawValue: Int { - switch self { - case .azone: return 0 - } - } - } - enum isProxy: SwiftProtobuf.Enum { - typealias RawValue = Int - case aisProxy // = 0 + enum isProxy: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aisProxy = 0 init() { self = .aisProxy } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aisProxy - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aisProxy: return 0 - } - } - } - enum copy: SwiftProtobuf.Enum { - typealias RawValue = Int - case acopy // = 0 + enum copy: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case acopy = 0 init() { self = .acopy } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .acopy - default: return nil - } - } - - var rawValue: Int { - switch self { - case .acopy: return 0 - } - } - } - enum mutableCopy: SwiftProtobuf.Enum { - typealias RawValue = Int - case amutableCopy // = 0 + enum mutableCopy: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case amutableCopy = 0 init() { self = .amutableCopy } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .amutableCopy - default: return nil - } - } - - var rawValue: Int { - switch self { - case .amutableCopy: return 0 - } - } - } - enum classForCoder: SwiftProtobuf.Enum { - typealias RawValue = Int - case aclassForCoder // = 0 + enum classForCoder: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aclassForCoder = 0 init() { self = .aclassForCoder } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aclassForCoder - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aclassForCoder: return 0 - } - } - } - enum clear: SwiftProtobuf.Enum { - typealias RawValue = Int - case aclear // = 0 + enum clear: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aclear = 0 init() { self = .aclear } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aclear - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aclear: return 0 - } - } - } - enum data: SwiftProtobuf.Enum { - typealias RawValue = Int - case adata // = 0 + enum data: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adata = 0 init() { self = .adata } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adata - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adata: return 0 - } - } - } - enum delimitedData: SwiftProtobuf.Enum { - typealias RawValue = Int - case adelimitedData // = 0 + enum delimitedData: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adelimitedData = 0 init() { self = .adelimitedData } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adelimitedData - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adelimitedData: return 0 - } - } - } - enum descriptor: SwiftProtobuf.Enum { - typealias RawValue = Int - case adescriptor // = 0 + enum descriptor: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adescriptor = 0 init() { self = .adescriptor } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adescriptor - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adescriptor: return 0 - } - } - } - enum extensionRegistry: SwiftProtobuf.Enum { - typealias RawValue = Int - case aextensionRegistry // = 0 + enum extensionRegistry: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aextensionRegistry = 0 init() { self = .aextensionRegistry } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aextensionRegistry - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aextensionRegistry: return 0 - } - } - } - enum extensionsCurrentlySet: SwiftProtobuf.Enum { - typealias RawValue = Int - case aextensionsCurrentlySet // = 0 + enum extensionsCurrentlySet: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aextensionsCurrentlySet = 0 init() { self = .aextensionsCurrentlySet } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aextensionsCurrentlySet - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aextensionsCurrentlySet: return 0 - } - } - } - enum isInitializedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aisInitialized // = 0 + enum isInitializedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aisInitialized = 0 init() { self = .aisInitialized } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aisInitialized - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aisInitialized: return 0 - } - } - } - enum serializedSize: SwiftProtobuf.Enum { - typealias RawValue = Int - case aserializedSize // = 0 + enum serializedSize: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aserializedSize = 0 init() { self = .aserializedSize } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aserializedSize - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aserializedSize: return 0 - } - } - } - enum sortedExtensionsInUse: SwiftProtobuf.Enum { - typealias RawValue = Int - case asortedExtensionsInUse // = 0 + enum sortedExtensionsInUse: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case asortedExtensionsInUse = 0 init() { self = .asortedExtensionsInUse - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .asortedExtensionsInUse - default: return nil - } - } - - var rawValue: Int { - switch self { - case .asortedExtensionsInUse: return 0 - } - } - - } - - enum unknownFieldsEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aunknownFields // = 0 - - init() { - self = .aunknownFields - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aunknownFields - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aunknownFields: return 0 - } - } - - } - - enum Fixed: SwiftProtobuf.Enum { - typealias RawValue = Int - case aFixed // = 0 - - init() { - self = .aFixed - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aFixed - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aFixed: return 0 - } - } - - } - - enum Fract: SwiftProtobuf.Enum { - typealias RawValue = Int - case aFract // = 0 - - init() { - self = .aFract - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aFract - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aFract: return 0 - } - } - - } - - enum Size: SwiftProtobuf.Enum { - typealias RawValue = Int - case aSize // = 0 - - init() { - self = .aSize - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aSize - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aSize: return 0 - } - } - - } - - enum LogicalAddress: SwiftProtobuf.Enum { - typealias RawValue = Int - case aLogicalAddress // = 0 - - init() { - self = .aLogicalAddress - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aLogicalAddress - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aLogicalAddress: return 0 - } - } - - } - - enum PhysicalAddress: SwiftProtobuf.Enum { - typealias RawValue = Int - case aPhysicalAddress // = 0 - - init() { - self = .aPhysicalAddress - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aPhysicalAddress - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aPhysicalAddress: return 0 - } - } - - } - - enum ByteCount: SwiftProtobuf.Enum { - typealias RawValue = Int - case aByteCount // = 0 - - init() { - self = .aByteCount - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aByteCount - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aByteCount: return 0 - } - } - - } - - enum ByteOffset: SwiftProtobuf.Enum { - typealias RawValue = Int - case aByteOffset // = 0 - - init() { - self = .aByteOffset - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aByteOffset - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aByteOffset: return 0 - } - } - - } - - enum Duration: SwiftProtobuf.Enum { - typealias RawValue = Int - case aDuration // = 0 - - init() { - self = .aDuration - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aDuration - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aDuration: return 0 - } - } - - } - - enum AbsoluteTime: SwiftProtobuf.Enum { - typealias RawValue = Int - case aAbsoluteTime // = 0 - - init() { - self = .aAbsoluteTime - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aAbsoluteTime - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aAbsoluteTime: return 0 - } - } - - } - - enum OptionBits: SwiftProtobuf.Enum { - typealias RawValue = Int - case aOptionBits // = 0 - - init() { - self = .aOptionBits - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aOptionBits - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aOptionBits: return 0 - } - } - - } - - enum ItemCount: SwiftProtobuf.Enum { - typealias RawValue = Int - case aItemCount // = 0 - - init() { - self = .aItemCount - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aItemCount - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aItemCount: return 0 - } - } - - } - - enum PBVersion: SwiftProtobuf.Enum { - typealias RawValue = Int - case aPbversion // = 0 - - init() { - self = .aPbversion - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aPbversion - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aPbversion: return 0 - } - } - - } - - enum ScriptCode: SwiftProtobuf.Enum { - typealias RawValue = Int - case aScriptCode // = 0 - - init() { - self = .aScriptCode - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aScriptCode - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aScriptCode: return 0 - } - } - - } - - enum LangCode: SwiftProtobuf.Enum { - typealias RawValue = Int - case aLangCode // = 0 - - init() { - self = .aLangCode - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aLangCode - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aLangCode: return 0 - } - } - - } - - enum RegionCode: SwiftProtobuf.Enum { - typealias RawValue = Int - case aRegionCode // = 0 - - init() { - self = .aRegionCode - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aRegionCode - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aRegionCode: return 0 - } - } - - } - - enum OSType: SwiftProtobuf.Enum { - typealias RawValue = Int - case aOstype // = 0 - - init() { - self = .aOstype - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aOstype - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aOstype: return 0 - } - } - - } - - enum ProcessSerialNumber: SwiftProtobuf.Enum { - typealias RawValue = Int - case aProcessSerialNumber // = 0 - - init() { - self = .aProcessSerialNumber - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aProcessSerialNumber - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aProcessSerialNumber: return 0 - } - } - - } - - enum Point: SwiftProtobuf.Enum { - typealias RawValue = Int - case aPoint // = 0 - - init() { - self = .aPoint - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aPoint - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aPoint: return 0 - } - } - - } - - enum Rect: SwiftProtobuf.Enum { - typealias RawValue = Int - case aRect // = 0 - - init() { - self = .aRect - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aRect - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aRect: return 0 - } - } - - } - - enum FixedPoint: SwiftProtobuf.Enum { - typealias RawValue = Int - case aFixedPoint // = 0 - - init() { - self = .aFixedPoint - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aFixedPoint - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aFixedPoint: return 0 - } - } - - } - - enum FixedRect: SwiftProtobuf.Enum { - typealias RawValue = Int - case aFixedRect // = 0 - - init() { - self = .aFixedRect - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aFixedRect - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aFixedRect: return 0 - } - } - - } - - enum Style: SwiftProtobuf.Enum { - typealias RawValue = Int - case aStyle // = 0 - - init() { - self = .aStyle - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aStyle - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aStyle: return 0 - } - } - - } - - enum StyleParameter: SwiftProtobuf.Enum { - typealias RawValue = Int - case aStyleParameter // = 0 - - init() { - self = .aStyleParameter - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aStyleParameter - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aStyleParameter: return 0 - } - } - - } - - enum StyleField: SwiftProtobuf.Enum { - typealias RawValue = Int - case aStyleField // = 0 - - init() { - self = .aStyleField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aStyleField - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aStyleField: return 0 - } - } - - } - - enum TimeScale: SwiftProtobuf.Enum { - typealias RawValue = Int - case aTimeScale // = 0 - - init() { - self = .aTimeScale - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aTimeScale - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aTimeScale: return 0 - } - } - - } - - enum TimeBase: SwiftProtobuf.Enum { - typealias RawValue = Int - case aTimeBase // = 0 - - init() { - self = .aTimeBase - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aTimeBase - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aTimeBase: return 0 - } - } - - } - - enum TimeRecord: SwiftProtobuf.Enum { - typealias RawValue = Int - case aTimeRecord // = 0 - - init() { - self = .aTimeRecord - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aTimeRecord - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aTimeRecord: return 0 - } - } - - } - - enum Extension: SwiftProtobuf.Enum { - typealias RawValue = Int - case aExtension // = 0 - - init() { - self = .aExtension - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aExtension - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aExtension: return 0 - } - } - - } - - enum ExtensionsEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aExtensions // = 0 - - init() { - self = .aExtensions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aExtensions - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aExtensions: return 0 - } - } - - } - - init() {} -} - -#if swift(>=4.2) - -extension SwiftUnittest_Names_EnumNames.StringEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.ProtocolEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.IntEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.DoubleEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.FloatEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.UIntEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.hashValueEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.descriptionEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.debugDescriptionEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.Swift: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.UNRECOGNIZED: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.classEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.deinitEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.enumEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.extensionEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.funcEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.importEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.initEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.inoutEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.internalEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.letEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.operatorEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.privateEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.protocolEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.publicEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.staticEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.structEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.subscriptEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.typealiasEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.varEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.breakEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.caseEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.continueEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.defaultEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.deferEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.doEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.elseEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.fallthroughEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.forEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.guardEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.ifEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.inEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.repeatEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.returnEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.switchEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.whereEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.whileEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.asEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.catchEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.dynamicTypeEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.falseEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.isEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.nilEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.rethrowsEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.superEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.selfEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.throwEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.throwsEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.trueEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.tryEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.__COLUMN__Enum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.__FILE__Enum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.__FUNCTION__Enum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.__LINE__Enum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames._Enum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.__Enum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.associativity: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.convenience: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.dynamic: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.didSet: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.final: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.get: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.infix: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.indirect: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.lazy: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.left: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.mutating: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.none: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.nonmutating: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.optional: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.override: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.postfix: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.precedence: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.prefix: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.required: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.right: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.set: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.TypeEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.unowned: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.weak: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.willSet: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.id: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames._cmd: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.out: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.bycopy: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.byref: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.oneway: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.and: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.and_eq: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.alignas: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.alignof: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.asm: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.auto: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.bitand: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.bitor: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.bool: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.char: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.char16_t: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.char32_t: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.compl: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.const: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.constexpr: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.const_cast: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.decltype: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.delete: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.dynamic_cast: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.explicit: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.export: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.extern: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.friend: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.goto: CaseIterable { - // Support synthesized by the compiler. -} + enum unknownFieldsEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aunknownFields = 0 -extension SwiftUnittest_Names_EnumNames.inline: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aunknownFields + } -extension SwiftUnittest_Names_EnumNames.long: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.mutable: CaseIterable { - // Support synthesized by the compiler. -} + enum Fixed: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aFixed = 0 -extension SwiftUnittest_Names_EnumNames.namespace: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aFixed + } -extension SwiftUnittest_Names_EnumNames.new: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.noexcept: CaseIterable { - // Support synthesized by the compiler. -} + enum Fract: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aFract = 0 -extension SwiftUnittest_Names_EnumNames.not: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aFract + } -extension SwiftUnittest_Names_EnumNames.not_eq: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.nullptr: CaseIterable { - // Support synthesized by the compiler. -} + enum Size: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aSize = 0 -extension SwiftUnittest_Names_EnumNames.or: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aSize + } -extension SwiftUnittest_Names_EnumNames.or_eq: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.protected: CaseIterable { - // Support synthesized by the compiler. -} + enum LogicalAddress: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aLogicalAddress = 0 -extension SwiftUnittest_Names_EnumNames.register: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aLogicalAddress + } -extension SwiftUnittest_Names_EnumNames.reinterpret_cast: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.short: CaseIterable { - // Support synthesized by the compiler. -} + enum PhysicalAddress: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aPhysicalAddress = 0 -extension SwiftUnittest_Names_EnumNames.signed: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aPhysicalAddress + } -extension SwiftUnittest_Names_EnumNames.sizeof: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.static_assert: CaseIterable { - // Support synthesized by the compiler. -} + enum ByteCount: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aByteCount = 0 -extension SwiftUnittest_Names_EnumNames.static_cast: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aByteCount + } -extension SwiftUnittest_Names_EnumNames.template: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.this: CaseIterable { - // Support synthesized by the compiler. -} + enum ByteOffset: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aByteOffset = 0 -extension SwiftUnittest_Names_EnumNames.thread_local: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aByteOffset + } -extension SwiftUnittest_Names_EnumNames.typedef: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.typeid: CaseIterable { - // Support synthesized by the compiler. -} + enum Duration: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aDuration = 0 -extension SwiftUnittest_Names_EnumNames.typename: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aDuration + } -extension SwiftUnittest_Names_EnumNames.union: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.unsigned: CaseIterable { - // Support synthesized by the compiler. -} + enum AbsoluteTime: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aAbsoluteTime = 0 -extension SwiftUnittest_Names_EnumNames.using: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aAbsoluteTime + } -extension SwiftUnittest_Names_EnumNames.virtual: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.void: CaseIterable { - // Support synthesized by the compiler. -} + enum OptionBits: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aOptionBits = 0 -extension SwiftUnittest_Names_EnumNames.volatile: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aOptionBits + } -extension SwiftUnittest_Names_EnumNames.wchar_t: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.xor: CaseIterable { - // Support synthesized by the compiler. -} + enum ItemCount: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aItemCount = 0 -extension SwiftUnittest_Names_EnumNames.xor_eq: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aItemCount + } -extension SwiftUnittest_Names_EnumNames.restrict: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.Category: CaseIterable { - // Support synthesized by the compiler. -} + enum PBVersion: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aPbversion = 0 -extension SwiftUnittest_Names_EnumNames.Ivar: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aPbversion + } -extension SwiftUnittest_Names_EnumNames.Method: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.finalize: CaseIterable { - // Support synthesized by the compiler. -} + enum ScriptCode: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aScriptCode = 0 -extension SwiftUnittest_Names_EnumNames.hash: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aScriptCode + } -extension SwiftUnittest_Names_EnumNames.dealloc: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.superclass: CaseIterable { - // Support synthesized by the compiler. -} + enum LangCode: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aLangCode = 0 -extension SwiftUnittest_Names_EnumNames.retain: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aLangCode + } -extension SwiftUnittest_Names_EnumNames.release: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.autorelease: CaseIterable { - // Support synthesized by the compiler. -} + enum RegionCode: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aRegionCode = 0 -extension SwiftUnittest_Names_EnumNames.retainCount: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aRegionCode + } -extension SwiftUnittest_Names_EnumNames.zone: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.isProxy: CaseIterable { - // Support synthesized by the compiler. -} + enum OSType: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aOstype = 0 -extension SwiftUnittest_Names_EnumNames.copy: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aOstype + } -extension SwiftUnittest_Names_EnumNames.mutableCopy: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.classForCoder: CaseIterable { - // Support synthesized by the compiler. -} + enum ProcessSerialNumber: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aProcessSerialNumber = 0 -extension SwiftUnittest_Names_EnumNames.clear: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aProcessSerialNumber + } -extension SwiftUnittest_Names_EnumNames.data: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.delimitedData: CaseIterable { - // Support synthesized by the compiler. -} + enum Point: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aPoint = 0 -extension SwiftUnittest_Names_EnumNames.descriptor: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aPoint + } -extension SwiftUnittest_Names_EnumNames.extensionRegistry: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.extensionsCurrentlySet: CaseIterable { - // Support synthesized by the compiler. -} + enum Rect: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aRect = 0 -extension SwiftUnittest_Names_EnumNames.isInitializedEnum: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aRect + } -extension SwiftUnittest_Names_EnumNames.serializedSize: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.sortedExtensionsInUse: CaseIterable { - // Support synthesized by the compiler. -} + enum FixedPoint: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aFixedPoint = 0 -extension SwiftUnittest_Names_EnumNames.unknownFieldsEnum: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aFixedPoint + } -extension SwiftUnittest_Names_EnumNames.Fixed: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.Fract: CaseIterable { - // Support synthesized by the compiler. -} + enum FixedRect: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aFixedRect = 0 -extension SwiftUnittest_Names_EnumNames.Size: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aFixedRect + } -extension SwiftUnittest_Names_EnumNames.LogicalAddress: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.PhysicalAddress: CaseIterable { - // Support synthesized by the compiler. -} + enum Style: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aStyle = 0 -extension SwiftUnittest_Names_EnumNames.ByteCount: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aStyle + } -extension SwiftUnittest_Names_EnumNames.ByteOffset: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.Duration: CaseIterable { - // Support synthesized by the compiler. -} + enum StyleParameter: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aStyleParameter = 0 -extension SwiftUnittest_Names_EnumNames.AbsoluteTime: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aStyleParameter + } -extension SwiftUnittest_Names_EnumNames.OptionBits: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.ItemCount: CaseIterable { - // Support synthesized by the compiler. -} + enum StyleField: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aStyleField = 0 -extension SwiftUnittest_Names_EnumNames.PBVersion: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aStyleField + } -extension SwiftUnittest_Names_EnumNames.ScriptCode: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.LangCode: CaseIterable { - // Support synthesized by the compiler. -} + enum TimeScale: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aTimeScale = 0 -extension SwiftUnittest_Names_EnumNames.RegionCode: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aTimeScale + } -extension SwiftUnittest_Names_EnumNames.OSType: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.ProcessSerialNumber: CaseIterable { - // Support synthesized by the compiler. -} + enum TimeBase: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aTimeBase = 0 -extension SwiftUnittest_Names_EnumNames.Point: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aTimeBase + } -extension SwiftUnittest_Names_EnumNames.Rect: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.FixedPoint: CaseIterable { - // Support synthesized by the compiler. -} + enum TimeRecord: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aTimeRecord = 0 -extension SwiftUnittest_Names_EnumNames.FixedRect: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aTimeRecord + } -extension SwiftUnittest_Names_EnumNames.Style: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.StyleParameter: CaseIterable { - // Support synthesized by the compiler. -} + enum Extension: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aExtension = 0 -extension SwiftUnittest_Names_EnumNames.StyleField: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aExtension + } -extension SwiftUnittest_Names_EnumNames.TimeScale: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.TimeBase: CaseIterable { - // Support synthesized by the compiler. -} + enum ExtensionsEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aExtensions = 0 -extension SwiftUnittest_Names_EnumNames.TimeRecord: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aExtensions + } -extension SwiftUnittest_Names_EnumNames.Extension: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.ExtensionsEnum: CaseIterable { - // Support synthesized by the compiler. + init() {} } -#endif // swift(>=4.2) - -struct SwiftUnittest_Names_FieldNamingInitials { +struct SwiftProtoTesting_Names_FieldNamingInitials: Sendable { // 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() - struct Lowers { + struct Lowers: @unchecked Sendable { // 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 http: Int32 { - get {return _storage._http ?? 0} + get {_storage._http ?? 0} set {_uniqueStorage()._http = newValue} } /// Returns true if `http` has been explicitly set. - var hasHTTP: Bool {return _storage._http != nil} + var hasHTTP: Bool {_storage._http != nil} /// Clears the value of `http`. Subsequent reads from it will return its default value. mutating func clearHTTP() {_uniqueStorage()._http = nil} var httpRequest: Int32 { - get {return _storage._httpRequest ?? 0} + get {_storage._httpRequest ?? 0} set {_uniqueStorage()._httpRequest = newValue} } /// Returns true if `httpRequest` has been explicitly set. - var hasHTTPRequest: Bool {return _storage._httpRequest != nil} + var hasHTTPRequest: Bool {_storage._httpRequest != nil} /// Clears the value of `httpRequest`. Subsequent reads from it will return its default value. mutating func clearHTTPRequest() {_uniqueStorage()._httpRequest = nil} var theHTTPRequest: Int32 { - get {return _storage._theHTTPRequest ?? 0} + get {_storage._theHTTPRequest ?? 0} set {_uniqueStorage()._theHTTPRequest = newValue} } /// Returns true if `theHTTPRequest` has been explicitly set. - var hasTheHTTPRequest: Bool {return _storage._theHTTPRequest != nil} + var hasTheHTTPRequest: Bool {_storage._theHTTPRequest != nil} /// Clears the value of `theHTTPRequest`. Subsequent reads from it will return its default value. mutating func clearTheHTTPRequest() {_uniqueStorage()._theHTTPRequest = nil} var theHTTP: Int32 { - get {return _storage._theHTTP ?? 0} + get {_storage._theHTTP ?? 0} set {_uniqueStorage()._theHTTP = newValue} } /// Returns true if `theHTTP` has been explicitly set. - var hasTheHTTP: Bool {return _storage._theHTTP != nil} + var hasTheHTTP: Bool {_storage._theHTTP != nil} /// Clears the value of `theHTTP`. Subsequent reads from it will return its default value. mutating func clearTheHTTP() {_uniqueStorage()._theHTTP = nil} var https: Int32 { - get {return _storage._https ?? 0} + get {_storage._https ?? 0} set {_uniqueStorage()._https = newValue} } /// Returns true if `https` has been explicitly set. - var hasHTTPS: Bool {return _storage._https != nil} + var hasHTTPS: Bool {_storage._https != nil} /// Clears the value of `https`. Subsequent reads from it will return its default value. mutating func clearHTTPS() {_uniqueStorage()._https = nil} var httpsRequest: Int32 { - get {return _storage._httpsRequest ?? 0} + get {_storage._httpsRequest ?? 0} set {_uniqueStorage()._httpsRequest = newValue} } /// Returns true if `httpsRequest` has been explicitly set. - var hasHTTPSRequest: Bool {return _storage._httpsRequest != nil} + var hasHTTPSRequest: Bool {_storage._httpsRequest != nil} /// Clears the value of `httpsRequest`. Subsequent reads from it will return its default value. mutating func clearHTTPSRequest() {_uniqueStorage()._httpsRequest = nil} var theHTTPSRequest: Int32 { - get {return _storage._theHTTPSRequest ?? 0} + get {_storage._theHTTPSRequest ?? 0} set {_uniqueStorage()._theHTTPSRequest = newValue} } /// Returns true if `theHTTPSRequest` has been explicitly set. - var hasTheHTTPSRequest: Bool {return _storage._theHTTPSRequest != nil} + var hasTheHTTPSRequest: Bool {_storage._theHTTPSRequest != nil} /// Clears the value of `theHTTPSRequest`. Subsequent reads from it will return its default value. mutating func clearTheHTTPSRequest() {_uniqueStorage()._theHTTPSRequest = nil} var theHTTPS: Int32 { - get {return _storage._theHTTPS ?? 0} + get {_storage._theHTTPS ?? 0} set {_uniqueStorage()._theHTTPS = newValue} } /// Returns true if `theHTTPS` has been explicitly set. - var hasTheHTTPS: Bool {return _storage._theHTTPS != nil} + var hasTheHTTPS: Bool {_storage._theHTTPS != nil} /// Clears the value of `theHTTPS`. Subsequent reads from it will return its default value. mutating func clearTheHTTPS() {_uniqueStorage()._theHTTPS = nil} var url: Int32 { - get {return _storage._url ?? 0} + get {_storage._url ?? 0} set {_uniqueStorage()._url = newValue} } /// Returns true if `url` has been explicitly set. - var hasURL: Bool {return _storage._url != nil} + var hasURL: Bool {_storage._url != nil} /// Clears the value of `url`. Subsequent reads from it will return its default value. mutating func clearURL() {_uniqueStorage()._url = nil} var urlValue: Int32 { - get {return _storage._urlValue ?? 0} + get {_storage._urlValue ?? 0} set {_uniqueStorage()._urlValue = newValue} } /// Returns true if `urlValue` has been explicitly set. - var hasURLValue: Bool {return _storage._urlValue != nil} + var hasURLValue: Bool {_storage._urlValue != nil} /// Clears the value of `urlValue`. Subsequent reads from it will return its default value. mutating func clearURLValue() {_uniqueStorage()._urlValue = nil} var theURLValue: Int32 { - get {return _storage._theURLValue ?? 0} + get {_storage._theURLValue ?? 0} set {_uniqueStorage()._theURLValue = newValue} } /// Returns true if `theURLValue` has been explicitly set. - var hasTheURLValue: Bool {return _storage._theURLValue != nil} + var hasTheURLValue: Bool {_storage._theURLValue != nil} /// Clears the value of `theURLValue`. Subsequent reads from it will return its default value. mutating func clearTheURLValue() {_uniqueStorage()._theURLValue = nil} var theURL: Int32 { - get {return _storage._theURL ?? 0} + get {_storage._theURL ?? 0} set {_uniqueStorage()._theURL = newValue} } /// Returns true if `theURL` has been explicitly set. - var hasTheURL: Bool {return _storage._theURL != nil} + var hasTheURL: Bool {_storage._theURL != nil} /// Clears the value of `theURL`. Subsequent reads from it will return its default value. mutating func clearTheURL() {_uniqueStorage()._theURL = nil} var aBC: Int32 { - get {return _storage._aBC ?? 0} + get {_storage._aBC ?? 0} set {_uniqueStorage()._aBC = newValue} } /// Returns true if `aBC` has been explicitly set. - var hasABC: Bool {return _storage._aBC != nil} + var hasABC: Bool {_storage._aBC != nil} /// Clears the value of `aBC`. Subsequent reads from it will return its default value. mutating func clearABC() {_uniqueStorage()._aBC = nil} var id: Int32 { - get {return _storage._id ?? 0} + get {_storage._id ?? 0} set {_uniqueStorage()._id = newValue} } /// Returns true if `id` has been explicitly set. - var hasID: Bool {return _storage._id != nil} + var hasID: Bool {_storage._id != nil} /// Clears the value of `id`. Subsequent reads from it will return its default value. mutating func clearID() {_uniqueStorage()._id = nil} var idNumber: Int32 { - get {return _storage._idNumber ?? 0} + get {_storage._idNumber ?? 0} set {_uniqueStorage()._idNumber = newValue} } /// Returns true if `idNumber` has been explicitly set. - var hasIDNumber: Bool {return _storage._idNumber != nil} + var hasIDNumber: Bool {_storage._idNumber != nil} /// Clears the value of `idNumber`. Subsequent reads from it will return its default value. mutating func clearIDNumber() {_uniqueStorage()._idNumber = nil} var theIDNumber: Int32 { - get {return _storage._theIDNumber ?? 0} + get {_storage._theIDNumber ?? 0} set {_uniqueStorage()._theIDNumber = newValue} } /// Returns true if `theIDNumber` has been explicitly set. - var hasTheIDNumber: Bool {return _storage._theIDNumber != nil} + var hasTheIDNumber: Bool {_storage._theIDNumber != nil} /// Clears the value of `theIDNumber`. Subsequent reads from it will return its default value. mutating func clearTheIDNumber() {_uniqueStorage()._theIDNumber = nil} var requestID: Int32 { - get {return _storage._requestID ?? 0} + get {_storage._requestID ?? 0} set {_uniqueStorage()._requestID = newValue} } /// Returns true if `requestID` has been explicitly set. - var hasRequestID: Bool {return _storage._requestID != nil} + var hasRequestID: Bool {_storage._requestID != nil} /// Clears the value of `requestID`. Subsequent reads from it will return its default value. mutating func clearRequestID() {_uniqueStorage()._requestID = nil} @@ -13143,152 +8881,152 @@ struct SwiftUnittest_Names_FieldNamingInitials { fileprivate var _storage = _StorageClass.defaultInstance } - struct Uppers { + struct Uppers: Sendable { // 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 http: Int32 { - get {return _http ?? 0} + get {_http ?? 0} set {_http = newValue} } /// Returns true if `http` has been explicitly set. - var hasHTTP: Bool {return self._http != nil} + var hasHTTP: Bool {self._http != nil} /// Clears the value of `http`. Subsequent reads from it will return its default value. mutating func clearHTTP() {self._http = nil} var httpRequest: Int32 { - get {return _httpRequest ?? 0} + get {_httpRequest ?? 0} set {_httpRequest = newValue} } /// Returns true if `httpRequest` has been explicitly set. - var hasHTTPRequest: Bool {return self._httpRequest != nil} + var hasHTTPRequest: Bool {self._httpRequest != nil} /// Clears the value of `httpRequest`. Subsequent reads from it will return its default value. mutating func clearHTTPRequest() {self._httpRequest = nil} var theHTTPRequest: Int32 { - get {return _theHTTPRequest ?? 0} + get {_theHTTPRequest ?? 0} set {_theHTTPRequest = newValue} } /// Returns true if `theHTTPRequest` has been explicitly set. - var hasTheHTTPRequest: Bool {return self._theHTTPRequest != nil} + var hasTheHTTPRequest: Bool {self._theHTTPRequest != nil} /// Clears the value of `theHTTPRequest`. Subsequent reads from it will return its default value. mutating func clearTheHTTPRequest() {self._theHTTPRequest = nil} var theHTTP: Int32 { - get {return _theHTTP ?? 0} + get {_theHTTP ?? 0} set {_theHTTP = newValue} } /// Returns true if `theHTTP` has been explicitly set. - var hasTheHTTP: Bool {return self._theHTTP != nil} + var hasTheHTTP: Bool {self._theHTTP != nil} /// Clears the value of `theHTTP`. Subsequent reads from it will return its default value. mutating func clearTheHTTP() {self._theHTTP = nil} var https: Int32 { - get {return _https ?? 0} + get {_https ?? 0} set {_https = newValue} } /// Returns true if `https` has been explicitly set. - var hasHTTPS: Bool {return self._https != nil} + var hasHTTPS: Bool {self._https != nil} /// Clears the value of `https`. Subsequent reads from it will return its default value. mutating func clearHTTPS() {self._https = nil} var httpsRequest: Int32 { - get {return _httpsRequest ?? 0} + get {_httpsRequest ?? 0} set {_httpsRequest = newValue} } /// Returns true if `httpsRequest` has been explicitly set. - var hasHTTPSRequest: Bool {return self._httpsRequest != nil} + var hasHTTPSRequest: Bool {self._httpsRequest != nil} /// Clears the value of `httpsRequest`. Subsequent reads from it will return its default value. mutating func clearHTTPSRequest() {self._httpsRequest = nil} var theHTTPSRequest: Int32 { - get {return _theHTTPSRequest ?? 0} + get {_theHTTPSRequest ?? 0} set {_theHTTPSRequest = newValue} } /// Returns true if `theHTTPSRequest` has been explicitly set. - var hasTheHTTPSRequest: Bool {return self._theHTTPSRequest != nil} + var hasTheHTTPSRequest: Bool {self._theHTTPSRequest != nil} /// Clears the value of `theHTTPSRequest`. Subsequent reads from it will return its default value. mutating func clearTheHTTPSRequest() {self._theHTTPSRequest = nil} var theHTTPS: Int32 { - get {return _theHTTPS ?? 0} + get {_theHTTPS ?? 0} set {_theHTTPS = newValue} } /// Returns true if `theHTTPS` has been explicitly set. - var hasTheHTTPS: Bool {return self._theHTTPS != nil} + var hasTheHTTPS: Bool {self._theHTTPS != nil} /// Clears the value of `theHTTPS`. Subsequent reads from it will return its default value. mutating func clearTheHTTPS() {self._theHTTPS = nil} var url: Int32 { - get {return _url ?? 0} + get {_url ?? 0} set {_url = newValue} } /// Returns true if `url` has been explicitly set. - var hasURL: Bool {return self._url != nil} + var hasURL: Bool {self._url != nil} /// Clears the value of `url`. Subsequent reads from it will return its default value. mutating func clearURL() {self._url = nil} var urlValue: Int32 { - get {return _urlValue ?? 0} + get {_urlValue ?? 0} set {_urlValue = newValue} } /// Returns true if `urlValue` has been explicitly set. - var hasURLValue: Bool {return self._urlValue != nil} + var hasURLValue: Bool {self._urlValue != nil} /// Clears the value of `urlValue`. Subsequent reads from it will return its default value. mutating func clearURLValue() {self._urlValue = nil} var theURLValue: Int32 { - get {return _theURLValue ?? 0} + get {_theURLValue ?? 0} set {_theURLValue = newValue} } /// Returns true if `theURLValue` has been explicitly set. - var hasTheURLValue: Bool {return self._theURLValue != nil} + var hasTheURLValue: Bool {self._theURLValue != nil} /// Clears the value of `theURLValue`. Subsequent reads from it will return its default value. mutating func clearTheURLValue() {self._theURLValue = nil} var theURL: Int32 { - get {return _theURL ?? 0} + get {_theURL ?? 0} set {_theURL = newValue} } /// Returns true if `theURL` has been explicitly set. - var hasTheURL: Bool {return self._theURL != nil} + var hasTheURL: Bool {self._theURL != nil} /// Clears the value of `theURL`. Subsequent reads from it will return its default value. mutating func clearTheURL() {self._theURL = nil} var id: Int32 { - get {return _id ?? 0} + get {_id ?? 0} set {_id = newValue} } /// Returns true if `id` has been explicitly set. - var hasID: Bool {return self._id != nil} + var hasID: Bool {self._id != nil} /// Clears the value of `id`. Subsequent reads from it will return its default value. mutating func clearID() {self._id = nil} var idNumber: Int32 { - get {return _idNumber ?? 0} + get {_idNumber ?? 0} set {_idNumber = newValue} } /// Returns true if `idNumber` has been explicitly set. - var hasIDNumber: Bool {return self._idNumber != nil} + var hasIDNumber: Bool {self._idNumber != nil} /// Clears the value of `idNumber`. Subsequent reads from it will return its default value. mutating func clearIDNumber() {self._idNumber = nil} var theIDNumber: Int32 { - get {return _theIDNumber ?? 0} + get {_theIDNumber ?? 0} set {_theIDNumber = newValue} } /// Returns true if `theIDNumber` has been explicitly set. - var hasTheIDNumber: Bool {return self._theIDNumber != nil} + var hasTheIDNumber: Bool {self._theIDNumber != nil} /// Clears the value of `theIDNumber`. Subsequent reads from it will return its default value. mutating func clearTheIDNumber() {self._theIDNumber = nil} var requestID: Int32 { - get {return _requestID ?? 0} + get {_requestID ?? 0} set {_requestID = newValue} } /// Returns true if `requestID` has been explicitly set. - var hasRequestID: Bool {return self._requestID != nil} + var hasRequestID: Bool {self._requestID != nil} /// Clears the value of `requestID`. Subsequent reads from it will return its default value. mutating func clearRequestID() {self._requestID = nil} @@ -13314,152 +9052,152 @@ struct SwiftUnittest_Names_FieldNamingInitials { fileprivate var _requestID: Int32? = nil } - struct WordCase { + struct WordCase: Sendable { // 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 http: Int32 { - get {return _http ?? 0} + get {_http ?? 0} set {_http = newValue} } /// Returns true if `http` has been explicitly set. - var hasHTTP: Bool {return self._http != nil} + var hasHTTP: Bool {self._http != nil} /// Clears the value of `http`. Subsequent reads from it will return its default value. mutating func clearHTTP() {self._http = nil} var httpRequest: Int32 { - get {return _httpRequest ?? 0} + get {_httpRequest ?? 0} set {_httpRequest = newValue} } /// Returns true if `httpRequest` has been explicitly set. - var hasHTTPRequest: Bool {return self._httpRequest != nil} + var hasHTTPRequest: Bool {self._httpRequest != nil} /// Clears the value of `httpRequest`. Subsequent reads from it will return its default value. mutating func clearHTTPRequest() {self._httpRequest = nil} var theHTTPRequest: Int32 { - get {return _theHTTPRequest ?? 0} + get {_theHTTPRequest ?? 0} set {_theHTTPRequest = newValue} } /// Returns true if `theHTTPRequest` has been explicitly set. - var hasTheHTTPRequest: Bool {return self._theHTTPRequest != nil} + var hasTheHTTPRequest: Bool {self._theHTTPRequest != nil} /// Clears the value of `theHTTPRequest`. Subsequent reads from it will return its default value. mutating func clearTheHTTPRequest() {self._theHTTPRequest = nil} var theHTTP: Int32 { - get {return _theHTTP ?? 0} + get {_theHTTP ?? 0} set {_theHTTP = newValue} } /// Returns true if `theHTTP` has been explicitly set. - var hasTheHTTP: Bool {return self._theHTTP != nil} + var hasTheHTTP: Bool {self._theHTTP != nil} /// Clears the value of `theHTTP`. Subsequent reads from it will return its default value. mutating func clearTheHTTP() {self._theHTTP = nil} var https: Int32 { - get {return _https ?? 0} + get {_https ?? 0} set {_https = newValue} } /// Returns true if `https` has been explicitly set. - var hasHTTPS: Bool {return self._https != nil} + var hasHTTPS: Bool {self._https != nil} /// Clears the value of `https`. Subsequent reads from it will return its default value. mutating func clearHTTPS() {self._https = nil} var httpsRequest: Int32 { - get {return _httpsRequest ?? 0} + get {_httpsRequest ?? 0} set {_httpsRequest = newValue} } /// Returns true if `httpsRequest` has been explicitly set. - var hasHTTPSRequest: Bool {return self._httpsRequest != nil} + var hasHTTPSRequest: Bool {self._httpsRequest != nil} /// Clears the value of `httpsRequest`. Subsequent reads from it will return its default value. mutating func clearHTTPSRequest() {self._httpsRequest = nil} var theHTTPSRequest: Int32 { - get {return _theHTTPSRequest ?? 0} + get {_theHTTPSRequest ?? 0} set {_theHTTPSRequest = newValue} } /// Returns true if `theHTTPSRequest` has been explicitly set. - var hasTheHTTPSRequest: Bool {return self._theHTTPSRequest != nil} + var hasTheHTTPSRequest: Bool {self._theHTTPSRequest != nil} /// Clears the value of `theHTTPSRequest`. Subsequent reads from it will return its default value. mutating func clearTheHTTPSRequest() {self._theHTTPSRequest = nil} var theHTTPS: Int32 { - get {return _theHTTPS ?? 0} + get {_theHTTPS ?? 0} set {_theHTTPS = newValue} } /// Returns true if `theHTTPS` has been explicitly set. - var hasTheHTTPS: Bool {return self._theHTTPS != nil} + var hasTheHTTPS: Bool {self._theHTTPS != nil} /// Clears the value of `theHTTPS`. Subsequent reads from it will return its default value. mutating func clearTheHTTPS() {self._theHTTPS = nil} var url: Int32 { - get {return _url ?? 0} + get {_url ?? 0} set {_url = newValue} } /// Returns true if `url` has been explicitly set. - var hasURL: Bool {return self._url != nil} + var hasURL: Bool {self._url != nil} /// Clears the value of `url`. Subsequent reads from it will return its default value. mutating func clearURL() {self._url = nil} var urlValue: Int32 { - get {return _urlValue ?? 0} + get {_urlValue ?? 0} set {_urlValue = newValue} } /// Returns true if `urlValue` has been explicitly set. - var hasURLValue: Bool {return self._urlValue != nil} + var hasURLValue: Bool {self._urlValue != nil} /// Clears the value of `urlValue`. Subsequent reads from it will return its default value. mutating func clearURLValue() {self._urlValue = nil} var theURLValue: Int32 { - get {return _theURLValue ?? 0} + get {_theURLValue ?? 0} set {_theURLValue = newValue} } /// Returns true if `theURLValue` has been explicitly set. - var hasTheURLValue: Bool {return self._theURLValue != nil} + var hasTheURLValue: Bool {self._theURLValue != nil} /// Clears the value of `theURLValue`. Subsequent reads from it will return its default value. mutating func clearTheURLValue() {self._theURLValue = nil} var theURL: Int32 { - get {return _theURL ?? 0} + get {_theURL ?? 0} set {_theURL = newValue} } /// Returns true if `theURL` has been explicitly set. - var hasTheURL: Bool {return self._theURL != nil} + var hasTheURL: Bool {self._theURL != nil} /// Clears the value of `theURL`. Subsequent reads from it will return its default value. mutating func clearTheURL() {self._theURL = nil} var id: Int32 { - get {return _id ?? 0} + get {_id ?? 0} set {_id = newValue} } /// Returns true if `id` has been explicitly set. - var hasID: Bool {return self._id != nil} + var hasID: Bool {self._id != nil} /// Clears the value of `id`. Subsequent reads from it will return its default value. mutating func clearID() {self._id = nil} var idNumber: Int32 { - get {return _idNumber ?? 0} + get {_idNumber ?? 0} set {_idNumber = newValue} } /// Returns true if `idNumber` has been explicitly set. - var hasIDNumber: Bool {return self._idNumber != nil} + var hasIDNumber: Bool {self._idNumber != nil} /// Clears the value of `idNumber`. Subsequent reads from it will return its default value. mutating func clearIDNumber() {self._idNumber = nil} var theIDNumber: Int32 { - get {return _theIDNumber ?? 0} + get {_theIDNumber ?? 0} set {_theIDNumber = newValue} } /// Returns true if `theIDNumber` has been explicitly set. - var hasTheIDNumber: Bool {return self._theIDNumber != nil} + var hasTheIDNumber: Bool {self._theIDNumber != nil} /// Clears the value of `theIDNumber`. Subsequent reads from it will return its default value. mutating func clearTheIDNumber() {self._theIDNumber = nil} var requestID: Int32 { - get {return _requestID ?? 0} + get {_requestID ?? 0} set {_requestID = newValue} } /// Returns true if `requestID` has been explicitly set. - var hasRequestID: Bool {return self._requestID != nil} + var hasRequestID: Bool {self._requestID != nil} /// Clears the value of `requestID`. Subsequent reads from it will return its default value. mutating func clearRequestID() {self._requestID = nil} @@ -13488,7 +9226,7 @@ struct SwiftUnittest_Names_FieldNamingInitials { init() {} } -struct SwiftUnittest_Names_ExtensionNamingInitials: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Names_ExtensionNamingInitials: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -13500,7 +9238,7 @@ struct SwiftUnittest_Names_ExtensionNamingInitials: SwiftProtobuf.ExtensibleMess var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct SwiftUnittest_Names_Lowers { +struct SwiftProtoTesting_Names_Lowers: Sendable { // 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. @@ -13510,7 +9248,7 @@ struct SwiftUnittest_Names_Lowers { init() {} } -struct SwiftUnittest_Names_Uppers { +struct SwiftProtoTesting_Names_Uppers: Sendable { // 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. @@ -13520,7 +9258,7 @@ struct SwiftUnittest_Names_Uppers { init() {} } -struct SwiftUnittest_Names_WordCase { +struct SwiftProtoTesting_Names_WordCase: Sendable { // 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. @@ -13530,7 +9268,7 @@ struct SwiftUnittest_Names_WordCase { init() {} } -struct SwiftUnittest_Names_ExtensionNamingInitialsLowers: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Names_ExtensionNamingInitialsLowers: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -13542,7 +9280,7 @@ struct SwiftUnittest_Names_ExtensionNamingInitialsLowers: SwiftProtobuf.Extensib var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct SwiftUnittest_Names_ExtensionNamingInitialsUppers: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Names_ExtensionNamingInitialsUppers: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -13554,7 +9292,7 @@ struct SwiftUnittest_Names_ExtensionNamingInitialsUppers: SwiftProtobuf.Extensib var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct SwiftUnittest_Names_ExtensionNamingInitialsWordCase: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -13566,39 +9304,39 @@ struct SwiftUnittest_Names_ExtensionNamingInitialsWordCase: SwiftProtobuf.Extens var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct SwiftUnittest_Names_ValidIdentifiers { +struct SwiftProtoTesting_Names_ValidIdentifiers: Sendable { // 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 _1Field: Int32 { - get {return __1Field ?? 0} + get {__1Field ?? 0} set {__1Field = newValue} } /// Returns true if `_1Field` has been explicitly set. - var has_1Field: Bool {return self.__1Field != nil} + var has_1Field: Bool {self.__1Field != nil} /// Clears the value of `_1Field`. Subsequent reads from it will return its default value. mutating func clear_1Field() {self.__1Field = nil} var field: Int32 { - get {return _field ?? 0} + get {_field ?? 0} set {_field = newValue} } /// Returns true if `field` has been explicitly set. - var hasField: Bool {return self._field != nil} + var hasField: Bool {self._field != nil} /// Clears the value of `field`. Subsequent reads from it will return its default value. mutating func clearField() {self._field = nil} var _3Field3: Int32 { - get {return __3Field3 ?? 0} + get {__3Field3 ?? 0} set {__3Field3 = newValue} } /// Returns true if `_3Field3` has been explicitly set. - var has_3Field3: Bool {return self.__3Field3 != nil} + var has_3Field3: Bool {self.__3Field3 != nil} /// Clears the value of `_3Field3`. Subsequent reads from it will return its default value. mutating func clear_3Field3() {self.__3Field3 = nil} - var _2Of: SwiftUnittest_Names_ValidIdentifiers.OneOf__2Of? = nil + var _2Of: SwiftProtoTesting_Names_ValidIdentifiers.OneOf__2Of? = nil var _4: Int32 { get { @@ -13616,79 +9354,41 @@ struct SwiftUnittest_Names_ValidIdentifiers { set {_2Of = ._5Field(newValue)} } - var enumField: SwiftUnittest_Names_ValidIdentifiers.TestEnum { - get {return _enumField ?? .testEnum0} + var enumField: SwiftProtoTesting_Names_ValidIdentifiers.TestEnum { + get {_enumField ?? .testEnum0} set {_enumField = newValue} } /// Returns true if `enumField` has been explicitly set. - var hasEnumField: Bool {return self._enumField != nil} + var hasEnumField: Bool {self._enumField != nil} /// Clears the value of `enumField`. Subsequent reads from it will return its default value. mutating func clearEnumField() {self._enumField = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf__2Of: Equatable { + enum OneOf__2Of: Equatable, Sendable { case _4(Int32) case _5Field(Int32) - #if !swift(>=4.1) - static func ==(lhs: SwiftUnittest_Names_ValidIdentifiers.OneOf__2Of, rhs: SwiftUnittest_Names_ValidIdentifiers.OneOf__2Of) -> 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 (._4, ._4): return { - guard case ._4(let l) = lhs, case ._4(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (._5Field, ._5Field): return { - guard case ._5Field(let l) = lhs, case ._5Field(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum TestEnum: SwiftProtobuf.Enum { - typealias RawValue = Int + enum TestEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { /// Won't prefix strip - case testEnum0 // = 0 + case testEnum0 = 0 /// Will prefix strip - case first // = 1 + case first = 1 /// Leading underscore & number, keeps that. - case _2 // = 2 + case _2 = 2 /// Leading underscore & number, keeps that. - case _3Value // = 3 + case _3Value = 3 init() { self = .testEnum0 } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .testEnum0 - case 1: self = .first - case 2: self = ._2 - case 3: self = ._3Value - default: return nil - } - } - - var rawValue: Int { - switch self { - case .testEnum0: return 0 - case .first: return 1 - case ._2: return 2 - case ._3Value: return 3 - } - } - } init() {} @@ -13696,26 +9396,18 @@ struct SwiftUnittest_Names_ValidIdentifiers { fileprivate var __1Field: Int32? = nil fileprivate var _field: Int32? = nil fileprivate var __3Field3: Int32? = nil - fileprivate var _enumField: SwiftUnittest_Names_ValidIdentifiers.TestEnum? = nil + fileprivate var _enumField: SwiftProtoTesting_Names_ValidIdentifiers.TestEnum? = nil } -#if swift(>=4.2) - -extension SwiftUnittest_Names_ValidIdentifiers.TestEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - /// For issue #1084 - If the generated code compiles, things are good. /// /// This gets special handling because of the generated setter. -struct SwiftUnittest_Names_SpecialNames1 { +struct SwiftProtoTesting_Names_SpecialNames1: Sendable { // 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 newValue: SwiftUnittest_Names_SpecialNames1.OneOf_NewValue? = nil + var newValue: SwiftProtoTesting_Names_SpecialNames1.OneOf_NewValue? = nil var str: String { get { @@ -13727,39 +9419,26 @@ struct SwiftUnittest_Names_SpecialNames1 { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_NewValue: Equatable { + enum OneOf_NewValue: Equatable, Sendable { case str(String) - #if !swift(>=4.1) - static func ==(lhs: SwiftUnittest_Names_SpecialNames1.OneOf_NewValue, rhs: SwiftUnittest_Names_SpecialNames1.OneOf_NewValue) -> 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 (.str, .str): return { - guard case .str(let l) = lhs, case .str(let r) = rhs else { preconditionFailure() } - return l == r - }() - } - } - #endif } init() {} } /// No special handling needed in the generator. -struct SwiftUnittest_Names_SpecialNames2 { +struct SwiftProtoTesting_Names_SpecialNames2: Sendable { // 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 newValue: String { - get {return _newValue ?? String()} + get {_newValue ?? String()} set {_newValue = newValue} } /// Returns true if `newValue` has been explicitly set. - var hasNewValue: Bool {return self._newValue != nil} + var hasNewValue: Bool {self._newValue != nil} /// Clears the value of `newValue`. Subsequent reads from it will return its default value. mutating func clearNewValue() {self._newValue = nil} @@ -13771,7 +9450,7 @@ struct SwiftUnittest_Names_SpecialNames2 { } /// No special handling needed in the generator. -struct SwiftUnittest_Names_SpecialNames3 { +struct SwiftProtoTesting_Names_SpecialNames3: @unchecked Sendable { // 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. @@ -13789,33 +9468,20 @@ struct SwiftUnittest_Names_SpecialNames3 { set {_uniqueStorage()._newValue = .str(newValue)} } - var forcesStorage: SwiftUnittest_Names_SpecialNames3 { - get {return _storage._forcesStorage ?? SwiftUnittest_Names_SpecialNames3()} + var forcesStorage: SwiftProtoTesting_Names_SpecialNames3 { + get {_storage._forcesStorage ?? SwiftProtoTesting_Names_SpecialNames3()} set {_uniqueStorage()._forcesStorage = newValue} } /// Returns true if `forcesStorage` has been explicitly set. - var hasForcesStorage: Bool {return _storage._forcesStorage != nil} + var hasForcesStorage: Bool {_storage._forcesStorage != nil} /// Clears the value of `forcesStorage`. Subsequent reads from it will return its default value. mutating func clearForcesStorage() {_uniqueStorage()._forcesStorage = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_NewValue: Equatable { + enum OneOf_NewValue: Equatable, Sendable { case str(String) - #if !swift(>=4.1) - static func ==(lhs: SwiftUnittest_Names_SpecialNames3.OneOf_NewValue, rhs: SwiftUnittest_Names_SpecialNames3.OneOf_NewValue) -> 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 (.str, .str): return { - guard case .str(let l) = lhs, case .str(let r) = rhs else { preconditionFailure() } - return l == r - }() - } - } - #endif } init() {} @@ -13824,26 +9490,26 @@ struct SwiftUnittest_Names_SpecialNames3 { } /// No special handling needed in the generator. -struct SwiftUnittest_Names_SpecialNames4 { +struct SwiftProtoTesting_Names_SpecialNames4: @unchecked Sendable { // 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 newValue: String { - get {return _storage._newValue ?? String()} + get {_storage._newValue ?? String()} set {_uniqueStorage()._newValue = newValue} } /// Returns true if `newValue` has been explicitly set. - var hasNewValue: Bool {return _storage._newValue != nil} + var hasNewValue: Bool {_storage._newValue != nil} /// Clears the value of `newValue`. Subsequent reads from it will return its default value. mutating func clearNewValue() {_uniqueStorage()._newValue = nil} - var forcesStorage: SwiftUnittest_Names_SpecialNames4 { - get {return _storage._forcesStorage ?? SwiftUnittest_Names_SpecialNames4()} + var forcesStorage: SwiftProtoTesting_Names_SpecialNames4 { + get {_storage._forcesStorage ?? SwiftProtoTesting_Names_SpecialNames4()} set {_uniqueStorage()._forcesStorage = newValue} } /// Returns true if `forcesStorage` has been explicitly set. - var hasForcesStorage: Bool {return _storage._forcesStorage != nil} + var hasForcesStorage: Bool {_storage._forcesStorage != nil} /// Clears the value of `forcesStorage`. Subsequent reads from it will return its default value. mutating func clearForcesStorage() {_uniqueStorage()._forcesStorage = nil} @@ -13854,2889 +9520,2223 @@ struct SwiftUnittest_Names_SpecialNames4 { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=5.5) && canImport(_Concurrency) -extension SwiftUnittest_Names_EnumFieldNames: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumFieldNames2: @unchecked Sendable {} -extension SwiftUnittest_Names_Foo: @unchecked Sendable {} -extension SwiftUnittest_Names_FieldNames: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.StringMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.ProtocolMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.IntMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.DoubleMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.FloatMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.UIntMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.hashValueMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.descriptionMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.debugDescriptionMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Swift: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.UNRECOGNIZED: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.classMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.deinitMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.enumMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.extensionMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.funcMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.importMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.initMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.inoutMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.internalMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.letMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.operatorMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.privateMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.protocolMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.publicMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.staticMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.structMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.subscriptMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.typealiasMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.varMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.breakMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.caseMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.continueMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.defaultMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.deferMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.doMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.elseMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.fallthroughMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.forMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.guardMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.ifMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.inMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.repeatMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.returnMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.switchMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.whereMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.whileMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.asMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.catchMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.dynamicTypeMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.falseMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.isMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.nilMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.rethrowsMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.superMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.selfMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.throwMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.throwsMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.trueMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.tryMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.__COLUMN__Message: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.__FILE__Message: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.__FUNCTION__Message: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.__LINE__Message: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames._Message: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.__Message: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.associativity: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.convenience: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.dynamic: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.didSet: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.final: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.get: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.infix: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.indirect: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.lazy: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.left: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.mutating: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.none: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.nonmutating: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.optional: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.override: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.postfix: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.precedence: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.prefix: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.required: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.right: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.set: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.TypeMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.unowned: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.weak: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.willSet: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.id: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames._cmd: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.out: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.bycopy: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.byref: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.oneway: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.and: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.and_eq: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.alignas: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.alignof: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.asm: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.auto: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.bitand: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.bitor: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.bool: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.char: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.char16_t: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.char32_t: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.compl: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.const: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.constexpr: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.const_cast: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.decltype: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.delete: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.dynamic_cast: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.explicit: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.export: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.extern: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.friend: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.goto: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.inline: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.long: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.mutable: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.namespace: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.new: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.noexcept: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.not: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.not_eq: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.nullptr: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.or: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.or_eq: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.protected: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.register: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.reinterpret_cast: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.short: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.signed: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.sizeof: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.static_assert: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.static_cast: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.template: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.this: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.thread_local: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.typedef: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.typeid: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.typename: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.union: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.unsigned: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.using: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.virtual: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.void: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.volatile: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.wchar_t: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.xor: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.xor_eq: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.restrict: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Category: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Ivar: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Method: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.finalize: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.hash: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.dealloc: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.superclass: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.retain: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.release: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.autorelease: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.retainCount: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.zone: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.isProxy: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.copy: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.mutableCopy: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.classForCoder: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.clear: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.data: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.delimitedData: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.descriptor: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.extensionRegistry: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.extensionsCurrentlySet: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.isInitializedMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.serializedSize: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.sortedExtensionsInUse: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.unknownFieldsMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Fixed: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Fract: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Size: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.LogicalAddress: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.PhysicalAddress: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.ByteCount: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.ByteOffset: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Duration: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.AbsoluteTime: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.OptionBits: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.ItemCount: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.PBVersion: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.ScriptCode: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.LangCode: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.RegionCode: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.OSType: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.ProcessSerialNumber: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Point: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Rect: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.FixedPoint: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.FixedRect: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Style: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.StyleParameter: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.StyleField: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.TimeScale: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.TimeBase: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.TimeRecord: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.serializedData: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.jsonUTF8Data: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.jsonString: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Extension: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.ExtensionsMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.StringEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.ProtocolEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.IntEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.DoubleEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.FloatEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.UIntEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.hashValueEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.descriptionEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.debugDescriptionEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Swift: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.UNRECOGNIZED: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.classEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.deinitEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.enumEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.extensionEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.funcEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.importEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.initEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.inoutEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.internalEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.letEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.operatorEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.privateEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.protocolEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.publicEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.staticEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.structEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.subscriptEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.typealiasEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.varEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.breakEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.caseEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.continueEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.defaultEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.deferEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.doEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.elseEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.fallthroughEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.forEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.guardEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.ifEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.inEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.repeatEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.returnEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.switchEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.whereEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.whileEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.asEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.catchEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.dynamicTypeEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.falseEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.isEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.nilEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.rethrowsEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.superEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.selfEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.throwEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.throwsEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.trueEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.tryEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.__COLUMN__Enum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.__FILE__Enum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.__FUNCTION__Enum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.__LINE__Enum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames._Enum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.__Enum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.associativity: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.convenience: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.dynamic: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.didSet: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.final: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.get: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.infix: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.indirect: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.lazy: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.left: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.mutating: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.none: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.nonmutating: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.optional: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.override: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.postfix: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.precedence: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.prefix: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.required: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.right: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.set: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.TypeEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.unowned: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.weak: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.willSet: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.id: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames._cmd: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.out: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.bycopy: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.byref: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.oneway: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.and: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.and_eq: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.alignas: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.alignof: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.asm: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.auto: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.bitand: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.bitor: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.bool: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.char: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.char16_t: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.char32_t: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.compl: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.const: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.constexpr: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.const_cast: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.decltype: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.delete: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.dynamic_cast: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.explicit: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.export: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.extern: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.friend: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.goto: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.inline: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.long: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.mutable: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.namespace: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.new: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.noexcept: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.not: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.not_eq: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.nullptr: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.or: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.or_eq: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.protected: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.register: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.reinterpret_cast: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.short: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.signed: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.sizeof: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.static_assert: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.static_cast: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.template: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.this: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.thread_local: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.typedef: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.typeid: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.typename: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.union: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.unsigned: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.using: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.virtual: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.void: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.volatile: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.wchar_t: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.xor: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.xor_eq: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.restrict: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Category: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Ivar: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Method: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.finalize: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.hash: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.dealloc: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.superclass: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.retain: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.release: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.autorelease: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.retainCount: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.zone: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.isProxy: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.copy: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.mutableCopy: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.classForCoder: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.clear: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.data: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.delimitedData: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.descriptor: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.extensionRegistry: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.extensionsCurrentlySet: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.isInitializedEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.serializedSize: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.sortedExtensionsInUse: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.unknownFieldsEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Fixed: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Fract: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Size: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.LogicalAddress: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.PhysicalAddress: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.ByteCount: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.ByteOffset: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Duration: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.AbsoluteTime: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.OptionBits: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.ItemCount: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.PBVersion: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.ScriptCode: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.LangCode: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.RegionCode: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.OSType: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.ProcessSerialNumber: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Point: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Rect: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.FixedPoint: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.FixedRect: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Style: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.StyleParameter: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.StyleField: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.TimeScale: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.TimeBase: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.TimeRecord: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Extension: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.ExtensionsEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_FieldNamingInitials: @unchecked Sendable {} -extension SwiftUnittest_Names_FieldNamingInitials.Lowers: @unchecked Sendable {} -extension SwiftUnittest_Names_FieldNamingInitials.Uppers: @unchecked Sendable {} -extension SwiftUnittest_Names_FieldNamingInitials.WordCase: @unchecked Sendable {} -extension SwiftUnittest_Names_ExtensionNamingInitials: @unchecked Sendable {} -extension SwiftUnittest_Names_Lowers: @unchecked Sendable {} -extension SwiftUnittest_Names_Uppers: @unchecked Sendable {} -extension SwiftUnittest_Names_WordCase: @unchecked Sendable {} -extension SwiftUnittest_Names_ExtensionNamingInitialsLowers: @unchecked Sendable {} -extension SwiftUnittest_Names_ExtensionNamingInitialsUppers: @unchecked Sendable {} -extension SwiftUnittest_Names_ExtensionNamingInitialsWordCase: @unchecked Sendable {} -extension SwiftUnittest_Names_ValidIdentifiers: @unchecked Sendable {} -extension SwiftUnittest_Names_ValidIdentifiers.OneOf__2Of: @unchecked Sendable {} -extension SwiftUnittest_Names_ValidIdentifiers.TestEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_SpecialNames1: @unchecked Sendable {} -extension SwiftUnittest_Names_SpecialNames1.OneOf_NewValue: @unchecked Sendable {} -extension SwiftUnittest_Names_SpecialNames2: @unchecked Sendable {} -extension SwiftUnittest_Names_SpecialNames3: @unchecked Sendable {} -extension SwiftUnittest_Names_SpecialNames3.OneOf_NewValue: @unchecked Sendable {} -extension SwiftUnittest_Names_SpecialNames4: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_naming.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 SwiftUnittest_Names_ExtensionNamingInitials { +extension SwiftProtoTesting_Names_ExtensionNamingInitials { - var SwiftUnittest_Names_Lowers_http: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.http) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.http, value: newValue)} + var SwiftProtoTesting_Names_Lowers_http: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.http) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.http, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.http` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.http` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_http: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.http) + var hasSwiftProtoTesting_Names_Lowers_http: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.http) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.http`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.http`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_http() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.http) + mutating func clearSwiftProtoTesting_Names_Lowers_http() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.http) } - var SwiftUnittest_Names_Lowers_httpRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.http_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.http_request, value: newValue)} + var SwiftProtoTesting_Names_Lowers_httpRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.http_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.http_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.http_request` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.http_request` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_httpRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.http_request) + var hasSwiftProtoTesting_Names_Lowers_httpRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.http_request) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.http_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.http_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_httpRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.http_request) + mutating func clearSwiftProtoTesting_Names_Lowers_httpRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.http_request) } - var SwiftUnittest_Names_Lowers_theHTTPRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_http_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_http_request, value: newValue)} + var SwiftProtoTesting_Names_Lowers_theHTTPRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_http_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_http_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.the_http_request` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.the_http_request` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_theHTTPRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_http_request) + var hasSwiftProtoTesting_Names_Lowers_theHTTPRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_http_request) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.the_http_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.the_http_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_theHTTPRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_http_request) + mutating func clearSwiftProtoTesting_Names_Lowers_theHTTPRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_http_request) } - var SwiftUnittest_Names_Lowers_theHTTP: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_http) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_http, value: newValue)} + var SwiftProtoTesting_Names_Lowers_theHTTP: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_http) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_http, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.the_http` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.the_http` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_theHTTP: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_http) + var hasSwiftProtoTesting_Names_Lowers_theHTTP: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_http) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.the_http`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.the_http`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_theHTTP() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_http) + mutating func clearSwiftProtoTesting_Names_Lowers_theHTTP() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_http) } - var SwiftUnittest_Names_Lowers_https: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.https) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.https, value: newValue)} + var SwiftProtoTesting_Names_Lowers_https: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.https) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.https, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.https` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.https` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_https: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.https) + var hasSwiftProtoTesting_Names_Lowers_https: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.https) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.https`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.https`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_https() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.https) + mutating func clearSwiftProtoTesting_Names_Lowers_https() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.https) } - var SwiftUnittest_Names_Lowers_httpsRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.https_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.https_request, value: newValue)} + var SwiftProtoTesting_Names_Lowers_httpsRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.https_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.https_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.https_request` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.https_request` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_httpsRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.https_request) + var hasSwiftProtoTesting_Names_Lowers_httpsRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.https_request) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.https_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.https_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_httpsRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.https_request) + mutating func clearSwiftProtoTesting_Names_Lowers_httpsRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.https_request) } - var SwiftUnittest_Names_Lowers_theHTTPSRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_https_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_https_request, value: newValue)} + var SwiftProtoTesting_Names_Lowers_theHTTPSRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_https_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_https_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.the_https_request` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.the_https_request` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_theHTTPSRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_https_request) + var hasSwiftProtoTesting_Names_Lowers_theHTTPSRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_https_request) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.the_https_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.the_https_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_theHTTPSRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_https_request) + mutating func clearSwiftProtoTesting_Names_Lowers_theHTTPSRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_https_request) } - var SwiftUnittest_Names_Lowers_theHTTPS: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_https) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_https, value: newValue)} + var SwiftProtoTesting_Names_Lowers_theHTTPS: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_https) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_https, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.the_https` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.the_https` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_theHTTPS: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_https) + var hasSwiftProtoTesting_Names_Lowers_theHTTPS: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_https) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.the_https`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.the_https`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_theHTTPS() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_https) + mutating func clearSwiftProtoTesting_Names_Lowers_theHTTPS() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_https) } - var SwiftUnittest_Names_Lowers_url: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.url) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.url, value: newValue)} + var SwiftProtoTesting_Names_Lowers_url: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.url) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.url, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.url` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.url` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_url: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.url) + var hasSwiftProtoTesting_Names_Lowers_url: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.url) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.url`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.url`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_url() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.url) + mutating func clearSwiftProtoTesting_Names_Lowers_url() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.url) } - var SwiftUnittest_Names_Lowers_urlValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.url_value) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.url_value, value: newValue)} + var SwiftProtoTesting_Names_Lowers_urlValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.url_value) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.url_value, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.url_value` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.url_value` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_urlValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.url_value) + var hasSwiftProtoTesting_Names_Lowers_urlValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.url_value) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.url_value`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.url_value`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_urlValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.url_value) + mutating func clearSwiftProtoTesting_Names_Lowers_urlValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.url_value) } - var SwiftUnittest_Names_Lowers_theURLValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_url_value) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_url_value, value: newValue)} + var SwiftProtoTesting_Names_Lowers_theURLValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_url_value) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_url_value, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.the_url_value` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.the_url_value` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_theURLValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_url_value) + var hasSwiftProtoTesting_Names_Lowers_theURLValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_url_value) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.the_url_value`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.the_url_value`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_theURLValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_url_value) + mutating func clearSwiftProtoTesting_Names_Lowers_theURLValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_url_value) } - var SwiftUnittest_Names_Lowers_theURL: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_url) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_url, value: newValue)} + var SwiftProtoTesting_Names_Lowers_theURL: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_url) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_url, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.the_url` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.the_url` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_theURL: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_url) + var hasSwiftProtoTesting_Names_Lowers_theURL: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_url) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.the_url`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.the_url`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_theURL() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_url) + mutating func clearSwiftProtoTesting_Names_Lowers_theURL() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_url) } - var SwiftUnittest_Names_Lowers_aBC: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.a_b_c) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.a_b_c, value: newValue)} + var SwiftProtoTesting_Names_Lowers_aBC: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.a_b_c) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.a_b_c, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.a_b_c` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.a_b_c` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_aBC: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.a_b_c) + var hasSwiftProtoTesting_Names_Lowers_aBC: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.a_b_c) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.a_b_c`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.a_b_c`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_aBC() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.a_b_c) + mutating func clearSwiftProtoTesting_Names_Lowers_aBC() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.a_b_c) } - var SwiftUnittest_Names_Lowers_id: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.id) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.id, value: newValue)} + var SwiftProtoTesting_Names_Lowers_id: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.id) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.id, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.id` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.id` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_id: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.id) + var hasSwiftProtoTesting_Names_Lowers_id: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.id) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.id`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.id`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_id() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.id) + mutating func clearSwiftProtoTesting_Names_Lowers_id() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.id) } - var SwiftUnittest_Names_Lowers_idNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.id_number) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.id_number, value: newValue)} + var SwiftProtoTesting_Names_Lowers_idNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.id_number) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.id_number, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.id_number` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.id_number` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_idNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.id_number) + var hasSwiftProtoTesting_Names_Lowers_idNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.id_number) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.id_number`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.id_number`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_idNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.id_number) + mutating func clearSwiftProtoTesting_Names_Lowers_idNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.id_number) } - var SwiftUnittest_Names_Lowers_theIDNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_id_number) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_id_number, value: newValue)} + var SwiftProtoTesting_Names_Lowers_theIDNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_id_number) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_id_number, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.the_id_number` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.the_id_number` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_theIDNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_id_number) + var hasSwiftProtoTesting_Names_Lowers_theIDNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_id_number) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.the_id_number`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.the_id_number`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_theIDNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_id_number) + mutating func clearSwiftProtoTesting_Names_Lowers_theIDNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_id_number) } - var SwiftUnittest_Names_Lowers_requestID: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.request_id) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.request_id, value: newValue)} + var SwiftProtoTesting_Names_Lowers_requestID: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.request_id) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.request_id, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.request_id` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.request_id` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_requestID: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.request_id) + var hasSwiftProtoTesting_Names_Lowers_requestID: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.request_id) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.request_id`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.request_id`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_requestID() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.request_id) + mutating func clearSwiftProtoTesting_Names_Lowers_requestID() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.request_id) } - var SwiftUnittest_Names_Uppers_http: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTP) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTP, value: newValue)} + var SwiftProtoTesting_Names_Uppers_http: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTP) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTP, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.HTTP` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.HTTP` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_http: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTP) + var hasSwiftProtoTesting_Names_Uppers_http: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTP) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.HTTP`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.HTTP`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_http() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTP) + mutating func clearSwiftProtoTesting_Names_Uppers_http() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTP) } - var SwiftUnittest_Names_Uppers_httpRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTP_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTP_request, value: newValue)} + var SwiftProtoTesting_Names_Uppers_httpRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTP_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTP_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.HTTP_request` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.HTTP_request` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_httpRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTP_request) + var hasSwiftProtoTesting_Names_Uppers_httpRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTP_request) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.HTTP_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.HTTP_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_httpRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTP_request) + mutating func clearSwiftProtoTesting_Names_Uppers_httpRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTP_request) } - var SwiftUnittest_Names_Uppers_theHTTPRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTP_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTP_request, value: newValue)} + var SwiftProtoTesting_Names_Uppers_theHTTPRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.the_HTTP_request` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP_request` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_theHTTPRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTP_request) + var hasSwiftProtoTesting_Names_Uppers_theHTTPRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP_request) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.the_HTTP_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_theHTTPRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTP_request) + mutating func clearSwiftProtoTesting_Names_Uppers_theHTTPRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP_request) } - var SwiftUnittest_Names_Uppers_theHTTP: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTP) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTP, value: newValue)} + var SwiftProtoTesting_Names_Uppers_theHTTP: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.the_HTTP` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_theHTTP: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTP) + var hasSwiftProtoTesting_Names_Uppers_theHTTP: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.the_HTTP`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_theHTTP() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTP) + mutating func clearSwiftProtoTesting_Names_Uppers_theHTTP() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP) } - var SwiftUnittest_Names_Uppers_https: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTPS) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTPS, value: newValue)} + var SwiftProtoTesting_Names_Uppers_https: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTPS) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTPS, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.HTTPS` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.HTTPS` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_https: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTPS) + var hasSwiftProtoTesting_Names_Uppers_https: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTPS) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.HTTPS`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.HTTPS`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_https() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTPS) + mutating func clearSwiftProtoTesting_Names_Uppers_https() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTPS) } - var SwiftUnittest_Names_Uppers_httpsRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTPS_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTPS_request, value: newValue)} + var SwiftProtoTesting_Names_Uppers_httpsRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTPS_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTPS_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.HTTPS_request` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.HTTPS_request` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_httpsRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTPS_request) + var hasSwiftProtoTesting_Names_Uppers_httpsRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTPS_request) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.HTTPS_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.HTTPS_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_httpsRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTPS_request) + mutating func clearSwiftProtoTesting_Names_Uppers_httpsRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTPS_request) } - var SwiftUnittest_Names_Uppers_theHTTPSRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTPS_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTPS_request, value: newValue)} + var SwiftProtoTesting_Names_Uppers_theHTTPSRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.the_HTTPS_request` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS_request` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_theHTTPSRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTPS_request) + var hasSwiftProtoTesting_Names_Uppers_theHTTPSRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS_request) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.the_HTTPS_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_theHTTPSRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTPS_request) + mutating func clearSwiftProtoTesting_Names_Uppers_theHTTPSRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS_request) } - var SwiftUnittest_Names_Uppers_theHTTPS: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTPS) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTPS, value: newValue)} + var SwiftProtoTesting_Names_Uppers_theHTTPS: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.the_HTTPS` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_theHTTPS: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTPS) + var hasSwiftProtoTesting_Names_Uppers_theHTTPS: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.the_HTTPS`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_theHTTPS() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTPS) + mutating func clearSwiftProtoTesting_Names_Uppers_theHTTPS() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS) } - var SwiftUnittest_Names_Uppers_url: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.URL) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.URL, value: newValue)} + var SwiftProtoTesting_Names_Uppers_url: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.URL) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.URL, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.URL` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.URL` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_url: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.URL) + var hasSwiftProtoTesting_Names_Uppers_url: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.URL) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.URL`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.URL`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_url() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.URL) + mutating func clearSwiftProtoTesting_Names_Uppers_url() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.URL) } - var SwiftUnittest_Names_Uppers_urlValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.URL_value) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.URL_value, value: newValue)} + var SwiftProtoTesting_Names_Uppers_urlValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.URL_value) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.URL_value, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.URL_value` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.URL_value` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_urlValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.URL_value) + var hasSwiftProtoTesting_Names_Uppers_urlValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.URL_value) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.URL_value`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.URL_value`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_urlValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.URL_value) + mutating func clearSwiftProtoTesting_Names_Uppers_urlValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.URL_value) } - var SwiftUnittest_Names_Uppers_theURLValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_URL_value) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_URL_value, value: newValue)} + var SwiftProtoTesting_Names_Uppers_theURLValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_URL_value) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_URL_value, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.the_URL_value` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.the_URL_value` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_theURLValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_URL_value) + var hasSwiftProtoTesting_Names_Uppers_theURLValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_URL_value) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.the_URL_value`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.the_URL_value`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_theURLValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_URL_value) + mutating func clearSwiftProtoTesting_Names_Uppers_theURLValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_URL_value) } - var SwiftUnittest_Names_Uppers_theURL: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_URL) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_URL, value: newValue)} + var SwiftProtoTesting_Names_Uppers_theURL: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_URL) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_URL, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.the_URL` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.the_URL` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_theURL: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_URL) + var hasSwiftProtoTesting_Names_Uppers_theURL: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_URL) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.the_URL`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.the_URL`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_theURL() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_URL) + mutating func clearSwiftProtoTesting_Names_Uppers_theURL() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_URL) } - var SwiftUnittest_Names_Uppers_id: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.ID) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.ID, value: newValue)} + var SwiftProtoTesting_Names_Uppers_id: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.ID) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.ID, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.ID` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.ID` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_id: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.ID) + var hasSwiftProtoTesting_Names_Uppers_id: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.ID) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.ID`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.ID`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_id() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.ID) + mutating func clearSwiftProtoTesting_Names_Uppers_id() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.ID) } - var SwiftUnittest_Names_Uppers_idNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.ID_number) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.ID_number, value: newValue)} + var SwiftProtoTesting_Names_Uppers_idNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.ID_number) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.ID_number, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.ID_number` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.ID_number` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_idNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.ID_number) + var hasSwiftProtoTesting_Names_Uppers_idNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.ID_number) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.ID_number`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.ID_number`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_idNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.ID_number) + mutating func clearSwiftProtoTesting_Names_Uppers_idNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.ID_number) } - var SwiftUnittest_Names_Uppers_theIDNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_ID_number) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_ID_number, value: newValue)} + var SwiftProtoTesting_Names_Uppers_theIDNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_ID_number) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_ID_number, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.the_ID_number` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.the_ID_number` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_theIDNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_ID_number) + var hasSwiftProtoTesting_Names_Uppers_theIDNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_ID_number) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.the_ID_number`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.the_ID_number`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_theIDNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_ID_number) + mutating func clearSwiftProtoTesting_Names_Uppers_theIDNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_ID_number) } - var SwiftUnittest_Names_Uppers_requestID: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.request_ID) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.request_ID, value: newValue)} + var SwiftProtoTesting_Names_Uppers_requestID: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.request_ID) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.request_ID, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.request_ID` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.request_ID` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_requestID: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.request_ID) + var hasSwiftProtoTesting_Names_Uppers_requestID: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.request_ID) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.request_ID`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.request_ID`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_requestID() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.request_ID) + mutating func clearSwiftProtoTesting_Names_Uppers_requestID() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.request_ID) } - var SwiftUnittest_Names_WordCase_http: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Http) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Http, value: newValue)} + var SwiftProtoTesting_Names_WordCase_http: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Http) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Http, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.Http` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.Http` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_http: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Http) + var hasSwiftProtoTesting_Names_WordCase_http: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Http) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.Http`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.Http`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_http() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Http) + mutating func clearSwiftProtoTesting_Names_WordCase_http() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Http) } - var SwiftUnittest_Names_WordCase_httpRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.HttpRequest) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.HttpRequest, value: newValue)} + var SwiftProtoTesting_Names_WordCase_httpRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.HttpRequest) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.HttpRequest, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.HttpRequest` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.HttpRequest` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_httpRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.HttpRequest) + var hasSwiftProtoTesting_Names_WordCase_httpRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.HttpRequest) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.HttpRequest`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.HttpRequest`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_httpRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.HttpRequest) + mutating func clearSwiftProtoTesting_Names_WordCase_httpRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.HttpRequest) } - var SwiftUnittest_Names_WordCase_theHTTPRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttpRequest) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttpRequest, value: newValue)} + var SwiftProtoTesting_Names_WordCase_theHTTPRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttpRequest) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttpRequest, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.TheHttpRequest` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.TheHttpRequest` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_theHTTPRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttpRequest) + var hasSwiftProtoTesting_Names_WordCase_theHTTPRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttpRequest) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.TheHttpRequest`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.TheHttpRequest`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_theHTTPRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttpRequest) + mutating func clearSwiftProtoTesting_Names_WordCase_theHTTPRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttpRequest) } - var SwiftUnittest_Names_WordCase_theHTTP: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttp) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttp, value: newValue)} + var SwiftProtoTesting_Names_WordCase_theHTTP: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttp) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttp, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.TheHttp` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.TheHttp` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_theHTTP: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttp) + var hasSwiftProtoTesting_Names_WordCase_theHTTP: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttp) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.TheHttp`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.TheHttp`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_theHTTP() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttp) + mutating func clearSwiftProtoTesting_Names_WordCase_theHTTP() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttp) } - var SwiftUnittest_Names_WordCase_https: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Https) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Https, value: newValue)} + var SwiftProtoTesting_Names_WordCase_https: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Https) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Https, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.Https` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.Https` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_https: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Https) + var hasSwiftProtoTesting_Names_WordCase_https: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Https) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.Https`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.Https`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_https() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Https) + mutating func clearSwiftProtoTesting_Names_WordCase_https() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Https) } - var SwiftUnittest_Names_WordCase_httpsRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.HttpsRequest) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.HttpsRequest, value: newValue)} + var SwiftProtoTesting_Names_WordCase_httpsRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.HttpsRequest) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.HttpsRequest, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.HttpsRequest` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.HttpsRequest` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_httpsRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.HttpsRequest) + var hasSwiftProtoTesting_Names_WordCase_httpsRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.HttpsRequest) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.HttpsRequest`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.HttpsRequest`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_httpsRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.HttpsRequest) + mutating func clearSwiftProtoTesting_Names_WordCase_httpsRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.HttpsRequest) } - var SwiftUnittest_Names_WordCase_theHTTPSRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttpsRequest) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttpsRequest, value: newValue)} + var SwiftProtoTesting_Names_WordCase_theHTTPSRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttpsRequest) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttpsRequest, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.TheHttpsRequest` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.TheHttpsRequest` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_theHTTPSRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttpsRequest) + var hasSwiftProtoTesting_Names_WordCase_theHTTPSRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttpsRequest) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.TheHttpsRequest`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.TheHttpsRequest`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_theHTTPSRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttpsRequest) + mutating func clearSwiftProtoTesting_Names_WordCase_theHTTPSRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttpsRequest) } - var SwiftUnittest_Names_WordCase_theHTTPS: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttps) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttps, value: newValue)} + var SwiftProtoTesting_Names_WordCase_theHTTPS: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttps) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttps, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.TheHttps` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.TheHttps` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_theHTTPS: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttps) + var hasSwiftProtoTesting_Names_WordCase_theHTTPS: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttps) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.TheHttps`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.TheHttps`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_theHTTPS() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttps) + mutating func clearSwiftProtoTesting_Names_WordCase_theHTTPS() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttps) } - var SwiftUnittest_Names_WordCase_url: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Url) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Url, value: newValue)} + var SwiftProtoTesting_Names_WordCase_url: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Url) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Url, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.Url` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.Url` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_url: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Url) + var hasSwiftProtoTesting_Names_WordCase_url: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Url) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.Url`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.Url`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_url() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Url) + mutating func clearSwiftProtoTesting_Names_WordCase_url() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Url) } - var SwiftUnittest_Names_WordCase_urlValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.UrlValue) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.UrlValue, value: newValue)} + var SwiftProtoTesting_Names_WordCase_urlValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.UrlValue) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.UrlValue, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.UrlValue` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.UrlValue` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_urlValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.UrlValue) + var hasSwiftProtoTesting_Names_WordCase_urlValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.UrlValue) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.UrlValue`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.UrlValue`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_urlValue() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.UrlValue) + mutating func clearSwiftProtoTesting_Names_WordCase_urlValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.UrlValue) } - var SwiftUnittest_Names_WordCase_theURLValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheUrlValue) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheUrlValue, value: newValue)} + var SwiftProtoTesting_Names_WordCase_theURLValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheUrlValue) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheUrlValue, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.TheUrlValue` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.TheUrlValue` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_theURLValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheUrlValue) + var hasSwiftProtoTesting_Names_WordCase_theURLValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheUrlValue) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.TheUrlValue`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.TheUrlValue`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_theURLValue() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheUrlValue) + mutating func clearSwiftProtoTesting_Names_WordCase_theURLValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheUrlValue) } - var SwiftUnittest_Names_WordCase_theURL: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheUrl) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheUrl, value: newValue)} + var SwiftProtoTesting_Names_WordCase_theURL: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheUrl) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheUrl, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.TheUrl` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.TheUrl` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_theURL: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheUrl) + var hasSwiftProtoTesting_Names_WordCase_theURL: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheUrl) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.TheUrl`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.TheUrl`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_theURL() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheUrl) + mutating func clearSwiftProtoTesting_Names_WordCase_theURL() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheUrl) } - var SwiftUnittest_Names_WordCase_id: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Id) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Id, value: newValue)} + var SwiftProtoTesting_Names_WordCase_id: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Id) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Id, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.Id` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.Id` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_id: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Id) + var hasSwiftProtoTesting_Names_WordCase_id: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Id) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.Id`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.Id`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_id() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Id) + mutating func clearSwiftProtoTesting_Names_WordCase_id() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Id) } - var SwiftUnittest_Names_WordCase_idNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.IdNumber) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.IdNumber, value: newValue)} + var SwiftProtoTesting_Names_WordCase_idNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.IdNumber) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.IdNumber, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.IdNumber` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.IdNumber` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_idNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.IdNumber) + var hasSwiftProtoTesting_Names_WordCase_idNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.IdNumber) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.IdNumber`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.IdNumber`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_idNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.IdNumber) + mutating func clearSwiftProtoTesting_Names_WordCase_idNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.IdNumber) } - var SwiftUnittest_Names_WordCase_theIDNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheIdNumber) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheIdNumber, value: newValue)} + var SwiftProtoTesting_Names_WordCase_theIDNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheIdNumber) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheIdNumber, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.TheIdNumber` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.TheIdNumber` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_theIDNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheIdNumber) + var hasSwiftProtoTesting_Names_WordCase_theIDNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheIdNumber) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.TheIdNumber`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.TheIdNumber`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_theIDNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheIdNumber) + mutating func clearSwiftProtoTesting_Names_WordCase_theIDNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheIdNumber) } - var SwiftUnittest_Names_WordCase_requestID: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.RequestId) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.RequestId, value: newValue)} + var SwiftProtoTesting_Names_WordCase_requestID: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.RequestId) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.RequestId, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.RequestId` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.RequestId` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_requestID: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.RequestId) + var hasSwiftProtoTesting_Names_WordCase_requestID: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.RequestId) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.RequestId`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.RequestId`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_requestID() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.RequestId) + mutating func clearSwiftProtoTesting_Names_WordCase_requestID() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.RequestId) } } -extension SwiftUnittest_Names_ExtensionNamingInitialsLowers { +extension SwiftProtoTesting_Names_ExtensionNamingInitialsLowers { - var SwiftUnittest_Names_http: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_http) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_http, value: newValue)} + var SwiftProtoTesting_Names_http: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_http) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_http, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_http` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_http` /// has been explicitly set. - var hasSwiftUnittest_Names_http: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_http) + var hasSwiftProtoTesting_Names_http: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_http) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_http`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_http`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_http() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_http) + mutating func clearSwiftProtoTesting_Names_http() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_http) } - var SwiftUnittest_Names_httpRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_http_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_http_request, value: newValue)} + var SwiftProtoTesting_Names_httpRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_http_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_http_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_http_request` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_http_request` /// has been explicitly set. - var hasSwiftUnittest_Names_httpRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_http_request) + var hasSwiftProtoTesting_Names_httpRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_http_request) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_http_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_http_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_httpRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_http_request) + mutating func clearSwiftProtoTesting_Names_httpRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_http_request) } - var SwiftUnittest_Names_theHTTPRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_http_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_http_request, value: newValue)} + var SwiftProtoTesting_Names_theHTTPRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_http_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_http_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_http_request` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_http_request` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTPRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_http_request) + var hasSwiftProtoTesting_Names_theHTTPRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_http_request) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_http_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_http_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTPRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_http_request) + mutating func clearSwiftProtoTesting_Names_theHTTPRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_http_request) } - var SwiftUnittest_Names_theHTTP: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_http) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_http, value: newValue)} + var SwiftProtoTesting_Names_theHTTP: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_http) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_http, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_http` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_http` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTP: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_http) + var hasSwiftProtoTesting_Names_theHTTP: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_http) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_http`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_http`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTP() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_http) + mutating func clearSwiftProtoTesting_Names_theHTTP() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_http) } - var SwiftUnittest_Names_https: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_https) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_https, value: newValue)} + var SwiftProtoTesting_Names_https: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_https) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_https, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_https` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_https` /// has been explicitly set. - var hasSwiftUnittest_Names_https: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_https) + var hasSwiftProtoTesting_Names_https: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_https) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_https`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_https`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_https() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_https) + mutating func clearSwiftProtoTesting_Names_https() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_https) } - var SwiftUnittest_Names_httpsRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_https_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_https_request, value: newValue)} + var SwiftProtoTesting_Names_httpsRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_https_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_https_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_https_request` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_https_request` /// has been explicitly set. - var hasSwiftUnittest_Names_httpsRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_https_request) + var hasSwiftProtoTesting_Names_httpsRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_https_request) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_https_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_https_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_httpsRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_https_request) + mutating func clearSwiftProtoTesting_Names_httpsRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_https_request) } - var SwiftUnittest_Names_theHTTPSRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_https_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_https_request, value: newValue)} + var SwiftProtoTesting_Names_theHTTPSRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_https_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_https_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_https_request` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_https_request` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTPSRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_https_request) + var hasSwiftProtoTesting_Names_theHTTPSRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_https_request) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_https_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_https_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTPSRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_https_request) + mutating func clearSwiftProtoTesting_Names_theHTTPSRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_https_request) } - var SwiftUnittest_Names_theHTTPS: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_https) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_https, value: newValue)} + var SwiftProtoTesting_Names_theHTTPS: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_https) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_https, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_https` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_https` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTPS: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_https) + var hasSwiftProtoTesting_Names_theHTTPS: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_https) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_https`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_https`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTPS() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_https) + mutating func clearSwiftProtoTesting_Names_theHTTPS() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_https) } - var SwiftUnittest_Names_url: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_url) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_url, value: newValue)} + var SwiftProtoTesting_Names_url: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_url) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_url, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_url` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_url` /// has been explicitly set. - var hasSwiftUnittest_Names_url: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_url) + var hasSwiftProtoTesting_Names_url: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_url) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_url`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_url`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_url() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_url) + mutating func clearSwiftProtoTesting_Names_url() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_url) } - var SwiftUnittest_Names_urlValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_url_value) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_url_value, value: newValue)} + var SwiftProtoTesting_Names_urlValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_url_value) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_url_value, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_url_value` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_url_value` /// has been explicitly set. - var hasSwiftUnittest_Names_urlValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_url_value) + var hasSwiftProtoTesting_Names_urlValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_url_value) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_url_value`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_url_value`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_urlValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_url_value) + mutating func clearSwiftProtoTesting_Names_urlValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_url_value) } - var SwiftUnittest_Names_theURLValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_url_value) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_url_value, value: newValue)} + var SwiftProtoTesting_Names_theURLValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_url_value) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_url_value, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_url_value` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_url_value` /// has been explicitly set. - var hasSwiftUnittest_Names_theURLValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_url_value) + var hasSwiftProtoTesting_Names_theURLValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_url_value) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_url_value`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_url_value`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theURLValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_url_value) + mutating func clearSwiftProtoTesting_Names_theURLValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_url_value) } - var SwiftUnittest_Names_theURL: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_url) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_url, value: newValue)} + var SwiftProtoTesting_Names_theURL: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_url) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_url, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_url` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_url` /// has been explicitly set. - var hasSwiftUnittest_Names_theURL: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_url) + var hasSwiftProtoTesting_Names_theURL: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_url) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_url`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_url`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theURL() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_url) + mutating func clearSwiftProtoTesting_Names_theURL() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_url) } - var SwiftUnittest_Names_aBC: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_a_b_c) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_a_b_c, value: newValue)} + var SwiftProtoTesting_Names_aBC: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_a_b_c) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_a_b_c, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_a_b_c` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_a_b_c` /// has been explicitly set. - var hasSwiftUnittest_Names_aBC: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_a_b_c) + var hasSwiftProtoTesting_Names_aBC: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_a_b_c) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_a_b_c`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_a_b_c`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_aBC() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_a_b_c) + mutating func clearSwiftProtoTesting_Names_aBC() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_a_b_c) } - var SwiftUnittest_Names_id: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_id) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_id, value: newValue)} + var SwiftProtoTesting_Names_id: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_id) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_id, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_id` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_id` /// has been explicitly set. - var hasSwiftUnittest_Names_id: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_id) + var hasSwiftProtoTesting_Names_id: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_id) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_id`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_id`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_id() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_id) + mutating func clearSwiftProtoTesting_Names_id() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_id) } - var SwiftUnittest_Names_idNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_id_number) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_id_number, value: newValue)} + var SwiftProtoTesting_Names_idNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_id_number) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_id_number, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_id_number` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_id_number` /// has been explicitly set. - var hasSwiftUnittest_Names_idNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_id_number) + var hasSwiftProtoTesting_Names_idNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_id_number) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_id_number`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_id_number`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_idNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_id_number) + mutating func clearSwiftProtoTesting_Names_idNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_id_number) } - var SwiftUnittest_Names_theIDNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_id_number) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_id_number, value: newValue)} + var SwiftProtoTesting_Names_theIDNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_id_number) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_id_number, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_id_number` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_id_number` /// has been explicitly set. - var hasSwiftUnittest_Names_theIDNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_id_number) + var hasSwiftProtoTesting_Names_theIDNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_id_number) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_id_number`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_id_number`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theIDNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_id_number) + mutating func clearSwiftProtoTesting_Names_theIDNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_id_number) } - var SwiftUnittest_Names_requestID: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_request_id) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_request_id, value: newValue)} + var SwiftProtoTesting_Names_requestID: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_request_id) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_request_id, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_request_id` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_request_id` /// has been explicitly set. - var hasSwiftUnittest_Names_requestID: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_request_id) + var hasSwiftProtoTesting_Names_requestID: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_request_id) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_request_id`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_request_id`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_requestID() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_request_id) + mutating func clearSwiftProtoTesting_Names_requestID() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_request_id) } } -extension SwiftUnittest_Names_ExtensionNamingInitialsUppers { +extension SwiftProtoTesting_Names_ExtensionNamingInitialsUppers { - var SwiftUnittest_Names_http: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTP) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTP, value: newValue)} + var SwiftProtoTesting_Names_http: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTP) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTP, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_HTTP` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_HTTP` /// has been explicitly set. - var hasSwiftUnittest_Names_http: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTP) + var hasSwiftProtoTesting_Names_http: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTP) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_HTTP`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_HTTP`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_http() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTP) + mutating func clearSwiftProtoTesting_Names_http() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTP) } - var SwiftUnittest_Names_httpRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTP_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTP_request, value: newValue)} + var SwiftProtoTesting_Names_httpRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTP_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTP_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_HTTP_request` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_HTTP_request` /// has been explicitly set. - var hasSwiftUnittest_Names_httpRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTP_request) + var hasSwiftProtoTesting_Names_httpRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTP_request) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_HTTP_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_HTTP_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_httpRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTP_request) + mutating func clearSwiftProtoTesting_Names_httpRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTP_request) } - var SwiftUnittest_Names_theHTTPRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTP_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTP_request, value: newValue)} + var SwiftProtoTesting_Names_theHTTPRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTP_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTP_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_HTTP_request` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_HTTP_request` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTPRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTP_request) + var hasSwiftProtoTesting_Names_theHTTPRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTP_request) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_HTTP_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_HTTP_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTPRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTP_request) + mutating func clearSwiftProtoTesting_Names_theHTTPRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTP_request) } - var SwiftUnittest_Names_theHTTP: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTP) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTP, value: newValue)} + var SwiftProtoTesting_Names_theHTTP: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTP) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTP, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_HTTP` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_HTTP` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTP: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTP) + var hasSwiftProtoTesting_Names_theHTTP: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTP) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_HTTP`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_HTTP`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTP() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTP) + mutating func clearSwiftProtoTesting_Names_theHTTP() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTP) } - var SwiftUnittest_Names_https: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTPS) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTPS, value: newValue)} + var SwiftProtoTesting_Names_https: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTPS) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTPS, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_HTTPS` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_HTTPS` /// has been explicitly set. - var hasSwiftUnittest_Names_https: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTPS) + var hasSwiftProtoTesting_Names_https: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTPS) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_HTTPS`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_HTTPS`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_https() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTPS) + mutating func clearSwiftProtoTesting_Names_https() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTPS) } - var SwiftUnittest_Names_httpsRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTPS_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTPS_request, value: newValue)} + var SwiftProtoTesting_Names_httpsRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTPS_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTPS_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_HTTPS_request` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_HTTPS_request` /// has been explicitly set. - var hasSwiftUnittest_Names_httpsRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTPS_request) + var hasSwiftProtoTesting_Names_httpsRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTPS_request) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_HTTPS_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_HTTPS_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_httpsRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTPS_request) + mutating func clearSwiftProtoTesting_Names_httpsRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTPS_request) } - var SwiftUnittest_Names_theHTTPSRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTPS_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTPS_request, value: newValue)} + var SwiftProtoTesting_Names_theHTTPSRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTPS_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTPS_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_HTTPS_request` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_HTTPS_request` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTPSRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTPS_request) + var hasSwiftProtoTesting_Names_theHTTPSRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTPS_request) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_HTTPS_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_HTTPS_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTPSRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTPS_request) + mutating func clearSwiftProtoTesting_Names_theHTTPSRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTPS_request) } - var SwiftUnittest_Names_theHTTPS: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTPS) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTPS, value: newValue)} + var SwiftProtoTesting_Names_theHTTPS: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTPS) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTPS, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_HTTPS` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_HTTPS` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTPS: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTPS) + var hasSwiftProtoTesting_Names_theHTTPS: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTPS) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_HTTPS`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_HTTPS`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTPS() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTPS) + mutating func clearSwiftProtoTesting_Names_theHTTPS() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTPS) } - var SwiftUnittest_Names_url: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_URL) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_URL, value: newValue)} + var SwiftProtoTesting_Names_url: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_URL) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_URL, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_URL` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_URL` /// has been explicitly set. - var hasSwiftUnittest_Names_url: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_URL) + var hasSwiftProtoTesting_Names_url: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_URL) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_URL`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_URL`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_url() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_URL) + mutating func clearSwiftProtoTesting_Names_url() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_URL) } - var SwiftUnittest_Names_urlValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_URL_value) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_URL_value, value: newValue)} + var SwiftProtoTesting_Names_urlValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_URL_value) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_URL_value, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_URL_value` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_URL_value` /// has been explicitly set. - var hasSwiftUnittest_Names_urlValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_URL_value) + var hasSwiftProtoTesting_Names_urlValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_URL_value) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_URL_value`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_URL_value`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_urlValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_URL_value) + mutating func clearSwiftProtoTesting_Names_urlValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_URL_value) } - var SwiftUnittest_Names_theURLValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_URL_value) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_URL_value, value: newValue)} + var SwiftProtoTesting_Names_theURLValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_URL_value) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_URL_value, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_URL_value` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_URL_value` /// has been explicitly set. - var hasSwiftUnittest_Names_theURLValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_URL_value) + var hasSwiftProtoTesting_Names_theURLValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_URL_value) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_URL_value`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_URL_value`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theURLValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_URL_value) + mutating func clearSwiftProtoTesting_Names_theURLValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_URL_value) } - var SwiftUnittest_Names_theURL: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_URL) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_URL, value: newValue)} + var SwiftProtoTesting_Names_theURL: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_URL) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_URL, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_URL` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_URL` /// has been explicitly set. - var hasSwiftUnittest_Names_theURL: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_URL) + var hasSwiftProtoTesting_Names_theURL: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_URL) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_URL`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_URL`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theURL() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_URL) + mutating func clearSwiftProtoTesting_Names_theURL() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_URL) } - var SwiftUnittest_Names_id: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_ID) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_ID, value: newValue)} + var SwiftProtoTesting_Names_id: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_ID) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_ID, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_ID` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_ID` /// has been explicitly set. - var hasSwiftUnittest_Names_id: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_ID) + var hasSwiftProtoTesting_Names_id: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_ID) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_ID`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_ID`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_id() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_ID) + mutating func clearSwiftProtoTesting_Names_id() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_ID) } - var SwiftUnittest_Names_idNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_ID_number) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_ID_number, value: newValue)} + var SwiftProtoTesting_Names_idNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_ID_number) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_ID_number, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_ID_number` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_ID_number` /// has been explicitly set. - var hasSwiftUnittest_Names_idNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_ID_number) + var hasSwiftProtoTesting_Names_idNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_ID_number) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_ID_number`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_ID_number`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_idNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_ID_number) + mutating func clearSwiftProtoTesting_Names_idNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_ID_number) } - var SwiftUnittest_Names_theIDNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_ID_number) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_ID_number, value: newValue)} + var SwiftProtoTesting_Names_theIDNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_ID_number) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_ID_number, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_ID_number` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_ID_number` /// has been explicitly set. - var hasSwiftUnittest_Names_theIDNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_ID_number) + var hasSwiftProtoTesting_Names_theIDNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_ID_number) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_ID_number`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_ID_number`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theIDNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_ID_number) + mutating func clearSwiftProtoTesting_Names_theIDNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_ID_number) } - var SwiftUnittest_Names_requestID: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_request_ID) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_request_ID, value: newValue)} + var SwiftProtoTesting_Names_requestID: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_request_ID) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_request_ID, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_request_ID` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_request_ID` /// has been explicitly set. - var hasSwiftUnittest_Names_requestID: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_request_ID) + var hasSwiftProtoTesting_Names_requestID: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_request_ID) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_request_ID`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_request_ID`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_requestID() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_request_ID) + mutating func clearSwiftProtoTesting_Names_requestID() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_request_ID) } } -extension SwiftUnittest_Names_ExtensionNamingInitialsWordCase { +extension SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase { - var SwiftUnittest_Names_http: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_Http) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_Http, value: newValue)} + var SwiftProtoTesting_Names_http: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Http) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Http, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_Http` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_Http` /// has been explicitly set. - var hasSwiftUnittest_Names_http: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_Http) + var hasSwiftProtoTesting_Names_http: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Http) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_Http`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_Http`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_http() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_Http) + mutating func clearSwiftProtoTesting_Names_http() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Http) } - var SwiftUnittest_Names_httpRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_HttpRequest) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_HttpRequest, value: newValue)} + var SwiftProtoTesting_Names_httpRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HttpRequest) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HttpRequest, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_HttpRequest` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_HttpRequest` /// has been explicitly set. - var hasSwiftUnittest_Names_httpRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_HttpRequest) + var hasSwiftProtoTesting_Names_httpRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HttpRequest) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_HttpRequest`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_HttpRequest`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_httpRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_HttpRequest) + mutating func clearSwiftProtoTesting_Names_httpRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HttpRequest) } - var SwiftUnittest_Names_theHTTPRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttpRequest) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttpRequest, value: newValue)} + var SwiftProtoTesting_Names_theHTTPRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttpRequest) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttpRequest, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_TheHttpRequest` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_TheHttpRequest` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTPRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttpRequest) + var hasSwiftProtoTesting_Names_theHTTPRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttpRequest) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_TheHttpRequest`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_TheHttpRequest`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTPRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttpRequest) + mutating func clearSwiftProtoTesting_Names_theHTTPRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttpRequest) } - var SwiftUnittest_Names_theHTTP: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttp) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttp, value: newValue)} + var SwiftProtoTesting_Names_theHTTP: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttp) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttp, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_TheHttp` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_TheHttp` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTP: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttp) + var hasSwiftProtoTesting_Names_theHTTP: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttp) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_TheHttp`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_TheHttp`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTP() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttp) + mutating func clearSwiftProtoTesting_Names_theHTTP() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttp) } - var SwiftUnittest_Names_https: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_Https) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_Https, value: newValue)} + var SwiftProtoTesting_Names_https: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Https) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Https, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_Https` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_Https` /// has been explicitly set. - var hasSwiftUnittest_Names_https: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_Https) + var hasSwiftProtoTesting_Names_https: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Https) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_Https`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_Https`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_https() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_Https) + mutating func clearSwiftProtoTesting_Names_https() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Https) } - var SwiftUnittest_Names_httpsRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_HttpsRequest) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_HttpsRequest, value: newValue)} + var SwiftProtoTesting_Names_httpsRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HttpsRequest) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HttpsRequest, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_HttpsRequest` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_HttpsRequest` /// has been explicitly set. - var hasSwiftUnittest_Names_httpsRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_HttpsRequest) + var hasSwiftProtoTesting_Names_httpsRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HttpsRequest) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_HttpsRequest`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_HttpsRequest`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_httpsRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_HttpsRequest) + mutating func clearSwiftProtoTesting_Names_httpsRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HttpsRequest) } - var SwiftUnittest_Names_theHTTPSRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttpsRequest) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttpsRequest, value: newValue)} + var SwiftProtoTesting_Names_theHTTPSRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttpsRequest) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttpsRequest, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_TheHttpsRequest` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_TheHttpsRequest` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTPSRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttpsRequest) + var hasSwiftProtoTesting_Names_theHTTPSRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttpsRequest) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_TheHttpsRequest`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_TheHttpsRequest`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTPSRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttpsRequest) + mutating func clearSwiftProtoTesting_Names_theHTTPSRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttpsRequest) } - var SwiftUnittest_Names_theHTTPS: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttps) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttps, value: newValue)} + var SwiftProtoTesting_Names_theHTTPS: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttps) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttps, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_TheHttps` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_TheHttps` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTPS: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttps) + var hasSwiftProtoTesting_Names_theHTTPS: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttps) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_TheHttps`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_TheHttps`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTPS() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttps) + mutating func clearSwiftProtoTesting_Names_theHTTPS() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttps) } - var SwiftUnittest_Names_url: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_Url) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_Url, value: newValue)} + var SwiftProtoTesting_Names_url: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Url) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Url, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_Url` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_Url` /// has been explicitly set. - var hasSwiftUnittest_Names_url: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_Url) + var hasSwiftProtoTesting_Names_url: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Url) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_Url`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_Url`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_url() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_Url) + mutating func clearSwiftProtoTesting_Names_url() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Url) } - var SwiftUnittest_Names_urlValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_UrlValue) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_UrlValue, value: newValue)} + var SwiftProtoTesting_Names_urlValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_UrlValue) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_UrlValue, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_UrlValue` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_UrlValue` /// has been explicitly set. - var hasSwiftUnittest_Names_urlValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_UrlValue) + var hasSwiftProtoTesting_Names_urlValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_UrlValue) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_UrlValue`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_UrlValue`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_urlValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_UrlValue) + mutating func clearSwiftProtoTesting_Names_urlValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_UrlValue) } - var SwiftUnittest_Names_theURLValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_TheUrlValue) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_TheUrlValue, value: newValue)} + var SwiftProtoTesting_Names_theURLValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheUrlValue) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheUrlValue, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_TheUrlValue` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_TheUrlValue` /// has been explicitly set. - var hasSwiftUnittest_Names_theURLValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_TheUrlValue) + var hasSwiftProtoTesting_Names_theURLValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheUrlValue) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_TheUrlValue`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_TheUrlValue`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theURLValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_TheUrlValue) + mutating func clearSwiftProtoTesting_Names_theURLValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheUrlValue) } - var SwiftUnittest_Names_theURL: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_TheUrl) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_TheUrl, value: newValue)} + var SwiftProtoTesting_Names_theURL: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheUrl) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheUrl, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_TheUrl` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_TheUrl` /// has been explicitly set. - var hasSwiftUnittest_Names_theURL: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_TheUrl) + var hasSwiftProtoTesting_Names_theURL: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheUrl) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_TheUrl`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_TheUrl`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theURL() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_TheUrl) + mutating func clearSwiftProtoTesting_Names_theURL() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheUrl) } - var SwiftUnittest_Names_id: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_Id) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_Id, value: newValue)} + var SwiftProtoTesting_Names_id: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Id) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Id, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_Id` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_Id` /// has been explicitly set. - var hasSwiftUnittest_Names_id: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_Id) + var hasSwiftProtoTesting_Names_id: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Id) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_Id`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_Id`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_id() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_Id) + mutating func clearSwiftProtoTesting_Names_id() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Id) } - var SwiftUnittest_Names_idNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_IdNumber) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_IdNumber, value: newValue)} + var SwiftProtoTesting_Names_idNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_IdNumber) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_IdNumber, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_IdNumber` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_IdNumber` /// has been explicitly set. - var hasSwiftUnittest_Names_idNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_IdNumber) + var hasSwiftProtoTesting_Names_idNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_IdNumber) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_IdNumber`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_IdNumber`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_idNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_IdNumber) + mutating func clearSwiftProtoTesting_Names_idNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_IdNumber) } - var SwiftUnittest_Names_theIDNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_TheIdNumber) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_TheIdNumber, value: newValue)} + var SwiftProtoTesting_Names_theIDNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheIdNumber) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheIdNumber, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_TheIdNumber` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_TheIdNumber` /// has been explicitly set. - var hasSwiftUnittest_Names_theIDNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_TheIdNumber) + var hasSwiftProtoTesting_Names_theIDNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheIdNumber) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_TheIdNumber`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_TheIdNumber`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theIDNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_TheIdNumber) + mutating func clearSwiftProtoTesting_Names_theIDNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheIdNumber) } - var SwiftUnittest_Names_requestID: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_RequestId) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_RequestId, value: newValue)} + var SwiftProtoTesting_Names_requestID: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_RequestId) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_RequestId, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_RequestId` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_RequestId` /// has been explicitly set. - var hasSwiftUnittest_Names_requestID: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_RequestId) + var hasSwiftProtoTesting_Names_requestID: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_RequestId) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_RequestId`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_RequestId`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_requestID() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_RequestId) + mutating func clearSwiftProtoTesting_Names_requestID() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_RequestId) } } -extension SwiftUnittest_Names_Foo { +extension SwiftProtoTesting_Names_Foo { - var SwiftUnittest_Names_FieldNames_foo1: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_FieldNames.Extensions.foo1) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_FieldNames.Extensions.foo1, value: newValue)} + var SwiftProtoTesting_Names_FieldNames_foo1: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_FieldNames.Extensions.foo1) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_FieldNames.Extensions.foo1, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_FieldNames.Extensions.foo1` + /// Returns true if extension `SwiftProtoTesting_Names_FieldNames.Extensions.foo1` /// has been explicitly set. - var hasSwiftUnittest_Names_FieldNames_foo1: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_FieldNames.Extensions.foo1) + var hasSwiftProtoTesting_Names_FieldNames_foo1: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_FieldNames.Extensions.foo1) } - /// Clears the value of extension `SwiftUnittest_Names_FieldNames.Extensions.foo1`. + /// Clears the value of extension `SwiftProtoTesting_Names_FieldNames.Extensions.foo1`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_FieldNames_foo1() { - clearExtensionValue(ext: SwiftUnittest_Names_FieldNames.Extensions.foo1) + mutating func clearSwiftProtoTesting_Names_FieldNames_foo1() { + clearExtensionValue(ext: SwiftProtoTesting_Names_FieldNames.Extensions.foo1) } - var SwiftUnittest_Names_MessageNames_foo2: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_MessageNames.Extensions.foo2) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_MessageNames.Extensions.foo2, value: newValue)} + var SwiftProtoTesting_Names_MessageNames_foo2: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.Extensions.foo2) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.Extensions.foo2, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_MessageNames.Extensions.foo2` + /// Returns true if extension `SwiftProtoTesting_Names_MessageNames.Extensions.foo2` /// has been explicitly set. - var hasSwiftUnittest_Names_MessageNames_foo2: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_MessageNames.Extensions.foo2) + var hasSwiftProtoTesting_Names_MessageNames_foo2: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.Extensions.foo2) } - /// Clears the value of extension `SwiftUnittest_Names_MessageNames.Extensions.foo2`. + /// Clears the value of extension `SwiftProtoTesting_Names_MessageNames.Extensions.foo2`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_MessageNames_foo2() { - clearExtensionValue(ext: SwiftUnittest_Names_MessageNames.Extensions.foo2) + mutating func clearSwiftProtoTesting_Names_MessageNames_foo2() { + clearExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.Extensions.foo2) } - var SwiftUnittest_Names_MessageNames_foo4: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_MessageNames.Extensions.foo4) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_MessageNames.Extensions.foo4, value: newValue)} + var SwiftProtoTesting_Names_MessageNames_foo4: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.Extensions.foo4) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.Extensions.foo4, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_MessageNames.Extensions.foo4` + /// Returns true if extension `SwiftProtoTesting_Names_MessageNames.Extensions.foo4` /// has been explicitly set. - var hasSwiftUnittest_Names_MessageNames_foo4: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_MessageNames.Extensions.foo4) + var hasSwiftProtoTesting_Names_MessageNames_foo4: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.Extensions.foo4) } - /// Clears the value of extension `SwiftUnittest_Names_MessageNames.Extensions.foo4`. + /// Clears the value of extension `SwiftProtoTesting_Names_MessageNames.Extensions.foo4`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_MessageNames_foo4() { - clearExtensionValue(ext: SwiftUnittest_Names_MessageNames.Extensions.foo4) + mutating func clearSwiftProtoTesting_Names_MessageNames_foo4() { + clearExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.Extensions.foo4) } - var SwiftUnittest_Names_MessageNames_StringMessage_foo3: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_MessageNames.StringMessage.Extensions.foo3) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_MessageNames.StringMessage.Extensions.foo3, value: newValue)} + var SwiftProtoTesting_Names_MessageNames_StringMessage_foo3: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.StringMessage.Extensions.foo3) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.StringMessage.Extensions.foo3, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_MessageNames.StringMessage.Extensions.foo3` + /// Returns true if extension `SwiftProtoTesting_Names_MessageNames.StringMessage.Extensions.foo3` /// has been explicitly set. - var hasSwiftUnittest_Names_MessageNames_StringMessage_foo3: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_MessageNames.StringMessage.Extensions.foo3) + var hasSwiftProtoTesting_Names_MessageNames_StringMessage_foo3: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.StringMessage.Extensions.foo3) } - /// Clears the value of extension `SwiftUnittest_Names_MessageNames.StringMessage.Extensions.foo3`. + /// Clears the value of extension `SwiftProtoTesting_Names_MessageNames.StringMessage.Extensions.foo3`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_MessageNames_StringMessage_foo3() { - clearExtensionValue(ext: SwiftUnittest_Names_MessageNames.StringMessage.Extensions.foo3) + mutating func clearSwiftProtoTesting_Names_MessageNames_StringMessage_foo3() { + clearExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.StringMessage.Extensions.foo3) } } -// MARK: - File's ExtensionMap: SwiftUnittest_Names_UnittestSwiftNaming_Extensions +// MARK: - File's ExtensionMap: SwiftProtoTesting_Names_UnittestSwiftNaming_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 SwiftUnittest_Names_UnittestSwiftNaming_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - SwiftUnittest_Names_Extensions_http, - SwiftUnittest_Names_Extensions_http_request, - SwiftUnittest_Names_Extensions_the_http_request, - SwiftUnittest_Names_Extensions_the_http, - SwiftUnittest_Names_Extensions_https, - SwiftUnittest_Names_Extensions_https_request, - SwiftUnittest_Names_Extensions_the_https_request, - SwiftUnittest_Names_Extensions_the_https, - SwiftUnittest_Names_Extensions_url, - SwiftUnittest_Names_Extensions_url_value, - SwiftUnittest_Names_Extensions_the_url_value, - SwiftUnittest_Names_Extensions_the_url, - SwiftUnittest_Names_Extensions_a_b_c, - SwiftUnittest_Names_Extensions_id, - SwiftUnittest_Names_Extensions_id_number, - SwiftUnittest_Names_Extensions_the_id_number, - SwiftUnittest_Names_Extensions_request_id, - SwiftUnittest_Names_Extensions_HTTP, - SwiftUnittest_Names_Extensions_HTTP_request, - SwiftUnittest_Names_Extensions_the_HTTP_request, - SwiftUnittest_Names_Extensions_the_HTTP, - SwiftUnittest_Names_Extensions_HTTPS, - SwiftUnittest_Names_Extensions_HTTPS_request, - SwiftUnittest_Names_Extensions_the_HTTPS_request, - SwiftUnittest_Names_Extensions_the_HTTPS, - SwiftUnittest_Names_Extensions_URL, - SwiftUnittest_Names_Extensions_URL_value, - SwiftUnittest_Names_Extensions_the_URL_value, - SwiftUnittest_Names_Extensions_the_URL, - SwiftUnittest_Names_Extensions_ID, - SwiftUnittest_Names_Extensions_ID_number, - SwiftUnittest_Names_Extensions_the_ID_number, - SwiftUnittest_Names_Extensions_request_ID, - SwiftUnittest_Names_Extensions_Http, - SwiftUnittest_Names_Extensions_HttpRequest, - SwiftUnittest_Names_Extensions_TheHttpRequest, - SwiftUnittest_Names_Extensions_TheHttp, - SwiftUnittest_Names_Extensions_Https, - SwiftUnittest_Names_Extensions_HttpsRequest, - SwiftUnittest_Names_Extensions_TheHttpsRequest, - SwiftUnittest_Names_Extensions_TheHttps, - SwiftUnittest_Names_Extensions_Url, - SwiftUnittest_Names_Extensions_UrlValue, - SwiftUnittest_Names_Extensions_TheUrlValue, - SwiftUnittest_Names_Extensions_TheUrl, - SwiftUnittest_Names_Extensions_Id, - SwiftUnittest_Names_Extensions_IdNumber, - SwiftUnittest_Names_Extensions_TheIdNumber, - SwiftUnittest_Names_Extensions_RequestId, - SwiftUnittest_Names_FieldNames.Extensions.foo1, - SwiftUnittest_Names_MessageNames.Extensions.foo2, - SwiftUnittest_Names_MessageNames.Extensions.foo4, - SwiftUnittest_Names_MessageNames.StringMessage.Extensions.foo3, - SwiftUnittest_Names_Lowers.Extensions.http, - SwiftUnittest_Names_Lowers.Extensions.http_request, - SwiftUnittest_Names_Lowers.Extensions.the_http_request, - SwiftUnittest_Names_Lowers.Extensions.the_http, - SwiftUnittest_Names_Lowers.Extensions.https, - SwiftUnittest_Names_Lowers.Extensions.https_request, - SwiftUnittest_Names_Lowers.Extensions.the_https_request, - SwiftUnittest_Names_Lowers.Extensions.the_https, - SwiftUnittest_Names_Lowers.Extensions.url, - SwiftUnittest_Names_Lowers.Extensions.url_value, - SwiftUnittest_Names_Lowers.Extensions.the_url_value, - SwiftUnittest_Names_Lowers.Extensions.the_url, - SwiftUnittest_Names_Lowers.Extensions.a_b_c, - SwiftUnittest_Names_Lowers.Extensions.id, - SwiftUnittest_Names_Lowers.Extensions.id_number, - SwiftUnittest_Names_Lowers.Extensions.the_id_number, - SwiftUnittest_Names_Lowers.Extensions.request_id, - SwiftUnittest_Names_Uppers.Extensions.HTTP, - SwiftUnittest_Names_Uppers.Extensions.HTTP_request, - SwiftUnittest_Names_Uppers.Extensions.the_HTTP_request, - SwiftUnittest_Names_Uppers.Extensions.the_HTTP, - SwiftUnittest_Names_Uppers.Extensions.HTTPS, - SwiftUnittest_Names_Uppers.Extensions.HTTPS_request, - SwiftUnittest_Names_Uppers.Extensions.the_HTTPS_request, - SwiftUnittest_Names_Uppers.Extensions.the_HTTPS, - SwiftUnittest_Names_Uppers.Extensions.URL, - SwiftUnittest_Names_Uppers.Extensions.URL_value, - SwiftUnittest_Names_Uppers.Extensions.the_URL_value, - SwiftUnittest_Names_Uppers.Extensions.the_URL, - SwiftUnittest_Names_Uppers.Extensions.ID, - SwiftUnittest_Names_Uppers.Extensions.ID_number, - SwiftUnittest_Names_Uppers.Extensions.the_ID_number, - SwiftUnittest_Names_Uppers.Extensions.request_ID, - SwiftUnittest_Names_WordCase.Extensions.Http, - SwiftUnittest_Names_WordCase.Extensions.HttpRequest, - SwiftUnittest_Names_WordCase.Extensions.TheHttpRequest, - SwiftUnittest_Names_WordCase.Extensions.TheHttp, - SwiftUnittest_Names_WordCase.Extensions.Https, - SwiftUnittest_Names_WordCase.Extensions.HttpsRequest, - SwiftUnittest_Names_WordCase.Extensions.TheHttpsRequest, - SwiftUnittest_Names_WordCase.Extensions.TheHttps, - SwiftUnittest_Names_WordCase.Extensions.Url, - SwiftUnittest_Names_WordCase.Extensions.UrlValue, - SwiftUnittest_Names_WordCase.Extensions.TheUrlValue, - SwiftUnittest_Names_WordCase.Extensions.TheUrl, - SwiftUnittest_Names_WordCase.Extensions.Id, - SwiftUnittest_Names_WordCase.Extensions.IdNumber, - SwiftUnittest_Names_WordCase.Extensions.TheIdNumber, - SwiftUnittest_Names_WordCase.Extensions.RequestId +let SwiftProtoTesting_Names_UnittestSwiftNaming_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Names_Extensions_http, + SwiftProtoTesting_Names_Extensions_http_request, + SwiftProtoTesting_Names_Extensions_the_http_request, + SwiftProtoTesting_Names_Extensions_the_http, + SwiftProtoTesting_Names_Extensions_https, + SwiftProtoTesting_Names_Extensions_https_request, + SwiftProtoTesting_Names_Extensions_the_https_request, + SwiftProtoTesting_Names_Extensions_the_https, + SwiftProtoTesting_Names_Extensions_url, + SwiftProtoTesting_Names_Extensions_url_value, + SwiftProtoTesting_Names_Extensions_the_url_value, + SwiftProtoTesting_Names_Extensions_the_url, + SwiftProtoTesting_Names_Extensions_a_b_c, + SwiftProtoTesting_Names_Extensions_id, + SwiftProtoTesting_Names_Extensions_id_number, + SwiftProtoTesting_Names_Extensions_the_id_number, + SwiftProtoTesting_Names_Extensions_request_id, + SwiftProtoTesting_Names_Extensions_HTTP, + SwiftProtoTesting_Names_Extensions_HTTP_request, + SwiftProtoTesting_Names_Extensions_the_HTTP_request, + SwiftProtoTesting_Names_Extensions_the_HTTP, + SwiftProtoTesting_Names_Extensions_HTTPS, + SwiftProtoTesting_Names_Extensions_HTTPS_request, + SwiftProtoTesting_Names_Extensions_the_HTTPS_request, + SwiftProtoTesting_Names_Extensions_the_HTTPS, + SwiftProtoTesting_Names_Extensions_URL, + SwiftProtoTesting_Names_Extensions_URL_value, + SwiftProtoTesting_Names_Extensions_the_URL_value, + SwiftProtoTesting_Names_Extensions_the_URL, + SwiftProtoTesting_Names_Extensions_ID, + SwiftProtoTesting_Names_Extensions_ID_number, + SwiftProtoTesting_Names_Extensions_the_ID_number, + SwiftProtoTesting_Names_Extensions_request_ID, + SwiftProtoTesting_Names_Extensions_Http, + SwiftProtoTesting_Names_Extensions_HttpRequest, + SwiftProtoTesting_Names_Extensions_TheHttpRequest, + SwiftProtoTesting_Names_Extensions_TheHttp, + SwiftProtoTesting_Names_Extensions_Https, + SwiftProtoTesting_Names_Extensions_HttpsRequest, + SwiftProtoTesting_Names_Extensions_TheHttpsRequest, + SwiftProtoTesting_Names_Extensions_TheHttps, + SwiftProtoTesting_Names_Extensions_Url, + SwiftProtoTesting_Names_Extensions_UrlValue, + SwiftProtoTesting_Names_Extensions_TheUrlValue, + SwiftProtoTesting_Names_Extensions_TheUrl, + SwiftProtoTesting_Names_Extensions_Id, + SwiftProtoTesting_Names_Extensions_IdNumber, + SwiftProtoTesting_Names_Extensions_TheIdNumber, + SwiftProtoTesting_Names_Extensions_RequestId, + SwiftProtoTesting_Names_FieldNames.Extensions.foo1, + SwiftProtoTesting_Names_MessageNames.Extensions.foo2, + SwiftProtoTesting_Names_MessageNames.Extensions.foo4, + SwiftProtoTesting_Names_MessageNames.StringMessage.Extensions.foo3, + SwiftProtoTesting_Names_Lowers.Extensions.http, + SwiftProtoTesting_Names_Lowers.Extensions.http_request, + SwiftProtoTesting_Names_Lowers.Extensions.the_http_request, + SwiftProtoTesting_Names_Lowers.Extensions.the_http, + SwiftProtoTesting_Names_Lowers.Extensions.https, + SwiftProtoTesting_Names_Lowers.Extensions.https_request, + SwiftProtoTesting_Names_Lowers.Extensions.the_https_request, + SwiftProtoTesting_Names_Lowers.Extensions.the_https, + SwiftProtoTesting_Names_Lowers.Extensions.url, + SwiftProtoTesting_Names_Lowers.Extensions.url_value, + SwiftProtoTesting_Names_Lowers.Extensions.the_url_value, + SwiftProtoTesting_Names_Lowers.Extensions.the_url, + SwiftProtoTesting_Names_Lowers.Extensions.a_b_c, + SwiftProtoTesting_Names_Lowers.Extensions.id, + SwiftProtoTesting_Names_Lowers.Extensions.id_number, + SwiftProtoTesting_Names_Lowers.Extensions.the_id_number, + SwiftProtoTesting_Names_Lowers.Extensions.request_id, + SwiftProtoTesting_Names_Uppers.Extensions.HTTP, + SwiftProtoTesting_Names_Uppers.Extensions.HTTP_request, + SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP_request, + SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP, + SwiftProtoTesting_Names_Uppers.Extensions.HTTPS, + SwiftProtoTesting_Names_Uppers.Extensions.HTTPS_request, + SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS_request, + SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS, + SwiftProtoTesting_Names_Uppers.Extensions.URL, + SwiftProtoTesting_Names_Uppers.Extensions.URL_value, + SwiftProtoTesting_Names_Uppers.Extensions.the_URL_value, + SwiftProtoTesting_Names_Uppers.Extensions.the_URL, + SwiftProtoTesting_Names_Uppers.Extensions.ID, + SwiftProtoTesting_Names_Uppers.Extensions.ID_number, + SwiftProtoTesting_Names_Uppers.Extensions.the_ID_number, + SwiftProtoTesting_Names_Uppers.Extensions.request_ID, + SwiftProtoTesting_Names_WordCase.Extensions.Http, + SwiftProtoTesting_Names_WordCase.Extensions.HttpRequest, + SwiftProtoTesting_Names_WordCase.Extensions.TheHttpRequest, + SwiftProtoTesting_Names_WordCase.Extensions.TheHttp, + SwiftProtoTesting_Names_WordCase.Extensions.Https, + SwiftProtoTesting_Names_WordCase.Extensions.HttpsRequest, + SwiftProtoTesting_Names_WordCase.Extensions.TheHttpsRequest, + SwiftProtoTesting_Names_WordCase.Extensions.TheHttps, + SwiftProtoTesting_Names_WordCase.Extensions.Url, + SwiftProtoTesting_Names_WordCase.Extensions.UrlValue, + SwiftProtoTesting_Names_WordCase.Extensions.TheUrlValue, + SwiftProtoTesting_Names_WordCase.Extensions.TheUrl, + SwiftProtoTesting_Names_WordCase.Extensions.Id, + SwiftProtoTesting_Names_WordCase.Extensions.IdNumber, + SwiftProtoTesting_Names_WordCase.Extensions.TheIdNumber, + SwiftProtoTesting_Names_WordCase.Extensions.RequestId ] // 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 SwiftUnittest_Names_Extensions_http = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_http = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 1, - fieldName: "swift_unittest.names.http" + fieldName: "swift_proto_testing.names.http" ) -let SwiftUnittest_Names_Extensions_http_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_http_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 2, - fieldName: "swift_unittest.names.http_request" + fieldName: "swift_proto_testing.names.http_request" ) -let SwiftUnittest_Names_Extensions_the_http_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_the_http_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 3, - fieldName: "swift_unittest.names.the_http_request" + fieldName: "swift_proto_testing.names.the_http_request" ) -let SwiftUnittest_Names_Extensions_the_http = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_the_http = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 4, - fieldName: "swift_unittest.names.the_http" + fieldName: "swift_proto_testing.names.the_http" ) -let SwiftUnittest_Names_Extensions_https = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_https = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 11, - fieldName: "swift_unittest.names.https" + fieldName: "swift_proto_testing.names.https" ) -let SwiftUnittest_Names_Extensions_https_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_https_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 12, - fieldName: "swift_unittest.names.https_request" + fieldName: "swift_proto_testing.names.https_request" ) -let SwiftUnittest_Names_Extensions_the_https_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_the_https_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 13, - fieldName: "swift_unittest.names.the_https_request" + fieldName: "swift_proto_testing.names.the_https_request" ) -let SwiftUnittest_Names_Extensions_the_https = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_the_https = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 14, - fieldName: "swift_unittest.names.the_https" + fieldName: "swift_proto_testing.names.the_https" ) -let SwiftUnittest_Names_Extensions_url = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_url = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 21, - fieldName: "swift_unittest.names.url" + fieldName: "swift_proto_testing.names.url" ) -let SwiftUnittest_Names_Extensions_url_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_url_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 22, - fieldName: "swift_unittest.names.url_value" + fieldName: "swift_proto_testing.names.url_value" ) -let SwiftUnittest_Names_Extensions_the_url_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_the_url_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 23, - fieldName: "swift_unittest.names.the_url_value" + fieldName: "swift_proto_testing.names.the_url_value" ) -let SwiftUnittest_Names_Extensions_the_url = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_the_url = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 24, - fieldName: "swift_unittest.names.the_url" + fieldName: "swift_proto_testing.names.the_url" ) -let SwiftUnittest_Names_Extensions_a_b_c = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_a_b_c = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 31, - fieldName: "swift_unittest.names.a_b_c" + fieldName: "swift_proto_testing.names.a_b_c" ) -let SwiftUnittest_Names_Extensions_id = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_id = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 41, - fieldName: "swift_unittest.names.id" + fieldName: "swift_proto_testing.names.id" ) -let SwiftUnittest_Names_Extensions_id_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_id_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 42, - fieldName: "swift_unittest.names.id_number" + fieldName: "swift_proto_testing.names.id_number" ) -let SwiftUnittest_Names_Extensions_the_id_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_the_id_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 43, - fieldName: "swift_unittest.names.the_id_number" + fieldName: "swift_proto_testing.names.the_id_number" ) -let SwiftUnittest_Names_Extensions_request_id = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_request_id = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 44, - fieldName: "swift_unittest.names.request_id" + fieldName: "swift_proto_testing.names.request_id" ) -let SwiftUnittest_Names_Extensions_HTTP = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_HTTP = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 1, - fieldName: "swift_unittest.names.HTTP" + fieldName: "swift_proto_testing.names.HTTP" ) -let SwiftUnittest_Names_Extensions_HTTP_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_HTTP_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 2, - fieldName: "swift_unittest.names.HTTP_request" + fieldName: "swift_proto_testing.names.HTTP_request" ) -let SwiftUnittest_Names_Extensions_the_HTTP_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_the_HTTP_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 3, - fieldName: "swift_unittest.names.the_HTTP_request" + fieldName: "swift_proto_testing.names.the_HTTP_request" ) -let SwiftUnittest_Names_Extensions_the_HTTP = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_the_HTTP = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 4, - fieldName: "swift_unittest.names.the_HTTP" + fieldName: "swift_proto_testing.names.the_HTTP" ) -let SwiftUnittest_Names_Extensions_HTTPS = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_HTTPS = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 11, - fieldName: "swift_unittest.names.HTTPS" + fieldName: "swift_proto_testing.names.HTTPS" ) -let SwiftUnittest_Names_Extensions_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 12, - fieldName: "swift_unittest.names.HTTPS_request" + fieldName: "swift_proto_testing.names.HTTPS_request" ) -let SwiftUnittest_Names_Extensions_the_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_the_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 13, - fieldName: "swift_unittest.names.the_HTTPS_request" + fieldName: "swift_proto_testing.names.the_HTTPS_request" ) -let SwiftUnittest_Names_Extensions_the_HTTPS = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_the_HTTPS = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 14, - fieldName: "swift_unittest.names.the_HTTPS" + fieldName: "swift_proto_testing.names.the_HTTPS" ) -let SwiftUnittest_Names_Extensions_URL = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_URL = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 21, - fieldName: "swift_unittest.names.URL" + fieldName: "swift_proto_testing.names.URL" ) -let SwiftUnittest_Names_Extensions_URL_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_URL_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 22, - fieldName: "swift_unittest.names.URL_value" + fieldName: "swift_proto_testing.names.URL_value" ) -let SwiftUnittest_Names_Extensions_the_URL_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_the_URL_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 23, - fieldName: "swift_unittest.names.the_URL_value" + fieldName: "swift_proto_testing.names.the_URL_value" ) -let SwiftUnittest_Names_Extensions_the_URL = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_the_URL = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 24, - fieldName: "swift_unittest.names.the_URL" + fieldName: "swift_proto_testing.names.the_URL" ) -let SwiftUnittest_Names_Extensions_ID = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_ID = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 41, - fieldName: "swift_unittest.names.ID" + fieldName: "swift_proto_testing.names.ID" ) -let SwiftUnittest_Names_Extensions_ID_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_ID_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 42, - fieldName: "swift_unittest.names.ID_number" + fieldName: "swift_proto_testing.names.ID_number" ) -let SwiftUnittest_Names_Extensions_the_ID_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_the_ID_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 43, - fieldName: "swift_unittest.names.the_ID_number" + fieldName: "swift_proto_testing.names.the_ID_number" ) -let SwiftUnittest_Names_Extensions_request_ID = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_request_ID = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 44, - fieldName: "swift_unittest.names.request_ID" + fieldName: "swift_proto_testing.names.request_ID" ) -let SwiftUnittest_Names_Extensions_Http = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_Http = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 1, - fieldName: "swift_unittest.names.Http" + fieldName: "swift_proto_testing.names.Http" ) -let SwiftUnittest_Names_Extensions_HttpRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_HttpRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 2, - fieldName: "swift_unittest.names.HttpRequest" + fieldName: "swift_proto_testing.names.HttpRequest" ) -let SwiftUnittest_Names_Extensions_TheHttpRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_TheHttpRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 3, - fieldName: "swift_unittest.names.TheHttpRequest" + fieldName: "swift_proto_testing.names.TheHttpRequest" ) -let SwiftUnittest_Names_Extensions_TheHttp = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_TheHttp = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 4, - fieldName: "swift_unittest.names.TheHttp" + fieldName: "swift_proto_testing.names.TheHttp" ) -let SwiftUnittest_Names_Extensions_Https = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_Https = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 11, - fieldName: "swift_unittest.names.Https" + fieldName: "swift_proto_testing.names.Https" ) -let SwiftUnittest_Names_Extensions_HttpsRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_HttpsRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 12, - fieldName: "swift_unittest.names.HttpsRequest" + fieldName: "swift_proto_testing.names.HttpsRequest" ) -let SwiftUnittest_Names_Extensions_TheHttpsRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_TheHttpsRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 13, - fieldName: "swift_unittest.names.TheHttpsRequest" + fieldName: "swift_proto_testing.names.TheHttpsRequest" ) -let SwiftUnittest_Names_Extensions_TheHttps = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_TheHttps = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 14, - fieldName: "swift_unittest.names.TheHttps" + fieldName: "swift_proto_testing.names.TheHttps" ) -let SwiftUnittest_Names_Extensions_Url = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_Url = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 21, - fieldName: "swift_unittest.names.Url" + fieldName: "swift_proto_testing.names.Url" ) -let SwiftUnittest_Names_Extensions_UrlValue = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_UrlValue = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 22, - fieldName: "swift_unittest.names.UrlValue" + fieldName: "swift_proto_testing.names.UrlValue" ) -let SwiftUnittest_Names_Extensions_TheUrlValue = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_TheUrlValue = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 23, - fieldName: "swift_unittest.names.TheUrlValue" + fieldName: "swift_proto_testing.names.TheUrlValue" ) -let SwiftUnittest_Names_Extensions_TheUrl = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_TheUrl = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 24, - fieldName: "swift_unittest.names.TheUrl" + fieldName: "swift_proto_testing.names.TheUrl" ) -let SwiftUnittest_Names_Extensions_Id = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_Id = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 41, - fieldName: "swift_unittest.names.Id" + fieldName: "swift_proto_testing.names.Id" ) -let SwiftUnittest_Names_Extensions_IdNumber = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_IdNumber = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 42, - fieldName: "swift_unittest.names.IdNumber" + fieldName: "swift_proto_testing.names.IdNumber" ) -let SwiftUnittest_Names_Extensions_TheIdNumber = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_TheIdNumber = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 43, - fieldName: "swift_unittest.names.TheIdNumber" + fieldName: "swift_proto_testing.names.TheIdNumber" ) -let SwiftUnittest_Names_Extensions_RequestId = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_RequestId = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 44, - fieldName: "swift_unittest.names.RequestId" + fieldName: "swift_proto_testing.names.RequestId" ) -extension SwiftUnittest_Names_FieldNames { +extension SwiftProtoTesting_Names_FieldNames { enum Extensions { - static let foo1 = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_Foo>( + static let foo1 = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_Foo>( _protobuf_fieldNumber: 1, - fieldName: "swift_unittest.names.FieldNames.foo1" + fieldName: "swift_proto_testing.names.FieldNames.foo1" ) } } -extension SwiftUnittest_Names_MessageNames { +extension SwiftProtoTesting_Names_MessageNames { enum Extensions { - static let foo2 = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_Foo>( + static let foo2 = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_Foo>( _protobuf_fieldNumber: 2, - fieldName: "swift_unittest.names.MessageNames.foo2" + fieldName: "swift_proto_testing.names.MessageNames.foo2" ) - static let foo4 = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_Foo>( + static let foo4 = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_Foo>( _protobuf_fieldNumber: 4, - fieldName: "swift_unittest.names.MessageNames.foo4" + fieldName: "swift_proto_testing.names.MessageNames.foo4" ) } } -extension SwiftUnittest_Names_MessageNames.StringMessage { +extension SwiftProtoTesting_Names_MessageNames.StringMessage { enum Extensions { - static let foo3 = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_Foo>( + static let foo3 = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_Foo>( _protobuf_fieldNumber: 3, - fieldName: "swift_unittest.names.MessageNames.String.foo3" + fieldName: "swift_proto_testing.names.MessageNames.String.foo3" ) } } -extension SwiftUnittest_Names_Lowers { +extension SwiftProtoTesting_Names_Lowers { enum Extensions { - static let http = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let http = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 1, - fieldName: "swift_unittest.names.Lowers.http" + fieldName: "swift_proto_testing.names.Lowers.http" ) - static let http_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let http_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 2, - fieldName: "swift_unittest.names.Lowers.http_request" + fieldName: "swift_proto_testing.names.Lowers.http_request" ) - static let the_http_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_http_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 3, - fieldName: "swift_unittest.names.Lowers.the_http_request" + fieldName: "swift_proto_testing.names.Lowers.the_http_request" ) - static let the_http = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_http = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 4, - fieldName: "swift_unittest.names.Lowers.the_http" + fieldName: "swift_proto_testing.names.Lowers.the_http" ) - static let https = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let https = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 11, - fieldName: "swift_unittest.names.Lowers.https" + fieldName: "swift_proto_testing.names.Lowers.https" ) - static let https_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let https_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 12, - fieldName: "swift_unittest.names.Lowers.https_request" + fieldName: "swift_proto_testing.names.Lowers.https_request" ) - static let the_https_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_https_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 13, - fieldName: "swift_unittest.names.Lowers.the_https_request" + fieldName: "swift_proto_testing.names.Lowers.the_https_request" ) - static let the_https = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_https = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 14, - fieldName: "swift_unittest.names.Lowers.the_https" + fieldName: "swift_proto_testing.names.Lowers.the_https" ) - static let url = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let url = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 21, - fieldName: "swift_unittest.names.Lowers.url" + fieldName: "swift_proto_testing.names.Lowers.url" ) - static let url_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let url_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 22, - fieldName: "swift_unittest.names.Lowers.url_value" + fieldName: "swift_proto_testing.names.Lowers.url_value" ) - static let the_url_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_url_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 23, - fieldName: "swift_unittest.names.Lowers.the_url_value" + fieldName: "swift_proto_testing.names.Lowers.the_url_value" ) - static let the_url = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_url = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 24, - fieldName: "swift_unittest.names.Lowers.the_url" + fieldName: "swift_proto_testing.names.Lowers.the_url" ) - static let a_b_c = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let a_b_c = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 31, - fieldName: "swift_unittest.names.Lowers.a_b_c" + fieldName: "swift_proto_testing.names.Lowers.a_b_c" ) - static let id = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let id = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 41, - fieldName: "swift_unittest.names.Lowers.id" + fieldName: "swift_proto_testing.names.Lowers.id" ) - static let id_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let id_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 42, - fieldName: "swift_unittest.names.Lowers.id_number" + fieldName: "swift_proto_testing.names.Lowers.id_number" ) - static let the_id_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_id_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 43, - fieldName: "swift_unittest.names.Lowers.the_id_number" + fieldName: "swift_proto_testing.names.Lowers.the_id_number" ) - static let request_id = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let request_id = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 44, - fieldName: "swift_unittest.names.Lowers.request_id" + fieldName: "swift_proto_testing.names.Lowers.request_id" ) } } -extension SwiftUnittest_Names_Uppers { +extension SwiftProtoTesting_Names_Uppers { enum Extensions { - static let HTTP = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let HTTP = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 101, - fieldName: "swift_unittest.names.Uppers.HTTP" + fieldName: "swift_proto_testing.names.Uppers.HTTP" ) - static let HTTP_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let HTTP_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 102, - fieldName: "swift_unittest.names.Uppers.HTTP_request" + fieldName: "swift_proto_testing.names.Uppers.HTTP_request" ) - static let the_HTTP_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_HTTP_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 103, - fieldName: "swift_unittest.names.Uppers.the_HTTP_request" + fieldName: "swift_proto_testing.names.Uppers.the_HTTP_request" ) - static let the_HTTP = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_HTTP = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 104, - fieldName: "swift_unittest.names.Uppers.the_HTTP" + fieldName: "swift_proto_testing.names.Uppers.the_HTTP" ) - static let HTTPS = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let HTTPS = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 111, - fieldName: "swift_unittest.names.Uppers.HTTPS" + fieldName: "swift_proto_testing.names.Uppers.HTTPS" ) - static let HTTPS_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let HTTPS_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 112, - fieldName: "swift_unittest.names.Uppers.HTTPS_request" + fieldName: "swift_proto_testing.names.Uppers.HTTPS_request" ) - static let the_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 113, - fieldName: "swift_unittest.names.Uppers.the_HTTPS_request" + fieldName: "swift_proto_testing.names.Uppers.the_HTTPS_request" ) - static let the_HTTPS = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_HTTPS = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 114, - fieldName: "swift_unittest.names.Uppers.the_HTTPS" + fieldName: "swift_proto_testing.names.Uppers.the_HTTPS" ) - static let URL = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let URL = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 121, - fieldName: "swift_unittest.names.Uppers.URL" + fieldName: "swift_proto_testing.names.Uppers.URL" ) - static let URL_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let URL_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 122, - fieldName: "swift_unittest.names.Uppers.URL_value" + fieldName: "swift_proto_testing.names.Uppers.URL_value" ) - static let the_URL_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_URL_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 123, - fieldName: "swift_unittest.names.Uppers.the_URL_value" + fieldName: "swift_proto_testing.names.Uppers.the_URL_value" ) - static let the_URL = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_URL = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 124, - fieldName: "swift_unittest.names.Uppers.the_URL" + fieldName: "swift_proto_testing.names.Uppers.the_URL" ) - static let ID = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let ID = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 141, - fieldName: "swift_unittest.names.Uppers.ID" + fieldName: "swift_proto_testing.names.Uppers.ID" ) - static let ID_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let ID_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 142, - fieldName: "swift_unittest.names.Uppers.ID_number" + fieldName: "swift_proto_testing.names.Uppers.ID_number" ) - static let the_ID_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_ID_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 143, - fieldName: "swift_unittest.names.Uppers.the_ID_number" + fieldName: "swift_proto_testing.names.Uppers.the_ID_number" ) - static let request_ID = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let request_ID = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 144, - fieldName: "swift_unittest.names.Uppers.request_ID" + fieldName: "swift_proto_testing.names.Uppers.request_ID" ) } } -extension SwiftUnittest_Names_WordCase { +extension SwiftProtoTesting_Names_WordCase { enum Extensions { - static let Http = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let Http = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 201, - fieldName: "swift_unittest.names.WordCase.Http" + fieldName: "swift_proto_testing.names.WordCase.Http" ) - static let HttpRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let HttpRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 202, - fieldName: "swift_unittest.names.WordCase.HttpRequest" + fieldName: "swift_proto_testing.names.WordCase.HttpRequest" ) - static let TheHttpRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let TheHttpRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 203, - fieldName: "swift_unittest.names.WordCase.TheHttpRequest" + fieldName: "swift_proto_testing.names.WordCase.TheHttpRequest" ) - static let TheHttp = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let TheHttp = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 204, - fieldName: "swift_unittest.names.WordCase.TheHttp" + fieldName: "swift_proto_testing.names.WordCase.TheHttp" ) - static let Https = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let Https = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 211, - fieldName: "swift_unittest.names.WordCase.Https" + fieldName: "swift_proto_testing.names.WordCase.Https" ) - static let HttpsRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let HttpsRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 212, - fieldName: "swift_unittest.names.WordCase.HttpsRequest" + fieldName: "swift_proto_testing.names.WordCase.HttpsRequest" ) - static let TheHttpsRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let TheHttpsRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 213, - fieldName: "swift_unittest.names.WordCase.TheHttpsRequest" + fieldName: "swift_proto_testing.names.WordCase.TheHttpsRequest" ) - static let TheHttps = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let TheHttps = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 214, - fieldName: "swift_unittest.names.WordCase.TheHttps" + fieldName: "swift_proto_testing.names.WordCase.TheHttps" ) - static let Url = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let Url = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 221, - fieldName: "swift_unittest.names.WordCase.Url" + fieldName: "swift_proto_testing.names.WordCase.Url" ) - static let UrlValue = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let UrlValue = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 222, - fieldName: "swift_unittest.names.WordCase.UrlValue" + fieldName: "swift_proto_testing.names.WordCase.UrlValue" ) - static let TheUrlValue = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let TheUrlValue = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 223, - fieldName: "swift_unittest.names.WordCase.TheUrlValue" + fieldName: "swift_proto_testing.names.WordCase.TheUrlValue" ) - static let TheUrl = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let TheUrl = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 224, - fieldName: "swift_unittest.names.WordCase.TheUrl" + fieldName: "swift_proto_testing.names.WordCase.TheUrl" ) - static let Id = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let Id = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 241, - fieldName: "swift_unittest.names.WordCase.Id" + fieldName: "swift_proto_testing.names.WordCase.Id" ) - static let IdNumber = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let IdNumber = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 242, - fieldName: "swift_unittest.names.WordCase.IdNumber" + fieldName: "swift_proto_testing.names.WordCase.IdNumber" ) - static let TheIdNumber = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let TheIdNumber = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 243, - fieldName: "swift_unittest.names.WordCase.TheIdNumber" + fieldName: "swift_proto_testing.names.WordCase.TheIdNumber" ) - static let RequestId = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let RequestId = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 244, - fieldName: "swift_unittest.names.WordCase.RequestId" + fieldName: "swift_proto_testing.names.WordCase.RequestId" ) } } // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "swift_unittest.names" - -extension SwiftUnittest_Names_EnumFieldNames: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "A"), - 1: .same(proto: "String"), - 2: .same(proto: "Int"), - 3: .same(proto: "Double"), - 4: .same(proto: "Float"), - 5: .same(proto: "UInt"), - 6: .same(proto: "hashValue"), - 7: .same(proto: "description"), - 8: .same(proto: "debugDescription"), - 9: .same(proto: "Swift"), - 10: .same(proto: "UNRECOGNIZED"), - 11: .same(proto: "class"), - 12: .same(proto: "deinit"), - 13: .same(proto: "enum"), - 14: .same(proto: "extension"), - 15: .same(proto: "func"), - 16: .same(proto: "import"), - 17: .same(proto: "init"), - 18: .same(proto: "inout"), - 19: .same(proto: "internal"), - 20: .same(proto: "let"), - 21: .same(proto: "operator"), - 22: .same(proto: "private"), - 23: .same(proto: "protocol"), - 24: .same(proto: "public"), - 25: .same(proto: "static"), - 26: .same(proto: "struct"), - 27: .same(proto: "subscript"), - 28: .same(proto: "typealias"), - 29: .same(proto: "var"), - 30: .same(proto: "break"), - 31: .same(proto: "case"), - 32: .same(proto: "continue"), - 33: .same(proto: "default"), - 34: .same(proto: "defer"), - 35: .same(proto: "do"), - 36: .same(proto: "else"), - 37: .same(proto: "fallthrough"), - 38: .same(proto: "for"), - 39: .same(proto: "guard"), - 40: .same(proto: "if"), - 41: .same(proto: "in"), - 42: .same(proto: "repeat"), - 43: .same(proto: "return"), - 44: .same(proto: "switch"), - 45: .same(proto: "where"), - 46: .same(proto: "while"), - 47: .same(proto: "as"), - 48: .same(proto: "catch"), - 49: .same(proto: "dynamicType"), - 50: .same(proto: "false"), - 51: .same(proto: "is"), - 52: .same(proto: "nil"), - 53: .same(proto: "rethrows"), - 54: .same(proto: "super"), - 55: .same(proto: "self"), - 57: .same(proto: "throw"), - 58: .same(proto: "throws"), - 59: .same(proto: "true"), - 60: .same(proto: "try"), - 61: .same(proto: "__COLUMN__"), - 62: .same(proto: "__FILE__"), - 63: .same(proto: "__FUNCTION__"), - 64: .same(proto: "__LINE__"), - 65: .same(proto: "_"), - 66: .same(proto: "associativity"), - 67: .same(proto: "convenience"), - 68: .same(proto: "dynamic"), - 69: .same(proto: "didSet"), - 70: .same(proto: "final"), - 71: .same(proto: "get"), - 72: .same(proto: "infix"), - 73: .same(proto: "indirect"), - 74: .same(proto: "lazy"), - 75: .same(proto: "left"), - 76: .same(proto: "mutating"), - 77: .same(proto: "none"), - 78: .same(proto: "nonmutating"), - 79: .same(proto: "optional"), - 80: .same(proto: "override"), - 81: .same(proto: "postfix"), - 82: .same(proto: "precedence"), - 83: .same(proto: "prefix"), - 85: .same(proto: "required"), - 86: .same(proto: "right"), - 87: .same(proto: "set"), - 88: .same(proto: "Type"), - 89: .same(proto: "unowned"), - 90: .same(proto: "weak"), - 91: .same(proto: "willSet"), - 93: .same(proto: "_cmd"), - 96: .same(proto: "out"), - 98: .same(proto: "bycopy"), - 99: .same(proto: "byref"), - 100: .same(proto: "oneway"), - 102: .same(proto: "and"), - 103: .same(proto: "and_eq"), - 104: .same(proto: "alignas"), - 105: .same(proto: "alignof"), - 106: .same(proto: "asm"), - 107: .same(proto: "auto"), - 108: .same(proto: "bitand"), - 109: .same(proto: "bitor"), - 110: .same(proto: "bool"), - 114: .same(proto: "char"), - 115: .same(proto: "char16_t"), - 116: .same(proto: "char32_t"), - 118: .same(proto: "compl"), - 119: .same(proto: "const"), - 120: .same(proto: "constexpr"), - 121: .same(proto: "const_cast"), - 123: .same(proto: "decltype"), - 125: .same(proto: "delete"), - 127: .same(proto: "dynamic_cast"), - 130: .same(proto: "explicit"), - 131: .same(proto: "export"), - 132: .same(proto: "extern"), - 136: .same(proto: "friend"), - 137: .same(proto: "goto"), - 139: .same(proto: "inline"), - 141: .same(proto: "long"), - 142: .same(proto: "mutable"), - 143: .same(proto: "namespace"), - 144: .same(proto: "new"), - 145: .same(proto: "noexcept"), - 146: .same(proto: "not"), - 147: .same(proto: "not_eq"), - 148: .same(proto: "nullptr"), - 150: .same(proto: "or"), - 151: .same(proto: "or_eq"), - 153: .same(proto: "protected"), - 155: .same(proto: "register"), - 156: .same(proto: "reinterpret_cast"), - 158: .same(proto: "short"), - 159: .same(proto: "signed"), - 160: .same(proto: "sizeof"), - 162: .same(proto: "static_assert"), - 163: .same(proto: "static_cast"), - 166: .same(proto: "template"), - 167: .same(proto: "this"), - 168: .same(proto: "thread_local"), - 172: .same(proto: "typedef"), - 173: .same(proto: "typeid"), - 174: .same(proto: "typename"), - 175: .same(proto: "union"), - 176: .same(proto: "unsigned"), - 177: .same(proto: "using"), - 178: .same(proto: "virtual"), - 179: .same(proto: "void"), - 180: .same(proto: "volatile"), - 181: .same(proto: "wchar_t"), - 183: .same(proto: "xor"), - 184: .same(proto: "xor_eq"), - 185: .same(proto: "restrict"), - 186: .same(proto: "Category"), - 187: .same(proto: "Ivar"), - 188: .same(proto: "Method"), - 192: .same(proto: "finalize"), - 193: .same(proto: "hash"), - 194: .same(proto: "dealloc"), - 197: .same(proto: "superclass"), - 198: .same(proto: "retain"), - 199: .same(proto: "release"), - 200: .same(proto: "autorelease"), - 201: .same(proto: "retainCount"), - 202: .same(proto: "zone"), - 203: .same(proto: "isProxy"), - 204: .same(proto: "copy"), - 205: .same(proto: "mutableCopy"), - 206: .same(proto: "classForCoder"), - 207: .same(proto: "clear"), - 208: .same(proto: "data"), - 209: .same(proto: "delimitedData"), - 210: .same(proto: "descriptor"), - 211: .same(proto: "extensionRegistry"), - 212: .same(proto: "extensionsCurrentlySet"), - 213: .same(proto: "isInitialized"), - 214: .same(proto: "serializedSize"), - 215: .same(proto: "sortedExtensionsInUse"), - 216: .same(proto: "unknownFields"), - 217: .same(proto: "Fixed"), - 218: .same(proto: "Fract"), - 219: .same(proto: "Size"), - 220: .same(proto: "LogicalAddress"), - 221: .same(proto: "PhysicalAddress"), - 222: .same(proto: "ByteCount"), - 223: .same(proto: "ByteOffset"), - 224: .same(proto: "Duration"), - 225: .same(proto: "AbsoluteTime"), - 226: .same(proto: "OptionBits"), - 227: .same(proto: "ItemCount"), - 228: .same(proto: "PBVersion"), - 229: .same(proto: "ScriptCode"), - 230: .same(proto: "LangCode"), - 231: .same(proto: "RegionCode"), - 232: .same(proto: "OSType"), - 233: .same(proto: "ProcessSerialNumber"), - 234: .same(proto: "Point"), - 235: .same(proto: "Rect"), - 236: .same(proto: "FixedPoint"), - 237: .same(proto: "FixedRect"), - 238: .same(proto: "Style"), - 239: .same(proto: "StyleParameter"), - 240: .same(proto: "StyleField"), - 241: .same(proto: "TimeScale"), - 242: .same(proto: "TimeBase"), - 243: .same(proto: "TimeRecord"), - 244: .same(proto: "Extensions"), - ] -} - -extension SwiftUnittest_Names_EnumFieldNames2: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "AA"), - 1065: .same(proto: "__"), - ] -} - -extension SwiftUnittest_Names_Foo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +fileprivate let _protobuf_package = "swift_proto_testing.names" + +extension SwiftProtoTesting_Names_EnumFieldNames: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0A\0\u{1}String\0\u{1}Int\0\u{1}Double\0\u{1}Float\0\u{1}UInt\0\u{1}hashValue\0\u{1}description\0\u{1}debugDescription\0\u{1}Swift\0\u{1}UNRECOGNIZED\0\u{1}class\0\u{1}deinit\0\u{1}enum\0\u{1}extension\0\u{1}func\0\u{1}import\0\u{1}init\0\u{1}inout\0\u{1}internal\0\u{1}let\0\u{1}operator\0\u{1}private\0\u{1}protocol\0\u{1}public\0\u{1}static\0\u{1}struct\0\u{1}subscript\0\u{1}typealias\0\u{1}var\0\u{1}break\0\u{1}case\0\u{1}continue\0\u{1}default\0\u{1}defer\0\u{1}do\0\u{1}else\0\u{1}fallthrough\0\u{1}for\0\u{1}guard\0\u{1}if\0\u{1}in\0\u{1}repeat\0\u{1}return\0\u{1}switch\0\u{1}where\0\u{1}while\0\u{1}as\0\u{1}catch\0\u{1}dynamicType\0\u{1}false\0\u{1}is\0\u{1}nil\0\u{1}rethrows\0\u{1}super\0\u{1}self\0\u{2}\u{2}throw\0\u{1}throws\0\u{1}true\0\u{1}try\0\u{1}__COLUMN__\0\u{1}__FILE__\0\u{1}__FUNCTION__\0\u{1}__LINE__\0\u{1}_\0\u{1}associativity\0\u{1}convenience\0\u{1}dynamic\0\u{1}didSet\0\u{1}final\0\u{1}get\0\u{1}infix\0\u{1}indirect\0\u{1}lazy\0\u{1}left\0\u{1}mutating\0\u{1}none\0\u{1}nonmutating\0\u{1}optional\0\u{1}override\0\u{1}postfix\0\u{1}precedence\0\u{1}prefix\0\u{2}\u{2}required\0\u{1}right\0\u{1}set\0\u{1}Type\0\u{1}unowned\0\u{1}weak\0\u{1}willSet\0\u{2}\u{2}_cmd\0\u{2}\u{3}out\0\u{2}\u{2}bycopy\0\u{1}byref\0\u{1}oneway\0\u{2}\u{2}and\0\u{1}and_eq\0\u{1}alignas\0\u{1}alignof\0\u{1}asm\0\u{1}auto\0\u{1}bitand\0\u{1}bitor\0\u{1}bool\0\u{2}\u{4}char\0\u{1}char16_t\0\u{1}char32_t\0\u{2}\u{2}compl\0\u{1}const\0\u{1}constexpr\0\u{1}const_cast\0\u{2}\u{2}decltype\0\u{2}\u{2}delete\0\u{2}\u{2}dynamic_cast\0\u{2}\u{3}explicit\0\u{1}export\0\u{1}extern\0\u{2}\u{4}friend\0\u{1}goto\0\u{2}\u{2}inline\0\u{2}\u{2}long\0\u{1}mutable\0\u{1}namespace\0\u{1}new\0\u{1}noexcept\0\u{1}not\0\u{1}not_eq\0\u{1}nullptr\0\u{2}\u{2}or\0\u{1}or_eq\0\u{2}\u{2}protected\0\u{2}\u{2}register\0\u{1}reinterpret_cast\0\u{2}\u{2}short\0\u{1}signed\0\u{1}sizeof\0\u{2}\u{2}static_assert\0\u{1}static_cast\0\u{2}\u{3}template\0\u{1}this\0\u{1}thread_local\0\u{2}\u{4}typedef\0\u{1}typeid\0\u{1}typename\0\u{1}union\0\u{1}unsigned\0\u{1}using\0\u{1}virtual\0\u{1}void\0\u{1}volatile\0\u{1}wchar_t\0\u{2}\u{2}xor\0\u{1}xor_eq\0\u{1}restrict\0\u{1}Category\0\u{1}Ivar\0\u{1}Method\0\u{2}\u{4}finalize\0\u{1}hash\0\u{1}dealloc\0\u{2}\u{3}superclass\0\u{1}retain\0\u{1}release\0\u{1}autorelease\0\u{1}retainCount\0\u{1}zone\0\u{1}isProxy\0\u{1}copy\0\u{1}mutableCopy\0\u{1}classForCoder\0\u{1}clear\0\u{1}data\0\u{1}delimitedData\0\u{1}descriptor\0\u{1}extensionRegistry\0\u{1}extensionsCurrentlySet\0\u{1}isInitialized\0\u{1}serializedSize\0\u{1}sortedExtensionsInUse\0\u{1}unknownFields\0\u{1}Fixed\0\u{1}Fract\0\u{1}Size\0\u{1}LogicalAddress\0\u{1}PhysicalAddress\0\u{1}ByteCount\0\u{1}ByteOffset\0\u{1}Duration\0\u{1}AbsoluteTime\0\u{1}OptionBits\0\u{1}ItemCount\0\u{1}PBVersion\0\u{1}ScriptCode\0\u{1}LangCode\0\u{1}RegionCode\0\u{1}OSType\0\u{1}ProcessSerialNumber\0\u{1}Point\0\u{1}Rect\0\u{1}FixedPoint\0\u{1}FixedRect\0\u{1}Style\0\u{1}StyleParameter\0\u{1}StyleField\0\u{1}TimeScale\0\u{1}TimeBase\0\u{1}TimeRecord\0\u{1}Extensions\0") +} + +extension SwiftProtoTesting_Names_EnumFieldNames2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0AA\0\u{2}i\u{10}__\0") +} + +extension SwiftProtoTesting_Names_Foo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Foo" static let _protobuf_nameMap = SwiftProtobuf._NameMap() @@ -16748,7 +11748,7 @@ extension SwiftUnittest_Names_Foo: SwiftProtobuf.Message, SwiftProtobuf._Message mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { if (1 <= fieldNumber && fieldNumber < 5001) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftUnittest_Names_Foo.self, fieldNumber: fieldNumber) + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Names_Foo.self, fieldNumber: fieldNumber) } } } @@ -16758,239 +11758,16 @@ extension SwiftUnittest_Names_Foo: SwiftProtobuf.Message, SwiftProtobuf._Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_Foo, rhs: SwiftUnittest_Names_Foo) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_Foo, rhs: SwiftProtoTesting_Names_Foo) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension SwiftUnittest_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".FieldNames" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "String"), - 2: .same(proto: "Int"), - 3: .same(proto: "Double"), - 4: .same(proto: "Float"), - 5: .same(proto: "UInt"), - 6: .same(proto: "hashValue"), - 7: .same(proto: "description"), - 8: .same(proto: "debugDescription"), - 9: .same(proto: "Swift"), - 10: .same(proto: "UNRECOGNIZED"), - 11: .same(proto: "class"), - 12: .same(proto: "deinit"), - 13: .same(proto: "enum"), - 15: .same(proto: "func"), - 16: .same(proto: "import"), - 17: .same(proto: "init"), - 18: .same(proto: "inout"), - 19: .same(proto: "internal"), - 20: .same(proto: "let"), - 21: .same(proto: "operator"), - 22: .same(proto: "private"), - 23: .same(proto: "protocol"), - 24: .same(proto: "public"), - 25: .same(proto: "static"), - 26: .same(proto: "struct"), - 27: .same(proto: "subscript"), - 28: .same(proto: "typealias"), - 29: .same(proto: "var"), - 30: .same(proto: "break"), - 31: .same(proto: "case"), - 32: .same(proto: "continue"), - 33: .same(proto: "default"), - 34: .same(proto: "defer"), - 35: .same(proto: "do"), - 36: .same(proto: "else"), - 37: .same(proto: "fallthrough"), - 38: .same(proto: "for"), - 39: .same(proto: "guard"), - 40: .same(proto: "if"), - 41: .same(proto: "in"), - 42: .same(proto: "repeat"), - 43: .same(proto: "return"), - 44: .same(proto: "switch"), - 45: .same(proto: "where"), - 46: .same(proto: "while"), - 47: .same(proto: "as"), - 48: .same(proto: "catch"), - 49: .same(proto: "dynamicType"), - 50: .same(proto: "false"), - 51: .same(proto: "is"), - 52: .same(proto: "nil"), - 53: .same(proto: "rethrows"), - 54: .same(proto: "super"), - 55: .same(proto: "self"), - 57: .same(proto: "throw"), - 58: .same(proto: "throws"), - 59: .same(proto: "true"), - 60: .same(proto: "try"), - 61: .standard(proto: "__COLUMN__"), - 62: .standard(proto: "__FILE__"), - 63: .standard(proto: "__FUNCTION__"), - 64: .standard(proto: "__LINE__"), - 65: .standard(proto: "_"), - 66: .same(proto: "associativity"), - 67: .same(proto: "convenience"), - 68: .same(proto: "dynamic"), - 69: .same(proto: "didSet"), - 70: .same(proto: "final"), - 71: .same(proto: "get"), - 72: .same(proto: "infix"), - 73: .same(proto: "indirect"), - 74: .same(proto: "lazy"), - 75: .same(proto: "left"), - 76: .same(proto: "mutating"), - 77: .same(proto: "none"), - 78: .same(proto: "nonmutating"), - 79: .same(proto: "optional"), - 80: .same(proto: "override"), - 81: .same(proto: "postfix"), - 82: .same(proto: "precedence"), - 83: .same(proto: "prefix"), - 85: .same(proto: "required"), - 86: .same(proto: "right"), - 87: .same(proto: "set"), - 88: .same(proto: "Type"), - 89: .same(proto: "unowned"), - 90: .same(proto: "weak"), - 91: .same(proto: "willSet"), - 92: .same(proto: "id"), - 93: .standard(proto: "_cmd"), - 96: .same(proto: "out"), - 98: .same(proto: "bycopy"), - 99: .same(proto: "byref"), - 100: .same(proto: "oneway"), - 102: .same(proto: "and"), - 103: .standard(proto: "and_eq"), - 104: .same(proto: "alignas"), - 105: .same(proto: "alignof"), - 106: .same(proto: "asm"), - 107: .same(proto: "auto"), - 108: .same(proto: "bitand"), - 109: .same(proto: "bitor"), - 110: .same(proto: "bool"), - 114: .same(proto: "char"), - 115: .standard(proto: "char16_t"), - 116: .standard(proto: "char32_t"), - 118: .same(proto: "compl"), - 119: .same(proto: "const"), - 120: .same(proto: "constexpr"), - 121: .standard(proto: "const_cast"), - 123: .same(proto: "decltype"), - 125: .same(proto: "delete"), - 127: .standard(proto: "dynamic_cast"), - 130: .same(proto: "explicit"), - 131: .same(proto: "export"), - 132: .same(proto: "extern"), - 136: .same(proto: "friend"), - 137: .same(proto: "goto"), - 139: .same(proto: "inline"), - 141: .same(proto: "long"), - 142: .same(proto: "mutable"), - 143: .same(proto: "namespace"), - 144: .same(proto: "new"), - 145: .same(proto: "noexcept"), - 146: .same(proto: "not"), - 147: .standard(proto: "not_eq"), - 148: .same(proto: "nullptr"), - 150: .same(proto: "or"), - 151: .standard(proto: "or_eq"), - 153: .same(proto: "protected"), - 155: .same(proto: "register"), - 156: .standard(proto: "reinterpret_cast"), - 158: .same(proto: "short"), - 159: .same(proto: "signed"), - 160: .same(proto: "sizeof"), - 162: .standard(proto: "static_assert"), - 163: .standard(proto: "static_cast"), - 166: .same(proto: "template"), - 167: .same(proto: "this"), - 168: .standard(proto: "thread_local"), - 172: .same(proto: "typedef"), - 173: .same(proto: "typeid"), - 174: .same(proto: "typename"), - 175: .same(proto: "union"), - 176: .same(proto: "unsigned"), - 177: .same(proto: "using"), - 178: .same(proto: "virtual"), - 179: .same(proto: "void"), - 180: .same(proto: "volatile"), - 181: .standard(proto: "wchar_t"), - 183: .same(proto: "xor"), - 184: .standard(proto: "xor_eq"), - 185: .same(proto: "restrict"), - 186: .same(proto: "Category"), - 187: .same(proto: "Ivar"), - 188: .same(proto: "Method"), - 192: .same(proto: "finalize"), - 193: .same(proto: "hash"), - 194: .same(proto: "dealloc"), - 197: .same(proto: "superclass"), - 198: .same(proto: "retain"), - 199: .same(proto: "release"), - 200: .same(proto: "autorelease"), - 201: .same(proto: "retainCount"), - 202: .same(proto: "zone"), - 203: .same(proto: "isProxy"), - 204: .same(proto: "copy"), - 205: .same(proto: "mutableCopy"), - 206: .same(proto: "classForCoder"), - 207: .same(proto: "clear"), - 208: .same(proto: "data"), - 209: .same(proto: "delimitedData"), - 210: .same(proto: "descriptor"), - 211: .same(proto: "extensionRegistry"), - 212: .same(proto: "extensionsCurrentlySet"), - 213: .same(proto: "isInitialized"), - 214: .same(proto: "serializedSize"), - 215: .same(proto: "sortedExtensionsInUse"), - 216: .same(proto: "unknownFields"), - 217: .same(proto: "Fixed"), - 218: .same(proto: "Fract"), - 219: .same(proto: "Size"), - 220: .same(proto: "LogicalAddress"), - 221: .same(proto: "PhysicalAddress"), - 222: .same(proto: "ByteCount"), - 223: .same(proto: "ByteOffset"), - 224: .same(proto: "Duration"), - 225: .same(proto: "AbsoluteTime"), - 226: .same(proto: "OptionBits"), - 227: .same(proto: "ItemCount"), - 228: .same(proto: "PBVersion"), - 229: .same(proto: "ScriptCode"), - 230: .same(proto: "LangCode"), - 231: .same(proto: "RegionCode"), - 232: .same(proto: "OSType"), - 233: .same(proto: "ProcessSerialNumber"), - 234: .same(proto: "Point"), - 235: .same(proto: "Rect"), - 236: .same(proto: "FixedPoint"), - 237: .same(proto: "FixedRect"), - 238: .same(proto: "Style"), - 239: .same(proto: "StyleParameter"), - 240: .same(proto: "StyleField"), - 241: .same(proto: "TimeScale"), - 242: .same(proto: "TimeBase"), - 243: .same(proto: "TimeRecord"), - 244: .unique(proto: "json_should_be_overriden", json: "json_was_overridden"), - 245: .same(proto: "Any"), - 246: .same(proto: "Int32"), - 247: .same(proto: "Int64"), - 250: .same(proto: "UInt32"), - 251: .same(proto: "UInt64"), - 252: .same(proto: "associatedtype"), - 253: .same(proto: "fileprivate"), - 254: .same(proto: "open"), - 255: .same(proto: "serializedData"), - 256: .same(proto: "hasSerializedData"), - 257: .same(proto: "clearSerializedData"), - 258: .same(proto: "jsonUTF8Data"), - 259: .same(proto: "jsonString"), - 260: .same(proto: "Extension"), - 261: .same(proto: "Extensions"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}String\0\u{1}Int\0\u{1}Double\0\u{1}Float\0\u{1}UInt\0\u{1}hashValue\0\u{1}description\0\u{1}debugDescription\0\u{1}Swift\0\u{1}UNRECOGNIZED\0\u{1}class\0\u{1}deinit\0\u{1}enum\0\u{2}\u{2}func\0\u{1}import\0\u{1}init\0\u{1}inout\0\u{1}internal\0\u{1}let\0\u{1}operator\0\u{1}private\0\u{1}protocol\0\u{1}public\0\u{1}static\0\u{1}struct\0\u{1}subscript\0\u{1}typealias\0\u{1}var\0\u{1}break\0\u{1}case\0\u{1}continue\0\u{1}default\0\u{1}defer\0\u{1}do\0\u{1}else\0\u{1}fallthrough\0\u{1}for\0\u{1}guard\0\u{1}if\0\u{1}in\0\u{1}repeat\0\u{1}return\0\u{1}switch\0\u{1}where\0\u{1}while\0\u{1}as\0\u{1}catch\0\u{1}dynamicType\0\u{1}false\0\u{1}is\0\u{1}nil\0\u{1}rethrows\0\u{1}super\0\u{1}self\0\u{2}\u{2}throw\0\u{1}throws\0\u{1}true\0\u{1}try\0\u{3}__COLUMN__\0\u{3}__FILE__\0\u{3}__FUNCTION__\0\u{3}__LINE__\0\u{3}_\0\u{1}associativity\0\u{1}convenience\0\u{1}dynamic\0\u{1}didSet\0\u{1}final\0\u{1}get\0\u{1}infix\0\u{1}indirect\0\u{1}lazy\0\u{1}left\0\u{1}mutating\0\u{1}none\0\u{1}nonmutating\0\u{1}optional\0\u{1}override\0\u{1}postfix\0\u{1}precedence\0\u{1}prefix\0\u{2}\u{2}required\0\u{1}right\0\u{1}set\0\u{1}Type\0\u{1}unowned\0\u{1}weak\0\u{1}willSet\0\u{1}id\0\u{3}_cmd\0\u{2}\u{3}out\0\u{2}\u{2}bycopy\0\u{1}byref\0\u{1}oneway\0\u{2}\u{2}and\0\u{3}and_eq\0\u{1}alignas\0\u{1}alignof\0\u{1}asm\0\u{1}auto\0\u{1}bitand\0\u{1}bitor\0\u{1}bool\0\u{2}\u{4}char\0\u{3}char16_t\0\u{3}char32_t\0\u{2}\u{2}compl\0\u{1}const\0\u{1}constexpr\0\u{3}const_cast\0\u{2}\u{2}decltype\0\u{2}\u{2}delete\0\u{4}\u{2}dynamic_cast\0\u{2}\u{3}explicit\0\u{1}export\0\u{1}extern\0\u{2}\u{4}friend\0\u{1}goto\0\u{2}\u{2}inline\0\u{2}\u{2}long\0\u{1}mutable\0\u{1}namespace\0\u{1}new\0\u{1}noexcept\0\u{1}not\0\u{3}not_eq\0\u{1}nullptr\0\u{2}\u{2}or\0\u{3}or_eq\0\u{2}\u{2}protected\0\u{2}\u{2}register\0\u{3}reinterpret_cast\0\u{2}\u{2}short\0\u{1}signed\0\u{1}sizeof\0\u{4}\u{2}static_assert\0\u{3}static_cast\0\u{2}\u{3}template\0\u{1}this\0\u{3}thread_local\0\u{2}\u{4}typedef\0\u{1}typeid\0\u{1}typename\0\u{1}union\0\u{1}unsigned\0\u{1}using\0\u{1}virtual\0\u{1}void\0\u{1}volatile\0\u{3}wchar_t\0\u{2}\u{2}xor\0\u{3}xor_eq\0\u{1}restrict\0\u{1}Category\0\u{1}Ivar\0\u{1}Method\0\u{2}\u{4}finalize\0\u{1}hash\0\u{1}dealloc\0\u{2}\u{3}superclass\0\u{1}retain\0\u{1}release\0\u{1}autorelease\0\u{1}retainCount\0\u{1}zone\0\u{1}isProxy\0\u{1}copy\0\u{1}mutableCopy\0\u{1}classForCoder\0\u{1}clear\0\u{1}data\0\u{1}delimitedData\0\u{1}descriptor\0\u{1}extensionRegistry\0\u{1}extensionsCurrentlySet\0\u{1}isInitialized\0\u{1}serializedSize\0\u{1}sortedExtensionsInUse\0\u{1}unknownFields\0\u{1}Fixed\0\u{1}Fract\0\u{1}Size\0\u{1}LogicalAddress\0\u{1}PhysicalAddress\0\u{1}ByteCount\0\u{1}ByteOffset\0\u{1}Duration\0\u{1}AbsoluteTime\0\u{1}OptionBits\0\u{1}ItemCount\0\u{1}PBVersion\0\u{1}ScriptCode\0\u{1}LangCode\0\u{1}RegionCode\0\u{1}OSType\0\u{1}ProcessSerialNumber\0\u{1}Point\0\u{1}Rect\0\u{1}FixedPoint\0\u{1}FixedRect\0\u{1}Style\0\u{1}StyleParameter\0\u{1}StyleField\0\u{1}TimeScale\0\u{1}TimeBase\0\u{1}TimeRecord\0\u{5}json_should_be_overridden\0json_was_overridden\0\u{1}Any\0\u{1}Int32\0\u{1}Int64\0\u{2}\u{3}UInt32\0\u{1}UInt64\0\u{1}associatedtype\0\u{1}fileprivate\0\u{1}open\0\u{1}serializedData\0\u{1}hasSerializedData\0\u{1}clearSerializedData\0\u{1}jsonUTF8Data\0\u{1}jsonString\0\u{1}Extension\0\u{1}Extensions\0") fileprivate class _StorageClass { var _string: Int32? = nil @@ -17199,7 +11976,7 @@ extension SwiftUnittest_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._ var _timeScale: Int32? = nil var _timeBase: Int32? = nil var _timeRecord: Int32? = nil - var _jsonShouldBeOverriden: Int32? = nil + var _jsonShouldBeOverridden: Int32? = nil var _any: Int32? = nil var _int32: Int32? = nil var _int64: Int32? = nil @@ -17216,7 +11993,11 @@ extension SwiftUnittest_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._ var _extension: Int32? = nil var _extensions: Int32? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -17427,7 +12208,7 @@ extension SwiftUnittest_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._ _timeScale = source._timeScale _timeBase = source._timeBase _timeRecord = source._timeRecord - _jsonShouldBeOverriden = source._jsonShouldBeOverriden + _jsonShouldBeOverridden = source._jsonShouldBeOverridden _any = source._any _int32 = source._int32 _int64 = source._int64 @@ -17667,7 +12448,7 @@ extension SwiftUnittest_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._ case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._timeScale) }() case 242: try { try decoder.decodeSingularInt32Field(value: &_storage._timeBase) }() case 243: try { try decoder.decodeSingularInt32Field(value: &_storage._timeRecord) }() - case 244: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonShouldBeOverriden) }() + case 244: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonShouldBeOverridden) }() case 245: try { try decoder.decodeSingularInt32Field(value: &_storage._any) }() case 246: try { try decoder.decodeSingularInt32Field(value: &_storage._int32) }() case 247: try { try decoder.decodeSingularInt32Field(value: &_storage._int64) }() @@ -18313,7 +13094,7 @@ extension SwiftUnittest_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._ try { if let v = _storage._timeRecord { try visitor.visitSingularInt32Field(value: v, fieldNumber: 243) } }() - try { if let v = _storage._jsonShouldBeOverriden { + try { if let v = _storage._jsonShouldBeOverridden { try visitor.visitSingularInt32Field(value: v, fieldNumber: 244) } }() try { if let v = _storage._any { @@ -18365,7 +13146,7 @@ extension SwiftUnittest_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._ try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_FieldNames, rhs: SwiftUnittest_Names_FieldNames) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_FieldNames, rhs: SwiftProtoTesting_Names_FieldNames) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -18576,7 +13357,7 @@ extension SwiftUnittest_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._ if _storage._timeScale != rhs_storage._timeScale {return false} if _storage._timeBase != rhs_storage._timeBase {return false} if _storage._timeRecord != rhs_storage._timeRecord {return false} - if _storage._jsonShouldBeOverriden != rhs_storage._jsonShouldBeOverriden {return false} + if _storage._jsonShouldBeOverridden != rhs_storage._jsonShouldBeOverridden {return false} if _storage._any != rhs_storage._any {return false} if _storage._int32 != rhs_storage._int32 {return false} if _storage._int64 != rhs_storage._int64 {return false} @@ -18601,30 +13382,28 @@ extension SwiftUnittest_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._ } } -extension SwiftUnittest_Names_MessageNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_MessageNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MessageNames" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames, rhs: SwiftUnittest_Names_MessageNames) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames, rhs: SwiftProtoTesting_Names_MessageNames) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.StringMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".String" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "String"), - ] +extension SwiftProtoTesting_Names_MessageNames.StringMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".String" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}String\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18649,18 +13428,16 @@ extension SwiftUnittest_Names_MessageNames.StringMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.StringMessage, rhs: SwiftUnittest_Names_MessageNames.StringMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.StringMessage, rhs: SwiftProtoTesting_Names_MessageNames.StringMessage) -> Bool { if lhs._string != rhs._string {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.ProtocolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Protocol" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Protocol"), - ] +extension SwiftProtoTesting_Names_MessageNames.ProtocolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Protocol" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Protocol\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18685,18 +13462,16 @@ extension SwiftUnittest_Names_MessageNames.ProtocolMessage: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.ProtocolMessage, rhs: SwiftUnittest_Names_MessageNames.ProtocolMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ProtocolMessage, rhs: SwiftProtoTesting_Names_MessageNames.ProtocolMessage) -> Bool { if lhs._protocol != rhs._protocol {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.IntMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Int" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Int"), - ] +extension SwiftProtoTesting_Names_MessageNames.IntMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Int" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Int\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18721,18 +13496,16 @@ extension SwiftUnittest_Names_MessageNames.IntMessage: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.IntMessage, rhs: SwiftUnittest_Names_MessageNames.IntMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.IntMessage, rhs: SwiftProtoTesting_Names_MessageNames.IntMessage) -> Bool { if lhs._int != rhs._int {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.DoubleMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Double" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Double"), - ] +extension SwiftProtoTesting_Names_MessageNames.DoubleMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Double" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Double\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18757,18 +13530,16 @@ extension SwiftUnittest_Names_MessageNames.DoubleMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.DoubleMessage, rhs: SwiftUnittest_Names_MessageNames.DoubleMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.DoubleMessage, rhs: SwiftProtoTesting_Names_MessageNames.DoubleMessage) -> Bool { if lhs._double != rhs._double {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.FloatMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Float" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Float"), - ] +extension SwiftProtoTesting_Names_MessageNames.FloatMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Float" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Float\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18793,18 +13564,16 @@ extension SwiftUnittest_Names_MessageNames.FloatMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.FloatMessage, rhs: SwiftUnittest_Names_MessageNames.FloatMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.FloatMessage, rhs: SwiftProtoTesting_Names_MessageNames.FloatMessage) -> Bool { if lhs._float != rhs._float {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.UIntMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".UInt" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UInt"), - ] +extension SwiftProtoTesting_Names_MessageNames.UIntMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".UInt" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UInt\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18829,18 +13598,16 @@ extension SwiftUnittest_Names_MessageNames.UIntMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.UIntMessage, rhs: SwiftUnittest_Names_MessageNames.UIntMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.UIntMessage, rhs: SwiftProtoTesting_Names_MessageNames.UIntMessage) -> Bool { if lhs._uint != rhs._uint {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.hashValueMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".hashValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hashValue"), - ] +extension SwiftProtoTesting_Names_MessageNames.hashValueMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".hashValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hashValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18865,18 +13632,16 @@ extension SwiftUnittest_Names_MessageNames.hashValueMessage: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.hashValueMessage, rhs: SwiftUnittest_Names_MessageNames.hashValueMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.hashValueMessage, rhs: SwiftProtoTesting_Names_MessageNames.hashValueMessage) -> Bool { if lhs._hashValue_p != rhs._hashValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.descriptionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".description" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "description"), - ] +extension SwiftProtoTesting_Names_MessageNames.descriptionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".description" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}description\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18901,18 +13666,16 @@ extension SwiftUnittest_Names_MessageNames.descriptionMessage: SwiftProtobuf.Mes try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.descriptionMessage, rhs: SwiftUnittest_Names_MessageNames.descriptionMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.descriptionMessage, rhs: SwiftProtoTesting_Names_MessageNames.descriptionMessage) -> Bool { if lhs._description_p != rhs._description_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.debugDescriptionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".debugDescription" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "debugDescription"), - ] +extension SwiftProtoTesting_Names_MessageNames.debugDescriptionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".debugDescription" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}debugDescription\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18937,18 +13700,16 @@ extension SwiftUnittest_Names_MessageNames.debugDescriptionMessage: SwiftProtobu try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.debugDescriptionMessage, rhs: SwiftUnittest_Names_MessageNames.debugDescriptionMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.debugDescriptionMessage, rhs: SwiftProtoTesting_Names_MessageNames.debugDescriptionMessage) -> Bool { if lhs._debugDescription_p != rhs._debugDescription_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Swift: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Swift" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Swift"), - ] +extension SwiftProtoTesting_Names_MessageNames.SwiftMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Swift" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Swift\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18973,18 +13734,16 @@ extension SwiftUnittest_Names_MessageNames.Swift: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Swift, rhs: SwiftUnittest_Names_MessageNames.Swift) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.SwiftMessage, rhs: SwiftProtoTesting_Names_MessageNames.SwiftMessage) -> Bool { if lhs._swift != rhs._swift {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.UNRECOGNIZED: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".UNRECOGNIZED" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UNRECOGNIZED"), - ] +extension SwiftProtoTesting_Names_MessageNames.UNRECOGNIZED: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".UNRECOGNIZED" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UNRECOGNIZED\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19009,18 +13768,16 @@ extension SwiftUnittest_Names_MessageNames.UNRECOGNIZED: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.UNRECOGNIZED, rhs: SwiftUnittest_Names_MessageNames.UNRECOGNIZED) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.UNRECOGNIZED, rhs: SwiftProtoTesting_Names_MessageNames.UNRECOGNIZED) -> Bool { if lhs._unrecognized != rhs._unrecognized {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.classMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".class" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "class"), - ] +extension SwiftProtoTesting_Names_MessageNames.classMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".class" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}class\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19045,18 +13802,16 @@ extension SwiftUnittest_Names_MessageNames.classMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.classMessage, rhs: SwiftUnittest_Names_MessageNames.classMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.classMessage, rhs: SwiftProtoTesting_Names_MessageNames.classMessage) -> Bool { if lhs._class != rhs._class {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.deinitMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".deinit" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "deinit"), - ] +extension SwiftProtoTesting_Names_MessageNames.deinitMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".deinit" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}deinit\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19081,18 +13836,16 @@ extension SwiftUnittest_Names_MessageNames.deinitMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.deinitMessage, rhs: SwiftUnittest_Names_MessageNames.deinitMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.deinitMessage, rhs: SwiftProtoTesting_Names_MessageNames.deinitMessage) -> Bool { if lhs._deinit != rhs._deinit {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.enumMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".enum" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "enum"), - ] +extension SwiftProtoTesting_Names_MessageNames.enumMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".enum" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19117,18 +13870,16 @@ extension SwiftUnittest_Names_MessageNames.enumMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.enumMessage, rhs: SwiftUnittest_Names_MessageNames.enumMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.enumMessage, rhs: SwiftProtoTesting_Names_MessageNames.enumMessage) -> Bool { if lhs._enum != rhs._enum {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.extensionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".extension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extension"), - ] +extension SwiftProtoTesting_Names_MessageNames.extensionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".extension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19153,18 +13904,16 @@ extension SwiftUnittest_Names_MessageNames.extensionMessage: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.extensionMessage, rhs: SwiftUnittest_Names_MessageNames.extensionMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.extensionMessage, rhs: SwiftProtoTesting_Names_MessageNames.extensionMessage) -> Bool { if lhs._extension != rhs._extension {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.funcMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".func" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "func"), - ] +extension SwiftProtoTesting_Names_MessageNames.funcMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".func" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}func\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19189,18 +13938,16 @@ extension SwiftUnittest_Names_MessageNames.funcMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.funcMessage, rhs: SwiftUnittest_Names_MessageNames.funcMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.funcMessage, rhs: SwiftProtoTesting_Names_MessageNames.funcMessage) -> Bool { if lhs._func != rhs._func {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.importMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".import" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "import"), - ] +extension SwiftProtoTesting_Names_MessageNames.importMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".import" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}import\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19225,18 +13972,16 @@ extension SwiftUnittest_Names_MessageNames.importMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.importMessage, rhs: SwiftUnittest_Names_MessageNames.importMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.importMessage, rhs: SwiftProtoTesting_Names_MessageNames.importMessage) -> Bool { if lhs._import != rhs._import {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.initMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".init" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "init"), - ] +extension SwiftProtoTesting_Names_MessageNames.initMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".init" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}init\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19261,18 +14006,16 @@ extension SwiftUnittest_Names_MessageNames.initMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.initMessage, rhs: SwiftUnittest_Names_MessageNames.initMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.initMessage, rhs: SwiftProtoTesting_Names_MessageNames.initMessage) -> Bool { if lhs._init_p != rhs._init_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.inoutMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".inout" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "inout"), - ] +extension SwiftProtoTesting_Names_MessageNames.inoutMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".inout" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}inout\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19297,18 +14040,16 @@ extension SwiftUnittest_Names_MessageNames.inoutMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.inoutMessage, rhs: SwiftUnittest_Names_MessageNames.inoutMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.inoutMessage, rhs: SwiftProtoTesting_Names_MessageNames.inoutMessage) -> Bool { if lhs._inout != rhs._inout {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.internalMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".internal" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "internal"), - ] +extension SwiftProtoTesting_Names_MessageNames.internalMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".internal" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}internal\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19333,18 +14074,16 @@ extension SwiftUnittest_Names_MessageNames.internalMessage: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.internalMessage, rhs: SwiftUnittest_Names_MessageNames.internalMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.internalMessage, rhs: SwiftProtoTesting_Names_MessageNames.internalMessage) -> Bool { if lhs._internal != rhs._internal {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.letMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".let" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "let"), - ] +extension SwiftProtoTesting_Names_MessageNames.letMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".let" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}let\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19369,18 +14108,16 @@ extension SwiftUnittest_Names_MessageNames.letMessage: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.letMessage, rhs: SwiftUnittest_Names_MessageNames.letMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.letMessage, rhs: SwiftProtoTesting_Names_MessageNames.letMessage) -> Bool { if lhs._let != rhs._let {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.operatorMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".operator" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "operator"), - ] +extension SwiftProtoTesting_Names_MessageNames.operatorMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".operator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}operator\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19405,18 +14142,16 @@ extension SwiftUnittest_Names_MessageNames.operatorMessage: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.operatorMessage, rhs: SwiftUnittest_Names_MessageNames.operatorMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.operatorMessage, rhs: SwiftProtoTesting_Names_MessageNames.operatorMessage) -> Bool { if lhs._operator != rhs._operator {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.privateMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".private" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "private"), - ] +extension SwiftProtoTesting_Names_MessageNames.privateMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".private" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}private\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19441,18 +14176,16 @@ extension SwiftUnittest_Names_MessageNames.privateMessage: SwiftProtobuf.Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.privateMessage, rhs: SwiftUnittest_Names_MessageNames.privateMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.privateMessage, rhs: SwiftProtoTesting_Names_MessageNames.privateMessage) -> Bool { if lhs._private != rhs._private {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.protocolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".protocol" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "protocol"), - ] +extension SwiftProtoTesting_Names_MessageNames.protocolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".protocol" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}protocol\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19477,18 +14210,16 @@ extension SwiftUnittest_Names_MessageNames.protocolMessage: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.protocolMessage, rhs: SwiftUnittest_Names_MessageNames.protocolMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.protocolMessage, rhs: SwiftProtoTesting_Names_MessageNames.protocolMessage) -> Bool { if lhs._protocol != rhs._protocol {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.publicMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".public" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "public"), - ] +extension SwiftProtoTesting_Names_MessageNames.publicMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".public" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}public\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19513,18 +14244,16 @@ extension SwiftUnittest_Names_MessageNames.publicMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.publicMessage, rhs: SwiftUnittest_Names_MessageNames.publicMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.publicMessage, rhs: SwiftProtoTesting_Names_MessageNames.publicMessage) -> Bool { if lhs._public != rhs._public {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.staticMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".static" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "static"), - ] +extension SwiftProtoTesting_Names_MessageNames.staticMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".static" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}static\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19549,18 +14278,16 @@ extension SwiftUnittest_Names_MessageNames.staticMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.staticMessage, rhs: SwiftUnittest_Names_MessageNames.staticMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.staticMessage, rhs: SwiftProtoTesting_Names_MessageNames.staticMessage) -> Bool { if lhs._static != rhs._static {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.structMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".struct" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "struct"), - ] +extension SwiftProtoTesting_Names_MessageNames.structMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".struct" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}struct\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19585,18 +14312,16 @@ extension SwiftUnittest_Names_MessageNames.structMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.structMessage, rhs: SwiftUnittest_Names_MessageNames.structMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.structMessage, rhs: SwiftProtoTesting_Names_MessageNames.structMessage) -> Bool { if lhs._struct != rhs._struct {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.subscriptMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".subscript" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "subscript"), - ] +extension SwiftProtoTesting_Names_MessageNames.subscriptMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".subscript" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}subscript\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19621,18 +14346,16 @@ extension SwiftUnittest_Names_MessageNames.subscriptMessage: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.subscriptMessage, rhs: SwiftUnittest_Names_MessageNames.subscriptMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.subscriptMessage, rhs: SwiftProtoTesting_Names_MessageNames.subscriptMessage) -> Bool { if lhs._subscript != rhs._subscript {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.typealiasMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".typealias" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typealias"), - ] +extension SwiftProtoTesting_Names_MessageNames.typealiasMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".typealias" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typealias\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19657,18 +14380,16 @@ extension SwiftUnittest_Names_MessageNames.typealiasMessage: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.typealiasMessage, rhs: SwiftUnittest_Names_MessageNames.typealiasMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.typealiasMessage, rhs: SwiftProtoTesting_Names_MessageNames.typealiasMessage) -> Bool { if lhs._typealias != rhs._typealias {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.varMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".var" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "var"), - ] +extension SwiftProtoTesting_Names_MessageNames.varMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".var" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}var\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19693,18 +14414,16 @@ extension SwiftUnittest_Names_MessageNames.varMessage: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.varMessage, rhs: SwiftUnittest_Names_MessageNames.varMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.varMessage, rhs: SwiftProtoTesting_Names_MessageNames.varMessage) -> Bool { if lhs._var != rhs._var {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.breakMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".break" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "break"), - ] +extension SwiftProtoTesting_Names_MessageNames.breakMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".break" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}break\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19729,18 +14448,16 @@ extension SwiftUnittest_Names_MessageNames.breakMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.breakMessage, rhs: SwiftUnittest_Names_MessageNames.breakMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.breakMessage, rhs: SwiftProtoTesting_Names_MessageNames.breakMessage) -> Bool { if lhs._break != rhs._break {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.caseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".case" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "case"), - ] +extension SwiftProtoTesting_Names_MessageNames.caseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".case" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}case\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19765,18 +14482,16 @@ extension SwiftUnittest_Names_MessageNames.caseMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.caseMessage, rhs: SwiftUnittest_Names_MessageNames.caseMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.caseMessage, rhs: SwiftProtoTesting_Names_MessageNames.caseMessage) -> Bool { if lhs._case != rhs._case {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.continueMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".continue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "continue"), - ] +extension SwiftProtoTesting_Names_MessageNames.continueMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".continue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}continue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19801,18 +14516,16 @@ extension SwiftUnittest_Names_MessageNames.continueMessage: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.continueMessage, rhs: SwiftUnittest_Names_MessageNames.continueMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.continueMessage, rhs: SwiftProtoTesting_Names_MessageNames.continueMessage) -> Bool { if lhs._continue != rhs._continue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.defaultMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".default" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "default"), - ] +extension SwiftProtoTesting_Names_MessageNames.defaultMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".default" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}default\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19837,18 +14550,16 @@ extension SwiftUnittest_Names_MessageNames.defaultMessage: SwiftProtobuf.Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.defaultMessage, rhs: SwiftUnittest_Names_MessageNames.defaultMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.defaultMessage, rhs: SwiftProtoTesting_Names_MessageNames.defaultMessage) -> Bool { if lhs._default != rhs._default {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.deferMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".defer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "defer"), - ] +extension SwiftProtoTesting_Names_MessageNames.deferMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".defer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}defer\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19873,18 +14584,16 @@ extension SwiftUnittest_Names_MessageNames.deferMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.deferMessage, rhs: SwiftUnittest_Names_MessageNames.deferMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.deferMessage, rhs: SwiftProtoTesting_Names_MessageNames.deferMessage) -> Bool { if lhs._defer != rhs._defer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.doMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".do" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "do"), - ] +extension SwiftProtoTesting_Names_MessageNames.doMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".do" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}do\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19909,18 +14618,16 @@ extension SwiftUnittest_Names_MessageNames.doMessage: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.doMessage, rhs: SwiftUnittest_Names_MessageNames.doMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.doMessage, rhs: SwiftProtoTesting_Names_MessageNames.doMessage) -> Bool { if lhs._do != rhs._do {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.elseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".else" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "else"), - ] +extension SwiftProtoTesting_Names_MessageNames.elseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".else" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}else\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19945,18 +14652,16 @@ extension SwiftUnittest_Names_MessageNames.elseMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.elseMessage, rhs: SwiftUnittest_Names_MessageNames.elseMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.elseMessage, rhs: SwiftProtoTesting_Names_MessageNames.elseMessage) -> Bool { if lhs._else != rhs._else {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.fallthroughMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".fallthrough" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fallthrough"), - ] +extension SwiftProtoTesting_Names_MessageNames.fallthroughMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".fallthrough" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fallthrough\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19981,18 +14686,16 @@ extension SwiftUnittest_Names_MessageNames.fallthroughMessage: SwiftProtobuf.Mes try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.fallthroughMessage, rhs: SwiftUnittest_Names_MessageNames.fallthroughMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.fallthroughMessage, rhs: SwiftProtoTesting_Names_MessageNames.fallthroughMessage) -> Bool { if lhs._fallthrough != rhs._fallthrough {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.forMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".for" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "for"), - ] +extension SwiftProtoTesting_Names_MessageNames.forMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".for" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}for\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20017,18 +14720,16 @@ extension SwiftUnittest_Names_MessageNames.forMessage: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.forMessage, rhs: SwiftUnittest_Names_MessageNames.forMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.forMessage, rhs: SwiftProtoTesting_Names_MessageNames.forMessage) -> Bool { if lhs._for != rhs._for {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.guardMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".guard" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "guard"), - ] +extension SwiftProtoTesting_Names_MessageNames.guardMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".guard" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}guard\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20053,18 +14754,16 @@ extension SwiftUnittest_Names_MessageNames.guardMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.guardMessage, rhs: SwiftUnittest_Names_MessageNames.guardMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.guardMessage, rhs: SwiftProtoTesting_Names_MessageNames.guardMessage) -> Bool { if lhs._guard != rhs._guard {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.ifMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".if" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "if"), - ] +extension SwiftProtoTesting_Names_MessageNames.ifMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".if" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}if\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20089,18 +14788,16 @@ extension SwiftUnittest_Names_MessageNames.ifMessage: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.ifMessage, rhs: SwiftUnittest_Names_MessageNames.ifMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ifMessage, rhs: SwiftProtoTesting_Names_MessageNames.ifMessage) -> Bool { if lhs._if != rhs._if {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.inMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".in" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "in"), - ] +extension SwiftProtoTesting_Names_MessageNames.inMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".in" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}in\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20125,18 +14822,16 @@ extension SwiftUnittest_Names_MessageNames.inMessage: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.inMessage, rhs: SwiftUnittest_Names_MessageNames.inMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.inMessage, rhs: SwiftProtoTesting_Names_MessageNames.inMessage) -> Bool { if lhs._in != rhs._in {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.repeatMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".repeat" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "repeat"), - ] +extension SwiftProtoTesting_Names_MessageNames.repeatMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".repeat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}repeat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20161,18 +14856,16 @@ extension SwiftUnittest_Names_MessageNames.repeatMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.repeatMessage, rhs: SwiftUnittest_Names_MessageNames.repeatMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.repeatMessage, rhs: SwiftProtoTesting_Names_MessageNames.repeatMessage) -> Bool { if lhs._repeat != rhs._repeat {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.returnMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".return" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "return"), - ] +extension SwiftProtoTesting_Names_MessageNames.returnMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".return" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}return\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20197,18 +14890,16 @@ extension SwiftUnittest_Names_MessageNames.returnMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.returnMessage, rhs: SwiftUnittest_Names_MessageNames.returnMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.returnMessage, rhs: SwiftProtoTesting_Names_MessageNames.returnMessage) -> Bool { if lhs._return != rhs._return {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.switchMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".switch" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "switch"), - ] +extension SwiftProtoTesting_Names_MessageNames.switchMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".switch" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}switch\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20233,18 +14924,16 @@ extension SwiftUnittest_Names_MessageNames.switchMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.switchMessage, rhs: SwiftUnittest_Names_MessageNames.switchMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.switchMessage, rhs: SwiftProtoTesting_Names_MessageNames.switchMessage) -> Bool { if lhs._switch != rhs._switch {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.whereMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".where" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "where"), - ] +extension SwiftProtoTesting_Names_MessageNames.whereMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".where" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}where\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20269,18 +14958,16 @@ extension SwiftUnittest_Names_MessageNames.whereMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.whereMessage, rhs: SwiftUnittest_Names_MessageNames.whereMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.whereMessage, rhs: SwiftProtoTesting_Names_MessageNames.whereMessage) -> Bool { if lhs._where != rhs._where {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.whileMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".while" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "while"), - ] +extension SwiftProtoTesting_Names_MessageNames.whileMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".while" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}while\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20305,18 +14992,16 @@ extension SwiftUnittest_Names_MessageNames.whileMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.whileMessage, rhs: SwiftUnittest_Names_MessageNames.whileMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.whileMessage, rhs: SwiftProtoTesting_Names_MessageNames.whileMessage) -> Bool { if lhs._while != rhs._while {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.asMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".as" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "as"), - ] +extension SwiftProtoTesting_Names_MessageNames.asMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".as" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}as\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20341,18 +15026,16 @@ extension SwiftUnittest_Names_MessageNames.asMessage: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.asMessage, rhs: SwiftUnittest_Names_MessageNames.asMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.asMessage, rhs: SwiftProtoTesting_Names_MessageNames.asMessage) -> Bool { if lhs._as != rhs._as {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.catchMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".catch" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "catch"), - ] +extension SwiftProtoTesting_Names_MessageNames.catchMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".catch" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}catch\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20377,18 +15060,16 @@ extension SwiftUnittest_Names_MessageNames.catchMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.catchMessage, rhs: SwiftUnittest_Names_MessageNames.catchMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.catchMessage, rhs: SwiftProtoTesting_Names_MessageNames.catchMessage) -> Bool { if lhs._catch != rhs._catch {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.dynamicTypeMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".dynamicType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "dynamicType"), - ] +extension SwiftProtoTesting_Names_MessageNames.dynamicTypeMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".dynamicType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}dynamicType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20413,18 +15094,16 @@ extension SwiftUnittest_Names_MessageNames.dynamicTypeMessage: SwiftProtobuf.Mes try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.dynamicTypeMessage, rhs: SwiftUnittest_Names_MessageNames.dynamicTypeMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.dynamicTypeMessage, rhs: SwiftProtoTesting_Names_MessageNames.dynamicTypeMessage) -> Bool { if lhs._dynamicType_p != rhs._dynamicType_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.falseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".false" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "false"), - ] +extension SwiftProtoTesting_Names_MessageNames.falseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".false" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}false\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20449,18 +15128,16 @@ extension SwiftUnittest_Names_MessageNames.falseMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.falseMessage, rhs: SwiftUnittest_Names_MessageNames.falseMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.falseMessage, rhs: SwiftProtoTesting_Names_MessageNames.falseMessage) -> Bool { if lhs._false != rhs._false {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.isMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".is" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "is"), - ] +extension SwiftProtoTesting_Names_MessageNames.isMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".is" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}is\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20485,18 +15162,16 @@ extension SwiftUnittest_Names_MessageNames.isMessage: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.isMessage, rhs: SwiftUnittest_Names_MessageNames.isMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.isMessage, rhs: SwiftProtoTesting_Names_MessageNames.isMessage) -> Bool { if lhs._is != rhs._is {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.nilMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".nil" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nil"), - ] +extension SwiftProtoTesting_Names_MessageNames.nilMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".nil" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nil\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20521,18 +15196,16 @@ extension SwiftUnittest_Names_MessageNames.nilMessage: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.nilMessage, rhs: SwiftUnittest_Names_MessageNames.nilMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.nilMessage, rhs: SwiftProtoTesting_Names_MessageNames.nilMessage) -> Bool { if lhs._nil != rhs._nil {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.rethrowsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".rethrows" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "rethrows"), - ] +extension SwiftProtoTesting_Names_MessageNames.rethrowsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".rethrows" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}rethrows\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20557,18 +15230,16 @@ extension SwiftUnittest_Names_MessageNames.rethrowsMessage: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.rethrowsMessage, rhs: SwiftUnittest_Names_MessageNames.rethrowsMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.rethrowsMessage, rhs: SwiftProtoTesting_Names_MessageNames.rethrowsMessage) -> Bool { if lhs._rethrows != rhs._rethrows {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.superMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".super" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "super"), - ] +extension SwiftProtoTesting_Names_MessageNames.superMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".super" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}super\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20593,18 +15264,16 @@ extension SwiftUnittest_Names_MessageNames.superMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.superMessage, rhs: SwiftUnittest_Names_MessageNames.superMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.superMessage, rhs: SwiftProtoTesting_Names_MessageNames.superMessage) -> Bool { if lhs._super != rhs._super {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.selfMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".self" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "self"), - ] +extension SwiftProtoTesting_Names_MessageNames.selfMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".self" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}self\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20629,18 +15298,16 @@ extension SwiftUnittest_Names_MessageNames.selfMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.selfMessage, rhs: SwiftUnittest_Names_MessageNames.selfMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.selfMessage, rhs: SwiftProtoTesting_Names_MessageNames.selfMessage) -> Bool { if lhs._self_p != rhs._self_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.throwMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".throw" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "throw"), - ] +extension SwiftProtoTesting_Names_MessageNames.throwMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".throw" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}throw\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20665,18 +15332,16 @@ extension SwiftUnittest_Names_MessageNames.throwMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.throwMessage, rhs: SwiftUnittest_Names_MessageNames.throwMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.throwMessage, rhs: SwiftProtoTesting_Names_MessageNames.throwMessage) -> Bool { if lhs._throw != rhs._throw {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.throwsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".throws" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "throws"), - ] +extension SwiftProtoTesting_Names_MessageNames.throwsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".throws" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}throws\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20701,18 +15366,16 @@ extension SwiftUnittest_Names_MessageNames.throwsMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.throwsMessage, rhs: SwiftUnittest_Names_MessageNames.throwsMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.throwsMessage, rhs: SwiftProtoTesting_Names_MessageNames.throwsMessage) -> Bool { if lhs._throws != rhs._throws {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.trueMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".true" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "true"), - ] +extension SwiftProtoTesting_Names_MessageNames.trueMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".true" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}true\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20737,18 +15400,16 @@ extension SwiftUnittest_Names_MessageNames.trueMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.trueMessage, rhs: SwiftUnittest_Names_MessageNames.trueMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.trueMessage, rhs: SwiftProtoTesting_Names_MessageNames.trueMessage) -> Bool { if lhs._true != rhs._true {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.tryMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".try" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "try"), - ] +extension SwiftProtoTesting_Names_MessageNames.tryMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".try" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}try\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20773,18 +15434,16 @@ extension SwiftUnittest_Names_MessageNames.tryMessage: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.tryMessage, rhs: SwiftUnittest_Names_MessageNames.tryMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.tryMessage, rhs: SwiftProtoTesting_Names_MessageNames.tryMessage) -> Bool { if lhs._try != rhs._try {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.__COLUMN__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".__COLUMN__" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "__COLUMN__"), - ] +extension SwiftProtoTesting_Names_MessageNames.__COLUMN__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".__COLUMN__" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}__COLUMN__\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20809,18 +15468,16 @@ extension SwiftUnittest_Names_MessageNames.__COLUMN__Message: SwiftProtobuf.Mess try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.__COLUMN__Message, rhs: SwiftUnittest_Names_MessageNames.__COLUMN__Message) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.__COLUMN__Message, rhs: SwiftProtoTesting_Names_MessageNames.__COLUMN__Message) -> Bool { if lhs.__Column__ != rhs.__Column__ {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.__FILE__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".__FILE__" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "__FILE__"), - ] +extension SwiftProtoTesting_Names_MessageNames.__FILE__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".__FILE__" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}__FILE__\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20845,18 +15502,16 @@ extension SwiftUnittest_Names_MessageNames.__FILE__Message: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.__FILE__Message, rhs: SwiftUnittest_Names_MessageNames.__FILE__Message) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.__FILE__Message, rhs: SwiftProtoTesting_Names_MessageNames.__FILE__Message) -> Bool { if lhs.__File__ != rhs.__File__ {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.__FUNCTION__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".__FUNCTION__" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "__FUNCTION__"), - ] +extension SwiftProtoTesting_Names_MessageNames.__FUNCTION__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".__FUNCTION__" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}__FUNCTION__\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20881,18 +15536,16 @@ extension SwiftUnittest_Names_MessageNames.__FUNCTION__Message: SwiftProtobuf.Me try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.__FUNCTION__Message, rhs: SwiftUnittest_Names_MessageNames.__FUNCTION__Message) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.__FUNCTION__Message, rhs: SwiftProtoTesting_Names_MessageNames.__FUNCTION__Message) -> Bool { if lhs.__Function__ != rhs.__Function__ {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.__LINE__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".__LINE__" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "__LINE__"), - ] +extension SwiftProtoTesting_Names_MessageNames.__LINE__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".__LINE__" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}__LINE__\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20917,18 +15570,16 @@ extension SwiftUnittest_Names_MessageNames.__LINE__Message: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.__LINE__Message, rhs: SwiftUnittest_Names_MessageNames.__LINE__Message) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.__LINE__Message, rhs: SwiftProtoTesting_Names_MessageNames.__LINE__Message) -> Bool { if lhs.__Line__ != rhs.__Line__ {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames._Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + "._" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "_"), - ] +extension SwiftProtoTesting_Names_MessageNames._Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + "._" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}_\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20953,18 +15604,16 @@ extension SwiftUnittest_Names_MessageNames._Message: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames._Message, rhs: SwiftUnittest_Names_MessageNames._Message) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames._Message, rhs: SwiftProtoTesting_Names_MessageNames._Message) -> Bool { if lhs.____ != rhs.____ {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".__" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "__"), - ] +extension SwiftProtoTesting_Names_MessageNames.__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".__" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}__\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20989,18 +15638,16 @@ extension SwiftUnittest_Names_MessageNames.__Message: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.__Message, rhs: SwiftUnittest_Names_MessageNames.__Message) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.__Message, rhs: SwiftProtoTesting_Names_MessageNames.__Message) -> Bool { if lhs._____ != rhs._____ {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.associativity: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".associativity" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "associativity"), - ] +extension SwiftProtoTesting_Names_MessageNames.associativity: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".associativity" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}associativity\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21025,18 +15672,16 @@ extension SwiftUnittest_Names_MessageNames.associativity: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.associativity, rhs: SwiftUnittest_Names_MessageNames.associativity) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.associativity, rhs: SwiftProtoTesting_Names_MessageNames.associativity) -> Bool { if lhs._associativity != rhs._associativity {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.convenience: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".convenience" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "convenience"), - ] +extension SwiftProtoTesting_Names_MessageNames.convenience: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".convenience" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}convenience\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21061,18 +15706,16 @@ extension SwiftUnittest_Names_MessageNames.convenience: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.convenience, rhs: SwiftUnittest_Names_MessageNames.convenience) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.convenience, rhs: SwiftProtoTesting_Names_MessageNames.convenience) -> Bool { if lhs._convenience != rhs._convenience {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.dynamic: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".dynamic" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "dynamic"), - ] +extension SwiftProtoTesting_Names_MessageNames.dynamic: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".dynamic" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}dynamic\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21097,18 +15740,16 @@ extension SwiftUnittest_Names_MessageNames.dynamic: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.dynamic, rhs: SwiftUnittest_Names_MessageNames.dynamic) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.dynamic, rhs: SwiftProtoTesting_Names_MessageNames.dynamic) -> Bool { if lhs._dynamic != rhs._dynamic {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.didSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".didSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "didSet"), - ] +extension SwiftProtoTesting_Names_MessageNames.didSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".didSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}didSet\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21133,18 +15774,16 @@ extension SwiftUnittest_Names_MessageNames.didSet: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.didSet, rhs: SwiftUnittest_Names_MessageNames.didSet) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.didSet, rhs: SwiftProtoTesting_Names_MessageNames.didSet) -> Bool { if lhs._didSet != rhs._didSet {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.final: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".final" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "final"), - ] +extension SwiftProtoTesting_Names_MessageNames.final: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".final" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}final\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21169,18 +15808,16 @@ extension SwiftUnittest_Names_MessageNames.final: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.final, rhs: SwiftUnittest_Names_MessageNames.final) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.final, rhs: SwiftProtoTesting_Names_MessageNames.final) -> Bool { if lhs._final != rhs._final {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.get: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".get" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "get"), - ] +extension SwiftProtoTesting_Names_MessageNames.get: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".get" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}get\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21205,18 +15842,16 @@ extension SwiftUnittest_Names_MessageNames.get: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.get, rhs: SwiftUnittest_Names_MessageNames.get) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.get, rhs: SwiftProtoTesting_Names_MessageNames.get) -> Bool { if lhs._get != rhs._get {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.infix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".infix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "infix"), - ] +extension SwiftProtoTesting_Names_MessageNames.infix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".infix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}infix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21241,18 +15876,16 @@ extension SwiftUnittest_Names_MessageNames.infix: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.infix, rhs: SwiftUnittest_Names_MessageNames.infix) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.infix, rhs: SwiftProtoTesting_Names_MessageNames.infix) -> Bool { if lhs._infix != rhs._infix {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.indirect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".indirect" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "indirect"), - ] +extension SwiftProtoTesting_Names_MessageNames.indirect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".indirect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}indirect\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21277,18 +15910,16 @@ extension SwiftUnittest_Names_MessageNames.indirect: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.indirect, rhs: SwiftUnittest_Names_MessageNames.indirect) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.indirect, rhs: SwiftProtoTesting_Names_MessageNames.indirect) -> Bool { if lhs._indirect != rhs._indirect {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.lazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".lazy" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "lazy"), - ] +extension SwiftProtoTesting_Names_MessageNames.lazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".lazy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}lazy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21313,18 +15944,16 @@ extension SwiftUnittest_Names_MessageNames.lazy: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.lazy, rhs: SwiftUnittest_Names_MessageNames.lazy) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.lazy, rhs: SwiftProtoTesting_Names_MessageNames.lazy) -> Bool { if lhs._lazy != rhs._lazy {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.left: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".left" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "left"), - ] +extension SwiftProtoTesting_Names_MessageNames.left: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".left" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}left\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21349,18 +15978,16 @@ extension SwiftUnittest_Names_MessageNames.left: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.left, rhs: SwiftUnittest_Names_MessageNames.left) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.left, rhs: SwiftProtoTesting_Names_MessageNames.left) -> Bool { if lhs._left != rhs._left {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.mutating: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".mutating" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mutating"), - ] +extension SwiftProtoTesting_Names_MessageNames.mutating: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".mutating" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mutating\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21385,18 +16012,16 @@ extension SwiftUnittest_Names_MessageNames.mutating: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.mutating, rhs: SwiftUnittest_Names_MessageNames.mutating) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.mutating, rhs: SwiftProtoTesting_Names_MessageNames.mutating) -> Bool { if lhs._mutating != rhs._mutating {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.none: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".none" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "none"), - ] +extension SwiftProtoTesting_Names_MessageNames.none: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".none" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}none\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21421,18 +16046,16 @@ extension SwiftUnittest_Names_MessageNames.none: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.none, rhs: SwiftUnittest_Names_MessageNames.none) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.none, rhs: SwiftProtoTesting_Names_MessageNames.none) -> Bool { if lhs._none != rhs._none {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.nonmutating: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".nonmutating" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nonmutating"), - ] +extension SwiftProtoTesting_Names_MessageNames.nonmutating: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".nonmutating" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nonmutating\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21457,18 +16080,16 @@ extension SwiftUnittest_Names_MessageNames.nonmutating: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.nonmutating, rhs: SwiftUnittest_Names_MessageNames.nonmutating) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.nonmutating, rhs: SwiftProtoTesting_Names_MessageNames.nonmutating) -> Bool { if lhs._nonmutating != rhs._nonmutating {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".optional" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "optional"), - ] +extension SwiftProtoTesting_Names_MessageNames.optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".optional" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}optional\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21493,18 +16114,16 @@ extension SwiftUnittest_Names_MessageNames.optional: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.optional, rhs: SwiftUnittest_Names_MessageNames.optional) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.optional, rhs: SwiftProtoTesting_Names_MessageNames.optional) -> Bool { if lhs._optional != rhs._optional {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.override: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".override" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "override"), - ] +extension SwiftProtoTesting_Names_MessageNames.override: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".override" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}override\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21529,18 +16148,16 @@ extension SwiftUnittest_Names_MessageNames.override: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.override, rhs: SwiftUnittest_Names_MessageNames.override) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.override, rhs: SwiftProtoTesting_Names_MessageNames.override) -> Bool { if lhs._override != rhs._override {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.postfix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".postfix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "postfix"), - ] +extension SwiftProtoTesting_Names_MessageNames.postfix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".postfix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}postfix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21565,18 +16182,16 @@ extension SwiftUnittest_Names_MessageNames.postfix: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.postfix, rhs: SwiftUnittest_Names_MessageNames.postfix) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.postfix, rhs: SwiftProtoTesting_Names_MessageNames.postfix) -> Bool { if lhs._postfix != rhs._postfix {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.precedence: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".precedence" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "precedence"), - ] +extension SwiftProtoTesting_Names_MessageNames.precedence: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".precedence" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}precedence\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21601,18 +16216,16 @@ extension SwiftUnittest_Names_MessageNames.precedence: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.precedence, rhs: SwiftUnittest_Names_MessageNames.precedence) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.precedence, rhs: SwiftProtoTesting_Names_MessageNames.precedence) -> Bool { if lhs._precedence != rhs._precedence {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.prefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".prefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "prefix"), - ] +extension SwiftProtoTesting_Names_MessageNames.prefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".prefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}prefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21637,18 +16250,16 @@ extension SwiftUnittest_Names_MessageNames.prefix: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.prefix, rhs: SwiftUnittest_Names_MessageNames.prefix) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.prefix, rhs: SwiftProtoTesting_Names_MessageNames.prefix) -> Bool { if lhs._prefix != rhs._prefix {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.required: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".required" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "required"), - ] +extension SwiftProtoTesting_Names_MessageNames.required: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".required" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}required\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21673,18 +16284,16 @@ extension SwiftUnittest_Names_MessageNames.required: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.required, rhs: SwiftUnittest_Names_MessageNames.required) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.required, rhs: SwiftProtoTesting_Names_MessageNames.required) -> Bool { if lhs._required != rhs._required {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.right: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".right" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "right"), - ] +extension SwiftProtoTesting_Names_MessageNames.right: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".right" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}right\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21709,18 +16318,16 @@ extension SwiftUnittest_Names_MessageNames.right: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.right, rhs: SwiftUnittest_Names_MessageNames.right) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.right, rhs: SwiftProtoTesting_Names_MessageNames.right) -> Bool { if lhs._right != rhs._right {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.set: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".set" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "set"), - ] +extension SwiftProtoTesting_Names_MessageNames.set: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".set" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}set\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21745,18 +16352,16 @@ extension SwiftUnittest_Names_MessageNames.set: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.set, rhs: SwiftUnittest_Names_MessageNames.set) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.set, rhs: SwiftProtoTesting_Names_MessageNames.set) -> Bool { if lhs._set != rhs._set {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.TypeMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Type" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Type"), - ] +extension SwiftProtoTesting_Names_MessageNames.TypeMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Type" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Type\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21781,18 +16386,16 @@ extension SwiftUnittest_Names_MessageNames.TypeMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.TypeMessage, rhs: SwiftUnittest_Names_MessageNames.TypeMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.TypeMessage, rhs: SwiftProtoTesting_Names_MessageNames.TypeMessage) -> Bool { if lhs._type != rhs._type {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.unowned: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".unowned" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "unowned"), - ] +extension SwiftProtoTesting_Names_MessageNames.unowned: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".unowned" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unowned\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21817,18 +16420,16 @@ extension SwiftUnittest_Names_MessageNames.unowned: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.unowned, rhs: SwiftUnittest_Names_MessageNames.unowned) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.unowned, rhs: SwiftProtoTesting_Names_MessageNames.unowned) -> Bool { if lhs._unowned != rhs._unowned {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.weak: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".weak" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "weak"), - ] +extension SwiftProtoTesting_Names_MessageNames.weak: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".weak" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}weak\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21853,18 +16454,16 @@ extension SwiftUnittest_Names_MessageNames.weak: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.weak, rhs: SwiftUnittest_Names_MessageNames.weak) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.weak, rhs: SwiftProtoTesting_Names_MessageNames.weak) -> Bool { if lhs._weak != rhs._weak {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.willSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".willSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "willSet"), - ] +extension SwiftProtoTesting_Names_MessageNames.willSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".willSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}willSet\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21889,18 +16488,16 @@ extension SwiftUnittest_Names_MessageNames.willSet: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.willSet, rhs: SwiftUnittest_Names_MessageNames.willSet) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.willSet, rhs: SwiftProtoTesting_Names_MessageNames.willSet) -> Bool { if lhs._willSet != rhs._willSet {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.id: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".id" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "id"), - ] +extension SwiftProtoTesting_Names_MessageNames.id: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".id" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21925,18 +16522,16 @@ extension SwiftUnittest_Names_MessageNames.id: SwiftProtobuf.Message, SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.id, rhs: SwiftUnittest_Names_MessageNames.id) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.id, rhs: SwiftProtoTesting_Names_MessageNames.id) -> Bool { if lhs._id != rhs._id {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames._cmd: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + "._cmd" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "_cmd"), - ] +extension SwiftProtoTesting_Names_MessageNames._cmd: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + "._cmd" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}_cmd\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21961,18 +16556,16 @@ extension SwiftUnittest_Names_MessageNames._cmd: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames._cmd, rhs: SwiftUnittest_Names_MessageNames._cmd) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames._cmd, rhs: SwiftProtoTesting_Names_MessageNames._cmd) -> Bool { if lhs._cmd != rhs._cmd {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.out: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".out" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "out"), - ] +extension SwiftProtoTesting_Names_MessageNames.out: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".out" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}out\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21997,18 +16590,16 @@ extension SwiftUnittest_Names_MessageNames.out: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.out, rhs: SwiftUnittest_Names_MessageNames.out) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.out, rhs: SwiftProtoTesting_Names_MessageNames.out) -> Bool { if lhs._out != rhs._out {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.bycopy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".bycopy" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bycopy"), - ] +extension SwiftProtoTesting_Names_MessageNames.bycopy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".bycopy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bycopy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22033,18 +16624,16 @@ extension SwiftUnittest_Names_MessageNames.bycopy: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.bycopy, rhs: SwiftUnittest_Names_MessageNames.bycopy) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.bycopy, rhs: SwiftProtoTesting_Names_MessageNames.bycopy) -> Bool { if lhs._bycopy != rhs._bycopy {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.byref: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".byref" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "byref"), - ] +extension SwiftProtoTesting_Names_MessageNames.byref: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".byref" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}byref\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22069,18 +16658,16 @@ extension SwiftUnittest_Names_MessageNames.byref: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.byref, rhs: SwiftUnittest_Names_MessageNames.byref) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.byref, rhs: SwiftProtoTesting_Names_MessageNames.byref) -> Bool { if lhs._byref != rhs._byref {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.oneway: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".oneway" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "oneway"), - ] +extension SwiftProtoTesting_Names_MessageNames.oneway: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".oneway" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}oneway\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22105,18 +16692,16 @@ extension SwiftUnittest_Names_MessageNames.oneway: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.oneway, rhs: SwiftUnittest_Names_MessageNames.oneway) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.oneway, rhs: SwiftProtoTesting_Names_MessageNames.oneway) -> Bool { if lhs._oneway != rhs._oneway {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.and: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".and" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "and"), - ] +extension SwiftProtoTesting_Names_MessageNames.and: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".and" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}and\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22141,18 +16726,16 @@ extension SwiftUnittest_Names_MessageNames.and: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.and, rhs: SwiftUnittest_Names_MessageNames.and) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.and, rhs: SwiftProtoTesting_Names_MessageNames.and) -> Bool { if lhs._and != rhs._and {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.and_eq: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".and_eq" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "and_eq"), - ] +extension SwiftProtoTesting_Names_MessageNames.and_eq: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".and_eq" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}and_eq\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22177,18 +16760,16 @@ extension SwiftUnittest_Names_MessageNames.and_eq: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.and_eq, rhs: SwiftUnittest_Names_MessageNames.and_eq) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.and_eq, rhs: SwiftProtoTesting_Names_MessageNames.and_eq) -> Bool { if lhs._andEq != rhs._andEq {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.alignas: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".alignas" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "alignas"), - ] +extension SwiftProtoTesting_Names_MessageNames.alignas: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".alignas" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}alignas\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22213,18 +16794,16 @@ extension SwiftUnittest_Names_MessageNames.alignas: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.alignas, rhs: SwiftUnittest_Names_MessageNames.alignas) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.alignas, rhs: SwiftProtoTesting_Names_MessageNames.alignas) -> Bool { if lhs._alignas != rhs._alignas {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.alignof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".alignof" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "alignof"), - ] +extension SwiftProtoTesting_Names_MessageNames.alignof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".alignof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}alignof\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22249,18 +16828,16 @@ extension SwiftUnittest_Names_MessageNames.alignof: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.alignof, rhs: SwiftUnittest_Names_MessageNames.alignof) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.alignof, rhs: SwiftProtoTesting_Names_MessageNames.alignof) -> Bool { if lhs._alignof != rhs._alignof {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.asm: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".asm" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "asm"), - ] +extension SwiftProtoTesting_Names_MessageNames.asm: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".asm" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}asm\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22285,18 +16862,16 @@ extension SwiftUnittest_Names_MessageNames.asm: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.asm, rhs: SwiftUnittest_Names_MessageNames.asm) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.asm, rhs: SwiftProtoTesting_Names_MessageNames.asm) -> Bool { if lhs._asm != rhs._asm {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.auto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".auto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "auto"), - ] +extension SwiftProtoTesting_Names_MessageNames.auto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".auto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}auto\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22321,18 +16896,16 @@ extension SwiftUnittest_Names_MessageNames.auto: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.auto, rhs: SwiftUnittest_Names_MessageNames.auto) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.auto, rhs: SwiftProtoTesting_Names_MessageNames.auto) -> Bool { if lhs._auto != rhs._auto {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.bitand: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".bitand" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bitand"), - ] +extension SwiftProtoTesting_Names_MessageNames.bitand: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".bitand" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bitand\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22357,18 +16930,16 @@ extension SwiftUnittest_Names_MessageNames.bitand: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.bitand, rhs: SwiftUnittest_Names_MessageNames.bitand) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.bitand, rhs: SwiftProtoTesting_Names_MessageNames.bitand) -> Bool { if lhs._bitand != rhs._bitand {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.bitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".bitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bitor"), - ] +extension SwiftProtoTesting_Names_MessageNames.bitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".bitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22393,18 +16964,16 @@ extension SwiftUnittest_Names_MessageNames.bitor: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.bitor, rhs: SwiftUnittest_Names_MessageNames.bitor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.bitor, rhs: SwiftProtoTesting_Names_MessageNames.bitor) -> Bool { if lhs._bitor != rhs._bitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.bool: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".bool" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bool"), - ] +extension SwiftProtoTesting_Names_MessageNames.bool: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".bool" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bool\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22429,18 +16998,16 @@ extension SwiftUnittest_Names_MessageNames.bool: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.bool, rhs: SwiftUnittest_Names_MessageNames.bool) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.bool, rhs: SwiftProtoTesting_Names_MessageNames.bool) -> Bool { if lhs._bool != rhs._bool {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.char: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".char" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "char"), - ] +extension SwiftProtoTesting_Names_MessageNames.char: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".char" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}char\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22465,18 +17032,16 @@ extension SwiftUnittest_Names_MessageNames.char: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.char, rhs: SwiftUnittest_Names_MessageNames.char) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.char, rhs: SwiftProtoTesting_Names_MessageNames.char) -> Bool { if lhs._char != rhs._char {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.char16_t: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".char16_t" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "char16_t"), - ] +extension SwiftProtoTesting_Names_MessageNames.char16_t: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".char16_t" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}char16_t\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22501,18 +17066,16 @@ extension SwiftUnittest_Names_MessageNames.char16_t: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.char16_t, rhs: SwiftUnittest_Names_MessageNames.char16_t) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.char16_t, rhs: SwiftProtoTesting_Names_MessageNames.char16_t) -> Bool { if lhs._char16T != rhs._char16T {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.char32_t: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".char32_t" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "char32_t"), - ] +extension SwiftProtoTesting_Names_MessageNames.char32_t: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".char32_t" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}char32_t\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22537,18 +17100,16 @@ extension SwiftUnittest_Names_MessageNames.char32_t: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.char32_t, rhs: SwiftUnittest_Names_MessageNames.char32_t) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.char32_t, rhs: SwiftProtoTesting_Names_MessageNames.char32_t) -> Bool { if lhs._char32T != rhs._char32T {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.compl: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".compl" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "compl"), - ] +extension SwiftProtoTesting_Names_MessageNames.compl: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".compl" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}compl\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22573,18 +17134,16 @@ extension SwiftUnittest_Names_MessageNames.compl: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.compl, rhs: SwiftUnittest_Names_MessageNames.compl) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.compl, rhs: SwiftProtoTesting_Names_MessageNames.compl) -> Bool { if lhs._compl != rhs._compl {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.const: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".const" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "const"), - ] +extension SwiftProtoTesting_Names_MessageNames.const: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".const" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}const\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22609,18 +17168,16 @@ extension SwiftUnittest_Names_MessageNames.const: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.const, rhs: SwiftUnittest_Names_MessageNames.const) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.const, rhs: SwiftProtoTesting_Names_MessageNames.const) -> Bool { if lhs._const != rhs._const {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.constexpr: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".constexpr" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "constexpr"), - ] +extension SwiftProtoTesting_Names_MessageNames.constexpr: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".constexpr" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}constexpr\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22645,18 +17202,16 @@ extension SwiftUnittest_Names_MessageNames.constexpr: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.constexpr, rhs: SwiftUnittest_Names_MessageNames.constexpr) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.constexpr, rhs: SwiftProtoTesting_Names_MessageNames.constexpr) -> Bool { if lhs._constexpr != rhs._constexpr {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.const_cast: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".const_cast" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "const_cast"), - ] +extension SwiftProtoTesting_Names_MessageNames.const_cast: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".const_cast" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}const_cast\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22681,18 +17236,16 @@ extension SwiftUnittest_Names_MessageNames.const_cast: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.const_cast, rhs: SwiftUnittest_Names_MessageNames.const_cast) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.const_cast, rhs: SwiftProtoTesting_Names_MessageNames.const_cast) -> Bool { if lhs._constCast != rhs._constCast {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.decltype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".decltype" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decltype"), - ] +extension SwiftProtoTesting_Names_MessageNames.decltype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".decltype" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decltype\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22717,18 +17270,16 @@ extension SwiftUnittest_Names_MessageNames.decltype: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.decltype, rhs: SwiftUnittest_Names_MessageNames.decltype) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.decltype, rhs: SwiftProtoTesting_Names_MessageNames.decltype) -> Bool { if lhs._decltype != rhs._decltype {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.delete: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".delete" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "delete"), - ] +extension SwiftProtoTesting_Names_MessageNames.delete: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".delete" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}delete\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22753,18 +17304,16 @@ extension SwiftUnittest_Names_MessageNames.delete: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.delete, rhs: SwiftUnittest_Names_MessageNames.delete) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.delete, rhs: SwiftProtoTesting_Names_MessageNames.delete) -> Bool { if lhs._delete != rhs._delete {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.dynamic_cast: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".dynamic_cast" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "dynamic_cast"), - ] +extension SwiftProtoTesting_Names_MessageNames.dynamic_cast: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".dynamic_cast" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}dynamic_cast\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22789,18 +17338,16 @@ extension SwiftUnittest_Names_MessageNames.dynamic_cast: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.dynamic_cast, rhs: SwiftUnittest_Names_MessageNames.dynamic_cast) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.dynamic_cast, rhs: SwiftProtoTesting_Names_MessageNames.dynamic_cast) -> Bool { if lhs._dynamicCast != rhs._dynamicCast {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.explicit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".explicit" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "explicit"), - ] +extension SwiftProtoTesting_Names_MessageNames.explicit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".explicit" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}explicit\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22825,18 +17372,16 @@ extension SwiftUnittest_Names_MessageNames.explicit: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.explicit, rhs: SwiftUnittest_Names_MessageNames.explicit) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.explicit, rhs: SwiftProtoTesting_Names_MessageNames.explicit) -> Bool { if lhs._explicit != rhs._explicit {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.export: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".export" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "export"), - ] +extension SwiftProtoTesting_Names_MessageNames.export: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".export" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}export\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22861,18 +17406,16 @@ extension SwiftUnittest_Names_MessageNames.export: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.export, rhs: SwiftUnittest_Names_MessageNames.export) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.export, rhs: SwiftProtoTesting_Names_MessageNames.export) -> Bool { if lhs._export != rhs._export {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.extern: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".extern" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extern"), - ] +extension SwiftProtoTesting_Names_MessageNames.extern: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".extern" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extern\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22897,18 +17440,16 @@ extension SwiftUnittest_Names_MessageNames.extern: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.extern, rhs: SwiftUnittest_Names_MessageNames.extern) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.extern, rhs: SwiftProtoTesting_Names_MessageNames.extern) -> Bool { if lhs._extern != rhs._extern {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.friend: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".friend" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "friend"), - ] +extension SwiftProtoTesting_Names_MessageNames.friend: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".friend" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}friend\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22933,18 +17474,16 @@ extension SwiftUnittest_Names_MessageNames.friend: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.friend, rhs: SwiftUnittest_Names_MessageNames.friend) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.friend, rhs: SwiftProtoTesting_Names_MessageNames.friend) -> Bool { if lhs._friend != rhs._friend {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.goto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".goto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "goto"), - ] +extension SwiftProtoTesting_Names_MessageNames.goto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".goto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}goto\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22969,18 +17508,16 @@ extension SwiftUnittest_Names_MessageNames.goto: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.goto, rhs: SwiftUnittest_Names_MessageNames.goto) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.goto, rhs: SwiftProtoTesting_Names_MessageNames.goto) -> Bool { if lhs._goto != rhs._goto {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.inline: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".inline" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "inline"), - ] +extension SwiftProtoTesting_Names_MessageNames.inline: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".inline" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}inline\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23005,18 +17542,16 @@ extension SwiftUnittest_Names_MessageNames.inline: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.inline, rhs: SwiftUnittest_Names_MessageNames.inline) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.inline, rhs: SwiftProtoTesting_Names_MessageNames.inline) -> Bool { if lhs._inline != rhs._inline {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.long: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".long" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "long"), - ] +extension SwiftProtoTesting_Names_MessageNames.long: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".long" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}long\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23041,18 +17576,16 @@ extension SwiftUnittest_Names_MessageNames.long: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.long, rhs: SwiftUnittest_Names_MessageNames.long) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.long, rhs: SwiftProtoTesting_Names_MessageNames.long) -> Bool { if lhs._long != rhs._long {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.mutable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".mutable" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mutable"), - ] +extension SwiftProtoTesting_Names_MessageNames.mutable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".mutable" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mutable\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23077,18 +17610,16 @@ extension SwiftUnittest_Names_MessageNames.mutable: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.mutable, rhs: SwiftUnittest_Names_MessageNames.mutable) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.mutable, rhs: SwiftProtoTesting_Names_MessageNames.mutable) -> Bool { if lhs._mutable != rhs._mutable {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.namespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".namespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "namespace"), - ] +extension SwiftProtoTesting_Names_MessageNames.namespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".namespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}namespace\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23113,18 +17644,16 @@ extension SwiftUnittest_Names_MessageNames.namespace: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.namespace, rhs: SwiftUnittest_Names_MessageNames.namespace) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.namespace, rhs: SwiftProtoTesting_Names_MessageNames.namespace) -> Bool { if lhs._namespace != rhs._namespace {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.new: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".new" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "new"), - ] +extension SwiftProtoTesting_Names_MessageNames.new: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".new" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}new\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23149,18 +17678,16 @@ extension SwiftUnittest_Names_MessageNames.new: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.new, rhs: SwiftUnittest_Names_MessageNames.new) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.new, rhs: SwiftProtoTesting_Names_MessageNames.new) -> Bool { if lhs._new != rhs._new {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.noexcept: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".noexcept" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "noexcept"), - ] +extension SwiftProtoTesting_Names_MessageNames.noexcept: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".noexcept" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}noexcept\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23185,18 +17712,16 @@ extension SwiftUnittest_Names_MessageNames.noexcept: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.noexcept, rhs: SwiftUnittest_Names_MessageNames.noexcept) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.noexcept, rhs: SwiftProtoTesting_Names_MessageNames.noexcept) -> Bool { if lhs._noexcept != rhs._noexcept {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.not: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".not" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "not"), - ] +extension SwiftProtoTesting_Names_MessageNames.not: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".not" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}not\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23221,18 +17746,16 @@ extension SwiftUnittest_Names_MessageNames.not: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.not, rhs: SwiftUnittest_Names_MessageNames.not) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.not, rhs: SwiftProtoTesting_Names_MessageNames.not) -> Bool { if lhs._not != rhs._not {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.not_eq: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".not_eq" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "not_eq"), - ] +extension SwiftProtoTesting_Names_MessageNames.not_eq: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".not_eq" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}not_eq\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23257,18 +17780,16 @@ extension SwiftUnittest_Names_MessageNames.not_eq: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.not_eq, rhs: SwiftUnittest_Names_MessageNames.not_eq) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.not_eq, rhs: SwiftProtoTesting_Names_MessageNames.not_eq) -> Bool { if lhs._notEq != rhs._notEq {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.nullptr: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".nullptr" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nullptr"), - ] +extension SwiftProtoTesting_Names_MessageNames.nullptr: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".nullptr" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nullptr\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23293,18 +17814,16 @@ extension SwiftUnittest_Names_MessageNames.nullptr: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.nullptr, rhs: SwiftUnittest_Names_MessageNames.nullptr) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.nullptr, rhs: SwiftProtoTesting_Names_MessageNames.nullptr) -> Bool { if lhs._nullptr != rhs._nullptr {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.or: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".or" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "or"), - ] +extension SwiftProtoTesting_Names_MessageNames.or: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".or" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}or\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23329,18 +17848,16 @@ extension SwiftUnittest_Names_MessageNames.or: SwiftProtobuf.Message, SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.or, rhs: SwiftUnittest_Names_MessageNames.or) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.or, rhs: SwiftProtoTesting_Names_MessageNames.or) -> Bool { if lhs._or != rhs._or {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.or_eq: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".or_eq" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "or_eq"), - ] +extension SwiftProtoTesting_Names_MessageNames.or_eq: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".or_eq" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}or_eq\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23365,18 +17882,16 @@ extension SwiftUnittest_Names_MessageNames.or_eq: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.or_eq, rhs: SwiftUnittest_Names_MessageNames.or_eq) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.or_eq, rhs: SwiftProtoTesting_Names_MessageNames.or_eq) -> Bool { if lhs._orEq != rhs._orEq {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.protected: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".protected" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "protected"), - ] +extension SwiftProtoTesting_Names_MessageNames.protected: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".protected" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}protected\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23401,18 +17916,16 @@ extension SwiftUnittest_Names_MessageNames.protected: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.protected, rhs: SwiftUnittest_Names_MessageNames.protected) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.protected, rhs: SwiftProtoTesting_Names_MessageNames.protected) -> Bool { if lhs._protected != rhs._protected {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.register: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".register" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "register"), - ] +extension SwiftProtoTesting_Names_MessageNames.register: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".register" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}register\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23437,18 +17950,16 @@ extension SwiftUnittest_Names_MessageNames.register: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.register, rhs: SwiftUnittest_Names_MessageNames.register) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.register, rhs: SwiftProtoTesting_Names_MessageNames.register) -> Bool { if lhs._register != rhs._register {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.reinterpret_cast: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".reinterpret_cast" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "reinterpret_cast"), - ] +extension SwiftProtoTesting_Names_MessageNames.reinterpret_cast: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".reinterpret_cast" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}reinterpret_cast\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23473,18 +17984,16 @@ extension SwiftUnittest_Names_MessageNames.reinterpret_cast: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.reinterpret_cast, rhs: SwiftUnittest_Names_MessageNames.reinterpret_cast) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.reinterpret_cast, rhs: SwiftProtoTesting_Names_MessageNames.reinterpret_cast) -> Bool { if lhs._reinterpretCast != rhs._reinterpretCast {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.short: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".short" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "short"), - ] +extension SwiftProtoTesting_Names_MessageNames.short: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".short" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}short\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23509,18 +18018,16 @@ extension SwiftUnittest_Names_MessageNames.short: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.short, rhs: SwiftUnittest_Names_MessageNames.short) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.short, rhs: SwiftProtoTesting_Names_MessageNames.short) -> Bool { if lhs._short != rhs._short {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.signed: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".signed" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "signed"), - ] +extension SwiftProtoTesting_Names_MessageNames.signed: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".signed" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}signed\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23545,18 +18052,16 @@ extension SwiftUnittest_Names_MessageNames.signed: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.signed, rhs: SwiftUnittest_Names_MessageNames.signed) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.signed, rhs: SwiftProtoTesting_Names_MessageNames.signed) -> Bool { if lhs._signed != rhs._signed {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.sizeof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".sizeof" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sizeof"), - ] +extension SwiftProtoTesting_Names_MessageNames.sizeof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".sizeof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sizeof\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23581,18 +18086,16 @@ extension SwiftUnittest_Names_MessageNames.sizeof: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.sizeof, rhs: SwiftUnittest_Names_MessageNames.sizeof) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.sizeof, rhs: SwiftProtoTesting_Names_MessageNames.sizeof) -> Bool { if lhs._sizeof != rhs._sizeof {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.static_assert: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".static_assert" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "static_assert"), - ] +extension SwiftProtoTesting_Names_MessageNames.static_assert: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".static_assert" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}static_assert\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23617,18 +18120,16 @@ extension SwiftUnittest_Names_MessageNames.static_assert: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.static_assert, rhs: SwiftUnittest_Names_MessageNames.static_assert) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.static_assert, rhs: SwiftProtoTesting_Names_MessageNames.static_assert) -> Bool { if lhs._staticAssert != rhs._staticAssert {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.static_cast: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".static_cast" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "static_cast"), - ] +extension SwiftProtoTesting_Names_MessageNames.static_cast: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".static_cast" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}static_cast\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23653,18 +18154,16 @@ extension SwiftUnittest_Names_MessageNames.static_cast: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.static_cast, rhs: SwiftUnittest_Names_MessageNames.static_cast) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.static_cast, rhs: SwiftProtoTesting_Names_MessageNames.static_cast) -> Bool { if lhs._staticCast != rhs._staticCast {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.template: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".template" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "template"), - ] +extension SwiftProtoTesting_Names_MessageNames.template: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".template" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}template\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23689,18 +18188,16 @@ extension SwiftUnittest_Names_MessageNames.template: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.template, rhs: SwiftUnittest_Names_MessageNames.template) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.template, rhs: SwiftProtoTesting_Names_MessageNames.template) -> Bool { if lhs._template != rhs._template {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.this: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".this" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "this"), - ] +extension SwiftProtoTesting_Names_MessageNames.this: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".this" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}this\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23725,18 +18222,16 @@ extension SwiftUnittest_Names_MessageNames.this: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.this, rhs: SwiftUnittest_Names_MessageNames.this) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.this, rhs: SwiftProtoTesting_Names_MessageNames.this) -> Bool { if lhs._this != rhs._this {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.thread_local: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".thread_local" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "thread_local"), - ] +extension SwiftProtoTesting_Names_MessageNames.thread_local: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".thread_local" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}thread_local\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23761,18 +18256,16 @@ extension SwiftUnittest_Names_MessageNames.thread_local: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.thread_local, rhs: SwiftUnittest_Names_MessageNames.thread_local) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.thread_local, rhs: SwiftProtoTesting_Names_MessageNames.thread_local) -> Bool { if lhs._threadLocal != rhs._threadLocal {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.typedef: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".typedef" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typedef"), - ] +extension SwiftProtoTesting_Names_MessageNames.typedef: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".typedef" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typedef\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23797,18 +18290,16 @@ extension SwiftUnittest_Names_MessageNames.typedef: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.typedef, rhs: SwiftUnittest_Names_MessageNames.typedef) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.typedef, rhs: SwiftProtoTesting_Names_MessageNames.typedef) -> Bool { if lhs._typedef != rhs._typedef {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.typeid: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".typeid" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typeid"), - ] +extension SwiftProtoTesting_Names_MessageNames.typeid: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".typeid" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typeid\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23833,18 +18324,16 @@ extension SwiftUnittest_Names_MessageNames.typeid: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.typeid, rhs: SwiftUnittest_Names_MessageNames.typeid) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.typeid, rhs: SwiftProtoTesting_Names_MessageNames.typeid) -> Bool { if lhs._typeid != rhs._typeid {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.typename: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".typename" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typename"), - ] +extension SwiftProtoTesting_Names_MessageNames.typename: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".typename" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typename\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23869,18 +18358,16 @@ extension SwiftUnittest_Names_MessageNames.typename: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.typename, rhs: SwiftUnittest_Names_MessageNames.typename) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.typename, rhs: SwiftProtoTesting_Names_MessageNames.typename) -> Bool { if lhs._typename != rhs._typename {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.union: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".union" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "union"), - ] +extension SwiftProtoTesting_Names_MessageNames.union: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".union" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}union\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23905,18 +18392,16 @@ extension SwiftUnittest_Names_MessageNames.union: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.union, rhs: SwiftUnittest_Names_MessageNames.union) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.union, rhs: SwiftProtoTesting_Names_MessageNames.union) -> Bool { if lhs._union != rhs._union {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.unsigned: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".unsigned" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "unsigned"), - ] +extension SwiftProtoTesting_Names_MessageNames.unsigned: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".unsigned" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unsigned\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23941,18 +18426,16 @@ extension SwiftUnittest_Names_MessageNames.unsigned: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.unsigned, rhs: SwiftUnittest_Names_MessageNames.unsigned) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.unsigned, rhs: SwiftProtoTesting_Names_MessageNames.unsigned) -> Bool { if lhs._unsigned != rhs._unsigned {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.using: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".using" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "using"), - ] +extension SwiftProtoTesting_Names_MessageNames.using: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".using" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}using\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23977,18 +18460,16 @@ extension SwiftUnittest_Names_MessageNames.using: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.using, rhs: SwiftUnittest_Names_MessageNames.using) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.using, rhs: SwiftProtoTesting_Names_MessageNames.using) -> Bool { if lhs._using != rhs._using {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.virtual: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".virtual" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "virtual"), - ] +extension SwiftProtoTesting_Names_MessageNames.virtual: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".virtual" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}virtual\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24013,18 +18494,16 @@ extension SwiftUnittest_Names_MessageNames.virtual: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.virtual, rhs: SwiftUnittest_Names_MessageNames.virtual) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.virtual, rhs: SwiftProtoTesting_Names_MessageNames.virtual) -> Bool { if lhs._virtual != rhs._virtual {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.void: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".void" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "void"), - ] +extension SwiftProtoTesting_Names_MessageNames.void: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".void" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}void\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24049,18 +18528,16 @@ extension SwiftUnittest_Names_MessageNames.void: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.void, rhs: SwiftUnittest_Names_MessageNames.void) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.void, rhs: SwiftProtoTesting_Names_MessageNames.void) -> Bool { if lhs._void != rhs._void {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.volatile: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".volatile" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "volatile"), - ] +extension SwiftProtoTesting_Names_MessageNames.volatile: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".volatile" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}volatile\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24085,18 +18562,16 @@ extension SwiftUnittest_Names_MessageNames.volatile: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.volatile, rhs: SwiftUnittest_Names_MessageNames.volatile) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.volatile, rhs: SwiftProtoTesting_Names_MessageNames.volatile) -> Bool { if lhs._volatile != rhs._volatile {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.wchar_t: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".wchar_t" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "wchar_t"), - ] +extension SwiftProtoTesting_Names_MessageNames.wchar_t: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".wchar_t" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}wchar_t\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24121,18 +18596,16 @@ extension SwiftUnittest_Names_MessageNames.wchar_t: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.wchar_t, rhs: SwiftUnittest_Names_MessageNames.wchar_t) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.wchar_t, rhs: SwiftProtoTesting_Names_MessageNames.wchar_t) -> Bool { if lhs._wcharT != rhs._wcharT {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.xor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".xor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "xor"), - ] +extension SwiftProtoTesting_Names_MessageNames.xor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".xor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}xor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24157,18 +18630,16 @@ extension SwiftUnittest_Names_MessageNames.xor: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.xor, rhs: SwiftUnittest_Names_MessageNames.xor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.xor, rhs: SwiftProtoTesting_Names_MessageNames.xor) -> Bool { if lhs._xor != rhs._xor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.xor_eq: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".xor_eq" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "xor_eq"), - ] +extension SwiftProtoTesting_Names_MessageNames.xor_eq: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".xor_eq" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}xor_eq\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24193,18 +18664,16 @@ extension SwiftUnittest_Names_MessageNames.xor_eq: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.xor_eq, rhs: SwiftUnittest_Names_MessageNames.xor_eq) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.xor_eq, rhs: SwiftProtoTesting_Names_MessageNames.xor_eq) -> Bool { if lhs._xorEq != rhs._xorEq {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.restrict: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".restrict" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "restrict"), - ] +extension SwiftProtoTesting_Names_MessageNames.restrict: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".restrict" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}restrict\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24229,18 +18698,16 @@ extension SwiftUnittest_Names_MessageNames.restrict: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.restrict, rhs: SwiftUnittest_Names_MessageNames.restrict) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.restrict, rhs: SwiftProtoTesting_Names_MessageNames.restrict) -> Bool { if lhs._restrict != rhs._restrict {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Category: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Category" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Category"), - ] +extension SwiftProtoTesting_Names_MessageNames.Category: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Category" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Category\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24265,18 +18732,16 @@ extension SwiftUnittest_Names_MessageNames.Category: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Category, rhs: SwiftUnittest_Names_MessageNames.Category) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Category, rhs: SwiftProtoTesting_Names_MessageNames.Category) -> Bool { if lhs._category != rhs._category {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Ivar: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Ivar" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Ivar"), - ] +extension SwiftProtoTesting_Names_MessageNames.Ivar: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Ivar" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Ivar\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24301,18 +18766,16 @@ extension SwiftUnittest_Names_MessageNames.Ivar: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Ivar, rhs: SwiftUnittest_Names_MessageNames.Ivar) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Ivar, rhs: SwiftProtoTesting_Names_MessageNames.Ivar) -> Bool { if lhs._ivar != rhs._ivar {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Method: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Method" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Method"), - ] +extension SwiftProtoTesting_Names_MessageNames.Method: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Method" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Method\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24337,18 +18800,16 @@ extension SwiftUnittest_Names_MessageNames.Method: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Method, rhs: SwiftUnittest_Names_MessageNames.Method) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Method, rhs: SwiftProtoTesting_Names_MessageNames.Method) -> Bool { if lhs._method != rhs._method {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.finalize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".finalize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "finalize"), - ] +extension SwiftProtoTesting_Names_MessageNames.finalize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".finalize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}finalize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24373,18 +18834,16 @@ extension SwiftUnittest_Names_MessageNames.finalize: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.finalize, rhs: SwiftUnittest_Names_MessageNames.finalize) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.finalize, rhs: SwiftProtoTesting_Names_MessageNames.finalize) -> Bool { if lhs._finalize != rhs._finalize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.hash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".hash" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hash"), - ] +extension SwiftProtoTesting_Names_MessageNames.hash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".hash" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hash\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24409,18 +18868,16 @@ extension SwiftUnittest_Names_MessageNames.hash: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.hash, rhs: SwiftUnittest_Names_MessageNames.hash) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.hash, rhs: SwiftProtoTesting_Names_MessageNames.hash) -> Bool { if lhs._hash != rhs._hash {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.dealloc: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".dealloc" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "dealloc"), - ] +extension SwiftProtoTesting_Names_MessageNames.dealloc: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".dealloc" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}dealloc\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24445,18 +18902,16 @@ extension SwiftUnittest_Names_MessageNames.dealloc: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.dealloc, rhs: SwiftUnittest_Names_MessageNames.dealloc) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.dealloc, rhs: SwiftProtoTesting_Names_MessageNames.dealloc) -> Bool { if lhs._dealloc != rhs._dealloc {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.superclass: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".superclass" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "superclass"), - ] +extension SwiftProtoTesting_Names_MessageNames.superclass: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".superclass" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}superclass\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24481,18 +18936,16 @@ extension SwiftUnittest_Names_MessageNames.superclass: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.superclass, rhs: SwiftUnittest_Names_MessageNames.superclass) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.superclass, rhs: SwiftProtoTesting_Names_MessageNames.superclass) -> Bool { if lhs._superclass != rhs._superclass {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.retain: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".retain" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "retain"), - ] +extension SwiftProtoTesting_Names_MessageNames.retain: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".retain" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}retain\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24517,18 +18970,16 @@ extension SwiftUnittest_Names_MessageNames.retain: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.retain, rhs: SwiftUnittest_Names_MessageNames.retain) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.retain, rhs: SwiftProtoTesting_Names_MessageNames.retain) -> Bool { if lhs._retain != rhs._retain {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.release: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".release" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "release"), - ] +extension SwiftProtoTesting_Names_MessageNames.release: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".release" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}release\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24553,18 +19004,16 @@ extension SwiftUnittest_Names_MessageNames.release: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.release, rhs: SwiftUnittest_Names_MessageNames.release) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.release, rhs: SwiftProtoTesting_Names_MessageNames.release) -> Bool { if lhs._release != rhs._release {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.autorelease: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".autorelease" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "autorelease"), - ] +extension SwiftProtoTesting_Names_MessageNames.autorelease: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".autorelease" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}autorelease\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24589,18 +19038,16 @@ extension SwiftUnittest_Names_MessageNames.autorelease: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.autorelease, rhs: SwiftUnittest_Names_MessageNames.autorelease) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.autorelease, rhs: SwiftProtoTesting_Names_MessageNames.autorelease) -> Bool { if lhs._autorelease != rhs._autorelease {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.retainCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".retainCount" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "retainCount"), - ] +extension SwiftProtoTesting_Names_MessageNames.retainCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".retainCount" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}retainCount\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24625,18 +19072,16 @@ extension SwiftUnittest_Names_MessageNames.retainCount: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.retainCount, rhs: SwiftUnittest_Names_MessageNames.retainCount) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.retainCount, rhs: SwiftProtoTesting_Names_MessageNames.retainCount) -> Bool { if lhs._retainCount != rhs._retainCount {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.zone: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".zone" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "zone"), - ] +extension SwiftProtoTesting_Names_MessageNames.zone: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".zone" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}zone\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24661,18 +19106,16 @@ extension SwiftUnittest_Names_MessageNames.zone: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.zone, rhs: SwiftUnittest_Names_MessageNames.zone) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.zone, rhs: SwiftProtoTesting_Names_MessageNames.zone) -> Bool { if lhs._zone != rhs._zone {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.isProxy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".isProxy" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "isProxy"), - ] +extension SwiftProtoTesting_Names_MessageNames.isProxy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".isProxy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isProxy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24697,18 +19140,16 @@ extension SwiftUnittest_Names_MessageNames.isProxy: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.isProxy, rhs: SwiftUnittest_Names_MessageNames.isProxy) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.isProxy, rhs: SwiftProtoTesting_Names_MessageNames.isProxy) -> Bool { if lhs._isProxy != rhs._isProxy {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.copy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".copy" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "copy"), - ] +extension SwiftProtoTesting_Names_MessageNames.copy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".copy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}copy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24733,18 +19174,16 @@ extension SwiftUnittest_Names_MessageNames.copy: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.copy, rhs: SwiftUnittest_Names_MessageNames.copy) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.copy, rhs: SwiftProtoTesting_Names_MessageNames.copy) -> Bool { if lhs._copy != rhs._copy {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.mutableCopy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".mutableCopy" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mutableCopy"), - ] +extension SwiftProtoTesting_Names_MessageNames.mutableCopy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".mutableCopy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mutableCopy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24769,18 +19208,16 @@ extension SwiftUnittest_Names_MessageNames.mutableCopy: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.mutableCopy, rhs: SwiftUnittest_Names_MessageNames.mutableCopy) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.mutableCopy, rhs: SwiftProtoTesting_Names_MessageNames.mutableCopy) -> Bool { if lhs._mutableCopy != rhs._mutableCopy {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.classForCoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".classForCoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "classForCoder"), - ] +extension SwiftProtoTesting_Names_MessageNames.classForCoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".classForCoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}classForCoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24805,18 +19242,16 @@ extension SwiftUnittest_Names_MessageNames.classForCoder: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.classForCoder, rhs: SwiftUnittest_Names_MessageNames.classForCoder) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.classForCoder, rhs: SwiftProtoTesting_Names_MessageNames.classForCoder) -> Bool { if lhs._classForCoder != rhs._classForCoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.clear: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".clear" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clear"), - ] +extension SwiftProtoTesting_Names_MessageNames.clear: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".clear" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clear\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24841,18 +19276,16 @@ extension SwiftUnittest_Names_MessageNames.clear: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.clear, rhs: SwiftUnittest_Names_MessageNames.clear) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.clear, rhs: SwiftProtoTesting_Names_MessageNames.clear) -> Bool { if lhs._clear != rhs._clear {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.data: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".data" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] +extension SwiftProtoTesting_Names_MessageNames.data: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24877,18 +19310,16 @@ extension SwiftUnittest_Names_MessageNames.data: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.data, rhs: SwiftUnittest_Names_MessageNames.data) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.data, rhs: SwiftProtoTesting_Names_MessageNames.data) -> Bool { if lhs._data != rhs._data {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.delimitedData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".delimitedData" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "delimitedData"), - ] +extension SwiftProtoTesting_Names_MessageNames.delimitedData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".delimitedData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}delimitedData\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24913,18 +19344,16 @@ extension SwiftUnittest_Names_MessageNames.delimitedData: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.delimitedData, rhs: SwiftUnittest_Names_MessageNames.delimitedData) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.delimitedData, rhs: SwiftProtoTesting_Names_MessageNames.delimitedData) -> Bool { if lhs._delimitedData != rhs._delimitedData {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.descriptor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".descriptor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "descriptor"), - ] +extension SwiftProtoTesting_Names_MessageNames.descriptor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".descriptor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}descriptor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24949,18 +19378,16 @@ extension SwiftUnittest_Names_MessageNames.descriptor: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.descriptor, rhs: SwiftUnittest_Names_MessageNames.descriptor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.descriptor, rhs: SwiftProtoTesting_Names_MessageNames.descriptor) -> Bool { if lhs._descriptor != rhs._descriptor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.extensionRegistry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".extensionRegistry" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extensionRegistry"), - ] +extension SwiftProtoTesting_Names_MessageNames.extensionRegistry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".extensionRegistry" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extensionRegistry\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24985,18 +19412,16 @@ extension SwiftUnittest_Names_MessageNames.extensionRegistry: SwiftProtobuf.Mess try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.extensionRegistry, rhs: SwiftUnittest_Names_MessageNames.extensionRegistry) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.extensionRegistry, rhs: SwiftProtoTesting_Names_MessageNames.extensionRegistry) -> Bool { if lhs._extensionRegistry != rhs._extensionRegistry {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.extensionsCurrentlySet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".extensionsCurrentlySet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extensionsCurrentlySet"), - ] +extension SwiftProtoTesting_Names_MessageNames.extensionsCurrentlySet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".extensionsCurrentlySet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extensionsCurrentlySet\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25021,18 +19446,16 @@ extension SwiftUnittest_Names_MessageNames.extensionsCurrentlySet: SwiftProtobuf try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.extensionsCurrentlySet, rhs: SwiftUnittest_Names_MessageNames.extensionsCurrentlySet) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.extensionsCurrentlySet, rhs: SwiftProtoTesting_Names_MessageNames.extensionsCurrentlySet) -> Bool { if lhs._extensionsCurrentlySet != rhs._extensionsCurrentlySet {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.isInitializedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".isInitialized" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "isInitialized"), - ] +extension SwiftProtoTesting_Names_MessageNames.isInitializedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".isInitialized" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isInitialized\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25057,18 +19480,16 @@ extension SwiftUnittest_Names_MessageNames.isInitializedMessage: SwiftProtobuf.M try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.isInitializedMessage, rhs: SwiftUnittest_Names_MessageNames.isInitializedMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.isInitializedMessage, rhs: SwiftProtoTesting_Names_MessageNames.isInitializedMessage) -> Bool { if lhs._isInitialized_p != rhs._isInitialized_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.serializedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".serializedSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "serializedSize"), - ] +extension SwiftProtoTesting_Names_MessageNames.serializedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".serializedSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}serializedSize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25093,18 +19514,16 @@ extension SwiftUnittest_Names_MessageNames.serializedSize: SwiftProtobuf.Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.serializedSize, rhs: SwiftUnittest_Names_MessageNames.serializedSize) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.serializedSize, rhs: SwiftProtoTesting_Names_MessageNames.serializedSize) -> Bool { if lhs._serializedSize != rhs._serializedSize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.sortedExtensionsInUse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".sortedExtensionsInUse" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sortedExtensionsInUse"), - ] +extension SwiftProtoTesting_Names_MessageNames.sortedExtensionsInUse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".sortedExtensionsInUse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sortedExtensionsInUse\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25129,18 +19548,16 @@ extension SwiftUnittest_Names_MessageNames.sortedExtensionsInUse: SwiftProtobuf. try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.sortedExtensionsInUse, rhs: SwiftUnittest_Names_MessageNames.sortedExtensionsInUse) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.sortedExtensionsInUse, rhs: SwiftProtoTesting_Names_MessageNames.sortedExtensionsInUse) -> Bool { if lhs._sortedExtensionsInUse != rhs._sortedExtensionsInUse {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.unknownFieldsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".unknownFields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "unknownFields"), - ] +extension SwiftProtoTesting_Names_MessageNames.unknownFieldsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".unknownFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unknownFields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25165,18 +19582,16 @@ extension SwiftUnittest_Names_MessageNames.unknownFieldsMessage: SwiftProtobuf.M try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.unknownFieldsMessage, rhs: SwiftUnittest_Names_MessageNames.unknownFieldsMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.unknownFieldsMessage, rhs: SwiftProtoTesting_Names_MessageNames.unknownFieldsMessage) -> Bool { if lhs._unknownFields_p != rhs._unknownFields_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Fixed: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Fixed" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Fixed"), - ] +extension SwiftProtoTesting_Names_MessageNames.Fixed: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Fixed" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Fixed\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25201,18 +19616,16 @@ extension SwiftUnittest_Names_MessageNames.Fixed: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Fixed, rhs: SwiftUnittest_Names_MessageNames.Fixed) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Fixed, rhs: SwiftProtoTesting_Names_MessageNames.Fixed) -> Bool { if lhs._fixed != rhs._fixed {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Fract: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Fract" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Fract"), - ] +extension SwiftProtoTesting_Names_MessageNames.Fract: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Fract" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Fract\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25237,18 +19650,16 @@ extension SwiftUnittest_Names_MessageNames.Fract: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Fract, rhs: SwiftUnittest_Names_MessageNames.Fract) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Fract, rhs: SwiftProtoTesting_Names_MessageNames.Fract) -> Bool { if lhs._fract != rhs._fract {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Size: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Size" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Size"), - ] +extension SwiftProtoTesting_Names_MessageNames.Size: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Size" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Size\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25273,18 +19684,16 @@ extension SwiftUnittest_Names_MessageNames.Size: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Size, rhs: SwiftUnittest_Names_MessageNames.Size) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Size, rhs: SwiftProtoTesting_Names_MessageNames.Size) -> Bool { if lhs._size != rhs._size {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.LogicalAddress: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".LogicalAddress" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "LogicalAddress"), - ] +extension SwiftProtoTesting_Names_MessageNames.LogicalAddress: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".LogicalAddress" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}LogicalAddress\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25309,18 +19718,16 @@ extension SwiftUnittest_Names_MessageNames.LogicalAddress: SwiftProtobuf.Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.LogicalAddress, rhs: SwiftUnittest_Names_MessageNames.LogicalAddress) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.LogicalAddress, rhs: SwiftProtoTesting_Names_MessageNames.LogicalAddress) -> Bool { if lhs._logicalAddress != rhs._logicalAddress {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.PhysicalAddress: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".PhysicalAddress" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "PhysicalAddress"), - ] +extension SwiftProtoTesting_Names_MessageNames.PhysicalAddress: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".PhysicalAddress" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}PhysicalAddress\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25345,18 +19752,16 @@ extension SwiftUnittest_Names_MessageNames.PhysicalAddress: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.PhysicalAddress, rhs: SwiftUnittest_Names_MessageNames.PhysicalAddress) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.PhysicalAddress, rhs: SwiftProtoTesting_Names_MessageNames.PhysicalAddress) -> Bool { if lhs._physicalAddress != rhs._physicalAddress {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.ByteCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".ByteCount" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ByteCount"), - ] +extension SwiftProtoTesting_Names_MessageNames.ByteCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".ByteCount" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ByteCount\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25381,18 +19786,16 @@ extension SwiftUnittest_Names_MessageNames.ByteCount: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.ByteCount, rhs: SwiftUnittest_Names_MessageNames.ByteCount) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ByteCount, rhs: SwiftProtoTesting_Names_MessageNames.ByteCount) -> Bool { if lhs._byteCount != rhs._byteCount {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.ByteOffset: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".ByteOffset" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ByteOffset"), - ] +extension SwiftProtoTesting_Names_MessageNames.ByteOffset: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".ByteOffset" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ByteOffset\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25417,18 +19820,16 @@ extension SwiftUnittest_Names_MessageNames.ByteOffset: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.ByteOffset, rhs: SwiftUnittest_Names_MessageNames.ByteOffset) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ByteOffset, rhs: SwiftProtoTesting_Names_MessageNames.ByteOffset) -> Bool { if lhs._byteOffset != rhs._byteOffset {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Duration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Duration" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Duration"), - ] +extension SwiftProtoTesting_Names_MessageNames.Duration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Duration" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Duration\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25453,18 +19854,16 @@ extension SwiftUnittest_Names_MessageNames.Duration: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Duration, rhs: SwiftUnittest_Names_MessageNames.Duration) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Duration, rhs: SwiftProtoTesting_Names_MessageNames.Duration) -> Bool { if lhs._duration != rhs._duration {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.AbsoluteTime: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".AbsoluteTime" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "AbsoluteTime"), - ] +extension SwiftProtoTesting_Names_MessageNames.AbsoluteTime: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".AbsoluteTime" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}AbsoluteTime\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25489,18 +19888,16 @@ extension SwiftUnittest_Names_MessageNames.AbsoluteTime: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.AbsoluteTime, rhs: SwiftUnittest_Names_MessageNames.AbsoluteTime) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.AbsoluteTime, rhs: SwiftProtoTesting_Names_MessageNames.AbsoluteTime) -> Bool { if lhs._absoluteTime != rhs._absoluteTime {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.OptionBits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".OptionBits" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "OptionBits"), - ] +extension SwiftProtoTesting_Names_MessageNames.OptionBits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".OptionBits" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OptionBits\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25525,18 +19922,16 @@ extension SwiftUnittest_Names_MessageNames.OptionBits: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.OptionBits, rhs: SwiftUnittest_Names_MessageNames.OptionBits) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.OptionBits, rhs: SwiftProtoTesting_Names_MessageNames.OptionBits) -> Bool { if lhs._optionBits != rhs._optionBits {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.ItemCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".ItemCount" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ItemCount"), - ] +extension SwiftProtoTesting_Names_MessageNames.ItemCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".ItemCount" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ItemCount\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25561,18 +19956,16 @@ extension SwiftUnittest_Names_MessageNames.ItemCount: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.ItemCount, rhs: SwiftUnittest_Names_MessageNames.ItemCount) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ItemCount, rhs: SwiftProtoTesting_Names_MessageNames.ItemCount) -> Bool { if lhs._itemCount != rhs._itemCount {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.PBVersion: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".PBVersion" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "PBVersion"), - ] +extension SwiftProtoTesting_Names_MessageNames.PBVersion: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".PBVersion" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}PBVersion\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25597,18 +19990,16 @@ extension SwiftUnittest_Names_MessageNames.PBVersion: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.PBVersion, rhs: SwiftUnittest_Names_MessageNames.PBVersion) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.PBVersion, rhs: SwiftProtoTesting_Names_MessageNames.PBVersion) -> Bool { if lhs._pbversion != rhs._pbversion {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.ScriptCode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".ScriptCode" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ScriptCode"), - ] +extension SwiftProtoTesting_Names_MessageNames.ScriptCode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".ScriptCode" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ScriptCode\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25633,18 +20024,16 @@ extension SwiftUnittest_Names_MessageNames.ScriptCode: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.ScriptCode, rhs: SwiftUnittest_Names_MessageNames.ScriptCode) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ScriptCode, rhs: SwiftProtoTesting_Names_MessageNames.ScriptCode) -> Bool { if lhs._scriptCode != rhs._scriptCode {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.LangCode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".LangCode" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "LangCode"), - ] +extension SwiftProtoTesting_Names_MessageNames.LangCode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".LangCode" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}LangCode\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25669,18 +20058,16 @@ extension SwiftUnittest_Names_MessageNames.LangCode: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.LangCode, rhs: SwiftUnittest_Names_MessageNames.LangCode) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.LangCode, rhs: SwiftProtoTesting_Names_MessageNames.LangCode) -> Bool { if lhs._langCode != rhs._langCode {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.RegionCode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".RegionCode" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "RegionCode"), - ] +extension SwiftProtoTesting_Names_MessageNames.RegionCode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".RegionCode" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}RegionCode\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25705,18 +20092,16 @@ extension SwiftUnittest_Names_MessageNames.RegionCode: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.RegionCode, rhs: SwiftUnittest_Names_MessageNames.RegionCode) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.RegionCode, rhs: SwiftProtoTesting_Names_MessageNames.RegionCode) -> Bool { if lhs._regionCode != rhs._regionCode {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.OSType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".OSType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "OSType"), - ] +extension SwiftProtoTesting_Names_MessageNames.OSType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".OSType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OSType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25741,18 +20126,16 @@ extension SwiftUnittest_Names_MessageNames.OSType: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.OSType, rhs: SwiftUnittest_Names_MessageNames.OSType) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.OSType, rhs: SwiftProtoTesting_Names_MessageNames.OSType) -> Bool { if lhs._ostype != rhs._ostype {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.ProcessSerialNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".ProcessSerialNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProcessSerialNumber"), - ] +extension SwiftProtoTesting_Names_MessageNames.ProcessSerialNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".ProcessSerialNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProcessSerialNumber\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25777,18 +20160,16 @@ extension SwiftUnittest_Names_MessageNames.ProcessSerialNumber: SwiftProtobuf.Me try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.ProcessSerialNumber, rhs: SwiftUnittest_Names_MessageNames.ProcessSerialNumber) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ProcessSerialNumber, rhs: SwiftProtoTesting_Names_MessageNames.ProcessSerialNumber) -> Bool { if lhs._processSerialNumber != rhs._processSerialNumber {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Point: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Point" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Point"), - ] +extension SwiftProtoTesting_Names_MessageNames.Point: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Point" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Point\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25813,18 +20194,16 @@ extension SwiftUnittest_Names_MessageNames.Point: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Point, rhs: SwiftUnittest_Names_MessageNames.Point) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Point, rhs: SwiftProtoTesting_Names_MessageNames.Point) -> Bool { if lhs._point != rhs._point {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Rect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Rect" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Rect"), - ] +extension SwiftProtoTesting_Names_MessageNames.Rect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Rect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Rect\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25849,18 +20228,16 @@ extension SwiftUnittest_Names_MessageNames.Rect: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Rect, rhs: SwiftUnittest_Names_MessageNames.Rect) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Rect, rhs: SwiftProtoTesting_Names_MessageNames.Rect) -> Bool { if lhs._rect != rhs._rect {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.FixedPoint: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".FixedPoint" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FixedPoint"), - ] +extension SwiftProtoTesting_Names_MessageNames.FixedPoint: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".FixedPoint" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FixedPoint\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25885,18 +20262,16 @@ extension SwiftUnittest_Names_MessageNames.FixedPoint: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.FixedPoint, rhs: SwiftUnittest_Names_MessageNames.FixedPoint) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.FixedPoint, rhs: SwiftProtoTesting_Names_MessageNames.FixedPoint) -> Bool { if lhs._fixedPoint != rhs._fixedPoint {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.FixedRect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".FixedRect" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FixedRect"), - ] +extension SwiftProtoTesting_Names_MessageNames.FixedRect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".FixedRect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FixedRect\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25921,18 +20296,16 @@ extension SwiftUnittest_Names_MessageNames.FixedRect: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.FixedRect, rhs: SwiftUnittest_Names_MessageNames.FixedRect) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.FixedRect, rhs: SwiftProtoTesting_Names_MessageNames.FixedRect) -> Bool { if lhs._fixedRect != rhs._fixedRect {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Style: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Style" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Style"), - ] +extension SwiftProtoTesting_Names_MessageNames.Style: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Style" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Style\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25957,18 +20330,16 @@ extension SwiftUnittest_Names_MessageNames.Style: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Style, rhs: SwiftUnittest_Names_MessageNames.Style) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Style, rhs: SwiftProtoTesting_Names_MessageNames.Style) -> Bool { if lhs._style != rhs._style {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.StyleParameter: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".StyleParameter" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "StyleParameter"), - ] +extension SwiftProtoTesting_Names_MessageNames.StyleParameter: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".StyleParameter" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}StyleParameter\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25993,18 +20364,16 @@ extension SwiftUnittest_Names_MessageNames.StyleParameter: SwiftProtobuf.Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.StyleParameter, rhs: SwiftUnittest_Names_MessageNames.StyleParameter) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.StyleParameter, rhs: SwiftProtoTesting_Names_MessageNames.StyleParameter) -> Bool { if lhs._styleParameter != rhs._styleParameter {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.StyleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".StyleField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "StyleField"), - ] +extension SwiftProtoTesting_Names_MessageNames.StyleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".StyleField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}StyleField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26029,18 +20398,16 @@ extension SwiftUnittest_Names_MessageNames.StyleField: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.StyleField, rhs: SwiftUnittest_Names_MessageNames.StyleField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.StyleField, rhs: SwiftProtoTesting_Names_MessageNames.StyleField) -> Bool { if lhs._styleField != rhs._styleField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.TimeScale: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".TimeScale" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TimeScale"), - ] +extension SwiftProtoTesting_Names_MessageNames.TimeScale: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".TimeScale" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}TimeScale\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26065,18 +20432,16 @@ extension SwiftUnittest_Names_MessageNames.TimeScale: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.TimeScale, rhs: SwiftUnittest_Names_MessageNames.TimeScale) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.TimeScale, rhs: SwiftProtoTesting_Names_MessageNames.TimeScale) -> Bool { if lhs._timeScale != rhs._timeScale {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.TimeBase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".TimeBase" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TimeBase"), - ] +extension SwiftProtoTesting_Names_MessageNames.TimeBase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".TimeBase" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}TimeBase\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26101,18 +20466,16 @@ extension SwiftUnittest_Names_MessageNames.TimeBase: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.TimeBase, rhs: SwiftUnittest_Names_MessageNames.TimeBase) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.TimeBase, rhs: SwiftProtoTesting_Names_MessageNames.TimeBase) -> Bool { if lhs._timeBase != rhs._timeBase {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.TimeRecord: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".TimeRecord" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TimeRecord"), - ] +extension SwiftProtoTesting_Names_MessageNames.TimeRecord: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".TimeRecord" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}TimeRecord\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26137,18 +20500,16 @@ extension SwiftUnittest_Names_MessageNames.TimeRecord: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.TimeRecord, rhs: SwiftUnittest_Names_MessageNames.TimeRecord) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.TimeRecord, rhs: SwiftProtoTesting_Names_MessageNames.TimeRecord) -> Bool { if lhs._timeRecord != rhs._timeRecord {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.serializedData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".serializedData" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "serializedData"), - ] +extension SwiftProtoTesting_Names_MessageNames.serializedData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".serializedData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}serializedData\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26173,18 +20534,16 @@ extension SwiftUnittest_Names_MessageNames.serializedData: SwiftProtobuf.Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.serializedData, rhs: SwiftUnittest_Names_MessageNames.serializedData) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.serializedData, rhs: SwiftProtoTesting_Names_MessageNames.serializedData) -> Bool { if lhs._serializedData != rhs._serializedData {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.jsonUTF8Data: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".jsonUTF8Data" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jsonUTF8Data"), - ] +extension SwiftProtoTesting_Names_MessageNames.jsonUTF8Data: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".jsonUTF8Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonUTF8Data\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26209,18 +20568,16 @@ extension SwiftUnittest_Names_MessageNames.jsonUTF8Data: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.jsonUTF8Data, rhs: SwiftUnittest_Names_MessageNames.jsonUTF8Data) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.jsonUTF8Data, rhs: SwiftProtoTesting_Names_MessageNames.jsonUTF8Data) -> Bool { if lhs._jsonUtf8Data != rhs._jsonUtf8Data {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.jsonString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".jsonString" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jsonString"), - ] +extension SwiftProtoTesting_Names_MessageNames.jsonString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".jsonString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonString\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26245,18 +20602,16 @@ extension SwiftUnittest_Names_MessageNames.jsonString: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.jsonString, rhs: SwiftUnittest_Names_MessageNames.jsonString) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.jsonString, rhs: SwiftProtoTesting_Names_MessageNames.jsonString) -> Bool { if lhs._jsonString != rhs._jsonString {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Extension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Extension"), - ] +extension SwiftProtoTesting_Names_MessageNames.Extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Extension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Extension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26281,18 +20636,16 @@ extension SwiftUnittest_Names_MessageNames.Extension: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Extension, rhs: SwiftUnittest_Names_MessageNames.Extension) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Extension, rhs: SwiftProtoTesting_Names_MessageNames.Extension) -> Bool { if lhs._extension != rhs._extension {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.ExtensionsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Extensions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Extensions"), - ] +extension SwiftProtoTesting_Names_MessageNames.ExtensionsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Extensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Extensions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26317,1338 +20670,898 @@ extension SwiftUnittest_Names_MessageNames.ExtensionsMessage: SwiftProtobuf.Mess try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.ExtensionsMessage, rhs: SwiftUnittest_Names_MessageNames.ExtensionsMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ExtensionsMessage, rhs: SwiftProtoTesting_Names_MessageNames.ExtensionsMessage) -> Bool { if lhs._extensions != rhs._extensions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_EnumNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_EnumNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".EnumNames" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_EnumNames, rhs: SwiftUnittest_Names_EnumNames) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_EnumNames, rhs: SwiftProtoTesting_Names_EnumNames) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_EnumNames.StringEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aString"), - ] +extension SwiftProtoTesting_Names_EnumNames.StringEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aString\0") } -extension SwiftUnittest_Names_EnumNames.ProtocolEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aProtocol"), - ] +extension SwiftProtoTesting_Names_EnumNames.ProtocolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aProtocol\0") } -extension SwiftUnittest_Names_EnumNames.IntEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aInt"), - ] +extension SwiftProtoTesting_Names_EnumNames.IntEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aInt\0") } -extension SwiftUnittest_Names_EnumNames.DoubleEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aDouble"), - ] +extension SwiftProtoTesting_Names_EnumNames.DoubleEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aDouble\0") } -extension SwiftUnittest_Names_EnumNames.FloatEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aFloat"), - ] +extension SwiftProtoTesting_Names_EnumNames.FloatEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aFloat\0") } -extension SwiftUnittest_Names_EnumNames.UIntEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aUInt"), - ] +extension SwiftProtoTesting_Names_EnumNames.UIntEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aUInt\0") } -extension SwiftUnittest_Names_EnumNames.hashValueEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ahashValue"), - ] +extension SwiftProtoTesting_Names_EnumNames.hashValueEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ahashValue\0") } -extension SwiftUnittest_Names_EnumNames.descriptionEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adescription"), - ] +extension SwiftProtoTesting_Names_EnumNames.descriptionEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adescription\0") } -extension SwiftUnittest_Names_EnumNames.debugDescriptionEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adebugDescription"), - ] +extension SwiftProtoTesting_Names_EnumNames.debugDescriptionEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adebugDescription\0") } -extension SwiftUnittest_Names_EnumNames.Swift: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aSwift"), - ] +extension SwiftProtoTesting_Names_EnumNames.SwiftEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aSwift\0") } -extension SwiftUnittest_Names_EnumNames.UNRECOGNIZED: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aUNRECOGNIZED"), - ] +extension SwiftProtoTesting_Names_EnumNames.UNRECOGNIZED: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aUNRECOGNIZED\0") } -extension SwiftUnittest_Names_EnumNames.classEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aclass"), - ] +extension SwiftProtoTesting_Names_EnumNames.classEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aclass\0") } -extension SwiftUnittest_Names_EnumNames.deinitEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adeinit"), - ] +extension SwiftProtoTesting_Names_EnumNames.deinitEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adeinit\0") } -extension SwiftUnittest_Names_EnumNames.enumEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aenum"), - ] +extension SwiftProtoTesting_Names_EnumNames.enumEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aenum\0") } -extension SwiftUnittest_Names_EnumNames.extensionEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aextension"), - ] +extension SwiftProtoTesting_Names_EnumNames.extensionEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aextension\0") } -extension SwiftUnittest_Names_EnumNames.funcEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "afunc"), - ] +extension SwiftProtoTesting_Names_EnumNames.funcEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0afunc\0") } -extension SwiftUnittest_Names_EnumNames.importEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aimport"), - ] +extension SwiftProtoTesting_Names_EnumNames.importEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aimport\0") } -extension SwiftUnittest_Names_EnumNames.initEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ainit"), - ] +extension SwiftProtoTesting_Names_EnumNames.initEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ainit\0") } -extension SwiftUnittest_Names_EnumNames.inoutEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ainout"), - ] +extension SwiftProtoTesting_Names_EnumNames.inoutEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ainout\0") } -extension SwiftUnittest_Names_EnumNames.internalEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ainternal"), - ] +extension SwiftProtoTesting_Names_EnumNames.internalEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ainternal\0") } -extension SwiftUnittest_Names_EnumNames.letEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "alet"), - ] +extension SwiftProtoTesting_Names_EnumNames.letEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0alet\0") } -extension SwiftUnittest_Names_EnumNames.operatorEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aoperator"), - ] +extension SwiftProtoTesting_Names_EnumNames.operatorEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aoperator\0") } -extension SwiftUnittest_Names_EnumNames.privateEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aprivate"), - ] +extension SwiftProtoTesting_Names_EnumNames.privateEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aprivate\0") } -extension SwiftUnittest_Names_EnumNames.protocolEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aprotocol"), - ] +extension SwiftProtoTesting_Names_EnumNames.protocolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aprotocol\0") } -extension SwiftUnittest_Names_EnumNames.publicEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "apublic"), - ] +extension SwiftProtoTesting_Names_EnumNames.publicEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0apublic\0") } -extension SwiftUnittest_Names_EnumNames.staticEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "astatic"), - ] +extension SwiftProtoTesting_Names_EnumNames.staticEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0astatic\0") } -extension SwiftUnittest_Names_EnumNames.structEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "astruct"), - ] +extension SwiftProtoTesting_Names_EnumNames.structEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0astruct\0") } -extension SwiftUnittest_Names_EnumNames.subscriptEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "asubscript"), - ] +extension SwiftProtoTesting_Names_EnumNames.subscriptEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0asubscript\0") } -extension SwiftUnittest_Names_EnumNames.typealiasEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "atypealias"), - ] +extension SwiftProtoTesting_Names_EnumNames.typealiasEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0atypealias\0") } -extension SwiftUnittest_Names_EnumNames.varEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "avar"), - ] +extension SwiftProtoTesting_Names_EnumNames.varEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0avar\0") } -extension SwiftUnittest_Names_EnumNames.breakEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "abreak"), - ] +extension SwiftProtoTesting_Names_EnumNames.breakEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0abreak\0") } -extension SwiftUnittest_Names_EnumNames.caseEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "acase"), - ] +extension SwiftProtoTesting_Names_EnumNames.caseEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0acase\0") } -extension SwiftUnittest_Names_EnumNames.continueEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "acontinue"), - ] +extension SwiftProtoTesting_Names_EnumNames.continueEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0acontinue\0") } -extension SwiftUnittest_Names_EnumNames.defaultEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adefault"), - ] +extension SwiftProtoTesting_Names_EnumNames.defaultEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adefault\0") } -extension SwiftUnittest_Names_EnumNames.deferEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adefer"), - ] +extension SwiftProtoTesting_Names_EnumNames.deferEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adefer\0") } -extension SwiftUnittest_Names_EnumNames.doEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ado"), - ] +extension SwiftProtoTesting_Names_EnumNames.doEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ado\0") } -extension SwiftUnittest_Names_EnumNames.elseEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aelse"), - ] +extension SwiftProtoTesting_Names_EnumNames.elseEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aelse\0") } -extension SwiftUnittest_Names_EnumNames.fallthroughEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "afallthrough"), - ] +extension SwiftProtoTesting_Names_EnumNames.fallthroughEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0afallthrough\0") } -extension SwiftUnittest_Names_EnumNames.forEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "afor"), - ] +extension SwiftProtoTesting_Names_EnumNames.forEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0afor\0") } -extension SwiftUnittest_Names_EnumNames.guardEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aguard"), - ] +extension SwiftProtoTesting_Names_EnumNames.guardEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aguard\0") } -extension SwiftUnittest_Names_EnumNames.ifEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aif"), - ] +extension SwiftProtoTesting_Names_EnumNames.ifEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aif\0") } -extension SwiftUnittest_Names_EnumNames.inEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ain"), - ] +extension SwiftProtoTesting_Names_EnumNames.inEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ain\0") } -extension SwiftUnittest_Names_EnumNames.repeatEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "arepeat"), - ] +extension SwiftProtoTesting_Names_EnumNames.repeatEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0arepeat\0") } -extension SwiftUnittest_Names_EnumNames.returnEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "areturn"), - ] +extension SwiftProtoTesting_Names_EnumNames.returnEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0areturn\0") } -extension SwiftUnittest_Names_EnumNames.switchEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aswitch"), - ] +extension SwiftProtoTesting_Names_EnumNames.switchEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aswitch\0") } -extension SwiftUnittest_Names_EnumNames.whereEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "awhere"), - ] +extension SwiftProtoTesting_Names_EnumNames.whereEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0awhere\0") } -extension SwiftUnittest_Names_EnumNames.whileEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "awhile"), - ] +extension SwiftProtoTesting_Names_EnumNames.whileEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0awhile\0") } -extension SwiftUnittest_Names_EnumNames.asEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aas"), - ] +extension SwiftProtoTesting_Names_EnumNames.asEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aas\0") } -extension SwiftUnittest_Names_EnumNames.catchEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "acatch"), - ] +extension SwiftProtoTesting_Names_EnumNames.catchEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0acatch\0") } -extension SwiftUnittest_Names_EnumNames.dynamicTypeEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adynamicType"), - ] +extension SwiftProtoTesting_Names_EnumNames.dynamicTypeEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adynamicType\0") } -extension SwiftUnittest_Names_EnumNames.falseEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "afalse"), - ] +extension SwiftProtoTesting_Names_EnumNames.falseEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0afalse\0") } -extension SwiftUnittest_Names_EnumNames.isEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ais"), - ] +extension SwiftProtoTesting_Names_EnumNames.isEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ais\0") } -extension SwiftUnittest_Names_EnumNames.nilEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "anil"), - ] +extension SwiftProtoTesting_Names_EnumNames.nilEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0anil\0") } -extension SwiftUnittest_Names_EnumNames.rethrowsEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "arethrows"), - ] +extension SwiftProtoTesting_Names_EnumNames.rethrowsEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0arethrows\0") } -extension SwiftUnittest_Names_EnumNames.superEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "asuper"), - ] +extension SwiftProtoTesting_Names_EnumNames.superEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0asuper\0") } -extension SwiftUnittest_Names_EnumNames.selfEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aself"), - ] +extension SwiftProtoTesting_Names_EnumNames.selfEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aself\0") } -extension SwiftUnittest_Names_EnumNames.throwEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "athrow"), - ] +extension SwiftProtoTesting_Names_EnumNames.throwEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0athrow\0") } -extension SwiftUnittest_Names_EnumNames.throwsEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "athrows"), - ] +extension SwiftProtoTesting_Names_EnumNames.throwsEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0athrows\0") } -extension SwiftUnittest_Names_EnumNames.trueEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "atrue"), - ] +extension SwiftProtoTesting_Names_EnumNames.trueEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0atrue\0") } -extension SwiftUnittest_Names_EnumNames.tryEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "atry"), - ] +extension SwiftProtoTesting_Names_EnumNames.tryEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0atry\0") } -extension SwiftUnittest_Names_EnumNames.__COLUMN__Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "a__COLUMN__"), - ] +extension SwiftProtoTesting_Names_EnumNames.__COLUMN__Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0a__COLUMN__\0") } -extension SwiftUnittest_Names_EnumNames.__FILE__Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "a__FILE__"), - ] +extension SwiftProtoTesting_Names_EnumNames.__FILE__Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0a__FILE__\0") } -extension SwiftUnittest_Names_EnumNames.__FUNCTION__Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "a__FUNCTION__"), - ] +extension SwiftProtoTesting_Names_EnumNames.__FUNCTION__Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0a__FUNCTION__\0") } -extension SwiftUnittest_Names_EnumNames.__LINE__Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "a__LINE__"), - ] +extension SwiftProtoTesting_Names_EnumNames.__LINE__Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0a__LINE__\0") } -extension SwiftUnittest_Names_EnumNames._Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "a_"), - ] +extension SwiftProtoTesting_Names_EnumNames._Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0a_\0") } -extension SwiftUnittest_Names_EnumNames.__Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "a__"), - ] +extension SwiftProtoTesting_Names_EnumNames.__Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0a__\0") } -extension SwiftUnittest_Names_EnumNames.associativity: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aassociativity"), - ] +extension SwiftProtoTesting_Names_EnumNames.associativity: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aassociativity\0") } -extension SwiftUnittest_Names_EnumNames.convenience: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aconvenience"), - ] +extension SwiftProtoTesting_Names_EnumNames.convenience: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aconvenience\0") } -extension SwiftUnittest_Names_EnumNames.dynamic: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adynamic"), - ] +extension SwiftProtoTesting_Names_EnumNames.dynamic: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adynamic\0") } -extension SwiftUnittest_Names_EnumNames.didSet: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adidSet"), - ] +extension SwiftProtoTesting_Names_EnumNames.didSet: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adidSet\0") } -extension SwiftUnittest_Names_EnumNames.final: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "afinal"), - ] +extension SwiftProtoTesting_Names_EnumNames.final: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0afinal\0") } -extension SwiftUnittest_Names_EnumNames.get: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aget"), - ] +extension SwiftProtoTesting_Names_EnumNames.get: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aget\0") } -extension SwiftUnittest_Names_EnumNames.infix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ainfix"), - ] +extension SwiftProtoTesting_Names_EnumNames.infix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ainfix\0") } -extension SwiftUnittest_Names_EnumNames.indirect: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aindirect"), - ] +extension SwiftProtoTesting_Names_EnumNames.indirect: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aindirect\0") } -extension SwiftUnittest_Names_EnumNames.lazy: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "alazy"), - ] +extension SwiftProtoTesting_Names_EnumNames.lazy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0alazy\0") } -extension SwiftUnittest_Names_EnumNames.left: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aleft"), - ] +extension SwiftProtoTesting_Names_EnumNames.left: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aleft\0") } -extension SwiftUnittest_Names_EnumNames.mutating: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "amutating"), - ] +extension SwiftProtoTesting_Names_EnumNames.mutating: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0amutating\0") } -extension SwiftUnittest_Names_EnumNames.none: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "anone"), - ] +extension SwiftProtoTesting_Names_EnumNames.none: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0anone\0") } -extension SwiftUnittest_Names_EnumNames.nonmutating: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "anonmutating"), - ] +extension SwiftProtoTesting_Names_EnumNames.nonmutating: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0anonmutating\0") } -extension SwiftUnittest_Names_EnumNames.optional: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aoptional"), - ] +extension SwiftProtoTesting_Names_EnumNames.optional: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aoptional\0") } -extension SwiftUnittest_Names_EnumNames.override: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aoverride"), - ] +extension SwiftProtoTesting_Names_EnumNames.override: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aoverride\0") } -extension SwiftUnittest_Names_EnumNames.postfix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "apostfix"), - ] +extension SwiftProtoTesting_Names_EnumNames.postfix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0apostfix\0") } -extension SwiftUnittest_Names_EnumNames.precedence: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aprecedence"), - ] +extension SwiftProtoTesting_Names_EnumNames.precedence: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aprecedence\0") } -extension SwiftUnittest_Names_EnumNames.prefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aprefix"), - ] +extension SwiftProtoTesting_Names_EnumNames.prefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aprefix\0") } -extension SwiftUnittest_Names_EnumNames.required: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "arequired"), - ] +extension SwiftProtoTesting_Names_EnumNames.required: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0arequired\0") } -extension SwiftUnittest_Names_EnumNames.right: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aright"), - ] +extension SwiftProtoTesting_Names_EnumNames.right: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aright\0") } -extension SwiftUnittest_Names_EnumNames.set: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aset"), - ] +extension SwiftProtoTesting_Names_EnumNames.set: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aset\0") } -extension SwiftUnittest_Names_EnumNames.TypeEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aType"), - ] +extension SwiftProtoTesting_Names_EnumNames.TypeEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aType\0") } -extension SwiftUnittest_Names_EnumNames.unowned: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aunowned"), - ] +extension SwiftProtoTesting_Names_EnumNames.unowned: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aunowned\0") } -extension SwiftUnittest_Names_EnumNames.weak: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aweak"), - ] +extension SwiftProtoTesting_Names_EnumNames.weak: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aweak\0") } -extension SwiftUnittest_Names_EnumNames.willSet: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "awillSet"), - ] +extension SwiftProtoTesting_Names_EnumNames.willSet: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0awillSet\0") } -extension SwiftUnittest_Names_EnumNames.id: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aid"), - ] +extension SwiftProtoTesting_Names_EnumNames.id: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aid\0") } -extension SwiftUnittest_Names_EnumNames._cmd: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "a_cmd"), - ] +extension SwiftProtoTesting_Names_EnumNames._cmd: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0a_cmd\0") } -extension SwiftUnittest_Names_EnumNames.out: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aout"), - ] +extension SwiftProtoTesting_Names_EnumNames.out: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aout\0") } -extension SwiftUnittest_Names_EnumNames.bycopy: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "abycopy"), - ] +extension SwiftProtoTesting_Names_EnumNames.bycopy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0abycopy\0") } -extension SwiftUnittest_Names_EnumNames.byref: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "abyref"), - ] +extension SwiftProtoTesting_Names_EnumNames.byref: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0abyref\0") } -extension SwiftUnittest_Names_EnumNames.oneway: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aoneway"), - ] +extension SwiftProtoTesting_Names_EnumNames.oneway: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aoneway\0") } -extension SwiftUnittest_Names_EnumNames.and: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aand"), - ] +extension SwiftProtoTesting_Names_EnumNames.and: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aand\0") } -extension SwiftUnittest_Names_EnumNames.and_eq: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aand_eq"), - ] +extension SwiftProtoTesting_Names_EnumNames.and_eq: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aand_eq\0") } -extension SwiftUnittest_Names_EnumNames.alignas: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aalignas"), - ] +extension SwiftProtoTesting_Names_EnumNames.alignas: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aalignas\0") } -extension SwiftUnittest_Names_EnumNames.alignof: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aalignof"), - ] +extension SwiftProtoTesting_Names_EnumNames.alignof: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aalignof\0") } -extension SwiftUnittest_Names_EnumNames.asm: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aasm"), - ] +extension SwiftProtoTesting_Names_EnumNames.asm: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aasm\0") } -extension SwiftUnittest_Names_EnumNames.auto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aauto"), - ] +extension SwiftProtoTesting_Names_EnumNames.auto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aauto\0") } -extension SwiftUnittest_Names_EnumNames.bitand: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "abitand"), - ] +extension SwiftProtoTesting_Names_EnumNames.bitand: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0abitand\0") } -extension SwiftUnittest_Names_EnumNames.bitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "abitor"), - ] +extension SwiftProtoTesting_Names_EnumNames.bitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0abitor\0") } -extension SwiftUnittest_Names_EnumNames.bool: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "abool"), - ] +extension SwiftProtoTesting_Names_EnumNames.bool: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0abool\0") } -extension SwiftUnittest_Names_EnumNames.char: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "achar"), - ] +extension SwiftProtoTesting_Names_EnumNames.char: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0achar\0") } -extension SwiftUnittest_Names_EnumNames.char16_t: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "achar16_t"), - ] +extension SwiftProtoTesting_Names_EnumNames.char16_t: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0achar16_t\0") } -extension SwiftUnittest_Names_EnumNames.char32_t: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "achar32_t"), - ] +extension SwiftProtoTesting_Names_EnumNames.char32_t: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0achar32_t\0") } -extension SwiftUnittest_Names_EnumNames.compl: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "acompl"), - ] +extension SwiftProtoTesting_Names_EnumNames.compl: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0acompl\0") } -extension SwiftUnittest_Names_EnumNames.const: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aconst"), - ] +extension SwiftProtoTesting_Names_EnumNames.const: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aconst\0") } -extension SwiftUnittest_Names_EnumNames.constexpr: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aconstexpr"), - ] +extension SwiftProtoTesting_Names_EnumNames.constexpr: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aconstexpr\0") } -extension SwiftUnittest_Names_EnumNames.const_cast: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aconst_cast"), - ] +extension SwiftProtoTesting_Names_EnumNames.const_cast: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aconst_cast\0") } -extension SwiftUnittest_Names_EnumNames.decltype: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adecltype"), - ] +extension SwiftProtoTesting_Names_EnumNames.decltype: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adecltype\0") } -extension SwiftUnittest_Names_EnumNames.delete: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adelete"), - ] +extension SwiftProtoTesting_Names_EnumNames.delete: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adelete\0") } -extension SwiftUnittest_Names_EnumNames.dynamic_cast: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adynamic_cast"), - ] +extension SwiftProtoTesting_Names_EnumNames.dynamic_cast: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adynamic_cast\0") } -extension SwiftUnittest_Names_EnumNames.explicit: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aexplicit"), - ] +extension SwiftProtoTesting_Names_EnumNames.explicit: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aexplicit\0") } -extension SwiftUnittest_Names_EnumNames.export: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aexport"), - ] +extension SwiftProtoTesting_Names_EnumNames.export: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aexport\0") } -extension SwiftUnittest_Names_EnumNames.extern: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aextern"), - ] +extension SwiftProtoTesting_Names_EnumNames.extern: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aextern\0") } -extension SwiftUnittest_Names_EnumNames.friend: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "afriend"), - ] +extension SwiftProtoTesting_Names_EnumNames.friend: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0afriend\0") } -extension SwiftUnittest_Names_EnumNames.goto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "agoto"), - ] +extension SwiftProtoTesting_Names_EnumNames.goto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0agoto\0") } -extension SwiftUnittest_Names_EnumNames.inline: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ainline"), - ] +extension SwiftProtoTesting_Names_EnumNames.inline: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ainline\0") } -extension SwiftUnittest_Names_EnumNames.long: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "along"), - ] +extension SwiftProtoTesting_Names_EnumNames.long: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0along\0") } -extension SwiftUnittest_Names_EnumNames.mutable: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "amutable"), - ] +extension SwiftProtoTesting_Names_EnumNames.mutable: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0amutable\0") } -extension SwiftUnittest_Names_EnumNames.namespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "anamespace"), - ] +extension SwiftProtoTesting_Names_EnumNames.namespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0anamespace\0") } -extension SwiftUnittest_Names_EnumNames.new: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "anew"), - ] +extension SwiftProtoTesting_Names_EnumNames.new: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0anew\0") } -extension SwiftUnittest_Names_EnumNames.noexcept: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "anoexcept"), - ] +extension SwiftProtoTesting_Names_EnumNames.noexcept: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0anoexcept\0") } -extension SwiftUnittest_Names_EnumNames.not: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "anot"), - ] +extension SwiftProtoTesting_Names_EnumNames.not: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0anot\0") } -extension SwiftUnittest_Names_EnumNames.not_eq: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "anot_eq"), - ] +extension SwiftProtoTesting_Names_EnumNames.not_eq: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0anot_eq\0") } -extension SwiftUnittest_Names_EnumNames.nullptr: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "anullptr"), - ] +extension SwiftProtoTesting_Names_EnumNames.nullptr: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0anullptr\0") } -extension SwiftUnittest_Names_EnumNames.or: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aor"), - ] +extension SwiftProtoTesting_Names_EnumNames.or: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aor\0") } -extension SwiftUnittest_Names_EnumNames.or_eq: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aor_eq"), - ] +extension SwiftProtoTesting_Names_EnumNames.or_eq: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aor_eq\0") } -extension SwiftUnittest_Names_EnumNames.protected: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aprotected"), - ] +extension SwiftProtoTesting_Names_EnumNames.protected: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aprotected\0") } -extension SwiftUnittest_Names_EnumNames.register: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aregister"), - ] +extension SwiftProtoTesting_Names_EnumNames.register: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aregister\0") } -extension SwiftUnittest_Names_EnumNames.reinterpret_cast: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "areinterpret_cast"), - ] +extension SwiftProtoTesting_Names_EnumNames.reinterpret_cast: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0areinterpret_cast\0") } -extension SwiftUnittest_Names_EnumNames.short: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ashort"), - ] +extension SwiftProtoTesting_Names_EnumNames.short: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ashort\0") } -extension SwiftUnittest_Names_EnumNames.signed: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "asigned"), - ] +extension SwiftProtoTesting_Names_EnumNames.signed: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0asigned\0") } -extension SwiftUnittest_Names_EnumNames.sizeof: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "asizeof"), - ] +extension SwiftProtoTesting_Names_EnumNames.sizeof: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0asizeof\0") } -extension SwiftUnittest_Names_EnumNames.static_assert: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "astatic_assert"), - ] +extension SwiftProtoTesting_Names_EnumNames.static_assert: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0astatic_assert\0") } -extension SwiftUnittest_Names_EnumNames.static_cast: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "astatic_cast"), - ] +extension SwiftProtoTesting_Names_EnumNames.static_cast: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0astatic_cast\0") } -extension SwiftUnittest_Names_EnumNames.template: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "atemplate"), - ] +extension SwiftProtoTesting_Names_EnumNames.template: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0atemplate\0") } -extension SwiftUnittest_Names_EnumNames.this: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "athis"), - ] +extension SwiftProtoTesting_Names_EnumNames.this: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0athis\0") } -extension SwiftUnittest_Names_EnumNames.thread_local: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "athread_local"), - ] +extension SwiftProtoTesting_Names_EnumNames.thread_local: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0athread_local\0") } -extension SwiftUnittest_Names_EnumNames.typedef: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "atypedef"), - ] +extension SwiftProtoTesting_Names_EnumNames.typedef: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0atypedef\0") } -extension SwiftUnittest_Names_EnumNames.typeid: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "atypeid"), - ] +extension SwiftProtoTesting_Names_EnumNames.typeid: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0atypeid\0") } -extension SwiftUnittest_Names_EnumNames.typename: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "atypename"), - ] +extension SwiftProtoTesting_Names_EnumNames.typename: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0atypename\0") } -extension SwiftUnittest_Names_EnumNames.union: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aunion"), - ] +extension SwiftProtoTesting_Names_EnumNames.union: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aunion\0") } -extension SwiftUnittest_Names_EnumNames.unsigned: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aunsigned"), - ] +extension SwiftProtoTesting_Names_EnumNames.unsigned: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aunsigned\0") } -extension SwiftUnittest_Names_EnumNames.using: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ausing"), - ] +extension SwiftProtoTesting_Names_EnumNames.using: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ausing\0") } -extension SwiftUnittest_Names_EnumNames.virtual: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "avirtual"), - ] +extension SwiftProtoTesting_Names_EnumNames.virtual: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0avirtual\0") } -extension SwiftUnittest_Names_EnumNames.void: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "avoid"), - ] +extension SwiftProtoTesting_Names_EnumNames.void: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0avoid\0") } -extension SwiftUnittest_Names_EnumNames.volatile: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "avolatile"), - ] +extension SwiftProtoTesting_Names_EnumNames.volatile: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0avolatile\0") } -extension SwiftUnittest_Names_EnumNames.wchar_t: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "awchar_t"), - ] +extension SwiftProtoTesting_Names_EnumNames.wchar_t: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0awchar_t\0") } -extension SwiftUnittest_Names_EnumNames.xor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "axor"), - ] +extension SwiftProtoTesting_Names_EnumNames.xor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0axor\0") } -extension SwiftUnittest_Names_EnumNames.xor_eq: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "axor_eq"), - ] +extension SwiftProtoTesting_Names_EnumNames.xor_eq: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0axor_eq\0") } -extension SwiftUnittest_Names_EnumNames.restrict: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "arestrict"), - ] +extension SwiftProtoTesting_Names_EnumNames.restrict: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0arestrict\0") } -extension SwiftUnittest_Names_EnumNames.Category: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aCategory"), - ] +extension SwiftProtoTesting_Names_EnumNames.Category: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aCategory\0") } -extension SwiftUnittest_Names_EnumNames.Ivar: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aIvar"), - ] +extension SwiftProtoTesting_Names_EnumNames.Ivar: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aIvar\0") } -extension SwiftUnittest_Names_EnumNames.Method: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aMethod"), - ] +extension SwiftProtoTesting_Names_EnumNames.Method: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aMethod\0") } -extension SwiftUnittest_Names_EnumNames.finalize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "afinalize"), - ] +extension SwiftProtoTesting_Names_EnumNames.finalize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0afinalize\0") } -extension SwiftUnittest_Names_EnumNames.hash: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ahash"), - ] +extension SwiftProtoTesting_Names_EnumNames.hash: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ahash\0") } -extension SwiftUnittest_Names_EnumNames.dealloc: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adealloc"), - ] +extension SwiftProtoTesting_Names_EnumNames.dealloc: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adealloc\0") } -extension SwiftUnittest_Names_EnumNames.superclass: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "asuperclass"), - ] +extension SwiftProtoTesting_Names_EnumNames.superclass: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0asuperclass\0") } -extension SwiftUnittest_Names_EnumNames.retain: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aretain"), - ] +extension SwiftProtoTesting_Names_EnumNames.retain: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aretain\0") } -extension SwiftUnittest_Names_EnumNames.release: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "arelease"), - ] +extension SwiftProtoTesting_Names_EnumNames.release: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0arelease\0") } -extension SwiftUnittest_Names_EnumNames.autorelease: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aautorelease"), - ] +extension SwiftProtoTesting_Names_EnumNames.autorelease: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aautorelease\0") } -extension SwiftUnittest_Names_EnumNames.retainCount: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aretainCount"), - ] +extension SwiftProtoTesting_Names_EnumNames.retainCount: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aretainCount\0") } -extension SwiftUnittest_Names_EnumNames.zone: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "azone"), - ] +extension SwiftProtoTesting_Names_EnumNames.zone: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0azone\0") } -extension SwiftUnittest_Names_EnumNames.isProxy: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aisProxy"), - ] +extension SwiftProtoTesting_Names_EnumNames.isProxy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aisProxy\0") } -extension SwiftUnittest_Names_EnumNames.copy: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "acopy"), - ] +extension SwiftProtoTesting_Names_EnumNames.copy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0acopy\0") } -extension SwiftUnittest_Names_EnumNames.mutableCopy: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "amutableCopy"), - ] +extension SwiftProtoTesting_Names_EnumNames.mutableCopy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0amutableCopy\0") } -extension SwiftUnittest_Names_EnumNames.classForCoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aclassForCoder"), - ] +extension SwiftProtoTesting_Names_EnumNames.classForCoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aclassForCoder\0") } -extension SwiftUnittest_Names_EnumNames.clear: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aclear"), - ] +extension SwiftProtoTesting_Names_EnumNames.clear: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aclear\0") } -extension SwiftUnittest_Names_EnumNames.data: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adata"), - ] +extension SwiftProtoTesting_Names_EnumNames.data: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adata\0") } -extension SwiftUnittest_Names_EnumNames.delimitedData: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adelimitedData"), - ] +extension SwiftProtoTesting_Names_EnumNames.delimitedData: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adelimitedData\0") } -extension SwiftUnittest_Names_EnumNames.descriptor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adescriptor"), - ] +extension SwiftProtoTesting_Names_EnumNames.descriptor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adescriptor\0") } -extension SwiftUnittest_Names_EnumNames.extensionRegistry: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aextensionRegistry"), - ] +extension SwiftProtoTesting_Names_EnumNames.extensionRegistry: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aextensionRegistry\0") } -extension SwiftUnittest_Names_EnumNames.extensionsCurrentlySet: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aextensionsCurrentlySet"), - ] +extension SwiftProtoTesting_Names_EnumNames.extensionsCurrentlySet: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aextensionsCurrentlySet\0") } -extension SwiftUnittest_Names_EnumNames.isInitializedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aisInitialized"), - ] +extension SwiftProtoTesting_Names_EnumNames.isInitializedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aisInitialized\0") } -extension SwiftUnittest_Names_EnumNames.serializedSize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aserializedSize"), - ] +extension SwiftProtoTesting_Names_EnumNames.serializedSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aserializedSize\0") } -extension SwiftUnittest_Names_EnumNames.sortedExtensionsInUse: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "asortedExtensionsInUse"), - ] +extension SwiftProtoTesting_Names_EnumNames.sortedExtensionsInUse: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0asortedExtensionsInUse\0") } -extension SwiftUnittest_Names_EnumNames.unknownFieldsEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aunknownFields"), - ] +extension SwiftProtoTesting_Names_EnumNames.unknownFieldsEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aunknownFields\0") } -extension SwiftUnittest_Names_EnumNames.Fixed: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aFixed"), - ] +extension SwiftProtoTesting_Names_EnumNames.Fixed: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aFixed\0") } -extension SwiftUnittest_Names_EnumNames.Fract: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aFract"), - ] +extension SwiftProtoTesting_Names_EnumNames.Fract: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aFract\0") } -extension SwiftUnittest_Names_EnumNames.Size: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aSize"), - ] +extension SwiftProtoTesting_Names_EnumNames.Size: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aSize\0") } -extension SwiftUnittest_Names_EnumNames.LogicalAddress: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aLogicalAddress"), - ] +extension SwiftProtoTesting_Names_EnumNames.LogicalAddress: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aLogicalAddress\0") } -extension SwiftUnittest_Names_EnumNames.PhysicalAddress: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aPhysicalAddress"), - ] +extension SwiftProtoTesting_Names_EnumNames.PhysicalAddress: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aPhysicalAddress\0") } -extension SwiftUnittest_Names_EnumNames.ByteCount: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aByteCount"), - ] +extension SwiftProtoTesting_Names_EnumNames.ByteCount: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aByteCount\0") } -extension SwiftUnittest_Names_EnumNames.ByteOffset: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aByteOffset"), - ] +extension SwiftProtoTesting_Names_EnumNames.ByteOffset: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aByteOffset\0") } -extension SwiftUnittest_Names_EnumNames.Duration: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aDuration"), - ] +extension SwiftProtoTesting_Names_EnumNames.Duration: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aDuration\0") } -extension SwiftUnittest_Names_EnumNames.AbsoluteTime: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aAbsoluteTime"), - ] +extension SwiftProtoTesting_Names_EnumNames.AbsoluteTime: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aAbsoluteTime\0") } -extension SwiftUnittest_Names_EnumNames.OptionBits: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aOptionBits"), - ] +extension SwiftProtoTesting_Names_EnumNames.OptionBits: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aOptionBits\0") } -extension SwiftUnittest_Names_EnumNames.ItemCount: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aItemCount"), - ] +extension SwiftProtoTesting_Names_EnumNames.ItemCount: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aItemCount\0") } -extension SwiftUnittest_Names_EnumNames.PBVersion: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aPBVersion"), - ] +extension SwiftProtoTesting_Names_EnumNames.PBVersion: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aPBVersion\0") } -extension SwiftUnittest_Names_EnumNames.ScriptCode: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aScriptCode"), - ] +extension SwiftProtoTesting_Names_EnumNames.ScriptCode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aScriptCode\0") } -extension SwiftUnittest_Names_EnumNames.LangCode: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aLangCode"), - ] +extension SwiftProtoTesting_Names_EnumNames.LangCode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aLangCode\0") } -extension SwiftUnittest_Names_EnumNames.RegionCode: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aRegionCode"), - ] +extension SwiftProtoTesting_Names_EnumNames.RegionCode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aRegionCode\0") } -extension SwiftUnittest_Names_EnumNames.OSType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aOSType"), - ] +extension SwiftProtoTesting_Names_EnumNames.OSType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aOSType\0") } -extension SwiftUnittest_Names_EnumNames.ProcessSerialNumber: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aProcessSerialNumber"), - ] +extension SwiftProtoTesting_Names_EnumNames.ProcessSerialNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aProcessSerialNumber\0") } -extension SwiftUnittest_Names_EnumNames.Point: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aPoint"), - ] +extension SwiftProtoTesting_Names_EnumNames.Point: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aPoint\0") } -extension SwiftUnittest_Names_EnumNames.Rect: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aRect"), - ] +extension SwiftProtoTesting_Names_EnumNames.Rect: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aRect\0") } -extension SwiftUnittest_Names_EnumNames.FixedPoint: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aFixedPoint"), - ] +extension SwiftProtoTesting_Names_EnumNames.FixedPoint: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aFixedPoint\0") } -extension SwiftUnittest_Names_EnumNames.FixedRect: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aFixedRect"), - ] +extension SwiftProtoTesting_Names_EnumNames.FixedRect: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aFixedRect\0") } -extension SwiftUnittest_Names_EnumNames.Style: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aStyle"), - ] +extension SwiftProtoTesting_Names_EnumNames.Style: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aStyle\0") } -extension SwiftUnittest_Names_EnumNames.StyleParameter: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aStyleParameter"), - ] +extension SwiftProtoTesting_Names_EnumNames.StyleParameter: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aStyleParameter\0") } -extension SwiftUnittest_Names_EnumNames.StyleField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aStyleField"), - ] +extension SwiftProtoTesting_Names_EnumNames.StyleField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aStyleField\0") } -extension SwiftUnittest_Names_EnumNames.TimeScale: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aTimeScale"), - ] +extension SwiftProtoTesting_Names_EnumNames.TimeScale: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aTimeScale\0") } -extension SwiftUnittest_Names_EnumNames.TimeBase: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aTimeBase"), - ] +extension SwiftProtoTesting_Names_EnumNames.TimeBase: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aTimeBase\0") } -extension SwiftUnittest_Names_EnumNames.TimeRecord: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aTimeRecord"), - ] +extension SwiftProtoTesting_Names_EnumNames.TimeRecord: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aTimeRecord\0") } -extension SwiftUnittest_Names_EnumNames.Extension: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aExtension"), - ] +extension SwiftProtoTesting_Names_EnumNames.Extension: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aExtension\0") } -extension SwiftUnittest_Names_EnumNames.ExtensionsEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aExtensions"), - ] +extension SwiftProtoTesting_Names_EnumNames.ExtensionsEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aExtensions\0") } -extension SwiftUnittest_Names_FieldNamingInitials: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_FieldNamingInitials: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".FieldNamingInitials" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_FieldNamingInitials, rhs: SwiftUnittest_Names_FieldNamingInitials) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_FieldNamingInitials, rhs: SwiftProtoTesting_Names_FieldNamingInitials) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_FieldNamingInitials.Lowers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_FieldNamingInitials.protoMessageName + ".Lowers" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "http"), - 2: .standard(proto: "http_request"), - 3: .standard(proto: "the_http_request"), - 4: .standard(proto: "the_http"), - 11: .same(proto: "https"), - 12: .standard(proto: "https_request"), - 13: .standard(proto: "the_https_request"), - 14: .standard(proto: "the_https"), - 21: .same(proto: "url"), - 22: .standard(proto: "url_value"), - 23: .standard(proto: "the_url_value"), - 24: .standard(proto: "the_url"), - 31: .standard(proto: "a_b_c"), - 41: .same(proto: "id"), - 42: .standard(proto: "id_number"), - 43: .standard(proto: "the_id_number"), - 44: .standard(proto: "request_id"), - ] +extension SwiftProtoTesting_Names_FieldNamingInitials.Lowers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_FieldNamingInitials.protoMessageName + ".Lowers" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}http\0\u{3}http_request\0\u{3}the_http_request\0\u{3}the_http\0\u{2}\u{7}https\0\u{3}https_request\0\u{3}the_https_request\0\u{3}the_https\0\u{2}\u{7}url\0\u{3}url_value\0\u{3}the_url_value\0\u{3}the_url\0\u{4}\u{7}a_b_c\0\u{2}\u{a}id\0\u{3}id_number\0\u{3}the_id_number\0\u{3}request_id\0") fileprivate class _StorageClass { var _http: Int32? = nil @@ -27669,7 +21582,11 @@ extension SwiftUnittest_Names_FieldNamingInitials.Lowers: SwiftProtobuf.Message, var _theIDNumber: Int32? = nil var _requestID: Int32? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -27793,7 +21710,7 @@ extension SwiftUnittest_Names_FieldNamingInitials.Lowers: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_FieldNamingInitials.Lowers, rhs: SwiftUnittest_Names_FieldNamingInitials.Lowers) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_FieldNamingInitials.Lowers, rhs: SwiftProtoTesting_Names_FieldNamingInitials.Lowers) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -27824,26 +21741,9 @@ extension SwiftUnittest_Names_FieldNamingInitials.Lowers: SwiftProtobuf.Message, } } -extension SwiftUnittest_Names_FieldNamingInitials.Uppers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_FieldNamingInitials.protoMessageName + ".Uppers" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "HTTP"), - 2: .standard(proto: "HTTP_request"), - 3: .standard(proto: "the_HTTP_request"), - 4: .standard(proto: "the_HTTP"), - 11: .same(proto: "HTTPS"), - 12: .standard(proto: "HTTPS_request"), - 13: .standard(proto: "the_HTTPS_request"), - 14: .standard(proto: "the_HTTPS"), - 21: .same(proto: "URL"), - 22: .standard(proto: "URL_value"), - 23: .standard(proto: "the_URL_value"), - 24: .standard(proto: "the_URL"), - 41: .same(proto: "ID"), - 42: .standard(proto: "ID_number"), - 43: .standard(proto: "the_ID_number"), - 44: .standard(proto: "request_ID"), - ] +extension SwiftProtoTesting_Names_FieldNamingInitials.Uppers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_FieldNamingInitials.protoMessageName + ".Uppers" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}HTTP\0\u{3}HTTP_request\0\u{3}the_HTTP_request\0\u{3}the_HTTP\0\u{2}\u{7}HTTPS\0\u{3}HTTPS_request\0\u{3}the_HTTPS_request\0\u{3}the_HTTPS\0\u{2}\u{7}URL\0\u{3}URL_value\0\u{3}the_URL_value\0\u{3}the_URL\0\u{2}\u{11}ID\0\u{3}ID_number\0\u{3}the_ID_number\0\u{3}request_ID\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27928,7 +21828,7 @@ extension SwiftUnittest_Names_FieldNamingInitials.Uppers: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_FieldNamingInitials.Uppers, rhs: SwiftUnittest_Names_FieldNamingInitials.Uppers) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_FieldNamingInitials.Uppers, rhs: SwiftProtoTesting_Names_FieldNamingInitials.Uppers) -> Bool { if lhs._http != rhs._http {return false} if lhs._httpRequest != rhs._httpRequest {return false} if lhs._theHTTPRequest != rhs._theHTTPRequest {return false} @@ -27950,26 +21850,9 @@ extension SwiftUnittest_Names_FieldNamingInitials.Uppers: SwiftProtobuf.Message, } } -extension SwiftUnittest_Names_FieldNamingInitials.WordCase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_FieldNamingInitials.protoMessageName + ".WordCase" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Http"), - 2: .same(proto: "HttpRequest"), - 3: .same(proto: "TheHttpRequest"), - 4: .same(proto: "TheHttp"), - 11: .same(proto: "Https"), - 12: .same(proto: "HttpsRequest"), - 13: .same(proto: "TheHttpsRequest"), - 14: .same(proto: "TheHttps"), - 21: .same(proto: "Url"), - 22: .same(proto: "UrlValue"), - 23: .same(proto: "TheUrlValue"), - 24: .same(proto: "TheUrl"), - 41: .same(proto: "Id"), - 42: .same(proto: "IdNumber"), - 43: .same(proto: "TheIdNumber"), - 44: .same(proto: "RequestId"), - ] +extension SwiftProtoTesting_Names_FieldNamingInitials.WordCase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_FieldNamingInitials.protoMessageName + ".WordCase" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Http\0\u{1}HttpRequest\0\u{1}TheHttpRequest\0\u{1}TheHttp\0\u{2}\u{7}Https\0\u{1}HttpsRequest\0\u{1}TheHttpsRequest\0\u{1}TheHttps\0\u{2}\u{7}Url\0\u{1}UrlValue\0\u{1}TheUrlValue\0\u{1}TheUrl\0\u{2}\u{11}Id\0\u{1}IdNumber\0\u{1}TheIdNumber\0\u{1}RequestId\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28054,7 +21937,7 @@ extension SwiftUnittest_Names_FieldNamingInitials.WordCase: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_FieldNamingInitials.WordCase, rhs: SwiftUnittest_Names_FieldNamingInitials.WordCase) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_FieldNamingInitials.WordCase, rhs: SwiftProtoTesting_Names_FieldNamingInitials.WordCase) -> Bool { if lhs._http != rhs._http {return false} if lhs._httpRequest != rhs._httpRequest {return false} if lhs._theHTTPRequest != rhs._theHTTPRequest {return false} @@ -28076,7 +21959,7 @@ extension SwiftUnittest_Names_FieldNamingInitials.WordCase: SwiftProtobuf.Messag } } -extension SwiftUnittest_Names_ExtensionNamingInitials: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_ExtensionNamingInitials: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ExtensionNamingInitials" static let _protobuf_nameMap = SwiftProtobuf._NameMap() @@ -28088,7 +21971,7 @@ extension SwiftUnittest_Names_ExtensionNamingInitials: SwiftProtobuf.Message, Sw mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { if (1 <= fieldNumber && fieldNumber < 1001) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftUnittest_Names_ExtensionNamingInitials.self, fieldNumber: fieldNumber) + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Names_ExtensionNamingInitials.self, fieldNumber: fieldNumber) } } } @@ -28098,71 +21981,71 @@ extension SwiftUnittest_Names_ExtensionNamingInitials: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_ExtensionNamingInitials, rhs: SwiftUnittest_Names_ExtensionNamingInitials) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_ExtensionNamingInitials, rhs: SwiftProtoTesting_Names_ExtensionNamingInitials) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension SwiftUnittest_Names_Lowers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_Lowers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Lowers" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_Lowers, rhs: SwiftUnittest_Names_Lowers) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_Lowers, rhs: SwiftProtoTesting_Names_Lowers) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_Uppers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_Uppers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Uppers" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_Uppers, rhs: SwiftUnittest_Names_Uppers) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_Uppers, rhs: SwiftProtoTesting_Names_Uppers) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_WordCase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_WordCase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".WordCase" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_WordCase, rhs: SwiftUnittest_Names_WordCase) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_WordCase, rhs: SwiftProtoTesting_Names_WordCase) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_ExtensionNamingInitialsLowers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_ExtensionNamingInitialsLowers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ExtensionNamingInitialsLowers" static let _protobuf_nameMap = SwiftProtobuf._NameMap() @@ -28174,7 +22057,7 @@ extension SwiftUnittest_Names_ExtensionNamingInitialsLowers: SwiftProtobuf.Messa mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { if (1 <= fieldNumber && fieldNumber < 1001) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftUnittest_Names_ExtensionNamingInitialsLowers.self, fieldNumber: fieldNumber) + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Names_ExtensionNamingInitialsLowers.self, fieldNumber: fieldNumber) } } } @@ -28184,14 +22067,14 @@ extension SwiftUnittest_Names_ExtensionNamingInitialsLowers: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_ExtensionNamingInitialsLowers, rhs: SwiftUnittest_Names_ExtensionNamingInitialsLowers) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_ExtensionNamingInitialsLowers, rhs: SwiftProtoTesting_Names_ExtensionNamingInitialsLowers) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension SwiftUnittest_Names_ExtensionNamingInitialsUppers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_ExtensionNamingInitialsUppers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ExtensionNamingInitialsUppers" static let _protobuf_nameMap = SwiftProtobuf._NameMap() @@ -28203,7 +22086,7 @@ extension SwiftUnittest_Names_ExtensionNamingInitialsUppers: SwiftProtobuf.Messa mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { if (1 <= fieldNumber && fieldNumber < 1001) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftUnittest_Names_ExtensionNamingInitialsUppers.self, fieldNumber: fieldNumber) + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Names_ExtensionNamingInitialsUppers.self, fieldNumber: fieldNumber) } } } @@ -28213,14 +22096,14 @@ extension SwiftUnittest_Names_ExtensionNamingInitialsUppers: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_ExtensionNamingInitialsUppers, rhs: SwiftUnittest_Names_ExtensionNamingInitialsUppers) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_ExtensionNamingInitialsUppers, rhs: SwiftProtoTesting_Names_ExtensionNamingInitialsUppers) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension SwiftUnittest_Names_ExtensionNamingInitialsWordCase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ExtensionNamingInitialsWordCase" static let _protobuf_nameMap = SwiftProtobuf._NameMap() @@ -28232,7 +22115,7 @@ extension SwiftUnittest_Names_ExtensionNamingInitialsWordCase: SwiftProtobuf.Mes mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { if (1 <= fieldNumber && fieldNumber < 1001) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftUnittest_Names_ExtensionNamingInitialsWordCase.self, fieldNumber: fieldNumber) + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase.self, fieldNumber: fieldNumber) } } } @@ -28242,23 +22125,16 @@ extension SwiftUnittest_Names_ExtensionNamingInitialsWordCase: SwiftProtobuf.Mes try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_ExtensionNamingInitialsWordCase, rhs: SwiftUnittest_Names_ExtensionNamingInitialsWordCase) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase, rhs: SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension SwiftUnittest_Names_ValidIdentifiers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_ValidIdentifiers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ValidIdentifiers" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "_1field"), - 2: .standard(proto: "_field"), - 3: .standard(proto: "_3field_3"), - 4: .standard(proto: "_4"), - 5: .standard(proto: "_5field"), - 6: .standard(proto: "enum_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}_1field\0\u{3}_field\0\u{3}_3field_3\0\u{3}_4\0\u{3}_5field\0\u{3}enum_field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28322,7 +22198,7 @@ extension SwiftUnittest_Names_ValidIdentifiers: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_ValidIdentifiers, rhs: SwiftUnittest_Names_ValidIdentifiers) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_ValidIdentifiers, rhs: SwiftProtoTesting_Names_ValidIdentifiers) -> Bool { if lhs.__1Field != rhs.__1Field {return false} if lhs._field != rhs._field {return false} if lhs.__3Field3 != rhs.__3Field3 {return false} @@ -28333,20 +22209,13 @@ extension SwiftUnittest_Names_ValidIdentifiers: SwiftProtobuf.Message, SwiftProt } } -extension SwiftUnittest_Names_ValidIdentifiers.TestEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "TEST_ENUM_0"), - 1: .same(proto: "TEST_ENUM_FIRST"), - 2: .same(proto: "_2"), - 3: .same(proto: "_3_VALUE"), - ] +extension SwiftProtoTesting_Names_ValidIdentifiers.TestEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0TEST_ENUM_0\0\u{1}TEST_ENUM_FIRST\0\u{1}_2\0\u{1}_3_VALUE\0") } -extension SwiftUnittest_Names_SpecialNames1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_SpecialNames1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SpecialNames1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "str"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}str\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28378,18 +22247,16 @@ extension SwiftUnittest_Names_SpecialNames1: SwiftProtobuf.Message, SwiftProtobu try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_SpecialNames1, rhs: SwiftUnittest_Names_SpecialNames1) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_SpecialNames1, rhs: SwiftProtoTesting_Names_SpecialNames1) -> Bool { if lhs.newValue != rhs.newValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_SpecialNames2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_SpecialNames2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SpecialNames2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "new_value"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}new_value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28414,25 +22281,26 @@ extension SwiftUnittest_Names_SpecialNames2: SwiftProtobuf.Message, SwiftProtobu try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_SpecialNames2, rhs: SwiftUnittest_Names_SpecialNames2) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_SpecialNames2, rhs: SwiftProtoTesting_Names_SpecialNames2) -> Bool { if lhs._newValue != rhs._newValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_SpecialNames3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_SpecialNames3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SpecialNames3" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "str"), - 2: .standard(proto: "forces_storage"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}str\0\u{3}forces_storage\0") fileprivate class _StorageClass { - var _newValue: SwiftUnittest_Names_SpecialNames3.OneOf_NewValue? - var _forcesStorage: SwiftUnittest_Names_SpecialNames3? = nil + var _newValue: SwiftProtoTesting_Names_SpecialNames3.OneOf_NewValue? + var _forcesStorage: SwiftProtoTesting_Names_SpecialNames3? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -28488,7 +22356,7 @@ extension SwiftUnittest_Names_SpecialNames3: SwiftProtobuf.Message, SwiftProtobu try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_SpecialNames3, rhs: SwiftUnittest_Names_SpecialNames3) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_SpecialNames3, rhs: SwiftProtoTesting_Names_SpecialNames3) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -28504,18 +22372,19 @@ extension SwiftUnittest_Names_SpecialNames3: SwiftProtobuf.Message, SwiftProtobu } } -extension SwiftUnittest_Names_SpecialNames4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_SpecialNames4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SpecialNames4" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "new_value"), - 2: .standard(proto: "forces_storage"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}new_value\0\u{3}forces_storage\0") fileprivate class _StorageClass { var _newValue: String? = nil - var _forcesStorage: SwiftUnittest_Names_SpecialNames4? = nil + var _forcesStorage: SwiftProtoTesting_Names_SpecialNames4? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -28564,7 +22433,7 @@ extension SwiftUnittest_Names_SpecialNames4: SwiftProtobuf.Message, SwiftProtobu try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_SpecialNames4, rhs: SwiftUnittest_Names_SpecialNames4) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_SpecialNames4, rhs: SwiftProtoTesting_Names_SpecialNames4) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 diff --git a/Reference/unittest_swift_naming_no_prefix.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_naming_no_prefix.pb.swift similarity index 91% rename from Reference/unittest_swift_naming_no_prefix.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_naming_no_prefix.pb.swift index 025642f22..9cd93c6ad 100644 --- a/Reference/unittest_swift_naming_no_prefix.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_naming_no_prefix.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_naming_no_prefix.proto @@ -23,7 +24,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -40,7 +40,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// /// Top level extensions declarations are qualified with `Extensions_`, so there is nothing special /// is needed in generation handling. -struct BaseMessage: SwiftProtobuf.ExtensibleMessage { +struct BaseMessage: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -52,15 +52,11 @@ struct BaseMessage: SwiftProtobuf.ExtensibleMessage { var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -#if swift(>=5.5) && canImport(_Concurrency) -extension BaseMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_naming_no_prefix.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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. @@ -83,7 +79,7 @@ extension BaseMessage { } } -extension SwiftUnittest_Names_ExtensionNamingInitialsLowers { +extension SwiftProtoTesting_Names_ExtensionNamingInitialsLowers { var http: Int32 { get {return getExtensionValue(ext: Extensions_http) ?? 0} @@ -341,7 +337,7 @@ extension SwiftUnittest_Names_ExtensionNamingInitialsLowers { } } -extension SwiftUnittest_Names_ExtensionNamingInitialsUppers { +extension SwiftProtoTesting_Names_ExtensionNamingInitialsUppers { var http: Int32 { get {return getExtensionValue(ext: Extensions_HTTP) ?? 0} @@ -584,7 +580,7 @@ extension SwiftUnittest_Names_ExtensionNamingInitialsUppers { } } -extension SwiftUnittest_Names_ExtensionNamingInitialsWordCase { +extension SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase { var http: Int32 { get {return getExtensionValue(ext: Extensions_Http) ?? 0} @@ -891,247 +887,247 @@ let UnittestSwiftNamingNoPrefix_Extensions: SwiftProtobuf.SimpleExtensionMap = [ // constructing a `SimpleExtensionMap`, otherwise, use the above _Extension Properties_ // accessors for the extension fields on the messages directly. -let Extensions_http = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_http = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 101, fieldName: "http" ) -let Extensions_http_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_http_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 102, fieldName: "http_request" ) -let Extensions_the_http_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_the_http_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 103, fieldName: "the_http_request" ) -let Extensions_the_http = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_the_http = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 104, fieldName: "the_http" ) -let Extensions_https = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_https = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 111, fieldName: "https" ) -let Extensions_https_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_https_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 112, fieldName: "https_request" ) -let Extensions_the_https_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_the_https_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 113, fieldName: "the_https_request" ) -let Extensions_the_https = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_the_https = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 114, fieldName: "the_https" ) -let Extensions_url = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_url = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 121, fieldName: "url" ) -let Extensions_url_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_url_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 122, fieldName: "url_value" ) -let Extensions_the_url_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_the_url_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 123, fieldName: "the_url_value" ) -let Extensions_the_url = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_the_url = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 124, fieldName: "the_url" ) -let Extensions_a_b_c = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_a_b_c = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 131, fieldName: "a_b_c" ) -let Extensions_id = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_id = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 141, fieldName: "id" ) -let Extensions_id_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_id_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 142, fieldName: "id_number" ) -let Extensions_the_id_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_the_id_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 143, fieldName: "the_id_number" ) -let Extensions_request_id = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_request_id = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 144, fieldName: "request_id" ) -let Extensions_HTTP = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_HTTP = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 101, fieldName: "HTTP" ) -let Extensions_HTTP_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_HTTP_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 102, fieldName: "HTTP_request" ) -let Extensions_the_HTTP_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_the_HTTP_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 103, fieldName: "the_HTTP_request" ) -let Extensions_the_HTTP = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_the_HTTP = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 104, fieldName: "the_HTTP" ) -let Extensions_HTTPS = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_HTTPS = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 111, fieldName: "HTTPS" ) -let Extensions_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 112, fieldName: "HTTPS_request" ) -let Extensions_the_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_the_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 113, fieldName: "the_HTTPS_request" ) -let Extensions_the_HTTPS = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_the_HTTPS = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 114, fieldName: "the_HTTPS" ) -let Extensions_URL = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_URL = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 121, fieldName: "URL" ) -let Extensions_URL_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_URL_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 122, fieldName: "URL_value" ) -let Extensions_the_URL_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_the_URL_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 123, fieldName: "the_URL_value" ) -let Extensions_the_URL = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_the_URL = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 124, fieldName: "the_URL" ) -let Extensions_ID = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_ID = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 141, fieldName: "ID" ) -let Extensions_ID_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_ID_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 142, fieldName: "ID_number" ) -let Extensions_the_ID_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_the_ID_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 143, fieldName: "the_ID_number" ) -let Extensions_request_ID = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_request_ID = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 144, fieldName: "request_ID" ) -let Extensions_Http = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_Http = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 101, fieldName: "Http" ) -let Extensions_HttpRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_HttpRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 102, fieldName: "HttpRequest" ) -let Extensions_TheHttpRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_TheHttpRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 103, fieldName: "TheHttpRequest" ) -let Extensions_TheHttp = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_TheHttp = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 104, fieldName: "TheHttp" ) -let Extensions_Https = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_Https = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 111, fieldName: "Https" ) -let Extensions_HttpsRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_HttpsRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 112, fieldName: "HttpsRequest" ) -let Extensions_TheHttpsRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_TheHttpsRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 113, fieldName: "TheHttpsRequest" ) -let Extensions_TheHttps = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_TheHttps = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 114, fieldName: "TheHttps" ) -let Extensions_Url = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_Url = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 121, fieldName: "Url" ) -let Extensions_UrlValue = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_UrlValue = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 122, fieldName: "UrlValue" ) -let Extensions_TheUrlValue = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_TheUrlValue = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 123, fieldName: "TheUrlValue" ) -let Extensions_TheUrl = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_TheUrl = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 124, fieldName: "TheUrl" ) -let Extensions_Id = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_Id = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 141, fieldName: "Id" ) -let Extensions_IdNumber = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_IdNumber = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 142, fieldName: "IdNumber" ) -let Extensions_TheIdNumber = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_TheIdNumber = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 143, fieldName: "TheIdNumber" ) -let Extensions_RequestId = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_RequestId = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 144, fieldName: "RequestId" ) diff --git a/Reference/unittest_swift_naming_number_prefix.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_naming_number_prefix.pb.swift similarity index 84% rename from Reference/unittest_swift_naming_number_prefix.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_naming_number_prefix.pb.swift index c4e7d1cdf..0afb04ca6 100644 --- a/Reference/unittest_swift_naming_number_prefix.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_naming_number_prefix.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_naming_number_prefix.proto @@ -23,7 +24,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -36,17 +36,17 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct _4fun_Mumble_MyMessage { +struct _4fun_SwiftProtoTesting_Mumble_MyMessage: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -57,19 +57,13 @@ struct _4fun_Mumble_MyMessage { fileprivate var _a: Int32? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension _4fun_Mumble_MyMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "_4fun.mumble" +fileprivate let _protobuf_package = "_4fun.swift_proto_testing.mumble" -extension _4fun_Mumble_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension _4fun_SwiftProtoTesting_Mumble_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MyMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -94,7 +88,7 @@ extension _4fun_Mumble_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageI try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: _4fun_Mumble_MyMessage, rhs: _4fun_Mumble_MyMessage) -> Bool { + static func ==(lhs: _4fun_SwiftProtoTesting_Mumble_MyMessage, rhs: _4fun_SwiftProtoTesting_Mumble_MyMessage) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Reference/unittest_swift_oneof_all_required.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_oneof_all_required.pb.swift similarity index 75% rename from Reference/unittest_swift_oneof_all_required.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_oneof_all_required.pb.swift index 8adcf5714..d82adff86 100644 --- a/Reference/unittest_swift_oneof_all_required.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_oneof_all_required.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_oneof_all_required.proto @@ -37,7 +38,6 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -50,17 +50,17 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_OneOfOptionMessage1 { +struct SwiftProtoTesting_OneOfOptionMessage1: Sendable { // 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 requiredField: Int32 { - get {return _requiredField ?? 0} + get {_requiredField ?? 0} set {_requiredField = newValue} } /// Returns true if `requiredField` has been explicitly set. - var hasRequiredField: Bool {return self._requiredField != nil} + var hasRequiredField: Bool {self._requiredField != nil} /// Clears the value of `requiredField`. Subsequent reads from it will return its default value. mutating func clearRequiredField() {self._requiredField = nil} @@ -71,17 +71,17 @@ struct ProtobufUnittest_OneOfOptionMessage1 { fileprivate var _requiredField: Int32? = nil } -struct ProtobufUnittest_OneOfOptionMessage2 { +struct SwiftProtoTesting_OneOfOptionMessage2: Sendable { // 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 requiredField: Int32 { - get {return _requiredField ?? 0} + get {_requiredField ?? 0} set {_requiredField = newValue} } /// Returns true if `requiredField` has been explicitly set. - var hasRequiredField: Bool {return self._requiredField != nil} + var hasRequiredField: Bool {self._requiredField != nil} /// Clears the value of `requiredField`. Subsequent reads from it will return its default value. mutating func clearRequiredField() {self._requiredField = nil} @@ -92,33 +92,33 @@ struct ProtobufUnittest_OneOfOptionMessage2 { fileprivate var _requiredField: Int32? = nil } -struct ProtobufUnittest_OneOfContainer { +struct SwiftProtoTesting_OneOfContainer: Sendable { // 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 option: ProtobufUnittest_OneOfContainer.OneOf_Option? = nil + var option: SwiftProtoTesting_OneOfContainer.OneOf_Option? = nil - var option1: ProtobufUnittest_OneOfOptionMessage1 { + var option1: SwiftProtoTesting_OneOfOptionMessage1 { get { if case .option1(let v)? = option {return v} - return ProtobufUnittest_OneOfOptionMessage1() + return SwiftProtoTesting_OneOfOptionMessage1() } set {option = .option1(newValue)} } - var option2: ProtobufUnittest_OneOfOptionMessage2 { + var option2: SwiftProtoTesting_OneOfOptionMessage2 { get { if case .option2(let v)? = option {return v} - return ProtobufUnittest_OneOfOptionMessage2() + return SwiftProtoTesting_OneOfOptionMessage2() } set {option = .option2(newValue)} } - var option3: ProtobufUnittest_OneOfContainer.Option3 { + var option3: SwiftProtoTesting_OneOfContainer.Option3 { get { if case .option3(let v)? = option {return v} - return ProtobufUnittest_OneOfContainer.Option3() + return SwiftProtoTesting_OneOfContainer.Option3() } set {option = .option3(newValue)} } @@ -133,10 +133,10 @@ struct ProtobufUnittest_OneOfContainer { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_Option: Equatable { - case option1(ProtobufUnittest_OneOfOptionMessage1) - case option2(ProtobufUnittest_OneOfOptionMessage2) - case option3(ProtobufUnittest_OneOfContainer.Option3) + enum OneOf_Option: Equatable, Sendable { + case option1(SwiftProtoTesting_OneOfOptionMessage1) + case option2(SwiftProtoTesting_OneOfOptionMessage2) + case option3(SwiftProtoTesting_OneOfContainer.Option3) case option4(Int32) fileprivate var isInitialized: Bool { @@ -160,54 +160,28 @@ struct ProtobufUnittest_OneOfContainer { } } - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_OneOfContainer.OneOf_Option, rhs: ProtobufUnittest_OneOfContainer.OneOf_Option) -> 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 (.option1, .option1): return { - guard case .option1(let l) = lhs, case .option1(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.option2, .option2): return { - guard case .option2(let l) = lhs, case .option2(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.option3, .option3): return { - guard case .option3(let l) = lhs, case .option3(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.option4, .option4): return { - guard case .option4(let l) = lhs, case .option4(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - struct Option3 { + struct Option3: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} var b: String { - get {return _b ?? String()} + get {_b ?? String()} set {_b = newValue} } /// Returns true if `b` has been explicitly set. - var hasB: Bool {return self._b != nil} + var hasB: Bool {self._b != nil} /// Clears the value of `b`. Subsequent reads from it will return its default value. mutating func clearB() {self._b = nil} @@ -222,23 +196,13 @@ struct ProtobufUnittest_OneOfContainer { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_OneOfOptionMessage1: @unchecked Sendable {} -extension ProtobufUnittest_OneOfOptionMessage2: @unchecked Sendable {} -extension ProtobufUnittest_OneOfContainer: @unchecked Sendable {} -extension ProtobufUnittest_OneOfContainer.OneOf_Option: @unchecked Sendable {} -extension ProtobufUnittest_OneOfContainer.Option3: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_OneOfOptionMessage1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_OneOfOptionMessage1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".OneOfOptionMessage1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "requiredField"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}requiredField\0") public var isInitialized: Bool { if self._requiredField == nil {return false} @@ -268,18 +232,16 @@ extension ProtobufUnittest_OneOfOptionMessage1: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_OneOfOptionMessage1, rhs: ProtobufUnittest_OneOfOptionMessage1) -> Bool { + static func ==(lhs: SwiftProtoTesting_OneOfOptionMessage1, rhs: SwiftProtoTesting_OneOfOptionMessage1) -> Bool { if lhs._requiredField != rhs._requiredField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_OneOfOptionMessage2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_OneOfOptionMessage2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".OneOfOptionMessage2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "requiredField"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}requiredField\0") public var isInitialized: Bool { if self._requiredField == nil {return false} @@ -309,21 +271,16 @@ extension ProtobufUnittest_OneOfOptionMessage2: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_OneOfOptionMessage2, rhs: ProtobufUnittest_OneOfOptionMessage2) -> Bool { + static func ==(lhs: SwiftProtoTesting_OneOfOptionMessage2, rhs: SwiftProtoTesting_OneOfOptionMessage2) -> Bool { if lhs._requiredField != rhs._requiredField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_OneOfContainer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_OneOfContainer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".OneOfContainer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "option1"), - 2: .same(proto: "option2"), - 3: .unique(proto: "Option3", json: "option3"), - 6: .same(proto: "option4"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}option1\0\u{1}option2\0\u{7}Option3\0\u{2}\u{3}option4\0") public var isInitialized: Bool { if let v = self.option, !v.isInitialized {return false} @@ -337,7 +294,7 @@ extension ProtobufUnittest_OneOfContainer: SwiftProtobuf.Message, SwiftProtobuf. // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { case 1: try { - var v: ProtobufUnittest_OneOfOptionMessage1? + var v: SwiftProtoTesting_OneOfOptionMessage1? var hadOneofValue = false if let current = self.option { hadOneofValue = true @@ -350,7 +307,7 @@ extension ProtobufUnittest_OneOfContainer: SwiftProtobuf.Message, SwiftProtobuf. } }() case 2: try { - var v: ProtobufUnittest_OneOfOptionMessage2? + var v: SwiftProtoTesting_OneOfOptionMessage2? var hadOneofValue = false if let current = self.option { hadOneofValue = true @@ -363,7 +320,7 @@ extension ProtobufUnittest_OneOfContainer: SwiftProtobuf.Message, SwiftProtobuf. } }() case 3: try { - var v: ProtobufUnittest_OneOfContainer.Option3? + var v: SwiftProtoTesting_OneOfContainer.Option3? var hadOneofValue = false if let current = self.option { hadOneofValue = true @@ -415,19 +372,16 @@ extension ProtobufUnittest_OneOfContainer: SwiftProtobuf.Message, SwiftProtobuf. try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_OneOfContainer, rhs: ProtobufUnittest_OneOfContainer) -> Bool { + static func ==(lhs: SwiftProtoTesting_OneOfContainer, rhs: SwiftProtoTesting_OneOfContainer) -> Bool { if lhs.option != rhs.option {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_OneOfContainer.Option3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_OneOfContainer.protoMessageName + ".Option3" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 4: .same(proto: "a"), - 5: .same(proto: "b"), - ] +extension SwiftProtoTesting_OneOfContainer.Option3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_OneOfContainer.protoMessageName + ".Option3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{4}a\0\u{1}b\0") public var isInitialized: Bool { if self._a == nil {return false} @@ -461,7 +415,7 @@ extension ProtobufUnittest_OneOfContainer.Option3: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_OneOfContainer.Option3, rhs: ProtobufUnittest_OneOfContainer.Option3) -> Bool { + static func ==(lhs: SwiftProtoTesting_OneOfContainer.Option3, rhs: SwiftProtoTesting_OneOfContainer.Option3) -> Bool { if lhs._a != rhs._a {return false} if lhs._b != rhs._b {return false} if lhs.unknownFields != rhs.unknownFields {return false} diff --git a/Reference/unittest_swift_oneof_merging.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_oneof_merging.pb.swift similarity index 71% rename from Reference/unittest_swift_oneof_merging.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_oneof_merging.pb.swift index 13e3ce71e..63aeddadf 100644 --- a/Reference/unittest_swift_oneof_merging.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_oneof_merging.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_oneof_merging.proto @@ -38,12 +39,12 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct SwiftUnittest_TestMessage { +struct SwiftProtoTesting_Merging_TestMessage: Sendable { // 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 oneofField: SwiftUnittest_TestMessage.OneOf_OneofField? = nil + var oneofField: SwiftProtoTesting_Merging_TestMessage.OneOf_OneofField? = nil var oneofUint32: UInt32 { get { @@ -53,10 +54,10 @@ struct SwiftUnittest_TestMessage { set {oneofField = .oneofUint32(newValue)} } - var oneofNestedMessage: SwiftUnittest_TestMessage.NestedMessage { + var oneofNestedMessage: SwiftProtoTesting_Merging_TestMessage.NestedMessage { get { if case .oneofNestedMessage(let v)? = oneofField {return v} - return SwiftUnittest_TestMessage.NestedMessage() + return SwiftProtoTesting_Merging_TestMessage.NestedMessage() } set {oneofField = .oneofNestedMessage(newValue)} } @@ -79,69 +80,43 @@ struct SwiftUnittest_TestMessage { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case oneofUint32(UInt32) - case oneofNestedMessage(SwiftUnittest_TestMessage.NestedMessage) + case oneofNestedMessage(SwiftProtoTesting_Merging_TestMessage.NestedMessage) case oneofString(String) case oneofBytes(Data) - #if !swift(>=4.1) - static func ==(lhs: SwiftUnittest_TestMessage.OneOf_OneofField, rhs: SwiftUnittest_TestMessage.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - struct NestedMessage { + struct NestedMessage: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} var b: Int32 { - get {return _b ?? 0} + get {_b ?? 0} set {_b = newValue} } /// Returns true if `b` has been explicitly set. - var hasB: Bool {return self._b != nil} + var hasB: Bool {self._b != nil} /// Clears the value of `b`. Subsequent reads from it will return its default value. mutating func clearB() {self._b = nil} var c: Int32 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -157,32 +132,32 @@ struct SwiftUnittest_TestMessage { init() {} } -struct SwiftUnittest_TestParsingMerge { +struct SwiftProtoTesting_Merging_TestParsingMerge: Sendable { // 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 optionalMessage: SwiftUnittest_TestMessage { - get {return _optionalMessage ?? SwiftUnittest_TestMessage()} + var optionalMessage: SwiftProtoTesting_Merging_TestMessage { + get {_optionalMessage ?? SwiftProtoTesting_Merging_TestMessage()} set {_optionalMessage = newValue} } /// Returns true if `optionalMessage` has been explicitly set. - var hasOptionalMessage: Bool {return self._optionalMessage != nil} + var hasOptionalMessage: Bool {self._optionalMessage != nil} /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalMessage() {self._optionalMessage = nil} - var repeatedMessage: [SwiftUnittest_TestMessage] = [] + var repeatedMessage: [SwiftProtoTesting_Merging_TestMessage] = [] var unknownFields = SwiftProtobuf.UnknownStorage() - struct RepeatedFieldsGenerator { + struct RepeatedFieldsGenerator: Sendable { // 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: [SwiftUnittest_TestMessage] = [] + var field1: [SwiftProtoTesting_Merging_TestMessage] = [] - var field2: [SwiftUnittest_TestMessage] = [] + var field2: [SwiftProtoTesting_Merging_TestMessage] = [] var unknownFields = SwiftProtobuf.UnknownStorage() @@ -191,29 +166,16 @@ struct SwiftUnittest_TestParsingMerge { init() {} - fileprivate var _optionalMessage: SwiftUnittest_TestMessage? = nil + fileprivate var _optionalMessage: SwiftProtoTesting_Merging_TestMessage? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension SwiftUnittest_TestMessage: @unchecked Sendable {} -extension SwiftUnittest_TestMessage.OneOf_OneofField: @unchecked Sendable {} -extension SwiftUnittest_TestMessage.NestedMessage: @unchecked Sendable {} -extension SwiftUnittest_TestParsingMerge: @unchecked Sendable {} -extension SwiftUnittest_TestParsingMerge.RepeatedFieldsGenerator: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "swift_unittest" +fileprivate let _protobuf_package = "swift_proto_testing.merging" -extension SwiftUnittest_TestMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Merging_TestMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}o\u{1}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -230,7 +192,7 @@ extension SwiftUnittest_TestMessage: SwiftProtobuf.Message, SwiftProtobuf._Messa } }() case 112: try { - var v: SwiftUnittest_TestMessage.NestedMessage? + var v: SwiftProtoTesting_Merging_TestMessage.NestedMessage? var hadOneofValue = false if let current = self.oneofField { hadOneofValue = true @@ -290,20 +252,16 @@ extension SwiftUnittest_TestMessage: SwiftProtobuf.Message, SwiftProtobuf._Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_TestMessage, rhs: SwiftUnittest_TestMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Merging_TestMessage, rhs: SwiftProtoTesting_Merging_TestMessage) -> Bool { if lhs.oneofField != rhs.oneofField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_TestMessage.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_TestMessage.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 2: .same(proto: "b"), - 3: .same(proto: "c"), - ] +extension SwiftProtoTesting_Merging_TestMessage.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Merging_TestMessage.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0\u{1}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -336,7 +294,7 @@ extension SwiftUnittest_TestMessage.NestedMessage: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_TestMessage.NestedMessage, rhs: SwiftUnittest_TestMessage.NestedMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Merging_TestMessage.NestedMessage, rhs: SwiftProtoTesting_Merging_TestMessage.NestedMessage) -> Bool { if lhs._a != rhs._a {return false} if lhs._b != rhs._b {return false} if lhs._c != rhs._c {return false} @@ -345,12 +303,9 @@ extension SwiftUnittest_TestMessage.NestedMessage: SwiftProtobuf.Message, SwiftP } } -extension SwiftUnittest_TestParsingMerge: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Merging_TestParsingMerge: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestParsingMerge" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_message"), - 2: .standard(proto: "repeated_message"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_message\0\u{3}repeated_message\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -379,7 +334,7 @@ extension SwiftUnittest_TestParsingMerge: SwiftProtobuf.Message, SwiftProtobuf._ try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_TestParsingMerge, rhs: SwiftUnittest_TestParsingMerge) -> Bool { + static func ==(lhs: SwiftProtoTesting_Merging_TestParsingMerge, rhs: SwiftProtoTesting_Merging_TestParsingMerge) -> Bool { if lhs._optionalMessage != rhs._optionalMessage {return false} if lhs.repeatedMessage != rhs.repeatedMessage {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -387,12 +342,9 @@ extension SwiftUnittest_TestParsingMerge: SwiftProtobuf.Message, SwiftProtobuf._ } } -extension SwiftUnittest_TestParsingMerge.RepeatedFieldsGenerator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_TestParsingMerge.protoMessageName + ".RepeatedFieldsGenerator" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "field1"), - 2: .same(proto: "field2"), - ] +extension SwiftProtoTesting_Merging_TestParsingMerge.RepeatedFieldsGenerator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Merging_TestParsingMerge.protoMessageName + ".RepeatedFieldsGenerator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field1\0\u{1}field2\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -417,7 +369,7 @@ extension SwiftUnittest_TestParsingMerge.RepeatedFieldsGenerator: SwiftProtobuf. try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_TestParsingMerge.RepeatedFieldsGenerator, rhs: SwiftUnittest_TestParsingMerge.RepeatedFieldsGenerator) -> Bool { + static func ==(lhs: SwiftProtoTesting_Merging_TestParsingMerge.RepeatedFieldsGenerator, rhs: SwiftProtoTesting_Merging_TestParsingMerge.RepeatedFieldsGenerator) -> Bool { if lhs.field1 != rhs.field1 {return false} if lhs.field2 != rhs.field2 {return false} if lhs.unknownFields != rhs.unknownFields {return false} diff --git a/Reference/Tests/SwiftProtobufTests/unittest_swift_oneof_switch_split.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_oneof_switch_split.pb.swift new file mode 100644 index 000000000..8a0d891d2 --- /dev/null +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_oneof_switch_split.pb.swift @@ -0,0 +1,10789 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: unittest_swift_oneof_switch_split.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protos/Tests/SwiftProtobufTests/unittest_swift_oneof_switch_split.proto +// Test for switch statement splitting in oneof traverse generation +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2025 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 +// +// ----------------------------------------------------------------------------- +/// +/// This message tests oneof switch splitting with interleaved non-oneof fields. +/// - Regular fields at 2, 251, 502, and 509 break oneof into multiple chunks +/// - Regular field at 2 creates first break +/// - Regular field at 251 creates second break +/// - Regular field at 502 creates third break +/// - Regular field at 509 creates fourth break +/// - The oneof fields are also reordered to test proper sorting in generated code +/// +// ----------------------------------------------------------------------------- + +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 SwiftProtoTesting_SwitchSplit_SwitchSplitMessage: Sendable { + // 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. + + /// Regular fields that split the oneof into chunks + var regularField002: Int32 { + get {_regularField002 ?? 0} + set {_regularField002 = newValue} + } + /// Returns true if `regularField002` has been explicitly set. + var hasRegularField002: Bool {self._regularField002 != nil} + /// Clears the value of `regularField002`. Subsequent reads from it will return its default value. + mutating func clearRegularField002() {self._regularField002 = nil} + + var regularField251: Int32 { + get {_regularField251 ?? 0} + set {_regularField251 = newValue} + } + /// Returns true if `regularField251` has been explicitly set. + var hasRegularField251: Bool {self._regularField251 != nil} + /// Clears the value of `regularField251`. Subsequent reads from it will return its default value. + mutating func clearRegularField251() {self._regularField251 = nil} + + var regularField502: Int32 { + get {_regularField502 ?? 0} + set {_regularField502 = newValue} + } + /// Returns true if `regularField502` has been explicitly set. + var hasRegularField502: Bool {self._regularField502 != nil} + /// Clears the value of `regularField502`. Subsequent reads from it will return its default value. + mutating func clearRegularField502() {self._regularField502 = nil} + + var regularField509: Int32 { + get {_regularField509 ?? 0} + set {_regularField509 = newValue} + } + /// Returns true if `regularField509` has been explicitly set. + var hasRegularField509: Bool {self._regularField509 != nil} + /// Clears the value of `regularField509`. Subsequent reads from it will return its default value. + mutating func clearRegularField509() {self._regularField509 = nil} + + var value: SwiftProtoTesting_SwitchSplit_SwitchSplitMessage.OneOf_Value? = nil + + var field001: Int32 { + get { + if case .field001(let v)? = value {return v} + return 0 + } + set {value = .field001(newValue)} + } + + var field003: Int32 { + get { + if case .field003(let v)? = value {return v} + return 0 + } + set {value = .field003(newValue)} + } + + var field004: Int32 { + get { + if case .field004(let v)? = value {return v} + return 0 + } + set {value = .field004(newValue)} + } + + var field005: Int32 { + get { + if case .field005(let v)? = value {return v} + return 0 + } + set {value = .field005(newValue)} + } + + var field006: Int32 { + get { + if case .field006(let v)? = value {return v} + return 0 + } + set {value = .field006(newValue)} + } + + var field007: Int32 { + get { + if case .field007(let v)? = value {return v} + return 0 + } + set {value = .field007(newValue)} + } + + var field008: Int32 { + get { + if case .field008(let v)? = value {return v} + return 0 + } + set {value = .field008(newValue)} + } + + var field009: Int32 { + get { + if case .field009(let v)? = value {return v} + return 0 + } + set {value = .field009(newValue)} + } + + var field010: Int32 { + get { + if case .field010(let v)? = value {return v} + return 0 + } + set {value = .field010(newValue)} + } + + var field011: Int32 { + get { + if case .field011(let v)? = value {return v} + return 0 + } + set {value = .field011(newValue)} + } + + var field012: Int32 { + get { + if case .field012(let v)? = value {return v} + return 0 + } + set {value = .field012(newValue)} + } + + var field013: Int32 { + get { + if case .field013(let v)? = value {return v} + return 0 + } + set {value = .field013(newValue)} + } + + var field014: Int32 { + get { + if case .field014(let v)? = value {return v} + return 0 + } + set {value = .field014(newValue)} + } + + var field015: Int32 { + get { + if case .field015(let v)? = value {return v} + return 0 + } + set {value = .field015(newValue)} + } + + var field016: Int32 { + get { + if case .field016(let v)? = value {return v} + return 0 + } + set {value = .field016(newValue)} + } + + var field017: Int32 { + get { + if case .field017(let v)? = value {return v} + return 0 + } + set {value = .field017(newValue)} + } + + var field018: Int32 { + get { + if case .field018(let v)? = value {return v} + return 0 + } + set {value = .field018(newValue)} + } + + var field019: Int32 { + get { + if case .field019(let v)? = value {return v} + return 0 + } + set {value = .field019(newValue)} + } + + var field020: Int32 { + get { + if case .field020(let v)? = value {return v} + return 0 + } + set {value = .field020(newValue)} + } + + var field021: Int32 { + get { + if case .field021(let v)? = value {return v} + return 0 + } + set {value = .field021(newValue)} + } + + var field022: Int32 { + get { + if case .field022(let v)? = value {return v} + return 0 + } + set {value = .field022(newValue)} + } + + var field023: Int32 { + get { + if case .field023(let v)? = value {return v} + return 0 + } + set {value = .field023(newValue)} + } + + var field024: Int32 { + get { + if case .field024(let v)? = value {return v} + return 0 + } + set {value = .field024(newValue)} + } + + var field025: Int32 { + get { + if case .field025(let v)? = value {return v} + return 0 + } + set {value = .field025(newValue)} + } + + var field026: Int32 { + get { + if case .field026(let v)? = value {return v} + return 0 + } + set {value = .field026(newValue)} + } + + var field027: Int32 { + get { + if case .field027(let v)? = value {return v} + return 0 + } + set {value = .field027(newValue)} + } + + var field028: Int32 { + get { + if case .field028(let v)? = value {return v} + return 0 + } + set {value = .field028(newValue)} + } + + var field029: Int32 { + get { + if case .field029(let v)? = value {return v} + return 0 + } + set {value = .field029(newValue)} + } + + var field030: Int32 { + get { + if case .field030(let v)? = value {return v} + return 0 + } + set {value = .field030(newValue)} + } + + var field031: Int32 { + get { + if case .field031(let v)? = value {return v} + return 0 + } + set {value = .field031(newValue)} + } + + var field032: Int32 { + get { + if case .field032(let v)? = value {return v} + return 0 + } + set {value = .field032(newValue)} + } + + var field033: Int32 { + get { + if case .field033(let v)? = value {return v} + return 0 + } + set {value = .field033(newValue)} + } + + var field034: Int32 { + get { + if case .field034(let v)? = value {return v} + return 0 + } + set {value = .field034(newValue)} + } + + var field035: Int32 { + get { + if case .field035(let v)? = value {return v} + return 0 + } + set {value = .field035(newValue)} + } + + var field036: Int32 { + get { + if case .field036(let v)? = value {return v} + return 0 + } + set {value = .field036(newValue)} + } + + var field037: Int32 { + get { + if case .field037(let v)? = value {return v} + return 0 + } + set {value = .field037(newValue)} + } + + var field038: Int32 { + get { + if case .field038(let v)? = value {return v} + return 0 + } + set {value = .field038(newValue)} + } + + var field039: Int32 { + get { + if case .field039(let v)? = value {return v} + return 0 + } + set {value = .field039(newValue)} + } + + var field040: Int32 { + get { + if case .field040(let v)? = value {return v} + return 0 + } + set {value = .field040(newValue)} + } + + var field041: Int32 { + get { + if case .field041(let v)? = value {return v} + return 0 + } + set {value = .field041(newValue)} + } + + var field042: Int32 { + get { + if case .field042(let v)? = value {return v} + return 0 + } + set {value = .field042(newValue)} + } + + var field043: Int32 { + get { + if case .field043(let v)? = value {return v} + return 0 + } + set {value = .field043(newValue)} + } + + var field044: Int32 { + get { + if case .field044(let v)? = value {return v} + return 0 + } + set {value = .field044(newValue)} + } + + var field045: Int32 { + get { + if case .field045(let v)? = value {return v} + return 0 + } + set {value = .field045(newValue)} + } + + var field046: Int32 { + get { + if case .field046(let v)? = value {return v} + return 0 + } + set {value = .field046(newValue)} + } + + var field047: Int32 { + get { + if case .field047(let v)? = value {return v} + return 0 + } + set {value = .field047(newValue)} + } + + var field048: Int32 { + get { + if case .field048(let v)? = value {return v} + return 0 + } + set {value = .field048(newValue)} + } + + var field049: Int32 { + get { + if case .field049(let v)? = value {return v} + return 0 + } + set {value = .field049(newValue)} + } + + var field050: Int32 { + get { + if case .field050(let v)? = value {return v} + return 0 + } + set {value = .field050(newValue)} + } + + var field051: Int32 { + get { + if case .field051(let v)? = value {return v} + return 0 + } + set {value = .field051(newValue)} + } + + var field052: Int32 { + get { + if case .field052(let v)? = value {return v} + return 0 + } + set {value = .field052(newValue)} + } + + var field053: Int32 { + get { + if case .field053(let v)? = value {return v} + return 0 + } + set {value = .field053(newValue)} + } + + var field054: Int32 { + get { + if case .field054(let v)? = value {return v} + return 0 + } + set {value = .field054(newValue)} + } + + var field055: Int32 { + get { + if case .field055(let v)? = value {return v} + return 0 + } + set {value = .field055(newValue)} + } + + var field056: Int32 { + get { + if case .field056(let v)? = value {return v} + return 0 + } + set {value = .field056(newValue)} + } + + var field057: Int32 { + get { + if case .field057(let v)? = value {return v} + return 0 + } + set {value = .field057(newValue)} + } + + var field058: Int32 { + get { + if case .field058(let v)? = value {return v} + return 0 + } + set {value = .field058(newValue)} + } + + var field059: Int32 { + get { + if case .field059(let v)? = value {return v} + return 0 + } + set {value = .field059(newValue)} + } + + var field060: Int32 { + get { + if case .field060(let v)? = value {return v} + return 0 + } + set {value = .field060(newValue)} + } + + var field061: Int32 { + get { + if case .field061(let v)? = value {return v} + return 0 + } + set {value = .field061(newValue)} + } + + var field062: Int32 { + get { + if case .field062(let v)? = value {return v} + return 0 + } + set {value = .field062(newValue)} + } + + var field063: Int32 { + get { + if case .field063(let v)? = value {return v} + return 0 + } + set {value = .field063(newValue)} + } + + var field064: Int32 { + get { + if case .field064(let v)? = value {return v} + return 0 + } + set {value = .field064(newValue)} + } + + var field065: Int32 { + get { + if case .field065(let v)? = value {return v} + return 0 + } + set {value = .field065(newValue)} + } + + var field066: Int32 { + get { + if case .field066(let v)? = value {return v} + return 0 + } + set {value = .field066(newValue)} + } + + var field067: Int32 { + get { + if case .field067(let v)? = value {return v} + return 0 + } + set {value = .field067(newValue)} + } + + var field068: Int32 { + get { + if case .field068(let v)? = value {return v} + return 0 + } + set {value = .field068(newValue)} + } + + var field069: Int32 { + get { + if case .field069(let v)? = value {return v} + return 0 + } + set {value = .field069(newValue)} + } + + var field070: Int32 { + get { + if case .field070(let v)? = value {return v} + return 0 + } + set {value = .field070(newValue)} + } + + var field071: Int32 { + get { + if case .field071(let v)? = value {return v} + return 0 + } + set {value = .field071(newValue)} + } + + var field072: Int32 { + get { + if case .field072(let v)? = value {return v} + return 0 + } + set {value = .field072(newValue)} + } + + var field073: Int32 { + get { + if case .field073(let v)? = value {return v} + return 0 + } + set {value = .field073(newValue)} + } + + var field074: Int32 { + get { + if case .field074(let v)? = value {return v} + return 0 + } + set {value = .field074(newValue)} + } + + var field075: Int32 { + get { + if case .field075(let v)? = value {return v} + return 0 + } + set {value = .field075(newValue)} + } + + var field076: Int32 { + get { + if case .field076(let v)? = value {return v} + return 0 + } + set {value = .field076(newValue)} + } + + var field077: Int32 { + get { + if case .field077(let v)? = value {return v} + return 0 + } + set {value = .field077(newValue)} + } + + var field078: Int32 { + get { + if case .field078(let v)? = value {return v} + return 0 + } + set {value = .field078(newValue)} + } + + var field079: Int32 { + get { + if case .field079(let v)? = value {return v} + return 0 + } + set {value = .field079(newValue)} + } + + var field080: Int32 { + get { + if case .field080(let v)? = value {return v} + return 0 + } + set {value = .field080(newValue)} + } + + var field081: Int32 { + get { + if case .field081(let v)? = value {return v} + return 0 + } + set {value = .field081(newValue)} + } + + var field082: Int32 { + get { + if case .field082(let v)? = value {return v} + return 0 + } + set {value = .field082(newValue)} + } + + var field083: Int32 { + get { + if case .field083(let v)? = value {return v} + return 0 + } + set {value = .field083(newValue)} + } + + var field084: Int32 { + get { + if case .field084(let v)? = value {return v} + return 0 + } + set {value = .field084(newValue)} + } + + var field085: Int32 { + get { + if case .field085(let v)? = value {return v} + return 0 + } + set {value = .field085(newValue)} + } + + var field086: Int32 { + get { + if case .field086(let v)? = value {return v} + return 0 + } + set {value = .field086(newValue)} + } + + var field087: Int32 { + get { + if case .field087(let v)? = value {return v} + return 0 + } + set {value = .field087(newValue)} + } + + var field088: Int32 { + get { + if case .field088(let v)? = value {return v} + return 0 + } + set {value = .field088(newValue)} + } + + var field089: Int32 { + get { + if case .field089(let v)? = value {return v} + return 0 + } + set {value = .field089(newValue)} + } + + var field090: Int32 { + get { + if case .field090(let v)? = value {return v} + return 0 + } + set {value = .field090(newValue)} + } + + var field091: Int32 { + get { + if case .field091(let v)? = value {return v} + return 0 + } + set {value = .field091(newValue)} + } + + var field092: Int32 { + get { + if case .field092(let v)? = value {return v} + return 0 + } + set {value = .field092(newValue)} + } + + var field093: Int32 { + get { + if case .field093(let v)? = value {return v} + return 0 + } + set {value = .field093(newValue)} + } + + var field094: Int32 { + get { + if case .field094(let v)? = value {return v} + return 0 + } + set {value = .field094(newValue)} + } + + var field095: Int32 { + get { + if case .field095(let v)? = value {return v} + return 0 + } + set {value = .field095(newValue)} + } + + var field096: Int32 { + get { + if case .field096(let v)? = value {return v} + return 0 + } + set {value = .field096(newValue)} + } + + var field097: Int32 { + get { + if case .field097(let v)? = value {return v} + return 0 + } + set {value = .field097(newValue)} + } + + var field098: Int32 { + get { + if case .field098(let v)? = value {return v} + return 0 + } + set {value = .field098(newValue)} + } + + var field099: Int32 { + get { + if case .field099(let v)? = value {return v} + return 0 + } + set {value = .field099(newValue)} + } + + var field100: Int32 { + get { + if case .field100(let v)? = value {return v} + return 0 + } + set {value = .field100(newValue)} + } + + var field101: Int32 { + get { + if case .field101(let v)? = value {return v} + return 0 + } + set {value = .field101(newValue)} + } + + var field102: Int32 { + get { + if case .field102(let v)? = value {return v} + return 0 + } + set {value = .field102(newValue)} + } + + var field103: Int32 { + get { + if case .field103(let v)? = value {return v} + return 0 + } + set {value = .field103(newValue)} + } + + var field104: Int32 { + get { + if case .field104(let v)? = value {return v} + return 0 + } + set {value = .field104(newValue)} + } + + var field105: Int32 { + get { + if case .field105(let v)? = value {return v} + return 0 + } + set {value = .field105(newValue)} + } + + var field106: Int32 { + get { + if case .field106(let v)? = value {return v} + return 0 + } + set {value = .field106(newValue)} + } + + var field107: Int32 { + get { + if case .field107(let v)? = value {return v} + return 0 + } + set {value = .field107(newValue)} + } + + var field108: Int32 { + get { + if case .field108(let v)? = value {return v} + return 0 + } + set {value = .field108(newValue)} + } + + var field109: Int32 { + get { + if case .field109(let v)? = value {return v} + return 0 + } + set {value = .field109(newValue)} + } + + var field110: Int32 { + get { + if case .field110(let v)? = value {return v} + return 0 + } + set {value = .field110(newValue)} + } + + var field111: Int32 { + get { + if case .field111(let v)? = value {return v} + return 0 + } + set {value = .field111(newValue)} + } + + var field112: Int32 { + get { + if case .field112(let v)? = value {return v} + return 0 + } + set {value = .field112(newValue)} + } + + var field113: Int32 { + get { + if case .field113(let v)? = value {return v} + return 0 + } + set {value = .field113(newValue)} + } + + var field114: Int32 { + get { + if case .field114(let v)? = value {return v} + return 0 + } + set {value = .field114(newValue)} + } + + var field115: Int32 { + get { + if case .field115(let v)? = value {return v} + return 0 + } + set {value = .field115(newValue)} + } + + var field116: Int32 { + get { + if case .field116(let v)? = value {return v} + return 0 + } + set {value = .field116(newValue)} + } + + var field117: Int32 { + get { + if case .field117(let v)? = value {return v} + return 0 + } + set {value = .field117(newValue)} + } + + var field118: Int32 { + get { + if case .field118(let v)? = value {return v} + return 0 + } + set {value = .field118(newValue)} + } + + var field119: Int32 { + get { + if case .field119(let v)? = value {return v} + return 0 + } + set {value = .field119(newValue)} + } + + var field120: Int32 { + get { + if case .field120(let v)? = value {return v} + return 0 + } + set {value = .field120(newValue)} + } + + var field121: Int32 { + get { + if case .field121(let v)? = value {return v} + return 0 + } + set {value = .field121(newValue)} + } + + var field122: Int32 { + get { + if case .field122(let v)? = value {return v} + return 0 + } + set {value = .field122(newValue)} + } + + var field123: Int32 { + get { + if case .field123(let v)? = value {return v} + return 0 + } + set {value = .field123(newValue)} + } + + var field124: Int32 { + get { + if case .field124(let v)? = value {return v} + return 0 + } + set {value = .field124(newValue)} + } + + var field125: Int32 { + get { + if case .field125(let v)? = value {return v} + return 0 + } + set {value = .field125(newValue)} + } + + var field126: Int32 { + get { + if case .field126(let v)? = value {return v} + return 0 + } + set {value = .field126(newValue)} + } + + var field127: Int32 { + get { + if case .field127(let v)? = value {return v} + return 0 + } + set {value = .field127(newValue)} + } + + var field128: Int32 { + get { + if case .field128(let v)? = value {return v} + return 0 + } + set {value = .field128(newValue)} + } + + var field129: Int32 { + get { + if case .field129(let v)? = value {return v} + return 0 + } + set {value = .field129(newValue)} + } + + var field130: Int32 { + get { + if case .field130(let v)? = value {return v} + return 0 + } + set {value = .field130(newValue)} + } + + var field131: Int32 { + get { + if case .field131(let v)? = value {return v} + return 0 + } + set {value = .field131(newValue)} + } + + var field132: Int32 { + get { + if case .field132(let v)? = value {return v} + return 0 + } + set {value = .field132(newValue)} + } + + var field133: Int32 { + get { + if case .field133(let v)? = value {return v} + return 0 + } + set {value = .field133(newValue)} + } + + var field134: Int32 { + get { + if case .field134(let v)? = value {return v} + return 0 + } + set {value = .field134(newValue)} + } + + var field135: Int32 { + get { + if case .field135(let v)? = value {return v} + return 0 + } + set {value = .field135(newValue)} + } + + var field136: Int32 { + get { + if case .field136(let v)? = value {return v} + return 0 + } + set {value = .field136(newValue)} + } + + var field137: Int32 { + get { + if case .field137(let v)? = value {return v} + return 0 + } + set {value = .field137(newValue)} + } + + var field138: Int32 { + get { + if case .field138(let v)? = value {return v} + return 0 + } + set {value = .field138(newValue)} + } + + var field139: Int32 { + get { + if case .field139(let v)? = value {return v} + return 0 + } + set {value = .field139(newValue)} + } + + var field140: Int32 { + get { + if case .field140(let v)? = value {return v} + return 0 + } + set {value = .field140(newValue)} + } + + var field141: Int32 { + get { + if case .field141(let v)? = value {return v} + return 0 + } + set {value = .field141(newValue)} + } + + var field142: Int32 { + get { + if case .field142(let v)? = value {return v} + return 0 + } + set {value = .field142(newValue)} + } + + var field143: Int32 { + get { + if case .field143(let v)? = value {return v} + return 0 + } + set {value = .field143(newValue)} + } + + var field144: Int32 { + get { + if case .field144(let v)? = value {return v} + return 0 + } + set {value = .field144(newValue)} + } + + var field145: Int32 { + get { + if case .field145(let v)? = value {return v} + return 0 + } + set {value = .field145(newValue)} + } + + var field146: Int32 { + get { + if case .field146(let v)? = value {return v} + return 0 + } + set {value = .field146(newValue)} + } + + var field147: Int32 { + get { + if case .field147(let v)? = value {return v} + return 0 + } + set {value = .field147(newValue)} + } + + var field148: Int32 { + get { + if case .field148(let v)? = value {return v} + return 0 + } + set {value = .field148(newValue)} + } + + var field149: Int32 { + get { + if case .field149(let v)? = value {return v} + return 0 + } + set {value = .field149(newValue)} + } + + var field150: Int32 { + get { + if case .field150(let v)? = value {return v} + return 0 + } + set {value = .field150(newValue)} + } + + var field151: Int32 { + get { + if case .field151(let v)? = value {return v} + return 0 + } + set {value = .field151(newValue)} + } + + var field152: Int32 { + get { + if case .field152(let v)? = value {return v} + return 0 + } + set {value = .field152(newValue)} + } + + var field153: Int32 { + get { + if case .field153(let v)? = value {return v} + return 0 + } + set {value = .field153(newValue)} + } + + var field154: Int32 { + get { + if case .field154(let v)? = value {return v} + return 0 + } + set {value = .field154(newValue)} + } + + var field155: Int32 { + get { + if case .field155(let v)? = value {return v} + return 0 + } + set {value = .field155(newValue)} + } + + var field156: Int32 { + get { + if case .field156(let v)? = value {return v} + return 0 + } + set {value = .field156(newValue)} + } + + var field157: Int32 { + get { + if case .field157(let v)? = value {return v} + return 0 + } + set {value = .field157(newValue)} + } + + var field158: Int32 { + get { + if case .field158(let v)? = value {return v} + return 0 + } + set {value = .field158(newValue)} + } + + var field159: Int32 { + get { + if case .field159(let v)? = value {return v} + return 0 + } + set {value = .field159(newValue)} + } + + var field160: Int32 { + get { + if case .field160(let v)? = value {return v} + return 0 + } + set {value = .field160(newValue)} + } + + var field161: Int32 { + get { + if case .field161(let v)? = value {return v} + return 0 + } + set {value = .field161(newValue)} + } + + var field162: Int32 { + get { + if case .field162(let v)? = value {return v} + return 0 + } + set {value = .field162(newValue)} + } + + var field163: Int32 { + get { + if case .field163(let v)? = value {return v} + return 0 + } + set {value = .field163(newValue)} + } + + var field164: Int32 { + get { + if case .field164(let v)? = value {return v} + return 0 + } + set {value = .field164(newValue)} + } + + var field165: Int32 { + get { + if case .field165(let v)? = value {return v} + return 0 + } + set {value = .field165(newValue)} + } + + var field166: Int32 { + get { + if case .field166(let v)? = value {return v} + return 0 + } + set {value = .field166(newValue)} + } + + var field167: Int32 { + get { + if case .field167(let v)? = value {return v} + return 0 + } + set {value = .field167(newValue)} + } + + var field168: Int32 { + get { + if case .field168(let v)? = value {return v} + return 0 + } + set {value = .field168(newValue)} + } + + var field169: Int32 { + get { + if case .field169(let v)? = value {return v} + return 0 + } + set {value = .field169(newValue)} + } + + var field170: Int32 { + get { + if case .field170(let v)? = value {return v} + return 0 + } + set {value = .field170(newValue)} + } + + var field171: Int32 { + get { + if case .field171(let v)? = value {return v} + return 0 + } + set {value = .field171(newValue)} + } + + var field172: Int32 { + get { + if case .field172(let v)? = value {return v} + return 0 + } + set {value = .field172(newValue)} + } + + var field173: Int32 { + get { + if case .field173(let v)? = value {return v} + return 0 + } + set {value = .field173(newValue)} + } + + var field174: Int32 { + get { + if case .field174(let v)? = value {return v} + return 0 + } + set {value = .field174(newValue)} + } + + var field175: Int32 { + get { + if case .field175(let v)? = value {return v} + return 0 + } + set {value = .field175(newValue)} + } + + var field176: Int32 { + get { + if case .field176(let v)? = value {return v} + return 0 + } + set {value = .field176(newValue)} + } + + var field177: Int32 { + get { + if case .field177(let v)? = value {return v} + return 0 + } + set {value = .field177(newValue)} + } + + var field178: Int32 { + get { + if case .field178(let v)? = value {return v} + return 0 + } + set {value = .field178(newValue)} + } + + var field179: Int32 { + get { + if case .field179(let v)? = value {return v} + return 0 + } + set {value = .field179(newValue)} + } + + var field180: Int32 { + get { + if case .field180(let v)? = value {return v} + return 0 + } + set {value = .field180(newValue)} + } + + var field181: Int32 { + get { + if case .field181(let v)? = value {return v} + return 0 + } + set {value = .field181(newValue)} + } + + var field182: Int32 { + get { + if case .field182(let v)? = value {return v} + return 0 + } + set {value = .field182(newValue)} + } + + var field183: Int32 { + get { + if case .field183(let v)? = value {return v} + return 0 + } + set {value = .field183(newValue)} + } + + var field184: Int32 { + get { + if case .field184(let v)? = value {return v} + return 0 + } + set {value = .field184(newValue)} + } + + var field185: Int32 { + get { + if case .field185(let v)? = value {return v} + return 0 + } + set {value = .field185(newValue)} + } + + var field186: Int32 { + get { + if case .field186(let v)? = value {return v} + return 0 + } + set {value = .field186(newValue)} + } + + var field187: Int32 { + get { + if case .field187(let v)? = value {return v} + return 0 + } + set {value = .field187(newValue)} + } + + var field188: Int32 { + get { + if case .field188(let v)? = value {return v} + return 0 + } + set {value = .field188(newValue)} + } + + var field189: Int32 { + get { + if case .field189(let v)? = value {return v} + return 0 + } + set {value = .field189(newValue)} + } + + var field190: Int32 { + get { + if case .field190(let v)? = value {return v} + return 0 + } + set {value = .field190(newValue)} + } + + var field191: Int32 { + get { + if case .field191(let v)? = value {return v} + return 0 + } + set {value = .field191(newValue)} + } + + var field192: Int32 { + get { + if case .field192(let v)? = value {return v} + return 0 + } + set {value = .field192(newValue)} + } + + var field193: Int32 { + get { + if case .field193(let v)? = value {return v} + return 0 + } + set {value = .field193(newValue)} + } + + var field194: Int32 { + get { + if case .field194(let v)? = value {return v} + return 0 + } + set {value = .field194(newValue)} + } + + var field195: Int32 { + get { + if case .field195(let v)? = value {return v} + return 0 + } + set {value = .field195(newValue)} + } + + var field196: Int32 { + get { + if case .field196(let v)? = value {return v} + return 0 + } + set {value = .field196(newValue)} + } + + var field197: Int32 { + get { + if case .field197(let v)? = value {return v} + return 0 + } + set {value = .field197(newValue)} + } + + var field198: Int32 { + get { + if case .field198(let v)? = value {return v} + return 0 + } + set {value = .field198(newValue)} + } + + var field199: Int32 { + get { + if case .field199(let v)? = value {return v} + return 0 + } + set {value = .field199(newValue)} + } + + var field200: Int32 { + get { + if case .field200(let v)? = value {return v} + return 0 + } + set {value = .field200(newValue)} + } + + var field201: Int32 { + get { + if case .field201(let v)? = value {return v} + return 0 + } + set {value = .field201(newValue)} + } + + var field202: Int32 { + get { + if case .field202(let v)? = value {return v} + return 0 + } + set {value = .field202(newValue)} + } + + var field203: Int32 { + get { + if case .field203(let v)? = value {return v} + return 0 + } + set {value = .field203(newValue)} + } + + var field204: Int32 { + get { + if case .field204(let v)? = value {return v} + return 0 + } + set {value = .field204(newValue)} + } + + var field205: Int32 { + get { + if case .field205(let v)? = value {return v} + return 0 + } + set {value = .field205(newValue)} + } + + var field206: Int32 { + get { + if case .field206(let v)? = value {return v} + return 0 + } + set {value = .field206(newValue)} + } + + var field207: Int32 { + get { + if case .field207(let v)? = value {return v} + return 0 + } + set {value = .field207(newValue)} + } + + var field208: Int32 { + get { + if case .field208(let v)? = value {return v} + return 0 + } + set {value = .field208(newValue)} + } + + var field209: Int32 { + get { + if case .field209(let v)? = value {return v} + return 0 + } + set {value = .field209(newValue)} + } + + var field210: Int32 { + get { + if case .field210(let v)? = value {return v} + return 0 + } + set {value = .field210(newValue)} + } + + var field211: Int32 { + get { + if case .field211(let v)? = value {return v} + return 0 + } + set {value = .field211(newValue)} + } + + var field212: Int32 { + get { + if case .field212(let v)? = value {return v} + return 0 + } + set {value = .field212(newValue)} + } + + var field213: Int32 { + get { + if case .field213(let v)? = value {return v} + return 0 + } + set {value = .field213(newValue)} + } + + var field214: Int32 { + get { + if case .field214(let v)? = value {return v} + return 0 + } + set {value = .field214(newValue)} + } + + var field215: Int32 { + get { + if case .field215(let v)? = value {return v} + return 0 + } + set {value = .field215(newValue)} + } + + var field216: Int32 { + get { + if case .field216(let v)? = value {return v} + return 0 + } + set {value = .field216(newValue)} + } + + var field217: Int32 { + get { + if case .field217(let v)? = value {return v} + return 0 + } + set {value = .field217(newValue)} + } + + var field218: Int32 { + get { + if case .field218(let v)? = value {return v} + return 0 + } + set {value = .field218(newValue)} + } + + var field219: Int32 { + get { + if case .field219(let v)? = value {return v} + return 0 + } + set {value = .field219(newValue)} + } + + var field220: Int32 { + get { + if case .field220(let v)? = value {return v} + return 0 + } + set {value = .field220(newValue)} + } + + var field221: Int32 { + get { + if case .field221(let v)? = value {return v} + return 0 + } + set {value = .field221(newValue)} + } + + var field222: Int32 { + get { + if case .field222(let v)? = value {return v} + return 0 + } + set {value = .field222(newValue)} + } + + var field223: Int32 { + get { + if case .field223(let v)? = value {return v} + return 0 + } + set {value = .field223(newValue)} + } + + var field224: Int32 { + get { + if case .field224(let v)? = value {return v} + return 0 + } + set {value = .field224(newValue)} + } + + var field225: Int32 { + get { + if case .field225(let v)? = value {return v} + return 0 + } + set {value = .field225(newValue)} + } + + var field226: Int32 { + get { + if case .field226(let v)? = value {return v} + return 0 + } + set {value = .field226(newValue)} + } + + var field227: Int32 { + get { + if case .field227(let v)? = value {return v} + return 0 + } + set {value = .field227(newValue)} + } + + var field228: Int32 { + get { + if case .field228(let v)? = value {return v} + return 0 + } + set {value = .field228(newValue)} + } + + var field229: Int32 { + get { + if case .field229(let v)? = value {return v} + return 0 + } + set {value = .field229(newValue)} + } + + var field230: Int32 { + get { + if case .field230(let v)? = value {return v} + return 0 + } + set {value = .field230(newValue)} + } + + var field231: Int32 { + get { + if case .field231(let v)? = value {return v} + return 0 + } + set {value = .field231(newValue)} + } + + var field232: Int32 { + get { + if case .field232(let v)? = value {return v} + return 0 + } + set {value = .field232(newValue)} + } + + var field233: Int32 { + get { + if case .field233(let v)? = value {return v} + return 0 + } + set {value = .field233(newValue)} + } + + var field234: Int32 { + get { + if case .field234(let v)? = value {return v} + return 0 + } + set {value = .field234(newValue)} + } + + var field235: Int32 { + get { + if case .field235(let v)? = value {return v} + return 0 + } + set {value = .field235(newValue)} + } + + var field236: Int32 { + get { + if case .field236(let v)? = value {return v} + return 0 + } + set {value = .field236(newValue)} + } + + var field237: Int32 { + get { + if case .field237(let v)? = value {return v} + return 0 + } + set {value = .field237(newValue)} + } + + var field238: Int32 { + get { + if case .field238(let v)? = value {return v} + return 0 + } + set {value = .field238(newValue)} + } + + var field239: Int32 { + get { + if case .field239(let v)? = value {return v} + return 0 + } + set {value = .field239(newValue)} + } + + var field240: Int32 { + get { + if case .field240(let v)? = value {return v} + return 0 + } + set {value = .field240(newValue)} + } + + var field241: Int32 { + get { + if case .field241(let v)? = value {return v} + return 0 + } + set {value = .field241(newValue)} + } + + var field242: Int32 { + get { + if case .field242(let v)? = value {return v} + return 0 + } + set {value = .field242(newValue)} + } + + var field243: Int32 { + get { + if case .field243(let v)? = value {return v} + return 0 + } + set {value = .field243(newValue)} + } + + var field244: Int32 { + get { + if case .field244(let v)? = value {return v} + return 0 + } + set {value = .field244(newValue)} + } + + var field245: Int32 { + get { + if case .field245(let v)? = value {return v} + return 0 + } + set {value = .field245(newValue)} + } + + var field246: Int32 { + get { + if case .field246(let v)? = value {return v} + return 0 + } + set {value = .field246(newValue)} + } + + var field247: Int32 { + get { + if case .field247(let v)? = value {return v} + return 0 + } + set {value = .field247(newValue)} + } + + var field248: Int32 { + get { + if case .field248(let v)? = value {return v} + return 0 + } + set {value = .field248(newValue)} + } + + var field249: Int32 { + get { + if case .field249(let v)? = value {return v} + return 0 + } + set {value = .field249(newValue)} + } + + var field250: Int32 { + get { + if case .field250(let v)? = value {return v} + return 0 + } + set {value = .field250(newValue)} + } + + var field252: Int32 { + get { + if case .field252(let v)? = value {return v} + return 0 + } + set {value = .field252(newValue)} + } + + var field253: Int32 { + get { + if case .field253(let v)? = value {return v} + return 0 + } + set {value = .field253(newValue)} + } + + var field254: Int32 { + get { + if case .field254(let v)? = value {return v} + return 0 + } + set {value = .field254(newValue)} + } + + var field255: Int32 { + get { + if case .field255(let v)? = value {return v} + return 0 + } + set {value = .field255(newValue)} + } + + var field256: Int32 { + get { + if case .field256(let v)? = value {return v} + return 0 + } + set {value = .field256(newValue)} + } + + var field257: Int32 { + get { + if case .field257(let v)? = value {return v} + return 0 + } + set {value = .field257(newValue)} + } + + var field258: Int32 { + get { + if case .field258(let v)? = value {return v} + return 0 + } + set {value = .field258(newValue)} + } + + var field259: Int32 { + get { + if case .field259(let v)? = value {return v} + return 0 + } + set {value = .field259(newValue)} + } + + var field260: Int32 { + get { + if case .field260(let v)? = value {return v} + return 0 + } + set {value = .field260(newValue)} + } + + var field261: Int32 { + get { + if case .field261(let v)? = value {return v} + return 0 + } + set {value = .field261(newValue)} + } + + var field262: Int32 { + get { + if case .field262(let v)? = value {return v} + return 0 + } + set {value = .field262(newValue)} + } + + var field263: Int32 { + get { + if case .field263(let v)? = value {return v} + return 0 + } + set {value = .field263(newValue)} + } + + var field264: Int32 { + get { + if case .field264(let v)? = value {return v} + return 0 + } + set {value = .field264(newValue)} + } + + var field265: Int32 { + get { + if case .field265(let v)? = value {return v} + return 0 + } + set {value = .field265(newValue)} + } + + var field266: Int32 { + get { + if case .field266(let v)? = value {return v} + return 0 + } + set {value = .field266(newValue)} + } + + var field267: Int32 { + get { + if case .field267(let v)? = value {return v} + return 0 + } + set {value = .field267(newValue)} + } + + var field268: Int32 { + get { + if case .field268(let v)? = value {return v} + return 0 + } + set {value = .field268(newValue)} + } + + var field269: Int32 { + get { + if case .field269(let v)? = value {return v} + return 0 + } + set {value = .field269(newValue)} + } + + var field270: Int32 { + get { + if case .field270(let v)? = value {return v} + return 0 + } + set {value = .field270(newValue)} + } + + var field271: Int32 { + get { + if case .field271(let v)? = value {return v} + return 0 + } + set {value = .field271(newValue)} + } + + var field272: Int32 { + get { + if case .field272(let v)? = value {return v} + return 0 + } + set {value = .field272(newValue)} + } + + var field273: Int32 { + get { + if case .field273(let v)? = value {return v} + return 0 + } + set {value = .field273(newValue)} + } + + var field274: Int32 { + get { + if case .field274(let v)? = value {return v} + return 0 + } + set {value = .field274(newValue)} + } + + var field275: Int32 { + get { + if case .field275(let v)? = value {return v} + return 0 + } + set {value = .field275(newValue)} + } + + var field276: Int32 { + get { + if case .field276(let v)? = value {return v} + return 0 + } + set {value = .field276(newValue)} + } + + var field277: Int32 { + get { + if case .field277(let v)? = value {return v} + return 0 + } + set {value = .field277(newValue)} + } + + var field278: Int32 { + get { + if case .field278(let v)? = value {return v} + return 0 + } + set {value = .field278(newValue)} + } + + var field279: Int32 { + get { + if case .field279(let v)? = value {return v} + return 0 + } + set {value = .field279(newValue)} + } + + var field280: Int32 { + get { + if case .field280(let v)? = value {return v} + return 0 + } + set {value = .field280(newValue)} + } + + var field281: Int32 { + get { + if case .field281(let v)? = value {return v} + return 0 + } + set {value = .field281(newValue)} + } + + var field282: Int32 { + get { + if case .field282(let v)? = value {return v} + return 0 + } + set {value = .field282(newValue)} + } + + var field283: Int32 { + get { + if case .field283(let v)? = value {return v} + return 0 + } + set {value = .field283(newValue)} + } + + var field284: Int32 { + get { + if case .field284(let v)? = value {return v} + return 0 + } + set {value = .field284(newValue)} + } + + var field285: Int32 { + get { + if case .field285(let v)? = value {return v} + return 0 + } + set {value = .field285(newValue)} + } + + var field286: Int32 { + get { + if case .field286(let v)? = value {return v} + return 0 + } + set {value = .field286(newValue)} + } + + var field287: Int32 { + get { + if case .field287(let v)? = value {return v} + return 0 + } + set {value = .field287(newValue)} + } + + var field288: Int32 { + get { + if case .field288(let v)? = value {return v} + return 0 + } + set {value = .field288(newValue)} + } + + var field289: Int32 { + get { + if case .field289(let v)? = value {return v} + return 0 + } + set {value = .field289(newValue)} + } + + var field290: Int32 { + get { + if case .field290(let v)? = value {return v} + return 0 + } + set {value = .field290(newValue)} + } + + var field291: Int32 { + get { + if case .field291(let v)? = value {return v} + return 0 + } + set {value = .field291(newValue)} + } + + var field292: Int32 { + get { + if case .field292(let v)? = value {return v} + return 0 + } + set {value = .field292(newValue)} + } + + var field293: Int32 { + get { + if case .field293(let v)? = value {return v} + return 0 + } + set {value = .field293(newValue)} + } + + var field294: Int32 { + get { + if case .field294(let v)? = value {return v} + return 0 + } + set {value = .field294(newValue)} + } + + var field295: Int32 { + get { + if case .field295(let v)? = value {return v} + return 0 + } + set {value = .field295(newValue)} + } + + var field296: Int32 { + get { + if case .field296(let v)? = value {return v} + return 0 + } + set {value = .field296(newValue)} + } + + var field297: Int32 { + get { + if case .field297(let v)? = value {return v} + return 0 + } + set {value = .field297(newValue)} + } + + var field298: Int32 { + get { + if case .field298(let v)? = value {return v} + return 0 + } + set {value = .field298(newValue)} + } + + var field299: Int32 { + get { + if case .field299(let v)? = value {return v} + return 0 + } + set {value = .field299(newValue)} + } + + var field300: Int32 { + get { + if case .field300(let v)? = value {return v} + return 0 + } + set {value = .field300(newValue)} + } + + var field301: Int32 { + get { + if case .field301(let v)? = value {return v} + return 0 + } + set {value = .field301(newValue)} + } + + var field302: Int32 { + get { + if case .field302(let v)? = value {return v} + return 0 + } + set {value = .field302(newValue)} + } + + var field303: Int32 { + get { + if case .field303(let v)? = value {return v} + return 0 + } + set {value = .field303(newValue)} + } + + var field304: Int32 { + get { + if case .field304(let v)? = value {return v} + return 0 + } + set {value = .field304(newValue)} + } + + var field305: Int32 { + get { + if case .field305(let v)? = value {return v} + return 0 + } + set {value = .field305(newValue)} + } + + var field306: Int32 { + get { + if case .field306(let v)? = value {return v} + return 0 + } + set {value = .field306(newValue)} + } + + var field307: Int32 { + get { + if case .field307(let v)? = value {return v} + return 0 + } + set {value = .field307(newValue)} + } + + var field308: Int32 { + get { + if case .field308(let v)? = value {return v} + return 0 + } + set {value = .field308(newValue)} + } + + var field309: Int32 { + get { + if case .field309(let v)? = value {return v} + return 0 + } + set {value = .field309(newValue)} + } + + var field310: Int32 { + get { + if case .field310(let v)? = value {return v} + return 0 + } + set {value = .field310(newValue)} + } + + var field311: Int32 { + get { + if case .field311(let v)? = value {return v} + return 0 + } + set {value = .field311(newValue)} + } + + var field312: Int32 { + get { + if case .field312(let v)? = value {return v} + return 0 + } + set {value = .field312(newValue)} + } + + var field313: Int32 { + get { + if case .field313(let v)? = value {return v} + return 0 + } + set {value = .field313(newValue)} + } + + var field314: Int32 { + get { + if case .field314(let v)? = value {return v} + return 0 + } + set {value = .field314(newValue)} + } + + var field315: Int32 { + get { + if case .field315(let v)? = value {return v} + return 0 + } + set {value = .field315(newValue)} + } + + var field316: Int32 { + get { + if case .field316(let v)? = value {return v} + return 0 + } + set {value = .field316(newValue)} + } + + var field317: Int32 { + get { + if case .field317(let v)? = value {return v} + return 0 + } + set {value = .field317(newValue)} + } + + var field318: Int32 { + get { + if case .field318(let v)? = value {return v} + return 0 + } + set {value = .field318(newValue)} + } + + var field319: Int32 { + get { + if case .field319(let v)? = value {return v} + return 0 + } + set {value = .field319(newValue)} + } + + var field320: Int32 { + get { + if case .field320(let v)? = value {return v} + return 0 + } + set {value = .field320(newValue)} + } + + var field321: Int32 { + get { + if case .field321(let v)? = value {return v} + return 0 + } + set {value = .field321(newValue)} + } + + var field322: Int32 { + get { + if case .field322(let v)? = value {return v} + return 0 + } + set {value = .field322(newValue)} + } + + var field323: Int32 { + get { + if case .field323(let v)? = value {return v} + return 0 + } + set {value = .field323(newValue)} + } + + var field324: Int32 { + get { + if case .field324(let v)? = value {return v} + return 0 + } + set {value = .field324(newValue)} + } + + var field325: Int32 { + get { + if case .field325(let v)? = value {return v} + return 0 + } + set {value = .field325(newValue)} + } + + var field326: Int32 { + get { + if case .field326(let v)? = value {return v} + return 0 + } + set {value = .field326(newValue)} + } + + var field327: Int32 { + get { + if case .field327(let v)? = value {return v} + return 0 + } + set {value = .field327(newValue)} + } + + var field328: Int32 { + get { + if case .field328(let v)? = value {return v} + return 0 + } + set {value = .field328(newValue)} + } + + var field329: Int32 { + get { + if case .field329(let v)? = value {return v} + return 0 + } + set {value = .field329(newValue)} + } + + var field330: Int32 { + get { + if case .field330(let v)? = value {return v} + return 0 + } + set {value = .field330(newValue)} + } + + var field331: Int32 { + get { + if case .field331(let v)? = value {return v} + return 0 + } + set {value = .field331(newValue)} + } + + var field332: Int32 { + get { + if case .field332(let v)? = value {return v} + return 0 + } + set {value = .field332(newValue)} + } + + var field333: Int32 { + get { + if case .field333(let v)? = value {return v} + return 0 + } + set {value = .field333(newValue)} + } + + var field334: Int32 { + get { + if case .field334(let v)? = value {return v} + return 0 + } + set {value = .field334(newValue)} + } + + var field335: Int32 { + get { + if case .field335(let v)? = value {return v} + return 0 + } + set {value = .field335(newValue)} + } + + var field336: Int32 { + get { + if case .field336(let v)? = value {return v} + return 0 + } + set {value = .field336(newValue)} + } + + var field337: Int32 { + get { + if case .field337(let v)? = value {return v} + return 0 + } + set {value = .field337(newValue)} + } + + var field338: Int32 { + get { + if case .field338(let v)? = value {return v} + return 0 + } + set {value = .field338(newValue)} + } + + var field339: Int32 { + get { + if case .field339(let v)? = value {return v} + return 0 + } + set {value = .field339(newValue)} + } + + var field340: Int32 { + get { + if case .field340(let v)? = value {return v} + return 0 + } + set {value = .field340(newValue)} + } + + var field341: Int32 { + get { + if case .field341(let v)? = value {return v} + return 0 + } + set {value = .field341(newValue)} + } + + var field342: Int32 { + get { + if case .field342(let v)? = value {return v} + return 0 + } + set {value = .field342(newValue)} + } + + var field343: Int32 { + get { + if case .field343(let v)? = value {return v} + return 0 + } + set {value = .field343(newValue)} + } + + var field344: Int32 { + get { + if case .field344(let v)? = value {return v} + return 0 + } + set {value = .field344(newValue)} + } + + var field345: Int32 { + get { + if case .field345(let v)? = value {return v} + return 0 + } + set {value = .field345(newValue)} + } + + var field346: Int32 { + get { + if case .field346(let v)? = value {return v} + return 0 + } + set {value = .field346(newValue)} + } + + var field347: Int32 { + get { + if case .field347(let v)? = value {return v} + return 0 + } + set {value = .field347(newValue)} + } + + var field348: Int32 { + get { + if case .field348(let v)? = value {return v} + return 0 + } + set {value = .field348(newValue)} + } + + var field349: Int32 { + get { + if case .field349(let v)? = value {return v} + return 0 + } + set {value = .field349(newValue)} + } + + var field350: Int32 { + get { + if case .field350(let v)? = value {return v} + return 0 + } + set {value = .field350(newValue)} + } + + var field351: Int32 { + get { + if case .field351(let v)? = value {return v} + return 0 + } + set {value = .field351(newValue)} + } + + var field352: Int32 { + get { + if case .field352(let v)? = value {return v} + return 0 + } + set {value = .field352(newValue)} + } + + var field353: Int32 { + get { + if case .field353(let v)? = value {return v} + return 0 + } + set {value = .field353(newValue)} + } + + var field354: Int32 { + get { + if case .field354(let v)? = value {return v} + return 0 + } + set {value = .field354(newValue)} + } + + var field355: Int32 { + get { + if case .field355(let v)? = value {return v} + return 0 + } + set {value = .field355(newValue)} + } + + var field356: Int32 { + get { + if case .field356(let v)? = value {return v} + return 0 + } + set {value = .field356(newValue)} + } + + var field357: Int32 { + get { + if case .field357(let v)? = value {return v} + return 0 + } + set {value = .field357(newValue)} + } + + var field358: Int32 { + get { + if case .field358(let v)? = value {return v} + return 0 + } + set {value = .field358(newValue)} + } + + var field359: Int32 { + get { + if case .field359(let v)? = value {return v} + return 0 + } + set {value = .field359(newValue)} + } + + var field360: Int32 { + get { + if case .field360(let v)? = value {return v} + return 0 + } + set {value = .field360(newValue)} + } + + var field361: Int32 { + get { + if case .field361(let v)? = value {return v} + return 0 + } + set {value = .field361(newValue)} + } + + var field362: Int32 { + get { + if case .field362(let v)? = value {return v} + return 0 + } + set {value = .field362(newValue)} + } + + var field363: Int32 { + get { + if case .field363(let v)? = value {return v} + return 0 + } + set {value = .field363(newValue)} + } + + var field364: Int32 { + get { + if case .field364(let v)? = value {return v} + return 0 + } + set {value = .field364(newValue)} + } + + var field365: Int32 { + get { + if case .field365(let v)? = value {return v} + return 0 + } + set {value = .field365(newValue)} + } + + var field366: Int32 { + get { + if case .field366(let v)? = value {return v} + return 0 + } + set {value = .field366(newValue)} + } + + var field367: Int32 { + get { + if case .field367(let v)? = value {return v} + return 0 + } + set {value = .field367(newValue)} + } + + var field368: Int32 { + get { + if case .field368(let v)? = value {return v} + return 0 + } + set {value = .field368(newValue)} + } + + var field369: Int32 { + get { + if case .field369(let v)? = value {return v} + return 0 + } + set {value = .field369(newValue)} + } + + var field370: Int32 { + get { + if case .field370(let v)? = value {return v} + return 0 + } + set {value = .field370(newValue)} + } + + var field371: Int32 { + get { + if case .field371(let v)? = value {return v} + return 0 + } + set {value = .field371(newValue)} + } + + var field372: Int32 { + get { + if case .field372(let v)? = value {return v} + return 0 + } + set {value = .field372(newValue)} + } + + var field373: Int32 { + get { + if case .field373(let v)? = value {return v} + return 0 + } + set {value = .field373(newValue)} + } + + var field374: Int32 { + get { + if case .field374(let v)? = value {return v} + return 0 + } + set {value = .field374(newValue)} + } + + var field375: Int32 { + get { + if case .field375(let v)? = value {return v} + return 0 + } + set {value = .field375(newValue)} + } + + var field376: Int32 { + get { + if case .field376(let v)? = value {return v} + return 0 + } + set {value = .field376(newValue)} + } + + var field377: Int32 { + get { + if case .field377(let v)? = value {return v} + return 0 + } + set {value = .field377(newValue)} + } + + var field378: Int32 { + get { + if case .field378(let v)? = value {return v} + return 0 + } + set {value = .field378(newValue)} + } + + var field379: Int32 { + get { + if case .field379(let v)? = value {return v} + return 0 + } + set {value = .field379(newValue)} + } + + var field380: Int32 { + get { + if case .field380(let v)? = value {return v} + return 0 + } + set {value = .field380(newValue)} + } + + var field381: Int32 { + get { + if case .field381(let v)? = value {return v} + return 0 + } + set {value = .field381(newValue)} + } + + var field382: Int32 { + get { + if case .field382(let v)? = value {return v} + return 0 + } + set {value = .field382(newValue)} + } + + var field383: Int32 { + get { + if case .field383(let v)? = value {return v} + return 0 + } + set {value = .field383(newValue)} + } + + var field384: Int32 { + get { + if case .field384(let v)? = value {return v} + return 0 + } + set {value = .field384(newValue)} + } + + var field385: Int32 { + get { + if case .field385(let v)? = value {return v} + return 0 + } + set {value = .field385(newValue)} + } + + var field386: Int32 { + get { + if case .field386(let v)? = value {return v} + return 0 + } + set {value = .field386(newValue)} + } + + var field387: Int32 { + get { + if case .field387(let v)? = value {return v} + return 0 + } + set {value = .field387(newValue)} + } + + var field388: Int32 { + get { + if case .field388(let v)? = value {return v} + return 0 + } + set {value = .field388(newValue)} + } + + var field389: Int32 { + get { + if case .field389(let v)? = value {return v} + return 0 + } + set {value = .field389(newValue)} + } + + var field390: Int32 { + get { + if case .field390(let v)? = value {return v} + return 0 + } + set {value = .field390(newValue)} + } + + var field391: Int32 { + get { + if case .field391(let v)? = value {return v} + return 0 + } + set {value = .field391(newValue)} + } + + var field392: Int32 { + get { + if case .field392(let v)? = value {return v} + return 0 + } + set {value = .field392(newValue)} + } + + var field393: Int32 { + get { + if case .field393(let v)? = value {return v} + return 0 + } + set {value = .field393(newValue)} + } + + var field394: Int32 { + get { + if case .field394(let v)? = value {return v} + return 0 + } + set {value = .field394(newValue)} + } + + var field395: Int32 { + get { + if case .field395(let v)? = value {return v} + return 0 + } + set {value = .field395(newValue)} + } + + var field396: Int32 { + get { + if case .field396(let v)? = value {return v} + return 0 + } + set {value = .field396(newValue)} + } + + var field397: Int32 { + get { + if case .field397(let v)? = value {return v} + return 0 + } + set {value = .field397(newValue)} + } + + var field398: Int32 { + get { + if case .field398(let v)? = value {return v} + return 0 + } + set {value = .field398(newValue)} + } + + var field399: Int32 { + get { + if case .field399(let v)? = value {return v} + return 0 + } + set {value = .field399(newValue)} + } + + var field400: Int32 { + get { + if case .field400(let v)? = value {return v} + return 0 + } + set {value = .field400(newValue)} + } + + var field401: Int32 { + get { + if case .field401(let v)? = value {return v} + return 0 + } + set {value = .field401(newValue)} + } + + var field402: Int32 { + get { + if case .field402(let v)? = value {return v} + return 0 + } + set {value = .field402(newValue)} + } + + var field403: Int32 { + get { + if case .field403(let v)? = value {return v} + return 0 + } + set {value = .field403(newValue)} + } + + var field404: Int32 { + get { + if case .field404(let v)? = value {return v} + return 0 + } + set {value = .field404(newValue)} + } + + var field405: Int32 { + get { + if case .field405(let v)? = value {return v} + return 0 + } + set {value = .field405(newValue)} + } + + var field406: Int32 { + get { + if case .field406(let v)? = value {return v} + return 0 + } + set {value = .field406(newValue)} + } + + var field407: Int32 { + get { + if case .field407(let v)? = value {return v} + return 0 + } + set {value = .field407(newValue)} + } + + var field408: Int32 { + get { + if case .field408(let v)? = value {return v} + return 0 + } + set {value = .field408(newValue)} + } + + var field409: Int32 { + get { + if case .field409(let v)? = value {return v} + return 0 + } + set {value = .field409(newValue)} + } + + var field410: Int32 { + get { + if case .field410(let v)? = value {return v} + return 0 + } + set {value = .field410(newValue)} + } + + var field411: Int32 { + get { + if case .field411(let v)? = value {return v} + return 0 + } + set {value = .field411(newValue)} + } + + var field412: Int32 { + get { + if case .field412(let v)? = value {return v} + return 0 + } + set {value = .field412(newValue)} + } + + var field413: Int32 { + get { + if case .field413(let v)? = value {return v} + return 0 + } + set {value = .field413(newValue)} + } + + var field414: Int32 { + get { + if case .field414(let v)? = value {return v} + return 0 + } + set {value = .field414(newValue)} + } + + var field415: Int32 { + get { + if case .field415(let v)? = value {return v} + return 0 + } + set {value = .field415(newValue)} + } + + var field416: Int32 { + get { + if case .field416(let v)? = value {return v} + return 0 + } + set {value = .field416(newValue)} + } + + var field417: Int32 { + get { + if case .field417(let v)? = value {return v} + return 0 + } + set {value = .field417(newValue)} + } + + var field418: Int32 { + get { + if case .field418(let v)? = value {return v} + return 0 + } + set {value = .field418(newValue)} + } + + var field419: Int32 { + get { + if case .field419(let v)? = value {return v} + return 0 + } + set {value = .field419(newValue)} + } + + var field420: Int32 { + get { + if case .field420(let v)? = value {return v} + return 0 + } + set {value = .field420(newValue)} + } + + var field421: Int32 { + get { + if case .field421(let v)? = value {return v} + return 0 + } + set {value = .field421(newValue)} + } + + var field422: Int32 { + get { + if case .field422(let v)? = value {return v} + return 0 + } + set {value = .field422(newValue)} + } + + var field423: Int32 { + get { + if case .field423(let v)? = value {return v} + return 0 + } + set {value = .field423(newValue)} + } + + var field424: Int32 { + get { + if case .field424(let v)? = value {return v} + return 0 + } + set {value = .field424(newValue)} + } + + var field425: Int32 { + get { + if case .field425(let v)? = value {return v} + return 0 + } + set {value = .field425(newValue)} + } + + var field426: Int32 { + get { + if case .field426(let v)? = value {return v} + return 0 + } + set {value = .field426(newValue)} + } + + var field427: Int32 { + get { + if case .field427(let v)? = value {return v} + return 0 + } + set {value = .field427(newValue)} + } + + var field428: Int32 { + get { + if case .field428(let v)? = value {return v} + return 0 + } + set {value = .field428(newValue)} + } + + var field429: Int32 { + get { + if case .field429(let v)? = value {return v} + return 0 + } + set {value = .field429(newValue)} + } + + var field430: Int32 { + get { + if case .field430(let v)? = value {return v} + return 0 + } + set {value = .field430(newValue)} + } + + var field431: Int32 { + get { + if case .field431(let v)? = value {return v} + return 0 + } + set {value = .field431(newValue)} + } + + var field432: Int32 { + get { + if case .field432(let v)? = value {return v} + return 0 + } + set {value = .field432(newValue)} + } + + var field433: Int32 { + get { + if case .field433(let v)? = value {return v} + return 0 + } + set {value = .field433(newValue)} + } + + var field434: Int32 { + get { + if case .field434(let v)? = value {return v} + return 0 + } + set {value = .field434(newValue)} + } + + var field435: Int32 { + get { + if case .field435(let v)? = value {return v} + return 0 + } + set {value = .field435(newValue)} + } + + var field436: Int32 { + get { + if case .field436(let v)? = value {return v} + return 0 + } + set {value = .field436(newValue)} + } + + var field437: Int32 { + get { + if case .field437(let v)? = value {return v} + return 0 + } + set {value = .field437(newValue)} + } + + var field438: Int32 { + get { + if case .field438(let v)? = value {return v} + return 0 + } + set {value = .field438(newValue)} + } + + var field439: Int32 { + get { + if case .field439(let v)? = value {return v} + return 0 + } + set {value = .field439(newValue)} + } + + var field440: Int32 { + get { + if case .field440(let v)? = value {return v} + return 0 + } + set {value = .field440(newValue)} + } + + var field441: Int32 { + get { + if case .field441(let v)? = value {return v} + return 0 + } + set {value = .field441(newValue)} + } + + var field442: Int32 { + get { + if case .field442(let v)? = value {return v} + return 0 + } + set {value = .field442(newValue)} + } + + var field443: Int32 { + get { + if case .field443(let v)? = value {return v} + return 0 + } + set {value = .field443(newValue)} + } + + var field444: Int32 { + get { + if case .field444(let v)? = value {return v} + return 0 + } + set {value = .field444(newValue)} + } + + var field445: Int32 { + get { + if case .field445(let v)? = value {return v} + return 0 + } + set {value = .field445(newValue)} + } + + var field446: Int32 { + get { + if case .field446(let v)? = value {return v} + return 0 + } + set {value = .field446(newValue)} + } + + var field447: Int32 { + get { + if case .field447(let v)? = value {return v} + return 0 + } + set {value = .field447(newValue)} + } + + var field448: Int32 { + get { + if case .field448(let v)? = value {return v} + return 0 + } + set {value = .field448(newValue)} + } + + var field449: Int32 { + get { + if case .field449(let v)? = value {return v} + return 0 + } + set {value = .field449(newValue)} + } + + var field450: Int32 { + get { + if case .field450(let v)? = value {return v} + return 0 + } + set {value = .field450(newValue)} + } + + var field451: Int32 { + get { + if case .field451(let v)? = value {return v} + return 0 + } + set {value = .field451(newValue)} + } + + var field452: Int32 { + get { + if case .field452(let v)? = value {return v} + return 0 + } + set {value = .field452(newValue)} + } + + var field453: Int32 { + get { + if case .field453(let v)? = value {return v} + return 0 + } + set {value = .field453(newValue)} + } + + var field454: Int32 { + get { + if case .field454(let v)? = value {return v} + return 0 + } + set {value = .field454(newValue)} + } + + var field455: Int32 { + get { + if case .field455(let v)? = value {return v} + return 0 + } + set {value = .field455(newValue)} + } + + var field456: Int32 { + get { + if case .field456(let v)? = value {return v} + return 0 + } + set {value = .field456(newValue)} + } + + var field457: Int32 { + get { + if case .field457(let v)? = value {return v} + return 0 + } + set {value = .field457(newValue)} + } + + var field458: Int32 { + get { + if case .field458(let v)? = value {return v} + return 0 + } + set {value = .field458(newValue)} + } + + var field459: Int32 { + get { + if case .field459(let v)? = value {return v} + return 0 + } + set {value = .field459(newValue)} + } + + var field460: Int32 { + get { + if case .field460(let v)? = value {return v} + return 0 + } + set {value = .field460(newValue)} + } + + var field461: Int32 { + get { + if case .field461(let v)? = value {return v} + return 0 + } + set {value = .field461(newValue)} + } + + var field462: Int32 { + get { + if case .field462(let v)? = value {return v} + return 0 + } + set {value = .field462(newValue)} + } + + var field463: Int32 { + get { + if case .field463(let v)? = value {return v} + return 0 + } + set {value = .field463(newValue)} + } + + var field464: Int32 { + get { + if case .field464(let v)? = value {return v} + return 0 + } + set {value = .field464(newValue)} + } + + var field465: Int32 { + get { + if case .field465(let v)? = value {return v} + return 0 + } + set {value = .field465(newValue)} + } + + var field466: Int32 { + get { + if case .field466(let v)? = value {return v} + return 0 + } + set {value = .field466(newValue)} + } + + var field467: Int32 { + get { + if case .field467(let v)? = value {return v} + return 0 + } + set {value = .field467(newValue)} + } + + var field468: Int32 { + get { + if case .field468(let v)? = value {return v} + return 0 + } + set {value = .field468(newValue)} + } + + var field469: Int32 { + get { + if case .field469(let v)? = value {return v} + return 0 + } + set {value = .field469(newValue)} + } + + var field470: Int32 { + get { + if case .field470(let v)? = value {return v} + return 0 + } + set {value = .field470(newValue)} + } + + var field471: Int32 { + get { + if case .field471(let v)? = value {return v} + return 0 + } + set {value = .field471(newValue)} + } + + var field472: Int32 { + get { + if case .field472(let v)? = value {return v} + return 0 + } + set {value = .field472(newValue)} + } + + var field473: Int32 { + get { + if case .field473(let v)? = value {return v} + return 0 + } + set {value = .field473(newValue)} + } + + var field474: Int32 { + get { + if case .field474(let v)? = value {return v} + return 0 + } + set {value = .field474(newValue)} + } + + var field475: Int32 { + get { + if case .field475(let v)? = value {return v} + return 0 + } + set {value = .field475(newValue)} + } + + var field476: Int32 { + get { + if case .field476(let v)? = value {return v} + return 0 + } + set {value = .field476(newValue)} + } + + var field477: Int32 { + get { + if case .field477(let v)? = value {return v} + return 0 + } + set {value = .field477(newValue)} + } + + var field478: Int32 { + get { + if case .field478(let v)? = value {return v} + return 0 + } + set {value = .field478(newValue)} + } + + var field479: Int32 { + get { + if case .field479(let v)? = value {return v} + return 0 + } + set {value = .field479(newValue)} + } + + var field480: Int32 { + get { + if case .field480(let v)? = value {return v} + return 0 + } + set {value = .field480(newValue)} + } + + var field481: Int32 { + get { + if case .field481(let v)? = value {return v} + return 0 + } + set {value = .field481(newValue)} + } + + var field482: Int32 { + get { + if case .field482(let v)? = value {return v} + return 0 + } + set {value = .field482(newValue)} + } + + var field483: Int32 { + get { + if case .field483(let v)? = value {return v} + return 0 + } + set {value = .field483(newValue)} + } + + var field484: Int32 { + get { + if case .field484(let v)? = value {return v} + return 0 + } + set {value = .field484(newValue)} + } + + var field485: Int32 { + get { + if case .field485(let v)? = value {return v} + return 0 + } + set {value = .field485(newValue)} + } + + var field486: Int32 { + get { + if case .field486(let v)? = value {return v} + return 0 + } + set {value = .field486(newValue)} + } + + var field487: Int32 { + get { + if case .field487(let v)? = value {return v} + return 0 + } + set {value = .field487(newValue)} + } + + var field488: Int32 { + get { + if case .field488(let v)? = value {return v} + return 0 + } + set {value = .field488(newValue)} + } + + var field489: Int32 { + get { + if case .field489(let v)? = value {return v} + return 0 + } + set {value = .field489(newValue)} + } + + var field490: Int32 { + get { + if case .field490(let v)? = value {return v} + return 0 + } + set {value = .field490(newValue)} + } + + var field491: Int32 { + get { + if case .field491(let v)? = value {return v} + return 0 + } + set {value = .field491(newValue)} + } + + var field492: Int32 { + get { + if case .field492(let v)? = value {return v} + return 0 + } + set {value = .field492(newValue)} + } + + var field493: Int32 { + get { + if case .field493(let v)? = value {return v} + return 0 + } + set {value = .field493(newValue)} + } + + var field494: Int32 { + get { + if case .field494(let v)? = value {return v} + return 0 + } + set {value = .field494(newValue)} + } + + var field495: Int32 { + get { + if case .field495(let v)? = value {return v} + return 0 + } + set {value = .field495(newValue)} + } + + var field496: Int32 { + get { + if case .field496(let v)? = value {return v} + return 0 + } + set {value = .field496(newValue)} + } + + var field497: Int32 { + get { + if case .field497(let v)? = value {return v} + return 0 + } + set {value = .field497(newValue)} + } + + var field498: Int32 { + get { + if case .field498(let v)? = value {return v} + return 0 + } + set {value = .field498(newValue)} + } + + var field499: Int32 { + get { + if case .field499(let v)? = value {return v} + return 0 + } + set {value = .field499(newValue)} + } + + var field500: Int32 { + get { + if case .field500(let v)? = value {return v} + return 0 + } + set {value = .field500(newValue)} + } + + var field501: Int32 { + get { + if case .field501(let v)? = value {return v} + return 0 + } + set {value = .field501(newValue)} + } + + var field503: Int32 { + get { + if case .field503(let v)? = value {return v} + return 0 + } + set {value = .field503(newValue)} + } + + var field504: Int32 { + get { + if case .field504(let v)? = value {return v} + return 0 + } + set {value = .field504(newValue)} + } + + var field505: Int32 { + get { + if case .field505(let v)? = value {return v} + return 0 + } + set {value = .field505(newValue)} + } + + var field506: Int32 { + get { + if case .field506(let v)? = value {return v} + return 0 + } + set {value = .field506(newValue)} + } + + var field507: Int32 { + get { + if case .field507(let v)? = value {return v} + return 0 + } + set {value = .field507(newValue)} + } + + var field508: Int32 { + get { + if case .field508(let v)? = value {return v} + return 0 + } + set {value = .field508(newValue)} + } + + var field510: Int32 { + get { + if case .field510(let v)? = value {return v} + return 0 + } + set {value = .field510(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_Value: Equatable, Sendable { + case field001(Int32) + case field003(Int32) + case field004(Int32) + case field005(Int32) + case field006(Int32) + case field007(Int32) + case field008(Int32) + case field009(Int32) + case field010(Int32) + case field011(Int32) + case field012(Int32) + case field013(Int32) + case field014(Int32) + case field015(Int32) + case field016(Int32) + case field017(Int32) + case field018(Int32) + case field019(Int32) + case field020(Int32) + case field021(Int32) + case field022(Int32) + case field023(Int32) + case field024(Int32) + case field025(Int32) + case field026(Int32) + case field027(Int32) + case field028(Int32) + case field029(Int32) + case field030(Int32) + case field031(Int32) + case field032(Int32) + case field033(Int32) + case field034(Int32) + case field035(Int32) + case field036(Int32) + case field037(Int32) + case field038(Int32) + case field039(Int32) + case field040(Int32) + case field041(Int32) + case field042(Int32) + case field043(Int32) + case field044(Int32) + case field045(Int32) + case field046(Int32) + case field047(Int32) + case field048(Int32) + case field049(Int32) + case field050(Int32) + case field051(Int32) + case field052(Int32) + case field053(Int32) + case field054(Int32) + case field055(Int32) + case field056(Int32) + case field057(Int32) + case field058(Int32) + case field059(Int32) + case field060(Int32) + case field061(Int32) + case field062(Int32) + case field063(Int32) + case field064(Int32) + case field065(Int32) + case field066(Int32) + case field067(Int32) + case field068(Int32) + case field069(Int32) + case field070(Int32) + case field071(Int32) + case field072(Int32) + case field073(Int32) + case field074(Int32) + case field075(Int32) + case field076(Int32) + case field077(Int32) + case field078(Int32) + case field079(Int32) + case field080(Int32) + case field081(Int32) + case field082(Int32) + case field083(Int32) + case field084(Int32) + case field085(Int32) + case field086(Int32) + case field087(Int32) + case field088(Int32) + case field089(Int32) + case field090(Int32) + case field091(Int32) + case field092(Int32) + case field093(Int32) + case field094(Int32) + case field095(Int32) + case field096(Int32) + case field097(Int32) + case field098(Int32) + case field099(Int32) + case field100(Int32) + case field101(Int32) + case field102(Int32) + case field103(Int32) + case field104(Int32) + case field105(Int32) + case field106(Int32) + case field107(Int32) + case field108(Int32) + case field109(Int32) + case field110(Int32) + case field111(Int32) + case field112(Int32) + case field113(Int32) + case field114(Int32) + case field115(Int32) + case field116(Int32) + case field117(Int32) + case field118(Int32) + case field119(Int32) + case field120(Int32) + case field121(Int32) + case field122(Int32) + case field123(Int32) + case field124(Int32) + case field125(Int32) + case field126(Int32) + case field127(Int32) + case field128(Int32) + case field129(Int32) + case field130(Int32) + case field131(Int32) + case field132(Int32) + case field133(Int32) + case field134(Int32) + case field135(Int32) + case field136(Int32) + case field137(Int32) + case field138(Int32) + case field139(Int32) + case field140(Int32) + case field141(Int32) + case field142(Int32) + case field143(Int32) + case field144(Int32) + case field145(Int32) + case field146(Int32) + case field147(Int32) + case field148(Int32) + case field149(Int32) + case field150(Int32) + case field151(Int32) + case field152(Int32) + case field153(Int32) + case field154(Int32) + case field155(Int32) + case field156(Int32) + case field157(Int32) + case field158(Int32) + case field159(Int32) + case field160(Int32) + case field161(Int32) + case field162(Int32) + case field163(Int32) + case field164(Int32) + case field165(Int32) + case field166(Int32) + case field167(Int32) + case field168(Int32) + case field169(Int32) + case field170(Int32) + case field171(Int32) + case field172(Int32) + case field173(Int32) + case field174(Int32) + case field175(Int32) + case field176(Int32) + case field177(Int32) + case field178(Int32) + case field179(Int32) + case field180(Int32) + case field181(Int32) + case field182(Int32) + case field183(Int32) + case field184(Int32) + case field185(Int32) + case field186(Int32) + case field187(Int32) + case field188(Int32) + case field189(Int32) + case field190(Int32) + case field191(Int32) + case field192(Int32) + case field193(Int32) + case field194(Int32) + case field195(Int32) + case field196(Int32) + case field197(Int32) + case field198(Int32) + case field199(Int32) + case field200(Int32) + case field201(Int32) + case field202(Int32) + case field203(Int32) + case field204(Int32) + case field205(Int32) + case field206(Int32) + case field207(Int32) + case field208(Int32) + case field209(Int32) + case field210(Int32) + case field211(Int32) + case field212(Int32) + case field213(Int32) + case field214(Int32) + case field215(Int32) + case field216(Int32) + case field217(Int32) + case field218(Int32) + case field219(Int32) + case field220(Int32) + case field221(Int32) + case field222(Int32) + case field223(Int32) + case field224(Int32) + case field225(Int32) + case field226(Int32) + case field227(Int32) + case field228(Int32) + case field229(Int32) + case field230(Int32) + case field231(Int32) + case field232(Int32) + case field233(Int32) + case field234(Int32) + case field235(Int32) + case field236(Int32) + case field237(Int32) + case field238(Int32) + case field239(Int32) + case field240(Int32) + case field241(Int32) + case field242(Int32) + case field243(Int32) + case field244(Int32) + case field245(Int32) + case field246(Int32) + case field247(Int32) + case field248(Int32) + case field249(Int32) + case field250(Int32) + case field252(Int32) + case field253(Int32) + case field254(Int32) + case field255(Int32) + case field256(Int32) + case field257(Int32) + case field258(Int32) + case field259(Int32) + case field260(Int32) + case field261(Int32) + case field262(Int32) + case field263(Int32) + case field264(Int32) + case field265(Int32) + case field266(Int32) + case field267(Int32) + case field268(Int32) + case field269(Int32) + case field270(Int32) + case field271(Int32) + case field272(Int32) + case field273(Int32) + case field274(Int32) + case field275(Int32) + case field276(Int32) + case field277(Int32) + case field278(Int32) + case field279(Int32) + case field280(Int32) + case field281(Int32) + case field282(Int32) + case field283(Int32) + case field284(Int32) + case field285(Int32) + case field286(Int32) + case field287(Int32) + case field288(Int32) + case field289(Int32) + case field290(Int32) + case field291(Int32) + case field292(Int32) + case field293(Int32) + case field294(Int32) + case field295(Int32) + case field296(Int32) + case field297(Int32) + case field298(Int32) + case field299(Int32) + case field300(Int32) + case field301(Int32) + case field302(Int32) + case field303(Int32) + case field304(Int32) + case field305(Int32) + case field306(Int32) + case field307(Int32) + case field308(Int32) + case field309(Int32) + case field310(Int32) + case field311(Int32) + case field312(Int32) + case field313(Int32) + case field314(Int32) + case field315(Int32) + case field316(Int32) + case field317(Int32) + case field318(Int32) + case field319(Int32) + case field320(Int32) + case field321(Int32) + case field322(Int32) + case field323(Int32) + case field324(Int32) + case field325(Int32) + case field326(Int32) + case field327(Int32) + case field328(Int32) + case field329(Int32) + case field330(Int32) + case field331(Int32) + case field332(Int32) + case field333(Int32) + case field334(Int32) + case field335(Int32) + case field336(Int32) + case field337(Int32) + case field338(Int32) + case field339(Int32) + case field340(Int32) + case field341(Int32) + case field342(Int32) + case field343(Int32) + case field344(Int32) + case field345(Int32) + case field346(Int32) + case field347(Int32) + case field348(Int32) + case field349(Int32) + case field350(Int32) + case field351(Int32) + case field352(Int32) + case field353(Int32) + case field354(Int32) + case field355(Int32) + case field356(Int32) + case field357(Int32) + case field358(Int32) + case field359(Int32) + case field360(Int32) + case field361(Int32) + case field362(Int32) + case field363(Int32) + case field364(Int32) + case field365(Int32) + case field366(Int32) + case field367(Int32) + case field368(Int32) + case field369(Int32) + case field370(Int32) + case field371(Int32) + case field372(Int32) + case field373(Int32) + case field374(Int32) + case field375(Int32) + case field376(Int32) + case field377(Int32) + case field378(Int32) + case field379(Int32) + case field380(Int32) + case field381(Int32) + case field382(Int32) + case field383(Int32) + case field384(Int32) + case field385(Int32) + case field386(Int32) + case field387(Int32) + case field388(Int32) + case field389(Int32) + case field390(Int32) + case field391(Int32) + case field392(Int32) + case field393(Int32) + case field394(Int32) + case field395(Int32) + case field396(Int32) + case field397(Int32) + case field398(Int32) + case field399(Int32) + case field400(Int32) + case field401(Int32) + case field402(Int32) + case field403(Int32) + case field404(Int32) + case field405(Int32) + case field406(Int32) + case field407(Int32) + case field408(Int32) + case field409(Int32) + case field410(Int32) + case field411(Int32) + case field412(Int32) + case field413(Int32) + case field414(Int32) + case field415(Int32) + case field416(Int32) + case field417(Int32) + case field418(Int32) + case field419(Int32) + case field420(Int32) + case field421(Int32) + case field422(Int32) + case field423(Int32) + case field424(Int32) + case field425(Int32) + case field426(Int32) + case field427(Int32) + case field428(Int32) + case field429(Int32) + case field430(Int32) + case field431(Int32) + case field432(Int32) + case field433(Int32) + case field434(Int32) + case field435(Int32) + case field436(Int32) + case field437(Int32) + case field438(Int32) + case field439(Int32) + case field440(Int32) + case field441(Int32) + case field442(Int32) + case field443(Int32) + case field444(Int32) + case field445(Int32) + case field446(Int32) + case field447(Int32) + case field448(Int32) + case field449(Int32) + case field450(Int32) + case field451(Int32) + case field452(Int32) + case field453(Int32) + case field454(Int32) + case field455(Int32) + case field456(Int32) + case field457(Int32) + case field458(Int32) + case field459(Int32) + case field460(Int32) + case field461(Int32) + case field462(Int32) + case field463(Int32) + case field464(Int32) + case field465(Int32) + case field466(Int32) + case field467(Int32) + case field468(Int32) + case field469(Int32) + case field470(Int32) + case field471(Int32) + case field472(Int32) + case field473(Int32) + case field474(Int32) + case field475(Int32) + case field476(Int32) + case field477(Int32) + case field478(Int32) + case field479(Int32) + case field480(Int32) + case field481(Int32) + case field482(Int32) + case field483(Int32) + case field484(Int32) + case field485(Int32) + case field486(Int32) + case field487(Int32) + case field488(Int32) + case field489(Int32) + case field490(Int32) + case field491(Int32) + case field492(Int32) + case field493(Int32) + case field494(Int32) + case field495(Int32) + case field496(Int32) + case field497(Int32) + case field498(Int32) + case field499(Int32) + case field500(Int32) + case field501(Int32) + case field503(Int32) + case field504(Int32) + case field505(Int32) + case field506(Int32) + case field507(Int32) + case field508(Int32) + case field510(Int32) + + } + + init() {} + + fileprivate var _regularField002: Int32? = nil + fileprivate var _regularField251: Int32? = nil + fileprivate var _regularField502: Int32? = nil + fileprivate var _regularField509: Int32? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_proto_testing.switch_split" + +extension SwiftProtoTesting_SwitchSplit_SwitchSplitMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".SwitchSplitMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}field_001\0\u{3}regular_field_002\0\u{3}field_003\0\u{3}field_004\0\u{3}field_005\0\u{3}field_006\0\u{3}field_007\0\u{3}field_008\0\u{3}field_009\0\u{3}field_050\0\u{3}field_011\0\u{3}field_012\0\u{3}field_013\0\u{3}field_014\0\u{3}field_015\0\u{3}field_016\0\u{3}field_017\0\u{3}field_018\0\u{3}field_019\0\u{3}field_020\0\u{3}field_021\0\u{3}field_022\0\u{3}field_023\0\u{3}field_024\0\u{3}field_025\0\u{3}field_026\0\u{3}field_027\0\u{3}field_028\0\u{3}field_029\0\u{3}field_030\0\u{3}field_031\0\u{3}field_032\0\u{3}field_033\0\u{3}field_034\0\u{3}field_035\0\u{3}field_036\0\u{3}field_037\0\u{3}field_038\0\u{3}field_039\0\u{3}field_040\0\u{3}field_041\0\u{3}field_042\0\u{3}field_043\0\u{3}field_044\0\u{3}field_045\0\u{3}field_046\0\u{3}field_047\0\u{3}field_048\0\u{3}field_049\0\u{3}field_010\0\u{3}field_051\0\u{3}field_052\0\u{3}field_053\0\u{3}field_054\0\u{3}field_055\0\u{3}field_056\0\u{3}field_057\0\u{3}field_058\0\u{3}field_059\0\u{3}field_060\0\u{3}field_061\0\u{3}field_062\0\u{3}field_063\0\u{3}field_064\0\u{3}field_065\0\u{3}field_066\0\u{3}field_067\0\u{3}field_068\0\u{3}field_069\0\u{3}field_070\0\u{3}field_071\0\u{3}field_072\0\u{3}field_073\0\u{3}field_074\0\u{3}field_075\0\u{3}field_076\0\u{3}field_077\0\u{3}field_078\0\u{3}field_079\0\u{3}field_080\0\u{3}field_081\0\u{3}field_082\0\u{3}field_083\0\u{3}field_084\0\u{3}field_085\0\u{3}field_086\0\u{3}field_087\0\u{3}field_088\0\u{3}field_089\0\u{3}field_090\0\u{3}field_091\0\u{3}field_092\0\u{3}field_093\0\u{3}field_094\0\u{3}field_095\0\u{3}field_096\0\u{3}field_097\0\u{3}field_098\0\u{3}field_099\0\u{3}field_200\0\u{3}field_101\0\u{3}field_102\0\u{3}field_103\0\u{3}field_104\0\u{3}field_105\0\u{3}field_106\0\u{3}field_107\0\u{3}field_108\0\u{3}field_109\0\u{3}field_110\0\u{3}field_111\0\u{3}field_112\0\u{3}field_113\0\u{3}field_114\0\u{3}field_115\0\u{3}field_116\0\u{3}field_117\0\u{3}field_118\0\u{3}field_119\0\u{3}field_120\0\u{3}field_121\0\u{3}field_122\0\u{3}field_123\0\u{3}field_124\0\u{3}field_125\0\u{3}field_126\0\u{3}field_127\0\u{3}field_128\0\u{3}field_129\0\u{3}field_130\0\u{3}field_131\0\u{3}field_132\0\u{3}field_133\0\u{3}field_134\0\u{3}field_135\0\u{3}field_136\0\u{3}field_137\0\u{3}field_138\0\u{3}field_139\0\u{3}field_140\0\u{3}field_141\0\u{3}field_142\0\u{3}field_143\0\u{3}field_144\0\u{3}field_145\0\u{3}field_146\0\u{3}field_147\0\u{3}field_148\0\u{3}field_149\0\u{3}field_150\0\u{3}field_151\0\u{3}field_152\0\u{3}field_153\0\u{3}field_154\0\u{3}field_155\0\u{3}field_156\0\u{3}field_157\0\u{3}field_158\0\u{3}field_159\0\u{3}field_160\0\u{3}field_161\0\u{3}field_162\0\u{3}field_163\0\u{3}field_164\0\u{3}field_165\0\u{3}field_166\0\u{3}field_167\0\u{3}field_168\0\u{3}field_169\0\u{3}field_170\0\u{3}field_171\0\u{3}field_172\0\u{3}field_173\0\u{3}field_174\0\u{3}field_175\0\u{3}field_176\0\u{3}field_177\0\u{3}field_178\0\u{3}field_179\0\u{3}field_180\0\u{3}field_181\0\u{3}field_182\0\u{3}field_183\0\u{3}field_184\0\u{3}field_185\0\u{3}field_186\0\u{3}field_187\0\u{3}field_188\0\u{3}field_189\0\u{3}field_190\0\u{3}field_191\0\u{3}field_192\0\u{3}field_193\0\u{3}field_194\0\u{3}field_195\0\u{3}field_196\0\u{3}field_197\0\u{3}field_198\0\u{3}field_199\0\u{3}field_100\0\u{3}field_201\0\u{3}field_202\0\u{3}field_203\0\u{3}field_204\0\u{3}field_205\0\u{3}field_206\0\u{3}field_207\0\u{3}field_208\0\u{3}field_209\0\u{3}field_210\0\u{3}field_211\0\u{3}field_212\0\u{3}field_213\0\u{3}field_214\0\u{3}field_215\0\u{3}field_216\0\u{3}field_217\0\u{3}field_218\0\u{3}field_219\0\u{3}field_220\0\u{3}field_221\0\u{3}field_222\0\u{3}field_223\0\u{3}field_224\0\u{3}field_225\0\u{3}field_226\0\u{3}field_227\0\u{3}field_228\0\u{3}field_229\0\u{3}field_230\0\u{3}field_231\0\u{3}field_232\0\u{3}field_233\0\u{3}field_234\0\u{3}field_235\0\u{3}field_236\0\u{3}field_237\0\u{3}field_238\0\u{3}field_239\0\u{3}field_240\0\u{3}field_241\0\u{3}field_242\0\u{3}field_243\0\u{3}field_244\0\u{3}field_245\0\u{3}field_246\0\u{3}field_247\0\u{3}field_248\0\u{3}field_249\0\u{3}field_250\0\u{3}regular_field_251\0\u{3}field_252\0\u{3}field_253\0\u{3}field_254\0\u{3}field_255\0\u{3}field_256\0\u{3}field_257\0\u{3}field_258\0\u{3}field_259\0\u{3}field_260\0\u{3}field_261\0\u{3}field_262\0\u{3}field_263\0\u{3}field_264\0\u{3}field_265\0\u{3}field_266\0\u{3}field_267\0\u{3}field_268\0\u{3}field_269\0\u{3}field_270\0\u{3}field_271\0\u{3}field_272\0\u{3}field_273\0\u{3}field_274\0\u{3}field_275\0\u{3}field_276\0\u{3}field_277\0\u{3}field_278\0\u{3}field_279\0\u{3}field_280\0\u{3}field_281\0\u{3}field_282\0\u{3}field_283\0\u{3}field_284\0\u{3}field_285\0\u{3}field_286\0\u{3}field_287\0\u{3}field_288\0\u{3}field_289\0\u{3}field_290\0\u{3}field_291\0\u{3}field_292\0\u{3}field_293\0\u{3}field_294\0\u{3}field_295\0\u{3}field_296\0\u{3}field_297\0\u{3}field_298\0\u{3}field_299\0\u{3}field_400\0\u{3}field_301\0\u{3}field_302\0\u{3}field_303\0\u{3}field_304\0\u{3}field_305\0\u{3}field_306\0\u{3}field_307\0\u{3}field_308\0\u{3}field_309\0\u{3}field_310\0\u{3}field_311\0\u{3}field_312\0\u{3}field_313\0\u{3}field_314\0\u{3}field_315\0\u{3}field_316\0\u{3}field_317\0\u{3}field_318\0\u{3}field_319\0\u{3}field_320\0\u{3}field_321\0\u{3}field_322\0\u{3}field_323\0\u{3}field_324\0\u{3}field_325\0\u{3}field_326\0\u{3}field_327\0\u{3}field_328\0\u{3}field_329\0\u{3}field_330\0\u{3}field_331\0\u{3}field_332\0\u{3}field_333\0\u{3}field_334\0\u{3}field_335\0\u{3}field_336\0\u{3}field_337\0\u{3}field_338\0\u{3}field_339\0\u{3}field_340\0\u{3}field_341\0\u{3}field_342\0\u{3}field_343\0\u{3}field_344\0\u{3}field_345\0\u{3}field_346\0\u{3}field_347\0\u{3}field_348\0\u{3}field_349\0\u{3}field_350\0\u{3}field_351\0\u{3}field_352\0\u{3}field_353\0\u{3}field_354\0\u{3}field_355\0\u{3}field_356\0\u{3}field_357\0\u{3}field_358\0\u{3}field_359\0\u{3}field_360\0\u{3}field_361\0\u{3}field_362\0\u{3}field_363\0\u{3}field_364\0\u{3}field_365\0\u{3}field_366\0\u{3}field_367\0\u{3}field_368\0\u{3}field_369\0\u{3}field_370\0\u{3}field_371\0\u{3}field_372\0\u{3}field_373\0\u{3}field_374\0\u{3}field_375\0\u{3}field_376\0\u{3}field_377\0\u{3}field_378\0\u{3}field_379\0\u{3}field_380\0\u{3}field_381\0\u{3}field_382\0\u{3}field_383\0\u{3}field_384\0\u{3}field_385\0\u{3}field_386\0\u{3}field_387\0\u{3}field_388\0\u{3}field_389\0\u{3}field_390\0\u{3}field_391\0\u{3}field_392\0\u{3}field_393\0\u{3}field_394\0\u{3}field_395\0\u{3}field_396\0\u{3}field_397\0\u{3}field_398\0\u{3}field_399\0\u{3}field_300\0\u{3}field_401\0\u{3}field_402\0\u{3}field_403\0\u{3}field_404\0\u{3}field_405\0\u{3}field_406\0\u{3}field_407\0\u{3}field_408\0\u{3}field_409\0\u{3}field_410\0\u{3}field_411\0\u{3}field_412\0\u{3}field_413\0\u{3}field_414\0\u{3}field_415\0\u{3}field_416\0\u{3}field_417\0\u{3}field_418\0\u{3}field_419\0\u{3}field_420\0\u{3}field_421\0\u{3}field_422\0\u{3}field_423\0\u{3}field_424\0\u{3}field_425\0\u{3}field_426\0\u{3}field_427\0\u{3}field_428\0\u{3}field_429\0\u{3}field_430\0\u{3}field_431\0\u{3}field_432\0\u{3}field_433\0\u{3}field_434\0\u{3}field_435\0\u{3}field_436\0\u{3}field_437\0\u{3}field_438\0\u{3}field_439\0\u{3}field_440\0\u{3}field_441\0\u{3}field_442\0\u{3}field_443\0\u{3}field_444\0\u{3}field_445\0\u{3}field_446\0\u{3}field_447\0\u{3}field_448\0\u{3}field_449\0\u{3}field_450\0\u{3}field_451\0\u{3}field_452\0\u{3}field_453\0\u{3}field_454\0\u{3}field_455\0\u{3}field_456\0\u{3}field_457\0\u{3}field_458\0\u{3}field_459\0\u{3}field_460\0\u{3}field_461\0\u{3}field_462\0\u{3}field_463\0\u{3}field_464\0\u{3}field_465\0\u{3}field_466\0\u{3}field_467\0\u{3}field_468\0\u{3}field_469\0\u{3}field_470\0\u{3}field_471\0\u{3}field_472\0\u{3}field_473\0\u{3}field_474\0\u{3}field_475\0\u{3}field_476\0\u{3}field_477\0\u{3}field_478\0\u{3}field_479\0\u{3}field_480\0\u{3}field_481\0\u{3}field_482\0\u{3}field_483\0\u{3}field_484\0\u{3}field_485\0\u{3}field_486\0\u{3}field_487\0\u{3}field_488\0\u{3}field_489\0\u{3}field_490\0\u{3}field_491\0\u{3}field_492\0\u{3}field_493\0\u{3}field_494\0\u{3}field_495\0\u{3}field_496\0\u{3}field_497\0\u{3}field_498\0\u{3}field_499\0\u{3}field_500\0\u{3}field_501\0\u{3}regular_field_502\0\u{3}field_503\0\u{3}field_504\0\u{3}field_505\0\u{3}field_506\0\u{3}field_507\0\u{3}field_508\0\u{3}regular_field_509\0\u{3}field_510\0") + + 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: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field001(v) + } + }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._regularField002) }() + case 3: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field003(v) + } + }() + case 4: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field004(v) + } + }() + case 5: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field005(v) + } + }() + case 6: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field006(v) + } + }() + case 7: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field007(v) + } + }() + case 8: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field008(v) + } + }() + case 9: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field009(v) + } + }() + case 10: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field050(v) + } + }() + case 11: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field011(v) + } + }() + case 12: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field012(v) + } + }() + case 13: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field013(v) + } + }() + case 14: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field014(v) + } + }() + case 15: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field015(v) + } + }() + case 16: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field016(v) + } + }() + case 17: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field017(v) + } + }() + case 18: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field018(v) + } + }() + case 19: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field019(v) + } + }() + case 20: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field020(v) + } + }() + case 21: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field021(v) + } + }() + case 22: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field022(v) + } + }() + case 23: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field023(v) + } + }() + case 24: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field024(v) + } + }() + case 25: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field025(v) + } + }() + case 26: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field026(v) + } + }() + case 27: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field027(v) + } + }() + case 28: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field028(v) + } + }() + case 29: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field029(v) + } + }() + case 30: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field030(v) + } + }() + case 31: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field031(v) + } + }() + case 32: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field032(v) + } + }() + case 33: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field033(v) + } + }() + case 34: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field034(v) + } + }() + case 35: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field035(v) + } + }() + case 36: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field036(v) + } + }() + case 37: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field037(v) + } + }() + case 38: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field038(v) + } + }() + case 39: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field039(v) + } + }() + case 40: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field040(v) + } + }() + case 41: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field041(v) + } + }() + case 42: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field042(v) + } + }() + case 43: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field043(v) + } + }() + case 44: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field044(v) + } + }() + case 45: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field045(v) + } + }() + case 46: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field046(v) + } + }() + case 47: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field047(v) + } + }() + case 48: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field048(v) + } + }() + case 49: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field049(v) + } + }() + case 50: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field010(v) + } + }() + case 51: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field051(v) + } + }() + case 52: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field052(v) + } + }() + case 53: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field053(v) + } + }() + case 54: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field054(v) + } + }() + case 55: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field055(v) + } + }() + case 56: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field056(v) + } + }() + case 57: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field057(v) + } + }() + case 58: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field058(v) + } + }() + case 59: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field059(v) + } + }() + case 60: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field060(v) + } + }() + case 61: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field061(v) + } + }() + case 62: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field062(v) + } + }() + case 63: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field063(v) + } + }() + case 64: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field064(v) + } + }() + case 65: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field065(v) + } + }() + case 66: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field066(v) + } + }() + case 67: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field067(v) + } + }() + case 68: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field068(v) + } + }() + case 69: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field069(v) + } + }() + case 70: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field070(v) + } + }() + case 71: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field071(v) + } + }() + case 72: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field072(v) + } + }() + case 73: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field073(v) + } + }() + case 74: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field074(v) + } + }() + case 75: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field075(v) + } + }() + case 76: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field076(v) + } + }() + case 77: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field077(v) + } + }() + case 78: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field078(v) + } + }() + case 79: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field079(v) + } + }() + case 80: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field080(v) + } + }() + case 81: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field081(v) + } + }() + case 82: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field082(v) + } + }() + case 83: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field083(v) + } + }() + case 84: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field084(v) + } + }() + case 85: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field085(v) + } + }() + case 86: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field086(v) + } + }() + case 87: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field087(v) + } + }() + case 88: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field088(v) + } + }() + case 89: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field089(v) + } + }() + case 90: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field090(v) + } + }() + case 91: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field091(v) + } + }() + case 92: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field092(v) + } + }() + case 93: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field093(v) + } + }() + case 94: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field094(v) + } + }() + case 95: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field095(v) + } + }() + case 96: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field096(v) + } + }() + case 97: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field097(v) + } + }() + case 98: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field098(v) + } + }() + case 99: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field099(v) + } + }() + case 100: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field200(v) + } + }() + case 101: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field101(v) + } + }() + case 102: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field102(v) + } + }() + case 103: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field103(v) + } + }() + case 104: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field104(v) + } + }() + case 105: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field105(v) + } + }() + case 106: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field106(v) + } + }() + case 107: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field107(v) + } + }() + case 108: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field108(v) + } + }() + case 109: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field109(v) + } + }() + case 110: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field110(v) + } + }() + case 111: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field111(v) + } + }() + case 112: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field112(v) + } + }() + case 113: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field113(v) + } + }() + case 114: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field114(v) + } + }() + case 115: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field115(v) + } + }() + case 116: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field116(v) + } + }() + case 117: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field117(v) + } + }() + case 118: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field118(v) + } + }() + case 119: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field119(v) + } + }() + case 120: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field120(v) + } + }() + case 121: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field121(v) + } + }() + case 122: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field122(v) + } + }() + case 123: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field123(v) + } + }() + case 124: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field124(v) + } + }() + case 125: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field125(v) + } + }() + case 126: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field126(v) + } + }() + case 127: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field127(v) + } + }() + case 128: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field128(v) + } + }() + case 129: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field129(v) + } + }() + case 130: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field130(v) + } + }() + case 131: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field131(v) + } + }() + case 132: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field132(v) + } + }() + case 133: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field133(v) + } + }() + case 134: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field134(v) + } + }() + case 135: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field135(v) + } + }() + case 136: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field136(v) + } + }() + case 137: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field137(v) + } + }() + case 138: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field138(v) + } + }() + case 139: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field139(v) + } + }() + case 140: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field140(v) + } + }() + case 141: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field141(v) + } + }() + case 142: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field142(v) + } + }() + case 143: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field143(v) + } + }() + case 144: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field144(v) + } + }() + case 145: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field145(v) + } + }() + case 146: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field146(v) + } + }() + case 147: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field147(v) + } + }() + case 148: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field148(v) + } + }() + case 149: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field149(v) + } + }() + case 150: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field150(v) + } + }() + case 151: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field151(v) + } + }() + case 152: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field152(v) + } + }() + case 153: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field153(v) + } + }() + case 154: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field154(v) + } + }() + case 155: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field155(v) + } + }() + case 156: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field156(v) + } + }() + case 157: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field157(v) + } + }() + case 158: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field158(v) + } + }() + case 159: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field159(v) + } + }() + case 160: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field160(v) + } + }() + case 161: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field161(v) + } + }() + case 162: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field162(v) + } + }() + case 163: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field163(v) + } + }() + case 164: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field164(v) + } + }() + case 165: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field165(v) + } + }() + case 166: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field166(v) + } + }() + case 167: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field167(v) + } + }() + case 168: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field168(v) + } + }() + case 169: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field169(v) + } + }() + case 170: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field170(v) + } + }() + case 171: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field171(v) + } + }() + case 172: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field172(v) + } + }() + case 173: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field173(v) + } + }() + case 174: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field174(v) + } + }() + case 175: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field175(v) + } + }() + case 176: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field176(v) + } + }() + case 177: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field177(v) + } + }() + case 178: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field178(v) + } + }() + case 179: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field179(v) + } + }() + case 180: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field180(v) + } + }() + case 181: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field181(v) + } + }() + case 182: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field182(v) + } + }() + case 183: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field183(v) + } + }() + case 184: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field184(v) + } + }() + case 185: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field185(v) + } + }() + case 186: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field186(v) + } + }() + case 187: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field187(v) + } + }() + case 188: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field188(v) + } + }() + case 189: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field189(v) + } + }() + case 190: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field190(v) + } + }() + case 191: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field191(v) + } + }() + case 192: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field192(v) + } + }() + case 193: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field193(v) + } + }() + case 194: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field194(v) + } + }() + case 195: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field195(v) + } + }() + case 196: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field196(v) + } + }() + case 197: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field197(v) + } + }() + case 198: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field198(v) + } + }() + case 199: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field199(v) + } + }() + case 200: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field100(v) + } + }() + case 201: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field201(v) + } + }() + case 202: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field202(v) + } + }() + case 203: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field203(v) + } + }() + case 204: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field204(v) + } + }() + case 205: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field205(v) + } + }() + case 206: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field206(v) + } + }() + case 207: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field207(v) + } + }() + case 208: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field208(v) + } + }() + case 209: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field209(v) + } + }() + case 210: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field210(v) + } + }() + case 211: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field211(v) + } + }() + case 212: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field212(v) + } + }() + case 213: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field213(v) + } + }() + case 214: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field214(v) + } + }() + case 215: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field215(v) + } + }() + case 216: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field216(v) + } + }() + case 217: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field217(v) + } + }() + case 218: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field218(v) + } + }() + case 219: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field219(v) + } + }() + case 220: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field220(v) + } + }() + case 221: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field221(v) + } + }() + case 222: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field222(v) + } + }() + case 223: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field223(v) + } + }() + case 224: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field224(v) + } + }() + case 225: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field225(v) + } + }() + case 226: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field226(v) + } + }() + case 227: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field227(v) + } + }() + case 228: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field228(v) + } + }() + case 229: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field229(v) + } + }() + case 230: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field230(v) + } + }() + case 231: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field231(v) + } + }() + case 232: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field232(v) + } + }() + case 233: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field233(v) + } + }() + case 234: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field234(v) + } + }() + case 235: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field235(v) + } + }() + case 236: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field236(v) + } + }() + case 237: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field237(v) + } + }() + case 238: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field238(v) + } + }() + case 239: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field239(v) + } + }() + case 240: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field240(v) + } + }() + case 241: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field241(v) + } + }() + case 242: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field242(v) + } + }() + case 243: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field243(v) + } + }() + case 244: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field244(v) + } + }() + case 245: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field245(v) + } + }() + case 246: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field246(v) + } + }() + case 247: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field247(v) + } + }() + case 248: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field248(v) + } + }() + case 249: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field249(v) + } + }() + case 250: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field250(v) + } + }() + case 251: try { try decoder.decodeSingularInt32Field(value: &self._regularField251) }() + case 252: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field252(v) + } + }() + case 253: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field253(v) + } + }() + case 254: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field254(v) + } + }() + case 255: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field255(v) + } + }() + case 256: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field256(v) + } + }() + case 257: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field257(v) + } + }() + case 258: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field258(v) + } + }() + case 259: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field259(v) + } + }() + case 260: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field260(v) + } + }() + case 261: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field261(v) + } + }() + case 262: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field262(v) + } + }() + case 263: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field263(v) + } + }() + case 264: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field264(v) + } + }() + case 265: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field265(v) + } + }() + case 266: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field266(v) + } + }() + case 267: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field267(v) + } + }() + case 268: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field268(v) + } + }() + case 269: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field269(v) + } + }() + case 270: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field270(v) + } + }() + case 271: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field271(v) + } + }() + case 272: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field272(v) + } + }() + case 273: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field273(v) + } + }() + case 274: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field274(v) + } + }() + case 275: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field275(v) + } + }() + case 276: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field276(v) + } + }() + case 277: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field277(v) + } + }() + case 278: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field278(v) + } + }() + case 279: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field279(v) + } + }() + case 280: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field280(v) + } + }() + case 281: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field281(v) + } + }() + case 282: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field282(v) + } + }() + case 283: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field283(v) + } + }() + case 284: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field284(v) + } + }() + case 285: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field285(v) + } + }() + case 286: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field286(v) + } + }() + case 287: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field287(v) + } + }() + case 288: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field288(v) + } + }() + case 289: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field289(v) + } + }() + case 290: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field290(v) + } + }() + case 291: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field291(v) + } + }() + case 292: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field292(v) + } + }() + case 293: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field293(v) + } + }() + case 294: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field294(v) + } + }() + case 295: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field295(v) + } + }() + case 296: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field296(v) + } + }() + case 297: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field297(v) + } + }() + case 298: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field298(v) + } + }() + case 299: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field299(v) + } + }() + case 300: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field400(v) + } + }() + case 301: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field301(v) + } + }() + case 302: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field302(v) + } + }() + case 303: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field303(v) + } + }() + case 304: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field304(v) + } + }() + case 305: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field305(v) + } + }() + case 306: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field306(v) + } + }() + case 307: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field307(v) + } + }() + case 308: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field308(v) + } + }() + case 309: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field309(v) + } + }() + case 310: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field310(v) + } + }() + case 311: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field311(v) + } + }() + case 312: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field312(v) + } + }() + case 313: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field313(v) + } + }() + case 314: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field314(v) + } + }() + case 315: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field315(v) + } + }() + case 316: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field316(v) + } + }() + case 317: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field317(v) + } + }() + case 318: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field318(v) + } + }() + case 319: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field319(v) + } + }() + case 320: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field320(v) + } + }() + case 321: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field321(v) + } + }() + case 322: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field322(v) + } + }() + case 323: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field323(v) + } + }() + case 324: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field324(v) + } + }() + case 325: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field325(v) + } + }() + case 326: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field326(v) + } + }() + case 327: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field327(v) + } + }() + case 328: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field328(v) + } + }() + case 329: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field329(v) + } + }() + case 330: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field330(v) + } + }() + case 331: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field331(v) + } + }() + case 332: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field332(v) + } + }() + case 333: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field333(v) + } + }() + case 334: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field334(v) + } + }() + case 335: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field335(v) + } + }() + case 336: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field336(v) + } + }() + case 337: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field337(v) + } + }() + case 338: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field338(v) + } + }() + case 339: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field339(v) + } + }() + case 340: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field340(v) + } + }() + case 341: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field341(v) + } + }() + case 342: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field342(v) + } + }() + case 343: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field343(v) + } + }() + case 344: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field344(v) + } + }() + case 345: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field345(v) + } + }() + case 346: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field346(v) + } + }() + case 347: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field347(v) + } + }() + case 348: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field348(v) + } + }() + case 349: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field349(v) + } + }() + case 350: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field350(v) + } + }() + case 351: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field351(v) + } + }() + case 352: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field352(v) + } + }() + case 353: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field353(v) + } + }() + case 354: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field354(v) + } + }() + case 355: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field355(v) + } + }() + case 356: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field356(v) + } + }() + case 357: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field357(v) + } + }() + case 358: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field358(v) + } + }() + case 359: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field359(v) + } + }() + case 360: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field360(v) + } + }() + case 361: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field361(v) + } + }() + case 362: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field362(v) + } + }() + case 363: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field363(v) + } + }() + case 364: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field364(v) + } + }() + case 365: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field365(v) + } + }() + case 366: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field366(v) + } + }() + case 367: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field367(v) + } + }() + case 368: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field368(v) + } + }() + case 369: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field369(v) + } + }() + case 370: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field370(v) + } + }() + case 371: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field371(v) + } + }() + case 372: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field372(v) + } + }() + case 373: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field373(v) + } + }() + case 374: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field374(v) + } + }() + case 375: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field375(v) + } + }() + case 376: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field376(v) + } + }() + case 377: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field377(v) + } + }() + case 378: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field378(v) + } + }() + case 379: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field379(v) + } + }() + case 380: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field380(v) + } + }() + case 381: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field381(v) + } + }() + case 382: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field382(v) + } + }() + case 383: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field383(v) + } + }() + case 384: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field384(v) + } + }() + case 385: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field385(v) + } + }() + case 386: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field386(v) + } + }() + case 387: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field387(v) + } + }() + case 388: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field388(v) + } + }() + case 389: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field389(v) + } + }() + case 390: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field390(v) + } + }() + case 391: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field391(v) + } + }() + case 392: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field392(v) + } + }() + case 393: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field393(v) + } + }() + case 394: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field394(v) + } + }() + case 395: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field395(v) + } + }() + case 396: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field396(v) + } + }() + case 397: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field397(v) + } + }() + case 398: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field398(v) + } + }() + case 399: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field399(v) + } + }() + case 400: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field300(v) + } + }() + case 401: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field401(v) + } + }() + case 402: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field402(v) + } + }() + case 403: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field403(v) + } + }() + case 404: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field404(v) + } + }() + case 405: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field405(v) + } + }() + case 406: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field406(v) + } + }() + case 407: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field407(v) + } + }() + case 408: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field408(v) + } + }() + case 409: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field409(v) + } + }() + case 410: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field410(v) + } + }() + case 411: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field411(v) + } + }() + case 412: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field412(v) + } + }() + case 413: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field413(v) + } + }() + case 414: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field414(v) + } + }() + case 415: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field415(v) + } + }() + case 416: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field416(v) + } + }() + case 417: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field417(v) + } + }() + case 418: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field418(v) + } + }() + case 419: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field419(v) + } + }() + case 420: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field420(v) + } + }() + case 421: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field421(v) + } + }() + case 422: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field422(v) + } + }() + case 423: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field423(v) + } + }() + case 424: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field424(v) + } + }() + case 425: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field425(v) + } + }() + case 426: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field426(v) + } + }() + case 427: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field427(v) + } + }() + case 428: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field428(v) + } + }() + case 429: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field429(v) + } + }() + case 430: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field430(v) + } + }() + case 431: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field431(v) + } + }() + case 432: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field432(v) + } + }() + case 433: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field433(v) + } + }() + case 434: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field434(v) + } + }() + case 435: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field435(v) + } + }() + case 436: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field436(v) + } + }() + case 437: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field437(v) + } + }() + case 438: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field438(v) + } + }() + case 439: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field439(v) + } + }() + case 440: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field440(v) + } + }() + case 441: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field441(v) + } + }() + case 442: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field442(v) + } + }() + case 443: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field443(v) + } + }() + case 444: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field444(v) + } + }() + case 445: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field445(v) + } + }() + case 446: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field446(v) + } + }() + case 447: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field447(v) + } + }() + case 448: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field448(v) + } + }() + case 449: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field449(v) + } + }() + case 450: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field450(v) + } + }() + case 451: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field451(v) + } + }() + case 452: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field452(v) + } + }() + case 453: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field453(v) + } + }() + case 454: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field454(v) + } + }() + case 455: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field455(v) + } + }() + case 456: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field456(v) + } + }() + case 457: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field457(v) + } + }() + case 458: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field458(v) + } + }() + case 459: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field459(v) + } + }() + case 460: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field460(v) + } + }() + case 461: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field461(v) + } + }() + case 462: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field462(v) + } + }() + case 463: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field463(v) + } + }() + case 464: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field464(v) + } + }() + case 465: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field465(v) + } + }() + case 466: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field466(v) + } + }() + case 467: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field467(v) + } + }() + case 468: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field468(v) + } + }() + case 469: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field469(v) + } + }() + case 470: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field470(v) + } + }() + case 471: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field471(v) + } + }() + case 472: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field472(v) + } + }() + case 473: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field473(v) + } + }() + case 474: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field474(v) + } + }() + case 475: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field475(v) + } + }() + case 476: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field476(v) + } + }() + case 477: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field477(v) + } + }() + case 478: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field478(v) + } + }() + case 479: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field479(v) + } + }() + case 480: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field480(v) + } + }() + case 481: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field481(v) + } + }() + case 482: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field482(v) + } + }() + case 483: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field483(v) + } + }() + case 484: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field484(v) + } + }() + case 485: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field485(v) + } + }() + case 486: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field486(v) + } + }() + case 487: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field487(v) + } + }() + case 488: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field488(v) + } + }() + case 489: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field489(v) + } + }() + case 490: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field490(v) + } + }() + case 491: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field491(v) + } + }() + case 492: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field492(v) + } + }() + case 493: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field493(v) + } + }() + case 494: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field494(v) + } + }() + case 495: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field495(v) + } + }() + case 496: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field496(v) + } + }() + case 497: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field497(v) + } + }() + case 498: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field498(v) + } + }() + case 499: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field499(v) + } + }() + case 500: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field500(v) + } + }() + case 501: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field501(v) + } + }() + case 502: try { try decoder.decodeSingularInt32Field(value: &self._regularField502) }() + case 503: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field503(v) + } + }() + case 504: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field504(v) + } + }() + case 505: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field505(v) + } + }() + case 506: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field506(v) + } + }() + case 507: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field507(v) + } + }() + case 508: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field508(v) + } + }() + case 509: try { try decoder.decodeSingularInt32Field(value: &self._regularField509) }() + case 510: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field510(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 + try { if case .field001(let v)? = self.value { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._regularField002 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + switch self.value { + case .field003?: try { + guard case .field003(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + }() + case .field004?: try { + guard case .field004(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + }() + case .field005?: try { + guard case .field005(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) + }() + case .field006?: try { + guard case .field006(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) + }() + case .field007?: try { + guard case .field007(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) + }() + case .field008?: try { + guard case .field008(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 8) + }() + case .field009?: try { + guard case .field009(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + }() + case .field050?: try { + guard case .field050(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 10) + }() + case .field011?: try { + guard case .field011(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 11) + }() + case .field012?: try { + guard case .field012(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 12) + }() + case .field013?: try { + guard case .field013(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 13) + }() + case .field014?: try { + guard case .field014(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 14) + }() + case .field015?: try { + guard case .field015(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 15) + }() + case .field016?: try { + guard case .field016(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 16) + }() + case .field017?: try { + guard case .field017(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) + }() + case .field018?: try { + guard case .field018(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 18) + }() + case .field019?: try { + guard case .field019(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 19) + }() + case .field020?: try { + guard case .field020(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 20) + }() + case .field021?: try { + guard case .field021(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 21) + }() + case .field022?: try { + guard case .field022(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 22) + }() + case .field023?: try { + guard case .field023(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 23) + }() + case .field024?: try { + guard case .field024(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 24) + }() + case .field025?: try { + guard case .field025(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 25) + }() + case .field026?: try { + guard case .field026(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 26) + }() + case .field027?: try { + guard case .field027(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 27) + }() + case .field028?: try { + guard case .field028(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 28) + }() + case .field029?: try { + guard case .field029(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 29) + }() + case .field030?: try { + guard case .field030(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 30) + }() + case .field031?: try { + guard case .field031(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 31) + }() + case .field032?: try { + guard case .field032(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 32) + }() + case .field033?: try { + guard case .field033(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 33) + }() + case .field034?: try { + guard case .field034(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 34) + }() + case .field035?: try { + guard case .field035(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 35) + }() + case .field036?: try { + guard case .field036(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 36) + }() + case .field037?: try { + guard case .field037(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 37) + }() + case .field038?: try { + guard case .field038(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 38) + }() + case .field039?: try { + guard case .field039(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 39) + }() + case .field040?: try { + guard case .field040(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 40) + }() + case .field041?: try { + guard case .field041(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 41) + }() + case .field042?: try { + guard case .field042(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 42) + }() + case .field043?: try { + guard case .field043(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 43) + }() + case .field044?: try { + guard case .field044(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 44) + }() + case .field045?: try { + guard case .field045(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 45) + }() + case .field046?: try { + guard case .field046(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 46) + }() + case .field047?: try { + guard case .field047(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) + }() + case .field048?: try { + guard case .field048(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 48) + }() + case .field049?: try { + guard case .field049(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 49) + }() + case .field010?: try { + guard case .field010(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 50) + }() + case .field051?: try { + guard case .field051(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 51) + }() + case .field052?: try { + guard case .field052(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 52) + }() + case .field053?: try { + guard case .field053(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 53) + }() + case .field054?: try { + guard case .field054(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 54) + }() + case .field055?: try { + guard case .field055(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 55) + }() + case .field056?: try { + guard case .field056(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 56) + }() + case .field057?: try { + guard case .field057(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 57) + }() + case .field058?: try { + guard case .field058(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 58) + }() + case .field059?: try { + guard case .field059(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 59) + }() + case .field060?: try { + guard case .field060(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 60) + }() + case .field061?: try { + guard case .field061(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 61) + }() + case .field062?: try { + guard case .field062(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 62) + }() + case .field063?: try { + guard case .field063(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 63) + }() + case .field064?: try { + guard case .field064(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 64) + }() + case .field065?: try { + guard case .field065(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 65) + }() + case .field066?: try { + guard case .field066(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 66) + }() + case .field067?: try { + guard case .field067(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 67) + }() + case .field068?: try { + guard case .field068(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 68) + }() + case .field069?: try { + guard case .field069(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 69) + }() + case .field070?: try { + guard case .field070(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 70) + }() + case .field071?: try { + guard case .field071(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 71) + }() + case .field072?: try { + guard case .field072(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 72) + }() + case .field073?: try { + guard case .field073(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 73) + }() + case .field074?: try { + guard case .field074(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 74) + }() + case .field075?: try { + guard case .field075(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 75) + }() + case .field076?: try { + guard case .field076(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 76) + }() + case .field077?: try { + guard case .field077(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 77) + }() + case .field078?: try { + guard case .field078(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 78) + }() + case .field079?: try { + guard case .field079(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 79) + }() + case .field080?: try { + guard case .field080(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 80) + }() + case .field081?: try { + guard case .field081(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 81) + }() + case .field082?: try { + guard case .field082(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 82) + }() + case .field083?: try { + guard case .field083(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 83) + }() + case .field084?: try { + guard case .field084(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 84) + }() + case .field085?: try { + guard case .field085(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 85) + }() + case .field086?: try { + guard case .field086(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 86) + }() + case .field087?: try { + guard case .field087(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 87) + }() + case .field088?: try { + guard case .field088(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 88) + }() + case .field089?: try { + guard case .field089(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 89) + }() + case .field090?: try { + guard case .field090(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 90) + }() + case .field091?: try { + guard case .field091(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 91) + }() + case .field092?: try { + guard case .field092(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 92) + }() + case .field093?: try { + guard case .field093(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 93) + }() + case .field094?: try { + guard case .field094(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 94) + }() + case .field095?: try { + guard case .field095(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 95) + }() + case .field096?: try { + guard case .field096(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 96) + }() + case .field097?: try { + guard case .field097(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 97) + }() + case .field098?: try { + guard case .field098(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 98) + }() + case .field099?: try { + guard case .field099(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 99) + }() + case .field200?: try { + guard case .field200(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 100) + }() + case .field101?: try { + guard case .field101(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 101) + }() + case .field102?: try { + guard case .field102(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 102) + }() + case .field103?: try { + guard case .field103(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 103) + }() + case .field104?: try { + guard case .field104(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 104) + }() + case .field105?: try { + guard case .field105(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 105) + }() + case .field106?: try { + guard case .field106(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 106) + }() + case .field107?: try { + guard case .field107(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 107) + }() + case .field108?: try { + guard case .field108(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 108) + }() + case .field109?: try { + guard case .field109(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 109) + }() + case .field110?: try { + guard case .field110(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 110) + }() + case .field111?: try { + guard case .field111(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 111) + }() + case .field112?: try { + guard case .field112(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 112) + }() + case .field113?: try { + guard case .field113(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 113) + }() + case .field114?: try { + guard case .field114(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 114) + }() + case .field115?: try { + guard case .field115(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 115) + }() + case .field116?: try { + guard case .field116(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 116) + }() + case .field117?: try { + guard case .field117(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 117) + }() + case .field118?: try { + guard case .field118(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 118) + }() + case .field119?: try { + guard case .field119(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 119) + }() + case .field120?: try { + guard case .field120(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 120) + }() + case .field121?: try { + guard case .field121(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 121) + }() + case .field122?: try { + guard case .field122(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 122) + }() + case .field123?: try { + guard case .field123(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 123) + }() + case .field124?: try { + guard case .field124(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 124) + }() + case .field125?: try { + guard case .field125(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 125) + }() + case .field126?: try { + guard case .field126(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 126) + }() + case .field127?: try { + guard case .field127(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 127) + }() + case .field128?: try { + guard case .field128(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 128) + }() + case .field129?: try { + guard case .field129(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 129) + }() + case .field130?: try { + guard case .field130(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 130) + }() + case .field131?: try { + guard case .field131(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 131) + }() + case .field132?: try { + guard case .field132(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 132) + }() + case .field133?: try { + guard case .field133(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 133) + }() + case .field134?: try { + guard case .field134(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 134) + }() + case .field135?: try { + guard case .field135(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 135) + }() + case .field136?: try { + guard case .field136(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 136) + }() + case .field137?: try { + guard case .field137(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 137) + }() + case .field138?: try { + guard case .field138(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 138) + }() + case .field139?: try { + guard case .field139(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 139) + }() + case .field140?: try { + guard case .field140(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 140) + }() + case .field141?: try { + guard case .field141(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 141) + }() + case .field142?: try { + guard case .field142(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 142) + }() + case .field143?: try { + guard case .field143(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 143) + }() + case .field144?: try { + guard case .field144(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 144) + }() + case .field145?: try { + guard case .field145(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 145) + }() + case .field146?: try { + guard case .field146(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 146) + }() + case .field147?: try { + guard case .field147(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 147) + }() + case .field148?: try { + guard case .field148(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 148) + }() + case .field149?: try { + guard case .field149(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 149) + }() + case .field150?: try { + guard case .field150(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 150) + }() + case .field151?: try { + guard case .field151(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 151) + }() + case .field152?: try { + guard case .field152(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 152) + }() + case .field153?: try { + guard case .field153(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 153) + }() + case .field154?: try { + guard case .field154(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 154) + }() + case .field155?: try { + guard case .field155(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 155) + }() + case .field156?: try { + guard case .field156(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 156) + }() + case .field157?: try { + guard case .field157(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 157) + }() + case .field158?: try { + guard case .field158(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 158) + }() + case .field159?: try { + guard case .field159(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 159) + }() + case .field160?: try { + guard case .field160(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 160) + }() + case .field161?: try { + guard case .field161(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 161) + }() + case .field162?: try { + guard case .field162(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 162) + }() + case .field163?: try { + guard case .field163(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 163) + }() + case .field164?: try { + guard case .field164(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 164) + }() + case .field165?: try { + guard case .field165(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 165) + }() + case .field166?: try { + guard case .field166(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 166) + }() + case .field167?: try { + guard case .field167(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 167) + }() + case .field168?: try { + guard case .field168(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 168) + }() + case .field169?: try { + guard case .field169(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 169) + }() + case .field170?: try { + guard case .field170(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 170) + }() + case .field171?: try { + guard case .field171(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 171) + }() + case .field172?: try { + guard case .field172(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 172) + }() + case .field173?: try { + guard case .field173(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 173) + }() + case .field174?: try { + guard case .field174(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 174) + }() + case .field175?: try { + guard case .field175(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 175) + }() + case .field176?: try { + guard case .field176(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 176) + }() + case .field177?: try { + guard case .field177(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 177) + }() + case .field178?: try { + guard case .field178(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 178) + }() + case .field179?: try { + guard case .field179(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 179) + }() + case .field180?: try { + guard case .field180(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 180) + }() + case .field181?: try { + guard case .field181(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 181) + }() + case .field182?: try { + guard case .field182(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 182) + }() + case .field183?: try { + guard case .field183(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 183) + }() + case .field184?: try { + guard case .field184(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 184) + }() + case .field185?: try { + guard case .field185(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 185) + }() + case .field186?: try { + guard case .field186(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 186) + }() + case .field187?: try { + guard case .field187(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 187) + }() + case .field188?: try { + guard case .field188(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 188) + }() + case .field189?: try { + guard case .field189(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 189) + }() + case .field190?: try { + guard case .field190(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 190) + }() + case .field191?: try { + guard case .field191(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 191) + }() + case .field192?: try { + guard case .field192(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 192) + }() + case .field193?: try { + guard case .field193(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 193) + }() + case .field194?: try { + guard case .field194(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 194) + }() + case .field195?: try { + guard case .field195(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 195) + }() + case .field196?: try { + guard case .field196(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 196) + }() + case .field197?: try { + guard case .field197(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 197) + }() + case .field198?: try { + guard case .field198(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 198) + }() + case .field199?: try { + guard case .field199(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 199) + }() + case .field100?: try { + guard case .field100(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 200) + }() + case .field201?: try { + guard case .field201(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 201) + }() + case .field202?: try { + guard case .field202(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 202) + }() + case .field203?: try { + guard case .field203(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 203) + }() + case .field204?: try { + guard case .field204(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 204) + }() + case .field205?: try { + guard case .field205(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 205) + }() + case .field206?: try { + guard case .field206(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 206) + }() + case .field207?: try { + guard case .field207(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 207) + }() + case .field208?: try { + guard case .field208(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 208) + }() + case .field209?: try { + guard case .field209(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 209) + }() + case .field210?: try { + guard case .field210(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 210) + }() + case .field211?: try { + guard case .field211(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 211) + }() + case .field212?: try { + guard case .field212(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 212) + }() + case .field213?: try { + guard case .field213(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 213) + }() + case .field214?: try { + guard case .field214(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 214) + }() + case .field215?: try { + guard case .field215(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 215) + }() + case .field216?: try { + guard case .field216(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 216) + }() + case .field217?: try { + guard case .field217(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 217) + }() + case .field218?: try { + guard case .field218(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 218) + }() + case .field219?: try { + guard case .field219(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 219) + }() + case .field220?: try { + guard case .field220(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 220) + }() + case .field221?: try { + guard case .field221(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 221) + }() + case .field222?: try { + guard case .field222(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 222) + }() + case .field223?: try { + guard case .field223(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 223) + }() + case .field224?: try { + guard case .field224(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 224) + }() + case .field225?: try { + guard case .field225(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 225) + }() + case .field226?: try { + guard case .field226(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 226) + }() + case .field227?: try { + guard case .field227(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 227) + }() + case .field228?: try { + guard case .field228(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 228) + }() + case .field229?: try { + guard case .field229(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 229) + }() + case .field230?: try { + guard case .field230(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 230) + }() + case .field231?: try { + guard case .field231(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 231) + }() + case .field232?: try { + guard case .field232(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 232) + }() + case .field233?: try { + guard case .field233(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 233) + }() + case .field234?: try { + guard case .field234(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 234) + }() + case .field235?: try { + guard case .field235(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 235) + }() + case .field236?: try { + guard case .field236(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 236) + }() + case .field237?: try { + guard case .field237(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 237) + }() + case .field238?: try { + guard case .field238(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 238) + }() + case .field239?: try { + guard case .field239(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 239) + }() + case .field240?: try { + guard case .field240(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 240) + }() + case .field241?: try { + guard case .field241(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 241) + }() + case .field242?: try { + guard case .field242(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 242) + }() + case .field243?: try { + guard case .field243(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 243) + }() + case .field244?: try { + guard case .field244(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 244) + }() + case .field245?: try { + guard case .field245(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 245) + }() + case .field246?: try { + guard case .field246(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 246) + }() + case .field247?: try { + guard case .field247(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 247) + }() + case .field248?: try { + guard case .field248(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 248) + }() + case .field249?: try { + guard case .field249(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 249) + }() + case .field250?: try { + guard case .field250(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 250) + }() + default: break + } + try { if let v = self._regularField251 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 251) + } }() + switch self.value { + case .field252?: try { + guard case .field252(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 252) + }() + case .field253?: try { + guard case .field253(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 253) + }() + case .field254?: try { + guard case .field254(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 254) + }() + case .field255?: try { + guard case .field255(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 255) + }() + case .field256?: try { + guard case .field256(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 256) + }() + case .field257?: try { + guard case .field257(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 257) + }() + case .field258?: try { + guard case .field258(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 258) + }() + case .field259?: try { + guard case .field259(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 259) + }() + case .field260?: try { + guard case .field260(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 260) + }() + case .field261?: try { + guard case .field261(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 261) + }() + case .field262?: try { + guard case .field262(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 262) + }() + case .field263?: try { + guard case .field263(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 263) + }() + case .field264?: try { + guard case .field264(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 264) + }() + case .field265?: try { + guard case .field265(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 265) + }() + case .field266?: try { + guard case .field266(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 266) + }() + case .field267?: try { + guard case .field267(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 267) + }() + case .field268?: try { + guard case .field268(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 268) + }() + case .field269?: try { + guard case .field269(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 269) + }() + case .field270?: try { + guard case .field270(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 270) + }() + case .field271?: try { + guard case .field271(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 271) + }() + case .field272?: try { + guard case .field272(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 272) + }() + case .field273?: try { + guard case .field273(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 273) + }() + case .field274?: try { + guard case .field274(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 274) + }() + case .field275?: try { + guard case .field275(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 275) + }() + case .field276?: try { + guard case .field276(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 276) + }() + case .field277?: try { + guard case .field277(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 277) + }() + case .field278?: try { + guard case .field278(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 278) + }() + case .field279?: try { + guard case .field279(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 279) + }() + case .field280?: try { + guard case .field280(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 280) + }() + case .field281?: try { + guard case .field281(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 281) + }() + case .field282?: try { + guard case .field282(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 282) + }() + case .field283?: try { + guard case .field283(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 283) + }() + case .field284?: try { + guard case .field284(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 284) + }() + case .field285?: try { + guard case .field285(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 285) + }() + case .field286?: try { + guard case .field286(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 286) + }() + case .field287?: try { + guard case .field287(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 287) + }() + case .field288?: try { + guard case .field288(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 288) + }() + case .field289?: try { + guard case .field289(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 289) + }() + case .field290?: try { + guard case .field290(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 290) + }() + case .field291?: try { + guard case .field291(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 291) + }() + case .field292?: try { + guard case .field292(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 292) + }() + case .field293?: try { + guard case .field293(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 293) + }() + case .field294?: try { + guard case .field294(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 294) + }() + case .field295?: try { + guard case .field295(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 295) + }() + case .field296?: try { + guard case .field296(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 296) + }() + case .field297?: try { + guard case .field297(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 297) + }() + case .field298?: try { + guard case .field298(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 298) + }() + case .field299?: try { + guard case .field299(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 299) + }() + case .field400?: try { + guard case .field400(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 300) + }() + case .field301?: try { + guard case .field301(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 301) + }() + case .field302?: try { + guard case .field302(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 302) + }() + case .field303?: try { + guard case .field303(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 303) + }() + case .field304?: try { + guard case .field304(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 304) + }() + case .field305?: try { + guard case .field305(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 305) + }() + case .field306?: try { + guard case .field306(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 306) + }() + case .field307?: try { + guard case .field307(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 307) + }() + case .field308?: try { + guard case .field308(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 308) + }() + case .field309?: try { + guard case .field309(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 309) + }() + case .field310?: try { + guard case .field310(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 310) + }() + case .field311?: try { + guard case .field311(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 311) + }() + case .field312?: try { + guard case .field312(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 312) + }() + case .field313?: try { + guard case .field313(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 313) + }() + case .field314?: try { + guard case .field314(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 314) + }() + case .field315?: try { + guard case .field315(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 315) + }() + case .field316?: try { + guard case .field316(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 316) + }() + case .field317?: try { + guard case .field317(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 317) + }() + case .field318?: try { + guard case .field318(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 318) + }() + case .field319?: try { + guard case .field319(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 319) + }() + case .field320?: try { + guard case .field320(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 320) + }() + case .field321?: try { + guard case .field321(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 321) + }() + case .field322?: try { + guard case .field322(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 322) + }() + case .field323?: try { + guard case .field323(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 323) + }() + case .field324?: try { + guard case .field324(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 324) + }() + case .field325?: try { + guard case .field325(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 325) + }() + case .field326?: try { + guard case .field326(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 326) + }() + case .field327?: try { + guard case .field327(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 327) + }() + case .field328?: try { + guard case .field328(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 328) + }() + case .field329?: try { + guard case .field329(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 329) + }() + case .field330?: try { + guard case .field330(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 330) + }() + case .field331?: try { + guard case .field331(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 331) + }() + case .field332?: try { + guard case .field332(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 332) + }() + case .field333?: try { + guard case .field333(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 333) + }() + case .field334?: try { + guard case .field334(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 334) + }() + case .field335?: try { + guard case .field335(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 335) + }() + case .field336?: try { + guard case .field336(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 336) + }() + case .field337?: try { + guard case .field337(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 337) + }() + case .field338?: try { + guard case .field338(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 338) + }() + case .field339?: try { + guard case .field339(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 339) + }() + case .field340?: try { + guard case .field340(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 340) + }() + case .field341?: try { + guard case .field341(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 341) + }() + case .field342?: try { + guard case .field342(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 342) + }() + case .field343?: try { + guard case .field343(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 343) + }() + case .field344?: try { + guard case .field344(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 344) + }() + case .field345?: try { + guard case .field345(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 345) + }() + case .field346?: try { + guard case .field346(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 346) + }() + case .field347?: try { + guard case .field347(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 347) + }() + case .field348?: try { + guard case .field348(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 348) + }() + case .field349?: try { + guard case .field349(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 349) + }() + case .field350?: try { + guard case .field350(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 350) + }() + case .field351?: try { + guard case .field351(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 351) + }() + case .field352?: try { + guard case .field352(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 352) + }() + case .field353?: try { + guard case .field353(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 353) + }() + case .field354?: try { + guard case .field354(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 354) + }() + case .field355?: try { + guard case .field355(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 355) + }() + case .field356?: try { + guard case .field356(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 356) + }() + case .field357?: try { + guard case .field357(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 357) + }() + case .field358?: try { + guard case .field358(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 358) + }() + case .field359?: try { + guard case .field359(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 359) + }() + case .field360?: try { + guard case .field360(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 360) + }() + case .field361?: try { + guard case .field361(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 361) + }() + case .field362?: try { + guard case .field362(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 362) + }() + case .field363?: try { + guard case .field363(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 363) + }() + case .field364?: try { + guard case .field364(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 364) + }() + case .field365?: try { + guard case .field365(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 365) + }() + case .field366?: try { + guard case .field366(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 366) + }() + case .field367?: try { + guard case .field367(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 367) + }() + case .field368?: try { + guard case .field368(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 368) + }() + case .field369?: try { + guard case .field369(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 369) + }() + case .field370?: try { + guard case .field370(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 370) + }() + case .field371?: try { + guard case .field371(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 371) + }() + case .field372?: try { + guard case .field372(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 372) + }() + case .field373?: try { + guard case .field373(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 373) + }() + case .field374?: try { + guard case .field374(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 374) + }() + case .field375?: try { + guard case .field375(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 375) + }() + case .field376?: try { + guard case .field376(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 376) + }() + case .field377?: try { + guard case .field377(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 377) + }() + case .field378?: try { + guard case .field378(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 378) + }() + case .field379?: try { + guard case .field379(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 379) + }() + case .field380?: try { + guard case .field380(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 380) + }() + case .field381?: try { + guard case .field381(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 381) + }() + case .field382?: try { + guard case .field382(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 382) + }() + case .field383?: try { + guard case .field383(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 383) + }() + case .field384?: try { + guard case .field384(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 384) + }() + case .field385?: try { + guard case .field385(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 385) + }() + case .field386?: try { + guard case .field386(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 386) + }() + case .field387?: try { + guard case .field387(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 387) + }() + case .field388?: try { + guard case .field388(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 388) + }() + case .field389?: try { + guard case .field389(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 389) + }() + case .field390?: try { + guard case .field390(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 390) + }() + case .field391?: try { + guard case .field391(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 391) + }() + case .field392?: try { + guard case .field392(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 392) + }() + case .field393?: try { + guard case .field393(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 393) + }() + case .field394?: try { + guard case .field394(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 394) + }() + case .field395?: try { + guard case .field395(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 395) + }() + case .field396?: try { + guard case .field396(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 396) + }() + case .field397?: try { + guard case .field397(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 397) + }() + case .field398?: try { + guard case .field398(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 398) + }() + case .field399?: try { + guard case .field399(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 399) + }() + case .field300?: try { + guard case .field300(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 400) + }() + case .field401?: try { + guard case .field401(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 401) + }() + case .field402?: try { + guard case .field402(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 402) + }() + case .field403?: try { + guard case .field403(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 403) + }() + case .field404?: try { + guard case .field404(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 404) + }() + case .field405?: try { + guard case .field405(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 405) + }() + case .field406?: try { + guard case .field406(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 406) + }() + case .field407?: try { + guard case .field407(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 407) + }() + case .field408?: try { + guard case .field408(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 408) + }() + case .field409?: try { + guard case .field409(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 409) + }() + case .field410?: try { + guard case .field410(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 410) + }() + case .field411?: try { + guard case .field411(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 411) + }() + case .field412?: try { + guard case .field412(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 412) + }() + case .field413?: try { + guard case .field413(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 413) + }() + case .field414?: try { + guard case .field414(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 414) + }() + case .field415?: try { + guard case .field415(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 415) + }() + case .field416?: try { + guard case .field416(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 416) + }() + case .field417?: try { + guard case .field417(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 417) + }() + case .field418?: try { + guard case .field418(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 418) + }() + case .field419?: try { + guard case .field419(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 419) + }() + case .field420?: try { + guard case .field420(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 420) + }() + case .field421?: try { + guard case .field421(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 421) + }() + case .field422?: try { + guard case .field422(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 422) + }() + case .field423?: try { + guard case .field423(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 423) + }() + case .field424?: try { + guard case .field424(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 424) + }() + case .field425?: try { + guard case .field425(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 425) + }() + case .field426?: try { + guard case .field426(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 426) + }() + case .field427?: try { + guard case .field427(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 427) + }() + case .field428?: try { + guard case .field428(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 428) + }() + case .field429?: try { + guard case .field429(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 429) + }() + case .field430?: try { + guard case .field430(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 430) + }() + case .field431?: try { + guard case .field431(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 431) + }() + case .field432?: try { + guard case .field432(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 432) + }() + case .field433?: try { + guard case .field433(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 433) + }() + case .field434?: try { + guard case .field434(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 434) + }() + case .field435?: try { + guard case .field435(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 435) + }() + case .field436?: try { + guard case .field436(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 436) + }() + case .field437?: try { + guard case .field437(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 437) + }() + case .field438?: try { + guard case .field438(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 438) + }() + case .field439?: try { + guard case .field439(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 439) + }() + case .field440?: try { + guard case .field440(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 440) + }() + case .field441?: try { + guard case .field441(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 441) + }() + case .field442?: try { + guard case .field442(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 442) + }() + case .field443?: try { + guard case .field443(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 443) + }() + case .field444?: try { + guard case .field444(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 444) + }() + case .field445?: try { + guard case .field445(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 445) + }() + case .field446?: try { + guard case .field446(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 446) + }() + case .field447?: try { + guard case .field447(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 447) + }() + case .field448?: try { + guard case .field448(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 448) + }() + case .field449?: try { + guard case .field449(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 449) + }() + case .field450?: try { + guard case .field450(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 450) + }() + case .field451?: try { + guard case .field451(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 451) + }() + case .field452?: try { + guard case .field452(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 452) + }() + case .field453?: try { + guard case .field453(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 453) + }() + case .field454?: try { + guard case .field454(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 454) + }() + case .field455?: try { + guard case .field455(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 455) + }() + case .field456?: try { + guard case .field456(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 456) + }() + case .field457?: try { + guard case .field457(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 457) + }() + case .field458?: try { + guard case .field458(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 458) + }() + case .field459?: try { + guard case .field459(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 459) + }() + case .field460?: try { + guard case .field460(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 460) + }() + case .field461?: try { + guard case .field461(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 461) + }() + case .field462?: try { + guard case .field462(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 462) + }() + case .field463?: try { + guard case .field463(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 463) + }() + case .field464?: try { + guard case .field464(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 464) + }() + case .field465?: try { + guard case .field465(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 465) + }() + case .field466?: try { + guard case .field466(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 466) + }() + case .field467?: try { + guard case .field467(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 467) + }() + case .field468?: try { + guard case .field468(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 468) + }() + case .field469?: try { + guard case .field469(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 469) + }() + case .field470?: try { + guard case .field470(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 470) + }() + case .field471?: try { + guard case .field471(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 471) + }() + case .field472?: try { + guard case .field472(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 472) + }() + case .field473?: try { + guard case .field473(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 473) + }() + case .field474?: try { + guard case .field474(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 474) + }() + case .field475?: try { + guard case .field475(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 475) + }() + case .field476?: try { + guard case .field476(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 476) + }() + case .field477?: try { + guard case .field477(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 477) + }() + case .field478?: try { + guard case .field478(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 478) + }() + case .field479?: try { + guard case .field479(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 479) + }() + case .field480?: try { + guard case .field480(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 480) + }() + case .field481?: try { + guard case .field481(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 481) + }() + case .field482?: try { + guard case .field482(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 482) + }() + case .field483?: try { + guard case .field483(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 483) + }() + case .field484?: try { + guard case .field484(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 484) + }() + case .field485?: try { + guard case .field485(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 485) + }() + case .field486?: try { + guard case .field486(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 486) + }() + case .field487?: try { + guard case .field487(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 487) + }() + case .field488?: try { + guard case .field488(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 488) + }() + case .field489?: try { + guard case .field489(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 489) + }() + case .field490?: try { + guard case .field490(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 490) + }() + case .field491?: try { + guard case .field491(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 491) + }() + case .field492?: try { + guard case .field492(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 492) + }() + case .field493?: try { + guard case .field493(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 493) + }() + case .field494?: try { + guard case .field494(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 494) + }() + case .field495?: try { + guard case .field495(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 495) + }() + case .field496?: try { + guard case .field496(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 496) + }() + case .field497?: try { + guard case .field497(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 497) + }() + case .field498?: try { + guard case .field498(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 498) + }() + case .field499?: try { + guard case .field499(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 499) + }() + case .field500?: try { + guard case .field500(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 500) + }() + case .field501?: try { + guard case .field501(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 501) + }() + default: break + } + try { if let v = self._regularField502 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 502) + } }() + switch self.value { + case .field503?: try { + guard case .field503(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 503) + }() + case .field504?: try { + guard case .field504(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 504) + }() + case .field505?: try { + guard case .field505(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 505) + }() + case .field506?: try { + guard case .field506(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 506) + }() + case .field507?: try { + guard case .field507(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 507) + }() + case .field508?: try { + guard case .field508(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 508) + }() + default: break + } + try { if let v = self._regularField509 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 509) + } }() + try { if case .field510(let v)? = self.value { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 510) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_SwitchSplit_SwitchSplitMessage, rhs: SwiftProtoTesting_SwitchSplit_SwitchSplitMessage) -> Bool { + if lhs._regularField002 != rhs._regularField002 {return false} + if lhs._regularField251 != rhs._regularField251 {return false} + if lhs._regularField502 != rhs._regularField502 {return false} + if lhs._regularField509 != rhs._regularField509 {return false} + if lhs.value != rhs.value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/Tests/SwiftProtobufTests/unittest_swift_reserved.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_reserved.pb.swift new file mode 100644 index 000000000..ec473cedf --- /dev/null +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_reserved.pb.swift @@ -0,0 +1,678 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: unittest_swift_reserved.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protos/unittest_swift_reserved.proto - test proto +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2016 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 Swift reserved words used as enum or message names +/// +// ----------------------------------------------------------------------------- + +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 SwiftProtoTesting_SwiftReservedTest: Sendable { + // 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. + + /// static r/o properties on Message, ensure they still work as fields. + var protoMessageName: Int32 { + get {_protoMessageName ?? 0} + set {_protoMessageName = newValue} + } + /// Returns true if `protoMessageName` has been explicitly set. + var hasProtoMessageName: Bool {self._protoMessageName != nil} + /// Clears the value of `protoMessageName`. Subsequent reads from it will return its default value. + mutating func clearProtoMessageName() {self._protoMessageName = nil} + + var protoPackageName: Int32 { + get {_protoPackageName ?? 0} + set {_protoPackageName = newValue} + } + /// Returns true if `protoPackageName` has been explicitly set. + var hasProtoPackageName: Bool {self._protoPackageName != nil} + /// Clears the value of `protoPackageName`. Subsequent reads from it will return its default value. + mutating func clearProtoPackageName() {self._protoPackageName = nil} + + var anyTypePrefix: Int32 { + get {_anyTypePrefix ?? 0} + set {_anyTypePrefix = newValue} + } + /// Returns true if `anyTypePrefix` has been explicitly set. + var hasAnyTypePrefix: Bool {self._anyTypePrefix != nil} + /// Clears the value of `anyTypePrefix`. Subsequent reads from it will return its default value. + mutating func clearAnyTypePrefix() {self._anyTypePrefix = nil} + + var anyTypeURL: Int32 { + get {_anyTypeURL ?? 0} + set {_anyTypeURL = newValue} + } + /// Returns true if `anyTypeURL` has been explicitly set. + var hasAnyTypeURL: Bool {self._anyTypeURL != nil} + /// Clears the value of `anyTypeURL`. Subsequent reads from it will return its default value. + mutating func clearAnyTypeURL() {self._anyTypeURL = nil} + + /// r/o properties on Message, ensure it gets remapped. + var isInitialized_p: String { + get {_isInitialized_p ?? String()} + set {_isInitialized_p = newValue} + } + /// Returns true if `isInitialized_p` has been explicitly set. + var hasIsInitialized_p: Bool {self._isInitialized_p != nil} + /// Clears the value of `isInitialized_p`. Subsequent reads from it will return its default value. + mutating func clearIsInitialized_p() {self._isInitialized_p = nil} + + var hashValue_p: String { + get {_hashValue_p ?? String()} + set {_hashValue_p = newValue} + } + /// Returns true if `hashValue_p` has been explicitly set. + var hasHashValue_p: Bool {self._hashValue_p != nil} + /// Clears the value of `hashValue_p`. Subsequent reads from it will return its default value. + mutating func clearHashValue_p() {self._hashValue_p = nil} + + var debugDescription_p: Int32 { + get {_debugDescription_p ?? 0} + set {_debugDescription_p = newValue} + } + /// Returns true if `debugDescription_p` has been explicitly set. + var hasDebugDescription_p: Bool {self._debugDescription_p != nil} + /// Clears the value of `debugDescription_p`. Subsequent reads from it will return its default value. + mutating func clearDebugDescription_p() {self._debugDescription_p = nil} + + /// Prompt code generator to build an 'isInitialized' test + var requiredInt: Int32 { + get {_requiredInt ?? 0} + set {_requiredInt = newValue} + } + /// Returns true if `requiredInt` has been explicitly set. + var hasRequiredInt: Bool {self._requiredInt != nil} + /// Clears the value of `requiredInt`. Subsequent reads from it will return its default value. + mutating func clearRequiredInt() {self._requiredInt = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case double = 1 + case json = 2 + case `class` = 3 + case ___ = 4 + case self_ = 5 + case type = 6 + + init() { + self = .double + } + + } + + enum ProtocolEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case a = 1 + + init() { + self = .a + } + + } + + struct classMessage: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() + } + + struct TypeMessage: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() + } + + struct isEqual: Sendable { + // 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() {} + } + + init() {} + + fileprivate var _protoMessageName: Int32? = nil + fileprivate var _protoPackageName: Int32? = nil + fileprivate var _anyTypePrefix: Int32? = nil + fileprivate var _anyTypeURL: Int32? = nil + fileprivate var _isInitialized_p: String? = nil + fileprivate var _hashValue_p: String? = nil + fileprivate var _debugDescription_p: Int32? = nil + fileprivate var _requiredInt: Int32? = nil +} + +struct SwiftProtoTesting_SwiftReservedTestExt: Sendable { + // 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() {} +} + +// MARK: - Extension support defined in unittest_swift_reserved.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 SwiftProtoTesting_SwiftReservedTest.classMessage { + + /// Won't get _p added because it is fully qualified. + var SwiftProtoTesting_debugDescription: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_debug_description) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_debug_description, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_debug_description` + /// has been explicitly set. + var hasSwiftProtoTesting_debugDescription: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_debug_description) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_debug_description`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_debugDescription() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_debug_description) + } + + /// These are scoped to the file, so the package prefix (or a Swift prefix) + /// will get added to them to they aren't going to get renamed. + var SwiftProtoTesting_as: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_as) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_as, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_as` + /// has been explicitly set. + var hasSwiftProtoTesting_as: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_as) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_as`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_as() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_as) + } + + var SwiftProtoTesting_var: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_var) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_var, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_var` + /// has been explicitly set. + var hasSwiftProtoTesting_var: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_var) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_var`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_var() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_var) + } + + var SwiftProtoTesting_try: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_try) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_try, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_try` + /// has been explicitly set. + var hasSwiftProtoTesting_try: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_try) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_try`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_try() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_try) + } + + var SwiftProtoTesting_do: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_do) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_do, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_do` + /// has been explicitly set. + var hasSwiftProtoTesting_do: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_do) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_do`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_do() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_do) + } + + var SwiftProtoTesting_nil: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_nil) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_nil, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_nil` + /// has been explicitly set. + var hasSwiftProtoTesting_nil: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_nil) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_nil`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_nil() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_nil) + } + + /// This will end up in the "enum Extensions" to scope it, but there + /// the raw form is used ("hash_value", not the Swift one "hashValue"), + /// so there is no conflict, and no renaming happens. + var SwiftProtoTesting_SwiftReservedTestExt_hashValue: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.hash_value) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.hash_value, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.hash_value` + /// has been explicitly set. + var hasSwiftProtoTesting_SwiftReservedTestExt_hashValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.hash_value) + } + /// Clears the value of extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.hash_value`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_SwiftReservedTestExt_hashValue() { + clearExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.hash_value) + } + + /// Reserved words, since these end up in the "struct Extensions", they + /// can't just be get their names, and sanitation kicks. + var SwiftProtoTesting_SwiftReservedTestExt_as: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.as) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.as, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.as` + /// has been explicitly set. + var hasSwiftProtoTesting_SwiftReservedTestExt_as: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.as) + } + /// Clears the value of extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.as`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_SwiftReservedTestExt_as() { + clearExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.as) + } + + var SwiftProtoTesting_SwiftReservedTestExt_var: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.var) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.var, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.var` + /// has been explicitly set. + var hasSwiftProtoTesting_SwiftReservedTestExt_var: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.var) + } + /// Clears the value of extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.var`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_SwiftReservedTestExt_var() { + clearExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.var) + } + + var SwiftProtoTesting_SwiftReservedTestExt_try: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.try) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.try, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.try` + /// has been explicitly set. + var hasSwiftProtoTesting_SwiftReservedTestExt_try: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.try) + } + /// Clears the value of extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.try`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_SwiftReservedTestExt_try() { + clearExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.try) + } + + var SwiftProtoTesting_SwiftReservedTestExt_do: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.do) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.do, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.do` + /// has been explicitly set. + var hasSwiftProtoTesting_SwiftReservedTestExt_do: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.do) + } + /// Clears the value of extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.do`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_SwiftReservedTestExt_do() { + clearExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.do) + } + + var SwiftProtoTesting_SwiftReservedTestExt_nil: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.nil) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.nil, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.nil` + /// has been explicitly set. + var hasSwiftProtoTesting_SwiftReservedTestExt_nil: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.nil) + } + /// Clears the value of extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.nil`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_SwiftReservedTestExt_nil() { + clearExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.nil) + } + +} + +// MARK: - File's ExtensionMap: SwiftProtoTesting_UnittestSwiftReserved_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 SwiftProtoTesting_UnittestSwiftReserved_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Extensions_debug_description, + SwiftProtoTesting_Extensions_as, + SwiftProtoTesting_Extensions_var, + SwiftProtoTesting_Extensions_try, + SwiftProtoTesting_Extensions_do, + SwiftProtoTesting_Extensions_nil, + SwiftProtoTesting_SwiftReservedTestExt.Extensions.hash_value, + SwiftProtoTesting_SwiftReservedTestExt.Extensions.as, + SwiftProtoTesting_SwiftReservedTestExt.Extensions.var, + SwiftProtoTesting_SwiftReservedTestExt.Extensions.try, + SwiftProtoTesting_SwiftReservedTestExt.Extensions.do, + SwiftProtoTesting_SwiftReservedTestExt.Extensions.nil +] + +// 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. + +/// Won't get _p added because it is fully qualified. +let SwiftProtoTesting_Extensions_debug_description = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( + _protobuf_fieldNumber: 1000, + fieldName: "swift_proto_testing.debug_description" +) + +/// These are scoped to the file, so the package prefix (or a Swift prefix) +/// will get added to them to they aren't going to get renamed. +let SwiftProtoTesting_Extensions_as = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( + _protobuf_fieldNumber: 1012, + fieldName: "swift_proto_testing.as" +) + +let SwiftProtoTesting_Extensions_var = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( + _protobuf_fieldNumber: 1013, + fieldName: "swift_proto_testing.var" +) + +let SwiftProtoTesting_Extensions_try = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( + _protobuf_fieldNumber: 1014, + fieldName: "swift_proto_testing.try" +) + +let SwiftProtoTesting_Extensions_do = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( + _protobuf_fieldNumber: 1015, + fieldName: "swift_proto_testing.do" +) + +let SwiftProtoTesting_Extensions_nil = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( + _protobuf_fieldNumber: 1016, + fieldName: "swift_proto_testing.nil" +) + +extension SwiftProtoTesting_SwiftReservedTestExt { + enum Extensions { + /// This will end up in the "enum Extensions" to scope it, but there + /// the raw form is used ("hash_value", not the Swift one "hashValue"), + /// so there is no conflict, and no renaming happens. + static let hash_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( + _protobuf_fieldNumber: 1001, + fieldName: "swift_proto_testing.SwiftReservedTestExt.hash_value" + ) + + /// Reserved words, since these end up in the "struct Extensions", they + /// can't just be get their names, and sanitation kicks. + static let `as` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( + _protobuf_fieldNumber: 1022, + fieldName: "swift_proto_testing.SwiftReservedTestExt.as" + ) + + static let `var` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( + _protobuf_fieldNumber: 1023, + fieldName: "swift_proto_testing.SwiftReservedTestExt.var" + ) + + static let `try` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( + _protobuf_fieldNumber: 1024, + fieldName: "swift_proto_testing.SwiftReservedTestExt.try" + ) + + static let `do` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( + _protobuf_fieldNumber: 1025, + fieldName: "swift_proto_testing.SwiftReservedTestExt.do" + ) + + static let `nil` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( + _protobuf_fieldNumber: 1026, + fieldName: "swift_proto_testing.SwiftReservedTestExt.nil" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_proto_testing" + +extension SwiftProtoTesting_SwiftReservedTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".SwiftReservedTest" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{a}proto_message_name\0\u{3}proto_package_name\0\u{3}any_type_prefix\0\u{3}any_type_url\0\u{4}\u{7}is_initialized\0\u{3}hash_value\0\u{3}debug_description\0\u{4}\u{8}required_int\0") + + public var isInitialized: Bool { + if self._requiredInt == nil {return false} + return true + } + + 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 10: try { try decoder.decodeSingularInt32Field(value: &self._protoMessageName) }() + case 11: try { try decoder.decodeSingularInt32Field(value: &self._protoPackageName) }() + case 12: try { try decoder.decodeSingularInt32Field(value: &self._anyTypePrefix) }() + case 13: try { try decoder.decodeSingularInt32Field(value: &self._anyTypeURL) }() + case 20: try { try decoder.decodeSingularStringField(value: &self._isInitialized_p) }() + case 21: try { try decoder.decodeSingularStringField(value: &self._hashValue_p) }() + case 22: try { try decoder.decodeSingularInt32Field(value: &self._debugDescription_p) }() + case 30: try { try decoder.decodeSingularInt32Field(value: &self._requiredInt) }() + 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 + try { if let v = self._protoMessageName { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 10) + } }() + try { if let v = self._protoPackageName { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 11) + } }() + try { if let v = self._anyTypePrefix { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 12) + } }() + try { if let v = self._anyTypeURL { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 13) + } }() + try { if let v = self._isInitialized_p { + try visitor.visitSingularStringField(value: v, fieldNumber: 20) + } }() + try { if let v = self._hashValue_p { + try visitor.visitSingularStringField(value: v, fieldNumber: 21) + } }() + try { if let v = self._debugDescription_p { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 22) + } }() + try { if let v = self._requiredInt { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 30) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_SwiftReservedTest, rhs: SwiftProtoTesting_SwiftReservedTest) -> Bool { + if lhs._protoMessageName != rhs._protoMessageName {return false} + if lhs._protoPackageName != rhs._protoPackageName {return false} + if lhs._anyTypePrefix != rhs._anyTypePrefix {return false} + if lhs._anyTypeURL != rhs._anyTypeURL {return false} + if lhs._isInitialized_p != rhs._isInitialized_p {return false} + if lhs._hashValue_p != rhs._hashValue_p {return false} + if lhs._debugDescription_p != rhs._debugDescription_p {return false} + if lhs._requiredInt != rhs._requiredInt {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_SwiftReservedTest.Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}DOUBLE\0\u{1}JSON\0\u{1}CLASS\0\u{1}_\0\u{1}SELF\0\u{1}TYPE\0") +} + +extension SwiftProtoTesting_SwiftReservedTest.ProtocolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") +} + +extension SwiftProtoTesting_SwiftReservedTest.classMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_SwiftReservedTest.protoMessageName + ".class" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1000 <= fieldNumber && fieldNumber < 2001) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_SwiftReservedTest.classMessage.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 2001) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_SwiftReservedTest.classMessage, rhs: SwiftProtoTesting_SwiftReservedTest.classMessage) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension SwiftProtoTesting_SwiftReservedTest.TypeMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_SwiftReservedTest.protoMessageName + ".Type" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1000 <= fieldNumber && fieldNumber < 2001) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_SwiftReservedTest.TypeMessage.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 2001) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_SwiftReservedTest.TypeMessage, rhs: SwiftProtoTesting_SwiftReservedTest.TypeMessage) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension SwiftProtoTesting_SwiftReservedTest.isEqual: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_SwiftReservedTest.protoMessageName + ".isEqual" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_SwiftReservedTest.isEqual, rhs: SwiftProtoTesting_SwiftReservedTest.isEqual) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_SwiftReservedTestExt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".SwiftReservedTestExt" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_SwiftReservedTestExt, rhs: SwiftProtoTesting_SwiftReservedTestExt) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/unittest_swift_reserved_ext.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_reserved_ext.pb.swift similarity index 89% rename from Reference/unittest_swift_reserved_ext.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_reserved_ext.pb.swift index 238f3b59c..ab98d6d0d 100644 --- a/Reference/unittest_swift_reserved_ext.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_reserved_ext.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_reserved_ext.proto @@ -23,7 +24,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -36,7 +36,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct SwiftReservedTestExt2 { +struct SwiftReservedTestExt2: Sendable { // 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. @@ -46,20 +46,16 @@ struct SwiftReservedTestExt2 { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension SwiftReservedTestExt2: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_reserved_ext.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 ProtobufUnittest_SwiftReservedTest.TypeMessage { +extension SwiftProtoTesting_SwiftReservedTest.TypeMessage { /// Will get _p added because it has no package/swift prefix to scope and /// would otherwise be a problem when added to the message. @@ -275,67 +271,67 @@ let UnittestSwiftReservedExt_Extensions: SwiftProtobuf.SimpleExtensionMap = [ /// Will get _p added because it has no package/swift prefix to scope and /// would otherwise be a problem when added to the message. -let Extensions_debugDescription = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( +let Extensions_debugDescription = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1000, fieldName: "debugDescription" ) /// These will get _p added for the same reasoning. -let Extensions_as = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( +let Extensions_as = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1012, fieldName: "as" ) -let Extensions_var = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( +let Extensions_var = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1013, fieldName: "var" ) -let Extensions_try = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( +let Extensions_try = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1014, fieldName: "try" ) -let Extensions_do = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( +let Extensions_do = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1015, fieldName: "do" ) -let Extensions_nil = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( +let Extensions_nil = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1016, fieldName: "nil" ) extension SwiftReservedTestExt2 { enum Extensions { - static let hashValue_ = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( + static let hashValue_ = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1001, fieldName: "SwiftReservedTestExt2.hashValue" ) /// Reserved words, since these end up in the "enum Extensions", they /// can't just be get their names, and sanitation kicks. - static let `as` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( + static let `as` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1022, fieldName: "SwiftReservedTestExt2.as" ) - static let `var` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( + static let `var` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1023, fieldName: "SwiftReservedTestExt2.var" ) - static let `try` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( + static let `try` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1024, fieldName: "SwiftReservedTestExt2.try" ) - static let `do` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( + static let `do` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1025, fieldName: "SwiftReservedTestExt2.do" ) - static let `nil` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( + static let `nil` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1026, fieldName: "SwiftReservedTestExt2.nil" ) @@ -349,8 +345,8 @@ extension SwiftReservedTestExt2: SwiftProtobuf.Message, SwiftProtobuf._MessageIm static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { diff --git a/Reference/unittest_swift_runtime_proto2.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_runtime_proto2.pb.swift similarity index 77% rename from Reference/unittest_swift_runtime_proto2.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_runtime_proto2.pb.swift index ec106e899..594485dc3 100644 --- a/Reference/unittest_swift_runtime_proto2.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_runtime_proto2.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_runtime_proto2.proto @@ -49,260 +50,260 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_Message2 { +struct SwiftProtoTesting_Message2: @unchecked Sendable { // 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 optionalInt32: Int32 { - get {return _storage._optionalInt32 ?? 0} + get {_storage._optionalInt32 ?? 0} set {_uniqueStorage()._optionalInt32 = newValue} } /// Returns true if `optionalInt32` has been explicitly set. - var hasOptionalInt32: Bool {return _storage._optionalInt32 != nil} + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} var optionalInt64: Int64 { - get {return _storage._optionalInt64 ?? 0} + get {_storage._optionalInt64 ?? 0} set {_uniqueStorage()._optionalInt64 = newValue} } /// Returns true if `optionalInt64` has been explicitly set. - var hasOptionalInt64: Bool {return _storage._optionalInt64 != nil} + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} var optionalUint32: UInt32 { - get {return _storage._optionalUint32 ?? 0} + get {_storage._optionalUint32 ?? 0} set {_uniqueStorage()._optionalUint32 = newValue} } /// Returns true if `optionalUint32` has been explicitly set. - var hasOptionalUint32: Bool {return _storage._optionalUint32 != nil} + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} var optionalUint64: UInt64 { - get {return _storage._optionalUint64 ?? 0} + get {_storage._optionalUint64 ?? 0} set {_uniqueStorage()._optionalUint64 = newValue} } /// Returns true if `optionalUint64` has been explicitly set. - var hasOptionalUint64: Bool {return _storage._optionalUint64 != nil} + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} var optionalSint32: Int32 { - get {return _storage._optionalSint32 ?? 0} + get {_storage._optionalSint32 ?? 0} set {_uniqueStorage()._optionalSint32 = newValue} } /// Returns true if `optionalSint32` has been explicitly set. - var hasOptionalSint32: Bool {return _storage._optionalSint32 != nil} + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} var optionalSint64: Int64 { - get {return _storage._optionalSint64 ?? 0} + get {_storage._optionalSint64 ?? 0} set {_uniqueStorage()._optionalSint64 = newValue} } /// Returns true if `optionalSint64` has been explicitly set. - var hasOptionalSint64: Bool {return _storage._optionalSint64 != nil} + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32 ?? 0} + get {_storage._optionalFixed32 ?? 0} set {_uniqueStorage()._optionalFixed32 = newValue} } /// Returns true if `optionalFixed32` has been explicitly set. - var hasOptionalFixed32: Bool {return _storage._optionalFixed32 != nil} + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64 ?? 0} + get {_storage._optionalFixed64 ?? 0} set {_uniqueStorage()._optionalFixed64 = newValue} } /// Returns true if `optionalFixed64` has been explicitly set. - var hasOptionalFixed64: Bool {return _storage._optionalFixed64 != nil} + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32 ?? 0} + get {_storage._optionalSfixed32 ?? 0} set {_uniqueStorage()._optionalSfixed32 = newValue} } /// Returns true if `optionalSfixed32` has been explicitly set. - var hasOptionalSfixed32: Bool {return _storage._optionalSfixed32 != nil} + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64 ?? 0} + get {_storage._optionalSfixed64 ?? 0} set {_uniqueStorage()._optionalSfixed64 = newValue} } /// Returns true if `optionalSfixed64` has been explicitly set. - var hasOptionalSfixed64: Bool {return _storage._optionalSfixed64 != nil} + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} var optionalFloat: Float { - get {return _storage._optionalFloat ?? 0} + get {_storage._optionalFloat ?? 0} set {_uniqueStorage()._optionalFloat = newValue} } /// Returns true if `optionalFloat` has been explicitly set. - var hasOptionalFloat: Bool {return _storage._optionalFloat != nil} + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} var optionalDouble: Double { - get {return _storage._optionalDouble ?? 0} + get {_storage._optionalDouble ?? 0} set {_uniqueStorage()._optionalDouble = newValue} } /// Returns true if `optionalDouble` has been explicitly set. - var hasOptionalDouble: Bool {return _storage._optionalDouble != nil} + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} var optionalBool: Bool { - get {return _storage._optionalBool ?? false} + get {_storage._optionalBool ?? false} set {_uniqueStorage()._optionalBool = newValue} } /// Returns true if `optionalBool` has been explicitly set. - var hasOptionalBool: Bool {return _storage._optionalBool != nil} + var hasOptionalBool: Bool {_storage._optionalBool != nil} /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} var optionalString: String { - get {return _storage._optionalString ?? String()} + get {_storage._optionalString ?? String()} set {_uniqueStorage()._optionalString = newValue} } /// Returns true if `optionalString` has been explicitly set. - var hasOptionalString: Bool {return _storage._optionalString != nil} + var hasOptionalString: Bool {_storage._optionalString != nil} /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} var optionalBytes: Data { - get {return _storage._optionalBytes ?? Data()} + get {_storage._optionalBytes ?? Data()} set {_uniqueStorage()._optionalBytes = newValue} } /// Returns true if `optionalBytes` has been explicitly set. - var hasOptionalBytes: Bool {return _storage._optionalBytes != nil} + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} - var optionalGroup: ProtobufUnittest_Message2.OptionalGroup { - get {return _storage._optionalGroup ?? ProtobufUnittest_Message2.OptionalGroup()} + var optionalGroup: SwiftProtoTesting_Message2.OptionalGroup { + get {_storage._optionalGroup ?? SwiftProtoTesting_Message2.OptionalGroup()} set {_uniqueStorage()._optionalGroup = newValue} } /// Returns true if `optionalGroup` has been explicitly set. - var hasOptionalGroup: Bool {return _storage._optionalGroup != nil} + var hasOptionalGroup: Bool {_storage._optionalGroup != nil} /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. mutating func clearOptionalGroup() {_uniqueStorage()._optionalGroup = nil} - var optionalMessage: ProtobufUnittest_Message2 { - get {return _storage._optionalMessage ?? ProtobufUnittest_Message2()} + var optionalMessage: SwiftProtoTesting_Message2 { + get {_storage._optionalMessage ?? SwiftProtoTesting_Message2()} set {_uniqueStorage()._optionalMessage = newValue} } /// Returns true if `optionalMessage` has been explicitly set. - var hasOptionalMessage: Bool {return _storage._optionalMessage != nil} + var hasOptionalMessage: Bool {_storage._optionalMessage != nil} /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalMessage() {_uniqueStorage()._optionalMessage = nil} - var optionalEnum: ProtobufUnittest_Message2.Enum { - get {return _storage._optionalEnum ?? .foo} + var optionalEnum: SwiftProtoTesting_Message2.Enum { + get {_storage._optionalEnum ?? .foo} set {_uniqueStorage()._optionalEnum = newValue} } /// Returns true if `optionalEnum` has been explicitly set. - var hasOptionalEnum: Bool {return _storage._optionalEnum != nil} + var hasOptionalEnum: Bool {_storage._optionalEnum != nil} /// Clears the value of `optionalEnum`. Subsequent reads from it will return its default value. mutating func clearOptionalEnum() {_uniqueStorage()._optionalEnum = nil} var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } - var repeatedGroup: [ProtobufUnittest_Message2.RepeatedGroup] { - get {return _storage._repeatedGroup} + var repeatedGroup: [SwiftProtoTesting_Message2.RepeatedGroup] { + get {_storage._repeatedGroup} set {_uniqueStorage()._repeatedGroup = newValue} } - var repeatedMessage: [ProtobufUnittest_Message2] { - get {return _storage._repeatedMessage} + var repeatedMessage: [SwiftProtoTesting_Message2] { + get {_storage._repeatedMessage} set {_uniqueStorage()._repeatedMessage = newValue} } - var repeatedEnum: [ProtobufUnittest_Message2.Enum] { - get {return _storage._repeatedEnum} + var repeatedEnum: [SwiftProtoTesting_Message2.Enum] { + get {_storage._repeatedEnum} set {_uniqueStorage()._repeatedEnum = newValue} } @@ -431,23 +432,23 @@ struct ProtobufUnittest_Message2 { set {_uniqueStorage()._o = .oneofBytes(newValue)} } - var oneofGroup: ProtobufUnittest_Message2.OneofGroup { + var oneofGroup: SwiftProtoTesting_Message2.OneofGroup { get { if case .oneofGroup(let v)? = _storage._o {return v} - return ProtobufUnittest_Message2.OneofGroup() + return SwiftProtoTesting_Message2.OneofGroup() } set {_uniqueStorage()._o = .oneofGroup(newValue)} } - var oneofMessage: ProtobufUnittest_Message2 { + var oneofMessage: SwiftProtoTesting_Message2 { get { if case .oneofMessage(let v)? = _storage._o {return v} - return ProtobufUnittest_Message2() + return SwiftProtoTesting_Message2() } set {_uniqueStorage()._o = .oneofMessage(newValue)} } - var oneofEnum: ProtobufUnittest_Message2.Enum { + var oneofEnum: SwiftProtoTesting_Message2.Enum { get { if case .oneofEnum(let v)? = _storage._o {return v} return .baz @@ -457,103 +458,103 @@ struct ProtobufUnittest_Message2 { /// Some token map cases, too many combinations to list them all. var mapInt32Int32: Dictionary { - get {return _storage._mapInt32Int32} + get {_storage._mapInt32Int32} set {_uniqueStorage()._mapInt32Int32 = newValue} } var mapInt64Int64: Dictionary { - get {return _storage._mapInt64Int64} + get {_storage._mapInt64Int64} set {_uniqueStorage()._mapInt64Int64 = newValue} } var mapUint32Uint32: Dictionary { - get {return _storage._mapUint32Uint32} + get {_storage._mapUint32Uint32} set {_uniqueStorage()._mapUint32Uint32 = newValue} } var mapUint64Uint64: Dictionary { - get {return _storage._mapUint64Uint64} + get {_storage._mapUint64Uint64} set {_uniqueStorage()._mapUint64Uint64 = newValue} } var mapSint32Sint32: Dictionary { - get {return _storage._mapSint32Sint32} + get {_storage._mapSint32Sint32} set {_uniqueStorage()._mapSint32Sint32 = newValue} } var mapSint64Sint64: Dictionary { - get {return _storage._mapSint64Sint64} + get {_storage._mapSint64Sint64} set {_uniqueStorage()._mapSint64Sint64 = newValue} } var mapFixed32Fixed32: Dictionary { - get {return _storage._mapFixed32Fixed32} + get {_storage._mapFixed32Fixed32} set {_uniqueStorage()._mapFixed32Fixed32 = newValue} } var mapFixed64Fixed64: Dictionary { - get {return _storage._mapFixed64Fixed64} + get {_storage._mapFixed64Fixed64} set {_uniqueStorage()._mapFixed64Fixed64 = newValue} } var mapSfixed32Sfixed32: Dictionary { - get {return _storage._mapSfixed32Sfixed32} + get {_storage._mapSfixed32Sfixed32} set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} } var mapSfixed64Sfixed64: Dictionary { - get {return _storage._mapSfixed64Sfixed64} + get {_storage._mapSfixed64Sfixed64} set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} } var mapInt32Float: Dictionary { - get {return _storage._mapInt32Float} + get {_storage._mapInt32Float} set {_uniqueStorage()._mapInt32Float = newValue} } var mapInt32Double: Dictionary { - get {return _storage._mapInt32Double} + get {_storage._mapInt32Double} set {_uniqueStorage()._mapInt32Double = newValue} } var mapBoolBool: Dictionary { - get {return _storage._mapBoolBool} + get {_storage._mapBoolBool} set {_uniqueStorage()._mapBoolBool = newValue} } var mapStringString: Dictionary { - get {return _storage._mapStringString} + get {_storage._mapStringString} set {_uniqueStorage()._mapStringString = newValue} } var mapStringBytes: Dictionary { - get {return _storage._mapStringBytes} + get {_storage._mapStringBytes} set {_uniqueStorage()._mapStringBytes = newValue} } - var mapStringMessage: Dictionary { - get {return _storage._mapStringMessage} + var mapStringMessage: Dictionary { + get {_storage._mapStringMessage} set {_uniqueStorage()._mapStringMessage = newValue} } var mapInt32Bytes: Dictionary { - get {return _storage._mapInt32Bytes} + get {_storage._mapInt32Bytes} set {_uniqueStorage()._mapInt32Bytes = newValue} } - var mapInt32Enum: Dictionary { - get {return _storage._mapInt32Enum} + var mapInt32Enum: Dictionary { + get {_storage._mapInt32Enum} set {_uniqueStorage()._mapInt32Enum = newValue} } - var mapInt32Message: Dictionary { - get {return _storage._mapInt32Message} + var mapInt32Message: Dictionary { + get {_storage._mapInt32Message} set {_uniqueStorage()._mapInt32Message = newValue} } var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_O: Equatable { + enum OneOf_O: Equatable, Sendable { case oneofInt32(Int32) case oneofInt64(Int64) case oneofUint32(UInt32) @@ -569,137 +570,35 @@ struct ProtobufUnittest_Message2 { case oneofBool(Bool) case oneofString(String) case oneofBytes(Data) - case oneofGroup(ProtobufUnittest_Message2.OneofGroup) - case oneofMessage(ProtobufUnittest_Message2) - case oneofEnum(ProtobufUnittest_Message2.Enum) + case oneofGroup(SwiftProtoTesting_Message2.OneofGroup) + case oneofMessage(SwiftProtoTesting_Message2) + case oneofEnum(SwiftProtoTesting_Message2.Enum) - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_Message2.OneOf_O, rhs: ProtobufUnittest_Message2.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 (.oneofInt32, .oneofInt32): return { - guard case .oneofInt32(let l) = lhs, case .oneofInt32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofInt64, .oneofInt64): return { - guard case .oneofInt64(let l) = lhs, case .oneofInt64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint64, .oneofUint64): return { - guard case .oneofUint64(let l) = lhs, case .oneofUint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSint32, .oneofSint32): return { - guard case .oneofSint32(let l) = lhs, case .oneofSint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSint64, .oneofSint64): return { - guard case .oneofSint64(let l) = lhs, case .oneofSint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFixed32, .oneofFixed32): return { - guard case .oneofFixed32(let l) = lhs, case .oneofFixed32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFixed64, .oneofFixed64): return { - guard case .oneofFixed64(let l) = lhs, case .oneofFixed64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSfixed32, .oneofSfixed32): return { - guard case .oneofSfixed32(let l) = lhs, case .oneofSfixed32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSfixed64, .oneofSfixed64): return { - guard case .oneofSfixed64(let l) = lhs, case .oneofSfixed64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFloat, .oneofFloat): return { - guard case .oneofFloat(let l) = lhs, case .oneofFloat(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofDouble, .oneofDouble): return { - guard case .oneofDouble(let l) = lhs, case .oneofDouble(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBool, .oneofBool): return { - guard case .oneofBool(let l) = lhs, case .oneofBool(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofGroup, .oneofGroup): return { - guard case .oneofGroup(let l) = lhs, case .oneofGroup(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofMessage, .oneofMessage): return { - guard case .oneofMessage(let l) = lhs, case .oneofMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofEnum, .oneofEnum): return { - guard case .oneofEnum(let l) = lhs, case .oneofEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 0 - case bar // = 1 - case baz // = 2 - case extra2 // = 20 + enum Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 + case extra2 = 20 init() { self = .foo } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .foo - case 1: self = .bar - case 2: self = .baz - case 20: self = .extra2 - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo: return 0 - case .bar: return 1 - case .baz: return 2 - case .extra2: return 20 - } - } - } - struct OptionalGroup { + struct OptionalGroup: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -710,17 +609,17 @@ struct ProtobufUnittest_Message2 { fileprivate var _a: Int32? = nil } - struct RepeatedGroup { + struct RepeatedGroup: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -731,26 +630,26 @@ struct ProtobufUnittest_Message2 { fileprivate var _a: Int32? = nil } - struct OneofGroup { + struct OneofGroup: Sendable { // 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 a: Int32 { - get {return _a ?? 116} + get {_a ?? 116} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} var b: Int32 { - get {return _b ?? 0} + get {_b ?? 0} set {_b = newValue} } /// Returns true if `b` has been explicitly set. - var hasB: Bool {return self._b != nil} + var hasB: Bool {self._b != nil} /// Clears the value of `b`. Subsequent reads from it will return its default value. mutating func clearB() {self._b = nil} @@ -767,15 +666,7 @@ struct ProtobufUnittest_Message2 { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension ProtobufUnittest_Message2.Enum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_Msg2NoStorage { +struct SwiftProtoTesting_Msg2NoStorage: Sendable { // 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. @@ -785,18 +676,18 @@ struct ProtobufUnittest_Msg2NoStorage { init() {} } -struct ProtobufUnittest_Msg2UsesStorage { +struct SwiftProtoTesting_Msg2UsesStorage: @unchecked Sendable { // 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. /// Recursive class (i.e. - can build a graph), forces _StorageClass. - var y: ProtobufUnittest_Msg2UsesStorage { - get {return _storage._y ?? ProtobufUnittest_Msg2UsesStorage()} + var y: SwiftProtoTesting_Msg2UsesStorage { + get {_storage._y ?? SwiftProtoTesting_Msg2UsesStorage()} set {_uniqueStorage()._y = newValue} } /// Returns true if `y` has been explicitly set. - var hasY: Bool {return _storage._y != nil} + var hasY: Bool {_storage._y != nil} /// Clears the value of `y`. Subsequent reads from it will return its default value. mutating func clearY() {_uniqueStorage()._y = nil} @@ -808,35 +699,35 @@ struct ProtobufUnittest_Msg2UsesStorage { } /// Names that match protocols - No Storage -struct ProtobufUnittest_Msg2NamesNoStorage { +struct SwiftProtoTesting_Msg2NamesNoStorage: Sendable { // 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 isInitialized_p: Int32 { - get {return _isInitialized_p ?? 0} + get {_isInitialized_p ?? 0} set {_isInitialized_p = newValue} } /// Returns true if `isInitialized_p` has been explicitly set. - var hasIsInitialized_p: Bool {return self._isInitialized_p != nil} + var hasIsInitialized_p: Bool {self._isInitialized_p != nil} /// Clears the value of `isInitialized_p`. Subsequent reads from it will return its default value. mutating func clearIsInitialized_p() {self._isInitialized_p = nil} var debugDescription_p: Int32 { - get {return _debugDescription_p ?? 0} + get {_debugDescription_p ?? 0} set {_debugDescription_p = newValue} } /// Returns true if `debugDescription_p` has been explicitly set. - var hasDebugDescription_p: Bool {return self._debugDescription_p != nil} + var hasDebugDescription_p: Bool {self._debugDescription_p != nil} /// Clears the value of `debugDescription_p`. Subsequent reads from it will return its default value. mutating func clearDebugDescription_p() {self._debugDescription_p = nil} var value: Int32 { - get {return _value ?? 0} + get {_value ?? 0} set {_value = newValue} } /// Returns true if `value` has been explicitly set. - var hasValue: Bool {return self._value != nil} + var hasValue: Bool {self._value != nil} /// Clears the value of `value`. Subsequent reads from it will return its default value. mutating func clearValue() {self._value = nil} @@ -850,36 +741,36 @@ struct ProtobufUnittest_Msg2NamesNoStorage { } /// Names that match protocols - Storage -struct ProtobufUnittest_Msg2NamesUsesStorage { +struct SwiftProtoTesting_Msg2NamesUsesStorage: Sendable { // 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 isInitialized_p: Int32 { - get {return _isInitialized_p ?? 0} + get {_isInitialized_p ?? 0} set {_isInitialized_p = newValue} } /// Returns true if `isInitialized_p` has been explicitly set. - var hasIsInitialized_p: Bool {return self._isInitialized_p != nil} + var hasIsInitialized_p: Bool {self._isInitialized_p != nil} /// Clears the value of `isInitialized_p`. Subsequent reads from it will return its default value. mutating func clearIsInitialized_p() {self._isInitialized_p = nil} var debugDescription_p: Int32 { - get {return _debugDescription_p ?? 0} + get {_debugDescription_p ?? 0} set {_debugDescription_p = newValue} } /// Returns true if `debugDescription_p` has been explicitly set. - var hasDebugDescription_p: Bool {return self._debugDescription_p != nil} + var hasDebugDescription_p: Bool {self._debugDescription_p != nil} /// Clears the value of `debugDescription_p`. Subsequent reads from it will return its default value. mutating func clearDebugDescription_p() {self._debugDescription_p = nil} /// Recursive class, forces _StorageClass - var value: ProtobufUnittest_Msg2UsesStorage { - get {return _value ?? ProtobufUnittest_Msg2UsesStorage()} + var value: SwiftProtoTesting_Msg2UsesStorage { + get {_value ?? SwiftProtoTesting_Msg2UsesStorage()} set {_value = newValue} } /// Returns true if `value` has been explicitly set. - var hasValue: Bool {return self._value != nil} + var hasValue: Bool {self._value != nil} /// Clears the value of `value`. Subsequent reads from it will return its default value. mutating func clearValue() {self._value = nil} @@ -889,103 +780,16 @@ struct ProtobufUnittest_Msg2NamesUsesStorage { fileprivate var _isInitialized_p: Int32? = nil fileprivate var _debugDescription_p: Int32? = nil - fileprivate var _value: ProtobufUnittest_Msg2UsesStorage? = nil + fileprivate var _value: SwiftProtoTesting_Msg2UsesStorage? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_Message2: @unchecked Sendable {} -extension ProtobufUnittest_Message2.OneOf_O: @unchecked Sendable {} -extension ProtobufUnittest_Message2.Enum: @unchecked Sendable {} -extension ProtobufUnittest_Message2.OptionalGroup: @unchecked Sendable {} -extension ProtobufUnittest_Message2.RepeatedGroup: @unchecked Sendable {} -extension ProtobufUnittest_Message2.OneofGroup: @unchecked Sendable {} -extension ProtobufUnittest_Msg2NoStorage: @unchecked Sendable {} -extension ProtobufUnittest_Msg2UsesStorage: @unchecked Sendable {} -extension ProtobufUnittest_Msg2NamesNoStorage: @unchecked Sendable {} -extension ProtobufUnittest_Msg2NamesUsesStorage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Message2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Message2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 16: .unique(proto: "OptionalGroup", json: "optionalgroup"), - 18: .standard(proto: "optional_message"), - 19: .standard(proto: "optional_enum"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 46: .unique(proto: "RepeatedGroup", json: "repeatedgroup"), - 48: .standard(proto: "repeated_message"), - 49: .standard(proto: "repeated_enum"), - 51: .standard(proto: "oneof_int32"), - 52: .standard(proto: "oneof_int64"), - 53: .standard(proto: "oneof_uint32"), - 54: .standard(proto: "oneof_uint64"), - 55: .standard(proto: "oneof_sint32"), - 56: .standard(proto: "oneof_sint64"), - 57: .standard(proto: "oneof_fixed32"), - 58: .standard(proto: "oneof_fixed64"), - 59: .standard(proto: "oneof_sfixed32"), - 60: .standard(proto: "oneof_sfixed64"), - 61: .standard(proto: "oneof_float"), - 62: .standard(proto: "oneof_double"), - 63: .standard(proto: "oneof_bool"), - 64: .standard(proto: "oneof_string"), - 65: .standard(proto: "oneof_bytes"), - 66: .unique(proto: "OneofGroup", json: "oneofgroup"), - 68: .standard(proto: "oneof_message"), - 69: .standard(proto: "oneof_enum"), - 70: .standard(proto: "map_int32_int32"), - 71: .standard(proto: "map_int64_int64"), - 72: .standard(proto: "map_uint32_uint32"), - 73: .standard(proto: "map_uint64_uint64"), - 74: .standard(proto: "map_sint32_sint32"), - 75: .standard(proto: "map_sint64_sint64"), - 76: .standard(proto: "map_fixed32_fixed32"), - 77: .standard(proto: "map_fixed64_fixed64"), - 78: .standard(proto: "map_sfixed32_sfixed32"), - 79: .standard(proto: "map_sfixed64_sfixed64"), - 80: .standard(proto: "map_int32_float"), - 81: .standard(proto: "map_int32_double"), - 82: .standard(proto: "map_bool_bool"), - 83: .standard(proto: "map_string_string"), - 84: .standard(proto: "map_string_bytes"), - 85: .standard(proto: "map_string_message"), - 86: .standard(proto: "map_int32_bytes"), - 87: .standard(proto: "map_int32_enum"), - 88: .standard(proto: "map_int32_message"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{7}OptionalGroup\0\u{4}\u{2}optional_message\0\u{3}optional_enum\0\u{4}\u{c}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{7}RepeatedGroup\0\u{4}\u{2}repeated_message\0\u{3}repeated_enum\0\u{4}\u{2}oneof_int32\0\u{3}oneof_int64\0\u{3}oneof_uint32\0\u{3}oneof_uint64\0\u{3}oneof_sint32\0\u{3}oneof_sint64\0\u{3}oneof_fixed32\0\u{3}oneof_fixed64\0\u{3}oneof_sfixed32\0\u{3}oneof_sfixed64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_bool\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{7}OneofGroup\0\u{4}\u{2}oneof_message\0\u{3}oneof_enum\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_message\0\u{3}map_int32_bytes\0\u{3}map_int32_enum\0\u{3}map_int32_message\0") fileprivate class _StorageClass { var _optionalInt32: Int32? = nil @@ -1003,9 +807,9 @@ extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._Messa var _optionalBool: Bool? = nil var _optionalString: String? = nil var _optionalBytes: Data? = nil - var _optionalGroup: ProtobufUnittest_Message2.OptionalGroup? = nil - var _optionalMessage: ProtobufUnittest_Message2? = nil - var _optionalEnum: ProtobufUnittest_Message2.Enum? = nil + var _optionalGroup: SwiftProtoTesting_Message2.OptionalGroup? = nil + var _optionalMessage: SwiftProtoTesting_Message2? = nil + var _optionalEnum: SwiftProtoTesting_Message2.Enum? = nil var _repeatedInt32: [Int32] = [] var _repeatedInt64: [Int64] = [] var _repeatedUint32: [UInt32] = [] @@ -1021,10 +825,10 @@ extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._Messa var _repeatedBool: [Bool] = [] var _repeatedString: [String] = [] var _repeatedBytes: [Data] = [] - var _repeatedGroup: [ProtobufUnittest_Message2.RepeatedGroup] = [] - var _repeatedMessage: [ProtobufUnittest_Message2] = [] - var _repeatedEnum: [ProtobufUnittest_Message2.Enum] = [] - var _o: ProtobufUnittest_Message2.OneOf_O? + var _repeatedGroup: [SwiftProtoTesting_Message2.RepeatedGroup] = [] + var _repeatedMessage: [SwiftProtoTesting_Message2] = [] + var _repeatedEnum: [SwiftProtoTesting_Message2.Enum] = [] + var _o: SwiftProtoTesting_Message2.OneOf_O? var _mapInt32Int32: Dictionary = [:] var _mapInt64Int64: Dictionary = [:] var _mapUint32Uint32: Dictionary = [:] @@ -1040,12 +844,16 @@ extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._Messa var _mapBoolBool: Dictionary = [:] var _mapStringString: Dictionary = [:] var _mapStringBytes: Dictionary = [:] - var _mapStringMessage: Dictionary = [:] + var _mapStringMessage: Dictionary = [:] var _mapInt32Bytes: Dictionary = [:] - var _mapInt32Enum: Dictionary = [:] - var _mapInt32Message: Dictionary = [:] + var _mapInt32Enum: Dictionary = [:] + var _mapInt32Message: Dictionary = [:] - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1281,7 +1089,7 @@ extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._Messa } }() case 66: try { - var v: ProtobufUnittest_Message2.OneofGroup? + var v: SwiftProtoTesting_Message2.OneofGroup? var hadOneofValue = false if let current = _storage._o { hadOneofValue = true @@ -1294,7 +1102,7 @@ extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._Messa } }() case 68: try { - var v: ProtobufUnittest_Message2? + var v: SwiftProtoTesting_Message2? var hadOneofValue = false if let current = _storage._o { hadOneofValue = true @@ -1307,7 +1115,7 @@ extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._Messa } }() case 69: try { - var v: ProtobufUnittest_Message2.Enum? + var v: SwiftProtoTesting_Message2.Enum? try decoder.decodeSingularEnumField(value: &v) if let v = v { if _storage._o != nil {try decoder.handleConflictingOneOf()} @@ -1329,10 +1137,10 @@ extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._Messa case 82: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() case 83: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() case 84: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() - case 85: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringMessage) }() + case 85: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringMessage) }() case 86: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bytes) }() - case 87: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() - case 88: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32Message) }() + case 87: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() + case 88: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32Message) }() default: break } } @@ -1574,22 +1382,22 @@ extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._Messa try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 84) } if !_storage._mapStringMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringMessage, fieldNumber: 85) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringMessage, fieldNumber: 85) } if !_storage._mapInt32Bytes.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bytes, fieldNumber: 86) } if !_storage._mapInt32Enum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 87) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 87) } if !_storage._mapInt32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32Message, fieldNumber: 88) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32Message, fieldNumber: 88) } } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Message2, rhs: ProtobufUnittest_Message2) -> Bool { + static func ==(lhs: SwiftProtoTesting_Message2, rhs: SwiftProtoTesting_Message2) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -1659,20 +1467,13 @@ extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._Messa } } -extension ProtobufUnittest_Message2.Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - 20: .same(proto: "EXTRA_2"), - ] +extension SwiftProtoTesting_Message2.Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOO\0\u{1}BAR\0\u{1}BAZ\0\u{2}\u{12}EXTRA_2\0") } -extension ProtobufUnittest_Message2.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_Message2.protoMessageName + ".OptionalGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 17: .same(proto: "a"), - ] +extension SwiftProtoTesting_Message2.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Message2.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{11}a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1697,18 +1498,16 @@ extension ProtobufUnittest_Message2.OptionalGroup: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Message2.OptionalGroup, rhs: ProtobufUnittest_Message2.OptionalGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_Message2.OptionalGroup, rhs: SwiftProtoTesting_Message2.OptionalGroup) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Message2.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_Message2.protoMessageName + ".RepeatedGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 47: .same(proto: "a"), - ] +extension SwiftProtoTesting_Message2.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Message2.protoMessageName + ".RepeatedGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}/a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1733,19 +1532,16 @@ extension ProtobufUnittest_Message2.RepeatedGroup: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Message2.RepeatedGroup, rhs: ProtobufUnittest_Message2.RepeatedGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_Message2.RepeatedGroup, rhs: SwiftProtoTesting_Message2.RepeatedGroup) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Message2.OneofGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_Message2.protoMessageName + ".OneofGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 67: .same(proto: "a"), - 167: .same(proto: "b"), - ] +extension SwiftProtoTesting_Message2.OneofGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Message2.protoMessageName + ".OneofGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}C\u{1}a\0\u{2}d\u{1}b\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1774,7 +1570,7 @@ extension ProtobufUnittest_Message2.OneofGroup: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Message2.OneofGroup, rhs: ProtobufUnittest_Message2.OneofGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_Message2.OneofGroup, rhs: SwiftProtoTesting_Message2.OneofGroup) -> Bool { if lhs._a != rhs._a {return false} if lhs._b != rhs._b {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -1782,35 +1578,37 @@ extension ProtobufUnittest_Message2.OneofGroup: SwiftProtobuf.Message, SwiftProt } } -extension ProtobufUnittest_Msg2NoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Msg2NoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg2NoStorage" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Msg2NoStorage, rhs: ProtobufUnittest_Msg2NoStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Msg2NoStorage, rhs: SwiftProtoTesting_Msg2NoStorage) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Msg2UsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Msg2UsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg2UsesStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 999: .same(proto: "y"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}g\u{f}y\0") fileprivate class _StorageClass { - var _y: ProtobufUnittest_Msg2UsesStorage? = nil + var _y: SwiftProtoTesting_Msg2UsesStorage? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1854,7 +1652,7 @@ extension ProtobufUnittest_Msg2UsesStorage: SwiftProtobuf.Message, SwiftProtobuf try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Msg2UsesStorage, rhs: ProtobufUnittest_Msg2UsesStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Msg2UsesStorage, rhs: SwiftProtoTesting_Msg2UsesStorage) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -1869,13 +1667,9 @@ extension ProtobufUnittest_Msg2UsesStorage: SwiftProtobuf.Message, SwiftProtobuf } } -extension ProtobufUnittest_Msg2NamesNoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Msg2NamesNoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg2NamesNoStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "is_initialized"), - 2: .standard(proto: "debug_description"), - 3: .same(proto: "value"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}is_initialized\0\u{3}debug_description\0\u{1}value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1908,7 +1702,7 @@ extension ProtobufUnittest_Msg2NamesNoStorage: SwiftProtobuf.Message, SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Msg2NamesNoStorage, rhs: ProtobufUnittest_Msg2NamesNoStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Msg2NamesNoStorage, rhs: SwiftProtoTesting_Msg2NamesNoStorage) -> Bool { if lhs._isInitialized_p != rhs._isInitialized_p {return false} if lhs._debugDescription_p != rhs._debugDescription_p {return false} if lhs._value != rhs._value {return false} @@ -1917,13 +1711,9 @@ extension ProtobufUnittest_Msg2NamesNoStorage: SwiftProtobuf.Message, SwiftProto } } -extension ProtobufUnittest_Msg2NamesUsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Msg2NamesUsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg2NamesUsesStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "is_initialized"), - 2: .standard(proto: "debug_description"), - 3: .same(proto: "value"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}is_initialized\0\u{3}debug_description\0\u{1}value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1956,7 +1746,7 @@ extension ProtobufUnittest_Msg2NamesUsesStorage: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Msg2NamesUsesStorage, rhs: ProtobufUnittest_Msg2NamesUsesStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Msg2NamesUsesStorage, rhs: SwiftProtoTesting_Msg2NamesUsesStorage) -> Bool { if lhs._isInitialized_p != rhs._isInitialized_p {return false} if lhs._debugDescription_p != rhs._debugDescription_p {return false} if lhs._value != rhs._value {return false} diff --git a/Reference/unittest_swift_runtime_proto3.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_swift_runtime_proto3.pb.swift similarity index 78% rename from Reference/unittest_swift_runtime_proto3.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_swift_runtime_proto3.pb.swift index d74d4f39d..6650886e2 100644 --- a/Reference/unittest_swift_runtime_proto3.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_swift_runtime_proto3.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_runtime_proto3.proto @@ -49,184 +50,184 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_Message3 { +struct SwiftProtoTesting_Message3: @unchecked Sendable { // 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 optionalInt32: Int32 { - get {return _storage._optionalInt32} + get {_storage._optionalInt32} set {_uniqueStorage()._optionalInt32 = newValue} } var optionalInt64: Int64 { - get {return _storage._optionalInt64} + get {_storage._optionalInt64} set {_uniqueStorage()._optionalInt64 = newValue} } var optionalUint32: UInt32 { - get {return _storage._optionalUint32} + get {_storage._optionalUint32} set {_uniqueStorage()._optionalUint32 = newValue} } var optionalUint64: UInt64 { - get {return _storage._optionalUint64} + get {_storage._optionalUint64} set {_uniqueStorage()._optionalUint64 = newValue} } var optionalSint32: Int32 { - get {return _storage._optionalSint32} + get {_storage._optionalSint32} set {_uniqueStorage()._optionalSint32 = newValue} } var optionalSint64: Int64 { - get {return _storage._optionalSint64} + get {_storage._optionalSint64} set {_uniqueStorage()._optionalSint64 = newValue} } var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32} + get {_storage._optionalFixed32} set {_uniqueStorage()._optionalFixed32 = newValue} } var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64} + get {_storage._optionalFixed64} set {_uniqueStorage()._optionalFixed64 = newValue} } var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32} + get {_storage._optionalSfixed32} set {_uniqueStorage()._optionalSfixed32 = newValue} } var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64} + get {_storage._optionalSfixed64} set {_uniqueStorage()._optionalSfixed64 = newValue} } var optionalFloat: Float { - get {return _storage._optionalFloat} + get {_storage._optionalFloat} set {_uniqueStorage()._optionalFloat = newValue} } var optionalDouble: Double { - get {return _storage._optionalDouble} + get {_storage._optionalDouble} set {_uniqueStorage()._optionalDouble = newValue} } var optionalBool: Bool { - get {return _storage._optionalBool} + get {_storage._optionalBool} set {_uniqueStorage()._optionalBool = newValue} } var optionalString: String { - get {return _storage._optionalString} + get {_storage._optionalString} set {_uniqueStorage()._optionalString = newValue} } var optionalBytes: Data { - get {return _storage._optionalBytes} + get {_storage._optionalBytes} set {_uniqueStorage()._optionalBytes = newValue} } /// No 'group' in proto3. - var optionalMessage: ProtobufUnittest_Message3 { - get {return _storage._optionalMessage ?? ProtobufUnittest_Message3()} + var optionalMessage: SwiftProtoTesting_Message3 { + get {_storage._optionalMessage ?? SwiftProtoTesting_Message3()} set {_uniqueStorage()._optionalMessage = newValue} } /// Returns true if `optionalMessage` has been explicitly set. - var hasOptionalMessage: Bool {return _storage._optionalMessage != nil} + var hasOptionalMessage: Bool {_storage._optionalMessage != nil} /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalMessage() {_uniqueStorage()._optionalMessage = nil} - var optionalEnum: ProtobufUnittest_Message3.Enum { - get {return _storage._optionalEnum} + var optionalEnum: SwiftProtoTesting_Message3.Enum { + get {_storage._optionalEnum} set {_uniqueStorage()._optionalEnum = newValue} } var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } /// No 'group' in proto3. - var repeatedMessage: [ProtobufUnittest_Message3] { - get {return _storage._repeatedMessage} + var repeatedMessage: [SwiftProtoTesting_Message3] { + get {_storage._repeatedMessage} set {_uniqueStorage()._repeatedMessage = newValue} } - var repeatedEnum: [ProtobufUnittest_Message3.Enum] { - get {return _storage._repeatedEnum} + var repeatedEnum: [SwiftProtoTesting_Message3.Enum] { + get {_storage._repeatedEnum} set {_uniqueStorage()._repeatedEnum = newValue} } @@ -356,15 +357,15 @@ struct ProtobufUnittest_Message3 { } /// No 'group' in proto3. - var oneofMessage: ProtobufUnittest_Message3 { + var oneofMessage: SwiftProtoTesting_Message3 { get { if case .oneofMessage(let v)? = _storage._o {return v} - return ProtobufUnittest_Message3() + return SwiftProtoTesting_Message3() } set {_uniqueStorage()._o = .oneofMessage(newValue)} } - var oneofEnum: ProtobufUnittest_Message3.Enum { + var oneofEnum: SwiftProtoTesting_Message3.Enum { get { if case .oneofEnum(let v)? = _storage._o {return v} return .foo @@ -374,103 +375,103 @@ struct ProtobufUnittest_Message3 { /// Some token map cases, too many combinations to list them all. var mapInt32Int32: Dictionary { - get {return _storage._mapInt32Int32} + get {_storage._mapInt32Int32} set {_uniqueStorage()._mapInt32Int32 = newValue} } var mapInt64Int64: Dictionary { - get {return _storage._mapInt64Int64} + get {_storage._mapInt64Int64} set {_uniqueStorage()._mapInt64Int64 = newValue} } var mapUint32Uint32: Dictionary { - get {return _storage._mapUint32Uint32} + get {_storage._mapUint32Uint32} set {_uniqueStorage()._mapUint32Uint32 = newValue} } var mapUint64Uint64: Dictionary { - get {return _storage._mapUint64Uint64} + get {_storage._mapUint64Uint64} set {_uniqueStorage()._mapUint64Uint64 = newValue} } var mapSint32Sint32: Dictionary { - get {return _storage._mapSint32Sint32} + get {_storage._mapSint32Sint32} set {_uniqueStorage()._mapSint32Sint32 = newValue} } var mapSint64Sint64: Dictionary { - get {return _storage._mapSint64Sint64} + get {_storage._mapSint64Sint64} set {_uniqueStorage()._mapSint64Sint64 = newValue} } var mapFixed32Fixed32: Dictionary { - get {return _storage._mapFixed32Fixed32} + get {_storage._mapFixed32Fixed32} set {_uniqueStorage()._mapFixed32Fixed32 = newValue} } var mapFixed64Fixed64: Dictionary { - get {return _storage._mapFixed64Fixed64} + get {_storage._mapFixed64Fixed64} set {_uniqueStorage()._mapFixed64Fixed64 = newValue} } var mapSfixed32Sfixed32: Dictionary { - get {return _storage._mapSfixed32Sfixed32} + get {_storage._mapSfixed32Sfixed32} set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} } var mapSfixed64Sfixed64: Dictionary { - get {return _storage._mapSfixed64Sfixed64} + get {_storage._mapSfixed64Sfixed64} set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} } var mapInt32Float: Dictionary { - get {return _storage._mapInt32Float} + get {_storage._mapInt32Float} set {_uniqueStorage()._mapInt32Float = newValue} } var mapInt32Double: Dictionary { - get {return _storage._mapInt32Double} + get {_storage._mapInt32Double} set {_uniqueStorage()._mapInt32Double = newValue} } var mapBoolBool: Dictionary { - get {return _storage._mapBoolBool} + get {_storage._mapBoolBool} set {_uniqueStorage()._mapBoolBool = newValue} } var mapStringString: Dictionary { - get {return _storage._mapStringString} + get {_storage._mapStringString} set {_uniqueStorage()._mapStringString = newValue} } var mapStringBytes: Dictionary { - get {return _storage._mapStringBytes} + get {_storage._mapStringBytes} set {_uniqueStorage()._mapStringBytes = newValue} } - var mapStringMessage: Dictionary { - get {return _storage._mapStringMessage} + var mapStringMessage: Dictionary { + get {_storage._mapStringMessage} set {_uniqueStorage()._mapStringMessage = newValue} } var mapInt32Bytes: Dictionary { - get {return _storage._mapInt32Bytes} + get {_storage._mapInt32Bytes} set {_uniqueStorage()._mapInt32Bytes = newValue} } - var mapInt32Enum: Dictionary { - get {return _storage._mapInt32Enum} + var mapInt32Enum: Dictionary { + get {_storage._mapInt32Enum} set {_uniqueStorage()._mapInt32Enum = newValue} } - var mapInt32Message: Dictionary { - get {return _storage._mapInt32Message} + var mapInt32Message: Dictionary { + get {_storage._mapInt32Message} set {_uniqueStorage()._mapInt32Message = newValue} } var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_O: Equatable { + enum OneOf_O: Equatable, Sendable { case oneofInt32(Int32) case oneofInt64(Int64) case oneofUint32(UInt32) @@ -487,90 +488,12 @@ struct ProtobufUnittest_Message3 { case oneofString(String) case oneofBytes(Data) /// No 'group' in proto3. - case oneofMessage(ProtobufUnittest_Message3) - case oneofEnum(ProtobufUnittest_Message3.Enum) + case oneofMessage(SwiftProtoTesting_Message3) + case oneofEnum(SwiftProtoTesting_Message3.Enum) - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_Message3.OneOf_O, rhs: ProtobufUnittest_Message3.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 (.oneofInt32, .oneofInt32): return { - guard case .oneofInt32(let l) = lhs, case .oneofInt32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofInt64, .oneofInt64): return { - guard case .oneofInt64(let l) = lhs, case .oneofInt64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint64, .oneofUint64): return { - guard case .oneofUint64(let l) = lhs, case .oneofUint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSint32, .oneofSint32): return { - guard case .oneofSint32(let l) = lhs, case .oneofSint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSint64, .oneofSint64): return { - guard case .oneofSint64(let l) = lhs, case .oneofSint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFixed32, .oneofFixed32): return { - guard case .oneofFixed32(let l) = lhs, case .oneofFixed32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFixed64, .oneofFixed64): return { - guard case .oneofFixed64(let l) = lhs, case .oneofFixed64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSfixed32, .oneofSfixed32): return { - guard case .oneofSfixed32(let l) = lhs, case .oneofSfixed32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSfixed64, .oneofSfixed64): return { - guard case .oneofSfixed64(let l) = lhs, case .oneofSfixed64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFloat, .oneofFloat): return { - guard case .oneofFloat(let l) = lhs, case .oneofFloat(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofDouble, .oneofDouble): return { - guard case .oneofDouble(let l) = lhs, case .oneofDouble(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBool, .oneofBool): return { - guard case .oneofBool(let l) = lhs, case .oneofBool(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofMessage, .oneofMessage): return { - guard case .oneofMessage(let l) = lhs, case .oneofMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofEnum, .oneofEnum): return { - guard case .oneofEnum(let l) = lhs, case .oneofEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum Enum: SwiftProtobuf.Enum { + enum Enum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foo // = 0 case bar // = 1 @@ -602,6 +525,14 @@ struct ProtobufUnittest_Message3 { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Message3.Enum] = [ + .foo, + .bar, + .baz, + .extra3, + ] + } init() {} @@ -609,21 +540,7 @@ struct ProtobufUnittest_Message3 { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension ProtobufUnittest_Message3.Enum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittest_Message3.Enum] = [ - .foo, - .bar, - .baz, - .extra3, - ] -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_Msg3NoStorage { +struct SwiftProtoTesting_Msg3NoStorage: Sendable { // 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. @@ -633,18 +550,18 @@ struct ProtobufUnittest_Msg3NoStorage { init() {} } -struct ProtobufUnittest_Msg3UsesStorage { +struct SwiftProtoTesting_Msg3UsesStorage: @unchecked Sendable { // 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. /// Recursive class (i.e. - can build a graph), forces _StorageClass. - var y: ProtobufUnittest_Msg3UsesStorage { - get {return _storage._y ?? ProtobufUnittest_Msg3UsesStorage()} + var y: SwiftProtoTesting_Msg3UsesStorage { + get {_storage._y ?? SwiftProtoTesting_Msg3UsesStorage()} set {_uniqueStorage()._y = newValue} } /// Returns true if `y` has been explicitly set. - var hasY: Bool {return _storage._y != nil} + var hasY: Bool {_storage._y != nil} /// Clears the value of `y`. Subsequent reads from it will return its default value. mutating func clearY() {_uniqueStorage()._y = nil} @@ -656,7 +573,7 @@ struct ProtobufUnittest_Msg3UsesStorage { } /// Names that match protocols - No Storage -struct ProtobufUnittest_Msg3NamesNoStorage { +struct SwiftProtoTesting_Msg3NamesNoStorage: Sendable { // 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. @@ -673,7 +590,7 @@ struct ProtobufUnittest_Msg3NamesNoStorage { } /// Names that match protocols - No Storage -struct ProtobufUnittest_Msg3NamesUsesStorage { +struct SwiftProtoTesting_Msg3NamesUsesStorage: Sendable { // 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. @@ -683,12 +600,12 @@ struct ProtobufUnittest_Msg3NamesUsesStorage { var debugDescription_p: Int32 = 0 /// Recursive class, forces _StorageClass - var value: ProtobufUnittest_Msg3UsesStorage { - get {return _value ?? ProtobufUnittest_Msg3UsesStorage()} + var value: SwiftProtoTesting_Msg3UsesStorage { + get {_value ?? SwiftProtoTesting_Msg3UsesStorage()} set {_value = newValue} } /// Returns true if `value` has been explicitly set. - var hasValue: Bool {return self._value != nil} + var hasValue: Bool {self._value != nil} /// Clears the value of `value`. Subsequent reads from it will return its default value. mutating func clearValue() {self._value = nil} @@ -696,97 +613,16 @@ struct ProtobufUnittest_Msg3NamesUsesStorage { init() {} - fileprivate var _value: ProtobufUnittest_Msg3UsesStorage? = nil + fileprivate var _value: SwiftProtoTesting_Msg3UsesStorage? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_Message3: @unchecked Sendable {} -extension ProtobufUnittest_Message3.OneOf_O: @unchecked Sendable {} -extension ProtobufUnittest_Message3.Enum: @unchecked Sendable {} -extension ProtobufUnittest_Msg3NoStorage: @unchecked Sendable {} -extension ProtobufUnittest_Msg3UsesStorage: @unchecked Sendable {} -extension ProtobufUnittest_Msg3NamesNoStorage: @unchecked Sendable {} -extension ProtobufUnittest_Msg3NamesUsesStorage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Message3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Message3" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 18: .standard(proto: "optional_message"), - 19: .standard(proto: "optional_enum"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 48: .standard(proto: "repeated_message"), - 49: .standard(proto: "repeated_enum"), - 51: .standard(proto: "oneof_int32"), - 52: .standard(proto: "oneof_int64"), - 53: .standard(proto: "oneof_uint32"), - 54: .standard(proto: "oneof_uint64"), - 55: .standard(proto: "oneof_sint32"), - 56: .standard(proto: "oneof_sint64"), - 57: .standard(proto: "oneof_fixed32"), - 58: .standard(proto: "oneof_fixed64"), - 59: .standard(proto: "oneof_sfixed32"), - 60: .standard(proto: "oneof_sfixed64"), - 61: .standard(proto: "oneof_float"), - 62: .standard(proto: "oneof_double"), - 63: .standard(proto: "oneof_bool"), - 64: .standard(proto: "oneof_string"), - 65: .standard(proto: "oneof_bytes"), - 68: .standard(proto: "oneof_message"), - 69: .standard(proto: "oneof_enum"), - 70: .standard(proto: "map_int32_int32"), - 71: .standard(proto: "map_int64_int64"), - 72: .standard(proto: "map_uint32_uint32"), - 73: .standard(proto: "map_uint64_uint64"), - 74: .standard(proto: "map_sint32_sint32"), - 75: .standard(proto: "map_sint64_sint64"), - 76: .standard(proto: "map_fixed32_fixed32"), - 77: .standard(proto: "map_fixed64_fixed64"), - 78: .standard(proto: "map_sfixed32_sfixed32"), - 79: .standard(proto: "map_sfixed64_sfixed64"), - 80: .standard(proto: "map_int32_float"), - 81: .standard(proto: "map_int32_double"), - 82: .standard(proto: "map_bool_bool"), - 83: .standard(proto: "map_string_string"), - 84: .standard(proto: "map_string_bytes"), - 85: .standard(proto: "map_string_message"), - 86: .standard(proto: "map_int32_bytes"), - 87: .standard(proto: "map_int32_enum"), - 88: .standard(proto: "map_int32_message"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_message\0\u{3}optional_enum\0\u{4}\u{c}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_message\0\u{3}repeated_enum\0\u{4}\u{2}oneof_int32\0\u{3}oneof_int64\0\u{3}oneof_uint32\0\u{3}oneof_uint64\0\u{3}oneof_sint32\0\u{3}oneof_sint64\0\u{3}oneof_fixed32\0\u{3}oneof_fixed64\0\u{3}oneof_sfixed32\0\u{3}oneof_sfixed64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_bool\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{4}\u{3}oneof_message\0\u{3}oneof_enum\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_message\0\u{3}map_int32_bytes\0\u{3}map_int32_enum\0\u{3}map_int32_message\0") fileprivate class _StorageClass { var _optionalInt32: Int32 = 0 @@ -804,8 +640,8 @@ extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._Messa var _optionalBool: Bool = false var _optionalString: String = String() var _optionalBytes: Data = Data() - var _optionalMessage: ProtobufUnittest_Message3? = nil - var _optionalEnum: ProtobufUnittest_Message3.Enum = .foo + var _optionalMessage: SwiftProtoTesting_Message3? = nil + var _optionalEnum: SwiftProtoTesting_Message3.Enum = .foo var _repeatedInt32: [Int32] = [] var _repeatedInt64: [Int64] = [] var _repeatedUint32: [UInt32] = [] @@ -821,9 +657,9 @@ extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._Messa var _repeatedBool: [Bool] = [] var _repeatedString: [String] = [] var _repeatedBytes: [Data] = [] - var _repeatedMessage: [ProtobufUnittest_Message3] = [] - var _repeatedEnum: [ProtobufUnittest_Message3.Enum] = [] - var _o: ProtobufUnittest_Message3.OneOf_O? + var _repeatedMessage: [SwiftProtoTesting_Message3] = [] + var _repeatedEnum: [SwiftProtoTesting_Message3.Enum] = [] + var _o: SwiftProtoTesting_Message3.OneOf_O? var _mapInt32Int32: Dictionary = [:] var _mapInt64Int64: Dictionary = [:] var _mapUint32Uint32: Dictionary = [:] @@ -839,12 +675,16 @@ extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._Messa var _mapBoolBool: Dictionary = [:] var _mapStringString: Dictionary = [:] var _mapStringBytes: Dictionary = [:] - var _mapStringMessage: Dictionary = [:] + var _mapStringMessage: Dictionary = [:] var _mapInt32Bytes: Dictionary = [:] - var _mapInt32Enum: Dictionary = [:] - var _mapInt32Message: Dictionary = [:] + var _mapInt32Enum: Dictionary = [:] + var _mapInt32Message: Dictionary = [:] - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1076,7 +916,7 @@ extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._Messa } }() case 68: try { - var v: ProtobufUnittest_Message3? + var v: SwiftProtoTesting_Message3? var hadOneofValue = false if let current = _storage._o { hadOneofValue = true @@ -1089,7 +929,7 @@ extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._Messa } }() case 69: try { - var v: ProtobufUnittest_Message3.Enum? + var v: SwiftProtoTesting_Message3.Enum? try decoder.decodeSingularEnumField(value: &v) if let v = v { if _storage._o != nil {try decoder.handleConflictingOneOf()} @@ -1111,10 +951,10 @@ extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._Messa case 82: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() case 83: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() case 84: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() - case 85: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringMessage) }() + case 85: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringMessage) }() case 86: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bytes) }() - case 87: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() - case 88: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32Message) }() + case 87: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() + case 88: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32Message) }() default: break } } @@ -1157,10 +997,10 @@ extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._Messa if _storage._optionalSfixed64 != 0 { try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) } - if _storage._optionalFloat != 0 { + if _storage._optionalFloat.bitPattern != 0 { try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) } - if _storage._optionalDouble != 0 { + if _storage._optionalDouble.bitPattern != 0 { try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) } if _storage._optionalBool != false { @@ -1346,22 +1186,22 @@ extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._Messa try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 84) } if !_storage._mapStringMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringMessage, fieldNumber: 85) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringMessage, fieldNumber: 85) } if !_storage._mapInt32Bytes.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bytes, fieldNumber: 86) } if !_storage._mapInt32Enum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 87) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 87) } if !_storage._mapInt32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32Message, fieldNumber: 88) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32Message, fieldNumber: 88) } } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Message3, rhs: ProtobufUnittest_Message3) -> Bool { + static func ==(lhs: SwiftProtoTesting_Message3, rhs: SwiftProtoTesting_Message3) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -1429,44 +1269,41 @@ extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._Messa } } -extension ProtobufUnittest_Message3.Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - 30: .same(proto: "EXTRA_3"), - ] +extension SwiftProtoTesting_Message3.Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOO\0\u{1}BAR\0\u{1}BAZ\0\u{2}\u{1c}EXTRA_3\0") } -extension ProtobufUnittest_Msg3NoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Msg3NoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg3NoStorage" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Msg3NoStorage, rhs: ProtobufUnittest_Msg3NoStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Msg3NoStorage, rhs: SwiftProtoTesting_Msg3NoStorage) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Msg3UsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Msg3UsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg3UsesStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 999: .same(proto: "y"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}g\u{f}y\0") fileprivate class _StorageClass { - var _y: ProtobufUnittest_Msg3UsesStorage? = nil + var _y: SwiftProtoTesting_Msg3UsesStorage? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1510,7 +1347,7 @@ extension ProtobufUnittest_Msg3UsesStorage: SwiftProtobuf.Message, SwiftProtobuf try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Msg3UsesStorage, rhs: ProtobufUnittest_Msg3UsesStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Msg3UsesStorage, rhs: SwiftProtoTesting_Msg3UsesStorage) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -1525,13 +1362,9 @@ extension ProtobufUnittest_Msg3UsesStorage: SwiftProtobuf.Message, SwiftProtobuf } } -extension ProtobufUnittest_Msg3NamesNoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Msg3NamesNoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg3NamesNoStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "is_initialized"), - 2: .standard(proto: "debug_description"), - 3: .standard(proto: "has_value"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}is_initialized\0\u{3}debug_description\0\u{3}has_value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1560,7 +1393,7 @@ extension ProtobufUnittest_Msg3NamesNoStorage: SwiftProtobuf.Message, SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Msg3NamesNoStorage, rhs: ProtobufUnittest_Msg3NamesNoStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Msg3NamesNoStorage, rhs: SwiftProtoTesting_Msg3NamesNoStorage) -> Bool { if lhs.isInitialized_p != rhs.isInitialized_p {return false} if lhs.debugDescription_p != rhs.debugDescription_p {return false} if lhs.hasValue_p != rhs.hasValue_p {return false} @@ -1569,13 +1402,9 @@ extension ProtobufUnittest_Msg3NamesNoStorage: SwiftProtobuf.Message, SwiftProto } } -extension ProtobufUnittest_Msg3NamesUsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Msg3NamesUsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg3NamesUsesStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "is_initialized"), - 2: .standard(proto: "debug_description"), - 3: .same(proto: "value"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}is_initialized\0\u{3}debug_description\0\u{1}value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1608,7 +1437,7 @@ extension ProtobufUnittest_Msg3NamesUsesStorage: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Msg3NamesUsesStorage, rhs: ProtobufUnittest_Msg3NamesUsesStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Msg3NamesUsesStorage, rhs: SwiftProtoTesting_Msg3NamesUsesStorage) -> Bool { if lhs.isInitialized_p != rhs.isInitialized_p {return false} if lhs.debugDescription_p != rhs.debugDescription_p {return false} if lhs._value != rhs._value {return false} diff --git a/Reference/google/protobuf/unittest_well_known_types.pb.swift b/Reference/Tests/SwiftProtobufTests/unittest_well_known_types.pb.swift similarity index 82% rename from Reference/google/protobuf/unittest_well_known_types.pb.swift rename to Reference/Tests/SwiftProtobufTests/unittest_well_known_types.pb.swift index d8b98850d..66900d3c9 100644 --- a/Reference/google/protobuf/unittest_well_known_types.pb.swift +++ b/Reference/Tests/SwiftProtobufTests/unittest_well_known_types.pb.swift @@ -1,13 +1,43 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_well_known_types.proto +// Source: unittest_well_known_types.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ -import Foundation +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -23,180 +53,180 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// Test that we can include all well-known types. /// Each wrapper type is included separately, as languages /// map handle different wrappers in different ways. -struct ProtobufUnittest_TestWellKnownTypes { +struct SwiftProtoTesting_TestWellKnownTypes: @unchecked Sendable { // 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 anyField: SwiftProtobuf.Google_Protobuf_Any { - get {return _storage._anyField ?? SwiftProtobuf.Google_Protobuf_Any()} + get {_storage._anyField ?? SwiftProtobuf.Google_Protobuf_Any()} set {_uniqueStorage()._anyField = newValue} } /// Returns true if `anyField` has been explicitly set. - var hasAnyField: Bool {return _storage._anyField != nil} + var hasAnyField: Bool {_storage._anyField != nil} /// Clears the value of `anyField`. Subsequent reads from it will return its default value. mutating func clearAnyField() {_uniqueStorage()._anyField = nil} var apiField: SwiftProtobuf.Google_Protobuf_Api { - get {return _storage._apiField ?? SwiftProtobuf.Google_Protobuf_Api()} + get {_storage._apiField ?? SwiftProtobuf.Google_Protobuf_Api()} set {_uniqueStorage()._apiField = newValue} } /// Returns true if `apiField` has been explicitly set. - var hasApiField: Bool {return _storage._apiField != nil} + var hasApiField: Bool {_storage._apiField != nil} /// Clears the value of `apiField`. Subsequent reads from it will return its default value. mutating func clearApiField() {_uniqueStorage()._apiField = nil} var durationField: SwiftProtobuf.Google_Protobuf_Duration { - get {return _storage._durationField ?? SwiftProtobuf.Google_Protobuf_Duration()} + get {_storage._durationField ?? SwiftProtobuf.Google_Protobuf_Duration()} set {_uniqueStorage()._durationField = newValue} } /// Returns true if `durationField` has been explicitly set. - var hasDurationField: Bool {return _storage._durationField != nil} + var hasDurationField: Bool {_storage._durationField != nil} /// Clears the value of `durationField`. Subsequent reads from it will return its default value. mutating func clearDurationField() {_uniqueStorage()._durationField = nil} var emptyField: SwiftProtobuf.Google_Protobuf_Empty { - get {return _storage._emptyField ?? SwiftProtobuf.Google_Protobuf_Empty()} + get {_storage._emptyField ?? SwiftProtobuf.Google_Protobuf_Empty()} set {_uniqueStorage()._emptyField = newValue} } /// Returns true if `emptyField` has been explicitly set. - var hasEmptyField: Bool {return _storage._emptyField != nil} + var hasEmptyField: Bool {_storage._emptyField != nil} /// Clears the value of `emptyField`. Subsequent reads from it will return its default value. mutating func clearEmptyField() {_uniqueStorage()._emptyField = nil} var fieldMaskField: SwiftProtobuf.Google_Protobuf_FieldMask { - get {return _storage._fieldMaskField ?? SwiftProtobuf.Google_Protobuf_FieldMask()} + get {_storage._fieldMaskField ?? SwiftProtobuf.Google_Protobuf_FieldMask()} set {_uniqueStorage()._fieldMaskField = newValue} } /// Returns true if `fieldMaskField` has been explicitly set. - var hasFieldMaskField: Bool {return _storage._fieldMaskField != nil} + var hasFieldMaskField: Bool {_storage._fieldMaskField != nil} /// Clears the value of `fieldMaskField`. Subsequent reads from it will return its default value. mutating func clearFieldMaskField() {_uniqueStorage()._fieldMaskField = nil} var sourceContextField: SwiftProtobuf.Google_Protobuf_SourceContext { - get {return _storage._sourceContextField ?? SwiftProtobuf.Google_Protobuf_SourceContext()} + get {_storage._sourceContextField ?? SwiftProtobuf.Google_Protobuf_SourceContext()} set {_uniqueStorage()._sourceContextField = newValue} } /// Returns true if `sourceContextField` has been explicitly set. - var hasSourceContextField: Bool {return _storage._sourceContextField != nil} + var hasSourceContextField: Bool {_storage._sourceContextField != nil} /// Clears the value of `sourceContextField`. Subsequent reads from it will return its default value. mutating func clearSourceContextField() {_uniqueStorage()._sourceContextField = nil} var structField: SwiftProtobuf.Google_Protobuf_Struct { - get {return _storage._structField ?? SwiftProtobuf.Google_Protobuf_Struct()} + get {_storage._structField ?? SwiftProtobuf.Google_Protobuf_Struct()} set {_uniqueStorage()._structField = newValue} } /// Returns true if `structField` has been explicitly set. - var hasStructField: Bool {return _storage._structField != nil} + var hasStructField: Bool {_storage._structField != nil} /// Clears the value of `structField`. Subsequent reads from it will return its default value. mutating func clearStructField() {_uniqueStorage()._structField = nil} var timestampField: SwiftProtobuf.Google_Protobuf_Timestamp { - get {return _storage._timestampField ?? SwiftProtobuf.Google_Protobuf_Timestamp()} + get {_storage._timestampField ?? SwiftProtobuf.Google_Protobuf_Timestamp()} set {_uniqueStorage()._timestampField = newValue} } /// Returns true if `timestampField` has been explicitly set. - var hasTimestampField: Bool {return _storage._timestampField != nil} + var hasTimestampField: Bool {_storage._timestampField != nil} /// Clears the value of `timestampField`. Subsequent reads from it will return its default value. mutating func clearTimestampField() {_uniqueStorage()._timestampField = nil} var typeField: SwiftProtobuf.Google_Protobuf_Type { - get {return _storage._typeField ?? SwiftProtobuf.Google_Protobuf_Type()} + get {_storage._typeField ?? SwiftProtobuf.Google_Protobuf_Type()} set {_uniqueStorage()._typeField = newValue} } /// Returns true if `typeField` has been explicitly set. - var hasTypeField: Bool {return _storage._typeField != nil} + var hasTypeField: Bool {_storage._typeField != nil} /// Clears the value of `typeField`. Subsequent reads from it will return its default value. mutating func clearTypeField() {_uniqueStorage()._typeField = nil} var doubleField: SwiftProtobuf.Google_Protobuf_DoubleValue { - get {return _storage._doubleField ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} + get {_storage._doubleField ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} set {_uniqueStorage()._doubleField = newValue} } /// Returns true if `doubleField` has been explicitly set. - var hasDoubleField: Bool {return _storage._doubleField != nil} + var hasDoubleField: Bool {_storage._doubleField != nil} /// Clears the value of `doubleField`. Subsequent reads from it will return its default value. mutating func clearDoubleField() {_uniqueStorage()._doubleField = nil} var floatField: SwiftProtobuf.Google_Protobuf_FloatValue { - get {return _storage._floatField ?? SwiftProtobuf.Google_Protobuf_FloatValue()} + get {_storage._floatField ?? SwiftProtobuf.Google_Protobuf_FloatValue()} set {_uniqueStorage()._floatField = newValue} } /// Returns true if `floatField` has been explicitly set. - var hasFloatField: Bool {return _storage._floatField != nil} + var hasFloatField: Bool {_storage._floatField != nil} /// Clears the value of `floatField`. Subsequent reads from it will return its default value. mutating func clearFloatField() {_uniqueStorage()._floatField = nil} var int64Field: SwiftProtobuf.Google_Protobuf_Int64Value { - get {return _storage._int64Field ?? SwiftProtobuf.Google_Protobuf_Int64Value()} + get {_storage._int64Field ?? SwiftProtobuf.Google_Protobuf_Int64Value()} set {_uniqueStorage()._int64Field = newValue} } /// Returns true if `int64Field` has been explicitly set. - var hasInt64Field: Bool {return _storage._int64Field != nil} + var hasInt64Field: Bool {_storage._int64Field != nil} /// Clears the value of `int64Field`. Subsequent reads from it will return its default value. mutating func clearInt64Field() {_uniqueStorage()._int64Field = nil} var uint64Field: SwiftProtobuf.Google_Protobuf_UInt64Value { - get {return _storage._uint64Field ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} + get {_storage._uint64Field ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} set {_uniqueStorage()._uint64Field = newValue} } /// Returns true if `uint64Field` has been explicitly set. - var hasUint64Field: Bool {return _storage._uint64Field != nil} + var hasUint64Field: Bool {_storage._uint64Field != nil} /// Clears the value of `uint64Field`. Subsequent reads from it will return its default value. mutating func clearUint64Field() {_uniqueStorage()._uint64Field = nil} var int32Field: SwiftProtobuf.Google_Protobuf_Int32Value { - get {return _storage._int32Field ?? SwiftProtobuf.Google_Protobuf_Int32Value()} + get {_storage._int32Field ?? SwiftProtobuf.Google_Protobuf_Int32Value()} set {_uniqueStorage()._int32Field = newValue} } /// Returns true if `int32Field` has been explicitly set. - var hasInt32Field: Bool {return _storage._int32Field != nil} + var hasInt32Field: Bool {_storage._int32Field != nil} /// Clears the value of `int32Field`. Subsequent reads from it will return its default value. mutating func clearInt32Field() {_uniqueStorage()._int32Field = nil} var uint32Field: SwiftProtobuf.Google_Protobuf_UInt32Value { - get {return _storage._uint32Field ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} + get {_storage._uint32Field ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} set {_uniqueStorage()._uint32Field = newValue} } /// Returns true if `uint32Field` has been explicitly set. - var hasUint32Field: Bool {return _storage._uint32Field != nil} + var hasUint32Field: Bool {_storage._uint32Field != nil} /// Clears the value of `uint32Field`. Subsequent reads from it will return its default value. mutating func clearUint32Field() {_uniqueStorage()._uint32Field = nil} var boolField: SwiftProtobuf.Google_Protobuf_BoolValue { - get {return _storage._boolField ?? SwiftProtobuf.Google_Protobuf_BoolValue()} + get {_storage._boolField ?? SwiftProtobuf.Google_Protobuf_BoolValue()} set {_uniqueStorage()._boolField = newValue} } /// Returns true if `boolField` has been explicitly set. - var hasBoolField: Bool {return _storage._boolField != nil} + var hasBoolField: Bool {_storage._boolField != nil} /// Clears the value of `boolField`. Subsequent reads from it will return its default value. mutating func clearBoolField() {_uniqueStorage()._boolField = nil} var stringField: SwiftProtobuf.Google_Protobuf_StringValue { - get {return _storage._stringField ?? SwiftProtobuf.Google_Protobuf_StringValue()} + get {_storage._stringField ?? SwiftProtobuf.Google_Protobuf_StringValue()} set {_uniqueStorage()._stringField = newValue} } /// Returns true if `stringField` has been explicitly set. - var hasStringField: Bool {return _storage._stringField != nil} + var hasStringField: Bool {_storage._stringField != nil} /// Clears the value of `stringField`. Subsequent reads from it will return its default value. mutating func clearStringField() {_uniqueStorage()._stringField = nil} var bytesField: SwiftProtobuf.Google_Protobuf_BytesValue { - get {return _storage._bytesField ?? SwiftProtobuf.Google_Protobuf_BytesValue()} + get {_storage._bytesField ?? SwiftProtobuf.Google_Protobuf_BytesValue()} set {_uniqueStorage()._bytesField = newValue} } /// Returns true if `bytesField` has been explicitly set. - var hasBytesField: Bool {return _storage._bytesField != nil} + var hasBytesField: Bool {_storage._bytesField != nil} /// Clears the value of `bytesField`. Subsequent reads from it will return its default value. mutating func clearBytesField() {_uniqueStorage()._bytesField = nil} /// Part of struct, but useful to be able to test separately var valueField: SwiftProtobuf.Google_Protobuf_Value { - get {return _storage._valueField ?? SwiftProtobuf.Google_Protobuf_Value()} + get {_storage._valueField ?? SwiftProtobuf.Google_Protobuf_Value()} set {_uniqueStorage()._valueField = newValue} } /// Returns true if `valueField` has been explicitly set. - var hasValueField: Bool {return _storage._valueField != nil} + var hasValueField: Bool {_storage._valueField != nil} /// Clears the value of `valueField`. Subsequent reads from it will return its default value. mutating func clearValueField() {_uniqueStorage()._valueField = nil} @@ -208,99 +238,99 @@ struct ProtobufUnittest_TestWellKnownTypes { } /// A repeated field for each well-known type. -struct ProtobufUnittest_RepeatedWellKnownTypes { +struct SwiftProtoTesting_RepeatedWellKnownTypes: @unchecked Sendable { // 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 anyField: [SwiftProtobuf.Google_Protobuf_Any] { - get {return _storage._anyField} + get {_storage._anyField} set {_uniqueStorage()._anyField = newValue} } var apiField: [SwiftProtobuf.Google_Protobuf_Api] { - get {return _storage._apiField} + get {_storage._apiField} set {_uniqueStorage()._apiField = newValue} } var durationField: [SwiftProtobuf.Google_Protobuf_Duration] { - get {return _storage._durationField} + get {_storage._durationField} set {_uniqueStorage()._durationField = newValue} } var emptyField: [SwiftProtobuf.Google_Protobuf_Empty] { - get {return _storage._emptyField} + get {_storage._emptyField} set {_uniqueStorage()._emptyField = newValue} } var fieldMaskField: [SwiftProtobuf.Google_Protobuf_FieldMask] { - get {return _storage._fieldMaskField} + get {_storage._fieldMaskField} set {_uniqueStorage()._fieldMaskField = newValue} } var sourceContextField: [SwiftProtobuf.Google_Protobuf_SourceContext] { - get {return _storage._sourceContextField} + get {_storage._sourceContextField} set {_uniqueStorage()._sourceContextField = newValue} } var structField: [SwiftProtobuf.Google_Protobuf_Struct] { - get {return _storage._structField} + get {_storage._structField} set {_uniqueStorage()._structField = newValue} } var timestampField: [SwiftProtobuf.Google_Protobuf_Timestamp] { - get {return _storage._timestampField} + get {_storage._timestampField} set {_uniqueStorage()._timestampField = newValue} } var typeField: [SwiftProtobuf.Google_Protobuf_Type] { - get {return _storage._typeField} + get {_storage._typeField} set {_uniqueStorage()._typeField = newValue} } /// These don't actually make a lot of sense, but they're not prohibited... var doubleField: [SwiftProtobuf.Google_Protobuf_DoubleValue] { - get {return _storage._doubleField} + get {_storage._doubleField} set {_uniqueStorage()._doubleField = newValue} } var floatField: [SwiftProtobuf.Google_Protobuf_FloatValue] { - get {return _storage._floatField} + get {_storage._floatField} set {_uniqueStorage()._floatField = newValue} } var int64Field: [SwiftProtobuf.Google_Protobuf_Int64Value] { - get {return _storage._int64Field} + get {_storage._int64Field} set {_uniqueStorage()._int64Field = newValue} } var uint64Field: [SwiftProtobuf.Google_Protobuf_UInt64Value] { - get {return _storage._uint64Field} + get {_storage._uint64Field} set {_uniqueStorage()._uint64Field = newValue} } var int32Field: [SwiftProtobuf.Google_Protobuf_Int32Value] { - get {return _storage._int32Field} + get {_storage._int32Field} set {_uniqueStorage()._int32Field = newValue} } var uint32Field: [SwiftProtobuf.Google_Protobuf_UInt32Value] { - get {return _storage._uint32Field} + get {_storage._uint32Field} set {_uniqueStorage()._uint32Field = newValue} } var boolField: [SwiftProtobuf.Google_Protobuf_BoolValue] { - get {return _storage._boolField} + get {_storage._boolField} set {_uniqueStorage()._boolField = newValue} } var stringField: [SwiftProtobuf.Google_Protobuf_StringValue] { - get {return _storage._stringField} + get {_storage._stringField} set {_uniqueStorage()._stringField = newValue} } var bytesField: [SwiftProtobuf.Google_Protobuf_BytesValue] { - get {return _storage._bytesField} + get {_storage._bytesField} set {_uniqueStorage()._bytesField = newValue} } @@ -311,12 +341,12 @@ struct ProtobufUnittest_RepeatedWellKnownTypes { fileprivate var _storage = _StorageClass.defaultInstance } -struct ProtobufUnittest_OneofWellKnownTypes { +struct SwiftProtoTesting_OneofWellKnownTypes: Sendable { // 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 oneofField: ProtobufUnittest_OneofWellKnownTypes.OneOf_OneofField? = nil + var oneofField: SwiftProtoTesting_OneofWellKnownTypes.OneOf_OneofField? = nil var anyField: SwiftProtobuf.Google_Protobuf_Any { get { @@ -464,7 +494,7 @@ struct ProtobufUnittest_OneofWellKnownTypes { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case anyField(SwiftProtobuf.Google_Protobuf_Any) case apiField(SwiftProtobuf.Google_Protobuf_Api) case durationField(SwiftProtobuf.Google_Protobuf_Duration) @@ -484,88 +514,6 @@ struct ProtobufUnittest_OneofWellKnownTypes { case stringField(SwiftProtobuf.Google_Protobuf_StringValue) case bytesField(SwiftProtobuf.Google_Protobuf_BytesValue) - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_OneofWellKnownTypes.OneOf_OneofField, rhs: ProtobufUnittest_OneofWellKnownTypes.OneOf_OneofField) -> 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 (.anyField, .anyField): return { - guard case .anyField(let l) = lhs, case .anyField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.apiField, .apiField): return { - guard case .apiField(let l) = lhs, case .apiField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.durationField, .durationField): return { - guard case .durationField(let l) = lhs, case .durationField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.emptyField, .emptyField): return { - guard case .emptyField(let l) = lhs, case .emptyField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fieldMaskField, .fieldMaskField): return { - guard case .fieldMaskField(let l) = lhs, case .fieldMaskField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.sourceContextField, .sourceContextField): return { - guard case .sourceContextField(let l) = lhs, case .sourceContextField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.structField, .structField): return { - guard case .structField(let l) = lhs, case .structField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.timestampField, .timestampField): return { - guard case .timestampField(let l) = lhs, case .timestampField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.typeField, .typeField): return { - guard case .typeField(let l) = lhs, case .typeField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.doubleField, .doubleField): return { - guard case .doubleField(let l) = lhs, case .doubleField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.floatField, .floatField): return { - guard case .floatField(let l) = lhs, case .floatField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.int64Field, .int64Field): return { - guard case .int64Field(let l) = lhs, case .int64Field(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.uint64Field, .uint64Field): return { - guard case .uint64Field(let l) = lhs, case .uint64Field(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.int32Field, .int32Field): return { - guard case .int32Field(let l) = lhs, case .int32Field(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.uint32Field, .uint32Field): return { - guard case .uint32Field(let l) = lhs, case .uint32Field(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.boolField, .boolField): return { - guard case .boolField(let l) = lhs, case .boolField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.stringField, .stringField): return { - guard case .stringField(let l) = lhs, case .stringField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.bytesField, .bytesField): return { - guard case .bytesField(let l) = lhs, case .bytesField(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } init() {} @@ -574,98 +522,98 @@ struct ProtobufUnittest_OneofWellKnownTypes { /// A map field for each well-known type. We only /// need to worry about the value part of the map being the /// well-known types, as messages can't be map keys. -struct ProtobufUnittest_MapWellKnownTypes { +struct SwiftProtoTesting_MapWellKnownTypes: @unchecked Sendable { // 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 anyField: Dictionary { - get {return _storage._anyField} + get {_storage._anyField} set {_uniqueStorage()._anyField = newValue} } var apiField: Dictionary { - get {return _storage._apiField} + get {_storage._apiField} set {_uniqueStorage()._apiField = newValue} } var durationField: Dictionary { - get {return _storage._durationField} + get {_storage._durationField} set {_uniqueStorage()._durationField = newValue} } var emptyField: Dictionary { - get {return _storage._emptyField} + get {_storage._emptyField} set {_uniqueStorage()._emptyField = newValue} } var fieldMaskField: Dictionary { - get {return _storage._fieldMaskField} + get {_storage._fieldMaskField} set {_uniqueStorage()._fieldMaskField = newValue} } var sourceContextField: Dictionary { - get {return _storage._sourceContextField} + get {_storage._sourceContextField} set {_uniqueStorage()._sourceContextField = newValue} } var structField: Dictionary { - get {return _storage._structField} + get {_storage._structField} set {_uniqueStorage()._structField = newValue} } var timestampField: Dictionary { - get {return _storage._timestampField} + get {_storage._timestampField} set {_uniqueStorage()._timestampField = newValue} } var typeField: Dictionary { - get {return _storage._typeField} + get {_storage._typeField} set {_uniqueStorage()._typeField = newValue} } var doubleField: Dictionary { - get {return _storage._doubleField} + get {_storage._doubleField} set {_uniqueStorage()._doubleField = newValue} } var floatField: Dictionary { - get {return _storage._floatField} + get {_storage._floatField} set {_uniqueStorage()._floatField = newValue} } var int64Field: Dictionary { - get {return _storage._int64Field} + get {_storage._int64Field} set {_uniqueStorage()._int64Field = newValue} } var uint64Field: Dictionary { - get {return _storage._uint64Field} + get {_storage._uint64Field} set {_uniqueStorage()._uint64Field = newValue} } var int32Field: Dictionary { - get {return _storage._int32Field} + get {_storage._int32Field} set {_uniqueStorage()._int32Field = newValue} } var uint32Field: Dictionary { - get {return _storage._uint32Field} + get {_storage._uint32Field} set {_uniqueStorage()._uint32Field = newValue} } var boolField: Dictionary { - get {return _storage._boolField} + get {_storage._boolField} set {_uniqueStorage()._boolField = newValue} } var stringField: Dictionary { - get {return _storage._stringField} + get {_storage._stringField} set {_uniqueStorage()._stringField = newValue} } var bytesField: Dictionary { - get {return _storage._bytesField} + get {_storage._bytesField} set {_uniqueStorage()._bytesField = newValue} } @@ -676,41 +624,13 @@ struct ProtobufUnittest_MapWellKnownTypes { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_TestWellKnownTypes: @unchecked Sendable {} -extension ProtobufUnittest_RepeatedWellKnownTypes: @unchecked Sendable {} -extension ProtobufUnittest_OneofWellKnownTypes: @unchecked Sendable {} -extension ProtobufUnittest_OneofWellKnownTypes.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufUnittest_MapWellKnownTypes: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_TestWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_TestWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestWellKnownTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "any_field"), - 2: .standard(proto: "api_field"), - 3: .standard(proto: "duration_field"), - 4: .standard(proto: "empty_field"), - 5: .standard(proto: "field_mask_field"), - 6: .standard(proto: "source_context_field"), - 7: .standard(proto: "struct_field"), - 8: .standard(proto: "timestamp_field"), - 9: .standard(proto: "type_field"), - 10: .standard(proto: "double_field"), - 11: .standard(proto: "float_field"), - 12: .standard(proto: "int64_field"), - 13: .standard(proto: "uint64_field"), - 14: .standard(proto: "int32_field"), - 15: .standard(proto: "uint32_field"), - 16: .standard(proto: "bool_field"), - 17: .standard(proto: "string_field"), - 18: .standard(proto: "bytes_field"), - 19: .standard(proto: "value_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}any_field\0\u{3}api_field\0\u{3}duration_field\0\u{3}empty_field\0\u{3}field_mask_field\0\u{3}source_context_field\0\u{3}struct_field\0\u{3}timestamp_field\0\u{3}type_field\0\u{3}double_field\0\u{3}float_field\0\u{3}int64_field\0\u{3}uint64_field\0\u{3}int32_field\0\u{3}uint32_field\0\u{3}bool_field\0\u{3}string_field\0\u{3}bytes_field\0\u{3}value_field\0") fileprivate class _StorageClass { var _anyField: SwiftProtobuf.Google_Protobuf_Any? = nil @@ -733,7 +653,11 @@ extension ProtobufUnittest_TestWellKnownTypes: SwiftProtobuf.Message, SwiftProto var _bytesField: SwiftProtobuf.Google_Protobuf_BytesValue? = nil var _valueField: SwiftProtobuf.Google_Protobuf_Value? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -867,7 +791,7 @@ extension ProtobufUnittest_TestWellKnownTypes: SwiftProtobuf.Message, SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestWellKnownTypes, rhs: ProtobufUnittest_TestWellKnownTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestWellKnownTypes, rhs: SwiftProtoTesting_TestWellKnownTypes) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -900,28 +824,9 @@ extension ProtobufUnittest_TestWellKnownTypes: SwiftProtobuf.Message, SwiftProto } } -extension ProtobufUnittest_RepeatedWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_RepeatedWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".RepeatedWellKnownTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "any_field"), - 2: .standard(proto: "api_field"), - 3: .standard(proto: "duration_field"), - 4: .standard(proto: "empty_field"), - 5: .standard(proto: "field_mask_field"), - 6: .standard(proto: "source_context_field"), - 7: .standard(proto: "struct_field"), - 8: .standard(proto: "timestamp_field"), - 9: .standard(proto: "type_field"), - 10: .standard(proto: "double_field"), - 11: .standard(proto: "float_field"), - 12: .standard(proto: "int64_field"), - 13: .standard(proto: "uint64_field"), - 14: .standard(proto: "int32_field"), - 15: .standard(proto: "uint32_field"), - 16: .standard(proto: "bool_field"), - 17: .standard(proto: "string_field"), - 18: .standard(proto: "bytes_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}any_field\0\u{3}api_field\0\u{3}duration_field\0\u{3}empty_field\0\u{3}field_mask_field\0\u{3}source_context_field\0\u{3}struct_field\0\u{3}timestamp_field\0\u{3}type_field\0\u{3}double_field\0\u{3}float_field\0\u{3}int64_field\0\u{3}uint64_field\0\u{3}int32_field\0\u{3}uint32_field\0\u{3}bool_field\0\u{3}string_field\0\u{3}bytes_field\0") fileprivate class _StorageClass { var _anyField: [SwiftProtobuf.Google_Protobuf_Any] = [] @@ -943,7 +848,11 @@ extension ProtobufUnittest_RepeatedWellKnownTypes: SwiftProtobuf.Message, SwiftP var _stringField: [SwiftProtobuf.Google_Protobuf_StringValue] = [] var _bytesField: [SwiftProtobuf.Google_Protobuf_BytesValue] = [] - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1068,7 +977,7 @@ extension ProtobufUnittest_RepeatedWellKnownTypes: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_RepeatedWellKnownTypes, rhs: ProtobufUnittest_RepeatedWellKnownTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_RepeatedWellKnownTypes, rhs: SwiftProtoTesting_RepeatedWellKnownTypes) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -1100,28 +1009,9 @@ extension ProtobufUnittest_RepeatedWellKnownTypes: SwiftProtobuf.Message, SwiftP } } -extension ProtobufUnittest_OneofWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_OneofWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".OneofWellKnownTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "any_field"), - 2: .standard(proto: "api_field"), - 3: .standard(proto: "duration_field"), - 4: .standard(proto: "empty_field"), - 5: .standard(proto: "field_mask_field"), - 6: .standard(proto: "source_context_field"), - 7: .standard(proto: "struct_field"), - 8: .standard(proto: "timestamp_field"), - 9: .standard(proto: "type_field"), - 10: .standard(proto: "double_field"), - 11: .standard(proto: "float_field"), - 12: .standard(proto: "int64_field"), - 13: .standard(proto: "uint64_field"), - 14: .standard(proto: "int32_field"), - 15: .standard(proto: "uint32_field"), - 16: .standard(proto: "bool_field"), - 17: .standard(proto: "string_field"), - 18: .standard(proto: "bytes_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}any_field\0\u{3}api_field\0\u{3}duration_field\0\u{3}empty_field\0\u{3}field_mask_field\0\u{3}source_context_field\0\u{3}struct_field\0\u{3}timestamp_field\0\u{3}type_field\0\u{3}double_field\0\u{3}float_field\0\u{3}int64_field\0\u{3}uint64_field\0\u{3}int32_field\0\u{3}uint32_field\0\u{3}bool_field\0\u{3}string_field\0\u{3}bytes_field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1451,35 +1341,16 @@ extension ProtobufUnittest_OneofWellKnownTypes: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_OneofWellKnownTypes, rhs: ProtobufUnittest_OneofWellKnownTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_OneofWellKnownTypes, rhs: SwiftProtoTesting_OneofWellKnownTypes) -> Bool { if lhs.oneofField != rhs.oneofField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_MapWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_MapWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MapWellKnownTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "any_field"), - 2: .standard(proto: "api_field"), - 3: .standard(proto: "duration_field"), - 4: .standard(proto: "empty_field"), - 5: .standard(proto: "field_mask_field"), - 6: .standard(proto: "source_context_field"), - 7: .standard(proto: "struct_field"), - 8: .standard(proto: "timestamp_field"), - 9: .standard(proto: "type_field"), - 10: .standard(proto: "double_field"), - 11: .standard(proto: "float_field"), - 12: .standard(proto: "int64_field"), - 13: .standard(proto: "uint64_field"), - 14: .standard(proto: "int32_field"), - 15: .standard(proto: "uint32_field"), - 16: .standard(proto: "bool_field"), - 17: .standard(proto: "string_field"), - 18: .standard(proto: "bytes_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}any_field\0\u{3}api_field\0\u{3}duration_field\0\u{3}empty_field\0\u{3}field_mask_field\0\u{3}source_context_field\0\u{3}struct_field\0\u{3}timestamp_field\0\u{3}type_field\0\u{3}double_field\0\u{3}float_field\0\u{3}int64_field\0\u{3}uint64_field\0\u{3}int32_field\0\u{3}uint32_field\0\u{3}bool_field\0\u{3}string_field\0\u{3}bytes_field\0") fileprivate class _StorageClass { var _anyField: Dictionary = [:] @@ -1501,7 +1372,11 @@ extension ProtobufUnittest_MapWellKnownTypes: SwiftProtobuf.Message, SwiftProtob var _stringField: Dictionary = [:] var _bytesField: Dictionary = [:] - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1626,7 +1501,7 @@ extension ProtobufUnittest_MapWellKnownTypes: SwiftProtobuf.Message, SwiftProtob try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_MapWellKnownTypes, rhs: ProtobufUnittest_MapWellKnownTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_MapWellKnownTypes, rhs: SwiftProtoTesting_MapWellKnownTypes) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 diff --git a/Reference/Tests/protoc-gen-swiftTests/plugin_descriptor_test.pb.swift b/Reference/Tests/protoc-gen-swiftTests/plugin_descriptor_test.pb.swift new file mode 100644 index 000000000..443c4de8b --- /dev/null +++ b/Reference/Tests/protoc-gen-swiftTests/plugin_descriptor_test.pb.swift @@ -0,0 +1,345 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: plugin_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 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 +} + +/// To check handling of extension ranges that are out of order. +struct SwiftDescriptorTest_MsgExtensionRangeOrdering: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 SwiftDescriptorTest_MsgExtensionRangeOrderingWithFields: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 {_field6 ?? 0} + set {_field6 = newValue} + } + /// Returns true if `field6` has been explicitly set. + var hasField6: Bool {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 {_field124 ?? 0} + set {_field124 = newValue} + } + /// Returns true if `field124` has been explicitly set. + var hasField124: Bool {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 {_field125 ?? 0} + set {_field125 = newValue} + } + /// Returns true if `field125` has been explicitly set. + var hasField125: Bool {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 {_field200 ?? 0} + set {_field200 = newValue} + } + /// Returns true if `field200` has been explicitly set. + var hasField200: Bool {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 SwiftDescriptorTest_MsgExtensionRangeOrderingNoMerging: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 {_field1 ?? 0} + set {_field1 = newValue} + } + /// Returns true if `field1` has been explicitly set. + var hasField1: Bool {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 {_field2 ?? 0} + set {_field2 = newValue} + } + /// Returns true if `field2` has been explicitly set. + var hasField2: Bool {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 {_field6 ?? 0} + set {_field6 = newValue} + } + /// Returns true if `field6` has been explicitly set. + var hasField6: Bool {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 {_field13 ?? 0} + set {_field13 = newValue} + } + /// Returns true if `field13` has been explicitly set. + var hasField13: Bool {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 {_field15 ?? 0} + set {_field15 = newValue} + } + /// Returns true if `field15` has been explicitly set. + var hasField15: Bool {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 {_field21 ?? 0} + set {_field21 = newValue} + } + /// Returns true if `field21` has been explicitly set. + var hasField21: Bool {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 +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_descriptor_test" + +extension SwiftDescriptorTest_MsgExtensionRangeOrdering: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MsgExtensionRangeOrdering" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{c}\u{8}\u{1}\u{c}y\u{1}\u{5}") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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..<5, 7, 9, 100..<121, 126..<131: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftDescriptorTest_MsgExtensionRangeOrdering.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 131) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftDescriptorTest_MsgExtensionRangeOrdering, rhs: SwiftDescriptorTest_MsgExtensionRangeOrdering) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension SwiftDescriptorTest_MsgExtensionRangeOrderingWithFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MsgExtensionRangeOrderingWithFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{6}field6\0\u{2}v\u{1}field124\0\u{1}field125\0\u{2}K\u{1}field200\0\u{c}\u{8}\u{1}\u{c}y\u{1}\u{3}") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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 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: SwiftDescriptorTest_MsgExtensionRangeOrderingWithFields.self, fieldNumber: fieldNumber) }() + 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 + 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: SwiftDescriptorTest_MsgExtensionRangeOrderingWithFields, rhs: SwiftDescriptorTest_MsgExtensionRangeOrderingWithFields) -> 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 SwiftDescriptorTest_MsgExtensionRangeOrderingNoMerging: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MsgExtensionRangeOrderingNoMerging" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field1\0\u{1}field2\0\u{2}\u{4}field6\0\u{2}\u{7}field13\0\u{2}\u{2}field15\0\u{2}\u{6}field21\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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._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: SwiftDescriptorTest_MsgExtensionRangeOrderingNoMerging.self, fieldNumber: fieldNumber) }() + 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 + 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: SwiftDescriptorTest_MsgExtensionRangeOrderingNoMerging, rhs: SwiftDescriptorTest_MsgExtensionRangeOrderingNoMerging) -> 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 + } +} diff --git a/Reference/generated_swift_names_enum_cases.pb.swift b/Reference/generated_swift_names_enum_cases.pb.swift deleted file mode 100644 index d1057efb5..000000000 --- a/Reference/generated_swift_names_enum_cases.pb.swift +++ /dev/null @@ -1,4426 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: generated_swift_names_enum_cases.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -/// See Makefile for the logic that generates this -/// Protoc errors imply this file is being generated incorrectly -/// Swift compile errors are probably bugs in protoc-gen-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 ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case none // = 0 - case adjusted // = 1 - case aggregateValue // = 2 - case allCases_ // = 3 - case allowAlias // = 4 - case alwaysPrintEnumsAsInts // = 5 - case annotation // = 6 - case any // = 7 - case anyExtensionField // = 8 - case anyMessageExtension // = 9 - case anyMessageStorage // = 10 - case anyUnpackError // = 11 - case api // = 12 - case appended // = 13 - case appendUintHex // = 14 - case appendUnknown // = 15 - case areAllInitialized // = 16 - case array // = 17 - case arrayDepth // = 18 - case arrayLiteral // = 19 - case arraySeparator // = 20 - case `as` // = 21 - case asciiOpenCurlyBracket // = 22 - case asciiZero // = 23 - case available // = 24 - case b // = 25 - case base64Values // = 26 - case baseAddress // = 27 - case baseType // = 28 - case begin // = 29 - case binary // = 30 - case binaryDecoder // = 31 - case binaryDecodingError // = 32 - case binaryDecodingOptions // = 33 - case binaryDelimited // = 34 - case binaryEncoder // = 35 - case binaryEncodingError // = 36 - case binaryEncodingMessageSetSizeVisitor // = 37 - case binaryEncodingMessageSetVisitor // = 38 - case binaryEncodingSizeVisitor // = 39 - case binaryEncodingVisitor // = 40 - case binaryOptions // = 41 - case body // = 42 - case bool // = 43 - case booleanLiteral // = 44 - case booleanLiteralType // = 45 - case boolValue // = 46 - case bytes // = 47 - case bytesInGroup // = 48 - case bytesRead // = 49 - case bytesValue // = 50 - case c // = 51 - case capitalizeNext // = 52 - case cardinality // = 53 - case ccEnableArenas // = 54 - case ccGenericServices // = 55 - case character // = 56 - case chars // = 57 - case `class` // = 58 - case clearAggregateValue // = 59 - case clearAllowAlias // = 60 - case clearBegin // = 61 - case clearCcEnableArenas // = 62 - case clearCcGenericServices // = 63 - case clearClientStreaming // = 64 - case clearCsharpNamespace // = 65 - case clearCtype // = 66 - case clearDefaultValue // = 67 - case clearDeprecated // = 68 - case clearDoubleValue // = 69 - case clearEnd // = 70 - case clearExtendee // = 71 - case clearExtensionValue // = 72 - case clearGoPackage // = 73 - case clearIdempotencyLevel // = 74 - case clearIdentifierValue // = 75 - case clearInputType // = 76 - case clearIsExtension // = 77 - case clearJavaGenerateEqualsAndHash // = 78 - case clearJavaGenericServices // = 79 - case clearJavaMultipleFiles // = 80 - case clearJavaOuterClassname // = 81 - case clearJavaPackage // = 82 - case clearJavaStringCheckUtf8 // = 83 - case clearJsonName // = 84 - case clearJstype // = 85 - case clearLabel // = 86 - case clearLazy // = 87 - case clearLeadingComments // = 88 - case clearMapEntry // = 89 - case clearMessageSetWireFormat // = 90 - case clearName // = 91 - case clearNamePart // = 92 - case clearNegativeIntValue // = 93 - case clearNoStandardDescriptorAccessor // = 94 - case clearNumber // = 95 - case clearObjcClassPrefix // = 96 - case clearOneofIndex // = 97 - case clearOptimizeFor // = 98 - case clearOptions // = 99 - case clearOutputType // = 100 - case clearPackage // = 101 - case clearPacked // = 102 - case clearPhpClassPrefix // = 103 - case clearPhpGenericServices // = 104 - case clearPhpMetadataNamespace // = 105 - case clearPhpNamespace // = 106 - case clearPositiveIntValue // = 107 - case clearProto3Optional // = 108 - case clearPyGenericServices // = 109 - case clearRubyPackage // = 110 - case clearServerStreaming // = 111 - case clearSourceCodeInfo // = 112 - case clearSourceContext // = 113 - case clearSourceFile // = 114 - case clearStart // = 115 - case clearStringValue // = 116 - case clearSwiftPrefix // = 117 - case clearSyntax // = 118 - case clearTrailingComments // = 119 - case clearType // = 120 - case clearTypeName // = 121 - case clearValue // = 122 - case clearWeak // = 123 - case clientStreaming // = 124 - case codePoint // = 125 - case codeUnits // = 126 - case collection // = 127 - case com // = 128 - case comma // = 129 - case contentsOf // = 130 - case contiguousBytes // = 131 - case count // = 132 - case countVarintsInBuffer // = 133 - case csharpNamespace // = 134 - case ctype // = 135 - case customCodable // = 136 - case customDebugStringConvertible // = 137 - case d // = 138 - case data // = 139 - case dataResult // = 140 - case date // = 141 - case daySec // = 142 - case daysSinceEpoch // = 143 - case debugDescription_ // = 144 - case decoded // = 145 - case decodedFromJsonnull // = 146 - case decodeExtensionField // = 147 - case decodeExtensionFieldsAsMessageSet // = 148 - case decodeJson // = 149 - case decodeMapField // = 150 - case decodeMessage // = 151 - case decoder // = 152 - case decodeRepeated // = 153 - case decodeRepeatedBoolField // = 154 - case decodeRepeatedBytesField // = 155 - case decodeRepeatedDoubleField // = 156 - case decodeRepeatedEnumField // = 157 - case decodeRepeatedFixed32Field // = 158 - case decodeRepeatedFixed64Field // = 159 - case decodeRepeatedFloatField // = 160 - case decodeRepeatedGroupField // = 161 - case decodeRepeatedInt32Field // = 162 - case decodeRepeatedInt64Field // = 163 - case decodeRepeatedMessageField // = 164 - case decodeRepeatedSfixed32Field // = 165 - case decodeRepeatedSfixed64Field // = 166 - case decodeRepeatedSint32Field // = 167 - case decodeRepeatedSint64Field // = 168 - case decodeRepeatedStringField // = 169 - case decodeRepeatedUint32Field // = 170 - case decodeRepeatedUint64Field // = 171 - case decodeSingular // = 172 - case decodeSingularBoolField // = 173 - case decodeSingularBytesField // = 174 - case decodeSingularDoubleField // = 175 - case decodeSingularEnumField // = 176 - case decodeSingularFixed32Field // = 177 - case decodeSingularFixed64Field // = 178 - case decodeSingularFloatField // = 179 - case decodeSingularGroupField // = 180 - case decodeSingularInt32Field // = 181 - case decodeSingularInt64Field // = 182 - case decodeSingularMessageField // = 183 - case decodeSingularSfixed32Field // = 184 - case decodeSingularSfixed64Field // = 185 - case decodeSingularSint32Field // = 186 - case decodeSingularSint64Field // = 187 - case decodeSingularStringField // = 188 - case decodeSingularUint32Field // = 189 - case decodeSingularUint64Field // = 190 - case decodeTextFormat // = 191 - case defaultAnyTypeUrlprefix // = 192 - case defaultValue // = 193 - case dependency // = 194 - case deprecated // = 195 - case description_ // = 196 - case descriptorProto // = 197 - case dictionary // = 198 - case dictionaryLiteral // = 199 - case digit // = 200 - case digit0 // = 201 - case digit1 // = 202 - case digitCount // = 203 - case digits // = 204 - case digitValue // = 205 - case discardableResult // = 206 - case discardUnknownFields // = 207 - case distance // = 208 - case double // = 209 - case doubleValue // = 210 - case duration // = 211 - case e // = 212 - case element // = 213 - case elements // = 214 - case emitExtensionFieldName // = 215 - case emitFieldName // = 216 - case emitFieldNumber // = 217 - case empty // = 218 - case emptyData // = 219 - case encodeAsBytes // = 220 - case encoded // = 221 - case encodedJsonstring // = 222 - case encodedSize // = 223 - case encodeField // = 224 - case encoder // = 225 - case end // = 226 - case endArray // = 227 - case endMessageField // = 228 - case endObject // = 229 - case endRegularField // = 230 - case `enum` // = 231 - case enumDescriptorProto // = 232 - case enumOptions // = 233 - case enumReservedRange // = 234 - case enumType // = 235 - case enumvalue // = 236 - case enumValueDescriptorProto // = 237 - case enumValueOptions // = 238 - case equatable // = 239 - case error // = 240 - case expressibleByArrayLiteral // = 241 - case expressibleByDictionaryLiteral // = 242 - case ext // = 243 - case extDecoder // = 244 - case extendedGraphemeClusterLiteral // = 245 - case extendedGraphemeClusterLiteralType // = 246 - case extendee // = 247 - case extensibleMessage // = 248 - case `extension` // = 249 - case extensionField // = 250 - case extensionFieldNumber // = 251 - case extensionFieldValueSet // = 252 - case extensionMap // = 253 - case extensionRange // = 254 - case extensionRangeOptions // = 255 - case extensions // = 256 - case extras // = 257 - case f // = 258 - case `false` // = 259 - case field // = 260 - case fieldData // = 261 - case fieldDescriptorProto // = 262 - case fieldMask // = 263 - case fieldName // = 264 - case fieldNameCount // = 265 - case fieldNum // = 266 - case fieldNumber // = 267 - case fieldNumberForProto // = 268 - case fieldOptions // = 269 - case fields // = 270 - case fieldSize // = 271 - case fieldTag // = 272 - case fieldType // = 273 - case file // = 274 - case fileDescriptorProto // = 275 - case fileDescriptorSet // = 276 - case fileName // = 277 - case fileOptions // = 278 - case filter // = 279 - case first // = 280 - case firstItem // = 281 - case float // = 282 - case floatLiteral // = 283 - case floatLiteralType // = 284 - case floatValue // = 285 - case forMessageName // = 286 - case formUnion // = 287 - case forReadingFrom // = 288 - case forTypeURL // = 289 - case forwardParser // = 290 - case forWritingInto // = 291 - case from // = 292 - case fromAscii2 // = 293 - case fromAscii4 // = 294 - case fromByteOffset // = 295 - case fromHexDigit // = 296 - case `func` // = 297 - case g // = 298 - case generatedCodeInfo // = 299 - case get // = 300 - case getExtensionValue // = 301 - case googleapis // = 302 - case googleProtobufAny // = 303 - case googleProtobufApi // = 304 - case googleProtobufBoolValue // = 305 - case googleProtobufBytesValue // = 306 - case googleProtobufDescriptorProto // = 307 - case googleProtobufDoubleValue // = 308 - case googleProtobufDuration // = 309 - case googleProtobufEmpty // = 310 - case googleProtobufEnum // = 311 - case googleProtobufEnumDescriptorProto // = 312 - case googleProtobufEnumOptions // = 313 - case googleProtobufEnumValue // = 314 - case googleProtobufEnumValueDescriptorProto // = 315 - case googleProtobufEnumValueOptions // = 316 - case googleProtobufExtensionRangeOptions // = 317 - case googleProtobufField // = 318 - case googleProtobufFieldDescriptorProto // = 319 - case googleProtobufFieldMask // = 320 - case googleProtobufFieldOptions // = 321 - case googleProtobufFileDescriptorProto // = 322 - case googleProtobufFileDescriptorSet // = 323 - case googleProtobufFileOptions // = 324 - case googleProtobufFloatValue // = 325 - case googleProtobufGeneratedCodeInfo // = 326 - case googleProtobufInt32Value // = 327 - case googleProtobufInt64Value // = 328 - case googleProtobufListValue // = 329 - case googleProtobufMessageOptions // = 330 - case googleProtobufMethod // = 331 - case googleProtobufMethodDescriptorProto // = 332 - case googleProtobufMethodOptions // = 333 - case googleProtobufMixin // = 334 - case googleProtobufNullValue // = 335 - case googleProtobufOneofDescriptorProto // = 336 - case googleProtobufOneofOptions // = 337 - case googleProtobufOption // = 338 - case googleProtobufServiceDescriptorProto // = 339 - case googleProtobufServiceOptions // = 340 - case googleProtobufSourceCodeInfo // = 341 - case googleProtobufSourceContext // = 342 - case googleProtobufStringValue // = 343 - case googleProtobufStruct // = 344 - case googleProtobufSyntax // = 345 - case googleProtobufTimestamp // = 346 - case googleProtobufType // = 347 - case googleProtobufUint32Value // = 348 - case googleProtobufUint64Value // = 349 - case googleProtobufUninterpretedOption // = 350 - case googleProtobufValue // = 351 - case goPackage // = 352 - case group // = 353 - case groupFieldNumberStack // = 354 - case groupSize // = 355 - case h // = 356 - case hadOneofValue // = 357 - case handleConflictingOneOf // = 358 - case hasAggregateValue // = 359 - case hasAllowAlias // = 360 - case hasBegin // = 361 - case hasCcEnableArenas // = 362 - case hasCcGenericServices // = 363 - case hasClientStreaming // = 364 - case hasCsharpNamespace // = 365 - case hasCtype // = 366 - case hasDefaultValue // = 367 - case hasDeprecated // = 368 - case hasDoubleValue // = 369 - case hasEnd // = 370 - case hasExtendee // = 371 - case hasExtensionValue // = 372 - case hasGoPackage // = 373 - case hash // = 374 - case hashable // = 375 - case hasher // = 376 - case hashValue_ // = 377 - case hashVisitor // = 378 - case hasIdempotencyLevel // = 379 - case hasIdentifierValue // = 380 - case hasInputType // = 381 - case hasIsExtension // = 382 - case hasJavaGenerateEqualsAndHash // = 383 - case hasJavaGenericServices // = 384 - case hasJavaMultipleFiles // = 385 - case hasJavaOuterClassname // = 386 - case hasJavaPackage // = 387 - case hasJavaStringCheckUtf8 // = 388 - case hasJsonName // = 389 - case hasJstype // = 390 - case hasLabel // = 391 - case hasLazy // = 392 - case hasLeadingComments // = 393 - case hasMapEntry // = 394 - case hasMessageSetWireFormat // = 395 - case hasName // = 396 - case hasNamePart // = 397 - case hasNegativeIntValue // = 398 - case hasNoStandardDescriptorAccessor // = 399 - case hasNumber // = 400 - case hasObjcClassPrefix // = 401 - case hasOneofIndex // = 402 - case hasOptimizeFor // = 403 - case hasOptions // = 404 - case hasOutputType // = 405 - case hasPackage // = 406 - case hasPacked // = 407 - case hasPhpClassPrefix // = 408 - case hasPhpGenericServices // = 409 - case hasPhpMetadataNamespace // = 410 - case hasPhpNamespace // = 411 - case hasPositiveIntValue // = 412 - case hasProto3Optional // = 413 - case hasPyGenericServices // = 414 - case hasRubyPackage // = 415 - case hasServerStreaming // = 416 - case hasSourceCodeInfo // = 417 - case hasSourceContext // = 418 - case hasSourceFile // = 419 - case hasStart // = 420 - case hasStringValue // = 421 - case hasSwiftPrefix // = 422 - case hasSyntax // = 423 - case hasTrailingComments // = 424 - case hasType // = 425 - case hasTypeName // = 426 - case hasValue // = 427 - case hasWeak // = 428 - case hour // = 429 - case i // = 430 - case idempotencyLevel // = 431 - case identifierValue // = 432 - case `if` // = 433 - case ignoreUnknownFields // = 434 - case index // = 435 - case init_ // = 436 - case `inout` // = 437 - case inputType // = 438 - case insert // = 439 - case int // = 440 - case int32 // = 441 - case int32Value // = 442 - case int64 // = 443 - case int64Value // = 444 - case int8 // = 445 - case integerLiteral // = 446 - case integerLiteralType // = 447 - case intern // = 448 - case `internal` // = 449 - case internalState // = 450 - case into // = 451 - case ints // = 452 - case isA // = 453 - case isEqual // = 454 - case isEqualTo // = 455 - case isExtension // = 456 - case isInitialized // = 457 - case itemTagsEncodedSize // = 458 - case iterator // = 459 - case i2166136261 // = 460 - case javaGenerateEqualsAndHash // = 461 - case javaGenericServices // = 462 - case javaMultipleFiles // = 463 - case javaOuterClassname // = 464 - case javaPackage // = 465 - case javaStringCheckUtf8 // = 466 - case jsondecoder // = 467 - case jsondecodingError // = 468 - case jsondecodingOptions // = 469 - case jsonEncoder // = 470 - case jsonencodingError // = 471 - case jsonencodingOptions // = 472 - case jsonencodingVisitor // = 473 - case jsonmapEncodingVisitor // = 474 - case jsonName // = 475 - case jsonPath // = 476 - case jsonPaths // = 477 - case jsonscanner // = 478 - case jsonString // = 479 - case jsonText // = 480 - case jsonUtf8Data // = 481 - case jstype // = 482 - case k // = 483 - case key // = 484 - case keyField // = 485 - case keyType // = 486 - case kind // = 487 - case l // = 488 - case label // = 489 - case lazy // = 490 - case leadingComments // = 491 - case leadingDetachedComments // = 492 - case length // = 493 - case lessThan // = 494 - case `let` // = 495 - case lhs // = 496 - case list // = 497 - case listOfMessages // = 498 - case listValue // = 499 - case littleEndian // = 500 - case littleEndianBytes // = 501 - case load // = 502 - case localHasher // = 503 - case location // = 504 - case m // = 505 - case major // = 506 - case makeIterator // = 507 - case mapEntry // = 508 - case mapHash // = 509 - case mapKeyType // = 510 - case mapNameResolver // = 511 - case mapToMessages // = 512 - case mapValueType // = 513 - case mapVisitor // = 514 - case mdayStart // = 515 - case merge // = 516 - case message // = 517 - case messageDepthLimit // = 518 - case messageExtension // = 519 - case messageImplementationBase // = 520 - case messageOptions // = 521 - case messageSet // = 522 - case messageSetWireFormat // = 523 - case messageType // = 524 - case method // = 525 - case methodDescriptorProto // = 526 - case methodOptions // = 527 - case methods // = 528 - case minor // = 529 - case mixin // = 530 - case mixins // = 531 - case modifier // = 532 - case modify // = 533 - case month // = 534 - case msgExtension // = 535 - case mutating // = 536 - case n // = 537 - case name // = 538 - case nameDescription // = 539 - case nameMap // = 540 - case namePart // = 541 - case nameResolver // = 542 - case names // = 543 - case nanos // = 544 - case nativeBytes // = 545 - case nativeEndianBytes // = 546 - case negativeIntValue // = 547 - case nestedType // = 548 - case newL // = 549 - case newList // = 550 - case newValue // = 551 - case nextByte // = 552 - case nextFieldNumber // = 553 - case `nil` // = 554 - case nilLiteral // = 555 - case noStandardDescriptorAccessor // = 556 - case nullValue // = 557 - case number // = 558 - case numberValue // = 559 - case objcClassPrefix // = 560 - case of // = 561 - case oneofDecl // = 562 - case oneofDescriptorProto // = 563 - case oneofIndex // = 564 - case oneofOptions // = 565 - case oneofs // = 566 - case oneOfKind // = 567 - case optimizeFor // = 568 - case optimizeMode // = 569 - case option // = 570 - case optionalEnumExtensionField // = 571 - case optionalExtensionField // = 572 - case optionalGroupExtensionField // = 573 - case optionalMessageExtensionField // = 574 - case options // = 575 - case other // = 576 - case others // = 577 - case out // = 578 - case outputType // = 579 - case p // = 580 - case package // = 581 - case packed // = 582 - case packedEnumExtensionField // = 583 - case packedExtensionField // = 584 - case padding // = 585 - case parent // = 586 - case parse // = 587 - case partial // = 588 - case path // = 589 - case paths // = 590 - case payload // = 591 - case payloadSize // = 592 - case phpClassPrefix // = 593 - case phpGenericServices // = 594 - case phpMetadataNamespace // = 595 - case phpNamespace // = 596 - case pointer // = 597 - case pos // = 598 - case positiveIntValue // = 599 - case prefix // = 600 - case preserveProtoFieldNames // = 601 - case preTraverse // = 602 - case printUnknownFields // = 603 - case proto2 // = 604 - case proto3DefaultValue // = 605 - case proto3Optional // = 606 - case protobufApiversionCheck // = 607 - case protobufApiversion2 // = 608 - case protobufBool // = 609 - case protobufBytes // = 610 - case protobufDouble // = 611 - case protobufEnumMap // = 612 - case protobufExtension // = 613 - case protobufFixed32 // = 614 - case protobufFixed64 // = 615 - case protobufFloat // = 616 - case protobufInt32 // = 617 - case protobufInt64 // = 618 - case protobufMap // = 619 - case protobufMessageMap // = 620 - case protobufSfixed32 // = 621 - case protobufSfixed64 // = 622 - case protobufSint32 // = 623 - case protobufSint64 // = 624 - case protobufString // = 625 - case protobufUint32 // = 626 - case protobufUint64 // = 627 - case protobufExtensionFieldValues // = 628 - case protobufFieldNumber // = 629 - case protobufGeneratedIsEqualTo // = 630 - case protobufNameMap // = 631 - case protobufNewField // = 632 - case protobufPackage // = 633 - case `protocol` // = 634 - case protoFieldName // = 635 - case protoMessageName // = 636 - case protoNameProviding // = 637 - case protoPaths // = 638 - case `public` // = 639 - case publicDependency // = 640 - case putBoolValue // = 641 - case putBytesValue // = 642 - case putDoubleValue // = 643 - case putEnumValue // = 644 - case putFixedUint32 // = 645 - case putFixedUint64 // = 646 - case putFloatValue // = 647 - case putInt64 // = 648 - case putStringValue // = 649 - case putUint64 // = 650 - case putUint64Hex // = 651 - case putVarInt // = 652 - case putZigZagVarInt // = 653 - case pyGenericServices // = 654 - case rawChars // = 655 - case rawRepresentable // = 656 - case rawValue_ // = 657 - case read4HexDigits // = 658 - case register // = 659 - case repeatedEnumExtensionField // = 660 - case repeatedExtensionField // = 661 - case repeatedGroupExtensionField // = 662 - case repeatedMessageExtensionField // = 663 - case requestStreaming // = 664 - case requestTypeURL // = 665 - case requiredSize // = 666 - case reservedName // = 667 - case reservedRange // = 668 - case responseStreaming // = 669 - case responseTypeURL // = 670 - case result // = 671 - case `rethrows` // = 672 - case `return` // = 673 - case returnType // = 674 - case revision // = 675 - case rhs // = 676 - case root // = 677 - case rubyPackage // = 678 - case s // = 679 - case sawBackslash // = 680 - case sawSection4Characters // = 681 - case sawSection5Characters // = 682 - case scanner // = 683 - case seconds // = 684 - case self_ // = 685 - case separator // = 686 - case serialize // = 687 - case serializedData // = 688 - case serializedSize // = 689 - case serverStreaming // = 690 - case service // = 691 - case serviceDescriptorProto // = 692 - case serviceOptions // = 693 - case set // = 694 - case setExtensionValue // = 695 - case shift // = 696 - case simpleExtensionMap // = 697 - case sizer // = 698 - case source // = 699 - case sourceCodeInfo // = 700 - case sourceContext // = 701 - case sourceEncoding // = 702 - case sourceFile // = 703 - case span // = 704 - case split // = 705 - case start // = 706 - case startArray // = 707 - case startArrayObject // = 708 - case startField // = 709 - case startIndex // = 710 - case startMessageField // = 711 - case startObject // = 712 - case startRegularField // = 713 - case state // = 714 - case `static` // = 715 - case staticString // = 716 - case storage // = 717 - case string // = 718 - case stringLiteral // = 719 - case stringLiteralType // = 720 - case stringResult // = 721 - case stringValue // = 722 - case `struct` // = 723 - case structValue // = 724 - case subDecoder // = 725 - case `subscript` // = 726 - case subVisitor // = 727 - case swift // = 728 - case swiftPrefix // = 729 - case swiftProtobuf // = 730 - case syntax // = 731 - case t // = 732 - case tag // = 733 - case terminator // = 734 - case testDecoder // = 735 - case text // = 736 - case textDecoder // = 737 - case textFormatDecoder // = 738 - case textFormatDecodingError // = 739 - case textFormatDecodingOptions // = 740 - case textFormatEncodingOptions // = 741 - case textFormatEncodingVisitor // = 742 - case textFormatString // = 743 - case `throws` // = 744 - case timeInterval // = 745 - case timeIntervalSince1970 // = 746 - case timeIntervalSinceReferenceDate // = 747 - case timestamp // = 748 - case total // = 749 - case totalArrayDepth // = 750 - case totalSize // = 751 - case trailingComments // = 752 - case traverse // = 753 - case `true` // = 754 - case `try` // = 755 - case type // = 756 - case `typealias` // = 757 - case typeEnum // = 758 - case typeName // = 759 - case typePrefix // = 760 - case typeStart // = 761 - case typeUnknown // = 762 - case typeURL // = 763 - case uint32 // = 764 - case uint32Value // = 765 - case uint64 // = 766 - case uint64Value // = 767 - case uint8 // = 768 - case unicodeScalarLiteral // = 769 - case unicodeScalarLiteralType // = 770 - case unicodeScalars // = 771 - case unicodeScalarView // = 772 - case uninterpretedOption // = 773 - case union // = 774 - case uniqueStorage // = 775 - case unknown // = 776 - case unknownFields // = 777 - case unknownStorage // = 778 - case unpackTo // = 779 - case unsafeBufferPointer // = 780 - case unsafeMutablePointer // = 781 - case unsafeMutableRawBufferPointer // = 782 - case unsafeMutableRawPointer // = 783 - case unsafeRawBufferPointer // = 784 - case unsafeRawPointer // = 785 - case updatedOptions // = 786 - case url // = 787 - case utf8 // = 788 - case utf8Ptr // = 789 - case utf8ToDouble // = 790 - case utf8View // = 791 - case v // = 792 - case value // = 793 - case valueField // = 794 - case values // = 795 - case valueType // = 796 - case `var` // = 797 - case version // = 798 - case versionString // = 799 - case visitExtensionFields // = 800 - case visitExtensionFieldsAsMessageSet // = 801 - case visitMapField // = 802 - case visitor // = 803 - case visitPacked // = 804 - case visitPackedBoolField // = 805 - case visitPackedDoubleField // = 806 - case visitPackedEnumField // = 807 - case visitPackedFixed32Field // = 808 - case visitPackedFixed64Field // = 809 - case visitPackedFloatField // = 810 - case visitPackedInt32Field // = 811 - case visitPackedInt64Field // = 812 - case visitPackedSfixed32Field // = 813 - case visitPackedSfixed64Field // = 814 - case visitPackedSint32Field // = 815 - case visitPackedSint64Field // = 816 - case visitPackedUint32Field // = 817 - case visitPackedUint64Field // = 818 - case visitRepeated // = 819 - case visitRepeatedBoolField // = 820 - case visitRepeatedBytesField // = 821 - case visitRepeatedDoubleField // = 822 - case visitRepeatedEnumField // = 823 - case visitRepeatedFixed32Field // = 824 - case visitRepeatedFixed64Field // = 825 - case visitRepeatedFloatField // = 826 - case visitRepeatedGroupField // = 827 - case visitRepeatedInt32Field // = 828 - case visitRepeatedInt64Field // = 829 - case visitRepeatedMessageField // = 830 - case visitRepeatedSfixed32Field // = 831 - case visitRepeatedSfixed64Field // = 832 - case visitRepeatedSint32Field // = 833 - case visitRepeatedSint64Field // = 834 - case visitRepeatedStringField // = 835 - case visitRepeatedUint32Field // = 836 - case visitRepeatedUint64Field // = 837 - case visitSingular // = 838 - case visitSingularBoolField // = 839 - case visitSingularBytesField // = 840 - case visitSingularDoubleField // = 841 - case visitSingularEnumField // = 842 - case visitSingularFixed32Field // = 843 - case visitSingularFixed64Field // = 844 - case visitSingularFloatField // = 845 - case visitSingularGroupField // = 846 - case visitSingularInt32Field // = 847 - case visitSingularInt64Field // = 848 - case visitSingularMessageField // = 849 - case visitSingularSfixed32Field // = 850 - case visitSingularSfixed64Field // = 851 - case visitSingularSint32Field // = 852 - case visitSingularSint64Field // = 853 - case visitSingularStringField // = 854 - case visitSingularUint32Field // = 855 - case visitSingularUint64Field // = 856 - case visitUnknown // = 857 - case wasDecoded // = 858 - case weak // = 859 - case weakDependency // = 860 - case `where` // = 861 - case wireFormat // = 862 - case with // = 863 - case withUnsafeBytes // = 864 - case withUnsafeMutableBytes // = 865 - case work // = 866 - case wrappedType // = 867 - case written // = 868 - case yday // = 869 - case UNRECOGNIZED(Int) - - init() { - self = .none - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .none - case 1: self = .adjusted - case 2: self = .aggregateValue - case 3: self = .allCases_ - case 4: self = .allowAlias - case 5: self = .alwaysPrintEnumsAsInts - case 6: self = .annotation - case 7: self = .any - case 8: self = .anyExtensionField - case 9: self = .anyMessageExtension - case 10: self = .anyMessageStorage - case 11: self = .anyUnpackError - case 12: self = .api - case 13: self = .appended - case 14: self = .appendUintHex - case 15: self = .appendUnknown - case 16: self = .areAllInitialized - case 17: self = .array - case 18: self = .arrayDepth - case 19: self = .arrayLiteral - case 20: self = .arraySeparator - case 21: self = .as - case 22: self = .asciiOpenCurlyBracket - case 23: self = .asciiZero - case 24: self = .available - case 25: self = .b - case 26: self = .base64Values - case 27: self = .baseAddress - case 28: self = .baseType - case 29: self = .begin - case 30: self = .binary - case 31: self = .binaryDecoder - case 32: self = .binaryDecodingError - case 33: self = .binaryDecodingOptions - case 34: self = .binaryDelimited - case 35: self = .binaryEncoder - case 36: self = .binaryEncodingError - case 37: self = .binaryEncodingMessageSetSizeVisitor - case 38: self = .binaryEncodingMessageSetVisitor - case 39: self = .binaryEncodingSizeVisitor - case 40: self = .binaryEncodingVisitor - case 41: self = .binaryOptions - case 42: self = .body - case 43: self = .bool - case 44: self = .booleanLiteral - case 45: self = .booleanLiteralType - case 46: self = .boolValue - case 47: self = .bytes - case 48: self = .bytesInGroup - case 49: self = .bytesRead - case 50: self = .bytesValue - case 51: self = .c - case 52: self = .capitalizeNext - case 53: self = .cardinality - case 54: self = .ccEnableArenas - case 55: self = .ccGenericServices - case 56: self = .character - case 57: self = .chars - case 58: self = .class - case 59: self = .clearAggregateValue - case 60: self = .clearAllowAlias - case 61: self = .clearBegin - case 62: self = .clearCcEnableArenas - case 63: self = .clearCcGenericServices - case 64: self = .clearClientStreaming - case 65: self = .clearCsharpNamespace - case 66: self = .clearCtype - case 67: self = .clearDefaultValue - case 68: self = .clearDeprecated - case 69: self = .clearDoubleValue - case 70: self = .clearEnd - case 71: self = .clearExtendee - case 72: self = .clearExtensionValue - case 73: self = .clearGoPackage - case 74: self = .clearIdempotencyLevel - case 75: self = .clearIdentifierValue - case 76: self = .clearInputType - case 77: self = .clearIsExtension - case 78: self = .clearJavaGenerateEqualsAndHash - case 79: self = .clearJavaGenericServices - case 80: self = .clearJavaMultipleFiles - case 81: self = .clearJavaOuterClassname - case 82: self = .clearJavaPackage - case 83: self = .clearJavaStringCheckUtf8 - case 84: self = .clearJsonName - case 85: self = .clearJstype - case 86: self = .clearLabel - case 87: self = .clearLazy - case 88: self = .clearLeadingComments - case 89: self = .clearMapEntry - case 90: self = .clearMessageSetWireFormat - case 91: self = .clearName - case 92: self = .clearNamePart - case 93: self = .clearNegativeIntValue - case 94: self = .clearNoStandardDescriptorAccessor - case 95: self = .clearNumber - case 96: self = .clearObjcClassPrefix - case 97: self = .clearOneofIndex - case 98: self = .clearOptimizeFor - case 99: self = .clearOptions - case 100: self = .clearOutputType - case 101: self = .clearPackage - case 102: self = .clearPacked - case 103: self = .clearPhpClassPrefix - case 104: self = .clearPhpGenericServices - case 105: self = .clearPhpMetadataNamespace - case 106: self = .clearPhpNamespace - case 107: self = .clearPositiveIntValue - case 108: self = .clearProto3Optional - case 109: self = .clearPyGenericServices - case 110: self = .clearRubyPackage - case 111: self = .clearServerStreaming - case 112: self = .clearSourceCodeInfo - case 113: self = .clearSourceContext - case 114: self = .clearSourceFile - case 115: self = .clearStart - case 116: self = .clearStringValue - case 117: self = .clearSwiftPrefix - case 118: self = .clearSyntax - case 119: self = .clearTrailingComments - case 120: self = .clearType - case 121: self = .clearTypeName - case 122: self = .clearValue - case 123: self = .clearWeak - case 124: self = .clientStreaming - case 125: self = .codePoint - case 126: self = .codeUnits - case 127: self = .collection - case 128: self = .com - case 129: self = .comma - case 130: self = .contentsOf - case 131: self = .contiguousBytes - case 132: self = .count - case 133: self = .countVarintsInBuffer - case 134: self = .csharpNamespace - case 135: self = .ctype - case 136: self = .customCodable - case 137: self = .customDebugStringConvertible - case 138: self = .d - case 139: self = .data - case 140: self = .dataResult - case 141: self = .date - case 142: self = .daySec - case 143: self = .daysSinceEpoch - case 144: self = .debugDescription_ - case 145: self = .decoded - case 146: self = .decodedFromJsonnull - case 147: self = .decodeExtensionField - case 148: self = .decodeExtensionFieldsAsMessageSet - case 149: self = .decodeJson - case 150: self = .decodeMapField - case 151: self = .decodeMessage - case 152: self = .decoder - case 153: self = .decodeRepeated - case 154: self = .decodeRepeatedBoolField - case 155: self = .decodeRepeatedBytesField - case 156: self = .decodeRepeatedDoubleField - case 157: self = .decodeRepeatedEnumField - case 158: self = .decodeRepeatedFixed32Field - case 159: self = .decodeRepeatedFixed64Field - case 160: self = .decodeRepeatedFloatField - case 161: self = .decodeRepeatedGroupField - case 162: self = .decodeRepeatedInt32Field - case 163: self = .decodeRepeatedInt64Field - case 164: self = .decodeRepeatedMessageField - case 165: self = .decodeRepeatedSfixed32Field - case 166: self = .decodeRepeatedSfixed64Field - case 167: self = .decodeRepeatedSint32Field - case 168: self = .decodeRepeatedSint64Field - case 169: self = .decodeRepeatedStringField - case 170: self = .decodeRepeatedUint32Field - case 171: self = .decodeRepeatedUint64Field - case 172: self = .decodeSingular - case 173: self = .decodeSingularBoolField - case 174: self = .decodeSingularBytesField - case 175: self = .decodeSingularDoubleField - case 176: self = .decodeSingularEnumField - case 177: self = .decodeSingularFixed32Field - case 178: self = .decodeSingularFixed64Field - case 179: self = .decodeSingularFloatField - case 180: self = .decodeSingularGroupField - case 181: self = .decodeSingularInt32Field - case 182: self = .decodeSingularInt64Field - case 183: self = .decodeSingularMessageField - case 184: self = .decodeSingularSfixed32Field - case 185: self = .decodeSingularSfixed64Field - case 186: self = .decodeSingularSint32Field - case 187: self = .decodeSingularSint64Field - case 188: self = .decodeSingularStringField - case 189: self = .decodeSingularUint32Field - case 190: self = .decodeSingularUint64Field - case 191: self = .decodeTextFormat - case 192: self = .defaultAnyTypeUrlprefix - case 193: self = .defaultValue - case 194: self = .dependency - case 195: self = .deprecated - case 196: self = .description_ - case 197: self = .descriptorProto - case 198: self = .dictionary - case 199: self = .dictionaryLiteral - case 200: self = .digit - case 201: self = .digit0 - case 202: self = .digit1 - case 203: self = .digitCount - case 204: self = .digits - case 205: self = .digitValue - case 206: self = .discardableResult - case 207: self = .discardUnknownFields - case 208: self = .distance - case 209: self = .double - case 210: self = .doubleValue - case 211: self = .duration - case 212: self = .e - case 213: self = .element - case 214: self = .elements - case 215: self = .emitExtensionFieldName - case 216: self = .emitFieldName - case 217: self = .emitFieldNumber - case 218: self = .empty - case 219: self = .emptyData - case 220: self = .encodeAsBytes - case 221: self = .encoded - case 222: self = .encodedJsonstring - case 223: self = .encodedSize - case 224: self = .encodeField - case 225: self = .encoder - case 226: self = .end - case 227: self = .endArray - case 228: self = .endMessageField - case 229: self = .endObject - case 230: self = .endRegularField - case 231: self = .enum - case 232: self = .enumDescriptorProto - case 233: self = .enumOptions - case 234: self = .enumReservedRange - case 235: self = .enumType - case 236: self = .enumvalue - case 237: self = .enumValueDescriptorProto - case 238: self = .enumValueOptions - case 239: self = .equatable - case 240: self = .error - case 241: self = .expressibleByArrayLiteral - case 242: self = .expressibleByDictionaryLiteral - case 243: self = .ext - case 244: self = .extDecoder - case 245: self = .extendedGraphemeClusterLiteral - case 246: self = .extendedGraphemeClusterLiteralType - case 247: self = .extendee - case 248: self = .extensibleMessage - case 249: self = .extension - case 250: self = .extensionField - case 251: self = .extensionFieldNumber - case 252: self = .extensionFieldValueSet - case 253: self = .extensionMap - case 254: self = .extensionRange - case 255: self = .extensionRangeOptions - case 256: self = .extensions - case 257: self = .extras - case 258: self = .f - case 259: self = .false - case 260: self = .field - case 261: self = .fieldData - case 262: self = .fieldDescriptorProto - case 263: self = .fieldMask - case 264: self = .fieldName - case 265: self = .fieldNameCount - case 266: self = .fieldNum - case 267: self = .fieldNumber - case 268: self = .fieldNumberForProto - case 269: self = .fieldOptions - case 270: self = .fields - case 271: self = .fieldSize - case 272: self = .fieldTag - case 273: self = .fieldType - case 274: self = .file - case 275: self = .fileDescriptorProto - case 276: self = .fileDescriptorSet - case 277: self = .fileName - case 278: self = .fileOptions - case 279: self = .filter - case 280: self = .first - case 281: self = .firstItem - case 282: self = .float - case 283: self = .floatLiteral - case 284: self = .floatLiteralType - case 285: self = .floatValue - case 286: self = .forMessageName - case 287: self = .formUnion - case 288: self = .forReadingFrom - case 289: self = .forTypeURL - case 290: self = .forwardParser - case 291: self = .forWritingInto - case 292: self = .from - case 293: self = .fromAscii2 - case 294: self = .fromAscii4 - case 295: self = .fromByteOffset - case 296: self = .fromHexDigit - case 297: self = .func - case 298: self = .g - case 299: self = .generatedCodeInfo - case 300: self = .get - case 301: self = .getExtensionValue - case 302: self = .googleapis - case 303: self = .googleProtobufAny - case 304: self = .googleProtobufApi - case 305: self = .googleProtobufBoolValue - case 306: self = .googleProtobufBytesValue - case 307: self = .googleProtobufDescriptorProto - case 308: self = .googleProtobufDoubleValue - case 309: self = .googleProtobufDuration - case 310: self = .googleProtobufEmpty - case 311: self = .googleProtobufEnum - case 312: self = .googleProtobufEnumDescriptorProto - case 313: self = .googleProtobufEnumOptions - case 314: self = .googleProtobufEnumValue - case 315: self = .googleProtobufEnumValueDescriptorProto - case 316: self = .googleProtobufEnumValueOptions - case 317: self = .googleProtobufExtensionRangeOptions - case 318: self = .googleProtobufField - case 319: self = .googleProtobufFieldDescriptorProto - case 320: self = .googleProtobufFieldMask - case 321: self = .googleProtobufFieldOptions - case 322: self = .googleProtobufFileDescriptorProto - case 323: self = .googleProtobufFileDescriptorSet - case 324: self = .googleProtobufFileOptions - case 325: self = .googleProtobufFloatValue - case 326: self = .googleProtobufGeneratedCodeInfo - case 327: self = .googleProtobufInt32Value - case 328: self = .googleProtobufInt64Value - case 329: self = .googleProtobufListValue - case 330: self = .googleProtobufMessageOptions - case 331: self = .googleProtobufMethod - case 332: self = .googleProtobufMethodDescriptorProto - case 333: self = .googleProtobufMethodOptions - case 334: self = .googleProtobufMixin - case 335: self = .googleProtobufNullValue - case 336: self = .googleProtobufOneofDescriptorProto - case 337: self = .googleProtobufOneofOptions - case 338: self = .googleProtobufOption - case 339: self = .googleProtobufServiceDescriptorProto - case 340: self = .googleProtobufServiceOptions - case 341: self = .googleProtobufSourceCodeInfo - case 342: self = .googleProtobufSourceContext - case 343: self = .googleProtobufStringValue - case 344: self = .googleProtobufStruct - case 345: self = .googleProtobufSyntax - case 346: self = .googleProtobufTimestamp - case 347: self = .googleProtobufType - case 348: self = .googleProtobufUint32Value - case 349: self = .googleProtobufUint64Value - case 350: self = .googleProtobufUninterpretedOption - case 351: self = .googleProtobufValue - case 352: self = .goPackage - case 353: self = .group - case 354: self = .groupFieldNumberStack - case 355: self = .groupSize - case 356: self = .h - case 357: self = .hadOneofValue - case 358: self = .handleConflictingOneOf - case 359: self = .hasAggregateValue - case 360: self = .hasAllowAlias - case 361: self = .hasBegin - case 362: self = .hasCcEnableArenas - case 363: self = .hasCcGenericServices - case 364: self = .hasClientStreaming - case 365: self = .hasCsharpNamespace - case 366: self = .hasCtype - case 367: self = .hasDefaultValue - case 368: self = .hasDeprecated - case 369: self = .hasDoubleValue - case 370: self = .hasEnd - case 371: self = .hasExtendee - case 372: self = .hasExtensionValue - case 373: self = .hasGoPackage - case 374: self = .hash - case 375: self = .hashable - case 376: self = .hasher - case 377: self = .hashValue_ - case 378: self = .hashVisitor - case 379: self = .hasIdempotencyLevel - case 380: self = .hasIdentifierValue - case 381: self = .hasInputType - case 382: self = .hasIsExtension - case 383: self = .hasJavaGenerateEqualsAndHash - case 384: self = .hasJavaGenericServices - case 385: self = .hasJavaMultipleFiles - case 386: self = .hasJavaOuterClassname - case 387: self = .hasJavaPackage - case 388: self = .hasJavaStringCheckUtf8 - case 389: self = .hasJsonName - case 390: self = .hasJstype - case 391: self = .hasLabel - case 392: self = .hasLazy - case 393: self = .hasLeadingComments - case 394: self = .hasMapEntry - case 395: self = .hasMessageSetWireFormat - case 396: self = .hasName - case 397: self = .hasNamePart - case 398: self = .hasNegativeIntValue - case 399: self = .hasNoStandardDescriptorAccessor - case 400: self = .hasNumber - case 401: self = .hasObjcClassPrefix - case 402: self = .hasOneofIndex - case 403: self = .hasOptimizeFor - case 404: self = .hasOptions - case 405: self = .hasOutputType - case 406: self = .hasPackage - case 407: self = .hasPacked - case 408: self = .hasPhpClassPrefix - case 409: self = .hasPhpGenericServices - case 410: self = .hasPhpMetadataNamespace - case 411: self = .hasPhpNamespace - case 412: self = .hasPositiveIntValue - case 413: self = .hasProto3Optional - case 414: self = .hasPyGenericServices - case 415: self = .hasRubyPackage - case 416: self = .hasServerStreaming - case 417: self = .hasSourceCodeInfo - case 418: self = .hasSourceContext - case 419: self = .hasSourceFile - case 420: self = .hasStart - case 421: self = .hasStringValue - case 422: self = .hasSwiftPrefix - case 423: self = .hasSyntax - case 424: self = .hasTrailingComments - case 425: self = .hasType - case 426: self = .hasTypeName - case 427: self = .hasValue - case 428: self = .hasWeak - case 429: self = .hour - case 430: self = .i - case 431: self = .idempotencyLevel - case 432: self = .identifierValue - case 433: self = .if - case 434: self = .ignoreUnknownFields - case 435: self = .index - case 436: self = .init_ - case 437: self = .inout - case 438: self = .inputType - case 439: self = .insert - case 440: self = .int - case 441: self = .int32 - case 442: self = .int32Value - case 443: self = .int64 - case 444: self = .int64Value - case 445: self = .int8 - case 446: self = .integerLiteral - case 447: self = .integerLiteralType - case 448: self = .intern - case 449: self = .internal - case 450: self = .internalState - case 451: self = .into - case 452: self = .ints - case 453: self = .isA - case 454: self = .isEqual - case 455: self = .isEqualTo - case 456: self = .isExtension - case 457: self = .isInitialized - case 458: self = .itemTagsEncodedSize - case 459: self = .iterator - case 460: self = .i2166136261 - case 461: self = .javaGenerateEqualsAndHash - case 462: self = .javaGenericServices - case 463: self = .javaMultipleFiles - case 464: self = .javaOuterClassname - case 465: self = .javaPackage - case 466: self = .javaStringCheckUtf8 - case 467: self = .jsondecoder - case 468: self = .jsondecodingError - case 469: self = .jsondecodingOptions - case 470: self = .jsonEncoder - case 471: self = .jsonencodingError - case 472: self = .jsonencodingOptions - case 473: self = .jsonencodingVisitor - case 474: self = .jsonmapEncodingVisitor - case 475: self = .jsonName - case 476: self = .jsonPath - case 477: self = .jsonPaths - case 478: self = .jsonscanner - case 479: self = .jsonString - case 480: self = .jsonText - case 481: self = .jsonUtf8Data - case 482: self = .jstype - case 483: self = .k - case 484: self = .key - case 485: self = .keyField - case 486: self = .keyType - case 487: self = .kind - case 488: self = .l - case 489: self = .label - case 490: self = .lazy - case 491: self = .leadingComments - case 492: self = .leadingDetachedComments - case 493: self = .length - case 494: self = .lessThan - case 495: self = .let - case 496: self = .lhs - case 497: self = .list - case 498: self = .listOfMessages - case 499: self = .listValue - case 500: self = .littleEndian - case 501: self = .littleEndianBytes - case 502: self = .load - case 503: self = .localHasher - case 504: self = .location - case 505: self = .m - case 506: self = .major - case 507: self = .makeIterator - case 508: self = .mapEntry - case 509: self = .mapHash - case 510: self = .mapKeyType - case 511: self = .mapNameResolver - case 512: self = .mapToMessages - case 513: self = .mapValueType - case 514: self = .mapVisitor - case 515: self = .mdayStart - case 516: self = .merge - case 517: self = .message - case 518: self = .messageDepthLimit - case 519: self = .messageExtension - case 520: self = .messageImplementationBase - case 521: self = .messageOptions - case 522: self = .messageSet - case 523: self = .messageSetWireFormat - case 524: self = .messageType - case 525: self = .method - case 526: self = .methodDescriptorProto - case 527: self = .methodOptions - case 528: self = .methods - case 529: self = .minor - case 530: self = .mixin - case 531: self = .mixins - case 532: self = .modifier - case 533: self = .modify - case 534: self = .month - case 535: self = .msgExtension - case 536: self = .mutating - case 537: self = .n - case 538: self = .name - case 539: self = .nameDescription - case 540: self = .nameMap - case 541: self = .namePart - case 542: self = .nameResolver - case 543: self = .names - case 544: self = .nanos - case 545: self = .nativeBytes - case 546: self = .nativeEndianBytes - case 547: self = .negativeIntValue - case 548: self = .nestedType - case 549: self = .newL - case 550: self = .newList - case 551: self = .newValue - case 552: self = .nextByte - case 553: self = .nextFieldNumber - case 554: self = .nil - case 555: self = .nilLiteral - case 556: self = .noStandardDescriptorAccessor - case 557: self = .nullValue - case 558: self = .number - case 559: self = .numberValue - case 560: self = .objcClassPrefix - case 561: self = .of - case 562: self = .oneofDecl - case 563: self = .oneofDescriptorProto - case 564: self = .oneofIndex - case 565: self = .oneofOptions - case 566: self = .oneofs - case 567: self = .oneOfKind - case 568: self = .optimizeFor - case 569: self = .optimizeMode - case 570: self = .option - case 571: self = .optionalEnumExtensionField - case 572: self = .optionalExtensionField - case 573: self = .optionalGroupExtensionField - case 574: self = .optionalMessageExtensionField - case 575: self = .options - case 576: self = .other - case 577: self = .others - case 578: self = .out - case 579: self = .outputType - case 580: self = .p - case 581: self = .package - case 582: self = .packed - case 583: self = .packedEnumExtensionField - case 584: self = .packedExtensionField - case 585: self = .padding - case 586: self = .parent - case 587: self = .parse - case 588: self = .partial - case 589: self = .path - case 590: self = .paths - case 591: self = .payload - case 592: self = .payloadSize - case 593: self = .phpClassPrefix - case 594: self = .phpGenericServices - case 595: self = .phpMetadataNamespace - case 596: self = .phpNamespace - case 597: self = .pointer - case 598: self = .pos - case 599: self = .positiveIntValue - case 600: self = .prefix - case 601: self = .preserveProtoFieldNames - case 602: self = .preTraverse - case 603: self = .printUnknownFields - case 604: self = .proto2 - case 605: self = .proto3DefaultValue - case 606: self = .proto3Optional - case 607: self = .protobufApiversionCheck - case 608: self = .protobufApiversion2 - case 609: self = .protobufBool - case 610: self = .protobufBytes - case 611: self = .protobufDouble - case 612: self = .protobufEnumMap - case 613: self = .protobufExtension - case 614: self = .protobufFixed32 - case 615: self = .protobufFixed64 - case 616: self = .protobufFloat - case 617: self = .protobufInt32 - case 618: self = .protobufInt64 - case 619: self = .protobufMap - case 620: self = .protobufMessageMap - case 621: self = .protobufSfixed32 - case 622: self = .protobufSfixed64 - case 623: self = .protobufSint32 - case 624: self = .protobufSint64 - case 625: self = .protobufString - case 626: self = .protobufUint32 - case 627: self = .protobufUint64 - case 628: self = .protobufExtensionFieldValues - case 629: self = .protobufFieldNumber - case 630: self = .protobufGeneratedIsEqualTo - case 631: self = .protobufNameMap - case 632: self = .protobufNewField - case 633: self = .protobufPackage - case 634: self = .protocol - case 635: self = .protoFieldName - case 636: self = .protoMessageName - case 637: self = .protoNameProviding - case 638: self = .protoPaths - case 639: self = .public - case 640: self = .publicDependency - case 641: self = .putBoolValue - case 642: self = .putBytesValue - case 643: self = .putDoubleValue - case 644: self = .putEnumValue - case 645: self = .putFixedUint32 - case 646: self = .putFixedUint64 - case 647: self = .putFloatValue - case 648: self = .putInt64 - case 649: self = .putStringValue - case 650: self = .putUint64 - case 651: self = .putUint64Hex - case 652: self = .putVarInt - case 653: self = .putZigZagVarInt - case 654: self = .pyGenericServices - case 655: self = .rawChars - case 656: self = .rawRepresentable - case 657: self = .rawValue_ - case 658: self = .read4HexDigits - case 659: self = .register - case 660: self = .repeatedEnumExtensionField - case 661: self = .repeatedExtensionField - case 662: self = .repeatedGroupExtensionField - case 663: self = .repeatedMessageExtensionField - case 664: self = .requestStreaming - case 665: self = .requestTypeURL - case 666: self = .requiredSize - case 667: self = .reservedName - case 668: self = .reservedRange - case 669: self = .responseStreaming - case 670: self = .responseTypeURL - case 671: self = .result - case 672: self = .rethrows - case 673: self = .return - case 674: self = .returnType - case 675: self = .revision - case 676: self = .rhs - case 677: self = .root - case 678: self = .rubyPackage - case 679: self = .s - case 680: self = .sawBackslash - case 681: self = .sawSection4Characters - case 682: self = .sawSection5Characters - case 683: self = .scanner - case 684: self = .seconds - case 685: self = .self_ - case 686: self = .separator - case 687: self = .serialize - case 688: self = .serializedData - case 689: self = .serializedSize - case 690: self = .serverStreaming - case 691: self = .service - case 692: self = .serviceDescriptorProto - case 693: self = .serviceOptions - case 694: self = .set - case 695: self = .setExtensionValue - case 696: self = .shift - case 697: self = .simpleExtensionMap - case 698: self = .sizer - case 699: self = .source - case 700: self = .sourceCodeInfo - case 701: self = .sourceContext - case 702: self = .sourceEncoding - case 703: self = .sourceFile - case 704: self = .span - case 705: self = .split - case 706: self = .start - case 707: self = .startArray - case 708: self = .startArrayObject - case 709: self = .startField - case 710: self = .startIndex - case 711: self = .startMessageField - case 712: self = .startObject - case 713: self = .startRegularField - case 714: self = .state - case 715: self = .static - case 716: self = .staticString - case 717: self = .storage - case 718: self = .string - case 719: self = .stringLiteral - case 720: self = .stringLiteralType - case 721: self = .stringResult - case 722: self = .stringValue - case 723: self = .struct - case 724: self = .structValue - case 725: self = .subDecoder - case 726: self = .subscript - case 727: self = .subVisitor - case 728: self = .swift - case 729: self = .swiftPrefix - case 730: self = .swiftProtobuf - case 731: self = .syntax - case 732: self = .t - case 733: self = .tag - case 734: self = .terminator - case 735: self = .testDecoder - case 736: self = .text - case 737: self = .textDecoder - case 738: self = .textFormatDecoder - case 739: self = .textFormatDecodingError - case 740: self = .textFormatDecodingOptions - case 741: self = .textFormatEncodingOptions - case 742: self = .textFormatEncodingVisitor - case 743: self = .textFormatString - case 744: self = .throws - case 745: self = .timeInterval - case 746: self = .timeIntervalSince1970 - case 747: self = .timeIntervalSinceReferenceDate - case 748: self = .timestamp - case 749: self = .total - case 750: self = .totalArrayDepth - case 751: self = .totalSize - case 752: self = .trailingComments - case 753: self = .traverse - case 754: self = .true - case 755: self = .try - case 756: self = .type - case 757: self = .typealias - case 758: self = .typeEnum - case 759: self = .typeName - case 760: self = .typePrefix - case 761: self = .typeStart - case 762: self = .typeUnknown - case 763: self = .typeURL - case 764: self = .uint32 - case 765: self = .uint32Value - case 766: self = .uint64 - case 767: self = .uint64Value - case 768: self = .uint8 - case 769: self = .unicodeScalarLiteral - case 770: self = .unicodeScalarLiteralType - case 771: self = .unicodeScalars - case 772: self = .unicodeScalarView - case 773: self = .uninterpretedOption - case 774: self = .union - case 775: self = .uniqueStorage - case 776: self = .unknown - case 777: self = .unknownFields - case 778: self = .unknownStorage - case 779: self = .unpackTo - case 780: self = .unsafeBufferPointer - case 781: self = .unsafeMutablePointer - case 782: self = .unsafeMutableRawBufferPointer - case 783: self = .unsafeMutableRawPointer - case 784: self = .unsafeRawBufferPointer - case 785: self = .unsafeRawPointer - case 786: self = .updatedOptions - case 787: self = .url - case 788: self = .utf8 - case 789: self = .utf8Ptr - case 790: self = .utf8ToDouble - case 791: self = .utf8View - case 792: self = .v - case 793: self = .value - case 794: self = .valueField - case 795: self = .values - case 796: self = .valueType - case 797: self = .var - case 798: self = .version - case 799: self = .versionString - case 800: self = .visitExtensionFields - case 801: self = .visitExtensionFieldsAsMessageSet - case 802: self = .visitMapField - case 803: self = .visitor - case 804: self = .visitPacked - case 805: self = .visitPackedBoolField - case 806: self = .visitPackedDoubleField - case 807: self = .visitPackedEnumField - case 808: self = .visitPackedFixed32Field - case 809: self = .visitPackedFixed64Field - case 810: self = .visitPackedFloatField - case 811: self = .visitPackedInt32Field - case 812: self = .visitPackedInt64Field - case 813: self = .visitPackedSfixed32Field - case 814: self = .visitPackedSfixed64Field - case 815: self = .visitPackedSint32Field - case 816: self = .visitPackedSint64Field - case 817: self = .visitPackedUint32Field - case 818: self = .visitPackedUint64Field - case 819: self = .visitRepeated - case 820: self = .visitRepeatedBoolField - case 821: self = .visitRepeatedBytesField - case 822: self = .visitRepeatedDoubleField - case 823: self = .visitRepeatedEnumField - case 824: self = .visitRepeatedFixed32Field - case 825: self = .visitRepeatedFixed64Field - case 826: self = .visitRepeatedFloatField - case 827: self = .visitRepeatedGroupField - case 828: self = .visitRepeatedInt32Field - case 829: self = .visitRepeatedInt64Field - case 830: self = .visitRepeatedMessageField - case 831: self = .visitRepeatedSfixed32Field - case 832: self = .visitRepeatedSfixed64Field - case 833: self = .visitRepeatedSint32Field - case 834: self = .visitRepeatedSint64Field - case 835: self = .visitRepeatedStringField - case 836: self = .visitRepeatedUint32Field - case 837: self = .visitRepeatedUint64Field - case 838: self = .visitSingular - case 839: self = .visitSingularBoolField - case 840: self = .visitSingularBytesField - case 841: self = .visitSingularDoubleField - case 842: self = .visitSingularEnumField - case 843: self = .visitSingularFixed32Field - case 844: self = .visitSingularFixed64Field - case 845: self = .visitSingularFloatField - case 846: self = .visitSingularGroupField - case 847: self = .visitSingularInt32Field - case 848: self = .visitSingularInt64Field - case 849: self = .visitSingularMessageField - case 850: self = .visitSingularSfixed32Field - case 851: self = .visitSingularSfixed64Field - case 852: self = .visitSingularSint32Field - case 853: self = .visitSingularSint64Field - case 854: self = .visitSingularStringField - case 855: self = .visitSingularUint32Field - case 856: self = .visitSingularUint64Field - case 857: self = .visitUnknown - case 858: self = .wasDecoded - case 859: self = .weak - case 860: self = .weakDependency - case 861: self = .where - case 862: self = .wireFormat - case 863: self = .with - case 864: self = .withUnsafeBytes - case 865: self = .withUnsafeMutableBytes - case 866: self = .work - case 867: self = .wrappedType - case 868: self = .written - case 869: self = .yday - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .none: return 0 - case .adjusted: return 1 - case .aggregateValue: return 2 - case .allCases_: return 3 - case .allowAlias: return 4 - case .alwaysPrintEnumsAsInts: return 5 - case .annotation: return 6 - case .any: return 7 - case .anyExtensionField: return 8 - case .anyMessageExtension: return 9 - case .anyMessageStorage: return 10 - case .anyUnpackError: return 11 - case .api: return 12 - case .appended: return 13 - case .appendUintHex: return 14 - case .appendUnknown: return 15 - case .areAllInitialized: return 16 - case .array: return 17 - case .arrayDepth: return 18 - case .arrayLiteral: return 19 - case .arraySeparator: return 20 - case .as: return 21 - case .asciiOpenCurlyBracket: return 22 - case .asciiZero: return 23 - case .available: return 24 - case .b: return 25 - case .base64Values: return 26 - case .baseAddress: return 27 - case .baseType: return 28 - case .begin: return 29 - case .binary: return 30 - case .binaryDecoder: return 31 - case .binaryDecodingError: return 32 - case .binaryDecodingOptions: return 33 - case .binaryDelimited: return 34 - case .binaryEncoder: return 35 - case .binaryEncodingError: return 36 - case .binaryEncodingMessageSetSizeVisitor: return 37 - case .binaryEncodingMessageSetVisitor: return 38 - case .binaryEncodingSizeVisitor: return 39 - case .binaryEncodingVisitor: return 40 - case .binaryOptions: return 41 - case .body: return 42 - case .bool: return 43 - case .booleanLiteral: return 44 - case .booleanLiteralType: return 45 - case .boolValue: return 46 - case .bytes: return 47 - case .bytesInGroup: return 48 - case .bytesRead: return 49 - case .bytesValue: return 50 - case .c: return 51 - case .capitalizeNext: return 52 - case .cardinality: return 53 - case .ccEnableArenas: return 54 - case .ccGenericServices: return 55 - case .character: return 56 - case .chars: return 57 - case .class: return 58 - case .clearAggregateValue: return 59 - case .clearAllowAlias: return 60 - case .clearBegin: return 61 - case .clearCcEnableArenas: return 62 - case .clearCcGenericServices: return 63 - case .clearClientStreaming: return 64 - case .clearCsharpNamespace: return 65 - case .clearCtype: return 66 - case .clearDefaultValue: return 67 - case .clearDeprecated: return 68 - case .clearDoubleValue: return 69 - case .clearEnd: return 70 - case .clearExtendee: return 71 - case .clearExtensionValue: return 72 - case .clearGoPackage: return 73 - case .clearIdempotencyLevel: return 74 - case .clearIdentifierValue: return 75 - case .clearInputType: return 76 - case .clearIsExtension: return 77 - case .clearJavaGenerateEqualsAndHash: return 78 - case .clearJavaGenericServices: return 79 - case .clearJavaMultipleFiles: return 80 - case .clearJavaOuterClassname: return 81 - case .clearJavaPackage: return 82 - case .clearJavaStringCheckUtf8: return 83 - case .clearJsonName: return 84 - case .clearJstype: return 85 - case .clearLabel: return 86 - case .clearLazy: return 87 - case .clearLeadingComments: return 88 - case .clearMapEntry: return 89 - case .clearMessageSetWireFormat: return 90 - case .clearName: return 91 - case .clearNamePart: return 92 - case .clearNegativeIntValue: return 93 - case .clearNoStandardDescriptorAccessor: return 94 - case .clearNumber: return 95 - case .clearObjcClassPrefix: return 96 - case .clearOneofIndex: return 97 - case .clearOptimizeFor: return 98 - case .clearOptions: return 99 - case .clearOutputType: return 100 - case .clearPackage: return 101 - case .clearPacked: return 102 - case .clearPhpClassPrefix: return 103 - case .clearPhpGenericServices: return 104 - case .clearPhpMetadataNamespace: return 105 - case .clearPhpNamespace: return 106 - case .clearPositiveIntValue: return 107 - case .clearProto3Optional: return 108 - case .clearPyGenericServices: return 109 - case .clearRubyPackage: return 110 - case .clearServerStreaming: return 111 - case .clearSourceCodeInfo: return 112 - case .clearSourceContext: return 113 - case .clearSourceFile: return 114 - case .clearStart: return 115 - case .clearStringValue: return 116 - case .clearSwiftPrefix: return 117 - case .clearSyntax: return 118 - case .clearTrailingComments: return 119 - case .clearType: return 120 - case .clearTypeName: return 121 - case .clearValue: return 122 - case .clearWeak: return 123 - case .clientStreaming: return 124 - case .codePoint: return 125 - case .codeUnits: return 126 - case .collection: return 127 - case .com: return 128 - case .comma: return 129 - case .contentsOf: return 130 - case .contiguousBytes: return 131 - case .count: return 132 - case .countVarintsInBuffer: return 133 - case .csharpNamespace: return 134 - case .ctype: return 135 - case .customCodable: return 136 - case .customDebugStringConvertible: return 137 - case .d: return 138 - case .data: return 139 - case .dataResult: return 140 - case .date: return 141 - case .daySec: return 142 - case .daysSinceEpoch: return 143 - case .debugDescription_: return 144 - case .decoded: return 145 - case .decodedFromJsonnull: return 146 - case .decodeExtensionField: return 147 - case .decodeExtensionFieldsAsMessageSet: return 148 - case .decodeJson: return 149 - case .decodeMapField: return 150 - case .decodeMessage: return 151 - case .decoder: return 152 - case .decodeRepeated: return 153 - case .decodeRepeatedBoolField: return 154 - case .decodeRepeatedBytesField: return 155 - case .decodeRepeatedDoubleField: return 156 - case .decodeRepeatedEnumField: return 157 - case .decodeRepeatedFixed32Field: return 158 - case .decodeRepeatedFixed64Field: return 159 - case .decodeRepeatedFloatField: return 160 - case .decodeRepeatedGroupField: return 161 - case .decodeRepeatedInt32Field: return 162 - case .decodeRepeatedInt64Field: return 163 - case .decodeRepeatedMessageField: return 164 - case .decodeRepeatedSfixed32Field: return 165 - case .decodeRepeatedSfixed64Field: return 166 - case .decodeRepeatedSint32Field: return 167 - case .decodeRepeatedSint64Field: return 168 - case .decodeRepeatedStringField: return 169 - case .decodeRepeatedUint32Field: return 170 - case .decodeRepeatedUint64Field: return 171 - case .decodeSingular: return 172 - case .decodeSingularBoolField: return 173 - case .decodeSingularBytesField: return 174 - case .decodeSingularDoubleField: return 175 - case .decodeSingularEnumField: return 176 - case .decodeSingularFixed32Field: return 177 - case .decodeSingularFixed64Field: return 178 - case .decodeSingularFloatField: return 179 - case .decodeSingularGroupField: return 180 - case .decodeSingularInt32Field: return 181 - case .decodeSingularInt64Field: return 182 - case .decodeSingularMessageField: return 183 - case .decodeSingularSfixed32Field: return 184 - case .decodeSingularSfixed64Field: return 185 - case .decodeSingularSint32Field: return 186 - case .decodeSingularSint64Field: return 187 - case .decodeSingularStringField: return 188 - case .decodeSingularUint32Field: return 189 - case .decodeSingularUint64Field: return 190 - case .decodeTextFormat: return 191 - case .defaultAnyTypeUrlprefix: return 192 - case .defaultValue: return 193 - case .dependency: return 194 - case .deprecated: return 195 - case .description_: return 196 - case .descriptorProto: return 197 - case .dictionary: return 198 - case .dictionaryLiteral: return 199 - case .digit: return 200 - case .digit0: return 201 - case .digit1: return 202 - case .digitCount: return 203 - case .digits: return 204 - case .digitValue: return 205 - case .discardableResult: return 206 - case .discardUnknownFields: return 207 - case .distance: return 208 - case .double: return 209 - case .doubleValue: return 210 - case .duration: return 211 - case .e: return 212 - case .element: return 213 - case .elements: return 214 - case .emitExtensionFieldName: return 215 - case .emitFieldName: return 216 - case .emitFieldNumber: return 217 - case .empty: return 218 - case .emptyData: return 219 - case .encodeAsBytes: return 220 - case .encoded: return 221 - case .encodedJsonstring: return 222 - case .encodedSize: return 223 - case .encodeField: return 224 - case .encoder: return 225 - case .end: return 226 - case .endArray: return 227 - case .endMessageField: return 228 - case .endObject: return 229 - case .endRegularField: return 230 - case .enum: return 231 - case .enumDescriptorProto: return 232 - case .enumOptions: return 233 - case .enumReservedRange: return 234 - case .enumType: return 235 - case .enumvalue: return 236 - case .enumValueDescriptorProto: return 237 - case .enumValueOptions: return 238 - case .equatable: return 239 - case .error: return 240 - case .expressibleByArrayLiteral: return 241 - case .expressibleByDictionaryLiteral: return 242 - case .ext: return 243 - case .extDecoder: return 244 - case .extendedGraphemeClusterLiteral: return 245 - case .extendedGraphemeClusterLiteralType: return 246 - case .extendee: return 247 - case .extensibleMessage: return 248 - case .extension: return 249 - case .extensionField: return 250 - case .extensionFieldNumber: return 251 - case .extensionFieldValueSet: return 252 - case .extensionMap: return 253 - case .extensionRange: return 254 - case .extensionRangeOptions: return 255 - case .extensions: return 256 - case .extras: return 257 - case .f: return 258 - case .false: return 259 - case .field: return 260 - case .fieldData: return 261 - case .fieldDescriptorProto: return 262 - case .fieldMask: return 263 - case .fieldName: return 264 - case .fieldNameCount: return 265 - case .fieldNum: return 266 - case .fieldNumber: return 267 - case .fieldNumberForProto: return 268 - case .fieldOptions: return 269 - case .fields: return 270 - case .fieldSize: return 271 - case .fieldTag: return 272 - case .fieldType: return 273 - case .file: return 274 - case .fileDescriptorProto: return 275 - case .fileDescriptorSet: return 276 - case .fileName: return 277 - case .fileOptions: return 278 - case .filter: return 279 - case .first: return 280 - case .firstItem: return 281 - case .float: return 282 - case .floatLiteral: return 283 - case .floatLiteralType: return 284 - case .floatValue: return 285 - case .forMessageName: return 286 - case .formUnion: return 287 - case .forReadingFrom: return 288 - case .forTypeURL: return 289 - case .forwardParser: return 290 - case .forWritingInto: return 291 - case .from: return 292 - case .fromAscii2: return 293 - case .fromAscii4: return 294 - case .fromByteOffset: return 295 - case .fromHexDigit: return 296 - case .func: return 297 - case .g: return 298 - case .generatedCodeInfo: return 299 - case .get: return 300 - case .getExtensionValue: return 301 - case .googleapis: return 302 - case .googleProtobufAny: return 303 - case .googleProtobufApi: return 304 - case .googleProtobufBoolValue: return 305 - case .googleProtobufBytesValue: return 306 - case .googleProtobufDescriptorProto: return 307 - case .googleProtobufDoubleValue: return 308 - case .googleProtobufDuration: return 309 - case .googleProtobufEmpty: return 310 - case .googleProtobufEnum: return 311 - case .googleProtobufEnumDescriptorProto: return 312 - case .googleProtobufEnumOptions: return 313 - case .googleProtobufEnumValue: return 314 - case .googleProtobufEnumValueDescriptorProto: return 315 - case .googleProtobufEnumValueOptions: return 316 - case .googleProtobufExtensionRangeOptions: return 317 - case .googleProtobufField: return 318 - case .googleProtobufFieldDescriptorProto: return 319 - case .googleProtobufFieldMask: return 320 - case .googleProtobufFieldOptions: return 321 - case .googleProtobufFileDescriptorProto: return 322 - case .googleProtobufFileDescriptorSet: return 323 - case .googleProtobufFileOptions: return 324 - case .googleProtobufFloatValue: return 325 - case .googleProtobufGeneratedCodeInfo: return 326 - case .googleProtobufInt32Value: return 327 - case .googleProtobufInt64Value: return 328 - case .googleProtobufListValue: return 329 - case .googleProtobufMessageOptions: return 330 - case .googleProtobufMethod: return 331 - case .googleProtobufMethodDescriptorProto: return 332 - case .googleProtobufMethodOptions: return 333 - case .googleProtobufMixin: return 334 - case .googleProtobufNullValue: return 335 - case .googleProtobufOneofDescriptorProto: return 336 - case .googleProtobufOneofOptions: return 337 - case .googleProtobufOption: return 338 - case .googleProtobufServiceDescriptorProto: return 339 - case .googleProtobufServiceOptions: return 340 - case .googleProtobufSourceCodeInfo: return 341 - case .googleProtobufSourceContext: return 342 - case .googleProtobufStringValue: return 343 - case .googleProtobufStruct: return 344 - case .googleProtobufSyntax: return 345 - case .googleProtobufTimestamp: return 346 - case .googleProtobufType: return 347 - case .googleProtobufUint32Value: return 348 - case .googleProtobufUint64Value: return 349 - case .googleProtobufUninterpretedOption: return 350 - case .googleProtobufValue: return 351 - case .goPackage: return 352 - case .group: return 353 - case .groupFieldNumberStack: return 354 - case .groupSize: return 355 - case .h: return 356 - case .hadOneofValue: return 357 - case .handleConflictingOneOf: return 358 - case .hasAggregateValue: return 359 - case .hasAllowAlias: return 360 - case .hasBegin: return 361 - case .hasCcEnableArenas: return 362 - case .hasCcGenericServices: return 363 - case .hasClientStreaming: return 364 - case .hasCsharpNamespace: return 365 - case .hasCtype: return 366 - case .hasDefaultValue: return 367 - case .hasDeprecated: return 368 - case .hasDoubleValue: return 369 - case .hasEnd: return 370 - case .hasExtendee: return 371 - case .hasExtensionValue: return 372 - case .hasGoPackage: return 373 - case .hash: return 374 - case .hashable: return 375 - case .hasher: return 376 - case .hashValue_: return 377 - case .hashVisitor: return 378 - case .hasIdempotencyLevel: return 379 - case .hasIdentifierValue: return 380 - case .hasInputType: return 381 - case .hasIsExtension: return 382 - case .hasJavaGenerateEqualsAndHash: return 383 - case .hasJavaGenericServices: return 384 - case .hasJavaMultipleFiles: return 385 - case .hasJavaOuterClassname: return 386 - case .hasJavaPackage: return 387 - case .hasJavaStringCheckUtf8: return 388 - case .hasJsonName: return 389 - case .hasJstype: return 390 - case .hasLabel: return 391 - case .hasLazy: return 392 - case .hasLeadingComments: return 393 - case .hasMapEntry: return 394 - case .hasMessageSetWireFormat: return 395 - case .hasName: return 396 - case .hasNamePart: return 397 - case .hasNegativeIntValue: return 398 - case .hasNoStandardDescriptorAccessor: return 399 - case .hasNumber: return 400 - case .hasObjcClassPrefix: return 401 - case .hasOneofIndex: return 402 - case .hasOptimizeFor: return 403 - case .hasOptions: return 404 - case .hasOutputType: return 405 - case .hasPackage: return 406 - case .hasPacked: return 407 - case .hasPhpClassPrefix: return 408 - case .hasPhpGenericServices: return 409 - case .hasPhpMetadataNamespace: return 410 - case .hasPhpNamespace: return 411 - case .hasPositiveIntValue: return 412 - case .hasProto3Optional: return 413 - case .hasPyGenericServices: return 414 - case .hasRubyPackage: return 415 - case .hasServerStreaming: return 416 - case .hasSourceCodeInfo: return 417 - case .hasSourceContext: return 418 - case .hasSourceFile: return 419 - case .hasStart: return 420 - case .hasStringValue: return 421 - case .hasSwiftPrefix: return 422 - case .hasSyntax: return 423 - case .hasTrailingComments: return 424 - case .hasType: return 425 - case .hasTypeName: return 426 - case .hasValue: return 427 - case .hasWeak: return 428 - case .hour: return 429 - case .i: return 430 - case .idempotencyLevel: return 431 - case .identifierValue: return 432 - case .if: return 433 - case .ignoreUnknownFields: return 434 - case .index: return 435 - case .init_: return 436 - case .inout: return 437 - case .inputType: return 438 - case .insert: return 439 - case .int: return 440 - case .int32: return 441 - case .int32Value: return 442 - case .int64: return 443 - case .int64Value: return 444 - case .int8: return 445 - case .integerLiteral: return 446 - case .integerLiteralType: return 447 - case .intern: return 448 - case .internal: return 449 - case .internalState: return 450 - case .into: return 451 - case .ints: return 452 - case .isA: return 453 - case .isEqual: return 454 - case .isEqualTo: return 455 - case .isExtension: return 456 - case .isInitialized: return 457 - case .itemTagsEncodedSize: return 458 - case .iterator: return 459 - case .i2166136261: return 460 - case .javaGenerateEqualsAndHash: return 461 - case .javaGenericServices: return 462 - case .javaMultipleFiles: return 463 - case .javaOuterClassname: return 464 - case .javaPackage: return 465 - case .javaStringCheckUtf8: return 466 - case .jsondecoder: return 467 - case .jsondecodingError: return 468 - case .jsondecodingOptions: return 469 - case .jsonEncoder: return 470 - case .jsonencodingError: return 471 - case .jsonencodingOptions: return 472 - case .jsonencodingVisitor: return 473 - case .jsonmapEncodingVisitor: return 474 - case .jsonName: return 475 - case .jsonPath: return 476 - case .jsonPaths: return 477 - case .jsonscanner: return 478 - case .jsonString: return 479 - case .jsonText: return 480 - case .jsonUtf8Data: return 481 - case .jstype: return 482 - case .k: return 483 - case .key: return 484 - case .keyField: return 485 - case .keyType: return 486 - case .kind: return 487 - case .l: return 488 - case .label: return 489 - case .lazy: return 490 - case .leadingComments: return 491 - case .leadingDetachedComments: return 492 - case .length: return 493 - case .lessThan: return 494 - case .let: return 495 - case .lhs: return 496 - case .list: return 497 - case .listOfMessages: return 498 - case .listValue: return 499 - default: break - } - switch self { - case .littleEndian: return 500 - case .littleEndianBytes: return 501 - case .load: return 502 - case .localHasher: return 503 - case .location: return 504 - case .m: return 505 - case .major: return 506 - case .makeIterator: return 507 - case .mapEntry: return 508 - case .mapHash: return 509 - case .mapKeyType: return 510 - case .mapNameResolver: return 511 - case .mapToMessages: return 512 - case .mapValueType: return 513 - case .mapVisitor: return 514 - case .mdayStart: return 515 - case .merge: return 516 - case .message: return 517 - case .messageDepthLimit: return 518 - case .messageExtension: return 519 - case .messageImplementationBase: return 520 - case .messageOptions: return 521 - case .messageSet: return 522 - case .messageSetWireFormat: return 523 - case .messageType: return 524 - case .method: return 525 - case .methodDescriptorProto: return 526 - case .methodOptions: return 527 - case .methods: return 528 - case .minor: return 529 - case .mixin: return 530 - case .mixins: return 531 - case .modifier: return 532 - case .modify: return 533 - case .month: return 534 - case .msgExtension: return 535 - case .mutating: return 536 - case .n: return 537 - case .name: return 538 - case .nameDescription: return 539 - case .nameMap: return 540 - case .namePart: return 541 - case .nameResolver: return 542 - case .names: return 543 - case .nanos: return 544 - case .nativeBytes: return 545 - case .nativeEndianBytes: return 546 - case .negativeIntValue: return 547 - case .nestedType: return 548 - case .newL: return 549 - case .newList: return 550 - case .newValue: return 551 - case .nextByte: return 552 - case .nextFieldNumber: return 553 - case .nil: return 554 - case .nilLiteral: return 555 - case .noStandardDescriptorAccessor: return 556 - case .nullValue: return 557 - case .number: return 558 - case .numberValue: return 559 - case .objcClassPrefix: return 560 - case .of: return 561 - case .oneofDecl: return 562 - case .oneofDescriptorProto: return 563 - case .oneofIndex: return 564 - case .oneofOptions: return 565 - case .oneofs: return 566 - case .oneOfKind: return 567 - case .optimizeFor: return 568 - case .optimizeMode: return 569 - case .option: return 570 - case .optionalEnumExtensionField: return 571 - case .optionalExtensionField: return 572 - case .optionalGroupExtensionField: return 573 - case .optionalMessageExtensionField: return 574 - case .options: return 575 - case .other: return 576 - case .others: return 577 - case .out: return 578 - case .outputType: return 579 - case .p: return 580 - case .package: return 581 - case .packed: return 582 - case .packedEnumExtensionField: return 583 - case .packedExtensionField: return 584 - case .padding: return 585 - case .parent: return 586 - case .parse: return 587 - case .partial: return 588 - case .path: return 589 - case .paths: return 590 - case .payload: return 591 - case .payloadSize: return 592 - case .phpClassPrefix: return 593 - case .phpGenericServices: return 594 - case .phpMetadataNamespace: return 595 - case .phpNamespace: return 596 - case .pointer: return 597 - case .pos: return 598 - case .positiveIntValue: return 599 - case .prefix: return 600 - case .preserveProtoFieldNames: return 601 - case .preTraverse: return 602 - case .printUnknownFields: return 603 - case .proto2: return 604 - case .proto3DefaultValue: return 605 - case .proto3Optional: return 606 - case .protobufApiversionCheck: return 607 - case .protobufApiversion2: return 608 - case .protobufBool: return 609 - case .protobufBytes: return 610 - case .protobufDouble: return 611 - case .protobufEnumMap: return 612 - case .protobufExtension: return 613 - case .protobufFixed32: return 614 - case .protobufFixed64: return 615 - case .protobufFloat: return 616 - case .protobufInt32: return 617 - case .protobufInt64: return 618 - case .protobufMap: return 619 - case .protobufMessageMap: return 620 - case .protobufSfixed32: return 621 - case .protobufSfixed64: return 622 - case .protobufSint32: return 623 - case .protobufSint64: return 624 - case .protobufString: return 625 - case .protobufUint32: return 626 - case .protobufUint64: return 627 - case .protobufExtensionFieldValues: return 628 - case .protobufFieldNumber: return 629 - case .protobufGeneratedIsEqualTo: return 630 - case .protobufNameMap: return 631 - case .protobufNewField: return 632 - case .protobufPackage: return 633 - case .protocol: return 634 - case .protoFieldName: return 635 - case .protoMessageName: return 636 - case .protoNameProviding: return 637 - case .protoPaths: return 638 - case .public: return 639 - case .publicDependency: return 640 - case .putBoolValue: return 641 - case .putBytesValue: return 642 - case .putDoubleValue: return 643 - case .putEnumValue: return 644 - case .putFixedUint32: return 645 - case .putFixedUint64: return 646 - case .putFloatValue: return 647 - case .putInt64: return 648 - case .putStringValue: return 649 - case .putUint64: return 650 - case .putUint64Hex: return 651 - case .putVarInt: return 652 - case .putZigZagVarInt: return 653 - case .pyGenericServices: return 654 - case .rawChars: return 655 - case .rawRepresentable: return 656 - case .rawValue_: return 657 - case .read4HexDigits: return 658 - case .register: return 659 - case .repeatedEnumExtensionField: return 660 - case .repeatedExtensionField: return 661 - case .repeatedGroupExtensionField: return 662 - case .repeatedMessageExtensionField: return 663 - case .requestStreaming: return 664 - case .requestTypeURL: return 665 - case .requiredSize: return 666 - case .reservedName: return 667 - case .reservedRange: return 668 - case .responseStreaming: return 669 - case .responseTypeURL: return 670 - case .result: return 671 - case .rethrows: return 672 - case .return: return 673 - case .returnType: return 674 - case .revision: return 675 - case .rhs: return 676 - case .root: return 677 - case .rubyPackage: return 678 - case .s: return 679 - case .sawBackslash: return 680 - case .sawSection4Characters: return 681 - case .sawSection5Characters: return 682 - case .scanner: return 683 - case .seconds: return 684 - case .self_: return 685 - case .separator: return 686 - case .serialize: return 687 - case .serializedData: return 688 - case .serializedSize: return 689 - case .serverStreaming: return 690 - case .service: return 691 - case .serviceDescriptorProto: return 692 - case .serviceOptions: return 693 - case .set: return 694 - case .setExtensionValue: return 695 - case .shift: return 696 - case .simpleExtensionMap: return 697 - case .sizer: return 698 - case .source: return 699 - case .sourceCodeInfo: return 700 - case .sourceContext: return 701 - case .sourceEncoding: return 702 - case .sourceFile: return 703 - case .span: return 704 - case .split: return 705 - case .start: return 706 - case .startArray: return 707 - case .startArrayObject: return 708 - case .startField: return 709 - case .startIndex: return 710 - case .startMessageField: return 711 - case .startObject: return 712 - case .startRegularField: return 713 - case .state: return 714 - case .static: return 715 - case .staticString: return 716 - case .storage: return 717 - case .string: return 718 - case .stringLiteral: return 719 - case .stringLiteralType: return 720 - case .stringResult: return 721 - case .stringValue: return 722 - case .struct: return 723 - case .structValue: return 724 - case .subDecoder: return 725 - case .subscript: return 726 - case .subVisitor: return 727 - case .swift: return 728 - case .swiftPrefix: return 729 - case .swiftProtobuf: return 730 - case .syntax: return 731 - case .t: return 732 - case .tag: return 733 - case .terminator: return 734 - case .testDecoder: return 735 - case .text: return 736 - case .textDecoder: return 737 - case .textFormatDecoder: return 738 - case .textFormatDecodingError: return 739 - case .textFormatDecodingOptions: return 740 - case .textFormatEncodingOptions: return 741 - case .textFormatEncodingVisitor: return 742 - case .textFormatString: return 743 - case .throws: return 744 - case .timeInterval: return 745 - case .timeIntervalSince1970: return 746 - case .timeIntervalSinceReferenceDate: return 747 - case .timestamp: return 748 - case .total: return 749 - case .totalArrayDepth: return 750 - case .totalSize: return 751 - case .trailingComments: return 752 - case .traverse: return 753 - case .true: return 754 - case .try: return 755 - case .type: return 756 - case .typealias: return 757 - case .typeEnum: return 758 - case .typeName: return 759 - case .typePrefix: return 760 - case .typeStart: return 761 - case .typeUnknown: return 762 - case .typeURL: return 763 - case .uint32: return 764 - case .uint32Value: return 765 - case .uint64: return 766 - case .uint64Value: return 767 - case .uint8: return 768 - case .unicodeScalarLiteral: return 769 - case .unicodeScalarLiteralType: return 770 - case .unicodeScalars: return 771 - case .unicodeScalarView: return 772 - case .uninterpretedOption: return 773 - case .union: return 774 - case .uniqueStorage: return 775 - case .unknown: return 776 - case .unknownFields: return 777 - case .unknownStorage: return 778 - case .unpackTo: return 779 - case .unsafeBufferPointer: return 780 - case .unsafeMutablePointer: return 781 - case .unsafeMutableRawBufferPointer: return 782 - case .unsafeMutableRawPointer: return 783 - case .unsafeRawBufferPointer: return 784 - case .unsafeRawPointer: return 785 - case .updatedOptions: return 786 - case .url: return 787 - case .utf8: return 788 - case .utf8Ptr: return 789 - case .utf8ToDouble: return 790 - case .utf8View: return 791 - case .v: return 792 - case .value: return 793 - case .valueField: return 794 - case .values: return 795 - case .valueType: return 796 - case .var: return 797 - case .version: return 798 - case .versionString: return 799 - case .visitExtensionFields: return 800 - case .visitExtensionFieldsAsMessageSet: return 801 - case .visitMapField: return 802 - case .visitor: return 803 - case .visitPacked: return 804 - case .visitPackedBoolField: return 805 - case .visitPackedDoubleField: return 806 - case .visitPackedEnumField: return 807 - case .visitPackedFixed32Field: return 808 - case .visitPackedFixed64Field: return 809 - case .visitPackedFloatField: return 810 - case .visitPackedInt32Field: return 811 - case .visitPackedInt64Field: return 812 - case .visitPackedSfixed32Field: return 813 - case .visitPackedSfixed64Field: return 814 - case .visitPackedSint32Field: return 815 - case .visitPackedSint64Field: return 816 - case .visitPackedUint32Field: return 817 - case .visitPackedUint64Field: return 818 - case .visitRepeated: return 819 - case .visitRepeatedBoolField: return 820 - case .visitRepeatedBytesField: return 821 - case .visitRepeatedDoubleField: return 822 - case .visitRepeatedEnumField: return 823 - case .visitRepeatedFixed32Field: return 824 - case .visitRepeatedFixed64Field: return 825 - case .visitRepeatedFloatField: return 826 - case .visitRepeatedGroupField: return 827 - case .visitRepeatedInt32Field: return 828 - case .visitRepeatedInt64Field: return 829 - case .visitRepeatedMessageField: return 830 - case .visitRepeatedSfixed32Field: return 831 - case .visitRepeatedSfixed64Field: return 832 - case .visitRepeatedSint32Field: return 833 - case .visitRepeatedSint64Field: return 834 - case .visitRepeatedStringField: return 835 - case .visitRepeatedUint32Field: return 836 - case .visitRepeatedUint64Field: return 837 - case .visitSingular: return 838 - case .visitSingularBoolField: return 839 - case .visitSingularBytesField: return 840 - case .visitSingularDoubleField: return 841 - case .visitSingularEnumField: return 842 - case .visitSingularFixed32Field: return 843 - case .visitSingularFixed64Field: return 844 - case .visitSingularFloatField: return 845 - case .visitSingularGroupField: return 846 - case .visitSingularInt32Field: return 847 - case .visitSingularInt64Field: return 848 - case .visitSingularMessageField: return 849 - case .visitSingularSfixed32Field: return 850 - case .visitSingularSfixed64Field: return 851 - case .visitSingularSint32Field: return 852 - case .visitSingularSint64Field: return 853 - case .visitSingularStringField: return 854 - case .visitSingularUint32Field: return 855 - case .visitSingularUint64Field: return 856 - case .visitUnknown: return 857 - case .wasDecoded: return 858 - case .weak: return 859 - case .weakDependency: return 860 - case .where: return 861 - case .wireFormat: return 862 - case .with: return 863 - case .withUnsafeBytes: return 864 - case .withUnsafeMutableBytes: return 865 - case .work: return 866 - case .wrappedType: return 867 - case .written: return 868 - case .yday: return 869 - case .UNRECOGNIZED(let i): return i - default: break - } - - // Can't get here, all the cases are listed in the above switches. - // See https://github.com/apple/swift-protobuf/issues/904 for more details. - fatalError() - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnum] = [ - .none, - .adjusted, - .aggregateValue, - .allCases_, - .allowAlias, - .alwaysPrintEnumsAsInts, - .annotation, - .any, - .anyExtensionField, - .anyMessageExtension, - .anyMessageStorage, - .anyUnpackError, - .api, - .appended, - .appendUintHex, - .appendUnknown, - .areAllInitialized, - .array, - .arrayDepth, - .arrayLiteral, - .arraySeparator, - .as, - .asciiOpenCurlyBracket, - .asciiZero, - .available, - .b, - .base64Values, - .baseAddress, - .baseType, - .begin, - .binary, - .binaryDecoder, - .binaryDecodingError, - .binaryDecodingOptions, - .binaryDelimited, - .binaryEncoder, - .binaryEncodingError, - .binaryEncodingMessageSetSizeVisitor, - .binaryEncodingMessageSetVisitor, - .binaryEncodingSizeVisitor, - .binaryEncodingVisitor, - .binaryOptions, - .body, - .bool, - .booleanLiteral, - .booleanLiteralType, - .boolValue, - .bytes, - .bytesInGroup, - .bytesRead, - .bytesValue, - .c, - .capitalizeNext, - .cardinality, - .ccEnableArenas, - .ccGenericServices, - .character, - .chars, - .class, - .clearAggregateValue, - .clearAllowAlias, - .clearBegin, - .clearCcEnableArenas, - .clearCcGenericServices, - .clearClientStreaming, - .clearCsharpNamespace, - .clearCtype, - .clearDefaultValue, - .clearDeprecated, - .clearDoubleValue, - .clearEnd, - .clearExtendee, - .clearExtensionValue, - .clearGoPackage, - .clearIdempotencyLevel, - .clearIdentifierValue, - .clearInputType, - .clearIsExtension, - .clearJavaGenerateEqualsAndHash, - .clearJavaGenericServices, - .clearJavaMultipleFiles, - .clearJavaOuterClassname, - .clearJavaPackage, - .clearJavaStringCheckUtf8, - .clearJsonName, - .clearJstype, - .clearLabel, - .clearLazy, - .clearLeadingComments, - .clearMapEntry, - .clearMessageSetWireFormat, - .clearName, - .clearNamePart, - .clearNegativeIntValue, - .clearNoStandardDescriptorAccessor, - .clearNumber, - .clearObjcClassPrefix, - .clearOneofIndex, - .clearOptimizeFor, - .clearOptions, - .clearOutputType, - .clearPackage, - .clearPacked, - .clearPhpClassPrefix, - .clearPhpGenericServices, - .clearPhpMetadataNamespace, - .clearPhpNamespace, - .clearPositiveIntValue, - .clearProto3Optional, - .clearPyGenericServices, - .clearRubyPackage, - .clearServerStreaming, - .clearSourceCodeInfo, - .clearSourceContext, - .clearSourceFile, - .clearStart, - .clearStringValue, - .clearSwiftPrefix, - .clearSyntax, - .clearTrailingComments, - .clearType, - .clearTypeName, - .clearValue, - .clearWeak, - .clientStreaming, - .codePoint, - .codeUnits, - .collection, - .com, - .comma, - .contentsOf, - .contiguousBytes, - .count, - .countVarintsInBuffer, - .csharpNamespace, - .ctype, - .customCodable, - .customDebugStringConvertible, - .d, - .data, - .dataResult, - .date, - .daySec, - .daysSinceEpoch, - .debugDescription_, - .decoded, - .decodedFromJsonnull, - .decodeExtensionField, - .decodeExtensionFieldsAsMessageSet, - .decodeJson, - .decodeMapField, - .decodeMessage, - .decoder, - .decodeRepeated, - .decodeRepeatedBoolField, - .decodeRepeatedBytesField, - .decodeRepeatedDoubleField, - .decodeRepeatedEnumField, - .decodeRepeatedFixed32Field, - .decodeRepeatedFixed64Field, - .decodeRepeatedFloatField, - .decodeRepeatedGroupField, - .decodeRepeatedInt32Field, - .decodeRepeatedInt64Field, - .decodeRepeatedMessageField, - .decodeRepeatedSfixed32Field, - .decodeRepeatedSfixed64Field, - .decodeRepeatedSint32Field, - .decodeRepeatedSint64Field, - .decodeRepeatedStringField, - .decodeRepeatedUint32Field, - .decodeRepeatedUint64Field, - .decodeSingular, - .decodeSingularBoolField, - .decodeSingularBytesField, - .decodeSingularDoubleField, - .decodeSingularEnumField, - .decodeSingularFixed32Field, - .decodeSingularFixed64Field, - .decodeSingularFloatField, - .decodeSingularGroupField, - .decodeSingularInt32Field, - .decodeSingularInt64Field, - .decodeSingularMessageField, - .decodeSingularSfixed32Field, - .decodeSingularSfixed64Field, - .decodeSingularSint32Field, - .decodeSingularSint64Field, - .decodeSingularStringField, - .decodeSingularUint32Field, - .decodeSingularUint64Field, - .decodeTextFormat, - .defaultAnyTypeUrlprefix, - .defaultValue, - .dependency, - .deprecated, - .description_, - .descriptorProto, - .dictionary, - .dictionaryLiteral, - .digit, - .digit0, - .digit1, - .digitCount, - .digits, - .digitValue, - .discardableResult, - .discardUnknownFields, - .distance, - .double, - .doubleValue, - .duration, - .e, - .element, - .elements, - .emitExtensionFieldName, - .emitFieldName, - .emitFieldNumber, - .empty, - .emptyData, - .encodeAsBytes, - .encoded, - .encodedJsonstring, - .encodedSize, - .encodeField, - .encoder, - .end, - .endArray, - .endMessageField, - .endObject, - .endRegularField, - .enum, - .enumDescriptorProto, - .enumOptions, - .enumReservedRange, - .enumType, - .enumvalue, - .enumValueDescriptorProto, - .enumValueOptions, - .equatable, - .error, - .expressibleByArrayLiteral, - .expressibleByDictionaryLiteral, - .ext, - .extDecoder, - .extendedGraphemeClusterLiteral, - .extendedGraphemeClusterLiteralType, - .extendee, - .extensibleMessage, - .extension, - .extensionField, - .extensionFieldNumber, - .extensionFieldValueSet, - .extensionMap, - .extensionRange, - .extensionRangeOptions, - .extensions, - .extras, - .f, - .false, - .field, - .fieldData, - .fieldDescriptorProto, - .fieldMask, - .fieldName, - .fieldNameCount, - .fieldNum, - .fieldNumber, - .fieldNumberForProto, - .fieldOptions, - .fields, - .fieldSize, - .fieldTag, - .fieldType, - .file, - .fileDescriptorProto, - .fileDescriptorSet, - .fileName, - .fileOptions, - .filter, - .first, - .firstItem, - .float, - .floatLiteral, - .floatLiteralType, - .floatValue, - .forMessageName, - .formUnion, - .forReadingFrom, - .forTypeURL, - .forwardParser, - .forWritingInto, - .from, - .fromAscii2, - .fromAscii4, - .fromByteOffset, - .fromHexDigit, - .func, - .g, - .generatedCodeInfo, - .get, - .getExtensionValue, - .googleapis, - .googleProtobufAny, - .googleProtobufApi, - .googleProtobufBoolValue, - .googleProtobufBytesValue, - .googleProtobufDescriptorProto, - .googleProtobufDoubleValue, - .googleProtobufDuration, - .googleProtobufEmpty, - .googleProtobufEnum, - .googleProtobufEnumDescriptorProto, - .googleProtobufEnumOptions, - .googleProtobufEnumValue, - .googleProtobufEnumValueDescriptorProto, - .googleProtobufEnumValueOptions, - .googleProtobufExtensionRangeOptions, - .googleProtobufField, - .googleProtobufFieldDescriptorProto, - .googleProtobufFieldMask, - .googleProtobufFieldOptions, - .googleProtobufFileDescriptorProto, - .googleProtobufFileDescriptorSet, - .googleProtobufFileOptions, - .googleProtobufFloatValue, - .googleProtobufGeneratedCodeInfo, - .googleProtobufInt32Value, - .googleProtobufInt64Value, - .googleProtobufListValue, - .googleProtobufMessageOptions, - .googleProtobufMethod, - .googleProtobufMethodDescriptorProto, - .googleProtobufMethodOptions, - .googleProtobufMixin, - .googleProtobufNullValue, - .googleProtobufOneofDescriptorProto, - .googleProtobufOneofOptions, - .googleProtobufOption, - .googleProtobufServiceDescriptorProto, - .googleProtobufServiceOptions, - .googleProtobufSourceCodeInfo, - .googleProtobufSourceContext, - .googleProtobufStringValue, - .googleProtobufStruct, - .googleProtobufSyntax, - .googleProtobufTimestamp, - .googleProtobufType, - .googleProtobufUint32Value, - .googleProtobufUint64Value, - .googleProtobufUninterpretedOption, - .googleProtobufValue, - .goPackage, - .group, - .groupFieldNumberStack, - .groupSize, - .h, - .hadOneofValue, - .handleConflictingOneOf, - .hasAggregateValue, - .hasAllowAlias, - .hasBegin, - .hasCcEnableArenas, - .hasCcGenericServices, - .hasClientStreaming, - .hasCsharpNamespace, - .hasCtype, - .hasDefaultValue, - .hasDeprecated, - .hasDoubleValue, - .hasEnd, - .hasExtendee, - .hasExtensionValue, - .hasGoPackage, - .hash, - .hashable, - .hasher, - .hashValue_, - .hashVisitor, - .hasIdempotencyLevel, - .hasIdentifierValue, - .hasInputType, - .hasIsExtension, - .hasJavaGenerateEqualsAndHash, - .hasJavaGenericServices, - .hasJavaMultipleFiles, - .hasJavaOuterClassname, - .hasJavaPackage, - .hasJavaStringCheckUtf8, - .hasJsonName, - .hasJstype, - .hasLabel, - .hasLazy, - .hasLeadingComments, - .hasMapEntry, - .hasMessageSetWireFormat, - .hasName, - .hasNamePart, - .hasNegativeIntValue, - .hasNoStandardDescriptorAccessor, - .hasNumber, - .hasObjcClassPrefix, - .hasOneofIndex, - .hasOptimizeFor, - .hasOptions, - .hasOutputType, - .hasPackage, - .hasPacked, - .hasPhpClassPrefix, - .hasPhpGenericServices, - .hasPhpMetadataNamespace, - .hasPhpNamespace, - .hasPositiveIntValue, - .hasProto3Optional, - .hasPyGenericServices, - .hasRubyPackage, - .hasServerStreaming, - .hasSourceCodeInfo, - .hasSourceContext, - .hasSourceFile, - .hasStart, - .hasStringValue, - .hasSwiftPrefix, - .hasSyntax, - .hasTrailingComments, - .hasType, - .hasTypeName, - .hasValue, - .hasWeak, - .hour, - .i, - .idempotencyLevel, - .identifierValue, - .if, - .ignoreUnknownFields, - .index, - .init_, - .inout, - .inputType, - .insert, - .int, - .int32, - .int32Value, - .int64, - .int64Value, - .int8, - .integerLiteral, - .integerLiteralType, - .intern, - .internal, - .internalState, - .into, - .ints, - .isA, - .isEqual, - .isEqualTo, - .isExtension, - .isInitialized, - .itemTagsEncodedSize, - .iterator, - .i2166136261, - .javaGenerateEqualsAndHash, - .javaGenericServices, - .javaMultipleFiles, - .javaOuterClassname, - .javaPackage, - .javaStringCheckUtf8, - .jsondecoder, - .jsondecodingError, - .jsondecodingOptions, - .jsonEncoder, - .jsonencodingError, - .jsonencodingOptions, - .jsonencodingVisitor, - .jsonmapEncodingVisitor, - .jsonName, - .jsonPath, - .jsonPaths, - .jsonscanner, - .jsonString, - .jsonText, - .jsonUtf8Data, - .jstype, - .k, - .key, - .keyField, - .keyType, - .kind, - .l, - .label, - .lazy, - .leadingComments, - .leadingDetachedComments, - .length, - .lessThan, - .let, - .lhs, - .list, - .listOfMessages, - .listValue, - .littleEndian, - .littleEndianBytes, - .load, - .localHasher, - .location, - .m, - .major, - .makeIterator, - .mapEntry, - .mapHash, - .mapKeyType, - .mapNameResolver, - .mapToMessages, - .mapValueType, - .mapVisitor, - .mdayStart, - .merge, - .message, - .messageDepthLimit, - .messageExtension, - .messageImplementationBase, - .messageOptions, - .messageSet, - .messageSetWireFormat, - .messageType, - .method, - .methodDescriptorProto, - .methodOptions, - .methods, - .minor, - .mixin, - .mixins, - .modifier, - .modify, - .month, - .msgExtension, - .mutating, - .n, - .name, - .nameDescription, - .nameMap, - .namePart, - .nameResolver, - .names, - .nanos, - .nativeBytes, - .nativeEndianBytes, - .negativeIntValue, - .nestedType, - .newL, - .newList, - .newValue, - .nextByte, - .nextFieldNumber, - .nil, - .nilLiteral, - .noStandardDescriptorAccessor, - .nullValue, - .number, - .numberValue, - .objcClassPrefix, - .of, - .oneofDecl, - .oneofDescriptorProto, - .oneofIndex, - .oneofOptions, - .oneofs, - .oneOfKind, - .optimizeFor, - .optimizeMode, - .option, - .optionalEnumExtensionField, - .optionalExtensionField, - .optionalGroupExtensionField, - .optionalMessageExtensionField, - .options, - .other, - .others, - .out, - .outputType, - .p, - .package, - .packed, - .packedEnumExtensionField, - .packedExtensionField, - .padding, - .parent, - .parse, - .partial, - .path, - .paths, - .payload, - .payloadSize, - .phpClassPrefix, - .phpGenericServices, - .phpMetadataNamespace, - .phpNamespace, - .pointer, - .pos, - .positiveIntValue, - .prefix, - .preserveProtoFieldNames, - .preTraverse, - .printUnknownFields, - .proto2, - .proto3DefaultValue, - .proto3Optional, - .protobufApiversionCheck, - .protobufApiversion2, - .protobufBool, - .protobufBytes, - .protobufDouble, - .protobufEnumMap, - .protobufExtension, - .protobufFixed32, - .protobufFixed64, - .protobufFloat, - .protobufInt32, - .protobufInt64, - .protobufMap, - .protobufMessageMap, - .protobufSfixed32, - .protobufSfixed64, - .protobufSint32, - .protobufSint64, - .protobufString, - .protobufUint32, - .protobufUint64, - .protobufExtensionFieldValues, - .protobufFieldNumber, - .protobufGeneratedIsEqualTo, - .protobufNameMap, - .protobufNewField, - .protobufPackage, - .protocol, - .protoFieldName, - .protoMessageName, - .protoNameProviding, - .protoPaths, - .public, - .publicDependency, - .putBoolValue, - .putBytesValue, - .putDoubleValue, - .putEnumValue, - .putFixedUint32, - .putFixedUint64, - .putFloatValue, - .putInt64, - .putStringValue, - .putUint64, - .putUint64Hex, - .putVarInt, - .putZigZagVarInt, - .pyGenericServices, - .rawChars, - .rawRepresentable, - .rawValue_, - .read4HexDigits, - .register, - .repeatedEnumExtensionField, - .repeatedExtensionField, - .repeatedGroupExtensionField, - .repeatedMessageExtensionField, - .requestStreaming, - .requestTypeURL, - .requiredSize, - .reservedName, - .reservedRange, - .responseStreaming, - .responseTypeURL, - .result, - .rethrows, - .return, - .returnType, - .revision, - .rhs, - .root, - .rubyPackage, - .s, - .sawBackslash, - .sawSection4Characters, - .sawSection5Characters, - .scanner, - .seconds, - .self_, - .separator, - .serialize, - .serializedData, - .serializedSize, - .serverStreaming, - .service, - .serviceDescriptorProto, - .serviceOptions, - .set, - .setExtensionValue, - .shift, - .simpleExtensionMap, - .sizer, - .source, - .sourceCodeInfo, - .sourceContext, - .sourceEncoding, - .sourceFile, - .span, - .split, - .start, - .startArray, - .startArrayObject, - .startField, - .startIndex, - .startMessageField, - .startObject, - .startRegularField, - .state, - .static, - .staticString, - .storage, - .string, - .stringLiteral, - .stringLiteralType, - .stringResult, - .stringValue, - .struct, - .structValue, - .subDecoder, - .subscript, - .subVisitor, - .swift, - .swiftPrefix, - .swiftProtobuf, - .syntax, - .t, - .tag, - .terminator, - .testDecoder, - .text, - .textDecoder, - .textFormatDecoder, - .textFormatDecodingError, - .textFormatDecodingOptions, - .textFormatEncodingOptions, - .textFormatEncodingVisitor, - .textFormatString, - .throws, - .timeInterval, - .timeIntervalSince1970, - .timeIntervalSinceReferenceDate, - .timestamp, - .total, - .totalArrayDepth, - .totalSize, - .trailingComments, - .traverse, - .true, - .try, - .type, - .typealias, - .typeEnum, - .typeName, - .typePrefix, - .typeStart, - .typeUnknown, - .typeURL, - .uint32, - .uint32Value, - .uint64, - .uint64Value, - .uint8, - .unicodeScalarLiteral, - .unicodeScalarLiteralType, - .unicodeScalars, - .unicodeScalarView, - .uninterpretedOption, - .union, - .uniqueStorage, - .unknown, - .unknownFields, - .unknownStorage, - .unpackTo, - .unsafeBufferPointer, - .unsafeMutablePointer, - .unsafeMutableRawBufferPointer, - .unsafeMutableRawPointer, - .unsafeRawBufferPointer, - .unsafeRawPointer, - .updatedOptions, - .url, - .utf8, - .utf8Ptr, - .utf8ToDouble, - .utf8View, - .v, - .value, - .valueField, - .values, - .valueType, - .var, - .version, - .versionString, - .visitExtensionFields, - .visitExtensionFieldsAsMessageSet, - .visitMapField, - .visitor, - .visitPacked, - .visitPackedBoolField, - .visitPackedDoubleField, - .visitPackedEnumField, - .visitPackedFixed32Field, - .visitPackedFixed64Field, - .visitPackedFloatField, - .visitPackedInt32Field, - .visitPackedInt64Field, - .visitPackedSfixed32Field, - .visitPackedSfixed64Field, - .visitPackedSint32Field, - .visitPackedSint64Field, - .visitPackedUint32Field, - .visitPackedUint64Field, - .visitRepeated, - .visitRepeatedBoolField, - .visitRepeatedBytesField, - .visitRepeatedDoubleField, - .visitRepeatedEnumField, - .visitRepeatedFixed32Field, - .visitRepeatedFixed64Field, - .visitRepeatedFloatField, - .visitRepeatedGroupField, - .visitRepeatedInt32Field, - .visitRepeatedInt64Field, - .visitRepeatedMessageField, - .visitRepeatedSfixed32Field, - .visitRepeatedSfixed64Field, - .visitRepeatedSint32Field, - .visitRepeatedSint64Field, - .visitRepeatedStringField, - .visitRepeatedUint32Field, - .visitRepeatedUint64Field, - .visitSingular, - .visitSingularBoolField, - .visitSingularBytesField, - .visitSingularDoubleField, - .visitSingularEnumField, - .visitSingularFixed32Field, - .visitSingularFixed64Field, - .visitSingularFloatField, - .visitSingularGroupField, - .visitSingularInt32Field, - .visitSingularInt64Field, - .visitSingularMessageField, - .visitSingularSfixed32Field, - .visitSingularSfixed64Field, - .visitSingularSint32Field, - .visitSingularSint64Field, - .visitSingularStringField, - .visitSingularUint32Field, - .visitSingularUint64Field, - .visitUnknown, - .wasDecoded, - .weak, - .weakDependency, - .where, - .wireFormat, - .with, - .withUnsafeBytes, - .withUnsafeMutableBytes, - .work, - .wrappedType, - .written, - .yday, - ] -} - -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE"), - 1: .same(proto: "adjusted"), - 2: .same(proto: "aggregateValue"), - 3: .same(proto: "allCases"), - 4: .same(proto: "allowAlias"), - 5: .same(proto: "alwaysPrintEnumsAsInts"), - 6: .same(proto: "annotation"), - 7: .same(proto: "any"), - 8: .same(proto: "AnyExtensionField"), - 9: .same(proto: "AnyMessageExtension"), - 10: .same(proto: "AnyMessageStorage"), - 11: .same(proto: "AnyUnpackError"), - 12: .same(proto: "Api"), - 13: .same(proto: "appended"), - 14: .same(proto: "appendUIntHex"), - 15: .same(proto: "appendUnknown"), - 16: .same(proto: "areAllInitialized"), - 17: .same(proto: "array"), - 18: .same(proto: "arrayDepth"), - 19: .same(proto: "arrayLiteral"), - 20: .same(proto: "arraySeparator"), - 21: .same(proto: "as"), - 22: .same(proto: "asciiOpenCurlyBracket"), - 23: .same(proto: "asciiZero"), - 24: .same(proto: "available"), - 25: .same(proto: "b"), - 26: .same(proto: "base64Values"), - 27: .same(proto: "baseAddress"), - 28: .same(proto: "BaseType"), - 29: .same(proto: "begin"), - 30: .same(proto: "binary"), - 31: .same(proto: "BinaryDecoder"), - 32: .same(proto: "BinaryDecodingError"), - 33: .same(proto: "BinaryDecodingOptions"), - 34: .same(proto: "BinaryDelimited"), - 35: .same(proto: "BinaryEncoder"), - 36: .same(proto: "BinaryEncodingError"), - 37: .same(proto: "BinaryEncodingMessageSetSizeVisitor"), - 38: .same(proto: "BinaryEncodingMessageSetVisitor"), - 39: .same(proto: "BinaryEncodingSizeVisitor"), - 40: .same(proto: "BinaryEncodingVisitor"), - 41: .same(proto: "binaryOptions"), - 42: .same(proto: "body"), - 43: .same(proto: "Bool"), - 44: .same(proto: "booleanLiteral"), - 45: .same(proto: "BooleanLiteralType"), - 46: .same(proto: "boolValue"), - 47: .same(proto: "bytes"), - 48: .same(proto: "bytesInGroup"), - 49: .same(proto: "bytesRead"), - 50: .same(proto: "BytesValue"), - 51: .same(proto: "c"), - 52: .same(proto: "capitalizeNext"), - 53: .same(proto: "cardinality"), - 54: .same(proto: "ccEnableArenas"), - 55: .same(proto: "ccGenericServices"), - 56: .same(proto: "Character"), - 57: .same(proto: "chars"), - 58: .same(proto: "class"), - 59: .same(proto: "clearAggregateValue"), - 60: .same(proto: "clearAllowAlias"), - 61: .same(proto: "clearBegin"), - 62: .same(proto: "clearCcEnableArenas"), - 63: .same(proto: "clearCcGenericServices"), - 64: .same(proto: "clearClientStreaming"), - 65: .same(proto: "clearCsharpNamespace"), - 66: .same(proto: "clearCtype"), - 67: .same(proto: "clearDefaultValue"), - 68: .same(proto: "clearDeprecated"), - 69: .same(proto: "clearDoubleValue"), - 70: .same(proto: "clearEnd"), - 71: .same(proto: "clearExtendee"), - 72: .same(proto: "clearExtensionValue"), - 73: .same(proto: "clearGoPackage"), - 74: .same(proto: "clearIdempotencyLevel"), - 75: .same(proto: "clearIdentifierValue"), - 76: .same(proto: "clearInputType"), - 77: .same(proto: "clearIsExtension"), - 78: .same(proto: "clearJavaGenerateEqualsAndHash"), - 79: .same(proto: "clearJavaGenericServices"), - 80: .same(proto: "clearJavaMultipleFiles"), - 81: .same(proto: "clearJavaOuterClassname"), - 82: .same(proto: "clearJavaPackage"), - 83: .same(proto: "clearJavaStringCheckUtf8"), - 84: .same(proto: "clearJsonName"), - 85: .same(proto: "clearJstype"), - 86: .same(proto: "clearLabel"), - 87: .same(proto: "clearLazy"), - 88: .same(proto: "clearLeadingComments"), - 89: .same(proto: "clearMapEntry"), - 90: .same(proto: "clearMessageSetWireFormat"), - 91: .same(proto: "clearName"), - 92: .same(proto: "clearNamePart"), - 93: .same(proto: "clearNegativeIntValue"), - 94: .same(proto: "clearNoStandardDescriptorAccessor"), - 95: .same(proto: "clearNumber"), - 96: .same(proto: "clearObjcClassPrefix"), - 97: .same(proto: "clearOneofIndex"), - 98: .same(proto: "clearOptimizeFor"), - 99: .same(proto: "clearOptions"), - 100: .same(proto: "clearOutputType"), - 101: .same(proto: "clearPackage"), - 102: .same(proto: "clearPacked"), - 103: .same(proto: "clearPhpClassPrefix"), - 104: .same(proto: "clearPhpGenericServices"), - 105: .same(proto: "clearPhpMetadataNamespace"), - 106: .same(proto: "clearPhpNamespace"), - 107: .same(proto: "clearPositiveIntValue"), - 108: .same(proto: "clearProto3Optional"), - 109: .same(proto: "clearPyGenericServices"), - 110: .same(proto: "clearRubyPackage"), - 111: .same(proto: "clearServerStreaming"), - 112: .same(proto: "clearSourceCodeInfo"), - 113: .same(proto: "clearSourceContext"), - 114: .same(proto: "clearSourceFile"), - 115: .same(proto: "clearStart"), - 116: .same(proto: "clearStringValue"), - 117: .same(proto: "clearSwiftPrefix"), - 118: .same(proto: "clearSyntax"), - 119: .same(proto: "clearTrailingComments"), - 120: .same(proto: "clearType"), - 121: .same(proto: "clearTypeName"), - 122: .same(proto: "clearValue"), - 123: .same(proto: "clearWeak"), - 124: .same(proto: "clientStreaming"), - 125: .same(proto: "codePoint"), - 126: .same(proto: "codeUnits"), - 127: .same(proto: "Collection"), - 128: .same(proto: "com"), - 129: .same(proto: "comma"), - 130: .same(proto: "contentsOf"), - 131: .same(proto: "ContiguousBytes"), - 132: .same(proto: "count"), - 133: .same(proto: "countVarintsInBuffer"), - 134: .same(proto: "csharpNamespace"), - 135: .same(proto: "ctype"), - 136: .same(proto: "customCodable"), - 137: .same(proto: "CustomDebugStringConvertible"), - 138: .same(proto: "d"), - 139: .same(proto: "Data"), - 140: .same(proto: "dataResult"), - 141: .same(proto: "date"), - 142: .same(proto: "daySec"), - 143: .same(proto: "daysSinceEpoch"), - 144: .same(proto: "debugDescription"), - 145: .same(proto: "decoded"), - 146: .same(proto: "decodedFromJSONNull"), - 147: .same(proto: "decodeExtensionField"), - 148: .same(proto: "decodeExtensionFieldsAsMessageSet"), - 149: .same(proto: "decodeJSON"), - 150: .same(proto: "decodeMapField"), - 151: .same(proto: "decodeMessage"), - 152: .same(proto: "decoder"), - 153: .same(proto: "decodeRepeated"), - 154: .same(proto: "decodeRepeatedBoolField"), - 155: .same(proto: "decodeRepeatedBytesField"), - 156: .same(proto: "decodeRepeatedDoubleField"), - 157: .same(proto: "decodeRepeatedEnumField"), - 158: .same(proto: "decodeRepeatedFixed32Field"), - 159: .same(proto: "decodeRepeatedFixed64Field"), - 160: .same(proto: "decodeRepeatedFloatField"), - 161: .same(proto: "decodeRepeatedGroupField"), - 162: .same(proto: "decodeRepeatedInt32Field"), - 163: .same(proto: "decodeRepeatedInt64Field"), - 164: .same(proto: "decodeRepeatedMessageField"), - 165: .same(proto: "decodeRepeatedSFixed32Field"), - 166: .same(proto: "decodeRepeatedSFixed64Field"), - 167: .same(proto: "decodeRepeatedSInt32Field"), - 168: .same(proto: "decodeRepeatedSInt64Field"), - 169: .same(proto: "decodeRepeatedStringField"), - 170: .same(proto: "decodeRepeatedUInt32Field"), - 171: .same(proto: "decodeRepeatedUInt64Field"), - 172: .same(proto: "decodeSingular"), - 173: .same(proto: "decodeSingularBoolField"), - 174: .same(proto: "decodeSingularBytesField"), - 175: .same(proto: "decodeSingularDoubleField"), - 176: .same(proto: "decodeSingularEnumField"), - 177: .same(proto: "decodeSingularFixed32Field"), - 178: .same(proto: "decodeSingularFixed64Field"), - 179: .same(proto: "decodeSingularFloatField"), - 180: .same(proto: "decodeSingularGroupField"), - 181: .same(proto: "decodeSingularInt32Field"), - 182: .same(proto: "decodeSingularInt64Field"), - 183: .same(proto: "decodeSingularMessageField"), - 184: .same(proto: "decodeSingularSFixed32Field"), - 185: .same(proto: "decodeSingularSFixed64Field"), - 186: .same(proto: "decodeSingularSInt32Field"), - 187: .same(proto: "decodeSingularSInt64Field"), - 188: .same(proto: "decodeSingularStringField"), - 189: .same(proto: "decodeSingularUInt32Field"), - 190: .same(proto: "decodeSingularUInt64Field"), - 191: .same(proto: "decodeTextFormat"), - 192: .same(proto: "defaultAnyTypeURLPrefix"), - 193: .same(proto: "defaultValue"), - 194: .same(proto: "dependency"), - 195: .same(proto: "deprecated"), - 196: .same(proto: "description"), - 197: .same(proto: "DescriptorProto"), - 198: .same(proto: "Dictionary"), - 199: .same(proto: "dictionaryLiteral"), - 200: .same(proto: "digit"), - 201: .same(proto: "digit0"), - 202: .same(proto: "digit1"), - 203: .same(proto: "digitCount"), - 204: .same(proto: "digits"), - 205: .same(proto: "digitValue"), - 206: .same(proto: "discardableResult"), - 207: .same(proto: "discardUnknownFields"), - 208: .same(proto: "distance"), - 209: .same(proto: "double"), - 210: .same(proto: "doubleValue"), - 211: .same(proto: "Duration"), - 212: .same(proto: "E"), - 213: .same(proto: "Element"), - 214: .same(proto: "elements"), - 215: .same(proto: "emitExtensionFieldName"), - 216: .same(proto: "emitFieldName"), - 217: .same(proto: "emitFieldNumber"), - 218: .same(proto: "Empty"), - 219: .same(proto: "emptyData"), - 220: .same(proto: "encodeAsBytes"), - 221: .same(proto: "encoded"), - 222: .same(proto: "encodedJSONString"), - 223: .same(proto: "encodedSize"), - 224: .same(proto: "encodeField"), - 225: .same(proto: "encoder"), - 226: .same(proto: "end"), - 227: .same(proto: "endArray"), - 228: .same(proto: "endMessageField"), - 229: .same(proto: "endObject"), - 230: .same(proto: "endRegularField"), - 231: .same(proto: "enum"), - 232: .same(proto: "EnumDescriptorProto"), - 233: .same(proto: "EnumOptions"), - 234: .same(proto: "EnumReservedRange"), - 235: .same(proto: "enumType"), - 236: .same(proto: "enumvalue"), - 237: .same(proto: "EnumValueDescriptorProto"), - 238: .same(proto: "EnumValueOptions"), - 239: .same(proto: "Equatable"), - 240: .same(proto: "Error"), - 241: .same(proto: "ExpressibleByArrayLiteral"), - 242: .same(proto: "ExpressibleByDictionaryLiteral"), - 243: .same(proto: "ext"), - 244: .same(proto: "extDecoder"), - 245: .same(proto: "extendedGraphemeClusterLiteral"), - 246: .same(proto: "ExtendedGraphemeClusterLiteralType"), - 247: .same(proto: "extendee"), - 248: .same(proto: "ExtensibleMessage"), - 249: .same(proto: "extension"), - 250: .same(proto: "ExtensionField"), - 251: .same(proto: "extensionFieldNumber"), - 252: .same(proto: "ExtensionFieldValueSet"), - 253: .same(proto: "ExtensionMap"), - 254: .same(proto: "extensionRange"), - 255: .same(proto: "ExtensionRangeOptions"), - 256: .same(proto: "extensions"), - 257: .same(proto: "extras"), - 258: .same(proto: "F"), - 259: .same(proto: "false"), - 260: .same(proto: "field"), - 261: .same(proto: "fieldData"), - 262: .same(proto: "FieldDescriptorProto"), - 263: .same(proto: "FieldMask"), - 264: .same(proto: "fieldName"), - 265: .same(proto: "fieldNameCount"), - 266: .same(proto: "fieldNum"), - 267: .same(proto: "fieldNumber"), - 268: .same(proto: "fieldNumberForProto"), - 269: .same(proto: "FieldOptions"), - 270: .same(proto: "fields"), - 271: .same(proto: "fieldSize"), - 272: .same(proto: "FieldTag"), - 273: .same(proto: "fieldType"), - 274: .same(proto: "file"), - 275: .same(proto: "FileDescriptorProto"), - 276: .same(proto: "FileDescriptorSet"), - 277: .same(proto: "fileName"), - 278: .same(proto: "FileOptions"), - 279: .same(proto: "filter"), - 280: .same(proto: "first"), - 281: .same(proto: "firstItem"), - 282: .same(proto: "float"), - 283: .same(proto: "floatLiteral"), - 284: .same(proto: "FloatLiteralType"), - 285: .same(proto: "FloatValue"), - 286: .same(proto: "forMessageName"), - 287: .same(proto: "formUnion"), - 288: .same(proto: "forReadingFrom"), - 289: .same(proto: "forTypeURL"), - 290: .same(proto: "ForwardParser"), - 291: .same(proto: "forWritingInto"), - 292: .same(proto: "from"), - 293: .same(proto: "fromAscii2"), - 294: .same(proto: "fromAscii4"), - 295: .same(proto: "fromByteOffset"), - 296: .same(proto: "fromHexDigit"), - 297: .same(proto: "func"), - 298: .same(proto: "G"), - 299: .same(proto: "GeneratedCodeInfo"), - 300: .same(proto: "get"), - 301: .same(proto: "getExtensionValue"), - 302: .same(proto: "googleapis"), - 303: .same(proto: "Google_Protobuf_Any"), - 304: .same(proto: "Google_Protobuf_Api"), - 305: .same(proto: "Google_Protobuf_BoolValue"), - 306: .same(proto: "Google_Protobuf_BytesValue"), - 307: .same(proto: "Google_Protobuf_DescriptorProto"), - 308: .same(proto: "Google_Protobuf_DoubleValue"), - 309: .same(proto: "Google_Protobuf_Duration"), - 310: .same(proto: "Google_Protobuf_Empty"), - 311: .same(proto: "Google_Protobuf_Enum"), - 312: .same(proto: "Google_Protobuf_EnumDescriptorProto"), - 313: .same(proto: "Google_Protobuf_EnumOptions"), - 314: .same(proto: "Google_Protobuf_EnumValue"), - 315: .same(proto: "Google_Protobuf_EnumValueDescriptorProto"), - 316: .same(proto: "Google_Protobuf_EnumValueOptions"), - 317: .same(proto: "Google_Protobuf_ExtensionRangeOptions"), - 318: .same(proto: "Google_Protobuf_Field"), - 319: .same(proto: "Google_Protobuf_FieldDescriptorProto"), - 320: .same(proto: "Google_Protobuf_FieldMask"), - 321: .same(proto: "Google_Protobuf_FieldOptions"), - 322: .same(proto: "Google_Protobuf_FileDescriptorProto"), - 323: .same(proto: "Google_Protobuf_FileDescriptorSet"), - 324: .same(proto: "Google_Protobuf_FileOptions"), - 325: .same(proto: "Google_Protobuf_FloatValue"), - 326: .same(proto: "Google_Protobuf_GeneratedCodeInfo"), - 327: .same(proto: "Google_Protobuf_Int32Value"), - 328: .same(proto: "Google_Protobuf_Int64Value"), - 329: .same(proto: "Google_Protobuf_ListValue"), - 330: .same(proto: "Google_Protobuf_MessageOptions"), - 331: .same(proto: "Google_Protobuf_Method"), - 332: .same(proto: "Google_Protobuf_MethodDescriptorProto"), - 333: .same(proto: "Google_Protobuf_MethodOptions"), - 334: .same(proto: "Google_Protobuf_Mixin"), - 335: .same(proto: "Google_Protobuf_NullValue"), - 336: .same(proto: "Google_Protobuf_OneofDescriptorProto"), - 337: .same(proto: "Google_Protobuf_OneofOptions"), - 338: .same(proto: "Google_Protobuf_Option"), - 339: .same(proto: "Google_Protobuf_ServiceDescriptorProto"), - 340: .same(proto: "Google_Protobuf_ServiceOptions"), - 341: .same(proto: "Google_Protobuf_SourceCodeInfo"), - 342: .same(proto: "Google_Protobuf_SourceContext"), - 343: .same(proto: "Google_Protobuf_StringValue"), - 344: .same(proto: "Google_Protobuf_Struct"), - 345: .same(proto: "Google_Protobuf_Syntax"), - 346: .same(proto: "Google_Protobuf_Timestamp"), - 347: .same(proto: "Google_Protobuf_Type"), - 348: .same(proto: "Google_Protobuf_UInt32Value"), - 349: .same(proto: "Google_Protobuf_UInt64Value"), - 350: .same(proto: "Google_Protobuf_UninterpretedOption"), - 351: .same(proto: "Google_Protobuf_Value"), - 352: .same(proto: "goPackage"), - 353: .same(proto: "group"), - 354: .same(proto: "groupFieldNumberStack"), - 355: .same(proto: "groupSize"), - 356: .same(proto: "h"), - 357: .same(proto: "hadOneofValue"), - 358: .same(proto: "handleConflictingOneOf"), - 359: .same(proto: "hasAggregateValue"), - 360: .same(proto: "hasAllowAlias"), - 361: .same(proto: "hasBegin"), - 362: .same(proto: "hasCcEnableArenas"), - 363: .same(proto: "hasCcGenericServices"), - 364: .same(proto: "hasClientStreaming"), - 365: .same(proto: "hasCsharpNamespace"), - 366: .same(proto: "hasCtype"), - 367: .same(proto: "hasDefaultValue"), - 368: .same(proto: "hasDeprecated"), - 369: .same(proto: "hasDoubleValue"), - 370: .same(proto: "hasEnd"), - 371: .same(proto: "hasExtendee"), - 372: .same(proto: "hasExtensionValue"), - 373: .same(proto: "hasGoPackage"), - 374: .same(proto: "hash"), - 375: .same(proto: "Hashable"), - 376: .same(proto: "hasher"), - 377: .same(proto: "hashValue"), - 378: .same(proto: "HashVisitor"), - 379: .same(proto: "hasIdempotencyLevel"), - 380: .same(proto: "hasIdentifierValue"), - 381: .same(proto: "hasInputType"), - 382: .same(proto: "hasIsExtension"), - 383: .same(proto: "hasJavaGenerateEqualsAndHash"), - 384: .same(proto: "hasJavaGenericServices"), - 385: .same(proto: "hasJavaMultipleFiles"), - 386: .same(proto: "hasJavaOuterClassname"), - 387: .same(proto: "hasJavaPackage"), - 388: .same(proto: "hasJavaStringCheckUtf8"), - 389: .same(proto: "hasJsonName"), - 390: .same(proto: "hasJstype"), - 391: .same(proto: "hasLabel"), - 392: .same(proto: "hasLazy"), - 393: .same(proto: "hasLeadingComments"), - 394: .same(proto: "hasMapEntry"), - 395: .same(proto: "hasMessageSetWireFormat"), - 396: .same(proto: "hasName"), - 397: .same(proto: "hasNamePart"), - 398: .same(proto: "hasNegativeIntValue"), - 399: .same(proto: "hasNoStandardDescriptorAccessor"), - 400: .same(proto: "hasNumber"), - 401: .same(proto: "hasObjcClassPrefix"), - 402: .same(proto: "hasOneofIndex"), - 403: .same(proto: "hasOptimizeFor"), - 404: .same(proto: "hasOptions"), - 405: .same(proto: "hasOutputType"), - 406: .same(proto: "hasPackage"), - 407: .same(proto: "hasPacked"), - 408: .same(proto: "hasPhpClassPrefix"), - 409: .same(proto: "hasPhpGenericServices"), - 410: .same(proto: "hasPhpMetadataNamespace"), - 411: .same(proto: "hasPhpNamespace"), - 412: .same(proto: "hasPositiveIntValue"), - 413: .same(proto: "hasProto3Optional"), - 414: .same(proto: "hasPyGenericServices"), - 415: .same(proto: "hasRubyPackage"), - 416: .same(proto: "hasServerStreaming"), - 417: .same(proto: "hasSourceCodeInfo"), - 418: .same(proto: "hasSourceContext"), - 419: .same(proto: "hasSourceFile"), - 420: .same(proto: "hasStart"), - 421: .same(proto: "hasStringValue"), - 422: .same(proto: "hasSwiftPrefix"), - 423: .same(proto: "hasSyntax"), - 424: .same(proto: "hasTrailingComments"), - 425: .same(proto: "hasType"), - 426: .same(proto: "hasTypeName"), - 427: .same(proto: "hasValue"), - 428: .same(proto: "hasWeak"), - 429: .same(proto: "hour"), - 430: .same(proto: "i"), - 431: .same(proto: "idempotencyLevel"), - 432: .same(proto: "identifierValue"), - 433: .same(proto: "if"), - 434: .same(proto: "ignoreUnknownFields"), - 435: .same(proto: "index"), - 436: .same(proto: "init"), - 437: .same(proto: "inout"), - 438: .same(proto: "inputType"), - 439: .same(proto: "insert"), - 440: .same(proto: "Int"), - 441: .same(proto: "Int32"), - 442: .same(proto: "Int32Value"), - 443: .same(proto: "Int64"), - 444: .same(proto: "Int64Value"), - 445: .same(proto: "Int8"), - 446: .same(proto: "integerLiteral"), - 447: .same(proto: "IntegerLiteralType"), - 448: .same(proto: "intern"), - 449: .same(proto: "Internal"), - 450: .same(proto: "InternalState"), - 451: .same(proto: "into"), - 452: .same(proto: "ints"), - 453: .same(proto: "isA"), - 454: .same(proto: "isEqual"), - 455: .same(proto: "isEqualTo"), - 456: .same(proto: "isExtension"), - 457: .same(proto: "isInitialized"), - 458: .same(proto: "itemTagsEncodedSize"), - 459: .same(proto: "Iterator"), - 460: .same(proto: "i_2166136261"), - 461: .same(proto: "javaGenerateEqualsAndHash"), - 462: .same(proto: "javaGenericServices"), - 463: .same(proto: "javaMultipleFiles"), - 464: .same(proto: "javaOuterClassname"), - 465: .same(proto: "javaPackage"), - 466: .same(proto: "javaStringCheckUtf8"), - 467: .same(proto: "JSONDecoder"), - 468: .same(proto: "JSONDecodingError"), - 469: .same(proto: "JSONDecodingOptions"), - 470: .same(proto: "jsonEncoder"), - 471: .same(proto: "JSONEncodingError"), - 472: .same(proto: "JSONEncodingOptions"), - 473: .same(proto: "JSONEncodingVisitor"), - 474: .same(proto: "JSONMapEncodingVisitor"), - 475: .same(proto: "jsonName"), - 476: .same(proto: "jsonPath"), - 477: .same(proto: "jsonPaths"), - 478: .same(proto: "JSONScanner"), - 479: .same(proto: "jsonString"), - 480: .same(proto: "jsonText"), - 481: .same(proto: "jsonUTF8Data"), - 482: .same(proto: "jstype"), - 483: .same(proto: "k"), - 484: .same(proto: "Key"), - 485: .same(proto: "keyField"), - 486: .same(proto: "KeyType"), - 487: .same(proto: "kind"), - 488: .same(proto: "l"), - 489: .same(proto: "label"), - 490: .same(proto: "lazy"), - 491: .same(proto: "leadingComments"), - 492: .same(proto: "leadingDetachedComments"), - 493: .same(proto: "length"), - 494: .same(proto: "lessThan"), - 495: .same(proto: "let"), - 496: .same(proto: "lhs"), - 497: .same(proto: "list"), - 498: .same(proto: "listOfMessages"), - 499: .same(proto: "listValue"), - 500: .same(proto: "littleEndian"), - 501: .same(proto: "littleEndianBytes"), - 502: .same(proto: "load"), - 503: .same(proto: "localHasher"), - 504: .same(proto: "location"), - 505: .same(proto: "M"), - 506: .same(proto: "major"), - 507: .same(proto: "makeIterator"), - 508: .same(proto: "mapEntry"), - 509: .same(proto: "mapHash"), - 510: .same(proto: "MapKeyType"), - 511: .same(proto: "mapNameResolver"), - 512: .same(proto: "mapToMessages"), - 513: .same(proto: "MapValueType"), - 514: .same(proto: "mapVisitor"), - 515: .same(proto: "mdayStart"), - 516: .same(proto: "merge"), - 517: .same(proto: "message"), - 518: .same(proto: "messageDepthLimit"), - 519: .same(proto: "MessageExtension"), - 520: .same(proto: "MessageImplementationBase"), - 521: .same(proto: "MessageOptions"), - 522: .same(proto: "MessageSet"), - 523: .same(proto: "messageSetWireFormat"), - 524: .same(proto: "messageType"), - 525: .same(proto: "Method"), - 526: .same(proto: "MethodDescriptorProto"), - 527: .same(proto: "MethodOptions"), - 528: .same(proto: "methods"), - 529: .same(proto: "minor"), - 530: .same(proto: "Mixin"), - 531: .same(proto: "mixins"), - 532: .same(proto: "modifier"), - 533: .same(proto: "modify"), - 534: .same(proto: "month"), - 535: .same(proto: "msgExtension"), - 536: .same(proto: "mutating"), - 537: .same(proto: "n"), - 538: .same(proto: "name"), - 539: .same(proto: "NameDescription"), - 540: .same(proto: "NameMap"), - 541: .same(proto: "NamePart"), - 542: .same(proto: "nameResolver"), - 543: .same(proto: "names"), - 544: .same(proto: "nanos"), - 545: .same(proto: "nativeBytes"), - 546: .same(proto: "nativeEndianBytes"), - 547: .same(proto: "negativeIntValue"), - 548: .same(proto: "nestedType"), - 549: .same(proto: "newL"), - 550: .same(proto: "newList"), - 551: .same(proto: "newValue"), - 552: .same(proto: "nextByte"), - 553: .same(proto: "nextFieldNumber"), - 554: .same(proto: "nil"), - 555: .same(proto: "nilLiteral"), - 556: .same(proto: "noStandardDescriptorAccessor"), - 557: .same(proto: "nullValue"), - 558: .same(proto: "number"), - 559: .same(proto: "numberValue"), - 560: .same(proto: "objcClassPrefix"), - 561: .same(proto: "of"), - 562: .same(proto: "oneofDecl"), - 563: .same(proto: "OneofDescriptorProto"), - 564: .same(proto: "oneofIndex"), - 565: .same(proto: "OneofOptions"), - 566: .same(proto: "oneofs"), - 567: .same(proto: "OneOf_Kind"), - 568: .same(proto: "optimizeFor"), - 569: .same(proto: "OptimizeMode"), - 570: .same(proto: "Option"), - 571: .same(proto: "OptionalEnumExtensionField"), - 572: .same(proto: "OptionalExtensionField"), - 573: .same(proto: "OptionalGroupExtensionField"), - 574: .same(proto: "OptionalMessageExtensionField"), - 575: .same(proto: "options"), - 576: .same(proto: "other"), - 577: .same(proto: "others"), - 578: .same(proto: "out"), - 579: .same(proto: "outputType"), - 580: .same(proto: "p"), - 581: .same(proto: "package"), - 582: .same(proto: "packed"), - 583: .same(proto: "PackedEnumExtensionField"), - 584: .same(proto: "PackedExtensionField"), - 585: .same(proto: "padding"), - 586: .same(proto: "parent"), - 587: .same(proto: "parse"), - 588: .same(proto: "partial"), - 589: .same(proto: "path"), - 590: .same(proto: "paths"), - 591: .same(proto: "payload"), - 592: .same(proto: "payloadSize"), - 593: .same(proto: "phpClassPrefix"), - 594: .same(proto: "phpGenericServices"), - 595: .same(proto: "phpMetadataNamespace"), - 596: .same(proto: "phpNamespace"), - 597: .same(proto: "pointer"), - 598: .same(proto: "pos"), - 599: .same(proto: "positiveIntValue"), - 600: .same(proto: "prefix"), - 601: .same(proto: "preserveProtoFieldNames"), - 602: .same(proto: "preTraverse"), - 603: .same(proto: "printUnknownFields"), - 604: .same(proto: "proto2"), - 605: .same(proto: "proto3DefaultValue"), - 606: .same(proto: "proto3Optional"), - 607: .same(proto: "ProtobufAPIVersionCheck"), - 608: .same(proto: "ProtobufAPIVersion_2"), - 609: .same(proto: "ProtobufBool"), - 610: .same(proto: "ProtobufBytes"), - 611: .same(proto: "ProtobufDouble"), - 612: .same(proto: "ProtobufEnumMap"), - 613: .same(proto: "protobufExtension"), - 614: .same(proto: "ProtobufFixed32"), - 615: .same(proto: "ProtobufFixed64"), - 616: .same(proto: "ProtobufFloat"), - 617: .same(proto: "ProtobufInt32"), - 618: .same(proto: "ProtobufInt64"), - 619: .same(proto: "ProtobufMap"), - 620: .same(proto: "ProtobufMessageMap"), - 621: .same(proto: "ProtobufSFixed32"), - 622: .same(proto: "ProtobufSFixed64"), - 623: .same(proto: "ProtobufSInt32"), - 624: .same(proto: "ProtobufSInt64"), - 625: .same(proto: "ProtobufString"), - 626: .same(proto: "ProtobufUInt32"), - 627: .same(proto: "ProtobufUInt64"), - 628: .same(proto: "protobuf_extensionFieldValues"), - 629: .same(proto: "protobuf_fieldNumber"), - 630: .same(proto: "protobuf_generated_isEqualTo"), - 631: .same(proto: "protobuf_nameMap"), - 632: .same(proto: "protobuf_newField"), - 633: .same(proto: "protobuf_package"), - 634: .same(proto: "protocol"), - 635: .same(proto: "protoFieldName"), - 636: .same(proto: "protoMessageName"), - 637: .same(proto: "ProtoNameProviding"), - 638: .same(proto: "protoPaths"), - 639: .same(proto: "public"), - 640: .same(proto: "publicDependency"), - 641: .same(proto: "putBoolValue"), - 642: .same(proto: "putBytesValue"), - 643: .same(proto: "putDoubleValue"), - 644: .same(proto: "putEnumValue"), - 645: .same(proto: "putFixedUInt32"), - 646: .same(proto: "putFixedUInt64"), - 647: .same(proto: "putFloatValue"), - 648: .same(proto: "putInt64"), - 649: .same(proto: "putStringValue"), - 650: .same(proto: "putUInt64"), - 651: .same(proto: "putUInt64Hex"), - 652: .same(proto: "putVarInt"), - 653: .same(proto: "putZigZagVarInt"), - 654: .same(proto: "pyGenericServices"), - 655: .same(proto: "rawChars"), - 656: .same(proto: "RawRepresentable"), - 657: .same(proto: "RawValue"), - 658: .same(proto: "read4HexDigits"), - 659: .same(proto: "register"), - 660: .same(proto: "RepeatedEnumExtensionField"), - 661: .same(proto: "RepeatedExtensionField"), - 662: .same(proto: "RepeatedGroupExtensionField"), - 663: .same(proto: "RepeatedMessageExtensionField"), - 664: .same(proto: "requestStreaming"), - 665: .same(proto: "requestTypeURL"), - 666: .same(proto: "requiredSize"), - 667: .same(proto: "reservedName"), - 668: .same(proto: "reservedRange"), - 669: .same(proto: "responseStreaming"), - 670: .same(proto: "responseTypeURL"), - 671: .same(proto: "result"), - 672: .same(proto: "rethrows"), - 673: .same(proto: "return"), - 674: .same(proto: "ReturnType"), - 675: .same(proto: "revision"), - 676: .same(proto: "rhs"), - 677: .same(proto: "root"), - 678: .same(proto: "rubyPackage"), - 679: .same(proto: "s"), - 680: .same(proto: "sawBackslash"), - 681: .same(proto: "sawSection4Characters"), - 682: .same(proto: "sawSection5Characters"), - 683: .same(proto: "scanner"), - 684: .same(proto: "seconds"), - 685: .same(proto: "self"), - 686: .same(proto: "separator"), - 687: .same(proto: "serialize"), - 688: .same(proto: "serializedData"), - 689: .same(proto: "serializedSize"), - 690: .same(proto: "serverStreaming"), - 691: .same(proto: "service"), - 692: .same(proto: "ServiceDescriptorProto"), - 693: .same(proto: "ServiceOptions"), - 694: .same(proto: "set"), - 695: .same(proto: "setExtensionValue"), - 696: .same(proto: "shift"), - 697: .same(proto: "SimpleExtensionMap"), - 698: .same(proto: "sizer"), - 699: .same(proto: "source"), - 700: .same(proto: "sourceCodeInfo"), - 701: .same(proto: "sourceContext"), - 702: .same(proto: "sourceEncoding"), - 703: .same(proto: "sourceFile"), - 704: .same(proto: "span"), - 705: .same(proto: "split"), - 706: .same(proto: "start"), - 707: .same(proto: "startArray"), - 708: .same(proto: "startArrayObject"), - 709: .same(proto: "startField"), - 710: .same(proto: "startIndex"), - 711: .same(proto: "startMessageField"), - 712: .same(proto: "startObject"), - 713: .same(proto: "startRegularField"), - 714: .same(proto: "state"), - 715: .same(proto: "static"), - 716: .same(proto: "StaticString"), - 717: .same(proto: "storage"), - 718: .same(proto: "String"), - 719: .same(proto: "stringLiteral"), - 720: .same(proto: "StringLiteralType"), - 721: .same(proto: "stringResult"), - 722: .same(proto: "stringValue"), - 723: .same(proto: "struct"), - 724: .same(proto: "structValue"), - 725: .same(proto: "subDecoder"), - 726: .same(proto: "subscript"), - 727: .same(proto: "subVisitor"), - 728: .same(proto: "Swift"), - 729: .same(proto: "swiftPrefix"), - 730: .same(proto: "SwiftProtobuf"), - 731: .same(proto: "syntax"), - 732: .same(proto: "T"), - 733: .same(proto: "tag"), - 734: .same(proto: "terminator"), - 735: .same(proto: "testDecoder"), - 736: .same(proto: "text"), - 737: .same(proto: "textDecoder"), - 738: .same(proto: "TextFormatDecoder"), - 739: .same(proto: "TextFormatDecodingError"), - 740: .same(proto: "TextFormatDecodingOptions"), - 741: .same(proto: "TextFormatEncodingOptions"), - 742: .same(proto: "TextFormatEncodingVisitor"), - 743: .same(proto: "textFormatString"), - 744: .same(proto: "throws"), - 745: .same(proto: "timeInterval"), - 746: .same(proto: "timeIntervalSince1970"), - 747: .same(proto: "timeIntervalSinceReferenceDate"), - 748: .same(proto: "Timestamp"), - 749: .same(proto: "total"), - 750: .same(proto: "totalArrayDepth"), - 751: .same(proto: "totalSize"), - 752: .same(proto: "trailingComments"), - 753: .same(proto: "traverse"), - 754: .same(proto: "true"), - 755: .same(proto: "try"), - 756: .same(proto: "type"), - 757: .same(proto: "typealias"), - 758: .same(proto: "TypeEnum"), - 759: .same(proto: "typeName"), - 760: .same(proto: "typePrefix"), - 761: .same(proto: "typeStart"), - 762: .same(proto: "typeUnknown"), - 763: .same(proto: "typeURL"), - 764: .same(proto: "UInt32"), - 765: .same(proto: "UInt32Value"), - 766: .same(proto: "UInt64"), - 767: .same(proto: "UInt64Value"), - 768: .same(proto: "UInt8"), - 769: .same(proto: "unicodeScalarLiteral"), - 770: .same(proto: "UnicodeScalarLiteralType"), - 771: .same(proto: "unicodeScalars"), - 772: .same(proto: "UnicodeScalarView"), - 773: .same(proto: "uninterpretedOption"), - 774: .same(proto: "union"), - 775: .same(proto: "uniqueStorage"), - 776: .same(proto: "unknown"), - 777: .same(proto: "unknownFields"), - 778: .same(proto: "UnknownStorage"), - 779: .same(proto: "unpackTo"), - 780: .same(proto: "UnsafeBufferPointer"), - 781: .same(proto: "UnsafeMutablePointer"), - 782: .same(proto: "UnsafeMutableRawBufferPointer"), - 783: .same(proto: "UnsafeMutableRawPointer"), - 784: .same(proto: "UnsafeRawBufferPointer"), - 785: .same(proto: "UnsafeRawPointer"), - 786: .same(proto: "updatedOptions"), - 787: .same(proto: "url"), - 788: .same(proto: "utf8"), - 789: .same(proto: "utf8Ptr"), - 790: .same(proto: "utf8ToDouble"), - 791: .same(proto: "UTF8View"), - 792: .same(proto: "v"), - 793: .same(proto: "value"), - 794: .same(proto: "valueField"), - 795: .same(proto: "values"), - 796: .same(proto: "ValueType"), - 797: .same(proto: "var"), - 798: .same(proto: "Version"), - 799: .same(proto: "versionString"), - 800: .same(proto: "visitExtensionFields"), - 801: .same(proto: "visitExtensionFieldsAsMessageSet"), - 802: .same(proto: "visitMapField"), - 803: .same(proto: "visitor"), - 804: .same(proto: "visitPacked"), - 805: .same(proto: "visitPackedBoolField"), - 806: .same(proto: "visitPackedDoubleField"), - 807: .same(proto: "visitPackedEnumField"), - 808: .same(proto: "visitPackedFixed32Field"), - 809: .same(proto: "visitPackedFixed64Field"), - 810: .same(proto: "visitPackedFloatField"), - 811: .same(proto: "visitPackedInt32Field"), - 812: .same(proto: "visitPackedInt64Field"), - 813: .same(proto: "visitPackedSFixed32Field"), - 814: .same(proto: "visitPackedSFixed64Field"), - 815: .same(proto: "visitPackedSInt32Field"), - 816: .same(proto: "visitPackedSInt64Field"), - 817: .same(proto: "visitPackedUInt32Field"), - 818: .same(proto: "visitPackedUInt64Field"), - 819: .same(proto: "visitRepeated"), - 820: .same(proto: "visitRepeatedBoolField"), - 821: .same(proto: "visitRepeatedBytesField"), - 822: .same(proto: "visitRepeatedDoubleField"), - 823: .same(proto: "visitRepeatedEnumField"), - 824: .same(proto: "visitRepeatedFixed32Field"), - 825: .same(proto: "visitRepeatedFixed64Field"), - 826: .same(proto: "visitRepeatedFloatField"), - 827: .same(proto: "visitRepeatedGroupField"), - 828: .same(proto: "visitRepeatedInt32Field"), - 829: .same(proto: "visitRepeatedInt64Field"), - 830: .same(proto: "visitRepeatedMessageField"), - 831: .same(proto: "visitRepeatedSFixed32Field"), - 832: .same(proto: "visitRepeatedSFixed64Field"), - 833: .same(proto: "visitRepeatedSInt32Field"), - 834: .same(proto: "visitRepeatedSInt64Field"), - 835: .same(proto: "visitRepeatedStringField"), - 836: .same(proto: "visitRepeatedUInt32Field"), - 837: .same(proto: "visitRepeatedUInt64Field"), - 838: .same(proto: "visitSingular"), - 839: .same(proto: "visitSingularBoolField"), - 840: .same(proto: "visitSingularBytesField"), - 841: .same(proto: "visitSingularDoubleField"), - 842: .same(proto: "visitSingularEnumField"), - 843: .same(proto: "visitSingularFixed32Field"), - 844: .same(proto: "visitSingularFixed64Field"), - 845: .same(proto: "visitSingularFloatField"), - 846: .same(proto: "visitSingularGroupField"), - 847: .same(proto: "visitSingularInt32Field"), - 848: .same(proto: "visitSingularInt64Field"), - 849: .same(proto: "visitSingularMessageField"), - 850: .same(proto: "visitSingularSFixed32Field"), - 851: .same(proto: "visitSingularSFixed64Field"), - 852: .same(proto: "visitSingularSInt32Field"), - 853: .same(proto: "visitSingularSInt64Field"), - 854: .same(proto: "visitSingularStringField"), - 855: .same(proto: "visitSingularUInt32Field"), - 856: .same(proto: "visitSingularUInt64Field"), - 857: .same(proto: "visitUnknown"), - 858: .same(proto: "wasDecoded"), - 859: .same(proto: "weak"), - 860: .same(proto: "weakDependency"), - 861: .same(proto: "where"), - 862: .same(proto: "wireFormat"), - 863: .same(proto: "with"), - 864: .same(proto: "withUnsafeBytes"), - 865: .same(proto: "withUnsafeMutableBytes"), - 866: .same(proto: "work"), - 867: .same(proto: "WrappedType"), - 868: .same(proto: "written"), - 869: .same(proto: "yday"), - ] -} diff --git a/Reference/generated_swift_names_enums.pb.swift b/Reference/generated_swift_names_enums.pb.swift deleted file mode 100644 index 2b63bc96e..000000000 --- a/Reference/generated_swift_names_enums.pb.swift +++ /dev/null @@ -1,33957 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: generated_swift_names_enums.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -/// See Makefile for the logic that generates this -/// Protoc errors imply this file is being generated incorrectly -/// Swift compile errors are probably bugs in protoc-gen-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 -} - -struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { - // 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() - - enum adjusted: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAdjusted // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAdjusted - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAdjusted - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAdjusted: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum aggregateValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAggregateValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAggregateValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAggregateValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAggregateValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum allCases: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAllCases // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAllCases - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAllCases - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAllCases: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum allowAlias: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAllowAlias // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAllowAlias - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAllowAlias - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAllowAlias: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum alwaysPrintEnumsAsInts: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAlwaysPrintEnumsAsInts // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAlwaysPrintEnumsAsInts - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAlwaysPrintEnumsAsInts - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAlwaysPrintEnumsAsInts: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum annotation: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAnnotation // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAnnotation - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAnnotation - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAnnotation: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum any: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAny // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAny - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAny - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAny: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum AnyExtensionField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAnyExtensionField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAnyExtensionField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAnyExtensionField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAnyExtensionField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum AnyMessageExtension: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAnyMessageExtension // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAnyMessageExtension - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAnyMessageExtension - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAnyMessageExtension: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum AnyMessageStorage: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAnyMessageStorage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAnyMessageStorage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAnyMessageStorage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAnyMessageStorage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum AnyUnpackError: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAnyUnpackError // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAnyUnpackError - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAnyUnpackError - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAnyUnpackError: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Api: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneApi // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneApi - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneApi - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneApi: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum appended: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAppended // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAppended - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAppended - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAppended: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum appendUIntHex: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAppendUintHex // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAppendUintHex - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAppendUintHex - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAppendUintHex: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum appendUnknown: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAppendUnknown // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAppendUnknown - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAppendUnknown - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAppendUnknown: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum areAllInitialized: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAreAllInitialized // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAreAllInitialized - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAreAllInitialized - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAreAllInitialized: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum array: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneArray // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneArray - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneArray - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneArray: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum arrayDepth: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneArrayDepth // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneArrayDepth - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneArrayDepth - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneArrayDepth: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum arrayLiteral: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneArrayLiteral // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneArrayLiteral - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneArrayLiteral - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneArrayLiteral: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum arraySeparator: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneArraySeparator // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneArraySeparator - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneArraySeparator - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneArraySeparator: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum asEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAs // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAs - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAs - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAs: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum asciiOpenCurlyBracket: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAsciiOpenCurlyBracket // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAsciiOpenCurlyBracket - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAsciiOpenCurlyBracket - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAsciiOpenCurlyBracket: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum asciiZero: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAsciiZero // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAsciiZero - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAsciiZero - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAsciiZero: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum available: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneAvailable // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneAvailable - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneAvailable - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneAvailable: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum b: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneB // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneB - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneB - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneB: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum base64Values: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBase64Values // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBase64Values - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBase64Values - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBase64Values: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum baseAddress: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBaseAddress // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBaseAddress - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBaseAddress - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBaseAddress: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum BaseType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBaseType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBaseType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBaseType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBaseType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum begin: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBegin // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBegin - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBegin - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBegin: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum binary: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBinary // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBinary - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBinary - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBinary: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum BinaryDecoder: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBinaryDecoder // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBinaryDecoder - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBinaryDecoder - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBinaryDecoder: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum BinaryDecodingError: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBinaryDecodingError // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBinaryDecodingError - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBinaryDecodingError - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBinaryDecodingError: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum BinaryDecodingOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBinaryDecodingOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBinaryDecodingOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBinaryDecodingOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBinaryDecodingOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum BinaryDelimited: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBinaryDelimited // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBinaryDelimited - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBinaryDelimited - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBinaryDelimited: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum BinaryEncoder: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBinaryEncoder // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBinaryEncoder - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBinaryEncoder - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBinaryEncoder: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum BinaryEncodingError: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBinaryEncodingError // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBinaryEncodingError - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBinaryEncodingError - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBinaryEncodingError: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum BinaryEncodingMessageSetSizeVisitor: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBinaryEncodingMessageSetSizeVisitor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBinaryEncodingMessageSetSizeVisitor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBinaryEncodingMessageSetSizeVisitor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBinaryEncodingMessageSetSizeVisitor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum BinaryEncodingMessageSetVisitor: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBinaryEncodingMessageSetVisitor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBinaryEncodingMessageSetVisitor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBinaryEncodingMessageSetVisitor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBinaryEncodingMessageSetVisitor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum BinaryEncodingSizeVisitor: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBinaryEncodingSizeVisitor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBinaryEncodingSizeVisitor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBinaryEncodingSizeVisitor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBinaryEncodingSizeVisitor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum BinaryEncodingVisitor: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBinaryEncodingVisitor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBinaryEncodingVisitor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBinaryEncodingVisitor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBinaryEncodingVisitor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum binaryOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBinaryOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBinaryOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBinaryOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBinaryOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum body: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBody // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBody - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBody - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBody: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum BoolEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBool // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBool - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBool - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBool: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum booleanLiteral: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBooleanLiteral // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBooleanLiteral - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBooleanLiteral - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBooleanLiteral: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum BooleanLiteralType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBooleanLiteralType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBooleanLiteralType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBooleanLiteralType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBooleanLiteralType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum boolValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBoolValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBoolValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBoolValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBoolValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum bytes: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBytes // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBytes - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBytes - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBytes: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum bytesInGroup: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBytesInGroup // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBytesInGroup - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBytesInGroup - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBytesInGroup: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum bytesRead: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBytesRead // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBytesRead - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBytesRead - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBytesRead: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum BytesValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneBytesValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneBytesValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneBytesValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneBytesValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum c: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneC // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneC - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneC - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneC: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum capitalizeNext: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneCapitalizeNext // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneCapitalizeNext - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneCapitalizeNext - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneCapitalizeNext: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum cardinality: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneCardinality // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneCardinality - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneCardinality - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneCardinality: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ccEnableArenas: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneCcEnableArenas // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneCcEnableArenas - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneCcEnableArenas - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneCcEnableArenas: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ccGenericServices: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneCcGenericServices // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneCcGenericServices - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneCcGenericServices - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneCcGenericServices: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Character: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneCharacter // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneCharacter - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneCharacter - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneCharacter: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum chars: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneChars // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneChars - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneChars - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneChars: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum classEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClass // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClass - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClass - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClass: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearAggregateValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearAggregateValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearAggregateValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearAggregateValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearAggregateValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearAllowAlias: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearAllowAlias // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearAllowAlias - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearAllowAlias - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearAllowAlias: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearBegin: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearBegin // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearBegin - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearBegin - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearBegin: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearCcEnableArenas: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearCcEnableArenas // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearCcEnableArenas - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearCcEnableArenas - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearCcEnableArenas: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearCcGenericServices: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearCcGenericServices // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearCcGenericServices - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearCcGenericServices - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearCcGenericServices: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearClientStreaming: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearClientStreaming // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearClientStreaming - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearClientStreaming - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearClientStreaming: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearCsharpNamespace: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearCsharpNamespace // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearCsharpNamespace - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearCsharpNamespace - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearCsharpNamespace: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearCtype: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearCtype // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearCtype - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearCtype - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearCtype: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearDefaultValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearDefaultValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearDefaultValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearDefaultValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearDefaultValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearDeprecated: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearDeprecated // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearDeprecated - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearDeprecated - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearDeprecated: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearDoubleValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearDoubleValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearDoubleValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearDoubleValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearDoubleValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearEnd: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearEnd // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearEnd - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearEnd - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearEnd: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearExtendee: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearExtendee // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearExtendee - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearExtendee - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearExtendee: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearExtensionValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearExtensionValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearExtensionValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearExtensionValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearExtensionValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearGoPackage: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearGoPackage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearGoPackage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearGoPackage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearGoPackage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearIdempotencyLevel: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearIdempotencyLevel // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearIdempotencyLevel - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearIdempotencyLevel - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearIdempotencyLevel: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearIdentifierValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearIdentifierValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearIdentifierValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearIdentifierValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearIdentifierValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearInputType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearInputType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearInputType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearInputType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearInputType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearIsExtension: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearIsExtension // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearIsExtension - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearIsExtension - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearIsExtension: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearJavaGenerateEqualsAndHash: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearJavaGenerateEqualsAndHash // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearJavaGenerateEqualsAndHash - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearJavaGenerateEqualsAndHash - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearJavaGenerateEqualsAndHash: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearJavaGenericServices: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearJavaGenericServices // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearJavaGenericServices - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearJavaGenericServices - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearJavaGenericServices: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearJavaMultipleFiles: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearJavaMultipleFiles // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearJavaMultipleFiles - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearJavaMultipleFiles - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearJavaMultipleFiles: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearJavaOuterClassname: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearJavaOuterClassname // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearJavaOuterClassname - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearJavaOuterClassname - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearJavaOuterClassname: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearJavaPackage: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearJavaPackage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearJavaPackage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearJavaPackage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearJavaPackage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearJavaStringCheckUtf8: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearJavaStringCheckUtf8 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearJavaStringCheckUtf8 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearJavaStringCheckUtf8 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearJavaStringCheckUtf8: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearJsonName: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearJsonName // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearJsonName - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearJsonName - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearJsonName: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearJstype: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearJstype // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearJstype - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearJstype - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearJstype: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearLabel: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearLabel // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearLabel - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearLabel - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearLabel: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearLazy: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearLazy // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearLazy - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearLazy - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearLazy: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearLeadingComments: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearLeadingComments // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearLeadingComments - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearLeadingComments - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearLeadingComments: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearMapEntry: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearMapEntry // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearMapEntry - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearMapEntry - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearMapEntry: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearMessageSetWireFormat: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearMessageSetWireFormat // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearMessageSetWireFormat - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearMessageSetWireFormat - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearMessageSetWireFormat: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearName: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearName // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearName - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearName - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearName: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearNamePart: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearNamePart // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearNamePart - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearNamePart - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearNamePart: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearNegativeIntValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearNegativeIntValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearNegativeIntValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearNegativeIntValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearNegativeIntValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearNoStandardDescriptorAccessor: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearNoStandardDescriptorAccessor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearNoStandardDescriptorAccessor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearNoStandardDescriptorAccessor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearNoStandardDescriptorAccessor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearNumber: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearNumber // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearNumber - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearNumber - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearNumber: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearObjcClassPrefix: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearObjcClassPrefix // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearObjcClassPrefix - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearObjcClassPrefix - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearObjcClassPrefix: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearOneofIndex: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearOneofIndex // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearOneofIndex - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearOneofIndex - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearOneofIndex: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearOptimizeFor: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearOptimizeFor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearOptimizeFor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearOptimizeFor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearOptimizeFor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearOutputType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearOutputType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearOutputType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearOutputType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearOutputType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearPackage: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearPackage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearPackage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearPackage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearPackage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearPacked: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearPacked // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearPacked - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearPacked - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearPacked: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearPhpClassPrefix: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearPhpClassPrefix // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearPhpClassPrefix - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearPhpClassPrefix - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearPhpClassPrefix: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearPhpGenericServices: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearPhpGenericServices // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearPhpGenericServices - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearPhpGenericServices - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearPhpGenericServices: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearPhpMetadataNamespace: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearPhpMetadataNamespace // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearPhpMetadataNamespace - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearPhpMetadataNamespace - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearPhpMetadataNamespace: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearPhpNamespace: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearPhpNamespace // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearPhpNamespace - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearPhpNamespace - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearPhpNamespace: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearPositiveIntValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearPositiveIntValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearPositiveIntValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearPositiveIntValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearPositiveIntValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearProto3Optional: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearProto3Optional // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearProto3Optional - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearProto3Optional - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearProto3Optional: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearPyGenericServices: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearPyGenericServices // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearPyGenericServices - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearPyGenericServices - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearPyGenericServices: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearRubyPackage: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearRubyPackage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearRubyPackage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearRubyPackage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearRubyPackage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearServerStreaming: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearServerStreaming // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearServerStreaming - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearServerStreaming - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearServerStreaming: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearSourceCodeInfo: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearSourceCodeInfo // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearSourceCodeInfo - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearSourceCodeInfo - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearSourceCodeInfo: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearSourceContext: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearSourceContext // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearSourceContext - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearSourceContext - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearSourceContext: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearSourceFile: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearSourceFile // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearSourceFile - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearSourceFile - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearSourceFile: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearStart: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearStart // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearStart - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearStart - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearStart: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearStringValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearStringValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearStringValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearStringValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearStringValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearSwiftPrefix: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearSwiftPrefix // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearSwiftPrefix - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearSwiftPrefix - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearSwiftPrefix: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearSyntax: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearSyntax // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearSyntax - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearSyntax - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearSyntax: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearTrailingComments: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearTrailingComments // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearTrailingComments - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearTrailingComments - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearTrailingComments: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearTypeName: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearTypeName // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearTypeName - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearTypeName - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearTypeName: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clearWeak: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClearWeak // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClearWeak - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClearWeak - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClearWeak: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum clientStreaming: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneClientStreaming // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneClientStreaming - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneClientStreaming - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneClientStreaming: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum codePoint: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneCodePoint // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneCodePoint - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneCodePoint - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneCodePoint: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum codeUnits: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneCodeUnits // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneCodeUnits - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneCodeUnits - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneCodeUnits: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Collection: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneCollection // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneCollection - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneCollection - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneCollection: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum com: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneCom // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneCom - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneCom - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneCom: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum comma: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneComma // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneComma - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneComma - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneComma: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum contentsOf: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneContentsOf // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneContentsOf - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneContentsOf - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneContentsOf: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ContiguousBytes: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneContiguousBytes // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneContiguousBytes - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneContiguousBytes - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneContiguousBytes: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum count: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneCount // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneCount - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneCount - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneCount: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum countVarintsInBuffer: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneCountVarintsInBuffer // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneCountVarintsInBuffer - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneCountVarintsInBuffer - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneCountVarintsInBuffer: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum csharpNamespace: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneCsharpNamespace // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneCsharpNamespace - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneCsharpNamespace - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneCsharpNamespace: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ctype: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneCtype // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneCtype - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneCtype - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneCtype: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum customCodable: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneCustomCodable // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneCustomCodable - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneCustomCodable - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneCustomCodable: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum CustomDebugStringConvertible: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneCustomDebugStringConvertible // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneCustomDebugStringConvertible - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneCustomDebugStringConvertible - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneCustomDebugStringConvertible: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum d: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneD // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneD - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneD - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneD: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum DataEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneData // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneData - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneData - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneData: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum dataResult: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDataResult // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDataResult - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDataResult - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDataResult: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum date: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDate // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDate - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDate - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDate: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum daySec: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDaySec // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDaySec - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDaySec - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDaySec: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum daysSinceEpoch: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDaysSinceEpoch // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDaysSinceEpoch - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDaysSinceEpoch - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDaysSinceEpoch: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum debugDescriptionEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDebugDescription // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDebugDescription - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDebugDescription - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDebugDescription: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decoded: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecoded // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecoded - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecoded - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecoded: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodedFromJSONNull: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodedFromJsonnull // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodedFromJsonnull - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodedFromJsonnull - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodedFromJsonnull: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeExtensionField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeExtensionField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeExtensionField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeExtensionField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeExtensionField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeExtensionFieldsAsMessageSet: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeExtensionFieldsAsMessageSet // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeExtensionFieldsAsMessageSet - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeExtensionFieldsAsMessageSet - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeExtensionFieldsAsMessageSet: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeJSON: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeJson // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeJson - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeJson - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeJson: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeMapField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeMapField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeMapField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeMapField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeMapField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeMessageEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeMessage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeMessage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeMessage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeMessage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decoder: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecoder // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecoder - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecoder - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecoder: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeated: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeated // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeated - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeated - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeated: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeatedBoolField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeatedBoolField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeatedBoolField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeatedBoolField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeatedBoolField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeatedBytesField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeatedBytesField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeatedBytesField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeatedBytesField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeatedBytesField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeatedDoubleField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeatedDoubleField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeatedDoubleField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeatedDoubleField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeatedDoubleField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeatedEnumField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeatedEnumField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeatedEnumField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeatedEnumField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeatedEnumField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeatedFixed32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeatedFixed32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeatedFixed32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeatedFixed32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeatedFixed32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeatedFixed64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeatedFixed64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeatedFixed64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeatedFixed64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeatedFixed64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeatedFloatField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeatedFloatField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeatedFloatField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeatedFloatField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeatedFloatField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeatedGroupField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeatedGroupField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeatedGroupField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeatedGroupField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeatedGroupField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeatedInt32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeatedInt32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeatedInt32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeatedInt32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeatedInt32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeatedInt64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeatedInt64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeatedInt64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeatedInt64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeatedInt64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeatedMessageField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeatedMessageField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeatedMessageField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeatedMessageField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeatedMessageField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeatedSFixed32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeatedSfixed32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeatedSfixed32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeatedSfixed32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeatedSfixed32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeatedSFixed64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeatedSfixed64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeatedSfixed64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeatedSfixed64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeatedSfixed64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeatedSInt32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeatedSint32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeatedSint32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeatedSint32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeatedSint32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeatedSInt64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeatedSint64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeatedSint64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeatedSint64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeatedSint64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeatedStringField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeatedStringField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeatedStringField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeatedStringField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeatedStringField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeatedUInt32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeatedUint32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeatedUint32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeatedUint32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeatedUint32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeRepeatedUInt64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeRepeatedUint64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeRepeatedUint64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeRepeatedUint64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeRepeatedUint64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingular: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingular // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingular - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingular - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingular: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingularBoolField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingularBoolField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingularBoolField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingularBoolField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingularBoolField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingularBytesField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingularBytesField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingularBytesField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingularBytesField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingularBytesField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingularDoubleField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingularDoubleField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingularDoubleField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingularDoubleField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingularDoubleField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingularEnumField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingularEnumField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingularEnumField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingularEnumField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingularEnumField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingularFixed32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingularFixed32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingularFixed32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingularFixed32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingularFixed32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingularFixed64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingularFixed64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingularFixed64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingularFixed64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingularFixed64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingularFloatField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingularFloatField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingularFloatField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingularFloatField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingularFloatField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingularGroupField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingularGroupField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingularGroupField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingularGroupField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingularGroupField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingularInt32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingularInt32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingularInt32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingularInt32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingularInt32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingularInt64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingularInt64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingularInt64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingularInt64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingularInt64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingularMessageField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingularMessageField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingularMessageField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingularMessageField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingularMessageField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingularSFixed32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingularSfixed32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingularSfixed32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingularSfixed32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingularSfixed32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingularSFixed64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingularSfixed64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingularSfixed64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingularSfixed64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingularSfixed64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingularSInt32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingularSint32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingularSint32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingularSint32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingularSint32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingularSInt64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingularSint64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingularSint64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingularSint64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingularSint64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingularStringField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingularStringField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingularStringField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingularStringField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingularStringField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingularUInt32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingularUint32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingularUint32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingularUint32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingularUint32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeSingularUInt64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeSingularUint64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeSingularUint64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeSingularUint64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeSingularUint64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum decodeTextFormat: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDecodeTextFormat // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDecodeTextFormat - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDecodeTextFormat - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDecodeTextFormat: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum defaultAnyTypeURLPrefix: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDefaultAnyTypeUrlprefix // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDefaultAnyTypeUrlprefix - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDefaultAnyTypeUrlprefix - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDefaultAnyTypeUrlprefix: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum defaultValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDefaultValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDefaultValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDefaultValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDefaultValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum dependency: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDependency // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDependency - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDependency - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDependency: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum deprecated: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDeprecated // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDeprecated - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDeprecated - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDeprecated: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum descriptionEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDescription // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDescription - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDescription - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDescription: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum DescriptorProto: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDescriptorProto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDescriptorProto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDescriptorProto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDescriptorProto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Dictionary: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDictionary // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDictionary - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDictionary - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDictionary: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum dictionaryLiteral: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDictionaryLiteral // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDictionaryLiteral - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDictionaryLiteral - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDictionaryLiteral: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum digit: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDigit // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDigit - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDigit - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDigit: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum digit0: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDigit0 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDigit0 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDigit0 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDigit0: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum digit1: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDigit1 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDigit1 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDigit1 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDigit1: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum digitCount: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDigitCount // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDigitCount - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDigitCount - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDigitCount: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum digits: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDigits // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDigits - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDigits - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDigits: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum digitValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDigitValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDigitValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDigitValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDigitValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum discardableResult: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDiscardableResult // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDiscardableResult - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDiscardableResult - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDiscardableResult: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum discardUnknownFields: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDiscardUnknownFields // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDiscardUnknownFields - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDiscardUnknownFields - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDiscardUnknownFields: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum distance: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDistance // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDistance - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDistance - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDistance: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum double: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDouble // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDouble - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDouble - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDouble: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum doubleValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDoubleValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDoubleValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDoubleValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDoubleValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Duration: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneDuration // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneDuration - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneDuration - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneDuration: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum E: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneE // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneE - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneE - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneE: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Element: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneElement // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneElement - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneElement - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneElement: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum elements: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneElements // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneElements - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneElements - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneElements: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum emitExtensionFieldName: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEmitExtensionFieldName // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEmitExtensionFieldName - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEmitExtensionFieldName - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEmitExtensionFieldName: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum emitFieldName: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEmitFieldName // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEmitFieldName - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEmitFieldName - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEmitFieldName: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum emitFieldNumber: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEmitFieldNumber // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEmitFieldNumber - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEmitFieldNumber - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEmitFieldNumber: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Empty: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEmpty // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEmpty - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEmpty - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEmpty: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum emptyData: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEmptyData // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEmptyData - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEmptyData - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEmptyData: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum encodeAsBytes: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEncodeAsBytes // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEncodeAsBytes - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEncodeAsBytes - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEncodeAsBytes: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum encoded: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEncoded // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEncoded - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEncoded - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEncoded: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum encodedJSONString: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEncodedJsonstring // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEncodedJsonstring - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEncodedJsonstring - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEncodedJsonstring: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum encodedSize: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEncodedSize // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEncodedSize - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEncodedSize - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEncodedSize: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum encodeField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEncodeField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEncodeField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEncodeField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEncodeField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum encoder: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEncoder // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEncoder - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEncoder - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEncoder: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum end: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEnd // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEnd - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEnd - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEnd: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum endArray: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEndArray // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEndArray - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEndArray - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEndArray: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum endMessageField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEndMessageField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEndMessageField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEndMessageField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEndMessageField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum endObject: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEndObject // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEndObject - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEndObject - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEndObject: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum endRegularField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEndRegularField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEndRegularField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEndRegularField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEndRegularField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum enumEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEnum // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEnum - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEnum - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEnum: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum EnumDescriptorProto: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEnumDescriptorProto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEnumDescriptorProto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEnumDescriptorProto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEnumDescriptorProto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum EnumOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEnumOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEnumOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEnumOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEnumOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum EnumReservedRange: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEnumReservedRange // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEnumReservedRange - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEnumReservedRange - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEnumReservedRange: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum enumType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEnumType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEnumType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEnumType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEnumType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum enumvalue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEnumvalue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEnumvalue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEnumvalue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEnumvalue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum EnumValueDescriptorProto: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEnumValueDescriptorProto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEnumValueDescriptorProto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEnumValueDescriptorProto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEnumValueDescriptorProto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum EnumValueOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEnumValueOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEnumValueOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEnumValueOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEnumValueOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Equatable: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneEquatable // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneEquatable - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneEquatable - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneEquatable: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Error: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneError // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneError - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneError - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneError: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ExpressibleByArrayLiteral: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneExpressibleByArrayLiteral // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneExpressibleByArrayLiteral - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneExpressibleByArrayLiteral - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneExpressibleByArrayLiteral: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ExpressibleByDictionaryLiteral: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneExpressibleByDictionaryLiteral // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneExpressibleByDictionaryLiteral - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneExpressibleByDictionaryLiteral - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneExpressibleByDictionaryLiteral: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ext: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneExt // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneExt - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneExt - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneExt: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum extDecoder: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneExtDecoder // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneExtDecoder - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneExtDecoder - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneExtDecoder: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum extendedGraphemeClusterLiteral: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneExtendedGraphemeClusterLiteral // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneExtendedGraphemeClusterLiteral - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneExtendedGraphemeClusterLiteral - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneExtendedGraphemeClusterLiteral: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ExtendedGraphemeClusterLiteralType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneExtendedGraphemeClusterLiteralType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneExtendedGraphemeClusterLiteralType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneExtendedGraphemeClusterLiteralType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneExtendedGraphemeClusterLiteralType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum extendee: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneExtendee // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneExtendee - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneExtendee - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneExtendee: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ExtensibleMessage: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneExtensibleMessage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneExtensibleMessage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneExtensibleMessage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneExtensibleMessage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum extensionEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneExtension // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneExtension - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneExtension - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneExtension: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ExtensionField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneExtensionField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneExtensionField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneExtensionField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneExtensionField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum extensionFieldNumber: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneExtensionFieldNumber // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneExtensionFieldNumber - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneExtensionFieldNumber - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneExtensionFieldNumber: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ExtensionFieldValueSet: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneExtensionFieldValueSet // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneExtensionFieldValueSet - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneExtensionFieldValueSet - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneExtensionFieldValueSet: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ExtensionMap: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneExtensionMap // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneExtensionMap - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneExtensionMap - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneExtensionMap: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum extensionRange: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneExtensionRange // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneExtensionRange - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneExtensionRange - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneExtensionRange: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ExtensionRangeOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneExtensionRangeOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneExtensionRangeOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneExtensionRangeOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneExtensionRangeOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum extensions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneExtensions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneExtensions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneExtensions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneExtensions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum extras: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneExtras // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneExtras - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneExtras - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneExtras: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum F: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneF // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneF - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneF - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneF: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum falseEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFalse // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFalse - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFalse - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFalse: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum fieldData: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFieldData // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFieldData - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFieldData - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFieldData: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum FieldDescriptorProto: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFieldDescriptorProto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFieldDescriptorProto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFieldDescriptorProto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFieldDescriptorProto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum FieldMask: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFieldMask // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFieldMask - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFieldMask - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFieldMask: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum fieldName: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFieldName // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFieldName - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFieldName - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFieldName: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum fieldNameCount: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFieldNameCount // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFieldNameCount - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFieldNameCount - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFieldNameCount: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum fieldNum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFieldNum // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFieldNum - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFieldNum - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFieldNum: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum fieldNumber: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFieldNumber // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFieldNumber - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFieldNumber - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFieldNumber: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum fieldNumberForProto: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFieldNumberForProto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFieldNumberForProto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFieldNumberForProto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFieldNumberForProto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum FieldOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFieldOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFieldOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFieldOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFieldOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum fields: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFields // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFields - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFields - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFields: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum fieldSize: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFieldSize // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFieldSize - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFieldSize - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFieldSize: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum FieldTag: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFieldTag // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFieldTag - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFieldTag - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFieldTag: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum fieldType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFieldType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFieldType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFieldType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFieldType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum file: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFile // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFile - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFile - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFile: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum FileDescriptorProto: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFileDescriptorProto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFileDescriptorProto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFileDescriptorProto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFileDescriptorProto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum FileDescriptorSet: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFileDescriptorSet // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFileDescriptorSet - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFileDescriptorSet - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFileDescriptorSet: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum fileName: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFileName // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFileName - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFileName - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFileName: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum FileOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFileOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFileOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFileOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFileOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum filter: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFilter // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFilter - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFilter - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFilter: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum first: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFirst // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFirst - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFirst - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFirst: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum firstItem: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFirstItem // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFirstItem - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFirstItem - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFirstItem: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum float: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFloat // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFloat - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFloat - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFloat: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum floatLiteral: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFloatLiteral // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFloatLiteral - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFloatLiteral - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFloatLiteral: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum FloatLiteralType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFloatLiteralType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFloatLiteralType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFloatLiteralType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFloatLiteralType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum FloatValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFloatValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFloatValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFloatValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFloatValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum forMessageName: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneForMessageName // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneForMessageName - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneForMessageName - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneForMessageName: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum formUnion: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFormUnion // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFormUnion - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFormUnion - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFormUnion: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum forReadingFrom: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneForReadingFrom // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneForReadingFrom - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneForReadingFrom - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneForReadingFrom: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum forTypeURL: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneForTypeURL // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneForTypeURL - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneForTypeURL - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneForTypeURL: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ForwardParser: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneForwardParser // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneForwardParser - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneForwardParser - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneForwardParser: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum forWritingInto: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneForWritingInto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneForWritingInto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneForWritingInto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneForWritingInto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum from: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFrom // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFrom - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFrom - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFrom: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum fromAscii2: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFromAscii2 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFromAscii2 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFromAscii2 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFromAscii2: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum fromAscii4: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFromAscii4 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFromAscii4 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFromAscii4 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFromAscii4: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum fromByteOffset: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFromByteOffset // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFromByteOffset - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFromByteOffset - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFromByteOffset: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum fromHexDigit: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFromHexDigit // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFromHexDigit - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFromHexDigit - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFromHexDigit: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum funcEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneFunc // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneFunc - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneFunc - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneFunc: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum G: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneG // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneG - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneG - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneG: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum GeneratedCodeInfo: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGeneratedCodeInfo // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGeneratedCodeInfo - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGeneratedCodeInfo - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGeneratedCodeInfo: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum get: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGet // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGet - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGet - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGet: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum getExtensionValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGetExtensionValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGetExtensionValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGetExtensionValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGetExtensionValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum googleapis: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleapis // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleapis - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleapis - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleapis: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_Any: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufAny // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufAny - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufAny - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufAny: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_Api: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufApi // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufApi - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufApi - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufApi: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_BoolValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufBoolValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufBoolValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufBoolValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufBoolValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_BytesValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufBytesValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufBytesValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufBytesValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufBytesValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_DescriptorProto: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufDescriptorProto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufDescriptorProto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufDescriptorProto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufDescriptorProto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_DoubleValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufDoubleValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufDoubleValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufDoubleValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufDoubleValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_Duration: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufDuration // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufDuration - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufDuration - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufDuration: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_Empty: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufEmpty // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufEmpty - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufEmpty - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufEmpty: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufEnum // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufEnum - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufEnum - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufEnum: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_EnumDescriptorProto: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufEnumDescriptorProto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufEnumDescriptorProto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufEnumDescriptorProto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufEnumDescriptorProto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_EnumOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufEnumOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufEnumOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufEnumOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufEnumOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_EnumValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufEnumValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufEnumValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufEnumValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufEnumValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_EnumValueDescriptorProto: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufEnumValueDescriptorProto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufEnumValueDescriptorProto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufEnumValueDescriptorProto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufEnumValueDescriptorProto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_EnumValueOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufEnumValueOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufEnumValueOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufEnumValueOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufEnumValueOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufExtensionRangeOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufExtensionRangeOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufExtensionRangeOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufExtensionRangeOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_FieldDescriptorProto: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufFieldDescriptorProto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufFieldDescriptorProto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufFieldDescriptorProto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufFieldDescriptorProto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_FieldMask: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufFieldMask // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufFieldMask - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufFieldMask - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufFieldMask: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_FieldOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufFieldOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufFieldOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufFieldOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufFieldOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufFileDescriptorProto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufFileDescriptorProto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufFileDescriptorProto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufFileDescriptorProto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_FileDescriptorSet: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufFileDescriptorSet // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufFileDescriptorSet - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufFileDescriptorSet - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufFileDescriptorSet: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_FileOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufFileOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufFileOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufFileOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufFileOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_FloatValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufFloatValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufFloatValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufFloatValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufFloatValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufGeneratedCodeInfo // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufGeneratedCodeInfo - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufGeneratedCodeInfo - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufGeneratedCodeInfo: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_Int32Value: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufInt32Value // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufInt32Value - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufInt32Value - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufInt32Value: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_Int64Value: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufInt64Value // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufInt64Value - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufInt64Value - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufInt64Value: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_ListValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufListValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufListValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufListValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufListValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_MessageOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufMessageOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufMessageOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufMessageOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufMessageOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_Method: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufMethod // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufMethod - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufMethod - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufMethod: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_MethodDescriptorProto: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufMethodDescriptorProto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufMethodDescriptorProto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufMethodDescriptorProto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufMethodDescriptorProto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_MethodOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufMethodOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufMethodOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufMethodOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufMethodOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_Mixin: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufMixin // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufMixin - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufMixin - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufMixin: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_NullValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufNullValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufNullValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufNullValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufNullValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_OneofDescriptorProto: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufOneofDescriptorProto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufOneofDescriptorProto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufOneofDescriptorProto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufOneofDescriptorProto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_OneofOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufOneofOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufOneofOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufOneofOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufOneofOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_Option: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufOption // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufOption - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufOption - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufOption: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufServiceDescriptorProto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufServiceDescriptorProto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufServiceDescriptorProto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufServiceDescriptorProto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_ServiceOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufServiceOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufServiceOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufServiceOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufServiceOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_SourceCodeInfo: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufSourceCodeInfo // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufSourceCodeInfo - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufSourceCodeInfo - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufSourceCodeInfo: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_SourceContext: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufSourceContext // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufSourceContext - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufSourceContext - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufSourceContext: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_StringValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufStringValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufStringValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufStringValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufStringValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_Struct: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufStruct // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufStruct - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufStruct - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufStruct: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_Syntax: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufSyntax // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufSyntax - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufSyntax - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufSyntax: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_Timestamp: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufTimestamp // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufTimestamp - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufTimestamp - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufTimestamp: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_Type: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_UInt32Value: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufUint32Value // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufUint32Value - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufUint32Value - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufUint32Value: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_UInt64Value: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufUint64Value // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufUint64Value - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufUint64Value - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufUint64Value: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_UninterpretedOption: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufUninterpretedOption // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufUninterpretedOption - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufUninterpretedOption - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufUninterpretedOption: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Google_Protobuf_Value: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoogleProtobufValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoogleProtobufValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoogleProtobufValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoogleProtobufValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum goPackage: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGoPackage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGoPackage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGoPackage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGoPackage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum group: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGroup // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGroup - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGroup - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGroup: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum groupFieldNumberStack: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGroupFieldNumberStack // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGroupFieldNumberStack - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGroupFieldNumberStack - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGroupFieldNumberStack: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum groupSize: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneGroupSize // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneGroupSize - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneGroupSize - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneGroupSize: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum h: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneH // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneH - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneH - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneH: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hadOneofValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHadOneofValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHadOneofValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHadOneofValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHadOneofValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum handleConflictingOneOf: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHandleConflictingOneOf // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHandleConflictingOneOf - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHandleConflictingOneOf - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHandleConflictingOneOf: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasAggregateValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasAggregateValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasAggregateValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasAggregateValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasAggregateValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasAllowAlias: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasAllowAlias // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasAllowAlias - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasAllowAlias - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasAllowAlias: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasBegin: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasBegin // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasBegin - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasBegin - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasBegin: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasCcEnableArenas: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasCcEnableArenas // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasCcEnableArenas - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasCcEnableArenas - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasCcEnableArenas: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasCcGenericServices: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasCcGenericServices // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasCcGenericServices - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasCcGenericServices - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasCcGenericServices: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasClientStreaming: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasClientStreaming // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasClientStreaming - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasClientStreaming - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasClientStreaming: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasCsharpNamespace: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasCsharpNamespace // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasCsharpNamespace - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasCsharpNamespace - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasCsharpNamespace: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasCtype: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasCtype // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasCtype - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasCtype - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasCtype: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasDefaultValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasDefaultValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasDefaultValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasDefaultValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasDefaultValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasDeprecated: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasDeprecated // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasDeprecated - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasDeprecated - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasDeprecated: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasDoubleValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasDoubleValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasDoubleValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasDoubleValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasDoubleValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasEnd: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasEnd // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasEnd - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasEnd - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasEnd: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasExtendee: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasExtendee // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasExtendee - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasExtendee - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasExtendee: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasExtensionValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasExtensionValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasExtensionValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasExtensionValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasExtensionValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasGoPackage: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasGoPackage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasGoPackage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasGoPackage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasGoPackage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hash: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHash // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHash - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHash - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHash: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Hashable: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHashable // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHashable - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHashable - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHashable: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasher: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasher // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasher - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasher - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasher: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hashValueEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHashValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHashValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHashValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHashValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum HashVisitor: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHashVisitor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHashVisitor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHashVisitor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHashVisitor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasIdempotencyLevel: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasIdempotencyLevel // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasIdempotencyLevel - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasIdempotencyLevel - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasIdempotencyLevel: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasIdentifierValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasIdentifierValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasIdentifierValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasIdentifierValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasIdentifierValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasInputType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasInputType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasInputType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasInputType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasInputType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasIsExtension: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasIsExtension // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasIsExtension - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasIsExtension - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasIsExtension: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasJavaGenerateEqualsAndHash: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasJavaGenerateEqualsAndHash // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasJavaGenerateEqualsAndHash - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasJavaGenerateEqualsAndHash - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasJavaGenerateEqualsAndHash: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasJavaGenericServices: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasJavaGenericServices // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasJavaGenericServices - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasJavaGenericServices - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasJavaGenericServices: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasJavaMultipleFiles: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasJavaMultipleFiles // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasJavaMultipleFiles - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasJavaMultipleFiles - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasJavaMultipleFiles: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasJavaOuterClassname: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasJavaOuterClassname // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasJavaOuterClassname - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasJavaOuterClassname - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasJavaOuterClassname: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasJavaPackage: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasJavaPackage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasJavaPackage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasJavaPackage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasJavaPackage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasJavaStringCheckUtf8: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasJavaStringCheckUtf8 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasJavaStringCheckUtf8 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasJavaStringCheckUtf8 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasJavaStringCheckUtf8: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasJsonName: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasJsonName // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasJsonName - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasJsonName - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasJsonName: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasJstype: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasJstype // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasJstype - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasJstype - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasJstype: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasLabel: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasLabel // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasLabel - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasLabel - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasLabel: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasLazy: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasLazy // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasLazy - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasLazy - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasLazy: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasLeadingComments: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasLeadingComments // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasLeadingComments - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasLeadingComments - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasLeadingComments: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasMapEntry: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasMapEntry // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasMapEntry - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasMapEntry - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasMapEntry: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasMessageSetWireFormat: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasMessageSetWireFormat // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasMessageSetWireFormat - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasMessageSetWireFormat - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasMessageSetWireFormat: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasName: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasName // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasName - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasName - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasName: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasNamePart: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasNamePart // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasNamePart - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasNamePart - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasNamePart: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasNegativeIntValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasNegativeIntValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasNegativeIntValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasNegativeIntValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasNegativeIntValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasNoStandardDescriptorAccessor: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasNoStandardDescriptorAccessor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasNoStandardDescriptorAccessor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasNoStandardDescriptorAccessor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasNoStandardDescriptorAccessor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasNumber: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasNumber // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasNumber - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasNumber - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasNumber: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasObjcClassPrefix: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasObjcClassPrefix // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasObjcClassPrefix - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasObjcClassPrefix - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasObjcClassPrefix: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasOneofIndex: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasOneofIndex // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasOneofIndex - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasOneofIndex - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasOneofIndex: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasOptimizeFor: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasOptimizeFor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasOptimizeFor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasOptimizeFor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasOptimizeFor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasOutputType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasOutputType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasOutputType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasOutputType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasOutputType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasPackage: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasPackage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasPackage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasPackage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasPackage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasPacked: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasPacked // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasPacked - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasPacked - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasPacked: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasPhpClassPrefix: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasPhpClassPrefix // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasPhpClassPrefix - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasPhpClassPrefix - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasPhpClassPrefix: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasPhpGenericServices: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasPhpGenericServices // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasPhpGenericServices - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasPhpGenericServices - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasPhpGenericServices: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasPhpMetadataNamespace: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasPhpMetadataNamespace // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasPhpMetadataNamespace - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasPhpMetadataNamespace - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasPhpMetadataNamespace: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasPhpNamespace: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasPhpNamespace // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasPhpNamespace - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasPhpNamespace - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasPhpNamespace: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasPositiveIntValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasPositiveIntValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasPositiveIntValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasPositiveIntValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasPositiveIntValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasProto3Optional: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasProto3Optional // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasProto3Optional - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasProto3Optional - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasProto3Optional: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasPyGenericServices: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasPyGenericServices // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasPyGenericServices - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasPyGenericServices - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasPyGenericServices: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasRubyPackage: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasRubyPackage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasRubyPackage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasRubyPackage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasRubyPackage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasServerStreaming: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasServerStreaming // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasServerStreaming - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasServerStreaming - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasServerStreaming: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasSourceCodeInfo: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasSourceCodeInfo // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasSourceCodeInfo - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasSourceCodeInfo - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasSourceCodeInfo: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasSourceContext: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasSourceContext // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasSourceContext - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasSourceContext - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasSourceContext: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasSourceFile: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasSourceFile // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasSourceFile - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasSourceFile - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasSourceFile: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasStart: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasStart // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasStart - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasStart - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasStart: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasStringValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasStringValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasStringValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasStringValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasStringValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasSwiftPrefix: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasSwiftPrefix // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasSwiftPrefix - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasSwiftPrefix - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasSwiftPrefix: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasSyntax: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasSyntax // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasSyntax - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasSyntax - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasSyntax: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasTrailingComments: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasTrailingComments // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasTrailingComments - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasTrailingComments - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasTrailingComments: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasTypeName: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasTypeName // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasTypeName - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasTypeName - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasTypeName: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hasWeak: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHasWeak // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHasWeak - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHasWeak - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHasWeak: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum hour: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneHour // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneHour - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneHour - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneHour: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum i: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneI // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneI - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneI - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneI: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum idempotencyLevel: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneIdempotencyLevel // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneIdempotencyLevel - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneIdempotencyLevel - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneIdempotencyLevel: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum identifierValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneIdentifierValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneIdentifierValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneIdentifierValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneIdentifierValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ifEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneIf // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneIf - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneIf - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneIf: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ignoreUnknownFields: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneIgnoreUnknownFields // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneIgnoreUnknownFields - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneIgnoreUnknownFields - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneIgnoreUnknownFields: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum index: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneIndex // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneIndex - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneIndex - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneIndex: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum initEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneInit // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneInit - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneInit - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneInit: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum inoutEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneInout // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneInout - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneInout - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneInout: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum inputType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneInputType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneInputType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneInputType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneInputType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum insert: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneInsert // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneInsert - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneInsert - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneInsert: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum IntEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneInt // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneInt - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneInt - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneInt: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Int32Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneInt32 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneInt32 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneInt32 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneInt32: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Int32Value: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneInt32Value // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneInt32Value - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneInt32Value - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneInt32Value: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Int64Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneInt64 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneInt64 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneInt64 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneInt64: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Int64Value: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneInt64Value // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneInt64Value - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneInt64Value - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneInt64Value: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Int8: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneInt8 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneInt8 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneInt8 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneInt8: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum integerLiteral: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneIntegerLiteral // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneIntegerLiteral - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneIntegerLiteral - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneIntegerLiteral: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum IntegerLiteralType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneIntegerLiteralType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneIntegerLiteralType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneIntegerLiteralType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneIntegerLiteralType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum intern: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneIntern // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneIntern - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneIntern - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneIntern: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Internal: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneInternal // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneInternal - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneInternal - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneInternal: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum InternalState: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneInternalState // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneInternalState - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneInternalState - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneInternalState: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum into: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneInto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneInto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneInto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneInto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ints: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneInts // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneInts - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneInts - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneInts: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum isA: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneIsA // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneIsA - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneIsA - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneIsA: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum isEqual: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneIsEqual // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneIsEqual - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneIsEqual - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneIsEqual: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum isEqualTo: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneIsEqualTo // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneIsEqualTo - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneIsEqualTo - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneIsEqualTo: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum isExtension: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneIsExtension // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneIsExtension - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneIsExtension - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneIsExtension: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum isInitializedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneIsInitialized // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneIsInitialized - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneIsInitialized - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneIsInitialized: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum itemTagsEncodedSize: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneItemTagsEncodedSize // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneItemTagsEncodedSize - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneItemTagsEncodedSize - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneItemTagsEncodedSize: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Iterator: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneIterator // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneIterator - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneIterator - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneIterator: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum i_2166136261: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneI2166136261 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneI2166136261 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneI2166136261 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneI2166136261: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum javaGenerateEqualsAndHash: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJavaGenerateEqualsAndHash // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJavaGenerateEqualsAndHash - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJavaGenerateEqualsAndHash - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJavaGenerateEqualsAndHash: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum javaGenericServices: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJavaGenericServices // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJavaGenericServices - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJavaGenericServices - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJavaGenericServices: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum javaMultipleFiles: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJavaMultipleFiles // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJavaMultipleFiles - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJavaMultipleFiles - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJavaMultipleFiles: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum javaOuterClassname: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJavaOuterClassname // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJavaOuterClassname - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJavaOuterClassname - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJavaOuterClassname: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum javaPackage: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJavaPackage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJavaPackage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJavaPackage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJavaPackage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum javaStringCheckUtf8: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJavaStringCheckUtf8 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJavaStringCheckUtf8 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJavaStringCheckUtf8 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJavaStringCheckUtf8: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum JSONDecoder: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJsondecoder // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJsondecoder - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJsondecoder - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJsondecoder: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum JSONDecodingError: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJsondecodingError // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJsondecodingError - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJsondecodingError - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJsondecodingError: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum JSONDecodingOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJsondecodingOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJsondecodingOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJsondecodingOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJsondecodingOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum jsonEncoder: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJsonEncoder // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJsonEncoder - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJsonEncoder - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJsonEncoder: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum JSONEncodingError: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJsonencodingError // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJsonencodingError - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJsonencodingError - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJsonencodingError: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum JSONEncodingOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJsonencodingOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJsonencodingOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJsonencodingOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJsonencodingOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum JSONEncodingVisitor: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJsonencodingVisitor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJsonencodingVisitor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJsonencodingVisitor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJsonencodingVisitor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum JSONMapEncodingVisitor: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJsonmapEncodingVisitor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJsonmapEncodingVisitor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJsonmapEncodingVisitor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJsonmapEncodingVisitor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum jsonName: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJsonName // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJsonName - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJsonName - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJsonName: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum jsonPath: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJsonPath // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJsonPath - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJsonPath - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJsonPath: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum jsonPaths: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJsonPaths // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJsonPaths - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJsonPaths - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJsonPaths: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum JSONScanner: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJsonscanner // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJsonscanner - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJsonscanner - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJsonscanner: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum jsonString: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJsonString // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJsonString - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJsonString - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJsonString: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum jsonText: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJsonText // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJsonText - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJsonText - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJsonText: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum jsonUTF8Data: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJsonUtf8Data // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJsonUtf8Data - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJsonUtf8Data - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJsonUtf8Data: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum jstype: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneJstype // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneJstype - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneJstype - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneJstype: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum k: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneK // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneK - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneK - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneK: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Key: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneKey // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneKey - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneKey - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneKey: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum keyField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneKeyField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneKeyField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneKeyField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneKeyField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum KeyType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneKeyType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneKeyType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneKeyType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneKeyType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum kind: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneKind // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneKind - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneKind - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneKind: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum l: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneL // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneL - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneL - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneL: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum label: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneLabel // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneLabel - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneLabel - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneLabel: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum lazy: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneLazy // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneLazy - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneLazy - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneLazy: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum leadingComments: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneLeadingComments // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneLeadingComments - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneLeadingComments - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneLeadingComments: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum leadingDetachedComments: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneLeadingDetachedComments // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneLeadingDetachedComments - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneLeadingDetachedComments - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneLeadingDetachedComments: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum length: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneLength // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneLength - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneLength - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneLength: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum lessThan: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneLessThan // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneLessThan - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneLessThan - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneLessThan: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum letEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneLet // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneLet - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneLet - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneLet: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum lhs: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneLhs // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneLhs - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneLhs - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneLhs: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum list: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneList // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneList - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneList - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneList: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum listOfMessages: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneListOfMessages // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneListOfMessages - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneListOfMessages - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneListOfMessages: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum listValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneListValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneListValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneListValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneListValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum littleEndian: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneLittleEndian // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneLittleEndian - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneLittleEndian - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneLittleEndian: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum littleEndianBytes: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneLittleEndianBytes // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneLittleEndianBytes - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneLittleEndianBytes - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneLittleEndianBytes: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum load: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneLoad // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneLoad - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneLoad - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneLoad: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum localHasher: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneLocalHasher // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneLocalHasher - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneLocalHasher - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneLocalHasher: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum location: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneLocation // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneLocation - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneLocation - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneLocation: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum M: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneM // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneM - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneM - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneM: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum major: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMajor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMajor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMajor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMajor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum makeIterator: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMakeIterator // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMakeIterator - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMakeIterator - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMakeIterator: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum mapEntry: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMapEntry // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMapEntry - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMapEntry - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMapEntry: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum mapHash: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMapHash // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMapHash - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMapHash - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMapHash: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum MapKeyType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMapKeyType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMapKeyType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMapKeyType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMapKeyType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum mapNameResolver: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMapNameResolver // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMapNameResolver - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMapNameResolver - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMapNameResolver: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum mapToMessages: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMapToMessages // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMapToMessages - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMapToMessages - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMapToMessages: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum MapValueType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMapValueType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMapValueType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMapValueType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMapValueType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum mapVisitor: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMapVisitor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMapVisitor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMapVisitor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMapVisitor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum mdayStart: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMdayStart // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMdayStart - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMdayStart - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMdayStart: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum merge: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMerge // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMerge - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMerge - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMerge: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum message: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMessage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMessage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMessage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMessage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum messageDepthLimit: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMessageDepthLimit // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMessageDepthLimit - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMessageDepthLimit - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMessageDepthLimit: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum MessageExtension: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMessageExtension // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMessageExtension - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMessageExtension - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMessageExtension: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum MessageImplementationBase: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMessageImplementationBase // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMessageImplementationBase - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMessageImplementationBase - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMessageImplementationBase: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum MessageOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMessageOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMessageOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMessageOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMessageOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum MessageSet: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMessageSet // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMessageSet - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMessageSet - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMessageSet: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum messageSetWireFormat: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMessageSetWireFormat // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMessageSetWireFormat - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMessageSetWireFormat - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMessageSetWireFormat: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum messageType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMessageType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMessageType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMessageType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMessageType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Method: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMethod // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMethod - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMethod - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMethod: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum MethodDescriptorProto: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMethodDescriptorProto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMethodDescriptorProto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMethodDescriptorProto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMethodDescriptorProto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum MethodOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMethodOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMethodOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMethodOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMethodOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum methods: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMethods // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMethods - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMethods - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMethods: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum minor: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMinor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMinor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMinor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMinor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Mixin: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMixin // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMixin - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMixin - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMixin: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum mixins: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMixins // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMixins - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMixins - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMixins: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum modifier: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneModifier // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneModifier - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneModifier - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneModifier: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum modify: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneModify // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneModify - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneModify - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneModify: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum month: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMonth // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMonth - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMonth - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMonth: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum msgExtension: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMsgExtension // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMsgExtension - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMsgExtension - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMsgExtension: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum mutating: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneMutating // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneMutating - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneMutating - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneMutating: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum n: SwiftProtobuf.Enum { - typealias RawValue = Int - case oneN // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .oneN - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .oneN - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .oneN: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum name: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneName // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneName - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneName - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneName: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum NameDescription: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNameDescription // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNameDescription - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNameDescription - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNameDescription: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum NameMap: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNameMap // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNameMap - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNameMap - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNameMap: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum NamePart: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNamePart // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNamePart - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNamePart - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNamePart: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum nameResolver: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNameResolver // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNameResolver - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNameResolver - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNameResolver: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum names: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNames // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNames - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNames - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNames: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum nanos: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNanos // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNanos - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNanos - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNanos: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum nativeBytes: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNativeBytes // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNativeBytes - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNativeBytes - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNativeBytes: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum nativeEndianBytes: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNativeEndianBytes // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNativeEndianBytes - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNativeEndianBytes - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNativeEndianBytes: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum negativeIntValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNegativeIntValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNegativeIntValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNegativeIntValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNegativeIntValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum nestedType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNestedType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNestedType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNestedType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNestedType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum newL: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNewL // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNewL - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNewL - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNewL: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum newList: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNewList // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNewList - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNewList - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNewList: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum newValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNewValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNewValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNewValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNewValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum nextByte: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNextByte // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNextByte - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNextByte - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNextByte: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum nextFieldNumber: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNextFieldNumber // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNextFieldNumber - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNextFieldNumber - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNextFieldNumber: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum nilEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNil // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNil - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNil - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNil: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum nilLiteral: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNilLiteral // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNilLiteral - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNilLiteral - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNilLiteral: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum noStandardDescriptorAccessor: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNoStandardDescriptorAccessor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNoStandardDescriptorAccessor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNoStandardDescriptorAccessor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNoStandardDescriptorAccessor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum nullValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNullValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNullValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNullValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNullValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum number: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNumber // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNumber - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNumber - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNumber: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum numberValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneNumberValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneNumberValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneNumberValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneNumberValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum objcClassPrefix: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneObjcClassPrefix // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneObjcClassPrefix - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneObjcClassPrefix - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneObjcClassPrefix: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum of: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOf // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOf - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOf - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOf: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum oneofDecl: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOneofDecl // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOneofDecl - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOneofDecl - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOneofDecl: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum OneofDescriptorProto: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOneofDescriptorProto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOneofDescriptorProto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOneofDescriptorProto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOneofDescriptorProto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum oneofIndex: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOneofIndex // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOneofIndex - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOneofIndex - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOneofIndex: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum OneofOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOneofOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOneofOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOneofOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOneofOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum oneofs: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOneofs // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOneofs - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOneofs - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOneofs: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum OneOf_Kind: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOneOfKind // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOneOfKind - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOneOfKind - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOneOfKind: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum optimizeFor: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOptimizeFor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOptimizeFor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOptimizeFor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOptimizeFor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum OptimizeMode: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOptimizeMode // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOptimizeMode - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOptimizeMode - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOptimizeMode: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Option: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOption // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOption - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOption - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOption: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum OptionalEnumExtensionField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOptionalEnumExtensionField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOptionalEnumExtensionField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOptionalEnumExtensionField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOptionalEnumExtensionField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum OptionalExtensionField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOptionalExtensionField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOptionalExtensionField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOptionalExtensionField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOptionalExtensionField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum OptionalGroupExtensionField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOptionalGroupExtensionField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOptionalGroupExtensionField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOptionalGroupExtensionField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOptionalGroupExtensionField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum OptionalMessageExtensionField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOptionalMessageExtensionField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOptionalMessageExtensionField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOptionalMessageExtensionField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOptionalMessageExtensionField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum options: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum other: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOther // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOther - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOther - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOther: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum others: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOthers // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOthers - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOthers - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOthers: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum out: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOut // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOut - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOut - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOut: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum outputType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneOutputType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneOutputType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneOutputType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneOutputType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum p: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneP // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneP - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneP - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneP: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum package: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePackage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePackage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePackage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePackage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum packed: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePacked // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePacked - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePacked - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePacked: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum PackedEnumExtensionField: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePackedEnumExtensionField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePackedEnumExtensionField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePackedEnumExtensionField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePackedEnumExtensionField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum PackedExtensionField: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePackedExtensionField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePackedExtensionField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePackedExtensionField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePackedExtensionField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum padding: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePadding // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePadding - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePadding - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePadding: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum parent: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneParent // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneParent - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneParent - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneParent: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum parse: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneParse // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneParse - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneParse - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneParse: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum partial: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePartial // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePartial - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePartial - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePartial: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum path: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePath // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePath - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePath - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePath: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum paths: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePaths // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePaths - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePaths - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePaths: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum payload: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePayload // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePayload - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePayload - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePayload: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum payloadSize: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePayloadSize // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePayloadSize - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePayloadSize - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePayloadSize: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum phpClassPrefix: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePhpClassPrefix // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePhpClassPrefix - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePhpClassPrefix - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePhpClassPrefix: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum phpGenericServices: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePhpGenericServices // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePhpGenericServices - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePhpGenericServices - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePhpGenericServices: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum phpMetadataNamespace: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePhpMetadataNamespace // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePhpMetadataNamespace - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePhpMetadataNamespace - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePhpMetadataNamespace: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum phpNamespace: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePhpNamespace // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePhpNamespace - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePhpNamespace - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePhpNamespace: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum pointer: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePointer // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePointer - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePointer - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePointer: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum pos: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePos // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePos - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePos - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePos: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum positiveIntValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePositiveIntValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePositiveIntValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePositiveIntValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePositiveIntValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum prefix: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePrefix // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePrefix - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePrefix - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePrefix: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum preserveProtoFieldNames: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePreserveProtoFieldNames // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePreserveProtoFieldNames - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePreserveProtoFieldNames - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePreserveProtoFieldNames: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum preTraverse: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePreTraverse // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePreTraverse - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePreTraverse - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePreTraverse: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum printUnknownFields: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePrintUnknownFields // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePrintUnknownFields - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePrintUnknownFields - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePrintUnknownFields: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum proto2: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProto2 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProto2 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProto2 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProto2: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum proto3DefaultValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProto3DefaultValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProto3DefaultValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProto3DefaultValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProto3DefaultValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum proto3Optional: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProto3Optional // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProto3Optional - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProto3Optional - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProto3Optional: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufAPIVersionCheck: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufApiversionCheck // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufApiversionCheck - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufApiversionCheck - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufApiversionCheck: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufAPIVersion_2: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufApiversion2 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufApiversion2 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufApiversion2 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufApiversion2: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufBool: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufBool // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufBool - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufBool - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufBool: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufBytes: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufBytes // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufBytes - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufBytes - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufBytes: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufDouble: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufDouble // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufDouble - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufDouble - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufDouble: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufEnumMap: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufEnumMap // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufEnumMap - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufEnumMap - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufEnumMap: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum protobufExtension: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufExtension // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufExtension - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufExtension - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufExtension: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufFixed32: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufFixed32 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufFixed32 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufFixed32 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufFixed32: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufFixed64: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufFixed64 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufFixed64 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufFixed64 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufFixed64: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufFloat: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufFloat // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufFloat - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufFloat - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufFloat: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufInt32: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufInt32 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufInt32 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufInt32 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufInt32: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufInt64: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufInt64 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufInt64 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufInt64 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufInt64: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufMap: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufMap // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufMap - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufMap - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufMap: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufMessageMap: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufMessageMap // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufMessageMap - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufMessageMap - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufMessageMap: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufSFixed32: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufSfixed32 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufSfixed32 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufSfixed32 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufSfixed32: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufSFixed64: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufSfixed64 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufSfixed64 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufSfixed64 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufSfixed64: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufSInt32: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufSint32 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufSint32 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufSint32 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufSint32: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufSInt64: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufSint64 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufSint64 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufSint64 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufSint64: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufString: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufString // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufString - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufString - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufString: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufUInt32: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufUint32 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufUint32 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufUint32 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufUint32: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtobufUInt64: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufUint64 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufUint64 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufUint64 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufUint64: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum protobuf_extensionFieldValues: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufExtensionFieldValues // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufExtensionFieldValues - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufExtensionFieldValues - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufExtensionFieldValues: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum protobuf_fieldNumber: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufFieldNumber // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufFieldNumber - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufFieldNumber - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufFieldNumber: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum protobuf_generated_isEqualTo: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufGeneratedIsEqualTo // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufGeneratedIsEqualTo - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufGeneratedIsEqualTo - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufGeneratedIsEqualTo: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum protobuf_nameMap: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufNameMap // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufNameMap - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufNameMap - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufNameMap: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum protobuf_newField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufNewField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufNewField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufNewField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufNewField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum protobuf_package: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtobufPackage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtobufPackage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtobufPackage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtobufPackage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum protocolEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtocol // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtocol - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtocol - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtocol: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum protoFieldName: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtoFieldName // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtoFieldName - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtoFieldName - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtoFieldName: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum protoMessageNameEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtoMessageName // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtoMessageName - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtoMessageName - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtoMessageName: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ProtoNameProviding: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtoNameProviding // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtoNameProviding - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtoNameProviding - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtoNameProviding: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum protoPaths: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneProtoPaths // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneProtoPaths - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneProtoPaths - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneProtoPaths: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum publicEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePublic // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePublic - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePublic - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePublic: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum publicDependency: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePublicDependency // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePublicDependency - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePublicDependency - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePublicDependency: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum putBoolValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePutBoolValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePutBoolValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePutBoolValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePutBoolValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum putBytesValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePutBytesValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePutBytesValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePutBytesValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePutBytesValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum putDoubleValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePutDoubleValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePutDoubleValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePutDoubleValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePutDoubleValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum putEnumValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePutEnumValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePutEnumValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePutEnumValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePutEnumValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum putFixedUInt32: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePutFixedUint32 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePutFixedUint32 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePutFixedUint32 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePutFixedUint32: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum putFixedUInt64: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePutFixedUint64 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePutFixedUint64 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePutFixedUint64 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePutFixedUint64: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum putFloatValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePutFloatValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePutFloatValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePutFloatValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePutFloatValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum putInt64: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePutInt64 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePutInt64 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePutInt64 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePutInt64: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum putStringValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePutStringValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePutStringValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePutStringValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePutStringValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum putUInt64: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePutUint64 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePutUint64 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePutUint64 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePutUint64: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum putUInt64Hex: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePutUint64Hex // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePutUint64Hex - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePutUint64Hex - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePutUint64Hex: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum putVarInt: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePutVarInt // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePutVarInt - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePutVarInt - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePutVarInt: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum putZigZagVarInt: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePutZigZagVarInt // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePutZigZagVarInt - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePutZigZagVarInt - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePutZigZagVarInt: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum pyGenericServices: SwiftProtobuf.Enum { - typealias RawValue = Int - case nonePyGenericServices // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .nonePyGenericServices - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .nonePyGenericServices - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .nonePyGenericServices: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum rawChars: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneRawChars // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneRawChars - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneRawChars - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneRawChars: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum RawRepresentable: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneRawRepresentable // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneRawRepresentable - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneRawRepresentable - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneRawRepresentable: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum RawValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneRawValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneRawValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneRawValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneRawValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum read4HexDigits: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneRead4HexDigits // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneRead4HexDigits - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneRead4HexDigits - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneRead4HexDigits: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum register: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneRegister // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneRegister - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneRegister - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneRegister: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum RepeatedEnumExtensionField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneRepeatedEnumExtensionField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneRepeatedEnumExtensionField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneRepeatedEnumExtensionField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneRepeatedEnumExtensionField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum RepeatedExtensionField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneRepeatedExtensionField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneRepeatedExtensionField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneRepeatedExtensionField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneRepeatedExtensionField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum RepeatedGroupExtensionField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneRepeatedGroupExtensionField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneRepeatedGroupExtensionField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneRepeatedGroupExtensionField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneRepeatedGroupExtensionField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum RepeatedMessageExtensionField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneRepeatedMessageExtensionField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneRepeatedMessageExtensionField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneRepeatedMessageExtensionField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneRepeatedMessageExtensionField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum requestStreaming: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneRequestStreaming // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneRequestStreaming - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneRequestStreaming - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneRequestStreaming: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum requestTypeURL: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneRequestTypeURL // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneRequestTypeURL - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneRequestTypeURL - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneRequestTypeURL: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum requiredSize: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneRequiredSize // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneRequiredSize - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneRequiredSize - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneRequiredSize: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum reservedName: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneReservedName // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneReservedName - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneReservedName - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneReservedName: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum reservedRange: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneReservedRange // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneReservedRange - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneReservedRange - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneReservedRange: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum responseStreaming: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneResponseStreaming // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneResponseStreaming - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneResponseStreaming - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneResponseStreaming: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum responseTypeURL: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneResponseTypeURL // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneResponseTypeURL - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneResponseTypeURL - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneResponseTypeURL: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum result: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneResult // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneResult - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneResult - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneResult: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum rethrowsEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneRethrows // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneRethrows - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneRethrows - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneRethrows: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum returnEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneReturn // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneReturn - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneReturn - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneReturn: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ReturnType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneReturnType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneReturnType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneReturnType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneReturnType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum revision: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneRevision // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneRevision - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneRevision - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneRevision: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum rhs: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneRhs // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneRhs - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneRhs - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneRhs: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum root: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneRoot // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneRoot - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneRoot - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneRoot: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum rubyPackage: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneRubyPackage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneRubyPackage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneRubyPackage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneRubyPackage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum s: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneS // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneS - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneS - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneS: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum sawBackslash: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSawBackslash // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSawBackslash - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSawBackslash - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSawBackslash: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum sawSection4Characters: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSawSection4Characters // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSawSection4Characters - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSawSection4Characters - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSawSection4Characters: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum sawSection5Characters: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSawSection5Characters // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSawSection5Characters - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSawSection5Characters - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSawSection5Characters: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum scanner: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneScanner // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneScanner - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneScanner - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneScanner: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum seconds: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSeconds // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSeconds - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSeconds - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSeconds: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum selfEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSelf // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSelf - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSelf - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSelf: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum separator: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSeparator // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSeparator - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSeparator - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSeparator: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum serialize: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSerialize // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSerialize - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSerialize - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSerialize: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum serializedData: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSerializedData // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSerializedData - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSerializedData - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSerializedData: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum serializedSize: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSerializedSize // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSerializedSize - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSerializedSize - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSerializedSize: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum serverStreaming: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneServerStreaming // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneServerStreaming - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneServerStreaming - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneServerStreaming: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum service: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneService // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneService - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneService - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneService: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ServiceDescriptorProto: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneServiceDescriptorProto // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneServiceDescriptorProto - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneServiceDescriptorProto - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneServiceDescriptorProto: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ServiceOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneServiceOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneServiceOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneServiceOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneServiceOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum set: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSet // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSet - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSet - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSet: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum setExtensionValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSetExtensionValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSetExtensionValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSetExtensionValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSetExtensionValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum shift: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneShift // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneShift - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneShift - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneShift: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum SimpleExtensionMap: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSimpleExtensionMap // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSimpleExtensionMap - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSimpleExtensionMap - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSimpleExtensionMap: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum sizer: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSizer // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSizer - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSizer - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSizer: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum source: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSource // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSource - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSource - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSource: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum sourceCodeInfo: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSourceCodeInfo // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSourceCodeInfo - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSourceCodeInfo - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSourceCodeInfo: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum sourceContext: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSourceContext // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSourceContext - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSourceContext - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSourceContext: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum sourceEncoding: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSourceEncoding // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSourceEncoding - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSourceEncoding - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSourceEncoding: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum sourceFile: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSourceFile // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSourceFile - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSourceFile - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSourceFile: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum span: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSpan // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSpan - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSpan - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSpan: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum split: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSplit // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSplit - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSplit - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSplit: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum start: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneStart // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneStart - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneStart - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneStart: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum startArray: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneStartArray // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneStartArray - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneStartArray - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneStartArray: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum startArrayObject: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneStartArrayObject // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneStartArrayObject - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneStartArrayObject - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneStartArrayObject: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum startField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneStartField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneStartField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneStartField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneStartField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum startIndex: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneStartIndex // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneStartIndex - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneStartIndex - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneStartIndex: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum startMessageField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneStartMessageField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneStartMessageField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneStartMessageField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneStartMessageField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum startObject: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneStartObject // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneStartObject - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneStartObject - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneStartObject: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum startRegularField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneStartRegularField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneStartRegularField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneStartRegularField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneStartRegularField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum state: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneState // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneState - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneState - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneState: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum staticEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneStatic // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneStatic - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneStatic - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneStatic: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum StaticString: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneStaticString // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneStaticString - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneStaticString - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneStaticString: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum storage: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneStorage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneStorage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneStorage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneStorage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum StringEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneString // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneString - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneString - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneString: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum stringLiteral: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneStringLiteral // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneStringLiteral - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneStringLiteral - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneStringLiteral: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum StringLiteralType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneStringLiteralType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneStringLiteralType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneStringLiteralType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneStringLiteralType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum stringResult: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneStringResult // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneStringResult - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneStringResult - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneStringResult: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum stringValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneStringValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneStringValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneStringValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneStringValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum structEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneStruct // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneStruct - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneStruct - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneStruct: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum structValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneStructValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneStructValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneStructValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneStructValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum subDecoder: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSubDecoder // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSubDecoder - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSubDecoder - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSubDecoder: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum subscriptEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSubscript // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSubscript - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSubscript - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSubscript: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum subVisitor: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSubVisitor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSubVisitor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSubVisitor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSubVisitor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Swift: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSwift // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSwift - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSwift - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSwift: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum swiftPrefix: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSwiftPrefix // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSwiftPrefix - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSwiftPrefix - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSwiftPrefix: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum SwiftProtobufEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSwiftProtobuf // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSwiftProtobuf - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSwiftProtobuf - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSwiftProtobuf: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum syntax: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneSyntax // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneSyntax - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneSyntax - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneSyntax: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum T: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneT // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneT - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneT - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneT: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum tag: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTag // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTag - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTag - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTag: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum terminator: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTerminator // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTerminator - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTerminator - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTerminator: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum testDecoder: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTestDecoder // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTestDecoder - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTestDecoder - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTestDecoder: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum text: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneText // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneText - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneText - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneText: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum textDecoder: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTextDecoder // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTextDecoder - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTextDecoder - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTextDecoder: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum TextFormatDecoder: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTextFormatDecoder // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTextFormatDecoder - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTextFormatDecoder - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTextFormatDecoder: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum TextFormatDecodingError: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTextFormatDecodingError // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTextFormatDecodingError - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTextFormatDecodingError - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTextFormatDecodingError: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum TextFormatDecodingOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTextFormatDecodingOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTextFormatDecodingOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTextFormatDecodingOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTextFormatDecodingOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum TextFormatEncodingOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTextFormatEncodingOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTextFormatEncodingOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTextFormatEncodingOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTextFormatEncodingOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum TextFormatEncodingVisitor: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTextFormatEncodingVisitor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTextFormatEncodingVisitor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTextFormatEncodingVisitor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTextFormatEncodingVisitor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum textFormatString: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTextFormatString // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTextFormatString - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTextFormatString - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTextFormatString: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum throwsEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneThrows // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneThrows - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneThrows - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneThrows: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum timeInterval: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTimeInterval // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTimeInterval - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTimeInterval - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTimeInterval: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum timeIntervalSince1970: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTimeIntervalSince1970 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTimeIntervalSince1970 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTimeIntervalSince1970 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTimeIntervalSince1970: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum timeIntervalSinceReferenceDate: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTimeIntervalSinceReferenceDate // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTimeIntervalSinceReferenceDate - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTimeIntervalSinceReferenceDate - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTimeIntervalSinceReferenceDate: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Timestamp: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTimestamp // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTimestamp - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTimestamp - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTimestamp: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum total: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTotal // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTotal - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTotal - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTotal: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum totalArrayDepth: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTotalArrayDepth // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTotalArrayDepth - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTotalArrayDepth - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTotalArrayDepth: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum totalSize: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTotalSize // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTotalSize - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTotalSize - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTotalSize: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum trailingComments: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTrailingComments // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTrailingComments - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTrailingComments - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTrailingComments: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum traverseEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTraverse // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTraverse - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTraverse - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTraverse: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum trueEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTrue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTrue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTrue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTrue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum tryEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTry // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTry - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTry - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTry: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum type: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum typealiasEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTypealias // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTypealias - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTypealias - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTypealias: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum TypeEnumEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTypeEnum // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTypeEnum - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTypeEnum - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTypeEnum: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum typeName: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTypeName // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTypeName - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTypeName - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTypeName: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum typePrefix: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTypePrefix // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTypePrefix - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTypePrefix - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTypePrefix: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum typeStart: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTypeStart // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTypeStart - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTypeStart - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTypeStart: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum typeUnknown: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTypeUnknown // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTypeUnknown - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTypeUnknown - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTypeUnknown: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum typeURL: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneTypeURL // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneTypeURL - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneTypeURL - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneTypeURL: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum UInt32Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUint32 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUint32 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUint32 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUint32: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum UInt32Value: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUint32Value // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUint32Value - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUint32Value - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUint32Value: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum UInt64Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUint64 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUint64 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUint64 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUint64: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum UInt64Value: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUint64Value // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUint64Value - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUint64Value - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUint64Value: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum UInt8: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUint8 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUint8 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUint8 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUint8: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum unicodeScalarLiteral: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUnicodeScalarLiteral // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUnicodeScalarLiteral - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUnicodeScalarLiteral - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUnicodeScalarLiteral: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum UnicodeScalarLiteralType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUnicodeScalarLiteralType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUnicodeScalarLiteralType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUnicodeScalarLiteralType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUnicodeScalarLiteralType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum unicodeScalars: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUnicodeScalars // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUnicodeScalars - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUnicodeScalars - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUnicodeScalars: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum UnicodeScalarView: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUnicodeScalarView // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUnicodeScalarView - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUnicodeScalarView - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUnicodeScalarView: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum uninterpretedOption: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUninterpretedOption // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUninterpretedOption - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUninterpretedOption - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUninterpretedOption: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum union: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUnion // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUnion - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUnion - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUnion: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum uniqueStorage: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUniqueStorage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUniqueStorage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUniqueStorage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUniqueStorage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum unknown: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUnknown // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUnknown - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUnknown - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUnknown: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum unknownFieldsEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUnknownFields // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUnknownFields - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUnknownFields - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUnknownFields: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum UnknownStorage: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUnknownStorage // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUnknownStorage - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUnknownStorage - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUnknownStorage: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum unpackTo: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUnpackTo // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUnpackTo - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUnpackTo - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUnpackTo: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum UnsafeBufferPointer: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUnsafeBufferPointer // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUnsafeBufferPointer - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUnsafeBufferPointer - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUnsafeBufferPointer: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum UnsafeMutablePointer: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUnsafeMutablePointer // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUnsafeMutablePointer - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUnsafeMutablePointer - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUnsafeMutablePointer: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum UnsafeMutableRawBufferPointer: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUnsafeMutableRawBufferPointer // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUnsafeMutableRawBufferPointer - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUnsafeMutableRawBufferPointer - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUnsafeMutableRawBufferPointer: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum UnsafeMutableRawPointer: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUnsafeMutableRawPointer // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUnsafeMutableRawPointer - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUnsafeMutableRawPointer - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUnsafeMutableRawPointer: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum UnsafeRawBufferPointer: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUnsafeRawBufferPointer // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUnsafeRawBufferPointer - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUnsafeRawBufferPointer - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUnsafeRawBufferPointer: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum UnsafeRawPointer: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUnsafeRawPointer // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUnsafeRawPointer - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUnsafeRawPointer - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUnsafeRawPointer: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum updatedOptions: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUpdatedOptions // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUpdatedOptions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUpdatedOptions - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUpdatedOptions: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum url: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneURL // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneURL - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneURL - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneURL: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum utf8: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUtf8 // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUtf8 - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUtf8 - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUtf8: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum utf8Ptr: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUtf8Ptr // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUtf8Ptr - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUtf8Ptr - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUtf8Ptr: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum utf8ToDouble: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUtf8ToDouble // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUtf8ToDouble - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUtf8ToDouble - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUtf8ToDouble: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum UTF8View: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneUtf8View // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneUtf8View - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneUtf8View - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneUtf8View: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum v: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneV // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneV - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneV - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneV: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum value: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneValue // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneValue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneValue: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum valueField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneValueField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneValueField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneValueField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneValueField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum values: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneValues // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneValues - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneValues - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneValues: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum ValueType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneValueType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneValueType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneValueType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneValueType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum varEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVar // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVar - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVar - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVar: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum Version: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVersion // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVersion - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVersion - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVersion: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum versionString: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVersionString // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVersionString - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVersionString - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVersionString: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitExtensionFields: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitExtensionFields // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitExtensionFields - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitExtensionFields - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitExtensionFields: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitExtensionFieldsAsMessageSet: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitExtensionFieldsAsMessageSet // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitExtensionFieldsAsMessageSet - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitExtensionFieldsAsMessageSet - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitExtensionFieldsAsMessageSet: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitMapField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitMapField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitMapField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitMapField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitMapField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitor: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitor // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitor - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitor - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitor: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitPacked: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitPacked // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitPacked - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitPacked - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitPacked: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitPackedBoolField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitPackedBoolField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitPackedBoolField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitPackedBoolField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitPackedBoolField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitPackedDoubleField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitPackedDoubleField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitPackedDoubleField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitPackedDoubleField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitPackedDoubleField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitPackedEnumField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitPackedEnumField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitPackedEnumField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitPackedEnumField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitPackedEnumField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitPackedFixed32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitPackedFixed32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitPackedFixed32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitPackedFixed32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitPackedFixed32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitPackedFixed64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitPackedFixed64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitPackedFixed64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitPackedFixed64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitPackedFixed64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitPackedFloatField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitPackedFloatField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitPackedFloatField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitPackedFloatField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitPackedFloatField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitPackedInt32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitPackedInt32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitPackedInt32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitPackedInt32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitPackedInt32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitPackedInt64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitPackedInt64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitPackedInt64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitPackedInt64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitPackedInt64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitPackedSFixed32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitPackedSfixed32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitPackedSfixed32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitPackedSfixed32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitPackedSfixed32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitPackedSFixed64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitPackedSfixed64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitPackedSfixed64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitPackedSfixed64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitPackedSfixed64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitPackedSInt32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitPackedSint32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitPackedSint32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitPackedSint32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitPackedSint32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitPackedSInt64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitPackedSint64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitPackedSint64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitPackedSint64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitPackedSint64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitPackedUInt32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitPackedUint32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitPackedUint32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitPackedUint32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitPackedUint32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitPackedUInt64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitPackedUint64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitPackedUint64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitPackedUint64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitPackedUint64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeated: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeated // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeated - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeated - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeated: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeatedBoolField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeatedBoolField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeatedBoolField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeatedBoolField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeatedBoolField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeatedBytesField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeatedBytesField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeatedBytesField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeatedBytesField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeatedBytesField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeatedDoubleField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeatedDoubleField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeatedDoubleField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeatedDoubleField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeatedDoubleField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeatedEnumField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeatedEnumField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeatedEnumField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeatedEnumField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeatedEnumField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeatedFixed32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeatedFixed32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeatedFixed32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeatedFixed32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeatedFixed32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeatedFixed64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeatedFixed64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeatedFixed64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeatedFixed64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeatedFixed64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeatedFloatField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeatedFloatField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeatedFloatField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeatedFloatField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeatedFloatField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeatedGroupField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeatedGroupField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeatedGroupField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeatedGroupField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeatedGroupField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeatedInt32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeatedInt32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeatedInt32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeatedInt32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeatedInt32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeatedInt64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeatedInt64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeatedInt64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeatedInt64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeatedInt64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeatedMessageField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeatedMessageField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeatedMessageField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeatedMessageField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeatedMessageField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeatedSFixed32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeatedSfixed32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeatedSfixed32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeatedSfixed32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeatedSfixed32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeatedSFixed64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeatedSfixed64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeatedSfixed64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeatedSfixed64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeatedSfixed64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeatedSInt32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeatedSint32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeatedSint32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeatedSint32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeatedSint32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeatedSInt64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeatedSint64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeatedSint64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeatedSint64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeatedSint64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeatedStringField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeatedStringField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeatedStringField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeatedStringField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeatedStringField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeatedUInt32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeatedUint32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeatedUint32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeatedUint32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeatedUint32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitRepeatedUInt64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitRepeatedUint64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitRepeatedUint64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitRepeatedUint64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitRepeatedUint64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingular: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingular // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingular - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingular - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingular: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingularBoolField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingularBoolField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingularBoolField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingularBoolField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingularBoolField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingularBytesField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingularBytesField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingularBytesField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingularBytesField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingularBytesField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingularDoubleField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingularDoubleField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingularDoubleField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingularDoubleField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingularDoubleField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingularEnumField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingularEnumField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingularEnumField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingularEnumField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingularEnumField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingularFixed32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingularFixed32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingularFixed32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingularFixed32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingularFixed32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingularFixed64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingularFixed64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingularFixed64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingularFixed64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingularFixed64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingularFloatField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingularFloatField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingularFloatField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingularFloatField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingularFloatField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingularGroupField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingularGroupField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingularGroupField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingularGroupField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingularGroupField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingularInt32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingularInt32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingularInt32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingularInt32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingularInt32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingularInt64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingularInt64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingularInt64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingularInt64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingularInt64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingularMessageField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingularMessageField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingularMessageField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingularMessageField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingularMessageField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingularSFixed32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingularSfixed32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingularSfixed32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingularSfixed32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingularSfixed32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingularSFixed64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingularSfixed64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingularSfixed64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingularSfixed64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingularSfixed64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingularSInt32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingularSint32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingularSint32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingularSint32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingularSint32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingularSInt64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingularSint64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingularSint64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingularSint64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingularSint64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingularStringField: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingularStringField // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingularStringField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingularStringField - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingularStringField: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingularUInt32Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingularUint32Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingularUint32Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingularUint32Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingularUint32Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitSingularUInt64Field: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitSingularUint64Field // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitSingularUint64Field - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitSingularUint64Field - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitSingularUint64Field: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum visitUnknown: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneVisitUnknown // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneVisitUnknown - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneVisitUnknown - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneVisitUnknown: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum wasDecoded: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneWasDecoded // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneWasDecoded - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneWasDecoded - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneWasDecoded: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum weak: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneWeak // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneWeak - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneWeak - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneWeak: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum weakDependency: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneWeakDependency // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneWeakDependency - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneWeakDependency - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneWeakDependency: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum whereEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneWhere // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneWhere - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneWhere - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneWhere: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum wireFormat: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneWireFormat // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneWireFormat - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneWireFormat - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneWireFormat: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum with: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneWith // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneWith - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneWith - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneWith: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum withUnsafeBytes: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneWithUnsafeBytes // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneWithUnsafeBytes - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneWithUnsafeBytes - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneWithUnsafeBytes: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum withUnsafeMutableBytes: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneWithUnsafeMutableBytes // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneWithUnsafeMutableBytes - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneWithUnsafeMutableBytes - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneWithUnsafeMutableBytes: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum work: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneWork // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneWork - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneWork - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneWork: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum WrappedType: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneWrappedType // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneWrappedType - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneWrappedType - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneWrappedType: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum written: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneWritten // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneWritten - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneWritten - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneWritten: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - enum yday: SwiftProtobuf.Enum { - typealias RawValue = Int - case noneYday // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .noneYday - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .noneYday - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .noneYday: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - - init() {} -} - -#if swift(>=4.2) - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.adjusted: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.adjusted] = [ - .noneAdjusted, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.aggregateValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.aggregateValue] = [ - .noneAggregateValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allCases: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allCases] = [ - .noneAllCases, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allowAlias: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allowAlias] = [ - .noneAllowAlias, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.alwaysPrintEnumsAsInts: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.alwaysPrintEnumsAsInts] = [ - .noneAlwaysPrintEnumsAsInts, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.annotation: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.annotation] = [ - .noneAnnotation, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.any: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.any] = [ - .noneAny, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyExtensionField] = [ - .noneAnyExtensionField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageExtension: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageExtension] = [ - .noneAnyMessageExtension, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageStorage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageStorage] = [ - .noneAnyMessageStorage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyUnpackError: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyUnpackError] = [ - .noneAnyUnpackError, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Api: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Api] = [ - .noneApi, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appended: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appended] = [ - .noneAppended, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUIntHex: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUIntHex] = [ - .noneAppendUintHex, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUnknown: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUnknown] = [ - .noneAppendUnknown, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.areAllInitialized: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.areAllInitialized] = [ - .noneAreAllInitialized, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.array: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.array] = [ - .noneArray, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayDepth: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayDepth] = [ - .noneArrayDepth, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayLiteral] = [ - .noneArrayLiteral, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arraySeparator: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arraySeparator] = [ - .noneArraySeparator, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asEnum] = [ - .noneAs, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiOpenCurlyBracket: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiOpenCurlyBracket] = [ - .noneAsciiOpenCurlyBracket, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiZero: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiZero] = [ - .noneAsciiZero, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.available: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.available] = [ - .noneAvailable, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.b: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.b] = [ - .noneB, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.base64Values: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.base64Values] = [ - .noneBase64Values, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.baseAddress: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.baseAddress] = [ - .noneBaseAddress, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BaseType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BaseType] = [ - .noneBaseType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.begin: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.begin] = [ - .noneBegin, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binary: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binary] = [ - .noneBinary, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecoder] = [ - .noneBinaryDecoder, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingError: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingError] = [ - .noneBinaryDecodingError, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingOptions] = [ - .noneBinaryDecodingOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDelimited: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDelimited] = [ - .noneBinaryDelimited, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncoder] = [ - .noneBinaryEncoder, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingError: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingError] = [ - .noneBinaryEncodingError, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetSizeVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetSizeVisitor] = [ - .noneBinaryEncodingMessageSetSizeVisitor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetVisitor] = [ - .noneBinaryEncodingMessageSetVisitor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingSizeVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingSizeVisitor] = [ - .noneBinaryEncodingSizeVisitor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingVisitor] = [ - .noneBinaryEncodingVisitor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binaryOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binaryOptions] = [ - .noneBinaryOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.body: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.body] = [ - .noneBody, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BoolEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BoolEnum] = [ - .noneBool, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.booleanLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.booleanLiteral] = [ - .noneBooleanLiteral, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BooleanLiteralType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BooleanLiteralType] = [ - .noneBooleanLiteralType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.boolValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.boolValue] = [ - .noneBoolValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytes: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytes] = [ - .noneBytes, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesInGroup: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesInGroup] = [ - .noneBytesInGroup, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesRead: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesRead] = [ - .noneBytesRead, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BytesValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BytesValue] = [ - .noneBytesValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.c: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.c] = [ - .noneC, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.capitalizeNext: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.capitalizeNext] = [ - .noneCapitalizeNext, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.cardinality: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.cardinality] = [ - .noneCardinality, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ccEnableArenas: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ccEnableArenas] = [ - .noneCcEnableArenas, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ccGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ccGenericServices] = [ - .noneCcGenericServices, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Character: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Character] = [ - .noneCharacter, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.chars: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.chars] = [ - .noneChars, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.classEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.classEnum] = [ - .noneClass, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearAggregateValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearAggregateValue] = [ - .noneClearAggregateValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearAllowAlias: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearAllowAlias] = [ - .noneClearAllowAlias, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearBegin: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearBegin] = [ - .noneClearBegin, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCcEnableArenas: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCcEnableArenas] = [ - .noneClearCcEnableArenas, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCcGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCcGenericServices] = [ - .noneClearCcGenericServices, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearClientStreaming: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearClientStreaming] = [ - .noneClearClientStreaming, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCsharpNamespace: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCsharpNamespace] = [ - .noneClearCsharpNamespace, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCtype: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCtype] = [ - .noneClearCtype, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDefaultValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDefaultValue] = [ - .noneClearDefaultValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDeprecated: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDeprecated] = [ - .noneClearDeprecated, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDoubleValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDoubleValue] = [ - .noneClearDoubleValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearEnd: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearEnd] = [ - .noneClearEnd, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtendee: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtendee] = [ - .noneClearExtendee, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtensionValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtensionValue] = [ - .noneClearExtensionValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearGoPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearGoPackage] = [ - .noneClearGoPackage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIdempotencyLevel: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIdempotencyLevel] = [ - .noneClearIdempotencyLevel, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIdentifierValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIdentifierValue] = [ - .noneClearIdentifierValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearInputType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearInputType] = [ - .noneClearInputType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIsExtension: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIsExtension] = [ - .noneClearIsExtension, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaGenerateEqualsAndHash: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaGenerateEqualsAndHash] = [ - .noneClearJavaGenerateEqualsAndHash, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaGenericServices] = [ - .noneClearJavaGenericServices, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaMultipleFiles: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaMultipleFiles] = [ - .noneClearJavaMultipleFiles, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaOuterClassname: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaOuterClassname] = [ - .noneClearJavaOuterClassname, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaPackage] = [ - .noneClearJavaPackage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaStringCheckUtf8: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaStringCheckUtf8] = [ - .noneClearJavaStringCheckUtf8, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJsonName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJsonName] = [ - .noneClearJsonName, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJstype: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJstype] = [ - .noneClearJstype, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLabel: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLabel] = [ - .noneClearLabel, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLazy: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLazy] = [ - .noneClearLazy, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLeadingComments: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLeadingComments] = [ - .noneClearLeadingComments, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearMapEntry: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearMapEntry] = [ - .noneClearMapEntry, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearMessageSetWireFormat: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearMessageSetWireFormat] = [ - .noneClearMessageSetWireFormat, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearName] = [ - .noneClearName, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNamePart: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNamePart] = [ - .noneClearNamePart, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNegativeIntValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNegativeIntValue] = [ - .noneClearNegativeIntValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNoStandardDescriptorAccessor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNoStandardDescriptorAccessor] = [ - .noneClearNoStandardDescriptorAccessor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNumber: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNumber] = [ - .noneClearNumber, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearObjcClassPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearObjcClassPrefix] = [ - .noneClearObjcClassPrefix, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOneofIndex: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOneofIndex] = [ - .noneClearOneofIndex, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOptimizeFor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOptimizeFor] = [ - .noneClearOptimizeFor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOptions] = [ - .noneClearOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOutputType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOutputType] = [ - .noneClearOutputType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPackage] = [ - .noneClearPackage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPacked: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPacked] = [ - .noneClearPacked, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpClassPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpClassPrefix] = [ - .noneClearPhpClassPrefix, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpGenericServices] = [ - .noneClearPhpGenericServices, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpMetadataNamespace: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpMetadataNamespace] = [ - .noneClearPhpMetadataNamespace, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpNamespace: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpNamespace] = [ - .noneClearPhpNamespace, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPositiveIntValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPositiveIntValue] = [ - .noneClearPositiveIntValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearProto3Optional: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearProto3Optional] = [ - .noneClearProto3Optional, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPyGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPyGenericServices] = [ - .noneClearPyGenericServices, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearRubyPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearRubyPackage] = [ - .noneClearRubyPackage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearServerStreaming: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearServerStreaming] = [ - .noneClearServerStreaming, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceCodeInfo: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceCodeInfo] = [ - .noneClearSourceCodeInfo, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceContext: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceContext] = [ - .noneClearSourceContext, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceFile: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceFile] = [ - .noneClearSourceFile, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearStart: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearStart] = [ - .noneClearStart, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearStringValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearStringValue] = [ - .noneClearStringValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSwiftPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSwiftPrefix] = [ - .noneClearSwiftPrefix, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSyntax: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSyntax] = [ - .noneClearSyntax, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearTrailingComments: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearTrailingComments] = [ - .noneClearTrailingComments, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearType] = [ - .noneClearType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearTypeName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearTypeName] = [ - .noneClearTypeName, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearValue] = [ - .noneClearValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearWeak: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearWeak] = [ - .noneClearWeak, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clientStreaming: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clientStreaming] = [ - .noneClientStreaming, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codePoint: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codePoint] = [ - .noneCodePoint, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codeUnits: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codeUnits] = [ - .noneCodeUnits, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Collection: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Collection] = [ - .noneCollection, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.com: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.com] = [ - .noneCom, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.comma: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.comma] = [ - .noneComma, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.contentsOf: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.contentsOf] = [ - .noneContentsOf, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ContiguousBytes: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ContiguousBytes] = [ - .noneContiguousBytes, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.count: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.count] = [ - .noneCount, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.countVarintsInBuffer: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.countVarintsInBuffer] = [ - .noneCountVarintsInBuffer, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.csharpNamespace: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.csharpNamespace] = [ - .noneCsharpNamespace, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ctype: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ctype] = [ - .noneCtype, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.customCodable: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.customCodable] = [ - .noneCustomCodable, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.CustomDebugStringConvertible: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.CustomDebugStringConvertible] = [ - .noneCustomDebugStringConvertible, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.d: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.d] = [ - .noneD, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DataEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DataEnum] = [ - .noneData, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dataResult: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dataResult] = [ - .noneDataResult, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.date: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.date] = [ - .noneDate, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daySec: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daySec] = [ - .noneDaySec, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daysSinceEpoch: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daysSinceEpoch] = [ - .noneDaysSinceEpoch, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.debugDescriptionEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.debugDescriptionEnum] = [ - .noneDebugDescription, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoded: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoded] = [ - .noneDecoded, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodedFromJSONNull: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodedFromJSONNull] = [ - .noneDecodedFromJsonnull, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionField] = [ - .noneDecodeExtensionField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionFieldsAsMessageSet: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionFieldsAsMessageSet] = [ - .noneDecodeExtensionFieldsAsMessageSet, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeJSON: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeJSON] = [ - .noneDecodeJson, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMapField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMapField] = [ - .noneDecodeMapField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMessageEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMessageEnum] = [ - .noneDecodeMessage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoder] = [ - .noneDecoder, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeated: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeated] = [ - .noneDecodeRepeated, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBoolField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBoolField] = [ - .noneDecodeRepeatedBoolField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBytesField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBytesField] = [ - .noneDecodeRepeatedBytesField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedDoubleField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedDoubleField] = [ - .noneDecodeRepeatedDoubleField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedEnumField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedEnumField] = [ - .noneDecodeRepeatedEnumField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed32Field] = [ - .noneDecodeRepeatedFixed32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed64Field] = [ - .noneDecodeRepeatedFixed64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFloatField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFloatField] = [ - .noneDecodeRepeatedFloatField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedGroupField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedGroupField] = [ - .noneDecodeRepeatedGroupField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt32Field] = [ - .noneDecodeRepeatedInt32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt64Field] = [ - .noneDecodeRepeatedInt64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedMessageField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedMessageField] = [ - .noneDecodeRepeatedMessageField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed32Field] = [ - .noneDecodeRepeatedSfixed32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed64Field] = [ - .noneDecodeRepeatedSfixed64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt32Field] = [ - .noneDecodeRepeatedSint32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt64Field] = [ - .noneDecodeRepeatedSint64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedStringField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedStringField] = [ - .noneDecodeRepeatedStringField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt32Field] = [ - .noneDecodeRepeatedUint32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt64Field] = [ - .noneDecodeRepeatedUint64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingular: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingular] = [ - .noneDecodeSingular, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBoolField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBoolField] = [ - .noneDecodeSingularBoolField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBytesField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBytesField] = [ - .noneDecodeSingularBytesField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularDoubleField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularDoubleField] = [ - .noneDecodeSingularDoubleField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularEnumField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularEnumField] = [ - .noneDecodeSingularEnumField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed32Field] = [ - .noneDecodeSingularFixed32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed64Field] = [ - .noneDecodeSingularFixed64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFloatField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFloatField] = [ - .noneDecodeSingularFloatField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularGroupField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularGroupField] = [ - .noneDecodeSingularGroupField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt32Field] = [ - .noneDecodeSingularInt32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt64Field] = [ - .noneDecodeSingularInt64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularMessageField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularMessageField] = [ - .noneDecodeSingularMessageField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed32Field] = [ - .noneDecodeSingularSfixed32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed64Field] = [ - .noneDecodeSingularSfixed64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt32Field] = [ - .noneDecodeSingularSint32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt64Field] = [ - .noneDecodeSingularSint64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularStringField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularStringField] = [ - .noneDecodeSingularStringField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt32Field] = [ - .noneDecodeSingularUint32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt64Field] = [ - .noneDecodeSingularUint64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeTextFormat: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeTextFormat] = [ - .noneDecodeTextFormat, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultAnyTypeURLPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultAnyTypeURLPrefix] = [ - .noneDefaultAnyTypeUrlprefix, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultValue] = [ - .noneDefaultValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dependency: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dependency] = [ - .noneDependency, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.deprecated: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.deprecated] = [ - .noneDeprecated, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.descriptionEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.descriptionEnum] = [ - .noneDescription, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DescriptorProto] = [ - .noneDescriptorProto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Dictionary: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Dictionary] = [ - .noneDictionary, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dictionaryLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dictionaryLiteral] = [ - .noneDictionaryLiteral, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit] = [ - .noneDigit, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit0: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit0] = [ - .noneDigit0, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit1: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit1] = [ - .noneDigit1, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitCount: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitCount] = [ - .noneDigitCount, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digits: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digits] = [ - .noneDigits, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitValue] = [ - .noneDigitValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardableResult: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardableResult] = [ - .noneDiscardableResult, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardUnknownFields: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardUnknownFields] = [ - .noneDiscardUnknownFields, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.distance: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.distance] = [ - .noneDistance, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.double: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.double] = [ - .noneDouble, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.doubleValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.doubleValue] = [ - .noneDoubleValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Duration: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Duration] = [ - .noneDuration, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.E: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.E] = [ - .noneE, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Element: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Element] = [ - .noneElement, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.elements: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.elements] = [ - .noneElements, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitExtensionFieldName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitExtensionFieldName] = [ - .noneEmitExtensionFieldName, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldName] = [ - .noneEmitFieldName, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldNumber: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldNumber] = [ - .noneEmitFieldNumber, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Empty: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Empty] = [ - .noneEmpty, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emptyData: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emptyData] = [ - .noneEmptyData, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeAsBytes: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeAsBytes] = [ - .noneEncodeAsBytes, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoded: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoded] = [ - .noneEncoded, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedJSONString: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedJSONString] = [ - .noneEncodedJsonstring, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedSize: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedSize] = [ - .noneEncodedSize, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeField] = [ - .noneEncodeField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoder] = [ - .noneEncoder, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.end: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.end] = [ - .noneEnd, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endArray: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endArray] = [ - .noneEndArray, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endMessageField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endMessageField] = [ - .noneEndMessageField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endObject: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endObject] = [ - .noneEndObject, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endRegularField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endRegularField] = [ - .noneEndRegularField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumEnum] = [ - .noneEnum, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumDescriptorProto] = [ - .noneEnumDescriptorProto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumOptions] = [ - .noneEnumOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumReservedRange: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumReservedRange] = [ - .noneEnumReservedRange, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumType] = [ - .noneEnumType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumvalue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumvalue] = [ - .noneEnumvalue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumValueDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumValueDescriptorProto] = [ - .noneEnumValueDescriptorProto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumValueOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumValueOptions] = [ - .noneEnumValueOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Equatable: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Equatable] = [ - .noneEquatable, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Error: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Error] = [ - .noneError, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByArrayLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByArrayLiteral] = [ - .noneExpressibleByArrayLiteral, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByDictionaryLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByDictionaryLiteral] = [ - .noneExpressibleByDictionaryLiteral, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ext: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ext] = [ - .noneExt, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extDecoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extDecoder] = [ - .noneExtDecoder, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendedGraphemeClusterLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendedGraphemeClusterLiteral] = [ - .noneExtendedGraphemeClusterLiteral, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtendedGraphemeClusterLiteralType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtendedGraphemeClusterLiteralType] = [ - .noneExtendedGraphemeClusterLiteralType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendee: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendee] = [ - .noneExtendee, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensibleMessage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensibleMessage] = [ - .noneExtensibleMessage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionEnum] = [ - .noneExtension, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionField] = [ - .noneExtensionField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionFieldNumber: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionFieldNumber] = [ - .noneExtensionFieldNumber, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionFieldValueSet: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionFieldValueSet] = [ - .noneExtensionFieldValueSet, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionMap: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionMap] = [ - .noneExtensionMap, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionRange: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionRange] = [ - .noneExtensionRange, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionRangeOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionRangeOptions] = [ - .noneExtensionRangeOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensions] = [ - .noneExtensions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extras: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extras] = [ - .noneExtras, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.F: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.F] = [ - .noneF, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.falseEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.falseEnum] = [ - .noneFalse, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.field] = [ - .noneField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldData: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldData] = [ - .noneFieldData, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldDescriptorProto] = [ - .noneFieldDescriptorProto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldMask: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldMask] = [ - .noneFieldMask, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldName] = [ - .noneFieldName, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNameCount: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNameCount] = [ - .noneFieldNameCount, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNum] = [ - .noneFieldNum, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumber: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumber] = [ - .noneFieldNumber, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumberForProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumberForProto] = [ - .noneFieldNumberForProto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldOptions] = [ - .noneFieldOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fields: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fields] = [ - .noneFields, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldSize: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldSize] = [ - .noneFieldSize, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldTag: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldTag] = [ - .noneFieldTag, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldType] = [ - .noneFieldType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.file: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.file] = [ - .noneFile, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileDescriptorProto] = [ - .noneFileDescriptorProto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileDescriptorSet: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileDescriptorSet] = [ - .noneFileDescriptorSet, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fileName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fileName] = [ - .noneFileName, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileOptions] = [ - .noneFileOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.filter: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.filter] = [ - .noneFilter, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.first: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.first] = [ - .noneFirst, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.firstItem: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.firstItem] = [ - .noneFirstItem, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.float: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.float] = [ - .noneFloat, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.floatLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.floatLiteral] = [ - .noneFloatLiteral, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatLiteralType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatLiteralType] = [ - .noneFloatLiteralType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatValue] = [ - .noneFloatValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forMessageName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forMessageName] = [ - .noneForMessageName, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.formUnion: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.formUnion] = [ - .noneFormUnion, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forReadingFrom: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forReadingFrom] = [ - .noneForReadingFrom, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forTypeURL: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forTypeURL] = [ - .noneForTypeURL, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ForwardParser: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ForwardParser] = [ - .noneForwardParser, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forWritingInto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forWritingInto] = [ - .noneForWritingInto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.from: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.from] = [ - .noneFrom, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii2: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii2] = [ - .noneFromAscii2, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii4: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii4] = [ - .noneFromAscii4, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromByteOffset: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromByteOffset] = [ - .noneFromByteOffset, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromHexDigit: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromHexDigit] = [ - .noneFromHexDigit, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.funcEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.funcEnum] = [ - .noneFunc, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.G: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.G] = [ - .noneG, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.GeneratedCodeInfo: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.GeneratedCodeInfo] = [ - .noneGeneratedCodeInfo, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.get: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.get] = [ - .noneGet, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.getExtensionValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.getExtensionValue] = [ - .noneGetExtensionValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.googleapis: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.googleapis] = [ - .noneGoogleapis, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Any: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Any] = [ - .noneGoogleProtobufAny, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Api: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Api] = [ - .noneGoogleProtobufApi, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BoolValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BoolValue] = [ - .noneGoogleProtobufBoolValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BytesValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BytesValue] = [ - .noneGoogleProtobufBytesValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DescriptorProto] = [ - .noneGoogleProtobufDescriptorProto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DoubleValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DoubleValue] = [ - .noneGoogleProtobufDoubleValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Duration: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Duration] = [ - .noneGoogleProtobufDuration, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Empty: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Empty] = [ - .noneGoogleProtobufEmpty, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Enum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Enum] = [ - .noneGoogleProtobufEnum, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumDescriptorProto] = [ - .noneGoogleProtobufEnumDescriptorProto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumOptions] = [ - .noneGoogleProtobufEnumOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValue] = [ - .noneGoogleProtobufEnumValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueDescriptorProto] = [ - .noneGoogleProtobufEnumValueDescriptorProto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueOptions] = [ - .noneGoogleProtobufEnumValueOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ExtensionRangeOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ExtensionRangeOptions] = [ - .noneGoogleProtobufExtensionRangeOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Field] = [ - .noneGoogleProtobufField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldDescriptorProto] = [ - .noneGoogleProtobufFieldDescriptorProto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldMask: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldMask] = [ - .noneGoogleProtobufFieldMask, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldOptions] = [ - .noneGoogleProtobufFieldOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorProto] = [ - .noneGoogleProtobufFileDescriptorProto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorSet: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorSet] = [ - .noneGoogleProtobufFileDescriptorSet, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileOptions] = [ - .noneGoogleProtobufFileOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FloatValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FloatValue] = [ - .noneGoogleProtobufFloatValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_GeneratedCodeInfo: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_GeneratedCodeInfo] = [ - .noneGoogleProtobufGeneratedCodeInfo, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int32Value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int32Value] = [ - .noneGoogleProtobufInt32Value, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int64Value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int64Value] = [ - .noneGoogleProtobufInt64Value, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ListValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ListValue] = [ - .noneGoogleProtobufListValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MessageOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MessageOptions] = [ - .noneGoogleProtobufMessageOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Method: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Method] = [ - .noneGoogleProtobufMethod, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodDescriptorProto] = [ - .noneGoogleProtobufMethodDescriptorProto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodOptions] = [ - .noneGoogleProtobufMethodOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Mixin: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Mixin] = [ - .noneGoogleProtobufMixin, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_NullValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_NullValue] = [ - .noneGoogleProtobufNullValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofDescriptorProto] = [ - .noneGoogleProtobufOneofDescriptorProto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofOptions] = [ - .noneGoogleProtobufOneofOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Option: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Option] = [ - .noneGoogleProtobufOption, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceDescriptorProto] = [ - .noneGoogleProtobufServiceDescriptorProto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceOptions] = [ - .noneGoogleProtobufServiceOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceCodeInfo: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceCodeInfo] = [ - .noneGoogleProtobufSourceCodeInfo, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceContext: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceContext] = [ - .noneGoogleProtobufSourceContext, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_StringValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_StringValue] = [ - .noneGoogleProtobufStringValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Struct: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Struct] = [ - .noneGoogleProtobufStruct, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Syntax: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Syntax] = [ - .noneGoogleProtobufSyntax, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Timestamp: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Timestamp] = [ - .noneGoogleProtobufTimestamp, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Type: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Type] = [ - .noneGoogleProtobufType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt32Value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt32Value] = [ - .noneGoogleProtobufUint32Value, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt64Value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt64Value] = [ - .noneGoogleProtobufUint64Value, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UninterpretedOption: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UninterpretedOption] = [ - .noneGoogleProtobufUninterpretedOption, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Value] = [ - .noneGoogleProtobufValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.goPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.goPackage] = [ - .noneGoPackage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.group: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.group] = [ - .noneGroup, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupFieldNumberStack: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupFieldNumberStack] = [ - .noneGroupFieldNumberStack, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupSize: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupSize] = [ - .noneGroupSize, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.h: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.h] = [ - .noneH, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hadOneofValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hadOneofValue] = [ - .noneHadOneofValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.handleConflictingOneOf: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.handleConflictingOneOf] = [ - .noneHandleConflictingOneOf, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasAggregateValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasAggregateValue] = [ - .noneHasAggregateValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasAllowAlias: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasAllowAlias] = [ - .noneHasAllowAlias, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasBegin: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasBegin] = [ - .noneHasBegin, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCcEnableArenas: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCcEnableArenas] = [ - .noneHasCcEnableArenas, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCcGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCcGenericServices] = [ - .noneHasCcGenericServices, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasClientStreaming: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasClientStreaming] = [ - .noneHasClientStreaming, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCsharpNamespace: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCsharpNamespace] = [ - .noneHasCsharpNamespace, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCtype: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCtype] = [ - .noneHasCtype, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDefaultValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDefaultValue] = [ - .noneHasDefaultValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDeprecated: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDeprecated] = [ - .noneHasDeprecated, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDoubleValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDoubleValue] = [ - .noneHasDoubleValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasEnd: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasEnd] = [ - .noneHasEnd, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtendee: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtendee] = [ - .noneHasExtendee, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtensionValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtensionValue] = [ - .noneHasExtensionValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasGoPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasGoPackage] = [ - .noneHasGoPackage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hash: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hash] = [ - .noneHash, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Hashable: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Hashable] = [ - .noneHashable, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasher: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasher] = [ - .noneHasher, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hashValueEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hashValueEnum] = [ - .noneHashValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.HashVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.HashVisitor] = [ - .noneHashVisitor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIdempotencyLevel: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIdempotencyLevel] = [ - .noneHasIdempotencyLevel, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIdentifierValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIdentifierValue] = [ - .noneHasIdentifierValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasInputType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasInputType] = [ - .noneHasInputType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIsExtension: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIsExtension] = [ - .noneHasIsExtension, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaGenerateEqualsAndHash: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaGenerateEqualsAndHash] = [ - .noneHasJavaGenerateEqualsAndHash, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaGenericServices] = [ - .noneHasJavaGenericServices, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaMultipleFiles: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaMultipleFiles] = [ - .noneHasJavaMultipleFiles, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaOuterClassname: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaOuterClassname] = [ - .noneHasJavaOuterClassname, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaPackage] = [ - .noneHasJavaPackage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaStringCheckUtf8: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaStringCheckUtf8] = [ - .noneHasJavaStringCheckUtf8, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJsonName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJsonName] = [ - .noneHasJsonName, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJstype: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJstype] = [ - .noneHasJstype, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLabel: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLabel] = [ - .noneHasLabel, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLazy: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLazy] = [ - .noneHasLazy, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLeadingComments: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLeadingComments] = [ - .noneHasLeadingComments, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasMapEntry: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasMapEntry] = [ - .noneHasMapEntry, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasMessageSetWireFormat: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasMessageSetWireFormat] = [ - .noneHasMessageSetWireFormat, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasName] = [ - .noneHasName, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNamePart: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNamePart] = [ - .noneHasNamePart, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNegativeIntValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNegativeIntValue] = [ - .noneHasNegativeIntValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNoStandardDescriptorAccessor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNoStandardDescriptorAccessor] = [ - .noneHasNoStandardDescriptorAccessor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNumber: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNumber] = [ - .noneHasNumber, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasObjcClassPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasObjcClassPrefix] = [ - .noneHasObjcClassPrefix, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOneofIndex: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOneofIndex] = [ - .noneHasOneofIndex, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOptimizeFor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOptimizeFor] = [ - .noneHasOptimizeFor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOptions] = [ - .noneHasOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOutputType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOutputType] = [ - .noneHasOutputType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPackage] = [ - .noneHasPackage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPacked: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPacked] = [ - .noneHasPacked, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpClassPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpClassPrefix] = [ - .noneHasPhpClassPrefix, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpGenericServices] = [ - .noneHasPhpGenericServices, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpMetadataNamespace: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpMetadataNamespace] = [ - .noneHasPhpMetadataNamespace, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpNamespace: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpNamespace] = [ - .noneHasPhpNamespace, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPositiveIntValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPositiveIntValue] = [ - .noneHasPositiveIntValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasProto3Optional: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasProto3Optional] = [ - .noneHasProto3Optional, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPyGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPyGenericServices] = [ - .noneHasPyGenericServices, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasRubyPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasRubyPackage] = [ - .noneHasRubyPackage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasServerStreaming: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasServerStreaming] = [ - .noneHasServerStreaming, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceCodeInfo: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceCodeInfo] = [ - .noneHasSourceCodeInfo, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceContext: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceContext] = [ - .noneHasSourceContext, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceFile: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceFile] = [ - .noneHasSourceFile, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasStart: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasStart] = [ - .noneHasStart, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasStringValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasStringValue] = [ - .noneHasStringValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSwiftPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSwiftPrefix] = [ - .noneHasSwiftPrefix, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSyntax: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSyntax] = [ - .noneHasSyntax, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasTrailingComments: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasTrailingComments] = [ - .noneHasTrailingComments, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasType] = [ - .noneHasType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasTypeName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasTypeName] = [ - .noneHasTypeName, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasValue] = [ - .noneHasValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasWeak: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasWeak] = [ - .noneHasWeak, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hour: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hour] = [ - .noneHour, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i] = [ - .noneI, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.idempotencyLevel: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.idempotencyLevel] = [ - .noneIdempotencyLevel, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.identifierValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.identifierValue] = [ - .noneIdentifierValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ifEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ifEnum] = [ - .noneIf, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ignoreUnknownFields: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ignoreUnknownFields] = [ - .noneIgnoreUnknownFields, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.index: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.index] = [ - .noneIndex, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.initEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.initEnum] = [ - .noneInit, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inoutEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inoutEnum] = [ - .noneInout, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inputType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inputType] = [ - .noneInputType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.insert: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.insert] = [ - .noneInsert, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntEnum] = [ - .noneInt, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Enum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Enum] = [ - .noneInt32, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Value] = [ - .noneInt32Value, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Enum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Enum] = [ - .noneInt64, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Value] = [ - .noneInt64Value, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int8: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int8] = [ - .noneInt8, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.integerLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.integerLiteral] = [ - .noneIntegerLiteral, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntegerLiteralType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntegerLiteralType] = [ - .noneIntegerLiteralType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.intern: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.intern] = [ - .noneIntern, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Internal: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Internal] = [ - .noneInternal, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.InternalState: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.InternalState] = [ - .noneInternalState, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.into: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.into] = [ - .noneInto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ints: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ints] = [ - .noneInts, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isA: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isA] = [ - .noneIsA, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqual: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqual] = [ - .noneIsEqual, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqualTo: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqualTo] = [ - .noneIsEqualTo, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isExtension: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isExtension] = [ - .noneIsExtension, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isInitializedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isInitializedEnum] = [ - .noneIsInitialized, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.itemTagsEncodedSize: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.itemTagsEncodedSize] = [ - .noneItemTagsEncodedSize, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Iterator: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Iterator] = [ - .noneIterator, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i_2166136261: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i_2166136261] = [ - .noneI2166136261, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaGenerateEqualsAndHash: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaGenerateEqualsAndHash] = [ - .noneJavaGenerateEqualsAndHash, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaGenericServices] = [ - .noneJavaGenericServices, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaMultipleFiles: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaMultipleFiles] = [ - .noneJavaMultipleFiles, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaOuterClassname: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaOuterClassname] = [ - .noneJavaOuterClassname, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaPackage] = [ - .noneJavaPackage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaStringCheckUtf8: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaStringCheckUtf8] = [ - .noneJavaStringCheckUtf8, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecoder] = [ - .noneJsondecoder, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingError: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingError] = [ - .noneJsondecodingError, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingOptions] = [ - .noneJsondecodingOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonEncoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonEncoder] = [ - .noneJsonEncoder, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingError: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingError] = [ - .noneJsonencodingError, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingOptions] = [ - .noneJsonencodingOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingVisitor] = [ - .noneJsonencodingVisitor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONMapEncodingVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONMapEncodingVisitor] = [ - .noneJsonmapEncodingVisitor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonName] = [ - .noneJsonName, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPath: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPath] = [ - .noneJsonPath, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPaths: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPaths] = [ - .noneJsonPaths, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONScanner: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONScanner] = [ - .noneJsonscanner, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonString: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonString] = [ - .noneJsonString, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonText: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonText] = [ - .noneJsonText, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonUTF8Data: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonUTF8Data] = [ - .noneJsonUtf8Data, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jstype: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jstype] = [ - .noneJstype, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.k: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.k] = [ - .noneK, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Key: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Key] = [ - .noneKey, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.keyField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.keyField] = [ - .noneKeyField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.KeyType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.KeyType] = [ - .noneKeyType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.kind: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.kind] = [ - .noneKind, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.l: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.l] = [ - .noneL, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.label: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.label] = [ - .noneLabel, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lazy: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lazy] = [ - .noneLazy, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.leadingComments: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.leadingComments] = [ - .noneLeadingComments, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.leadingDetachedComments: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.leadingDetachedComments] = [ - .noneLeadingDetachedComments, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.length: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.length] = [ - .noneLength, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lessThan: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lessThan] = [ - .noneLessThan, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.letEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.letEnum] = [ - .noneLet, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lhs: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lhs] = [ - .noneLhs, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.list: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.list] = [ - .noneList, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listOfMessages: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listOfMessages] = [ - .noneListOfMessages, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listValue] = [ - .noneListValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndian: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndian] = [ - .noneLittleEndian, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndianBytes: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndianBytes] = [ - .noneLittleEndianBytes, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.load: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.load] = [ - .noneLoad, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.localHasher: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.localHasher] = [ - .noneLocalHasher, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.location: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.location] = [ - .noneLocation, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.M: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.M] = [ - .noneM, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.major: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.major] = [ - .noneMajor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.makeIterator: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.makeIterator] = [ - .noneMakeIterator, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapEntry: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapEntry] = [ - .noneMapEntry, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapHash: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapHash] = [ - .noneMapHash, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapKeyType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapKeyType] = [ - .noneMapKeyType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapNameResolver: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapNameResolver] = [ - .noneMapNameResolver, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapToMessages: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapToMessages] = [ - .noneMapToMessages, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapValueType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapValueType] = [ - .noneMapValueType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapVisitor] = [ - .noneMapVisitor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mdayStart: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mdayStart] = [ - .noneMdayStart, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.merge: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.merge] = [ - .noneMerge, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.message: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.message] = [ - .noneMessage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageDepthLimit: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageDepthLimit] = [ - .noneMessageDepthLimit, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageExtension: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageExtension] = [ - .noneMessageExtension, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageImplementationBase: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageImplementationBase] = [ - .noneMessageImplementationBase, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageOptions] = [ - .noneMessageOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageSet: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageSet] = [ - .noneMessageSet, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageSetWireFormat: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageSetWireFormat] = [ - .noneMessageSetWireFormat, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageType] = [ - .noneMessageType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Method: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Method] = [ - .noneMethod, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MethodDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MethodDescriptorProto] = [ - .noneMethodDescriptorProto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MethodOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MethodOptions] = [ - .noneMethodOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.methods: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.methods] = [ - .noneMethods, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.minor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.minor] = [ - .noneMinor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Mixin: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Mixin] = [ - .noneMixin, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mixins: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mixins] = [ - .noneMixins, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.modifier: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.modifier] = [ - .noneModifier, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.modify: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.modify] = [ - .noneModify, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.month: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.month] = [ - .noneMonth, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.msgExtension: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.msgExtension] = [ - .noneMsgExtension, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mutating: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mutating] = [ - .noneMutating, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.n: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.n] = [ - .oneN, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.name: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.name] = [ - .noneName, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameDescription: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameDescription] = [ - .noneNameDescription, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameMap: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameMap] = [ - .noneNameMap, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NamePart: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NamePart] = [ - .noneNamePart, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nameResolver: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nameResolver] = [ - .noneNameResolver, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.names: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.names] = [ - .noneNames, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nanos: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nanos] = [ - .noneNanos, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeBytes: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeBytes] = [ - .noneNativeBytes, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeEndianBytes: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeEndianBytes] = [ - .noneNativeEndianBytes, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.negativeIntValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.negativeIntValue] = [ - .noneNegativeIntValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nestedType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nestedType] = [ - .noneNestedType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newL: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newL] = [ - .noneNewL, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newList: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newList] = [ - .noneNewList, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newValue] = [ - .noneNewValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextByte: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextByte] = [ - .noneNextByte, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextFieldNumber: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextFieldNumber] = [ - .noneNextFieldNumber, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilEnum] = [ - .noneNil, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilLiteral] = [ - .noneNilLiteral, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.noStandardDescriptorAccessor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.noStandardDescriptorAccessor] = [ - .noneNoStandardDescriptorAccessor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nullValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nullValue] = [ - .noneNullValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.number: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.number] = [ - .noneNumber, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.numberValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.numberValue] = [ - .noneNumberValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.objcClassPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.objcClassPrefix] = [ - .noneObjcClassPrefix, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.of: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.of] = [ - .noneOf, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofDecl: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofDecl] = [ - .noneOneofDecl, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneofDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneofDescriptorProto] = [ - .noneOneofDescriptorProto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofIndex: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofIndex] = [ - .noneOneofIndex, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneofOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneofOptions] = [ - .noneOneofOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofs: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofs] = [ - .noneOneofs, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneOf_Kind: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneOf_Kind] = [ - .noneOneOfKind, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.optimizeFor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.optimizeFor] = [ - .noneOptimizeFor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptimizeMode: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptimizeMode] = [ - .noneOptimizeMode, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Option: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Option] = [ - .noneOption, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalEnumExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalEnumExtensionField] = [ - .noneOptionalEnumExtensionField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalExtensionField] = [ - .noneOptionalExtensionField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalGroupExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalGroupExtensionField] = [ - .noneOptionalGroupExtensionField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalMessageExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalMessageExtensionField] = [ - .noneOptionalMessageExtensionField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.options: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.options] = [ - .noneOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.other: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.other] = [ - .noneOther, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.others: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.others] = [ - .noneOthers, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.out: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.out] = [ - .noneOut, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.outputType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.outputType] = [ - .noneOutputType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.p: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.p] = [ - .noneP, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.package: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.package] = [ - .nonePackage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.packed: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.packed] = [ - .nonePacked, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedEnumExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedEnumExtensionField] = [ - .nonePackedEnumExtensionField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedExtensionField] = [ - .nonePackedExtensionField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.padding: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.padding] = [ - .nonePadding, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parent: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parent] = [ - .noneParent, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parse: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parse] = [ - .noneParse, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.partial: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.partial] = [ - .nonePartial, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.path: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.path] = [ - .nonePath, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.paths: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.paths] = [ - .nonePaths, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payload: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payload] = [ - .nonePayload, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payloadSize: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payloadSize] = [ - .nonePayloadSize, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpClassPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpClassPrefix] = [ - .nonePhpClassPrefix, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpGenericServices] = [ - .nonePhpGenericServices, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpMetadataNamespace: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpMetadataNamespace] = [ - .nonePhpMetadataNamespace, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpNamespace: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpNamespace] = [ - .nonePhpNamespace, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pointer: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pointer] = [ - .nonePointer, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pos: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pos] = [ - .nonePos, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.positiveIntValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.positiveIntValue] = [ - .nonePositiveIntValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.prefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.prefix] = [ - .nonePrefix, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preserveProtoFieldNames: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preserveProtoFieldNames] = [ - .nonePreserveProtoFieldNames, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preTraverse: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preTraverse] = [ - .nonePreTraverse, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.printUnknownFields: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.printUnknownFields] = [ - .nonePrintUnknownFields, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto2: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto2] = [ - .noneProto2, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3DefaultValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3DefaultValue] = [ - .noneProto3DefaultValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3Optional: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3Optional] = [ - .noneProto3Optional, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck] = [ - .noneProtobufApiversionCheck, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_2: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_2] = [ - .noneProtobufApiversion2, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBool: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBool] = [ - .noneProtobufBool, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBytes: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBytes] = [ - .noneProtobufBytes, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufDouble: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufDouble] = [ - .noneProtobufDouble, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufEnumMap: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufEnumMap] = [ - .noneProtobufEnumMap, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobufExtension: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobufExtension] = [ - .noneProtobufExtension, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed32: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed32] = [ - .noneProtobufFixed32, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed64: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed64] = [ - .noneProtobufFixed64, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFloat: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFloat] = [ - .noneProtobufFloat, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt32: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt32] = [ - .noneProtobufInt32, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt64: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt64] = [ - .noneProtobufInt64, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMap: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMap] = [ - .noneProtobufMap, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMessageMap: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMessageMap] = [ - .noneProtobufMessageMap, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed32: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed32] = [ - .noneProtobufSfixed32, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed64: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed64] = [ - .noneProtobufSfixed64, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt32: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt32] = [ - .noneProtobufSint32, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt64: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt64] = [ - .noneProtobufSint64, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufString: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufString] = [ - .noneProtobufString, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt32: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt32] = [ - .noneProtobufUint32, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt64: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt64] = [ - .noneProtobufUint64, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues] = [ - .noneProtobufExtensionFieldValues, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_fieldNumber: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_fieldNumber] = [ - .noneProtobufFieldNumber, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo] = [ - .noneProtobufGeneratedIsEqualTo, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_nameMap: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_nameMap] = [ - .noneProtobufNameMap, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_newField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_newField] = [ - .noneProtobufNewField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_package: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_package] = [ - .noneProtobufPackage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protocolEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protocolEnum] = [ - .noneProtocol, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoFieldName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoFieldName] = [ - .noneProtoFieldName, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoMessageNameEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoMessageNameEnum] = [ - .noneProtoMessageName, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtoNameProviding: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtoNameProviding] = [ - .noneProtoNameProviding, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoPaths: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoPaths] = [ - .noneProtoPaths, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicEnum] = [ - .nonePublic, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicDependency: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicDependency] = [ - .nonePublicDependency, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBoolValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBoolValue] = [ - .nonePutBoolValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBytesValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBytesValue] = [ - .nonePutBytesValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putDoubleValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putDoubleValue] = [ - .nonePutDoubleValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putEnumValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putEnumValue] = [ - .nonePutEnumValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt32: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt32] = [ - .nonePutFixedUint32, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt64: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt64] = [ - .nonePutFixedUint64, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFloatValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFloatValue] = [ - .nonePutFloatValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putInt64: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putInt64] = [ - .nonePutInt64, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putStringValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putStringValue] = [ - .nonePutStringValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64] = [ - .nonePutUint64, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64Hex: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64Hex] = [ - .nonePutUint64Hex, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putVarInt: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putVarInt] = [ - .nonePutVarInt, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putZigZagVarInt: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putZigZagVarInt] = [ - .nonePutZigZagVarInt, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pyGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pyGenericServices] = [ - .nonePyGenericServices, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rawChars: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rawChars] = [ - .noneRawChars, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawRepresentable: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawRepresentable] = [ - .noneRawRepresentable, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawValue] = [ - .noneRawValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.read4HexDigits: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.read4HexDigits] = [ - .noneRead4HexDigits, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.register: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.register] = [ - .noneRegister, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField] = [ - .noneRepeatedEnumExtensionField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedExtensionField] = [ - .noneRepeatedExtensionField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField] = [ - .noneRepeatedGroupExtensionField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField] = [ - .noneRepeatedMessageExtensionField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestStreaming: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestStreaming] = [ - .noneRequestStreaming, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestTypeURL: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestTypeURL] = [ - .noneRequestTypeURL, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requiredSize: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requiredSize] = [ - .noneRequiredSize, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.reservedName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.reservedName] = [ - .noneReservedName, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.reservedRange: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.reservedRange] = [ - .noneReservedRange, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseStreaming: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseStreaming] = [ - .noneResponseStreaming, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseTypeURL: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseTypeURL] = [ - .noneResponseTypeURL, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.result: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.result] = [ - .noneResult, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rethrowsEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rethrowsEnum] = [ - .noneRethrows, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.returnEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.returnEnum] = [ - .noneReturn, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ReturnType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ReturnType] = [ - .noneReturnType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.revision: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.revision] = [ - .noneRevision, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rhs: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rhs] = [ - .noneRhs, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.root: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.root] = [ - .noneRoot, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rubyPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rubyPackage] = [ - .noneRubyPackage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.s: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.s] = [ - .noneS, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawBackslash: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawBackslash] = [ - .noneSawBackslash, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection4Characters: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection4Characters] = [ - .noneSawSection4Characters, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection5Characters: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection5Characters] = [ - .noneSawSection5Characters, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.scanner: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.scanner] = [ - .noneScanner, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.seconds: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.seconds] = [ - .noneSeconds, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.selfEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.selfEnum] = [ - .noneSelf, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.separator: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.separator] = [ - .noneSeparator, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serialize: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serialize] = [ - .noneSerialize, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedData: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedData] = [ - .noneSerializedData, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedSize: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedSize] = [ - .noneSerializedSize, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serverStreaming: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serverStreaming] = [ - .noneServerStreaming, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.service: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.service] = [ - .noneService, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ServiceDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ServiceDescriptorProto] = [ - .noneServiceDescriptorProto, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ServiceOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ServiceOptions] = [ - .noneServiceOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.set: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.set] = [ - .noneSet, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.setExtensionValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.setExtensionValue] = [ - .noneSetExtensionValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.shift: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.shift] = [ - .noneShift, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SimpleExtensionMap: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SimpleExtensionMap] = [ - .noneSimpleExtensionMap, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sizer: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sizer] = [ - .noneSizer, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.source: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.source] = [ - .noneSource, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceCodeInfo: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceCodeInfo] = [ - .noneSourceCodeInfo, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceContext: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceContext] = [ - .noneSourceContext, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceEncoding: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceEncoding] = [ - .noneSourceEncoding, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceFile: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceFile] = [ - .noneSourceFile, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.span: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.span] = [ - .noneSpan, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.split: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.split] = [ - .noneSplit, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.start: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.start] = [ - .noneStart, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArray: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArray] = [ - .noneStartArray, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArrayObject: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArrayObject] = [ - .noneStartArrayObject, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startField] = [ - .noneStartField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startIndex: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startIndex] = [ - .noneStartIndex, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startMessageField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startMessageField] = [ - .noneStartMessageField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startObject: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startObject] = [ - .noneStartObject, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startRegularField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startRegularField] = [ - .noneStartRegularField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.state: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.state] = [ - .noneState, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.staticEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.staticEnum] = [ - .noneStatic, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StaticString: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StaticString] = [ - .noneStaticString, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.storage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.storage] = [ - .noneStorage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringEnum] = [ - .noneString, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringLiteral] = [ - .noneStringLiteral, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringLiteralType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringLiteralType] = [ - .noneStringLiteralType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringResult: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringResult] = [ - .noneStringResult, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringValue] = [ - .noneStringValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structEnum] = [ - .noneStruct, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structValue] = [ - .noneStructValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subDecoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subDecoder] = [ - .noneSubDecoder, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subscriptEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subscriptEnum] = [ - .noneSubscript, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subVisitor] = [ - .noneSubVisitor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Swift: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Swift] = [ - .noneSwift, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.swiftPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.swiftPrefix] = [ - .noneSwiftPrefix, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SwiftProtobufEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SwiftProtobufEnum] = [ - .noneSwiftProtobuf, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.syntax: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.syntax] = [ - .noneSyntax, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.T: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.T] = [ - .noneT, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tag: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tag] = [ - .noneTag, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.terminator: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.terminator] = [ - .noneTerminator, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.testDecoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.testDecoder] = [ - .noneTestDecoder, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.text: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.text] = [ - .noneText, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textDecoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textDecoder] = [ - .noneTextDecoder, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecoder] = [ - .noneTextFormatDecoder, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingError: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingError] = [ - .noneTextFormatDecodingError, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingOptions] = [ - .noneTextFormatDecodingOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingOptions] = [ - .noneTextFormatEncodingOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingVisitor] = [ - .noneTextFormatEncodingVisitor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textFormatString: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textFormatString] = [ - .noneTextFormatString, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.throwsEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.throwsEnum] = [ - .noneThrows, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeInterval: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeInterval] = [ - .noneTimeInterval, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSince1970: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSince1970] = [ - .noneTimeIntervalSince1970, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate] = [ - .noneTimeIntervalSinceReferenceDate, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Timestamp: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Timestamp] = [ - .noneTimestamp, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.total: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.total] = [ - .noneTotal, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalArrayDepth: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalArrayDepth] = [ - .noneTotalArrayDepth, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalSize: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalSize] = [ - .noneTotalSize, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trailingComments: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trailingComments] = [ - .noneTrailingComments, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.traverseEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.traverseEnum] = [ - .noneTraverse, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trueEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trueEnum] = [ - .noneTrue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tryEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tryEnum] = [ - .noneTry, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.type: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.type] = [ - .noneType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typealiasEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typealiasEnum] = [ - .noneTypealias, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TypeEnumEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TypeEnumEnum] = [ - .noneTypeEnum, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeName] = [ - .noneTypeName, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typePrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typePrefix] = [ - .noneTypePrefix, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeStart: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeStart] = [ - .noneTypeStart, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeUnknown: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeUnknown] = [ - .noneTypeUnknown, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeURL: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeURL] = [ - .noneTypeURL, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Enum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Enum] = [ - .noneUint32, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Value] = [ - .noneUint32Value, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Enum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Enum] = [ - .noneUint64, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Value] = [ - .noneUint64Value, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt8: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt8] = [ - .noneUint8, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalarLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalarLiteral] = [ - .noneUnicodeScalarLiteral, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarLiteralType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarLiteralType] = [ - .noneUnicodeScalarLiteralType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalars: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalars] = [ - .noneUnicodeScalars, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarView: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarView] = [ - .noneUnicodeScalarView, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uninterpretedOption: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uninterpretedOption] = [ - .noneUninterpretedOption, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.union: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.union] = [ - .noneUnion, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uniqueStorage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uniqueStorage] = [ - .noneUniqueStorage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknown: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknown] = [ - .noneUnknown, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknownFieldsEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknownFieldsEnum] = [ - .noneUnknownFields, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnknownStorage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnknownStorage] = [ - .noneUnknownStorage, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unpackTo: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unpackTo] = [ - .noneUnpackTo, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeBufferPointer: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeBufferPointer] = [ - .noneUnsafeBufferPointer, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutablePointer: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutablePointer] = [ - .noneUnsafeMutablePointer, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawBufferPointer: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawBufferPointer] = [ - .noneUnsafeMutableRawBufferPointer, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawPointer: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawPointer] = [ - .noneUnsafeMutableRawPointer, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawBufferPointer: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawBufferPointer] = [ - .noneUnsafeRawBufferPointer, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawPointer: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawPointer] = [ - .noneUnsafeRawPointer, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.updatedOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.updatedOptions] = [ - .noneUpdatedOptions, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.url: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.url] = [ - .noneURL, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8] = [ - .noneUtf8, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8Ptr: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8Ptr] = [ - .noneUtf8Ptr, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8ToDouble: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8ToDouble] = [ - .noneUtf8ToDouble, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UTF8View: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UTF8View] = [ - .noneUtf8View, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.v: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.v] = [ - .noneV, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.value] = [ - .noneValue, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.valueField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.valueField] = [ - .noneValueField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.values: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.values] = [ - .noneValues, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ValueType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ValueType] = [ - .noneValueType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.varEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.varEnum] = [ - .noneVar, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Version: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Version] = [ - .noneVersion, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.versionString: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.versionString] = [ - .noneVersionString, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFields: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFields] = [ - .noneVisitExtensionFields, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFieldsAsMessageSet: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFieldsAsMessageSet] = [ - .noneVisitExtensionFieldsAsMessageSet, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitMapField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitMapField] = [ - .noneVisitMapField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitor] = [ - .noneVisitor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPacked: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPacked] = [ - .noneVisitPacked, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedBoolField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedBoolField] = [ - .noneVisitPackedBoolField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedDoubleField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedDoubleField] = [ - .noneVisitPackedDoubleField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedEnumField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedEnumField] = [ - .noneVisitPackedEnumField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed32Field] = [ - .noneVisitPackedFixed32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed64Field] = [ - .noneVisitPackedFixed64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFloatField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFloatField] = [ - .noneVisitPackedFloatField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt32Field] = [ - .noneVisitPackedInt32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt64Field] = [ - .noneVisitPackedInt64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed32Field] = [ - .noneVisitPackedSfixed32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed64Field] = [ - .noneVisitPackedSfixed64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt32Field] = [ - .noneVisitPackedSint32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt64Field] = [ - .noneVisitPackedSint64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt32Field] = [ - .noneVisitPackedUint32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt64Field] = [ - .noneVisitPackedUint64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeated: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeated] = [ - .noneVisitRepeated, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBoolField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBoolField] = [ - .noneVisitRepeatedBoolField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBytesField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBytesField] = [ - .noneVisitRepeatedBytesField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedDoubleField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedDoubleField] = [ - .noneVisitRepeatedDoubleField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedEnumField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedEnumField] = [ - .noneVisitRepeatedEnumField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed32Field] = [ - .noneVisitRepeatedFixed32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed64Field] = [ - .noneVisitRepeatedFixed64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFloatField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFloatField] = [ - .noneVisitRepeatedFloatField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedGroupField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedGroupField] = [ - .noneVisitRepeatedGroupField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt32Field] = [ - .noneVisitRepeatedInt32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt64Field] = [ - .noneVisitRepeatedInt64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedMessageField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedMessageField] = [ - .noneVisitRepeatedMessageField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed32Field] = [ - .noneVisitRepeatedSfixed32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed64Field] = [ - .noneVisitRepeatedSfixed64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt32Field] = [ - .noneVisitRepeatedSint32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt64Field] = [ - .noneVisitRepeatedSint64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedStringField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedStringField] = [ - .noneVisitRepeatedStringField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt32Field] = [ - .noneVisitRepeatedUint32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt64Field] = [ - .noneVisitRepeatedUint64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingular: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingular] = [ - .noneVisitSingular, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBoolField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBoolField] = [ - .noneVisitSingularBoolField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBytesField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBytesField] = [ - .noneVisitSingularBytesField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularDoubleField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularDoubleField] = [ - .noneVisitSingularDoubleField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularEnumField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularEnumField] = [ - .noneVisitSingularEnumField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed32Field] = [ - .noneVisitSingularFixed32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed64Field] = [ - .noneVisitSingularFixed64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFloatField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFloatField] = [ - .noneVisitSingularFloatField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularGroupField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularGroupField] = [ - .noneVisitSingularGroupField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt32Field] = [ - .noneVisitSingularInt32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt64Field] = [ - .noneVisitSingularInt64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularMessageField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularMessageField] = [ - .noneVisitSingularMessageField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed32Field] = [ - .noneVisitSingularSfixed32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed64Field] = [ - .noneVisitSingularSfixed64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt32Field] = [ - .noneVisitSingularSint32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt64Field] = [ - .noneVisitSingularSint64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularStringField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularStringField] = [ - .noneVisitSingularStringField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt32Field] = [ - .noneVisitSingularUint32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt64Field] = [ - .noneVisitSingularUint64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitUnknown: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitUnknown] = [ - .noneVisitUnknown, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wasDecoded: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wasDecoded] = [ - .noneWasDecoded, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.weak: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.weak] = [ - .noneWeak, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.weakDependency: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.weakDependency] = [ - .noneWeakDependency, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.whereEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.whereEnum] = [ - .noneWhere, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wireFormat: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wireFormat] = [ - .noneWireFormat, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.with: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.with] = [ - .noneWith, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeBytes: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeBytes] = [ - .noneWithUnsafeBytes, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeMutableBytes: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeMutableBytes] = [ - .noneWithUnsafeMutableBytes, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.work: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.work] = [ - .noneWork, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.WrappedType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.WrappedType] = [ - .noneWrappedType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.written: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.written] = [ - .noneWritten, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.yday: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.yday] = [ - .noneYday, - ] -} - -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.adjusted: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.aggregateValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allCases: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allowAlias: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.alwaysPrintEnumsAsInts: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.annotation: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.any: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageStorage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyUnpackError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Api: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appended: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUIntHex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUnknown: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.areAllInitialized: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.array: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayDepth: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arraySeparator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiOpenCurlyBracket: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiZero: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.available: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.b: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.base64Values: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.baseAddress: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BaseType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.begin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binary: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDelimited: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetSizeVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingSizeVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binaryOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.body: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BoolEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.booleanLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BooleanLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.boolValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesInGroup: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesRead: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BytesValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.c: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.capitalizeNext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.cardinality: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ccEnableArenas: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ccGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Character: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.chars: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.classEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearAggregateValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearAllowAlias: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearBegin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCcEnableArenas: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCcGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearClientStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCsharpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCtype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDefaultValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDeprecated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDoubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearEnd: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtendee: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtensionValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearGoPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIdempotencyLevel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIdentifierValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearInputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIsExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaGenerateEqualsAndHash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaMultipleFiles: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaOuterClassname: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaStringCheckUtf8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJsonName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJstype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLabel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLazy: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLeadingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearMapEntry: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearMessageSetWireFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNamePart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNegativeIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNoStandardDescriptorAccessor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearObjcClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOneofIndex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOptimizeFor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOutputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPacked: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpMetadataNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPositiveIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearProto3Optional: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPyGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearRubyPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearServerStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceContext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceFile: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearStart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearStringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSwiftPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSyntax: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearTrailingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearTypeName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearWeak: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clientStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codePoint: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codeUnits: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Collection: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.com: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.comma: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.contentsOf: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ContiguousBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.count: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.countVarintsInBuffer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.csharpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ctype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.customCodable: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.CustomDebugStringConvertible: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.d: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DataEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dataResult: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.date: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daySec: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daysSinceEpoch: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.debugDescriptionEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoded: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodedFromJSONNull: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionFieldsAsMessageSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeJSON: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMapField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMessageEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBytesField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedGroupField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedStringField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingular: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBytesField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularGroupField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularStringField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeTextFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultAnyTypeURLPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dependency: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.deprecated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.descriptionEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Dictionary: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dictionaryLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit0: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit1: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitCount: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digits: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardableResult: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardUnknownFields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.distance: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.double: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.doubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Duration: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.E: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Element: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.elements: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitExtensionFieldName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Empty: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emptyData: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeAsBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoded: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedJSONString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.end: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endArray: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endObject: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endRegularField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumReservedRange: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumvalue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumValueDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumValueOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Equatable: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Error: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByArrayLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByDictionaryLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendedGraphemeClusterLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtendedGraphemeClusterLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendee: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensibleMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionFieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionFieldValueSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionRange: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionRangeOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extras: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.F: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.falseEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldData: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldMask: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNameCount: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumberForProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldTag: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.file: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileDescriptorSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fileName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.filter: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.first: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.firstItem: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.float: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.floatLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forMessageName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.formUnion: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forReadingFrom: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forTypeURL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ForwardParser: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forWritingInto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.from: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii2: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii4: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromByteOffset: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromHexDigit: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.funcEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.G: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.GeneratedCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.get: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.getExtensionValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.googleapis: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Any: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Api: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BoolValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BytesValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DoubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Duration: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Empty: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Enum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ExtensionRangeOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldMask: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FloatValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_GeneratedCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int32Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int64Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ListValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MessageOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Method: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Mixin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_NullValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Option: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceContext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_StringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Struct: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Syntax: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Timestamp: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Type: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt32Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt64Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UninterpretedOption: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.goPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.group: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupFieldNumberStack: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.h: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hadOneofValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.handleConflictingOneOf: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasAggregateValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasAllowAlias: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasBegin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCcEnableArenas: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCcGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasClientStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCsharpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCtype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDefaultValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDeprecated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDoubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasEnd: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtendee: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtensionValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasGoPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Hashable: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasher: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hashValueEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.HashVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIdempotencyLevel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIdentifierValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasInputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIsExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaGenerateEqualsAndHash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaMultipleFiles: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaOuterClassname: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaStringCheckUtf8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJsonName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJstype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLabel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLazy: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLeadingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasMapEntry: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasMessageSetWireFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNamePart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNegativeIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNoStandardDescriptorAccessor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasObjcClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOneofIndex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOptimizeFor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOutputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPacked: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpMetadataNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPositiveIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasProto3Optional: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPyGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasRubyPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasServerStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceContext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceFile: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasStart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasStringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSwiftPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSyntax: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasTrailingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasTypeName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasWeak: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hour: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.idempotencyLevel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.identifierValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ifEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ignoreUnknownFields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.index: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.initEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inoutEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.insert: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Enum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Enum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.integerLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntegerLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.intern: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Internal: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.InternalState: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.into: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ints: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isA: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqual: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqualTo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isInitializedEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.itemTagsEncodedSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Iterator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i_2166136261: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaGenerateEqualsAndHash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaMultipleFiles: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaOuterClassname: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaStringCheckUtf8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonEncoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONMapEncodingVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPath: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPaths: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONScanner: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonText: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonUTF8Data: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jstype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.k: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Key: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.keyField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.KeyType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.kind: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.l: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.label: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lazy: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.leadingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.leadingDetachedComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.length: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lessThan: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.letEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lhs: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.list: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listOfMessages: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndian: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndianBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.load: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.localHasher: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.location: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.M: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.major: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.makeIterator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapEntry: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapHash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapKeyType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapNameResolver: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapToMessages: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapValueType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mdayStart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.merge: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.message: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageDepthLimit: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageImplementationBase: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageSetWireFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Method: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MethodDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MethodOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.methods: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.minor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Mixin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mixins: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.modifier: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.modify: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.month: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.msgExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mutating: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.n: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.name: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameDescription: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NamePart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nameResolver: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.names: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nanos: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeEndianBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.negativeIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nestedType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newList: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextByte: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextFieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.noStandardDescriptorAccessor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nullValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.number: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.numberValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.objcClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.of: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofDecl: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneofDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofIndex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneofOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofs: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneOf_Kind: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.optimizeFor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptimizeMode: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Option: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalEnumExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalGroupExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalMessageExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.options: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.other: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.others: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.out: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.outputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.p: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.package: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.packed: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedEnumExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.padding: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parent: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parse: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.partial: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.path: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.paths: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payload: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payloadSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpMetadataNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pos: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.positiveIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.prefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preserveProtoFieldNames: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preTraverse: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.printUnknownFields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto2: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3DefaultValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3Optional: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_2: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBool: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufDouble: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufEnumMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobufExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFloat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMessageMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_fieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_nameMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_newField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_package: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protocolEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoFieldName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoMessageNameEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtoNameProviding: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoPaths: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicDependency: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBoolValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBytesValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putDoubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putEnumValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFloatValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putStringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64Hex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putVarInt: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putZigZagVarInt: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pyGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rawChars: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawRepresentable: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.read4HexDigits: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.register: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestTypeURL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requiredSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.reservedName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.reservedRange: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseTypeURL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.result: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rethrowsEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.returnEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ReturnType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.revision: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rhs: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.root: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rubyPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.s: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawBackslash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection4Characters: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection5Characters: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.scanner: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.seconds: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.selfEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.separator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serialize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedData: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serverStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.service: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ServiceDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ServiceOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.set: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.setExtensionValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.shift: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SimpleExtensionMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sizer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.source: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceContext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceEncoding: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceFile: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.span: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.split: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.start: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArray: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArrayObject: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startIndex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startObject: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startRegularField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.state: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.staticEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StaticString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.storage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringResult: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subscriptEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Swift: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.swiftPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SwiftProtobufEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.syntax: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.T: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tag: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.terminator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.testDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.text: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textFormatString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.throwsEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeInterval: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSince1970: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Timestamp: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.total: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalArrayDepth: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trailingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.traverseEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trueEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tryEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.type: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typealiasEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TypeEnumEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typePrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeStart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeUnknown: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeURL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Enum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Enum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalarLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalars: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarView: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uninterpretedOption: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.union: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uniqueStorage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknown: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknownFieldsEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnknownStorage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unpackTo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeBufferPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutablePointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawBufferPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawBufferPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.updatedOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.url: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8Ptr: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8ToDouble: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UTF8View: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.v: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.valueField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.values: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ValueType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.varEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Version: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.versionString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFieldsAsMessageSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitMapField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPacked: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBytesField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedGroupField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedStringField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingular: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBytesField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularGroupField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularStringField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitUnknown: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wasDecoded: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.weak: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.weakDependency: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.whereEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wireFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.with: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeMutableBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.work: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.WrappedType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.written: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.yday: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest_generated" - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".GeneratedSwiftReservedEnums" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedEnums, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedEnums) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.adjusted: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_adjusted"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.aggregateValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_aggregateValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allCases: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_allCases"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allowAlias: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_allowAlias"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.alwaysPrintEnumsAsInts: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_alwaysPrintEnumsAsInts"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.annotation: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_annotation"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.any: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_any"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_AnyExtensionField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageExtension: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_AnyMessageExtension"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageStorage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_AnyMessageStorage"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyUnpackError: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_AnyUnpackError"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Api: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Api"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appended: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_appended"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUIntHex: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_appendUIntHex"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUnknown: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_appendUnknown"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.areAllInitialized: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_areAllInitialized"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.array: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_array"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayDepth: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_arrayDepth"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_arrayLiteral"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arraySeparator: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_arraySeparator"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_as"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiOpenCurlyBracket: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_asciiOpenCurlyBracket"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiZero: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_asciiZero"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.available: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_available"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.b: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_b"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.base64Values: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_base64Values"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.baseAddress: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_baseAddress"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BaseType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BaseType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.begin: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_begin"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binary: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_binary"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryDecoder"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingError: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryDecodingError"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryDecodingOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDelimited: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryDelimited"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryEncoder"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingError: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryEncodingError"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetSizeVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryEncodingMessageSetSizeVisitor"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryEncodingMessageSetVisitor"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingSizeVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryEncodingSizeVisitor"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryEncodingVisitor"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binaryOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_binaryOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.body: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_body"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BoolEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Bool"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.booleanLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_booleanLiteral"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BooleanLiteralType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BooleanLiteralType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.boolValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_boolValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytes: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_bytes"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesInGroup: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_bytesInGroup"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesRead: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_bytesRead"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BytesValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BytesValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.c: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_c"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.capitalizeNext: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_capitalizeNext"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.cardinality: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_cardinality"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ccEnableArenas: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ccEnableArenas"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ccGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ccGenericServices"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Character: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Character"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.chars: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_chars"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.classEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_class"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearAggregateValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearAggregateValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearAllowAlias: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearAllowAlias"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearBegin: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearBegin"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCcEnableArenas: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearCcEnableArenas"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCcGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearCcGenericServices"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearClientStreaming: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearClientStreaming"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCsharpNamespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearCsharpNamespace"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCtype: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearCtype"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDefaultValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearDefaultValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDeprecated: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearDeprecated"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDoubleValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearDoubleValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearEnd: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearEnd"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtendee: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearExtendee"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtensionValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearExtensionValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearGoPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearGoPackage"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIdempotencyLevel: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearIdempotencyLevel"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIdentifierValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearIdentifierValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearInputType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearInputType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIsExtension: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearIsExtension"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaGenerateEqualsAndHash: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearJavaGenerateEqualsAndHash"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearJavaGenericServices"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaMultipleFiles: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearJavaMultipleFiles"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaOuterClassname: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearJavaOuterClassname"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearJavaPackage"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaStringCheckUtf8: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearJavaStringCheckUtf8"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJsonName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearJsonName"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJstype: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearJstype"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLabel: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearLabel"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLazy: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearLazy"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLeadingComments: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearLeadingComments"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearMapEntry: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearMapEntry"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearMessageSetWireFormat: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearMessageSetWireFormat"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearName"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNamePart: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearNamePart"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNegativeIntValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearNegativeIntValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNoStandardDescriptorAccessor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearNoStandardDescriptorAccessor"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNumber: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearNumber"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearObjcClassPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearObjcClassPrefix"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOneofIndex: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearOneofIndex"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOptimizeFor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearOptimizeFor"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOutputType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearOutputType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearPackage"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPacked: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearPacked"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpClassPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearPhpClassPrefix"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearPhpGenericServices"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpMetadataNamespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearPhpMetadataNamespace"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpNamespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearPhpNamespace"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPositiveIntValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearPositiveIntValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearProto3Optional: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearProto3Optional"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPyGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearPyGenericServices"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearRubyPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearRubyPackage"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearServerStreaming: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearServerStreaming"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceCodeInfo: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearSourceCodeInfo"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceContext: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearSourceContext"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceFile: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearSourceFile"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearStart: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearStart"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearStringValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearStringValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSwiftPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearSwiftPrefix"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSyntax: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearSyntax"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearTrailingComments: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearTrailingComments"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearTypeName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearTypeName"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearWeak: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearWeak"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clientStreaming: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clientStreaming"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codePoint: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_codePoint"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codeUnits: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_codeUnits"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Collection: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Collection"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.com: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_com"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.comma: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_comma"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.contentsOf: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_contentsOf"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ContiguousBytes: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ContiguousBytes"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.count: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_count"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.countVarintsInBuffer: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_countVarintsInBuffer"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.csharpNamespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_csharpNamespace"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ctype: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ctype"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.customCodable: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_customCodable"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.CustomDebugStringConvertible: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_CustomDebugStringConvertible"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.d: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_d"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DataEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Data"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dataResult: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_dataResult"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.date: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_date"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daySec: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_daySec"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daysSinceEpoch: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_daysSinceEpoch"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.debugDescriptionEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_debugDescription"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoded: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decoded"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodedFromJSONNull: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodedFromJSONNull"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeExtensionField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionFieldsAsMessageSet: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeExtensionFieldsAsMessageSet"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeJSON: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeJSON"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMapField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeMapField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMessageEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeMessage"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decoder"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeated: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeated"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBoolField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedBoolField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBytesField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedBytesField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedDoubleField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedDoubleField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedEnumField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedEnumField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedFixed32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedFixed64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFloatField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedFloatField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedGroupField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedGroupField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedInt32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedInt64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedMessageField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedMessageField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedSFixed32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedSFixed64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedSInt32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedSInt64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedStringField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedStringField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedUInt32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedUInt64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingular: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingular"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBoolField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularBoolField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBytesField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularBytesField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularDoubleField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularDoubleField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularEnumField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularEnumField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularFixed32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularFixed64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFloatField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularFloatField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularGroupField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularGroupField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularInt32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularInt64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularMessageField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularMessageField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularSFixed32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularSFixed64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularSInt32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularSInt64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularStringField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularStringField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularUInt32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularUInt64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeTextFormat: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeTextFormat"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultAnyTypeURLPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_defaultAnyTypeURLPrefix"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_defaultValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dependency: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_dependency"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.deprecated: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_deprecated"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.descriptionEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_description"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_DescriptorProto"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Dictionary: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Dictionary"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dictionaryLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_dictionaryLiteral"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_digit"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit0: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_digit0"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit1: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_digit1"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitCount: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_digitCount"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digits: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_digits"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_digitValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardableResult: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_discardableResult"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardUnknownFields: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_discardUnknownFields"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.distance: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_distance"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.double: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_double"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.doubleValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_doubleValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Duration: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Duration"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.E: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_E"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Element: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Element"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.elements: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_elements"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitExtensionFieldName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_emitExtensionFieldName"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_emitFieldName"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldNumber: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_emitFieldNumber"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Empty: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Empty"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emptyData: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_emptyData"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeAsBytes: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_encodeAsBytes"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoded: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_encoded"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedJSONString: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_encodedJSONString"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedSize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_encodedSize"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_encodeField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_encoder"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.end: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_end"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endArray: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_endArray"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endMessageField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_endMessageField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endObject: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_endObject"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endRegularField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_endRegularField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_enum"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_EnumDescriptorProto"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_EnumOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumReservedRange: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_EnumReservedRange"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_enumType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumvalue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_enumvalue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumValueDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_EnumValueDescriptorProto"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumValueOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_EnumValueOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Equatable: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Equatable"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Error: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Error"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByArrayLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ExpressibleByArrayLiteral"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByDictionaryLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ExpressibleByDictionaryLiteral"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ext: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ext"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extDecoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_extDecoder"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendedGraphemeClusterLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_extendedGraphemeClusterLiteral"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtendedGraphemeClusterLiteralType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ExtendedGraphemeClusterLiteralType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendee: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_extendee"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensibleMessage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ExtensibleMessage"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_extension"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ExtensionField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionFieldNumber: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_extensionFieldNumber"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionFieldValueSet: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ExtensionFieldValueSet"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionMap: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ExtensionMap"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionRange: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_extensionRange"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionRangeOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ExtensionRangeOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_extensions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extras: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_extras"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.F: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_F"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.falseEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_false"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldData: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fieldData"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_FieldDescriptorProto"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldMask: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_FieldMask"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fieldName"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNameCount: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fieldNameCount"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fieldNum"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumber: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fieldNumber"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumberForProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fieldNumberForProto"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_FieldOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fields: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fields"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldSize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fieldSize"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldTag: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_FieldTag"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fieldType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.file: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_file"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_FileDescriptorProto"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileDescriptorSet: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_FileDescriptorSet"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fileName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fileName"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_FileOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.filter: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_filter"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.first: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_first"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.firstItem: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_firstItem"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.float: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_float"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.floatLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_floatLiteral"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatLiteralType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_FloatLiteralType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_FloatValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forMessageName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_forMessageName"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.formUnion: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_formUnion"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forReadingFrom: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_forReadingFrom"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forTypeURL: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_forTypeURL"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ForwardParser: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ForwardParser"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forWritingInto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_forWritingInto"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.from: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_from"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii2: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fromAscii2"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii4: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fromAscii4"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromByteOffset: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fromByteOffset"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromHexDigit: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fromHexDigit"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.funcEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_func"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.G: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_G"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.GeneratedCodeInfo: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_GeneratedCodeInfo"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.get: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_get"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.getExtensionValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_getExtensionValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.googleapis: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_googleapis"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Any: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Any"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Api: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Api"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BoolValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_BoolValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BytesValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_BytesValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_DescriptorProto"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DoubleValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_DoubleValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Duration: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Duration"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Empty: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Empty"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Enum"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_EnumDescriptorProto"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_EnumOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_EnumValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_EnumValueDescriptorProto"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_EnumValueOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_ExtensionRangeOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_FieldDescriptorProto"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldMask: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_FieldMask"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_FieldOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_FileDescriptorProto"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorSet: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_FileDescriptorSet"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_FileOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FloatValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_FloatValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_GeneratedCodeInfo"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int32Value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Int32Value"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int64Value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Int64Value"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ListValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_ListValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MessageOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_MessageOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Method: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Method"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_MethodDescriptorProto"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_MethodOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Mixin: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Mixin"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_NullValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_NullValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_OneofDescriptorProto"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_OneofOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Option: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Option"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_ServiceDescriptorProto"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_ServiceOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceCodeInfo: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_SourceCodeInfo"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceContext: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_SourceContext"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_StringValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_StringValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Struct: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Struct"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Syntax: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Syntax"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Timestamp: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Timestamp"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Type: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Type"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt32Value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_UInt32Value"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt64Value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_UInt64Value"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UninterpretedOption: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_UninterpretedOption"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Value"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.goPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_goPackage"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.group: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_group"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupFieldNumberStack: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_groupFieldNumberStack"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupSize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_groupSize"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.h: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_h"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hadOneofValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hadOneofValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.handleConflictingOneOf: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_handleConflictingOneOf"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasAggregateValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasAggregateValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasAllowAlias: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasAllowAlias"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasBegin: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasBegin"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCcEnableArenas: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasCcEnableArenas"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCcGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasCcGenericServices"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasClientStreaming: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasClientStreaming"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCsharpNamespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasCsharpNamespace"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCtype: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasCtype"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDefaultValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasDefaultValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDeprecated: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasDeprecated"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDoubleValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasDoubleValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasEnd: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasEnd"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtendee: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasExtendee"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtensionValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasExtensionValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasGoPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasGoPackage"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hash: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hash"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Hashable: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Hashable"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasher: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasher"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hashValueEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hashValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.HashVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_HashVisitor"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIdempotencyLevel: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasIdempotencyLevel"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIdentifierValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasIdentifierValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasInputType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasInputType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIsExtension: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasIsExtension"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaGenerateEqualsAndHash: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasJavaGenerateEqualsAndHash"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasJavaGenericServices"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaMultipleFiles: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasJavaMultipleFiles"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaOuterClassname: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasJavaOuterClassname"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasJavaPackage"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaStringCheckUtf8: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasJavaStringCheckUtf8"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJsonName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasJsonName"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJstype: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasJstype"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLabel: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasLabel"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLazy: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasLazy"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLeadingComments: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasLeadingComments"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasMapEntry: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasMapEntry"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasMessageSetWireFormat: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasMessageSetWireFormat"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasName"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNamePart: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasNamePart"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNegativeIntValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasNegativeIntValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNoStandardDescriptorAccessor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasNoStandardDescriptorAccessor"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNumber: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasNumber"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasObjcClassPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasObjcClassPrefix"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOneofIndex: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasOneofIndex"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOptimizeFor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasOptimizeFor"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOutputType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasOutputType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasPackage"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPacked: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasPacked"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpClassPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasPhpClassPrefix"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasPhpGenericServices"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpMetadataNamespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasPhpMetadataNamespace"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpNamespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasPhpNamespace"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPositiveIntValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasPositiveIntValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasProto3Optional: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasProto3Optional"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPyGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasPyGenericServices"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasRubyPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasRubyPackage"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasServerStreaming: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasServerStreaming"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceCodeInfo: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasSourceCodeInfo"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceContext: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasSourceContext"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceFile: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasSourceFile"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasStart: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasStart"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasStringValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasStringValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSwiftPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasSwiftPrefix"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSyntax: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasSyntax"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasTrailingComments: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasTrailingComments"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasTypeName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasTypeName"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasWeak: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasWeak"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hour: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hour"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_i"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.idempotencyLevel: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_idempotencyLevel"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.identifierValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_identifierValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ifEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_if"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ignoreUnknownFields: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ignoreUnknownFields"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.index: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_index"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.initEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_init"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inoutEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_inout"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inputType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_inputType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.insert: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_insert"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Int"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Int32"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Int32Value"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Int64"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Int64Value"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int8: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Int8"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.integerLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_integerLiteral"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntegerLiteralType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_IntegerLiteralType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.intern: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_intern"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Internal: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Internal"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.InternalState: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_InternalState"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.into: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_into"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ints: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ints"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isA: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_isA"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqual: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_isEqual"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqualTo: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_isEqualTo"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isExtension: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_isExtension"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isInitializedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_isInitialized"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.itemTagsEncodedSize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_itemTagsEncodedSize"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Iterator: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Iterator"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i_2166136261: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_i_2166136261"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaGenerateEqualsAndHash: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_javaGenerateEqualsAndHash"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_javaGenericServices"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaMultipleFiles: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_javaMultipleFiles"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaOuterClassname: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_javaOuterClassname"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_javaPackage"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaStringCheckUtf8: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_javaStringCheckUtf8"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_JSONDecoder"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingError: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_JSONDecodingError"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_JSONDecodingOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonEncoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_jsonEncoder"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingError: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_JSONEncodingError"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_JSONEncodingOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_JSONEncodingVisitor"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONMapEncodingVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_JSONMapEncodingVisitor"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_jsonName"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPath: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_jsonPath"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPaths: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_jsonPaths"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONScanner: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_JSONScanner"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonString: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_jsonString"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonText: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_jsonText"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonUTF8Data: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_jsonUTF8Data"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jstype: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_jstype"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.k: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_k"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Key: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Key"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.keyField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_keyField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.KeyType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_KeyType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.kind: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_kind"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.l: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_l"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.label: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_label"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lazy: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_lazy"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.leadingComments: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_leadingComments"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.leadingDetachedComments: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_leadingDetachedComments"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.length: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_length"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lessThan: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_lessThan"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.letEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_let"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lhs: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_lhs"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.list: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_list"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listOfMessages: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_listOfMessages"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_listValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndian: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_littleEndian"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndianBytes: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_littleEndianBytes"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.load: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_load"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.localHasher: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_localHasher"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.location: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_location"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.M: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_M"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.major: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_major"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.makeIterator: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_makeIterator"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapEntry: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_mapEntry"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapHash: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_mapHash"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapKeyType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_MapKeyType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapNameResolver: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_mapNameResolver"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapToMessages: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_mapToMessages"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapValueType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_MapValueType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_mapVisitor"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mdayStart: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_mdayStart"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.merge: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_merge"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.message: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_message"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageDepthLimit: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_messageDepthLimit"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageExtension: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_MessageExtension"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageImplementationBase: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_MessageImplementationBase"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_MessageOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageSet: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_MessageSet"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageSetWireFormat: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_messageSetWireFormat"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_messageType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Method: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Method"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MethodDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_MethodDescriptorProto"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MethodOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_MethodOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.methods: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_methods"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.minor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_minor"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Mixin: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Mixin"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mixins: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_mixins"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.modifier: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_modifier"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.modify: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_modify"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.month: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_month"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.msgExtension: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_msgExtension"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mutating: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_mutating"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.n: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_n"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.name: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_name"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameDescription: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_NameDescription"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameMap: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_NameMap"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NamePart: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_NamePart"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nameResolver: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nameResolver"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.names: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_names"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nanos: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nanos"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeBytes: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nativeBytes"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeEndianBytes: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nativeEndianBytes"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.negativeIntValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_negativeIntValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nestedType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nestedType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newL: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_newL"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newList: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_newList"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_newValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextByte: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nextByte"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextFieldNumber: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nextFieldNumber"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nil"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nilLiteral"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.noStandardDescriptorAccessor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_noStandardDescriptorAccessor"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nullValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nullValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.number: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_number"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.numberValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_numberValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.objcClassPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_objcClassPrefix"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.of: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_of"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofDecl: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_oneofDecl"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneofDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_OneofDescriptorProto"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofIndex: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_oneofIndex"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneofOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_OneofOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofs: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_oneofs"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneOf_Kind: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_OneOf_Kind"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.optimizeFor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_optimizeFor"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptimizeMode: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_OptimizeMode"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Option: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Option"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalEnumExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_OptionalEnumExtensionField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_OptionalExtensionField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalGroupExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_OptionalGroupExtensionField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalMessageExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_OptionalMessageExtensionField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.options: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_options"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.other: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_other"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.others: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_others"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.out: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_out"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.outputType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_outputType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.p: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_p"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.package: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_package"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.packed: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_packed"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedEnumExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_PackedEnumExtensionField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_PackedExtensionField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.padding: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_padding"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parent: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_parent"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parse: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_parse"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.partial: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_partial"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.path: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_path"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.paths: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_paths"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payload: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_payload"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payloadSize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_payloadSize"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpClassPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_phpClassPrefix"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_phpGenericServices"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpMetadataNamespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_phpMetadataNamespace"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpNamespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_phpNamespace"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pointer: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_pointer"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pos: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_pos"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.positiveIntValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_positiveIntValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.prefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_prefix"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preserveProtoFieldNames: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_preserveProtoFieldNames"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preTraverse: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_preTraverse"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.printUnknownFields: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_printUnknownFields"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto2: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_proto2"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3DefaultValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_proto3DefaultValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3Optional: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_proto3Optional"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufAPIVersionCheck"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_2: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufAPIVersion_2"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBool: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufBool"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBytes: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufBytes"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufDouble: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufDouble"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufEnumMap: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufEnumMap"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobufExtension: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protobufExtension"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed32: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufFixed32"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed64: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufFixed64"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFloat: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufFloat"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt32: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufInt32"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt64: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufInt64"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMap: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufMap"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMessageMap: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufMessageMap"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed32: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufSFixed32"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed64: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufSFixed64"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt32: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufSInt32"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt64: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufSInt64"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufString: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufString"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt32: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufUInt32"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt64: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufUInt64"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protobuf_extensionFieldValues"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_fieldNumber: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protobuf_fieldNumber"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protobuf_generated_isEqualTo"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_nameMap: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protobuf_nameMap"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_newField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protobuf_newField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_package: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protobuf_package"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protocolEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protocol"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoFieldName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protoFieldName"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoMessageNameEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protoMessageName"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtoNameProviding: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtoNameProviding"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoPaths: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protoPaths"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_public"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicDependency: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_publicDependency"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBoolValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putBoolValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBytesValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putBytesValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putDoubleValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putDoubleValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putEnumValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putEnumValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt32: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putFixedUInt32"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt64: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putFixedUInt64"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFloatValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putFloatValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putInt64: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putInt64"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putStringValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putStringValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putUInt64"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64Hex: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putUInt64Hex"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putVarInt: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putVarInt"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putZigZagVarInt: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putZigZagVarInt"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pyGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_pyGenericServices"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rawChars: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_rawChars"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawRepresentable: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_RawRepresentable"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_RawValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.read4HexDigits: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_read4HexDigits"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.register: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_register"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_RepeatedEnumExtensionField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_RepeatedExtensionField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_RepeatedGroupExtensionField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_RepeatedMessageExtensionField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestStreaming: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_requestStreaming"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestTypeURL: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_requestTypeURL"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requiredSize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_requiredSize"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.reservedName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_reservedName"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.reservedRange: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_reservedRange"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseStreaming: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_responseStreaming"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseTypeURL: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_responseTypeURL"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.result: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_result"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rethrowsEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_rethrows"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.returnEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_return"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ReturnType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ReturnType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.revision: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_revision"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rhs: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_rhs"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.root: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_root"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rubyPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_rubyPackage"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.s: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_s"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawBackslash: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_sawBackslash"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection4Characters: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_sawSection4Characters"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection5Characters: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_sawSection5Characters"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.scanner: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_scanner"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.seconds: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_seconds"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.selfEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_self"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.separator: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_separator"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serialize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_serialize"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedData: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_serializedData"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedSize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_serializedSize"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serverStreaming: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_serverStreaming"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.service: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_service"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ServiceDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ServiceDescriptorProto"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ServiceOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ServiceOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.set: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_set"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.setExtensionValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_setExtensionValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.shift: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_shift"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SimpleExtensionMap: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_SimpleExtensionMap"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sizer: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_sizer"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.source: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_source"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceCodeInfo: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_sourceCodeInfo"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceContext: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_sourceContext"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceEncoding: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_sourceEncoding"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceFile: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_sourceFile"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.span: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_span"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.split: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_split"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.start: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_start"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArray: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_startArray"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArrayObject: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_startArrayObject"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_startField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startIndex: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_startIndex"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startMessageField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_startMessageField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startObject: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_startObject"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startRegularField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_startRegularField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.state: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_state"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.staticEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_static"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StaticString: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_StaticString"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.storage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_storage"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_String"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_stringLiteral"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringLiteralType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_StringLiteralType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringResult: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_stringResult"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_stringValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_struct"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_structValue"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subDecoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_subDecoder"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subscriptEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_subscript"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_subVisitor"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Swift: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Swift"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.swiftPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_swiftPrefix"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SwiftProtobufEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_SwiftProtobuf"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.syntax: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_syntax"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.T: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_T"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tag: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_tag"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.terminator: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_terminator"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.testDecoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_testDecoder"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.text: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_text"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textDecoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_textDecoder"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_TextFormatDecoder"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingError: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_TextFormatDecodingError"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_TextFormatDecodingOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_TextFormatEncodingOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_TextFormatEncodingVisitor"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textFormatString: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_textFormatString"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.throwsEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_throws"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeInterval: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_timeInterval"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSince1970: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_timeIntervalSince1970"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_timeIntervalSinceReferenceDate"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Timestamp: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Timestamp"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.total: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_total"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalArrayDepth: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_totalArrayDepth"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalSize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_totalSize"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trailingComments: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_trailingComments"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.traverseEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_traverse"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trueEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_true"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tryEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_try"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.type: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_type"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typealiasEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_typealias"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TypeEnumEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_TypeEnum"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_typeName"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typePrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_typePrefix"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeStart: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_typeStart"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeUnknown: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_typeUnknown"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeURL: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_typeURL"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UInt32"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UInt32Value"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UInt64"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UInt64Value"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt8: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UInt8"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalarLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_unicodeScalarLiteral"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarLiteralType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UnicodeScalarLiteralType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalars: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_unicodeScalars"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarView: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UnicodeScalarView"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uninterpretedOption: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_uninterpretedOption"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.union: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_union"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uniqueStorage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_uniqueStorage"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknown: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_unknown"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknownFieldsEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_unknownFields"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnknownStorage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UnknownStorage"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unpackTo: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_unpackTo"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeBufferPointer: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UnsafeBufferPointer"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutablePointer: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UnsafeMutablePointer"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawBufferPointer: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UnsafeMutableRawBufferPointer"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawPointer: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UnsafeMutableRawPointer"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawBufferPointer: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UnsafeRawBufferPointer"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawPointer: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UnsafeRawPointer"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.updatedOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_updatedOptions"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.url: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_url"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_utf8"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8Ptr: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_utf8Ptr"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8ToDouble: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_utf8ToDouble"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UTF8View: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UTF8View"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.v: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_v"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_value"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.valueField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_valueField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.values: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_values"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ValueType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ValueType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.varEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_var"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Version: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Version"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.versionString: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_versionString"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFields: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitExtensionFields"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFieldsAsMessageSet: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitExtensionFieldsAsMessageSet"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitMapField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitMapField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitor"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPacked: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPacked"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedBoolField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedBoolField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedDoubleField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedDoubleField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedEnumField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedEnumField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedFixed32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedFixed64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFloatField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedFloatField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedInt32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedInt64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedSFixed32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedSFixed64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedSInt32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedSInt64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedUInt32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedUInt64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeated: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeated"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBoolField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedBoolField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBytesField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedBytesField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedDoubleField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedDoubleField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedEnumField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedEnumField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedFixed32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedFixed64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFloatField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedFloatField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedGroupField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedGroupField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedInt32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedInt64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedMessageField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedMessageField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedSFixed32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedSFixed64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedSInt32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedSInt64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedStringField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedStringField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedUInt32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedUInt64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingular: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingular"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBoolField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularBoolField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBytesField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularBytesField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularDoubleField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularDoubleField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularEnumField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularEnumField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularFixed32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularFixed64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFloatField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularFloatField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularGroupField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularGroupField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularInt32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularInt64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularMessageField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularMessageField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularSFixed32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularSFixed64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularSInt32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularSInt64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularStringField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularStringField"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularUInt32Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularUInt64Field"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitUnknown: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitUnknown"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wasDecoded: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_wasDecoded"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.weak: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_weak"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.weakDependency: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_weakDependency"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.whereEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_where"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wireFormat: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_wireFormat"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.with: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_with"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeBytes: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_withUnsafeBytes"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeMutableBytes: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_withUnsafeMutableBytes"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.work: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_work"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.WrappedType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_WrappedType"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.written: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_written"), - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.yday: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_yday"), - ] -} diff --git a/Reference/google/protobuf/map_proto2_unittest.pb.swift b/Reference/google/protobuf/map_proto2_unittest.pb.swift deleted file mode 100644 index 5d0aa252e..000000000 --- a/Reference/google/protobuf/map_proto2_unittest.pb.swift +++ /dev/null @@ -1,543 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/map_proto2_unittest.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -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 ProtobufUnittest_Proto2MapEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 0 - case bar // = 1 - case baz // = 2 - - init() { - self = .foo - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .foo - case 1: self = .bar - case 2: self = .baz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo: return 0 - case .bar: return 1 - case .baz: return 2 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_Proto2MapEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -enum ProtobufUnittest_Proto2MapEnumPlusExtra: SwiftProtobuf.Enum { - typealias RawValue = Int - case eProto2MapEnumFoo // = 0 - case eProto2MapEnumBar // = 1 - case eProto2MapEnumBaz // = 2 - case eProto2MapEnumExtra // = 3 - - init() { - self = .eProto2MapEnumFoo - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .eProto2MapEnumFoo - case 1: self = .eProto2MapEnumBar - case 2: self = .eProto2MapEnumBaz - case 3: self = .eProto2MapEnumExtra - default: return nil - } - } - - var rawValue: Int { - switch self { - case .eProto2MapEnumFoo: return 0 - case .eProto2MapEnumBar: return 1 - case .eProto2MapEnumBaz: return 2 - case .eProto2MapEnumExtra: return 3 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_Proto2MapEnumPlusExtra: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_TestEnumMap { - // 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 knownMapField: Dictionary = [:] - - var unknownMapField: Dictionary = [:] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -struct ProtobufUnittest_TestEnumMapPlusExtra { - // 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 knownMapField: Dictionary = [:] - - var unknownMapField: Dictionary = [:] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -struct ProtobufUnittest_TestImportEnumMap { - // 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 importEnumAmp: Dictionary = [:] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -struct ProtobufUnittest_TestIntIntMap { - // 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 m: Dictionary = [:] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -/// Test all key types: string, plus the non-floating-point scalars. -struct ProtobufUnittest_TestMaps { - // 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 mInt32: Dictionary = [:] - - var mInt64: Dictionary = [:] - - var mUint32: Dictionary = [:] - - var mUint64: Dictionary = [:] - - var mSint32: Dictionary = [:] - - var mSint64: Dictionary = [:] - - var mFixed32: Dictionary = [:] - - var mFixed64: Dictionary = [:] - - var mSfixed32: Dictionary = [:] - - var mSfixed64: Dictionary = [:] - - var mBool: Dictionary = [:] - - var mString: Dictionary = [:] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -/// Test maps in submessages. -struct ProtobufUnittest_TestSubmessageMaps { - // 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 m: ProtobufUnittest_TestMaps { - get {return _m ?? ProtobufUnittest_TestMaps()} - set {_m = newValue} - } - /// Returns true if `m` has been explicitly set. - var hasM: Bool {return self._m != nil} - /// Clears the value of `m`. Subsequent reads from it will return its default value. - mutating func clearM() {self._m = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _m: ProtobufUnittest_TestMaps? = nil -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_Proto2MapEnum: @unchecked Sendable {} -extension ProtobufUnittest_Proto2MapEnumPlusExtra: @unchecked Sendable {} -extension ProtobufUnittest_TestEnumMap: @unchecked Sendable {} -extension ProtobufUnittest_TestEnumMapPlusExtra: @unchecked Sendable {} -extension ProtobufUnittest_TestImportEnumMap: @unchecked Sendable {} -extension ProtobufUnittest_TestIntIntMap: @unchecked Sendable {} -extension ProtobufUnittest_TestMaps: @unchecked Sendable {} -extension ProtobufUnittest_TestSubmessageMaps: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest" - -extension ProtobufUnittest_Proto2MapEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "PROTO2_MAP_ENUM_FOO"), - 1: .same(proto: "PROTO2_MAP_ENUM_BAR"), - 2: .same(proto: "PROTO2_MAP_ENUM_BAZ"), - ] -} - -extension ProtobufUnittest_Proto2MapEnumPlusExtra: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "E_PROTO2_MAP_ENUM_FOO"), - 1: .same(proto: "E_PROTO2_MAP_ENUM_BAR"), - 2: .same(proto: "E_PROTO2_MAP_ENUM_BAZ"), - 3: .same(proto: "E_PROTO2_MAP_ENUM_EXTRA"), - ] -} - -extension ProtobufUnittest_TestEnumMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestEnumMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 101: .standard(proto: "known_map_field"), - 102: .standard(proto: "unknown_map_field"), - ] - - 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 101: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.knownMapField) }() - case 102: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapField) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.knownMapField.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.knownMapField, fieldNumber: 101) - } - if !self.unknownMapField.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapField, fieldNumber: 102) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestEnumMap, rhs: ProtobufUnittest_TestEnumMap) -> Bool { - if lhs.knownMapField != rhs.knownMapField {return false} - if lhs.unknownMapField != rhs.unknownMapField {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestEnumMapPlusExtra: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestEnumMapPlusExtra" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 101: .standard(proto: "known_map_field"), - 102: .standard(proto: "unknown_map_field"), - ] - - 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 101: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.knownMapField) }() - case 102: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapField) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.knownMapField.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.knownMapField, fieldNumber: 101) - } - if !self.unknownMapField.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapField, fieldNumber: 102) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestEnumMapPlusExtra, rhs: ProtobufUnittest_TestEnumMapPlusExtra) -> Bool { - if lhs.knownMapField != rhs.knownMapField {return false} - if lhs.unknownMapField != rhs.unknownMapField {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestImportEnumMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestImportEnumMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "import_enum_amp"), - ] - - 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.importEnumAmp) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.importEnumAmp.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.importEnumAmp, fieldNumber: 1) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestImportEnumMap, rhs: ProtobufUnittest_TestImportEnumMap) -> Bool { - if lhs.importEnumAmp != rhs.importEnumAmp {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestIntIntMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestIntIntMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "m"), - ] - - 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.m) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.m.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.m, fieldNumber: 1) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestIntIntMap, rhs: ProtobufUnittest_TestIntIntMap) -> Bool { - if lhs.m != rhs.m {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestMaps: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMaps" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "m_int32"), - 2: .standard(proto: "m_int64"), - 3: .standard(proto: "m_uint32"), - 4: .standard(proto: "m_uint64"), - 5: .standard(proto: "m_sint32"), - 6: .standard(proto: "m_sint64"), - 7: .standard(proto: "m_fixed32"), - 8: .standard(proto: "m_fixed64"), - 9: .standard(proto: "m_sfixed32"), - 10: .standard(proto: "m_sfixed64"), - 11: .standard(proto: "m_bool"), - 12: .standard(proto: "m_string"), - ] - - 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mInt32) }() - case 2: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mInt64) }() - case 3: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mUint32) }() - case 4: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mUint64) }() - case 5: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mSint32) }() - case 6: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mSint64) }() - case 7: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mFixed32) }() - case 8: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mFixed64) }() - case 9: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mSfixed32) }() - case 10: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mSfixed64) }() - case 11: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mBool) }() - case 12: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mString) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.mInt32.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mInt32, fieldNumber: 1) - } - if !self.mInt64.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mInt64, fieldNumber: 2) - } - if !self.mUint32.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mUint32, fieldNumber: 3) - } - if !self.mUint64.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mUint64, fieldNumber: 4) - } - if !self.mSint32.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mSint32, fieldNumber: 5) - } - if !self.mSint64.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mSint64, fieldNumber: 6) - } - if !self.mFixed32.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mFixed32, fieldNumber: 7) - } - if !self.mFixed64.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mFixed64, fieldNumber: 8) - } - if !self.mSfixed32.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mSfixed32, fieldNumber: 9) - } - if !self.mSfixed64.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mSfixed64, fieldNumber: 10) - } - if !self.mBool.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mBool, fieldNumber: 11) - } - if !self.mString.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mString, fieldNumber: 12) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMaps, rhs: ProtobufUnittest_TestMaps) -> Bool { - if lhs.mInt32 != rhs.mInt32 {return false} - if lhs.mInt64 != rhs.mInt64 {return false} - if lhs.mUint32 != rhs.mUint32 {return false} - if lhs.mUint64 != rhs.mUint64 {return false} - if lhs.mSint32 != rhs.mSint32 {return false} - if lhs.mSint64 != rhs.mSint64 {return false} - if lhs.mFixed32 != rhs.mFixed32 {return false} - if lhs.mFixed64 != rhs.mFixed64 {return false} - if lhs.mSfixed32 != rhs.mSfixed32 {return false} - if lhs.mSfixed64 != rhs.mSfixed64 {return false} - if lhs.mBool != rhs.mBool {return false} - if lhs.mString != rhs.mString {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestSubmessageMaps: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestSubmessageMaps" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "m"), - ] - - 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.decodeSingularMessageField(value: &self._m) }() - 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 - try { if let v = self._m { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestSubmessageMaps, rhs: ProtobufUnittest_TestSubmessageMaps) -> Bool { - if lhs._m != rhs._m {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Reference/google/protobuf/unittest.pb.swift b/Reference/google/protobuf/unittest.pb.swift deleted file mode 100644 index f86c07c75..000000000 --- a/Reference/google/protobuf/unittest.pb.swift +++ /dev/null @@ -1,13514 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// A proto file we will use for unit testing. -// -// LINT: ALLOW_GROUPS, LEGACY_NAMES - -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 ProtobufUnittest_ForeignEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foreignFoo // = 4 - case foreignBar // = 5 - case foreignBaz // = 6 - - init() { - self = .foreignFoo - } - - init?(rawValue: Int) { - switch rawValue { - case 4: self = .foreignFoo - case 5: self = .foreignBar - case 6: self = .foreignBaz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foreignFoo: return 4 - case .foreignBar: return 5 - case .foreignBaz: return 6 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_ForeignEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// Test an enum that has multiple values with the same number. -enum ProtobufUnittest_TestEnumWithDupValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo1 // = 1 - case bar1 // = 2 - case baz // = 3 - static let foo2 = foo1 - static let bar2 = bar1 - - init() { - self = .foo1 - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .foo1 - case 2: self = .bar1 - case 3: self = .baz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo1: return 1 - case .bar1: return 2 - case .baz: return 3 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_TestEnumWithDupValue: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// Test an enum with large, unordered values. -enum ProtobufUnittest_TestSparseEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case sparseA // = 123 - case sparseB // = 62374 - case sparseC // = 12589234 - case sparseD // = -15 - case sparseE // = -53452 - case sparseF // = 0 - case sparseG // = 2 - - init() { - self = .sparseA - } - - init?(rawValue: Int) { - switch rawValue { - case -53452: self = .sparseE - case -15: self = .sparseD - case 0: self = .sparseF - case 2: self = .sparseG - case 123: self = .sparseA - case 62374: self = .sparseB - case 12589234: self = .sparseC - default: return nil - } - } - - var rawValue: Int { - switch self { - case .sparseE: return -53452 - case .sparseD: return -15 - case .sparseF: return 0 - case .sparseG: return 2 - case .sparseA: return 123 - case .sparseB: return 62374 - case .sparseC: return 12589234 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_TestSparseEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -enum ProtobufUnittest_VeryLargeEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case enumLabelDefault // = 0 - case enumLabel1 // = 1 - case enumLabel2 // = 2 - case enumLabel3 // = 3 - case enumLabel4 // = 4 - case enumLabel5 // = 5 - case enumLabel6 // = 6 - case enumLabel7 // = 7 - case enumLabel8 // = 8 - case enumLabel9 // = 9 - case enumLabel10 // = 10 - case enumLabel11 // = 11 - case enumLabel12 // = 12 - case enumLabel13 // = 13 - case enumLabel14 // = 14 - case enumLabel15 // = 15 - case enumLabel16 // = 16 - case enumLabel17 // = 17 - case enumLabel18 // = 18 - case enumLabel19 // = 19 - case enumLabel20 // = 20 - case enumLabel21 // = 21 - case enumLabel22 // = 22 - case enumLabel23 // = 23 - case enumLabel24 // = 24 - case enumLabel25 // = 25 - case enumLabel26 // = 26 - case enumLabel27 // = 27 - case enumLabel28 // = 28 - case enumLabel29 // = 29 - case enumLabel30 // = 30 - case enumLabel31 // = 31 - case enumLabel32 // = 32 - case enumLabel33 // = 33 - case enumLabel34 // = 34 - case enumLabel35 // = 35 - case enumLabel36 // = 36 - case enumLabel37 // = 37 - case enumLabel38 // = 38 - case enumLabel39 // = 39 - case enumLabel40 // = 40 - case enumLabel41 // = 41 - case enumLabel42 // = 42 - case enumLabel43 // = 43 - case enumLabel44 // = 44 - case enumLabel45 // = 45 - case enumLabel46 // = 46 - case enumLabel47 // = 47 - case enumLabel48 // = 48 - case enumLabel49 // = 49 - case enumLabel50 // = 50 - case enumLabel51 // = 51 - case enumLabel52 // = 52 - case enumLabel53 // = 53 - case enumLabel54 // = 54 - case enumLabel55 // = 55 - case enumLabel56 // = 56 - case enumLabel57 // = 57 - case enumLabel58 // = 58 - case enumLabel59 // = 59 - case enumLabel60 // = 60 - case enumLabel61 // = 61 - case enumLabel62 // = 62 - case enumLabel63 // = 63 - case enumLabel64 // = 64 - case enumLabel65 // = 65 - case enumLabel66 // = 66 - case enumLabel67 // = 67 - case enumLabel68 // = 68 - case enumLabel69 // = 69 - case enumLabel70 // = 70 - case enumLabel71 // = 71 - case enumLabel72 // = 72 - case enumLabel73 // = 73 - case enumLabel74 // = 74 - case enumLabel75 // = 75 - case enumLabel76 // = 76 - case enumLabel77 // = 77 - case enumLabel78 // = 78 - case enumLabel79 // = 79 - case enumLabel80 // = 80 - case enumLabel81 // = 81 - case enumLabel82 // = 82 - case enumLabel83 // = 83 - case enumLabel84 // = 84 - case enumLabel85 // = 85 - case enumLabel86 // = 86 - case enumLabel87 // = 87 - case enumLabel88 // = 88 - case enumLabel89 // = 89 - case enumLabel90 // = 90 - case enumLabel91 // = 91 - case enumLabel92 // = 92 - case enumLabel93 // = 93 - case enumLabel94 // = 94 - case enumLabel95 // = 95 - case enumLabel96 // = 96 - case enumLabel97 // = 97 - case enumLabel98 // = 98 - case enumLabel99 // = 99 - case enumLabel100 // = 100 - - init() { - self = .enumLabelDefault - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .enumLabelDefault - case 1: self = .enumLabel1 - case 2: self = .enumLabel2 - case 3: self = .enumLabel3 - case 4: self = .enumLabel4 - case 5: self = .enumLabel5 - case 6: self = .enumLabel6 - case 7: self = .enumLabel7 - case 8: self = .enumLabel8 - case 9: self = .enumLabel9 - case 10: self = .enumLabel10 - case 11: self = .enumLabel11 - case 12: self = .enumLabel12 - case 13: self = .enumLabel13 - case 14: self = .enumLabel14 - case 15: self = .enumLabel15 - case 16: self = .enumLabel16 - case 17: self = .enumLabel17 - case 18: self = .enumLabel18 - case 19: self = .enumLabel19 - case 20: self = .enumLabel20 - case 21: self = .enumLabel21 - case 22: self = .enumLabel22 - case 23: self = .enumLabel23 - case 24: self = .enumLabel24 - case 25: self = .enumLabel25 - case 26: self = .enumLabel26 - case 27: self = .enumLabel27 - case 28: self = .enumLabel28 - case 29: self = .enumLabel29 - case 30: self = .enumLabel30 - case 31: self = .enumLabel31 - case 32: self = .enumLabel32 - case 33: self = .enumLabel33 - case 34: self = .enumLabel34 - case 35: self = .enumLabel35 - case 36: self = .enumLabel36 - case 37: self = .enumLabel37 - case 38: self = .enumLabel38 - case 39: self = .enumLabel39 - case 40: self = .enumLabel40 - case 41: self = .enumLabel41 - case 42: self = .enumLabel42 - case 43: self = .enumLabel43 - case 44: self = .enumLabel44 - case 45: self = .enumLabel45 - case 46: self = .enumLabel46 - case 47: self = .enumLabel47 - case 48: self = .enumLabel48 - case 49: self = .enumLabel49 - case 50: self = .enumLabel50 - case 51: self = .enumLabel51 - case 52: self = .enumLabel52 - case 53: self = .enumLabel53 - case 54: self = .enumLabel54 - case 55: self = .enumLabel55 - case 56: self = .enumLabel56 - case 57: self = .enumLabel57 - case 58: self = .enumLabel58 - case 59: self = .enumLabel59 - case 60: self = .enumLabel60 - case 61: self = .enumLabel61 - case 62: self = .enumLabel62 - case 63: self = .enumLabel63 - case 64: self = .enumLabel64 - case 65: self = .enumLabel65 - case 66: self = .enumLabel66 - case 67: self = .enumLabel67 - case 68: self = .enumLabel68 - case 69: self = .enumLabel69 - case 70: self = .enumLabel70 - case 71: self = .enumLabel71 - case 72: self = .enumLabel72 - case 73: self = .enumLabel73 - case 74: self = .enumLabel74 - case 75: self = .enumLabel75 - case 76: self = .enumLabel76 - case 77: self = .enumLabel77 - case 78: self = .enumLabel78 - case 79: self = .enumLabel79 - case 80: self = .enumLabel80 - case 81: self = .enumLabel81 - case 82: self = .enumLabel82 - case 83: self = .enumLabel83 - case 84: self = .enumLabel84 - case 85: self = .enumLabel85 - case 86: self = .enumLabel86 - case 87: self = .enumLabel87 - case 88: self = .enumLabel88 - case 89: self = .enumLabel89 - case 90: self = .enumLabel90 - case 91: self = .enumLabel91 - case 92: self = .enumLabel92 - case 93: self = .enumLabel93 - case 94: self = .enumLabel94 - case 95: self = .enumLabel95 - case 96: self = .enumLabel96 - case 97: self = .enumLabel97 - case 98: self = .enumLabel98 - case 99: self = .enumLabel99 - case 100: self = .enumLabel100 - default: return nil - } - } - - var rawValue: Int { - switch self { - case .enumLabelDefault: return 0 - case .enumLabel1: return 1 - case .enumLabel2: return 2 - case .enumLabel3: return 3 - case .enumLabel4: return 4 - case .enumLabel5: return 5 - case .enumLabel6: return 6 - case .enumLabel7: return 7 - case .enumLabel8: return 8 - case .enumLabel9: return 9 - case .enumLabel10: return 10 - case .enumLabel11: return 11 - case .enumLabel12: return 12 - case .enumLabel13: return 13 - case .enumLabel14: return 14 - case .enumLabel15: return 15 - case .enumLabel16: return 16 - case .enumLabel17: return 17 - case .enumLabel18: return 18 - case .enumLabel19: return 19 - case .enumLabel20: return 20 - case .enumLabel21: return 21 - case .enumLabel22: return 22 - case .enumLabel23: return 23 - case .enumLabel24: return 24 - case .enumLabel25: return 25 - case .enumLabel26: return 26 - case .enumLabel27: return 27 - case .enumLabel28: return 28 - case .enumLabel29: return 29 - case .enumLabel30: return 30 - case .enumLabel31: return 31 - case .enumLabel32: return 32 - case .enumLabel33: return 33 - case .enumLabel34: return 34 - case .enumLabel35: return 35 - case .enumLabel36: return 36 - case .enumLabel37: return 37 - case .enumLabel38: return 38 - case .enumLabel39: return 39 - case .enumLabel40: return 40 - case .enumLabel41: return 41 - case .enumLabel42: return 42 - case .enumLabel43: return 43 - case .enumLabel44: return 44 - case .enumLabel45: return 45 - case .enumLabel46: return 46 - case .enumLabel47: return 47 - case .enumLabel48: return 48 - case .enumLabel49: return 49 - case .enumLabel50: return 50 - case .enumLabel51: return 51 - case .enumLabel52: return 52 - case .enumLabel53: return 53 - case .enumLabel54: return 54 - case .enumLabel55: return 55 - case .enumLabel56: return 56 - case .enumLabel57: return 57 - case .enumLabel58: return 58 - case .enumLabel59: return 59 - case .enumLabel60: return 60 - case .enumLabel61: return 61 - case .enumLabel62: return 62 - case .enumLabel63: return 63 - case .enumLabel64: return 64 - case .enumLabel65: return 65 - case .enumLabel66: return 66 - case .enumLabel67: return 67 - case .enumLabel68: return 68 - case .enumLabel69: return 69 - case .enumLabel70: return 70 - case .enumLabel71: return 71 - case .enumLabel72: return 72 - case .enumLabel73: return 73 - case .enumLabel74: return 74 - case .enumLabel75: return 75 - case .enumLabel76: return 76 - case .enumLabel77: return 77 - case .enumLabel78: return 78 - case .enumLabel79: return 79 - case .enumLabel80: return 80 - case .enumLabel81: return 81 - case .enumLabel82: return 82 - case .enumLabel83: return 83 - case .enumLabel84: return 84 - case .enumLabel85: return 85 - case .enumLabel86: return 86 - case .enumLabel87: return 87 - case .enumLabel88: return 88 - case .enumLabel89: return 89 - case .enumLabel90: return 90 - case .enumLabel91: return 91 - case .enumLabel92: return 92 - case .enumLabel93: return 93 - case .enumLabel94: return 94 - case .enumLabel95: return 95 - case .enumLabel96: return 96 - case .enumLabel97: return 97 - case .enumLabel98: return 98 - case .enumLabel99: return 99 - case .enumLabel100: return 100 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_VeryLargeEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// This proto includes every type of field in both singular and repeated -/// forms. -struct ProtobufUnittest_TestAllTypes { - // 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. - - /// Singular - var optionalInt32: Int32 { - get {return _storage._optionalInt32 ?? 0} - set {_uniqueStorage()._optionalInt32 = newValue} - } - /// Returns true if `optionalInt32` has been explicitly set. - var hasOptionalInt32: Bool {return _storage._optionalInt32 != nil} - /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. - mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} - - var optionalInt64: Int64 { - get {return _storage._optionalInt64 ?? 0} - set {_uniqueStorage()._optionalInt64 = newValue} - } - /// Returns true if `optionalInt64` has been explicitly set. - var hasOptionalInt64: Bool {return _storage._optionalInt64 != nil} - /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. - mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} - - var optionalUint32: UInt32 { - get {return _storage._optionalUint32 ?? 0} - set {_uniqueStorage()._optionalUint32 = newValue} - } - /// Returns true if `optionalUint32` has been explicitly set. - var hasOptionalUint32: Bool {return _storage._optionalUint32 != nil} - /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. - mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} - - var optionalUint64: UInt64 { - get {return _storage._optionalUint64 ?? 0} - set {_uniqueStorage()._optionalUint64 = newValue} - } - /// Returns true if `optionalUint64` has been explicitly set. - var hasOptionalUint64: Bool {return _storage._optionalUint64 != nil} - /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. - mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} - - var optionalSint32: Int32 { - get {return _storage._optionalSint32 ?? 0} - set {_uniqueStorage()._optionalSint32 = newValue} - } - /// Returns true if `optionalSint32` has been explicitly set. - var hasOptionalSint32: Bool {return _storage._optionalSint32 != nil} - /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. - mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} - - var optionalSint64: Int64 { - get {return _storage._optionalSint64 ?? 0} - set {_uniqueStorage()._optionalSint64 = newValue} - } - /// Returns true if `optionalSint64` has been explicitly set. - var hasOptionalSint64: Bool {return _storage._optionalSint64 != nil} - /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. - mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} - - var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32 ?? 0} - set {_uniqueStorage()._optionalFixed32 = newValue} - } - /// Returns true if `optionalFixed32` has been explicitly set. - var hasOptionalFixed32: Bool {return _storage._optionalFixed32 != nil} - /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. - mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} - - var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64 ?? 0} - set {_uniqueStorage()._optionalFixed64 = newValue} - } - /// Returns true if `optionalFixed64` has been explicitly set. - var hasOptionalFixed64: Bool {return _storage._optionalFixed64 != nil} - /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. - mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} - - var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32 ?? 0} - set {_uniqueStorage()._optionalSfixed32 = newValue} - } - /// Returns true if `optionalSfixed32` has been explicitly set. - var hasOptionalSfixed32: Bool {return _storage._optionalSfixed32 != nil} - /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. - mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} - - var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64 ?? 0} - set {_uniqueStorage()._optionalSfixed64 = newValue} - } - /// Returns true if `optionalSfixed64` has been explicitly set. - var hasOptionalSfixed64: Bool {return _storage._optionalSfixed64 != nil} - /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. - mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} - - var optionalFloat: Float { - get {return _storage._optionalFloat ?? 0} - set {_uniqueStorage()._optionalFloat = newValue} - } - /// Returns true if `optionalFloat` has been explicitly set. - var hasOptionalFloat: Bool {return _storage._optionalFloat != nil} - /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. - mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} - - var optionalDouble: Double { - get {return _storage._optionalDouble ?? 0} - set {_uniqueStorage()._optionalDouble = newValue} - } - /// Returns true if `optionalDouble` has been explicitly set. - var hasOptionalDouble: Bool {return _storage._optionalDouble != nil} - /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. - mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} - - var optionalBool: Bool { - get {return _storage._optionalBool ?? false} - set {_uniqueStorage()._optionalBool = newValue} - } - /// Returns true if `optionalBool` has been explicitly set. - var hasOptionalBool: Bool {return _storage._optionalBool != nil} - /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. - mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} - - var optionalString: String { - get {return _storage._optionalString ?? String()} - set {_uniqueStorage()._optionalString = newValue} - } - /// Returns true if `optionalString` has been explicitly set. - var hasOptionalString: Bool {return _storage._optionalString != nil} - /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. - mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} - - var optionalBytes: Data { - get {return _storage._optionalBytes ?? Data()} - set {_uniqueStorage()._optionalBytes = newValue} - } - /// Returns true if `optionalBytes` has been explicitly set. - var hasOptionalBytes: Bool {return _storage._optionalBytes != nil} - /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. - mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} - - var optionalGroup: ProtobufUnittest_TestAllTypes.OptionalGroup { - get {return _storage._optionalGroup ?? ProtobufUnittest_TestAllTypes.OptionalGroup()} - set {_uniqueStorage()._optionalGroup = newValue} - } - /// Returns true if `optionalGroup` has been explicitly set. - var hasOptionalGroup: Bool {return _storage._optionalGroup != nil} - /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. - mutating func clearOptionalGroup() {_uniqueStorage()._optionalGroup = nil} - - var optionalNestedMessage: ProtobufUnittest_TestAllTypes.NestedMessage { - get {return _storage._optionalNestedMessage ?? ProtobufUnittest_TestAllTypes.NestedMessage()} - set {_uniqueStorage()._optionalNestedMessage = newValue} - } - /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} - /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} - - var optionalForeignMessage: ProtobufUnittest_ForeignMessage { - get {return _storage._optionalForeignMessage ?? ProtobufUnittest_ForeignMessage()} - set {_uniqueStorage()._optionalForeignMessage = newValue} - } - /// Returns true if `optionalForeignMessage` has been explicitly set. - var hasOptionalForeignMessage: Bool {return _storage._optionalForeignMessage != nil} - /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} - - var optionalImportMessage: ProtobufUnittestImport_ImportMessage { - get {return _storage._optionalImportMessage ?? ProtobufUnittestImport_ImportMessage()} - set {_uniqueStorage()._optionalImportMessage = newValue} - } - /// Returns true if `optionalImportMessage` has been explicitly set. - var hasOptionalImportMessage: Bool {return _storage._optionalImportMessage != nil} - /// Clears the value of `optionalImportMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalImportMessage() {_uniqueStorage()._optionalImportMessage = nil} - - var optionalNestedEnum: ProtobufUnittest_TestAllTypes.NestedEnum { - get {return _storage._optionalNestedEnum ?? .foo} - set {_uniqueStorage()._optionalNestedEnum = newValue} - } - /// Returns true if `optionalNestedEnum` has been explicitly set. - var hasOptionalNestedEnum: Bool {return _storage._optionalNestedEnum != nil} - /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. - mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} - - var optionalForeignEnum: ProtobufUnittest_ForeignEnum { - get {return _storage._optionalForeignEnum ?? .foreignFoo} - set {_uniqueStorage()._optionalForeignEnum = newValue} - } - /// Returns true if `optionalForeignEnum` has been explicitly set. - var hasOptionalForeignEnum: Bool {return _storage._optionalForeignEnum != nil} - /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. - mutating func clearOptionalForeignEnum() {_uniqueStorage()._optionalForeignEnum = nil} - - var optionalImportEnum: ProtobufUnittestImport_ImportEnum { - get {return _storage._optionalImportEnum ?? .importFoo} - set {_uniqueStorage()._optionalImportEnum = newValue} - } - /// Returns true if `optionalImportEnum` has been explicitly set. - var hasOptionalImportEnum: Bool {return _storage._optionalImportEnum != nil} - /// Clears the value of `optionalImportEnum`. Subsequent reads from it will return its default value. - mutating func clearOptionalImportEnum() {_uniqueStorage()._optionalImportEnum = nil} - - var optionalStringPiece: String { - get {return _storage._optionalStringPiece ?? String()} - set {_uniqueStorage()._optionalStringPiece = newValue} - } - /// Returns true if `optionalStringPiece` has been explicitly set. - var hasOptionalStringPiece: Bool {return _storage._optionalStringPiece != nil} - /// Clears the value of `optionalStringPiece`. Subsequent reads from it will return its default value. - mutating func clearOptionalStringPiece() {_uniqueStorage()._optionalStringPiece = nil} - - var optionalCord: String { - get {return _storage._optionalCord ?? String()} - set {_uniqueStorage()._optionalCord = newValue} - } - /// Returns true if `optionalCord` has been explicitly set. - var hasOptionalCord: Bool {return _storage._optionalCord != nil} - /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. - mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} - - /// Defined in unittest_import_public.proto - var optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessage { - get {return _storage._optionalPublicImportMessage ?? ProtobufUnittestImport_PublicImportMessage()} - set {_uniqueStorage()._optionalPublicImportMessage = newValue} - } - /// Returns true if `optionalPublicImportMessage` has been explicitly set. - var hasOptionalPublicImportMessage: Bool {return _storage._optionalPublicImportMessage != nil} - /// Clears the value of `optionalPublicImportMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalPublicImportMessage() {_uniqueStorage()._optionalPublicImportMessage = nil} - - var optionalLazyMessage: ProtobufUnittest_TestAllTypes.NestedMessage { - get {return _storage._optionalLazyMessage ?? ProtobufUnittest_TestAllTypes.NestedMessage()} - set {_uniqueStorage()._optionalLazyMessage = newValue} - } - /// Returns true if `optionalLazyMessage` has been explicitly set. - var hasOptionalLazyMessage: Bool {return _storage._optionalLazyMessage != nil} - /// Clears the value of `optionalLazyMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalLazyMessage() {_uniqueStorage()._optionalLazyMessage = nil} - - /// Repeated - var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} - set {_uniqueStorage()._repeatedInt32 = newValue} - } - - var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} - set {_uniqueStorage()._repeatedInt64 = newValue} - } - - var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} - set {_uniqueStorage()._repeatedUint32 = newValue} - } - - var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} - set {_uniqueStorage()._repeatedUint64 = newValue} - } - - var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} - set {_uniqueStorage()._repeatedSint32 = newValue} - } - - var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} - set {_uniqueStorage()._repeatedSint64 = newValue} - } - - var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} - set {_uniqueStorage()._repeatedFixed32 = newValue} - } - - var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} - set {_uniqueStorage()._repeatedFixed64 = newValue} - } - - var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} - set {_uniqueStorage()._repeatedSfixed32 = newValue} - } - - var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} - set {_uniqueStorage()._repeatedSfixed64 = newValue} - } - - var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} - set {_uniqueStorage()._repeatedFloat = newValue} - } - - var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} - set {_uniqueStorage()._repeatedDouble = newValue} - } - - var repeatedBool: [Bool] { - get {return _storage._repeatedBool} - set {_uniqueStorage()._repeatedBool = newValue} - } - - var repeatedString: [String] { - get {return _storage._repeatedString} - set {_uniqueStorage()._repeatedString = newValue} - } - - var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} - set {_uniqueStorage()._repeatedBytes = newValue} - } - - var repeatedGroup: [ProtobufUnittest_TestAllTypes.RepeatedGroup] { - get {return _storage._repeatedGroup} - set {_uniqueStorage()._repeatedGroup = newValue} - } - - var repeatedNestedMessage: [ProtobufUnittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedNestedMessage} - set {_uniqueStorage()._repeatedNestedMessage = newValue} - } - - var repeatedForeignMessage: [ProtobufUnittest_ForeignMessage] { - get {return _storage._repeatedForeignMessage} - set {_uniqueStorage()._repeatedForeignMessage = newValue} - } - - var repeatedImportMessage: [ProtobufUnittestImport_ImportMessage] { - get {return _storage._repeatedImportMessage} - set {_uniqueStorage()._repeatedImportMessage = newValue} - } - - var repeatedNestedEnum: [ProtobufUnittest_TestAllTypes.NestedEnum] { - get {return _storage._repeatedNestedEnum} - set {_uniqueStorage()._repeatedNestedEnum = newValue} - } - - var repeatedForeignEnum: [ProtobufUnittest_ForeignEnum] { - get {return _storage._repeatedForeignEnum} - set {_uniqueStorage()._repeatedForeignEnum = newValue} - } - - var repeatedImportEnum: [ProtobufUnittestImport_ImportEnum] { - get {return _storage._repeatedImportEnum} - set {_uniqueStorage()._repeatedImportEnum = newValue} - } - - var repeatedStringPiece: [String] { - get {return _storage._repeatedStringPiece} - set {_uniqueStorage()._repeatedStringPiece = newValue} - } - - var repeatedCord: [String] { - get {return _storage._repeatedCord} - set {_uniqueStorage()._repeatedCord = newValue} - } - - var repeatedLazyMessage: [ProtobufUnittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedLazyMessage} - set {_uniqueStorage()._repeatedLazyMessage = newValue} - } - - /// Singular with defaults - var defaultInt32: Int32 { - get {return _storage._defaultInt32 ?? 41} - set {_uniqueStorage()._defaultInt32 = newValue} - } - /// Returns true if `defaultInt32` has been explicitly set. - var hasDefaultInt32: Bool {return _storage._defaultInt32 != nil} - /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. - mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} - - var defaultInt64: Int64 { - get {return _storage._defaultInt64 ?? 42} - set {_uniqueStorage()._defaultInt64 = newValue} - } - /// Returns true if `defaultInt64` has been explicitly set. - var hasDefaultInt64: Bool {return _storage._defaultInt64 != nil} - /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. - mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} - - var defaultUint32: UInt32 { - get {return _storage._defaultUint32 ?? 43} - set {_uniqueStorage()._defaultUint32 = newValue} - } - /// Returns true if `defaultUint32` has been explicitly set. - var hasDefaultUint32: Bool {return _storage._defaultUint32 != nil} - /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. - mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} - - var defaultUint64: UInt64 { - get {return _storage._defaultUint64 ?? 44} - set {_uniqueStorage()._defaultUint64 = newValue} - } - /// Returns true if `defaultUint64` has been explicitly set. - var hasDefaultUint64: Bool {return _storage._defaultUint64 != nil} - /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. - mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} - - var defaultSint32: Int32 { - get {return _storage._defaultSint32 ?? -45} - set {_uniqueStorage()._defaultSint32 = newValue} - } - /// Returns true if `defaultSint32` has been explicitly set. - var hasDefaultSint32: Bool {return _storage._defaultSint32 != nil} - /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. - mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} - - var defaultSint64: Int64 { - get {return _storage._defaultSint64 ?? 46} - set {_uniqueStorage()._defaultSint64 = newValue} - } - /// Returns true if `defaultSint64` has been explicitly set. - var hasDefaultSint64: Bool {return _storage._defaultSint64 != nil} - /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. - mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} - - var defaultFixed32: UInt32 { - get {return _storage._defaultFixed32 ?? 47} - set {_uniqueStorage()._defaultFixed32 = newValue} - } - /// Returns true if `defaultFixed32` has been explicitly set. - var hasDefaultFixed32: Bool {return _storage._defaultFixed32 != nil} - /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. - mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} - - var defaultFixed64: UInt64 { - get {return _storage._defaultFixed64 ?? 48} - set {_uniqueStorage()._defaultFixed64 = newValue} - } - /// Returns true if `defaultFixed64` has been explicitly set. - var hasDefaultFixed64: Bool {return _storage._defaultFixed64 != nil} - /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. - mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} - - var defaultSfixed32: Int32 { - get {return _storage._defaultSfixed32 ?? 49} - set {_uniqueStorage()._defaultSfixed32 = newValue} - } - /// Returns true if `defaultSfixed32` has been explicitly set. - var hasDefaultSfixed32: Bool {return _storage._defaultSfixed32 != nil} - /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. - mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} - - var defaultSfixed64: Int64 { - get {return _storage._defaultSfixed64 ?? -50} - set {_uniqueStorage()._defaultSfixed64 = newValue} - } - /// Returns true if `defaultSfixed64` has been explicitly set. - var hasDefaultSfixed64: Bool {return _storage._defaultSfixed64 != nil} - /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. - mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} - - var defaultFloat: Float { - get {return _storage._defaultFloat ?? 51.5} - set {_uniqueStorage()._defaultFloat = newValue} - } - /// Returns true if `defaultFloat` has been explicitly set. - var hasDefaultFloat: Bool {return _storage._defaultFloat != nil} - /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. - mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} - - var defaultDouble: Double { - get {return _storage._defaultDouble ?? 52000} - set {_uniqueStorage()._defaultDouble = newValue} - } - /// Returns true if `defaultDouble` has been explicitly set. - var hasDefaultDouble: Bool {return _storage._defaultDouble != nil} - /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. - mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} - - var defaultBool: Bool { - get {return _storage._defaultBool ?? true} - set {_uniqueStorage()._defaultBool = newValue} - } - /// Returns true if `defaultBool` has been explicitly set. - var hasDefaultBool: Bool {return _storage._defaultBool != nil} - /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. - mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} - - var defaultString: String { - get {return _storage._defaultString ?? "hello"} - set {_uniqueStorage()._defaultString = newValue} - } - /// Returns true if `defaultString` has been explicitly set. - var hasDefaultString: Bool {return _storage._defaultString != nil} - /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. - mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} - - var defaultBytes: Data { - get {return _storage._defaultBytes ?? Data([119, 111, 114, 108, 100])} - set {_uniqueStorage()._defaultBytes = newValue} - } - /// Returns true if `defaultBytes` has been explicitly set. - var hasDefaultBytes: Bool {return _storage._defaultBytes != nil} - /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. - mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} - - var defaultNestedEnum: ProtobufUnittest_TestAllTypes.NestedEnum { - get {return _storage._defaultNestedEnum ?? .bar} - set {_uniqueStorage()._defaultNestedEnum = newValue} - } - /// Returns true if `defaultNestedEnum` has been explicitly set. - var hasDefaultNestedEnum: Bool {return _storage._defaultNestedEnum != nil} - /// Clears the value of `defaultNestedEnum`. Subsequent reads from it will return its default value. - mutating func clearDefaultNestedEnum() {_uniqueStorage()._defaultNestedEnum = nil} - - var defaultForeignEnum: ProtobufUnittest_ForeignEnum { - get {return _storage._defaultForeignEnum ?? .foreignBar} - set {_uniqueStorage()._defaultForeignEnum = newValue} - } - /// Returns true if `defaultForeignEnum` has been explicitly set. - var hasDefaultForeignEnum: Bool {return _storage._defaultForeignEnum != nil} - /// Clears the value of `defaultForeignEnum`. Subsequent reads from it will return its default value. - mutating func clearDefaultForeignEnum() {_uniqueStorage()._defaultForeignEnum = nil} - - var defaultImportEnum: ProtobufUnittestImport_ImportEnum { - get {return _storage._defaultImportEnum ?? .importBar} - set {_uniqueStorage()._defaultImportEnum = newValue} - } - /// Returns true if `defaultImportEnum` has been explicitly set. - var hasDefaultImportEnum: Bool {return _storage._defaultImportEnum != nil} - /// Clears the value of `defaultImportEnum`. Subsequent reads from it will return its default value. - mutating func clearDefaultImportEnum() {_uniqueStorage()._defaultImportEnum = nil} - - var defaultStringPiece: String { - get {return _storage._defaultStringPiece ?? "abc"} - set {_uniqueStorage()._defaultStringPiece = newValue} - } - /// Returns true if `defaultStringPiece` has been explicitly set. - var hasDefaultStringPiece: Bool {return _storage._defaultStringPiece != nil} - /// Clears the value of `defaultStringPiece`. Subsequent reads from it will return its default value. - mutating func clearDefaultStringPiece() {_uniqueStorage()._defaultStringPiece = nil} - - var defaultCord: String { - get {return _storage._defaultCord ?? "123"} - set {_uniqueStorage()._defaultCord = newValue} - } - /// Returns true if `defaultCord` has been explicitly set. - var hasDefaultCord: Bool {return _storage._defaultCord != nil} - /// Clears the value of `defaultCord`. Subsequent reads from it will return its default value. - mutating func clearDefaultCord() {_uniqueStorage()._defaultCord = nil} - - /// For oneof test - var oneofField: OneOf_OneofField? { - get {return _storage._oneofField} - set {_uniqueStorage()._oneofField = newValue} - } - - var oneofUint32: UInt32 { - get { - if case .oneofUint32(let v)? = _storage._oneofField {return v} - return 0 - } - set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} - } - - var oneofNestedMessage: ProtobufUnittest_TestAllTypes.NestedMessage { - get { - if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} - return ProtobufUnittest_TestAllTypes.NestedMessage() - } - set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} - } - - var oneofString: String { - get { - if case .oneofString(let v)? = _storage._oneofField {return v} - return String() - } - set {_uniqueStorage()._oneofField = .oneofString(newValue)} - } - - var oneofBytes: Data { - get { - if case .oneofBytes(let v)? = _storage._oneofField {return v} - return Data() - } - set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - /// For oneof test - enum OneOf_OneofField: Equatable { - case oneofUint32(UInt32) - case oneofNestedMessage(ProtobufUnittest_TestAllTypes.NestedMessage) - case oneofString(String) - case oneofBytes(Data) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestAllTypes.OneOf_OneofField, rhs: ProtobufUnittest_TestAllTypes.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif - } - - enum NestedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 1 - case bar // = 2 - case baz // = 3 - - /// Intentionally negative. - case neg // = -1 - - init() { - self = .foo - } - - init?(rawValue: Int) { - switch rawValue { - case -1: self = .neg - case 1: self = .foo - case 2: self = .bar - case 3: self = .baz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .neg: return -1 - case .foo: return 1 - case .bar: return 2 - case .baz: return 3 - } - } - - } - - struct NestedMessage { - // 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. - - /// The field name "b" fails to compile in proto1 because it conflicts with - /// a local variable named "b" in one of the generated methods. Doh. - /// This file needs to compile in proto1 to test backwards-compatibility. - var bb: Int32 { - get {return _bb ?? 0} - set {_bb = newValue} - } - /// Returns true if `bb` has been explicitly set. - var hasBb: Bool {return self._bb != nil} - /// Clears the value of `bb`. Subsequent reads from it will return its default value. - mutating func clearBb() {self._bb = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _bb: Int32? = nil - } - - struct OptionalGroup { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil - } - - struct RepeatedGroup { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil - } - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -#if swift(>=4.2) - -extension ProtobufUnittest_TestAllTypes.NestedEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// This proto includes a recursively nested message. -struct ProtobufUnittest_NestedTestAllTypes { - // 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 child: ProtobufUnittest_NestedTestAllTypes { - get {return _storage._child ?? ProtobufUnittest_NestedTestAllTypes()} - set {_uniqueStorage()._child = newValue} - } - /// Returns true if `child` has been explicitly set. - var hasChild: Bool {return _storage._child != nil} - /// Clears the value of `child`. Subsequent reads from it will return its default value. - mutating func clearChild() {_uniqueStorage()._child = nil} - - var payload: ProtobufUnittest_TestAllTypes { - get {return _storage._payload ?? ProtobufUnittest_TestAllTypes()} - set {_uniqueStorage()._payload = newValue} - } - /// Returns true if `payload` has been explicitly set. - var hasPayload: Bool {return _storage._payload != nil} - /// Clears the value of `payload`. Subsequent reads from it will return its default value. - mutating func clearPayload() {_uniqueStorage()._payload = nil} - - var repeatedChild: [ProtobufUnittest_NestedTestAllTypes] { - get {return _storage._repeatedChild} - set {_uniqueStorage()._repeatedChild = newValue} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -struct ProtobufUnittest_TestDeprecatedFields { - // 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 deprecatedInt32: Int32 { - get {return _deprecatedInt32 ?? 0} - set {_deprecatedInt32 = newValue} - } - /// Returns true if `deprecatedInt32` has been explicitly set. - var hasDeprecatedInt32: Bool {return self._deprecatedInt32 != nil} - /// Clears the value of `deprecatedInt32`. Subsequent reads from it will return its default value. - mutating func clearDeprecatedInt32() {self._deprecatedInt32 = nil} - - var oneofFields: ProtobufUnittest_TestDeprecatedFields.OneOf_OneofFields? = nil - - var deprecatedInt32InOneof: Int32 { - get { - if case .deprecatedInt32InOneof(let v)? = oneofFields {return v} - return 0 - } - set {oneofFields = .deprecatedInt32InOneof(newValue)} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum OneOf_OneofFields: Equatable { - case deprecatedInt32InOneof(Int32) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestDeprecatedFields.OneOf_OneofFields, rhs: ProtobufUnittest_TestDeprecatedFields.OneOf_OneofFields) -> 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 (.deprecatedInt32InOneof, .deprecatedInt32InOneof): return { - guard case .deprecatedInt32InOneof(let l) = lhs, case .deprecatedInt32InOneof(let r) = rhs else { preconditionFailure() } - return l == r - }() - } - } - #endif - } - - init() {} - - fileprivate var _deprecatedInt32: Int32? = nil -} - -struct ProtobufUnittest_TestDeprecatedMessage { - // 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() {} -} - -/// Define these after TestAllTypes to make sure the compiler can handle -/// that. -struct ProtobufUnittest_ForeignMessage { - // 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 c: Int32 { - get {return _c ?? 0} - set {_c = newValue} - } - /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} - /// Clears the value of `c`. Subsequent reads from it will return its default value. - mutating func clearC() {self._c = nil} - - var d: Int32 { - get {return _d ?? 0} - set {_d = newValue} - } - /// Returns true if `d` has been explicitly set. - var hasD: Bool {return self._d != nil} - /// Clears the value of `d`. Subsequent reads from it will return its default value. - mutating func clearD() {self._d = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _c: Int32? = nil - fileprivate var _d: Int32? = nil -} - -struct ProtobufUnittest_TestReservedFields { - // 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 ProtobufUnittest_TestAllExtensions: 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() -} - -struct ProtobufUnittest_OptionalGroup_extension { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil -} - -struct ProtobufUnittest_RepeatedGroup_extension { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil -} - -struct ProtobufUnittest_TestGroup { - // 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 optionalGroup: ProtobufUnittest_TestGroup.OptionalGroup { - get {return _optionalGroup ?? ProtobufUnittest_TestGroup.OptionalGroup()} - set {_optionalGroup = newValue} - } - /// Returns true if `optionalGroup` has been explicitly set. - var hasOptionalGroup: Bool {return self._optionalGroup != nil} - /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. - mutating func clearOptionalGroup() {self._optionalGroup = nil} - - var optionalForeignEnum: ProtobufUnittest_ForeignEnum { - get {return _optionalForeignEnum ?? .foreignFoo} - set {_optionalForeignEnum = newValue} - } - /// Returns true if `optionalForeignEnum` has been explicitly set. - var hasOptionalForeignEnum: Bool {return self._optionalForeignEnum != nil} - /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. - mutating func clearOptionalForeignEnum() {self._optionalForeignEnum = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct OptionalGroup { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil - } - - init() {} - - fileprivate var _optionalGroup: ProtobufUnittest_TestGroup.OptionalGroup? = nil - fileprivate var _optionalForeignEnum: ProtobufUnittest_ForeignEnum? = nil -} - -struct ProtobufUnittest_TestGroupExtension: 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() -} - -struct ProtobufUnittest_TestNestedExtension { - // 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() - - struct OptionalGroup_extension { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil - } - - init() {} -} - -struct ProtobufUnittest_TestChildExtension { - // 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 a: String { - get {return _a ?? String()} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var b: String { - get {return _b ?? String()} - set {_b = newValue} - } - /// Returns true if `b` has been explicitly set. - var hasB: Bool {return self._b != nil} - /// Clears the value of `b`. Subsequent reads from it will return its default value. - mutating func clearB() {self._b = nil} - - var optionalExtension: ProtobufUnittest_TestAllExtensions { - get {return _optionalExtension ?? ProtobufUnittest_TestAllExtensions()} - set {_optionalExtension = newValue} - } - /// Returns true if `optionalExtension` has been explicitly set. - var hasOptionalExtension: Bool {return self._optionalExtension != nil} - /// Clears the value of `optionalExtension`. Subsequent reads from it will return its default value. - mutating func clearOptionalExtension() {self._optionalExtension = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: String? = nil - fileprivate var _b: String? = nil - fileprivate var _optionalExtension: ProtobufUnittest_TestAllExtensions? = nil -} - -/// We have separate messages for testing required fields because it's -/// annoying to have to fill in required fields in TestProto in order to -/// do anything with it. Note that we don't need to test every type of -/// required filed because the code output is basically identical to -/// optional fields for all types. -struct ProtobufUnittest_TestRequired { - // 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 a: Int32 { - get {return _storage._a ?? 0} - set {_uniqueStorage()._a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return _storage._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {_uniqueStorage()._a = nil} - - var dummy2: Int32 { - get {return _storage._dummy2 ?? 0} - set {_uniqueStorage()._dummy2 = newValue} - } - /// Returns true if `dummy2` has been explicitly set. - var hasDummy2: Bool {return _storage._dummy2 != nil} - /// Clears the value of `dummy2`. Subsequent reads from it will return its default value. - mutating func clearDummy2() {_uniqueStorage()._dummy2 = nil} - - var b: Int32 { - get {return _storage._b ?? 0} - set {_uniqueStorage()._b = newValue} - } - /// Returns true if `b` has been explicitly set. - var hasB: Bool {return _storage._b != nil} - /// Clears the value of `b`. Subsequent reads from it will return its default value. - mutating func clearB() {_uniqueStorage()._b = nil} - - /// Pad the field count to 32 so that we can test that IsInitialized() - /// properly checks multiple elements of has_bits_. - var dummy4: Int32 { - get {return _storage._dummy4 ?? 0} - set {_uniqueStorage()._dummy4 = newValue} - } - /// Returns true if `dummy4` has been explicitly set. - var hasDummy4: Bool {return _storage._dummy4 != nil} - /// Clears the value of `dummy4`. Subsequent reads from it will return its default value. - mutating func clearDummy4() {_uniqueStorage()._dummy4 = nil} - - var dummy5: Int32 { - get {return _storage._dummy5 ?? 0} - set {_uniqueStorage()._dummy5 = newValue} - } - /// Returns true if `dummy5` has been explicitly set. - var hasDummy5: Bool {return _storage._dummy5 != nil} - /// Clears the value of `dummy5`. Subsequent reads from it will return its default value. - mutating func clearDummy5() {_uniqueStorage()._dummy5 = nil} - - var dummy6: Int32 { - get {return _storage._dummy6 ?? 0} - set {_uniqueStorage()._dummy6 = newValue} - } - /// Returns true if `dummy6` has been explicitly set. - var hasDummy6: Bool {return _storage._dummy6 != nil} - /// Clears the value of `dummy6`. Subsequent reads from it will return its default value. - mutating func clearDummy6() {_uniqueStorage()._dummy6 = nil} - - var dummy7: Int32 { - get {return _storage._dummy7 ?? 0} - set {_uniqueStorage()._dummy7 = newValue} - } - /// Returns true if `dummy7` has been explicitly set. - var hasDummy7: Bool {return _storage._dummy7 != nil} - /// Clears the value of `dummy7`. Subsequent reads from it will return its default value. - mutating func clearDummy7() {_uniqueStorage()._dummy7 = nil} - - var dummy8: Int32 { - get {return _storage._dummy8 ?? 0} - set {_uniqueStorage()._dummy8 = newValue} - } - /// Returns true if `dummy8` has been explicitly set. - var hasDummy8: Bool {return _storage._dummy8 != nil} - /// Clears the value of `dummy8`. Subsequent reads from it will return its default value. - mutating func clearDummy8() {_uniqueStorage()._dummy8 = nil} - - var dummy9: Int32 { - get {return _storage._dummy9 ?? 0} - set {_uniqueStorage()._dummy9 = newValue} - } - /// Returns true if `dummy9` has been explicitly set. - var hasDummy9: Bool {return _storage._dummy9 != nil} - /// Clears the value of `dummy9`. Subsequent reads from it will return its default value. - mutating func clearDummy9() {_uniqueStorage()._dummy9 = nil} - - var dummy10: Int32 { - get {return _storage._dummy10 ?? 0} - set {_uniqueStorage()._dummy10 = newValue} - } - /// Returns true if `dummy10` has been explicitly set. - var hasDummy10: Bool {return _storage._dummy10 != nil} - /// Clears the value of `dummy10`. Subsequent reads from it will return its default value. - mutating func clearDummy10() {_uniqueStorage()._dummy10 = nil} - - var dummy11: Int32 { - get {return _storage._dummy11 ?? 0} - set {_uniqueStorage()._dummy11 = newValue} - } - /// Returns true if `dummy11` has been explicitly set. - var hasDummy11: Bool {return _storage._dummy11 != nil} - /// Clears the value of `dummy11`. Subsequent reads from it will return its default value. - mutating func clearDummy11() {_uniqueStorage()._dummy11 = nil} - - var dummy12: Int32 { - get {return _storage._dummy12 ?? 0} - set {_uniqueStorage()._dummy12 = newValue} - } - /// Returns true if `dummy12` has been explicitly set. - var hasDummy12: Bool {return _storage._dummy12 != nil} - /// Clears the value of `dummy12`. Subsequent reads from it will return its default value. - mutating func clearDummy12() {_uniqueStorage()._dummy12 = nil} - - var dummy13: Int32 { - get {return _storage._dummy13 ?? 0} - set {_uniqueStorage()._dummy13 = newValue} - } - /// Returns true if `dummy13` has been explicitly set. - var hasDummy13: Bool {return _storage._dummy13 != nil} - /// Clears the value of `dummy13`. Subsequent reads from it will return its default value. - mutating func clearDummy13() {_uniqueStorage()._dummy13 = nil} - - var dummy14: Int32 { - get {return _storage._dummy14 ?? 0} - set {_uniqueStorage()._dummy14 = newValue} - } - /// Returns true if `dummy14` has been explicitly set. - var hasDummy14: Bool {return _storage._dummy14 != nil} - /// Clears the value of `dummy14`. Subsequent reads from it will return its default value. - mutating func clearDummy14() {_uniqueStorage()._dummy14 = nil} - - var dummy15: Int32 { - get {return _storage._dummy15 ?? 0} - set {_uniqueStorage()._dummy15 = newValue} - } - /// Returns true if `dummy15` has been explicitly set. - var hasDummy15: Bool {return _storage._dummy15 != nil} - /// Clears the value of `dummy15`. Subsequent reads from it will return its default value. - mutating func clearDummy15() {_uniqueStorage()._dummy15 = nil} - - var dummy16: Int32 { - get {return _storage._dummy16 ?? 0} - set {_uniqueStorage()._dummy16 = newValue} - } - /// Returns true if `dummy16` has been explicitly set. - var hasDummy16: Bool {return _storage._dummy16 != nil} - /// Clears the value of `dummy16`. Subsequent reads from it will return its default value. - mutating func clearDummy16() {_uniqueStorage()._dummy16 = nil} - - var dummy17: Int32 { - get {return _storage._dummy17 ?? 0} - set {_uniqueStorage()._dummy17 = newValue} - } - /// Returns true if `dummy17` has been explicitly set. - var hasDummy17: Bool {return _storage._dummy17 != nil} - /// Clears the value of `dummy17`. Subsequent reads from it will return its default value. - mutating func clearDummy17() {_uniqueStorage()._dummy17 = nil} - - var dummy18: Int32 { - get {return _storage._dummy18 ?? 0} - set {_uniqueStorage()._dummy18 = newValue} - } - /// Returns true if `dummy18` has been explicitly set. - var hasDummy18: Bool {return _storage._dummy18 != nil} - /// Clears the value of `dummy18`. Subsequent reads from it will return its default value. - mutating func clearDummy18() {_uniqueStorage()._dummy18 = nil} - - var dummy19: Int32 { - get {return _storage._dummy19 ?? 0} - set {_uniqueStorage()._dummy19 = newValue} - } - /// Returns true if `dummy19` has been explicitly set. - var hasDummy19: Bool {return _storage._dummy19 != nil} - /// Clears the value of `dummy19`. Subsequent reads from it will return its default value. - mutating func clearDummy19() {_uniqueStorage()._dummy19 = nil} - - var dummy20: Int32 { - get {return _storage._dummy20 ?? 0} - set {_uniqueStorage()._dummy20 = newValue} - } - /// Returns true if `dummy20` has been explicitly set. - var hasDummy20: Bool {return _storage._dummy20 != nil} - /// Clears the value of `dummy20`. Subsequent reads from it will return its default value. - mutating func clearDummy20() {_uniqueStorage()._dummy20 = nil} - - var dummy21: Int32 { - get {return _storage._dummy21 ?? 0} - set {_uniqueStorage()._dummy21 = newValue} - } - /// Returns true if `dummy21` has been explicitly set. - var hasDummy21: Bool {return _storage._dummy21 != nil} - /// Clears the value of `dummy21`. Subsequent reads from it will return its default value. - mutating func clearDummy21() {_uniqueStorage()._dummy21 = nil} - - var dummy22: Int32 { - get {return _storage._dummy22 ?? 0} - set {_uniqueStorage()._dummy22 = newValue} - } - /// Returns true if `dummy22` has been explicitly set. - var hasDummy22: Bool {return _storage._dummy22 != nil} - /// Clears the value of `dummy22`. Subsequent reads from it will return its default value. - mutating func clearDummy22() {_uniqueStorage()._dummy22 = nil} - - var dummy23: Int32 { - get {return _storage._dummy23 ?? 0} - set {_uniqueStorage()._dummy23 = newValue} - } - /// Returns true if `dummy23` has been explicitly set. - var hasDummy23: Bool {return _storage._dummy23 != nil} - /// Clears the value of `dummy23`. Subsequent reads from it will return its default value. - mutating func clearDummy23() {_uniqueStorage()._dummy23 = nil} - - var dummy24: Int32 { - get {return _storage._dummy24 ?? 0} - set {_uniqueStorage()._dummy24 = newValue} - } - /// Returns true if `dummy24` has been explicitly set. - var hasDummy24: Bool {return _storage._dummy24 != nil} - /// Clears the value of `dummy24`. Subsequent reads from it will return its default value. - mutating func clearDummy24() {_uniqueStorage()._dummy24 = nil} - - var dummy25: Int32 { - get {return _storage._dummy25 ?? 0} - set {_uniqueStorage()._dummy25 = newValue} - } - /// Returns true if `dummy25` has been explicitly set. - var hasDummy25: Bool {return _storage._dummy25 != nil} - /// Clears the value of `dummy25`. Subsequent reads from it will return its default value. - mutating func clearDummy25() {_uniqueStorage()._dummy25 = nil} - - var dummy26: Int32 { - get {return _storage._dummy26 ?? 0} - set {_uniqueStorage()._dummy26 = newValue} - } - /// Returns true if `dummy26` has been explicitly set. - var hasDummy26: Bool {return _storage._dummy26 != nil} - /// Clears the value of `dummy26`. Subsequent reads from it will return its default value. - mutating func clearDummy26() {_uniqueStorage()._dummy26 = nil} - - var dummy27: Int32 { - get {return _storage._dummy27 ?? 0} - set {_uniqueStorage()._dummy27 = newValue} - } - /// Returns true if `dummy27` has been explicitly set. - var hasDummy27: Bool {return _storage._dummy27 != nil} - /// Clears the value of `dummy27`. Subsequent reads from it will return its default value. - mutating func clearDummy27() {_uniqueStorage()._dummy27 = nil} - - var dummy28: Int32 { - get {return _storage._dummy28 ?? 0} - set {_uniqueStorage()._dummy28 = newValue} - } - /// Returns true if `dummy28` has been explicitly set. - var hasDummy28: Bool {return _storage._dummy28 != nil} - /// Clears the value of `dummy28`. Subsequent reads from it will return its default value. - mutating func clearDummy28() {_uniqueStorage()._dummy28 = nil} - - var dummy29: Int32 { - get {return _storage._dummy29 ?? 0} - set {_uniqueStorage()._dummy29 = newValue} - } - /// Returns true if `dummy29` has been explicitly set. - var hasDummy29: Bool {return _storage._dummy29 != nil} - /// Clears the value of `dummy29`. Subsequent reads from it will return its default value. - mutating func clearDummy29() {_uniqueStorage()._dummy29 = nil} - - var dummy30: Int32 { - get {return _storage._dummy30 ?? 0} - set {_uniqueStorage()._dummy30 = newValue} - } - /// Returns true if `dummy30` has been explicitly set. - var hasDummy30: Bool {return _storage._dummy30 != nil} - /// Clears the value of `dummy30`. Subsequent reads from it will return its default value. - mutating func clearDummy30() {_uniqueStorage()._dummy30 = nil} - - var dummy31: Int32 { - get {return _storage._dummy31 ?? 0} - set {_uniqueStorage()._dummy31 = newValue} - } - /// Returns true if `dummy31` has been explicitly set. - var hasDummy31: Bool {return _storage._dummy31 != nil} - /// Clears the value of `dummy31`. Subsequent reads from it will return its default value. - mutating func clearDummy31() {_uniqueStorage()._dummy31 = nil} - - var dummy32: Int32 { - get {return _storage._dummy32 ?? 0} - set {_uniqueStorage()._dummy32 = newValue} - } - /// Returns true if `dummy32` has been explicitly set. - var hasDummy32: Bool {return _storage._dummy32 != nil} - /// Clears the value of `dummy32`. Subsequent reads from it will return its default value. - mutating func clearDummy32() {_uniqueStorage()._dummy32 = nil} - - var c: Int32 { - get {return _storage._c ?? 0} - set {_uniqueStorage()._c = newValue} - } - /// Returns true if `c` has been explicitly set. - var hasC: Bool {return _storage._c != nil} - /// Clears the value of `c`. Subsequent reads from it will return its default value. - mutating func clearC() {_uniqueStorage()._c = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -struct ProtobufUnittest_TestRequiredForeign { - // 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 optionalMessage: ProtobufUnittest_TestRequired { - get {return _optionalMessage ?? ProtobufUnittest_TestRequired()} - set {_optionalMessage = newValue} - } - /// Returns true if `optionalMessage` has been explicitly set. - var hasOptionalMessage: Bool {return self._optionalMessage != nil} - /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalMessage() {self._optionalMessage = nil} - - var repeatedMessage: [ProtobufUnittest_TestRequired] = [] - - var dummy: Int32 { - get {return _dummy ?? 0} - set {_dummy = newValue} - } - /// Returns true if `dummy` has been explicitly set. - var hasDummy: Bool {return self._dummy != nil} - /// Clears the value of `dummy`. Subsequent reads from it will return its default value. - mutating func clearDummy() {self._dummy = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _optionalMessage: ProtobufUnittest_TestRequired? = nil - fileprivate var _dummy: Int32? = nil -} - -struct ProtobufUnittest_TestRequiredMessage { - // 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 optionalMessage: ProtobufUnittest_TestRequired { - get {return _optionalMessage ?? ProtobufUnittest_TestRequired()} - set {_optionalMessage = newValue} - } - /// Returns true if `optionalMessage` has been explicitly set. - var hasOptionalMessage: Bool {return self._optionalMessage != nil} - /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalMessage() {self._optionalMessage = nil} - - var repeatedMessage: [ProtobufUnittest_TestRequired] = [] - - var requiredMessage: ProtobufUnittest_TestRequired { - get {return _requiredMessage ?? ProtobufUnittest_TestRequired()} - set {_requiredMessage = newValue} - } - /// Returns true if `requiredMessage` has been explicitly set. - var hasRequiredMessage: Bool {return self._requiredMessage != nil} - /// Clears the value of `requiredMessage`. Subsequent reads from it will return its default value. - mutating func clearRequiredMessage() {self._requiredMessage = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _optionalMessage: ProtobufUnittest_TestRequired? = nil - fileprivate var _requiredMessage: ProtobufUnittest_TestRequired? = nil -} - -/// Test that we can use NestedMessage from outside TestAllTypes. -struct ProtobufUnittest_TestForeignNested { - // 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 foreignNested: ProtobufUnittest_TestAllTypes.NestedMessage { - get {return _foreignNested ?? ProtobufUnittest_TestAllTypes.NestedMessage()} - set {_foreignNested = newValue} - } - /// Returns true if `foreignNested` has been explicitly set. - var hasForeignNested: Bool {return self._foreignNested != nil} - /// Clears the value of `foreignNested`. Subsequent reads from it will return its default value. - mutating func clearForeignNested() {self._foreignNested = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _foreignNested: ProtobufUnittest_TestAllTypes.NestedMessage? = nil -} - -/// TestEmptyMessage is used to test unknown field support. -struct ProtobufUnittest_TestEmptyMessage { - // 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() {} -} - -/// Like above, but declare all field numbers as potential extensions. No -/// actual extensions should ever be defined for this type. -struct ProtobufUnittest_TestEmptyMessageWithExtensions: 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() -} - -/// Needed for a Python test. -struct ProtobufUnittest_TestPickleNestedMessage { - // 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() - - struct NestedMessage { - // 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 bb: Int32 { - get {return _bb ?? 0} - set {_bb = newValue} - } - /// Returns true if `bb` has been explicitly set. - var hasBb: Bool {return self._bb != nil} - /// Clears the value of `bb`. Subsequent reads from it will return its default value. - mutating func clearBb() {self._bb = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct NestedNestedMessage { - // 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 cc: Int32 { - get {return _cc ?? 0} - set {_cc = newValue} - } - /// Returns true if `cc` has been explicitly set. - var hasCc: Bool {return self._cc != nil} - /// Clears the value of `cc`. Subsequent reads from it will return its default value. - mutating func clearCc() {self._cc = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _cc: Int32? = nil - } - - init() {} - - fileprivate var _bb: Int32? = nil - } - - init() {} -} - -struct ProtobufUnittest_TestMultipleExtensionRanges: 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() -} - -/// Test that really large tag numbers don't break anything. -struct ProtobufUnittest_TestReallyLargeTagNumber { - // 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. - - /// The largest possible tag number is 2^28 - 1, since the wire format uses - /// three bits to communicate wire type. - var a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var bb: Int32 { - get {return _bb ?? 0} - set {_bb = newValue} - } - /// Returns true if `bb` has been explicitly set. - var hasBb: Bool {return self._bb != nil} - /// Clears the value of `bb`. Subsequent reads from it will return its default value. - mutating func clearBb() {self._bb = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil - fileprivate var _bb: Int32? = nil -} - -struct ProtobufUnittest_TestRecursiveMessage { - // 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 a: ProtobufUnittest_TestRecursiveMessage { - get {return _storage._a ?? ProtobufUnittest_TestRecursiveMessage()} - set {_uniqueStorage()._a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return _storage._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {_uniqueStorage()._a = nil} - - var i: Int32 { - get {return _storage._i ?? 0} - set {_uniqueStorage()._i = newValue} - } - /// Returns true if `i` has been explicitly set. - var hasI: Bool {return _storage._i != nil} - /// Clears the value of `i`. Subsequent reads from it will return its default value. - mutating func clearI() {_uniqueStorage()._i = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -/// Test that mutual recursion works. -struct ProtobufUnittest_TestMutualRecursionA { - // 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 bb: ProtobufUnittest_TestMutualRecursionB { - get {return _storage._bb ?? ProtobufUnittest_TestMutualRecursionB()} - set {_uniqueStorage()._bb = newValue} - } - /// Returns true if `bb` has been explicitly set. - var hasBb: Bool {return _storage._bb != nil} - /// Clears the value of `bb`. Subsequent reads from it will return its default value. - mutating func clearBb() {_uniqueStorage()._bb = nil} - - var subGroup: ProtobufUnittest_TestMutualRecursionA.SubGroup { - get {return _storage._subGroup ?? ProtobufUnittest_TestMutualRecursionA.SubGroup()} - set {_uniqueStorage()._subGroup = newValue} - } - /// Returns true if `subGroup` has been explicitly set. - var hasSubGroup: Bool {return _storage._subGroup != nil} - /// Clears the value of `subGroup`. Subsequent reads from it will return its default value. - mutating func clearSubGroup() {_uniqueStorage()._subGroup = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - 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 b: ProtobufUnittest_TestMutualRecursionB { - get {return _storage._b ?? ProtobufUnittest_TestMutualRecursionB()} - set {_uniqueStorage()._b = newValue} - } - /// Returns true if `b` has been explicitly set. - var hasB: Bool {return _storage._b != nil} - /// Clears the value of `b`. Subsequent reads from it will return its default value. - mutating func clearB() {_uniqueStorage()._b = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance - } - - struct SubGroup { - // 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. - - /// Needed because of bug in javatest - var subMessage: ProtobufUnittest_TestMutualRecursionA.SubMessage { - get {return _storage._subMessage ?? ProtobufUnittest_TestMutualRecursionA.SubMessage()} - set {_uniqueStorage()._subMessage = newValue} - } - /// Returns true if `subMessage` has been explicitly set. - var hasSubMessage: Bool {return _storage._subMessage != nil} - /// Clears the value of `subMessage`. Subsequent reads from it will return its default value. - mutating func clearSubMessage() {_uniqueStorage()._subMessage = nil} - - var notInThisScc: ProtobufUnittest_TestAllTypes { - get {return _storage._notInThisScc ?? ProtobufUnittest_TestAllTypes()} - set {_uniqueStorage()._notInThisScc = newValue} - } - /// Returns true if `notInThisScc` has been explicitly set. - var hasNotInThisScc: Bool {return _storage._notInThisScc != nil} - /// Clears the value of `notInThisScc`. Subsequent reads from it will return its default value. - mutating func clearNotInThisScc() {_uniqueStorage()._notInThisScc = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance - } - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -struct ProtobufUnittest_TestMutualRecursionB { - // 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 a: ProtobufUnittest_TestMutualRecursionA { - get {return _storage._a ?? ProtobufUnittest_TestMutualRecursionA()} - set {_uniqueStorage()._a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return _storage._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {_uniqueStorage()._a = nil} - - var optionalInt32: Int32 { - get {return _storage._optionalInt32 ?? 0} - set {_uniqueStorage()._optionalInt32 = newValue} - } - /// Returns true if `optionalInt32` has been explicitly set. - var hasOptionalInt32: Bool {return _storage._optionalInt32 != nil} - /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. - mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -struct ProtobufUnittest_TestIsInitialized { - // 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 subMessage: ProtobufUnittest_TestIsInitialized.SubMessage { - get {return _subMessage ?? ProtobufUnittest_TestIsInitialized.SubMessage()} - set {_subMessage = newValue} - } - /// Returns true if `subMessage` has been explicitly set. - var hasSubMessage: Bool {return self._subMessage != nil} - /// Clears the value of `subMessage`. Subsequent reads from it will return its default value. - mutating func clearSubMessage() {self._subMessage = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - 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 subGroup: ProtobufUnittest_TestIsInitialized.SubMessage.SubGroup { - get {return _subGroup ?? ProtobufUnittest_TestIsInitialized.SubMessage.SubGroup()} - set {_subGroup = newValue} - } - /// Returns true if `subGroup` has been explicitly set. - var hasSubGroup: Bool {return self._subGroup != nil} - /// Clears the value of `subGroup`. Subsequent reads from it will return its default value. - mutating func clearSubGroup() {self._subGroup = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct SubGroup { - // 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 i: Int32 { - get {return _i ?? 0} - set {_i = newValue} - } - /// Returns true if `i` has been explicitly set. - var hasI: Bool {return self._i != nil} - /// Clears the value of `i`. Subsequent reads from it will return its default value. - mutating func clearI() {self._i = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _i: Int32? = nil - } - - init() {} - - fileprivate var _subGroup: ProtobufUnittest_TestIsInitialized.SubMessage.SubGroup? = nil - } - - init() {} - - fileprivate var _subMessage: ProtobufUnittest_TestIsInitialized.SubMessage? = nil -} - -/// Test that groups have disjoint field numbers from their siblings and -/// parents. This is NOT possible in proto1; only google.protobuf. When attempting -/// to compile with proto1, this will emit an error; so we only include it -/// in protobuf_unittest_proto. -struct ProtobufUnittest_TestDupFieldNumber { - // 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. - - /// NO_PROTO1 - var a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var foo: ProtobufUnittest_TestDupFieldNumber.Foo { - get {return _foo ?? ProtobufUnittest_TestDupFieldNumber.Foo()} - set {_foo = newValue} - } - /// Returns true if `foo` has been explicitly set. - var hasFoo: Bool {return self._foo != nil} - /// Clears the value of `foo`. Subsequent reads from it will return its default value. - mutating func clearFoo() {self._foo = nil} - - var bar: ProtobufUnittest_TestDupFieldNumber.Bar { - get {return _bar ?? ProtobufUnittest_TestDupFieldNumber.Bar()} - set {_bar = newValue} - } - /// Returns true if `bar` has been explicitly set. - var hasBar: Bool {return self._bar != nil} - /// Clears the value of `bar`. Subsequent reads from it will return its default value. - mutating func clearBar() {self._bar = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct Foo { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil - } - - struct Bar { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil - } - - init() {} - - fileprivate var _a: Int32? = nil - fileprivate var _foo: ProtobufUnittest_TestDupFieldNumber.Foo? = nil - fileprivate var _bar: ProtobufUnittest_TestDupFieldNumber.Bar? = nil -} - -/// Additional messages for testing lazy fields. -struct ProtobufUnittest_TestEagerMessage { - // 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 subMessage: ProtobufUnittest_TestAllTypes { - get {return _subMessage ?? ProtobufUnittest_TestAllTypes()} - set {_subMessage = newValue} - } - /// Returns true if `subMessage` has been explicitly set. - var hasSubMessage: Bool {return self._subMessage != nil} - /// Clears the value of `subMessage`. Subsequent reads from it will return its default value. - mutating func clearSubMessage() {self._subMessage = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _subMessage: ProtobufUnittest_TestAllTypes? = nil -} - -struct ProtobufUnittest_TestLazyMessage { - // 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 subMessage: ProtobufUnittest_TestAllTypes { - get {return _subMessage ?? ProtobufUnittest_TestAllTypes()} - set {_subMessage = newValue} - } - /// Returns true if `subMessage` has been explicitly set. - var hasSubMessage: Bool {return self._subMessage != nil} - /// Clears the value of `subMessage`. Subsequent reads from it will return its default value. - mutating func clearSubMessage() {self._subMessage = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _subMessage: ProtobufUnittest_TestAllTypes? = nil -} - -/// Needed for a Python test. -struct ProtobufUnittest_TestNestedMessageHasBits { - // 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 optionalNestedMessage: ProtobufUnittest_TestNestedMessageHasBits.NestedMessage { - get {return _optionalNestedMessage ?? ProtobufUnittest_TestNestedMessageHasBits.NestedMessage()} - set {_optionalNestedMessage = newValue} - } - /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return self._optionalNestedMessage != nil} - /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalNestedMessage() {self._optionalNestedMessage = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct NestedMessage { - // 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 nestedmessageRepeatedInt32: [Int32] = [] - - var nestedmessageRepeatedForeignmessage: [ProtobufUnittest_ForeignMessage] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - } - - init() {} - - fileprivate var _optionalNestedMessage: ProtobufUnittest_TestNestedMessageHasBits.NestedMessage? = nil -} - -/// Test message with CamelCase field names. This violates Protocol Buffer -/// standard style. -struct ProtobufUnittest_TestCamelCaseFieldNames { - // 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 primitiveField: Int32 { - get {return _primitiveField ?? 0} - set {_primitiveField = newValue} - } - /// Returns true if `primitiveField` has been explicitly set. - var hasPrimitiveField: Bool {return self._primitiveField != nil} - /// Clears the value of `primitiveField`. Subsequent reads from it will return its default value. - mutating func clearPrimitiveField() {self._primitiveField = nil} - - var stringField: String { - get {return _stringField ?? String()} - set {_stringField = newValue} - } - /// Returns true if `stringField` has been explicitly set. - var hasStringField: Bool {return self._stringField != nil} - /// Clears the value of `stringField`. Subsequent reads from it will return its default value. - mutating func clearStringField() {self._stringField = nil} - - var enumField: ProtobufUnittest_ForeignEnum { - get {return _enumField ?? .foreignFoo} - set {_enumField = newValue} - } - /// Returns true if `enumField` has been explicitly set. - var hasEnumField: Bool {return self._enumField != nil} - /// Clears the value of `enumField`. Subsequent reads from it will return its default value. - mutating func clearEnumField() {self._enumField = nil} - - var messageField: ProtobufUnittest_ForeignMessage { - get {return _messageField ?? ProtobufUnittest_ForeignMessage()} - set {_messageField = newValue} - } - /// Returns true if `messageField` has been explicitly set. - var hasMessageField: Bool {return self._messageField != nil} - /// Clears the value of `messageField`. Subsequent reads from it will return its default value. - mutating func clearMessageField() {self._messageField = nil} - - var stringPieceField: String { - get {return _stringPieceField ?? String()} - set {_stringPieceField = newValue} - } - /// Returns true if `stringPieceField` has been explicitly set. - var hasStringPieceField: Bool {return self._stringPieceField != nil} - /// Clears the value of `stringPieceField`. Subsequent reads from it will return its default value. - mutating func clearStringPieceField() {self._stringPieceField = nil} - - var cordField: String { - get {return _cordField ?? String()} - set {_cordField = newValue} - } - /// Returns true if `cordField` has been explicitly set. - var hasCordField: Bool {return self._cordField != nil} - /// Clears the value of `cordField`. Subsequent reads from it will return its default value. - mutating func clearCordField() {self._cordField = nil} - - var repeatedPrimitiveField: [Int32] = [] - - var repeatedStringField: [String] = [] - - var repeatedEnumField: [ProtobufUnittest_ForeignEnum] = [] - - var repeatedMessageField: [ProtobufUnittest_ForeignMessage] = [] - - var repeatedStringPieceField: [String] = [] - - var repeatedCordField: [String] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _primitiveField: Int32? = nil - fileprivate var _stringField: String? = nil - fileprivate var _enumField: ProtobufUnittest_ForeignEnum? = nil - fileprivate var _messageField: ProtobufUnittest_ForeignMessage? = nil - fileprivate var _stringPieceField: String? = nil - fileprivate var _cordField: String? = nil -} - -/// We list fields out of order, to ensure that we're using field number and not -/// field index to determine serialization order. -struct ProtobufUnittest_TestFieldOrderings: 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 myString: String { - get {return _myString ?? String()} - set {_myString = newValue} - } - /// Returns true if `myString` has been explicitly set. - var hasMyString: Bool {return self._myString != nil} - /// Clears the value of `myString`. Subsequent reads from it will return its default value. - mutating func clearMyString() {self._myString = nil} - - var myInt: Int64 { - get {return _myInt ?? 0} - set {_myInt = newValue} - } - /// Returns true if `myInt` has been explicitly set. - var hasMyInt: Bool {return self._myInt != nil} - /// Clears the value of `myInt`. Subsequent reads from it will return its default value. - mutating func clearMyInt() {self._myInt = nil} - - var myFloat: Float { - get {return _myFloat ?? 0} - set {_myFloat = newValue} - } - /// Returns true if `myFloat` has been explicitly set. - var hasMyFloat: Bool {return self._myFloat != nil} - /// Clears the value of `myFloat`. Subsequent reads from it will return its default value. - mutating func clearMyFloat() {self._myFloat = nil} - - var optionalNestedMessage: ProtobufUnittest_TestFieldOrderings.NestedMessage { - get {return _optionalNestedMessage ?? ProtobufUnittest_TestFieldOrderings.NestedMessage()} - set {_optionalNestedMessage = newValue} - } - /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return self._optionalNestedMessage != nil} - /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalNestedMessage() {self._optionalNestedMessage = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct NestedMessage { - // 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 oo: Int64 { - get {return _oo ?? 0} - set {_oo = newValue} - } - /// Returns true if `oo` has been explicitly set. - var hasOo: Bool {return self._oo != nil} - /// Clears the value of `oo`. Subsequent reads from it will return its default value. - mutating func clearOo() {self._oo = nil} - - /// The field name "b" fails to compile in proto1 because it conflicts with - /// a local variable named "b" in one of the generated methods. Doh. - /// This file needs to compile in proto1 to test backwards-compatibility. - var bb: Int32 { - get {return _bb ?? 0} - set {_bb = newValue} - } - /// Returns true if `bb` has been explicitly set. - var hasBb: Bool {return self._bb != nil} - /// Clears the value of `bb`. Subsequent reads from it will return its default value. - mutating func clearBb() {self._bb = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _oo: Int64? = nil - fileprivate var _bb: Int32? = nil - } - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _myString: String? = nil - fileprivate var _myInt: Int64? = nil - fileprivate var _myFloat: Float? = nil - fileprivate var _optionalNestedMessage: ProtobufUnittest_TestFieldOrderings.NestedMessage? = nil -} - -struct ProtobufUnittest_TestExtensionOrderings1 { - // 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 myString: String { - get {return _myString ?? String()} - set {_myString = newValue} - } - /// Returns true if `myString` has been explicitly set. - var hasMyString: Bool {return self._myString != nil} - /// Clears the value of `myString`. Subsequent reads from it will return its default value. - mutating func clearMyString() {self._myString = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _myString: String? = nil -} - -struct ProtobufUnittest_TestExtensionOrderings2 { - // 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 myString: String { - get {return _myString ?? String()} - set {_myString = newValue} - } - /// Returns true if `myString` has been explicitly set. - var hasMyString: Bool {return self._myString != nil} - /// Clears the value of `myString`. Subsequent reads from it will return its default value. - mutating func clearMyString() {self._myString = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct TestExtensionOrderings3 { - // 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 myString: String { - get {return _myString ?? String()} - set {_myString = newValue} - } - /// Returns true if `myString` has been explicitly set. - var hasMyString: Bool {return self._myString != nil} - /// Clears the value of `myString`. Subsequent reads from it will return its default value. - mutating func clearMyString() {self._myString = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _myString: String? = nil - } - - init() {} - - fileprivate var _myString: String? = nil -} - -struct ProtobufUnittest_TestExtremeDefaultValues { - // 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 escapedBytes: Data { - get {return _storage._escapedBytes ?? Data([0, 1, 7, 8, 12, 10, 13, 9, 11, 92, 39, 34, 254])} - set {_uniqueStorage()._escapedBytes = newValue} - } - /// Returns true if `escapedBytes` has been explicitly set. - var hasEscapedBytes: Bool {return _storage._escapedBytes != nil} - /// Clears the value of `escapedBytes`. Subsequent reads from it will return its default value. - mutating func clearEscapedBytes() {_uniqueStorage()._escapedBytes = nil} - - var largeUint32: UInt32 { - get {return _storage._largeUint32 ?? 4294967295} - set {_uniqueStorage()._largeUint32 = newValue} - } - /// Returns true if `largeUint32` has been explicitly set. - var hasLargeUint32: Bool {return _storage._largeUint32 != nil} - /// Clears the value of `largeUint32`. Subsequent reads from it will return its default value. - mutating func clearLargeUint32() {_uniqueStorage()._largeUint32 = nil} - - var largeUint64: UInt64 { - get {return _storage._largeUint64 ?? 18446744073709551615} - set {_uniqueStorage()._largeUint64 = newValue} - } - /// Returns true if `largeUint64` has been explicitly set. - var hasLargeUint64: Bool {return _storage._largeUint64 != nil} - /// Clears the value of `largeUint64`. Subsequent reads from it will return its default value. - mutating func clearLargeUint64() {_uniqueStorage()._largeUint64 = nil} - - var smallInt32: Int32 { - get {return _storage._smallInt32 ?? -2147483647} - set {_uniqueStorage()._smallInt32 = newValue} - } - /// Returns true if `smallInt32` has been explicitly set. - var hasSmallInt32: Bool {return _storage._smallInt32 != nil} - /// Clears the value of `smallInt32`. Subsequent reads from it will return its default value. - mutating func clearSmallInt32() {_uniqueStorage()._smallInt32 = nil} - - var smallInt64: Int64 { - get {return _storage._smallInt64 ?? -9223372036854775807} - set {_uniqueStorage()._smallInt64 = newValue} - } - /// Returns true if `smallInt64` has been explicitly set. - var hasSmallInt64: Bool {return _storage._smallInt64 != nil} - /// Clears the value of `smallInt64`. Subsequent reads from it will return its default value. - mutating func clearSmallInt64() {_uniqueStorage()._smallInt64 = nil} - - var reallySmallInt32: Int32 { - get {return _storage._reallySmallInt32 ?? -2147483648} - set {_uniqueStorage()._reallySmallInt32 = newValue} - } - /// Returns true if `reallySmallInt32` has been explicitly set. - var hasReallySmallInt32: Bool {return _storage._reallySmallInt32 != nil} - /// Clears the value of `reallySmallInt32`. Subsequent reads from it will return its default value. - mutating func clearReallySmallInt32() {_uniqueStorage()._reallySmallInt32 = nil} - - var reallySmallInt64: Int64 { - get {return _storage._reallySmallInt64 ?? -9223372036854775808} - set {_uniqueStorage()._reallySmallInt64 = newValue} - } - /// Returns true if `reallySmallInt64` has been explicitly set. - var hasReallySmallInt64: Bool {return _storage._reallySmallInt64 != nil} - /// Clears the value of `reallySmallInt64`. Subsequent reads from it will return its default value. - mutating func clearReallySmallInt64() {_uniqueStorage()._reallySmallInt64 = nil} - - /// The default value here is UTF-8 for "\u1234". (We could also just type - /// the UTF-8 text directly into this text file rather than escape it, but - /// lots of people use editors that would be confused by this.) - var utf8String: String { - get {return _storage._utf8String ?? "ሴ"} - set {_uniqueStorage()._utf8String = newValue} - } - /// Returns true if `utf8String` has been explicitly set. - var hasUtf8String: Bool {return _storage._utf8String != nil} - /// Clears the value of `utf8String`. Subsequent reads from it will return its default value. - mutating func clearUtf8String() {_uniqueStorage()._utf8String = nil} - - /// Tests for single-precision floating-point values. - var zeroFloat: Float { - get {return _storage._zeroFloat ?? 0} - set {_uniqueStorage()._zeroFloat = newValue} - } - /// Returns true if `zeroFloat` has been explicitly set. - var hasZeroFloat: Bool {return _storage._zeroFloat != nil} - /// Clears the value of `zeroFloat`. Subsequent reads from it will return its default value. - mutating func clearZeroFloat() {_uniqueStorage()._zeroFloat = nil} - - var oneFloat: Float { - get {return _storage._oneFloat ?? 1} - set {_uniqueStorage()._oneFloat = newValue} - } - /// Returns true if `oneFloat` has been explicitly set. - var hasOneFloat: Bool {return _storage._oneFloat != nil} - /// Clears the value of `oneFloat`. Subsequent reads from it will return its default value. - mutating func clearOneFloat() {_uniqueStorage()._oneFloat = nil} - - var smallFloat: Float { - get {return _storage._smallFloat ?? 1.5} - set {_uniqueStorage()._smallFloat = newValue} - } - /// Returns true if `smallFloat` has been explicitly set. - var hasSmallFloat: Bool {return _storage._smallFloat != nil} - /// Clears the value of `smallFloat`. Subsequent reads from it will return its default value. - mutating func clearSmallFloat() {_uniqueStorage()._smallFloat = nil} - - var negativeOneFloat: Float { - get {return _storage._negativeOneFloat ?? -1} - set {_uniqueStorage()._negativeOneFloat = newValue} - } - /// Returns true if `negativeOneFloat` has been explicitly set. - var hasNegativeOneFloat: Bool {return _storage._negativeOneFloat != nil} - /// Clears the value of `negativeOneFloat`. Subsequent reads from it will return its default value. - mutating func clearNegativeOneFloat() {_uniqueStorage()._negativeOneFloat = nil} - - var negativeFloat: Float { - get {return _storage._negativeFloat ?? -1.5} - set {_uniqueStorage()._negativeFloat = newValue} - } - /// Returns true if `negativeFloat` has been explicitly set. - var hasNegativeFloat: Bool {return _storage._negativeFloat != nil} - /// Clears the value of `negativeFloat`. Subsequent reads from it will return its default value. - mutating func clearNegativeFloat() {_uniqueStorage()._negativeFloat = nil} - - /// Using exponents - var largeFloat: Float { - get {return _storage._largeFloat ?? 2e+08} - set {_uniqueStorage()._largeFloat = newValue} - } - /// Returns true if `largeFloat` has been explicitly set. - var hasLargeFloat: Bool {return _storage._largeFloat != nil} - /// Clears the value of `largeFloat`. Subsequent reads from it will return its default value. - mutating func clearLargeFloat() {_uniqueStorage()._largeFloat = nil} - - var smallNegativeFloat: Float { - get {return _storage._smallNegativeFloat ?? -8e-28} - set {_uniqueStorage()._smallNegativeFloat = newValue} - } - /// Returns true if `smallNegativeFloat` has been explicitly set. - var hasSmallNegativeFloat: Bool {return _storage._smallNegativeFloat != nil} - /// Clears the value of `smallNegativeFloat`. Subsequent reads from it will return its default value. - mutating func clearSmallNegativeFloat() {_uniqueStorage()._smallNegativeFloat = nil} - - /// Text for nonfinite floating-point values. - var infDouble: Double { - get {return _storage._infDouble ?? Double.infinity} - set {_uniqueStorage()._infDouble = newValue} - } - /// Returns true if `infDouble` has been explicitly set. - var hasInfDouble: Bool {return _storage._infDouble != nil} - /// Clears the value of `infDouble`. Subsequent reads from it will return its default value. - mutating func clearInfDouble() {_uniqueStorage()._infDouble = nil} - - var negInfDouble: Double { - get {return _storage._negInfDouble ?? -Double.infinity} - set {_uniqueStorage()._negInfDouble = newValue} - } - /// Returns true if `negInfDouble` has been explicitly set. - var hasNegInfDouble: Bool {return _storage._negInfDouble != nil} - /// Clears the value of `negInfDouble`. Subsequent reads from it will return its default value. - mutating func clearNegInfDouble() {_uniqueStorage()._negInfDouble = nil} - - var nanDouble: Double { - get {return _storage._nanDouble ?? Double.nan} - set {_uniqueStorage()._nanDouble = newValue} - } - /// Returns true if `nanDouble` has been explicitly set. - var hasNanDouble: Bool {return _storage._nanDouble != nil} - /// Clears the value of `nanDouble`. Subsequent reads from it will return its default value. - mutating func clearNanDouble() {_uniqueStorage()._nanDouble = nil} - - var infFloat: Float { - get {return _storage._infFloat ?? Float.infinity} - set {_uniqueStorage()._infFloat = newValue} - } - /// Returns true if `infFloat` has been explicitly set. - var hasInfFloat: Bool {return _storage._infFloat != nil} - /// Clears the value of `infFloat`. Subsequent reads from it will return its default value. - mutating func clearInfFloat() {_uniqueStorage()._infFloat = nil} - - var negInfFloat: Float { - get {return _storage._negInfFloat ?? -Float.infinity} - set {_uniqueStorage()._negInfFloat = newValue} - } - /// Returns true if `negInfFloat` has been explicitly set. - var hasNegInfFloat: Bool {return _storage._negInfFloat != nil} - /// Clears the value of `negInfFloat`. Subsequent reads from it will return its default value. - mutating func clearNegInfFloat() {_uniqueStorage()._negInfFloat = nil} - - var nanFloat: Float { - get {return _storage._nanFloat ?? Float.nan} - set {_uniqueStorage()._nanFloat = newValue} - } - /// Returns true if `nanFloat` has been explicitly set. - var hasNanFloat: Bool {return _storage._nanFloat != nil} - /// Clears the value of `nanFloat`. Subsequent reads from it will return its default value. - mutating func clearNanFloat() {_uniqueStorage()._nanFloat = nil} - - /// Tests for C++ trigraphs. - /// Trigraphs should be escaped in C++ generated files, but they should not be - /// escaped for other languages. - /// Note that in .proto file, "\?" is a valid way to escape ? in string - /// literals. - var cppTrigraph: String { - get {return _storage._cppTrigraph ?? "? ? ?? ?? ??? ??/ ??-"} - set {_uniqueStorage()._cppTrigraph = newValue} - } - /// Returns true if `cppTrigraph` has been explicitly set. - var hasCppTrigraph: Bool {return _storage._cppTrigraph != nil} - /// Clears the value of `cppTrigraph`. Subsequent reads from it will return its default value. - mutating func clearCppTrigraph() {_uniqueStorage()._cppTrigraph = nil} - - /// String defaults containing the character '\000' - var stringWithZero: String { - get {return _storage._stringWithZero ?? "hel\0lo"} - set {_uniqueStorage()._stringWithZero = newValue} - } - /// Returns true if `stringWithZero` has been explicitly set. - var hasStringWithZero: Bool {return _storage._stringWithZero != nil} - /// Clears the value of `stringWithZero`. Subsequent reads from it will return its default value. - mutating func clearStringWithZero() {_uniqueStorage()._stringWithZero = nil} - - var bytesWithZero: Data { - get {return _storage._bytesWithZero ?? Data([119, 111, 114, 0, 108, 100])} - set {_uniqueStorage()._bytesWithZero = newValue} - } - /// Returns true if `bytesWithZero` has been explicitly set. - var hasBytesWithZero: Bool {return _storage._bytesWithZero != nil} - /// Clears the value of `bytesWithZero`. Subsequent reads from it will return its default value. - mutating func clearBytesWithZero() {_uniqueStorage()._bytesWithZero = nil} - - var stringPieceWithZero: String { - get {return _storage._stringPieceWithZero ?? "ab\0c"} - set {_uniqueStorage()._stringPieceWithZero = newValue} - } - /// Returns true if `stringPieceWithZero` has been explicitly set. - var hasStringPieceWithZero: Bool {return _storage._stringPieceWithZero != nil} - /// Clears the value of `stringPieceWithZero`. Subsequent reads from it will return its default value. - mutating func clearStringPieceWithZero() {_uniqueStorage()._stringPieceWithZero = nil} - - var cordWithZero: String { - get {return _storage._cordWithZero ?? "12\03"} - set {_uniqueStorage()._cordWithZero = newValue} - } - /// Returns true if `cordWithZero` has been explicitly set. - var hasCordWithZero: Bool {return _storage._cordWithZero != nil} - /// Clears the value of `cordWithZero`. Subsequent reads from it will return its default value. - mutating func clearCordWithZero() {_uniqueStorage()._cordWithZero = nil} - - var replacementString: String { - get {return _storage._replacementString ?? "${unknown}"} - set {_uniqueStorage()._replacementString = newValue} - } - /// Returns true if `replacementString` has been explicitly set. - var hasReplacementString: Bool {return _storage._replacementString != nil} - /// Clears the value of `replacementString`. Subsequent reads from it will return its default value. - mutating func clearReplacementString() {_uniqueStorage()._replacementString = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -struct ProtobufUnittest_SparseEnumMessage { - // 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 sparseEnum: ProtobufUnittest_TestSparseEnum { - get {return _sparseEnum ?? .sparseA} - set {_sparseEnum = newValue} - } - /// Returns true if `sparseEnum` has been explicitly set. - var hasSparseEnum: Bool {return self._sparseEnum != nil} - /// Clears the value of `sparseEnum`. Subsequent reads from it will return its default value. - mutating func clearSparseEnum() {self._sparseEnum = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _sparseEnum: ProtobufUnittest_TestSparseEnum? = nil -} - -/// Test String and Bytes: string is for valid UTF-8 strings -struct ProtobufUnittest_OneString { - // 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 data: String { - get {return _data ?? String()} - set {_data = newValue} - } - /// Returns true if `data` has been explicitly set. - var hasData: Bool {return self._data != nil} - /// Clears the value of `data`. Subsequent reads from it will return its default value. - mutating func clearData() {self._data = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _data: String? = nil -} - -struct ProtobufUnittest_MoreString { - // 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 data: [String] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -struct ProtobufUnittest_OneBytes { - // 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 data: Data { - get {return _data ?? Data()} - set {_data = newValue} - } - /// Returns true if `data` has been explicitly set. - var hasData: Bool {return self._data != nil} - /// Clears the value of `data`. Subsequent reads from it will return its default value. - mutating func clearData() {self._data = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _data: Data? = nil -} - -struct ProtobufUnittest_MoreBytes { - // 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 data: [Data] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -/// Test int32, uint32, int64, uint64, and bool are all compatible -struct ProtobufUnittest_Int32Message { - // 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 data: Int32 { - get {return _data ?? 0} - set {_data = newValue} - } - /// Returns true if `data` has been explicitly set. - var hasData: Bool {return self._data != nil} - /// Clears the value of `data`. Subsequent reads from it will return its default value. - mutating func clearData() {self._data = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _data: Int32? = nil -} - -struct ProtobufUnittest_Uint32Message { - // 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 data: UInt32 { - get {return _data ?? 0} - set {_data = newValue} - } - /// Returns true if `data` has been explicitly set. - var hasData: Bool {return self._data != nil} - /// Clears the value of `data`. Subsequent reads from it will return its default value. - mutating func clearData() {self._data = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _data: UInt32? = nil -} - -struct ProtobufUnittest_Int64Message { - // 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 data: Int64 { - get {return _data ?? 0} - set {_data = newValue} - } - /// Returns true if `data` has been explicitly set. - var hasData: Bool {return self._data != nil} - /// Clears the value of `data`. Subsequent reads from it will return its default value. - mutating func clearData() {self._data = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _data: Int64? = nil -} - -struct ProtobufUnittest_Uint64Message { - // 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 data: UInt64 { - get {return _data ?? 0} - set {_data = newValue} - } - /// Returns true if `data` has been explicitly set. - var hasData: Bool {return self._data != nil} - /// Clears the value of `data`. Subsequent reads from it will return its default value. - mutating func clearData() {self._data = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _data: UInt64? = nil -} - -struct ProtobufUnittest_BoolMessage { - // 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 data: Bool { - get {return _data ?? false} - set {_data = newValue} - } - /// Returns true if `data` has been explicitly set. - var hasData: Bool {return self._data != nil} - /// Clears the value of `data`. Subsequent reads from it will return its default value. - mutating func clearData() {self._data = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _data: Bool? = nil -} - -/// Test oneofs. -struct ProtobufUnittest_TestOneof { - // 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 foo: ProtobufUnittest_TestOneof.OneOf_Foo? = nil - - var fooInt: Int32 { - get { - if case .fooInt(let v)? = foo {return v} - return 0 - } - set {foo = .fooInt(newValue)} - } - - var fooString: String { - get { - if case .fooString(let v)? = foo {return v} - return String() - } - set {foo = .fooString(newValue)} - } - - var fooMessage: ProtobufUnittest_TestAllTypes { - get { - if case .fooMessage(let v)? = foo {return v} - return ProtobufUnittest_TestAllTypes() - } - set {foo = .fooMessage(newValue)} - } - - var fooGroup: ProtobufUnittest_TestOneof.FooGroup { - get { - if case .fooGroup(let v)? = foo {return v} - return ProtobufUnittest_TestOneof.FooGroup() - } - set {foo = .fooGroup(newValue)} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum OneOf_Foo: Equatable { - case fooInt(Int32) - case fooString(String) - case fooMessage(ProtobufUnittest_TestAllTypes) - case fooGroup(ProtobufUnittest_TestOneof.FooGroup) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestOneof.OneOf_Foo, rhs: ProtobufUnittest_TestOneof.OneOf_Foo) -> 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 (.fooInt, .fooInt): return { - guard case .fooInt(let l) = lhs, case .fooInt(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooString, .fooString): return { - guard case .fooString(let l) = lhs, case .fooString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooMessage, .fooMessage): return { - guard case .fooMessage(let l) = lhs, case .fooMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooGroup, .fooGroup): return { - guard case .fooGroup(let l) = lhs, case .fooGroup(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif - } - - struct FooGroup { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var b: String { - get {return _b ?? String()} - set {_b = newValue} - } - /// Returns true if `b` has been explicitly set. - var hasB: Bool {return self._b != nil} - /// Clears the value of `b`. Subsequent reads from it will return its default value. - mutating func clearB() {self._b = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil - fileprivate var _b: String? = nil - } - - init() {} -} - -struct ProtobufUnittest_TestOneofBackwardsCompatible { - // 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 fooInt: Int32 { - get {return _fooInt ?? 0} - set {_fooInt = newValue} - } - /// Returns true if `fooInt` has been explicitly set. - var hasFooInt: Bool {return self._fooInt != nil} - /// Clears the value of `fooInt`. Subsequent reads from it will return its default value. - mutating func clearFooInt() {self._fooInt = nil} - - var fooString: String { - get {return _fooString ?? String()} - set {_fooString = newValue} - } - /// Returns true if `fooString` has been explicitly set. - var hasFooString: Bool {return self._fooString != nil} - /// Clears the value of `fooString`. Subsequent reads from it will return its default value. - mutating func clearFooString() {self._fooString = nil} - - var fooMessage: ProtobufUnittest_TestAllTypes { - get {return _fooMessage ?? ProtobufUnittest_TestAllTypes()} - set {_fooMessage = newValue} - } - /// Returns true if `fooMessage` has been explicitly set. - var hasFooMessage: Bool {return self._fooMessage != nil} - /// Clears the value of `fooMessage`. Subsequent reads from it will return its default value. - mutating func clearFooMessage() {self._fooMessage = nil} - - var fooGroup: ProtobufUnittest_TestOneofBackwardsCompatible.FooGroup { - get {return _fooGroup ?? ProtobufUnittest_TestOneofBackwardsCompatible.FooGroup()} - set {_fooGroup = newValue} - } - /// Returns true if `fooGroup` has been explicitly set. - var hasFooGroup: Bool {return self._fooGroup != nil} - /// Clears the value of `fooGroup`. Subsequent reads from it will return its default value. - mutating func clearFooGroup() {self._fooGroup = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct FooGroup { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var b: String { - get {return _b ?? String()} - set {_b = newValue} - } - /// Returns true if `b` has been explicitly set. - var hasB: Bool {return self._b != nil} - /// Clears the value of `b`. Subsequent reads from it will return its default value. - mutating func clearB() {self._b = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil - fileprivate var _b: String? = nil - } - - init() {} - - fileprivate var _fooInt: Int32? = nil - fileprivate var _fooString: String? = nil - fileprivate var _fooMessage: ProtobufUnittest_TestAllTypes? = nil - fileprivate var _fooGroup: ProtobufUnittest_TestOneofBackwardsCompatible.FooGroup? = nil -} - -struct ProtobufUnittest_TestOneof2 { - // 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 foo: ProtobufUnittest_TestOneof2.OneOf_Foo? = nil - - var fooInt: Int32 { - get { - if case .fooInt(let v)? = foo {return v} - return 0 - } - set {foo = .fooInt(newValue)} - } - - var fooString: String { - get { - if case .fooString(let v)? = foo {return v} - return String() - } - set {foo = .fooString(newValue)} - } - - var fooCord: String { - get { - if case .fooCord(let v)? = foo {return v} - return String() - } - set {foo = .fooCord(newValue)} - } - - var fooStringPiece: String { - get { - if case .fooStringPiece(let v)? = foo {return v} - return String() - } - set {foo = .fooStringPiece(newValue)} - } - - var fooBytes: Data { - get { - if case .fooBytes(let v)? = foo {return v} - return Data() - } - set {foo = .fooBytes(newValue)} - } - - var fooEnum: ProtobufUnittest_TestOneof2.NestedEnum { - get { - if case .fooEnum(let v)? = foo {return v} - return .foo - } - set {foo = .fooEnum(newValue)} - } - - var fooMessage: ProtobufUnittest_TestOneof2.NestedMessage { - get { - if case .fooMessage(let v)? = foo {return v} - return ProtobufUnittest_TestOneof2.NestedMessage() - } - set {foo = .fooMessage(newValue)} - } - - var fooGroup: ProtobufUnittest_TestOneof2.FooGroup { - get { - if case .fooGroup(let v)? = foo {return v} - return ProtobufUnittest_TestOneof2.FooGroup() - } - set {foo = .fooGroup(newValue)} - } - - var fooLazyMessage: ProtobufUnittest_TestOneof2.NestedMessage { - get { - if case .fooLazyMessage(let v)? = foo {return v} - return ProtobufUnittest_TestOneof2.NestedMessage() - } - set {foo = .fooLazyMessage(newValue)} - } - - var bar: ProtobufUnittest_TestOneof2.OneOf_Bar? = nil - - var barInt: Int32 { - get { - if case .barInt(let v)? = bar {return v} - return 5 - } - set {bar = .barInt(newValue)} - } - - var barString: String { - get { - if case .barString(let v)? = bar {return v} - return "STRING" - } - set {bar = .barString(newValue)} - } - - var barCord: String { - get { - if case .barCord(let v)? = bar {return v} - return "CORD" - } - set {bar = .barCord(newValue)} - } - - var barStringPiece: String { - get { - if case .barStringPiece(let v)? = bar {return v} - return "SPIECE" - } - set {bar = .barStringPiece(newValue)} - } - - var barBytes: Data { - get { - if case .barBytes(let v)? = bar {return v} - return Data([66, 89, 84, 69, 83]) - } - set {bar = .barBytes(newValue)} - } - - var barEnum: ProtobufUnittest_TestOneof2.NestedEnum { - get { - if case .barEnum(let v)? = bar {return v} - return .bar - } - set {bar = .barEnum(newValue)} - } - - var barStringWithEmptyDefault: String { - get { - if case .barStringWithEmptyDefault(let v)? = bar {return v} - return String() - } - set {bar = .barStringWithEmptyDefault(newValue)} - } - - var barCordWithEmptyDefault: String { - get { - if case .barCordWithEmptyDefault(let v)? = bar {return v} - return String() - } - set {bar = .barCordWithEmptyDefault(newValue)} - } - - var barStringPieceWithEmptyDefault: String { - get { - if case .barStringPieceWithEmptyDefault(let v)? = bar {return v} - return String() - } - set {bar = .barStringPieceWithEmptyDefault(newValue)} - } - - var barBytesWithEmptyDefault: Data { - get { - if case .barBytesWithEmptyDefault(let v)? = bar {return v} - return Data() - } - set {bar = .barBytesWithEmptyDefault(newValue)} - } - - var bazInt: Int32 { - get {return _bazInt ?? 0} - set {_bazInt = newValue} - } - /// Returns true if `bazInt` has been explicitly set. - var hasBazInt: Bool {return self._bazInt != nil} - /// Clears the value of `bazInt`. Subsequent reads from it will return its default value. - mutating func clearBazInt() {self._bazInt = nil} - - var bazString: String { - get {return _bazString ?? "BAZ"} - set {_bazString = newValue} - } - /// Returns true if `bazString` has been explicitly set. - var hasBazString: Bool {return self._bazString != nil} - /// Clears the value of `bazString`. Subsequent reads from it will return its default value. - mutating func clearBazString() {self._bazString = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum OneOf_Foo: Equatable { - case fooInt(Int32) - case fooString(String) - case fooCord(String) - case fooStringPiece(String) - case fooBytes(Data) - case fooEnum(ProtobufUnittest_TestOneof2.NestedEnum) - case fooMessage(ProtobufUnittest_TestOneof2.NestedMessage) - case fooGroup(ProtobufUnittest_TestOneof2.FooGroup) - case fooLazyMessage(ProtobufUnittest_TestOneof2.NestedMessage) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestOneof2.OneOf_Foo, rhs: ProtobufUnittest_TestOneof2.OneOf_Foo) -> 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 (.fooInt, .fooInt): return { - guard case .fooInt(let l) = lhs, case .fooInt(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooString, .fooString): return { - guard case .fooString(let l) = lhs, case .fooString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooCord, .fooCord): return { - guard case .fooCord(let l) = lhs, case .fooCord(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooStringPiece, .fooStringPiece): return { - guard case .fooStringPiece(let l) = lhs, case .fooStringPiece(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooBytes, .fooBytes): return { - guard case .fooBytes(let l) = lhs, case .fooBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooEnum, .fooEnum): return { - guard case .fooEnum(let l) = lhs, case .fooEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooMessage, .fooMessage): return { - guard case .fooMessage(let l) = lhs, case .fooMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooGroup, .fooGroup): return { - guard case .fooGroup(let l) = lhs, case .fooGroup(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooLazyMessage, .fooLazyMessage): return { - guard case .fooLazyMessage(let l) = lhs, case .fooLazyMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif - } - - enum OneOf_Bar: Equatable { - case barInt(Int32) - case barString(String) - case barCord(String) - case barStringPiece(String) - case barBytes(Data) - case barEnum(ProtobufUnittest_TestOneof2.NestedEnum) - case barStringWithEmptyDefault(String) - case barCordWithEmptyDefault(String) - case barStringPieceWithEmptyDefault(String) - case barBytesWithEmptyDefault(Data) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestOneof2.OneOf_Bar, rhs: ProtobufUnittest_TestOneof2.OneOf_Bar) -> 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 (.barInt, .barInt): return { - guard case .barInt(let l) = lhs, case .barInt(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.barString, .barString): return { - guard case .barString(let l) = lhs, case .barString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.barCord, .barCord): return { - guard case .barCord(let l) = lhs, case .barCord(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.barStringPiece, .barStringPiece): return { - guard case .barStringPiece(let l) = lhs, case .barStringPiece(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.barBytes, .barBytes): return { - guard case .barBytes(let l) = lhs, case .barBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.barEnum, .barEnum): return { - guard case .barEnum(let l) = lhs, case .barEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.barStringWithEmptyDefault, .barStringWithEmptyDefault): return { - guard case .barStringWithEmptyDefault(let l) = lhs, case .barStringWithEmptyDefault(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.barCordWithEmptyDefault, .barCordWithEmptyDefault): return { - guard case .barCordWithEmptyDefault(let l) = lhs, case .barCordWithEmptyDefault(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.barStringPieceWithEmptyDefault, .barStringPieceWithEmptyDefault): return { - guard case .barStringPieceWithEmptyDefault(let l) = lhs, case .barStringPieceWithEmptyDefault(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.barBytesWithEmptyDefault, .barBytesWithEmptyDefault): return { - guard case .barBytesWithEmptyDefault(let l) = lhs, case .barBytesWithEmptyDefault(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif - } - - enum NestedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 1 - case bar // = 2 - case baz // = 3 - - init() { - self = .foo - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .foo - case 2: self = .bar - case 3: self = .baz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo: return 1 - case .bar: return 2 - case .baz: return 3 - } - } - - } - - struct FooGroup { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var b: String { - get {return _b ?? String()} - set {_b = newValue} - } - /// Returns true if `b` has been explicitly set. - var hasB: Bool {return self._b != nil} - /// Clears the value of `b`. Subsequent reads from it will return its default value. - mutating func clearB() {self._b = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil - fileprivate var _b: String? = nil - } - - struct NestedMessage { - // 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 quxInt: Int64 { - get {return _quxInt ?? 0} - set {_quxInt = newValue} - } - /// Returns true if `quxInt` has been explicitly set. - var hasQuxInt: Bool {return self._quxInt != nil} - /// Clears the value of `quxInt`. Subsequent reads from it will return its default value. - mutating func clearQuxInt() {self._quxInt = nil} - - var corgeInt: [Int32] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _quxInt: Int64? = nil - } - - init() {} - - fileprivate var _bazInt: Int32? = nil - fileprivate var _bazString: String? = nil -} - -#if swift(>=4.2) - -extension ProtobufUnittest_TestOneof2.NestedEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_TestRequiredOneof { - // 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 foo: ProtobufUnittest_TestRequiredOneof.OneOf_Foo? = nil - - var fooInt: Int32 { - get { - if case .fooInt(let v)? = foo {return v} - return 0 - } - set {foo = .fooInt(newValue)} - } - - var fooString: String { - get { - if case .fooString(let v)? = foo {return v} - return String() - } - set {foo = .fooString(newValue)} - } - - var fooMessage: ProtobufUnittest_TestRequiredOneof.NestedMessage { - get { - if case .fooMessage(let v)? = foo {return v} - return ProtobufUnittest_TestRequiredOneof.NestedMessage() - } - set {foo = .fooMessage(newValue)} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum OneOf_Foo: Equatable { - case fooInt(Int32) - case fooString(String) - case fooMessage(ProtobufUnittest_TestRequiredOneof.NestedMessage) - - fileprivate var isInitialized: Bool { - guard case .fooMessage(let v) = self else {return true} - return v.isInitialized - } - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestRequiredOneof.OneOf_Foo, rhs: ProtobufUnittest_TestRequiredOneof.OneOf_Foo) -> 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 (.fooInt, .fooInt): return { - guard case .fooInt(let l) = lhs, case .fooInt(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooString, .fooString): return { - guard case .fooString(let l) = lhs, case .fooString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooMessage, .fooMessage): return { - guard case .fooMessage(let l) = lhs, case .fooMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif - } - - struct NestedMessage { - // 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 requiredDouble: Double { - get {return _requiredDouble ?? 0} - set {_requiredDouble = newValue} - } - /// Returns true if `requiredDouble` has been explicitly set. - var hasRequiredDouble: Bool {return self._requiredDouble != nil} - /// Clears the value of `requiredDouble`. Subsequent reads from it will return its default value. - mutating func clearRequiredDouble() {self._requiredDouble = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _requiredDouble: Double? = nil - } - - init() {} -} - -struct ProtobufUnittest_TestPackedTypes { - // 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 packedInt32: [Int32] = [] - - var packedInt64: [Int64] = [] - - var packedUint32: [UInt32] = [] - - var packedUint64: [UInt64] = [] - - var packedSint32: [Int32] = [] - - var packedSint64: [Int64] = [] - - var packedFixed32: [UInt32] = [] - - var packedFixed64: [UInt64] = [] - - var packedSfixed32: [Int32] = [] - - var packedSfixed64: [Int64] = [] - - var packedFloat: [Float] = [] - - var packedDouble: [Double] = [] - - var packedBool: [Bool] = [] - - var packedEnum: [ProtobufUnittest_ForeignEnum] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -/// A message with the same fields as TestPackedTypes, but without packing. Used -/// to test packed <-> unpacked wire compatibility. -struct ProtobufUnittest_TestUnpackedTypes { - // 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 unpackedInt32: [Int32] = [] - - var unpackedInt64: [Int64] = [] - - var unpackedUint32: [UInt32] = [] - - var unpackedUint64: [UInt64] = [] - - var unpackedSint32: [Int32] = [] - - var unpackedSint64: [Int64] = [] - - var unpackedFixed32: [UInt32] = [] - - var unpackedFixed64: [UInt64] = [] - - var unpackedSfixed32: [Int32] = [] - - var unpackedSfixed64: [Int64] = [] - - var unpackedFloat: [Float] = [] - - var unpackedDouble: [Double] = [] - - var unpackedBool: [Bool] = [] - - var unpackedEnum: [ProtobufUnittest_ForeignEnum] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -struct ProtobufUnittest_TestPackedExtensions: 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() -} - -struct ProtobufUnittest_TestUnpackedExtensions: 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() -} - -/// Used by ExtensionSetTest/DynamicExtensions. The test actually builds -/// a set of extensions to TestAllExtensions dynamically, based on the fields -/// of this message type. -struct ProtobufUnittest_TestDynamicExtensions { - // 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 scalarExtension: UInt32 { - get {return _scalarExtension ?? 0} - set {_scalarExtension = newValue} - } - /// Returns true if `scalarExtension` has been explicitly set. - var hasScalarExtension: Bool {return self._scalarExtension != nil} - /// Clears the value of `scalarExtension`. Subsequent reads from it will return its default value. - mutating func clearScalarExtension() {self._scalarExtension = nil} - - var enumExtension: ProtobufUnittest_ForeignEnum { - get {return _enumExtension ?? .foreignFoo} - set {_enumExtension = newValue} - } - /// Returns true if `enumExtension` has been explicitly set. - var hasEnumExtension: Bool {return self._enumExtension != nil} - /// Clears the value of `enumExtension`. Subsequent reads from it will return its default value. - mutating func clearEnumExtension() {self._enumExtension = nil} - - var dynamicEnumExtension: ProtobufUnittest_TestDynamicExtensions.DynamicEnumType { - get {return _dynamicEnumExtension ?? .dynamicFoo} - set {_dynamicEnumExtension = newValue} - } - /// Returns true if `dynamicEnumExtension` has been explicitly set. - var hasDynamicEnumExtension: Bool {return self._dynamicEnumExtension != nil} - /// Clears the value of `dynamicEnumExtension`. Subsequent reads from it will return its default value. - mutating func clearDynamicEnumExtension() {self._dynamicEnumExtension = nil} - - var messageExtension: ProtobufUnittest_ForeignMessage { - get {return _messageExtension ?? ProtobufUnittest_ForeignMessage()} - set {_messageExtension = newValue} - } - /// Returns true if `messageExtension` has been explicitly set. - var hasMessageExtension: Bool {return self._messageExtension != nil} - /// Clears the value of `messageExtension`. Subsequent reads from it will return its default value. - mutating func clearMessageExtension() {self._messageExtension = nil} - - var dynamicMessageExtension: ProtobufUnittest_TestDynamicExtensions.DynamicMessageType { - get {return _dynamicMessageExtension ?? ProtobufUnittest_TestDynamicExtensions.DynamicMessageType()} - set {_dynamicMessageExtension = newValue} - } - /// Returns true if `dynamicMessageExtension` has been explicitly set. - var hasDynamicMessageExtension: Bool {return self._dynamicMessageExtension != nil} - /// Clears the value of `dynamicMessageExtension`. Subsequent reads from it will return its default value. - mutating func clearDynamicMessageExtension() {self._dynamicMessageExtension = nil} - - var repeatedExtension: [String] = [] - - var packedExtension: [Int32] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum DynamicEnumType: SwiftProtobuf.Enum { - typealias RawValue = Int - case dynamicFoo // = 2200 - case dynamicBar // = 2201 - case dynamicBaz // = 2202 - - init() { - self = .dynamicFoo - } - - init?(rawValue: Int) { - switch rawValue { - case 2200: self = .dynamicFoo - case 2201: self = .dynamicBar - case 2202: self = .dynamicBaz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .dynamicFoo: return 2200 - case .dynamicBar: return 2201 - case .dynamicBaz: return 2202 - } - } - - } - - struct DynamicMessageType { - // 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 dynamicField: Int32 { - get {return _dynamicField ?? 0} - set {_dynamicField = newValue} - } - /// Returns true if `dynamicField` has been explicitly set. - var hasDynamicField: Bool {return self._dynamicField != nil} - /// Clears the value of `dynamicField`. Subsequent reads from it will return its default value. - mutating func clearDynamicField() {self._dynamicField = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _dynamicField: Int32? = nil - } - - init() {} - - fileprivate var _scalarExtension: UInt32? = nil - fileprivate var _enumExtension: ProtobufUnittest_ForeignEnum? = nil - fileprivate var _dynamicEnumExtension: ProtobufUnittest_TestDynamicExtensions.DynamicEnumType? = nil - fileprivate var _messageExtension: ProtobufUnittest_ForeignMessage? = nil - fileprivate var _dynamicMessageExtension: ProtobufUnittest_TestDynamicExtensions.DynamicMessageType? = nil -} - -#if swift(>=4.2) - -extension ProtobufUnittest_TestDynamicExtensions.DynamicEnumType: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_TestRepeatedScalarDifferentTagSizes { - // 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. - - /// Parsing repeated fixed size values used to fail. This message needs to be - /// used in order to get a tag of the right size; all of the repeated fields - /// in TestAllTypes didn't trigger the check. - var repeatedFixed32: [UInt32] = [] - - /// Check for a varint type, just for good measure. - var repeatedInt32: [Int32] = [] - - /// These have two-byte tags. - var repeatedFixed64: [UInt64] = [] - - var repeatedInt64: [Int64] = [] - - /// Three byte tags. - var repeatedFloat: [Float] = [] - - var repeatedUint64: [UInt64] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -/// Test that if an optional or required message/group field appears multiple -/// times in the input, they need to be merged. -struct ProtobufUnittest_TestParsingMerge: 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 requiredAllTypes: ProtobufUnittest_TestAllTypes { - get {return _requiredAllTypes ?? ProtobufUnittest_TestAllTypes()} - set {_requiredAllTypes = newValue} - } - /// Returns true if `requiredAllTypes` has been explicitly set. - var hasRequiredAllTypes: Bool {return self._requiredAllTypes != nil} - /// Clears the value of `requiredAllTypes`. Subsequent reads from it will return its default value. - mutating func clearRequiredAllTypes() {self._requiredAllTypes = nil} - - var optionalAllTypes: ProtobufUnittest_TestAllTypes { - get {return _optionalAllTypes ?? ProtobufUnittest_TestAllTypes()} - set {_optionalAllTypes = newValue} - } - /// Returns true if `optionalAllTypes` has been explicitly set. - var hasOptionalAllTypes: Bool {return self._optionalAllTypes != nil} - /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. - mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} - - var repeatedAllTypes: [ProtobufUnittest_TestAllTypes] = [] - - var optionalGroup: ProtobufUnittest_TestParsingMerge.OptionalGroup { - get {return _optionalGroup ?? ProtobufUnittest_TestParsingMerge.OptionalGroup()} - set {_optionalGroup = newValue} - } - /// Returns true if `optionalGroup` has been explicitly set. - var hasOptionalGroup: Bool {return self._optionalGroup != nil} - /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. - mutating func clearOptionalGroup() {self._optionalGroup = nil} - - var repeatedGroup: [ProtobufUnittest_TestParsingMerge.RepeatedGroup] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - /// RepeatedFieldsGenerator defines matching field types as TestParsingMerge, - /// except that all fields are repeated. In the tests, we will serialize the - /// RepeatedFieldsGenerator to bytes, and parse the bytes to TestParsingMerge. - /// Repeated fields in RepeatedFieldsGenerator are expected to be merged into - /// the corresponding required/optional fields in TestParsingMerge. - struct RepeatedFieldsGenerator { - // 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: [ProtobufUnittest_TestAllTypes] = [] - - var field2: [ProtobufUnittest_TestAllTypes] = [] - - var field3: [ProtobufUnittest_TestAllTypes] = [] - - var group1: [ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group1] = [] - - var group2: [ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group2] = [] - - var ext1: [ProtobufUnittest_TestAllTypes] = [] - - var ext2: [ProtobufUnittest_TestAllTypes] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct Group1 { - // 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: ProtobufUnittest_TestAllTypes { - get {return _field1 ?? ProtobufUnittest_TestAllTypes()} - 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 unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _field1: ProtobufUnittest_TestAllTypes? = nil - } - - struct Group2 { - // 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: ProtobufUnittest_TestAllTypes { - get {return _field1 ?? ProtobufUnittest_TestAllTypes()} - 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 unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _field1: ProtobufUnittest_TestAllTypes? = nil - } - - init() {} - } - - struct OptionalGroup { - // 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 optionalGroupAllTypes: ProtobufUnittest_TestAllTypes { - get {return _optionalGroupAllTypes ?? ProtobufUnittest_TestAllTypes()} - set {_optionalGroupAllTypes = newValue} - } - /// Returns true if `optionalGroupAllTypes` has been explicitly set. - var hasOptionalGroupAllTypes: Bool {return self._optionalGroupAllTypes != nil} - /// Clears the value of `optionalGroupAllTypes`. Subsequent reads from it will return its default value. - mutating func clearOptionalGroupAllTypes() {self._optionalGroupAllTypes = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _optionalGroupAllTypes: ProtobufUnittest_TestAllTypes? = nil - } - - struct RepeatedGroup { - // 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 repeatedGroupAllTypes: ProtobufUnittest_TestAllTypes { - get {return _repeatedGroupAllTypes ?? ProtobufUnittest_TestAllTypes()} - set {_repeatedGroupAllTypes = newValue} - } - /// Returns true if `repeatedGroupAllTypes` has been explicitly set. - var hasRepeatedGroupAllTypes: Bool {return self._repeatedGroupAllTypes != nil} - /// Clears the value of `repeatedGroupAllTypes`. Subsequent reads from it will return its default value. - mutating func clearRepeatedGroupAllTypes() {self._repeatedGroupAllTypes = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _repeatedGroupAllTypes: ProtobufUnittest_TestAllTypes? = nil - } - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _requiredAllTypes: ProtobufUnittest_TestAllTypes? = nil - fileprivate var _optionalAllTypes: ProtobufUnittest_TestAllTypes? = nil - fileprivate var _optionalGroup: ProtobufUnittest_TestParsingMerge.OptionalGroup? = nil -} - -struct ProtobufUnittest_TestCommentInjectionMessage { - // 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. - - /// */ <- This should not close the generated doc comment - var a: String { - get {return _a ?? "*/ <- Neither should this."} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: String? = nil -} - -/// Test that RPC services work. -struct ProtobufUnittest_FooRequest { - // 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 ProtobufUnittest_FooResponse { - // 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 ProtobufUnittest_FooClientMessage { - // 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 ProtobufUnittest_FooServerMessage { - // 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 ProtobufUnittest_BarRequest { - // 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 ProtobufUnittest_BarResponse { - // 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 ProtobufUnittest_TestJsonName { - // 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 fieldName1: Int32 { - get {return _fieldName1 ?? 0} - set {_fieldName1 = newValue} - } - /// Returns true if `fieldName1` has been explicitly set. - var hasFieldName1: Bool {return self._fieldName1 != nil} - /// Clears the value of `fieldName1`. Subsequent reads from it will return its default value. - mutating func clearFieldName1() {self._fieldName1 = nil} - - var fieldName2: Int32 { - get {return _fieldName2 ?? 0} - set {_fieldName2 = newValue} - } - /// Returns true if `fieldName2` has been explicitly set. - var hasFieldName2: Bool {return self._fieldName2 != nil} - /// Clears the value of `fieldName2`. Subsequent reads from it will return its default value. - mutating func clearFieldName2() {self._fieldName2 = nil} - - var fieldName3: Int32 { - get {return _fieldName3 ?? 0} - set {_fieldName3 = newValue} - } - /// Returns true if `fieldName3` has been explicitly set. - var hasFieldName3: Bool {return self._fieldName3 != nil} - /// Clears the value of `fieldName3`. Subsequent reads from it will return its default value. - mutating func clearFieldName3() {self._fieldName3 = nil} - - var fieldName4: Int32 { - get {return _fieldName4 ?? 0} - set {_fieldName4 = newValue} - } - /// Returns true if `fieldName4` has been explicitly set. - var hasFieldName4: Bool {return self._fieldName4 != nil} - /// Clears the value of `fieldName4`. Subsequent reads from it will return its default value. - mutating func clearFieldName4() {self._fieldName4 = nil} - - var fieldName5: Int32 { - get {return _fieldName5 ?? 0} - set {_fieldName5 = newValue} - } - /// Returns true if `fieldName5` has been explicitly set. - var hasFieldName5: Bool {return self._fieldName5 != nil} - /// Clears the value of `fieldName5`. Subsequent reads from it will return its default value. - mutating func clearFieldName5() {self._fieldName5 = nil} - - var fieldName6: Int32 { - get {return _fieldName6 ?? 0} - set {_fieldName6 = newValue} - } - /// Returns true if `fieldName6` has been explicitly set. - var hasFieldName6: Bool {return self._fieldName6 != nil} - /// Clears the value of `fieldName6`. Subsequent reads from it will return its default value. - mutating func clearFieldName6() {self._fieldName6 = nil} - - var fieldname7: Int32 { - get {return _fieldname7 ?? 0} - set {_fieldname7 = newValue} - } - /// Returns true if `fieldname7` has been explicitly set. - var hasFieldname7: Bool {return self._fieldname7 != nil} - /// Clears the value of `fieldname7`. Subsequent reads from it will return its default value. - mutating func clearFieldname7() {self._fieldname7 = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _fieldName1: Int32? = nil - fileprivate var _fieldName2: Int32? = nil - fileprivate var _fieldName3: Int32? = nil - fileprivate var _fieldName4: Int32? = nil - fileprivate var _fieldName5: Int32? = nil - fileprivate var _fieldName6: Int32? = nil - fileprivate var _fieldname7: Int32? = nil -} - -struct ProtobufUnittest_TestHugeFieldNumbers: 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 optionalInt32: Int32 { - get {return _optionalInt32 ?? 0} - set {_optionalInt32 = newValue} - } - /// Returns true if `optionalInt32` has been explicitly set. - var hasOptionalInt32: Bool {return self._optionalInt32 != nil} - /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. - mutating func clearOptionalInt32() {self._optionalInt32 = nil} - - var fixed32: Int32 { - get {return _fixed32 ?? 0} - set {_fixed32 = newValue} - } - /// Returns true if `fixed32` has been explicitly set. - var hasFixed32: Bool {return self._fixed32 != nil} - /// Clears the value of `fixed32`. Subsequent reads from it will return its default value. - mutating func clearFixed32() {self._fixed32 = nil} - - var repeatedInt32: [Int32] = [] - - var packedInt32: [Int32] = [] - - var optionalEnum: ProtobufUnittest_ForeignEnum { - get {return _optionalEnum ?? .foreignFoo} - set {_optionalEnum = newValue} - } - /// Returns true if `optionalEnum` has been explicitly set. - var hasOptionalEnum: Bool {return self._optionalEnum != nil} - /// Clears the value of `optionalEnum`. Subsequent reads from it will return its default value. - mutating func clearOptionalEnum() {self._optionalEnum = nil} - - var optionalString: String { - get {return _optionalString ?? String()} - set {_optionalString = newValue} - } - /// Returns true if `optionalString` has been explicitly set. - var hasOptionalString: Bool {return self._optionalString != nil} - /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. - mutating func clearOptionalString() {self._optionalString = nil} - - var optionalBytes: Data { - get {return _optionalBytes ?? Data()} - set {_optionalBytes = newValue} - } - /// Returns true if `optionalBytes` has been explicitly set. - var hasOptionalBytes: Bool {return self._optionalBytes != nil} - /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. - mutating func clearOptionalBytes() {self._optionalBytes = nil} - - var optionalMessage: ProtobufUnittest_ForeignMessage { - get {return _optionalMessage ?? ProtobufUnittest_ForeignMessage()} - set {_optionalMessage = newValue} - } - /// Returns true if `optionalMessage` has been explicitly set. - var hasOptionalMessage: Bool {return self._optionalMessage != nil} - /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalMessage() {self._optionalMessage = nil} - - var optionalGroup: ProtobufUnittest_TestHugeFieldNumbers.OptionalGroup { - get {return _optionalGroup ?? ProtobufUnittest_TestHugeFieldNumbers.OptionalGroup()} - set {_optionalGroup = newValue} - } - /// Returns true if `optionalGroup` has been explicitly set. - var hasOptionalGroup: Bool {return self._optionalGroup != nil} - /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. - mutating func clearOptionalGroup() {self._optionalGroup = nil} - - var stringStringMap: Dictionary = [:] - - var oneofField: ProtobufUnittest_TestHugeFieldNumbers.OneOf_OneofField? = nil - - var oneofUint32: UInt32 { - get { - if case .oneofUint32(let v)? = oneofField {return v} - return 0 - } - set {oneofField = .oneofUint32(newValue)} - } - - var oneofTestAllTypes: ProtobufUnittest_TestAllTypes { - get { - if case .oneofTestAllTypes(let v)? = oneofField {return v} - return ProtobufUnittest_TestAllTypes() - } - set {oneofField = .oneofTestAllTypes(newValue)} - } - - var oneofString: String { - get { - if case .oneofString(let v)? = oneofField {return v} - return String() - } - set {oneofField = .oneofString(newValue)} - } - - var oneofBytes: Data { - get { - if case .oneofBytes(let v)? = oneofField {return v} - return Data() - } - set {oneofField = .oneofBytes(newValue)} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum OneOf_OneofField: Equatable { - case oneofUint32(UInt32) - case oneofTestAllTypes(ProtobufUnittest_TestAllTypes) - case oneofString(String) - case oneofBytes(Data) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestHugeFieldNumbers.OneOf_OneofField, rhs: ProtobufUnittest_TestHugeFieldNumbers.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofTestAllTypes, .oneofTestAllTypes): return { - guard case .oneofTestAllTypes(let l) = lhs, case .oneofTestAllTypes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif - } - - struct OptionalGroup { - // 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 groupA: Int32 { - get {return _groupA ?? 0} - set {_groupA = newValue} - } - /// Returns true if `groupA` has been explicitly set. - var hasGroupA: Bool {return self._groupA != nil} - /// Clears the value of `groupA`. Subsequent reads from it will return its default value. - mutating func clearGroupA() {self._groupA = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _groupA: Int32? = nil - } - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _optionalInt32: Int32? = nil - fileprivate var _fixed32: Int32? = nil - fileprivate var _optionalEnum: ProtobufUnittest_ForeignEnum? = nil - fileprivate var _optionalString: String? = nil - fileprivate var _optionalBytes: Data? = nil - fileprivate var _optionalMessage: ProtobufUnittest_ForeignMessage? = nil - fileprivate var _optionalGroup: ProtobufUnittest_TestHugeFieldNumbers.OptionalGroup? = nil -} - -struct ProtobufUnittest_TestExtensionInsideTable: 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 field3: Int32 { - get {return _field3 ?? 0} - set {_field3 = newValue} - } - /// Returns true if `field3` has been explicitly set. - var hasField3: Bool {return self._field3 != nil} - /// Clears the value of `field3`. Subsequent reads from it will return its default value. - mutating func clearField3() {self._field3 = nil} - - var field4: Int32 { - get {return _field4 ?? 0} - set {_field4 = newValue} - } - /// Returns true if `field4` has been explicitly set. - var hasField4: Bool {return self._field4 != nil} - /// Clears the value of `field4`. Subsequent reads from it will return its default value. - mutating func clearField4() {self._field4 = 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 field7: Int32 { - get {return _field7 ?? 0} - set {_field7 = newValue} - } - /// Returns true if `field7` has been explicitly set. - var hasField7: Bool {return self._field7 != nil} - /// Clears the value of `field7`. Subsequent reads from it will return its default value. - mutating func clearField7() {self._field7 = nil} - - var field8: Int32 { - get {return _field8 ?? 0} - set {_field8 = newValue} - } - /// Returns true if `field8` has been explicitly set. - var hasField8: Bool {return self._field8 != nil} - /// Clears the value of `field8`. Subsequent reads from it will return its default value. - mutating func clearField8() {self._field8 = nil} - - var field9: Int32 { - get {return _field9 ?? 0} - set {_field9 = newValue} - } - /// Returns true if `field9` has been explicitly set. - var hasField9: Bool {return self._field9 != nil} - /// Clears the value of `field9`. Subsequent reads from it will return its default value. - mutating func clearField9() {self._field9 = nil} - - var field10: Int32 { - get {return _field10 ?? 0} - set {_field10 = newValue} - } - /// Returns true if `field10` has been explicitly set. - var hasField10: Bool {return self._field10 != nil} - /// Clears the value of `field10`. Subsequent reads from it will return its default value. - mutating func clearField10() {self._field10 = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _field1: Int32? = nil - fileprivate var _field2: Int32? = nil - fileprivate var _field3: Int32? = nil - fileprivate var _field4: Int32? = nil - fileprivate var _field6: Int32? = nil - fileprivate var _field7: Int32? = nil - fileprivate var _field8: Int32? = nil - fileprivate var _field9: Int32? = nil - fileprivate var _field10: Int32? = nil -} - -struct ProtobufUnittest_TestExtensionRangeSerialize: 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 fooOne: Int32 { - get {return _fooOne ?? 0} - set {_fooOne = newValue} - } - /// Returns true if `fooOne` has been explicitly set. - var hasFooOne: Bool {return self._fooOne != nil} - /// Clears the value of `fooOne`. Subsequent reads from it will return its default value. - mutating func clearFooOne() {self._fooOne = nil} - - var fooTwo: Int32 { - get {return _fooTwo ?? 0} - set {_fooTwo = newValue} - } - /// Returns true if `fooTwo` has been explicitly set. - var hasFooTwo: Bool {return self._fooTwo != nil} - /// Clears the value of `fooTwo`. Subsequent reads from it will return its default value. - mutating func clearFooTwo() {self._fooTwo = nil} - - var fooThree: Int32 { - get {return _fooThree ?? 0} - set {_fooThree = newValue} - } - /// Returns true if `fooThree` has been explicitly set. - var hasFooThree: Bool {return self._fooThree != nil} - /// Clears the value of `fooThree`. Subsequent reads from it will return its default value. - mutating func clearFooThree() {self._fooThree = nil} - - var fooFour: Int32 { - get {return _fooFour ?? 0} - set {_fooFour = newValue} - } - /// Returns true if `fooFour` has been explicitly set. - var hasFooFour: Bool {return self._fooFour != nil} - /// Clears the value of `fooFour`. Subsequent reads from it will return its default value. - mutating func clearFooFour() {self._fooFour = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _fooOne: Int32? = nil - fileprivate var _fooTwo: Int32? = nil - fileprivate var _fooThree: Int32? = nil - fileprivate var _fooFour: Int32? = nil -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_ForeignEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestEnumWithDupValue: @unchecked Sendable {} -extension ProtobufUnittest_TestSparseEnum: @unchecked Sendable {} -extension ProtobufUnittest_VeryLargeEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypes: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypes.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypes.NestedEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypes.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypes.OptionalGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypes.RepeatedGroup: @unchecked Sendable {} -extension ProtobufUnittest_NestedTestAllTypes: @unchecked Sendable {} -extension ProtobufUnittest_TestDeprecatedFields: @unchecked Sendable {} -extension ProtobufUnittest_TestDeprecatedFields.OneOf_OneofFields: @unchecked Sendable {} -extension ProtobufUnittest_TestDeprecatedMessage: @unchecked Sendable {} -extension ProtobufUnittest_ForeignMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestReservedFields: @unchecked Sendable {} -extension ProtobufUnittest_TestAllExtensions: @unchecked Sendable {} -extension ProtobufUnittest_OptionalGroup_extension: @unchecked Sendable {} -extension ProtobufUnittest_RepeatedGroup_extension: @unchecked Sendable {} -extension ProtobufUnittest_TestGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestGroup.OptionalGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestGroupExtension: @unchecked Sendable {} -extension ProtobufUnittest_TestNestedExtension: @unchecked Sendable {} -extension ProtobufUnittest_TestNestedExtension.OptionalGroup_extension: @unchecked Sendable {} -extension ProtobufUnittest_TestChildExtension: @unchecked Sendable {} -extension ProtobufUnittest_TestRequired: @unchecked Sendable {} -extension ProtobufUnittest_TestRequiredForeign: @unchecked Sendable {} -extension ProtobufUnittest_TestRequiredMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestForeignNested: @unchecked Sendable {} -extension ProtobufUnittest_TestEmptyMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestEmptyMessageWithExtensions: @unchecked Sendable {} -extension ProtobufUnittest_TestPickleNestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestPickleNestedMessage.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestMultipleExtensionRanges: @unchecked Sendable {} -extension ProtobufUnittest_TestReallyLargeTagNumber: @unchecked Sendable {} -extension ProtobufUnittest_TestRecursiveMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestMutualRecursionA: @unchecked Sendable {} -extension ProtobufUnittest_TestMutualRecursionA.SubMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestMutualRecursionA.SubGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestMutualRecursionB: @unchecked Sendable {} -extension ProtobufUnittest_TestIsInitialized: @unchecked Sendable {} -extension ProtobufUnittest_TestIsInitialized.SubMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestIsInitialized.SubMessage.SubGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestDupFieldNumber: @unchecked Sendable {} -extension ProtobufUnittest_TestDupFieldNumber.Foo: @unchecked Sendable {} -extension ProtobufUnittest_TestDupFieldNumber.Bar: @unchecked Sendable {} -extension ProtobufUnittest_TestEagerMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestLazyMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestNestedMessageHasBits: @unchecked Sendable {} -extension ProtobufUnittest_TestNestedMessageHasBits.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestCamelCaseFieldNames: @unchecked Sendable {} -extension ProtobufUnittest_TestFieldOrderings: @unchecked Sendable {} -extension ProtobufUnittest_TestFieldOrderings.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestExtensionOrderings1: @unchecked Sendable {} -extension ProtobufUnittest_TestExtensionOrderings2: @unchecked Sendable {} -extension ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3: @unchecked Sendable {} -extension ProtobufUnittest_TestExtremeDefaultValues: @unchecked Sendable {} -extension ProtobufUnittest_SparseEnumMessage: @unchecked Sendable {} -extension ProtobufUnittest_OneString: @unchecked Sendable {} -extension ProtobufUnittest_MoreString: @unchecked Sendable {} -extension ProtobufUnittest_OneBytes: @unchecked Sendable {} -extension ProtobufUnittest_MoreBytes: @unchecked Sendable {} -extension ProtobufUnittest_Int32Message: @unchecked Sendable {} -extension ProtobufUnittest_Uint32Message: @unchecked Sendable {} -extension ProtobufUnittest_Int64Message: @unchecked Sendable {} -extension ProtobufUnittest_Uint64Message: @unchecked Sendable {} -extension ProtobufUnittest_BoolMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestOneof: @unchecked Sendable {} -extension ProtobufUnittest_TestOneof.OneOf_Foo: @unchecked Sendable {} -extension ProtobufUnittest_TestOneof.FooGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestOneofBackwardsCompatible: @unchecked Sendable {} -extension ProtobufUnittest_TestOneofBackwardsCompatible.FooGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestOneof2: @unchecked Sendable {} -extension ProtobufUnittest_TestOneof2.OneOf_Foo: @unchecked Sendable {} -extension ProtobufUnittest_TestOneof2.OneOf_Bar: @unchecked Sendable {} -extension ProtobufUnittest_TestOneof2.NestedEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestOneof2.FooGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestOneof2.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestRequiredOneof: @unchecked Sendable {} -extension ProtobufUnittest_TestRequiredOneof.OneOf_Foo: @unchecked Sendable {} -extension ProtobufUnittest_TestRequiredOneof.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestPackedTypes: @unchecked Sendable {} -extension ProtobufUnittest_TestUnpackedTypes: @unchecked Sendable {} -extension ProtobufUnittest_TestPackedExtensions: @unchecked Sendable {} -extension ProtobufUnittest_TestUnpackedExtensions: @unchecked Sendable {} -extension ProtobufUnittest_TestDynamicExtensions: @unchecked Sendable {} -extension ProtobufUnittest_TestDynamicExtensions.DynamicEnumType: @unchecked Sendable {} -extension ProtobufUnittest_TestDynamicExtensions.DynamicMessageType: @unchecked Sendable {} -extension ProtobufUnittest_TestRepeatedScalarDifferentTagSizes: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMerge: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group1: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group2: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMerge.OptionalGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMerge.RepeatedGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestCommentInjectionMessage: @unchecked Sendable {} -extension ProtobufUnittest_FooRequest: @unchecked Sendable {} -extension ProtobufUnittest_FooResponse: @unchecked Sendable {} -extension ProtobufUnittest_FooClientMessage: @unchecked Sendable {} -extension ProtobufUnittest_FooServerMessage: @unchecked Sendable {} -extension ProtobufUnittest_BarRequest: @unchecked Sendable {} -extension ProtobufUnittest_BarResponse: @unchecked Sendable {} -extension ProtobufUnittest_TestJsonName: @unchecked Sendable {} -extension ProtobufUnittest_TestHugeFieldNumbers: @unchecked Sendable {} -extension ProtobufUnittest_TestHugeFieldNumbers.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufUnittest_TestHugeFieldNumbers.OptionalGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestExtensionInsideTable: @unchecked Sendable {} -extension ProtobufUnittest_TestExtensionRangeSerialize: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Extension support defined in unittest.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 ProtobufUnittest_TestAllExtensions { - - /// Singular - var ProtobufUnittest_optionalInt32Extension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_int32_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_int32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_int32_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalInt32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_int32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_int32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalInt32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_int32_extension) - } - - var ProtobufUnittest_optionalInt64Extension: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_int64_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_int64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_int64_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalInt64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_int64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_int64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalInt64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_int64_extension) - } - - var ProtobufUnittest_optionalUint32Extension: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint32_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_uint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalUint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_uint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalUint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint32_extension) - } - - var ProtobufUnittest_optionalUint64Extension: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint64_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_uint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalUint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_uint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalUint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint64_extension) - } - - var ProtobufUnittest_optionalSint32Extension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint32_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_sint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalSint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_sint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalSint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint32_extension) - } - - var ProtobufUnittest_optionalSint64Extension: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint64_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_sint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalSint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_sint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalSint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint64_extension) - } - - var ProtobufUnittest_optionalFixed32Extension: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed32_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_fixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalFixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_fixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalFixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed32_extension) - } - - var ProtobufUnittest_optionalFixed64Extension: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed64_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_fixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalFixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_fixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalFixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed64_extension) - } - - var ProtobufUnittest_optionalSfixed32Extension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed32_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_sfixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalSfixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_sfixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalSfixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed32_extension) - } - - var ProtobufUnittest_optionalSfixed64Extension: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed64_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_sfixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalSfixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_sfixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalSfixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed64_extension) - } - - var ProtobufUnittest_optionalFloatExtension: Float { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_float_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_float_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_float_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalFloatExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_float_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_float_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalFloatExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_float_extension) - } - - var ProtobufUnittest_optionalDoubleExtension: Double { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_double_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_double_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_double_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalDoubleExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_double_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_double_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalDoubleExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_double_extension) - } - - var ProtobufUnittest_optionalBoolExtension: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_bool_extension) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_bool_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_bool_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalBoolExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_bool_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_bool_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalBoolExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_bool_extension) - } - - var ProtobufUnittest_optionalStringExtension: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_extension) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_string_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalStringExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_string_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalStringExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_extension) - } - - var ProtobufUnittest_optionalBytesExtension: Data { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_bytes_extension) ?? Data()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_bytes_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_bytes_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalBytesExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_bytes_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_bytes_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalBytesExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_bytes_extension) - } - - var ProtobufUnittest_optionalGroupExtension: ProtobufUnittest_OptionalGroup_extension { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_OptionalGroup_extension) ?? ProtobufUnittest_OptionalGroup_extension()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_OptionalGroup_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_OptionalGroup_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalGroupExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_OptionalGroup_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_OptionalGroup_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalGroupExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_OptionalGroup_extension) - } - - var ProtobufUnittest_optionalNestedMessageExtension: ProtobufUnittest_TestAllTypes.NestedMessage { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_message_extension) ?? ProtobufUnittest_TestAllTypes.NestedMessage()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_nested_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalNestedMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_nested_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalNestedMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_message_extension) - } - - var ProtobufUnittest_optionalForeignMessageExtension: ProtobufUnittest_ForeignMessage { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_message_extension) ?? ProtobufUnittest_ForeignMessage()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_foreign_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalForeignMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_foreign_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalForeignMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_message_extension) - } - - var ProtobufUnittest_optionalImportMessageExtension: ProtobufUnittestImport_ImportMessage { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_message_extension) ?? ProtobufUnittestImport_ImportMessage()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_import_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalImportMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_import_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalImportMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_message_extension) - } - - var ProtobufUnittest_optionalNestedEnumExtension: ProtobufUnittest_TestAllTypes.NestedEnum { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_enum_extension) ?? .foo} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_nested_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalNestedEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_nested_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalNestedEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_enum_extension) - } - - var ProtobufUnittest_optionalForeignEnumExtension: ProtobufUnittest_ForeignEnum { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_enum_extension) ?? .foreignFoo} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_foreign_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalForeignEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_foreign_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalForeignEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_enum_extension) - } - - var ProtobufUnittest_optionalImportEnumExtension: ProtobufUnittestImport_ImportEnum { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_enum_extension) ?? .importFoo} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_import_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalImportEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_import_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalImportEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_enum_extension) - } - - var ProtobufUnittest_optionalStringPieceExtension: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_piece_extension) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_piece_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_string_piece_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalStringPieceExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_piece_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_string_piece_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalStringPieceExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_piece_extension) - } - - var ProtobufUnittest_optionalCordExtension: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_cord_extension) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_cord_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_cord_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalCordExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_cord_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_cord_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalCordExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_cord_extension) - } - - var ProtobufUnittest_optionalPublicImportMessageExtension: ProtobufUnittestImport_PublicImportMessage { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_public_import_message_extension) ?? ProtobufUnittestImport_PublicImportMessage()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_public_import_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_public_import_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalPublicImportMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_public_import_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_public_import_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalPublicImportMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_public_import_message_extension) - } - - var ProtobufUnittest_optionalLazyMessageExtension: ProtobufUnittest_TestAllTypes.NestedMessage { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_lazy_message_extension) ?? ProtobufUnittest_TestAllTypes.NestedMessage()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_lazy_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_lazy_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalLazyMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_lazy_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_lazy_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalLazyMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_lazy_message_extension) - } - - /// Repeated - var ProtobufUnittest_repeatedInt32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_int32_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedInt32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_int32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedInt32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int32_extension) - } - - var ProtobufUnittest_repeatedInt64Extension: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_int64_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedInt64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_int64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedInt64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int64_extension) - } - - var ProtobufUnittest_repeatedUint32Extension: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_uint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedUint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_uint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedUint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint32_extension) - } - - var ProtobufUnittest_repeatedUint64Extension: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_uint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedUint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_uint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedUint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint64_extension) - } - - var ProtobufUnittest_repeatedSint32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_sint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedSint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_sint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedSint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint32_extension) - } - - var ProtobufUnittest_repeatedSint64Extension: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_sint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedSint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_sint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedSint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint64_extension) - } - - var ProtobufUnittest_repeatedFixed32Extension: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_fixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedFixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_fixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedFixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed32_extension) - } - - var ProtobufUnittest_repeatedFixed64Extension: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_fixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedFixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_fixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedFixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed64_extension) - } - - var ProtobufUnittest_repeatedSfixed32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_sfixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedSfixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_sfixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedSfixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed32_extension) - } - - var ProtobufUnittest_repeatedSfixed64Extension: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_sfixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedSfixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_sfixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedSfixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed64_extension) - } - - var ProtobufUnittest_repeatedFloatExtension: [Float] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_float_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_float_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_float_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedFloatExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_float_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_float_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedFloatExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_float_extension) - } - - var ProtobufUnittest_repeatedDoubleExtension: [Double] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_double_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_double_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_double_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedDoubleExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_double_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_double_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedDoubleExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_double_extension) - } - - var ProtobufUnittest_repeatedBoolExtension: [Bool] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bool_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bool_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_bool_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedBoolExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bool_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_bool_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedBoolExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bool_extension) - } - - var ProtobufUnittest_repeatedStringExtension: [String] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_string_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedStringExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_string_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedStringExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_extension) - } - - var ProtobufUnittest_repeatedBytesExtension: [Data] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bytes_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bytes_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_bytes_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedBytesExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bytes_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_bytes_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedBytesExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bytes_extension) - } - - var ProtobufUnittest_repeatedGroupExtension: [ProtobufUnittest_RepeatedGroup_extension] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_RepeatedGroup_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_RepeatedGroup_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_RepeatedGroup_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedGroupExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_RepeatedGroup_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_RepeatedGroup_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedGroupExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_RepeatedGroup_extension) - } - - var ProtobufUnittest_repeatedNestedMessageExtension: [ProtobufUnittest_TestAllTypes.NestedMessage] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_message_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_nested_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedNestedMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_nested_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedNestedMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_message_extension) - } - - var ProtobufUnittest_repeatedForeignMessageExtension: [ProtobufUnittest_ForeignMessage] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_message_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_foreign_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedForeignMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_foreign_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedForeignMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_message_extension) - } - - var ProtobufUnittest_repeatedImportMessageExtension: [ProtobufUnittestImport_ImportMessage] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_message_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_import_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedImportMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_import_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedImportMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_message_extension) - } - - var ProtobufUnittest_repeatedNestedEnumExtension: [ProtobufUnittest_TestAllTypes.NestedEnum] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_enum_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_nested_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedNestedEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_nested_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedNestedEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_enum_extension) - } - - var ProtobufUnittest_repeatedForeignEnumExtension: [ProtobufUnittest_ForeignEnum] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_enum_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_foreign_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedForeignEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_foreign_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedForeignEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_enum_extension) - } - - var ProtobufUnittest_repeatedImportEnumExtension: [ProtobufUnittestImport_ImportEnum] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_enum_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_import_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedImportEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_import_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedImportEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_enum_extension) - } - - var ProtobufUnittest_repeatedStringPieceExtension: [String] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_piece_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_piece_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_string_piece_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedStringPieceExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_piece_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_string_piece_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedStringPieceExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_piece_extension) - } - - var ProtobufUnittest_repeatedCordExtension: [String] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_cord_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_cord_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_cord_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedCordExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_cord_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_cord_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedCordExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_cord_extension) - } - - var ProtobufUnittest_repeatedLazyMessageExtension: [ProtobufUnittest_TestAllTypes.NestedMessage] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_lazy_message_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_lazy_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_lazy_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedLazyMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_lazy_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_lazy_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedLazyMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_lazy_message_extension) - } - - /// Singular with defaults - var ProtobufUnittest_defaultInt32Extension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_int32_extension) ?? 41} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_int32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_int32_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultInt32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_int32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_int32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultInt32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_int32_extension) - } - - var ProtobufUnittest_defaultInt64Extension: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_int64_extension) ?? 42} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_int64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_int64_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultInt64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_int64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_int64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultInt64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_int64_extension) - } - - var ProtobufUnittest_defaultUint32Extension: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_uint32_extension) ?? 43} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_uint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_uint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultUint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_uint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_uint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultUint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_uint32_extension) - } - - var ProtobufUnittest_defaultUint64Extension: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_uint64_extension) ?? 44} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_uint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_uint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultUint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_uint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_uint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultUint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_uint64_extension) - } - - var ProtobufUnittest_defaultSint32Extension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_sint32_extension) ?? -45} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_sint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_sint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultSint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_sint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_sint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultSint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_sint32_extension) - } - - var ProtobufUnittest_defaultSint64Extension: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_sint64_extension) ?? 46} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_sint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_sint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultSint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_sint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_sint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultSint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_sint64_extension) - } - - var ProtobufUnittest_defaultFixed32Extension: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed32_extension) ?? 47} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_fixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultFixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_fixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultFixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed32_extension) - } - - var ProtobufUnittest_defaultFixed64Extension: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed64_extension) ?? 48} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_fixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultFixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_fixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultFixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed64_extension) - } - - var ProtobufUnittest_defaultSfixed32Extension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed32_extension) ?? 49} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_sfixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultSfixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_sfixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultSfixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed32_extension) - } - - var ProtobufUnittest_defaultSfixed64Extension: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed64_extension) ?? -50} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_sfixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultSfixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_sfixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultSfixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed64_extension) - } - - var ProtobufUnittest_defaultFloatExtension: Float { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_float_extension) ?? 51.5} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_float_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_float_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultFloatExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_float_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_float_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultFloatExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_float_extension) - } - - var ProtobufUnittest_defaultDoubleExtension: Double { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_double_extension) ?? 52000} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_double_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_double_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultDoubleExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_double_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_double_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultDoubleExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_double_extension) - } - - var ProtobufUnittest_defaultBoolExtension: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_bool_extension) ?? true} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_bool_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_bool_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultBoolExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_bool_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_bool_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultBoolExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_bool_extension) - } - - var ProtobufUnittest_defaultStringExtension: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_string_extension) ?? "hello"} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_string_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_string_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultStringExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_string_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_string_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultStringExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_string_extension) - } - - var ProtobufUnittest_defaultBytesExtension: Data { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_bytes_extension) ?? Data([119, 111, 114, 108, 100])} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_bytes_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_bytes_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultBytesExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_bytes_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_bytes_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultBytesExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_bytes_extension) - } - - var ProtobufUnittest_defaultNestedEnumExtension: ProtobufUnittest_TestAllTypes.NestedEnum { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_nested_enum_extension) ?? .bar} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_nested_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_nested_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultNestedEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_nested_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_nested_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultNestedEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_nested_enum_extension) - } - - var ProtobufUnittest_defaultForeignEnumExtension: ProtobufUnittest_ForeignEnum { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_foreign_enum_extension) ?? .foreignBar} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_foreign_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_foreign_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultForeignEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_foreign_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_foreign_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultForeignEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_foreign_enum_extension) - } - - var ProtobufUnittest_defaultImportEnumExtension: ProtobufUnittestImport_ImportEnum { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_import_enum_extension) ?? .importBar} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_import_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_import_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultImportEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_import_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_import_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultImportEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_import_enum_extension) - } - - var ProtobufUnittest_defaultStringPieceExtension: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_string_piece_extension) ?? "abc"} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_string_piece_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_string_piece_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultStringPieceExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_string_piece_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_string_piece_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultStringPieceExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_string_piece_extension) - } - - var ProtobufUnittest_defaultCordExtension: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_cord_extension) ?? "123"} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_cord_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_cord_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultCordExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_cord_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_cord_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultCordExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_cord_extension) - } - - /// For oneof test - var ProtobufUnittest_oneofUint32Extension: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_oneof_uint32_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_oneof_uint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_oneof_uint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_oneofUint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_oneof_uint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_oneof_uint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_oneofUint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_oneof_uint32_extension) - } - - var ProtobufUnittest_oneofNestedMessageExtension: ProtobufUnittest_TestAllTypes.NestedMessage { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_oneof_nested_message_extension) ?? ProtobufUnittest_TestAllTypes.NestedMessage()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_oneof_nested_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_oneof_nested_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_oneofNestedMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_oneof_nested_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_oneof_nested_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_oneofNestedMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_oneof_nested_message_extension) - } - - var ProtobufUnittest_oneofStringExtension: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_oneof_string_extension) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_oneof_string_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_oneof_string_extension` - /// has been explicitly set. - var hasProtobufUnittest_oneofStringExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_oneof_string_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_oneof_string_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_oneofStringExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_oneof_string_extension) - } - - var ProtobufUnittest_oneofBytesExtension: Data { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_oneof_bytes_extension) ?? Data()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_oneof_bytes_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_oneof_bytes_extension` - /// has been explicitly set. - var hasProtobufUnittest_oneofBytesExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_oneof_bytes_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_oneof_bytes_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_oneofBytesExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_oneof_bytes_extension) - } - - /// Check for bug where string extensions declared in tested scope did not - /// compile. - var ProtobufUnittest_TestNestedExtension_test: String { - get {return getExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.test) ?? "test"} - set {setExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.test, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestNestedExtension.Extensions.test` - /// has been explicitly set. - var hasProtobufUnittest_TestNestedExtension_test: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.test) - } - /// Clears the value of extension `ProtobufUnittest_TestNestedExtension.Extensions.test`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestNestedExtension_test() { - clearExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.test) - } - - /// Used to test if generated extension name is correct when there are - /// underscores. - var ProtobufUnittest_TestNestedExtension_nestedStringExtension: String { - get {return getExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.nested_string_extension) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.nested_string_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestNestedExtension.Extensions.nested_string_extension` - /// has been explicitly set. - var hasProtobufUnittest_TestNestedExtension_nestedStringExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.nested_string_extension) - } - /// Clears the value of extension `ProtobufUnittest_TestNestedExtension.Extensions.nested_string_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestNestedExtension_nestedStringExtension() { - clearExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.nested_string_extension) - } - - var ProtobufUnittest_TestRequired_single: ProtobufUnittest_TestRequired { - get {return getExtensionValue(ext: ProtobufUnittest_TestRequired.Extensions.single) ?? ProtobufUnittest_TestRequired()} - set {setExtensionValue(ext: ProtobufUnittest_TestRequired.Extensions.single, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestRequired.Extensions.single` - /// has been explicitly set. - var hasProtobufUnittest_TestRequired_single: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestRequired.Extensions.single) - } - /// Clears the value of extension `ProtobufUnittest_TestRequired.Extensions.single`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestRequired_single() { - clearExtensionValue(ext: ProtobufUnittest_TestRequired.Extensions.single) - } - - var ProtobufUnittest_TestRequired_multi: [ProtobufUnittest_TestRequired] { - get {return getExtensionValue(ext: ProtobufUnittest_TestRequired.Extensions.multi) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_TestRequired.Extensions.multi, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestRequired.Extensions.multi` - /// has been explicitly set. - var hasProtobufUnittest_TestRequired_multi: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestRequired.Extensions.multi) - } - /// Clears the value of extension `ProtobufUnittest_TestRequired.Extensions.multi`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestRequired_multi() { - clearExtensionValue(ext: ProtobufUnittest_TestRequired.Extensions.multi) - } -} - -extension ProtobufUnittest_TestExtensionInsideTable { - - var ProtobufUnittest_testExtensionInsideTableExtension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_test_extension_inside_table_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_test_extension_inside_table_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_test_extension_inside_table_extension` - /// has been explicitly set. - var hasProtobufUnittest_testExtensionInsideTableExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_test_extension_inside_table_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_test_extension_inside_table_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_testExtensionInsideTableExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_test_extension_inside_table_extension) - } -} - -extension ProtobufUnittest_TestExtensionRangeSerialize { - - var ProtobufUnittest_TestExtensionRangeSerialize_barOne: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_one) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_one, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_one` - /// has been explicitly set. - var hasProtobufUnittest_TestExtensionRangeSerialize_barOne: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_one) - } - /// Clears the value of extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_one`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestExtensionRangeSerialize_barOne() { - clearExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_one) - } - - var ProtobufUnittest_TestExtensionRangeSerialize_barTwo: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_two) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_two, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_two` - /// has been explicitly set. - var hasProtobufUnittest_TestExtensionRangeSerialize_barTwo: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_two) - } - /// Clears the value of extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_two`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestExtensionRangeSerialize_barTwo() { - clearExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_two) - } - - var ProtobufUnittest_TestExtensionRangeSerialize_barThree: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_three) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_three, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_three` - /// has been explicitly set. - var hasProtobufUnittest_TestExtensionRangeSerialize_barThree: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_three) - } - /// Clears the value of extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_three`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestExtensionRangeSerialize_barThree() { - clearExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_three) - } - - var ProtobufUnittest_TestExtensionRangeSerialize_barFour: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_four) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_four, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_four` - /// has been explicitly set. - var hasProtobufUnittest_TestExtensionRangeSerialize_barFour: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_four) - } - /// Clears the value of extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_four`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestExtensionRangeSerialize_barFour() { - clearExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_four) - } - - var ProtobufUnittest_TestExtensionRangeSerialize_barFive: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_five) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_five, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_five` - /// has been explicitly set. - var hasProtobufUnittest_TestExtensionRangeSerialize_barFive: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_five) - } - /// Clears the value of extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_five`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestExtensionRangeSerialize_barFive() { - clearExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_five) - } -} - -extension ProtobufUnittest_TestFieldOrderings { - - var ProtobufUnittest_myExtensionString: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_my_extension_string) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_my_extension_string, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_my_extension_string` - /// has been explicitly set. - var hasProtobufUnittest_myExtensionString: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_my_extension_string) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_my_extension_string`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_myExtensionString() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_my_extension_string) - } - - var ProtobufUnittest_myExtensionInt: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_my_extension_int) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_my_extension_int, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_my_extension_int` - /// has been explicitly set. - var hasProtobufUnittest_myExtensionInt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_my_extension_int) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_my_extension_int`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_myExtensionInt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_my_extension_int) - } - - var ProtobufUnittest_TestExtensionOrderings1_testExtOrderings1: ProtobufUnittest_TestExtensionOrderings1 { - get {return getExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1) ?? ProtobufUnittest_TestExtensionOrderings1()} - set {setExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1` - /// has been explicitly set. - var hasProtobufUnittest_TestExtensionOrderings1_testExtOrderings1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1) - } - /// Clears the value of extension `ProtobufUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestExtensionOrderings1_testExtOrderings1() { - clearExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1) - } - - var ProtobufUnittest_TestExtensionOrderings2_testExtOrderings2: ProtobufUnittest_TestExtensionOrderings2 { - get {return getExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2) ?? ProtobufUnittest_TestExtensionOrderings2()} - set {setExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2` - /// has been explicitly set. - var hasProtobufUnittest_TestExtensionOrderings2_testExtOrderings2: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2) - } - /// Clears the value of extension `ProtobufUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestExtensionOrderings2_testExtOrderings2() { - clearExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2) - } - - var ProtobufUnittest_TestExtensionOrderings2_TestExtensionOrderings3_testExtOrderings3: ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3 { - get {return getExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3) ?? ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3()} - set {setExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3` - /// has been explicitly set. - var hasProtobufUnittest_TestExtensionOrderings2_TestExtensionOrderings3_testExtOrderings3: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3) - } - /// Clears the value of extension `ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestExtensionOrderings2_TestExtensionOrderings3_testExtOrderings3() { - clearExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3) - } -} - -extension ProtobufUnittest_TestGroupExtension { - - var ProtobufUnittest_TestNestedExtension_optionalGroupExtension: ProtobufUnittest_TestNestedExtension.OptionalGroup_extension { - get {return getExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.OptionalGroup_extension) ?? ProtobufUnittest_TestNestedExtension.OptionalGroup_extension()} - set {setExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.OptionalGroup_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestNestedExtension.Extensions.OptionalGroup_extension` - /// has been explicitly set. - var hasProtobufUnittest_TestNestedExtension_optionalGroupExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.OptionalGroup_extension) - } - /// Clears the value of extension `ProtobufUnittest_TestNestedExtension.Extensions.OptionalGroup_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestNestedExtension_optionalGroupExtension() { - clearExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.OptionalGroup_extension) - } - - var ProtobufUnittest_TestNestedExtension_optionalForeignEnumExtension: ProtobufUnittest_ForeignEnum { - get {return getExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension) ?? .foreignFoo} - set {setExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_TestNestedExtension_optionalForeignEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestNestedExtension_optionalForeignEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension) - } -} - -extension ProtobufUnittest_TestHugeFieldNumbers { - - var ProtobufUnittest_testAllTypes: ProtobufUnittest_TestAllTypes { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_test_all_types) ?? ProtobufUnittest_TestAllTypes()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_test_all_types, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_test_all_types` - /// has been explicitly set. - var hasProtobufUnittest_testAllTypes: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_test_all_types) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_test_all_types`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_testAllTypes() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_test_all_types) - } -} - -extension ProtobufUnittest_TestPackedExtensions { - - var ProtobufUnittest_packedInt32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_int32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_int32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_int32_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedInt32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_int32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_int32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedInt32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_int32_extension) - } - - var ProtobufUnittest_packedInt64Extension: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_int64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_int64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_int64_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedInt64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_int64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_int64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedInt64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_int64_extension) - } - - var ProtobufUnittest_packedUint32Extension: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_uint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedUint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_uint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedUint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint32_extension) - } - - var ProtobufUnittest_packedUint64Extension: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_uint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedUint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_uint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedUint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint64_extension) - } - - var ProtobufUnittest_packedSint32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_sint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedSint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_sint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedSint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint32_extension) - } - - var ProtobufUnittest_packedSint64Extension: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_sint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedSint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_sint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedSint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint64_extension) - } - - var ProtobufUnittest_packedFixed32Extension: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_fixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedFixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_fixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedFixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed32_extension) - } - - var ProtobufUnittest_packedFixed64Extension: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_fixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedFixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_fixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedFixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed64_extension) - } - - var ProtobufUnittest_packedSfixed32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_sfixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedSfixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_sfixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedSfixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed32_extension) - } - - var ProtobufUnittest_packedSfixed64Extension: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_sfixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedSfixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_sfixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedSfixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed64_extension) - } - - var ProtobufUnittest_packedFloatExtension: [Float] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_float_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_float_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_float_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedFloatExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_float_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_float_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedFloatExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_float_extension) - } - - var ProtobufUnittest_packedDoubleExtension: [Double] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_double_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_double_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_double_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedDoubleExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_double_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_double_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedDoubleExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_double_extension) - } - - var ProtobufUnittest_packedBoolExtension: [Bool] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_bool_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_bool_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_bool_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedBoolExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_bool_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_bool_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedBoolExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_bool_extension) - } - - var ProtobufUnittest_packedEnumExtension: [ProtobufUnittest_ForeignEnum] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_enum_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_enum_extension) - } -} - -extension ProtobufUnittest_TestParsingMerge { - - var ProtobufUnittest_TestParsingMerge_optionalExt: ProtobufUnittest_TestAllTypes { - get {return getExtensionValue(ext: ProtobufUnittest_TestParsingMerge.Extensions.optional_ext) ?? ProtobufUnittest_TestAllTypes()} - set {setExtensionValue(ext: ProtobufUnittest_TestParsingMerge.Extensions.optional_ext, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestParsingMerge.Extensions.optional_ext` - /// has been explicitly set. - var hasProtobufUnittest_TestParsingMerge_optionalExt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestParsingMerge.Extensions.optional_ext) - } - /// Clears the value of extension `ProtobufUnittest_TestParsingMerge.Extensions.optional_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestParsingMerge_optionalExt() { - clearExtensionValue(ext: ProtobufUnittest_TestParsingMerge.Extensions.optional_ext) - } - - var ProtobufUnittest_TestParsingMerge_repeatedExt: [ProtobufUnittest_TestAllTypes] { - get {return getExtensionValue(ext: ProtobufUnittest_TestParsingMerge.Extensions.repeated_ext) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_TestParsingMerge.Extensions.repeated_ext, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestParsingMerge.Extensions.repeated_ext` - /// has been explicitly set. - var hasProtobufUnittest_TestParsingMerge_repeatedExt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestParsingMerge.Extensions.repeated_ext) - } - /// Clears the value of extension `ProtobufUnittest_TestParsingMerge.Extensions.repeated_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestParsingMerge_repeatedExt() { - clearExtensionValue(ext: ProtobufUnittest_TestParsingMerge.Extensions.repeated_ext) - } -} - -extension ProtobufUnittest_TestUnpackedExtensions { - - var ProtobufUnittest_unpackedInt32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_int32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_int32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_int32_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedInt32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_int32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_int32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedInt32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_int32_extension) - } - - var ProtobufUnittest_unpackedInt64Extension: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_int64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_int64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_int64_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedInt64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_int64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_int64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedInt64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_int64_extension) - } - - var ProtobufUnittest_unpackedUint32Extension: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_uint32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_uint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_uint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedUint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_uint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_uint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedUint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_uint32_extension) - } - - var ProtobufUnittest_unpackedUint64Extension: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_uint64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_uint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_uint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedUint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_uint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_uint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedUint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_uint64_extension) - } - - var ProtobufUnittest_unpackedSint32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sint32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_sint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedSint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_sint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedSint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sint32_extension) - } - - var ProtobufUnittest_unpackedSint64Extension: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sint64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_sint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedSint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_sint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedSint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sint64_extension) - } - - var ProtobufUnittest_unpackedFixed32Extension: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_fixed32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_fixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_fixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedFixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_fixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_fixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedFixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_fixed32_extension) - } - - var ProtobufUnittest_unpackedFixed64Extension: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_fixed64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_fixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_fixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedFixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_fixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_fixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedFixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_fixed64_extension) - } - - var ProtobufUnittest_unpackedSfixed32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sfixed32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sfixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_sfixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedSfixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sfixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_sfixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedSfixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sfixed32_extension) - } - - var ProtobufUnittest_unpackedSfixed64Extension: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sfixed64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sfixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_sfixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedSfixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sfixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_sfixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedSfixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sfixed64_extension) - } - - var ProtobufUnittest_unpackedFloatExtension: [Float] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_float_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_float_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_float_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedFloatExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_float_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_float_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedFloatExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_float_extension) - } - - var ProtobufUnittest_unpackedDoubleExtension: [Double] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_double_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_double_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_double_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedDoubleExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_double_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_double_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedDoubleExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_double_extension) - } - - var ProtobufUnittest_unpackedBoolExtension: [Bool] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_bool_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_bool_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_bool_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedBoolExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_bool_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_bool_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedBoolExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_bool_extension) - } - - var ProtobufUnittest_unpackedEnumExtension: [ProtobufUnittest_ForeignEnum] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_enum_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_enum_extension) - } - -} - -// MARK: - File's ExtensionMap: ProtobufUnittest_Unittest_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 ProtobufUnittest_Unittest_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_Extensions_optional_int32_extension, - ProtobufUnittest_Extensions_optional_int64_extension, - ProtobufUnittest_Extensions_optional_uint32_extension, - ProtobufUnittest_Extensions_optional_uint64_extension, - ProtobufUnittest_Extensions_optional_sint32_extension, - ProtobufUnittest_Extensions_optional_sint64_extension, - ProtobufUnittest_Extensions_optional_fixed32_extension, - ProtobufUnittest_Extensions_optional_fixed64_extension, - ProtobufUnittest_Extensions_optional_sfixed32_extension, - ProtobufUnittest_Extensions_optional_sfixed64_extension, - ProtobufUnittest_Extensions_optional_float_extension, - ProtobufUnittest_Extensions_optional_double_extension, - ProtobufUnittest_Extensions_optional_bool_extension, - ProtobufUnittest_Extensions_optional_string_extension, - ProtobufUnittest_Extensions_optional_bytes_extension, - ProtobufUnittest_Extensions_OptionalGroup_extension, - ProtobufUnittest_Extensions_optional_nested_message_extension, - ProtobufUnittest_Extensions_optional_foreign_message_extension, - ProtobufUnittest_Extensions_optional_import_message_extension, - ProtobufUnittest_Extensions_optional_nested_enum_extension, - ProtobufUnittest_Extensions_optional_foreign_enum_extension, - ProtobufUnittest_Extensions_optional_import_enum_extension, - ProtobufUnittest_Extensions_optional_string_piece_extension, - ProtobufUnittest_Extensions_optional_cord_extension, - ProtobufUnittest_Extensions_optional_public_import_message_extension, - ProtobufUnittest_Extensions_optional_lazy_message_extension, - ProtobufUnittest_Extensions_repeated_int32_extension, - ProtobufUnittest_Extensions_repeated_int64_extension, - ProtobufUnittest_Extensions_repeated_uint32_extension, - ProtobufUnittest_Extensions_repeated_uint64_extension, - ProtobufUnittest_Extensions_repeated_sint32_extension, - ProtobufUnittest_Extensions_repeated_sint64_extension, - ProtobufUnittest_Extensions_repeated_fixed32_extension, - ProtobufUnittest_Extensions_repeated_fixed64_extension, - ProtobufUnittest_Extensions_repeated_sfixed32_extension, - ProtobufUnittest_Extensions_repeated_sfixed64_extension, - ProtobufUnittest_Extensions_repeated_float_extension, - ProtobufUnittest_Extensions_repeated_double_extension, - ProtobufUnittest_Extensions_repeated_bool_extension, - ProtobufUnittest_Extensions_repeated_string_extension, - ProtobufUnittest_Extensions_repeated_bytes_extension, - ProtobufUnittest_Extensions_RepeatedGroup_extension, - ProtobufUnittest_Extensions_repeated_nested_message_extension, - ProtobufUnittest_Extensions_repeated_foreign_message_extension, - ProtobufUnittest_Extensions_repeated_import_message_extension, - ProtobufUnittest_Extensions_repeated_nested_enum_extension, - ProtobufUnittest_Extensions_repeated_foreign_enum_extension, - ProtobufUnittest_Extensions_repeated_import_enum_extension, - ProtobufUnittest_Extensions_repeated_string_piece_extension, - ProtobufUnittest_Extensions_repeated_cord_extension, - ProtobufUnittest_Extensions_repeated_lazy_message_extension, - ProtobufUnittest_Extensions_default_int32_extension, - ProtobufUnittest_Extensions_default_int64_extension, - ProtobufUnittest_Extensions_default_uint32_extension, - ProtobufUnittest_Extensions_default_uint64_extension, - ProtobufUnittest_Extensions_default_sint32_extension, - ProtobufUnittest_Extensions_default_sint64_extension, - ProtobufUnittest_Extensions_default_fixed32_extension, - ProtobufUnittest_Extensions_default_fixed64_extension, - ProtobufUnittest_Extensions_default_sfixed32_extension, - ProtobufUnittest_Extensions_default_sfixed64_extension, - ProtobufUnittest_Extensions_default_float_extension, - ProtobufUnittest_Extensions_default_double_extension, - ProtobufUnittest_Extensions_default_bool_extension, - ProtobufUnittest_Extensions_default_string_extension, - ProtobufUnittest_Extensions_default_bytes_extension, - ProtobufUnittest_Extensions_default_nested_enum_extension, - ProtobufUnittest_Extensions_default_foreign_enum_extension, - ProtobufUnittest_Extensions_default_import_enum_extension, - ProtobufUnittest_Extensions_default_string_piece_extension, - ProtobufUnittest_Extensions_default_cord_extension, - ProtobufUnittest_Extensions_oneof_uint32_extension, - ProtobufUnittest_Extensions_oneof_nested_message_extension, - ProtobufUnittest_Extensions_oneof_string_extension, - ProtobufUnittest_Extensions_oneof_bytes_extension, - ProtobufUnittest_Extensions_my_extension_string, - ProtobufUnittest_Extensions_my_extension_int, - ProtobufUnittest_Extensions_packed_int32_extension, - ProtobufUnittest_Extensions_packed_int64_extension, - ProtobufUnittest_Extensions_packed_uint32_extension, - ProtobufUnittest_Extensions_packed_uint64_extension, - ProtobufUnittest_Extensions_packed_sint32_extension, - ProtobufUnittest_Extensions_packed_sint64_extension, - ProtobufUnittest_Extensions_packed_fixed32_extension, - ProtobufUnittest_Extensions_packed_fixed64_extension, - ProtobufUnittest_Extensions_packed_sfixed32_extension, - ProtobufUnittest_Extensions_packed_sfixed64_extension, - ProtobufUnittest_Extensions_packed_float_extension, - ProtobufUnittest_Extensions_packed_double_extension, - ProtobufUnittest_Extensions_packed_bool_extension, - ProtobufUnittest_Extensions_packed_enum_extension, - ProtobufUnittest_Extensions_unpacked_int32_extension, - ProtobufUnittest_Extensions_unpacked_int64_extension, - ProtobufUnittest_Extensions_unpacked_uint32_extension, - ProtobufUnittest_Extensions_unpacked_uint64_extension, - ProtobufUnittest_Extensions_unpacked_sint32_extension, - ProtobufUnittest_Extensions_unpacked_sint64_extension, - ProtobufUnittest_Extensions_unpacked_fixed32_extension, - ProtobufUnittest_Extensions_unpacked_fixed64_extension, - ProtobufUnittest_Extensions_unpacked_sfixed32_extension, - ProtobufUnittest_Extensions_unpacked_sfixed64_extension, - ProtobufUnittest_Extensions_unpacked_float_extension, - ProtobufUnittest_Extensions_unpacked_double_extension, - ProtobufUnittest_Extensions_unpacked_bool_extension, - ProtobufUnittest_Extensions_unpacked_enum_extension, - ProtobufUnittest_Extensions_test_all_types, - ProtobufUnittest_Extensions_test_extension_inside_table_extension, - ProtobufUnittest_TestNestedExtension.Extensions.test, - ProtobufUnittest_TestNestedExtension.Extensions.nested_string_extension, - ProtobufUnittest_TestNestedExtension.Extensions.OptionalGroup_extension, - ProtobufUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension, - ProtobufUnittest_TestRequired.Extensions.single, - ProtobufUnittest_TestRequired.Extensions.multi, - ProtobufUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1, - ProtobufUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2, - ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3, - ProtobufUnittest_TestParsingMerge.Extensions.optional_ext, - ProtobufUnittest_TestParsingMerge.Extensions.repeated_ext, - ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_one, - ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_two, - ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_three, - ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_four, - ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_five -] - -// 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. - -/// Singular -let ProtobufUnittest_Extensions_optional_int32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 1, - fieldName: "protobuf_unittest.optional_int32_extension" -) - -let ProtobufUnittest_Extensions_optional_int64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 2, - fieldName: "protobuf_unittest.optional_int64_extension" -) - -let ProtobufUnittest_Extensions_optional_uint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 3, - fieldName: "protobuf_unittest.optional_uint32_extension" -) - -let ProtobufUnittest_Extensions_optional_uint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 4, - fieldName: "protobuf_unittest.optional_uint64_extension" -) - -let ProtobufUnittest_Extensions_optional_sint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 5, - fieldName: "protobuf_unittest.optional_sint32_extension" -) - -let ProtobufUnittest_Extensions_optional_sint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 6, - fieldName: "protobuf_unittest.optional_sint64_extension" -) - -let ProtobufUnittest_Extensions_optional_fixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 7, - fieldName: "protobuf_unittest.optional_fixed32_extension" -) - -let ProtobufUnittest_Extensions_optional_fixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 8, - fieldName: "protobuf_unittest.optional_fixed64_extension" -) - -let ProtobufUnittest_Extensions_optional_sfixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 9, - fieldName: "protobuf_unittest.optional_sfixed32_extension" -) - -let ProtobufUnittest_Extensions_optional_sfixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 10, - fieldName: "protobuf_unittest.optional_sfixed64_extension" -) - -let ProtobufUnittest_Extensions_optional_float_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 11, - fieldName: "protobuf_unittest.optional_float_extension" -) - -let ProtobufUnittest_Extensions_optional_double_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 12, - fieldName: "protobuf_unittest.optional_double_extension" -) - -let ProtobufUnittest_Extensions_optional_bool_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 13, - fieldName: "protobuf_unittest.optional_bool_extension" -) - -let ProtobufUnittest_Extensions_optional_string_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 14, - fieldName: "protobuf_unittest.optional_string_extension" -) - -let ProtobufUnittest_Extensions_optional_bytes_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 15, - fieldName: "protobuf_unittest.optional_bytes_extension" -) - -let ProtobufUnittest_Extensions_OptionalGroup_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 16, - fieldName: "protobuf_unittest.optionalgroup_extension" -) - -let ProtobufUnittest_Extensions_optional_nested_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 18, - fieldName: "protobuf_unittest.optional_nested_message_extension" -) - -let ProtobufUnittest_Extensions_optional_foreign_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 19, - fieldName: "protobuf_unittest.optional_foreign_message_extension" -) - -let ProtobufUnittest_Extensions_optional_import_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 20, - fieldName: "protobuf_unittest.optional_import_message_extension" -) - -let ProtobufUnittest_Extensions_optional_nested_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 21, - fieldName: "protobuf_unittest.optional_nested_enum_extension" -) - -let ProtobufUnittest_Extensions_optional_foreign_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 22, - fieldName: "protobuf_unittest.optional_foreign_enum_extension" -) - -let ProtobufUnittest_Extensions_optional_import_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 23, - fieldName: "protobuf_unittest.optional_import_enum_extension" -) - -let ProtobufUnittest_Extensions_optional_string_piece_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 24, - fieldName: "protobuf_unittest.optional_string_piece_extension" -) - -let ProtobufUnittest_Extensions_optional_cord_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 25, - fieldName: "protobuf_unittest.optional_cord_extension" -) - -let ProtobufUnittest_Extensions_optional_public_import_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 26, - fieldName: "protobuf_unittest.optional_public_import_message_extension" -) - -let ProtobufUnittest_Extensions_optional_lazy_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 27, - fieldName: "protobuf_unittest.optional_lazy_message_extension" -) - -/// Repeated -let ProtobufUnittest_Extensions_repeated_int32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 31, - fieldName: "protobuf_unittest.repeated_int32_extension" -) - -let ProtobufUnittest_Extensions_repeated_int64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 32, - fieldName: "protobuf_unittest.repeated_int64_extension" -) - -let ProtobufUnittest_Extensions_repeated_uint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 33, - fieldName: "protobuf_unittest.repeated_uint32_extension" -) - -let ProtobufUnittest_Extensions_repeated_uint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 34, - fieldName: "protobuf_unittest.repeated_uint64_extension" -) - -let ProtobufUnittest_Extensions_repeated_sint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 35, - fieldName: "protobuf_unittest.repeated_sint32_extension" -) - -let ProtobufUnittest_Extensions_repeated_sint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 36, - fieldName: "protobuf_unittest.repeated_sint64_extension" -) - -let ProtobufUnittest_Extensions_repeated_fixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 37, - fieldName: "protobuf_unittest.repeated_fixed32_extension" -) - -let ProtobufUnittest_Extensions_repeated_fixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 38, - fieldName: "protobuf_unittest.repeated_fixed64_extension" -) - -let ProtobufUnittest_Extensions_repeated_sfixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 39, - fieldName: "protobuf_unittest.repeated_sfixed32_extension" -) - -let ProtobufUnittest_Extensions_repeated_sfixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 40, - fieldName: "protobuf_unittest.repeated_sfixed64_extension" -) - -let ProtobufUnittest_Extensions_repeated_float_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 41, - fieldName: "protobuf_unittest.repeated_float_extension" -) - -let ProtobufUnittest_Extensions_repeated_double_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 42, - fieldName: "protobuf_unittest.repeated_double_extension" -) - -let ProtobufUnittest_Extensions_repeated_bool_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 43, - fieldName: "protobuf_unittest.repeated_bool_extension" -) - -let ProtobufUnittest_Extensions_repeated_string_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 44, - fieldName: "protobuf_unittest.repeated_string_extension" -) - -let ProtobufUnittest_Extensions_repeated_bytes_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 45, - fieldName: "protobuf_unittest.repeated_bytes_extension" -) - -let ProtobufUnittest_Extensions_RepeatedGroup_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 46, - fieldName: "protobuf_unittest.repeatedgroup_extension" -) - -let ProtobufUnittest_Extensions_repeated_nested_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 48, - fieldName: "protobuf_unittest.repeated_nested_message_extension" -) - -let ProtobufUnittest_Extensions_repeated_foreign_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 49, - fieldName: "protobuf_unittest.repeated_foreign_message_extension" -) - -let ProtobufUnittest_Extensions_repeated_import_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 50, - fieldName: "protobuf_unittest.repeated_import_message_extension" -) - -let ProtobufUnittest_Extensions_repeated_nested_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 51, - fieldName: "protobuf_unittest.repeated_nested_enum_extension" -) - -let ProtobufUnittest_Extensions_repeated_foreign_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 52, - fieldName: "protobuf_unittest.repeated_foreign_enum_extension" -) - -let ProtobufUnittest_Extensions_repeated_import_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 53, - fieldName: "protobuf_unittest.repeated_import_enum_extension" -) - -let ProtobufUnittest_Extensions_repeated_string_piece_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 54, - fieldName: "protobuf_unittest.repeated_string_piece_extension" -) - -let ProtobufUnittest_Extensions_repeated_cord_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 55, - fieldName: "protobuf_unittest.repeated_cord_extension" -) - -let ProtobufUnittest_Extensions_repeated_lazy_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 57, - fieldName: "protobuf_unittest.repeated_lazy_message_extension" -) - -/// Singular with defaults -let ProtobufUnittest_Extensions_default_int32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 61, - fieldName: "protobuf_unittest.default_int32_extension" -) - -let ProtobufUnittest_Extensions_default_int64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 62, - fieldName: "protobuf_unittest.default_int64_extension" -) - -let ProtobufUnittest_Extensions_default_uint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 63, - fieldName: "protobuf_unittest.default_uint32_extension" -) - -let ProtobufUnittest_Extensions_default_uint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 64, - fieldName: "protobuf_unittest.default_uint64_extension" -) - -let ProtobufUnittest_Extensions_default_sint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 65, - fieldName: "protobuf_unittest.default_sint32_extension" -) - -let ProtobufUnittest_Extensions_default_sint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 66, - fieldName: "protobuf_unittest.default_sint64_extension" -) - -let ProtobufUnittest_Extensions_default_fixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 67, - fieldName: "protobuf_unittest.default_fixed32_extension" -) - -let ProtobufUnittest_Extensions_default_fixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 68, - fieldName: "protobuf_unittest.default_fixed64_extension" -) - -let ProtobufUnittest_Extensions_default_sfixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 69, - fieldName: "protobuf_unittest.default_sfixed32_extension" -) - -let ProtobufUnittest_Extensions_default_sfixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 70, - fieldName: "protobuf_unittest.default_sfixed64_extension" -) - -let ProtobufUnittest_Extensions_default_float_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 71, - fieldName: "protobuf_unittest.default_float_extension" -) - -let ProtobufUnittest_Extensions_default_double_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 72, - fieldName: "protobuf_unittest.default_double_extension" -) - -let ProtobufUnittest_Extensions_default_bool_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 73, - fieldName: "protobuf_unittest.default_bool_extension" -) - -let ProtobufUnittest_Extensions_default_string_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 74, - fieldName: "protobuf_unittest.default_string_extension" -) - -let ProtobufUnittest_Extensions_default_bytes_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 75, - fieldName: "protobuf_unittest.default_bytes_extension" -) - -let ProtobufUnittest_Extensions_default_nested_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 81, - fieldName: "protobuf_unittest.default_nested_enum_extension" -) - -let ProtobufUnittest_Extensions_default_foreign_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 82, - fieldName: "protobuf_unittest.default_foreign_enum_extension" -) - -let ProtobufUnittest_Extensions_default_import_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 83, - fieldName: "protobuf_unittest.default_import_enum_extension" -) - -let ProtobufUnittest_Extensions_default_string_piece_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 84, - fieldName: "protobuf_unittest.default_string_piece_extension" -) - -let ProtobufUnittest_Extensions_default_cord_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 85, - fieldName: "protobuf_unittest.default_cord_extension" -) - -/// For oneof test -let ProtobufUnittest_Extensions_oneof_uint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 111, - fieldName: "protobuf_unittest.oneof_uint32_extension" -) - -let ProtobufUnittest_Extensions_oneof_nested_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 112, - fieldName: "protobuf_unittest.oneof_nested_message_extension" -) - -let ProtobufUnittest_Extensions_oneof_string_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 113, - fieldName: "protobuf_unittest.oneof_string_extension" -) - -let ProtobufUnittest_Extensions_oneof_bytes_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 114, - fieldName: "protobuf_unittest.oneof_bytes_extension" -) - -let ProtobufUnittest_Extensions_my_extension_string = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestFieldOrderings>( - _protobuf_fieldNumber: 50, - fieldName: "protobuf_unittest.my_extension_string" -) - -let ProtobufUnittest_Extensions_my_extension_int = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestFieldOrderings>( - _protobuf_fieldNumber: 5, - fieldName: "protobuf_unittest.my_extension_int" -) - -let ProtobufUnittest_Extensions_packed_int32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 90, - fieldName: "protobuf_unittest.packed_int32_extension" -) - -let ProtobufUnittest_Extensions_packed_int64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 91, - fieldName: "protobuf_unittest.packed_int64_extension" -) - -let ProtobufUnittest_Extensions_packed_uint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 92, - fieldName: "protobuf_unittest.packed_uint32_extension" -) - -let ProtobufUnittest_Extensions_packed_uint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 93, - fieldName: "protobuf_unittest.packed_uint64_extension" -) - -let ProtobufUnittest_Extensions_packed_sint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 94, - fieldName: "protobuf_unittest.packed_sint32_extension" -) - -let ProtobufUnittest_Extensions_packed_sint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 95, - fieldName: "protobuf_unittest.packed_sint64_extension" -) - -let ProtobufUnittest_Extensions_packed_fixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 96, - fieldName: "protobuf_unittest.packed_fixed32_extension" -) - -let ProtobufUnittest_Extensions_packed_fixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 97, - fieldName: "protobuf_unittest.packed_fixed64_extension" -) - -let ProtobufUnittest_Extensions_packed_sfixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 98, - fieldName: "protobuf_unittest.packed_sfixed32_extension" -) - -let ProtobufUnittest_Extensions_packed_sfixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 99, - fieldName: "protobuf_unittest.packed_sfixed64_extension" -) - -let ProtobufUnittest_Extensions_packed_float_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 100, - fieldName: "protobuf_unittest.packed_float_extension" -) - -let ProtobufUnittest_Extensions_packed_double_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 101, - fieldName: "protobuf_unittest.packed_double_extension" -) - -let ProtobufUnittest_Extensions_packed_bool_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 102, - fieldName: "protobuf_unittest.packed_bool_extension" -) - -let ProtobufUnittest_Extensions_packed_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 103, - fieldName: "protobuf_unittest.packed_enum_extension" -) - -let ProtobufUnittest_Extensions_unpacked_int32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 90, - fieldName: "protobuf_unittest.unpacked_int32_extension" -) - -let ProtobufUnittest_Extensions_unpacked_int64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 91, - fieldName: "protobuf_unittest.unpacked_int64_extension" -) - -let ProtobufUnittest_Extensions_unpacked_uint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 92, - fieldName: "protobuf_unittest.unpacked_uint32_extension" -) - -let ProtobufUnittest_Extensions_unpacked_uint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 93, - fieldName: "protobuf_unittest.unpacked_uint64_extension" -) - -let ProtobufUnittest_Extensions_unpacked_sint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 94, - fieldName: "protobuf_unittest.unpacked_sint32_extension" -) - -let ProtobufUnittest_Extensions_unpacked_sint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 95, - fieldName: "protobuf_unittest.unpacked_sint64_extension" -) - -let ProtobufUnittest_Extensions_unpacked_fixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 96, - fieldName: "protobuf_unittest.unpacked_fixed32_extension" -) - -let ProtobufUnittest_Extensions_unpacked_fixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 97, - fieldName: "protobuf_unittest.unpacked_fixed64_extension" -) - -let ProtobufUnittest_Extensions_unpacked_sfixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 98, - fieldName: "protobuf_unittest.unpacked_sfixed32_extension" -) - -let ProtobufUnittest_Extensions_unpacked_sfixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 99, - fieldName: "protobuf_unittest.unpacked_sfixed64_extension" -) - -let ProtobufUnittest_Extensions_unpacked_float_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 100, - fieldName: "protobuf_unittest.unpacked_float_extension" -) - -let ProtobufUnittest_Extensions_unpacked_double_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 101, - fieldName: "protobuf_unittest.unpacked_double_extension" -) - -let ProtobufUnittest_Extensions_unpacked_bool_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 102, - fieldName: "protobuf_unittest.unpacked_bool_extension" -) - -let ProtobufUnittest_Extensions_unpacked_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 103, - fieldName: "protobuf_unittest.unpacked_enum_extension" -) - -let ProtobufUnittest_Extensions_test_all_types = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestHugeFieldNumbers>( - _protobuf_fieldNumber: 536860000, - fieldName: "protobuf_unittest.test_all_types" -) - -let ProtobufUnittest_Extensions_test_extension_inside_table_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestExtensionInsideTable>( - _protobuf_fieldNumber: 5, - fieldName: "protobuf_unittest.test_extension_inside_table_extension" -) - -extension ProtobufUnittest_TestNestedExtension { - enum Extensions { - /// Check for bug where string extensions declared in tested scope did not - /// compile. - static let test = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 1002, - fieldName: "protobuf_unittest.TestNestedExtension.test" - ) - - /// Used to test if generated extension name is correct when there are - /// underscores. - static let nested_string_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 1003, - fieldName: "protobuf_unittest.TestNestedExtension.nested_string_extension" - ) - - static let OptionalGroup_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestGroupExtension>( - _protobuf_fieldNumber: 16, - fieldName: "protobuf_unittest.TestNestedExtension.optionalgroup_extension" - ) - - static let optional_foreign_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestGroupExtension>( - _protobuf_fieldNumber: 22, - fieldName: "protobuf_unittest.TestNestedExtension.optional_foreign_enum_extension" - ) - } -} - -extension ProtobufUnittest_TestRequired { - enum Extensions { - static let single = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 1000, - fieldName: "protobuf_unittest.TestRequired.single" - ) - - static let multi = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 1001, - fieldName: "protobuf_unittest.TestRequired.multi" - ) - } -} - -extension ProtobufUnittest_TestExtensionOrderings1 { - enum Extensions { - static let test_ext_orderings1 = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestFieldOrderings>( - _protobuf_fieldNumber: 13, - fieldName: "protobuf_unittest.TestExtensionOrderings1.test_ext_orderings1" - ) - } -} - -extension ProtobufUnittest_TestExtensionOrderings2 { - enum Extensions { - static let test_ext_orderings2 = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestFieldOrderings>( - _protobuf_fieldNumber: 12, - fieldName: "protobuf_unittest.TestExtensionOrderings2.test_ext_orderings2" - ) - } -} - -extension ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3 { - enum Extensions { - static let test_ext_orderings3 = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestFieldOrderings>( - _protobuf_fieldNumber: 14, - fieldName: "protobuf_unittest.TestExtensionOrderings2.TestExtensionOrderings3.test_ext_orderings3" - ) - } -} - -extension ProtobufUnittest_TestParsingMerge { - enum Extensions { - static let optional_ext = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestParsingMerge>( - _protobuf_fieldNumber: 1000, - fieldName: "protobuf_unittest.TestParsingMerge.optional_ext" - ) - - static let repeated_ext = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestParsingMerge>( - _protobuf_fieldNumber: 1001, - fieldName: "protobuf_unittest.TestParsingMerge.repeated_ext" - ) - } -} - -extension ProtobufUnittest_TestExtensionRangeSerialize { - enum Extensions { - static let bar_one = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestExtensionRangeSerialize>( - _protobuf_fieldNumber: 2, - fieldName: "protobuf_unittest.TestExtensionRangeSerialize.bar_one" - ) - - static let bar_two = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestExtensionRangeSerialize>( - _protobuf_fieldNumber: 4, - fieldName: "protobuf_unittest.TestExtensionRangeSerialize.bar_two" - ) - - static let bar_three = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestExtensionRangeSerialize>( - _protobuf_fieldNumber: 10, - fieldName: "protobuf_unittest.TestExtensionRangeSerialize.bar_three" - ) - - static let bar_four = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestExtensionRangeSerialize>( - _protobuf_fieldNumber: 15, - fieldName: "protobuf_unittest.TestExtensionRangeSerialize.bar_four" - ) - - static let bar_five = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestExtensionRangeSerialize>( - _protobuf_fieldNumber: 19, - fieldName: "protobuf_unittest.TestExtensionRangeSerialize.bar_five" - ) - } -} - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest" - -extension ProtobufUnittest_ForeignEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 4: .same(proto: "FOREIGN_FOO"), - 5: .same(proto: "FOREIGN_BAR"), - 6: .same(proto: "FOREIGN_BAZ"), - ] -} - -extension ProtobufUnittest_TestEnumWithDupValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .aliased(proto: "FOO1", aliases: ["FOO2"]), - 2: .aliased(proto: "BAR1", aliases: ["BAR2"]), - 3: .same(proto: "BAZ"), - ] -} - -extension ProtobufUnittest_TestSparseEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -53452: .same(proto: "SPARSE_E"), - -15: .same(proto: "SPARSE_D"), - 0: .same(proto: "SPARSE_F"), - 2: .same(proto: "SPARSE_G"), - 123: .same(proto: "SPARSE_A"), - 62374: .same(proto: "SPARSE_B"), - 12589234: .same(proto: "SPARSE_C"), - ] -} - -extension ProtobufUnittest_VeryLargeEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ENUM_LABEL_DEFAULT"), - 1: .same(proto: "ENUM_LABEL_1"), - 2: .same(proto: "ENUM_LABEL_2"), - 3: .same(proto: "ENUM_LABEL_3"), - 4: .same(proto: "ENUM_LABEL_4"), - 5: .same(proto: "ENUM_LABEL_5"), - 6: .same(proto: "ENUM_LABEL_6"), - 7: .same(proto: "ENUM_LABEL_7"), - 8: .same(proto: "ENUM_LABEL_8"), - 9: .same(proto: "ENUM_LABEL_9"), - 10: .same(proto: "ENUM_LABEL_10"), - 11: .same(proto: "ENUM_LABEL_11"), - 12: .same(proto: "ENUM_LABEL_12"), - 13: .same(proto: "ENUM_LABEL_13"), - 14: .same(proto: "ENUM_LABEL_14"), - 15: .same(proto: "ENUM_LABEL_15"), - 16: .same(proto: "ENUM_LABEL_16"), - 17: .same(proto: "ENUM_LABEL_17"), - 18: .same(proto: "ENUM_LABEL_18"), - 19: .same(proto: "ENUM_LABEL_19"), - 20: .same(proto: "ENUM_LABEL_20"), - 21: .same(proto: "ENUM_LABEL_21"), - 22: .same(proto: "ENUM_LABEL_22"), - 23: .same(proto: "ENUM_LABEL_23"), - 24: .same(proto: "ENUM_LABEL_24"), - 25: .same(proto: "ENUM_LABEL_25"), - 26: .same(proto: "ENUM_LABEL_26"), - 27: .same(proto: "ENUM_LABEL_27"), - 28: .same(proto: "ENUM_LABEL_28"), - 29: .same(proto: "ENUM_LABEL_29"), - 30: .same(proto: "ENUM_LABEL_30"), - 31: .same(proto: "ENUM_LABEL_31"), - 32: .same(proto: "ENUM_LABEL_32"), - 33: .same(proto: "ENUM_LABEL_33"), - 34: .same(proto: "ENUM_LABEL_34"), - 35: .same(proto: "ENUM_LABEL_35"), - 36: .same(proto: "ENUM_LABEL_36"), - 37: .same(proto: "ENUM_LABEL_37"), - 38: .same(proto: "ENUM_LABEL_38"), - 39: .same(proto: "ENUM_LABEL_39"), - 40: .same(proto: "ENUM_LABEL_40"), - 41: .same(proto: "ENUM_LABEL_41"), - 42: .same(proto: "ENUM_LABEL_42"), - 43: .same(proto: "ENUM_LABEL_43"), - 44: .same(proto: "ENUM_LABEL_44"), - 45: .same(proto: "ENUM_LABEL_45"), - 46: .same(proto: "ENUM_LABEL_46"), - 47: .same(proto: "ENUM_LABEL_47"), - 48: .same(proto: "ENUM_LABEL_48"), - 49: .same(proto: "ENUM_LABEL_49"), - 50: .same(proto: "ENUM_LABEL_50"), - 51: .same(proto: "ENUM_LABEL_51"), - 52: .same(proto: "ENUM_LABEL_52"), - 53: .same(proto: "ENUM_LABEL_53"), - 54: .same(proto: "ENUM_LABEL_54"), - 55: .same(proto: "ENUM_LABEL_55"), - 56: .same(proto: "ENUM_LABEL_56"), - 57: .same(proto: "ENUM_LABEL_57"), - 58: .same(proto: "ENUM_LABEL_58"), - 59: .same(proto: "ENUM_LABEL_59"), - 60: .same(proto: "ENUM_LABEL_60"), - 61: .same(proto: "ENUM_LABEL_61"), - 62: .same(proto: "ENUM_LABEL_62"), - 63: .same(proto: "ENUM_LABEL_63"), - 64: .same(proto: "ENUM_LABEL_64"), - 65: .same(proto: "ENUM_LABEL_65"), - 66: .same(proto: "ENUM_LABEL_66"), - 67: .same(proto: "ENUM_LABEL_67"), - 68: .same(proto: "ENUM_LABEL_68"), - 69: .same(proto: "ENUM_LABEL_69"), - 70: .same(proto: "ENUM_LABEL_70"), - 71: .same(proto: "ENUM_LABEL_71"), - 72: .same(proto: "ENUM_LABEL_72"), - 73: .same(proto: "ENUM_LABEL_73"), - 74: .same(proto: "ENUM_LABEL_74"), - 75: .same(proto: "ENUM_LABEL_75"), - 76: .same(proto: "ENUM_LABEL_76"), - 77: .same(proto: "ENUM_LABEL_77"), - 78: .same(proto: "ENUM_LABEL_78"), - 79: .same(proto: "ENUM_LABEL_79"), - 80: .same(proto: "ENUM_LABEL_80"), - 81: .same(proto: "ENUM_LABEL_81"), - 82: .same(proto: "ENUM_LABEL_82"), - 83: .same(proto: "ENUM_LABEL_83"), - 84: .same(proto: "ENUM_LABEL_84"), - 85: .same(proto: "ENUM_LABEL_85"), - 86: .same(proto: "ENUM_LABEL_86"), - 87: .same(proto: "ENUM_LABEL_87"), - 88: .same(proto: "ENUM_LABEL_88"), - 89: .same(proto: "ENUM_LABEL_89"), - 90: .same(proto: "ENUM_LABEL_90"), - 91: .same(proto: "ENUM_LABEL_91"), - 92: .same(proto: "ENUM_LABEL_92"), - 93: .same(proto: "ENUM_LABEL_93"), - 94: .same(proto: "ENUM_LABEL_94"), - 95: .same(proto: "ENUM_LABEL_95"), - 96: .same(proto: "ENUM_LABEL_96"), - 97: .same(proto: "ENUM_LABEL_97"), - 98: .same(proto: "ENUM_LABEL_98"), - 99: .same(proto: "ENUM_LABEL_99"), - 100: .same(proto: "ENUM_LABEL_100"), - ] -} - -extension ProtobufUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 16: .unique(proto: "OptionalGroup", json: "optionalgroup"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "optional_foreign_message"), - 20: .standard(proto: "optional_import_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "optional_foreign_enum"), - 23: .standard(proto: "optional_import_enum"), - 24: .standard(proto: "optional_string_piece"), - 25: .standard(proto: "optional_cord"), - 26: .standard(proto: "optional_public_import_message"), - 27: .standard(proto: "optional_lazy_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 46: .unique(proto: "RepeatedGroup", json: "repeatedgroup"), - 48: .standard(proto: "repeated_nested_message"), - 49: .standard(proto: "repeated_foreign_message"), - 50: .standard(proto: "repeated_import_message"), - 51: .standard(proto: "repeated_nested_enum"), - 52: .standard(proto: "repeated_foreign_enum"), - 53: .standard(proto: "repeated_import_enum"), - 54: .standard(proto: "repeated_string_piece"), - 55: .standard(proto: "repeated_cord"), - 57: .standard(proto: "repeated_lazy_message"), - 61: .standard(proto: "default_int32"), - 62: .standard(proto: "default_int64"), - 63: .standard(proto: "default_uint32"), - 64: .standard(proto: "default_uint64"), - 65: .standard(proto: "default_sint32"), - 66: .standard(proto: "default_sint64"), - 67: .standard(proto: "default_fixed32"), - 68: .standard(proto: "default_fixed64"), - 69: .standard(proto: "default_sfixed32"), - 70: .standard(proto: "default_sfixed64"), - 71: .standard(proto: "default_float"), - 72: .standard(proto: "default_double"), - 73: .standard(proto: "default_bool"), - 74: .standard(proto: "default_string"), - 75: .standard(proto: "default_bytes"), - 81: .standard(proto: "default_nested_enum"), - 82: .standard(proto: "default_foreign_enum"), - 83: .standard(proto: "default_import_enum"), - 84: .standard(proto: "default_string_piece"), - 85: .standard(proto: "default_cord"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - ] - - fileprivate class _StorageClass { - var _optionalInt32: Int32? = nil - var _optionalInt64: Int64? = nil - var _optionalUint32: UInt32? = nil - var _optionalUint64: UInt64? = nil - var _optionalSint32: Int32? = nil - var _optionalSint64: Int64? = nil - var _optionalFixed32: UInt32? = nil - var _optionalFixed64: UInt64? = nil - var _optionalSfixed32: Int32? = nil - var _optionalSfixed64: Int64? = nil - var _optionalFloat: Float? = nil - var _optionalDouble: Double? = nil - var _optionalBool: Bool? = nil - var _optionalString: String? = nil - var _optionalBytes: Data? = nil - var _optionalGroup: ProtobufUnittest_TestAllTypes.OptionalGroup? = nil - var _optionalNestedMessage: ProtobufUnittest_TestAllTypes.NestedMessage? = nil - var _optionalForeignMessage: ProtobufUnittest_ForeignMessage? = nil - var _optionalImportMessage: ProtobufUnittestImport_ImportMessage? = nil - var _optionalNestedEnum: ProtobufUnittest_TestAllTypes.NestedEnum? = nil - var _optionalForeignEnum: ProtobufUnittest_ForeignEnum? = nil - var _optionalImportEnum: ProtobufUnittestImport_ImportEnum? = nil - var _optionalStringPiece: String? = nil - var _optionalCord: String? = nil - var _optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessage? = nil - var _optionalLazyMessage: ProtobufUnittest_TestAllTypes.NestedMessage? = nil - var _repeatedInt32: [Int32] = [] - var _repeatedInt64: [Int64] = [] - var _repeatedUint32: [UInt32] = [] - var _repeatedUint64: [UInt64] = [] - var _repeatedSint32: [Int32] = [] - var _repeatedSint64: [Int64] = [] - var _repeatedFixed32: [UInt32] = [] - var _repeatedFixed64: [UInt64] = [] - var _repeatedSfixed32: [Int32] = [] - var _repeatedSfixed64: [Int64] = [] - var _repeatedFloat: [Float] = [] - var _repeatedDouble: [Double] = [] - var _repeatedBool: [Bool] = [] - var _repeatedString: [String] = [] - var _repeatedBytes: [Data] = [] - var _repeatedGroup: [ProtobufUnittest_TestAllTypes.RepeatedGroup] = [] - var _repeatedNestedMessage: [ProtobufUnittest_TestAllTypes.NestedMessage] = [] - var _repeatedForeignMessage: [ProtobufUnittest_ForeignMessage] = [] - var _repeatedImportMessage: [ProtobufUnittestImport_ImportMessage] = [] - var _repeatedNestedEnum: [ProtobufUnittest_TestAllTypes.NestedEnum] = [] - var _repeatedForeignEnum: [ProtobufUnittest_ForeignEnum] = [] - var _repeatedImportEnum: [ProtobufUnittestImport_ImportEnum] = [] - var _repeatedStringPiece: [String] = [] - var _repeatedCord: [String] = [] - var _repeatedLazyMessage: [ProtobufUnittest_TestAllTypes.NestedMessage] = [] - var _defaultInt32: Int32? = nil - var _defaultInt64: Int64? = nil - var _defaultUint32: UInt32? = nil - var _defaultUint64: UInt64? = nil - var _defaultSint32: Int32? = nil - var _defaultSint64: Int64? = nil - var _defaultFixed32: UInt32? = nil - var _defaultFixed64: UInt64? = nil - var _defaultSfixed32: Int32? = nil - var _defaultSfixed64: Int64? = nil - var _defaultFloat: Float? = nil - var _defaultDouble: Double? = nil - var _defaultBool: Bool? = nil - var _defaultString: String? = nil - var _defaultBytes: Data? = nil - var _defaultNestedEnum: ProtobufUnittest_TestAllTypes.NestedEnum? = nil - var _defaultForeignEnum: ProtobufUnittest_ForeignEnum? = nil - var _defaultImportEnum: ProtobufUnittestImport_ImportEnum? = nil - var _defaultStringPiece: String? = nil - var _defaultCord: String? = nil - var _oneofField: ProtobufUnittest_TestAllTypes.OneOf_OneofField? - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _optionalInt32 = source._optionalInt32 - _optionalInt64 = source._optionalInt64 - _optionalUint32 = source._optionalUint32 - _optionalUint64 = source._optionalUint64 - _optionalSint32 = source._optionalSint32 - _optionalSint64 = source._optionalSint64 - _optionalFixed32 = source._optionalFixed32 - _optionalFixed64 = source._optionalFixed64 - _optionalSfixed32 = source._optionalSfixed32 - _optionalSfixed64 = source._optionalSfixed64 - _optionalFloat = source._optionalFloat - _optionalDouble = source._optionalDouble - _optionalBool = source._optionalBool - _optionalString = source._optionalString - _optionalBytes = source._optionalBytes - _optionalGroup = source._optionalGroup - _optionalNestedMessage = source._optionalNestedMessage - _optionalForeignMessage = source._optionalForeignMessage - _optionalImportMessage = source._optionalImportMessage - _optionalNestedEnum = source._optionalNestedEnum - _optionalForeignEnum = source._optionalForeignEnum - _optionalImportEnum = source._optionalImportEnum - _optionalStringPiece = source._optionalStringPiece - _optionalCord = source._optionalCord - _optionalPublicImportMessage = source._optionalPublicImportMessage - _optionalLazyMessage = source._optionalLazyMessage - _repeatedInt32 = source._repeatedInt32 - _repeatedInt64 = source._repeatedInt64 - _repeatedUint32 = source._repeatedUint32 - _repeatedUint64 = source._repeatedUint64 - _repeatedSint32 = source._repeatedSint32 - _repeatedSint64 = source._repeatedSint64 - _repeatedFixed32 = source._repeatedFixed32 - _repeatedFixed64 = source._repeatedFixed64 - _repeatedSfixed32 = source._repeatedSfixed32 - _repeatedSfixed64 = source._repeatedSfixed64 - _repeatedFloat = source._repeatedFloat - _repeatedDouble = source._repeatedDouble - _repeatedBool = source._repeatedBool - _repeatedString = source._repeatedString - _repeatedBytes = source._repeatedBytes - _repeatedGroup = source._repeatedGroup - _repeatedNestedMessage = source._repeatedNestedMessage - _repeatedForeignMessage = source._repeatedForeignMessage - _repeatedImportMessage = source._repeatedImportMessage - _repeatedNestedEnum = source._repeatedNestedEnum - _repeatedForeignEnum = source._repeatedForeignEnum - _repeatedImportEnum = source._repeatedImportEnum - _repeatedStringPiece = source._repeatedStringPiece - _repeatedCord = source._repeatedCord - _repeatedLazyMessage = source._repeatedLazyMessage - _defaultInt32 = source._defaultInt32 - _defaultInt64 = source._defaultInt64 - _defaultUint32 = source._defaultUint32 - _defaultUint64 = source._defaultUint64 - _defaultSint32 = source._defaultSint32 - _defaultSint64 = source._defaultSint64 - _defaultFixed32 = source._defaultFixed32 - _defaultFixed64 = source._defaultFixed64 - _defaultSfixed32 = source._defaultSfixed32 - _defaultSfixed64 = source._defaultSfixed64 - _defaultFloat = source._defaultFloat - _defaultDouble = source._defaultDouble - _defaultBool = source._defaultBool - _defaultString = source._defaultString - _defaultBytes = source._defaultBytes - _defaultNestedEnum = source._defaultNestedEnum - _defaultForeignEnum = source._defaultForeignEnum - _defaultImportEnum = source._defaultImportEnum - _defaultStringPiece = source._defaultStringPiece - _defaultCord = source._defaultCord - _oneofField = source._oneofField - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._optionalInt32) }() - case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() - case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() - case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() - case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() - case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() - case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() - case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() - case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() - case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() - case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() - case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() - case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() - case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() - case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() - case 16: try { try decoder.decodeSingularGroupField(value: &_storage._optionalGroup) }() - case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() - case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() - case 20: try { try decoder.decodeSingularMessageField(value: &_storage._optionalImportMessage) }() - case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() - case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() - case 23: try { try decoder.decodeSingularEnumField(value: &_storage._optionalImportEnum) }() - case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() - case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() - case 26: try { try decoder.decodeSingularMessageField(value: &_storage._optionalPublicImportMessage) }() - case 27: try { try decoder.decodeSingularMessageField(value: &_storage._optionalLazyMessage) }() - case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() - case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() - case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() - case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() - case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() - case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() - case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() - case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() - case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() - case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() - case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() - case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() - case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() - case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() - case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() - case 46: try { try decoder.decodeRepeatedGroupField(value: &_storage._repeatedGroup) }() - case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() - case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() - case 50: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedImportMessage) }() - case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() - case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() - case 53: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedImportEnum) }() - case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() - case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() - case 57: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedLazyMessage) }() - case 61: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() - case 62: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() - case 63: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() - case 64: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() - case 65: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() - case 66: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() - case 67: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() - case 68: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() - case 69: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() - case 70: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() - case 71: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() - case 72: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() - case 73: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() - case 74: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() - case 75: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() - case 81: try { try decoder.decodeSingularEnumField(value: &_storage._defaultNestedEnum) }() - case 82: try { try decoder.decodeSingularEnumField(value: &_storage._defaultForeignEnum) }() - case 83: try { try decoder.decodeSingularEnumField(value: &_storage._defaultImportEnum) }() - case 84: try { try decoder.decodeSingularStringField(value: &_storage._defaultStringPiece) }() - case 85: try { try decoder.decodeSingularStringField(value: &_storage._defaultCord) }() - case 111: try { - var v: UInt32? - try decoder.decodeSingularUInt32Field(value: &v) - if let v = v { - if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofUint32(v) - } - }() - case 112: try { - var v: ProtobufUnittest_TestAllTypes.NestedMessage? - var hadOneofValue = false - if let current = _storage._oneofField { - hadOneofValue = true - if case .oneofNestedMessage(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofNestedMessage(v) - } - }() - case 113: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofString(v) - } - }() - case 114: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofBytes(v) - } - }() - default: break - } - } - } - } - - func traverse(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._optionalInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._optionalInt64 { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) - } }() - try { if let v = _storage._optionalUint32 { - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) - } }() - try { if let v = _storage._optionalUint64 { - try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) - } }() - try { if let v = _storage._optionalSint32 { - try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) - } }() - try { if let v = _storage._optionalSint64 { - try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) - } }() - try { if let v = _storage._optionalFixed32 { - try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) - } }() - try { if let v = _storage._optionalFixed64 { - try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) - } }() - try { if let v = _storage._optionalSfixed32 { - try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) - } }() - try { if let v = _storage._optionalSfixed64 { - try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) - } }() - try { if let v = _storage._optionalFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 11) - } }() - try { if let v = _storage._optionalDouble { - try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) - } }() - try { if let v = _storage._optionalBool { - try visitor.visitSingularBoolField(value: v, fieldNumber: 13) - } }() - try { if let v = _storage._optionalString { - try visitor.visitSingularStringField(value: v, fieldNumber: 14) - } }() - try { if let v = _storage._optionalBytes { - try visitor.visitSingularBytesField(value: v, fieldNumber: 15) - } }() - try { if let v = _storage._optionalGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 16) - } }() - try { if let v = _storage._optionalNestedMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 18) - } }() - try { if let v = _storage._optionalForeignMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 19) - } }() - try { if let v = _storage._optionalImportMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 20) - } }() - try { if let v = _storage._optionalNestedEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 21) - } }() - try { if let v = _storage._optionalForeignEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 22) - } }() - try { if let v = _storage._optionalImportEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 23) - } }() - try { if let v = _storage._optionalStringPiece { - try visitor.visitSingularStringField(value: v, fieldNumber: 24) - } }() - try { if let v = _storage._optionalCord { - try visitor.visitSingularStringField(value: v, fieldNumber: 25) - } }() - try { if let v = _storage._optionalPublicImportMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 26) - } }() - try { if let v = _storage._optionalLazyMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 27) - } }() - if !_storage._repeatedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) - } - if !_storage._repeatedInt64.isEmpty { - try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) - } - if !_storage._repeatedUint32.isEmpty { - try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) - } - if !_storage._repeatedUint64.isEmpty { - try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) - } - if !_storage._repeatedSint32.isEmpty { - try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) - } - if !_storage._repeatedSint64.isEmpty { - try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) - } - if !_storage._repeatedFixed32.isEmpty { - try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) - } - if !_storage._repeatedFixed64.isEmpty { - try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) - } - if !_storage._repeatedSfixed32.isEmpty { - try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) - } - if !_storage._repeatedSfixed64.isEmpty { - try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) - } - if !_storage._repeatedFloat.isEmpty { - try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) - } - if !_storage._repeatedDouble.isEmpty { - try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) - } - if !_storage._repeatedBool.isEmpty { - try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43) - } - if !_storage._repeatedString.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) - } - if !_storage._repeatedBytes.isEmpty { - try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) - } - if !_storage._repeatedGroup.isEmpty { - try visitor.visitRepeatedGroupField(value: _storage._repeatedGroup, fieldNumber: 46) - } - if !_storage._repeatedNestedMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) - } - if !_storage._repeatedForeignMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) - } - if !_storage._repeatedImportMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedImportMessage, fieldNumber: 50) - } - if !_storage._repeatedNestedEnum.isEmpty { - try visitor.visitRepeatedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) - } - if !_storage._repeatedForeignEnum.isEmpty { - try visitor.visitRepeatedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) - } - if !_storage._repeatedImportEnum.isEmpty { - try visitor.visitRepeatedEnumField(value: _storage._repeatedImportEnum, fieldNumber: 53) - } - if !_storage._repeatedStringPiece.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) - } - if !_storage._repeatedCord.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) - } - if !_storage._repeatedLazyMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedLazyMessage, fieldNumber: 57) - } - try { if let v = _storage._defaultInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 61) - } }() - try { if let v = _storage._defaultInt64 { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 62) - } }() - try { if let v = _storage._defaultUint32 { - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63) - } }() - try { if let v = _storage._defaultUint64 { - try visitor.visitSingularUInt64Field(value: v, fieldNumber: 64) - } }() - try { if let v = _storage._defaultSint32 { - try visitor.visitSingularSInt32Field(value: v, fieldNumber: 65) - } }() - try { if let v = _storage._defaultSint64 { - try visitor.visitSingularSInt64Field(value: v, fieldNumber: 66) - } }() - try { if let v = _storage._defaultFixed32 { - try visitor.visitSingularFixed32Field(value: v, fieldNumber: 67) - } }() - try { if let v = _storage._defaultFixed64 { - try visitor.visitSingularFixed64Field(value: v, fieldNumber: 68) - } }() - try { if let v = _storage._defaultSfixed32 { - try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 69) - } }() - try { if let v = _storage._defaultSfixed64 { - try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 70) - } }() - try { if let v = _storage._defaultFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 71) - } }() - try { if let v = _storage._defaultDouble { - try visitor.visitSingularDoubleField(value: v, fieldNumber: 72) - } }() - try { if let v = _storage._defaultBool { - try visitor.visitSingularBoolField(value: v, fieldNumber: 73) - } }() - try { if let v = _storage._defaultString { - try visitor.visitSingularStringField(value: v, fieldNumber: 74) - } }() - try { if let v = _storage._defaultBytes { - try visitor.visitSingularBytesField(value: v, fieldNumber: 75) - } }() - try { if let v = _storage._defaultNestedEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 81) - } }() - try { if let v = _storage._defaultForeignEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 82) - } }() - try { if let v = _storage._defaultImportEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 83) - } }() - try { if let v = _storage._defaultStringPiece { - try visitor.visitSingularStringField(value: v, fieldNumber: 84) - } }() - try { if let v = _storage._defaultCord { - try visitor.visitSingularStringField(value: v, fieldNumber: 85) - } }() - switch _storage._oneofField { - case .oneofUint32?: try { - guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) - }() - case .oneofNestedMessage?: try { - guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 112) - }() - case .oneofString?: try { - guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 113) - }() - case .oneofBytes?: try { - guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 114) - }() - case nil: break - } - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllTypes, rhs: ProtobufUnittest_TestAllTypes) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} - if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} - if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} - if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} - if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} - if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} - if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} - if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} - if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} - if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} - if _storage._optionalFloat != rhs_storage._optionalFloat {return false} - if _storage._optionalDouble != rhs_storage._optionalDouble {return false} - if _storage._optionalBool != rhs_storage._optionalBool {return false} - if _storage._optionalString != rhs_storage._optionalString {return false} - if _storage._optionalBytes != rhs_storage._optionalBytes {return false} - if _storage._optionalGroup != rhs_storage._optionalGroup {return false} - if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} - if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} - if _storage._optionalImportMessage != rhs_storage._optionalImportMessage {return false} - if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} - if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} - if _storage._optionalImportEnum != rhs_storage._optionalImportEnum {return false} - if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} - if _storage._optionalCord != rhs_storage._optionalCord {return false} - if _storage._optionalPublicImportMessage != rhs_storage._optionalPublicImportMessage {return false} - if _storage._optionalLazyMessage != rhs_storage._optionalLazyMessage {return false} - if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} - if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} - if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} - if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} - if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} - if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} - if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} - if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} - if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} - if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} - if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} - if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} - if _storage._repeatedBool != rhs_storage._repeatedBool {return false} - if _storage._repeatedString != rhs_storage._repeatedString {return false} - if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} - if _storage._repeatedGroup != rhs_storage._repeatedGroup {return false} - if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} - if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} - if _storage._repeatedImportMessage != rhs_storage._repeatedImportMessage {return false} - if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} - if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} - if _storage._repeatedImportEnum != rhs_storage._repeatedImportEnum {return false} - if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} - if _storage._repeatedCord != rhs_storage._repeatedCord {return false} - if _storage._repeatedLazyMessage != rhs_storage._repeatedLazyMessage {return false} - if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} - if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} - if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} - if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} - if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} - if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} - if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} - if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} - if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} - if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} - if _storage._defaultFloat != rhs_storage._defaultFloat {return false} - if _storage._defaultDouble != rhs_storage._defaultDouble {return false} - if _storage._defaultBool != rhs_storage._defaultBool {return false} - if _storage._defaultString != rhs_storage._defaultString {return false} - if _storage._defaultBytes != rhs_storage._defaultBytes {return false} - if _storage._defaultNestedEnum != rhs_storage._defaultNestedEnum {return false} - if _storage._defaultForeignEnum != rhs_storage._defaultForeignEnum {return false} - if _storage._defaultImportEnum != rhs_storage._defaultImportEnum {return false} - if _storage._defaultStringPiece != rhs_storage._defaultStringPiece {return false} - if _storage._defaultCord != rhs_storage._defaultCord {return false} - if _storage._oneofField != rhs_storage._oneofField {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestAllTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -1: .same(proto: "NEG"), - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - 3: .same(proto: "BAZ"), - ] -} - -extension ProtobufUnittest_TestAllTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestAllTypes.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - ] - - 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._bb) }() - 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 - try { if let v = self._bb { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllTypes.NestedMessage, rhs: ProtobufUnittest_TestAllTypes.NestedMessage) -> Bool { - if lhs._bb != rhs._bb {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestAllTypes.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestAllTypes.protoMessageName + ".OptionalGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 17: .same(proto: "a"), - ] - - 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllTypes.OptionalGroup, rhs: ProtobufUnittest_TestAllTypes.OptionalGroup) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestAllTypes.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestAllTypes.protoMessageName + ".RepeatedGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 47: .same(proto: "a"), - ] - - 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 47: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllTypes.RepeatedGroup, rhs: ProtobufUnittest_TestAllTypes.RepeatedGroup) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".NestedTestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "child"), - 2: .same(proto: "payload"), - 3: .standard(proto: "repeated_child"), - ] - - fileprivate class _StorageClass { - var _child: ProtobufUnittest_NestedTestAllTypes? = nil - var _payload: ProtobufUnittest_TestAllTypes? = nil - var _repeatedChild: [ProtobufUnittest_NestedTestAllTypes] = [] - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _child = source._child - _payload = source._payload - _repeatedChild = source._repeatedChild - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._child) }() - case 2: try { try decoder.decodeSingularMessageField(value: &_storage._payload) }() - case 3: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedChild) }() - default: break - } - } - } - } - - func traverse(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._child { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._payload { - try visitor.visitSingularMessageField(value: v, fieldNumber: 2) - } }() - if !_storage._repeatedChild.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedChild, fieldNumber: 3) - } - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_NestedTestAllTypes, rhs: ProtobufUnittest_NestedTestAllTypes) -> 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._child != rhs_storage._child {return false} - if _storage._payload != rhs_storage._payload {return false} - if _storage._repeatedChild != rhs_storage._repeatedChild {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestDeprecatedFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestDeprecatedFields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "deprecated_int32"), - 2: .standard(proto: "deprecated_int32_in_oneof"), - ] - - 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._deprecatedInt32) }() - case 2: try { - var v: Int32? - try decoder.decodeSingularInt32Field(value: &v) - if let v = v { - if self.oneofFields != nil {try decoder.handleConflictingOneOf()} - self.oneofFields = .deprecatedInt32InOneof(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 - try { if let v = self._deprecatedInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if case .deprecatedInt32InOneof(let v)? = self.oneofFields { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestDeprecatedFields, rhs: ProtobufUnittest_TestDeprecatedFields) -> Bool { - if lhs._deprecatedInt32 != rhs._deprecatedInt32 {return false} - if lhs.oneofFields != rhs.oneofFields {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestDeprecatedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestDeprecatedMessage" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestDeprecatedMessage, rhs: ProtobufUnittest_TestDeprecatedMessage) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ForeignMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - 2: .same(proto: "d"), - ] - - 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._c) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &self._d) }() - 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 - try { if let v = self._c { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._d { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_ForeignMessage, rhs: ProtobufUnittest_ForeignMessage) -> Bool { - if lhs._c != rhs._c {return false} - if lhs._d != rhs._d {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestReservedFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestReservedFields" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestReservedFields, rhs: ProtobufUnittest_TestReservedFields) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestAllExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestAllExtensions" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestAllExtensions.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllExtensions, rhs: ProtobufUnittest_TestAllExtensions) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_OptionalGroup_extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".OptionalGroup_extension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 17: .same(proto: "a"), - ] - - 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_OptionalGroup_extension, rhs: ProtobufUnittest_OptionalGroup_extension) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_RepeatedGroup_extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".RepeatedGroup_extension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 47: .same(proto: "a"), - ] - - 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 47: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_RepeatedGroup_extension, rhs: ProtobufUnittest_RepeatedGroup_extension) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 16: .unique(proto: "OptionalGroup", json: "optionalgroup"), - 22: .standard(proto: "optional_foreign_enum"), - ] - - 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 16: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() - case 22: try { try decoder.decodeSingularEnumField(value: &self._optionalForeignEnum) }() - 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 - try { if let v = self._optionalGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 16) - } }() - try { if let v = self._optionalForeignEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 22) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestGroup, rhs: ProtobufUnittest_TestGroup) -> Bool { - if lhs._optionalGroup != rhs._optionalGroup {return false} - if lhs._optionalForeignEnum != rhs._optionalForeignEnum {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestGroup.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestGroup.protoMessageName + ".OptionalGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 17: .same(proto: "a"), - ] - - 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestGroup.OptionalGroup, rhs: ProtobufUnittest_TestGroup.OptionalGroup) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestGroupExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestGroupExtension" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestGroupExtension.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestGroupExtension, rhs: ProtobufUnittest_TestGroupExtension) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestNestedExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestNestedExtension" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestNestedExtension, rhs: ProtobufUnittest_TestNestedExtension) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestNestedExtension.OptionalGroup_extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestNestedExtension.protoMessageName + ".OptionalGroup_extension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 17: .same(proto: "a"), - ] - - 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestNestedExtension.OptionalGroup_extension, rhs: ProtobufUnittest_TestNestedExtension.OptionalGroup_extension) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestChildExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestChildExtension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 2: .same(proto: "b"), - 3: .standard(proto: "optional_extension"), - ] - - public var isInitialized: Bool { - if let v = self._optionalExtension, !v.isInitialized {return false} - return true - } - - 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._a) }() - case 2: try { try decoder.decodeSingularStringField(value: &self._b) }() - case 3: try { try decoder.decodeSingularMessageField(value: &self._optionalExtension) }() - 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 - try { if let v = self._a { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try { if let v = self._b { - try visitor.visitSingularStringField(value: v, fieldNumber: 2) - } }() - try { if let v = self._optionalExtension { - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestChildExtension, rhs: ProtobufUnittest_TestChildExtension) -> Bool { - if lhs._a != rhs._a {return false} - if lhs._b != rhs._b {return false} - if lhs._optionalExtension != rhs._optionalExtension {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestRequired: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestRequired" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 2: .same(proto: "dummy2"), - 3: .same(proto: "b"), - 4: .same(proto: "dummy4"), - 5: .same(proto: "dummy5"), - 6: .same(proto: "dummy6"), - 7: .same(proto: "dummy7"), - 8: .same(proto: "dummy8"), - 9: .same(proto: "dummy9"), - 10: .same(proto: "dummy10"), - 11: .same(proto: "dummy11"), - 12: .same(proto: "dummy12"), - 13: .same(proto: "dummy13"), - 14: .same(proto: "dummy14"), - 15: .same(proto: "dummy15"), - 16: .same(proto: "dummy16"), - 17: .same(proto: "dummy17"), - 18: .same(proto: "dummy18"), - 19: .same(proto: "dummy19"), - 20: .same(proto: "dummy20"), - 21: .same(proto: "dummy21"), - 22: .same(proto: "dummy22"), - 23: .same(proto: "dummy23"), - 24: .same(proto: "dummy24"), - 25: .same(proto: "dummy25"), - 26: .same(proto: "dummy26"), - 27: .same(proto: "dummy27"), - 28: .same(proto: "dummy28"), - 29: .same(proto: "dummy29"), - 30: .same(proto: "dummy30"), - 31: .same(proto: "dummy31"), - 32: .same(proto: "dummy32"), - 33: .same(proto: "c"), - ] - - fileprivate class _StorageClass { - var _a: Int32? = nil - var _dummy2: Int32? = nil - var _b: Int32? = nil - var _dummy4: Int32? = nil - var _dummy5: Int32? = nil - var _dummy6: Int32? = nil - var _dummy7: Int32? = nil - var _dummy8: Int32? = nil - var _dummy9: Int32? = nil - var _dummy10: Int32? = nil - var _dummy11: Int32? = nil - var _dummy12: Int32? = nil - var _dummy13: Int32? = nil - var _dummy14: Int32? = nil - var _dummy15: Int32? = nil - var _dummy16: Int32? = nil - var _dummy17: Int32? = nil - var _dummy18: Int32? = nil - var _dummy19: Int32? = nil - var _dummy20: Int32? = nil - var _dummy21: Int32? = nil - var _dummy22: Int32? = nil - var _dummy23: Int32? = nil - var _dummy24: Int32? = nil - var _dummy25: Int32? = nil - var _dummy26: Int32? = nil - var _dummy27: Int32? = nil - var _dummy28: Int32? = nil - var _dummy29: Int32? = nil - var _dummy30: Int32? = nil - var _dummy31: Int32? = nil - var _dummy32: Int32? = nil - var _c: Int32? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _a = source._a - _dummy2 = source._dummy2 - _b = source._b - _dummy4 = source._dummy4 - _dummy5 = source._dummy5 - _dummy6 = source._dummy6 - _dummy7 = source._dummy7 - _dummy8 = source._dummy8 - _dummy9 = source._dummy9 - _dummy10 = source._dummy10 - _dummy11 = source._dummy11 - _dummy12 = source._dummy12 - _dummy13 = source._dummy13 - _dummy14 = source._dummy14 - _dummy15 = source._dummy15 - _dummy16 = source._dummy16 - _dummy17 = source._dummy17 - _dummy18 = source._dummy18 - _dummy19 = source._dummy19 - _dummy20 = source._dummy20 - _dummy21 = source._dummy21 - _dummy22 = source._dummy22 - _dummy23 = source._dummy23 - _dummy24 = source._dummy24 - _dummy25 = source._dummy25 - _dummy26 = source._dummy26 - _dummy27 = source._dummy27 - _dummy28 = source._dummy28 - _dummy29 = source._dummy29 - _dummy30 = source._dummy30 - _dummy31 = source._dummy31 - _dummy32 = source._dummy32 - _c = source._c - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - public var isInitialized: Bool { - return withExtendedLifetime(_storage) { (_storage: _StorageClass) in - if _storage._a == nil {return false} - if _storage._b == nil {return false} - if _storage._c == nil {return false} - return true - } - } - - mutating func decodeMessage(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._a) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy2) }() - case 3: try { try decoder.decodeSingularInt32Field(value: &_storage._b) }() - case 4: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy4) }() - case 5: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy5) }() - case 6: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy6) }() - case 7: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy7) }() - case 8: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy8) }() - case 9: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy9) }() - case 10: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy10) }() - case 11: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy11) }() - case 12: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy12) }() - case 13: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy13) }() - case 14: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy14) }() - case 15: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy15) }() - case 16: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy16) }() - case 17: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy17) }() - case 18: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy18) }() - case 19: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy19) }() - case 20: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy20) }() - case 21: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy21) }() - case 22: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy22) }() - case 23: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy23) }() - case 24: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy24) }() - case 25: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy25) }() - case 26: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy26) }() - case 27: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy27) }() - case 28: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy28) }() - case 29: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy29) }() - case 30: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy30) }() - case 31: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy31) }() - case 32: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy32) }() - case 33: try { try decoder.decodeSingularInt32Field(value: &_storage._c) }() - default: break - } - } - } - } - - func traverse(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._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._dummy2 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try { if let v = _storage._b { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) - } }() - try { if let v = _storage._dummy4 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) - } }() - try { if let v = _storage._dummy5 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) - } }() - try { if let v = _storage._dummy6 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) - } }() - try { if let v = _storage._dummy7 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) - } }() - try { if let v = _storage._dummy8 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 8) - } }() - try { if let v = _storage._dummy9 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) - } }() - try { if let v = _storage._dummy10 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 10) - } }() - try { if let v = _storage._dummy11 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 11) - } }() - try { if let v = _storage._dummy12 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 12) - } }() - try { if let v = _storage._dummy13 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 13) - } }() - try { if let v = _storage._dummy14 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 14) - } }() - try { if let v = _storage._dummy15 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 15) - } }() - try { if let v = _storage._dummy16 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 16) - } }() - try { if let v = _storage._dummy17 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) - } }() - try { if let v = _storage._dummy18 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 18) - } }() - try { if let v = _storage._dummy19 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 19) - } }() - try { if let v = _storage._dummy20 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 20) - } }() - try { if let v = _storage._dummy21 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 21) - } }() - try { if let v = _storage._dummy22 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 22) - } }() - try { if let v = _storage._dummy23 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 23) - } }() - try { if let v = _storage._dummy24 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 24) - } }() - try { if let v = _storage._dummy25 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 25) - } }() - try { if let v = _storage._dummy26 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 26) - } }() - try { if let v = _storage._dummy27 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 27) - } }() - try { if let v = _storage._dummy28 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 28) - } }() - try { if let v = _storage._dummy29 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 29) - } }() - try { if let v = _storage._dummy30 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 30) - } }() - try { if let v = _storage._dummy31 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 31) - } }() - try { if let v = _storage._dummy32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 32) - } }() - try { if let v = _storage._c { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 33) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestRequired, rhs: ProtobufUnittest_TestRequired) -> 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._a != rhs_storage._a {return false} - if _storage._dummy2 != rhs_storage._dummy2 {return false} - if _storage._b != rhs_storage._b {return false} - if _storage._dummy4 != rhs_storage._dummy4 {return false} - if _storage._dummy5 != rhs_storage._dummy5 {return false} - if _storage._dummy6 != rhs_storage._dummy6 {return false} - if _storage._dummy7 != rhs_storage._dummy7 {return false} - if _storage._dummy8 != rhs_storage._dummy8 {return false} - if _storage._dummy9 != rhs_storage._dummy9 {return false} - if _storage._dummy10 != rhs_storage._dummy10 {return false} - if _storage._dummy11 != rhs_storage._dummy11 {return false} - if _storage._dummy12 != rhs_storage._dummy12 {return false} - if _storage._dummy13 != rhs_storage._dummy13 {return false} - if _storage._dummy14 != rhs_storage._dummy14 {return false} - if _storage._dummy15 != rhs_storage._dummy15 {return false} - if _storage._dummy16 != rhs_storage._dummy16 {return false} - if _storage._dummy17 != rhs_storage._dummy17 {return false} - if _storage._dummy18 != rhs_storage._dummy18 {return false} - if _storage._dummy19 != rhs_storage._dummy19 {return false} - if _storage._dummy20 != rhs_storage._dummy20 {return false} - if _storage._dummy21 != rhs_storage._dummy21 {return false} - if _storage._dummy22 != rhs_storage._dummy22 {return false} - if _storage._dummy23 != rhs_storage._dummy23 {return false} - if _storage._dummy24 != rhs_storage._dummy24 {return false} - if _storage._dummy25 != rhs_storage._dummy25 {return false} - if _storage._dummy26 != rhs_storage._dummy26 {return false} - if _storage._dummy27 != rhs_storage._dummy27 {return false} - if _storage._dummy28 != rhs_storage._dummy28 {return false} - if _storage._dummy29 != rhs_storage._dummy29 {return false} - if _storage._dummy30 != rhs_storage._dummy30 {return false} - if _storage._dummy31 != rhs_storage._dummy31 {return false} - if _storage._dummy32 != rhs_storage._dummy32 {return false} - if _storage._c != rhs_storage._c {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestRequiredForeign: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestRequiredForeign" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_message"), - 2: .standard(proto: "repeated_message"), - 3: .same(proto: "dummy"), - ] - - public var isInitialized: Bool { - if let v = self._optionalMessage, !v.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.repeatedMessage) {return false} - return true - } - - 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.decodeSingularMessageField(value: &self._optionalMessage) }() - case 2: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedMessage) }() - case 3: try { try decoder.decodeSingularInt32Field(value: &self._dummy) }() - 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 - try { if let v = self._optionalMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - if !self.repeatedMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: self.repeatedMessage, fieldNumber: 2) - } - try { if let v = self._dummy { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestRequiredForeign, rhs: ProtobufUnittest_TestRequiredForeign) -> Bool { - if lhs._optionalMessage != rhs._optionalMessage {return false} - if lhs.repeatedMessage != rhs.repeatedMessage {return false} - if lhs._dummy != rhs._dummy {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestRequiredMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestRequiredMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_message"), - 2: .standard(proto: "repeated_message"), - 3: .standard(proto: "required_message"), - ] - - public var isInitialized: Bool { - if self._requiredMessage == nil {return false} - if let v = self._optionalMessage, !v.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.repeatedMessage) {return false} - if let v = self._requiredMessage, !v.isInitialized {return false} - return true - } - - 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.decodeSingularMessageField(value: &self._optionalMessage) }() - case 2: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedMessage) }() - case 3: try { try decoder.decodeSingularMessageField(value: &self._requiredMessage) }() - 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 - try { if let v = self._optionalMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - if !self.repeatedMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: self.repeatedMessage, fieldNumber: 2) - } - try { if let v = self._requiredMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestRequiredMessage, rhs: ProtobufUnittest_TestRequiredMessage) -> Bool { - if lhs._optionalMessage != rhs._optionalMessage {return false} - if lhs.repeatedMessage != rhs.repeatedMessage {return false} - if lhs._requiredMessage != rhs._requiredMessage {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestForeignNested: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestForeignNested" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "foreign_nested"), - ] - - 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.decodeSingularMessageField(value: &self._foreignNested) }() - 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 - try { if let v = self._foreignNested { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestForeignNested, rhs: ProtobufUnittest_TestForeignNested) -> Bool { - if lhs._foreignNested != rhs._foreignNested {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestEmptyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestEmptyMessage" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestEmptyMessage, rhs: ProtobufUnittest_TestEmptyMessage) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestEmptyMessageWithExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestEmptyMessageWithExtensions" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestEmptyMessageWithExtensions.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestEmptyMessageWithExtensions, rhs: ProtobufUnittest_TestEmptyMessageWithExtensions) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestPickleNestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestPickleNestedMessage" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestPickleNestedMessage, rhs: ProtobufUnittest_TestPickleNestedMessage) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestPickleNestedMessage.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestPickleNestedMessage.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - ] - - 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._bb) }() - 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 - try { if let v = self._bb { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestPickleNestedMessage.NestedMessage, rhs: ProtobufUnittest_TestPickleNestedMessage.NestedMessage) -> Bool { - if lhs._bb != rhs._bb {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestPickleNestedMessage.NestedMessage.protoMessageName + ".NestedNestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "cc"), - ] - - 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._cc) }() - 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 - try { if let v = self._cc { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage, rhs: ProtobufUnittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage) -> Bool { - if lhs._cc != rhs._cc {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestMultipleExtensionRanges: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMultipleExtensionRanges" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (42 == fieldNumber) || (4143 <= fieldNumber && fieldNumber < 4244) || (65536 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestMultipleExtensionRanges.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 42, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMultipleExtensionRanges, rhs: ProtobufUnittest_TestMultipleExtensionRanges) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestReallyLargeTagNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestReallyLargeTagNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 268435455: .same(proto: "bb"), - ] - - 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._a) }() - case 268435455: try { try decoder.decodeSingularInt32Field(value: &self._bb) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._bb { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 268435455) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestReallyLargeTagNumber, rhs: ProtobufUnittest_TestReallyLargeTagNumber) -> Bool { - if lhs._a != rhs._a {return false} - if lhs._bb != rhs._bb {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestRecursiveMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestRecursiveMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 2: .same(proto: "i"), - ] - - fileprivate class _StorageClass { - var _a: ProtobufUnittest_TestRecursiveMessage? = nil - var _i: Int32? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _a = source._a - _i = source._i - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._a) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._i) }() - default: break - } - } - } - } - - func traverse(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._a { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._i { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestRecursiveMessage, rhs: ProtobufUnittest_TestRecursiveMessage) -> 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._a != rhs_storage._a {return false} - if _storage._i != rhs_storage._i {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestMutualRecursionA: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMutualRecursionA" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - 2: .unique(proto: "SubGroup", json: "subgroup"), - ] - - fileprivate class _StorageClass { - var _bb: ProtobufUnittest_TestMutualRecursionB? = nil - var _subGroup: ProtobufUnittest_TestMutualRecursionA.SubGroup? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _bb = source._bb - _subGroup = source._subGroup - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._bb) }() - case 2: try { try decoder.decodeSingularGroupField(value: &_storage._subGroup) }() - default: break - } - } - } - } - - func traverse(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._bb { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._subGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 2) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMutualRecursionA, rhs: ProtobufUnittest_TestMutualRecursionA) -> 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._bb != rhs_storage._bb {return false} - if _storage._subGroup != rhs_storage._subGroup {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestMutualRecursionA.SubMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestMutualRecursionA.protoMessageName + ".SubMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "b"), - ] - - fileprivate class _StorageClass { - var _b: ProtobufUnittest_TestMutualRecursionB? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _b = source._b - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._b) }() - default: break - } - } - } - } - - func traverse(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._b { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMutualRecursionA.SubMessage, rhs: ProtobufUnittest_TestMutualRecursionA.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._b != rhs_storage._b {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestMutualRecursionA.SubGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestMutualRecursionA.protoMessageName + ".SubGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 3: .standard(proto: "sub_message"), - 4: .standard(proto: "not_in_this_scc"), - ] - - fileprivate class _StorageClass { - var _subMessage: ProtobufUnittest_TestMutualRecursionA.SubMessage? = nil - var _notInThisScc: ProtobufUnittest_TestAllTypes? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _subMessage = source._subMessage - _notInThisScc = source._notInThisScc - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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 3: try { try decoder.decodeSingularMessageField(value: &_storage._subMessage) }() - case 4: try { try decoder.decodeSingularMessageField(value: &_storage._notInThisScc) }() - default: break - } - } - } - } - - func traverse(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._subMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - } }() - try { if let v = _storage._notInThisScc { - try visitor.visitSingularMessageField(value: v, fieldNumber: 4) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMutualRecursionA.SubGroup, rhs: ProtobufUnittest_TestMutualRecursionA.SubGroup) -> 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._subMessage != rhs_storage._subMessage {return false} - if _storage._notInThisScc != rhs_storage._notInThisScc {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestMutualRecursionB: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMutualRecursionB" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 2: .standard(proto: "optional_int32"), - ] - - fileprivate class _StorageClass { - var _a: ProtobufUnittest_TestMutualRecursionA? = nil - var _optionalInt32: Int32? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _a = source._a - _optionalInt32 = source._optionalInt32 - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._a) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalInt32) }() - default: break - } - } - } - } - - func traverse(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._a { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._optionalInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMutualRecursionB, rhs: ProtobufUnittest_TestMutualRecursionB) -> 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._a != rhs_storage._a {return false} - if _storage._optionalInt32 != rhs_storage._optionalInt32 {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestIsInitialized: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestIsInitialized" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "sub_message"), - ] - - public var isInitialized: Bool { - if let v = self._subMessage, !v.isInitialized {return false} - return true - } - - 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.decodeSingularMessageField(value: &self._subMessage) }() - 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 - try { if let v = self._subMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestIsInitialized, rhs: ProtobufUnittest_TestIsInitialized) -> Bool { - if lhs._subMessage != rhs._subMessage {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestIsInitialized.SubMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestIsInitialized.protoMessageName + ".SubMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .unique(proto: "SubGroup", json: "subgroup"), - ] - - public var isInitialized: Bool { - if let v = self._subGroup, !v.isInitialized {return false} - return true - } - - 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.decodeSingularGroupField(value: &self._subGroup) }() - 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 - try { if let v = self._subGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestIsInitialized.SubMessage, rhs: ProtobufUnittest_TestIsInitialized.SubMessage) -> Bool { - if lhs._subGroup != rhs._subGroup {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestIsInitialized.SubMessage.SubGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestIsInitialized.SubMessage.protoMessageName + ".SubGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2: .same(proto: "i"), - ] - - public var isInitialized: Bool { - if self._i == nil {return false} - return true - } - - 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 2: try { try decoder.decodeSingularInt32Field(value: &self._i) }() - 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 - try { if let v = self._i { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestIsInitialized.SubMessage.SubGroup, rhs: ProtobufUnittest_TestIsInitialized.SubMessage.SubGroup) -> Bool { - if lhs._i != rhs._i {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestDupFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestDupFieldNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 2: .unique(proto: "Foo", json: "foo"), - 3: .unique(proto: "Bar", json: "bar"), - ] - - 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._a) }() - case 2: try { try decoder.decodeSingularGroupField(value: &self._foo) }() - case 3: try { try decoder.decodeSingularGroupField(value: &self._bar) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._foo { - try visitor.visitSingularGroupField(value: v, fieldNumber: 2) - } }() - try { if let v = self._bar { - try visitor.visitSingularGroupField(value: v, fieldNumber: 3) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestDupFieldNumber, rhs: ProtobufUnittest_TestDupFieldNumber) -> Bool { - if lhs._a != rhs._a {return false} - if lhs._foo != rhs._foo {return false} - if lhs._bar != rhs._bar {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestDupFieldNumber.Foo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestDupFieldNumber.protoMessageName + ".Foo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] - - 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._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestDupFieldNumber.Foo, rhs: ProtobufUnittest_TestDupFieldNumber.Foo) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestDupFieldNumber.Bar: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestDupFieldNumber.protoMessageName + ".Bar" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] - - 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._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestDupFieldNumber.Bar, rhs: ProtobufUnittest_TestDupFieldNumber.Bar) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestEagerMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestEagerMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "sub_message"), - ] - - 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.decodeSingularMessageField(value: &self._subMessage) }() - 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 - try { if let v = self._subMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestEagerMessage, rhs: ProtobufUnittest_TestEagerMessage) -> Bool { - if lhs._subMessage != rhs._subMessage {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestLazyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestLazyMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "sub_message"), - ] - - 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.decodeSingularMessageField(value: &self._subMessage) }() - 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 - try { if let v = self._subMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestLazyMessage, rhs: ProtobufUnittest_TestLazyMessage) -> Bool { - if lhs._subMessage != rhs._subMessage {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestNestedMessageHasBits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestNestedMessageHasBits" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_nested_message"), - ] - - 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.decodeSingularMessageField(value: &self._optionalNestedMessage) }() - 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 - try { if let v = self._optionalNestedMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestNestedMessageHasBits, rhs: ProtobufUnittest_TestNestedMessageHasBits) -> Bool { - if lhs._optionalNestedMessage != rhs._optionalNestedMessage {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestNestedMessageHasBits.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestNestedMessageHasBits.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "nestedmessage_repeated_int32"), - 2: .standard(proto: "nestedmessage_repeated_foreignmessage"), - ] - - 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.decodeRepeatedInt32Field(value: &self.nestedmessageRepeatedInt32) }() - case 2: try { try decoder.decodeRepeatedMessageField(value: &self.nestedmessageRepeatedForeignmessage) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.nestedmessageRepeatedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.nestedmessageRepeatedInt32, fieldNumber: 1) - } - if !self.nestedmessageRepeatedForeignmessage.isEmpty { - try visitor.visitRepeatedMessageField(value: self.nestedmessageRepeatedForeignmessage, fieldNumber: 2) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestNestedMessageHasBits.NestedMessage, rhs: ProtobufUnittest_TestNestedMessageHasBits.NestedMessage) -> Bool { - if lhs.nestedmessageRepeatedInt32 != rhs.nestedmessageRepeatedInt32 {return false} - if lhs.nestedmessageRepeatedForeignmessage != rhs.nestedmessageRepeatedForeignmessage {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestCamelCaseFieldNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestCamelCaseFieldNames" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "PrimitiveField"), - 2: .same(proto: "StringField"), - 3: .same(proto: "EnumField"), - 4: .same(proto: "MessageField"), - 5: .same(proto: "StringPieceField"), - 6: .same(proto: "CordField"), - 7: .same(proto: "RepeatedPrimitiveField"), - 8: .same(proto: "RepeatedStringField"), - 9: .same(proto: "RepeatedEnumField"), - 10: .same(proto: "RepeatedMessageField"), - 11: .same(proto: "RepeatedStringPieceField"), - 12: .same(proto: "RepeatedCordField"), - ] - - 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._primitiveField) }() - case 2: try { try decoder.decodeSingularStringField(value: &self._stringField) }() - case 3: try { try decoder.decodeSingularEnumField(value: &self._enumField) }() - case 4: try { try decoder.decodeSingularMessageField(value: &self._messageField) }() - case 5: try { try decoder.decodeSingularStringField(value: &self._stringPieceField) }() - case 6: try { try decoder.decodeSingularStringField(value: &self._cordField) }() - case 7: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedPrimitiveField) }() - case 8: try { try decoder.decodeRepeatedStringField(value: &self.repeatedStringField) }() - case 9: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedEnumField) }() - case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedMessageField) }() - case 11: try { try decoder.decodeRepeatedStringField(value: &self.repeatedStringPieceField) }() - case 12: try { try decoder.decodeRepeatedStringField(value: &self.repeatedCordField) }() - 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 - try { if let v = self._primitiveField { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._stringField { - try visitor.visitSingularStringField(value: v, fieldNumber: 2) - } }() - try { if let v = self._enumField { - try visitor.visitSingularEnumField(value: v, fieldNumber: 3) - } }() - try { if let v = self._messageField { - try visitor.visitSingularMessageField(value: v, fieldNumber: 4) - } }() - try { if let v = self._stringPieceField { - try visitor.visitSingularStringField(value: v, fieldNumber: 5) - } }() - try { if let v = self._cordField { - try visitor.visitSingularStringField(value: v, fieldNumber: 6) - } }() - if !self.repeatedPrimitiveField.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.repeatedPrimitiveField, fieldNumber: 7) - } - if !self.repeatedStringField.isEmpty { - try visitor.visitRepeatedStringField(value: self.repeatedStringField, fieldNumber: 8) - } - if !self.repeatedEnumField.isEmpty { - try visitor.visitRepeatedEnumField(value: self.repeatedEnumField, fieldNumber: 9) - } - if !self.repeatedMessageField.isEmpty { - try visitor.visitRepeatedMessageField(value: self.repeatedMessageField, fieldNumber: 10) - } - if !self.repeatedStringPieceField.isEmpty { - try visitor.visitRepeatedStringField(value: self.repeatedStringPieceField, fieldNumber: 11) - } - if !self.repeatedCordField.isEmpty { - try visitor.visitRepeatedStringField(value: self.repeatedCordField, fieldNumber: 12) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestCamelCaseFieldNames, rhs: ProtobufUnittest_TestCamelCaseFieldNames) -> Bool { - if lhs._primitiveField != rhs._primitiveField {return false} - if lhs._stringField != rhs._stringField {return false} - if lhs._enumField != rhs._enumField {return false} - if lhs._messageField != rhs._messageField {return false} - if lhs._stringPieceField != rhs._stringPieceField {return false} - if lhs._cordField != rhs._cordField {return false} - if lhs.repeatedPrimitiveField != rhs.repeatedPrimitiveField {return false} - if lhs.repeatedStringField != rhs.repeatedStringField {return false} - if lhs.repeatedEnumField != rhs.repeatedEnumField {return false} - if lhs.repeatedMessageField != rhs.repeatedMessageField {return false} - if lhs.repeatedStringPieceField != rhs.repeatedStringPieceField {return false} - if lhs.repeatedCordField != rhs.repeatedCordField {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestFieldOrderings: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestFieldOrderings" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 11: .standard(proto: "my_string"), - 1: .standard(proto: "my_int"), - 101: .standard(proto: "my_float"), - 200: .standard(proto: "optional_nested_message"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - 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.decodeSingularInt64Field(value: &self._myInt) }() - case 11: try { try decoder.decodeSingularStringField(value: &self._myString) }() - case 101: try { try decoder.decodeSingularFloatField(value: &self._myFloat) }() - case 200: try { try decoder.decodeSingularMessageField(value: &self._optionalNestedMessage) }() - case 2..<11, 12..<101: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestFieldOrderings.self, fieldNumber: fieldNumber) }() - 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 - try { if let v = self._myInt { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 1) - } }() - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2, end: 11) - try { if let v = self._myString { - try visitor.visitSingularStringField(value: v, fieldNumber: 11) - } }() - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 12, end: 101) - try { if let v = self._myFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 101) - } }() - try { if let v = self._optionalNestedMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 200) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestFieldOrderings, rhs: ProtobufUnittest_TestFieldOrderings) -> Bool { - if lhs._myString != rhs._myString {return false} - if lhs._myInt != rhs._myInt {return false} - if lhs._myFloat != rhs._myFloat {return false} - if lhs._optionalNestedMessage != rhs._optionalNestedMessage {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestFieldOrderings.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestFieldOrderings.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2: .same(proto: "oo"), - 1: .same(proto: "bb"), - ] - - 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._bb) }() - case 2: try { try decoder.decodeSingularInt64Field(value: &self._oo) }() - 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 - try { if let v = self._bb { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._oo { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestFieldOrderings.NestedMessage, rhs: ProtobufUnittest_TestFieldOrderings.NestedMessage) -> Bool { - if lhs._oo != rhs._oo {return false} - if lhs._bb != rhs._bb {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestExtensionOrderings1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestExtensionOrderings1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "my_string"), - ] - - 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._myString) }() - 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 - try { if let v = self._myString { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestExtensionOrderings1, rhs: ProtobufUnittest_TestExtensionOrderings1) -> Bool { - if lhs._myString != rhs._myString {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestExtensionOrderings2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestExtensionOrderings2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "my_string"), - ] - - 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._myString) }() - 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 - try { if let v = self._myString { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestExtensionOrderings2, rhs: ProtobufUnittest_TestExtensionOrderings2) -> Bool { - if lhs._myString != rhs._myString {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestExtensionOrderings2.protoMessageName + ".TestExtensionOrderings3" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "my_string"), - ] - - 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._myString) }() - 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 - try { if let v = self._myString { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3, rhs: ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3) -> Bool { - if lhs._myString != rhs._myString {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestExtremeDefaultValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestExtremeDefaultValues" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "escaped_bytes"), - 2: .standard(proto: "large_uint32"), - 3: .standard(proto: "large_uint64"), - 4: .standard(proto: "small_int32"), - 5: .standard(proto: "small_int64"), - 21: .standard(proto: "really_small_int32"), - 22: .standard(proto: "really_small_int64"), - 6: .standard(proto: "utf8_string"), - 7: .standard(proto: "zero_float"), - 8: .standard(proto: "one_float"), - 9: .standard(proto: "small_float"), - 10: .standard(proto: "negative_one_float"), - 11: .standard(proto: "negative_float"), - 12: .standard(proto: "large_float"), - 13: .standard(proto: "small_negative_float"), - 14: .standard(proto: "inf_double"), - 15: .standard(proto: "neg_inf_double"), - 16: .standard(proto: "nan_double"), - 17: .standard(proto: "inf_float"), - 18: .standard(proto: "neg_inf_float"), - 19: .standard(proto: "nan_float"), - 20: .standard(proto: "cpp_trigraph"), - 23: .standard(proto: "string_with_zero"), - 24: .standard(proto: "bytes_with_zero"), - 25: .standard(proto: "string_piece_with_zero"), - 26: .standard(proto: "cord_with_zero"), - 27: .standard(proto: "replacement_string"), - ] - - fileprivate class _StorageClass { - var _escapedBytes: Data? = nil - var _largeUint32: UInt32? = nil - var _largeUint64: UInt64? = nil - var _smallInt32: Int32? = nil - var _smallInt64: Int64? = nil - var _reallySmallInt32: Int32? = nil - var _reallySmallInt64: Int64? = nil - var _utf8String: String? = nil - var _zeroFloat: Float? = nil - var _oneFloat: Float? = nil - var _smallFloat: Float? = nil - var _negativeOneFloat: Float? = nil - var _negativeFloat: Float? = nil - var _largeFloat: Float? = nil - var _smallNegativeFloat: Float? = nil - var _infDouble: Double? = nil - var _negInfDouble: Double? = nil - var _nanDouble: Double? = nil - var _infFloat: Float? = nil - var _negInfFloat: Float? = nil - var _nanFloat: Float? = nil - var _cppTrigraph: String? = nil - var _stringWithZero: String? = nil - var _bytesWithZero: Data? = nil - var _stringPieceWithZero: String? = nil - var _cordWithZero: String? = nil - var _replacementString: String? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _escapedBytes = source._escapedBytes - _largeUint32 = source._largeUint32 - _largeUint64 = source._largeUint64 - _smallInt32 = source._smallInt32 - _smallInt64 = source._smallInt64 - _reallySmallInt32 = source._reallySmallInt32 - _reallySmallInt64 = source._reallySmallInt64 - _utf8String = source._utf8String - _zeroFloat = source._zeroFloat - _oneFloat = source._oneFloat - _smallFloat = source._smallFloat - _negativeOneFloat = source._negativeOneFloat - _negativeFloat = source._negativeFloat - _largeFloat = source._largeFloat - _smallNegativeFloat = source._smallNegativeFloat - _infDouble = source._infDouble - _negInfDouble = source._negInfDouble - _nanDouble = source._nanDouble - _infFloat = source._infFloat - _negInfFloat = source._negInfFloat - _nanFloat = source._nanFloat - _cppTrigraph = source._cppTrigraph - _stringWithZero = source._stringWithZero - _bytesWithZero = source._bytesWithZero - _stringPieceWithZero = source._stringPieceWithZero - _cordWithZero = source._cordWithZero - _replacementString = source._replacementString - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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.decodeSingularBytesField(value: &_storage._escapedBytes) }() - case 2: try { try decoder.decodeSingularUInt32Field(value: &_storage._largeUint32) }() - case 3: try { try decoder.decodeSingularUInt64Field(value: &_storage._largeUint64) }() - case 4: try { try decoder.decodeSingularInt32Field(value: &_storage._smallInt32) }() - case 5: try { try decoder.decodeSingularInt64Field(value: &_storage._smallInt64) }() - case 6: try { try decoder.decodeSingularStringField(value: &_storage._utf8String) }() - case 7: try { try decoder.decodeSingularFloatField(value: &_storage._zeroFloat) }() - case 8: try { try decoder.decodeSingularFloatField(value: &_storage._oneFloat) }() - case 9: try { try decoder.decodeSingularFloatField(value: &_storage._smallFloat) }() - case 10: try { try decoder.decodeSingularFloatField(value: &_storage._negativeOneFloat) }() - case 11: try { try decoder.decodeSingularFloatField(value: &_storage._negativeFloat) }() - case 12: try { try decoder.decodeSingularFloatField(value: &_storage._largeFloat) }() - case 13: try { try decoder.decodeSingularFloatField(value: &_storage._smallNegativeFloat) }() - case 14: try { try decoder.decodeSingularDoubleField(value: &_storage._infDouble) }() - case 15: try { try decoder.decodeSingularDoubleField(value: &_storage._negInfDouble) }() - case 16: try { try decoder.decodeSingularDoubleField(value: &_storage._nanDouble) }() - case 17: try { try decoder.decodeSingularFloatField(value: &_storage._infFloat) }() - case 18: try { try decoder.decodeSingularFloatField(value: &_storage._negInfFloat) }() - case 19: try { try decoder.decodeSingularFloatField(value: &_storage._nanFloat) }() - case 20: try { try decoder.decodeSingularStringField(value: &_storage._cppTrigraph) }() - case 21: try { try decoder.decodeSingularInt32Field(value: &_storage._reallySmallInt32) }() - case 22: try { try decoder.decodeSingularInt64Field(value: &_storage._reallySmallInt64) }() - case 23: try { try decoder.decodeSingularStringField(value: &_storage._stringWithZero) }() - case 24: try { try decoder.decodeSingularBytesField(value: &_storage._bytesWithZero) }() - case 25: try { try decoder.decodeSingularStringField(value: &_storage._stringPieceWithZero) }() - case 26: try { try decoder.decodeSingularStringField(value: &_storage._cordWithZero) }() - case 27: try { try decoder.decodeSingularStringField(value: &_storage._replacementString) }() - default: break - } - } - } - } - - func traverse(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._escapedBytes { - try visitor.visitSingularBytesField(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._largeUint32 { - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2) - } }() - try { if let v = _storage._largeUint64 { - try visitor.visitSingularUInt64Field(value: v, fieldNumber: 3) - } }() - try { if let v = _storage._smallInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) - } }() - try { if let v = _storage._smallInt64 { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 5) - } }() - try { if let v = _storage._utf8String { - try visitor.visitSingularStringField(value: v, fieldNumber: 6) - } }() - try { if let v = _storage._zeroFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 7) - } }() - try { if let v = _storage._oneFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 8) - } }() - try { if let v = _storage._smallFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 9) - } }() - try { if let v = _storage._negativeOneFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 10) - } }() - try { if let v = _storage._negativeFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 11) - } }() - try { if let v = _storage._largeFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 12) - } }() - try { if let v = _storage._smallNegativeFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 13) - } }() - try { if let v = _storage._infDouble { - try visitor.visitSingularDoubleField(value: v, fieldNumber: 14) - } }() - try { if let v = _storage._negInfDouble { - try visitor.visitSingularDoubleField(value: v, fieldNumber: 15) - } }() - try { if let v = _storage._nanDouble { - try visitor.visitSingularDoubleField(value: v, fieldNumber: 16) - } }() - try { if let v = _storage._infFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 17) - } }() - try { if let v = _storage._negInfFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 18) - } }() - try { if let v = _storage._nanFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 19) - } }() - try { if let v = _storage._cppTrigraph { - try visitor.visitSingularStringField(value: v, fieldNumber: 20) - } }() - try { if let v = _storage._reallySmallInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 21) - } }() - try { if let v = _storage._reallySmallInt64 { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 22) - } }() - try { if let v = _storage._stringWithZero { - try visitor.visitSingularStringField(value: v, fieldNumber: 23) - } }() - try { if let v = _storage._bytesWithZero { - try visitor.visitSingularBytesField(value: v, fieldNumber: 24) - } }() - try { if let v = _storage._stringPieceWithZero { - try visitor.visitSingularStringField(value: v, fieldNumber: 25) - } }() - try { if let v = _storage._cordWithZero { - try visitor.visitSingularStringField(value: v, fieldNumber: 26) - } }() - try { if let v = _storage._replacementString { - try visitor.visitSingularStringField(value: v, fieldNumber: 27) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestExtremeDefaultValues, rhs: ProtobufUnittest_TestExtremeDefaultValues) -> 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._escapedBytes != rhs_storage._escapedBytes {return false} - if _storage._largeUint32 != rhs_storage._largeUint32 {return false} - if _storage._largeUint64 != rhs_storage._largeUint64 {return false} - if _storage._smallInt32 != rhs_storage._smallInt32 {return false} - if _storage._smallInt64 != rhs_storage._smallInt64 {return false} - if _storage._reallySmallInt32 != rhs_storage._reallySmallInt32 {return false} - if _storage._reallySmallInt64 != rhs_storage._reallySmallInt64 {return false} - if _storage._utf8String != rhs_storage._utf8String {return false} - if _storage._zeroFloat != rhs_storage._zeroFloat {return false} - if _storage._oneFloat != rhs_storage._oneFloat {return false} - if _storage._smallFloat != rhs_storage._smallFloat {return false} - if _storage._negativeOneFloat != rhs_storage._negativeOneFloat {return false} - if _storage._negativeFloat != rhs_storage._negativeFloat {return false} - if _storage._largeFloat != rhs_storage._largeFloat {return false} - if _storage._smallNegativeFloat != rhs_storage._smallNegativeFloat {return false} - if _storage._infDouble != rhs_storage._infDouble {return false} - if _storage._negInfDouble != rhs_storage._negInfDouble {return false} - if _storage._nanDouble != rhs_storage._nanDouble {return false} - if _storage._infFloat != rhs_storage._infFloat {return false} - if _storage._negInfFloat != rhs_storage._negInfFloat {return false} - if _storage._nanFloat != rhs_storage._nanFloat {return false} - if _storage._cppTrigraph != rhs_storage._cppTrigraph {return false} - if _storage._stringWithZero != rhs_storage._stringWithZero {return false} - if _storage._bytesWithZero != rhs_storage._bytesWithZero {return false} - if _storage._stringPieceWithZero != rhs_storage._stringPieceWithZero {return false} - if _storage._cordWithZero != rhs_storage._cordWithZero {return false} - if _storage._replacementString != rhs_storage._replacementString {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_SparseEnumMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".SparseEnumMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "sparse_enum"), - ] - - 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._sparseEnum) }() - 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 - try { if let v = self._sparseEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_SparseEnumMessage, rhs: ProtobufUnittest_SparseEnumMessage) -> Bool { - if lhs._sparseEnum != rhs._sparseEnum {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_OneString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".OneString" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] - - 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._data) }() - 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 - try { if let v = self._data { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_OneString, rhs: ProtobufUnittest_OneString) -> Bool { - if lhs._data != rhs._data {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_MoreString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".MoreString" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] - - 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.decodeRepeatedStringField(value: &self.data) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.data.isEmpty { - try visitor.visitRepeatedStringField(value: self.data, fieldNumber: 1) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_MoreString, rhs: ProtobufUnittest_MoreString) -> Bool { - if lhs.data != rhs.data {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_OneBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".OneBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] - - 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.decodeSingularBytesField(value: &self._data) }() - 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 - try { if let v = self._data { - try visitor.visitSingularBytesField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_OneBytes, rhs: ProtobufUnittest_OneBytes) -> Bool { - if lhs._data != rhs._data {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_MoreBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".MoreBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] - - 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.decodeRepeatedBytesField(value: &self.data) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.data.isEmpty { - try visitor.visitRepeatedBytesField(value: self.data, fieldNumber: 1) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_MoreBytes, rhs: ProtobufUnittest_MoreBytes) -> Bool { - if lhs.data != rhs.data {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_Int32Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".Int32Message" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] - - 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._data) }() - 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 - try { if let v = self._data { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_Int32Message, rhs: ProtobufUnittest_Int32Message) -> Bool { - if lhs._data != rhs._data {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_Uint32Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".Uint32Message" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] - - 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._data) }() - 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 - try { if let v = self._data { - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_Uint32Message, rhs: ProtobufUnittest_Uint32Message) -> Bool { - if lhs._data != rhs._data {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_Int64Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".Int64Message" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] - - 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.decodeSingularInt64Field(value: &self._data) }() - 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 - try { if let v = self._data { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_Int64Message, rhs: ProtobufUnittest_Int64Message) -> Bool { - if lhs._data != rhs._data {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_Uint64Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".Uint64Message" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] - - 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.decodeSingularUInt64Field(value: &self._data) }() - 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 - try { if let v = self._data { - try visitor.visitSingularUInt64Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_Uint64Message, rhs: ProtobufUnittest_Uint64Message) -> Bool { - if lhs._data != rhs._data {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_BoolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".BoolMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] - - 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.decodeSingularBoolField(value: &self._data) }() - 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 - try { if let v = self._data { - try visitor.visitSingularBoolField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_BoolMessage, rhs: ProtobufUnittest_BoolMessage) -> Bool { - if lhs._data != rhs._data {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestOneof" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "foo_int"), - 2: .standard(proto: "foo_string"), - 3: .standard(proto: "foo_message"), - 4: .unique(proto: "FooGroup", json: "foogroup"), - ] - - 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: Int32? - try decoder.decodeSingularInt32Field(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooInt(v) - } - }() - case 2: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooString(v) - } - }() - case 3: try { - var v: ProtobufUnittest_TestAllTypes? - var hadOneofValue = false - if let current = self.foo { - hadOneofValue = true - if case .fooMessage(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.foo = .fooMessage(v) - } - }() - case 4: try { - var v: ProtobufUnittest_TestOneof.FooGroup? - var hadOneofValue = false - if let current = self.foo { - hadOneofValue = true - if case .fooGroup(let m) = current {v = m} - } - try decoder.decodeSingularGroupField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.foo = .fooGroup(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.foo { - case .fooInt?: try { - guard case .fooInt(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - }() - case .fooString?: try { - guard case .fooString(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 2) - }() - case .fooMessage?: try { - guard case .fooMessage(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - }() - case .fooGroup?: try { - guard case .fooGroup(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularGroupField(value: v, fieldNumber: 4) - }() - case nil: break - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestOneof, rhs: ProtobufUnittest_TestOneof) -> Bool { - if lhs.foo != rhs.foo {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestOneof.FooGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestOneof.protoMessageName + ".FooGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 5: .same(proto: "a"), - 6: .same(proto: "b"), - ] - - 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 5: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - case 6: try { try decoder.decodeSingularStringField(value: &self._b) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) - } }() - try { if let v = self._b { - try visitor.visitSingularStringField(value: v, fieldNumber: 6) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestOneof.FooGroup, rhs: ProtobufUnittest_TestOneof.FooGroup) -> Bool { - if lhs._a != rhs._a {return false} - if lhs._b != rhs._b {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestOneofBackwardsCompatible: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestOneofBackwardsCompatible" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "foo_int"), - 2: .standard(proto: "foo_string"), - 3: .standard(proto: "foo_message"), - 4: .unique(proto: "FooGroup", json: "foogroup"), - ] - - 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._fooInt) }() - case 2: try { try decoder.decodeSingularStringField(value: &self._fooString) }() - case 3: try { try decoder.decodeSingularMessageField(value: &self._fooMessage) }() - case 4: try { try decoder.decodeSingularGroupField(value: &self._fooGroup) }() - 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 - try { if let v = self._fooInt { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._fooString { - try visitor.visitSingularStringField(value: v, fieldNumber: 2) - } }() - try { if let v = self._fooMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - } }() - try { if let v = self._fooGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 4) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestOneofBackwardsCompatible, rhs: ProtobufUnittest_TestOneofBackwardsCompatible) -> Bool { - if lhs._fooInt != rhs._fooInt {return false} - if lhs._fooString != rhs._fooString {return false} - if lhs._fooMessage != rhs._fooMessage {return false} - if lhs._fooGroup != rhs._fooGroup {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestOneofBackwardsCompatible.FooGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestOneofBackwardsCompatible.protoMessageName + ".FooGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 5: .same(proto: "a"), - 6: .same(proto: "b"), - ] - - 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 5: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - case 6: try { try decoder.decodeSingularStringField(value: &self._b) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) - } }() - try { if let v = self._b { - try visitor.visitSingularStringField(value: v, fieldNumber: 6) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestOneofBackwardsCompatible.FooGroup, rhs: ProtobufUnittest_TestOneofBackwardsCompatible.FooGroup) -> Bool { - if lhs._a != rhs._a {return false} - if lhs._b != rhs._b {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestOneof2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestOneof2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "foo_int"), - 2: .standard(proto: "foo_string"), - 3: .standard(proto: "foo_cord"), - 4: .standard(proto: "foo_string_piece"), - 5: .standard(proto: "foo_bytes"), - 6: .standard(proto: "foo_enum"), - 7: .standard(proto: "foo_message"), - 8: .unique(proto: "FooGroup", json: "foogroup"), - 11: .standard(proto: "foo_lazy_message"), - 12: .standard(proto: "bar_int"), - 13: .standard(proto: "bar_string"), - 14: .standard(proto: "bar_cord"), - 15: .standard(proto: "bar_string_piece"), - 16: .standard(proto: "bar_bytes"), - 17: .standard(proto: "bar_enum"), - 20: .standard(proto: "bar_string_with_empty_default"), - 21: .standard(proto: "bar_cord_with_empty_default"), - 22: .standard(proto: "bar_string_piece_with_empty_default"), - 23: .standard(proto: "bar_bytes_with_empty_default"), - 18: .standard(proto: "baz_int"), - 19: .standard(proto: "baz_string"), - ] - - 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: Int32? - try decoder.decodeSingularInt32Field(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooInt(v) - } - }() - case 2: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooString(v) - } - }() - case 3: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooCord(v) - } - }() - case 4: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooStringPiece(v) - } - }() - case 5: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooBytes(v) - } - }() - case 6: try { - var v: ProtobufUnittest_TestOneof2.NestedEnum? - try decoder.decodeSingularEnumField(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooEnum(v) - } - }() - case 7: try { - var v: ProtobufUnittest_TestOneof2.NestedMessage? - var hadOneofValue = false - if let current = self.foo { - hadOneofValue = true - if case .fooMessage(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.foo = .fooMessage(v) - } - }() - case 8: try { - var v: ProtobufUnittest_TestOneof2.FooGroup? - var hadOneofValue = false - if let current = self.foo { - hadOneofValue = true - if case .fooGroup(let m) = current {v = m} - } - try decoder.decodeSingularGroupField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.foo = .fooGroup(v) - } - }() - case 11: try { - var v: ProtobufUnittest_TestOneof2.NestedMessage? - var hadOneofValue = false - if let current = self.foo { - hadOneofValue = true - if case .fooLazyMessage(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.foo = .fooLazyMessage(v) - } - }() - case 12: try { - var v: Int32? - try decoder.decodeSingularInt32Field(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barInt(v) - } - }() - case 13: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barString(v) - } - }() - case 14: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barCord(v) - } - }() - case 15: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barStringPiece(v) - } - }() - case 16: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barBytes(v) - } - }() - case 17: try { - var v: ProtobufUnittest_TestOneof2.NestedEnum? - try decoder.decodeSingularEnumField(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barEnum(v) - } - }() - case 18: try { try decoder.decodeSingularInt32Field(value: &self._bazInt) }() - case 19: try { try decoder.decodeSingularStringField(value: &self._bazString) }() - case 20: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barStringWithEmptyDefault(v) - } - }() - case 21: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barCordWithEmptyDefault(v) - } - }() - case 22: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barStringPieceWithEmptyDefault(v) - } - }() - case 23: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barBytesWithEmptyDefault(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.foo { - case .fooInt?: try { - guard case .fooInt(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - }() - case .fooString?: try { - guard case .fooString(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 2) - }() - case .fooCord?: try { - guard case .fooCord(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 3) - }() - case .fooStringPiece?: try { - guard case .fooStringPiece(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 4) - }() - case .fooBytes?: try { - guard case .fooBytes(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 5) - }() - case .fooEnum?: try { - guard case .fooEnum(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularEnumField(value: v, fieldNumber: 6) - }() - case .fooMessage?: try { - guard case .fooMessage(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 7) - }() - case .fooGroup?: try { - guard case .fooGroup(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularGroupField(value: v, fieldNumber: 8) - }() - case .fooLazyMessage?: try { - guard case .fooLazyMessage(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 11) - }() - case nil: break - } - switch self.bar { - case .barInt?: try { - guard case .barInt(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularInt32Field(value: v, fieldNumber: 12) - }() - case .barString?: try { - guard case .barString(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 13) - }() - case .barCord?: try { - guard case .barCord(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 14) - }() - case .barStringPiece?: try { - guard case .barStringPiece(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 15) - }() - case .barBytes?: try { - guard case .barBytes(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 16) - }() - case .barEnum?: try { - guard case .barEnum(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularEnumField(value: v, fieldNumber: 17) - }() - default: break - } - try { if let v = self._bazInt { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 18) - } }() - try { if let v = self._bazString { - try visitor.visitSingularStringField(value: v, fieldNumber: 19) - } }() - switch self.bar { - case .barStringWithEmptyDefault?: try { - guard case .barStringWithEmptyDefault(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 20) - }() - case .barCordWithEmptyDefault?: try { - guard case .barCordWithEmptyDefault(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 21) - }() - case .barStringPieceWithEmptyDefault?: try { - guard case .barStringPieceWithEmptyDefault(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 22) - }() - case .barBytesWithEmptyDefault?: try { - guard case .barBytesWithEmptyDefault(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 23) - }() - default: break - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestOneof2, rhs: ProtobufUnittest_TestOneof2) -> Bool { - if lhs.foo != rhs.foo {return false} - if lhs.bar != rhs.bar {return false} - if lhs._bazInt != rhs._bazInt {return false} - if lhs._bazString != rhs._bazString {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestOneof2.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - 3: .same(proto: "BAZ"), - ] -} - -extension ProtobufUnittest_TestOneof2.FooGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestOneof2.protoMessageName + ".FooGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 9: .same(proto: "a"), - 10: .same(proto: "b"), - ] - - 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 9: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - case 10: try { try decoder.decodeSingularStringField(value: &self._b) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) - } }() - try { if let v = self._b { - try visitor.visitSingularStringField(value: v, fieldNumber: 10) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestOneof2.FooGroup, rhs: ProtobufUnittest_TestOneof2.FooGroup) -> Bool { - if lhs._a != rhs._a {return false} - if lhs._b != rhs._b {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestOneof2.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestOneof2.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "qux_int"), - 2: .standard(proto: "corge_int"), - ] - - 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.decodeSingularInt64Field(value: &self._quxInt) }() - case 2: try { try decoder.decodeRepeatedInt32Field(value: &self.corgeInt) }() - 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 - try { if let v = self._quxInt { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 1) - } }() - if !self.corgeInt.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.corgeInt, fieldNumber: 2) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestOneof2.NestedMessage, rhs: ProtobufUnittest_TestOneof2.NestedMessage) -> Bool { - if lhs._quxInt != rhs._quxInt {return false} - if lhs.corgeInt != rhs.corgeInt {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestRequiredOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestRequiredOneof" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "foo_int"), - 2: .standard(proto: "foo_string"), - 3: .standard(proto: "foo_message"), - ] - - public var isInitialized: Bool { - if let v = self.foo, !v.isInitialized {return false} - return true - } - - 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: Int32? - try decoder.decodeSingularInt32Field(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooInt(v) - } - }() - case 2: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooString(v) - } - }() - case 3: try { - var v: ProtobufUnittest_TestRequiredOneof.NestedMessage? - var hadOneofValue = false - if let current = self.foo { - hadOneofValue = true - if case .fooMessage(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.foo = .fooMessage(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.foo { - case .fooInt?: try { - guard case .fooInt(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - }() - case .fooString?: try { - guard case .fooString(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 2) - }() - case .fooMessage?: try { - guard case .fooMessage(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - }() - case nil: break - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestRequiredOneof, rhs: ProtobufUnittest_TestRequiredOneof) -> Bool { - if lhs.foo != rhs.foo {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestRequiredOneof.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestRequiredOneof.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "required_double"), - ] - - public var isInitialized: Bool { - if self._requiredDouble == nil {return false} - return true - } - - 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.decodeSingularDoubleField(value: &self._requiredDouble) }() - 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 - try { if let v = self._requiredDouble { - try visitor.visitSingularDoubleField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestRequiredOneof.NestedMessage, rhs: ProtobufUnittest_TestRequiredOneof.NestedMessage) -> Bool { - if lhs._requiredDouble != rhs._requiredDouble {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestPackedTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 90: .standard(proto: "packed_int32"), - 91: .standard(proto: "packed_int64"), - 92: .standard(proto: "packed_uint32"), - 93: .standard(proto: "packed_uint64"), - 94: .standard(proto: "packed_sint32"), - 95: .standard(proto: "packed_sint64"), - 96: .standard(proto: "packed_fixed32"), - 97: .standard(proto: "packed_fixed64"), - 98: .standard(proto: "packed_sfixed32"), - 99: .standard(proto: "packed_sfixed64"), - 100: .standard(proto: "packed_float"), - 101: .standard(proto: "packed_double"), - 102: .standard(proto: "packed_bool"), - 103: .standard(proto: "packed_enum"), - ] - - 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 90: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32) }() - case 91: try { try decoder.decodeRepeatedInt64Field(value: &self.packedInt64) }() - case 92: try { try decoder.decodeRepeatedUInt32Field(value: &self.packedUint32) }() - case 93: try { try decoder.decodeRepeatedUInt64Field(value: &self.packedUint64) }() - case 94: try { try decoder.decodeRepeatedSInt32Field(value: &self.packedSint32) }() - case 95: try { try decoder.decodeRepeatedSInt64Field(value: &self.packedSint64) }() - case 96: try { try decoder.decodeRepeatedFixed32Field(value: &self.packedFixed32) }() - case 97: try { try decoder.decodeRepeatedFixed64Field(value: &self.packedFixed64) }() - case 98: try { try decoder.decodeRepeatedSFixed32Field(value: &self.packedSfixed32) }() - case 99: try { try decoder.decodeRepeatedSFixed64Field(value: &self.packedSfixed64) }() - case 100: try { try decoder.decodeRepeatedFloatField(value: &self.packedFloat) }() - case 101: try { try decoder.decodeRepeatedDoubleField(value: &self.packedDouble) }() - case 102: try { try decoder.decodeRepeatedBoolField(value: &self.packedBool) }() - case 103: try { try decoder.decodeRepeatedEnumField(value: &self.packedEnum) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.packedInt32.isEmpty { - try visitor.visitPackedInt32Field(value: self.packedInt32, fieldNumber: 90) - } - if !self.packedInt64.isEmpty { - try visitor.visitPackedInt64Field(value: self.packedInt64, fieldNumber: 91) - } - if !self.packedUint32.isEmpty { - try visitor.visitPackedUInt32Field(value: self.packedUint32, fieldNumber: 92) - } - if !self.packedUint64.isEmpty { - try visitor.visitPackedUInt64Field(value: self.packedUint64, fieldNumber: 93) - } - if !self.packedSint32.isEmpty { - try visitor.visitPackedSInt32Field(value: self.packedSint32, fieldNumber: 94) - } - if !self.packedSint64.isEmpty { - try visitor.visitPackedSInt64Field(value: self.packedSint64, fieldNumber: 95) - } - if !self.packedFixed32.isEmpty { - try visitor.visitPackedFixed32Field(value: self.packedFixed32, fieldNumber: 96) - } - if !self.packedFixed64.isEmpty { - try visitor.visitPackedFixed64Field(value: self.packedFixed64, fieldNumber: 97) - } - if !self.packedSfixed32.isEmpty { - try visitor.visitPackedSFixed32Field(value: self.packedSfixed32, fieldNumber: 98) - } - if !self.packedSfixed64.isEmpty { - try visitor.visitPackedSFixed64Field(value: self.packedSfixed64, fieldNumber: 99) - } - if !self.packedFloat.isEmpty { - try visitor.visitPackedFloatField(value: self.packedFloat, fieldNumber: 100) - } - if !self.packedDouble.isEmpty { - try visitor.visitPackedDoubleField(value: self.packedDouble, fieldNumber: 101) - } - if !self.packedBool.isEmpty { - try visitor.visitPackedBoolField(value: self.packedBool, fieldNumber: 102) - } - if !self.packedEnum.isEmpty { - try visitor.visitPackedEnumField(value: self.packedEnum, fieldNumber: 103) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestPackedTypes, rhs: ProtobufUnittest_TestPackedTypes) -> Bool { - if lhs.packedInt32 != rhs.packedInt32 {return false} - if lhs.packedInt64 != rhs.packedInt64 {return false} - if lhs.packedUint32 != rhs.packedUint32 {return false} - if lhs.packedUint64 != rhs.packedUint64 {return false} - if lhs.packedSint32 != rhs.packedSint32 {return false} - if lhs.packedSint64 != rhs.packedSint64 {return false} - if lhs.packedFixed32 != rhs.packedFixed32 {return false} - if lhs.packedFixed64 != rhs.packedFixed64 {return false} - if lhs.packedSfixed32 != rhs.packedSfixed32 {return false} - if lhs.packedSfixed64 != rhs.packedSfixed64 {return false} - if lhs.packedFloat != rhs.packedFloat {return false} - if lhs.packedDouble != rhs.packedDouble {return false} - if lhs.packedBool != rhs.packedBool {return false} - if lhs.packedEnum != rhs.packedEnum {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestUnpackedTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 90: .standard(proto: "unpacked_int32"), - 91: .standard(proto: "unpacked_int64"), - 92: .standard(proto: "unpacked_uint32"), - 93: .standard(proto: "unpacked_uint64"), - 94: .standard(proto: "unpacked_sint32"), - 95: .standard(proto: "unpacked_sint64"), - 96: .standard(proto: "unpacked_fixed32"), - 97: .standard(proto: "unpacked_fixed64"), - 98: .standard(proto: "unpacked_sfixed32"), - 99: .standard(proto: "unpacked_sfixed64"), - 100: .standard(proto: "unpacked_float"), - 101: .standard(proto: "unpacked_double"), - 102: .standard(proto: "unpacked_bool"), - 103: .standard(proto: "unpacked_enum"), - ] - - 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 90: try { try decoder.decodeRepeatedInt32Field(value: &self.unpackedInt32) }() - case 91: try { try decoder.decodeRepeatedInt64Field(value: &self.unpackedInt64) }() - case 92: try { try decoder.decodeRepeatedUInt32Field(value: &self.unpackedUint32) }() - case 93: try { try decoder.decodeRepeatedUInt64Field(value: &self.unpackedUint64) }() - case 94: try { try decoder.decodeRepeatedSInt32Field(value: &self.unpackedSint32) }() - case 95: try { try decoder.decodeRepeatedSInt64Field(value: &self.unpackedSint64) }() - case 96: try { try decoder.decodeRepeatedFixed32Field(value: &self.unpackedFixed32) }() - case 97: try { try decoder.decodeRepeatedFixed64Field(value: &self.unpackedFixed64) }() - case 98: try { try decoder.decodeRepeatedSFixed32Field(value: &self.unpackedSfixed32) }() - case 99: try { try decoder.decodeRepeatedSFixed64Field(value: &self.unpackedSfixed64) }() - case 100: try { try decoder.decodeRepeatedFloatField(value: &self.unpackedFloat) }() - case 101: try { try decoder.decodeRepeatedDoubleField(value: &self.unpackedDouble) }() - case 102: try { try decoder.decodeRepeatedBoolField(value: &self.unpackedBool) }() - case 103: try { try decoder.decodeRepeatedEnumField(value: &self.unpackedEnum) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.unpackedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.unpackedInt32, fieldNumber: 90) - } - if !self.unpackedInt64.isEmpty { - try visitor.visitRepeatedInt64Field(value: self.unpackedInt64, fieldNumber: 91) - } - if !self.unpackedUint32.isEmpty { - try visitor.visitRepeatedUInt32Field(value: self.unpackedUint32, fieldNumber: 92) - } - if !self.unpackedUint64.isEmpty { - try visitor.visitRepeatedUInt64Field(value: self.unpackedUint64, fieldNumber: 93) - } - if !self.unpackedSint32.isEmpty { - try visitor.visitRepeatedSInt32Field(value: self.unpackedSint32, fieldNumber: 94) - } - if !self.unpackedSint64.isEmpty { - try visitor.visitRepeatedSInt64Field(value: self.unpackedSint64, fieldNumber: 95) - } - if !self.unpackedFixed32.isEmpty { - try visitor.visitRepeatedFixed32Field(value: self.unpackedFixed32, fieldNumber: 96) - } - if !self.unpackedFixed64.isEmpty { - try visitor.visitRepeatedFixed64Field(value: self.unpackedFixed64, fieldNumber: 97) - } - if !self.unpackedSfixed32.isEmpty { - try visitor.visitRepeatedSFixed32Field(value: self.unpackedSfixed32, fieldNumber: 98) - } - if !self.unpackedSfixed64.isEmpty { - try visitor.visitRepeatedSFixed64Field(value: self.unpackedSfixed64, fieldNumber: 99) - } - if !self.unpackedFloat.isEmpty { - try visitor.visitRepeatedFloatField(value: self.unpackedFloat, fieldNumber: 100) - } - if !self.unpackedDouble.isEmpty { - try visitor.visitRepeatedDoubleField(value: self.unpackedDouble, fieldNumber: 101) - } - if !self.unpackedBool.isEmpty { - try visitor.visitRepeatedBoolField(value: self.unpackedBool, fieldNumber: 102) - } - if !self.unpackedEnum.isEmpty { - try visitor.visitRepeatedEnumField(value: self.unpackedEnum, fieldNumber: 103) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestUnpackedTypes, rhs: ProtobufUnittest_TestUnpackedTypes) -> Bool { - if lhs.unpackedInt32 != rhs.unpackedInt32 {return false} - if lhs.unpackedInt64 != rhs.unpackedInt64 {return false} - if lhs.unpackedUint32 != rhs.unpackedUint32 {return false} - if lhs.unpackedUint64 != rhs.unpackedUint64 {return false} - if lhs.unpackedSint32 != rhs.unpackedSint32 {return false} - if lhs.unpackedSint64 != rhs.unpackedSint64 {return false} - if lhs.unpackedFixed32 != rhs.unpackedFixed32 {return false} - if lhs.unpackedFixed64 != rhs.unpackedFixed64 {return false} - if lhs.unpackedSfixed32 != rhs.unpackedSfixed32 {return false} - if lhs.unpackedSfixed64 != rhs.unpackedSfixed64 {return false} - if lhs.unpackedFloat != rhs.unpackedFloat {return false} - if lhs.unpackedDouble != rhs.unpackedDouble {return false} - if lhs.unpackedBool != rhs.unpackedBool {return false} - if lhs.unpackedEnum != rhs.unpackedEnum {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestPackedExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestPackedExtensions" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestPackedExtensions.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestPackedExtensions, rhs: ProtobufUnittest_TestPackedExtensions) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestUnpackedExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestUnpackedExtensions" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestUnpackedExtensions.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestUnpackedExtensions, rhs: ProtobufUnittest_TestUnpackedExtensions) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestDynamicExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestDynamicExtensions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2000: .standard(proto: "scalar_extension"), - 2001: .standard(proto: "enum_extension"), - 2002: .standard(proto: "dynamic_enum_extension"), - 2003: .standard(proto: "message_extension"), - 2004: .standard(proto: "dynamic_message_extension"), - 2005: .standard(proto: "repeated_extension"), - 2006: .standard(proto: "packed_extension"), - ] - - 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 2000: try { try decoder.decodeSingularFixed32Field(value: &self._scalarExtension) }() - case 2001: try { try decoder.decodeSingularEnumField(value: &self._enumExtension) }() - case 2002: try { try decoder.decodeSingularEnumField(value: &self._dynamicEnumExtension) }() - case 2003: try { try decoder.decodeSingularMessageField(value: &self._messageExtension) }() - case 2004: try { try decoder.decodeSingularMessageField(value: &self._dynamicMessageExtension) }() - case 2005: try { try decoder.decodeRepeatedStringField(value: &self.repeatedExtension) }() - case 2006: try { try decoder.decodeRepeatedSInt32Field(value: &self.packedExtension) }() - 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 - try { if let v = self._scalarExtension { - try visitor.visitSingularFixed32Field(value: v, fieldNumber: 2000) - } }() - try { if let v = self._enumExtension { - try visitor.visitSingularEnumField(value: v, fieldNumber: 2001) - } }() - try { if let v = self._dynamicEnumExtension { - try visitor.visitSingularEnumField(value: v, fieldNumber: 2002) - } }() - try { if let v = self._messageExtension { - try visitor.visitSingularMessageField(value: v, fieldNumber: 2003) - } }() - try { if let v = self._dynamicMessageExtension { - try visitor.visitSingularMessageField(value: v, fieldNumber: 2004) - } }() - if !self.repeatedExtension.isEmpty { - try visitor.visitRepeatedStringField(value: self.repeatedExtension, fieldNumber: 2005) - } - if !self.packedExtension.isEmpty { - try visitor.visitPackedSInt32Field(value: self.packedExtension, fieldNumber: 2006) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestDynamicExtensions, rhs: ProtobufUnittest_TestDynamicExtensions) -> Bool { - if lhs._scalarExtension != rhs._scalarExtension {return false} - if lhs._enumExtension != rhs._enumExtension {return false} - if lhs._dynamicEnumExtension != rhs._dynamicEnumExtension {return false} - if lhs._messageExtension != rhs._messageExtension {return false} - if lhs._dynamicMessageExtension != rhs._dynamicMessageExtension {return false} - if lhs.repeatedExtension != rhs.repeatedExtension {return false} - if lhs.packedExtension != rhs.packedExtension {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestDynamicExtensions.DynamicEnumType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2200: .same(proto: "DYNAMIC_FOO"), - 2201: .same(proto: "DYNAMIC_BAR"), - 2202: .same(proto: "DYNAMIC_BAZ"), - ] -} - -extension ProtobufUnittest_TestDynamicExtensions.DynamicMessageType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestDynamicExtensions.protoMessageName + ".DynamicMessageType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2100: .standard(proto: "dynamic_field"), - ] - - 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 2100: try { try decoder.decodeSingularInt32Field(value: &self._dynamicField) }() - 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 - try { if let v = self._dynamicField { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2100) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestDynamicExtensions.DynamicMessageType, rhs: ProtobufUnittest_TestDynamicExtensions.DynamicMessageType) -> Bool { - if lhs._dynamicField != rhs._dynamicField {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestRepeatedScalarDifferentTagSizes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestRepeatedScalarDifferentTagSizes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 12: .standard(proto: "repeated_fixed32"), - 13: .standard(proto: "repeated_int32"), - 2046: .standard(proto: "repeated_fixed64"), - 2047: .standard(proto: "repeated_int64"), - 262142: .standard(proto: "repeated_float"), - 262143: .standard(proto: "repeated_uint64"), - ] - - 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 12: try { try decoder.decodeRepeatedFixed32Field(value: &self.repeatedFixed32) }() - case 13: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() - case 2046: try { try decoder.decodeRepeatedFixed64Field(value: &self.repeatedFixed64) }() - case 2047: try { try decoder.decodeRepeatedInt64Field(value: &self.repeatedInt64) }() - case 262142: try { try decoder.decodeRepeatedFloatField(value: &self.repeatedFloat) }() - case 262143: try { try decoder.decodeRepeatedUInt64Field(value: &self.repeatedUint64) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.repeatedFixed32.isEmpty { - try visitor.visitRepeatedFixed32Field(value: self.repeatedFixed32, fieldNumber: 12) - } - if !self.repeatedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 13) - } - if !self.repeatedFixed64.isEmpty { - try visitor.visitRepeatedFixed64Field(value: self.repeatedFixed64, fieldNumber: 2046) - } - if !self.repeatedInt64.isEmpty { - try visitor.visitRepeatedInt64Field(value: self.repeatedInt64, fieldNumber: 2047) - } - if !self.repeatedFloat.isEmpty { - try visitor.visitRepeatedFloatField(value: self.repeatedFloat, fieldNumber: 262142) - } - if !self.repeatedUint64.isEmpty { - try visitor.visitRepeatedUInt64Field(value: self.repeatedUint64, fieldNumber: 262143) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestRepeatedScalarDifferentTagSizes, rhs: ProtobufUnittest_TestRepeatedScalarDifferentTagSizes) -> Bool { - if lhs.repeatedFixed32 != rhs.repeatedFixed32 {return false} - if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} - if lhs.repeatedFixed64 != rhs.repeatedFixed64 {return false} - if lhs.repeatedInt64 != rhs.repeatedInt64 {return false} - if lhs.repeatedFloat != rhs.repeatedFloat {return false} - if lhs.repeatedUint64 != rhs.repeatedUint64 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestParsingMerge: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestParsingMerge" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "required_all_types"), - 2: .standard(proto: "optional_all_types"), - 3: .standard(proto: "repeated_all_types"), - 10: .unique(proto: "OptionalGroup", json: "optionalgroup"), - 20: .unique(proto: "RepeatedGroup", json: "repeatedgroup"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - if self._requiredAllTypes == nil {return false} - return true - } - - 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.decodeSingularMessageField(value: &self._requiredAllTypes) }() - case 2: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() - case 3: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() - case 10: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() - case 20: try { try decoder.decodeRepeatedGroupField(value: &self.repeatedGroup) }() - case 1000..<536870912: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestParsingMerge.self, fieldNumber: fieldNumber) }() - 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 - try { if let v = self._requiredAllTypes { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = self._optionalAllTypes { - try visitor.visitSingularMessageField(value: v, fieldNumber: 2) - } }() - if !self.repeatedAllTypes.isEmpty { - try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 3) - } - try { if let v = self._optionalGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 10) - } }() - if !self.repeatedGroup.isEmpty { - try visitor.visitRepeatedGroupField(value: self.repeatedGroup, fieldNumber: 20) - } - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestParsingMerge, rhs: ProtobufUnittest_TestParsingMerge) -> Bool { - if lhs._requiredAllTypes != rhs._requiredAllTypes {return false} - if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} - if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} - if lhs._optionalGroup != rhs._optionalGroup {return false} - if lhs.repeatedGroup != rhs.repeatedGroup {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMerge.protoMessageName + ".RepeatedFieldsGenerator" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "field1"), - 2: .same(proto: "field2"), - 3: .same(proto: "field3"), - 10: .unique(proto: "Group1", json: "group1"), - 20: .unique(proto: "Group2", json: "group2"), - 1000: .same(proto: "ext1"), - 1001: .same(proto: "ext2"), - ] - - 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.decodeRepeatedMessageField(value: &self.field1) }() - case 2: try { try decoder.decodeRepeatedMessageField(value: &self.field2) }() - case 3: try { try decoder.decodeRepeatedMessageField(value: &self.field3) }() - case 10: try { try decoder.decodeRepeatedGroupField(value: &self.group1) }() - case 20: try { try decoder.decodeRepeatedGroupField(value: &self.group2) }() - case 1000: try { try decoder.decodeRepeatedMessageField(value: &self.ext1) }() - case 1001: try { try decoder.decodeRepeatedMessageField(value: &self.ext2) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.field1.isEmpty { - try visitor.visitRepeatedMessageField(value: self.field1, fieldNumber: 1) - } - if !self.field2.isEmpty { - try visitor.visitRepeatedMessageField(value: self.field2, fieldNumber: 2) - } - if !self.field3.isEmpty { - try visitor.visitRepeatedMessageField(value: self.field3, fieldNumber: 3) - } - if !self.group1.isEmpty { - try visitor.visitRepeatedGroupField(value: self.group1, fieldNumber: 10) - } - if !self.group2.isEmpty { - try visitor.visitRepeatedGroupField(value: self.group2, fieldNumber: 20) - } - if !self.ext1.isEmpty { - try visitor.visitRepeatedMessageField(value: self.ext1, fieldNumber: 1000) - } - if !self.ext2.isEmpty { - try visitor.visitRepeatedMessageField(value: self.ext2, fieldNumber: 1001) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator, rhs: ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator) -> Bool { - if lhs.field1 != rhs.field1 {return false} - if lhs.field2 != rhs.field2 {return false} - if lhs.field3 != rhs.field3 {return false} - if lhs.group1 != rhs.group1 {return false} - if lhs.group2 != rhs.group2 {return false} - if lhs.ext1 != rhs.ext1 {return false} - if lhs.ext2 != rhs.ext2 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.protoMessageName + ".Group1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 11: .same(proto: "field1"), - ] - - 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 11: try { try decoder.decodeSingularMessageField(value: &self._field1) }() - 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 - try { if let v = self._field1 { - try visitor.visitSingularMessageField(value: v, fieldNumber: 11) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group1, rhs: ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group1) -> Bool { - if lhs._field1 != rhs._field1 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.protoMessageName + ".Group2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 21: .same(proto: "field1"), - ] - - 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 21: try { try decoder.decodeSingularMessageField(value: &self._field1) }() - 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 - try { if let v = self._field1 { - try visitor.visitSingularMessageField(value: v, fieldNumber: 21) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group2, rhs: ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group2) -> Bool { - if lhs._field1 != rhs._field1 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestParsingMerge.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMerge.protoMessageName + ".OptionalGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 11: .standard(proto: "optional_group_all_types"), - ] - - 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 11: try { try decoder.decodeSingularMessageField(value: &self._optionalGroupAllTypes) }() - 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 - try { if let v = self._optionalGroupAllTypes { - try visitor.visitSingularMessageField(value: v, fieldNumber: 11) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestParsingMerge.OptionalGroup, rhs: ProtobufUnittest_TestParsingMerge.OptionalGroup) -> Bool { - if lhs._optionalGroupAllTypes != rhs._optionalGroupAllTypes {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestParsingMerge.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMerge.protoMessageName + ".RepeatedGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 21: .standard(proto: "repeated_group_all_types"), - ] - - 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 21: try { try decoder.decodeSingularMessageField(value: &self._repeatedGroupAllTypes) }() - 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 - try { if let v = self._repeatedGroupAllTypes { - try visitor.visitSingularMessageField(value: v, fieldNumber: 21) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestParsingMerge.RepeatedGroup, rhs: ProtobufUnittest_TestParsingMerge.RepeatedGroup) -> Bool { - if lhs._repeatedGroupAllTypes != rhs._repeatedGroupAllTypes {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestCommentInjectionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestCommentInjectionMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] - - 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._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestCommentInjectionMessage, rhs: ProtobufUnittest_TestCommentInjectionMessage) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_FooRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".FooRequest" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_FooRequest, rhs: ProtobufUnittest_FooRequest) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_FooResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".FooResponse" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_FooResponse, rhs: ProtobufUnittest_FooResponse) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_FooClientMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".FooClientMessage" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_FooClientMessage, rhs: ProtobufUnittest_FooClientMessage) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_FooServerMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".FooServerMessage" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_FooServerMessage, rhs: ProtobufUnittest_FooServerMessage) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_BarRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".BarRequest" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_BarRequest, rhs: ProtobufUnittest_BarRequest) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_BarResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".BarResponse" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_BarResponse, rhs: ProtobufUnittest_BarResponse) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestJsonName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestJsonName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "field_name1"), - 2: .same(proto: "fieldName2"), - 3: .same(proto: "FieldName3"), - 4: .standard(proto: "_field_name4"), - 5: .standard(proto: "FIELD_NAME5"), - 6: .unique(proto: "field_name6", json: "@type"), - 7: .same(proto: "fieldname7"), - ] - - 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._fieldName1) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &self._fieldName2) }() - case 3: try { try decoder.decodeSingularInt32Field(value: &self._fieldName3) }() - case 4: try { try decoder.decodeSingularInt32Field(value: &self._fieldName4) }() - case 5: try { try decoder.decodeSingularInt32Field(value: &self._fieldName5) }() - case 6: try { try decoder.decodeSingularInt32Field(value: &self._fieldName6) }() - case 7: try { try decoder.decodeSingularInt32Field(value: &self._fieldname7) }() - 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 - try { if let v = self._fieldName1 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._fieldName2 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try { if let v = self._fieldName3 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) - } }() - try { if let v = self._fieldName4 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) - } }() - try { if let v = self._fieldName5 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) - } }() - try { if let v = self._fieldName6 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) - } }() - try { if let v = self._fieldname7 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestJsonName, rhs: ProtobufUnittest_TestJsonName) -> Bool { - if lhs._fieldName1 != rhs._fieldName1 {return false} - if lhs._fieldName2 != rhs._fieldName2 {return false} - if lhs._fieldName3 != rhs._fieldName3 {return false} - if lhs._fieldName4 != rhs._fieldName4 {return false} - if lhs._fieldName5 != rhs._fieldName5 {return false} - if lhs._fieldName6 != rhs._fieldName6 {return false} - if lhs._fieldname7 != rhs._fieldname7 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestHugeFieldNumbers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestHugeFieldNumbers" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 536870000: .standard(proto: "optional_int32"), - 536870001: .standard(proto: "fixed_32"), - 536870002: .standard(proto: "repeated_int32"), - 536870003: .standard(proto: "packed_int32"), - 536870004: .standard(proto: "optional_enum"), - 536870005: .standard(proto: "optional_string"), - 536870006: .standard(proto: "optional_bytes"), - 536870007: .standard(proto: "optional_message"), - 536870008: .unique(proto: "OptionalGroup", json: "optionalgroup"), - 536870010: .standard(proto: "string_string_map"), - 536870011: .standard(proto: "oneof_uint32"), - 536870012: .standard(proto: "oneof_test_all_types"), - 536870013: .standard(proto: "oneof_string"), - 536870014: .standard(proto: "oneof_bytes"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - 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 536870000: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32) }() - case 536870001: try { try decoder.decodeSingularInt32Field(value: &self._fixed32) }() - case 536870002: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() - case 536870003: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32) }() - case 536870004: try { try decoder.decodeSingularEnumField(value: &self._optionalEnum) }() - case 536870005: try { try decoder.decodeSingularStringField(value: &self._optionalString) }() - case 536870006: try { try decoder.decodeSingularBytesField(value: &self._optionalBytes) }() - case 536870007: try { try decoder.decodeSingularMessageField(value: &self._optionalMessage) }() - case 536870008: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() - case 536870010: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.stringStringMap) }() - case 536870011: try { - var v: UInt32? - try decoder.decodeSingularUInt32Field(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofUint32(v) - } - }() - case 536870012: try { - var v: ProtobufUnittest_TestAllTypes? - var hadOneofValue = false - if let current = self.oneofField { - hadOneofValue = true - if case .oneofTestAllTypes(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofTestAllTypes(v) - } - }() - case 536870013: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofString(v) - } - }() - case 536870014: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofBytes(v) - } - }() - case 536860000..<536870000: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestHugeFieldNumbers.self, fieldNumber: fieldNumber) }() - 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 - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 536860000, end: 536870000) - try { if let v = self._optionalInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870000) - } }() - try { if let v = self._fixed32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870001) - } }() - if !self.repeatedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 536870002) - } - if !self.packedInt32.isEmpty { - try visitor.visitPackedInt32Field(value: self.packedInt32, fieldNumber: 536870003) - } - try { if let v = self._optionalEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 536870004) - } }() - try { if let v = self._optionalString { - try visitor.visitSingularStringField(value: v, fieldNumber: 536870005) - } }() - try { if let v = self._optionalBytes { - try visitor.visitSingularBytesField(value: v, fieldNumber: 536870006) - } }() - try { if let v = self._optionalMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 536870007) - } }() - try { if let v = self._optionalGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 536870008) - } }() - if !self.stringStringMap.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.stringStringMap, fieldNumber: 536870010) - } - switch self.oneofField { - case .oneofUint32?: try { - guard case .oneofUint32(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 536870011) - }() - case .oneofTestAllTypes?: try { - guard case .oneofTestAllTypes(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 536870012) - }() - case .oneofString?: try { - guard case .oneofString(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 536870013) - }() - case .oneofBytes?: try { - guard case .oneofBytes(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 536870014) - }() - case nil: break - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestHugeFieldNumbers, rhs: ProtobufUnittest_TestHugeFieldNumbers) -> Bool { - if lhs._optionalInt32 != rhs._optionalInt32 {return false} - if lhs._fixed32 != rhs._fixed32 {return false} - if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} - if lhs.packedInt32 != rhs.packedInt32 {return false} - if lhs._optionalEnum != rhs._optionalEnum {return false} - if lhs._optionalString != rhs._optionalString {return false} - if lhs._optionalBytes != rhs._optionalBytes {return false} - if lhs._optionalMessage != rhs._optionalMessage {return false} - if lhs._optionalGroup != rhs._optionalGroup {return false} - if lhs.stringStringMap != rhs.stringStringMap {return false} - if lhs.oneofField != rhs.oneofField {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestHugeFieldNumbers.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestHugeFieldNumbers.protoMessageName + ".OptionalGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 536870009: .standard(proto: "group_a"), - ] - - 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 536870009: try { try decoder.decodeSingularInt32Field(value: &self._groupA) }() - 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 - try { if let v = self._groupA { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870009) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestHugeFieldNumbers.OptionalGroup, rhs: ProtobufUnittest_TestHugeFieldNumbers.OptionalGroup) -> Bool { - if lhs._groupA != rhs._groupA {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestExtensionInsideTable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestExtensionInsideTable" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "field1"), - 2: .same(proto: "field2"), - 3: .same(proto: "field3"), - 4: .same(proto: "field4"), - 6: .same(proto: "field6"), - 7: .same(proto: "field7"), - 8: .same(proto: "field8"), - 9: .same(proto: "field9"), - 10: .same(proto: "field10"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - 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._field1) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &self._field2) }() - case 3: try { try decoder.decodeSingularInt32Field(value: &self._field3) }() - case 4: try { try decoder.decodeSingularInt32Field(value: &self._field4) }() - case 6: try { try decoder.decodeSingularInt32Field(value: &self._field6) }() - case 7: try { try decoder.decodeSingularInt32Field(value: &self._field7) }() - case 8: try { try decoder.decodeSingularInt32Field(value: &self._field8) }() - case 9: try { try decoder.decodeSingularInt32Field(value: &self._field9) }() - case 10: try { try decoder.decodeSingularInt32Field(value: &self._field10) }() - case 5: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestExtensionInsideTable.self, fieldNumber: fieldNumber) }() - 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 - 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 { if let v = self._field3 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) - } }() - try { if let v = self._field4 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) - } }() - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 5, end: 6) - try { if let v = self._field6 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) - } }() - try { if let v = self._field7 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) - } }() - try { if let v = self._field8 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 8) - } }() - try { if let v = self._field9 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) - } }() - try { if let v = self._field10 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 10) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestExtensionInsideTable, rhs: ProtobufUnittest_TestExtensionInsideTable) -> Bool { - if lhs._field1 != rhs._field1 {return false} - if lhs._field2 != rhs._field2 {return false} - if lhs._field3 != rhs._field3 {return false} - if lhs._field4 != rhs._field4 {return false} - if lhs._field6 != rhs._field6 {return false} - if lhs._field7 != rhs._field7 {return false} - if lhs._field8 != rhs._field8 {return false} - if lhs._field9 != rhs._field9 {return false} - if lhs._field10 != rhs._field10 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestExtensionRangeSerialize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestExtensionRangeSerialize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "foo_one"), - 6: .standard(proto: "foo_two"), - 7: .standard(proto: "foo_three"), - 13: .standard(proto: "foo_four"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - 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._fooOne) }() - case 6: try { try decoder.decodeSingularInt32Field(value: &self._fooTwo) }() - case 7: try { try decoder.decodeSingularInt32Field(value: &self._fooThree) }() - case 13: try { try decoder.decodeSingularInt32Field(value: &self._fooFour) }() - case 2..<5, 9..<11, 15, 17, 19: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestExtensionRangeSerialize.self, fieldNumber: fieldNumber) }() - 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 - try { if let v = self._fooOne { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2, end: 5) - try { if let v = self._fooTwo { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) - } }() - try { if let v = self._fooThree { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) - } }() - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 9, end: 11) - try { if let v = self._fooFour { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 13) - } }() - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 15, end: 20) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestExtensionRangeSerialize, rhs: ProtobufUnittest_TestExtensionRangeSerialize) -> Bool { - if lhs._fooOne != rhs._fooOne {return false} - if lhs._fooTwo != rhs._fooTwo {return false} - if lhs._fooThree != rhs._fooThree {return false} - if lhs._fooFour != rhs._fooFour {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} diff --git a/Reference/google/protobuf/unittest_custom_options.pb.swift b/Reference/google/protobuf/unittest_custom_options.pb.swift deleted file mode 100644 index ba00a6a54..000000000 --- a/Reference/google/protobuf/unittest_custom_options.pb.swift +++ /dev/null @@ -1,2910 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_custom_options.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: benjy@google.com (Benjy Weinberger) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// A proto file used to test the "custom options" feature of google.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 -} - -enum ProtobufUnittest_MethodOpt1: SwiftProtobuf.Enum { - typealias RawValue = Int - case val1 // = 1 - case val2 // = 2 - - init() { - self = .val1 - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .val1 - case 2: self = .val2 - default: return nil - } - } - - var rawValue: Int { - switch self { - case .val1: return 1 - case .val2: return 2 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_MethodOpt1: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -enum ProtobufUnittest_AggregateEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case value // = 1 - - init() { - self = .value - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .value - default: return nil - } - } - - var rawValue: Int { - switch self { - case .value: return 1 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_AggregateEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// A test message with custom options at all possible locations (and also some -/// regular options, to make sure they interact nicely). -struct ProtobufUnittest_TestMessageWithCustomOptions { - // 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 _field1 ?? String()} - 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 anOneof: ProtobufUnittest_TestMessageWithCustomOptions.OneOf_AnOneof? = nil - - var oneofField: Int32 { - get { - if case .oneofField(let v)? = anOneof {return v} - return 0 - } - set {anOneof = .oneofField(newValue)} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum OneOf_AnOneof: Equatable { - case oneofField(Int32) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestMessageWithCustomOptions.OneOf_AnOneof, rhs: ProtobufUnittest_TestMessageWithCustomOptions.OneOf_AnOneof) -> 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 (.oneofField, .oneofField): return { - guard case .oneofField(let l) = lhs, case .oneofField(let r) = rhs else { preconditionFailure() } - return l == r - }() - } - } - #endif - } - - enum AnEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case val1 // = 1 - case val2 // = 2 - - init() { - self = .val1 - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .val1 - case 2: self = .val2 - default: return nil - } - } - - var rawValue: Int { - switch self { - case .val1: return 1 - case .val2: return 2 - } - } - - } - - init() {} - - fileprivate var _field1: String? = nil -} - -#if swift(>=4.2) - -extension ProtobufUnittest_TestMessageWithCustomOptions.AnEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// A test RPC service with custom options at all possible locations (and also -/// some regular options, to make sure they interact nicely). -struct ProtobufUnittest_CustomOptionFooRequest { - // 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 ProtobufUnittest_CustomOptionFooResponse { - // 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 ProtobufUnittest_CustomOptionFooClientMessage { - // 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 ProtobufUnittest_CustomOptionFooServerMessage { - // 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 ProtobufUnittest_DummyMessageContainingEnum { - // 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() - - enum TestEnumType: SwiftProtobuf.Enum { - typealias RawValue = Int - case testOptionEnumType1 // = 22 - case testOptionEnumType2 // = -23 - - init() { - self = .testOptionEnumType1 - } - - init?(rawValue: Int) { - switch rawValue { - case -23: self = .testOptionEnumType2 - case 22: self = .testOptionEnumType1 - default: return nil - } - } - - var rawValue: Int { - switch self { - case .testOptionEnumType2: return -23 - case .testOptionEnumType1: return 22 - } - } - - } - - init() {} -} - -#if swift(>=4.2) - -extension ProtobufUnittest_DummyMessageContainingEnum.TestEnumType: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_DummyMessageInvalidAsOptionType { - // 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 ProtobufUnittest_CustomOptionMinIntegerValues { - // 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 ProtobufUnittest_CustomOptionMaxIntegerValues { - // 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 ProtobufUnittest_CustomOptionOtherValues { - // 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 ProtobufUnittest_SettingRealsFromPositiveInts { - // 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 ProtobufUnittest_SettingRealsFromNegativeInts { - // 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 ProtobufUnittest_ComplexOptionType1: 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 foo: Int32 { - get {return _foo ?? 0} - set {_foo = newValue} - } - /// Returns true if `foo` has been explicitly set. - var hasFoo: Bool {return self._foo != nil} - /// Clears the value of `foo`. Subsequent reads from it will return its default value. - mutating func clearFoo() {self._foo = nil} - - var foo2: Int32 { - get {return _foo2 ?? 0} - set {_foo2 = newValue} - } - /// Returns true if `foo2` has been explicitly set. - var hasFoo2: Bool {return self._foo2 != nil} - /// Clears the value of `foo2`. Subsequent reads from it will return its default value. - mutating func clearFoo2() {self._foo2 = nil} - - var foo3: Int32 { - get {return _foo3 ?? 0} - set {_foo3 = newValue} - } - /// Returns true if `foo3` has been explicitly set. - var hasFoo3: Bool {return self._foo3 != nil} - /// Clears the value of `foo3`. Subsequent reads from it will return its default value. - mutating func clearFoo3() {self._foo3 = nil} - - var foo4: [Int32] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _foo: Int32? = nil - fileprivate var _foo2: Int32? = nil - fileprivate var _foo3: Int32? = nil -} - -struct ProtobufUnittest_ComplexOptionType2: 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 bar: ProtobufUnittest_ComplexOptionType1 { - get {return _bar ?? ProtobufUnittest_ComplexOptionType1()} - set {_bar = newValue} - } - /// Returns true if `bar` has been explicitly set. - var hasBar: Bool {return self._bar != nil} - /// Clears the value of `bar`. Subsequent reads from it will return its default value. - mutating func clearBar() {self._bar = nil} - - var baz: Int32 { - get {return _baz ?? 0} - set {_baz = newValue} - } - /// Returns true if `baz` has been explicitly set. - var hasBaz: Bool {return self._baz != nil} - /// Clears the value of `baz`. Subsequent reads from it will return its default value. - mutating func clearBaz() {self._baz = nil} - - var fred: ProtobufUnittest_ComplexOptionType2.ComplexOptionType4 { - get {return _fred ?? ProtobufUnittest_ComplexOptionType2.ComplexOptionType4()} - set {_fred = newValue} - } - /// Returns true if `fred` has been explicitly set. - var hasFred: Bool {return self._fred != nil} - /// Clears the value of `fred`. Subsequent reads from it will return its default value. - mutating func clearFred() {self._fred = nil} - - var barney: [ProtobufUnittest_ComplexOptionType2.ComplexOptionType4] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct ComplexOptionType4 { - // 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 waldo: Int32 { - get {return _waldo ?? 0} - set {_waldo = newValue} - } - /// Returns true if `waldo` has been explicitly set. - var hasWaldo: Bool {return self._waldo != nil} - /// Clears the value of `waldo`. Subsequent reads from it will return its default value. - mutating func clearWaldo() {self._waldo = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _waldo: Int32? = nil - } - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _bar: ProtobufUnittest_ComplexOptionType1? = nil - fileprivate var _baz: Int32? = nil - fileprivate var _fred: ProtobufUnittest_ComplexOptionType2.ComplexOptionType4? = nil -} - -struct ProtobufUnittest_ComplexOptionType3 { - // 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 qux: Int32 { - get {return _qux ?? 0} - set {_qux = newValue} - } - /// Returns true if `qux` has been explicitly set. - var hasQux: Bool {return self._qux != nil} - /// Clears the value of `qux`. Subsequent reads from it will return its default value. - mutating func clearQux() {self._qux = nil} - - var complexOptionType5: ProtobufUnittest_ComplexOptionType3.ComplexOptionType5 { - get {return _complexOptionType5 ?? ProtobufUnittest_ComplexOptionType3.ComplexOptionType5()} - set {_complexOptionType5 = newValue} - } - /// Returns true if `complexOptionType5` has been explicitly set. - var hasComplexOptionType5: Bool {return self._complexOptionType5 != nil} - /// Clears the value of `complexOptionType5`. Subsequent reads from it will return its default value. - mutating func clearComplexOptionType5() {self._complexOptionType5 = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct ComplexOptionType5 { - // 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 plugh: Int32 { - get {return _plugh ?? 0} - set {_plugh = newValue} - } - /// Returns true if `plugh` has been explicitly set. - var hasPlugh: Bool {return self._plugh != nil} - /// Clears the value of `plugh`. Subsequent reads from it will return its default value. - mutating func clearPlugh() {self._plugh = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _plugh: Int32? = nil - } - - init() {} - - fileprivate var _qux: Int32? = nil - fileprivate var _complexOptionType5: ProtobufUnittest_ComplexOptionType3.ComplexOptionType5? = nil -} - -struct ProtobufUnittest_ComplexOpt6 { - // 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 xyzzy: Int32 { - get {return _xyzzy ?? 0} - set {_xyzzy = newValue} - } - /// Returns true if `xyzzy` has been explicitly set. - var hasXyzzy: Bool {return self._xyzzy != nil} - /// Clears the value of `xyzzy`. Subsequent reads from it will return its default value. - mutating func clearXyzzy() {self._xyzzy = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _xyzzy: Int32? = nil -} - -/// Note that we try various different ways of naming the same extension. -struct ProtobufUnittest_VariousComplexOptions { - // 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 ProtobufUnittest_AggregateMessageSet: 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() -} - -struct ProtobufUnittest_AggregateMessageSetElement { - // 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 s: String { - get {return _s ?? String()} - set {_s = newValue} - } - /// Returns true if `s` has been explicitly set. - var hasS: Bool {return self._s != nil} - /// Clears the value of `s`. Subsequent reads from it will return its default value. - mutating func clearS() {self._s = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _s: String? = nil -} - -/// A helper type used to test aggregate option parsing -struct ProtobufUnittest_Aggregate { - // 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 i: Int32 { - get {return _storage._i ?? 0} - set {_uniqueStorage()._i = newValue} - } - /// Returns true if `i` has been explicitly set. - var hasI: Bool {return _storage._i != nil} - /// Clears the value of `i`. Subsequent reads from it will return its default value. - mutating func clearI() {_uniqueStorage()._i = nil} - - var s: String { - get {return _storage._s ?? String()} - set {_uniqueStorage()._s = newValue} - } - /// Returns true if `s` has been explicitly set. - var hasS: Bool {return _storage._s != nil} - /// Clears the value of `s`. Subsequent reads from it will return its default value. - mutating func clearS() {_uniqueStorage()._s = nil} - - /// A nested object - var sub: ProtobufUnittest_Aggregate { - get {return _storage._sub ?? ProtobufUnittest_Aggregate()} - set {_uniqueStorage()._sub = newValue} - } - /// Returns true if `sub` has been explicitly set. - var hasSub: Bool {return _storage._sub != nil} - /// Clears the value of `sub`. Subsequent reads from it will return its default value. - mutating func clearSub() {_uniqueStorage()._sub = nil} - - /// To test the parsing of extensions inside aggregate values - var file: SwiftProtobuf.Google_Protobuf_FileOptions { - get {return _storage._file ?? SwiftProtobuf.Google_Protobuf_FileOptions()} - set {_uniqueStorage()._file = newValue} - } - /// Returns true if `file` has been explicitly set. - var hasFile: Bool {return _storage._file != nil} - /// Clears the value of `file`. Subsequent reads from it will return its default value. - mutating func clearFile() {_uniqueStorage()._file = nil} - - /// An embedded message set - var mset: ProtobufUnittest_AggregateMessageSet { - get {return _storage._mset ?? ProtobufUnittest_AggregateMessageSet()} - set {_uniqueStorage()._mset = newValue} - } - /// Returns true if `mset` has been explicitly set. - var hasMset: Bool {return _storage._mset != nil} - /// Clears the value of `mset`. Subsequent reads from it will return its default value. - mutating func clearMset() {_uniqueStorage()._mset = nil} - - /// An any - var any: SwiftProtobuf.Google_Protobuf_Any { - get {return _storage._any ?? SwiftProtobuf.Google_Protobuf_Any()} - set {_uniqueStorage()._any = newValue} - } - /// Returns true if `any` has been explicitly set. - var hasAny: Bool {return _storage._any != nil} - /// Clears the value of `any`. Subsequent reads from it will return its default value. - mutating func clearAny() {_uniqueStorage()._any = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -struct ProtobufUnittest_AggregateMessage { - // 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 fieldname: Int32 { - get {return _fieldname ?? 0} - set {_fieldname = newValue} - } - /// Returns true if `fieldname` has been explicitly set. - var hasFieldname: Bool {return self._fieldname != nil} - /// Clears the value of `fieldname`. Subsequent reads from it will return its default value. - mutating func clearFieldname() {self._fieldname = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _fieldname: Int32? = nil -} - -/// Test custom options for nested type. -struct ProtobufUnittest_NestedOptionType { - // 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() - - enum NestedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case value // = 1 - - init() { - self = .value - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .value - default: return nil - } - } - - var rawValue: Int { - switch self { - case .value: return 1 - } - } - - } - - struct NestedMessage { - // 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 nestedField: Int32 { - get {return _nestedField ?? 0} - set {_nestedField = newValue} - } - /// Returns true if `nestedField` has been explicitly set. - var hasNestedField: Bool {return self._nestedField != nil} - /// Clears the value of `nestedField`. Subsequent reads from it will return its default value. - mutating func clearNestedField() {self._nestedField = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _nestedField: Int32? = nil - } - - init() {} -} - -#if swift(>=4.2) - -extension ProtobufUnittest_NestedOptionType.NestedEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// Custom message option that has a required enum field. -/// WARNING: this is strongly discouraged! -struct ProtobufUnittest_OldOptionType { - // 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 value: ProtobufUnittest_OldOptionType.TestEnum { - get {return _value ?? .oldValue} - set {_value = newValue} - } - /// Returns true if `value` has been explicitly set. - var hasValue: Bool {return self._value != nil} - /// Clears the value of `value`. Subsequent reads from it will return its default value. - mutating func clearValue() {self._value = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum TestEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case oldValue // = 0 - - init() { - self = .oldValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .oldValue - default: return nil - } - } - - var rawValue: Int { - switch self { - case .oldValue: return 0 - } - } - - } - - init() {} - - fileprivate var _value: ProtobufUnittest_OldOptionType.TestEnum? = nil -} - -#if swift(>=4.2) - -extension ProtobufUnittest_OldOptionType.TestEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// Updated version of the custom option above. -struct ProtobufUnittest_NewOptionType { - // 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 value: ProtobufUnittest_NewOptionType.TestEnum { - get {return _value ?? .oldValue} - set {_value = newValue} - } - /// Returns true if `value` has been explicitly set. - var hasValue: Bool {return self._value != nil} - /// Clears the value of `value`. Subsequent reads from it will return its default value. - mutating func clearValue() {self._value = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum TestEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case oldValue // = 0 - case newValue // = 1 - - init() { - self = .oldValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .oldValue - case 1: self = .newValue - default: return nil - } - } - - var rawValue: Int { - switch self { - case .oldValue: return 0 - case .newValue: return 1 - } - } - - } - - init() {} - - fileprivate var _value: ProtobufUnittest_NewOptionType.TestEnum? = nil -} - -#if swift(>=4.2) - -extension ProtobufUnittest_NewOptionType.TestEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// Test message using the "required_enum_opt" option defined above. -struct ProtobufUnittest_TestMessageWithRequiredEnumOption { - // 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() {} -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_MethodOpt1: @unchecked Sendable {} -extension ProtobufUnittest_AggregateEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestMessageWithCustomOptions: @unchecked Sendable {} -extension ProtobufUnittest_TestMessageWithCustomOptions.OneOf_AnOneof: @unchecked Sendable {} -extension ProtobufUnittest_TestMessageWithCustomOptions.AnEnum: @unchecked Sendable {} -extension ProtobufUnittest_CustomOptionFooRequest: @unchecked Sendable {} -extension ProtobufUnittest_CustomOptionFooResponse: @unchecked Sendable {} -extension ProtobufUnittest_CustomOptionFooClientMessage: @unchecked Sendable {} -extension ProtobufUnittest_CustomOptionFooServerMessage: @unchecked Sendable {} -extension ProtobufUnittest_DummyMessageContainingEnum: @unchecked Sendable {} -extension ProtobufUnittest_DummyMessageContainingEnum.TestEnumType: @unchecked Sendable {} -extension ProtobufUnittest_DummyMessageInvalidAsOptionType: @unchecked Sendable {} -extension ProtobufUnittest_CustomOptionMinIntegerValues: @unchecked Sendable {} -extension ProtobufUnittest_CustomOptionMaxIntegerValues: @unchecked Sendable {} -extension ProtobufUnittest_CustomOptionOtherValues: @unchecked Sendable {} -extension ProtobufUnittest_SettingRealsFromPositiveInts: @unchecked Sendable {} -extension ProtobufUnittest_SettingRealsFromNegativeInts: @unchecked Sendable {} -extension ProtobufUnittest_ComplexOptionType1: @unchecked Sendable {} -extension ProtobufUnittest_ComplexOptionType2: @unchecked Sendable {} -extension ProtobufUnittest_ComplexOptionType2.ComplexOptionType4: @unchecked Sendable {} -extension ProtobufUnittest_ComplexOptionType3: @unchecked Sendable {} -extension ProtobufUnittest_ComplexOptionType3.ComplexOptionType5: @unchecked Sendable {} -extension ProtobufUnittest_ComplexOpt6: @unchecked Sendable {} -extension ProtobufUnittest_VariousComplexOptions: @unchecked Sendable {} -extension ProtobufUnittest_AggregateMessageSet: @unchecked Sendable {} -extension ProtobufUnittest_AggregateMessageSetElement: @unchecked Sendable {} -extension ProtobufUnittest_Aggregate: @unchecked Sendable {} -extension ProtobufUnittest_AggregateMessage: @unchecked Sendable {} -extension ProtobufUnittest_NestedOptionType: @unchecked Sendable {} -extension ProtobufUnittest_NestedOptionType.NestedEnum: @unchecked Sendable {} -extension ProtobufUnittest_NestedOptionType.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_OldOptionType: @unchecked Sendable {} -extension ProtobufUnittest_OldOptionType.TestEnum: @unchecked Sendable {} -extension ProtobufUnittest_NewOptionType: @unchecked Sendable {} -extension ProtobufUnittest_NewOptionType.TestEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestMessageWithRequiredEnumOption: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Extension support defined in unittest_custom_options.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 ProtobufUnittest_AggregateMessageSet { - - var ProtobufUnittest_AggregateMessageSetElement_messageSetExtension: ProtobufUnittest_AggregateMessageSetElement { - get {return getExtensionValue(ext: ProtobufUnittest_AggregateMessageSetElement.Extensions.message_set_extension) ?? ProtobufUnittest_AggregateMessageSetElement()} - set {setExtensionValue(ext: ProtobufUnittest_AggregateMessageSetElement.Extensions.message_set_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_AggregateMessageSetElement.Extensions.message_set_extension` - /// has been explicitly set. - var hasProtobufUnittest_AggregateMessageSetElement_messageSetExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_AggregateMessageSetElement.Extensions.message_set_extension) - } - /// Clears the value of extension `ProtobufUnittest_AggregateMessageSetElement.Extensions.message_set_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_AggregateMessageSetElement_messageSetExtension() { - clearExtensionValue(ext: ProtobufUnittest_AggregateMessageSetElement.Extensions.message_set_extension) - } -} - -extension ProtobufUnittest_ComplexOptionType1 { - - var ProtobufUnittest_quux: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_quux) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_quux, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_quux` - /// has been explicitly set. - var hasProtobufUnittest_quux: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_quux) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_quux`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_quux() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_quux) - } - - var ProtobufUnittest_corge: ProtobufUnittest_ComplexOptionType3 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_corge) ?? ProtobufUnittest_ComplexOptionType3()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_corge, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_corge` - /// has been explicitly set. - var hasProtobufUnittest_corge: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_corge) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_corge`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_corge() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_corge) - } -} - -extension ProtobufUnittest_ComplexOptionType2 { - - var ProtobufUnittest_grault: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_grault) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_grault, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_grault` - /// has been explicitly set. - var hasProtobufUnittest_grault: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_grault) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_grault`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_grault() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_grault) - } - - var ProtobufUnittest_garply: ProtobufUnittest_ComplexOptionType1 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_garply) ?? ProtobufUnittest_ComplexOptionType1()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_garply, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_garply` - /// has been explicitly set. - var hasProtobufUnittest_garply: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_garply) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_garply`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_garply() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_garply) - } -} - -extension SwiftProtobuf.Google_Protobuf_EnumOptions { - - var ProtobufUnittest_enumOpt1: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_enum_opt1) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_enum_opt1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_enum_opt1` - /// has been explicitly set. - var hasProtobufUnittest_enumOpt1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_enum_opt1) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_enum_opt1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_enumOpt1() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_enum_opt1) - } - - var ProtobufUnittest_enumopt: ProtobufUnittest_Aggregate { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_enumopt) ?? ProtobufUnittest_Aggregate()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_enumopt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_enumopt` - /// has been explicitly set. - var hasProtobufUnittest_enumopt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_enumopt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_enumopt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_enumopt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_enumopt) - } -} - -extension SwiftProtobuf.Google_Protobuf_EnumValueOptions { - - var ProtobufUnittest_enumValueOpt1: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_enum_value_opt1) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_enum_value_opt1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_enum_value_opt1` - /// has been explicitly set. - var hasProtobufUnittest_enumValueOpt1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_enum_value_opt1) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_enum_value_opt1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_enumValueOpt1() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_enum_value_opt1) - } - - var ProtobufUnittest_enumvalopt: ProtobufUnittest_Aggregate { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_enumvalopt) ?? ProtobufUnittest_Aggregate()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_enumvalopt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_enumvalopt` - /// has been explicitly set. - var hasProtobufUnittest_enumvalopt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_enumvalopt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_enumvalopt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_enumvalopt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_enumvalopt) - } -} - -extension SwiftProtobuf.Google_Protobuf_FieldOptions { - - var ProtobufUnittest_fieldOpt1: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_field_opt1) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_field_opt1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_field_opt1` - /// has been explicitly set. - var hasProtobufUnittest_fieldOpt1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_field_opt1) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_field_opt1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_fieldOpt1() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_field_opt1) - } - - /// This is useful for testing that we correctly register default values for - /// extension options. - var ProtobufUnittest_fieldOpt2: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_field_opt2) ?? 42} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_field_opt2, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_field_opt2` - /// has been explicitly set. - var hasProtobufUnittest_fieldOpt2: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_field_opt2) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_field_opt2`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_fieldOpt2() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_field_opt2) - } - - var ProtobufUnittest_fieldopt: ProtobufUnittest_Aggregate { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_fieldopt) ?? ProtobufUnittest_Aggregate()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_fieldopt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_fieldopt` - /// has been explicitly set. - var hasProtobufUnittest_fieldopt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_fieldopt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_fieldopt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_fieldopt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_fieldopt) - } -} - -extension SwiftProtobuf.Google_Protobuf_FileOptions { - - var ProtobufUnittest_fileOpt1: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_file_opt1) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_file_opt1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_file_opt1` - /// has been explicitly set. - var hasProtobufUnittest_fileOpt1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_file_opt1) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_file_opt1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_fileOpt1() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_file_opt1) - } - - var ProtobufUnittest_fileopt: ProtobufUnittest_Aggregate { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_fileopt) ?? ProtobufUnittest_Aggregate()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_fileopt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_fileopt` - /// has been explicitly set. - var hasProtobufUnittest_fileopt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_fileopt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_fileopt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_fileopt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_fileopt) - } - - var ProtobufUnittest_Aggregate_nested: ProtobufUnittest_Aggregate { - get {return getExtensionValue(ext: ProtobufUnittest_Aggregate.Extensions.nested) ?? ProtobufUnittest_Aggregate()} - set {setExtensionValue(ext: ProtobufUnittest_Aggregate.Extensions.nested, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Aggregate.Extensions.nested` - /// has been explicitly set. - var hasProtobufUnittest_Aggregate_nested: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Aggregate.Extensions.nested) - } - /// Clears the value of extension `ProtobufUnittest_Aggregate.Extensions.nested`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Aggregate_nested() { - clearExtensionValue(ext: ProtobufUnittest_Aggregate.Extensions.nested) - } - - var ProtobufUnittest_NestedOptionType_nestedExtension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_NestedOptionType.Extensions.nested_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_NestedOptionType.Extensions.nested_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_NestedOptionType.Extensions.nested_extension` - /// has been explicitly set. - var hasProtobufUnittest_NestedOptionType_nestedExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_NestedOptionType.Extensions.nested_extension) - } - /// Clears the value of extension `ProtobufUnittest_NestedOptionType.Extensions.nested_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_NestedOptionType_nestedExtension() { - clearExtensionValue(ext: ProtobufUnittest_NestedOptionType.Extensions.nested_extension) - } -} - -extension SwiftProtobuf.Google_Protobuf_MessageOptions { - - var ProtobufUnittest_messageOpt1: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_message_opt1) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_message_opt1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_message_opt1` - /// has been explicitly set. - var hasProtobufUnittest_messageOpt1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_message_opt1) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_message_opt1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_messageOpt1() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_message_opt1) - } - - var ProtobufUnittest_boolOpt: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_bool_opt) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_bool_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_bool_opt` - /// has been explicitly set. - var hasProtobufUnittest_boolOpt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_bool_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_bool_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_boolOpt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_bool_opt) - } - - var ProtobufUnittest_int32Opt: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_int32_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_int32_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_int32_opt` - /// has been explicitly set. - var hasProtobufUnittest_int32Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_int32_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_int32_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_int32Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_int32_opt) - } - - var ProtobufUnittest_int64Opt: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_int64_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_int64_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_int64_opt` - /// has been explicitly set. - var hasProtobufUnittest_int64Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_int64_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_int64_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_int64Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_int64_opt) - } - - var ProtobufUnittest_uint32Opt: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_uint32_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_uint32_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_uint32_opt` - /// has been explicitly set. - var hasProtobufUnittest_uint32Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_uint32_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_uint32_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_uint32Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_uint32_opt) - } - - var ProtobufUnittest_uint64Opt: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_uint64_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_uint64_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_uint64_opt` - /// has been explicitly set. - var hasProtobufUnittest_uint64Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_uint64_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_uint64_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_uint64Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_uint64_opt) - } - - var ProtobufUnittest_sint32Opt: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_sint32_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_sint32_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_sint32_opt` - /// has been explicitly set. - var hasProtobufUnittest_sint32Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_sint32_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_sint32_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_sint32Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_sint32_opt) - } - - var ProtobufUnittest_sint64Opt: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_sint64_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_sint64_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_sint64_opt` - /// has been explicitly set. - var hasProtobufUnittest_sint64Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_sint64_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_sint64_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_sint64Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_sint64_opt) - } - - var ProtobufUnittest_fixed32Opt: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_fixed32_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_fixed32_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_fixed32_opt` - /// has been explicitly set. - var hasProtobufUnittest_fixed32Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_fixed32_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_fixed32_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_fixed32Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_fixed32_opt) - } - - var ProtobufUnittest_fixed64Opt: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_fixed64_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_fixed64_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_fixed64_opt` - /// has been explicitly set. - var hasProtobufUnittest_fixed64Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_fixed64_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_fixed64_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_fixed64Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_fixed64_opt) - } - - var ProtobufUnittest_sfixed32Opt: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_sfixed32_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_sfixed32_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_sfixed32_opt` - /// has been explicitly set. - var hasProtobufUnittest_sfixed32Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_sfixed32_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_sfixed32_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_sfixed32Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_sfixed32_opt) - } - - var ProtobufUnittest_sfixed64Opt: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_sfixed64_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_sfixed64_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_sfixed64_opt` - /// has been explicitly set. - var hasProtobufUnittest_sfixed64Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_sfixed64_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_sfixed64_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_sfixed64Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_sfixed64_opt) - } - - var ProtobufUnittest_floatOpt: Float { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_float_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_float_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_float_opt` - /// has been explicitly set. - var hasProtobufUnittest_floatOpt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_float_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_float_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_floatOpt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_float_opt) - } - - var ProtobufUnittest_doubleOpt: Double { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_double_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_double_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_double_opt` - /// has been explicitly set. - var hasProtobufUnittest_doubleOpt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_double_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_double_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_doubleOpt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_double_opt) - } - - var ProtobufUnittest_stringOpt: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_string_opt) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_string_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_string_opt` - /// has been explicitly set. - var hasProtobufUnittest_stringOpt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_string_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_string_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_stringOpt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_string_opt) - } - - var ProtobufUnittest_bytesOpt: Data { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_bytes_opt) ?? Data()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_bytes_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_bytes_opt` - /// has been explicitly set. - var hasProtobufUnittest_bytesOpt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_bytes_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_bytes_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_bytesOpt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_bytes_opt) - } - - var ProtobufUnittest_enumOpt: ProtobufUnittest_DummyMessageContainingEnum.TestEnumType { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_enum_opt) ?? .testOptionEnumType1} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_enum_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_enum_opt` - /// has been explicitly set. - var hasProtobufUnittest_enumOpt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_enum_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_enum_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_enumOpt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_enum_opt) - } - - var ProtobufUnittest_messageTypeOpt: ProtobufUnittest_DummyMessageInvalidAsOptionType { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_message_type_opt) ?? ProtobufUnittest_DummyMessageInvalidAsOptionType()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_message_type_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_message_type_opt` - /// has been explicitly set. - var hasProtobufUnittest_messageTypeOpt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_message_type_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_message_type_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_messageTypeOpt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_message_type_opt) - } - - var ProtobufUnittest_complexOpt1: ProtobufUnittest_ComplexOptionType1 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt1) ?? ProtobufUnittest_ComplexOptionType1()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_complex_opt1` - /// has been explicitly set. - var hasProtobufUnittest_complexOpt1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt1) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_complex_opt1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_complexOpt1() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt1) - } - - var ProtobufUnittest_complexOpt2: ProtobufUnittest_ComplexOptionType2 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt2) ?? ProtobufUnittest_ComplexOptionType2()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt2, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_complex_opt2` - /// has been explicitly set. - var hasProtobufUnittest_complexOpt2: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt2) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_complex_opt2`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_complexOpt2() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt2) - } - - var ProtobufUnittest_complexOpt3: ProtobufUnittest_ComplexOptionType3 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt3) ?? ProtobufUnittest_ComplexOptionType3()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt3, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_complex_opt3` - /// has been explicitly set. - var hasProtobufUnittest_complexOpt3: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt3) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_complex_opt3`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_complexOpt3() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt3) - } - - var ProtobufUnittest_complexOpt6: ProtobufUnittest_ComplexOpt6 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_ComplexOpt6) ?? ProtobufUnittest_ComplexOpt6()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_ComplexOpt6, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_ComplexOpt6` - /// has been explicitly set. - var hasProtobufUnittest_complexOpt6: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_ComplexOpt6) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_ComplexOpt6`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_complexOpt6() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_ComplexOpt6) - } - - var ProtobufUnittest_msgopt: ProtobufUnittest_Aggregate { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_msgopt) ?? ProtobufUnittest_Aggregate()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_msgopt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_msgopt` - /// has been explicitly set. - var hasProtobufUnittest_msgopt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_msgopt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_msgopt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_msgopt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_msgopt) - } - - var ProtobufUnittest_requiredEnumOpt: ProtobufUnittest_OldOptionType { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_required_enum_opt) ?? ProtobufUnittest_OldOptionType()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_required_enum_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_required_enum_opt` - /// has been explicitly set. - var hasProtobufUnittest_requiredEnumOpt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_required_enum_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_required_enum_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_requiredEnumOpt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_required_enum_opt) - } - - var ProtobufUnittest_ComplexOptionType2_ComplexOptionType4_complexOpt4: ProtobufUnittest_ComplexOptionType2.ComplexOptionType4 { - get {return getExtensionValue(ext: ProtobufUnittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4) ?? ProtobufUnittest_ComplexOptionType2.ComplexOptionType4()} - set {setExtensionValue(ext: ProtobufUnittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4` - /// has been explicitly set. - var hasProtobufUnittest_ComplexOptionType2_ComplexOptionType4_complexOpt4: Bool { - return hasExtensionValue(ext: ProtobufUnittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4) - } - /// Clears the value of extension `ProtobufUnittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_ComplexOptionType2_ComplexOptionType4_complexOpt4() { - clearExtensionValue(ext: ProtobufUnittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4) - } -} - -extension SwiftProtobuf.Google_Protobuf_MethodOptions { - - var ProtobufUnittest_methodOpt1: ProtobufUnittest_MethodOpt1 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_method_opt1) ?? .val1} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_method_opt1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_method_opt1` - /// has been explicitly set. - var hasProtobufUnittest_methodOpt1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_method_opt1) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_method_opt1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_methodOpt1() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_method_opt1) - } - - var ProtobufUnittest_methodopt: ProtobufUnittest_Aggregate { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_methodopt) ?? ProtobufUnittest_Aggregate()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_methodopt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_methodopt` - /// has been explicitly set. - var hasProtobufUnittest_methodopt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_methodopt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_methodopt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_methodopt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_methodopt) - } -} - -extension SwiftProtobuf.Google_Protobuf_OneofOptions { - - var ProtobufUnittest_oneofOpt1: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_oneof_opt1) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_oneof_opt1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_oneof_opt1` - /// has been explicitly set. - var hasProtobufUnittest_oneofOpt1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_oneof_opt1) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_oneof_opt1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_oneofOpt1() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_oneof_opt1) - } -} - -extension SwiftProtobuf.Google_Protobuf_ServiceOptions { - - var ProtobufUnittest_serviceOpt1: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_service_opt1) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_service_opt1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_service_opt1` - /// has been explicitly set. - var hasProtobufUnittest_serviceOpt1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_service_opt1) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_service_opt1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_serviceOpt1() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_service_opt1) - } - - var ProtobufUnittest_serviceopt: ProtobufUnittest_Aggregate { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_serviceopt) ?? ProtobufUnittest_Aggregate()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_serviceopt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_serviceopt` - /// has been explicitly set. - var hasProtobufUnittest_serviceopt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_serviceopt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_serviceopt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_serviceopt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_serviceopt) - } - -} - -// MARK: - File's ExtensionMap: ProtobufUnittest_UnittestCustomOptions_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 ProtobufUnittest_UnittestCustomOptions_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_Extensions_file_opt1, - ProtobufUnittest_Extensions_message_opt1, - ProtobufUnittest_Extensions_field_opt1, - ProtobufUnittest_Extensions_field_opt2, - ProtobufUnittest_Extensions_oneof_opt1, - ProtobufUnittest_Extensions_enum_opt1, - ProtobufUnittest_Extensions_enum_value_opt1, - ProtobufUnittest_Extensions_service_opt1, - ProtobufUnittest_Extensions_method_opt1, - ProtobufUnittest_Extensions_bool_opt, - ProtobufUnittest_Extensions_int32_opt, - ProtobufUnittest_Extensions_int64_opt, - ProtobufUnittest_Extensions_uint32_opt, - ProtobufUnittest_Extensions_uint64_opt, - ProtobufUnittest_Extensions_sint32_opt, - ProtobufUnittest_Extensions_sint64_opt, - ProtobufUnittest_Extensions_fixed32_opt, - ProtobufUnittest_Extensions_fixed64_opt, - ProtobufUnittest_Extensions_sfixed32_opt, - ProtobufUnittest_Extensions_sfixed64_opt, - ProtobufUnittest_Extensions_float_opt, - ProtobufUnittest_Extensions_double_opt, - ProtobufUnittest_Extensions_string_opt, - ProtobufUnittest_Extensions_bytes_opt, - ProtobufUnittest_Extensions_enum_opt, - ProtobufUnittest_Extensions_message_type_opt, - ProtobufUnittest_Extensions_quux, - ProtobufUnittest_Extensions_corge, - ProtobufUnittest_Extensions_grault, - ProtobufUnittest_Extensions_garply, - ProtobufUnittest_Extensions_complex_opt1, - ProtobufUnittest_Extensions_complex_opt2, - ProtobufUnittest_Extensions_complex_opt3, - ProtobufUnittest_Extensions_ComplexOpt6, - ProtobufUnittest_Extensions_fileopt, - ProtobufUnittest_Extensions_msgopt, - ProtobufUnittest_Extensions_fieldopt, - ProtobufUnittest_Extensions_enumopt, - ProtobufUnittest_Extensions_enumvalopt, - ProtobufUnittest_Extensions_serviceopt, - ProtobufUnittest_Extensions_methodopt, - ProtobufUnittest_Extensions_required_enum_opt, - ProtobufUnittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4, - ProtobufUnittest_AggregateMessageSetElement.Extensions.message_set_extension, - ProtobufUnittest_Aggregate.Extensions.nested, - ProtobufUnittest_NestedOptionType.Extensions.nested_extension -] - -// 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 ProtobufUnittest_Extensions_file_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( - _protobuf_fieldNumber: 7736974, - fieldName: "protobuf_unittest.file_opt1" -) - -let ProtobufUnittest_Extensions_message_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7739036, - fieldName: "protobuf_unittest.message_opt1" -) - -let ProtobufUnittest_Extensions_field_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FieldOptions>( - _protobuf_fieldNumber: 7740936, - fieldName: "protobuf_unittest.field_opt1" -) - -/// This is useful for testing that we correctly register default values for -/// extension options. -let ProtobufUnittest_Extensions_field_opt2 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FieldOptions>( - _protobuf_fieldNumber: 7753913, - fieldName: "protobuf_unittest.field_opt2" -) - -let ProtobufUnittest_Extensions_oneof_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_OneofOptions>( - _protobuf_fieldNumber: 7740111, - fieldName: "protobuf_unittest.oneof_opt1" -) - -let ProtobufUnittest_Extensions_enum_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_EnumOptions>( - _protobuf_fieldNumber: 7753576, - fieldName: "protobuf_unittest.enum_opt1" -) - -let ProtobufUnittest_Extensions_enum_value_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_EnumValueOptions>( - _protobuf_fieldNumber: 1560678, - fieldName: "protobuf_unittest.enum_value_opt1" -) - -let ProtobufUnittest_Extensions_service_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_ServiceOptions>( - _protobuf_fieldNumber: 7887650, - fieldName: "protobuf_unittest.service_opt1" -) - -let ProtobufUnittest_Extensions_method_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MethodOptions>( - _protobuf_fieldNumber: 7890860, - fieldName: "protobuf_unittest.method_opt1" -) - -let ProtobufUnittest_Extensions_bool_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7706090, - fieldName: "protobuf_unittest.bool_opt" -) - -let ProtobufUnittest_Extensions_int32_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7705709, - fieldName: "protobuf_unittest.int32_opt" -) - -let ProtobufUnittest_Extensions_int64_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7705542, - fieldName: "protobuf_unittest.int64_opt" -) - -let ProtobufUnittest_Extensions_uint32_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7704880, - fieldName: "protobuf_unittest.uint32_opt" -) - -let ProtobufUnittest_Extensions_uint64_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7702367, - fieldName: "protobuf_unittest.uint64_opt" -) - -let ProtobufUnittest_Extensions_sint32_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7701568, - fieldName: "protobuf_unittest.sint32_opt" -) - -let ProtobufUnittest_Extensions_sint64_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7700863, - fieldName: "protobuf_unittest.sint64_opt" -) - -let ProtobufUnittest_Extensions_fixed32_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7700307, - fieldName: "protobuf_unittest.fixed32_opt" -) - -let ProtobufUnittest_Extensions_fixed64_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7700194, - fieldName: "protobuf_unittest.fixed64_opt" -) - -let ProtobufUnittest_Extensions_sfixed32_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7698645, - fieldName: "protobuf_unittest.sfixed32_opt" -) - -let ProtobufUnittest_Extensions_sfixed64_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7685475, - fieldName: "protobuf_unittest.sfixed64_opt" -) - -let ProtobufUnittest_Extensions_float_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7675390, - fieldName: "protobuf_unittest.float_opt" -) - -let ProtobufUnittest_Extensions_double_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7673293, - fieldName: "protobuf_unittest.double_opt" -) - -let ProtobufUnittest_Extensions_string_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7673285, - fieldName: "protobuf_unittest.string_opt" -) - -let ProtobufUnittest_Extensions_bytes_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7673238, - fieldName: "protobuf_unittest.bytes_opt" -) - -let ProtobufUnittest_Extensions_enum_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7673233, - fieldName: "protobuf_unittest.enum_opt" -) - -let ProtobufUnittest_Extensions_message_type_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7665967, - fieldName: "protobuf_unittest.message_type_opt" -) - -let ProtobufUnittest_Extensions_quux = SwiftProtobuf.MessageExtension, ProtobufUnittest_ComplexOptionType1>( - _protobuf_fieldNumber: 7663707, - fieldName: "protobuf_unittest.quux" -) - -let ProtobufUnittest_Extensions_corge = SwiftProtobuf.MessageExtension, ProtobufUnittest_ComplexOptionType1>( - _protobuf_fieldNumber: 7663442, - fieldName: "protobuf_unittest.corge" -) - -let ProtobufUnittest_Extensions_grault = SwiftProtobuf.MessageExtension, ProtobufUnittest_ComplexOptionType2>( - _protobuf_fieldNumber: 7650927, - fieldName: "protobuf_unittest.grault" -) - -let ProtobufUnittest_Extensions_garply = SwiftProtobuf.MessageExtension, ProtobufUnittest_ComplexOptionType2>( - _protobuf_fieldNumber: 7649992, - fieldName: "protobuf_unittest.garply" -) - -let ProtobufUnittest_Extensions_complex_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7646756, - fieldName: "protobuf_unittest.complex_opt1" -) - -let ProtobufUnittest_Extensions_complex_opt2 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7636949, - fieldName: "protobuf_unittest.complex_opt2" -) - -let ProtobufUnittest_Extensions_complex_opt3 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7636463, - fieldName: "protobuf_unittest.complex_opt3" -) - -let ProtobufUnittest_Extensions_ComplexOpt6 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7595468, - fieldName: "protobuf_unittest.complexopt6" -) - -let ProtobufUnittest_Extensions_fileopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( - _protobuf_fieldNumber: 15478479, - fieldName: "protobuf_unittest.fileopt" -) - -let ProtobufUnittest_Extensions_msgopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 15480088, - fieldName: "protobuf_unittest.msgopt" -) - -let ProtobufUnittest_Extensions_fieldopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FieldOptions>( - _protobuf_fieldNumber: 15481374, - fieldName: "protobuf_unittest.fieldopt" -) - -let ProtobufUnittest_Extensions_enumopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_EnumOptions>( - _protobuf_fieldNumber: 15483218, - fieldName: "protobuf_unittest.enumopt" -) - -let ProtobufUnittest_Extensions_enumvalopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_EnumValueOptions>( - _protobuf_fieldNumber: 15486921, - fieldName: "protobuf_unittest.enumvalopt" -) - -let ProtobufUnittest_Extensions_serviceopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_ServiceOptions>( - _protobuf_fieldNumber: 15497145, - fieldName: "protobuf_unittest.serviceopt" -) - -let ProtobufUnittest_Extensions_methodopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MethodOptions>( - _protobuf_fieldNumber: 15512713, - fieldName: "protobuf_unittest.methodopt" -) - -let ProtobufUnittest_Extensions_required_enum_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 106161807, - fieldName: "protobuf_unittest.required_enum_opt" -) - -extension ProtobufUnittest_ComplexOptionType2.ComplexOptionType4 { - enum Extensions { - static let complex_opt4 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7633546, - fieldName: "protobuf_unittest.ComplexOptionType2.ComplexOptionType4.complex_opt4" - ) - } -} - -extension ProtobufUnittest_AggregateMessageSetElement { - enum Extensions { - static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_AggregateMessageSet>( - _protobuf_fieldNumber: 15447542, - fieldName: "protobuf_unittest.AggregateMessageSetElement" - ) - } -} - -extension ProtobufUnittest_Aggregate { - enum Extensions { - static let nested = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( - _protobuf_fieldNumber: 15476903, - fieldName: "protobuf_unittest.Aggregate.nested" - ) - } -} - -extension ProtobufUnittest_NestedOptionType { - enum Extensions { - static let nested_extension = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( - _protobuf_fieldNumber: 7912573, - fieldName: "protobuf_unittest.NestedOptionType.nested_extension" - ) - } -} - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest" - -extension ProtobufUnittest_MethodOpt1: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "METHODOPT1_VAL1"), - 2: .same(proto: "METHODOPT1_VAL2"), - ] -} - -extension ProtobufUnittest_AggregateEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "VALUE"), - ] -} - -extension ProtobufUnittest_TestMessageWithCustomOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMessageWithCustomOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "field1"), - 2: .standard(proto: "oneof_field"), - ] - - 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._field1) }() - case 2: try { - var v: Int32? - try decoder.decodeSingularInt32Field(value: &v) - if let v = v { - if self.anOneof != nil {try decoder.handleConflictingOneOf()} - self.anOneof = .oneofField(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 - try { if let v = self._field1 { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try { if case .oneofField(let v)? = self.anOneof { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMessageWithCustomOptions, rhs: ProtobufUnittest_TestMessageWithCustomOptions) -> Bool { - if lhs._field1 != rhs._field1 {return false} - if lhs.anOneof != rhs.anOneof {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestMessageWithCustomOptions.AnEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ANENUM_VAL1"), - 2: .same(proto: "ANENUM_VAL2"), - ] -} - -extension ProtobufUnittest_CustomOptionFooRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".CustomOptionFooRequest" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_CustomOptionFooRequest, rhs: ProtobufUnittest_CustomOptionFooRequest) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_CustomOptionFooResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".CustomOptionFooResponse" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_CustomOptionFooResponse, rhs: ProtobufUnittest_CustomOptionFooResponse) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_CustomOptionFooClientMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".CustomOptionFooClientMessage" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_CustomOptionFooClientMessage, rhs: ProtobufUnittest_CustomOptionFooClientMessage) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_CustomOptionFooServerMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".CustomOptionFooServerMessage" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_CustomOptionFooServerMessage, rhs: ProtobufUnittest_CustomOptionFooServerMessage) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_DummyMessageContainingEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".DummyMessageContainingEnum" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_DummyMessageContainingEnum, rhs: ProtobufUnittest_DummyMessageContainingEnum) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_DummyMessageContainingEnum.TestEnumType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -23: .same(proto: "TEST_OPTION_ENUM_TYPE2"), - 22: .same(proto: "TEST_OPTION_ENUM_TYPE1"), - ] -} - -extension ProtobufUnittest_DummyMessageInvalidAsOptionType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".DummyMessageInvalidAsOptionType" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_DummyMessageInvalidAsOptionType, rhs: ProtobufUnittest_DummyMessageInvalidAsOptionType) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_CustomOptionMinIntegerValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".CustomOptionMinIntegerValues" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_CustomOptionMinIntegerValues, rhs: ProtobufUnittest_CustomOptionMinIntegerValues) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_CustomOptionMaxIntegerValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".CustomOptionMaxIntegerValues" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_CustomOptionMaxIntegerValues, rhs: ProtobufUnittest_CustomOptionMaxIntegerValues) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_CustomOptionOtherValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".CustomOptionOtherValues" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_CustomOptionOtherValues, rhs: ProtobufUnittest_CustomOptionOtherValues) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_SettingRealsFromPositiveInts: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".SettingRealsFromPositiveInts" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_SettingRealsFromPositiveInts, rhs: ProtobufUnittest_SettingRealsFromPositiveInts) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_SettingRealsFromNegativeInts: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".SettingRealsFromNegativeInts" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_SettingRealsFromNegativeInts, rhs: ProtobufUnittest_SettingRealsFromNegativeInts) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_ComplexOptionType1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ComplexOptionType1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "foo"), - 2: .same(proto: "foo2"), - 3: .same(proto: "foo3"), - 4: .same(proto: "foo4"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - 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._foo) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &self._foo2) }() - case 3: try { try decoder.decodeSingularInt32Field(value: &self._foo3) }() - case 4: try { try decoder.decodeRepeatedInt32Field(value: &self.foo4) }() - case 100..<536870912: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_ComplexOptionType1.self, fieldNumber: fieldNumber) }() - 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 - try { if let v = self._foo { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._foo2 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try { if let v = self._foo3 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) - } }() - if !self.foo4.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.foo4, fieldNumber: 4) - } - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 100, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_ComplexOptionType1, rhs: ProtobufUnittest_ComplexOptionType1) -> Bool { - if lhs._foo != rhs._foo {return false} - if lhs._foo2 != rhs._foo2 {return false} - if lhs._foo3 != rhs._foo3 {return false} - if lhs.foo4 != rhs.foo4 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_ComplexOptionType2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ComplexOptionType2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bar"), - 2: .same(proto: "baz"), - 3: .same(proto: "fred"), - 4: .same(proto: "barney"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - if let v = self._bar, !v.isInitialized {return false} - return true - } - - 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.decodeSingularMessageField(value: &self._bar) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &self._baz) }() - case 3: try { try decoder.decodeSingularMessageField(value: &self._fred) }() - case 4: try { try decoder.decodeRepeatedMessageField(value: &self.barney) }() - case 100..<536870912: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_ComplexOptionType2.self, fieldNumber: fieldNumber) }() - 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 - try { if let v = self._bar { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = self._baz { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try { if let v = self._fred { - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - } }() - if !self.barney.isEmpty { - try visitor.visitRepeatedMessageField(value: self.barney, fieldNumber: 4) - } - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 100, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_ComplexOptionType2, rhs: ProtobufUnittest_ComplexOptionType2) -> Bool { - if lhs._bar != rhs._bar {return false} - if lhs._baz != rhs._baz {return false} - if lhs._fred != rhs._fred {return false} - if lhs.barney != rhs.barney {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_ComplexOptionType2.ComplexOptionType4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_ComplexOptionType2.protoMessageName + ".ComplexOptionType4" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "waldo"), - ] - - 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._waldo) }() - 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 - try { if let v = self._waldo { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_ComplexOptionType2.ComplexOptionType4, rhs: ProtobufUnittest_ComplexOptionType2.ComplexOptionType4) -> Bool { - if lhs._waldo != rhs._waldo {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_ComplexOptionType3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ComplexOptionType3" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "qux"), - 2: .unique(proto: "ComplexOptionType5", json: "complexoptiontype5"), - ] - - 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._qux) }() - case 2: try { try decoder.decodeSingularGroupField(value: &self._complexOptionType5) }() - 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 - try { if let v = self._qux { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._complexOptionType5 { - try visitor.visitSingularGroupField(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_ComplexOptionType3, rhs: ProtobufUnittest_ComplexOptionType3) -> Bool { - if lhs._qux != rhs._qux {return false} - if lhs._complexOptionType5 != rhs._complexOptionType5 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_ComplexOptionType3.ComplexOptionType5: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_ComplexOptionType3.protoMessageName + ".ComplexOptionType5" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 3: .same(proto: "plugh"), - ] - - 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 3: try { try decoder.decodeSingularInt32Field(value: &self._plugh) }() - 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 - try { if let v = self._plugh { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_ComplexOptionType3.ComplexOptionType5, rhs: ProtobufUnittest_ComplexOptionType3.ComplexOptionType5) -> Bool { - if lhs._plugh != rhs._plugh {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_ComplexOpt6: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ComplexOpt6" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 7593951: .same(proto: "xyzzy"), - ] - - 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 7593951: try { try decoder.decodeSingularInt32Field(value: &self._xyzzy) }() - 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 - try { if let v = self._xyzzy { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 7593951) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_ComplexOpt6, rhs: ProtobufUnittest_ComplexOpt6) -> Bool { - if lhs._xyzzy != rhs._xyzzy {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_VariousComplexOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".VariousComplexOptions" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_VariousComplexOptions, rhs: ProtobufUnittest_VariousComplexOptions) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_AggregateMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".AggregateMessageSet" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_AggregateMessageSet.self) - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_AggregateMessageSet, rhs: ProtobufUnittest_AggregateMessageSet) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_AggregateMessageSetElement: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".AggregateMessageSetElement" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "s"), - ] - - 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._s) }() - 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 - try { if let v = self._s { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_AggregateMessageSetElement, rhs: ProtobufUnittest_AggregateMessageSetElement) -> Bool { - if lhs._s != rhs._s {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_Aggregate: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".Aggregate" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "i"), - 2: .same(proto: "s"), - 3: .same(proto: "sub"), - 4: .same(proto: "file"), - 5: .same(proto: "mset"), - 6: .same(proto: "any"), - ] - - fileprivate class _StorageClass { - var _i: Int32? = nil - var _s: String? = nil - var _sub: ProtobufUnittest_Aggregate? = nil - var _file: SwiftProtobuf.Google_Protobuf_FileOptions? = nil - var _mset: ProtobufUnittest_AggregateMessageSet? = nil - var _any: SwiftProtobuf.Google_Protobuf_Any? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _i = source._i - _s = source._s - _sub = source._sub - _file = source._file - _mset = source._mset - _any = source._any - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - public var isInitialized: Bool { - return withExtendedLifetime(_storage) { (_storage: _StorageClass) in - if let v = _storage._sub, !v.isInitialized {return false} - if let v = _storage._file, !v.isInitialized {return false} - if let v = _storage._mset, !v.isInitialized {return false} - return true - } - } - - mutating func decodeMessage(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._i) }() - case 2: try { try decoder.decodeSingularStringField(value: &_storage._s) }() - case 3: try { try decoder.decodeSingularMessageField(value: &_storage._sub) }() - case 4: try { try decoder.decodeSingularMessageField(value: &_storage._file) }() - case 5: try { try decoder.decodeSingularMessageField(value: &_storage._mset) }() - case 6: try { try decoder.decodeSingularMessageField(value: &_storage._any) }() - default: break - } - } - } - } - - func traverse(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._i { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._s { - try visitor.visitSingularStringField(value: v, fieldNumber: 2) - } }() - try { if let v = _storage._sub { - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - } }() - try { if let v = _storage._file { - try visitor.visitSingularMessageField(value: v, fieldNumber: 4) - } }() - try { if let v = _storage._mset { - try visitor.visitSingularMessageField(value: v, fieldNumber: 5) - } }() - try { if let v = _storage._any { - try visitor.visitSingularMessageField(value: v, fieldNumber: 6) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_Aggregate, rhs: ProtobufUnittest_Aggregate) -> 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._i != rhs_storage._i {return false} - if _storage._s != rhs_storage._s {return false} - if _storage._sub != rhs_storage._sub {return false} - if _storage._file != rhs_storage._file {return false} - if _storage._mset != rhs_storage._mset {return false} - if _storage._any != rhs_storage._any {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_AggregateMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".AggregateMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fieldname"), - ] - - 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._fieldname) }() - 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 - try { if let v = self._fieldname { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_AggregateMessage, rhs: ProtobufUnittest_AggregateMessage) -> Bool { - if lhs._fieldname != rhs._fieldname {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_NestedOptionType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".NestedOptionType" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_NestedOptionType, rhs: ProtobufUnittest_NestedOptionType) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_NestedOptionType.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "NESTED_ENUM_VALUE"), - ] -} - -extension ProtobufUnittest_NestedOptionType.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_NestedOptionType.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "nested_field"), - ] - - 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._nestedField) }() - 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 - try { if let v = self._nestedField { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_NestedOptionType.NestedMessage, rhs: ProtobufUnittest_NestedOptionType.NestedMessage) -> Bool { - if lhs._nestedField != rhs._nestedField {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_OldOptionType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".OldOptionType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] - - public var isInitialized: Bool { - if self._value == nil {return false} - return true - } - - 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._value) }() - 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 - try { if let v = self._value { - try visitor.visitSingularEnumField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_OldOptionType, rhs: ProtobufUnittest_OldOptionType) -> Bool { - if lhs._value != rhs._value {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_OldOptionType.TestEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "OLD_VALUE"), - ] -} - -extension ProtobufUnittest_NewOptionType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".NewOptionType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] - - public var isInitialized: Bool { - if self._value == nil {return false} - return true - } - - 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._value) }() - 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 - try { if let v = self._value { - try visitor.visitSingularEnumField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_NewOptionType, rhs: ProtobufUnittest_NewOptionType) -> Bool { - if lhs._value != rhs._value {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_NewOptionType.TestEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "OLD_VALUE"), - 1: .same(proto: "NEW_VALUE"), - ] -} - -extension ProtobufUnittest_TestMessageWithRequiredEnumOption: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMessageWithRequiredEnumOption" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMessageWithRequiredEnumOption, rhs: ProtobufUnittest_TestMessageWithRequiredEnumOption) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Reference/google/protobuf/unittest_empty.pb.swift b/Reference/google/protobuf/unittest_empty.pb.swift deleted file mode 100644 index 3c31eb186..000000000 --- a/Reference/google/protobuf/unittest_empty.pb.swift +++ /dev/null @@ -1,58 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_empty.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// This file intentionally left blank. (At one point this wouldn't compile -// correctly.) - -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 -} diff --git a/Reference/google/protobuf/unittest_import.pb.swift b/Reference/google/protobuf/unittest_import.pb.swift deleted file mode 100644 index 2a159da09..000000000 --- a/Reference/google/protobuf/unittest_import.pb.swift +++ /dev/null @@ -1,215 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_import.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// A proto file which is imported by unittest.proto to test importing. - -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 ProtobufUnittestImport_ImportEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case importFoo // = 7 - case importBar // = 8 - case importBaz // = 9 - - init() { - self = .importFoo - } - - init?(rawValue: Int) { - switch rawValue { - case 7: self = .importFoo - case 8: self = .importBar - case 9: self = .importBaz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .importFoo: return 7 - case .importBar: return 8 - case .importBaz: return 9 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittestImport_ImportEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// To use an enum in a map, it must has the first value as 0. -enum ProtobufUnittestImport_ImportEnumForMap: SwiftProtobuf.Enum { - typealias RawValue = Int - case unknown // = 0 - case foo // = 1 - case bar // = 2 - - init() { - self = .unknown - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .unknown - case 1: self = .foo - case 2: self = .bar - default: return nil - } - } - - var rawValue: Int { - switch self { - case .unknown: return 0 - case .foo: return 1 - case .bar: return 2 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittestImport_ImportEnumForMap: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittestImport_ImportMessage { - // 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 d: Int32 { - get {return _d ?? 0} - set {_d = newValue} - } - /// Returns true if `d` has been explicitly set. - var hasD: Bool {return self._d != nil} - /// Clears the value of `d`. Subsequent reads from it will return its default value. - mutating func clearD() {self._d = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _d: Int32? = nil -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittestImport_ImportEnum: @unchecked Sendable {} -extension ProtobufUnittestImport_ImportEnumForMap: @unchecked Sendable {} -extension ProtobufUnittestImport_ImportMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest_import" - -extension ProtobufUnittestImport_ImportEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 7: .same(proto: "IMPORT_FOO"), - 8: .same(proto: "IMPORT_BAR"), - 9: .same(proto: "IMPORT_BAZ"), - ] -} - -extension ProtobufUnittestImport_ImportEnumForMap: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "UNKNOWN"), - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - ] -} - -extension ProtobufUnittestImport_ImportMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ImportMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "d"), - ] - - 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._d) }() - 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 - try { if let v = self._d { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittestImport_ImportMessage, rhs: ProtobufUnittestImport_ImportMessage) -> Bool { - if lhs._d != rhs._d {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Reference/google/protobuf/unittest_import_lite.pb.swift b/Reference/google/protobuf/unittest_import_lite.pb.swift deleted file mode 100644 index 3ede8968c..000000000 --- a/Reference/google/protobuf/unittest_import_lite.pb.swift +++ /dev/null @@ -1,166 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_import_lite.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) -// -// This is like unittest_import.proto but with optimize_for = LITE_RUNTIME. - -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 ProtobufUnittestImport_ImportEnumLite: SwiftProtobuf.Enum { - typealias RawValue = Int - case importLiteFoo // = 7 - case importLiteBar // = 8 - case importLiteBaz // = 9 - - init() { - self = .importLiteFoo - } - - init?(rawValue: Int) { - switch rawValue { - case 7: self = .importLiteFoo - case 8: self = .importLiteBar - case 9: self = .importLiteBaz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .importLiteFoo: return 7 - case .importLiteBar: return 8 - case .importLiteBaz: return 9 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittestImport_ImportEnumLite: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittestImport_ImportMessageLite { - // 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 d: Int32 { - get {return _d ?? 0} - set {_d = newValue} - } - /// Returns true if `d` has been explicitly set. - var hasD: Bool {return self._d != nil} - /// Clears the value of `d`. Subsequent reads from it will return its default value. - mutating func clearD() {self._d = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _d: Int32? = nil -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittestImport_ImportEnumLite: @unchecked Sendable {} -extension ProtobufUnittestImport_ImportMessageLite: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest_import" - -extension ProtobufUnittestImport_ImportEnumLite: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 7: .same(proto: "IMPORT_LITE_FOO"), - 8: .same(proto: "IMPORT_LITE_BAR"), - 9: .same(proto: "IMPORT_LITE_BAZ"), - ] -} - -extension ProtobufUnittestImport_ImportMessageLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ImportMessageLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "d"), - ] - - 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._d) }() - 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 - try { if let v = self._d { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittestImport_ImportMessageLite, rhs: ProtobufUnittestImport_ImportMessageLite) -> Bool { - if lhs._d != rhs._d {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Reference/google/protobuf/unittest_lite.pb.swift b/Reference/google/protobuf/unittest_lite.pb.swift deleted file mode 100644 index 0be873709..000000000 --- a/Reference/google/protobuf/unittest_lite.pb.swift +++ /dev/null @@ -1,6197 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_lite.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) -// -// This is like unittest.proto but with optimize_for = LITE_RUNTIME. - -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 ProtobufUnittest_ForeignEnumLite: SwiftProtobuf.Enum { - typealias RawValue = Int - case foreignLiteFoo // = 4 - case foreignLiteBaz // = 6 - case foreignLiteBar // = 5 - - init() { - self = .foreignLiteFoo - } - - init?(rawValue: Int) { - switch rawValue { - case 4: self = .foreignLiteFoo - case 5: self = .foreignLiteBar - case 6: self = .foreignLiteBaz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foreignLiteFoo: return 4 - case .foreignLiteBar: return 5 - case .foreignLiteBaz: return 6 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_ForeignEnumLite: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -enum ProtobufUnittest_V1EnumLite: SwiftProtobuf.Enum { - typealias RawValue = Int - case v1First // = 1 - - init() { - self = .v1First - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .v1First - default: return nil - } - } - - var rawValue: Int { - switch self { - case .v1First: return 1 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_V1EnumLite: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -enum ProtobufUnittest_V2EnumLite: SwiftProtobuf.Enum { - typealias RawValue = Int - case v2First // = 1 - case v2Second // = 2 - - init() { - self = .v2First - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .v2First - case 2: self = .v2Second - default: return nil - } - } - - var rawValue: Int { - switch self { - case .v2First: return 1 - case .v2Second: return 2 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_V2EnumLite: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// Same as TestAllTypes but with the lite runtime. -struct ProtobufUnittest_TestAllTypesLite { - // 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. - - /// Singular - var optionalInt32: Int32 { - get {return _storage._optionalInt32 ?? 0} - set {_uniqueStorage()._optionalInt32 = newValue} - } - /// Returns true if `optionalInt32` has been explicitly set. - var hasOptionalInt32: Bool {return _storage._optionalInt32 != nil} - /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. - mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} - - var optionalInt64: Int64 { - get {return _storage._optionalInt64 ?? 0} - set {_uniqueStorage()._optionalInt64 = newValue} - } - /// Returns true if `optionalInt64` has been explicitly set. - var hasOptionalInt64: Bool {return _storage._optionalInt64 != nil} - /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. - mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} - - var optionalUint32: UInt32 { - get {return _storage._optionalUint32 ?? 0} - set {_uniqueStorage()._optionalUint32 = newValue} - } - /// Returns true if `optionalUint32` has been explicitly set. - var hasOptionalUint32: Bool {return _storage._optionalUint32 != nil} - /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. - mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} - - var optionalUint64: UInt64 { - get {return _storage._optionalUint64 ?? 0} - set {_uniqueStorage()._optionalUint64 = newValue} - } - /// Returns true if `optionalUint64` has been explicitly set. - var hasOptionalUint64: Bool {return _storage._optionalUint64 != nil} - /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. - mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} - - var optionalSint32: Int32 { - get {return _storage._optionalSint32 ?? 0} - set {_uniqueStorage()._optionalSint32 = newValue} - } - /// Returns true if `optionalSint32` has been explicitly set. - var hasOptionalSint32: Bool {return _storage._optionalSint32 != nil} - /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. - mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} - - var optionalSint64: Int64 { - get {return _storage._optionalSint64 ?? 0} - set {_uniqueStorage()._optionalSint64 = newValue} - } - /// Returns true if `optionalSint64` has been explicitly set. - var hasOptionalSint64: Bool {return _storage._optionalSint64 != nil} - /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. - mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} - - var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32 ?? 0} - set {_uniqueStorage()._optionalFixed32 = newValue} - } - /// Returns true if `optionalFixed32` has been explicitly set. - var hasOptionalFixed32: Bool {return _storage._optionalFixed32 != nil} - /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. - mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} - - var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64 ?? 0} - set {_uniqueStorage()._optionalFixed64 = newValue} - } - /// Returns true if `optionalFixed64` has been explicitly set. - var hasOptionalFixed64: Bool {return _storage._optionalFixed64 != nil} - /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. - mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} - - var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32 ?? 0} - set {_uniqueStorage()._optionalSfixed32 = newValue} - } - /// Returns true if `optionalSfixed32` has been explicitly set. - var hasOptionalSfixed32: Bool {return _storage._optionalSfixed32 != nil} - /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. - mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} - - var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64 ?? 0} - set {_uniqueStorage()._optionalSfixed64 = newValue} - } - /// Returns true if `optionalSfixed64` has been explicitly set. - var hasOptionalSfixed64: Bool {return _storage._optionalSfixed64 != nil} - /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. - mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} - - var optionalFloat: Float { - get {return _storage._optionalFloat ?? 0} - set {_uniqueStorage()._optionalFloat = newValue} - } - /// Returns true if `optionalFloat` has been explicitly set. - var hasOptionalFloat: Bool {return _storage._optionalFloat != nil} - /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. - mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} - - var optionalDouble: Double { - get {return _storage._optionalDouble ?? 0} - set {_uniqueStorage()._optionalDouble = newValue} - } - /// Returns true if `optionalDouble` has been explicitly set. - var hasOptionalDouble: Bool {return _storage._optionalDouble != nil} - /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. - mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} - - var optionalBool: Bool { - get {return _storage._optionalBool ?? false} - set {_uniqueStorage()._optionalBool = newValue} - } - /// Returns true if `optionalBool` has been explicitly set. - var hasOptionalBool: Bool {return _storage._optionalBool != nil} - /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. - mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} - - var optionalString: String { - get {return _storage._optionalString ?? String()} - set {_uniqueStorage()._optionalString = newValue} - } - /// Returns true if `optionalString` has been explicitly set. - var hasOptionalString: Bool {return _storage._optionalString != nil} - /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. - mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} - - var optionalBytes: Data { - get {return _storage._optionalBytes ?? Data()} - set {_uniqueStorage()._optionalBytes = newValue} - } - /// Returns true if `optionalBytes` has been explicitly set. - var hasOptionalBytes: Bool {return _storage._optionalBytes != nil} - /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. - mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} - - var optionalGroup: ProtobufUnittest_TestAllTypesLite.OptionalGroup { - get {return _storage._optionalGroup ?? ProtobufUnittest_TestAllTypesLite.OptionalGroup()} - set {_uniqueStorage()._optionalGroup = newValue} - } - /// Returns true if `optionalGroup` has been explicitly set. - var hasOptionalGroup: Bool {return _storage._optionalGroup != nil} - /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. - mutating func clearOptionalGroup() {_uniqueStorage()._optionalGroup = nil} - - var optionalNestedMessage: ProtobufUnittest_TestAllTypesLite.NestedMessage { - get {return _storage._optionalNestedMessage ?? ProtobufUnittest_TestAllTypesLite.NestedMessage()} - set {_uniqueStorage()._optionalNestedMessage = newValue} - } - /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} - /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} - - var optionalForeignMessage: ProtobufUnittest_ForeignMessageLite { - get {return _storage._optionalForeignMessage ?? ProtobufUnittest_ForeignMessageLite()} - set {_uniqueStorage()._optionalForeignMessage = newValue} - } - /// Returns true if `optionalForeignMessage` has been explicitly set. - var hasOptionalForeignMessage: Bool {return _storage._optionalForeignMessage != nil} - /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} - - var optionalImportMessage: ProtobufUnittestImport_ImportMessageLite { - get {return _storage._optionalImportMessage ?? ProtobufUnittestImport_ImportMessageLite()} - set {_uniqueStorage()._optionalImportMessage = newValue} - } - /// Returns true if `optionalImportMessage` has been explicitly set. - var hasOptionalImportMessage: Bool {return _storage._optionalImportMessage != nil} - /// Clears the value of `optionalImportMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalImportMessage() {_uniqueStorage()._optionalImportMessage = nil} - - var optionalNestedEnum: ProtobufUnittest_TestAllTypesLite.NestedEnum { - get {return _storage._optionalNestedEnum ?? .foo} - set {_uniqueStorage()._optionalNestedEnum = newValue} - } - /// Returns true if `optionalNestedEnum` has been explicitly set. - var hasOptionalNestedEnum: Bool {return _storage._optionalNestedEnum != nil} - /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. - mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} - - var optionalForeignEnum: ProtobufUnittest_ForeignEnumLite { - get {return _storage._optionalForeignEnum ?? .foreignLiteFoo} - set {_uniqueStorage()._optionalForeignEnum = newValue} - } - /// Returns true if `optionalForeignEnum` has been explicitly set. - var hasOptionalForeignEnum: Bool {return _storage._optionalForeignEnum != nil} - /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. - mutating func clearOptionalForeignEnum() {_uniqueStorage()._optionalForeignEnum = nil} - - var optionalImportEnum: ProtobufUnittestImport_ImportEnumLite { - get {return _storage._optionalImportEnum ?? .importLiteFoo} - set {_uniqueStorage()._optionalImportEnum = newValue} - } - /// Returns true if `optionalImportEnum` has been explicitly set. - var hasOptionalImportEnum: Bool {return _storage._optionalImportEnum != nil} - /// Clears the value of `optionalImportEnum`. Subsequent reads from it will return its default value. - mutating func clearOptionalImportEnum() {_uniqueStorage()._optionalImportEnum = nil} - - var optionalStringPiece: String { - get {return _storage._optionalStringPiece ?? String()} - set {_uniqueStorage()._optionalStringPiece = newValue} - } - /// Returns true if `optionalStringPiece` has been explicitly set. - var hasOptionalStringPiece: Bool {return _storage._optionalStringPiece != nil} - /// Clears the value of `optionalStringPiece`. Subsequent reads from it will return its default value. - mutating func clearOptionalStringPiece() {_uniqueStorage()._optionalStringPiece = nil} - - var optionalCord: String { - get {return _storage._optionalCord ?? String()} - set {_uniqueStorage()._optionalCord = newValue} - } - /// Returns true if `optionalCord` has been explicitly set. - var hasOptionalCord: Bool {return _storage._optionalCord != nil} - /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. - mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} - - /// Defined in unittest_import_public.proto - var optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessageLite { - get {return _storage._optionalPublicImportMessage ?? ProtobufUnittestImport_PublicImportMessageLite()} - set {_uniqueStorage()._optionalPublicImportMessage = newValue} - } - /// Returns true if `optionalPublicImportMessage` has been explicitly set. - var hasOptionalPublicImportMessage: Bool {return _storage._optionalPublicImportMessage != nil} - /// Clears the value of `optionalPublicImportMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalPublicImportMessage() {_uniqueStorage()._optionalPublicImportMessage = nil} - - var optionalLazyMessage: ProtobufUnittest_TestAllTypesLite.NestedMessage { - get {return _storage._optionalLazyMessage ?? ProtobufUnittest_TestAllTypesLite.NestedMessage()} - set {_uniqueStorage()._optionalLazyMessage = newValue} - } - /// Returns true if `optionalLazyMessage` has been explicitly set. - var hasOptionalLazyMessage: Bool {return _storage._optionalLazyMessage != nil} - /// Clears the value of `optionalLazyMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalLazyMessage() {_uniqueStorage()._optionalLazyMessage = nil} - - /// Repeated - var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} - set {_uniqueStorage()._repeatedInt32 = newValue} - } - - var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} - set {_uniqueStorage()._repeatedInt64 = newValue} - } - - var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} - set {_uniqueStorage()._repeatedUint32 = newValue} - } - - var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} - set {_uniqueStorage()._repeatedUint64 = newValue} - } - - var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} - set {_uniqueStorage()._repeatedSint32 = newValue} - } - - var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} - set {_uniqueStorage()._repeatedSint64 = newValue} - } - - var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} - set {_uniqueStorage()._repeatedFixed32 = newValue} - } - - var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} - set {_uniqueStorage()._repeatedFixed64 = newValue} - } - - var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} - set {_uniqueStorage()._repeatedSfixed32 = newValue} - } - - var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} - set {_uniqueStorage()._repeatedSfixed64 = newValue} - } - - var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} - set {_uniqueStorage()._repeatedFloat = newValue} - } - - var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} - set {_uniqueStorage()._repeatedDouble = newValue} - } - - var repeatedBool: [Bool] { - get {return _storage._repeatedBool} - set {_uniqueStorage()._repeatedBool = newValue} - } - - var repeatedString: [String] { - get {return _storage._repeatedString} - set {_uniqueStorage()._repeatedString = newValue} - } - - var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} - set {_uniqueStorage()._repeatedBytes = newValue} - } - - var repeatedGroup: [ProtobufUnittest_TestAllTypesLite.RepeatedGroup] { - get {return _storage._repeatedGroup} - set {_uniqueStorage()._repeatedGroup = newValue} - } - - var repeatedNestedMessage: [ProtobufUnittest_TestAllTypesLite.NestedMessage] { - get {return _storage._repeatedNestedMessage} - set {_uniqueStorage()._repeatedNestedMessage = newValue} - } - - var repeatedForeignMessage: [ProtobufUnittest_ForeignMessageLite] { - get {return _storage._repeatedForeignMessage} - set {_uniqueStorage()._repeatedForeignMessage = newValue} - } - - var repeatedImportMessage: [ProtobufUnittestImport_ImportMessageLite] { - get {return _storage._repeatedImportMessage} - set {_uniqueStorage()._repeatedImportMessage = newValue} - } - - var repeatedNestedEnum: [ProtobufUnittest_TestAllTypesLite.NestedEnum] { - get {return _storage._repeatedNestedEnum} - set {_uniqueStorage()._repeatedNestedEnum = newValue} - } - - var repeatedForeignEnum: [ProtobufUnittest_ForeignEnumLite] { - get {return _storage._repeatedForeignEnum} - set {_uniqueStorage()._repeatedForeignEnum = newValue} - } - - var repeatedImportEnum: [ProtobufUnittestImport_ImportEnumLite] { - get {return _storage._repeatedImportEnum} - set {_uniqueStorage()._repeatedImportEnum = newValue} - } - - var repeatedStringPiece: [String] { - get {return _storage._repeatedStringPiece} - set {_uniqueStorage()._repeatedStringPiece = newValue} - } - - var repeatedCord: [String] { - get {return _storage._repeatedCord} - set {_uniqueStorage()._repeatedCord = newValue} - } - - var repeatedLazyMessage: [ProtobufUnittest_TestAllTypesLite.NestedMessage] { - get {return _storage._repeatedLazyMessage} - set {_uniqueStorage()._repeatedLazyMessage = newValue} - } - - /// Singular with defaults - var defaultInt32: Int32 { - get {return _storage._defaultInt32 ?? 41} - set {_uniqueStorage()._defaultInt32 = newValue} - } - /// Returns true if `defaultInt32` has been explicitly set. - var hasDefaultInt32: Bool {return _storage._defaultInt32 != nil} - /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. - mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} - - var defaultInt64: Int64 { - get {return _storage._defaultInt64 ?? 42} - set {_uniqueStorage()._defaultInt64 = newValue} - } - /// Returns true if `defaultInt64` has been explicitly set. - var hasDefaultInt64: Bool {return _storage._defaultInt64 != nil} - /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. - mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} - - var defaultUint32: UInt32 { - get {return _storage._defaultUint32 ?? 43} - set {_uniqueStorage()._defaultUint32 = newValue} - } - /// Returns true if `defaultUint32` has been explicitly set. - var hasDefaultUint32: Bool {return _storage._defaultUint32 != nil} - /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. - mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} - - var defaultUint64: UInt64 { - get {return _storage._defaultUint64 ?? 44} - set {_uniqueStorage()._defaultUint64 = newValue} - } - /// Returns true if `defaultUint64` has been explicitly set. - var hasDefaultUint64: Bool {return _storage._defaultUint64 != nil} - /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. - mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} - - var defaultSint32: Int32 { - get {return _storage._defaultSint32 ?? -45} - set {_uniqueStorage()._defaultSint32 = newValue} - } - /// Returns true if `defaultSint32` has been explicitly set. - var hasDefaultSint32: Bool {return _storage._defaultSint32 != nil} - /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. - mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} - - var defaultSint64: Int64 { - get {return _storage._defaultSint64 ?? 46} - set {_uniqueStorage()._defaultSint64 = newValue} - } - /// Returns true if `defaultSint64` has been explicitly set. - var hasDefaultSint64: Bool {return _storage._defaultSint64 != nil} - /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. - mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} - - var defaultFixed32: UInt32 { - get {return _storage._defaultFixed32 ?? 47} - set {_uniqueStorage()._defaultFixed32 = newValue} - } - /// Returns true if `defaultFixed32` has been explicitly set. - var hasDefaultFixed32: Bool {return _storage._defaultFixed32 != nil} - /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. - mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} - - var defaultFixed64: UInt64 { - get {return _storage._defaultFixed64 ?? 48} - set {_uniqueStorage()._defaultFixed64 = newValue} - } - /// Returns true if `defaultFixed64` has been explicitly set. - var hasDefaultFixed64: Bool {return _storage._defaultFixed64 != nil} - /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. - mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} - - var defaultSfixed32: Int32 { - get {return _storage._defaultSfixed32 ?? 49} - set {_uniqueStorage()._defaultSfixed32 = newValue} - } - /// Returns true if `defaultSfixed32` has been explicitly set. - var hasDefaultSfixed32: Bool {return _storage._defaultSfixed32 != nil} - /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. - mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} - - var defaultSfixed64: Int64 { - get {return _storage._defaultSfixed64 ?? -50} - set {_uniqueStorage()._defaultSfixed64 = newValue} - } - /// Returns true if `defaultSfixed64` has been explicitly set. - var hasDefaultSfixed64: Bool {return _storage._defaultSfixed64 != nil} - /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. - mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} - - var defaultFloat: Float { - get {return _storage._defaultFloat ?? 51.5} - set {_uniqueStorage()._defaultFloat = newValue} - } - /// Returns true if `defaultFloat` has been explicitly set. - var hasDefaultFloat: Bool {return _storage._defaultFloat != nil} - /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. - mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} - - var defaultDouble: Double { - get {return _storage._defaultDouble ?? 52000} - set {_uniqueStorage()._defaultDouble = newValue} - } - /// Returns true if `defaultDouble` has been explicitly set. - var hasDefaultDouble: Bool {return _storage._defaultDouble != nil} - /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. - mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} - - var defaultBool: Bool { - get {return _storage._defaultBool ?? true} - set {_uniqueStorage()._defaultBool = newValue} - } - /// Returns true if `defaultBool` has been explicitly set. - var hasDefaultBool: Bool {return _storage._defaultBool != nil} - /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. - mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} - - var defaultString: String { - get {return _storage._defaultString ?? "hello"} - set {_uniqueStorage()._defaultString = newValue} - } - /// Returns true if `defaultString` has been explicitly set. - var hasDefaultString: Bool {return _storage._defaultString != nil} - /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. - mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} - - var defaultBytes: Data { - get {return _storage._defaultBytes ?? Data([119, 111, 114, 108, 100])} - set {_uniqueStorage()._defaultBytes = newValue} - } - /// Returns true if `defaultBytes` has been explicitly set. - var hasDefaultBytes: Bool {return _storage._defaultBytes != nil} - /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. - mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} - - var defaultNestedEnum: ProtobufUnittest_TestAllTypesLite.NestedEnum { - get {return _storage._defaultNestedEnum ?? .bar} - set {_uniqueStorage()._defaultNestedEnum = newValue} - } - /// Returns true if `defaultNestedEnum` has been explicitly set. - var hasDefaultNestedEnum: Bool {return _storage._defaultNestedEnum != nil} - /// Clears the value of `defaultNestedEnum`. Subsequent reads from it will return its default value. - mutating func clearDefaultNestedEnum() {_uniqueStorage()._defaultNestedEnum = nil} - - var defaultForeignEnum: ProtobufUnittest_ForeignEnumLite { - get {return _storage._defaultForeignEnum ?? .foreignLiteBar} - set {_uniqueStorage()._defaultForeignEnum = newValue} - } - /// Returns true if `defaultForeignEnum` has been explicitly set. - var hasDefaultForeignEnum: Bool {return _storage._defaultForeignEnum != nil} - /// Clears the value of `defaultForeignEnum`. Subsequent reads from it will return its default value. - mutating func clearDefaultForeignEnum() {_uniqueStorage()._defaultForeignEnum = nil} - - var defaultImportEnum: ProtobufUnittestImport_ImportEnumLite { - get {return _storage._defaultImportEnum ?? .importLiteBar} - set {_uniqueStorage()._defaultImportEnum = newValue} - } - /// Returns true if `defaultImportEnum` has been explicitly set. - var hasDefaultImportEnum: Bool {return _storage._defaultImportEnum != nil} - /// Clears the value of `defaultImportEnum`. Subsequent reads from it will return its default value. - mutating func clearDefaultImportEnum() {_uniqueStorage()._defaultImportEnum = nil} - - var defaultStringPiece: String { - get {return _storage._defaultStringPiece ?? "abc"} - set {_uniqueStorage()._defaultStringPiece = newValue} - } - /// Returns true if `defaultStringPiece` has been explicitly set. - var hasDefaultStringPiece: Bool {return _storage._defaultStringPiece != nil} - /// Clears the value of `defaultStringPiece`. Subsequent reads from it will return its default value. - mutating func clearDefaultStringPiece() {_uniqueStorage()._defaultStringPiece = nil} - - var defaultCord: String { - get {return _storage._defaultCord ?? "123"} - set {_uniqueStorage()._defaultCord = newValue} - } - /// Returns true if `defaultCord` has been explicitly set. - var hasDefaultCord: Bool {return _storage._defaultCord != nil} - /// Clears the value of `defaultCord`. Subsequent reads from it will return its default value. - mutating func clearDefaultCord() {_uniqueStorage()._defaultCord = nil} - - /// For oneof test - var oneofField: OneOf_OneofField? { - get {return _storage._oneofField} - set {_uniqueStorage()._oneofField = newValue} - } - - var oneofUint32: UInt32 { - get { - if case .oneofUint32(let v)? = _storage._oneofField {return v} - return 0 - } - set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} - } - - var oneofNestedMessage: ProtobufUnittest_TestAllTypesLite.NestedMessage { - get { - if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} - return ProtobufUnittest_TestAllTypesLite.NestedMessage() - } - set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} - } - - var oneofString: String { - get { - if case .oneofString(let v)? = _storage._oneofField {return v} - return String() - } - set {_uniqueStorage()._oneofField = .oneofString(newValue)} - } - - var oneofBytes: Data { - get { - if case .oneofBytes(let v)? = _storage._oneofField {return v} - return Data() - } - set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} - } - - var oneofLazyNestedMessage: ProtobufUnittest_TestAllTypesLite.NestedMessage { - get { - if case .oneofLazyNestedMessage(let v)? = _storage._oneofField {return v} - return ProtobufUnittest_TestAllTypesLite.NestedMessage() - } - set {_uniqueStorage()._oneofField = .oneofLazyNestedMessage(newValue)} - } - - var oneofNestedMessage2: ProtobufUnittest_TestAllTypesLite.NestedMessage2 { - get { - if case .oneofNestedMessage2(let v)? = _storage._oneofField {return v} - return ProtobufUnittest_TestAllTypesLite.NestedMessage2() - } - set {_uniqueStorage()._oneofField = .oneofNestedMessage2(newValue)} - } - - /// Tests toString for non-repeated fields with a list suffix - var deceptivelyNamedList: Int32 { - get {return _storage._deceptivelyNamedList ?? 0} - set {_uniqueStorage()._deceptivelyNamedList = newValue} - } - /// Returns true if `deceptivelyNamedList` has been explicitly set. - var hasDeceptivelyNamedList: Bool {return _storage._deceptivelyNamedList != nil} - /// Clears the value of `deceptivelyNamedList`. Subsequent reads from it will return its default value. - mutating func clearDeceptivelyNamedList() {_uniqueStorage()._deceptivelyNamedList = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - /// For oneof test - enum OneOf_OneofField: Equatable { - case oneofUint32(UInt32) - case oneofNestedMessage(ProtobufUnittest_TestAllTypesLite.NestedMessage) - case oneofString(String) - case oneofBytes(Data) - case oneofLazyNestedMessage(ProtobufUnittest_TestAllTypesLite.NestedMessage) - case oneofNestedMessage2(ProtobufUnittest_TestAllTypesLite.NestedMessage2) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestAllTypesLite.OneOf_OneofField, rhs: ProtobufUnittest_TestAllTypesLite.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofLazyNestedMessage, .oneofLazyNestedMessage): return { - guard case .oneofLazyNestedMessage(let l) = lhs, case .oneofLazyNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage2, .oneofNestedMessage2): return { - guard case .oneofNestedMessage2(let l) = lhs, case .oneofNestedMessage2(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif - } - - enum NestedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 1 - case bar // = 2 - case baz // = 3 - - init() { - self = .foo - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .foo - case 2: self = .bar - case 3: self = .baz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo: return 1 - case .bar: return 2 - case .baz: return 3 - } - } - - } - - struct NestedMessage { - // 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 bb: Int32 { - get {return _bb ?? 0} - set {_bb = newValue} - } - /// Returns true if `bb` has been explicitly set. - var hasBb: Bool {return self._bb != nil} - /// Clears the value of `bb`. Subsequent reads from it will return its default value. - mutating func clearBb() {self._bb = nil} - - var cc: Int64 { - get {return _cc ?? 0} - set {_cc = newValue} - } - /// Returns true if `cc` has been explicitly set. - var hasCc: Bool {return self._cc != nil} - /// Clears the value of `cc`. Subsequent reads from it will return its default value. - mutating func clearCc() {self._cc = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _bb: Int32? = nil - fileprivate var _cc: Int64? = nil - } - - struct NestedMessage2 { - // 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 dd: Int32 { - get {return _dd ?? 0} - set {_dd = newValue} - } - /// Returns true if `dd` has been explicitly set. - var hasDd: Bool {return self._dd != nil} - /// Clears the value of `dd`. Subsequent reads from it will return its default value. - mutating func clearDd() {self._dd = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _dd: Int32? = nil - } - - struct OptionalGroup { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil - } - - struct RepeatedGroup { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil - } - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -#if swift(>=4.2) - -extension ProtobufUnittest_TestAllTypesLite.NestedEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_ForeignMessageLite { - // 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 c: Int32 { - get {return _c ?? 0} - set {_c = newValue} - } - /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} - /// Clears the value of `c`. Subsequent reads from it will return its default value. - mutating func clearC() {self._c = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _c: Int32? = nil -} - -struct ProtobufUnittest_TestPackedTypesLite { - // 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 packedInt32: [Int32] = [] - - var packedInt64: [Int64] = [] - - var packedUint32: [UInt32] = [] - - var packedUint64: [UInt64] = [] - - var packedSint32: [Int32] = [] - - var packedSint64: [Int64] = [] - - var packedFixed32: [UInt32] = [] - - var packedFixed64: [UInt64] = [] - - var packedSfixed32: [Int32] = [] - - var packedSfixed64: [Int64] = [] - - var packedFloat: [Float] = [] - - var packedDouble: [Double] = [] - - var packedBool: [Bool] = [] - - var packedEnum: [ProtobufUnittest_ForeignEnumLite] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -struct ProtobufUnittest_TestAllExtensionsLite: 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() -} - -struct ProtobufUnittest_OptionalGroup_extension_lite { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil -} - -struct ProtobufUnittest_RepeatedGroup_extension_lite { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil -} - -struct ProtobufUnittest_TestPackedExtensionsLite: 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() -} - -struct ProtobufUnittest_TestNestedExtensionLite { - // 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() {} -} - -/// Test that deprecated fields work. We only verify that they compile (at one -/// point this failed). -struct ProtobufUnittest_TestDeprecatedLite { - // 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 deprecatedField: Int32 { - get {return _storage._deprecatedField ?? 0} - set {_uniqueStorage()._deprecatedField = newValue} - } - /// Returns true if `deprecatedField` has been explicitly set. - var hasDeprecatedField: Bool {return _storage._deprecatedField != nil} - /// Clears the value of `deprecatedField`. Subsequent reads from it will return its default value. - mutating func clearDeprecatedField() {_uniqueStorage()._deprecatedField = nil} - - var deprecatedField2: Int32 { - get {return _storage._deprecatedField2 ?? 0} - set {_uniqueStorage()._deprecatedField2 = newValue} - } - /// Returns true if `deprecatedField2` has been explicitly set. - var hasDeprecatedField2: Bool {return _storage._deprecatedField2 != nil} - /// Clears the value of `deprecatedField2`. Subsequent reads from it will return its default value. - mutating func clearDeprecatedField2() {_uniqueStorage()._deprecatedField2 = nil} - - var deprecatedField3: String { - get {return _storage._deprecatedField3 ?? String()} - set {_uniqueStorage()._deprecatedField3 = newValue} - } - /// Returns true if `deprecatedField3` has been explicitly set. - var hasDeprecatedField3: Bool {return _storage._deprecatedField3 != nil} - /// Clears the value of `deprecatedField3`. Subsequent reads from it will return its default value. - mutating func clearDeprecatedField3() {_uniqueStorage()._deprecatedField3 = nil} - - var deprecatedField4: ProtobufUnittest_TestDeprecatedLite { - get {return _storage._deprecatedField4 ?? ProtobufUnittest_TestDeprecatedLite()} - set {_uniqueStorage()._deprecatedField4 = newValue} - } - /// Returns true if `deprecatedField4` has been explicitly set. - var hasDeprecatedField4: Bool {return _storage._deprecatedField4 != nil} - /// Clears the value of `deprecatedField4`. Subsequent reads from it will return its default value. - mutating func clearDeprecatedField4() {_uniqueStorage()._deprecatedField4 = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -/// See the comments of the same type in unittest.proto. -struct ProtobufUnittest_TestParsingMergeLite: 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 requiredAllTypes: ProtobufUnittest_TestAllTypesLite { - get {return _requiredAllTypes ?? ProtobufUnittest_TestAllTypesLite()} - set {_requiredAllTypes = newValue} - } - /// Returns true if `requiredAllTypes` has been explicitly set. - var hasRequiredAllTypes: Bool {return self._requiredAllTypes != nil} - /// Clears the value of `requiredAllTypes`. Subsequent reads from it will return its default value. - mutating func clearRequiredAllTypes() {self._requiredAllTypes = nil} - - var optionalAllTypes: ProtobufUnittest_TestAllTypesLite { - get {return _optionalAllTypes ?? ProtobufUnittest_TestAllTypesLite()} - set {_optionalAllTypes = newValue} - } - /// Returns true if `optionalAllTypes` has been explicitly set. - var hasOptionalAllTypes: Bool {return self._optionalAllTypes != nil} - /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. - mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} - - var repeatedAllTypes: [ProtobufUnittest_TestAllTypesLite] = [] - - var optionalGroup: ProtobufUnittest_TestParsingMergeLite.OptionalGroup { - get {return _optionalGroup ?? ProtobufUnittest_TestParsingMergeLite.OptionalGroup()} - set {_optionalGroup = newValue} - } - /// Returns true if `optionalGroup` has been explicitly set. - var hasOptionalGroup: Bool {return self._optionalGroup != nil} - /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. - mutating func clearOptionalGroup() {self._optionalGroup = nil} - - var repeatedGroup: [ProtobufUnittest_TestParsingMergeLite.RepeatedGroup] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct RepeatedFieldsGenerator { - // 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: [ProtobufUnittest_TestAllTypesLite] = [] - - var field2: [ProtobufUnittest_TestAllTypesLite] = [] - - var field3: [ProtobufUnittest_TestAllTypesLite] = [] - - var group1: [ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group1] = [] - - var group2: [ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group2] = [] - - var ext1: [ProtobufUnittest_TestAllTypesLite] = [] - - var ext2: [ProtobufUnittest_TestAllTypesLite] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct Group1 { - // 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: ProtobufUnittest_TestAllTypesLite { - get {return _field1 ?? ProtobufUnittest_TestAllTypesLite()} - 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 unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _field1: ProtobufUnittest_TestAllTypesLite? = nil - } - - struct Group2 { - // 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: ProtobufUnittest_TestAllTypesLite { - get {return _field1 ?? ProtobufUnittest_TestAllTypesLite()} - 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 unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _field1: ProtobufUnittest_TestAllTypesLite? = nil - } - - init() {} - } - - struct OptionalGroup { - // 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 optionalGroupAllTypes: ProtobufUnittest_TestAllTypesLite { - get {return _optionalGroupAllTypes ?? ProtobufUnittest_TestAllTypesLite()} - set {_optionalGroupAllTypes = newValue} - } - /// Returns true if `optionalGroupAllTypes` has been explicitly set. - var hasOptionalGroupAllTypes: Bool {return self._optionalGroupAllTypes != nil} - /// Clears the value of `optionalGroupAllTypes`. Subsequent reads from it will return its default value. - mutating func clearOptionalGroupAllTypes() {self._optionalGroupAllTypes = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _optionalGroupAllTypes: ProtobufUnittest_TestAllTypesLite? = nil - } - - struct RepeatedGroup { - // 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 repeatedGroupAllTypes: ProtobufUnittest_TestAllTypesLite { - get {return _repeatedGroupAllTypes ?? ProtobufUnittest_TestAllTypesLite()} - set {_repeatedGroupAllTypes = newValue} - } - /// Returns true if `repeatedGroupAllTypes` has been explicitly set. - var hasRepeatedGroupAllTypes: Bool {return self._repeatedGroupAllTypes != nil} - /// Clears the value of `repeatedGroupAllTypes`. Subsequent reads from it will return its default value. - mutating func clearRepeatedGroupAllTypes() {self._repeatedGroupAllTypes = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _repeatedGroupAllTypes: ProtobufUnittest_TestAllTypesLite? = nil - } - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _requiredAllTypes: ProtobufUnittest_TestAllTypesLite? = nil - fileprivate var _optionalAllTypes: ProtobufUnittest_TestAllTypesLite? = nil - fileprivate var _optionalGroup: ProtobufUnittest_TestParsingMergeLite.OptionalGroup? = nil -} - -/// TestEmptyMessageLite is used to test unknown fields support in lite mode. -struct ProtobufUnittest_TestEmptyMessageLite { - // 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() {} -} - -/// Like above, but declare all field numbers as potential extensions. No -/// actual extensions should ever be defined for this type. -struct ProtobufUnittest_TestEmptyMessageWithExtensionsLite: 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() -} - -struct ProtobufUnittest_V1MessageLite { - // 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 intField: Int32 { - get {return _intField ?? 0} - set {_intField = newValue} - } - /// Returns true if `intField` has been explicitly set. - var hasIntField: Bool {return self._intField != nil} - /// Clears the value of `intField`. Subsequent reads from it will return its default value. - mutating func clearIntField() {self._intField = nil} - - var enumField: ProtobufUnittest_V1EnumLite { - get {return _enumField ?? .v1First} - set {_enumField = newValue} - } - /// Returns true if `enumField` has been explicitly set. - var hasEnumField: Bool {return self._enumField != nil} - /// Clears the value of `enumField`. Subsequent reads from it will return its default value. - mutating func clearEnumField() {self._enumField = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _intField: Int32? = nil - fileprivate var _enumField: ProtobufUnittest_V1EnumLite? = nil -} - -struct ProtobufUnittest_V2MessageLite { - // 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 intField: Int32 { - get {return _intField ?? 0} - set {_intField = newValue} - } - /// Returns true if `intField` has been explicitly set. - var hasIntField: Bool {return self._intField != nil} - /// Clears the value of `intField`. Subsequent reads from it will return its default value. - mutating func clearIntField() {self._intField = nil} - - var enumField: ProtobufUnittest_V2EnumLite { - get {return _enumField ?? .v2First} - set {_enumField = newValue} - } - /// Returns true if `enumField` has been explicitly set. - var hasEnumField: Bool {return self._enumField != nil} - /// Clears the value of `enumField`. Subsequent reads from it will return its default value. - mutating func clearEnumField() {self._enumField = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _intField: Int32? = nil - fileprivate var _enumField: ProtobufUnittest_V2EnumLite? = nil -} - -struct ProtobufUnittest_TestHugeFieldNumbersLite: 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 optionalInt32: Int32 { - get {return _optionalInt32 ?? 0} - set {_optionalInt32 = newValue} - } - /// Returns true if `optionalInt32` has been explicitly set. - var hasOptionalInt32: Bool {return self._optionalInt32 != nil} - /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. - mutating func clearOptionalInt32() {self._optionalInt32 = nil} - - var fixed32: Int32 { - get {return _fixed32 ?? 0} - set {_fixed32 = newValue} - } - /// Returns true if `fixed32` has been explicitly set. - var hasFixed32: Bool {return self._fixed32 != nil} - /// Clears the value of `fixed32`. Subsequent reads from it will return its default value. - mutating func clearFixed32() {self._fixed32 = nil} - - var repeatedInt32: [Int32] = [] - - var packedInt32: [Int32] = [] - - var optionalEnum: ProtobufUnittest_ForeignEnumLite { - get {return _optionalEnum ?? .foreignLiteFoo} - set {_optionalEnum = newValue} - } - /// Returns true if `optionalEnum` has been explicitly set. - var hasOptionalEnum: Bool {return self._optionalEnum != nil} - /// Clears the value of `optionalEnum`. Subsequent reads from it will return its default value. - mutating func clearOptionalEnum() {self._optionalEnum = nil} - - var optionalString: String { - get {return _optionalString ?? String()} - set {_optionalString = newValue} - } - /// Returns true if `optionalString` has been explicitly set. - var hasOptionalString: Bool {return self._optionalString != nil} - /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. - mutating func clearOptionalString() {self._optionalString = nil} - - var optionalBytes: Data { - get {return _optionalBytes ?? Data()} - set {_optionalBytes = newValue} - } - /// Returns true if `optionalBytes` has been explicitly set. - var hasOptionalBytes: Bool {return self._optionalBytes != nil} - /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. - mutating func clearOptionalBytes() {self._optionalBytes = nil} - - var optionalMessage: ProtobufUnittest_ForeignMessageLite { - get {return _optionalMessage ?? ProtobufUnittest_ForeignMessageLite()} - set {_optionalMessage = newValue} - } - /// Returns true if `optionalMessage` has been explicitly set. - var hasOptionalMessage: Bool {return self._optionalMessage != nil} - /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalMessage() {self._optionalMessage = nil} - - var optionalGroup: ProtobufUnittest_TestHugeFieldNumbersLite.OptionalGroup { - get {return _optionalGroup ?? ProtobufUnittest_TestHugeFieldNumbersLite.OptionalGroup()} - set {_optionalGroup = newValue} - } - /// Returns true if `optionalGroup` has been explicitly set. - var hasOptionalGroup: Bool {return self._optionalGroup != nil} - /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. - mutating func clearOptionalGroup() {self._optionalGroup = nil} - - var stringStringMap: Dictionary = [:] - - var oneofField: ProtobufUnittest_TestHugeFieldNumbersLite.OneOf_OneofField? = nil - - var oneofUint32: UInt32 { - get { - if case .oneofUint32(let v)? = oneofField {return v} - return 0 - } - set {oneofField = .oneofUint32(newValue)} - } - - var oneofTestAllTypes: ProtobufUnittest_TestAllTypesLite { - get { - if case .oneofTestAllTypes(let v)? = oneofField {return v} - return ProtobufUnittest_TestAllTypesLite() - } - set {oneofField = .oneofTestAllTypes(newValue)} - } - - var oneofString: String { - get { - if case .oneofString(let v)? = oneofField {return v} - return String() - } - set {oneofField = .oneofString(newValue)} - } - - var oneofBytes: Data { - get { - if case .oneofBytes(let v)? = oneofField {return v} - return Data() - } - set {oneofField = .oneofBytes(newValue)} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum OneOf_OneofField: Equatable { - case oneofUint32(UInt32) - case oneofTestAllTypes(ProtobufUnittest_TestAllTypesLite) - case oneofString(String) - case oneofBytes(Data) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestHugeFieldNumbersLite.OneOf_OneofField, rhs: ProtobufUnittest_TestHugeFieldNumbersLite.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofTestAllTypes, .oneofTestAllTypes): return { - guard case .oneofTestAllTypes(let l) = lhs, case .oneofTestAllTypes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif - } - - struct OptionalGroup { - // 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 groupA: Int32 { - get {return _groupA ?? 0} - set {_groupA = newValue} - } - /// Returns true if `groupA` has been explicitly set. - var hasGroupA: Bool {return self._groupA != nil} - /// Clears the value of `groupA`. Subsequent reads from it will return its default value. - mutating func clearGroupA() {self._groupA = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _groupA: Int32? = nil - } - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _optionalInt32: Int32? = nil - fileprivate var _fixed32: Int32? = nil - fileprivate var _optionalEnum: ProtobufUnittest_ForeignEnumLite? = nil - fileprivate var _optionalString: String? = nil - fileprivate var _optionalBytes: Data? = nil - fileprivate var _optionalMessage: ProtobufUnittest_ForeignMessageLite? = nil - fileprivate var _optionalGroup: ProtobufUnittest_TestHugeFieldNumbersLite.OptionalGroup? = nil -} - -struct ProtobufUnittest_TestOneofParsingLite { - // 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 oneofField: ProtobufUnittest_TestOneofParsingLite.OneOf_OneofField? = nil - - var oneofInt32: Int32 { - get { - if case .oneofInt32(let v)? = oneofField {return v} - return 0 - } - set {oneofField = .oneofInt32(newValue)} - } - - var oneofSubmessage: ProtobufUnittest_TestAllTypesLite { - get { - if case .oneofSubmessage(let v)? = oneofField {return v} - return ProtobufUnittest_TestAllTypesLite() - } - set {oneofField = .oneofSubmessage(newValue)} - } - - var oneofString: String { - get { - if case .oneofString(let v)? = oneofField {return v} - return String() - } - set {oneofField = .oneofString(newValue)} - } - - var oneofBytes: Data { - get { - if case .oneofBytes(let v)? = oneofField {return v} - return Data([100, 101, 102, 97, 117, 108, 116, 32, 98, 121, 116, 101, 115]) - } - set {oneofField = .oneofBytes(newValue)} - } - - var oneofStringCord: String { - get { - if case .oneofStringCord(let v)? = oneofField {return v} - return "default Cord" - } - set {oneofField = .oneofStringCord(newValue)} - } - - var oneofBytesCord: Data { - get { - if case .oneofBytesCord(let v)? = oneofField {return v} - return Data() - } - set {oneofField = .oneofBytesCord(newValue)} - } - - var oneofStringStringPiece: String { - get { - if case .oneofStringStringPiece(let v)? = oneofField {return v} - return String() - } - set {oneofField = .oneofStringStringPiece(newValue)} - } - - var oneofBytesStringPiece: Data { - get { - if case .oneofBytesStringPiece(let v)? = oneofField {return v} - return Data([100, 101, 102, 97, 117, 108, 116, 32, 83, 116, 114, 105, 110, 103, 80, 105, 101, 99, 101]) - } - set {oneofField = .oneofBytesStringPiece(newValue)} - } - - var oneofEnum: ProtobufUnittest_V2EnumLite { - get { - if case .oneofEnum(let v)? = oneofField {return v} - return .v2First - } - set {oneofField = .oneofEnum(newValue)} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum OneOf_OneofField: Equatable { - case oneofInt32(Int32) - case oneofSubmessage(ProtobufUnittest_TestAllTypesLite) - case oneofString(String) - case oneofBytes(Data) - case oneofStringCord(String) - case oneofBytesCord(Data) - case oneofStringStringPiece(String) - case oneofBytesStringPiece(Data) - case oneofEnum(ProtobufUnittest_V2EnumLite) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestOneofParsingLite.OneOf_OneofField, rhs: ProtobufUnittest_TestOneofParsingLite.OneOf_OneofField) -> 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 (.oneofInt32, .oneofInt32): return { - guard case .oneofInt32(let l) = lhs, case .oneofInt32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSubmessage, .oneofSubmessage): return { - guard case .oneofSubmessage(let l) = lhs, case .oneofSubmessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofStringCord, .oneofStringCord): return { - guard case .oneofStringCord(let l) = lhs, case .oneofStringCord(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytesCord, .oneofBytesCord): return { - guard case .oneofBytesCord(let l) = lhs, case .oneofBytesCord(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofStringStringPiece, .oneofStringStringPiece): return { - guard case .oneofStringStringPiece(let l) = lhs, case .oneofStringStringPiece(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytesStringPiece, .oneofBytesStringPiece): return { - guard case .oneofBytesStringPiece(let l) = lhs, case .oneofBytesStringPiece(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofEnum, .oneofEnum): return { - guard case .oneofEnum(let l) = lhs, case .oneofEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif - } - - init() {} -} - -/// The following four messages are set up to test for wire compatibility between -/// packed and non-packed repeated fields. We use the field number 2048, because -/// that is large enough to require a 3-byte varint for the tag. -struct ProtobufUnittest_PackedInt32 { - // 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 repeatedInt32: [Int32] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -struct ProtobufUnittest_NonPackedInt32 { - // 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 repeatedInt32: [Int32] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -struct ProtobufUnittest_PackedFixed32 { - // 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 repeatedFixed32: [UInt32] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -struct ProtobufUnittest_NonPackedFixed32 { - // 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 repeatedFixed32: [UInt32] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -/// Test an enum that has multiple values with the same number. -struct ProtobufUnittest_DupEnum { - // 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() - - enum TestEnumWithDupValueLite: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo1 // = 1 - case bar1 // = 2 - case baz // = 3 - static let foo2 = foo1 - static let bar2 = bar1 - - init() { - self = .foo1 - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .foo1 - case 2: self = .bar1 - case 3: self = .baz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo1: return 1 - case .bar1: return 2 - case .baz: return 3 - } - } - - } - - init() {} -} - -#if swift(>=4.2) - -extension ProtobufUnittest_DupEnum.TestEnumWithDupValueLite: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_RecursiveMessage { - // 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 recurse: ProtobufUnittest_RecursiveMessage { - get {return _storage._recurse ?? ProtobufUnittest_RecursiveMessage()} - set {_uniqueStorage()._recurse = newValue} - } - /// Returns true if `recurse` has been explicitly set. - var hasRecurse: Bool {return _storage._recurse != nil} - /// Clears the value of `recurse`. Subsequent reads from it will return its default value. - mutating func clearRecurse() {_uniqueStorage()._recurse = nil} - - var payload: Data { - get {return _storage._payload ?? Data()} - set {_uniqueStorage()._payload = newValue} - } - /// Returns true if `payload` has been explicitly set. - var hasPayload: Bool {return _storage._payload != nil} - /// Clears the value of `payload`. Subsequent reads from it will return its default value. - mutating func clearPayload() {_uniqueStorage()._payload = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_ForeignEnumLite: @unchecked Sendable {} -extension ProtobufUnittest_V1EnumLite: @unchecked Sendable {} -extension ProtobufUnittest_V2EnumLite: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypesLite: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypesLite.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypesLite.NestedEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypesLite.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypesLite.NestedMessage2: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypesLite.OptionalGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypesLite.RepeatedGroup: @unchecked Sendable {} -extension ProtobufUnittest_ForeignMessageLite: @unchecked Sendable {} -extension ProtobufUnittest_TestPackedTypesLite: @unchecked Sendable {} -extension ProtobufUnittest_TestAllExtensionsLite: @unchecked Sendable {} -extension ProtobufUnittest_OptionalGroup_extension_lite: @unchecked Sendable {} -extension ProtobufUnittest_RepeatedGroup_extension_lite: @unchecked Sendable {} -extension ProtobufUnittest_TestPackedExtensionsLite: @unchecked Sendable {} -extension ProtobufUnittest_TestNestedExtensionLite: @unchecked Sendable {} -extension ProtobufUnittest_TestDeprecatedLite: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMergeLite: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group1: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group2: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMergeLite.OptionalGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMergeLite.RepeatedGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestEmptyMessageLite: @unchecked Sendable {} -extension ProtobufUnittest_TestEmptyMessageWithExtensionsLite: @unchecked Sendable {} -extension ProtobufUnittest_V1MessageLite: @unchecked Sendable {} -extension ProtobufUnittest_V2MessageLite: @unchecked Sendable {} -extension ProtobufUnittest_TestHugeFieldNumbersLite: @unchecked Sendable {} -extension ProtobufUnittest_TestHugeFieldNumbersLite.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufUnittest_TestHugeFieldNumbersLite.OptionalGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestOneofParsingLite: @unchecked Sendable {} -extension ProtobufUnittest_TestOneofParsingLite.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufUnittest_PackedInt32: @unchecked Sendable {} -extension ProtobufUnittest_NonPackedInt32: @unchecked Sendable {} -extension ProtobufUnittest_PackedFixed32: @unchecked Sendable {} -extension ProtobufUnittest_NonPackedFixed32: @unchecked Sendable {} -extension ProtobufUnittest_DupEnum: @unchecked Sendable {} -extension ProtobufUnittest_DupEnum.TestEnumWithDupValueLite: @unchecked Sendable {} -extension ProtobufUnittest_RecursiveMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Extension support defined in unittest_lite.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 ProtobufUnittest_TestAllExtensionsLite { - - /// Singular - var ProtobufUnittest_optionalInt32ExtensionLite: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_int32_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_int32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_int32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalInt32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_int32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_int32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalInt32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_int32_extension_lite) - } - - var ProtobufUnittest_optionalInt64ExtensionLite: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_int64_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_int64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_int64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalInt64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_int64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_int64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalInt64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_int64_extension_lite) - } - - var ProtobufUnittest_optionalUint32ExtensionLite: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint32_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_uint32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalUint32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_uint32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalUint32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint32_extension_lite) - } - - var ProtobufUnittest_optionalUint64ExtensionLite: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint64_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_uint64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalUint64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_uint64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalUint64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint64_extension_lite) - } - - var ProtobufUnittest_optionalSint32ExtensionLite: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint32_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_sint32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalSint32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_sint32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalSint32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint32_extension_lite) - } - - var ProtobufUnittest_optionalSint64ExtensionLite: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint64_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_sint64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalSint64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_sint64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalSint64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint64_extension_lite) - } - - var ProtobufUnittest_optionalFixed32ExtensionLite: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed32_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_fixed32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalFixed32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_fixed32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalFixed32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed32_extension_lite) - } - - var ProtobufUnittest_optionalFixed64ExtensionLite: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed64_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_fixed64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalFixed64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_fixed64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalFixed64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed64_extension_lite) - } - - var ProtobufUnittest_optionalSfixed32ExtensionLite: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed32_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_sfixed32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalSfixed32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_sfixed32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalSfixed32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed32_extension_lite) - } - - var ProtobufUnittest_optionalSfixed64ExtensionLite: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed64_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_sfixed64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalSfixed64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_sfixed64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalSfixed64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed64_extension_lite) - } - - var ProtobufUnittest_optionalFloatExtensionLite: Float { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_float_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_float_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_float_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalFloatExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_float_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_float_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalFloatExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_float_extension_lite) - } - - var ProtobufUnittest_optionalDoubleExtensionLite: Double { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_double_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_double_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_double_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalDoubleExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_double_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_double_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalDoubleExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_double_extension_lite) - } - - var ProtobufUnittest_optionalBoolExtensionLite: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_bool_extension_lite) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_bool_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_bool_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalBoolExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_bool_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_bool_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalBoolExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_bool_extension_lite) - } - - var ProtobufUnittest_optionalStringExtensionLite: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_extension_lite) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_string_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalStringExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_string_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalStringExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_extension_lite) - } - - var ProtobufUnittest_optionalBytesExtensionLite: Data { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_bytes_extension_lite) ?? Data()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_bytes_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_bytes_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalBytesExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_bytes_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_bytes_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalBytesExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_bytes_extension_lite) - } - - var ProtobufUnittest_optionalGroupExtensionLite: ProtobufUnittest_OptionalGroup_extension_lite { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_OptionalGroup_extension_lite) ?? ProtobufUnittest_OptionalGroup_extension_lite()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_OptionalGroup_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_OptionalGroup_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalGroupExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_OptionalGroup_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_OptionalGroup_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalGroupExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_OptionalGroup_extension_lite) - } - - var ProtobufUnittest_optionalNestedMessageExtensionLite: ProtobufUnittest_TestAllTypesLite.NestedMessage { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_message_extension_lite) ?? ProtobufUnittest_TestAllTypesLite.NestedMessage()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_nested_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalNestedMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_nested_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalNestedMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_message_extension_lite) - } - - var ProtobufUnittest_optionalForeignMessageExtensionLite: ProtobufUnittest_ForeignMessageLite { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_message_extension_lite) ?? ProtobufUnittest_ForeignMessageLite()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_foreign_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalForeignMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_foreign_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalForeignMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_message_extension_lite) - } - - var ProtobufUnittest_optionalImportMessageExtensionLite: ProtobufUnittestImport_ImportMessageLite { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_message_extension_lite) ?? ProtobufUnittestImport_ImportMessageLite()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_import_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalImportMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_import_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalImportMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_message_extension_lite) - } - - var ProtobufUnittest_optionalNestedEnumExtensionLite: ProtobufUnittest_TestAllTypesLite.NestedEnum { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_enum_extension_lite) ?? .foo} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_nested_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalNestedEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_nested_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalNestedEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_enum_extension_lite) - } - - var ProtobufUnittest_optionalForeignEnumExtensionLite: ProtobufUnittest_ForeignEnumLite { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_enum_extension_lite) ?? .foreignLiteFoo} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_foreign_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalForeignEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_foreign_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalForeignEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_enum_extension_lite) - } - - var ProtobufUnittest_optionalImportEnumExtensionLite: ProtobufUnittestImport_ImportEnumLite { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_enum_extension_lite) ?? .importLiteFoo} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_import_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalImportEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_import_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalImportEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_enum_extension_lite) - } - - var ProtobufUnittest_optionalStringPieceExtensionLite: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_piece_extension_lite) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_piece_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_string_piece_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalStringPieceExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_piece_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_string_piece_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalStringPieceExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_piece_extension_lite) - } - - var ProtobufUnittest_optionalCordExtensionLite: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_cord_extension_lite) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_cord_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_cord_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalCordExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_cord_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_cord_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalCordExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_cord_extension_lite) - } - - var ProtobufUnittest_optionalPublicImportMessageExtensionLite: ProtobufUnittestImport_PublicImportMessageLite { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_public_import_message_extension_lite) ?? ProtobufUnittestImport_PublicImportMessageLite()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_public_import_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_public_import_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalPublicImportMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_public_import_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_public_import_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalPublicImportMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_public_import_message_extension_lite) - } - - var ProtobufUnittest_optionalLazyMessageExtensionLite: ProtobufUnittest_TestAllTypesLite.NestedMessage { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_lazy_message_extension_lite) ?? ProtobufUnittest_TestAllTypesLite.NestedMessage()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_lazy_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_lazy_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalLazyMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_lazy_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_lazy_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalLazyMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_lazy_message_extension_lite) - } - - /// Repeated - var ProtobufUnittest_repeatedInt32ExtensionLite: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_int32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedInt32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_int32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedInt32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int32_extension_lite) - } - - var ProtobufUnittest_repeatedInt64ExtensionLite: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_int64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedInt64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_int64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedInt64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int64_extension_lite) - } - - var ProtobufUnittest_repeatedUint32ExtensionLite: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_uint32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedUint32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_uint32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedUint32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint32_extension_lite) - } - - var ProtobufUnittest_repeatedUint64ExtensionLite: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_uint64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedUint64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_uint64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedUint64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint64_extension_lite) - } - - var ProtobufUnittest_repeatedSint32ExtensionLite: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_sint32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedSint32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_sint32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedSint32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint32_extension_lite) - } - - var ProtobufUnittest_repeatedSint64ExtensionLite: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_sint64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedSint64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_sint64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedSint64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint64_extension_lite) - } - - var ProtobufUnittest_repeatedFixed32ExtensionLite: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_fixed32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedFixed32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_fixed32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedFixed32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed32_extension_lite) - } - - var ProtobufUnittest_repeatedFixed64ExtensionLite: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_fixed64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedFixed64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_fixed64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedFixed64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed64_extension_lite) - } - - var ProtobufUnittest_repeatedSfixed32ExtensionLite: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_sfixed32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedSfixed32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_sfixed32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedSfixed32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed32_extension_lite) - } - - var ProtobufUnittest_repeatedSfixed64ExtensionLite: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_sfixed64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedSfixed64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_sfixed64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedSfixed64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed64_extension_lite) - } - - var ProtobufUnittest_repeatedFloatExtensionLite: [Float] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_float_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_float_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_float_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedFloatExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_float_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_float_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedFloatExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_float_extension_lite) - } - - var ProtobufUnittest_repeatedDoubleExtensionLite: [Double] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_double_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_double_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_double_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedDoubleExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_double_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_double_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedDoubleExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_double_extension_lite) - } - - var ProtobufUnittest_repeatedBoolExtensionLite: [Bool] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bool_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bool_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_bool_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedBoolExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bool_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_bool_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedBoolExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bool_extension_lite) - } - - var ProtobufUnittest_repeatedStringExtensionLite: [String] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_string_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedStringExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_string_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedStringExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_extension_lite) - } - - var ProtobufUnittest_repeatedBytesExtensionLite: [Data] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bytes_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bytes_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_bytes_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedBytesExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bytes_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_bytes_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedBytesExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bytes_extension_lite) - } - - var ProtobufUnittest_repeatedGroupExtensionLite: [ProtobufUnittest_RepeatedGroup_extension_lite] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_RepeatedGroup_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_RepeatedGroup_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_RepeatedGroup_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedGroupExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_RepeatedGroup_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_RepeatedGroup_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedGroupExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_RepeatedGroup_extension_lite) - } - - var ProtobufUnittest_repeatedNestedMessageExtensionLite: [ProtobufUnittest_TestAllTypesLite.NestedMessage] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_message_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_nested_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedNestedMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_nested_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedNestedMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_message_extension_lite) - } - - var ProtobufUnittest_repeatedForeignMessageExtensionLite: [ProtobufUnittest_ForeignMessageLite] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_message_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_foreign_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedForeignMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_foreign_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedForeignMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_message_extension_lite) - } - - var ProtobufUnittest_repeatedImportMessageExtensionLite: [ProtobufUnittestImport_ImportMessageLite] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_message_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_import_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedImportMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_import_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedImportMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_message_extension_lite) - } - - var ProtobufUnittest_repeatedNestedEnumExtensionLite: [ProtobufUnittest_TestAllTypesLite.NestedEnum] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_enum_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_nested_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedNestedEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_nested_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedNestedEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_enum_extension_lite) - } - - var ProtobufUnittest_repeatedForeignEnumExtensionLite: [ProtobufUnittest_ForeignEnumLite] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_enum_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_foreign_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedForeignEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_foreign_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedForeignEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_enum_extension_lite) - } - - var ProtobufUnittest_repeatedImportEnumExtensionLite: [ProtobufUnittestImport_ImportEnumLite] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_enum_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_import_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedImportEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_import_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedImportEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_enum_extension_lite) - } - - var ProtobufUnittest_repeatedStringPieceExtensionLite: [String] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_piece_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_piece_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_string_piece_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedStringPieceExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_piece_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_string_piece_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedStringPieceExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_piece_extension_lite) - } - - var ProtobufUnittest_repeatedCordExtensionLite: [String] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_cord_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_cord_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_cord_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedCordExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_cord_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_cord_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedCordExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_cord_extension_lite) - } - - var ProtobufUnittest_repeatedLazyMessageExtensionLite: [ProtobufUnittest_TestAllTypesLite.NestedMessage] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_lazy_message_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_lazy_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_lazy_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedLazyMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_lazy_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_lazy_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedLazyMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_lazy_message_extension_lite) - } - - /// Singular with defaults - var ProtobufUnittest_defaultInt32ExtensionLite: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_int32_extension_lite) ?? 41} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_int32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_int32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultInt32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_int32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_int32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultInt32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_int32_extension_lite) - } - - var ProtobufUnittest_defaultInt64ExtensionLite: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_int64_extension_lite) ?? 42} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_int64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_int64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultInt64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_int64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_int64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultInt64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_int64_extension_lite) - } - - var ProtobufUnittest_defaultUint32ExtensionLite: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_uint32_extension_lite) ?? 43} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_uint32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_uint32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultUint32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_uint32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_uint32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultUint32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_uint32_extension_lite) - } - - var ProtobufUnittest_defaultUint64ExtensionLite: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_uint64_extension_lite) ?? 44} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_uint64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_uint64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultUint64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_uint64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_uint64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultUint64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_uint64_extension_lite) - } - - var ProtobufUnittest_defaultSint32ExtensionLite: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_sint32_extension_lite) ?? -45} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_sint32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_sint32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultSint32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_sint32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_sint32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultSint32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_sint32_extension_lite) - } - - var ProtobufUnittest_defaultSint64ExtensionLite: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_sint64_extension_lite) ?? 46} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_sint64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_sint64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultSint64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_sint64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_sint64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultSint64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_sint64_extension_lite) - } - - var ProtobufUnittest_defaultFixed32ExtensionLite: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed32_extension_lite) ?? 47} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_fixed32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultFixed32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_fixed32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultFixed32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed32_extension_lite) - } - - var ProtobufUnittest_defaultFixed64ExtensionLite: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed64_extension_lite) ?? 48} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_fixed64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultFixed64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_fixed64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultFixed64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed64_extension_lite) - } - - var ProtobufUnittest_defaultSfixed32ExtensionLite: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed32_extension_lite) ?? 49} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_sfixed32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultSfixed32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_sfixed32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultSfixed32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed32_extension_lite) - } - - var ProtobufUnittest_defaultSfixed64ExtensionLite: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed64_extension_lite) ?? -50} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_sfixed64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultSfixed64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_sfixed64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultSfixed64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed64_extension_lite) - } - - var ProtobufUnittest_defaultFloatExtensionLite: Float { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_float_extension_lite) ?? 51.5} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_float_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_float_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultFloatExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_float_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_float_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultFloatExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_float_extension_lite) - } - - var ProtobufUnittest_defaultDoubleExtensionLite: Double { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_double_extension_lite) ?? 52000} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_double_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_double_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultDoubleExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_double_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_double_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultDoubleExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_double_extension_lite) - } - - var ProtobufUnittest_defaultBoolExtensionLite: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_bool_extension_lite) ?? true} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_bool_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_bool_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultBoolExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_bool_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_bool_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultBoolExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_bool_extension_lite) - } - - var ProtobufUnittest_defaultStringExtensionLite: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_string_extension_lite) ?? "hello"} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_string_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_string_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultStringExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_string_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_string_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultStringExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_string_extension_lite) - } - - var ProtobufUnittest_defaultBytesExtensionLite: Data { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_bytes_extension_lite) ?? Data([119, 111, 114, 108, 100])} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_bytes_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_bytes_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultBytesExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_bytes_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_bytes_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultBytesExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_bytes_extension_lite) - } - - var ProtobufUnittest_defaultNestedEnumExtensionLite: ProtobufUnittest_TestAllTypesLite.NestedEnum { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_nested_enum_extension_lite) ?? .bar} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_nested_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_nested_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultNestedEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_nested_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_nested_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultNestedEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_nested_enum_extension_lite) - } - - var ProtobufUnittest_defaultForeignEnumExtensionLite: ProtobufUnittest_ForeignEnumLite { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_foreign_enum_extension_lite) ?? .foreignLiteBar} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_foreign_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_foreign_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultForeignEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_foreign_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_foreign_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultForeignEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_foreign_enum_extension_lite) - } - - var ProtobufUnittest_defaultImportEnumExtensionLite: ProtobufUnittestImport_ImportEnumLite { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_import_enum_extension_lite) ?? .importLiteBar} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_import_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_import_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultImportEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_import_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_import_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultImportEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_import_enum_extension_lite) - } - - var ProtobufUnittest_defaultStringPieceExtensionLite: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_string_piece_extension_lite) ?? "abc"} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_string_piece_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_string_piece_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultStringPieceExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_string_piece_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_string_piece_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultStringPieceExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_string_piece_extension_lite) - } - - var ProtobufUnittest_defaultCordExtensionLite: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_cord_extension_lite) ?? "123"} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_cord_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_cord_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultCordExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_cord_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_cord_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultCordExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_cord_extension_lite) - } - - /// For oneof test - var ProtobufUnittest_oneofUint32ExtensionLite: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_oneof_uint32_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_oneof_uint32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_oneof_uint32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_oneofUint32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_oneof_uint32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_oneof_uint32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_oneofUint32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_oneof_uint32_extension_lite) - } - - var ProtobufUnittest_oneofNestedMessageExtensionLite: ProtobufUnittest_TestAllTypesLite.NestedMessage { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_oneof_nested_message_extension_lite) ?? ProtobufUnittest_TestAllTypesLite.NestedMessage()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_oneof_nested_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_oneof_nested_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_oneofNestedMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_oneof_nested_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_oneof_nested_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_oneofNestedMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_oneof_nested_message_extension_lite) - } - - var ProtobufUnittest_oneofStringExtensionLite: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_oneof_string_extension_lite) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_oneof_string_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_oneof_string_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_oneofStringExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_oneof_string_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_oneof_string_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_oneofStringExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_oneof_string_extension_lite) - } - - var ProtobufUnittest_oneofBytesExtensionLite: Data { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_oneof_bytes_extension_lite) ?? Data()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_oneof_bytes_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_oneof_bytes_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_oneofBytesExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_oneof_bytes_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_oneof_bytes_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_oneofBytesExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_oneof_bytes_extension_lite) - } - - var ProtobufUnittest_TestNestedExtensionLite_nestedExtension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_TestNestedExtensionLite.Extensions.nested_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_TestNestedExtensionLite.Extensions.nested_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestNestedExtensionLite.Extensions.nested_extension` - /// has been explicitly set. - var hasProtobufUnittest_TestNestedExtensionLite_nestedExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestNestedExtensionLite.Extensions.nested_extension) - } - /// Clears the value of extension `ProtobufUnittest_TestNestedExtensionLite.Extensions.nested_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestNestedExtensionLite_nestedExtension() { - clearExtensionValue(ext: ProtobufUnittest_TestNestedExtensionLite.Extensions.nested_extension) - } -} - -extension ProtobufUnittest_TestHugeFieldNumbersLite { - - var ProtobufUnittest_testAllTypesLite: ProtobufUnittest_TestAllTypesLite { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_test_all_types_lite) ?? ProtobufUnittest_TestAllTypesLite()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_test_all_types_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_test_all_types_lite` - /// has been explicitly set. - var hasProtobufUnittest_testAllTypesLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_test_all_types_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_test_all_types_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_testAllTypesLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_test_all_types_lite) - } -} - -extension ProtobufUnittest_TestPackedExtensionsLite { - - var ProtobufUnittest_packedInt32ExtensionLite: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_int32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_int32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_int32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedInt32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_int32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_int32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedInt32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_int32_extension_lite) - } - - var ProtobufUnittest_packedInt64ExtensionLite: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_int64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_int64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_int64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedInt64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_int64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_int64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedInt64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_int64_extension_lite) - } - - var ProtobufUnittest_packedUint32ExtensionLite: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_uint32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedUint32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_uint32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedUint32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint32_extension_lite) - } - - var ProtobufUnittest_packedUint64ExtensionLite: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_uint64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedUint64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_uint64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedUint64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint64_extension_lite) - } - - var ProtobufUnittest_packedSint32ExtensionLite: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_sint32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedSint32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_sint32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedSint32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint32_extension_lite) - } - - var ProtobufUnittest_packedSint64ExtensionLite: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_sint64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedSint64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_sint64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedSint64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint64_extension_lite) - } - - var ProtobufUnittest_packedFixed32ExtensionLite: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_fixed32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedFixed32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_fixed32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedFixed32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed32_extension_lite) - } - - var ProtobufUnittest_packedFixed64ExtensionLite: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_fixed64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedFixed64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_fixed64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedFixed64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed64_extension_lite) - } - - var ProtobufUnittest_packedSfixed32ExtensionLite: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_sfixed32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedSfixed32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_sfixed32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedSfixed32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed32_extension_lite) - } - - var ProtobufUnittest_packedSfixed64ExtensionLite: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_sfixed64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedSfixed64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_sfixed64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedSfixed64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed64_extension_lite) - } - - var ProtobufUnittest_packedFloatExtensionLite: [Float] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_float_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_float_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_float_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedFloatExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_float_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_float_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedFloatExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_float_extension_lite) - } - - var ProtobufUnittest_packedDoubleExtensionLite: [Double] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_double_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_double_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_double_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedDoubleExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_double_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_double_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedDoubleExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_double_extension_lite) - } - - var ProtobufUnittest_packedBoolExtensionLite: [Bool] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_bool_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_bool_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_bool_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedBoolExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_bool_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_bool_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedBoolExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_bool_extension_lite) - } - - var ProtobufUnittest_packedEnumExtensionLite: [ProtobufUnittest_ForeignEnumLite] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_enum_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_enum_extension_lite) - } -} - -extension ProtobufUnittest_TestParsingMergeLite { - - var ProtobufUnittest_TestParsingMergeLite_optionalExt: ProtobufUnittest_TestAllTypesLite { - get {return getExtensionValue(ext: ProtobufUnittest_TestParsingMergeLite.Extensions.optional_ext) ?? ProtobufUnittest_TestAllTypesLite()} - set {setExtensionValue(ext: ProtobufUnittest_TestParsingMergeLite.Extensions.optional_ext, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestParsingMergeLite.Extensions.optional_ext` - /// has been explicitly set. - var hasProtobufUnittest_TestParsingMergeLite_optionalExt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestParsingMergeLite.Extensions.optional_ext) - } - /// Clears the value of extension `ProtobufUnittest_TestParsingMergeLite.Extensions.optional_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestParsingMergeLite_optionalExt() { - clearExtensionValue(ext: ProtobufUnittest_TestParsingMergeLite.Extensions.optional_ext) - } - - var ProtobufUnittest_TestParsingMergeLite_repeatedExt: [ProtobufUnittest_TestAllTypesLite] { - get {return getExtensionValue(ext: ProtobufUnittest_TestParsingMergeLite.Extensions.repeated_ext) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_TestParsingMergeLite.Extensions.repeated_ext, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestParsingMergeLite.Extensions.repeated_ext` - /// has been explicitly set. - var hasProtobufUnittest_TestParsingMergeLite_repeatedExt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestParsingMergeLite.Extensions.repeated_ext) - } - /// Clears the value of extension `ProtobufUnittest_TestParsingMergeLite.Extensions.repeated_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestParsingMergeLite_repeatedExt() { - clearExtensionValue(ext: ProtobufUnittest_TestParsingMergeLite.Extensions.repeated_ext) - } - -} - -// MARK: - File's ExtensionMap: ProtobufUnittest_UnittestLite_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 ProtobufUnittest_UnittestLite_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_Extensions_optional_int32_extension_lite, - ProtobufUnittest_Extensions_optional_int64_extension_lite, - ProtobufUnittest_Extensions_optional_uint32_extension_lite, - ProtobufUnittest_Extensions_optional_uint64_extension_lite, - ProtobufUnittest_Extensions_optional_sint32_extension_lite, - ProtobufUnittest_Extensions_optional_sint64_extension_lite, - ProtobufUnittest_Extensions_optional_fixed32_extension_lite, - ProtobufUnittest_Extensions_optional_fixed64_extension_lite, - ProtobufUnittest_Extensions_optional_sfixed32_extension_lite, - ProtobufUnittest_Extensions_optional_sfixed64_extension_lite, - ProtobufUnittest_Extensions_optional_float_extension_lite, - ProtobufUnittest_Extensions_optional_double_extension_lite, - ProtobufUnittest_Extensions_optional_bool_extension_lite, - ProtobufUnittest_Extensions_optional_string_extension_lite, - ProtobufUnittest_Extensions_optional_bytes_extension_lite, - ProtobufUnittest_Extensions_OptionalGroup_extension_lite, - ProtobufUnittest_Extensions_optional_nested_message_extension_lite, - ProtobufUnittest_Extensions_optional_foreign_message_extension_lite, - ProtobufUnittest_Extensions_optional_import_message_extension_lite, - ProtobufUnittest_Extensions_optional_nested_enum_extension_lite, - ProtobufUnittest_Extensions_optional_foreign_enum_extension_lite, - ProtobufUnittest_Extensions_optional_import_enum_extension_lite, - ProtobufUnittest_Extensions_optional_string_piece_extension_lite, - ProtobufUnittest_Extensions_optional_cord_extension_lite, - ProtobufUnittest_Extensions_optional_public_import_message_extension_lite, - ProtobufUnittest_Extensions_optional_lazy_message_extension_lite, - ProtobufUnittest_Extensions_repeated_int32_extension_lite, - ProtobufUnittest_Extensions_repeated_int64_extension_lite, - ProtobufUnittest_Extensions_repeated_uint32_extension_lite, - ProtobufUnittest_Extensions_repeated_uint64_extension_lite, - ProtobufUnittest_Extensions_repeated_sint32_extension_lite, - ProtobufUnittest_Extensions_repeated_sint64_extension_lite, - ProtobufUnittest_Extensions_repeated_fixed32_extension_lite, - ProtobufUnittest_Extensions_repeated_fixed64_extension_lite, - ProtobufUnittest_Extensions_repeated_sfixed32_extension_lite, - ProtobufUnittest_Extensions_repeated_sfixed64_extension_lite, - ProtobufUnittest_Extensions_repeated_float_extension_lite, - ProtobufUnittest_Extensions_repeated_double_extension_lite, - ProtobufUnittest_Extensions_repeated_bool_extension_lite, - ProtobufUnittest_Extensions_repeated_string_extension_lite, - ProtobufUnittest_Extensions_repeated_bytes_extension_lite, - ProtobufUnittest_Extensions_RepeatedGroup_extension_lite, - ProtobufUnittest_Extensions_repeated_nested_message_extension_lite, - ProtobufUnittest_Extensions_repeated_foreign_message_extension_lite, - ProtobufUnittest_Extensions_repeated_import_message_extension_lite, - ProtobufUnittest_Extensions_repeated_nested_enum_extension_lite, - ProtobufUnittest_Extensions_repeated_foreign_enum_extension_lite, - ProtobufUnittest_Extensions_repeated_import_enum_extension_lite, - ProtobufUnittest_Extensions_repeated_string_piece_extension_lite, - ProtobufUnittest_Extensions_repeated_cord_extension_lite, - ProtobufUnittest_Extensions_repeated_lazy_message_extension_lite, - ProtobufUnittest_Extensions_default_int32_extension_lite, - ProtobufUnittest_Extensions_default_int64_extension_lite, - ProtobufUnittest_Extensions_default_uint32_extension_lite, - ProtobufUnittest_Extensions_default_uint64_extension_lite, - ProtobufUnittest_Extensions_default_sint32_extension_lite, - ProtobufUnittest_Extensions_default_sint64_extension_lite, - ProtobufUnittest_Extensions_default_fixed32_extension_lite, - ProtobufUnittest_Extensions_default_fixed64_extension_lite, - ProtobufUnittest_Extensions_default_sfixed32_extension_lite, - ProtobufUnittest_Extensions_default_sfixed64_extension_lite, - ProtobufUnittest_Extensions_default_float_extension_lite, - ProtobufUnittest_Extensions_default_double_extension_lite, - ProtobufUnittest_Extensions_default_bool_extension_lite, - ProtobufUnittest_Extensions_default_string_extension_lite, - ProtobufUnittest_Extensions_default_bytes_extension_lite, - ProtobufUnittest_Extensions_default_nested_enum_extension_lite, - ProtobufUnittest_Extensions_default_foreign_enum_extension_lite, - ProtobufUnittest_Extensions_default_import_enum_extension_lite, - ProtobufUnittest_Extensions_default_string_piece_extension_lite, - ProtobufUnittest_Extensions_default_cord_extension_lite, - ProtobufUnittest_Extensions_oneof_uint32_extension_lite, - ProtobufUnittest_Extensions_oneof_nested_message_extension_lite, - ProtobufUnittest_Extensions_oneof_string_extension_lite, - ProtobufUnittest_Extensions_oneof_bytes_extension_lite, - ProtobufUnittest_Extensions_packed_int32_extension_lite, - ProtobufUnittest_Extensions_packed_int64_extension_lite, - ProtobufUnittest_Extensions_packed_uint32_extension_lite, - ProtobufUnittest_Extensions_packed_uint64_extension_lite, - ProtobufUnittest_Extensions_packed_sint32_extension_lite, - ProtobufUnittest_Extensions_packed_sint64_extension_lite, - ProtobufUnittest_Extensions_packed_fixed32_extension_lite, - ProtobufUnittest_Extensions_packed_fixed64_extension_lite, - ProtobufUnittest_Extensions_packed_sfixed32_extension_lite, - ProtobufUnittest_Extensions_packed_sfixed64_extension_lite, - ProtobufUnittest_Extensions_packed_float_extension_lite, - ProtobufUnittest_Extensions_packed_double_extension_lite, - ProtobufUnittest_Extensions_packed_bool_extension_lite, - ProtobufUnittest_Extensions_packed_enum_extension_lite, - ProtobufUnittest_Extensions_test_all_types_lite, - ProtobufUnittest_TestNestedExtensionLite.Extensions.nested_extension, - ProtobufUnittest_TestParsingMergeLite.Extensions.optional_ext, - ProtobufUnittest_TestParsingMergeLite.Extensions.repeated_ext -] - -// 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. - -/// Singular -let ProtobufUnittest_Extensions_optional_int32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 1, - fieldName: "protobuf_unittest.optional_int32_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_int64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 2, - fieldName: "protobuf_unittest.optional_int64_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_uint32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 3, - fieldName: "protobuf_unittest.optional_uint32_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_uint64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 4, - fieldName: "protobuf_unittest.optional_uint64_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_sint32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 5, - fieldName: "protobuf_unittest.optional_sint32_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_sint64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 6, - fieldName: "protobuf_unittest.optional_sint64_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_fixed32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 7, - fieldName: "protobuf_unittest.optional_fixed32_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_fixed64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 8, - fieldName: "protobuf_unittest.optional_fixed64_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_sfixed32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 9, - fieldName: "protobuf_unittest.optional_sfixed32_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_sfixed64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 10, - fieldName: "protobuf_unittest.optional_sfixed64_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_float_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 11, - fieldName: "protobuf_unittest.optional_float_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_double_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 12, - fieldName: "protobuf_unittest.optional_double_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_bool_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 13, - fieldName: "protobuf_unittest.optional_bool_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_string_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 14, - fieldName: "protobuf_unittest.optional_string_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_bytes_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 15, - fieldName: "protobuf_unittest.optional_bytes_extension_lite" -) - -let ProtobufUnittest_Extensions_OptionalGroup_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 16, - fieldName: "protobuf_unittest.optionalgroup_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_nested_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 18, - fieldName: "protobuf_unittest.optional_nested_message_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_foreign_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 19, - fieldName: "protobuf_unittest.optional_foreign_message_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_import_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 20, - fieldName: "protobuf_unittest.optional_import_message_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_nested_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 21, - fieldName: "protobuf_unittest.optional_nested_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_foreign_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 22, - fieldName: "protobuf_unittest.optional_foreign_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_import_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 23, - fieldName: "protobuf_unittest.optional_import_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_string_piece_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 24, - fieldName: "protobuf_unittest.optional_string_piece_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_cord_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 25, - fieldName: "protobuf_unittest.optional_cord_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_public_import_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 26, - fieldName: "protobuf_unittest.optional_public_import_message_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_lazy_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 27, - fieldName: "protobuf_unittest.optional_lazy_message_extension_lite" -) - -/// Repeated -let ProtobufUnittest_Extensions_repeated_int32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 31, - fieldName: "protobuf_unittest.repeated_int32_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_int64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 32, - fieldName: "protobuf_unittest.repeated_int64_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_uint32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 33, - fieldName: "protobuf_unittest.repeated_uint32_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_uint64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 34, - fieldName: "protobuf_unittest.repeated_uint64_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_sint32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 35, - fieldName: "protobuf_unittest.repeated_sint32_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_sint64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 36, - fieldName: "protobuf_unittest.repeated_sint64_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_fixed32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 37, - fieldName: "protobuf_unittest.repeated_fixed32_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_fixed64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 38, - fieldName: "protobuf_unittest.repeated_fixed64_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_sfixed32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 39, - fieldName: "protobuf_unittest.repeated_sfixed32_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_sfixed64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 40, - fieldName: "protobuf_unittest.repeated_sfixed64_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_float_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 41, - fieldName: "protobuf_unittest.repeated_float_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_double_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 42, - fieldName: "protobuf_unittest.repeated_double_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_bool_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 43, - fieldName: "protobuf_unittest.repeated_bool_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_string_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 44, - fieldName: "protobuf_unittest.repeated_string_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_bytes_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 45, - fieldName: "protobuf_unittest.repeated_bytes_extension_lite" -) - -let ProtobufUnittest_Extensions_RepeatedGroup_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 46, - fieldName: "protobuf_unittest.repeatedgroup_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_nested_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 48, - fieldName: "protobuf_unittest.repeated_nested_message_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_foreign_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 49, - fieldName: "protobuf_unittest.repeated_foreign_message_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_import_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 50, - fieldName: "protobuf_unittest.repeated_import_message_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_nested_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 51, - fieldName: "protobuf_unittest.repeated_nested_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_foreign_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 52, - fieldName: "protobuf_unittest.repeated_foreign_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_import_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 53, - fieldName: "protobuf_unittest.repeated_import_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_string_piece_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 54, - fieldName: "protobuf_unittest.repeated_string_piece_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_cord_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 55, - fieldName: "protobuf_unittest.repeated_cord_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_lazy_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 57, - fieldName: "protobuf_unittest.repeated_lazy_message_extension_lite" -) - -/// Singular with defaults -let ProtobufUnittest_Extensions_default_int32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 61, - fieldName: "protobuf_unittest.default_int32_extension_lite" -) - -let ProtobufUnittest_Extensions_default_int64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 62, - fieldName: "protobuf_unittest.default_int64_extension_lite" -) - -let ProtobufUnittest_Extensions_default_uint32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 63, - fieldName: "protobuf_unittest.default_uint32_extension_lite" -) - -let ProtobufUnittest_Extensions_default_uint64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 64, - fieldName: "protobuf_unittest.default_uint64_extension_lite" -) - -let ProtobufUnittest_Extensions_default_sint32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 65, - fieldName: "protobuf_unittest.default_sint32_extension_lite" -) - -let ProtobufUnittest_Extensions_default_sint64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 66, - fieldName: "protobuf_unittest.default_sint64_extension_lite" -) - -let ProtobufUnittest_Extensions_default_fixed32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 67, - fieldName: "protobuf_unittest.default_fixed32_extension_lite" -) - -let ProtobufUnittest_Extensions_default_fixed64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 68, - fieldName: "protobuf_unittest.default_fixed64_extension_lite" -) - -let ProtobufUnittest_Extensions_default_sfixed32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 69, - fieldName: "protobuf_unittest.default_sfixed32_extension_lite" -) - -let ProtobufUnittest_Extensions_default_sfixed64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 70, - fieldName: "protobuf_unittest.default_sfixed64_extension_lite" -) - -let ProtobufUnittest_Extensions_default_float_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 71, - fieldName: "protobuf_unittest.default_float_extension_lite" -) - -let ProtobufUnittest_Extensions_default_double_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 72, - fieldName: "protobuf_unittest.default_double_extension_lite" -) - -let ProtobufUnittest_Extensions_default_bool_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 73, - fieldName: "protobuf_unittest.default_bool_extension_lite" -) - -let ProtobufUnittest_Extensions_default_string_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 74, - fieldName: "protobuf_unittest.default_string_extension_lite" -) - -let ProtobufUnittest_Extensions_default_bytes_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 75, - fieldName: "protobuf_unittest.default_bytes_extension_lite" -) - -let ProtobufUnittest_Extensions_default_nested_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 81, - fieldName: "protobuf_unittest.default_nested_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_default_foreign_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 82, - fieldName: "protobuf_unittest.default_foreign_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_default_import_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 83, - fieldName: "protobuf_unittest.default_import_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_default_string_piece_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 84, - fieldName: "protobuf_unittest.default_string_piece_extension_lite" -) - -let ProtobufUnittest_Extensions_default_cord_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 85, - fieldName: "protobuf_unittest.default_cord_extension_lite" -) - -/// For oneof test -let ProtobufUnittest_Extensions_oneof_uint32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 111, - fieldName: "protobuf_unittest.oneof_uint32_extension_lite" -) - -let ProtobufUnittest_Extensions_oneof_nested_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 112, - fieldName: "protobuf_unittest.oneof_nested_message_extension_lite" -) - -let ProtobufUnittest_Extensions_oneof_string_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 113, - fieldName: "protobuf_unittest.oneof_string_extension_lite" -) - -let ProtobufUnittest_Extensions_oneof_bytes_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 114, - fieldName: "protobuf_unittest.oneof_bytes_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_int32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 90, - fieldName: "protobuf_unittest.packed_int32_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_int64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 91, - fieldName: "protobuf_unittest.packed_int64_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_uint32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 92, - fieldName: "protobuf_unittest.packed_uint32_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_uint64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 93, - fieldName: "protobuf_unittest.packed_uint64_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_sint32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 94, - fieldName: "protobuf_unittest.packed_sint32_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_sint64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 95, - fieldName: "protobuf_unittest.packed_sint64_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_fixed32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 96, - fieldName: "protobuf_unittest.packed_fixed32_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_fixed64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 97, - fieldName: "protobuf_unittest.packed_fixed64_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_sfixed32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 98, - fieldName: "protobuf_unittest.packed_sfixed32_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_sfixed64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 99, - fieldName: "protobuf_unittest.packed_sfixed64_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_float_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 100, - fieldName: "protobuf_unittest.packed_float_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_double_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 101, - fieldName: "protobuf_unittest.packed_double_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_bool_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 102, - fieldName: "protobuf_unittest.packed_bool_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 103, - fieldName: "protobuf_unittest.packed_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_test_all_types_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestHugeFieldNumbersLite>( - _protobuf_fieldNumber: 536860000, - fieldName: "protobuf_unittest.test_all_types_lite" -) - -extension ProtobufUnittest_TestNestedExtensionLite { - enum Extensions { - static let nested_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 12345, - fieldName: "protobuf_unittest.TestNestedExtensionLite.nested_extension" - ) - } -} - -extension ProtobufUnittest_TestParsingMergeLite { - enum Extensions { - static let optional_ext = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestParsingMergeLite>( - _protobuf_fieldNumber: 1000, - fieldName: "protobuf_unittest.TestParsingMergeLite.optional_ext" - ) - - static let repeated_ext = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestParsingMergeLite>( - _protobuf_fieldNumber: 1001, - fieldName: "protobuf_unittest.TestParsingMergeLite.repeated_ext" - ) - } -} - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest" - -extension ProtobufUnittest_ForeignEnumLite: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 4: .same(proto: "FOREIGN_LITE_FOO"), - 5: .same(proto: "FOREIGN_LITE_BAR"), - 6: .same(proto: "FOREIGN_LITE_BAZ"), - ] -} - -extension ProtobufUnittest_V1EnumLite: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "V1_FIRST"), - ] -} - -extension ProtobufUnittest_V2EnumLite: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "V2_FIRST"), - 2: .same(proto: "V2_SECOND"), - ] -} - -extension ProtobufUnittest_TestAllTypesLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestAllTypesLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 16: .unique(proto: "OptionalGroup", json: "optionalgroup"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "optional_foreign_message"), - 20: .standard(proto: "optional_import_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "optional_foreign_enum"), - 23: .standard(proto: "optional_import_enum"), - 24: .standard(proto: "optional_string_piece"), - 25: .standard(proto: "optional_cord"), - 26: .standard(proto: "optional_public_import_message"), - 27: .standard(proto: "optional_lazy_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 46: .unique(proto: "RepeatedGroup", json: "repeatedgroup"), - 48: .standard(proto: "repeated_nested_message"), - 49: .standard(proto: "repeated_foreign_message"), - 50: .standard(proto: "repeated_import_message"), - 51: .standard(proto: "repeated_nested_enum"), - 52: .standard(proto: "repeated_foreign_enum"), - 53: .standard(proto: "repeated_import_enum"), - 54: .standard(proto: "repeated_string_piece"), - 55: .standard(proto: "repeated_cord"), - 57: .standard(proto: "repeated_lazy_message"), - 61: .standard(proto: "default_int32"), - 62: .standard(proto: "default_int64"), - 63: .standard(proto: "default_uint32"), - 64: .standard(proto: "default_uint64"), - 65: .standard(proto: "default_sint32"), - 66: .standard(proto: "default_sint64"), - 67: .standard(proto: "default_fixed32"), - 68: .standard(proto: "default_fixed64"), - 69: .standard(proto: "default_sfixed32"), - 70: .standard(proto: "default_sfixed64"), - 71: .standard(proto: "default_float"), - 72: .standard(proto: "default_double"), - 73: .standard(proto: "default_bool"), - 74: .standard(proto: "default_string"), - 75: .standard(proto: "default_bytes"), - 81: .standard(proto: "default_nested_enum"), - 82: .standard(proto: "default_foreign_enum"), - 83: .standard(proto: "default_import_enum"), - 84: .standard(proto: "default_string_piece"), - 85: .standard(proto: "default_cord"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - 115: .standard(proto: "oneof_lazy_nested_message"), - 117: .standard(proto: "oneof_nested_message2"), - 116: .standard(proto: "deceptively_named_list"), - ] - - fileprivate class _StorageClass { - var _optionalInt32: Int32? = nil - var _optionalInt64: Int64? = nil - var _optionalUint32: UInt32? = nil - var _optionalUint64: UInt64? = nil - var _optionalSint32: Int32? = nil - var _optionalSint64: Int64? = nil - var _optionalFixed32: UInt32? = nil - var _optionalFixed64: UInt64? = nil - var _optionalSfixed32: Int32? = nil - var _optionalSfixed64: Int64? = nil - var _optionalFloat: Float? = nil - var _optionalDouble: Double? = nil - var _optionalBool: Bool? = nil - var _optionalString: String? = nil - var _optionalBytes: Data? = nil - var _optionalGroup: ProtobufUnittest_TestAllTypesLite.OptionalGroup? = nil - var _optionalNestedMessage: ProtobufUnittest_TestAllTypesLite.NestedMessage? = nil - var _optionalForeignMessage: ProtobufUnittest_ForeignMessageLite? = nil - var _optionalImportMessage: ProtobufUnittestImport_ImportMessageLite? = nil - var _optionalNestedEnum: ProtobufUnittest_TestAllTypesLite.NestedEnum? = nil - var _optionalForeignEnum: ProtobufUnittest_ForeignEnumLite? = nil - var _optionalImportEnum: ProtobufUnittestImport_ImportEnumLite? = nil - var _optionalStringPiece: String? = nil - var _optionalCord: String? = nil - var _optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessageLite? = nil - var _optionalLazyMessage: ProtobufUnittest_TestAllTypesLite.NestedMessage? = nil - var _repeatedInt32: [Int32] = [] - var _repeatedInt64: [Int64] = [] - var _repeatedUint32: [UInt32] = [] - var _repeatedUint64: [UInt64] = [] - var _repeatedSint32: [Int32] = [] - var _repeatedSint64: [Int64] = [] - var _repeatedFixed32: [UInt32] = [] - var _repeatedFixed64: [UInt64] = [] - var _repeatedSfixed32: [Int32] = [] - var _repeatedSfixed64: [Int64] = [] - var _repeatedFloat: [Float] = [] - var _repeatedDouble: [Double] = [] - var _repeatedBool: [Bool] = [] - var _repeatedString: [String] = [] - var _repeatedBytes: [Data] = [] - var _repeatedGroup: [ProtobufUnittest_TestAllTypesLite.RepeatedGroup] = [] - var _repeatedNestedMessage: [ProtobufUnittest_TestAllTypesLite.NestedMessage] = [] - var _repeatedForeignMessage: [ProtobufUnittest_ForeignMessageLite] = [] - var _repeatedImportMessage: [ProtobufUnittestImport_ImportMessageLite] = [] - var _repeatedNestedEnum: [ProtobufUnittest_TestAllTypesLite.NestedEnum] = [] - var _repeatedForeignEnum: [ProtobufUnittest_ForeignEnumLite] = [] - var _repeatedImportEnum: [ProtobufUnittestImport_ImportEnumLite] = [] - var _repeatedStringPiece: [String] = [] - var _repeatedCord: [String] = [] - var _repeatedLazyMessage: [ProtobufUnittest_TestAllTypesLite.NestedMessage] = [] - var _defaultInt32: Int32? = nil - var _defaultInt64: Int64? = nil - var _defaultUint32: UInt32? = nil - var _defaultUint64: UInt64? = nil - var _defaultSint32: Int32? = nil - var _defaultSint64: Int64? = nil - var _defaultFixed32: UInt32? = nil - var _defaultFixed64: UInt64? = nil - var _defaultSfixed32: Int32? = nil - var _defaultSfixed64: Int64? = nil - var _defaultFloat: Float? = nil - var _defaultDouble: Double? = nil - var _defaultBool: Bool? = nil - var _defaultString: String? = nil - var _defaultBytes: Data? = nil - var _defaultNestedEnum: ProtobufUnittest_TestAllTypesLite.NestedEnum? = nil - var _defaultForeignEnum: ProtobufUnittest_ForeignEnumLite? = nil - var _defaultImportEnum: ProtobufUnittestImport_ImportEnumLite? = nil - var _defaultStringPiece: String? = nil - var _defaultCord: String? = nil - var _oneofField: ProtobufUnittest_TestAllTypesLite.OneOf_OneofField? - var _deceptivelyNamedList: Int32? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _optionalInt32 = source._optionalInt32 - _optionalInt64 = source._optionalInt64 - _optionalUint32 = source._optionalUint32 - _optionalUint64 = source._optionalUint64 - _optionalSint32 = source._optionalSint32 - _optionalSint64 = source._optionalSint64 - _optionalFixed32 = source._optionalFixed32 - _optionalFixed64 = source._optionalFixed64 - _optionalSfixed32 = source._optionalSfixed32 - _optionalSfixed64 = source._optionalSfixed64 - _optionalFloat = source._optionalFloat - _optionalDouble = source._optionalDouble - _optionalBool = source._optionalBool - _optionalString = source._optionalString - _optionalBytes = source._optionalBytes - _optionalGroup = source._optionalGroup - _optionalNestedMessage = source._optionalNestedMessage - _optionalForeignMessage = source._optionalForeignMessage - _optionalImportMessage = source._optionalImportMessage - _optionalNestedEnum = source._optionalNestedEnum - _optionalForeignEnum = source._optionalForeignEnum - _optionalImportEnum = source._optionalImportEnum - _optionalStringPiece = source._optionalStringPiece - _optionalCord = source._optionalCord - _optionalPublicImportMessage = source._optionalPublicImportMessage - _optionalLazyMessage = source._optionalLazyMessage - _repeatedInt32 = source._repeatedInt32 - _repeatedInt64 = source._repeatedInt64 - _repeatedUint32 = source._repeatedUint32 - _repeatedUint64 = source._repeatedUint64 - _repeatedSint32 = source._repeatedSint32 - _repeatedSint64 = source._repeatedSint64 - _repeatedFixed32 = source._repeatedFixed32 - _repeatedFixed64 = source._repeatedFixed64 - _repeatedSfixed32 = source._repeatedSfixed32 - _repeatedSfixed64 = source._repeatedSfixed64 - _repeatedFloat = source._repeatedFloat - _repeatedDouble = source._repeatedDouble - _repeatedBool = source._repeatedBool - _repeatedString = source._repeatedString - _repeatedBytes = source._repeatedBytes - _repeatedGroup = source._repeatedGroup - _repeatedNestedMessage = source._repeatedNestedMessage - _repeatedForeignMessage = source._repeatedForeignMessage - _repeatedImportMessage = source._repeatedImportMessage - _repeatedNestedEnum = source._repeatedNestedEnum - _repeatedForeignEnum = source._repeatedForeignEnum - _repeatedImportEnum = source._repeatedImportEnum - _repeatedStringPiece = source._repeatedStringPiece - _repeatedCord = source._repeatedCord - _repeatedLazyMessage = source._repeatedLazyMessage - _defaultInt32 = source._defaultInt32 - _defaultInt64 = source._defaultInt64 - _defaultUint32 = source._defaultUint32 - _defaultUint64 = source._defaultUint64 - _defaultSint32 = source._defaultSint32 - _defaultSint64 = source._defaultSint64 - _defaultFixed32 = source._defaultFixed32 - _defaultFixed64 = source._defaultFixed64 - _defaultSfixed32 = source._defaultSfixed32 - _defaultSfixed64 = source._defaultSfixed64 - _defaultFloat = source._defaultFloat - _defaultDouble = source._defaultDouble - _defaultBool = source._defaultBool - _defaultString = source._defaultString - _defaultBytes = source._defaultBytes - _defaultNestedEnum = source._defaultNestedEnum - _defaultForeignEnum = source._defaultForeignEnum - _defaultImportEnum = source._defaultImportEnum - _defaultStringPiece = source._defaultStringPiece - _defaultCord = source._defaultCord - _oneofField = source._oneofField - _deceptivelyNamedList = source._deceptivelyNamedList - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._optionalInt32) }() - case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() - case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() - case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() - case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() - case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() - case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() - case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() - case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() - case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() - case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() - case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() - case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() - case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() - case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() - case 16: try { try decoder.decodeSingularGroupField(value: &_storage._optionalGroup) }() - case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() - case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() - case 20: try { try decoder.decodeSingularMessageField(value: &_storage._optionalImportMessage) }() - case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() - case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() - case 23: try { try decoder.decodeSingularEnumField(value: &_storage._optionalImportEnum) }() - case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() - case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() - case 26: try { try decoder.decodeSingularMessageField(value: &_storage._optionalPublicImportMessage) }() - case 27: try { try decoder.decodeSingularMessageField(value: &_storage._optionalLazyMessage) }() - case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() - case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() - case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() - case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() - case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() - case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() - case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() - case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() - case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() - case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() - case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() - case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() - case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() - case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() - case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() - case 46: try { try decoder.decodeRepeatedGroupField(value: &_storage._repeatedGroup) }() - case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() - case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() - case 50: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedImportMessage) }() - case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() - case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() - case 53: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedImportEnum) }() - case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() - case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() - case 57: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedLazyMessage) }() - case 61: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() - case 62: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() - case 63: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() - case 64: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() - case 65: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() - case 66: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() - case 67: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() - case 68: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() - case 69: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() - case 70: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() - case 71: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() - case 72: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() - case 73: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() - case 74: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() - case 75: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() - case 81: try { try decoder.decodeSingularEnumField(value: &_storage._defaultNestedEnum) }() - case 82: try { try decoder.decodeSingularEnumField(value: &_storage._defaultForeignEnum) }() - case 83: try { try decoder.decodeSingularEnumField(value: &_storage._defaultImportEnum) }() - case 84: try { try decoder.decodeSingularStringField(value: &_storage._defaultStringPiece) }() - case 85: try { try decoder.decodeSingularStringField(value: &_storage._defaultCord) }() - case 111: try { - var v: UInt32? - try decoder.decodeSingularUInt32Field(value: &v) - if let v = v { - if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofUint32(v) - } - }() - case 112: try { - var v: ProtobufUnittest_TestAllTypesLite.NestedMessage? - var hadOneofValue = false - if let current = _storage._oneofField { - hadOneofValue = true - if case .oneofNestedMessage(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofNestedMessage(v) - } - }() - case 113: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofString(v) - } - }() - case 114: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofBytes(v) - } - }() - case 115: try { - var v: ProtobufUnittest_TestAllTypesLite.NestedMessage? - var hadOneofValue = false - if let current = _storage._oneofField { - hadOneofValue = true - if case .oneofLazyNestedMessage(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofLazyNestedMessage(v) - } - }() - case 116: try { try decoder.decodeSingularInt32Field(value: &_storage._deceptivelyNamedList) }() - case 117: try { - var v: ProtobufUnittest_TestAllTypesLite.NestedMessage2? - var hadOneofValue = false - if let current = _storage._oneofField { - hadOneofValue = true - if case .oneofNestedMessage2(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofNestedMessage2(v) - } - }() - default: break - } - } - } - } - - func traverse(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._optionalInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._optionalInt64 { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) - } }() - try { if let v = _storage._optionalUint32 { - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) - } }() - try { if let v = _storage._optionalUint64 { - try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) - } }() - try { if let v = _storage._optionalSint32 { - try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) - } }() - try { if let v = _storage._optionalSint64 { - try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) - } }() - try { if let v = _storage._optionalFixed32 { - try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) - } }() - try { if let v = _storage._optionalFixed64 { - try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) - } }() - try { if let v = _storage._optionalSfixed32 { - try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) - } }() - try { if let v = _storage._optionalSfixed64 { - try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) - } }() - try { if let v = _storage._optionalFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 11) - } }() - try { if let v = _storage._optionalDouble { - try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) - } }() - try { if let v = _storage._optionalBool { - try visitor.visitSingularBoolField(value: v, fieldNumber: 13) - } }() - try { if let v = _storage._optionalString { - try visitor.visitSingularStringField(value: v, fieldNumber: 14) - } }() - try { if let v = _storage._optionalBytes { - try visitor.visitSingularBytesField(value: v, fieldNumber: 15) - } }() - try { if let v = _storage._optionalGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 16) - } }() - try { if let v = _storage._optionalNestedMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 18) - } }() - try { if let v = _storage._optionalForeignMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 19) - } }() - try { if let v = _storage._optionalImportMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 20) - } }() - try { if let v = _storage._optionalNestedEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 21) - } }() - try { if let v = _storage._optionalForeignEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 22) - } }() - try { if let v = _storage._optionalImportEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 23) - } }() - try { if let v = _storage._optionalStringPiece { - try visitor.visitSingularStringField(value: v, fieldNumber: 24) - } }() - try { if let v = _storage._optionalCord { - try visitor.visitSingularStringField(value: v, fieldNumber: 25) - } }() - try { if let v = _storage._optionalPublicImportMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 26) - } }() - try { if let v = _storage._optionalLazyMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 27) - } }() - if !_storage._repeatedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) - } - if !_storage._repeatedInt64.isEmpty { - try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) - } - if !_storage._repeatedUint32.isEmpty { - try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) - } - if !_storage._repeatedUint64.isEmpty { - try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) - } - if !_storage._repeatedSint32.isEmpty { - try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) - } - if !_storage._repeatedSint64.isEmpty { - try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) - } - if !_storage._repeatedFixed32.isEmpty { - try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) - } - if !_storage._repeatedFixed64.isEmpty { - try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) - } - if !_storage._repeatedSfixed32.isEmpty { - try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) - } - if !_storage._repeatedSfixed64.isEmpty { - try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) - } - if !_storage._repeatedFloat.isEmpty { - try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) - } - if !_storage._repeatedDouble.isEmpty { - try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) - } - if !_storage._repeatedBool.isEmpty { - try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43) - } - if !_storage._repeatedString.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) - } - if !_storage._repeatedBytes.isEmpty { - try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) - } - if !_storage._repeatedGroup.isEmpty { - try visitor.visitRepeatedGroupField(value: _storage._repeatedGroup, fieldNumber: 46) - } - if !_storage._repeatedNestedMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) - } - if !_storage._repeatedForeignMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) - } - if !_storage._repeatedImportMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedImportMessage, fieldNumber: 50) - } - if !_storage._repeatedNestedEnum.isEmpty { - try visitor.visitRepeatedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) - } - if !_storage._repeatedForeignEnum.isEmpty { - try visitor.visitRepeatedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) - } - if !_storage._repeatedImportEnum.isEmpty { - try visitor.visitRepeatedEnumField(value: _storage._repeatedImportEnum, fieldNumber: 53) - } - if !_storage._repeatedStringPiece.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) - } - if !_storage._repeatedCord.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) - } - if !_storage._repeatedLazyMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedLazyMessage, fieldNumber: 57) - } - try { if let v = _storage._defaultInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 61) - } }() - try { if let v = _storage._defaultInt64 { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 62) - } }() - try { if let v = _storage._defaultUint32 { - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63) - } }() - try { if let v = _storage._defaultUint64 { - try visitor.visitSingularUInt64Field(value: v, fieldNumber: 64) - } }() - try { if let v = _storage._defaultSint32 { - try visitor.visitSingularSInt32Field(value: v, fieldNumber: 65) - } }() - try { if let v = _storage._defaultSint64 { - try visitor.visitSingularSInt64Field(value: v, fieldNumber: 66) - } }() - try { if let v = _storage._defaultFixed32 { - try visitor.visitSingularFixed32Field(value: v, fieldNumber: 67) - } }() - try { if let v = _storage._defaultFixed64 { - try visitor.visitSingularFixed64Field(value: v, fieldNumber: 68) - } }() - try { if let v = _storage._defaultSfixed32 { - try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 69) - } }() - try { if let v = _storage._defaultSfixed64 { - try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 70) - } }() - try { if let v = _storage._defaultFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 71) - } }() - try { if let v = _storage._defaultDouble { - try visitor.visitSingularDoubleField(value: v, fieldNumber: 72) - } }() - try { if let v = _storage._defaultBool { - try visitor.visitSingularBoolField(value: v, fieldNumber: 73) - } }() - try { if let v = _storage._defaultString { - try visitor.visitSingularStringField(value: v, fieldNumber: 74) - } }() - try { if let v = _storage._defaultBytes { - try visitor.visitSingularBytesField(value: v, fieldNumber: 75) - } }() - try { if let v = _storage._defaultNestedEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 81) - } }() - try { if let v = _storage._defaultForeignEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 82) - } }() - try { if let v = _storage._defaultImportEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 83) - } }() - try { if let v = _storage._defaultStringPiece { - try visitor.visitSingularStringField(value: v, fieldNumber: 84) - } }() - try { if let v = _storage._defaultCord { - try visitor.visitSingularStringField(value: v, fieldNumber: 85) - } }() - switch _storage._oneofField { - case .oneofUint32?: try { - guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) - }() - case .oneofNestedMessage?: try { - guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 112) - }() - case .oneofString?: try { - guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 113) - }() - case .oneofBytes?: try { - guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 114) - }() - case .oneofLazyNestedMessage?: try { - guard case .oneofLazyNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 115) - }() - default: break - } - try { if let v = _storage._deceptivelyNamedList { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 116) - } }() - try { if case .oneofNestedMessage2(let v)? = _storage._oneofField { - try visitor.visitSingularMessageField(value: v, fieldNumber: 117) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllTypesLite, rhs: ProtobufUnittest_TestAllTypesLite) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} - if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} - if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} - if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} - if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} - if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} - if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} - if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} - if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} - if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} - if _storage._optionalFloat != rhs_storage._optionalFloat {return false} - if _storage._optionalDouble != rhs_storage._optionalDouble {return false} - if _storage._optionalBool != rhs_storage._optionalBool {return false} - if _storage._optionalString != rhs_storage._optionalString {return false} - if _storage._optionalBytes != rhs_storage._optionalBytes {return false} - if _storage._optionalGroup != rhs_storage._optionalGroup {return false} - if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} - if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} - if _storage._optionalImportMessage != rhs_storage._optionalImportMessage {return false} - if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} - if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} - if _storage._optionalImportEnum != rhs_storage._optionalImportEnum {return false} - if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} - if _storage._optionalCord != rhs_storage._optionalCord {return false} - if _storage._optionalPublicImportMessage != rhs_storage._optionalPublicImportMessage {return false} - if _storage._optionalLazyMessage != rhs_storage._optionalLazyMessage {return false} - if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} - if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} - if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} - if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} - if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} - if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} - if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} - if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} - if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} - if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} - if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} - if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} - if _storage._repeatedBool != rhs_storage._repeatedBool {return false} - if _storage._repeatedString != rhs_storage._repeatedString {return false} - if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} - if _storage._repeatedGroup != rhs_storage._repeatedGroup {return false} - if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} - if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} - if _storage._repeatedImportMessage != rhs_storage._repeatedImportMessage {return false} - if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} - if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} - if _storage._repeatedImportEnum != rhs_storage._repeatedImportEnum {return false} - if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} - if _storage._repeatedCord != rhs_storage._repeatedCord {return false} - if _storage._repeatedLazyMessage != rhs_storage._repeatedLazyMessage {return false} - if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} - if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} - if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} - if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} - if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} - if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} - if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} - if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} - if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} - if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} - if _storage._defaultFloat != rhs_storage._defaultFloat {return false} - if _storage._defaultDouble != rhs_storage._defaultDouble {return false} - if _storage._defaultBool != rhs_storage._defaultBool {return false} - if _storage._defaultString != rhs_storage._defaultString {return false} - if _storage._defaultBytes != rhs_storage._defaultBytes {return false} - if _storage._defaultNestedEnum != rhs_storage._defaultNestedEnum {return false} - if _storage._defaultForeignEnum != rhs_storage._defaultForeignEnum {return false} - if _storage._defaultImportEnum != rhs_storage._defaultImportEnum {return false} - if _storage._defaultStringPiece != rhs_storage._defaultStringPiece {return false} - if _storage._defaultCord != rhs_storage._defaultCord {return false} - if _storage._oneofField != rhs_storage._oneofField {return false} - if _storage._deceptivelyNamedList != rhs_storage._deceptivelyNamedList {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestAllTypesLite.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - 3: .same(proto: "BAZ"), - ] -} - -extension ProtobufUnittest_TestAllTypesLite.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestAllTypesLite.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - 2: .same(proto: "cc"), - ] - - 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._bb) }() - case 2: try { try decoder.decodeSingularInt64Field(value: &self._cc) }() - 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 - try { if let v = self._bb { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._cc { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllTypesLite.NestedMessage, rhs: ProtobufUnittest_TestAllTypesLite.NestedMessage) -> Bool { - if lhs._bb != rhs._bb {return false} - if lhs._cc != rhs._cc {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestAllTypesLite.NestedMessage2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestAllTypesLite.protoMessageName + ".NestedMessage2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "dd"), - ] - - 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._dd) }() - 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 - try { if let v = self._dd { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllTypesLite.NestedMessage2, rhs: ProtobufUnittest_TestAllTypesLite.NestedMessage2) -> Bool { - if lhs._dd != rhs._dd {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestAllTypesLite.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestAllTypesLite.protoMessageName + ".OptionalGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 17: .same(proto: "a"), - ] - - 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllTypesLite.OptionalGroup, rhs: ProtobufUnittest_TestAllTypesLite.OptionalGroup) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestAllTypesLite.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestAllTypesLite.protoMessageName + ".RepeatedGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 47: .same(proto: "a"), - ] - - 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 47: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllTypesLite.RepeatedGroup, rhs: ProtobufUnittest_TestAllTypesLite.RepeatedGroup) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_ForeignMessageLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ForeignMessageLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - ] - - 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._c) }() - 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 - try { if let v = self._c { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_ForeignMessageLite, rhs: ProtobufUnittest_ForeignMessageLite) -> Bool { - if lhs._c != rhs._c {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestPackedTypesLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestPackedTypesLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 90: .standard(proto: "packed_int32"), - 91: .standard(proto: "packed_int64"), - 92: .standard(proto: "packed_uint32"), - 93: .standard(proto: "packed_uint64"), - 94: .standard(proto: "packed_sint32"), - 95: .standard(proto: "packed_sint64"), - 96: .standard(proto: "packed_fixed32"), - 97: .standard(proto: "packed_fixed64"), - 98: .standard(proto: "packed_sfixed32"), - 99: .standard(proto: "packed_sfixed64"), - 100: .standard(proto: "packed_float"), - 101: .standard(proto: "packed_double"), - 102: .standard(proto: "packed_bool"), - 103: .standard(proto: "packed_enum"), - ] - - 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 90: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32) }() - case 91: try { try decoder.decodeRepeatedInt64Field(value: &self.packedInt64) }() - case 92: try { try decoder.decodeRepeatedUInt32Field(value: &self.packedUint32) }() - case 93: try { try decoder.decodeRepeatedUInt64Field(value: &self.packedUint64) }() - case 94: try { try decoder.decodeRepeatedSInt32Field(value: &self.packedSint32) }() - case 95: try { try decoder.decodeRepeatedSInt64Field(value: &self.packedSint64) }() - case 96: try { try decoder.decodeRepeatedFixed32Field(value: &self.packedFixed32) }() - case 97: try { try decoder.decodeRepeatedFixed64Field(value: &self.packedFixed64) }() - case 98: try { try decoder.decodeRepeatedSFixed32Field(value: &self.packedSfixed32) }() - case 99: try { try decoder.decodeRepeatedSFixed64Field(value: &self.packedSfixed64) }() - case 100: try { try decoder.decodeRepeatedFloatField(value: &self.packedFloat) }() - case 101: try { try decoder.decodeRepeatedDoubleField(value: &self.packedDouble) }() - case 102: try { try decoder.decodeRepeatedBoolField(value: &self.packedBool) }() - case 103: try { try decoder.decodeRepeatedEnumField(value: &self.packedEnum) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.packedInt32.isEmpty { - try visitor.visitPackedInt32Field(value: self.packedInt32, fieldNumber: 90) - } - if !self.packedInt64.isEmpty { - try visitor.visitPackedInt64Field(value: self.packedInt64, fieldNumber: 91) - } - if !self.packedUint32.isEmpty { - try visitor.visitPackedUInt32Field(value: self.packedUint32, fieldNumber: 92) - } - if !self.packedUint64.isEmpty { - try visitor.visitPackedUInt64Field(value: self.packedUint64, fieldNumber: 93) - } - if !self.packedSint32.isEmpty { - try visitor.visitPackedSInt32Field(value: self.packedSint32, fieldNumber: 94) - } - if !self.packedSint64.isEmpty { - try visitor.visitPackedSInt64Field(value: self.packedSint64, fieldNumber: 95) - } - if !self.packedFixed32.isEmpty { - try visitor.visitPackedFixed32Field(value: self.packedFixed32, fieldNumber: 96) - } - if !self.packedFixed64.isEmpty { - try visitor.visitPackedFixed64Field(value: self.packedFixed64, fieldNumber: 97) - } - if !self.packedSfixed32.isEmpty { - try visitor.visitPackedSFixed32Field(value: self.packedSfixed32, fieldNumber: 98) - } - if !self.packedSfixed64.isEmpty { - try visitor.visitPackedSFixed64Field(value: self.packedSfixed64, fieldNumber: 99) - } - if !self.packedFloat.isEmpty { - try visitor.visitPackedFloatField(value: self.packedFloat, fieldNumber: 100) - } - if !self.packedDouble.isEmpty { - try visitor.visitPackedDoubleField(value: self.packedDouble, fieldNumber: 101) - } - if !self.packedBool.isEmpty { - try visitor.visitPackedBoolField(value: self.packedBool, fieldNumber: 102) - } - if !self.packedEnum.isEmpty { - try visitor.visitPackedEnumField(value: self.packedEnum, fieldNumber: 103) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestPackedTypesLite, rhs: ProtobufUnittest_TestPackedTypesLite) -> Bool { - if lhs.packedInt32 != rhs.packedInt32 {return false} - if lhs.packedInt64 != rhs.packedInt64 {return false} - if lhs.packedUint32 != rhs.packedUint32 {return false} - if lhs.packedUint64 != rhs.packedUint64 {return false} - if lhs.packedSint32 != rhs.packedSint32 {return false} - if lhs.packedSint64 != rhs.packedSint64 {return false} - if lhs.packedFixed32 != rhs.packedFixed32 {return false} - if lhs.packedFixed64 != rhs.packedFixed64 {return false} - if lhs.packedSfixed32 != rhs.packedSfixed32 {return false} - if lhs.packedSfixed64 != rhs.packedSfixed64 {return false} - if lhs.packedFloat != rhs.packedFloat {return false} - if lhs.packedDouble != rhs.packedDouble {return false} - if lhs.packedBool != rhs.packedBool {return false} - if lhs.packedEnum != rhs.packedEnum {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestAllExtensionsLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestAllExtensionsLite" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestAllExtensionsLite.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllExtensionsLite, rhs: ProtobufUnittest_TestAllExtensionsLite) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_OptionalGroup_extension_lite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".OptionalGroup_extension_lite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 17: .same(proto: "a"), - ] - - 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_OptionalGroup_extension_lite, rhs: ProtobufUnittest_OptionalGroup_extension_lite) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_RepeatedGroup_extension_lite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".RepeatedGroup_extension_lite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 47: .same(proto: "a"), - ] - - 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 47: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_RepeatedGroup_extension_lite, rhs: ProtobufUnittest_RepeatedGroup_extension_lite) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestPackedExtensionsLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestPackedExtensionsLite" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestPackedExtensionsLite.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestPackedExtensionsLite, rhs: ProtobufUnittest_TestPackedExtensionsLite) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestNestedExtensionLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestNestedExtensionLite" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestNestedExtensionLite, rhs: ProtobufUnittest_TestNestedExtensionLite) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestDeprecatedLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestDeprecatedLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "deprecated_field"), - 2: .standard(proto: "deprecated_field2"), - 3: .standard(proto: "deprecated_field3"), - 4: .standard(proto: "deprecated_field4"), - ] - - fileprivate class _StorageClass { - var _deprecatedField: Int32? = nil - var _deprecatedField2: Int32? = nil - var _deprecatedField3: String? = nil - var _deprecatedField4: ProtobufUnittest_TestDeprecatedLite? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _deprecatedField = source._deprecatedField - _deprecatedField2 = source._deprecatedField2 - _deprecatedField3 = source._deprecatedField3 - _deprecatedField4 = source._deprecatedField4 - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - public var isInitialized: Bool { - return withExtendedLifetime(_storage) { (_storage: _StorageClass) in - if _storage._deprecatedField2 == nil {return false} - if let v = _storage._deprecatedField4, !v.isInitialized {return false} - return true - } - } - - mutating func decodeMessage(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._deprecatedField) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._deprecatedField2) }() - case 3: try { try decoder.decodeSingularStringField(value: &_storage._deprecatedField3) }() - case 4: try { try decoder.decodeSingularMessageField(value: &_storage._deprecatedField4) }() - default: break - } - } - } - } - - func traverse(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._deprecatedField { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._deprecatedField2 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try { if let v = _storage._deprecatedField3 { - try visitor.visitSingularStringField(value: v, fieldNumber: 3) - } }() - try { if let v = _storage._deprecatedField4 { - try visitor.visitSingularMessageField(value: v, fieldNumber: 4) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestDeprecatedLite, rhs: ProtobufUnittest_TestDeprecatedLite) -> 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._deprecatedField != rhs_storage._deprecatedField {return false} - if _storage._deprecatedField2 != rhs_storage._deprecatedField2 {return false} - if _storage._deprecatedField3 != rhs_storage._deprecatedField3 {return false} - if _storage._deprecatedField4 != rhs_storage._deprecatedField4 {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestParsingMergeLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestParsingMergeLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "required_all_types"), - 2: .standard(proto: "optional_all_types"), - 3: .standard(proto: "repeated_all_types"), - 10: .unique(proto: "OptionalGroup", json: "optionalgroup"), - 20: .unique(proto: "RepeatedGroup", json: "repeatedgroup"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - if self._requiredAllTypes == nil {return false} - return true - } - - 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.decodeSingularMessageField(value: &self._requiredAllTypes) }() - case 2: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() - case 3: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() - case 10: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() - case 20: try { try decoder.decodeRepeatedGroupField(value: &self.repeatedGroup) }() - case 1000..<536870912: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestParsingMergeLite.self, fieldNumber: fieldNumber) }() - 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 - try { if let v = self._requiredAllTypes { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = self._optionalAllTypes { - try visitor.visitSingularMessageField(value: v, fieldNumber: 2) - } }() - if !self.repeatedAllTypes.isEmpty { - try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 3) - } - try { if let v = self._optionalGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 10) - } }() - if !self.repeatedGroup.isEmpty { - try visitor.visitRepeatedGroupField(value: self.repeatedGroup, fieldNumber: 20) - } - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestParsingMergeLite, rhs: ProtobufUnittest_TestParsingMergeLite) -> Bool { - if lhs._requiredAllTypes != rhs._requiredAllTypes {return false} - if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} - if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} - if lhs._optionalGroup != rhs._optionalGroup {return false} - if lhs.repeatedGroup != rhs.repeatedGroup {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMergeLite.protoMessageName + ".RepeatedFieldsGenerator" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "field1"), - 2: .same(proto: "field2"), - 3: .same(proto: "field3"), - 10: .unique(proto: "Group1", json: "group1"), - 20: .unique(proto: "Group2", json: "group2"), - 1000: .same(proto: "ext1"), - 1001: .same(proto: "ext2"), - ] - - 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.decodeRepeatedMessageField(value: &self.field1) }() - case 2: try { try decoder.decodeRepeatedMessageField(value: &self.field2) }() - case 3: try { try decoder.decodeRepeatedMessageField(value: &self.field3) }() - case 10: try { try decoder.decodeRepeatedGroupField(value: &self.group1) }() - case 20: try { try decoder.decodeRepeatedGroupField(value: &self.group2) }() - case 1000: try { try decoder.decodeRepeatedMessageField(value: &self.ext1) }() - case 1001: try { try decoder.decodeRepeatedMessageField(value: &self.ext2) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.field1.isEmpty { - try visitor.visitRepeatedMessageField(value: self.field1, fieldNumber: 1) - } - if !self.field2.isEmpty { - try visitor.visitRepeatedMessageField(value: self.field2, fieldNumber: 2) - } - if !self.field3.isEmpty { - try visitor.visitRepeatedMessageField(value: self.field3, fieldNumber: 3) - } - if !self.group1.isEmpty { - try visitor.visitRepeatedGroupField(value: self.group1, fieldNumber: 10) - } - if !self.group2.isEmpty { - try visitor.visitRepeatedGroupField(value: self.group2, fieldNumber: 20) - } - if !self.ext1.isEmpty { - try visitor.visitRepeatedMessageField(value: self.ext1, fieldNumber: 1000) - } - if !self.ext2.isEmpty { - try visitor.visitRepeatedMessageField(value: self.ext2, fieldNumber: 1001) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator, rhs: ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator) -> Bool { - if lhs.field1 != rhs.field1 {return false} - if lhs.field2 != rhs.field2 {return false} - if lhs.field3 != rhs.field3 {return false} - if lhs.group1 != rhs.group1 {return false} - if lhs.group2 != rhs.group2 {return false} - if lhs.ext1 != rhs.ext1 {return false} - if lhs.ext2 != rhs.ext2 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.protoMessageName + ".Group1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 11: .same(proto: "field1"), - ] - - 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 11: try { try decoder.decodeSingularMessageField(value: &self._field1) }() - 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 - try { if let v = self._field1 { - try visitor.visitSingularMessageField(value: v, fieldNumber: 11) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group1, rhs: ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group1) -> Bool { - if lhs._field1 != rhs._field1 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.protoMessageName + ".Group2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 21: .same(proto: "field1"), - ] - - 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 21: try { try decoder.decodeSingularMessageField(value: &self._field1) }() - 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 - try { if let v = self._field1 { - try visitor.visitSingularMessageField(value: v, fieldNumber: 21) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group2, rhs: ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group2) -> Bool { - if lhs._field1 != rhs._field1 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestParsingMergeLite.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMergeLite.protoMessageName + ".OptionalGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 11: .standard(proto: "optional_group_all_types"), - ] - - 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 11: try { try decoder.decodeSingularMessageField(value: &self._optionalGroupAllTypes) }() - 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 - try { if let v = self._optionalGroupAllTypes { - try visitor.visitSingularMessageField(value: v, fieldNumber: 11) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestParsingMergeLite.OptionalGroup, rhs: ProtobufUnittest_TestParsingMergeLite.OptionalGroup) -> Bool { - if lhs._optionalGroupAllTypes != rhs._optionalGroupAllTypes {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestParsingMergeLite.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMergeLite.protoMessageName + ".RepeatedGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 21: .standard(proto: "repeated_group_all_types"), - ] - - 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 21: try { try decoder.decodeSingularMessageField(value: &self._repeatedGroupAllTypes) }() - 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 - try { if let v = self._repeatedGroupAllTypes { - try visitor.visitSingularMessageField(value: v, fieldNumber: 21) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestParsingMergeLite.RepeatedGroup, rhs: ProtobufUnittest_TestParsingMergeLite.RepeatedGroup) -> Bool { - if lhs._repeatedGroupAllTypes != rhs._repeatedGroupAllTypes {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestEmptyMessageLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestEmptyMessageLite" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestEmptyMessageLite, rhs: ProtobufUnittest_TestEmptyMessageLite) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestEmptyMessageWithExtensionsLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestEmptyMessageWithExtensionsLite" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestEmptyMessageWithExtensionsLite.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestEmptyMessageWithExtensionsLite, rhs: ProtobufUnittest_TestEmptyMessageWithExtensionsLite) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_V1MessageLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".V1MessageLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "int_field"), - 2: .standard(proto: "enum_field"), - ] - - public var isInitialized: Bool { - if self._intField == nil {return false} - return true - } - - 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._intField) }() - case 2: try { try decoder.decodeSingularEnumField(value: &self._enumField) }() - 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 - try { if let v = self._intField { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._enumField { - try visitor.visitSingularEnumField(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_V1MessageLite, rhs: ProtobufUnittest_V1MessageLite) -> Bool { - if lhs._intField != rhs._intField {return false} - if lhs._enumField != rhs._enumField {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_V2MessageLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".V2MessageLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "int_field"), - 2: .standard(proto: "enum_field"), - ] - - public var isInitialized: Bool { - if self._intField == nil {return false} - return true - } - - 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._intField) }() - case 2: try { try decoder.decodeSingularEnumField(value: &self._enumField) }() - 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 - try { if let v = self._intField { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._enumField { - try visitor.visitSingularEnumField(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_V2MessageLite, rhs: ProtobufUnittest_V2MessageLite) -> Bool { - if lhs._intField != rhs._intField {return false} - if lhs._enumField != rhs._enumField {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestHugeFieldNumbersLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestHugeFieldNumbersLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 536870000: .standard(proto: "optional_int32"), - 536870001: .standard(proto: "fixed_32"), - 536870002: .standard(proto: "repeated_int32"), - 536870003: .standard(proto: "packed_int32"), - 536870004: .standard(proto: "optional_enum"), - 536870005: .standard(proto: "optional_string"), - 536870006: .standard(proto: "optional_bytes"), - 536870007: .standard(proto: "optional_message"), - 536870008: .unique(proto: "OptionalGroup", json: "optionalgroup"), - 536870010: .standard(proto: "string_string_map"), - 536870011: .standard(proto: "oneof_uint32"), - 536870012: .standard(proto: "oneof_test_all_types"), - 536870013: .standard(proto: "oneof_string"), - 536870014: .standard(proto: "oneof_bytes"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - 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 536870000: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32) }() - case 536870001: try { try decoder.decodeSingularInt32Field(value: &self._fixed32) }() - case 536870002: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() - case 536870003: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32) }() - case 536870004: try { try decoder.decodeSingularEnumField(value: &self._optionalEnum) }() - case 536870005: try { try decoder.decodeSingularStringField(value: &self._optionalString) }() - case 536870006: try { try decoder.decodeSingularBytesField(value: &self._optionalBytes) }() - case 536870007: try { try decoder.decodeSingularMessageField(value: &self._optionalMessage) }() - case 536870008: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() - case 536870010: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.stringStringMap) }() - case 536870011: try { - var v: UInt32? - try decoder.decodeSingularUInt32Field(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofUint32(v) - } - }() - case 536870012: try { - var v: ProtobufUnittest_TestAllTypesLite? - var hadOneofValue = false - if let current = self.oneofField { - hadOneofValue = true - if case .oneofTestAllTypes(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofTestAllTypes(v) - } - }() - case 536870013: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofString(v) - } - }() - case 536870014: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofBytes(v) - } - }() - case 536860000..<536870000: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestHugeFieldNumbersLite.self, fieldNumber: fieldNumber) }() - 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 - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 536860000, end: 536870000) - try { if let v = self._optionalInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870000) - } }() - try { if let v = self._fixed32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870001) - } }() - if !self.repeatedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 536870002) - } - if !self.packedInt32.isEmpty { - try visitor.visitPackedInt32Field(value: self.packedInt32, fieldNumber: 536870003) - } - try { if let v = self._optionalEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 536870004) - } }() - try { if let v = self._optionalString { - try visitor.visitSingularStringField(value: v, fieldNumber: 536870005) - } }() - try { if let v = self._optionalBytes { - try visitor.visitSingularBytesField(value: v, fieldNumber: 536870006) - } }() - try { if let v = self._optionalMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 536870007) - } }() - try { if let v = self._optionalGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 536870008) - } }() - if !self.stringStringMap.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.stringStringMap, fieldNumber: 536870010) - } - switch self.oneofField { - case .oneofUint32?: try { - guard case .oneofUint32(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 536870011) - }() - case .oneofTestAllTypes?: try { - guard case .oneofTestAllTypes(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 536870012) - }() - case .oneofString?: try { - guard case .oneofString(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 536870013) - }() - case .oneofBytes?: try { - guard case .oneofBytes(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 536870014) - }() - case nil: break - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestHugeFieldNumbersLite, rhs: ProtobufUnittest_TestHugeFieldNumbersLite) -> Bool { - if lhs._optionalInt32 != rhs._optionalInt32 {return false} - if lhs._fixed32 != rhs._fixed32 {return false} - if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} - if lhs.packedInt32 != rhs.packedInt32 {return false} - if lhs._optionalEnum != rhs._optionalEnum {return false} - if lhs._optionalString != rhs._optionalString {return false} - if lhs._optionalBytes != rhs._optionalBytes {return false} - if lhs._optionalMessage != rhs._optionalMessage {return false} - if lhs._optionalGroup != rhs._optionalGroup {return false} - if lhs.stringStringMap != rhs.stringStringMap {return false} - if lhs.oneofField != rhs.oneofField {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestHugeFieldNumbersLite.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestHugeFieldNumbersLite.protoMessageName + ".OptionalGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 536870009: .standard(proto: "group_a"), - ] - - 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 536870009: try { try decoder.decodeSingularInt32Field(value: &self._groupA) }() - 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 - try { if let v = self._groupA { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870009) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestHugeFieldNumbersLite.OptionalGroup, rhs: ProtobufUnittest_TestHugeFieldNumbersLite.OptionalGroup) -> Bool { - if lhs._groupA != rhs._groupA {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestOneofParsingLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestOneofParsingLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "oneof_int32"), - 2: .standard(proto: "oneof_submessage"), - 3: .standard(proto: "oneof_string"), - 4: .standard(proto: "oneof_bytes"), - 5: .standard(proto: "oneof_string_cord"), - 6: .standard(proto: "oneof_bytes_cord"), - 7: .standard(proto: "oneof_string_string_piece"), - 8: .standard(proto: "oneof_bytes_string_piece"), - 9: .standard(proto: "oneof_enum"), - ] - - 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: Int32? - try decoder.decodeSingularInt32Field(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofInt32(v) - } - }() - case 2: try { - var v: ProtobufUnittest_TestAllTypesLite? - var hadOneofValue = false - if let current = self.oneofField { - hadOneofValue = true - if case .oneofSubmessage(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofSubmessage(v) - } - }() - case 3: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofString(v) - } - }() - case 4: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofBytes(v) - } - }() - case 5: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofStringCord(v) - } - }() - case 6: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofBytesCord(v) - } - }() - case 7: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofStringStringPiece(v) - } - }() - case 8: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofBytesStringPiece(v) - } - }() - case 9: try { - var v: ProtobufUnittest_V2EnumLite? - try decoder.decodeSingularEnumField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofEnum(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.oneofField { - case .oneofInt32?: try { - guard case .oneofInt32(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - }() - case .oneofSubmessage?: try { - guard case .oneofSubmessage(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 2) - }() - case .oneofString?: try { - guard case .oneofString(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 3) - }() - case .oneofBytes?: try { - guard case .oneofBytes(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 4) - }() - case .oneofStringCord?: try { - guard case .oneofStringCord(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 5) - }() - case .oneofBytesCord?: try { - guard case .oneofBytesCord(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 6) - }() - case .oneofStringStringPiece?: try { - guard case .oneofStringStringPiece(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 7) - }() - case .oneofBytesStringPiece?: try { - guard case .oneofBytesStringPiece(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 8) - }() - case .oneofEnum?: try { - guard case .oneofEnum(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularEnumField(value: v, fieldNumber: 9) - }() - case nil: break - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestOneofParsingLite, rhs: ProtobufUnittest_TestOneofParsingLite) -> Bool { - if lhs.oneofField != rhs.oneofField {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_PackedInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".PackedInt32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2048: .standard(proto: "repeated_int32"), - ] - - 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 2048: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.repeatedInt32.isEmpty { - try visitor.visitPackedInt32Field(value: self.repeatedInt32, fieldNumber: 2048) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_PackedInt32, rhs: ProtobufUnittest_PackedInt32) -> Bool { - if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_NonPackedInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".NonPackedInt32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2048: .standard(proto: "repeated_int32"), - ] - - 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 2048: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.repeatedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 2048) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_NonPackedInt32, rhs: ProtobufUnittest_NonPackedInt32) -> Bool { - if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_PackedFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".PackedFixed32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2048: .standard(proto: "repeated_fixed32"), - ] - - 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 2048: try { try decoder.decodeRepeatedFixed32Field(value: &self.repeatedFixed32) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.repeatedFixed32.isEmpty { - try visitor.visitPackedFixed32Field(value: self.repeatedFixed32, fieldNumber: 2048) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_PackedFixed32, rhs: ProtobufUnittest_PackedFixed32) -> Bool { - if lhs.repeatedFixed32 != rhs.repeatedFixed32 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_NonPackedFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".NonPackedFixed32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2048: .standard(proto: "repeated_fixed32"), - ] - - 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 2048: try { try decoder.decodeRepeatedFixed32Field(value: &self.repeatedFixed32) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.repeatedFixed32.isEmpty { - try visitor.visitRepeatedFixed32Field(value: self.repeatedFixed32, fieldNumber: 2048) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_NonPackedFixed32, rhs: ProtobufUnittest_NonPackedFixed32) -> Bool { - if lhs.repeatedFixed32 != rhs.repeatedFixed32 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_DupEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".DupEnum" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_DupEnum, rhs: ProtobufUnittest_DupEnum) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_DupEnum.TestEnumWithDupValueLite: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .aliased(proto: "FOO1", aliases: ["FOO2"]), - 2: .aliased(proto: "BAR1", aliases: ["BAR2"]), - 3: .same(proto: "BAZ"), - ] -} - -extension ProtobufUnittest_RecursiveMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".RecursiveMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "recurse"), - 2: .same(proto: "payload"), - ] - - fileprivate class _StorageClass { - var _recurse: ProtobufUnittest_RecursiveMessage? = nil - var _payload: Data? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _recurse = source._recurse - _payload = source._payload - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._recurse) }() - case 2: try { try decoder.decodeSingularBytesField(value: &_storage._payload) }() - default: break - } - } - } - } - - func traverse(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._recurse { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._payload { - try visitor.visitSingularBytesField(value: v, fieldNumber: 2) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_RecursiveMessage, rhs: ProtobufUnittest_RecursiveMessage) -> 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._recurse != rhs_storage._recurse {return false} - if _storage._payload != rhs_storage._payload {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Reference/google/protobuf/unittest_lite_imports_nonlite.pb.swift b/Reference/google/protobuf/unittest_lite_imports_nonlite.pb.swift deleted file mode 100644 index b06c51f0d..000000000 --- a/Reference/google/protobuf/unittest_lite_imports_nonlite.pb.swift +++ /dev/null @@ -1,142 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_lite_imports_nonlite.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) -// -// Tests that a "lite" message can import a regular message. - -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 ProtobufUnittest_TestLiteImportsNonlite { - // 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 message: ProtobufUnittest_TestAllTypes { - get {return _message ?? ProtobufUnittest_TestAllTypes()} - set {_message = newValue} - } - /// Returns true if `message` has been explicitly set. - var hasMessage: Bool {return self._message != nil} - /// Clears the value of `message`. Subsequent reads from it will return its default value. - mutating func clearMessage() {self._message = nil} - - /// Verifies that transitive required fields generates valid code. - var messageWithRequired: ProtobufUnittest_TestRequired { - get {return _messageWithRequired ?? ProtobufUnittest_TestRequired()} - set {_messageWithRequired = newValue} - } - /// Returns true if `messageWithRequired` has been explicitly set. - var hasMessageWithRequired: Bool {return self._messageWithRequired != nil} - /// Clears the value of `messageWithRequired`. Subsequent reads from it will return its default value. - mutating func clearMessageWithRequired() {self._messageWithRequired = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _message: ProtobufUnittest_TestAllTypes? = nil - fileprivate var _messageWithRequired: ProtobufUnittest_TestRequired? = nil -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_TestLiteImportsNonlite: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest" - -extension ProtobufUnittest_TestLiteImportsNonlite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestLiteImportsNonlite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "message"), - 2: .standard(proto: "message_with_required"), - ] - - public var isInitialized: Bool { - if let v = self._messageWithRequired, !v.isInitialized {return false} - return true - } - - 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.decodeSingularMessageField(value: &self._message) }() - case 2: try { try decoder.decodeSingularMessageField(value: &self._messageWithRequired) }() - 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 - try { if let v = self._message { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = self._messageWithRequired { - try visitor.visitSingularMessageField(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestLiteImportsNonlite, rhs: ProtobufUnittest_TestLiteImportsNonlite) -> Bool { - if lhs._message != rhs._message {return false} - if lhs._messageWithRequired != rhs._messageWithRequired {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Reference/google/protobuf/unittest_mset.pb.swift b/Reference/google/protobuf/unittest_mset.pb.swift deleted file mode 100644 index c8f8c90f1..000000000 --- a/Reference/google/protobuf/unittest_mset.pb.swift +++ /dev/null @@ -1,488 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_mset.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// This file is similar to unittest_mset_wire_format.proto, but does not -// have a TestMessageSet, so it can be downgraded to proto1. - -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 ProtobufUnittest_TestMessageSetContainer { - // 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 messageSet: Proto2WireformatUnittest_TestMessageSet { - get {return _messageSet ?? Proto2WireformatUnittest_TestMessageSet()} - set {_messageSet = newValue} - } - /// Returns true if `messageSet` has been explicitly set. - var hasMessageSet: Bool {return self._messageSet != nil} - /// Clears the value of `messageSet`. Subsequent reads from it will return its default value. - mutating func clearMessageSet() {self._messageSet = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _messageSet: Proto2WireformatUnittest_TestMessageSet? = nil -} - -struct ProtobufUnittest_TestMessageSetExtension1 { - // 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 i: Int32 { - get {return _i ?? 0} - set {_i = newValue} - } - /// Returns true if `i` has been explicitly set. - var hasI: Bool {return self._i != nil} - /// Clears the value of `i`. Subsequent reads from it will return its default value. - mutating func clearI() {self._i = nil} - - var recursive: Proto2WireformatUnittest_TestMessageSet { - get {return _recursive ?? Proto2WireformatUnittest_TestMessageSet()} - set {_recursive = newValue} - } - /// Returns true if `recursive` has been explicitly set. - var hasRecursive: Bool {return self._recursive != nil} - /// Clears the value of `recursive`. Subsequent reads from it will return its default value. - mutating func clearRecursive() {self._recursive = nil} - - var testAliasing: String { - get {return _testAliasing ?? String()} - set {_testAliasing = newValue} - } - /// Returns true if `testAliasing` has been explicitly set. - var hasTestAliasing: Bool {return self._testAliasing != nil} - /// Clears the value of `testAliasing`. Subsequent reads from it will return its default value. - mutating func clearTestAliasing() {self._testAliasing = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _i: Int32? = nil - fileprivate var _recursive: Proto2WireformatUnittest_TestMessageSet? = nil - fileprivate var _testAliasing: String? = nil -} - -struct ProtobufUnittest_TestMessageSetExtension2 { - // 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 str: String { - get {return _str ?? String()} - set {_str = newValue} - } - /// Returns true if `str` has been explicitly set. - var hasStr: Bool {return self._str != nil} - /// Clears the value of `str`. Subsequent reads from it will return its default value. - mutating func clearStr() {self._str = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _str: String? = nil -} - -/// MessageSet wire format is equivalent to this. -struct ProtobufUnittest_RawMessageSet { - // 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 item: [ProtobufUnittest_RawMessageSet.Item] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct Item { - // 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 typeID: Int32 { - get {return _typeID ?? 0} - set {_typeID = newValue} - } - /// Returns true if `typeID` has been explicitly set. - var hasTypeID: Bool {return self._typeID != nil} - /// Clears the value of `typeID`. Subsequent reads from it will return its default value. - mutating func clearTypeID() {self._typeID = nil} - - var message: Data { - get {return _message ?? Data()} - set {_message = newValue} - } - /// Returns true if `message` has been explicitly set. - var hasMessage: Bool {return self._message != nil} - /// Clears the value of `message`. Subsequent reads from it will return its default value. - mutating func clearMessage() {self._message = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _typeID: Int32? = nil - fileprivate var _message: Data? = nil - } - - init() {} -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_TestMessageSetContainer: @unchecked Sendable {} -extension ProtobufUnittest_TestMessageSetExtension1: @unchecked Sendable {} -extension ProtobufUnittest_TestMessageSetExtension2: @unchecked Sendable {} -extension ProtobufUnittest_RawMessageSet: @unchecked Sendable {} -extension ProtobufUnittest_RawMessageSet.Item: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Extension support defined in unittest_mset.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 Proto2WireformatUnittest_TestMessageSet { - - var ProtobufUnittest_TestMessageSetExtension1_messageSetExtension: ProtobufUnittest_TestMessageSetExtension1 { - get {return getExtensionValue(ext: ProtobufUnittest_TestMessageSetExtension1.Extensions.message_set_extension) ?? ProtobufUnittest_TestMessageSetExtension1()} - set {setExtensionValue(ext: ProtobufUnittest_TestMessageSetExtension1.Extensions.message_set_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestMessageSetExtension1.Extensions.message_set_extension` - /// has been explicitly set. - var hasProtobufUnittest_TestMessageSetExtension1_messageSetExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestMessageSetExtension1.Extensions.message_set_extension) - } - /// Clears the value of extension `ProtobufUnittest_TestMessageSetExtension1.Extensions.message_set_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestMessageSetExtension1_messageSetExtension() { - clearExtensionValue(ext: ProtobufUnittest_TestMessageSetExtension1.Extensions.message_set_extension) - } - - var ProtobufUnittest_TestMessageSetExtension2_messageSetExtension: ProtobufUnittest_TestMessageSetExtension2 { - get {return getExtensionValue(ext: ProtobufUnittest_TestMessageSetExtension2.Extensions.message_set_extension) ?? ProtobufUnittest_TestMessageSetExtension2()} - set {setExtensionValue(ext: ProtobufUnittest_TestMessageSetExtension2.Extensions.message_set_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestMessageSetExtension2.Extensions.message_set_extension` - /// has been explicitly set. - var hasProtobufUnittest_TestMessageSetExtension2_messageSetExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestMessageSetExtension2.Extensions.message_set_extension) - } - /// Clears the value of extension `ProtobufUnittest_TestMessageSetExtension2.Extensions.message_set_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestMessageSetExtension2_messageSetExtension() { - clearExtensionValue(ext: ProtobufUnittest_TestMessageSetExtension2.Extensions.message_set_extension) - } - -} - -// MARK: - File's ExtensionMap: ProtobufUnittest_UnittestMset_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 ProtobufUnittest_UnittestMset_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_TestMessageSetExtension1.Extensions.message_set_extension, - ProtobufUnittest_TestMessageSetExtension2.Extensions.message_set_extension -] - -// 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. - -extension ProtobufUnittest_TestMessageSetExtension1 { - enum Extensions { - static let message_set_extension = SwiftProtobuf.MessageExtension, Proto2WireformatUnittest_TestMessageSet>( - _protobuf_fieldNumber: 1545008, - fieldName: "protobuf_unittest.TestMessageSetExtension1" - ) - } -} - -extension ProtobufUnittest_TestMessageSetExtension2 { - enum Extensions { - static let message_set_extension = SwiftProtobuf.MessageExtension, Proto2WireformatUnittest_TestMessageSet>( - _protobuf_fieldNumber: 1547769, - fieldName: "protobuf_unittest.TestMessageSetExtension2" - ) - } -} - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest" - -extension ProtobufUnittest_TestMessageSetContainer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMessageSetContainer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "message_set"), - ] - - public var isInitialized: Bool { - if let v = self._messageSet, !v.isInitialized {return false} - return true - } - - 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.decodeSingularMessageField(value: &self._messageSet) }() - 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 - try { if let v = self._messageSet { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMessageSetContainer, rhs: ProtobufUnittest_TestMessageSetContainer) -> Bool { - if lhs._messageSet != rhs._messageSet {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestMessageSetExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMessageSetExtension1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 15: .same(proto: "i"), - 16: .same(proto: "recursive"), - 17: .standard(proto: "test_aliasing"), - ] - - public var isInitialized: Bool { - if let v = self._recursive, !v.isInitialized {return false} - return true - } - - 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 15: try { try decoder.decodeSingularInt32Field(value: &self._i) }() - case 16: try { try decoder.decodeSingularMessageField(value: &self._recursive) }() - case 17: try { try decoder.decodeSingularStringField(value: &self._testAliasing) }() - 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 - try { if let v = self._i { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 15) - } }() - try { if let v = self._recursive { - try visitor.visitSingularMessageField(value: v, fieldNumber: 16) - } }() - try { if let v = self._testAliasing { - try visitor.visitSingularStringField(value: v, fieldNumber: 17) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMessageSetExtension1, rhs: ProtobufUnittest_TestMessageSetExtension1) -> Bool { - if lhs._i != rhs._i {return false} - if lhs._recursive != rhs._recursive {return false} - if lhs._testAliasing != rhs._testAliasing {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestMessageSetExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMessageSetExtension2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 25: .same(proto: "str"), - ] - - 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 25: try { try decoder.decodeSingularStringField(value: &self._str) }() - 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 - try { if let v = self._str { - try visitor.visitSingularStringField(value: v, fieldNumber: 25) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMessageSetExtension2, rhs: ProtobufUnittest_TestMessageSetExtension2) -> Bool { - if lhs._str != rhs._str {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_RawMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".RawMessageSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .unique(proto: "Item", json: "item"), - ] - - public var isInitialized: Bool { - if !SwiftProtobuf.Internal.areAllInitialized(self.item) {return false} - return true - } - - 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.decodeRepeatedGroupField(value: &self.item) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.item.isEmpty { - try visitor.visitRepeatedGroupField(value: self.item, fieldNumber: 1) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_RawMessageSet, rhs: ProtobufUnittest_RawMessageSet) -> Bool { - if lhs.item != rhs.item {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_RawMessageSet.Item: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_RawMessageSet.protoMessageName + ".Item" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2: .standard(proto: "type_id"), - 3: .same(proto: "message"), - ] - - public var isInitialized: Bool { - if self._typeID == nil {return false} - if self._message == nil {return false} - return true - } - - 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 2: try { try decoder.decodeSingularInt32Field(value: &self._typeID) }() - case 3: try { try decoder.decodeSingularBytesField(value: &self._message) }() - 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 - try { if let v = self._typeID { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try { if let v = self._message { - try visitor.visitSingularBytesField(value: v, fieldNumber: 3) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_RawMessageSet.Item, rhs: ProtobufUnittest_RawMessageSet.Item) -> Bool { - if lhs._typeID != rhs._typeID {return false} - if lhs._message != rhs._message {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Reference/google/protobuf/unittest_no_field_presence.pb.swift b/Reference/google/protobuf/unittest_no_field_presence.pb.swift deleted file mode 100644 index a37887f3e..000000000 --- a/Reference/google/protobuf/unittest_no_field_presence.pb.swift +++ /dev/null @@ -1,1152 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_no_field_presence.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// A proto file used to test a message type with no explicit field presence. - -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 Proto2NofieldpresenceUnittest_ForeignEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foreignFoo // = 0 - case foreignBar // = 1 - case foreignBaz // = 2 - case UNRECOGNIZED(Int) - - init() { - self = .foreignFoo - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .foreignFoo - case 1: self = .foreignBar - case 2: self = .foreignBaz - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .foreignFoo: return 0 - case .foreignBar: return 1 - case .foreignBaz: return 2 - case .UNRECOGNIZED(let i): return i - } - } - -} - -#if swift(>=4.2) - -extension Proto2NofieldpresenceUnittest_ForeignEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto2NofieldpresenceUnittest_ForeignEnum] = [ - .foreignFoo, - .foreignBar, - .foreignBaz, - ] -} - -#endif // swift(>=4.2) - -/// This proto includes every type of field in both singular and repeated -/// forms. -struct Proto2NofieldpresenceUnittest_TestAllTypes { - // 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. - - /// Singular - /// TODO: remove 'optional' labels as soon as CL 69188077 is LGTM'd to make - /// 'optional' optional. - var optionalInt32: Int32 { - get {return _storage._optionalInt32} - set {_uniqueStorage()._optionalInt32 = newValue} - } - - var optionalInt64: Int64 { - get {return _storage._optionalInt64} - set {_uniqueStorage()._optionalInt64 = newValue} - } - - var optionalUint32: UInt32 { - get {return _storage._optionalUint32} - set {_uniqueStorage()._optionalUint32 = newValue} - } - - var optionalUint64: UInt64 { - get {return _storage._optionalUint64} - set {_uniqueStorage()._optionalUint64 = newValue} - } - - var optionalSint32: Int32 { - get {return _storage._optionalSint32} - set {_uniqueStorage()._optionalSint32 = newValue} - } - - var optionalSint64: Int64 { - get {return _storage._optionalSint64} - set {_uniqueStorage()._optionalSint64 = newValue} - } - - var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32} - set {_uniqueStorage()._optionalFixed32 = newValue} - } - - var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64} - set {_uniqueStorage()._optionalFixed64 = newValue} - } - - var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32} - set {_uniqueStorage()._optionalSfixed32 = newValue} - } - - var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64} - set {_uniqueStorage()._optionalSfixed64 = newValue} - } - - var optionalFloat: Float { - get {return _storage._optionalFloat} - set {_uniqueStorage()._optionalFloat = newValue} - } - - var optionalDouble: Double { - get {return _storage._optionalDouble} - set {_uniqueStorage()._optionalDouble = newValue} - } - - var optionalBool: Bool { - get {return _storage._optionalBool} - set {_uniqueStorage()._optionalBool = newValue} - } - - var optionalString: String { - get {return _storage._optionalString} - set {_uniqueStorage()._optionalString = newValue} - } - - var optionalBytes: Data { - get {return _storage._optionalBytes} - set {_uniqueStorage()._optionalBytes = newValue} - } - - var optionalNestedMessage: Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage { - get {return _storage._optionalNestedMessage ?? Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage()} - set {_uniqueStorage()._optionalNestedMessage = newValue} - } - /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} - /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} - - var optionalForeignMessage: Proto2NofieldpresenceUnittest_ForeignMessage { - get {return _storage._optionalForeignMessage ?? Proto2NofieldpresenceUnittest_ForeignMessage()} - set {_uniqueStorage()._optionalForeignMessage = newValue} - } - /// Returns true if `optionalForeignMessage` has been explicitly set. - var hasOptionalForeignMessage: Bool {return _storage._optionalForeignMessage != nil} - /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} - - var optionalProto2Message: ProtobufUnittest_TestAllTypes { - get {return _storage._optionalProto2Message ?? ProtobufUnittest_TestAllTypes()} - set {_uniqueStorage()._optionalProto2Message = newValue} - } - /// Returns true if `optionalProto2Message` has been explicitly set. - var hasOptionalProto2Message: Bool {return _storage._optionalProto2Message != nil} - /// Clears the value of `optionalProto2Message`. Subsequent reads from it will return its default value. - mutating func clearOptionalProto2Message() {_uniqueStorage()._optionalProto2Message = nil} - - var optionalNestedEnum: Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum { - get {return _storage._optionalNestedEnum} - set {_uniqueStorage()._optionalNestedEnum = newValue} - } - - /// N.B.: proto2-enum-type fields not allowed, because their default values - /// might not be zero. - ///optional protobuf_unittest.ForeignEnum optional_proto2_enum = 23; - var optionalForeignEnum: Proto2NofieldpresenceUnittest_ForeignEnum { - get {return _storage._optionalForeignEnum} - set {_uniqueStorage()._optionalForeignEnum = newValue} - } - - var optionalStringPiece: String { - get {return _storage._optionalStringPiece} - set {_uniqueStorage()._optionalStringPiece = newValue} - } - - var optionalCord: String { - get {return _storage._optionalCord} - set {_uniqueStorage()._optionalCord = newValue} - } - - var optionalLazyMessage: Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage { - get {return _storage._optionalLazyMessage ?? Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage()} - set {_uniqueStorage()._optionalLazyMessage = newValue} - } - /// Returns true if `optionalLazyMessage` has been explicitly set. - var hasOptionalLazyMessage: Bool {return _storage._optionalLazyMessage != nil} - /// Clears the value of `optionalLazyMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalLazyMessage() {_uniqueStorage()._optionalLazyMessage = nil} - - /// Repeated - var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} - set {_uniqueStorage()._repeatedInt32 = newValue} - } - - var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} - set {_uniqueStorage()._repeatedInt64 = newValue} - } - - var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} - set {_uniqueStorage()._repeatedUint32 = newValue} - } - - var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} - set {_uniqueStorage()._repeatedUint64 = newValue} - } - - var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} - set {_uniqueStorage()._repeatedSint32 = newValue} - } - - var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} - set {_uniqueStorage()._repeatedSint64 = newValue} - } - - var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} - set {_uniqueStorage()._repeatedFixed32 = newValue} - } - - var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} - set {_uniqueStorage()._repeatedFixed64 = newValue} - } - - var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} - set {_uniqueStorage()._repeatedSfixed32 = newValue} - } - - var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} - set {_uniqueStorage()._repeatedSfixed64 = newValue} - } - - var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} - set {_uniqueStorage()._repeatedFloat = newValue} - } - - var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} - set {_uniqueStorage()._repeatedDouble = newValue} - } - - var repeatedBool: [Bool] { - get {return _storage._repeatedBool} - set {_uniqueStorage()._repeatedBool = newValue} - } - - var repeatedString: [String] { - get {return _storage._repeatedString} - set {_uniqueStorage()._repeatedString = newValue} - } - - var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} - set {_uniqueStorage()._repeatedBytes = newValue} - } - - var repeatedNestedMessage: [Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedNestedMessage} - set {_uniqueStorage()._repeatedNestedMessage = newValue} - } - - var repeatedForeignMessage: [Proto2NofieldpresenceUnittest_ForeignMessage] { - get {return _storage._repeatedForeignMessage} - set {_uniqueStorage()._repeatedForeignMessage = newValue} - } - - var repeatedProto2Message: [ProtobufUnittest_TestAllTypes] { - get {return _storage._repeatedProto2Message} - set {_uniqueStorage()._repeatedProto2Message = newValue} - } - - var repeatedNestedEnum: [Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum] { - get {return _storage._repeatedNestedEnum} - set {_uniqueStorage()._repeatedNestedEnum = newValue} - } - - var repeatedForeignEnum: [Proto2NofieldpresenceUnittest_ForeignEnum] { - get {return _storage._repeatedForeignEnum} - set {_uniqueStorage()._repeatedForeignEnum = newValue} - } - - var repeatedStringPiece: [String] { - get {return _storage._repeatedStringPiece} - set {_uniqueStorage()._repeatedStringPiece = newValue} - } - - var repeatedCord: [String] { - get {return _storage._repeatedCord} - set {_uniqueStorage()._repeatedCord = newValue} - } - - var repeatedLazyMessage: [Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedLazyMessage} - set {_uniqueStorage()._repeatedLazyMessage = newValue} - } - - var oneofField: OneOf_OneofField? { - get {return _storage._oneofField} - set {_uniqueStorage()._oneofField = newValue} - } - - var oneofUint32: UInt32 { - get { - if case .oneofUint32(let v)? = _storage._oneofField {return v} - return 0 - } - set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} - } - - var oneofNestedMessage: Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage { - get { - if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} - return Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage() - } - set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} - } - - var oneofString: String { - get { - if case .oneofString(let v)? = _storage._oneofField {return v} - return String() - } - set {_uniqueStorage()._oneofField = .oneofString(newValue)} - } - - var oneofEnum: Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum { - get { - if case .oneofEnum(let v)? = _storage._oneofField {return v} - return .foo - } - set {_uniqueStorage()._oneofField = .oneofEnum(newValue)} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum OneOf_OneofField: Equatable { - case oneofUint32(UInt32) - case oneofNestedMessage(Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage) - case oneofString(String) - case oneofEnum(Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum) - - #if !swift(>=4.1) - static func ==(lhs: Proto2NofieldpresenceUnittest_TestAllTypes.OneOf_OneofField, rhs: Proto2NofieldpresenceUnittest_TestAllTypes.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofEnum, .oneofEnum): return { - guard case .oneofEnum(let l) = lhs, case .oneofEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif - } - - enum NestedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 0 - case bar // = 1 - case baz // = 2 - case UNRECOGNIZED(Int) - - init() { - self = .foo - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .foo - case 1: self = .bar - case 2: self = .baz - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .foo: return 0 - case .bar: return 1 - case .baz: return 2 - case .UNRECOGNIZED(let i): return i - } - } - - } - - struct NestedMessage { - // 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 bb: Int32 = 0 - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - } - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -#if swift(>=4.2) - -extension Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum] = [ - .foo, - .bar, - .baz, - ] -} - -#endif // swift(>=4.2) - -struct Proto2NofieldpresenceUnittest_TestProto2Required { - // 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 proto2: ProtobufUnittest_TestRequired { - get {return _proto2 ?? ProtobufUnittest_TestRequired()} - set {_proto2 = newValue} - } - /// Returns true if `proto2` has been explicitly set. - var hasProto2: Bool {return self._proto2 != nil} - /// Clears the value of `proto2`. Subsequent reads from it will return its default value. - mutating func clearProto2() {self._proto2 = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _proto2: ProtobufUnittest_TestRequired? = nil -} - -/// Define these after TestAllTypes to make sure the compiler can handle -/// that. -struct Proto2NofieldpresenceUnittest_ForeignMessage { - // 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 c: Int32 = 0 - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension Proto2NofieldpresenceUnittest_ForeignEnum: @unchecked Sendable {} -extension Proto2NofieldpresenceUnittest_TestAllTypes: @unchecked Sendable {} -extension Proto2NofieldpresenceUnittest_TestAllTypes.OneOf_OneofField: @unchecked Sendable {} -extension Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum: @unchecked Sendable {} -extension Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage: @unchecked Sendable {} -extension Proto2NofieldpresenceUnittest_TestProto2Required: @unchecked Sendable {} -extension Proto2NofieldpresenceUnittest_ForeignMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "proto2_nofieldpresence_unittest" - -extension Proto2NofieldpresenceUnittest_ForeignEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOREIGN_FOO"), - 1: .same(proto: "FOREIGN_BAR"), - 2: .same(proto: "FOREIGN_BAZ"), - ] -} - -extension Proto2NofieldpresenceUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "optional_foreign_message"), - 20: .standard(proto: "optional_proto2_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "optional_foreign_enum"), - 24: .standard(proto: "optional_string_piece"), - 25: .standard(proto: "optional_cord"), - 30: .standard(proto: "optional_lazy_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 48: .standard(proto: "repeated_nested_message"), - 49: .standard(proto: "repeated_foreign_message"), - 50: .standard(proto: "repeated_proto2_message"), - 51: .standard(proto: "repeated_nested_enum"), - 52: .standard(proto: "repeated_foreign_enum"), - 54: .standard(proto: "repeated_string_piece"), - 55: .standard(proto: "repeated_cord"), - 57: .standard(proto: "repeated_lazy_message"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_enum"), - ] - - fileprivate class _StorageClass { - var _optionalInt32: Int32 = 0 - var _optionalInt64: Int64 = 0 - var _optionalUint32: UInt32 = 0 - var _optionalUint64: UInt64 = 0 - var _optionalSint32: Int32 = 0 - var _optionalSint64: Int64 = 0 - var _optionalFixed32: UInt32 = 0 - var _optionalFixed64: UInt64 = 0 - var _optionalSfixed32: Int32 = 0 - var _optionalSfixed64: Int64 = 0 - var _optionalFloat: Float = 0 - var _optionalDouble: Double = 0 - var _optionalBool: Bool = false - var _optionalString: String = String() - var _optionalBytes: Data = Data() - var _optionalNestedMessage: Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage? = nil - var _optionalForeignMessage: Proto2NofieldpresenceUnittest_ForeignMessage? = nil - var _optionalProto2Message: ProtobufUnittest_TestAllTypes? = nil - var _optionalNestedEnum: Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum = .foo - var _optionalForeignEnum: Proto2NofieldpresenceUnittest_ForeignEnum = .foreignFoo - var _optionalStringPiece: String = String() - var _optionalCord: String = String() - var _optionalLazyMessage: Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage? = nil - var _repeatedInt32: [Int32] = [] - var _repeatedInt64: [Int64] = [] - var _repeatedUint32: [UInt32] = [] - var _repeatedUint64: [UInt64] = [] - var _repeatedSint32: [Int32] = [] - var _repeatedSint64: [Int64] = [] - var _repeatedFixed32: [UInt32] = [] - var _repeatedFixed64: [UInt64] = [] - var _repeatedSfixed32: [Int32] = [] - var _repeatedSfixed64: [Int64] = [] - var _repeatedFloat: [Float] = [] - var _repeatedDouble: [Double] = [] - var _repeatedBool: [Bool] = [] - var _repeatedString: [String] = [] - var _repeatedBytes: [Data] = [] - var _repeatedNestedMessage: [Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage] = [] - var _repeatedForeignMessage: [Proto2NofieldpresenceUnittest_ForeignMessage] = [] - var _repeatedProto2Message: [ProtobufUnittest_TestAllTypes] = [] - var _repeatedNestedEnum: [Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum] = [] - var _repeatedForeignEnum: [Proto2NofieldpresenceUnittest_ForeignEnum] = [] - var _repeatedStringPiece: [String] = [] - var _repeatedCord: [String] = [] - var _repeatedLazyMessage: [Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage] = [] - var _oneofField: Proto2NofieldpresenceUnittest_TestAllTypes.OneOf_OneofField? - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _optionalInt32 = source._optionalInt32 - _optionalInt64 = source._optionalInt64 - _optionalUint32 = source._optionalUint32 - _optionalUint64 = source._optionalUint64 - _optionalSint32 = source._optionalSint32 - _optionalSint64 = source._optionalSint64 - _optionalFixed32 = source._optionalFixed32 - _optionalFixed64 = source._optionalFixed64 - _optionalSfixed32 = source._optionalSfixed32 - _optionalSfixed64 = source._optionalSfixed64 - _optionalFloat = source._optionalFloat - _optionalDouble = source._optionalDouble - _optionalBool = source._optionalBool - _optionalString = source._optionalString - _optionalBytes = source._optionalBytes - _optionalNestedMessage = source._optionalNestedMessage - _optionalForeignMessage = source._optionalForeignMessage - _optionalProto2Message = source._optionalProto2Message - _optionalNestedEnum = source._optionalNestedEnum - _optionalForeignEnum = source._optionalForeignEnum - _optionalStringPiece = source._optionalStringPiece - _optionalCord = source._optionalCord - _optionalLazyMessage = source._optionalLazyMessage - _repeatedInt32 = source._repeatedInt32 - _repeatedInt64 = source._repeatedInt64 - _repeatedUint32 = source._repeatedUint32 - _repeatedUint64 = source._repeatedUint64 - _repeatedSint32 = source._repeatedSint32 - _repeatedSint64 = source._repeatedSint64 - _repeatedFixed32 = source._repeatedFixed32 - _repeatedFixed64 = source._repeatedFixed64 - _repeatedSfixed32 = source._repeatedSfixed32 - _repeatedSfixed64 = source._repeatedSfixed64 - _repeatedFloat = source._repeatedFloat - _repeatedDouble = source._repeatedDouble - _repeatedBool = source._repeatedBool - _repeatedString = source._repeatedString - _repeatedBytes = source._repeatedBytes - _repeatedNestedMessage = source._repeatedNestedMessage - _repeatedForeignMessage = source._repeatedForeignMessage - _repeatedProto2Message = source._repeatedProto2Message - _repeatedNestedEnum = source._repeatedNestedEnum - _repeatedForeignEnum = source._repeatedForeignEnum - _repeatedStringPiece = source._repeatedStringPiece - _repeatedCord = source._repeatedCord - _repeatedLazyMessage = source._repeatedLazyMessage - _oneofField = source._oneofField - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._optionalInt32) }() - case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() - case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() - case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() - case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() - case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() - case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() - case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() - case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() - case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() - case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() - case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() - case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() - case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() - case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() - case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() - case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() - case 20: try { try decoder.decodeSingularMessageField(value: &_storage._optionalProto2Message) }() - case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() - case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() - case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() - case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() - case 30: try { try decoder.decodeSingularMessageField(value: &_storage._optionalLazyMessage) }() - case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() - case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() - case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() - case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() - case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() - case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() - case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() - case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() - case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() - case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() - case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() - case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() - case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() - case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() - case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() - case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() - case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() - case 50: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedProto2Message) }() - case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() - case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() - case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() - case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() - case 57: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedLazyMessage) }() - case 111: try { - var v: UInt32? - try decoder.decodeSingularUInt32Field(value: &v) - if let v = v { - if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofUint32(v) - } - }() - case 112: try { - var v: Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage? - var hadOneofValue = false - if let current = _storage._oneofField { - hadOneofValue = true - if case .oneofNestedMessage(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofNestedMessage(v) - } - }() - case 113: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofString(v) - } - }() - case 114: try { - var v: Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum? - try decoder.decodeSingularEnumField(value: &v) - if let v = v { - if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofEnum(v) - } - }() - default: break - } - } - } - } - - func traverse(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 - if _storage._optionalInt32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._optionalInt32, fieldNumber: 1) - } - if _storage._optionalInt64 != 0 { - try visitor.visitSingularInt64Field(value: _storage._optionalInt64, fieldNumber: 2) - } - if _storage._optionalUint32 != 0 { - try visitor.visitSingularUInt32Field(value: _storage._optionalUint32, fieldNumber: 3) - } - if _storage._optionalUint64 != 0 { - try visitor.visitSingularUInt64Field(value: _storage._optionalUint64, fieldNumber: 4) - } - if _storage._optionalSint32 != 0 { - try visitor.visitSingularSInt32Field(value: _storage._optionalSint32, fieldNumber: 5) - } - if _storage._optionalSint64 != 0 { - try visitor.visitSingularSInt64Field(value: _storage._optionalSint64, fieldNumber: 6) - } - if _storage._optionalFixed32 != 0 { - try visitor.visitSingularFixed32Field(value: _storage._optionalFixed32, fieldNumber: 7) - } - if _storage._optionalFixed64 != 0 { - try visitor.visitSingularFixed64Field(value: _storage._optionalFixed64, fieldNumber: 8) - } - if _storage._optionalSfixed32 != 0 { - try visitor.visitSingularSFixed32Field(value: _storage._optionalSfixed32, fieldNumber: 9) - } - if _storage._optionalSfixed64 != 0 { - try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) - } - if _storage._optionalFloat != 0 { - try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) - } - if _storage._optionalDouble != 0 { - try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) - } - if _storage._optionalBool != false { - try visitor.visitSingularBoolField(value: _storage._optionalBool, fieldNumber: 13) - } - if !_storage._optionalString.isEmpty { - try visitor.visitSingularStringField(value: _storage._optionalString, fieldNumber: 14) - } - if !_storage._optionalBytes.isEmpty { - try visitor.visitSingularBytesField(value: _storage._optionalBytes, fieldNumber: 15) - } - try { if let v = _storage._optionalNestedMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 18) - } }() - try { if let v = _storage._optionalForeignMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 19) - } }() - try { if let v = _storage._optionalProto2Message { - try visitor.visitSingularMessageField(value: v, fieldNumber: 20) - } }() - if _storage._optionalNestedEnum != .foo { - try visitor.visitSingularEnumField(value: _storage._optionalNestedEnum, fieldNumber: 21) - } - if _storage._optionalForeignEnum != .foreignFoo { - try visitor.visitSingularEnumField(value: _storage._optionalForeignEnum, fieldNumber: 22) - } - if !_storage._optionalStringPiece.isEmpty { - try visitor.visitSingularStringField(value: _storage._optionalStringPiece, fieldNumber: 24) - } - if !_storage._optionalCord.isEmpty { - try visitor.visitSingularStringField(value: _storage._optionalCord, fieldNumber: 25) - } - try { if let v = _storage._optionalLazyMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 30) - } }() - if !_storage._repeatedInt32.isEmpty { - try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) - } - if !_storage._repeatedInt64.isEmpty { - try visitor.visitPackedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) - } - if !_storage._repeatedUint32.isEmpty { - try visitor.visitPackedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) - } - if !_storage._repeatedUint64.isEmpty { - try visitor.visitPackedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) - } - if !_storage._repeatedSint32.isEmpty { - try visitor.visitPackedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) - } - if !_storage._repeatedSint64.isEmpty { - try visitor.visitPackedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) - } - if !_storage._repeatedFixed32.isEmpty { - try visitor.visitPackedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) - } - if !_storage._repeatedFixed64.isEmpty { - try visitor.visitPackedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) - } - if !_storage._repeatedSfixed32.isEmpty { - try visitor.visitPackedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) - } - if !_storage._repeatedSfixed64.isEmpty { - try visitor.visitPackedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) - } - if !_storage._repeatedFloat.isEmpty { - try visitor.visitPackedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) - } - if !_storage._repeatedDouble.isEmpty { - try visitor.visitPackedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) - } - if !_storage._repeatedBool.isEmpty { - try visitor.visitPackedBoolField(value: _storage._repeatedBool, fieldNumber: 43) - } - if !_storage._repeatedString.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) - } - if !_storage._repeatedBytes.isEmpty { - try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) - } - if !_storage._repeatedNestedMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) - } - if !_storage._repeatedForeignMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) - } - if !_storage._repeatedProto2Message.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedProto2Message, fieldNumber: 50) - } - if !_storage._repeatedNestedEnum.isEmpty { - try visitor.visitPackedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) - } - if !_storage._repeatedForeignEnum.isEmpty { - try visitor.visitPackedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) - } - if !_storage._repeatedStringPiece.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) - } - if !_storage._repeatedCord.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) - } - if !_storage._repeatedLazyMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedLazyMessage, fieldNumber: 57) - } - switch _storage._oneofField { - case .oneofUint32?: try { - guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) - }() - case .oneofNestedMessage?: try { - guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 112) - }() - case .oneofString?: try { - guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 113) - }() - case .oneofEnum?: try { - guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularEnumField(value: v, fieldNumber: 114) - }() - case nil: break - } - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: Proto2NofieldpresenceUnittest_TestAllTypes, rhs: Proto2NofieldpresenceUnittest_TestAllTypes) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} - if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} - if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} - if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} - if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} - if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} - if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} - if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} - if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} - if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} - if _storage._optionalFloat != rhs_storage._optionalFloat {return false} - if _storage._optionalDouble != rhs_storage._optionalDouble {return false} - if _storage._optionalBool != rhs_storage._optionalBool {return false} - if _storage._optionalString != rhs_storage._optionalString {return false} - if _storage._optionalBytes != rhs_storage._optionalBytes {return false} - if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} - if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} - if _storage._optionalProto2Message != rhs_storage._optionalProto2Message {return false} - if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} - if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} - if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} - if _storage._optionalCord != rhs_storage._optionalCord {return false} - if _storage._optionalLazyMessage != rhs_storage._optionalLazyMessage {return false} - if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} - if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} - if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} - if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} - if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} - if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} - if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} - if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} - if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} - if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} - if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} - if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} - if _storage._repeatedBool != rhs_storage._repeatedBool {return false} - if _storage._repeatedString != rhs_storage._repeatedString {return false} - if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} - if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} - if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} - if _storage._repeatedProto2Message != rhs_storage._repeatedProto2Message {return false} - if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} - if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} - if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} - if _storage._repeatedCord != rhs_storage._repeatedCord {return false} - if _storage._repeatedLazyMessage != rhs_storage._repeatedLazyMessage {return false} - if _storage._oneofField != rhs_storage._oneofField {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - ] -} - -extension Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = Proto2NofieldpresenceUnittest_TestAllTypes.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - ] - - 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.bb) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if self.bb != 0 { - try visitor.visitSingularInt32Field(value: self.bb, fieldNumber: 1) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage, rhs: Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage) -> Bool { - if lhs.bb != rhs.bb {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension Proto2NofieldpresenceUnittest_TestProto2Required: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestProto2Required" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "proto2"), - ] - - public var isInitialized: Bool { - if let v = self._proto2, !v.isInitialized {return false} - return true - } - - 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.decodeSingularMessageField(value: &self._proto2) }() - 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 - try { if let v = self._proto2 { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: Proto2NofieldpresenceUnittest_TestProto2Required, rhs: Proto2NofieldpresenceUnittest_TestProto2Required) -> Bool { - if lhs._proto2 != rhs._proto2 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension Proto2NofieldpresenceUnittest_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ForeignMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - ] - - 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.c) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if self.c != 0 { - try visitor.visitSingularInt32Field(value: self.c, fieldNumber: 1) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: Proto2NofieldpresenceUnittest_ForeignMessage, rhs: Proto2NofieldpresenceUnittest_ForeignMessage) -> Bool { - if lhs.c != rhs.c {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Reference/google/protobuf/unittest_no_generic_services.pb.swift b/Reference/google/protobuf/unittest_no_generic_services.pb.swift deleted file mode 100644 index 536191da6..000000000 --- a/Reference/google/protobuf/unittest_no_generic_services.pb.swift +++ /dev/null @@ -1,213 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_no_generic_services.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) - -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 ProtobufUnittest_NoGenericServicesTest_TestEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 1 - - init() { - self = .foo - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .foo - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo: return 1 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_NoGenericServicesTest_TestEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_NoGenericServicesTest_TestMessage: 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _a: Int32? = nil -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_NoGenericServicesTest_TestEnum: @unchecked Sendable {} -extension ProtobufUnittest_NoGenericServicesTest_TestMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Extension support defined in unittest_no_generic_services.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 ProtobufUnittest_NoGenericServicesTest_TestMessage { - - var ProtobufUnittest_NoGenericServicesTest_testExtension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_NoGenericServicesTest_Extensions_test_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_NoGenericServicesTest_Extensions_test_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_NoGenericServicesTest_Extensions_test_extension` - /// has been explicitly set. - var hasProtobufUnittest_NoGenericServicesTest_testExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_NoGenericServicesTest_Extensions_test_extension) - } - /// Clears the value of extension `ProtobufUnittest_NoGenericServicesTest_Extensions_test_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_NoGenericServicesTest_testExtension() { - clearExtensionValue(ext: ProtobufUnittest_NoGenericServicesTest_Extensions_test_extension) - } - -} - -// MARK: - File's ExtensionMap: ProtobufUnittest_NoGenericServicesTest_UnittestNoGenericServices_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 ProtobufUnittest_NoGenericServicesTest_UnittestNoGenericServices_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_NoGenericServicesTest_Extensions_test_extension -] - -// 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 ProtobufUnittest_NoGenericServicesTest_Extensions_test_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_NoGenericServicesTest_TestMessage>( - _protobuf_fieldNumber: 1000, - fieldName: "protobuf_unittest.no_generic_services_test.test_extension" -) - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest.no_generic_services_test" - -extension ProtobufUnittest_NoGenericServicesTest_TestEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FOO"), - ] -} - -extension ProtobufUnittest_NoGenericServicesTest_TestMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - 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._a) }() - case 1000..<536870912: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_NoGenericServicesTest_TestMessage.self, fieldNumber: fieldNumber) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_NoGenericServicesTest_TestMessage, rhs: ProtobufUnittest_NoGenericServicesTest_TestMessage) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} diff --git a/Reference/google/protobuf/unittest_optimize_for.pb.swift b/Reference/google/protobuf/unittest_optimize_for.pb.swift deleted file mode 100644 index 88d0c5b14..000000000 --- a/Reference/google/protobuf/unittest_optimize_for.pb.swift +++ /dev/null @@ -1,419 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_optimize_for.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// A proto file which uses optimize_for = CODE_SIZE. - -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 ProtobufUnittest_TestOptimizedForSize: 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 i: Int32 { - get {return _i ?? 0} - set {_i = newValue} - } - /// Returns true if `i` has been explicitly set. - var hasI: Bool {return self._i != nil} - /// Clears the value of `i`. Subsequent reads from it will return its default value. - mutating func clearI() {self._i = nil} - - var msg: ProtobufUnittest_ForeignMessage { - get {return _msg ?? ProtobufUnittest_ForeignMessage()} - set {_msg = newValue} - } - /// Returns true if `msg` has been explicitly set. - var hasMsg: Bool {return self._msg != nil} - /// Clears the value of `msg`. Subsequent reads from it will return its default value. - mutating func clearMsg() {self._msg = nil} - - var foo: ProtobufUnittest_TestOptimizedForSize.OneOf_Foo? = nil - - var integerField: Int32 { - get { - if case .integerField(let v)? = foo {return v} - return 0 - } - set {foo = .integerField(newValue)} - } - - var stringField: String { - get { - if case .stringField(let v)? = foo {return v} - return String() - } - set {foo = .stringField(newValue)} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum OneOf_Foo: Equatable { - case integerField(Int32) - case stringField(String) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestOptimizedForSize.OneOf_Foo, rhs: ProtobufUnittest_TestOptimizedForSize.OneOf_Foo) -> 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 (.integerField, .integerField): return { - guard case .integerField(let l) = lhs, case .integerField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.stringField, .stringField): return { - guard case .stringField(let l) = lhs, case .stringField(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif - } - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _i: Int32? = nil - fileprivate var _msg: ProtobufUnittest_ForeignMessage? = nil -} - -struct ProtobufUnittest_TestRequiredOptimizedForSize { - // 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 x: Int32 { - get {return _x ?? 0} - set {_x = newValue} - } - /// Returns true if `x` has been explicitly set. - var hasX: Bool {return self._x != nil} - /// Clears the value of `x`. Subsequent reads from it will return its default value. - mutating func clearX() {self._x = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _x: Int32? = nil -} - -struct ProtobufUnittest_TestOptionalOptimizedForSize { - // 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 o: ProtobufUnittest_TestRequiredOptimizedForSize { - get {return _o ?? ProtobufUnittest_TestRequiredOptimizedForSize()} - set {_o = newValue} - } - /// Returns true if `o` has been explicitly set. - var hasO: Bool {return self._o != nil} - /// Clears the value of `o`. Subsequent reads from it will return its default value. - mutating func clearO() {self._o = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _o: ProtobufUnittest_TestRequiredOptimizedForSize? = nil -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_TestOptimizedForSize: @unchecked Sendable {} -extension ProtobufUnittest_TestOptimizedForSize.OneOf_Foo: @unchecked Sendable {} -extension ProtobufUnittest_TestRequiredOptimizedForSize: @unchecked Sendable {} -extension ProtobufUnittest_TestOptionalOptimizedForSize: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Extension support defined in unittest_optimize_for.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 ProtobufUnittest_TestOptimizedForSize { - - var ProtobufUnittest_TestOptimizedForSize_testExtension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension` - /// has been explicitly set. - var hasProtobufUnittest_TestOptimizedForSize_testExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension) - } - /// Clears the value of extension `ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestOptimizedForSize_testExtension() { - clearExtensionValue(ext: ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension) - } - - var ProtobufUnittest_TestOptimizedForSize_testExtension2: ProtobufUnittest_TestRequiredOptimizedForSize { - get {return getExtensionValue(ext: ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension2) ?? ProtobufUnittest_TestRequiredOptimizedForSize()} - set {setExtensionValue(ext: ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension2, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension2` - /// has been explicitly set. - var hasProtobufUnittest_TestOptimizedForSize_testExtension2: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension2) - } - /// Clears the value of extension `ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension2`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestOptimizedForSize_testExtension2() { - clearExtensionValue(ext: ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension2) - } - -} - -// MARK: - File's ExtensionMap: ProtobufUnittest_UnittestOptimizeFor_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 ProtobufUnittest_UnittestOptimizeFor_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension, - ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension2 -] - -// 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. - -extension ProtobufUnittest_TestOptimizedForSize { - enum Extensions { - static let test_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestOptimizedForSize>( - _protobuf_fieldNumber: 1234, - fieldName: "protobuf_unittest.TestOptimizedForSize.test_extension" - ) - - static let test_extension2 = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestOptimizedForSize>( - _protobuf_fieldNumber: 1235, - fieldName: "protobuf_unittest.TestOptimizedForSize.test_extension2" - ) - } -} - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest" - -extension ProtobufUnittest_TestOptimizedForSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestOptimizedForSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "i"), - 19: .same(proto: "msg"), - 2: .standard(proto: "integer_field"), - 3: .standard(proto: "string_field"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - 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._i) }() - case 2: try { - var v: Int32? - try decoder.decodeSingularInt32Field(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .integerField(v) - } - }() - case 3: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .stringField(v) - } - }() - case 19: try { try decoder.decodeSingularMessageField(value: &self._msg) }() - case 1000..<536870912: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestOptimizedForSize.self, fieldNumber: fieldNumber) }() - 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 - try { if let v = self._i { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - switch self.foo { - case .integerField?: try { - guard case .integerField(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - }() - case .stringField?: try { - guard case .stringField(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 3) - }() - case nil: break - } - try { if let v = self._msg { - try visitor.visitSingularMessageField(value: v, fieldNumber: 19) - } }() - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestOptimizedForSize, rhs: ProtobufUnittest_TestOptimizedForSize) -> Bool { - if lhs._i != rhs._i {return false} - if lhs._msg != rhs._msg {return false} - if lhs.foo != rhs.foo {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestRequiredOptimizedForSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestRequiredOptimizedForSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "x"), - ] - - public var isInitialized: Bool { - if self._x == nil {return false} - return true - } - - 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._x) }() - 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 - try { if let v = self._x { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestRequiredOptimizedForSize, rhs: ProtobufUnittest_TestRequiredOptimizedForSize) -> Bool { - if lhs._x != rhs._x {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestOptionalOptimizedForSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestOptionalOptimizedForSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "o"), - ] - - public var isInitialized: Bool { - if let v = self._o, !v.isInitialized {return false} - return true - } - - 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.decodeSingularMessageField(value: &self._o) }() - 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 - try { if let v = self._o { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestOptionalOptimizedForSize, rhs: ProtobufUnittest_TestOptionalOptimizedForSize) -> Bool { - if lhs._o != rhs._o {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Reference/unittest_swift_performance.pb.swift b/Reference/unittest_swift_performance.pb.swift deleted file mode 100644 index 2609e2597..000000000 --- a/Reference/unittest_swift_performance.pb.swift +++ /dev/null @@ -1,546 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: unittest_swift_performance.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -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 Swift_Performance_TestAllTypes { - // 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. - - /// One of every singular field type - var optionalInt32: Int32 { - get {return _storage._optionalInt32} - set {_uniqueStorage()._optionalInt32 = newValue} - } - - var optionalInt64: Int64 { - get {return _storage._optionalInt64} - set {_uniqueStorage()._optionalInt64 = newValue} - } - - var optionalUint32: UInt32 { - get {return _storage._optionalUint32} - set {_uniqueStorage()._optionalUint32 = newValue} - } - - var optionalUint64: UInt64 { - get {return _storage._optionalUint64} - set {_uniqueStorage()._optionalUint64 = newValue} - } - - var optionalSint32: Int32 { - get {return _storage._optionalSint32} - set {_uniqueStorage()._optionalSint32 = newValue} - } - - var optionalSint64: Int64 { - get {return _storage._optionalSint64} - set {_uniqueStorage()._optionalSint64 = newValue} - } - - var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32} - set {_uniqueStorage()._optionalFixed32 = newValue} - } - - var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64} - set {_uniqueStorage()._optionalFixed64 = newValue} - } - - var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32} - set {_uniqueStorage()._optionalSfixed32 = newValue} - } - - var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64} - set {_uniqueStorage()._optionalSfixed64 = newValue} - } - - var optionalFloat: Float { - get {return _storage._optionalFloat} - set {_uniqueStorage()._optionalFloat = newValue} - } - - var optionalDouble: Double { - get {return _storage._optionalDouble} - set {_uniqueStorage()._optionalDouble = newValue} - } - - var optionalBool: Bool { - get {return _storage._optionalBool} - set {_uniqueStorage()._optionalBool = newValue} - } - - var optionalString: String { - get {return _storage._optionalString} - set {_uniqueStorage()._optionalString = newValue} - } - - var optionalBytes: Data { - get {return _storage._optionalBytes} - set {_uniqueStorage()._optionalBytes = newValue} - } - - var repeatedRecursiveMessage: [Swift_Performance_TestAllTypes] { - get {return _storage._repeatedRecursiveMessage} - set {_uniqueStorage()._repeatedRecursiveMessage = newValue} - } - - /// Repeated - var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} - set {_uniqueStorage()._repeatedInt32 = newValue} - } - - var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} - set {_uniqueStorage()._repeatedInt64 = newValue} - } - - var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} - set {_uniqueStorage()._repeatedUint32 = newValue} - } - - var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} - set {_uniqueStorage()._repeatedUint64 = newValue} - } - - var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} - set {_uniqueStorage()._repeatedSint32 = newValue} - } - - var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} - set {_uniqueStorage()._repeatedSint64 = newValue} - } - - var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} - set {_uniqueStorage()._repeatedFixed32 = newValue} - } - - var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} - set {_uniqueStorage()._repeatedFixed64 = newValue} - } - - var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} - set {_uniqueStorage()._repeatedSfixed32 = newValue} - } - - var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} - set {_uniqueStorage()._repeatedSfixed64 = newValue} - } - - var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} - set {_uniqueStorage()._repeatedFloat = newValue} - } - - var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} - set {_uniqueStorage()._repeatedDouble = newValue} - } - - var repeatedBool: [Bool] { - get {return _storage._repeatedBool} - set {_uniqueStorage()._repeatedBool = newValue} - } - - var repeatedString: [String] { - get {return _storage._repeatedString} - set {_uniqueStorage()._repeatedString = newValue} - } - - var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} - set {_uniqueStorage()._repeatedBytes = newValue} - } - - /// Map - var mapStringMessage: Dictionary { - get {return _storage._mapStringMessage} - set {_uniqueStorage()._mapStringMessage = newValue} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension Swift_Performance_TestAllTypes: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "swift.performance" - -extension Swift_Performance_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 27: .standard(proto: "repeated_recursive_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 71: .standard(proto: "map_string_message"), - ] - - fileprivate class _StorageClass { - var _optionalInt32: Int32 = 0 - var _optionalInt64: Int64 = 0 - var _optionalUint32: UInt32 = 0 - var _optionalUint64: UInt64 = 0 - var _optionalSint32: Int32 = 0 - var _optionalSint64: Int64 = 0 - var _optionalFixed32: UInt32 = 0 - var _optionalFixed64: UInt64 = 0 - var _optionalSfixed32: Int32 = 0 - var _optionalSfixed64: Int64 = 0 - var _optionalFloat: Float = 0 - var _optionalDouble: Double = 0 - var _optionalBool: Bool = false - var _optionalString: String = String() - var _optionalBytes: Data = Data() - var _repeatedRecursiveMessage: [Swift_Performance_TestAllTypes] = [] - var _repeatedInt32: [Int32] = [] - var _repeatedInt64: [Int64] = [] - var _repeatedUint32: [UInt32] = [] - var _repeatedUint64: [UInt64] = [] - var _repeatedSint32: [Int32] = [] - var _repeatedSint64: [Int64] = [] - var _repeatedFixed32: [UInt32] = [] - var _repeatedFixed64: [UInt64] = [] - var _repeatedSfixed32: [Int32] = [] - var _repeatedSfixed64: [Int64] = [] - var _repeatedFloat: [Float] = [] - var _repeatedDouble: [Double] = [] - var _repeatedBool: [Bool] = [] - var _repeatedString: [String] = [] - var _repeatedBytes: [Data] = [] - var _mapStringMessage: Dictionary = [:] - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _optionalInt32 = source._optionalInt32 - _optionalInt64 = source._optionalInt64 - _optionalUint32 = source._optionalUint32 - _optionalUint64 = source._optionalUint64 - _optionalSint32 = source._optionalSint32 - _optionalSint64 = source._optionalSint64 - _optionalFixed32 = source._optionalFixed32 - _optionalFixed64 = source._optionalFixed64 - _optionalSfixed32 = source._optionalSfixed32 - _optionalSfixed64 = source._optionalSfixed64 - _optionalFloat = source._optionalFloat - _optionalDouble = source._optionalDouble - _optionalBool = source._optionalBool - _optionalString = source._optionalString - _optionalBytes = source._optionalBytes - _repeatedRecursiveMessage = source._repeatedRecursiveMessage - _repeatedInt32 = source._repeatedInt32 - _repeatedInt64 = source._repeatedInt64 - _repeatedUint32 = source._repeatedUint32 - _repeatedUint64 = source._repeatedUint64 - _repeatedSint32 = source._repeatedSint32 - _repeatedSint64 = source._repeatedSint64 - _repeatedFixed32 = source._repeatedFixed32 - _repeatedFixed64 = source._repeatedFixed64 - _repeatedSfixed32 = source._repeatedSfixed32 - _repeatedSfixed64 = source._repeatedSfixed64 - _repeatedFloat = source._repeatedFloat - _repeatedDouble = source._repeatedDouble - _repeatedBool = source._repeatedBool - _repeatedString = source._repeatedString - _repeatedBytes = source._repeatedBytes - _mapStringMessage = source._mapStringMessage - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._optionalInt32) }() - case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() - case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() - case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() - case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() - case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() - case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() - case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() - case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() - case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() - case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() - case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() - case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() - case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() - case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() - case 27: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedRecursiveMessage) }() - case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() - case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() - case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() - case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() - case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() - case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() - case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() - case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() - case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() - case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() - case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() - case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() - case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() - case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() - case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() - case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringMessage) }() - default: break - } - } - } - } - - func traverse(visitor: inout V) throws { - try withExtendedLifetime(_storage) { (_storage: _StorageClass) in - if _storage._optionalInt32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._optionalInt32, fieldNumber: 1) - } - if _storage._optionalInt64 != 0 { - try visitor.visitSingularInt64Field(value: _storage._optionalInt64, fieldNumber: 2) - } - if _storage._optionalUint32 != 0 { - try visitor.visitSingularUInt32Field(value: _storage._optionalUint32, fieldNumber: 3) - } - if _storage._optionalUint64 != 0 { - try visitor.visitSingularUInt64Field(value: _storage._optionalUint64, fieldNumber: 4) - } - if _storage._optionalSint32 != 0 { - try visitor.visitSingularSInt32Field(value: _storage._optionalSint32, fieldNumber: 5) - } - if _storage._optionalSint64 != 0 { - try visitor.visitSingularSInt64Field(value: _storage._optionalSint64, fieldNumber: 6) - } - if _storage._optionalFixed32 != 0 { - try visitor.visitSingularFixed32Field(value: _storage._optionalFixed32, fieldNumber: 7) - } - if _storage._optionalFixed64 != 0 { - try visitor.visitSingularFixed64Field(value: _storage._optionalFixed64, fieldNumber: 8) - } - if _storage._optionalSfixed32 != 0 { - try visitor.visitSingularSFixed32Field(value: _storage._optionalSfixed32, fieldNumber: 9) - } - if _storage._optionalSfixed64 != 0 { - try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) - } - if _storage._optionalFloat != 0 { - try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) - } - if _storage._optionalDouble != 0 { - try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) - } - if _storage._optionalBool != false { - try visitor.visitSingularBoolField(value: _storage._optionalBool, fieldNumber: 13) - } - if !_storage._optionalString.isEmpty { - try visitor.visitSingularStringField(value: _storage._optionalString, fieldNumber: 14) - } - if !_storage._optionalBytes.isEmpty { - try visitor.visitSingularBytesField(value: _storage._optionalBytes, fieldNumber: 15) - } - if !_storage._repeatedRecursiveMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedRecursiveMessage, fieldNumber: 27) - } - if !_storage._repeatedInt32.isEmpty { - try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) - } - if !_storage._repeatedInt64.isEmpty { - try visitor.visitPackedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) - } - if !_storage._repeatedUint32.isEmpty { - try visitor.visitPackedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) - } - if !_storage._repeatedUint64.isEmpty { - try visitor.visitPackedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) - } - if !_storage._repeatedSint32.isEmpty { - try visitor.visitPackedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) - } - if !_storage._repeatedSint64.isEmpty { - try visitor.visitPackedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) - } - if !_storage._repeatedFixed32.isEmpty { - try visitor.visitPackedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) - } - if !_storage._repeatedFixed64.isEmpty { - try visitor.visitPackedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) - } - if !_storage._repeatedSfixed32.isEmpty { - try visitor.visitPackedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) - } - if !_storage._repeatedSfixed64.isEmpty { - try visitor.visitPackedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) - } - if !_storage._repeatedFloat.isEmpty { - try visitor.visitPackedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) - } - if !_storage._repeatedDouble.isEmpty { - try visitor.visitPackedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) - } - if !_storage._repeatedBool.isEmpty { - try visitor.visitPackedBoolField(value: _storage._repeatedBool, fieldNumber: 43) - } - if !_storage._repeatedString.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) - } - if !_storage._repeatedBytes.isEmpty { - try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) - } - if !_storage._mapStringMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringMessage, fieldNumber: 71) - } - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: Swift_Performance_TestAllTypes, rhs: Swift_Performance_TestAllTypes) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} - if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} - if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} - if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} - if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} - if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} - if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} - if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} - if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} - if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} - if _storage._optionalFloat != rhs_storage._optionalFloat {return false} - if _storage._optionalDouble != rhs_storage._optionalDouble {return false} - if _storage._optionalBool != rhs_storage._optionalBool {return false} - if _storage._optionalString != rhs_storage._optionalString {return false} - if _storage._optionalBytes != rhs_storage._optionalBytes {return false} - if _storage._repeatedRecursiveMessage != rhs_storage._repeatedRecursiveMessage {return false} - if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} - if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} - if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} - if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} - if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} - if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} - if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} - if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} - if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} - if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} - if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} - if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} - if _storage._repeatedBool != rhs_storage._repeatedBool {return false} - if _storage._repeatedString != rhs_storage._repeatedString {return false} - if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} - if _storage._mapStringMessage != rhs_storage._mapStringMessage {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Reference/unittest_swift_reserved.pb.swift b/Reference/unittest_swift_reserved.pb.swift deleted file mode 100644 index 5e081f63b..000000000 --- a/Reference/unittest_swift_reserved.pb.swift +++ /dev/null @@ -1,756 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: unittest_swift_reserved.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protos/unittest_swift_reserved.proto - test proto -// -// This source file is part of the Swift.org open source project -// -// Copyright (c) 2014 - 2016 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 Swift reserved words used as enum or message names -/// -// ----------------------------------------------------------------------------- - -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 ProtobufUnittest_SwiftReservedTest { - // 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. - - /// static r/o properties on Message, ensure they still work as fields. - var protoMessageName: Int32 { - get {return _protoMessageName ?? 0} - set {_protoMessageName = newValue} - } - /// Returns true if `protoMessageName` has been explicitly set. - var hasProtoMessageName: Bool {return self._protoMessageName != nil} - /// Clears the value of `protoMessageName`. Subsequent reads from it will return its default value. - mutating func clearProtoMessageName() {self._protoMessageName = nil} - - var protoPackageName: Int32 { - get {return _protoPackageName ?? 0} - set {_protoPackageName = newValue} - } - /// Returns true if `protoPackageName` has been explicitly set. - var hasProtoPackageName: Bool {return self._protoPackageName != nil} - /// Clears the value of `protoPackageName`. Subsequent reads from it will return its default value. - mutating func clearProtoPackageName() {self._protoPackageName = nil} - - var anyTypePrefix: Int32 { - get {return _anyTypePrefix ?? 0} - set {_anyTypePrefix = newValue} - } - /// Returns true if `anyTypePrefix` has been explicitly set. - var hasAnyTypePrefix: Bool {return self._anyTypePrefix != nil} - /// Clears the value of `anyTypePrefix`. Subsequent reads from it will return its default value. - mutating func clearAnyTypePrefix() {self._anyTypePrefix = nil} - - var anyTypeURL: Int32 { - get {return _anyTypeURL ?? 0} - set {_anyTypeURL = newValue} - } - /// Returns true if `anyTypeURL` has been explicitly set. - var hasAnyTypeURL: Bool {return self._anyTypeURL != nil} - /// Clears the value of `anyTypeURL`. Subsequent reads from it will return its default value. - mutating func clearAnyTypeURL() {self._anyTypeURL = nil} - - /// r/o properties on Message, ensure it gets remapped. - var isInitialized_p: String { - get {return _isInitialized_p ?? String()} - set {_isInitialized_p = newValue} - } - /// Returns true if `isInitialized_p` has been explicitly set. - var hasIsInitialized_p: Bool {return self._isInitialized_p != nil} - /// Clears the value of `isInitialized_p`. Subsequent reads from it will return its default value. - mutating func clearIsInitialized_p() {self._isInitialized_p = nil} - - var hashValue_p: String { - get {return _hashValue_p ?? String()} - set {_hashValue_p = newValue} - } - /// Returns true if `hashValue_p` has been explicitly set. - var hasHashValue_p: Bool {return self._hashValue_p != nil} - /// Clears the value of `hashValue_p`. Subsequent reads from it will return its default value. - mutating func clearHashValue_p() {self._hashValue_p = nil} - - var debugDescription_p: Int32 { - get {return _debugDescription_p ?? 0} - set {_debugDescription_p = newValue} - } - /// Returns true if `debugDescription_p` has been explicitly set. - var hasDebugDescription_p: Bool {return self._debugDescription_p != nil} - /// Clears the value of `debugDescription_p`. Subsequent reads from it will return its default value. - mutating func clearDebugDescription_p() {self._debugDescription_p = nil} - - /// Prompt code generator to build an 'isInitialized' test - var requiredInt: Int32 { - get {return _requiredInt ?? 0} - set {_requiredInt = newValue} - } - /// Returns true if `requiredInt` has been explicitly set. - var hasRequiredInt: Bool {return self._requiredInt != nil} - /// Clears the value of `requiredInt`. Subsequent reads from it will return its default value. - mutating func clearRequiredInt() {self._requiredInt = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case double // = 1 - case json // = 2 - case `class` // = 3 - case ___ // = 4 - case self_ // = 5 - case type // = 6 - - init() { - self = .double - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .double - case 2: self = .json - case 3: self = .class - case 4: self = .___ - case 5: self = .self_ - case 6: self = .type - default: return nil - } - } - - var rawValue: Int { - switch self { - case .double: return 1 - case .json: return 2 - case .class: return 3 - case .___: return 4 - case .self_: return 5 - case .type: return 6 - } - } - - } - - enum ProtocolEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case a // = 1 - - init() { - self = .a - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .a - default: return nil - } - } - - var rawValue: Int { - switch self { - case .a: return 1 - } - } - - } - - struct classMessage: 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() - } - - struct TypeMessage: 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() - } - - struct isEqual { - // 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() {} - } - - init() {} - - fileprivate var _protoMessageName: Int32? = nil - fileprivate var _protoPackageName: Int32? = nil - fileprivate var _anyTypePrefix: Int32? = nil - fileprivate var _anyTypeURL: Int32? = nil - fileprivate var _isInitialized_p: String? = nil - fileprivate var _hashValue_p: String? = nil - fileprivate var _debugDescription_p: Int32? = nil - fileprivate var _requiredInt: Int32? = nil -} - -#if swift(>=4.2) - -extension ProtobufUnittest_SwiftReservedTest.Enum: CaseIterable { - // Support synthesized by the compiler. -} - -extension ProtobufUnittest_SwiftReservedTest.ProtocolEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_SwiftReservedTestExt { - // 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() {} -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_SwiftReservedTest: @unchecked Sendable {} -extension ProtobufUnittest_SwiftReservedTest.Enum: @unchecked Sendable {} -extension ProtobufUnittest_SwiftReservedTest.ProtocolEnum: @unchecked Sendable {} -extension ProtobufUnittest_SwiftReservedTest.classMessage: @unchecked Sendable {} -extension ProtobufUnittest_SwiftReservedTest.TypeMessage: @unchecked Sendable {} -extension ProtobufUnittest_SwiftReservedTest.isEqual: @unchecked Sendable {} -extension ProtobufUnittest_SwiftReservedTestExt: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Extension support defined in unittest_swift_reserved.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 ProtobufUnittest_SwiftReservedTest.classMessage { - - /// Won't get _p added because it is fully qualified. - var ProtobufUnittest_debugDescription: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_debug_description) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_debug_description, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_debug_description` - /// has been explicitly set. - var hasProtobufUnittest_debugDescription: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_debug_description) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_debug_description`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_debugDescription() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_debug_description) - } - - /// These are scoped to the file, so the package prefix (or a Swift prefix) - /// will get added to them to they aren't going to get renamed. - var ProtobufUnittest_as: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_as) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_as, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_as` - /// has been explicitly set. - var hasProtobufUnittest_as: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_as) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_as`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_as() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_as) - } - - var ProtobufUnittest_var: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_var) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_var, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_var` - /// has been explicitly set. - var hasProtobufUnittest_var: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_var) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_var`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_var() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_var) - } - - var ProtobufUnittest_try: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_try) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_try, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_try` - /// has been explicitly set. - var hasProtobufUnittest_try: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_try) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_try`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_try() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_try) - } - - var ProtobufUnittest_do: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_do) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_do, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_do` - /// has been explicitly set. - var hasProtobufUnittest_do: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_do) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_do`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_do() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_do) - } - - var ProtobufUnittest_nil: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_nil) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_nil, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_nil` - /// has been explicitly set. - var hasProtobufUnittest_nil: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_nil) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_nil`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_nil() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_nil) - } - - /// This will end up in the "enum Extensions" to scope it, but there - /// the raw form is used ("hash_value", not the Swift one "hashValue"), - /// so there is no conflict, and no renaming happens. - var ProtobufUnittest_SwiftReservedTestExt_hashValue: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.hash_value) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.hash_value, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.hash_value` - /// has been explicitly set. - var hasProtobufUnittest_SwiftReservedTestExt_hashValue: Bool { - return hasExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.hash_value) - } - /// Clears the value of extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.hash_value`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_SwiftReservedTestExt_hashValue() { - clearExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.hash_value) - } - - /// Reserved words, since these end up in the "struct Extensions", they - /// can't just be get their names, and sanitation kicks. - var ProtobufUnittest_SwiftReservedTestExt_as: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.as) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.as, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.as` - /// has been explicitly set. - var hasProtobufUnittest_SwiftReservedTestExt_as: Bool { - return hasExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.as) - } - /// Clears the value of extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.as`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_SwiftReservedTestExt_as() { - clearExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.as) - } - - var ProtobufUnittest_SwiftReservedTestExt_var: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.var) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.var, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.var` - /// has been explicitly set. - var hasProtobufUnittest_SwiftReservedTestExt_var: Bool { - return hasExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.var) - } - /// Clears the value of extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.var`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_SwiftReservedTestExt_var() { - clearExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.var) - } - - var ProtobufUnittest_SwiftReservedTestExt_try: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.try) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.try, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.try` - /// has been explicitly set. - var hasProtobufUnittest_SwiftReservedTestExt_try: Bool { - return hasExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.try) - } - /// Clears the value of extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.try`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_SwiftReservedTestExt_try() { - clearExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.try) - } - - var ProtobufUnittest_SwiftReservedTestExt_do: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.do) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.do, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.do` - /// has been explicitly set. - var hasProtobufUnittest_SwiftReservedTestExt_do: Bool { - return hasExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.do) - } - /// Clears the value of extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.do`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_SwiftReservedTestExt_do() { - clearExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.do) - } - - var ProtobufUnittest_SwiftReservedTestExt_nil: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.nil) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.nil, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.nil` - /// has been explicitly set. - var hasProtobufUnittest_SwiftReservedTestExt_nil: Bool { - return hasExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.nil) - } - /// Clears the value of extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.nil`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_SwiftReservedTestExt_nil() { - clearExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.nil) - } - -} - -// MARK: - File's ExtensionMap: ProtobufUnittest_UnittestSwiftReserved_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 ProtobufUnittest_UnittestSwiftReserved_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_Extensions_debug_description, - ProtobufUnittest_Extensions_as, - ProtobufUnittest_Extensions_var, - ProtobufUnittest_Extensions_try, - ProtobufUnittest_Extensions_do, - ProtobufUnittest_Extensions_nil, - ProtobufUnittest_SwiftReservedTestExt.Extensions.hash_value, - ProtobufUnittest_SwiftReservedTestExt.Extensions.as, - ProtobufUnittest_SwiftReservedTestExt.Extensions.var, - ProtobufUnittest_SwiftReservedTestExt.Extensions.try, - ProtobufUnittest_SwiftReservedTestExt.Extensions.do, - ProtobufUnittest_SwiftReservedTestExt.Extensions.nil -] - -// 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. - -/// Won't get _p added because it is fully qualified. -let ProtobufUnittest_Extensions_debug_description = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( - _protobuf_fieldNumber: 1000, - fieldName: "protobuf_unittest.debug_description" -) - -/// These are scoped to the file, so the package prefix (or a Swift prefix) -/// will get added to them to they aren't going to get renamed. -let ProtobufUnittest_Extensions_as = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( - _protobuf_fieldNumber: 1012, - fieldName: "protobuf_unittest.as" -) - -let ProtobufUnittest_Extensions_var = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( - _protobuf_fieldNumber: 1013, - fieldName: "protobuf_unittest.var" -) - -let ProtobufUnittest_Extensions_try = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( - _protobuf_fieldNumber: 1014, - fieldName: "protobuf_unittest.try" -) - -let ProtobufUnittest_Extensions_do = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( - _protobuf_fieldNumber: 1015, - fieldName: "protobuf_unittest.do" -) - -let ProtobufUnittest_Extensions_nil = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( - _protobuf_fieldNumber: 1016, - fieldName: "protobuf_unittest.nil" -) - -extension ProtobufUnittest_SwiftReservedTestExt { - enum Extensions { - /// This will end up in the "enum Extensions" to scope it, but there - /// the raw form is used ("hash_value", not the Swift one "hashValue"), - /// so there is no conflict, and no renaming happens. - static let hash_value = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( - _protobuf_fieldNumber: 1001, - fieldName: "protobuf_unittest.SwiftReservedTestExt.hash_value" - ) - - /// Reserved words, since these end up in the "struct Extensions", they - /// can't just be get their names, and sanitation kicks. - static let `as` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( - _protobuf_fieldNumber: 1022, - fieldName: "protobuf_unittest.SwiftReservedTestExt.as" - ) - - static let `var` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( - _protobuf_fieldNumber: 1023, - fieldName: "protobuf_unittest.SwiftReservedTestExt.var" - ) - - static let `try` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( - _protobuf_fieldNumber: 1024, - fieldName: "protobuf_unittest.SwiftReservedTestExt.try" - ) - - static let `do` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( - _protobuf_fieldNumber: 1025, - fieldName: "protobuf_unittest.SwiftReservedTestExt.do" - ) - - static let `nil` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( - _protobuf_fieldNumber: 1026, - fieldName: "protobuf_unittest.SwiftReservedTestExt.nil" - ) - } -} - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest" - -extension ProtobufUnittest_SwiftReservedTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".SwiftReservedTest" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 10: .standard(proto: "proto_message_name"), - 11: .standard(proto: "proto_package_name"), - 12: .standard(proto: "any_type_prefix"), - 13: .standard(proto: "any_type_url"), - 20: .standard(proto: "is_initialized"), - 21: .standard(proto: "hash_value"), - 22: .standard(proto: "debug_description"), - 30: .standard(proto: "required_int"), - ] - - public var isInitialized: Bool { - if self._requiredInt == nil {return false} - return true - } - - 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 10: try { try decoder.decodeSingularInt32Field(value: &self._protoMessageName) }() - case 11: try { try decoder.decodeSingularInt32Field(value: &self._protoPackageName) }() - case 12: try { try decoder.decodeSingularInt32Field(value: &self._anyTypePrefix) }() - case 13: try { try decoder.decodeSingularInt32Field(value: &self._anyTypeURL) }() - case 20: try { try decoder.decodeSingularStringField(value: &self._isInitialized_p) }() - case 21: try { try decoder.decodeSingularStringField(value: &self._hashValue_p) }() - case 22: try { try decoder.decodeSingularInt32Field(value: &self._debugDescription_p) }() - case 30: try { try decoder.decodeSingularInt32Field(value: &self._requiredInt) }() - 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 - try { if let v = self._protoMessageName { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 10) - } }() - try { if let v = self._protoPackageName { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 11) - } }() - try { if let v = self._anyTypePrefix { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 12) - } }() - try { if let v = self._anyTypeURL { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 13) - } }() - try { if let v = self._isInitialized_p { - try visitor.visitSingularStringField(value: v, fieldNumber: 20) - } }() - try { if let v = self._hashValue_p { - try visitor.visitSingularStringField(value: v, fieldNumber: 21) - } }() - try { if let v = self._debugDescription_p { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 22) - } }() - try { if let v = self._requiredInt { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 30) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_SwiftReservedTest, rhs: ProtobufUnittest_SwiftReservedTest) -> Bool { - if lhs._protoMessageName != rhs._protoMessageName {return false} - if lhs._protoPackageName != rhs._protoPackageName {return false} - if lhs._anyTypePrefix != rhs._anyTypePrefix {return false} - if lhs._anyTypeURL != rhs._anyTypeURL {return false} - if lhs._isInitialized_p != rhs._isInitialized_p {return false} - if lhs._hashValue_p != rhs._hashValue_p {return false} - if lhs._debugDescription_p != rhs._debugDescription_p {return false} - if lhs._requiredInt != rhs._requiredInt {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_SwiftReservedTest.Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "DOUBLE"), - 2: .same(proto: "JSON"), - 3: .same(proto: "CLASS"), - 4: .same(proto: "_"), - 5: .same(proto: "SELF"), - 6: .same(proto: "TYPE"), - ] -} - -extension ProtobufUnittest_SwiftReservedTest.ProtocolEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] -} - -extension ProtobufUnittest_SwiftReservedTest.classMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_SwiftReservedTest.protoMessageName + ".class" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1000 <= fieldNumber && fieldNumber < 2001) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_SwiftReservedTest.classMessage.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 2001) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_SwiftReservedTest.classMessage, rhs: ProtobufUnittest_SwiftReservedTest.classMessage) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_SwiftReservedTest.TypeMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_SwiftReservedTest.protoMessageName + ".Type" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1000 <= fieldNumber && fieldNumber < 2001) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_SwiftReservedTest.TypeMessage.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 2001) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_SwiftReservedTest.TypeMessage, rhs: ProtobufUnittest_SwiftReservedTest.TypeMessage) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_SwiftReservedTest.isEqual: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_SwiftReservedTest.protoMessageName + ".isEqual" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_SwiftReservedTest.isEqual, rhs: ProtobufUnittest_SwiftReservedTest.isEqual) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_SwiftReservedTestExt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".SwiftReservedTestExt" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_SwiftReservedTestExt, rhs: ProtobufUnittest_SwiftReservedTestExt) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Reference/unittest_swift_startup.pb.swift b/Reference/unittest_swift_startup.pb.swift deleted file mode 100644 index f7b331b6b..000000000 --- a/Reference/unittest_swift_startup.pb.swift +++ /dev/null @@ -1,225 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: unittest_swift_startup.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -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 ProtobufObjcUnittest_TestObjCStartupMessage: 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() -} - -struct ProtobufObjcUnittest_TestObjCStartupNested { - // 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() {} -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufObjcUnittest_TestObjCStartupMessage: @unchecked Sendable {} -extension ProtobufObjcUnittest_TestObjCStartupNested: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Extension support defined in unittest_swift_startup.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 ProtobufObjcUnittest_TestObjCStartupMessage { - - /// Singular - var ProtobufObjcUnittest_optionalInt32Extension: Int32 { - get {return getExtensionValue(ext: ProtobufObjcUnittest_Extensions_optional_int32_extension) ?? 0} - set {setExtensionValue(ext: ProtobufObjcUnittest_Extensions_optional_int32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufObjcUnittest_Extensions_optional_int32_extension` - /// has been explicitly set. - var hasProtobufObjcUnittest_optionalInt32Extension: Bool { - return hasExtensionValue(ext: ProtobufObjcUnittest_Extensions_optional_int32_extension) - } - /// Clears the value of extension `ProtobufObjcUnittest_Extensions_optional_int32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufObjcUnittest_optionalInt32Extension() { - clearExtensionValue(ext: ProtobufObjcUnittest_Extensions_optional_int32_extension) - } - - var ProtobufObjcUnittest_repeatedInt32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufObjcUnittest_Extensions_repeated_int32_extension) ?? []} - set {setExtensionValue(ext: ProtobufObjcUnittest_Extensions_repeated_int32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufObjcUnittest_Extensions_repeated_int32_extension` - /// has been explicitly set. - var hasProtobufObjcUnittest_repeatedInt32Extension: Bool { - return hasExtensionValue(ext: ProtobufObjcUnittest_Extensions_repeated_int32_extension) - } - /// Clears the value of extension `ProtobufObjcUnittest_Extensions_repeated_int32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufObjcUnittest_repeatedInt32Extension() { - clearExtensionValue(ext: ProtobufObjcUnittest_Extensions_repeated_int32_extension) - } - - var ProtobufObjcUnittest_TestObjCStartupNested_nestedStringExtension: String { - get {return getExtensionValue(ext: ProtobufObjcUnittest_TestObjCStartupNested.Extensions.nested_string_extension) ?? String()} - set {setExtensionValue(ext: ProtobufObjcUnittest_TestObjCStartupNested.Extensions.nested_string_extension, value: newValue)} - } - /// Returns true if extension `ProtobufObjcUnittest_TestObjCStartupNested.Extensions.nested_string_extension` - /// has been explicitly set. - var hasProtobufObjcUnittest_TestObjCStartupNested_nestedStringExtension: Bool { - return hasExtensionValue(ext: ProtobufObjcUnittest_TestObjCStartupNested.Extensions.nested_string_extension) - } - /// Clears the value of extension `ProtobufObjcUnittest_TestObjCStartupNested.Extensions.nested_string_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufObjcUnittest_TestObjCStartupNested_nestedStringExtension() { - clearExtensionValue(ext: ProtobufObjcUnittest_TestObjCStartupNested.Extensions.nested_string_extension) - } - -} - -// MARK: - File's ExtensionMap: ProtobufObjcUnittest_UnittestSwiftStartup_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 ProtobufObjcUnittest_UnittestSwiftStartup_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufObjcUnittest_Extensions_optional_int32_extension, - ProtobufObjcUnittest_Extensions_repeated_int32_extension, - ProtobufObjcUnittest_TestObjCStartupNested.Extensions.nested_string_extension -] - -// 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. - -/// Singular -let ProtobufObjcUnittest_Extensions_optional_int32_extension = SwiftProtobuf.MessageExtension, ProtobufObjcUnittest_TestObjCStartupMessage>( - _protobuf_fieldNumber: 1, - fieldName: "protobuf_objc_unittest.optional_int32_extension" -) - -let ProtobufObjcUnittest_Extensions_repeated_int32_extension = SwiftProtobuf.MessageExtension, ProtobufObjcUnittest_TestObjCStartupMessage>( - _protobuf_fieldNumber: 2, - fieldName: "protobuf_objc_unittest.repeated_int32_extension" -) - -extension ProtobufObjcUnittest_TestObjCStartupNested { - enum Extensions { - static let nested_string_extension = SwiftProtobuf.MessageExtension, ProtobufObjcUnittest_TestObjCStartupMessage>( - _protobuf_fieldNumber: 3, - fieldName: "protobuf_objc_unittest.TestObjCStartupNested.nested_string_extension" - ) - } -} - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_objc_unittest" - -extension ProtobufObjcUnittest_TestObjCStartupMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestObjCStartupMessage" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufObjcUnittest_TestObjCStartupMessage.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufObjcUnittest_TestObjCStartupMessage, rhs: ProtobufObjcUnittest_TestObjCStartupMessage) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufObjcUnittest_TestObjCStartupNested: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestObjCStartupNested" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufObjcUnittest_TestObjCStartupNested, rhs: ProtobufObjcUnittest_TestObjCStartupNested) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Tests/SwiftProtobufTests/conformance.pb.swift b/Reference/upstream/conformance/conformance.pb.swift similarity index 73% rename from Tests/SwiftProtobufTests/conformance.pb.swift rename to Reference/upstream/conformance/conformance.pb.swift index d19d0cca6..d1e311190 100644 --- a/Tests/SwiftProtobufTests/conformance.pb.swift +++ b/Reference/upstream/conformance/conformance.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: conformance/conformance.proto @@ -9,33 +10,10 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd import Foundation import SwiftProtobuf @@ -50,13 +28,13 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum Conformance_WireFormat: SwiftProtobuf.Enum { +enum Conformance_WireFormat: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case unspecified // = 0 case protobuf // = 1 case json // = 2 - /// Google internal only. Opensource testees just skip it. + /// Only used inside Google. Opensource testees just skip it. case jspb // = 3 case textFormat // = 4 case UNRECOGNIZED(Int) @@ -87,24 +65,18 @@ enum Conformance_WireFormat: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension Conformance_WireFormat: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Conformance_WireFormat] = [ + static let allCases: [Conformance_WireFormat] = [ .unspecified, .protobuf, .json, .jspb, .textFormat, ] -} -#endif // swift(>=4.2) +} -enum Conformance_TestCategory: SwiftProtobuf.Enum { +enum Conformance_TestCategory: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case unspecifiedTest // = 0 @@ -121,7 +93,8 @@ enum Conformance_TestCategory: SwiftProtobuf.Enum { /// for more detail. case jsonIgnoreUnknownParsingTest // = 3 - /// Test jspb wire format. Google internal only. Opensource testees just skip it. + /// Test jspb wire format. Only used inside Google. Opensource testees just + /// skip it. case jspbTest // = 4 /// Test text format. For cpp, java and python, testees can already deal with @@ -157,13 +130,8 @@ enum Conformance_TestCategory: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension Conformance_TestCategory: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Conformance_TestCategory] = [ + static let allCases: [Conformance_TestCategory] = [ .unspecifiedTest, .binaryTest, .jsonTest, @@ -171,19 +139,39 @@ extension Conformance_TestCategory: CaseIterable { .jspbTest, .textFormatTest, ] + } -#endif // swift(>=4.2) +/// Meant to encapsulate all types of tests: successes, skips, failures, etc. +/// Therefore, this may or may not have a failure message. Failure messages +/// may be truncated for our failure lists. +struct Conformance_TestStatus: Sendable { + // 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 name: String = String() + + var failureMessage: String = String() + + /// What an actual test name matched to in a failure list. Can be wildcarded or + /// an exact match without wildcards. + var matchedName: String = String() + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} /// The conformance runner will request a list of failures as the first request. /// This will be known by message_type == "conformance.FailureSet", a conformance /// test should return a serialized FailureSet in protobuf_payload. -struct Conformance_FailureSet { +struct Conformance_FailureSet: Sendable { // 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 failure: [String] = [] + var test: [Conformance_TestStatus] = [] var unknownFields = SwiftProtobuf.UnknownStorage() @@ -195,7 +183,7 @@ struct Conformance_FailureSet { /// 1. parse this proto (which should always succeed) /// 2. parse the protobuf or JSON payload in "payload" (which may fail) /// 3. if the parse succeeded, serialize the message in the requested format. -struct Conformance_ConformanceRequest { +struct Conformance_ConformanceRequest: Sendable { // 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. @@ -203,10 +191,6 @@ struct Conformance_ConformanceRequest { /// The payload (whether protobuf of JSON) is always for a /// protobuf_test_messages.proto3.TestAllTypes proto (as defined in /// src/google/protobuf/proto3_test_messages.proto). - /// - /// TODO(haberman): if/when we expand the conformance tests to support proto2, - /// we will want to include a field that lets the payload/response be a - /// protobuf_test_messages.google.protobuf.TestAllTypes message instead. var payload: Conformance_ConformanceRequest.OneOf_Payload? = nil var protobufPayload: Data { @@ -225,7 +209,7 @@ struct Conformance_ConformanceRequest { set {payload = .jsonPayload(newValue)} } - /// Google internal only. Opensource testees just skip it. + /// Only used inside Google. Opensource testees just skip it. var jspbPayload: String { get { if case .jspbPayload(let v)? = payload {return v} @@ -247,21 +231,24 @@ struct Conformance_ConformanceRequest { /// The full name for the test message to use; for the moment, either: /// protobuf_test_messages.proto3.TestAllTypesProto3 or - /// protobuf_test_messages.google.protobuf.TestAllTypesProto2. + /// protobuf_test_messages.proto2.TestAllTypesProto2 or + /// protobuf_test_messages.editions.proto2.TestAllTypesProto2 or + /// protobuf_test_messages.editions.proto3.TestAllTypesProto3 or + /// protobuf_test_messages.editions.TestAllTypesEdition2023. var messageType: String = String() /// Each test is given a specific test category. Some category may need - /// specific support in testee programs. Refer to the definition of TestCategory - /// for more information. + /// specific support in testee programs. Refer to the definition of + /// TestCategory for more information. var testCategory: Conformance_TestCategory = .unspecifiedTest /// Specify details for how to encode jspb. var jspbEncodingOptions: Conformance_JspbEncodingConfig { - get {return _jspbEncodingOptions ?? Conformance_JspbEncodingConfig()} + get {_jspbEncodingOptions ?? Conformance_JspbEncodingConfig()} set {_jspbEncodingOptions = newValue} } /// Returns true if `jspbEncodingOptions` has been explicitly set. - var hasJspbEncodingOptions: Bool {return self._jspbEncodingOptions != nil} + var hasJspbEncodingOptions: Bool {self._jspbEncodingOptions != nil} /// Clears the value of `jspbEncodingOptions`. Subsequent reads from it will return its default value. mutating func clearJspbEncodingOptions() {self._jspbEncodingOptions = nil} @@ -274,43 +261,13 @@ struct Conformance_ConformanceRequest { /// The payload (whether protobuf of JSON) is always for a /// protobuf_test_messages.proto3.TestAllTypes proto (as defined in /// src/google/protobuf/proto3_test_messages.proto). - /// - /// TODO(haberman): if/when we expand the conformance tests to support proto2, - /// we will want to include a field that lets the payload/response be a - /// protobuf_test_messages.google.protobuf.TestAllTypes message instead. - enum OneOf_Payload: Equatable { + enum OneOf_Payload: Equatable, Sendable { case protobufPayload(Data) case jsonPayload(String) - /// Google internal only. Opensource testees just skip it. + /// Only used inside Google. Opensource testees just skip it. case jspbPayload(String) case textPayload(String) - #if !swift(>=4.1) - static func ==(lhs: Conformance_ConformanceRequest.OneOf_Payload, rhs: Conformance_ConformanceRequest.OneOf_Payload) -> 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 (.protobufPayload, .protobufPayload): return { - guard case .protobufPayload(let l) = lhs, case .protobufPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.jsonPayload, .jsonPayload): return { - guard case .jsonPayload(let l) = lhs, case .jsonPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.jspbPayload, .jspbPayload): return { - guard case .jspbPayload(let l) = lhs, case .jspbPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.textPayload, .textPayload): return { - guard case .textPayload(let l) = lhs, case .textPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } init() {} @@ -319,7 +276,7 @@ struct Conformance_ConformanceRequest { } /// Represents a single test case's output. -struct Conformance_ConformanceResponse { +struct Conformance_ConformanceResponse: Sendable { // 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. @@ -350,6 +307,17 @@ struct Conformance_ConformanceResponse { set {result = .serializeError(newValue)} } + /// This should be set if the test program timed out. The string should + /// provide more information about what the child process was doing when it + /// was killed. + var timeoutError: String { + get { + if case .timeoutError(let v)? = result {return v} + return String() + } + set {result = .timeoutError(newValue)} + } + /// This should be set if some other error occurred. This will always /// indicate that the test failed. The string can provide more information /// about the failure. @@ -392,8 +360,8 @@ struct Conformance_ConformanceResponse { } /// If the input was successfully parsed and the requested output was JSPB, - /// serialize to JSPB and set it in this field. JSPB is google internal only - /// format. Opensource testees can just skip it. + /// serialize to JSPB and set it in this field. JSPB is only used inside + /// Google. Opensource testees can just skip it. var jspbPayload: String { get { if case .jspbPayload(let v)? = result {return v} @@ -414,7 +382,7 @@ struct Conformance_ConformanceResponse { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_Result: Equatable { + enum OneOf_Result: Equatable, Sendable { /// This string should be set to indicate parsing failed. The string can /// provide more information about the parse error if it is available. /// @@ -425,6 +393,10 @@ struct Conformance_ConformanceResponse { /// serializing it to the requested output format, set the error message in /// this field. case serializeError(String) + /// This should be set if the test program timed out. The string should + /// provide more information about what the child process was doing when it + /// was killed. + case timeoutError(String) /// This should be set if some other error occurred. This will always /// indicate that the test failed. The string can provide more information /// about the failure. @@ -439,62 +411,20 @@ struct Conformance_ConformanceResponse { /// wasn't supported, like JSON input/output. case skipped(String) /// If the input was successfully parsed and the requested output was JSPB, - /// serialize to JSPB and set it in this field. JSPB is google internal only - /// format. Opensource testees can just skip it. + /// serialize to JSPB and set it in this field. JSPB is only used inside + /// Google. Opensource testees can just skip it. case jspbPayload(String) /// If the input was successfully parsed and the requested output was /// TEXT_FORMAT, serialize to TEXT_FORMAT and set it in this field. case textPayload(String) - #if !swift(>=4.1) - static func ==(lhs: Conformance_ConformanceResponse.OneOf_Result, rhs: Conformance_ConformanceResponse.OneOf_Result) -> 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 (.parseError, .parseError): return { - guard case .parseError(let l) = lhs, case .parseError(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.serializeError, .serializeError): return { - guard case .serializeError(let l) = lhs, case .serializeError(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.runtimeError, .runtimeError): return { - guard case .runtimeError(let l) = lhs, case .runtimeError(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.protobufPayload, .protobufPayload): return { - guard case .protobufPayload(let l) = lhs, case .protobufPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.jsonPayload, .jsonPayload): return { - guard case .jsonPayload(let l) = lhs, case .jsonPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.skipped, .skipped): return { - guard case .skipped(let l) = lhs, case .skipped(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.jspbPayload, .jspbPayload): return { - guard case .jspbPayload(let l) = lhs, case .jspbPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.textPayload, .textPayload): return { - guard case .textPayload(let l) = lhs, case .textPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } init() {} } /// Encoding options for jspb format. -struct Conformance_JspbEncodingConfig { +struct Conformance_JspbEncodingConfig: Sendable { // 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. @@ -507,47 +437,61 @@ struct Conformance_JspbEncodingConfig { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Conformance_WireFormat: @unchecked Sendable {} -extension Conformance_TestCategory: @unchecked Sendable {} -extension Conformance_FailureSet: @unchecked Sendable {} -extension Conformance_ConformanceRequest: @unchecked Sendable {} -extension Conformance_ConformanceRequest.OneOf_Payload: @unchecked Sendable {} -extension Conformance_ConformanceResponse: @unchecked Sendable {} -extension Conformance_ConformanceResponse.OneOf_Result: @unchecked Sendable {} -extension Conformance_JspbEncodingConfig: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "conformance" extension Conformance_WireFormat: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "UNSPECIFIED"), - 1: .same(proto: "PROTOBUF"), - 2: .same(proto: "JSON"), - 3: .same(proto: "JSPB"), - 4: .same(proto: "TEXT_FORMAT"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNSPECIFIED\0\u{1}PROTOBUF\0\u{1}JSON\0\u{1}JSPB\0\u{1}TEXT_FORMAT\0") } extension Conformance_TestCategory: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "UNSPECIFIED_TEST"), - 1: .same(proto: "BINARY_TEST"), - 2: .same(proto: "JSON_TEST"), - 3: .same(proto: "JSON_IGNORE_UNKNOWN_PARSING_TEST"), - 4: .same(proto: "JSPB_TEST"), - 5: .same(proto: "TEXT_FORMAT_TEST"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNSPECIFIED_TEST\0\u{1}BINARY_TEST\0\u{1}JSON_TEST\0\u{1}JSON_IGNORE_UNKNOWN_PARSING_TEST\0\u{1}JSPB_TEST\0\u{1}TEXT_FORMAT_TEST\0") +} + +extension Conformance_TestStatus: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestStatus" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}name\0\u{3}failure_message\0\u{3}matched_name\0") + + 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.name) }() + case 2: try { try decoder.decodeSingularStringField(value: &self.failureMessage) }() + case 3: try { try decoder.decodeSingularStringField(value: &self.matchedName) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.name.isEmpty { + try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) + } + if !self.failureMessage.isEmpty { + try visitor.visitSingularStringField(value: self.failureMessage, fieldNumber: 2) + } + if !self.matchedName.isEmpty { + try visitor.visitSingularStringField(value: self.matchedName, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Conformance_TestStatus, rhs: Conformance_TestStatus) -> Bool { + if lhs.name != rhs.name {return false} + if lhs.failureMessage != rhs.failureMessage {return false} + if lhs.matchedName != rhs.matchedName {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } } extension Conformance_FailureSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".FailureSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "failure"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{2}test\0\u{c}\u{1}\u{1}") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -555,21 +499,21 @@ extension Conformance_FailureSet: SwiftProtobuf.Message, SwiftProtobuf._MessageI // 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.decodeRepeatedStringField(value: &self.failure) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.test) }() default: break } } } func traverse(visitor: inout V) throws { - if !self.failure.isEmpty { - try visitor.visitRepeatedStringField(value: self.failure, fieldNumber: 1) + if !self.test.isEmpty { + try visitor.visitRepeatedMessageField(value: self.test, fieldNumber: 2) } try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Conformance_FailureSet, rhs: Conformance_FailureSet) -> Bool { - if lhs.failure != rhs.failure {return false} + if lhs.test != rhs.test {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } @@ -577,17 +521,7 @@ extension Conformance_FailureSet: SwiftProtobuf.Message, SwiftProtobuf._MessageI extension Conformance_ConformanceRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ConformanceRequest" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "protobuf_payload"), - 2: .standard(proto: "json_payload"), - 7: .standard(proto: "jspb_payload"), - 8: .standard(proto: "text_payload"), - 3: .standard(proto: "requested_output_format"), - 4: .standard(proto: "message_type"), - 5: .standard(proto: "test_category"), - 6: .standard(proto: "jspb_encoding_options"), - 9: .standard(proto: "print_unknown_fields"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}protobuf_payload\0\u{3}json_payload\0\u{3}requested_output_format\0\u{3}message_type\0\u{3}test_category\0\u{3}jspb_encoding_options\0\u{3}jspb_payload\0\u{3}text_payload\0\u{3}print_unknown_fields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -696,16 +630,7 @@ extension Conformance_ConformanceRequest: SwiftProtobuf.Message, SwiftProtobuf._ extension Conformance_ConformanceResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ConformanceResponse" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "parse_error"), - 6: .standard(proto: "serialize_error"), - 2: .standard(proto: "runtime_error"), - 3: .standard(proto: "protobuf_payload"), - 4: .standard(proto: "json_payload"), - 5: .same(proto: "skipped"), - 7: .standard(proto: "jspb_payload"), - 8: .standard(proto: "text_payload"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}parse_error\0\u{3}runtime_error\0\u{3}protobuf_payload\0\u{3}json_payload\0\u{1}skipped\0\u{3}serialize_error\0\u{3}jspb_payload\0\u{3}text_payload\0\u{3}timeout_error\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -777,6 +702,14 @@ extension Conformance_ConformanceResponse: SwiftProtobuf.Message, SwiftProtobuf. self.result = .textPayload(v) } }() + case 9: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.result != nil {try decoder.handleConflictingOneOf()} + self.result = .timeoutError(v) + } + }() default: break } } @@ -820,6 +753,10 @@ extension Conformance_ConformanceResponse: SwiftProtobuf.Message, SwiftProtobuf. guard case .textPayload(let v)? = self.result else { preconditionFailure() } try visitor.visitSingularStringField(value: v, fieldNumber: 8) }() + case .timeoutError?: try { + guard case .timeoutError(let v)? = self.result else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 9) + }() case nil: break } try unknownFields.traverse(visitor: &visitor) @@ -834,9 +771,7 @@ extension Conformance_ConformanceResponse: SwiftProtobuf.Message, SwiftProtobuf. extension Conformance_JspbEncodingConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".JspbEncodingConfig" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "use_jspb_array_any_format"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}use_jspb_array_any_format\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { diff --git a/Reference/upstream/conformance/test_protos/test_messages_edition2023.pb.swift b/Reference/upstream/conformance/test_protos/test_messages_edition2023.pb.swift new file mode 100644 index 000000000..e9601952b --- /dev/null +++ b/Reference/upstream/conformance/test_protos/test_messages_edition2023.pb.swift @@ -0,0 +1,2073 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: conformance/test_protos/test_messages_edition2023.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2024 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +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 ProtobufTestMessages_Editions_ForeignEnumEdition2023: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foreignFoo // = 0 + case foreignBar // = 1 + case foreignBaz // = 2 + case UNRECOGNIZED(Int) + + init() { + self = .foreignFoo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .foreignFoo + case 1: self = .foreignBar + case 2: self = .foreignBaz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .foreignFoo: return 0 + case .foreignBar: return 1 + case .foreignBaz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Editions_ForeignEnumEdition2023] = [ + .foreignFoo, + .foreignBar, + .foreignBaz, + ] + +} + +struct ProtobufTestMessages_Editions_ComplexMessage: Sendable { + // 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 d: Int32 { + get {_d ?? 0} + set {_d = newValue} + } + /// Returns true if `d` has been explicitly set. + var hasD: Bool {self._d != nil} + /// Clears the value of `d`. Subsequent reads from it will return its default value. + mutating func clearD() {self._d = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _d: Int32? = nil +} + +struct ProtobufTestMessages_Editions_TestAllTypesEdition2023: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Singular + var optionalInt32: Int32 { + get {_storage._optionalInt32 ?? 0} + set {_uniqueStorage()._optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} + + var optionalInt64: Int64 { + get {_storage._optionalInt64 ?? 0} + set {_uniqueStorage()._optionalInt64 = newValue} + } + /// Returns true if `optionalInt64` has been explicitly set. + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} + /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} + + var optionalUint32: UInt32 { + get {_storage._optionalUint32 ?? 0} + set {_uniqueStorage()._optionalUint32 = newValue} + } + /// Returns true if `optionalUint32` has been explicitly set. + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} + /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} + + var optionalUint64: UInt64 { + get {_storage._optionalUint64 ?? 0} + set {_uniqueStorage()._optionalUint64 = newValue} + } + /// Returns true if `optionalUint64` has been explicitly set. + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} + /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} + + var optionalSint32: Int32 { + get {_storage._optionalSint32 ?? 0} + set {_uniqueStorage()._optionalSint32 = newValue} + } + /// Returns true if `optionalSint32` has been explicitly set. + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} + /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} + + var optionalSint64: Int64 { + get {_storage._optionalSint64 ?? 0} + set {_uniqueStorage()._optionalSint64 = newValue} + } + /// Returns true if `optionalSint64` has been explicitly set. + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} + /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} + + var optionalFixed32: UInt32 { + get {_storage._optionalFixed32 ?? 0} + set {_uniqueStorage()._optionalFixed32 = newValue} + } + /// Returns true if `optionalFixed32` has been explicitly set. + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} + /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} + + var optionalFixed64: UInt64 { + get {_storage._optionalFixed64 ?? 0} + set {_uniqueStorage()._optionalFixed64 = newValue} + } + /// Returns true if `optionalFixed64` has been explicitly set. + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} + /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} + + var optionalSfixed32: Int32 { + get {_storage._optionalSfixed32 ?? 0} + set {_uniqueStorage()._optionalSfixed32 = newValue} + } + /// Returns true if `optionalSfixed32` has been explicitly set. + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} + /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} + + var optionalSfixed64: Int64 { + get {_storage._optionalSfixed64 ?? 0} + set {_uniqueStorage()._optionalSfixed64 = newValue} + } + /// Returns true if `optionalSfixed64` has been explicitly set. + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} + /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} + + var optionalFloat: Float { + get {_storage._optionalFloat ?? 0} + set {_uniqueStorage()._optionalFloat = newValue} + } + /// Returns true if `optionalFloat` has been explicitly set. + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} + /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} + + var optionalDouble: Double { + get {_storage._optionalDouble ?? 0} + set {_uniqueStorage()._optionalDouble = newValue} + } + /// Returns true if `optionalDouble` has been explicitly set. + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} + /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. + mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} + + var optionalBool: Bool { + get {_storage._optionalBool ?? false} + set {_uniqueStorage()._optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {_storage._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} + + var optionalString: String { + get {_storage._optionalString ?? String()} + set {_uniqueStorage()._optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {_storage._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} + + var optionalBytes: Data { + get {_storage._optionalBytes ?? Data()} + set {_uniqueStorage()._optionalBytes = newValue} + } + /// Returns true if `optionalBytes` has been explicitly set. + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} + /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} + + var optionalNestedMessage: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage { + get {_storage._optionalNestedMessage ?? ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage()} + set {_uniqueStorage()._optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} + + var optionalForeignMessage: ProtobufTestMessages_Editions_ForeignMessageEdition2023 { + get {_storage._optionalForeignMessage ?? ProtobufTestMessages_Editions_ForeignMessageEdition2023()} + set {_uniqueStorage()._optionalForeignMessage = newValue} + } + /// Returns true if `optionalForeignMessage` has been explicitly set. + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} + /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} + + var optionalNestedEnum: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum { + get {_storage._optionalNestedEnum ?? .foo} + set {_uniqueStorage()._optionalNestedEnum = newValue} + } + /// Returns true if `optionalNestedEnum` has been explicitly set. + var hasOptionalNestedEnum: Bool {_storage._optionalNestedEnum != nil} + /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} + + var optionalForeignEnum: ProtobufTestMessages_Editions_ForeignEnumEdition2023 { + get {_storage._optionalForeignEnum ?? .foreignFoo} + set {_uniqueStorage()._optionalForeignEnum = newValue} + } + /// Returns true if `optionalForeignEnum` has been explicitly set. + var hasOptionalForeignEnum: Bool {_storage._optionalForeignEnum != nil} + /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignEnum() {_uniqueStorage()._optionalForeignEnum = nil} + + var optionalStringPiece: String { + get {_storage._optionalStringPiece ?? String()} + set {_uniqueStorage()._optionalStringPiece = newValue} + } + /// Returns true if `optionalStringPiece` has been explicitly set. + var hasOptionalStringPiece: Bool {_storage._optionalStringPiece != nil} + /// Clears the value of `optionalStringPiece`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringPiece() {_uniqueStorage()._optionalStringPiece = nil} + + var optionalCord: String { + get {_storage._optionalCord ?? String()} + set {_uniqueStorage()._optionalCord = newValue} + } + /// Returns true if `optionalCord` has been explicitly set. + var hasOptionalCord: Bool {_storage._optionalCord != nil} + /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. + mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} + + var recursiveMessage: ProtobufTestMessages_Editions_TestAllTypesEdition2023 { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Editions_TestAllTypesEdition2023()} + set {_uniqueStorage()._recursiveMessage = newValue} + } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} + + /// Repeated + var repeatedInt32: [Int32] { + get {_storage._repeatedInt32} + set {_uniqueStorage()._repeatedInt32 = newValue} + } + + var repeatedInt64: [Int64] { + get {_storage._repeatedInt64} + set {_uniqueStorage()._repeatedInt64 = newValue} + } + + var repeatedUint32: [UInt32] { + get {_storage._repeatedUint32} + set {_uniqueStorage()._repeatedUint32 = newValue} + } + + var repeatedUint64: [UInt64] { + get {_storage._repeatedUint64} + set {_uniqueStorage()._repeatedUint64 = newValue} + } + + var repeatedSint32: [Int32] { + get {_storage._repeatedSint32} + set {_uniqueStorage()._repeatedSint32 = newValue} + } + + var repeatedSint64: [Int64] { + get {_storage._repeatedSint64} + set {_uniqueStorage()._repeatedSint64 = newValue} + } + + var repeatedFixed32: [UInt32] { + get {_storage._repeatedFixed32} + set {_uniqueStorage()._repeatedFixed32 = newValue} + } + + var repeatedFixed64: [UInt64] { + get {_storage._repeatedFixed64} + set {_uniqueStorage()._repeatedFixed64 = newValue} + } + + var repeatedSfixed32: [Int32] { + get {_storage._repeatedSfixed32} + set {_uniqueStorage()._repeatedSfixed32 = newValue} + } + + var repeatedSfixed64: [Int64] { + get {_storage._repeatedSfixed64} + set {_uniqueStorage()._repeatedSfixed64 = newValue} + } + + var repeatedFloat: [Float] { + get {_storage._repeatedFloat} + set {_uniqueStorage()._repeatedFloat = newValue} + } + + var repeatedDouble: [Double] { + get {_storage._repeatedDouble} + set {_uniqueStorage()._repeatedDouble = newValue} + } + + var repeatedBool: [Bool] { + get {_storage._repeatedBool} + set {_uniqueStorage()._repeatedBool = newValue} + } + + var repeatedString: [String] { + get {_storage._repeatedString} + set {_uniqueStorage()._repeatedString = newValue} + } + + var repeatedBytes: [Data] { + get {_storage._repeatedBytes} + set {_uniqueStorage()._repeatedBytes = newValue} + } + + var repeatedNestedMessage: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage] { + get {_storage._repeatedNestedMessage} + set {_uniqueStorage()._repeatedNestedMessage = newValue} + } + + var repeatedForeignMessage: [ProtobufTestMessages_Editions_ForeignMessageEdition2023] { + get {_storage._repeatedForeignMessage} + set {_uniqueStorage()._repeatedForeignMessage = newValue} + } + + var repeatedNestedEnum: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] { + get {_storage._repeatedNestedEnum} + set {_uniqueStorage()._repeatedNestedEnum = newValue} + } + + var repeatedForeignEnum: [ProtobufTestMessages_Editions_ForeignEnumEdition2023] { + get {_storage._repeatedForeignEnum} + set {_uniqueStorage()._repeatedForeignEnum = newValue} + } + + var repeatedStringPiece: [String] { + get {_storage._repeatedStringPiece} + set {_uniqueStorage()._repeatedStringPiece = newValue} + } + + var repeatedCord: [String] { + get {_storage._repeatedCord} + set {_uniqueStorage()._repeatedCord = newValue} + } + + /// Packed + var packedInt32: [Int32] { + get {_storage._packedInt32} + set {_uniqueStorage()._packedInt32 = newValue} + } + + var packedInt64: [Int64] { + get {_storage._packedInt64} + set {_uniqueStorage()._packedInt64 = newValue} + } + + var packedUint32: [UInt32] { + get {_storage._packedUint32} + set {_uniqueStorage()._packedUint32 = newValue} + } + + var packedUint64: [UInt64] { + get {_storage._packedUint64} + set {_uniqueStorage()._packedUint64 = newValue} + } + + var packedSint32: [Int32] { + get {_storage._packedSint32} + set {_uniqueStorage()._packedSint32 = newValue} + } + + var packedSint64: [Int64] { + get {_storage._packedSint64} + set {_uniqueStorage()._packedSint64 = newValue} + } + + var packedFixed32: [UInt32] { + get {_storage._packedFixed32} + set {_uniqueStorage()._packedFixed32 = newValue} + } + + var packedFixed64: [UInt64] { + get {_storage._packedFixed64} + set {_uniqueStorage()._packedFixed64 = newValue} + } + + var packedSfixed32: [Int32] { + get {_storage._packedSfixed32} + set {_uniqueStorage()._packedSfixed32 = newValue} + } + + var packedSfixed64: [Int64] { + get {_storage._packedSfixed64} + set {_uniqueStorage()._packedSfixed64 = newValue} + } + + var packedFloat: [Float] { + get {_storage._packedFloat} + set {_uniqueStorage()._packedFloat = newValue} + } + + var packedDouble: [Double] { + get {_storage._packedDouble} + set {_uniqueStorage()._packedDouble = newValue} + } + + var packedBool: [Bool] { + get {_storage._packedBool} + set {_uniqueStorage()._packedBool = newValue} + } + + var packedNestedEnum: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] { + get {_storage._packedNestedEnum} + set {_uniqueStorage()._packedNestedEnum = newValue} + } + + /// Unpacked + var unpackedInt32: [Int32] { + get {_storage._unpackedInt32} + set {_uniqueStorage()._unpackedInt32 = newValue} + } + + var unpackedInt64: [Int64] { + get {_storage._unpackedInt64} + set {_uniqueStorage()._unpackedInt64 = newValue} + } + + var unpackedUint32: [UInt32] { + get {_storage._unpackedUint32} + set {_uniqueStorage()._unpackedUint32 = newValue} + } + + var unpackedUint64: [UInt64] { + get {_storage._unpackedUint64} + set {_uniqueStorage()._unpackedUint64 = newValue} + } + + var unpackedSint32: [Int32] { + get {_storage._unpackedSint32} + set {_uniqueStorage()._unpackedSint32 = newValue} + } + + var unpackedSint64: [Int64] { + get {_storage._unpackedSint64} + set {_uniqueStorage()._unpackedSint64 = newValue} + } + + var unpackedFixed32: [UInt32] { + get {_storage._unpackedFixed32} + set {_uniqueStorage()._unpackedFixed32 = newValue} + } + + var unpackedFixed64: [UInt64] { + get {_storage._unpackedFixed64} + set {_uniqueStorage()._unpackedFixed64 = newValue} + } + + var unpackedSfixed32: [Int32] { + get {_storage._unpackedSfixed32} + set {_uniqueStorage()._unpackedSfixed32 = newValue} + } + + var unpackedSfixed64: [Int64] { + get {_storage._unpackedSfixed64} + set {_uniqueStorage()._unpackedSfixed64 = newValue} + } + + var unpackedFloat: [Float] { + get {_storage._unpackedFloat} + set {_uniqueStorage()._unpackedFloat = newValue} + } + + var unpackedDouble: [Double] { + get {_storage._unpackedDouble} + set {_uniqueStorage()._unpackedDouble = newValue} + } + + var unpackedBool: [Bool] { + get {_storage._unpackedBool} + set {_uniqueStorage()._unpackedBool = newValue} + } + + var unpackedNestedEnum: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] { + get {_storage._unpackedNestedEnum} + set {_uniqueStorage()._unpackedNestedEnum = newValue} + } + + /// Map + var mapInt32Int32: Dictionary { + get {_storage._mapInt32Int32} + set {_uniqueStorage()._mapInt32Int32 = newValue} + } + + var mapInt64Int64: Dictionary { + get {_storage._mapInt64Int64} + set {_uniqueStorage()._mapInt64Int64 = newValue} + } + + var mapUint32Uint32: Dictionary { + get {_storage._mapUint32Uint32} + set {_uniqueStorage()._mapUint32Uint32 = newValue} + } + + var mapUint64Uint64: Dictionary { + get {_storage._mapUint64Uint64} + set {_uniqueStorage()._mapUint64Uint64 = newValue} + } + + var mapSint32Sint32: Dictionary { + get {_storage._mapSint32Sint32} + set {_uniqueStorage()._mapSint32Sint32 = newValue} + } + + var mapSint64Sint64: Dictionary { + get {_storage._mapSint64Sint64} + set {_uniqueStorage()._mapSint64Sint64 = newValue} + } + + var mapFixed32Fixed32: Dictionary { + get {_storage._mapFixed32Fixed32} + set {_uniqueStorage()._mapFixed32Fixed32 = newValue} + } + + var mapFixed64Fixed64: Dictionary { + get {_storage._mapFixed64Fixed64} + set {_uniqueStorage()._mapFixed64Fixed64 = newValue} + } + + var mapSfixed32Sfixed32: Dictionary { + get {_storage._mapSfixed32Sfixed32} + set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} + } + + var mapSfixed64Sfixed64: Dictionary { + get {_storage._mapSfixed64Sfixed64} + set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} + } + + var mapInt32Float: Dictionary { + get {_storage._mapInt32Float} + set {_uniqueStorage()._mapInt32Float = newValue} + } + + var mapInt32Double: Dictionary { + get {_storage._mapInt32Double} + set {_uniqueStorage()._mapInt32Double = newValue} + } + + var mapBoolBool: Dictionary { + get {_storage._mapBoolBool} + set {_uniqueStorage()._mapBoolBool = newValue} + } + + var mapStringString: Dictionary { + get {_storage._mapStringString} + set {_uniqueStorage()._mapStringString = newValue} + } + + var mapStringBytes: Dictionary { + get {_storage._mapStringBytes} + set {_uniqueStorage()._mapStringBytes = newValue} + } + + var mapStringNestedMessage: Dictionary { + get {_storage._mapStringNestedMessage} + set {_uniqueStorage()._mapStringNestedMessage = newValue} + } + + var mapStringForeignMessage: Dictionary { + get {_storage._mapStringForeignMessage} + set {_uniqueStorage()._mapStringForeignMessage = newValue} + } + + var mapStringNestedEnum: Dictionary { + get {_storage._mapStringNestedEnum} + set {_uniqueStorage()._mapStringNestedEnum = newValue} + } + + var mapStringForeignEnum: Dictionary { + get {_storage._mapStringForeignEnum} + set {_uniqueStorage()._mapStringForeignEnum = newValue} + } + + var oneofField: OneOf_OneofField? { + get {return _storage._oneofField} + set {_uniqueStorage()._oneofField = newValue} + } + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} + } + + var oneofNestedMessage: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage { + get { + if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} + return ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = _storage._oneofField {return v} + return Data() + } + set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} + } + + var oneofBool: Bool { + get { + if case .oneofBool(let v)? = _storage._oneofField {return v} + return false + } + set {_uniqueStorage()._oneofField = .oneofBool(newValue)} + } + + var oneofUint64: UInt64 { + get { + if case .oneofUint64(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint64(newValue)} + } + + var oneofFloat: Float { + get { + if case .oneofFloat(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofFloat(newValue)} + } + + var oneofDouble: Double { + get { + if case .oneofDouble(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofDouble(newValue)} + } + + var oneofEnum: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum { + get { + if case .oneofEnum(let v)? = _storage._oneofField {return v} + return .foo + } + set {_uniqueStorage()._oneofField = .oneofEnum(newValue)} + } + + var groupLikeType: ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType { + get {_storage._groupLikeType ?? ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType()} + set {_uniqueStorage()._groupLikeType = newValue} + } + /// Returns true if `groupLikeType` has been explicitly set. + var hasGroupLikeType: Bool {_storage._groupLikeType != nil} + /// Clears the value of `groupLikeType`. Subsequent reads from it will return its default value. + mutating func clearGroupLikeType() {_uniqueStorage()._groupLikeType = nil} + + var delimitedField: ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType { + get {_storage._delimitedField ?? ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType()} + set {_uniqueStorage()._delimitedField = newValue} + } + /// Returns true if `delimitedField` has been explicitly set. + var hasDelimitedField: Bool {_storage._delimitedField != nil} + /// Clears the value of `delimitedField`. Subsequent reads from it will return its default value. + mutating func clearDelimitedField() {_uniqueStorage()._delimitedField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofNestedMessage(ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage) + case oneofString(String) + case oneofBytes(Data) + case oneofBool(Bool) + case oneofUint64(UInt64) + case oneofFloat(Float) + case oneofDouble(Double) + case oneofEnum(ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum) + + fileprivate var isInitialized: Bool { + guard case .oneofNestedMessage(let v) = self else {return true} + return v.isInitialized + } + + } + + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foo // = 0 + case bar // = 1 + case baz // = 2 + + /// Intentionally negative. + case neg // = -1 + case UNRECOGNIZED(Int) + + init() { + self = .foo + } + + init?(rawValue: Int) { + switch rawValue { + case -1: self = .neg + case 0: self = .foo + case 1: self = .bar + case 2: self = .baz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .neg: return -1 + case .foo: return 0 + case .bar: return 1 + case .baz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] = [ + .foo, + .bar, + .baz, + .neg, + ] + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var corecursive: ProtobufTestMessages_Editions_TestAllTypesEdition2023 { + get {_storage._corecursive ?? ProtobufTestMessages_Editions_TestAllTypesEdition2023()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + /// groups + struct GroupLikeType: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct ProtobufTestMessages_Editions_ForeignMessageEdition2023: Sendable { + // 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 c: Int32 { + get {_c ?? 0} + set {_c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {self._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {self._c = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _c: Int32? = nil +} + +struct ProtobufTestMessages_Editions_GroupLikeType: Sendable { + // 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 c: Int32 { + get {_c ?? 0} + set {_c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {self._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {self._c = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _c: Int32? = nil +} + +// MARK: - Extension support defined in test_messages_edition2023.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 ProtobufTestMessages_Editions_TestAllTypesEdition2023 { + + var ProtobufTestMessages_Editions_extensionInt32: Int32 { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_extension_int32) ?? 0} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_extension_int32, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Extensions_extension_int32` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_extensionInt32: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_extension_int32) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Extensions_extension_int32`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_extensionInt32() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_extension_int32) + } + + var ProtobufTestMessages_Editions_groupLikeType: ProtobufTestMessages_Editions_GroupLikeType { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_GroupLikeType) ?? ProtobufTestMessages_Editions_GroupLikeType()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_GroupLikeType, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Extensions_GroupLikeType` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_groupLikeType: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_GroupLikeType) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Extensions_GroupLikeType`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_groupLikeType() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_GroupLikeType) + } + + var ProtobufTestMessages_Editions_delimitedExt: ProtobufTestMessages_Editions_GroupLikeType { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_delimited_ext) ?? ProtobufTestMessages_Editions_GroupLikeType()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_delimited_ext, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Extensions_delimited_ext` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_delimitedExt: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_delimited_ext) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Extensions_delimited_ext`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_delimitedExt() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_delimited_ext) + } + +} + +// MARK: - File's ExtensionMap: ProtobufTestMessages_Editions_TestMessagesEdition2023_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 ProtobufTestMessages_Editions_TestMessagesEdition2023_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + ProtobufTestMessages_Editions_Extensions_extension_int32, + ProtobufTestMessages_Editions_Extensions_GroupLikeType, + ProtobufTestMessages_Editions_Extensions_delimited_ext +] + +// 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 ProtobufTestMessages_Editions_Extensions_extension_int32 = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_TestAllTypesEdition2023>( + _protobuf_fieldNumber: 120, + fieldName: "protobuf_test_messages.editions.extension_int32" +) + +let ProtobufTestMessages_Editions_Extensions_GroupLikeType = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_TestAllTypesEdition2023>( + _protobuf_fieldNumber: 121, + fieldName: "protobuf_test_messages.editions.groupliketype" +) + +let ProtobufTestMessages_Editions_Extensions_delimited_ext = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_TestAllTypesEdition2023>( + _protobuf_fieldNumber: 122, + fieldName: "protobuf_test_messages.editions.delimited_ext" +) + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "protobuf_test_messages.editions" + +extension ProtobufTestMessages_Editions_ForeignEnumEdition2023: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") +} + +extension ProtobufTestMessages_Editions_ComplexMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ComplexMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}d\0") + + 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._d) }() + 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 + try { if let v = self._d { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_ComplexMessage, rhs: ProtobufTestMessages_Editions_ComplexMessage) -> Bool { + if lhs._d != rhs._d {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_TestAllTypesEdition2023: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypesEdition2023" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{4}\u{2}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{4}\u{2}optional_string_piece\0\u{3}optional_cord\0\u{4}\u{2}recursive_message\0\u{4}\u{4}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{4}\u{2}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_nested_message\0\u{3}map_string_foreign_message\0\u{3}map_string_nested_enum\0\u{3}map_string_foreign_enum\0\u{3}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_nested_enum\0\u{3}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_nested_enum\0\u{4}\u{9}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_bool\0\u{3}oneof_uint64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_enum\0\u{8}R\u{1}GroupLikeType\0\u{3}delimited_field\0") + + fileprivate class _StorageClass { + var _optionalInt32: Int32? = nil + var _optionalInt64: Int64? = nil + var _optionalUint32: UInt32? = nil + var _optionalUint64: UInt64? = nil + var _optionalSint32: Int32? = nil + var _optionalSint64: Int64? = nil + var _optionalFixed32: UInt32? = nil + var _optionalFixed64: UInt64? = nil + var _optionalSfixed32: Int32? = nil + var _optionalSfixed64: Int64? = nil + var _optionalFloat: Float? = nil + var _optionalDouble: Double? = nil + var _optionalBool: Bool? = nil + var _optionalString: String? = nil + var _optionalBytes: Data? = nil + var _optionalNestedMessage: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage? = nil + var _optionalForeignMessage: ProtobufTestMessages_Editions_ForeignMessageEdition2023? = nil + var _optionalNestedEnum: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum? = nil + var _optionalForeignEnum: ProtobufTestMessages_Editions_ForeignEnumEdition2023? = nil + var _optionalStringPiece: String? = nil + var _optionalCord: String? = nil + var _recursiveMessage: ProtobufTestMessages_Editions_TestAllTypesEdition2023? = nil + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedNestedMessage: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage] = [] + var _repeatedForeignMessage: [ProtobufTestMessages_Editions_ForeignMessageEdition2023] = [] + var _repeatedNestedEnum: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] = [] + var _repeatedForeignEnum: [ProtobufTestMessages_Editions_ForeignEnumEdition2023] = [] + var _repeatedStringPiece: [String] = [] + var _repeatedCord: [String] = [] + var _packedInt32: [Int32] = [] + var _packedInt64: [Int64] = [] + var _packedUint32: [UInt32] = [] + var _packedUint64: [UInt64] = [] + var _packedSint32: [Int32] = [] + var _packedSint64: [Int64] = [] + var _packedFixed32: [UInt32] = [] + var _packedFixed64: [UInt64] = [] + var _packedSfixed32: [Int32] = [] + var _packedSfixed64: [Int64] = [] + var _packedFloat: [Float] = [] + var _packedDouble: [Double] = [] + var _packedBool: [Bool] = [] + var _packedNestedEnum: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] = [] + var _unpackedInt32: [Int32] = [] + var _unpackedInt64: [Int64] = [] + var _unpackedUint32: [UInt32] = [] + var _unpackedUint64: [UInt64] = [] + var _unpackedSint32: [Int32] = [] + var _unpackedSint64: [Int64] = [] + var _unpackedFixed32: [UInt32] = [] + var _unpackedFixed64: [UInt64] = [] + var _unpackedSfixed32: [Int32] = [] + var _unpackedSfixed64: [Int64] = [] + var _unpackedFloat: [Float] = [] + var _unpackedDouble: [Double] = [] + var _unpackedBool: [Bool] = [] + var _unpackedNestedEnum: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] = [] + var _mapInt32Int32: Dictionary = [:] + var _mapInt64Int64: Dictionary = [:] + var _mapUint32Uint32: Dictionary = [:] + var _mapUint64Uint64: Dictionary = [:] + var _mapSint32Sint32: Dictionary = [:] + var _mapSint64Sint64: Dictionary = [:] + var _mapFixed32Fixed32: Dictionary = [:] + var _mapFixed64Fixed64: Dictionary = [:] + var _mapSfixed32Sfixed32: Dictionary = [:] + var _mapSfixed64Sfixed64: Dictionary = [:] + var _mapInt32Float: Dictionary = [:] + var _mapInt32Double: Dictionary = [:] + var _mapBoolBool: Dictionary = [:] + var _mapStringString: Dictionary = [:] + var _mapStringBytes: Dictionary = [:] + var _mapStringNestedMessage: Dictionary = [:] + var _mapStringForeignMessage: Dictionary = [:] + var _mapStringNestedEnum: Dictionary = [:] + var _mapStringForeignEnum: Dictionary = [:] + var _oneofField: ProtobufTestMessages_Editions_TestAllTypesEdition2023.OneOf_OneofField? + var _groupLikeType: ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType? = nil + var _delimitedField: ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalNestedMessage = source._optionalNestedMessage + _optionalForeignMessage = source._optionalForeignMessage + _optionalNestedEnum = source._optionalNestedEnum + _optionalForeignEnum = source._optionalForeignEnum + _optionalStringPiece = source._optionalStringPiece + _optionalCord = source._optionalCord + _recursiveMessage = source._recursiveMessage + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedForeignMessage = source._repeatedForeignMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _repeatedForeignEnum = source._repeatedForeignEnum + _repeatedStringPiece = source._repeatedStringPiece + _repeatedCord = source._repeatedCord + _packedInt32 = source._packedInt32 + _packedInt64 = source._packedInt64 + _packedUint32 = source._packedUint32 + _packedUint64 = source._packedUint64 + _packedSint32 = source._packedSint32 + _packedSint64 = source._packedSint64 + _packedFixed32 = source._packedFixed32 + _packedFixed64 = source._packedFixed64 + _packedSfixed32 = source._packedSfixed32 + _packedSfixed64 = source._packedSfixed64 + _packedFloat = source._packedFloat + _packedDouble = source._packedDouble + _packedBool = source._packedBool + _packedNestedEnum = source._packedNestedEnum + _unpackedInt32 = source._unpackedInt32 + _unpackedInt64 = source._unpackedInt64 + _unpackedUint32 = source._unpackedUint32 + _unpackedUint64 = source._unpackedUint64 + _unpackedSint32 = source._unpackedSint32 + _unpackedSint64 = source._unpackedSint64 + _unpackedFixed32 = source._unpackedFixed32 + _unpackedFixed64 = source._unpackedFixed64 + _unpackedSfixed32 = source._unpackedSfixed32 + _unpackedSfixed64 = source._unpackedSfixed64 + _unpackedFloat = source._unpackedFloat + _unpackedDouble = source._unpackedDouble + _unpackedBool = source._unpackedBool + _unpackedNestedEnum = source._unpackedNestedEnum + _mapInt32Int32 = source._mapInt32Int32 + _mapInt64Int64 = source._mapInt64Int64 + _mapUint32Uint32 = source._mapUint32Uint32 + _mapUint64Uint64 = source._mapUint64Uint64 + _mapSint32Sint32 = source._mapSint32Sint32 + _mapSint64Sint64 = source._mapSint64Sint64 + _mapFixed32Fixed32 = source._mapFixed32Fixed32 + _mapFixed64Fixed64 = source._mapFixed64Fixed64 + _mapSfixed32Sfixed32 = source._mapSfixed32Sfixed32 + _mapSfixed64Sfixed64 = source._mapSfixed64Sfixed64 + _mapInt32Float = source._mapInt32Float + _mapInt32Double = source._mapInt32Double + _mapBoolBool = source._mapBoolBool + _mapStringString = source._mapStringString + _mapStringBytes = source._mapStringBytes + _mapStringNestedMessage = source._mapStringNestedMessage + _mapStringForeignMessage = source._mapStringForeignMessage + _mapStringNestedEnum = source._mapStringNestedEnum + _mapStringForeignEnum = source._mapStringForeignEnum + _oneofField = source._oneofField + _groupLikeType = source._groupLikeType + _delimitedField = source._delimitedField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._optionalNestedMessage, !v.isInitialized {return false} + if let v = _storage._recursiveMessage, !v.isInitialized {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._repeatedNestedMessage) {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._mapStringNestedMessage) {return false} + if let v = _storage._oneofField, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() + case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() + case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() + case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() + case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() + case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() + case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() + case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() + case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() + case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() + case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() + case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() + case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() + case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() + case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() + case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() + case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() + case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() + case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() + case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() + case 56: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Int32) }() + case 57: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() + case 58: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() + case 59: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Uint64) }() + case 60: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Sint32) }() + case 61: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Sint64) }() + case 62: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Fixed32) }() + case 63: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Fixed64) }() + case 64: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Sfixed32) }() + case 65: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Sfixed64) }() + case 66: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Float) }() + case 67: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Double) }() + case 68: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() + case 69: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() + case 70: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() + case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringNestedMessage) }() + case 72: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() + case 73: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringNestedEnum) }() + case 74: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringForeignEnum) }() + case 75: try { try decoder.decodeRepeatedInt32Field(value: &_storage._packedInt32) }() + case 76: try { try decoder.decodeRepeatedInt64Field(value: &_storage._packedInt64) }() + case 77: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._packedUint32) }() + case 78: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._packedUint64) }() + case 79: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._packedSint32) }() + case 80: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._packedSint64) }() + case 81: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._packedFixed32) }() + case 82: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._packedFixed64) }() + case 83: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._packedSfixed32) }() + case 84: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._packedSfixed64) }() + case 85: try { try decoder.decodeRepeatedFloatField(value: &_storage._packedFloat) }() + case 86: try { try decoder.decodeRepeatedDoubleField(value: &_storage._packedDouble) }() + case 87: try { try decoder.decodeRepeatedBoolField(value: &_storage._packedBool) }() + case 88: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedNestedEnum) }() + case 89: try { try decoder.decodeRepeatedInt32Field(value: &_storage._unpackedInt32) }() + case 90: try { try decoder.decodeRepeatedInt64Field(value: &_storage._unpackedInt64) }() + case 91: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._unpackedUint32) }() + case 92: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._unpackedUint64) }() + case 93: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._unpackedSint32) }() + case 94: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._unpackedSint64) }() + case 95: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._unpackedFixed32) }() + case 96: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._unpackedFixed64) }() + case 97: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._unpackedSfixed32) }() + case 98: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._unpackedSfixed64) }() + case 99: try { try decoder.decodeRepeatedFloatField(value: &_storage._unpackedFloat) }() + case 100: try { try decoder.decodeRepeatedDoubleField(value: &_storage._unpackedDouble) }() + case 101: try { try decoder.decodeRepeatedBoolField(value: &_storage._unpackedBool) }() + case 102: try { try decoder.decodeRepeatedEnumField(value: &_storage._unpackedNestedEnum) }() + case 111: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 112: try { + var v: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage(v) + } + }() + case 113: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 114: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() + case 115: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBool(v) + } + }() + case 116: try { + var v: UInt64? + try decoder.decodeSingularUInt64Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint64(v) + } + }() + case 117: try { + var v: Float? + try decoder.decodeSingularFloatField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofFloat(v) + } + }() + case 118: try { + var v: Double? + try decoder.decodeSingularDoubleField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofDouble(v) + } + }() + case 119: try { + var v: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofEnum(v) + } + }() + case 201: try { try decoder.decodeSingularGroupField(value: &_storage._groupLikeType) }() + case 202: try { try decoder.decodeSingularGroupField(value: &_storage._delimitedField) }() + case 120..<201: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Editions_TestAllTypesEdition2023.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._optionalInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._optionalUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._optionalSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._optionalSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._optionalFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._optionalFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._optionalSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._optionalSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._optionalFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._optionalDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._optionalBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._optionalForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._optionalNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._optionalForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._optionalStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._optionalCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + if !_storage._repeatedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + } + if !_storage._repeatedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + } + if !_storage._repeatedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + } + if !_storage._repeatedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + } + if !_storage._repeatedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + } + if !_storage._repeatedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + } + if !_storage._repeatedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + } + if !_storage._repeatedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + } + if !_storage._repeatedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + } + if !_storage._repeatedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + } + if !_storage._repeatedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + } + if !_storage._repeatedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + } + if !_storage._repeatedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + } + if !_storage._repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) + } + if !_storage._repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) + } + if !_storage._repeatedNestedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) + } + if !_storage._repeatedForeignMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) + } + if !_storage._repeatedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + } + if !_storage._repeatedForeignEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) + } + if !_storage._repeatedStringPiece.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) + } + if !_storage._repeatedCord.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) + } + if !_storage._mapInt32Int32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Int32, fieldNumber: 56) + } + if !_storage._mapInt64Int64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Int64, fieldNumber: 57) + } + if !_storage._mapUint32Uint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Uint32, fieldNumber: 58) + } + if !_storage._mapUint64Uint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Uint64, fieldNumber: 59) + } + if !_storage._mapSint32Sint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Sint32, fieldNumber: 60) + } + if !_storage._mapSint64Sint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Sint64, fieldNumber: 61) + } + if !_storage._mapFixed32Fixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Fixed32, fieldNumber: 62) + } + if !_storage._mapFixed64Fixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Fixed64, fieldNumber: 63) + } + if !_storage._mapSfixed32Sfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 64) + } + if !_storage._mapSfixed64Sfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 65) + } + if !_storage._mapInt32Float.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Float, fieldNumber: 66) + } + if !_storage._mapInt32Double.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Double, fieldNumber: 67) + } + if !_storage._mapBoolBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolBool, fieldNumber: 68) + } + if !_storage._mapStringString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringString, fieldNumber: 69) + } + if !_storage._mapStringBytes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 70) + } + if !_storage._mapStringNestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringNestedMessage, fieldNumber: 71) + } + if !_storage._mapStringForeignMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 72) + } + if !_storage._mapStringNestedEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringNestedEnum, fieldNumber: 73) + } + if !_storage._mapStringForeignEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringForeignEnum, fieldNumber: 74) + } + if !_storage._packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._packedInt32, fieldNumber: 75) + } + if !_storage._packedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._packedInt64, fieldNumber: 76) + } + if !_storage._packedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._packedUint32, fieldNumber: 77) + } + if !_storage._packedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._packedUint64, fieldNumber: 78) + } + if !_storage._packedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._packedSint32, fieldNumber: 79) + } + if !_storage._packedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._packedSint64, fieldNumber: 80) + } + if !_storage._packedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._packedFixed32, fieldNumber: 81) + } + if !_storage._packedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._packedFixed64, fieldNumber: 82) + } + if !_storage._packedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._packedSfixed32, fieldNumber: 83) + } + if !_storage._packedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._packedSfixed64, fieldNumber: 84) + } + if !_storage._packedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._packedFloat, fieldNumber: 85) + } + if !_storage._packedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._packedDouble, fieldNumber: 86) + } + if !_storage._packedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._packedBool, fieldNumber: 87) + } + if !_storage._packedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedNestedEnum, fieldNumber: 88) + } + if !_storage._unpackedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._unpackedInt32, fieldNumber: 89) + } + if !_storage._unpackedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._unpackedInt64, fieldNumber: 90) + } + if !_storage._unpackedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._unpackedUint32, fieldNumber: 91) + } + if !_storage._unpackedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._unpackedUint64, fieldNumber: 92) + } + if !_storage._unpackedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._unpackedSint32, fieldNumber: 93) + } + if !_storage._unpackedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._unpackedSint64, fieldNumber: 94) + } + if !_storage._unpackedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._unpackedFixed32, fieldNumber: 95) + } + if !_storage._unpackedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._unpackedFixed64, fieldNumber: 96) + } + if !_storage._unpackedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._unpackedSfixed32, fieldNumber: 97) + } + if !_storage._unpackedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._unpackedSfixed64, fieldNumber: 98) + } + if !_storage._unpackedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._unpackedFloat, fieldNumber: 99) + } + if !_storage._unpackedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._unpackedDouble, fieldNumber: 100) + } + if !_storage._unpackedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._unpackedBool, fieldNumber: 101) + } + if !_storage._unpackedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._unpackedNestedEnum, fieldNumber: 102) + } + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case .oneofBool?: try { + guard case .oneofBool(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 115) + }() + case .oneofUint64?: try { + guard case .oneofUint64(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 116) + }() + case .oneofFloat?: try { + guard case .oneofFloat(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularFloatField(value: v, fieldNumber: 117) + }() + case .oneofDouble?: try { + guard case .oneofDouble(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularDoubleField(value: v, fieldNumber: 118) + }() + case .oneofEnum?: try { + guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 119) + }() + case nil: break + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201) + try { if let v = _storage._groupLikeType { + try visitor.visitSingularGroupField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._delimitedField { + try visitor.visitSingularGroupField(value: v, fieldNumber: 202) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_TestAllTypesEdition2023, rhs: ProtobufTestMessages_Editions_TestAllTypesEdition2023) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} + if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} + if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} + if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} + if _storage._repeatedCord != rhs_storage._repeatedCord {return false} + if _storage._packedInt32 != rhs_storage._packedInt32 {return false} + if _storage._packedInt64 != rhs_storage._packedInt64 {return false} + if _storage._packedUint32 != rhs_storage._packedUint32 {return false} + if _storage._packedUint64 != rhs_storage._packedUint64 {return false} + if _storage._packedSint32 != rhs_storage._packedSint32 {return false} + if _storage._packedSint64 != rhs_storage._packedSint64 {return false} + if _storage._packedFixed32 != rhs_storage._packedFixed32 {return false} + if _storage._packedFixed64 != rhs_storage._packedFixed64 {return false} + if _storage._packedSfixed32 != rhs_storage._packedSfixed32 {return false} + if _storage._packedSfixed64 != rhs_storage._packedSfixed64 {return false} + if _storage._packedFloat != rhs_storage._packedFloat {return false} + if _storage._packedDouble != rhs_storage._packedDouble {return false} + if _storage._packedBool != rhs_storage._packedBool {return false} + if _storage._packedNestedEnum != rhs_storage._packedNestedEnum {return false} + if _storage._unpackedInt32 != rhs_storage._unpackedInt32 {return false} + if _storage._unpackedInt64 != rhs_storage._unpackedInt64 {return false} + if _storage._unpackedUint32 != rhs_storage._unpackedUint32 {return false} + if _storage._unpackedUint64 != rhs_storage._unpackedUint64 {return false} + if _storage._unpackedSint32 != rhs_storage._unpackedSint32 {return false} + if _storage._unpackedSint64 != rhs_storage._unpackedSint64 {return false} + if _storage._unpackedFixed32 != rhs_storage._unpackedFixed32 {return false} + if _storage._unpackedFixed64 != rhs_storage._unpackedFixed64 {return false} + if _storage._unpackedSfixed32 != rhs_storage._unpackedSfixed32 {return false} + if _storage._unpackedSfixed64 != rhs_storage._unpackedSfixed64 {return false} + if _storage._unpackedFloat != rhs_storage._unpackedFloat {return false} + if _storage._unpackedDouble != rhs_storage._unpackedDouble {return false} + if _storage._unpackedBool != rhs_storage._unpackedBool {return false} + if _storage._unpackedNestedEnum != rhs_storage._unpackedNestedEnum {return false} + if _storage._mapInt32Int32 != rhs_storage._mapInt32Int32 {return false} + if _storage._mapInt64Int64 != rhs_storage._mapInt64Int64 {return false} + if _storage._mapUint32Uint32 != rhs_storage._mapUint32Uint32 {return false} + if _storage._mapUint64Uint64 != rhs_storage._mapUint64Uint64 {return false} + if _storage._mapSint32Sint32 != rhs_storage._mapSint32Sint32 {return false} + if _storage._mapSint64Sint64 != rhs_storage._mapSint64Sint64 {return false} + if _storage._mapFixed32Fixed32 != rhs_storage._mapFixed32Fixed32 {return false} + if _storage._mapFixed64Fixed64 != rhs_storage._mapFixed64Fixed64 {return false} + if _storage._mapSfixed32Sfixed32 != rhs_storage._mapSfixed32Sfixed32 {return false} + if _storage._mapSfixed64Sfixed64 != rhs_storage._mapSfixed64Sfixed64 {return false} + if _storage._mapInt32Float != rhs_storage._mapInt32Float {return false} + if _storage._mapInt32Double != rhs_storage._mapInt32Double {return false} + if _storage._mapBoolBool != rhs_storage._mapBoolBool {return false} + if _storage._mapStringString != rhs_storage._mapStringString {return false} + if _storage._mapStringBytes != rhs_storage._mapStringBytes {return false} + if _storage._mapStringNestedMessage != rhs_storage._mapStringNestedMessage {return false} + if _storage._mapStringForeignMessage != rhs_storage._mapStringForeignMessage {return false} + if _storage._mapStringNestedEnum != rhs_storage._mapStringNestedEnum {return false} + if _storage._mapStringForeignEnum != rhs_storage._mapStringForeignEnum {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + if _storage._groupLikeType != rhs_storage._groupLikeType {return false} + if _storage._delimitedField != rhs_storage._delimitedField {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_TestAllTypesEdition2023.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _corecursive: ProtobufTestMessages_Editions_TestAllTypesEdition2023? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._corecursive, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage, rhs: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_TestAllTypesEdition2023.protoMessageName + ".GroupLikeType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}J\u{3}group_int32\0\u{3}group_uint32\0") + + 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 202: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 203: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 202) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 203) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType, rhs: ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_ForeignMessageEdition2023: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessageEdition2023" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") + + 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._c) }() + 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 + try { if let v = self._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_ForeignMessageEdition2023, rhs: ProtobufTestMessages_Editions_ForeignMessageEdition2023) -> Bool { + if lhs._c != rhs._c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_GroupLikeType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GroupLikeType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") + + 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._c) }() + 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 + try { if let v = self._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_GroupLikeType, rhs: ProtobufTestMessages_Editions_GroupLikeType) -> Bool { + if lhs._c != rhs._c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/editions/golden/test_messages_proto2_editions.pb.swift b/Reference/upstream/editions/golden/test_messages_proto2_editions.pb.swift new file mode 100644 index 000000000..4ef883387 --- /dev/null +++ b/Reference/upstream/editions/golden/test_messages_proto2_editions.pb.swift @@ -0,0 +1,4828 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: editions/golden/test_messages_proto2_editions.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// clang-format off +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Test schema for proto2 messages. This test schema is used by: +// +// - conformance tests + +// LINT: ALLOW_GROUPS + +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 ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foreignFoo = 0 + case foreignBar = 1 + case foreignBaz = 2 + + init() { + self = .foreignFoo + } + +} + +/// This proto includes every type of field in both singular and repeated +/// forms. +/// +/// Also, crucially, all messages and enums in this file are eventually +/// submessages of this message. So for example, a fuzz test of TestAllTypes +/// could trigger bugs that occur in any message type in this file. We verify +/// this stays true in a unit test. +struct ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Singular + var optionalInt32: Int32 { + get {_storage._optionalInt32 ?? 0} + set {_uniqueStorage()._optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} + + var optionalInt64: Int64 { + get {_storage._optionalInt64 ?? 0} + set {_uniqueStorage()._optionalInt64 = newValue} + } + /// Returns true if `optionalInt64` has been explicitly set. + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} + /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} + + var optionalUint32: UInt32 { + get {_storage._optionalUint32 ?? 0} + set {_uniqueStorage()._optionalUint32 = newValue} + } + /// Returns true if `optionalUint32` has been explicitly set. + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} + /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} + + var optionalUint64: UInt64 { + get {_storage._optionalUint64 ?? 0} + set {_uniqueStorage()._optionalUint64 = newValue} + } + /// Returns true if `optionalUint64` has been explicitly set. + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} + /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} + + var optionalSint32: Int32 { + get {_storage._optionalSint32 ?? 0} + set {_uniqueStorage()._optionalSint32 = newValue} + } + /// Returns true if `optionalSint32` has been explicitly set. + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} + /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} + + var optionalSint64: Int64 { + get {_storage._optionalSint64 ?? 0} + set {_uniqueStorage()._optionalSint64 = newValue} + } + /// Returns true if `optionalSint64` has been explicitly set. + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} + /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} + + var optionalFixed32: UInt32 { + get {_storage._optionalFixed32 ?? 0} + set {_uniqueStorage()._optionalFixed32 = newValue} + } + /// Returns true if `optionalFixed32` has been explicitly set. + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} + /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} + + var optionalFixed64: UInt64 { + get {_storage._optionalFixed64 ?? 0} + set {_uniqueStorage()._optionalFixed64 = newValue} + } + /// Returns true if `optionalFixed64` has been explicitly set. + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} + /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} + + var optionalSfixed32: Int32 { + get {_storage._optionalSfixed32 ?? 0} + set {_uniqueStorage()._optionalSfixed32 = newValue} + } + /// Returns true if `optionalSfixed32` has been explicitly set. + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} + /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} + + var optionalSfixed64: Int64 { + get {_storage._optionalSfixed64 ?? 0} + set {_uniqueStorage()._optionalSfixed64 = newValue} + } + /// Returns true if `optionalSfixed64` has been explicitly set. + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} + /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} + + var optionalFloat: Float { + get {_storage._optionalFloat ?? 0} + set {_uniqueStorage()._optionalFloat = newValue} + } + /// Returns true if `optionalFloat` has been explicitly set. + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} + /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} + + var optionalDouble: Double { + get {_storage._optionalDouble ?? 0} + set {_uniqueStorage()._optionalDouble = newValue} + } + /// Returns true if `optionalDouble` has been explicitly set. + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} + /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. + mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} + + var optionalBool: Bool { + get {_storage._optionalBool ?? false} + set {_uniqueStorage()._optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {_storage._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} + + var optionalString: String { + get {_storage._optionalString ?? String()} + set {_uniqueStorage()._optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {_storage._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} + + var optionalBytes: Data { + get {_storage._optionalBytes ?? Data()} + set {_uniqueStorage()._optionalBytes = newValue} + } + /// Returns true if `optionalBytes` has been explicitly set. + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} + /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} + + var optionalNestedMessage: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage { + get {_storage._optionalNestedMessage ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage()} + set {_uniqueStorage()._optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} + + var optionalForeignMessage: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2 { + get {_storage._optionalForeignMessage ?? ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2()} + set {_uniqueStorage()._optionalForeignMessage = newValue} + } + /// Returns true if `optionalForeignMessage` has been explicitly set. + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} + /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} + + var optionalNestedEnum: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum { + get {_storage._optionalNestedEnum ?? .foo} + set {_uniqueStorage()._optionalNestedEnum = newValue} + } + /// Returns true if `optionalNestedEnum` has been explicitly set. + var hasOptionalNestedEnum: Bool {_storage._optionalNestedEnum != nil} + /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} + + var optionalForeignEnum: ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2 { + get {_storage._optionalForeignEnum ?? .foreignFoo} + set {_uniqueStorage()._optionalForeignEnum = newValue} + } + /// Returns true if `optionalForeignEnum` has been explicitly set. + var hasOptionalForeignEnum: Bool {_storage._optionalForeignEnum != nil} + /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignEnum() {_uniqueStorage()._optionalForeignEnum = nil} + + var optionalStringPiece: String { + get {_storage._optionalStringPiece ?? String()} + set {_uniqueStorage()._optionalStringPiece = newValue} + } + /// Returns true if `optionalStringPiece` has been explicitly set. + var hasOptionalStringPiece: Bool {_storage._optionalStringPiece != nil} + /// Clears the value of `optionalStringPiece`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringPiece() {_uniqueStorage()._optionalStringPiece = nil} + + var optionalCord: String { + get {_storage._optionalCord ?? String()} + set {_uniqueStorage()._optionalCord = newValue} + } + /// Returns true if `optionalCord` has been explicitly set. + var hasOptionalCord: Bool {_storage._optionalCord != nil} + /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. + mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} + + var recursiveMessage: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2 { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2()} + set {_uniqueStorage()._recursiveMessage = newValue} + } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} + + /// Repeated + var repeatedInt32: [Int32] { + get {_storage._repeatedInt32} + set {_uniqueStorage()._repeatedInt32 = newValue} + } + + var repeatedInt64: [Int64] { + get {_storage._repeatedInt64} + set {_uniqueStorage()._repeatedInt64 = newValue} + } + + var repeatedUint32: [UInt32] { + get {_storage._repeatedUint32} + set {_uniqueStorage()._repeatedUint32 = newValue} + } + + var repeatedUint64: [UInt64] { + get {_storage._repeatedUint64} + set {_uniqueStorage()._repeatedUint64 = newValue} + } + + var repeatedSint32: [Int32] { + get {_storage._repeatedSint32} + set {_uniqueStorage()._repeatedSint32 = newValue} + } + + var repeatedSint64: [Int64] { + get {_storage._repeatedSint64} + set {_uniqueStorage()._repeatedSint64 = newValue} + } + + var repeatedFixed32: [UInt32] { + get {_storage._repeatedFixed32} + set {_uniqueStorage()._repeatedFixed32 = newValue} + } + + var repeatedFixed64: [UInt64] { + get {_storage._repeatedFixed64} + set {_uniqueStorage()._repeatedFixed64 = newValue} + } + + var repeatedSfixed32: [Int32] { + get {_storage._repeatedSfixed32} + set {_uniqueStorage()._repeatedSfixed32 = newValue} + } + + var repeatedSfixed64: [Int64] { + get {_storage._repeatedSfixed64} + set {_uniqueStorage()._repeatedSfixed64 = newValue} + } + + var repeatedFloat: [Float] { + get {_storage._repeatedFloat} + set {_uniqueStorage()._repeatedFloat = newValue} + } + + var repeatedDouble: [Double] { + get {_storage._repeatedDouble} + set {_uniqueStorage()._repeatedDouble = newValue} + } + + var repeatedBool: [Bool] { + get {_storage._repeatedBool} + set {_uniqueStorage()._repeatedBool = newValue} + } + + var repeatedString: [String] { + get {_storage._repeatedString} + set {_uniqueStorage()._repeatedString = newValue} + } + + var repeatedBytes: [Data] { + get {_storage._repeatedBytes} + set {_uniqueStorage()._repeatedBytes = newValue} + } + + var repeatedNestedMessage: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage] { + get {_storage._repeatedNestedMessage} + set {_uniqueStorage()._repeatedNestedMessage = newValue} + } + + var repeatedForeignMessage: [ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2] { + get {_storage._repeatedForeignMessage} + set {_uniqueStorage()._repeatedForeignMessage = newValue} + } + + var repeatedNestedEnum: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum] { + get {_storage._repeatedNestedEnum} + set {_uniqueStorage()._repeatedNestedEnum = newValue} + } + + var repeatedForeignEnum: [ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2] { + get {_storage._repeatedForeignEnum} + set {_uniqueStorage()._repeatedForeignEnum = newValue} + } + + var repeatedStringPiece: [String] { + get {_storage._repeatedStringPiece} + set {_uniqueStorage()._repeatedStringPiece = newValue} + } + + var repeatedCord: [String] { + get {_storage._repeatedCord} + set {_uniqueStorage()._repeatedCord = newValue} + } + + /// Packed + var packedInt32: [Int32] { + get {_storage._packedInt32} + set {_uniqueStorage()._packedInt32 = newValue} + } + + var packedInt64: [Int64] { + get {_storage._packedInt64} + set {_uniqueStorage()._packedInt64 = newValue} + } + + var packedUint32: [UInt32] { + get {_storage._packedUint32} + set {_uniqueStorage()._packedUint32 = newValue} + } + + var packedUint64: [UInt64] { + get {_storage._packedUint64} + set {_uniqueStorage()._packedUint64 = newValue} + } + + var packedSint32: [Int32] { + get {_storage._packedSint32} + set {_uniqueStorage()._packedSint32 = newValue} + } + + var packedSint64: [Int64] { + get {_storage._packedSint64} + set {_uniqueStorage()._packedSint64 = newValue} + } + + var packedFixed32: [UInt32] { + get {_storage._packedFixed32} + set {_uniqueStorage()._packedFixed32 = newValue} + } + + var packedFixed64: [UInt64] { + get {_storage._packedFixed64} + set {_uniqueStorage()._packedFixed64 = newValue} + } + + var packedSfixed32: [Int32] { + get {_storage._packedSfixed32} + set {_uniqueStorage()._packedSfixed32 = newValue} + } + + var packedSfixed64: [Int64] { + get {_storage._packedSfixed64} + set {_uniqueStorage()._packedSfixed64 = newValue} + } + + var packedFloat: [Float] { + get {_storage._packedFloat} + set {_uniqueStorage()._packedFloat = newValue} + } + + var packedDouble: [Double] { + get {_storage._packedDouble} + set {_uniqueStorage()._packedDouble = newValue} + } + + var packedBool: [Bool] { + get {_storage._packedBool} + set {_uniqueStorage()._packedBool = newValue} + } + + var packedNestedEnum: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum] { + get {_storage._packedNestedEnum} + set {_uniqueStorage()._packedNestedEnum = newValue} + } + + /// Unpacked + var unpackedInt32: [Int32] { + get {_storage._unpackedInt32} + set {_uniqueStorage()._unpackedInt32 = newValue} + } + + var unpackedInt64: [Int64] { + get {_storage._unpackedInt64} + set {_uniqueStorage()._unpackedInt64 = newValue} + } + + var unpackedUint32: [UInt32] { + get {_storage._unpackedUint32} + set {_uniqueStorage()._unpackedUint32 = newValue} + } + + var unpackedUint64: [UInt64] { + get {_storage._unpackedUint64} + set {_uniqueStorage()._unpackedUint64 = newValue} + } + + var unpackedSint32: [Int32] { + get {_storage._unpackedSint32} + set {_uniqueStorage()._unpackedSint32 = newValue} + } + + var unpackedSint64: [Int64] { + get {_storage._unpackedSint64} + set {_uniqueStorage()._unpackedSint64 = newValue} + } + + var unpackedFixed32: [UInt32] { + get {_storage._unpackedFixed32} + set {_uniqueStorage()._unpackedFixed32 = newValue} + } + + var unpackedFixed64: [UInt64] { + get {_storage._unpackedFixed64} + set {_uniqueStorage()._unpackedFixed64 = newValue} + } + + var unpackedSfixed32: [Int32] { + get {_storage._unpackedSfixed32} + set {_uniqueStorage()._unpackedSfixed32 = newValue} + } + + var unpackedSfixed64: [Int64] { + get {_storage._unpackedSfixed64} + set {_uniqueStorage()._unpackedSfixed64 = newValue} + } + + var unpackedFloat: [Float] { + get {_storage._unpackedFloat} + set {_uniqueStorage()._unpackedFloat = newValue} + } + + var unpackedDouble: [Double] { + get {_storage._unpackedDouble} + set {_uniqueStorage()._unpackedDouble = newValue} + } + + var unpackedBool: [Bool] { + get {_storage._unpackedBool} + set {_uniqueStorage()._unpackedBool = newValue} + } + + var unpackedNestedEnum: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum] { + get {_storage._unpackedNestedEnum} + set {_uniqueStorage()._unpackedNestedEnum = newValue} + } + + /// Map + var mapInt32Int32: Dictionary { + get {_storage._mapInt32Int32} + set {_uniqueStorage()._mapInt32Int32 = newValue} + } + + var mapInt64Int64: Dictionary { + get {_storage._mapInt64Int64} + set {_uniqueStorage()._mapInt64Int64 = newValue} + } + + var mapUint32Uint32: Dictionary { + get {_storage._mapUint32Uint32} + set {_uniqueStorage()._mapUint32Uint32 = newValue} + } + + var mapUint64Uint64: Dictionary { + get {_storage._mapUint64Uint64} + set {_uniqueStorage()._mapUint64Uint64 = newValue} + } + + var mapSint32Sint32: Dictionary { + get {_storage._mapSint32Sint32} + set {_uniqueStorage()._mapSint32Sint32 = newValue} + } + + var mapSint64Sint64: Dictionary { + get {_storage._mapSint64Sint64} + set {_uniqueStorage()._mapSint64Sint64 = newValue} + } + + var mapFixed32Fixed32: Dictionary { + get {_storage._mapFixed32Fixed32} + set {_uniqueStorage()._mapFixed32Fixed32 = newValue} + } + + var mapFixed64Fixed64: Dictionary { + get {_storage._mapFixed64Fixed64} + set {_uniqueStorage()._mapFixed64Fixed64 = newValue} + } + + var mapSfixed32Sfixed32: Dictionary { + get {_storage._mapSfixed32Sfixed32} + set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} + } + + var mapSfixed64Sfixed64: Dictionary { + get {_storage._mapSfixed64Sfixed64} + set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} + } + + var mapInt32Bool: Dictionary { + get {_storage._mapInt32Bool} + set {_uniqueStorage()._mapInt32Bool = newValue} + } + + var mapInt32Float: Dictionary { + get {_storage._mapInt32Float} + set {_uniqueStorage()._mapInt32Float = newValue} + } + + var mapInt32Double: Dictionary { + get {_storage._mapInt32Double} + set {_uniqueStorage()._mapInt32Double = newValue} + } + + var mapInt32NestedMessage: Dictionary { + get {_storage._mapInt32NestedMessage} + set {_uniqueStorage()._mapInt32NestedMessage = newValue} + } + + var mapBoolBool: Dictionary { + get {_storage._mapBoolBool} + set {_uniqueStorage()._mapBoolBool = newValue} + } + + var mapStringString: Dictionary { + get {_storage._mapStringString} + set {_uniqueStorage()._mapStringString = newValue} + } + + var mapStringBytes: Dictionary { + get {_storage._mapStringBytes} + set {_uniqueStorage()._mapStringBytes = newValue} + } + + var mapStringNestedMessage: Dictionary { + get {_storage._mapStringNestedMessage} + set {_uniqueStorage()._mapStringNestedMessage = newValue} + } + + var mapStringForeignMessage: Dictionary { + get {_storage._mapStringForeignMessage} + set {_uniqueStorage()._mapStringForeignMessage = newValue} + } + + var mapStringNestedEnum: Dictionary { + get {_storage._mapStringNestedEnum} + set {_uniqueStorage()._mapStringNestedEnum = newValue} + } + + var mapStringForeignEnum: Dictionary { + get {_storage._mapStringForeignEnum} + set {_uniqueStorage()._mapStringForeignEnum = newValue} + } + + var oneofField: OneOf_OneofField? { + get {return _storage._oneofField} + set {_uniqueStorage()._oneofField = newValue} + } + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} + } + + var oneofNestedMessage: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage { + get { + if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} + return ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = _storage._oneofField {return v} + return Data() + } + set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} + } + + var oneofBool: Bool { + get { + if case .oneofBool(let v)? = _storage._oneofField {return v} + return false + } + set {_uniqueStorage()._oneofField = .oneofBool(newValue)} + } + + var oneofUint64: UInt64 { + get { + if case .oneofUint64(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint64(newValue)} + } + + var oneofFloat: Float { + get { + if case .oneofFloat(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofFloat(newValue)} + } + + var oneofDouble: Double { + get { + if case .oneofDouble(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofDouble(newValue)} + } + + var oneofEnum: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum { + get { + if case .oneofEnum(let v)? = _storage._oneofField {return v} + return .foo + } + set {_uniqueStorage()._oneofField = .oneofEnum(newValue)} + } + + var data: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.DataMessage { + get {_storage._data ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.DataMessage()} + set {_uniqueStorage()._data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {_storage._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {_uniqueStorage()._data = nil} + + var multiWordGroupField: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MultiWordGroupField { + get {_storage._multiWordGroupField ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MultiWordGroupField()} + set {_uniqueStorage()._multiWordGroupField = newValue} + } + /// Returns true if `multiWordGroupField` has been explicitly set. + var hasMultiWordGroupField: Bool {_storage._multiWordGroupField != nil} + /// Clears the value of `multiWordGroupField`. Subsequent reads from it will return its default value. + mutating func clearMultiWordGroupField() {_uniqueStorage()._multiWordGroupField = nil} + + /// default values + var defaultInt32: Int32 { + get {_storage._defaultInt32 ?? -123456789} + set {_uniqueStorage()._defaultInt32 = newValue} + } + /// Returns true if `defaultInt32` has been explicitly set. + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} + /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} + + var defaultInt64: Int64 { + get {_storage._defaultInt64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultInt64 = newValue} + } + /// Returns true if `defaultInt64` has been explicitly set. + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} + /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} + + var defaultUint32: UInt32 { + get {_storage._defaultUint32 ?? 2123456789} + set {_uniqueStorage()._defaultUint32 = newValue} + } + /// Returns true if `defaultUint32` has been explicitly set. + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} + /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} + + var defaultUint64: UInt64 { + get {_storage._defaultUint64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultUint64 = newValue} + } + /// Returns true if `defaultUint64` has been explicitly set. + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} + /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} + + var defaultSint32: Int32 { + get {_storage._defaultSint32 ?? -123456789} + set {_uniqueStorage()._defaultSint32 = newValue} + } + /// Returns true if `defaultSint32` has been explicitly set. + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} + /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} + + var defaultSint64: Int64 { + get {_storage._defaultSint64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSint64 = newValue} + } + /// Returns true if `defaultSint64` has been explicitly set. + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} + /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} + + var defaultFixed32: UInt32 { + get {_storage._defaultFixed32 ?? 2123456789} + set {_uniqueStorage()._defaultFixed32 = newValue} + } + /// Returns true if `defaultFixed32` has been explicitly set. + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} + /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} + + var defaultFixed64: UInt64 { + get {_storage._defaultFixed64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultFixed64 = newValue} + } + /// Returns true if `defaultFixed64` has been explicitly set. + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} + /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} + + var defaultSfixed32: Int32 { + get {_storage._defaultSfixed32 ?? -123456789} + set {_uniqueStorage()._defaultSfixed32 = newValue} + } + /// Returns true if `defaultSfixed32` has been explicitly set. + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} + /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} + + var defaultSfixed64: Int64 { + get {_storage._defaultSfixed64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSfixed64 = newValue} + } + /// Returns true if `defaultSfixed64` has been explicitly set. + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} + /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} + + var defaultFloat: Float { + get {_storage._defaultFloat ?? 9e+09} + set {_uniqueStorage()._defaultFloat = newValue} + } + /// Returns true if `defaultFloat` has been explicitly set. + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} + /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. + mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} + + var defaultDouble: Double { + get {_storage._defaultDouble ?? 7e+22} + set {_uniqueStorage()._defaultDouble = newValue} + } + /// Returns true if `defaultDouble` has been explicitly set. + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} + /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. + mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} + + var defaultBool: Bool { + get {_storage._defaultBool ?? true} + set {_uniqueStorage()._defaultBool = newValue} + } + /// Returns true if `defaultBool` has been explicitly set. + var hasDefaultBool: Bool {_storage._defaultBool != nil} + /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. + mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} + + var defaultString: String { + get {_storage._defaultString ?? "Rosebud"} + set {_uniqueStorage()._defaultString = newValue} + } + /// Returns true if `defaultString` has been explicitly set. + var hasDefaultString: Bool {_storage._defaultString != nil} + /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. + mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} + + var defaultBytes: Data { + get {_storage._defaultBytes ?? Data([106, 111, 115, 104, 117, 97])} + set {_uniqueStorage()._defaultBytes = newValue} + } + /// Returns true if `defaultBytes` has been explicitly set. + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} + /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. + mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} + + /// Test field-name-to-JSON-name convention. + /// (protobuf says names can be any valid C/C++ identifier.) + var fieldname1: Int32 { + get {_storage._fieldname1 ?? 0} + set {_uniqueStorage()._fieldname1 = newValue} + } + /// Returns true if `fieldname1` has been explicitly set. + var hasFieldname1: Bool {_storage._fieldname1 != nil} + /// Clears the value of `fieldname1`. Subsequent reads from it will return its default value. + mutating func clearFieldname1() {_uniqueStorage()._fieldname1 = nil} + + var fieldName2: Int32 { + get {_storage._fieldName2 ?? 0} + set {_uniqueStorage()._fieldName2 = newValue} + } + /// Returns true if `fieldName2` has been explicitly set. + var hasFieldName2: Bool {_storage._fieldName2 != nil} + /// Clears the value of `fieldName2`. Subsequent reads from it will return its default value. + mutating func clearFieldName2() {_uniqueStorage()._fieldName2 = nil} + + var fieldName3: Int32 { + get {_storage._fieldName3 ?? 0} + set {_uniqueStorage()._fieldName3 = newValue} + } + /// Returns true if `fieldName3` has been explicitly set. + var hasFieldName3: Bool {_storage._fieldName3 != nil} + /// Clears the value of `fieldName3`. Subsequent reads from it will return its default value. + mutating func clearFieldName3() {_uniqueStorage()._fieldName3 = nil} + + var field_Name4_: Int32 { + get {_storage._field_Name4_ ?? 0} + set {_uniqueStorage()._field_Name4_ = newValue} + } + /// Returns true if `field_Name4_` has been explicitly set. + var hasField_Name4_: Bool {_storage._field_Name4_ != nil} + /// Clears the value of `field_Name4_`. Subsequent reads from it will return its default value. + mutating func clearField_Name4_() {_uniqueStorage()._field_Name4_ = nil} + + var field0Name5: Int32 { + get {_storage._field0Name5 ?? 0} + set {_uniqueStorage()._field0Name5 = newValue} + } + /// Returns true if `field0Name5` has been explicitly set. + var hasField0Name5: Bool {_storage._field0Name5 != nil} + /// Clears the value of `field0Name5`. Subsequent reads from it will return its default value. + mutating func clearField0Name5() {_uniqueStorage()._field0Name5 = nil} + + var field0Name6: Int32 { + get {_storage._field0Name6 ?? 0} + set {_uniqueStorage()._field0Name6 = newValue} + } + /// Returns true if `field0Name6` has been explicitly set. + var hasField0Name6: Bool {_storage._field0Name6 != nil} + /// Clears the value of `field0Name6`. Subsequent reads from it will return its default value. + mutating func clearField0Name6() {_uniqueStorage()._field0Name6 = nil} + + var fieldName7: Int32 { + get {_storage._fieldName7 ?? 0} + set {_uniqueStorage()._fieldName7 = newValue} + } + /// Returns true if `fieldName7` has been explicitly set. + var hasFieldName7: Bool {_storage._fieldName7 != nil} + /// Clears the value of `fieldName7`. Subsequent reads from it will return its default value. + mutating func clearFieldName7() {_uniqueStorage()._fieldName7 = nil} + + var fieldName8: Int32 { + get {_storage._fieldName8 ?? 0} + set {_uniqueStorage()._fieldName8 = newValue} + } + /// Returns true if `fieldName8` has been explicitly set. + var hasFieldName8: Bool {_storage._fieldName8 != nil} + /// Clears the value of `fieldName8`. Subsequent reads from it will return its default value. + mutating func clearFieldName8() {_uniqueStorage()._fieldName8 = nil} + + var fieldName9: Int32 { + get {_storage._fieldName9 ?? 0} + set {_uniqueStorage()._fieldName9 = newValue} + } + /// Returns true if `fieldName9` has been explicitly set. + var hasFieldName9: Bool {_storage._fieldName9 != nil} + /// Clears the value of `fieldName9`. Subsequent reads from it will return its default value. + mutating func clearFieldName9() {_uniqueStorage()._fieldName9 = nil} + + var fieldName10: Int32 { + get {_storage._fieldName10 ?? 0} + set {_uniqueStorage()._fieldName10 = newValue} + } + /// Returns true if `fieldName10` has been explicitly set. + var hasFieldName10: Bool {_storage._fieldName10 != nil} + /// Clears the value of `fieldName10`. Subsequent reads from it will return its default value. + mutating func clearFieldName10() {_uniqueStorage()._fieldName10 = nil} + + var fieldName11: Int32 { + get {_storage._fieldName11 ?? 0} + set {_uniqueStorage()._fieldName11 = newValue} + } + /// Returns true if `fieldName11` has been explicitly set. + var hasFieldName11: Bool {_storage._fieldName11 != nil} + /// Clears the value of `fieldName11`. Subsequent reads from it will return its default value. + mutating func clearFieldName11() {_uniqueStorage()._fieldName11 = nil} + + var fieldName12: Int32 { + get {_storage._fieldName12 ?? 0} + set {_uniqueStorage()._fieldName12 = newValue} + } + /// Returns true if `fieldName12` has been explicitly set. + var hasFieldName12: Bool {_storage._fieldName12 != nil} + /// Clears the value of `fieldName12`. Subsequent reads from it will return its default value. + mutating func clearFieldName12() {_uniqueStorage()._fieldName12 = nil} + + var _FieldName13: Int32 { + get {_storage.__FieldName13 ?? 0} + set {_uniqueStorage().__FieldName13 = newValue} + } + /// Returns true if `_FieldName13` has been explicitly set. + var has_FieldName13: Bool {_storage.__FieldName13 != nil} + /// Clears the value of `_FieldName13`. Subsequent reads from it will return its default value. + mutating func clear_FieldName13() {_uniqueStorage().__FieldName13 = nil} + + var _FieldName14: Int32 { + get {_storage.__FieldName14 ?? 0} + set {_uniqueStorage().__FieldName14 = newValue} + } + /// Returns true if `_FieldName14` has been explicitly set. + var has_FieldName14: Bool {_storage.__FieldName14 != nil} + /// Clears the value of `_FieldName14`. Subsequent reads from it will return its default value. + mutating func clear_FieldName14() {_uniqueStorage().__FieldName14 = nil} + + var field_Name15: Int32 { + get {_storage._field_Name15 ?? 0} + set {_uniqueStorage()._field_Name15 = newValue} + } + /// Returns true if `field_Name15` has been explicitly set. + var hasField_Name15: Bool {_storage._field_Name15 != nil} + /// Clears the value of `field_Name15`. Subsequent reads from it will return its default value. + mutating func clearField_Name15() {_uniqueStorage()._field_Name15 = nil} + + var field_Name16: Int32 { + get {_storage._field_Name16 ?? 0} + set {_uniqueStorage()._field_Name16 = newValue} + } + /// Returns true if `field_Name16` has been explicitly set. + var hasField_Name16: Bool {_storage._field_Name16 != nil} + /// Clears the value of `field_Name16`. Subsequent reads from it will return its default value. + mutating func clearField_Name16() {_uniqueStorage()._field_Name16 = nil} + + var fieldName17__: Int32 { + get {_storage._fieldName17__ ?? 0} + set {_uniqueStorage()._fieldName17__ = newValue} + } + /// Returns true if `fieldName17__` has been explicitly set. + var hasFieldName17__: Bool {_storage._fieldName17__ != nil} + /// Clears the value of `fieldName17__`. Subsequent reads from it will return its default value. + mutating func clearFieldName17__() {_uniqueStorage()._fieldName17__ = nil} + + var fieldName18__: Int32 { + get {_storage._fieldName18__ ?? 0} + set {_uniqueStorage()._fieldName18__ = newValue} + } + /// Returns true if `fieldName18__` has been explicitly set. + var hasFieldName18__: Bool {_storage._fieldName18__ != nil} + /// Clears the value of `fieldName18__`. Subsequent reads from it will return its default value. + mutating func clearFieldName18__() {_uniqueStorage()._fieldName18__ = nil} + + var messageSetCorrect: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect { + get {_storage._messageSetCorrect ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect()} + set {_uniqueStorage()._messageSetCorrect = newValue} + } + /// Returns true if `messageSetCorrect` has been explicitly set. + var hasMessageSetCorrect: Bool {_storage._messageSetCorrect != nil} + /// Clears the value of `messageSetCorrect`. Subsequent reads from it will return its default value. + mutating func clearMessageSetCorrect() {_uniqueStorage()._messageSetCorrect = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofNestedMessage(ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage) + case oneofString(String) + case oneofBytes(Data) + case oneofBool(Bool) + case oneofUint64(UInt64) + case oneofFloat(Float) + case oneofDouble(Double) + case oneofEnum(ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum) + + fileprivate var isInitialized: Bool { + guard case .oneofNestedMessage(let v) = self else {return true} + return v.isInitialized + } + + } + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 + + /// Intentionally negative. + case neg = -1 + + init() { + self = .foo + } + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var corecursive: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2 { + get {_storage._corecursive ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + /// groups + struct DataMessage: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + struct MultiWordGroupField: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + /// message_set test case. + struct MessageSetCorrect: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() + } + + struct MessageSetCorrectExtension1: Sendable { + // 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 str: String { + get {_str ?? String()} + set {_str = newValue} + } + /// Returns true if `str` has been explicitly set. + var hasStr: Bool {self._str != nil} + /// Clears the value of `str`. Subsequent reads from it will return its default value. + mutating func clearStr() {self._str = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _str: String? = nil + } + + struct MessageSetCorrectExtension2: Sendable { + // 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 i: Int32 { + get {_i ?? 0} + set {_i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {self._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {self._i = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _i: Int32? = nil + } + + struct ExtensionWithOneof: Sendable { + // 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 oneofField: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.OneOf_OneofField? = nil + + var a: Int32 { + get { + if case .a(let v)? = oneofField {return v} + return 0 + } + set {oneofField = .a(newValue)} + } + + var b: Int32 { + get { + if case .b(let v)? = oneofField {return v} + return 0 + } + set {oneofField = .b(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case a(Int32) + case b(Int32) + + } + + init() {} + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2: Sendable { + // 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 c: Int32 { + get {_c ?? 0} + set {_c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {self._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {self._c = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _c: Int32? = nil +} + +struct ProtobufTestMessages_Editions_Proto2_GroupField: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil +} + +struct ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes: Sendable { + // 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 optionalInt32: Int32 { + get {_optionalInt32 ?? 0} + set {_optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {self._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {self._optionalInt32 = nil} + + var optionalString: String { + get {_optionalString ?? String()} + set {_optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {self._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {self._optionalString = nil} + + var nestedMessage: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2 { + get {_nestedMessage ?? ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2()} + set {_nestedMessage = newValue} + } + /// Returns true if `nestedMessage` has been explicitly set. + var hasNestedMessage: Bool {self._nestedMessage != nil} + /// Clears the value of `nestedMessage`. Subsequent reads from it will return its default value. + mutating func clearNestedMessage() {self._nestedMessage = nil} + + var optionalGroup: ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.OptionalGroup { + get {_optionalGroup ?? ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.OptionalGroup()} + set {_optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {self._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {self._optionalGroup = nil} + + var optionalBool: Bool { + get {_optionalBool ?? false} + set {_optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {self._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {self._optionalBool = nil} + + var repeatedInt32: [Int32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct OptionalGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + init() {} + + fileprivate var _optionalInt32: Int32? = nil + fileprivate var _optionalString: String? = nil + fileprivate var _nestedMessage: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2? = nil + fileprivate var _optionalGroup: ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.OptionalGroup? = nil + fileprivate var _optionalBool: Bool? = nil +} + +struct ProtobufTestMessages_Editions_Proto2_NullHypothesisProto2: Sendable { + // 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 ProtobufTestMessages_Editions_Proto2_EnumOnlyProto2: Sendable { + // 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() + + enum BoolEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case kFalse = 0 + case kTrue = 1 + + init() { + self = .kFalse + } + + } + + init() {} +} + +struct ProtobufTestMessages_Editions_Proto2_OneStringProto2: Sendable { + // 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 data: String { + get {_data ?? String()} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: String? = nil +} + +struct ProtobufTestMessages_Editions_Proto2_ProtoWithKeywords: Sendable { + // 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 inline: Int32 { + get {_inline ?? 0} + set {_inline = newValue} + } + /// Returns true if `inline` has been explicitly set. + var hasInline: Bool {self._inline != nil} + /// Clears the value of `inline`. Subsequent reads from it will return its default value. + mutating func clearInline() {self._inline = nil} + + var concept: String { + get {_concept ?? String()} + set {_concept = newValue} + } + /// Returns true if `concept` has been explicitly set. + var hasConcept: Bool {self._concept != nil} + /// Clears the value of `concept`. Subsequent reads from it will return its default value. + mutating func clearConcept() {self._concept = nil} + + var requires: [String] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _inline: Int32? = nil + fileprivate var _concept: String? = nil +} + +struct ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Singular + var requiredInt32: Int32 { + get {_storage._requiredInt32 ?? 0} + set {_uniqueStorage()._requiredInt32 = newValue} + } + /// Returns true if `requiredInt32` has been explicitly set. + var hasRequiredInt32: Bool {_storage._requiredInt32 != nil} + /// Clears the value of `requiredInt32`. Subsequent reads from it will return its default value. + mutating func clearRequiredInt32() {_uniqueStorage()._requiredInt32 = nil} + + var requiredInt64: Int64 { + get {_storage._requiredInt64 ?? 0} + set {_uniqueStorage()._requiredInt64 = newValue} + } + /// Returns true if `requiredInt64` has been explicitly set. + var hasRequiredInt64: Bool {_storage._requiredInt64 != nil} + /// Clears the value of `requiredInt64`. Subsequent reads from it will return its default value. + mutating func clearRequiredInt64() {_uniqueStorage()._requiredInt64 = nil} + + var requiredUint32: UInt32 { + get {_storage._requiredUint32 ?? 0} + set {_uniqueStorage()._requiredUint32 = newValue} + } + /// Returns true if `requiredUint32` has been explicitly set. + var hasRequiredUint32: Bool {_storage._requiredUint32 != nil} + /// Clears the value of `requiredUint32`. Subsequent reads from it will return its default value. + mutating func clearRequiredUint32() {_uniqueStorage()._requiredUint32 = nil} + + var requiredUint64: UInt64 { + get {_storage._requiredUint64 ?? 0} + set {_uniqueStorage()._requiredUint64 = newValue} + } + /// Returns true if `requiredUint64` has been explicitly set. + var hasRequiredUint64: Bool {_storage._requiredUint64 != nil} + /// Clears the value of `requiredUint64`. Subsequent reads from it will return its default value. + mutating func clearRequiredUint64() {_uniqueStorage()._requiredUint64 = nil} + + var requiredSint32: Int32 { + get {_storage._requiredSint32 ?? 0} + set {_uniqueStorage()._requiredSint32 = newValue} + } + /// Returns true if `requiredSint32` has been explicitly set. + var hasRequiredSint32: Bool {_storage._requiredSint32 != nil} + /// Clears the value of `requiredSint32`. Subsequent reads from it will return its default value. + mutating func clearRequiredSint32() {_uniqueStorage()._requiredSint32 = nil} + + var requiredSint64: Int64 { + get {_storage._requiredSint64 ?? 0} + set {_uniqueStorage()._requiredSint64 = newValue} + } + /// Returns true if `requiredSint64` has been explicitly set. + var hasRequiredSint64: Bool {_storage._requiredSint64 != nil} + /// Clears the value of `requiredSint64`. Subsequent reads from it will return its default value. + mutating func clearRequiredSint64() {_uniqueStorage()._requiredSint64 = nil} + + var requiredFixed32: UInt32 { + get {_storage._requiredFixed32 ?? 0} + set {_uniqueStorage()._requiredFixed32 = newValue} + } + /// Returns true if `requiredFixed32` has been explicitly set. + var hasRequiredFixed32: Bool {_storage._requiredFixed32 != nil} + /// Clears the value of `requiredFixed32`. Subsequent reads from it will return its default value. + mutating func clearRequiredFixed32() {_uniqueStorage()._requiredFixed32 = nil} + + var requiredFixed64: UInt64 { + get {_storage._requiredFixed64 ?? 0} + set {_uniqueStorage()._requiredFixed64 = newValue} + } + /// Returns true if `requiredFixed64` has been explicitly set. + var hasRequiredFixed64: Bool {_storage._requiredFixed64 != nil} + /// Clears the value of `requiredFixed64`. Subsequent reads from it will return its default value. + mutating func clearRequiredFixed64() {_uniqueStorage()._requiredFixed64 = nil} + + var requiredSfixed32: Int32 { + get {_storage._requiredSfixed32 ?? 0} + set {_uniqueStorage()._requiredSfixed32 = newValue} + } + /// Returns true if `requiredSfixed32` has been explicitly set. + var hasRequiredSfixed32: Bool {_storage._requiredSfixed32 != nil} + /// Clears the value of `requiredSfixed32`. Subsequent reads from it will return its default value. + mutating func clearRequiredSfixed32() {_uniqueStorage()._requiredSfixed32 = nil} + + var requiredSfixed64: Int64 { + get {_storage._requiredSfixed64 ?? 0} + set {_uniqueStorage()._requiredSfixed64 = newValue} + } + /// Returns true if `requiredSfixed64` has been explicitly set. + var hasRequiredSfixed64: Bool {_storage._requiredSfixed64 != nil} + /// Clears the value of `requiredSfixed64`. Subsequent reads from it will return its default value. + mutating func clearRequiredSfixed64() {_uniqueStorage()._requiredSfixed64 = nil} + + var requiredFloat: Float { + get {_storage._requiredFloat ?? 0} + set {_uniqueStorage()._requiredFloat = newValue} + } + /// Returns true if `requiredFloat` has been explicitly set. + var hasRequiredFloat: Bool {_storage._requiredFloat != nil} + /// Clears the value of `requiredFloat`. Subsequent reads from it will return its default value. + mutating func clearRequiredFloat() {_uniqueStorage()._requiredFloat = nil} + + var requiredDouble: Double { + get {_storage._requiredDouble ?? 0} + set {_uniqueStorage()._requiredDouble = newValue} + } + /// Returns true if `requiredDouble` has been explicitly set. + var hasRequiredDouble: Bool {_storage._requiredDouble != nil} + /// Clears the value of `requiredDouble`. Subsequent reads from it will return its default value. + mutating func clearRequiredDouble() {_uniqueStorage()._requiredDouble = nil} + + var requiredBool: Bool { + get {_storage._requiredBool ?? false} + set {_uniqueStorage()._requiredBool = newValue} + } + /// Returns true if `requiredBool` has been explicitly set. + var hasRequiredBool: Bool {_storage._requiredBool != nil} + /// Clears the value of `requiredBool`. Subsequent reads from it will return its default value. + mutating func clearRequiredBool() {_uniqueStorage()._requiredBool = nil} + + var requiredString: String { + get {_storage._requiredString ?? String()} + set {_uniqueStorage()._requiredString = newValue} + } + /// Returns true if `requiredString` has been explicitly set. + var hasRequiredString: Bool {_storage._requiredString != nil} + /// Clears the value of `requiredString`. Subsequent reads from it will return its default value. + mutating func clearRequiredString() {_uniqueStorage()._requiredString = nil} + + var requiredBytes: Data { + get {_storage._requiredBytes ?? Data()} + set {_uniqueStorage()._requiredBytes = newValue} + } + /// Returns true if `requiredBytes` has been explicitly set. + var hasRequiredBytes: Bool {_storage._requiredBytes != nil} + /// Clears the value of `requiredBytes`. Subsequent reads from it will return its default value. + mutating func clearRequiredBytes() {_uniqueStorage()._requiredBytes = nil} + + var requiredNestedMessage: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedMessage { + get {_storage._requiredNestedMessage ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedMessage()} + set {_uniqueStorage()._requiredNestedMessage = newValue} + } + /// Returns true if `requiredNestedMessage` has been explicitly set. + var hasRequiredNestedMessage: Bool {_storage._requiredNestedMessage != nil} + /// Clears the value of `requiredNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearRequiredNestedMessage() {_uniqueStorage()._requiredNestedMessage = nil} + + var requiredForeignMessage: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2 { + get {_storage._requiredForeignMessage ?? ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2()} + set {_uniqueStorage()._requiredForeignMessage = newValue} + } + /// Returns true if `requiredForeignMessage` has been explicitly set. + var hasRequiredForeignMessage: Bool {_storage._requiredForeignMessage != nil} + /// Clears the value of `requiredForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearRequiredForeignMessage() {_uniqueStorage()._requiredForeignMessage = nil} + + var requiredNestedEnum: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedEnum { + get {_storage._requiredNestedEnum ?? .foo} + set {_uniqueStorage()._requiredNestedEnum = newValue} + } + /// Returns true if `requiredNestedEnum` has been explicitly set. + var hasRequiredNestedEnum: Bool {_storage._requiredNestedEnum != nil} + /// Clears the value of `requiredNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredNestedEnum() {_uniqueStorage()._requiredNestedEnum = nil} + + var requiredForeignEnum: ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2 { + get {_storage._requiredForeignEnum ?? .foreignFoo} + set {_uniqueStorage()._requiredForeignEnum = newValue} + } + /// Returns true if `requiredForeignEnum` has been explicitly set. + var hasRequiredForeignEnum: Bool {_storage._requiredForeignEnum != nil} + /// Clears the value of `requiredForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredForeignEnum() {_uniqueStorage()._requiredForeignEnum = nil} + + var requiredStringPiece: String { + get {_storage._requiredStringPiece ?? String()} + set {_uniqueStorage()._requiredStringPiece = newValue} + } + /// Returns true if `requiredStringPiece` has been explicitly set. + var hasRequiredStringPiece: Bool {_storage._requiredStringPiece != nil} + /// Clears the value of `requiredStringPiece`. Subsequent reads from it will return its default value. + mutating func clearRequiredStringPiece() {_uniqueStorage()._requiredStringPiece = nil} + + var requiredCord: String { + get {_storage._requiredCord ?? String()} + set {_uniqueStorage()._requiredCord = newValue} + } + /// Returns true if `requiredCord` has been explicitly set. + var hasRequiredCord: Bool {_storage._requiredCord != nil} + /// Clears the value of `requiredCord`. Subsequent reads from it will return its default value. + mutating func clearRequiredCord() {_uniqueStorage()._requiredCord = nil} + + var recursiveMessage: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2 { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._recursiveMessage = newValue} + } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} + + var optionalRecursiveMessage: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2 { + get {_storage._optionalRecursiveMessage ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._optionalRecursiveMessage = newValue} + } + /// Returns true if `optionalRecursiveMessage` has been explicitly set. + var hasOptionalRecursiveMessage: Bool {_storage._optionalRecursiveMessage != nil} + /// Clears the value of `optionalRecursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalRecursiveMessage() {_uniqueStorage()._optionalRecursiveMessage = nil} + + var data: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.DataMessage { + get {_storage._data ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.DataMessage()} + set {_uniqueStorage()._data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {_storage._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {_uniqueStorage()._data = nil} + + /// default values + var defaultInt32: Int32 { + get {_storage._defaultInt32 ?? -123456789} + set {_uniqueStorage()._defaultInt32 = newValue} + } + /// Returns true if `defaultInt32` has been explicitly set. + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} + /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} + + var defaultInt64: Int64 { + get {_storage._defaultInt64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultInt64 = newValue} + } + /// Returns true if `defaultInt64` has been explicitly set. + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} + /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} + + var defaultUint32: UInt32 { + get {_storage._defaultUint32 ?? 2123456789} + set {_uniqueStorage()._defaultUint32 = newValue} + } + /// Returns true if `defaultUint32` has been explicitly set. + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} + /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} + + var defaultUint64: UInt64 { + get {_storage._defaultUint64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultUint64 = newValue} + } + /// Returns true if `defaultUint64` has been explicitly set. + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} + /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} + + var defaultSint32: Int32 { + get {_storage._defaultSint32 ?? -123456789} + set {_uniqueStorage()._defaultSint32 = newValue} + } + /// Returns true if `defaultSint32` has been explicitly set. + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} + /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} + + var defaultSint64: Int64 { + get {_storage._defaultSint64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSint64 = newValue} + } + /// Returns true if `defaultSint64` has been explicitly set. + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} + /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} + + var defaultFixed32: UInt32 { + get {_storage._defaultFixed32 ?? 2123456789} + set {_uniqueStorage()._defaultFixed32 = newValue} + } + /// Returns true if `defaultFixed32` has been explicitly set. + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} + /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} + + var defaultFixed64: UInt64 { + get {_storage._defaultFixed64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultFixed64 = newValue} + } + /// Returns true if `defaultFixed64` has been explicitly set. + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} + /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} + + var defaultSfixed32: Int32 { + get {_storage._defaultSfixed32 ?? -123456789} + set {_uniqueStorage()._defaultSfixed32 = newValue} + } + /// Returns true if `defaultSfixed32` has been explicitly set. + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} + /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} + + var defaultSfixed64: Int64 { + get {_storage._defaultSfixed64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSfixed64 = newValue} + } + /// Returns true if `defaultSfixed64` has been explicitly set. + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} + /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} + + var defaultFloat: Float { + get {_storage._defaultFloat ?? 9e+09} + set {_uniqueStorage()._defaultFloat = newValue} + } + /// Returns true if `defaultFloat` has been explicitly set. + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} + /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. + mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} + + var defaultDouble: Double { + get {_storage._defaultDouble ?? 7e+22} + set {_uniqueStorage()._defaultDouble = newValue} + } + /// Returns true if `defaultDouble` has been explicitly set. + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} + /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. + mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} + + var defaultBool: Bool { + get {_storage._defaultBool ?? true} + set {_uniqueStorage()._defaultBool = newValue} + } + /// Returns true if `defaultBool` has been explicitly set. + var hasDefaultBool: Bool {_storage._defaultBool != nil} + /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. + mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} + + var defaultString: String { + get {_storage._defaultString ?? "Rosebud"} + set {_uniqueStorage()._defaultString = newValue} + } + /// Returns true if `defaultString` has been explicitly set. + var hasDefaultString: Bool {_storage._defaultString != nil} + /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. + mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} + + var defaultBytes: Data { + get {_storage._defaultBytes ?? Data([106, 111, 115, 104, 117, 97])} + set {_uniqueStorage()._defaultBytes = newValue} + } + /// Returns true if `defaultBytes` has been explicitly set. + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} + /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. + mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 + + /// Intentionally negative. + case neg = -1 + + init() { + self = .foo + } + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var corecursive: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2 { + get {_storage._corecursive ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var optionalCorecursive: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2 { + get {_storage._optionalCorecursive ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._optionalCorecursive = newValue} + } + /// Returns true if `optionalCorecursive` has been explicitly set. + var hasOptionalCorecursive: Bool {_storage._optionalCorecursive != nil} + /// Clears the value of `optionalCorecursive`. Subsequent reads from it will return its default value. + mutating func clearOptionalCorecursive() {_uniqueStorage()._optionalCorecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + /// groups + struct DataMessage: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + /// message_set test case. + struct MessageSetCorrect: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() + } + + struct MessageSetCorrectExtension1: Sendable { + // 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 str: String { + get {_str ?? String()} + set {_str = newValue} + } + /// Returns true if `str` has been explicitly set. + var hasStr: Bool {self._str != nil} + /// Clears the value of `str`. Subsequent reads from it will return its default value. + mutating func clearStr() {self._str = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _str: String? = nil + } + + struct MessageSetCorrectExtension2: Sendable { + // 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 i: Int32 { + get {_i ?? 0} + set {_i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {self._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {self._i = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _i: Int32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct ProtobufTestMessages_Editions_Proto2_TestLargeOneof: Sendable { + // 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 largeOneof: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.OneOf_LargeOneof? = nil + + var a1: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1 { + get { + if case .a1(let v)? = largeOneof {return v} + return ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1() + } + set {largeOneof = .a1(newValue)} + } + + var a2: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2 { + get { + if case .a2(let v)? = largeOneof {return v} + return ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2() + } + set {largeOneof = .a2(newValue)} + } + + var a3: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3 { + get { + if case .a3(let v)? = largeOneof {return v} + return ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3() + } + set {largeOneof = .a3(newValue)} + } + + var a4: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4 { + get { + if case .a4(let v)? = largeOneof {return v} + return ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4() + } + set {largeOneof = .a4(newValue)} + } + + var a5: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5 { + get { + if case .a5(let v)? = largeOneof {return v} + return ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5() + } + set {largeOneof = .a5(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_LargeOneof: Equatable, Sendable { + case a1(ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1) + case a2(ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2) + case a3(ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3) + case a4(ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4) + case a5(ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5) + + } + + struct A1: Sendable { + // 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 A2: Sendable { + // 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 A3: Sendable { + // 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 A4: Sendable { + // 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 A5: Sendable { + // 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() {} + } + + init() {} +} + +// MARK: - Extension support defined in test_messages_proto2_editions.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect { + + var ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension1_messageSetExtension: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1 { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension1_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension2_messageSetExtension: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2 { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension2_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2 { + + var ProtobufTestMessages_Editions_Proto2_extensionInt32: Int32 { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32) ?? 0} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_extensionInt32: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_extensionInt32() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32) + } + + var ProtobufTestMessages_Editions_Proto2_groupField: ProtobufTestMessages_Editions_Proto2_GroupField { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_GroupField) ?? ProtobufTestMessages_Editions_Proto2_GroupField()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_GroupField, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_Extensions_GroupField` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_groupField: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_GroupField) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_Extensions_GroupField`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_groupField() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_GroupField) + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect { + + var ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1 { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2 { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_ExtensionWithOneof_extensionWithOneof: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof) ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_ExtensionWithOneof_extensionWithOneof: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_ExtensionWithOneof_extensionWithOneof() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof) + } + +} + +// MARK: - File's ExtensionMap: ProtobufTestMessages_Editions_Proto2_TestMessagesProto2Editions_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 ProtobufTestMessages_Editions_Proto2_TestMessagesProto2Editions_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32, + ProtobufTestMessages_Editions_Proto2_Extensions_GroupField, + ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, + ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, + ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof, + ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, + ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension +] + +// 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 ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32 = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2>( + _protobuf_fieldNumber: 120, + fieldName: "protobuf_test_messages.editions.proto2.extension_int32" +) + +let ProtobufTestMessages_Editions_Proto2_Extensions_GroupField = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2>( + _protobuf_fieldNumber: 121, + fieldName: "protobuf_test_messages.editions.proto2.groupfield" +) + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 1547769, + fieldName: "protobuf_test_messages.editions.proto2.TestAllTypesProto2.MessageSetCorrectExtension1" + ) + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 4135312, + fieldName: "protobuf_test_messages.editions.proto2.TestAllTypesProto2.MessageSetCorrectExtension2" + ) + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof { + enum Extensions { + static let extension_with_oneof = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 123456789, + fieldName: "protobuf_test_messages.editions.proto2.TestAllTypesProto2.ExtensionWithOneof" + ) + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 1547769, + fieldName: "protobuf_test_messages.editions.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension1" + ) + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 4135312, + fieldName: "protobuf_test_messages.editions.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension2" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "protobuf_test_messages.editions.proto2" + +extension ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypesProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{4}\u{2}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{4}\u{2}optional_string_piece\0\u{3}optional_cord\0\u{4}\u{2}recursive_message\0\u{4}\u{4}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{4}\u{2}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_nested_message\0\u{3}map_string_foreign_message\0\u{3}map_string_nested_enum\0\u{3}map_string_foreign_enum\0\u{3}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_nested_enum\0\u{3}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_nested_enum\0\u{3}map_int32_nested_message\0\u{3}map_int32_bool\0\u{4}\u{7}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_bool\0\u{3}oneof_uint64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_enum\0\u{8}R\u{1}Data\0\u{8}\u{3}MultiWordGroupField\0\u{4}%default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{2}R\u{2}fieldname1\0\u{3}field_name2\0\u{3}_field_name3\0\u{3}field__name4_\0\u{1}field0name5\0\u{3}field_0_name6\0\u{1}fieldName7\0\u{1}FieldName8\0\u{3}field_Name9\0\u{3}Field_Name10\0\u{3}FIELD_NAME11\0\u{3}FIELD_name12\0\u{3}__field_name13\0\u{3}__Field_name14\0\u{3}field__name15\0\u{3}field__Name16\0\u{3}field_name17__\0\u{3}Field_name18__\0\u{4}R\u{1}message_set_correct\0\u{b}reserved_field\0\u{c}h\u{f}hL\u{2}\u{c}\u{7f}Ht\u{3}\u{1}") + + fileprivate class _StorageClass { + var _optionalInt32: Int32? = nil + var _optionalInt64: Int64? = nil + var _optionalUint32: UInt32? = nil + var _optionalUint64: UInt64? = nil + var _optionalSint32: Int32? = nil + var _optionalSint64: Int64? = nil + var _optionalFixed32: UInt32? = nil + var _optionalFixed64: UInt64? = nil + var _optionalSfixed32: Int32? = nil + var _optionalSfixed64: Int64? = nil + var _optionalFloat: Float? = nil + var _optionalDouble: Double? = nil + var _optionalBool: Bool? = nil + var _optionalString: String? = nil + var _optionalBytes: Data? = nil + var _optionalNestedMessage: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage? = nil + var _optionalForeignMessage: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2? = nil + var _optionalNestedEnum: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum? = nil + var _optionalForeignEnum: ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2? = nil + var _optionalStringPiece: String? = nil + var _optionalCord: String? = nil + var _recursiveMessage: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2? = nil + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedNestedMessage: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage] = [] + var _repeatedForeignMessage: [ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2] = [] + var _repeatedNestedEnum: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _repeatedForeignEnum: [ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2] = [] + var _repeatedStringPiece: [String] = [] + var _repeatedCord: [String] = [] + var _packedInt32: [Int32] = [] + var _packedInt64: [Int64] = [] + var _packedUint32: [UInt32] = [] + var _packedUint64: [UInt64] = [] + var _packedSint32: [Int32] = [] + var _packedSint64: [Int64] = [] + var _packedFixed32: [UInt32] = [] + var _packedFixed64: [UInt64] = [] + var _packedSfixed32: [Int32] = [] + var _packedSfixed64: [Int64] = [] + var _packedFloat: [Float] = [] + var _packedDouble: [Double] = [] + var _packedBool: [Bool] = [] + var _packedNestedEnum: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _unpackedInt32: [Int32] = [] + var _unpackedInt64: [Int64] = [] + var _unpackedUint32: [UInt32] = [] + var _unpackedUint64: [UInt64] = [] + var _unpackedSint32: [Int32] = [] + var _unpackedSint64: [Int64] = [] + var _unpackedFixed32: [UInt32] = [] + var _unpackedFixed64: [UInt64] = [] + var _unpackedSfixed32: [Int32] = [] + var _unpackedSfixed64: [Int64] = [] + var _unpackedFloat: [Float] = [] + var _unpackedDouble: [Double] = [] + var _unpackedBool: [Bool] = [] + var _unpackedNestedEnum: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _mapInt32Int32: Dictionary = [:] + var _mapInt64Int64: Dictionary = [:] + var _mapUint32Uint32: Dictionary = [:] + var _mapUint64Uint64: Dictionary = [:] + var _mapSint32Sint32: Dictionary = [:] + var _mapSint64Sint64: Dictionary = [:] + var _mapFixed32Fixed32: Dictionary = [:] + var _mapFixed64Fixed64: Dictionary = [:] + var _mapSfixed32Sfixed32: Dictionary = [:] + var _mapSfixed64Sfixed64: Dictionary = [:] + var _mapInt32Bool: Dictionary = [:] + var _mapInt32Float: Dictionary = [:] + var _mapInt32Double: Dictionary = [:] + var _mapInt32NestedMessage: Dictionary = [:] + var _mapBoolBool: Dictionary = [:] + var _mapStringString: Dictionary = [:] + var _mapStringBytes: Dictionary = [:] + var _mapStringNestedMessage: Dictionary = [:] + var _mapStringForeignMessage: Dictionary = [:] + var _mapStringNestedEnum: Dictionary = [:] + var _mapStringForeignEnum: Dictionary = [:] + var _oneofField: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.OneOf_OneofField? + var _data: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.DataMessage? = nil + var _multiWordGroupField: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MultiWordGroupField? = nil + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + var _fieldname1: Int32? = nil + var _fieldName2: Int32? = nil + var _fieldName3: Int32? = nil + var _field_Name4_: Int32? = nil + var _field0Name5: Int32? = nil + var _field0Name6: Int32? = nil + var _fieldName7: Int32? = nil + var _fieldName8: Int32? = nil + var _fieldName9: Int32? = nil + var _fieldName10: Int32? = nil + var _fieldName11: Int32? = nil + var _fieldName12: Int32? = nil + var __FieldName13: Int32? = nil + var __FieldName14: Int32? = nil + var _field_Name15: Int32? = nil + var _field_Name16: Int32? = nil + var _fieldName17__: Int32? = nil + var _fieldName18__: Int32? = nil + var _messageSetCorrect: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalNestedMessage = source._optionalNestedMessage + _optionalForeignMessage = source._optionalForeignMessage + _optionalNestedEnum = source._optionalNestedEnum + _optionalForeignEnum = source._optionalForeignEnum + _optionalStringPiece = source._optionalStringPiece + _optionalCord = source._optionalCord + _recursiveMessage = source._recursiveMessage + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedForeignMessage = source._repeatedForeignMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _repeatedForeignEnum = source._repeatedForeignEnum + _repeatedStringPiece = source._repeatedStringPiece + _repeatedCord = source._repeatedCord + _packedInt32 = source._packedInt32 + _packedInt64 = source._packedInt64 + _packedUint32 = source._packedUint32 + _packedUint64 = source._packedUint64 + _packedSint32 = source._packedSint32 + _packedSint64 = source._packedSint64 + _packedFixed32 = source._packedFixed32 + _packedFixed64 = source._packedFixed64 + _packedSfixed32 = source._packedSfixed32 + _packedSfixed64 = source._packedSfixed64 + _packedFloat = source._packedFloat + _packedDouble = source._packedDouble + _packedBool = source._packedBool + _packedNestedEnum = source._packedNestedEnum + _unpackedInt32 = source._unpackedInt32 + _unpackedInt64 = source._unpackedInt64 + _unpackedUint32 = source._unpackedUint32 + _unpackedUint64 = source._unpackedUint64 + _unpackedSint32 = source._unpackedSint32 + _unpackedSint64 = source._unpackedSint64 + _unpackedFixed32 = source._unpackedFixed32 + _unpackedFixed64 = source._unpackedFixed64 + _unpackedSfixed32 = source._unpackedSfixed32 + _unpackedSfixed64 = source._unpackedSfixed64 + _unpackedFloat = source._unpackedFloat + _unpackedDouble = source._unpackedDouble + _unpackedBool = source._unpackedBool + _unpackedNestedEnum = source._unpackedNestedEnum + _mapInt32Int32 = source._mapInt32Int32 + _mapInt64Int64 = source._mapInt64Int64 + _mapUint32Uint32 = source._mapUint32Uint32 + _mapUint64Uint64 = source._mapUint64Uint64 + _mapSint32Sint32 = source._mapSint32Sint32 + _mapSint64Sint64 = source._mapSint64Sint64 + _mapFixed32Fixed32 = source._mapFixed32Fixed32 + _mapFixed64Fixed64 = source._mapFixed64Fixed64 + _mapSfixed32Sfixed32 = source._mapSfixed32Sfixed32 + _mapSfixed64Sfixed64 = source._mapSfixed64Sfixed64 + _mapInt32Bool = source._mapInt32Bool + _mapInt32Float = source._mapInt32Float + _mapInt32Double = source._mapInt32Double + _mapInt32NestedMessage = source._mapInt32NestedMessage + _mapBoolBool = source._mapBoolBool + _mapStringString = source._mapStringString + _mapStringBytes = source._mapStringBytes + _mapStringNestedMessage = source._mapStringNestedMessage + _mapStringForeignMessage = source._mapStringForeignMessage + _mapStringNestedEnum = source._mapStringNestedEnum + _mapStringForeignEnum = source._mapStringForeignEnum + _oneofField = source._oneofField + _data = source._data + _multiWordGroupField = source._multiWordGroupField + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + _fieldname1 = source._fieldname1 + _fieldName2 = source._fieldName2 + _fieldName3 = source._fieldName3 + _field_Name4_ = source._field_Name4_ + _field0Name5 = source._field0Name5 + _field0Name6 = source._field0Name6 + _fieldName7 = source._fieldName7 + _fieldName8 = source._fieldName8 + _fieldName9 = source._fieldName9 + _fieldName10 = source._fieldName10 + _fieldName11 = source._fieldName11 + _fieldName12 = source._fieldName12 + __FieldName13 = source.__FieldName13 + __FieldName14 = source.__FieldName14 + _field_Name15 = source._field_Name15 + _field_Name16 = source._field_Name16 + _fieldName17__ = source._fieldName17__ + _fieldName18__ = source._fieldName18__ + _messageSetCorrect = source._messageSetCorrect + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._optionalNestedMessage, !v.isInitialized {return false} + if let v = _storage._recursiveMessage, !v.isInitialized {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._repeatedNestedMessage) {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._mapInt32NestedMessage) {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._mapStringNestedMessage) {return false} + if let v = _storage._oneofField, !v.isInitialized {return false} + if let v = _storage._messageSetCorrect, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() + case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() + case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() + case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() + case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() + case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() + case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() + case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() + case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() + case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() + case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() + case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() + case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() + case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() + case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() + case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() + case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() + case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() + case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() + case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() + case 56: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Int32) }() + case 57: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() + case 58: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() + case 59: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Uint64) }() + case 60: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Sint32) }() + case 61: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Sint64) }() + case 62: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Fixed32) }() + case 63: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Fixed64) }() + case 64: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Sfixed32) }() + case 65: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Sfixed64) }() + case 66: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Float) }() + case 67: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Double) }() + case 68: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() + case 69: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() + case 70: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() + case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringNestedMessage) }() + case 72: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() + case 73: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringNestedEnum) }() + case 74: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringForeignEnum) }() + case 75: try { try decoder.decodeRepeatedInt32Field(value: &_storage._packedInt32) }() + case 76: try { try decoder.decodeRepeatedInt64Field(value: &_storage._packedInt64) }() + case 77: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._packedUint32) }() + case 78: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._packedUint64) }() + case 79: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._packedSint32) }() + case 80: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._packedSint64) }() + case 81: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._packedFixed32) }() + case 82: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._packedFixed64) }() + case 83: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._packedSfixed32) }() + case 84: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._packedSfixed64) }() + case 85: try { try decoder.decodeRepeatedFloatField(value: &_storage._packedFloat) }() + case 86: try { try decoder.decodeRepeatedDoubleField(value: &_storage._packedDouble) }() + case 87: try { try decoder.decodeRepeatedBoolField(value: &_storage._packedBool) }() + case 88: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedNestedEnum) }() + case 89: try { try decoder.decodeRepeatedInt32Field(value: &_storage._unpackedInt32) }() + case 90: try { try decoder.decodeRepeatedInt64Field(value: &_storage._unpackedInt64) }() + case 91: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._unpackedUint32) }() + case 92: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._unpackedUint64) }() + case 93: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._unpackedSint32) }() + case 94: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._unpackedSint64) }() + case 95: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._unpackedFixed32) }() + case 96: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._unpackedFixed64) }() + case 97: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._unpackedSfixed32) }() + case 98: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._unpackedSfixed64) }() + case 99: try { try decoder.decodeRepeatedFloatField(value: &_storage._unpackedFloat) }() + case 100: try { try decoder.decodeRepeatedDoubleField(value: &_storage._unpackedDouble) }() + case 101: try { try decoder.decodeRepeatedBoolField(value: &_storage._unpackedBool) }() + case 102: try { try decoder.decodeRepeatedEnumField(value: &_storage._unpackedNestedEnum) }() + case 103: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32NestedMessage) }() + case 104: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bool) }() + case 111: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 112: try { + var v: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage(v) + } + }() + case 113: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 114: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() + case 115: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBool(v) + } + }() + case 116: try { + var v: UInt64? + try decoder.decodeSingularUInt64Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint64(v) + } + }() + case 117: try { + var v: Float? + try decoder.decodeSingularFloatField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofFloat(v) + } + }() + case 118: try { + var v: Double? + try decoder.decodeSingularDoubleField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofDouble(v) + } + }() + case 119: try { + var v: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofEnum(v) + } + }() + case 201: try { try decoder.decodeSingularGroupField(value: &_storage._data) }() + case 204: try { try decoder.decodeSingularGroupField(value: &_storage._multiWordGroupField) }() + case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 242: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 243: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 244: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 245: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 246: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 247: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 248: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 249: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 250: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 251: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 252: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 253: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 254: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 255: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() + case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldname1) }() + case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName2) }() + case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName3) }() + case 404: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name4_) }() + case 405: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name5) }() + case 406: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name6) }() + case 407: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName7) }() + case 408: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName8) }() + case 409: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName9) }() + case 410: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName10) }() + case 411: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName11) }() + case 412: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName12) }() + case 413: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName13) }() + case 414: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName14) }() + case 415: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name15) }() + case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name16) }() + case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName17__) }() + case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName18__) }() + case 500: try { try decoder.decodeSingularMessageField(value: &_storage._messageSetCorrect) }() + case 120..<201: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._optionalInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._optionalUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._optionalSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._optionalSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._optionalFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._optionalFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._optionalSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._optionalSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._optionalFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._optionalDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._optionalBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._optionalForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._optionalNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._optionalForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._optionalStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._optionalCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + if !_storage._repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + } + if !_storage._repeatedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + } + if !_storage._repeatedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + } + if !_storage._repeatedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + } + if !_storage._repeatedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + } + if !_storage._repeatedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + } + if !_storage._repeatedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + } + if !_storage._repeatedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + } + if !_storage._repeatedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + } + if !_storage._repeatedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + } + if !_storage._repeatedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + } + if !_storage._repeatedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + } + if !_storage._repeatedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + } + if !_storage._repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) + } + if !_storage._repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) + } + if !_storage._repeatedNestedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) + } + if !_storage._repeatedForeignMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) + } + if !_storage._repeatedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + } + if !_storage._repeatedForeignEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) + } + if !_storage._repeatedStringPiece.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) + } + if !_storage._repeatedCord.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) + } + if !_storage._mapInt32Int32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Int32, fieldNumber: 56) + } + if !_storage._mapInt64Int64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Int64, fieldNumber: 57) + } + if !_storage._mapUint32Uint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Uint32, fieldNumber: 58) + } + if !_storage._mapUint64Uint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Uint64, fieldNumber: 59) + } + if !_storage._mapSint32Sint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Sint32, fieldNumber: 60) + } + if !_storage._mapSint64Sint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Sint64, fieldNumber: 61) + } + if !_storage._mapFixed32Fixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Fixed32, fieldNumber: 62) + } + if !_storage._mapFixed64Fixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Fixed64, fieldNumber: 63) + } + if !_storage._mapSfixed32Sfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 64) + } + if !_storage._mapSfixed64Sfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 65) + } + if !_storage._mapInt32Float.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Float, fieldNumber: 66) + } + if !_storage._mapInt32Double.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Double, fieldNumber: 67) + } + if !_storage._mapBoolBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolBool, fieldNumber: 68) + } + if !_storage._mapStringString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringString, fieldNumber: 69) + } + if !_storage._mapStringBytes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 70) + } + if !_storage._mapStringNestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringNestedMessage, fieldNumber: 71) + } + if !_storage._mapStringForeignMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 72) + } + if !_storage._mapStringNestedEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringNestedEnum, fieldNumber: 73) + } + if !_storage._mapStringForeignEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringForeignEnum, fieldNumber: 74) + } + if !_storage._packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._packedInt32, fieldNumber: 75) + } + if !_storage._packedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._packedInt64, fieldNumber: 76) + } + if !_storage._packedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._packedUint32, fieldNumber: 77) + } + if !_storage._packedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._packedUint64, fieldNumber: 78) + } + if !_storage._packedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._packedSint32, fieldNumber: 79) + } + if !_storage._packedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._packedSint64, fieldNumber: 80) + } + if !_storage._packedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._packedFixed32, fieldNumber: 81) + } + if !_storage._packedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._packedFixed64, fieldNumber: 82) + } + if !_storage._packedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._packedSfixed32, fieldNumber: 83) + } + if !_storage._packedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._packedSfixed64, fieldNumber: 84) + } + if !_storage._packedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._packedFloat, fieldNumber: 85) + } + if !_storage._packedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._packedDouble, fieldNumber: 86) + } + if !_storage._packedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._packedBool, fieldNumber: 87) + } + if !_storage._packedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedNestedEnum, fieldNumber: 88) + } + if !_storage._unpackedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._unpackedInt32, fieldNumber: 89) + } + if !_storage._unpackedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._unpackedInt64, fieldNumber: 90) + } + if !_storage._unpackedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._unpackedUint32, fieldNumber: 91) + } + if !_storage._unpackedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._unpackedUint64, fieldNumber: 92) + } + if !_storage._unpackedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._unpackedSint32, fieldNumber: 93) + } + if !_storage._unpackedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._unpackedSint64, fieldNumber: 94) + } + if !_storage._unpackedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._unpackedFixed32, fieldNumber: 95) + } + if !_storage._unpackedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._unpackedFixed64, fieldNumber: 96) + } + if !_storage._unpackedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._unpackedSfixed32, fieldNumber: 97) + } + if !_storage._unpackedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._unpackedSfixed64, fieldNumber: 98) + } + if !_storage._unpackedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._unpackedFloat, fieldNumber: 99) + } + if !_storage._unpackedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._unpackedDouble, fieldNumber: 100) + } + if !_storage._unpackedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._unpackedBool, fieldNumber: 101) + } + if !_storage._unpackedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._unpackedNestedEnum, fieldNumber: 102) + } + if !_storage._mapInt32NestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32NestedMessage, fieldNumber: 103) + } + if !_storage._mapInt32Bool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bool, fieldNumber: 104) + } + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case .oneofBool?: try { + guard case .oneofBool(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 115) + }() + case .oneofUint64?: try { + guard case .oneofUint64(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 116) + }() + case .oneofFloat?: try { + guard case .oneofFloat(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularFloatField(value: v, fieldNumber: 117) + }() + case .oneofDouble?: try { + guard case .oneofDouble(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularDoubleField(value: v, fieldNumber: 118) + }() + case .oneofEnum?: try { + guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 119) + }() + case nil: break + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201) + try { if let v = _storage._data { + try visitor.visitSingularGroupField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._multiWordGroupField { + try visitor.visitSingularGroupField(value: v, fieldNumber: 204) + } }() + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 241) + } }() + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 242) + } }() + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 243) + } }() + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 244) + } }() + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 245) + } }() + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 246) + } }() + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 247) + } }() + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 248) + } }() + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 249) + } }() + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 250) + } }() + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 251) + } }() + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 252) + } }() + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 253) + } }() + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 254) + } }() + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 255) + } }() + try { if let v = _storage._fieldname1 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 401) + } }() + try { if let v = _storage._fieldName2 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 402) + } }() + try { if let v = _storage._fieldName3 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 403) + } }() + try { if let v = _storage._field_Name4_ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 404) + } }() + try { if let v = _storage._field0Name5 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 405) + } }() + try { if let v = _storage._field0Name6 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 406) + } }() + try { if let v = _storage._fieldName7 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 407) + } }() + try { if let v = _storage._fieldName8 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 408) + } }() + try { if let v = _storage._fieldName9 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 409) + } }() + try { if let v = _storage._fieldName10 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 410) + } }() + try { if let v = _storage._fieldName11 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 411) + } }() + try { if let v = _storage._fieldName12 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 412) + } }() + try { if let v = _storage.__FieldName13 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 413) + } }() + try { if let v = _storage.__FieldName14 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 414) + } }() + try { if let v = _storage._field_Name15 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 415) + } }() + try { if let v = _storage._field_Name16 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 416) + } }() + try { if let v = _storage._fieldName17__ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 417) + } }() + try { if let v = _storage._fieldName18__ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 418) + } }() + try { if let v = _storage._messageSetCorrect { + try visitor.visitSingularMessageField(value: v, fieldNumber: 500) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} + if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} + if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} + if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} + if _storage._repeatedCord != rhs_storage._repeatedCord {return false} + if _storage._packedInt32 != rhs_storage._packedInt32 {return false} + if _storage._packedInt64 != rhs_storage._packedInt64 {return false} + if _storage._packedUint32 != rhs_storage._packedUint32 {return false} + if _storage._packedUint64 != rhs_storage._packedUint64 {return false} + if _storage._packedSint32 != rhs_storage._packedSint32 {return false} + if _storage._packedSint64 != rhs_storage._packedSint64 {return false} + if _storage._packedFixed32 != rhs_storage._packedFixed32 {return false} + if _storage._packedFixed64 != rhs_storage._packedFixed64 {return false} + if _storage._packedSfixed32 != rhs_storage._packedSfixed32 {return false} + if _storage._packedSfixed64 != rhs_storage._packedSfixed64 {return false} + if _storage._packedFloat != rhs_storage._packedFloat {return false} + if _storage._packedDouble != rhs_storage._packedDouble {return false} + if _storage._packedBool != rhs_storage._packedBool {return false} + if _storage._packedNestedEnum != rhs_storage._packedNestedEnum {return false} + if _storage._unpackedInt32 != rhs_storage._unpackedInt32 {return false} + if _storage._unpackedInt64 != rhs_storage._unpackedInt64 {return false} + if _storage._unpackedUint32 != rhs_storage._unpackedUint32 {return false} + if _storage._unpackedUint64 != rhs_storage._unpackedUint64 {return false} + if _storage._unpackedSint32 != rhs_storage._unpackedSint32 {return false} + if _storage._unpackedSint64 != rhs_storage._unpackedSint64 {return false} + if _storage._unpackedFixed32 != rhs_storage._unpackedFixed32 {return false} + if _storage._unpackedFixed64 != rhs_storage._unpackedFixed64 {return false} + if _storage._unpackedSfixed32 != rhs_storage._unpackedSfixed32 {return false} + if _storage._unpackedSfixed64 != rhs_storage._unpackedSfixed64 {return false} + if _storage._unpackedFloat != rhs_storage._unpackedFloat {return false} + if _storage._unpackedDouble != rhs_storage._unpackedDouble {return false} + if _storage._unpackedBool != rhs_storage._unpackedBool {return false} + if _storage._unpackedNestedEnum != rhs_storage._unpackedNestedEnum {return false} + if _storage._mapInt32Int32 != rhs_storage._mapInt32Int32 {return false} + if _storage._mapInt64Int64 != rhs_storage._mapInt64Int64 {return false} + if _storage._mapUint32Uint32 != rhs_storage._mapUint32Uint32 {return false} + if _storage._mapUint64Uint64 != rhs_storage._mapUint64Uint64 {return false} + if _storage._mapSint32Sint32 != rhs_storage._mapSint32Sint32 {return false} + if _storage._mapSint64Sint64 != rhs_storage._mapSint64Sint64 {return false} + if _storage._mapFixed32Fixed32 != rhs_storage._mapFixed32Fixed32 {return false} + if _storage._mapFixed64Fixed64 != rhs_storage._mapFixed64Fixed64 {return false} + if _storage._mapSfixed32Sfixed32 != rhs_storage._mapSfixed32Sfixed32 {return false} + if _storage._mapSfixed64Sfixed64 != rhs_storage._mapSfixed64Sfixed64 {return false} + if _storage._mapInt32Bool != rhs_storage._mapInt32Bool {return false} + if _storage._mapInt32Float != rhs_storage._mapInt32Float {return false} + if _storage._mapInt32Double != rhs_storage._mapInt32Double {return false} + if _storage._mapInt32NestedMessage != rhs_storage._mapInt32NestedMessage {return false} + if _storage._mapBoolBool != rhs_storage._mapBoolBool {return false} + if _storage._mapStringString != rhs_storage._mapStringString {return false} + if _storage._mapStringBytes != rhs_storage._mapStringBytes {return false} + if _storage._mapStringNestedMessage != rhs_storage._mapStringNestedMessage {return false} + if _storage._mapStringForeignMessage != rhs_storage._mapStringForeignMessage {return false} + if _storage._mapStringNestedEnum != rhs_storage._mapStringNestedEnum {return false} + if _storage._mapStringForeignEnum != rhs_storage._mapStringForeignEnum {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + if _storage._data != rhs_storage._data {return false} + if _storage._multiWordGroupField != rhs_storage._multiWordGroupField {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} + if _storage._fieldname1 != rhs_storage._fieldname1 {return false} + if _storage._fieldName2 != rhs_storage._fieldName2 {return false} + if _storage._fieldName3 != rhs_storage._fieldName3 {return false} + if _storage._field_Name4_ != rhs_storage._field_Name4_ {return false} + if _storage._field0Name5 != rhs_storage._field0Name5 {return false} + if _storage._field0Name6 != rhs_storage._field0Name6 {return false} + if _storage._fieldName7 != rhs_storage._fieldName7 {return false} + if _storage._fieldName8 != rhs_storage._fieldName8 {return false} + if _storage._fieldName9 != rhs_storage._fieldName9 {return false} + if _storage._fieldName10 != rhs_storage._fieldName10 {return false} + if _storage._fieldName11 != rhs_storage._fieldName11 {return false} + if _storage._fieldName12 != rhs_storage._fieldName12 {return false} + if _storage.__FieldName13 != rhs_storage.__FieldName13 {return false} + if _storage.__FieldName14 != rhs_storage.__FieldName14 {return false} + if _storage._field_Name15 != rhs_storage._field_Name15 {return false} + if _storage._field_Name16 != rhs_storage._field_Name16 {return false} + if _storage._fieldName17__ != rhs_storage._fieldName17__ {return false} + if _storage._fieldName18__ != rhs_storage._fieldName18__ {return false} + if _storage._messageSetCorrect != rhs_storage._messageSetCorrect {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _corecursive: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._corecursive, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}J\u{3}group_int32\0\u{3}group_uint32\0") + + 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 202: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 203: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 202) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 203) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.DataMessage, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.DataMessage) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MultiWordGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".MultiWordGroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}M\u{3}group_int32\0\u{3}group_uint32\0") + + 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 205: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 206: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 205) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 206) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MultiWordGroupField, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MultiWordGroupField) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect.self) + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrectExtension1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{19}str\0") + + 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 25: try { try decoder.decodeSingularStringField(value: &self._str) }() + 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 + try { if let v = self._str { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1) -> Bool { + if lhs._str != rhs._str {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrectExtension2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{9}i\0") + + 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 9: try { try decoder.decodeSingularInt32Field(value: &self._i) }() + 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 + try { if let v = self._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2) -> Bool { + if lhs._i != rhs._i {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".ExtensionWithOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .a(v) + } + }() + case 2: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .b(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.oneofField { + case .a?: try { + guard case .a(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + }() + case .b?: try { + guard case .b(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof) -> Bool { + if lhs.oneofField != rhs.oneofField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessageProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") + + 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._c) }() + 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 + try { if let v = self._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2, rhs: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2) -> Bool { + if lhs._c != rhs._c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_GroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}z\u{1}group_int32\0\u{3}group_uint32\0") + + 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 122: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 123: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 122) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 123) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_GroupField, rhs: ProtobufTestMessages_Editions_Proto2_GroupField) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".UnknownToTestAllTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}i\u{f}optional_int32\0\u{3}optional_string\0\u{3}nested_message\0\u{7}OptionalGroup\0\u{4}\u{2}optional_bool\0\u{4}\u{5}repeated_int32\0") + + 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 1001: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32) }() + case 1002: try { try decoder.decodeSingularStringField(value: &self._optionalString) }() + case 1003: try { try decoder.decodeSingularMessageField(value: &self._nestedMessage) }() + case 1004: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() + case 1006: try { try decoder.decodeSingularBoolField(value: &self._optionalBool) }() + case 1011: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() + 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 + try { if let v = self._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1001) + } }() + try { if let v = self._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1002) + } }() + try { if let v = self._nestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1003) + } }() + try { if let v = self._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 1004) + } }() + try { if let v = self._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1006) + } }() + if !self.repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 1011) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes, rhs: ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes) -> Bool { + if lhs._optionalInt32 != rhs._optionalInt32 {return false} + if lhs._optionalString != rhs._optionalString {return false} + if lhs._nestedMessage != rhs._nestedMessage {return false} + if lhs._optionalGroup != rhs._optionalGroup {return false} + if lhs._optionalBool != rhs._optionalBool {return false} + if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") + + 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._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.OptionalGroup, rhs: ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.OptionalGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_NullHypothesisProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NullHypothesisProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_NullHypothesisProto2, rhs: ProtobufTestMessages_Editions_Proto2_NullHypothesisProto2) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_EnumOnlyProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumOnlyProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_EnumOnlyProto2, rhs: ProtobufTestMessages_Editions_Proto2_EnumOnlyProto2) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_EnumOnlyProto2.BoolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0kFalse\0\u{1}kTrue\0") +} + +extension ProtobufTestMessages_Editions_Proto2_OneStringProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OneStringProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_OneStringProto2, rhs: ProtobufTestMessages_Editions_Proto2_OneStringProto2) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_ProtoWithKeywords: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ProtoWithKeywords" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}inline\0\u{1}concept\0\u{1}requires\0") + + 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._inline) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._concept) }() + case 3: try { try decoder.decodeRepeatedStringField(value: &self.requires) }() + 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 + try { if let v = self._inline { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._concept { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + if !self.requires.isEmpty { + try visitor.visitRepeatedStringField(value: self.requires, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_ProtoWithKeywords, rhs: ProtobufTestMessages_Editions_Proto2_ProtoWithKeywords) -> Bool { + if lhs._inline != rhs._inline {return false} + if lhs._concept != rhs._concept {return false} + if lhs.requires != rhs.requires {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllRequiredTypesProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_int32\0\u{3}required_int64\0\u{3}required_uint32\0\u{3}required_uint64\0\u{3}required_sint32\0\u{3}required_sint64\0\u{3}required_fixed32\0\u{3}required_fixed64\0\u{3}required_sfixed32\0\u{3}required_sfixed64\0\u{3}required_float\0\u{3}required_double\0\u{3}required_bool\0\u{3}required_string\0\u{3}required_bytes\0\u{4}\u{3}required_nested_message\0\u{3}required_foreign_message\0\u{4}\u{2}required_nested_enum\0\u{3}required_foreign_enum\0\u{4}\u{2}required_string_piece\0\u{3}required_cord\0\u{4}\u{2}recursive_message\0\u{3}optional_recursive_message\0\u{8}m\u{2}Data\0\u{4}(default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{c}h\u{f}hL\u{2}") + + fileprivate class _StorageClass { + var _requiredInt32: Int32? = nil + var _requiredInt64: Int64? = nil + var _requiredUint32: UInt32? = nil + var _requiredUint64: UInt64? = nil + var _requiredSint32: Int32? = nil + var _requiredSint64: Int64? = nil + var _requiredFixed32: UInt32? = nil + var _requiredFixed64: UInt64? = nil + var _requiredSfixed32: Int32? = nil + var _requiredSfixed64: Int64? = nil + var _requiredFloat: Float? = nil + var _requiredDouble: Double? = nil + var _requiredBool: Bool? = nil + var _requiredString: String? = nil + var _requiredBytes: Data? = nil + var _requiredNestedMessage: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedMessage? = nil + var _requiredForeignMessage: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2? = nil + var _requiredNestedEnum: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedEnum? = nil + var _requiredForeignEnum: ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2? = nil + var _requiredStringPiece: String? = nil + var _requiredCord: String? = nil + var _recursiveMessage: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2? = nil + var _optionalRecursiveMessage: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2? = nil + var _data: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.DataMessage? = nil + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _requiredInt32 = source._requiredInt32 + _requiredInt64 = source._requiredInt64 + _requiredUint32 = source._requiredUint32 + _requiredUint64 = source._requiredUint64 + _requiredSint32 = source._requiredSint32 + _requiredSint64 = source._requiredSint64 + _requiredFixed32 = source._requiredFixed32 + _requiredFixed64 = source._requiredFixed64 + _requiredSfixed32 = source._requiredSfixed32 + _requiredSfixed64 = source._requiredSfixed64 + _requiredFloat = source._requiredFloat + _requiredDouble = source._requiredDouble + _requiredBool = source._requiredBool + _requiredString = source._requiredString + _requiredBytes = source._requiredBytes + _requiredNestedMessage = source._requiredNestedMessage + _requiredForeignMessage = source._requiredForeignMessage + _requiredNestedEnum = source._requiredNestedEnum + _requiredForeignEnum = source._requiredForeignEnum + _requiredStringPiece = source._requiredStringPiece + _requiredCord = source._requiredCord + _recursiveMessage = source._recursiveMessage + _optionalRecursiveMessage = source._optionalRecursiveMessage + _data = source._data + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._requiredInt32 == nil {return false} + if _storage._requiredInt64 == nil {return false} + if _storage._requiredUint32 == nil {return false} + if _storage._requiredUint64 == nil {return false} + if _storage._requiredSint32 == nil {return false} + if _storage._requiredSint64 == nil {return false} + if _storage._requiredFixed32 == nil {return false} + if _storage._requiredFixed64 == nil {return false} + if _storage._requiredSfixed32 == nil {return false} + if _storage._requiredSfixed64 == nil {return false} + if _storage._requiredFloat == nil {return false} + if _storage._requiredDouble == nil {return false} + if _storage._requiredBool == nil {return false} + if _storage._requiredString == nil {return false} + if _storage._requiredBytes == nil {return false} + if _storage._requiredNestedMessage == nil {return false} + if _storage._requiredForeignMessage == nil {return false} + if _storage._requiredNestedEnum == nil {return false} + if _storage._requiredForeignEnum == nil {return false} + if _storage._requiredStringPiece == nil {return false} + if _storage._requiredCord == nil {return false} + if _storage._recursiveMessage == nil {return false} + if _storage._data == nil {return false} + if _storage._defaultInt32 == nil {return false} + if _storage._defaultInt64 == nil {return false} + if _storage._defaultUint32 == nil {return false} + if _storage._defaultUint64 == nil {return false} + if _storage._defaultSint32 == nil {return false} + if _storage._defaultSint64 == nil {return false} + if _storage._defaultFixed32 == nil {return false} + if _storage._defaultFixed64 == nil {return false} + if _storage._defaultSfixed32 == nil {return false} + if _storage._defaultSfixed64 == nil {return false} + if _storage._defaultFloat == nil {return false} + if _storage._defaultDouble == nil {return false} + if _storage._defaultBool == nil {return false} + if _storage._defaultString == nil {return false} + if _storage._defaultBytes == nil {return false} + if let v = _storage._requiredNestedMessage, !v.isInitialized {return false} + if let v = _storage._recursiveMessage, !v.isInitialized {return false} + if let v = _storage._optionalRecursiveMessage, !v.isInitialized {return false} + if let v = _storage._data, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._requiredInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._requiredInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._requiredUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._requiredUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._requiredSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._requiredSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._requiredFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._requiredFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._requiredSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._requiredSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._requiredFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._requiredDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._requiredBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._requiredString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._requiredBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._requiredNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._requiredForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._requiredNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._requiredForeignEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._requiredStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._requiredCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 28: try { try decoder.decodeSingularMessageField(value: &_storage._optionalRecursiveMessage) }() + case 201: try { try decoder.decodeSingularGroupField(value: &_storage._data) }() + case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 242: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 243: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 244: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 245: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 246: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 247: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 248: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 249: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 250: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 251: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 252: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 253: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 254: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 255: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() + case 120..<201: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._requiredInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._requiredInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._requiredUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._requiredUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._requiredSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._requiredSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._requiredFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._requiredFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._requiredSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._requiredSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._requiredFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._requiredDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._requiredBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._requiredString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._requiredBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._requiredNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._requiredForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._requiredNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._requiredForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._requiredStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._requiredCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + try { if let v = _storage._optionalRecursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 28) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201) + try { if let v = _storage._data { + try visitor.visitSingularGroupField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 241) + } }() + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 242) + } }() + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 243) + } }() + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 244) + } }() + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 245) + } }() + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 246) + } }() + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 247) + } }() + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 248) + } }() + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 249) + } }() + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 250) + } }() + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 251) + } }() + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 252) + } }() + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 253) + } }() + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 254) + } }() + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 255) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2, rhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2) -> 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._requiredInt32 != rhs_storage._requiredInt32 {return false} + if _storage._requiredInt64 != rhs_storage._requiredInt64 {return false} + if _storage._requiredUint32 != rhs_storage._requiredUint32 {return false} + if _storage._requiredUint64 != rhs_storage._requiredUint64 {return false} + if _storage._requiredSint32 != rhs_storage._requiredSint32 {return false} + if _storage._requiredSint64 != rhs_storage._requiredSint64 {return false} + if _storage._requiredFixed32 != rhs_storage._requiredFixed32 {return false} + if _storage._requiredFixed64 != rhs_storage._requiredFixed64 {return false} + if _storage._requiredSfixed32 != rhs_storage._requiredSfixed32 {return false} + if _storage._requiredSfixed64 != rhs_storage._requiredSfixed64 {return false} + if _storage._requiredFloat != rhs_storage._requiredFloat {return false} + if _storage._requiredDouble != rhs_storage._requiredDouble {return false} + if _storage._requiredBool != rhs_storage._requiredBool {return false} + if _storage._requiredString != rhs_storage._requiredString {return false} + if _storage._requiredBytes != rhs_storage._requiredBytes {return false} + if _storage._requiredNestedMessage != rhs_storage._requiredNestedMessage {return false} + if _storage._requiredForeignMessage != rhs_storage._requiredForeignMessage {return false} + if _storage._requiredNestedEnum != rhs_storage._requiredNestedEnum {return false} + if _storage._requiredForeignEnum != rhs_storage._requiredForeignEnum {return false} + if _storage._requiredStringPiece != rhs_storage._requiredStringPiece {return false} + if _storage._requiredCord != rhs_storage._requiredCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._optionalRecursiveMessage != rhs_storage._optionalRecursiveMessage {return false} + if _storage._data != rhs_storage._data {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0\u{3}optional_corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _corecursive: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2? = nil + var _optionalCorecursive: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + _optionalCorecursive = source._optionalCorecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._a == nil {return false} + if _storage._corecursive == nil {return false} + if let v = _storage._corecursive, !v.isInitialized {return false} + if let v = _storage._optionalCorecursive, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._optionalCorecursive) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalCorecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedMessage, rhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + if _storage._optionalCorecursive != rhs_storage._optionalCorecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}J\u{3}group_int32\0\u{3}group_uint32\0") + + public var isInitialized: Bool { + if self._groupInt32 == nil {return false} + if self._groupUint32 == nil {return false} + return true + } + + 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 202: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 203: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 202) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 203) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.DataMessage, rhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.DataMessage) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".MessageSetCorrect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect.self) + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect, rhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".MessageSetCorrectExtension1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{19}str\0") + + public var isInitialized: Bool { + if self._str == nil {return false} + return true + } + + 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 25: try { try decoder.decodeSingularStringField(value: &self._str) }() + 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 + try { if let v = self._str { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1, rhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1) -> Bool { + if lhs._str != rhs._str {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".MessageSetCorrectExtension2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{9}i\0") + + public var isInitialized: Bool { + if self._i == nil {return false} + return true + } + + 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 9: try { try decoder.decodeSingularInt32Field(value: &self._i) }() + 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 + try { if let v = self._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2, rhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2) -> Bool { + if lhs._i != rhs._i {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestLargeOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestLargeOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a1\0\u{1}a2\0\u{1}a3\0\u{1}a4\0\u{1}a5\0") + + 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: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a1(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a1(v) + } + }() + case 2: try { + var v: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a2(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a2(v) + } + }() + case 3: try { + var v: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a3(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a3(v) + } + }() + case 4: try { + var v: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a4(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a4(v) + } + }() + case 5: try { + var v: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a5(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a5(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.largeOneof { + case .a1?: try { + guard case .a1(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + }() + case .a2?: try { + guard case .a2(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + }() + case .a3?: try { + guard case .a3(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + }() + case .a4?: try { + guard case .a4(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + }() + case .a5?: try { + guard case .a5(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof, rhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof) -> Bool { + if lhs.largeOneof != rhs.largeOneof {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestLargeOneof.protoMessageName + ".A1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1, rhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestLargeOneof.protoMessageName + ".A2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2, rhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestLargeOneof.protoMessageName + ".A3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3, rhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestLargeOneof.protoMessageName + ".A4" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4, rhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestLargeOneof.protoMessageName + ".A5" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5, rhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/editions/golden/test_messages_proto3_editions.pb.swift b/Reference/upstream/editions/golden/test_messages_proto3_editions.pb.swift new file mode 100644 index 000000000..1bcdda760 --- /dev/null +++ b/Reference/upstream/editions/golden/test_messages_proto3_editions.pb.swift @@ -0,0 +1,2500 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: editions/golden/test_messages_proto3_editions.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// clang-format off +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Test schema for proto3 messages. This test schema is used by: +// +// - benchmarks +// - fuzz tests +// - conformance tests + +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 ProtobufTestMessages_Editions_Proto3_ForeignEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foreignFoo // = 0 + case foreignBar // = 1 + case foreignBaz // = 2 + case UNRECOGNIZED(Int) + + init() { + self = .foreignFoo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .foreignFoo + case 1: self = .foreignBar + case 2: self = .foreignBaz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .foreignFoo: return 0 + case .foreignBar: return 1 + case .foreignBaz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Editions_Proto3_ForeignEnum] = [ + .foreignFoo, + .foreignBar, + .foreignBaz, + ] + +} + +/// This proto includes every type of field in both singular and repeated +/// forms. +/// +/// Also, crucially, all messages and enums in this file are eventually +/// submessages of this message. So for example, a fuzz test of TestAllTypes +/// could trigger bugs that occur in any message type in this file. We verify +/// this stays true in a unit test. +struct ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3: @unchecked Sendable { + // 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. + + /// Singular + /// test [kotlin] comment + var optionalInt32: Int32 { + get {_storage._optionalInt32} + set {_uniqueStorage()._optionalInt32 = newValue} + } + + var optionalInt64: Int64 { + get {_storage._optionalInt64} + set {_uniqueStorage()._optionalInt64 = newValue} + } + + var optionalUint32: UInt32 { + get {_storage._optionalUint32} + set {_uniqueStorage()._optionalUint32 = newValue} + } + + var optionalUint64: UInt64 { + get {_storage._optionalUint64} + set {_uniqueStorage()._optionalUint64 = newValue} + } + + var optionalSint32: Int32 { + get {_storage._optionalSint32} + set {_uniqueStorage()._optionalSint32 = newValue} + } + + var optionalSint64: Int64 { + get {_storage._optionalSint64} + set {_uniqueStorage()._optionalSint64 = newValue} + } + + var optionalFixed32: UInt32 { + get {_storage._optionalFixed32} + set {_uniqueStorage()._optionalFixed32 = newValue} + } + + var optionalFixed64: UInt64 { + get {_storage._optionalFixed64} + set {_uniqueStorage()._optionalFixed64 = newValue} + } + + var optionalSfixed32: Int32 { + get {_storage._optionalSfixed32} + set {_uniqueStorage()._optionalSfixed32 = newValue} + } + + var optionalSfixed64: Int64 { + get {_storage._optionalSfixed64} + set {_uniqueStorage()._optionalSfixed64 = newValue} + } + + var optionalFloat: Float { + get {_storage._optionalFloat} + set {_uniqueStorage()._optionalFloat = newValue} + } + + var optionalDouble: Double { + get {_storage._optionalDouble} + set {_uniqueStorage()._optionalDouble = newValue} + } + + var optionalBool: Bool { + get {_storage._optionalBool} + set {_uniqueStorage()._optionalBool = newValue} + } + + var optionalString: String { + get {_storage._optionalString} + set {_uniqueStorage()._optionalString = newValue} + } + + var optionalBytes: Data { + get {_storage._optionalBytes} + set {_uniqueStorage()._optionalBytes = newValue} + } + + var optionalNestedMessage: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage { + get {_storage._optionalNestedMessage ?? ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage()} + set {_uniqueStorage()._optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} + + var optionalForeignMessage: ProtobufTestMessages_Editions_Proto3_ForeignMessage { + get {_storage._optionalForeignMessage ?? ProtobufTestMessages_Editions_Proto3_ForeignMessage()} + set {_uniqueStorage()._optionalForeignMessage = newValue} + } + /// Returns true if `optionalForeignMessage` has been explicitly set. + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} + /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} + + var optionalNestedEnum: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum { + get {_storage._optionalNestedEnum} + set {_uniqueStorage()._optionalNestedEnum = newValue} + } + + var optionalForeignEnum: ProtobufTestMessages_Editions_Proto3_ForeignEnum { + get {_storage._optionalForeignEnum} + set {_uniqueStorage()._optionalForeignEnum = newValue} + } + + var optionalAliasedEnum: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.AliasedEnum { + get {_storage._optionalAliasedEnum} + set {_uniqueStorage()._optionalAliasedEnum = newValue} + } + + var optionalStringPiece: String { + get {_storage._optionalStringPiece} + set {_uniqueStorage()._optionalStringPiece = newValue} + } + + var optionalCord: String { + get {_storage._optionalCord} + set {_uniqueStorage()._optionalCord = newValue} + } + + var recursiveMessage: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3 { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3()} + set {_uniqueStorage()._recursiveMessage = newValue} + } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} + + /// Repeated + var repeatedInt32: [Int32] { + get {_storage._repeatedInt32} + set {_uniqueStorage()._repeatedInt32 = newValue} + } + + var repeatedInt64: [Int64] { + get {_storage._repeatedInt64} + set {_uniqueStorage()._repeatedInt64 = newValue} + } + + var repeatedUint32: [UInt32] { + get {_storage._repeatedUint32} + set {_uniqueStorage()._repeatedUint32 = newValue} + } + + var repeatedUint64: [UInt64] { + get {_storage._repeatedUint64} + set {_uniqueStorage()._repeatedUint64 = newValue} + } + + var repeatedSint32: [Int32] { + get {_storage._repeatedSint32} + set {_uniqueStorage()._repeatedSint32 = newValue} + } + + var repeatedSint64: [Int64] { + get {_storage._repeatedSint64} + set {_uniqueStorage()._repeatedSint64 = newValue} + } + + var repeatedFixed32: [UInt32] { + get {_storage._repeatedFixed32} + set {_uniqueStorage()._repeatedFixed32 = newValue} + } + + var repeatedFixed64: [UInt64] { + get {_storage._repeatedFixed64} + set {_uniqueStorage()._repeatedFixed64 = newValue} + } + + var repeatedSfixed32: [Int32] { + get {_storage._repeatedSfixed32} + set {_uniqueStorage()._repeatedSfixed32 = newValue} + } + + var repeatedSfixed64: [Int64] { + get {_storage._repeatedSfixed64} + set {_uniqueStorage()._repeatedSfixed64 = newValue} + } + + var repeatedFloat: [Float] { + get {_storage._repeatedFloat} + set {_uniqueStorage()._repeatedFloat = newValue} + } + + var repeatedDouble: [Double] { + get {_storage._repeatedDouble} + set {_uniqueStorage()._repeatedDouble = newValue} + } + + var repeatedBool: [Bool] { + get {_storage._repeatedBool} + set {_uniqueStorage()._repeatedBool = newValue} + } + + var repeatedString: [String] { + get {_storage._repeatedString} + set {_uniqueStorage()._repeatedString = newValue} + } + + var repeatedBytes: [Data] { + get {_storage._repeatedBytes} + set {_uniqueStorage()._repeatedBytes = newValue} + } + + var repeatedNestedMessage: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage] { + get {_storage._repeatedNestedMessage} + set {_uniqueStorage()._repeatedNestedMessage = newValue} + } + + var repeatedForeignMessage: [ProtobufTestMessages_Editions_Proto3_ForeignMessage] { + get {_storage._repeatedForeignMessage} + set {_uniqueStorage()._repeatedForeignMessage = newValue} + } + + var repeatedNestedEnum: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] { + get {_storage._repeatedNestedEnum} + set {_uniqueStorage()._repeatedNestedEnum = newValue} + } + + var repeatedForeignEnum: [ProtobufTestMessages_Editions_Proto3_ForeignEnum] { + get {_storage._repeatedForeignEnum} + set {_uniqueStorage()._repeatedForeignEnum = newValue} + } + + var repeatedStringPiece: [String] { + get {_storage._repeatedStringPiece} + set {_uniqueStorage()._repeatedStringPiece = newValue} + } + + var repeatedCord: [String] { + get {_storage._repeatedCord} + set {_uniqueStorage()._repeatedCord = newValue} + } + + /// Packed + var packedInt32: [Int32] { + get {_storage._packedInt32} + set {_uniqueStorage()._packedInt32 = newValue} + } + + var packedInt64: [Int64] { + get {_storage._packedInt64} + set {_uniqueStorage()._packedInt64 = newValue} + } + + var packedUint32: [UInt32] { + get {_storage._packedUint32} + set {_uniqueStorage()._packedUint32 = newValue} + } + + var packedUint64: [UInt64] { + get {_storage._packedUint64} + set {_uniqueStorage()._packedUint64 = newValue} + } + + var packedSint32: [Int32] { + get {_storage._packedSint32} + set {_uniqueStorage()._packedSint32 = newValue} + } + + var packedSint64: [Int64] { + get {_storage._packedSint64} + set {_uniqueStorage()._packedSint64 = newValue} + } + + var packedFixed32: [UInt32] { + get {_storage._packedFixed32} + set {_uniqueStorage()._packedFixed32 = newValue} + } + + var packedFixed64: [UInt64] { + get {_storage._packedFixed64} + set {_uniqueStorage()._packedFixed64 = newValue} + } + + var packedSfixed32: [Int32] { + get {_storage._packedSfixed32} + set {_uniqueStorage()._packedSfixed32 = newValue} + } + + var packedSfixed64: [Int64] { + get {_storage._packedSfixed64} + set {_uniqueStorage()._packedSfixed64 = newValue} + } + + var packedFloat: [Float] { + get {_storage._packedFloat} + set {_uniqueStorage()._packedFloat = newValue} + } + + var packedDouble: [Double] { + get {_storage._packedDouble} + set {_uniqueStorage()._packedDouble = newValue} + } + + var packedBool: [Bool] { + get {_storage._packedBool} + set {_uniqueStorage()._packedBool = newValue} + } + + var packedNestedEnum: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] { + get {_storage._packedNestedEnum} + set {_uniqueStorage()._packedNestedEnum = newValue} + } + + /// Unpacked + var unpackedInt32: [Int32] { + get {_storage._unpackedInt32} + set {_uniqueStorage()._unpackedInt32 = newValue} + } + + var unpackedInt64: [Int64] { + get {_storage._unpackedInt64} + set {_uniqueStorage()._unpackedInt64 = newValue} + } + + var unpackedUint32: [UInt32] { + get {_storage._unpackedUint32} + set {_uniqueStorage()._unpackedUint32 = newValue} + } + + var unpackedUint64: [UInt64] { + get {_storage._unpackedUint64} + set {_uniqueStorage()._unpackedUint64 = newValue} + } + + var unpackedSint32: [Int32] { + get {_storage._unpackedSint32} + set {_uniqueStorage()._unpackedSint32 = newValue} + } + + var unpackedSint64: [Int64] { + get {_storage._unpackedSint64} + set {_uniqueStorage()._unpackedSint64 = newValue} + } + + var unpackedFixed32: [UInt32] { + get {_storage._unpackedFixed32} + set {_uniqueStorage()._unpackedFixed32 = newValue} + } + + var unpackedFixed64: [UInt64] { + get {_storage._unpackedFixed64} + set {_uniqueStorage()._unpackedFixed64 = newValue} + } + + var unpackedSfixed32: [Int32] { + get {_storage._unpackedSfixed32} + set {_uniqueStorage()._unpackedSfixed32 = newValue} + } + + var unpackedSfixed64: [Int64] { + get {_storage._unpackedSfixed64} + set {_uniqueStorage()._unpackedSfixed64 = newValue} + } + + var unpackedFloat: [Float] { + get {_storage._unpackedFloat} + set {_uniqueStorage()._unpackedFloat = newValue} + } + + var unpackedDouble: [Double] { + get {_storage._unpackedDouble} + set {_uniqueStorage()._unpackedDouble = newValue} + } + + var unpackedBool: [Bool] { + get {_storage._unpackedBool} + set {_uniqueStorage()._unpackedBool = newValue} + } + + var unpackedNestedEnum: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] { + get {_storage._unpackedNestedEnum} + set {_uniqueStorage()._unpackedNestedEnum = newValue} + } + + /// Map + var mapInt32Int32: Dictionary { + get {_storage._mapInt32Int32} + set {_uniqueStorage()._mapInt32Int32 = newValue} + } + + var mapInt64Int64: Dictionary { + get {_storage._mapInt64Int64} + set {_uniqueStorage()._mapInt64Int64 = newValue} + } + + var mapUint32Uint32: Dictionary { + get {_storage._mapUint32Uint32} + set {_uniqueStorage()._mapUint32Uint32 = newValue} + } + + var mapUint64Uint64: Dictionary { + get {_storage._mapUint64Uint64} + set {_uniqueStorage()._mapUint64Uint64 = newValue} + } + + var mapSint32Sint32: Dictionary { + get {_storage._mapSint32Sint32} + set {_uniqueStorage()._mapSint32Sint32 = newValue} + } + + var mapSint64Sint64: Dictionary { + get {_storage._mapSint64Sint64} + set {_uniqueStorage()._mapSint64Sint64 = newValue} + } + + var mapFixed32Fixed32: Dictionary { + get {_storage._mapFixed32Fixed32} + set {_uniqueStorage()._mapFixed32Fixed32 = newValue} + } + + var mapFixed64Fixed64: Dictionary { + get {_storage._mapFixed64Fixed64} + set {_uniqueStorage()._mapFixed64Fixed64 = newValue} + } + + var mapSfixed32Sfixed32: Dictionary { + get {_storage._mapSfixed32Sfixed32} + set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} + } + + var mapSfixed64Sfixed64: Dictionary { + get {_storage._mapSfixed64Sfixed64} + set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} + } + + var mapInt32Float: Dictionary { + get {_storage._mapInt32Float} + set {_uniqueStorage()._mapInt32Float = newValue} + } + + var mapInt32Double: Dictionary { + get {_storage._mapInt32Double} + set {_uniqueStorage()._mapInt32Double = newValue} + } + + var mapBoolBool: Dictionary { + get {_storage._mapBoolBool} + set {_uniqueStorage()._mapBoolBool = newValue} + } + + var mapStringString: Dictionary { + get {_storage._mapStringString} + set {_uniqueStorage()._mapStringString = newValue} + } + + var mapStringBytes: Dictionary { + get {_storage._mapStringBytes} + set {_uniqueStorage()._mapStringBytes = newValue} + } + + var mapStringNestedMessage: Dictionary { + get {_storage._mapStringNestedMessage} + set {_uniqueStorage()._mapStringNestedMessage = newValue} + } + + var mapStringForeignMessage: Dictionary { + get {_storage._mapStringForeignMessage} + set {_uniqueStorage()._mapStringForeignMessage = newValue} + } + + var mapStringNestedEnum: Dictionary { + get {_storage._mapStringNestedEnum} + set {_uniqueStorage()._mapStringNestedEnum = newValue} + } + + var mapStringForeignEnum: Dictionary { + get {_storage._mapStringForeignEnum} + set {_uniqueStorage()._mapStringForeignEnum = newValue} + } + + var oneofField: OneOf_OneofField? { + get {return _storage._oneofField} + set {_uniqueStorage()._oneofField = newValue} + } + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} + } + + var oneofNestedMessage: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage { + get { + if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} + return ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = _storage._oneofField {return v} + return Data() + } + set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} + } + + var oneofBool: Bool { + get { + if case .oneofBool(let v)? = _storage._oneofField {return v} + return false + } + set {_uniqueStorage()._oneofField = .oneofBool(newValue)} + } + + var oneofUint64: UInt64 { + get { + if case .oneofUint64(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint64(newValue)} + } + + var oneofFloat: Float { + get { + if case .oneofFloat(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofFloat(newValue)} + } + + var oneofDouble: Double { + get { + if case .oneofDouble(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofDouble(newValue)} + } + + var oneofEnum: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum { + get { + if case .oneofEnum(let v)? = _storage._oneofField {return v} + return .foo + } + set {_uniqueStorage()._oneofField = .oneofEnum(newValue)} + } + + var oneofNullValue: SwiftProtobuf.Google_Protobuf_NullValue { + get { + if case .oneofNullValue(let v)? = _storage._oneofField {return v} + return .nullValue + } + set {_uniqueStorage()._oneofField = .oneofNullValue(newValue)} + } + + /// Well-known types + var optionalBoolWrapper: SwiftProtobuf.Google_Protobuf_BoolValue { + get {_storage._optionalBoolWrapper ?? SwiftProtobuf.Google_Protobuf_BoolValue()} + set {_uniqueStorage()._optionalBoolWrapper = newValue} + } + /// Returns true if `optionalBoolWrapper` has been explicitly set. + var hasOptionalBoolWrapper: Bool {_storage._optionalBoolWrapper != nil} + /// Clears the value of `optionalBoolWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalBoolWrapper() {_uniqueStorage()._optionalBoolWrapper = nil} + + var optionalInt32Wrapper: SwiftProtobuf.Google_Protobuf_Int32Value { + get {_storage._optionalInt32Wrapper ?? SwiftProtobuf.Google_Protobuf_Int32Value()} + set {_uniqueStorage()._optionalInt32Wrapper = newValue} + } + /// Returns true if `optionalInt32Wrapper` has been explicitly set. + var hasOptionalInt32Wrapper: Bool {_storage._optionalInt32Wrapper != nil} + /// Clears the value of `optionalInt32Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32Wrapper() {_uniqueStorage()._optionalInt32Wrapper = nil} + + var optionalInt64Wrapper: SwiftProtobuf.Google_Protobuf_Int64Value { + get {_storage._optionalInt64Wrapper ?? SwiftProtobuf.Google_Protobuf_Int64Value()} + set {_uniqueStorage()._optionalInt64Wrapper = newValue} + } + /// Returns true if `optionalInt64Wrapper` has been explicitly set. + var hasOptionalInt64Wrapper: Bool {_storage._optionalInt64Wrapper != nil} + /// Clears the value of `optionalInt64Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64Wrapper() {_uniqueStorage()._optionalInt64Wrapper = nil} + + var optionalUint32Wrapper: SwiftProtobuf.Google_Protobuf_UInt32Value { + get {_storage._optionalUint32Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} + set {_uniqueStorage()._optionalUint32Wrapper = newValue} + } + /// Returns true if `optionalUint32Wrapper` has been explicitly set. + var hasOptionalUint32Wrapper: Bool {_storage._optionalUint32Wrapper != nil} + /// Clears the value of `optionalUint32Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint32Wrapper() {_uniqueStorage()._optionalUint32Wrapper = nil} + + var optionalUint64Wrapper: SwiftProtobuf.Google_Protobuf_UInt64Value { + get {_storage._optionalUint64Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} + set {_uniqueStorage()._optionalUint64Wrapper = newValue} + } + /// Returns true if `optionalUint64Wrapper` has been explicitly set. + var hasOptionalUint64Wrapper: Bool {_storage._optionalUint64Wrapper != nil} + /// Clears the value of `optionalUint64Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint64Wrapper() {_uniqueStorage()._optionalUint64Wrapper = nil} + + var optionalFloatWrapper: SwiftProtobuf.Google_Protobuf_FloatValue { + get {_storage._optionalFloatWrapper ?? SwiftProtobuf.Google_Protobuf_FloatValue()} + set {_uniqueStorage()._optionalFloatWrapper = newValue} + } + /// Returns true if `optionalFloatWrapper` has been explicitly set. + var hasOptionalFloatWrapper: Bool {_storage._optionalFloatWrapper != nil} + /// Clears the value of `optionalFloatWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloatWrapper() {_uniqueStorage()._optionalFloatWrapper = nil} + + var optionalDoubleWrapper: SwiftProtobuf.Google_Protobuf_DoubleValue { + get {_storage._optionalDoubleWrapper ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} + set {_uniqueStorage()._optionalDoubleWrapper = newValue} + } + /// Returns true if `optionalDoubleWrapper` has been explicitly set. + var hasOptionalDoubleWrapper: Bool {_storage._optionalDoubleWrapper != nil} + /// Clears the value of `optionalDoubleWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalDoubleWrapper() {_uniqueStorage()._optionalDoubleWrapper = nil} + + var optionalStringWrapper: SwiftProtobuf.Google_Protobuf_StringValue { + get {_storage._optionalStringWrapper ?? SwiftProtobuf.Google_Protobuf_StringValue()} + set {_uniqueStorage()._optionalStringWrapper = newValue} + } + /// Returns true if `optionalStringWrapper` has been explicitly set. + var hasOptionalStringWrapper: Bool {_storage._optionalStringWrapper != nil} + /// Clears the value of `optionalStringWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringWrapper() {_uniqueStorage()._optionalStringWrapper = nil} + + var optionalBytesWrapper: SwiftProtobuf.Google_Protobuf_BytesValue { + get {_storage._optionalBytesWrapper ?? SwiftProtobuf.Google_Protobuf_BytesValue()} + set {_uniqueStorage()._optionalBytesWrapper = newValue} + } + /// Returns true if `optionalBytesWrapper` has been explicitly set. + var hasOptionalBytesWrapper: Bool {_storage._optionalBytesWrapper != nil} + /// Clears the value of `optionalBytesWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytesWrapper() {_uniqueStorage()._optionalBytesWrapper = nil} + + var repeatedBoolWrapper: [SwiftProtobuf.Google_Protobuf_BoolValue] { + get {_storage._repeatedBoolWrapper} + set {_uniqueStorage()._repeatedBoolWrapper = newValue} + } + + var repeatedInt32Wrapper: [SwiftProtobuf.Google_Protobuf_Int32Value] { + get {_storage._repeatedInt32Wrapper} + set {_uniqueStorage()._repeatedInt32Wrapper = newValue} + } + + var repeatedInt64Wrapper: [SwiftProtobuf.Google_Protobuf_Int64Value] { + get {_storage._repeatedInt64Wrapper} + set {_uniqueStorage()._repeatedInt64Wrapper = newValue} + } + + var repeatedUint32Wrapper: [SwiftProtobuf.Google_Protobuf_UInt32Value] { + get {_storage._repeatedUint32Wrapper} + set {_uniqueStorage()._repeatedUint32Wrapper = newValue} + } + + var repeatedUint64Wrapper: [SwiftProtobuf.Google_Protobuf_UInt64Value] { + get {_storage._repeatedUint64Wrapper} + set {_uniqueStorage()._repeatedUint64Wrapper = newValue} + } + + var repeatedFloatWrapper: [SwiftProtobuf.Google_Protobuf_FloatValue] { + get {_storage._repeatedFloatWrapper} + set {_uniqueStorage()._repeatedFloatWrapper = newValue} + } + + var repeatedDoubleWrapper: [SwiftProtobuf.Google_Protobuf_DoubleValue] { + get {_storage._repeatedDoubleWrapper} + set {_uniqueStorage()._repeatedDoubleWrapper = newValue} + } + + var repeatedStringWrapper: [SwiftProtobuf.Google_Protobuf_StringValue] { + get {_storage._repeatedStringWrapper} + set {_uniqueStorage()._repeatedStringWrapper = newValue} + } + + var repeatedBytesWrapper: [SwiftProtobuf.Google_Protobuf_BytesValue] { + get {_storage._repeatedBytesWrapper} + set {_uniqueStorage()._repeatedBytesWrapper = newValue} + } + + var optionalDuration: SwiftProtobuf.Google_Protobuf_Duration { + get {_storage._optionalDuration ?? SwiftProtobuf.Google_Protobuf_Duration()} + set {_uniqueStorage()._optionalDuration = newValue} + } + /// Returns true if `optionalDuration` has been explicitly set. + var hasOptionalDuration: Bool {_storage._optionalDuration != nil} + /// Clears the value of `optionalDuration`. Subsequent reads from it will return its default value. + mutating func clearOptionalDuration() {_uniqueStorage()._optionalDuration = nil} + + var optionalTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp { + get {_storage._optionalTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()} + set {_uniqueStorage()._optionalTimestamp = newValue} + } + /// Returns true if `optionalTimestamp` has been explicitly set. + var hasOptionalTimestamp: Bool {_storage._optionalTimestamp != nil} + /// Clears the value of `optionalTimestamp`. Subsequent reads from it will return its default value. + mutating func clearOptionalTimestamp() {_uniqueStorage()._optionalTimestamp = nil} + + var optionalFieldMask: SwiftProtobuf.Google_Protobuf_FieldMask { + get {_storage._optionalFieldMask ?? SwiftProtobuf.Google_Protobuf_FieldMask()} + set {_uniqueStorage()._optionalFieldMask = newValue} + } + /// Returns true if `optionalFieldMask` has been explicitly set. + var hasOptionalFieldMask: Bool {_storage._optionalFieldMask != nil} + /// Clears the value of `optionalFieldMask`. Subsequent reads from it will return its default value. + mutating func clearOptionalFieldMask() {_uniqueStorage()._optionalFieldMask = nil} + + var optionalStruct: SwiftProtobuf.Google_Protobuf_Struct { + get {_storage._optionalStruct ?? SwiftProtobuf.Google_Protobuf_Struct()} + set {_uniqueStorage()._optionalStruct = newValue} + } + /// Returns true if `optionalStruct` has been explicitly set. + var hasOptionalStruct: Bool {_storage._optionalStruct != nil} + /// Clears the value of `optionalStruct`. Subsequent reads from it will return its default value. + mutating func clearOptionalStruct() {_uniqueStorage()._optionalStruct = nil} + + var optionalAny: SwiftProtobuf.Google_Protobuf_Any { + get {_storage._optionalAny ?? SwiftProtobuf.Google_Protobuf_Any()} + set {_uniqueStorage()._optionalAny = newValue} + } + /// Returns true if `optionalAny` has been explicitly set. + var hasOptionalAny: Bool {_storage._optionalAny != nil} + /// Clears the value of `optionalAny`. Subsequent reads from it will return its default value. + mutating func clearOptionalAny() {_uniqueStorage()._optionalAny = nil} + + var optionalValue: SwiftProtobuf.Google_Protobuf_Value { + get {_storage._optionalValue ?? SwiftProtobuf.Google_Protobuf_Value()} + set {_uniqueStorage()._optionalValue = newValue} + } + /// Returns true if `optionalValue` has been explicitly set. + var hasOptionalValue: Bool {_storage._optionalValue != nil} + /// Clears the value of `optionalValue`. Subsequent reads from it will return its default value. + mutating func clearOptionalValue() {_uniqueStorage()._optionalValue = nil} + + var optionalNullValue: SwiftProtobuf.Google_Protobuf_NullValue { + get {_storage._optionalNullValue} + set {_uniqueStorage()._optionalNullValue = newValue} + } + + var repeatedDuration: [SwiftProtobuf.Google_Protobuf_Duration] { + get {_storage._repeatedDuration} + set {_uniqueStorage()._repeatedDuration = newValue} + } + + var repeatedTimestamp: [SwiftProtobuf.Google_Protobuf_Timestamp] { + get {_storage._repeatedTimestamp} + set {_uniqueStorage()._repeatedTimestamp = newValue} + } + + var repeatedFieldmask: [SwiftProtobuf.Google_Protobuf_FieldMask] { + get {_storage._repeatedFieldmask} + set {_uniqueStorage()._repeatedFieldmask = newValue} + } + + var repeatedStruct: [SwiftProtobuf.Google_Protobuf_Struct] { + get {_storage._repeatedStruct} + set {_uniqueStorage()._repeatedStruct = newValue} + } + + var repeatedAny: [SwiftProtobuf.Google_Protobuf_Any] { + get {_storage._repeatedAny} + set {_uniqueStorage()._repeatedAny = newValue} + } + + var repeatedValue: [SwiftProtobuf.Google_Protobuf_Value] { + get {_storage._repeatedValue} + set {_uniqueStorage()._repeatedValue = newValue} + } + + var repeatedListValue: [SwiftProtobuf.Google_Protobuf_ListValue] { + get {_storage._repeatedListValue} + set {_uniqueStorage()._repeatedListValue = newValue} + } + + /// Test field-name-to-JSON-name convention. + /// (protobuf says names can be any valid C/C++ identifier.) + var fieldname1: Int32 { + get {_storage._fieldname1} + set {_uniqueStorage()._fieldname1 = newValue} + } + + var fieldName2: Int32 { + get {_storage._fieldName2} + set {_uniqueStorage()._fieldName2 = newValue} + } + + var fieldName3: Int32 { + get {_storage._fieldName3} + set {_uniqueStorage()._fieldName3 = newValue} + } + + var field_Name4_: Int32 { + get {_storage._field_Name4_} + set {_uniqueStorage()._field_Name4_ = newValue} + } + + var field0Name5: Int32 { + get {_storage._field0Name5} + set {_uniqueStorage()._field0Name5 = newValue} + } + + var field0Name6: Int32 { + get {_storage._field0Name6} + set {_uniqueStorage()._field0Name6 = newValue} + } + + var fieldName7: Int32 { + get {_storage._fieldName7} + set {_uniqueStorage()._fieldName7 = newValue} + } + + var fieldName8: Int32 { + get {_storage._fieldName8} + set {_uniqueStorage()._fieldName8 = newValue} + } + + var fieldName9: Int32 { + get {_storage._fieldName9} + set {_uniqueStorage()._fieldName9 = newValue} + } + + var fieldName10: Int32 { + get {_storage._fieldName10} + set {_uniqueStorage()._fieldName10 = newValue} + } + + var fieldName11: Int32 { + get {_storage._fieldName11} + set {_uniqueStorage()._fieldName11 = newValue} + } + + var fieldName12: Int32 { + get {_storage._fieldName12} + set {_uniqueStorage()._fieldName12 = newValue} + } + + var _FieldName13: Int32 { + get {_storage.__FieldName13} + set {_uniqueStorage().__FieldName13 = newValue} + } + + var _FieldName14: Int32 { + get {_storage.__FieldName14} + set {_uniqueStorage().__FieldName14 = newValue} + } + + var field_Name15: Int32 { + get {_storage._field_Name15} + set {_uniqueStorage()._field_Name15 = newValue} + } + + var field_Name16: Int32 { + get {_storage._field_Name16} + set {_uniqueStorage()._field_Name16 = newValue} + } + + var fieldName17__: Int32 { + get {_storage._fieldName17__} + set {_uniqueStorage()._fieldName17__ = newValue} + } + + var fieldName18__: Int32 { + get {_storage._fieldName18__} + set {_uniqueStorage()._fieldName18__ = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofNestedMessage(ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage) + case oneofString(String) + case oneofBytes(Data) + case oneofBool(Bool) + case oneofUint64(UInt64) + case oneofFloat(Float) + case oneofDouble(Double) + case oneofEnum(ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum) + case oneofNullValue(SwiftProtobuf.Google_Protobuf_NullValue) + + } + + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foo // = 0 + case bar // = 1 + case baz // = 2 + + /// Intentionally negative. + case neg // = -1 + case UNRECOGNIZED(Int) + + init() { + self = .foo + } + + init?(rawValue: Int) { + switch rawValue { + case -1: self = .neg + case 0: self = .foo + case 1: self = .bar + case 2: self = .baz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .neg: return -1 + case .foo: return 0 + case .bar: return 1 + case .baz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] = [ + .foo, + .bar, + .baz, + .neg, + ] + + } + + enum AliasedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case aliasFoo // = 0 + case aliasBar // = 1 + case aliasBaz // = 2 + static let moo = aliasBaz + static let bAz = aliasBaz + case UNRECOGNIZED(Int) + + init() { + self = .aliasFoo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .aliasFoo + case 1: self = .aliasBar + case 2: self = .aliasBaz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .aliasFoo: return 0 + case .aliasBar: return 1 + case .aliasBaz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.AliasedEnum] = [ + .aliasFoo, + .aliasBar, + .aliasBaz, + ] + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a} + set {_uniqueStorage()._a = newValue} + } + + var corecursive: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3 { + get {_storage._corecursive ?? ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct ProtobufTestMessages_Editions_Proto3_ForeignMessage: Sendable { + // 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 c: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct ProtobufTestMessages_Editions_Proto3_NullHypothesisProto3: Sendable { + // 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 ProtobufTestMessages_Editions_Proto3_EnumOnlyProto3: Sendable { + // 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() + + enum BoolEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case kFalse // = 0 + case kTrue // = 1 + case UNRECOGNIZED(Int) + + init() { + self = .kFalse + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .kFalse + case 1: self = .kTrue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .kFalse: return 0 + case .kTrue: return 1 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Editions_Proto3_EnumOnlyProto3.BoolEnum] = [ + .kFalse, + .kTrue, + ] + + } + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "protobuf_test_messages.editions.proto3" + +extension ProtobufTestMessages_Editions_Proto3_ForeignEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") +} + +extension ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypesProto3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{4}\u{2}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{3}optional_aliased_enum\0\u{3}optional_string_piece\0\u{3}optional_cord\0\u{4}\u{2}recursive_message\0\u{4}\u{4}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{4}\u{2}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_nested_message\0\u{3}map_string_foreign_message\0\u{3}map_string_nested_enum\0\u{3}map_string_foreign_enum\0\u{3}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_nested_enum\0\u{3}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_nested_enum\0\u{4}\u{9}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_bool\0\u{3}oneof_uint64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_enum\0\u{3}oneof_null_value\0\u{4}Q\u{1}optional_bool_wrapper\0\u{3}optional_int32_wrapper\0\u{3}optional_int64_wrapper\0\u{3}optional_uint32_wrapper\0\u{3}optional_uint64_wrapper\0\u{3}optional_float_wrapper\0\u{3}optional_double_wrapper\0\u{3}optional_string_wrapper\0\u{3}optional_bytes_wrapper\0\u{4}\u{2}repeated_bool_wrapper\0\u{3}repeated_int32_wrapper\0\u{3}repeated_int64_wrapper\0\u{3}repeated_uint32_wrapper\0\u{3}repeated_uint64_wrapper\0\u{3}repeated_float_wrapper\0\u{3}repeated_double_wrapper\0\u{3}repeated_string_wrapper\0\u{3}repeated_bytes_wrapper\0\u{4}R\u{1}optional_duration\0\u{3}optional_timestamp\0\u{3}optional_field_mask\0\u{3}optional_struct\0\u{3}optional_any\0\u{3}optional_value\0\u{3}optional_null_value\0\u{4}\u{4}repeated_duration\0\u{3}repeated_timestamp\0\u{3}repeated_fieldmask\0\u{4}\u{2}repeated_any\0\u{3}repeated_value\0\u{3}repeated_list_value\0\u{4}\u{7}repeated_struct\0\u{2}M\u{1}fieldname1\0\u{3}field_name2\0\u{3}_field_name3\0\u{3}field__name4_\0\u{1}field0name5\0\u{3}field_0_name6\0\u{1}fieldName7\0\u{1}FieldName8\0\u{3}field_Name9\0\u{3}Field_Name10\0\u{3}FIELD_NAME11\0\u{3}FIELD_name12\0\u{3}__field_name13\0\u{3}__Field_name14\0\u{3}field__name15\0\u{3}field__Name16\0\u{3}field_name17__\0\u{3}Field_name18__\0\u{b}reserved_field\0\u{c}u\u{7}\u{a}\u{c}\u{7f}Ht\u{3}\u{1}") + + fileprivate class _StorageClass { + var _optionalInt32: Int32 = 0 + var _optionalInt64: Int64 = 0 + var _optionalUint32: UInt32 = 0 + var _optionalUint64: UInt64 = 0 + var _optionalSint32: Int32 = 0 + var _optionalSint64: Int64 = 0 + var _optionalFixed32: UInt32 = 0 + var _optionalFixed64: UInt64 = 0 + var _optionalSfixed32: Int32 = 0 + var _optionalSfixed64: Int64 = 0 + var _optionalFloat: Float = 0 + var _optionalDouble: Double = 0 + var _optionalBool: Bool = false + var _optionalString: String = String() + var _optionalBytes: Data = Data() + var _optionalNestedMessage: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage? = nil + var _optionalForeignMessage: ProtobufTestMessages_Editions_Proto3_ForeignMessage? = nil + var _optionalNestedEnum: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum = .foo + var _optionalForeignEnum: ProtobufTestMessages_Editions_Proto3_ForeignEnum = .foreignFoo + var _optionalAliasedEnum: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.AliasedEnum = .aliasFoo + var _optionalStringPiece: String = String() + var _optionalCord: String = String() + var _recursiveMessage: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3? = nil + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedNestedMessage: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage] = [] + var _repeatedForeignMessage: [ProtobufTestMessages_Editions_Proto3_ForeignMessage] = [] + var _repeatedNestedEnum: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] = [] + var _repeatedForeignEnum: [ProtobufTestMessages_Editions_Proto3_ForeignEnum] = [] + var _repeatedStringPiece: [String] = [] + var _repeatedCord: [String] = [] + var _packedInt32: [Int32] = [] + var _packedInt64: [Int64] = [] + var _packedUint32: [UInt32] = [] + var _packedUint64: [UInt64] = [] + var _packedSint32: [Int32] = [] + var _packedSint64: [Int64] = [] + var _packedFixed32: [UInt32] = [] + var _packedFixed64: [UInt64] = [] + var _packedSfixed32: [Int32] = [] + var _packedSfixed64: [Int64] = [] + var _packedFloat: [Float] = [] + var _packedDouble: [Double] = [] + var _packedBool: [Bool] = [] + var _packedNestedEnum: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] = [] + var _unpackedInt32: [Int32] = [] + var _unpackedInt64: [Int64] = [] + var _unpackedUint32: [UInt32] = [] + var _unpackedUint64: [UInt64] = [] + var _unpackedSint32: [Int32] = [] + var _unpackedSint64: [Int64] = [] + var _unpackedFixed32: [UInt32] = [] + var _unpackedFixed64: [UInt64] = [] + var _unpackedSfixed32: [Int32] = [] + var _unpackedSfixed64: [Int64] = [] + var _unpackedFloat: [Float] = [] + var _unpackedDouble: [Double] = [] + var _unpackedBool: [Bool] = [] + var _unpackedNestedEnum: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] = [] + var _mapInt32Int32: Dictionary = [:] + var _mapInt64Int64: Dictionary = [:] + var _mapUint32Uint32: Dictionary = [:] + var _mapUint64Uint64: Dictionary = [:] + var _mapSint32Sint32: Dictionary = [:] + var _mapSint64Sint64: Dictionary = [:] + var _mapFixed32Fixed32: Dictionary = [:] + var _mapFixed64Fixed64: Dictionary = [:] + var _mapSfixed32Sfixed32: Dictionary = [:] + var _mapSfixed64Sfixed64: Dictionary = [:] + var _mapInt32Float: Dictionary = [:] + var _mapInt32Double: Dictionary = [:] + var _mapBoolBool: Dictionary = [:] + var _mapStringString: Dictionary = [:] + var _mapStringBytes: Dictionary = [:] + var _mapStringNestedMessage: Dictionary = [:] + var _mapStringForeignMessage: Dictionary = [:] + var _mapStringNestedEnum: Dictionary = [:] + var _mapStringForeignEnum: Dictionary = [:] + var _oneofField: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.OneOf_OneofField? + var _optionalBoolWrapper: SwiftProtobuf.Google_Protobuf_BoolValue? = nil + var _optionalInt32Wrapper: SwiftProtobuf.Google_Protobuf_Int32Value? = nil + var _optionalInt64Wrapper: SwiftProtobuf.Google_Protobuf_Int64Value? = nil + var _optionalUint32Wrapper: SwiftProtobuf.Google_Protobuf_UInt32Value? = nil + var _optionalUint64Wrapper: SwiftProtobuf.Google_Protobuf_UInt64Value? = nil + var _optionalFloatWrapper: SwiftProtobuf.Google_Protobuf_FloatValue? = nil + var _optionalDoubleWrapper: SwiftProtobuf.Google_Protobuf_DoubleValue? = nil + var _optionalStringWrapper: SwiftProtobuf.Google_Protobuf_StringValue? = nil + var _optionalBytesWrapper: SwiftProtobuf.Google_Protobuf_BytesValue? = nil + var _repeatedBoolWrapper: [SwiftProtobuf.Google_Protobuf_BoolValue] = [] + var _repeatedInt32Wrapper: [SwiftProtobuf.Google_Protobuf_Int32Value] = [] + var _repeatedInt64Wrapper: [SwiftProtobuf.Google_Protobuf_Int64Value] = [] + var _repeatedUint32Wrapper: [SwiftProtobuf.Google_Protobuf_UInt32Value] = [] + var _repeatedUint64Wrapper: [SwiftProtobuf.Google_Protobuf_UInt64Value] = [] + var _repeatedFloatWrapper: [SwiftProtobuf.Google_Protobuf_FloatValue] = [] + var _repeatedDoubleWrapper: [SwiftProtobuf.Google_Protobuf_DoubleValue] = [] + var _repeatedStringWrapper: [SwiftProtobuf.Google_Protobuf_StringValue] = [] + var _repeatedBytesWrapper: [SwiftProtobuf.Google_Protobuf_BytesValue] = [] + var _optionalDuration: SwiftProtobuf.Google_Protobuf_Duration? = nil + var _optionalTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp? = nil + var _optionalFieldMask: SwiftProtobuf.Google_Protobuf_FieldMask? = nil + var _optionalStruct: SwiftProtobuf.Google_Protobuf_Struct? = nil + var _optionalAny: SwiftProtobuf.Google_Protobuf_Any? = nil + var _optionalValue: SwiftProtobuf.Google_Protobuf_Value? = nil + var _optionalNullValue: SwiftProtobuf.Google_Protobuf_NullValue = .nullValue + var _repeatedDuration: [SwiftProtobuf.Google_Protobuf_Duration] = [] + var _repeatedTimestamp: [SwiftProtobuf.Google_Protobuf_Timestamp] = [] + var _repeatedFieldmask: [SwiftProtobuf.Google_Protobuf_FieldMask] = [] + var _repeatedStruct: [SwiftProtobuf.Google_Protobuf_Struct] = [] + var _repeatedAny: [SwiftProtobuf.Google_Protobuf_Any] = [] + var _repeatedValue: [SwiftProtobuf.Google_Protobuf_Value] = [] + var _repeatedListValue: [SwiftProtobuf.Google_Protobuf_ListValue] = [] + var _fieldname1: Int32 = 0 + var _fieldName2: Int32 = 0 + var _fieldName3: Int32 = 0 + var _field_Name4_: Int32 = 0 + var _field0Name5: Int32 = 0 + var _field0Name6: Int32 = 0 + var _fieldName7: Int32 = 0 + var _fieldName8: Int32 = 0 + var _fieldName9: Int32 = 0 + var _fieldName10: Int32 = 0 + var _fieldName11: Int32 = 0 + var _fieldName12: Int32 = 0 + var __FieldName13: Int32 = 0 + var __FieldName14: Int32 = 0 + var _field_Name15: Int32 = 0 + var _field_Name16: Int32 = 0 + var _fieldName17__: Int32 = 0 + var _fieldName18__: Int32 = 0 + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalNestedMessage = source._optionalNestedMessage + _optionalForeignMessage = source._optionalForeignMessage + _optionalNestedEnum = source._optionalNestedEnum + _optionalForeignEnum = source._optionalForeignEnum + _optionalAliasedEnum = source._optionalAliasedEnum + _optionalStringPiece = source._optionalStringPiece + _optionalCord = source._optionalCord + _recursiveMessage = source._recursiveMessage + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedForeignMessage = source._repeatedForeignMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _repeatedForeignEnum = source._repeatedForeignEnum + _repeatedStringPiece = source._repeatedStringPiece + _repeatedCord = source._repeatedCord + _packedInt32 = source._packedInt32 + _packedInt64 = source._packedInt64 + _packedUint32 = source._packedUint32 + _packedUint64 = source._packedUint64 + _packedSint32 = source._packedSint32 + _packedSint64 = source._packedSint64 + _packedFixed32 = source._packedFixed32 + _packedFixed64 = source._packedFixed64 + _packedSfixed32 = source._packedSfixed32 + _packedSfixed64 = source._packedSfixed64 + _packedFloat = source._packedFloat + _packedDouble = source._packedDouble + _packedBool = source._packedBool + _packedNestedEnum = source._packedNestedEnum + _unpackedInt32 = source._unpackedInt32 + _unpackedInt64 = source._unpackedInt64 + _unpackedUint32 = source._unpackedUint32 + _unpackedUint64 = source._unpackedUint64 + _unpackedSint32 = source._unpackedSint32 + _unpackedSint64 = source._unpackedSint64 + _unpackedFixed32 = source._unpackedFixed32 + _unpackedFixed64 = source._unpackedFixed64 + _unpackedSfixed32 = source._unpackedSfixed32 + _unpackedSfixed64 = source._unpackedSfixed64 + _unpackedFloat = source._unpackedFloat + _unpackedDouble = source._unpackedDouble + _unpackedBool = source._unpackedBool + _unpackedNestedEnum = source._unpackedNestedEnum + _mapInt32Int32 = source._mapInt32Int32 + _mapInt64Int64 = source._mapInt64Int64 + _mapUint32Uint32 = source._mapUint32Uint32 + _mapUint64Uint64 = source._mapUint64Uint64 + _mapSint32Sint32 = source._mapSint32Sint32 + _mapSint64Sint64 = source._mapSint64Sint64 + _mapFixed32Fixed32 = source._mapFixed32Fixed32 + _mapFixed64Fixed64 = source._mapFixed64Fixed64 + _mapSfixed32Sfixed32 = source._mapSfixed32Sfixed32 + _mapSfixed64Sfixed64 = source._mapSfixed64Sfixed64 + _mapInt32Float = source._mapInt32Float + _mapInt32Double = source._mapInt32Double + _mapBoolBool = source._mapBoolBool + _mapStringString = source._mapStringString + _mapStringBytes = source._mapStringBytes + _mapStringNestedMessage = source._mapStringNestedMessage + _mapStringForeignMessage = source._mapStringForeignMessage + _mapStringNestedEnum = source._mapStringNestedEnum + _mapStringForeignEnum = source._mapStringForeignEnum + _oneofField = source._oneofField + _optionalBoolWrapper = source._optionalBoolWrapper + _optionalInt32Wrapper = source._optionalInt32Wrapper + _optionalInt64Wrapper = source._optionalInt64Wrapper + _optionalUint32Wrapper = source._optionalUint32Wrapper + _optionalUint64Wrapper = source._optionalUint64Wrapper + _optionalFloatWrapper = source._optionalFloatWrapper + _optionalDoubleWrapper = source._optionalDoubleWrapper + _optionalStringWrapper = source._optionalStringWrapper + _optionalBytesWrapper = source._optionalBytesWrapper + _repeatedBoolWrapper = source._repeatedBoolWrapper + _repeatedInt32Wrapper = source._repeatedInt32Wrapper + _repeatedInt64Wrapper = source._repeatedInt64Wrapper + _repeatedUint32Wrapper = source._repeatedUint32Wrapper + _repeatedUint64Wrapper = source._repeatedUint64Wrapper + _repeatedFloatWrapper = source._repeatedFloatWrapper + _repeatedDoubleWrapper = source._repeatedDoubleWrapper + _repeatedStringWrapper = source._repeatedStringWrapper + _repeatedBytesWrapper = source._repeatedBytesWrapper + _optionalDuration = source._optionalDuration + _optionalTimestamp = source._optionalTimestamp + _optionalFieldMask = source._optionalFieldMask + _optionalStruct = source._optionalStruct + _optionalAny = source._optionalAny + _optionalValue = source._optionalValue + _optionalNullValue = source._optionalNullValue + _repeatedDuration = source._repeatedDuration + _repeatedTimestamp = source._repeatedTimestamp + _repeatedFieldmask = source._repeatedFieldmask + _repeatedStruct = source._repeatedStruct + _repeatedAny = source._repeatedAny + _repeatedValue = source._repeatedValue + _repeatedListValue = source._repeatedListValue + _fieldname1 = source._fieldname1 + _fieldName2 = source._fieldName2 + _fieldName3 = source._fieldName3 + _field_Name4_ = source._field_Name4_ + _field0Name5 = source._field0Name5 + _field0Name6 = source._field0Name6 + _fieldName7 = source._fieldName7 + _fieldName8 = source._fieldName8 + _fieldName9 = source._fieldName9 + _fieldName10 = source._fieldName10 + _fieldName11 = source._fieldName11 + _fieldName12 = source._fieldName12 + __FieldName13 = source.__FieldName13 + __FieldName14 = source.__FieldName14 + _field_Name15 = source._field_Name15 + _field_Name16 = source._field_Name16 + _fieldName17__ = source._fieldName17__ + _fieldName18__ = source._fieldName18__ + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() + case 23: try { try decoder.decodeSingularEnumField(value: &_storage._optionalAliasedEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() + case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() + case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() + case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() + case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() + case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() + case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() + case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() + case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() + case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() + case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() + case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() + case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() + case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() + case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() + case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() + case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() + case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() + case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() + case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() + case 56: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Int32) }() + case 57: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() + case 58: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() + case 59: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Uint64) }() + case 60: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Sint32) }() + case 61: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Sint64) }() + case 62: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Fixed32) }() + case 63: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Fixed64) }() + case 64: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Sfixed32) }() + case 65: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Sfixed64) }() + case 66: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Float) }() + case 67: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Double) }() + case 68: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() + case 69: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() + case 70: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() + case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringNestedMessage) }() + case 72: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() + case 73: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringNestedEnum) }() + case 74: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringForeignEnum) }() + case 75: try { try decoder.decodeRepeatedInt32Field(value: &_storage._packedInt32) }() + case 76: try { try decoder.decodeRepeatedInt64Field(value: &_storage._packedInt64) }() + case 77: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._packedUint32) }() + case 78: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._packedUint64) }() + case 79: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._packedSint32) }() + case 80: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._packedSint64) }() + case 81: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._packedFixed32) }() + case 82: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._packedFixed64) }() + case 83: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._packedSfixed32) }() + case 84: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._packedSfixed64) }() + case 85: try { try decoder.decodeRepeatedFloatField(value: &_storage._packedFloat) }() + case 86: try { try decoder.decodeRepeatedDoubleField(value: &_storage._packedDouble) }() + case 87: try { try decoder.decodeRepeatedBoolField(value: &_storage._packedBool) }() + case 88: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedNestedEnum) }() + case 89: try { try decoder.decodeRepeatedInt32Field(value: &_storage._unpackedInt32) }() + case 90: try { try decoder.decodeRepeatedInt64Field(value: &_storage._unpackedInt64) }() + case 91: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._unpackedUint32) }() + case 92: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._unpackedUint64) }() + case 93: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._unpackedSint32) }() + case 94: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._unpackedSint64) }() + case 95: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._unpackedFixed32) }() + case 96: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._unpackedFixed64) }() + case 97: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._unpackedSfixed32) }() + case 98: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._unpackedSfixed64) }() + case 99: try { try decoder.decodeRepeatedFloatField(value: &_storage._unpackedFloat) }() + case 100: try { try decoder.decodeRepeatedDoubleField(value: &_storage._unpackedDouble) }() + case 101: try { try decoder.decodeRepeatedBoolField(value: &_storage._unpackedBool) }() + case 102: try { try decoder.decodeRepeatedEnumField(value: &_storage._unpackedNestedEnum) }() + case 111: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 112: try { + var v: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage(v) + } + }() + case 113: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 114: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() + case 115: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBool(v) + } + }() + case 116: try { + var v: UInt64? + try decoder.decodeSingularUInt64Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint64(v) + } + }() + case 117: try { + var v: Float? + try decoder.decodeSingularFloatField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofFloat(v) + } + }() + case 118: try { + var v: Double? + try decoder.decodeSingularDoubleField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofDouble(v) + } + }() + case 119: try { + var v: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofEnum(v) + } + }() + case 120: try { + var v: SwiftProtobuf.Google_Protobuf_NullValue? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNullValue(v) + } + }() + case 201: try { try decoder.decodeSingularMessageField(value: &_storage._optionalBoolWrapper) }() + case 202: try { try decoder.decodeSingularMessageField(value: &_storage._optionalInt32Wrapper) }() + case 203: try { try decoder.decodeSingularMessageField(value: &_storage._optionalInt64Wrapper) }() + case 204: try { try decoder.decodeSingularMessageField(value: &_storage._optionalUint32Wrapper) }() + case 205: try { try decoder.decodeSingularMessageField(value: &_storage._optionalUint64Wrapper) }() + case 206: try { try decoder.decodeSingularMessageField(value: &_storage._optionalFloatWrapper) }() + case 207: try { try decoder.decodeSingularMessageField(value: &_storage._optionalDoubleWrapper) }() + case 208: try { try decoder.decodeSingularMessageField(value: &_storage._optionalStringWrapper) }() + case 209: try { try decoder.decodeSingularMessageField(value: &_storage._optionalBytesWrapper) }() + case 211: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedBoolWrapper) }() + case 212: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedInt32Wrapper) }() + case 213: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedInt64Wrapper) }() + case 214: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedUint32Wrapper) }() + case 215: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedUint64Wrapper) }() + case 216: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedFloatWrapper) }() + case 217: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedDoubleWrapper) }() + case 218: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedStringWrapper) }() + case 219: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedBytesWrapper) }() + case 301: try { try decoder.decodeSingularMessageField(value: &_storage._optionalDuration) }() + case 302: try { try decoder.decodeSingularMessageField(value: &_storage._optionalTimestamp) }() + case 303: try { try decoder.decodeSingularMessageField(value: &_storage._optionalFieldMask) }() + case 304: try { try decoder.decodeSingularMessageField(value: &_storage._optionalStruct) }() + case 305: try { try decoder.decodeSingularMessageField(value: &_storage._optionalAny) }() + case 306: try { try decoder.decodeSingularMessageField(value: &_storage._optionalValue) }() + case 307: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNullValue) }() + case 311: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedDuration) }() + case 312: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedTimestamp) }() + case 313: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedFieldmask) }() + case 315: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedAny) }() + case 316: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedValue) }() + case 317: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedListValue) }() + case 324: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedStruct) }() + case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldname1) }() + case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName2) }() + case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName3) }() + case 404: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name4_) }() + case 405: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name5) }() + case 406: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name6) }() + case 407: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName7) }() + case 408: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName8) }() + case 409: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName9) }() + case 410: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName10) }() + case 411: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName11) }() + case 412: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName12) }() + case 413: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName13) }() + case 414: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName14) }() + case 415: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name15) }() + case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name16) }() + case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName17__) }() + case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName18__) }() + default: break + } + } + } + } + + func traverse(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 + if _storage._optionalInt32 != 0 { + try visitor.visitSingularInt32Field(value: _storage._optionalInt32, fieldNumber: 1) + } + if _storage._optionalInt64 != 0 { + try visitor.visitSingularInt64Field(value: _storage._optionalInt64, fieldNumber: 2) + } + if _storage._optionalUint32 != 0 { + try visitor.visitSingularUInt32Field(value: _storage._optionalUint32, fieldNumber: 3) + } + if _storage._optionalUint64 != 0 { + try visitor.visitSingularUInt64Field(value: _storage._optionalUint64, fieldNumber: 4) + } + if _storage._optionalSint32 != 0 { + try visitor.visitSingularSInt32Field(value: _storage._optionalSint32, fieldNumber: 5) + } + if _storage._optionalSint64 != 0 { + try visitor.visitSingularSInt64Field(value: _storage._optionalSint64, fieldNumber: 6) + } + if _storage._optionalFixed32 != 0 { + try visitor.visitSingularFixed32Field(value: _storage._optionalFixed32, fieldNumber: 7) + } + if _storage._optionalFixed64 != 0 { + try visitor.visitSingularFixed64Field(value: _storage._optionalFixed64, fieldNumber: 8) + } + if _storage._optionalSfixed32 != 0 { + try visitor.visitSingularSFixed32Field(value: _storage._optionalSfixed32, fieldNumber: 9) + } + if _storage._optionalSfixed64 != 0 { + try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) + } + if _storage._optionalFloat.bitPattern != 0 { + try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) + } + if _storage._optionalDouble.bitPattern != 0 { + try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) + } + if _storage._optionalBool != false { + try visitor.visitSingularBoolField(value: _storage._optionalBool, fieldNumber: 13) + } + if !_storage._optionalString.isEmpty { + try visitor.visitSingularStringField(value: _storage._optionalString, fieldNumber: 14) + } + if !_storage._optionalBytes.isEmpty { + try visitor.visitSingularBytesField(value: _storage._optionalBytes, fieldNumber: 15) + } + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._optionalForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + if _storage._optionalNestedEnum != .foo { + try visitor.visitSingularEnumField(value: _storage._optionalNestedEnum, fieldNumber: 21) + } + if _storage._optionalForeignEnum != .foreignFoo { + try visitor.visitSingularEnumField(value: _storage._optionalForeignEnum, fieldNumber: 22) + } + if _storage._optionalAliasedEnum != .aliasFoo { + try visitor.visitSingularEnumField(value: _storage._optionalAliasedEnum, fieldNumber: 23) + } + if !_storage._optionalStringPiece.isEmpty { + try visitor.visitSingularStringField(value: _storage._optionalStringPiece, fieldNumber: 24) + } + if !_storage._optionalCord.isEmpty { + try visitor.visitSingularStringField(value: _storage._optionalCord, fieldNumber: 25) + } + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + if !_storage._repeatedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + } + if !_storage._repeatedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + } + if !_storage._repeatedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + } + if !_storage._repeatedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + } + if !_storage._repeatedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + } + if !_storage._repeatedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + } + if !_storage._repeatedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + } + if !_storage._repeatedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + } + if !_storage._repeatedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + } + if !_storage._repeatedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + } + if !_storage._repeatedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + } + if !_storage._repeatedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + } + if !_storage._repeatedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + } + if !_storage._repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) + } + if !_storage._repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) + } + if !_storage._repeatedNestedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) + } + if !_storage._repeatedForeignMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) + } + if !_storage._repeatedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + } + if !_storage._repeatedForeignEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) + } + if !_storage._repeatedStringPiece.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) + } + if !_storage._repeatedCord.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) + } + if !_storage._mapInt32Int32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Int32, fieldNumber: 56) + } + if !_storage._mapInt64Int64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Int64, fieldNumber: 57) + } + if !_storage._mapUint32Uint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Uint32, fieldNumber: 58) + } + if !_storage._mapUint64Uint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Uint64, fieldNumber: 59) + } + if !_storage._mapSint32Sint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Sint32, fieldNumber: 60) + } + if !_storage._mapSint64Sint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Sint64, fieldNumber: 61) + } + if !_storage._mapFixed32Fixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Fixed32, fieldNumber: 62) + } + if !_storage._mapFixed64Fixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Fixed64, fieldNumber: 63) + } + if !_storage._mapSfixed32Sfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 64) + } + if !_storage._mapSfixed64Sfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 65) + } + if !_storage._mapInt32Float.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Float, fieldNumber: 66) + } + if !_storage._mapInt32Double.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Double, fieldNumber: 67) + } + if !_storage._mapBoolBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolBool, fieldNumber: 68) + } + if !_storage._mapStringString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringString, fieldNumber: 69) + } + if !_storage._mapStringBytes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 70) + } + if !_storage._mapStringNestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringNestedMessage, fieldNumber: 71) + } + if !_storage._mapStringForeignMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 72) + } + if !_storage._mapStringNestedEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringNestedEnum, fieldNumber: 73) + } + if !_storage._mapStringForeignEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringForeignEnum, fieldNumber: 74) + } + if !_storage._packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._packedInt32, fieldNumber: 75) + } + if !_storage._packedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._packedInt64, fieldNumber: 76) + } + if !_storage._packedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._packedUint32, fieldNumber: 77) + } + if !_storage._packedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._packedUint64, fieldNumber: 78) + } + if !_storage._packedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._packedSint32, fieldNumber: 79) + } + if !_storage._packedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._packedSint64, fieldNumber: 80) + } + if !_storage._packedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._packedFixed32, fieldNumber: 81) + } + if !_storage._packedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._packedFixed64, fieldNumber: 82) + } + if !_storage._packedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._packedSfixed32, fieldNumber: 83) + } + if !_storage._packedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._packedSfixed64, fieldNumber: 84) + } + if !_storage._packedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._packedFloat, fieldNumber: 85) + } + if !_storage._packedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._packedDouble, fieldNumber: 86) + } + if !_storage._packedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._packedBool, fieldNumber: 87) + } + if !_storage._packedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedNestedEnum, fieldNumber: 88) + } + if !_storage._unpackedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._unpackedInt32, fieldNumber: 89) + } + if !_storage._unpackedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._unpackedInt64, fieldNumber: 90) + } + if !_storage._unpackedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._unpackedUint32, fieldNumber: 91) + } + if !_storage._unpackedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._unpackedUint64, fieldNumber: 92) + } + if !_storage._unpackedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._unpackedSint32, fieldNumber: 93) + } + if !_storage._unpackedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._unpackedSint64, fieldNumber: 94) + } + if !_storage._unpackedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._unpackedFixed32, fieldNumber: 95) + } + if !_storage._unpackedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._unpackedFixed64, fieldNumber: 96) + } + if !_storage._unpackedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._unpackedSfixed32, fieldNumber: 97) + } + if !_storage._unpackedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._unpackedSfixed64, fieldNumber: 98) + } + if !_storage._unpackedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._unpackedFloat, fieldNumber: 99) + } + if !_storage._unpackedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._unpackedDouble, fieldNumber: 100) + } + if !_storage._unpackedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._unpackedBool, fieldNumber: 101) + } + if !_storage._unpackedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._unpackedNestedEnum, fieldNumber: 102) + } + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case .oneofBool?: try { + guard case .oneofBool(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 115) + }() + case .oneofUint64?: try { + guard case .oneofUint64(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 116) + }() + case .oneofFloat?: try { + guard case .oneofFloat(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularFloatField(value: v, fieldNumber: 117) + }() + case .oneofDouble?: try { + guard case .oneofDouble(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularDoubleField(value: v, fieldNumber: 118) + }() + case .oneofEnum?: try { + guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 119) + }() + case .oneofNullValue?: try { + guard case .oneofNullValue(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 120) + }() + case nil: break + } + try { if let v = _storage._optionalBoolWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._optionalInt32Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 202) + } }() + try { if let v = _storage._optionalInt64Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 203) + } }() + try { if let v = _storage._optionalUint32Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 204) + } }() + try { if let v = _storage._optionalUint64Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 205) + } }() + try { if let v = _storage._optionalFloatWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 206) + } }() + try { if let v = _storage._optionalDoubleWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 207) + } }() + try { if let v = _storage._optionalStringWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 208) + } }() + try { if let v = _storage._optionalBytesWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 209) + } }() + if !_storage._repeatedBoolWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedBoolWrapper, fieldNumber: 211) + } + if !_storage._repeatedInt32Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedInt32Wrapper, fieldNumber: 212) + } + if !_storage._repeatedInt64Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedInt64Wrapper, fieldNumber: 213) + } + if !_storage._repeatedUint32Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedUint32Wrapper, fieldNumber: 214) + } + if !_storage._repeatedUint64Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedUint64Wrapper, fieldNumber: 215) + } + if !_storage._repeatedFloatWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedFloatWrapper, fieldNumber: 216) + } + if !_storage._repeatedDoubleWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedDoubleWrapper, fieldNumber: 217) + } + if !_storage._repeatedStringWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedStringWrapper, fieldNumber: 218) + } + if !_storage._repeatedBytesWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedBytesWrapper, fieldNumber: 219) + } + try { if let v = _storage._optionalDuration { + try visitor.visitSingularMessageField(value: v, fieldNumber: 301) + } }() + try { if let v = _storage._optionalTimestamp { + try visitor.visitSingularMessageField(value: v, fieldNumber: 302) + } }() + try { if let v = _storage._optionalFieldMask { + try visitor.visitSingularMessageField(value: v, fieldNumber: 303) + } }() + try { if let v = _storage._optionalStruct { + try visitor.visitSingularMessageField(value: v, fieldNumber: 304) + } }() + try { if let v = _storage._optionalAny { + try visitor.visitSingularMessageField(value: v, fieldNumber: 305) + } }() + try { if let v = _storage._optionalValue { + try visitor.visitSingularMessageField(value: v, fieldNumber: 306) + } }() + if _storage._optionalNullValue != .nullValue { + try visitor.visitSingularEnumField(value: _storage._optionalNullValue, fieldNumber: 307) + } + if !_storage._repeatedDuration.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedDuration, fieldNumber: 311) + } + if !_storage._repeatedTimestamp.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedTimestamp, fieldNumber: 312) + } + if !_storage._repeatedFieldmask.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedFieldmask, fieldNumber: 313) + } + if !_storage._repeatedAny.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedAny, fieldNumber: 315) + } + if !_storage._repeatedValue.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedValue, fieldNumber: 316) + } + if !_storage._repeatedListValue.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedListValue, fieldNumber: 317) + } + if !_storage._repeatedStruct.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedStruct, fieldNumber: 324) + } + if _storage._fieldname1 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldname1, fieldNumber: 401) + } + if _storage._fieldName2 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName2, fieldNumber: 402) + } + if _storage._fieldName3 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName3, fieldNumber: 403) + } + if _storage._field_Name4_ != 0 { + try visitor.visitSingularInt32Field(value: _storage._field_Name4_, fieldNumber: 404) + } + if _storage._field0Name5 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field0Name5, fieldNumber: 405) + } + if _storage._field0Name6 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field0Name6, fieldNumber: 406) + } + if _storage._fieldName7 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName7, fieldNumber: 407) + } + if _storage._fieldName8 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName8, fieldNumber: 408) + } + if _storage._fieldName9 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName9, fieldNumber: 409) + } + if _storage._fieldName10 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName10, fieldNumber: 410) + } + if _storage._fieldName11 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName11, fieldNumber: 411) + } + if _storage._fieldName12 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName12, fieldNumber: 412) + } + if _storage.__FieldName13 != 0 { + try visitor.visitSingularInt32Field(value: _storage.__FieldName13, fieldNumber: 413) + } + if _storage.__FieldName14 != 0 { + try visitor.visitSingularInt32Field(value: _storage.__FieldName14, fieldNumber: 414) + } + if _storage._field_Name15 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field_Name15, fieldNumber: 415) + } + if _storage._field_Name16 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field_Name16, fieldNumber: 416) + } + if _storage._fieldName17__ != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName17__, fieldNumber: 417) + } + if _storage._fieldName18__ != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName18__, fieldNumber: 418) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3, rhs: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} + if _storage._optionalAliasedEnum != rhs_storage._optionalAliasedEnum {return false} + if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} + if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} + if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} + if _storage._repeatedCord != rhs_storage._repeatedCord {return false} + if _storage._packedInt32 != rhs_storage._packedInt32 {return false} + if _storage._packedInt64 != rhs_storage._packedInt64 {return false} + if _storage._packedUint32 != rhs_storage._packedUint32 {return false} + if _storage._packedUint64 != rhs_storage._packedUint64 {return false} + if _storage._packedSint32 != rhs_storage._packedSint32 {return false} + if _storage._packedSint64 != rhs_storage._packedSint64 {return false} + if _storage._packedFixed32 != rhs_storage._packedFixed32 {return false} + if _storage._packedFixed64 != rhs_storage._packedFixed64 {return false} + if _storage._packedSfixed32 != rhs_storage._packedSfixed32 {return false} + if _storage._packedSfixed64 != rhs_storage._packedSfixed64 {return false} + if _storage._packedFloat != rhs_storage._packedFloat {return false} + if _storage._packedDouble != rhs_storage._packedDouble {return false} + if _storage._packedBool != rhs_storage._packedBool {return false} + if _storage._packedNestedEnum != rhs_storage._packedNestedEnum {return false} + if _storage._unpackedInt32 != rhs_storage._unpackedInt32 {return false} + if _storage._unpackedInt64 != rhs_storage._unpackedInt64 {return false} + if _storage._unpackedUint32 != rhs_storage._unpackedUint32 {return false} + if _storage._unpackedUint64 != rhs_storage._unpackedUint64 {return false} + if _storage._unpackedSint32 != rhs_storage._unpackedSint32 {return false} + if _storage._unpackedSint64 != rhs_storage._unpackedSint64 {return false} + if _storage._unpackedFixed32 != rhs_storage._unpackedFixed32 {return false} + if _storage._unpackedFixed64 != rhs_storage._unpackedFixed64 {return false} + if _storage._unpackedSfixed32 != rhs_storage._unpackedSfixed32 {return false} + if _storage._unpackedSfixed64 != rhs_storage._unpackedSfixed64 {return false} + if _storage._unpackedFloat != rhs_storage._unpackedFloat {return false} + if _storage._unpackedDouble != rhs_storage._unpackedDouble {return false} + if _storage._unpackedBool != rhs_storage._unpackedBool {return false} + if _storage._unpackedNestedEnum != rhs_storage._unpackedNestedEnum {return false} + if _storage._mapInt32Int32 != rhs_storage._mapInt32Int32 {return false} + if _storage._mapInt64Int64 != rhs_storage._mapInt64Int64 {return false} + if _storage._mapUint32Uint32 != rhs_storage._mapUint32Uint32 {return false} + if _storage._mapUint64Uint64 != rhs_storage._mapUint64Uint64 {return false} + if _storage._mapSint32Sint32 != rhs_storage._mapSint32Sint32 {return false} + if _storage._mapSint64Sint64 != rhs_storage._mapSint64Sint64 {return false} + if _storage._mapFixed32Fixed32 != rhs_storage._mapFixed32Fixed32 {return false} + if _storage._mapFixed64Fixed64 != rhs_storage._mapFixed64Fixed64 {return false} + if _storage._mapSfixed32Sfixed32 != rhs_storage._mapSfixed32Sfixed32 {return false} + if _storage._mapSfixed64Sfixed64 != rhs_storage._mapSfixed64Sfixed64 {return false} + if _storage._mapInt32Float != rhs_storage._mapInt32Float {return false} + if _storage._mapInt32Double != rhs_storage._mapInt32Double {return false} + if _storage._mapBoolBool != rhs_storage._mapBoolBool {return false} + if _storage._mapStringString != rhs_storage._mapStringString {return false} + if _storage._mapStringBytes != rhs_storage._mapStringBytes {return false} + if _storage._mapStringNestedMessage != rhs_storage._mapStringNestedMessage {return false} + if _storage._mapStringForeignMessage != rhs_storage._mapStringForeignMessage {return false} + if _storage._mapStringNestedEnum != rhs_storage._mapStringNestedEnum {return false} + if _storage._mapStringForeignEnum != rhs_storage._mapStringForeignEnum {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + if _storage._optionalBoolWrapper != rhs_storage._optionalBoolWrapper {return false} + if _storage._optionalInt32Wrapper != rhs_storage._optionalInt32Wrapper {return false} + if _storage._optionalInt64Wrapper != rhs_storage._optionalInt64Wrapper {return false} + if _storage._optionalUint32Wrapper != rhs_storage._optionalUint32Wrapper {return false} + if _storage._optionalUint64Wrapper != rhs_storage._optionalUint64Wrapper {return false} + if _storage._optionalFloatWrapper != rhs_storage._optionalFloatWrapper {return false} + if _storage._optionalDoubleWrapper != rhs_storage._optionalDoubleWrapper {return false} + if _storage._optionalStringWrapper != rhs_storage._optionalStringWrapper {return false} + if _storage._optionalBytesWrapper != rhs_storage._optionalBytesWrapper {return false} + if _storage._repeatedBoolWrapper != rhs_storage._repeatedBoolWrapper {return false} + if _storage._repeatedInt32Wrapper != rhs_storage._repeatedInt32Wrapper {return false} + if _storage._repeatedInt64Wrapper != rhs_storage._repeatedInt64Wrapper {return false} + if _storage._repeatedUint32Wrapper != rhs_storage._repeatedUint32Wrapper {return false} + if _storage._repeatedUint64Wrapper != rhs_storage._repeatedUint64Wrapper {return false} + if _storage._repeatedFloatWrapper != rhs_storage._repeatedFloatWrapper {return false} + if _storage._repeatedDoubleWrapper != rhs_storage._repeatedDoubleWrapper {return false} + if _storage._repeatedStringWrapper != rhs_storage._repeatedStringWrapper {return false} + if _storage._repeatedBytesWrapper != rhs_storage._repeatedBytesWrapper {return false} + if _storage._optionalDuration != rhs_storage._optionalDuration {return false} + if _storage._optionalTimestamp != rhs_storage._optionalTimestamp {return false} + if _storage._optionalFieldMask != rhs_storage._optionalFieldMask {return false} + if _storage._optionalStruct != rhs_storage._optionalStruct {return false} + if _storage._optionalAny != rhs_storage._optionalAny {return false} + if _storage._optionalValue != rhs_storage._optionalValue {return false} + if _storage._optionalNullValue != rhs_storage._optionalNullValue {return false} + if _storage._repeatedDuration != rhs_storage._repeatedDuration {return false} + if _storage._repeatedTimestamp != rhs_storage._repeatedTimestamp {return false} + if _storage._repeatedFieldmask != rhs_storage._repeatedFieldmask {return false} + if _storage._repeatedStruct != rhs_storage._repeatedStruct {return false} + if _storage._repeatedAny != rhs_storage._repeatedAny {return false} + if _storage._repeatedValue != rhs_storage._repeatedValue {return false} + if _storage._repeatedListValue != rhs_storage._repeatedListValue {return false} + if _storage._fieldname1 != rhs_storage._fieldname1 {return false} + if _storage._fieldName2 != rhs_storage._fieldName2 {return false} + if _storage._fieldName3 != rhs_storage._fieldName3 {return false} + if _storage._field_Name4_ != rhs_storage._field_Name4_ {return false} + if _storage._field0Name5 != rhs_storage._field0Name5 {return false} + if _storage._field0Name6 != rhs_storage._field0Name6 {return false} + if _storage._fieldName7 != rhs_storage._fieldName7 {return false} + if _storage._fieldName8 != rhs_storage._fieldName8 {return false} + if _storage._fieldName9 != rhs_storage._fieldName9 {return false} + if _storage._fieldName10 != rhs_storage._fieldName10 {return false} + if _storage._fieldName11 != rhs_storage._fieldName11 {return false} + if _storage._fieldName12 != rhs_storage._fieldName12 {return false} + if _storage.__FieldName13 != rhs_storage.__FieldName13 {return false} + if _storage.__FieldName14 != rhs_storage.__FieldName14 {return false} + if _storage._field_Name15 != rhs_storage._field_Name15 {return false} + if _storage._field_Name16 != rhs_storage._field_Name16 {return false} + if _storage._fieldName17__ != rhs_storage._fieldName17__ {return false} + if _storage._fieldName18__ != rhs_storage._fieldName18__ {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.AliasedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ALIAS_FOO\0\u{1}ALIAS_BAR\0\u{9}ALIAS_BAZ\0\u{3}MOO\0moo\0bAz\0") +} + +extension ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32 = 0 + var _corecursive: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + default: break + } + } + } + } + + func traverse(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 + if _storage._a != 0 { + try visitor.visitSingularInt32Field(value: _storage._a, fieldNumber: 1) + } + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage, rhs: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto3_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") + + 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.c) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.c != 0 { + try visitor.visitSingularInt32Field(value: self.c, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto3_ForeignMessage, rhs: ProtobufTestMessages_Editions_Proto3_ForeignMessage) -> Bool { + if lhs.c != rhs.c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto3_NullHypothesisProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NullHypothesisProto3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto3_NullHypothesisProto3, rhs: ProtobufTestMessages_Editions_Proto3_NullHypothesisProto3) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto3_EnumOnlyProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumOnlyProto3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto3_EnumOnlyProto3, rhs: ProtobufTestMessages_Editions_Proto3_EnumOnlyProto3) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto3_EnumOnlyProto3.BoolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0kFalse\0\u{1}kTrue\0") +} diff --git a/Reference/upstream/google/protobuf/any.pb.swift b/Reference/upstream/google/protobuf/any.pb.swift new file mode 100644 index 000000000..76c554248 --- /dev/null +++ b/Reference/upstream/google/protobuf/any.pb.swift @@ -0,0 +1,244 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/any.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. + +// 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: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// `Any` contains an arbitrary serialized protocol buffer message along with a +/// URL that describes the type of the serialized message. +/// +/// Protobuf library provides support to pack/unpack Any values in the form +/// of utility functions or additional generated methods of the Any type. +/// +/// Example 1: Pack and unpack a message in C++. +/// +/// Foo foo = ...; +/// Any any; +/// any.PackFrom(foo); +/// ... +/// if (any.UnpackTo(&foo)) { +/// ... +/// } +/// +/// Example 2: Pack and unpack a message in Java. +/// +/// Foo foo = ...; +/// Any any = Any.pack(foo); +/// ... +/// if (any.is(Foo.class)) { +/// foo = any.unpack(Foo.class); +/// } +/// // or ... +/// if (any.isSameTypeAs(Foo.getDefaultInstance())) { +/// foo = any.unpack(Foo.getDefaultInstance()); +/// } +/// +/// Example 3: Pack and unpack a message in Python. +/// +/// foo = Foo(...) +/// any = Any() +/// any.Pack(foo) +/// ... +/// if any.Is(Foo.DESCRIPTOR): +/// any.Unpack(foo) +/// ... +/// +/// Example 4: Pack and unpack a message in Go +/// +/// foo := &pb.Foo{...} +/// any, err := anypb.New(foo) +/// if err != nil { +/// ... +/// } +/// ... +/// foo := &pb.Foo{} +/// if err := any.UnmarshalTo(foo); err != nil { +/// ... +/// } +/// +/// The pack methods provided by protobuf library will by default use +/// 'type.googleapis.com/full.type.name' as the type URL and the unpack +/// methods only use the fully qualified type name after the last '/' +/// in the type URL, for example "foo.bar.com/x/y.z" will yield type +/// name "y.z". +/// +/// JSON +/// ==== +/// The JSON representation of an `Any` value uses the regular +/// representation of the deserialized, embedded message, with an +/// additional field `@type` which contains the type URL. Example: +/// +/// package google.profile; +/// message Person { +/// string first_name = 1; +/// string last_name = 2; +/// } +/// +/// { +/// "@type": "type.googleapis.com/google.profile.Person", +/// "firstName": , +/// "lastName": +/// } +/// +/// If the embedded message type is well-known and has a custom JSON +/// representation, that representation will be embedded adding a field +/// `value` which holds the custom JSON in addition to the `@type` +/// field. Example (for message [google.protobuf.Duration][]): +/// +/// { +/// "@type": "type.googleapis.com/google.protobuf.Duration", +/// "value": "1.212s" +/// } +struct Google_Protobuf_Any: @unchecked Sendable { + // 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. + + /// A URL/resource name that uniquely identifies the type of the serialized + /// protocol buffer message. This string must contain at least + /// one "/" character. The last segment of the URL's path must represent + /// the fully qualified name of the type (as in + /// `path/google.protobuf.Duration`). The name should be in a canonical form + /// (e.g., leading "." is not accepted). + /// + /// In practice, teams usually precompile into the binary all types that they + /// expect it to use in the context of Any. However, for URLs which use the + /// scheme `http`, `https`, or no scheme, one can optionally set up a type + /// server that maps type URLs to message definitions as follows: + /// + /// * If no scheme is provided, `https` is assumed. + /// * An HTTP GET on the URL must yield a [google.protobuf.Type][] + /// value in binary format, or produce an error. + /// * Applications are allowed to cache lookup results based on the + /// URL, or have them precompiled into a binary to avoid any + /// lookup. Therefore, binary compatibility needs to be preserved + /// on changes to types. (Use versioned type names to manage + /// breaking changes.) + /// + /// Note: this functionality is not currently available in the official + /// protobuf release, and it is not used for type URLs beginning with + /// type.googleapis.com. As of May 2023, there are no widely used type server + /// implementations and no plans to implement one. + /// + /// Schemes other than `http`, `https` (or the empty scheme) might be + /// used with implementation specific semantics. + var typeURL: String { + get {_storage._typeURL} + set {_uniqueStorage()._typeURL = newValue} + } + + /// Must be a valid serialized protocol buffer of the above specified type. + var value: Data { + get {_storage._value} + set {_uniqueStorage()._value = newValue} + } + + var unknownFields = UnknownStorage() + + init() {} + + internal var _storage = _StorageClass.defaultInstance +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "google.protobuf" + +extension Google_Protobuf_Any: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Any" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}type_url\0\u{1}value\0") + + typealias _StorageClass = AnyMessageStorage + + internal mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._typeURL) }() + case 2: try { try decoder.decodeSingularBytesField(value: &_storage._value) }() + default: break + } + } + } + } + + func traverse(visitor: inout V) throws { + try withExtendedLifetime(_storage) { (_storage: _StorageClass) in + try _storage.preTraverse() + if !_storage._typeURL.isEmpty { + try visitor.visitSingularStringField(value: _storage._typeURL, fieldNumber: 1) + } + if !_storage._value.isEmpty { + try visitor.visitSingularBytesField(value: _storage._value, fieldNumber: 2) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_Any, rhs: Google_Protobuf_Any) -> Bool { + if lhs._storage !== rhs._storage { + let storagesAreEqual: Bool = lhs._storage.isEqualTo(other: rhs._storage) + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/any_test.pb.swift b/Reference/upstream/google/protobuf/any_test.pb.swift new file mode 100644 index 000000000..24d7cb897 --- /dev/null +++ b/Reference/upstream/google/protobuf/any_test.pb.swift @@ -0,0 +1,108 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/any_test.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +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 Proto2Unittest_TestAny: Sendable { + // 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 int32Value: Int32 = 0 + + var anyValue: SwiftProtobuf.Google_Protobuf_Any { + get {_anyValue ?? SwiftProtobuf.Google_Protobuf_Any()} + set {_anyValue = newValue} + } + /// Returns true if `anyValue` has been explicitly set. + var hasAnyValue: Bool {self._anyValue != nil} + /// Clears the value of `anyValue`. Subsequent reads from it will return its default value. + mutating func clearAnyValue() {self._anyValue = nil} + + var repeatedAnyValue: [SwiftProtobuf.Google_Protobuf_Any] = [] + + var text: String = String() + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _anyValue: SwiftProtobuf.Google_Protobuf_Any? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest" + +extension Proto2Unittest_TestAny: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAny" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}int32_value\0\u{3}any_value\0\u{3}repeated_any_value\0\u{1}text\0") + + 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.int32Value) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._anyValue) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAnyValue) }() + case 4: try { try decoder.decodeSingularStringField(value: &self.text) }() + 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 + if self.int32Value != 0 { + try visitor.visitSingularInt32Field(value: self.int32Value, fieldNumber: 1) + } + try { if let v = self._anyValue { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + if !self.repeatedAnyValue.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAnyValue, fieldNumber: 3) + } + if !self.text.isEmpty { + try visitor.visitSingularStringField(value: self.text, fieldNumber: 4) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestAny, rhs: Proto2Unittest_TestAny) -> Bool { + if lhs.int32Value != rhs.int32Value {return false} + if lhs._anyValue != rhs._anyValue {return false} + if lhs.repeatedAnyValue != rhs.repeatedAnyValue {return false} + if lhs.text != rhs.text {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/api.pb.swift b/Reference/upstream/google/protobuf/api.pb.swift new file mode 100644 index 000000000..645cddc18 --- /dev/null +++ b/Reference/upstream/google/protobuf/api.pb.swift @@ -0,0 +1,446 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/api.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. + +// 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: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// Api is a light-weight descriptor for an API Interface. +/// +/// Interfaces are also described as "protocol buffer services" in some contexts, +/// such as by the "service" keyword in a .proto file, but they are different +/// from API Services, which represent a concrete implementation of an interface +/// as opposed to simply a description of methods and bindings. They are also +/// sometimes simply referred to as "APIs" in other contexts, such as the name of +/// this message itself. See https://cloud.google.com/apis/design/glossary for +/// detailed terminology. +/// +/// New usages of this message as an alternative to ServiceDescriptorProto are +/// strongly discouraged. This message does not reliability preserve all +/// information necessary to model the schema and preserve semantics. Instead +/// make use of FileDescriptorSet which preserves the necessary information. +struct Google_Protobuf_Api: Sendable { + // 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. + + /// The fully qualified name of this interface, including package name + /// followed by the interface's simple name. + var name: String = String() + + /// The methods of this interface, in unspecified order. + var methods: [Google_Protobuf_Method] = [] + + /// Any metadata attached to the interface. + var options: [Google_Protobuf_Option] = [] + + /// A version string for this interface. If specified, must have the form + /// `major-version.minor-version`, as in `1.10`. If the minor version is + /// omitted, it defaults to zero. If the entire version field is empty, the + /// major version is derived from the package name, as outlined below. If the + /// field is not empty, the version in the package name will be verified to be + /// consistent with what is provided here. + /// + /// The versioning schema uses [semantic + /// versioning](http://semver.org) where the major version number + /// indicates a breaking change and the minor version an additive, + /// non-breaking change. Both version numbers are signals to users + /// what to expect from different versions, and should be carefully + /// chosen based on the product plan. + /// + /// The major version is also reflected in the package name of the + /// interface, which must end in `v`, as in + /// `google.feature.v1`. For major versions 0 and 1, the suffix can + /// be omitted. Zero major versions must only be used for + /// experimental, non-GA interfaces. + var version: String = String() + + /// Source context for the protocol buffer service represented by this + /// message. + var sourceContext: Google_Protobuf_SourceContext { + get {_sourceContext ?? Google_Protobuf_SourceContext()} + set {_sourceContext = newValue} + } + /// Returns true if `sourceContext` has been explicitly set. + var hasSourceContext: Bool {self._sourceContext != nil} + /// Clears the value of `sourceContext`. Subsequent reads from it will return its default value. + mutating func clearSourceContext() {self._sourceContext = nil} + + /// Included interfaces. See [Mixin][]. + var mixins: [Google_Protobuf_Mixin] = [] + + /// The source syntax of the service. + var syntax: Google_Protobuf_Syntax = .proto2 + + /// The source edition string, only valid when syntax is SYNTAX_EDITIONS. + var edition: String = String() + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _sourceContext: Google_Protobuf_SourceContext? = nil +} + +/// Method represents a method of an API interface. +/// +/// New usages of this message as an alternative to MethodDescriptorProto are +/// strongly discouraged. This message does not reliability preserve all +/// information necessary to model the schema and preserve semantics. Instead +/// make use of FileDescriptorSet which preserves the necessary information. +struct Google_Protobuf_Method: Sendable { + // 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. + + /// The simple name of this method. + var name: String = String() + + /// A URL of the input message type. + var requestTypeURL: String = String() + + /// If true, the request is streamed. + var requestStreaming: Bool = false + + /// The URL of the output message type. + var responseTypeURL: String = String() + + /// If true, the response is streamed. + var responseStreaming: Bool = false + + /// Any metadata attached to the method. + var options: [Google_Protobuf_Option] = [] + + /// The source syntax of this method. + /// + /// This field should be ignored, instead the syntax should be inherited from + /// Api. This is similar to Field and EnumValue. + /// + /// NOTE: This field was marked as deprecated in the .proto file. + var syntax: Google_Protobuf_Syntax = .proto2 + + /// The source edition string, only valid when syntax is SYNTAX_EDITIONS. + /// + /// This field should be ignored, instead the edition should be inherited from + /// Api. This is similar to Field and EnumValue. + /// + /// NOTE: This field was marked as deprecated in the .proto file. + var edition: String = String() + + var unknownFields = UnknownStorage() + + init() {} +} + +/// Declares an API Interface to be included in this interface. The including +/// interface must redeclare all the methods from the included interface, but +/// documentation and options are inherited as follows: +/// +/// - If after comment and whitespace stripping, the documentation +/// string of the redeclared method is empty, it will be inherited +/// from the original method. +/// +/// - Each annotation belonging to the service config (http, +/// visibility) which is not set in the redeclared method will be +/// inherited. +/// +/// - If an http annotation is inherited, the path pattern will be +/// modified as follows. Any version prefix will be replaced by the +/// version of the including interface plus the [root][] path if +/// specified. +/// +/// Example of a simple mixin: +/// +/// package google.acl.v1; +/// service AccessControl { +/// // Get the underlying ACL object. +/// rpc GetAcl(GetAclRequest) returns (Acl) { +/// option (google.api.http).get = "/v1/{resource=**}:getAcl"; +/// } +/// } +/// +/// package google.storage.v2; +/// service Storage { +/// rpc GetAcl(GetAclRequest) returns (Acl); +/// +/// // Get a data record. +/// rpc GetData(GetDataRequest) returns (Data) { +/// option (google.api.http).get = "/v2/{resource=**}"; +/// } +/// } +/// +/// Example of a mixin configuration: +/// +/// apis: +/// - name: google.storage.v2.Storage +/// mixins: +/// - name: google.acl.v1.AccessControl +/// +/// The mixin construct implies that all methods in `AccessControl` are +/// also declared with same name and request/response types in +/// `Storage`. A documentation generator or annotation processor will +/// see the effective `Storage.GetAcl` method after inheriting +/// documentation and annotations as follows: +/// +/// service Storage { +/// // Get the underlying ACL object. +/// rpc GetAcl(GetAclRequest) returns (Acl) { +/// option (google.api.http).get = "/v2/{resource=**}:getAcl"; +/// } +/// ... +/// } +/// +/// Note how the version in the path pattern changed from `v1` to `v2`. +/// +/// If the `root` field in the mixin is specified, it should be a +/// relative path under which inherited HTTP paths are placed. Example: +/// +/// apis: +/// - name: google.storage.v2.Storage +/// mixins: +/// - name: google.acl.v1.AccessControl +/// root: acls +/// +/// This implies the following inherited HTTP annotation: +/// +/// service Storage { +/// // Get the underlying ACL object. +/// rpc GetAcl(GetAclRequest) returns (Acl) { +/// option (google.api.http).get = "/v2/acls/{resource=**}:getAcl"; +/// } +/// ... +/// } +struct Google_Protobuf_Mixin: Sendable { + // 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. + + /// The fully qualified name of the interface which is included. + var name: String = String() + + /// If non-empty specifies a path under which inherited HTTP paths + /// are rooted. + var root: String = String() + + var unknownFields = UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "google.protobuf" + +extension Google_Protobuf_Api: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Api" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}methods\0\u{1}options\0\u{1}version\0\u{3}source_context\0\u{1}mixins\0\u{1}syntax\0\u{1}edition\0") + + 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.name) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.methods) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &self.options) }() + case 4: try { try decoder.decodeSingularStringField(value: &self.version) }() + case 5: try { try decoder.decodeSingularMessageField(value: &self._sourceContext) }() + case 6: try { try decoder.decodeRepeatedMessageField(value: &self.mixins) }() + case 7: try { try decoder.decodeSingularEnumField(value: &self.syntax) }() + case 8: try { try decoder.decodeSingularStringField(value: &self.edition) }() + 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 + if !self.name.isEmpty { + try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) + } + if !self.methods.isEmpty { + try visitor.visitRepeatedMessageField(value: self.methods, fieldNumber: 2) + } + if !self.options.isEmpty { + try visitor.visitRepeatedMessageField(value: self.options, fieldNumber: 3) + } + if !self.version.isEmpty { + try visitor.visitSingularStringField(value: self.version, fieldNumber: 4) + } + try { if let v = self._sourceContext { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + if !self.mixins.isEmpty { + try visitor.visitRepeatedMessageField(value: self.mixins, fieldNumber: 6) + } + if self.syntax != .proto2 { + try visitor.visitSingularEnumField(value: self.syntax, fieldNumber: 7) + } + if !self.edition.isEmpty { + try visitor.visitSingularStringField(value: self.edition, fieldNumber: 8) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_Api, rhs: Google_Protobuf_Api) -> Bool { + if lhs.name != rhs.name {return false} + if lhs.methods != rhs.methods {return false} + if lhs.options != rhs.options {return false} + if lhs.version != rhs.version {return false} + if lhs._sourceContext != rhs._sourceContext {return false} + if lhs.mixins != rhs.mixins {return false} + if lhs.syntax != rhs.syntax {return false} + if lhs.edition != rhs.edition {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_Method: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Method" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{3}request_type_url\0\u{3}request_streaming\0\u{3}response_type_url\0\u{3}response_streaming\0\u{1}options\0\u{1}syntax\0\u{1}edition\0") + + 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.name) }() + case 2: try { try decoder.decodeSingularStringField(value: &self.requestTypeURL) }() + case 3: try { try decoder.decodeSingularBoolField(value: &self.requestStreaming) }() + case 4: try { try decoder.decodeSingularStringField(value: &self.responseTypeURL) }() + case 5: try { try decoder.decodeSingularBoolField(value: &self.responseStreaming) }() + case 6: try { try decoder.decodeRepeatedMessageField(value: &self.options) }() + case 7: try { try decoder.decodeSingularEnumField(value: &self.syntax) }() + case 8: try { try decoder.decodeSingularStringField(value: &self.edition) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.name.isEmpty { + try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) + } + if !self.requestTypeURL.isEmpty { + try visitor.visitSingularStringField(value: self.requestTypeURL, fieldNumber: 2) + } + if self.requestStreaming != false { + try visitor.visitSingularBoolField(value: self.requestStreaming, fieldNumber: 3) + } + if !self.responseTypeURL.isEmpty { + try visitor.visitSingularStringField(value: self.responseTypeURL, fieldNumber: 4) + } + if self.responseStreaming != false { + try visitor.visitSingularBoolField(value: self.responseStreaming, fieldNumber: 5) + } + if !self.options.isEmpty { + try visitor.visitRepeatedMessageField(value: self.options, fieldNumber: 6) + } + if self.syntax != .proto2 { + try visitor.visitSingularEnumField(value: self.syntax, fieldNumber: 7) + } + if !self.edition.isEmpty { + try visitor.visitSingularStringField(value: self.edition, fieldNumber: 8) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_Method, rhs: Google_Protobuf_Method) -> Bool { + if lhs.name != rhs.name {return false} + if lhs.requestTypeURL != rhs.requestTypeURL {return false} + if lhs.requestStreaming != rhs.requestStreaming {return false} + if lhs.responseTypeURL != rhs.responseTypeURL {return false} + if lhs.responseStreaming != rhs.responseStreaming {return false} + if lhs.options != rhs.options {return false} + if lhs.syntax != rhs.syntax {return false} + if lhs.edition != rhs.edition {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_Mixin: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Mixin" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}root\0") + + 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.name) }() + case 2: try { try decoder.decodeSingularStringField(value: &self.root) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.name.isEmpty { + try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) + } + if !self.root.isEmpty { + try visitor.visitSingularStringField(value: self.root, fieldNumber: 2) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_Mixin, rhs: Google_Protobuf_Mixin) -> Bool { + if lhs.name != rhs.name {return false} + if lhs.root != rhs.root {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/compiler/plugin.pb.swift b/Reference/upstream/google/protobuf/compiler/plugin.pb.swift new file mode 100644 index 000000000..930d2c42c --- /dev/null +++ b/Reference/upstream/google/protobuf/compiler/plugin.pb.swift @@ -0,0 +1,568 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/compiler/plugin.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// +// protoc (aka the Protocol Compiler) can be extended via plugins. A plugin is +// just a program that reads a CodeGeneratorRequest from stdin and writes a +// CodeGeneratorResponse to stdout. +// +// Plugins written using C++ can use google/protobuf/compiler/plugin.h instead +// of dealing with the raw protocol defined here. +// +// A plugin executable needs only to be placed somewhere in the path. The +// plugin should be named "protoc-gen-$NAME", and will then be used when the +// flag "--${NAME}_out" is passed to protoc. + +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 +} + +/// The version number of protocol compiler. +struct Google_Protobuf_Compiler_Version: Sendable { + // 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 major: Int32 { + get {_major ?? 0} + set {_major = newValue} + } + /// Returns true if `major` has been explicitly set. + var hasMajor: Bool {self._major != nil} + /// Clears the value of `major`. Subsequent reads from it will return its default value. + mutating func clearMajor() {self._major = nil} + + var minor: Int32 { + get {_minor ?? 0} + set {_minor = newValue} + } + /// Returns true if `minor` has been explicitly set. + var hasMinor: Bool {self._minor != nil} + /// Clears the value of `minor`. Subsequent reads from it will return its default value. + mutating func clearMinor() {self._minor = nil} + + var patch: Int32 { + get {_patch ?? 0} + set {_patch = newValue} + } + /// Returns true if `patch` has been explicitly set. + var hasPatch: Bool {self._patch != nil} + /// Clears the value of `patch`. Subsequent reads from it will return its default value. + mutating func clearPatch() {self._patch = nil} + + /// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should + /// be empty for mainline stable releases. + var suffix: String { + get {_suffix ?? String()} + set {_suffix = newValue} + } + /// Returns true if `suffix` has been explicitly set. + var hasSuffix: Bool {self._suffix != nil} + /// Clears the value of `suffix`. Subsequent reads from it will return its default value. + mutating func clearSuffix() {self._suffix = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _major: Int32? = nil + fileprivate var _minor: Int32? = nil + fileprivate var _patch: Int32? = nil + fileprivate var _suffix: String? = nil +} + +/// An encoded CodeGeneratorRequest is written to the plugin's stdin. +struct Google_Protobuf_Compiler_CodeGeneratorRequest: Sendable { + // 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. + + /// The .proto files that were explicitly listed on the command-line. The + /// code generator should generate code only for these files. Each file's + /// descriptor will be included in proto_file, below. + var fileToGenerate: [String] = [] + + /// The generator parameter passed on the command-line. + var parameter: String { + get {_parameter ?? String()} + set {_parameter = newValue} + } + /// Returns true if `parameter` has been explicitly set. + var hasParameter: Bool {self._parameter != nil} + /// Clears the value of `parameter`. Subsequent reads from it will return its default value. + mutating func clearParameter() {self._parameter = nil} + + /// FileDescriptorProtos for all files in files_to_generate and everything + /// they import. The files will appear in topological order, so each file + /// appears before any file that imports it. + /// + /// Note: the files listed in files_to_generate will include runtime-retention + /// options only, but all other files will include source-retention options. + /// The source_file_descriptors field below is available in case you need + /// source-retention options for files_to_generate. + /// + /// protoc guarantees that all proto_files will be written after + /// the fields above, even though this is not technically guaranteed by the + /// protobuf wire format. This theoretically could allow a plugin to stream + /// in the FileDescriptorProtos and handle them one by one rather than read + /// the entire set into memory at once. However, as of this writing, this + /// is not similarly optimized on protoc's end -- it will store all fields in + /// memory at once before sending them to the plugin. + /// + /// Type names of fields and extensions in the FileDescriptorProto are always + /// fully qualified. + var protoFile: [SwiftProtobuf.Google_Protobuf_FileDescriptorProto] = [] + + /// File descriptors with all options, including source-retention options. + /// These descriptors are only provided for the files listed in + /// files_to_generate. + var sourceFileDescriptors: [SwiftProtobuf.Google_Protobuf_FileDescriptorProto] = [] + + /// The version number of protocol compiler. + var compilerVersion: Google_Protobuf_Compiler_Version { + get {_compilerVersion ?? Google_Protobuf_Compiler_Version()} + set {_compilerVersion = newValue} + } + /// Returns true if `compilerVersion` has been explicitly set. + var hasCompilerVersion: Bool {self._compilerVersion != nil} + /// Clears the value of `compilerVersion`. Subsequent reads from it will return its default value. + mutating func clearCompilerVersion() {self._compilerVersion = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _parameter: String? = nil + fileprivate var _compilerVersion: Google_Protobuf_Compiler_Version? = nil +} + +/// The plugin writes an encoded CodeGeneratorResponse to stdout. +struct Google_Protobuf_Compiler_CodeGeneratorResponse: Sendable { + // 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. + + /// Error message. If non-empty, code generation failed. The plugin process + /// should exit with status code zero even if it reports an error in this way. + /// + /// This should be used to indicate errors in .proto files which prevent the + /// code generator from generating correct code. Errors which indicate a + /// problem in protoc itself -- such as the input CodeGeneratorRequest being + /// unparseable -- should be reported by writing a message to stderr and + /// exiting with a non-zero status code. + var error: String { + get {_error ?? String()} + set {_error = newValue} + } + /// Returns true if `error` has been explicitly set. + var hasError: Bool {self._error != nil} + /// Clears the value of `error`. Subsequent reads from it will return its default value. + mutating func clearError() {self._error = nil} + + /// A bitmask of supported features that the code generator supports. + /// This is a bitwise "or" of values from the Feature enum. + var supportedFeatures: UInt64 { + get {_supportedFeatures ?? 0} + set {_supportedFeatures = newValue} + } + /// Returns true if `supportedFeatures` has been explicitly set. + var hasSupportedFeatures: Bool {self._supportedFeatures != nil} + /// Clears the value of `supportedFeatures`. Subsequent reads from it will return its default value. + mutating func clearSupportedFeatures() {self._supportedFeatures = nil} + + /// The minimum edition this plugin supports. This will be treated as an + /// Edition enum, but we want to allow unknown values. It should be specified + /// according the edition enum value, *not* the edition number. Only takes + /// effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + var minimumEdition: Int32 { + get {_minimumEdition ?? 0} + set {_minimumEdition = newValue} + } + /// Returns true if `minimumEdition` has been explicitly set. + var hasMinimumEdition: Bool {self._minimumEdition != nil} + /// Clears the value of `minimumEdition`. Subsequent reads from it will return its default value. + mutating func clearMinimumEdition() {self._minimumEdition = nil} + + /// The maximum edition this plugin supports. This will be treated as an + /// Edition enum, but we want to allow unknown values. It should be specified + /// according the edition enum value, *not* the edition number. Only takes + /// effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + var maximumEdition: Int32 { + get {_maximumEdition ?? 0} + set {_maximumEdition = newValue} + } + /// Returns true if `maximumEdition` has been explicitly set. + var hasMaximumEdition: Bool {self._maximumEdition != nil} + /// Clears the value of `maximumEdition`. Subsequent reads from it will return its default value. + mutating func clearMaximumEdition() {self._maximumEdition = nil} + + var file: [Google_Protobuf_Compiler_CodeGeneratorResponse.File] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + /// Sync with code_generator.h. + enum Feature: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case none = 0 + case proto3Optional = 1 + case supportsEditions = 2 + + init() { + self = .none + } + + } + + /// Represents a single generated file. + struct File: Sendable { + // 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. + + /// The file name, relative to the output directory. The name must not + /// contain "." or ".." components and must be relative, not be absolute (so, + /// the file cannot lie outside the output directory). "/" must be used as + /// the path separator, not "\". + /// + /// If the name is omitted, the content will be appended to the previous + /// file. This allows the generator to break large files into small chunks, + /// and allows the generated text to be streamed back to protoc so that large + /// files need not reside completely in memory at one time. Note that as of + /// this writing protoc does not optimize for this -- it will read the entire + /// CodeGeneratorResponse before writing files to disk. + var name: String { + get {_name ?? String()} + set {_name = newValue} + } + /// Returns true if `name` has been explicitly set. + var hasName: Bool {self._name != nil} + /// Clears the value of `name`. Subsequent reads from it will return its default value. + mutating func clearName() {self._name = nil} + + /// If non-empty, indicates that the named file should already exist, and the + /// content here is to be inserted into that file at a defined insertion + /// point. This feature allows a code generator to extend the output + /// produced by another code generator. The original generator may provide + /// insertion points by placing special annotations in the file that look + /// like: + /// @@protoc_insertion_point(NAME) + /// The annotation can have arbitrary text before and after it on the line, + /// which allows it to be placed in a comment. NAME should be replaced with + /// an identifier naming the point -- this is what other generators will use + /// as the insertion_point. Code inserted at this point will be placed + /// immediately above the line containing the insertion point (thus multiple + /// insertions to the same point will come out in the order they were added). + /// The double-@ is intended to make it unlikely that the generated code + /// could contain things that look like insertion points by accident. + /// + /// For example, the C++ code generator places the following line in the + /// .pb.h files that it generates: + /// // @@protoc_insertion_point(namespace_scope) + /// This line appears within the scope of the file's package namespace, but + /// outside of any particular class. Another plugin can then specify the + /// insertion_point "namespace_scope" to generate additional classes or + /// other declarations that should be placed in this scope. + /// + /// Note that if the line containing the insertion point begins with + /// whitespace, the same whitespace will be added to every line of the + /// inserted text. This is useful for languages like Python, where + /// indentation matters. In these languages, the insertion point comment + /// should be indented the same amount as any inserted code will need to be + /// in order to work correctly in that context. + /// + /// The code generator that generates the initial file and the one which + /// inserts into it must both run as part of a single invocation of protoc. + /// Code generators are executed in the order in which they appear on the + /// command line. + /// + /// If |insertion_point| is present, |name| must also be present. + var insertionPoint: String { + get {_insertionPoint ?? String()} + set {_insertionPoint = newValue} + } + /// Returns true if `insertionPoint` has been explicitly set. + var hasInsertionPoint: Bool {self._insertionPoint != nil} + /// Clears the value of `insertionPoint`. Subsequent reads from it will return its default value. + mutating func clearInsertionPoint() {self._insertionPoint = nil} + + /// The file contents. + var content: String { + get {_content ?? String()} + set {_content = newValue} + } + /// Returns true if `content` has been explicitly set. + var hasContent: Bool {self._content != nil} + /// Clears the value of `content`. Subsequent reads from it will return its default value. + mutating func clearContent() {self._content = nil} + + /// Information describing the file content being inserted. If an insertion + /// point is used, this information will be appropriately offset and inserted + /// into the code generation metadata for the generated files. + var generatedCodeInfo: SwiftProtobuf.Google_Protobuf_GeneratedCodeInfo { + get {_generatedCodeInfo ?? SwiftProtobuf.Google_Protobuf_GeneratedCodeInfo()} + set {_generatedCodeInfo = newValue} + } + /// Returns true if `generatedCodeInfo` has been explicitly set. + var hasGeneratedCodeInfo: Bool {self._generatedCodeInfo != nil} + /// Clears the value of `generatedCodeInfo`. Subsequent reads from it will return its default value. + mutating func clearGeneratedCodeInfo() {self._generatedCodeInfo = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _name: String? = nil + fileprivate var _insertionPoint: String? = nil + fileprivate var _content: String? = nil + fileprivate var _generatedCodeInfo: SwiftProtobuf.Google_Protobuf_GeneratedCodeInfo? = nil + } + + init() {} + + fileprivate var _error: String? = nil + fileprivate var _supportedFeatures: UInt64? = nil + fileprivate var _minimumEdition: Int32? = nil + fileprivate var _maximumEdition: Int32? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "google.protobuf.compiler" + +extension Google_Protobuf_Compiler_Version: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Version" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}major\0\u{1}minor\0\u{1}patch\0\u{1}suffix\0") + + 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._major) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._minor) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._patch) }() + case 4: try { try decoder.decodeSingularStringField(value: &self._suffix) }() + 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 + try { if let v = self._major { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._minor { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._patch { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._suffix { + try visitor.visitSingularStringField(value: v, fieldNumber: 4) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_Compiler_Version, rhs: Google_Protobuf_Compiler_Version) -> Bool { + if lhs._major != rhs._major {return false} + if lhs._minor != rhs._minor {return false} + if lhs._patch != rhs._patch {return false} + if lhs._suffix != rhs._suffix {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_Compiler_CodeGeneratorRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".CodeGeneratorRequest" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}file_to_generate\0\u{1}parameter\0\u{3}compiler_version\0\u{4}\u{c}proto_file\0\u{4}\u{2}source_file_descriptors\0") + + public var isInitialized: Bool { + if !SwiftProtobuf.Internal.areAllInitialized(self.protoFile) {return false} + if !SwiftProtobuf.Internal.areAllInitialized(self.sourceFileDescriptors) {return false} + return true + } + + 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.decodeRepeatedStringField(value: &self.fileToGenerate) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._parameter) }() + case 3: try { try decoder.decodeSingularMessageField(value: &self._compilerVersion) }() + case 15: try { try decoder.decodeRepeatedMessageField(value: &self.protoFile) }() + case 17: try { try decoder.decodeRepeatedMessageField(value: &self.sourceFileDescriptors) }() + 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 + if !self.fileToGenerate.isEmpty { + try visitor.visitRepeatedStringField(value: self.fileToGenerate, fieldNumber: 1) + } + try { if let v = self._parameter { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._compilerVersion { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + if !self.protoFile.isEmpty { + try visitor.visitRepeatedMessageField(value: self.protoFile, fieldNumber: 15) + } + if !self.sourceFileDescriptors.isEmpty { + try visitor.visitRepeatedMessageField(value: self.sourceFileDescriptors, fieldNumber: 17) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_Compiler_CodeGeneratorRequest, rhs: Google_Protobuf_Compiler_CodeGeneratorRequest) -> Bool { + if lhs.fileToGenerate != rhs.fileToGenerate {return false} + if lhs._parameter != rhs._parameter {return false} + if lhs.protoFile != rhs.protoFile {return false} + if lhs.sourceFileDescriptors != rhs.sourceFileDescriptors {return false} + if lhs._compilerVersion != rhs._compilerVersion {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_Compiler_CodeGeneratorResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".CodeGeneratorResponse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}error\0\u{3}supported_features\0\u{3}minimum_edition\0\u{3}maximum_edition\0\u{2}\u{b}file\0") + + 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._error) }() + case 2: try { try decoder.decodeSingularUInt64Field(value: &self._supportedFeatures) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._minimumEdition) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &self._maximumEdition) }() + case 15: try { try decoder.decodeRepeatedMessageField(value: &self.file) }() + 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 + try { if let v = self._error { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = self._supportedFeatures { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._minimumEdition { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._maximumEdition { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + if !self.file.isEmpty { + try visitor.visitRepeatedMessageField(value: self.file, fieldNumber: 15) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_Compiler_CodeGeneratorResponse, rhs: Google_Protobuf_Compiler_CodeGeneratorResponse) -> Bool { + if lhs._error != rhs._error {return false} + if lhs._supportedFeatures != rhs._supportedFeatures {return false} + if lhs._minimumEdition != rhs._minimumEdition {return false} + if lhs._maximumEdition != rhs._maximumEdition {return false} + if lhs.file != rhs.file {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_Compiler_CodeGeneratorResponse.Feature: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FEATURE_NONE\0\u{1}FEATURE_PROTO3_OPTIONAL\0\u{1}FEATURE_SUPPORTS_EDITIONS\0") +} + +extension Google_Protobuf_Compiler_CodeGeneratorResponse.File: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Google_Protobuf_Compiler_CodeGeneratorResponse.protoMessageName + ".File" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}name\0\u{3}insertion_point\0\u{2}\u{d}content\0\u{3}generated_code_info\0") + + 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._name) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._insertionPoint) }() + case 15: try { try decoder.decodeSingularStringField(value: &self._content) }() + case 16: try { try decoder.decodeSingularMessageField(value: &self._generatedCodeInfo) }() + 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 + try { if let v = self._name { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = self._insertionPoint { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._content { + try visitor.visitSingularStringField(value: v, fieldNumber: 15) + } }() + try { if let v = self._generatedCodeInfo { + try visitor.visitSingularMessageField(value: v, fieldNumber: 16) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_Compiler_CodeGeneratorResponse.File, rhs: Google_Protobuf_Compiler_CodeGeneratorResponse.File) -> Bool { + if lhs._name != rhs._name {return false} + if lhs._insertionPoint != rhs._insertionPoint {return false} + if lhs._content != rhs._content {return false} + if lhs._generatedCodeInfo != rhs._generatedCodeInfo {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/cpp_features.pb.swift b/Reference/upstream/google/protobuf/cpp_features.pb.swift new file mode 100644 index 000000000..0a50297db --- /dev/null +++ b/Reference/upstream/google/protobuf/cpp_features.pb.swift @@ -0,0 +1,184 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/cpp_features.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2023 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +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 Pb_CppFeatures: Sendable { + // 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. + + /// Whether or not to treat an enum field as closed. This option is only + /// applicable to enum fields, and will be removed in the future. It is + /// consistent with the legacy behavior of using proto3 enum types for proto2 + /// fields. + var legacyClosedEnum: Bool { + get {_legacyClosedEnum ?? false} + set {_legacyClosedEnum = newValue} + } + /// Returns true if `legacyClosedEnum` has been explicitly set. + var hasLegacyClosedEnum: Bool {self._legacyClosedEnum != nil} + /// Clears the value of `legacyClosedEnum`. Subsequent reads from it will return its default value. + mutating func clearLegacyClosedEnum() {self._legacyClosedEnum = nil} + + var stringType: Pb_CppFeatures.StringType { + get {_stringType ?? .unknown} + set {_stringType = newValue} + } + /// Returns true if `stringType` has been explicitly set. + var hasStringType: Bool {self._stringType != nil} + /// Clears the value of `stringType`. Subsequent reads from it will return its default value. + mutating func clearStringType() {self._stringType = nil} + + var enumNameUsesStringView: Bool { + get {_enumNameUsesStringView ?? false} + set {_enumNameUsesStringView = newValue} + } + /// Returns true if `enumNameUsesStringView` has been explicitly set. + var hasEnumNameUsesStringView: Bool {self._enumNameUsesStringView != nil} + /// Clears the value of `enumNameUsesStringView`. Subsequent reads from it will return its default value. + mutating func clearEnumNameUsesStringView() {self._enumNameUsesStringView = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum StringType: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unknown = 0 + case view = 1 + case cord = 2 + case string = 3 + + init() { + self = .unknown + } + + } + + init() {} + + fileprivate var _legacyClosedEnum: Bool? = nil + fileprivate var _stringType: Pb_CppFeatures.StringType? = nil + fileprivate var _enumNameUsesStringView: Bool? = nil +} + +// MARK: - Extension support defined in cpp_features.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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_FeatureSet { + + var Pb_cpp: Pb_CppFeatures { + get {return getExtensionValue(ext: Pb_Extensions_cpp) ?? Pb_CppFeatures()} + set {setExtensionValue(ext: Pb_Extensions_cpp, value: newValue)} + } + /// Returns true if extension `Pb_Extensions_cpp` + /// has been explicitly set. + var hasPb_cpp: Bool { + return hasExtensionValue(ext: Pb_Extensions_cpp) + } + /// Clears the value of extension `Pb_Extensions_cpp`. + /// Subsequent reads from it will return its default value. + mutating func clearPb_cpp() { + clearExtensionValue(ext: Pb_Extensions_cpp) + } + +} + +// MARK: - File's ExtensionMap: Pb_CppFeatures_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 Pb_CppFeatures_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Pb_Extensions_cpp +] + +// 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 Pb_Extensions_cpp = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FeatureSet>( + _protobuf_fieldNumber: 1000, + fieldName: "pb.cpp" +) + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "pb" + +extension Pb_CppFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".CppFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}legacy_closed_enum\0\u{3}string_type\0\u{3}enum_name_uses_string_view\0") + + 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.decodeSingularBoolField(value: &self._legacyClosedEnum) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self._stringType) }() + case 3: try { try decoder.decodeSingularBoolField(value: &self._enumNameUsesStringView) }() + 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 + try { if let v = self._legacyClosedEnum { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1) + } }() + try { if let v = self._stringType { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) + } }() + try { if let v = self._enumNameUsesStringView { + try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Pb_CppFeatures, rhs: Pb_CppFeatures) -> Bool { + if lhs._legacyClosedEnum != rhs._legacyClosedEnum {return false} + if lhs._stringType != rhs._stringType {return false} + if lhs._enumNameUsesStringView != rhs._enumNameUsesStringView {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Pb_CppFeatures.StringType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0STRING_TYPE_UNKNOWN\0\u{1}VIEW\0\u{1}CORD\0\u{1}STRING\0") +} diff --git a/Reference/upstream/google/protobuf/descriptor.pb.swift b/Reference/upstream/google/protobuf/descriptor.pb.swift new file mode 100644 index 000000000..870941e7f --- /dev/null +++ b/Reference/upstream/google/protobuf/descriptor.pb.swift @@ -0,0 +1,5274 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/descriptor.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// The messages in this file describe the definitions found in .proto files. +// A valid .proto file can be translated directly to a FileDescriptorProto +// without any other information (e.g. without reading its imports). + +import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. + +// 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: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// The full set of known editions. +enum Google_Protobuf_Edition: Int, Enum, Swift.CaseIterable { + + /// A placeholder for an unknown edition value. + case unknown = 0 + + /// A placeholder edition for specifying default behaviors *before* a feature + /// was first introduced. This is effectively an "infinite past". + case legacy = 900 + + /// Legacy syntax "editions". These pre-date editions, but behave much like + /// distinct editions. These can't be used to specify the edition of proto + /// files, but feature definitions must supply proto2/proto3 defaults for + /// backwards compatibility. + case proto2 = 998 + case proto3 = 999 + + /// Editions that have been released. The specific values are arbitrary and + /// should not be depended on, but they will always be time-ordered for easy + /// comparison. + case edition2023 = 1000 + case edition2024 = 1001 + + /// A placeholder edition for developing and testing unscheduled features. + case unstable = 9999 + + /// Placeholder editions for testing feature resolution. These should not be + /// used or relied on outside of tests. + case edition1TestOnly = 1 + case edition2TestOnly = 2 + case edition99997TestOnly = 99997 + case edition99998TestOnly = 99998 + case edition99999TestOnly = 99999 + + /// Placeholder for specifying unbounded edition support. This should only + /// ever be used by plugins that can expect to never require any changes to + /// support a new edition. + case max = 2147483647 + + init() { + self = .unknown + } + +} + +/// Describes the 'visibility' of a symbol with respect to the proto import +/// system. Symbols can only be imported when the visibility rules do not prevent +/// it (ex: local symbols cannot be imported). Visibility modifiers can only set +/// on `message` and `enum` as they are the only types available to be referenced +/// from other files. +enum Google_Protobuf_SymbolVisibility: Int, Enum, Swift.CaseIterable { + case visibilityUnset = 0 + case visibilityLocal = 1 + case visibilityExport = 2 + + init() { + self = .visibilityUnset + } + +} + +/// The protocol compiler can output a FileDescriptorSet containing the .proto +/// files it parses. +struct Google_Protobuf_FileDescriptorSet: ExtensibleMessage, Sendable { + // 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 file: [Google_Protobuf_FileDescriptorProto] = [] + + var unknownFields = UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() +} + +/// Describes a complete .proto file. +struct Google_Protobuf_FileDescriptorProto: Sendable { + // 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. + + /// file name, relative to root of source tree + var name: String { + get {_name ?? String()} + set {_name = newValue} + } + /// Returns true if `name` has been explicitly set. + var hasName: Bool {self._name != nil} + /// Clears the value of `name`. Subsequent reads from it will return its default value. + mutating func clearName() {self._name = nil} + + /// e.g. "foo", "foo.bar", etc. + var package: String { + get {_package ?? String()} + set {_package = newValue} + } + /// Returns true if `package` has been explicitly set. + var hasPackage: Bool {self._package != nil} + /// Clears the value of `package`. Subsequent reads from it will return its default value. + mutating func clearPackage() {self._package = nil} + + /// Names of files imported by this file. + var dependency: [String] = [] + + /// Indexes of the public imported files in the dependency list above. + var publicDependency: [Int32] = [] + + /// Indexes of the weak imported files in the dependency list. + /// For Google-internal migration only. Do not use. + var weakDependency: [Int32] = [] + + /// Names of files imported by this file purely for the purpose of providing + /// option extensions. These are excluded from the dependency list above. + var optionDependency: [String] = [] + + /// All top-level definitions in this file. + var messageType: [Google_Protobuf_DescriptorProto] = [] + + var enumType: [Google_Protobuf_EnumDescriptorProto] = [] + + var service: [Google_Protobuf_ServiceDescriptorProto] = [] + + var `extension`: [Google_Protobuf_FieldDescriptorProto] = [] + + var options: Google_Protobuf_FileOptions { + get {_options ?? Google_Protobuf_FileOptions()} + set {_options = newValue} + } + /// Returns true if `options` has been explicitly set. + var hasOptions: Bool {self._options != nil} + /// Clears the value of `options`. Subsequent reads from it will return its default value. + mutating func clearOptions() {self._options = nil} + + /// This field contains optional information about the original source code. + /// You may safely remove this entire field without harming runtime + /// functionality of the descriptors -- the information is needed only by + /// development tools. + var sourceCodeInfo: Google_Protobuf_SourceCodeInfo { + get {_sourceCodeInfo ?? Google_Protobuf_SourceCodeInfo()} + set {_sourceCodeInfo = newValue} + } + /// Returns true if `sourceCodeInfo` has been explicitly set. + var hasSourceCodeInfo: Bool {self._sourceCodeInfo != nil} + /// Clears the value of `sourceCodeInfo`. Subsequent reads from it will return its default value. + mutating func clearSourceCodeInfo() {self._sourceCodeInfo = nil} + + /// The syntax of the proto file. + /// The supported values are "proto2", "proto3", and "editions". + /// + /// If `edition` is present, this value must be "editions". + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var syntax: String { + get {_syntax ?? String()} + set {_syntax = newValue} + } + /// Returns true if `syntax` has been explicitly set. + var hasSyntax: Bool {self._syntax != nil} + /// Clears the value of `syntax`. Subsequent reads from it will return its default value. + mutating func clearSyntax() {self._syntax = nil} + + /// The edition of the proto file. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var edition: Google_Protobuf_Edition { + get {_edition ?? .unknown} + set {_edition = newValue} + } + /// Returns true if `edition` has been explicitly set. + var hasEdition: Bool {self._edition != nil} + /// Clears the value of `edition`. Subsequent reads from it will return its default value. + mutating func clearEdition() {self._edition = nil} + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _name: String? = nil + fileprivate var _package: String? = nil + fileprivate var _options: Google_Protobuf_FileOptions? = nil + fileprivate var _sourceCodeInfo: Google_Protobuf_SourceCodeInfo? = nil + fileprivate var _syntax: String? = nil + fileprivate var _edition: Google_Protobuf_Edition? = nil +} + +/// Describes a message type. +struct Google_Protobuf_DescriptorProto: @unchecked Sendable { + // 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 name: String { + get {_storage._name ?? String()} + set {_uniqueStorage()._name = newValue} + } + /// Returns true if `name` has been explicitly set. + var hasName: Bool {_storage._name != nil} + /// Clears the value of `name`. Subsequent reads from it will return its default value. + mutating func clearName() {_uniqueStorage()._name = nil} + + var field: [Google_Protobuf_FieldDescriptorProto] { + get {_storage._field} + set {_uniqueStorage()._field = newValue} + } + + var `extension`: [Google_Protobuf_FieldDescriptorProto] { + get {_storage._extension} + set {_uniqueStorage()._extension = newValue} + } + + var nestedType: [Google_Protobuf_DescriptorProto] { + get {_storage._nestedType} + set {_uniqueStorage()._nestedType = newValue} + } + + var enumType: [Google_Protobuf_EnumDescriptorProto] { + get {_storage._enumType} + set {_uniqueStorage()._enumType = newValue} + } + + var extensionRange: [Google_Protobuf_DescriptorProto.ExtensionRange] { + get {_storage._extensionRange} + set {_uniqueStorage()._extensionRange = newValue} + } + + var oneofDecl: [Google_Protobuf_OneofDescriptorProto] { + get {_storage._oneofDecl} + set {_uniqueStorage()._oneofDecl = newValue} + } + + var options: Google_Protobuf_MessageOptions { + get {_storage._options ?? Google_Protobuf_MessageOptions()} + set {_uniqueStorage()._options = newValue} + } + /// Returns true if `options` has been explicitly set. + var hasOptions: Bool {_storage._options != nil} + /// Clears the value of `options`. Subsequent reads from it will return its default value. + mutating func clearOptions() {_uniqueStorage()._options = nil} + + var reservedRange: [Google_Protobuf_DescriptorProto.ReservedRange] { + get {_storage._reservedRange} + set {_uniqueStorage()._reservedRange = newValue} + } + + /// Reserved field names, which may not be used by fields in the same message. + /// A given name may only be reserved once. + var reservedName: [String] { + get {_storage._reservedName} + set {_uniqueStorage()._reservedName = newValue} + } + + /// Support for `export` and `local` keywords on enums. + var visibility: Google_Protobuf_SymbolVisibility { + get {_storage._visibility ?? .visibilityUnset} + set {_uniqueStorage()._visibility = newValue} + } + /// Returns true if `visibility` has been explicitly set. + var hasVisibility: Bool {_storage._visibility != nil} + /// Clears the value of `visibility`. Subsequent reads from it will return its default value. + mutating func clearVisibility() {_uniqueStorage()._visibility = nil} + + var unknownFields = UnknownStorage() + + struct ExtensionRange: Sendable { + // 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. + + /// Inclusive. + var start: Int32 { + get {_start ?? 0} + set {_start = newValue} + } + /// Returns true if `start` has been explicitly set. + var hasStart: Bool {self._start != nil} + /// Clears the value of `start`. Subsequent reads from it will return its default value. + mutating func clearStart() {self._start = nil} + + /// Exclusive. + var end: Int32 { + get {_end ?? 0} + set {_end = newValue} + } + /// Returns true if `end` has been explicitly set. + var hasEnd: Bool {self._end != nil} + /// Clears the value of `end`. Subsequent reads from it will return its default value. + mutating func clearEnd() {self._end = nil} + + var options: Google_Protobuf_ExtensionRangeOptions { + get {_options ?? Google_Protobuf_ExtensionRangeOptions()} + set {_options = newValue} + } + /// Returns true if `options` has been explicitly set. + var hasOptions: Bool {self._options != nil} + /// Clears the value of `options`. Subsequent reads from it will return its default value. + mutating func clearOptions() {self._options = nil} + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _start: Int32? = nil + fileprivate var _end: Int32? = nil + fileprivate var _options: Google_Protobuf_ExtensionRangeOptions? = nil + } + + /// Range of reserved tag numbers. Reserved tag numbers may not be used by + /// fields or extension ranges in the same message. Reserved ranges may + /// not overlap. + struct ReservedRange: Sendable { + // 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. + + /// Inclusive. + var start: Int32 { + get {_start ?? 0} + set {_start = newValue} + } + /// Returns true if `start` has been explicitly set. + var hasStart: Bool {self._start != nil} + /// Clears the value of `start`. Subsequent reads from it will return its default value. + mutating func clearStart() {self._start = nil} + + /// Exclusive. + var end: Int32 { + get {_end ?? 0} + set {_end = newValue} + } + /// Returns true if `end` has been explicitly set. + var hasEnd: Bool {self._end != nil} + /// Clears the value of `end`. Subsequent reads from it will return its default value. + mutating func clearEnd() {self._end = nil} + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _start: Int32? = nil + fileprivate var _end: Int32? = nil + } + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Google_Protobuf_ExtensionRangeOptions: ExtensibleMessage, Sendable { + // 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. + + /// The parser stores options it doesn't recognize here. See above. + var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] + + /// For external users: DO NOT USE. We are in the process of open sourcing + /// extension declaration and executing internal cleanups before it can be + /// used externally. + var declaration: [Google_Protobuf_ExtensionRangeOptions.Declaration] = [] + + /// Any features defined in the specific edition. + var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + mutating func clearFeatures() {self._features = nil} + + /// The verification state of the range. + /// TODO: flip the default to DECLARATION once all empty ranges + /// are marked as UNVERIFIED. + var verification: Google_Protobuf_ExtensionRangeOptions.VerificationState { + get {_verification ?? .unverified} + set {_verification = newValue} + } + /// Returns true if `verification` has been explicitly set. + var hasVerification: Bool {self._verification != nil} + /// Clears the value of `verification`. Subsequent reads from it will return its default value. + mutating func clearVerification() {self._verification = nil} + + var unknownFields = UnknownStorage() + + /// The verification state of the extension range. + enum VerificationState: Int, Enum, Swift.CaseIterable { + + /// All the extensions of the range must be declared. + case declaration = 0 + case unverified = 1 + + init() { + self = .declaration + } + + } + + struct Declaration: Sendable { + // 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. + + /// The extension number declared within the extension range. + var number: Int32 { + get {_number ?? 0} + set {_number = newValue} + } + /// Returns true if `number` has been explicitly set. + var hasNumber: Bool {self._number != nil} + /// Clears the value of `number`. Subsequent reads from it will return its default value. + mutating func clearNumber() {self._number = nil} + + /// The fully-qualified name of the extension field. There must be a leading + /// dot in front of the full name. + var fullName: String { + get {_fullName ?? String()} + set {_fullName = newValue} + } + /// Returns true if `fullName` has been explicitly set. + var hasFullName: Bool {self._fullName != nil} + /// Clears the value of `fullName`. Subsequent reads from it will return its default value. + mutating func clearFullName() {self._fullName = nil} + + /// The fully-qualified type name of the extension field. Unlike + /// Metadata.type, Declaration.type must have a leading dot for messages + /// and enums. + var type: String { + get {_type ?? String()} + set {_type = newValue} + } + /// Returns true if `type` has been explicitly set. + var hasType: Bool {self._type != nil} + /// Clears the value of `type`. Subsequent reads from it will return its default value. + mutating func clearType() {self._type = nil} + + /// If true, indicates that the number is reserved in the extension range, + /// and any extension field with the number will fail to compile. Set this + /// when a declared extension field is deleted. + var reserved: Bool { + get {_reserved ?? false} + set {_reserved = newValue} + } + /// Returns true if `reserved` has been explicitly set. + var hasReserved: Bool {self._reserved != nil} + /// Clears the value of `reserved`. Subsequent reads from it will return its default value. + mutating func clearReserved() {self._reserved = nil} + + /// If true, indicates that the extension must be defined as repeated. + /// Otherwise the extension must be defined as optional. + var repeated: Bool { + get {_repeated ?? false} + set {_repeated = newValue} + } + /// Returns true if `repeated` has been explicitly set. + var hasRepeated: Bool {self._repeated != nil} + /// Clears the value of `repeated`. Subsequent reads from it will return its default value. + mutating func clearRepeated() {self._repeated = nil} + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _number: Int32? = nil + fileprivate var _fullName: String? = nil + fileprivate var _type: String? = nil + fileprivate var _reserved: Bool? = nil + fileprivate var _repeated: Bool? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _features: Google_Protobuf_FeatureSet? = nil + fileprivate var _verification: Google_Protobuf_ExtensionRangeOptions.VerificationState? = nil +} + +/// Describes a field within a message. +struct Google_Protobuf_FieldDescriptorProto: Sendable { + // 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 name: String { + get {_name ?? String()} + set {_name = newValue} + } + /// Returns true if `name` has been explicitly set. + var hasName: Bool {self._name != nil} + /// Clears the value of `name`. Subsequent reads from it will return its default value. + mutating func clearName() {self._name = nil} + + var number: Int32 { + get {_number ?? 0} + set {_number = newValue} + } + /// Returns true if `number` has been explicitly set. + var hasNumber: Bool {self._number != nil} + /// Clears the value of `number`. Subsequent reads from it will return its default value. + mutating func clearNumber() {self._number = nil} + + var label: Google_Protobuf_FieldDescriptorProto.Label { + get {_label ?? .optional} + set {_label = newValue} + } + /// Returns true if `label` has been explicitly set. + var hasLabel: Bool {self._label != nil} + /// Clears the value of `label`. Subsequent reads from it will return its default value. + mutating func clearLabel() {self._label = nil} + + /// If type_name is set, this need not be set. If both this and type_name + /// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. + var type: Google_Protobuf_FieldDescriptorProto.TypeEnum { + get {_type ?? .double} + set {_type = newValue} + } + /// Returns true if `type` has been explicitly set. + var hasType: Bool {self._type != nil} + /// Clears the value of `type`. Subsequent reads from it will return its default value. + mutating func clearType() {self._type = nil} + + /// For message and enum types, this is the name of the type. If the name + /// starts with a '.', it is fully-qualified. Otherwise, C++-like scoping + /// rules are used to find the type (i.e. first the nested types within this + /// message are searched, then within the parent, on up to the root + /// namespace). + var typeName: String { + get {_typeName ?? String()} + set {_typeName = newValue} + } + /// Returns true if `typeName` has been explicitly set. + var hasTypeName: Bool {self._typeName != nil} + /// Clears the value of `typeName`. Subsequent reads from it will return its default value. + mutating func clearTypeName() {self._typeName = nil} + + /// For extensions, this is the name of the type being extended. It is + /// resolved in the same manner as type_name. + var extendee: String { + get {_extendee ?? String()} + set {_extendee = newValue} + } + /// Returns true if `extendee` has been explicitly set. + var hasExtendee: Bool {self._extendee != nil} + /// Clears the value of `extendee`. Subsequent reads from it will return its default value. + mutating func clearExtendee() {self._extendee = nil} + + /// For numeric types, contains the original text representation of the value. + /// For booleans, "true" or "false". + /// For strings, contains the default text contents (not escaped in any way). + /// For bytes, contains the C escaped value. All bytes >= 128 are escaped. + var defaultValue: String { + get {_defaultValue ?? String()} + set {_defaultValue = newValue} + } + /// Returns true if `defaultValue` has been explicitly set. + var hasDefaultValue: Bool {self._defaultValue != nil} + /// Clears the value of `defaultValue`. Subsequent reads from it will return its default value. + mutating func clearDefaultValue() {self._defaultValue = nil} + + /// If set, gives the index of a oneof in the containing type's oneof_decl + /// list. This field is a member of that oneof. + var oneofIndex: Int32 { + get {_oneofIndex ?? 0} + set {_oneofIndex = newValue} + } + /// Returns true if `oneofIndex` has been explicitly set. + var hasOneofIndex: Bool {self._oneofIndex != nil} + /// Clears the value of `oneofIndex`. Subsequent reads from it will return its default value. + mutating func clearOneofIndex() {self._oneofIndex = nil} + + /// JSON name of this field. The value is set by protocol compiler. If the + /// user has set a "json_name" option on this field, that option's value + /// will be used. Otherwise, it's deduced from the field's name by converting + /// it to camelCase. + var jsonName: String { + get {_jsonName ?? String()} + set {_jsonName = newValue} + } + /// Returns true if `jsonName` has been explicitly set. + var hasJsonName: Bool {self._jsonName != nil} + /// Clears the value of `jsonName`. Subsequent reads from it will return its default value. + mutating func clearJsonName() {self._jsonName = nil} + + var options: Google_Protobuf_FieldOptions { + get {_options ?? Google_Protobuf_FieldOptions()} + set {_options = newValue} + } + /// Returns true if `options` has been explicitly set. + var hasOptions: Bool {self._options != nil} + /// Clears the value of `options`. Subsequent reads from it will return its default value. + mutating func clearOptions() {self._options = nil} + + /// If true, this is a proto3 "optional". When a proto3 field is optional, it + /// tracks presence regardless of field type. + /// + /// When proto3_optional is true, this field must belong to a oneof to signal + /// to old proto3 clients that presence is tracked for this field. This oneof + /// is known as a "synthetic" oneof, and this field must be its sole member + /// (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs + /// exist in the descriptor only, and do not generate any API. Synthetic oneofs + /// must be ordered after all "real" oneofs. + /// + /// For message fields, proto3_optional doesn't create any semantic change, + /// since non-repeated message fields always track presence. However it still + /// indicates the semantic detail of whether the user wrote "optional" or not. + /// This can be useful for round-tripping the .proto file. For consistency we + /// give message fields a synthetic oneof also, even though it is not required + /// to track presence. This is especially important because the parser can't + /// tell if a field is a message or an enum, so it must always create a + /// synthetic oneof. + /// + /// Proto2 optional fields do not set this flag, because they already indicate + /// optional with `LABEL_OPTIONAL`. + var proto3Optional: Bool { + get {_proto3Optional ?? false} + set {_proto3Optional = newValue} + } + /// Returns true if `proto3Optional` has been explicitly set. + var hasProto3Optional: Bool {self._proto3Optional != nil} + /// Clears the value of `proto3Optional`. Subsequent reads from it will return its default value. + mutating func clearProto3Optional() {self._proto3Optional = nil} + + var unknownFields = UnknownStorage() + + enum TypeEnum: Int, Enum, Swift.CaseIterable { + + /// 0 is reserved for errors. + /// Order is weird for historical reasons. + case double = 1 + case float = 2 + + /// Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + /// negative values are likely. + case int64 = 3 + case uint64 = 4 + + /// Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + /// negative values are likely. + case int32 = 5 + case fixed64 = 6 + case fixed32 = 7 + case bool = 8 + case string = 9 + + /// Tag-delimited aggregate. + /// Group type is deprecated and not supported after google.protobuf. However, Proto3 + /// implementations should still be able to parse the group wire format and + /// treat group fields as unknown fields. In Editions, the group wire format + /// can be enabled via the `message_encoding` feature. + case group = 10 + + /// Length-delimited aggregate. + case message = 11 + + /// New in version 2. + case bytes = 12 + case uint32 = 13 + case `enum` = 14 + case sfixed32 = 15 + case sfixed64 = 16 + + /// Uses ZigZag encoding. + case sint32 = 17 + + /// Uses ZigZag encoding. + case sint64 = 18 + + init() { + self = .double + } + + } + + enum Label: Int, Enum, Swift.CaseIterable { + + /// 0 is reserved for errors + case `optional` = 1 + case repeated = 3 + + /// The required label is only allowed in google.protobuf. In proto3 and Editions + /// it's explicitly prohibited. In Editions, the `field_presence` feature + /// can be used to get this behavior. + case `required` = 2 + + init() { + self = .optional + } + + } + + init() {} + + fileprivate var _name: String? = nil + fileprivate var _number: Int32? = nil + fileprivate var _label: Google_Protobuf_FieldDescriptorProto.Label? = nil + fileprivate var _type: Google_Protobuf_FieldDescriptorProto.TypeEnum? = nil + fileprivate var _typeName: String? = nil + fileprivate var _extendee: String? = nil + fileprivate var _defaultValue: String? = nil + fileprivate var _oneofIndex: Int32? = nil + fileprivate var _jsonName: String? = nil + fileprivate var _options: Google_Protobuf_FieldOptions? = nil + fileprivate var _proto3Optional: Bool? = nil +} + +/// Describes a oneof. +struct Google_Protobuf_OneofDescriptorProto: Sendable { + // 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 name: String { + get {_name ?? String()} + set {_name = newValue} + } + /// Returns true if `name` has been explicitly set. + var hasName: Bool {self._name != nil} + /// Clears the value of `name`. Subsequent reads from it will return its default value. + mutating func clearName() {self._name = nil} + + var options: Google_Protobuf_OneofOptions { + get {_options ?? Google_Protobuf_OneofOptions()} + set {_options = newValue} + } + /// Returns true if `options` has been explicitly set. + var hasOptions: Bool {self._options != nil} + /// Clears the value of `options`. Subsequent reads from it will return its default value. + mutating func clearOptions() {self._options = nil} + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _name: String? = nil + fileprivate var _options: Google_Protobuf_OneofOptions? = nil +} + +/// Describes an enum type. +struct Google_Protobuf_EnumDescriptorProto: @unchecked Sendable { + // 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 name: String { + get {_storage._name ?? String()} + set {_uniqueStorage()._name = newValue} + } + /// Returns true if `name` has been explicitly set. + var hasName: Bool {_storage._name != nil} + /// Clears the value of `name`. Subsequent reads from it will return its default value. + mutating func clearName() {_uniqueStorage()._name = nil} + + var value: [Google_Protobuf_EnumValueDescriptorProto] { + get {_storage._value} + set {_uniqueStorage()._value = newValue} + } + + var options: Google_Protobuf_EnumOptions { + get {_storage._options ?? Google_Protobuf_EnumOptions()} + set {_uniqueStorage()._options = newValue} + } + /// Returns true if `options` has been explicitly set. + var hasOptions: Bool {_storage._options != nil} + /// Clears the value of `options`. Subsequent reads from it will return its default value. + mutating func clearOptions() {_uniqueStorage()._options = nil} + + /// Range of reserved numeric values. Reserved numeric values may not be used + /// by enum values in the same enum declaration. Reserved ranges may not + /// overlap. + var reservedRange: [Google_Protobuf_EnumDescriptorProto.EnumReservedRange] { + get {_storage._reservedRange} + set {_uniqueStorage()._reservedRange = newValue} + } + + /// Reserved enum value names, which may not be reused. A given name may only + /// be reserved once. + var reservedName: [String] { + get {_storage._reservedName} + set {_uniqueStorage()._reservedName = newValue} + } + + /// Support for `export` and `local` keywords on enums. + var visibility: Google_Protobuf_SymbolVisibility { + get {_storage._visibility ?? .visibilityUnset} + set {_uniqueStorage()._visibility = newValue} + } + /// Returns true if `visibility` has been explicitly set. + var hasVisibility: Bool {_storage._visibility != nil} + /// Clears the value of `visibility`. Subsequent reads from it will return its default value. + mutating func clearVisibility() {_uniqueStorage()._visibility = nil} + + var unknownFields = UnknownStorage() + + /// Range of reserved numeric values. Reserved values may not be used by + /// entries in the same enum. Reserved ranges may not overlap. + /// + /// Note that this is distinct from DescriptorProto.ReservedRange in that it + /// is inclusive such that it can appropriately represent the entire int32 + /// domain. + struct EnumReservedRange: Sendable { + // 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. + + /// Inclusive. + var start: Int32 { + get {_start ?? 0} + set {_start = newValue} + } + /// Returns true if `start` has been explicitly set. + var hasStart: Bool {self._start != nil} + /// Clears the value of `start`. Subsequent reads from it will return its default value. + mutating func clearStart() {self._start = nil} + + /// Inclusive. + var end: Int32 { + get {_end ?? 0} + set {_end = newValue} + } + /// Returns true if `end` has been explicitly set. + var hasEnd: Bool {self._end != nil} + /// Clears the value of `end`. Subsequent reads from it will return its default value. + mutating func clearEnd() {self._end = nil} + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _start: Int32? = nil + fileprivate var _end: Int32? = nil + } + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// Describes a value within an enum. +struct Google_Protobuf_EnumValueDescriptorProto: @unchecked Sendable { + // 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 name: String { + get {_storage._name ?? String()} + set {_uniqueStorage()._name = newValue} + } + /// Returns true if `name` has been explicitly set. + var hasName: Bool {_storage._name != nil} + /// Clears the value of `name`. Subsequent reads from it will return its default value. + mutating func clearName() {_uniqueStorage()._name = nil} + + var number: Int32 { + get {_storage._number ?? 0} + set {_uniqueStorage()._number = newValue} + } + /// Returns true if `number` has been explicitly set. + var hasNumber: Bool {_storage._number != nil} + /// Clears the value of `number`. Subsequent reads from it will return its default value. + mutating func clearNumber() {_uniqueStorage()._number = nil} + + var options: Google_Protobuf_EnumValueOptions { + get {_storage._options ?? Google_Protobuf_EnumValueOptions()} + set {_uniqueStorage()._options = newValue} + } + /// Returns true if `options` has been explicitly set. + var hasOptions: Bool {_storage._options != nil} + /// Clears the value of `options`. Subsequent reads from it will return its default value. + mutating func clearOptions() {_uniqueStorage()._options = nil} + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// Describes a service. +struct Google_Protobuf_ServiceDescriptorProto: Sendable { + // 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 name: String { + get {_name ?? String()} + set {_name = newValue} + } + /// Returns true if `name` has been explicitly set. + var hasName: Bool {self._name != nil} + /// Clears the value of `name`. Subsequent reads from it will return its default value. + mutating func clearName() {self._name = nil} + + var method: [Google_Protobuf_MethodDescriptorProto] = [] + + var options: Google_Protobuf_ServiceOptions { + get {_options ?? Google_Protobuf_ServiceOptions()} + set {_options = newValue} + } + /// Returns true if `options` has been explicitly set. + var hasOptions: Bool {self._options != nil} + /// Clears the value of `options`. Subsequent reads from it will return its default value. + mutating func clearOptions() {self._options = nil} + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _name: String? = nil + fileprivate var _options: Google_Protobuf_ServiceOptions? = nil +} + +/// Describes a method of a service. +struct Google_Protobuf_MethodDescriptorProto: Sendable { + // 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 name: String { + get {_name ?? String()} + set {_name = newValue} + } + /// Returns true if `name` has been explicitly set. + var hasName: Bool {self._name != nil} + /// Clears the value of `name`. Subsequent reads from it will return its default value. + mutating func clearName() {self._name = nil} + + /// Input and output type names. These are resolved in the same way as + /// FieldDescriptorProto.type_name, but must refer to a message type. + var inputType: String { + get {_inputType ?? String()} + set {_inputType = newValue} + } + /// Returns true if `inputType` has been explicitly set. + var hasInputType: Bool {self._inputType != nil} + /// Clears the value of `inputType`. Subsequent reads from it will return its default value. + mutating func clearInputType() {self._inputType = nil} + + var outputType: String { + get {_outputType ?? String()} + set {_outputType = newValue} + } + /// Returns true if `outputType` has been explicitly set. + var hasOutputType: Bool {self._outputType != nil} + /// Clears the value of `outputType`. Subsequent reads from it will return its default value. + mutating func clearOutputType() {self._outputType = nil} + + var options: Google_Protobuf_MethodOptions { + get {_options ?? Google_Protobuf_MethodOptions()} + set {_options = newValue} + } + /// Returns true if `options` has been explicitly set. + var hasOptions: Bool {self._options != nil} + /// Clears the value of `options`. Subsequent reads from it will return its default value. + mutating func clearOptions() {self._options = nil} + + /// Identifies if client streams multiple client messages + var clientStreaming: Bool { + get {_clientStreaming ?? false} + set {_clientStreaming = newValue} + } + /// Returns true if `clientStreaming` has been explicitly set. + var hasClientStreaming: Bool {self._clientStreaming != nil} + /// Clears the value of `clientStreaming`. Subsequent reads from it will return its default value. + mutating func clearClientStreaming() {self._clientStreaming = nil} + + /// Identifies if server streams multiple server messages + var serverStreaming: Bool { + get {_serverStreaming ?? false} + set {_serverStreaming = newValue} + } + /// Returns true if `serverStreaming` has been explicitly set. + var hasServerStreaming: Bool {self._serverStreaming != nil} + /// Clears the value of `serverStreaming`. Subsequent reads from it will return its default value. + mutating func clearServerStreaming() {self._serverStreaming = nil} + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _name: String? = nil + fileprivate var _inputType: String? = nil + fileprivate var _outputType: String? = nil + fileprivate var _options: Google_Protobuf_MethodOptions? = nil + fileprivate var _clientStreaming: Bool? = nil + fileprivate var _serverStreaming: Bool? = nil +} + +struct Google_Protobuf_FileOptions: ExtensibleMessage, @unchecked Sendable { + // 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 Java package where classes generated from this .proto will be + /// placed. By default, the proto package is used, but this is often + /// inappropriate because proto packages do not normally start with backwards + /// domain names. + var javaPackage: String { + get {_storage._javaPackage ?? String()} + set {_uniqueStorage()._javaPackage = newValue} + } + /// Returns true if `javaPackage` has been explicitly set. + var hasJavaPackage: Bool {_storage._javaPackage != nil} + /// Clears the value of `javaPackage`. Subsequent reads from it will return its default value. + mutating func clearJavaPackage() {_uniqueStorage()._javaPackage = nil} + + /// Controls the name of the wrapper Java class generated for the .proto file. + /// That class will always contain the .proto file's getDescriptor() method as + /// well as any top-level extensions defined in the .proto file. + /// If java_multiple_files is disabled, then all the other classes from the + /// .proto file will be nested inside the single wrapper outer class. + var javaOuterClassname: String { + get {_storage._javaOuterClassname ?? String()} + set {_uniqueStorage()._javaOuterClassname = newValue} + } + /// Returns true if `javaOuterClassname` has been explicitly set. + var hasJavaOuterClassname: Bool {_storage._javaOuterClassname != nil} + /// Clears the value of `javaOuterClassname`. Subsequent reads from it will return its default value. + mutating func clearJavaOuterClassname() {_uniqueStorage()._javaOuterClassname = nil} + + /// If enabled, then the Java code generator will generate a separate .java + /// file for each top-level message, enum, and service defined in the .proto + /// file. Thus, these types will *not* be nested inside the wrapper class + /// named by java_outer_classname. However, the wrapper class will still be + /// generated to contain the file's getDescriptor() method as well as any + /// top-level extensions defined in the file. + var javaMultipleFiles: Bool { + get {_storage._javaMultipleFiles ?? false} + set {_uniqueStorage()._javaMultipleFiles = newValue} + } + /// Returns true if `javaMultipleFiles` has been explicitly set. + var hasJavaMultipleFiles: Bool {_storage._javaMultipleFiles != nil} + /// Clears the value of `javaMultipleFiles`. Subsequent reads from it will return its default value. + mutating func clearJavaMultipleFiles() {_uniqueStorage()._javaMultipleFiles = nil} + + /// This option does nothing. + /// + /// NOTE: This field was marked as deprecated in the .proto file. + var javaGenerateEqualsAndHash: Bool { + get {_storage._javaGenerateEqualsAndHash ?? false} + set {_uniqueStorage()._javaGenerateEqualsAndHash = newValue} + } + /// Returns true if `javaGenerateEqualsAndHash` has been explicitly set. + var hasJavaGenerateEqualsAndHash: Bool {_storage._javaGenerateEqualsAndHash != nil} + /// Clears the value of `javaGenerateEqualsAndHash`. Subsequent reads from it will return its default value. + mutating func clearJavaGenerateEqualsAndHash() {_uniqueStorage()._javaGenerateEqualsAndHash = nil} + + /// A proto2 file can set this to true to opt in to UTF-8 checking for Java, + /// which will throw an exception if invalid UTF-8 is parsed from the wire or + /// assigned to a string field. + /// + /// TODO: clarify exactly what kinds of field types this option + /// applies to, and update these docs accordingly. + /// + /// Proto3 files already perform these checks. Setting the option explicitly to + /// false has no effect: it cannot be used to opt proto3 files out of UTF-8 + /// checks. + var javaStringCheckUtf8: Bool { + get {_storage._javaStringCheckUtf8 ?? false} + set {_uniqueStorage()._javaStringCheckUtf8 = newValue} + } + /// Returns true if `javaStringCheckUtf8` has been explicitly set. + var hasJavaStringCheckUtf8: Bool {_storage._javaStringCheckUtf8 != nil} + /// Clears the value of `javaStringCheckUtf8`. Subsequent reads from it will return its default value. + mutating func clearJavaStringCheckUtf8() {_uniqueStorage()._javaStringCheckUtf8 = nil} + + var optimizeFor: Google_Protobuf_FileOptions.OptimizeMode { + get {_storage._optimizeFor ?? .speed} + set {_uniqueStorage()._optimizeFor = newValue} + } + /// Returns true if `optimizeFor` has been explicitly set. + var hasOptimizeFor: Bool {_storage._optimizeFor != nil} + /// Clears the value of `optimizeFor`. Subsequent reads from it will return its default value. + mutating func clearOptimizeFor() {_uniqueStorage()._optimizeFor = nil} + + /// Sets the Go package where structs generated from this .proto will be + /// placed. If omitted, the Go package will be derived from the following: + /// - The basename of the package import path, if provided. + /// - Otherwise, the package statement in the .proto file, if present. + /// - Otherwise, the basename of the .proto file, without extension. + var goPackage: String { + get {_storage._goPackage ?? String()} + set {_uniqueStorage()._goPackage = newValue} + } + /// Returns true if `goPackage` has been explicitly set. + var hasGoPackage: Bool {_storage._goPackage != nil} + /// Clears the value of `goPackage`. Subsequent reads from it will return its default value. + mutating func clearGoPackage() {_uniqueStorage()._goPackage = nil} + + /// Should generic services be generated in each language? "Generic" services + /// are not specific to any particular RPC system. They are generated by the + /// main code generators in each language (without additional plugins). + /// Generic services were the only kind of service generation supported by + /// early versions of google.protobuf. + /// + /// Generic services are now considered deprecated in favor of using plugins + /// that generate code specific to your particular RPC system. Therefore, + /// these default to false. Old code which depends on generic services should + /// explicitly set them to true. + var ccGenericServices: Bool { + get {_storage._ccGenericServices ?? false} + set {_uniqueStorage()._ccGenericServices = newValue} + } + /// Returns true if `ccGenericServices` has been explicitly set. + var hasCcGenericServices: Bool {_storage._ccGenericServices != nil} + /// Clears the value of `ccGenericServices`. Subsequent reads from it will return its default value. + mutating func clearCcGenericServices() {_uniqueStorage()._ccGenericServices = nil} + + var javaGenericServices: Bool { + get {_storage._javaGenericServices ?? false} + set {_uniqueStorage()._javaGenericServices = newValue} + } + /// Returns true if `javaGenericServices` has been explicitly set. + var hasJavaGenericServices: Bool {_storage._javaGenericServices != nil} + /// Clears the value of `javaGenericServices`. Subsequent reads from it will return its default value. + mutating func clearJavaGenericServices() {_uniqueStorage()._javaGenericServices = nil} + + var pyGenericServices: Bool { + get {_storage._pyGenericServices ?? false} + set {_uniqueStorage()._pyGenericServices = newValue} + } + /// Returns true if `pyGenericServices` has been explicitly set. + var hasPyGenericServices: Bool {_storage._pyGenericServices != nil} + /// Clears the value of `pyGenericServices`. Subsequent reads from it will return its default value. + mutating func clearPyGenericServices() {_uniqueStorage()._pyGenericServices = nil} + + /// Is this file deprecated? + /// Depending on the target platform, this can emit Deprecated annotations + /// for everything in the file, or it will be completely ignored; in the very + /// least, this is a formalization for deprecating files. + var deprecated: Bool { + get {_storage._deprecated ?? false} + set {_uniqueStorage()._deprecated = newValue} + } + /// Returns true if `deprecated` has been explicitly set. + var hasDeprecated: Bool {_storage._deprecated != nil} + /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. + mutating func clearDeprecated() {_uniqueStorage()._deprecated = nil} + + /// Enables the use of arenas for the proto messages in this file. This applies + /// only to generated classes for C++. + var ccEnableArenas: Bool { + get {_storage._ccEnableArenas ?? true} + set {_uniqueStorage()._ccEnableArenas = newValue} + } + /// Returns true if `ccEnableArenas` has been explicitly set. + var hasCcEnableArenas: Bool {_storage._ccEnableArenas != nil} + /// Clears the value of `ccEnableArenas`. Subsequent reads from it will return its default value. + mutating func clearCcEnableArenas() {_uniqueStorage()._ccEnableArenas = nil} + + /// Sets the objective c class prefix which is prepended to all objective c + /// generated classes from this .proto. There is no default. + var objcClassPrefix: String { + get {_storage._objcClassPrefix ?? String()} + set {_uniqueStorage()._objcClassPrefix = newValue} + } + /// Returns true if `objcClassPrefix` has been explicitly set. + var hasObjcClassPrefix: Bool {_storage._objcClassPrefix != nil} + /// Clears the value of `objcClassPrefix`. Subsequent reads from it will return its default value. + mutating func clearObjcClassPrefix() {_uniqueStorage()._objcClassPrefix = nil} + + /// Namespace for generated classes; defaults to the package. + var csharpNamespace: String { + get {_storage._csharpNamespace ?? String()} + set {_uniqueStorage()._csharpNamespace = newValue} + } + /// Returns true if `csharpNamespace` has been explicitly set. + var hasCsharpNamespace: Bool {_storage._csharpNamespace != nil} + /// Clears the value of `csharpNamespace`. Subsequent reads from it will return its default value. + mutating func clearCsharpNamespace() {_uniqueStorage()._csharpNamespace = nil} + + /// By default Swift generators will take the proto package and CamelCase it + /// replacing '.' with underscore and use that to prefix the types/symbols + /// defined. When this options is provided, they will use this value instead + /// to prefix the types/symbols defined. + var swiftPrefix: String { + get {_storage._swiftPrefix ?? String()} + set {_uniqueStorage()._swiftPrefix = newValue} + } + /// Returns true if `swiftPrefix` has been explicitly set. + var hasSwiftPrefix: Bool {_storage._swiftPrefix != nil} + /// Clears the value of `swiftPrefix`. Subsequent reads from it will return its default value. + mutating func clearSwiftPrefix() {_uniqueStorage()._swiftPrefix = nil} + + /// Sets the php class prefix which is prepended to all php generated classes + /// from this .proto. Default is empty. + var phpClassPrefix: String { + get {_storage._phpClassPrefix ?? String()} + set {_uniqueStorage()._phpClassPrefix = newValue} + } + /// Returns true if `phpClassPrefix` has been explicitly set. + var hasPhpClassPrefix: Bool {_storage._phpClassPrefix != nil} + /// Clears the value of `phpClassPrefix`. Subsequent reads from it will return its default value. + mutating func clearPhpClassPrefix() {_uniqueStorage()._phpClassPrefix = nil} + + /// Use this option to change the namespace of php generated classes. Default + /// is empty. When this option is empty, the package name will be used for + /// determining the namespace. + var phpNamespace: String { + get {_storage._phpNamespace ?? String()} + set {_uniqueStorage()._phpNamespace = newValue} + } + /// Returns true if `phpNamespace` has been explicitly set. + var hasPhpNamespace: Bool {_storage._phpNamespace != nil} + /// Clears the value of `phpNamespace`. Subsequent reads from it will return its default value. + mutating func clearPhpNamespace() {_uniqueStorage()._phpNamespace = nil} + + /// Use this option to change the namespace of php generated metadata classes. + /// Default is empty. When this option is empty, the proto file name will be + /// used for determining the namespace. + var phpMetadataNamespace: String { + get {_storage._phpMetadataNamespace ?? String()} + set {_uniqueStorage()._phpMetadataNamespace = newValue} + } + /// Returns true if `phpMetadataNamespace` has been explicitly set. + var hasPhpMetadataNamespace: Bool {_storage._phpMetadataNamespace != nil} + /// Clears the value of `phpMetadataNamespace`. Subsequent reads from it will return its default value. + mutating func clearPhpMetadataNamespace() {_uniqueStorage()._phpMetadataNamespace = nil} + + /// Use this option to change the package of ruby generated classes. Default + /// is empty. When this option is not set, the package name will be used for + /// determining the ruby package. + var rubyPackage: String { + get {_storage._rubyPackage ?? String()} + set {_uniqueStorage()._rubyPackage = newValue} + } + /// Returns true if `rubyPackage` has been explicitly set. + var hasRubyPackage: Bool {_storage._rubyPackage != nil} + /// Clears the value of `rubyPackage`. Subsequent reads from it will return its default value. + mutating func clearRubyPackage() {_uniqueStorage()._rubyPackage = nil} + + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var features: Google_Protobuf_FeatureSet { + get {_storage._features ?? Google_Protobuf_FeatureSet()} + set {_uniqueStorage()._features = newValue} + } + /// Returns true if `features` has been explicitly set. + var hasFeatures: Bool {_storage._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + mutating func clearFeatures() {_uniqueStorage()._features = nil} + + /// The parser stores options it doesn't recognize here. + /// See the documentation for the "Options" section above. + var uninterpretedOption: [Google_Protobuf_UninterpretedOption] { + get {_storage._uninterpretedOption} + set {_uniqueStorage()._uninterpretedOption = newValue} + } + + var unknownFields = UnknownStorage() + + /// Generated classes can be optimized for speed or code size. + enum OptimizeMode: Int, Enum, Swift.CaseIterable { + + /// Generate complete code for parsing, serialization, + case speed = 1 + + /// etc. + case codeSize = 2 + + /// Generate code using MessageLite and the lite runtime. + case liteRuntime = 3 + + init() { + self = .speed + } + + } + + init() {} + + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Google_Protobuf_MessageOptions: ExtensibleMessage, Sendable { + // 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. + + /// Set true to use the old proto1 MessageSet wire format for extensions. + /// This is provided for backwards-compatibility with the MessageSet wire + /// format. You should not use this for any other reason: It's less + /// efficient, has fewer features, and is more complicated. + /// + /// The message must be defined exactly as follows: + /// message Foo { + /// option message_set_wire_format = true; + /// extensions 4 to max; + /// } + /// Note that the message cannot have any defined fields; MessageSets only + /// have extensions. + /// + /// All extensions of your type must be singular messages; e.g. they cannot + /// be int32s, enums, or repeated messages. + /// + /// Because this is an option, the above two restrictions are not enforced by + /// the protocol compiler. + var messageSetWireFormat: Bool { + get {_messageSetWireFormat ?? false} + set {_messageSetWireFormat = newValue} + } + /// Returns true if `messageSetWireFormat` has been explicitly set. + var hasMessageSetWireFormat: Bool {self._messageSetWireFormat != nil} + /// Clears the value of `messageSetWireFormat`. Subsequent reads from it will return its default value. + mutating func clearMessageSetWireFormat() {self._messageSetWireFormat = nil} + + /// Disables the generation of the standard "descriptor()" accessor, which can + /// conflict with a field of the same name. This is meant to make migration + /// from proto1 easier; new code should avoid fields named "descriptor". + var noStandardDescriptorAccessor: Bool { + get {_noStandardDescriptorAccessor ?? false} + set {_noStandardDescriptorAccessor = newValue} + } + /// Returns true if `noStandardDescriptorAccessor` has been explicitly set. + var hasNoStandardDescriptorAccessor: Bool {self._noStandardDescriptorAccessor != nil} + /// Clears the value of `noStandardDescriptorAccessor`. Subsequent reads from it will return its default value. + mutating func clearNoStandardDescriptorAccessor() {self._noStandardDescriptorAccessor = nil} + + /// Is this message deprecated? + /// Depending on the target platform, this can emit Deprecated annotations + /// for the message, or it will be completely ignored; in the very least, + /// this is a formalization for deprecating messages. + var deprecated: Bool { + get {_deprecated ?? false} + set {_deprecated = newValue} + } + /// Returns true if `deprecated` has been explicitly set. + var hasDeprecated: Bool {self._deprecated != nil} + /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. + mutating func clearDeprecated() {self._deprecated = nil} + + /// Whether the message is an automatically generated map entry type for the + /// maps field. + /// + /// For maps fields: + /// map map_field = 1; + /// The parsed descriptor looks like: + /// message MapFieldEntry { + /// option map_entry = true; + /// optional KeyType key = 1; + /// optional ValueType value = 2; + /// } + /// repeated MapFieldEntry map_field = 1; + /// + /// Implementations may choose not to generate the map_entry=true message, but + /// use a native map in the target language to hold the keys and values. + /// The reflection APIs in such implementations still need to work as + /// if the field is a repeated message field. + /// + /// NOTE: Do not set the option in .proto files. Always use the maps syntax + /// instead. The option should only be implicitly set by the proto compiler + /// parser. + var mapEntry: Bool { + get {_mapEntry ?? false} + set {_mapEntry = newValue} + } + /// Returns true if `mapEntry` has been explicitly set. + var hasMapEntry: Bool {self._mapEntry != nil} + /// Clears the value of `mapEntry`. Subsequent reads from it will return its default value. + mutating func clearMapEntry() {self._mapEntry = nil} + + /// Enable the legacy handling of JSON field name conflicts. This lowercases + /// and strips underscored from the fields before comparison in proto3 only. + /// The new behavior takes `json_name` into account and applies to proto2 as + /// well. + /// + /// This should only be used as a temporary measure against broken builds due + /// to the change in behavior for JSON field name conflicts. + /// + /// TODO This is legacy behavior we plan to remove once downstream + /// teams have had time to migrate. + /// + /// NOTE: This field was marked as deprecated in the .proto file. + var deprecatedLegacyJsonFieldConflicts: Bool { + get {_deprecatedLegacyJsonFieldConflicts ?? false} + set {_deprecatedLegacyJsonFieldConflicts = newValue} + } + /// Returns true if `deprecatedLegacyJsonFieldConflicts` has been explicitly set. + var hasDeprecatedLegacyJsonFieldConflicts: Bool {self._deprecatedLegacyJsonFieldConflicts != nil} + /// Clears the value of `deprecatedLegacyJsonFieldConflicts`. Subsequent reads from it will return its default value. + mutating func clearDeprecatedLegacyJsonFieldConflicts() {self._deprecatedLegacyJsonFieldConflicts = nil} + + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + mutating func clearFeatures() {self._features = nil} + + /// The parser stores options it doesn't recognize here. See above. + var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] + + var unknownFields = UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _messageSetWireFormat: Bool? = nil + fileprivate var _noStandardDescriptorAccessor: Bool? = nil + fileprivate var _deprecated: Bool? = nil + fileprivate var _mapEntry: Bool? = nil + fileprivate var _deprecatedLegacyJsonFieldConflicts: Bool? = nil + fileprivate var _features: Google_Protobuf_FeatureSet? = nil +} + +struct Google_Protobuf_FieldOptions: ExtensibleMessage, @unchecked Sendable { + // 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. + + /// NOTE: ctype is deprecated. Use `features.(pb.cpp).string_type` instead. + /// The ctype option instructs the C++ code generator to use a different + /// representation of the field than it normally would. See the specific + /// options below. This option is only implemented to support use of + /// [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of + /// type "bytes" in the open source release. + /// TODO: make ctype actually deprecated. + var ctype: Google_Protobuf_FieldOptions.CType { + get {_storage._ctype ?? .string} + set {_uniqueStorage()._ctype = newValue} + } + /// Returns true if `ctype` has been explicitly set. + var hasCtype: Bool {_storage._ctype != nil} + /// Clears the value of `ctype`. Subsequent reads from it will return its default value. + mutating func clearCtype() {_uniqueStorage()._ctype = nil} + + /// The packed option can be enabled for repeated primitive fields to enable + /// a more efficient representation on the wire. Rather than repeatedly + /// writing the tag and type for each element, the entire array is encoded as + /// a single length-delimited blob. In proto3, only explicit setting it to + /// false will avoid using packed encoding. This option is prohibited in + /// Editions, but the `repeated_field_encoding` feature can be used to control + /// the behavior. + var packed: Bool { + get {_storage._packed ?? false} + set {_uniqueStorage()._packed = newValue} + } + /// Returns true if `packed` has been explicitly set. + var hasPacked: Bool {_storage._packed != nil} + /// Clears the value of `packed`. Subsequent reads from it will return its default value. + mutating func clearPacked() {_uniqueStorage()._packed = nil} + + /// The jstype option determines the JavaScript type used for values of the + /// field. The option is permitted only for 64 bit integral and fixed types + /// (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING + /// is represented as JavaScript string, which avoids loss of precision that + /// can happen when a large value is converted to a floating point JavaScript. + /// Specifying JS_NUMBER for the jstype causes the generated JavaScript code to + /// use the JavaScript "number" type. The behavior of the default option + /// JS_NORMAL is implementation dependent. + /// + /// This option is an enum to permit additional types to be added, e.g. + /// goog.math.Integer. + var jstype: Google_Protobuf_FieldOptions.JSType { + get {_storage._jstype ?? .jsNormal} + set {_uniqueStorage()._jstype = newValue} + } + /// Returns true if `jstype` has been explicitly set. + var hasJstype: Bool {_storage._jstype != nil} + /// Clears the value of `jstype`. Subsequent reads from it will return its default value. + mutating func clearJstype() {_uniqueStorage()._jstype = nil} + + /// Should this field be parsed lazily? Lazy applies only to message-type + /// fields. It means that when the outer message is initially parsed, the + /// inner message's contents will not be parsed but instead stored in encoded + /// form. The inner message will actually be parsed when it is first accessed. + /// + /// This is only a hint. Implementations are free to choose whether to use + /// eager or lazy parsing regardless of the value of this option. However, + /// setting this option true suggests that the protocol author believes that + /// using lazy parsing on this field is worth the additional bookkeeping + /// overhead typically needed to implement it. + /// + /// This option does not affect the public interface of any generated code; + /// all method signatures remain the same. Furthermore, thread-safety of the + /// interface is not affected by this option; const methods remain safe to + /// call from multiple threads concurrently, while non-const methods continue + /// to require exclusive access. + /// + /// Note that lazy message fields are still eagerly verified to check + /// ill-formed wireformat or missing required fields. Calling IsInitialized() + /// on the outer message would fail if the inner message has missing required + /// fields. Failed verification would result in parsing failure (except when + /// uninitialized messages are acceptable). + var lazy: Bool { + get {_storage._lazy ?? false} + set {_uniqueStorage()._lazy = newValue} + } + /// Returns true if `lazy` has been explicitly set. + var hasLazy: Bool {_storage._lazy != nil} + /// Clears the value of `lazy`. Subsequent reads from it will return its default value. + mutating func clearLazy() {_uniqueStorage()._lazy = nil} + + /// unverified_lazy does no correctness checks on the byte stream. This should + /// only be used where lazy with verification is prohibitive for performance + /// reasons. + var unverifiedLazy: Bool { + get {_storage._unverifiedLazy ?? false} + set {_uniqueStorage()._unverifiedLazy = newValue} + } + /// Returns true if `unverifiedLazy` has been explicitly set. + var hasUnverifiedLazy: Bool {_storage._unverifiedLazy != nil} + /// Clears the value of `unverifiedLazy`. Subsequent reads from it will return its default value. + mutating func clearUnverifiedLazy() {_uniqueStorage()._unverifiedLazy = nil} + + /// Is this field deprecated? + /// Depending on the target platform, this can emit Deprecated annotations + /// for accessors, or it will be completely ignored; in the very least, this + /// is a formalization for deprecating fields. + var deprecated: Bool { + get {_storage._deprecated ?? false} + set {_uniqueStorage()._deprecated = newValue} + } + /// Returns true if `deprecated` has been explicitly set. + var hasDeprecated: Bool {_storage._deprecated != nil} + /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. + mutating func clearDeprecated() {_uniqueStorage()._deprecated = nil} + + /// DEPRECATED. DO NOT USE! + /// For Google-internal migration only. Do not use. + /// + /// NOTE: This field was marked as deprecated in the .proto file. + var weak: Bool { + get {_storage._weak ?? false} + set {_uniqueStorage()._weak = newValue} + } + /// Returns true if `weak` has been explicitly set. + var hasWeak: Bool {_storage._weak != nil} + /// Clears the value of `weak`. Subsequent reads from it will return its default value. + mutating func clearWeak() {_uniqueStorage()._weak = nil} + + /// Indicate that the field value should not be printed out when using debug + /// formats, e.g. when the field contains sensitive credentials. + var debugRedact: Bool { + get {_storage._debugRedact ?? false} + set {_uniqueStorage()._debugRedact = newValue} + } + /// Returns true if `debugRedact` has been explicitly set. + var hasDebugRedact: Bool {_storage._debugRedact != nil} + /// Clears the value of `debugRedact`. Subsequent reads from it will return its default value. + mutating func clearDebugRedact() {_uniqueStorage()._debugRedact = nil} + + var retention: Google_Protobuf_FieldOptions.OptionRetention { + get {_storage._retention ?? .retentionUnknown} + set {_uniqueStorage()._retention = newValue} + } + /// Returns true if `retention` has been explicitly set. + var hasRetention: Bool {_storage._retention != nil} + /// Clears the value of `retention`. Subsequent reads from it will return its default value. + mutating func clearRetention() {_uniqueStorage()._retention = nil} + + var targets: [Google_Protobuf_FieldOptions.OptionTargetType] { + get {_storage._targets} + set {_uniqueStorage()._targets = newValue} + } + + var editionDefaults: [Google_Protobuf_FieldOptions.EditionDefault] { + get {_storage._editionDefaults} + set {_uniqueStorage()._editionDefaults = newValue} + } + + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var features: Google_Protobuf_FeatureSet { + get {_storage._features ?? Google_Protobuf_FeatureSet()} + set {_uniqueStorage()._features = newValue} + } + /// Returns true if `features` has been explicitly set. + var hasFeatures: Bool {_storage._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + mutating func clearFeatures() {_uniqueStorage()._features = nil} + + var featureSupport: Google_Protobuf_FieldOptions.FeatureSupport { + get {_storage._featureSupport ?? Google_Protobuf_FieldOptions.FeatureSupport()} + set {_uniqueStorage()._featureSupport = newValue} + } + /// Returns true if `featureSupport` has been explicitly set. + var hasFeatureSupport: Bool {_storage._featureSupport != nil} + /// Clears the value of `featureSupport`. Subsequent reads from it will return its default value. + mutating func clearFeatureSupport() {_uniqueStorage()._featureSupport = nil} + + /// The parser stores options it doesn't recognize here. See above. + var uninterpretedOption: [Google_Protobuf_UninterpretedOption] { + get {_storage._uninterpretedOption} + set {_uniqueStorage()._uninterpretedOption = newValue} + } + + var unknownFields = UnknownStorage() + + enum CType: Int, Enum, Swift.CaseIterable { + + /// Default mode. + case string = 0 + + /// The option [ctype=CORD] may be applied to a non-repeated field of type + /// "bytes". It indicates that in C++, the data should be stored in a Cord + /// instead of a string. For very large strings, this may reduce memory + /// fragmentation. It may also allow better performance when parsing from a + /// Cord, or when parsing with aliasing enabled, as the parsed Cord may then + /// alias the original buffer. + case cord = 1 + case stringPiece = 2 + + init() { + self = .string + } + + } + + enum JSType: Int, Enum, Swift.CaseIterable { + + /// Use the default type. + case jsNormal = 0 + + /// Use JavaScript strings. + case jsString = 1 + + /// Use JavaScript numbers. + case jsNumber = 2 + + init() { + self = .jsNormal + } + + } + + /// If set to RETENTION_SOURCE, the option will be omitted from the binary. + enum OptionRetention: Int, Enum, Swift.CaseIterable { + case retentionUnknown = 0 + case retentionRuntime = 1 + case retentionSource = 2 + + init() { + self = .retentionUnknown + } + + } + + /// This indicates the types of entities that the field may apply to when used + /// as an option. If it is unset, then the field may be freely used as an + /// option on any kind of entity. + enum OptionTargetType: Int, Enum, Swift.CaseIterable { + case targetTypeUnknown = 0 + case targetTypeFile = 1 + case targetTypeExtensionRange = 2 + case targetTypeMessage = 3 + case targetTypeField = 4 + case targetTypeOneof = 5 + case targetTypeEnum = 6 + case targetTypeEnumEntry = 7 + case targetTypeService = 8 + case targetTypeMethod = 9 + + init() { + self = .targetTypeUnknown + } + + } + + struct EditionDefault: Sendable { + // 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 edition: Google_Protobuf_Edition { + get {_edition ?? .unknown} + set {_edition = newValue} + } + /// Returns true if `edition` has been explicitly set. + var hasEdition: Bool {self._edition != nil} + /// Clears the value of `edition`. Subsequent reads from it will return its default value. + mutating func clearEdition() {self._edition = nil} + + /// Textproto value. + var value: String { + get {_value ?? String()} + set {_value = newValue} + } + /// Returns true if `value` has been explicitly set. + var hasValue: Bool {self._value != nil} + /// Clears the value of `value`. Subsequent reads from it will return its default value. + mutating func clearValue() {self._value = nil} + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _edition: Google_Protobuf_Edition? = nil + fileprivate var _value: String? = nil + } + + /// Information about the support window of a feature. + struct FeatureSupport: Sendable { + // 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. + + /// The edition that this feature was first available in. In editions + /// earlier than this one, the default assigned to EDITION_LEGACY will be + /// used, and proto files will not be able to override it. + var editionIntroduced: Google_Protobuf_Edition { + get {_editionIntroduced ?? .unknown} + set {_editionIntroduced = newValue} + } + /// Returns true if `editionIntroduced` has been explicitly set. + var hasEditionIntroduced: Bool {self._editionIntroduced != nil} + /// Clears the value of `editionIntroduced`. Subsequent reads from it will return its default value. + mutating func clearEditionIntroduced() {self._editionIntroduced = nil} + + /// The edition this feature becomes deprecated in. Using this after this + /// edition may trigger warnings. + var editionDeprecated: Google_Protobuf_Edition { + get {_editionDeprecated ?? .unknown} + set {_editionDeprecated = newValue} + } + /// Returns true if `editionDeprecated` has been explicitly set. + var hasEditionDeprecated: Bool {self._editionDeprecated != nil} + /// Clears the value of `editionDeprecated`. Subsequent reads from it will return its default value. + mutating func clearEditionDeprecated() {self._editionDeprecated = nil} + + /// The deprecation warning text if this feature is used after the edition it + /// was marked deprecated in. + var deprecationWarning: String { + get {_deprecationWarning ?? String()} + set {_deprecationWarning = newValue} + } + /// Returns true if `deprecationWarning` has been explicitly set. + var hasDeprecationWarning: Bool {self._deprecationWarning != nil} + /// Clears the value of `deprecationWarning`. Subsequent reads from it will return its default value. + mutating func clearDeprecationWarning() {self._deprecationWarning = nil} + + /// The edition this feature is no longer available in. In editions after + /// this one, the last default assigned will be used, and proto files will + /// not be able to override it. + var editionRemoved: Google_Protobuf_Edition { + get {_editionRemoved ?? .unknown} + set {_editionRemoved = newValue} + } + /// Returns true if `editionRemoved` has been explicitly set. + var hasEditionRemoved: Bool {self._editionRemoved != nil} + /// Clears the value of `editionRemoved`. Subsequent reads from it will return its default value. + mutating func clearEditionRemoved() {self._editionRemoved = nil} + + /// The removal error text if this feature is used after the edition it was + /// removed in. + var removalError: String { + get {_removalError ?? String()} + set {_removalError = newValue} + } + /// Returns true if `removalError` has been explicitly set. + var hasRemovalError: Bool {self._removalError != nil} + /// Clears the value of `removalError`. Subsequent reads from it will return its default value. + mutating func clearRemovalError() {self._removalError = nil} + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _editionIntroduced: Google_Protobuf_Edition? = nil + fileprivate var _editionDeprecated: Google_Protobuf_Edition? = nil + fileprivate var _deprecationWarning: String? = nil + fileprivate var _editionRemoved: Google_Protobuf_Edition? = nil + fileprivate var _removalError: String? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Google_Protobuf_OneofOptions: ExtensibleMessage, Sendable { + // 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. + + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + mutating func clearFeatures() {self._features = nil} + + /// The parser stores options it doesn't recognize here. See above. + var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] + + var unknownFields = UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _features: Google_Protobuf_FeatureSet? = nil +} + +struct Google_Protobuf_EnumOptions: ExtensibleMessage, Sendable { + // 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. + + /// Set this option to true to allow mapping different tag names to the same + /// value. + var allowAlias: Bool { + get {_allowAlias ?? false} + set {_allowAlias = newValue} + } + /// Returns true if `allowAlias` has been explicitly set. + var hasAllowAlias: Bool {self._allowAlias != nil} + /// Clears the value of `allowAlias`. Subsequent reads from it will return its default value. + mutating func clearAllowAlias() {self._allowAlias = nil} + + /// Is this enum deprecated? + /// Depending on the target platform, this can emit Deprecated annotations + /// for the enum, or it will be completely ignored; in the very least, this + /// is a formalization for deprecating enums. + var deprecated: Bool { + get {_deprecated ?? false} + set {_deprecated = newValue} + } + /// Returns true if `deprecated` has been explicitly set. + var hasDeprecated: Bool {self._deprecated != nil} + /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. + mutating func clearDeprecated() {self._deprecated = nil} + + /// Enable the legacy handling of JSON field name conflicts. This lowercases + /// and strips underscored from the fields before comparison in proto3 only. + /// The new behavior takes `json_name` into account and applies to proto2 as + /// well. + /// TODO Remove this legacy behavior once downstream teams have + /// had time to migrate. + /// + /// NOTE: This field was marked as deprecated in the .proto file. + var deprecatedLegacyJsonFieldConflicts: Bool { + get {_deprecatedLegacyJsonFieldConflicts ?? false} + set {_deprecatedLegacyJsonFieldConflicts = newValue} + } + /// Returns true if `deprecatedLegacyJsonFieldConflicts` has been explicitly set. + var hasDeprecatedLegacyJsonFieldConflicts: Bool {self._deprecatedLegacyJsonFieldConflicts != nil} + /// Clears the value of `deprecatedLegacyJsonFieldConflicts`. Subsequent reads from it will return its default value. + mutating func clearDeprecatedLegacyJsonFieldConflicts() {self._deprecatedLegacyJsonFieldConflicts = nil} + + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + mutating func clearFeatures() {self._features = nil} + + /// The parser stores options it doesn't recognize here. See above. + var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] + + var unknownFields = UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _allowAlias: Bool? = nil + fileprivate var _deprecated: Bool? = nil + fileprivate var _deprecatedLegacyJsonFieldConflicts: Bool? = nil + fileprivate var _features: Google_Protobuf_FeatureSet? = nil +} + +struct Google_Protobuf_EnumValueOptions: ExtensibleMessage, Sendable { + // 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. + + /// Is this enum value deprecated? + /// Depending on the target platform, this can emit Deprecated annotations + /// for the enum value, or it will be completely ignored; in the very least, + /// this is a formalization for deprecating enum values. + var deprecated: Bool { + get {_deprecated ?? false} + set {_deprecated = newValue} + } + /// Returns true if `deprecated` has been explicitly set. + var hasDeprecated: Bool {self._deprecated != nil} + /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. + mutating func clearDeprecated() {self._deprecated = nil} + + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + mutating func clearFeatures() {self._features = nil} + + /// Indicate that fields annotated with this enum value should not be printed + /// out when using debug formats, e.g. when the field contains sensitive + /// credentials. + var debugRedact: Bool { + get {_debugRedact ?? false} + set {_debugRedact = newValue} + } + /// Returns true if `debugRedact` has been explicitly set. + var hasDebugRedact: Bool {self._debugRedact != nil} + /// Clears the value of `debugRedact`. Subsequent reads from it will return its default value. + mutating func clearDebugRedact() {self._debugRedact = nil} + + /// Information about the support window of a feature value. + var featureSupport: Google_Protobuf_FieldOptions.FeatureSupport { + get {_featureSupport ?? Google_Protobuf_FieldOptions.FeatureSupport()} + set {_featureSupport = newValue} + } + /// Returns true if `featureSupport` has been explicitly set. + var hasFeatureSupport: Bool {self._featureSupport != nil} + /// Clears the value of `featureSupport`. Subsequent reads from it will return its default value. + mutating func clearFeatureSupport() {self._featureSupport = nil} + + /// The parser stores options it doesn't recognize here. See above. + var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] + + var unknownFields = UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _deprecated: Bool? = nil + fileprivate var _features: Google_Protobuf_FeatureSet? = nil + fileprivate var _debugRedact: Bool? = nil + fileprivate var _featureSupport: Google_Protobuf_FieldOptions.FeatureSupport? = nil +} + +struct Google_Protobuf_ServiceOptions: ExtensibleMessage, Sendable { + // 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. + + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + mutating func clearFeatures() {self._features = nil} + + /// Is this service deprecated? + /// Depending on the target platform, this can emit Deprecated annotations + /// for the service, or it will be completely ignored; in the very least, + /// this is a formalization for deprecating services. + var deprecated: Bool { + get {_deprecated ?? false} + set {_deprecated = newValue} + } + /// Returns true if `deprecated` has been explicitly set. + var hasDeprecated: Bool {self._deprecated != nil} + /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. + mutating func clearDeprecated() {self._deprecated = nil} + + /// The parser stores options it doesn't recognize here. See above. + var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] + + var unknownFields = UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _features: Google_Protobuf_FeatureSet? = nil + fileprivate var _deprecated: Bool? = nil +} + +struct Google_Protobuf_MethodOptions: ExtensibleMessage, Sendable { + // 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. + + /// Is this method deprecated? + /// Depending on the target platform, this can emit Deprecated annotations + /// for the method, or it will be completely ignored; in the very least, + /// this is a formalization for deprecating methods. + var deprecated: Bool { + get {_deprecated ?? false} + set {_deprecated = newValue} + } + /// Returns true if `deprecated` has been explicitly set. + var hasDeprecated: Bool {self._deprecated != nil} + /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. + mutating func clearDeprecated() {self._deprecated = nil} + + var idempotencyLevel: Google_Protobuf_MethodOptions.IdempotencyLevel { + get {_idempotencyLevel ?? .idempotencyUnknown} + set {_idempotencyLevel = newValue} + } + /// Returns true if `idempotencyLevel` has been explicitly set. + var hasIdempotencyLevel: Bool {self._idempotencyLevel != nil} + /// Clears the value of `idempotencyLevel`. Subsequent reads from it will return its default value. + mutating func clearIdempotencyLevel() {self._idempotencyLevel = nil} + + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + mutating func clearFeatures() {self._features = nil} + + /// The parser stores options it doesn't recognize here. See above. + var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] + + var unknownFields = UnknownStorage() + + /// Is this method side-effect-free (or safe in HTTP parlance), or idempotent, + /// or neither? HTTP based RPC implementation may choose GET verb for safe + /// methods, and PUT verb for idempotent methods instead of the default POST. + enum IdempotencyLevel: Int, Enum, Swift.CaseIterable { + case idempotencyUnknown = 0 + + /// implies idempotent + case noSideEffects = 1 + + /// idempotent, but may have side effects + case idempotent = 2 + + init() { + self = .idempotencyUnknown + } + + } + + init() {} + + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _deprecated: Bool? = nil + fileprivate var _idempotencyLevel: Google_Protobuf_MethodOptions.IdempotencyLevel? = nil + fileprivate var _features: Google_Protobuf_FeatureSet? = nil +} + +/// A message representing a option the parser does not recognize. This only +/// appears in options protos created by the compiler::Parser class. +/// DescriptorPool resolves these when building Descriptor objects. Therefore, +/// options protos in descriptor objects (e.g. returned by Descriptor::options(), +/// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions +/// in them. +struct Google_Protobuf_UninterpretedOption: Sendable { + // 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 name: [Google_Protobuf_UninterpretedOption.NamePart] = [] + + /// The value of the uninterpreted option, in whatever type the tokenizer + /// identified it as during parsing. Exactly one of these should be set. + var identifierValue: String { + get {_identifierValue ?? String()} + set {_identifierValue = newValue} + } + /// Returns true if `identifierValue` has been explicitly set. + var hasIdentifierValue: Bool {self._identifierValue != nil} + /// Clears the value of `identifierValue`. Subsequent reads from it will return its default value. + mutating func clearIdentifierValue() {self._identifierValue = nil} + + var positiveIntValue: UInt64 { + get {_positiveIntValue ?? 0} + set {_positiveIntValue = newValue} + } + /// Returns true if `positiveIntValue` has been explicitly set. + var hasPositiveIntValue: Bool {self._positiveIntValue != nil} + /// Clears the value of `positiveIntValue`. Subsequent reads from it will return its default value. + mutating func clearPositiveIntValue() {self._positiveIntValue = nil} + + var negativeIntValue: Int64 { + get {_negativeIntValue ?? 0} + set {_negativeIntValue = newValue} + } + /// Returns true if `negativeIntValue` has been explicitly set. + var hasNegativeIntValue: Bool {self._negativeIntValue != nil} + /// Clears the value of `negativeIntValue`. Subsequent reads from it will return its default value. + mutating func clearNegativeIntValue() {self._negativeIntValue = nil} + + var doubleValue: Double { + get {_doubleValue ?? 0} + set {_doubleValue = newValue} + } + /// Returns true if `doubleValue` has been explicitly set. + var hasDoubleValue: Bool {self._doubleValue != nil} + /// Clears the value of `doubleValue`. Subsequent reads from it will return its default value. + mutating func clearDoubleValue() {self._doubleValue = nil} + + var stringValue: Data { + get {_stringValue ?? Data()} + set {_stringValue = newValue} + } + /// Returns true if `stringValue` has been explicitly set. + var hasStringValue: Bool {self._stringValue != nil} + /// Clears the value of `stringValue`. Subsequent reads from it will return its default value. + mutating func clearStringValue() {self._stringValue = nil} + + var aggregateValue: String { + get {_aggregateValue ?? String()} + set {_aggregateValue = newValue} + } + /// Returns true if `aggregateValue` has been explicitly set. + var hasAggregateValue: Bool {self._aggregateValue != nil} + /// Clears the value of `aggregateValue`. Subsequent reads from it will return its default value. + mutating func clearAggregateValue() {self._aggregateValue = nil} + + var unknownFields = UnknownStorage() + + /// The name of the uninterpreted option. Each string represents a segment in + /// a dot-separated name. is_extension is true iff a segment represents an + /// extension (denoted with parentheses in options specs in .proto files). + /// E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents + /// "foo.(bar.baz).moo". + struct NamePart: Sendable { + // 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 namePart: String { + get {_namePart ?? String()} + set {_namePart = newValue} + } + /// Returns true if `namePart` has been explicitly set. + var hasNamePart: Bool {self._namePart != nil} + /// Clears the value of `namePart`. Subsequent reads from it will return its default value. + mutating func clearNamePart() {self._namePart = nil} + + var isExtension: Bool { + get {_isExtension ?? false} + set {_isExtension = newValue} + } + /// Returns true if `isExtension` has been explicitly set. + var hasIsExtension: Bool {self._isExtension != nil} + /// Clears the value of `isExtension`. Subsequent reads from it will return its default value. + mutating func clearIsExtension() {self._isExtension = nil} + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _namePart: String? = nil + fileprivate var _isExtension: Bool? = nil + } + + init() {} + + fileprivate var _identifierValue: String? = nil + fileprivate var _positiveIntValue: UInt64? = nil + fileprivate var _negativeIntValue: Int64? = nil + fileprivate var _doubleValue: Double? = nil + fileprivate var _stringValue: Data? = nil + fileprivate var _aggregateValue: String? = nil +} + +/// TODO Enums in C++ gencode (and potentially other languages) are +/// not well scoped. This means that each of the feature enums below can clash +/// with each other. The short names we've chosen maximize call-site +/// readability, but leave us very open to this scenario. A future feature will +/// be designed and implemented to handle this, hopefully before we ever hit a +/// conflict here. +struct Google_Protobuf_FeatureSet: ExtensibleMessage, Sendable { + // 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 fieldPresence: Google_Protobuf_FeatureSet.FieldPresence { + get {_fieldPresence ?? .unknown} + set {_fieldPresence = newValue} + } + /// Returns true if `fieldPresence` has been explicitly set. + var hasFieldPresence: Bool {self._fieldPresence != nil} + /// Clears the value of `fieldPresence`. Subsequent reads from it will return its default value. + mutating func clearFieldPresence() {self._fieldPresence = nil} + + var enumType: Google_Protobuf_FeatureSet.EnumType { + get {_enumType ?? .unknown} + set {_enumType = newValue} + } + /// Returns true if `enumType` has been explicitly set. + var hasEnumType: Bool {self._enumType != nil} + /// Clears the value of `enumType`. Subsequent reads from it will return its default value. + mutating func clearEnumType() {self._enumType = nil} + + var repeatedFieldEncoding: Google_Protobuf_FeatureSet.RepeatedFieldEncoding { + get {_repeatedFieldEncoding ?? .unknown} + set {_repeatedFieldEncoding = newValue} + } + /// Returns true if `repeatedFieldEncoding` has been explicitly set. + var hasRepeatedFieldEncoding: Bool {self._repeatedFieldEncoding != nil} + /// Clears the value of `repeatedFieldEncoding`. Subsequent reads from it will return its default value. + mutating func clearRepeatedFieldEncoding() {self._repeatedFieldEncoding = nil} + + var utf8Validation: Google_Protobuf_FeatureSet.Utf8Validation { + get {_utf8Validation ?? .unknown} + set {_utf8Validation = newValue} + } + /// Returns true if `utf8Validation` has been explicitly set. + var hasUtf8Validation: Bool {self._utf8Validation != nil} + /// Clears the value of `utf8Validation`. Subsequent reads from it will return its default value. + mutating func clearUtf8Validation() {self._utf8Validation = nil} + + var messageEncoding: Google_Protobuf_FeatureSet.MessageEncoding { + get {_messageEncoding ?? .unknown} + set {_messageEncoding = newValue} + } + /// Returns true if `messageEncoding` has been explicitly set. + var hasMessageEncoding: Bool {self._messageEncoding != nil} + /// Clears the value of `messageEncoding`. Subsequent reads from it will return its default value. + mutating func clearMessageEncoding() {self._messageEncoding = nil} + + var jsonFormat: Google_Protobuf_FeatureSet.JsonFormat { + get {_jsonFormat ?? .unknown} + set {_jsonFormat = newValue} + } + /// Returns true if `jsonFormat` has been explicitly set. + var hasJsonFormat: Bool {self._jsonFormat != nil} + /// Clears the value of `jsonFormat`. Subsequent reads from it will return its default value. + mutating func clearJsonFormat() {self._jsonFormat = nil} + + var enforceNamingStyle: Google_Protobuf_FeatureSet.EnforceNamingStyle { + get {_enforceNamingStyle ?? .unknown} + set {_enforceNamingStyle = newValue} + } + /// Returns true if `enforceNamingStyle` has been explicitly set. + var hasEnforceNamingStyle: Bool {self._enforceNamingStyle != nil} + /// Clears the value of `enforceNamingStyle`. Subsequent reads from it will return its default value. + mutating func clearEnforceNamingStyle() {self._enforceNamingStyle = nil} + + var defaultSymbolVisibility: Google_Protobuf_FeatureSet.VisibilityFeature.DefaultSymbolVisibility { + get {_defaultSymbolVisibility ?? .unknown} + set {_defaultSymbolVisibility = newValue} + } + /// Returns true if `defaultSymbolVisibility` has been explicitly set. + var hasDefaultSymbolVisibility: Bool {self._defaultSymbolVisibility != nil} + /// Clears the value of `defaultSymbolVisibility`. Subsequent reads from it will return its default value. + mutating func clearDefaultSymbolVisibility() {self._defaultSymbolVisibility = nil} + + var unknownFields = UnknownStorage() + + enum FieldPresence: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case explicit = 1 + case implicit = 2 + case legacyRequired = 3 + + init() { + self = .unknown + } + + } + + enum EnumType: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case `open` = 1 + case closed = 2 + + init() { + self = .unknown + } + + } + + enum RepeatedFieldEncoding: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case packed = 1 + case expanded = 2 + + init() { + self = .unknown + } + + } + + enum Utf8Validation: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case verify = 2 + case none = 3 + + init() { + self = .unknown + } + + } + + enum MessageEncoding: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case lengthPrefixed = 1 + case delimited = 2 + + init() { + self = .unknown + } + + } + + enum JsonFormat: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case allow = 1 + case legacyBestEffort = 2 + + init() { + self = .unknown + } + + } + + enum EnforceNamingStyle: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case style2024 = 1 + case styleLegacy = 2 + + init() { + self = .unknown + } + + } + + struct VisibilityFeature: Sendable { + // 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 = UnknownStorage() + + enum DefaultSymbolVisibility: Int, Enum, Swift.CaseIterable { + case unknown = 0 + + /// Default pre-EDITION_2024, all UNSET visibility are export. + case exportAll = 1 + + /// All top-level symbols default to export, nested default to local. + case exportTopLevel = 2 + + /// All symbols default to local. + case localAll = 3 + + /// All symbols local by default. Nested types cannot be exported. + /// With special case caveat for message { enum {} reserved 1 to max; } + /// This is the recommended setting for new protos. + case strict = 4 + + init() { + self = .unknown + } + + } + + init() {} + } + + init() {} + + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _fieldPresence: Google_Protobuf_FeatureSet.FieldPresence? = nil + fileprivate var _enumType: Google_Protobuf_FeatureSet.EnumType? = nil + fileprivate var _repeatedFieldEncoding: Google_Protobuf_FeatureSet.RepeatedFieldEncoding? = nil + fileprivate var _utf8Validation: Google_Protobuf_FeatureSet.Utf8Validation? = nil + fileprivate var _messageEncoding: Google_Protobuf_FeatureSet.MessageEncoding? = nil + fileprivate var _jsonFormat: Google_Protobuf_FeatureSet.JsonFormat? = nil + fileprivate var _enforceNamingStyle: Google_Protobuf_FeatureSet.EnforceNamingStyle? = nil + fileprivate var _defaultSymbolVisibility: Google_Protobuf_FeatureSet.VisibilityFeature.DefaultSymbolVisibility? = nil +} + +/// A compiled specification for the defaults of a set of features. These +/// messages are generated from FeatureSet extensions and can be used to seed +/// feature resolution. The resolution with this object becomes a simple search +/// for the closest matching edition, followed by proto merges. +struct Google_Protobuf_FeatureSetDefaults: Sendable { + // 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 defaults: [Google_Protobuf_FeatureSetDefaults.FeatureSetEditionDefault] = [] + + /// The minimum supported edition (inclusive) when this was constructed. + /// Editions before this will not have defaults. + var minimumEdition: Google_Protobuf_Edition { + get {_minimumEdition ?? .unknown} + set {_minimumEdition = newValue} + } + /// Returns true if `minimumEdition` has been explicitly set. + var hasMinimumEdition: Bool {self._minimumEdition != nil} + /// Clears the value of `minimumEdition`. Subsequent reads from it will return its default value. + mutating func clearMinimumEdition() {self._minimumEdition = nil} + + /// The maximum known edition (inclusive) when this was constructed. Editions + /// after this will not have reliable defaults. + var maximumEdition: Google_Protobuf_Edition { + get {_maximumEdition ?? .unknown} + set {_maximumEdition = newValue} + } + /// Returns true if `maximumEdition` has been explicitly set. + var hasMaximumEdition: Bool {self._maximumEdition != nil} + /// Clears the value of `maximumEdition`. Subsequent reads from it will return its default value. + mutating func clearMaximumEdition() {self._maximumEdition = nil} + + var unknownFields = UnknownStorage() + + /// A map from every known edition with a unique set of defaults to its + /// defaults. Not all editions may be contained here. For a given edition, + /// the defaults at the closest matching edition ordered at or before it should + /// be used. This field must be in strict ascending order by edition. + struct FeatureSetEditionDefault: @unchecked Sendable { + // 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 edition: Google_Protobuf_Edition { + get {_storage._edition ?? .unknown} + set {_uniqueStorage()._edition = newValue} + } + /// Returns true if `edition` has been explicitly set. + var hasEdition: Bool {_storage._edition != nil} + /// Clears the value of `edition`. Subsequent reads from it will return its default value. + mutating func clearEdition() {_uniqueStorage()._edition = nil} + + /// Defaults of features that can be overridden in this edition. + var overridableFeatures: Google_Protobuf_FeatureSet { + get {_storage._overridableFeatures ?? Google_Protobuf_FeatureSet()} + set {_uniqueStorage()._overridableFeatures = newValue} + } + /// Returns true if `overridableFeatures` has been explicitly set. + var hasOverridableFeatures: Bool {_storage._overridableFeatures != nil} + /// Clears the value of `overridableFeatures`. Subsequent reads from it will return its default value. + mutating func clearOverridableFeatures() {_uniqueStorage()._overridableFeatures = nil} + + /// Defaults of features that can't be overridden in this edition. + var fixedFeatures: Google_Protobuf_FeatureSet { + get {_storage._fixedFeatures ?? Google_Protobuf_FeatureSet()} + set {_uniqueStorage()._fixedFeatures = newValue} + } + /// Returns true if `fixedFeatures` has been explicitly set. + var hasFixedFeatures: Bool {_storage._fixedFeatures != nil} + /// Clears the value of `fixedFeatures`. Subsequent reads from it will return its default value. + mutating func clearFixedFeatures() {_uniqueStorage()._fixedFeatures = nil} + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + init() {} + + fileprivate var _minimumEdition: Google_Protobuf_Edition? = nil + fileprivate var _maximumEdition: Google_Protobuf_Edition? = nil +} + +/// Encapsulates information about the original source file from which a +/// FileDescriptorProto was generated. +struct Google_Protobuf_SourceCodeInfo: ExtensibleMessage, Sendable { + // 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. + + /// A Location identifies a piece of source code in a .proto file which + /// corresponds to a particular definition. This information is intended + /// to be useful to IDEs, code indexers, documentation generators, and similar + /// tools. + /// + /// For example, say we have a file like: + /// message Foo { + /// optional string foo = 1; + /// } + /// Let's look at just the field definition: + /// optional string foo = 1; + /// ^ ^^ ^^ ^ ^^^ + /// a bc de f ghi + /// We have the following locations: + /// span path represents + /// [a,i) [ 4, 0, 2, 0 ] The whole field definition. + /// [a,b) [ 4, 0, 2, 0, 4 ] The label (optional). + /// [c,d) [ 4, 0, 2, 0, 5 ] The type (string). + /// [e,f) [ 4, 0, 2, 0, 1 ] The name (foo). + /// [g,h) [ 4, 0, 2, 0, 3 ] The number (1). + /// + /// Notes: + /// - A location may refer to a repeated field itself (i.e. not to any + /// particular index within it). This is used whenever a set of elements are + /// logically enclosed in a single code segment. For example, an entire + /// extend block (possibly containing multiple extension definitions) will + /// have an outer location whose path refers to the "extensions" repeated + /// field without an index. + /// - Multiple locations may have the same path. This happens when a single + /// logical declaration is spread out across multiple places. The most + /// obvious example is the "extend" block again -- there may be multiple + /// extend blocks in the same scope, each of which will have the same path. + /// - A location's span is not always a subset of its parent's span. For + /// example, the "extendee" of an extension declaration appears at the + /// beginning of the "extend" block and is shared by all extensions within + /// the block. + /// - Just because a location's span is a subset of some other location's span + /// does not mean that it is a descendant. For example, a "group" defines + /// both a type and a field in a single declaration. Thus, the locations + /// corresponding to the type and field and their components will overlap. + /// - Code which tries to interpret locations should probably be designed to + /// ignore those that it doesn't understand, as more types of locations could + /// be recorded in the future. + var location: [Google_Protobuf_SourceCodeInfo.Location] = [] + + var unknownFields = UnknownStorage() + + struct Location: Sendable { + // 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. + + /// Identifies which part of the FileDescriptorProto was defined at this + /// location. + /// + /// Each element is a field number or an index. They form a path from + /// the root FileDescriptorProto to the place where the definition appears. + /// For example, this path: + /// [ 4, 3, 2, 7, 1 ] + /// refers to: + /// file.message_type(3) // 4, 3 + /// .field(7) // 2, 7 + /// .name() // 1 + /// This is because FileDescriptorProto.message_type has field number 4: + /// repeated DescriptorProto message_type = 4; + /// and DescriptorProto.field has field number 2: + /// repeated FieldDescriptorProto field = 2; + /// and FieldDescriptorProto.name has field number 1: + /// optional string name = 1; + /// + /// Thus, the above path gives the location of a field name. If we removed + /// the last element: + /// [ 4, 3, 2, 7 ] + /// this path refers to the whole field declaration (from the beginning + /// of the label to the terminating semicolon). + var path: [Int32] = [] + + /// Always has exactly three or four elements: start line, start column, + /// end line (optional, otherwise assumed same as start line), end column. + /// These are packed into a single field for efficiency. Note that line + /// and column numbers are zero-based -- typically you will want to add + /// 1 to each before displaying to a user. + var span: [Int32] = [] + + /// If this SourceCodeInfo represents a complete declaration, these are any + /// comments appearing before and after the declaration which appear to be + /// attached to the declaration. + /// + /// A series of line comments appearing on consecutive lines, with no other + /// tokens appearing on those lines, will be treated as a single comment. + /// + /// leading_detached_comments will keep paragraphs of comments that appear + /// before (but not connected to) the current element. Each paragraph, + /// separated by empty lines, will be one comment element in the repeated + /// field. + /// + /// Only the comment content is provided; comment markers (e.g. //) are + /// stripped out. For block comments, leading whitespace and an asterisk + /// will be stripped from the beginning of each line other than the first. + /// Newlines are included in the output. + /// + /// Examples: + /// + /// optional int32 foo = 1; // Comment attached to foo. + /// // Comment attached to bar. + /// optional int32 bar = 2; + /// + /// optional string baz = 3; + /// // Comment attached to baz. + /// // Another line attached to baz. + /// + /// // Comment attached to moo. + /// // + /// // Another line attached to moo. + /// optional double moo = 4; + /// + /// // Detached comment for corge. This is not leading or trailing comments + /// // to moo or corge because there are blank lines separating it from + /// // both. + /// + /// // Detached comment for corge paragraph 2. + /// + /// optional string corge = 5; + /// /* Block comment attached + /// * to corge. Leading asterisks + /// * will be removed. */ + /// /* Block comment attached to + /// * grault. */ + /// optional int32 grault = 6; + /// + /// // ignored detached comments. + var leadingComments: String { + get {_leadingComments ?? String()} + set {_leadingComments = newValue} + } + /// Returns true if `leadingComments` has been explicitly set. + var hasLeadingComments: Bool {self._leadingComments != nil} + /// Clears the value of `leadingComments`. Subsequent reads from it will return its default value. + mutating func clearLeadingComments() {self._leadingComments = nil} + + var trailingComments: String { + get {_trailingComments ?? String()} + set {_trailingComments = newValue} + } + /// Returns true if `trailingComments` has been explicitly set. + var hasTrailingComments: Bool {self._trailingComments != nil} + /// Clears the value of `trailingComments`. Subsequent reads from it will return its default value. + mutating func clearTrailingComments() {self._trailingComments = nil} + + var leadingDetachedComments: [String] = [] + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _leadingComments: String? = nil + fileprivate var _trailingComments: String? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = ExtensionFieldValueSet() +} + +/// Describes the relationship between generated code and its original source +/// file. A GeneratedCodeInfo message is associated with only one generated +/// source file, but may contain references to different source .proto files. +struct Google_Protobuf_GeneratedCodeInfo: Sendable { + // 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. + + /// An Annotation connects some span of text in generated code to an element + /// of its generating .proto file. + var annotation: [Google_Protobuf_GeneratedCodeInfo.Annotation] = [] + + var unknownFields = UnknownStorage() + + struct Annotation: Sendable { + // 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. + + /// Identifies the element in the original source .proto file. This field + /// is formatted the same as SourceCodeInfo.Location.path. + var path: [Int32] = [] + + /// Identifies the filesystem path to the original source .proto. + var sourceFile: String { + get {_sourceFile ?? String()} + set {_sourceFile = newValue} + } + /// Returns true if `sourceFile` has been explicitly set. + var hasSourceFile: Bool {self._sourceFile != nil} + /// Clears the value of `sourceFile`. Subsequent reads from it will return its default value. + mutating func clearSourceFile() {self._sourceFile = nil} + + /// Identifies the starting offset in bytes in the generated code + /// that relates to the identified object. + var begin: Int32 { + get {_begin ?? 0} + set {_begin = newValue} + } + /// Returns true if `begin` has been explicitly set. + var hasBegin: Bool {self._begin != nil} + /// Clears the value of `begin`. Subsequent reads from it will return its default value. + mutating func clearBegin() {self._begin = nil} + + /// Identifies the ending offset in bytes in the generated code that + /// relates to the identified object. The end offset should be one past + /// the last relevant byte (so the length of the text = end - begin). + var end: Int32 { + get {_end ?? 0} + set {_end = newValue} + } + /// Returns true if `end` has been explicitly set. + var hasEnd: Bool {self._end != nil} + /// Clears the value of `end`. Subsequent reads from it will return its default value. + mutating func clearEnd() {self._end = nil} + + var semantic: Google_Protobuf_GeneratedCodeInfo.Annotation.Semantic { + get {_semantic ?? .none} + set {_semantic = newValue} + } + /// Returns true if `semantic` has been explicitly set. + var hasSemantic: Bool {self._semantic != nil} + /// Clears the value of `semantic`. Subsequent reads from it will return its default value. + mutating func clearSemantic() {self._semantic = nil} + + var unknownFields = UnknownStorage() + + /// Represents the identified object's effect on the element in the original + /// .proto file. + enum Semantic: Int, Enum, Swift.CaseIterable { + + /// There is no effect or the effect is indescribable. + case none = 0 + + /// The element is set or otherwise mutated. + case set = 1 + + /// An alias to the element is returned. + case alias = 2 + + init() { + self = .none + } + + } + + init() {} + + fileprivate var _sourceFile: String? = nil + fileprivate var _begin: Int32? = nil + fileprivate var _end: Int32? = nil + fileprivate var _semantic: Google_Protobuf_GeneratedCodeInfo.Annotation.Semantic? = nil + } + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "google.protobuf" + +extension Google_Protobuf_Edition: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0EDITION_UNKNOWN\0\u{1}EDITION_1_TEST_ONLY\0\u{1}EDITION_2_TEST_ONLY\0\u{2}B\u{e}EDITION_LEGACY\0\u{2}b\u{1}EDITION_PROTO2\0\u{1}EDITION_PROTO3\0\u{1}EDITION_2023\0\u{1}EDITION_2024\0\u{2}fL\u{2}EDITION_UNSTABLE\0\u{2}N~\u{15}EDITION_99997_TEST_ONLY\0\u{1}EDITION_99998_TEST_ONLY\0\u{1}EDITION_99999_TEST_ONLY\0\u{2}`eg\u{7f}\u{7f}\u{1}EDITION_MAX\0") +} + +extension Google_Protobuf_SymbolVisibility: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0VISIBILITY_UNSET\0\u{1}VISIBILITY_LOCAL\0\u{1}VISIBILITY_EXPORT\0") +} + +extension Google_Protobuf_FileDescriptorSet: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FileDescriptorSet" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}file\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + if !Internal.areAllInitialized(self.file) {return false} + return true + } + + 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.decodeRepeatedMessageField(value: &self.file) }() + case 536000000: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_FileDescriptorSet.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.file.isEmpty { + try visitor.visitRepeatedMessageField(value: self.file, fieldNumber: 1) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 536000000, end: 536000001) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_FileDescriptorSet, rhs: Google_Protobuf_FileDescriptorSet) -> Bool { + if lhs.file != rhs.file {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Google_Protobuf_FileDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FileDescriptorProto" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}package\0\u{1}dependency\0\u{3}message_type\0\u{3}enum_type\0\u{1}service\0\u{1}extension\0\u{1}options\0\u{3}source_code_info\0\u{3}public_dependency\0\u{3}weak_dependency\0\u{1}syntax\0\u{2}\u{2}edition\0\u{3}option_dependency\0") + + public var isInitialized: Bool { + if !Internal.areAllInitialized(self.messageType) {return false} + if !Internal.areAllInitialized(self.enumType) {return false} + if !Internal.areAllInitialized(self.service) {return false} + if !Internal.areAllInitialized(self.`extension`) {return false} + if let v = self._options, !v.isInitialized {return false} + if let v = self._sourceCodeInfo, !v.isInitialized {return false} + return true + } + + 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._name) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._package) }() + case 3: try { try decoder.decodeRepeatedStringField(value: &self.dependency) }() + case 4: try { try decoder.decodeRepeatedMessageField(value: &self.messageType) }() + case 5: try { try decoder.decodeRepeatedMessageField(value: &self.enumType) }() + case 6: try { try decoder.decodeRepeatedMessageField(value: &self.service) }() + case 7: try { try decoder.decodeRepeatedMessageField(value: &self.`extension`) }() + case 8: try { try decoder.decodeSingularMessageField(value: &self._options) }() + case 9: try { try decoder.decodeSingularMessageField(value: &self._sourceCodeInfo) }() + case 10: try { try decoder.decodeRepeatedInt32Field(value: &self.publicDependency) }() + case 11: try { try decoder.decodeRepeatedInt32Field(value: &self.weakDependency) }() + case 12: try { try decoder.decodeSingularStringField(value: &self._syntax) }() + case 14: try { try decoder.decodeSingularEnumField(value: &self._edition) }() + case 15: try { try decoder.decodeRepeatedStringField(value: &self.optionDependency) }() + 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 + try { if let v = self._name { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = self._package { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + if !self.dependency.isEmpty { + try visitor.visitRepeatedStringField(value: self.dependency, fieldNumber: 3) + } + if !self.messageType.isEmpty { + try visitor.visitRepeatedMessageField(value: self.messageType, fieldNumber: 4) + } + if !self.enumType.isEmpty { + try visitor.visitRepeatedMessageField(value: self.enumType, fieldNumber: 5) + } + if !self.service.isEmpty { + try visitor.visitRepeatedMessageField(value: self.service, fieldNumber: 6) + } + if !self.`extension`.isEmpty { + try visitor.visitRepeatedMessageField(value: self.`extension`, fieldNumber: 7) + } + try { if let v = self._options { + try visitor.visitSingularMessageField(value: v, fieldNumber: 8) + } }() + try { if let v = self._sourceCodeInfo { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !self.publicDependency.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.publicDependency, fieldNumber: 10) + } + if !self.weakDependency.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.weakDependency, fieldNumber: 11) + } + try { if let v = self._syntax { + try visitor.visitSingularStringField(value: v, fieldNumber: 12) + } }() + try { if let v = self._edition { + try visitor.visitSingularEnumField(value: v, fieldNumber: 14) + } }() + if !self.optionDependency.isEmpty { + try visitor.visitRepeatedStringField(value: self.optionDependency, fieldNumber: 15) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_FileDescriptorProto, rhs: Google_Protobuf_FileDescriptorProto) -> Bool { + if lhs._name != rhs._name {return false} + if lhs._package != rhs._package {return false} + if lhs.dependency != rhs.dependency {return false} + if lhs.publicDependency != rhs.publicDependency {return false} + if lhs.weakDependency != rhs.weakDependency {return false} + if lhs.optionDependency != rhs.optionDependency {return false} + if lhs.messageType != rhs.messageType {return false} + if lhs.enumType != rhs.enumType {return false} + if lhs.service != rhs.service {return false} + if lhs.`extension` != rhs.`extension` {return false} + if lhs._options != rhs._options {return false} + if lhs._sourceCodeInfo != rhs._sourceCodeInfo {return false} + if lhs._syntax != rhs._syntax {return false} + if lhs._edition != rhs._edition {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_DescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".DescriptorProto" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}field\0\u{3}nested_type\0\u{3}enum_type\0\u{3}extension_range\0\u{1}extension\0\u{1}options\0\u{3}oneof_decl\0\u{3}reserved_range\0\u{3}reserved_name\0\u{1}visibility\0") + + fileprivate class _StorageClass { + var _name: String? = nil + var _field: [Google_Protobuf_FieldDescriptorProto] = [] + var _extension: [Google_Protobuf_FieldDescriptorProto] = [] + var _nestedType: [Google_Protobuf_DescriptorProto] = [] + var _enumType: [Google_Protobuf_EnumDescriptorProto] = [] + var _extensionRange: [Google_Protobuf_DescriptorProto.ExtensionRange] = [] + var _oneofDecl: [Google_Protobuf_OneofDescriptorProto] = [] + var _options: Google_Protobuf_MessageOptions? = nil + var _reservedRange: [Google_Protobuf_DescriptorProto.ReservedRange] = [] + var _reservedName: [String] = [] + var _visibility: Google_Protobuf_SymbolVisibility? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _name = source._name + _field = source._field + _extension = source._extension + _nestedType = source._nestedType + _enumType = source._enumType + _extensionRange = source._extensionRange + _oneofDecl = source._oneofDecl + _options = source._options + _reservedRange = source._reservedRange + _reservedName = source._reservedName + _visibility = source._visibility + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if !Internal.areAllInitialized(_storage._field) {return false} + if !Internal.areAllInitialized(_storage._extension) {return false} + if !Internal.areAllInitialized(_storage._nestedType) {return false} + if !Internal.areAllInitialized(_storage._enumType) {return false} + if !Internal.areAllInitialized(_storage._extensionRange) {return false} + if !Internal.areAllInitialized(_storage._oneofDecl) {return false} + if let v = _storage._options, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._name) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &_storage._field) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &_storage._nestedType) }() + case 4: try { try decoder.decodeRepeatedMessageField(value: &_storage._enumType) }() + case 5: try { try decoder.decodeRepeatedMessageField(value: &_storage._extensionRange) }() + case 6: try { try decoder.decodeRepeatedMessageField(value: &_storage._extension) }() + case 7: try { try decoder.decodeSingularMessageField(value: &_storage._options) }() + case 8: try { try decoder.decodeRepeatedMessageField(value: &_storage._oneofDecl) }() + case 9: try { try decoder.decodeRepeatedMessageField(value: &_storage._reservedRange) }() + case 10: try { try decoder.decodeRepeatedStringField(value: &_storage._reservedName) }() + case 11: try { try decoder.decodeSingularEnumField(value: &_storage._visibility) }() + default: break + } + } + } + } + + func traverse(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._name { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + if !_storage._field.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._field, fieldNumber: 2) + } + if !_storage._nestedType.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._nestedType, fieldNumber: 3) + } + if !_storage._enumType.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._enumType, fieldNumber: 4) + } + if !_storage._extensionRange.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._extensionRange, fieldNumber: 5) + } + if !_storage._extension.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._extension, fieldNumber: 6) + } + try { if let v = _storage._options { + try visitor.visitSingularMessageField(value: v, fieldNumber: 7) + } }() + if !_storage._oneofDecl.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._oneofDecl, fieldNumber: 8) + } + if !_storage._reservedRange.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._reservedRange, fieldNumber: 9) + } + if !_storage._reservedName.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._reservedName, fieldNumber: 10) + } + try { if let v = _storage._visibility { + try visitor.visitSingularEnumField(value: v, fieldNumber: 11) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_DescriptorProto, rhs: Google_Protobuf_DescriptorProto) -> 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._name != rhs_storage._name {return false} + if _storage._field != rhs_storage._field {return false} + if _storage._extension != rhs_storage._extension {return false} + if _storage._nestedType != rhs_storage._nestedType {return false} + if _storage._enumType != rhs_storage._enumType {return false} + if _storage._extensionRange != rhs_storage._extensionRange {return false} + if _storage._oneofDecl != rhs_storage._oneofDecl {return false} + if _storage._options != rhs_storage._options {return false} + if _storage._reservedRange != rhs_storage._reservedRange {return false} + if _storage._reservedName != rhs_storage._reservedName {return false} + if _storage._visibility != rhs_storage._visibility {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_DescriptorProto.ExtensionRange: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = Google_Protobuf_DescriptorProto.protoMessageName + ".ExtensionRange" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}start\0\u{1}end\0\u{1}options\0") + + public var isInitialized: Bool { + if let v = self._options, !v.isInitialized {return false} + return true + } + + 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._start) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._end) }() + case 3: try { try decoder.decodeSingularMessageField(value: &self._options) }() + 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 + try { if let v = self._start { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._end { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._options { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_DescriptorProto.ExtensionRange, rhs: Google_Protobuf_DescriptorProto.ExtensionRange) -> Bool { + if lhs._start != rhs._start {return false} + if lhs._end != rhs._end {return false} + if lhs._options != rhs._options {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_DescriptorProto.ReservedRange: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = Google_Protobuf_DescriptorProto.protoMessageName + ".ReservedRange" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}start\0\u{1}end\0") + + 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._start) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._end) }() + 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 + try { if let v = self._start { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._end { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_DescriptorProto.ReservedRange, rhs: Google_Protobuf_DescriptorProto.ReservedRange) -> Bool { + if lhs._start != rhs._start {return false} + if lhs._end != rhs._end {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_ExtensionRangeOptions: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ExtensionRangeOptions" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\u{2}declaration\0\u{1}verification\0\u{2}/features\0\u{4}u\u{e}uninterpreted_option\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} + if let v = self._features, !v.isInitialized {return false} + return true + } + + 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 2: try { try decoder.decodeRepeatedMessageField(value: &self.declaration) }() + case 3: try { try decoder.decodeSingularEnumField(value: &self._verification) }() + case 50: try { try decoder.decodeSingularMessageField(value: &self._features) }() + case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_ExtensionRangeOptions.self, fieldNumber: fieldNumber) }() + 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 + if !self.declaration.isEmpty { + try visitor.visitRepeatedMessageField(value: self.declaration, fieldNumber: 2) + } + try { if let v = self._verification { + try visitor.visitSingularEnumField(value: v, fieldNumber: 3) + } }() + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 50) + } }() + if !self.uninterpretedOption.isEmpty { + try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_ExtensionRangeOptions, rhs: Google_Protobuf_ExtensionRangeOptions) -> Bool { + if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} + if lhs.declaration != rhs.declaration {return false} + if lhs._features != rhs._features {return false} + if lhs._verification != rhs._verification {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Google_Protobuf_ExtensionRangeOptions.VerificationState: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0DECLARATION\0\u{1}UNVERIFIED\0") +} + +extension Google_Protobuf_ExtensionRangeOptions.Declaration: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = Google_Protobuf_ExtensionRangeOptions.protoMessageName + ".Declaration" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}number\0\u{3}full_name\0\u{1}type\0\u{2}\u{2}reserved\0\u{1}repeated\0\u{c}\u{4}\u{1}") + + 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._number) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._fullName) }() + case 3: try { try decoder.decodeSingularStringField(value: &self._type) }() + case 5: try { try decoder.decodeSingularBoolField(value: &self._reserved) }() + case 6: try { try decoder.decodeSingularBoolField(value: &self._repeated) }() + 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 + try { if let v = self._number { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._fullName { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._type { + try visitor.visitSingularStringField(value: v, fieldNumber: 3) + } }() + try { if let v = self._reserved { + try visitor.visitSingularBoolField(value: v, fieldNumber: 5) + } }() + try { if let v = self._repeated { + try visitor.visitSingularBoolField(value: v, fieldNumber: 6) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_ExtensionRangeOptions.Declaration, rhs: Google_Protobuf_ExtensionRangeOptions.Declaration) -> Bool { + if lhs._number != rhs._number {return false} + if lhs._fullName != rhs._fullName {return false} + if lhs._type != rhs._type {return false} + if lhs._reserved != rhs._reserved {return false} + if lhs._repeated != rhs._repeated {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_FieldDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FieldDescriptorProto" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}extendee\0\u{1}number\0\u{1}label\0\u{1}type\0\u{3}type_name\0\u{3}default_value\0\u{1}options\0\u{3}oneof_index\0\u{3}json_name\0\u{4}\u{7}proto3_optional\0") + + public var isInitialized: Bool { + if let v = self._options, !v.isInitialized {return false} + return true + } + + 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._name) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._extendee) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._number) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._label) }() + case 5: try { try decoder.decodeSingularEnumField(value: &self._type) }() + case 6: try { try decoder.decodeSingularStringField(value: &self._typeName) }() + case 7: try { try decoder.decodeSingularStringField(value: &self._defaultValue) }() + case 8: try { try decoder.decodeSingularMessageField(value: &self._options) }() + case 9: try { try decoder.decodeSingularInt32Field(value: &self._oneofIndex) }() + case 10: try { try decoder.decodeSingularStringField(value: &self._jsonName) }() + case 17: try { try decoder.decodeSingularBoolField(value: &self._proto3Optional) }() + 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 + try { if let v = self._name { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = self._extendee { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._number { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._label { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + try { if let v = self._type { + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + } }() + try { if let v = self._typeName { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) + } }() + try { if let v = self._defaultValue { + try visitor.visitSingularStringField(value: v, fieldNumber: 7) + } }() + try { if let v = self._options { + try visitor.visitSingularMessageField(value: v, fieldNumber: 8) + } }() + try { if let v = self._oneofIndex { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try { if let v = self._jsonName { + try visitor.visitSingularStringField(value: v, fieldNumber: 10) + } }() + try { if let v = self._proto3Optional { + try visitor.visitSingularBoolField(value: v, fieldNumber: 17) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_FieldDescriptorProto, rhs: Google_Protobuf_FieldDescriptorProto) -> Bool { + if lhs._name != rhs._name {return false} + if lhs._number != rhs._number {return false} + if lhs._label != rhs._label {return false} + if lhs._type != rhs._type {return false} + if lhs._typeName != rhs._typeName {return false} + if lhs._extendee != rhs._extendee {return false} + if lhs._defaultValue != rhs._defaultValue {return false} + if lhs._oneofIndex != rhs._oneofIndex {return false} + if lhs._jsonName != rhs._jsonName {return false} + if lhs._options != rhs._options {return false} + if lhs._proto3Optional != rhs._proto3Optional {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_FieldDescriptorProto.TypeEnum: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}TYPE_DOUBLE\0\u{1}TYPE_FLOAT\0\u{1}TYPE_INT64\0\u{1}TYPE_UINT64\0\u{1}TYPE_INT32\0\u{1}TYPE_FIXED64\0\u{1}TYPE_FIXED32\0\u{1}TYPE_BOOL\0\u{1}TYPE_STRING\0\u{1}TYPE_GROUP\0\u{1}TYPE_MESSAGE\0\u{1}TYPE_BYTES\0\u{1}TYPE_UINT32\0\u{1}TYPE_ENUM\0\u{1}TYPE_SFIXED32\0\u{1}TYPE_SFIXED64\0\u{1}TYPE_SINT32\0\u{1}TYPE_SINT64\0") +} + +extension Google_Protobuf_FieldDescriptorProto.Label: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}LABEL_OPTIONAL\0\u{1}LABEL_REQUIRED\0\u{1}LABEL_REPEATED\0") +} + +extension Google_Protobuf_OneofDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OneofDescriptorProto" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}options\0") + + public var isInitialized: Bool { + if let v = self._options, !v.isInitialized {return false} + return true + } + + 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._name) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._options) }() + 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 + try { if let v = self._name { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = self._options { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_OneofDescriptorProto, rhs: Google_Protobuf_OneofDescriptorProto) -> Bool { + if lhs._name != rhs._name {return false} + if lhs._options != rhs._options {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_EnumDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumDescriptorProto" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}value\0\u{1}options\0\u{3}reserved_range\0\u{3}reserved_name\0\u{1}visibility\0") + + fileprivate class _StorageClass { + var _name: String? = nil + var _value: [Google_Protobuf_EnumValueDescriptorProto] = [] + var _options: Google_Protobuf_EnumOptions? = nil + var _reservedRange: [Google_Protobuf_EnumDescriptorProto.EnumReservedRange] = [] + var _reservedName: [String] = [] + var _visibility: Google_Protobuf_SymbolVisibility? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _name = source._name + _value = source._value + _options = source._options + _reservedRange = source._reservedRange + _reservedName = source._reservedName + _visibility = source._visibility + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if !Internal.areAllInitialized(_storage._value) {return false} + if let v = _storage._options, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._name) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &_storage._value) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._options) }() + case 4: try { try decoder.decodeRepeatedMessageField(value: &_storage._reservedRange) }() + case 5: try { try decoder.decodeRepeatedStringField(value: &_storage._reservedName) }() + case 6: try { try decoder.decodeSingularEnumField(value: &_storage._visibility) }() + default: break + } + } + } + } + + func traverse(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._name { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + if !_storage._value.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._value, fieldNumber: 2) + } + try { if let v = _storage._options { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + if !_storage._reservedRange.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._reservedRange, fieldNumber: 4) + } + if !_storage._reservedName.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._reservedName, fieldNumber: 5) + } + try { if let v = _storage._visibility { + try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_EnumDescriptorProto, rhs: Google_Protobuf_EnumDescriptorProto) -> 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._name != rhs_storage._name {return false} + if _storage._value != rhs_storage._value {return false} + if _storage._options != rhs_storage._options {return false} + if _storage._reservedRange != rhs_storage._reservedRange {return false} + if _storage._reservedName != rhs_storage._reservedName {return false} + if _storage._visibility != rhs_storage._visibility {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_EnumDescriptorProto.EnumReservedRange: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = Google_Protobuf_EnumDescriptorProto.protoMessageName + ".EnumReservedRange" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}start\0\u{1}end\0") + + 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._start) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._end) }() + 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 + try { if let v = self._start { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._end { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_EnumDescriptorProto.EnumReservedRange, rhs: Google_Protobuf_EnumDescriptorProto.EnumReservedRange) -> Bool { + if lhs._start != rhs._start {return false} + if lhs._end != rhs._end {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_EnumValueDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumValueDescriptorProto" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}number\0\u{1}options\0") + + fileprivate class _StorageClass { + var _name: String? = nil + var _number: Int32? = nil + var _options: Google_Protobuf_EnumValueOptions? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _name = source._name + _number = source._number + _options = source._options + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._options, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._name) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._number) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._options) }() + default: break + } + } + } + } + + func traverse(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._name { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._number { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._options { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_EnumValueDescriptorProto, rhs: Google_Protobuf_EnumValueDescriptorProto) -> 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._name != rhs_storage._name {return false} + if _storage._number != rhs_storage._number {return false} + if _storage._options != rhs_storage._options {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_ServiceDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ServiceDescriptorProto" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}method\0\u{1}options\0\u{b}stream\0\u{c}\u{4}\u{1}") + + public var isInitialized: Bool { + if !Internal.areAllInitialized(self.method) {return false} + if let v = self._options, !v.isInitialized {return false} + return true + } + + 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._name) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.method) }() + case 3: try { try decoder.decodeSingularMessageField(value: &self._options) }() + 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 + try { if let v = self._name { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + if !self.method.isEmpty { + try visitor.visitRepeatedMessageField(value: self.method, fieldNumber: 2) + } + try { if let v = self._options { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_ServiceDescriptorProto, rhs: Google_Protobuf_ServiceDescriptorProto) -> Bool { + if lhs._name != rhs._name {return false} + if lhs.method != rhs.method {return false} + if lhs._options != rhs._options {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_MethodDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MethodDescriptorProto" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{3}input_type\0\u{3}output_type\0\u{1}options\0\u{3}client_streaming\0\u{3}server_streaming\0") + + public var isInitialized: Bool { + if let v = self._options, !v.isInitialized {return false} + return true + } + + 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._name) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._inputType) }() + case 3: try { try decoder.decodeSingularStringField(value: &self._outputType) }() + case 4: try { try decoder.decodeSingularMessageField(value: &self._options) }() + case 5: try { try decoder.decodeSingularBoolField(value: &self._clientStreaming) }() + case 6: try { try decoder.decodeSingularBoolField(value: &self._serverStreaming) }() + 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 + try { if let v = self._name { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = self._inputType { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._outputType { + try visitor.visitSingularStringField(value: v, fieldNumber: 3) + } }() + try { if let v = self._options { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + try { if let v = self._clientStreaming { + try visitor.visitSingularBoolField(value: v, fieldNumber: 5) + } }() + try { if let v = self._serverStreaming { + try visitor.visitSingularBoolField(value: v, fieldNumber: 6) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_MethodDescriptorProto, rhs: Google_Protobuf_MethodDescriptorProto) -> Bool { + if lhs._name != rhs._name {return false} + if lhs._inputType != rhs._inputType {return false} + if lhs._outputType != rhs._outputType {return false} + if lhs._options != rhs._options {return false} + if lhs._clientStreaming != rhs._clientStreaming {return false} + if lhs._serverStreaming != rhs._serverStreaming {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_FileOptions: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FileOptions" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}java_package\0\u{4}\u{7}java_outer_classname\0\u{3}optimize_for\0\u{3}java_multiple_files\0\u{3}go_package\0\u{4}\u{5}cc_generic_services\0\u{3}java_generic_services\0\u{3}py_generic_services\0\u{4}\u{2}java_generate_equals_and_hash\0\u{2}\u{3}deprecated\0\u{4}\u{4}java_string_check_utf8\0\u{4}\u{4}cc_enable_arenas\0\u{4}\u{5}objc_class_prefix\0\u{3}csharp_namespace\0\u{4}\u{2}swift_prefix\0\u{3}php_class_prefix\0\u{3}php_namespace\0\u{4}\u{3}php_metadata_namespace\0\u{3}ruby_package\0\u{2}\u{5}features\0\u{4}u\u{e}uninterpreted_option\0\u{b}php_generic_services\0\u{c}*\u{1}\u{c}&\u{1}") + + fileprivate class _StorageClass { + var _javaPackage: String? = nil + var _javaOuterClassname: String? = nil + var _javaMultipleFiles: Bool? = nil + var _javaGenerateEqualsAndHash: Bool? = nil + var _javaStringCheckUtf8: Bool? = nil + var _optimizeFor: Google_Protobuf_FileOptions.OptimizeMode? = nil + var _goPackage: String? = nil + var _ccGenericServices: Bool? = nil + var _javaGenericServices: Bool? = nil + var _pyGenericServices: Bool? = nil + var _deprecated: Bool? = nil + var _ccEnableArenas: Bool? = nil + var _objcClassPrefix: String? = nil + var _csharpNamespace: String? = nil + var _swiftPrefix: String? = nil + var _phpClassPrefix: String? = nil + var _phpNamespace: String? = nil + var _phpMetadataNamespace: String? = nil + var _rubyPackage: String? = nil + var _features: Google_Protobuf_FeatureSet? = nil + var _uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _javaPackage = source._javaPackage + _javaOuterClassname = source._javaOuterClassname + _javaMultipleFiles = source._javaMultipleFiles + _javaGenerateEqualsAndHash = source._javaGenerateEqualsAndHash + _javaStringCheckUtf8 = source._javaStringCheckUtf8 + _optimizeFor = source._optimizeFor + _goPackage = source._goPackage + _ccGenericServices = source._ccGenericServices + _javaGenericServices = source._javaGenericServices + _pyGenericServices = source._pyGenericServices + _deprecated = source._deprecated + _ccEnableArenas = source._ccEnableArenas + _objcClassPrefix = source._objcClassPrefix + _csharpNamespace = source._csharpNamespace + _swiftPrefix = source._swiftPrefix + _phpClassPrefix = source._phpClassPrefix + _phpNamespace = source._phpNamespace + _phpMetadataNamespace = source._phpMetadataNamespace + _rubyPackage = source._rubyPackage + _features = source._features + _uninterpretedOption = source._uninterpretedOption + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(_storage._uninterpretedOption) {return false} + return true + } + } + + mutating func decodeMessage(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._javaPackage) }() + case 8: try { try decoder.decodeSingularStringField(value: &_storage._javaOuterClassname) }() + case 9: try { try decoder.decodeSingularEnumField(value: &_storage._optimizeFor) }() + case 10: try { try decoder.decodeSingularBoolField(value: &_storage._javaMultipleFiles) }() + case 11: try { try decoder.decodeSingularStringField(value: &_storage._goPackage) }() + case 16: try { try decoder.decodeSingularBoolField(value: &_storage._ccGenericServices) }() + case 17: try { try decoder.decodeSingularBoolField(value: &_storage._javaGenericServices) }() + case 18: try { try decoder.decodeSingularBoolField(value: &_storage._pyGenericServices) }() + case 20: try { try decoder.decodeSingularBoolField(value: &_storage._javaGenerateEqualsAndHash) }() + case 23: try { try decoder.decodeSingularBoolField(value: &_storage._deprecated) }() + case 27: try { try decoder.decodeSingularBoolField(value: &_storage._javaStringCheckUtf8) }() + case 31: try { try decoder.decodeSingularBoolField(value: &_storage._ccEnableArenas) }() + case 36: try { try decoder.decodeSingularStringField(value: &_storage._objcClassPrefix) }() + case 37: try { try decoder.decodeSingularStringField(value: &_storage._csharpNamespace) }() + case 39: try { try decoder.decodeSingularStringField(value: &_storage._swiftPrefix) }() + case 40: try { try decoder.decodeSingularStringField(value: &_storage._phpClassPrefix) }() + case 41: try { try decoder.decodeSingularStringField(value: &_storage._phpNamespace) }() + case 44: try { try decoder.decodeSingularStringField(value: &_storage._phpMetadataNamespace) }() + case 45: try { try decoder.decodeSingularStringField(value: &_storage._rubyPackage) }() + case 50: try { try decoder.decodeSingularMessageField(value: &_storage._features) }() + case 999: try { try decoder.decodeRepeatedMessageField(value: &_storage._uninterpretedOption) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_FileOptions.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._javaPackage { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._javaOuterClassname { + try visitor.visitSingularStringField(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._optimizeFor { + try visitor.visitSingularEnumField(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._javaMultipleFiles { + try visitor.visitSingularBoolField(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._goPackage { + try visitor.visitSingularStringField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._ccGenericServices { + try visitor.visitSingularBoolField(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._javaGenericServices { + try visitor.visitSingularBoolField(value: v, fieldNumber: 17) + } }() + try { if let v = _storage._pyGenericServices { + try visitor.visitSingularBoolField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._javaGenerateEqualsAndHash { + try visitor.visitSingularBoolField(value: v, fieldNumber: 20) + } }() + try { if let v = _storage._deprecated { + try visitor.visitSingularBoolField(value: v, fieldNumber: 23) + } }() + try { if let v = _storage._javaStringCheckUtf8 { + try visitor.visitSingularBoolField(value: v, fieldNumber: 27) + } }() + try { if let v = _storage._ccEnableArenas { + try visitor.visitSingularBoolField(value: v, fieldNumber: 31) + } }() + try { if let v = _storage._objcClassPrefix { + try visitor.visitSingularStringField(value: v, fieldNumber: 36) + } }() + try { if let v = _storage._csharpNamespace { + try visitor.visitSingularStringField(value: v, fieldNumber: 37) + } }() + try { if let v = _storage._swiftPrefix { + try visitor.visitSingularStringField(value: v, fieldNumber: 39) + } }() + try { if let v = _storage._phpClassPrefix { + try visitor.visitSingularStringField(value: v, fieldNumber: 40) + } }() + try { if let v = _storage._phpNamespace { + try visitor.visitSingularStringField(value: v, fieldNumber: 41) + } }() + try { if let v = _storage._phpMetadataNamespace { + try visitor.visitSingularStringField(value: v, fieldNumber: 44) + } }() + try { if let v = _storage._rubyPackage { + try visitor.visitSingularStringField(value: v, fieldNumber: 45) + } }() + try { if let v = _storage._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 50) + } }() + if !_storage._uninterpretedOption.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._uninterpretedOption, fieldNumber: 999) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_FileOptions, rhs: Google_Protobuf_FileOptions) -> 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._javaPackage != rhs_storage._javaPackage {return false} + if _storage._javaOuterClassname != rhs_storage._javaOuterClassname {return false} + if _storage._javaMultipleFiles != rhs_storage._javaMultipleFiles {return false} + if _storage._javaGenerateEqualsAndHash != rhs_storage._javaGenerateEqualsAndHash {return false} + if _storage._javaStringCheckUtf8 != rhs_storage._javaStringCheckUtf8 {return false} + if _storage._optimizeFor != rhs_storage._optimizeFor {return false} + if _storage._goPackage != rhs_storage._goPackage {return false} + if _storage._ccGenericServices != rhs_storage._ccGenericServices {return false} + if _storage._javaGenericServices != rhs_storage._javaGenericServices {return false} + if _storage._pyGenericServices != rhs_storage._pyGenericServices {return false} + if _storage._deprecated != rhs_storage._deprecated {return false} + if _storage._ccEnableArenas != rhs_storage._ccEnableArenas {return false} + if _storage._objcClassPrefix != rhs_storage._objcClassPrefix {return false} + if _storage._csharpNamespace != rhs_storage._csharpNamespace {return false} + if _storage._swiftPrefix != rhs_storage._swiftPrefix {return false} + if _storage._phpClassPrefix != rhs_storage._phpClassPrefix {return false} + if _storage._phpNamespace != rhs_storage._phpNamespace {return false} + if _storage._phpMetadataNamespace != rhs_storage._phpMetadataNamespace {return false} + if _storage._rubyPackage != rhs_storage._rubyPackage {return false} + if _storage._features != rhs_storage._features {return false} + if _storage._uninterpretedOption != rhs_storage._uninterpretedOption {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Google_Protobuf_FileOptions.OptimizeMode: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}SPEED\0\u{1}CODE_SIZE\0\u{1}LITE_RUNTIME\0") +} + +extension Google_Protobuf_MessageOptions: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MessageOptions" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}message_set_wire_format\0\u{3}no_standard_descriptor_accessor\0\u{1}deprecated\0\u{4}\u{4}map_entry\0\u{4}\u{4}deprecated_legacy_json_field_conflicts\0\u{1}features\0\u{4}[\u{f}uninterpreted_option\0\u{c}\u{4}\u{1}\u{c}\u{5}\u{1}\u{c}\u{6}\u{1}\u{c}\u{8}\u{1}\u{c}\u{9}\u{1}") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + if let v = self._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} + return true + } + + 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.decodeSingularBoolField(value: &self._messageSetWireFormat) }() + case 2: try { try decoder.decodeSingularBoolField(value: &self._noStandardDescriptorAccessor) }() + case 3: try { try decoder.decodeSingularBoolField(value: &self._deprecated) }() + case 7: try { try decoder.decodeSingularBoolField(value: &self._mapEntry) }() + case 11: try { try decoder.decodeSingularBoolField(value: &self._deprecatedLegacyJsonFieldConflicts) }() + case 12: try { try decoder.decodeSingularMessageField(value: &self._features) }() + case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_MessageOptions.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._messageSetWireFormat { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1) + } }() + try { if let v = self._noStandardDescriptorAccessor { + try visitor.visitSingularBoolField(value: v, fieldNumber: 2) + } }() + try { if let v = self._deprecated { + try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + } }() + try { if let v = self._mapEntry { + try visitor.visitSingularBoolField(value: v, fieldNumber: 7) + } }() + try { if let v = self._deprecatedLegacyJsonFieldConflicts { + try visitor.visitSingularBoolField(value: v, fieldNumber: 11) + } }() + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 12) + } }() + if !self.uninterpretedOption.isEmpty { + try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_MessageOptions, rhs: Google_Protobuf_MessageOptions) -> Bool { + if lhs._messageSetWireFormat != rhs._messageSetWireFormat {return false} + if lhs._noStandardDescriptorAccessor != rhs._noStandardDescriptorAccessor {return false} + if lhs._deprecated != rhs._deprecated {return false} + if lhs._mapEntry != rhs._mapEntry {return false} + if lhs._deprecatedLegacyJsonFieldConflicts != rhs._deprecatedLegacyJsonFieldConflicts {return false} + if lhs._features != rhs._features {return false} + if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Google_Protobuf_FieldOptions: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FieldOptions" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}ctype\0\u{1}packed\0\u{1}deprecated\0\u{2}\u{2}lazy\0\u{1}jstype\0\u{2}\u{4}weak\0\u{4}\u{5}unverified_lazy\0\u{3}debug_redact\0\u{1}retention\0\u{2}\u{2}targets\0\u{3}edition_defaults\0\u{1}features\0\u{3}feature_support\0\u{4}Q\u{f}uninterpreted_option\0\u{c}\u{4}\u{1}\u{c}\u{12}\u{1}") + + fileprivate class _StorageClass { + var _ctype: Google_Protobuf_FieldOptions.CType? = nil + var _packed: Bool? = nil + var _jstype: Google_Protobuf_FieldOptions.JSType? = nil + var _lazy: Bool? = nil + var _unverifiedLazy: Bool? = nil + var _deprecated: Bool? = nil + var _weak: Bool? = nil + var _debugRedact: Bool? = nil + var _retention: Google_Protobuf_FieldOptions.OptionRetention? = nil + var _targets: [Google_Protobuf_FieldOptions.OptionTargetType] = [] + var _editionDefaults: [Google_Protobuf_FieldOptions.EditionDefault] = [] + var _features: Google_Protobuf_FeatureSet? = nil + var _featureSupport: Google_Protobuf_FieldOptions.FeatureSupport? = nil + var _uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _ctype = source._ctype + _packed = source._packed + _jstype = source._jstype + _lazy = source._lazy + _unverifiedLazy = source._unverifiedLazy + _deprecated = source._deprecated + _weak = source._weak + _debugRedact = source._debugRedact + _retention = source._retention + _targets = source._targets + _editionDefaults = source._editionDefaults + _features = source._features + _featureSupport = source._featureSupport + _uninterpretedOption = source._uninterpretedOption + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(_storage._uninterpretedOption) {return false} + return true + } + } + + mutating func decodeMessage(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.decodeSingularEnumField(value: &_storage._ctype) }() + case 2: try { try decoder.decodeSingularBoolField(value: &_storage._packed) }() + case 3: try { try decoder.decodeSingularBoolField(value: &_storage._deprecated) }() + case 5: try { try decoder.decodeSingularBoolField(value: &_storage._lazy) }() + case 6: try { try decoder.decodeSingularEnumField(value: &_storage._jstype) }() + case 10: try { try decoder.decodeSingularBoolField(value: &_storage._weak) }() + case 15: try { try decoder.decodeSingularBoolField(value: &_storage._unverifiedLazy) }() + case 16: try { try decoder.decodeSingularBoolField(value: &_storage._debugRedact) }() + case 17: try { try decoder.decodeSingularEnumField(value: &_storage._retention) }() + case 19: try { try decoder.decodeRepeatedEnumField(value: &_storage._targets) }() + case 20: try { try decoder.decodeRepeatedMessageField(value: &_storage._editionDefaults) }() + case 21: try { try decoder.decodeSingularMessageField(value: &_storage._features) }() + case 22: try { try decoder.decodeSingularMessageField(value: &_storage._featureSupport) }() + case 999: try { try decoder.decodeRepeatedMessageField(value: &_storage._uninterpretedOption) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_FieldOptions.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._ctype { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._packed { + try visitor.visitSingularBoolField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._deprecated { + try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._lazy { + try visitor.visitSingularBoolField(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._jstype { + try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._weak { + try visitor.visitSingularBoolField(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._unverifiedLazy { + try visitor.visitSingularBoolField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._debugRedact { + try visitor.visitSingularBoolField(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._retention { + try visitor.visitSingularEnumField(value: v, fieldNumber: 17) + } }() + if !_storage._targets.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._targets, fieldNumber: 19) + } + if !_storage._editionDefaults.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._editionDefaults, fieldNumber: 20) + } + try { if let v = _storage._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._featureSupport { + try visitor.visitSingularMessageField(value: v, fieldNumber: 22) + } }() + if !_storage._uninterpretedOption.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._uninterpretedOption, fieldNumber: 999) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_FieldOptions, rhs: Google_Protobuf_FieldOptions) -> 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._ctype != rhs_storage._ctype {return false} + if _storage._packed != rhs_storage._packed {return false} + if _storage._jstype != rhs_storage._jstype {return false} + if _storage._lazy != rhs_storage._lazy {return false} + if _storage._unverifiedLazy != rhs_storage._unverifiedLazy {return false} + if _storage._deprecated != rhs_storage._deprecated {return false} + if _storage._weak != rhs_storage._weak {return false} + if _storage._debugRedact != rhs_storage._debugRedact {return false} + if _storage._retention != rhs_storage._retention {return false} + if _storage._targets != rhs_storage._targets {return false} + if _storage._editionDefaults != rhs_storage._editionDefaults {return false} + if _storage._features != rhs_storage._features {return false} + if _storage._featureSupport != rhs_storage._featureSupport {return false} + if _storage._uninterpretedOption != rhs_storage._uninterpretedOption {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Google_Protobuf_FieldOptions.CType: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0STRING\0\u{1}CORD\0\u{1}STRING_PIECE\0") +} + +extension Google_Protobuf_FieldOptions.JSType: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0JS_NORMAL\0\u{1}JS_STRING\0\u{1}JS_NUMBER\0") +} + +extension Google_Protobuf_FieldOptions.OptionRetention: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0RETENTION_UNKNOWN\0\u{1}RETENTION_RUNTIME\0\u{1}RETENTION_SOURCE\0") +} + +extension Google_Protobuf_FieldOptions.OptionTargetType: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0TARGET_TYPE_UNKNOWN\0\u{1}TARGET_TYPE_FILE\0\u{1}TARGET_TYPE_EXTENSION_RANGE\0\u{1}TARGET_TYPE_MESSAGE\0\u{1}TARGET_TYPE_FIELD\0\u{1}TARGET_TYPE_ONEOF\0\u{1}TARGET_TYPE_ENUM\0\u{1}TARGET_TYPE_ENUM_ENTRY\0\u{1}TARGET_TYPE_SERVICE\0\u{1}TARGET_TYPE_METHOD\0") +} + +extension Google_Protobuf_FieldOptions.EditionDefault: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = Google_Protobuf_FieldOptions.protoMessageName + ".EditionDefault" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\u{2}value\0\u{1}edition\0") + + 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 2: try { try decoder.decodeSingularStringField(value: &self._value) }() + case 3: try { try decoder.decodeSingularEnumField(value: &self._edition) }() + 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 + try { if let v = self._value { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._edition { + try visitor.visitSingularEnumField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_FieldOptions.EditionDefault, rhs: Google_Protobuf_FieldOptions.EditionDefault) -> Bool { + if lhs._edition != rhs._edition {return false} + if lhs._value != rhs._value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_FieldOptions.FeatureSupport: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = Google_Protobuf_FieldOptions.protoMessageName + ".FeatureSupport" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}edition_introduced\0\u{3}edition_deprecated\0\u{3}deprecation_warning\0\u{3}edition_removed\0\u{3}removal_error\0") + + 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._editionIntroduced) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self._editionDeprecated) }() + case 3: try { try decoder.decodeSingularStringField(value: &self._deprecationWarning) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._editionRemoved) }() + case 5: try { try decoder.decodeSingularStringField(value: &self._removalError) }() + 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 + try { if let v = self._editionIntroduced { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = self._editionDeprecated { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) + } }() + try { if let v = self._deprecationWarning { + try visitor.visitSingularStringField(value: v, fieldNumber: 3) + } }() + try { if let v = self._editionRemoved { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + try { if let v = self._removalError { + try visitor.visitSingularStringField(value: v, fieldNumber: 5) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_FieldOptions.FeatureSupport, rhs: Google_Protobuf_FieldOptions.FeatureSupport) -> Bool { + if lhs._editionIntroduced != rhs._editionIntroduced {return false} + if lhs._editionDeprecated != rhs._editionDeprecated {return false} + if lhs._deprecationWarning != rhs._deprecationWarning {return false} + if lhs._editionRemoved != rhs._editionRemoved {return false} + if lhs._removalError != rhs._removalError {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_OneofOptions: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OneofOptions" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}features\0\u{4}f\u{f}uninterpreted_option\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + if let v = self._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._features) }() + case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_OneofOptions.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + if !self.uninterpretedOption.isEmpty { + try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_OneofOptions, rhs: Google_Protobuf_OneofOptions) -> Bool { + if lhs._features != rhs._features {return false} + if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Google_Protobuf_EnumOptions: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumOptions" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{4}\u{2}allow_alias\0\u{1}deprecated\0\u{4}\u{3}deprecated_legacy_json_field_conflicts\0\u{1}features\0\u{4}`\u{f}uninterpreted_option\0\u{c}\u{5}\u{1}") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + if let v = self._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} + return true + } + + 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 2: try { try decoder.decodeSingularBoolField(value: &self._allowAlias) }() + case 3: try { try decoder.decodeSingularBoolField(value: &self._deprecated) }() + case 6: try { try decoder.decodeSingularBoolField(value: &self._deprecatedLegacyJsonFieldConflicts) }() + case 7: try { try decoder.decodeSingularMessageField(value: &self._features) }() + case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_EnumOptions.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._allowAlias { + try visitor.visitSingularBoolField(value: v, fieldNumber: 2) + } }() + try { if let v = self._deprecated { + try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + } }() + try { if let v = self._deprecatedLegacyJsonFieldConflicts { + try visitor.visitSingularBoolField(value: v, fieldNumber: 6) + } }() + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 7) + } }() + if !self.uninterpretedOption.isEmpty { + try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_EnumOptions, rhs: Google_Protobuf_EnumOptions) -> Bool { + if lhs._allowAlias != rhs._allowAlias {return false} + if lhs._deprecated != rhs._deprecated {return false} + if lhs._deprecatedLegacyJsonFieldConflicts != rhs._deprecatedLegacyJsonFieldConflicts {return false} + if lhs._features != rhs._features {return false} + if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Google_Protobuf_EnumValueOptions: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumValueOptions" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}deprecated\0\u{1}features\0\u{3}debug_redact\0\u{3}feature_support\0\u{4}c\u{f}uninterpreted_option\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + if let v = self._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} + return true + } + + 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.decodeSingularBoolField(value: &self._deprecated) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._features) }() + case 3: try { try decoder.decodeSingularBoolField(value: &self._debugRedact) }() + case 4: try { try decoder.decodeSingularMessageField(value: &self._featureSupport) }() + case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_EnumValueOptions.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._deprecated { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1) + } }() + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = self._debugRedact { + try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + } }() + try { if let v = self._featureSupport { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + if !self.uninterpretedOption.isEmpty { + try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_EnumValueOptions, rhs: Google_Protobuf_EnumValueOptions) -> Bool { + if lhs._deprecated != rhs._deprecated {return false} + if lhs._features != rhs._features {return false} + if lhs._debugRedact != rhs._debugRedact {return false} + if lhs._featureSupport != rhs._featureSupport {return false} + if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Google_Protobuf_ServiceOptions: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ServiceOptions" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}!deprecated\0\u{1}features\0\u{4}E\u{f}uninterpreted_option\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + if let v = self._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} + return true + } + + 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 33: try { try decoder.decodeSingularBoolField(value: &self._deprecated) }() + case 34: try { try decoder.decodeSingularMessageField(value: &self._features) }() + case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_ServiceOptions.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._deprecated { + try visitor.visitSingularBoolField(value: v, fieldNumber: 33) + } }() + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 34) + } }() + if !self.uninterpretedOption.isEmpty { + try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_ServiceOptions, rhs: Google_Protobuf_ServiceOptions) -> Bool { + if lhs._features != rhs._features {return false} + if lhs._deprecated != rhs._deprecated {return false} + if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Google_Protobuf_MethodOptions: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MethodOptions" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}!deprecated\0\u{3}idempotency_level\0\u{1}features\0\u{4}D\u{f}uninterpreted_option\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + if let v = self._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} + return true + } + + 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 33: try { try decoder.decodeSingularBoolField(value: &self._deprecated) }() + case 34: try { try decoder.decodeSingularEnumField(value: &self._idempotencyLevel) }() + case 35: try { try decoder.decodeSingularMessageField(value: &self._features) }() + case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_MethodOptions.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._deprecated { + try visitor.visitSingularBoolField(value: v, fieldNumber: 33) + } }() + try { if let v = self._idempotencyLevel { + try visitor.visitSingularEnumField(value: v, fieldNumber: 34) + } }() + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 35) + } }() + if !self.uninterpretedOption.isEmpty { + try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_MethodOptions, rhs: Google_Protobuf_MethodOptions) -> Bool { + if lhs._deprecated != rhs._deprecated {return false} + if lhs._idempotencyLevel != rhs._idempotencyLevel {return false} + if lhs._features != rhs._features {return false} + if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Google_Protobuf_MethodOptions.IdempotencyLevel: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0IDEMPOTENCY_UNKNOWN\0\u{1}NO_SIDE_EFFECTS\0\u{1}IDEMPOTENT\0") +} + +extension Google_Protobuf_UninterpretedOption: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".UninterpretedOption" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\u{2}name\0\u{3}identifier_value\0\u{3}positive_int_value\0\u{3}negative_int_value\0\u{3}double_value\0\u{3}string_value\0\u{3}aggregate_value\0") + + public var isInitialized: Bool { + if !Internal.areAllInitialized(self.name) {return false} + return true + } + + 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 2: try { try decoder.decodeRepeatedMessageField(value: &self.name) }() + case 3: try { try decoder.decodeSingularStringField(value: &self._identifierValue) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &self._positiveIntValue) }() + case 5: try { try decoder.decodeSingularInt64Field(value: &self._negativeIntValue) }() + case 6: try { try decoder.decodeSingularDoubleField(value: &self._doubleValue) }() + case 7: try { try decoder.decodeSingularBytesField(value: &self._stringValue) }() + case 8: try { try decoder.decodeSingularStringField(value: &self._aggregateValue) }() + 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 + if !self.name.isEmpty { + try visitor.visitRepeatedMessageField(value: self.name, fieldNumber: 2) + } + try { if let v = self._identifierValue { + try visitor.visitSingularStringField(value: v, fieldNumber: 3) + } }() + try { if let v = self._positiveIntValue { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = self._negativeIntValue { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 5) + } }() + try { if let v = self._doubleValue { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 6) + } }() + try { if let v = self._stringValue { + try visitor.visitSingularBytesField(value: v, fieldNumber: 7) + } }() + try { if let v = self._aggregateValue { + try visitor.visitSingularStringField(value: v, fieldNumber: 8) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_UninterpretedOption, rhs: Google_Protobuf_UninterpretedOption) -> Bool { + if lhs.name != rhs.name {return false} + if lhs._identifierValue != rhs._identifierValue {return false} + if lhs._positiveIntValue != rhs._positiveIntValue {return false} + if lhs._negativeIntValue != rhs._negativeIntValue {return false} + if lhs._doubleValue != rhs._doubleValue {return false} + if lhs._stringValue != rhs._stringValue {return false} + if lhs._aggregateValue != rhs._aggregateValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_UninterpretedOption.NamePart: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = Google_Protobuf_UninterpretedOption.protoMessageName + ".NamePart" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}name_part\0\u{3}is_extension\0") + + public var isInitialized: Bool { + if self._namePart == nil {return false} + if self._isExtension == nil {return false} + return true + } + + 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._namePart) }() + case 2: try { try decoder.decodeSingularBoolField(value: &self._isExtension) }() + 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 + try { if let v = self._namePart { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = self._isExtension { + try visitor.visitSingularBoolField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_UninterpretedOption.NamePart, rhs: Google_Protobuf_UninterpretedOption.NamePart) -> Bool { + if lhs._namePart != rhs._namePart {return false} + if lhs._isExtension != rhs._isExtension {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_FeatureSet: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FeatureSet" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}field_presence\0\u{3}enum_type\0\u{3}repeated_field_encoding\0\u{3}utf8_validation\0\u{3}message_encoding\0\u{3}json_format\0\u{3}enforce_naming_style\0\u{3}default_symbol_visibility\0\u{c}g\u{f}\u{1}") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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._fieldPresence) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self._enumType) }() + case 3: try { try decoder.decodeSingularEnumField(value: &self._repeatedFieldEncoding) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._utf8Validation) }() + case 5: try { try decoder.decodeSingularEnumField(value: &self._messageEncoding) }() + case 6: try { try decoder.decodeSingularEnumField(value: &self._jsonFormat) }() + case 7: try { try decoder.decodeSingularEnumField(value: &self._enforceNamingStyle) }() + case 8: try { try decoder.decodeSingularEnumField(value: &self._defaultSymbolVisibility) }() + case 1000..<10001: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_FeatureSet.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._fieldPresence { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = self._enumType { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) + } }() + try { if let v = self._repeatedFieldEncoding { + try visitor.visitSingularEnumField(value: v, fieldNumber: 3) + } }() + try { if let v = self._utf8Validation { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + try { if let v = self._messageEncoding { + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + } }() + try { if let v = self._jsonFormat { + try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + } }() + try { if let v = self._enforceNamingStyle { + try visitor.visitSingularEnumField(value: v, fieldNumber: 7) + } }() + try { if let v = self._defaultSymbolVisibility { + try visitor.visitSingularEnumField(value: v, fieldNumber: 8) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 10001) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_FeatureSet, rhs: Google_Protobuf_FeatureSet) -> Bool { + if lhs._fieldPresence != rhs._fieldPresence {return false} + if lhs._enumType != rhs._enumType {return false} + if lhs._repeatedFieldEncoding != rhs._repeatedFieldEncoding {return false} + if lhs._utf8Validation != rhs._utf8Validation {return false} + if lhs._messageEncoding != rhs._messageEncoding {return false} + if lhs._jsonFormat != rhs._jsonFormat {return false} + if lhs._enforceNamingStyle != rhs._enforceNamingStyle {return false} + if lhs._defaultSymbolVisibility != rhs._defaultSymbolVisibility {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Google_Protobuf_FeatureSet.FieldPresence: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0FIELD_PRESENCE_UNKNOWN\0\u{1}EXPLICIT\0\u{1}IMPLICIT\0\u{1}LEGACY_REQUIRED\0") +} + +extension Google_Protobuf_FeatureSet.EnumType: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0ENUM_TYPE_UNKNOWN\0\u{1}OPEN\0\u{1}CLOSED\0") +} + +extension Google_Protobuf_FeatureSet.RepeatedFieldEncoding: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0REPEATED_FIELD_ENCODING_UNKNOWN\0\u{1}PACKED\0\u{1}EXPANDED\0") +} + +extension Google_Protobuf_FeatureSet.Utf8Validation: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0UTF8_VALIDATION_UNKNOWN\0\u{2}\u{2}VERIFY\0\u{1}NONE\0") +} + +extension Google_Protobuf_FeatureSet.MessageEncoding: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0MESSAGE_ENCODING_UNKNOWN\0\u{1}LENGTH_PREFIXED\0\u{1}DELIMITED\0") +} + +extension Google_Protobuf_FeatureSet.JsonFormat: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0JSON_FORMAT_UNKNOWN\0\u{1}ALLOW\0\u{1}LEGACY_BEST_EFFORT\0") +} + +extension Google_Protobuf_FeatureSet.EnforceNamingStyle: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0ENFORCE_NAMING_STYLE_UNKNOWN\0\u{1}STYLE2024\0\u{1}STYLE_LEGACY\0") +} + +extension Google_Protobuf_FeatureSet.VisibilityFeature: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = Google_Protobuf_FeatureSet.protoMessageName + ".VisibilityFeature" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{c}\u{1}\u{7f}\u{7f}\u{7f}\u{7f}\u{1f}") + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_FeatureSet.VisibilityFeature, rhs: Google_Protobuf_FeatureSet.VisibilityFeature) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_FeatureSet.VisibilityFeature.DefaultSymbolVisibility: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0DEFAULT_SYMBOL_VISIBILITY_UNKNOWN\0\u{1}EXPORT_ALL\0\u{1}EXPORT_TOP_LEVEL\0\u{1}LOCAL_ALL\0\u{1}STRICT\0") +} + +extension Google_Protobuf_FeatureSetDefaults: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FeatureSetDefaults" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}defaults\0\u{4}\u{3}minimum_edition\0\u{3}maximum_edition\0") + + public var isInitialized: Bool { + if !Internal.areAllInitialized(self.defaults) {return false} + return true + } + + 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.decodeRepeatedMessageField(value: &self.defaults) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._minimumEdition) }() + case 5: try { try decoder.decodeSingularEnumField(value: &self._maximumEdition) }() + 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 + if !self.defaults.isEmpty { + try visitor.visitRepeatedMessageField(value: self.defaults, fieldNumber: 1) + } + try { if let v = self._minimumEdition { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + try { if let v = self._maximumEdition { + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_FeatureSetDefaults, rhs: Google_Protobuf_FeatureSetDefaults) -> Bool { + if lhs.defaults != rhs.defaults {return false} + if lhs._minimumEdition != rhs._minimumEdition {return false} + if lhs._maximumEdition != rhs._maximumEdition {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_FeatureSetDefaults.FeatureSetEditionDefault: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = Google_Protobuf_FeatureSetDefaults.protoMessageName + ".FeatureSetEditionDefault" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\u{3}edition\0\u{3}overridable_features\0\u{3}fixed_features\0\u{b}features\0\u{c}\u{1}\u{1}\u{c}\u{2}\u{1}") + + fileprivate class _StorageClass { + var _edition: Google_Protobuf_Edition? = nil + var _overridableFeatures: Google_Protobuf_FeatureSet? = nil + var _fixedFeatures: Google_Protobuf_FeatureSet? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _edition = source._edition + _overridableFeatures = source._overridableFeatures + _fixedFeatures = source._fixedFeatures + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._overridableFeatures, !v.isInitialized {return false} + if let v = _storage._fixedFeatures, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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 3: try { try decoder.decodeSingularEnumField(value: &_storage._edition) }() + case 4: try { try decoder.decodeSingularMessageField(value: &_storage._overridableFeatures) }() + case 5: try { try decoder.decodeSingularMessageField(value: &_storage._fixedFeatures) }() + default: break + } + } + } + } + + func traverse(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._edition { + try visitor.visitSingularEnumField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._overridableFeatures { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._fixedFeatures { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_FeatureSetDefaults.FeatureSetEditionDefault, rhs: Google_Protobuf_FeatureSetDefaults.FeatureSetEditionDefault) -> 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._edition != rhs_storage._edition {return false} + if _storage._overridableFeatures != rhs_storage._overridableFeatures {return false} + if _storage._fixedFeatures != rhs_storage._fixedFeatures {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_SourceCodeInfo: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".SourceCodeInfo" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}location\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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.decodeRepeatedMessageField(value: &self.location) }() + case 536000000: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_SourceCodeInfo.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.location.isEmpty { + try visitor.visitRepeatedMessageField(value: self.location, fieldNumber: 1) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 536000000, end: 536000001) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_SourceCodeInfo, rhs: Google_Protobuf_SourceCodeInfo) -> Bool { + if lhs.location != rhs.location {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Google_Protobuf_SourceCodeInfo.Location: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = Google_Protobuf_SourceCodeInfo.protoMessageName + ".Location" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}path\0\u{1}span\0\u{3}leading_comments\0\u{3}trailing_comments\0\u{4}\u{2}leading_detached_comments\0") + + 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.decodeRepeatedInt32Field(value: &self.path) }() + case 2: try { try decoder.decodeRepeatedInt32Field(value: &self.span) }() + case 3: try { try decoder.decodeSingularStringField(value: &self._leadingComments) }() + case 4: try { try decoder.decodeSingularStringField(value: &self._trailingComments) }() + case 6: try { try decoder.decodeRepeatedStringField(value: &self.leadingDetachedComments) }() + 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 + if !self.path.isEmpty { + try visitor.visitPackedInt32Field(value: self.path, fieldNumber: 1) + } + if !self.span.isEmpty { + try visitor.visitPackedInt32Field(value: self.span, fieldNumber: 2) + } + try { if let v = self._leadingComments { + try visitor.visitSingularStringField(value: v, fieldNumber: 3) + } }() + try { if let v = self._trailingComments { + try visitor.visitSingularStringField(value: v, fieldNumber: 4) + } }() + if !self.leadingDetachedComments.isEmpty { + try visitor.visitRepeatedStringField(value: self.leadingDetachedComments, fieldNumber: 6) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_SourceCodeInfo.Location, rhs: Google_Protobuf_SourceCodeInfo.Location) -> Bool { + if lhs.path != rhs.path {return false} + if lhs.span != rhs.span {return false} + if lhs._leadingComments != rhs._leadingComments {return false} + if lhs._trailingComments != rhs._trailingComments {return false} + if lhs.leadingDetachedComments != rhs.leadingDetachedComments {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_GeneratedCodeInfo: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GeneratedCodeInfo" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}annotation\0") + + 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.decodeRepeatedMessageField(value: &self.annotation) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.annotation.isEmpty { + try visitor.visitRepeatedMessageField(value: self.annotation, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_GeneratedCodeInfo, rhs: Google_Protobuf_GeneratedCodeInfo) -> Bool { + if lhs.annotation != rhs.annotation {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_GeneratedCodeInfo.Annotation: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = Google_Protobuf_GeneratedCodeInfo.protoMessageName + ".Annotation" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}path\0\u{3}source_file\0\u{1}begin\0\u{1}end\0\u{1}semantic\0") + + 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.decodeRepeatedInt32Field(value: &self.path) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._sourceFile) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._begin) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &self._end) }() + case 5: try { try decoder.decodeSingularEnumField(value: &self._semantic) }() + 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 + if !self.path.isEmpty { + try visitor.visitPackedInt32Field(value: self.path, fieldNumber: 1) + } + try { if let v = self._sourceFile { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._begin { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._end { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try { if let v = self._semantic { + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_GeneratedCodeInfo.Annotation, rhs: Google_Protobuf_GeneratedCodeInfo.Annotation) -> Bool { + if lhs.path != rhs.path {return false} + if lhs._sourceFile != rhs._sourceFile {return false} + if lhs._begin != rhs._begin {return false} + if lhs._end != rhs._end {return false} + if lhs._semantic != rhs._semantic {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_GeneratedCodeInfo.Annotation.Semantic: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0NONE\0\u{1}SET\0\u{1}ALIAS\0") +} diff --git a/Reference/upstream/google/protobuf/duration.pb.swift b/Reference/upstream/google/protobuf/duration.pb.swift new file mode 100644 index 000000000..8bf22e67c --- /dev/null +++ b/Reference/upstream/google/protobuf/duration.pb.swift @@ -0,0 +1,171 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/duration.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. + +// 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: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// A Duration represents a signed, fixed-length span of time represented +/// as a count of seconds and fractions of seconds at nanosecond +/// resolution. It is independent of any calendar and concepts like "day" +/// or "month". It is related to Timestamp in that the difference between +/// two Timestamp values is a Duration and it can be added or subtracted +/// from a Timestamp. Range is approximately +-10,000 years. +/// +/// # Examples +/// +/// Example 1: Compute Duration from two Timestamps in pseudo code. +/// +/// Timestamp start = ...; +/// Timestamp end = ...; +/// Duration duration = ...; +/// +/// duration.seconds = end.seconds - start.seconds; +/// duration.nanos = end.nanos - start.nanos; +/// +/// if (duration.seconds < 0 && duration.nanos > 0) { +/// duration.seconds += 1; +/// duration.nanos -= 1000000000; +/// } else if (duration.seconds > 0 && duration.nanos < 0) { +/// duration.seconds -= 1; +/// duration.nanos += 1000000000; +/// } +/// +/// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. +/// +/// Timestamp start = ...; +/// Duration duration = ...; +/// Timestamp end = ...; +/// +/// end.seconds = start.seconds + duration.seconds; +/// end.nanos = start.nanos + duration.nanos; +/// +/// if (end.nanos < 0) { +/// end.seconds -= 1; +/// end.nanos += 1000000000; +/// } else if (end.nanos >= 1000000000) { +/// end.seconds += 1; +/// end.nanos -= 1000000000; +/// } +/// +/// Example 3: Compute Duration from datetime.timedelta in Python. +/// +/// td = datetime.timedelta(days=3, minutes=10) +/// duration = Duration() +/// duration.FromTimedelta(td) +/// +/// # JSON Mapping +/// +/// In JSON format, the Duration type is encoded as a string rather than an +/// object, where the string ends in the suffix "s" (indicating seconds) and +/// is preceded by the number of seconds, with nanoseconds expressed as +/// fractional seconds. For example, 3 seconds with 0 nanoseconds should be +/// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should +/// be expressed in JSON format as "3.000000001s", and 3 seconds and 1 +/// microsecond should be expressed in JSON format as "3.000001s". +struct Google_Protobuf_Duration: Sendable { + // 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. + + /// Signed seconds of the span of time. Must be from -315,576,000,000 + /// to +315,576,000,000 inclusive. Note: these bounds are computed from: + /// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years + var seconds: Int64 = 0 + + /// Signed fractions of a second at nanosecond resolution of the span + /// of time. Durations less than one second are represented with a 0 + /// `seconds` field and a positive or negative `nanos` field. For durations + /// of one second or more, a non-zero value for the `nanos` field must be + /// of the same sign as the `seconds` field. Must be from -999,999,999 + /// to +999,999,999 inclusive. + var nanos: Int32 = 0 + + var unknownFields = UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "google.protobuf" + +extension Google_Protobuf_Duration: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Duration" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}seconds\0\u{1}nanos\0") + + 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.decodeSingularInt64Field(value: &self.seconds) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self.nanos) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.seconds != 0 { + try visitor.visitSingularInt64Field(value: self.seconds, fieldNumber: 1) + } + if self.nanos != 0 { + try visitor.visitSingularInt32Field(value: self.nanos, fieldNumber: 2) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_Duration, rhs: Google_Protobuf_Duration) -> Bool { + if lhs.seconds != rhs.seconds {return false} + if lhs.nanos != rhs.nanos {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/edition_unittest.pb.swift b/Reference/upstream/google/protobuf/edition_unittest.pb.swift new file mode 100644 index 000000000..e0f8ba37a --- /dev/null +++ b/Reference/upstream/google/protobuf/edition_unittest.pb.swift @@ -0,0 +1,19034 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/edition_unittest.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// A proto file we will use for unit testing. See comments in +// edition_message_unittest.cc before adding new features. +// +// LINT: ALLOW_GROUPS, LEGACY_NAMES + +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 EditionUnittest_ForeignEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foreignFoo = 4 + case foreignBar = 5 + case foreignBaz = 6 + + /// (1 << 32) to generate a 64b bitmask would be incorrect. + case foreignBax = 32 + + init() { + self = .foreignFoo + } + +} + +enum EditionUnittest_TestReservedEnumFields: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unknown = 0 + + init() { + self = .unknown + } + +} + +/// Test an enum that has multiple values with the same number. +enum EditionUnittest_TestEnumWithDupValue: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case dupUnknown1 = 0 + case dupFoo1 = 1 + case dupBar1 = 2 + case dupBaz = 3 + static let dupUnknown2 = dupUnknown1 + static let dupFoo2 = dupFoo1 + static let dupBar2 = dupBar1 + + init() { + self = .dupUnknown1 + } + +} + +/// Test an enum with large, unordered values. +enum EditionUnittest_TestSparseEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case sparseA = 123 + case sparseB = 62374 + case sparseC = 12589234 + case sparseD = -15 + case sparseE = -53452 + case sparseF = 0 + case sparseG = 2 + + init() { + self = .sparseA + } + +} + +enum EditionUnittest_VeryLargeEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case enumLabelDefault = 0 + case enumLabel1 = 1 + case enumLabel2 = 2 + case enumLabel3 = 3 + case enumLabel4 = 4 + case enumLabel5 = 5 + case enumLabel6 = 6 + case enumLabel7 = 7 + case enumLabel8 = 8 + case enumLabel9 = 9 + case enumLabel10 = 10 + case enumLabel11 = 11 + case enumLabel12 = 12 + case enumLabel13 = 13 + case enumLabel14 = 14 + case enumLabel15 = 15 + case enumLabel16 = 16 + case enumLabel17 = 17 + case enumLabel18 = 18 + case enumLabel19 = 19 + case enumLabel20 = 20 + case enumLabel21 = 21 + case enumLabel22 = 22 + case enumLabel23 = 23 + case enumLabel24 = 24 + case enumLabel25 = 25 + case enumLabel26 = 26 + case enumLabel27 = 27 + case enumLabel28 = 28 + case enumLabel29 = 29 + case enumLabel30 = 30 + case enumLabel31 = 31 + case enumLabel32 = 32 + case enumLabel33 = 33 + case enumLabel34 = 34 + case enumLabel35 = 35 + case enumLabel36 = 36 + case enumLabel37 = 37 + case enumLabel38 = 38 + case enumLabel39 = 39 + case enumLabel40 = 40 + case enumLabel41 = 41 + case enumLabel42 = 42 + case enumLabel43 = 43 + case enumLabel44 = 44 + case enumLabel45 = 45 + case enumLabel46 = 46 + case enumLabel47 = 47 + case enumLabel48 = 48 + case enumLabel49 = 49 + case enumLabel50 = 50 + case enumLabel51 = 51 + case enumLabel52 = 52 + case enumLabel53 = 53 + case enumLabel54 = 54 + case enumLabel55 = 55 + case enumLabel56 = 56 + case enumLabel57 = 57 + case enumLabel58 = 58 + case enumLabel59 = 59 + case enumLabel60 = 60 + case enumLabel61 = 61 + case enumLabel62 = 62 + case enumLabel63 = 63 + case enumLabel64 = 64 + case enumLabel65 = 65 + case enumLabel66 = 66 + case enumLabel67 = 67 + case enumLabel68 = 68 + case enumLabel69 = 69 + case enumLabel70 = 70 + case enumLabel71 = 71 + case enumLabel72 = 72 + case enumLabel73 = 73 + case enumLabel74 = 74 + case enumLabel75 = 75 + case enumLabel76 = 76 + case enumLabel77 = 77 + case enumLabel78 = 78 + case enumLabel79 = 79 + case enumLabel80 = 80 + case enumLabel81 = 81 + case enumLabel82 = 82 + case enumLabel83 = 83 + case enumLabel84 = 84 + case enumLabel85 = 85 + case enumLabel86 = 86 + case enumLabel87 = 87 + case enumLabel88 = 88 + case enumLabel89 = 89 + case enumLabel90 = 90 + case enumLabel91 = 91 + case enumLabel92 = 92 + case enumLabel93 = 93 + case enumLabel94 = 94 + case enumLabel95 = 95 + case enumLabel96 = 96 + case enumLabel97 = 97 + case enumLabel98 = 98 + case enumLabel99 = 99 + case enumLabel100 = 100 + + init() { + self = .enumLabelDefault + } + +} + +/// This proto includes every type of field in both singular and repeated +/// forms. +struct EditionUnittest_TestAllTypes: @unchecked Sendable { + // 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. + + /// Singular + var optionalInt32: Int32 { + get {_storage._optionalInt32 ?? 0} + set {_uniqueStorage()._optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} + + var optionalInt64: Int64 { + get {_storage._optionalInt64 ?? 0} + set {_uniqueStorage()._optionalInt64 = newValue} + } + /// Returns true if `optionalInt64` has been explicitly set. + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} + /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} + + var optionalUint32: UInt32 { + get {_storage._optionalUint32 ?? 0} + set {_uniqueStorage()._optionalUint32 = newValue} + } + /// Returns true if `optionalUint32` has been explicitly set. + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} + /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} + + var optionalUint64: UInt64 { + get {_storage._optionalUint64 ?? 0} + set {_uniqueStorage()._optionalUint64 = newValue} + } + /// Returns true if `optionalUint64` has been explicitly set. + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} + /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} + + var optionalSint32: Int32 { + get {_storage._optionalSint32 ?? 0} + set {_uniqueStorage()._optionalSint32 = newValue} + } + /// Returns true if `optionalSint32` has been explicitly set. + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} + /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} + + var optionalSint64: Int64 { + get {_storage._optionalSint64 ?? 0} + set {_uniqueStorage()._optionalSint64 = newValue} + } + /// Returns true if `optionalSint64` has been explicitly set. + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} + /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} + + var optionalFixed32: UInt32 { + get {_storage._optionalFixed32 ?? 0} + set {_uniqueStorage()._optionalFixed32 = newValue} + } + /// Returns true if `optionalFixed32` has been explicitly set. + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} + /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} + + var optionalFixed64: UInt64 { + get {_storage._optionalFixed64 ?? 0} + set {_uniqueStorage()._optionalFixed64 = newValue} + } + /// Returns true if `optionalFixed64` has been explicitly set. + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} + /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} + + var optionalSfixed32: Int32 { + get {_storage._optionalSfixed32 ?? 0} + set {_uniqueStorage()._optionalSfixed32 = newValue} + } + /// Returns true if `optionalSfixed32` has been explicitly set. + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} + /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} + + var optionalSfixed64: Int64 { + get {_storage._optionalSfixed64 ?? 0} + set {_uniqueStorage()._optionalSfixed64 = newValue} + } + /// Returns true if `optionalSfixed64` has been explicitly set. + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} + /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} + + var optionalFloat: Float { + get {_storage._optionalFloat ?? 0} + set {_uniqueStorage()._optionalFloat = newValue} + } + /// Returns true if `optionalFloat` has been explicitly set. + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} + /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} + + var optionalDouble: Double { + get {_storage._optionalDouble ?? 0} + set {_uniqueStorage()._optionalDouble = newValue} + } + /// Returns true if `optionalDouble` has been explicitly set. + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} + /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. + mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} + + var optionalBool: Bool { + get {_storage._optionalBool ?? false} + set {_uniqueStorage()._optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {_storage._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} + + var optionalString: String { + get {_storage._optionalString ?? String()} + set {_uniqueStorage()._optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {_storage._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} + + var optionalBytes: Data { + get {_storage._optionalBytes ?? Data()} + set {_uniqueStorage()._optionalBytes = newValue} + } + /// Returns true if `optionalBytes` has been explicitly set. + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} + /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} + + var optionalGroup: EditionUnittest_TestAllTypes.OptionalGroup { + get {_storage._optionalGroup ?? EditionUnittest_TestAllTypes.OptionalGroup()} + set {_uniqueStorage()._optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {_storage._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {_uniqueStorage()._optionalGroup = nil} + + var optionalNestedMessage: EditionUnittest_TestAllTypes.NestedMessage { + get {_storage._optionalNestedMessage ?? EditionUnittest_TestAllTypes.NestedMessage()} + set {_uniqueStorage()._optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} + + var optionalForeignMessage: EditionUnittest_ForeignMessage { + get {_storage._optionalForeignMessage ?? EditionUnittest_ForeignMessage()} + set {_uniqueStorage()._optionalForeignMessage = newValue} + } + /// Returns true if `optionalForeignMessage` has been explicitly set. + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} + /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} + + var optionalImportMessage: Proto2UnittestImport_ImportMessage { + get {_storage._optionalImportMessage ?? Proto2UnittestImport_ImportMessage()} + set {_uniqueStorage()._optionalImportMessage = newValue} + } + /// Returns true if `optionalImportMessage` has been explicitly set. + var hasOptionalImportMessage: Bool {_storage._optionalImportMessage != nil} + /// Clears the value of `optionalImportMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalImportMessage() {_uniqueStorage()._optionalImportMessage = nil} + + var optionalNestedEnum: EditionUnittest_TestAllTypes.NestedEnum { + get {_storage._optionalNestedEnum ?? .foo} + set {_uniqueStorage()._optionalNestedEnum = newValue} + } + /// Returns true if `optionalNestedEnum` has been explicitly set. + var hasOptionalNestedEnum: Bool {_storage._optionalNestedEnum != nil} + /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} + + var optionalForeignEnum: EditionUnittest_ForeignEnum { + get {_storage._optionalForeignEnum ?? .foreignFoo} + set {_uniqueStorage()._optionalForeignEnum = newValue} + } + /// Returns true if `optionalForeignEnum` has been explicitly set. + var hasOptionalForeignEnum: Bool {_storage._optionalForeignEnum != nil} + /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignEnum() {_uniqueStorage()._optionalForeignEnum = nil} + + var optionalImportEnum: Proto2UnittestImport_ImportEnum { + get {_storage._optionalImportEnum ?? .importFoo} + set {_uniqueStorage()._optionalImportEnum = newValue} + } + /// Returns true if `optionalImportEnum` has been explicitly set. + var hasOptionalImportEnum: Bool {_storage._optionalImportEnum != nil} + /// Clears the value of `optionalImportEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalImportEnum() {_uniqueStorage()._optionalImportEnum = nil} + + var optionalStringPiece: String { + get {_storage._optionalStringPiece ?? String()} + set {_uniqueStorage()._optionalStringPiece = newValue} + } + /// Returns true if `optionalStringPiece` has been explicitly set. + var hasOptionalStringPiece: Bool {_storage._optionalStringPiece != nil} + /// Clears the value of `optionalStringPiece`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringPiece() {_uniqueStorage()._optionalStringPiece = nil} + + var optionalCord: String { + get {_storage._optionalCord ?? String()} + set {_uniqueStorage()._optionalCord = newValue} + } + /// Returns true if `optionalCord` has been explicitly set. + var hasOptionalCord: Bool {_storage._optionalCord != nil} + /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. + mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} + + var optionalBytesCord: Data { + get {_storage._optionalBytesCord ?? Data()} + set {_uniqueStorage()._optionalBytesCord = newValue} + } + /// Returns true if `optionalBytesCord` has been explicitly set. + var hasOptionalBytesCord: Bool {_storage._optionalBytesCord != nil} + /// Clears the value of `optionalBytesCord`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytesCord() {_uniqueStorage()._optionalBytesCord = nil} + + /// Defined in unittest_import_public.proto + var optionalPublicImportMessage: Proto2UnittestImport_PublicImportMessage { + get {_storage._optionalPublicImportMessage ?? Proto2UnittestImport_PublicImportMessage()} + set {_uniqueStorage()._optionalPublicImportMessage = newValue} + } + /// Returns true if `optionalPublicImportMessage` has been explicitly set. + var hasOptionalPublicImportMessage: Bool {_storage._optionalPublicImportMessage != nil} + /// Clears the value of `optionalPublicImportMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalPublicImportMessage() {_uniqueStorage()._optionalPublicImportMessage = nil} + + var optionalLazyMessage: EditionUnittest_TestAllTypes.NestedMessage { + get {_storage._optionalLazyMessage ?? EditionUnittest_TestAllTypes.NestedMessage()} + set {_uniqueStorage()._optionalLazyMessage = newValue} + } + /// Returns true if `optionalLazyMessage` has been explicitly set. + var hasOptionalLazyMessage: Bool {_storage._optionalLazyMessage != nil} + /// Clears the value of `optionalLazyMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalLazyMessage() {_uniqueStorage()._optionalLazyMessage = nil} + + var optionalUnverifiedLazyMessage: EditionUnittest_TestAllTypes.NestedMessage { + get {_storage._optionalUnverifiedLazyMessage ?? EditionUnittest_TestAllTypes.NestedMessage()} + set {_uniqueStorage()._optionalUnverifiedLazyMessage = newValue} + } + /// Returns true if `optionalUnverifiedLazyMessage` has been explicitly set. + var hasOptionalUnverifiedLazyMessage: Bool {_storage._optionalUnverifiedLazyMessage != nil} + /// Clears the value of `optionalUnverifiedLazyMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalUnverifiedLazyMessage() {_uniqueStorage()._optionalUnverifiedLazyMessage = nil} + + /// Repeated + var repeatedInt32: [Int32] { + get {_storage._repeatedInt32} + set {_uniqueStorage()._repeatedInt32 = newValue} + } + + var repeatedInt64: [Int64] { + get {_storage._repeatedInt64} + set {_uniqueStorage()._repeatedInt64 = newValue} + } + + var repeatedUint32: [UInt32] { + get {_storage._repeatedUint32} + set {_uniqueStorage()._repeatedUint32 = newValue} + } + + var repeatedUint64: [UInt64] { + get {_storage._repeatedUint64} + set {_uniqueStorage()._repeatedUint64 = newValue} + } + + var repeatedSint32: [Int32] { + get {_storage._repeatedSint32} + set {_uniqueStorage()._repeatedSint32 = newValue} + } + + var repeatedSint64: [Int64] { + get {_storage._repeatedSint64} + set {_uniqueStorage()._repeatedSint64 = newValue} + } + + var repeatedFixed32: [UInt32] { + get {_storage._repeatedFixed32} + set {_uniqueStorage()._repeatedFixed32 = newValue} + } + + var repeatedFixed64: [UInt64] { + get {_storage._repeatedFixed64} + set {_uniqueStorage()._repeatedFixed64 = newValue} + } + + var repeatedSfixed32: [Int32] { + get {_storage._repeatedSfixed32} + set {_uniqueStorage()._repeatedSfixed32 = newValue} + } + + var repeatedSfixed64: [Int64] { + get {_storage._repeatedSfixed64} + set {_uniqueStorage()._repeatedSfixed64 = newValue} + } + + var repeatedFloat: [Float] { + get {_storage._repeatedFloat} + set {_uniqueStorage()._repeatedFloat = newValue} + } + + var repeatedDouble: [Double] { + get {_storage._repeatedDouble} + set {_uniqueStorage()._repeatedDouble = newValue} + } + + var repeatedBool: [Bool] { + get {_storage._repeatedBool} + set {_uniqueStorage()._repeatedBool = newValue} + } + + var repeatedString: [String] { + get {_storage._repeatedString} + set {_uniqueStorage()._repeatedString = newValue} + } + + var repeatedBytes: [Data] { + get {_storage._repeatedBytes} + set {_uniqueStorage()._repeatedBytes = newValue} + } + + var repeatedGroup: [EditionUnittest_TestAllTypes.RepeatedGroup] { + get {_storage._repeatedGroup} + set {_uniqueStorage()._repeatedGroup = newValue} + } + + var repeatedNestedMessage: [EditionUnittest_TestAllTypes.NestedMessage] { + get {_storage._repeatedNestedMessage} + set {_uniqueStorage()._repeatedNestedMessage = newValue} + } + + var repeatedForeignMessage: [EditionUnittest_ForeignMessage] { + get {_storage._repeatedForeignMessage} + set {_uniqueStorage()._repeatedForeignMessage = newValue} + } + + var repeatedImportMessage: [Proto2UnittestImport_ImportMessage] { + get {_storage._repeatedImportMessage} + set {_uniqueStorage()._repeatedImportMessage = newValue} + } + + var repeatedNestedEnum: [EditionUnittest_TestAllTypes.NestedEnum] { + get {_storage._repeatedNestedEnum} + set {_uniqueStorage()._repeatedNestedEnum = newValue} + } + + var repeatedForeignEnum: [EditionUnittest_ForeignEnum] { + get {_storage._repeatedForeignEnum} + set {_uniqueStorage()._repeatedForeignEnum = newValue} + } + + var repeatedImportEnum: [Proto2UnittestImport_ImportEnum] { + get {_storage._repeatedImportEnum} + set {_uniqueStorage()._repeatedImportEnum = newValue} + } + + var repeatedStringPiece: [String] { + get {_storage._repeatedStringPiece} + set {_uniqueStorage()._repeatedStringPiece = newValue} + } + + var repeatedCord: [String] { + get {_storage._repeatedCord} + set {_uniqueStorage()._repeatedCord = newValue} + } + + var repeatedLazyMessage: [EditionUnittest_TestAllTypes.NestedMessage] { + get {_storage._repeatedLazyMessage} + set {_uniqueStorage()._repeatedLazyMessage = newValue} + } + + /// Singular with defaults + var defaultInt32: Int32 { + get {_storage._defaultInt32 ?? 41} + set {_uniqueStorage()._defaultInt32 = newValue} + } + /// Returns true if `defaultInt32` has been explicitly set. + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} + /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} + + var defaultInt64: Int64 { + get {_storage._defaultInt64 ?? 42} + set {_uniqueStorage()._defaultInt64 = newValue} + } + /// Returns true if `defaultInt64` has been explicitly set. + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} + /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} + + var defaultUint32: UInt32 { + get {_storage._defaultUint32 ?? 43} + set {_uniqueStorage()._defaultUint32 = newValue} + } + /// Returns true if `defaultUint32` has been explicitly set. + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} + /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} + + var defaultUint64: UInt64 { + get {_storage._defaultUint64 ?? 44} + set {_uniqueStorage()._defaultUint64 = newValue} + } + /// Returns true if `defaultUint64` has been explicitly set. + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} + /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} + + var defaultSint32: Int32 { + get {_storage._defaultSint32 ?? -45} + set {_uniqueStorage()._defaultSint32 = newValue} + } + /// Returns true if `defaultSint32` has been explicitly set. + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} + /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} + + var defaultSint64: Int64 { + get {_storage._defaultSint64 ?? 46} + set {_uniqueStorage()._defaultSint64 = newValue} + } + /// Returns true if `defaultSint64` has been explicitly set. + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} + /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} + + var defaultFixed32: UInt32 { + get {_storage._defaultFixed32 ?? 47} + set {_uniqueStorage()._defaultFixed32 = newValue} + } + /// Returns true if `defaultFixed32` has been explicitly set. + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} + /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} + + var defaultFixed64: UInt64 { + get {_storage._defaultFixed64 ?? 48} + set {_uniqueStorage()._defaultFixed64 = newValue} + } + /// Returns true if `defaultFixed64` has been explicitly set. + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} + /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} + + var defaultSfixed32: Int32 { + get {_storage._defaultSfixed32 ?? 49} + set {_uniqueStorage()._defaultSfixed32 = newValue} + } + /// Returns true if `defaultSfixed32` has been explicitly set. + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} + /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} + + var defaultSfixed64: Int64 { + get {_storage._defaultSfixed64 ?? -50} + set {_uniqueStorage()._defaultSfixed64 = newValue} + } + /// Returns true if `defaultSfixed64` has been explicitly set. + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} + /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} + + var defaultFloat: Float { + get {_storage._defaultFloat ?? 51.5} + set {_uniqueStorage()._defaultFloat = newValue} + } + /// Returns true if `defaultFloat` has been explicitly set. + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} + /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. + mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} + + var defaultDouble: Double { + get {_storage._defaultDouble ?? 52000} + set {_uniqueStorage()._defaultDouble = newValue} + } + /// Returns true if `defaultDouble` has been explicitly set. + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} + /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. + mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} + + var defaultBool: Bool { + get {_storage._defaultBool ?? true} + set {_uniqueStorage()._defaultBool = newValue} + } + /// Returns true if `defaultBool` has been explicitly set. + var hasDefaultBool: Bool {_storage._defaultBool != nil} + /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. + mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} + + var defaultString: String { + get {_storage._defaultString ?? "hello"} + set {_uniqueStorage()._defaultString = newValue} + } + /// Returns true if `defaultString` has been explicitly set. + var hasDefaultString: Bool {_storage._defaultString != nil} + /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. + mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} + + var defaultBytes: Data { + get {_storage._defaultBytes ?? Data([119, 111, 114, 108, 100])} + set {_uniqueStorage()._defaultBytes = newValue} + } + /// Returns true if `defaultBytes` has been explicitly set. + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} + /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. + mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} + + var defaultNestedEnum: EditionUnittest_TestAllTypes.NestedEnum { + get {_storage._defaultNestedEnum ?? .bar} + set {_uniqueStorage()._defaultNestedEnum = newValue} + } + /// Returns true if `defaultNestedEnum` has been explicitly set. + var hasDefaultNestedEnum: Bool {_storage._defaultNestedEnum != nil} + /// Clears the value of `defaultNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearDefaultNestedEnum() {_uniqueStorage()._defaultNestedEnum = nil} + + var defaultForeignEnum: EditionUnittest_ForeignEnum { + get {_storage._defaultForeignEnum ?? .foreignBar} + set {_uniqueStorage()._defaultForeignEnum = newValue} + } + /// Returns true if `defaultForeignEnum` has been explicitly set. + var hasDefaultForeignEnum: Bool {_storage._defaultForeignEnum != nil} + /// Clears the value of `defaultForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearDefaultForeignEnum() {_uniqueStorage()._defaultForeignEnum = nil} + + var defaultImportEnum: Proto2UnittestImport_ImportEnum { + get {_storage._defaultImportEnum ?? .importBar} + set {_uniqueStorage()._defaultImportEnum = newValue} + } + /// Returns true if `defaultImportEnum` has been explicitly set. + var hasDefaultImportEnum: Bool {_storage._defaultImportEnum != nil} + /// Clears the value of `defaultImportEnum`. Subsequent reads from it will return its default value. + mutating func clearDefaultImportEnum() {_uniqueStorage()._defaultImportEnum = nil} + + var defaultStringPiece: String { + get {_storage._defaultStringPiece ?? "abc"} + set {_uniqueStorage()._defaultStringPiece = newValue} + } + /// Returns true if `defaultStringPiece` has been explicitly set. + var hasDefaultStringPiece: Bool {_storage._defaultStringPiece != nil} + /// Clears the value of `defaultStringPiece`. Subsequent reads from it will return its default value. + mutating func clearDefaultStringPiece() {_uniqueStorage()._defaultStringPiece = nil} + + var defaultCord: String { + get {_storage._defaultCord ?? "123"} + set {_uniqueStorage()._defaultCord = newValue} + } + /// Returns true if `defaultCord` has been explicitly set. + var hasDefaultCord: Bool {_storage._defaultCord != nil} + /// Clears the value of `defaultCord`. Subsequent reads from it will return its default value. + mutating func clearDefaultCord() {_uniqueStorage()._defaultCord = nil} + + /// For oneof test + var oneofField: OneOf_OneofField? { + get {return _storage._oneofField} + set {_uniqueStorage()._oneofField = newValue} + } + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} + } + + var oneofNestedMessage: EditionUnittest_TestAllTypes.NestedMessage { + get { + if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} + return EditionUnittest_TestAllTypes.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = _storage._oneofField {return v} + return Data() + } + set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} + } + + var oneofCord: String { + get { + if case .oneofCord(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofCord(newValue)} + } + + var oneofStringPiece: String { + get { + if case .oneofStringPiece(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofStringPiece(newValue)} + } + + var oneofLazyNestedMessage: EditionUnittest_TestAllTypes.NestedMessage { + get { + if case .oneofLazyNestedMessage(let v)? = _storage._oneofField {return v} + return EditionUnittest_TestAllTypes.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofLazyNestedMessage(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + /// For oneof test + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofNestedMessage(EditionUnittest_TestAllTypes.NestedMessage) + case oneofString(String) + case oneofBytes(Data) + case oneofCord(String) + case oneofStringPiece(String) + case oneofLazyNestedMessage(EditionUnittest_TestAllTypes.NestedMessage) + + } + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 1 + case bar = 2 + case baz = 3 + + /// Intentionally negative. + case neg = -1 + + init() { + self = .foo + } + + } + + struct NestedMessage: Sendable { + // 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. + + /// The field name "b" fails to compile in proto1 because it conflicts with + /// a local variable named "b" in one of the generated methods. Doh. + /// This file needs to compile in proto1 to test backwards-compatibility. + var bb: Int32 { + get {_bb ?? 0} + set {_bb = newValue} + } + /// Returns true if `bb` has been explicitly set. + var hasBb: Bool {self._bb != nil} + /// Clears the value of `bb`. Subsequent reads from it will return its default value. + mutating func clearBb() {self._bb = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _bb: Int32? = nil + } + + struct OptionalGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + struct RepeatedGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// This proto includes a recursively nested message. +struct EditionUnittest_NestedTestAllTypes: @unchecked Sendable { + // 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 child: EditionUnittest_NestedTestAllTypes { + get {_storage._child ?? EditionUnittest_NestedTestAllTypes()} + set {_uniqueStorage()._child = newValue} + } + /// Returns true if `child` has been explicitly set. + var hasChild: Bool {_storage._child != nil} + /// Clears the value of `child`. Subsequent reads from it will return its default value. + mutating func clearChild() {_uniqueStorage()._child = nil} + + var payload: EditionUnittest_TestAllTypes { + get {_storage._payload ?? EditionUnittest_TestAllTypes()} + set {_uniqueStorage()._payload = newValue} + } + /// Returns true if `payload` has been explicitly set. + var hasPayload: Bool {_storage._payload != nil} + /// Clears the value of `payload`. Subsequent reads from it will return its default value. + mutating func clearPayload() {_uniqueStorage()._payload = nil} + + var repeatedChild: [EditionUnittest_NestedTestAllTypes] { + get {_storage._repeatedChild} + set {_uniqueStorage()._repeatedChild = newValue} + } + + var lazyChild: EditionUnittest_NestedTestAllTypes { + get {_storage._lazyChild ?? EditionUnittest_NestedTestAllTypes()} + set {_uniqueStorage()._lazyChild = newValue} + } + /// Returns true if `lazyChild` has been explicitly set. + var hasLazyChild: Bool {_storage._lazyChild != nil} + /// Clears the value of `lazyChild`. Subsequent reads from it will return its default value. + mutating func clearLazyChild() {_uniqueStorage()._lazyChild = nil} + + var eagerChild: EditionUnittest_TestAllTypes { + get {_storage._eagerChild ?? EditionUnittest_TestAllTypes()} + set {_uniqueStorage()._eagerChild = newValue} + } + /// Returns true if `eagerChild` has been explicitly set. + var hasEagerChild: Bool {_storage._eagerChild != nil} + /// Clears the value of `eagerChild`. Subsequent reads from it will return its default value. + mutating func clearEagerChild() {_uniqueStorage()._eagerChild = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct EditionUnittest_TestDeprecatedFields: @unchecked Sendable { + // 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. + + /// NOTE: This field was marked as deprecated in the .proto file. + var deprecatedInt32: Int32 { + get {_storage._deprecatedInt32 ?? 0} + set {_uniqueStorage()._deprecatedInt32 = newValue} + } + /// Returns true if `deprecatedInt32` has been explicitly set. + var hasDeprecatedInt32: Bool {_storage._deprecatedInt32 != nil} + /// Clears the value of `deprecatedInt32`. Subsequent reads from it will return its default value. + mutating func clearDeprecatedInt32() {_uniqueStorage()._deprecatedInt32 = nil} + + /// NOTE: This field was marked as deprecated in the .proto file. + var deprecatedRepeatedString: [String] { + get {_storage._deprecatedRepeatedString} + set {_uniqueStorage()._deprecatedRepeatedString = newValue} + } + + /// NOTE: This field was marked as deprecated in the .proto file. + var deprecatedMessage: EditionUnittest_TestAllTypes.NestedMessage { + get {_storage._deprecatedMessage ?? EditionUnittest_TestAllTypes.NestedMessage()} + set {_uniqueStorage()._deprecatedMessage = newValue} + } + /// Returns true if `deprecatedMessage` has been explicitly set. + var hasDeprecatedMessage: Bool {_storage._deprecatedMessage != nil} + /// Clears the value of `deprecatedMessage`. Subsequent reads from it will return its default value. + mutating func clearDeprecatedMessage() {_uniqueStorage()._deprecatedMessage = nil} + + var oneofFields: OneOf_OneofFields? { + get {return _storage._oneofFields} + set {_uniqueStorage()._oneofFields = newValue} + } + + /// NOTE: This field was marked as deprecated in the .proto file. + var deprecatedInt32InOneof: Int32 { + get { + if case .deprecatedInt32InOneof(let v)? = _storage._oneofFields {return v} + return 0 + } + set {_uniqueStorage()._oneofFields = .deprecatedInt32InOneof(newValue)} + } + + var nested: EditionUnittest_TestDeprecatedFields { + get {_storage._nested ?? EditionUnittest_TestDeprecatedFields()} + set {_uniqueStorage()._nested = newValue} + } + /// Returns true if `nested` has been explicitly set. + var hasNested: Bool {_storage._nested != nil} + /// Clears the value of `nested`. Subsequent reads from it will return its default value. + mutating func clearNested() {_uniqueStorage()._nested = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofFields: Equatable, Sendable { + /// NOTE: This field was marked as deprecated in the .proto file. + case deprecatedInt32InOneof(Int32) + + } + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// NOTE: This message was marked as deprecated in the .proto file. +struct EditionUnittest_TestDeprecatedMessage: Sendable { + // 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() {} +} + +/// Define these after TestAllTypes to make sure the compiler can handle that. +struct EditionUnittest_ForeignMessage: Sendable { + // 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 c: Int32 { + get {_c ?? 0} + set {_c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {self._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {self._c = nil} + + var d: Int32 { + get {_d ?? 0} + set {_d = newValue} + } + /// Returns true if `d` has been explicitly set. + var hasD: Bool {self._d != nil} + /// Clears the value of `d`. Subsequent reads from it will return its default value. + mutating func clearD() {self._d = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _c: Int32? = nil + fileprivate var _d: Int32? = nil +} + +struct EditionUnittest_TestReservedFields: Sendable { + // 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 EditionUnittest_TestAllExtensions: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +struct EditionUnittest_OptionalGroup_extension: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil +} + +struct EditionUnittest_RepeatedGroup_extension: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil +} + +struct EditionUnittest_TestMixedFieldsAndExtensions: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: [UInt32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _a: Int32? = nil +} + +struct EditionUnittest_TestGroup: Sendable { + // 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 optionalGroup: EditionUnittest_TestGroup.OptionalGroup { + get {_optionalGroup ?? EditionUnittest_TestGroup.OptionalGroup()} + set {_optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {self._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {self._optionalGroup = nil} + + var optionalForeignEnum: EditionUnittest_ForeignEnum { + get {_optionalForeignEnum ?? .foreignFoo} + set {_optionalForeignEnum = newValue} + } + /// Returns true if `optionalForeignEnum` has been explicitly set. + var hasOptionalForeignEnum: Bool {self._optionalForeignEnum != nil} + /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignEnum() {self._optionalForeignEnum = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct OptionalGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + /// fast table size must be at least 16, for this + var zz: Int32 { + get {_zz ?? 0} + set {_zz = newValue} + } + /// Returns true if `zz` has been explicitly set. + var hasZz: Bool {self._zz != nil} + /// Clears the value of `zz`. Subsequent reads from it will return its default value. + mutating func clearZz() {self._zz = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _zz: Int32? = nil + } + + init() {} + + fileprivate var _optionalGroup: EditionUnittest_TestGroup.OptionalGroup? = nil + fileprivate var _optionalForeignEnum: EditionUnittest_ForeignEnum? = nil +} + +struct EditionUnittest_TestGroupExtension: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +struct EditionUnittest_TestNestedExtension: Sendable { + // 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() + + struct OptionalGroup_extension: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + init() {} +} + +struct EditionUnittest_TestChildExtension: Sendable { + // 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 a: String { + get {_a ?? String()} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: String { + get {_b ?? String()} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var optionalExtension: EditionUnittest_TestAllExtensions { + get {_optionalExtension ?? EditionUnittest_TestAllExtensions()} + set {_optionalExtension = newValue} + } + /// Returns true if `optionalExtension` has been explicitly set. + var hasOptionalExtension: Bool {self._optionalExtension != nil} + /// Clears the value of `optionalExtension`. Subsequent reads from it will return its default value. + mutating func clearOptionalExtension() {self._optionalExtension = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: String? = nil + fileprivate var _b: String? = nil + fileprivate var _optionalExtension: EditionUnittest_TestAllExtensions? = nil +} + +/// Emulates wireformat data of TestChildExtension with dynamic extension +/// (DynamicExtension). +struct EditionUnittest_TestChildExtensionData: Sendable { + // 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 a: String { + get {_a ?? String()} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: String { + get {_b ?? String()} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var optionalExtension: EditionUnittest_TestChildExtensionData.NestedTestAllExtensionsData { + get {_optionalExtension ?? EditionUnittest_TestChildExtensionData.NestedTestAllExtensionsData()} + set {_optionalExtension = newValue} + } + /// Returns true if `optionalExtension` has been explicitly set. + var hasOptionalExtension: Bool {self._optionalExtension != nil} + /// Clears the value of `optionalExtension`. Subsequent reads from it will return its default value. + mutating func clearOptionalExtension() {self._optionalExtension = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct NestedTestAllExtensionsData: Sendable { + // 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 dynamic: EditionUnittest_TestChildExtensionData.NestedTestAllExtensionsData.NestedDynamicExtensions { + get {_dynamic ?? EditionUnittest_TestChildExtensionData.NestedTestAllExtensionsData.NestedDynamicExtensions()} + set {_dynamic = newValue} + } + /// Returns true if `dynamic` has been explicitly set. + var hasDynamic: Bool {self._dynamic != nil} + /// Clears the value of `dynamic`. Subsequent reads from it will return its default value. + mutating func clearDynamic() {self._dynamic = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct NestedDynamicExtensions: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil + } + + init() {} + + fileprivate var _dynamic: EditionUnittest_TestChildExtensionData.NestedTestAllExtensionsData.NestedDynamicExtensions? = nil + } + + init() {} + + fileprivate var _a: String? = nil + fileprivate var _b: String? = nil + fileprivate var _optionalExtension: EditionUnittest_TestChildExtensionData.NestedTestAllExtensionsData? = nil +} + +struct EditionUnittest_TestNestedChildExtension: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var child: EditionUnittest_TestChildExtension { + get {_child ?? EditionUnittest_TestChildExtension()} + set {_child = newValue} + } + /// Returns true if `child` has been explicitly set. + var hasChild: Bool {self._child != nil} + /// Clears the value of `child`. Subsequent reads from it will return its default value. + mutating func clearChild() {self._child = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _child: EditionUnittest_TestChildExtension? = nil +} + +/// Emulates wireformat data of TestNestedChildExtension with dynamic extension +/// (DynamicExtension). +struct EditionUnittest_TestNestedChildExtensionData: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var child: EditionUnittest_TestChildExtensionData { + get {_child ?? EditionUnittest_TestChildExtensionData()} + set {_child = newValue} + } + /// Returns true if `child` has been explicitly set. + var hasChild: Bool {self._child != nil} + /// Clears the value of `child`. Subsequent reads from it will return its default value. + mutating func clearChild() {self._child = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _child: EditionUnittest_TestChildExtensionData? = nil +} + +/// Required and closed enum fields are considered unknown fields if the value is +/// not valid. We need to make sure it functions as expected. +struct EditionUnittest_TestRequiredEnum: Sendable { + // 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 requiredEnum: EditionUnittest_ForeignEnum { + get {_requiredEnum ?? .foreignFoo} + set {_requiredEnum = newValue} + } + /// Returns true if `requiredEnum` has been explicitly set. + var hasRequiredEnum: Bool {self._requiredEnum != nil} + /// Clears the value of `requiredEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum() {self._requiredEnum = nil} + + /// A dummy optional field. + var a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _requiredEnum: EditionUnittest_ForeignEnum? = nil + fileprivate var _a: Int32? = nil +} + +/// TestRequiredEnum + using enum values that won't fit to 64 bitmask. +struct EditionUnittest_TestRequiredEnumNoMask: Sendable { + // 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 requiredEnum: EditionUnittest_TestRequiredEnumNoMask.NestedEnum { + get {_requiredEnum ?? .unspecified} + set {_requiredEnum = newValue} + } + /// Returns true if `requiredEnum` has been explicitly set. + var hasRequiredEnum: Bool {self._requiredEnum != nil} + /// Clears the value of `requiredEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum() {self._requiredEnum = nil} + + /// A dummy optional field. + var a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unspecified = 0 + case foo = 2 + case bar = 100 + + /// Intentionally negative. + case baz = -1 + + init() { + self = .unspecified + } + + } + + init() {} + + fileprivate var _requiredEnum: EditionUnittest_TestRequiredEnumNoMask.NestedEnum? = nil + fileprivate var _a: Int32? = nil +} + +struct EditionUnittest_TestRequiredEnumMulti: Sendable { + // 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. + + /// Intentionally placed in descending field number to force sorting in closed + /// enum verification. + var requiredEnum4: EditionUnittest_TestRequiredEnumMulti.NestedEnum { + get {_requiredEnum4 ?? .unspecified} + set {_requiredEnum4 = newValue} + } + /// Returns true if `requiredEnum4` has been explicitly set. + var hasRequiredEnum4: Bool {self._requiredEnum4 != nil} + /// Clears the value of `requiredEnum4`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum4() {self._requiredEnum4 = nil} + + var a3: Int32 { + get {_a3 ?? 0} + set {_a3 = newValue} + } + /// Returns true if `a3` has been explicitly set. + var hasA3: Bool {self._a3 != nil} + /// Clears the value of `a3`. Subsequent reads from it will return its default value. + mutating func clearA3() {self._a3 = nil} + + var requiredEnum2: EditionUnittest_TestRequiredEnumMulti.NestedEnum { + get {_requiredEnum2 ?? .unspecified} + set {_requiredEnum2 = newValue} + } + /// Returns true if `requiredEnum2` has been explicitly set. + var hasRequiredEnum2: Bool {self._requiredEnum2 != nil} + /// Clears the value of `requiredEnum2`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum2() {self._requiredEnum2 = nil} + + var requiredEnum1: EditionUnittest_ForeignEnum { + get {_requiredEnum1 ?? .foreignFoo} + set {_requiredEnum1 = newValue} + } + /// Returns true if `requiredEnum1` has been explicitly set. + var hasRequiredEnum1: Bool {self._requiredEnum1 != nil} + /// Clears the value of `requiredEnum1`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum1() {self._requiredEnum1 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unspecified = 0 + case foo = 1 + case bar = 2 + case baz = 100 + + init() { + self = .unspecified + } + + } + + init() {} + + fileprivate var _requiredEnum4: EditionUnittest_TestRequiredEnumMulti.NestedEnum? = nil + fileprivate var _a3: Int32? = nil + fileprivate var _requiredEnum2: EditionUnittest_TestRequiredEnumMulti.NestedEnum? = nil + fileprivate var _requiredEnum1: EditionUnittest_ForeignEnum? = nil +} + +struct EditionUnittest_TestRequiredNoMaskMulti: Sendable { + // 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. + + /// Intentionally placed in descending field number to force sorting in closed + /// enum verification. Also, using large field numbers to use tag only + /// matching for fields. + var requiredFixed3280: UInt32 { + get {_requiredFixed3280 ?? 0} + set {_requiredFixed3280 = newValue} + } + /// Returns true if `requiredFixed3280` has been explicitly set. + var hasRequiredFixed3280: Bool {self._requiredFixed3280 != nil} + /// Clears the value of `requiredFixed3280`. Subsequent reads from it will return its default value. + mutating func clearRequiredFixed3280() {self._requiredFixed3280 = nil} + + var requiredFixed3270: UInt32 { + get {_requiredFixed3270 ?? 0} + set {_requiredFixed3270 = newValue} + } + /// Returns true if `requiredFixed3270` has been explicitly set. + var hasRequiredFixed3270: Bool {self._requiredFixed3270 != nil} + /// Clears the value of `requiredFixed3270`. Subsequent reads from it will return its default value. + mutating func clearRequiredFixed3270() {self._requiredFixed3270 = nil} + + var requiredEnum64: EditionUnittest_TestRequiredNoMaskMulti.NestedEnum { + get {_requiredEnum64 ?? .unspecified} + set {_requiredEnum64 = newValue} + } + /// Returns true if `requiredEnum64` has been explicitly set. + var hasRequiredEnum64: Bool {self._requiredEnum64 != nil} + /// Clears the value of `requiredEnum64`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum64() {self._requiredEnum64 = nil} + + var requiredEnum4: EditionUnittest_TestRequiredNoMaskMulti.NestedEnum { + get {_requiredEnum4 ?? .unspecified} + set {_requiredEnum4 = newValue} + } + /// Returns true if `requiredEnum4` has been explicitly set. + var hasRequiredEnum4: Bool {self._requiredEnum4 != nil} + /// Clears the value of `requiredEnum4`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum4() {self._requiredEnum4 = nil} + + var a3: Int32 { + get {_a3 ?? 0} + set {_a3 = newValue} + } + /// Returns true if `a3` has been explicitly set. + var hasA3: Bool {self._a3 != nil} + /// Clears the value of `a3`. Subsequent reads from it will return its default value. + mutating func clearA3() {self._a3 = nil} + + var requiredEnum2: EditionUnittest_TestRequiredNoMaskMulti.NestedEnum { + get {_requiredEnum2 ?? .unspecified} + set {_requiredEnum2 = newValue} + } + /// Returns true if `requiredEnum2` has been explicitly set. + var hasRequiredEnum2: Bool {self._requiredEnum2 != nil} + /// Clears the value of `requiredEnum2`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum2() {self._requiredEnum2 = nil} + + var requiredEnum1: EditionUnittest_ForeignEnum { + get {_requiredEnum1 ?? .foreignFoo} + set {_requiredEnum1 = newValue} + } + /// Returns true if `requiredEnum1` has been explicitly set. + var hasRequiredEnum1: Bool {self._requiredEnum1 != nil} + /// Clears the value of `requiredEnum1`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum1() {self._requiredEnum1 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unspecified = 0 + case foo = 1 + case bar = 2 + case baz = 100 + + init() { + self = .unspecified + } + + } + + init() {} + + fileprivate var _requiredFixed3280: UInt32? = nil + fileprivate var _requiredFixed3270: UInt32? = nil + fileprivate var _requiredEnum64: EditionUnittest_TestRequiredNoMaskMulti.NestedEnum? = nil + fileprivate var _requiredEnum4: EditionUnittest_TestRequiredNoMaskMulti.NestedEnum? = nil + fileprivate var _a3: Int32? = nil + fileprivate var _requiredEnum2: EditionUnittest_TestRequiredNoMaskMulti.NestedEnum? = nil + fileprivate var _requiredEnum1: EditionUnittest_ForeignEnum? = nil +} + +/// We have separate messages for testing fields because it's +/// annoying to have to fill in fields in TestProto in order to +/// do anything with it. Note that we don't need to test every type of +/// filed because the code output is basically identical to +/// optional fields for all types. +struct EditionUnittest_TestRequired: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var dummy2: Int32 { + get {_storage._dummy2 ?? 0} + set {_uniqueStorage()._dummy2 = newValue} + } + /// Returns true if `dummy2` has been explicitly set. + var hasDummy2: Bool {_storage._dummy2 != nil} + /// Clears the value of `dummy2`. Subsequent reads from it will return its default value. + mutating func clearDummy2() {_uniqueStorage()._dummy2 = nil} + + var b: Int32 { + get {_storage._b ?? 0} + set {_uniqueStorage()._b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {_storage._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {_uniqueStorage()._b = nil} + + /// Pad the field count to 32 so that we can test that IsInitialized() + /// properly checks multiple elements of has_bits_. + var dummy4: Int32 { + get {_storage._dummy4 ?? 0} + set {_uniqueStorage()._dummy4 = newValue} + } + /// Returns true if `dummy4` has been explicitly set. + var hasDummy4: Bool {_storage._dummy4 != nil} + /// Clears the value of `dummy4`. Subsequent reads from it will return its default value. + mutating func clearDummy4() {_uniqueStorage()._dummy4 = nil} + + var dummy5: Int32 { + get {_storage._dummy5 ?? 0} + set {_uniqueStorage()._dummy5 = newValue} + } + /// Returns true if `dummy5` has been explicitly set. + var hasDummy5: Bool {_storage._dummy5 != nil} + /// Clears the value of `dummy5`. Subsequent reads from it will return its default value. + mutating func clearDummy5() {_uniqueStorage()._dummy5 = nil} + + var dummy6: Int32 { + get {_storage._dummy6 ?? 0} + set {_uniqueStorage()._dummy6 = newValue} + } + /// Returns true if `dummy6` has been explicitly set. + var hasDummy6: Bool {_storage._dummy6 != nil} + /// Clears the value of `dummy6`. Subsequent reads from it will return its default value. + mutating func clearDummy6() {_uniqueStorage()._dummy6 = nil} + + var dummy7: Int32 { + get {_storage._dummy7 ?? 0} + set {_uniqueStorage()._dummy7 = newValue} + } + /// Returns true if `dummy7` has been explicitly set. + var hasDummy7: Bool {_storage._dummy7 != nil} + /// Clears the value of `dummy7`. Subsequent reads from it will return its default value. + mutating func clearDummy7() {_uniqueStorage()._dummy7 = nil} + + var dummy8: Int32 { + get {_storage._dummy8 ?? 0} + set {_uniqueStorage()._dummy8 = newValue} + } + /// Returns true if `dummy8` has been explicitly set. + var hasDummy8: Bool {_storage._dummy8 != nil} + /// Clears the value of `dummy8`. Subsequent reads from it will return its default value. + mutating func clearDummy8() {_uniqueStorage()._dummy8 = nil} + + var dummy9: Int32 { + get {_storage._dummy9 ?? 0} + set {_uniqueStorage()._dummy9 = newValue} + } + /// Returns true if `dummy9` has been explicitly set. + var hasDummy9: Bool {_storage._dummy9 != nil} + /// Clears the value of `dummy9`. Subsequent reads from it will return its default value. + mutating func clearDummy9() {_uniqueStorage()._dummy9 = nil} + + var dummy10: Int32 { + get {_storage._dummy10 ?? 0} + set {_uniqueStorage()._dummy10 = newValue} + } + /// Returns true if `dummy10` has been explicitly set. + var hasDummy10: Bool {_storage._dummy10 != nil} + /// Clears the value of `dummy10`. Subsequent reads from it will return its default value. + mutating func clearDummy10() {_uniqueStorage()._dummy10 = nil} + + var dummy11: Int32 { + get {_storage._dummy11 ?? 0} + set {_uniqueStorage()._dummy11 = newValue} + } + /// Returns true if `dummy11` has been explicitly set. + var hasDummy11: Bool {_storage._dummy11 != nil} + /// Clears the value of `dummy11`. Subsequent reads from it will return its default value. + mutating func clearDummy11() {_uniqueStorage()._dummy11 = nil} + + var dummy12: Int32 { + get {_storage._dummy12 ?? 0} + set {_uniqueStorage()._dummy12 = newValue} + } + /// Returns true if `dummy12` has been explicitly set. + var hasDummy12: Bool {_storage._dummy12 != nil} + /// Clears the value of `dummy12`. Subsequent reads from it will return its default value. + mutating func clearDummy12() {_uniqueStorage()._dummy12 = nil} + + var dummy13: Int32 { + get {_storage._dummy13 ?? 0} + set {_uniqueStorage()._dummy13 = newValue} + } + /// Returns true if `dummy13` has been explicitly set. + var hasDummy13: Bool {_storage._dummy13 != nil} + /// Clears the value of `dummy13`. Subsequent reads from it will return its default value. + mutating func clearDummy13() {_uniqueStorage()._dummy13 = nil} + + var dummy14: Int32 { + get {_storage._dummy14 ?? 0} + set {_uniqueStorage()._dummy14 = newValue} + } + /// Returns true if `dummy14` has been explicitly set. + var hasDummy14: Bool {_storage._dummy14 != nil} + /// Clears the value of `dummy14`. Subsequent reads from it will return its default value. + mutating func clearDummy14() {_uniqueStorage()._dummy14 = nil} + + var dummy15: Int32 { + get {_storage._dummy15 ?? 0} + set {_uniqueStorage()._dummy15 = newValue} + } + /// Returns true if `dummy15` has been explicitly set. + var hasDummy15: Bool {_storage._dummy15 != nil} + /// Clears the value of `dummy15`. Subsequent reads from it will return its default value. + mutating func clearDummy15() {_uniqueStorage()._dummy15 = nil} + + var dummy16: Int32 { + get {_storage._dummy16 ?? 0} + set {_uniqueStorage()._dummy16 = newValue} + } + /// Returns true if `dummy16` has been explicitly set. + var hasDummy16: Bool {_storage._dummy16 != nil} + /// Clears the value of `dummy16`. Subsequent reads from it will return its default value. + mutating func clearDummy16() {_uniqueStorage()._dummy16 = nil} + + var dummy17: Int32 { + get {_storage._dummy17 ?? 0} + set {_uniqueStorage()._dummy17 = newValue} + } + /// Returns true if `dummy17` has been explicitly set. + var hasDummy17: Bool {_storage._dummy17 != nil} + /// Clears the value of `dummy17`. Subsequent reads from it will return its default value. + mutating func clearDummy17() {_uniqueStorage()._dummy17 = nil} + + var dummy18: Int32 { + get {_storage._dummy18 ?? 0} + set {_uniqueStorage()._dummy18 = newValue} + } + /// Returns true if `dummy18` has been explicitly set. + var hasDummy18: Bool {_storage._dummy18 != nil} + /// Clears the value of `dummy18`. Subsequent reads from it will return its default value. + mutating func clearDummy18() {_uniqueStorage()._dummy18 = nil} + + var dummy19: Int32 { + get {_storage._dummy19 ?? 0} + set {_uniqueStorage()._dummy19 = newValue} + } + /// Returns true if `dummy19` has been explicitly set. + var hasDummy19: Bool {_storage._dummy19 != nil} + /// Clears the value of `dummy19`. Subsequent reads from it will return its default value. + mutating func clearDummy19() {_uniqueStorage()._dummy19 = nil} + + var dummy20: Int32 { + get {_storage._dummy20 ?? 0} + set {_uniqueStorage()._dummy20 = newValue} + } + /// Returns true if `dummy20` has been explicitly set. + var hasDummy20: Bool {_storage._dummy20 != nil} + /// Clears the value of `dummy20`. Subsequent reads from it will return its default value. + mutating func clearDummy20() {_uniqueStorage()._dummy20 = nil} + + var dummy21: Int32 { + get {_storage._dummy21 ?? 0} + set {_uniqueStorage()._dummy21 = newValue} + } + /// Returns true if `dummy21` has been explicitly set. + var hasDummy21: Bool {_storage._dummy21 != nil} + /// Clears the value of `dummy21`. Subsequent reads from it will return its default value. + mutating func clearDummy21() {_uniqueStorage()._dummy21 = nil} + + var dummy22: Int32 { + get {_storage._dummy22 ?? 0} + set {_uniqueStorage()._dummy22 = newValue} + } + /// Returns true if `dummy22` has been explicitly set. + var hasDummy22: Bool {_storage._dummy22 != nil} + /// Clears the value of `dummy22`. Subsequent reads from it will return its default value. + mutating func clearDummy22() {_uniqueStorage()._dummy22 = nil} + + var dummy23: Int32 { + get {_storage._dummy23 ?? 0} + set {_uniqueStorage()._dummy23 = newValue} + } + /// Returns true if `dummy23` has been explicitly set. + var hasDummy23: Bool {_storage._dummy23 != nil} + /// Clears the value of `dummy23`. Subsequent reads from it will return its default value. + mutating func clearDummy23() {_uniqueStorage()._dummy23 = nil} + + var dummy24: Int32 { + get {_storage._dummy24 ?? 0} + set {_uniqueStorage()._dummy24 = newValue} + } + /// Returns true if `dummy24` has been explicitly set. + var hasDummy24: Bool {_storage._dummy24 != nil} + /// Clears the value of `dummy24`. Subsequent reads from it will return its default value. + mutating func clearDummy24() {_uniqueStorage()._dummy24 = nil} + + var dummy25: Int32 { + get {_storage._dummy25 ?? 0} + set {_uniqueStorage()._dummy25 = newValue} + } + /// Returns true if `dummy25` has been explicitly set. + var hasDummy25: Bool {_storage._dummy25 != nil} + /// Clears the value of `dummy25`. Subsequent reads from it will return its default value. + mutating func clearDummy25() {_uniqueStorage()._dummy25 = nil} + + var dummy26: Int32 { + get {_storage._dummy26 ?? 0} + set {_uniqueStorage()._dummy26 = newValue} + } + /// Returns true if `dummy26` has been explicitly set. + var hasDummy26: Bool {_storage._dummy26 != nil} + /// Clears the value of `dummy26`. Subsequent reads from it will return its default value. + mutating func clearDummy26() {_uniqueStorage()._dummy26 = nil} + + var dummy27: Int32 { + get {_storage._dummy27 ?? 0} + set {_uniqueStorage()._dummy27 = newValue} + } + /// Returns true if `dummy27` has been explicitly set. + var hasDummy27: Bool {_storage._dummy27 != nil} + /// Clears the value of `dummy27`. Subsequent reads from it will return its default value. + mutating func clearDummy27() {_uniqueStorage()._dummy27 = nil} + + var dummy28: Int32 { + get {_storage._dummy28 ?? 0} + set {_uniqueStorage()._dummy28 = newValue} + } + /// Returns true if `dummy28` has been explicitly set. + var hasDummy28: Bool {_storage._dummy28 != nil} + /// Clears the value of `dummy28`. Subsequent reads from it will return its default value. + mutating func clearDummy28() {_uniqueStorage()._dummy28 = nil} + + var dummy29: Int32 { + get {_storage._dummy29 ?? 0} + set {_uniqueStorage()._dummy29 = newValue} + } + /// Returns true if `dummy29` has been explicitly set. + var hasDummy29: Bool {_storage._dummy29 != nil} + /// Clears the value of `dummy29`. Subsequent reads from it will return its default value. + mutating func clearDummy29() {_uniqueStorage()._dummy29 = nil} + + var dummy30: Int32 { + get {_storage._dummy30 ?? 0} + set {_uniqueStorage()._dummy30 = newValue} + } + /// Returns true if `dummy30` has been explicitly set. + var hasDummy30: Bool {_storage._dummy30 != nil} + /// Clears the value of `dummy30`. Subsequent reads from it will return its default value. + mutating func clearDummy30() {_uniqueStorage()._dummy30 = nil} + + var dummy31: Int32 { + get {_storage._dummy31 ?? 0} + set {_uniqueStorage()._dummy31 = newValue} + } + /// Returns true if `dummy31` has been explicitly set. + var hasDummy31: Bool {_storage._dummy31 != nil} + /// Clears the value of `dummy31`. Subsequent reads from it will return its default value. + mutating func clearDummy31() {_uniqueStorage()._dummy31 = nil} + + var dummy32: Int32 { + get {_storage._dummy32 ?? 0} + set {_uniqueStorage()._dummy32 = newValue} + } + /// Returns true if `dummy32` has been explicitly set. + var hasDummy32: Bool {_storage._dummy32 != nil} + /// Clears the value of `dummy32`. Subsequent reads from it will return its default value. + mutating func clearDummy32() {_uniqueStorage()._dummy32 = nil} + + var c: Int32 { + get {_storage._c ?? 0} + set {_uniqueStorage()._c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {_storage._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {_uniqueStorage()._c = nil} + + /// Add an optional child message to make this non-trivial for go/pdlazy. + var optionalForeign: EditionUnittest_ForeignMessage { + get {_storage._optionalForeign ?? EditionUnittest_ForeignMessage()} + set {_uniqueStorage()._optionalForeign = newValue} + } + /// Returns true if `optionalForeign` has been explicitly set. + var hasOptionalForeign: Bool {_storage._optionalForeign != nil} + /// Clears the value of `optionalForeign`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeign() {_uniqueStorage()._optionalForeign = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct EditionUnittest_TestRequiredForeign: Sendable { + // 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 optionalMessage: EditionUnittest_TestRequired { + get {_optionalMessage ?? EditionUnittest_TestRequired()} + set {_optionalMessage = newValue} + } + /// Returns true if `optionalMessage` has been explicitly set. + var hasOptionalMessage: Bool {self._optionalMessage != nil} + /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalMessage() {self._optionalMessage = nil} + + var repeatedMessage: [EditionUnittest_TestRequired] = [] + + var dummy: Int32 { + get {_dummy ?? 0} + set {_dummy = newValue} + } + /// Returns true if `dummy` has been explicitly set. + var hasDummy: Bool {self._dummy != nil} + /// Clears the value of `dummy`. Subsequent reads from it will return its default value. + mutating func clearDummy() {self._dummy = nil} + + /// Missing fields must not affect verification of child messages. + var optionalLazyMessage: EditionUnittest_NestedTestAllTypes { + get {_optionalLazyMessage ?? EditionUnittest_NestedTestAllTypes()} + set {_optionalLazyMessage = newValue} + } + /// Returns true if `optionalLazyMessage` has been explicitly set. + var hasOptionalLazyMessage: Bool {self._optionalLazyMessage != nil} + /// Clears the value of `optionalLazyMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalLazyMessage() {self._optionalLazyMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalMessage: EditionUnittest_TestRequired? = nil + fileprivate var _dummy: Int32? = nil + fileprivate var _optionalLazyMessage: EditionUnittest_NestedTestAllTypes? = nil +} + +struct EditionUnittest_TestRequiredMessage: Sendable { + // 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 optionalMessage: EditionUnittest_TestRequired { + get {_optionalMessage ?? EditionUnittest_TestRequired()} + set {_optionalMessage = newValue} + } + /// Returns true if `optionalMessage` has been explicitly set. + var hasOptionalMessage: Bool {self._optionalMessage != nil} + /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalMessage() {self._optionalMessage = nil} + + var repeatedMessage: [EditionUnittest_TestRequired] = [] + + var requiredMessage: EditionUnittest_TestRequired { + get {_requiredMessage ?? EditionUnittest_TestRequired()} + set {_requiredMessage = newValue} + } + /// Returns true if `requiredMessage` has been explicitly set. + var hasRequiredMessage: Bool {self._requiredMessage != nil} + /// Clears the value of `requiredMessage`. Subsequent reads from it will return its default value. + mutating func clearRequiredMessage() {self._requiredMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalMessage: EditionUnittest_TestRequired? = nil + fileprivate var _requiredMessage: EditionUnittest_TestRequired? = nil +} + +struct EditionUnittest_TestNestedRequiredForeign: @unchecked Sendable { + // 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 child: EditionUnittest_TestNestedRequiredForeign { + get {_storage._child ?? EditionUnittest_TestNestedRequiredForeign()} + set {_uniqueStorage()._child = newValue} + } + /// Returns true if `child` has been explicitly set. + var hasChild: Bool {_storage._child != nil} + /// Clears the value of `child`. Subsequent reads from it will return its default value. + mutating func clearChild() {_uniqueStorage()._child = nil} + + var payload: EditionUnittest_TestRequiredForeign { + get {_storage._payload ?? EditionUnittest_TestRequiredForeign()} + set {_uniqueStorage()._payload = newValue} + } + /// Returns true if `payload` has been explicitly set. + var hasPayload: Bool {_storage._payload != nil} + /// Clears the value of `payload`. Subsequent reads from it will return its default value. + mutating func clearPayload() {_uniqueStorage()._payload = nil} + + var dummy: Int32 { + get {_storage._dummy ?? 0} + set {_uniqueStorage()._dummy = newValue} + } + /// Returns true if `dummy` has been explicitly set. + var hasDummy: Bool {_storage._dummy != nil} + /// Clears the value of `dummy`. Subsequent reads from it will return its default value. + mutating func clearDummy() {_uniqueStorage()._dummy = nil} + + /// optional message to test closed enum. + var requiredEnum: EditionUnittest_TestRequiredEnum { + get {_storage._requiredEnum ?? EditionUnittest_TestRequiredEnum()} + set {_uniqueStorage()._requiredEnum = newValue} + } + /// Returns true if `requiredEnum` has been explicitly set. + var hasRequiredEnum: Bool {_storage._requiredEnum != nil} + /// Clears the value of `requiredEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum() {_uniqueStorage()._requiredEnum = nil} + + var requiredEnumNoMask: EditionUnittest_TestRequiredEnumNoMask { + get {_storage._requiredEnumNoMask ?? EditionUnittest_TestRequiredEnumNoMask()} + set {_uniqueStorage()._requiredEnumNoMask = newValue} + } + /// Returns true if `requiredEnumNoMask` has been explicitly set. + var hasRequiredEnumNoMask: Bool {_storage._requiredEnumNoMask != nil} + /// Clears the value of `requiredEnumNoMask`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnumNoMask() {_uniqueStorage()._requiredEnumNoMask = nil} + + var requiredEnumMulti: EditionUnittest_TestRequiredEnumMulti { + get {_storage._requiredEnumMulti ?? EditionUnittest_TestRequiredEnumMulti()} + set {_uniqueStorage()._requiredEnumMulti = newValue} + } + /// Returns true if `requiredEnumMulti` has been explicitly set. + var hasRequiredEnumMulti: Bool {_storage._requiredEnumMulti != nil} + /// Clears the value of `requiredEnumMulti`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnumMulti() {_uniqueStorage()._requiredEnumMulti = nil} + + var requiredNoMask: EditionUnittest_TestRequiredNoMaskMulti { + get {_storage._requiredNoMask ?? EditionUnittest_TestRequiredNoMaskMulti()} + set {_uniqueStorage()._requiredNoMask = newValue} + } + /// Returns true if `requiredNoMask` has been explicitly set. + var hasRequiredNoMask: Bool {_storage._requiredNoMask != nil} + /// Clears the value of `requiredNoMask`. Subsequent reads from it will return its default value. + mutating func clearRequiredNoMask() {_uniqueStorage()._requiredNoMask = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// Test that we can use NestedMessage from outside TestAllTypes. +struct EditionUnittest_TestForeignNested: Sendable { + // 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 foreignNested: EditionUnittest_TestAllTypes.NestedMessage { + get {_foreignNested ?? EditionUnittest_TestAllTypes.NestedMessage()} + set {_foreignNested = newValue} + } + /// Returns true if `foreignNested` has been explicitly set. + var hasForeignNested: Bool {self._foreignNested != nil} + /// Clears the value of `foreignNested`. Subsequent reads from it will return its default value. + mutating func clearForeignNested() {self._foreignNested = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _foreignNested: EditionUnittest_TestAllTypes.NestedMessage? = nil +} + +/// TestEmptyMessage is used to test unknown field support. +struct EditionUnittest_TestEmptyMessage: Sendable { + // 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() {} +} + +/// Like above, but declare all field numbers as potential extensions. No +/// actual extensions should ever be defined for this type. +struct EditionUnittest_TestEmptyMessageWithExtensions: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +/// Needed for a Python test. +struct EditionUnittest_TestPickleNestedMessage: Sendable { + // 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() + + struct NestedMessage: Sendable { + // 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 bb: Int32 { + get {_bb ?? 0} + set {_bb = newValue} + } + /// Returns true if `bb` has been explicitly set. + var hasBb: Bool {self._bb != nil} + /// Clears the value of `bb`. Subsequent reads from it will return its default value. + mutating func clearBb() {self._bb = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct NestedNestedMessage: Sendable { + // 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 cc: Int32 { + get {_cc ?? 0} + set {_cc = newValue} + } + /// Returns true if `cc` has been explicitly set. + var hasCc: Bool {self._cc != nil} + /// Clears the value of `cc`. Subsequent reads from it will return its default value. + mutating func clearCc() {self._cc = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _cc: Int32? = nil + } + + init() {} + + fileprivate var _bb: Int32? = nil + } + + init() {} +} + +struct EditionUnittest_TestMultipleExtensionRanges: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +/// Test that really large tag numbers don't break anything. +struct EditionUnittest_TestReallyLargeTagNumber: Sendable { + // 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. + + /// The largest possible tag number is 2^28 - 1, since the wire format uses + /// three bits to communicate wire type. + var a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var bb: Int32 { + get {_bb ?? 0} + set {_bb = newValue} + } + /// Returns true if `bb` has been explicitly set. + var hasBb: Bool {self._bb != nil} + /// Clears the value of `bb`. Subsequent reads from it will return its default value. + mutating func clearBb() {self._bb = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _bb: Int32? = nil +} + +struct EditionUnittest_TestRecursiveMessage: @unchecked Sendable { + // 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 a: EditionUnittest_TestRecursiveMessage { + get {_storage._a ?? EditionUnittest_TestRecursiveMessage()} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var i: Int32 { + get {_storage._i ?? 0} + set {_uniqueStorage()._i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {_storage._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {_uniqueStorage()._i = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// Test that mutual recursion works. +struct EditionUnittest_TestMutualRecursionA: @unchecked Sendable { + // 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 bb: EditionUnittest_TestMutualRecursionB { + get {_storage._bb ?? EditionUnittest_TestMutualRecursionB()} + set {_uniqueStorage()._bb = newValue} + } + /// Returns true if `bb` has been explicitly set. + var hasBb: Bool {_storage._bb != nil} + /// Clears the value of `bb`. Subsequent reads from it will return its default value. + mutating func clearBb() {_uniqueStorage()._bb = nil} + + var subGroup: EditionUnittest_TestMutualRecursionA.SubGroup { + get {_storage._subGroup ?? EditionUnittest_TestMutualRecursionA.SubGroup()} + set {_uniqueStorage()._subGroup = newValue} + } + /// Returns true if `subGroup` has been explicitly set. + var hasSubGroup: Bool {_storage._subGroup != nil} + /// Clears the value of `subGroup`. Subsequent reads from it will return its default value. + mutating func clearSubGroup() {_uniqueStorage()._subGroup = nil} + + var subGroupR: [EditionUnittest_TestMutualRecursionA.SubGroupR] { + get {_storage._subGroupR} + set {_uniqueStorage()._subGroupR = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct SubMessage: @unchecked Sendable { + // 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 b: EditionUnittest_TestMutualRecursionB { + get {_storage._b ?? EditionUnittest_TestMutualRecursionB()} + set {_uniqueStorage()._b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {_storage._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {_uniqueStorage()._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + struct SubGroup: @unchecked Sendable { + // 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. + + /// Needed because of bug in javatest + var subMessage: EditionUnittest_TestMutualRecursionA.SubMessage { + get {_storage._subMessage ?? EditionUnittest_TestMutualRecursionA.SubMessage()} + set {_uniqueStorage()._subMessage = newValue} + } + /// Returns true if `subMessage` has been explicitly set. + var hasSubMessage: Bool {_storage._subMessage != nil} + /// Clears the value of `subMessage`. Subsequent reads from it will return its default value. + mutating func clearSubMessage() {_uniqueStorage()._subMessage = nil} + + var notInThisScc: EditionUnittest_TestAllTypes { + get {_storage._notInThisScc ?? EditionUnittest_TestAllTypes()} + set {_uniqueStorage()._notInThisScc = newValue} + } + /// Returns true if `notInThisScc` has been explicitly set. + var hasNotInThisScc: Bool {_storage._notInThisScc != nil} + /// Clears the value of `notInThisScc`. Subsequent reads from it will return its default value. + mutating func clearNotInThisScc() {_uniqueStorage()._notInThisScc = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + struct SubGroupR: Sendable { + // 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 payload: EditionUnittest_TestAllTypes { + get {_payload ?? EditionUnittest_TestAllTypes()} + set {_payload = newValue} + } + /// Returns true if `payload` has been explicitly set. + var hasPayload: Bool {self._payload != nil} + /// Clears the value of `payload`. Subsequent reads from it will return its default value. + mutating func clearPayload() {self._payload = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _payload: EditionUnittest_TestAllTypes? = nil + } + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct EditionUnittest_TestMutualRecursionB: @unchecked Sendable { + // 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 a: EditionUnittest_TestMutualRecursionA { + get {_storage._a ?? EditionUnittest_TestMutualRecursionA()} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var optionalInt32: Int32 { + get {_storage._optionalInt32 ?? 0} + set {_uniqueStorage()._optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct EditionUnittest_TestIsInitialized: Sendable { + // 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 subMessage: EditionUnittest_TestIsInitialized.SubMessage { + get {_subMessage ?? EditionUnittest_TestIsInitialized.SubMessage()} + set {_subMessage = newValue} + } + /// Returns true if `subMessage` has been explicitly set. + var hasSubMessage: Bool {self._subMessage != nil} + /// Clears the value of `subMessage`. Subsequent reads from it will return its default value. + mutating func clearSubMessage() {self._subMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct SubMessage: Sendable { + // 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 subGroup: EditionUnittest_TestIsInitialized.SubMessage.SubGroup { + get {_subGroup ?? EditionUnittest_TestIsInitialized.SubMessage.SubGroup()} + set {_subGroup = newValue} + } + /// Returns true if `subGroup` has been explicitly set. + var hasSubGroup: Bool {self._subGroup != nil} + /// Clears the value of `subGroup`. Subsequent reads from it will return its default value. + mutating func clearSubGroup() {self._subGroup = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct SubGroup: Sendable { + // 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 i: Int32 { + get {_i ?? 0} + set {_i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {self._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {self._i = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _i: Int32? = nil + } + + init() {} + + fileprivate var _subGroup: EditionUnittest_TestIsInitialized.SubMessage.SubGroup? = nil + } + + init() {} + + fileprivate var _subMessage: EditionUnittest_TestIsInitialized.SubMessage? = nil +} + +/// Test that groups have disjoint field numbers from their siblings and +/// parents. This is NOT possible in proto1; only google.protobuf. When attempting +/// to compile with proto1, this will emit an error; so we only include it +/// in proto2_unittest_proto. +struct EditionUnittest_TestDupFieldNumber: Sendable { + // 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. + + /// NO_PROTO1 + var a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var foo: EditionUnittest_TestDupFieldNumber.Foo { + get {_foo ?? EditionUnittest_TestDupFieldNumber.Foo()} + set {_foo = newValue} + } + /// Returns true if `foo` has been explicitly set. + var hasFoo: Bool {self._foo != nil} + /// Clears the value of `foo`. Subsequent reads from it will return its default value. + mutating func clearFoo() {self._foo = nil} + + var bar: EditionUnittest_TestDupFieldNumber.Bar { + get {_bar ?? EditionUnittest_TestDupFieldNumber.Bar()} + set {_bar = newValue} + } + /// Returns true if `bar` has been explicitly set. + var hasBar: Bool {self._bar != nil} + /// Clears the value of `bar`. Subsequent reads from it will return its default value. + mutating func clearBar() {self._bar = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct Foo: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + struct Bar: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _foo: EditionUnittest_TestDupFieldNumber.Foo? = nil + fileprivate var _bar: EditionUnittest_TestDupFieldNumber.Bar? = nil +} + +/// Additional messages for testing lazy fields. +struct EditionUnittest_TestEagerMessage: Sendable { + // 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 subMessage: EditionUnittest_TestAllTypes { + get {_subMessage ?? EditionUnittest_TestAllTypes()} + set {_subMessage = newValue} + } + /// Returns true if `subMessage` has been explicitly set. + var hasSubMessage: Bool {self._subMessage != nil} + /// Clears the value of `subMessage`. Subsequent reads from it will return its default value. + mutating func clearSubMessage() {self._subMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _subMessage: EditionUnittest_TestAllTypes? = nil +} + +struct EditionUnittest_TestLazyMessage: Sendable { + // 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 subMessage: EditionUnittest_TestAllTypes { + get {_subMessage ?? EditionUnittest_TestAllTypes()} + set {_subMessage = newValue} + } + /// Returns true if `subMessage` has been explicitly set. + var hasSubMessage: Bool {self._subMessage != nil} + /// Clears the value of `subMessage`. Subsequent reads from it will return its default value. + mutating func clearSubMessage() {self._subMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _subMessage: EditionUnittest_TestAllTypes? = nil +} + +struct EditionUnittest_TestLazyMessageRepeated: Sendable { + // 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 repeatedMessage: [EditionUnittest_TestLazyMessage] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct EditionUnittest_TestEagerMaybeLazy: Sendable { + // 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 messageFoo: EditionUnittest_TestAllTypes { + get {_messageFoo ?? EditionUnittest_TestAllTypes()} + set {_messageFoo = newValue} + } + /// Returns true if `messageFoo` has been explicitly set. + var hasMessageFoo: Bool {self._messageFoo != nil} + /// Clears the value of `messageFoo`. Subsequent reads from it will return its default value. + mutating func clearMessageFoo() {self._messageFoo = nil} + + var messageBar: EditionUnittest_TestAllTypes { + get {_messageBar ?? EditionUnittest_TestAllTypes()} + set {_messageBar = newValue} + } + /// Returns true if `messageBar` has been explicitly set. + var hasMessageBar: Bool {self._messageBar != nil} + /// Clears the value of `messageBar`. Subsequent reads from it will return its default value. + mutating func clearMessageBar() {self._messageBar = nil} + + var messageBaz: EditionUnittest_TestEagerMaybeLazy.NestedMessage { + get {_messageBaz ?? EditionUnittest_TestEagerMaybeLazy.NestedMessage()} + set {_messageBaz = newValue} + } + /// Returns true if `messageBaz` has been explicitly set. + var hasMessageBaz: Bool {self._messageBaz != nil} + /// Clears the value of `messageBaz`. Subsequent reads from it will return its default value. + mutating func clearMessageBaz() {self._messageBaz = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct NestedMessage: Sendable { + // 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 packed: EditionUnittest_TestPackedTypes { + get {_packed ?? EditionUnittest_TestPackedTypes()} + set {_packed = newValue} + } + /// Returns true if `packed` has been explicitly set. + var hasPacked: Bool {self._packed != nil} + /// Clears the value of `packed`. Subsequent reads from it will return its default value. + mutating func clearPacked() {self._packed = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _packed: EditionUnittest_TestPackedTypes? = nil + } + + init() {} + + fileprivate var _messageFoo: EditionUnittest_TestAllTypes? = nil + fileprivate var _messageBar: EditionUnittest_TestAllTypes? = nil + fileprivate var _messageBaz: EditionUnittest_TestEagerMaybeLazy.NestedMessage? = nil +} + +/// Needed for a Python test. +struct EditionUnittest_TestNestedMessageHasBits: Sendable { + // 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 optionalNestedMessage: EditionUnittest_TestNestedMessageHasBits.NestedMessage { + get {_optionalNestedMessage ?? EditionUnittest_TestNestedMessageHasBits.NestedMessage()} + set {_optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {self._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {self._optionalNestedMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct NestedMessage: Sendable { + // 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 nestedmessageRepeatedInt32: [Int32] = [] + + var nestedmessageRepeatedForeignmessage: [EditionUnittest_ForeignMessage] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + init() {} + + fileprivate var _optionalNestedMessage: EditionUnittest_TestNestedMessageHasBits.NestedMessage? = nil +} + +/// Test message with CamelCase field names. This violates Protocol Buffer +/// standard style. +struct EditionUnittest_TestCamelCaseFieldNames: Sendable { + // 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 primitiveField: Int32 { + get {_primitiveField ?? 0} + set {_primitiveField = newValue} + } + /// Returns true if `primitiveField` has been explicitly set. + var hasPrimitiveField: Bool {self._primitiveField != nil} + /// Clears the value of `primitiveField`. Subsequent reads from it will return its default value. + mutating func clearPrimitiveField() {self._primitiveField = nil} + + var stringField: String { + get {_stringField ?? String()} + set {_stringField = newValue} + } + /// Returns true if `stringField` has been explicitly set. + var hasStringField: Bool {self._stringField != nil} + /// Clears the value of `stringField`. Subsequent reads from it will return its default value. + mutating func clearStringField() {self._stringField = nil} + + var enumField: EditionUnittest_ForeignEnum { + get {_enumField ?? .foreignFoo} + set {_enumField = newValue} + } + /// Returns true if `enumField` has been explicitly set. + var hasEnumField: Bool {self._enumField != nil} + /// Clears the value of `enumField`. Subsequent reads from it will return its default value. + mutating func clearEnumField() {self._enumField = nil} + + var messageField: EditionUnittest_ForeignMessage { + get {_messageField ?? EditionUnittest_ForeignMessage()} + set {_messageField = newValue} + } + /// Returns true if `messageField` has been explicitly set. + var hasMessageField: Bool {self._messageField != nil} + /// Clears the value of `messageField`. Subsequent reads from it will return its default value. + mutating func clearMessageField() {self._messageField = nil} + + var stringPieceField: String { + get {_stringPieceField ?? String()} + set {_stringPieceField = newValue} + } + /// Returns true if `stringPieceField` has been explicitly set. + var hasStringPieceField: Bool {self._stringPieceField != nil} + /// Clears the value of `stringPieceField`. Subsequent reads from it will return its default value. + mutating func clearStringPieceField() {self._stringPieceField = nil} + + var cordField: String { + get {_cordField ?? String()} + set {_cordField = newValue} + } + /// Returns true if `cordField` has been explicitly set. + var hasCordField: Bool {self._cordField != nil} + /// Clears the value of `cordField`. Subsequent reads from it will return its default value. + mutating func clearCordField() {self._cordField = nil} + + var repeatedPrimitiveField: [Int32] = [] + + var repeatedStringField: [String] = [] + + var repeatedEnumField: [EditionUnittest_ForeignEnum] = [] + + var repeatedMessageField: [EditionUnittest_ForeignMessage] = [] + + var repeatedStringPieceField: [String] = [] + + var repeatedCordField: [String] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _primitiveField: Int32? = nil + fileprivate var _stringField: String? = nil + fileprivate var _enumField: EditionUnittest_ForeignEnum? = nil + fileprivate var _messageField: EditionUnittest_ForeignMessage? = nil + fileprivate var _stringPieceField: String? = nil + fileprivate var _cordField: String? = nil +} + +/// We list fields out of order, to ensure that we're using field number and not +/// field index to determine serialization order. +struct EditionUnittest_TestFieldOrderings: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 myString: String { + get {_myString ?? String()} + set {_myString = newValue} + } + /// Returns true if `myString` has been explicitly set. + var hasMyString: Bool {self._myString != nil} + /// Clears the value of `myString`. Subsequent reads from it will return its default value. + mutating func clearMyString() {self._myString = nil} + + var myInt: Int64 { + get {_myInt ?? 0} + set {_myInt = newValue} + } + /// Returns true if `myInt` has been explicitly set. + var hasMyInt: Bool {self._myInt != nil} + /// Clears the value of `myInt`. Subsequent reads from it will return its default value. + mutating func clearMyInt() {self._myInt = nil} + + var myFloat: Float { + get {_myFloat ?? 0} + set {_myFloat = newValue} + } + /// Returns true if `myFloat` has been explicitly set. + var hasMyFloat: Bool {self._myFloat != nil} + /// Clears the value of `myFloat`. Subsequent reads from it will return its default value. + mutating func clearMyFloat() {self._myFloat = nil} + + var optionalNestedMessage: EditionUnittest_TestFieldOrderings.NestedMessage { + get {_optionalNestedMessage ?? EditionUnittest_TestFieldOrderings.NestedMessage()} + set {_optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {self._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {self._optionalNestedMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct NestedMessage: Sendable { + // 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 oo: Int64 { + get {_oo ?? 0} + set {_oo = newValue} + } + /// Returns true if `oo` has been explicitly set. + var hasOo: Bool {self._oo != nil} + /// Clears the value of `oo`. Subsequent reads from it will return its default value. + mutating func clearOo() {self._oo = nil} + + /// The field name "b" fails to compile in proto1 because it conflicts with + /// a local variable named "b" in one of the generated methods. Doh. + /// This file needs to compile in proto1 to test backwards-compatibility. + var bb: Int32 { + get {_bb ?? 0} + set {_bb = newValue} + } + /// Returns true if `bb` has been explicitly set. + var hasBb: Bool {self._bb != nil} + /// Clears the value of `bb`. Subsequent reads from it will return its default value. + mutating func clearBb() {self._bb = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _oo: Int64? = nil + fileprivate var _bb: Int32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _myString: String? = nil + fileprivate var _myInt: Int64? = nil + fileprivate var _myFloat: Float? = nil + fileprivate var _optionalNestedMessage: EditionUnittest_TestFieldOrderings.NestedMessage? = nil +} + +struct EditionUnittest_TestExtensionOrderings1: Sendable { + // 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 myString: String { + get {_myString ?? String()} + set {_myString = newValue} + } + /// Returns true if `myString` has been explicitly set. + var hasMyString: Bool {self._myString != nil} + /// Clears the value of `myString`. Subsequent reads from it will return its default value. + mutating func clearMyString() {self._myString = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _myString: String? = nil +} + +struct EditionUnittest_TestExtensionOrderings2: Sendable { + // 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 myString: String { + get {_myString ?? String()} + set {_myString = newValue} + } + /// Returns true if `myString` has been explicitly set. + var hasMyString: Bool {self._myString != nil} + /// Clears the value of `myString`. Subsequent reads from it will return its default value. + mutating func clearMyString() {self._myString = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct TestExtensionOrderings3: Sendable { + // 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 myString: String { + get {_myString ?? String()} + set {_myString = newValue} + } + /// Returns true if `myString` has been explicitly set. + var hasMyString: Bool {self._myString != nil} + /// Clears the value of `myString`. Subsequent reads from it will return its default value. + mutating func clearMyString() {self._myString = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _myString: String? = nil + } + + init() {} + + fileprivate var _myString: String? = nil +} + +struct EditionUnittest_TestExtremeDefaultValues: @unchecked Sendable { + // 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 escapedBytes: Data { + get {_storage._escapedBytes ?? Data([0, 1, 7, 8, 12, 10, 13, 9, 11, 92, 39, 34, 254])} + set {_uniqueStorage()._escapedBytes = newValue} + } + /// Returns true if `escapedBytes` has been explicitly set. + var hasEscapedBytes: Bool {_storage._escapedBytes != nil} + /// Clears the value of `escapedBytes`. Subsequent reads from it will return its default value. + mutating func clearEscapedBytes() {_uniqueStorage()._escapedBytes = nil} + + var largeUint32: UInt32 { + get {_storage._largeUint32 ?? 4294967295} + set {_uniqueStorage()._largeUint32 = newValue} + } + /// Returns true if `largeUint32` has been explicitly set. + var hasLargeUint32: Bool {_storage._largeUint32 != nil} + /// Clears the value of `largeUint32`. Subsequent reads from it will return its default value. + mutating func clearLargeUint32() {_uniqueStorage()._largeUint32 = nil} + + var largeUint64: UInt64 { + get {_storage._largeUint64 ?? 18446744073709551615} + set {_uniqueStorage()._largeUint64 = newValue} + } + /// Returns true if `largeUint64` has been explicitly set. + var hasLargeUint64: Bool {_storage._largeUint64 != nil} + /// Clears the value of `largeUint64`. Subsequent reads from it will return its default value. + mutating func clearLargeUint64() {_uniqueStorage()._largeUint64 = nil} + + var smallInt32: Int32 { + get {_storage._smallInt32 ?? -2147483647} + set {_uniqueStorage()._smallInt32 = newValue} + } + /// Returns true if `smallInt32` has been explicitly set. + var hasSmallInt32: Bool {_storage._smallInt32 != nil} + /// Clears the value of `smallInt32`. Subsequent reads from it will return its default value. + mutating func clearSmallInt32() {_uniqueStorage()._smallInt32 = nil} + + var smallInt64: Int64 { + get {_storage._smallInt64 ?? -9223372036854775807} + set {_uniqueStorage()._smallInt64 = newValue} + } + /// Returns true if `smallInt64` has been explicitly set. + var hasSmallInt64: Bool {_storage._smallInt64 != nil} + /// Clears the value of `smallInt64`. Subsequent reads from it will return its default value. + mutating func clearSmallInt64() {_uniqueStorage()._smallInt64 = nil} + + var reallySmallInt32: Int32 { + get {_storage._reallySmallInt32 ?? -2147483648} + set {_uniqueStorage()._reallySmallInt32 = newValue} + } + /// Returns true if `reallySmallInt32` has been explicitly set. + var hasReallySmallInt32: Bool {_storage._reallySmallInt32 != nil} + /// Clears the value of `reallySmallInt32`. Subsequent reads from it will return its default value. + mutating func clearReallySmallInt32() {_uniqueStorage()._reallySmallInt32 = nil} + + var reallySmallInt64: Int64 { + get {_storage._reallySmallInt64 ?? -9223372036854775808} + set {_uniqueStorage()._reallySmallInt64 = newValue} + } + /// Returns true if `reallySmallInt64` has been explicitly set. + var hasReallySmallInt64: Bool {_storage._reallySmallInt64 != nil} + /// Clears the value of `reallySmallInt64`. Subsequent reads from it will return its default value. + mutating func clearReallySmallInt64() {_uniqueStorage()._reallySmallInt64 = nil} + + /// The default value here is UTF-8 for "\u1234". (We could also just type + /// the UTF-8 text directly into this text file rather than escape it, but + /// lots of people use editors that would be confused by this.) + var utf8String: String { + get {_storage._utf8String ?? "ሴ"} + set {_uniqueStorage()._utf8String = newValue} + } + /// Returns true if `utf8String` has been explicitly set. + var hasUtf8String: Bool {_storage._utf8String != nil} + /// Clears the value of `utf8String`. Subsequent reads from it will return its default value. + mutating func clearUtf8String() {_uniqueStorage()._utf8String = nil} + + /// Tests for single-precision floating-point values. + var zeroFloat: Float { + get {_storage._zeroFloat ?? 0} + set {_uniqueStorage()._zeroFloat = newValue} + } + /// Returns true if `zeroFloat` has been explicitly set. + var hasZeroFloat: Bool {_storage._zeroFloat != nil} + /// Clears the value of `zeroFloat`. Subsequent reads from it will return its default value. + mutating func clearZeroFloat() {_uniqueStorage()._zeroFloat = nil} + + var oneFloat: Float { + get {_storage._oneFloat ?? 1} + set {_uniqueStorage()._oneFloat = newValue} + } + /// Returns true if `oneFloat` has been explicitly set. + var hasOneFloat: Bool {_storage._oneFloat != nil} + /// Clears the value of `oneFloat`. Subsequent reads from it will return its default value. + mutating func clearOneFloat() {_uniqueStorage()._oneFloat = nil} + + var smallFloat: Float { + get {_storage._smallFloat ?? 1.5} + set {_uniqueStorage()._smallFloat = newValue} + } + /// Returns true if `smallFloat` has been explicitly set. + var hasSmallFloat: Bool {_storage._smallFloat != nil} + /// Clears the value of `smallFloat`. Subsequent reads from it will return its default value. + mutating func clearSmallFloat() {_uniqueStorage()._smallFloat = nil} + + var negativeOneFloat: Float { + get {_storage._negativeOneFloat ?? -1} + set {_uniqueStorage()._negativeOneFloat = newValue} + } + /// Returns true if `negativeOneFloat` has been explicitly set. + var hasNegativeOneFloat: Bool {_storage._negativeOneFloat != nil} + /// Clears the value of `negativeOneFloat`. Subsequent reads from it will return its default value. + mutating func clearNegativeOneFloat() {_uniqueStorage()._negativeOneFloat = nil} + + var negativeFloat: Float { + get {_storage._negativeFloat ?? -1.5} + set {_uniqueStorage()._negativeFloat = newValue} + } + /// Returns true if `negativeFloat` has been explicitly set. + var hasNegativeFloat: Bool {_storage._negativeFloat != nil} + /// Clears the value of `negativeFloat`. Subsequent reads from it will return its default value. + mutating func clearNegativeFloat() {_uniqueStorage()._negativeFloat = nil} + + /// Using exponents + var largeFloat: Float { + get {_storage._largeFloat ?? 2e+08} + set {_uniqueStorage()._largeFloat = newValue} + } + /// Returns true if `largeFloat` has been explicitly set. + var hasLargeFloat: Bool {_storage._largeFloat != nil} + /// Clears the value of `largeFloat`. Subsequent reads from it will return its default value. + mutating func clearLargeFloat() {_uniqueStorage()._largeFloat = nil} + + var smallNegativeFloat: Float { + get {_storage._smallNegativeFloat ?? -8e-28} + set {_uniqueStorage()._smallNegativeFloat = newValue} + } + /// Returns true if `smallNegativeFloat` has been explicitly set. + var hasSmallNegativeFloat: Bool {_storage._smallNegativeFloat != nil} + /// Clears the value of `smallNegativeFloat`. Subsequent reads from it will return its default value. + mutating func clearSmallNegativeFloat() {_uniqueStorage()._smallNegativeFloat = nil} + + /// Text for nonfinite floating-point values. + var infDouble: Double { + get {_storage._infDouble ?? Double.infinity} + set {_uniqueStorage()._infDouble = newValue} + } + /// Returns true if `infDouble` has been explicitly set. + var hasInfDouble: Bool {_storage._infDouble != nil} + /// Clears the value of `infDouble`. Subsequent reads from it will return its default value. + mutating func clearInfDouble() {_uniqueStorage()._infDouble = nil} + + var negInfDouble: Double { + get {_storage._negInfDouble ?? -Double.infinity} + set {_uniqueStorage()._negInfDouble = newValue} + } + /// Returns true if `negInfDouble` has been explicitly set. + var hasNegInfDouble: Bool {_storage._negInfDouble != nil} + /// Clears the value of `negInfDouble`. Subsequent reads from it will return its default value. + mutating func clearNegInfDouble() {_uniqueStorage()._negInfDouble = nil} + + var nanDouble: Double { + get {_storage._nanDouble ?? Double.nan} + set {_uniqueStorage()._nanDouble = newValue} + } + /// Returns true if `nanDouble` has been explicitly set. + var hasNanDouble: Bool {_storage._nanDouble != nil} + /// Clears the value of `nanDouble`. Subsequent reads from it will return its default value. + mutating func clearNanDouble() {_uniqueStorage()._nanDouble = nil} + + var infFloat: Float { + get {_storage._infFloat ?? Float.infinity} + set {_uniqueStorage()._infFloat = newValue} + } + /// Returns true if `infFloat` has been explicitly set. + var hasInfFloat: Bool {_storage._infFloat != nil} + /// Clears the value of `infFloat`. Subsequent reads from it will return its default value. + mutating func clearInfFloat() {_uniqueStorage()._infFloat = nil} + + var negInfFloat: Float { + get {_storage._negInfFloat ?? -Float.infinity} + set {_uniqueStorage()._negInfFloat = newValue} + } + /// Returns true if `negInfFloat` has been explicitly set. + var hasNegInfFloat: Bool {_storage._negInfFloat != nil} + /// Clears the value of `negInfFloat`. Subsequent reads from it will return its default value. + mutating func clearNegInfFloat() {_uniqueStorage()._negInfFloat = nil} + + var nanFloat: Float { + get {_storage._nanFloat ?? Float.nan} + set {_uniqueStorage()._nanFloat = newValue} + } + /// Returns true if `nanFloat` has been explicitly set. + var hasNanFloat: Bool {_storage._nanFloat != nil} + /// Clears the value of `nanFloat`. Subsequent reads from it will return its default value. + mutating func clearNanFloat() {_uniqueStorage()._nanFloat = nil} + + /// Tests for C++ trigraphs. + /// Trigraphs should be escaped in C++ generated files, but they should not be + /// escaped for other languages. + /// Note that in .proto file, "\?" is a valid way to escape ? in string + /// literals. + var cppTrigraph: String { + get {_storage._cppTrigraph ?? "? ? ?? ?? ??? ??/ ??-"} + set {_uniqueStorage()._cppTrigraph = newValue} + } + /// Returns true if `cppTrigraph` has been explicitly set. + var hasCppTrigraph: Bool {_storage._cppTrigraph != nil} + /// Clears the value of `cppTrigraph`. Subsequent reads from it will return its default value. + mutating func clearCppTrigraph() {_uniqueStorage()._cppTrigraph = nil} + + /// String defaults containing the character '\000' + var stringWithZero: String { + get {_storage._stringWithZero ?? "hel\0lo"} + set {_uniqueStorage()._stringWithZero = newValue} + } + /// Returns true if `stringWithZero` has been explicitly set. + var hasStringWithZero: Bool {_storage._stringWithZero != nil} + /// Clears the value of `stringWithZero`. Subsequent reads from it will return its default value. + mutating func clearStringWithZero() {_uniqueStorage()._stringWithZero = nil} + + var bytesWithZero: Data { + get {_storage._bytesWithZero ?? Data([119, 111, 114, 0, 108, 100])} + set {_uniqueStorage()._bytesWithZero = newValue} + } + /// Returns true if `bytesWithZero` has been explicitly set. + var hasBytesWithZero: Bool {_storage._bytesWithZero != nil} + /// Clears the value of `bytesWithZero`. Subsequent reads from it will return its default value. + mutating func clearBytesWithZero() {_uniqueStorage()._bytesWithZero = nil} + + var stringPieceWithZero: String { + get {_storage._stringPieceWithZero ?? "ab\0c"} + set {_uniqueStorage()._stringPieceWithZero = newValue} + } + /// Returns true if `stringPieceWithZero` has been explicitly set. + var hasStringPieceWithZero: Bool {_storage._stringPieceWithZero != nil} + /// Clears the value of `stringPieceWithZero`. Subsequent reads from it will return its default value. + mutating func clearStringPieceWithZero() {_uniqueStorage()._stringPieceWithZero = nil} + + var cordWithZero: String { + get {_storage._cordWithZero ?? "12\03"} + set {_uniqueStorage()._cordWithZero = newValue} + } + /// Returns true if `cordWithZero` has been explicitly set. + var hasCordWithZero: Bool {_storage._cordWithZero != nil} + /// Clears the value of `cordWithZero`. Subsequent reads from it will return its default value. + mutating func clearCordWithZero() {_uniqueStorage()._cordWithZero = nil} + + var replacementString: String { + get {_storage._replacementString ?? "${unknown}"} + set {_uniqueStorage()._replacementString = newValue} + } + /// Returns true if `replacementString` has been explicitly set. + var hasReplacementString: Bool {_storage._replacementString != nil} + /// Clears the value of `replacementString`. Subsequent reads from it will return its default value. + mutating func clearReplacementString() {_uniqueStorage()._replacementString = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct EditionUnittest_SparseEnumMessage: Sendable { + // 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 sparseEnum: EditionUnittest_TestSparseEnum { + get {_sparseEnum ?? .sparseA} + set {_sparseEnum = newValue} + } + /// Returns true if `sparseEnum` has been explicitly set. + var hasSparseEnum: Bool {self._sparseEnum != nil} + /// Clears the value of `sparseEnum`. Subsequent reads from it will return its default value. + mutating func clearSparseEnum() {self._sparseEnum = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _sparseEnum: EditionUnittest_TestSparseEnum? = nil +} + +/// Test String and Bytes: string is for valid UTF-8 strings +struct EditionUnittest_OneString: Sendable { + // 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 data: String { + get {_data ?? String()} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: String? = nil +} + +struct EditionUnittest_MoreString: Sendable { + // 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 data: [String] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct EditionUnittest_OneBytes: Sendable { + // 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 data: Data { + get {_data ?? Data()} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: Data? = nil +} + +struct EditionUnittest_MoreBytes: Sendable { + // 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 data: [Data] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct EditionUnittest_ManyOptionalString: @unchecked Sendable { + // 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 str1: String { + get {_storage._str1 ?? String()} + set {_uniqueStorage()._str1 = newValue} + } + /// Returns true if `str1` has been explicitly set. + var hasStr1: Bool {_storage._str1 != nil} + /// Clears the value of `str1`. Subsequent reads from it will return its default value. + mutating func clearStr1() {_uniqueStorage()._str1 = nil} + + var str2: String { + get {_storage._str2 ?? String()} + set {_uniqueStorage()._str2 = newValue} + } + /// Returns true if `str2` has been explicitly set. + var hasStr2: Bool {_storage._str2 != nil} + /// Clears the value of `str2`. Subsequent reads from it will return its default value. + mutating func clearStr2() {_uniqueStorage()._str2 = nil} + + var str3: String { + get {_storage._str3 ?? String()} + set {_uniqueStorage()._str3 = newValue} + } + /// Returns true if `str3` has been explicitly set. + var hasStr3: Bool {_storage._str3 != nil} + /// Clears the value of `str3`. Subsequent reads from it will return its default value. + mutating func clearStr3() {_uniqueStorage()._str3 = nil} + + var str4: String { + get {_storage._str4 ?? String()} + set {_uniqueStorage()._str4 = newValue} + } + /// Returns true if `str4` has been explicitly set. + var hasStr4: Bool {_storage._str4 != nil} + /// Clears the value of `str4`. Subsequent reads from it will return its default value. + mutating func clearStr4() {_uniqueStorage()._str4 = nil} + + var str5: String { + get {_storage._str5 ?? String()} + set {_uniqueStorage()._str5 = newValue} + } + /// Returns true if `str5` has been explicitly set. + var hasStr5: Bool {_storage._str5 != nil} + /// Clears the value of `str5`. Subsequent reads from it will return its default value. + mutating func clearStr5() {_uniqueStorage()._str5 = nil} + + var str6: String { + get {_storage._str6 ?? String()} + set {_uniqueStorage()._str6 = newValue} + } + /// Returns true if `str6` has been explicitly set. + var hasStr6: Bool {_storage._str6 != nil} + /// Clears the value of `str6`. Subsequent reads from it will return its default value. + mutating func clearStr6() {_uniqueStorage()._str6 = nil} + + var str7: String { + get {_storage._str7 ?? String()} + set {_uniqueStorage()._str7 = newValue} + } + /// Returns true if `str7` has been explicitly set. + var hasStr7: Bool {_storage._str7 != nil} + /// Clears the value of `str7`. Subsequent reads from it will return its default value. + mutating func clearStr7() {_uniqueStorage()._str7 = nil} + + var str8: String { + get {_storage._str8 ?? String()} + set {_uniqueStorage()._str8 = newValue} + } + /// Returns true if `str8` has been explicitly set. + var hasStr8: Bool {_storage._str8 != nil} + /// Clears the value of `str8`. Subsequent reads from it will return its default value. + mutating func clearStr8() {_uniqueStorage()._str8 = nil} + + var str9: String { + get {_storage._str9 ?? String()} + set {_uniqueStorage()._str9 = newValue} + } + /// Returns true if `str9` has been explicitly set. + var hasStr9: Bool {_storage._str9 != nil} + /// Clears the value of `str9`. Subsequent reads from it will return its default value. + mutating func clearStr9() {_uniqueStorage()._str9 = nil} + + var str10: String { + get {_storage._str10 ?? String()} + set {_uniqueStorage()._str10 = newValue} + } + /// Returns true if `str10` has been explicitly set. + var hasStr10: Bool {_storage._str10 != nil} + /// Clears the value of `str10`. Subsequent reads from it will return its default value. + mutating func clearStr10() {_uniqueStorage()._str10 = nil} + + var str11: String { + get {_storage._str11 ?? String()} + set {_uniqueStorage()._str11 = newValue} + } + /// Returns true if `str11` has been explicitly set. + var hasStr11: Bool {_storage._str11 != nil} + /// Clears the value of `str11`. Subsequent reads from it will return its default value. + mutating func clearStr11() {_uniqueStorage()._str11 = nil} + + var str12: String { + get {_storage._str12 ?? String()} + set {_uniqueStorage()._str12 = newValue} + } + /// Returns true if `str12` has been explicitly set. + var hasStr12: Bool {_storage._str12 != nil} + /// Clears the value of `str12`. Subsequent reads from it will return its default value. + mutating func clearStr12() {_uniqueStorage()._str12 = nil} + + var str13: String { + get {_storage._str13 ?? String()} + set {_uniqueStorage()._str13 = newValue} + } + /// Returns true if `str13` has been explicitly set. + var hasStr13: Bool {_storage._str13 != nil} + /// Clears the value of `str13`. Subsequent reads from it will return its default value. + mutating func clearStr13() {_uniqueStorage()._str13 = nil} + + var str14: String { + get {_storage._str14 ?? String()} + set {_uniqueStorage()._str14 = newValue} + } + /// Returns true if `str14` has been explicitly set. + var hasStr14: Bool {_storage._str14 != nil} + /// Clears the value of `str14`. Subsequent reads from it will return its default value. + mutating func clearStr14() {_uniqueStorage()._str14 = nil} + + var str15: String { + get {_storage._str15 ?? String()} + set {_uniqueStorage()._str15 = newValue} + } + /// Returns true if `str15` has been explicitly set. + var hasStr15: Bool {_storage._str15 != nil} + /// Clears the value of `str15`. Subsequent reads from it will return its default value. + mutating func clearStr15() {_uniqueStorage()._str15 = nil} + + var str16: String { + get {_storage._str16 ?? String()} + set {_uniqueStorage()._str16 = newValue} + } + /// Returns true if `str16` has been explicitly set. + var hasStr16: Bool {_storage._str16 != nil} + /// Clears the value of `str16`. Subsequent reads from it will return its default value. + mutating func clearStr16() {_uniqueStorage()._str16 = nil} + + var str17: String { + get {_storage._str17 ?? String()} + set {_uniqueStorage()._str17 = newValue} + } + /// Returns true if `str17` has been explicitly set. + var hasStr17: Bool {_storage._str17 != nil} + /// Clears the value of `str17`. Subsequent reads from it will return its default value. + mutating func clearStr17() {_uniqueStorage()._str17 = nil} + + var str18: String { + get {_storage._str18 ?? String()} + set {_uniqueStorage()._str18 = newValue} + } + /// Returns true if `str18` has been explicitly set. + var hasStr18: Bool {_storage._str18 != nil} + /// Clears the value of `str18`. Subsequent reads from it will return its default value. + mutating func clearStr18() {_uniqueStorage()._str18 = nil} + + var str19: String { + get {_storage._str19 ?? String()} + set {_uniqueStorage()._str19 = newValue} + } + /// Returns true if `str19` has been explicitly set. + var hasStr19: Bool {_storage._str19 != nil} + /// Clears the value of `str19`. Subsequent reads from it will return its default value. + mutating func clearStr19() {_uniqueStorage()._str19 = nil} + + var str20: String { + get {_storage._str20 ?? String()} + set {_uniqueStorage()._str20 = newValue} + } + /// Returns true if `str20` has been explicitly set. + var hasStr20: Bool {_storage._str20 != nil} + /// Clears the value of `str20`. Subsequent reads from it will return its default value. + mutating func clearStr20() {_uniqueStorage()._str20 = nil} + + var str21: String { + get {_storage._str21 ?? String()} + set {_uniqueStorage()._str21 = newValue} + } + /// Returns true if `str21` has been explicitly set. + var hasStr21: Bool {_storage._str21 != nil} + /// Clears the value of `str21`. Subsequent reads from it will return its default value. + mutating func clearStr21() {_uniqueStorage()._str21 = nil} + + var str22: String { + get {_storage._str22 ?? String()} + set {_uniqueStorage()._str22 = newValue} + } + /// Returns true if `str22` has been explicitly set. + var hasStr22: Bool {_storage._str22 != nil} + /// Clears the value of `str22`. Subsequent reads from it will return its default value. + mutating func clearStr22() {_uniqueStorage()._str22 = nil} + + var str23: String { + get {_storage._str23 ?? String()} + set {_uniqueStorage()._str23 = newValue} + } + /// Returns true if `str23` has been explicitly set. + var hasStr23: Bool {_storage._str23 != nil} + /// Clears the value of `str23`. Subsequent reads from it will return its default value. + mutating func clearStr23() {_uniqueStorage()._str23 = nil} + + var str24: String { + get {_storage._str24 ?? String()} + set {_uniqueStorage()._str24 = newValue} + } + /// Returns true if `str24` has been explicitly set. + var hasStr24: Bool {_storage._str24 != nil} + /// Clears the value of `str24`. Subsequent reads from it will return its default value. + mutating func clearStr24() {_uniqueStorage()._str24 = nil} + + var str25: String { + get {_storage._str25 ?? String()} + set {_uniqueStorage()._str25 = newValue} + } + /// Returns true if `str25` has been explicitly set. + var hasStr25: Bool {_storage._str25 != nil} + /// Clears the value of `str25`. Subsequent reads from it will return its default value. + mutating func clearStr25() {_uniqueStorage()._str25 = nil} + + var str26: String { + get {_storage._str26 ?? String()} + set {_uniqueStorage()._str26 = newValue} + } + /// Returns true if `str26` has been explicitly set. + var hasStr26: Bool {_storage._str26 != nil} + /// Clears the value of `str26`. Subsequent reads from it will return its default value. + mutating func clearStr26() {_uniqueStorage()._str26 = nil} + + var str27: String { + get {_storage._str27 ?? String()} + set {_uniqueStorage()._str27 = newValue} + } + /// Returns true if `str27` has been explicitly set. + var hasStr27: Bool {_storage._str27 != nil} + /// Clears the value of `str27`. Subsequent reads from it will return its default value. + mutating func clearStr27() {_uniqueStorage()._str27 = nil} + + var str28: String { + get {_storage._str28 ?? String()} + set {_uniqueStorage()._str28 = newValue} + } + /// Returns true if `str28` has been explicitly set. + var hasStr28: Bool {_storage._str28 != nil} + /// Clears the value of `str28`. Subsequent reads from it will return its default value. + mutating func clearStr28() {_uniqueStorage()._str28 = nil} + + var str29: String { + get {_storage._str29 ?? String()} + set {_uniqueStorage()._str29 = newValue} + } + /// Returns true if `str29` has been explicitly set. + var hasStr29: Bool {_storage._str29 != nil} + /// Clears the value of `str29`. Subsequent reads from it will return its default value. + mutating func clearStr29() {_uniqueStorage()._str29 = nil} + + var str30: String { + get {_storage._str30 ?? String()} + set {_uniqueStorage()._str30 = newValue} + } + /// Returns true if `str30` has been explicitly set. + var hasStr30: Bool {_storage._str30 != nil} + /// Clears the value of `str30`. Subsequent reads from it will return its default value. + mutating func clearStr30() {_uniqueStorage()._str30 = nil} + + var str31: String { + get {_storage._str31 ?? String()} + set {_uniqueStorage()._str31 = newValue} + } + /// Returns true if `str31` has been explicitly set. + var hasStr31: Bool {_storage._str31 != nil} + /// Clears the value of `str31`. Subsequent reads from it will return its default value. + mutating func clearStr31() {_uniqueStorage()._str31 = nil} + + var str32: String { + get {_storage._str32 ?? String()} + set {_uniqueStorage()._str32 = newValue} + } + /// Returns true if `str32` has been explicitly set. + var hasStr32: Bool {_storage._str32 != nil} + /// Clears the value of `str32`. Subsequent reads from it will return its default value. + mutating func clearStr32() {_uniqueStorage()._str32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// Test int32, uint32, int64, uint64, and bool are all compatible +struct EditionUnittest_Int32Message: Sendable { + // 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 data: Int32 { + get {_data ?? 0} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: Int32? = nil +} + +struct EditionUnittest_Uint32Message: Sendable { + // 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 data: UInt32 { + get {_data ?? 0} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: UInt32? = nil +} + +struct EditionUnittest_Int64Message: Sendable { + // 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 data: Int64 { + get {_data ?? 0} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: Int64? = nil +} + +struct EditionUnittest_Uint64Message: Sendable { + // 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 data: UInt64 { + get {_data ?? 0} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: UInt64? = nil +} + +struct EditionUnittest_BoolMessage: Sendable { + // 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 data: Bool { + get {_data ?? false} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: Bool? = nil +} + +/// Test oneofs. +struct EditionUnittest_TestOneof: Sendable { + // 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 foo: EditionUnittest_TestOneof.OneOf_Foo? = nil + + var fooInt: Int32 { + get { + if case .fooInt(let v)? = foo {return v} + return 0 + } + set {foo = .fooInt(newValue)} + } + + var fooString: String { + get { + if case .fooString(let v)? = foo {return v} + return String() + } + set {foo = .fooString(newValue)} + } + + var fooMessage: EditionUnittest_TestAllTypes { + get { + if case .fooMessage(let v)? = foo {return v} + return EditionUnittest_TestAllTypes() + } + set {foo = .fooMessage(newValue)} + } + + var fooGroup: EditionUnittest_TestOneof.FooGroup { + get { + if case .fooGroup(let v)? = foo {return v} + return EditionUnittest_TestOneof.FooGroup() + } + set {foo = .fooGroup(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_Foo: Equatable, Sendable { + case fooInt(Int32) + case fooString(String) + case fooMessage(EditionUnittest_TestAllTypes) + case fooGroup(EditionUnittest_TestOneof.FooGroup) + + } + + struct FooGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: String { + get {_b ?? String()} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: String? = nil + } + + init() {} +} + +struct EditionUnittest_TestOneofBackwardsCompatible: Sendable { + // 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 fooInt: Int32 { + get {_fooInt ?? 0} + set {_fooInt = newValue} + } + /// Returns true if `fooInt` has been explicitly set. + var hasFooInt: Bool {self._fooInt != nil} + /// Clears the value of `fooInt`. Subsequent reads from it will return its default value. + mutating func clearFooInt() {self._fooInt = nil} + + var fooString: String { + get {_fooString ?? String()} + set {_fooString = newValue} + } + /// Returns true if `fooString` has been explicitly set. + var hasFooString: Bool {self._fooString != nil} + /// Clears the value of `fooString`. Subsequent reads from it will return its default value. + mutating func clearFooString() {self._fooString = nil} + + var fooMessage: EditionUnittest_TestAllTypes { + get {_fooMessage ?? EditionUnittest_TestAllTypes()} + set {_fooMessage = newValue} + } + /// Returns true if `fooMessage` has been explicitly set. + var hasFooMessage: Bool {self._fooMessage != nil} + /// Clears the value of `fooMessage`. Subsequent reads from it will return its default value. + mutating func clearFooMessage() {self._fooMessage = nil} + + var fooGroup: EditionUnittest_TestOneofBackwardsCompatible.FooGroup { + get {_fooGroup ?? EditionUnittest_TestOneofBackwardsCompatible.FooGroup()} + set {_fooGroup = newValue} + } + /// Returns true if `fooGroup` has been explicitly set. + var hasFooGroup: Bool {self._fooGroup != nil} + /// Clears the value of `fooGroup`. Subsequent reads from it will return its default value. + mutating func clearFooGroup() {self._fooGroup = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct FooGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: String { + get {_b ?? String()} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: String? = nil + } + + init() {} + + fileprivate var _fooInt: Int32? = nil + fileprivate var _fooString: String? = nil + fileprivate var _fooMessage: EditionUnittest_TestAllTypes? = nil + fileprivate var _fooGroup: EditionUnittest_TestOneofBackwardsCompatible.FooGroup? = nil +} + +struct EditionUnittest_TestOneof2: Sendable { + // 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 foo: EditionUnittest_TestOneof2.OneOf_Foo? = nil + + var fooInt: Int32 { + get { + if case .fooInt(let v)? = foo {return v} + return 0 + } + set {foo = .fooInt(newValue)} + } + + var fooString: String { + get { + if case .fooString(let v)? = foo {return v} + return String() + } + set {foo = .fooString(newValue)} + } + + var fooCord: String { + get { + if case .fooCord(let v)? = foo {return v} + return String() + } + set {foo = .fooCord(newValue)} + } + + var fooStringPiece: String { + get { + if case .fooStringPiece(let v)? = foo {return v} + return String() + } + set {foo = .fooStringPiece(newValue)} + } + + var fooBytes: Data { + get { + if case .fooBytes(let v)? = foo {return v} + return Data() + } + set {foo = .fooBytes(newValue)} + } + + var fooEnum: EditionUnittest_TestOneof2.NestedEnum { + get { + if case .fooEnum(let v)? = foo {return v} + return .unknown + } + set {foo = .fooEnum(newValue)} + } + + var fooMessage: EditionUnittest_TestOneof2.NestedMessage { + get { + if case .fooMessage(let v)? = foo {return v} + return EditionUnittest_TestOneof2.NestedMessage() + } + set {foo = .fooMessage(newValue)} + } + + var fooGroup: EditionUnittest_TestOneof2.FooGroup { + get { + if case .fooGroup(let v)? = foo {return v} + return EditionUnittest_TestOneof2.FooGroup() + } + set {foo = .fooGroup(newValue)} + } + + var fooLazyMessage: EditionUnittest_TestOneof2.NestedMessage { + get { + if case .fooLazyMessage(let v)? = foo {return v} + return EditionUnittest_TestOneof2.NestedMessage() + } + set {foo = .fooLazyMessage(newValue)} + } + + var fooBytesCord: Data { + get { + if case .fooBytesCord(let v)? = foo {return v} + return Data() + } + set {foo = .fooBytesCord(newValue)} + } + + var bar: EditionUnittest_TestOneof2.OneOf_Bar? = nil + + var barInt: Int32 { + get { + if case .barInt(let v)? = bar {return v} + return 5 + } + set {bar = .barInt(newValue)} + } + + var barString: String { + get { + if case .barString(let v)? = bar {return v} + return "STRING" + } + set {bar = .barString(newValue)} + } + + var barCord: String { + get { + if case .barCord(let v)? = bar {return v} + return "CORD" + } + set {bar = .barCord(newValue)} + } + + var barStringPiece: String { + get { + if case .barStringPiece(let v)? = bar {return v} + return "SPIECE" + } + set {bar = .barStringPiece(newValue)} + } + + var barBytes: Data { + get { + if case .barBytes(let v)? = bar {return v} + return Data([66, 89, 84, 69, 83]) + } + set {bar = .barBytes(newValue)} + } + + var barEnum: EditionUnittest_TestOneof2.NestedEnum { + get { + if case .barEnum(let v)? = bar {return v} + return .bar + } + set {bar = .barEnum(newValue)} + } + + var barStringWithEmptyDefault: String { + get { + if case .barStringWithEmptyDefault(let v)? = bar {return v} + return String() + } + set {bar = .barStringWithEmptyDefault(newValue)} + } + + var barCordWithEmptyDefault: String { + get { + if case .barCordWithEmptyDefault(let v)? = bar {return v} + return String() + } + set {bar = .barCordWithEmptyDefault(newValue)} + } + + var barStringPieceWithEmptyDefault: String { + get { + if case .barStringPieceWithEmptyDefault(let v)? = bar {return v} + return String() + } + set {bar = .barStringPieceWithEmptyDefault(newValue)} + } + + var barBytesWithEmptyDefault: Data { + get { + if case .barBytesWithEmptyDefault(let v)? = bar {return v} + return Data() + } + set {bar = .barBytesWithEmptyDefault(newValue)} + } + + var bazInt: Int32 { + get {_bazInt ?? 0} + set {_bazInt = newValue} + } + /// Returns true if `bazInt` has been explicitly set. + var hasBazInt: Bool {self._bazInt != nil} + /// Clears the value of `bazInt`. Subsequent reads from it will return its default value. + mutating func clearBazInt() {self._bazInt = nil} + + var bazString: String { + get {_bazString ?? "BAZ"} + set {_bazString = newValue} + } + /// Returns true if `bazString` has been explicitly set. + var hasBazString: Bool {self._bazString != nil} + /// Clears the value of `bazString`. Subsequent reads from it will return its default value. + mutating func clearBazString() {self._bazString = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_Foo: Equatable, Sendable { + case fooInt(Int32) + case fooString(String) + case fooCord(String) + case fooStringPiece(String) + case fooBytes(Data) + case fooEnum(EditionUnittest_TestOneof2.NestedEnum) + case fooMessage(EditionUnittest_TestOneof2.NestedMessage) + case fooGroup(EditionUnittest_TestOneof2.FooGroup) + case fooLazyMessage(EditionUnittest_TestOneof2.NestedMessage) + case fooBytesCord(Data) + + } + + enum OneOf_Bar: Equatable, Sendable { + case barInt(Int32) + case barString(String) + case barCord(String) + case barStringPiece(String) + case barBytes(Data) + case barEnum(EditionUnittest_TestOneof2.NestedEnum) + case barStringWithEmptyDefault(String) + case barCordWithEmptyDefault(String) + case barStringPieceWithEmptyDefault(String) + case barBytesWithEmptyDefault(Data) + + } + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unknown = 0 + case foo = 1 + case bar = 2 + case baz = 3 + + init() { + self = .unknown + } + + } + + struct FooGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: String { + get {_b ?? String()} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: String? = nil + } + + struct NestedMessage: Sendable { + // 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 mooInt: Int64 { + get {_mooInt ?? 0} + set {_mooInt = newValue} + } + /// Returns true if `mooInt` has been explicitly set. + var hasMooInt: Bool {self._mooInt != nil} + /// Clears the value of `mooInt`. Subsequent reads from it will return its default value. + mutating func clearMooInt() {self._mooInt = nil} + + var corgeInt: [Int32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _mooInt: Int64? = nil + } + + init() {} + + fileprivate var _bazInt: Int32? = nil + fileprivate var _bazString: String? = nil +} + +struct EditionUnittest_TestRequiredOneof: Sendable { + // 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 foo: EditionUnittest_TestRequiredOneof.OneOf_Foo? = nil + + var fooInt: Int32 { + get { + if case .fooInt(let v)? = foo {return v} + return 0 + } + set {foo = .fooInt(newValue)} + } + + var fooString: String { + get { + if case .fooString(let v)? = foo {return v} + return String() + } + set {foo = .fooString(newValue)} + } + + var fooMessage: EditionUnittest_TestRequiredOneof.NestedMessage { + get { + if case .fooMessage(let v)? = foo {return v} + return EditionUnittest_TestRequiredOneof.NestedMessage() + } + set {foo = .fooMessage(newValue)} + } + + var fooLazyMessage: EditionUnittest_TestRequiredOneof.NestedMessage { + get { + if case .fooLazyMessage(let v)? = foo {return v} + return EditionUnittest_TestRequiredOneof.NestedMessage() + } + set {foo = .fooLazyMessage(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_Foo: Equatable, Sendable { + case fooInt(Int32) + case fooString(String) + case fooMessage(EditionUnittest_TestRequiredOneof.NestedMessage) + case fooLazyMessage(EditionUnittest_TestRequiredOneof.NestedMessage) + + fileprivate var isInitialized: 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 self { + case .fooMessage: return { + guard case .fooMessage(let v) = self else { preconditionFailure() } + return v.isInitialized + }() + case .fooLazyMessage: return { + guard case .fooLazyMessage(let v) = self else { preconditionFailure() } + return v.isInitialized + }() + default: return true + } + } + + } + + struct NestedMessage: Sendable { + // 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 requiredDouble: Double { + get {_requiredDouble ?? 0} + set {_requiredDouble = newValue} + } + /// Returns true if `requiredDouble` has been explicitly set. + var hasRequiredDouble: Bool {self._requiredDouble != nil} + /// Clears the value of `requiredDouble`. Subsequent reads from it will return its default value. + mutating func clearRequiredDouble() {self._requiredDouble = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _requiredDouble: Double? = nil + } + + init() {} +} + +struct EditionUnittest_TestPackedTypes: Sendable { + // 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 packedInt32: [Int32] = [] + + var packedInt64: [Int64] = [] + + var packedUint32: [UInt32] = [] + + var packedUint64: [UInt64] = [] + + var packedSint32: [Int32] = [] + + var packedSint64: [Int64] = [] + + var packedFixed32: [UInt32] = [] + + var packedFixed64: [UInt64] = [] + + var packedSfixed32: [Int32] = [] + + var packedSfixed64: [Int64] = [] + + var packedFloat: [Float] = [] + + var packedDouble: [Double] = [] + + var packedBool: [Bool] = [] + + var packedEnum: [EditionUnittest_ForeignEnum] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +/// A message with the same fields as TestPackedTypes, but without packing. Used +/// to test packed <-> unpacked wire compatibility. +struct EditionUnittest_TestUnpackedTypes: Sendable { + // 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 unpackedInt32: [Int32] = [] + + var unpackedInt64: [Int64] = [] + + var unpackedUint32: [UInt32] = [] + + var unpackedUint64: [UInt64] = [] + + var unpackedSint32: [Int32] = [] + + var unpackedSint64: [Int64] = [] + + var unpackedFixed32: [UInt32] = [] + + var unpackedFixed64: [UInt64] = [] + + var unpackedSfixed32: [Int32] = [] + + var unpackedSfixed64: [Int64] = [] + + var unpackedFloat: [Float] = [] + + var unpackedDouble: [Double] = [] + + var unpackedBool: [Bool] = [] + + var unpackedEnum: [EditionUnittest_ForeignEnum] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct EditionUnittest_TestPackedExtensions: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +struct EditionUnittest_TestUnpackedExtensions: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +/// Used by ExtensionSetTest/DynamicExtensions. The test actually builds +/// a set of extensions to TestAllExtensions dynamically, based on the fields +/// of this message type. +struct EditionUnittest_TestDynamicExtensions: Sendable { + // 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 scalarExtension: UInt32 { + get {_scalarExtension ?? 0} + set {_scalarExtension = newValue} + } + /// Returns true if `scalarExtension` has been explicitly set. + var hasScalarExtension: Bool {self._scalarExtension != nil} + /// Clears the value of `scalarExtension`. Subsequent reads from it will return its default value. + mutating func clearScalarExtension() {self._scalarExtension = nil} + + var enumExtension: EditionUnittest_ForeignEnum { + get {_enumExtension ?? .foreignFoo} + set {_enumExtension = newValue} + } + /// Returns true if `enumExtension` has been explicitly set. + var hasEnumExtension: Bool {self._enumExtension != nil} + /// Clears the value of `enumExtension`. Subsequent reads from it will return its default value. + mutating func clearEnumExtension() {self._enumExtension = nil} + + var dynamicEnumExtension: EditionUnittest_TestDynamicExtensions.DynamicEnumType { + get {_dynamicEnumExtension ?? .dynamicUnknown} + set {_dynamicEnumExtension = newValue} + } + /// Returns true if `dynamicEnumExtension` has been explicitly set. + var hasDynamicEnumExtension: Bool {self._dynamicEnumExtension != nil} + /// Clears the value of `dynamicEnumExtension`. Subsequent reads from it will return its default value. + mutating func clearDynamicEnumExtension() {self._dynamicEnumExtension = nil} + + var messageExtension: EditionUnittest_ForeignMessage { + get {_messageExtension ?? EditionUnittest_ForeignMessage()} + set {_messageExtension = newValue} + } + /// Returns true if `messageExtension` has been explicitly set. + var hasMessageExtension: Bool {self._messageExtension != nil} + /// Clears the value of `messageExtension`. Subsequent reads from it will return its default value. + mutating func clearMessageExtension() {self._messageExtension = nil} + + var dynamicMessageExtension: EditionUnittest_TestDynamicExtensions.DynamicMessageType { + get {_dynamicMessageExtension ?? EditionUnittest_TestDynamicExtensions.DynamicMessageType()} + set {_dynamicMessageExtension = newValue} + } + /// Returns true if `dynamicMessageExtension` has been explicitly set. + var hasDynamicMessageExtension: Bool {self._dynamicMessageExtension != nil} + /// Clears the value of `dynamicMessageExtension`. Subsequent reads from it will return its default value. + mutating func clearDynamicMessageExtension() {self._dynamicMessageExtension = nil} + + var repeatedExtension: [String] = [] + + var packedExtension: [Int32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum DynamicEnumType: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case dynamicUnknown = 0 + case dynamicFoo = 2200 + case dynamicBar = 2201 + case dynamicBaz = 2202 + + init() { + self = .dynamicUnknown + } + + } + + struct DynamicMessageType: Sendable { + // 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 dynamicField: Int32 { + get {_dynamicField ?? 0} + set {_dynamicField = newValue} + } + /// Returns true if `dynamicField` has been explicitly set. + var hasDynamicField: Bool {self._dynamicField != nil} + /// Clears the value of `dynamicField`. Subsequent reads from it will return its default value. + mutating func clearDynamicField() {self._dynamicField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _dynamicField: Int32? = nil + } + + init() {} + + fileprivate var _scalarExtension: UInt32? = nil + fileprivate var _enumExtension: EditionUnittest_ForeignEnum? = nil + fileprivate var _dynamicEnumExtension: EditionUnittest_TestDynamicExtensions.DynamicEnumType? = nil + fileprivate var _messageExtension: EditionUnittest_ForeignMessage? = nil + fileprivate var _dynamicMessageExtension: EditionUnittest_TestDynamicExtensions.DynamicMessageType? = nil +} + +struct EditionUnittest_TestRepeatedString: Sendable { + // 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 repeatedString1: [String] = [] + + var repeatedString2: [String] = [] + + var repeatedBytes11: [Data] = [] + + var repeatedBytes12: [Data] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct EditionUnittest_TestRepeatedScalarDifferentTagSizes: Sendable { + // 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. + + /// Parsing repeated fixed size values used to fail. This message needs to be + /// used in order to get a tag of the right size; all of the repeated fields + /// in TestAllTypes didn't trigger the check. + var repeatedFixed32: [UInt32] = [] + + /// Check for a varint type, just for good measure. + var repeatedInt32: [Int32] = [] + + /// These have two-byte tags. + var repeatedFixed64: [UInt64] = [] + + var repeatedInt64: [Int64] = [] + + /// Three byte tags. + var repeatedFloat: [Float] = [] + + var repeatedUint64: [UInt64] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +/// Test that if an optional or message/group field appears multiple +/// times in the input, they need to be merged. +struct EditionUnittest_TestParsingMerge: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 requiredAllTypes: EditionUnittest_TestAllTypes { + get {_requiredAllTypes ?? EditionUnittest_TestAllTypes()} + set {_requiredAllTypes = newValue} + } + /// Returns true if `requiredAllTypes` has been explicitly set. + var hasRequiredAllTypes: Bool {self._requiredAllTypes != nil} + /// Clears the value of `requiredAllTypes`. Subsequent reads from it will return its default value. + mutating func clearRequiredAllTypes() {self._requiredAllTypes = nil} + + var optionalAllTypes: EditionUnittest_TestAllTypes { + get {_optionalAllTypes ?? EditionUnittest_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [EditionUnittest_TestAllTypes] = [] + + var optionalGroup: EditionUnittest_TestParsingMerge.OptionalGroup { + get {_optionalGroup ?? EditionUnittest_TestParsingMerge.OptionalGroup()} + set {_optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {self._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {self._optionalGroup = nil} + + var repeatedGroup: [EditionUnittest_TestParsingMerge.RepeatedGroup] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + /// RepeatedFieldsGenerator defines matching field types as TestParsingMerge, + /// except that all fields are repeated. In the tests, we will serialize the + /// RepeatedFieldsGenerator to bytes, and parse the bytes to TestParsingMerge. + /// Repeated fields in RepeatedFieldsGenerator are expected to be merged into + /// the corresponding required/optional fields in TestParsingMerge. + struct RepeatedFieldsGenerator: Sendable { + // 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: [EditionUnittest_TestAllTypes] = [] + + var field2: [EditionUnittest_TestAllTypes] = [] + + var field3: [EditionUnittest_TestAllTypes] = [] + + var group1: [EditionUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group1] = [] + + var group2: [EditionUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group2] = [] + + var ext1: [EditionUnittest_TestAllTypes] = [] + + var ext2: [EditionUnittest_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct Group1: Sendable { + // 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: EditionUnittest_TestAllTypes { + get {_field1 ?? EditionUnittest_TestAllTypes()} + set {_field1 = newValue} + } + /// Returns true if `field1` has been explicitly set. + var hasField1: Bool {self._field1 != nil} + /// Clears the value of `field1`. Subsequent reads from it will return its default value. + mutating func clearField1() {self._field1 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _field1: EditionUnittest_TestAllTypes? = nil + } + + struct Group2: Sendable { + // 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: EditionUnittest_TestAllTypes { + get {_field1 ?? EditionUnittest_TestAllTypes()} + set {_field1 = newValue} + } + /// Returns true if `field1` has been explicitly set. + var hasField1: Bool {self._field1 != nil} + /// Clears the value of `field1`. Subsequent reads from it will return its default value. + mutating func clearField1() {self._field1 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _field1: EditionUnittest_TestAllTypes? = nil + } + + init() {} + } + + struct OptionalGroup: Sendable { + // 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 optionalGroupAllTypes: EditionUnittest_TestAllTypes { + get {_optionalGroupAllTypes ?? EditionUnittest_TestAllTypes()} + set {_optionalGroupAllTypes = newValue} + } + /// Returns true if `optionalGroupAllTypes` has been explicitly set. + var hasOptionalGroupAllTypes: Bool {self._optionalGroupAllTypes != nil} + /// Clears the value of `optionalGroupAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroupAllTypes() {self._optionalGroupAllTypes = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalGroupAllTypes: EditionUnittest_TestAllTypes? = nil + } + + struct RepeatedGroup: Sendable { + // 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 repeatedGroupAllTypes: EditionUnittest_TestAllTypes { + get {_repeatedGroupAllTypes ?? EditionUnittest_TestAllTypes()} + set {_repeatedGroupAllTypes = newValue} + } + /// Returns true if `repeatedGroupAllTypes` has been explicitly set. + var hasRepeatedGroupAllTypes: Bool {self._repeatedGroupAllTypes != nil} + /// Clears the value of `repeatedGroupAllTypes`. Subsequent reads from it will return its default value. + mutating func clearRepeatedGroupAllTypes() {self._repeatedGroupAllTypes = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _repeatedGroupAllTypes: EditionUnittest_TestAllTypes? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _requiredAllTypes: EditionUnittest_TestAllTypes? = nil + fileprivate var _optionalAllTypes: EditionUnittest_TestAllTypes? = nil + fileprivate var _optionalGroup: EditionUnittest_TestParsingMerge.OptionalGroup? = nil +} + +/// Test that the correct exception is thrown by parseFrom in a corner case +/// involving merging, extensions, and fields. +struct EditionUnittest_TestMergeException: Sendable { + // 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 allExtensions: EditionUnittest_TestAllExtensions { + get {_allExtensions ?? EditionUnittest_TestAllExtensions()} + set {_allExtensions = newValue} + } + /// Returns true if `allExtensions` has been explicitly set. + var hasAllExtensions: Bool {self._allExtensions != nil} + /// Clears the value of `allExtensions`. Subsequent reads from it will return its default value. + mutating func clearAllExtensions() {self._allExtensions = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _allExtensions: EditionUnittest_TestAllExtensions? = nil +} + +struct EditionUnittest_TestCommentInjectionMessage: Sendable { + // 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. + + /// */ <- This should not close the generated doc comment + var a: String { + get {_a ?? "*/ <- Neither should this."} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: String? = nil +} + +/// Used to check that the c++ code generator re-orders messages to reduce +/// padding. +struct EditionUnittest_TestMessageSize: Sendable { + // 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 m1: Bool { + get {_m1 ?? false} + set {_m1 = newValue} + } + /// Returns true if `m1` has been explicitly set. + var hasM1: Bool {self._m1 != nil} + /// Clears the value of `m1`. Subsequent reads from it will return its default value. + mutating func clearM1() {self._m1 = nil} + + var m2: Int64 { + get {_m2 ?? 0} + set {_m2 = newValue} + } + /// Returns true if `m2` has been explicitly set. + var hasM2: Bool {self._m2 != nil} + /// Clears the value of `m2`. Subsequent reads from it will return its default value. + mutating func clearM2() {self._m2 = nil} + + var m3: Bool { + get {_m3 ?? false} + set {_m3 = newValue} + } + /// Returns true if `m3` has been explicitly set. + var hasM3: Bool {self._m3 != nil} + /// Clears the value of `m3`. Subsequent reads from it will return its default value. + mutating func clearM3() {self._m3 = nil} + + var m4: String { + get {_m4 ?? String()} + set {_m4 = newValue} + } + /// Returns true if `m4` has been explicitly set. + var hasM4: Bool {self._m4 != nil} + /// Clears the value of `m4`. Subsequent reads from it will return its default value. + mutating func clearM4() {self._m4 = nil} + + var m5: Int32 { + get {_m5 ?? 0} + set {_m5 = newValue} + } + /// Returns true if `m5` has been explicitly set. + var hasM5: Bool {self._m5 != nil} + /// Clears the value of `m5`. Subsequent reads from it will return its default value. + mutating func clearM5() {self._m5 = nil} + + var m6: Int64 { + get {_m6 ?? 0} + set {_m6 = newValue} + } + /// Returns true if `m6` has been explicitly set. + var hasM6: Bool {self._m6 != nil} + /// Clears the value of `m6`. Subsequent reads from it will return its default value. + mutating func clearM6() {self._m6 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _m1: Bool? = nil + fileprivate var _m2: Int64? = nil + fileprivate var _m3: Bool? = nil + fileprivate var _m4: String? = nil + fileprivate var _m5: Int32? = nil + fileprivate var _m6: Int64? = nil +} + +/// Tests eager verification of a lazy message field. +struct EditionUnittest_TestEagerlyVerifiedLazyMessage: Sendable { + // 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 lazyMessage: EditionUnittest_TestEagerlyVerifiedLazyMessage.LazyMessage { + get {_lazyMessage ?? EditionUnittest_TestEagerlyVerifiedLazyMessage.LazyMessage()} + set {_lazyMessage = newValue} + } + /// Returns true if `lazyMessage` has been explicitly set. + var hasLazyMessage: Bool {self._lazyMessage != nil} + /// Clears the value of `lazyMessage`. Subsequent reads from it will return its default value. + mutating func clearLazyMessage() {self._lazyMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct LazyMessage: Sendable { + // 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 bytesField: Data { + get {_bytesField ?? Data()} + set {_bytesField = newValue} + } + /// Returns true if `bytesField` has been explicitly set. + var hasBytesField: Bool {self._bytesField != nil} + /// Clears the value of `bytesField`. Subsequent reads from it will return its default value. + mutating func clearBytesField() {self._bytesField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _bytesField: Data? = nil + } + + init() {} + + fileprivate var _lazyMessage: EditionUnittest_TestEagerlyVerifiedLazyMessage.LazyMessage? = nil +} + +/// Test that RPC services work. +struct EditionUnittest_FooRequest: Sendable { + // 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 EditionUnittest_FooResponse: Sendable { + // 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 EditionUnittest_FooClientMessage: Sendable { + // 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 EditionUnittest_FooServerMessage: Sendable { + // 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 EditionUnittest_BarRequest: Sendable { + // 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 EditionUnittest_BarResponse: Sendable { + // 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 EditionUnittest_TestJsonName: Sendable { + // 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 fieldName1: Int32 { + get {_fieldName1 ?? 0} + set {_fieldName1 = newValue} + } + /// Returns true if `fieldName1` has been explicitly set. + var hasFieldName1: Bool {self._fieldName1 != nil} + /// Clears the value of `fieldName1`. Subsequent reads from it will return its default value. + mutating func clearFieldName1() {self._fieldName1 = nil} + + var fieldName2: Int32 { + get {_fieldName2 ?? 0} + set {_fieldName2 = newValue} + } + /// Returns true if `fieldName2` has been explicitly set. + var hasFieldName2: Bool {self._fieldName2 != nil} + /// Clears the value of `fieldName2`. Subsequent reads from it will return its default value. + mutating func clearFieldName2() {self._fieldName2 = nil} + + var fieldName3: Int32 { + get {_fieldName3 ?? 0} + set {_fieldName3 = newValue} + } + /// Returns true if `fieldName3` has been explicitly set. + var hasFieldName3: Bool {self._fieldName3 != nil} + /// Clears the value of `fieldName3`. Subsequent reads from it will return its default value. + mutating func clearFieldName3() {self._fieldName3 = nil} + + var fieldName4: Int32 { + get {_fieldName4 ?? 0} + set {_fieldName4 = newValue} + } + /// Returns true if `fieldName4` has been explicitly set. + var hasFieldName4: Bool {self._fieldName4 != nil} + /// Clears the value of `fieldName4`. Subsequent reads from it will return its default value. + mutating func clearFieldName4() {self._fieldName4 = nil} + + var fieldName5: Int32 { + get {_fieldName5 ?? 0} + set {_fieldName5 = newValue} + } + /// Returns true if `fieldName5` has been explicitly set. + var hasFieldName5: Bool {self._fieldName5 != nil} + /// Clears the value of `fieldName5`. Subsequent reads from it will return its default value. + mutating func clearFieldName5() {self._fieldName5 = nil} + + var fieldName6: Int32 { + get {_fieldName6 ?? 0} + set {_fieldName6 = newValue} + } + /// Returns true if `fieldName6` has been explicitly set. + var hasFieldName6: Bool {self._fieldName6 != nil} + /// Clears the value of `fieldName6`. Subsequent reads from it will return its default value. + mutating func clearFieldName6() {self._fieldName6 = nil} + + var fieldname7: Int32 { + get {_fieldname7 ?? 0} + set {_fieldname7 = newValue} + } + /// Returns true if `fieldname7` has been explicitly set. + var hasFieldname7: Bool {self._fieldname7 != nil} + /// Clears the value of `fieldname7`. Subsequent reads from it will return its default value. + mutating func clearFieldname7() {self._fieldname7 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _fieldName1: Int32? = nil + fileprivate var _fieldName2: Int32? = nil + fileprivate var _fieldName3: Int32? = nil + fileprivate var _fieldName4: Int32? = nil + fileprivate var _fieldName5: Int32? = nil + fileprivate var _fieldName6: Int32? = nil + fileprivate var _fieldname7: Int32? = nil +} + +struct EditionUnittest_TestHugeFieldNumbers: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 optionalInt32: Int32 { + get {_optionalInt32 ?? 0} + set {_optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {self._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {self._optionalInt32 = nil} + + var fixed32: Int32 { + get {_fixed32 ?? 0} + set {_fixed32 = newValue} + } + /// Returns true if `fixed32` has been explicitly set. + var hasFixed32: Bool {self._fixed32 != nil} + /// Clears the value of `fixed32`. Subsequent reads from it will return its default value. + mutating func clearFixed32() {self._fixed32 = nil} + + var repeatedInt32: [Int32] = [] + + var packedInt32: [Int32] = [] + + var optionalEnum: EditionUnittest_ForeignEnum { + get {_optionalEnum ?? .foreignFoo} + set {_optionalEnum = newValue} + } + /// Returns true if `optionalEnum` has been explicitly set. + var hasOptionalEnum: Bool {self._optionalEnum != nil} + /// Clears the value of `optionalEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalEnum() {self._optionalEnum = nil} + + var optionalString: String { + get {_optionalString ?? String()} + set {_optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {self._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {self._optionalString = nil} + + var optionalBytes: Data { + get {_optionalBytes ?? Data()} + set {_optionalBytes = newValue} + } + /// Returns true if `optionalBytes` has been explicitly set. + var hasOptionalBytes: Bool {self._optionalBytes != nil} + /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytes() {self._optionalBytes = nil} + + var optionalMessage: EditionUnittest_ForeignMessage { + get {_optionalMessage ?? EditionUnittest_ForeignMessage()} + set {_optionalMessage = newValue} + } + /// Returns true if `optionalMessage` has been explicitly set. + var hasOptionalMessage: Bool {self._optionalMessage != nil} + /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalMessage() {self._optionalMessage = nil} + + var optionalGroup: EditionUnittest_TestHugeFieldNumbers.OptionalGroup { + get {_optionalGroup ?? EditionUnittest_TestHugeFieldNumbers.OptionalGroup()} + set {_optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {self._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {self._optionalGroup = nil} + + var stringStringMap: Dictionary = [:] + + var oneofField: EditionUnittest_TestHugeFieldNumbers.OneOf_OneofField? = nil + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = oneofField {return v} + return 0 + } + set {oneofField = .oneofUint32(newValue)} + } + + var oneofTestAllTypes: EditionUnittest_TestAllTypes { + get { + if case .oneofTestAllTypes(let v)? = oneofField {return v} + return EditionUnittest_TestAllTypes() + } + set {oneofField = .oneofTestAllTypes(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = oneofField {return v} + return String() + } + set {oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = oneofField {return v} + return Data() + } + set {oneofField = .oneofBytes(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofTestAllTypes(EditionUnittest_TestAllTypes) + case oneofString(String) + case oneofBytes(Data) + + } + + struct OptionalGroup: Sendable { + // 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 groupA: Int32 { + get {_groupA ?? 0} + set {_groupA = newValue} + } + /// Returns true if `groupA` has been explicitly set. + var hasGroupA: Bool {self._groupA != nil} + /// Clears the value of `groupA`. Subsequent reads from it will return its default value. + mutating func clearGroupA() {self._groupA = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupA: Int32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _optionalInt32: Int32? = nil + fileprivate var _fixed32: Int32? = nil + fileprivate var _optionalEnum: EditionUnittest_ForeignEnum? = nil + fileprivate var _optionalString: String? = nil + fileprivate var _optionalBytes: Data? = nil + fileprivate var _optionalMessage: EditionUnittest_ForeignMessage? = nil + fileprivate var _optionalGroup: EditionUnittest_TestHugeFieldNumbers.OptionalGroup? = nil +} + +struct EditionUnittest_TestExtensionInsideTable: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 {_field1 ?? 0} + set {_field1 = newValue} + } + /// Returns true if `field1` has been explicitly set. + var hasField1: Bool {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 {_field2 ?? 0} + set {_field2 = newValue} + } + /// Returns true if `field2` has been explicitly set. + var hasField2: Bool {self._field2 != nil} + /// Clears the value of `field2`. Subsequent reads from it will return its default value. + mutating func clearField2() {self._field2 = nil} + + var field3: Int32 { + get {_field3 ?? 0} + set {_field3 = newValue} + } + /// Returns true if `field3` has been explicitly set. + var hasField3: Bool {self._field3 != nil} + /// Clears the value of `field3`. Subsequent reads from it will return its default value. + mutating func clearField3() {self._field3 = nil} + + var field4: Int32 { + get {_field4 ?? 0} + set {_field4 = newValue} + } + /// Returns true if `field4` has been explicitly set. + var hasField4: Bool {self._field4 != nil} + /// Clears the value of `field4`. Subsequent reads from it will return its default value. + mutating func clearField4() {self._field4 = nil} + + var field6: Int32 { + get {_field6 ?? 0} + set {_field6 = newValue} + } + /// Returns true if `field6` has been explicitly set. + var hasField6: Bool {self._field6 != nil} + /// Clears the value of `field6`. Subsequent reads from it will return its default value. + mutating func clearField6() {self._field6 = nil} + + var field7: Int32 { + get {_field7 ?? 0} + set {_field7 = newValue} + } + /// Returns true if `field7` has been explicitly set. + var hasField7: Bool {self._field7 != nil} + /// Clears the value of `field7`. Subsequent reads from it will return its default value. + mutating func clearField7() {self._field7 = nil} + + var field8: Int32 { + get {_field8 ?? 0} + set {_field8 = newValue} + } + /// Returns true if `field8` has been explicitly set. + var hasField8: Bool {self._field8 != nil} + /// Clears the value of `field8`. Subsequent reads from it will return its default value. + mutating func clearField8() {self._field8 = nil} + + var field9: Int32 { + get {_field9 ?? 0} + set {_field9 = newValue} + } + /// Returns true if `field9` has been explicitly set. + var hasField9: Bool {self._field9 != nil} + /// Clears the value of `field9`. Subsequent reads from it will return its default value. + mutating func clearField9() {self._field9 = nil} + + var field10: Int32 { + get {_field10 ?? 0} + set {_field10 = newValue} + } + /// Returns true if `field10` has been explicitly set. + var hasField10: Bool {self._field10 != nil} + /// Clears the value of `field10`. Subsequent reads from it will return its default value. + mutating func clearField10() {self._field10 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _field1: Int32? = nil + fileprivate var _field2: Int32? = nil + fileprivate var _field3: Int32? = nil + fileprivate var _field4: Int32? = nil + fileprivate var _field6: Int32? = nil + fileprivate var _field7: Int32? = nil + fileprivate var _field8: Int32? = nil + fileprivate var _field9: Int32? = nil + fileprivate var _field10: Int32? = nil +} + +/// NOTE: Intentionally nested to mirror go/glep. +struct EditionUnittest_TestNestedGroupExtensionOuter: Sendable { + // 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 lay1Optionalgroup: EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup { + get {_lay1Optionalgroup ?? EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup()} + set {_lay1Optionalgroup = newValue} + } + /// Returns true if `lay1Optionalgroup` has been explicitly set. + var hasLay1Optionalgroup: Bool {self._lay1Optionalgroup != nil} + /// Clears the value of `lay1Optionalgroup`. Subsequent reads from it will return its default value. + mutating func clearLay1Optionalgroup() {self._lay1Optionalgroup = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct Layer1OptionalGroup: Sendable { + // 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 layer2RepeatedGroup: [EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2RepeatedGroup] = [] + + var layer2AnotherOptionalRepeatedGroup: [EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2AnotherOptionalRepeatedGroup] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct Layer2RepeatedGroup: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 anotherField: String { + get {_anotherField ?? String()} + set {_anotherField = newValue} + } + /// Returns true if `anotherField` has been explicitly set. + var hasAnotherField: Bool {self._anotherField != nil} + /// Clears the value of `anotherField`. Subsequent reads from it will return its default value. + mutating func clearAnotherField() {self._anotherField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _anotherField: String? = nil + } + + struct Layer2AnotherOptionalRepeatedGroup: Sendable { + // 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 butWhyTho: String { + get {_butWhyTho ?? String()} + set {_butWhyTho = newValue} + } + /// Returns true if `butWhyTho` has been explicitly set. + var hasButWhyTho: Bool {self._butWhyTho != nil} + /// Clears the value of `butWhyTho`. Subsequent reads from it will return its default value. + mutating func clearButWhyTho() {self._butWhyTho = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _butWhyTho: String? = nil + } + + init() {} + } + + init() {} + + fileprivate var _lay1Optionalgroup: EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup? = nil +} + +struct EditionUnittest_TestNestedGroupExtensionInnerExtension: Sendable { + // 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 innerName: String { + get {_innerName ?? String()} + set {_innerName = newValue} + } + /// Returns true if `innerName` has been explicitly set. + var hasInnerName: Bool {self._innerName != nil} + /// Clears the value of `innerName`. Subsequent reads from it will return its default value. + mutating func clearInnerName() {self._innerName = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _innerName: String? = nil +} + +struct EditionUnittest_TestExtensionRangeSerialize: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 fooOne: Int32 { + get {_fooOne ?? 0} + set {_fooOne = newValue} + } + /// Returns true if `fooOne` has been explicitly set. + var hasFooOne: Bool {self._fooOne != nil} + /// Clears the value of `fooOne`. Subsequent reads from it will return its default value. + mutating func clearFooOne() {self._fooOne = nil} + + var fooTwo: Int32 { + get {_fooTwo ?? 0} + set {_fooTwo = newValue} + } + /// Returns true if `fooTwo` has been explicitly set. + var hasFooTwo: Bool {self._fooTwo != nil} + /// Clears the value of `fooTwo`. Subsequent reads from it will return its default value. + mutating func clearFooTwo() {self._fooTwo = nil} + + var fooThree: Int32 { + get {_fooThree ?? 0} + set {_fooThree = newValue} + } + /// Returns true if `fooThree` has been explicitly set. + var hasFooThree: Bool {self._fooThree != nil} + /// Clears the value of `fooThree`. Subsequent reads from it will return its default value. + mutating func clearFooThree() {self._fooThree = nil} + + var fooFour: Int32 { + get {_fooFour ?? 0} + set {_fooFour = newValue} + } + /// Returns true if `fooFour` has been explicitly set. + var hasFooFour: Bool {self._fooFour != nil} + /// Clears the value of `fooFour`. Subsequent reads from it will return its default value. + mutating func clearFooFour() {self._fooFour = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _fooOne: Int32? = nil + fileprivate var _fooTwo: Int32? = nil + fileprivate var _fooThree: Int32? = nil + fileprivate var _fooFour: Int32? = nil +} + +struct EditionUnittest_TestVerifyInt32Simple: Sendable { + // 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 optionalInt321: Int32 { + get {_optionalInt321 ?? 0} + set {_optionalInt321 = newValue} + } + /// Returns true if `optionalInt321` has been explicitly set. + var hasOptionalInt321: Bool {self._optionalInt321 != nil} + /// Clears the value of `optionalInt321`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt321() {self._optionalInt321 = nil} + + var optionalInt322: Int32 { + get {_optionalInt322 ?? 0} + set {_optionalInt322 = newValue} + } + /// Returns true if `optionalInt322` has been explicitly set. + var hasOptionalInt322: Bool {self._optionalInt322 != nil} + /// Clears the value of `optionalInt322`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt322() {self._optionalInt322 = nil} + + var optionalInt3263: Int32 { + get {_optionalInt3263 ?? 0} + set {_optionalInt3263 = newValue} + } + /// Returns true if `optionalInt3263` has been explicitly set. + var hasOptionalInt3263: Bool {self._optionalInt3263 != nil} + /// Clears the value of `optionalInt3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3263() {self._optionalInt3263 = nil} + + var optionalInt3264: Int32 { + get {_optionalInt3264 ?? 0} + set {_optionalInt3264 = newValue} + } + /// Returns true if `optionalInt3264` has been explicitly set. + var hasOptionalInt3264: Bool {self._optionalInt3264 != nil} + /// Clears the value of `optionalInt3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3264() {self._optionalInt3264 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalInt321: Int32? = nil + fileprivate var _optionalInt322: Int32? = nil + fileprivate var _optionalInt3263: Int32? = nil + fileprivate var _optionalInt3264: Int32? = nil +} + +struct EditionUnittest_TestVerifyInt32: Sendable { + // 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 optionalInt321: Int32 { + get {_optionalInt321 ?? 0} + set {_optionalInt321 = newValue} + } + /// Returns true if `optionalInt321` has been explicitly set. + var hasOptionalInt321: Bool {self._optionalInt321 != nil} + /// Clears the value of `optionalInt321`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt321() {self._optionalInt321 = nil} + + var optionalInt322: Int32 { + get {_optionalInt322 ?? 0} + set {_optionalInt322 = newValue} + } + /// Returns true if `optionalInt322` has been explicitly set. + var hasOptionalInt322: Bool {self._optionalInt322 != nil} + /// Clears the value of `optionalInt322`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt322() {self._optionalInt322 = nil} + + var optionalInt3263: Int32 { + get {_optionalInt3263 ?? 0} + set {_optionalInt3263 = newValue} + } + /// Returns true if `optionalInt3263` has been explicitly set. + var hasOptionalInt3263: Bool {self._optionalInt3263 != nil} + /// Clears the value of `optionalInt3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3263() {self._optionalInt3263 = nil} + + var optionalInt3264: Int32 { + get {_optionalInt3264 ?? 0} + set {_optionalInt3264 = newValue} + } + /// Returns true if `optionalInt3264` has been explicitly set. + var hasOptionalInt3264: Bool {self._optionalInt3264 != nil} + /// Clears the value of `optionalInt3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3264() {self._optionalInt3264 = nil} + + var optionalAllTypes: EditionUnittest_TestAllTypes { + get {_optionalAllTypes ?? EditionUnittest_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [EditionUnittest_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalInt321: Int32? = nil + fileprivate var _optionalInt322: Int32? = nil + fileprivate var _optionalInt3263: Int32? = nil + fileprivate var _optionalInt3264: Int32? = nil + fileprivate var _optionalAllTypes: EditionUnittest_TestAllTypes? = nil +} + +struct EditionUnittest_TestVerifyMostlyInt32: Sendable { + // 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 optionalInt6430: Int64 { + get {_optionalInt6430 ?? 0} + set {_optionalInt6430 = newValue} + } + /// Returns true if `optionalInt6430` has been explicitly set. + var hasOptionalInt6430: Bool {self._optionalInt6430 != nil} + /// Clears the value of `optionalInt6430`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt6430() {self._optionalInt6430 = nil} + + var optionalInt321: Int32 { + get {_optionalInt321 ?? 0} + set {_optionalInt321 = newValue} + } + /// Returns true if `optionalInt321` has been explicitly set. + var hasOptionalInt321: Bool {self._optionalInt321 != nil} + /// Clears the value of `optionalInt321`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt321() {self._optionalInt321 = nil} + + var optionalInt322: Int32 { + get {_optionalInt322 ?? 0} + set {_optionalInt322 = newValue} + } + /// Returns true if `optionalInt322` has been explicitly set. + var hasOptionalInt322: Bool {self._optionalInt322 != nil} + /// Clears the value of `optionalInt322`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt322() {self._optionalInt322 = nil} + + var optionalInt323: Int32 { + get {_optionalInt323 ?? 0} + set {_optionalInt323 = newValue} + } + /// Returns true if `optionalInt323` has been explicitly set. + var hasOptionalInt323: Bool {self._optionalInt323 != nil} + /// Clears the value of `optionalInt323`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt323() {self._optionalInt323 = nil} + + var optionalInt324: Int32 { + get {_optionalInt324 ?? 0} + set {_optionalInt324 = newValue} + } + /// Returns true if `optionalInt324` has been explicitly set. + var hasOptionalInt324: Bool {self._optionalInt324 != nil} + /// Clears the value of `optionalInt324`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt324() {self._optionalInt324 = nil} + + var optionalInt3263: Int32 { + get {_optionalInt3263 ?? 0} + set {_optionalInt3263 = newValue} + } + /// Returns true if `optionalInt3263` has been explicitly set. + var hasOptionalInt3263: Bool {self._optionalInt3263 != nil} + /// Clears the value of `optionalInt3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3263() {self._optionalInt3263 = nil} + + var optionalInt3264: Int32 { + get {_optionalInt3264 ?? 0} + set {_optionalInt3264 = newValue} + } + /// Returns true if `optionalInt3264` has been explicitly set. + var hasOptionalInt3264: Bool {self._optionalInt3264 != nil} + /// Clears the value of `optionalInt3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3264() {self._optionalInt3264 = nil} + + var optionalAllTypes: EditionUnittest_TestAllTypes { + get {_optionalAllTypes ?? EditionUnittest_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [EditionUnittest_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalInt6430: Int64? = nil + fileprivate var _optionalInt321: Int32? = nil + fileprivate var _optionalInt322: Int32? = nil + fileprivate var _optionalInt323: Int32? = nil + fileprivate var _optionalInt324: Int32? = nil + fileprivate var _optionalInt3263: Int32? = nil + fileprivate var _optionalInt3264: Int32? = nil + fileprivate var _optionalAllTypes: EditionUnittest_TestAllTypes? = nil +} + +struct EditionUnittest_TestVerifyMostlyInt32BigFieldNumber: Sendable { + // 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 optionalInt6430: Int64 { + get {_optionalInt6430 ?? 0} + set {_optionalInt6430 = newValue} + } + /// Returns true if `optionalInt6430` has been explicitly set. + var hasOptionalInt6430: Bool {self._optionalInt6430 != nil} + /// Clears the value of `optionalInt6430`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt6430() {self._optionalInt6430 = nil} + + var optionalInt32300: Int32 { + get {_optionalInt32300 ?? 0} + set {_optionalInt32300 = newValue} + } + /// Returns true if `optionalInt32300` has been explicitly set. + var hasOptionalInt32300: Bool {self._optionalInt32300 != nil} + /// Clears the value of `optionalInt32300`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32300() {self._optionalInt32300 = nil} + + var optionalInt321: Int32 { + get {_optionalInt321 ?? 0} + set {_optionalInt321 = newValue} + } + /// Returns true if `optionalInt321` has been explicitly set. + var hasOptionalInt321: Bool {self._optionalInt321 != nil} + /// Clears the value of `optionalInt321`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt321() {self._optionalInt321 = nil} + + var optionalInt322: Int32 { + get {_optionalInt322 ?? 0} + set {_optionalInt322 = newValue} + } + /// Returns true if `optionalInt322` has been explicitly set. + var hasOptionalInt322: Bool {self._optionalInt322 != nil} + /// Clears the value of `optionalInt322`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt322() {self._optionalInt322 = nil} + + var optionalInt323: Int32 { + get {_optionalInt323 ?? 0} + set {_optionalInt323 = newValue} + } + /// Returns true if `optionalInt323` has been explicitly set. + var hasOptionalInt323: Bool {self._optionalInt323 != nil} + /// Clears the value of `optionalInt323`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt323() {self._optionalInt323 = nil} + + var optionalInt324: Int32 { + get {_optionalInt324 ?? 0} + set {_optionalInt324 = newValue} + } + /// Returns true if `optionalInt324` has been explicitly set. + var hasOptionalInt324: Bool {self._optionalInt324 != nil} + /// Clears the value of `optionalInt324`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt324() {self._optionalInt324 = nil} + + var optionalInt3263: Int32 { + get {_optionalInt3263 ?? 0} + set {_optionalInt3263 = newValue} + } + /// Returns true if `optionalInt3263` has been explicitly set. + var hasOptionalInt3263: Bool {self._optionalInt3263 != nil} + /// Clears the value of `optionalInt3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3263() {self._optionalInt3263 = nil} + + var optionalInt3264: Int32 { + get {_optionalInt3264 ?? 0} + set {_optionalInt3264 = newValue} + } + /// Returns true if `optionalInt3264` has been explicitly set. + var hasOptionalInt3264: Bool {self._optionalInt3264 != nil} + /// Clears the value of `optionalInt3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3264() {self._optionalInt3264 = nil} + + var optionalAllTypes: EditionUnittest_TestAllTypes { + get {_optionalAllTypes ?? EditionUnittest_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [EditionUnittest_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalInt6430: Int64? = nil + fileprivate var _optionalInt32300: Int32? = nil + fileprivate var _optionalInt321: Int32? = nil + fileprivate var _optionalInt322: Int32? = nil + fileprivate var _optionalInt323: Int32? = nil + fileprivate var _optionalInt324: Int32? = nil + fileprivate var _optionalInt3263: Int32? = nil + fileprivate var _optionalInt3264: Int32? = nil + fileprivate var _optionalAllTypes: EditionUnittest_TestAllTypes? = nil +} + +struct EditionUnittest_TestVerifyUint32Simple: Sendable { + // 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 optionalUint321: UInt32 { + get {_optionalUint321 ?? 0} + set {_optionalUint321 = newValue} + } + /// Returns true if `optionalUint321` has been explicitly set. + var hasOptionalUint321: Bool {self._optionalUint321 != nil} + /// Clears the value of `optionalUint321`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint321() {self._optionalUint321 = nil} + + var optionalUint322: UInt32 { + get {_optionalUint322 ?? 0} + set {_optionalUint322 = newValue} + } + /// Returns true if `optionalUint322` has been explicitly set. + var hasOptionalUint322: Bool {self._optionalUint322 != nil} + /// Clears the value of `optionalUint322`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint322() {self._optionalUint322 = nil} + + var optionalUint3263: UInt32 { + get {_optionalUint3263 ?? 0} + set {_optionalUint3263 = newValue} + } + /// Returns true if `optionalUint3263` has been explicitly set. + var hasOptionalUint3263: Bool {self._optionalUint3263 != nil} + /// Clears the value of `optionalUint3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3263() {self._optionalUint3263 = nil} + + var optionalUint3264: UInt32 { + get {_optionalUint3264 ?? 0} + set {_optionalUint3264 = newValue} + } + /// Returns true if `optionalUint3264` has been explicitly set. + var hasOptionalUint3264: Bool {self._optionalUint3264 != nil} + /// Clears the value of `optionalUint3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3264() {self._optionalUint3264 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalUint321: UInt32? = nil + fileprivate var _optionalUint322: UInt32? = nil + fileprivate var _optionalUint3263: UInt32? = nil + fileprivate var _optionalUint3264: UInt32? = nil +} + +struct EditionUnittest_TestVerifyUint32: Sendable { + // 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 optionalUint321: UInt32 { + get {_optionalUint321 ?? 0} + set {_optionalUint321 = newValue} + } + /// Returns true if `optionalUint321` has been explicitly set. + var hasOptionalUint321: Bool {self._optionalUint321 != nil} + /// Clears the value of `optionalUint321`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint321() {self._optionalUint321 = nil} + + var optionalUint322: UInt32 { + get {_optionalUint322 ?? 0} + set {_optionalUint322 = newValue} + } + /// Returns true if `optionalUint322` has been explicitly set. + var hasOptionalUint322: Bool {self._optionalUint322 != nil} + /// Clears the value of `optionalUint322`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint322() {self._optionalUint322 = nil} + + var optionalUint3263: UInt32 { + get {_optionalUint3263 ?? 0} + set {_optionalUint3263 = newValue} + } + /// Returns true if `optionalUint3263` has been explicitly set. + var hasOptionalUint3263: Bool {self._optionalUint3263 != nil} + /// Clears the value of `optionalUint3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3263() {self._optionalUint3263 = nil} + + var optionalUint3264: UInt32 { + get {_optionalUint3264 ?? 0} + set {_optionalUint3264 = newValue} + } + /// Returns true if `optionalUint3264` has been explicitly set. + var hasOptionalUint3264: Bool {self._optionalUint3264 != nil} + /// Clears the value of `optionalUint3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3264() {self._optionalUint3264 = nil} + + var optionalAllTypes: EditionUnittest_TestAllTypes { + get {_optionalAllTypes ?? EditionUnittest_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [EditionUnittest_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalUint321: UInt32? = nil + fileprivate var _optionalUint322: UInt32? = nil + fileprivate var _optionalUint3263: UInt32? = nil + fileprivate var _optionalUint3264: UInt32? = nil + fileprivate var _optionalAllTypes: EditionUnittest_TestAllTypes? = nil +} + +struct EditionUnittest_TestVerifyOneUint32: Sendable { + // 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 optionalUint321: UInt32 { + get {_optionalUint321 ?? 0} + set {_optionalUint321 = newValue} + } + /// Returns true if `optionalUint321` has been explicitly set. + var hasOptionalUint321: Bool {self._optionalUint321 != nil} + /// Clears the value of `optionalUint321`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint321() {self._optionalUint321 = nil} + + var optionalInt322: Int32 { + get {_optionalInt322 ?? 0} + set {_optionalInt322 = newValue} + } + /// Returns true if `optionalInt322` has been explicitly set. + var hasOptionalInt322: Bool {self._optionalInt322 != nil} + /// Clears the value of `optionalInt322`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt322() {self._optionalInt322 = nil} + + var optionalInt3263: Int32 { + get {_optionalInt3263 ?? 0} + set {_optionalInt3263 = newValue} + } + /// Returns true if `optionalInt3263` has been explicitly set. + var hasOptionalInt3263: Bool {self._optionalInt3263 != nil} + /// Clears the value of `optionalInt3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3263() {self._optionalInt3263 = nil} + + var optionalInt3264: Int32 { + get {_optionalInt3264 ?? 0} + set {_optionalInt3264 = newValue} + } + /// Returns true if `optionalInt3264` has been explicitly set. + var hasOptionalInt3264: Bool {self._optionalInt3264 != nil} + /// Clears the value of `optionalInt3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3264() {self._optionalInt3264 = nil} + + var optionalAllTypes: EditionUnittest_TestAllTypes { + get {_optionalAllTypes ?? EditionUnittest_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [EditionUnittest_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalUint321: UInt32? = nil + fileprivate var _optionalInt322: Int32? = nil + fileprivate var _optionalInt3263: Int32? = nil + fileprivate var _optionalInt3264: Int32? = nil + fileprivate var _optionalAllTypes: EditionUnittest_TestAllTypes? = nil +} + +struct EditionUnittest_TestVerifyOneInt32BigFieldNumber: Sendable { + // 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 optionalInt3265: Int32 { + get {_optionalInt3265 ?? 0} + set {_optionalInt3265 = newValue} + } + /// Returns true if `optionalInt3265` has been explicitly set. + var hasOptionalInt3265: Bool {self._optionalInt3265 != nil} + /// Clears the value of `optionalInt3265`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3265() {self._optionalInt3265 = nil} + + var optionalInt641: Int64 { + get {_optionalInt641 ?? 0} + set {_optionalInt641 = newValue} + } + /// Returns true if `optionalInt641` has been explicitly set. + var hasOptionalInt641: Bool {self._optionalInt641 != nil} + /// Clears the value of `optionalInt641`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt641() {self._optionalInt641 = nil} + + var optionalInt642: Int64 { + get {_optionalInt642 ?? 0} + set {_optionalInt642 = newValue} + } + /// Returns true if `optionalInt642` has been explicitly set. + var hasOptionalInt642: Bool {self._optionalInt642 != nil} + /// Clears the value of `optionalInt642`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt642() {self._optionalInt642 = nil} + + var optionalInt6463: Int64 { + get {_optionalInt6463 ?? 0} + set {_optionalInt6463 = newValue} + } + /// Returns true if `optionalInt6463` has been explicitly set. + var hasOptionalInt6463: Bool {self._optionalInt6463 != nil} + /// Clears the value of `optionalInt6463`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt6463() {self._optionalInt6463 = nil} + + var optionalInt6464: Int64 { + get {_optionalInt6464 ?? 0} + set {_optionalInt6464 = newValue} + } + /// Returns true if `optionalInt6464` has been explicitly set. + var hasOptionalInt6464: Bool {self._optionalInt6464 != nil} + /// Clears the value of `optionalInt6464`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt6464() {self._optionalInt6464 = nil} + + var optionalAllTypes: EditionUnittest_TestAllTypes { + get {_optionalAllTypes ?? EditionUnittest_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [EditionUnittest_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalInt3265: Int32? = nil + fileprivate var _optionalInt641: Int64? = nil + fileprivate var _optionalInt642: Int64? = nil + fileprivate var _optionalInt6463: Int64? = nil + fileprivate var _optionalInt6464: Int64? = nil + fileprivate var _optionalAllTypes: EditionUnittest_TestAllTypes? = nil +} + +struct EditionUnittest_TestVerifyInt32BigFieldNumber: Sendable { + // 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 optionalInt321000: Int32 { + get {_optionalInt321000 ?? 0} + set {_optionalInt321000 = newValue} + } + /// Returns true if `optionalInt321000` has been explicitly set. + var hasOptionalInt321000: Bool {self._optionalInt321000 != nil} + /// Clears the value of `optionalInt321000`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt321000() {self._optionalInt321000 = nil} + + var optionalInt3265: Int32 { + get {_optionalInt3265 ?? 0} + set {_optionalInt3265 = newValue} + } + /// Returns true if `optionalInt3265` has been explicitly set. + var hasOptionalInt3265: Bool {self._optionalInt3265 != nil} + /// Clears the value of `optionalInt3265`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3265() {self._optionalInt3265 = nil} + + var optionalInt321: Int32 { + get {_optionalInt321 ?? 0} + set {_optionalInt321 = newValue} + } + /// Returns true if `optionalInt321` has been explicitly set. + var hasOptionalInt321: Bool {self._optionalInt321 != nil} + /// Clears the value of `optionalInt321`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt321() {self._optionalInt321 = nil} + + var optionalInt322: Int32 { + get {_optionalInt322 ?? 0} + set {_optionalInt322 = newValue} + } + /// Returns true if `optionalInt322` has been explicitly set. + var hasOptionalInt322: Bool {self._optionalInt322 != nil} + /// Clears the value of `optionalInt322`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt322() {self._optionalInt322 = nil} + + var optionalInt3263: Int32 { + get {_optionalInt3263 ?? 0} + set {_optionalInt3263 = newValue} + } + /// Returns true if `optionalInt3263` has been explicitly set. + var hasOptionalInt3263: Bool {self._optionalInt3263 != nil} + /// Clears the value of `optionalInt3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3263() {self._optionalInt3263 = nil} + + var optionalInt3264: Int32 { + get {_optionalInt3264 ?? 0} + set {_optionalInt3264 = newValue} + } + /// Returns true if `optionalInt3264` has been explicitly set. + var hasOptionalInt3264: Bool {self._optionalInt3264 != nil} + /// Clears the value of `optionalInt3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3264() {self._optionalInt3264 = nil} + + var optionalAllTypes: EditionUnittest_TestAllTypes { + get {_optionalAllTypes ?? EditionUnittest_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [EditionUnittest_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalInt321000: Int32? = nil + fileprivate var _optionalInt3265: Int32? = nil + fileprivate var _optionalInt321: Int32? = nil + fileprivate var _optionalInt322: Int32? = nil + fileprivate var _optionalInt3263: Int32? = nil + fileprivate var _optionalInt3264: Int32? = nil + fileprivate var _optionalAllTypes: EditionUnittest_TestAllTypes? = nil +} + +struct EditionUnittest_TestVerifyUint32BigFieldNumber: Sendable { + // 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 optionalUint321000: UInt32 { + get {_optionalUint321000 ?? 0} + set {_optionalUint321000 = newValue} + } + /// Returns true if `optionalUint321000` has been explicitly set. + var hasOptionalUint321000: Bool {self._optionalUint321000 != nil} + /// Clears the value of `optionalUint321000`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint321000() {self._optionalUint321000 = nil} + + var optionalUint3265: UInt32 { + get {_optionalUint3265 ?? 0} + set {_optionalUint3265 = newValue} + } + /// Returns true if `optionalUint3265` has been explicitly set. + var hasOptionalUint3265: Bool {self._optionalUint3265 != nil} + /// Clears the value of `optionalUint3265`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3265() {self._optionalUint3265 = nil} + + var optionalUint321: UInt32 { + get {_optionalUint321 ?? 0} + set {_optionalUint321 = newValue} + } + /// Returns true if `optionalUint321` has been explicitly set. + var hasOptionalUint321: Bool {self._optionalUint321 != nil} + /// Clears the value of `optionalUint321`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint321() {self._optionalUint321 = nil} + + var optionalUint322: UInt32 { + get {_optionalUint322 ?? 0} + set {_optionalUint322 = newValue} + } + /// Returns true if `optionalUint322` has been explicitly set. + var hasOptionalUint322: Bool {self._optionalUint322 != nil} + /// Clears the value of `optionalUint322`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint322() {self._optionalUint322 = nil} + + var optionalUint3263: UInt32 { + get {_optionalUint3263 ?? 0} + set {_optionalUint3263 = newValue} + } + /// Returns true if `optionalUint3263` has been explicitly set. + var hasOptionalUint3263: Bool {self._optionalUint3263 != nil} + /// Clears the value of `optionalUint3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3263() {self._optionalUint3263 = nil} + + var optionalUint3264: UInt32 { + get {_optionalUint3264 ?? 0} + set {_optionalUint3264 = newValue} + } + /// Returns true if `optionalUint3264` has been explicitly set. + var hasOptionalUint3264: Bool {self._optionalUint3264 != nil} + /// Clears the value of `optionalUint3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3264() {self._optionalUint3264 = nil} + + var optionalAllTypes: EditionUnittest_TestAllTypes { + get {_optionalAllTypes ?? EditionUnittest_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [EditionUnittest_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalUint321000: UInt32? = nil + fileprivate var _optionalUint3265: UInt32? = nil + fileprivate var _optionalUint321: UInt32? = nil + fileprivate var _optionalUint322: UInt32? = nil + fileprivate var _optionalUint3263: UInt32? = nil + fileprivate var _optionalUint3264: UInt32? = nil + fileprivate var _optionalAllTypes: EditionUnittest_TestAllTypes? = nil +} + +struct EditionUnittest_TestVerifyBigFieldNumberUint32: Sendable { + // 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 optionalNested: EditionUnittest_TestVerifyBigFieldNumberUint32.Nested { + get {_optionalNested ?? EditionUnittest_TestVerifyBigFieldNumberUint32.Nested()} + set {_optionalNested = newValue} + } + /// Returns true if `optionalNested` has been explicitly set. + var hasOptionalNested: Bool {self._optionalNested != nil} + /// Clears the value of `optionalNested`. Subsequent reads from it will return its default value. + mutating func clearOptionalNested() {self._optionalNested = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct Nested: @unchecked Sendable { + // 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 optionalUint325000: UInt32 { + get {_storage._optionalUint325000 ?? 0} + set {_uniqueStorage()._optionalUint325000 = newValue} + } + /// Returns true if `optionalUint325000` has been explicitly set. + var hasOptionalUint325000: Bool {_storage._optionalUint325000 != nil} + /// Clears the value of `optionalUint325000`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint325000() {_uniqueStorage()._optionalUint325000 = nil} + + var optionalUint321000: UInt32 { + get {_storage._optionalUint321000 ?? 0} + set {_uniqueStorage()._optionalUint321000 = newValue} + } + /// Returns true if `optionalUint321000` has been explicitly set. + var hasOptionalUint321000: Bool {_storage._optionalUint321000 != nil} + /// Clears the value of `optionalUint321000`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint321000() {_uniqueStorage()._optionalUint321000 = nil} + + var optionalUint3266: UInt32 { + get {_storage._optionalUint3266 ?? 0} + set {_uniqueStorage()._optionalUint3266 = newValue} + } + /// Returns true if `optionalUint3266` has been explicitly set. + var hasOptionalUint3266: Bool {_storage._optionalUint3266 != nil} + /// Clears the value of `optionalUint3266`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3266() {_uniqueStorage()._optionalUint3266 = nil} + + var optionalUint3265: UInt32 { + get {_storage._optionalUint3265 ?? 0} + set {_uniqueStorage()._optionalUint3265 = newValue} + } + /// Returns true if `optionalUint3265` has been explicitly set. + var hasOptionalUint3265: Bool {_storage._optionalUint3265 != nil} + /// Clears the value of `optionalUint3265`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3265() {_uniqueStorage()._optionalUint3265 = nil} + + var optionalUint321: UInt32 { + get {_storage._optionalUint321 ?? 0} + set {_uniqueStorage()._optionalUint321 = newValue} + } + /// Returns true if `optionalUint321` has been explicitly set. + var hasOptionalUint321: Bool {_storage._optionalUint321 != nil} + /// Clears the value of `optionalUint321`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint321() {_uniqueStorage()._optionalUint321 = nil} + + var optionalUint322: UInt32 { + get {_storage._optionalUint322 ?? 0} + set {_uniqueStorage()._optionalUint322 = newValue} + } + /// Returns true if `optionalUint322` has been explicitly set. + var hasOptionalUint322: Bool {_storage._optionalUint322 != nil} + /// Clears the value of `optionalUint322`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint322() {_uniqueStorage()._optionalUint322 = nil} + + var optionalUint3263: UInt32 { + get {_storage._optionalUint3263 ?? 0} + set {_uniqueStorage()._optionalUint3263 = newValue} + } + /// Returns true if `optionalUint3263` has been explicitly set. + var hasOptionalUint3263: Bool {_storage._optionalUint3263 != nil} + /// Clears the value of `optionalUint3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3263() {_uniqueStorage()._optionalUint3263 = nil} + + var optionalUint3264: UInt32 { + get {_storage._optionalUint3264 ?? 0} + set {_uniqueStorage()._optionalUint3264 = newValue} + } + /// Returns true if `optionalUint3264` has been explicitly set. + var hasOptionalUint3264: Bool {_storage._optionalUint3264 != nil} + /// Clears the value of `optionalUint3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3264() {_uniqueStorage()._optionalUint3264 = nil} + + var optionalNested: EditionUnittest_TestVerifyBigFieldNumberUint32.Nested { + get {_storage._optionalNested ?? EditionUnittest_TestVerifyBigFieldNumberUint32.Nested()} + set {_uniqueStorage()._optionalNested = newValue} + } + /// Returns true if `optionalNested` has been explicitly set. + var hasOptionalNested: Bool {_storage._optionalNested != nil} + /// Clears the value of `optionalNested`. Subsequent reads from it will return its default value. + mutating func clearOptionalNested() {_uniqueStorage()._optionalNested = nil} + + var repeatedNested: [EditionUnittest_TestVerifyBigFieldNumberUint32.Nested] { + get {_storage._repeatedNested} + set {_uniqueStorage()._repeatedNested = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + init() {} + + fileprivate var _optionalNested: EditionUnittest_TestVerifyBigFieldNumberUint32.Nested? = nil +} + +/// This message contains different kind of enums to exercise the different +/// parsers in table-driven. +struct EditionUnittest_EnumParseTester: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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 optionalSeqSmall0Lowfield: EditionUnittest_EnumParseTester.SeqSmall0 { + get {_storage._optionalSeqSmall0Lowfield ?? .default} + set {_uniqueStorage()._optionalSeqSmall0Lowfield = newValue} + } + /// Returns true if `optionalSeqSmall0Lowfield` has been explicitly set. + var hasOptionalSeqSmall0Lowfield: Bool {_storage._optionalSeqSmall0Lowfield != nil} + /// Clears the value of `optionalSeqSmall0Lowfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalSeqSmall0Lowfield() {_uniqueStorage()._optionalSeqSmall0Lowfield = nil} + + var optionalSeqSmall0Midfield: EditionUnittest_EnumParseTester.SeqSmall0 { + get {_storage._optionalSeqSmall0Midfield ?? .default} + set {_uniqueStorage()._optionalSeqSmall0Midfield = newValue} + } + /// Returns true if `optionalSeqSmall0Midfield` has been explicitly set. + var hasOptionalSeqSmall0Midfield: Bool {_storage._optionalSeqSmall0Midfield != nil} + /// Clears the value of `optionalSeqSmall0Midfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalSeqSmall0Midfield() {_uniqueStorage()._optionalSeqSmall0Midfield = nil} + + var optionalSeqSmall0Hifield: EditionUnittest_EnumParseTester.SeqSmall0 { + get {_storage._optionalSeqSmall0Hifield ?? .default} + set {_uniqueStorage()._optionalSeqSmall0Hifield = newValue} + } + /// Returns true if `optionalSeqSmall0Hifield` has been explicitly set. + var hasOptionalSeqSmall0Hifield: Bool {_storage._optionalSeqSmall0Hifield != nil} + /// Clears the value of `optionalSeqSmall0Hifield`. Subsequent reads from it will return its default value. + mutating func clearOptionalSeqSmall0Hifield() {_uniqueStorage()._optionalSeqSmall0Hifield = nil} + + var repeatedSeqSmall0Lowfield: [EditionUnittest_EnumParseTester.SeqSmall0] { + get {_storage._repeatedSeqSmall0Lowfield} + set {_uniqueStorage()._repeatedSeqSmall0Lowfield = newValue} + } + + var repeatedSeqSmall0Midfield: [EditionUnittest_EnumParseTester.SeqSmall0] { + get {_storage._repeatedSeqSmall0Midfield} + set {_uniqueStorage()._repeatedSeqSmall0Midfield = newValue} + } + + var repeatedSeqSmall0Hifield: [EditionUnittest_EnumParseTester.SeqSmall0] { + get {_storage._repeatedSeqSmall0Hifield} + set {_uniqueStorage()._repeatedSeqSmall0Hifield = newValue} + } + + var packedSeqSmall0Lowfield: [EditionUnittest_EnumParseTester.SeqSmall0] { + get {_storage._packedSeqSmall0Lowfield} + set {_uniqueStorage()._packedSeqSmall0Lowfield = newValue} + } + + var packedSeqSmall0Midfield: [EditionUnittest_EnumParseTester.SeqSmall0] { + get {_storage._packedSeqSmall0Midfield} + set {_uniqueStorage()._packedSeqSmall0Midfield = newValue} + } + + var packedSeqSmall0Hifield: [EditionUnittest_EnumParseTester.SeqSmall0] { + get {_storage._packedSeqSmall0Hifield} + set {_uniqueStorage()._packedSeqSmall0Hifield = newValue} + } + + var optionalSeqSmall1Lowfield: EditionUnittest_EnumParseTester.SeqSmall1 { + get {_storage._optionalSeqSmall1Lowfield ?? .unknown} + set {_uniqueStorage()._optionalSeqSmall1Lowfield = newValue} + } + /// Returns true if `optionalSeqSmall1Lowfield` has been explicitly set. + var hasOptionalSeqSmall1Lowfield: Bool {_storage._optionalSeqSmall1Lowfield != nil} + /// Clears the value of `optionalSeqSmall1Lowfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalSeqSmall1Lowfield() {_uniqueStorage()._optionalSeqSmall1Lowfield = nil} + + var optionalSeqSmall1Midfield: EditionUnittest_EnumParseTester.SeqSmall1 { + get {_storage._optionalSeqSmall1Midfield ?? .unknown} + set {_uniqueStorage()._optionalSeqSmall1Midfield = newValue} + } + /// Returns true if `optionalSeqSmall1Midfield` has been explicitly set. + var hasOptionalSeqSmall1Midfield: Bool {_storage._optionalSeqSmall1Midfield != nil} + /// Clears the value of `optionalSeqSmall1Midfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalSeqSmall1Midfield() {_uniqueStorage()._optionalSeqSmall1Midfield = nil} + + var optionalSeqSmall1Hifield: EditionUnittest_EnumParseTester.SeqSmall1 { + get {_storage._optionalSeqSmall1Hifield ?? .unknown} + set {_uniqueStorage()._optionalSeqSmall1Hifield = newValue} + } + /// Returns true if `optionalSeqSmall1Hifield` has been explicitly set. + var hasOptionalSeqSmall1Hifield: Bool {_storage._optionalSeqSmall1Hifield != nil} + /// Clears the value of `optionalSeqSmall1Hifield`. Subsequent reads from it will return its default value. + mutating func clearOptionalSeqSmall1Hifield() {_uniqueStorage()._optionalSeqSmall1Hifield = nil} + + var repeatedSeqSmall1Lowfield: [EditionUnittest_EnumParseTester.SeqSmall1] { + get {_storage._repeatedSeqSmall1Lowfield} + set {_uniqueStorage()._repeatedSeqSmall1Lowfield = newValue} + } + + var repeatedSeqSmall1Midfield: [EditionUnittest_EnumParseTester.SeqSmall1] { + get {_storage._repeatedSeqSmall1Midfield} + set {_uniqueStorage()._repeatedSeqSmall1Midfield = newValue} + } + + var repeatedSeqSmall1Hifield: [EditionUnittest_EnumParseTester.SeqSmall1] { + get {_storage._repeatedSeqSmall1Hifield} + set {_uniqueStorage()._repeatedSeqSmall1Hifield = newValue} + } + + var packedSeqSmall1Lowfield: [EditionUnittest_EnumParseTester.SeqSmall1] { + get {_storage._packedSeqSmall1Lowfield} + set {_uniqueStorage()._packedSeqSmall1Lowfield = newValue} + } + + var packedSeqSmall1Midfield: [EditionUnittest_EnumParseTester.SeqSmall1] { + get {_storage._packedSeqSmall1Midfield} + set {_uniqueStorage()._packedSeqSmall1Midfield = newValue} + } + + var packedSeqSmall1Hifield: [EditionUnittest_EnumParseTester.SeqSmall1] { + get {_storage._packedSeqSmall1Hifield} + set {_uniqueStorage()._packedSeqSmall1Hifield = newValue} + } + + var optionalSeqLargeLowfield: EditionUnittest_EnumParseTester.SeqLarge { + get {_storage._optionalSeqLargeLowfield ?? .default} + set {_uniqueStorage()._optionalSeqLargeLowfield = newValue} + } + /// Returns true if `optionalSeqLargeLowfield` has been explicitly set. + var hasOptionalSeqLargeLowfield: Bool {_storage._optionalSeqLargeLowfield != nil} + /// Clears the value of `optionalSeqLargeLowfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalSeqLargeLowfield() {_uniqueStorage()._optionalSeqLargeLowfield = nil} + + var optionalSeqLargeMidfield: EditionUnittest_EnumParseTester.SeqLarge { + get {_storage._optionalSeqLargeMidfield ?? .default} + set {_uniqueStorage()._optionalSeqLargeMidfield = newValue} + } + /// Returns true if `optionalSeqLargeMidfield` has been explicitly set. + var hasOptionalSeqLargeMidfield: Bool {_storage._optionalSeqLargeMidfield != nil} + /// Clears the value of `optionalSeqLargeMidfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalSeqLargeMidfield() {_uniqueStorage()._optionalSeqLargeMidfield = nil} + + var optionalSeqLargeHifield: EditionUnittest_EnumParseTester.SeqLarge { + get {_storage._optionalSeqLargeHifield ?? .default} + set {_uniqueStorage()._optionalSeqLargeHifield = newValue} + } + /// Returns true if `optionalSeqLargeHifield` has been explicitly set. + var hasOptionalSeqLargeHifield: Bool {_storage._optionalSeqLargeHifield != nil} + /// Clears the value of `optionalSeqLargeHifield`. Subsequent reads from it will return its default value. + mutating func clearOptionalSeqLargeHifield() {_uniqueStorage()._optionalSeqLargeHifield = nil} + + var repeatedSeqLargeLowfield: [EditionUnittest_EnumParseTester.SeqLarge] { + get {_storage._repeatedSeqLargeLowfield} + set {_uniqueStorage()._repeatedSeqLargeLowfield = newValue} + } + + var repeatedSeqLargeMidfield: [EditionUnittest_EnumParseTester.SeqLarge] { + get {_storage._repeatedSeqLargeMidfield} + set {_uniqueStorage()._repeatedSeqLargeMidfield = newValue} + } + + var repeatedSeqLargeHifield: [EditionUnittest_EnumParseTester.SeqLarge] { + get {_storage._repeatedSeqLargeHifield} + set {_uniqueStorage()._repeatedSeqLargeHifield = newValue} + } + + var packedSeqLargeLowfield: [EditionUnittest_EnumParseTester.SeqLarge] { + get {_storage._packedSeqLargeLowfield} + set {_uniqueStorage()._packedSeqLargeLowfield = newValue} + } + + var packedSeqLargeMidfield: [EditionUnittest_EnumParseTester.SeqLarge] { + get {_storage._packedSeqLargeMidfield} + set {_uniqueStorage()._packedSeqLargeMidfield = newValue} + } + + var packedSeqLargeHifield: [EditionUnittest_EnumParseTester.SeqLarge] { + get {_storage._packedSeqLargeHifield} + set {_uniqueStorage()._packedSeqLargeHifield = newValue} + } + + var optionalArbitraryLowfield: EditionUnittest_EnumParseTester.Arbitrary { + get {_storage._optionalArbitraryLowfield ?? .default} + set {_uniqueStorage()._optionalArbitraryLowfield = newValue} + } + /// Returns true if `optionalArbitraryLowfield` has been explicitly set. + var hasOptionalArbitraryLowfield: Bool {_storage._optionalArbitraryLowfield != nil} + /// Clears the value of `optionalArbitraryLowfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalArbitraryLowfield() {_uniqueStorage()._optionalArbitraryLowfield = nil} + + var optionalArbitraryMidfield: EditionUnittest_EnumParseTester.Arbitrary { + get {_storage._optionalArbitraryMidfield ?? .default} + set {_uniqueStorage()._optionalArbitraryMidfield = newValue} + } + /// Returns true if `optionalArbitraryMidfield` has been explicitly set. + var hasOptionalArbitraryMidfield: Bool {_storage._optionalArbitraryMidfield != nil} + /// Clears the value of `optionalArbitraryMidfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalArbitraryMidfield() {_uniqueStorage()._optionalArbitraryMidfield = nil} + + var optionalArbitraryHifield: EditionUnittest_EnumParseTester.Arbitrary { + get {_storage._optionalArbitraryHifield ?? .default} + set {_uniqueStorage()._optionalArbitraryHifield = newValue} + } + /// Returns true if `optionalArbitraryHifield` has been explicitly set. + var hasOptionalArbitraryHifield: Bool {_storage._optionalArbitraryHifield != nil} + /// Clears the value of `optionalArbitraryHifield`. Subsequent reads from it will return its default value. + mutating func clearOptionalArbitraryHifield() {_uniqueStorage()._optionalArbitraryHifield = nil} + + var repeatedArbitraryLowfield: [EditionUnittest_EnumParseTester.Arbitrary] { + get {_storage._repeatedArbitraryLowfield} + set {_uniqueStorage()._repeatedArbitraryLowfield = newValue} + } + + var repeatedArbitraryMidfield: [EditionUnittest_EnumParseTester.Arbitrary] { + get {_storage._repeatedArbitraryMidfield} + set {_uniqueStorage()._repeatedArbitraryMidfield = newValue} + } + + var repeatedArbitraryHifield: [EditionUnittest_EnumParseTester.Arbitrary] { + get {_storage._repeatedArbitraryHifield} + set {_uniqueStorage()._repeatedArbitraryHifield = newValue} + } + + var packedArbitraryLowfield: [EditionUnittest_EnumParseTester.Arbitrary] { + get {_storage._packedArbitraryLowfield} + set {_uniqueStorage()._packedArbitraryLowfield = newValue} + } + + var packedArbitraryMidfield: [EditionUnittest_EnumParseTester.Arbitrary] { + get {_storage._packedArbitraryMidfield} + set {_uniqueStorage()._packedArbitraryMidfield = newValue} + } + + var packedArbitraryHifield: [EditionUnittest_EnumParseTester.Arbitrary] { + get {_storage._packedArbitraryHifield} + set {_uniqueStorage()._packedArbitraryHifield = newValue} + } + + /// An arbitrary field we can append to to break the runs of repeated fields. + var otherField: Int32 { + get {_storage._otherField ?? 0} + set {_uniqueStorage()._otherField = newValue} + } + /// Returns true if `otherField` has been explicitly set. + var hasOtherField: Bool {_storage._otherField != nil} + /// Clears the value of `otherField`. Subsequent reads from it will return its default value. + mutating func clearOtherField() {_uniqueStorage()._otherField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum SeqSmall0: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case `default` = 0 + case seqSmall01 = 1 + case seqSmall02 = 2 + + init() { + self = .default + } + + } + + enum SeqSmall1: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unknown = 0 + case `default` = 1 + case seqSmall12 = 2 + case seqSmall13 = 3 + + init() { + self = .unknown + } + + } + + enum SeqLarge: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case `default` = -1 + case seqLarge0 = 0 + case seqLarge1 = 1 + case seqLarge2 = 2 + case seqLarge3 = 3 + case seqLarge4 = 4 + case seqLarge5 = 5 + case seqLarge6 = 6 + case seqLarge7 = 7 + case seqLarge8 = 8 + case seqLarge9 = 9 + case seqLarge10 = 10 + case seqLarge11 = 11 + case seqLarge12 = 12 + case seqLarge13 = 13 + case seqLarge14 = 14 + case seqLarge15 = 15 + case seqLarge16 = 16 + case seqLarge17 = 17 + case seqLarge18 = 18 + case seqLarge19 = 19 + case seqLarge20 = 20 + case seqLarge21 = 21 + case seqLarge22 = 22 + case seqLarge23 = 23 + case seqLarge24 = 24 + case seqLarge25 = 25 + case seqLarge26 = 26 + case seqLarge27 = 27 + case seqLarge28 = 28 + case seqLarge29 = 29 + case seqLarge30 = 30 + case seqLarge31 = 31 + case seqLarge32 = 32 + case seqLarge33 = 33 + + init() { + self = .default + } + + } + + enum Arbitrary: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case `default` = -123123 + case arbitrary1 = -123 + case arbitrary2 = 213 + case arbitrary3 = 213213 + case min = -2147483648 + case max = 2147483647 + + init() { + self = .default + } + + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// This message contains different kind of bool fields to exercise the different +/// parsers in table-drived. +struct EditionUnittest_BoolParseTester: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 optionalBoolLowfield: Bool { + get {_optionalBoolLowfield ?? false} + set {_optionalBoolLowfield = newValue} + } + /// Returns true if `optionalBoolLowfield` has been explicitly set. + var hasOptionalBoolLowfield: Bool {self._optionalBoolLowfield != nil} + /// Clears the value of `optionalBoolLowfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalBoolLowfield() {self._optionalBoolLowfield = nil} + + var optionalBoolMidfield: Bool { + get {_optionalBoolMidfield ?? false} + set {_optionalBoolMidfield = newValue} + } + /// Returns true if `optionalBoolMidfield` has been explicitly set. + var hasOptionalBoolMidfield: Bool {self._optionalBoolMidfield != nil} + /// Clears the value of `optionalBoolMidfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalBoolMidfield() {self._optionalBoolMidfield = nil} + + var optionalBoolHifield: Bool { + get {_optionalBoolHifield ?? false} + set {_optionalBoolHifield = newValue} + } + /// Returns true if `optionalBoolHifield` has been explicitly set. + var hasOptionalBoolHifield: Bool {self._optionalBoolHifield != nil} + /// Clears the value of `optionalBoolHifield`. Subsequent reads from it will return its default value. + mutating func clearOptionalBoolHifield() {self._optionalBoolHifield = nil} + + var repeatedBoolLowfield: [Bool] = [] + + var repeatedBoolMidfield: [Bool] = [] + + var repeatedBoolHifield: [Bool] = [] + + var packedBoolLowfield: [Bool] = [] + + var packedBoolMidfield: [Bool] = [] + + var packedBoolHifield: [Bool] = [] + + /// An arbitrary field we can append to to break the runs of repeated fields. + var otherField: Int32 { + get {_otherField ?? 0} + set {_otherField = newValue} + } + /// Returns true if `otherField` has been explicitly set. + var hasOtherField: Bool {self._otherField != nil} + /// Clears the value of `otherField`. Subsequent reads from it will return its default value. + mutating func clearOtherField() {self._otherField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _optionalBoolLowfield: Bool? = nil + fileprivate var _optionalBoolMidfield: Bool? = nil + fileprivate var _optionalBoolHifield: Bool? = nil + fileprivate var _otherField: Int32? = nil +} + +struct EditionUnittest_Int32ParseTester: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 optionalInt32Lowfield: Int32 { + get {_optionalInt32Lowfield ?? 0} + set {_optionalInt32Lowfield = newValue} + } + /// Returns true if `optionalInt32Lowfield` has been explicitly set. + var hasOptionalInt32Lowfield: Bool {self._optionalInt32Lowfield != nil} + /// Clears the value of `optionalInt32Lowfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32Lowfield() {self._optionalInt32Lowfield = nil} + + var optionalInt32Midfield: Int32 { + get {_optionalInt32Midfield ?? 0} + set {_optionalInt32Midfield = newValue} + } + /// Returns true if `optionalInt32Midfield` has been explicitly set. + var hasOptionalInt32Midfield: Bool {self._optionalInt32Midfield != nil} + /// Clears the value of `optionalInt32Midfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32Midfield() {self._optionalInt32Midfield = nil} + + var optionalInt32Hifield: Int32 { + get {_optionalInt32Hifield ?? 0} + set {_optionalInt32Hifield = newValue} + } + /// Returns true if `optionalInt32Hifield` has been explicitly set. + var hasOptionalInt32Hifield: Bool {self._optionalInt32Hifield != nil} + /// Clears the value of `optionalInt32Hifield`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32Hifield() {self._optionalInt32Hifield = nil} + + var repeatedInt32Lowfield: [Int32] = [] + + var repeatedInt32Midfield: [Int32] = [] + + var repeatedInt32Hifield: [Int32] = [] + + var packedInt32Lowfield: [Int32] = [] + + var packedInt32Midfield: [Int32] = [] + + var packedInt32Hifield: [Int32] = [] + + /// An arbitrary field we can append to to break the runs of repeated fields. + var otherField: Int32 { + get {_otherField ?? 0} + set {_otherField = newValue} + } + /// Returns true if `otherField` has been explicitly set. + var hasOtherField: Bool {self._otherField != nil} + /// Clears the value of `otherField`. Subsequent reads from it will return its default value. + mutating func clearOtherField() {self._otherField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _optionalInt32Lowfield: Int32? = nil + fileprivate var _optionalInt32Midfield: Int32? = nil + fileprivate var _optionalInt32Hifield: Int32? = nil + fileprivate var _otherField: Int32? = nil +} + +struct EditionUnittest_Int64ParseTester: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 optionalInt64Lowfield: Int64 { + get {_optionalInt64Lowfield ?? 0} + set {_optionalInt64Lowfield = newValue} + } + /// Returns true if `optionalInt64Lowfield` has been explicitly set. + var hasOptionalInt64Lowfield: Bool {self._optionalInt64Lowfield != nil} + /// Clears the value of `optionalInt64Lowfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64Lowfield() {self._optionalInt64Lowfield = nil} + + var optionalInt64Midfield: Int64 { + get {_optionalInt64Midfield ?? 0} + set {_optionalInt64Midfield = newValue} + } + /// Returns true if `optionalInt64Midfield` has been explicitly set. + var hasOptionalInt64Midfield: Bool {self._optionalInt64Midfield != nil} + /// Clears the value of `optionalInt64Midfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64Midfield() {self._optionalInt64Midfield = nil} + + var optionalInt64Hifield: Int64 { + get {_optionalInt64Hifield ?? 0} + set {_optionalInt64Hifield = newValue} + } + /// Returns true if `optionalInt64Hifield` has been explicitly set. + var hasOptionalInt64Hifield: Bool {self._optionalInt64Hifield != nil} + /// Clears the value of `optionalInt64Hifield`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64Hifield() {self._optionalInt64Hifield = nil} + + var repeatedInt64Lowfield: [Int64] = [] + + var repeatedInt64Midfield: [Int64] = [] + + var repeatedInt64Hifield: [Int64] = [] + + var packedInt64Lowfield: [Int64] = [] + + var packedInt64Midfield: [Int64] = [] + + var packedInt64Hifield: [Int64] = [] + + /// An arbitrary field we can append to to break the runs of repeated fields. + var otherField: Int32 { + get {_otherField ?? 0} + set {_otherField = newValue} + } + /// Returns true if `otherField` has been explicitly set. + var hasOtherField: Bool {self._otherField != nil} + /// Clears the value of `otherField`. Subsequent reads from it will return its default value. + mutating func clearOtherField() {self._otherField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _optionalInt64Lowfield: Int64? = nil + fileprivate var _optionalInt64Midfield: Int64? = nil + fileprivate var _optionalInt64Hifield: Int64? = nil + fileprivate var _otherField: Int32? = nil +} + +struct EditionUnittest_InlinedStringIdxRegressionProto: @unchecked Sendable { + // 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 mix data to make sure aux ids and inlined string idx do not match. + /// aux_idx == inlined_string_idx == 1 + var str1: String { + get {_storage._str1 ?? String()} + set {_uniqueStorage()._str1 = newValue} + } + /// Returns true if `str1` has been explicitly set. + var hasStr1: Bool {_storage._str1 != nil} + /// Clears the value of `str1`. Subsequent reads from it will return its default value. + mutating func clearStr1() {_uniqueStorage()._str1 = nil} + + /// aux_idx == 2 + var sub: EditionUnittest_InlinedStringIdxRegressionProto { + get {_storage._sub ?? EditionUnittest_InlinedStringIdxRegressionProto()} + set {_uniqueStorage()._sub = newValue} + } + /// Returns true if `sub` has been explicitly set. + var hasSub: Bool {_storage._sub != nil} + /// Clears the value of `sub`. Subsequent reads from it will return its default value. + mutating func clearSub() {_uniqueStorage()._sub = nil} + + /// aux_idx == 3, inlined_string_idx == 2 + var str2: String { + get {_storage._str2 ?? String()} + set {_uniqueStorage()._str2 = newValue} + } + /// Returns true if `str2` has been explicitly set. + var hasStr2: Bool {_storage._str2 != nil} + /// Clears the value of `str2`. Subsequent reads from it will return its default value. + mutating func clearStr2() {_uniqueStorage()._str2 = nil} + + /// aux_idx == 4, inlined_string_idx == 3 + var str3: Data { + get {_storage._str3 ?? Data()} + set {_uniqueStorage()._str3 = newValue} + } + /// Returns true if `str3` has been explicitly set. + var hasStr3: Bool {_storage._str3 != nil} + /// Clears the value of `str3`. Subsequent reads from it will return its default value. + mutating func clearStr3() {_uniqueStorage()._str3 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct EditionUnittest_StringParseTester: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 optionalStringLowfield: String { + get {_optionalStringLowfield ?? String()} + set {_optionalStringLowfield = newValue} + } + /// Returns true if `optionalStringLowfield` has been explicitly set. + var hasOptionalStringLowfield: Bool {self._optionalStringLowfield != nil} + /// Clears the value of `optionalStringLowfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringLowfield() {self._optionalStringLowfield = nil} + + var optionalStringMidfield: String { + get {_optionalStringMidfield ?? String()} + set {_optionalStringMidfield = newValue} + } + /// Returns true if `optionalStringMidfield` has been explicitly set. + var hasOptionalStringMidfield: Bool {self._optionalStringMidfield != nil} + /// Clears the value of `optionalStringMidfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringMidfield() {self._optionalStringMidfield = nil} + + var optionalStringHifield: String { + get {_optionalStringHifield ?? String()} + set {_optionalStringHifield = newValue} + } + /// Returns true if `optionalStringHifield` has been explicitly set. + var hasOptionalStringHifield: Bool {self._optionalStringHifield != nil} + /// Clears the value of `optionalStringHifield`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringHifield() {self._optionalStringHifield = nil} + + var repeatedStringLowfield: [String] = [] + + var repeatedStringMidfield: [String] = [] + + var repeatedStringHifield: [String] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _optionalStringLowfield: String? = nil + fileprivate var _optionalStringMidfield: String? = nil + fileprivate var _optionalStringHifield: String? = nil +} + +struct EditionUnittest_BadFieldNames: Sendable { + // 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 optionalInt32: Int32 { + get {_optionalInt32 ?? 0} + set {_optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {self._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {self._optionalInt32 = nil} + + var `for`: Int32 { + get {_for ?? 0} + set {_for = newValue} + } + /// Returns true if ``for`` has been explicitly set. + var hasFor: Bool {self._for != nil} + /// Clears the value of ``for``. Subsequent reads from it will return its default value. + mutating func clearFor() {self._for = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalInt32: Int32? = nil + fileprivate var _for: Int32? = nil +} + +struct EditionUnittest_TestNestedMessageRedaction: Sendable { + // 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 optionalUnredactedNestedString: String { + get {_optionalUnredactedNestedString ?? String()} + set {_optionalUnredactedNestedString = newValue} + } + /// Returns true if `optionalUnredactedNestedString` has been explicitly set. + var hasOptionalUnredactedNestedString: Bool {self._optionalUnredactedNestedString != nil} + /// Clears the value of `optionalUnredactedNestedString`. Subsequent reads from it will return its default value. + mutating func clearOptionalUnredactedNestedString() {self._optionalUnredactedNestedString = nil} + + var optionalRedactedNestedString: String { + get {_optionalRedactedNestedString ?? String()} + set {_optionalRedactedNestedString = newValue} + } + /// Returns true if `optionalRedactedNestedString` has been explicitly set. + var hasOptionalRedactedNestedString: Bool {self._optionalRedactedNestedString != nil} + /// Clears the value of `optionalRedactedNestedString`. Subsequent reads from it will return its default value. + mutating func clearOptionalRedactedNestedString() {self._optionalRedactedNestedString = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalUnredactedNestedString: String? = nil + fileprivate var _optionalRedactedNestedString: String? = nil +} + +struct EditionUnittest_RedactedFields: Sendable { + // 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 optionalRedactedString: String { + get {_optionalRedactedString ?? String()} + set {_optionalRedactedString = newValue} + } + /// Returns true if `optionalRedactedString` has been explicitly set. + var hasOptionalRedactedString: Bool {self._optionalRedactedString != nil} + /// Clears the value of `optionalRedactedString`. Subsequent reads from it will return its default value. + mutating func clearOptionalRedactedString() {self._optionalRedactedString = nil} + + var optionalUnredactedString: String { + get {_optionalUnredactedString ?? String()} + set {_optionalUnredactedString = newValue} + } + /// Returns true if `optionalUnredactedString` has been explicitly set. + var hasOptionalUnredactedString: Bool {self._optionalUnredactedString != nil} + /// Clears the value of `optionalUnredactedString`. Subsequent reads from it will return its default value. + mutating func clearOptionalUnredactedString() {self._optionalUnredactedString = nil} + + var repeatedRedactedString: [String] = [] + + var repeatedUnredactedString: [String] = [] + + var optionalRedactedMessage: EditionUnittest_TestNestedMessageRedaction { + get {_optionalRedactedMessage ?? EditionUnittest_TestNestedMessageRedaction()} + set {_optionalRedactedMessage = newValue} + } + /// Returns true if `optionalRedactedMessage` has been explicitly set. + var hasOptionalRedactedMessage: Bool {self._optionalRedactedMessage != nil} + /// Clears the value of `optionalRedactedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalRedactedMessage() {self._optionalRedactedMessage = nil} + + var optionalUnredactedMessage: EditionUnittest_TestNestedMessageRedaction { + get {_optionalUnredactedMessage ?? EditionUnittest_TestNestedMessageRedaction()} + set {_optionalUnredactedMessage = newValue} + } + /// Returns true if `optionalUnredactedMessage` has been explicitly set. + var hasOptionalUnredactedMessage: Bool {self._optionalUnredactedMessage != nil} + /// Clears the value of `optionalUnredactedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalUnredactedMessage() {self._optionalUnredactedMessage = nil} + + var repeatedRedactedMessage: [EditionUnittest_TestNestedMessageRedaction] = [] + + var repeatedUnredactedMessage: [EditionUnittest_TestNestedMessageRedaction] = [] + + var mapRedactedString: Dictionary = [:] + + var mapUnredactedString: Dictionary = [:] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalRedactedString: String? = nil + fileprivate var _optionalUnredactedString: String? = nil + fileprivate var _optionalRedactedMessage: EditionUnittest_TestNestedMessageRedaction? = nil + fileprivate var _optionalUnredactedMessage: EditionUnittest_TestNestedMessageRedaction? = nil +} + +struct EditionUnittest_TestCord: Sendable { + // 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 optionalBytesCord: Data { + get {_optionalBytesCord ?? Data()} + set {_optionalBytesCord = newValue} + } + /// Returns true if `optionalBytesCord` has been explicitly set. + var hasOptionalBytesCord: Bool {self._optionalBytesCord != nil} + /// Clears the value of `optionalBytesCord`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytesCord() {self._optionalBytesCord = nil} + + var optionalBytesCordDefault: Data { + get {_optionalBytesCordDefault ?? Data([104, 101, 108, 108, 111])} + set {_optionalBytesCordDefault = newValue} + } + /// Returns true if `optionalBytesCordDefault` has been explicitly set. + var hasOptionalBytesCordDefault: Bool {self._optionalBytesCordDefault != nil} + /// Clears the value of `optionalBytesCordDefault`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytesCordDefault() {self._optionalBytesCordDefault = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalBytesCord: Data? = nil + fileprivate var _optionalBytesCordDefault: Data? = nil +} + +struct EditionUnittest_TestPackedEnumSmallRange: Sendable { + // 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 vals: [EditionUnittest_TestPackedEnumSmallRange.NestedEnum] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unspecified = 0 + case foo = 1 + case bar = 2 + case baz = 3 + + init() { + self = .unspecified + } + + } + + init() {} +} + +struct EditionUnittest_EnumsForBenchmark: Sendable { + // 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() + + enum Flat: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case a0 = 0 + case a1 = 1 + case a2 = 2 + case a3 = 3 + case a4 = 4 + case a5 = 5 + case a6 = 6 + case a7 = 7 + case a8 = 8 + case a9 = 9 + case a10 = 10 + case a11 = 11 + case a12 = 12 + case a13 = 13 + case a14 = 14 + case a15 = 15 + + init() { + self = .a0 + } + + } + + /// Has a few holes, bitmap can be used. + enum AlmostFlat: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case b0 = 0 + case b1 = 1 + case b2 = 2 + case b3 = 3 + case b5 = 5 + case b6 = 6 + case b7 = 7 + case b8 = 8 + case b9 = 9 + case b11 = 11 + case b12 = 12 + case b13 = 13 + case b14 = 14 + case b15 = 15 + case b17 = 17 + case b19 = 19 + + init() { + self = .b0 + } + + } + + enum Sparse: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case c0 = 0 + case c536 = 536 + case c8387 = 8387 + case c9673 = 9673 + case c10285 = 10285 + case c13318 = 13318 + case c15963 = 15963 + case c16439 = 16439 + case c18197 = 18197 + case c19430 = 19430 + case c20361 = 20361 + case c20706 = 20706 + case c21050 = 21050 + case c21906 = 21906 + case c27265 = 27265 + case c30109 = 30109 + case c31670 = 31670 + + init() { + self = .c0 + } + + } + + init() {} +} + +struct EditionUnittest_TestMessageWithManyRepeatedPtrFields: @unchecked Sendable { + // 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 repeatedString1: [String] { + get {_storage._repeatedString1} + set {_uniqueStorage()._repeatedString1 = newValue} + } + + var repeatedString2: [String] { + get {_storage._repeatedString2} + set {_uniqueStorage()._repeatedString2 = newValue} + } + + var repeatedString3: [String] { + get {_storage._repeatedString3} + set {_uniqueStorage()._repeatedString3 = newValue} + } + + var repeatedString4: [String] { + get {_storage._repeatedString4} + set {_uniqueStorage()._repeatedString4 = newValue} + } + + var repeatedString5: [String] { + get {_storage._repeatedString5} + set {_uniqueStorage()._repeatedString5 = newValue} + } + + var repeatedString6: [String] { + get {_storage._repeatedString6} + set {_uniqueStorage()._repeatedString6 = newValue} + } + + var repeatedString7: [String] { + get {_storage._repeatedString7} + set {_uniqueStorage()._repeatedString7 = newValue} + } + + var repeatedString8: [String] { + get {_storage._repeatedString8} + set {_uniqueStorage()._repeatedString8 = newValue} + } + + var repeatedString9: [String] { + get {_storage._repeatedString9} + set {_uniqueStorage()._repeatedString9 = newValue} + } + + var repeatedString10: [String] { + get {_storage._repeatedString10} + set {_uniqueStorage()._repeatedString10 = newValue} + } + + var repeatedString11: [String] { + get {_storage._repeatedString11} + set {_uniqueStorage()._repeatedString11 = newValue} + } + + var repeatedString12: [String] { + get {_storage._repeatedString12} + set {_uniqueStorage()._repeatedString12 = newValue} + } + + var repeatedString13: [String] { + get {_storage._repeatedString13} + set {_uniqueStorage()._repeatedString13 = newValue} + } + + var repeatedString14: [String] { + get {_storage._repeatedString14} + set {_uniqueStorage()._repeatedString14 = newValue} + } + + var repeatedString15: [String] { + get {_storage._repeatedString15} + set {_uniqueStorage()._repeatedString15 = newValue} + } + + var repeatedString16: [String] { + get {_storage._repeatedString16} + set {_uniqueStorage()._repeatedString16 = newValue} + } + + var repeatedString17: [String] { + get {_storage._repeatedString17} + set {_uniqueStorage()._repeatedString17 = newValue} + } + + var repeatedString18: [String] { + get {_storage._repeatedString18} + set {_uniqueStorage()._repeatedString18 = newValue} + } + + var repeatedString19: [String] { + get {_storage._repeatedString19} + set {_uniqueStorage()._repeatedString19 = newValue} + } + + var repeatedString20: [String] { + get {_storage._repeatedString20} + set {_uniqueStorage()._repeatedString20 = newValue} + } + + var repeatedString21: [String] { + get {_storage._repeatedString21} + set {_uniqueStorage()._repeatedString21 = newValue} + } + + var repeatedString22: [String] { + get {_storage._repeatedString22} + set {_uniqueStorage()._repeatedString22 = newValue} + } + + var repeatedString23: [String] { + get {_storage._repeatedString23} + set {_uniqueStorage()._repeatedString23 = newValue} + } + + var repeatedString24: [String] { + get {_storage._repeatedString24} + set {_uniqueStorage()._repeatedString24 = newValue} + } + + var repeatedString25: [String] { + get {_storage._repeatedString25} + set {_uniqueStorage()._repeatedString25 = newValue} + } + + var repeatedString26: [String] { + get {_storage._repeatedString26} + set {_uniqueStorage()._repeatedString26 = newValue} + } + + var repeatedString27: [String] { + get {_storage._repeatedString27} + set {_uniqueStorage()._repeatedString27 = newValue} + } + + var repeatedString28: [String] { + get {_storage._repeatedString28} + set {_uniqueStorage()._repeatedString28 = newValue} + } + + var repeatedString29: [String] { + get {_storage._repeatedString29} + set {_uniqueStorage()._repeatedString29 = newValue} + } + + var repeatedString30: [String] { + get {_storage._repeatedString30} + set {_uniqueStorage()._repeatedString30 = newValue} + } + + var repeatedString31: [String] { + get {_storage._repeatedString31} + set {_uniqueStorage()._repeatedString31 = newValue} + } + + var repeatedString32: [String] { + get {_storage._repeatedString32} + set {_uniqueStorage()._repeatedString32 = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Extension support defined in edition_unittest.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 EditionUnittest_BoolParseTester { + + var EditionUnittest_BoolParseTester_optionalBoolExt: Bool { + get {return getExtensionValue(ext: EditionUnittest_BoolParseTester.Extensions.optional_bool_ext) ?? false} + set {setExtensionValue(ext: EditionUnittest_BoolParseTester.Extensions.optional_bool_ext, value: newValue)} + } + /// Returns true if extension `EditionUnittest_BoolParseTester.Extensions.optional_bool_ext` + /// has been explicitly set. + var hasEditionUnittest_BoolParseTester_optionalBoolExt: Bool { + return hasExtensionValue(ext: EditionUnittest_BoolParseTester.Extensions.optional_bool_ext) + } + /// Clears the value of extension `EditionUnittest_BoolParseTester.Extensions.optional_bool_ext`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_BoolParseTester_optionalBoolExt() { + clearExtensionValue(ext: EditionUnittest_BoolParseTester.Extensions.optional_bool_ext) + } + + var EditionUnittest_BoolParseTester_repeatedBoolExt: [Bool] { + get {return getExtensionValue(ext: EditionUnittest_BoolParseTester.Extensions.repeated_bool_ext) ?? []} + set {setExtensionValue(ext: EditionUnittest_BoolParseTester.Extensions.repeated_bool_ext, value: newValue)} + } + + var EditionUnittest_BoolParseTester_packedBoolExt: [Bool] { + get {return getExtensionValue(ext: EditionUnittest_BoolParseTester.Extensions.packed_bool_ext) ?? []} + set {setExtensionValue(ext: EditionUnittest_BoolParseTester.Extensions.packed_bool_ext, value: newValue)} + } +} + +extension EditionUnittest_EnumParseTester { + + var EditionUnittest_EnumParseTester_optionalArbitraryExt: EditionUnittest_EnumParseTester.Arbitrary { + get {return getExtensionValue(ext: EditionUnittest_EnumParseTester.Extensions.optional_arbitrary_ext) ?? .default} + set {setExtensionValue(ext: EditionUnittest_EnumParseTester.Extensions.optional_arbitrary_ext, value: newValue)} + } + /// Returns true if extension `EditionUnittest_EnumParseTester.Extensions.optional_arbitrary_ext` + /// has been explicitly set. + var hasEditionUnittest_EnumParseTester_optionalArbitraryExt: Bool { + return hasExtensionValue(ext: EditionUnittest_EnumParseTester.Extensions.optional_arbitrary_ext) + } + /// Clears the value of extension `EditionUnittest_EnumParseTester.Extensions.optional_arbitrary_ext`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_EnumParseTester_optionalArbitraryExt() { + clearExtensionValue(ext: EditionUnittest_EnumParseTester.Extensions.optional_arbitrary_ext) + } + + var EditionUnittest_EnumParseTester_repeatedArbitraryExt: [EditionUnittest_EnumParseTester.Arbitrary] { + get {return getExtensionValue(ext: EditionUnittest_EnumParseTester.Extensions.repeated_arbitrary_ext) ?? []} + set {setExtensionValue(ext: EditionUnittest_EnumParseTester.Extensions.repeated_arbitrary_ext, value: newValue)} + } + + var EditionUnittest_EnumParseTester_packedArbitraryExt: [EditionUnittest_EnumParseTester.Arbitrary] { + get {return getExtensionValue(ext: EditionUnittest_EnumParseTester.Extensions.packed_arbitrary_ext) ?? []} + set {setExtensionValue(ext: EditionUnittest_EnumParseTester.Extensions.packed_arbitrary_ext, value: newValue)} + } +} + +extension EditionUnittest_Int32ParseTester { + + var EditionUnittest_Int32ParseTester_optionalInt32Ext: Int32 { + get {return getExtensionValue(ext: EditionUnittest_Int32ParseTester.Extensions.optional_int32_ext) ?? 0} + set {setExtensionValue(ext: EditionUnittest_Int32ParseTester.Extensions.optional_int32_ext, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Int32ParseTester.Extensions.optional_int32_ext` + /// has been explicitly set. + var hasEditionUnittest_Int32ParseTester_optionalInt32Ext: Bool { + return hasExtensionValue(ext: EditionUnittest_Int32ParseTester.Extensions.optional_int32_ext) + } + /// Clears the value of extension `EditionUnittest_Int32ParseTester.Extensions.optional_int32_ext`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_Int32ParseTester_optionalInt32Ext() { + clearExtensionValue(ext: EditionUnittest_Int32ParseTester.Extensions.optional_int32_ext) + } + + var EditionUnittest_Int32ParseTester_repeatedInt32Ext: [Int32] { + get {return getExtensionValue(ext: EditionUnittest_Int32ParseTester.Extensions.repeated_int32_ext) ?? []} + set {setExtensionValue(ext: EditionUnittest_Int32ParseTester.Extensions.repeated_int32_ext, value: newValue)} + } + + var EditionUnittest_Int32ParseTester_packedInt32Ext: [Int32] { + get {return getExtensionValue(ext: EditionUnittest_Int32ParseTester.Extensions.packed_int32_ext) ?? []} + set {setExtensionValue(ext: EditionUnittest_Int32ParseTester.Extensions.packed_int32_ext, value: newValue)} + } +} + +extension EditionUnittest_Int64ParseTester { + + var EditionUnittest_Int64ParseTester_optionalInt64Ext: Int64 { + get {return getExtensionValue(ext: EditionUnittest_Int64ParseTester.Extensions.optional_int64_ext) ?? 0} + set {setExtensionValue(ext: EditionUnittest_Int64ParseTester.Extensions.optional_int64_ext, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Int64ParseTester.Extensions.optional_int64_ext` + /// has been explicitly set. + var hasEditionUnittest_Int64ParseTester_optionalInt64Ext: Bool { + return hasExtensionValue(ext: EditionUnittest_Int64ParseTester.Extensions.optional_int64_ext) + } + /// Clears the value of extension `EditionUnittest_Int64ParseTester.Extensions.optional_int64_ext`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_Int64ParseTester_optionalInt64Ext() { + clearExtensionValue(ext: EditionUnittest_Int64ParseTester.Extensions.optional_int64_ext) + } + + var EditionUnittest_Int64ParseTester_repeatedInt64Ext: [Int64] { + get {return getExtensionValue(ext: EditionUnittest_Int64ParseTester.Extensions.repeated_int64_ext) ?? []} + set {setExtensionValue(ext: EditionUnittest_Int64ParseTester.Extensions.repeated_int64_ext, value: newValue)} + } + + var EditionUnittest_Int64ParseTester_packedInt64Ext: [Int64] { + get {return getExtensionValue(ext: EditionUnittest_Int64ParseTester.Extensions.packed_int64_ext) ?? []} + set {setExtensionValue(ext: EditionUnittest_Int64ParseTester.Extensions.packed_int64_ext, value: newValue)} + } +} + +extension EditionUnittest_StringParseTester { + + var EditionUnittest_StringParseTester_optionalStringExt: String { + get {return getExtensionValue(ext: EditionUnittest_StringParseTester.Extensions.optional_string_ext) ?? String()} + set {setExtensionValue(ext: EditionUnittest_StringParseTester.Extensions.optional_string_ext, value: newValue)} + } + /// Returns true if extension `EditionUnittest_StringParseTester.Extensions.optional_string_ext` + /// has been explicitly set. + var hasEditionUnittest_StringParseTester_optionalStringExt: Bool { + return hasExtensionValue(ext: EditionUnittest_StringParseTester.Extensions.optional_string_ext) + } + /// Clears the value of extension `EditionUnittest_StringParseTester.Extensions.optional_string_ext`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_StringParseTester_optionalStringExt() { + clearExtensionValue(ext: EditionUnittest_StringParseTester.Extensions.optional_string_ext) + } + + var EditionUnittest_StringParseTester_repeatedStringExt: [String] { + get {return getExtensionValue(ext: EditionUnittest_StringParseTester.Extensions.repeated_string_ext) ?? []} + set {setExtensionValue(ext: EditionUnittest_StringParseTester.Extensions.repeated_string_ext, value: newValue)} + } +} + +extension EditionUnittest_TestAllExtensions { + + /// Singular + var EditionUnittest_optionalInt32Extension: Int32 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_int32_extension) ?? 0} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_int32_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_int32_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalInt32Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_int32_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_int32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalInt32Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_int32_extension) + } + + var EditionUnittest_optionalInt64Extension: Int64 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_int64_extension) ?? 0} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_int64_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_int64_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalInt64Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_int64_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_int64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalInt64Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_int64_extension) + } + + var EditionUnittest_optionalUint32Extension: UInt32 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_uint32_extension) ?? 0} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_uint32_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_uint32_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalUint32Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_uint32_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_uint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalUint32Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_uint32_extension) + } + + var EditionUnittest_optionalUint64Extension: UInt64 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_uint64_extension) ?? 0} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_uint64_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_uint64_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalUint64Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_uint64_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_uint64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalUint64Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_uint64_extension) + } + + var EditionUnittest_optionalSint32Extension: Int32 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_sint32_extension) ?? 0} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_sint32_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_sint32_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalSint32Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_sint32_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_sint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalSint32Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_sint32_extension) + } + + var EditionUnittest_optionalSint64Extension: Int64 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_sint64_extension) ?? 0} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_sint64_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_sint64_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalSint64Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_sint64_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_sint64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalSint64Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_sint64_extension) + } + + var EditionUnittest_optionalFixed32Extension: UInt32 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_fixed32_extension) ?? 0} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_fixed32_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_fixed32_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalFixed32Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_fixed32_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_fixed32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalFixed32Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_fixed32_extension) + } + + var EditionUnittest_optionalFixed64Extension: UInt64 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_fixed64_extension) ?? 0} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_fixed64_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_fixed64_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalFixed64Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_fixed64_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_fixed64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalFixed64Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_fixed64_extension) + } + + var EditionUnittest_optionalSfixed32Extension: Int32 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_sfixed32_extension) ?? 0} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_sfixed32_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_sfixed32_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalSfixed32Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_sfixed32_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_sfixed32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalSfixed32Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_sfixed32_extension) + } + + var EditionUnittest_optionalSfixed64Extension: Int64 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_sfixed64_extension) ?? 0} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_sfixed64_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_sfixed64_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalSfixed64Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_sfixed64_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_sfixed64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalSfixed64Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_sfixed64_extension) + } + + var EditionUnittest_optionalFloatExtension: Float { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_float_extension) ?? 0} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_float_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_float_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalFloatExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_float_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_float_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalFloatExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_float_extension) + } + + var EditionUnittest_optionalDoubleExtension: Double { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_double_extension) ?? 0} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_double_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_double_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalDoubleExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_double_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_double_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalDoubleExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_double_extension) + } + + var EditionUnittest_optionalBoolExtension: Bool { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_bool_extension) ?? false} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_bool_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_bool_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalBoolExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_bool_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_bool_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalBoolExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_bool_extension) + } + + var EditionUnittest_optionalStringExtension: String { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_string_extension) ?? String()} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_string_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_string_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalStringExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_string_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_string_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalStringExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_string_extension) + } + + var EditionUnittest_optionalBytesExtension: Data { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_bytes_extension) ?? Data()} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_bytes_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_bytes_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalBytesExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_bytes_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_bytes_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalBytesExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_bytes_extension) + } + + var EditionUnittest_optionalGroupExtension: EditionUnittest_OptionalGroup_extension { + get {return getExtensionValue(ext: EditionUnittest_Extensions_OptionalGroup_extension) ?? EditionUnittest_OptionalGroup_extension()} + set {setExtensionValue(ext: EditionUnittest_Extensions_OptionalGroup_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_OptionalGroup_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalGroupExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_OptionalGroup_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_OptionalGroup_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalGroupExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_OptionalGroup_extension) + } + + var EditionUnittest_optionalNestedMessageExtension: EditionUnittest_TestAllTypes.NestedMessage { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_nested_message_extension) ?? EditionUnittest_TestAllTypes.NestedMessage()} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_nested_message_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_nested_message_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalNestedMessageExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_nested_message_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_nested_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalNestedMessageExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_nested_message_extension) + } + + var EditionUnittest_optionalForeignMessageExtension: EditionUnittest_ForeignMessage { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_foreign_message_extension) ?? EditionUnittest_ForeignMessage()} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_foreign_message_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_foreign_message_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalForeignMessageExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_foreign_message_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_foreign_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalForeignMessageExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_foreign_message_extension) + } + + var EditionUnittest_optionalImportMessageExtension: Proto2UnittestImport_ImportMessage { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_import_message_extension) ?? Proto2UnittestImport_ImportMessage()} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_import_message_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_import_message_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalImportMessageExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_import_message_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_import_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalImportMessageExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_import_message_extension) + } + + var EditionUnittest_optionalNestedEnumExtension: EditionUnittest_TestAllTypes.NestedEnum { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_nested_enum_extension) ?? .foo} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_nested_enum_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_nested_enum_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalNestedEnumExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_nested_enum_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_nested_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalNestedEnumExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_nested_enum_extension) + } + + var EditionUnittest_optionalForeignEnumExtension: EditionUnittest_ForeignEnum { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_foreign_enum_extension) ?? .foreignFoo} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_foreign_enum_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_foreign_enum_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalForeignEnumExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_foreign_enum_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_foreign_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalForeignEnumExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_foreign_enum_extension) + } + + var EditionUnittest_optionalImportEnumExtension: Proto2UnittestImport_ImportEnum { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_import_enum_extension) ?? .importFoo} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_import_enum_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_import_enum_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalImportEnumExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_import_enum_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_import_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalImportEnumExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_import_enum_extension) + } + + var EditionUnittest_optionalStringPieceExtension: String { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_string_piece_extension) ?? String()} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_string_piece_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_string_piece_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalStringPieceExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_string_piece_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_string_piece_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalStringPieceExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_string_piece_extension) + } + + /// TODO: ctype=CORD is not supported for extension. Add + /// ctype=CORD option back after it is supported. + var EditionUnittest_optionalCordExtension: String { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_cord_extension) ?? String()} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_cord_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_cord_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalCordExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_cord_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_cord_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalCordExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_cord_extension) + } + + var EditionUnittest_optionalBytesCordExtension: Data { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_bytes_cord_extension) ?? Data()} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_bytes_cord_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_bytes_cord_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalBytesCordExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_bytes_cord_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_bytes_cord_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalBytesCordExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_bytes_cord_extension) + } + + var EditionUnittest_optionalPublicImportMessageExtension: Proto2UnittestImport_PublicImportMessage { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_public_import_message_extension) ?? Proto2UnittestImport_PublicImportMessage()} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_public_import_message_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_public_import_message_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalPublicImportMessageExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_public_import_message_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_public_import_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalPublicImportMessageExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_public_import_message_extension) + } + + var EditionUnittest_optionalLazyMessageExtension: EditionUnittest_TestAllTypes.NestedMessage { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_lazy_message_extension) ?? EditionUnittest_TestAllTypes.NestedMessage()} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_lazy_message_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_lazy_message_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalLazyMessageExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_lazy_message_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_lazy_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalLazyMessageExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_lazy_message_extension) + } + + var EditionUnittest_optionalUnverifiedLazyMessageExtension: EditionUnittest_TestAllTypes.NestedMessage { + get {return getExtensionValue(ext: EditionUnittest_Extensions_optional_unverified_lazy_message_extension) ?? EditionUnittest_TestAllTypes.NestedMessage()} + set {setExtensionValue(ext: EditionUnittest_Extensions_optional_unverified_lazy_message_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_optional_unverified_lazy_message_extension` + /// has been explicitly set. + var hasEditionUnittest_optionalUnverifiedLazyMessageExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_optional_unverified_lazy_message_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_optional_unverified_lazy_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_optionalUnverifiedLazyMessageExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_optional_unverified_lazy_message_extension) + } + + /// Repeated + var EditionUnittest_repeatedInt32Extension: [Int32] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_int32_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_int32_extension, value: newValue)} + } + + var EditionUnittest_repeatedInt64Extension: [Int64] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_int64_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_int64_extension, value: newValue)} + } + + var EditionUnittest_repeatedUint32Extension: [UInt32] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_uint32_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_uint32_extension, value: newValue)} + } + + var EditionUnittest_repeatedUint64Extension: [UInt64] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_uint64_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_uint64_extension, value: newValue)} + } + + var EditionUnittest_repeatedSint32Extension: [Int32] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_sint32_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_sint32_extension, value: newValue)} + } + + var EditionUnittest_repeatedSint64Extension: [Int64] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_sint64_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_sint64_extension, value: newValue)} + } + + var EditionUnittest_repeatedFixed32Extension: [UInt32] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_fixed32_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_fixed32_extension, value: newValue)} + } + + var EditionUnittest_repeatedFixed64Extension: [UInt64] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_fixed64_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_fixed64_extension, value: newValue)} + } + + var EditionUnittest_repeatedSfixed32Extension: [Int32] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_sfixed32_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_sfixed32_extension, value: newValue)} + } + + var EditionUnittest_repeatedSfixed64Extension: [Int64] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_sfixed64_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_sfixed64_extension, value: newValue)} + } + + var EditionUnittest_repeatedFloatExtension: [Float] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_float_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_float_extension, value: newValue)} + } + + var EditionUnittest_repeatedDoubleExtension: [Double] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_double_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_double_extension, value: newValue)} + } + + var EditionUnittest_repeatedBoolExtension: [Bool] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_bool_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_bool_extension, value: newValue)} + } + + var EditionUnittest_repeatedStringExtension: [String] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_string_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_string_extension, value: newValue)} + } + + var EditionUnittest_repeatedBytesExtension: [Data] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_bytes_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_bytes_extension, value: newValue)} + } + + var EditionUnittest_repeatedGroupExtension: [EditionUnittest_RepeatedGroup_extension] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_RepeatedGroup_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_RepeatedGroup_extension, value: newValue)} + } + + var EditionUnittest_repeatedNestedMessageExtension: [EditionUnittest_TestAllTypes.NestedMessage] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_nested_message_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_nested_message_extension, value: newValue)} + } + + var EditionUnittest_repeatedForeignMessageExtension: [EditionUnittest_ForeignMessage] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_foreign_message_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_foreign_message_extension, value: newValue)} + } + + var EditionUnittest_repeatedImportMessageExtension: [Proto2UnittestImport_ImportMessage] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_import_message_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_import_message_extension, value: newValue)} + } + + var EditionUnittest_repeatedNestedEnumExtension: [EditionUnittest_TestAllTypes.NestedEnum] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_nested_enum_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_nested_enum_extension, value: newValue)} + } + + var EditionUnittest_repeatedForeignEnumExtension: [EditionUnittest_ForeignEnum] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_foreign_enum_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_foreign_enum_extension, value: newValue)} + } + + var EditionUnittest_repeatedImportEnumExtension: [Proto2UnittestImport_ImportEnum] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_import_enum_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_import_enum_extension, value: newValue)} + } + + var EditionUnittest_repeatedStringPieceExtension: [String] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_string_piece_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_string_piece_extension, value: newValue)} + } + + /// TODO: ctype=CORD is not supported for extension. Add + /// ctype=CORD option back after it is supported. + var EditionUnittest_repeatedCordExtension: [String] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_cord_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_cord_extension, value: newValue)} + } + + var EditionUnittest_repeatedLazyMessageExtension: [EditionUnittest_TestAllTypes.NestedMessage] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_repeated_lazy_message_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_repeated_lazy_message_extension, value: newValue)} + } + + /// Singular with defaults + var EditionUnittest_defaultInt32Extension: Int32 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_int32_extension) ?? 41} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_int32_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_int32_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultInt32Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_int32_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_int32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultInt32Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_int32_extension) + } + + var EditionUnittest_defaultInt64Extension: Int64 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_int64_extension) ?? 42} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_int64_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_int64_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultInt64Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_int64_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_int64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultInt64Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_int64_extension) + } + + var EditionUnittest_defaultUint32Extension: UInt32 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_uint32_extension) ?? 43} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_uint32_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_uint32_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultUint32Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_uint32_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_uint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultUint32Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_uint32_extension) + } + + var EditionUnittest_defaultUint64Extension: UInt64 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_uint64_extension) ?? 44} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_uint64_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_uint64_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultUint64Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_uint64_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_uint64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultUint64Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_uint64_extension) + } + + var EditionUnittest_defaultSint32Extension: Int32 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_sint32_extension) ?? -45} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_sint32_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_sint32_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultSint32Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_sint32_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_sint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultSint32Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_sint32_extension) + } + + var EditionUnittest_defaultSint64Extension: Int64 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_sint64_extension) ?? 46} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_sint64_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_sint64_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultSint64Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_sint64_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_sint64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultSint64Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_sint64_extension) + } + + var EditionUnittest_defaultFixed32Extension: UInt32 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_fixed32_extension) ?? 47} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_fixed32_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_fixed32_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultFixed32Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_fixed32_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_fixed32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultFixed32Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_fixed32_extension) + } + + var EditionUnittest_defaultFixed64Extension: UInt64 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_fixed64_extension) ?? 48} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_fixed64_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_fixed64_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultFixed64Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_fixed64_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_fixed64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultFixed64Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_fixed64_extension) + } + + var EditionUnittest_defaultSfixed32Extension: Int32 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_sfixed32_extension) ?? 49} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_sfixed32_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_sfixed32_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultSfixed32Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_sfixed32_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_sfixed32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultSfixed32Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_sfixed32_extension) + } + + var EditionUnittest_defaultSfixed64Extension: Int64 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_sfixed64_extension) ?? -50} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_sfixed64_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_sfixed64_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultSfixed64Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_sfixed64_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_sfixed64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultSfixed64Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_sfixed64_extension) + } + + var EditionUnittest_defaultFloatExtension: Float { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_float_extension) ?? 51.5} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_float_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_float_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultFloatExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_float_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_float_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultFloatExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_float_extension) + } + + var EditionUnittest_defaultDoubleExtension: Double { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_double_extension) ?? 52000} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_double_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_double_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultDoubleExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_double_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_double_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultDoubleExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_double_extension) + } + + var EditionUnittest_defaultBoolExtension: Bool { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_bool_extension) ?? true} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_bool_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_bool_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultBoolExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_bool_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_bool_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultBoolExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_bool_extension) + } + + var EditionUnittest_defaultStringExtension: String { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_string_extension) ?? "hello"} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_string_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_string_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultStringExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_string_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_string_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultStringExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_string_extension) + } + + var EditionUnittest_defaultBytesExtension: Data { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_bytes_extension) ?? Data([119, 111, 114, 108, 100])} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_bytes_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_bytes_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultBytesExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_bytes_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_bytes_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultBytesExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_bytes_extension) + } + + var EditionUnittest_defaultNestedEnumExtension: EditionUnittest_TestAllTypes.NestedEnum { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_nested_enum_extension) ?? .bar} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_nested_enum_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_nested_enum_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultNestedEnumExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_nested_enum_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_nested_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultNestedEnumExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_nested_enum_extension) + } + + var EditionUnittest_defaultForeignEnumExtension: EditionUnittest_ForeignEnum { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_foreign_enum_extension) ?? .foreignBar} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_foreign_enum_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_foreign_enum_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultForeignEnumExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_foreign_enum_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_foreign_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultForeignEnumExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_foreign_enum_extension) + } + + var EditionUnittest_defaultImportEnumExtension: Proto2UnittestImport_ImportEnum { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_import_enum_extension) ?? .importBar} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_import_enum_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_import_enum_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultImportEnumExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_import_enum_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_import_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultImportEnumExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_import_enum_extension) + } + + var EditionUnittest_defaultStringPieceExtension: String { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_string_piece_extension) ?? "abc"} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_string_piece_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_string_piece_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultStringPieceExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_string_piece_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_string_piece_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultStringPieceExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_string_piece_extension) + } + + /// TODO: ctype=CORD is not supported for extension. Add + /// ctype=CORD option back after it is supported. + var EditionUnittest_defaultCordExtension: String { + get {return getExtensionValue(ext: EditionUnittest_Extensions_default_cord_extension) ?? "123"} + set {setExtensionValue(ext: EditionUnittest_Extensions_default_cord_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_default_cord_extension` + /// has been explicitly set. + var hasEditionUnittest_defaultCordExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_default_cord_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_default_cord_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_defaultCordExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_default_cord_extension) + } + + /// For oneof test + var EditionUnittest_oneofUint32Extension: UInt32 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_oneof_uint32_extension) ?? 0} + set {setExtensionValue(ext: EditionUnittest_Extensions_oneof_uint32_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_oneof_uint32_extension` + /// has been explicitly set. + var hasEditionUnittest_oneofUint32Extension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_oneof_uint32_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_oneof_uint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_oneofUint32Extension() { + clearExtensionValue(ext: EditionUnittest_Extensions_oneof_uint32_extension) + } + + var EditionUnittest_oneofNestedMessageExtension: EditionUnittest_TestAllTypes.NestedMessage { + get {return getExtensionValue(ext: EditionUnittest_Extensions_oneof_nested_message_extension) ?? EditionUnittest_TestAllTypes.NestedMessage()} + set {setExtensionValue(ext: EditionUnittest_Extensions_oneof_nested_message_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_oneof_nested_message_extension` + /// has been explicitly set. + var hasEditionUnittest_oneofNestedMessageExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_oneof_nested_message_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_oneof_nested_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_oneofNestedMessageExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_oneof_nested_message_extension) + } + + var EditionUnittest_oneofStringExtension: String { + get {return getExtensionValue(ext: EditionUnittest_Extensions_oneof_string_extension) ?? String()} + set {setExtensionValue(ext: EditionUnittest_Extensions_oneof_string_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_oneof_string_extension` + /// has been explicitly set. + var hasEditionUnittest_oneofStringExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_oneof_string_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_oneof_string_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_oneofStringExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_oneof_string_extension) + } + + var EditionUnittest_oneofBytesExtension: Data { + get {return getExtensionValue(ext: EditionUnittest_Extensions_oneof_bytes_extension) ?? Data()} + set {setExtensionValue(ext: EditionUnittest_Extensions_oneof_bytes_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_oneof_bytes_extension` + /// has been explicitly set. + var hasEditionUnittest_oneofBytesExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_oneof_bytes_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_oneof_bytes_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_oneofBytesExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_oneof_bytes_extension) + } + + /// Check for bug where string extensions declared in tested scope did not + /// compile. + var EditionUnittest_TestNestedExtension_test: String { + get {return getExtensionValue(ext: EditionUnittest_TestNestedExtension.Extensions.test) ?? "test"} + set {setExtensionValue(ext: EditionUnittest_TestNestedExtension.Extensions.test, value: newValue)} + } + /// Returns true if extension `EditionUnittest_TestNestedExtension.Extensions.test` + /// has been explicitly set. + var hasEditionUnittest_TestNestedExtension_test: Bool { + return hasExtensionValue(ext: EditionUnittest_TestNestedExtension.Extensions.test) + } + /// Clears the value of extension `EditionUnittest_TestNestedExtension.Extensions.test`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_TestNestedExtension_test() { + clearExtensionValue(ext: EditionUnittest_TestNestedExtension.Extensions.test) + } + + /// Used to test if generated extension name is correct when there are + /// underscores. + var EditionUnittest_TestNestedExtension_nestedStringExtension: String { + get {return getExtensionValue(ext: EditionUnittest_TestNestedExtension.Extensions.nested_string_extension) ?? String()} + set {setExtensionValue(ext: EditionUnittest_TestNestedExtension.Extensions.nested_string_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_TestNestedExtension.Extensions.nested_string_extension` + /// has been explicitly set. + var hasEditionUnittest_TestNestedExtension_nestedStringExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_TestNestedExtension.Extensions.nested_string_extension) + } + /// Clears the value of extension `EditionUnittest_TestNestedExtension.Extensions.nested_string_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_TestNestedExtension_nestedStringExtension() { + clearExtensionValue(ext: EditionUnittest_TestNestedExtension.Extensions.nested_string_extension) + } + + var EditionUnittest_TestRequired_single: EditionUnittest_TestRequired { + get {return getExtensionValue(ext: EditionUnittest_TestRequired.Extensions.single) ?? EditionUnittest_TestRequired()} + set {setExtensionValue(ext: EditionUnittest_TestRequired.Extensions.single, value: newValue)} + } + /// Returns true if extension `EditionUnittest_TestRequired.Extensions.single` + /// has been explicitly set. + var hasEditionUnittest_TestRequired_single: Bool { + return hasExtensionValue(ext: EditionUnittest_TestRequired.Extensions.single) + } + /// Clears the value of extension `EditionUnittest_TestRequired.Extensions.single`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_TestRequired_single() { + clearExtensionValue(ext: EditionUnittest_TestRequired.Extensions.single) + } + + var EditionUnittest_TestRequired_multi: [EditionUnittest_TestRequired] { + get {return getExtensionValue(ext: EditionUnittest_TestRequired.Extensions.multi) ?? []} + set {setExtensionValue(ext: EditionUnittest_TestRequired.Extensions.multi, value: newValue)} + } +} + +extension EditionUnittest_TestExtensionInsideTable { + + var EditionUnittest_testExtensionInsideTableExtension: Int32 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_test_extension_inside_table_extension) ?? 0} + set {setExtensionValue(ext: EditionUnittest_Extensions_test_extension_inside_table_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_test_extension_inside_table_extension` + /// has been explicitly set. + var hasEditionUnittest_testExtensionInsideTableExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_test_extension_inside_table_extension) + } + /// Clears the value of extension `EditionUnittest_Extensions_test_extension_inside_table_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_testExtensionInsideTableExtension() { + clearExtensionValue(ext: EditionUnittest_Extensions_test_extension_inside_table_extension) + } +} + +extension EditionUnittest_TestExtensionRangeSerialize { + + var EditionUnittest_TestExtensionRangeSerialize_barOne: Int32 { + get {return getExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_one) ?? 0} + set {setExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_one, value: newValue)} + } + /// Returns true if extension `EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_one` + /// has been explicitly set. + var hasEditionUnittest_TestExtensionRangeSerialize_barOne: Bool { + return hasExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_one) + } + /// Clears the value of extension `EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_one`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_TestExtensionRangeSerialize_barOne() { + clearExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_one) + } + + var EditionUnittest_TestExtensionRangeSerialize_barTwo: Int32 { + get {return getExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_two) ?? 0} + set {setExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_two, value: newValue)} + } + /// Returns true if extension `EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_two` + /// has been explicitly set. + var hasEditionUnittest_TestExtensionRangeSerialize_barTwo: Bool { + return hasExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_two) + } + /// Clears the value of extension `EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_two`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_TestExtensionRangeSerialize_barTwo() { + clearExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_two) + } + + var EditionUnittest_TestExtensionRangeSerialize_barThree: Int32 { + get {return getExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_three) ?? 0} + set {setExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_three, value: newValue)} + } + /// Returns true if extension `EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_three` + /// has been explicitly set. + var hasEditionUnittest_TestExtensionRangeSerialize_barThree: Bool { + return hasExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_three) + } + /// Clears the value of extension `EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_three`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_TestExtensionRangeSerialize_barThree() { + clearExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_three) + } + + var EditionUnittest_TestExtensionRangeSerialize_barFour: Int32 { + get {return getExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_four) ?? 0} + set {setExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_four, value: newValue)} + } + /// Returns true if extension `EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_four` + /// has been explicitly set. + var hasEditionUnittest_TestExtensionRangeSerialize_barFour: Bool { + return hasExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_four) + } + /// Clears the value of extension `EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_four`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_TestExtensionRangeSerialize_barFour() { + clearExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_four) + } + + var EditionUnittest_TestExtensionRangeSerialize_barFive: Int32 { + get {return getExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_five) ?? 0} + set {setExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_five, value: newValue)} + } + /// Returns true if extension `EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_five` + /// has been explicitly set. + var hasEditionUnittest_TestExtensionRangeSerialize_barFive: Bool { + return hasExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_five) + } + /// Clears the value of extension `EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_five`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_TestExtensionRangeSerialize_barFive() { + clearExtensionValue(ext: EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_five) + } +} + +extension EditionUnittest_TestFieldOrderings { + + var EditionUnittest_myExtensionString: String { + get {return getExtensionValue(ext: EditionUnittest_Extensions_my_extension_string) ?? String()} + set {setExtensionValue(ext: EditionUnittest_Extensions_my_extension_string, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_my_extension_string` + /// has been explicitly set. + var hasEditionUnittest_myExtensionString: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_my_extension_string) + } + /// Clears the value of extension `EditionUnittest_Extensions_my_extension_string`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_myExtensionString() { + clearExtensionValue(ext: EditionUnittest_Extensions_my_extension_string) + } + + var EditionUnittest_myExtensionInt: Int32 { + get {return getExtensionValue(ext: EditionUnittest_Extensions_my_extension_int) ?? 0} + set {setExtensionValue(ext: EditionUnittest_Extensions_my_extension_int, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_my_extension_int` + /// has been explicitly set. + var hasEditionUnittest_myExtensionInt: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_my_extension_int) + } + /// Clears the value of extension `EditionUnittest_Extensions_my_extension_int`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_myExtensionInt() { + clearExtensionValue(ext: EditionUnittest_Extensions_my_extension_int) + } + + var EditionUnittest_TestExtensionOrderings1_testExtOrderings1: EditionUnittest_TestExtensionOrderings1 { + get {return getExtensionValue(ext: EditionUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1) ?? EditionUnittest_TestExtensionOrderings1()} + set {setExtensionValue(ext: EditionUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1, value: newValue)} + } + /// Returns true if extension `EditionUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1` + /// has been explicitly set. + var hasEditionUnittest_TestExtensionOrderings1_testExtOrderings1: Bool { + return hasExtensionValue(ext: EditionUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1) + } + /// Clears the value of extension `EditionUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_TestExtensionOrderings1_testExtOrderings1() { + clearExtensionValue(ext: EditionUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1) + } + + var EditionUnittest_TestExtensionOrderings2_testExtOrderings2: EditionUnittest_TestExtensionOrderings2 { + get {return getExtensionValue(ext: EditionUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2) ?? EditionUnittest_TestExtensionOrderings2()} + set {setExtensionValue(ext: EditionUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2, value: newValue)} + } + /// Returns true if extension `EditionUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2` + /// has been explicitly set. + var hasEditionUnittest_TestExtensionOrderings2_testExtOrderings2: Bool { + return hasExtensionValue(ext: EditionUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2) + } + /// Clears the value of extension `EditionUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_TestExtensionOrderings2_testExtOrderings2() { + clearExtensionValue(ext: EditionUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2) + } + + var EditionUnittest_TestExtensionOrderings2_TestExtensionOrderings3_testExtOrderings3: EditionUnittest_TestExtensionOrderings2.TestExtensionOrderings3 { + get {return getExtensionValue(ext: EditionUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3) ?? EditionUnittest_TestExtensionOrderings2.TestExtensionOrderings3()} + set {setExtensionValue(ext: EditionUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3, value: newValue)} + } + /// Returns true if extension `EditionUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3` + /// has been explicitly set. + var hasEditionUnittest_TestExtensionOrderings2_TestExtensionOrderings3_testExtOrderings3: Bool { + return hasExtensionValue(ext: EditionUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3) + } + /// Clears the value of extension `EditionUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_TestExtensionOrderings2_TestExtensionOrderings3_testExtOrderings3() { + clearExtensionValue(ext: EditionUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3) + } +} + +extension EditionUnittest_TestGroupExtension { + + var EditionUnittest_TestNestedExtension_optionalGroupExtension: EditionUnittest_TestNestedExtension.OptionalGroup_extension { + get {return getExtensionValue(ext: EditionUnittest_TestNestedExtension.Extensions.OptionalGroup_extension) ?? EditionUnittest_TestNestedExtension.OptionalGroup_extension()} + set {setExtensionValue(ext: EditionUnittest_TestNestedExtension.Extensions.OptionalGroup_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_TestNestedExtension.Extensions.OptionalGroup_extension` + /// has been explicitly set. + var hasEditionUnittest_TestNestedExtension_optionalGroupExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_TestNestedExtension.Extensions.OptionalGroup_extension) + } + /// Clears the value of extension `EditionUnittest_TestNestedExtension.Extensions.OptionalGroup_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_TestNestedExtension_optionalGroupExtension() { + clearExtensionValue(ext: EditionUnittest_TestNestedExtension.Extensions.OptionalGroup_extension) + } + + var EditionUnittest_TestNestedExtension_optionalForeignEnumExtension: EditionUnittest_ForeignEnum { + get {return getExtensionValue(ext: EditionUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension) ?? .foreignFoo} + set {setExtensionValue(ext: EditionUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension, value: newValue)} + } + /// Returns true if extension `EditionUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension` + /// has been explicitly set. + var hasEditionUnittest_TestNestedExtension_optionalForeignEnumExtension: Bool { + return hasExtensionValue(ext: EditionUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension) + } + /// Clears the value of extension `EditionUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_TestNestedExtension_optionalForeignEnumExtension() { + clearExtensionValue(ext: EditionUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension) + } +} + +extension EditionUnittest_TestHugeFieldNumbers { + + var EditionUnittest_testAllTypes: EditionUnittest_TestAllTypes { + get {return getExtensionValue(ext: EditionUnittest_Extensions_test_all_types) ?? EditionUnittest_TestAllTypes()} + set {setExtensionValue(ext: EditionUnittest_Extensions_test_all_types, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_test_all_types` + /// has been explicitly set. + var hasEditionUnittest_testAllTypes: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_test_all_types) + } + /// Clears the value of extension `EditionUnittest_Extensions_test_all_types`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_testAllTypes() { + clearExtensionValue(ext: EditionUnittest_Extensions_test_all_types) + } +} + +extension EditionUnittest_TestMixedFieldsAndExtensions { + + var EditionUnittest_TestMixedFieldsAndExtensions_c: Int32 { + get {return getExtensionValue(ext: EditionUnittest_TestMixedFieldsAndExtensions.Extensions.c) ?? 0} + set {setExtensionValue(ext: EditionUnittest_TestMixedFieldsAndExtensions.Extensions.c, value: newValue)} + } + /// Returns true if extension `EditionUnittest_TestMixedFieldsAndExtensions.Extensions.c` + /// has been explicitly set. + var hasEditionUnittest_TestMixedFieldsAndExtensions_c: Bool { + return hasExtensionValue(ext: EditionUnittest_TestMixedFieldsAndExtensions.Extensions.c) + } + /// Clears the value of extension `EditionUnittest_TestMixedFieldsAndExtensions.Extensions.c`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_TestMixedFieldsAndExtensions_c() { + clearExtensionValue(ext: EditionUnittest_TestMixedFieldsAndExtensions.Extensions.c) + } + + var EditionUnittest_TestMixedFieldsAndExtensions_d: [UInt32] { + get {return getExtensionValue(ext: EditionUnittest_TestMixedFieldsAndExtensions.Extensions.d) ?? []} + set {setExtensionValue(ext: EditionUnittest_TestMixedFieldsAndExtensions.Extensions.d, value: newValue)} + } +} + +extension EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2RepeatedGroup { + + var EditionUnittest_inner: EditionUnittest_TestNestedGroupExtensionInnerExtension { + get {return getExtensionValue(ext: EditionUnittest_Extensions_inner) ?? EditionUnittest_TestNestedGroupExtensionInnerExtension()} + set {setExtensionValue(ext: EditionUnittest_Extensions_inner, value: newValue)} + } + /// Returns true if extension `EditionUnittest_Extensions_inner` + /// has been explicitly set. + var hasEditionUnittest_inner: Bool { + return hasExtensionValue(ext: EditionUnittest_Extensions_inner) + } + /// Clears the value of extension `EditionUnittest_Extensions_inner`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_inner() { + clearExtensionValue(ext: EditionUnittest_Extensions_inner) + } +} + +extension EditionUnittest_TestPackedExtensions { + + var EditionUnittest_packedInt32Extension: [Int32] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_packed_int32_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_packed_int32_extension, value: newValue)} + } + + var EditionUnittest_packedInt64Extension: [Int64] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_packed_int64_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_packed_int64_extension, value: newValue)} + } + + var EditionUnittest_packedUint32Extension: [UInt32] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_packed_uint32_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_packed_uint32_extension, value: newValue)} + } + + var EditionUnittest_packedUint64Extension: [UInt64] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_packed_uint64_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_packed_uint64_extension, value: newValue)} + } + + var EditionUnittest_packedSint32Extension: [Int32] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_packed_sint32_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_packed_sint32_extension, value: newValue)} + } + + var EditionUnittest_packedSint64Extension: [Int64] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_packed_sint64_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_packed_sint64_extension, value: newValue)} + } + + var EditionUnittest_packedFixed32Extension: [UInt32] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_packed_fixed32_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_packed_fixed32_extension, value: newValue)} + } + + var EditionUnittest_packedFixed64Extension: [UInt64] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_packed_fixed64_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_packed_fixed64_extension, value: newValue)} + } + + var EditionUnittest_packedSfixed32Extension: [Int32] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_packed_sfixed32_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_packed_sfixed32_extension, value: newValue)} + } + + var EditionUnittest_packedSfixed64Extension: [Int64] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_packed_sfixed64_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_packed_sfixed64_extension, value: newValue)} + } + + var EditionUnittest_packedFloatExtension: [Float] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_packed_float_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_packed_float_extension, value: newValue)} + } + + var EditionUnittest_packedDoubleExtension: [Double] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_packed_double_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_packed_double_extension, value: newValue)} + } + + var EditionUnittest_packedBoolExtension: [Bool] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_packed_bool_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_packed_bool_extension, value: newValue)} + } + + var EditionUnittest_packedEnumExtension: [EditionUnittest_ForeignEnum] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_packed_enum_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_packed_enum_extension, value: newValue)} + } +} + +extension EditionUnittest_TestParsingMerge { + + var EditionUnittest_TestParsingMerge_optionalExt: EditionUnittest_TestAllTypes { + get {return getExtensionValue(ext: EditionUnittest_TestParsingMerge.Extensions.optional_ext) ?? EditionUnittest_TestAllTypes()} + set {setExtensionValue(ext: EditionUnittest_TestParsingMerge.Extensions.optional_ext, value: newValue)} + } + /// Returns true if extension `EditionUnittest_TestParsingMerge.Extensions.optional_ext` + /// has been explicitly set. + var hasEditionUnittest_TestParsingMerge_optionalExt: Bool { + return hasExtensionValue(ext: EditionUnittest_TestParsingMerge.Extensions.optional_ext) + } + /// Clears the value of extension `EditionUnittest_TestParsingMerge.Extensions.optional_ext`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionUnittest_TestParsingMerge_optionalExt() { + clearExtensionValue(ext: EditionUnittest_TestParsingMerge.Extensions.optional_ext) + } + + var EditionUnittest_TestParsingMerge_repeatedExt: [EditionUnittest_TestAllTypes] { + get {return getExtensionValue(ext: EditionUnittest_TestParsingMerge.Extensions.repeated_ext) ?? []} + set {setExtensionValue(ext: EditionUnittest_TestParsingMerge.Extensions.repeated_ext, value: newValue)} + } +} + +extension EditionUnittest_TestUnpackedExtensions { + + var EditionUnittest_unpackedInt32Extension: [Int32] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_unpacked_int32_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_unpacked_int32_extension, value: newValue)} + } + + var EditionUnittest_unpackedInt64Extension: [Int64] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_unpacked_int64_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_unpacked_int64_extension, value: newValue)} + } + + var EditionUnittest_unpackedUint32Extension: [UInt32] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_unpacked_uint32_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_unpacked_uint32_extension, value: newValue)} + } + + var EditionUnittest_unpackedUint64Extension: [UInt64] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_unpacked_uint64_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_unpacked_uint64_extension, value: newValue)} + } + + var EditionUnittest_unpackedSint32Extension: [Int32] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_unpacked_sint32_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_unpacked_sint32_extension, value: newValue)} + } + + var EditionUnittest_unpackedSint64Extension: [Int64] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_unpacked_sint64_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_unpacked_sint64_extension, value: newValue)} + } + + var EditionUnittest_unpackedFixed32Extension: [UInt32] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_unpacked_fixed32_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_unpacked_fixed32_extension, value: newValue)} + } + + var EditionUnittest_unpackedFixed64Extension: [UInt64] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_unpacked_fixed64_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_unpacked_fixed64_extension, value: newValue)} + } + + var EditionUnittest_unpackedSfixed32Extension: [Int32] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_unpacked_sfixed32_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_unpacked_sfixed32_extension, value: newValue)} + } + + var EditionUnittest_unpackedSfixed64Extension: [Int64] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_unpacked_sfixed64_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_unpacked_sfixed64_extension, value: newValue)} + } + + var EditionUnittest_unpackedFloatExtension: [Float] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_unpacked_float_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_unpacked_float_extension, value: newValue)} + } + + var EditionUnittest_unpackedDoubleExtension: [Double] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_unpacked_double_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_unpacked_double_extension, value: newValue)} + } + + var EditionUnittest_unpackedBoolExtension: [Bool] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_unpacked_bool_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_unpacked_bool_extension, value: newValue)} + } + + var EditionUnittest_unpackedEnumExtension: [EditionUnittest_ForeignEnum] { + get {return getExtensionValue(ext: EditionUnittest_Extensions_unpacked_enum_extension) ?? []} + set {setExtensionValue(ext: EditionUnittest_Extensions_unpacked_enum_extension, value: newValue)} + } + +} + +// MARK: - File's ExtensionMap: EditionUnittest_EditionUnittest_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 EditionUnittest_EditionUnittest_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + EditionUnittest_Extensions_optional_int32_extension, + EditionUnittest_Extensions_optional_int64_extension, + EditionUnittest_Extensions_optional_uint32_extension, + EditionUnittest_Extensions_optional_uint64_extension, + EditionUnittest_Extensions_optional_sint32_extension, + EditionUnittest_Extensions_optional_sint64_extension, + EditionUnittest_Extensions_optional_fixed32_extension, + EditionUnittest_Extensions_optional_fixed64_extension, + EditionUnittest_Extensions_optional_sfixed32_extension, + EditionUnittest_Extensions_optional_sfixed64_extension, + EditionUnittest_Extensions_optional_float_extension, + EditionUnittest_Extensions_optional_double_extension, + EditionUnittest_Extensions_optional_bool_extension, + EditionUnittest_Extensions_optional_string_extension, + EditionUnittest_Extensions_optional_bytes_extension, + EditionUnittest_Extensions_OptionalGroup_extension, + EditionUnittest_Extensions_optional_nested_message_extension, + EditionUnittest_Extensions_optional_foreign_message_extension, + EditionUnittest_Extensions_optional_import_message_extension, + EditionUnittest_Extensions_optional_nested_enum_extension, + EditionUnittest_Extensions_optional_foreign_enum_extension, + EditionUnittest_Extensions_optional_import_enum_extension, + EditionUnittest_Extensions_optional_string_piece_extension, + EditionUnittest_Extensions_optional_cord_extension, + EditionUnittest_Extensions_optional_bytes_cord_extension, + EditionUnittest_Extensions_optional_public_import_message_extension, + EditionUnittest_Extensions_optional_lazy_message_extension, + EditionUnittest_Extensions_optional_unverified_lazy_message_extension, + EditionUnittest_Extensions_repeated_int32_extension, + EditionUnittest_Extensions_repeated_int64_extension, + EditionUnittest_Extensions_repeated_uint32_extension, + EditionUnittest_Extensions_repeated_uint64_extension, + EditionUnittest_Extensions_repeated_sint32_extension, + EditionUnittest_Extensions_repeated_sint64_extension, + EditionUnittest_Extensions_repeated_fixed32_extension, + EditionUnittest_Extensions_repeated_fixed64_extension, + EditionUnittest_Extensions_repeated_sfixed32_extension, + EditionUnittest_Extensions_repeated_sfixed64_extension, + EditionUnittest_Extensions_repeated_float_extension, + EditionUnittest_Extensions_repeated_double_extension, + EditionUnittest_Extensions_repeated_bool_extension, + EditionUnittest_Extensions_repeated_string_extension, + EditionUnittest_Extensions_repeated_bytes_extension, + EditionUnittest_Extensions_RepeatedGroup_extension, + EditionUnittest_Extensions_repeated_nested_message_extension, + EditionUnittest_Extensions_repeated_foreign_message_extension, + EditionUnittest_Extensions_repeated_import_message_extension, + EditionUnittest_Extensions_repeated_nested_enum_extension, + EditionUnittest_Extensions_repeated_foreign_enum_extension, + EditionUnittest_Extensions_repeated_import_enum_extension, + EditionUnittest_Extensions_repeated_string_piece_extension, + EditionUnittest_Extensions_repeated_cord_extension, + EditionUnittest_Extensions_repeated_lazy_message_extension, + EditionUnittest_Extensions_default_int32_extension, + EditionUnittest_Extensions_default_int64_extension, + EditionUnittest_Extensions_default_uint32_extension, + EditionUnittest_Extensions_default_uint64_extension, + EditionUnittest_Extensions_default_sint32_extension, + EditionUnittest_Extensions_default_sint64_extension, + EditionUnittest_Extensions_default_fixed32_extension, + EditionUnittest_Extensions_default_fixed64_extension, + EditionUnittest_Extensions_default_sfixed32_extension, + EditionUnittest_Extensions_default_sfixed64_extension, + EditionUnittest_Extensions_default_float_extension, + EditionUnittest_Extensions_default_double_extension, + EditionUnittest_Extensions_default_bool_extension, + EditionUnittest_Extensions_default_string_extension, + EditionUnittest_Extensions_default_bytes_extension, + EditionUnittest_Extensions_default_nested_enum_extension, + EditionUnittest_Extensions_default_foreign_enum_extension, + EditionUnittest_Extensions_default_import_enum_extension, + EditionUnittest_Extensions_default_string_piece_extension, + EditionUnittest_Extensions_default_cord_extension, + EditionUnittest_Extensions_oneof_uint32_extension, + EditionUnittest_Extensions_oneof_nested_message_extension, + EditionUnittest_Extensions_oneof_string_extension, + EditionUnittest_Extensions_oneof_bytes_extension, + EditionUnittest_Extensions_my_extension_string, + EditionUnittest_Extensions_my_extension_int, + EditionUnittest_Extensions_packed_int32_extension, + EditionUnittest_Extensions_packed_int64_extension, + EditionUnittest_Extensions_packed_uint32_extension, + EditionUnittest_Extensions_packed_uint64_extension, + EditionUnittest_Extensions_packed_sint32_extension, + EditionUnittest_Extensions_packed_sint64_extension, + EditionUnittest_Extensions_packed_fixed32_extension, + EditionUnittest_Extensions_packed_fixed64_extension, + EditionUnittest_Extensions_packed_sfixed32_extension, + EditionUnittest_Extensions_packed_sfixed64_extension, + EditionUnittest_Extensions_packed_float_extension, + EditionUnittest_Extensions_packed_double_extension, + EditionUnittest_Extensions_packed_bool_extension, + EditionUnittest_Extensions_packed_enum_extension, + EditionUnittest_Extensions_unpacked_int32_extension, + EditionUnittest_Extensions_unpacked_int64_extension, + EditionUnittest_Extensions_unpacked_uint32_extension, + EditionUnittest_Extensions_unpacked_uint64_extension, + EditionUnittest_Extensions_unpacked_sint32_extension, + EditionUnittest_Extensions_unpacked_sint64_extension, + EditionUnittest_Extensions_unpacked_fixed32_extension, + EditionUnittest_Extensions_unpacked_fixed64_extension, + EditionUnittest_Extensions_unpacked_sfixed32_extension, + EditionUnittest_Extensions_unpacked_sfixed64_extension, + EditionUnittest_Extensions_unpacked_float_extension, + EditionUnittest_Extensions_unpacked_double_extension, + EditionUnittest_Extensions_unpacked_bool_extension, + EditionUnittest_Extensions_unpacked_enum_extension, + EditionUnittest_Extensions_test_all_types, + EditionUnittest_Extensions_test_extension_inside_table_extension, + EditionUnittest_Extensions_inner, + EditionUnittest_TestMixedFieldsAndExtensions.Extensions.c, + EditionUnittest_TestMixedFieldsAndExtensions.Extensions.d, + EditionUnittest_TestNestedExtension.Extensions.test, + EditionUnittest_TestNestedExtension.Extensions.nested_string_extension, + EditionUnittest_TestNestedExtension.Extensions.OptionalGroup_extension, + EditionUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension, + EditionUnittest_TestRequired.Extensions.single, + EditionUnittest_TestRequired.Extensions.multi, + EditionUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1, + EditionUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2, + EditionUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3, + EditionUnittest_TestParsingMerge.Extensions.optional_ext, + EditionUnittest_TestParsingMerge.Extensions.repeated_ext, + EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_one, + EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_two, + EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_three, + EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_four, + EditionUnittest_TestExtensionRangeSerialize.Extensions.bar_five, + EditionUnittest_EnumParseTester.Extensions.optional_arbitrary_ext, + EditionUnittest_EnumParseTester.Extensions.repeated_arbitrary_ext, + EditionUnittest_EnumParseTester.Extensions.packed_arbitrary_ext, + EditionUnittest_BoolParseTester.Extensions.optional_bool_ext, + EditionUnittest_BoolParseTester.Extensions.repeated_bool_ext, + EditionUnittest_BoolParseTester.Extensions.packed_bool_ext, + EditionUnittest_Int32ParseTester.Extensions.optional_int32_ext, + EditionUnittest_Int32ParseTester.Extensions.repeated_int32_ext, + EditionUnittest_Int32ParseTester.Extensions.packed_int32_ext, + EditionUnittest_Int64ParseTester.Extensions.optional_int64_ext, + EditionUnittest_Int64ParseTester.Extensions.repeated_int64_ext, + EditionUnittest_Int64ParseTester.Extensions.packed_int64_ext, + EditionUnittest_StringParseTester.Extensions.optional_string_ext, + EditionUnittest_StringParseTester.Extensions.repeated_string_ext +] + +// 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. + +/// Singular +let EditionUnittest_Extensions_optional_int32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 1, + fieldName: "edition_unittest.optional_int32_extension" +) + +let EditionUnittest_Extensions_optional_int64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 2, + fieldName: "edition_unittest.optional_int64_extension" +) + +let EditionUnittest_Extensions_optional_uint32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 3, + fieldName: "edition_unittest.optional_uint32_extension" +) + +let EditionUnittest_Extensions_optional_uint64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 4, + fieldName: "edition_unittest.optional_uint64_extension" +) + +let EditionUnittest_Extensions_optional_sint32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 5, + fieldName: "edition_unittest.optional_sint32_extension" +) + +let EditionUnittest_Extensions_optional_sint64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 6, + fieldName: "edition_unittest.optional_sint64_extension" +) + +let EditionUnittest_Extensions_optional_fixed32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 7, + fieldName: "edition_unittest.optional_fixed32_extension" +) + +let EditionUnittest_Extensions_optional_fixed64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 8, + fieldName: "edition_unittest.optional_fixed64_extension" +) + +let EditionUnittest_Extensions_optional_sfixed32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 9, + fieldName: "edition_unittest.optional_sfixed32_extension" +) + +let EditionUnittest_Extensions_optional_sfixed64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 10, + fieldName: "edition_unittest.optional_sfixed64_extension" +) + +let EditionUnittest_Extensions_optional_float_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 11, + fieldName: "edition_unittest.optional_float_extension" +) + +let EditionUnittest_Extensions_optional_double_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 12, + fieldName: "edition_unittest.optional_double_extension" +) + +let EditionUnittest_Extensions_optional_bool_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 13, + fieldName: "edition_unittest.optional_bool_extension" +) + +let EditionUnittest_Extensions_optional_string_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 14, + fieldName: "edition_unittest.optional_string_extension" +) + +let EditionUnittest_Extensions_optional_bytes_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 15, + fieldName: "edition_unittest.optional_bytes_extension" +) + +let EditionUnittest_Extensions_OptionalGroup_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 16, + fieldName: "edition_unittest.optionalgroup_extension" +) + +let EditionUnittest_Extensions_optional_nested_message_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 18, + fieldName: "edition_unittest.optional_nested_message_extension" +) + +let EditionUnittest_Extensions_optional_foreign_message_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 19, + fieldName: "edition_unittest.optional_foreign_message_extension" +) + +let EditionUnittest_Extensions_optional_import_message_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 20, + fieldName: "edition_unittest.optional_import_message_extension" +) + +let EditionUnittest_Extensions_optional_nested_enum_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 21, + fieldName: "edition_unittest.optional_nested_enum_extension" +) + +let EditionUnittest_Extensions_optional_foreign_enum_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 22, + fieldName: "edition_unittest.optional_foreign_enum_extension" +) + +let EditionUnittest_Extensions_optional_import_enum_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 23, + fieldName: "edition_unittest.optional_import_enum_extension" +) + +let EditionUnittest_Extensions_optional_string_piece_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 24, + fieldName: "edition_unittest.optional_string_piece_extension" +) + +/// TODO: ctype=CORD is not supported for extension. Add +/// ctype=CORD option back after it is supported. +let EditionUnittest_Extensions_optional_cord_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 25, + fieldName: "edition_unittest.optional_cord_extension" +) + +let EditionUnittest_Extensions_optional_bytes_cord_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 86, + fieldName: "edition_unittest.optional_bytes_cord_extension" +) + +let EditionUnittest_Extensions_optional_public_import_message_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 26, + fieldName: "edition_unittest.optional_public_import_message_extension" +) + +let EditionUnittest_Extensions_optional_lazy_message_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 27, + fieldName: "edition_unittest.optional_lazy_message_extension" +) + +let EditionUnittest_Extensions_optional_unverified_lazy_message_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 28, + fieldName: "edition_unittest.optional_unverified_lazy_message_extension" +) + +/// Repeated +let EditionUnittest_Extensions_repeated_int32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 31, + fieldName: "edition_unittest.repeated_int32_extension" +) + +let EditionUnittest_Extensions_repeated_int64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 32, + fieldName: "edition_unittest.repeated_int64_extension" +) + +let EditionUnittest_Extensions_repeated_uint32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 33, + fieldName: "edition_unittest.repeated_uint32_extension" +) + +let EditionUnittest_Extensions_repeated_uint64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 34, + fieldName: "edition_unittest.repeated_uint64_extension" +) + +let EditionUnittest_Extensions_repeated_sint32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 35, + fieldName: "edition_unittest.repeated_sint32_extension" +) + +let EditionUnittest_Extensions_repeated_sint64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 36, + fieldName: "edition_unittest.repeated_sint64_extension" +) + +let EditionUnittest_Extensions_repeated_fixed32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 37, + fieldName: "edition_unittest.repeated_fixed32_extension" +) + +let EditionUnittest_Extensions_repeated_fixed64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 38, + fieldName: "edition_unittest.repeated_fixed64_extension" +) + +let EditionUnittest_Extensions_repeated_sfixed32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 39, + fieldName: "edition_unittest.repeated_sfixed32_extension" +) + +let EditionUnittest_Extensions_repeated_sfixed64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 40, + fieldName: "edition_unittest.repeated_sfixed64_extension" +) + +let EditionUnittest_Extensions_repeated_float_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 41, + fieldName: "edition_unittest.repeated_float_extension" +) + +let EditionUnittest_Extensions_repeated_double_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 42, + fieldName: "edition_unittest.repeated_double_extension" +) + +let EditionUnittest_Extensions_repeated_bool_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 43, + fieldName: "edition_unittest.repeated_bool_extension" +) + +let EditionUnittest_Extensions_repeated_string_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 44, + fieldName: "edition_unittest.repeated_string_extension" +) + +let EditionUnittest_Extensions_repeated_bytes_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 45, + fieldName: "edition_unittest.repeated_bytes_extension" +) + +let EditionUnittest_Extensions_RepeatedGroup_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 46, + fieldName: "edition_unittest.repeatedgroup_extension" +) + +let EditionUnittest_Extensions_repeated_nested_message_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 48, + fieldName: "edition_unittest.repeated_nested_message_extension" +) + +let EditionUnittest_Extensions_repeated_foreign_message_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 49, + fieldName: "edition_unittest.repeated_foreign_message_extension" +) + +let EditionUnittest_Extensions_repeated_import_message_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 50, + fieldName: "edition_unittest.repeated_import_message_extension" +) + +let EditionUnittest_Extensions_repeated_nested_enum_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 51, + fieldName: "edition_unittest.repeated_nested_enum_extension" +) + +let EditionUnittest_Extensions_repeated_foreign_enum_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 52, + fieldName: "edition_unittest.repeated_foreign_enum_extension" +) + +let EditionUnittest_Extensions_repeated_import_enum_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 53, + fieldName: "edition_unittest.repeated_import_enum_extension" +) + +let EditionUnittest_Extensions_repeated_string_piece_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 54, + fieldName: "edition_unittest.repeated_string_piece_extension" +) + +/// TODO: ctype=CORD is not supported for extension. Add +/// ctype=CORD option back after it is supported. +let EditionUnittest_Extensions_repeated_cord_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 55, + fieldName: "edition_unittest.repeated_cord_extension" +) + +let EditionUnittest_Extensions_repeated_lazy_message_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 57, + fieldName: "edition_unittest.repeated_lazy_message_extension" +) + +/// Singular with defaults +let EditionUnittest_Extensions_default_int32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 61, + fieldName: "edition_unittest.default_int32_extension" +) + +let EditionUnittest_Extensions_default_int64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 62, + fieldName: "edition_unittest.default_int64_extension" +) + +let EditionUnittest_Extensions_default_uint32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 63, + fieldName: "edition_unittest.default_uint32_extension" +) + +let EditionUnittest_Extensions_default_uint64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 64, + fieldName: "edition_unittest.default_uint64_extension" +) + +let EditionUnittest_Extensions_default_sint32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 65, + fieldName: "edition_unittest.default_sint32_extension" +) + +let EditionUnittest_Extensions_default_sint64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 66, + fieldName: "edition_unittest.default_sint64_extension" +) + +let EditionUnittest_Extensions_default_fixed32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 67, + fieldName: "edition_unittest.default_fixed32_extension" +) + +let EditionUnittest_Extensions_default_fixed64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 68, + fieldName: "edition_unittest.default_fixed64_extension" +) + +let EditionUnittest_Extensions_default_sfixed32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 69, + fieldName: "edition_unittest.default_sfixed32_extension" +) + +let EditionUnittest_Extensions_default_sfixed64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 70, + fieldName: "edition_unittest.default_sfixed64_extension" +) + +let EditionUnittest_Extensions_default_float_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 71, + fieldName: "edition_unittest.default_float_extension" +) + +let EditionUnittest_Extensions_default_double_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 72, + fieldName: "edition_unittest.default_double_extension" +) + +let EditionUnittest_Extensions_default_bool_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 73, + fieldName: "edition_unittest.default_bool_extension" +) + +let EditionUnittest_Extensions_default_string_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 74, + fieldName: "edition_unittest.default_string_extension" +) + +let EditionUnittest_Extensions_default_bytes_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 75, + fieldName: "edition_unittest.default_bytes_extension" +) + +let EditionUnittest_Extensions_default_nested_enum_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 81, + fieldName: "edition_unittest.default_nested_enum_extension" +) + +let EditionUnittest_Extensions_default_foreign_enum_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 82, + fieldName: "edition_unittest.default_foreign_enum_extension" +) + +let EditionUnittest_Extensions_default_import_enum_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 83, + fieldName: "edition_unittest.default_import_enum_extension" +) + +let EditionUnittest_Extensions_default_string_piece_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 84, + fieldName: "edition_unittest.default_string_piece_extension" +) + +/// TODO: ctype=CORD is not supported for extension. Add +/// ctype=CORD option back after it is supported. +let EditionUnittest_Extensions_default_cord_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 85, + fieldName: "edition_unittest.default_cord_extension" +) + +/// For oneof test +let EditionUnittest_Extensions_oneof_uint32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 111, + fieldName: "edition_unittest.oneof_uint32_extension" +) + +let EditionUnittest_Extensions_oneof_nested_message_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 112, + fieldName: "edition_unittest.oneof_nested_message_extension" +) + +let EditionUnittest_Extensions_oneof_string_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 113, + fieldName: "edition_unittest.oneof_string_extension" +) + +let EditionUnittest_Extensions_oneof_bytes_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 114, + fieldName: "edition_unittest.oneof_bytes_extension" +) + +let EditionUnittest_Extensions_my_extension_string = SwiftProtobuf.MessageExtension, EditionUnittest_TestFieldOrderings>( + _protobuf_fieldNumber: 50, + fieldName: "edition_unittest.my_extension_string" +) + +let EditionUnittest_Extensions_my_extension_int = SwiftProtobuf.MessageExtension, EditionUnittest_TestFieldOrderings>( + _protobuf_fieldNumber: 5, + fieldName: "edition_unittest.my_extension_int" +) + +let EditionUnittest_Extensions_packed_int32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestPackedExtensions>( + _protobuf_fieldNumber: 90, + fieldName: "edition_unittest.packed_int32_extension" +) + +let EditionUnittest_Extensions_packed_int64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestPackedExtensions>( + _protobuf_fieldNumber: 91, + fieldName: "edition_unittest.packed_int64_extension" +) + +let EditionUnittest_Extensions_packed_uint32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestPackedExtensions>( + _protobuf_fieldNumber: 92, + fieldName: "edition_unittest.packed_uint32_extension" +) + +let EditionUnittest_Extensions_packed_uint64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestPackedExtensions>( + _protobuf_fieldNumber: 93, + fieldName: "edition_unittest.packed_uint64_extension" +) + +let EditionUnittest_Extensions_packed_sint32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestPackedExtensions>( + _protobuf_fieldNumber: 94, + fieldName: "edition_unittest.packed_sint32_extension" +) + +let EditionUnittest_Extensions_packed_sint64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestPackedExtensions>( + _protobuf_fieldNumber: 95, + fieldName: "edition_unittest.packed_sint64_extension" +) + +let EditionUnittest_Extensions_packed_fixed32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestPackedExtensions>( + _protobuf_fieldNumber: 96, + fieldName: "edition_unittest.packed_fixed32_extension" +) + +let EditionUnittest_Extensions_packed_fixed64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestPackedExtensions>( + _protobuf_fieldNumber: 97, + fieldName: "edition_unittest.packed_fixed64_extension" +) + +let EditionUnittest_Extensions_packed_sfixed32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestPackedExtensions>( + _protobuf_fieldNumber: 98, + fieldName: "edition_unittest.packed_sfixed32_extension" +) + +let EditionUnittest_Extensions_packed_sfixed64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestPackedExtensions>( + _protobuf_fieldNumber: 99, + fieldName: "edition_unittest.packed_sfixed64_extension" +) + +let EditionUnittest_Extensions_packed_float_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestPackedExtensions>( + _protobuf_fieldNumber: 100, + fieldName: "edition_unittest.packed_float_extension" +) + +let EditionUnittest_Extensions_packed_double_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestPackedExtensions>( + _protobuf_fieldNumber: 101, + fieldName: "edition_unittest.packed_double_extension" +) + +let EditionUnittest_Extensions_packed_bool_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestPackedExtensions>( + _protobuf_fieldNumber: 102, + fieldName: "edition_unittest.packed_bool_extension" +) + +let EditionUnittest_Extensions_packed_enum_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestPackedExtensions>( + _protobuf_fieldNumber: 103, + fieldName: "edition_unittest.packed_enum_extension" +) + +let EditionUnittest_Extensions_unpacked_int32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 90, + fieldName: "edition_unittest.unpacked_int32_extension" +) + +let EditionUnittest_Extensions_unpacked_int64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 91, + fieldName: "edition_unittest.unpacked_int64_extension" +) + +let EditionUnittest_Extensions_unpacked_uint32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 92, + fieldName: "edition_unittest.unpacked_uint32_extension" +) + +let EditionUnittest_Extensions_unpacked_uint64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 93, + fieldName: "edition_unittest.unpacked_uint64_extension" +) + +let EditionUnittest_Extensions_unpacked_sint32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 94, + fieldName: "edition_unittest.unpacked_sint32_extension" +) + +let EditionUnittest_Extensions_unpacked_sint64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 95, + fieldName: "edition_unittest.unpacked_sint64_extension" +) + +let EditionUnittest_Extensions_unpacked_fixed32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 96, + fieldName: "edition_unittest.unpacked_fixed32_extension" +) + +let EditionUnittest_Extensions_unpacked_fixed64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 97, + fieldName: "edition_unittest.unpacked_fixed64_extension" +) + +let EditionUnittest_Extensions_unpacked_sfixed32_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 98, + fieldName: "edition_unittest.unpacked_sfixed32_extension" +) + +let EditionUnittest_Extensions_unpacked_sfixed64_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 99, + fieldName: "edition_unittest.unpacked_sfixed64_extension" +) + +let EditionUnittest_Extensions_unpacked_float_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 100, + fieldName: "edition_unittest.unpacked_float_extension" +) + +let EditionUnittest_Extensions_unpacked_double_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 101, + fieldName: "edition_unittest.unpacked_double_extension" +) + +let EditionUnittest_Extensions_unpacked_bool_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 102, + fieldName: "edition_unittest.unpacked_bool_extension" +) + +let EditionUnittest_Extensions_unpacked_enum_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 103, + fieldName: "edition_unittest.unpacked_enum_extension" +) + +let EditionUnittest_Extensions_test_all_types = SwiftProtobuf.MessageExtension, EditionUnittest_TestHugeFieldNumbers>( + _protobuf_fieldNumber: 536860000, + fieldName: "edition_unittest.test_all_types" +) + +let EditionUnittest_Extensions_test_extension_inside_table_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestExtensionInsideTable>( + _protobuf_fieldNumber: 5, + fieldName: "edition_unittest.test_extension_inside_table_extension" +) + +let EditionUnittest_Extensions_inner = SwiftProtobuf.MessageExtension, EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2RepeatedGroup>( + _protobuf_fieldNumber: 3, + fieldName: "edition_unittest.inner" +) + +extension EditionUnittest_TestMixedFieldsAndExtensions { + enum Extensions { + static let c = SwiftProtobuf.MessageExtension, EditionUnittest_TestMixedFieldsAndExtensions>( + _protobuf_fieldNumber: 2, + fieldName: "edition_unittest.TestMixedFieldsAndExtensions.c" + ) + + static let d = SwiftProtobuf.MessageExtension, EditionUnittest_TestMixedFieldsAndExtensions>( + _protobuf_fieldNumber: 4, + fieldName: "edition_unittest.TestMixedFieldsAndExtensions.d" + ) + } +} + +extension EditionUnittest_TestNestedExtension { + enum Extensions { + /// Check for bug where string extensions declared in tested scope did not + /// compile. + static let test = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 1002, + fieldName: "edition_unittest.TestNestedExtension.test" + ) + + /// Used to test if generated extension name is correct when there are + /// underscores. + static let nested_string_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 1003, + fieldName: "edition_unittest.TestNestedExtension.nested_string_extension" + ) + + static let OptionalGroup_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestGroupExtension>( + _protobuf_fieldNumber: 16, + fieldName: "edition_unittest.TestNestedExtension.optionalgroup_extension" + ) + + static let optional_foreign_enum_extension = SwiftProtobuf.MessageExtension, EditionUnittest_TestGroupExtension>( + _protobuf_fieldNumber: 22, + fieldName: "edition_unittest.TestNestedExtension.optional_foreign_enum_extension" + ) + } +} + +extension EditionUnittest_TestRequired { + enum Extensions { + static let single = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 1000, + fieldName: "edition_unittest.TestRequired.single" + ) + + static let multi = SwiftProtobuf.MessageExtension, EditionUnittest_TestAllExtensions>( + _protobuf_fieldNumber: 1001, + fieldName: "edition_unittest.TestRequired.multi" + ) + } +} + +extension EditionUnittest_TestExtensionOrderings1 { + enum Extensions { + static let test_ext_orderings1 = SwiftProtobuf.MessageExtension, EditionUnittest_TestFieldOrderings>( + _protobuf_fieldNumber: 13, + fieldName: "edition_unittest.TestExtensionOrderings1.test_ext_orderings1" + ) + } +} + +extension EditionUnittest_TestExtensionOrderings2 { + enum Extensions { + static let test_ext_orderings2 = SwiftProtobuf.MessageExtension, EditionUnittest_TestFieldOrderings>( + _protobuf_fieldNumber: 12, + fieldName: "edition_unittest.TestExtensionOrderings2.test_ext_orderings2" + ) + } +} + +extension EditionUnittest_TestExtensionOrderings2.TestExtensionOrderings3 { + enum Extensions { + static let test_ext_orderings3 = SwiftProtobuf.MessageExtension, EditionUnittest_TestFieldOrderings>( + _protobuf_fieldNumber: 14, + fieldName: "edition_unittest.TestExtensionOrderings2.TestExtensionOrderings3.test_ext_orderings3" + ) + } +} + +extension EditionUnittest_TestParsingMerge { + enum Extensions { + static let optional_ext = SwiftProtobuf.MessageExtension, EditionUnittest_TestParsingMerge>( + _protobuf_fieldNumber: 1000, + fieldName: "edition_unittest.TestParsingMerge.optional_ext" + ) + + static let repeated_ext = SwiftProtobuf.MessageExtension, EditionUnittest_TestParsingMerge>( + _protobuf_fieldNumber: 1001, + fieldName: "edition_unittest.TestParsingMerge.repeated_ext" + ) + } +} + +extension EditionUnittest_TestExtensionRangeSerialize { + enum Extensions { + static let bar_one = SwiftProtobuf.MessageExtension, EditionUnittest_TestExtensionRangeSerialize>( + _protobuf_fieldNumber: 2, + fieldName: "edition_unittest.TestExtensionRangeSerialize.bar_one" + ) + + static let bar_two = SwiftProtobuf.MessageExtension, EditionUnittest_TestExtensionRangeSerialize>( + _protobuf_fieldNumber: 4, + fieldName: "edition_unittest.TestExtensionRangeSerialize.bar_two" + ) + + static let bar_three = SwiftProtobuf.MessageExtension, EditionUnittest_TestExtensionRangeSerialize>( + _protobuf_fieldNumber: 10, + fieldName: "edition_unittest.TestExtensionRangeSerialize.bar_three" + ) + + static let bar_four = SwiftProtobuf.MessageExtension, EditionUnittest_TestExtensionRangeSerialize>( + _protobuf_fieldNumber: 15, + fieldName: "edition_unittest.TestExtensionRangeSerialize.bar_four" + ) + + static let bar_five = SwiftProtobuf.MessageExtension, EditionUnittest_TestExtensionRangeSerialize>( + _protobuf_fieldNumber: 19, + fieldName: "edition_unittest.TestExtensionRangeSerialize.bar_five" + ) + } +} + +extension EditionUnittest_EnumParseTester { + enum Extensions { + static let optional_arbitrary_ext = SwiftProtobuf.MessageExtension, EditionUnittest_EnumParseTester>( + _protobuf_fieldNumber: 2000000, + fieldName: "edition_unittest.EnumParseTester.optional_arbitrary_ext" + ) + + static let repeated_arbitrary_ext = SwiftProtobuf.MessageExtension, EditionUnittest_EnumParseTester>( + _protobuf_fieldNumber: 2000001, + fieldName: "edition_unittest.EnumParseTester.repeated_arbitrary_ext" + ) + + static let packed_arbitrary_ext = SwiftProtobuf.MessageExtension, EditionUnittest_EnumParseTester>( + _protobuf_fieldNumber: 2000002, + fieldName: "edition_unittest.EnumParseTester.packed_arbitrary_ext" + ) + } +} + +extension EditionUnittest_BoolParseTester { + enum Extensions { + static let optional_bool_ext = SwiftProtobuf.MessageExtension, EditionUnittest_BoolParseTester>( + _protobuf_fieldNumber: 2000000, + fieldName: "edition_unittest.BoolParseTester.optional_bool_ext" + ) + + static let repeated_bool_ext = SwiftProtobuf.MessageExtension, EditionUnittest_BoolParseTester>( + _protobuf_fieldNumber: 2000001, + fieldName: "edition_unittest.BoolParseTester.repeated_bool_ext" + ) + + static let packed_bool_ext = SwiftProtobuf.MessageExtension, EditionUnittest_BoolParseTester>( + _protobuf_fieldNumber: 2000002, + fieldName: "edition_unittest.BoolParseTester.packed_bool_ext" + ) + } +} + +extension EditionUnittest_Int32ParseTester { + enum Extensions { + static let optional_int32_ext = SwiftProtobuf.MessageExtension, EditionUnittest_Int32ParseTester>( + _protobuf_fieldNumber: 2000000, + fieldName: "edition_unittest.Int32ParseTester.optional_int32_ext" + ) + + static let repeated_int32_ext = SwiftProtobuf.MessageExtension, EditionUnittest_Int32ParseTester>( + _protobuf_fieldNumber: 2000001, + fieldName: "edition_unittest.Int32ParseTester.repeated_int32_ext" + ) + + static let packed_int32_ext = SwiftProtobuf.MessageExtension, EditionUnittest_Int32ParseTester>( + _protobuf_fieldNumber: 2000002, + fieldName: "edition_unittest.Int32ParseTester.packed_int32_ext" + ) + } +} + +extension EditionUnittest_Int64ParseTester { + enum Extensions { + static let optional_int64_ext = SwiftProtobuf.MessageExtension, EditionUnittest_Int64ParseTester>( + _protobuf_fieldNumber: 2000000, + fieldName: "edition_unittest.Int64ParseTester.optional_int64_ext" + ) + + static let repeated_int64_ext = SwiftProtobuf.MessageExtension, EditionUnittest_Int64ParseTester>( + _protobuf_fieldNumber: 2000001, + fieldName: "edition_unittest.Int64ParseTester.repeated_int64_ext" + ) + + static let packed_int64_ext = SwiftProtobuf.MessageExtension, EditionUnittest_Int64ParseTester>( + _protobuf_fieldNumber: 2000002, + fieldName: "edition_unittest.Int64ParseTester.packed_int64_ext" + ) + } +} + +extension EditionUnittest_StringParseTester { + enum Extensions { + static let optional_string_ext = SwiftProtobuf.MessageExtension, EditionUnittest_StringParseTester>( + _protobuf_fieldNumber: 2000000, + fieldName: "edition_unittest.StringParseTester.optional_string_ext" + ) + + static let repeated_string_ext = SwiftProtobuf.MessageExtension, EditionUnittest_StringParseTester>( + _protobuf_fieldNumber: 2000001, + fieldName: "edition_unittest.StringParseTester.repeated_string_ext" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "edition_unittest" + +extension EditionUnittest_ForeignEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{4}FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0\u{2}\u{1a}FOREIGN_BAX\0") +} + +extension EditionUnittest_TestReservedEnumFields: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNKNOWN\0") +} + +extension EditionUnittest_TestEnumWithDupValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{a}\0DUP_UNKNOWN1\0\u{1}DUP_UNKNOWN2\0\u{9}DUP_FOO1\0\u{1}DUP_FOO2\0\u{9}DUP_BAR1\0\u{1}DUP_BAR2\0\u{1}DUP_BAZ\0") +} + +extension EditionUnittest_TestSparseEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}t|r\u{7f}\u{7f}\u{3}SPARSE_E\0\u{2}}B\u{d}SPARSE_D\0\u{2}\u{f}SPARSE_F\0\u{2}\u{2}SPARSE_G\0\u{2}y\u{1}SPARSE_A\0\u{2}kL\u{f}SPARSE_B\0\u{2}LTr/SPARSE_C\0") +} + +extension EditionUnittest_VeryLargeEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ENUM_LABEL_DEFAULT\0\u{1}ENUM_LABEL_1\0\u{1}ENUM_LABEL_2\0\u{1}ENUM_LABEL_3\0\u{1}ENUM_LABEL_4\0\u{1}ENUM_LABEL_5\0\u{1}ENUM_LABEL_6\0\u{1}ENUM_LABEL_7\0\u{1}ENUM_LABEL_8\0\u{1}ENUM_LABEL_9\0\u{1}ENUM_LABEL_10\0\u{1}ENUM_LABEL_11\0\u{1}ENUM_LABEL_12\0\u{1}ENUM_LABEL_13\0\u{1}ENUM_LABEL_14\0\u{1}ENUM_LABEL_15\0\u{1}ENUM_LABEL_16\0\u{1}ENUM_LABEL_17\0\u{1}ENUM_LABEL_18\0\u{1}ENUM_LABEL_19\0\u{1}ENUM_LABEL_20\0\u{1}ENUM_LABEL_21\0\u{1}ENUM_LABEL_22\0\u{1}ENUM_LABEL_23\0\u{1}ENUM_LABEL_24\0\u{1}ENUM_LABEL_25\0\u{1}ENUM_LABEL_26\0\u{1}ENUM_LABEL_27\0\u{1}ENUM_LABEL_28\0\u{1}ENUM_LABEL_29\0\u{1}ENUM_LABEL_30\0\u{1}ENUM_LABEL_31\0\u{1}ENUM_LABEL_32\0\u{1}ENUM_LABEL_33\0\u{1}ENUM_LABEL_34\0\u{1}ENUM_LABEL_35\0\u{1}ENUM_LABEL_36\0\u{1}ENUM_LABEL_37\0\u{1}ENUM_LABEL_38\0\u{1}ENUM_LABEL_39\0\u{1}ENUM_LABEL_40\0\u{1}ENUM_LABEL_41\0\u{1}ENUM_LABEL_42\0\u{1}ENUM_LABEL_43\0\u{1}ENUM_LABEL_44\0\u{1}ENUM_LABEL_45\0\u{1}ENUM_LABEL_46\0\u{1}ENUM_LABEL_47\0\u{1}ENUM_LABEL_48\0\u{1}ENUM_LABEL_49\0\u{1}ENUM_LABEL_50\0\u{1}ENUM_LABEL_51\0\u{1}ENUM_LABEL_52\0\u{1}ENUM_LABEL_53\0\u{1}ENUM_LABEL_54\0\u{1}ENUM_LABEL_55\0\u{1}ENUM_LABEL_56\0\u{1}ENUM_LABEL_57\0\u{1}ENUM_LABEL_58\0\u{1}ENUM_LABEL_59\0\u{1}ENUM_LABEL_60\0\u{1}ENUM_LABEL_61\0\u{1}ENUM_LABEL_62\0\u{1}ENUM_LABEL_63\0\u{1}ENUM_LABEL_64\0\u{1}ENUM_LABEL_65\0\u{1}ENUM_LABEL_66\0\u{1}ENUM_LABEL_67\0\u{1}ENUM_LABEL_68\0\u{1}ENUM_LABEL_69\0\u{1}ENUM_LABEL_70\0\u{1}ENUM_LABEL_71\0\u{1}ENUM_LABEL_72\0\u{1}ENUM_LABEL_73\0\u{1}ENUM_LABEL_74\0\u{1}ENUM_LABEL_75\0\u{1}ENUM_LABEL_76\0\u{1}ENUM_LABEL_77\0\u{1}ENUM_LABEL_78\0\u{1}ENUM_LABEL_79\0\u{1}ENUM_LABEL_80\0\u{1}ENUM_LABEL_81\0\u{1}ENUM_LABEL_82\0\u{1}ENUM_LABEL_83\0\u{1}ENUM_LABEL_84\0\u{1}ENUM_LABEL_85\0\u{1}ENUM_LABEL_86\0\u{1}ENUM_LABEL_87\0\u{1}ENUM_LABEL_88\0\u{1}ENUM_LABEL_89\0\u{1}ENUM_LABEL_90\0\u{1}ENUM_LABEL_91\0\u{1}ENUM_LABEL_92\0\u{1}ENUM_LABEL_93\0\u{1}ENUM_LABEL_94\0\u{1}ENUM_LABEL_95\0\u{1}ENUM_LABEL_96\0\u{1}ENUM_LABEL_97\0\u{1}ENUM_LABEL_98\0\u{1}ENUM_LABEL_99\0\u{1}ENUM_LABEL_100\0") +} + +extension EditionUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{7}OptionalGroup\0\u{4}\u{2}optional_nested_message\0\u{3}optional_foreign_message\0\u{3}optional_import_message\0\u{3}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{3}optional_import_enum\0\u{3}optional_string_piece\0\u{3}optional_cord\0\u{3}optional_public_import_message\0\u{3}optional_lazy_message\0\u{3}optional_unverified_lazy_message\0\u{4}\u{3}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{7}RepeatedGroup\0\u{4}\u{2}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{3}repeated_import_message\0\u{3}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{3}repeated_import_enum\0\u{3}repeated_string_piece\0\u{3}repeated_cord\0\u{4}\u{2}repeated_lazy_message\0\u{4}\u{4}default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{4}\u{6}default_nested_enum\0\u{3}default_foreign_enum\0\u{3}default_import_enum\0\u{3}default_string_piece\0\u{3}default_cord\0\u{3}optional_bytes_cord\0\u{4}\u{19}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_cord\0\u{3}oneof_string_piece\0\u{3}oneof_lazy_nested_message\0") + + fileprivate class _StorageClass { + var _optionalInt32: Int32? = nil + var _optionalInt64: Int64? = nil + var _optionalUint32: UInt32? = nil + var _optionalUint64: UInt64? = nil + var _optionalSint32: Int32? = nil + var _optionalSint64: Int64? = nil + var _optionalFixed32: UInt32? = nil + var _optionalFixed64: UInt64? = nil + var _optionalSfixed32: Int32? = nil + var _optionalSfixed64: Int64? = nil + var _optionalFloat: Float? = nil + var _optionalDouble: Double? = nil + var _optionalBool: Bool? = nil + var _optionalString: String? = nil + var _optionalBytes: Data? = nil + var _optionalGroup: EditionUnittest_TestAllTypes.OptionalGroup? = nil + var _optionalNestedMessage: EditionUnittest_TestAllTypes.NestedMessage? = nil + var _optionalForeignMessage: EditionUnittest_ForeignMessage? = nil + var _optionalImportMessage: Proto2UnittestImport_ImportMessage? = nil + var _optionalNestedEnum: EditionUnittest_TestAllTypes.NestedEnum? = nil + var _optionalForeignEnum: EditionUnittest_ForeignEnum? = nil + var _optionalImportEnum: Proto2UnittestImport_ImportEnum? = nil + var _optionalStringPiece: String? = nil + var _optionalCord: String? = nil + var _optionalBytesCord: Data? = nil + var _optionalPublicImportMessage: Proto2UnittestImport_PublicImportMessage? = nil + var _optionalLazyMessage: EditionUnittest_TestAllTypes.NestedMessage? = nil + var _optionalUnverifiedLazyMessage: EditionUnittest_TestAllTypes.NestedMessage? = nil + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedGroup: [EditionUnittest_TestAllTypes.RepeatedGroup] = [] + var _repeatedNestedMessage: [EditionUnittest_TestAllTypes.NestedMessage] = [] + var _repeatedForeignMessage: [EditionUnittest_ForeignMessage] = [] + var _repeatedImportMessage: [Proto2UnittestImport_ImportMessage] = [] + var _repeatedNestedEnum: [EditionUnittest_TestAllTypes.NestedEnum] = [] + var _repeatedForeignEnum: [EditionUnittest_ForeignEnum] = [] + var _repeatedImportEnum: [Proto2UnittestImport_ImportEnum] = [] + var _repeatedStringPiece: [String] = [] + var _repeatedCord: [String] = [] + var _repeatedLazyMessage: [EditionUnittest_TestAllTypes.NestedMessage] = [] + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + var _defaultNestedEnum: EditionUnittest_TestAllTypes.NestedEnum? = nil + var _defaultForeignEnum: EditionUnittest_ForeignEnum? = nil + var _defaultImportEnum: Proto2UnittestImport_ImportEnum? = nil + var _defaultStringPiece: String? = nil + var _defaultCord: String? = nil + var _oneofField: EditionUnittest_TestAllTypes.OneOf_OneofField? + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalGroup = source._optionalGroup + _optionalNestedMessage = source._optionalNestedMessage + _optionalForeignMessage = source._optionalForeignMessage + _optionalImportMessage = source._optionalImportMessage + _optionalNestedEnum = source._optionalNestedEnum + _optionalForeignEnum = source._optionalForeignEnum + _optionalImportEnum = source._optionalImportEnum + _optionalStringPiece = source._optionalStringPiece + _optionalCord = source._optionalCord + _optionalBytesCord = source._optionalBytesCord + _optionalPublicImportMessage = source._optionalPublicImportMessage + _optionalLazyMessage = source._optionalLazyMessage + _optionalUnverifiedLazyMessage = source._optionalUnverifiedLazyMessage + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedGroup = source._repeatedGroup + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedForeignMessage = source._repeatedForeignMessage + _repeatedImportMessage = source._repeatedImportMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _repeatedForeignEnum = source._repeatedForeignEnum + _repeatedImportEnum = source._repeatedImportEnum + _repeatedStringPiece = source._repeatedStringPiece + _repeatedCord = source._repeatedCord + _repeatedLazyMessage = source._repeatedLazyMessage + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + _defaultNestedEnum = source._defaultNestedEnum + _defaultForeignEnum = source._defaultForeignEnum + _defaultImportEnum = source._defaultImportEnum + _defaultStringPiece = source._defaultStringPiece + _defaultCord = source._defaultCord + _oneofField = source._oneofField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 16: try { try decoder.decodeSingularGroupField(value: &_storage._optionalGroup) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() + case 20: try { try decoder.decodeSingularMessageField(value: &_storage._optionalImportMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() + case 23: try { try decoder.decodeSingularEnumField(value: &_storage._optionalImportEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() + case 26: try { try decoder.decodeSingularMessageField(value: &_storage._optionalPublicImportMessage) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._optionalLazyMessage) }() + case 28: try { try decoder.decodeSingularMessageField(value: &_storage._optionalUnverifiedLazyMessage) }() + case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() + case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() + case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() + case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() + case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() + case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() + case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() + case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() + case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() + case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() + case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() + case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() + case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() + case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() + case 46: try { try decoder.decodeRepeatedGroupField(value: &_storage._repeatedGroup) }() + case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() + case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() + case 50: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedImportMessage) }() + case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() + case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() + case 53: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedImportEnum) }() + case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() + case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() + case 57: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedLazyMessage) }() + case 61: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 62: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 63: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 64: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 65: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 66: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 67: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 68: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 69: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 70: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 71: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 72: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 73: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 74: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 75: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() + case 81: try { try decoder.decodeSingularEnumField(value: &_storage._defaultNestedEnum) }() + case 82: try { try decoder.decodeSingularEnumField(value: &_storage._defaultForeignEnum) }() + case 83: try { try decoder.decodeSingularEnumField(value: &_storage._defaultImportEnum) }() + case 84: try { try decoder.decodeSingularStringField(value: &_storage._defaultStringPiece) }() + case 85: try { try decoder.decodeSingularStringField(value: &_storage._defaultCord) }() + case 86: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytesCord) }() + case 111: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 112: try { + var v: EditionUnittest_TestAllTypes.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage(v) + } + }() + case 113: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 114: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() + case 115: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofCord(v) + } + }() + case 116: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofStringPiece(v) + } + }() + case 117: try { + var v: EditionUnittest_TestAllTypes.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofLazyNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofLazyNestedMessage(v) + } + }() + default: break + } + } + } + } + + func traverse(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._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._optionalInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._optionalUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._optionalSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._optionalSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._optionalFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._optionalFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._optionalSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._optionalSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._optionalFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._optionalDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._optionalBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._optionalForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._optionalImportMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 20) + } }() + try { if let v = _storage._optionalNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._optionalForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._optionalImportEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 23) + } }() + try { if let v = _storage._optionalStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._optionalCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._optionalPublicImportMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 26) + } }() + try { if let v = _storage._optionalLazyMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + try { if let v = _storage._optionalUnverifiedLazyMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 28) + } }() + if !_storage._repeatedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + } + if !_storage._repeatedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + } + if !_storage._repeatedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + } + if !_storage._repeatedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + } + if !_storage._repeatedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + } + if !_storage._repeatedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + } + if !_storage._repeatedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + } + if !_storage._repeatedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + } + if !_storage._repeatedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + } + if !_storage._repeatedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + } + if !_storage._repeatedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + } + if !_storage._repeatedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + } + if !_storage._repeatedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + } + if !_storage._repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) + } + if !_storage._repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) + } + if !_storage._repeatedGroup.isEmpty { + try visitor.visitRepeatedGroupField(value: _storage._repeatedGroup, fieldNumber: 46) + } + if !_storage._repeatedNestedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) + } + if !_storage._repeatedForeignMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) + } + if !_storage._repeatedImportMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedImportMessage, fieldNumber: 50) + } + if !_storage._repeatedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + } + if !_storage._repeatedForeignEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) + } + if !_storage._repeatedImportEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedImportEnum, fieldNumber: 53) + } + if !_storage._repeatedStringPiece.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) + } + if !_storage._repeatedCord.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) + } + if !_storage._repeatedLazyMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedLazyMessage, fieldNumber: 57) + } + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 61) + } }() + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 62) + } }() + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 64) + } }() + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 65) + } }() + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 66) + } }() + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 67) + } }() + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 68) + } }() + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 69) + } }() + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 70) + } }() + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 71) + } }() + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 72) + } }() + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 73) + } }() + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 74) + } }() + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 75) + } }() + try { if let v = _storage._defaultNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 81) + } }() + try { if let v = _storage._defaultForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 82) + } }() + try { if let v = _storage._defaultImportEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 83) + } }() + try { if let v = _storage._defaultStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 84) + } }() + try { if let v = _storage._defaultCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 85) + } }() + try { if let v = _storage._optionalBytesCord { + try visitor.visitSingularBytesField(value: v, fieldNumber: 86) + } }() + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case .oneofCord?: try { + guard case .oneofCord(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 115) + }() + case .oneofStringPiece?: try { + guard case .oneofStringPiece(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 116) + }() + case .oneofLazyNestedMessage?: try { + guard case .oneofLazyNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 117) + }() + case nil: break + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestAllTypes, rhs: EditionUnittest_TestAllTypes) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalGroup != rhs_storage._optionalGroup {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} + if _storage._optionalImportMessage != rhs_storage._optionalImportMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} + if _storage._optionalImportEnum != rhs_storage._optionalImportEnum {return false} + if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} + if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._optionalBytesCord != rhs_storage._optionalBytesCord {return false} + if _storage._optionalPublicImportMessage != rhs_storage._optionalPublicImportMessage {return false} + if _storage._optionalLazyMessage != rhs_storage._optionalLazyMessage {return false} + if _storage._optionalUnverifiedLazyMessage != rhs_storage._optionalUnverifiedLazyMessage {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedGroup != rhs_storage._repeatedGroup {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} + if _storage._repeatedImportMessage != rhs_storage._repeatedImportMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} + if _storage._repeatedImportEnum != rhs_storage._repeatedImportEnum {return false} + if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} + if _storage._repeatedCord != rhs_storage._repeatedCord {return false} + if _storage._repeatedLazyMessage != rhs_storage._repeatedLazyMessage {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} + if _storage._defaultNestedEnum != rhs_storage._defaultNestedEnum {return false} + if _storage._defaultForeignEnum != rhs_storage._defaultForeignEnum {return false} + if _storage._defaultImportEnum != rhs_storage._defaultImportEnum {return false} + if _storage._defaultStringPiece != rhs_storage._defaultStringPiece {return false} + if _storage._defaultCord != rhs_storage._defaultCord {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestAllTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{2}\u{2}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension EditionUnittest_TestAllTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestAllTypes.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") + + 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._bb) }() + 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 + try { if let v = self._bb { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestAllTypes.NestedMessage, rhs: EditionUnittest_TestAllTypes.NestedMessage) -> Bool { + if lhs._bb != rhs._bb {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestAllTypes.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestAllTypes.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{11}a\0") + + 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestAllTypes.OptionalGroup, rhs: EditionUnittest_TestAllTypes.OptionalGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestAllTypes.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestAllTypes.protoMessageName + ".RepeatedGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}/a\0") + + 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 47: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestAllTypes.RepeatedGroup, rhs: EditionUnittest_TestAllTypes.RepeatedGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NestedTestAllTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}child\0\u{1}payload\0\u{3}repeated_child\0\u{3}lazy_child\0\u{3}eager_child\0") + + fileprivate class _StorageClass { + var _child: EditionUnittest_NestedTestAllTypes? = nil + var _payload: EditionUnittest_TestAllTypes? = nil + var _repeatedChild: [EditionUnittest_NestedTestAllTypes] = [] + var _lazyChild: EditionUnittest_NestedTestAllTypes? = nil + var _eagerChild: EditionUnittest_TestAllTypes? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _child = source._child + _payload = source._payload + _repeatedChild = source._repeatedChild + _lazyChild = source._lazyChild + _eagerChild = source._eagerChild + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._child) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._payload) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedChild) }() + case 4: try { try decoder.decodeSingularMessageField(value: &_storage._lazyChild) }() + case 5: try { try decoder.decodeSingularMessageField(value: &_storage._eagerChild) }() + default: break + } + } + } + } + + func traverse(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._child { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._payload { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + if !_storage._repeatedChild.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedChild, fieldNumber: 3) + } + try { if let v = _storage._lazyChild { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._eagerChild { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_NestedTestAllTypes, rhs: EditionUnittest_NestedTestAllTypes) -> 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._child != rhs_storage._child {return false} + if _storage._payload != rhs_storage._payload {return false} + if _storage._repeatedChild != rhs_storage._repeatedChild {return false} + if _storage._lazyChild != rhs_storage._lazyChild {return false} + if _storage._eagerChild != rhs_storage._eagerChild {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestDeprecatedFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestDeprecatedFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}deprecated_int32\0\u{3}deprecated_int32_in_oneof\0\u{3}deprecated_message\0\u{3}deprecated_repeated_string\0\u{1}nested\0") + + fileprivate class _StorageClass { + var _deprecatedInt32: Int32? = nil + var _deprecatedRepeatedString: [String] = [] + var _deprecatedMessage: EditionUnittest_TestAllTypes.NestedMessage? = nil + var _oneofFields: EditionUnittest_TestDeprecatedFields.OneOf_OneofFields? + var _nested: EditionUnittest_TestDeprecatedFields? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _deprecatedInt32 = source._deprecatedInt32 + _deprecatedRepeatedString = source._deprecatedRepeatedString + _deprecatedMessage = source._deprecatedMessage + _oneofFields = source._oneofFields + _nested = source._nested + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._deprecatedInt32) }() + case 2: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if _storage._oneofFields != nil {try decoder.handleConflictingOneOf()} + _storage._oneofFields = .deprecatedInt32InOneof(v) + } + }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._deprecatedMessage) }() + case 4: try { try decoder.decodeRepeatedStringField(value: &_storage._deprecatedRepeatedString) }() + case 5: try { try decoder.decodeSingularMessageField(value: &_storage._nested) }() + default: break + } + } + } + } + + func traverse(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._deprecatedInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if case .deprecatedInt32InOneof(let v)? = _storage._oneofFields { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._deprecatedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + if !_storage._deprecatedRepeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._deprecatedRepeatedString, fieldNumber: 4) + } + try { if let v = _storage._nested { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestDeprecatedFields, rhs: EditionUnittest_TestDeprecatedFields) -> 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._deprecatedInt32 != rhs_storage._deprecatedInt32 {return false} + if _storage._deprecatedRepeatedString != rhs_storage._deprecatedRepeatedString {return false} + if _storage._deprecatedMessage != rhs_storage._deprecatedMessage {return false} + if _storage._oneofFields != rhs_storage._oneofFields {return false} + if _storage._nested != rhs_storage._nested {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestDeprecatedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestDeprecatedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestDeprecatedMessage, rhs: EditionUnittest_TestDeprecatedMessage) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0\u{1}d\0") + + 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._c) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._d) }() + 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 + try { if let v = self._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._d { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_ForeignMessage, rhs: EditionUnittest_ForeignMessage) -> Bool { + if lhs._c != rhs._c {return false} + if lhs._d != rhs._d {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestReservedFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestReservedFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{b}bar\0\u{b}baz\0\u{c}\u{2}\u{1}\u{c}\u{f}\u{1}\u{c}\u{9}\u{3}") + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestReservedFields, rhs: EditionUnittest_TestReservedFields) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestAllExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionUnittest_TestAllExtensions.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestAllExtensions, rhs: EditionUnittest_TestAllExtensions) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionUnittest_OptionalGroup_extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OptionalGroup_extension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{11}a\0") + + 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_OptionalGroup_extension, rhs: EditionUnittest_OptionalGroup_extension) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_RepeatedGroup_extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".RepeatedGroup_extension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}/a\0") + + 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 47: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_RepeatedGroup_extension, rhs: EditionUnittest_RepeatedGroup_extension) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestMixedFieldsAndExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMixedFieldsAndExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{2}\u{2}b\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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._a) }() + case 3: try { try decoder.decodeRepeatedFixed32Field(value: &self.b) }() + case 2, 4: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionUnittest_TestMixedFieldsAndExtensions.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2, end: 3) + if !self.b.isEmpty { + try visitor.visitPackedFixed32Field(value: self.b, fieldNumber: 3) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 4, end: 5) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestMixedFieldsAndExtensions, rhs: EditionUnittest_TestMixedFieldsAndExtensions) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.b != rhs.b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionUnittest_TestGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{8}\u{10}OptionalGroup\0\u{4}\u{6}optional_foreign_enum\0") + + 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 16: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() + case 22: try { try decoder.decodeSingularEnumField(value: &self._optionalForeignEnum) }() + 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 + try { if let v = self._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 16) + } }() + try { if let v = self._optionalForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestGroup, rhs: EditionUnittest_TestGroup) -> Bool { + if lhs._optionalGroup != rhs._optionalGroup {return false} + if lhs._optionalForeignEnum != rhs._optionalForeignEnum {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestGroup.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestGroup.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{11}a\0\u{2}H\u{1}zz\0") + + 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + case 89: try { try decoder.decodeSingularInt32Field(value: &self._zz) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) + } }() + try { if let v = self._zz { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 89) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestGroup.OptionalGroup, rhs: EditionUnittest_TestGroup.OptionalGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._zz != rhs._zz {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestGroupExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestGroupExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionUnittest_TestGroupExtension.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestGroupExtension, rhs: EditionUnittest_TestGroupExtension) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionUnittest_TestNestedExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestNestedExtension, rhs: EditionUnittest_TestNestedExtension) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestNestedExtension.OptionalGroup_extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestNestedExtension.protoMessageName + ".OptionalGroup_extension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{11}a\0") + + 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestNestedExtension.OptionalGroup_extension, rhs: EditionUnittest_TestNestedExtension.OptionalGroup_extension) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestChildExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestChildExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0\u{3}optional_extension\0") + + public var isInitialized: Bool { + if let v = self._optionalExtension, !v.isInitialized {return false} + return true + } + + 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._a) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._b) }() + case 3: try { try decoder.decodeSingularMessageField(value: &self._optionalExtension) }() + 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 + try { if let v = self._a { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalExtension { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestChildExtension, rhs: EditionUnittest_TestChildExtension) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs._optionalExtension != rhs._optionalExtension {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestChildExtensionData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestChildExtensionData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0\u{3}optional_extension\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._b) }() + case 3: try { try decoder.decodeSingularMessageField(value: &self._optionalExtension) }() + 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 + try { if let v = self._a { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalExtension { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestChildExtensionData, rhs: EditionUnittest_TestChildExtensionData) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs._optionalExtension != rhs._optionalExtension {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestChildExtensionData.NestedTestAllExtensionsData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestChildExtensionData.protoMessageName + ".NestedTestAllExtensionsData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}@HzZ\u{18}dynamic\0") + + 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 409707008: try { try decoder.decodeSingularMessageField(value: &self._dynamic) }() + 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 + try { if let v = self._dynamic { + try visitor.visitSingularMessageField(value: v, fieldNumber: 409707008) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestChildExtensionData.NestedTestAllExtensionsData, rhs: EditionUnittest_TestChildExtensionData.NestedTestAllExtensionsData) -> Bool { + if lhs._dynamic != rhs._dynamic {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestChildExtensionData.NestedTestAllExtensionsData.NestedDynamicExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestChildExtensionData.NestedTestAllExtensionsData.protoMessageName + ".NestedDynamicExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestChildExtensionData.NestedTestAllExtensionsData.NestedDynamicExtensions, rhs: EditionUnittest_TestChildExtensionData.NestedTestAllExtensionsData.NestedDynamicExtensions) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestNestedChildExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedChildExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}child\0") + + public var isInitialized: Bool { + if let v = self._child, !v.isInitialized {return false} + return true + } + + 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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._child) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._child { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestNestedChildExtension, rhs: EditionUnittest_TestNestedChildExtension) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._child != rhs._child {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestNestedChildExtensionData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedChildExtensionData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}child\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._child) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._child { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestNestedChildExtensionData, rhs: EditionUnittest_TestNestedChildExtensionData) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._child != rhs._child {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestRequiredEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredEnum" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_enum\0\u{1}a\0") + + public var isInitialized: Bool { + if self._requiredEnum == nil {return false} + return true + } + + 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._requiredEnum) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._requiredEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestRequiredEnum, rhs: EditionUnittest_TestRequiredEnum) -> Bool { + if lhs._requiredEnum != rhs._requiredEnum {return false} + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestRequiredEnumNoMask: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredEnumNoMask" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_enum\0\u{1}a\0") + + public var isInitialized: Bool { + if self._requiredEnum == nil {return false} + return true + } + + 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._requiredEnum) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._requiredEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestRequiredEnumNoMask, rhs: EditionUnittest_TestRequiredEnumNoMask) -> Bool { + if lhs._requiredEnum != rhs._requiredEnum {return false} + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestRequiredEnumNoMask.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}BAZ\0\u{1}UNSPECIFIED\0\u{2}\u{2}FOO\0\u{2}b\u{1}BAR\0") +} + +extension EditionUnittest_TestRequiredEnumMulti: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredEnumMulti" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_enum_1\0\u{3}required_enum_2\0\u{3}a_3\0\u{3}required_enum_4\0") + + public var isInitialized: Bool { + if self._requiredEnum4 == nil {return false} + if self._requiredEnum2 == nil {return false} + if self._requiredEnum1 == nil {return false} + return true + } + + 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._requiredEnum1) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self._requiredEnum2) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._a3) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._requiredEnum4) }() + 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 + try { if let v = self._requiredEnum1 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = self._requiredEnum2 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) + } }() + try { if let v = self._a3 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._requiredEnum4 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestRequiredEnumMulti, rhs: EditionUnittest_TestRequiredEnumMulti) -> Bool { + if lhs._requiredEnum4 != rhs._requiredEnum4 {return false} + if lhs._a3 != rhs._a3 {return false} + if lhs._requiredEnum2 != rhs._requiredEnum2 {return false} + if lhs._requiredEnum1 != rhs._requiredEnum1 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestRequiredEnumMulti.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNSPECIFIED\0\u{1}FOO\0\u{1}BAR\0\u{2}b\u{1}BAZ\0") +} + +extension EditionUnittest_TestRequiredNoMaskMulti: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredNoMaskMulti" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_enum_1\0\u{3}required_enum_2\0\u{3}a_3\0\u{3}required_enum_4\0\u{4}(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._requiredEnum1) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self._requiredEnum2) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._a3) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._requiredEnum4) }() + case 64: try { try decoder.decodeSingularEnumField(value: &self._requiredEnum64) }() + case 70: try { try decoder.decodeSingularFixed32Field(value: &self._requiredFixed3270) }() + case 80: try { try decoder.decodeSingularFixed32Field(value: &self._requiredFixed3280) }() + 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 + try { if let v = self._requiredEnum1 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = self._requiredEnum2 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) + } }() + try { if let v = self._a3 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._requiredEnum4 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + try { if let v = self._requiredEnum64 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 64) + } }() + try { if let v = self._requiredFixed3270 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 70) + } }() + try { if let v = self._requiredFixed3280 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 80) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestRequiredNoMaskMulti, rhs: EditionUnittest_TestRequiredNoMaskMulti) -> Bool { + if lhs._requiredFixed3280 != rhs._requiredFixed3280 {return false} + if lhs._requiredFixed3270 != rhs._requiredFixed3270 {return false} + if lhs._requiredEnum64 != rhs._requiredEnum64 {return false} + if lhs._requiredEnum4 != rhs._requiredEnum4 {return false} + if lhs._a3 != rhs._a3 {return false} + if lhs._requiredEnum2 != rhs._requiredEnum2 {return false} + if lhs._requiredEnum1 != rhs._requiredEnum1 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestRequiredNoMaskMulti.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNSPECIFIED\0\u{1}FOO\0\u{1}BAR\0\u{2}b\u{1}BAZ\0") +} + +extension EditionUnittest_TestRequired: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequired" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}dummy2\0\u{1}b\0\u{1}dummy4\0\u{1}dummy5\0\u{1}dummy6\0\u{1}dummy7\0\u{1}dummy8\0\u{1}dummy9\0\u{1}dummy10\0\u{1}dummy11\0\u{1}dummy12\0\u{1}dummy13\0\u{1}dummy14\0\u{1}dummy15\0\u{1}dummy16\0\u{1}dummy17\0\u{1}dummy18\0\u{1}dummy19\0\u{1}dummy20\0\u{1}dummy21\0\u{1}dummy22\0\u{1}dummy23\0\u{1}dummy24\0\u{1}dummy25\0\u{1}dummy26\0\u{1}dummy27\0\u{1}dummy28\0\u{1}dummy29\0\u{1}dummy30\0\u{1}dummy31\0\u{1}dummy32\0\u{1}c\0\u{3}optional_foreign\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _dummy2: Int32? = nil + var _b: Int32? = nil + var _dummy4: Int32? = nil + var _dummy5: Int32? = nil + var _dummy6: Int32? = nil + var _dummy7: Int32? = nil + var _dummy8: Int32? = nil + var _dummy9: Int32? = nil + var _dummy10: Int32? = nil + var _dummy11: Int32? = nil + var _dummy12: Int32? = nil + var _dummy13: Int32? = nil + var _dummy14: Int32? = nil + var _dummy15: Int32? = nil + var _dummy16: Int32? = nil + var _dummy17: Int32? = nil + var _dummy18: Int32? = nil + var _dummy19: Int32? = nil + var _dummy20: Int32? = nil + var _dummy21: Int32? = nil + var _dummy22: Int32? = nil + var _dummy23: Int32? = nil + var _dummy24: Int32? = nil + var _dummy25: Int32? = nil + var _dummy26: Int32? = nil + var _dummy27: Int32? = nil + var _dummy28: Int32? = nil + var _dummy29: Int32? = nil + var _dummy30: Int32? = nil + var _dummy31: Int32? = nil + var _dummy32: Int32? = nil + var _c: Int32? = nil + var _optionalForeign: EditionUnittest_ForeignMessage? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _dummy2 = source._dummy2 + _b = source._b + _dummy4 = source._dummy4 + _dummy5 = source._dummy5 + _dummy6 = source._dummy6 + _dummy7 = source._dummy7 + _dummy8 = source._dummy8 + _dummy9 = source._dummy9 + _dummy10 = source._dummy10 + _dummy11 = source._dummy11 + _dummy12 = source._dummy12 + _dummy13 = source._dummy13 + _dummy14 = source._dummy14 + _dummy15 = source._dummy15 + _dummy16 = source._dummy16 + _dummy17 = source._dummy17 + _dummy18 = source._dummy18 + _dummy19 = source._dummy19 + _dummy20 = source._dummy20 + _dummy21 = source._dummy21 + _dummy22 = source._dummy22 + _dummy23 = source._dummy23 + _dummy24 = source._dummy24 + _dummy25 = source._dummy25 + _dummy26 = source._dummy26 + _dummy27 = source._dummy27 + _dummy28 = source._dummy28 + _dummy29 = source._dummy29 + _dummy30 = source._dummy30 + _dummy31 = source._dummy31 + _dummy32 = source._dummy32 + _c = source._c + _optionalForeign = source._optionalForeign + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._a == nil {return false} + if _storage._b == nil {return false} + if _storage._c == nil {return false} + return true + } + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy2) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &_storage._b) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy4) }() + case 5: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy5) }() + case 6: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy6) }() + case 7: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy7) }() + case 8: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy8) }() + case 9: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy9) }() + case 10: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy10) }() + case 11: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy11) }() + case 12: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy12) }() + case 13: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy13) }() + case 14: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy14) }() + case 15: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy15) }() + case 16: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy16) }() + case 17: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy17) }() + case 18: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy18) }() + case 19: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy19) }() + case 20: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy20) }() + case 21: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy21) }() + case 22: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy22) }() + case 23: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy23) }() + case 24: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy24) }() + case 25: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy25) }() + case 26: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy26) }() + case 27: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy27) }() + case 28: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy28) }() + case 29: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy29) }() + case 30: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy30) }() + case 31: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy31) }() + case 32: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy32) }() + case 33: try { try decoder.decodeSingularInt32Field(value: &_storage._c) }() + case 34: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeign) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._dummy2 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._dummy4 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._dummy5 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._dummy6 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._dummy7 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._dummy8 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._dummy9 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._dummy10 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._dummy11 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._dummy12 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._dummy13 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._dummy14 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._dummy15 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._dummy16 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._dummy17 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) + } }() + try { if let v = _storage._dummy18 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._dummy19 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._dummy20 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 20) + } }() + try { if let v = _storage._dummy21 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._dummy22 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._dummy23 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 23) + } }() + try { if let v = _storage._dummy24 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._dummy25 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._dummy26 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 26) + } }() + try { if let v = _storage._dummy27 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 27) + } }() + try { if let v = _storage._dummy28 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 28) + } }() + try { if let v = _storage._dummy29 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 29) + } }() + try { if let v = _storage._dummy30 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 30) + } }() + try { if let v = _storage._dummy31 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 31) + } }() + try { if let v = _storage._dummy32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 32) + } }() + try { if let v = _storage._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 33) + } }() + try { if let v = _storage._optionalForeign { + try visitor.visitSingularMessageField(value: v, fieldNumber: 34) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestRequired, rhs: EditionUnittest_TestRequired) -> 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._a != rhs_storage._a {return false} + if _storage._dummy2 != rhs_storage._dummy2 {return false} + if _storage._b != rhs_storage._b {return false} + if _storage._dummy4 != rhs_storage._dummy4 {return false} + if _storage._dummy5 != rhs_storage._dummy5 {return false} + if _storage._dummy6 != rhs_storage._dummy6 {return false} + if _storage._dummy7 != rhs_storage._dummy7 {return false} + if _storage._dummy8 != rhs_storage._dummy8 {return false} + if _storage._dummy9 != rhs_storage._dummy9 {return false} + if _storage._dummy10 != rhs_storage._dummy10 {return false} + if _storage._dummy11 != rhs_storage._dummy11 {return false} + if _storage._dummy12 != rhs_storage._dummy12 {return false} + if _storage._dummy13 != rhs_storage._dummy13 {return false} + if _storage._dummy14 != rhs_storage._dummy14 {return false} + if _storage._dummy15 != rhs_storage._dummy15 {return false} + if _storage._dummy16 != rhs_storage._dummy16 {return false} + if _storage._dummy17 != rhs_storage._dummy17 {return false} + if _storage._dummy18 != rhs_storage._dummy18 {return false} + if _storage._dummy19 != rhs_storage._dummy19 {return false} + if _storage._dummy20 != rhs_storage._dummy20 {return false} + if _storage._dummy21 != rhs_storage._dummy21 {return false} + if _storage._dummy22 != rhs_storage._dummy22 {return false} + if _storage._dummy23 != rhs_storage._dummy23 {return false} + if _storage._dummy24 != rhs_storage._dummy24 {return false} + if _storage._dummy25 != rhs_storage._dummy25 {return false} + if _storage._dummy26 != rhs_storage._dummy26 {return false} + if _storage._dummy27 != rhs_storage._dummy27 {return false} + if _storage._dummy28 != rhs_storage._dummy28 {return false} + if _storage._dummy29 != rhs_storage._dummy29 {return false} + if _storage._dummy30 != rhs_storage._dummy30 {return false} + if _storage._dummy31 != rhs_storage._dummy31 {return false} + if _storage._dummy32 != rhs_storage._dummy32 {return false} + if _storage._c != rhs_storage._c {return false} + if _storage._optionalForeign != rhs_storage._optionalForeign {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestRequiredForeign: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredForeign" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_message\0\u{3}repeated_message\0\u{1}dummy\0\u{3}optional_lazy_message\0") + + public var isInitialized: Bool { + if let v = self._optionalMessage, !v.isInitialized {return false} + if !SwiftProtobuf.Internal.areAllInitialized(self.repeatedMessage) {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._optionalMessage) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedMessage) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._dummy) }() + case 4: try { try decoder.decodeSingularMessageField(value: &self._optionalLazyMessage) }() + 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 + try { if let v = self._optionalMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + if !self.repeatedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedMessage, fieldNumber: 2) + } + try { if let v = self._dummy { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._optionalLazyMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestRequiredForeign, rhs: EditionUnittest_TestRequiredForeign) -> Bool { + if lhs._optionalMessage != rhs._optionalMessage {return false} + if lhs.repeatedMessage != rhs.repeatedMessage {return false} + if lhs._dummy != rhs._dummy {return false} + if lhs._optionalLazyMessage != rhs._optionalLazyMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestRequiredMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_message\0\u{3}repeated_message\0\u{3}required_message\0") + + public var isInitialized: Bool { + if self._requiredMessage == nil {return false} + if let v = self._optionalMessage, !v.isInitialized {return false} + if !SwiftProtobuf.Internal.areAllInitialized(self.repeatedMessage) {return false} + if let v = self._requiredMessage, !v.isInitialized {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._optionalMessage) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedMessage) }() + case 3: try { try decoder.decodeSingularMessageField(value: &self._requiredMessage) }() + 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 + try { if let v = self._optionalMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + if !self.repeatedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedMessage, fieldNumber: 2) + } + try { if let v = self._requiredMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestRequiredMessage, rhs: EditionUnittest_TestRequiredMessage) -> Bool { + if lhs._optionalMessage != rhs._optionalMessage {return false} + if lhs.repeatedMessage != rhs.repeatedMessage {return false} + if lhs._requiredMessage != rhs._requiredMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestNestedRequiredForeign: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedRequiredForeign" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}child\0\u{1}payload\0\u{1}dummy\0\u{4}\u{2}required_enum\0\u{3}required_enum_no_mask\0\u{3}required_enum_multi\0\u{4}\u{2}required_no_mask\0") + + fileprivate class _StorageClass { + var _child: EditionUnittest_TestNestedRequiredForeign? = nil + var _payload: EditionUnittest_TestRequiredForeign? = nil + var _dummy: Int32? = nil + var _requiredEnum: EditionUnittest_TestRequiredEnum? = nil + var _requiredEnumNoMask: EditionUnittest_TestRequiredEnumNoMask? = nil + var _requiredEnumMulti: EditionUnittest_TestRequiredEnumMulti? = nil + var _requiredNoMask: EditionUnittest_TestRequiredNoMaskMulti? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _child = source._child + _payload = source._payload + _dummy = source._dummy + _requiredEnum = source._requiredEnum + _requiredEnumNoMask = source._requiredEnumNoMask + _requiredEnumMulti = source._requiredEnumMulti + _requiredNoMask = source._requiredNoMask + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._child, !v.isInitialized {return false} + if let v = _storage._payload, !v.isInitialized {return false} + if let v = _storage._requiredEnum, !v.isInitialized {return false} + if let v = _storage._requiredEnumNoMask, !v.isInitialized {return false} + if let v = _storage._requiredEnumMulti, !v.isInitialized {return false} + if let v = _storage._requiredNoMask, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._child) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._payload) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy) }() + case 5: try { try decoder.decodeSingularMessageField(value: &_storage._requiredEnum) }() + case 6: try { try decoder.decodeSingularMessageField(value: &_storage._requiredEnumNoMask) }() + case 7: try { try decoder.decodeSingularMessageField(value: &_storage._requiredEnumMulti) }() + case 9: try { try decoder.decodeSingularMessageField(value: &_storage._requiredNoMask) }() + default: break + } + } + } + } + + func traverse(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._child { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._payload { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._dummy { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._requiredEnum { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._requiredEnumNoMask { + try visitor.visitSingularMessageField(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._requiredEnumMulti { + try visitor.visitSingularMessageField(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._requiredNoMask { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestNestedRequiredForeign, rhs: EditionUnittest_TestNestedRequiredForeign) -> 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._child != rhs_storage._child {return false} + if _storage._payload != rhs_storage._payload {return false} + if _storage._dummy != rhs_storage._dummy {return false} + if _storage._requiredEnum != rhs_storage._requiredEnum {return false} + if _storage._requiredEnumNoMask != rhs_storage._requiredEnumNoMask {return false} + if _storage._requiredEnumMulti != rhs_storage._requiredEnumMulti {return false} + if _storage._requiredNoMask != rhs_storage._requiredNoMask {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestForeignNested: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestForeignNested" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}foreign_nested\0") + + 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.decodeSingularMessageField(value: &self._foreignNested) }() + 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 + try { if let v = self._foreignNested { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestForeignNested, rhs: EditionUnittest_TestForeignNested) -> Bool { + if lhs._foreignNested != rhs._foreignNested {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestEmptyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEmptyMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestEmptyMessage, rhs: EditionUnittest_TestEmptyMessage) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestEmptyMessageWithExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEmptyMessageWithExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionUnittest_TestEmptyMessageWithExtensions.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestEmptyMessageWithExtensions, rhs: EditionUnittest_TestEmptyMessageWithExtensions) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionUnittest_TestPickleNestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestPickleNestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestPickleNestedMessage, rhs: EditionUnittest_TestPickleNestedMessage) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestPickleNestedMessage.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestPickleNestedMessage.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") + + 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._bb) }() + 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 + try { if let v = self._bb { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestPickleNestedMessage.NestedMessage, rhs: EditionUnittest_TestPickleNestedMessage.NestedMessage) -> Bool { + if lhs._bb != rhs._bb {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestPickleNestedMessage.NestedMessage.protoMessageName + ".NestedNestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}cc\0") + + 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._cc) }() + 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 + try { if let v = self._cc { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage, rhs: EditionUnittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage) -> Bool { + if lhs._cc != rhs._cc {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestMultipleExtensionRanges: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMultipleExtensionRanges" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (42 == fieldNumber) || (4143 <= fieldNumber && fieldNumber < 4244) || (65536 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionUnittest_TestMultipleExtensionRanges.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 42, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestMultipleExtensionRanges, rhs: EditionUnittest_TestMultipleExtensionRanges) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionUnittest_TestReallyLargeTagNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestReallyLargeTagNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{2}~\u{7f}\u{7f}\u{7f}\u{f}bb\0") + + 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._a) }() + case 268435455: try { try decoder.decodeSingularInt32Field(value: &self._bb) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._bb { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 268435455) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestReallyLargeTagNumber, rhs: EditionUnittest_TestReallyLargeTagNumber) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._bb != rhs._bb {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestRecursiveMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRecursiveMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}i\0") + + fileprivate class _StorageClass { + var _a: EditionUnittest_TestRecursiveMessage? = nil + var _i: Int32? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _i = source._i + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._i) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestRecursiveMessage, rhs: EditionUnittest_TestRecursiveMessage) -> 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._a != rhs_storage._a {return false} + if _storage._i != rhs_storage._i {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestMutualRecursionA: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMutualRecursionA" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0\u{7}SubGroup\0\u{8}\u{3}SubGroupR\0") + + fileprivate class _StorageClass { + var _bb: EditionUnittest_TestMutualRecursionB? = nil + var _subGroup: EditionUnittest_TestMutualRecursionA.SubGroup? = nil + var _subGroupR: [EditionUnittest_TestMutualRecursionA.SubGroupR] = [] + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _bb = source._bb + _subGroup = source._subGroup + _subGroupR = source._subGroupR + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._bb) }() + case 2: try { try decoder.decodeSingularGroupField(value: &_storage._subGroup) }() + case 5: try { try decoder.decodeRepeatedGroupField(value: &_storage._subGroupR) }() + default: break + } + } + } + } + + func traverse(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._bb { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._subGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 2) + } }() + if !_storage._subGroupR.isEmpty { + try visitor.visitRepeatedGroupField(value: _storage._subGroupR, fieldNumber: 5) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestMutualRecursionA, rhs: EditionUnittest_TestMutualRecursionA) -> 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._bb != rhs_storage._bb {return false} + if _storage._subGroup != rhs_storage._subGroup {return false} + if _storage._subGroupR != rhs_storage._subGroupR {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestMutualRecursionA.SubMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestMutualRecursionA.protoMessageName + ".SubMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}b\0") + + fileprivate class _StorageClass { + var _b: EditionUnittest_TestMutualRecursionB? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _b = source._b + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._b) }() + default: break + } + } + } + } + + func traverse(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._b { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestMutualRecursionA.SubMessage, rhs: EditionUnittest_TestMutualRecursionA.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._b != rhs_storage._b {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestMutualRecursionA.SubGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestMutualRecursionA.protoMessageName + ".SubGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{3}sub_message\0\u{3}not_in_this_scc\0") + + fileprivate class _StorageClass { + var _subMessage: EditionUnittest_TestMutualRecursionA.SubMessage? = nil + var _notInThisScc: EditionUnittest_TestAllTypes? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _subMessage = source._subMessage + _notInThisScc = source._notInThisScc + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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 3: try { try decoder.decodeSingularMessageField(value: &_storage._subMessage) }() + case 4: try { try decoder.decodeSingularMessageField(value: &_storage._notInThisScc) }() + default: break + } + } + } + } + + func traverse(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._subMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._notInThisScc { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestMutualRecursionA.SubGroup, rhs: EditionUnittest_TestMutualRecursionA.SubGroup) -> 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._subMessage != rhs_storage._subMessage {return false} + if _storage._notInThisScc != rhs_storage._notInThisScc {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestMutualRecursionA.SubGroupR: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestMutualRecursionA.protoMessageName + ".SubGroupR" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{6}payload\0") + + 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 6: try { try decoder.decodeSingularMessageField(value: &self._payload) }() + 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 + try { if let v = self._payload { + try visitor.visitSingularMessageField(value: v, fieldNumber: 6) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestMutualRecursionA.SubGroupR, rhs: EditionUnittest_TestMutualRecursionA.SubGroupR) -> Bool { + if lhs._payload != rhs._payload {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestMutualRecursionB: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMutualRecursionB" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{3}optional_int32\0") + + fileprivate class _StorageClass { + var _a: EditionUnittest_TestMutualRecursionA? = nil + var _optionalInt32: Int32? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _optionalInt32 = source._optionalInt32 + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalInt32) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestMutualRecursionB, rhs: EditionUnittest_TestMutualRecursionB) -> 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._a != rhs_storage._a {return false} + if _storage._optionalInt32 != rhs_storage._optionalInt32 {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestIsInitialized: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestIsInitialized" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}sub_message\0") + + public var isInitialized: Bool { + if let v = self._subMessage, !v.isInitialized {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._subMessage) }() + 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 + try { if let v = self._subMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestIsInitialized, rhs: EditionUnittest_TestIsInitialized) -> Bool { + if lhs._subMessage != rhs._subMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestIsInitialized.SubMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestIsInitialized.protoMessageName + ".SubMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{7}SubGroup\0") + + public var isInitialized: Bool { + if let v = self._subGroup, !v.isInitialized {return false} + return true + } + + 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.decodeSingularGroupField(value: &self._subGroup) }() + 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 + try { if let v = self._subGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestIsInitialized.SubMessage, rhs: EditionUnittest_TestIsInitialized.SubMessage) -> Bool { + if lhs._subGroup != rhs._subGroup {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestIsInitialized.SubMessage.SubGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestIsInitialized.SubMessage.protoMessageName + ".SubGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{2}i\0") + + public var isInitialized: Bool { + if self._i == nil {return false} + return true + } + + 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 2: try { try decoder.decodeSingularInt32Field(value: &self._i) }() + 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 + try { if let v = self._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestIsInitialized.SubMessage.SubGroup, rhs: EditionUnittest_TestIsInitialized.SubMessage.SubGroup) -> Bool { + if lhs._i != rhs._i {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestDupFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestDupFieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{7}Foo\0\u{7}Bar\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularGroupField(value: &self._foo) }() + case 3: try { try decoder.decodeSingularGroupField(value: &self._bar) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._foo { + try visitor.visitSingularGroupField(value: v, fieldNumber: 2) + } }() + try { if let v = self._bar { + try visitor.visitSingularGroupField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestDupFieldNumber, rhs: EditionUnittest_TestDupFieldNumber) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._foo != rhs._foo {return false} + if lhs._bar != rhs._bar {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestDupFieldNumber.Foo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestDupFieldNumber.protoMessageName + ".Foo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") + + 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._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestDupFieldNumber.Foo, rhs: EditionUnittest_TestDupFieldNumber.Foo) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestDupFieldNumber.Bar: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestDupFieldNumber.protoMessageName + ".Bar" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") + + 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._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestDupFieldNumber.Bar, rhs: EditionUnittest_TestDupFieldNumber.Bar) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestEagerMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEagerMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}sub_message\0") + + 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.decodeSingularMessageField(value: &self._subMessage) }() + 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 + try { if let v = self._subMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestEagerMessage, rhs: EditionUnittest_TestEagerMessage) -> Bool { + if lhs._subMessage != rhs._subMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestLazyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestLazyMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}sub_message\0") + + 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.decodeSingularMessageField(value: &self._subMessage) }() + 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 + try { if let v = self._subMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestLazyMessage, rhs: EditionUnittest_TestLazyMessage) -> Bool { + if lhs._subMessage != rhs._subMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestLazyMessageRepeated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestLazyMessageRepeated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}repeated_message\0") + + 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.decodeRepeatedMessageField(value: &self.repeatedMessage) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.repeatedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedMessage, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestLazyMessageRepeated, rhs: EditionUnittest_TestLazyMessageRepeated) -> Bool { + if lhs.repeatedMessage != rhs.repeatedMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestEagerMaybeLazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEagerMaybeLazy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}message_foo\0\u{3}message_bar\0\u{3}message_baz\0") + + 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.decodeSingularMessageField(value: &self._messageFoo) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._messageBar) }() + case 3: try { try decoder.decodeSingularMessageField(value: &self._messageBaz) }() + 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 + try { if let v = self._messageFoo { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = self._messageBar { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = self._messageBaz { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestEagerMaybeLazy, rhs: EditionUnittest_TestEagerMaybeLazy) -> Bool { + if lhs._messageFoo != rhs._messageFoo {return false} + if lhs._messageBar != rhs._messageBar {return false} + if lhs._messageBaz != rhs._messageBaz {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestEagerMaybeLazy.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestEagerMaybeLazy.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}packed\0") + + 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.decodeSingularMessageField(value: &self._packed) }() + 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 + try { if let v = self._packed { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestEagerMaybeLazy.NestedMessage, rhs: EditionUnittest_TestEagerMaybeLazy.NestedMessage) -> Bool { + if lhs._packed != rhs._packed {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestNestedMessageHasBits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedMessageHasBits" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_nested_message\0") + + 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.decodeSingularMessageField(value: &self._optionalNestedMessage) }() + 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 + try { if let v = self._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestNestedMessageHasBits, rhs: EditionUnittest_TestNestedMessageHasBits) -> Bool { + if lhs._optionalNestedMessage != rhs._optionalNestedMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestNestedMessageHasBits.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestNestedMessageHasBits.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}nestedmessage_repeated_int32\0\u{3}nestedmessage_repeated_foreignmessage\0") + + 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.decodeRepeatedInt32Field(value: &self.nestedmessageRepeatedInt32) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.nestedmessageRepeatedForeignmessage) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.nestedmessageRepeatedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: self.nestedmessageRepeatedInt32, fieldNumber: 1) + } + if !self.nestedmessageRepeatedForeignmessage.isEmpty { + try visitor.visitRepeatedMessageField(value: self.nestedmessageRepeatedForeignmessage, fieldNumber: 2) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestNestedMessageHasBits.NestedMessage, rhs: EditionUnittest_TestNestedMessageHasBits.NestedMessage) -> Bool { + if lhs.nestedmessageRepeatedInt32 != rhs.nestedmessageRepeatedInt32 {return false} + if lhs.nestedmessageRepeatedForeignmessage != rhs.nestedmessageRepeatedForeignmessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestCamelCaseFieldNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestCamelCaseFieldNames" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}PrimitiveField\0\u{1}StringField\0\u{1}EnumField\0\u{1}MessageField\0\u{1}StringPieceField\0\u{1}CordField\0\u{1}RepeatedPrimitiveField\0\u{1}RepeatedStringField\0\u{1}RepeatedEnumField\0\u{1}RepeatedMessageField\0\u{1}RepeatedStringPieceField\0\u{1}RepeatedCordField\0") + + 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._primitiveField) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._stringField) }() + case 3: try { try decoder.decodeSingularEnumField(value: &self._enumField) }() + case 4: try { try decoder.decodeSingularMessageField(value: &self._messageField) }() + case 5: try { try decoder.decodeSingularStringField(value: &self._stringPieceField) }() + case 6: try { try decoder.decodeSingularStringField(value: &self._cordField) }() + case 7: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedPrimitiveField) }() + case 8: try { try decoder.decodeRepeatedStringField(value: &self.repeatedStringField) }() + case 9: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedEnumField) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedMessageField) }() + case 11: try { try decoder.decodeRepeatedStringField(value: &self.repeatedStringPieceField) }() + case 12: try { try decoder.decodeRepeatedStringField(value: &self.repeatedCordField) }() + 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 + try { if let v = self._primitiveField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._stringField { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._enumField { + try visitor.visitSingularEnumField(value: v, fieldNumber: 3) + } }() + try { if let v = self._messageField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + try { if let v = self._stringPieceField { + try visitor.visitSingularStringField(value: v, fieldNumber: 5) + } }() + try { if let v = self._cordField { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) + } }() + if !self.repeatedPrimitiveField.isEmpty { + try visitor.visitPackedInt32Field(value: self.repeatedPrimitiveField, fieldNumber: 7) + } + if !self.repeatedStringField.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedStringField, fieldNumber: 8) + } + if !self.repeatedEnumField.isEmpty { + try visitor.visitPackedEnumField(value: self.repeatedEnumField, fieldNumber: 9) + } + if !self.repeatedMessageField.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedMessageField, fieldNumber: 10) + } + if !self.repeatedStringPieceField.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedStringPieceField, fieldNumber: 11) + } + if !self.repeatedCordField.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedCordField, fieldNumber: 12) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestCamelCaseFieldNames, rhs: EditionUnittest_TestCamelCaseFieldNames) -> Bool { + if lhs._primitiveField != rhs._primitiveField {return false} + if lhs._stringField != rhs._stringField {return false} + if lhs._enumField != rhs._enumField {return false} + if lhs._messageField != rhs._messageField {return false} + if lhs._stringPieceField != rhs._stringPieceField {return false} + if lhs._cordField != rhs._cordField {return false} + if lhs.repeatedPrimitiveField != rhs.repeatedPrimitiveField {return false} + if lhs.repeatedStringField != rhs.repeatedStringField {return false} + if lhs.repeatedEnumField != rhs.repeatedEnumField {return false} + if lhs.repeatedMessageField != rhs.repeatedMessageField {return false} + if lhs.repeatedStringPieceField != rhs.repeatedStringPieceField {return false} + if lhs.repeatedCordField != rhs.repeatedCordField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestFieldOrderings: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestFieldOrderings" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}my_int\0\u{4}\u{a}my_string\0\u{4}Z\u{1}my_float\0\u{4}c\u{1}optional_nested_message\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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.decodeSingularInt64Field(value: &self._myInt) }() + case 11: try { try decoder.decodeSingularStringField(value: &self._myString) }() + case 101: try { try decoder.decodeSingularFloatField(value: &self._myFloat) }() + case 200: try { try decoder.decodeSingularMessageField(value: &self._optionalNestedMessage) }() + case 2..<11, 12..<101: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionUnittest_TestFieldOrderings.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._myInt { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 1) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2, end: 11) + try { if let v = self._myString { + try visitor.visitSingularStringField(value: v, fieldNumber: 11) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 12, end: 101) + try { if let v = self._myFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 101) + } }() + try { if let v = self._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 200) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestFieldOrderings, rhs: EditionUnittest_TestFieldOrderings) -> Bool { + if lhs._myString != rhs._myString {return false} + if lhs._myInt != rhs._myInt {return false} + if lhs._myFloat != rhs._myFloat {return false} + if lhs._optionalNestedMessage != rhs._optionalNestedMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionUnittest_TestFieldOrderings.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestFieldOrderings.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0\u{1}oo\0") + + 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._bb) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &self._oo) }() + 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 + try { if let v = self._bb { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._oo { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestFieldOrderings.NestedMessage, rhs: EditionUnittest_TestFieldOrderings.NestedMessage) -> Bool { + if lhs._oo != rhs._oo {return false} + if lhs._bb != rhs._bb {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestExtensionOrderings1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestExtensionOrderings1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}my_string\0") + + 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._myString) }() + 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 + try { if let v = self._myString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestExtensionOrderings1, rhs: EditionUnittest_TestExtensionOrderings1) -> Bool { + if lhs._myString != rhs._myString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestExtensionOrderings2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestExtensionOrderings2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}my_string\0") + + 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._myString) }() + 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 + try { if let v = self._myString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestExtensionOrderings2, rhs: EditionUnittest_TestExtensionOrderings2) -> Bool { + if lhs._myString != rhs._myString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestExtensionOrderings2.TestExtensionOrderings3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestExtensionOrderings2.protoMessageName + ".TestExtensionOrderings3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}my_string\0") + + 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._myString) }() + 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 + try { if let v = self._myString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestExtensionOrderings2.TestExtensionOrderings3, rhs: EditionUnittest_TestExtensionOrderings2.TestExtensionOrderings3) -> Bool { + if lhs._myString != rhs._myString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestExtremeDefaultValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestExtremeDefaultValues" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}escaped_bytes\0\u{3}large_uint32\0\u{3}large_uint64\0\u{3}small_int32\0\u{3}small_int64\0\u{3}utf8_string\0\u{3}zero_float\0\u{3}one_float\0\u{3}small_float\0\u{3}negative_one_float\0\u{3}negative_float\0\u{3}large_float\0\u{3}small_negative_float\0\u{3}inf_double\0\u{3}neg_inf_double\0\u{3}nan_double\0\u{3}inf_float\0\u{3}neg_inf_float\0\u{3}nan_float\0\u{3}cpp_trigraph\0\u{3}really_small_int32\0\u{3}really_small_int64\0\u{3}string_with_zero\0\u{3}bytes_with_zero\0\u{3}string_piece_with_zero\0\u{3}cord_with_zero\0\u{3}replacement_string\0") + + fileprivate class _StorageClass { + var _escapedBytes: Data? = nil + var _largeUint32: UInt32? = nil + var _largeUint64: UInt64? = nil + var _smallInt32: Int32? = nil + var _smallInt64: Int64? = nil + var _reallySmallInt32: Int32? = nil + var _reallySmallInt64: Int64? = nil + var _utf8String: String? = nil + var _zeroFloat: Float? = nil + var _oneFloat: Float? = nil + var _smallFloat: Float? = nil + var _negativeOneFloat: Float? = nil + var _negativeFloat: Float? = nil + var _largeFloat: Float? = nil + var _smallNegativeFloat: Float? = nil + var _infDouble: Double? = nil + var _negInfDouble: Double? = nil + var _nanDouble: Double? = nil + var _infFloat: Float? = nil + var _negInfFloat: Float? = nil + var _nanFloat: Float? = nil + var _cppTrigraph: String? = nil + var _stringWithZero: String? = nil + var _bytesWithZero: Data? = nil + var _stringPieceWithZero: String? = nil + var _cordWithZero: String? = nil + var _replacementString: String? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _escapedBytes = source._escapedBytes + _largeUint32 = source._largeUint32 + _largeUint64 = source._largeUint64 + _smallInt32 = source._smallInt32 + _smallInt64 = source._smallInt64 + _reallySmallInt32 = source._reallySmallInt32 + _reallySmallInt64 = source._reallySmallInt64 + _utf8String = source._utf8String + _zeroFloat = source._zeroFloat + _oneFloat = source._oneFloat + _smallFloat = source._smallFloat + _negativeOneFloat = source._negativeOneFloat + _negativeFloat = source._negativeFloat + _largeFloat = source._largeFloat + _smallNegativeFloat = source._smallNegativeFloat + _infDouble = source._infDouble + _negInfDouble = source._negInfDouble + _nanDouble = source._nanDouble + _infFloat = source._infFloat + _negInfFloat = source._negInfFloat + _nanFloat = source._nanFloat + _cppTrigraph = source._cppTrigraph + _stringWithZero = source._stringWithZero + _bytesWithZero = source._bytesWithZero + _stringPieceWithZero = source._stringPieceWithZero + _cordWithZero = source._cordWithZero + _replacementString = source._replacementString + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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.decodeSingularBytesField(value: &_storage._escapedBytes) }() + case 2: try { try decoder.decodeSingularUInt32Field(value: &_storage._largeUint32) }() + case 3: try { try decoder.decodeSingularUInt64Field(value: &_storage._largeUint64) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &_storage._smallInt32) }() + case 5: try { try decoder.decodeSingularInt64Field(value: &_storage._smallInt64) }() + case 6: try { try decoder.decodeSingularStringField(value: &_storage._utf8String) }() + case 7: try { try decoder.decodeSingularFloatField(value: &_storage._zeroFloat) }() + case 8: try { try decoder.decodeSingularFloatField(value: &_storage._oneFloat) }() + case 9: try { try decoder.decodeSingularFloatField(value: &_storage._smallFloat) }() + case 10: try { try decoder.decodeSingularFloatField(value: &_storage._negativeOneFloat) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._negativeFloat) }() + case 12: try { try decoder.decodeSingularFloatField(value: &_storage._largeFloat) }() + case 13: try { try decoder.decodeSingularFloatField(value: &_storage._smallNegativeFloat) }() + case 14: try { try decoder.decodeSingularDoubleField(value: &_storage._infDouble) }() + case 15: try { try decoder.decodeSingularDoubleField(value: &_storage._negInfDouble) }() + case 16: try { try decoder.decodeSingularDoubleField(value: &_storage._nanDouble) }() + case 17: try { try decoder.decodeSingularFloatField(value: &_storage._infFloat) }() + case 18: try { try decoder.decodeSingularFloatField(value: &_storage._negInfFloat) }() + case 19: try { try decoder.decodeSingularFloatField(value: &_storage._nanFloat) }() + case 20: try { try decoder.decodeSingularStringField(value: &_storage._cppTrigraph) }() + case 21: try { try decoder.decodeSingularInt32Field(value: &_storage._reallySmallInt32) }() + case 22: try { try decoder.decodeSingularInt64Field(value: &_storage._reallySmallInt64) }() + case 23: try { try decoder.decodeSingularStringField(value: &_storage._stringWithZero) }() + case 24: try { try decoder.decodeSingularBytesField(value: &_storage._bytesWithZero) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._stringPieceWithZero) }() + case 26: try { try decoder.decodeSingularStringField(value: &_storage._cordWithZero) }() + case 27: try { try decoder.decodeSingularStringField(value: &_storage._replacementString) }() + default: break + } + } + } + } + + func traverse(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._escapedBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._largeUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._largeUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._smallInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._smallInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._utf8String { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._zeroFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._oneFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._smallFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._negativeOneFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._negativeFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._largeFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._smallNegativeFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._infDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._negInfDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._nanDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._infFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 17) + } }() + try { if let v = _storage._negInfFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._nanFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._cppTrigraph { + try visitor.visitSingularStringField(value: v, fieldNumber: 20) + } }() + try { if let v = _storage._reallySmallInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._reallySmallInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._stringWithZero { + try visitor.visitSingularStringField(value: v, fieldNumber: 23) + } }() + try { if let v = _storage._bytesWithZero { + try visitor.visitSingularBytesField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._stringPieceWithZero { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._cordWithZero { + try visitor.visitSingularStringField(value: v, fieldNumber: 26) + } }() + try { if let v = _storage._replacementString { + try visitor.visitSingularStringField(value: v, fieldNumber: 27) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestExtremeDefaultValues, rhs: EditionUnittest_TestExtremeDefaultValues) -> 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._escapedBytes != rhs_storage._escapedBytes {return false} + if _storage._largeUint32 != rhs_storage._largeUint32 {return false} + if _storage._largeUint64 != rhs_storage._largeUint64 {return false} + if _storage._smallInt32 != rhs_storage._smallInt32 {return false} + if _storage._smallInt64 != rhs_storage._smallInt64 {return false} + if _storage._reallySmallInt32 != rhs_storage._reallySmallInt32 {return false} + if _storage._reallySmallInt64 != rhs_storage._reallySmallInt64 {return false} + if _storage._utf8String != rhs_storage._utf8String {return false} + if _storage._zeroFloat != rhs_storage._zeroFloat {return false} + if _storage._oneFloat != rhs_storage._oneFloat {return false} + if _storage._smallFloat != rhs_storage._smallFloat {return false} + if _storage._negativeOneFloat != rhs_storage._negativeOneFloat {return false} + if _storage._negativeFloat != rhs_storage._negativeFloat {return false} + if _storage._largeFloat != rhs_storage._largeFloat {return false} + if _storage._smallNegativeFloat != rhs_storage._smallNegativeFloat {return false} + if _storage._infDouble != rhs_storage._infDouble {return false} + if _storage._negInfDouble != rhs_storage._negInfDouble {return false} + if _storage._nanDouble != rhs_storage._nanDouble {return false} + if _storage._infFloat != rhs_storage._infFloat {return false} + if _storage._negInfFloat != rhs_storage._negInfFloat {return false} + if _storage._nanFloat != rhs_storage._nanFloat {return false} + if _storage._cppTrigraph != rhs_storage._cppTrigraph {return false} + if _storage._stringWithZero != rhs_storage._stringWithZero {return false} + if _storage._bytesWithZero != rhs_storage._bytesWithZero {return false} + if _storage._stringPieceWithZero != rhs_storage._stringPieceWithZero {return false} + if _storage._cordWithZero != rhs_storage._cordWithZero {return false} + if _storage._replacementString != rhs_storage._replacementString {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_SparseEnumMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".SparseEnumMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}sparse_enum\0") + + 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._sparseEnum) }() + 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 + try { if let v = self._sparseEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_SparseEnumMessage, rhs: EditionUnittest_SparseEnumMessage) -> Bool { + if lhs._sparseEnum != rhs._sparseEnum {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_OneString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OneString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_OneString, rhs: EditionUnittest_OneString) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_MoreString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MoreString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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.decodeRepeatedStringField(value: &self.data) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.data.isEmpty { + try visitor.visitRepeatedStringField(value: self.data, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_MoreString, rhs: EditionUnittest_MoreString) -> Bool { + if lhs.data != rhs.data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_OneBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OneBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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.decodeSingularBytesField(value: &self._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularBytesField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_OneBytes, rhs: EditionUnittest_OneBytes) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_MoreBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MoreBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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.decodeRepeatedBytesField(value: &self.data) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.data.isEmpty { + try visitor.visitRepeatedBytesField(value: self.data, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_MoreBytes, rhs: EditionUnittest_MoreBytes) -> Bool { + if lhs.data != rhs.data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_ManyOptionalString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ManyOptionalString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}str1\0\u{1}str2\0\u{1}str3\0\u{1}str4\0\u{1}str5\0\u{1}str6\0\u{1}str7\0\u{1}str8\0\u{1}str9\0\u{1}str10\0\u{1}str11\0\u{1}str12\0\u{1}str13\0\u{1}str14\0\u{1}str15\0\u{1}str16\0\u{1}str17\0\u{1}str18\0\u{1}str19\0\u{1}str20\0\u{1}str21\0\u{1}str22\0\u{1}str23\0\u{1}str24\0\u{1}str25\0\u{1}str26\0\u{1}str27\0\u{1}str28\0\u{1}str29\0\u{1}str30\0\u{1}str31\0\u{1}str32\0") + + fileprivate class _StorageClass { + var _str1: String? = nil + var _str2: String? = nil + var _str3: String? = nil + var _str4: String? = nil + var _str5: String? = nil + var _str6: String? = nil + var _str7: String? = nil + var _str8: String? = nil + var _str9: String? = nil + var _str10: String? = nil + var _str11: String? = nil + var _str12: String? = nil + var _str13: String? = nil + var _str14: String? = nil + var _str15: String? = nil + var _str16: String? = nil + var _str17: String? = nil + var _str18: String? = nil + var _str19: String? = nil + var _str20: String? = nil + var _str21: String? = nil + var _str22: String? = nil + var _str23: String? = nil + var _str24: String? = nil + var _str25: String? = nil + var _str26: String? = nil + var _str27: String? = nil + var _str28: String? = nil + var _str29: String? = nil + var _str30: String? = nil + var _str31: String? = nil + var _str32: String? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _str1 = source._str1 + _str2 = source._str2 + _str3 = source._str3 + _str4 = source._str4 + _str5 = source._str5 + _str6 = source._str6 + _str7 = source._str7 + _str8 = source._str8 + _str9 = source._str9 + _str10 = source._str10 + _str11 = source._str11 + _str12 = source._str12 + _str13 = source._str13 + _str14 = source._str14 + _str15 = source._str15 + _str16 = source._str16 + _str17 = source._str17 + _str18 = source._str18 + _str19 = source._str19 + _str20 = source._str20 + _str21 = source._str21 + _str22 = source._str22 + _str23 = source._str23 + _str24 = source._str24 + _str25 = source._str25 + _str26 = source._str26 + _str27 = source._str27 + _str28 = source._str28 + _str29 = source._str29 + _str30 = source._str30 + _str31 = source._str31 + _str32 = source._str32 + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._str1) }() + case 2: try { try decoder.decodeSingularStringField(value: &_storage._str2) }() + case 3: try { try decoder.decodeSingularStringField(value: &_storage._str3) }() + case 4: try { try decoder.decodeSingularStringField(value: &_storage._str4) }() + case 5: try { try decoder.decodeSingularStringField(value: &_storage._str5) }() + case 6: try { try decoder.decodeSingularStringField(value: &_storage._str6) }() + case 7: try { try decoder.decodeSingularStringField(value: &_storage._str7) }() + case 8: try { try decoder.decodeSingularStringField(value: &_storage._str8) }() + case 9: try { try decoder.decodeSingularStringField(value: &_storage._str9) }() + case 10: try { try decoder.decodeSingularStringField(value: &_storage._str10) }() + case 11: try { try decoder.decodeSingularStringField(value: &_storage._str11) }() + case 12: try { try decoder.decodeSingularStringField(value: &_storage._str12) }() + case 13: try { try decoder.decodeSingularStringField(value: &_storage._str13) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._str14) }() + case 15: try { try decoder.decodeSingularStringField(value: &_storage._str15) }() + case 16: try { try decoder.decodeSingularStringField(value: &_storage._str16) }() + case 17: try { try decoder.decodeSingularStringField(value: &_storage._str17) }() + case 18: try { try decoder.decodeSingularStringField(value: &_storage._str18) }() + case 19: try { try decoder.decodeSingularStringField(value: &_storage._str19) }() + case 20: try { try decoder.decodeSingularStringField(value: &_storage._str20) }() + case 21: try { try decoder.decodeSingularStringField(value: &_storage._str21) }() + case 22: try { try decoder.decodeSingularStringField(value: &_storage._str22) }() + case 23: try { try decoder.decodeSingularStringField(value: &_storage._str23) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._str24) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._str25) }() + case 26: try { try decoder.decodeSingularStringField(value: &_storage._str26) }() + case 27: try { try decoder.decodeSingularStringField(value: &_storage._str27) }() + case 28: try { try decoder.decodeSingularStringField(value: &_storage._str28) }() + case 29: try { try decoder.decodeSingularStringField(value: &_storage._str29) }() + case 30: try { try decoder.decodeSingularStringField(value: &_storage._str30) }() + case 31: try { try decoder.decodeSingularStringField(value: &_storage._str31) }() + case 32: try { try decoder.decodeSingularStringField(value: &_storage._str32) }() + default: break + } + } + } + } + + func traverse(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._str1 { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._str2 { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._str3 { + try visitor.visitSingularStringField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._str4 { + try visitor.visitSingularStringField(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._str5 { + try visitor.visitSingularStringField(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._str6 { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._str7 { + try visitor.visitSingularStringField(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._str8 { + try visitor.visitSingularStringField(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._str9 { + try visitor.visitSingularStringField(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._str10 { + try visitor.visitSingularStringField(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._str11 { + try visitor.visitSingularStringField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._str12 { + try visitor.visitSingularStringField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._str13 { + try visitor.visitSingularStringField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._str14 { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._str15 { + try visitor.visitSingularStringField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._str16 { + try visitor.visitSingularStringField(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._str17 { + try visitor.visitSingularStringField(value: v, fieldNumber: 17) + } }() + try { if let v = _storage._str18 { + try visitor.visitSingularStringField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._str19 { + try visitor.visitSingularStringField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._str20 { + try visitor.visitSingularStringField(value: v, fieldNumber: 20) + } }() + try { if let v = _storage._str21 { + try visitor.visitSingularStringField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._str22 { + try visitor.visitSingularStringField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._str23 { + try visitor.visitSingularStringField(value: v, fieldNumber: 23) + } }() + try { if let v = _storage._str24 { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._str25 { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._str26 { + try visitor.visitSingularStringField(value: v, fieldNumber: 26) + } }() + try { if let v = _storage._str27 { + try visitor.visitSingularStringField(value: v, fieldNumber: 27) + } }() + try { if let v = _storage._str28 { + try visitor.visitSingularStringField(value: v, fieldNumber: 28) + } }() + try { if let v = _storage._str29 { + try visitor.visitSingularStringField(value: v, fieldNumber: 29) + } }() + try { if let v = _storage._str30 { + try visitor.visitSingularStringField(value: v, fieldNumber: 30) + } }() + try { if let v = _storage._str31 { + try visitor.visitSingularStringField(value: v, fieldNumber: 31) + } }() + try { if let v = _storage._str32 { + try visitor.visitSingularStringField(value: v, fieldNumber: 32) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_ManyOptionalString, rhs: EditionUnittest_ManyOptionalString) -> 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._str1 != rhs_storage._str1 {return false} + if _storage._str2 != rhs_storage._str2 {return false} + if _storage._str3 != rhs_storage._str3 {return false} + if _storage._str4 != rhs_storage._str4 {return false} + if _storage._str5 != rhs_storage._str5 {return false} + if _storage._str6 != rhs_storage._str6 {return false} + if _storage._str7 != rhs_storage._str7 {return false} + if _storage._str8 != rhs_storage._str8 {return false} + if _storage._str9 != rhs_storage._str9 {return false} + if _storage._str10 != rhs_storage._str10 {return false} + if _storage._str11 != rhs_storage._str11 {return false} + if _storage._str12 != rhs_storage._str12 {return false} + if _storage._str13 != rhs_storage._str13 {return false} + if _storage._str14 != rhs_storage._str14 {return false} + if _storage._str15 != rhs_storage._str15 {return false} + if _storage._str16 != rhs_storage._str16 {return false} + if _storage._str17 != rhs_storage._str17 {return false} + if _storage._str18 != rhs_storage._str18 {return false} + if _storage._str19 != rhs_storage._str19 {return false} + if _storage._str20 != rhs_storage._str20 {return false} + if _storage._str21 != rhs_storage._str21 {return false} + if _storage._str22 != rhs_storage._str22 {return false} + if _storage._str23 != rhs_storage._str23 {return false} + if _storage._str24 != rhs_storage._str24 {return false} + if _storage._str25 != rhs_storage._str25 {return false} + if _storage._str26 != rhs_storage._str26 {return false} + if _storage._str27 != rhs_storage._str27 {return false} + if _storage._str28 != rhs_storage._str28 {return false} + if _storage._str29 != rhs_storage._str29 {return false} + if _storage._str30 != rhs_storage._str30 {return false} + if _storage._str31 != rhs_storage._str31 {return false} + if _storage._str32 != rhs_storage._str32 {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_Int32Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Int32Message" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_Int32Message, rhs: EditionUnittest_Int32Message) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_Uint32Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Uint32Message" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_Uint32Message, rhs: EditionUnittest_Uint32Message) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_Int64Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Int64Message" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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.decodeSingularInt64Field(value: &self._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_Int64Message, rhs: EditionUnittest_Int64Message) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_Uint64Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Uint64Message" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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.decodeSingularUInt64Field(value: &self._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_Uint64Message, rhs: EditionUnittest_Uint64Message) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_BoolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".BoolMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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.decodeSingularBoolField(value: &self._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_BoolMessage, rhs: EditionUnittest_BoolMessage) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}foo_int\0\u{3}foo_string\0\u{3}foo_message\0\u{7}FooGroup\0") + + 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: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooInt(v) + } + }() + case 2: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooString(v) + } + }() + case 3: try { + var v: EditionUnittest_TestAllTypes? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooMessage(v) + } + }() + case 4: try { + var v: EditionUnittest_TestOneof.FooGroup? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooGroup(let m) = current {v = m} + } + try decoder.decodeSingularGroupField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooGroup(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.foo { + case .fooInt?: try { + guard case .fooInt(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + }() + case .fooString?: try { + guard case .fooString(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + }() + case .fooMessage?: try { + guard case .fooMessage(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + }() + case .fooGroup?: try { + guard case .fooGroup(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularGroupField(value: v, fieldNumber: 4) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestOneof, rhs: EditionUnittest_TestOneof) -> Bool { + if lhs.foo != rhs.foo {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestOneof.FooGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestOneof.protoMessageName + ".FooGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{5}a\0\u{1}b\0") + + 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 5: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + case 6: try { try decoder.decodeSingularStringField(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = self._b { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestOneof.FooGroup, rhs: EditionUnittest_TestOneof.FooGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestOneofBackwardsCompatible: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestOneofBackwardsCompatible" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}foo_int\0\u{3}foo_string\0\u{3}foo_message\0\u{7}FooGroup\0") + + 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._fooInt) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._fooString) }() + case 3: try { try decoder.decodeSingularMessageField(value: &self._fooMessage) }() + case 4: try { try decoder.decodeSingularGroupField(value: &self._fooGroup) }() + 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 + try { if let v = self._fooInt { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._fooString { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._fooMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try { if let v = self._fooGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 4) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestOneofBackwardsCompatible, rhs: EditionUnittest_TestOneofBackwardsCompatible) -> Bool { + if lhs._fooInt != rhs._fooInt {return false} + if lhs._fooString != rhs._fooString {return false} + if lhs._fooMessage != rhs._fooMessage {return false} + if lhs._fooGroup != rhs._fooGroup {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestOneofBackwardsCompatible.FooGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestOneofBackwardsCompatible.protoMessageName + ".FooGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{5}a\0\u{1}b\0") + + 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 5: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + case 6: try { try decoder.decodeSingularStringField(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = self._b { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestOneofBackwardsCompatible.FooGroup, rhs: EditionUnittest_TestOneofBackwardsCompatible.FooGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestOneof2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestOneof2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}foo_int\0\u{3}foo_string\0\u{3}foo_cord\0\u{3}foo_string_piece\0\u{3}foo_bytes\0\u{3}foo_enum\0\u{3}foo_message\0\u{7}FooGroup\0\u{4}\u{3}foo_lazy_message\0\u{3}bar_int\0\u{3}bar_string\0\u{3}bar_cord\0\u{3}bar_string_piece\0\u{3}bar_bytes\0\u{3}bar_enum\0\u{3}baz_int\0\u{3}baz_string\0\u{3}bar_string_with_empty_default\0\u{3}bar_cord_with_empty_default\0\u{3}bar_string_piece_with_empty_default\0\u{3}bar_bytes_with_empty_default\0\u{4}\u{7}foo_bytes_cord\0") + + 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: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooInt(v) + } + }() + case 2: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooString(v) + } + }() + case 3: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooCord(v) + } + }() + case 4: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooStringPiece(v) + } + }() + case 5: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooBytes(v) + } + }() + case 6: try { + var v: EditionUnittest_TestOneof2.NestedEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooEnum(v) + } + }() + case 7: try { + var v: EditionUnittest_TestOneof2.NestedMessage? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooMessage(v) + } + }() + case 8: try { + var v: EditionUnittest_TestOneof2.FooGroup? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooGroup(let m) = current {v = m} + } + try decoder.decodeSingularGroupField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooGroup(v) + } + }() + case 11: try { + var v: EditionUnittest_TestOneof2.NestedMessage? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooLazyMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooLazyMessage(v) + } + }() + case 12: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barInt(v) + } + }() + case 13: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barString(v) + } + }() + case 14: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barCord(v) + } + }() + case 15: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barStringPiece(v) + } + }() + case 16: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barBytes(v) + } + }() + case 17: try { + var v: EditionUnittest_TestOneof2.NestedEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barEnum(v) + } + }() + case 18: try { try decoder.decodeSingularInt32Field(value: &self._bazInt) }() + case 19: try { try decoder.decodeSingularStringField(value: &self._bazString) }() + case 20: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barStringWithEmptyDefault(v) + } + }() + case 21: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barCordWithEmptyDefault(v) + } + }() + case 22: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barStringPieceWithEmptyDefault(v) + } + }() + case 23: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barBytesWithEmptyDefault(v) + } + }() + case 30: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooBytesCord(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.foo { + case .fooInt?: try { + guard case .fooInt(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + }() + case .fooString?: try { + guard case .fooString(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + }() + case .fooCord?: try { + guard case .fooCord(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 3) + }() + case .fooStringPiece?: try { + guard case .fooStringPiece(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 4) + }() + case .fooBytes?: try { + guard case .fooBytes(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 5) + }() + case .fooEnum?: try { + guard case .fooEnum(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + }() + case .fooMessage?: try { + guard case .fooMessage(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 7) + }() + case .fooGroup?: try { + guard case .fooGroup(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularGroupField(value: v, fieldNumber: 8) + }() + case .fooLazyMessage?: try { + guard case .fooLazyMessage(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 11) + }() + default: break + } + switch self.bar { + case .barInt?: try { + guard case .barInt(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 12) + }() + case .barString?: try { + guard case .barString(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 13) + }() + case .barCord?: try { + guard case .barCord(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + }() + case .barStringPiece?: try { + guard case .barStringPiece(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 15) + }() + case .barBytes?: try { + guard case .barBytes(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 16) + }() + case .barEnum?: try { + guard case .barEnum(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 17) + }() + default: break + } + try { if let v = self._bazInt { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 18) + } }() + try { if let v = self._bazString { + try visitor.visitSingularStringField(value: v, fieldNumber: 19) + } }() + switch self.bar { + case .barStringWithEmptyDefault?: try { + guard case .barStringWithEmptyDefault(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 20) + }() + case .barCordWithEmptyDefault?: try { + guard case .barCordWithEmptyDefault(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 21) + }() + case .barStringPieceWithEmptyDefault?: try { + guard case .barStringPieceWithEmptyDefault(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 22) + }() + case .barBytesWithEmptyDefault?: try { + guard case .barBytesWithEmptyDefault(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 23) + }() + default: break + } + try { if case .fooBytesCord(let v)? = self.foo { + try visitor.visitSingularBytesField(value: v, fieldNumber: 30) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestOneof2, rhs: EditionUnittest_TestOneof2) -> Bool { + if lhs.foo != rhs.foo {return false} + if lhs.bar != rhs.bar {return false} + if lhs._bazInt != rhs._bazInt {return false} + if lhs._bazString != rhs._bazString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestOneof2.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNKNOWN\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension EditionUnittest_TestOneof2.FooGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestOneof2.protoMessageName + ".FooGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{9}a\0\u{1}b\0") + + 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 9: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + case 10: try { try decoder.decodeSingularStringField(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try { if let v = self._b { + try visitor.visitSingularStringField(value: v, fieldNumber: 10) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestOneof2.FooGroup, rhs: EditionUnittest_TestOneof2.FooGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestOneof2.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestOneof2.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}moo_int\0\u{3}corge_int\0") + + 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.decodeSingularInt64Field(value: &self._mooInt) }() + case 2: try { try decoder.decodeRepeatedInt32Field(value: &self.corgeInt) }() + 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 + try { if let v = self._mooInt { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 1) + } }() + if !self.corgeInt.isEmpty { + try visitor.visitPackedInt32Field(value: self.corgeInt, fieldNumber: 2) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestOneof2.NestedMessage, rhs: EditionUnittest_TestOneof2.NestedMessage) -> Bool { + if lhs._mooInt != rhs._mooInt {return false} + if lhs.corgeInt != rhs.corgeInt {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestRequiredOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}foo_int\0\u{3}foo_string\0\u{3}foo_message\0\u{3}foo_lazy_message\0") + + public var isInitialized: Bool { + if let v = self.foo, !v.isInitialized {return false} + return true + } + + 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: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooInt(v) + } + }() + case 2: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooString(v) + } + }() + case 3: try { + var v: EditionUnittest_TestRequiredOneof.NestedMessage? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooMessage(v) + } + }() + case 4: try { + var v: EditionUnittest_TestRequiredOneof.NestedMessage? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooLazyMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooLazyMessage(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.foo { + case .fooInt?: try { + guard case .fooInt(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + }() + case .fooString?: try { + guard case .fooString(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + }() + case .fooMessage?: try { + guard case .fooMessage(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + }() + case .fooLazyMessage?: try { + guard case .fooLazyMessage(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestRequiredOneof, rhs: EditionUnittest_TestRequiredOneof) -> Bool { + if lhs.foo != rhs.foo {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestRequiredOneof.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestRequiredOneof.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_double\0") + + public var isInitialized: Bool { + if self._requiredDouble == nil {return false} + return true + } + + 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.decodeSingularDoubleField(value: &self._requiredDouble) }() + 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 + try { if let v = self._requiredDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestRequiredOneof.NestedMessage, rhs: EditionUnittest_TestRequiredOneof.NestedMessage) -> Bool { + if lhs._requiredDouble != rhs._requiredDouble {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestPackedTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}Z\u{1}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_enum\0") + + 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 90: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32) }() + case 91: try { try decoder.decodeRepeatedInt64Field(value: &self.packedInt64) }() + case 92: try { try decoder.decodeRepeatedUInt32Field(value: &self.packedUint32) }() + case 93: try { try decoder.decodeRepeatedUInt64Field(value: &self.packedUint64) }() + case 94: try { try decoder.decodeRepeatedSInt32Field(value: &self.packedSint32) }() + case 95: try { try decoder.decodeRepeatedSInt64Field(value: &self.packedSint64) }() + case 96: try { try decoder.decodeRepeatedFixed32Field(value: &self.packedFixed32) }() + case 97: try { try decoder.decodeRepeatedFixed64Field(value: &self.packedFixed64) }() + case 98: try { try decoder.decodeRepeatedSFixed32Field(value: &self.packedSfixed32) }() + case 99: try { try decoder.decodeRepeatedSFixed64Field(value: &self.packedSfixed64) }() + case 100: try { try decoder.decodeRepeatedFloatField(value: &self.packedFloat) }() + case 101: try { try decoder.decodeRepeatedDoubleField(value: &self.packedDouble) }() + case 102: try { try decoder.decodeRepeatedBoolField(value: &self.packedBool) }() + case 103: try { try decoder.decodeRepeatedEnumField(value: &self.packedEnum) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: self.packedInt32, fieldNumber: 90) + } + if !self.packedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: self.packedInt64, fieldNumber: 91) + } + if !self.packedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: self.packedUint32, fieldNumber: 92) + } + if !self.packedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: self.packedUint64, fieldNumber: 93) + } + if !self.packedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: self.packedSint32, fieldNumber: 94) + } + if !self.packedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: self.packedSint64, fieldNumber: 95) + } + if !self.packedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: self.packedFixed32, fieldNumber: 96) + } + if !self.packedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: self.packedFixed64, fieldNumber: 97) + } + if !self.packedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: self.packedSfixed32, fieldNumber: 98) + } + if !self.packedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: self.packedSfixed64, fieldNumber: 99) + } + if !self.packedFloat.isEmpty { + try visitor.visitPackedFloatField(value: self.packedFloat, fieldNumber: 100) + } + if !self.packedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: self.packedDouble, fieldNumber: 101) + } + if !self.packedBool.isEmpty { + try visitor.visitPackedBoolField(value: self.packedBool, fieldNumber: 102) + } + if !self.packedEnum.isEmpty { + try visitor.visitPackedEnumField(value: self.packedEnum, fieldNumber: 103) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestPackedTypes, rhs: EditionUnittest_TestPackedTypes) -> Bool { + if lhs.packedInt32 != rhs.packedInt32 {return false} + if lhs.packedInt64 != rhs.packedInt64 {return false} + if lhs.packedUint32 != rhs.packedUint32 {return false} + if lhs.packedUint64 != rhs.packedUint64 {return false} + if lhs.packedSint32 != rhs.packedSint32 {return false} + if lhs.packedSint64 != rhs.packedSint64 {return false} + if lhs.packedFixed32 != rhs.packedFixed32 {return false} + if lhs.packedFixed64 != rhs.packedFixed64 {return false} + if lhs.packedSfixed32 != rhs.packedSfixed32 {return false} + if lhs.packedSfixed64 != rhs.packedSfixed64 {return false} + if lhs.packedFloat != rhs.packedFloat {return false} + if lhs.packedDouble != rhs.packedDouble {return false} + if lhs.packedBool != rhs.packedBool {return false} + if lhs.packedEnum != rhs.packedEnum {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestUnpackedTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}Z\u{1}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_enum\0") + + 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 90: try { try decoder.decodeRepeatedInt32Field(value: &self.unpackedInt32) }() + case 91: try { try decoder.decodeRepeatedInt64Field(value: &self.unpackedInt64) }() + case 92: try { try decoder.decodeRepeatedUInt32Field(value: &self.unpackedUint32) }() + case 93: try { try decoder.decodeRepeatedUInt64Field(value: &self.unpackedUint64) }() + case 94: try { try decoder.decodeRepeatedSInt32Field(value: &self.unpackedSint32) }() + case 95: try { try decoder.decodeRepeatedSInt64Field(value: &self.unpackedSint64) }() + case 96: try { try decoder.decodeRepeatedFixed32Field(value: &self.unpackedFixed32) }() + case 97: try { try decoder.decodeRepeatedFixed64Field(value: &self.unpackedFixed64) }() + case 98: try { try decoder.decodeRepeatedSFixed32Field(value: &self.unpackedSfixed32) }() + case 99: try { try decoder.decodeRepeatedSFixed64Field(value: &self.unpackedSfixed64) }() + case 100: try { try decoder.decodeRepeatedFloatField(value: &self.unpackedFloat) }() + case 101: try { try decoder.decodeRepeatedDoubleField(value: &self.unpackedDouble) }() + case 102: try { try decoder.decodeRepeatedBoolField(value: &self.unpackedBool) }() + case 103: try { try decoder.decodeRepeatedEnumField(value: &self.unpackedEnum) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.unpackedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.unpackedInt32, fieldNumber: 90) + } + if !self.unpackedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: self.unpackedInt64, fieldNumber: 91) + } + if !self.unpackedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: self.unpackedUint32, fieldNumber: 92) + } + if !self.unpackedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: self.unpackedUint64, fieldNumber: 93) + } + if !self.unpackedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: self.unpackedSint32, fieldNumber: 94) + } + if !self.unpackedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: self.unpackedSint64, fieldNumber: 95) + } + if !self.unpackedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: self.unpackedFixed32, fieldNumber: 96) + } + if !self.unpackedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: self.unpackedFixed64, fieldNumber: 97) + } + if !self.unpackedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: self.unpackedSfixed32, fieldNumber: 98) + } + if !self.unpackedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: self.unpackedSfixed64, fieldNumber: 99) + } + if !self.unpackedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: self.unpackedFloat, fieldNumber: 100) + } + if !self.unpackedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: self.unpackedDouble, fieldNumber: 101) + } + if !self.unpackedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: self.unpackedBool, fieldNumber: 102) + } + if !self.unpackedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: self.unpackedEnum, fieldNumber: 103) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestUnpackedTypes, rhs: EditionUnittest_TestUnpackedTypes) -> Bool { + if lhs.unpackedInt32 != rhs.unpackedInt32 {return false} + if lhs.unpackedInt64 != rhs.unpackedInt64 {return false} + if lhs.unpackedUint32 != rhs.unpackedUint32 {return false} + if lhs.unpackedUint64 != rhs.unpackedUint64 {return false} + if lhs.unpackedSint32 != rhs.unpackedSint32 {return false} + if lhs.unpackedSint64 != rhs.unpackedSint64 {return false} + if lhs.unpackedFixed32 != rhs.unpackedFixed32 {return false} + if lhs.unpackedFixed64 != rhs.unpackedFixed64 {return false} + if lhs.unpackedSfixed32 != rhs.unpackedSfixed32 {return false} + if lhs.unpackedSfixed64 != rhs.unpackedSfixed64 {return false} + if lhs.unpackedFloat != rhs.unpackedFloat {return false} + if lhs.unpackedDouble != rhs.unpackedDouble {return false} + if lhs.unpackedBool != rhs.unpackedBool {return false} + if lhs.unpackedEnum != rhs.unpackedEnum {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestPackedExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestPackedExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionUnittest_TestPackedExtensions.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestPackedExtensions, rhs: EditionUnittest_TestPackedExtensions) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionUnittest_TestUnpackedExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestUnpackedExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionUnittest_TestUnpackedExtensions.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestUnpackedExtensions, rhs: EditionUnittest_TestUnpackedExtensions) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionUnittest_TestDynamicExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestDynamicExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}P\u{1f}scalar_extension\0\u{3}enum_extension\0\u{3}dynamic_enum_extension\0\u{3}message_extension\0\u{3}dynamic_message_extension\0\u{3}repeated_extension\0\u{3}packed_extension\0") + + 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 2000: try { try decoder.decodeSingularFixed32Field(value: &self._scalarExtension) }() + case 2001: try { try decoder.decodeSingularEnumField(value: &self._enumExtension) }() + case 2002: try { try decoder.decodeSingularEnumField(value: &self._dynamicEnumExtension) }() + case 2003: try { try decoder.decodeSingularMessageField(value: &self._messageExtension) }() + case 2004: try { try decoder.decodeSingularMessageField(value: &self._dynamicMessageExtension) }() + case 2005: try { try decoder.decodeRepeatedStringField(value: &self.repeatedExtension) }() + case 2006: try { try decoder.decodeRepeatedSInt32Field(value: &self.packedExtension) }() + 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 + try { if let v = self._scalarExtension { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 2000) + } }() + try { if let v = self._enumExtension { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2001) + } }() + try { if let v = self._dynamicEnumExtension { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2002) + } }() + try { if let v = self._messageExtension { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2003) + } }() + try { if let v = self._dynamicMessageExtension { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2004) + } }() + if !self.repeatedExtension.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedExtension, fieldNumber: 2005) + } + if !self.packedExtension.isEmpty { + try visitor.visitPackedSInt32Field(value: self.packedExtension, fieldNumber: 2006) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestDynamicExtensions, rhs: EditionUnittest_TestDynamicExtensions) -> Bool { + if lhs._scalarExtension != rhs._scalarExtension {return false} + if lhs._enumExtension != rhs._enumExtension {return false} + if lhs._dynamicEnumExtension != rhs._dynamicEnumExtension {return false} + if lhs._messageExtension != rhs._messageExtension {return false} + if lhs._dynamicMessageExtension != rhs._dynamicMessageExtension {return false} + if lhs.repeatedExtension != rhs.repeatedExtension {return false} + if lhs.packedExtension != rhs.packedExtension {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestDynamicExtensions.DynamicEnumType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0DYNAMIC_UNKNOWN\0\u{2}X\"DYNAMIC_FOO\0\u{1}DYNAMIC_BAR\0\u{1}DYNAMIC_BAZ\0") +} + +extension EditionUnittest_TestDynamicExtensions.DynamicMessageType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestDynamicExtensions.protoMessageName + ".DynamicMessageType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}t dynamic_field\0") + + 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 2100: try { try decoder.decodeSingularInt32Field(value: &self._dynamicField) }() + 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 + try { if let v = self._dynamicField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2100) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestDynamicExtensions.DynamicMessageType, rhs: EditionUnittest_TestDynamicExtensions.DynamicMessageType) -> Bool { + if lhs._dynamicField != rhs._dynamicField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestRepeatedString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRepeatedString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}repeated_string1\0\u{3}repeated_string2\0\u{4}\u{9}repeated_bytes11\0\u{3}repeated_bytes12\0") + + 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.decodeRepeatedStringField(value: &self.repeatedString1) }() + case 2: try { try decoder.decodeRepeatedStringField(value: &self.repeatedString2) }() + case 11: try { try decoder.decodeRepeatedBytesField(value: &self.repeatedBytes11) }() + case 12: try { try decoder.decodeRepeatedBytesField(value: &self.repeatedBytes12) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.repeatedString1.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedString1, fieldNumber: 1) + } + if !self.repeatedString2.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedString2, fieldNumber: 2) + } + if !self.repeatedBytes11.isEmpty { + try visitor.visitRepeatedBytesField(value: self.repeatedBytes11, fieldNumber: 11) + } + if !self.repeatedBytes12.isEmpty { + try visitor.visitRepeatedBytesField(value: self.repeatedBytes12, fieldNumber: 12) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestRepeatedString, rhs: EditionUnittest_TestRepeatedString) -> Bool { + if lhs.repeatedString1 != rhs.repeatedString1 {return false} + if lhs.repeatedString2 != rhs.repeatedString2 {return false} + if lhs.repeatedBytes11 != rhs.repeatedBytes11 {return false} + if lhs.repeatedBytes12 != rhs.repeatedBytes12 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestRepeatedScalarDifferentTagSizes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRepeatedScalarDifferentTagSizes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{c}repeated_fixed32\0\u{3}repeated_int32\0\u{4}q\u{1f}repeated_fixed64\0\u{3}repeated_int64\0\u{4}\u{7f}_?repeated_float\0\u{3}repeated_uint64\0") + + 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 12: try { try decoder.decodeRepeatedFixed32Field(value: &self.repeatedFixed32) }() + case 13: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() + case 2046: try { try decoder.decodeRepeatedFixed64Field(value: &self.repeatedFixed64) }() + case 2047: try { try decoder.decodeRepeatedInt64Field(value: &self.repeatedInt64) }() + case 262142: try { try decoder.decodeRepeatedFloatField(value: &self.repeatedFloat) }() + case 262143: try { try decoder.decodeRepeatedUInt64Field(value: &self.repeatedUint64) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.repeatedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: self.repeatedFixed32, fieldNumber: 12) + } + if !self.repeatedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: self.repeatedInt32, fieldNumber: 13) + } + if !self.repeatedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: self.repeatedFixed64, fieldNumber: 2046) + } + if !self.repeatedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: self.repeatedInt64, fieldNumber: 2047) + } + if !self.repeatedFloat.isEmpty { + try visitor.visitPackedFloatField(value: self.repeatedFloat, fieldNumber: 262142) + } + if !self.repeatedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: self.repeatedUint64, fieldNumber: 262143) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestRepeatedScalarDifferentTagSizes, rhs: EditionUnittest_TestRepeatedScalarDifferentTagSizes) -> Bool { + if lhs.repeatedFixed32 != rhs.repeatedFixed32 {return false} + if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} + if lhs.repeatedFixed64 != rhs.repeatedFixed64 {return false} + if lhs.repeatedInt64 != rhs.repeatedInt64 {return false} + if lhs.repeatedFloat != rhs.repeatedFloat {return false} + if lhs.repeatedUint64 != rhs.repeatedUint64 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestParsingMerge: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestParsingMerge" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_all_types\0\u{3}optional_all_types\0\u{3}repeated_all_types\0\u{8}\u{7}OptionalGroup\0\u{8}\u{a}RepeatedGroup\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + if self._requiredAllTypes == nil {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._requiredAllTypes) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 10: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() + case 20: try { try decoder.decodeRepeatedGroupField(value: &self.repeatedGroup) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionUnittest_TestParsingMerge.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._requiredAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 3) + } + try { if let v = self._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 10) + } }() + if !self.repeatedGroup.isEmpty { + try visitor.visitRepeatedGroupField(value: self.repeatedGroup, fieldNumber: 20) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestParsingMerge, rhs: EditionUnittest_TestParsingMerge) -> Bool { + if lhs._requiredAllTypes != rhs._requiredAllTypes {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs._optionalGroup != rhs._optionalGroup {return false} + if lhs.repeatedGroup != rhs.repeatedGroup {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionUnittest_TestParsingMerge.RepeatedFieldsGenerator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestParsingMerge.protoMessageName + ".RepeatedFieldsGenerator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field1\0\u{1}field2\0\u{1}field3\0\u{8}\u{7}Group1\0\u{8}\u{a}Group2\0\u{2}T\u{f}ext1\0\u{1}ext2\0") + + 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.decodeRepeatedMessageField(value: &self.field1) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.field2) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &self.field3) }() + case 10: try { try decoder.decodeRepeatedGroupField(value: &self.group1) }() + case 20: try { try decoder.decodeRepeatedGroupField(value: &self.group2) }() + case 1000: try { try decoder.decodeRepeatedMessageField(value: &self.ext1) }() + case 1001: try { try decoder.decodeRepeatedMessageField(value: &self.ext2) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.field1.isEmpty { + try visitor.visitRepeatedMessageField(value: self.field1, fieldNumber: 1) + } + if !self.field2.isEmpty { + try visitor.visitRepeatedMessageField(value: self.field2, fieldNumber: 2) + } + if !self.field3.isEmpty { + try visitor.visitRepeatedMessageField(value: self.field3, fieldNumber: 3) + } + if !self.group1.isEmpty { + try visitor.visitRepeatedGroupField(value: self.group1, fieldNumber: 10) + } + if !self.group2.isEmpty { + try visitor.visitRepeatedGroupField(value: self.group2, fieldNumber: 20) + } + if !self.ext1.isEmpty { + try visitor.visitRepeatedMessageField(value: self.ext1, fieldNumber: 1000) + } + if !self.ext2.isEmpty { + try visitor.visitRepeatedMessageField(value: self.ext2, fieldNumber: 1001) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestParsingMerge.RepeatedFieldsGenerator, rhs: EditionUnittest_TestParsingMerge.RepeatedFieldsGenerator) -> Bool { + if lhs.field1 != rhs.field1 {return false} + if lhs.field2 != rhs.field2 {return false} + if lhs.field3 != rhs.field3 {return false} + if lhs.group1 != rhs.group1 {return false} + if lhs.group2 != rhs.group2 {return false} + if lhs.ext1 != rhs.ext1 {return false} + if lhs.ext2 != rhs.ext2 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestParsingMerge.RepeatedFieldsGenerator.protoMessageName + ".Group1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{b}field1\0") + + 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 11: try { try decoder.decodeSingularMessageField(value: &self._field1) }() + 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 + try { if let v = self._field1 { + try visitor.visitSingularMessageField(value: v, fieldNumber: 11) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group1, rhs: EditionUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group1) -> Bool { + if lhs._field1 != rhs._field1 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestParsingMerge.RepeatedFieldsGenerator.protoMessageName + ".Group2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{15}field1\0") + + 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 21: try { try decoder.decodeSingularMessageField(value: &self._field1) }() + 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 + try { if let v = self._field1 { + try visitor.visitSingularMessageField(value: v, fieldNumber: 21) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group2, rhs: EditionUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group2) -> Bool { + if lhs._field1 != rhs._field1 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestParsingMerge.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestParsingMerge.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{b}optional_group_all_types\0") + + 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 11: try { try decoder.decodeSingularMessageField(value: &self._optionalGroupAllTypes) }() + 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 + try { if let v = self._optionalGroupAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 11) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestParsingMerge.OptionalGroup, rhs: EditionUnittest_TestParsingMerge.OptionalGroup) -> Bool { + if lhs._optionalGroupAllTypes != rhs._optionalGroupAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestParsingMerge.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestParsingMerge.protoMessageName + ".RepeatedGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{15}repeated_group_all_types\0") + + 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 21: try { try decoder.decodeSingularMessageField(value: &self._repeatedGroupAllTypes) }() + 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 + try { if let v = self._repeatedGroupAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 21) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestParsingMerge.RepeatedGroup, rhs: EditionUnittest_TestParsingMerge.RepeatedGroup) -> Bool { + if lhs._repeatedGroupAllTypes != rhs._repeatedGroupAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestMergeException: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMergeException" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}all_extensions\0") + + public var isInitialized: Bool { + if let v = self._allExtensions, !v.isInitialized {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._allExtensions) }() + 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 + try { if let v = self._allExtensions { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestMergeException, rhs: EditionUnittest_TestMergeException) -> Bool { + if lhs._allExtensions != rhs._allExtensions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestCommentInjectionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestCommentInjectionMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") + + 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._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestCommentInjectionMessage, rhs: EditionUnittest_TestCommentInjectionMessage) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestMessageSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}m1\0\u{1}m2\0\u{1}m3\0\u{1}m4\0\u{1}m5\0\u{1}m6\0") + + 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.decodeSingularBoolField(value: &self._m1) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &self._m2) }() + case 3: try { try decoder.decodeSingularBoolField(value: &self._m3) }() + case 4: try { try decoder.decodeSingularStringField(value: &self._m4) }() + case 5: try { try decoder.decodeSingularInt32Field(value: &self._m5) }() + case 6: try { try decoder.decodeSingularInt64Field(value: &self._m6) }() + 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 + try { if let v = self._m1 { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1) + } }() + try { if let v = self._m2 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._m3 { + try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + } }() + try { if let v = self._m4 { + try visitor.visitSingularStringField(value: v, fieldNumber: 4) + } }() + try { if let v = self._m5 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = self._m6 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 6) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestMessageSize, rhs: EditionUnittest_TestMessageSize) -> Bool { + if lhs._m1 != rhs._m1 {return false} + if lhs._m2 != rhs._m2 {return false} + if lhs._m3 != rhs._m3 {return false} + if lhs._m4 != rhs._m4 {return false} + if lhs._m5 != rhs._m5 {return false} + if lhs._m6 != rhs._m6 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestEagerlyVerifiedLazyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEagerlyVerifiedLazyMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}lazy_message\0") + + 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.decodeSingularMessageField(value: &self._lazyMessage) }() + 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 + try { if let v = self._lazyMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestEagerlyVerifiedLazyMessage, rhs: EditionUnittest_TestEagerlyVerifiedLazyMessage) -> Bool { + if lhs._lazyMessage != rhs._lazyMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestEagerlyVerifiedLazyMessage.LazyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestEagerlyVerifiedLazyMessage.protoMessageName + ".LazyMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}bytes_field\0") + + 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.decodeSingularBytesField(value: &self._bytesField) }() + 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 + try { if let v = self._bytesField { + try visitor.visitSingularBytesField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestEagerlyVerifiedLazyMessage.LazyMessage, rhs: EditionUnittest_TestEagerlyVerifiedLazyMessage.LazyMessage) -> Bool { + if lhs._bytesField != rhs._bytesField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_FooRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FooRequest" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_FooRequest, rhs: EditionUnittest_FooRequest) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_FooResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FooResponse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_FooResponse, rhs: EditionUnittest_FooResponse) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_FooClientMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FooClientMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_FooClientMessage, rhs: EditionUnittest_FooClientMessage) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_FooServerMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FooServerMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_FooServerMessage, rhs: EditionUnittest_FooServerMessage) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_BarRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".BarRequest" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_BarRequest, rhs: EditionUnittest_BarRequest) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_BarResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".BarResponse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_BarResponse, rhs: EditionUnittest_BarResponse) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestJsonName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestJsonName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}field_name1\0\u{1}fieldName2\0\u{1}FieldName3\0\u{3}_field_name4\0\u{3}FIELD_NAME5\0\u{5}field_name6\0@type\0\u{1}fieldname7\0") + + 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._fieldName1) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._fieldName2) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._fieldName3) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &self._fieldName4) }() + case 5: try { try decoder.decodeSingularInt32Field(value: &self._fieldName5) }() + case 6: try { try decoder.decodeSingularInt32Field(value: &self._fieldName6) }() + case 7: try { try decoder.decodeSingularInt32Field(value: &self._fieldname7) }() + 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 + try { if let v = self._fieldName1 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._fieldName2 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._fieldName3 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._fieldName4 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try { if let v = self._fieldName5 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = self._fieldName6 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) + } }() + try { if let v = self._fieldname7 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestJsonName, rhs: EditionUnittest_TestJsonName) -> Bool { + if lhs._fieldName1 != rhs._fieldName1 {return false} + if lhs._fieldName2 != rhs._fieldName2 {return false} + if lhs._fieldName3 != rhs._fieldName3 {return false} + if lhs._fieldName4 != rhs._fieldName4 {return false} + if lhs._fieldName5 != rhs._fieldName5 {return false} + if lhs._fieldName6 != rhs._fieldName6 {return false} + if lhs._fieldname7 != rhs._fieldname7 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestHugeFieldNumbers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestHugeFieldNumbers" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}pq\u{7f}\u{7f}\u{1f}optional_int32\0\u{3}fixed_32\0\u{3}repeated_int32\0\u{3}packed_int32\0\u{3}optional_enum\0\u{3}optional_string\0\u{3}optional_bytes\0\u{3}optional_message\0\u{7}OptionalGroup\0\u{4}\u{2}string_string_map\0\u{3}oneof_uint32\0\u{3}oneof_test_all_types\0\u{3}oneof_string\0\u{3}oneof_bytes\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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 536870000: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32) }() + case 536870001: try { try decoder.decodeSingularInt32Field(value: &self._fixed32) }() + case 536870002: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() + case 536870003: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32) }() + case 536870004: try { try decoder.decodeSingularEnumField(value: &self._optionalEnum) }() + case 536870005: try { try decoder.decodeSingularStringField(value: &self._optionalString) }() + case 536870006: try { try decoder.decodeSingularBytesField(value: &self._optionalBytes) }() + case 536870007: try { try decoder.decodeSingularMessageField(value: &self._optionalMessage) }() + case 536870008: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() + case 536870010: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.stringStringMap) }() + case 536870011: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .oneofUint32(v) + } + }() + case 536870012: try { + var v: EditionUnittest_TestAllTypes? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .oneofTestAllTypes(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .oneofTestAllTypes(v) + } + }() + case 536870013: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .oneofString(v) + } + }() + case 536870014: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .oneofBytes(v) + } + }() + case 536860000..<536870000: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionUnittest_TestHugeFieldNumbers.self, fieldNumber: fieldNumber) }() + 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 + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 536860000, end: 536870000) + try { if let v = self._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870000) + } }() + try { if let v = self._fixed32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870001) + } }() + if !self.repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 536870002) + } + if !self.packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: self.packedInt32, fieldNumber: 536870003) + } + try { if let v = self._optionalEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 536870004) + } }() + try { if let v = self._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 536870005) + } }() + try { if let v = self._optionalBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 536870006) + } }() + try { if let v = self._optionalMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 536870007) + } }() + try { if let v = self._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 536870008) + } }() + if !self.stringStringMap.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.stringStringMap, fieldNumber: 536870010) + } + switch self.oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 536870011) + }() + case .oneofTestAllTypes?: try { + guard case .oneofTestAllTypes(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 536870012) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 536870013) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 536870014) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestHugeFieldNumbers, rhs: EditionUnittest_TestHugeFieldNumbers) -> Bool { + if lhs._optionalInt32 != rhs._optionalInt32 {return false} + if lhs._fixed32 != rhs._fixed32 {return false} + if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} + if lhs.packedInt32 != rhs.packedInt32 {return false} + if lhs._optionalEnum != rhs._optionalEnum {return false} + if lhs._optionalString != rhs._optionalString {return false} + if lhs._optionalBytes != rhs._optionalBytes {return false} + if lhs._optionalMessage != rhs._optionalMessage {return false} + if lhs._optionalGroup != rhs._optionalGroup {return false} + if lhs.stringStringMap != rhs.stringStringMap {return false} + if lhs.oneofField != rhs.oneofField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionUnittest_TestHugeFieldNumbers.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestHugeFieldNumbers.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}yq\u{7f}\u{7f}\u{1f}group_a\0") + + 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 536870009: try { try decoder.decodeSingularInt32Field(value: &self._groupA) }() + 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 + try { if let v = self._groupA { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870009) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestHugeFieldNumbers.OptionalGroup, rhs: EditionUnittest_TestHugeFieldNumbers.OptionalGroup) -> Bool { + if lhs._groupA != rhs._groupA {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestExtensionInsideTable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestExtensionInsideTable" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field1\0\u{1}field2\0\u{1}field3\0\u{1}field4\0\u{2}\u{2}field6\0\u{1}field7\0\u{1}field8\0\u{1}field9\0\u{1}field10\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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._field1) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._field2) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._field3) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &self._field4) }() + case 6: try { try decoder.decodeSingularInt32Field(value: &self._field6) }() + case 7: try { try decoder.decodeSingularInt32Field(value: &self._field7) }() + case 8: try { try decoder.decodeSingularInt32Field(value: &self._field8) }() + case 9: try { try decoder.decodeSingularInt32Field(value: &self._field9) }() + case 10: try { try decoder.decodeSingularInt32Field(value: &self._field10) }() + case 5: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionUnittest_TestExtensionInsideTable.self, fieldNumber: fieldNumber) }() + 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 + 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 { if let v = self._field3 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._field4 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 5, end: 6) + try { if let v = self._field6 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) + } }() + try { if let v = self._field7 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) + } }() + try { if let v = self._field8 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 8) + } }() + try { if let v = self._field9 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try { if let v = self._field10 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 10) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestExtensionInsideTable, rhs: EditionUnittest_TestExtensionInsideTable) -> Bool { + if lhs._field1 != rhs._field1 {return false} + if lhs._field2 != rhs._field2 {return false} + if lhs._field3 != rhs._field3 {return false} + if lhs._field4 != rhs._field4 {return false} + if lhs._field6 != rhs._field6 {return false} + if lhs._field7 != rhs._field7 {return false} + if lhs._field8 != rhs._field8 {return false} + if lhs._field9 != rhs._field9 {return false} + if lhs._field10 != rhs._field10 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionUnittest_TestNestedGroupExtensionOuter: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedGroupExtensionOuter" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}lay1optionalgroup\0") + + public var isInitialized: Bool { + if let v = self._lay1Optionalgroup, !v.isInitialized {return false} + return true + } + + 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.decodeSingularGroupField(value: &self._lay1Optionalgroup) }() + 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 + try { if let v = self._lay1Optionalgroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestNestedGroupExtensionOuter, rhs: EditionUnittest_TestNestedGroupExtensionOuter) -> Bool { + if lhs._lay1Optionalgroup != rhs._lay1Optionalgroup {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestNestedGroupExtensionOuter.protoMessageName + ".Layer1OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{8}\u{2}Layer2RepeatedGroup\0\u{8}\u{2}Layer2AnotherOptionalRepeatedGroup\0") + + public var isInitialized: Bool { + if !SwiftProtobuf.Internal.areAllInitialized(self.layer2RepeatedGroup) {return false} + return true + } + + 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 2: try { try decoder.decodeRepeatedGroupField(value: &self.layer2RepeatedGroup) }() + case 4: try { try decoder.decodeRepeatedGroupField(value: &self.layer2AnotherOptionalRepeatedGroup) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.layer2RepeatedGroup.isEmpty { + try visitor.visitRepeatedGroupField(value: self.layer2RepeatedGroup, fieldNumber: 2) + } + if !self.layer2AnotherOptionalRepeatedGroup.isEmpty { + try visitor.visitRepeatedGroupField(value: self.layer2AnotherOptionalRepeatedGroup, fieldNumber: 4) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup, rhs: EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup) -> Bool { + if lhs.layer2RepeatedGroup != rhs.layer2RepeatedGroup {return false} + if lhs.layer2AnotherOptionalRepeatedGroup != rhs.layer2AnotherOptionalRepeatedGroup {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.protoMessageName + ".Layer2RepeatedGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{6}another_field\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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 6: try { try decoder.decodeSingularStringField(value: &self._anotherField) }() + case 3: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2RepeatedGroup.self, fieldNumber: fieldNumber) }() + 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 + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 3, end: 4) + try { if let v = self._anotherField { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2RepeatedGroup, rhs: EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2RepeatedGroup) -> Bool { + if lhs._anotherField != rhs._anotherField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2AnotherOptionalRepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.protoMessageName + ".Layer2AnotherOptionalRepeatedGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{5}but_why_tho\0") + + 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 5: try { try decoder.decodeSingularStringField(value: &self._butWhyTho) }() + 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 + try { if let v = self._butWhyTho { + try visitor.visitSingularStringField(value: v, fieldNumber: 5) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2AnotherOptionalRepeatedGroup, rhs: EditionUnittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2AnotherOptionalRepeatedGroup) -> Bool { + if lhs._butWhyTho != rhs._butWhyTho {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestNestedGroupExtensionInnerExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedGroupExtensionInnerExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}inner_name\0") + + 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._innerName) }() + 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 + try { if let v = self._innerName { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestNestedGroupExtensionInnerExtension, rhs: EditionUnittest_TestNestedGroupExtensionInnerExtension) -> Bool { + if lhs._innerName != rhs._innerName {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestExtensionRangeSerialize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestExtensionRangeSerialize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}foo_one\0\u{4}\u{5}foo_two\0\u{3}foo_three\0\u{4}\u{6}foo_four\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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._fooOne) }() + case 6: try { try decoder.decodeSingularInt32Field(value: &self._fooTwo) }() + case 7: try { try decoder.decodeSingularInt32Field(value: &self._fooThree) }() + case 13: try { try decoder.decodeSingularInt32Field(value: &self._fooFour) }() + case 2..<5, 9..<11, 15, 17, 19: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionUnittest_TestExtensionRangeSerialize.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._fooOne { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2, end: 5) + try { if let v = self._fooTwo { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) + } }() + try { if let v = self._fooThree { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 9, end: 11) + try { if let v = self._fooFour { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 13) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 15, end: 20) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestExtensionRangeSerialize, rhs: EditionUnittest_TestExtensionRangeSerialize) -> Bool { + if lhs._fooOne != rhs._fooOne {return false} + if lhs._fooTwo != rhs._fooTwo {return false} + if lhs._fooThree != rhs._fooThree {return false} + if lhs._fooFour != rhs._fooFour {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionUnittest_TestVerifyInt32Simple: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyInt32Simple" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32_1\0\u{3}optional_int32_2\0\u{4}=optional_int32_63\0\u{3}optional_int32_64\0") + + 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._optionalInt321) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt322) }() + case 63: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3263) }() + case 64: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3264) }() + 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 + try { if let v = self._optionalInt321 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalInt322 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalInt3263 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalInt3264 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 64) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestVerifyInt32Simple, rhs: EditionUnittest_TestVerifyInt32Simple) -> Bool { + if lhs._optionalInt321 != rhs._optionalInt321 {return false} + if lhs._optionalInt322 != rhs._optionalInt322 {return false} + if lhs._optionalInt3263 != rhs._optionalInt3263 {return false} + if lhs._optionalInt3264 != rhs._optionalInt3264 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestVerifyInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyInt32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32_1\0\u{3}optional_int32_2\0\u{4}\u{7}optional_all_types\0\u{3}repeated_all_types\0\u{4}5optional_int32_63\0\u{3}optional_int32_64\0") + + 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._optionalInt321) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt322) }() + case 9: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 63: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3263) }() + case 64: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3264) }() + 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 + try { if let v = self._optionalInt321 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalInt322 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 10) + } + try { if let v = self._optionalInt3263 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalInt3264 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 64) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestVerifyInt32, rhs: EditionUnittest_TestVerifyInt32) -> Bool { + if lhs._optionalInt321 != rhs._optionalInt321 {return false} + if lhs._optionalInt322 != rhs._optionalInt322 {return false} + if lhs._optionalInt3263 != rhs._optionalInt3263 {return false} + if lhs._optionalInt3264 != rhs._optionalInt3264 {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestVerifyMostlyInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyMostlyInt32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32_1\0\u{3}optional_int32_2\0\u{3}optional_int32_3\0\u{3}optional_int32_4\0\u{4}\u{5}optional_all_types\0\u{3}repeated_all_types\0\u{4}\u{14}optional_int64_30\0\u{4}!optional_int32_63\0\u{3}optional_int32_64\0") + + 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._optionalInt321) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt322) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt323) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt324) }() + case 9: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 30: try { try decoder.decodeSingularInt64Field(value: &self._optionalInt6430) }() + case 63: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3263) }() + case 64: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3264) }() + 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 + try { if let v = self._optionalInt321 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalInt322 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalInt323 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._optionalInt324 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 10) + } + try { if let v = self._optionalInt6430 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 30) + } }() + try { if let v = self._optionalInt3263 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalInt3264 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 64) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestVerifyMostlyInt32, rhs: EditionUnittest_TestVerifyMostlyInt32) -> Bool { + if lhs._optionalInt6430 != rhs._optionalInt6430 {return false} + if lhs._optionalInt321 != rhs._optionalInt321 {return false} + if lhs._optionalInt322 != rhs._optionalInt322 {return false} + if lhs._optionalInt323 != rhs._optionalInt323 {return false} + if lhs._optionalInt324 != rhs._optionalInt324 {return false} + if lhs._optionalInt3263 != rhs._optionalInt3263 {return false} + if lhs._optionalInt3264 != rhs._optionalInt3264 {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestVerifyMostlyInt32BigFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyMostlyInt32BigFieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32_1\0\u{3}optional_int32_2\0\u{3}optional_int32_3\0\u{3}optional_int32_4\0\u{4}\u{5}optional_all_types\0\u{3}repeated_all_types\0\u{4}\u{14}optional_int64_30\0\u{4}!optional_int32_63\0\u{3}optional_int32_64\0\u{4}l\u{3}optional_int32_300\0") + + 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._optionalInt321) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt322) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt323) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt324) }() + case 9: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 30: try { try decoder.decodeSingularInt64Field(value: &self._optionalInt6430) }() + case 63: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3263) }() + case 64: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3264) }() + case 300: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32300) }() + 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 + try { if let v = self._optionalInt321 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalInt322 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalInt323 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._optionalInt324 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 10) + } + try { if let v = self._optionalInt6430 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 30) + } }() + try { if let v = self._optionalInt3263 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalInt3264 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 64) + } }() + try { if let v = self._optionalInt32300 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 300) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestVerifyMostlyInt32BigFieldNumber, rhs: EditionUnittest_TestVerifyMostlyInt32BigFieldNumber) -> Bool { + if lhs._optionalInt6430 != rhs._optionalInt6430 {return false} + if lhs._optionalInt32300 != rhs._optionalInt32300 {return false} + if lhs._optionalInt321 != rhs._optionalInt321 {return false} + if lhs._optionalInt322 != rhs._optionalInt322 {return false} + if lhs._optionalInt323 != rhs._optionalInt323 {return false} + if lhs._optionalInt324 != rhs._optionalInt324 {return false} + if lhs._optionalInt3263 != rhs._optionalInt3263 {return false} + if lhs._optionalInt3264 != rhs._optionalInt3264 {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestVerifyUint32Simple: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyUint32Simple" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_uint32_1\0\u{3}optional_uint32_2\0\u{4}=optional_uint32_63\0\u{3}optional_uint32_64\0") + + 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._optionalUint321) }() + case 2: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint322) }() + case 63: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint3263) }() + case 64: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint3264) }() + 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 + try { if let v = self._optionalUint321 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalUint322 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalUint3263 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalUint3264 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 64) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestVerifyUint32Simple, rhs: EditionUnittest_TestVerifyUint32Simple) -> Bool { + if lhs._optionalUint321 != rhs._optionalUint321 {return false} + if lhs._optionalUint322 != rhs._optionalUint322 {return false} + if lhs._optionalUint3263 != rhs._optionalUint3263 {return false} + if lhs._optionalUint3264 != rhs._optionalUint3264 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestVerifyUint32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyUint32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_uint32_1\0\u{3}optional_uint32_2\0\u{4}\u{7}optional_all_types\0\u{3}repeated_all_types\0\u{4}5optional_uint32_63\0\u{3}optional_uint32_64\0") + + 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._optionalUint321) }() + case 2: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint322) }() + case 9: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 63: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint3263) }() + case 64: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint3264) }() + 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 + try { if let v = self._optionalUint321 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalUint322 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 10) + } + try { if let v = self._optionalUint3263 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalUint3264 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 64) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestVerifyUint32, rhs: EditionUnittest_TestVerifyUint32) -> Bool { + if lhs._optionalUint321 != rhs._optionalUint321 {return false} + if lhs._optionalUint322 != rhs._optionalUint322 {return false} + if lhs._optionalUint3263 != rhs._optionalUint3263 {return false} + if lhs._optionalUint3264 != rhs._optionalUint3264 {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestVerifyOneUint32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyOneUint32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_uint32_1\0\u{3}optional_int32_2\0\u{4}\u{7}optional_all_types\0\u{3}repeated_all_types\0\u{4}5optional_int32_63\0\u{3}optional_int32_64\0") + + 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._optionalUint321) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt322) }() + case 9: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 63: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3263) }() + case 64: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3264) }() + 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 + try { if let v = self._optionalUint321 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalInt322 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 10) + } + try { if let v = self._optionalInt3263 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalInt3264 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 64) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestVerifyOneUint32, rhs: EditionUnittest_TestVerifyOneUint32) -> Bool { + if lhs._optionalUint321 != rhs._optionalUint321 {return false} + if lhs._optionalInt322 != rhs._optionalInt322 {return false} + if lhs._optionalInt3263 != rhs._optionalInt3263 {return false} + if lhs._optionalInt3264 != rhs._optionalInt3264 {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestVerifyOneInt32BigFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyOneInt32BigFieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int64_1\0\u{3}optional_int64_2\0\u{4}\u{7}optional_all_types\0\u{3}repeated_all_types\0\u{4}5optional_int64_63\0\u{3}optional_int64_64\0\u{3}optional_int32_65\0") + + 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.decodeSingularInt64Field(value: &self._optionalInt641) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &self._optionalInt642) }() + case 9: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 63: try { try decoder.decodeSingularInt64Field(value: &self._optionalInt6463) }() + case 64: try { try decoder.decodeSingularInt64Field(value: &self._optionalInt6464) }() + case 65: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3265) }() + 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 + try { if let v = self._optionalInt641 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalInt642 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 10) + } + try { if let v = self._optionalInt6463 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalInt6464 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 64) + } }() + try { if let v = self._optionalInt3265 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 65) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestVerifyOneInt32BigFieldNumber, rhs: EditionUnittest_TestVerifyOneInt32BigFieldNumber) -> Bool { + if lhs._optionalInt3265 != rhs._optionalInt3265 {return false} + if lhs._optionalInt641 != rhs._optionalInt641 {return false} + if lhs._optionalInt642 != rhs._optionalInt642 {return false} + if lhs._optionalInt6463 != rhs._optionalInt6463 {return false} + if lhs._optionalInt6464 != rhs._optionalInt6464 {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestVerifyInt32BigFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyInt32BigFieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32_1\0\u{3}optional_int32_2\0\u{4}\u{7}optional_all_types\0\u{3}repeated_all_types\0\u{4}5optional_int32_63\0\u{3}optional_int32_64\0\u{3}optional_int32_65\0\u{4}g\u{e}optional_int32_1000\0") + + 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._optionalInt321) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt322) }() + case 9: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 63: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3263) }() + case 64: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3264) }() + case 65: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3265) }() + case 1000: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt321000) }() + 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 + try { if let v = self._optionalInt321 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalInt322 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 10) + } + try { if let v = self._optionalInt3263 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalInt3264 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 64) + } }() + try { if let v = self._optionalInt3265 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 65) + } }() + try { if let v = self._optionalInt321000 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1000) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestVerifyInt32BigFieldNumber, rhs: EditionUnittest_TestVerifyInt32BigFieldNumber) -> Bool { + if lhs._optionalInt321000 != rhs._optionalInt321000 {return false} + if lhs._optionalInt3265 != rhs._optionalInt3265 {return false} + if lhs._optionalInt321 != rhs._optionalInt321 {return false} + if lhs._optionalInt322 != rhs._optionalInt322 {return false} + if lhs._optionalInt3263 != rhs._optionalInt3263 {return false} + if lhs._optionalInt3264 != rhs._optionalInt3264 {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestVerifyUint32BigFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyUint32BigFieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_uint32_1\0\u{3}optional_uint32_2\0\u{4}\u{7}optional_all_types\0\u{3}repeated_all_types\0\u{4}5optional_uint32_63\0\u{3}optional_uint32_64\0\u{3}optional_uint32_65\0\u{4}g\u{e}optional_uint32_1000\0") + + 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._optionalUint321) }() + case 2: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint322) }() + case 9: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 63: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint3263) }() + case 64: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint3264) }() + case 65: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint3265) }() + case 1000: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint321000) }() + 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 + try { if let v = self._optionalUint321 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalUint322 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 10) + } + try { if let v = self._optionalUint3263 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalUint3264 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 64) + } }() + try { if let v = self._optionalUint3265 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 65) + } }() + try { if let v = self._optionalUint321000 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1000) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestVerifyUint32BigFieldNumber, rhs: EditionUnittest_TestVerifyUint32BigFieldNumber) -> Bool { + if lhs._optionalUint321000 != rhs._optionalUint321000 {return false} + if lhs._optionalUint3265 != rhs._optionalUint3265 {return false} + if lhs._optionalUint321 != rhs._optionalUint321 {return false} + if lhs._optionalUint322 != rhs._optionalUint322 {return false} + if lhs._optionalUint3263 != rhs._optionalUint3263 {return false} + if lhs._optionalUint3264 != rhs._optionalUint3264 {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestVerifyBigFieldNumberUint32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyBigFieldNumberUint32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_nested\0") + + 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.decodeSingularMessageField(value: &self._optionalNested) }() + 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 + try { if let v = self._optionalNested { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestVerifyBigFieldNumberUint32, rhs: EditionUnittest_TestVerifyBigFieldNumberUint32) -> Bool { + if lhs._optionalNested != rhs._optionalNested {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestVerifyBigFieldNumberUint32.Nested: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionUnittest_TestVerifyBigFieldNumberUint32.protoMessageName + ".Nested" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_uint32_1\0\u{3}optional_uint32_2\0\u{4}\u{7}optional_nested\0\u{3}repeated_nested\0\u{4}5optional_uint32_63\0\u{3}optional_uint32_64\0\u{3}optional_uint32_65\0\u{3}optional_uint32_66\0\u{4}f\u{e}optional_uint32_1000\0\u{4}`>optional_uint32_5000\0") + + fileprivate class _StorageClass { + var _optionalUint325000: UInt32? = nil + var _optionalUint321000: UInt32? = nil + var _optionalUint3266: UInt32? = nil + var _optionalUint3265: UInt32? = nil + var _optionalUint321: UInt32? = nil + var _optionalUint322: UInt32? = nil + var _optionalUint3263: UInt32? = nil + var _optionalUint3264: UInt32? = nil + var _optionalNested: EditionUnittest_TestVerifyBigFieldNumberUint32.Nested? = nil + var _repeatedNested: [EditionUnittest_TestVerifyBigFieldNumberUint32.Nested] = [] + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalUint325000 = source._optionalUint325000 + _optionalUint321000 = source._optionalUint321000 + _optionalUint3266 = source._optionalUint3266 + _optionalUint3265 = source._optionalUint3265 + _optionalUint321 = source._optionalUint321 + _optionalUint322 = source._optionalUint322 + _optionalUint3263 = source._optionalUint3263 + _optionalUint3264 = source._optionalUint3264 + _optionalNested = source._optionalNested + _repeatedNested = source._repeatedNested + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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.decodeSingularUInt32Field(value: &_storage._optionalUint321) }() + case 2: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint322) }() + case 9: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNested) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNested) }() + case 63: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint3263) }() + case 64: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint3264) }() + case 65: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint3265) }() + case 66: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint3266) }() + case 1000: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint321000) }() + case 5000: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint325000) }() + default: break + } + } + } + } + + func traverse(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._optionalUint321 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._optionalUint322 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalNested { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !_storage._repeatedNested.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNested, fieldNumber: 10) + } + try { if let v = _storage._optionalUint3263 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = _storage._optionalUint3264 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 64) + } }() + try { if let v = _storage._optionalUint3265 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 65) + } }() + try { if let v = _storage._optionalUint3266 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 66) + } }() + try { if let v = _storage._optionalUint321000 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1000) + } }() + try { if let v = _storage._optionalUint325000 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 5000) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestVerifyBigFieldNumberUint32.Nested, rhs: EditionUnittest_TestVerifyBigFieldNumberUint32.Nested) -> 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._optionalUint325000 != rhs_storage._optionalUint325000 {return false} + if _storage._optionalUint321000 != rhs_storage._optionalUint321000 {return false} + if _storage._optionalUint3266 != rhs_storage._optionalUint3266 {return false} + if _storage._optionalUint3265 != rhs_storage._optionalUint3265 {return false} + if _storage._optionalUint321 != rhs_storage._optionalUint321 {return false} + if _storage._optionalUint322 != rhs_storage._optionalUint322 {return false} + if _storage._optionalUint3263 != rhs_storage._optionalUint3263 {return false} + if _storage._optionalUint3264 != rhs_storage._optionalUint3264 {return false} + if _storage._optionalNested != rhs_storage._optionalNested {return false} + if _storage._repeatedNested != rhs_storage._repeatedNested {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_EnumParseTester: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumParseTester" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_seq_small_0_lowfield\0\u{3}repeated_seq_small_0_lowfield\0\u{3}packed_seq_small_0_lowfield\0\u{3}optional_seq_small_1_lowfield\0\u{3}repeated_seq_small_1_lowfield\0\u{3}packed_seq_small_1_lowfield\0\u{3}optional_seq_large_lowfield\0\u{3}repeated_seq_large_lowfield\0\u{3}packed_seq_large_lowfield\0\u{3}optional_arbitrary_lowfield\0\u{3}repeated_arbitrary_lowfield\0\u{3}packed_arbitrary_lowfield\0\u{4}W\u{1}other_field\0\u{4}F\u{e}optional_seq_small_0_midfield\0\u{3}repeated_seq_small_0_midfield\0\u{3}packed_seq_small_0_midfield\0\u{3}optional_seq_small_1_midfield\0\u{3}repeated_seq_small_1_midfield\0\u{3}packed_seq_small_1_midfield\0\u{3}optional_seq_large_midfield\0\u{3}repeated_seq_large_midfield\0\u{3}packed_seq_large_midfield\0\u{3}optional_arbitrary_midfield\0\u{3}repeated_arbitrary_midfield\0\u{3}packed_arbitrary_midfield\0\u{4}Mys\u{3}optional_seq_small_0_hifield\0\u{3}repeated_seq_small_0_hifield\0\u{3}packed_seq_small_0_hifield\0\u{3}optional_seq_small_1_hifield\0\u{3}repeated_seq_small_1_hifield\0\u{3}packed_seq_small_1_hifield\0\u{3}optional_seq_large_hifield\0\u{3}repeated_seq_large_hifield\0\u{3}packed_seq_large_hifield\0\u{3}optional_arbitrary_hifield\0\u{3}repeated_arbitrary_hifield\0\u{3}packed_arbitrary_hifield\0") + + fileprivate class _StorageClass { + var _optionalSeqSmall0Lowfield: EditionUnittest_EnumParseTester.SeqSmall0? = nil + var _optionalSeqSmall0Midfield: EditionUnittest_EnumParseTester.SeqSmall0? = nil + var _optionalSeqSmall0Hifield: EditionUnittest_EnumParseTester.SeqSmall0? = nil + var _repeatedSeqSmall0Lowfield: [EditionUnittest_EnumParseTester.SeqSmall0] = [] + var _repeatedSeqSmall0Midfield: [EditionUnittest_EnumParseTester.SeqSmall0] = [] + var _repeatedSeqSmall0Hifield: [EditionUnittest_EnumParseTester.SeqSmall0] = [] + var _packedSeqSmall0Lowfield: [EditionUnittest_EnumParseTester.SeqSmall0] = [] + var _packedSeqSmall0Midfield: [EditionUnittest_EnumParseTester.SeqSmall0] = [] + var _packedSeqSmall0Hifield: [EditionUnittest_EnumParseTester.SeqSmall0] = [] + var _optionalSeqSmall1Lowfield: EditionUnittest_EnumParseTester.SeqSmall1? = nil + var _optionalSeqSmall1Midfield: EditionUnittest_EnumParseTester.SeqSmall1? = nil + var _optionalSeqSmall1Hifield: EditionUnittest_EnumParseTester.SeqSmall1? = nil + var _repeatedSeqSmall1Lowfield: [EditionUnittest_EnumParseTester.SeqSmall1] = [] + var _repeatedSeqSmall1Midfield: [EditionUnittest_EnumParseTester.SeqSmall1] = [] + var _repeatedSeqSmall1Hifield: [EditionUnittest_EnumParseTester.SeqSmall1] = [] + var _packedSeqSmall1Lowfield: [EditionUnittest_EnumParseTester.SeqSmall1] = [] + var _packedSeqSmall1Midfield: [EditionUnittest_EnumParseTester.SeqSmall1] = [] + var _packedSeqSmall1Hifield: [EditionUnittest_EnumParseTester.SeqSmall1] = [] + var _optionalSeqLargeLowfield: EditionUnittest_EnumParseTester.SeqLarge? = nil + var _optionalSeqLargeMidfield: EditionUnittest_EnumParseTester.SeqLarge? = nil + var _optionalSeqLargeHifield: EditionUnittest_EnumParseTester.SeqLarge? = nil + var _repeatedSeqLargeLowfield: [EditionUnittest_EnumParseTester.SeqLarge] = [] + var _repeatedSeqLargeMidfield: [EditionUnittest_EnumParseTester.SeqLarge] = [] + var _repeatedSeqLargeHifield: [EditionUnittest_EnumParseTester.SeqLarge] = [] + var _packedSeqLargeLowfield: [EditionUnittest_EnumParseTester.SeqLarge] = [] + var _packedSeqLargeMidfield: [EditionUnittest_EnumParseTester.SeqLarge] = [] + var _packedSeqLargeHifield: [EditionUnittest_EnumParseTester.SeqLarge] = [] + var _optionalArbitraryLowfield: EditionUnittest_EnumParseTester.Arbitrary? = nil + var _optionalArbitraryMidfield: EditionUnittest_EnumParseTester.Arbitrary? = nil + var _optionalArbitraryHifield: EditionUnittest_EnumParseTester.Arbitrary? = nil + var _repeatedArbitraryLowfield: [EditionUnittest_EnumParseTester.Arbitrary] = [] + var _repeatedArbitraryMidfield: [EditionUnittest_EnumParseTester.Arbitrary] = [] + var _repeatedArbitraryHifield: [EditionUnittest_EnumParseTester.Arbitrary] = [] + var _packedArbitraryLowfield: [EditionUnittest_EnumParseTester.Arbitrary] = [] + var _packedArbitraryMidfield: [EditionUnittest_EnumParseTester.Arbitrary] = [] + var _packedArbitraryHifield: [EditionUnittest_EnumParseTester.Arbitrary] = [] + var _otherField: Int32? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalSeqSmall0Lowfield = source._optionalSeqSmall0Lowfield + _optionalSeqSmall0Midfield = source._optionalSeqSmall0Midfield + _optionalSeqSmall0Hifield = source._optionalSeqSmall0Hifield + _repeatedSeqSmall0Lowfield = source._repeatedSeqSmall0Lowfield + _repeatedSeqSmall0Midfield = source._repeatedSeqSmall0Midfield + _repeatedSeqSmall0Hifield = source._repeatedSeqSmall0Hifield + _packedSeqSmall0Lowfield = source._packedSeqSmall0Lowfield + _packedSeqSmall0Midfield = source._packedSeqSmall0Midfield + _packedSeqSmall0Hifield = source._packedSeqSmall0Hifield + _optionalSeqSmall1Lowfield = source._optionalSeqSmall1Lowfield + _optionalSeqSmall1Midfield = source._optionalSeqSmall1Midfield + _optionalSeqSmall1Hifield = source._optionalSeqSmall1Hifield + _repeatedSeqSmall1Lowfield = source._repeatedSeqSmall1Lowfield + _repeatedSeqSmall1Midfield = source._repeatedSeqSmall1Midfield + _repeatedSeqSmall1Hifield = source._repeatedSeqSmall1Hifield + _packedSeqSmall1Lowfield = source._packedSeqSmall1Lowfield + _packedSeqSmall1Midfield = source._packedSeqSmall1Midfield + _packedSeqSmall1Hifield = source._packedSeqSmall1Hifield + _optionalSeqLargeLowfield = source._optionalSeqLargeLowfield + _optionalSeqLargeMidfield = source._optionalSeqLargeMidfield + _optionalSeqLargeHifield = source._optionalSeqLargeHifield + _repeatedSeqLargeLowfield = source._repeatedSeqLargeLowfield + _repeatedSeqLargeMidfield = source._repeatedSeqLargeMidfield + _repeatedSeqLargeHifield = source._repeatedSeqLargeHifield + _packedSeqLargeLowfield = source._packedSeqLargeLowfield + _packedSeqLargeMidfield = source._packedSeqLargeMidfield + _packedSeqLargeHifield = source._packedSeqLargeHifield + _optionalArbitraryLowfield = source._optionalArbitraryLowfield + _optionalArbitraryMidfield = source._optionalArbitraryMidfield + _optionalArbitraryHifield = source._optionalArbitraryHifield + _repeatedArbitraryLowfield = source._repeatedArbitraryLowfield + _repeatedArbitraryMidfield = source._repeatedArbitraryMidfield + _repeatedArbitraryHifield = source._repeatedArbitraryHifield + _packedArbitraryLowfield = source._packedArbitraryLowfield + _packedArbitraryMidfield = source._packedArbitraryMidfield + _packedArbitraryHifield = source._packedArbitraryHifield + _otherField = source._otherField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(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.decodeSingularEnumField(value: &_storage._optionalSeqSmall0Lowfield) }() + case 2: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedSeqSmall0Lowfield) }() + case 3: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedSeqSmall0Lowfield) }() + case 4: try { try decoder.decodeSingularEnumField(value: &_storage._optionalSeqSmall1Lowfield) }() + case 5: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedSeqSmall1Lowfield) }() + case 6: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedSeqSmall1Lowfield) }() + case 7: try { try decoder.decodeSingularEnumField(value: &_storage._optionalSeqLargeLowfield) }() + case 8: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedSeqLargeLowfield) }() + case 9: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedSeqLargeLowfield) }() + case 10: try { try decoder.decodeSingularEnumField(value: &_storage._optionalArbitraryLowfield) }() + case 11: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedArbitraryLowfield) }() + case 12: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedArbitraryLowfield) }() + case 99: try { try decoder.decodeSingularInt32Field(value: &_storage._otherField) }() + case 1001: try { try decoder.decodeSingularEnumField(value: &_storage._optionalSeqSmall0Midfield) }() + case 1002: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedSeqSmall0Midfield) }() + case 1003: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedSeqSmall0Midfield) }() + case 1004: try { try decoder.decodeSingularEnumField(value: &_storage._optionalSeqSmall1Midfield) }() + case 1005: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedSeqSmall1Midfield) }() + case 1006: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedSeqSmall1Midfield) }() + case 1007: try { try decoder.decodeSingularEnumField(value: &_storage._optionalSeqLargeMidfield) }() + case 1008: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedSeqLargeMidfield) }() + case 1009: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedSeqLargeMidfield) }() + case 1010: try { try decoder.decodeSingularEnumField(value: &_storage._optionalArbitraryMidfield) }() + case 1011: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedArbitraryMidfield) }() + case 1012: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedArbitraryMidfield) }() + case 1000001: try { try decoder.decodeSingularEnumField(value: &_storage._optionalSeqSmall0Hifield) }() + case 1000002: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedSeqSmall0Hifield) }() + case 1000003: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedSeqSmall0Hifield) }() + case 1000004: try { try decoder.decodeSingularEnumField(value: &_storage._optionalSeqSmall1Hifield) }() + case 1000005: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedSeqSmall1Hifield) }() + case 1000006: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedSeqSmall1Hifield) }() + case 1000007: try { try decoder.decodeSingularEnumField(value: &_storage._optionalSeqLargeHifield) }() + case 1000008: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedSeqLargeHifield) }() + case 1000009: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedSeqLargeHifield) }() + case 1000010: try { try decoder.decodeSingularEnumField(value: &_storage._optionalArbitraryHifield) }() + case 1000011: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedArbitraryHifield) }() + case 1000012: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedArbitraryHifield) }() + case 2000000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionUnittest_EnumParseTester.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._optionalSeqSmall0Lowfield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + if !_storage._repeatedSeqSmall0Lowfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedSeqSmall0Lowfield, fieldNumber: 2) + } + if !_storage._packedSeqSmall0Lowfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedSeqSmall0Lowfield, fieldNumber: 3) + } + try { if let v = _storage._optionalSeqSmall1Lowfield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + if !_storage._repeatedSeqSmall1Lowfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedSeqSmall1Lowfield, fieldNumber: 5) + } + if !_storage._packedSeqSmall1Lowfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedSeqSmall1Lowfield, fieldNumber: 6) + } + try { if let v = _storage._optionalSeqLargeLowfield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 7) + } }() + if !_storage._repeatedSeqLargeLowfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedSeqLargeLowfield, fieldNumber: 8) + } + if !_storage._packedSeqLargeLowfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedSeqLargeLowfield, fieldNumber: 9) + } + try { if let v = _storage._optionalArbitraryLowfield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 10) + } }() + if !_storage._repeatedArbitraryLowfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedArbitraryLowfield, fieldNumber: 11) + } + if !_storage._packedArbitraryLowfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedArbitraryLowfield, fieldNumber: 12) + } + try { if let v = _storage._otherField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 99) + } }() + try { if let v = _storage._optionalSeqSmall0Midfield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1001) + } }() + if !_storage._repeatedSeqSmall0Midfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedSeqSmall0Midfield, fieldNumber: 1002) + } + if !_storage._packedSeqSmall0Midfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedSeqSmall0Midfield, fieldNumber: 1003) + } + try { if let v = _storage._optionalSeqSmall1Midfield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1004) + } }() + if !_storage._repeatedSeqSmall1Midfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedSeqSmall1Midfield, fieldNumber: 1005) + } + if !_storage._packedSeqSmall1Midfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedSeqSmall1Midfield, fieldNumber: 1006) + } + try { if let v = _storage._optionalSeqLargeMidfield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1007) + } }() + if !_storage._repeatedSeqLargeMidfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedSeqLargeMidfield, fieldNumber: 1008) + } + if !_storage._packedSeqLargeMidfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedSeqLargeMidfield, fieldNumber: 1009) + } + try { if let v = _storage._optionalArbitraryMidfield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1010) + } }() + if !_storage._repeatedArbitraryMidfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedArbitraryMidfield, fieldNumber: 1011) + } + if !_storage._packedArbitraryMidfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedArbitraryMidfield, fieldNumber: 1012) + } + try { if let v = _storage._optionalSeqSmall0Hifield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1000001) + } }() + if !_storage._repeatedSeqSmall0Hifield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedSeqSmall0Hifield, fieldNumber: 1000002) + } + if !_storage._packedSeqSmall0Hifield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedSeqSmall0Hifield, fieldNumber: 1000003) + } + try { if let v = _storage._optionalSeqSmall1Hifield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1000004) + } }() + if !_storage._repeatedSeqSmall1Hifield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedSeqSmall1Hifield, fieldNumber: 1000005) + } + if !_storage._packedSeqSmall1Hifield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedSeqSmall1Hifield, fieldNumber: 1000006) + } + try { if let v = _storage._optionalSeqLargeHifield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1000007) + } }() + if !_storage._repeatedSeqLargeHifield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedSeqLargeHifield, fieldNumber: 1000008) + } + if !_storage._packedSeqLargeHifield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedSeqLargeHifield, fieldNumber: 1000009) + } + try { if let v = _storage._optionalArbitraryHifield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1000010) + } }() + if !_storage._repeatedArbitraryHifield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedArbitraryHifield, fieldNumber: 1000011) + } + if !_storage._packedArbitraryHifield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedArbitraryHifield, fieldNumber: 1000012) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2000000, end: 536870912) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_EnumParseTester, rhs: EditionUnittest_EnumParseTester) -> 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._optionalSeqSmall0Lowfield != rhs_storage._optionalSeqSmall0Lowfield {return false} + if _storage._optionalSeqSmall0Midfield != rhs_storage._optionalSeqSmall0Midfield {return false} + if _storage._optionalSeqSmall0Hifield != rhs_storage._optionalSeqSmall0Hifield {return false} + if _storage._repeatedSeqSmall0Lowfield != rhs_storage._repeatedSeqSmall0Lowfield {return false} + if _storage._repeatedSeqSmall0Midfield != rhs_storage._repeatedSeqSmall0Midfield {return false} + if _storage._repeatedSeqSmall0Hifield != rhs_storage._repeatedSeqSmall0Hifield {return false} + if _storage._packedSeqSmall0Lowfield != rhs_storage._packedSeqSmall0Lowfield {return false} + if _storage._packedSeqSmall0Midfield != rhs_storage._packedSeqSmall0Midfield {return false} + if _storage._packedSeqSmall0Hifield != rhs_storage._packedSeqSmall0Hifield {return false} + if _storage._optionalSeqSmall1Lowfield != rhs_storage._optionalSeqSmall1Lowfield {return false} + if _storage._optionalSeqSmall1Midfield != rhs_storage._optionalSeqSmall1Midfield {return false} + if _storage._optionalSeqSmall1Hifield != rhs_storage._optionalSeqSmall1Hifield {return false} + if _storage._repeatedSeqSmall1Lowfield != rhs_storage._repeatedSeqSmall1Lowfield {return false} + if _storage._repeatedSeqSmall1Midfield != rhs_storage._repeatedSeqSmall1Midfield {return false} + if _storage._repeatedSeqSmall1Hifield != rhs_storage._repeatedSeqSmall1Hifield {return false} + if _storage._packedSeqSmall1Lowfield != rhs_storage._packedSeqSmall1Lowfield {return false} + if _storage._packedSeqSmall1Midfield != rhs_storage._packedSeqSmall1Midfield {return false} + if _storage._packedSeqSmall1Hifield != rhs_storage._packedSeqSmall1Hifield {return false} + if _storage._optionalSeqLargeLowfield != rhs_storage._optionalSeqLargeLowfield {return false} + if _storage._optionalSeqLargeMidfield != rhs_storage._optionalSeqLargeMidfield {return false} + if _storage._optionalSeqLargeHifield != rhs_storage._optionalSeqLargeHifield {return false} + if _storage._repeatedSeqLargeLowfield != rhs_storage._repeatedSeqLargeLowfield {return false} + if _storage._repeatedSeqLargeMidfield != rhs_storage._repeatedSeqLargeMidfield {return false} + if _storage._repeatedSeqLargeHifield != rhs_storage._repeatedSeqLargeHifield {return false} + if _storage._packedSeqLargeLowfield != rhs_storage._packedSeqLargeLowfield {return false} + if _storage._packedSeqLargeMidfield != rhs_storage._packedSeqLargeMidfield {return false} + if _storage._packedSeqLargeHifield != rhs_storage._packedSeqLargeHifield {return false} + if _storage._optionalArbitraryLowfield != rhs_storage._optionalArbitraryLowfield {return false} + if _storage._optionalArbitraryMidfield != rhs_storage._optionalArbitraryMidfield {return false} + if _storage._optionalArbitraryHifield != rhs_storage._optionalArbitraryHifield {return false} + if _storage._repeatedArbitraryLowfield != rhs_storage._repeatedArbitraryLowfield {return false} + if _storage._repeatedArbitraryMidfield != rhs_storage._repeatedArbitraryMidfield {return false} + if _storage._repeatedArbitraryHifield != rhs_storage._repeatedArbitraryHifield {return false} + if _storage._packedArbitraryLowfield != rhs_storage._packedArbitraryLowfield {return false} + if _storage._packedArbitraryMidfield != rhs_storage._packedArbitraryMidfield {return false} + if _storage._packedArbitraryHifield != rhs_storage._packedArbitraryHifield {return false} + if _storage._otherField != rhs_storage._otherField {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionUnittest_EnumParseTester.SeqSmall0: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0SEQ_SMALL_0_DEFAULT\0\u{1}SEQ_SMALL_0_1\0\u{1}SEQ_SMALL_0_2\0") +} + +extension EditionUnittest_EnumParseTester.SeqSmall1: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNKNOWN\0\u{1}SEQ_SMALL_1_DEFAULT\0\u{1}SEQ_SMALL_1_2\0\u{1}SEQ_SMALL_1_3\0") +} + +extension EditionUnittest_EnumParseTester.SeqLarge: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}SEQ_LARGE_DEFAULT\0\u{1}SEQ_LARGE_0\0\u{1}SEQ_LARGE_1\0\u{1}SEQ_LARGE_2\0\u{1}SEQ_LARGE_3\0\u{1}SEQ_LARGE_4\0\u{1}SEQ_LARGE_5\0\u{1}SEQ_LARGE_6\0\u{1}SEQ_LARGE_7\0\u{1}SEQ_LARGE_8\0\u{1}SEQ_LARGE_9\0\u{1}SEQ_LARGE_10\0\u{1}SEQ_LARGE_11\0\u{1}SEQ_LARGE_12\0\u{1}SEQ_LARGE_13\0\u{1}SEQ_LARGE_14\0\u{1}SEQ_LARGE_15\0\u{1}SEQ_LARGE_16\0\u{1}SEQ_LARGE_17\0\u{1}SEQ_LARGE_18\0\u{1}SEQ_LARGE_19\0\u{1}SEQ_LARGE_20\0\u{1}SEQ_LARGE_21\0\u{1}SEQ_LARGE_22\0\u{1}SEQ_LARGE_23\0\u{1}SEQ_LARGE_24\0\u{1}SEQ_LARGE_25\0\u{1}SEQ_LARGE_26\0\u{1}SEQ_LARGE_27\0\u{1}SEQ_LARGE_28\0\u{1}SEQ_LARGE_29\0\u{1}SEQ_LARGE_30\0\u{1}SEQ_LARGE_31\0\u{1}SEQ_LARGE_32\0\u{1}SEQ_LARGE_33\0") +} + +extension EditionUnittest_EnumParseTester.Arbitrary: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}@@@@@\u{2}ARBITRARY_MIN\0\u{2}M|a\u{7f}\u{7f}\u{1}ARBITRARY_DEFAULT\0\u{2}xA\u{1e}ARBITRARY_1\0\u{2}P\u{5}ARBITRARY_2\0\u{2}H@4ARBITRARY_3\0\u{2}b|K\u{7f}\u{7f}\u{1}ARBITRARY_MAX\0") +} + +extension EditionUnittest_BoolParseTester: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".BoolParseTester" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_bool_lowfield\0\u{3}repeated_bool_lowfield\0\u{3}packed_bool_lowfield\0\u{4}`\u{1}other_field\0\u{4}F\u{e}optional_bool_midfield\0\u{3}repeated_bool_midfield\0\u{3}packed_bool_midfield\0\u{4}Vys\u{3}optional_bool_hifield\0\u{3}repeated_bool_hifield\0\u{3}packed_bool_hifield\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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.decodeSingularBoolField(value: &self._optionalBoolLowfield) }() + case 2: try { try decoder.decodeRepeatedBoolField(value: &self.repeatedBoolLowfield) }() + case 3: try { try decoder.decodeRepeatedBoolField(value: &self.packedBoolLowfield) }() + case 99: try { try decoder.decodeSingularInt32Field(value: &self._otherField) }() + case 1001: try { try decoder.decodeSingularBoolField(value: &self._optionalBoolMidfield) }() + case 1002: try { try decoder.decodeRepeatedBoolField(value: &self.repeatedBoolMidfield) }() + case 1003: try { try decoder.decodeRepeatedBoolField(value: &self.packedBoolMidfield) }() + case 1000001: try { try decoder.decodeSingularBoolField(value: &self._optionalBoolHifield) }() + case 1000002: try { try decoder.decodeRepeatedBoolField(value: &self.repeatedBoolHifield) }() + case 1000003: try { try decoder.decodeRepeatedBoolField(value: &self.packedBoolHifield) }() + case 2000000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionUnittest_BoolParseTester.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._optionalBoolLowfield { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1) + } }() + if !self.repeatedBoolLowfield.isEmpty { + try visitor.visitPackedBoolField(value: self.repeatedBoolLowfield, fieldNumber: 2) + } + if !self.packedBoolLowfield.isEmpty { + try visitor.visitPackedBoolField(value: self.packedBoolLowfield, fieldNumber: 3) + } + try { if let v = self._otherField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 99) + } }() + try { if let v = self._optionalBoolMidfield { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1001) + } }() + if !self.repeatedBoolMidfield.isEmpty { + try visitor.visitPackedBoolField(value: self.repeatedBoolMidfield, fieldNumber: 1002) + } + if !self.packedBoolMidfield.isEmpty { + try visitor.visitPackedBoolField(value: self.packedBoolMidfield, fieldNumber: 1003) + } + try { if let v = self._optionalBoolHifield { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1000001) + } }() + if !self.repeatedBoolHifield.isEmpty { + try visitor.visitPackedBoolField(value: self.repeatedBoolHifield, fieldNumber: 1000002) + } + if !self.packedBoolHifield.isEmpty { + try visitor.visitPackedBoolField(value: self.packedBoolHifield, fieldNumber: 1000003) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2000000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_BoolParseTester, rhs: EditionUnittest_BoolParseTester) -> Bool { + if lhs._optionalBoolLowfield != rhs._optionalBoolLowfield {return false} + if lhs._optionalBoolMidfield != rhs._optionalBoolMidfield {return false} + if lhs._optionalBoolHifield != rhs._optionalBoolHifield {return false} + if lhs.repeatedBoolLowfield != rhs.repeatedBoolLowfield {return false} + if lhs.repeatedBoolMidfield != rhs.repeatedBoolMidfield {return false} + if lhs.repeatedBoolHifield != rhs.repeatedBoolHifield {return false} + if lhs.packedBoolLowfield != rhs.packedBoolLowfield {return false} + if lhs.packedBoolMidfield != rhs.packedBoolMidfield {return false} + if lhs.packedBoolHifield != rhs.packedBoolHifield {return false} + if lhs._otherField != rhs._otherField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionUnittest_Int32ParseTester: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Int32ParseTester" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32_lowfield\0\u{3}repeated_int32_lowfield\0\u{3}packed_int32_lowfield\0\u{4}`\u{1}other_field\0\u{4}F\u{e}optional_int32_midfield\0\u{3}repeated_int32_midfield\0\u{3}packed_int32_midfield\0\u{4}Vys\u{3}optional_int32_hifield\0\u{3}repeated_int32_hifield\0\u{3}packed_int32_hifield\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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._optionalInt32Lowfield) }() + case 2: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32Lowfield) }() + case 3: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32Lowfield) }() + case 99: try { try decoder.decodeSingularInt32Field(value: &self._otherField) }() + case 1001: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32Midfield) }() + case 1002: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32Midfield) }() + case 1003: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32Midfield) }() + case 1000001: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32Hifield) }() + case 1000002: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32Hifield) }() + case 1000003: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32Hifield) }() + case 2000000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionUnittest_Int32ParseTester.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._optionalInt32Lowfield { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + if !self.repeatedInt32Lowfield.isEmpty { + try visitor.visitPackedInt32Field(value: self.repeatedInt32Lowfield, fieldNumber: 2) + } + if !self.packedInt32Lowfield.isEmpty { + try visitor.visitPackedInt32Field(value: self.packedInt32Lowfield, fieldNumber: 3) + } + try { if let v = self._otherField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 99) + } }() + try { if let v = self._optionalInt32Midfield { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1001) + } }() + if !self.repeatedInt32Midfield.isEmpty { + try visitor.visitPackedInt32Field(value: self.repeatedInt32Midfield, fieldNumber: 1002) + } + if !self.packedInt32Midfield.isEmpty { + try visitor.visitPackedInt32Field(value: self.packedInt32Midfield, fieldNumber: 1003) + } + try { if let v = self._optionalInt32Hifield { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1000001) + } }() + if !self.repeatedInt32Hifield.isEmpty { + try visitor.visitPackedInt32Field(value: self.repeatedInt32Hifield, fieldNumber: 1000002) + } + if !self.packedInt32Hifield.isEmpty { + try visitor.visitPackedInt32Field(value: self.packedInt32Hifield, fieldNumber: 1000003) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2000000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_Int32ParseTester, rhs: EditionUnittest_Int32ParseTester) -> Bool { + if lhs._optionalInt32Lowfield != rhs._optionalInt32Lowfield {return false} + if lhs._optionalInt32Midfield != rhs._optionalInt32Midfield {return false} + if lhs._optionalInt32Hifield != rhs._optionalInt32Hifield {return false} + if lhs.repeatedInt32Lowfield != rhs.repeatedInt32Lowfield {return false} + if lhs.repeatedInt32Midfield != rhs.repeatedInt32Midfield {return false} + if lhs.repeatedInt32Hifield != rhs.repeatedInt32Hifield {return false} + if lhs.packedInt32Lowfield != rhs.packedInt32Lowfield {return false} + if lhs.packedInt32Midfield != rhs.packedInt32Midfield {return false} + if lhs.packedInt32Hifield != rhs.packedInt32Hifield {return false} + if lhs._otherField != rhs._otherField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionUnittest_Int64ParseTester: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Int64ParseTester" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int64_lowfield\0\u{3}repeated_int64_lowfield\0\u{3}packed_int64_lowfield\0\u{4}`\u{1}other_field\0\u{4}F\u{e}optional_int64_midfield\0\u{3}repeated_int64_midfield\0\u{3}packed_int64_midfield\0\u{4}Vys\u{3}optional_int64_hifield\0\u{3}repeated_int64_hifield\0\u{3}packed_int64_hifield\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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.decodeSingularInt64Field(value: &self._optionalInt64Lowfield) }() + case 2: try { try decoder.decodeRepeatedInt64Field(value: &self.repeatedInt64Lowfield) }() + case 3: try { try decoder.decodeRepeatedInt64Field(value: &self.packedInt64Lowfield) }() + case 99: try { try decoder.decodeSingularInt32Field(value: &self._otherField) }() + case 1001: try { try decoder.decodeSingularInt64Field(value: &self._optionalInt64Midfield) }() + case 1002: try { try decoder.decodeRepeatedInt64Field(value: &self.repeatedInt64Midfield) }() + case 1003: try { try decoder.decodeRepeatedInt64Field(value: &self.packedInt64Midfield) }() + case 1000001: try { try decoder.decodeSingularInt64Field(value: &self._optionalInt64Hifield) }() + case 1000002: try { try decoder.decodeRepeatedInt64Field(value: &self.repeatedInt64Hifield) }() + case 1000003: try { try decoder.decodeRepeatedInt64Field(value: &self.packedInt64Hifield) }() + case 2000000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionUnittest_Int64ParseTester.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._optionalInt64Lowfield { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 1) + } }() + if !self.repeatedInt64Lowfield.isEmpty { + try visitor.visitPackedInt64Field(value: self.repeatedInt64Lowfield, fieldNumber: 2) + } + if !self.packedInt64Lowfield.isEmpty { + try visitor.visitPackedInt64Field(value: self.packedInt64Lowfield, fieldNumber: 3) + } + try { if let v = self._otherField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 99) + } }() + try { if let v = self._optionalInt64Midfield { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 1001) + } }() + if !self.repeatedInt64Midfield.isEmpty { + try visitor.visitPackedInt64Field(value: self.repeatedInt64Midfield, fieldNumber: 1002) + } + if !self.packedInt64Midfield.isEmpty { + try visitor.visitPackedInt64Field(value: self.packedInt64Midfield, fieldNumber: 1003) + } + try { if let v = self._optionalInt64Hifield { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 1000001) + } }() + if !self.repeatedInt64Hifield.isEmpty { + try visitor.visitPackedInt64Field(value: self.repeatedInt64Hifield, fieldNumber: 1000002) + } + if !self.packedInt64Hifield.isEmpty { + try visitor.visitPackedInt64Field(value: self.packedInt64Hifield, fieldNumber: 1000003) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2000000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_Int64ParseTester, rhs: EditionUnittest_Int64ParseTester) -> Bool { + if lhs._optionalInt64Lowfield != rhs._optionalInt64Lowfield {return false} + if lhs._optionalInt64Midfield != rhs._optionalInt64Midfield {return false} + if lhs._optionalInt64Hifield != rhs._optionalInt64Hifield {return false} + if lhs.repeatedInt64Lowfield != rhs.repeatedInt64Lowfield {return false} + if lhs.repeatedInt64Midfield != rhs.repeatedInt64Midfield {return false} + if lhs.repeatedInt64Hifield != rhs.repeatedInt64Hifield {return false} + if lhs.packedInt64Lowfield != rhs.packedInt64Lowfield {return false} + if lhs.packedInt64Midfield != rhs.packedInt64Midfield {return false} + if lhs.packedInt64Hifield != rhs.packedInt64Hifield {return false} + if lhs._otherField != rhs._otherField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionUnittest_InlinedStringIdxRegressionProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".InlinedStringIdxRegressionProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}str1\0\u{1}sub\0\u{1}str2\0\u{1}str3\0") + + fileprivate class _StorageClass { + var _str1: String? = nil + var _sub: EditionUnittest_InlinedStringIdxRegressionProto? = nil + var _str2: String? = nil + var _str3: Data? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _str1 = source._str1 + _sub = source._sub + _str2 = source._str2 + _str3 = source._str3 + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._str1) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._sub) }() + case 3: try { try decoder.decodeSingularStringField(value: &_storage._str2) }() + case 4: try { try decoder.decodeSingularBytesField(value: &_storage._str3) }() + default: break + } + } + } + } + + func traverse(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._str1 { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._sub { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._str2 { + try visitor.visitSingularStringField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._str3 { + try visitor.visitSingularBytesField(value: v, fieldNumber: 4) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_InlinedStringIdxRegressionProto, rhs: EditionUnittest_InlinedStringIdxRegressionProto) -> 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._str1 != rhs_storage._str1 {return false} + if _storage._sub != rhs_storage._sub {return false} + if _storage._str2 != rhs_storage._str2 {return false} + if _storage._str3 != rhs_storage._str3 {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_StringParseTester: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".StringParseTester" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_string_lowfield\0\u{3}repeated_string_lowfield\0\u{4}g\u{f}optional_string_midfield\0\u{3}repeated_string_midfield\0\u{4}Wys\u{3}optional_string_hifield\0\u{3}repeated_string_hifield\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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._optionalStringLowfield) }() + case 2: try { try decoder.decodeRepeatedStringField(value: &self.repeatedStringLowfield) }() + case 1001: try { try decoder.decodeSingularStringField(value: &self._optionalStringMidfield) }() + case 1002: try { try decoder.decodeRepeatedStringField(value: &self.repeatedStringMidfield) }() + case 1000001: try { try decoder.decodeSingularStringField(value: &self._optionalStringHifield) }() + case 1000002: try { try decoder.decodeRepeatedStringField(value: &self.repeatedStringHifield) }() + case 2000000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionUnittest_StringParseTester.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._optionalStringLowfield { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + if !self.repeatedStringLowfield.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedStringLowfield, fieldNumber: 2) + } + try { if let v = self._optionalStringMidfield { + try visitor.visitSingularStringField(value: v, fieldNumber: 1001) + } }() + if !self.repeatedStringMidfield.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedStringMidfield, fieldNumber: 1002) + } + try { if let v = self._optionalStringHifield { + try visitor.visitSingularStringField(value: v, fieldNumber: 1000001) + } }() + if !self.repeatedStringHifield.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedStringHifield, fieldNumber: 1000002) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2000000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_StringParseTester, rhs: EditionUnittest_StringParseTester) -> Bool { + if lhs._optionalStringLowfield != rhs._optionalStringLowfield {return false} + if lhs._optionalStringMidfield != rhs._optionalStringMidfield {return false} + if lhs._optionalStringHifield != rhs._optionalStringHifield {return false} + if lhs.repeatedStringLowfield != rhs.repeatedStringLowfield {return false} + if lhs.repeatedStringMidfield != rhs.repeatedStringMidfield {return false} + if lhs.repeatedStringHifield != rhs.repeatedStringHifield {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionUnittest_BadFieldNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".BadFieldNames" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OptionalInt32\0\u{1}for\0") + + 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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._for) }() + 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 + try { if let v = self._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._for { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_BadFieldNames, rhs: EditionUnittest_BadFieldNames) -> Bool { + if lhs._optionalInt32 != rhs._optionalInt32 {return false} + if lhs._for != rhs._for {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestNestedMessageRedaction: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedMessageRedaction" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_unredacted_nested_string\0\u{3}optional_redacted_nested_string\0") + + 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._optionalUnredactedNestedString) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._optionalRedactedNestedString) }() + 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 + try { if let v = self._optionalUnredactedNestedString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalRedactedNestedString { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestNestedMessageRedaction, rhs: EditionUnittest_TestNestedMessageRedaction) -> Bool { + if lhs._optionalUnredactedNestedString != rhs._optionalUnredactedNestedString {return false} + if lhs._optionalRedactedNestedString != rhs._optionalRedactedNestedString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_RedactedFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".RedactedFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_redacted_string\0\u{3}optional_unredacted_string\0\u{3}repeated_redacted_string\0\u{3}repeated_unredacted_string\0\u{3}optional_redacted_message\0\u{3}optional_unredacted_message\0\u{3}repeated_redacted_message\0\u{3}repeated_unredacted_message\0\u{3}map_redacted_string\0\u{3}map_unredacted_string\0") + + 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._optionalRedactedString) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._optionalUnredactedString) }() + case 3: try { try decoder.decodeRepeatedStringField(value: &self.repeatedRedactedString) }() + case 4: try { try decoder.decodeRepeatedStringField(value: &self.repeatedUnredactedString) }() + case 5: try { try decoder.decodeSingularMessageField(value: &self._optionalRedactedMessage) }() + case 6: try { try decoder.decodeSingularMessageField(value: &self._optionalUnredactedMessage) }() + case 7: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedRedactedMessage) }() + case 8: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedUnredactedMessage) }() + case 9: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.mapRedactedString) }() + case 10: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.mapUnredactedString) }() + 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 + try { if let v = self._optionalRedactedString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalUnredactedString { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + if !self.repeatedRedactedString.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedRedactedString, fieldNumber: 3) + } + if !self.repeatedUnredactedString.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedUnredactedString, fieldNumber: 4) + } + try { if let v = self._optionalRedactedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + try { if let v = self._optionalUnredactedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 6) + } }() + if !self.repeatedRedactedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedRedactedMessage, fieldNumber: 7) + } + if !self.repeatedUnredactedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedUnredactedMessage, fieldNumber: 8) + } + if !self.mapRedactedString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.mapRedactedString, fieldNumber: 9) + } + if !self.mapUnredactedString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.mapUnredactedString, fieldNumber: 10) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_RedactedFields, rhs: EditionUnittest_RedactedFields) -> Bool { + if lhs._optionalRedactedString != rhs._optionalRedactedString {return false} + if lhs._optionalUnredactedString != rhs._optionalUnredactedString {return false} + if lhs.repeatedRedactedString != rhs.repeatedRedactedString {return false} + if lhs.repeatedUnredactedString != rhs.repeatedUnredactedString {return false} + if lhs._optionalRedactedMessage != rhs._optionalRedactedMessage {return false} + if lhs._optionalUnredactedMessage != rhs._optionalUnredactedMessage {return false} + if lhs.repeatedRedactedMessage != rhs.repeatedRedactedMessage {return false} + if lhs.repeatedUnredactedMessage != rhs.repeatedUnredactedMessage {return false} + if lhs.mapRedactedString != rhs.mapRedactedString {return false} + if lhs.mapUnredactedString != rhs.mapUnredactedString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestCord: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestCord" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_bytes_cord\0\u{3}optional_bytes_cord_default\0") + + 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.decodeSingularBytesField(value: &self._optionalBytesCord) }() + case 2: try { try decoder.decodeSingularBytesField(value: &self._optionalBytesCordDefault) }() + 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 + try { if let v = self._optionalBytesCord { + try visitor.visitSingularBytesField(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalBytesCordDefault { + try visitor.visitSingularBytesField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestCord, rhs: EditionUnittest_TestCord) -> Bool { + if lhs._optionalBytesCord != rhs._optionalBytesCord {return false} + if lhs._optionalBytesCordDefault != rhs._optionalBytesCordDefault {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestPackedEnumSmallRange: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestPackedEnumSmallRange" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}vals\0") + + 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.decodeRepeatedEnumField(value: &self.vals) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.vals.isEmpty { + try visitor.visitPackedEnumField(value: self.vals, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestPackedEnumSmallRange, rhs: EditionUnittest_TestPackedEnumSmallRange) -> Bool { + if lhs.vals != rhs.vals {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_TestPackedEnumSmallRange.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNSPECIFIED\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension EditionUnittest_EnumsForBenchmark: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumsForBenchmark" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_EnumsForBenchmark, rhs: EditionUnittest_EnumsForBenchmark) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionUnittest_EnumsForBenchmark.Flat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0A0\0\u{1}A1\0\u{1}A2\0\u{1}A3\0\u{1}A4\0\u{1}A5\0\u{1}A6\0\u{1}A7\0\u{1}A8\0\u{1}A9\0\u{1}A10\0\u{1}A11\0\u{1}A12\0\u{1}A13\0\u{1}A14\0\u{1}A15\0") +} + +extension EditionUnittest_EnumsForBenchmark.AlmostFlat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0B0\0\u{1}B1\0\u{1}B2\0\u{1}B3\0\u{2}\u{2}B5\0\u{1}B6\0\u{1}B7\0\u{1}B8\0\u{1}B9\0\u{2}\u{2}B11\0\u{1}B12\0\u{1}B13\0\u{1}B14\0\u{1}B15\0\u{2}\u{2}B17\0\u{2}\u{2}B19\0") +} + +extension EditionUnittest_EnumsForBenchmark.Sparse: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0C0\0\u{2}X\u{8}C536\0\u{2}kz\u{1}C8387\0\u{2}F\u{14}C9673\0\u{2}d\u{9}C10285\0\u{2}Y/C13318\0\u{2}U)C15963\0\u{2}\\\u{7}C16439\0\u{2}^\u{1b}C18197\0\u{2}Q\u{13}C19430\0\u{2}c\u{e}C20361\0\u{2}Y\u{5}C20706\0\u{2}X\u{5}C21050\0\u{2}X\u{d}C21906\0\u{2}oS\u{1}C27265\0\u{2}\\,C30109\0\u{2}Y\u{18}C31670\0") +} + +extension EditionUnittest_TestMessageWithManyRepeatedPtrFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageWithManyRepeatedPtrFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}repeated_string_1\0\u{3}repeated_string_2\0\u{3}repeated_string_3\0\u{3}repeated_string_4\0\u{3}repeated_string_5\0\u{3}repeated_string_6\0\u{3}repeated_string_7\0\u{3}repeated_string_8\0\u{3}repeated_string_9\0\u{3}repeated_string_10\0\u{3}repeated_string_11\0\u{3}repeated_string_12\0\u{3}repeated_string_13\0\u{3}repeated_string_14\0\u{3}repeated_string_15\0\u{3}repeated_string_16\0\u{3}repeated_string_17\0\u{3}repeated_string_18\0\u{3}repeated_string_19\0\u{3}repeated_string_20\0\u{3}repeated_string_21\0\u{3}repeated_string_22\0\u{3}repeated_string_23\0\u{3}repeated_string_24\0\u{3}repeated_string_25\0\u{3}repeated_string_26\0\u{3}repeated_string_27\0\u{3}repeated_string_28\0\u{3}repeated_string_29\0\u{3}repeated_string_30\0\u{3}repeated_string_31\0\u{3}repeated_string_32\0") + + fileprivate class _StorageClass { + var _repeatedString1: [String] = [] + var _repeatedString2: [String] = [] + var _repeatedString3: [String] = [] + var _repeatedString4: [String] = [] + var _repeatedString5: [String] = [] + var _repeatedString6: [String] = [] + var _repeatedString7: [String] = [] + var _repeatedString8: [String] = [] + var _repeatedString9: [String] = [] + var _repeatedString10: [String] = [] + var _repeatedString11: [String] = [] + var _repeatedString12: [String] = [] + var _repeatedString13: [String] = [] + var _repeatedString14: [String] = [] + var _repeatedString15: [String] = [] + var _repeatedString16: [String] = [] + var _repeatedString17: [String] = [] + var _repeatedString18: [String] = [] + var _repeatedString19: [String] = [] + var _repeatedString20: [String] = [] + var _repeatedString21: [String] = [] + var _repeatedString22: [String] = [] + var _repeatedString23: [String] = [] + var _repeatedString24: [String] = [] + var _repeatedString25: [String] = [] + var _repeatedString26: [String] = [] + var _repeatedString27: [String] = [] + var _repeatedString28: [String] = [] + var _repeatedString29: [String] = [] + var _repeatedString30: [String] = [] + var _repeatedString31: [String] = [] + var _repeatedString32: [String] = [] + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _repeatedString1 = source._repeatedString1 + _repeatedString2 = source._repeatedString2 + _repeatedString3 = source._repeatedString3 + _repeatedString4 = source._repeatedString4 + _repeatedString5 = source._repeatedString5 + _repeatedString6 = source._repeatedString6 + _repeatedString7 = source._repeatedString7 + _repeatedString8 = source._repeatedString8 + _repeatedString9 = source._repeatedString9 + _repeatedString10 = source._repeatedString10 + _repeatedString11 = source._repeatedString11 + _repeatedString12 = source._repeatedString12 + _repeatedString13 = source._repeatedString13 + _repeatedString14 = source._repeatedString14 + _repeatedString15 = source._repeatedString15 + _repeatedString16 = source._repeatedString16 + _repeatedString17 = source._repeatedString17 + _repeatedString18 = source._repeatedString18 + _repeatedString19 = source._repeatedString19 + _repeatedString20 = source._repeatedString20 + _repeatedString21 = source._repeatedString21 + _repeatedString22 = source._repeatedString22 + _repeatedString23 = source._repeatedString23 + _repeatedString24 = source._repeatedString24 + _repeatedString25 = source._repeatedString25 + _repeatedString26 = source._repeatedString26 + _repeatedString27 = source._repeatedString27 + _repeatedString28 = source._repeatedString28 + _repeatedString29 = source._repeatedString29 + _repeatedString30 = source._repeatedString30 + _repeatedString31 = source._repeatedString31 + _repeatedString32 = source._repeatedString32 + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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.decodeRepeatedStringField(value: &_storage._repeatedString1) }() + case 2: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString2) }() + case 3: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString3) }() + case 4: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString4) }() + case 5: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString5) }() + case 6: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString6) }() + case 7: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString7) }() + case 8: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString8) }() + case 9: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString9) }() + case 10: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString10) }() + case 11: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString11) }() + case 12: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString12) }() + case 13: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString13) }() + case 14: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString14) }() + case 15: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString15) }() + case 16: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString16) }() + case 17: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString17) }() + case 18: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString18) }() + case 19: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString19) }() + case 20: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString20) }() + case 21: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString21) }() + case 22: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString22) }() + case 23: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString23) }() + case 24: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString24) }() + case 25: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString25) }() + case 26: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString26) }() + case 27: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString27) }() + case 28: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString28) }() + case 29: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString29) }() + case 30: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString30) }() + case 31: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString31) }() + case 32: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString32) }() + default: break + } + } + } + } + + func traverse(visitor: inout V) throws { + try withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if !_storage._repeatedString1.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString1, fieldNumber: 1) + } + if !_storage._repeatedString2.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString2, fieldNumber: 2) + } + if !_storage._repeatedString3.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString3, fieldNumber: 3) + } + if !_storage._repeatedString4.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString4, fieldNumber: 4) + } + if !_storage._repeatedString5.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString5, fieldNumber: 5) + } + if !_storage._repeatedString6.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString6, fieldNumber: 6) + } + if !_storage._repeatedString7.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString7, fieldNumber: 7) + } + if !_storage._repeatedString8.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString8, fieldNumber: 8) + } + if !_storage._repeatedString9.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString9, fieldNumber: 9) + } + if !_storage._repeatedString10.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString10, fieldNumber: 10) + } + if !_storage._repeatedString11.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString11, fieldNumber: 11) + } + if !_storage._repeatedString12.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString12, fieldNumber: 12) + } + if !_storage._repeatedString13.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString13, fieldNumber: 13) + } + if !_storage._repeatedString14.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString14, fieldNumber: 14) + } + if !_storage._repeatedString15.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString15, fieldNumber: 15) + } + if !_storage._repeatedString16.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString16, fieldNumber: 16) + } + if !_storage._repeatedString17.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString17, fieldNumber: 17) + } + if !_storage._repeatedString18.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString18, fieldNumber: 18) + } + if !_storage._repeatedString19.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString19, fieldNumber: 19) + } + if !_storage._repeatedString20.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString20, fieldNumber: 20) + } + if !_storage._repeatedString21.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString21, fieldNumber: 21) + } + if !_storage._repeatedString22.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString22, fieldNumber: 22) + } + if !_storage._repeatedString23.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString23, fieldNumber: 23) + } + if !_storage._repeatedString24.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString24, fieldNumber: 24) + } + if !_storage._repeatedString25.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString25, fieldNumber: 25) + } + if !_storage._repeatedString26.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString26, fieldNumber: 26) + } + if !_storage._repeatedString27.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString27, fieldNumber: 27) + } + if !_storage._repeatedString28.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString28, fieldNumber: 28) + } + if !_storage._repeatedString29.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString29, fieldNumber: 29) + } + if !_storage._repeatedString30.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString30, fieldNumber: 30) + } + if !_storage._repeatedString31.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString31, fieldNumber: 31) + } + if !_storage._repeatedString32.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString32, fieldNumber: 32) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionUnittest_TestMessageWithManyRepeatedPtrFields, rhs: EditionUnittest_TestMessageWithManyRepeatedPtrFields) -> 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._repeatedString1 != rhs_storage._repeatedString1 {return false} + if _storage._repeatedString2 != rhs_storage._repeatedString2 {return false} + if _storage._repeatedString3 != rhs_storage._repeatedString3 {return false} + if _storage._repeatedString4 != rhs_storage._repeatedString4 {return false} + if _storage._repeatedString5 != rhs_storage._repeatedString5 {return false} + if _storage._repeatedString6 != rhs_storage._repeatedString6 {return false} + if _storage._repeatedString7 != rhs_storage._repeatedString7 {return false} + if _storage._repeatedString8 != rhs_storage._repeatedString8 {return false} + if _storage._repeatedString9 != rhs_storage._repeatedString9 {return false} + if _storage._repeatedString10 != rhs_storage._repeatedString10 {return false} + if _storage._repeatedString11 != rhs_storage._repeatedString11 {return false} + if _storage._repeatedString12 != rhs_storage._repeatedString12 {return false} + if _storage._repeatedString13 != rhs_storage._repeatedString13 {return false} + if _storage._repeatedString14 != rhs_storage._repeatedString14 {return false} + if _storage._repeatedString15 != rhs_storage._repeatedString15 {return false} + if _storage._repeatedString16 != rhs_storage._repeatedString16 {return false} + if _storage._repeatedString17 != rhs_storage._repeatedString17 {return false} + if _storage._repeatedString18 != rhs_storage._repeatedString18 {return false} + if _storage._repeatedString19 != rhs_storage._repeatedString19 {return false} + if _storage._repeatedString20 != rhs_storage._repeatedString20 {return false} + if _storage._repeatedString21 != rhs_storage._repeatedString21 {return false} + if _storage._repeatedString22 != rhs_storage._repeatedString22 {return false} + if _storage._repeatedString23 != rhs_storage._repeatedString23 {return false} + if _storage._repeatedString24 != rhs_storage._repeatedString24 {return false} + if _storage._repeatedString25 != rhs_storage._repeatedString25 {return false} + if _storage._repeatedString26 != rhs_storage._repeatedString26 {return false} + if _storage._repeatedString27 != rhs_storage._repeatedString27 {return false} + if _storage._repeatedString28 != rhs_storage._repeatedString28 {return false} + if _storage._repeatedString29 != rhs_storage._repeatedString29 {return false} + if _storage._repeatedString30 != rhs_storage._repeatedString30 {return false} + if _storage._repeatedString31 != rhs_storage._repeatedString31 {return false} + if _storage._repeatedString32 != rhs_storage._repeatedString32 {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/google/protobuf/unittest_lazy_dependencies_enum.pb.swift b/Reference/upstream/google/protobuf/empty.pb.swift similarity index 60% rename from Reference/google/protobuf/unittest_lazy_dependencies_enum.pb.swift rename to Reference/upstream/google/protobuf/empty.pb.swift index 77e3528e4..0d953467e 100644 --- a/Reference/google/protobuf/unittest_lazy_dependencies_enum.pb.swift +++ b/Reference/upstream/google/protobuf/empty.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_lazy_dependencies_enum.proto +// Source: google/protobuf/empty.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -37,68 +38,54 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Author: trafacz@google.com (Todd Rafacz) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// A proto file we will use for unit testing. - -import Foundation -import SwiftProtobuf +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } -enum ProtobufUnittest_LazyImports_LazyEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case lazyEnum0 // = 0 - case lazyEnum1 // = 1 - - init() { - self = .lazyEnum0 - } +/// A generic empty message that you can re-use to avoid defining duplicated +/// empty messages in your APIs. A typical example is to use it as the request +/// or the response type of an API method. For instance: +/// +/// service Foo { +/// rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); +/// } +struct Google_Protobuf_Empty: Sendable { + // 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. - init?(rawValue: Int) { - switch rawValue { - case 0: self = .lazyEnum0 - case 1: self = .lazyEnum1 - default: return nil - } - } - - var rawValue: Int { - switch self { - case .lazyEnum0: return 0 - case .lazyEnum1: return 1 - } - } + var unknownFields = UnknownStorage() + init() {} } -#if swift(>=4.2) +// MARK: - Code below here is support for the SwiftProtobuf runtime. -extension ProtobufUnittest_LazyImports_LazyEnum: CaseIterable { - // Support synthesized by the compiler. -} +fileprivate let _protobuf_package = "google.protobuf" -#endif // swift(>=4.2) +extension Google_Protobuf_Empty: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Empty" + static let _protobuf_nameMap = _NameMap() -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_LazyImports_LazyEnum: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } -// MARK: - Code below here is support for the SwiftProtobuf runtime. + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } -extension ProtobufUnittest_LazyImports_LazyEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "LAZY_ENUM_0"), - 1: .same(proto: "LAZY_ENUM_1"), - ] + static func ==(lhs: Google_Protobuf_Empty, rhs: Google_Protobuf_Empty) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } } diff --git a/Reference/upstream/google/protobuf/field_mask.pb.swift b/Reference/upstream/google/protobuf/field_mask.pb.swift new file mode 100644 index 000000000..6b75ef7a1 --- /dev/null +++ b/Reference/upstream/google/protobuf/field_mask.pb.swift @@ -0,0 +1,297 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/field_mask.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. + +// 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: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// `FieldMask` represents a set of symbolic field paths, for example: +/// +/// paths: "f.a" +/// paths: "f.b.d" +/// +/// Here `f` represents a field in some root message, `a` and `b` +/// fields in the message found in `f`, and `d` a field found in the +/// message in `f.b`. +/// +/// Field masks are used to specify a subset of fields that should be +/// returned by a get operation or modified by an update operation. +/// Field masks also have a custom JSON encoding (see below). +/// +/// # Field Masks in Projections +/// +/// When used in the context of a projection, a response message or +/// sub-message is filtered by the API to only contain those fields as +/// specified in the mask. For example, if the mask in the previous +/// example is applied to a response message as follows: +/// +/// f { +/// a : 22 +/// b { +/// d : 1 +/// x : 2 +/// } +/// y : 13 +/// } +/// z: 8 +/// +/// The result will not contain specific values for fields x,y and z +/// (their value will be set to the default, and omitted in proto text +/// output): +/// +/// +/// f { +/// a : 22 +/// b { +/// d : 1 +/// } +/// } +/// +/// A repeated field is not allowed except at the last position of a +/// paths string. +/// +/// If a FieldMask object is not present in a get operation, the +/// operation applies to all fields (as if a FieldMask of all fields +/// had been specified). +/// +/// Note that a field mask does not necessarily apply to the +/// top-level response message. In case of a REST get operation, the +/// field mask applies directly to the response, but in case of a REST +/// list operation, the mask instead applies to each individual message +/// in the returned resource list. In case of a REST custom method, +/// other definitions may be used. Where the mask applies will be +/// clearly documented together with its declaration in the API. In +/// any case, the effect on the returned resource/resources is required +/// behavior for APIs. +/// +/// # Field Masks in Update Operations +/// +/// A field mask in update operations specifies which fields of the +/// targeted resource are going to be updated. The API is required +/// to only change the values of the fields as specified in the mask +/// and leave the others untouched. If a resource is passed in to +/// describe the updated values, the API ignores the values of all +/// fields not covered by the mask. +/// +/// If a repeated field is specified for an update operation, new values will +/// be appended to the existing repeated field in the target resource. Note that +/// a repeated field is only allowed in the last position of a `paths` string. +/// +/// If a sub-message is specified in the last position of the field mask for an +/// update operation, then new value will be merged into the existing sub-message +/// in the target resource. +/// +/// For example, given the target message: +/// +/// f { +/// b { +/// d: 1 +/// x: 2 +/// } +/// c: [1] +/// } +/// +/// And an update message: +/// +/// f { +/// b { +/// d: 10 +/// } +/// c: [2] +/// } +/// +/// then if the field mask is: +/// +/// paths: ["f.b", "f.c"] +/// +/// then the result will be: +/// +/// f { +/// b { +/// d: 10 +/// x: 2 +/// } +/// c: [1, 2] +/// } +/// +/// An implementation may provide options to override this default behavior for +/// repeated and message fields. +/// +/// In order to reset a field's value to the default, the field must +/// be in the mask and set to the default value in the provided resource. +/// Hence, in order to reset all fields of a resource, provide a default +/// instance of the resource and set all fields in the mask, or do +/// not provide a mask as described below. +/// +/// If a field mask is not present on update, the operation applies to +/// all fields (as if a field mask of all fields has been specified). +/// Note that in the presence of schema evolution, this may mean that +/// fields the client does not know and has therefore not filled into +/// the request will be reset to their default. If this is unwanted +/// behavior, a specific service may require a client to always specify +/// a field mask, producing an error if not. +/// +/// As with get operations, the location of the resource which +/// describes the updated values in the request message depends on the +/// operation kind. In any case, the effect of the field mask is +/// required to be honored by the API. +/// +/// ## Considerations for HTTP REST +/// +/// The HTTP kind of an update operation which uses a field mask must +/// be set to PATCH instead of PUT in order to satisfy HTTP semantics +/// (PUT must only be used for full updates). +/// +/// # JSON Encoding of Field Masks +/// +/// In JSON, a field mask is encoded as a single string where paths are +/// separated by a comma. Fields name in each path are converted +/// to/from lower-camel naming conventions. +/// +/// As an example, consider the following message declarations: +/// +/// message Profile { +/// User user = 1; +/// Photo photo = 2; +/// } +/// message User { +/// string display_name = 1; +/// string address = 2; +/// } +/// +/// In proto a field mask for `Profile` may look as such: +/// +/// mask { +/// paths: "user.display_name" +/// paths: "photo" +/// } +/// +/// In JSON, the same mask is represented as below: +/// +/// { +/// mask: "user.displayName,photo" +/// } +/// +/// # Field Masks and Oneof Fields +/// +/// Field masks treat fields in oneofs just as regular fields. Consider the +/// following message: +/// +/// message SampleMessage { +/// oneof test_oneof { +/// string name = 4; +/// SubMessage sub_message = 9; +/// } +/// } +/// +/// The field mask can be: +/// +/// mask { +/// paths: "name" +/// } +/// +/// Or: +/// +/// mask { +/// paths: "sub_message" +/// } +/// +/// Note that oneof type names ("test_oneof" in this case) cannot be used in +/// paths. +/// +/// ## Field Mask Verification +/// +/// The implementation of any API method which has a FieldMask type field in the +/// request should verify the included field paths, and return an +/// `INVALID_ARGUMENT` error if any path is unmappable. +struct Google_Protobuf_FieldMask: Sendable { + // 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. + + /// The set of field mask paths. + var paths: [String] = [] + + var unknownFields = UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "google.protobuf" + +extension Google_Protobuf_FieldMask: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FieldMask" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}paths\0") + + 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.decodeRepeatedStringField(value: &self.paths) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.paths.isEmpty { + try visitor.visitRepeatedStringField(value: self.paths, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_FieldMask, rhs: Google_Protobuf_FieldMask) -> Bool { + if lhs.paths != rhs.paths {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/go_features.pb.swift b/Reference/upstream/google/protobuf/go_features.pb.swift new file mode 100644 index 000000000..a03d13f3c --- /dev/null +++ b/Reference/upstream/google/protobuf/go_features.pb.swift @@ -0,0 +1,272 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/go_features.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2023 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +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 Pb_GoFeatures: Sendable { + // 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. + + /// Whether or not to generate the deprecated UnmarshalJSON method for enums. + /// Can only be true for proto using the Open Struct api. + var legacyUnmarshalJsonEnum: Bool { + get {_legacyUnmarshalJsonEnum ?? false} + set {_legacyUnmarshalJsonEnum = newValue} + } + /// Returns true if `legacyUnmarshalJsonEnum` has been explicitly set. + var hasLegacyUnmarshalJsonEnum: Bool {self._legacyUnmarshalJsonEnum != nil} + /// Clears the value of `legacyUnmarshalJsonEnum`. Subsequent reads from it will return its default value. + mutating func clearLegacyUnmarshalJsonEnum() {self._legacyUnmarshalJsonEnum = nil} + + /// One of OPEN, HYBRID or OPAQUE. + var apiLevel: Pb_GoFeatures.APILevel { + get {_apiLevel ?? .unspecified} + set {_apiLevel = newValue} + } + /// Returns true if `apiLevel` has been explicitly set. + var hasApiLevel: Bool {self._apiLevel != nil} + /// Clears the value of `apiLevel`. Subsequent reads from it will return its default value. + mutating func clearApiLevel() {self._apiLevel = nil} + + var stripEnumPrefix: Pb_GoFeatures.StripEnumPrefix { + get {_stripEnumPrefix ?? .unspecified} + set {_stripEnumPrefix = newValue} + } + /// Returns true if `stripEnumPrefix` has been explicitly set. + var hasStripEnumPrefix: Bool {self._stripEnumPrefix != nil} + /// Clears the value of `stripEnumPrefix`. Subsequent reads from it will return its default value. + mutating func clearStripEnumPrefix() {self._stripEnumPrefix = nil} + + var optimizeMode: Pb_GoFeatures.OptimizeModeFeature.OptimizeMode { + get {_optimizeMode ?? .unspecified} + set {_optimizeMode = newValue} + } + /// Returns true if `optimizeMode` has been explicitly set. + var hasOptimizeMode: Bool {self._optimizeMode != nil} + /// Clears the value of `optimizeMode`. Subsequent reads from it will return its default value. + mutating func clearOptimizeMode() {self._optimizeMode = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum APILevel: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + + /// API_LEVEL_UNSPECIFIED results in selecting the OPEN API, + /// but needs to be a separate value to distinguish between + /// an explicitly set api level or a missing api level. + case unspecified = 0 + case apiOpen = 1 + case apiHybrid = 2 + case apiOpaque = 3 + + init() { + self = .unspecified + } + + } + + enum StripEnumPrefix: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unspecified = 0 + case keep = 1 + case generateBoth = 2 + case strip = 3 + + init() { + self = .unspecified + } + + } + + /// Wrap the OptimizeMode enum in a message for scoping: + /// This way, users can type shorter names (SPEED, CODE_SIZE). + struct OptimizeModeFeature: Sendable { + // 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() + + /// The name of this enum matches OptimizeMode in descriptor.proto. + enum OptimizeMode: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + + /// OPTIMIZE_MODE_UNSPECIFIED results in falling back to the default + /// (optimize for code size), but needs to be a separate value to distinguish + /// between an explicitly set optimize mode or a missing optimize mode. + case unspecified = 0 + case speed = 1 + + /// There is no enum entry for LITE_RUNTIME (descriptor.proto), + /// because Go Protobuf does not have the concept of a lite runtime. + case codeSize = 2 + + init() { + self = .unspecified + } + + } + + init() {} + } + + init() {} + + fileprivate var _legacyUnmarshalJsonEnum: Bool? = nil + fileprivate var _apiLevel: Pb_GoFeatures.APILevel? = nil + fileprivate var _stripEnumPrefix: Pb_GoFeatures.StripEnumPrefix? = nil + fileprivate var _optimizeMode: Pb_GoFeatures.OptimizeModeFeature.OptimizeMode? = nil +} + +// MARK: - Extension support defined in go_features.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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_FeatureSet { + + var Pb_go: Pb_GoFeatures { + get {return getExtensionValue(ext: Pb_Extensions_go) ?? Pb_GoFeatures()} + set {setExtensionValue(ext: Pb_Extensions_go, value: newValue)} + } + /// Returns true if extension `Pb_Extensions_go` + /// has been explicitly set. + var hasPb_go: Bool { + return hasExtensionValue(ext: Pb_Extensions_go) + } + /// Clears the value of extension `Pb_Extensions_go`. + /// Subsequent reads from it will return its default value. + mutating func clearPb_go() { + clearExtensionValue(ext: Pb_Extensions_go) + } + +} + +// MARK: - File's ExtensionMap: Pb_GoFeatures_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 Pb_GoFeatures_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Pb_Extensions_go +] + +// 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 Pb_Extensions_go = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FeatureSet>( + _protobuf_fieldNumber: 1002, + fieldName: "pb.go" +) + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "pb" + +extension Pb_GoFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GoFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}legacy_unmarshal_json_enum\0\u{3}api_level\0\u{3}strip_enum_prefix\0\u{3}optimize_mode\0") + + 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.decodeSingularBoolField(value: &self._legacyUnmarshalJsonEnum) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self._apiLevel) }() + case 3: try { try decoder.decodeSingularEnumField(value: &self._stripEnumPrefix) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._optimizeMode) }() + 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 + try { if let v = self._legacyUnmarshalJsonEnum { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1) + } }() + try { if let v = self._apiLevel { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) + } }() + try { if let v = self._stripEnumPrefix { + try visitor.visitSingularEnumField(value: v, fieldNumber: 3) + } }() + try { if let v = self._optimizeMode { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Pb_GoFeatures, rhs: Pb_GoFeatures) -> Bool { + if lhs._legacyUnmarshalJsonEnum != rhs._legacyUnmarshalJsonEnum {return false} + if lhs._apiLevel != rhs._apiLevel {return false} + if lhs._stripEnumPrefix != rhs._stripEnumPrefix {return false} + if lhs._optimizeMode != rhs._optimizeMode {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Pb_GoFeatures.APILevel: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0API_LEVEL_UNSPECIFIED\0\u{1}API_OPEN\0\u{1}API_HYBRID\0\u{1}API_OPAQUE\0") +} + +extension Pb_GoFeatures.StripEnumPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0STRIP_ENUM_PREFIX_UNSPECIFIED\0\u{1}STRIP_ENUM_PREFIX_KEEP\0\u{1}STRIP_ENUM_PREFIX_GENERATE_BOTH\0\u{1}STRIP_ENUM_PREFIX_STRIP\0") +} + +extension Pb_GoFeatures.OptimizeModeFeature: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Pb_GoFeatures.protoMessageName + ".OptimizeModeFeature" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Pb_GoFeatures.OptimizeModeFeature, rhs: Pb_GoFeatures.OptimizeModeFeature) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Pb_GoFeatures.OptimizeModeFeature.OptimizeMode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0OPTIMIZE_MODE_UNSPECIFIED\0\u{1}SPEED\0\u{1}CODE_SIZE\0") +} diff --git a/Reference/upstream/google/protobuf/internal_metadata_locator_test.pb.swift b/Reference/upstream/google/protobuf/internal_metadata_locator_test.pb.swift new file mode 100644 index 000000000..9d1b67257 --- /dev/null +++ b/Reference/upstream/google/protobuf/internal_metadata_locator_test.pb.swift @@ -0,0 +1,68 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/internal_metadata_locator_test.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +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 +} + +/// The test that uses this message requires that the message has only one field. +struct Proto2Unittest_TestOneRepeatedField: Sendable { + // 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 repeatedInt32: [Int32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest" + +extension Proto2Unittest_TestOneRepeatedField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestOneRepeatedField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}repeated_int32\0") + + 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.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.repeatedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: self.repeatedInt32, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestOneRepeatedField, rhs: Proto2Unittest_TestOneRepeatedField) -> Bool { + if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/internal_options.pb.swift b/Reference/upstream/google/protobuf/internal_options.pb.swift new file mode 100644 index 000000000..c2fab9a71 --- /dev/null +++ b/Reference/upstream/google/protobuf/internal_options.pb.swift @@ -0,0 +1,234 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/internal_options.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2023 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +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 Pb_InternalOptionsForce: Sendable { + // 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() + + enum Enum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case unspecified // = 0 + case forceOn // = 1 + case forceOff // = 2 + case UNRECOGNIZED(Int) + + init() { + self = .unspecified + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .unspecified + case 1: self = .forceOn + case 2: self = .forceOff + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .unspecified: return 0 + case .forceOn: return 1 + case .forceOff: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Pb_InternalOptionsForce.Enum] = [ + .unspecified, + .forceOn, + .forceOff, + ] + + } + + init() {} +} + +struct Pb_InternalFieldOptionsCpp: Sendable { + // 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 Pb_InternalFieldOptions: Sendable { + // 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 cpp: Pb_InternalFieldOptionsCpp { + get {_cpp ?? Pb_InternalFieldOptionsCpp()} + set {_cpp = newValue} + } + /// Returns true if `cpp` has been explicitly set. + var hasCpp: Bool {self._cpp != nil} + /// Clears the value of `cpp`. Subsequent reads from it will return its default value. + mutating func clearCpp() {self._cpp = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _cpp: Pb_InternalFieldOptionsCpp? = nil +} + +// MARK: - Extension support defined in internal_options.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 Pb_internalFieldOptions: Pb_InternalFieldOptions { + get {return getExtensionValue(ext: Pb_Extensions_internal_field_options) ?? Pb_InternalFieldOptions()} + set {setExtensionValue(ext: Pb_Extensions_internal_field_options, value: newValue)} + } + /// Returns true if extension `Pb_Extensions_internal_field_options` + /// has been explicitly set. + var hasPb_internalFieldOptions: Bool { + return hasExtensionValue(ext: Pb_Extensions_internal_field_options) + } + /// Clears the value of extension `Pb_Extensions_internal_field_options`. + /// Subsequent reads from it will return its default value. + mutating func clearPb_internalFieldOptions() { + clearExtensionValue(ext: Pb_Extensions_internal_field_options) + } + +} + +// MARK: - File's ExtensionMap: Pb_InternalOptions_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 Pb_InternalOptions_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Pb_Extensions_internal_field_options +] + +// 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 Pb_Extensions_internal_field_options = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FieldOptions>( + _protobuf_fieldNumber: 535801550, + fieldName: "pb.internal_field_options" +) + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "pb" + +extension Pb_InternalOptionsForce: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".InternalOptionsForce" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Pb_InternalOptionsForce, rhs: Pb_InternalOptionsForce) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Pb_InternalOptionsForce.Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNSPECIFIED\0\u{1}FORCE_ON\0\u{1}FORCE_OFF\0") +} + +extension Pb_InternalFieldOptionsCpp: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".InternalFieldOptionsCpp" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Pb_InternalFieldOptionsCpp, rhs: Pb_InternalFieldOptionsCpp) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Pb_InternalFieldOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".InternalFieldOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}cpp\0") + + 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.decodeSingularMessageField(value: &self._cpp) }() + 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 + try { if let v = self._cpp { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Pb_InternalFieldOptions, rhs: Pb_InternalFieldOptions) -> Bool { + if lhs._cpp != rhs._cpp {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/java_features.pb.swift b/Reference/upstream/google/protobuf/java_features.pb.swift new file mode 100644 index 000000000..83a51aaca --- /dev/null +++ b/Reference/upstream/google/protobuf/java_features.pb.swift @@ -0,0 +1,286 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/java_features.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2023 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +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 Pb_JavaFeatures: Sendable { + // 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. + + /// Whether or not to treat an enum field as closed. This option is only + /// applicable to enum fields, and will be removed in the future. It is + /// consistent with the legacy behavior of using proto3 enum types for proto2 + /// fields. + var legacyClosedEnum: Bool { + get {_legacyClosedEnum ?? false} + set {_legacyClosedEnum = newValue} + } + /// Returns true if `legacyClosedEnum` has been explicitly set. + var hasLegacyClosedEnum: Bool {self._legacyClosedEnum != nil} + /// Clears the value of `legacyClosedEnum`. Subsequent reads from it will return its default value. + mutating func clearLegacyClosedEnum() {self._legacyClosedEnum = nil} + + var utf8Validation: Pb_JavaFeatures.Utf8Validation { + get {_utf8Validation ?? .unknown} + set {_utf8Validation = newValue} + } + /// Returns true if `utf8Validation` has been explicitly set. + var hasUtf8Validation: Bool {self._utf8Validation != nil} + /// Clears the value of `utf8Validation`. Subsequent reads from it will return its default value. + mutating func clearUtf8Validation() {self._utf8Validation = nil} + + /// Allows creation of large Java enums, extending beyond the standard + /// constant limits imposed by the Java language. + var largeEnum: Bool { + get {_largeEnum ?? false} + set {_largeEnum = newValue} + } + /// Returns true if `largeEnum` has been explicitly set. + var hasLargeEnum: Bool {self._largeEnum != nil} + /// Clears the value of `largeEnum`. Subsequent reads from it will return its default value. + mutating func clearLargeEnum() {self._largeEnum = nil} + + /// Whether to use the old default outer class name scheme, or the new feature + /// which adds a "Proto" suffix to the outer class name. + /// + /// Users will not be able to set this option, because we removed it in the + /// same edition that it was introduced. But we use it to determine which + /// naming scheme to use for outer class name defaults. + var useOldOuterClassnameDefault: Bool { + get {_useOldOuterClassnameDefault ?? false} + set {_useOldOuterClassnameDefault = newValue} + } + /// Returns true if `useOldOuterClassnameDefault` has been explicitly set. + var hasUseOldOuterClassnameDefault: Bool {self._useOldOuterClassnameDefault != nil} + /// Clears the value of `useOldOuterClassnameDefault`. Subsequent reads from it will return its default value. + mutating func clearUseOldOuterClassnameDefault() {self._useOldOuterClassnameDefault = nil} + + /// Whether to nest the generated class in the generated file class. This is + /// only applicable to *top-level* messages, enums, and services. + var nestInFileClass: Pb_JavaFeatures.NestInFileClassFeature.NestInFileClass { + get {_nestInFileClass ?? .unknown} + set {_nestInFileClass = newValue} + } + /// Returns true if `nestInFileClass` has been explicitly set. + var hasNestInFileClass: Bool {self._nestInFileClass != nil} + /// Clears the value of `nestInFileClass`. Subsequent reads from it will return its default value. + mutating func clearNestInFileClass() {self._nestInFileClass = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + /// The UTF8 validation strategy to use. + enum Utf8Validation: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + + /// Invalid default, which should never be used. + case unknown = 0 + + /// Respect the UTF8 validation behavior specified by the global + /// utf8_validation feature. + case `default` = 1 + + /// Verifies UTF8 validity overriding the global utf8_validation + /// feature. This represents the legacy java_string_check_utf8 option. + case verify = 2 + + init() { + self = .unknown + } + + } + + struct NestInFileClassFeature: Sendable { + // 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() + + enum NestInFileClass: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + + /// Invalid default, which should never be used. + case unknown = 0 + + /// Do not nest the generated class in the file class. + case no = 1 + + /// Nest the generated class in the file class. + case yes = 2 + + /// Fall back to the `java_multiple_files` option. Users won't be able to + /// set this option. + case legacy = 3 + + init() { + self = .unknown + } + + } + + init() {} + } + + init() {} + + fileprivate var _legacyClosedEnum: Bool? = nil + fileprivate var _utf8Validation: Pb_JavaFeatures.Utf8Validation? = nil + fileprivate var _largeEnum: Bool? = nil + fileprivate var _useOldOuterClassnameDefault: Bool? = nil + fileprivate var _nestInFileClass: Pb_JavaFeatures.NestInFileClassFeature.NestInFileClass? = nil +} + +// MARK: - Extension support defined in java_features.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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_FeatureSet { + + var Pb_java: Pb_JavaFeatures { + get {return getExtensionValue(ext: Pb_Extensions_java) ?? Pb_JavaFeatures()} + set {setExtensionValue(ext: Pb_Extensions_java, value: newValue)} + } + /// Returns true if extension `Pb_Extensions_java` + /// has been explicitly set. + var hasPb_java: Bool { + return hasExtensionValue(ext: Pb_Extensions_java) + } + /// Clears the value of extension `Pb_Extensions_java`. + /// Subsequent reads from it will return its default value. + mutating func clearPb_java() { + clearExtensionValue(ext: Pb_Extensions_java) + } + +} + +// MARK: - File's ExtensionMap: Pb_JavaFeatures_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 Pb_JavaFeatures_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Pb_Extensions_java +] + +// 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 Pb_Extensions_java = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FeatureSet>( + _protobuf_fieldNumber: 1001, + fieldName: "pb.java" +) + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "pb" + +extension Pb_JavaFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".JavaFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}legacy_closed_enum\0\u{3}utf8_validation\0\u{3}large_enum\0\u{3}use_old_outer_classname_default\0\u{3}nest_in_file_class\0\u{c}\u{6}\u{1}") + + 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.decodeSingularBoolField(value: &self._legacyClosedEnum) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self._utf8Validation) }() + case 3: try { try decoder.decodeSingularBoolField(value: &self._largeEnum) }() + case 4: try { try decoder.decodeSingularBoolField(value: &self._useOldOuterClassnameDefault) }() + case 5: try { try decoder.decodeSingularEnumField(value: &self._nestInFileClass) }() + 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 + try { if let v = self._legacyClosedEnum { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1) + } }() + try { if let v = self._utf8Validation { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) + } }() + try { if let v = self._largeEnum { + try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + } }() + try { if let v = self._useOldOuterClassnameDefault { + try visitor.visitSingularBoolField(value: v, fieldNumber: 4) + } }() + try { if let v = self._nestInFileClass { + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Pb_JavaFeatures, rhs: Pb_JavaFeatures) -> Bool { + if lhs._legacyClosedEnum != rhs._legacyClosedEnum {return false} + if lhs._utf8Validation != rhs._utf8Validation {return false} + if lhs._largeEnum != rhs._largeEnum {return false} + if lhs._useOldOuterClassnameDefault != rhs._useOldOuterClassnameDefault {return false} + if lhs._nestInFileClass != rhs._nestInFileClass {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Pb_JavaFeatures.Utf8Validation: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UTF8_VALIDATION_UNKNOWN\0\u{1}DEFAULT\0\u{1}VERIFY\0") +} + +extension Pb_JavaFeatures.NestInFileClassFeature: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Pb_JavaFeatures.protoMessageName + ".NestInFileClassFeature" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{c}\u{1}\u{7f}\u{7f}\u{7f}\u{7f}\u{1f}") + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Pb_JavaFeatures.NestInFileClassFeature, rhs: Pb_JavaFeatures.NestInFileClassFeature) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Pb_JavaFeatures.NestInFileClassFeature.NestInFileClass: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NEST_IN_FILE_CLASS_UNKNOWN\0\u{1}NO\0\u{1}YES\0\u{1}LEGACY\0") +} diff --git a/Reference/upstream/google/protobuf/java_mutable_features.pb.swift b/Reference/upstream/google/protobuf/java_mutable_features.pb.swift new file mode 100644 index 000000000..670c48e95 --- /dev/null +++ b/Reference/upstream/google/protobuf/java_mutable_features.pb.swift @@ -0,0 +1,184 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/java_mutable_features.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +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 Pb_JavaMutableFeatures: Sendable { + // 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. + + /// Whether to nest the generated class in the generated file class for + /// Java Proto2 Mutable API. This is only available at the file level. + var nestInFileClass: Pb_JavaMutableFeatures.NestInFileClassFeature.NestInFileClass { + get {_nestInFileClass ?? .unknown} + set {_nestInFileClass = newValue} + } + /// Returns true if `nestInFileClass` has been explicitly set. + var hasNestInFileClass: Bool {self._nestInFileClass != nil} + /// Clears the value of `nestInFileClass`. Subsequent reads from it will return its default value. + mutating func clearNestInFileClass() {self._nestInFileClass = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct NestInFileClassFeature: Sendable { + // 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() + + enum NestInFileClass: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + + /// Invalid default, which should never be used. + case unknown = 0 + + /// Do not nest the generated class in the file class. + case no = 1 + + /// Nest the generated class in the file class. + case yes = 2 + + /// Fall back to the `java_multiple_files` and + /// `java_multiple_files_mutable_package` options. Users won't be able to + /// set this option. + case legacy = 3 + + init() { + self = .unknown + } + + } + + init() {} + } + + init() {} + + fileprivate var _nestInFileClass: Pb_JavaMutableFeatures.NestInFileClassFeature.NestInFileClass? = nil +} + +// MARK: - Extension support defined in java_mutable_features.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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_FeatureSet { + + var Pb_javaMutable: Pb_JavaMutableFeatures { + get {return getExtensionValue(ext: Pb_Extensions_java_mutable) ?? Pb_JavaMutableFeatures()} + set {setExtensionValue(ext: Pb_Extensions_java_mutable, value: newValue)} + } + /// Returns true if extension `Pb_Extensions_java_mutable` + /// has been explicitly set. + var hasPb_javaMutable: Bool { + return hasExtensionValue(ext: Pb_Extensions_java_mutable) + } + /// Clears the value of extension `Pb_Extensions_java_mutable`. + /// Subsequent reads from it will return its default value. + mutating func clearPb_javaMutable() { + clearExtensionValue(ext: Pb_Extensions_java_mutable) + } + +} + +// MARK: - File's ExtensionMap: Pb_JavaMutableFeatures_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 Pb_JavaMutableFeatures_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Pb_Extensions_java_mutable +] + +// 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 Pb_Extensions_java_mutable = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FeatureSet>( + _protobuf_fieldNumber: 9989, + fieldName: "pb.java_mutable" +) + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "pb" + +extension Pb_JavaMutableFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".JavaMutableFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{6}nest_in_file_class\0") + + 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 6: try { try decoder.decodeSingularEnumField(value: &self._nestInFileClass) }() + 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 + try { if let v = self._nestInFileClass { + try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Pb_JavaMutableFeatures, rhs: Pb_JavaMutableFeatures) -> Bool { + if lhs._nestInFileClass != rhs._nestInFileClass {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Pb_JavaMutableFeatures.NestInFileClassFeature: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Pb_JavaMutableFeatures.protoMessageName + ".NestInFileClassFeature" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{c}\u{1}\u{7f}\u{7f}\u{7f}\u{7f}\u{1f}") + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Pb_JavaMutableFeatures.NestInFileClassFeature, rhs: Pb_JavaMutableFeatures.NestInFileClassFeature) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Pb_JavaMutableFeatures.NestInFileClassFeature.NestInFileClass: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NEST_IN_FILE_CLASS_UNKNOWN\0\u{1}NO\0\u{1}YES\0\u{1}LEGACY\0") +} diff --git a/Reference/upstream/google/protobuf/late_loaded_option.pb.swift b/Reference/upstream/google/protobuf/late_loaded_option.pb.swift new file mode 100644 index 000000000..f7ed9eca4 --- /dev/null +++ b/Reference/upstream/google/protobuf/late_loaded_option.pb.swift @@ -0,0 +1,131 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/late_loaded_option.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +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 Proto2Unittest_LateLoadedOption: Sendable { + // 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 value: Int32 { + get {_value ?? 0} + set {_value = newValue} + } + /// Returns true if `value` has been explicitly set. + var hasValue: Bool {self._value != nil} + /// Clears the value of `value`. Subsequent reads from it will return its default value. + mutating func clearValue() {self._value = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _value: Int32? = nil +} + +// MARK: - Extension support defined in late_loaded_option.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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_MessageOptions { + + var Proto2Unittest_LateLoadedOption_ext: Proto2Unittest_LateLoadedOption { + get {return getExtensionValue(ext: Proto2Unittest_LateLoadedOption.Extensions.ext) ?? Proto2Unittest_LateLoadedOption()} + set {setExtensionValue(ext: Proto2Unittest_LateLoadedOption.Extensions.ext, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_LateLoadedOption.Extensions.ext` + /// has been explicitly set. + var hasProto2Unittest_LateLoadedOption_ext: Bool { + return hasExtensionValue(ext: Proto2Unittest_LateLoadedOption.Extensions.ext) + } + /// Clears the value of extension `Proto2Unittest_LateLoadedOption.Extensions.ext`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_LateLoadedOption_ext() { + clearExtensionValue(ext: Proto2Unittest_LateLoadedOption.Extensions.ext) + } + +} + +// MARK: - File's ExtensionMap: Proto2Unittest_LateLoadedOption_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 Proto2Unittest_LateLoadedOption_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Proto2Unittest_LateLoadedOption.Extensions.ext +] + +// 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. + +extension Proto2Unittest_LateLoadedOption { + enum Extensions { + static let ext = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 95126892, + fieldName: "proto2_unittest.LateLoadedOption.ext" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest" + +extension Proto2Unittest_LateLoadedOption: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".LateLoadedOption" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}value\0") + + 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._value) }() + 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 + try { if let v = self._value { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_LateLoadedOption, rhs: Proto2Unittest_LateLoadedOption) -> Bool { + if lhs._value != rhs._value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/late_loaded_option_user.pb.swift b/Reference/upstream/google/protobuf/late_loaded_option_user.pb.swift new file mode 100644 index 000000000..66ffcba27 --- /dev/null +++ b/Reference/upstream/google/protobuf/late_loaded_option_user.pb.swift @@ -0,0 +1,54 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/late_loaded_option_user.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +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 Proto2Unittest_LateLoadedOptionUser: Sendable { + // 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() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest" + +extension Proto2Unittest_LateLoadedOptionUser: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".LateLoadedOptionUser" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_LateLoadedOptionUser, rhs: Proto2Unittest_LateLoadedOptionUser) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/google/protobuf/map_lite_unittest.pb.swift b/Reference/upstream/google/protobuf/map_lite_unittest.pb.swift similarity index 71% rename from Reference/google/protobuf/map_lite_unittest.pb.swift rename to Reference/upstream/google/protobuf/map_lite_unittest.pb.swift index 62b5049f6..e370bf525 100644 --- a/Reference/google/protobuf/map_lite_unittest.pb.swift +++ b/Reference/upstream/google/protobuf/map_lite_unittest.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/map_lite_unittest.proto @@ -9,33 +10,10 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd import Foundation import SwiftProtobuf @@ -50,212 +28,132 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum ProtobufUnittest_Proto2MapEnumLite: SwiftProtobuf.Enum { - typealias RawValue = Int - case proto2MapEnumFooLite // = 0 - case proto2MapEnumBarLite // = 1 - case proto2MapEnumBazLite // = 2 +enum Proto2Unittest_Proto2MapEnumLite: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case proto2MapEnumFooLite = 0 + case proto2MapEnumBarLite = 1 + case proto2MapEnumBazLite = 2 init() { self = .proto2MapEnumFooLite } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .proto2MapEnumFooLite - case 1: self = .proto2MapEnumBarLite - case 2: self = .proto2MapEnumBazLite - default: return nil - } - } - - var rawValue: Int { - switch self { - case .proto2MapEnumFooLite: return 0 - case .proto2MapEnumBarLite: return 1 - case .proto2MapEnumBazLite: return 2 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_Proto2MapEnumLite: CaseIterable { - // Support synthesized by the compiler. } -#endif // swift(>=4.2) - -enum ProtobufUnittest_Proto2MapEnumPlusExtraLite: SwiftProtobuf.Enum { - typealias RawValue = Int - case eProto2MapEnumFooLite // = 0 - case eProto2MapEnumBarLite // = 1 - case eProto2MapEnumBazLite // = 2 - case eProto2MapEnumExtraLite // = 3 +enum Proto2Unittest_Proto2MapEnumPlusExtraLite: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case eProto2MapEnumFooLite = 0 + case eProto2MapEnumBarLite = 1 + case eProto2MapEnumBazLite = 2 + case eProto2MapEnumExtraLite = 3 init() { self = .eProto2MapEnumFooLite } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .eProto2MapEnumFooLite - case 1: self = .eProto2MapEnumBarLite - case 2: self = .eProto2MapEnumBazLite - case 3: self = .eProto2MapEnumExtraLite - default: return nil - } - } - - var rawValue: Int { - switch self { - case .eProto2MapEnumFooLite: return 0 - case .eProto2MapEnumBarLite: return 1 - case .eProto2MapEnumBazLite: return 2 - case .eProto2MapEnumExtraLite: return 3 - } - } - } -#if swift(>=4.2) - -extension ProtobufUnittest_Proto2MapEnumPlusExtraLite: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -enum ProtobufUnittest_MapEnumLite: SwiftProtobuf.Enum { - typealias RawValue = Int - case mapEnumFooLite // = 0 - case mapEnumBarLite // = 1 - case mapEnumBazLite // = 2 +enum Proto2Unittest_MapEnumLite: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case mapEnumFooLite = 0 + case mapEnumBarLite = 1 + case mapEnumBazLite = 2 init() { self = .mapEnumFooLite } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .mapEnumFooLite - case 1: self = .mapEnumBarLite - case 2: self = .mapEnumBazLite - default: return nil - } - } - - var rawValue: Int { - switch self { - case .mapEnumFooLite: return 0 - case .mapEnumBarLite: return 1 - case .mapEnumBazLite: return 2 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_MapEnumLite: CaseIterable { - // Support synthesized by the compiler. } -#endif // swift(>=4.2) - -struct ProtobufUnittest_TestMapLite { +struct Proto2Unittest_TestMapLite: @unchecked Sendable { // 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 mapInt32Int32: Dictionary { - get {return _storage._mapInt32Int32} + get {_storage._mapInt32Int32} set {_uniqueStorage()._mapInt32Int32 = newValue} } var mapInt64Int64: Dictionary { - get {return _storage._mapInt64Int64} + get {_storage._mapInt64Int64} set {_uniqueStorage()._mapInt64Int64 = newValue} } var mapUint32Uint32: Dictionary { - get {return _storage._mapUint32Uint32} + get {_storage._mapUint32Uint32} set {_uniqueStorage()._mapUint32Uint32 = newValue} } var mapUint64Uint64: Dictionary { - get {return _storage._mapUint64Uint64} + get {_storage._mapUint64Uint64} set {_uniqueStorage()._mapUint64Uint64 = newValue} } var mapSint32Sint32: Dictionary { - get {return _storage._mapSint32Sint32} + get {_storage._mapSint32Sint32} set {_uniqueStorage()._mapSint32Sint32 = newValue} } var mapSint64Sint64: Dictionary { - get {return _storage._mapSint64Sint64} + get {_storage._mapSint64Sint64} set {_uniqueStorage()._mapSint64Sint64 = newValue} } var mapFixed32Fixed32: Dictionary { - get {return _storage._mapFixed32Fixed32} + get {_storage._mapFixed32Fixed32} set {_uniqueStorage()._mapFixed32Fixed32 = newValue} } var mapFixed64Fixed64: Dictionary { - get {return _storage._mapFixed64Fixed64} + get {_storage._mapFixed64Fixed64} set {_uniqueStorage()._mapFixed64Fixed64 = newValue} } var mapSfixed32Sfixed32: Dictionary { - get {return _storage._mapSfixed32Sfixed32} + get {_storage._mapSfixed32Sfixed32} set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} } var mapSfixed64Sfixed64: Dictionary { - get {return _storage._mapSfixed64Sfixed64} + get {_storage._mapSfixed64Sfixed64} set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} } var mapInt32Float: Dictionary { - get {return _storage._mapInt32Float} + get {_storage._mapInt32Float} set {_uniqueStorage()._mapInt32Float = newValue} } var mapInt32Double: Dictionary { - get {return _storage._mapInt32Double} + get {_storage._mapInt32Double} set {_uniqueStorage()._mapInt32Double = newValue} } var mapBoolBool: Dictionary { - get {return _storage._mapBoolBool} + get {_storage._mapBoolBool} set {_uniqueStorage()._mapBoolBool = newValue} } var mapStringString: Dictionary { - get {return _storage._mapStringString} + get {_storage._mapStringString} set {_uniqueStorage()._mapStringString = newValue} } var mapInt32Bytes: Dictionary { - get {return _storage._mapInt32Bytes} + get {_storage._mapInt32Bytes} set {_uniqueStorage()._mapInt32Bytes = newValue} } - var mapInt32Enum: Dictionary { - get {return _storage._mapInt32Enum} + var mapInt32Enum: Dictionary { + get {_storage._mapInt32Enum} set {_uniqueStorage()._mapInt32Enum = newValue} } - var mapInt32ForeignMessage: Dictionary { - get {return _storage._mapInt32ForeignMessage} + var mapInt32ForeignMessage: Dictionary { + get {_storage._mapInt32ForeignMessage} set {_uniqueStorage()._mapInt32ForeignMessage = newValue} } var teboring: Dictionary { - get {return _storage._teboring} + get {_storage._teboring} set {_uniqueStorage()._teboring = newValue} } @@ -266,93 +164,93 @@ struct ProtobufUnittest_TestMapLite { fileprivate var _storage = _StorageClass.defaultInstance } -struct ProtobufUnittest_TestArenaMapLite { +struct Proto2Unittest_TestArenaMapLite: @unchecked Sendable { // 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 mapInt32Int32: Dictionary { - get {return _storage._mapInt32Int32} + get {_storage._mapInt32Int32} set {_uniqueStorage()._mapInt32Int32 = newValue} } var mapInt64Int64: Dictionary { - get {return _storage._mapInt64Int64} + get {_storage._mapInt64Int64} set {_uniqueStorage()._mapInt64Int64 = newValue} } var mapUint32Uint32: Dictionary { - get {return _storage._mapUint32Uint32} + get {_storage._mapUint32Uint32} set {_uniqueStorage()._mapUint32Uint32 = newValue} } var mapUint64Uint64: Dictionary { - get {return _storage._mapUint64Uint64} + get {_storage._mapUint64Uint64} set {_uniqueStorage()._mapUint64Uint64 = newValue} } var mapSint32Sint32: Dictionary { - get {return _storage._mapSint32Sint32} + get {_storage._mapSint32Sint32} set {_uniqueStorage()._mapSint32Sint32 = newValue} } var mapSint64Sint64: Dictionary { - get {return _storage._mapSint64Sint64} + get {_storage._mapSint64Sint64} set {_uniqueStorage()._mapSint64Sint64 = newValue} } var mapFixed32Fixed32: Dictionary { - get {return _storage._mapFixed32Fixed32} + get {_storage._mapFixed32Fixed32} set {_uniqueStorage()._mapFixed32Fixed32 = newValue} } var mapFixed64Fixed64: Dictionary { - get {return _storage._mapFixed64Fixed64} + get {_storage._mapFixed64Fixed64} set {_uniqueStorage()._mapFixed64Fixed64 = newValue} } var mapSfixed32Sfixed32: Dictionary { - get {return _storage._mapSfixed32Sfixed32} + get {_storage._mapSfixed32Sfixed32} set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} } var mapSfixed64Sfixed64: Dictionary { - get {return _storage._mapSfixed64Sfixed64} + get {_storage._mapSfixed64Sfixed64} set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} } var mapInt32Float: Dictionary { - get {return _storage._mapInt32Float} + get {_storage._mapInt32Float} set {_uniqueStorage()._mapInt32Float = newValue} } var mapInt32Double: Dictionary { - get {return _storage._mapInt32Double} + get {_storage._mapInt32Double} set {_uniqueStorage()._mapInt32Double = newValue} } var mapBoolBool: Dictionary { - get {return _storage._mapBoolBool} + get {_storage._mapBoolBool} set {_uniqueStorage()._mapBoolBool = newValue} } var mapStringString: Dictionary { - get {return _storage._mapStringString} + get {_storage._mapStringString} set {_uniqueStorage()._mapStringString = newValue} } var mapInt32Bytes: Dictionary { - get {return _storage._mapInt32Bytes} + get {_storage._mapInt32Bytes} set {_uniqueStorage()._mapInt32Bytes = newValue} } - var mapInt32Enum: Dictionary { - get {return _storage._mapInt32Enum} + var mapInt32Enum: Dictionary { + get {_storage._mapInt32Enum} set {_uniqueStorage()._mapInt32Enum = newValue} } - var mapInt32ForeignMessage: Dictionary { - get {return _storage._mapInt32ForeignMessage} + var mapInt32ForeignMessage: Dictionary { + get {_storage._mapInt32ForeignMessage} set {_uniqueStorage()._mapInt32ForeignMessage = newValue} } @@ -364,87 +262,87 @@ struct ProtobufUnittest_TestArenaMapLite { } /// Test embedded message with required fields -struct ProtobufUnittest_TestRequiredMessageMapLite { +struct Proto2Unittest_TestRequiredMessageMapLite: Sendable { // 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 mapField: Dictionary = [:] + var mapField: Dictionary = [:] var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } -struct ProtobufUnittest_TestEnumMapLite { +struct Proto2Unittest_TestEnumMapLite: Sendable { // 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 knownMapField: Dictionary = [:] + var knownMapField: Dictionary = [:] - var unknownMapField: Dictionary = [:] + var unknownMapField: Dictionary = [:] var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } -struct ProtobufUnittest_TestEnumMapPlusExtraLite { +struct Proto2Unittest_TestEnumMapPlusExtraLite: Sendable { // 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 knownMapField: Dictionary = [:] + var knownMapField: Dictionary = [:] - var unknownMapField: Dictionary = [:] + var unknownMapField: Dictionary = [:] var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } -struct ProtobufUnittest_TestMessageMapLite { +struct Proto2Unittest_TestMessageMapLite: Sendable { // 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 mapInt32Message: Dictionary = [:] + var mapInt32Message: Dictionary = [:] var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } -struct ProtobufUnittest_TestRequiredLite { +struct Proto2Unittest_TestRequiredLite: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} var b: Int32 { - get {return _b ?? 0} + get {_b ?? 0} set {_b = newValue} } /// Returns true if `b` has been explicitly set. - var hasB: Bool {return self._b != nil} + var hasB: Bool {self._b != nil} /// Clears the value of `b`. Subsequent reads from it will return its default value. mutating func clearB() {self._b = nil} var c: Int32 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -457,17 +355,17 @@ struct ProtobufUnittest_TestRequiredLite { fileprivate var _c: Int32? = nil } -struct ProtobufUnittest_ForeignMessageArenaLite { +struct Proto2Unittest_ForeignMessageArenaLite: Sendable { // 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 c: Int32 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -478,71 +376,76 @@ struct ProtobufUnittest_ForeignMessageArenaLite { fileprivate var _c: Int32? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_Proto2MapEnumLite: @unchecked Sendable {} -extension ProtobufUnittest_Proto2MapEnumPlusExtraLite: @unchecked Sendable {} -extension ProtobufUnittest_MapEnumLite: @unchecked Sendable {} -extension ProtobufUnittest_TestMapLite: @unchecked Sendable {} -extension ProtobufUnittest_TestArenaMapLite: @unchecked Sendable {} -extension ProtobufUnittest_TestRequiredMessageMapLite: @unchecked Sendable {} -extension ProtobufUnittest_TestEnumMapLite: @unchecked Sendable {} -extension ProtobufUnittest_TestEnumMapPlusExtraLite: @unchecked Sendable {} -extension ProtobufUnittest_TestMessageMapLite: @unchecked Sendable {} -extension ProtobufUnittest_TestRequiredLite: @unchecked Sendable {} -extension ProtobufUnittest_ForeignMessageArenaLite: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) +// MARK: - Extension support defined in map_lite_unittest.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 Proto2Unittest_TestAllExtensionsLite { + + var Proto2Unittest_TestRequiredLite_single: Proto2Unittest_TestRequiredLite { + get {return getExtensionValue(ext: Proto2Unittest_TestRequiredLite.Extensions.single) ?? Proto2Unittest_TestRequiredLite()} + set {setExtensionValue(ext: Proto2Unittest_TestRequiredLite.Extensions.single, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestRequiredLite.Extensions.single` + /// has been explicitly set. + var hasProto2Unittest_TestRequiredLite_single: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestRequiredLite.Extensions.single) + } + /// Clears the value of extension `Proto2Unittest_TestRequiredLite.Extensions.single`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestRequiredLite_single() { + clearExtensionValue(ext: Proto2Unittest_TestRequiredLite.Extensions.single) + } + +} + +// MARK: - File's ExtensionMap: Proto2Unittest_MapLiteUnittest_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 Proto2Unittest_MapLiteUnittest_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Proto2Unittest_TestRequiredLite.Extensions.single +] + +// 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. + +extension Proto2Unittest_TestRequiredLite { + enum Extensions { + static let single = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 1000, + fieldName: "proto2_unittest.TestRequiredLite.single" + ) + } +} // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "proto2_unittest" -extension ProtobufUnittest_Proto2MapEnumLite: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "PROTO2_MAP_ENUM_FOO_LITE"), - 1: .same(proto: "PROTO2_MAP_ENUM_BAR_LITE"), - 2: .same(proto: "PROTO2_MAP_ENUM_BAZ_LITE"), - ] +extension Proto2Unittest_Proto2MapEnumLite: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0PROTO2_MAP_ENUM_FOO_LITE\0\u{1}PROTO2_MAP_ENUM_BAR_LITE\0\u{1}PROTO2_MAP_ENUM_BAZ_LITE\0") } -extension ProtobufUnittest_Proto2MapEnumPlusExtraLite: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "E_PROTO2_MAP_ENUM_FOO_LITE"), - 1: .same(proto: "E_PROTO2_MAP_ENUM_BAR_LITE"), - 2: .same(proto: "E_PROTO2_MAP_ENUM_BAZ_LITE"), - 3: .same(proto: "E_PROTO2_MAP_ENUM_EXTRA_LITE"), - ] +extension Proto2Unittest_Proto2MapEnumPlusExtraLite: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0E_PROTO2_MAP_ENUM_FOO_LITE\0\u{1}E_PROTO2_MAP_ENUM_BAR_LITE\0\u{1}E_PROTO2_MAP_ENUM_BAZ_LITE\0\u{1}E_PROTO2_MAP_ENUM_EXTRA_LITE\0") } -extension ProtobufUnittest_MapEnumLite: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "MAP_ENUM_FOO_LITE"), - 1: .same(proto: "MAP_ENUM_BAR_LITE"), - 2: .same(proto: "MAP_ENUM_BAZ_LITE"), - ] +extension Proto2Unittest_MapEnumLite: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0MAP_ENUM_FOO_LITE\0\u{1}MAP_ENUM_BAR_LITE\0\u{1}MAP_ENUM_BAZ_LITE\0") } -extension ProtobufUnittest_TestMapLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestMapLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestMapLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "map_int32_int32"), - 2: .standard(proto: "map_int64_int64"), - 3: .standard(proto: "map_uint32_uint32"), - 4: .standard(proto: "map_uint64_uint64"), - 5: .standard(proto: "map_sint32_sint32"), - 6: .standard(proto: "map_sint64_sint64"), - 7: .standard(proto: "map_fixed32_fixed32"), - 8: .standard(proto: "map_fixed64_fixed64"), - 9: .standard(proto: "map_sfixed32_sfixed32"), - 10: .standard(proto: "map_sfixed64_sfixed64"), - 11: .standard(proto: "map_int32_float"), - 12: .standard(proto: "map_int32_double"), - 13: .standard(proto: "map_bool_bool"), - 14: .standard(proto: "map_string_string"), - 15: .standard(proto: "map_int32_bytes"), - 16: .standard(proto: "map_int32_enum"), - 17: .standard(proto: "map_int32_foreign_message"), - 18: .same(proto: "teboring"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_int32_bytes\0\u{3}map_int32_enum\0\u{3}map_int32_foreign_message\0\u{1}teboring\0") fileprivate class _StorageClass { var _mapInt32Int32: Dictionary = [:] @@ -560,11 +463,15 @@ extension ProtobufUnittest_TestMapLite: SwiftProtobuf.Message, SwiftProtobuf._Me var _mapBoolBool: Dictionary = [:] var _mapStringString: Dictionary = [:] var _mapInt32Bytes: Dictionary = [:] - var _mapInt32Enum: Dictionary = [:] - var _mapInt32ForeignMessage: Dictionary = [:] + var _mapInt32Enum: Dictionary = [:] + var _mapInt32ForeignMessage: Dictionary = [:] var _teboring: Dictionary = [:] - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -620,8 +527,8 @@ extension ProtobufUnittest_TestMapLite: SwiftProtobuf.Message, SwiftProtobuf._Me case 13: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() case 14: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() case 15: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bytes) }() - case 16: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() - case 17: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32ForeignMessage) }() + case 16: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() + case 17: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32ForeignMessage) }() case 18: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._teboring) }() default: break } @@ -677,10 +584,10 @@ extension ProtobufUnittest_TestMapLite: SwiftProtobuf.Message, SwiftProtobuf._Me try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bytes, fieldNumber: 15) } if !_storage._mapInt32Enum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 16) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 16) } if !_storage._mapInt32ForeignMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32ForeignMessage, fieldNumber: 17) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32ForeignMessage, fieldNumber: 17) } if !_storage._teboring.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._teboring, fieldNumber: 18) @@ -689,7 +596,7 @@ extension ProtobufUnittest_TestMapLite: SwiftProtobuf.Message, SwiftProtobuf._Me try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestMapLite, rhs: ProtobufUnittest_TestMapLite) -> Bool { + static func ==(lhs: Proto2Unittest_TestMapLite, rhs: Proto2Unittest_TestMapLite) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -721,27 +628,9 @@ extension ProtobufUnittest_TestMapLite: SwiftProtobuf.Message, SwiftProtobuf._Me } } -extension ProtobufUnittest_TestArenaMapLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestArenaMapLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestArenaMapLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "map_int32_int32"), - 2: .standard(proto: "map_int64_int64"), - 3: .standard(proto: "map_uint32_uint32"), - 4: .standard(proto: "map_uint64_uint64"), - 5: .standard(proto: "map_sint32_sint32"), - 6: .standard(proto: "map_sint64_sint64"), - 7: .standard(proto: "map_fixed32_fixed32"), - 8: .standard(proto: "map_fixed64_fixed64"), - 9: .standard(proto: "map_sfixed32_sfixed32"), - 10: .standard(proto: "map_sfixed64_sfixed64"), - 11: .standard(proto: "map_int32_float"), - 12: .standard(proto: "map_int32_double"), - 13: .standard(proto: "map_bool_bool"), - 14: .standard(proto: "map_string_string"), - 15: .standard(proto: "map_int32_bytes"), - 16: .standard(proto: "map_int32_enum"), - 17: .standard(proto: "map_int32_foreign_message"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_int32_bytes\0\u{3}map_int32_enum\0\u{3}map_int32_foreign_message\0") fileprivate class _StorageClass { var _mapInt32Int32: Dictionary = [:] @@ -759,10 +648,14 @@ extension ProtobufUnittest_TestArenaMapLite: SwiftProtobuf.Message, SwiftProtobu var _mapBoolBool: Dictionary = [:] var _mapStringString: Dictionary = [:] var _mapInt32Bytes: Dictionary = [:] - var _mapInt32Enum: Dictionary = [:] - var _mapInt32ForeignMessage: Dictionary = [:] + var _mapInt32Enum: Dictionary = [:] + var _mapInt32ForeignMessage: Dictionary = [:] - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -817,8 +710,8 @@ extension ProtobufUnittest_TestArenaMapLite: SwiftProtobuf.Message, SwiftProtobu case 13: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() case 14: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() case 15: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bytes) }() - case 16: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() - case 17: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32ForeignMessage) }() + case 16: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() + case 17: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32ForeignMessage) }() default: break } } @@ -873,16 +766,16 @@ extension ProtobufUnittest_TestArenaMapLite: SwiftProtobuf.Message, SwiftProtobu try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bytes, fieldNumber: 15) } if !_storage._mapInt32Enum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 16) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 16) } if !_storage._mapInt32ForeignMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32ForeignMessage, fieldNumber: 17) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32ForeignMessage, fieldNumber: 17) } } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestArenaMapLite, rhs: ProtobufUnittest_TestArenaMapLite) -> Bool { + static func ==(lhs: Proto2Unittest_TestArenaMapLite, rhs: Proto2Unittest_TestArenaMapLite) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -913,11 +806,9 @@ extension ProtobufUnittest_TestArenaMapLite: SwiftProtobuf.Message, SwiftProtobu } } -extension ProtobufUnittest_TestRequiredMessageMapLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestRequiredMessageMapLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestRequiredMessageMapLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "map_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}map_field\0") public var isInitialized: Bool { if !SwiftProtobuf.Internal.areAllInitialized(self.mapField) {return false} @@ -930,7 +821,7 @@ extension ProtobufUnittest_TestRequiredMessageMapLite: SwiftProtobuf.Message, Sw // 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapField) }() + case 1: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapField) }() default: break } } @@ -938,24 +829,21 @@ extension ProtobufUnittest_TestRequiredMessageMapLite: SwiftProtobuf.Message, Sw func traverse(visitor: inout V) throws { if !self.mapField.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapField, fieldNumber: 1) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestRequiredMessageMapLite, rhs: ProtobufUnittest_TestRequiredMessageMapLite) -> Bool { + static func ==(lhs: Proto2Unittest_TestRequiredMessageMapLite, rhs: Proto2Unittest_TestRequiredMessageMapLite) -> Bool { if lhs.mapField != rhs.mapField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestEnumMapLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestEnumMapLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestEnumMapLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 101: .standard(proto: "known_map_field"), - 102: .standard(proto: "unknown_map_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}e\u{1}known_map_field\0\u{3}unknown_map_field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -963,8 +851,8 @@ extension ProtobufUnittest_TestEnumMapLite: SwiftProtobuf.Message, SwiftProtobuf // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { - case 101: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.knownMapField) }() - case 102: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapField) }() + case 101: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.knownMapField) }() + case 102: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapField) }() default: break } } @@ -972,15 +860,15 @@ extension ProtobufUnittest_TestEnumMapLite: SwiftProtobuf.Message, SwiftProtobuf func traverse(visitor: inout V) throws { if !self.knownMapField.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.knownMapField, fieldNumber: 101) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.knownMapField, fieldNumber: 101) } if !self.unknownMapField.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapField, fieldNumber: 102) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapField, fieldNumber: 102) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestEnumMapLite, rhs: ProtobufUnittest_TestEnumMapLite) -> Bool { + static func ==(lhs: Proto2Unittest_TestEnumMapLite, rhs: Proto2Unittest_TestEnumMapLite) -> Bool { if lhs.knownMapField != rhs.knownMapField {return false} if lhs.unknownMapField != rhs.unknownMapField {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -988,12 +876,9 @@ extension ProtobufUnittest_TestEnumMapLite: SwiftProtobuf.Message, SwiftProtobuf } } -extension ProtobufUnittest_TestEnumMapPlusExtraLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestEnumMapPlusExtraLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestEnumMapPlusExtraLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 101: .standard(proto: "known_map_field"), - 102: .standard(proto: "unknown_map_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}e\u{1}known_map_field\0\u{3}unknown_map_field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1001,8 +886,8 @@ extension ProtobufUnittest_TestEnumMapPlusExtraLite: SwiftProtobuf.Message, Swif // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { - case 101: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.knownMapField) }() - case 102: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapField) }() + case 101: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.knownMapField) }() + case 102: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapField) }() default: break } } @@ -1010,15 +895,15 @@ extension ProtobufUnittest_TestEnumMapPlusExtraLite: SwiftProtobuf.Message, Swif func traverse(visitor: inout V) throws { if !self.knownMapField.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.knownMapField, fieldNumber: 101) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.knownMapField, fieldNumber: 101) } if !self.unknownMapField.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapField, fieldNumber: 102) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapField, fieldNumber: 102) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestEnumMapPlusExtraLite, rhs: ProtobufUnittest_TestEnumMapPlusExtraLite) -> Bool { + static func ==(lhs: Proto2Unittest_TestEnumMapPlusExtraLite, rhs: Proto2Unittest_TestEnumMapPlusExtraLite) -> Bool { if lhs.knownMapField != rhs.knownMapField {return false} if lhs.unknownMapField != rhs.unknownMapField {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -1026,11 +911,9 @@ extension ProtobufUnittest_TestEnumMapPlusExtraLite: SwiftProtobuf.Message, Swif } } -extension ProtobufUnittest_TestMessageMapLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestMessageMapLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestMessageMapLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "map_int32_message"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}map_int32_message\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1038,7 +921,7 @@ extension ProtobufUnittest_TestMessageMapLite: SwiftProtobuf.Message, SwiftProto // 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapInt32Message) }() + case 1: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapInt32Message) }() default: break } } @@ -1046,25 +929,21 @@ extension ProtobufUnittest_TestMessageMapLite: SwiftProtobuf.Message, SwiftProto func traverse(visitor: inout V) throws { if !self.mapInt32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapInt32Message, fieldNumber: 1) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapInt32Message, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestMessageMapLite, rhs: ProtobufUnittest_TestMessageMapLite) -> Bool { + static func ==(lhs: Proto2Unittest_TestMessageMapLite, rhs: Proto2Unittest_TestMessageMapLite) -> Bool { if lhs.mapInt32Message != rhs.mapInt32Message {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestRequiredLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestRequiredLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestRequiredLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 2: .same(proto: "b"), - 3: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0\u{1}c\0") public var isInitialized: Bool { if self._a == nil {return false} @@ -1104,7 +983,7 @@ extension ProtobufUnittest_TestRequiredLite: SwiftProtobuf.Message, SwiftProtobu try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestRequiredLite, rhs: ProtobufUnittest_TestRequiredLite) -> Bool { + static func ==(lhs: Proto2Unittest_TestRequiredLite, rhs: Proto2Unittest_TestRequiredLite) -> Bool { if lhs._a != rhs._a {return false} if lhs._b != rhs._b {return false} if lhs._c != rhs._c {return false} @@ -1113,11 +992,9 @@ extension ProtobufUnittest_TestRequiredLite: SwiftProtobuf.Message, SwiftProtobu } } -extension ProtobufUnittest_ForeignMessageArenaLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_ForeignMessageArenaLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ForeignMessageArenaLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1142,7 +1019,7 @@ extension ProtobufUnittest_ForeignMessageArenaLite: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_ForeignMessageArenaLite, rhs: ProtobufUnittest_ForeignMessageArenaLite) -> Bool { + static func ==(lhs: Proto2Unittest_ForeignMessageArenaLite, rhs: Proto2Unittest_ForeignMessageArenaLite) -> Bool { if lhs._c != rhs._c {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Reference/upstream/google/protobuf/map_proto2_unittest.pb.swift b/Reference/upstream/google/protobuf/map_proto2_unittest.pb.swift new file mode 100644 index 000000000..3d62f4629 --- /dev/null +++ b/Reference/upstream/google/protobuf/map_proto2_unittest.pb.swift @@ -0,0 +1,641 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/map_proto2_unittest.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +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 Proto2Unittest_Proto2MapEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 + + init() { + self = .foo + } + +} + +enum Proto2Unittest_Proto2MapEnumPlusExtra: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case eProto2MapEnumFoo = 0 + case eProto2MapEnumBar = 1 + case eProto2MapEnumBaz = 2 + case eProto2MapEnumExtra = 3 + + init() { + self = .eProto2MapEnumFoo + } + +} + +struct Proto2Unittest_TestEnumMap: Sendable { + // 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 knownMapField: Dictionary = [:] + + var unknownMapField: Dictionary = [:] + + /// Other maps with all key types to test the unknown entry serialization + var unknownMapFieldInt64: Dictionary = [:] + + var unknownMapFieldUint64: Dictionary = [:] + + var unknownMapFieldInt32: Dictionary = [:] + + var unknownMapFieldUint32: Dictionary = [:] + + var unknownMapFieldFixed32: Dictionary = [:] + + var unknownMapFieldFixed64: Dictionary = [:] + + var unknownMapFieldBool: Dictionary = [:] + + var unknownMapFieldString: Dictionary = [:] + + var unknownMapFieldSint32: Dictionary = [:] + + var unknownMapFieldSint64: Dictionary = [:] + + var unknownMapFieldSfixed32: Dictionary = [:] + + var unknownMapFieldSfixed64: Dictionary = [:] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Proto2Unittest_TestEnumMapPlusExtra: Sendable { + // 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 knownMapField: Dictionary = [:] + + var unknownMapField: Dictionary = [:] + + /// Other maps with all key types to test the unknown entry serialization + var unknownMapFieldInt64: Dictionary = [:] + + var unknownMapFieldUint64: Dictionary = [:] + + var unknownMapFieldInt32: Dictionary = [:] + + var unknownMapFieldUint32: Dictionary = [:] + + var unknownMapFieldFixed32: Dictionary = [:] + + var unknownMapFieldFixed64: Dictionary = [:] + + var unknownMapFieldBool: Dictionary = [:] + + var unknownMapFieldString: Dictionary = [:] + + var unknownMapFieldSint32: Dictionary = [:] + + var unknownMapFieldSint64: Dictionary = [:] + + var unknownMapFieldSfixed32: Dictionary = [:] + + var unknownMapFieldSfixed64: Dictionary = [:] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Proto2Unittest_TestImportEnumMap: Sendable { + // 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 importEnumAmp: Dictionary = [:] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Proto2Unittest_TestIntIntMap: Sendable { + // 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 m: Dictionary = [:] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +/// Test all key types: string, plus the non-floating-point scalars. +struct Proto2Unittest_TestMaps: Sendable { + // 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 mInt32: Dictionary = [:] + + var mInt64: Dictionary = [:] + + var mUint32: Dictionary = [:] + + var mUint64: Dictionary = [:] + + var mSint32: Dictionary = [:] + + var mSint64: Dictionary = [:] + + var mFixed32: Dictionary = [:] + + var mFixed64: Dictionary = [:] + + var mSfixed32: Dictionary = [:] + + var mSfixed64: Dictionary = [:] + + var mBool: Dictionary = [:] + + var mString: Dictionary = [:] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +/// Test maps in submessages. +struct Proto2Unittest_TestSubmessageMaps: Sendable { + // 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 m: Proto2Unittest_TestMaps { + get {_m ?? Proto2Unittest_TestMaps()} + set {_m = newValue} + } + /// Returns true if `m` has been explicitly set. + var hasM: Bool {self._m != nil} + /// Clears the value of `m`. Subsequent reads from it will return its default value. + mutating func clearM() {self._m = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _m: Proto2Unittest_TestMaps? = nil +} + +struct Proto2Unittest_TestProto2BytesMap: Sendable { + // 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 mapBytes: Dictionary = [:] + + var mapString: Dictionary = [:] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest" + +extension Proto2Unittest_Proto2MapEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0PROTO2_MAP_ENUM_FOO\0\u{1}PROTO2_MAP_ENUM_BAR\0\u{1}PROTO2_MAP_ENUM_BAZ\0") +} + +extension Proto2Unittest_Proto2MapEnumPlusExtra: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0E_PROTO2_MAP_ENUM_FOO\0\u{1}E_PROTO2_MAP_ENUM_BAR\0\u{1}E_PROTO2_MAP_ENUM_BAZ\0\u{1}E_PROTO2_MAP_ENUM_EXTRA\0") +} + +extension Proto2Unittest_TestEnumMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEnumMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}e\u{1}known_map_field\0\u{3}unknown_map_field\0\u{4}b\u{1}unknown_map_field_int64\0\u{3}unknown_map_field_uint64\0\u{3}unknown_map_field_int32\0\u{3}unknown_map_field_uint32\0\u{3}unknown_map_field_fixed32\0\u{3}unknown_map_field_fixed64\0\u{3}unknown_map_field_bool\0\u{3}unknown_map_field_string\0\u{3}unknown_map_field_sint32\0\u{3}unknown_map_field_sint64\0\u{3}unknown_map_field_sfixed32\0\u{3}unknown_map_field_sfixed64\0") + + 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 101: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.knownMapField) }() + case 102: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapField) }() + case 200: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldInt64) }() + case 201: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldUint64) }() + case 202: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldInt32) }() + case 203: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldUint32) }() + case 204: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldFixed32) }() + case 205: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldFixed64) }() + case 206: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldBool) }() + case 207: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldString) }() + case 208: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSint32) }() + case 209: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSint64) }() + case 210: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSfixed32) }() + case 211: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSfixed64) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.knownMapField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.knownMapField, fieldNumber: 101) + } + if !self.unknownMapField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapField, fieldNumber: 102) + } + if !self.unknownMapFieldInt64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldInt64, fieldNumber: 200) + } + if !self.unknownMapFieldUint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldUint64, fieldNumber: 201) + } + if !self.unknownMapFieldInt32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldInt32, fieldNumber: 202) + } + if !self.unknownMapFieldUint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldUint32, fieldNumber: 203) + } + if !self.unknownMapFieldFixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldFixed32, fieldNumber: 204) + } + if !self.unknownMapFieldFixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldFixed64, fieldNumber: 205) + } + if !self.unknownMapFieldBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldBool, fieldNumber: 206) + } + if !self.unknownMapFieldString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldString, fieldNumber: 207) + } + if !self.unknownMapFieldSint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSint32, fieldNumber: 208) + } + if !self.unknownMapFieldSint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSint64, fieldNumber: 209) + } + if !self.unknownMapFieldSfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSfixed32, fieldNumber: 210) + } + if !self.unknownMapFieldSfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSfixed64, fieldNumber: 211) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestEnumMap, rhs: Proto2Unittest_TestEnumMap) -> Bool { + if lhs.knownMapField != rhs.knownMapField {return false} + if lhs.unknownMapField != rhs.unknownMapField {return false} + if lhs.unknownMapFieldInt64 != rhs.unknownMapFieldInt64 {return false} + if lhs.unknownMapFieldUint64 != rhs.unknownMapFieldUint64 {return false} + if lhs.unknownMapFieldInt32 != rhs.unknownMapFieldInt32 {return false} + if lhs.unknownMapFieldUint32 != rhs.unknownMapFieldUint32 {return false} + if lhs.unknownMapFieldFixed32 != rhs.unknownMapFieldFixed32 {return false} + if lhs.unknownMapFieldFixed64 != rhs.unknownMapFieldFixed64 {return false} + if lhs.unknownMapFieldBool != rhs.unknownMapFieldBool {return false} + if lhs.unknownMapFieldString != rhs.unknownMapFieldString {return false} + if lhs.unknownMapFieldSint32 != rhs.unknownMapFieldSint32 {return false} + if lhs.unknownMapFieldSint64 != rhs.unknownMapFieldSint64 {return false} + if lhs.unknownMapFieldSfixed32 != rhs.unknownMapFieldSfixed32 {return false} + if lhs.unknownMapFieldSfixed64 != rhs.unknownMapFieldSfixed64 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestEnumMapPlusExtra: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEnumMapPlusExtra" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}e\u{1}known_map_field\0\u{3}unknown_map_field\0\u{4}b\u{1}unknown_map_field_int64\0\u{3}unknown_map_field_uint64\0\u{3}unknown_map_field_int32\0\u{3}unknown_map_field_uint32\0\u{3}unknown_map_field_fixed32\0\u{3}unknown_map_field_fixed64\0\u{3}unknown_map_field_bool\0\u{3}unknown_map_field_string\0\u{3}unknown_map_field_sint32\0\u{3}unknown_map_field_sint64\0\u{3}unknown_map_field_sfixed32\0\u{3}unknown_map_field_sfixed64\0") + + 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 101: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.knownMapField) }() + case 102: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapField) }() + case 200: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldInt64) }() + case 201: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldUint64) }() + case 202: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldInt32) }() + case 203: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldUint32) }() + case 204: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldFixed32) }() + case 205: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldFixed64) }() + case 206: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldBool) }() + case 207: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldString) }() + case 208: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSint32) }() + case 209: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSint64) }() + case 210: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSfixed32) }() + case 211: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSfixed64) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.knownMapField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.knownMapField, fieldNumber: 101) + } + if !self.unknownMapField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapField, fieldNumber: 102) + } + if !self.unknownMapFieldInt64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldInt64, fieldNumber: 200) + } + if !self.unknownMapFieldUint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldUint64, fieldNumber: 201) + } + if !self.unknownMapFieldInt32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldInt32, fieldNumber: 202) + } + if !self.unknownMapFieldUint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldUint32, fieldNumber: 203) + } + if !self.unknownMapFieldFixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldFixed32, fieldNumber: 204) + } + if !self.unknownMapFieldFixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldFixed64, fieldNumber: 205) + } + if !self.unknownMapFieldBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldBool, fieldNumber: 206) + } + if !self.unknownMapFieldString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldString, fieldNumber: 207) + } + if !self.unknownMapFieldSint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSint32, fieldNumber: 208) + } + if !self.unknownMapFieldSint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSint64, fieldNumber: 209) + } + if !self.unknownMapFieldSfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSfixed32, fieldNumber: 210) + } + if !self.unknownMapFieldSfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSfixed64, fieldNumber: 211) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestEnumMapPlusExtra, rhs: Proto2Unittest_TestEnumMapPlusExtra) -> Bool { + if lhs.knownMapField != rhs.knownMapField {return false} + if lhs.unknownMapField != rhs.unknownMapField {return false} + if lhs.unknownMapFieldInt64 != rhs.unknownMapFieldInt64 {return false} + if lhs.unknownMapFieldUint64 != rhs.unknownMapFieldUint64 {return false} + if lhs.unknownMapFieldInt32 != rhs.unknownMapFieldInt32 {return false} + if lhs.unknownMapFieldUint32 != rhs.unknownMapFieldUint32 {return false} + if lhs.unknownMapFieldFixed32 != rhs.unknownMapFieldFixed32 {return false} + if lhs.unknownMapFieldFixed64 != rhs.unknownMapFieldFixed64 {return false} + if lhs.unknownMapFieldBool != rhs.unknownMapFieldBool {return false} + if lhs.unknownMapFieldString != rhs.unknownMapFieldString {return false} + if lhs.unknownMapFieldSint32 != rhs.unknownMapFieldSint32 {return false} + if lhs.unknownMapFieldSint64 != rhs.unknownMapFieldSint64 {return false} + if lhs.unknownMapFieldSfixed32 != rhs.unknownMapFieldSfixed32 {return false} + if lhs.unknownMapFieldSfixed64 != rhs.unknownMapFieldSfixed64 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestImportEnumMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestImportEnumMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}import_enum_amp\0") + + 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.importEnumAmp) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.importEnumAmp.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.importEnumAmp, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestImportEnumMap, rhs: Proto2Unittest_TestImportEnumMap) -> Bool { + if lhs.importEnumAmp != rhs.importEnumAmp {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestIntIntMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestIntIntMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}m\0") + + 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.m) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.m.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.m, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestIntIntMap, rhs: Proto2Unittest_TestIntIntMap) -> Bool { + if lhs.m != rhs.m {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMaps: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMaps" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}m_int32\0\u{3}m_int64\0\u{3}m_uint32\0\u{3}m_uint64\0\u{3}m_sint32\0\u{3}m_sint64\0\u{3}m_fixed32\0\u{3}m_fixed64\0\u{3}m_sfixed32\0\u{3}m_sfixed64\0\u{3}m_bool\0\u{3}m_string\0") + + 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mInt32) }() + case 2: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mInt64) }() + case 3: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mUint32) }() + case 4: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mUint64) }() + case 5: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mSint32) }() + case 6: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mSint64) }() + case 7: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mFixed32) }() + case 8: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mFixed64) }() + case 9: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mSfixed32) }() + case 10: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mSfixed64) }() + case 11: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mBool) }() + case 12: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mString) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.mInt32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mInt32, fieldNumber: 1) + } + if !self.mInt64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mInt64, fieldNumber: 2) + } + if !self.mUint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mUint32, fieldNumber: 3) + } + if !self.mUint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mUint64, fieldNumber: 4) + } + if !self.mSint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mSint32, fieldNumber: 5) + } + if !self.mSint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mSint64, fieldNumber: 6) + } + if !self.mFixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mFixed32, fieldNumber: 7) + } + if !self.mFixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mFixed64, fieldNumber: 8) + } + if !self.mSfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mSfixed32, fieldNumber: 9) + } + if !self.mSfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mSfixed64, fieldNumber: 10) + } + if !self.mBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mBool, fieldNumber: 11) + } + if !self.mString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mString, fieldNumber: 12) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMaps, rhs: Proto2Unittest_TestMaps) -> Bool { + if lhs.mInt32 != rhs.mInt32 {return false} + if lhs.mInt64 != rhs.mInt64 {return false} + if lhs.mUint32 != rhs.mUint32 {return false} + if lhs.mUint64 != rhs.mUint64 {return false} + if lhs.mSint32 != rhs.mSint32 {return false} + if lhs.mSint64 != rhs.mSint64 {return false} + if lhs.mFixed32 != rhs.mFixed32 {return false} + if lhs.mFixed64 != rhs.mFixed64 {return false} + if lhs.mSfixed32 != rhs.mSfixed32 {return false} + if lhs.mSfixed64 != rhs.mSfixed64 {return false} + if lhs.mBool != rhs.mBool {return false} + if lhs.mString != rhs.mString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestSubmessageMaps: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestSubmessageMaps" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}m\0") + + 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.decodeSingularMessageField(value: &self._m) }() + 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 + try { if let v = self._m { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestSubmessageMaps, rhs: Proto2Unittest_TestSubmessageMaps) -> Bool { + if lhs._m != rhs._m {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestProto2BytesMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestProto2BytesMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}map_bytes\0\u{3}map_string\0") + + 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.mapBytes) }() + case 2: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.mapString) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.mapBytes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.mapBytes, fieldNumber: 1) + } + if !self.mapString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.mapString, fieldNumber: 2) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestProto2BytesMap, rhs: Proto2Unittest_TestProto2BytesMap) -> Bool { + if lhs.mapBytes != rhs.mapBytes {return false} + if lhs.mapString != rhs.mapString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/map_proto3_unittest.pb.swift b/Reference/upstream/google/protobuf/map_proto3_unittest.pb.swift new file mode 100644 index 000000000..3c8adef80 --- /dev/null +++ b/Reference/upstream/google/protobuf/map_proto3_unittest.pb.swift @@ -0,0 +1,124 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/map_proto3_unittest.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +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 Proto3Unittest_TestProto3BytesMap: Sendable { + // 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 mapBytes: Dictionary = [:] + + var mapString: Dictionary = [:] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Proto3Unittest_TestI32StrMap: Sendable { + // 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 m32Str: Dictionary = [:] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto3_unittest" + +extension Proto3Unittest_TestProto3BytesMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestProto3BytesMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}map_bytes\0\u{3}map_string\0") + + 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.mapBytes) }() + case 2: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.mapString) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.mapBytes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.mapBytes, fieldNumber: 1) + } + if !self.mapString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.mapString, fieldNumber: 2) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto3Unittest_TestProto3BytesMap, rhs: Proto3Unittest_TestProto3BytesMap) -> Bool { + if lhs.mapBytes != rhs.mapBytes {return false} + if lhs.mapString != rhs.mapString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto3Unittest_TestI32StrMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestI32StrMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}m_32_str\0") + + 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.m32Str) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.m32Str.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.m32Str, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto3Unittest_TestI32StrMap, rhs: Proto3Unittest_TestI32StrMap) -> Bool { + if lhs.m32Str != rhs.m32Str {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/google/protobuf/map_unittest.pb.swift b/Reference/upstream/google/protobuf/map_unittest.pb.swift similarity index 65% rename from Reference/google/protobuf/map_unittest.pb.swift rename to Reference/upstream/google/protobuf/map_unittest.pb.swift index b8592f732..79e2374ad 100644 --- a/Reference/google/protobuf/map_unittest.pb.swift +++ b/Reference/upstream/google/protobuf/map_unittest.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/map_unittest.proto @@ -9,33 +10,10 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd import Foundation import SwiftProtobuf @@ -50,7 +28,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum ProtobufUnittest_MapEnum: SwiftProtobuf.Enum { +enum Proto2Unittest_MapEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foo // = 0 case bar // = 1 @@ -79,119 +57,116 @@ enum ProtobufUnittest_MapEnum: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension ProtobufUnittest_MapEnum: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittest_MapEnum] = [ + static let allCases: [Proto2Unittest_MapEnum] = [ .foo, .bar, .baz, ] -} -#endif // swift(>=4.2) +} /// Tests maps. -struct ProtobufUnittest_TestMap { +struct Proto2Unittest_TestMap: @unchecked Sendable { // 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 mapInt32Int32: Dictionary { - get {return _storage._mapInt32Int32} + get {_storage._mapInt32Int32} set {_uniqueStorage()._mapInt32Int32 = newValue} } var mapInt64Int64: Dictionary { - get {return _storage._mapInt64Int64} + get {_storage._mapInt64Int64} set {_uniqueStorage()._mapInt64Int64 = newValue} } var mapUint32Uint32: Dictionary { - get {return _storage._mapUint32Uint32} + get {_storage._mapUint32Uint32} set {_uniqueStorage()._mapUint32Uint32 = newValue} } var mapUint64Uint64: Dictionary { - get {return _storage._mapUint64Uint64} + get {_storage._mapUint64Uint64} set {_uniqueStorage()._mapUint64Uint64 = newValue} } var mapSint32Sint32: Dictionary { - get {return _storage._mapSint32Sint32} + get {_storage._mapSint32Sint32} set {_uniqueStorage()._mapSint32Sint32 = newValue} } var mapSint64Sint64: Dictionary { - get {return _storage._mapSint64Sint64} + get {_storage._mapSint64Sint64} set {_uniqueStorage()._mapSint64Sint64 = newValue} } var mapFixed32Fixed32: Dictionary { - get {return _storage._mapFixed32Fixed32} + get {_storage._mapFixed32Fixed32} set {_uniqueStorage()._mapFixed32Fixed32 = newValue} } var mapFixed64Fixed64: Dictionary { - get {return _storage._mapFixed64Fixed64} + get {_storage._mapFixed64Fixed64} set {_uniqueStorage()._mapFixed64Fixed64 = newValue} } var mapSfixed32Sfixed32: Dictionary { - get {return _storage._mapSfixed32Sfixed32} + get {_storage._mapSfixed32Sfixed32} set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} } var mapSfixed64Sfixed64: Dictionary { - get {return _storage._mapSfixed64Sfixed64} + get {_storage._mapSfixed64Sfixed64} set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} } var mapInt32Float: Dictionary { - get {return _storage._mapInt32Float} + get {_storage._mapInt32Float} set {_uniqueStorage()._mapInt32Float = newValue} } var mapInt32Double: Dictionary { - get {return _storage._mapInt32Double} + get {_storage._mapInt32Double} set {_uniqueStorage()._mapInt32Double = newValue} } var mapBoolBool: Dictionary { - get {return _storage._mapBoolBool} + get {_storage._mapBoolBool} set {_uniqueStorage()._mapBoolBool = newValue} } var mapStringString: Dictionary { - get {return _storage._mapStringString} + get {_storage._mapStringString} set {_uniqueStorage()._mapStringString = newValue} } var mapInt32Bytes: Dictionary { - get {return _storage._mapInt32Bytes} + get {_storage._mapInt32Bytes} set {_uniqueStorage()._mapInt32Bytes = newValue} } - var mapInt32Enum: Dictionary { - get {return _storage._mapInt32Enum} + var mapInt32Enum: Dictionary { + get {_storage._mapInt32Enum} set {_uniqueStorage()._mapInt32Enum = newValue} } - var mapInt32ForeignMessage: Dictionary { - get {return _storage._mapInt32ForeignMessage} + var mapInt32ForeignMessage: Dictionary { + get {_storage._mapInt32ForeignMessage} set {_uniqueStorage()._mapInt32ForeignMessage = newValue} } - var mapStringForeignMessage: Dictionary { - get {return _storage._mapStringForeignMessage} + var mapStringForeignMessage: Dictionary { + get {_storage._mapStringForeignMessage} set {_uniqueStorage()._mapStringForeignMessage = newValue} } - var mapInt32AllTypes: Dictionary { - get {return _storage._mapInt32AllTypes} + /// Caveat emptor: be careful adding new fields here. + /// The TestMap proto is used to generate additional tests and couples tightly + /// with map_test_util.h, which in turn couples tightly with TestMapLite. + var mapInt32AllTypes: Dictionary { + get {_storage._mapInt32AllTypes} set {_uniqueStorage()._mapInt32AllTypes = newValue} } @@ -202,17 +177,51 @@ struct ProtobufUnittest_TestMap { fileprivate var _storage = _StorageClass.defaultInstance } -struct ProtobufUnittest_TestMapSubmessage { +struct Proto2Unittest_TestMapWithMessages: Sendable { + // 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 mapInt32AllTypes: Dictionary = [:] + + var mapInt64AllTypes: Dictionary = [:] + + var mapUint32AllTypes: Dictionary = [:] + + var mapUint64AllTypes: Dictionary = [:] + + var mapSint32AllTypes: Dictionary = [:] + + var mapSint64AllTypes: Dictionary = [:] + + var mapFixed32AllTypes: Dictionary = [:] + + var mapFixed64AllTypes: Dictionary = [:] + + var mapSfixed32AllTypes: Dictionary = [:] + + var mapSfixed64AllTypes: Dictionary = [:] + + var mapBoolAllTypes: Dictionary = [:] + + var mapStringAllTypes: Dictionary = [:] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Proto2Unittest_TestMapSubmessage: Sendable { // 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 testMap: ProtobufUnittest_TestMap { - get {return _testMap ?? ProtobufUnittest_TestMap()} + var testMap: Proto2Unittest_TestMap { + get {_testMap ?? Proto2Unittest_TestMap()} set {_testMap = newValue} } /// Returns true if `testMap` has been explicitly set. - var hasTestMap: Bool {return self._testMap != nil} + var hasTestMap: Bool {self._testMap != nil} /// Clears the value of `testMap`. Subsequent reads from it will return its default value. mutating func clearTestMap() {self._testMap = nil} @@ -220,15 +229,15 @@ struct ProtobufUnittest_TestMapSubmessage { init() {} - fileprivate var _testMap: ProtobufUnittest_TestMap? = nil + fileprivate var _testMap: Proto2Unittest_TestMap? = nil } -struct ProtobufUnittest_TestMessageMap { +struct Proto2Unittest_TestMessageMap: Sendable { // 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 mapInt32Message: Dictionary = [:] + var mapInt32Message: Dictionary = [:] var unknownFields = SwiftProtobuf.UnknownStorage() @@ -236,7 +245,7 @@ struct ProtobufUnittest_TestMessageMap { } /// Two map fields share the same entry default instance. -struct ProtobufUnittest_TestSameTypeMap { +struct Proto2Unittest_TestSameTypeMap: Sendable { // 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. @@ -251,105 +260,105 @@ struct ProtobufUnittest_TestSameTypeMap { } /// Test embedded message with required fields -struct ProtobufUnittest_TestRequiredMessageMap { +struct Proto2Unittest_TestRequiredMessageMap: Sendable { // 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 mapField: Dictionary = [:] + var mapField: Dictionary = [:] var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } -struct ProtobufUnittest_TestArenaMap { +struct Proto2Unittest_TestArenaMap: @unchecked Sendable { // 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 mapInt32Int32: Dictionary { - get {return _storage._mapInt32Int32} + get {_storage._mapInt32Int32} set {_uniqueStorage()._mapInt32Int32 = newValue} } var mapInt64Int64: Dictionary { - get {return _storage._mapInt64Int64} + get {_storage._mapInt64Int64} set {_uniqueStorage()._mapInt64Int64 = newValue} } var mapUint32Uint32: Dictionary { - get {return _storage._mapUint32Uint32} + get {_storage._mapUint32Uint32} set {_uniqueStorage()._mapUint32Uint32 = newValue} } var mapUint64Uint64: Dictionary { - get {return _storage._mapUint64Uint64} + get {_storage._mapUint64Uint64} set {_uniqueStorage()._mapUint64Uint64 = newValue} } var mapSint32Sint32: Dictionary { - get {return _storage._mapSint32Sint32} + get {_storage._mapSint32Sint32} set {_uniqueStorage()._mapSint32Sint32 = newValue} } var mapSint64Sint64: Dictionary { - get {return _storage._mapSint64Sint64} + get {_storage._mapSint64Sint64} set {_uniqueStorage()._mapSint64Sint64 = newValue} } var mapFixed32Fixed32: Dictionary { - get {return _storage._mapFixed32Fixed32} + get {_storage._mapFixed32Fixed32} set {_uniqueStorage()._mapFixed32Fixed32 = newValue} } var mapFixed64Fixed64: Dictionary { - get {return _storage._mapFixed64Fixed64} + get {_storage._mapFixed64Fixed64} set {_uniqueStorage()._mapFixed64Fixed64 = newValue} } var mapSfixed32Sfixed32: Dictionary { - get {return _storage._mapSfixed32Sfixed32} + get {_storage._mapSfixed32Sfixed32} set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} } var mapSfixed64Sfixed64: Dictionary { - get {return _storage._mapSfixed64Sfixed64} + get {_storage._mapSfixed64Sfixed64} set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} } var mapInt32Float: Dictionary { - get {return _storage._mapInt32Float} + get {_storage._mapInt32Float} set {_uniqueStorage()._mapInt32Float = newValue} } var mapInt32Double: Dictionary { - get {return _storage._mapInt32Double} + get {_storage._mapInt32Double} set {_uniqueStorage()._mapInt32Double = newValue} } var mapBoolBool: Dictionary { - get {return _storage._mapBoolBool} + get {_storage._mapBoolBool} set {_uniqueStorage()._mapBoolBool = newValue} } var mapStringString: Dictionary { - get {return _storage._mapStringString} + get {_storage._mapStringString} set {_uniqueStorage()._mapStringString = newValue} } var mapInt32Bytes: Dictionary { - get {return _storage._mapInt32Bytes} + get {_storage._mapInt32Bytes} set {_uniqueStorage()._mapInt32Bytes = newValue} } - var mapInt32Enum: Dictionary { - get {return _storage._mapInt32Enum} + var mapInt32Enum: Dictionary { + get {_storage._mapInt32Enum} set {_uniqueStorage()._mapInt32Enum = newValue} } - var mapInt32ForeignMessage: Dictionary { - get {return _storage._mapInt32ForeignMessage} + var mapInt32ForeignMessage: Dictionary { + get {_storage._mapInt32ForeignMessage} set {_uniqueStorage()._mapInt32ForeignMessage = newValue} } @@ -362,16 +371,16 @@ struct ProtobufUnittest_TestArenaMap { /// Previously, message containing enum called Type cannot be used as value of /// map field. -struct ProtobufUnittest_MessageContainingEnumCalledType { +struct Proto2Unittest_MessageContainingEnumCalledType: Sendable { // 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 type: Dictionary = [:] + var type: Dictionary = [:] var unknownFields = SwiftProtobuf.UnknownStorage() - enum TypeEnum: SwiftProtobuf.Enum { + enum TypeEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foo // = 0 case UNRECOGNIZED(Int) @@ -394,24 +403,18 @@ struct ProtobufUnittest_MessageContainingEnumCalledType { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Proto2Unittest_MessageContainingEnumCalledType.TypeEnum] = [ + .foo, + ] + } init() {} } -#if swift(>=4.2) - -extension ProtobufUnittest_MessageContainingEnumCalledType.TypeEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittest_MessageContainingEnumCalledType.TypeEnum] = [ - .foo, - ] -} - -#endif // swift(>=4.2) - /// Previously, message cannot contain map field called "entry". -struct ProtobufUnittest_MessageContainingMapCalledEntry { +struct Proto2Unittest_MessageContainingMapCalledEntry: Sendable { // 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. @@ -423,67 +426,41 @@ struct ProtobufUnittest_MessageContainingMapCalledEntry { init() {} } -struct ProtobufUnittest_TestRecursiveMapMessage { +struct Proto2Unittest_TestRecursiveMapMessage: Sendable { // 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 a: Dictionary = [:] + var a: Dictionary = [:] var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_MapEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestMap: @unchecked Sendable {} -extension ProtobufUnittest_TestMapSubmessage: @unchecked Sendable {} -extension ProtobufUnittest_TestMessageMap: @unchecked Sendable {} -extension ProtobufUnittest_TestSameTypeMap: @unchecked Sendable {} -extension ProtobufUnittest_TestRequiredMessageMap: @unchecked Sendable {} -extension ProtobufUnittest_TestArenaMap: @unchecked Sendable {} -extension ProtobufUnittest_MessageContainingEnumCalledType: @unchecked Sendable {} -extension ProtobufUnittest_MessageContainingEnumCalledType.TypeEnum: @unchecked Sendable {} -extension ProtobufUnittest_MessageContainingMapCalledEntry: @unchecked Sendable {} -extension ProtobufUnittest_TestRecursiveMapMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) +struct Proto2Unittest_TestI32StrMap: Sendable { + // 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 m32Str: Dictionary = [:] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "proto2_unittest" -extension ProtobufUnittest_MapEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "MAP_ENUM_FOO"), - 1: .same(proto: "MAP_ENUM_BAR"), - 2: .same(proto: "MAP_ENUM_BAZ"), - ] +extension Proto2Unittest_MapEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0MAP_ENUM_FOO\0\u{1}MAP_ENUM_BAR\0\u{1}MAP_ENUM_BAZ\0") } -extension ProtobufUnittest_TestMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "map_int32_int32"), - 2: .standard(proto: "map_int64_int64"), - 3: .standard(proto: "map_uint32_uint32"), - 4: .standard(proto: "map_uint64_uint64"), - 5: .standard(proto: "map_sint32_sint32"), - 6: .standard(proto: "map_sint64_sint64"), - 7: .standard(proto: "map_fixed32_fixed32"), - 8: .standard(proto: "map_fixed64_fixed64"), - 9: .standard(proto: "map_sfixed32_sfixed32"), - 10: .standard(proto: "map_sfixed64_sfixed64"), - 11: .standard(proto: "map_int32_float"), - 12: .standard(proto: "map_int32_double"), - 13: .standard(proto: "map_bool_bool"), - 14: .standard(proto: "map_string_string"), - 15: .standard(proto: "map_int32_bytes"), - 16: .standard(proto: "map_int32_enum"), - 17: .standard(proto: "map_int32_foreign_message"), - 18: .standard(proto: "map_string_foreign_message"), - 19: .standard(proto: "map_int32_all_types"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_int32_bytes\0\u{3}map_int32_enum\0\u{3}map_int32_foreign_message\0\u{3}map_string_foreign_message\0\u{3}map_int32_all_types\0") fileprivate class _StorageClass { var _mapInt32Int32: Dictionary = [:] @@ -501,12 +478,16 @@ extension ProtobufUnittest_TestMap: SwiftProtobuf.Message, SwiftProtobuf._Messag var _mapBoolBool: Dictionary = [:] var _mapStringString: Dictionary = [:] var _mapInt32Bytes: Dictionary = [:] - var _mapInt32Enum: Dictionary = [:] - var _mapInt32ForeignMessage: Dictionary = [:] - var _mapStringForeignMessage: Dictionary = [:] - var _mapInt32AllTypes: Dictionary = [:] + var _mapInt32Enum: Dictionary = [:] + var _mapInt32ForeignMessage: Dictionary = [:] + var _mapStringForeignMessage: Dictionary = [:] + var _mapInt32AllTypes: Dictionary = [:] - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -563,10 +544,10 @@ extension ProtobufUnittest_TestMap: SwiftProtobuf.Message, SwiftProtobuf._Messag case 13: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() case 14: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() case 15: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bytes) }() - case 16: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() - case 17: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32ForeignMessage) }() - case 18: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() - case 19: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32AllTypes) }() + case 16: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() + case 17: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32ForeignMessage) }() + case 18: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() + case 19: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32AllTypes) }() default: break } } @@ -621,22 +602,22 @@ extension ProtobufUnittest_TestMap: SwiftProtobuf.Message, SwiftProtobuf._Messag try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bytes, fieldNumber: 15) } if !_storage._mapInt32Enum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 16) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 16) } if !_storage._mapInt32ForeignMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32ForeignMessage, fieldNumber: 17) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32ForeignMessage, fieldNumber: 17) } if !_storage._mapStringForeignMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 18) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 18) } if !_storage._mapInt32AllTypes.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32AllTypes, fieldNumber: 19) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32AllTypes, fieldNumber: 19) } } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestMap, rhs: ProtobufUnittest_TestMap) -> Bool { + static func ==(lhs: Proto2Unittest_TestMap, rhs: Proto2Unittest_TestMap) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -669,11 +650,94 @@ extension ProtobufUnittest_TestMap: SwiftProtobuf.Message, SwiftProtobuf._Messag } } -extension ProtobufUnittest_TestMapSubmessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestMapWithMessages: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMapWithMessages" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}map_int32_all_types\0\u{3}map_int64_all_types\0\u{3}map_uint32_all_types\0\u{3}map_uint64_all_types\0\u{3}map_sint32_all_types\0\u{3}map_sint64_all_types\0\u{3}map_fixed32_all_types\0\u{3}map_fixed64_all_types\0\u{3}map_sfixed32_all_types\0\u{3}map_sfixed64_all_types\0\u{3}map_bool_all_types\0\u{3}map_string_all_types\0") + + 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapInt32AllTypes) }() + case 2: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapInt64AllTypes) }() + case 3: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapUint32AllTypes) }() + case 4: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapUint64AllTypes) }() + case 5: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapSint32AllTypes) }() + case 6: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapSint64AllTypes) }() + case 7: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapFixed32AllTypes) }() + case 8: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapFixed64AllTypes) }() + case 9: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapSfixed32AllTypes) }() + case 10: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapSfixed64AllTypes) }() + case 11: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapBoolAllTypes) }() + case 12: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapStringAllTypes) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.mapInt32AllTypes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapInt32AllTypes, fieldNumber: 1) + } + if !self.mapInt64AllTypes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapInt64AllTypes, fieldNumber: 2) + } + if !self.mapUint32AllTypes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapUint32AllTypes, fieldNumber: 3) + } + if !self.mapUint64AllTypes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapUint64AllTypes, fieldNumber: 4) + } + if !self.mapSint32AllTypes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapSint32AllTypes, fieldNumber: 5) + } + if !self.mapSint64AllTypes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapSint64AllTypes, fieldNumber: 6) + } + if !self.mapFixed32AllTypes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapFixed32AllTypes, fieldNumber: 7) + } + if !self.mapFixed64AllTypes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapFixed64AllTypes, fieldNumber: 8) + } + if !self.mapSfixed32AllTypes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapSfixed32AllTypes, fieldNumber: 9) + } + if !self.mapSfixed64AllTypes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapSfixed64AllTypes, fieldNumber: 10) + } + if !self.mapBoolAllTypes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapBoolAllTypes, fieldNumber: 11) + } + if !self.mapStringAllTypes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapStringAllTypes, fieldNumber: 12) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMapWithMessages, rhs: Proto2Unittest_TestMapWithMessages) -> Bool { + if lhs.mapInt32AllTypes != rhs.mapInt32AllTypes {return false} + if lhs.mapInt64AllTypes != rhs.mapInt64AllTypes {return false} + if lhs.mapUint32AllTypes != rhs.mapUint32AllTypes {return false} + if lhs.mapUint64AllTypes != rhs.mapUint64AllTypes {return false} + if lhs.mapSint32AllTypes != rhs.mapSint32AllTypes {return false} + if lhs.mapSint64AllTypes != rhs.mapSint64AllTypes {return false} + if lhs.mapFixed32AllTypes != rhs.mapFixed32AllTypes {return false} + if lhs.mapFixed64AllTypes != rhs.mapFixed64AllTypes {return false} + if lhs.mapSfixed32AllTypes != rhs.mapSfixed32AllTypes {return false} + if lhs.mapSfixed64AllTypes != rhs.mapSfixed64AllTypes {return false} + if lhs.mapBoolAllTypes != rhs.mapBoolAllTypes {return false} + if lhs.mapStringAllTypes != rhs.mapStringAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMapSubmessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestMapSubmessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "test_map"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}test_map\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -698,18 +762,16 @@ extension ProtobufUnittest_TestMapSubmessage: SwiftProtobuf.Message, SwiftProtob try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestMapSubmessage, rhs: ProtobufUnittest_TestMapSubmessage) -> Bool { + static func ==(lhs: Proto2Unittest_TestMapSubmessage, rhs: Proto2Unittest_TestMapSubmessage) -> Bool { if lhs._testMap != rhs._testMap {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestMessageMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestMessageMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestMessageMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "map_int32_message"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}map_int32_message\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -717,7 +779,7 @@ extension ProtobufUnittest_TestMessageMap: SwiftProtobuf.Message, SwiftProtobuf. // 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapInt32Message) }() + case 1: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapInt32Message) }() default: break } } @@ -725,24 +787,21 @@ extension ProtobufUnittest_TestMessageMap: SwiftProtobuf.Message, SwiftProtobuf. func traverse(visitor: inout V) throws { if !self.mapInt32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapInt32Message, fieldNumber: 1) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapInt32Message, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestMessageMap, rhs: ProtobufUnittest_TestMessageMap) -> Bool { + static func ==(lhs: Proto2Unittest_TestMessageMap, rhs: Proto2Unittest_TestMessageMap) -> Bool { if lhs.mapInt32Message != rhs.mapInt32Message {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestSameTypeMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestSameTypeMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestSameTypeMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "map1"), - 2: .same(proto: "map2"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}map1\0\u{1}map2\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -767,7 +826,7 @@ extension ProtobufUnittest_TestSameTypeMap: SwiftProtobuf.Message, SwiftProtobuf try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestSameTypeMap, rhs: ProtobufUnittest_TestSameTypeMap) -> Bool { + static func ==(lhs: Proto2Unittest_TestSameTypeMap, rhs: Proto2Unittest_TestSameTypeMap) -> Bool { if lhs.map1 != rhs.map1 {return false} if lhs.map2 != rhs.map2 {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -775,11 +834,9 @@ extension ProtobufUnittest_TestSameTypeMap: SwiftProtobuf.Message, SwiftProtobuf } } -extension ProtobufUnittest_TestRequiredMessageMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestRequiredMessageMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestRequiredMessageMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "map_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}map_field\0") public var isInitialized: Bool { if !SwiftProtobuf.Internal.areAllInitialized(self.mapField) {return false} @@ -792,7 +849,7 @@ extension ProtobufUnittest_TestRequiredMessageMap: SwiftProtobuf.Message, SwiftP // 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapField) }() + case 1: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapField) }() default: break } } @@ -800,39 +857,21 @@ extension ProtobufUnittest_TestRequiredMessageMap: SwiftProtobuf.Message, SwiftP func traverse(visitor: inout V) throws { if !self.mapField.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapField, fieldNumber: 1) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestRequiredMessageMap, rhs: ProtobufUnittest_TestRequiredMessageMap) -> Bool { + static func ==(lhs: Proto2Unittest_TestRequiredMessageMap, rhs: Proto2Unittest_TestRequiredMessageMap) -> Bool { if lhs.mapField != rhs.mapField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestArenaMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestArenaMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestArenaMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "map_int32_int32"), - 2: .standard(proto: "map_int64_int64"), - 3: .standard(proto: "map_uint32_uint32"), - 4: .standard(proto: "map_uint64_uint64"), - 5: .standard(proto: "map_sint32_sint32"), - 6: .standard(proto: "map_sint64_sint64"), - 7: .standard(proto: "map_fixed32_fixed32"), - 8: .standard(proto: "map_fixed64_fixed64"), - 9: .standard(proto: "map_sfixed32_sfixed32"), - 10: .standard(proto: "map_sfixed64_sfixed64"), - 11: .standard(proto: "map_int32_float"), - 12: .standard(proto: "map_int32_double"), - 13: .standard(proto: "map_bool_bool"), - 14: .standard(proto: "map_string_string"), - 15: .standard(proto: "map_int32_bytes"), - 16: .standard(proto: "map_int32_enum"), - 17: .standard(proto: "map_int32_foreign_message"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_int32_bytes\0\u{3}map_int32_enum\0\u{3}map_int32_foreign_message\0") fileprivate class _StorageClass { var _mapInt32Int32: Dictionary = [:] @@ -850,10 +889,14 @@ extension ProtobufUnittest_TestArenaMap: SwiftProtobuf.Message, SwiftProtobuf._M var _mapBoolBool: Dictionary = [:] var _mapStringString: Dictionary = [:] var _mapInt32Bytes: Dictionary = [:] - var _mapInt32Enum: Dictionary = [:] - var _mapInt32ForeignMessage: Dictionary = [:] + var _mapInt32Enum: Dictionary = [:] + var _mapInt32ForeignMessage: Dictionary = [:] - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -908,8 +951,8 @@ extension ProtobufUnittest_TestArenaMap: SwiftProtobuf.Message, SwiftProtobuf._M case 13: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() case 14: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() case 15: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bytes) }() - case 16: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() - case 17: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32ForeignMessage) }() + case 16: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() + case 17: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32ForeignMessage) }() default: break } } @@ -964,16 +1007,16 @@ extension ProtobufUnittest_TestArenaMap: SwiftProtobuf.Message, SwiftProtobuf._M try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bytes, fieldNumber: 15) } if !_storage._mapInt32Enum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 16) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 16) } if !_storage._mapInt32ForeignMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32ForeignMessage, fieldNumber: 17) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32ForeignMessage, fieldNumber: 17) } } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestArenaMap, rhs: ProtobufUnittest_TestArenaMap) -> Bool { + static func ==(lhs: Proto2Unittest_TestArenaMap, rhs: Proto2Unittest_TestArenaMap) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -1004,11 +1047,9 @@ extension ProtobufUnittest_TestArenaMap: SwiftProtobuf.Message, SwiftProtobuf._M } } -extension ProtobufUnittest_MessageContainingEnumCalledType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_MessageContainingEnumCalledType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MessageContainingEnumCalledType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "type"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}type\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1016,7 +1057,7 @@ extension ProtobufUnittest_MessageContainingEnumCalledType: SwiftProtobuf.Messag // 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.type) }() + case 1: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.type) }() default: break } } @@ -1024,29 +1065,25 @@ extension ProtobufUnittest_MessageContainingEnumCalledType: SwiftProtobuf.Messag func traverse(visitor: inout V) throws { if !self.type.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.type, fieldNumber: 1) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.type, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_MessageContainingEnumCalledType, rhs: ProtobufUnittest_MessageContainingEnumCalledType) -> Bool { + static func ==(lhs: Proto2Unittest_MessageContainingEnumCalledType, rhs: Proto2Unittest_MessageContainingEnumCalledType) -> Bool { if lhs.type != rhs.type {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_MessageContainingEnumCalledType.TypeEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "TYPE_FOO"), - ] +extension Proto2Unittest_MessageContainingEnumCalledType.TypeEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0TYPE_FOO\0") } -extension ProtobufUnittest_MessageContainingMapCalledEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_MessageContainingMapCalledEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MessageContainingMapCalledEntry" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "entry"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}entry\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1067,18 +1104,16 @@ extension ProtobufUnittest_MessageContainingMapCalledEntry: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_MessageContainingMapCalledEntry, rhs: ProtobufUnittest_MessageContainingMapCalledEntry) -> Bool { + static func ==(lhs: Proto2Unittest_MessageContainingMapCalledEntry, rhs: Proto2Unittest_MessageContainingMapCalledEntry) -> Bool { if lhs.entry != rhs.entry {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestRecursiveMapMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestRecursiveMapMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestRecursiveMapMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1086,7 +1121,7 @@ extension ProtobufUnittest_TestRecursiveMapMessage: SwiftProtobuf.Message, Swift // 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.a) }() + case 1: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.a) }() default: break } } @@ -1094,14 +1129,44 @@ extension ProtobufUnittest_TestRecursiveMapMessage: SwiftProtobuf.Message, Swift func traverse(visitor: inout V) throws { if !self.a.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.a, fieldNumber: 1) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.a, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestRecursiveMapMessage, rhs: ProtobufUnittest_TestRecursiveMapMessage) -> Bool { + static func ==(lhs: Proto2Unittest_TestRecursiveMapMessage, rhs: Proto2Unittest_TestRecursiveMapMessage) -> Bool { if lhs.a != rhs.a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } + +extension Proto2Unittest_TestI32StrMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestI32StrMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}m_32_str\0") + + 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.m32Str) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.m32Str.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.m32Str, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestI32StrMap, rhs: Proto2Unittest_TestI32StrMap) -> Bool { + if lhs.m32Str != rhs.m32Str {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/only_one_enum_test.pb.swift b/Reference/upstream/google/protobuf/only_one_enum_test.pb.swift new file mode 100644 index 000000000..48a4acc2c --- /dev/null +++ b/Reference/upstream/google/protobuf/only_one_enum_test.pb.swift @@ -0,0 +1,61 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/only_one_enum_test.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +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 Proto2Unittest_OnlyOneEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case `default` // = 0 + case valid // = 10 + case UNRECOGNIZED(Int) + + init() { + self = .default + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .default + case 10: self = .valid + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .default: return 0 + case .valid: return 10 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Proto2Unittest_OnlyOneEnum] = [ + .default, + .valid, + ] + +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension Proto2Unittest_OnlyOneEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ONLY_ONE_ENUM_DEFAULT\0\u{2}\u{a}ONLY_ONE_ENUM_VALID\0") +} diff --git a/Reference/upstream/google/protobuf/sample_messages_edition.pb.swift b/Reference/upstream/google/protobuf/sample_messages_edition.pb.swift new file mode 100644 index 000000000..7c1cb5622 --- /dev/null +++ b/Reference/upstream/google/protobuf/sample_messages_edition.pb.swift @@ -0,0 +1,4273 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/sample_messages_edition.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Sample messages to generate example code. + +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 ProtobufTestMessages_Edition_ForeignEnumEdition: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foreignFoo // = 0 + case foreignBar // = 1 + case foreignBaz // = 2 + case UNRECOGNIZED(Int) + + init() { + self = .foreignFoo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .foreignFoo + case 1: self = .foreignBar + case 2: self = .foreignBaz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .foreignFoo: return 0 + case .foreignBar: return 1 + case .foreignBaz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Edition_ForeignEnumEdition] = [ + .foreignFoo, + .foreignBar, + .foreignBaz, + ] + +} + +/// This proto includes every type of field in both singular and repeated +/// forms. +/// +/// Also, crucially, all messages and enums in this file are eventually +/// submessages of this message. So for example, a fuzz test of TestAllTypes +/// could trigger bugs that occur in any message type in this file. We verify +/// this stays true in a unit test. +struct ProtobufTestMessages_Edition_TestAllTypesEdition: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Singular + var optionalInt32: Int32 { + get {_storage._optionalInt32 ?? 0} + set {_uniqueStorage()._optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} + + var optionalInt64: Int64 { + get {_storage._optionalInt64 ?? 0} + set {_uniqueStorage()._optionalInt64 = newValue} + } + /// Returns true if `optionalInt64` has been explicitly set. + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} + /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} + + var optionalUint32: UInt32 { + get {_storage._optionalUint32 ?? 0} + set {_uniqueStorage()._optionalUint32 = newValue} + } + /// Returns true if `optionalUint32` has been explicitly set. + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} + /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} + + var optionalUint64: UInt64 { + get {_storage._optionalUint64 ?? 0} + set {_uniqueStorage()._optionalUint64 = newValue} + } + /// Returns true if `optionalUint64` has been explicitly set. + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} + /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} + + var optionalSint32: Int32 { + get {_storage._optionalSint32 ?? 0} + set {_uniqueStorage()._optionalSint32 = newValue} + } + /// Returns true if `optionalSint32` has been explicitly set. + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} + /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} + + var optionalSint64: Int64 { + get {_storage._optionalSint64 ?? 0} + set {_uniqueStorage()._optionalSint64 = newValue} + } + /// Returns true if `optionalSint64` has been explicitly set. + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} + /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} + + var optionalFixed32: UInt32 { + get {_storage._optionalFixed32 ?? 0} + set {_uniqueStorage()._optionalFixed32 = newValue} + } + /// Returns true if `optionalFixed32` has been explicitly set. + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} + /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} + + var optionalFixed64: UInt64 { + get {_storage._optionalFixed64 ?? 0} + set {_uniqueStorage()._optionalFixed64 = newValue} + } + /// Returns true if `optionalFixed64` has been explicitly set. + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} + /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} + + var optionalSfixed32: Int32 { + get {_storage._optionalSfixed32 ?? 0} + set {_uniqueStorage()._optionalSfixed32 = newValue} + } + /// Returns true if `optionalSfixed32` has been explicitly set. + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} + /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} + + var optionalSfixed64: Int64 { + get {_storage._optionalSfixed64 ?? 0} + set {_uniqueStorage()._optionalSfixed64 = newValue} + } + /// Returns true if `optionalSfixed64` has been explicitly set. + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} + /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} + + var optionalFloat: Float { + get {_storage._optionalFloat ?? 0} + set {_uniqueStorage()._optionalFloat = newValue} + } + /// Returns true if `optionalFloat` has been explicitly set. + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} + /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} + + var optionalDouble: Double { + get {_storage._optionalDouble ?? 0} + set {_uniqueStorage()._optionalDouble = newValue} + } + /// Returns true if `optionalDouble` has been explicitly set. + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} + /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. + mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} + + var optionalBool: Bool { + get {_storage._optionalBool ?? false} + set {_uniqueStorage()._optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {_storage._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} + + var optionalString: String { + get {_storage._optionalString ?? String()} + set {_uniqueStorage()._optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {_storage._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} + + var optionalBytes: Data { + get {_storage._optionalBytes ?? Data()} + set {_uniqueStorage()._optionalBytes = newValue} + } + /// Returns true if `optionalBytes` has been explicitly set. + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} + /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} + + var optionalNestedMessage: ProtobufTestMessages_Edition_TestAllTypesEdition.NestedMessage { + get {_storage._optionalNestedMessage ?? ProtobufTestMessages_Edition_TestAllTypesEdition.NestedMessage()} + set {_uniqueStorage()._optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} + + var optionalForeignMessage: ProtobufTestMessages_Edition_ForeignMessageEdition { + get {_storage._optionalForeignMessage ?? ProtobufTestMessages_Edition_ForeignMessageEdition()} + set {_uniqueStorage()._optionalForeignMessage = newValue} + } + /// Returns true if `optionalForeignMessage` has been explicitly set. + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} + /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} + + var optionalNestedEnum: ProtobufTestMessages_Edition_TestAllTypesEdition.NestedEnum { + get {_storage._optionalNestedEnum ?? .foo} + set {_uniqueStorage()._optionalNestedEnum = newValue} + } + /// Returns true if `optionalNestedEnum` has been explicitly set. + var hasOptionalNestedEnum: Bool {_storage._optionalNestedEnum != nil} + /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} + + var optionalForeignEnum: ProtobufTestMessages_Edition_ForeignEnumEdition { + get {_storage._optionalForeignEnum ?? .foreignFoo} + set {_uniqueStorage()._optionalForeignEnum = newValue} + } + /// Returns true if `optionalForeignEnum` has been explicitly set. + var hasOptionalForeignEnum: Bool {_storage._optionalForeignEnum != nil} + /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignEnum() {_uniqueStorage()._optionalForeignEnum = nil} + + var optionalStringPiece: String { + get {_storage._optionalStringPiece ?? String()} + set {_uniqueStorage()._optionalStringPiece = newValue} + } + /// Returns true if `optionalStringPiece` has been explicitly set. + var hasOptionalStringPiece: Bool {_storage._optionalStringPiece != nil} + /// Clears the value of `optionalStringPiece`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringPiece() {_uniqueStorage()._optionalStringPiece = nil} + + var optionalCord: String { + get {_storage._optionalCord ?? String()} + set {_uniqueStorage()._optionalCord = newValue} + } + /// Returns true if `optionalCord` has been explicitly set. + var hasOptionalCord: Bool {_storage._optionalCord != nil} + /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. + mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} + + var recursiveMessage: ProtobufTestMessages_Edition_TestAllTypesEdition { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Edition_TestAllTypesEdition()} + set {_uniqueStorage()._recursiveMessage = newValue} + } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} + + /// Repeated + var repeatedInt32: [Int32] { + get {_storage._repeatedInt32} + set {_uniqueStorage()._repeatedInt32 = newValue} + } + + var repeatedInt64: [Int64] { + get {_storage._repeatedInt64} + set {_uniqueStorage()._repeatedInt64 = newValue} + } + + var repeatedUint32: [UInt32] { + get {_storage._repeatedUint32} + set {_uniqueStorage()._repeatedUint32 = newValue} + } + + var repeatedUint64: [UInt64] { + get {_storage._repeatedUint64} + set {_uniqueStorage()._repeatedUint64 = newValue} + } + + var repeatedSint32: [Int32] { + get {_storage._repeatedSint32} + set {_uniqueStorage()._repeatedSint32 = newValue} + } + + var repeatedSint64: [Int64] { + get {_storage._repeatedSint64} + set {_uniqueStorage()._repeatedSint64 = newValue} + } + + var repeatedFixed32: [UInt32] { + get {_storage._repeatedFixed32} + set {_uniqueStorage()._repeatedFixed32 = newValue} + } + + var repeatedFixed64: [UInt64] { + get {_storage._repeatedFixed64} + set {_uniqueStorage()._repeatedFixed64 = newValue} + } + + var repeatedSfixed32: [Int32] { + get {_storage._repeatedSfixed32} + set {_uniqueStorage()._repeatedSfixed32 = newValue} + } + + var repeatedSfixed64: [Int64] { + get {_storage._repeatedSfixed64} + set {_uniqueStorage()._repeatedSfixed64 = newValue} + } + + var repeatedFloat: [Float] { + get {_storage._repeatedFloat} + set {_uniqueStorage()._repeatedFloat = newValue} + } + + var repeatedDouble: [Double] { + get {_storage._repeatedDouble} + set {_uniqueStorage()._repeatedDouble = newValue} + } + + var repeatedBool: [Bool] { + get {_storage._repeatedBool} + set {_uniqueStorage()._repeatedBool = newValue} + } + + var repeatedString: [String] { + get {_storage._repeatedString} + set {_uniqueStorage()._repeatedString = newValue} + } + + var repeatedBytes: [Data] { + get {_storage._repeatedBytes} + set {_uniqueStorage()._repeatedBytes = newValue} + } + + var repeatedNestedMessage: [ProtobufTestMessages_Edition_TestAllTypesEdition.NestedMessage] { + get {_storage._repeatedNestedMessage} + set {_uniqueStorage()._repeatedNestedMessage = newValue} + } + + var repeatedForeignMessage: [ProtobufTestMessages_Edition_ForeignMessageEdition] { + get {_storage._repeatedForeignMessage} + set {_uniqueStorage()._repeatedForeignMessage = newValue} + } + + var repeatedNestedEnum: [ProtobufTestMessages_Edition_TestAllTypesEdition.NestedEnum] { + get {_storage._repeatedNestedEnum} + set {_uniqueStorage()._repeatedNestedEnum = newValue} + } + + var repeatedForeignEnum: [ProtobufTestMessages_Edition_ForeignEnumEdition] { + get {_storage._repeatedForeignEnum} + set {_uniqueStorage()._repeatedForeignEnum = newValue} + } + + var repeatedStringPiece: [String] { + get {_storage._repeatedStringPiece} + set {_uniqueStorage()._repeatedStringPiece = newValue} + } + + var repeatedCord: [String] { + get {_storage._repeatedCord} + set {_uniqueStorage()._repeatedCord = newValue} + } + + /// Packed + var packedInt32: [Int32] { + get {_storage._packedInt32} + set {_uniqueStorage()._packedInt32 = newValue} + } + + var packedInt64: [Int64] { + get {_storage._packedInt64} + set {_uniqueStorage()._packedInt64 = newValue} + } + + var packedUint32: [UInt32] { + get {_storage._packedUint32} + set {_uniqueStorage()._packedUint32 = newValue} + } + + var packedUint64: [UInt64] { + get {_storage._packedUint64} + set {_uniqueStorage()._packedUint64 = newValue} + } + + var packedSint32: [Int32] { + get {_storage._packedSint32} + set {_uniqueStorage()._packedSint32 = newValue} + } + + var packedSint64: [Int64] { + get {_storage._packedSint64} + set {_uniqueStorage()._packedSint64 = newValue} + } + + var packedFixed32: [UInt32] { + get {_storage._packedFixed32} + set {_uniqueStorage()._packedFixed32 = newValue} + } + + var packedFixed64: [UInt64] { + get {_storage._packedFixed64} + set {_uniqueStorage()._packedFixed64 = newValue} + } + + var packedSfixed32: [Int32] { + get {_storage._packedSfixed32} + set {_uniqueStorage()._packedSfixed32 = newValue} + } + + var packedSfixed64: [Int64] { + get {_storage._packedSfixed64} + set {_uniqueStorage()._packedSfixed64 = newValue} + } + + var packedFloat: [Float] { + get {_storage._packedFloat} + set {_uniqueStorage()._packedFloat = newValue} + } + + var packedDouble: [Double] { + get {_storage._packedDouble} + set {_uniqueStorage()._packedDouble = newValue} + } + + var packedBool: [Bool] { + get {_storage._packedBool} + set {_uniqueStorage()._packedBool = newValue} + } + + var packedNestedEnum: [ProtobufTestMessages_Edition_TestAllTypesEdition.NestedEnum] { + get {_storage._packedNestedEnum} + set {_uniqueStorage()._packedNestedEnum = newValue} + } + + /// Unpacked + var unpackedInt32: [Int32] { + get {_storage._unpackedInt32} + set {_uniqueStorage()._unpackedInt32 = newValue} + } + + var unpackedInt64: [Int64] { + get {_storage._unpackedInt64} + set {_uniqueStorage()._unpackedInt64 = newValue} + } + + var unpackedUint32: [UInt32] { + get {_storage._unpackedUint32} + set {_uniqueStorage()._unpackedUint32 = newValue} + } + + var unpackedUint64: [UInt64] { + get {_storage._unpackedUint64} + set {_uniqueStorage()._unpackedUint64 = newValue} + } + + var unpackedSint32: [Int32] { + get {_storage._unpackedSint32} + set {_uniqueStorage()._unpackedSint32 = newValue} + } + + var unpackedSint64: [Int64] { + get {_storage._unpackedSint64} + set {_uniqueStorage()._unpackedSint64 = newValue} + } + + var unpackedFixed32: [UInt32] { + get {_storage._unpackedFixed32} + set {_uniqueStorage()._unpackedFixed32 = newValue} + } + + var unpackedFixed64: [UInt64] { + get {_storage._unpackedFixed64} + set {_uniqueStorage()._unpackedFixed64 = newValue} + } + + var unpackedSfixed32: [Int32] { + get {_storage._unpackedSfixed32} + set {_uniqueStorage()._unpackedSfixed32 = newValue} + } + + var unpackedSfixed64: [Int64] { + get {_storage._unpackedSfixed64} + set {_uniqueStorage()._unpackedSfixed64 = newValue} + } + + var unpackedFloat: [Float] { + get {_storage._unpackedFloat} + set {_uniqueStorage()._unpackedFloat = newValue} + } + + var unpackedDouble: [Double] { + get {_storage._unpackedDouble} + set {_uniqueStorage()._unpackedDouble = newValue} + } + + var unpackedBool: [Bool] { + get {_storage._unpackedBool} + set {_uniqueStorage()._unpackedBool = newValue} + } + + var unpackedNestedEnum: [ProtobufTestMessages_Edition_TestAllTypesEdition.NestedEnum] { + get {_storage._unpackedNestedEnum} + set {_uniqueStorage()._unpackedNestedEnum = newValue} + } + + /// Map + var mapInt32Int32: Dictionary { + get {_storage._mapInt32Int32} + set {_uniqueStorage()._mapInt32Int32 = newValue} + } + + var mapInt64Int64: Dictionary { + get {_storage._mapInt64Int64} + set {_uniqueStorage()._mapInt64Int64 = newValue} + } + + var mapUint32Uint32: Dictionary { + get {_storage._mapUint32Uint32} + set {_uniqueStorage()._mapUint32Uint32 = newValue} + } + + var mapUint64Uint64: Dictionary { + get {_storage._mapUint64Uint64} + set {_uniqueStorage()._mapUint64Uint64 = newValue} + } + + var mapSint32Sint32: Dictionary { + get {_storage._mapSint32Sint32} + set {_uniqueStorage()._mapSint32Sint32 = newValue} + } + + var mapSint64Sint64: Dictionary { + get {_storage._mapSint64Sint64} + set {_uniqueStorage()._mapSint64Sint64 = newValue} + } + + var mapFixed32Fixed32: Dictionary { + get {_storage._mapFixed32Fixed32} + set {_uniqueStorage()._mapFixed32Fixed32 = newValue} + } + + var mapFixed64Fixed64: Dictionary { + get {_storage._mapFixed64Fixed64} + set {_uniqueStorage()._mapFixed64Fixed64 = newValue} + } + + var mapSfixed32Sfixed32: Dictionary { + get {_storage._mapSfixed32Sfixed32} + set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} + } + + var mapSfixed64Sfixed64: Dictionary { + get {_storage._mapSfixed64Sfixed64} + set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} + } + + var mapInt32Float: Dictionary { + get {_storage._mapInt32Float} + set {_uniqueStorage()._mapInt32Float = newValue} + } + + var mapInt32Double: Dictionary { + get {_storage._mapInt32Double} + set {_uniqueStorage()._mapInt32Double = newValue} + } + + var mapBoolBool: Dictionary { + get {_storage._mapBoolBool} + set {_uniqueStorage()._mapBoolBool = newValue} + } + + var mapStringString: Dictionary { + get {_storage._mapStringString} + set {_uniqueStorage()._mapStringString = newValue} + } + + var mapStringBytes: Dictionary { + get {_storage._mapStringBytes} + set {_uniqueStorage()._mapStringBytes = newValue} + } + + var mapStringNestedMessage: Dictionary { + get {_storage._mapStringNestedMessage} + set {_uniqueStorage()._mapStringNestedMessage = newValue} + } + + var mapStringForeignMessage: Dictionary { + get {_storage._mapStringForeignMessage} + set {_uniqueStorage()._mapStringForeignMessage = newValue} + } + + var mapStringNestedEnum: Dictionary { + get {_storage._mapStringNestedEnum} + set {_uniqueStorage()._mapStringNestedEnum = newValue} + } + + var mapStringForeignEnum: Dictionary { + get {_storage._mapStringForeignEnum} + set {_uniqueStorage()._mapStringForeignEnum = newValue} + } + + var oneofField: OneOf_OneofField? { + get {return _storage._oneofField} + set {_uniqueStorage()._oneofField = newValue} + } + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} + } + + var oneofNestedMessage: ProtobufTestMessages_Edition_TestAllTypesEdition.NestedMessage { + get { + if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} + return ProtobufTestMessages_Edition_TestAllTypesEdition.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = _storage._oneofField {return v} + return Data() + } + set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} + } + + var oneofBool: Bool { + get { + if case .oneofBool(let v)? = _storage._oneofField {return v} + return false + } + set {_uniqueStorage()._oneofField = .oneofBool(newValue)} + } + + var oneofUint64: UInt64 { + get { + if case .oneofUint64(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint64(newValue)} + } + + var oneofFloat: Float { + get { + if case .oneofFloat(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofFloat(newValue)} + } + + var oneofDouble: Double { + get { + if case .oneofDouble(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofDouble(newValue)} + } + + var oneofEnum: ProtobufTestMessages_Edition_TestAllTypesEdition.NestedEnum { + get { + if case .oneofEnum(let v)? = _storage._oneofField {return v} + return .foo + } + set {_uniqueStorage()._oneofField = .oneofEnum(newValue)} + } + + var data: ProtobufTestMessages_Edition_TestAllTypesEdition.DataMessage { + get {_storage._data ?? ProtobufTestMessages_Edition_TestAllTypesEdition.DataMessage()} + set {_uniqueStorage()._data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {_storage._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {_uniqueStorage()._data = nil} + + /// default values + var defaultInt32: Int32 { + get {_storage._defaultInt32 ?? -123456789} + set {_uniqueStorage()._defaultInt32 = newValue} + } + /// Returns true if `defaultInt32` has been explicitly set. + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} + /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} + + var defaultInt64: Int64 { + get {_storage._defaultInt64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultInt64 = newValue} + } + /// Returns true if `defaultInt64` has been explicitly set. + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} + /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} + + var defaultUint32: UInt32 { + get {_storage._defaultUint32 ?? 2123456789} + set {_uniqueStorage()._defaultUint32 = newValue} + } + /// Returns true if `defaultUint32` has been explicitly set. + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} + /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} + + var defaultUint64: UInt64 { + get {_storage._defaultUint64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultUint64 = newValue} + } + /// Returns true if `defaultUint64` has been explicitly set. + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} + /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} + + var defaultSint32: Int32 { + get {_storage._defaultSint32 ?? -123456789} + set {_uniqueStorage()._defaultSint32 = newValue} + } + /// Returns true if `defaultSint32` has been explicitly set. + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} + /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} + + var defaultSint64: Int64 { + get {_storage._defaultSint64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSint64 = newValue} + } + /// Returns true if `defaultSint64` has been explicitly set. + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} + /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} + + var defaultFixed32: UInt32 { + get {_storage._defaultFixed32 ?? 2123456789} + set {_uniqueStorage()._defaultFixed32 = newValue} + } + /// Returns true if `defaultFixed32` has been explicitly set. + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} + /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} + + var defaultFixed64: UInt64 { + get {_storage._defaultFixed64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultFixed64 = newValue} + } + /// Returns true if `defaultFixed64` has been explicitly set. + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} + /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} + + var defaultSfixed32: Int32 { + get {_storage._defaultSfixed32 ?? -123456789} + set {_uniqueStorage()._defaultSfixed32 = newValue} + } + /// Returns true if `defaultSfixed32` has been explicitly set. + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} + /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} + + var defaultSfixed64: Int64 { + get {_storage._defaultSfixed64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSfixed64 = newValue} + } + /// Returns true if `defaultSfixed64` has been explicitly set. + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} + /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} + + var defaultFloat: Float { + get {_storage._defaultFloat ?? 9e+09} + set {_uniqueStorage()._defaultFloat = newValue} + } + /// Returns true if `defaultFloat` has been explicitly set. + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} + /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. + mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} + + var defaultDouble: Double { + get {_storage._defaultDouble ?? 7e+22} + set {_uniqueStorage()._defaultDouble = newValue} + } + /// Returns true if `defaultDouble` has been explicitly set. + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} + /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. + mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} + + var defaultBool: Bool { + get {_storage._defaultBool ?? true} + set {_uniqueStorage()._defaultBool = newValue} + } + /// Returns true if `defaultBool` has been explicitly set. + var hasDefaultBool: Bool {_storage._defaultBool != nil} + /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. + mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} + + var defaultString: String { + get {_storage._defaultString ?? "Rosebud"} + set {_uniqueStorage()._defaultString = newValue} + } + /// Returns true if `defaultString` has been explicitly set. + var hasDefaultString: Bool {_storage._defaultString != nil} + /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. + mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} + + var defaultBytes: Data { + get {_storage._defaultBytes ?? Data([106, 111, 115, 104, 117, 97])} + set {_uniqueStorage()._defaultBytes = newValue} + } + /// Returns true if `defaultBytes` has been explicitly set. + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} + /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. + mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} + + /// Test field-name-to-JSON-name convention. + /// (protobuf says names can be any valid C/C++ identifier.) + var fieldname1: Int32 { + get {_storage._fieldname1 ?? 0} + set {_uniqueStorage()._fieldname1 = newValue} + } + /// Returns true if `fieldname1` has been explicitly set. + var hasFieldname1: Bool {_storage._fieldname1 != nil} + /// Clears the value of `fieldname1`. Subsequent reads from it will return its default value. + mutating func clearFieldname1() {_uniqueStorage()._fieldname1 = nil} + + var fieldName2: Int32 { + get {_storage._fieldName2 ?? 0} + set {_uniqueStorage()._fieldName2 = newValue} + } + /// Returns true if `fieldName2` has been explicitly set. + var hasFieldName2: Bool {_storage._fieldName2 != nil} + /// Clears the value of `fieldName2`. Subsequent reads from it will return its default value. + mutating func clearFieldName2() {_uniqueStorage()._fieldName2 = nil} + + var fieldName3: Int32 { + get {_storage._fieldName3 ?? 0} + set {_uniqueStorage()._fieldName3 = newValue} + } + /// Returns true if `fieldName3` has been explicitly set. + var hasFieldName3: Bool {_storage._fieldName3 != nil} + /// Clears the value of `fieldName3`. Subsequent reads from it will return its default value. + mutating func clearFieldName3() {_uniqueStorage()._fieldName3 = nil} + + var field_Name4_: Int32 { + get {_storage._field_Name4_ ?? 0} + set {_uniqueStorage()._field_Name4_ = newValue} + } + /// Returns true if `field_Name4_` has been explicitly set. + var hasField_Name4_: Bool {_storage._field_Name4_ != nil} + /// Clears the value of `field_Name4_`. Subsequent reads from it will return its default value. + mutating func clearField_Name4_() {_uniqueStorage()._field_Name4_ = nil} + + var field0Name5: Int32 { + get {_storage._field0Name5 ?? 0} + set {_uniqueStorage()._field0Name5 = newValue} + } + /// Returns true if `field0Name5` has been explicitly set. + var hasField0Name5: Bool {_storage._field0Name5 != nil} + /// Clears the value of `field0Name5`. Subsequent reads from it will return its default value. + mutating func clearField0Name5() {_uniqueStorage()._field0Name5 = nil} + + var field0Name6: Int32 { + get {_storage._field0Name6 ?? 0} + set {_uniqueStorage()._field0Name6 = newValue} + } + /// Returns true if `field0Name6` has been explicitly set. + var hasField0Name6: Bool {_storage._field0Name6 != nil} + /// Clears the value of `field0Name6`. Subsequent reads from it will return its default value. + mutating func clearField0Name6() {_uniqueStorage()._field0Name6 = nil} + + var fieldName7: Int32 { + get {_storage._fieldName7 ?? 0} + set {_uniqueStorage()._fieldName7 = newValue} + } + /// Returns true if `fieldName7` has been explicitly set. + var hasFieldName7: Bool {_storage._fieldName7 != nil} + /// Clears the value of `fieldName7`. Subsequent reads from it will return its default value. + mutating func clearFieldName7() {_uniqueStorage()._fieldName7 = nil} + + var fieldName8: Int32 { + get {_storage._fieldName8 ?? 0} + set {_uniqueStorage()._fieldName8 = newValue} + } + /// Returns true if `fieldName8` has been explicitly set. + var hasFieldName8: Bool {_storage._fieldName8 != nil} + /// Clears the value of `fieldName8`. Subsequent reads from it will return its default value. + mutating func clearFieldName8() {_uniqueStorage()._fieldName8 = nil} + + var fieldName9: Int32 { + get {_storage._fieldName9 ?? 0} + set {_uniqueStorage()._fieldName9 = newValue} + } + /// Returns true if `fieldName9` has been explicitly set. + var hasFieldName9: Bool {_storage._fieldName9 != nil} + /// Clears the value of `fieldName9`. Subsequent reads from it will return its default value. + mutating func clearFieldName9() {_uniqueStorage()._fieldName9 = nil} + + var fieldName10: Int32 { + get {_storage._fieldName10 ?? 0} + set {_uniqueStorage()._fieldName10 = newValue} + } + /// Returns true if `fieldName10` has been explicitly set. + var hasFieldName10: Bool {_storage._fieldName10 != nil} + /// Clears the value of `fieldName10`. Subsequent reads from it will return its default value. + mutating func clearFieldName10() {_uniqueStorage()._fieldName10 = nil} + + var fieldName11: Int32 { + get {_storage._fieldName11 ?? 0} + set {_uniqueStorage()._fieldName11 = newValue} + } + /// Returns true if `fieldName11` has been explicitly set. + var hasFieldName11: Bool {_storage._fieldName11 != nil} + /// Clears the value of `fieldName11`. Subsequent reads from it will return its default value. + mutating func clearFieldName11() {_uniqueStorage()._fieldName11 = nil} + + var fieldName12: Int32 { + get {_storage._fieldName12 ?? 0} + set {_uniqueStorage()._fieldName12 = newValue} + } + /// Returns true if `fieldName12` has been explicitly set. + var hasFieldName12: Bool {_storage._fieldName12 != nil} + /// Clears the value of `fieldName12`. Subsequent reads from it will return its default value. + mutating func clearFieldName12() {_uniqueStorage()._fieldName12 = nil} + + var _FieldName13: Int32 { + get {_storage.__FieldName13 ?? 0} + set {_uniqueStorage().__FieldName13 = newValue} + } + /// Returns true if `_FieldName13` has been explicitly set. + var has_FieldName13: Bool {_storage.__FieldName13 != nil} + /// Clears the value of `_FieldName13`. Subsequent reads from it will return its default value. + mutating func clear_FieldName13() {_uniqueStorage().__FieldName13 = nil} + + var _FieldName14: Int32 { + get {_storage.__FieldName14 ?? 0} + set {_uniqueStorage().__FieldName14 = newValue} + } + /// Returns true if `_FieldName14` has been explicitly set. + var has_FieldName14: Bool {_storage.__FieldName14 != nil} + /// Clears the value of `_FieldName14`. Subsequent reads from it will return its default value. + mutating func clear_FieldName14() {_uniqueStorage().__FieldName14 = nil} + + var field_Name15: Int32 { + get {_storage._field_Name15 ?? 0} + set {_uniqueStorage()._field_Name15 = newValue} + } + /// Returns true if `field_Name15` has been explicitly set. + var hasField_Name15: Bool {_storage._field_Name15 != nil} + /// Clears the value of `field_Name15`. Subsequent reads from it will return its default value. + mutating func clearField_Name15() {_uniqueStorage()._field_Name15 = nil} + + var field_Name16: Int32 { + get {_storage._field_Name16 ?? 0} + set {_uniqueStorage()._field_Name16 = newValue} + } + /// Returns true if `field_Name16` has been explicitly set. + var hasField_Name16: Bool {_storage._field_Name16 != nil} + /// Clears the value of `field_Name16`. Subsequent reads from it will return its default value. + mutating func clearField_Name16() {_uniqueStorage()._field_Name16 = nil} + + var fieldName17__: Int32 { + get {_storage._fieldName17__ ?? 0} + set {_uniqueStorage()._fieldName17__ = newValue} + } + /// Returns true if `fieldName17__` has been explicitly set. + var hasFieldName17__: Bool {_storage._fieldName17__ != nil} + /// Clears the value of `fieldName17__`. Subsequent reads from it will return its default value. + mutating func clearFieldName17__() {_uniqueStorage()._fieldName17__ = nil} + + var fieldName18__: Int32 { + get {_storage._fieldName18__ ?? 0} + set {_uniqueStorage()._fieldName18__ = newValue} + } + /// Returns true if `fieldName18__` has been explicitly set. + var hasFieldName18__: Bool {_storage._fieldName18__ != nil} + /// Clears the value of `fieldName18__`. Subsequent reads from it will return its default value. + mutating func clearFieldName18__() {_uniqueStorage()._fieldName18__ = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofNestedMessage(ProtobufTestMessages_Edition_TestAllTypesEdition.NestedMessage) + case oneofString(String) + case oneofBytes(Data) + case oneofBool(Bool) + case oneofUint64(UInt64) + case oneofFloat(Float) + case oneofDouble(Double) + case oneofEnum(ProtobufTestMessages_Edition_TestAllTypesEdition.NestedEnum) + + fileprivate var isInitialized: Bool { + guard case .oneofNestedMessage(let v) = self else {return true} + return v.isInitialized + } + + } + + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foo // = 0 + case bar // = 1 + case baz // = 2 + + /// Intentionally negative. + case neg // = -1 + case UNRECOGNIZED(Int) + + init() { + self = .foo + } + + init?(rawValue: Int) { + switch rawValue { + case -1: self = .neg + case 0: self = .foo + case 1: self = .bar + case 2: self = .baz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .neg: return -1 + case .foo: return 0 + case .bar: return 1 + case .baz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Edition_TestAllTypesEdition.NestedEnum] = [ + .foo, + .bar, + .baz, + .neg, + ] + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var corecursive: ProtobufTestMessages_Edition_TestAllTypesEdition { + get {_storage._corecursive ?? ProtobufTestMessages_Edition_TestAllTypesEdition()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + /// groups + struct DataMessage: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + /// message_set test case. + struct MessageSetCorrect: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() + } + + struct MessageSetCorrectExtension1: Sendable { + // 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 str: String { + get {_str ?? String()} + set {_str = newValue} + } + /// Returns true if `str` has been explicitly set. + var hasStr: Bool {self._str != nil} + /// Clears the value of `str`. Subsequent reads from it will return its default value. + mutating func clearStr() {self._str = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _str: String? = nil + } + + struct MessageSetCorrectExtension2: Sendable { + // 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 i: Int32 { + get {_i ?? 0} + set {_i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {self._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {self._i = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _i: Int32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct ProtobufTestMessages_Edition_ForeignMessageEdition: Sendable { + // 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 c: Int32 { + get {_c ?? 0} + set {_c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {self._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {self._c = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _c: Int32? = nil +} + +struct ProtobufTestMessages_Edition_UnknownToTestAllTypes: Sendable { + // 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 optionalInt32: Int32 { + get {_optionalInt32 ?? 0} + set {_optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {self._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {self._optionalInt32 = nil} + + var optionalString: String { + get {_optionalString ?? String()} + set {_optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {self._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {self._optionalString = nil} + + var nestedMessage: ProtobufTestMessages_Edition_ForeignMessageEdition { + get {_nestedMessage ?? ProtobufTestMessages_Edition_ForeignMessageEdition()} + set {_nestedMessage = newValue} + } + /// Returns true if `nestedMessage` has been explicitly set. + var hasNestedMessage: Bool {self._nestedMessage != nil} + /// Clears the value of `nestedMessage`. Subsequent reads from it will return its default value. + mutating func clearNestedMessage() {self._nestedMessage = nil} + + var optionalGroup: ProtobufTestMessages_Edition_UnknownToTestAllTypes.OptionalGroup { + get {_optionalGroup ?? ProtobufTestMessages_Edition_UnknownToTestAllTypes.OptionalGroup()} + set {_optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {self._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {self._optionalGroup = nil} + + var optionalBool: Bool { + get {_optionalBool ?? false} + set {_optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {self._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {self._optionalBool = nil} + + var repeatedInt32: [Int32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct OptionalGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + init() {} + + fileprivate var _optionalInt32: Int32? = nil + fileprivate var _optionalString: String? = nil + fileprivate var _nestedMessage: ProtobufTestMessages_Edition_ForeignMessageEdition? = nil + fileprivate var _optionalGroup: ProtobufTestMessages_Edition_UnknownToTestAllTypes.OptionalGroup? = nil + fileprivate var _optionalBool: Bool? = nil +} + +struct ProtobufTestMessages_Edition_NullHypothesisEdition: Sendable { + // 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 ProtobufTestMessages_Edition_EnumOnlyEdition: Sendable { + // 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() + + enum BoolEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case kFalse // = 0 + case kTrue // = 1 + case UNRECOGNIZED(Int) + + init() { + self = .kFalse + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .kFalse + case 1: self = .kTrue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .kFalse: return 0 + case .kTrue: return 1 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Edition_EnumOnlyEdition.BoolEnum] = [ + .kFalse, + .kTrue, + ] + + } + + init() {} +} + +struct ProtobufTestMessages_Edition_OneStringEdition: Sendable { + // 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 data: String { + get {_data ?? String()} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: String? = nil +} + +struct ProtobufTestMessages_Edition_ProtoWithKeywords: Sendable { + // 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 inline: Int32 { + get {_inline ?? 0} + set {_inline = newValue} + } + /// Returns true if `inline` has been explicitly set. + var hasInline: Bool {self._inline != nil} + /// Clears the value of `inline`. Subsequent reads from it will return its default value. + mutating func clearInline() {self._inline = nil} + + var concept: String { + get {_concept ?? String()} + set {_concept = newValue} + } + /// Returns true if `concept` has been explicitly set. + var hasConcept: Bool {self._concept != nil} + /// Clears the value of `concept`. Subsequent reads from it will return its default value. + mutating func clearConcept() {self._concept = nil} + + var requires: [String] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _inline: Int32? = nil + fileprivate var _concept: String? = nil +} + +struct ProtobufTestMessages_Edition_TestAllRequiredTypesEdition: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Singular + var requiredInt32: Int32 { + get {_storage._requiredInt32 ?? 0} + set {_uniqueStorage()._requiredInt32 = newValue} + } + /// Returns true if `requiredInt32` has been explicitly set. + var hasRequiredInt32: Bool {_storage._requiredInt32 != nil} + /// Clears the value of `requiredInt32`. Subsequent reads from it will return its default value. + mutating func clearRequiredInt32() {_uniqueStorage()._requiredInt32 = nil} + + var requiredInt64: Int64 { + get {_storage._requiredInt64 ?? 0} + set {_uniqueStorage()._requiredInt64 = newValue} + } + /// Returns true if `requiredInt64` has been explicitly set. + var hasRequiredInt64: Bool {_storage._requiredInt64 != nil} + /// Clears the value of `requiredInt64`. Subsequent reads from it will return its default value. + mutating func clearRequiredInt64() {_uniqueStorage()._requiredInt64 = nil} + + var requiredUint32: UInt32 { + get {_storage._requiredUint32 ?? 0} + set {_uniqueStorage()._requiredUint32 = newValue} + } + /// Returns true if `requiredUint32` has been explicitly set. + var hasRequiredUint32: Bool {_storage._requiredUint32 != nil} + /// Clears the value of `requiredUint32`. Subsequent reads from it will return its default value. + mutating func clearRequiredUint32() {_uniqueStorage()._requiredUint32 = nil} + + var requiredUint64: UInt64 { + get {_storage._requiredUint64 ?? 0} + set {_uniqueStorage()._requiredUint64 = newValue} + } + /// Returns true if `requiredUint64` has been explicitly set. + var hasRequiredUint64: Bool {_storage._requiredUint64 != nil} + /// Clears the value of `requiredUint64`. Subsequent reads from it will return its default value. + mutating func clearRequiredUint64() {_uniqueStorage()._requiredUint64 = nil} + + var requiredSint32: Int32 { + get {_storage._requiredSint32 ?? 0} + set {_uniqueStorage()._requiredSint32 = newValue} + } + /// Returns true if `requiredSint32` has been explicitly set. + var hasRequiredSint32: Bool {_storage._requiredSint32 != nil} + /// Clears the value of `requiredSint32`. Subsequent reads from it will return its default value. + mutating func clearRequiredSint32() {_uniqueStorage()._requiredSint32 = nil} + + var requiredSint64: Int64 { + get {_storage._requiredSint64 ?? 0} + set {_uniqueStorage()._requiredSint64 = newValue} + } + /// Returns true if `requiredSint64` has been explicitly set. + var hasRequiredSint64: Bool {_storage._requiredSint64 != nil} + /// Clears the value of `requiredSint64`. Subsequent reads from it will return its default value. + mutating func clearRequiredSint64() {_uniqueStorage()._requiredSint64 = nil} + + var requiredFixed32: UInt32 { + get {_storage._requiredFixed32 ?? 0} + set {_uniqueStorage()._requiredFixed32 = newValue} + } + /// Returns true if `requiredFixed32` has been explicitly set. + var hasRequiredFixed32: Bool {_storage._requiredFixed32 != nil} + /// Clears the value of `requiredFixed32`. Subsequent reads from it will return its default value. + mutating func clearRequiredFixed32() {_uniqueStorage()._requiredFixed32 = nil} + + var requiredFixed64: UInt64 { + get {_storage._requiredFixed64 ?? 0} + set {_uniqueStorage()._requiredFixed64 = newValue} + } + /// Returns true if `requiredFixed64` has been explicitly set. + var hasRequiredFixed64: Bool {_storage._requiredFixed64 != nil} + /// Clears the value of `requiredFixed64`. Subsequent reads from it will return its default value. + mutating func clearRequiredFixed64() {_uniqueStorage()._requiredFixed64 = nil} + + var requiredSfixed32: Int32 { + get {_storage._requiredSfixed32 ?? 0} + set {_uniqueStorage()._requiredSfixed32 = newValue} + } + /// Returns true if `requiredSfixed32` has been explicitly set. + var hasRequiredSfixed32: Bool {_storage._requiredSfixed32 != nil} + /// Clears the value of `requiredSfixed32`. Subsequent reads from it will return its default value. + mutating func clearRequiredSfixed32() {_uniqueStorage()._requiredSfixed32 = nil} + + var requiredSfixed64: Int64 { + get {_storage._requiredSfixed64 ?? 0} + set {_uniqueStorage()._requiredSfixed64 = newValue} + } + /// Returns true if `requiredSfixed64` has been explicitly set. + var hasRequiredSfixed64: Bool {_storage._requiredSfixed64 != nil} + /// Clears the value of `requiredSfixed64`. Subsequent reads from it will return its default value. + mutating func clearRequiredSfixed64() {_uniqueStorage()._requiredSfixed64 = nil} + + var requiredFloat: Float { + get {_storage._requiredFloat ?? 0} + set {_uniqueStorage()._requiredFloat = newValue} + } + /// Returns true if `requiredFloat` has been explicitly set. + var hasRequiredFloat: Bool {_storage._requiredFloat != nil} + /// Clears the value of `requiredFloat`. Subsequent reads from it will return its default value. + mutating func clearRequiredFloat() {_uniqueStorage()._requiredFloat = nil} + + var requiredDouble: Double { + get {_storage._requiredDouble ?? 0} + set {_uniqueStorage()._requiredDouble = newValue} + } + /// Returns true if `requiredDouble` has been explicitly set. + var hasRequiredDouble: Bool {_storage._requiredDouble != nil} + /// Clears the value of `requiredDouble`. Subsequent reads from it will return its default value. + mutating func clearRequiredDouble() {_uniqueStorage()._requiredDouble = nil} + + var requiredBool: Bool { + get {_storage._requiredBool ?? false} + set {_uniqueStorage()._requiredBool = newValue} + } + /// Returns true if `requiredBool` has been explicitly set. + var hasRequiredBool: Bool {_storage._requiredBool != nil} + /// Clears the value of `requiredBool`. Subsequent reads from it will return its default value. + mutating func clearRequiredBool() {_uniqueStorage()._requiredBool = nil} + + var requiredString: String { + get {_storage._requiredString ?? String()} + set {_uniqueStorage()._requiredString = newValue} + } + /// Returns true if `requiredString` has been explicitly set. + var hasRequiredString: Bool {_storage._requiredString != nil} + /// Clears the value of `requiredString`. Subsequent reads from it will return its default value. + mutating func clearRequiredString() {_uniqueStorage()._requiredString = nil} + + var requiredBytes: Data { + get {_storage._requiredBytes ?? Data()} + set {_uniqueStorage()._requiredBytes = newValue} + } + /// Returns true if `requiredBytes` has been explicitly set. + var hasRequiredBytes: Bool {_storage._requiredBytes != nil} + /// Clears the value of `requiredBytes`. Subsequent reads from it will return its default value. + mutating func clearRequiredBytes() {_uniqueStorage()._requiredBytes = nil} + + var requiredNestedMessage: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.NestedMessage { + get {_storage._requiredNestedMessage ?? ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.NestedMessage()} + set {_uniqueStorage()._requiredNestedMessage = newValue} + } + /// Returns true if `requiredNestedMessage` has been explicitly set. + var hasRequiredNestedMessage: Bool {_storage._requiredNestedMessage != nil} + /// Clears the value of `requiredNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearRequiredNestedMessage() {_uniqueStorage()._requiredNestedMessage = nil} + + var requiredForeignMessage: ProtobufTestMessages_Edition_ForeignMessageEdition { + get {_storage._requiredForeignMessage ?? ProtobufTestMessages_Edition_ForeignMessageEdition()} + set {_uniqueStorage()._requiredForeignMessage = newValue} + } + /// Returns true if `requiredForeignMessage` has been explicitly set. + var hasRequiredForeignMessage: Bool {_storage._requiredForeignMessage != nil} + /// Clears the value of `requiredForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearRequiredForeignMessage() {_uniqueStorage()._requiredForeignMessage = nil} + + var requiredNestedEnum: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.NestedEnum { + get {_storage._requiredNestedEnum ?? .foo} + set {_uniqueStorage()._requiredNestedEnum = newValue} + } + /// Returns true if `requiredNestedEnum` has been explicitly set. + var hasRequiredNestedEnum: Bool {_storage._requiredNestedEnum != nil} + /// Clears the value of `requiredNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredNestedEnum() {_uniqueStorage()._requiredNestedEnum = nil} + + var requiredForeignEnum: ProtobufTestMessages_Edition_ForeignEnumEdition { + get {_storage._requiredForeignEnum ?? .foreignFoo} + set {_uniqueStorage()._requiredForeignEnum = newValue} + } + /// Returns true if `requiredForeignEnum` has been explicitly set. + var hasRequiredForeignEnum: Bool {_storage._requiredForeignEnum != nil} + /// Clears the value of `requiredForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredForeignEnum() {_uniqueStorage()._requiredForeignEnum = nil} + + var requiredStringPiece: String { + get {_storage._requiredStringPiece ?? String()} + set {_uniqueStorage()._requiredStringPiece = newValue} + } + /// Returns true if `requiredStringPiece` has been explicitly set. + var hasRequiredStringPiece: Bool {_storage._requiredStringPiece != nil} + /// Clears the value of `requiredStringPiece`. Subsequent reads from it will return its default value. + mutating func clearRequiredStringPiece() {_uniqueStorage()._requiredStringPiece = nil} + + var requiredCord: String { + get {_storage._requiredCord ?? String()} + set {_uniqueStorage()._requiredCord = newValue} + } + /// Returns true if `requiredCord` has been explicitly set. + var hasRequiredCord: Bool {_storage._requiredCord != nil} + /// Clears the value of `requiredCord`. Subsequent reads from it will return its default value. + mutating func clearRequiredCord() {_uniqueStorage()._requiredCord = nil} + + var recursiveMessage: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Edition_TestAllRequiredTypesEdition()} + set {_uniqueStorage()._recursiveMessage = newValue} + } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} + + var optionalRecursiveMessage: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition { + get {_storage._optionalRecursiveMessage ?? ProtobufTestMessages_Edition_TestAllRequiredTypesEdition()} + set {_uniqueStorage()._optionalRecursiveMessage = newValue} + } + /// Returns true if `optionalRecursiveMessage` has been explicitly set. + var hasOptionalRecursiveMessage: Bool {_storage._optionalRecursiveMessage != nil} + /// Clears the value of `optionalRecursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalRecursiveMessage() {_uniqueStorage()._optionalRecursiveMessage = nil} + + var data: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.DataMessage { + get {_storage._data ?? ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.DataMessage()} + set {_uniqueStorage()._data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {_storage._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {_uniqueStorage()._data = nil} + + /// default values + var defaultInt32: Int32 { + get {_storage._defaultInt32 ?? -123456789} + set {_uniqueStorage()._defaultInt32 = newValue} + } + /// Returns true if `defaultInt32` has been explicitly set. + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} + /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} + + var defaultInt64: Int64 { + get {_storage._defaultInt64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultInt64 = newValue} + } + /// Returns true if `defaultInt64` has been explicitly set. + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} + /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} + + var defaultUint32: UInt32 { + get {_storage._defaultUint32 ?? 2123456789} + set {_uniqueStorage()._defaultUint32 = newValue} + } + /// Returns true if `defaultUint32` has been explicitly set. + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} + /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} + + var defaultUint64: UInt64 { + get {_storage._defaultUint64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultUint64 = newValue} + } + /// Returns true if `defaultUint64` has been explicitly set. + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} + /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} + + var defaultSint32: Int32 { + get {_storage._defaultSint32 ?? -123456789} + set {_uniqueStorage()._defaultSint32 = newValue} + } + /// Returns true if `defaultSint32` has been explicitly set. + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} + /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} + + var defaultSint64: Int64 { + get {_storage._defaultSint64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSint64 = newValue} + } + /// Returns true if `defaultSint64` has been explicitly set. + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} + /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} + + var defaultFixed32: UInt32 { + get {_storage._defaultFixed32 ?? 2123456789} + set {_uniqueStorage()._defaultFixed32 = newValue} + } + /// Returns true if `defaultFixed32` has been explicitly set. + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} + /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} + + var defaultFixed64: UInt64 { + get {_storage._defaultFixed64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultFixed64 = newValue} + } + /// Returns true if `defaultFixed64` has been explicitly set. + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} + /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} + + var defaultSfixed32: Int32 { + get {_storage._defaultSfixed32 ?? -123456789} + set {_uniqueStorage()._defaultSfixed32 = newValue} + } + /// Returns true if `defaultSfixed32` has been explicitly set. + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} + /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} + + var defaultSfixed64: Int64 { + get {_storage._defaultSfixed64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSfixed64 = newValue} + } + /// Returns true if `defaultSfixed64` has been explicitly set. + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} + /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} + + var defaultFloat: Float { + get {_storage._defaultFloat ?? 9e+09} + set {_uniqueStorage()._defaultFloat = newValue} + } + /// Returns true if `defaultFloat` has been explicitly set. + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} + /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. + mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} + + var defaultDouble: Double { + get {_storage._defaultDouble ?? 7e+22} + set {_uniqueStorage()._defaultDouble = newValue} + } + /// Returns true if `defaultDouble` has been explicitly set. + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} + /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. + mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} + + var defaultBool: Bool { + get {_storage._defaultBool ?? true} + set {_uniqueStorage()._defaultBool = newValue} + } + /// Returns true if `defaultBool` has been explicitly set. + var hasDefaultBool: Bool {_storage._defaultBool != nil} + /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. + mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} + + var defaultString: String { + get {_storage._defaultString ?? "Rosebud"} + set {_uniqueStorage()._defaultString = newValue} + } + /// Returns true if `defaultString` has been explicitly set. + var hasDefaultString: Bool {_storage._defaultString != nil} + /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. + mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} + + var defaultBytes: Data { + get {_storage._defaultBytes ?? Data([106, 111, 115, 104, 117, 97])} + set {_uniqueStorage()._defaultBytes = newValue} + } + /// Returns true if `defaultBytes` has been explicitly set. + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} + /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. + mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foo // = 0 + case bar // = 1 + case baz // = 2 + + /// Intentionally negative. + case neg // = -1 + case UNRECOGNIZED(Int) + + init() { + self = .foo + } + + init?(rawValue: Int) { + switch rawValue { + case -1: self = .neg + case 0: self = .foo + case 1: self = .bar + case 2: self = .baz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .neg: return -1 + case .foo: return 0 + case .bar: return 1 + case .baz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.NestedEnum] = [ + .foo, + .bar, + .baz, + .neg, + ] + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var corecursive: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition { + get {_storage._corecursive ?? ProtobufTestMessages_Edition_TestAllRequiredTypesEdition()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var optionalCorecursive: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition { + get {_storage._optionalCorecursive ?? ProtobufTestMessages_Edition_TestAllRequiredTypesEdition()} + set {_uniqueStorage()._optionalCorecursive = newValue} + } + /// Returns true if `optionalCorecursive` has been explicitly set. + var hasOptionalCorecursive: Bool {_storage._optionalCorecursive != nil} + /// Clears the value of `optionalCorecursive`. Subsequent reads from it will return its default value. + mutating func clearOptionalCorecursive() {_uniqueStorage()._optionalCorecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + /// groups + struct DataMessage: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + /// message_set test case. + struct MessageSetCorrect: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() + } + + struct MessageSetCorrectExtension1: Sendable { + // 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 str: String { + get {_str ?? String()} + set {_str = newValue} + } + /// Returns true if `str` has been explicitly set. + var hasStr: Bool {self._str != nil} + /// Clears the value of `str`. Subsequent reads from it will return its default value. + mutating func clearStr() {self._str = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _str: String? = nil + } + + struct MessageSetCorrectExtension2: Sendable { + // 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 i: Int32 { + get {_i ?? 0} + set {_i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {self._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {self._i = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _i: Int32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Extension support defined in sample_messages_edition.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrect { + + var ProtobufTestMessages_Edition_TestAllRequiredTypesEdition_MessageSetCorrectExtension1_messageSetExtension: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension1 { + get {return getExtensionValue(ext: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension1.Extensions.message_set_extension) ?? ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension1()} + set {setExtensionValue(ext: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension1.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension1.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Edition_TestAllRequiredTypesEdition_MessageSetCorrectExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension1.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Edition_TestAllRequiredTypesEdition_MessageSetCorrectExtension1_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Edition_TestAllRequiredTypesEdition_MessageSetCorrectExtension2_messageSetExtension: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension2 { + get {return getExtensionValue(ext: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension2.Extensions.message_set_extension) ?? ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension2()} + set {setExtensionValue(ext: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension2.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension2.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Edition_TestAllRequiredTypesEdition_MessageSetCorrectExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension2.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Edition_TestAllRequiredTypesEdition_MessageSetCorrectExtension2_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension2.Extensions.message_set_extension) + } +} + +extension ProtobufTestMessages_Edition_TestAllTypesEdition { + + var ProtobufTestMessages_Edition_extensionInt32: Int32 { + get {return getExtensionValue(ext: ProtobufTestMessages_Edition_Extensions_extension_int32) ?? 0} + set {setExtensionValue(ext: ProtobufTestMessages_Edition_Extensions_extension_int32, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Edition_Extensions_extension_int32` + /// has been explicitly set. + var hasProtobufTestMessages_Edition_extensionInt32: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Edition_Extensions_extension_int32) + } + /// Clears the value of extension `ProtobufTestMessages_Edition_Extensions_extension_int32`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Edition_extensionInt32() { + clearExtensionValue(ext: ProtobufTestMessages_Edition_Extensions_extension_int32) + } +} + +extension ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrect { + + var ProtobufTestMessages_Edition_TestAllTypesEdition_MessageSetCorrectExtension1_messageSetExtension: ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension1 { + get {return getExtensionValue(ext: ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension1.Extensions.message_set_extension) ?? ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension1()} + set {setExtensionValue(ext: ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension1.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension1.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Edition_TestAllTypesEdition_MessageSetCorrectExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension1.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Edition_TestAllTypesEdition_MessageSetCorrectExtension1_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Edition_TestAllTypesEdition_MessageSetCorrectExtension2_messageSetExtension: ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension2 { + get {return getExtensionValue(ext: ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension2.Extensions.message_set_extension) ?? ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension2()} + set {setExtensionValue(ext: ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension2.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension2.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Edition_TestAllTypesEdition_MessageSetCorrectExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension2.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Edition_TestAllTypesEdition_MessageSetCorrectExtension2_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + +} + +// MARK: - File's ExtensionMap: ProtobufTestMessages_Edition_SampleMessagesEdition_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 ProtobufTestMessages_Edition_SampleMessagesEdition_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + ProtobufTestMessages_Edition_Extensions_extension_int32, + ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension1.Extensions.message_set_extension, + ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension2.Extensions.message_set_extension, + ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension1.Extensions.message_set_extension, + ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension2.Extensions.message_set_extension +] + +// 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 ProtobufTestMessages_Edition_Extensions_extension_int32 = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Edition_TestAllTypesEdition>( + _protobuf_fieldNumber: 120, + fieldName: "protobuf_test_messages.edition.extension_int32" +) + +extension ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension1 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrect>( + _protobuf_fieldNumber: 1547769, + fieldName: "protobuf_test_messages.edition.TestAllTypesEdition.MessageSetCorrectExtension1" + ) + } +} + +extension ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension2 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrect>( + _protobuf_fieldNumber: 4135312, + fieldName: "protobuf_test_messages.edition.TestAllTypesEdition.MessageSetCorrectExtension2" + ) + } +} + +extension ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension1 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrect>( + _protobuf_fieldNumber: 1547769, + fieldName: "protobuf_test_messages.edition.TestAllRequiredTypesEdition.MessageSetCorrectExtension1" + ) + } +} + +extension ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension2 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrect>( + _protobuf_fieldNumber: 4135312, + fieldName: "protobuf_test_messages.edition.TestAllRequiredTypesEdition.MessageSetCorrectExtension2" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "protobuf_test_messages.edition" + +extension ProtobufTestMessages_Edition_ForeignEnumEdition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") +} + +extension ProtobufTestMessages_Edition_TestAllTypesEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypesEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{4}\u{2}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{4}\u{2}optional_string_piece\0\u{3}optional_cord\0\u{4}\u{2}recursive_message\0\u{4}\u{4}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{4}\u{2}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_nested_message\0\u{3}map_string_foreign_message\0\u{3}map_string_nested_enum\0\u{3}map_string_foreign_enum\0\u{3}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_nested_enum\0\u{3}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_nested_enum\0\u{4}\u{9}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_bool\0\u{3}oneof_uint64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_enum\0\u{8}R\u{1}Data\0\u{4}(default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{2}R\u{2}fieldname1\0\u{3}field_name2\0\u{3}_field_name3\0\u{3}field__name4_\0\u{1}field0name5\0\u{3}field_0_name6\0\u{1}fieldName7\0\u{1}FieldName8\0\u{3}field_Name9\0\u{3}Field_Name10\0\u{3}FIELD_NAME11\0\u{3}FIELD_name12\0\u{3}__field_name13\0\u{3}__Field_name14\0\u{3}field__name15\0\u{3}field__Name16\0\u{3}field_name17__\0\u{3}Field_name18__\0\u{c}h\u{f}hL\u{2}") + + fileprivate class _StorageClass { + var _optionalInt32: Int32? = nil + var _optionalInt64: Int64? = nil + var _optionalUint32: UInt32? = nil + var _optionalUint64: UInt64? = nil + var _optionalSint32: Int32? = nil + var _optionalSint64: Int64? = nil + var _optionalFixed32: UInt32? = nil + var _optionalFixed64: UInt64? = nil + var _optionalSfixed32: Int32? = nil + var _optionalSfixed64: Int64? = nil + var _optionalFloat: Float? = nil + var _optionalDouble: Double? = nil + var _optionalBool: Bool? = nil + var _optionalString: String? = nil + var _optionalBytes: Data? = nil + var _optionalNestedMessage: ProtobufTestMessages_Edition_TestAllTypesEdition.NestedMessage? = nil + var _optionalForeignMessage: ProtobufTestMessages_Edition_ForeignMessageEdition? = nil + var _optionalNestedEnum: ProtobufTestMessages_Edition_TestAllTypesEdition.NestedEnum? = nil + var _optionalForeignEnum: ProtobufTestMessages_Edition_ForeignEnumEdition? = nil + var _optionalStringPiece: String? = nil + var _optionalCord: String? = nil + var _recursiveMessage: ProtobufTestMessages_Edition_TestAllTypesEdition? = nil + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedNestedMessage: [ProtobufTestMessages_Edition_TestAllTypesEdition.NestedMessage] = [] + var _repeatedForeignMessage: [ProtobufTestMessages_Edition_ForeignMessageEdition] = [] + var _repeatedNestedEnum: [ProtobufTestMessages_Edition_TestAllTypesEdition.NestedEnum] = [] + var _repeatedForeignEnum: [ProtobufTestMessages_Edition_ForeignEnumEdition] = [] + var _repeatedStringPiece: [String] = [] + var _repeatedCord: [String] = [] + var _packedInt32: [Int32] = [] + var _packedInt64: [Int64] = [] + var _packedUint32: [UInt32] = [] + var _packedUint64: [UInt64] = [] + var _packedSint32: [Int32] = [] + var _packedSint64: [Int64] = [] + var _packedFixed32: [UInt32] = [] + var _packedFixed64: [UInt64] = [] + var _packedSfixed32: [Int32] = [] + var _packedSfixed64: [Int64] = [] + var _packedFloat: [Float] = [] + var _packedDouble: [Double] = [] + var _packedBool: [Bool] = [] + var _packedNestedEnum: [ProtobufTestMessages_Edition_TestAllTypesEdition.NestedEnum] = [] + var _unpackedInt32: [Int32] = [] + var _unpackedInt64: [Int64] = [] + var _unpackedUint32: [UInt32] = [] + var _unpackedUint64: [UInt64] = [] + var _unpackedSint32: [Int32] = [] + var _unpackedSint64: [Int64] = [] + var _unpackedFixed32: [UInt32] = [] + var _unpackedFixed64: [UInt64] = [] + var _unpackedSfixed32: [Int32] = [] + var _unpackedSfixed64: [Int64] = [] + var _unpackedFloat: [Float] = [] + var _unpackedDouble: [Double] = [] + var _unpackedBool: [Bool] = [] + var _unpackedNestedEnum: [ProtobufTestMessages_Edition_TestAllTypesEdition.NestedEnum] = [] + var _mapInt32Int32: Dictionary = [:] + var _mapInt64Int64: Dictionary = [:] + var _mapUint32Uint32: Dictionary = [:] + var _mapUint64Uint64: Dictionary = [:] + var _mapSint32Sint32: Dictionary = [:] + var _mapSint64Sint64: Dictionary = [:] + var _mapFixed32Fixed32: Dictionary = [:] + var _mapFixed64Fixed64: Dictionary = [:] + var _mapSfixed32Sfixed32: Dictionary = [:] + var _mapSfixed64Sfixed64: Dictionary = [:] + var _mapInt32Float: Dictionary = [:] + var _mapInt32Double: Dictionary = [:] + var _mapBoolBool: Dictionary = [:] + var _mapStringString: Dictionary = [:] + var _mapStringBytes: Dictionary = [:] + var _mapStringNestedMessage: Dictionary = [:] + var _mapStringForeignMessage: Dictionary = [:] + var _mapStringNestedEnum: Dictionary = [:] + var _mapStringForeignEnum: Dictionary = [:] + var _oneofField: ProtobufTestMessages_Edition_TestAllTypesEdition.OneOf_OneofField? + var _data: ProtobufTestMessages_Edition_TestAllTypesEdition.DataMessage? = nil + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + var _fieldname1: Int32? = nil + var _fieldName2: Int32? = nil + var _fieldName3: Int32? = nil + var _field_Name4_: Int32? = nil + var _field0Name5: Int32? = nil + var _field0Name6: Int32? = nil + var _fieldName7: Int32? = nil + var _fieldName8: Int32? = nil + var _fieldName9: Int32? = nil + var _fieldName10: Int32? = nil + var _fieldName11: Int32? = nil + var _fieldName12: Int32? = nil + var __FieldName13: Int32? = nil + var __FieldName14: Int32? = nil + var _field_Name15: Int32? = nil + var _field_Name16: Int32? = nil + var _fieldName17__: Int32? = nil + var _fieldName18__: Int32? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalNestedMessage = source._optionalNestedMessage + _optionalForeignMessage = source._optionalForeignMessage + _optionalNestedEnum = source._optionalNestedEnum + _optionalForeignEnum = source._optionalForeignEnum + _optionalStringPiece = source._optionalStringPiece + _optionalCord = source._optionalCord + _recursiveMessage = source._recursiveMessage + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedForeignMessage = source._repeatedForeignMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _repeatedForeignEnum = source._repeatedForeignEnum + _repeatedStringPiece = source._repeatedStringPiece + _repeatedCord = source._repeatedCord + _packedInt32 = source._packedInt32 + _packedInt64 = source._packedInt64 + _packedUint32 = source._packedUint32 + _packedUint64 = source._packedUint64 + _packedSint32 = source._packedSint32 + _packedSint64 = source._packedSint64 + _packedFixed32 = source._packedFixed32 + _packedFixed64 = source._packedFixed64 + _packedSfixed32 = source._packedSfixed32 + _packedSfixed64 = source._packedSfixed64 + _packedFloat = source._packedFloat + _packedDouble = source._packedDouble + _packedBool = source._packedBool + _packedNestedEnum = source._packedNestedEnum + _unpackedInt32 = source._unpackedInt32 + _unpackedInt64 = source._unpackedInt64 + _unpackedUint32 = source._unpackedUint32 + _unpackedUint64 = source._unpackedUint64 + _unpackedSint32 = source._unpackedSint32 + _unpackedSint64 = source._unpackedSint64 + _unpackedFixed32 = source._unpackedFixed32 + _unpackedFixed64 = source._unpackedFixed64 + _unpackedSfixed32 = source._unpackedSfixed32 + _unpackedSfixed64 = source._unpackedSfixed64 + _unpackedFloat = source._unpackedFloat + _unpackedDouble = source._unpackedDouble + _unpackedBool = source._unpackedBool + _unpackedNestedEnum = source._unpackedNestedEnum + _mapInt32Int32 = source._mapInt32Int32 + _mapInt64Int64 = source._mapInt64Int64 + _mapUint32Uint32 = source._mapUint32Uint32 + _mapUint64Uint64 = source._mapUint64Uint64 + _mapSint32Sint32 = source._mapSint32Sint32 + _mapSint64Sint64 = source._mapSint64Sint64 + _mapFixed32Fixed32 = source._mapFixed32Fixed32 + _mapFixed64Fixed64 = source._mapFixed64Fixed64 + _mapSfixed32Sfixed32 = source._mapSfixed32Sfixed32 + _mapSfixed64Sfixed64 = source._mapSfixed64Sfixed64 + _mapInt32Float = source._mapInt32Float + _mapInt32Double = source._mapInt32Double + _mapBoolBool = source._mapBoolBool + _mapStringString = source._mapStringString + _mapStringBytes = source._mapStringBytes + _mapStringNestedMessage = source._mapStringNestedMessage + _mapStringForeignMessage = source._mapStringForeignMessage + _mapStringNestedEnum = source._mapStringNestedEnum + _mapStringForeignEnum = source._mapStringForeignEnum + _oneofField = source._oneofField + _data = source._data + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + _fieldname1 = source._fieldname1 + _fieldName2 = source._fieldName2 + _fieldName3 = source._fieldName3 + _field_Name4_ = source._field_Name4_ + _field0Name5 = source._field0Name5 + _field0Name6 = source._field0Name6 + _fieldName7 = source._fieldName7 + _fieldName8 = source._fieldName8 + _fieldName9 = source._fieldName9 + _fieldName10 = source._fieldName10 + _fieldName11 = source._fieldName11 + _fieldName12 = source._fieldName12 + __FieldName13 = source.__FieldName13 + __FieldName14 = source.__FieldName14 + _field_Name15 = source._field_Name15 + _field_Name16 = source._field_Name16 + _fieldName17__ = source._fieldName17__ + _fieldName18__ = source._fieldName18__ + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._optionalNestedMessage, !v.isInitialized {return false} + if let v = _storage._recursiveMessage, !v.isInitialized {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._repeatedNestedMessage) {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._mapStringNestedMessage) {return false} + if let v = _storage._oneofField, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() + case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() + case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() + case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() + case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() + case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() + case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() + case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() + case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() + case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() + case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() + case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() + case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() + case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() + case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() + case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() + case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() + case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() + case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() + case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() + case 56: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Int32) }() + case 57: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() + case 58: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() + case 59: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Uint64) }() + case 60: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Sint32) }() + case 61: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Sint64) }() + case 62: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Fixed32) }() + case 63: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Fixed64) }() + case 64: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Sfixed32) }() + case 65: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Sfixed64) }() + case 66: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Float) }() + case 67: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Double) }() + case 68: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() + case 69: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() + case 70: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() + case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringNestedMessage) }() + case 72: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() + case 73: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringNestedEnum) }() + case 74: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringForeignEnum) }() + case 75: try { try decoder.decodeRepeatedInt32Field(value: &_storage._packedInt32) }() + case 76: try { try decoder.decodeRepeatedInt64Field(value: &_storage._packedInt64) }() + case 77: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._packedUint32) }() + case 78: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._packedUint64) }() + case 79: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._packedSint32) }() + case 80: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._packedSint64) }() + case 81: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._packedFixed32) }() + case 82: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._packedFixed64) }() + case 83: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._packedSfixed32) }() + case 84: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._packedSfixed64) }() + case 85: try { try decoder.decodeRepeatedFloatField(value: &_storage._packedFloat) }() + case 86: try { try decoder.decodeRepeatedDoubleField(value: &_storage._packedDouble) }() + case 87: try { try decoder.decodeRepeatedBoolField(value: &_storage._packedBool) }() + case 88: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedNestedEnum) }() + case 89: try { try decoder.decodeRepeatedInt32Field(value: &_storage._unpackedInt32) }() + case 90: try { try decoder.decodeRepeatedInt64Field(value: &_storage._unpackedInt64) }() + case 91: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._unpackedUint32) }() + case 92: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._unpackedUint64) }() + case 93: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._unpackedSint32) }() + case 94: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._unpackedSint64) }() + case 95: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._unpackedFixed32) }() + case 96: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._unpackedFixed64) }() + case 97: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._unpackedSfixed32) }() + case 98: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._unpackedSfixed64) }() + case 99: try { try decoder.decodeRepeatedFloatField(value: &_storage._unpackedFloat) }() + case 100: try { try decoder.decodeRepeatedDoubleField(value: &_storage._unpackedDouble) }() + case 101: try { try decoder.decodeRepeatedBoolField(value: &_storage._unpackedBool) }() + case 102: try { try decoder.decodeRepeatedEnumField(value: &_storage._unpackedNestedEnum) }() + case 111: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 112: try { + var v: ProtobufTestMessages_Edition_TestAllTypesEdition.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage(v) + } + }() + case 113: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 114: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() + case 115: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBool(v) + } + }() + case 116: try { + var v: UInt64? + try decoder.decodeSingularUInt64Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint64(v) + } + }() + case 117: try { + var v: Float? + try decoder.decodeSingularFloatField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofFloat(v) + } + }() + case 118: try { + var v: Double? + try decoder.decodeSingularDoubleField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofDouble(v) + } + }() + case 119: try { + var v: ProtobufTestMessages_Edition_TestAllTypesEdition.NestedEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofEnum(v) + } + }() + case 201: try { try decoder.decodeSingularGroupField(value: &_storage._data) }() + case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 242: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 243: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 244: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 245: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 246: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 247: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 248: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 249: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 250: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 251: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 252: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 253: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 254: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 255: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() + case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldname1) }() + case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName2) }() + case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName3) }() + case 404: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name4_) }() + case 405: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name5) }() + case 406: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name6) }() + case 407: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName7) }() + case 408: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName8) }() + case 409: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName9) }() + case 410: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName10) }() + case 411: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName11) }() + case 412: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName12) }() + case 413: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName13) }() + case 414: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName14) }() + case 415: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name15) }() + case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name16) }() + case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName17__) }() + case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName18__) }() + case 120..<201: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Edition_TestAllTypesEdition.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._optionalInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._optionalUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._optionalSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._optionalSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._optionalFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._optionalFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._optionalSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._optionalSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._optionalFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._optionalDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._optionalBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._optionalForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._optionalNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._optionalForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._optionalStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._optionalCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + if !_storage._repeatedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + } + if !_storage._repeatedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + } + if !_storage._repeatedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + } + if !_storage._repeatedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + } + if !_storage._repeatedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + } + if !_storage._repeatedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + } + if !_storage._repeatedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + } + if !_storage._repeatedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + } + if !_storage._repeatedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + } + if !_storage._repeatedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + } + if !_storage._repeatedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + } + if !_storage._repeatedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + } + if !_storage._repeatedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + } + if !_storage._repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) + } + if !_storage._repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) + } + if !_storage._repeatedNestedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) + } + if !_storage._repeatedForeignMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) + } + if !_storage._repeatedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + } + if !_storage._repeatedForeignEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) + } + if !_storage._repeatedStringPiece.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) + } + if !_storage._repeatedCord.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) + } + if !_storage._mapInt32Int32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Int32, fieldNumber: 56) + } + if !_storage._mapInt64Int64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Int64, fieldNumber: 57) + } + if !_storage._mapUint32Uint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Uint32, fieldNumber: 58) + } + if !_storage._mapUint64Uint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Uint64, fieldNumber: 59) + } + if !_storage._mapSint32Sint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Sint32, fieldNumber: 60) + } + if !_storage._mapSint64Sint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Sint64, fieldNumber: 61) + } + if !_storage._mapFixed32Fixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Fixed32, fieldNumber: 62) + } + if !_storage._mapFixed64Fixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Fixed64, fieldNumber: 63) + } + if !_storage._mapSfixed32Sfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 64) + } + if !_storage._mapSfixed64Sfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 65) + } + if !_storage._mapInt32Float.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Float, fieldNumber: 66) + } + if !_storage._mapInt32Double.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Double, fieldNumber: 67) + } + if !_storage._mapBoolBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolBool, fieldNumber: 68) + } + if !_storage._mapStringString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringString, fieldNumber: 69) + } + if !_storage._mapStringBytes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 70) + } + if !_storage._mapStringNestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringNestedMessage, fieldNumber: 71) + } + if !_storage._mapStringForeignMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 72) + } + if !_storage._mapStringNestedEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringNestedEnum, fieldNumber: 73) + } + if !_storage._mapStringForeignEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringForeignEnum, fieldNumber: 74) + } + if !_storage._packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._packedInt32, fieldNumber: 75) + } + if !_storage._packedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._packedInt64, fieldNumber: 76) + } + if !_storage._packedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._packedUint32, fieldNumber: 77) + } + if !_storage._packedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._packedUint64, fieldNumber: 78) + } + if !_storage._packedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._packedSint32, fieldNumber: 79) + } + if !_storage._packedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._packedSint64, fieldNumber: 80) + } + if !_storage._packedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._packedFixed32, fieldNumber: 81) + } + if !_storage._packedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._packedFixed64, fieldNumber: 82) + } + if !_storage._packedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._packedSfixed32, fieldNumber: 83) + } + if !_storage._packedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._packedSfixed64, fieldNumber: 84) + } + if !_storage._packedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._packedFloat, fieldNumber: 85) + } + if !_storage._packedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._packedDouble, fieldNumber: 86) + } + if !_storage._packedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._packedBool, fieldNumber: 87) + } + if !_storage._packedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedNestedEnum, fieldNumber: 88) + } + if !_storage._unpackedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._unpackedInt32, fieldNumber: 89) + } + if !_storage._unpackedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._unpackedInt64, fieldNumber: 90) + } + if !_storage._unpackedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._unpackedUint32, fieldNumber: 91) + } + if !_storage._unpackedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._unpackedUint64, fieldNumber: 92) + } + if !_storage._unpackedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._unpackedSint32, fieldNumber: 93) + } + if !_storage._unpackedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._unpackedSint64, fieldNumber: 94) + } + if !_storage._unpackedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._unpackedFixed32, fieldNumber: 95) + } + if !_storage._unpackedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._unpackedFixed64, fieldNumber: 96) + } + if !_storage._unpackedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._unpackedSfixed32, fieldNumber: 97) + } + if !_storage._unpackedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._unpackedSfixed64, fieldNumber: 98) + } + if !_storage._unpackedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._unpackedFloat, fieldNumber: 99) + } + if !_storage._unpackedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._unpackedDouble, fieldNumber: 100) + } + if !_storage._unpackedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._unpackedBool, fieldNumber: 101) + } + if !_storage._unpackedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._unpackedNestedEnum, fieldNumber: 102) + } + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case .oneofBool?: try { + guard case .oneofBool(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 115) + }() + case .oneofUint64?: try { + guard case .oneofUint64(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 116) + }() + case .oneofFloat?: try { + guard case .oneofFloat(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularFloatField(value: v, fieldNumber: 117) + }() + case .oneofDouble?: try { + guard case .oneofDouble(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularDoubleField(value: v, fieldNumber: 118) + }() + case .oneofEnum?: try { + guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 119) + }() + case nil: break + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201) + try { if let v = _storage._data { + try visitor.visitSingularGroupField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 241) + } }() + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 242) + } }() + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 243) + } }() + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 244) + } }() + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 245) + } }() + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 246) + } }() + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 247) + } }() + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 248) + } }() + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 249) + } }() + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 250) + } }() + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 251) + } }() + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 252) + } }() + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 253) + } }() + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 254) + } }() + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 255) + } }() + try { if let v = _storage._fieldname1 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 401) + } }() + try { if let v = _storage._fieldName2 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 402) + } }() + try { if let v = _storage._fieldName3 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 403) + } }() + try { if let v = _storage._field_Name4_ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 404) + } }() + try { if let v = _storage._field0Name5 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 405) + } }() + try { if let v = _storage._field0Name6 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 406) + } }() + try { if let v = _storage._fieldName7 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 407) + } }() + try { if let v = _storage._fieldName8 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 408) + } }() + try { if let v = _storage._fieldName9 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 409) + } }() + try { if let v = _storage._fieldName10 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 410) + } }() + try { if let v = _storage._fieldName11 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 411) + } }() + try { if let v = _storage._fieldName12 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 412) + } }() + try { if let v = _storage.__FieldName13 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 413) + } }() + try { if let v = _storage.__FieldName14 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 414) + } }() + try { if let v = _storage._field_Name15 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 415) + } }() + try { if let v = _storage._field_Name16 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 416) + } }() + try { if let v = _storage._fieldName17__ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 417) + } }() + try { if let v = _storage._fieldName18__ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 418) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_TestAllTypesEdition, rhs: ProtobufTestMessages_Edition_TestAllTypesEdition) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} + if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} + if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} + if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} + if _storage._repeatedCord != rhs_storage._repeatedCord {return false} + if _storage._packedInt32 != rhs_storage._packedInt32 {return false} + if _storage._packedInt64 != rhs_storage._packedInt64 {return false} + if _storage._packedUint32 != rhs_storage._packedUint32 {return false} + if _storage._packedUint64 != rhs_storage._packedUint64 {return false} + if _storage._packedSint32 != rhs_storage._packedSint32 {return false} + if _storage._packedSint64 != rhs_storage._packedSint64 {return false} + if _storage._packedFixed32 != rhs_storage._packedFixed32 {return false} + if _storage._packedFixed64 != rhs_storage._packedFixed64 {return false} + if _storage._packedSfixed32 != rhs_storage._packedSfixed32 {return false} + if _storage._packedSfixed64 != rhs_storage._packedSfixed64 {return false} + if _storage._packedFloat != rhs_storage._packedFloat {return false} + if _storage._packedDouble != rhs_storage._packedDouble {return false} + if _storage._packedBool != rhs_storage._packedBool {return false} + if _storage._packedNestedEnum != rhs_storage._packedNestedEnum {return false} + if _storage._unpackedInt32 != rhs_storage._unpackedInt32 {return false} + if _storage._unpackedInt64 != rhs_storage._unpackedInt64 {return false} + if _storage._unpackedUint32 != rhs_storage._unpackedUint32 {return false} + if _storage._unpackedUint64 != rhs_storage._unpackedUint64 {return false} + if _storage._unpackedSint32 != rhs_storage._unpackedSint32 {return false} + if _storage._unpackedSint64 != rhs_storage._unpackedSint64 {return false} + if _storage._unpackedFixed32 != rhs_storage._unpackedFixed32 {return false} + if _storage._unpackedFixed64 != rhs_storage._unpackedFixed64 {return false} + if _storage._unpackedSfixed32 != rhs_storage._unpackedSfixed32 {return false} + if _storage._unpackedSfixed64 != rhs_storage._unpackedSfixed64 {return false} + if _storage._unpackedFloat != rhs_storage._unpackedFloat {return false} + if _storage._unpackedDouble != rhs_storage._unpackedDouble {return false} + if _storage._unpackedBool != rhs_storage._unpackedBool {return false} + if _storage._unpackedNestedEnum != rhs_storage._unpackedNestedEnum {return false} + if _storage._mapInt32Int32 != rhs_storage._mapInt32Int32 {return false} + if _storage._mapInt64Int64 != rhs_storage._mapInt64Int64 {return false} + if _storage._mapUint32Uint32 != rhs_storage._mapUint32Uint32 {return false} + if _storage._mapUint64Uint64 != rhs_storage._mapUint64Uint64 {return false} + if _storage._mapSint32Sint32 != rhs_storage._mapSint32Sint32 {return false} + if _storage._mapSint64Sint64 != rhs_storage._mapSint64Sint64 {return false} + if _storage._mapFixed32Fixed32 != rhs_storage._mapFixed32Fixed32 {return false} + if _storage._mapFixed64Fixed64 != rhs_storage._mapFixed64Fixed64 {return false} + if _storage._mapSfixed32Sfixed32 != rhs_storage._mapSfixed32Sfixed32 {return false} + if _storage._mapSfixed64Sfixed64 != rhs_storage._mapSfixed64Sfixed64 {return false} + if _storage._mapInt32Float != rhs_storage._mapInt32Float {return false} + if _storage._mapInt32Double != rhs_storage._mapInt32Double {return false} + if _storage._mapBoolBool != rhs_storage._mapBoolBool {return false} + if _storage._mapStringString != rhs_storage._mapStringString {return false} + if _storage._mapStringBytes != rhs_storage._mapStringBytes {return false} + if _storage._mapStringNestedMessage != rhs_storage._mapStringNestedMessage {return false} + if _storage._mapStringForeignMessage != rhs_storage._mapStringForeignMessage {return false} + if _storage._mapStringNestedEnum != rhs_storage._mapStringNestedEnum {return false} + if _storage._mapStringForeignEnum != rhs_storage._mapStringForeignEnum {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + if _storage._data != rhs_storage._data {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} + if _storage._fieldname1 != rhs_storage._fieldname1 {return false} + if _storage._fieldName2 != rhs_storage._fieldName2 {return false} + if _storage._fieldName3 != rhs_storage._fieldName3 {return false} + if _storage._field_Name4_ != rhs_storage._field_Name4_ {return false} + if _storage._field0Name5 != rhs_storage._field0Name5 {return false} + if _storage._field0Name6 != rhs_storage._field0Name6 {return false} + if _storage._fieldName7 != rhs_storage._fieldName7 {return false} + if _storage._fieldName8 != rhs_storage._fieldName8 {return false} + if _storage._fieldName9 != rhs_storage._fieldName9 {return false} + if _storage._fieldName10 != rhs_storage._fieldName10 {return false} + if _storage._fieldName11 != rhs_storage._fieldName11 {return false} + if _storage._fieldName12 != rhs_storage._fieldName12 {return false} + if _storage.__FieldName13 != rhs_storage.__FieldName13 {return false} + if _storage.__FieldName14 != rhs_storage.__FieldName14 {return false} + if _storage._field_Name15 != rhs_storage._field_Name15 {return false} + if _storage._field_Name16 != rhs_storage._field_Name16 {return false} + if _storage._fieldName17__ != rhs_storage._fieldName17__ {return false} + if _storage._fieldName18__ != rhs_storage._fieldName18__ {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Edition_TestAllTypesEdition.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Edition_TestAllTypesEdition.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Edition_TestAllTypesEdition.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _corecursive: ProtobufTestMessages_Edition_TestAllTypesEdition? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._corecursive, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_TestAllTypesEdition.NestedMessage, rhs: ProtobufTestMessages_Edition_TestAllTypesEdition.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Edition_TestAllTypesEdition.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Edition_TestAllTypesEdition.protoMessageName + ".Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}J\u{3}group_int32\0\u{3}group_uint32\0") + + 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 202: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 203: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 202) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 203) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_TestAllTypesEdition.DataMessage, rhs: ProtobufTestMessages_Edition_TestAllTypesEdition.DataMessage) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Edition_TestAllTypesEdition.protoMessageName + ".MessageSetCorrect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrect.self) + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrect, rhs: ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrect) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Edition_TestAllTypesEdition.protoMessageName + ".MessageSetCorrectExtension1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{19}str\0") + + 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 25: try { try decoder.decodeSingularStringField(value: &self._str) }() + 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 + try { if let v = self._str { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension1, rhs: ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension1) -> Bool { + if lhs._str != rhs._str {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Edition_TestAllTypesEdition.protoMessageName + ".MessageSetCorrectExtension2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{9}i\0") + + 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 9: try { try decoder.decodeSingularInt32Field(value: &self._i) }() + 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 + try { if let v = self._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension2, rhs: ProtobufTestMessages_Edition_TestAllTypesEdition.MessageSetCorrectExtension2) -> Bool { + if lhs._i != rhs._i {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Edition_ForeignMessageEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessageEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") + + 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._c) }() + 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 + try { if let v = self._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_ForeignMessageEdition, rhs: ProtobufTestMessages_Edition_ForeignMessageEdition) -> Bool { + if lhs._c != rhs._c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Edition_UnknownToTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".UnknownToTestAllTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}i\u{f}optional_int32\0\u{3}optional_string\0\u{3}nested_message\0\u{7}OptionalGroup\0\u{4}\u{2}optional_bool\0\u{4}\u{5}repeated_int32\0") + + 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 1001: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32) }() + case 1002: try { try decoder.decodeSingularStringField(value: &self._optionalString) }() + case 1003: try { try decoder.decodeSingularMessageField(value: &self._nestedMessage) }() + case 1004: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() + case 1006: try { try decoder.decodeSingularBoolField(value: &self._optionalBool) }() + case 1011: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() + 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 + try { if let v = self._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1001) + } }() + try { if let v = self._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1002) + } }() + try { if let v = self._nestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1003) + } }() + try { if let v = self._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 1004) + } }() + try { if let v = self._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1006) + } }() + if !self.repeatedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: self.repeatedInt32, fieldNumber: 1011) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_UnknownToTestAllTypes, rhs: ProtobufTestMessages_Edition_UnknownToTestAllTypes) -> Bool { + if lhs._optionalInt32 != rhs._optionalInt32 {return false} + if lhs._optionalString != rhs._optionalString {return false} + if lhs._nestedMessage != rhs._nestedMessage {return false} + if lhs._optionalGroup != rhs._optionalGroup {return false} + if lhs._optionalBool != rhs._optionalBool {return false} + if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Edition_UnknownToTestAllTypes.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Edition_UnknownToTestAllTypes.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") + + 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._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_UnknownToTestAllTypes.OptionalGroup, rhs: ProtobufTestMessages_Edition_UnknownToTestAllTypes.OptionalGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Edition_NullHypothesisEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NullHypothesisEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_NullHypothesisEdition, rhs: ProtobufTestMessages_Edition_NullHypothesisEdition) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Edition_EnumOnlyEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumOnlyEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_EnumOnlyEdition, rhs: ProtobufTestMessages_Edition_EnumOnlyEdition) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Edition_EnumOnlyEdition.BoolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0kFalse\0\u{1}kTrue\0") +} + +extension ProtobufTestMessages_Edition_OneStringEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OneStringEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_OneStringEdition, rhs: ProtobufTestMessages_Edition_OneStringEdition) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Edition_ProtoWithKeywords: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ProtoWithKeywords" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}inline\0\u{1}concept\0\u{1}requires\0") + + 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._inline) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._concept) }() + case 3: try { try decoder.decodeRepeatedStringField(value: &self.requires) }() + 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 + try { if let v = self._inline { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._concept { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + if !self.requires.isEmpty { + try visitor.visitRepeatedStringField(value: self.requires, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_ProtoWithKeywords, rhs: ProtobufTestMessages_Edition_ProtoWithKeywords) -> Bool { + if lhs._inline != rhs._inline {return false} + if lhs._concept != rhs._concept {return false} + if lhs.requires != rhs.requires {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Edition_TestAllRequiredTypesEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllRequiredTypesEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_int32\0\u{3}required_int64\0\u{3}required_uint32\0\u{3}required_uint64\0\u{3}required_sint32\0\u{3}required_sint64\0\u{3}required_fixed32\0\u{3}required_fixed64\0\u{3}required_sfixed32\0\u{3}required_sfixed64\0\u{3}required_float\0\u{3}required_double\0\u{3}required_bool\0\u{3}required_string\0\u{3}required_bytes\0\u{4}\u{3}required_nested_message\0\u{3}required_foreign_message\0\u{4}\u{2}required_nested_enum\0\u{3}required_foreign_enum\0\u{4}\u{2}required_string_piece\0\u{3}required_cord\0\u{4}\u{2}recursive_message\0\u{3}optional_recursive_message\0\u{8}m\u{2}Data\0\u{4}(default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{c}h\u{f}hL\u{2}") + + fileprivate class _StorageClass { + var _requiredInt32: Int32? = nil + var _requiredInt64: Int64? = nil + var _requiredUint32: UInt32? = nil + var _requiredUint64: UInt64? = nil + var _requiredSint32: Int32? = nil + var _requiredSint64: Int64? = nil + var _requiredFixed32: UInt32? = nil + var _requiredFixed64: UInt64? = nil + var _requiredSfixed32: Int32? = nil + var _requiredSfixed64: Int64? = nil + var _requiredFloat: Float? = nil + var _requiredDouble: Double? = nil + var _requiredBool: Bool? = nil + var _requiredString: String? = nil + var _requiredBytes: Data? = nil + var _requiredNestedMessage: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.NestedMessage? = nil + var _requiredForeignMessage: ProtobufTestMessages_Edition_ForeignMessageEdition? = nil + var _requiredNestedEnum: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.NestedEnum? = nil + var _requiredForeignEnum: ProtobufTestMessages_Edition_ForeignEnumEdition? = nil + var _requiredStringPiece: String? = nil + var _requiredCord: String? = nil + var _recursiveMessage: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition? = nil + var _optionalRecursiveMessage: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition? = nil + var _data: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.DataMessage? = nil + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _requiredInt32 = source._requiredInt32 + _requiredInt64 = source._requiredInt64 + _requiredUint32 = source._requiredUint32 + _requiredUint64 = source._requiredUint64 + _requiredSint32 = source._requiredSint32 + _requiredSint64 = source._requiredSint64 + _requiredFixed32 = source._requiredFixed32 + _requiredFixed64 = source._requiredFixed64 + _requiredSfixed32 = source._requiredSfixed32 + _requiredSfixed64 = source._requiredSfixed64 + _requiredFloat = source._requiredFloat + _requiredDouble = source._requiredDouble + _requiredBool = source._requiredBool + _requiredString = source._requiredString + _requiredBytes = source._requiredBytes + _requiredNestedMessage = source._requiredNestedMessage + _requiredForeignMessage = source._requiredForeignMessage + _requiredNestedEnum = source._requiredNestedEnum + _requiredForeignEnum = source._requiredForeignEnum + _requiredStringPiece = source._requiredStringPiece + _requiredCord = source._requiredCord + _recursiveMessage = source._recursiveMessage + _optionalRecursiveMessage = source._optionalRecursiveMessage + _data = source._data + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._requiredInt32 == nil {return false} + if _storage._requiredInt64 == nil {return false} + if _storage._requiredUint32 == nil {return false} + if _storage._requiredUint64 == nil {return false} + if _storage._requiredSint32 == nil {return false} + if _storage._requiredSint64 == nil {return false} + if _storage._requiredFixed32 == nil {return false} + if _storage._requiredFixed64 == nil {return false} + if _storage._requiredSfixed32 == nil {return false} + if _storage._requiredSfixed64 == nil {return false} + if _storage._requiredFloat == nil {return false} + if _storage._requiredDouble == nil {return false} + if _storage._requiredBool == nil {return false} + if _storage._requiredString == nil {return false} + if _storage._requiredBytes == nil {return false} + if _storage._requiredNestedMessage == nil {return false} + if _storage._requiredForeignMessage == nil {return false} + if _storage._requiredNestedEnum == nil {return false} + if _storage._requiredForeignEnum == nil {return false} + if _storage._requiredStringPiece == nil {return false} + if _storage._requiredCord == nil {return false} + if _storage._defaultInt32 == nil {return false} + if _storage._defaultInt64 == nil {return false} + if _storage._defaultUint32 == nil {return false} + if _storage._defaultUint64 == nil {return false} + if _storage._defaultSint32 == nil {return false} + if _storage._defaultSint64 == nil {return false} + if _storage._defaultFixed32 == nil {return false} + if _storage._defaultFixed64 == nil {return false} + if _storage._defaultSfixed32 == nil {return false} + if _storage._defaultSfixed64 == nil {return false} + if _storage._defaultFloat == nil {return false} + if _storage._defaultDouble == nil {return false} + if _storage._defaultBool == nil {return false} + if _storage._defaultString == nil {return false} + if _storage._defaultBytes == nil {return false} + if let v = _storage._requiredNestedMessage, !v.isInitialized {return false} + if let v = _storage._recursiveMessage, !v.isInitialized {return false} + if let v = _storage._optionalRecursiveMessage, !v.isInitialized {return false} + if let v = _storage._data, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._requiredInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._requiredInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._requiredUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._requiredUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._requiredSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._requiredSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._requiredFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._requiredFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._requiredSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._requiredSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._requiredFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._requiredDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._requiredBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._requiredString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._requiredBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._requiredNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._requiredForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._requiredNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._requiredForeignEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._requiredStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._requiredCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 28: try { try decoder.decodeSingularMessageField(value: &_storage._optionalRecursiveMessage) }() + case 201: try { try decoder.decodeSingularGroupField(value: &_storage._data) }() + case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 242: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 243: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 244: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 245: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 246: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 247: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 248: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 249: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 250: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 251: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 252: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 253: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 254: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 255: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() + case 120..<201: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._requiredInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._requiredInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._requiredUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._requiredUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._requiredSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._requiredSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._requiredFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._requiredFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._requiredSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._requiredSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._requiredFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._requiredDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._requiredBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._requiredString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._requiredBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._requiredNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._requiredForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._requiredNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._requiredForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._requiredStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._requiredCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + try { if let v = _storage._optionalRecursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 28) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201) + try { if let v = _storage._data { + try visitor.visitSingularGroupField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 241) + } }() + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 242) + } }() + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 243) + } }() + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 244) + } }() + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 245) + } }() + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 246) + } }() + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 247) + } }() + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 248) + } }() + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 249) + } }() + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 250) + } }() + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 251) + } }() + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 252) + } }() + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 253) + } }() + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 254) + } }() + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 255) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition, rhs: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition) -> 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._requiredInt32 != rhs_storage._requiredInt32 {return false} + if _storage._requiredInt64 != rhs_storage._requiredInt64 {return false} + if _storage._requiredUint32 != rhs_storage._requiredUint32 {return false} + if _storage._requiredUint64 != rhs_storage._requiredUint64 {return false} + if _storage._requiredSint32 != rhs_storage._requiredSint32 {return false} + if _storage._requiredSint64 != rhs_storage._requiredSint64 {return false} + if _storage._requiredFixed32 != rhs_storage._requiredFixed32 {return false} + if _storage._requiredFixed64 != rhs_storage._requiredFixed64 {return false} + if _storage._requiredSfixed32 != rhs_storage._requiredSfixed32 {return false} + if _storage._requiredSfixed64 != rhs_storage._requiredSfixed64 {return false} + if _storage._requiredFloat != rhs_storage._requiredFloat {return false} + if _storage._requiredDouble != rhs_storage._requiredDouble {return false} + if _storage._requiredBool != rhs_storage._requiredBool {return false} + if _storage._requiredString != rhs_storage._requiredString {return false} + if _storage._requiredBytes != rhs_storage._requiredBytes {return false} + if _storage._requiredNestedMessage != rhs_storage._requiredNestedMessage {return false} + if _storage._requiredForeignMessage != rhs_storage._requiredForeignMessage {return false} + if _storage._requiredNestedEnum != rhs_storage._requiredNestedEnum {return false} + if _storage._requiredForeignEnum != rhs_storage._requiredForeignEnum {return false} + if _storage._requiredStringPiece != rhs_storage._requiredStringPiece {return false} + if _storage._requiredCord != rhs_storage._requiredCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._optionalRecursiveMessage != rhs_storage._optionalRecursiveMessage {return false} + if _storage._data != rhs_storage._data {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0\u{3}optional_corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _corecursive: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition? = nil + var _optionalCorecursive: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + _optionalCorecursive = source._optionalCorecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._a == nil {return false} + if _storage._corecursive == nil {return false} + if let v = _storage._corecursive, !v.isInitialized {return false} + if let v = _storage._optionalCorecursive, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._optionalCorecursive) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalCorecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.NestedMessage, rhs: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + if _storage._optionalCorecursive != rhs_storage._optionalCorecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.protoMessageName + ".Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}J\u{3}group_int32\0\u{3}group_uint32\0") + + public var isInitialized: Bool { + if self._groupInt32 == nil {return false} + if self._groupUint32 == nil {return false} + return true + } + + 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 202: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 203: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 202) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 203) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.DataMessage, rhs: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.DataMessage) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.protoMessageName + ".MessageSetCorrect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrect.self) + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrect, rhs: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrect) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.protoMessageName + ".MessageSetCorrectExtension1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{19}str\0") + + public var isInitialized: Bool { + if self._str == nil {return false} + return true + } + + 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 25: try { try decoder.decodeSingularStringField(value: &self._str) }() + 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 + try { if let v = self._str { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension1, rhs: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension1) -> Bool { + if lhs._str != rhs._str {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.protoMessageName + ".MessageSetCorrectExtension2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{9}i\0") + + public var isInitialized: Bool { + if self._i == nil {return false} + return true + } + + 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 9: try { try decoder.decodeSingularInt32Field(value: &self._i) }() + 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 + try { if let v = self._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension2, rhs: ProtobufTestMessages_Edition_TestAllRequiredTypesEdition.MessageSetCorrectExtension2) -> Bool { + if lhs._i != rhs._i {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/source_context.pb.swift b/Reference/upstream/google/protobuf/source_context.pb.swift new file mode 100644 index 000000000..53b5753e2 --- /dev/null +++ b/Reference/upstream/google/protobuf/source_context.pb.swift @@ -0,0 +1,101 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/source_context.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. + +// 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: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// `SourceContext` represents information about the source of a +/// protobuf element, like the file in which it is defined. +struct Google_Protobuf_SourceContext: Sendable { + // 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. + + /// The path-qualified name of the .proto file that contained the associated + /// protobuf element. For example: `"google/protobuf/source_context.proto"`. + var fileName: String = String() + + var unknownFields = UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "google.protobuf" + +extension Google_Protobuf_SourceContext: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".SourceContext" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}file_name\0") + + 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.fileName) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.fileName.isEmpty { + try visitor.visitSingularStringField(value: self.fileName, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_SourceContext, rhs: Google_Protobuf_SourceContext) -> Bool { + if lhs.fileName != rhs.fileName {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/struct.pb.swift b/Reference/upstream/google/protobuf/struct.pb.swift new file mode 100644 index 000000000..023b628b9 --- /dev/null +++ b/Reference/upstream/google/protobuf/struct.pb.swift @@ -0,0 +1,397 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/struct.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. + +// 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: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// `NullValue` is a singleton enumeration to represent the null value for the +/// `Value` type union. +/// +/// The JSON representation for `NullValue` is JSON `null`. +enum Google_Protobuf_NullValue: Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// Null value. + case nullValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .nullValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .nullValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .nullValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Google_Protobuf_NullValue] = [ + .nullValue, + ] + +} + +/// `Struct` represents a structured data value, consisting of fields +/// which map to dynamically typed values. In some languages, `Struct` +/// might be supported by a native representation. For example, in +/// scripting languages like JS a struct is represented as an +/// object. The details of that representation are described together +/// with the proto support for the language. +/// +/// The JSON representation for `Struct` is JSON object. +struct Google_Protobuf_Struct: Sendable { + // 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. + + /// Unordered map of dynamically typed values. + var fields: Dictionary = [:] + + var unknownFields = UnknownStorage() + + init() {} +} + +/// `Value` represents a dynamically typed value which can be either +/// null, a number, a string, a boolean, a recursive struct value, or a +/// list of values. A producer of value is expected to set one of these +/// variants. Absence of any variant indicates an error. +/// +/// The JSON representation for `Value` is JSON value. +struct Google_Protobuf_Value: Sendable { + // 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. + + /// The kind of value. + var kind: Google_Protobuf_Value.OneOf_Kind? = nil + + /// Represents a null value. + var nullValue: Google_Protobuf_NullValue { + get { + if case .nullValue(let v)? = kind {return v} + return .nullValue + } + set {kind = .nullValue(newValue)} + } + + /// Represents a double value. + var numberValue: Double { + get { + if case .numberValue(let v)? = kind {return v} + return 0 + } + set {kind = .numberValue(newValue)} + } + + /// Represents a string value. + var stringValue: String { + get { + if case .stringValue(let v)? = kind {return v} + return String() + } + set {kind = .stringValue(newValue)} + } + + /// Represents a boolean value. + var boolValue: Bool { + get { + if case .boolValue(let v)? = kind {return v} + return false + } + set {kind = .boolValue(newValue)} + } + + /// Represents a structured value. + var structValue: Google_Protobuf_Struct { + get { + if case .structValue(let v)? = kind {return v} + return Google_Protobuf_Struct() + } + set {kind = .structValue(newValue)} + } + + /// Represents a repeated `Value`. + var listValue: Google_Protobuf_ListValue { + get { + if case .listValue(let v)? = kind {return v} + return Google_Protobuf_ListValue() + } + set {kind = .listValue(newValue)} + } + + var unknownFields = UnknownStorage() + + /// The kind of value. + enum OneOf_Kind: Equatable, Sendable { + /// Represents a null value. + case nullValue(Google_Protobuf_NullValue) + /// Represents a double value. + case numberValue(Double) + /// Represents a string value. + case stringValue(String) + /// Represents a boolean value. + case boolValue(Bool) + /// Represents a structured value. + case structValue(Google_Protobuf_Struct) + /// Represents a repeated `Value`. + case listValue(Google_Protobuf_ListValue) + + } + + init() {} +} + +/// `ListValue` is a wrapper around a repeated field of values. +/// +/// The JSON representation for `ListValue` is JSON array. +struct Google_Protobuf_ListValue: Sendable { + // 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. + + /// Repeated field of dynamically typed values. + var values: [Google_Protobuf_Value] = [] + + var unknownFields = UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "google.protobuf" + +extension Google_Protobuf_NullValue: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0NULL_VALUE\0") +} + +extension Google_Protobuf_Struct: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Struct" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}fields\0") + + 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.decodeMapField(fieldType: _ProtobufMessageMap.self, value: &self.fields) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.fields.isEmpty { + try visitor.visitMapField(fieldType: _ProtobufMessageMap.self, value: self.fields, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_Struct, rhs: Google_Protobuf_Struct) -> Bool { + if lhs.fields != rhs.fields {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_Value: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Value" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}null_value\0\u{3}number_value\0\u{3}string_value\0\u{3}bool_value\0\u{3}struct_value\0\u{3}list_value\0") + + 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: Google_Protobuf_NullValue? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if self.kind != nil {try decoder.handleConflictingOneOf()} + self.kind = .nullValue(v) + } + }() + case 2: try { + var v: Double? + try decoder.decodeSingularDoubleField(value: &v) + if let v = v { + if self.kind != nil {try decoder.handleConflictingOneOf()} + self.kind = .numberValue(v) + } + }() + case 3: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.kind != nil {try decoder.handleConflictingOneOf()} + self.kind = .stringValue(v) + } + }() + case 4: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if self.kind != nil {try decoder.handleConflictingOneOf()} + self.kind = .boolValue(v) + } + }() + case 5: try { + var v: Google_Protobuf_Struct? + var hadOneofValue = false + if let current = self.kind { + hadOneofValue = true + if case .structValue(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.kind = .structValue(v) + } + }() + case 6: try { + var v: Google_Protobuf_ListValue? + var hadOneofValue = false + if let current = self.kind { + hadOneofValue = true + if case .listValue(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.kind = .listValue(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.kind { + case .nullValue?: try { + guard case .nullValue(let v)? = self.kind else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + }() + case .numberValue?: try { + guard case .numberValue(let v)? = self.kind else { preconditionFailure() } + try visitor.visitSingularDoubleField(value: v, fieldNumber: 2) + }() + case .stringValue?: try { + guard case .stringValue(let v)? = self.kind else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 3) + }() + case .boolValue?: try { + guard case .boolValue(let v)? = self.kind else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 4) + }() + case .structValue?: try { + guard case .structValue(let v)? = self.kind else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + }() + case .listValue?: try { + guard case .listValue(let v)? = self.kind else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 6) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_Value, rhs: Google_Protobuf_Value) -> Bool { + if lhs.kind != rhs.kind {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_ListValue: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ListValue" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}values\0") + + 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.decodeRepeatedMessageField(value: &self.values) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.values.isEmpty { + try visitor.visitRepeatedMessageField(value: self.values, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_ListValue, rhs: Google_Protobuf_ListValue) -> Bool { + if lhs.values != rhs.values {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/test_messages_proto2.pb.swift b/Reference/upstream/google/protobuf/test_messages_proto2.pb.swift new file mode 100644 index 000000000..2ea8fa80e --- /dev/null +++ b/Reference/upstream/google/protobuf/test_messages_proto2.pb.swift @@ -0,0 +1,4827 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/test_messages_proto2.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Test schema for proto2 messages. This test schema is used by: +// +// - conformance tests + +// LINT: ALLOW_GROUPS + +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 ProtobufTestMessages_Proto2_ForeignEnumProto2: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foreignFoo = 0 + case foreignBar = 1 + case foreignBaz = 2 + + init() { + self = .foreignFoo + } + +} + +/// This proto includes every type of field in both singular and repeated +/// forms. +/// +/// Also, crucially, all messages and enums in this file are eventually +/// submessages of this message. So for example, a fuzz test of TestAllTypes +/// could trigger bugs that occur in any message type in this file. We verify +/// this stays true in a unit test. +struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Singular + var optionalInt32: Int32 { + get {_storage._optionalInt32 ?? 0} + set {_uniqueStorage()._optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} + + var optionalInt64: Int64 { + get {_storage._optionalInt64 ?? 0} + set {_uniqueStorage()._optionalInt64 = newValue} + } + /// Returns true if `optionalInt64` has been explicitly set. + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} + /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} + + var optionalUint32: UInt32 { + get {_storage._optionalUint32 ?? 0} + set {_uniqueStorage()._optionalUint32 = newValue} + } + /// Returns true if `optionalUint32` has been explicitly set. + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} + /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} + + var optionalUint64: UInt64 { + get {_storage._optionalUint64 ?? 0} + set {_uniqueStorage()._optionalUint64 = newValue} + } + /// Returns true if `optionalUint64` has been explicitly set. + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} + /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} + + var optionalSint32: Int32 { + get {_storage._optionalSint32 ?? 0} + set {_uniqueStorage()._optionalSint32 = newValue} + } + /// Returns true if `optionalSint32` has been explicitly set. + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} + /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} + + var optionalSint64: Int64 { + get {_storage._optionalSint64 ?? 0} + set {_uniqueStorage()._optionalSint64 = newValue} + } + /// Returns true if `optionalSint64` has been explicitly set. + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} + /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} + + var optionalFixed32: UInt32 { + get {_storage._optionalFixed32 ?? 0} + set {_uniqueStorage()._optionalFixed32 = newValue} + } + /// Returns true if `optionalFixed32` has been explicitly set. + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} + /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} + + var optionalFixed64: UInt64 { + get {_storage._optionalFixed64 ?? 0} + set {_uniqueStorage()._optionalFixed64 = newValue} + } + /// Returns true if `optionalFixed64` has been explicitly set. + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} + /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} + + var optionalSfixed32: Int32 { + get {_storage._optionalSfixed32 ?? 0} + set {_uniqueStorage()._optionalSfixed32 = newValue} + } + /// Returns true if `optionalSfixed32` has been explicitly set. + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} + /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} + + var optionalSfixed64: Int64 { + get {_storage._optionalSfixed64 ?? 0} + set {_uniqueStorage()._optionalSfixed64 = newValue} + } + /// Returns true if `optionalSfixed64` has been explicitly set. + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} + /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} + + var optionalFloat: Float { + get {_storage._optionalFloat ?? 0} + set {_uniqueStorage()._optionalFloat = newValue} + } + /// Returns true if `optionalFloat` has been explicitly set. + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} + /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} + + var optionalDouble: Double { + get {_storage._optionalDouble ?? 0} + set {_uniqueStorage()._optionalDouble = newValue} + } + /// Returns true if `optionalDouble` has been explicitly set. + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} + /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. + mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} + + var optionalBool: Bool { + get {_storage._optionalBool ?? false} + set {_uniqueStorage()._optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {_storage._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} + + var optionalString: String { + get {_storage._optionalString ?? String()} + set {_uniqueStorage()._optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {_storage._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} + + var optionalBytes: Data { + get {_storage._optionalBytes ?? Data()} + set {_uniqueStorage()._optionalBytes = newValue} + } + /// Returns true if `optionalBytes` has been explicitly set. + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} + /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} + + var optionalNestedMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage { + get {_storage._optionalNestedMessage ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage()} + set {_uniqueStorage()._optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} + + var optionalForeignMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2 { + get {_storage._optionalForeignMessage ?? ProtobufTestMessages_Proto2_ForeignMessageProto2()} + set {_uniqueStorage()._optionalForeignMessage = newValue} + } + /// Returns true if `optionalForeignMessage` has been explicitly set. + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} + /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} + + var optionalNestedEnum: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum { + get {_storage._optionalNestedEnum ?? .foo} + set {_uniqueStorage()._optionalNestedEnum = newValue} + } + /// Returns true if `optionalNestedEnum` has been explicitly set. + var hasOptionalNestedEnum: Bool {_storage._optionalNestedEnum != nil} + /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} + + var optionalForeignEnum: ProtobufTestMessages_Proto2_ForeignEnumProto2 { + get {_storage._optionalForeignEnum ?? .foreignFoo} + set {_uniqueStorage()._optionalForeignEnum = newValue} + } + /// Returns true if `optionalForeignEnum` has been explicitly set. + var hasOptionalForeignEnum: Bool {_storage._optionalForeignEnum != nil} + /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignEnum() {_uniqueStorage()._optionalForeignEnum = nil} + + var optionalStringPiece: String { + get {_storage._optionalStringPiece ?? String()} + set {_uniqueStorage()._optionalStringPiece = newValue} + } + /// Returns true if `optionalStringPiece` has been explicitly set. + var hasOptionalStringPiece: Bool {_storage._optionalStringPiece != nil} + /// Clears the value of `optionalStringPiece`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringPiece() {_uniqueStorage()._optionalStringPiece = nil} + + var optionalCord: String { + get {_storage._optionalCord ?? String()} + set {_uniqueStorage()._optionalCord = newValue} + } + /// Returns true if `optionalCord` has been explicitly set. + var hasOptionalCord: Bool {_storage._optionalCord != nil} + /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. + mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} + + var recursiveMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2 { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Proto2_TestAllTypesProto2()} + set {_uniqueStorage()._recursiveMessage = newValue} + } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} + + /// Repeated + var repeatedInt32: [Int32] { + get {_storage._repeatedInt32} + set {_uniqueStorage()._repeatedInt32 = newValue} + } + + var repeatedInt64: [Int64] { + get {_storage._repeatedInt64} + set {_uniqueStorage()._repeatedInt64 = newValue} + } + + var repeatedUint32: [UInt32] { + get {_storage._repeatedUint32} + set {_uniqueStorage()._repeatedUint32 = newValue} + } + + var repeatedUint64: [UInt64] { + get {_storage._repeatedUint64} + set {_uniqueStorage()._repeatedUint64 = newValue} + } + + var repeatedSint32: [Int32] { + get {_storage._repeatedSint32} + set {_uniqueStorage()._repeatedSint32 = newValue} + } + + var repeatedSint64: [Int64] { + get {_storage._repeatedSint64} + set {_uniqueStorage()._repeatedSint64 = newValue} + } + + var repeatedFixed32: [UInt32] { + get {_storage._repeatedFixed32} + set {_uniqueStorage()._repeatedFixed32 = newValue} + } + + var repeatedFixed64: [UInt64] { + get {_storage._repeatedFixed64} + set {_uniqueStorage()._repeatedFixed64 = newValue} + } + + var repeatedSfixed32: [Int32] { + get {_storage._repeatedSfixed32} + set {_uniqueStorage()._repeatedSfixed32 = newValue} + } + + var repeatedSfixed64: [Int64] { + get {_storage._repeatedSfixed64} + set {_uniqueStorage()._repeatedSfixed64 = newValue} + } + + var repeatedFloat: [Float] { + get {_storage._repeatedFloat} + set {_uniqueStorage()._repeatedFloat = newValue} + } + + var repeatedDouble: [Double] { + get {_storage._repeatedDouble} + set {_uniqueStorage()._repeatedDouble = newValue} + } + + var repeatedBool: [Bool] { + get {_storage._repeatedBool} + set {_uniqueStorage()._repeatedBool = newValue} + } + + var repeatedString: [String] { + get {_storage._repeatedString} + set {_uniqueStorage()._repeatedString = newValue} + } + + var repeatedBytes: [Data] { + get {_storage._repeatedBytes} + set {_uniqueStorage()._repeatedBytes = newValue} + } + + var repeatedNestedMessage: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage] { + get {_storage._repeatedNestedMessage} + set {_uniqueStorage()._repeatedNestedMessage = newValue} + } + + var repeatedForeignMessage: [ProtobufTestMessages_Proto2_ForeignMessageProto2] { + get {_storage._repeatedForeignMessage} + set {_uniqueStorage()._repeatedForeignMessage = newValue} + } + + var repeatedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] { + get {_storage._repeatedNestedEnum} + set {_uniqueStorage()._repeatedNestedEnum = newValue} + } + + var repeatedForeignEnum: [ProtobufTestMessages_Proto2_ForeignEnumProto2] { + get {_storage._repeatedForeignEnum} + set {_uniqueStorage()._repeatedForeignEnum = newValue} + } + + var repeatedStringPiece: [String] { + get {_storage._repeatedStringPiece} + set {_uniqueStorage()._repeatedStringPiece = newValue} + } + + var repeatedCord: [String] { + get {_storage._repeatedCord} + set {_uniqueStorage()._repeatedCord = newValue} + } + + /// Packed + var packedInt32: [Int32] { + get {_storage._packedInt32} + set {_uniqueStorage()._packedInt32 = newValue} + } + + var packedInt64: [Int64] { + get {_storage._packedInt64} + set {_uniqueStorage()._packedInt64 = newValue} + } + + var packedUint32: [UInt32] { + get {_storage._packedUint32} + set {_uniqueStorage()._packedUint32 = newValue} + } + + var packedUint64: [UInt64] { + get {_storage._packedUint64} + set {_uniqueStorage()._packedUint64 = newValue} + } + + var packedSint32: [Int32] { + get {_storage._packedSint32} + set {_uniqueStorage()._packedSint32 = newValue} + } + + var packedSint64: [Int64] { + get {_storage._packedSint64} + set {_uniqueStorage()._packedSint64 = newValue} + } + + var packedFixed32: [UInt32] { + get {_storage._packedFixed32} + set {_uniqueStorage()._packedFixed32 = newValue} + } + + var packedFixed64: [UInt64] { + get {_storage._packedFixed64} + set {_uniqueStorage()._packedFixed64 = newValue} + } + + var packedSfixed32: [Int32] { + get {_storage._packedSfixed32} + set {_uniqueStorage()._packedSfixed32 = newValue} + } + + var packedSfixed64: [Int64] { + get {_storage._packedSfixed64} + set {_uniqueStorage()._packedSfixed64 = newValue} + } + + var packedFloat: [Float] { + get {_storage._packedFloat} + set {_uniqueStorage()._packedFloat = newValue} + } + + var packedDouble: [Double] { + get {_storage._packedDouble} + set {_uniqueStorage()._packedDouble = newValue} + } + + var packedBool: [Bool] { + get {_storage._packedBool} + set {_uniqueStorage()._packedBool = newValue} + } + + var packedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] { + get {_storage._packedNestedEnum} + set {_uniqueStorage()._packedNestedEnum = newValue} + } + + /// Unpacked + var unpackedInt32: [Int32] { + get {_storage._unpackedInt32} + set {_uniqueStorage()._unpackedInt32 = newValue} + } + + var unpackedInt64: [Int64] { + get {_storage._unpackedInt64} + set {_uniqueStorage()._unpackedInt64 = newValue} + } + + var unpackedUint32: [UInt32] { + get {_storage._unpackedUint32} + set {_uniqueStorage()._unpackedUint32 = newValue} + } + + var unpackedUint64: [UInt64] { + get {_storage._unpackedUint64} + set {_uniqueStorage()._unpackedUint64 = newValue} + } + + var unpackedSint32: [Int32] { + get {_storage._unpackedSint32} + set {_uniqueStorage()._unpackedSint32 = newValue} + } + + var unpackedSint64: [Int64] { + get {_storage._unpackedSint64} + set {_uniqueStorage()._unpackedSint64 = newValue} + } + + var unpackedFixed32: [UInt32] { + get {_storage._unpackedFixed32} + set {_uniqueStorage()._unpackedFixed32 = newValue} + } + + var unpackedFixed64: [UInt64] { + get {_storage._unpackedFixed64} + set {_uniqueStorage()._unpackedFixed64 = newValue} + } + + var unpackedSfixed32: [Int32] { + get {_storage._unpackedSfixed32} + set {_uniqueStorage()._unpackedSfixed32 = newValue} + } + + var unpackedSfixed64: [Int64] { + get {_storage._unpackedSfixed64} + set {_uniqueStorage()._unpackedSfixed64 = newValue} + } + + var unpackedFloat: [Float] { + get {_storage._unpackedFloat} + set {_uniqueStorage()._unpackedFloat = newValue} + } + + var unpackedDouble: [Double] { + get {_storage._unpackedDouble} + set {_uniqueStorage()._unpackedDouble = newValue} + } + + var unpackedBool: [Bool] { + get {_storage._unpackedBool} + set {_uniqueStorage()._unpackedBool = newValue} + } + + var unpackedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] { + get {_storage._unpackedNestedEnum} + set {_uniqueStorage()._unpackedNestedEnum = newValue} + } + + /// Map + var mapInt32Int32: Dictionary { + get {_storage._mapInt32Int32} + set {_uniqueStorage()._mapInt32Int32 = newValue} + } + + var mapInt64Int64: Dictionary { + get {_storage._mapInt64Int64} + set {_uniqueStorage()._mapInt64Int64 = newValue} + } + + var mapUint32Uint32: Dictionary { + get {_storage._mapUint32Uint32} + set {_uniqueStorage()._mapUint32Uint32 = newValue} + } + + var mapUint64Uint64: Dictionary { + get {_storage._mapUint64Uint64} + set {_uniqueStorage()._mapUint64Uint64 = newValue} + } + + var mapSint32Sint32: Dictionary { + get {_storage._mapSint32Sint32} + set {_uniqueStorage()._mapSint32Sint32 = newValue} + } + + var mapSint64Sint64: Dictionary { + get {_storage._mapSint64Sint64} + set {_uniqueStorage()._mapSint64Sint64 = newValue} + } + + var mapFixed32Fixed32: Dictionary { + get {_storage._mapFixed32Fixed32} + set {_uniqueStorage()._mapFixed32Fixed32 = newValue} + } + + var mapFixed64Fixed64: Dictionary { + get {_storage._mapFixed64Fixed64} + set {_uniqueStorage()._mapFixed64Fixed64 = newValue} + } + + var mapSfixed32Sfixed32: Dictionary { + get {_storage._mapSfixed32Sfixed32} + set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} + } + + var mapSfixed64Sfixed64: Dictionary { + get {_storage._mapSfixed64Sfixed64} + set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} + } + + var mapInt32Bool: Dictionary { + get {_storage._mapInt32Bool} + set {_uniqueStorage()._mapInt32Bool = newValue} + } + + var mapInt32Float: Dictionary { + get {_storage._mapInt32Float} + set {_uniqueStorage()._mapInt32Float = newValue} + } + + var mapInt32Double: Dictionary { + get {_storage._mapInt32Double} + set {_uniqueStorage()._mapInt32Double = newValue} + } + + var mapInt32NestedMessage: Dictionary { + get {_storage._mapInt32NestedMessage} + set {_uniqueStorage()._mapInt32NestedMessage = newValue} + } + + var mapBoolBool: Dictionary { + get {_storage._mapBoolBool} + set {_uniqueStorage()._mapBoolBool = newValue} + } + + var mapStringString: Dictionary { + get {_storage._mapStringString} + set {_uniqueStorage()._mapStringString = newValue} + } + + var mapStringBytes: Dictionary { + get {_storage._mapStringBytes} + set {_uniqueStorage()._mapStringBytes = newValue} + } + + var mapStringNestedMessage: Dictionary { + get {_storage._mapStringNestedMessage} + set {_uniqueStorage()._mapStringNestedMessage = newValue} + } + + var mapStringForeignMessage: Dictionary { + get {_storage._mapStringForeignMessage} + set {_uniqueStorage()._mapStringForeignMessage = newValue} + } + + var mapStringNestedEnum: Dictionary { + get {_storage._mapStringNestedEnum} + set {_uniqueStorage()._mapStringNestedEnum = newValue} + } + + var mapStringForeignEnum: Dictionary { + get {_storage._mapStringForeignEnum} + set {_uniqueStorage()._mapStringForeignEnum = newValue} + } + + var oneofField: OneOf_OneofField? { + get {return _storage._oneofField} + set {_uniqueStorage()._oneofField = newValue} + } + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} + } + + var oneofNestedMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage { + get { + if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} + return ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = _storage._oneofField {return v} + return Data() + } + set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} + } + + var oneofBool: Bool { + get { + if case .oneofBool(let v)? = _storage._oneofField {return v} + return false + } + set {_uniqueStorage()._oneofField = .oneofBool(newValue)} + } + + var oneofUint64: UInt64 { + get { + if case .oneofUint64(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint64(newValue)} + } + + var oneofFloat: Float { + get { + if case .oneofFloat(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofFloat(newValue)} + } + + var oneofDouble: Double { + get { + if case .oneofDouble(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofDouble(newValue)} + } + + var oneofEnum: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum { + get { + if case .oneofEnum(let v)? = _storage._oneofField {return v} + return .foo + } + set {_uniqueStorage()._oneofField = .oneofEnum(newValue)} + } + + var data: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage { + get {_storage._data ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage()} + set {_uniqueStorage()._data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {_storage._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {_uniqueStorage()._data = nil} + + var multiWordGroupField: ProtobufTestMessages_Proto2_TestAllTypesProto2.MultiWordGroupField { + get {_storage._multiWordGroupField ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.MultiWordGroupField()} + set {_uniqueStorage()._multiWordGroupField = newValue} + } + /// Returns true if `multiWordGroupField` has been explicitly set. + var hasMultiWordGroupField: Bool {_storage._multiWordGroupField != nil} + /// Clears the value of `multiWordGroupField`. Subsequent reads from it will return its default value. + mutating func clearMultiWordGroupField() {_uniqueStorage()._multiWordGroupField = nil} + + /// default values + var defaultInt32: Int32 { + get {_storage._defaultInt32 ?? -123456789} + set {_uniqueStorage()._defaultInt32 = newValue} + } + /// Returns true if `defaultInt32` has been explicitly set. + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} + /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} + + var defaultInt64: Int64 { + get {_storage._defaultInt64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultInt64 = newValue} + } + /// Returns true if `defaultInt64` has been explicitly set. + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} + /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} + + var defaultUint32: UInt32 { + get {_storage._defaultUint32 ?? 2123456789} + set {_uniqueStorage()._defaultUint32 = newValue} + } + /// Returns true if `defaultUint32` has been explicitly set. + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} + /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} + + var defaultUint64: UInt64 { + get {_storage._defaultUint64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultUint64 = newValue} + } + /// Returns true if `defaultUint64` has been explicitly set. + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} + /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} + + var defaultSint32: Int32 { + get {_storage._defaultSint32 ?? -123456789} + set {_uniqueStorage()._defaultSint32 = newValue} + } + /// Returns true if `defaultSint32` has been explicitly set. + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} + /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} + + var defaultSint64: Int64 { + get {_storage._defaultSint64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSint64 = newValue} + } + /// Returns true if `defaultSint64` has been explicitly set. + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} + /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} + + var defaultFixed32: UInt32 { + get {_storage._defaultFixed32 ?? 2123456789} + set {_uniqueStorage()._defaultFixed32 = newValue} + } + /// Returns true if `defaultFixed32` has been explicitly set. + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} + /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} + + var defaultFixed64: UInt64 { + get {_storage._defaultFixed64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultFixed64 = newValue} + } + /// Returns true if `defaultFixed64` has been explicitly set. + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} + /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} + + var defaultSfixed32: Int32 { + get {_storage._defaultSfixed32 ?? -123456789} + set {_uniqueStorage()._defaultSfixed32 = newValue} + } + /// Returns true if `defaultSfixed32` has been explicitly set. + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} + /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} + + var defaultSfixed64: Int64 { + get {_storage._defaultSfixed64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSfixed64 = newValue} + } + /// Returns true if `defaultSfixed64` has been explicitly set. + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} + /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} + + var defaultFloat: Float { + get {_storage._defaultFloat ?? 9e+09} + set {_uniqueStorage()._defaultFloat = newValue} + } + /// Returns true if `defaultFloat` has been explicitly set. + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} + /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. + mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} + + var defaultDouble: Double { + get {_storage._defaultDouble ?? 7e+22} + set {_uniqueStorage()._defaultDouble = newValue} + } + /// Returns true if `defaultDouble` has been explicitly set. + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} + /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. + mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} + + var defaultBool: Bool { + get {_storage._defaultBool ?? true} + set {_uniqueStorage()._defaultBool = newValue} + } + /// Returns true if `defaultBool` has been explicitly set. + var hasDefaultBool: Bool {_storage._defaultBool != nil} + /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. + mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} + + var defaultString: String { + get {_storage._defaultString ?? "Rosebud"} + set {_uniqueStorage()._defaultString = newValue} + } + /// Returns true if `defaultString` has been explicitly set. + var hasDefaultString: Bool {_storage._defaultString != nil} + /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. + mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} + + var defaultBytes: Data { + get {_storage._defaultBytes ?? Data([106, 111, 115, 104, 117, 97])} + set {_uniqueStorage()._defaultBytes = newValue} + } + /// Returns true if `defaultBytes` has been explicitly set. + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} + /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. + mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} + + /// Test field-name-to-JSON-name convention. + /// (protobuf says names can be any valid C/C++ identifier.) + var fieldname1: Int32 { + get {_storage._fieldname1 ?? 0} + set {_uniqueStorage()._fieldname1 = newValue} + } + /// Returns true if `fieldname1` has been explicitly set. + var hasFieldname1: Bool {_storage._fieldname1 != nil} + /// Clears the value of `fieldname1`. Subsequent reads from it will return its default value. + mutating func clearFieldname1() {_uniqueStorage()._fieldname1 = nil} + + var fieldName2: Int32 { + get {_storage._fieldName2 ?? 0} + set {_uniqueStorage()._fieldName2 = newValue} + } + /// Returns true if `fieldName2` has been explicitly set. + var hasFieldName2: Bool {_storage._fieldName2 != nil} + /// Clears the value of `fieldName2`. Subsequent reads from it will return its default value. + mutating func clearFieldName2() {_uniqueStorage()._fieldName2 = nil} + + var fieldName3: Int32 { + get {_storage._fieldName3 ?? 0} + set {_uniqueStorage()._fieldName3 = newValue} + } + /// Returns true if `fieldName3` has been explicitly set. + var hasFieldName3: Bool {_storage._fieldName3 != nil} + /// Clears the value of `fieldName3`. Subsequent reads from it will return its default value. + mutating func clearFieldName3() {_uniqueStorage()._fieldName3 = nil} + + var field_Name4_: Int32 { + get {_storage._field_Name4_ ?? 0} + set {_uniqueStorage()._field_Name4_ = newValue} + } + /// Returns true if `field_Name4_` has been explicitly set. + var hasField_Name4_: Bool {_storage._field_Name4_ != nil} + /// Clears the value of `field_Name4_`. Subsequent reads from it will return its default value. + mutating func clearField_Name4_() {_uniqueStorage()._field_Name4_ = nil} + + var field0Name5: Int32 { + get {_storage._field0Name5 ?? 0} + set {_uniqueStorage()._field0Name5 = newValue} + } + /// Returns true if `field0Name5` has been explicitly set. + var hasField0Name5: Bool {_storage._field0Name5 != nil} + /// Clears the value of `field0Name5`. Subsequent reads from it will return its default value. + mutating func clearField0Name5() {_uniqueStorage()._field0Name5 = nil} + + var field0Name6: Int32 { + get {_storage._field0Name6 ?? 0} + set {_uniqueStorage()._field0Name6 = newValue} + } + /// Returns true if `field0Name6` has been explicitly set. + var hasField0Name6: Bool {_storage._field0Name6 != nil} + /// Clears the value of `field0Name6`. Subsequent reads from it will return its default value. + mutating func clearField0Name6() {_uniqueStorage()._field0Name6 = nil} + + var fieldName7: Int32 { + get {_storage._fieldName7 ?? 0} + set {_uniqueStorage()._fieldName7 = newValue} + } + /// Returns true if `fieldName7` has been explicitly set. + var hasFieldName7: Bool {_storage._fieldName7 != nil} + /// Clears the value of `fieldName7`. Subsequent reads from it will return its default value. + mutating func clearFieldName7() {_uniqueStorage()._fieldName7 = nil} + + var fieldName8: Int32 { + get {_storage._fieldName8 ?? 0} + set {_uniqueStorage()._fieldName8 = newValue} + } + /// Returns true if `fieldName8` has been explicitly set. + var hasFieldName8: Bool {_storage._fieldName8 != nil} + /// Clears the value of `fieldName8`. Subsequent reads from it will return its default value. + mutating func clearFieldName8() {_uniqueStorage()._fieldName8 = nil} + + var fieldName9: Int32 { + get {_storage._fieldName9 ?? 0} + set {_uniqueStorage()._fieldName9 = newValue} + } + /// Returns true if `fieldName9` has been explicitly set. + var hasFieldName9: Bool {_storage._fieldName9 != nil} + /// Clears the value of `fieldName9`. Subsequent reads from it will return its default value. + mutating func clearFieldName9() {_uniqueStorage()._fieldName9 = nil} + + var fieldName10: Int32 { + get {_storage._fieldName10 ?? 0} + set {_uniqueStorage()._fieldName10 = newValue} + } + /// Returns true if `fieldName10` has been explicitly set. + var hasFieldName10: Bool {_storage._fieldName10 != nil} + /// Clears the value of `fieldName10`. Subsequent reads from it will return its default value. + mutating func clearFieldName10() {_uniqueStorage()._fieldName10 = nil} + + var fieldName11: Int32 { + get {_storage._fieldName11 ?? 0} + set {_uniqueStorage()._fieldName11 = newValue} + } + /// Returns true if `fieldName11` has been explicitly set. + var hasFieldName11: Bool {_storage._fieldName11 != nil} + /// Clears the value of `fieldName11`. Subsequent reads from it will return its default value. + mutating func clearFieldName11() {_uniqueStorage()._fieldName11 = nil} + + var fieldName12: Int32 { + get {_storage._fieldName12 ?? 0} + set {_uniqueStorage()._fieldName12 = newValue} + } + /// Returns true if `fieldName12` has been explicitly set. + var hasFieldName12: Bool {_storage._fieldName12 != nil} + /// Clears the value of `fieldName12`. Subsequent reads from it will return its default value. + mutating func clearFieldName12() {_uniqueStorage()._fieldName12 = nil} + + var _FieldName13: Int32 { + get {_storage.__FieldName13 ?? 0} + set {_uniqueStorage().__FieldName13 = newValue} + } + /// Returns true if `_FieldName13` has been explicitly set. + var has_FieldName13: Bool {_storage.__FieldName13 != nil} + /// Clears the value of `_FieldName13`. Subsequent reads from it will return its default value. + mutating func clear_FieldName13() {_uniqueStorage().__FieldName13 = nil} + + var _FieldName14: Int32 { + get {_storage.__FieldName14 ?? 0} + set {_uniqueStorage().__FieldName14 = newValue} + } + /// Returns true if `_FieldName14` has been explicitly set. + var has_FieldName14: Bool {_storage.__FieldName14 != nil} + /// Clears the value of `_FieldName14`. Subsequent reads from it will return its default value. + mutating func clear_FieldName14() {_uniqueStorage().__FieldName14 = nil} + + var field_Name15: Int32 { + get {_storage._field_Name15 ?? 0} + set {_uniqueStorage()._field_Name15 = newValue} + } + /// Returns true if `field_Name15` has been explicitly set. + var hasField_Name15: Bool {_storage._field_Name15 != nil} + /// Clears the value of `field_Name15`. Subsequent reads from it will return its default value. + mutating func clearField_Name15() {_uniqueStorage()._field_Name15 = nil} + + var field_Name16: Int32 { + get {_storage._field_Name16 ?? 0} + set {_uniqueStorage()._field_Name16 = newValue} + } + /// Returns true if `field_Name16` has been explicitly set. + var hasField_Name16: Bool {_storage._field_Name16 != nil} + /// Clears the value of `field_Name16`. Subsequent reads from it will return its default value. + mutating func clearField_Name16() {_uniqueStorage()._field_Name16 = nil} + + var fieldName17__: Int32 { + get {_storage._fieldName17__ ?? 0} + set {_uniqueStorage()._fieldName17__ = newValue} + } + /// Returns true if `fieldName17__` has been explicitly set. + var hasFieldName17__: Bool {_storage._fieldName17__ != nil} + /// Clears the value of `fieldName17__`. Subsequent reads from it will return its default value. + mutating func clearFieldName17__() {_uniqueStorage()._fieldName17__ = nil} + + var fieldName18__: Int32 { + get {_storage._fieldName18__ ?? 0} + set {_uniqueStorage()._fieldName18__ = newValue} + } + /// Returns true if `fieldName18__` has been explicitly set. + var hasFieldName18__: Bool {_storage._fieldName18__ != nil} + /// Clears the value of `fieldName18__`. Subsequent reads from it will return its default value. + mutating func clearFieldName18__() {_uniqueStorage()._fieldName18__ = nil} + + var messageSetCorrect: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect { + get {_storage._messageSetCorrect ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect()} + set {_uniqueStorage()._messageSetCorrect = newValue} + } + /// Returns true if `messageSetCorrect` has been explicitly set. + var hasMessageSetCorrect: Bool {_storage._messageSetCorrect != nil} + /// Clears the value of `messageSetCorrect`. Subsequent reads from it will return its default value. + mutating func clearMessageSetCorrect() {_uniqueStorage()._messageSetCorrect = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofNestedMessage(ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage) + case oneofString(String) + case oneofBytes(Data) + case oneofBool(Bool) + case oneofUint64(UInt64) + case oneofFloat(Float) + case oneofDouble(Double) + case oneofEnum(ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum) + + fileprivate var isInitialized: Bool { + guard case .oneofNestedMessage(let v) = self else {return true} + return v.isInitialized + } + + } + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 + + /// Intentionally negative. + case neg = -1 + + init() { + self = .foo + } + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var corecursive: ProtobufTestMessages_Proto2_TestAllTypesProto2 { + get {_storage._corecursive ?? ProtobufTestMessages_Proto2_TestAllTypesProto2()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + /// groups + struct DataMessage: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + struct MultiWordGroupField: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + /// message_set test case. + struct MessageSetCorrect: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() + } + + struct MessageSetCorrectExtension1: Sendable { + // 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 str: String { + get {_str ?? String()} + set {_str = newValue} + } + /// Returns true if `str` has been explicitly set. + var hasStr: Bool {self._str != nil} + /// Clears the value of `str`. Subsequent reads from it will return its default value. + mutating func clearStr() {self._str = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _str: String? = nil + } + + struct MessageSetCorrectExtension2: Sendable { + // 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 i: Int32 { + get {_i ?? 0} + set {_i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {self._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {self._i = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _i: Int32? = nil + } + + struct ExtensionWithOneof: Sendable { + // 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 oneofField: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.OneOf_OneofField? = nil + + var a: Int32 { + get { + if case .a(let v)? = oneofField {return v} + return 0 + } + set {oneofField = .a(newValue)} + } + + var b: Int32 { + get { + if case .b(let v)? = oneofField {return v} + return 0 + } + set {oneofField = .b(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case a(Int32) + case b(Int32) + + } + + init() {} + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct ProtobufTestMessages_Proto2_ForeignMessageProto2: Sendable { + // 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 c: Int32 { + get {_c ?? 0} + set {_c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {self._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {self._c = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _c: Int32? = nil +} + +struct ProtobufTestMessages_Proto2_GroupField: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil +} + +struct ProtobufTestMessages_Proto2_UnknownToTestAllTypes: Sendable { + // 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 optionalInt32: Int32 { + get {_optionalInt32 ?? 0} + set {_optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {self._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {self._optionalInt32 = nil} + + var optionalString: String { + get {_optionalString ?? String()} + set {_optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {self._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {self._optionalString = nil} + + var nestedMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2 { + get {_nestedMessage ?? ProtobufTestMessages_Proto2_ForeignMessageProto2()} + set {_nestedMessage = newValue} + } + /// Returns true if `nestedMessage` has been explicitly set. + var hasNestedMessage: Bool {self._nestedMessage != nil} + /// Clears the value of `nestedMessage`. Subsequent reads from it will return its default value. + mutating func clearNestedMessage() {self._nestedMessage = nil} + + var optionalGroup: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup { + get {_optionalGroup ?? ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup()} + set {_optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {self._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {self._optionalGroup = nil} + + var optionalBool: Bool { + get {_optionalBool ?? false} + set {_optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {self._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {self._optionalBool = nil} + + var repeatedInt32: [Int32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct OptionalGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + init() {} + + fileprivate var _optionalInt32: Int32? = nil + fileprivate var _optionalString: String? = nil + fileprivate var _nestedMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2? = nil + fileprivate var _optionalGroup: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup? = nil + fileprivate var _optionalBool: Bool? = nil +} + +struct ProtobufTestMessages_Proto2_NullHypothesisProto2: Sendable { + // 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 ProtobufTestMessages_Proto2_EnumOnlyProto2: Sendable { + // 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() + + enum BoolEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case kFalse = 0 + case kTrue = 1 + + init() { + self = .kFalse + } + + } + + init() {} +} + +struct ProtobufTestMessages_Proto2_OneStringProto2: Sendable { + // 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 data: String { + get {_data ?? String()} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: String? = nil +} + +struct ProtobufTestMessages_Proto2_ProtoWithKeywords: Sendable { + // 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 inline: Int32 { + get {_inline ?? 0} + set {_inline = newValue} + } + /// Returns true if `inline` has been explicitly set. + var hasInline: Bool {self._inline != nil} + /// Clears the value of `inline`. Subsequent reads from it will return its default value. + mutating func clearInline() {self._inline = nil} + + var concept: String { + get {_concept ?? String()} + set {_concept = newValue} + } + /// Returns true if `concept` has been explicitly set. + var hasConcept: Bool {self._concept != nil} + /// Clears the value of `concept`. Subsequent reads from it will return its default value. + mutating func clearConcept() {self._concept = nil} + + var requires: [String] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _inline: Int32? = nil + fileprivate var _concept: String? = nil +} + +struct ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Singular + var requiredInt32: Int32 { + get {_storage._requiredInt32 ?? 0} + set {_uniqueStorage()._requiredInt32 = newValue} + } + /// Returns true if `requiredInt32` has been explicitly set. + var hasRequiredInt32: Bool {_storage._requiredInt32 != nil} + /// Clears the value of `requiredInt32`. Subsequent reads from it will return its default value. + mutating func clearRequiredInt32() {_uniqueStorage()._requiredInt32 = nil} + + var requiredInt64: Int64 { + get {_storage._requiredInt64 ?? 0} + set {_uniqueStorage()._requiredInt64 = newValue} + } + /// Returns true if `requiredInt64` has been explicitly set. + var hasRequiredInt64: Bool {_storage._requiredInt64 != nil} + /// Clears the value of `requiredInt64`. Subsequent reads from it will return its default value. + mutating func clearRequiredInt64() {_uniqueStorage()._requiredInt64 = nil} + + var requiredUint32: UInt32 { + get {_storage._requiredUint32 ?? 0} + set {_uniqueStorage()._requiredUint32 = newValue} + } + /// Returns true if `requiredUint32` has been explicitly set. + var hasRequiredUint32: Bool {_storage._requiredUint32 != nil} + /// Clears the value of `requiredUint32`. Subsequent reads from it will return its default value. + mutating func clearRequiredUint32() {_uniqueStorage()._requiredUint32 = nil} + + var requiredUint64: UInt64 { + get {_storage._requiredUint64 ?? 0} + set {_uniqueStorage()._requiredUint64 = newValue} + } + /// Returns true if `requiredUint64` has been explicitly set. + var hasRequiredUint64: Bool {_storage._requiredUint64 != nil} + /// Clears the value of `requiredUint64`. Subsequent reads from it will return its default value. + mutating func clearRequiredUint64() {_uniqueStorage()._requiredUint64 = nil} + + var requiredSint32: Int32 { + get {_storage._requiredSint32 ?? 0} + set {_uniqueStorage()._requiredSint32 = newValue} + } + /// Returns true if `requiredSint32` has been explicitly set. + var hasRequiredSint32: Bool {_storage._requiredSint32 != nil} + /// Clears the value of `requiredSint32`. Subsequent reads from it will return its default value. + mutating func clearRequiredSint32() {_uniqueStorage()._requiredSint32 = nil} + + var requiredSint64: Int64 { + get {_storage._requiredSint64 ?? 0} + set {_uniqueStorage()._requiredSint64 = newValue} + } + /// Returns true if `requiredSint64` has been explicitly set. + var hasRequiredSint64: Bool {_storage._requiredSint64 != nil} + /// Clears the value of `requiredSint64`. Subsequent reads from it will return its default value. + mutating func clearRequiredSint64() {_uniqueStorage()._requiredSint64 = nil} + + var requiredFixed32: UInt32 { + get {_storage._requiredFixed32 ?? 0} + set {_uniqueStorage()._requiredFixed32 = newValue} + } + /// Returns true if `requiredFixed32` has been explicitly set. + var hasRequiredFixed32: Bool {_storage._requiredFixed32 != nil} + /// Clears the value of `requiredFixed32`. Subsequent reads from it will return its default value. + mutating func clearRequiredFixed32() {_uniqueStorage()._requiredFixed32 = nil} + + var requiredFixed64: UInt64 { + get {_storage._requiredFixed64 ?? 0} + set {_uniqueStorage()._requiredFixed64 = newValue} + } + /// Returns true if `requiredFixed64` has been explicitly set. + var hasRequiredFixed64: Bool {_storage._requiredFixed64 != nil} + /// Clears the value of `requiredFixed64`. Subsequent reads from it will return its default value. + mutating func clearRequiredFixed64() {_uniqueStorage()._requiredFixed64 = nil} + + var requiredSfixed32: Int32 { + get {_storage._requiredSfixed32 ?? 0} + set {_uniqueStorage()._requiredSfixed32 = newValue} + } + /// Returns true if `requiredSfixed32` has been explicitly set. + var hasRequiredSfixed32: Bool {_storage._requiredSfixed32 != nil} + /// Clears the value of `requiredSfixed32`. Subsequent reads from it will return its default value. + mutating func clearRequiredSfixed32() {_uniqueStorage()._requiredSfixed32 = nil} + + var requiredSfixed64: Int64 { + get {_storage._requiredSfixed64 ?? 0} + set {_uniqueStorage()._requiredSfixed64 = newValue} + } + /// Returns true if `requiredSfixed64` has been explicitly set. + var hasRequiredSfixed64: Bool {_storage._requiredSfixed64 != nil} + /// Clears the value of `requiredSfixed64`. Subsequent reads from it will return its default value. + mutating func clearRequiredSfixed64() {_uniqueStorage()._requiredSfixed64 = nil} + + var requiredFloat: Float { + get {_storage._requiredFloat ?? 0} + set {_uniqueStorage()._requiredFloat = newValue} + } + /// Returns true if `requiredFloat` has been explicitly set. + var hasRequiredFloat: Bool {_storage._requiredFloat != nil} + /// Clears the value of `requiredFloat`. Subsequent reads from it will return its default value. + mutating func clearRequiredFloat() {_uniqueStorage()._requiredFloat = nil} + + var requiredDouble: Double { + get {_storage._requiredDouble ?? 0} + set {_uniqueStorage()._requiredDouble = newValue} + } + /// Returns true if `requiredDouble` has been explicitly set. + var hasRequiredDouble: Bool {_storage._requiredDouble != nil} + /// Clears the value of `requiredDouble`. Subsequent reads from it will return its default value. + mutating func clearRequiredDouble() {_uniqueStorage()._requiredDouble = nil} + + var requiredBool: Bool { + get {_storage._requiredBool ?? false} + set {_uniqueStorage()._requiredBool = newValue} + } + /// Returns true if `requiredBool` has been explicitly set. + var hasRequiredBool: Bool {_storage._requiredBool != nil} + /// Clears the value of `requiredBool`. Subsequent reads from it will return its default value. + mutating func clearRequiredBool() {_uniqueStorage()._requiredBool = nil} + + var requiredString: String { + get {_storage._requiredString ?? String()} + set {_uniqueStorage()._requiredString = newValue} + } + /// Returns true if `requiredString` has been explicitly set. + var hasRequiredString: Bool {_storage._requiredString != nil} + /// Clears the value of `requiredString`. Subsequent reads from it will return its default value. + mutating func clearRequiredString() {_uniqueStorage()._requiredString = nil} + + var requiredBytes: Data { + get {_storage._requiredBytes ?? Data()} + set {_uniqueStorage()._requiredBytes = newValue} + } + /// Returns true if `requiredBytes` has been explicitly set. + var hasRequiredBytes: Bool {_storage._requiredBytes != nil} + /// Clears the value of `requiredBytes`. Subsequent reads from it will return its default value. + mutating func clearRequiredBytes() {_uniqueStorage()._requiredBytes = nil} + + var requiredNestedMessage: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage { + get {_storage._requiredNestedMessage ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage()} + set {_uniqueStorage()._requiredNestedMessage = newValue} + } + /// Returns true if `requiredNestedMessage` has been explicitly set. + var hasRequiredNestedMessage: Bool {_storage._requiredNestedMessage != nil} + /// Clears the value of `requiredNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearRequiredNestedMessage() {_uniqueStorage()._requiredNestedMessage = nil} + + var requiredForeignMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2 { + get {_storage._requiredForeignMessage ?? ProtobufTestMessages_Proto2_ForeignMessageProto2()} + set {_uniqueStorage()._requiredForeignMessage = newValue} + } + /// Returns true if `requiredForeignMessage` has been explicitly set. + var hasRequiredForeignMessage: Bool {_storage._requiredForeignMessage != nil} + /// Clears the value of `requiredForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearRequiredForeignMessage() {_uniqueStorage()._requiredForeignMessage = nil} + + var requiredNestedEnum: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedEnum { + get {_storage._requiredNestedEnum ?? .foo} + set {_uniqueStorage()._requiredNestedEnum = newValue} + } + /// Returns true if `requiredNestedEnum` has been explicitly set. + var hasRequiredNestedEnum: Bool {_storage._requiredNestedEnum != nil} + /// Clears the value of `requiredNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredNestedEnum() {_uniqueStorage()._requiredNestedEnum = nil} + + var requiredForeignEnum: ProtobufTestMessages_Proto2_ForeignEnumProto2 { + get {_storage._requiredForeignEnum ?? .foreignFoo} + set {_uniqueStorage()._requiredForeignEnum = newValue} + } + /// Returns true if `requiredForeignEnum` has been explicitly set. + var hasRequiredForeignEnum: Bool {_storage._requiredForeignEnum != nil} + /// Clears the value of `requiredForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredForeignEnum() {_uniqueStorage()._requiredForeignEnum = nil} + + var requiredStringPiece: String { + get {_storage._requiredStringPiece ?? String()} + set {_uniqueStorage()._requiredStringPiece = newValue} + } + /// Returns true if `requiredStringPiece` has been explicitly set. + var hasRequiredStringPiece: Bool {_storage._requiredStringPiece != nil} + /// Clears the value of `requiredStringPiece`. Subsequent reads from it will return its default value. + mutating func clearRequiredStringPiece() {_uniqueStorage()._requiredStringPiece = nil} + + var requiredCord: String { + get {_storage._requiredCord ?? String()} + set {_uniqueStorage()._requiredCord = newValue} + } + /// Returns true if `requiredCord` has been explicitly set. + var hasRequiredCord: Bool {_storage._requiredCord != nil} + /// Clears the value of `requiredCord`. Subsequent reads from it will return its default value. + mutating func clearRequiredCord() {_uniqueStorage()._requiredCord = nil} + + var recursiveMessage: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2 { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._recursiveMessage = newValue} + } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} + + var optionalRecursiveMessage: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2 { + get {_storage._optionalRecursiveMessage ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._optionalRecursiveMessage = newValue} + } + /// Returns true if `optionalRecursiveMessage` has been explicitly set. + var hasOptionalRecursiveMessage: Bool {_storage._optionalRecursiveMessage != nil} + /// Clears the value of `optionalRecursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalRecursiveMessage() {_uniqueStorage()._optionalRecursiveMessage = nil} + + var data: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage { + get {_storage._data ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage()} + set {_uniqueStorage()._data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {_storage._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {_uniqueStorage()._data = nil} + + /// default values + var defaultInt32: Int32 { + get {_storage._defaultInt32 ?? -123456789} + set {_uniqueStorage()._defaultInt32 = newValue} + } + /// Returns true if `defaultInt32` has been explicitly set. + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} + /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} + + var defaultInt64: Int64 { + get {_storage._defaultInt64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultInt64 = newValue} + } + /// Returns true if `defaultInt64` has been explicitly set. + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} + /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} + + var defaultUint32: UInt32 { + get {_storage._defaultUint32 ?? 2123456789} + set {_uniqueStorage()._defaultUint32 = newValue} + } + /// Returns true if `defaultUint32` has been explicitly set. + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} + /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} + + var defaultUint64: UInt64 { + get {_storage._defaultUint64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultUint64 = newValue} + } + /// Returns true if `defaultUint64` has been explicitly set. + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} + /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} + + var defaultSint32: Int32 { + get {_storage._defaultSint32 ?? -123456789} + set {_uniqueStorage()._defaultSint32 = newValue} + } + /// Returns true if `defaultSint32` has been explicitly set. + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} + /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} + + var defaultSint64: Int64 { + get {_storage._defaultSint64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSint64 = newValue} + } + /// Returns true if `defaultSint64` has been explicitly set. + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} + /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} + + var defaultFixed32: UInt32 { + get {_storage._defaultFixed32 ?? 2123456789} + set {_uniqueStorage()._defaultFixed32 = newValue} + } + /// Returns true if `defaultFixed32` has been explicitly set. + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} + /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} + + var defaultFixed64: UInt64 { + get {_storage._defaultFixed64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultFixed64 = newValue} + } + /// Returns true if `defaultFixed64` has been explicitly set. + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} + /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} + + var defaultSfixed32: Int32 { + get {_storage._defaultSfixed32 ?? -123456789} + set {_uniqueStorage()._defaultSfixed32 = newValue} + } + /// Returns true if `defaultSfixed32` has been explicitly set. + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} + /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} + + var defaultSfixed64: Int64 { + get {_storage._defaultSfixed64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSfixed64 = newValue} + } + /// Returns true if `defaultSfixed64` has been explicitly set. + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} + /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} + + var defaultFloat: Float { + get {_storage._defaultFloat ?? 9e+09} + set {_uniqueStorage()._defaultFloat = newValue} + } + /// Returns true if `defaultFloat` has been explicitly set. + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} + /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. + mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} + + var defaultDouble: Double { + get {_storage._defaultDouble ?? 7e+22} + set {_uniqueStorage()._defaultDouble = newValue} + } + /// Returns true if `defaultDouble` has been explicitly set. + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} + /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. + mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} + + var defaultBool: Bool { + get {_storage._defaultBool ?? true} + set {_uniqueStorage()._defaultBool = newValue} + } + /// Returns true if `defaultBool` has been explicitly set. + var hasDefaultBool: Bool {_storage._defaultBool != nil} + /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. + mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} + + var defaultString: String { + get {_storage._defaultString ?? "Rosebud"} + set {_uniqueStorage()._defaultString = newValue} + } + /// Returns true if `defaultString` has been explicitly set. + var hasDefaultString: Bool {_storage._defaultString != nil} + /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. + mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} + + var defaultBytes: Data { + get {_storage._defaultBytes ?? Data([106, 111, 115, 104, 117, 97])} + set {_uniqueStorage()._defaultBytes = newValue} + } + /// Returns true if `defaultBytes` has been explicitly set. + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} + /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. + mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 + + /// Intentionally negative. + case neg = -1 + + init() { + self = .foo + } + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var corecursive: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2 { + get {_storage._corecursive ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var optionalCorecursive: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2 { + get {_storage._optionalCorecursive ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._optionalCorecursive = newValue} + } + /// Returns true if `optionalCorecursive` has been explicitly set. + var hasOptionalCorecursive: Bool {_storage._optionalCorecursive != nil} + /// Clears the value of `optionalCorecursive`. Subsequent reads from it will return its default value. + mutating func clearOptionalCorecursive() {_uniqueStorage()._optionalCorecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + /// groups + struct DataMessage: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + /// message_set test case. + struct MessageSetCorrect: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() + } + + struct MessageSetCorrectExtension1: Sendable { + // 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 str: String { + get {_str ?? String()} + set {_str = newValue} + } + /// Returns true if `str` has been explicitly set. + var hasStr: Bool {self._str != nil} + /// Clears the value of `str`. Subsequent reads from it will return its default value. + mutating func clearStr() {self._str = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _str: String? = nil + } + + struct MessageSetCorrectExtension2: Sendable { + // 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 i: Int32 { + get {_i ?? 0} + set {_i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {self._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {self._i = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _i: Int32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct ProtobufTestMessages_Proto2_TestLargeOneof: Sendable { + // 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 largeOneof: ProtobufTestMessages_Proto2_TestLargeOneof.OneOf_LargeOneof? = nil + + var a1: ProtobufTestMessages_Proto2_TestLargeOneof.A1 { + get { + if case .a1(let v)? = largeOneof {return v} + return ProtobufTestMessages_Proto2_TestLargeOneof.A1() + } + set {largeOneof = .a1(newValue)} + } + + var a2: ProtobufTestMessages_Proto2_TestLargeOneof.A2 { + get { + if case .a2(let v)? = largeOneof {return v} + return ProtobufTestMessages_Proto2_TestLargeOneof.A2() + } + set {largeOneof = .a2(newValue)} + } + + var a3: ProtobufTestMessages_Proto2_TestLargeOneof.A3 { + get { + if case .a3(let v)? = largeOneof {return v} + return ProtobufTestMessages_Proto2_TestLargeOneof.A3() + } + set {largeOneof = .a3(newValue)} + } + + var a4: ProtobufTestMessages_Proto2_TestLargeOneof.A4 { + get { + if case .a4(let v)? = largeOneof {return v} + return ProtobufTestMessages_Proto2_TestLargeOneof.A4() + } + set {largeOneof = .a4(newValue)} + } + + var a5: ProtobufTestMessages_Proto2_TestLargeOneof.A5 { + get { + if case .a5(let v)? = largeOneof {return v} + return ProtobufTestMessages_Proto2_TestLargeOneof.A5() + } + set {largeOneof = .a5(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_LargeOneof: Equatable, Sendable { + case a1(ProtobufTestMessages_Proto2_TestLargeOneof.A1) + case a2(ProtobufTestMessages_Proto2_TestLargeOneof.A2) + case a3(ProtobufTestMessages_Proto2_TestLargeOneof.A3) + case a4(ProtobufTestMessages_Proto2_TestLargeOneof.A4) + case a5(ProtobufTestMessages_Proto2_TestLargeOneof.A5) + + } + + struct A1: Sendable { + // 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 A2: Sendable { + // 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 A3: Sendable { + // 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 A4: Sendable { + // 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 A5: Sendable { + // 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() {} + } + + init() {} +} + +// MARK: - Extension support defined in test_messages_proto2.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect { + + var ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension1_messageSetExtension: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1 { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1()} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension1_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension2_messageSetExtension: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2 { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2()} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension2_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2 { + + var ProtobufTestMessages_Proto2_extensionInt32: Int32 { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32) ?? 0} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_Extensions_extension_int32` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_extensionInt32: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_Extensions_extension_int32`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_extensionInt32() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32) + } + + var ProtobufTestMessages_Proto2_groupField: ProtobufTestMessages_Proto2_GroupField { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_GroupField) ?? ProtobufTestMessages_Proto2_GroupField()} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_GroupField, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_Extensions_GroupField` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_groupField: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_GroupField) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_Extensions_GroupField`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_groupField() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_GroupField) + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect { + + var ProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1 { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1()} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2 { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2()} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Proto2_TestAllTypesProto2_ExtensionWithOneof_extensionWithOneof: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof) ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof()} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_TestAllTypesProto2_ExtensionWithOneof_extensionWithOneof: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_TestAllTypesProto2_ExtensionWithOneof_extensionWithOneof() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof) + } + +} + +// MARK: - File's ExtensionMap: ProtobufTestMessages_Proto2_TestMessagesProto2_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 ProtobufTestMessages_Proto2_TestMessagesProto2_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + ProtobufTestMessages_Proto2_Extensions_extension_int32, + ProtobufTestMessages_Proto2_Extensions_GroupField, + ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, + ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, + ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof, + ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, + ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension +] + +// 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 ProtobufTestMessages_Proto2_Extensions_extension_int32 = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2>( + _protobuf_fieldNumber: 120, + fieldName: "protobuf_test_messages.proto2.extension_int32" +) + +let ProtobufTestMessages_Proto2_Extensions_GroupField = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2>( + _protobuf_fieldNumber: 121, + fieldName: "protobuf_test_messages.proto2.groupfield" +) + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 1547769, + fieldName: "protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension1" + ) + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 4135312, + fieldName: "protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension2" + ) + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof { + enum Extensions { + static let extension_with_oneof = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 123456789, + fieldName: "protobuf_test_messages.proto2.TestAllTypesProto2.ExtensionWithOneof" + ) + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 1547769, + fieldName: "protobuf_test_messages.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension1" + ) + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 4135312, + fieldName: "protobuf_test_messages.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension2" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "protobuf_test_messages.proto2" + +extension ProtobufTestMessages_Proto2_ForeignEnumProto2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypesProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{4}\u{2}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{4}\u{2}optional_string_piece\0\u{3}optional_cord\0\u{4}\u{2}recursive_message\0\u{4}\u{4}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{4}\u{2}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_nested_message\0\u{3}map_string_foreign_message\0\u{3}map_string_nested_enum\0\u{3}map_string_foreign_enum\0\u{3}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_nested_enum\0\u{3}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_nested_enum\0\u{3}map_int32_nested_message\0\u{3}map_int32_bool\0\u{4}\u{7}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_bool\0\u{3}oneof_uint64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_enum\0\u{8}R\u{1}Data\0\u{8}\u{3}MultiWordGroupField\0\u{4}%default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{2}R\u{2}fieldname1\0\u{3}field_name2\0\u{3}_field_name3\0\u{3}field__name4_\0\u{1}field0name5\0\u{3}field_0_name6\0\u{1}fieldName7\0\u{1}FieldName8\0\u{3}field_Name9\0\u{3}Field_Name10\0\u{3}FIELD_NAME11\0\u{3}FIELD_name12\0\u{3}__field_name13\0\u{3}__Field_name14\0\u{3}field__name15\0\u{3}field__Name16\0\u{3}field_name17__\0\u{3}Field_name18__\0\u{4}R\u{1}message_set_correct\0\u{b}reserved_field\0\u{c}h\u{f}hL\u{2}\u{c}\u{7f}Ht\u{3}\u{1}") + + fileprivate class _StorageClass { + var _optionalInt32: Int32? = nil + var _optionalInt64: Int64? = nil + var _optionalUint32: UInt32? = nil + var _optionalUint64: UInt64? = nil + var _optionalSint32: Int32? = nil + var _optionalSint64: Int64? = nil + var _optionalFixed32: UInt32? = nil + var _optionalFixed64: UInt64? = nil + var _optionalSfixed32: Int32? = nil + var _optionalSfixed64: Int64? = nil + var _optionalFloat: Float? = nil + var _optionalDouble: Double? = nil + var _optionalBool: Bool? = nil + var _optionalString: String? = nil + var _optionalBytes: Data? = nil + var _optionalNestedMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage? = nil + var _optionalForeignMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2? = nil + var _optionalNestedEnum: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum? = nil + var _optionalForeignEnum: ProtobufTestMessages_Proto2_ForeignEnumProto2? = nil + var _optionalStringPiece: String? = nil + var _optionalCord: String? = nil + var _recursiveMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2? = nil + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedNestedMessage: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage] = [] + var _repeatedForeignMessage: [ProtobufTestMessages_Proto2_ForeignMessageProto2] = [] + var _repeatedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _repeatedForeignEnum: [ProtobufTestMessages_Proto2_ForeignEnumProto2] = [] + var _repeatedStringPiece: [String] = [] + var _repeatedCord: [String] = [] + var _packedInt32: [Int32] = [] + var _packedInt64: [Int64] = [] + var _packedUint32: [UInt32] = [] + var _packedUint64: [UInt64] = [] + var _packedSint32: [Int32] = [] + var _packedSint64: [Int64] = [] + var _packedFixed32: [UInt32] = [] + var _packedFixed64: [UInt64] = [] + var _packedSfixed32: [Int32] = [] + var _packedSfixed64: [Int64] = [] + var _packedFloat: [Float] = [] + var _packedDouble: [Double] = [] + var _packedBool: [Bool] = [] + var _packedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _unpackedInt32: [Int32] = [] + var _unpackedInt64: [Int64] = [] + var _unpackedUint32: [UInt32] = [] + var _unpackedUint64: [UInt64] = [] + var _unpackedSint32: [Int32] = [] + var _unpackedSint64: [Int64] = [] + var _unpackedFixed32: [UInt32] = [] + var _unpackedFixed64: [UInt64] = [] + var _unpackedSfixed32: [Int32] = [] + var _unpackedSfixed64: [Int64] = [] + var _unpackedFloat: [Float] = [] + var _unpackedDouble: [Double] = [] + var _unpackedBool: [Bool] = [] + var _unpackedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _mapInt32Int32: Dictionary = [:] + var _mapInt64Int64: Dictionary = [:] + var _mapUint32Uint32: Dictionary = [:] + var _mapUint64Uint64: Dictionary = [:] + var _mapSint32Sint32: Dictionary = [:] + var _mapSint64Sint64: Dictionary = [:] + var _mapFixed32Fixed32: Dictionary = [:] + var _mapFixed64Fixed64: Dictionary = [:] + var _mapSfixed32Sfixed32: Dictionary = [:] + var _mapSfixed64Sfixed64: Dictionary = [:] + var _mapInt32Bool: Dictionary = [:] + var _mapInt32Float: Dictionary = [:] + var _mapInt32Double: Dictionary = [:] + var _mapInt32NestedMessage: Dictionary = [:] + var _mapBoolBool: Dictionary = [:] + var _mapStringString: Dictionary = [:] + var _mapStringBytes: Dictionary = [:] + var _mapStringNestedMessage: Dictionary = [:] + var _mapStringForeignMessage: Dictionary = [:] + var _mapStringNestedEnum: Dictionary = [:] + var _mapStringForeignEnum: Dictionary = [:] + var _oneofField: ProtobufTestMessages_Proto2_TestAllTypesProto2.OneOf_OneofField? + var _data: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage? = nil + var _multiWordGroupField: ProtobufTestMessages_Proto2_TestAllTypesProto2.MultiWordGroupField? = nil + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + var _fieldname1: Int32? = nil + var _fieldName2: Int32? = nil + var _fieldName3: Int32? = nil + var _field_Name4_: Int32? = nil + var _field0Name5: Int32? = nil + var _field0Name6: Int32? = nil + var _fieldName7: Int32? = nil + var _fieldName8: Int32? = nil + var _fieldName9: Int32? = nil + var _fieldName10: Int32? = nil + var _fieldName11: Int32? = nil + var _fieldName12: Int32? = nil + var __FieldName13: Int32? = nil + var __FieldName14: Int32? = nil + var _field_Name15: Int32? = nil + var _field_Name16: Int32? = nil + var _fieldName17__: Int32? = nil + var _fieldName18__: Int32? = nil + var _messageSetCorrect: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalNestedMessage = source._optionalNestedMessage + _optionalForeignMessage = source._optionalForeignMessage + _optionalNestedEnum = source._optionalNestedEnum + _optionalForeignEnum = source._optionalForeignEnum + _optionalStringPiece = source._optionalStringPiece + _optionalCord = source._optionalCord + _recursiveMessage = source._recursiveMessage + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedForeignMessage = source._repeatedForeignMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _repeatedForeignEnum = source._repeatedForeignEnum + _repeatedStringPiece = source._repeatedStringPiece + _repeatedCord = source._repeatedCord + _packedInt32 = source._packedInt32 + _packedInt64 = source._packedInt64 + _packedUint32 = source._packedUint32 + _packedUint64 = source._packedUint64 + _packedSint32 = source._packedSint32 + _packedSint64 = source._packedSint64 + _packedFixed32 = source._packedFixed32 + _packedFixed64 = source._packedFixed64 + _packedSfixed32 = source._packedSfixed32 + _packedSfixed64 = source._packedSfixed64 + _packedFloat = source._packedFloat + _packedDouble = source._packedDouble + _packedBool = source._packedBool + _packedNestedEnum = source._packedNestedEnum + _unpackedInt32 = source._unpackedInt32 + _unpackedInt64 = source._unpackedInt64 + _unpackedUint32 = source._unpackedUint32 + _unpackedUint64 = source._unpackedUint64 + _unpackedSint32 = source._unpackedSint32 + _unpackedSint64 = source._unpackedSint64 + _unpackedFixed32 = source._unpackedFixed32 + _unpackedFixed64 = source._unpackedFixed64 + _unpackedSfixed32 = source._unpackedSfixed32 + _unpackedSfixed64 = source._unpackedSfixed64 + _unpackedFloat = source._unpackedFloat + _unpackedDouble = source._unpackedDouble + _unpackedBool = source._unpackedBool + _unpackedNestedEnum = source._unpackedNestedEnum + _mapInt32Int32 = source._mapInt32Int32 + _mapInt64Int64 = source._mapInt64Int64 + _mapUint32Uint32 = source._mapUint32Uint32 + _mapUint64Uint64 = source._mapUint64Uint64 + _mapSint32Sint32 = source._mapSint32Sint32 + _mapSint64Sint64 = source._mapSint64Sint64 + _mapFixed32Fixed32 = source._mapFixed32Fixed32 + _mapFixed64Fixed64 = source._mapFixed64Fixed64 + _mapSfixed32Sfixed32 = source._mapSfixed32Sfixed32 + _mapSfixed64Sfixed64 = source._mapSfixed64Sfixed64 + _mapInt32Bool = source._mapInt32Bool + _mapInt32Float = source._mapInt32Float + _mapInt32Double = source._mapInt32Double + _mapInt32NestedMessage = source._mapInt32NestedMessage + _mapBoolBool = source._mapBoolBool + _mapStringString = source._mapStringString + _mapStringBytes = source._mapStringBytes + _mapStringNestedMessage = source._mapStringNestedMessage + _mapStringForeignMessage = source._mapStringForeignMessage + _mapStringNestedEnum = source._mapStringNestedEnum + _mapStringForeignEnum = source._mapStringForeignEnum + _oneofField = source._oneofField + _data = source._data + _multiWordGroupField = source._multiWordGroupField + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + _fieldname1 = source._fieldname1 + _fieldName2 = source._fieldName2 + _fieldName3 = source._fieldName3 + _field_Name4_ = source._field_Name4_ + _field0Name5 = source._field0Name5 + _field0Name6 = source._field0Name6 + _fieldName7 = source._fieldName7 + _fieldName8 = source._fieldName8 + _fieldName9 = source._fieldName9 + _fieldName10 = source._fieldName10 + _fieldName11 = source._fieldName11 + _fieldName12 = source._fieldName12 + __FieldName13 = source.__FieldName13 + __FieldName14 = source.__FieldName14 + _field_Name15 = source._field_Name15 + _field_Name16 = source._field_Name16 + _fieldName17__ = source._fieldName17__ + _fieldName18__ = source._fieldName18__ + _messageSetCorrect = source._messageSetCorrect + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._optionalNestedMessage, !v.isInitialized {return false} + if let v = _storage._recursiveMessage, !v.isInitialized {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._repeatedNestedMessage) {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._mapInt32NestedMessage) {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._mapStringNestedMessage) {return false} + if let v = _storage._oneofField, !v.isInitialized {return false} + if let v = _storage._messageSetCorrect, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() + case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() + case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() + case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() + case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() + case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() + case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() + case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() + case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() + case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() + case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() + case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() + case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() + case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() + case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() + case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() + case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() + case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() + case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() + case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() + case 56: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Int32) }() + case 57: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() + case 58: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() + case 59: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Uint64) }() + case 60: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Sint32) }() + case 61: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Sint64) }() + case 62: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Fixed32) }() + case 63: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Fixed64) }() + case 64: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Sfixed32) }() + case 65: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Sfixed64) }() + case 66: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Float) }() + case 67: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Double) }() + case 68: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() + case 69: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() + case 70: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() + case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringNestedMessage) }() + case 72: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() + case 73: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringNestedEnum) }() + case 74: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringForeignEnum) }() + case 75: try { try decoder.decodeRepeatedInt32Field(value: &_storage._packedInt32) }() + case 76: try { try decoder.decodeRepeatedInt64Field(value: &_storage._packedInt64) }() + case 77: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._packedUint32) }() + case 78: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._packedUint64) }() + case 79: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._packedSint32) }() + case 80: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._packedSint64) }() + case 81: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._packedFixed32) }() + case 82: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._packedFixed64) }() + case 83: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._packedSfixed32) }() + case 84: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._packedSfixed64) }() + case 85: try { try decoder.decodeRepeatedFloatField(value: &_storage._packedFloat) }() + case 86: try { try decoder.decodeRepeatedDoubleField(value: &_storage._packedDouble) }() + case 87: try { try decoder.decodeRepeatedBoolField(value: &_storage._packedBool) }() + case 88: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedNestedEnum) }() + case 89: try { try decoder.decodeRepeatedInt32Field(value: &_storage._unpackedInt32) }() + case 90: try { try decoder.decodeRepeatedInt64Field(value: &_storage._unpackedInt64) }() + case 91: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._unpackedUint32) }() + case 92: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._unpackedUint64) }() + case 93: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._unpackedSint32) }() + case 94: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._unpackedSint64) }() + case 95: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._unpackedFixed32) }() + case 96: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._unpackedFixed64) }() + case 97: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._unpackedSfixed32) }() + case 98: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._unpackedSfixed64) }() + case 99: try { try decoder.decodeRepeatedFloatField(value: &_storage._unpackedFloat) }() + case 100: try { try decoder.decodeRepeatedDoubleField(value: &_storage._unpackedDouble) }() + case 101: try { try decoder.decodeRepeatedBoolField(value: &_storage._unpackedBool) }() + case 102: try { try decoder.decodeRepeatedEnumField(value: &_storage._unpackedNestedEnum) }() + case 103: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32NestedMessage) }() + case 104: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bool) }() + case 111: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 112: try { + var v: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage(v) + } + }() + case 113: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 114: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() + case 115: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBool(v) + } + }() + case 116: try { + var v: UInt64? + try decoder.decodeSingularUInt64Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint64(v) + } + }() + case 117: try { + var v: Float? + try decoder.decodeSingularFloatField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofFloat(v) + } + }() + case 118: try { + var v: Double? + try decoder.decodeSingularDoubleField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofDouble(v) + } + }() + case 119: try { + var v: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofEnum(v) + } + }() + case 201: try { try decoder.decodeSingularGroupField(value: &_storage._data) }() + case 204: try { try decoder.decodeSingularGroupField(value: &_storage._multiWordGroupField) }() + case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 242: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 243: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 244: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 245: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 246: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 247: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 248: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 249: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 250: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 251: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 252: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 253: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 254: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 255: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() + case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldname1) }() + case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName2) }() + case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName3) }() + case 404: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name4_) }() + case 405: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name5) }() + case 406: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name6) }() + case 407: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName7) }() + case 408: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName8) }() + case 409: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName9) }() + case 410: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName10) }() + case 411: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName11) }() + case 412: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName12) }() + case 413: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName13) }() + case 414: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName14) }() + case 415: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name15) }() + case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name16) }() + case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName17__) }() + case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName18__) }() + case 500: try { try decoder.decodeSingularMessageField(value: &_storage._messageSetCorrect) }() + case 120..<201: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Proto2_TestAllTypesProto2.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._optionalInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._optionalUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._optionalSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._optionalSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._optionalFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._optionalFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._optionalSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._optionalSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._optionalFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._optionalDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._optionalBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._optionalForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._optionalNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._optionalForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._optionalStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._optionalCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + if !_storage._repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + } + if !_storage._repeatedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + } + if !_storage._repeatedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + } + if !_storage._repeatedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + } + if !_storage._repeatedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + } + if !_storage._repeatedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + } + if !_storage._repeatedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + } + if !_storage._repeatedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + } + if !_storage._repeatedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + } + if !_storage._repeatedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + } + if !_storage._repeatedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + } + if !_storage._repeatedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + } + if !_storage._repeatedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + } + if !_storage._repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) + } + if !_storage._repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) + } + if !_storage._repeatedNestedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) + } + if !_storage._repeatedForeignMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) + } + if !_storage._repeatedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + } + if !_storage._repeatedForeignEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) + } + if !_storage._repeatedStringPiece.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) + } + if !_storage._repeatedCord.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) + } + if !_storage._mapInt32Int32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Int32, fieldNumber: 56) + } + if !_storage._mapInt64Int64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Int64, fieldNumber: 57) + } + if !_storage._mapUint32Uint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Uint32, fieldNumber: 58) + } + if !_storage._mapUint64Uint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Uint64, fieldNumber: 59) + } + if !_storage._mapSint32Sint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Sint32, fieldNumber: 60) + } + if !_storage._mapSint64Sint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Sint64, fieldNumber: 61) + } + if !_storage._mapFixed32Fixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Fixed32, fieldNumber: 62) + } + if !_storage._mapFixed64Fixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Fixed64, fieldNumber: 63) + } + if !_storage._mapSfixed32Sfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 64) + } + if !_storage._mapSfixed64Sfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 65) + } + if !_storage._mapInt32Float.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Float, fieldNumber: 66) + } + if !_storage._mapInt32Double.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Double, fieldNumber: 67) + } + if !_storage._mapBoolBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolBool, fieldNumber: 68) + } + if !_storage._mapStringString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringString, fieldNumber: 69) + } + if !_storage._mapStringBytes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 70) + } + if !_storage._mapStringNestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringNestedMessage, fieldNumber: 71) + } + if !_storage._mapStringForeignMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 72) + } + if !_storage._mapStringNestedEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringNestedEnum, fieldNumber: 73) + } + if !_storage._mapStringForeignEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringForeignEnum, fieldNumber: 74) + } + if !_storage._packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._packedInt32, fieldNumber: 75) + } + if !_storage._packedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._packedInt64, fieldNumber: 76) + } + if !_storage._packedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._packedUint32, fieldNumber: 77) + } + if !_storage._packedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._packedUint64, fieldNumber: 78) + } + if !_storage._packedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._packedSint32, fieldNumber: 79) + } + if !_storage._packedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._packedSint64, fieldNumber: 80) + } + if !_storage._packedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._packedFixed32, fieldNumber: 81) + } + if !_storage._packedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._packedFixed64, fieldNumber: 82) + } + if !_storage._packedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._packedSfixed32, fieldNumber: 83) + } + if !_storage._packedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._packedSfixed64, fieldNumber: 84) + } + if !_storage._packedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._packedFloat, fieldNumber: 85) + } + if !_storage._packedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._packedDouble, fieldNumber: 86) + } + if !_storage._packedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._packedBool, fieldNumber: 87) + } + if !_storage._packedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedNestedEnum, fieldNumber: 88) + } + if !_storage._unpackedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._unpackedInt32, fieldNumber: 89) + } + if !_storage._unpackedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._unpackedInt64, fieldNumber: 90) + } + if !_storage._unpackedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._unpackedUint32, fieldNumber: 91) + } + if !_storage._unpackedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._unpackedUint64, fieldNumber: 92) + } + if !_storage._unpackedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._unpackedSint32, fieldNumber: 93) + } + if !_storage._unpackedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._unpackedSint64, fieldNumber: 94) + } + if !_storage._unpackedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._unpackedFixed32, fieldNumber: 95) + } + if !_storage._unpackedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._unpackedFixed64, fieldNumber: 96) + } + if !_storage._unpackedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._unpackedSfixed32, fieldNumber: 97) + } + if !_storage._unpackedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._unpackedSfixed64, fieldNumber: 98) + } + if !_storage._unpackedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._unpackedFloat, fieldNumber: 99) + } + if !_storage._unpackedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._unpackedDouble, fieldNumber: 100) + } + if !_storage._unpackedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._unpackedBool, fieldNumber: 101) + } + if !_storage._unpackedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._unpackedNestedEnum, fieldNumber: 102) + } + if !_storage._mapInt32NestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32NestedMessage, fieldNumber: 103) + } + if !_storage._mapInt32Bool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bool, fieldNumber: 104) + } + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case .oneofBool?: try { + guard case .oneofBool(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 115) + }() + case .oneofUint64?: try { + guard case .oneofUint64(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 116) + }() + case .oneofFloat?: try { + guard case .oneofFloat(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularFloatField(value: v, fieldNumber: 117) + }() + case .oneofDouble?: try { + guard case .oneofDouble(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularDoubleField(value: v, fieldNumber: 118) + }() + case .oneofEnum?: try { + guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 119) + }() + case nil: break + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201) + try { if let v = _storage._data { + try visitor.visitSingularGroupField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._multiWordGroupField { + try visitor.visitSingularGroupField(value: v, fieldNumber: 204) + } }() + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 241) + } }() + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 242) + } }() + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 243) + } }() + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 244) + } }() + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 245) + } }() + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 246) + } }() + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 247) + } }() + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 248) + } }() + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 249) + } }() + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 250) + } }() + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 251) + } }() + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 252) + } }() + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 253) + } }() + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 254) + } }() + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 255) + } }() + try { if let v = _storage._fieldname1 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 401) + } }() + try { if let v = _storage._fieldName2 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 402) + } }() + try { if let v = _storage._fieldName3 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 403) + } }() + try { if let v = _storage._field_Name4_ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 404) + } }() + try { if let v = _storage._field0Name5 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 405) + } }() + try { if let v = _storage._field0Name6 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 406) + } }() + try { if let v = _storage._fieldName7 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 407) + } }() + try { if let v = _storage._fieldName8 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 408) + } }() + try { if let v = _storage._fieldName9 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 409) + } }() + try { if let v = _storage._fieldName10 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 410) + } }() + try { if let v = _storage._fieldName11 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 411) + } }() + try { if let v = _storage._fieldName12 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 412) + } }() + try { if let v = _storage.__FieldName13 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 413) + } }() + try { if let v = _storage.__FieldName14 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 414) + } }() + try { if let v = _storage._field_Name15 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 415) + } }() + try { if let v = _storage._field_Name16 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 416) + } }() + try { if let v = _storage._fieldName17__ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 417) + } }() + try { if let v = _storage._fieldName18__ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 418) + } }() + try { if let v = _storage._messageSetCorrect { + try visitor.visitSingularMessageField(value: v, fieldNumber: 500) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} + if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} + if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} + if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} + if _storage._repeatedCord != rhs_storage._repeatedCord {return false} + if _storage._packedInt32 != rhs_storage._packedInt32 {return false} + if _storage._packedInt64 != rhs_storage._packedInt64 {return false} + if _storage._packedUint32 != rhs_storage._packedUint32 {return false} + if _storage._packedUint64 != rhs_storage._packedUint64 {return false} + if _storage._packedSint32 != rhs_storage._packedSint32 {return false} + if _storage._packedSint64 != rhs_storage._packedSint64 {return false} + if _storage._packedFixed32 != rhs_storage._packedFixed32 {return false} + if _storage._packedFixed64 != rhs_storage._packedFixed64 {return false} + if _storage._packedSfixed32 != rhs_storage._packedSfixed32 {return false} + if _storage._packedSfixed64 != rhs_storage._packedSfixed64 {return false} + if _storage._packedFloat != rhs_storage._packedFloat {return false} + if _storage._packedDouble != rhs_storage._packedDouble {return false} + if _storage._packedBool != rhs_storage._packedBool {return false} + if _storage._packedNestedEnum != rhs_storage._packedNestedEnum {return false} + if _storage._unpackedInt32 != rhs_storage._unpackedInt32 {return false} + if _storage._unpackedInt64 != rhs_storage._unpackedInt64 {return false} + if _storage._unpackedUint32 != rhs_storage._unpackedUint32 {return false} + if _storage._unpackedUint64 != rhs_storage._unpackedUint64 {return false} + if _storage._unpackedSint32 != rhs_storage._unpackedSint32 {return false} + if _storage._unpackedSint64 != rhs_storage._unpackedSint64 {return false} + if _storage._unpackedFixed32 != rhs_storage._unpackedFixed32 {return false} + if _storage._unpackedFixed64 != rhs_storage._unpackedFixed64 {return false} + if _storage._unpackedSfixed32 != rhs_storage._unpackedSfixed32 {return false} + if _storage._unpackedSfixed64 != rhs_storage._unpackedSfixed64 {return false} + if _storage._unpackedFloat != rhs_storage._unpackedFloat {return false} + if _storage._unpackedDouble != rhs_storage._unpackedDouble {return false} + if _storage._unpackedBool != rhs_storage._unpackedBool {return false} + if _storage._unpackedNestedEnum != rhs_storage._unpackedNestedEnum {return false} + if _storage._mapInt32Int32 != rhs_storage._mapInt32Int32 {return false} + if _storage._mapInt64Int64 != rhs_storage._mapInt64Int64 {return false} + if _storage._mapUint32Uint32 != rhs_storage._mapUint32Uint32 {return false} + if _storage._mapUint64Uint64 != rhs_storage._mapUint64Uint64 {return false} + if _storage._mapSint32Sint32 != rhs_storage._mapSint32Sint32 {return false} + if _storage._mapSint64Sint64 != rhs_storage._mapSint64Sint64 {return false} + if _storage._mapFixed32Fixed32 != rhs_storage._mapFixed32Fixed32 {return false} + if _storage._mapFixed64Fixed64 != rhs_storage._mapFixed64Fixed64 {return false} + if _storage._mapSfixed32Sfixed32 != rhs_storage._mapSfixed32Sfixed32 {return false} + if _storage._mapSfixed64Sfixed64 != rhs_storage._mapSfixed64Sfixed64 {return false} + if _storage._mapInt32Bool != rhs_storage._mapInt32Bool {return false} + if _storage._mapInt32Float != rhs_storage._mapInt32Float {return false} + if _storage._mapInt32Double != rhs_storage._mapInt32Double {return false} + if _storage._mapInt32NestedMessage != rhs_storage._mapInt32NestedMessage {return false} + if _storage._mapBoolBool != rhs_storage._mapBoolBool {return false} + if _storage._mapStringString != rhs_storage._mapStringString {return false} + if _storage._mapStringBytes != rhs_storage._mapStringBytes {return false} + if _storage._mapStringNestedMessage != rhs_storage._mapStringNestedMessage {return false} + if _storage._mapStringForeignMessage != rhs_storage._mapStringForeignMessage {return false} + if _storage._mapStringNestedEnum != rhs_storage._mapStringNestedEnum {return false} + if _storage._mapStringForeignEnum != rhs_storage._mapStringForeignEnum {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + if _storage._data != rhs_storage._data {return false} + if _storage._multiWordGroupField != rhs_storage._multiWordGroupField {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} + if _storage._fieldname1 != rhs_storage._fieldname1 {return false} + if _storage._fieldName2 != rhs_storage._fieldName2 {return false} + if _storage._fieldName3 != rhs_storage._fieldName3 {return false} + if _storage._field_Name4_ != rhs_storage._field_Name4_ {return false} + if _storage._field0Name5 != rhs_storage._field0Name5 {return false} + if _storage._field0Name6 != rhs_storage._field0Name6 {return false} + if _storage._fieldName7 != rhs_storage._fieldName7 {return false} + if _storage._fieldName8 != rhs_storage._fieldName8 {return false} + if _storage._fieldName9 != rhs_storage._fieldName9 {return false} + if _storage._fieldName10 != rhs_storage._fieldName10 {return false} + if _storage._fieldName11 != rhs_storage._fieldName11 {return false} + if _storage._fieldName12 != rhs_storage._fieldName12 {return false} + if _storage.__FieldName13 != rhs_storage.__FieldName13 {return false} + if _storage.__FieldName14 != rhs_storage.__FieldName14 {return false} + if _storage._field_Name15 != rhs_storage._field_Name15 {return false} + if _storage._field_Name16 != rhs_storage._field_Name16 {return false} + if _storage._fieldName17__ != rhs_storage._fieldName17__ {return false} + if _storage._fieldName18__ != rhs_storage._fieldName18__ {return false} + if _storage._messageSetCorrect != rhs_storage._messageSetCorrect {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _corecursive: ProtobufTestMessages_Proto2_TestAllTypesProto2? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._corecursive, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}J\u{3}group_int32\0\u{3}group_uint32\0") + + 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 202: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 203: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 202) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 203) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MultiWordGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".MultiWordGroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}M\u{3}group_int32\0\u{3}group_uint32\0") + + 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 205: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 206: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 205) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 206) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MultiWordGroupField, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MultiWordGroupField) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect.self) + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrectExtension1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{19}str\0") + + 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 25: try { try decoder.decodeSingularStringField(value: &self._str) }() + 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 + try { if let v = self._str { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1) -> Bool { + if lhs._str != rhs._str {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrectExtension2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{9}i\0") + + 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 9: try { try decoder.decodeSingularInt32Field(value: &self._i) }() + 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 + try { if let v = self._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2) -> Bool { + if lhs._i != rhs._i {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".ExtensionWithOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .a(v) + } + }() + case 2: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .b(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.oneofField { + case .a?: try { + guard case .a(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + }() + case .b?: try { + guard case .b(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof) -> Bool { + if lhs.oneofField != rhs.oneofField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_ForeignMessageProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessageProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") + + 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._c) }() + 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 + try { if let v = self._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_ForeignMessageProto2, rhs: ProtobufTestMessages_Proto2_ForeignMessageProto2) -> Bool { + if lhs._c != rhs._c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_GroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}z\u{1}group_int32\0\u{3}group_uint32\0") + + 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 122: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 123: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 122) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 123) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_GroupField, rhs: ProtobufTestMessages_Proto2_GroupField) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".UnknownToTestAllTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}i\u{f}optional_int32\0\u{3}optional_string\0\u{3}nested_message\0\u{7}OptionalGroup\0\u{4}\u{2}optional_bool\0\u{4}\u{5}repeated_int32\0") + + 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 1001: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32) }() + case 1002: try { try decoder.decodeSingularStringField(value: &self._optionalString) }() + case 1003: try { try decoder.decodeSingularMessageField(value: &self._nestedMessage) }() + case 1004: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() + case 1006: try { try decoder.decodeSingularBoolField(value: &self._optionalBool) }() + case 1011: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() + 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 + try { if let v = self._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1001) + } }() + try { if let v = self._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1002) + } }() + try { if let v = self._nestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1003) + } }() + try { if let v = self._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 1004) + } }() + try { if let v = self._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1006) + } }() + if !self.repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 1011) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes, rhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes) -> Bool { + if lhs._optionalInt32 != rhs._optionalInt32 {return false} + if lhs._optionalString != rhs._optionalString {return false} + if lhs._nestedMessage != rhs._nestedMessage {return false} + if lhs._optionalGroup != rhs._optionalGroup {return false} + if lhs._optionalBool != rhs._optionalBool {return false} + if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_UnknownToTestAllTypes.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") + + 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._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup, rhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_NullHypothesisProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NullHypothesisProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_NullHypothesisProto2, rhs: ProtobufTestMessages_Proto2_NullHypothesisProto2) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_EnumOnlyProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumOnlyProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_EnumOnlyProto2, rhs: ProtobufTestMessages_Proto2_EnumOnlyProto2) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_EnumOnlyProto2.BoolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0kFalse\0\u{1}kTrue\0") +} + +extension ProtobufTestMessages_Proto2_OneStringProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OneStringProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_OneStringProto2, rhs: ProtobufTestMessages_Proto2_OneStringProto2) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_ProtoWithKeywords: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ProtoWithKeywords" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}inline\0\u{1}concept\0\u{1}requires\0") + + 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._inline) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._concept) }() + case 3: try { try decoder.decodeRepeatedStringField(value: &self.requires) }() + 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 + try { if let v = self._inline { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._concept { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + if !self.requires.isEmpty { + try visitor.visitRepeatedStringField(value: self.requires, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_ProtoWithKeywords, rhs: ProtobufTestMessages_Proto2_ProtoWithKeywords) -> Bool { + if lhs._inline != rhs._inline {return false} + if lhs._concept != rhs._concept {return false} + if lhs.requires != rhs.requires {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllRequiredTypesProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_int32\0\u{3}required_int64\0\u{3}required_uint32\0\u{3}required_uint64\0\u{3}required_sint32\0\u{3}required_sint64\0\u{3}required_fixed32\0\u{3}required_fixed64\0\u{3}required_sfixed32\0\u{3}required_sfixed64\0\u{3}required_float\0\u{3}required_double\0\u{3}required_bool\0\u{3}required_string\0\u{3}required_bytes\0\u{4}\u{3}required_nested_message\0\u{3}required_foreign_message\0\u{4}\u{2}required_nested_enum\0\u{3}required_foreign_enum\0\u{4}\u{2}required_string_piece\0\u{3}required_cord\0\u{4}\u{2}recursive_message\0\u{3}optional_recursive_message\0\u{8}m\u{2}Data\0\u{4}(default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{c}h\u{f}hL\u{2}") + + fileprivate class _StorageClass { + var _requiredInt32: Int32? = nil + var _requiredInt64: Int64? = nil + var _requiredUint32: UInt32? = nil + var _requiredUint64: UInt64? = nil + var _requiredSint32: Int32? = nil + var _requiredSint64: Int64? = nil + var _requiredFixed32: UInt32? = nil + var _requiredFixed64: UInt64? = nil + var _requiredSfixed32: Int32? = nil + var _requiredSfixed64: Int64? = nil + var _requiredFloat: Float? = nil + var _requiredDouble: Double? = nil + var _requiredBool: Bool? = nil + var _requiredString: String? = nil + var _requiredBytes: Data? = nil + var _requiredNestedMessage: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage? = nil + var _requiredForeignMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2? = nil + var _requiredNestedEnum: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedEnum? = nil + var _requiredForeignEnum: ProtobufTestMessages_Proto2_ForeignEnumProto2? = nil + var _requiredStringPiece: String? = nil + var _requiredCord: String? = nil + var _recursiveMessage: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2? = nil + var _optionalRecursiveMessage: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2? = nil + var _data: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage? = nil + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _requiredInt32 = source._requiredInt32 + _requiredInt64 = source._requiredInt64 + _requiredUint32 = source._requiredUint32 + _requiredUint64 = source._requiredUint64 + _requiredSint32 = source._requiredSint32 + _requiredSint64 = source._requiredSint64 + _requiredFixed32 = source._requiredFixed32 + _requiredFixed64 = source._requiredFixed64 + _requiredSfixed32 = source._requiredSfixed32 + _requiredSfixed64 = source._requiredSfixed64 + _requiredFloat = source._requiredFloat + _requiredDouble = source._requiredDouble + _requiredBool = source._requiredBool + _requiredString = source._requiredString + _requiredBytes = source._requiredBytes + _requiredNestedMessage = source._requiredNestedMessage + _requiredForeignMessage = source._requiredForeignMessage + _requiredNestedEnum = source._requiredNestedEnum + _requiredForeignEnum = source._requiredForeignEnum + _requiredStringPiece = source._requiredStringPiece + _requiredCord = source._requiredCord + _recursiveMessage = source._recursiveMessage + _optionalRecursiveMessage = source._optionalRecursiveMessage + _data = source._data + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._requiredInt32 == nil {return false} + if _storage._requiredInt64 == nil {return false} + if _storage._requiredUint32 == nil {return false} + if _storage._requiredUint64 == nil {return false} + if _storage._requiredSint32 == nil {return false} + if _storage._requiredSint64 == nil {return false} + if _storage._requiredFixed32 == nil {return false} + if _storage._requiredFixed64 == nil {return false} + if _storage._requiredSfixed32 == nil {return false} + if _storage._requiredSfixed64 == nil {return false} + if _storage._requiredFloat == nil {return false} + if _storage._requiredDouble == nil {return false} + if _storage._requiredBool == nil {return false} + if _storage._requiredString == nil {return false} + if _storage._requiredBytes == nil {return false} + if _storage._requiredNestedMessage == nil {return false} + if _storage._requiredForeignMessage == nil {return false} + if _storage._requiredNestedEnum == nil {return false} + if _storage._requiredForeignEnum == nil {return false} + if _storage._requiredStringPiece == nil {return false} + if _storage._requiredCord == nil {return false} + if _storage._recursiveMessage == nil {return false} + if _storage._data == nil {return false} + if _storage._defaultInt32 == nil {return false} + if _storage._defaultInt64 == nil {return false} + if _storage._defaultUint32 == nil {return false} + if _storage._defaultUint64 == nil {return false} + if _storage._defaultSint32 == nil {return false} + if _storage._defaultSint64 == nil {return false} + if _storage._defaultFixed32 == nil {return false} + if _storage._defaultFixed64 == nil {return false} + if _storage._defaultSfixed32 == nil {return false} + if _storage._defaultSfixed64 == nil {return false} + if _storage._defaultFloat == nil {return false} + if _storage._defaultDouble == nil {return false} + if _storage._defaultBool == nil {return false} + if _storage._defaultString == nil {return false} + if _storage._defaultBytes == nil {return false} + if let v = _storage._requiredNestedMessage, !v.isInitialized {return false} + if let v = _storage._recursiveMessage, !v.isInitialized {return false} + if let v = _storage._optionalRecursiveMessage, !v.isInitialized {return false} + if let v = _storage._data, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._requiredInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._requiredInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._requiredUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._requiredUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._requiredSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._requiredSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._requiredFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._requiredFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._requiredSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._requiredSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._requiredFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._requiredDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._requiredBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._requiredString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._requiredBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._requiredNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._requiredForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._requiredNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._requiredForeignEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._requiredStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._requiredCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 28: try { try decoder.decodeSingularMessageField(value: &_storage._optionalRecursiveMessage) }() + case 201: try { try decoder.decodeSingularGroupField(value: &_storage._data) }() + case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 242: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 243: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 244: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 245: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 246: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 247: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 248: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 249: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 250: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 251: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 252: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 253: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 254: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 255: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() + case 120..<201: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._requiredInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._requiredInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._requiredUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._requiredUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._requiredSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._requiredSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._requiredFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._requiredFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._requiredSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._requiredSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._requiredFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._requiredDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._requiredBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._requiredString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._requiredBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._requiredNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._requiredForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._requiredNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._requiredForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._requiredStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._requiredCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + try { if let v = _storage._optionalRecursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 28) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201) + try { if let v = _storage._data { + try visitor.visitSingularGroupField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 241) + } }() + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 242) + } }() + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 243) + } }() + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 244) + } }() + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 245) + } }() + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 246) + } }() + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 247) + } }() + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 248) + } }() + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 249) + } }() + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 250) + } }() + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 251) + } }() + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 252) + } }() + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 253) + } }() + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 254) + } }() + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 255) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2) -> 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._requiredInt32 != rhs_storage._requiredInt32 {return false} + if _storage._requiredInt64 != rhs_storage._requiredInt64 {return false} + if _storage._requiredUint32 != rhs_storage._requiredUint32 {return false} + if _storage._requiredUint64 != rhs_storage._requiredUint64 {return false} + if _storage._requiredSint32 != rhs_storage._requiredSint32 {return false} + if _storage._requiredSint64 != rhs_storage._requiredSint64 {return false} + if _storage._requiredFixed32 != rhs_storage._requiredFixed32 {return false} + if _storage._requiredFixed64 != rhs_storage._requiredFixed64 {return false} + if _storage._requiredSfixed32 != rhs_storage._requiredSfixed32 {return false} + if _storage._requiredSfixed64 != rhs_storage._requiredSfixed64 {return false} + if _storage._requiredFloat != rhs_storage._requiredFloat {return false} + if _storage._requiredDouble != rhs_storage._requiredDouble {return false} + if _storage._requiredBool != rhs_storage._requiredBool {return false} + if _storage._requiredString != rhs_storage._requiredString {return false} + if _storage._requiredBytes != rhs_storage._requiredBytes {return false} + if _storage._requiredNestedMessage != rhs_storage._requiredNestedMessage {return false} + if _storage._requiredForeignMessage != rhs_storage._requiredForeignMessage {return false} + if _storage._requiredNestedEnum != rhs_storage._requiredNestedEnum {return false} + if _storage._requiredForeignEnum != rhs_storage._requiredForeignEnum {return false} + if _storage._requiredStringPiece != rhs_storage._requiredStringPiece {return false} + if _storage._requiredCord != rhs_storage._requiredCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._optionalRecursiveMessage != rhs_storage._optionalRecursiveMessage {return false} + if _storage._data != rhs_storage._data {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0\u{3}optional_corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _corecursive: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2? = nil + var _optionalCorecursive: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + _optionalCorecursive = source._optionalCorecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._a == nil {return false} + if _storage._corecursive == nil {return false} + if let v = _storage._corecursive, !v.isInitialized {return false} + if let v = _storage._optionalCorecursive, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._optionalCorecursive) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalCorecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + if _storage._optionalCorecursive != rhs_storage._optionalCorecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}J\u{3}group_int32\0\u{3}group_uint32\0") + + public var isInitialized: Bool { + if self._groupInt32 == nil {return false} + if self._groupUint32 == nil {return false} + return true + } + + 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 202: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 203: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 202) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 203) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".MessageSetCorrect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect.self) + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".MessageSetCorrectExtension1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{19}str\0") + + public var isInitialized: Bool { + if self._str == nil {return false} + return true + } + + 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 25: try { try decoder.decodeSingularStringField(value: &self._str) }() + 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 + try { if let v = self._str { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1) -> Bool { + if lhs._str != rhs._str {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".MessageSetCorrectExtension2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{9}i\0") + + public var isInitialized: Bool { + if self._i == nil {return false} + return true + } + + 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 9: try { try decoder.decodeSingularInt32Field(value: &self._i) }() + 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 + try { if let v = self._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2) -> Bool { + if lhs._i != rhs._i {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestLargeOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestLargeOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a1\0\u{1}a2\0\u{1}a3\0\u{1}a4\0\u{1}a5\0") + + 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: ProtobufTestMessages_Proto2_TestLargeOneof.A1? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a1(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a1(v) + } + }() + case 2: try { + var v: ProtobufTestMessages_Proto2_TestLargeOneof.A2? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a2(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a2(v) + } + }() + case 3: try { + var v: ProtobufTestMessages_Proto2_TestLargeOneof.A3? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a3(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a3(v) + } + }() + case 4: try { + var v: ProtobufTestMessages_Proto2_TestLargeOneof.A4? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a4(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a4(v) + } + }() + case 5: try { + var v: ProtobufTestMessages_Proto2_TestLargeOneof.A5? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a5(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a5(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.largeOneof { + case .a1?: try { + guard case .a1(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + }() + case .a2?: try { + guard case .a2(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + }() + case .a3?: try { + guard case .a3(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + }() + case .a4?: try { + guard case .a4(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + }() + case .a5?: try { + guard case .a5(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestLargeOneof, rhs: ProtobufTestMessages_Proto2_TestLargeOneof) -> Bool { + if lhs.largeOneof != rhs.largeOneof {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestLargeOneof.A1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestLargeOneof.protoMessageName + ".A1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestLargeOneof.A1, rhs: ProtobufTestMessages_Proto2_TestLargeOneof.A1) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestLargeOneof.A2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestLargeOneof.protoMessageName + ".A2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestLargeOneof.A2, rhs: ProtobufTestMessages_Proto2_TestLargeOneof.A2) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestLargeOneof.A3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestLargeOneof.protoMessageName + ".A3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestLargeOneof.A3, rhs: ProtobufTestMessages_Proto2_TestLargeOneof.A3) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestLargeOneof.A4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestLargeOneof.protoMessageName + ".A4" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestLargeOneof.A4, rhs: ProtobufTestMessages_Proto2_TestLargeOneof.A4) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestLargeOneof.A5: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestLargeOneof.protoMessageName + ".A5" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestLargeOneof.A5, rhs: ProtobufTestMessages_Proto2_TestLargeOneof.A5) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/test_messages_proto3.pb.swift b/Reference/upstream/google/protobuf/test_messages_proto3.pb.swift new file mode 100644 index 000000000..6e42eff19 --- /dev/null +++ b/Reference/upstream/google/protobuf/test_messages_proto3.pb.swift @@ -0,0 +1,2499 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/test_messages_proto3.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Test schema for proto3 messages. This test schema is used by: +// +// - benchmarks +// - fuzz tests +// - conformance tests + +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 ProtobufTestMessages_Proto3_ForeignEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foreignFoo // = 0 + case foreignBar // = 1 + case foreignBaz // = 2 + case UNRECOGNIZED(Int) + + init() { + self = .foreignFoo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .foreignFoo + case 1: self = .foreignBar + case 2: self = .foreignBaz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .foreignFoo: return 0 + case .foreignBar: return 1 + case .foreignBaz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Proto3_ForeignEnum] = [ + .foreignFoo, + .foreignBar, + .foreignBaz, + ] + +} + +/// This proto includes every type of field in both singular and repeated +/// forms. +/// +/// Also, crucially, all messages and enums in this file are eventually +/// submessages of this message. So for example, a fuzz test of TestAllTypes +/// could trigger bugs that occur in any message type in this file. We verify +/// this stays true in a unit test. +struct ProtobufTestMessages_Proto3_TestAllTypesProto3: @unchecked Sendable { + // 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. + + /// Singular + /// test [kotlin] comment + var optionalInt32: Int32 { + get {_storage._optionalInt32} + set {_uniqueStorage()._optionalInt32 = newValue} + } + + var optionalInt64: Int64 { + get {_storage._optionalInt64} + set {_uniqueStorage()._optionalInt64 = newValue} + } + + var optionalUint32: UInt32 { + get {_storage._optionalUint32} + set {_uniqueStorage()._optionalUint32 = newValue} + } + + var optionalUint64: UInt64 { + get {_storage._optionalUint64} + set {_uniqueStorage()._optionalUint64 = newValue} + } + + var optionalSint32: Int32 { + get {_storage._optionalSint32} + set {_uniqueStorage()._optionalSint32 = newValue} + } + + var optionalSint64: Int64 { + get {_storage._optionalSint64} + set {_uniqueStorage()._optionalSint64 = newValue} + } + + var optionalFixed32: UInt32 { + get {_storage._optionalFixed32} + set {_uniqueStorage()._optionalFixed32 = newValue} + } + + var optionalFixed64: UInt64 { + get {_storage._optionalFixed64} + set {_uniqueStorage()._optionalFixed64 = newValue} + } + + var optionalSfixed32: Int32 { + get {_storage._optionalSfixed32} + set {_uniqueStorage()._optionalSfixed32 = newValue} + } + + var optionalSfixed64: Int64 { + get {_storage._optionalSfixed64} + set {_uniqueStorage()._optionalSfixed64 = newValue} + } + + var optionalFloat: Float { + get {_storage._optionalFloat} + set {_uniqueStorage()._optionalFloat = newValue} + } + + var optionalDouble: Double { + get {_storage._optionalDouble} + set {_uniqueStorage()._optionalDouble = newValue} + } + + var optionalBool: Bool { + get {_storage._optionalBool} + set {_uniqueStorage()._optionalBool = newValue} + } + + var optionalString: String { + get {_storage._optionalString} + set {_uniqueStorage()._optionalString = newValue} + } + + var optionalBytes: Data { + get {_storage._optionalBytes} + set {_uniqueStorage()._optionalBytes = newValue} + } + + var optionalNestedMessage: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage { + get {_storage._optionalNestedMessage ?? ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage()} + set {_uniqueStorage()._optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} + + var optionalForeignMessage: ProtobufTestMessages_Proto3_ForeignMessage { + get {_storage._optionalForeignMessage ?? ProtobufTestMessages_Proto3_ForeignMessage()} + set {_uniqueStorage()._optionalForeignMessage = newValue} + } + /// Returns true if `optionalForeignMessage` has been explicitly set. + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} + /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} + + var optionalNestedEnum: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum { + get {_storage._optionalNestedEnum} + set {_uniqueStorage()._optionalNestedEnum = newValue} + } + + var optionalForeignEnum: ProtobufTestMessages_Proto3_ForeignEnum { + get {_storage._optionalForeignEnum} + set {_uniqueStorage()._optionalForeignEnum = newValue} + } + + var optionalAliasedEnum: ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum { + get {_storage._optionalAliasedEnum} + set {_uniqueStorage()._optionalAliasedEnum = newValue} + } + + var optionalStringPiece: String { + get {_storage._optionalStringPiece} + set {_uniqueStorage()._optionalStringPiece = newValue} + } + + var optionalCord: String { + get {_storage._optionalCord} + set {_uniqueStorage()._optionalCord = newValue} + } + + var recursiveMessage: ProtobufTestMessages_Proto3_TestAllTypesProto3 { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Proto3_TestAllTypesProto3()} + set {_uniqueStorage()._recursiveMessage = newValue} + } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} + + /// Repeated + var repeatedInt32: [Int32] { + get {_storage._repeatedInt32} + set {_uniqueStorage()._repeatedInt32 = newValue} + } + + var repeatedInt64: [Int64] { + get {_storage._repeatedInt64} + set {_uniqueStorage()._repeatedInt64 = newValue} + } + + var repeatedUint32: [UInt32] { + get {_storage._repeatedUint32} + set {_uniqueStorage()._repeatedUint32 = newValue} + } + + var repeatedUint64: [UInt64] { + get {_storage._repeatedUint64} + set {_uniqueStorage()._repeatedUint64 = newValue} + } + + var repeatedSint32: [Int32] { + get {_storage._repeatedSint32} + set {_uniqueStorage()._repeatedSint32 = newValue} + } + + var repeatedSint64: [Int64] { + get {_storage._repeatedSint64} + set {_uniqueStorage()._repeatedSint64 = newValue} + } + + var repeatedFixed32: [UInt32] { + get {_storage._repeatedFixed32} + set {_uniqueStorage()._repeatedFixed32 = newValue} + } + + var repeatedFixed64: [UInt64] { + get {_storage._repeatedFixed64} + set {_uniqueStorage()._repeatedFixed64 = newValue} + } + + var repeatedSfixed32: [Int32] { + get {_storage._repeatedSfixed32} + set {_uniqueStorage()._repeatedSfixed32 = newValue} + } + + var repeatedSfixed64: [Int64] { + get {_storage._repeatedSfixed64} + set {_uniqueStorage()._repeatedSfixed64 = newValue} + } + + var repeatedFloat: [Float] { + get {_storage._repeatedFloat} + set {_uniqueStorage()._repeatedFloat = newValue} + } + + var repeatedDouble: [Double] { + get {_storage._repeatedDouble} + set {_uniqueStorage()._repeatedDouble = newValue} + } + + var repeatedBool: [Bool] { + get {_storage._repeatedBool} + set {_uniqueStorage()._repeatedBool = newValue} + } + + var repeatedString: [String] { + get {_storage._repeatedString} + set {_uniqueStorage()._repeatedString = newValue} + } + + var repeatedBytes: [Data] { + get {_storage._repeatedBytes} + set {_uniqueStorage()._repeatedBytes = newValue} + } + + var repeatedNestedMessage: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage] { + get {_storage._repeatedNestedMessage} + set {_uniqueStorage()._repeatedNestedMessage = newValue} + } + + var repeatedForeignMessage: [ProtobufTestMessages_Proto3_ForeignMessage] { + get {_storage._repeatedForeignMessage} + set {_uniqueStorage()._repeatedForeignMessage = newValue} + } + + var repeatedNestedEnum: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] { + get {_storage._repeatedNestedEnum} + set {_uniqueStorage()._repeatedNestedEnum = newValue} + } + + var repeatedForeignEnum: [ProtobufTestMessages_Proto3_ForeignEnum] { + get {_storage._repeatedForeignEnum} + set {_uniqueStorage()._repeatedForeignEnum = newValue} + } + + var repeatedStringPiece: [String] { + get {_storage._repeatedStringPiece} + set {_uniqueStorage()._repeatedStringPiece = newValue} + } + + var repeatedCord: [String] { + get {_storage._repeatedCord} + set {_uniqueStorage()._repeatedCord = newValue} + } + + /// Packed + var packedInt32: [Int32] { + get {_storage._packedInt32} + set {_uniqueStorage()._packedInt32 = newValue} + } + + var packedInt64: [Int64] { + get {_storage._packedInt64} + set {_uniqueStorage()._packedInt64 = newValue} + } + + var packedUint32: [UInt32] { + get {_storage._packedUint32} + set {_uniqueStorage()._packedUint32 = newValue} + } + + var packedUint64: [UInt64] { + get {_storage._packedUint64} + set {_uniqueStorage()._packedUint64 = newValue} + } + + var packedSint32: [Int32] { + get {_storage._packedSint32} + set {_uniqueStorage()._packedSint32 = newValue} + } + + var packedSint64: [Int64] { + get {_storage._packedSint64} + set {_uniqueStorage()._packedSint64 = newValue} + } + + var packedFixed32: [UInt32] { + get {_storage._packedFixed32} + set {_uniqueStorage()._packedFixed32 = newValue} + } + + var packedFixed64: [UInt64] { + get {_storage._packedFixed64} + set {_uniqueStorage()._packedFixed64 = newValue} + } + + var packedSfixed32: [Int32] { + get {_storage._packedSfixed32} + set {_uniqueStorage()._packedSfixed32 = newValue} + } + + var packedSfixed64: [Int64] { + get {_storage._packedSfixed64} + set {_uniqueStorage()._packedSfixed64 = newValue} + } + + var packedFloat: [Float] { + get {_storage._packedFloat} + set {_uniqueStorage()._packedFloat = newValue} + } + + var packedDouble: [Double] { + get {_storage._packedDouble} + set {_uniqueStorage()._packedDouble = newValue} + } + + var packedBool: [Bool] { + get {_storage._packedBool} + set {_uniqueStorage()._packedBool = newValue} + } + + var packedNestedEnum: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] { + get {_storage._packedNestedEnum} + set {_uniqueStorage()._packedNestedEnum = newValue} + } + + /// Unpacked + var unpackedInt32: [Int32] { + get {_storage._unpackedInt32} + set {_uniqueStorage()._unpackedInt32 = newValue} + } + + var unpackedInt64: [Int64] { + get {_storage._unpackedInt64} + set {_uniqueStorage()._unpackedInt64 = newValue} + } + + var unpackedUint32: [UInt32] { + get {_storage._unpackedUint32} + set {_uniqueStorage()._unpackedUint32 = newValue} + } + + var unpackedUint64: [UInt64] { + get {_storage._unpackedUint64} + set {_uniqueStorage()._unpackedUint64 = newValue} + } + + var unpackedSint32: [Int32] { + get {_storage._unpackedSint32} + set {_uniqueStorage()._unpackedSint32 = newValue} + } + + var unpackedSint64: [Int64] { + get {_storage._unpackedSint64} + set {_uniqueStorage()._unpackedSint64 = newValue} + } + + var unpackedFixed32: [UInt32] { + get {_storage._unpackedFixed32} + set {_uniqueStorage()._unpackedFixed32 = newValue} + } + + var unpackedFixed64: [UInt64] { + get {_storage._unpackedFixed64} + set {_uniqueStorage()._unpackedFixed64 = newValue} + } + + var unpackedSfixed32: [Int32] { + get {_storage._unpackedSfixed32} + set {_uniqueStorage()._unpackedSfixed32 = newValue} + } + + var unpackedSfixed64: [Int64] { + get {_storage._unpackedSfixed64} + set {_uniqueStorage()._unpackedSfixed64 = newValue} + } + + var unpackedFloat: [Float] { + get {_storage._unpackedFloat} + set {_uniqueStorage()._unpackedFloat = newValue} + } + + var unpackedDouble: [Double] { + get {_storage._unpackedDouble} + set {_uniqueStorage()._unpackedDouble = newValue} + } + + var unpackedBool: [Bool] { + get {_storage._unpackedBool} + set {_uniqueStorage()._unpackedBool = newValue} + } + + var unpackedNestedEnum: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] { + get {_storage._unpackedNestedEnum} + set {_uniqueStorage()._unpackedNestedEnum = newValue} + } + + /// Map + var mapInt32Int32: Dictionary { + get {_storage._mapInt32Int32} + set {_uniqueStorage()._mapInt32Int32 = newValue} + } + + var mapInt64Int64: Dictionary { + get {_storage._mapInt64Int64} + set {_uniqueStorage()._mapInt64Int64 = newValue} + } + + var mapUint32Uint32: Dictionary { + get {_storage._mapUint32Uint32} + set {_uniqueStorage()._mapUint32Uint32 = newValue} + } + + var mapUint64Uint64: Dictionary { + get {_storage._mapUint64Uint64} + set {_uniqueStorage()._mapUint64Uint64 = newValue} + } + + var mapSint32Sint32: Dictionary { + get {_storage._mapSint32Sint32} + set {_uniqueStorage()._mapSint32Sint32 = newValue} + } + + var mapSint64Sint64: Dictionary { + get {_storage._mapSint64Sint64} + set {_uniqueStorage()._mapSint64Sint64 = newValue} + } + + var mapFixed32Fixed32: Dictionary { + get {_storage._mapFixed32Fixed32} + set {_uniqueStorage()._mapFixed32Fixed32 = newValue} + } + + var mapFixed64Fixed64: Dictionary { + get {_storage._mapFixed64Fixed64} + set {_uniqueStorage()._mapFixed64Fixed64 = newValue} + } + + var mapSfixed32Sfixed32: Dictionary { + get {_storage._mapSfixed32Sfixed32} + set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} + } + + var mapSfixed64Sfixed64: Dictionary { + get {_storage._mapSfixed64Sfixed64} + set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} + } + + var mapInt32Float: Dictionary { + get {_storage._mapInt32Float} + set {_uniqueStorage()._mapInt32Float = newValue} + } + + var mapInt32Double: Dictionary { + get {_storage._mapInt32Double} + set {_uniqueStorage()._mapInt32Double = newValue} + } + + var mapBoolBool: Dictionary { + get {_storage._mapBoolBool} + set {_uniqueStorage()._mapBoolBool = newValue} + } + + var mapStringString: Dictionary { + get {_storage._mapStringString} + set {_uniqueStorage()._mapStringString = newValue} + } + + var mapStringBytes: Dictionary { + get {_storage._mapStringBytes} + set {_uniqueStorage()._mapStringBytes = newValue} + } + + var mapStringNestedMessage: Dictionary { + get {_storage._mapStringNestedMessage} + set {_uniqueStorage()._mapStringNestedMessage = newValue} + } + + var mapStringForeignMessage: Dictionary { + get {_storage._mapStringForeignMessage} + set {_uniqueStorage()._mapStringForeignMessage = newValue} + } + + var mapStringNestedEnum: Dictionary { + get {_storage._mapStringNestedEnum} + set {_uniqueStorage()._mapStringNestedEnum = newValue} + } + + var mapStringForeignEnum: Dictionary { + get {_storage._mapStringForeignEnum} + set {_uniqueStorage()._mapStringForeignEnum = newValue} + } + + var oneofField: OneOf_OneofField? { + get {return _storage._oneofField} + set {_uniqueStorage()._oneofField = newValue} + } + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} + } + + var oneofNestedMessage: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage { + get { + if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} + return ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = _storage._oneofField {return v} + return Data() + } + set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} + } + + var oneofBool: Bool { + get { + if case .oneofBool(let v)? = _storage._oneofField {return v} + return false + } + set {_uniqueStorage()._oneofField = .oneofBool(newValue)} + } + + var oneofUint64: UInt64 { + get { + if case .oneofUint64(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint64(newValue)} + } + + var oneofFloat: Float { + get { + if case .oneofFloat(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofFloat(newValue)} + } + + var oneofDouble: Double { + get { + if case .oneofDouble(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofDouble(newValue)} + } + + var oneofEnum: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum { + get { + if case .oneofEnum(let v)? = _storage._oneofField {return v} + return .foo + } + set {_uniqueStorage()._oneofField = .oneofEnum(newValue)} + } + + var oneofNullValue: SwiftProtobuf.Google_Protobuf_NullValue { + get { + if case .oneofNullValue(let v)? = _storage._oneofField {return v} + return .nullValue + } + set {_uniqueStorage()._oneofField = .oneofNullValue(newValue)} + } + + /// Well-known types + var optionalBoolWrapper: SwiftProtobuf.Google_Protobuf_BoolValue { + get {_storage._optionalBoolWrapper ?? SwiftProtobuf.Google_Protobuf_BoolValue()} + set {_uniqueStorage()._optionalBoolWrapper = newValue} + } + /// Returns true if `optionalBoolWrapper` has been explicitly set. + var hasOptionalBoolWrapper: Bool {_storage._optionalBoolWrapper != nil} + /// Clears the value of `optionalBoolWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalBoolWrapper() {_uniqueStorage()._optionalBoolWrapper = nil} + + var optionalInt32Wrapper: SwiftProtobuf.Google_Protobuf_Int32Value { + get {_storage._optionalInt32Wrapper ?? SwiftProtobuf.Google_Protobuf_Int32Value()} + set {_uniqueStorage()._optionalInt32Wrapper = newValue} + } + /// Returns true if `optionalInt32Wrapper` has been explicitly set. + var hasOptionalInt32Wrapper: Bool {_storage._optionalInt32Wrapper != nil} + /// Clears the value of `optionalInt32Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32Wrapper() {_uniqueStorage()._optionalInt32Wrapper = nil} + + var optionalInt64Wrapper: SwiftProtobuf.Google_Protobuf_Int64Value { + get {_storage._optionalInt64Wrapper ?? SwiftProtobuf.Google_Protobuf_Int64Value()} + set {_uniqueStorage()._optionalInt64Wrapper = newValue} + } + /// Returns true if `optionalInt64Wrapper` has been explicitly set. + var hasOptionalInt64Wrapper: Bool {_storage._optionalInt64Wrapper != nil} + /// Clears the value of `optionalInt64Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64Wrapper() {_uniqueStorage()._optionalInt64Wrapper = nil} + + var optionalUint32Wrapper: SwiftProtobuf.Google_Protobuf_UInt32Value { + get {_storage._optionalUint32Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} + set {_uniqueStorage()._optionalUint32Wrapper = newValue} + } + /// Returns true if `optionalUint32Wrapper` has been explicitly set. + var hasOptionalUint32Wrapper: Bool {_storage._optionalUint32Wrapper != nil} + /// Clears the value of `optionalUint32Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint32Wrapper() {_uniqueStorage()._optionalUint32Wrapper = nil} + + var optionalUint64Wrapper: SwiftProtobuf.Google_Protobuf_UInt64Value { + get {_storage._optionalUint64Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} + set {_uniqueStorage()._optionalUint64Wrapper = newValue} + } + /// Returns true if `optionalUint64Wrapper` has been explicitly set. + var hasOptionalUint64Wrapper: Bool {_storage._optionalUint64Wrapper != nil} + /// Clears the value of `optionalUint64Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint64Wrapper() {_uniqueStorage()._optionalUint64Wrapper = nil} + + var optionalFloatWrapper: SwiftProtobuf.Google_Protobuf_FloatValue { + get {_storage._optionalFloatWrapper ?? SwiftProtobuf.Google_Protobuf_FloatValue()} + set {_uniqueStorage()._optionalFloatWrapper = newValue} + } + /// Returns true if `optionalFloatWrapper` has been explicitly set. + var hasOptionalFloatWrapper: Bool {_storage._optionalFloatWrapper != nil} + /// Clears the value of `optionalFloatWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloatWrapper() {_uniqueStorage()._optionalFloatWrapper = nil} + + var optionalDoubleWrapper: SwiftProtobuf.Google_Protobuf_DoubleValue { + get {_storage._optionalDoubleWrapper ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} + set {_uniqueStorage()._optionalDoubleWrapper = newValue} + } + /// Returns true if `optionalDoubleWrapper` has been explicitly set. + var hasOptionalDoubleWrapper: Bool {_storage._optionalDoubleWrapper != nil} + /// Clears the value of `optionalDoubleWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalDoubleWrapper() {_uniqueStorage()._optionalDoubleWrapper = nil} + + var optionalStringWrapper: SwiftProtobuf.Google_Protobuf_StringValue { + get {_storage._optionalStringWrapper ?? SwiftProtobuf.Google_Protobuf_StringValue()} + set {_uniqueStorage()._optionalStringWrapper = newValue} + } + /// Returns true if `optionalStringWrapper` has been explicitly set. + var hasOptionalStringWrapper: Bool {_storage._optionalStringWrapper != nil} + /// Clears the value of `optionalStringWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringWrapper() {_uniqueStorage()._optionalStringWrapper = nil} + + var optionalBytesWrapper: SwiftProtobuf.Google_Protobuf_BytesValue { + get {_storage._optionalBytesWrapper ?? SwiftProtobuf.Google_Protobuf_BytesValue()} + set {_uniqueStorage()._optionalBytesWrapper = newValue} + } + /// Returns true if `optionalBytesWrapper` has been explicitly set. + var hasOptionalBytesWrapper: Bool {_storage._optionalBytesWrapper != nil} + /// Clears the value of `optionalBytesWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytesWrapper() {_uniqueStorage()._optionalBytesWrapper = nil} + + var repeatedBoolWrapper: [SwiftProtobuf.Google_Protobuf_BoolValue] { + get {_storage._repeatedBoolWrapper} + set {_uniqueStorage()._repeatedBoolWrapper = newValue} + } + + var repeatedInt32Wrapper: [SwiftProtobuf.Google_Protobuf_Int32Value] { + get {_storage._repeatedInt32Wrapper} + set {_uniqueStorage()._repeatedInt32Wrapper = newValue} + } + + var repeatedInt64Wrapper: [SwiftProtobuf.Google_Protobuf_Int64Value] { + get {_storage._repeatedInt64Wrapper} + set {_uniqueStorage()._repeatedInt64Wrapper = newValue} + } + + var repeatedUint32Wrapper: [SwiftProtobuf.Google_Protobuf_UInt32Value] { + get {_storage._repeatedUint32Wrapper} + set {_uniqueStorage()._repeatedUint32Wrapper = newValue} + } + + var repeatedUint64Wrapper: [SwiftProtobuf.Google_Protobuf_UInt64Value] { + get {_storage._repeatedUint64Wrapper} + set {_uniqueStorage()._repeatedUint64Wrapper = newValue} + } + + var repeatedFloatWrapper: [SwiftProtobuf.Google_Protobuf_FloatValue] { + get {_storage._repeatedFloatWrapper} + set {_uniqueStorage()._repeatedFloatWrapper = newValue} + } + + var repeatedDoubleWrapper: [SwiftProtobuf.Google_Protobuf_DoubleValue] { + get {_storage._repeatedDoubleWrapper} + set {_uniqueStorage()._repeatedDoubleWrapper = newValue} + } + + var repeatedStringWrapper: [SwiftProtobuf.Google_Protobuf_StringValue] { + get {_storage._repeatedStringWrapper} + set {_uniqueStorage()._repeatedStringWrapper = newValue} + } + + var repeatedBytesWrapper: [SwiftProtobuf.Google_Protobuf_BytesValue] { + get {_storage._repeatedBytesWrapper} + set {_uniqueStorage()._repeatedBytesWrapper = newValue} + } + + var optionalDuration: SwiftProtobuf.Google_Protobuf_Duration { + get {_storage._optionalDuration ?? SwiftProtobuf.Google_Protobuf_Duration()} + set {_uniqueStorage()._optionalDuration = newValue} + } + /// Returns true if `optionalDuration` has been explicitly set. + var hasOptionalDuration: Bool {_storage._optionalDuration != nil} + /// Clears the value of `optionalDuration`. Subsequent reads from it will return its default value. + mutating func clearOptionalDuration() {_uniqueStorage()._optionalDuration = nil} + + var optionalTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp { + get {_storage._optionalTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()} + set {_uniqueStorage()._optionalTimestamp = newValue} + } + /// Returns true if `optionalTimestamp` has been explicitly set. + var hasOptionalTimestamp: Bool {_storage._optionalTimestamp != nil} + /// Clears the value of `optionalTimestamp`. Subsequent reads from it will return its default value. + mutating func clearOptionalTimestamp() {_uniqueStorage()._optionalTimestamp = nil} + + var optionalFieldMask: SwiftProtobuf.Google_Protobuf_FieldMask { + get {_storage._optionalFieldMask ?? SwiftProtobuf.Google_Protobuf_FieldMask()} + set {_uniqueStorage()._optionalFieldMask = newValue} + } + /// Returns true if `optionalFieldMask` has been explicitly set. + var hasOptionalFieldMask: Bool {_storage._optionalFieldMask != nil} + /// Clears the value of `optionalFieldMask`. Subsequent reads from it will return its default value. + mutating func clearOptionalFieldMask() {_uniqueStorage()._optionalFieldMask = nil} + + var optionalStruct: SwiftProtobuf.Google_Protobuf_Struct { + get {_storage._optionalStruct ?? SwiftProtobuf.Google_Protobuf_Struct()} + set {_uniqueStorage()._optionalStruct = newValue} + } + /// Returns true if `optionalStruct` has been explicitly set. + var hasOptionalStruct: Bool {_storage._optionalStruct != nil} + /// Clears the value of `optionalStruct`. Subsequent reads from it will return its default value. + mutating func clearOptionalStruct() {_uniqueStorage()._optionalStruct = nil} + + var optionalAny: SwiftProtobuf.Google_Protobuf_Any { + get {_storage._optionalAny ?? SwiftProtobuf.Google_Protobuf_Any()} + set {_uniqueStorage()._optionalAny = newValue} + } + /// Returns true if `optionalAny` has been explicitly set. + var hasOptionalAny: Bool {_storage._optionalAny != nil} + /// Clears the value of `optionalAny`. Subsequent reads from it will return its default value. + mutating func clearOptionalAny() {_uniqueStorage()._optionalAny = nil} + + var optionalValue: SwiftProtobuf.Google_Protobuf_Value { + get {_storage._optionalValue ?? SwiftProtobuf.Google_Protobuf_Value()} + set {_uniqueStorage()._optionalValue = newValue} + } + /// Returns true if `optionalValue` has been explicitly set. + var hasOptionalValue: Bool {_storage._optionalValue != nil} + /// Clears the value of `optionalValue`. Subsequent reads from it will return its default value. + mutating func clearOptionalValue() {_uniqueStorage()._optionalValue = nil} + + var optionalNullValue: SwiftProtobuf.Google_Protobuf_NullValue { + get {_storage._optionalNullValue} + set {_uniqueStorage()._optionalNullValue = newValue} + } + + var repeatedDuration: [SwiftProtobuf.Google_Protobuf_Duration] { + get {_storage._repeatedDuration} + set {_uniqueStorage()._repeatedDuration = newValue} + } + + var repeatedTimestamp: [SwiftProtobuf.Google_Protobuf_Timestamp] { + get {_storage._repeatedTimestamp} + set {_uniqueStorage()._repeatedTimestamp = newValue} + } + + var repeatedFieldmask: [SwiftProtobuf.Google_Protobuf_FieldMask] { + get {_storage._repeatedFieldmask} + set {_uniqueStorage()._repeatedFieldmask = newValue} + } + + var repeatedStruct: [SwiftProtobuf.Google_Protobuf_Struct] { + get {_storage._repeatedStruct} + set {_uniqueStorage()._repeatedStruct = newValue} + } + + var repeatedAny: [SwiftProtobuf.Google_Protobuf_Any] { + get {_storage._repeatedAny} + set {_uniqueStorage()._repeatedAny = newValue} + } + + var repeatedValue: [SwiftProtobuf.Google_Protobuf_Value] { + get {_storage._repeatedValue} + set {_uniqueStorage()._repeatedValue = newValue} + } + + var repeatedListValue: [SwiftProtobuf.Google_Protobuf_ListValue] { + get {_storage._repeatedListValue} + set {_uniqueStorage()._repeatedListValue = newValue} + } + + /// Test field-name-to-JSON-name convention. + /// (protobuf says names can be any valid C/C++ identifier.) + var fieldname1: Int32 { + get {_storage._fieldname1} + set {_uniqueStorage()._fieldname1 = newValue} + } + + var fieldName2: Int32 { + get {_storage._fieldName2} + set {_uniqueStorage()._fieldName2 = newValue} + } + + var fieldName3: Int32 { + get {_storage._fieldName3} + set {_uniqueStorage()._fieldName3 = newValue} + } + + var field_Name4_: Int32 { + get {_storage._field_Name4_} + set {_uniqueStorage()._field_Name4_ = newValue} + } + + var field0Name5: Int32 { + get {_storage._field0Name5} + set {_uniqueStorage()._field0Name5 = newValue} + } + + var field0Name6: Int32 { + get {_storage._field0Name6} + set {_uniqueStorage()._field0Name6 = newValue} + } + + var fieldName7: Int32 { + get {_storage._fieldName7} + set {_uniqueStorage()._fieldName7 = newValue} + } + + var fieldName8: Int32 { + get {_storage._fieldName8} + set {_uniqueStorage()._fieldName8 = newValue} + } + + var fieldName9: Int32 { + get {_storage._fieldName9} + set {_uniqueStorage()._fieldName9 = newValue} + } + + var fieldName10: Int32 { + get {_storage._fieldName10} + set {_uniqueStorage()._fieldName10 = newValue} + } + + var fieldName11: Int32 { + get {_storage._fieldName11} + set {_uniqueStorage()._fieldName11 = newValue} + } + + var fieldName12: Int32 { + get {_storage._fieldName12} + set {_uniqueStorage()._fieldName12 = newValue} + } + + var _FieldName13: Int32 { + get {_storage.__FieldName13} + set {_uniqueStorage().__FieldName13 = newValue} + } + + var _FieldName14: Int32 { + get {_storage.__FieldName14} + set {_uniqueStorage().__FieldName14 = newValue} + } + + var field_Name15: Int32 { + get {_storage._field_Name15} + set {_uniqueStorage()._field_Name15 = newValue} + } + + var field_Name16: Int32 { + get {_storage._field_Name16} + set {_uniqueStorage()._field_Name16 = newValue} + } + + var fieldName17__: Int32 { + get {_storage._fieldName17__} + set {_uniqueStorage()._fieldName17__ = newValue} + } + + var fieldName18__: Int32 { + get {_storage._fieldName18__} + set {_uniqueStorage()._fieldName18__ = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofNestedMessage(ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage) + case oneofString(String) + case oneofBytes(Data) + case oneofBool(Bool) + case oneofUint64(UInt64) + case oneofFloat(Float) + case oneofDouble(Double) + case oneofEnum(ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum) + case oneofNullValue(SwiftProtobuf.Google_Protobuf_NullValue) + + } + + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foo // = 0 + case bar // = 1 + case baz // = 2 + + /// Intentionally negative. + case neg // = -1 + case UNRECOGNIZED(Int) + + init() { + self = .foo + } + + init?(rawValue: Int) { + switch rawValue { + case -1: self = .neg + case 0: self = .foo + case 1: self = .bar + case 2: self = .baz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .neg: return -1 + case .foo: return 0 + case .bar: return 1 + case .baz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] = [ + .foo, + .bar, + .baz, + .neg, + ] + + } + + enum AliasedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case aliasFoo // = 0 + case aliasBar // = 1 + case aliasBaz // = 2 + static let moo = aliasBaz + static let bAz = aliasBaz + case UNRECOGNIZED(Int) + + init() { + self = .aliasFoo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .aliasFoo + case 1: self = .aliasBar + case 2: self = .aliasBaz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .aliasFoo: return 0 + case .aliasBar: return 1 + case .aliasBaz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum] = [ + .aliasFoo, + .aliasBar, + .aliasBaz, + ] + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a} + set {_uniqueStorage()._a = newValue} + } + + var corecursive: ProtobufTestMessages_Proto3_TestAllTypesProto3 { + get {_storage._corecursive ?? ProtobufTestMessages_Proto3_TestAllTypesProto3()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct ProtobufTestMessages_Proto3_ForeignMessage: Sendable { + // 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 c: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct ProtobufTestMessages_Proto3_NullHypothesisProto3: Sendable { + // 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 ProtobufTestMessages_Proto3_EnumOnlyProto3: Sendable { + // 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() + + enum BoolEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case kFalse // = 0 + case kTrue // = 1 + case UNRECOGNIZED(Int) + + init() { + self = .kFalse + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .kFalse + case 1: self = .kTrue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .kFalse: return 0 + case .kTrue: return 1 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Proto3_EnumOnlyProto3.BoolEnum] = [ + .kFalse, + .kTrue, + ] + + } + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "protobuf_test_messages.proto3" + +extension ProtobufTestMessages_Proto3_ForeignEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") +} + +extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypesProto3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{4}\u{2}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{3}optional_aliased_enum\0\u{3}optional_string_piece\0\u{3}optional_cord\0\u{4}\u{2}recursive_message\0\u{4}\u{4}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{4}\u{2}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_nested_message\0\u{3}map_string_foreign_message\0\u{3}map_string_nested_enum\0\u{3}map_string_foreign_enum\0\u{3}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_nested_enum\0\u{3}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_nested_enum\0\u{4}\u{9}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_bool\0\u{3}oneof_uint64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_enum\0\u{3}oneof_null_value\0\u{4}Q\u{1}optional_bool_wrapper\0\u{3}optional_int32_wrapper\0\u{3}optional_int64_wrapper\0\u{3}optional_uint32_wrapper\0\u{3}optional_uint64_wrapper\0\u{3}optional_float_wrapper\0\u{3}optional_double_wrapper\0\u{3}optional_string_wrapper\0\u{3}optional_bytes_wrapper\0\u{4}\u{2}repeated_bool_wrapper\0\u{3}repeated_int32_wrapper\0\u{3}repeated_int64_wrapper\0\u{3}repeated_uint32_wrapper\0\u{3}repeated_uint64_wrapper\0\u{3}repeated_float_wrapper\0\u{3}repeated_double_wrapper\0\u{3}repeated_string_wrapper\0\u{3}repeated_bytes_wrapper\0\u{4}R\u{1}optional_duration\0\u{3}optional_timestamp\0\u{3}optional_field_mask\0\u{3}optional_struct\0\u{3}optional_any\0\u{3}optional_value\0\u{3}optional_null_value\0\u{4}\u{4}repeated_duration\0\u{3}repeated_timestamp\0\u{3}repeated_fieldmask\0\u{4}\u{2}repeated_any\0\u{3}repeated_value\0\u{3}repeated_list_value\0\u{4}\u{7}repeated_struct\0\u{2}M\u{1}fieldname1\0\u{3}field_name2\0\u{3}_field_name3\0\u{3}field__name4_\0\u{1}field0name5\0\u{3}field_0_name6\0\u{1}fieldName7\0\u{1}FieldName8\0\u{3}field_Name9\0\u{3}Field_Name10\0\u{3}FIELD_NAME11\0\u{3}FIELD_name12\0\u{3}__field_name13\0\u{3}__Field_name14\0\u{3}field__name15\0\u{3}field__Name16\0\u{3}field_name17__\0\u{3}Field_name18__\0\u{b}reserved_field\0\u{c}u\u{7}\u{a}\u{c}\u{7f}Ht\u{3}\u{1}") + + fileprivate class _StorageClass { + var _optionalInt32: Int32 = 0 + var _optionalInt64: Int64 = 0 + var _optionalUint32: UInt32 = 0 + var _optionalUint64: UInt64 = 0 + var _optionalSint32: Int32 = 0 + var _optionalSint64: Int64 = 0 + var _optionalFixed32: UInt32 = 0 + var _optionalFixed64: UInt64 = 0 + var _optionalSfixed32: Int32 = 0 + var _optionalSfixed64: Int64 = 0 + var _optionalFloat: Float = 0 + var _optionalDouble: Double = 0 + var _optionalBool: Bool = false + var _optionalString: String = String() + var _optionalBytes: Data = Data() + var _optionalNestedMessage: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage? = nil + var _optionalForeignMessage: ProtobufTestMessages_Proto3_ForeignMessage? = nil + var _optionalNestedEnum: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum = .foo + var _optionalForeignEnum: ProtobufTestMessages_Proto3_ForeignEnum = .foreignFoo + var _optionalAliasedEnum: ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum = .aliasFoo + var _optionalStringPiece: String = String() + var _optionalCord: String = String() + var _recursiveMessage: ProtobufTestMessages_Proto3_TestAllTypesProto3? = nil + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedNestedMessage: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage] = [] + var _repeatedForeignMessage: [ProtobufTestMessages_Proto3_ForeignMessage] = [] + var _repeatedNestedEnum: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] = [] + var _repeatedForeignEnum: [ProtobufTestMessages_Proto3_ForeignEnum] = [] + var _repeatedStringPiece: [String] = [] + var _repeatedCord: [String] = [] + var _packedInt32: [Int32] = [] + var _packedInt64: [Int64] = [] + var _packedUint32: [UInt32] = [] + var _packedUint64: [UInt64] = [] + var _packedSint32: [Int32] = [] + var _packedSint64: [Int64] = [] + var _packedFixed32: [UInt32] = [] + var _packedFixed64: [UInt64] = [] + var _packedSfixed32: [Int32] = [] + var _packedSfixed64: [Int64] = [] + var _packedFloat: [Float] = [] + var _packedDouble: [Double] = [] + var _packedBool: [Bool] = [] + var _packedNestedEnum: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] = [] + var _unpackedInt32: [Int32] = [] + var _unpackedInt64: [Int64] = [] + var _unpackedUint32: [UInt32] = [] + var _unpackedUint64: [UInt64] = [] + var _unpackedSint32: [Int32] = [] + var _unpackedSint64: [Int64] = [] + var _unpackedFixed32: [UInt32] = [] + var _unpackedFixed64: [UInt64] = [] + var _unpackedSfixed32: [Int32] = [] + var _unpackedSfixed64: [Int64] = [] + var _unpackedFloat: [Float] = [] + var _unpackedDouble: [Double] = [] + var _unpackedBool: [Bool] = [] + var _unpackedNestedEnum: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] = [] + var _mapInt32Int32: Dictionary = [:] + var _mapInt64Int64: Dictionary = [:] + var _mapUint32Uint32: Dictionary = [:] + var _mapUint64Uint64: Dictionary = [:] + var _mapSint32Sint32: Dictionary = [:] + var _mapSint64Sint64: Dictionary = [:] + var _mapFixed32Fixed32: Dictionary = [:] + var _mapFixed64Fixed64: Dictionary = [:] + var _mapSfixed32Sfixed32: Dictionary = [:] + var _mapSfixed64Sfixed64: Dictionary = [:] + var _mapInt32Float: Dictionary = [:] + var _mapInt32Double: Dictionary = [:] + var _mapBoolBool: Dictionary = [:] + var _mapStringString: Dictionary = [:] + var _mapStringBytes: Dictionary = [:] + var _mapStringNestedMessage: Dictionary = [:] + var _mapStringForeignMessage: Dictionary = [:] + var _mapStringNestedEnum: Dictionary = [:] + var _mapStringForeignEnum: Dictionary = [:] + var _oneofField: ProtobufTestMessages_Proto3_TestAllTypesProto3.OneOf_OneofField? + var _optionalBoolWrapper: SwiftProtobuf.Google_Protobuf_BoolValue? = nil + var _optionalInt32Wrapper: SwiftProtobuf.Google_Protobuf_Int32Value? = nil + var _optionalInt64Wrapper: SwiftProtobuf.Google_Protobuf_Int64Value? = nil + var _optionalUint32Wrapper: SwiftProtobuf.Google_Protobuf_UInt32Value? = nil + var _optionalUint64Wrapper: SwiftProtobuf.Google_Protobuf_UInt64Value? = nil + var _optionalFloatWrapper: SwiftProtobuf.Google_Protobuf_FloatValue? = nil + var _optionalDoubleWrapper: SwiftProtobuf.Google_Protobuf_DoubleValue? = nil + var _optionalStringWrapper: SwiftProtobuf.Google_Protobuf_StringValue? = nil + var _optionalBytesWrapper: SwiftProtobuf.Google_Protobuf_BytesValue? = nil + var _repeatedBoolWrapper: [SwiftProtobuf.Google_Protobuf_BoolValue] = [] + var _repeatedInt32Wrapper: [SwiftProtobuf.Google_Protobuf_Int32Value] = [] + var _repeatedInt64Wrapper: [SwiftProtobuf.Google_Protobuf_Int64Value] = [] + var _repeatedUint32Wrapper: [SwiftProtobuf.Google_Protobuf_UInt32Value] = [] + var _repeatedUint64Wrapper: [SwiftProtobuf.Google_Protobuf_UInt64Value] = [] + var _repeatedFloatWrapper: [SwiftProtobuf.Google_Protobuf_FloatValue] = [] + var _repeatedDoubleWrapper: [SwiftProtobuf.Google_Protobuf_DoubleValue] = [] + var _repeatedStringWrapper: [SwiftProtobuf.Google_Protobuf_StringValue] = [] + var _repeatedBytesWrapper: [SwiftProtobuf.Google_Protobuf_BytesValue] = [] + var _optionalDuration: SwiftProtobuf.Google_Protobuf_Duration? = nil + var _optionalTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp? = nil + var _optionalFieldMask: SwiftProtobuf.Google_Protobuf_FieldMask? = nil + var _optionalStruct: SwiftProtobuf.Google_Protobuf_Struct? = nil + var _optionalAny: SwiftProtobuf.Google_Protobuf_Any? = nil + var _optionalValue: SwiftProtobuf.Google_Protobuf_Value? = nil + var _optionalNullValue: SwiftProtobuf.Google_Protobuf_NullValue = .nullValue + var _repeatedDuration: [SwiftProtobuf.Google_Protobuf_Duration] = [] + var _repeatedTimestamp: [SwiftProtobuf.Google_Protobuf_Timestamp] = [] + var _repeatedFieldmask: [SwiftProtobuf.Google_Protobuf_FieldMask] = [] + var _repeatedStruct: [SwiftProtobuf.Google_Protobuf_Struct] = [] + var _repeatedAny: [SwiftProtobuf.Google_Protobuf_Any] = [] + var _repeatedValue: [SwiftProtobuf.Google_Protobuf_Value] = [] + var _repeatedListValue: [SwiftProtobuf.Google_Protobuf_ListValue] = [] + var _fieldname1: Int32 = 0 + var _fieldName2: Int32 = 0 + var _fieldName3: Int32 = 0 + var _field_Name4_: Int32 = 0 + var _field0Name5: Int32 = 0 + var _field0Name6: Int32 = 0 + var _fieldName7: Int32 = 0 + var _fieldName8: Int32 = 0 + var _fieldName9: Int32 = 0 + var _fieldName10: Int32 = 0 + var _fieldName11: Int32 = 0 + var _fieldName12: Int32 = 0 + var __FieldName13: Int32 = 0 + var __FieldName14: Int32 = 0 + var _field_Name15: Int32 = 0 + var _field_Name16: Int32 = 0 + var _fieldName17__: Int32 = 0 + var _fieldName18__: Int32 = 0 + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalNestedMessage = source._optionalNestedMessage + _optionalForeignMessage = source._optionalForeignMessage + _optionalNestedEnum = source._optionalNestedEnum + _optionalForeignEnum = source._optionalForeignEnum + _optionalAliasedEnum = source._optionalAliasedEnum + _optionalStringPiece = source._optionalStringPiece + _optionalCord = source._optionalCord + _recursiveMessage = source._recursiveMessage + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedForeignMessage = source._repeatedForeignMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _repeatedForeignEnum = source._repeatedForeignEnum + _repeatedStringPiece = source._repeatedStringPiece + _repeatedCord = source._repeatedCord + _packedInt32 = source._packedInt32 + _packedInt64 = source._packedInt64 + _packedUint32 = source._packedUint32 + _packedUint64 = source._packedUint64 + _packedSint32 = source._packedSint32 + _packedSint64 = source._packedSint64 + _packedFixed32 = source._packedFixed32 + _packedFixed64 = source._packedFixed64 + _packedSfixed32 = source._packedSfixed32 + _packedSfixed64 = source._packedSfixed64 + _packedFloat = source._packedFloat + _packedDouble = source._packedDouble + _packedBool = source._packedBool + _packedNestedEnum = source._packedNestedEnum + _unpackedInt32 = source._unpackedInt32 + _unpackedInt64 = source._unpackedInt64 + _unpackedUint32 = source._unpackedUint32 + _unpackedUint64 = source._unpackedUint64 + _unpackedSint32 = source._unpackedSint32 + _unpackedSint64 = source._unpackedSint64 + _unpackedFixed32 = source._unpackedFixed32 + _unpackedFixed64 = source._unpackedFixed64 + _unpackedSfixed32 = source._unpackedSfixed32 + _unpackedSfixed64 = source._unpackedSfixed64 + _unpackedFloat = source._unpackedFloat + _unpackedDouble = source._unpackedDouble + _unpackedBool = source._unpackedBool + _unpackedNestedEnum = source._unpackedNestedEnum + _mapInt32Int32 = source._mapInt32Int32 + _mapInt64Int64 = source._mapInt64Int64 + _mapUint32Uint32 = source._mapUint32Uint32 + _mapUint64Uint64 = source._mapUint64Uint64 + _mapSint32Sint32 = source._mapSint32Sint32 + _mapSint64Sint64 = source._mapSint64Sint64 + _mapFixed32Fixed32 = source._mapFixed32Fixed32 + _mapFixed64Fixed64 = source._mapFixed64Fixed64 + _mapSfixed32Sfixed32 = source._mapSfixed32Sfixed32 + _mapSfixed64Sfixed64 = source._mapSfixed64Sfixed64 + _mapInt32Float = source._mapInt32Float + _mapInt32Double = source._mapInt32Double + _mapBoolBool = source._mapBoolBool + _mapStringString = source._mapStringString + _mapStringBytes = source._mapStringBytes + _mapStringNestedMessage = source._mapStringNestedMessage + _mapStringForeignMessage = source._mapStringForeignMessage + _mapStringNestedEnum = source._mapStringNestedEnum + _mapStringForeignEnum = source._mapStringForeignEnum + _oneofField = source._oneofField + _optionalBoolWrapper = source._optionalBoolWrapper + _optionalInt32Wrapper = source._optionalInt32Wrapper + _optionalInt64Wrapper = source._optionalInt64Wrapper + _optionalUint32Wrapper = source._optionalUint32Wrapper + _optionalUint64Wrapper = source._optionalUint64Wrapper + _optionalFloatWrapper = source._optionalFloatWrapper + _optionalDoubleWrapper = source._optionalDoubleWrapper + _optionalStringWrapper = source._optionalStringWrapper + _optionalBytesWrapper = source._optionalBytesWrapper + _repeatedBoolWrapper = source._repeatedBoolWrapper + _repeatedInt32Wrapper = source._repeatedInt32Wrapper + _repeatedInt64Wrapper = source._repeatedInt64Wrapper + _repeatedUint32Wrapper = source._repeatedUint32Wrapper + _repeatedUint64Wrapper = source._repeatedUint64Wrapper + _repeatedFloatWrapper = source._repeatedFloatWrapper + _repeatedDoubleWrapper = source._repeatedDoubleWrapper + _repeatedStringWrapper = source._repeatedStringWrapper + _repeatedBytesWrapper = source._repeatedBytesWrapper + _optionalDuration = source._optionalDuration + _optionalTimestamp = source._optionalTimestamp + _optionalFieldMask = source._optionalFieldMask + _optionalStruct = source._optionalStruct + _optionalAny = source._optionalAny + _optionalValue = source._optionalValue + _optionalNullValue = source._optionalNullValue + _repeatedDuration = source._repeatedDuration + _repeatedTimestamp = source._repeatedTimestamp + _repeatedFieldmask = source._repeatedFieldmask + _repeatedStruct = source._repeatedStruct + _repeatedAny = source._repeatedAny + _repeatedValue = source._repeatedValue + _repeatedListValue = source._repeatedListValue + _fieldname1 = source._fieldname1 + _fieldName2 = source._fieldName2 + _fieldName3 = source._fieldName3 + _field_Name4_ = source._field_Name4_ + _field0Name5 = source._field0Name5 + _field0Name6 = source._field0Name6 + _fieldName7 = source._fieldName7 + _fieldName8 = source._fieldName8 + _fieldName9 = source._fieldName9 + _fieldName10 = source._fieldName10 + _fieldName11 = source._fieldName11 + _fieldName12 = source._fieldName12 + __FieldName13 = source.__FieldName13 + __FieldName14 = source.__FieldName14 + _field_Name15 = source._field_Name15 + _field_Name16 = source._field_Name16 + _fieldName17__ = source._fieldName17__ + _fieldName18__ = source._fieldName18__ + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() + case 23: try { try decoder.decodeSingularEnumField(value: &_storage._optionalAliasedEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() + case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() + case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() + case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() + case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() + case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() + case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() + case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() + case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() + case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() + case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() + case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() + case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() + case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() + case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() + case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() + case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() + case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() + case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() + case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() + case 56: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Int32) }() + case 57: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() + case 58: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() + case 59: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Uint64) }() + case 60: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Sint32) }() + case 61: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Sint64) }() + case 62: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Fixed32) }() + case 63: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Fixed64) }() + case 64: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Sfixed32) }() + case 65: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Sfixed64) }() + case 66: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Float) }() + case 67: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Double) }() + case 68: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() + case 69: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() + case 70: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() + case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringNestedMessage) }() + case 72: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() + case 73: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringNestedEnum) }() + case 74: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringForeignEnum) }() + case 75: try { try decoder.decodeRepeatedInt32Field(value: &_storage._packedInt32) }() + case 76: try { try decoder.decodeRepeatedInt64Field(value: &_storage._packedInt64) }() + case 77: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._packedUint32) }() + case 78: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._packedUint64) }() + case 79: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._packedSint32) }() + case 80: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._packedSint64) }() + case 81: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._packedFixed32) }() + case 82: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._packedFixed64) }() + case 83: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._packedSfixed32) }() + case 84: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._packedSfixed64) }() + case 85: try { try decoder.decodeRepeatedFloatField(value: &_storage._packedFloat) }() + case 86: try { try decoder.decodeRepeatedDoubleField(value: &_storage._packedDouble) }() + case 87: try { try decoder.decodeRepeatedBoolField(value: &_storage._packedBool) }() + case 88: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedNestedEnum) }() + case 89: try { try decoder.decodeRepeatedInt32Field(value: &_storage._unpackedInt32) }() + case 90: try { try decoder.decodeRepeatedInt64Field(value: &_storage._unpackedInt64) }() + case 91: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._unpackedUint32) }() + case 92: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._unpackedUint64) }() + case 93: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._unpackedSint32) }() + case 94: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._unpackedSint64) }() + case 95: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._unpackedFixed32) }() + case 96: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._unpackedFixed64) }() + case 97: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._unpackedSfixed32) }() + case 98: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._unpackedSfixed64) }() + case 99: try { try decoder.decodeRepeatedFloatField(value: &_storage._unpackedFloat) }() + case 100: try { try decoder.decodeRepeatedDoubleField(value: &_storage._unpackedDouble) }() + case 101: try { try decoder.decodeRepeatedBoolField(value: &_storage._unpackedBool) }() + case 102: try { try decoder.decodeRepeatedEnumField(value: &_storage._unpackedNestedEnum) }() + case 111: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 112: try { + var v: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage(v) + } + }() + case 113: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 114: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() + case 115: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBool(v) + } + }() + case 116: try { + var v: UInt64? + try decoder.decodeSingularUInt64Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint64(v) + } + }() + case 117: try { + var v: Float? + try decoder.decodeSingularFloatField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofFloat(v) + } + }() + case 118: try { + var v: Double? + try decoder.decodeSingularDoubleField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofDouble(v) + } + }() + case 119: try { + var v: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofEnum(v) + } + }() + case 120: try { + var v: SwiftProtobuf.Google_Protobuf_NullValue? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNullValue(v) + } + }() + case 201: try { try decoder.decodeSingularMessageField(value: &_storage._optionalBoolWrapper) }() + case 202: try { try decoder.decodeSingularMessageField(value: &_storage._optionalInt32Wrapper) }() + case 203: try { try decoder.decodeSingularMessageField(value: &_storage._optionalInt64Wrapper) }() + case 204: try { try decoder.decodeSingularMessageField(value: &_storage._optionalUint32Wrapper) }() + case 205: try { try decoder.decodeSingularMessageField(value: &_storage._optionalUint64Wrapper) }() + case 206: try { try decoder.decodeSingularMessageField(value: &_storage._optionalFloatWrapper) }() + case 207: try { try decoder.decodeSingularMessageField(value: &_storage._optionalDoubleWrapper) }() + case 208: try { try decoder.decodeSingularMessageField(value: &_storage._optionalStringWrapper) }() + case 209: try { try decoder.decodeSingularMessageField(value: &_storage._optionalBytesWrapper) }() + case 211: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedBoolWrapper) }() + case 212: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedInt32Wrapper) }() + case 213: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedInt64Wrapper) }() + case 214: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedUint32Wrapper) }() + case 215: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedUint64Wrapper) }() + case 216: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedFloatWrapper) }() + case 217: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedDoubleWrapper) }() + case 218: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedStringWrapper) }() + case 219: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedBytesWrapper) }() + case 301: try { try decoder.decodeSingularMessageField(value: &_storage._optionalDuration) }() + case 302: try { try decoder.decodeSingularMessageField(value: &_storage._optionalTimestamp) }() + case 303: try { try decoder.decodeSingularMessageField(value: &_storage._optionalFieldMask) }() + case 304: try { try decoder.decodeSingularMessageField(value: &_storage._optionalStruct) }() + case 305: try { try decoder.decodeSingularMessageField(value: &_storage._optionalAny) }() + case 306: try { try decoder.decodeSingularMessageField(value: &_storage._optionalValue) }() + case 307: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNullValue) }() + case 311: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedDuration) }() + case 312: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedTimestamp) }() + case 313: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedFieldmask) }() + case 315: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedAny) }() + case 316: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedValue) }() + case 317: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedListValue) }() + case 324: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedStruct) }() + case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldname1) }() + case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName2) }() + case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName3) }() + case 404: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name4_) }() + case 405: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name5) }() + case 406: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name6) }() + case 407: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName7) }() + case 408: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName8) }() + case 409: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName9) }() + case 410: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName10) }() + case 411: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName11) }() + case 412: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName12) }() + case 413: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName13) }() + case 414: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName14) }() + case 415: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name15) }() + case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name16) }() + case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName17__) }() + case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName18__) }() + default: break + } + } + } + } + + func traverse(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 + if _storage._optionalInt32 != 0 { + try visitor.visitSingularInt32Field(value: _storage._optionalInt32, fieldNumber: 1) + } + if _storage._optionalInt64 != 0 { + try visitor.visitSingularInt64Field(value: _storage._optionalInt64, fieldNumber: 2) + } + if _storage._optionalUint32 != 0 { + try visitor.visitSingularUInt32Field(value: _storage._optionalUint32, fieldNumber: 3) + } + if _storage._optionalUint64 != 0 { + try visitor.visitSingularUInt64Field(value: _storage._optionalUint64, fieldNumber: 4) + } + if _storage._optionalSint32 != 0 { + try visitor.visitSingularSInt32Field(value: _storage._optionalSint32, fieldNumber: 5) + } + if _storage._optionalSint64 != 0 { + try visitor.visitSingularSInt64Field(value: _storage._optionalSint64, fieldNumber: 6) + } + if _storage._optionalFixed32 != 0 { + try visitor.visitSingularFixed32Field(value: _storage._optionalFixed32, fieldNumber: 7) + } + if _storage._optionalFixed64 != 0 { + try visitor.visitSingularFixed64Field(value: _storage._optionalFixed64, fieldNumber: 8) + } + if _storage._optionalSfixed32 != 0 { + try visitor.visitSingularSFixed32Field(value: _storage._optionalSfixed32, fieldNumber: 9) + } + if _storage._optionalSfixed64 != 0 { + try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) + } + if _storage._optionalFloat.bitPattern != 0 { + try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) + } + if _storage._optionalDouble.bitPattern != 0 { + try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) + } + if _storage._optionalBool != false { + try visitor.visitSingularBoolField(value: _storage._optionalBool, fieldNumber: 13) + } + if !_storage._optionalString.isEmpty { + try visitor.visitSingularStringField(value: _storage._optionalString, fieldNumber: 14) + } + if !_storage._optionalBytes.isEmpty { + try visitor.visitSingularBytesField(value: _storage._optionalBytes, fieldNumber: 15) + } + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._optionalForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + if _storage._optionalNestedEnum != .foo { + try visitor.visitSingularEnumField(value: _storage._optionalNestedEnum, fieldNumber: 21) + } + if _storage._optionalForeignEnum != .foreignFoo { + try visitor.visitSingularEnumField(value: _storage._optionalForeignEnum, fieldNumber: 22) + } + if _storage._optionalAliasedEnum != .aliasFoo { + try visitor.visitSingularEnumField(value: _storage._optionalAliasedEnum, fieldNumber: 23) + } + if !_storage._optionalStringPiece.isEmpty { + try visitor.visitSingularStringField(value: _storage._optionalStringPiece, fieldNumber: 24) + } + if !_storage._optionalCord.isEmpty { + try visitor.visitSingularStringField(value: _storage._optionalCord, fieldNumber: 25) + } + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + if !_storage._repeatedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + } + if !_storage._repeatedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + } + if !_storage._repeatedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + } + if !_storage._repeatedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + } + if !_storage._repeatedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + } + if !_storage._repeatedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + } + if !_storage._repeatedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + } + if !_storage._repeatedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + } + if !_storage._repeatedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + } + if !_storage._repeatedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + } + if !_storage._repeatedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + } + if !_storage._repeatedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + } + if !_storage._repeatedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + } + if !_storage._repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) + } + if !_storage._repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) + } + if !_storage._repeatedNestedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) + } + if !_storage._repeatedForeignMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) + } + if !_storage._repeatedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + } + if !_storage._repeatedForeignEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) + } + if !_storage._repeatedStringPiece.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) + } + if !_storage._repeatedCord.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) + } + if !_storage._mapInt32Int32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Int32, fieldNumber: 56) + } + if !_storage._mapInt64Int64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Int64, fieldNumber: 57) + } + if !_storage._mapUint32Uint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Uint32, fieldNumber: 58) + } + if !_storage._mapUint64Uint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Uint64, fieldNumber: 59) + } + if !_storage._mapSint32Sint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Sint32, fieldNumber: 60) + } + if !_storage._mapSint64Sint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Sint64, fieldNumber: 61) + } + if !_storage._mapFixed32Fixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Fixed32, fieldNumber: 62) + } + if !_storage._mapFixed64Fixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Fixed64, fieldNumber: 63) + } + if !_storage._mapSfixed32Sfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 64) + } + if !_storage._mapSfixed64Sfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 65) + } + if !_storage._mapInt32Float.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Float, fieldNumber: 66) + } + if !_storage._mapInt32Double.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Double, fieldNumber: 67) + } + if !_storage._mapBoolBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolBool, fieldNumber: 68) + } + if !_storage._mapStringString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringString, fieldNumber: 69) + } + if !_storage._mapStringBytes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 70) + } + if !_storage._mapStringNestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringNestedMessage, fieldNumber: 71) + } + if !_storage._mapStringForeignMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 72) + } + if !_storage._mapStringNestedEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringNestedEnum, fieldNumber: 73) + } + if !_storage._mapStringForeignEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringForeignEnum, fieldNumber: 74) + } + if !_storage._packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._packedInt32, fieldNumber: 75) + } + if !_storage._packedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._packedInt64, fieldNumber: 76) + } + if !_storage._packedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._packedUint32, fieldNumber: 77) + } + if !_storage._packedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._packedUint64, fieldNumber: 78) + } + if !_storage._packedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._packedSint32, fieldNumber: 79) + } + if !_storage._packedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._packedSint64, fieldNumber: 80) + } + if !_storage._packedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._packedFixed32, fieldNumber: 81) + } + if !_storage._packedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._packedFixed64, fieldNumber: 82) + } + if !_storage._packedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._packedSfixed32, fieldNumber: 83) + } + if !_storage._packedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._packedSfixed64, fieldNumber: 84) + } + if !_storage._packedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._packedFloat, fieldNumber: 85) + } + if !_storage._packedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._packedDouble, fieldNumber: 86) + } + if !_storage._packedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._packedBool, fieldNumber: 87) + } + if !_storage._packedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedNestedEnum, fieldNumber: 88) + } + if !_storage._unpackedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._unpackedInt32, fieldNumber: 89) + } + if !_storage._unpackedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._unpackedInt64, fieldNumber: 90) + } + if !_storage._unpackedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._unpackedUint32, fieldNumber: 91) + } + if !_storage._unpackedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._unpackedUint64, fieldNumber: 92) + } + if !_storage._unpackedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._unpackedSint32, fieldNumber: 93) + } + if !_storage._unpackedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._unpackedSint64, fieldNumber: 94) + } + if !_storage._unpackedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._unpackedFixed32, fieldNumber: 95) + } + if !_storage._unpackedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._unpackedFixed64, fieldNumber: 96) + } + if !_storage._unpackedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._unpackedSfixed32, fieldNumber: 97) + } + if !_storage._unpackedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._unpackedSfixed64, fieldNumber: 98) + } + if !_storage._unpackedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._unpackedFloat, fieldNumber: 99) + } + if !_storage._unpackedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._unpackedDouble, fieldNumber: 100) + } + if !_storage._unpackedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._unpackedBool, fieldNumber: 101) + } + if !_storage._unpackedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._unpackedNestedEnum, fieldNumber: 102) + } + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case .oneofBool?: try { + guard case .oneofBool(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 115) + }() + case .oneofUint64?: try { + guard case .oneofUint64(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 116) + }() + case .oneofFloat?: try { + guard case .oneofFloat(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularFloatField(value: v, fieldNumber: 117) + }() + case .oneofDouble?: try { + guard case .oneofDouble(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularDoubleField(value: v, fieldNumber: 118) + }() + case .oneofEnum?: try { + guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 119) + }() + case .oneofNullValue?: try { + guard case .oneofNullValue(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 120) + }() + case nil: break + } + try { if let v = _storage._optionalBoolWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._optionalInt32Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 202) + } }() + try { if let v = _storage._optionalInt64Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 203) + } }() + try { if let v = _storage._optionalUint32Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 204) + } }() + try { if let v = _storage._optionalUint64Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 205) + } }() + try { if let v = _storage._optionalFloatWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 206) + } }() + try { if let v = _storage._optionalDoubleWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 207) + } }() + try { if let v = _storage._optionalStringWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 208) + } }() + try { if let v = _storage._optionalBytesWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 209) + } }() + if !_storage._repeatedBoolWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedBoolWrapper, fieldNumber: 211) + } + if !_storage._repeatedInt32Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedInt32Wrapper, fieldNumber: 212) + } + if !_storage._repeatedInt64Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedInt64Wrapper, fieldNumber: 213) + } + if !_storage._repeatedUint32Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedUint32Wrapper, fieldNumber: 214) + } + if !_storage._repeatedUint64Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedUint64Wrapper, fieldNumber: 215) + } + if !_storage._repeatedFloatWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedFloatWrapper, fieldNumber: 216) + } + if !_storage._repeatedDoubleWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedDoubleWrapper, fieldNumber: 217) + } + if !_storage._repeatedStringWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedStringWrapper, fieldNumber: 218) + } + if !_storage._repeatedBytesWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedBytesWrapper, fieldNumber: 219) + } + try { if let v = _storage._optionalDuration { + try visitor.visitSingularMessageField(value: v, fieldNumber: 301) + } }() + try { if let v = _storage._optionalTimestamp { + try visitor.visitSingularMessageField(value: v, fieldNumber: 302) + } }() + try { if let v = _storage._optionalFieldMask { + try visitor.visitSingularMessageField(value: v, fieldNumber: 303) + } }() + try { if let v = _storage._optionalStruct { + try visitor.visitSingularMessageField(value: v, fieldNumber: 304) + } }() + try { if let v = _storage._optionalAny { + try visitor.visitSingularMessageField(value: v, fieldNumber: 305) + } }() + try { if let v = _storage._optionalValue { + try visitor.visitSingularMessageField(value: v, fieldNumber: 306) + } }() + if _storage._optionalNullValue != .nullValue { + try visitor.visitSingularEnumField(value: _storage._optionalNullValue, fieldNumber: 307) + } + if !_storage._repeatedDuration.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedDuration, fieldNumber: 311) + } + if !_storage._repeatedTimestamp.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedTimestamp, fieldNumber: 312) + } + if !_storage._repeatedFieldmask.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedFieldmask, fieldNumber: 313) + } + if !_storage._repeatedAny.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedAny, fieldNumber: 315) + } + if !_storage._repeatedValue.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedValue, fieldNumber: 316) + } + if !_storage._repeatedListValue.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedListValue, fieldNumber: 317) + } + if !_storage._repeatedStruct.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedStruct, fieldNumber: 324) + } + if _storage._fieldname1 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldname1, fieldNumber: 401) + } + if _storage._fieldName2 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName2, fieldNumber: 402) + } + if _storage._fieldName3 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName3, fieldNumber: 403) + } + if _storage._field_Name4_ != 0 { + try visitor.visitSingularInt32Field(value: _storage._field_Name4_, fieldNumber: 404) + } + if _storage._field0Name5 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field0Name5, fieldNumber: 405) + } + if _storage._field0Name6 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field0Name6, fieldNumber: 406) + } + if _storage._fieldName7 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName7, fieldNumber: 407) + } + if _storage._fieldName8 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName8, fieldNumber: 408) + } + if _storage._fieldName9 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName9, fieldNumber: 409) + } + if _storage._fieldName10 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName10, fieldNumber: 410) + } + if _storage._fieldName11 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName11, fieldNumber: 411) + } + if _storage._fieldName12 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName12, fieldNumber: 412) + } + if _storage.__FieldName13 != 0 { + try visitor.visitSingularInt32Field(value: _storage.__FieldName13, fieldNumber: 413) + } + if _storage.__FieldName14 != 0 { + try visitor.visitSingularInt32Field(value: _storage.__FieldName14, fieldNumber: 414) + } + if _storage._field_Name15 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field_Name15, fieldNumber: 415) + } + if _storage._field_Name16 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field_Name16, fieldNumber: 416) + } + if _storage._fieldName17__ != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName17__, fieldNumber: 417) + } + if _storage._fieldName18__ != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName18__, fieldNumber: 418) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto3_TestAllTypesProto3, rhs: ProtobufTestMessages_Proto3_TestAllTypesProto3) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} + if _storage._optionalAliasedEnum != rhs_storage._optionalAliasedEnum {return false} + if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} + if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} + if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} + if _storage._repeatedCord != rhs_storage._repeatedCord {return false} + if _storage._packedInt32 != rhs_storage._packedInt32 {return false} + if _storage._packedInt64 != rhs_storage._packedInt64 {return false} + if _storage._packedUint32 != rhs_storage._packedUint32 {return false} + if _storage._packedUint64 != rhs_storage._packedUint64 {return false} + if _storage._packedSint32 != rhs_storage._packedSint32 {return false} + if _storage._packedSint64 != rhs_storage._packedSint64 {return false} + if _storage._packedFixed32 != rhs_storage._packedFixed32 {return false} + if _storage._packedFixed64 != rhs_storage._packedFixed64 {return false} + if _storage._packedSfixed32 != rhs_storage._packedSfixed32 {return false} + if _storage._packedSfixed64 != rhs_storage._packedSfixed64 {return false} + if _storage._packedFloat != rhs_storage._packedFloat {return false} + if _storage._packedDouble != rhs_storage._packedDouble {return false} + if _storage._packedBool != rhs_storage._packedBool {return false} + if _storage._packedNestedEnum != rhs_storage._packedNestedEnum {return false} + if _storage._unpackedInt32 != rhs_storage._unpackedInt32 {return false} + if _storage._unpackedInt64 != rhs_storage._unpackedInt64 {return false} + if _storage._unpackedUint32 != rhs_storage._unpackedUint32 {return false} + if _storage._unpackedUint64 != rhs_storage._unpackedUint64 {return false} + if _storage._unpackedSint32 != rhs_storage._unpackedSint32 {return false} + if _storage._unpackedSint64 != rhs_storage._unpackedSint64 {return false} + if _storage._unpackedFixed32 != rhs_storage._unpackedFixed32 {return false} + if _storage._unpackedFixed64 != rhs_storage._unpackedFixed64 {return false} + if _storage._unpackedSfixed32 != rhs_storage._unpackedSfixed32 {return false} + if _storage._unpackedSfixed64 != rhs_storage._unpackedSfixed64 {return false} + if _storage._unpackedFloat != rhs_storage._unpackedFloat {return false} + if _storage._unpackedDouble != rhs_storage._unpackedDouble {return false} + if _storage._unpackedBool != rhs_storage._unpackedBool {return false} + if _storage._unpackedNestedEnum != rhs_storage._unpackedNestedEnum {return false} + if _storage._mapInt32Int32 != rhs_storage._mapInt32Int32 {return false} + if _storage._mapInt64Int64 != rhs_storage._mapInt64Int64 {return false} + if _storage._mapUint32Uint32 != rhs_storage._mapUint32Uint32 {return false} + if _storage._mapUint64Uint64 != rhs_storage._mapUint64Uint64 {return false} + if _storage._mapSint32Sint32 != rhs_storage._mapSint32Sint32 {return false} + if _storage._mapSint64Sint64 != rhs_storage._mapSint64Sint64 {return false} + if _storage._mapFixed32Fixed32 != rhs_storage._mapFixed32Fixed32 {return false} + if _storage._mapFixed64Fixed64 != rhs_storage._mapFixed64Fixed64 {return false} + if _storage._mapSfixed32Sfixed32 != rhs_storage._mapSfixed32Sfixed32 {return false} + if _storage._mapSfixed64Sfixed64 != rhs_storage._mapSfixed64Sfixed64 {return false} + if _storage._mapInt32Float != rhs_storage._mapInt32Float {return false} + if _storage._mapInt32Double != rhs_storage._mapInt32Double {return false} + if _storage._mapBoolBool != rhs_storage._mapBoolBool {return false} + if _storage._mapStringString != rhs_storage._mapStringString {return false} + if _storage._mapStringBytes != rhs_storage._mapStringBytes {return false} + if _storage._mapStringNestedMessage != rhs_storage._mapStringNestedMessage {return false} + if _storage._mapStringForeignMessage != rhs_storage._mapStringForeignMessage {return false} + if _storage._mapStringNestedEnum != rhs_storage._mapStringNestedEnum {return false} + if _storage._mapStringForeignEnum != rhs_storage._mapStringForeignEnum {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + if _storage._optionalBoolWrapper != rhs_storage._optionalBoolWrapper {return false} + if _storage._optionalInt32Wrapper != rhs_storage._optionalInt32Wrapper {return false} + if _storage._optionalInt64Wrapper != rhs_storage._optionalInt64Wrapper {return false} + if _storage._optionalUint32Wrapper != rhs_storage._optionalUint32Wrapper {return false} + if _storage._optionalUint64Wrapper != rhs_storage._optionalUint64Wrapper {return false} + if _storage._optionalFloatWrapper != rhs_storage._optionalFloatWrapper {return false} + if _storage._optionalDoubleWrapper != rhs_storage._optionalDoubleWrapper {return false} + if _storage._optionalStringWrapper != rhs_storage._optionalStringWrapper {return false} + if _storage._optionalBytesWrapper != rhs_storage._optionalBytesWrapper {return false} + if _storage._repeatedBoolWrapper != rhs_storage._repeatedBoolWrapper {return false} + if _storage._repeatedInt32Wrapper != rhs_storage._repeatedInt32Wrapper {return false} + if _storage._repeatedInt64Wrapper != rhs_storage._repeatedInt64Wrapper {return false} + if _storage._repeatedUint32Wrapper != rhs_storage._repeatedUint32Wrapper {return false} + if _storage._repeatedUint64Wrapper != rhs_storage._repeatedUint64Wrapper {return false} + if _storage._repeatedFloatWrapper != rhs_storage._repeatedFloatWrapper {return false} + if _storage._repeatedDoubleWrapper != rhs_storage._repeatedDoubleWrapper {return false} + if _storage._repeatedStringWrapper != rhs_storage._repeatedStringWrapper {return false} + if _storage._repeatedBytesWrapper != rhs_storage._repeatedBytesWrapper {return false} + if _storage._optionalDuration != rhs_storage._optionalDuration {return false} + if _storage._optionalTimestamp != rhs_storage._optionalTimestamp {return false} + if _storage._optionalFieldMask != rhs_storage._optionalFieldMask {return false} + if _storage._optionalStruct != rhs_storage._optionalStruct {return false} + if _storage._optionalAny != rhs_storage._optionalAny {return false} + if _storage._optionalValue != rhs_storage._optionalValue {return false} + if _storage._optionalNullValue != rhs_storage._optionalNullValue {return false} + if _storage._repeatedDuration != rhs_storage._repeatedDuration {return false} + if _storage._repeatedTimestamp != rhs_storage._repeatedTimestamp {return false} + if _storage._repeatedFieldmask != rhs_storage._repeatedFieldmask {return false} + if _storage._repeatedStruct != rhs_storage._repeatedStruct {return false} + if _storage._repeatedAny != rhs_storage._repeatedAny {return false} + if _storage._repeatedValue != rhs_storage._repeatedValue {return false} + if _storage._repeatedListValue != rhs_storage._repeatedListValue {return false} + if _storage._fieldname1 != rhs_storage._fieldname1 {return false} + if _storage._fieldName2 != rhs_storage._fieldName2 {return false} + if _storage._fieldName3 != rhs_storage._fieldName3 {return false} + if _storage._field_Name4_ != rhs_storage._field_Name4_ {return false} + if _storage._field0Name5 != rhs_storage._field0Name5 {return false} + if _storage._field0Name6 != rhs_storage._field0Name6 {return false} + if _storage._fieldName7 != rhs_storage._fieldName7 {return false} + if _storage._fieldName8 != rhs_storage._fieldName8 {return false} + if _storage._fieldName9 != rhs_storage._fieldName9 {return false} + if _storage._fieldName10 != rhs_storage._fieldName10 {return false} + if _storage._fieldName11 != rhs_storage._fieldName11 {return false} + if _storage._fieldName12 != rhs_storage._fieldName12 {return false} + if _storage.__FieldName13 != rhs_storage.__FieldName13 {return false} + if _storage.__FieldName14 != rhs_storage.__FieldName14 {return false} + if _storage._field_Name15 != rhs_storage._field_Name15 {return false} + if _storage._field_Name16 != rhs_storage._field_Name16 {return false} + if _storage._fieldName17__ != rhs_storage._fieldName17__ {return false} + if _storage._fieldName18__ != rhs_storage._fieldName18__ {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ALIAS_FOO\0\u{1}ALIAS_BAR\0\u{9}ALIAS_BAZ\0\u{3}MOO\0moo\0bAz\0") +} + +extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto3_TestAllTypesProto3.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32 = 0 + var _corecursive: ProtobufTestMessages_Proto3_TestAllTypesProto3? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + default: break + } + } + } + } + + func traverse(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 + if _storage._a != 0 { + try visitor.visitSingularInt32Field(value: _storage._a, fieldNumber: 1) + } + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage, rhs: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto3_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") + + 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.c) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.c != 0 { + try visitor.visitSingularInt32Field(value: self.c, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto3_ForeignMessage, rhs: ProtobufTestMessages_Proto3_ForeignMessage) -> Bool { + if lhs.c != rhs.c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto3_NullHypothesisProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NullHypothesisProto3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto3_NullHypothesisProto3, rhs: ProtobufTestMessages_Proto3_NullHypothesisProto3) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto3_EnumOnlyProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumOnlyProto3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto3_EnumOnlyProto3, rhs: ProtobufTestMessages_Proto3_EnumOnlyProto3) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto3_EnumOnlyProto3.BoolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0kFalse\0\u{1}kTrue\0") +} diff --git a/Reference/upstream/google/protobuf/timestamp.pb.swift b/Reference/upstream/google/protobuf/timestamp.pb.swift new file mode 100644 index 000000000..30f78ae5b --- /dev/null +++ b/Reference/upstream/google/protobuf/timestamp.pb.swift @@ -0,0 +1,201 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/timestamp.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. + +// 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: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// A Timestamp represents a point in time independent of any time zone or local +/// calendar, encoded as a count of seconds and fractions of seconds at +/// nanosecond resolution. The count is relative to an epoch at UTC midnight on +/// January 1, 1970, in the proleptic Gregorian calendar which extends the +/// Gregorian calendar backwards to year one. +/// +/// All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap +/// second table is needed for interpretation, using a [24-hour linear +/// smear](https://developers.google.com/time/smear). +/// +/// The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By +/// restricting to that range, we ensure that we can convert to and from [RFC +/// 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. +/// +/// # Examples +/// +/// Example 1: Compute Timestamp from POSIX `time()`. +/// +/// Timestamp timestamp; +/// timestamp.set_seconds(time(NULL)); +/// timestamp.set_nanos(0); +/// +/// Example 2: Compute Timestamp from POSIX `gettimeofday()`. +/// +/// struct timeval tv; +/// gettimeofday(&tv, NULL); +/// +/// Timestamp timestamp; +/// timestamp.set_seconds(tv.tv_sec); +/// timestamp.set_nanos(tv.tv_usec * 1000); +/// +/// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. +/// +/// FILETIME ft; +/// GetSystemTimeAsFileTime(&ft); +/// UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; +/// +/// // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z +/// // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. +/// Timestamp timestamp; +/// timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); +/// timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); +/// +/// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. +/// +/// long millis = System.currentTimeMillis(); +/// +/// Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) +/// .setNanos((int) ((millis % 1000) * 1000000)).build(); +/// +/// Example 5: Compute Timestamp from Java `Instant.now()`. +/// +/// Instant now = Instant.now(); +/// +/// Timestamp timestamp = +/// Timestamp.newBuilder().setSeconds(now.getEpochSecond()) +/// .setNanos(now.getNano()).build(); +/// +/// Example 6: Compute Timestamp from current time in Python. +/// +/// timestamp = Timestamp() +/// timestamp.GetCurrentTime() +/// +/// # JSON Mapping +/// +/// In JSON format, the Timestamp type is encoded as a string in the +/// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the +/// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" +/// where {year} is always expressed using four digits while {month}, {day}, +/// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional +/// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), +/// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone +/// is required. A ProtoJSON serializer should always use UTC (as indicated by +/// "Z") when printing the Timestamp type and a ProtoJSON parser should be +/// able to accept both UTC and other timezones (as indicated by an offset). +/// +/// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past +/// 01:30 UTC on January 15, 2017. +/// +/// In JavaScript, one can convert a Date object to this format using the +/// standard +/// [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) +/// method. In Python, a standard `datetime.datetime` object can be converted +/// to this format using +/// [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with +/// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use +/// the Joda Time's [`ISODateTimeFormat.dateTime()`]( +/// http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime() +/// ) to obtain a formatter capable of generating timestamps in this format. +struct Google_Protobuf_Timestamp: Sendable { + // 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. + + /// Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must + /// be between -62135596800 and 253402300799 inclusive (which corresponds to + /// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z). + var seconds: Int64 = 0 + + /// Non-negative fractions of a second at nanosecond resolution. This field is + /// the nanosecond portion of the duration, not an alternative to seconds. + /// Negative second values with fractions must still have non-negative nanos + /// values that count forward in time. Must be between 0 and 999,999,999 + /// inclusive. + var nanos: Int32 = 0 + + var unknownFields = UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "google.protobuf" + +extension Google_Protobuf_Timestamp: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Timestamp" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}seconds\0\u{1}nanos\0") + + 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.decodeSingularInt64Field(value: &self.seconds) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self.nanos) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.seconds != 0 { + try visitor.visitSingularInt64Field(value: self.seconds, fieldNumber: 1) + } + if self.nanos != 0 { + try visitor.visitSingularInt32Field(value: self.nanos, fieldNumber: 2) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_Timestamp, rhs: Google_Protobuf_Timestamp) -> Bool { + if lhs.seconds != rhs.seconds {return false} + if lhs.nanos != rhs.nanos {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/type.pb.swift b/Reference/upstream/google/protobuf/type.pb.swift new file mode 100644 index 000000000..429e57454 --- /dev/null +++ b/Reference/upstream/google/protobuf/type.pb.swift @@ -0,0 +1,780 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/type.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. + +// 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: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// The syntax in which a protocol buffer element is defined. +enum Google_Protobuf_Syntax: Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// Syntax `proto2`. + case proto2 // = 0 + + /// Syntax `proto3`. + case proto3 // = 1 + + /// Syntax `editions`. + case editions // = 2 + case UNRECOGNIZED(Int) + + init() { + self = .proto2 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .proto2 + case 1: self = .proto3 + case 2: self = .editions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .proto2: return 0 + case .proto3: return 1 + case .editions: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Google_Protobuf_Syntax] = [ + .proto2, + .proto3, + .editions, + ] + +} + +/// A protocol buffer message type. +/// +/// New usages of this message as an alternative to DescriptorProto are strongly +/// discouraged. This message does not reliability preserve all information +/// necessary to model the schema and preserve semantics. Instead make use of +/// FileDescriptorSet which preserves the necessary information. +struct Google_Protobuf_Type: Sendable { + // 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. + + /// The fully qualified message name. + var name: String = String() + + /// The list of fields. + var fields: [Google_Protobuf_Field] = [] + + /// The list of types appearing in `oneof` definitions in this type. + var oneofs: [String] = [] + + /// The protocol buffer options. + var options: [Google_Protobuf_Option] = [] + + /// The source context. + var sourceContext: Google_Protobuf_SourceContext { + get {_sourceContext ?? Google_Protobuf_SourceContext()} + set {_sourceContext = newValue} + } + /// Returns true if `sourceContext` has been explicitly set. + var hasSourceContext: Bool {self._sourceContext != nil} + /// Clears the value of `sourceContext`. Subsequent reads from it will return its default value. + mutating func clearSourceContext() {self._sourceContext = nil} + + /// The source syntax. + var syntax: Google_Protobuf_Syntax = .proto2 + + /// The source edition string, only valid when syntax is SYNTAX_EDITIONS. + var edition: String = String() + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _sourceContext: Google_Protobuf_SourceContext? = nil +} + +/// A single field of a message type. +/// +/// New usages of this message as an alternative to FieldDescriptorProto are +/// strongly discouraged. This message does not reliability preserve all +/// information necessary to model the schema and preserve semantics. Instead +/// make use of FileDescriptorSet which preserves the necessary information. +struct Google_Protobuf_Field: Sendable { + // 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. + + /// The field type. + var kind: Google_Protobuf_Field.Kind = .typeUnknown + + /// The field cardinality. + var cardinality: Google_Protobuf_Field.Cardinality = .unknown + + /// The field number. + var number: Int32 = 0 + + /// The field name. + var name: String = String() + + /// The field type URL, without the scheme, for message or enumeration + /// types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`. + var typeURL: String = String() + + /// The index of the field type in `Type.oneofs`, for message or enumeration + /// types. The first type has index 1; zero means the type is not in the list. + var oneofIndex: Int32 = 0 + + /// Whether to use alternative packed wire representation. + var packed: Bool = false + + /// The protocol buffer options. + var options: [Google_Protobuf_Option] = [] + + /// The field JSON name. + var jsonName: String = String() + + /// The string value of the default value of this field. Proto2 syntax only. + var defaultValue: String = String() + + var unknownFields = UnknownStorage() + + /// Basic field types. + enum Kind: Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// Field type unknown. + case typeUnknown // = 0 + + /// Field type double. + case typeDouble // = 1 + + /// Field type float. + case typeFloat // = 2 + + /// Field type int64. + case typeInt64 // = 3 + + /// Field type uint64. + case typeUint64 // = 4 + + /// Field type int32. + case typeInt32 // = 5 + + /// Field type fixed64. + case typeFixed64 // = 6 + + /// Field type fixed32. + case typeFixed32 // = 7 + + /// Field type bool. + case typeBool // = 8 + + /// Field type string. + case typeString // = 9 + + /// Field type group. Proto2 syntax only, and deprecated. + case typeGroup // = 10 + + /// Field type message. + case typeMessage // = 11 + + /// Field type bytes. + case typeBytes // = 12 + + /// Field type uint32. + case typeUint32 // = 13 + + /// Field type enum. + case typeEnum // = 14 + + /// Field type sfixed32. + case typeSfixed32 // = 15 + + /// Field type sfixed64. + case typeSfixed64 // = 16 + + /// Field type sint32. + case typeSint32 // = 17 + + /// Field type sint64. + case typeSint64 // = 18 + case UNRECOGNIZED(Int) + + init() { + self = .typeUnknown + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .typeUnknown + case 1: self = .typeDouble + case 2: self = .typeFloat + case 3: self = .typeInt64 + case 4: self = .typeUint64 + case 5: self = .typeInt32 + case 6: self = .typeFixed64 + case 7: self = .typeFixed32 + case 8: self = .typeBool + case 9: self = .typeString + case 10: self = .typeGroup + case 11: self = .typeMessage + case 12: self = .typeBytes + case 13: self = .typeUint32 + case 14: self = .typeEnum + case 15: self = .typeSfixed32 + case 16: self = .typeSfixed64 + case 17: self = .typeSint32 + case 18: self = .typeSint64 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .typeUnknown: return 0 + case .typeDouble: return 1 + case .typeFloat: return 2 + case .typeInt64: return 3 + case .typeUint64: return 4 + case .typeInt32: return 5 + case .typeFixed64: return 6 + case .typeFixed32: return 7 + case .typeBool: return 8 + case .typeString: return 9 + case .typeGroup: return 10 + case .typeMessage: return 11 + case .typeBytes: return 12 + case .typeUint32: return 13 + case .typeEnum: return 14 + case .typeSfixed32: return 15 + case .typeSfixed64: return 16 + case .typeSint32: return 17 + case .typeSint64: return 18 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Google_Protobuf_Field.Kind] = [ + .typeUnknown, + .typeDouble, + .typeFloat, + .typeInt64, + .typeUint64, + .typeInt32, + .typeFixed64, + .typeFixed32, + .typeBool, + .typeString, + .typeGroup, + .typeMessage, + .typeBytes, + .typeUint32, + .typeEnum, + .typeSfixed32, + .typeSfixed64, + .typeSint32, + .typeSint64, + ] + + } + + /// Whether a field is optional, required, or repeated. + enum Cardinality: Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// For fields with unknown cardinality. + case unknown // = 0 + + /// For optional fields. + case `optional` // = 1 + + /// For required fields. Proto2 syntax only. + case `required` // = 2 + + /// For repeated fields. + case repeated // = 3 + case UNRECOGNIZED(Int) + + init() { + self = .unknown + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .unknown + case 1: self = .optional + case 2: self = .required + case 3: self = .repeated + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .unknown: return 0 + case .optional: return 1 + case .required: return 2 + case .repeated: return 3 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Google_Protobuf_Field.Cardinality] = [ + .unknown, + .optional, + .required, + .repeated, + ] + + } + + init() {} +} + +/// Enum type definition. +/// +/// New usages of this message as an alternative to EnumDescriptorProto are +/// strongly discouraged. This message does not reliability preserve all +/// information necessary to model the schema and preserve semantics. Instead +/// make use of FileDescriptorSet which preserves the necessary information. +struct Google_Protobuf_Enum: Sendable { + // 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. + + /// Enum type name. + var name: String = String() + + /// Enum value definitions. + var enumvalue: [Google_Protobuf_EnumValue] = [] + + /// Protocol buffer options. + var options: [Google_Protobuf_Option] = [] + + /// The source context. + var sourceContext: Google_Protobuf_SourceContext { + get {_sourceContext ?? Google_Protobuf_SourceContext()} + set {_sourceContext = newValue} + } + /// Returns true if `sourceContext` has been explicitly set. + var hasSourceContext: Bool {self._sourceContext != nil} + /// Clears the value of `sourceContext`. Subsequent reads from it will return its default value. + mutating func clearSourceContext() {self._sourceContext = nil} + + /// The source syntax. + var syntax: Google_Protobuf_Syntax = .proto2 + + /// The source edition string, only valid when syntax is SYNTAX_EDITIONS. + var edition: String = String() + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _sourceContext: Google_Protobuf_SourceContext? = nil +} + +/// Enum value definition. +/// +/// New usages of this message as an alternative to EnumValueDescriptorProto are +/// strongly discouraged. This message does not reliability preserve all +/// information necessary to model the schema and preserve semantics. Instead +/// make use of FileDescriptorSet which preserves the necessary information. +struct Google_Protobuf_EnumValue: Sendable { + // 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. + + /// Enum value name. + var name: String = String() + + /// Enum value number. + var number: Int32 = 0 + + /// Protocol buffer options. + var options: [Google_Protobuf_Option] = [] + + var unknownFields = UnknownStorage() + + init() {} +} + +/// A protocol buffer option, which can be attached to a message, field, +/// enumeration, etc. +/// +/// New usages of this message as an alternative to FileOptions, MessageOptions, +/// FieldOptions, EnumOptions, EnumValueOptions, ServiceOptions, or MethodOptions +/// are strongly discouraged. +struct Google_Protobuf_Option: Sendable { + // 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. + + /// The option's name. For protobuf built-in options (options defined in + /// descriptor.proto), this is the short name. For example, `"map_entry"`. + /// For custom options, it should be the fully-qualified name. For example, + /// `"google.api.http"`. + var name: String = String() + + /// The option's value packed in an Any message. If the value is a primitive, + /// the corresponding wrapper type defined in google/protobuf/wrappers.proto + /// should be used. If the value is an enum, it should be stored as an int32 + /// value using the google.protobuf.Int32Value type. + var value: Google_Protobuf_Any { + get {_value ?? Google_Protobuf_Any()} + set {_value = newValue} + } + /// Returns true if `value` has been explicitly set. + var hasValue: Bool {self._value != nil} + /// Clears the value of `value`. Subsequent reads from it will return its default value. + mutating func clearValue() {self._value = nil} + + var unknownFields = UnknownStorage() + + init() {} + + fileprivate var _value: Google_Protobuf_Any? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "google.protobuf" + +extension Google_Protobuf_Syntax: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0SYNTAX_PROTO2\0\u{1}SYNTAX_PROTO3\0\u{1}SYNTAX_EDITIONS\0") +} + +extension Google_Protobuf_Type: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Type" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}fields\0\u{1}oneofs\0\u{1}options\0\u{3}source_context\0\u{1}syntax\0\u{1}edition\0") + + 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.name) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.fields) }() + case 3: try { try decoder.decodeRepeatedStringField(value: &self.oneofs) }() + case 4: try { try decoder.decodeRepeatedMessageField(value: &self.options) }() + case 5: try { try decoder.decodeSingularMessageField(value: &self._sourceContext) }() + case 6: try { try decoder.decodeSingularEnumField(value: &self.syntax) }() + case 7: try { try decoder.decodeSingularStringField(value: &self.edition) }() + 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 + if !self.name.isEmpty { + try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) + } + if !self.fields.isEmpty { + try visitor.visitRepeatedMessageField(value: self.fields, fieldNumber: 2) + } + if !self.oneofs.isEmpty { + try visitor.visitRepeatedStringField(value: self.oneofs, fieldNumber: 3) + } + if !self.options.isEmpty { + try visitor.visitRepeatedMessageField(value: self.options, fieldNumber: 4) + } + try { if let v = self._sourceContext { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + if self.syntax != .proto2 { + try visitor.visitSingularEnumField(value: self.syntax, fieldNumber: 6) + } + if !self.edition.isEmpty { + try visitor.visitSingularStringField(value: self.edition, fieldNumber: 7) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_Type, rhs: Google_Protobuf_Type) -> Bool { + if lhs.name != rhs.name {return false} + if lhs.fields != rhs.fields {return false} + if lhs.oneofs != rhs.oneofs {return false} + if lhs.options != rhs.options {return false} + if lhs._sourceContext != rhs._sourceContext {return false} + if lhs.syntax != rhs.syntax {return false} + if lhs.edition != rhs.edition {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_Field: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Field" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}kind\0\u{1}cardinality\0\u{1}number\0\u{1}name\0\u{4}\u{2}type_url\0\u{3}oneof_index\0\u{1}packed\0\u{1}options\0\u{3}json_name\0\u{3}default_value\0") + + 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.kind) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self.cardinality) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self.number) }() + case 4: try { try decoder.decodeSingularStringField(value: &self.name) }() + case 6: try { try decoder.decodeSingularStringField(value: &self.typeURL) }() + case 7: try { try decoder.decodeSingularInt32Field(value: &self.oneofIndex) }() + case 8: try { try decoder.decodeSingularBoolField(value: &self.packed) }() + case 9: try { try decoder.decodeRepeatedMessageField(value: &self.options) }() + case 10: try { try decoder.decodeSingularStringField(value: &self.jsonName) }() + case 11: try { try decoder.decodeSingularStringField(value: &self.defaultValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.kind != .typeUnknown { + try visitor.visitSingularEnumField(value: self.kind, fieldNumber: 1) + } + if self.cardinality != .unknown { + try visitor.visitSingularEnumField(value: self.cardinality, fieldNumber: 2) + } + if self.number != 0 { + try visitor.visitSingularInt32Field(value: self.number, fieldNumber: 3) + } + if !self.name.isEmpty { + try visitor.visitSingularStringField(value: self.name, fieldNumber: 4) + } + if !self.typeURL.isEmpty { + try visitor.visitSingularStringField(value: self.typeURL, fieldNumber: 6) + } + if self.oneofIndex != 0 { + try visitor.visitSingularInt32Field(value: self.oneofIndex, fieldNumber: 7) + } + if self.packed != false { + try visitor.visitSingularBoolField(value: self.packed, fieldNumber: 8) + } + if !self.options.isEmpty { + try visitor.visitRepeatedMessageField(value: self.options, fieldNumber: 9) + } + if !self.jsonName.isEmpty { + try visitor.visitSingularStringField(value: self.jsonName, fieldNumber: 10) + } + if !self.defaultValue.isEmpty { + try visitor.visitSingularStringField(value: self.defaultValue, fieldNumber: 11) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_Field, rhs: Google_Protobuf_Field) -> Bool { + if lhs.kind != rhs.kind {return false} + if lhs.cardinality != rhs.cardinality {return false} + if lhs.number != rhs.number {return false} + if lhs.name != rhs.name {return false} + if lhs.typeURL != rhs.typeURL {return false} + if lhs.oneofIndex != rhs.oneofIndex {return false} + if lhs.packed != rhs.packed {return false} + if lhs.options != rhs.options {return false} + if lhs.jsonName != rhs.jsonName {return false} + if lhs.defaultValue != rhs.defaultValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_Field.Kind: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0TYPE_UNKNOWN\0\u{1}TYPE_DOUBLE\0\u{1}TYPE_FLOAT\0\u{1}TYPE_INT64\0\u{1}TYPE_UINT64\0\u{1}TYPE_INT32\0\u{1}TYPE_FIXED64\0\u{1}TYPE_FIXED32\0\u{1}TYPE_BOOL\0\u{1}TYPE_STRING\0\u{1}TYPE_GROUP\0\u{1}TYPE_MESSAGE\0\u{1}TYPE_BYTES\0\u{1}TYPE_UINT32\0\u{1}TYPE_ENUM\0\u{1}TYPE_SFIXED32\0\u{1}TYPE_SFIXED64\0\u{1}TYPE_SINT32\0\u{1}TYPE_SINT64\0") +} + +extension Google_Protobuf_Field.Cardinality: _ProtoNameProviding { + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0CARDINALITY_UNKNOWN\0\u{1}CARDINALITY_OPTIONAL\0\u{1}CARDINALITY_REQUIRED\0\u{1}CARDINALITY_REPEATED\0") +} + +extension Google_Protobuf_Enum: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Enum" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}enumvalue\0\u{1}options\0\u{3}source_context\0\u{1}syntax\0\u{1}edition\0") + + 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.name) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.enumvalue) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &self.options) }() + case 4: try { try decoder.decodeSingularMessageField(value: &self._sourceContext) }() + case 5: try { try decoder.decodeSingularEnumField(value: &self.syntax) }() + case 6: try { try decoder.decodeSingularStringField(value: &self.edition) }() + 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 + if !self.name.isEmpty { + try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) + } + if !self.enumvalue.isEmpty { + try visitor.visitRepeatedMessageField(value: self.enumvalue, fieldNumber: 2) + } + if !self.options.isEmpty { + try visitor.visitRepeatedMessageField(value: self.options, fieldNumber: 3) + } + try { if let v = self._sourceContext { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + if self.syntax != .proto2 { + try visitor.visitSingularEnumField(value: self.syntax, fieldNumber: 5) + } + if !self.edition.isEmpty { + try visitor.visitSingularStringField(value: self.edition, fieldNumber: 6) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_Enum, rhs: Google_Protobuf_Enum) -> Bool { + if lhs.name != rhs.name {return false} + if lhs.enumvalue != rhs.enumvalue {return false} + if lhs.options != rhs.options {return false} + if lhs._sourceContext != rhs._sourceContext {return false} + if lhs.syntax != rhs.syntax {return false} + if lhs.edition != rhs.edition {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_EnumValue: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumValue" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}number\0\u{1}options\0") + + 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.name) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self.number) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &self.options) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.name.isEmpty { + try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) + } + if self.number != 0 { + try visitor.visitSingularInt32Field(value: self.number, fieldNumber: 2) + } + if !self.options.isEmpty { + try visitor.visitRepeatedMessageField(value: self.options, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_EnumValue, rhs: Google_Protobuf_EnumValue) -> Bool { + if lhs.name != rhs.name {return false} + if lhs.number != rhs.number {return false} + if lhs.options != rhs.options {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_Option: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Option" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}value\0") + + 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.name) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._value) }() + 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 + if !self.name.isEmpty { + try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) + } + try { if let v = self._value { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_Option, rhs: Google_Protobuf_Option) -> Bool { + if lhs.name != rhs.name {return false} + if lhs._value != rhs._value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/unittest.pb.swift b/Reference/upstream/google/protobuf/unittest.pb.swift new file mode 100644 index 000000000..81ce3f851 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest.pb.swift @@ -0,0 +1,21245 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// A proto file we will use for unit testing. +// +// LINT: ALLOW_GROUPS, LEGACY_NAMES + +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 Proto2Unittest_ForeignEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foreignFoo = 4 + case foreignBar = 5 + case foreignBaz = 6 + + /// (1 << 32) to generate a 64b bitmask would be incorrect. + case foreignBax = 32 + + /// Large enough to escape the Boxed Integer cache. + case foreignLarge = 123456 + + init() { + self = .foreignFoo + } + +} + +enum Proto2Unittest_TestReservedEnumFields: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unknown = 0 + + init() { + self = .unknown + } + +} + +/// Required and open enum accepts invalid enum values. +enum Proto2Unittest_ForeignOpenEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foreignOpenUnknown // = 0 + case foreignOpenFoo // = 4 + case foreignOpenBar // = 5 + case foreignOpenBaz // = 6 + + /// (1 << 32) to generate a 64b bitmask would be + case foreignOpenBax // = 32 + case UNRECOGNIZED(Int) + + init() { + self = .foreignOpenUnknown + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .foreignOpenUnknown + case 4: self = .foreignOpenFoo + case 5: self = .foreignOpenBar + case 6: self = .foreignOpenBaz + case 32: self = .foreignOpenBax + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .foreignOpenUnknown: return 0 + case .foreignOpenFoo: return 4 + case .foreignOpenBar: return 5 + case .foreignOpenBaz: return 6 + case .foreignOpenBax: return 32 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Proto2Unittest_ForeignOpenEnum] = [ + .foreignOpenUnknown, + .foreignOpenFoo, + .foreignOpenBar, + .foreignOpenBaz, + .foreignOpenBax, + ] + +} + +/// Test an enum that has multiple values with the same number. +enum Proto2Unittest_TestEnumWithDupValue: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo1 = 1 + case bar1 = 2 + case baz = 3 + static let foo2 = foo1 + static let bar2 = bar1 + + init() { + self = .foo1 + } + +} + +/// Test an enum with large, unordered values. +enum Proto2Unittest_TestSparseEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case sparseA = 123 + case sparseB = 62374 + case sparseC = 12589234 + case sparseD = -15 + case sparseE = -53452 + case sparseF = 0 + case sparseG = 2 + + init() { + self = .sparseA + } + +} + +enum Proto2Unittest_VeryLargeEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case enumLabelDefault = 0 + case enumLabel1 = 1 + case enumLabel2 = 2 + case enumLabel3 = 3 + case enumLabel4 = 4 + case enumLabel5 = 5 + case enumLabel6 = 6 + case enumLabel7 = 7 + case enumLabel8 = 8 + case enumLabel9 = 9 + case enumLabel10 = 10 + case enumLabel11 = 11 + case enumLabel12 = 12 + case enumLabel13 = 13 + case enumLabel14 = 14 + case enumLabel15 = 15 + case enumLabel16 = 16 + case enumLabel17 = 17 + case enumLabel18 = 18 + case enumLabel19 = 19 + case enumLabel20 = 20 + case enumLabel21 = 21 + case enumLabel22 = 22 + case enumLabel23 = 23 + case enumLabel24 = 24 + case enumLabel25 = 25 + case enumLabel26 = 26 + case enumLabel27 = 27 + case enumLabel28 = 28 + case enumLabel29 = 29 + case enumLabel30 = 30 + case enumLabel31 = 31 + case enumLabel32 = 32 + case enumLabel33 = 33 + case enumLabel34 = 34 + case enumLabel35 = 35 + case enumLabel36 = 36 + case enumLabel37 = 37 + case enumLabel38 = 38 + case enumLabel39 = 39 + case enumLabel40 = 40 + case enumLabel41 = 41 + case enumLabel42 = 42 + case enumLabel43 = 43 + case enumLabel44 = 44 + case enumLabel45 = 45 + case enumLabel46 = 46 + case enumLabel47 = 47 + case enumLabel48 = 48 + case enumLabel49 = 49 + case enumLabel50 = 50 + case enumLabel51 = 51 + case enumLabel52 = 52 + case enumLabel53 = 53 + case enumLabel54 = 54 + case enumLabel55 = 55 + case enumLabel56 = 56 + case enumLabel57 = 57 + case enumLabel58 = 58 + case enumLabel59 = 59 + case enumLabel60 = 60 + case enumLabel61 = 61 + case enumLabel62 = 62 + case enumLabel63 = 63 + case enumLabel64 = 64 + case enumLabel65 = 65 + case enumLabel66 = 66 + case enumLabel67 = 67 + case enumLabel68 = 68 + case enumLabel69 = 69 + case enumLabel70 = 70 + case enumLabel71 = 71 + case enumLabel72 = 72 + case enumLabel73 = 73 + case enumLabel74 = 74 + case enumLabel75 = 75 + case enumLabel76 = 76 + case enumLabel77 = 77 + case enumLabel78 = 78 + case enumLabel79 = 79 + case enumLabel80 = 80 + case enumLabel81 = 81 + case enumLabel82 = 82 + case enumLabel83 = 83 + case enumLabel84 = 84 + case enumLabel85 = 85 + case enumLabel86 = 86 + case enumLabel87 = 87 + case enumLabel88 = 88 + case enumLabel89 = 89 + case enumLabel90 = 90 + case enumLabel91 = 91 + case enumLabel92 = 92 + case enumLabel93 = 93 + case enumLabel94 = 94 + case enumLabel95 = 95 + case enumLabel96 = 96 + case enumLabel97 = 97 + case enumLabel98 = 98 + case enumLabel99 = 99 + case enumLabel100 = 100 + + init() { + self = .enumLabelDefault + } + +} + +/// This proto includes every type of field in both singular and repeated +/// forms. +struct Proto2Unittest_TestAllTypes: @unchecked Sendable { + // 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. + + /// Singular + var optionalInt32: Int32 { + get {_storage._optionalInt32 ?? 0} + set {_uniqueStorage()._optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} + + var optionalInt64: Int64 { + get {_storage._optionalInt64 ?? 0} + set {_uniqueStorage()._optionalInt64 = newValue} + } + /// Returns true if `optionalInt64` has been explicitly set. + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} + /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} + + var optionalUint32: UInt32 { + get {_storage._optionalUint32 ?? 0} + set {_uniqueStorage()._optionalUint32 = newValue} + } + /// Returns true if `optionalUint32` has been explicitly set. + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} + /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} + + var optionalUint64: UInt64 { + get {_storage._optionalUint64 ?? 0} + set {_uniqueStorage()._optionalUint64 = newValue} + } + /// Returns true if `optionalUint64` has been explicitly set. + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} + /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} + + var optionalSint32: Int32 { + get {_storage._optionalSint32 ?? 0} + set {_uniqueStorage()._optionalSint32 = newValue} + } + /// Returns true if `optionalSint32` has been explicitly set. + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} + /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} + + var optionalSint64: Int64 { + get {_storage._optionalSint64 ?? 0} + set {_uniqueStorage()._optionalSint64 = newValue} + } + /// Returns true if `optionalSint64` has been explicitly set. + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} + /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} + + var optionalFixed32: UInt32 { + get {_storage._optionalFixed32 ?? 0} + set {_uniqueStorage()._optionalFixed32 = newValue} + } + /// Returns true if `optionalFixed32` has been explicitly set. + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} + /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} + + var optionalFixed64: UInt64 { + get {_storage._optionalFixed64 ?? 0} + set {_uniqueStorage()._optionalFixed64 = newValue} + } + /// Returns true if `optionalFixed64` has been explicitly set. + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} + /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} + + var optionalSfixed32: Int32 { + get {_storage._optionalSfixed32 ?? 0} + set {_uniqueStorage()._optionalSfixed32 = newValue} + } + /// Returns true if `optionalSfixed32` has been explicitly set. + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} + /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} + + var optionalSfixed64: Int64 { + get {_storage._optionalSfixed64 ?? 0} + set {_uniqueStorage()._optionalSfixed64 = newValue} + } + /// Returns true if `optionalSfixed64` has been explicitly set. + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} + /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} + + var optionalFloat: Float { + get {_storage._optionalFloat ?? 0} + set {_uniqueStorage()._optionalFloat = newValue} + } + /// Returns true if `optionalFloat` has been explicitly set. + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} + /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} + + var optionalDouble: Double { + get {_storage._optionalDouble ?? 0} + set {_uniqueStorage()._optionalDouble = newValue} + } + /// Returns true if `optionalDouble` has been explicitly set. + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} + /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. + mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} + + var optionalBool: Bool { + get {_storage._optionalBool ?? false} + set {_uniqueStorage()._optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {_storage._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} + + var optionalString: String { + get {_storage._optionalString ?? String()} + set {_uniqueStorage()._optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {_storage._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} + + var optionalBytes: Data { + get {_storage._optionalBytes ?? Data()} + set {_uniqueStorage()._optionalBytes = newValue} + } + /// Returns true if `optionalBytes` has been explicitly set. + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} + /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} + + var optionalGroup: Proto2Unittest_TestAllTypes.OptionalGroup { + get {_storage._optionalGroup ?? Proto2Unittest_TestAllTypes.OptionalGroup()} + set {_uniqueStorage()._optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {_storage._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {_uniqueStorage()._optionalGroup = nil} + + var optionalNestedMessage: Proto2Unittest_TestAllTypes.NestedMessage { + get {_storage._optionalNestedMessage ?? Proto2Unittest_TestAllTypes.NestedMessage()} + set {_uniqueStorage()._optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} + + var optionalForeignMessage: Proto2Unittest_ForeignMessage { + get {_storage._optionalForeignMessage ?? Proto2Unittest_ForeignMessage()} + set {_uniqueStorage()._optionalForeignMessage = newValue} + } + /// Returns true if `optionalForeignMessage` has been explicitly set. + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} + /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} + + var optionalImportMessage: Proto2UnittestImport_ImportMessage { + get {_storage._optionalImportMessage ?? Proto2UnittestImport_ImportMessage()} + set {_uniqueStorage()._optionalImportMessage = newValue} + } + /// Returns true if `optionalImportMessage` has been explicitly set. + var hasOptionalImportMessage: Bool {_storage._optionalImportMessage != nil} + /// Clears the value of `optionalImportMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalImportMessage() {_uniqueStorage()._optionalImportMessage = nil} + + var optionalNestedEnum: Proto2Unittest_TestAllTypes.NestedEnum { + get {_storage._optionalNestedEnum ?? .foo} + set {_uniqueStorage()._optionalNestedEnum = newValue} + } + /// Returns true if `optionalNestedEnum` has been explicitly set. + var hasOptionalNestedEnum: Bool {_storage._optionalNestedEnum != nil} + /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} + + var optionalForeignEnum: Proto2Unittest_ForeignEnum { + get {_storage._optionalForeignEnum ?? .foreignFoo} + set {_uniqueStorage()._optionalForeignEnum = newValue} + } + /// Returns true if `optionalForeignEnum` has been explicitly set. + var hasOptionalForeignEnum: Bool {_storage._optionalForeignEnum != nil} + /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignEnum() {_uniqueStorage()._optionalForeignEnum = nil} + + var optionalImportEnum: Proto2UnittestImport_ImportEnum { + get {_storage._optionalImportEnum ?? .importFoo} + set {_uniqueStorage()._optionalImportEnum = newValue} + } + /// Returns true if `optionalImportEnum` has been explicitly set. + var hasOptionalImportEnum: Bool {_storage._optionalImportEnum != nil} + /// Clears the value of `optionalImportEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalImportEnum() {_uniqueStorage()._optionalImportEnum = nil} + + var optionalStringPiece: String { + get {_storage._optionalStringPiece ?? String()} + set {_uniqueStorage()._optionalStringPiece = newValue} + } + /// Returns true if `optionalStringPiece` has been explicitly set. + var hasOptionalStringPiece: Bool {_storage._optionalStringPiece != nil} + /// Clears the value of `optionalStringPiece`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringPiece() {_uniqueStorage()._optionalStringPiece = nil} + + var optionalCord: String { + get {_storage._optionalCord ?? String()} + set {_uniqueStorage()._optionalCord = newValue} + } + /// Returns true if `optionalCord` has been explicitly set. + var hasOptionalCord: Bool {_storage._optionalCord != nil} + /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. + mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} + + var optionalBytesCord: Data { + get {_storage._optionalBytesCord ?? Data()} + set {_uniqueStorage()._optionalBytesCord = newValue} + } + /// Returns true if `optionalBytesCord` has been explicitly set. + var hasOptionalBytesCord: Bool {_storage._optionalBytesCord != nil} + /// Clears the value of `optionalBytesCord`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytesCord() {_uniqueStorage()._optionalBytesCord = nil} + + /// Defined in unittest_import_public.proto + var optionalPublicImportMessage: Proto2UnittestImport_PublicImportMessage { + get {_storage._optionalPublicImportMessage ?? Proto2UnittestImport_PublicImportMessage()} + set {_uniqueStorage()._optionalPublicImportMessage = newValue} + } + /// Returns true if `optionalPublicImportMessage` has been explicitly set. + var hasOptionalPublicImportMessage: Bool {_storage._optionalPublicImportMessage != nil} + /// Clears the value of `optionalPublicImportMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalPublicImportMessage() {_uniqueStorage()._optionalPublicImportMessage = nil} + + var optionalLazyMessage: Proto2Unittest_TestAllTypes.NestedMessage { + get {_storage._optionalLazyMessage ?? Proto2Unittest_TestAllTypes.NestedMessage()} + set {_uniqueStorage()._optionalLazyMessage = newValue} + } + /// Returns true if `optionalLazyMessage` has been explicitly set. + var hasOptionalLazyMessage: Bool {_storage._optionalLazyMessage != nil} + /// Clears the value of `optionalLazyMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalLazyMessage() {_uniqueStorage()._optionalLazyMessage = nil} + + var optionalUnverifiedLazyMessage: Proto2Unittest_TestAllTypes.NestedMessage { + get {_storage._optionalUnverifiedLazyMessage ?? Proto2Unittest_TestAllTypes.NestedMessage()} + set {_uniqueStorage()._optionalUnverifiedLazyMessage = newValue} + } + /// Returns true if `optionalUnverifiedLazyMessage` has been explicitly set. + var hasOptionalUnverifiedLazyMessage: Bool {_storage._optionalUnverifiedLazyMessage != nil} + /// Clears the value of `optionalUnverifiedLazyMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalUnverifiedLazyMessage() {_uniqueStorage()._optionalUnverifiedLazyMessage = nil} + + /// Repeated + var repeatedInt32: [Int32] { + get {_storage._repeatedInt32} + set {_uniqueStorage()._repeatedInt32 = newValue} + } + + var repeatedInt64: [Int64] { + get {_storage._repeatedInt64} + set {_uniqueStorage()._repeatedInt64 = newValue} + } + + var repeatedUint32: [UInt32] { + get {_storage._repeatedUint32} + set {_uniqueStorage()._repeatedUint32 = newValue} + } + + var repeatedUint64: [UInt64] { + get {_storage._repeatedUint64} + set {_uniqueStorage()._repeatedUint64 = newValue} + } + + var repeatedSint32: [Int32] { + get {_storage._repeatedSint32} + set {_uniqueStorage()._repeatedSint32 = newValue} + } + + var repeatedSint64: [Int64] { + get {_storage._repeatedSint64} + set {_uniqueStorage()._repeatedSint64 = newValue} + } + + var repeatedFixed32: [UInt32] { + get {_storage._repeatedFixed32} + set {_uniqueStorage()._repeatedFixed32 = newValue} + } + + var repeatedFixed64: [UInt64] { + get {_storage._repeatedFixed64} + set {_uniqueStorage()._repeatedFixed64 = newValue} + } + + var repeatedSfixed32: [Int32] { + get {_storage._repeatedSfixed32} + set {_uniqueStorage()._repeatedSfixed32 = newValue} + } + + var repeatedSfixed64: [Int64] { + get {_storage._repeatedSfixed64} + set {_uniqueStorage()._repeatedSfixed64 = newValue} + } + + var repeatedFloat: [Float] { + get {_storage._repeatedFloat} + set {_uniqueStorage()._repeatedFloat = newValue} + } + + var repeatedDouble: [Double] { + get {_storage._repeatedDouble} + set {_uniqueStorage()._repeatedDouble = newValue} + } + + var repeatedBool: [Bool] { + get {_storage._repeatedBool} + set {_uniqueStorage()._repeatedBool = newValue} + } + + var repeatedString: [String] { + get {_storage._repeatedString} + set {_uniqueStorage()._repeatedString = newValue} + } + + var repeatedBytes: [Data] { + get {_storage._repeatedBytes} + set {_uniqueStorage()._repeatedBytes = newValue} + } + + var repeatedGroup: [Proto2Unittest_TestAllTypes.RepeatedGroup] { + get {_storage._repeatedGroup} + set {_uniqueStorage()._repeatedGroup = newValue} + } + + var repeatedNestedMessage: [Proto2Unittest_TestAllTypes.NestedMessage] { + get {_storage._repeatedNestedMessage} + set {_uniqueStorage()._repeatedNestedMessage = newValue} + } + + var repeatedForeignMessage: [Proto2Unittest_ForeignMessage] { + get {_storage._repeatedForeignMessage} + set {_uniqueStorage()._repeatedForeignMessage = newValue} + } + + var repeatedImportMessage: [Proto2UnittestImport_ImportMessage] { + get {_storage._repeatedImportMessage} + set {_uniqueStorage()._repeatedImportMessage = newValue} + } + + var repeatedNestedEnum: [Proto2Unittest_TestAllTypes.NestedEnum] { + get {_storage._repeatedNestedEnum} + set {_uniqueStorage()._repeatedNestedEnum = newValue} + } + + var repeatedForeignEnum: [Proto2Unittest_ForeignEnum] { + get {_storage._repeatedForeignEnum} + set {_uniqueStorage()._repeatedForeignEnum = newValue} + } + + var repeatedImportEnum: [Proto2UnittestImport_ImportEnum] { + get {_storage._repeatedImportEnum} + set {_uniqueStorage()._repeatedImportEnum = newValue} + } + + var repeatedStringPiece: [String] { + get {_storage._repeatedStringPiece} + set {_uniqueStorage()._repeatedStringPiece = newValue} + } + + var repeatedCord: [String] { + get {_storage._repeatedCord} + set {_uniqueStorage()._repeatedCord = newValue} + } + + var repeatedLazyMessage: [Proto2Unittest_TestAllTypes.NestedMessage] { + get {_storage._repeatedLazyMessage} + set {_uniqueStorage()._repeatedLazyMessage = newValue} + } + + /// Singular with defaults + var defaultInt32: Int32 { + get {_storage._defaultInt32 ?? 41} + set {_uniqueStorage()._defaultInt32 = newValue} + } + /// Returns true if `defaultInt32` has been explicitly set. + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} + /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} + + var defaultInt64: Int64 { + get {_storage._defaultInt64 ?? 42} + set {_uniqueStorage()._defaultInt64 = newValue} + } + /// Returns true if `defaultInt64` has been explicitly set. + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} + /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} + + var defaultUint32: UInt32 { + get {_storage._defaultUint32 ?? 43} + set {_uniqueStorage()._defaultUint32 = newValue} + } + /// Returns true if `defaultUint32` has been explicitly set. + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} + /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} + + var defaultUint64: UInt64 { + get {_storage._defaultUint64 ?? 44} + set {_uniqueStorage()._defaultUint64 = newValue} + } + /// Returns true if `defaultUint64` has been explicitly set. + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} + /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} + + var defaultSint32: Int32 { + get {_storage._defaultSint32 ?? -45} + set {_uniqueStorage()._defaultSint32 = newValue} + } + /// Returns true if `defaultSint32` has been explicitly set. + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} + /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} + + var defaultSint64: Int64 { + get {_storage._defaultSint64 ?? 46} + set {_uniqueStorage()._defaultSint64 = newValue} + } + /// Returns true if `defaultSint64` has been explicitly set. + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} + /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} + + var defaultFixed32: UInt32 { + get {_storage._defaultFixed32 ?? 47} + set {_uniqueStorage()._defaultFixed32 = newValue} + } + /// Returns true if `defaultFixed32` has been explicitly set. + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} + /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} + + var defaultFixed64: UInt64 { + get {_storage._defaultFixed64 ?? 48} + set {_uniqueStorage()._defaultFixed64 = newValue} + } + /// Returns true if `defaultFixed64` has been explicitly set. + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} + /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} + + var defaultSfixed32: Int32 { + get {_storage._defaultSfixed32 ?? 49} + set {_uniqueStorage()._defaultSfixed32 = newValue} + } + /// Returns true if `defaultSfixed32` has been explicitly set. + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} + /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} + + var defaultSfixed64: Int64 { + get {_storage._defaultSfixed64 ?? -50} + set {_uniqueStorage()._defaultSfixed64 = newValue} + } + /// Returns true if `defaultSfixed64` has been explicitly set. + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} + /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} + + var defaultFloat: Float { + get {_storage._defaultFloat ?? 51.5} + set {_uniqueStorage()._defaultFloat = newValue} + } + /// Returns true if `defaultFloat` has been explicitly set. + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} + /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. + mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} + + var defaultDouble: Double { + get {_storage._defaultDouble ?? 52000} + set {_uniqueStorage()._defaultDouble = newValue} + } + /// Returns true if `defaultDouble` has been explicitly set. + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} + /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. + mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} + + var defaultBool: Bool { + get {_storage._defaultBool ?? true} + set {_uniqueStorage()._defaultBool = newValue} + } + /// Returns true if `defaultBool` has been explicitly set. + var hasDefaultBool: Bool {_storage._defaultBool != nil} + /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. + mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} + + var defaultString: String { + get {_storage._defaultString ?? "hello"} + set {_uniqueStorage()._defaultString = newValue} + } + /// Returns true if `defaultString` has been explicitly set. + var hasDefaultString: Bool {_storage._defaultString != nil} + /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. + mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} + + var defaultBytes: Data { + get {_storage._defaultBytes ?? Data([119, 111, 114, 108, 100])} + set {_uniqueStorage()._defaultBytes = newValue} + } + /// Returns true if `defaultBytes` has been explicitly set. + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} + /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. + mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} + + var defaultNestedEnum: Proto2Unittest_TestAllTypes.NestedEnum { + get {_storage._defaultNestedEnum ?? .bar} + set {_uniqueStorage()._defaultNestedEnum = newValue} + } + /// Returns true if `defaultNestedEnum` has been explicitly set. + var hasDefaultNestedEnum: Bool {_storage._defaultNestedEnum != nil} + /// Clears the value of `defaultNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearDefaultNestedEnum() {_uniqueStorage()._defaultNestedEnum = nil} + + var defaultForeignEnum: Proto2Unittest_ForeignEnum { + get {_storage._defaultForeignEnum ?? .foreignBar} + set {_uniqueStorage()._defaultForeignEnum = newValue} + } + /// Returns true if `defaultForeignEnum` has been explicitly set. + var hasDefaultForeignEnum: Bool {_storage._defaultForeignEnum != nil} + /// Clears the value of `defaultForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearDefaultForeignEnum() {_uniqueStorage()._defaultForeignEnum = nil} + + var defaultImportEnum: Proto2UnittestImport_ImportEnum { + get {_storage._defaultImportEnum ?? .importBar} + set {_uniqueStorage()._defaultImportEnum = newValue} + } + /// Returns true if `defaultImportEnum` has been explicitly set. + var hasDefaultImportEnum: Bool {_storage._defaultImportEnum != nil} + /// Clears the value of `defaultImportEnum`. Subsequent reads from it will return its default value. + mutating func clearDefaultImportEnum() {_uniqueStorage()._defaultImportEnum = nil} + + var defaultStringPiece: String { + get {_storage._defaultStringPiece ?? "abc"} + set {_uniqueStorage()._defaultStringPiece = newValue} + } + /// Returns true if `defaultStringPiece` has been explicitly set. + var hasDefaultStringPiece: Bool {_storage._defaultStringPiece != nil} + /// Clears the value of `defaultStringPiece`. Subsequent reads from it will return its default value. + mutating func clearDefaultStringPiece() {_uniqueStorage()._defaultStringPiece = nil} + + var defaultCord: String { + get {_storage._defaultCord ?? "123"} + set {_uniqueStorage()._defaultCord = newValue} + } + /// Returns true if `defaultCord` has been explicitly set. + var hasDefaultCord: Bool {_storage._defaultCord != nil} + /// Clears the value of `defaultCord`. Subsequent reads from it will return its default value. + mutating func clearDefaultCord() {_uniqueStorage()._defaultCord = nil} + + /// For oneof test + var oneofField: OneOf_OneofField? { + get {return _storage._oneofField} + set {_uniqueStorage()._oneofField = newValue} + } + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} + } + + var oneofNestedMessage: Proto2Unittest_TestAllTypes.NestedMessage { + get { + if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} + return Proto2Unittest_TestAllTypes.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = _storage._oneofField {return v} + return Data() + } + set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} + } + + var oneofCord: String { + get { + if case .oneofCord(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofCord(newValue)} + } + + var oneofStringPiece: String { + get { + if case .oneofStringPiece(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofStringPiece(newValue)} + } + + var oneofLazyNestedMessage: Proto2Unittest_TestAllTypes.NestedMessage { + get { + if case .oneofLazyNestedMessage(let v)? = _storage._oneofField {return v} + return Proto2Unittest_TestAllTypes.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofLazyNestedMessage(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + /// For oneof test + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofNestedMessage(Proto2Unittest_TestAllTypes.NestedMessage) + case oneofString(String) + case oneofBytes(Data) + case oneofCord(String) + case oneofStringPiece(String) + case oneofLazyNestedMessage(Proto2Unittest_TestAllTypes.NestedMessage) + + } + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 1 + case bar = 2 + case baz = 3 + + /// Intentionally negative. + case neg = -1 + + init() { + self = .foo + } + + } + + struct NestedMessage: Sendable { + // 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. + + /// The field name "b" fails to compile in proto1 because it conflicts with + /// a local variable named "b" in one of the generated methods. Doh. + /// This file needs to compile in proto1 to test backwards-compatibility. + var bb: Int32 { + get {_bb ?? 0} + set {_bb = newValue} + } + /// Returns true if `bb` has been explicitly set. + var hasBb: Bool {self._bb != nil} + /// Clears the value of `bb`. Subsequent reads from it will return its default value. + mutating func clearBb() {self._bb = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _bb: Int32? = nil + } + + struct OptionalGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + struct RepeatedGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// This proto includes a recursively nested message. +struct Proto2Unittest_NestedTestAllTypes: @unchecked Sendable { + // 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 child: Proto2Unittest_NestedTestAllTypes { + get {_storage._child ?? Proto2Unittest_NestedTestAllTypes()} + set {_uniqueStorage()._child = newValue} + } + /// Returns true if `child` has been explicitly set. + var hasChild: Bool {_storage._child != nil} + /// Clears the value of `child`. Subsequent reads from it will return its default value. + mutating func clearChild() {_uniqueStorage()._child = nil} + + var payload: Proto2Unittest_TestAllTypes { + get {_storage._payload ?? Proto2Unittest_TestAllTypes()} + set {_uniqueStorage()._payload = newValue} + } + /// Returns true if `payload` has been explicitly set. + var hasPayload: Bool {_storage._payload != nil} + /// Clears the value of `payload`. Subsequent reads from it will return its default value. + mutating func clearPayload() {_uniqueStorage()._payload = nil} + + var repeatedChild: [Proto2Unittest_NestedTestAllTypes] { + get {_storage._repeatedChild} + set {_uniqueStorage()._repeatedChild = newValue} + } + + var lazyChild: Proto2Unittest_NestedTestAllTypes { + get {_storage._lazyChild ?? Proto2Unittest_NestedTestAllTypes()} + set {_uniqueStorage()._lazyChild = newValue} + } + /// Returns true if `lazyChild` has been explicitly set. + var hasLazyChild: Bool {_storage._lazyChild != nil} + /// Clears the value of `lazyChild`. Subsequent reads from it will return its default value. + mutating func clearLazyChild() {_uniqueStorage()._lazyChild = nil} + + var eagerChild: Proto2Unittest_TestAllTypes { + get {_storage._eagerChild ?? Proto2Unittest_TestAllTypes()} + set {_uniqueStorage()._eagerChild = newValue} + } + /// Returns true if `eagerChild` has been explicitly set. + var hasEagerChild: Bool {_storage._eagerChild != nil} + /// Clears the value of `eagerChild`. Subsequent reads from it will return its default value. + mutating func clearEagerChild() {_uniqueStorage()._eagerChild = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Proto2Unittest_TestDeprecatedFields: @unchecked Sendable { + // 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. + + /// NOTE: This field was marked as deprecated in the .proto file. + var deprecatedInt32: Int32 { + get {_storage._deprecatedInt32 ?? 0} + set {_uniqueStorage()._deprecatedInt32 = newValue} + } + /// Returns true if `deprecatedInt32` has been explicitly set. + var hasDeprecatedInt32: Bool {_storage._deprecatedInt32 != nil} + /// Clears the value of `deprecatedInt32`. Subsequent reads from it will return its default value. + mutating func clearDeprecatedInt32() {_uniqueStorage()._deprecatedInt32 = nil} + + /// NOTE: This field was marked as deprecated in the .proto file. + var deprecatedRepeatedString: [String] { + get {_storage._deprecatedRepeatedString} + set {_uniqueStorage()._deprecatedRepeatedString = newValue} + } + + /// NOTE: This field was marked as deprecated in the .proto file. + var deprecatedMessage: Proto2Unittest_TestAllTypes.NestedMessage { + get {_storage._deprecatedMessage ?? Proto2Unittest_TestAllTypes.NestedMessage()} + set {_uniqueStorage()._deprecatedMessage = newValue} + } + /// Returns true if `deprecatedMessage` has been explicitly set. + var hasDeprecatedMessage: Bool {_storage._deprecatedMessage != nil} + /// Clears the value of `deprecatedMessage`. Subsequent reads from it will return its default value. + mutating func clearDeprecatedMessage() {_uniqueStorage()._deprecatedMessage = nil} + + var oneofFields: OneOf_OneofFields? { + get {return _storage._oneofFields} + set {_uniqueStorage()._oneofFields = newValue} + } + + /// NOTE: This field was marked as deprecated in the .proto file. + var deprecatedInt32InOneof: Int32 { + get { + if case .deprecatedInt32InOneof(let v)? = _storage._oneofFields {return v} + return 0 + } + set {_uniqueStorage()._oneofFields = .deprecatedInt32InOneof(newValue)} + } + + var nested: Proto2Unittest_TestDeprecatedFields { + get {_storage._nested ?? Proto2Unittest_TestDeprecatedFields()} + set {_uniqueStorage()._nested = newValue} + } + /// Returns true if `nested` has been explicitly set. + var hasNested: Bool {_storage._nested != nil} + /// Clears the value of `nested`. Subsequent reads from it will return its default value. + mutating func clearNested() {_uniqueStorage()._nested = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofFields: Equatable, Sendable { + /// NOTE: This field was marked as deprecated in the .proto file. + case deprecatedInt32InOneof(Int32) + + } + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// NOTE: This message was marked as deprecated in the .proto file. +struct Proto2Unittest_TestDeprecatedMessage: Sendable { + // 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() {} +} + +/// Define these after TestAllTypes to make sure the compiler can handle +/// that. +struct Proto2Unittest_ForeignMessage: Sendable { + // 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 c: Int32 { + get {_c ?? 0} + set {_c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {self._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {self._c = nil} + + var d: Int32 { + get {_d ?? 0} + set {_d = newValue} + } + /// Returns true if `d` has been explicitly set. + var hasD: Bool {self._d != nil} + /// Clears the value of `d`. Subsequent reads from it will return its default value. + mutating func clearD() {self._d = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _c: Int32? = nil + fileprivate var _d: Int32? = nil +} + +struct Proto2Unittest_TestReservedFields: Sendable { + // 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 Proto2Unittest_TestAllExtensions: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +struct Proto2Unittest_OptionalGroup_extension: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil +} + +struct Proto2Unittest_RepeatedGroup_extension: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil +} + +struct Proto2Unittest_TestMixedFieldsAndExtensions: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: [UInt32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _a: Int32? = nil +} + +struct Proto2Unittest_TestGroup: Sendable { + // 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 optionalGroup: Proto2Unittest_TestGroup.OptionalGroup { + get {_optionalGroup ?? Proto2Unittest_TestGroup.OptionalGroup()} + set {_optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {self._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {self._optionalGroup = nil} + + var optionalForeignEnum: Proto2Unittest_ForeignEnum { + get {_optionalForeignEnum ?? .foreignFoo} + set {_optionalForeignEnum = newValue} + } + /// Returns true if `optionalForeignEnum` has been explicitly set. + var hasOptionalForeignEnum: Bool {self._optionalForeignEnum != nil} + /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignEnum() {self._optionalForeignEnum = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct OptionalGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + /// fast table size must be at least 16, for this + var zz: Int32 { + get {_zz ?? 0} + set {_zz = newValue} + } + /// Returns true if `zz` has been explicitly set. + var hasZz: Bool {self._zz != nil} + /// Clears the value of `zz`. Subsequent reads from it will return its default value. + mutating func clearZz() {self._zz = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _zz: Int32? = nil + } + + init() {} + + fileprivate var _optionalGroup: Proto2Unittest_TestGroup.OptionalGroup? = nil + fileprivate var _optionalForeignEnum: Proto2Unittest_ForeignEnum? = nil +} + +struct Proto2Unittest_TestGroupExtension: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +struct Proto2Unittest_TestNestedExtension: Sendable { + // 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() + + struct OptionalGroup_extension: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + init() {} +} + +struct Proto2Unittest_TestChildExtension: Sendable { + // 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 a: String { + get {_a ?? String()} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: String { + get {_b ?? String()} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var optionalExtension: Proto2Unittest_TestAllExtensions { + get {_optionalExtension ?? Proto2Unittest_TestAllExtensions()} + set {_optionalExtension = newValue} + } + /// Returns true if `optionalExtension` has been explicitly set. + var hasOptionalExtension: Bool {self._optionalExtension != nil} + /// Clears the value of `optionalExtension`. Subsequent reads from it will return its default value. + mutating func clearOptionalExtension() {self._optionalExtension = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: String? = nil + fileprivate var _b: String? = nil + fileprivate var _optionalExtension: Proto2Unittest_TestAllExtensions? = nil +} + +/// Emulates wireformat data of TestChildExtension with dynamic extension +/// (DynamicExtension). +struct Proto2Unittest_TestChildExtensionData: Sendable { + // 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 a: String { + get {_a ?? String()} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: String { + get {_b ?? String()} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var optionalExtension: Proto2Unittest_TestChildExtensionData.NestedTestAllExtensionsData { + get {_optionalExtension ?? Proto2Unittest_TestChildExtensionData.NestedTestAllExtensionsData()} + set {_optionalExtension = newValue} + } + /// Returns true if `optionalExtension` has been explicitly set. + var hasOptionalExtension: Bool {self._optionalExtension != nil} + /// Clears the value of `optionalExtension`. Subsequent reads from it will return its default value. + mutating func clearOptionalExtension() {self._optionalExtension = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct NestedTestAllExtensionsData: Sendable { + // 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 dynamic: Proto2Unittest_TestChildExtensionData.NestedTestAllExtensionsData.NestedDynamicExtensions { + get {_dynamic ?? Proto2Unittest_TestChildExtensionData.NestedTestAllExtensionsData.NestedDynamicExtensions()} + set {_dynamic = newValue} + } + /// Returns true if `dynamic` has been explicitly set. + var hasDynamic: Bool {self._dynamic != nil} + /// Clears the value of `dynamic`. Subsequent reads from it will return its default value. + mutating func clearDynamic() {self._dynamic = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct NestedDynamicExtensions: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil + } + + init() {} + + fileprivate var _dynamic: Proto2Unittest_TestChildExtensionData.NestedTestAllExtensionsData.NestedDynamicExtensions? = nil + } + + init() {} + + fileprivate var _a: String? = nil + fileprivate var _b: String? = nil + fileprivate var _optionalExtension: Proto2Unittest_TestChildExtensionData.NestedTestAllExtensionsData? = nil +} + +struct Proto2Unittest_TestNestedChildExtension: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var child: Proto2Unittest_TestChildExtension { + get {_child ?? Proto2Unittest_TestChildExtension()} + set {_child = newValue} + } + /// Returns true if `child` has been explicitly set. + var hasChild: Bool {self._child != nil} + /// Clears the value of `child`. Subsequent reads from it will return its default value. + mutating func clearChild() {self._child = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _child: Proto2Unittest_TestChildExtension? = nil +} + +/// Emulates wireformat data of TestNestedChildExtension with dynamic extension +/// (DynamicExtension). +struct Proto2Unittest_TestNestedChildExtensionData: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var child: Proto2Unittest_TestChildExtensionData { + get {_child ?? Proto2Unittest_TestChildExtensionData()} + set {_child = newValue} + } + /// Returns true if `child` has been explicitly set. + var hasChild: Bool {self._child != nil} + /// Clears the value of `child`. Subsequent reads from it will return its default value. + mutating func clearChild() {self._child = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _child: Proto2Unittest_TestChildExtensionData? = nil +} + +/// Required and closed enum fields are considered unknown fields if the value is +/// not valid. We need to make sure it functions as expected. +struct Proto2Unittest_TestRequiredEnum: Sendable { + // 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 requiredEnum: Proto2Unittest_ForeignEnum { + get {_requiredEnum ?? .foreignFoo} + set {_requiredEnum = newValue} + } + /// Returns true if `requiredEnum` has been explicitly set. + var hasRequiredEnum: Bool {self._requiredEnum != nil} + /// Clears the value of `requiredEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum() {self._requiredEnum = nil} + + /// A dummy optional field. + var a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _requiredEnum: Proto2Unittest_ForeignEnum? = nil + fileprivate var _a: Int32? = nil +} + +struct Proto2Unittest_TestRequiredOpenEnum: Sendable { + // 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 requiredEnum: Proto2Unittest_ForeignOpenEnum { + get {_requiredEnum ?? .foreignOpenUnknown} + set {_requiredEnum = newValue} + } + /// Returns true if `requiredEnum` has been explicitly set. + var hasRequiredEnum: Bool {self._requiredEnum != nil} + /// Clears the value of `requiredEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum() {self._requiredEnum = nil} + + /// A dummy optional field. + var a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _requiredEnum: Proto2Unittest_ForeignOpenEnum? = nil + fileprivate var _a: Int32? = nil +} + +/// TestRequiredEnum + using enum values that won't fit to 64 bitmask. +struct Proto2Unittest_TestRequiredEnumNoMask: Sendable { + // 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 requiredEnum: Proto2Unittest_TestRequiredEnumNoMask.NestedEnum { + get {_requiredEnum ?? .unspecified} + set {_requiredEnum = newValue} + } + /// Returns true if `requiredEnum` has been explicitly set. + var hasRequiredEnum: Bool {self._requiredEnum != nil} + /// Clears the value of `requiredEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum() {self._requiredEnum = nil} + + /// A dummy optional field. + var a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unspecified = 0 + case foo = 2 + case bar = 100 + + /// Intentionally negative. + case baz = -1 + + init() { + self = .unspecified + } + + } + + init() {} + + fileprivate var _requiredEnum: Proto2Unittest_TestRequiredEnumNoMask.NestedEnum? = nil + fileprivate var _a: Int32? = nil +} + +struct Proto2Unittest_TestRequiredEnumMulti: Sendable { + // 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. + + /// Intentionally placed in descending field number to force sorting in closed + /// enum verification. + var requiredEnum4: Proto2Unittest_TestRequiredEnumMulti.NestedEnum { + get {_requiredEnum4 ?? .unspecified} + set {_requiredEnum4 = newValue} + } + /// Returns true if `requiredEnum4` has been explicitly set. + var hasRequiredEnum4: Bool {self._requiredEnum4 != nil} + /// Clears the value of `requiredEnum4`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum4() {self._requiredEnum4 = nil} + + var a3: Int32 { + get {_a3 ?? 0} + set {_a3 = newValue} + } + /// Returns true if `a3` has been explicitly set. + var hasA3: Bool {self._a3 != nil} + /// Clears the value of `a3`. Subsequent reads from it will return its default value. + mutating func clearA3() {self._a3 = nil} + + var requiredEnum2: Proto2Unittest_TestRequiredEnumMulti.NestedEnum { + get {_requiredEnum2 ?? .unspecified} + set {_requiredEnum2 = newValue} + } + /// Returns true if `requiredEnum2` has been explicitly set. + var hasRequiredEnum2: Bool {self._requiredEnum2 != nil} + /// Clears the value of `requiredEnum2`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum2() {self._requiredEnum2 = nil} + + var requiredEnum1: Proto2Unittest_ForeignEnum { + get {_requiredEnum1 ?? .foreignFoo} + set {_requiredEnum1 = newValue} + } + /// Returns true if `requiredEnum1` has been explicitly set. + var hasRequiredEnum1: Bool {self._requiredEnum1 != nil} + /// Clears the value of `requiredEnum1`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum1() {self._requiredEnum1 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unspecified = 0 + case foo = 1 + case bar = 2 + case baz = 100 + + init() { + self = .unspecified + } + + } + + init() {} + + fileprivate var _requiredEnum4: Proto2Unittest_TestRequiredEnumMulti.NestedEnum? = nil + fileprivate var _a3: Int32? = nil + fileprivate var _requiredEnum2: Proto2Unittest_TestRequiredEnumMulti.NestedEnum? = nil + fileprivate var _requiredEnum1: Proto2Unittest_ForeignEnum? = nil +} + +struct Proto2Unittest_TestRequiredNoMaskMulti: Sendable { + // 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. + + /// Intentionally placed in descending field number to force sorting in closed + /// enum verification. Also, using large field numbers to use tag only + /// matching for required fields. + var requiredFixed3280: UInt32 { + get {_requiredFixed3280 ?? 0} + set {_requiredFixed3280 = newValue} + } + /// Returns true if `requiredFixed3280` has been explicitly set. + var hasRequiredFixed3280: Bool {self._requiredFixed3280 != nil} + /// Clears the value of `requiredFixed3280`. Subsequent reads from it will return its default value. + mutating func clearRequiredFixed3280() {self._requiredFixed3280 = nil} + + var requiredFixed3270: UInt32 { + get {_requiredFixed3270 ?? 0} + set {_requiredFixed3270 = newValue} + } + /// Returns true if `requiredFixed3270` has been explicitly set. + var hasRequiredFixed3270: Bool {self._requiredFixed3270 != nil} + /// Clears the value of `requiredFixed3270`. Subsequent reads from it will return its default value. + mutating func clearRequiredFixed3270() {self._requiredFixed3270 = nil} + + var requiredEnum64: Proto2Unittest_TestRequiredNoMaskMulti.NestedEnum { + get {_requiredEnum64 ?? .unspecified} + set {_requiredEnum64 = newValue} + } + /// Returns true if `requiredEnum64` has been explicitly set. + var hasRequiredEnum64: Bool {self._requiredEnum64 != nil} + /// Clears the value of `requiredEnum64`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum64() {self._requiredEnum64 = nil} + + var requiredEnum4: Proto2Unittest_TestRequiredNoMaskMulti.NestedEnum { + get {_requiredEnum4 ?? .unspecified} + set {_requiredEnum4 = newValue} + } + /// Returns true if `requiredEnum4` has been explicitly set. + var hasRequiredEnum4: Bool {self._requiredEnum4 != nil} + /// Clears the value of `requiredEnum4`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum4() {self._requiredEnum4 = nil} + + var a3: Int32 { + get {_a3 ?? 0} + set {_a3 = newValue} + } + /// Returns true if `a3` has been explicitly set. + var hasA3: Bool {self._a3 != nil} + /// Clears the value of `a3`. Subsequent reads from it will return its default value. + mutating func clearA3() {self._a3 = nil} + + var requiredEnum2: Proto2Unittest_TestRequiredNoMaskMulti.NestedEnum { + get {_requiredEnum2 ?? .unspecified} + set {_requiredEnum2 = newValue} + } + /// Returns true if `requiredEnum2` has been explicitly set. + var hasRequiredEnum2: Bool {self._requiredEnum2 != nil} + /// Clears the value of `requiredEnum2`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum2() {self._requiredEnum2 = nil} + + var requiredEnum1: Proto2Unittest_ForeignEnum { + get {_requiredEnum1 ?? .foreignFoo} + set {_requiredEnum1 = newValue} + } + /// Returns true if `requiredEnum1` has been explicitly set. + var hasRequiredEnum1: Bool {self._requiredEnum1 != nil} + /// Clears the value of `requiredEnum1`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum1() {self._requiredEnum1 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unspecified = 0 + case foo = 1 + case bar = 2 + case baz = 100 + + init() { + self = .unspecified + } + + } + + init() {} + + fileprivate var _requiredFixed3280: UInt32? = nil + fileprivate var _requiredFixed3270: UInt32? = nil + fileprivate var _requiredEnum64: Proto2Unittest_TestRequiredNoMaskMulti.NestedEnum? = nil + fileprivate var _requiredEnum4: Proto2Unittest_TestRequiredNoMaskMulti.NestedEnum? = nil + fileprivate var _a3: Int32? = nil + fileprivate var _requiredEnum2: Proto2Unittest_TestRequiredNoMaskMulti.NestedEnum? = nil + fileprivate var _requiredEnum1: Proto2Unittest_ForeignEnum? = nil +} + +/// We have separate messages for testing required fields because it's +/// annoying to have to fill in required fields in TestProto in order to +/// do anything with it. Note that we don't need to test every type of +/// required filed because the code output is basically identical to +/// optional fields for all types. +struct Proto2Unittest_TestRequired: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var dummy2: Int32 { + get {_storage._dummy2 ?? 0} + set {_uniqueStorage()._dummy2 = newValue} + } + /// Returns true if `dummy2` has been explicitly set. + var hasDummy2: Bool {_storage._dummy2 != nil} + /// Clears the value of `dummy2`. Subsequent reads from it will return its default value. + mutating func clearDummy2() {_uniqueStorage()._dummy2 = nil} + + var b: Int32 { + get {_storage._b ?? 0} + set {_uniqueStorage()._b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {_storage._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {_uniqueStorage()._b = nil} + + /// Pad the field count to 32 so that we can test that IsInitialized() + /// properly checks multiple elements of has_bits_. + var dummy4: Int32 { + get {_storage._dummy4 ?? 0} + set {_uniqueStorage()._dummy4 = newValue} + } + /// Returns true if `dummy4` has been explicitly set. + var hasDummy4: Bool {_storage._dummy4 != nil} + /// Clears the value of `dummy4`. Subsequent reads from it will return its default value. + mutating func clearDummy4() {_uniqueStorage()._dummy4 = nil} + + var dummy5: Int32 { + get {_storage._dummy5 ?? 0} + set {_uniqueStorage()._dummy5 = newValue} + } + /// Returns true if `dummy5` has been explicitly set. + var hasDummy5: Bool {_storage._dummy5 != nil} + /// Clears the value of `dummy5`. Subsequent reads from it will return its default value. + mutating func clearDummy5() {_uniqueStorage()._dummy5 = nil} + + var dummy6: Int32 { + get {_storage._dummy6 ?? 0} + set {_uniqueStorage()._dummy6 = newValue} + } + /// Returns true if `dummy6` has been explicitly set. + var hasDummy6: Bool {_storage._dummy6 != nil} + /// Clears the value of `dummy6`. Subsequent reads from it will return its default value. + mutating func clearDummy6() {_uniqueStorage()._dummy6 = nil} + + var dummy7: Int32 { + get {_storage._dummy7 ?? 0} + set {_uniqueStorage()._dummy7 = newValue} + } + /// Returns true if `dummy7` has been explicitly set. + var hasDummy7: Bool {_storage._dummy7 != nil} + /// Clears the value of `dummy7`. Subsequent reads from it will return its default value. + mutating func clearDummy7() {_uniqueStorage()._dummy7 = nil} + + var dummy8: Int32 { + get {_storage._dummy8 ?? 0} + set {_uniqueStorage()._dummy8 = newValue} + } + /// Returns true if `dummy8` has been explicitly set. + var hasDummy8: Bool {_storage._dummy8 != nil} + /// Clears the value of `dummy8`. Subsequent reads from it will return its default value. + mutating func clearDummy8() {_uniqueStorage()._dummy8 = nil} + + var dummy9: Int32 { + get {_storage._dummy9 ?? 0} + set {_uniqueStorage()._dummy9 = newValue} + } + /// Returns true if `dummy9` has been explicitly set. + var hasDummy9: Bool {_storage._dummy9 != nil} + /// Clears the value of `dummy9`. Subsequent reads from it will return its default value. + mutating func clearDummy9() {_uniqueStorage()._dummy9 = nil} + + var dummy10: Int32 { + get {_storage._dummy10 ?? 0} + set {_uniqueStorage()._dummy10 = newValue} + } + /// Returns true if `dummy10` has been explicitly set. + var hasDummy10: Bool {_storage._dummy10 != nil} + /// Clears the value of `dummy10`. Subsequent reads from it will return its default value. + mutating func clearDummy10() {_uniqueStorage()._dummy10 = nil} + + var dummy11: Int32 { + get {_storage._dummy11 ?? 0} + set {_uniqueStorage()._dummy11 = newValue} + } + /// Returns true if `dummy11` has been explicitly set. + var hasDummy11: Bool {_storage._dummy11 != nil} + /// Clears the value of `dummy11`. Subsequent reads from it will return its default value. + mutating func clearDummy11() {_uniqueStorage()._dummy11 = nil} + + var dummy12: Int32 { + get {_storage._dummy12 ?? 0} + set {_uniqueStorage()._dummy12 = newValue} + } + /// Returns true if `dummy12` has been explicitly set. + var hasDummy12: Bool {_storage._dummy12 != nil} + /// Clears the value of `dummy12`. Subsequent reads from it will return its default value. + mutating func clearDummy12() {_uniqueStorage()._dummy12 = nil} + + var dummy13: Int32 { + get {_storage._dummy13 ?? 0} + set {_uniqueStorage()._dummy13 = newValue} + } + /// Returns true if `dummy13` has been explicitly set. + var hasDummy13: Bool {_storage._dummy13 != nil} + /// Clears the value of `dummy13`. Subsequent reads from it will return its default value. + mutating func clearDummy13() {_uniqueStorage()._dummy13 = nil} + + var dummy14: Int32 { + get {_storage._dummy14 ?? 0} + set {_uniqueStorage()._dummy14 = newValue} + } + /// Returns true if `dummy14` has been explicitly set. + var hasDummy14: Bool {_storage._dummy14 != nil} + /// Clears the value of `dummy14`. Subsequent reads from it will return its default value. + mutating func clearDummy14() {_uniqueStorage()._dummy14 = nil} + + var dummy15: Int32 { + get {_storage._dummy15 ?? 0} + set {_uniqueStorage()._dummy15 = newValue} + } + /// Returns true if `dummy15` has been explicitly set. + var hasDummy15: Bool {_storage._dummy15 != nil} + /// Clears the value of `dummy15`. Subsequent reads from it will return its default value. + mutating func clearDummy15() {_uniqueStorage()._dummy15 = nil} + + var dummy16: Int32 { + get {_storage._dummy16 ?? 0} + set {_uniqueStorage()._dummy16 = newValue} + } + /// Returns true if `dummy16` has been explicitly set. + var hasDummy16: Bool {_storage._dummy16 != nil} + /// Clears the value of `dummy16`. Subsequent reads from it will return its default value. + mutating func clearDummy16() {_uniqueStorage()._dummy16 = nil} + + var dummy17: Int32 { + get {_storage._dummy17 ?? 0} + set {_uniqueStorage()._dummy17 = newValue} + } + /// Returns true if `dummy17` has been explicitly set. + var hasDummy17: Bool {_storage._dummy17 != nil} + /// Clears the value of `dummy17`. Subsequent reads from it will return its default value. + mutating func clearDummy17() {_uniqueStorage()._dummy17 = nil} + + var dummy18: Int32 { + get {_storage._dummy18 ?? 0} + set {_uniqueStorage()._dummy18 = newValue} + } + /// Returns true if `dummy18` has been explicitly set. + var hasDummy18: Bool {_storage._dummy18 != nil} + /// Clears the value of `dummy18`. Subsequent reads from it will return its default value. + mutating func clearDummy18() {_uniqueStorage()._dummy18 = nil} + + var dummy19: Int32 { + get {_storage._dummy19 ?? 0} + set {_uniqueStorage()._dummy19 = newValue} + } + /// Returns true if `dummy19` has been explicitly set. + var hasDummy19: Bool {_storage._dummy19 != nil} + /// Clears the value of `dummy19`. Subsequent reads from it will return its default value. + mutating func clearDummy19() {_uniqueStorage()._dummy19 = nil} + + var dummy20: Int32 { + get {_storage._dummy20 ?? 0} + set {_uniqueStorage()._dummy20 = newValue} + } + /// Returns true if `dummy20` has been explicitly set. + var hasDummy20: Bool {_storage._dummy20 != nil} + /// Clears the value of `dummy20`. Subsequent reads from it will return its default value. + mutating func clearDummy20() {_uniqueStorage()._dummy20 = nil} + + var dummy21: Int32 { + get {_storage._dummy21 ?? 0} + set {_uniqueStorage()._dummy21 = newValue} + } + /// Returns true if `dummy21` has been explicitly set. + var hasDummy21: Bool {_storage._dummy21 != nil} + /// Clears the value of `dummy21`. Subsequent reads from it will return its default value. + mutating func clearDummy21() {_uniqueStorage()._dummy21 = nil} + + var dummy22: Int32 { + get {_storage._dummy22 ?? 0} + set {_uniqueStorage()._dummy22 = newValue} + } + /// Returns true if `dummy22` has been explicitly set. + var hasDummy22: Bool {_storage._dummy22 != nil} + /// Clears the value of `dummy22`. Subsequent reads from it will return its default value. + mutating func clearDummy22() {_uniqueStorage()._dummy22 = nil} + + var dummy23: Int32 { + get {_storage._dummy23 ?? 0} + set {_uniqueStorage()._dummy23 = newValue} + } + /// Returns true if `dummy23` has been explicitly set. + var hasDummy23: Bool {_storage._dummy23 != nil} + /// Clears the value of `dummy23`. Subsequent reads from it will return its default value. + mutating func clearDummy23() {_uniqueStorage()._dummy23 = nil} + + var dummy24: Int32 { + get {_storage._dummy24 ?? 0} + set {_uniqueStorage()._dummy24 = newValue} + } + /// Returns true if `dummy24` has been explicitly set. + var hasDummy24: Bool {_storage._dummy24 != nil} + /// Clears the value of `dummy24`. Subsequent reads from it will return its default value. + mutating func clearDummy24() {_uniqueStorage()._dummy24 = nil} + + var dummy25: Int32 { + get {_storage._dummy25 ?? 0} + set {_uniqueStorage()._dummy25 = newValue} + } + /// Returns true if `dummy25` has been explicitly set. + var hasDummy25: Bool {_storage._dummy25 != nil} + /// Clears the value of `dummy25`. Subsequent reads from it will return its default value. + mutating func clearDummy25() {_uniqueStorage()._dummy25 = nil} + + var dummy26: Int32 { + get {_storage._dummy26 ?? 0} + set {_uniqueStorage()._dummy26 = newValue} + } + /// Returns true if `dummy26` has been explicitly set. + var hasDummy26: Bool {_storage._dummy26 != nil} + /// Clears the value of `dummy26`. Subsequent reads from it will return its default value. + mutating func clearDummy26() {_uniqueStorage()._dummy26 = nil} + + var dummy27: Int32 { + get {_storage._dummy27 ?? 0} + set {_uniqueStorage()._dummy27 = newValue} + } + /// Returns true if `dummy27` has been explicitly set. + var hasDummy27: Bool {_storage._dummy27 != nil} + /// Clears the value of `dummy27`. Subsequent reads from it will return its default value. + mutating func clearDummy27() {_uniqueStorage()._dummy27 = nil} + + var dummy28: Int32 { + get {_storage._dummy28 ?? 0} + set {_uniqueStorage()._dummy28 = newValue} + } + /// Returns true if `dummy28` has been explicitly set. + var hasDummy28: Bool {_storage._dummy28 != nil} + /// Clears the value of `dummy28`. Subsequent reads from it will return its default value. + mutating func clearDummy28() {_uniqueStorage()._dummy28 = nil} + + var dummy29: Int32 { + get {_storage._dummy29 ?? 0} + set {_uniqueStorage()._dummy29 = newValue} + } + /// Returns true if `dummy29` has been explicitly set. + var hasDummy29: Bool {_storage._dummy29 != nil} + /// Clears the value of `dummy29`. Subsequent reads from it will return its default value. + mutating func clearDummy29() {_uniqueStorage()._dummy29 = nil} + + var dummy30: Int32 { + get {_storage._dummy30 ?? 0} + set {_uniqueStorage()._dummy30 = newValue} + } + /// Returns true if `dummy30` has been explicitly set. + var hasDummy30: Bool {_storage._dummy30 != nil} + /// Clears the value of `dummy30`. Subsequent reads from it will return its default value. + mutating func clearDummy30() {_uniqueStorage()._dummy30 = nil} + + var dummy31: Int32 { + get {_storage._dummy31 ?? 0} + set {_uniqueStorage()._dummy31 = newValue} + } + /// Returns true if `dummy31` has been explicitly set. + var hasDummy31: Bool {_storage._dummy31 != nil} + /// Clears the value of `dummy31`. Subsequent reads from it will return its default value. + mutating func clearDummy31() {_uniqueStorage()._dummy31 = nil} + + var dummy32: Int32 { + get {_storage._dummy32 ?? 0} + set {_uniqueStorage()._dummy32 = newValue} + } + /// Returns true if `dummy32` has been explicitly set. + var hasDummy32: Bool {_storage._dummy32 != nil} + /// Clears the value of `dummy32`. Subsequent reads from it will return its default value. + mutating func clearDummy32() {_uniqueStorage()._dummy32 = nil} + + var c: Int32 { + get {_storage._c ?? 0} + set {_uniqueStorage()._c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {_storage._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {_uniqueStorage()._c = nil} + + /// Add an optional child message to make this non-trivial for go/pdlazy. + var optionalForeign: Proto2Unittest_ForeignMessage { + get {_storage._optionalForeign ?? Proto2Unittest_ForeignMessage()} + set {_uniqueStorage()._optionalForeign = newValue} + } + /// Returns true if `optionalForeign` has been explicitly set. + var hasOptionalForeign: Bool {_storage._optionalForeign != nil} + /// Clears the value of `optionalForeign`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeign() {_uniqueStorage()._optionalForeign = nil} + + var mapField: Dictionary { + get {_storage._mapField} + set {_uniqueStorage()._mapField = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Proto2Unittest_TestRequiredForeign: Sendable { + // 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 optionalMessage: Proto2Unittest_TestRequired { + get {_optionalMessage ?? Proto2Unittest_TestRequired()} + set {_optionalMessage = newValue} + } + /// Returns true if `optionalMessage` has been explicitly set. + var hasOptionalMessage: Bool {self._optionalMessage != nil} + /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalMessage() {self._optionalMessage = nil} + + var repeatedMessage: [Proto2Unittest_TestRequired] = [] + + var dummy: Int32 { + get {_dummy ?? 0} + set {_dummy = newValue} + } + /// Returns true if `dummy` has been explicitly set. + var hasDummy: Bool {self._dummy != nil} + /// Clears the value of `dummy`. Subsequent reads from it will return its default value. + mutating func clearDummy() {self._dummy = nil} + + /// Missing required fields must not affect verification of child messages. + var optionalLazyMessage: Proto2Unittest_NestedTestAllTypes { + get {_optionalLazyMessage ?? Proto2Unittest_NestedTestAllTypes()} + set {_optionalLazyMessage = newValue} + } + /// Returns true if `optionalLazyMessage` has been explicitly set. + var hasOptionalLazyMessage: Bool {self._optionalLazyMessage != nil} + /// Clears the value of `optionalLazyMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalLazyMessage() {self._optionalLazyMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalMessage: Proto2Unittest_TestRequired? = nil + fileprivate var _dummy: Int32? = nil + fileprivate var _optionalLazyMessage: Proto2Unittest_NestedTestAllTypes? = nil +} + +struct Proto2Unittest_TestRequiredMessage: Sendable { + // 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 optionalMessage: Proto2Unittest_TestRequired { + get {_optionalMessage ?? Proto2Unittest_TestRequired()} + set {_optionalMessage = newValue} + } + /// Returns true if `optionalMessage` has been explicitly set. + var hasOptionalMessage: Bool {self._optionalMessage != nil} + /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalMessage() {self._optionalMessage = nil} + + var repeatedMessage: [Proto2Unittest_TestRequired] = [] + + var requiredMessage: Proto2Unittest_TestRequired { + get {_requiredMessage ?? Proto2Unittest_TestRequired()} + set {_requiredMessage = newValue} + } + /// Returns true if `requiredMessage` has been explicitly set. + var hasRequiredMessage: Bool {self._requiredMessage != nil} + /// Clears the value of `requiredMessage`. Subsequent reads from it will return its default value. + mutating func clearRequiredMessage() {self._requiredMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalMessage: Proto2Unittest_TestRequired? = nil + fileprivate var _requiredMessage: Proto2Unittest_TestRequired? = nil +} + +struct Proto2Unittest_TestRequiredLazyMessage: @unchecked Sendable { + // 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 child: Proto2Unittest_TestRequired { + get {_storage._child ?? Proto2Unittest_TestRequired()} + set {_uniqueStorage()._child = newValue} + } + /// Returns true if `child` has been explicitly set. + var hasChild: Bool {_storage._child != nil} + /// Clears the value of `child`. Subsequent reads from it will return its default value. + mutating func clearChild() {_uniqueStorage()._child = nil} + + var recurse: Proto2Unittest_TestRequiredLazyMessage { + get {_storage._recurse ?? Proto2Unittest_TestRequiredLazyMessage()} + set {_uniqueStorage()._recurse = newValue} + } + /// Returns true if `recurse` has been explicitly set. + var hasRecurse: Bool {_storage._recurse != nil} + /// Clears the value of `recurse`. Subsequent reads from it will return its default value. + mutating func clearRecurse() {_uniqueStorage()._recurse = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Proto2Unittest_TestNestedRequiredForeign: @unchecked Sendable { + // 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 child: Proto2Unittest_TestNestedRequiredForeign { + get {_storage._child ?? Proto2Unittest_TestNestedRequiredForeign()} + set {_uniqueStorage()._child = newValue} + } + /// Returns true if `child` has been explicitly set. + var hasChild: Bool {_storage._child != nil} + /// Clears the value of `child`. Subsequent reads from it will return its default value. + mutating func clearChild() {_uniqueStorage()._child = nil} + + var payload: Proto2Unittest_TestRequiredForeign { + get {_storage._payload ?? Proto2Unittest_TestRequiredForeign()} + set {_uniqueStorage()._payload = newValue} + } + /// Returns true if `payload` has been explicitly set. + var hasPayload: Bool {_storage._payload != nil} + /// Clears the value of `payload`. Subsequent reads from it will return its default value. + mutating func clearPayload() {_uniqueStorage()._payload = nil} + + var dummy: Int32 { + get {_storage._dummy ?? 0} + set {_uniqueStorage()._dummy = newValue} + } + /// Returns true if `dummy` has been explicitly set. + var hasDummy: Bool {_storage._dummy != nil} + /// Clears the value of `dummy`. Subsequent reads from it will return its default value. + mutating func clearDummy() {_uniqueStorage()._dummy = nil} + + /// optional message to test required closed enum. + var requiredEnum: Proto2Unittest_TestRequiredEnum { + get {_storage._requiredEnum ?? Proto2Unittest_TestRequiredEnum()} + set {_uniqueStorage()._requiredEnum = newValue} + } + /// Returns true if `requiredEnum` has been explicitly set. + var hasRequiredEnum: Bool {_storage._requiredEnum != nil} + /// Clears the value of `requiredEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnum() {_uniqueStorage()._requiredEnum = nil} + + var requiredEnumNoMask: Proto2Unittest_TestRequiredEnumNoMask { + get {_storage._requiredEnumNoMask ?? Proto2Unittest_TestRequiredEnumNoMask()} + set {_uniqueStorage()._requiredEnumNoMask = newValue} + } + /// Returns true if `requiredEnumNoMask` has been explicitly set. + var hasRequiredEnumNoMask: Bool {_storage._requiredEnumNoMask != nil} + /// Clears the value of `requiredEnumNoMask`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnumNoMask() {_uniqueStorage()._requiredEnumNoMask = nil} + + var requiredEnumMulti: Proto2Unittest_TestRequiredEnumMulti { + get {_storage._requiredEnumMulti ?? Proto2Unittest_TestRequiredEnumMulti()} + set {_uniqueStorage()._requiredEnumMulti = newValue} + } + /// Returns true if `requiredEnumMulti` has been explicitly set. + var hasRequiredEnumMulti: Bool {_storage._requiredEnumMulti != nil} + /// Clears the value of `requiredEnumMulti`. Subsequent reads from it will return its default value. + mutating func clearRequiredEnumMulti() {_uniqueStorage()._requiredEnumMulti = nil} + + var requiredNoMask: Proto2Unittest_TestRequiredNoMaskMulti { + get {_storage._requiredNoMask ?? Proto2Unittest_TestRequiredNoMaskMulti()} + set {_uniqueStorage()._requiredNoMask = newValue} + } + /// Returns true if `requiredNoMask` has been explicitly set. + var hasRequiredNoMask: Bool {_storage._requiredNoMask != nil} + /// Clears the value of `requiredNoMask`. Subsequent reads from it will return its default value. + mutating func clearRequiredNoMask() {_uniqueStorage()._requiredNoMask = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// Test that we can use NestedMessage from outside TestAllTypes. +struct Proto2Unittest_TestForeignNested: Sendable { + // 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 foreignNested: Proto2Unittest_TestAllTypes.NestedMessage { + get {_foreignNested ?? Proto2Unittest_TestAllTypes.NestedMessage()} + set {_foreignNested = newValue} + } + /// Returns true if `foreignNested` has been explicitly set. + var hasForeignNested: Bool {self._foreignNested != nil} + /// Clears the value of `foreignNested`. Subsequent reads from it will return its default value. + mutating func clearForeignNested() {self._foreignNested = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _foreignNested: Proto2Unittest_TestAllTypes.NestedMessage? = nil +} + +/// TestEmptyMessage is used to test unknown field support. +struct Proto2Unittest_TestEmptyMessage: Sendable { + // 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() {} +} + +/// Like above, but declare all field numbers as potential extensions. No +/// actual extensions should ever be defined for this type. +struct Proto2Unittest_TestEmptyMessageWithExtensions: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +/// Needed for a Python test. +struct Proto2Unittest_TestPickleNestedMessage: Sendable { + // 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() + + struct NestedMessage: Sendable { + // 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 bb: Int32 { + get {_bb ?? 0} + set {_bb = newValue} + } + /// Returns true if `bb` has been explicitly set. + var hasBb: Bool {self._bb != nil} + /// Clears the value of `bb`. Subsequent reads from it will return its default value. + mutating func clearBb() {self._bb = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct NestedNestedMessage: Sendable { + // 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 cc: Int32 { + get {_cc ?? 0} + set {_cc = newValue} + } + /// Returns true if `cc` has been explicitly set. + var hasCc: Bool {self._cc != nil} + /// Clears the value of `cc`. Subsequent reads from it will return its default value. + mutating func clearCc() {self._cc = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _cc: Int32? = nil + } + + init() {} + + fileprivate var _bb: Int32? = nil + } + + init() {} +} + +struct Proto2Unittest_TestMultipleExtensionRanges: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +/// Test that really large tag numbers don't break anything. +struct Proto2Unittest_TestReallyLargeTagNumber: Sendable { + // 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. + + /// The largest possible tag number is 2^28 - 1, since the wire format uses + /// three bits to communicate wire type. + var a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var bb: Int32 { + get {_bb ?? 0} + set {_bb = newValue} + } + /// Returns true if `bb` has been explicitly set. + var hasBb: Bool {self._bb != nil} + /// Clears the value of `bb`. Subsequent reads from it will return its default value. + mutating func clearBb() {self._bb = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _bb: Int32? = nil +} + +struct Proto2Unittest_TestRecursiveMessage: @unchecked Sendable { + // 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 a: Proto2Unittest_TestRecursiveMessage { + get {_storage._a ?? Proto2Unittest_TestRecursiveMessage()} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var i: Int32 { + get {_storage._i ?? 0} + set {_uniqueStorage()._i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {_storage._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {_uniqueStorage()._i = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// Test that mutual recursion works. +struct Proto2Unittest_TestMutualRecursionA: @unchecked Sendable { + // 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 bb: Proto2Unittest_TestMutualRecursionB { + get {_storage._bb ?? Proto2Unittest_TestMutualRecursionB()} + set {_uniqueStorage()._bb = newValue} + } + /// Returns true if `bb` has been explicitly set. + var hasBb: Bool {_storage._bb != nil} + /// Clears the value of `bb`. Subsequent reads from it will return its default value. + mutating func clearBb() {_uniqueStorage()._bb = nil} + + var subGroup: Proto2Unittest_TestMutualRecursionA.SubGroup { + get {_storage._subGroup ?? Proto2Unittest_TestMutualRecursionA.SubGroup()} + set {_uniqueStorage()._subGroup = newValue} + } + /// Returns true if `subGroup` has been explicitly set. + var hasSubGroup: Bool {_storage._subGroup != nil} + /// Clears the value of `subGroup`. Subsequent reads from it will return its default value. + mutating func clearSubGroup() {_uniqueStorage()._subGroup = nil} + + var subGroupR: [Proto2Unittest_TestMutualRecursionA.SubGroupR] { + get {_storage._subGroupR} + set {_uniqueStorage()._subGroupR = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct SubMessage: @unchecked Sendable { + // 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 b: Proto2Unittest_TestMutualRecursionB { + get {_storage._b ?? Proto2Unittest_TestMutualRecursionB()} + set {_uniqueStorage()._b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {_storage._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {_uniqueStorage()._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + struct SubGroup: @unchecked Sendable { + // 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. + + /// Needed because of bug in javatest + var subMessage: Proto2Unittest_TestMutualRecursionA.SubMessage { + get {_storage._subMessage ?? Proto2Unittest_TestMutualRecursionA.SubMessage()} + set {_uniqueStorage()._subMessage = newValue} + } + /// Returns true if `subMessage` has been explicitly set. + var hasSubMessage: Bool {_storage._subMessage != nil} + /// Clears the value of `subMessage`. Subsequent reads from it will return its default value. + mutating func clearSubMessage() {_uniqueStorage()._subMessage = nil} + + var notInThisScc: Proto2Unittest_TestAllTypes { + get {_storage._notInThisScc ?? Proto2Unittest_TestAllTypes()} + set {_uniqueStorage()._notInThisScc = newValue} + } + /// Returns true if `notInThisScc` has been explicitly set. + var hasNotInThisScc: Bool {_storage._notInThisScc != nil} + /// Clears the value of `notInThisScc`. Subsequent reads from it will return its default value. + mutating func clearNotInThisScc() {_uniqueStorage()._notInThisScc = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + struct SubGroupR: Sendable { + // 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 payload: Proto2Unittest_TestAllTypes { + get {_payload ?? Proto2Unittest_TestAllTypes()} + set {_payload = newValue} + } + /// Returns true if `payload` has been explicitly set. + var hasPayload: Bool {self._payload != nil} + /// Clears the value of `payload`. Subsequent reads from it will return its default value. + mutating func clearPayload() {self._payload = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _payload: Proto2Unittest_TestAllTypes? = nil + } + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Proto2Unittest_TestMutualRecursionB: @unchecked Sendable { + // 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 a: Proto2Unittest_TestMutualRecursionA { + get {_storage._a ?? Proto2Unittest_TestMutualRecursionA()} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var optionalInt32: Int32 { + get {_storage._optionalInt32 ?? 0} + set {_uniqueStorage()._optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Proto2Unittest_TestIsInitialized: Sendable { + // 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 subMessage: Proto2Unittest_TestIsInitialized.SubMessage { + get {_subMessage ?? Proto2Unittest_TestIsInitialized.SubMessage()} + set {_subMessage = newValue} + } + /// Returns true if `subMessage` has been explicitly set. + var hasSubMessage: Bool {self._subMessage != nil} + /// Clears the value of `subMessage`. Subsequent reads from it will return its default value. + mutating func clearSubMessage() {self._subMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct SubMessage: Sendable { + // 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 subGroup: Proto2Unittest_TestIsInitialized.SubMessage.SubGroup { + get {_subGroup ?? Proto2Unittest_TestIsInitialized.SubMessage.SubGroup()} + set {_subGroup = newValue} + } + /// Returns true if `subGroup` has been explicitly set. + var hasSubGroup: Bool {self._subGroup != nil} + /// Clears the value of `subGroup`. Subsequent reads from it will return its default value. + mutating func clearSubGroup() {self._subGroup = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct SubGroup: Sendable { + // 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 i: Int32 { + get {_i ?? 0} + set {_i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {self._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {self._i = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _i: Int32? = nil + } + + init() {} + + fileprivate var _subGroup: Proto2Unittest_TestIsInitialized.SubMessage.SubGroup? = nil + } + + init() {} + + fileprivate var _subMessage: Proto2Unittest_TestIsInitialized.SubMessage? = nil +} + +/// Test that groups have disjoint field numbers from their siblings and +/// parents. This is NOT possible in proto1; only google.protobuf. When attempting +/// to compile with proto1, this will emit an error; so we only include it +/// in proto2_unittest_proto. +struct Proto2Unittest_TestDupFieldNumber: Sendable { + // 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. + + /// NO_PROTO1 + var a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + /// NO_PROTO1 + var foo: Proto2Unittest_TestDupFieldNumber.Foo { + get {_foo ?? Proto2Unittest_TestDupFieldNumber.Foo()} + set {_foo = newValue} + } + /// Returns true if `foo` has been explicitly set. + var hasFoo: Bool {self._foo != nil} + /// Clears the value of `foo`. Subsequent reads from it will return its default value. + mutating func clearFoo() {self._foo = nil} + + /// NO_PROTO1 + var bar: Proto2Unittest_TestDupFieldNumber.Bar { + get {_bar ?? Proto2Unittest_TestDupFieldNumber.Bar()} + set {_bar = newValue} + } + /// Returns true if `bar` has been explicitly set. + var hasBar: Bool {self._bar != nil} + /// Clears the value of `bar`. Subsequent reads from it will return its default value. + mutating func clearBar() {self._bar = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + /// NO_PROTO1 + struct Foo: Sendable { + // 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. + + /// NO_PROTO1 + var a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + /// NO_PROTO1 + struct Bar: Sendable { + // 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. + + /// NO_PROTO1 + var a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _foo: Proto2Unittest_TestDupFieldNumber.Foo? = nil + fileprivate var _bar: Proto2Unittest_TestDupFieldNumber.Bar? = nil +} + +/// Additional messages for testing lazy fields. +struct Proto2Unittest_TestEagerMessage: Sendable { + // 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 subMessage: Proto2Unittest_TestAllTypes { + get {_subMessage ?? Proto2Unittest_TestAllTypes()} + set {_subMessage = newValue} + } + /// Returns true if `subMessage` has been explicitly set. + var hasSubMessage: Bool {self._subMessage != nil} + /// Clears the value of `subMessage`. Subsequent reads from it will return its default value. + mutating func clearSubMessage() {self._subMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _subMessage: Proto2Unittest_TestAllTypes? = nil +} + +struct Proto2Unittest_TestLazyMessage: Sendable { + // 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 subMessage: Proto2Unittest_TestAllTypes { + get {_subMessage ?? Proto2Unittest_TestAllTypes()} + set {_subMessage = newValue} + } + /// Returns true if `subMessage` has been explicitly set. + var hasSubMessage: Bool {self._subMessage != nil} + /// Clears the value of `subMessage`. Subsequent reads from it will return its default value. + mutating func clearSubMessage() {self._subMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _subMessage: Proto2Unittest_TestAllTypes? = nil +} + +struct Proto2Unittest_TestLazyRequiredEnum: @unchecked Sendable { + // 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 optionalRequiredOpenEnum: Proto2Unittest_TestRequiredOpenEnum { + get {_storage._optionalRequiredOpenEnum ?? Proto2Unittest_TestRequiredOpenEnum()} + set {_uniqueStorage()._optionalRequiredOpenEnum = newValue} + } + /// Returns true if `optionalRequiredOpenEnum` has been explicitly set. + var hasOptionalRequiredOpenEnum: Bool {_storage._optionalRequiredOpenEnum != nil} + /// Clears the value of `optionalRequiredOpenEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalRequiredOpenEnum() {_uniqueStorage()._optionalRequiredOpenEnum = nil} + + var optionalRequiredEnum: Proto2Unittest_TestRequiredEnum { + get {_storage._optionalRequiredEnum ?? Proto2Unittest_TestRequiredEnum()} + set {_uniqueStorage()._optionalRequiredEnum = newValue} + } + /// Returns true if `optionalRequiredEnum` has been explicitly set. + var hasOptionalRequiredEnum: Bool {_storage._optionalRequiredEnum != nil} + /// Clears the value of `optionalRequiredEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalRequiredEnum() {_uniqueStorage()._optionalRequiredEnum = nil} + + var optionalRequiredEnumNoMask: Proto2Unittest_TestRequiredEnumNoMask { + get {_storage._optionalRequiredEnumNoMask ?? Proto2Unittest_TestRequiredEnumNoMask()} + set {_uniqueStorage()._optionalRequiredEnumNoMask = newValue} + } + /// Returns true if `optionalRequiredEnumNoMask` has been explicitly set. + var hasOptionalRequiredEnumNoMask: Bool {_storage._optionalRequiredEnumNoMask != nil} + /// Clears the value of `optionalRequiredEnumNoMask`. Subsequent reads from it will return its default value. + mutating func clearOptionalRequiredEnumNoMask() {_uniqueStorage()._optionalRequiredEnumNoMask = nil} + + var optionalRequiredEnumMulti: Proto2Unittest_TestRequiredEnumMulti { + get {_storage._optionalRequiredEnumMulti ?? Proto2Unittest_TestRequiredEnumMulti()} + set {_uniqueStorage()._optionalRequiredEnumMulti = newValue} + } + /// Returns true if `optionalRequiredEnumMulti` has been explicitly set. + var hasOptionalRequiredEnumMulti: Bool {_storage._optionalRequiredEnumMulti != nil} + /// Clears the value of `optionalRequiredEnumMulti`. Subsequent reads from it will return its default value. + mutating func clearOptionalRequiredEnumMulti() {_uniqueStorage()._optionalRequiredEnumMulti = nil} + + var optionalRequiredNoMask: Proto2Unittest_TestRequiredNoMaskMulti { + get {_storage._optionalRequiredNoMask ?? Proto2Unittest_TestRequiredNoMaskMulti()} + set {_uniqueStorage()._optionalRequiredNoMask = newValue} + } + /// Returns true if `optionalRequiredNoMask` has been explicitly set. + var hasOptionalRequiredNoMask: Bool {_storage._optionalRequiredNoMask != nil} + /// Clears the value of `optionalRequiredNoMask`. Subsequent reads from it will return its default value. + mutating func clearOptionalRequiredNoMask() {_uniqueStorage()._optionalRequiredNoMask = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Proto2Unittest_TestLazyMessageRepeated: Sendable { + // 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 repeatedMessage: [Proto2Unittest_TestLazyMessage] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Proto2Unittest_TestEagerMaybeLazy: Sendable { + // 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 messageFoo: Proto2Unittest_TestAllTypes { + get {_messageFoo ?? Proto2Unittest_TestAllTypes()} + set {_messageFoo = newValue} + } + /// Returns true if `messageFoo` has been explicitly set. + var hasMessageFoo: Bool {self._messageFoo != nil} + /// Clears the value of `messageFoo`. Subsequent reads from it will return its default value. + mutating func clearMessageFoo() {self._messageFoo = nil} + + var messageBar: Proto2Unittest_TestAllTypes { + get {_messageBar ?? Proto2Unittest_TestAllTypes()} + set {_messageBar = newValue} + } + /// Returns true if `messageBar` has been explicitly set. + var hasMessageBar: Bool {self._messageBar != nil} + /// Clears the value of `messageBar`. Subsequent reads from it will return its default value. + mutating func clearMessageBar() {self._messageBar = nil} + + var messageBaz: Proto2Unittest_TestEagerMaybeLazy.NestedMessage { + get {_messageBaz ?? Proto2Unittest_TestEagerMaybeLazy.NestedMessage()} + set {_messageBaz = newValue} + } + /// Returns true if `messageBaz` has been explicitly set. + var hasMessageBaz: Bool {self._messageBaz != nil} + /// Clears the value of `messageBaz`. Subsequent reads from it will return its default value. + mutating func clearMessageBaz() {self._messageBaz = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct NestedMessage: Sendable { + // 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 packed: Proto2Unittest_TestPackedTypes { + get {_packed ?? Proto2Unittest_TestPackedTypes()} + set {_packed = newValue} + } + /// Returns true if `packed` has been explicitly set. + var hasPacked: Bool {self._packed != nil} + /// Clears the value of `packed`. Subsequent reads from it will return its default value. + mutating func clearPacked() {self._packed = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _packed: Proto2Unittest_TestPackedTypes? = nil + } + + init() {} + + fileprivate var _messageFoo: Proto2Unittest_TestAllTypes? = nil + fileprivate var _messageBar: Proto2Unittest_TestAllTypes? = nil + fileprivate var _messageBaz: Proto2Unittest_TestEagerMaybeLazy.NestedMessage? = nil +} + +/// Needed for a Python test. +struct Proto2Unittest_TestNestedMessageHasBits: Sendable { + // 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 optionalNestedMessage: Proto2Unittest_TestNestedMessageHasBits.NestedMessage { + get {_optionalNestedMessage ?? Proto2Unittest_TestNestedMessageHasBits.NestedMessage()} + set {_optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {self._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {self._optionalNestedMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct NestedMessage: Sendable { + // 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 nestedmessageRepeatedInt32: [Int32] = [] + + var nestedmessageRepeatedForeignmessage: [Proto2Unittest_ForeignMessage] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + init() {} + + fileprivate var _optionalNestedMessage: Proto2Unittest_TestNestedMessageHasBits.NestedMessage? = nil +} + +/// Test message with CamelCase field names. This violates Protocol Buffer +/// standard style. +struct Proto2Unittest_TestCamelCaseFieldNames: Sendable { + // 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 primitiveField: Int32 { + get {_primitiveField ?? 0} + set {_primitiveField = newValue} + } + /// Returns true if `primitiveField` has been explicitly set. + var hasPrimitiveField: Bool {self._primitiveField != nil} + /// Clears the value of `primitiveField`. Subsequent reads from it will return its default value. + mutating func clearPrimitiveField() {self._primitiveField = nil} + + var stringField: String { + get {_stringField ?? String()} + set {_stringField = newValue} + } + /// Returns true if `stringField` has been explicitly set. + var hasStringField: Bool {self._stringField != nil} + /// Clears the value of `stringField`. Subsequent reads from it will return its default value. + mutating func clearStringField() {self._stringField = nil} + + var enumField: Proto2Unittest_ForeignEnum { + get {_enumField ?? .foreignFoo} + set {_enumField = newValue} + } + /// Returns true if `enumField` has been explicitly set. + var hasEnumField: Bool {self._enumField != nil} + /// Clears the value of `enumField`. Subsequent reads from it will return its default value. + mutating func clearEnumField() {self._enumField = nil} + + var messageField: Proto2Unittest_ForeignMessage { + get {_messageField ?? Proto2Unittest_ForeignMessage()} + set {_messageField = newValue} + } + /// Returns true if `messageField` has been explicitly set. + var hasMessageField: Bool {self._messageField != nil} + /// Clears the value of `messageField`. Subsequent reads from it will return its default value. + mutating func clearMessageField() {self._messageField = nil} + + var stringPieceField: String { + get {_stringPieceField ?? String()} + set {_stringPieceField = newValue} + } + /// Returns true if `stringPieceField` has been explicitly set. + var hasStringPieceField: Bool {self._stringPieceField != nil} + /// Clears the value of `stringPieceField`. Subsequent reads from it will return its default value. + mutating func clearStringPieceField() {self._stringPieceField = nil} + + var cordField: String { + get {_cordField ?? String()} + set {_cordField = newValue} + } + /// Returns true if `cordField` has been explicitly set. + var hasCordField: Bool {self._cordField != nil} + /// Clears the value of `cordField`. Subsequent reads from it will return its default value. + mutating func clearCordField() {self._cordField = nil} + + var repeatedPrimitiveField: [Int32] = [] + + var repeatedStringField: [String] = [] + + var repeatedEnumField: [Proto2Unittest_ForeignEnum] = [] + + var repeatedMessageField: [Proto2Unittest_ForeignMessage] = [] + + var repeatedStringPieceField: [String] = [] + + var repeatedCordField: [String] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _primitiveField: Int32? = nil + fileprivate var _stringField: String? = nil + fileprivate var _enumField: Proto2Unittest_ForeignEnum? = nil + fileprivate var _messageField: Proto2Unittest_ForeignMessage? = nil + fileprivate var _stringPieceField: String? = nil + fileprivate var _cordField: String? = nil +} + +/// We list fields out of order, to ensure that we're using field number and not +/// field index to determine serialization order. +struct Proto2Unittest_TestFieldOrderings: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 myString: String { + get {_myString ?? String()} + set {_myString = newValue} + } + /// Returns true if `myString` has been explicitly set. + var hasMyString: Bool {self._myString != nil} + /// Clears the value of `myString`. Subsequent reads from it will return its default value. + mutating func clearMyString() {self._myString = nil} + + var myInt: Int64 { + get {_myInt ?? 0} + set {_myInt = newValue} + } + /// Returns true if `myInt` has been explicitly set. + var hasMyInt: Bool {self._myInt != nil} + /// Clears the value of `myInt`. Subsequent reads from it will return its default value. + mutating func clearMyInt() {self._myInt = nil} + + var myFloat: Float { + get {_myFloat ?? 0} + set {_myFloat = newValue} + } + /// Returns true if `myFloat` has been explicitly set. + var hasMyFloat: Bool {self._myFloat != nil} + /// Clears the value of `myFloat`. Subsequent reads from it will return its default value. + mutating func clearMyFloat() {self._myFloat = nil} + + var optionalNestedMessage: Proto2Unittest_TestFieldOrderings.NestedMessage { + get {_optionalNestedMessage ?? Proto2Unittest_TestFieldOrderings.NestedMessage()} + set {_optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {self._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {self._optionalNestedMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct NestedMessage: Sendable { + // 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 oo: Int64 { + get {_oo ?? 0} + set {_oo = newValue} + } + /// Returns true if `oo` has been explicitly set. + var hasOo: Bool {self._oo != nil} + /// Clears the value of `oo`. Subsequent reads from it will return its default value. + mutating func clearOo() {self._oo = nil} + + /// The field name "b" fails to compile in proto1 because it conflicts with + /// a local variable named "b" in one of the generated methods. Doh. + /// This file needs to compile in proto1 to test backwards-compatibility. + var bb: Int32 { + get {_bb ?? 0} + set {_bb = newValue} + } + /// Returns true if `bb` has been explicitly set. + var hasBb: Bool {self._bb != nil} + /// Clears the value of `bb`. Subsequent reads from it will return its default value. + mutating func clearBb() {self._bb = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _oo: Int64? = nil + fileprivate var _bb: Int32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _myString: String? = nil + fileprivate var _myInt: Int64? = nil + fileprivate var _myFloat: Float? = nil + fileprivate var _optionalNestedMessage: Proto2Unittest_TestFieldOrderings.NestedMessage? = nil +} + +struct Proto2Unittest_TestExtensionOrderings1: Sendable { + // 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 myString: String { + get {_myString ?? String()} + set {_myString = newValue} + } + /// Returns true if `myString` has been explicitly set. + var hasMyString: Bool {self._myString != nil} + /// Clears the value of `myString`. Subsequent reads from it will return its default value. + mutating func clearMyString() {self._myString = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _myString: String? = nil +} + +struct Proto2Unittest_TestExtensionOrderings2: Sendable { + // 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 myString: String { + get {_myString ?? String()} + set {_myString = newValue} + } + /// Returns true if `myString` has been explicitly set. + var hasMyString: Bool {self._myString != nil} + /// Clears the value of `myString`. Subsequent reads from it will return its default value. + mutating func clearMyString() {self._myString = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct TestExtensionOrderings3: Sendable { + // 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 myString: String { + get {_myString ?? String()} + set {_myString = newValue} + } + /// Returns true if `myString` has been explicitly set. + var hasMyString: Bool {self._myString != nil} + /// Clears the value of `myString`. Subsequent reads from it will return its default value. + mutating func clearMyString() {self._myString = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _myString: String? = nil + } + + init() {} + + fileprivate var _myString: String? = nil +} + +struct Proto2Unittest_TestExtremeDefaultValues: @unchecked Sendable { + // 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 escapedBytes: Data { + get {_storage._escapedBytes ?? Data([0, 1, 7, 8, 12, 10, 13, 9, 11, 92, 39, 34, 254])} + set {_uniqueStorage()._escapedBytes = newValue} + } + /// Returns true if `escapedBytes` has been explicitly set. + var hasEscapedBytes: Bool {_storage._escapedBytes != nil} + /// Clears the value of `escapedBytes`. Subsequent reads from it will return its default value. + mutating func clearEscapedBytes() {_uniqueStorage()._escapedBytes = nil} + + var largeUint32: UInt32 { + get {_storage._largeUint32 ?? 4294967295} + set {_uniqueStorage()._largeUint32 = newValue} + } + /// Returns true if `largeUint32` has been explicitly set. + var hasLargeUint32: Bool {_storage._largeUint32 != nil} + /// Clears the value of `largeUint32`. Subsequent reads from it will return its default value. + mutating func clearLargeUint32() {_uniqueStorage()._largeUint32 = nil} + + var largeUint64: UInt64 { + get {_storage._largeUint64 ?? 18446744073709551615} + set {_uniqueStorage()._largeUint64 = newValue} + } + /// Returns true if `largeUint64` has been explicitly set. + var hasLargeUint64: Bool {_storage._largeUint64 != nil} + /// Clears the value of `largeUint64`. Subsequent reads from it will return its default value. + mutating func clearLargeUint64() {_uniqueStorage()._largeUint64 = nil} + + var smallInt32: Int32 { + get {_storage._smallInt32 ?? -2147483647} + set {_uniqueStorage()._smallInt32 = newValue} + } + /// Returns true if `smallInt32` has been explicitly set. + var hasSmallInt32: Bool {_storage._smallInt32 != nil} + /// Clears the value of `smallInt32`. Subsequent reads from it will return its default value. + mutating func clearSmallInt32() {_uniqueStorage()._smallInt32 = nil} + + var smallInt64: Int64 { + get {_storage._smallInt64 ?? -9223372036854775807} + set {_uniqueStorage()._smallInt64 = newValue} + } + /// Returns true if `smallInt64` has been explicitly set. + var hasSmallInt64: Bool {_storage._smallInt64 != nil} + /// Clears the value of `smallInt64`. Subsequent reads from it will return its default value. + mutating func clearSmallInt64() {_uniqueStorage()._smallInt64 = nil} + + var reallySmallInt32: Int32 { + get {_storage._reallySmallInt32 ?? -2147483648} + set {_uniqueStorage()._reallySmallInt32 = newValue} + } + /// Returns true if `reallySmallInt32` has been explicitly set. + var hasReallySmallInt32: Bool {_storage._reallySmallInt32 != nil} + /// Clears the value of `reallySmallInt32`. Subsequent reads from it will return its default value. + mutating func clearReallySmallInt32() {_uniqueStorage()._reallySmallInt32 = nil} + + var reallySmallInt64: Int64 { + get {_storage._reallySmallInt64 ?? -9223372036854775808} + set {_uniqueStorage()._reallySmallInt64 = newValue} + } + /// Returns true if `reallySmallInt64` has been explicitly set. + var hasReallySmallInt64: Bool {_storage._reallySmallInt64 != nil} + /// Clears the value of `reallySmallInt64`. Subsequent reads from it will return its default value. + mutating func clearReallySmallInt64() {_uniqueStorage()._reallySmallInt64 = nil} + + /// The default value here is UTF-8 for "\u1234". (We could also just type + /// the UTF-8 text directly into this text file rather than escape it, but + /// lots of people use editors that would be confused by this.) + var utf8String: String { + get {_storage._utf8String ?? "ሴ"} + set {_uniqueStorage()._utf8String = newValue} + } + /// Returns true if `utf8String` has been explicitly set. + var hasUtf8String: Bool {_storage._utf8String != nil} + /// Clears the value of `utf8String`. Subsequent reads from it will return its default value. + mutating func clearUtf8String() {_uniqueStorage()._utf8String = nil} + + /// Tests for single-precision floating-point values. + var zeroFloat: Float { + get {_storage._zeroFloat ?? 0} + set {_uniqueStorage()._zeroFloat = newValue} + } + /// Returns true if `zeroFloat` has been explicitly set. + var hasZeroFloat: Bool {_storage._zeroFloat != nil} + /// Clears the value of `zeroFloat`. Subsequent reads from it will return its default value. + mutating func clearZeroFloat() {_uniqueStorage()._zeroFloat = nil} + + var oneFloat: Float { + get {_storage._oneFloat ?? 1} + set {_uniqueStorage()._oneFloat = newValue} + } + /// Returns true if `oneFloat` has been explicitly set. + var hasOneFloat: Bool {_storage._oneFloat != nil} + /// Clears the value of `oneFloat`. Subsequent reads from it will return its default value. + mutating func clearOneFloat() {_uniqueStorage()._oneFloat = nil} + + var smallFloat: Float { + get {_storage._smallFloat ?? 1.5} + set {_uniqueStorage()._smallFloat = newValue} + } + /// Returns true if `smallFloat` has been explicitly set. + var hasSmallFloat: Bool {_storage._smallFloat != nil} + /// Clears the value of `smallFloat`. Subsequent reads from it will return its default value. + mutating func clearSmallFloat() {_uniqueStorage()._smallFloat = nil} + + var negativeOneFloat: Float { + get {_storage._negativeOneFloat ?? -1} + set {_uniqueStorage()._negativeOneFloat = newValue} + } + /// Returns true if `negativeOneFloat` has been explicitly set. + var hasNegativeOneFloat: Bool {_storage._negativeOneFloat != nil} + /// Clears the value of `negativeOneFloat`. Subsequent reads from it will return its default value. + mutating func clearNegativeOneFloat() {_uniqueStorage()._negativeOneFloat = nil} + + var negativeFloat: Float { + get {_storage._negativeFloat ?? -1.5} + set {_uniqueStorage()._negativeFloat = newValue} + } + /// Returns true if `negativeFloat` has been explicitly set. + var hasNegativeFloat: Bool {_storage._negativeFloat != nil} + /// Clears the value of `negativeFloat`. Subsequent reads from it will return its default value. + mutating func clearNegativeFloat() {_uniqueStorage()._negativeFloat = nil} + + /// Using exponents + var largeFloat: Float { + get {_storage._largeFloat ?? 2e+08} + set {_uniqueStorage()._largeFloat = newValue} + } + /// Returns true if `largeFloat` has been explicitly set. + var hasLargeFloat: Bool {_storage._largeFloat != nil} + /// Clears the value of `largeFloat`. Subsequent reads from it will return its default value. + mutating func clearLargeFloat() {_uniqueStorage()._largeFloat = nil} + + var smallNegativeFloat: Float { + get {_storage._smallNegativeFloat ?? -8e-28} + set {_uniqueStorage()._smallNegativeFloat = newValue} + } + /// Returns true if `smallNegativeFloat` has been explicitly set. + var hasSmallNegativeFloat: Bool {_storage._smallNegativeFloat != nil} + /// Clears the value of `smallNegativeFloat`. Subsequent reads from it will return its default value. + mutating func clearSmallNegativeFloat() {_uniqueStorage()._smallNegativeFloat = nil} + + /// Text for nonfinite floating-point values. + var infDouble: Double { + get {_storage._infDouble ?? Double.infinity} + set {_uniqueStorage()._infDouble = newValue} + } + /// Returns true if `infDouble` has been explicitly set. + var hasInfDouble: Bool {_storage._infDouble != nil} + /// Clears the value of `infDouble`. Subsequent reads from it will return its default value. + mutating func clearInfDouble() {_uniqueStorage()._infDouble = nil} + + var negInfDouble: Double { + get {_storage._negInfDouble ?? -Double.infinity} + set {_uniqueStorage()._negInfDouble = newValue} + } + /// Returns true if `negInfDouble` has been explicitly set. + var hasNegInfDouble: Bool {_storage._negInfDouble != nil} + /// Clears the value of `negInfDouble`. Subsequent reads from it will return its default value. + mutating func clearNegInfDouble() {_uniqueStorage()._negInfDouble = nil} + + var nanDouble: Double { + get {_storage._nanDouble ?? Double.nan} + set {_uniqueStorage()._nanDouble = newValue} + } + /// Returns true if `nanDouble` has been explicitly set. + var hasNanDouble: Bool {_storage._nanDouble != nil} + /// Clears the value of `nanDouble`. Subsequent reads from it will return its default value. + mutating func clearNanDouble() {_uniqueStorage()._nanDouble = nil} + + var infFloat: Float { + get {_storage._infFloat ?? Float.infinity} + set {_uniqueStorage()._infFloat = newValue} + } + /// Returns true if `infFloat` has been explicitly set. + var hasInfFloat: Bool {_storage._infFloat != nil} + /// Clears the value of `infFloat`. Subsequent reads from it will return its default value. + mutating func clearInfFloat() {_uniqueStorage()._infFloat = nil} + + var negInfFloat: Float { + get {_storage._negInfFloat ?? -Float.infinity} + set {_uniqueStorage()._negInfFloat = newValue} + } + /// Returns true if `negInfFloat` has been explicitly set. + var hasNegInfFloat: Bool {_storage._negInfFloat != nil} + /// Clears the value of `negInfFloat`. Subsequent reads from it will return its default value. + mutating func clearNegInfFloat() {_uniqueStorage()._negInfFloat = nil} + + var nanFloat: Float { + get {_storage._nanFloat ?? Float.nan} + set {_uniqueStorage()._nanFloat = newValue} + } + /// Returns true if `nanFloat` has been explicitly set. + var hasNanFloat: Bool {_storage._nanFloat != nil} + /// Clears the value of `nanFloat`. Subsequent reads from it will return its default value. + mutating func clearNanFloat() {_uniqueStorage()._nanFloat = nil} + + /// Tests for C++ trigraphs. + /// Trigraphs should be escaped in C++ generated files, but they should not be + /// escaped for other languages. + /// Note that in .proto file, "\?" is a valid way to escape ? in string + /// literals. + var cppTrigraph: String { + get {_storage._cppTrigraph ?? "? ? ?? ?? ??? ??/ ??-"} + set {_uniqueStorage()._cppTrigraph = newValue} + } + /// Returns true if `cppTrigraph` has been explicitly set. + var hasCppTrigraph: Bool {_storage._cppTrigraph != nil} + /// Clears the value of `cppTrigraph`. Subsequent reads from it will return its default value. + mutating func clearCppTrigraph() {_uniqueStorage()._cppTrigraph = nil} + + /// String defaults containing the character '\000' + var stringWithZero: String { + get {_storage._stringWithZero ?? "hel\0lo"} + set {_uniqueStorage()._stringWithZero = newValue} + } + /// Returns true if `stringWithZero` has been explicitly set. + var hasStringWithZero: Bool {_storage._stringWithZero != nil} + /// Clears the value of `stringWithZero`. Subsequent reads from it will return its default value. + mutating func clearStringWithZero() {_uniqueStorage()._stringWithZero = nil} + + var bytesWithZero: Data { + get {_storage._bytesWithZero ?? Data([119, 111, 114, 0, 108, 100])} + set {_uniqueStorage()._bytesWithZero = newValue} + } + /// Returns true if `bytesWithZero` has been explicitly set. + var hasBytesWithZero: Bool {_storage._bytesWithZero != nil} + /// Clears the value of `bytesWithZero`. Subsequent reads from it will return its default value. + mutating func clearBytesWithZero() {_uniqueStorage()._bytesWithZero = nil} + + var stringPieceWithZero: String { + get {_storage._stringPieceWithZero ?? "ab\0c"} + set {_uniqueStorage()._stringPieceWithZero = newValue} + } + /// Returns true if `stringPieceWithZero` has been explicitly set. + var hasStringPieceWithZero: Bool {_storage._stringPieceWithZero != nil} + /// Clears the value of `stringPieceWithZero`. Subsequent reads from it will return its default value. + mutating func clearStringPieceWithZero() {_uniqueStorage()._stringPieceWithZero = nil} + + var cordWithZero: String { + get {_storage._cordWithZero ?? "12\03"} + set {_uniqueStorage()._cordWithZero = newValue} + } + /// Returns true if `cordWithZero` has been explicitly set. + var hasCordWithZero: Bool {_storage._cordWithZero != nil} + /// Clears the value of `cordWithZero`. Subsequent reads from it will return its default value. + mutating func clearCordWithZero() {_uniqueStorage()._cordWithZero = nil} + + var replacementString: String { + get {_storage._replacementString ?? "${unknown}"} + set {_uniqueStorage()._replacementString = newValue} + } + /// Returns true if `replacementString` has been explicitly set. + var hasReplacementString: Bool {_storage._replacementString != nil} + /// Clears the value of `replacementString`. Subsequent reads from it will return its default value. + mutating func clearReplacementString() {_uniqueStorage()._replacementString = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Proto2Unittest_SparseEnumMessage: Sendable { + // 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 sparseEnum: Proto2Unittest_TestSparseEnum { + get {_sparseEnum ?? .sparseA} + set {_sparseEnum = newValue} + } + /// Returns true if `sparseEnum` has been explicitly set. + var hasSparseEnum: Bool {self._sparseEnum != nil} + /// Clears the value of `sparseEnum`. Subsequent reads from it will return its default value. + mutating func clearSparseEnum() {self._sparseEnum = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _sparseEnum: Proto2Unittest_TestSparseEnum? = nil +} + +/// Test String and Bytes: string is for valid UTF-8 strings +struct Proto2Unittest_OneString: Sendable { + // 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 data: String { + get {_data ?? String()} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: String? = nil +} + +struct Proto2Unittest_MoreString: Sendable { + // 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 data: [String] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Proto2Unittest_OneBytes: Sendable { + // 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 data: Data { + get {_data ?? Data()} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: Data? = nil +} + +struct Proto2Unittest_MoreBytes: Sendable { + // 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 data: [Data] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Proto2Unittest_ManyOptionalString: @unchecked Sendable { + // 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 str1: String { + get {_storage._str1 ?? String()} + set {_uniqueStorage()._str1 = newValue} + } + /// Returns true if `str1` has been explicitly set. + var hasStr1: Bool {_storage._str1 != nil} + /// Clears the value of `str1`. Subsequent reads from it will return its default value. + mutating func clearStr1() {_uniqueStorage()._str1 = nil} + + var str2: String { + get {_storage._str2 ?? String()} + set {_uniqueStorage()._str2 = newValue} + } + /// Returns true if `str2` has been explicitly set. + var hasStr2: Bool {_storage._str2 != nil} + /// Clears the value of `str2`. Subsequent reads from it will return its default value. + mutating func clearStr2() {_uniqueStorage()._str2 = nil} + + var str3: String { + get {_storage._str3 ?? String()} + set {_uniqueStorage()._str3 = newValue} + } + /// Returns true if `str3` has been explicitly set. + var hasStr3: Bool {_storage._str3 != nil} + /// Clears the value of `str3`. Subsequent reads from it will return its default value. + mutating func clearStr3() {_uniqueStorage()._str3 = nil} + + var str4: String { + get {_storage._str4 ?? String()} + set {_uniqueStorage()._str4 = newValue} + } + /// Returns true if `str4` has been explicitly set. + var hasStr4: Bool {_storage._str4 != nil} + /// Clears the value of `str4`. Subsequent reads from it will return its default value. + mutating func clearStr4() {_uniqueStorage()._str4 = nil} + + var str5: String { + get {_storage._str5 ?? String()} + set {_uniqueStorage()._str5 = newValue} + } + /// Returns true if `str5` has been explicitly set. + var hasStr5: Bool {_storage._str5 != nil} + /// Clears the value of `str5`. Subsequent reads from it will return its default value. + mutating func clearStr5() {_uniqueStorage()._str5 = nil} + + var str6: String { + get {_storage._str6 ?? String()} + set {_uniqueStorage()._str6 = newValue} + } + /// Returns true if `str6` has been explicitly set. + var hasStr6: Bool {_storage._str6 != nil} + /// Clears the value of `str6`. Subsequent reads from it will return its default value. + mutating func clearStr6() {_uniqueStorage()._str6 = nil} + + var str7: String { + get {_storage._str7 ?? String()} + set {_uniqueStorage()._str7 = newValue} + } + /// Returns true if `str7` has been explicitly set. + var hasStr7: Bool {_storage._str7 != nil} + /// Clears the value of `str7`. Subsequent reads from it will return its default value. + mutating func clearStr7() {_uniqueStorage()._str7 = nil} + + var str8: String { + get {_storage._str8 ?? String()} + set {_uniqueStorage()._str8 = newValue} + } + /// Returns true if `str8` has been explicitly set. + var hasStr8: Bool {_storage._str8 != nil} + /// Clears the value of `str8`. Subsequent reads from it will return its default value. + mutating func clearStr8() {_uniqueStorage()._str8 = nil} + + var str9: String { + get {_storage._str9 ?? String()} + set {_uniqueStorage()._str9 = newValue} + } + /// Returns true if `str9` has been explicitly set. + var hasStr9: Bool {_storage._str9 != nil} + /// Clears the value of `str9`. Subsequent reads from it will return its default value. + mutating func clearStr9() {_uniqueStorage()._str9 = nil} + + var str10: String { + get {_storage._str10 ?? String()} + set {_uniqueStorage()._str10 = newValue} + } + /// Returns true if `str10` has been explicitly set. + var hasStr10: Bool {_storage._str10 != nil} + /// Clears the value of `str10`. Subsequent reads from it will return its default value. + mutating func clearStr10() {_uniqueStorage()._str10 = nil} + + var str11: String { + get {_storage._str11 ?? String()} + set {_uniqueStorage()._str11 = newValue} + } + /// Returns true if `str11` has been explicitly set. + var hasStr11: Bool {_storage._str11 != nil} + /// Clears the value of `str11`. Subsequent reads from it will return its default value. + mutating func clearStr11() {_uniqueStorage()._str11 = nil} + + var str12: String { + get {_storage._str12 ?? String()} + set {_uniqueStorage()._str12 = newValue} + } + /// Returns true if `str12` has been explicitly set. + var hasStr12: Bool {_storage._str12 != nil} + /// Clears the value of `str12`. Subsequent reads from it will return its default value. + mutating func clearStr12() {_uniqueStorage()._str12 = nil} + + var str13: String { + get {_storage._str13 ?? String()} + set {_uniqueStorage()._str13 = newValue} + } + /// Returns true if `str13` has been explicitly set. + var hasStr13: Bool {_storage._str13 != nil} + /// Clears the value of `str13`. Subsequent reads from it will return its default value. + mutating func clearStr13() {_uniqueStorage()._str13 = nil} + + var str14: String { + get {_storage._str14 ?? String()} + set {_uniqueStorage()._str14 = newValue} + } + /// Returns true if `str14` has been explicitly set. + var hasStr14: Bool {_storage._str14 != nil} + /// Clears the value of `str14`. Subsequent reads from it will return its default value. + mutating func clearStr14() {_uniqueStorage()._str14 = nil} + + var str15: String { + get {_storage._str15 ?? String()} + set {_uniqueStorage()._str15 = newValue} + } + /// Returns true if `str15` has been explicitly set. + var hasStr15: Bool {_storage._str15 != nil} + /// Clears the value of `str15`. Subsequent reads from it will return its default value. + mutating func clearStr15() {_uniqueStorage()._str15 = nil} + + var str16: String { + get {_storage._str16 ?? String()} + set {_uniqueStorage()._str16 = newValue} + } + /// Returns true if `str16` has been explicitly set. + var hasStr16: Bool {_storage._str16 != nil} + /// Clears the value of `str16`. Subsequent reads from it will return its default value. + mutating func clearStr16() {_uniqueStorage()._str16 = nil} + + var str17: String { + get {_storage._str17 ?? String()} + set {_uniqueStorage()._str17 = newValue} + } + /// Returns true if `str17` has been explicitly set. + var hasStr17: Bool {_storage._str17 != nil} + /// Clears the value of `str17`. Subsequent reads from it will return its default value. + mutating func clearStr17() {_uniqueStorage()._str17 = nil} + + var str18: String { + get {_storage._str18 ?? String()} + set {_uniqueStorage()._str18 = newValue} + } + /// Returns true if `str18` has been explicitly set. + var hasStr18: Bool {_storage._str18 != nil} + /// Clears the value of `str18`. Subsequent reads from it will return its default value. + mutating func clearStr18() {_uniqueStorage()._str18 = nil} + + var str19: String { + get {_storage._str19 ?? String()} + set {_uniqueStorage()._str19 = newValue} + } + /// Returns true if `str19` has been explicitly set. + var hasStr19: Bool {_storage._str19 != nil} + /// Clears the value of `str19`. Subsequent reads from it will return its default value. + mutating func clearStr19() {_uniqueStorage()._str19 = nil} + + var str20: String { + get {_storage._str20 ?? String()} + set {_uniqueStorage()._str20 = newValue} + } + /// Returns true if `str20` has been explicitly set. + var hasStr20: Bool {_storage._str20 != nil} + /// Clears the value of `str20`. Subsequent reads from it will return its default value. + mutating func clearStr20() {_uniqueStorage()._str20 = nil} + + var str21: String { + get {_storage._str21 ?? String()} + set {_uniqueStorage()._str21 = newValue} + } + /// Returns true if `str21` has been explicitly set. + var hasStr21: Bool {_storage._str21 != nil} + /// Clears the value of `str21`. Subsequent reads from it will return its default value. + mutating func clearStr21() {_uniqueStorage()._str21 = nil} + + var str22: String { + get {_storage._str22 ?? String()} + set {_uniqueStorage()._str22 = newValue} + } + /// Returns true if `str22` has been explicitly set. + var hasStr22: Bool {_storage._str22 != nil} + /// Clears the value of `str22`. Subsequent reads from it will return its default value. + mutating func clearStr22() {_uniqueStorage()._str22 = nil} + + var str23: String { + get {_storage._str23 ?? String()} + set {_uniqueStorage()._str23 = newValue} + } + /// Returns true if `str23` has been explicitly set. + var hasStr23: Bool {_storage._str23 != nil} + /// Clears the value of `str23`. Subsequent reads from it will return its default value. + mutating func clearStr23() {_uniqueStorage()._str23 = nil} + + var str24: String { + get {_storage._str24 ?? String()} + set {_uniqueStorage()._str24 = newValue} + } + /// Returns true if `str24` has been explicitly set. + var hasStr24: Bool {_storage._str24 != nil} + /// Clears the value of `str24`. Subsequent reads from it will return its default value. + mutating func clearStr24() {_uniqueStorage()._str24 = nil} + + var str25: String { + get {_storage._str25 ?? String()} + set {_uniqueStorage()._str25 = newValue} + } + /// Returns true if `str25` has been explicitly set. + var hasStr25: Bool {_storage._str25 != nil} + /// Clears the value of `str25`. Subsequent reads from it will return its default value. + mutating func clearStr25() {_uniqueStorage()._str25 = nil} + + var str26: String { + get {_storage._str26 ?? String()} + set {_uniqueStorage()._str26 = newValue} + } + /// Returns true if `str26` has been explicitly set. + var hasStr26: Bool {_storage._str26 != nil} + /// Clears the value of `str26`. Subsequent reads from it will return its default value. + mutating func clearStr26() {_uniqueStorage()._str26 = nil} + + var str27: String { + get {_storage._str27 ?? String()} + set {_uniqueStorage()._str27 = newValue} + } + /// Returns true if `str27` has been explicitly set. + var hasStr27: Bool {_storage._str27 != nil} + /// Clears the value of `str27`. Subsequent reads from it will return its default value. + mutating func clearStr27() {_uniqueStorage()._str27 = nil} + + var str28: String { + get {_storage._str28 ?? String()} + set {_uniqueStorage()._str28 = newValue} + } + /// Returns true if `str28` has been explicitly set. + var hasStr28: Bool {_storage._str28 != nil} + /// Clears the value of `str28`. Subsequent reads from it will return its default value. + mutating func clearStr28() {_uniqueStorage()._str28 = nil} + + var str29: String { + get {_storage._str29 ?? String()} + set {_uniqueStorage()._str29 = newValue} + } + /// Returns true if `str29` has been explicitly set. + var hasStr29: Bool {_storage._str29 != nil} + /// Clears the value of `str29`. Subsequent reads from it will return its default value. + mutating func clearStr29() {_uniqueStorage()._str29 = nil} + + var str30: String { + get {_storage._str30 ?? String()} + set {_uniqueStorage()._str30 = newValue} + } + /// Returns true if `str30` has been explicitly set. + var hasStr30: Bool {_storage._str30 != nil} + /// Clears the value of `str30`. Subsequent reads from it will return its default value. + mutating func clearStr30() {_uniqueStorage()._str30 = nil} + + var str31: String { + get {_storage._str31 ?? String()} + set {_uniqueStorage()._str31 = newValue} + } + /// Returns true if `str31` has been explicitly set. + var hasStr31: Bool {_storage._str31 != nil} + /// Clears the value of `str31`. Subsequent reads from it will return its default value. + mutating func clearStr31() {_uniqueStorage()._str31 = nil} + + var str32: String { + get {_storage._str32 ?? String()} + set {_uniqueStorage()._str32 = newValue} + } + /// Returns true if `str32` has been explicitly set. + var hasStr32: Bool {_storage._str32 != nil} + /// Clears the value of `str32`. Subsequent reads from it will return its default value. + mutating func clearStr32() {_uniqueStorage()._str32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// Test int32, uint32, int64, uint64, and bool are all compatible +struct Proto2Unittest_Int32Message: Sendable { + // 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 data: Int32 { + get {_data ?? 0} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: Int32? = nil +} + +struct Proto2Unittest_Uint32Message: Sendable { + // 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 data: UInt32 { + get {_data ?? 0} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: UInt32? = nil +} + +struct Proto2Unittest_Int64Message: Sendable { + // 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 data: Int64 { + get {_data ?? 0} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: Int64? = nil +} + +struct Proto2Unittest_Uint64Message: Sendable { + // 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 data: UInt64 { + get {_data ?? 0} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: UInt64? = nil +} + +struct Proto2Unittest_BoolMessage: Sendable { + // 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 data: Bool { + get {_data ?? false} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: Bool? = nil +} + +/// Test oneofs. +struct Proto2Unittest_TestOneof: Sendable { + // 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 foo: Proto2Unittest_TestOneof.OneOf_Foo? = nil + + var fooInt: Int32 { + get { + if case .fooInt(let v)? = foo {return v} + return 0 + } + set {foo = .fooInt(newValue)} + } + + var fooString: String { + get { + if case .fooString(let v)? = foo {return v} + return String() + } + set {foo = .fooString(newValue)} + } + + var fooMessage: Proto2Unittest_TestAllTypes { + get { + if case .fooMessage(let v)? = foo {return v} + return Proto2Unittest_TestAllTypes() + } + set {foo = .fooMessage(newValue)} + } + + var fooGroup: Proto2Unittest_TestOneof.FooGroup { + get { + if case .fooGroup(let v)? = foo {return v} + return Proto2Unittest_TestOneof.FooGroup() + } + set {foo = .fooGroup(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_Foo: Equatable, Sendable { + case fooInt(Int32) + case fooString(String) + case fooMessage(Proto2Unittest_TestAllTypes) + case fooGroup(Proto2Unittest_TestOneof.FooGroup) + + } + + struct FooGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: String { + get {_b ?? String()} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: String? = nil + } + + init() {} +} + +struct Proto2Unittest_TestOneofBackwardsCompatible: Sendable { + // 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 fooInt: Int32 { + get {_fooInt ?? 0} + set {_fooInt = newValue} + } + /// Returns true if `fooInt` has been explicitly set. + var hasFooInt: Bool {self._fooInt != nil} + /// Clears the value of `fooInt`. Subsequent reads from it will return its default value. + mutating func clearFooInt() {self._fooInt = nil} + + var fooString: String { + get {_fooString ?? String()} + set {_fooString = newValue} + } + /// Returns true if `fooString` has been explicitly set. + var hasFooString: Bool {self._fooString != nil} + /// Clears the value of `fooString`. Subsequent reads from it will return its default value. + mutating func clearFooString() {self._fooString = nil} + + var fooMessage: Proto2Unittest_TestAllTypes { + get {_fooMessage ?? Proto2Unittest_TestAllTypes()} + set {_fooMessage = newValue} + } + /// Returns true if `fooMessage` has been explicitly set. + var hasFooMessage: Bool {self._fooMessage != nil} + /// Clears the value of `fooMessage`. Subsequent reads from it will return its default value. + mutating func clearFooMessage() {self._fooMessage = nil} + + var fooGroup: Proto2Unittest_TestOneofBackwardsCompatible.FooGroup { + get {_fooGroup ?? Proto2Unittest_TestOneofBackwardsCompatible.FooGroup()} + set {_fooGroup = newValue} + } + /// Returns true if `fooGroup` has been explicitly set. + var hasFooGroup: Bool {self._fooGroup != nil} + /// Clears the value of `fooGroup`. Subsequent reads from it will return its default value. + mutating func clearFooGroup() {self._fooGroup = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct FooGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: String { + get {_b ?? String()} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: String? = nil + } + + init() {} + + fileprivate var _fooInt: Int32? = nil + fileprivate var _fooString: String? = nil + fileprivate var _fooMessage: Proto2Unittest_TestAllTypes? = nil + fileprivate var _fooGroup: Proto2Unittest_TestOneofBackwardsCompatible.FooGroup? = nil +} + +struct Proto2Unittest_TestOneof2: Sendable { + // 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 foo: Proto2Unittest_TestOneof2.OneOf_Foo? = nil + + var fooInt: Int32 { + get { + if case .fooInt(let v)? = foo {return v} + return 0 + } + set {foo = .fooInt(newValue)} + } + + var fooString: String { + get { + if case .fooString(let v)? = foo {return v} + return String() + } + set {foo = .fooString(newValue)} + } + + var fooCord: String { + get { + if case .fooCord(let v)? = foo {return v} + return String() + } + set {foo = .fooCord(newValue)} + } + + var fooStringPiece: String { + get { + if case .fooStringPiece(let v)? = foo {return v} + return String() + } + set {foo = .fooStringPiece(newValue)} + } + + var fooBytes: Data { + get { + if case .fooBytes(let v)? = foo {return v} + return Data() + } + set {foo = .fooBytes(newValue)} + } + + var fooEnum: Proto2Unittest_TestOneof2.NestedEnum { + get { + if case .fooEnum(let v)? = foo {return v} + return .foo + } + set {foo = .fooEnum(newValue)} + } + + var fooMessage: Proto2Unittest_TestOneof2.NestedMessage { + get { + if case .fooMessage(let v)? = foo {return v} + return Proto2Unittest_TestOneof2.NestedMessage() + } + set {foo = .fooMessage(newValue)} + } + + var fooGroup: Proto2Unittest_TestOneof2.FooGroup { + get { + if case .fooGroup(let v)? = foo {return v} + return Proto2Unittest_TestOneof2.FooGroup() + } + set {foo = .fooGroup(newValue)} + } + + var fooLazyMessage: Proto2Unittest_TestOneof2.NestedMessage { + get { + if case .fooLazyMessage(let v)? = foo {return v} + return Proto2Unittest_TestOneof2.NestedMessage() + } + set {foo = .fooLazyMessage(newValue)} + } + + var fooBytesCord: Data { + get { + if case .fooBytesCord(let v)? = foo {return v} + return Data() + } + set {foo = .fooBytesCord(newValue)} + } + + var bar: Proto2Unittest_TestOneof2.OneOf_Bar? = nil + + var barInt: Int32 { + get { + if case .barInt(let v)? = bar {return v} + return 5 + } + set {bar = .barInt(newValue)} + } + + var barString: String { + get { + if case .barString(let v)? = bar {return v} + return "STRING" + } + set {bar = .barString(newValue)} + } + + var barCord: String { + get { + if case .barCord(let v)? = bar {return v} + return "CORD" + } + set {bar = .barCord(newValue)} + } + + var barStringPiece: String { + get { + if case .barStringPiece(let v)? = bar {return v} + return "SPIECE" + } + set {bar = .barStringPiece(newValue)} + } + + var barBytes: Data { + get { + if case .barBytes(let v)? = bar {return v} + return Data([66, 89, 84, 69, 83]) + } + set {bar = .barBytes(newValue)} + } + + var barEnum: Proto2Unittest_TestOneof2.NestedEnum { + get { + if case .barEnum(let v)? = bar {return v} + return .bar + } + set {bar = .barEnum(newValue)} + } + + var barStringWithEmptyDefault: String { + get { + if case .barStringWithEmptyDefault(let v)? = bar {return v} + return String() + } + set {bar = .barStringWithEmptyDefault(newValue)} + } + + var barCordWithEmptyDefault: String { + get { + if case .barCordWithEmptyDefault(let v)? = bar {return v} + return String() + } + set {bar = .barCordWithEmptyDefault(newValue)} + } + + var barStringPieceWithEmptyDefault: String { + get { + if case .barStringPieceWithEmptyDefault(let v)? = bar {return v} + return String() + } + set {bar = .barStringPieceWithEmptyDefault(newValue)} + } + + var barBytesWithEmptyDefault: Data { + get { + if case .barBytesWithEmptyDefault(let v)? = bar {return v} + return Data() + } + set {bar = .barBytesWithEmptyDefault(newValue)} + } + + var bazInt: Int32 { + get {_bazInt ?? 0} + set {_bazInt = newValue} + } + /// Returns true if `bazInt` has been explicitly set. + var hasBazInt: Bool {self._bazInt != nil} + /// Clears the value of `bazInt`. Subsequent reads from it will return its default value. + mutating func clearBazInt() {self._bazInt = nil} + + var bazString: String { + get {_bazString ?? "BAZ"} + set {_bazString = newValue} + } + /// Returns true if `bazString` has been explicitly set. + var hasBazString: Bool {self._bazString != nil} + /// Clears the value of `bazString`. Subsequent reads from it will return its default value. + mutating func clearBazString() {self._bazString = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_Foo: Equatable, Sendable { + case fooInt(Int32) + case fooString(String) + case fooCord(String) + case fooStringPiece(String) + case fooBytes(Data) + case fooEnum(Proto2Unittest_TestOneof2.NestedEnum) + case fooMessage(Proto2Unittest_TestOneof2.NestedMessage) + case fooGroup(Proto2Unittest_TestOneof2.FooGroup) + case fooLazyMessage(Proto2Unittest_TestOneof2.NestedMessage) + case fooBytesCord(Data) + + } + + enum OneOf_Bar: Equatable, Sendable { + case barInt(Int32) + case barString(String) + case barCord(String) + case barStringPiece(String) + case barBytes(Data) + case barEnum(Proto2Unittest_TestOneof2.NestedEnum) + case barStringWithEmptyDefault(String) + case barCordWithEmptyDefault(String) + case barStringPieceWithEmptyDefault(String) + case barBytesWithEmptyDefault(Data) + + } + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 1 + case bar = 2 + case baz = 3 + + init() { + self = .foo + } + + } + + struct FooGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: String { + get {_b ?? String()} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: String? = nil + } + + struct NestedMessage: @unchecked Sendable { + // 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 mooInt: Int64 { + get {_storage._mooInt ?? 0} + set {_uniqueStorage()._mooInt = newValue} + } + /// Returns true if `mooInt` has been explicitly set. + var hasMooInt: Bool {_storage._mooInt != nil} + /// Clears the value of `mooInt`. Subsequent reads from it will return its default value. + mutating func clearMooInt() {_uniqueStorage()._mooInt = nil} + + var corgeInt: [Int32] { + get {_storage._corgeInt} + set {_uniqueStorage()._corgeInt = newValue} + } + + var child: Proto2Unittest_TestOneof2.NestedMessage { + get {_storage._child ?? Proto2Unittest_TestOneof2.NestedMessage()} + set {_uniqueStorage()._child = newValue} + } + /// Returns true if `child` has been explicitly set. + var hasChild: Bool {_storage._child != nil} + /// Clears the value of `child`. Subsequent reads from it will return its default value. + mutating func clearChild() {_uniqueStorage()._child = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + init() {} + + fileprivate var _bazInt: Int32? = nil + fileprivate var _bazString: String? = nil +} + +struct Proto2Unittest_TestRequiredOneof: Sendable { + // 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 foo: Proto2Unittest_TestRequiredOneof.OneOf_Foo? = nil + + var fooInt: Int32 { + get { + if case .fooInt(let v)? = foo {return v} + return 0 + } + set {foo = .fooInt(newValue)} + } + + var fooString: String { + get { + if case .fooString(let v)? = foo {return v} + return String() + } + set {foo = .fooString(newValue)} + } + + var fooMessage: Proto2Unittest_TestRequiredOneof.NestedMessage { + get { + if case .fooMessage(let v)? = foo {return v} + return Proto2Unittest_TestRequiredOneof.NestedMessage() + } + set {foo = .fooMessage(newValue)} + } + + var fooLazyMessage: Proto2Unittest_TestRequiredOneof.NestedMessage { + get { + if case .fooLazyMessage(let v)? = foo {return v} + return Proto2Unittest_TestRequiredOneof.NestedMessage() + } + set {foo = .fooLazyMessage(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_Foo: Equatable, Sendable { + case fooInt(Int32) + case fooString(String) + case fooMessage(Proto2Unittest_TestRequiredOneof.NestedMessage) + case fooLazyMessage(Proto2Unittest_TestRequiredOneof.NestedMessage) + + fileprivate var isInitialized: 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 self { + case .fooMessage: return { + guard case .fooMessage(let v) = self else { preconditionFailure() } + return v.isInitialized + }() + case .fooLazyMessage: return { + guard case .fooLazyMessage(let v) = self else { preconditionFailure() } + return v.isInitialized + }() + default: return true + } + } + + } + + struct NestedMessage: Sendable { + // 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 requiredDouble: Double { + get {_requiredDouble ?? 0} + set {_requiredDouble = newValue} + } + /// Returns true if `requiredDouble` has been explicitly set. + var hasRequiredDouble: Bool {self._requiredDouble != nil} + /// Clears the value of `requiredDouble`. Subsequent reads from it will return its default value. + mutating func clearRequiredDouble() {self._requiredDouble = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _requiredDouble: Double? = nil + } + + init() {} +} + +struct Proto2Unittest_TestPackedTypes: Sendable { + // 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 packedInt32: [Int32] = [] + + var packedInt64: [Int64] = [] + + var packedUint32: [UInt32] = [] + + var packedUint64: [UInt64] = [] + + var packedSint32: [Int32] = [] + + var packedSint64: [Int64] = [] + + var packedFixed32: [UInt32] = [] + + var packedFixed64: [UInt64] = [] + + var packedSfixed32: [Int32] = [] + + var packedSfixed64: [Int64] = [] + + var packedFloat: [Float] = [] + + var packedDouble: [Double] = [] + + var packedBool: [Bool] = [] + + var packedEnum: [Proto2Unittest_ForeignEnum] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +/// A message with the same fields as TestPackedTypes, but without packing. Used +/// to test packed <-> unpacked wire compatibility. +struct Proto2Unittest_TestUnpackedTypes: Sendable { + // 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 unpackedInt32: [Int32] = [] + + var unpackedInt64: [Int64] = [] + + var unpackedUint32: [UInt32] = [] + + var unpackedUint64: [UInt64] = [] + + var unpackedSint32: [Int32] = [] + + var unpackedSint64: [Int64] = [] + + var unpackedFixed32: [UInt32] = [] + + var unpackedFixed64: [UInt64] = [] + + var unpackedSfixed32: [Int32] = [] + + var unpackedSfixed64: [Int64] = [] + + var unpackedFloat: [Float] = [] + + var unpackedDouble: [Double] = [] + + var unpackedBool: [Bool] = [] + + var unpackedEnum: [Proto2Unittest_ForeignEnum] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Proto2Unittest_TestPackedExtensions: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +struct Proto2Unittest_TestUnpackedExtensions: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +/// Used by ExtensionSetTest/DynamicExtensions. The test actually builds +/// a set of extensions to TestAllExtensions dynamically, based on the fields +/// of this message type. +struct Proto2Unittest_TestDynamicExtensions: Sendable { + // 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 scalarExtension: UInt32 { + get {_scalarExtension ?? 0} + set {_scalarExtension = newValue} + } + /// Returns true if `scalarExtension` has been explicitly set. + var hasScalarExtension: Bool {self._scalarExtension != nil} + /// Clears the value of `scalarExtension`. Subsequent reads from it will return its default value. + mutating func clearScalarExtension() {self._scalarExtension = nil} + + var enumExtension: Proto2Unittest_ForeignEnum { + get {_enumExtension ?? .foreignFoo} + set {_enumExtension = newValue} + } + /// Returns true if `enumExtension` has been explicitly set. + var hasEnumExtension: Bool {self._enumExtension != nil} + /// Clears the value of `enumExtension`. Subsequent reads from it will return its default value. + mutating func clearEnumExtension() {self._enumExtension = nil} + + var dynamicEnumExtension: Proto2Unittest_TestDynamicExtensions.DynamicEnumType { + get {_dynamicEnumExtension ?? .dynamicFoo} + set {_dynamicEnumExtension = newValue} + } + /// Returns true if `dynamicEnumExtension` has been explicitly set. + var hasDynamicEnumExtension: Bool {self._dynamicEnumExtension != nil} + /// Clears the value of `dynamicEnumExtension`. Subsequent reads from it will return its default value. + mutating func clearDynamicEnumExtension() {self._dynamicEnumExtension = nil} + + var messageExtension: Proto2Unittest_ForeignMessage { + get {_messageExtension ?? Proto2Unittest_ForeignMessage()} + set {_messageExtension = newValue} + } + /// Returns true if `messageExtension` has been explicitly set. + var hasMessageExtension: Bool {self._messageExtension != nil} + /// Clears the value of `messageExtension`. Subsequent reads from it will return its default value. + mutating func clearMessageExtension() {self._messageExtension = nil} + + var dynamicMessageExtension: Proto2Unittest_TestDynamicExtensions.DynamicMessageType { + get {_dynamicMessageExtension ?? Proto2Unittest_TestDynamicExtensions.DynamicMessageType()} + set {_dynamicMessageExtension = newValue} + } + /// Returns true if `dynamicMessageExtension` has been explicitly set. + var hasDynamicMessageExtension: Bool {self._dynamicMessageExtension != nil} + /// Clears the value of `dynamicMessageExtension`. Subsequent reads from it will return its default value. + mutating func clearDynamicMessageExtension() {self._dynamicMessageExtension = nil} + + var repeatedExtension: [String] = [] + + var packedExtension: [Int32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum DynamicEnumType: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case dynamicFoo = 2200 + case dynamicBar = 2201 + case dynamicBaz = 2202 + + init() { + self = .dynamicFoo + } + + } + + struct DynamicMessageType: Sendable { + // 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 dynamicField: Int32 { + get {_dynamicField ?? 0} + set {_dynamicField = newValue} + } + /// Returns true if `dynamicField` has been explicitly set. + var hasDynamicField: Bool {self._dynamicField != nil} + /// Clears the value of `dynamicField`. Subsequent reads from it will return its default value. + mutating func clearDynamicField() {self._dynamicField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _dynamicField: Int32? = nil + } + + init() {} + + fileprivate var _scalarExtension: UInt32? = nil + fileprivate var _enumExtension: Proto2Unittest_ForeignEnum? = nil + fileprivate var _dynamicEnumExtension: Proto2Unittest_TestDynamicExtensions.DynamicEnumType? = nil + fileprivate var _messageExtension: Proto2Unittest_ForeignMessage? = nil + fileprivate var _dynamicMessageExtension: Proto2Unittest_TestDynamicExtensions.DynamicMessageType? = nil +} + +struct Proto2Unittest_TestRepeatedString: Sendable { + // 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 repeatedString1: [String] = [] + + var repeatedString2: [String] = [] + + var repeatedBytes11: [Data] = [] + + var repeatedBytes12: [Data] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Proto2Unittest_TestRepeatedScalarDifferentTagSizes: Sendable { + // 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. + + /// Parsing repeated fixed size values used to fail. This message needs to be + /// used in order to get a tag of the right size; all of the repeated fields + /// in TestAllTypes didn't trigger the check. + var repeatedFixed32: [UInt32] = [] + + /// Check for a varint type, just for good measure. + var repeatedInt32: [Int32] = [] + + /// These have two-byte tags. + var repeatedFixed64: [UInt64] = [] + + var repeatedInt64: [Int64] = [] + + /// Three byte tags. + var repeatedFloat: [Float] = [] + + var repeatedUint64: [UInt64] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +/// Test that if an optional or required message/group field appears multiple +/// times in the input, they need to be merged. +struct Proto2Unittest_TestParsingMerge: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 requiredAllTypes: Proto2Unittest_TestAllTypes { + get {_requiredAllTypes ?? Proto2Unittest_TestAllTypes()} + set {_requiredAllTypes = newValue} + } + /// Returns true if `requiredAllTypes` has been explicitly set. + var hasRequiredAllTypes: Bool {self._requiredAllTypes != nil} + /// Clears the value of `requiredAllTypes`. Subsequent reads from it will return its default value. + mutating func clearRequiredAllTypes() {self._requiredAllTypes = nil} + + var optionalAllTypes: Proto2Unittest_TestAllTypes { + get {_optionalAllTypes ?? Proto2Unittest_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [Proto2Unittest_TestAllTypes] = [] + + var optionalGroup: Proto2Unittest_TestParsingMerge.OptionalGroup { + get {_optionalGroup ?? Proto2Unittest_TestParsingMerge.OptionalGroup()} + set {_optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {self._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {self._optionalGroup = nil} + + var repeatedGroup: [Proto2Unittest_TestParsingMerge.RepeatedGroup] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + /// RepeatedFieldsGenerator defines matching field types as TestParsingMerge, + /// except that all fields are repeated. In the tests, we will serialize the + /// RepeatedFieldsGenerator to bytes, and parse the bytes to TestParsingMerge. + /// Repeated fields in RepeatedFieldsGenerator are expected to be merged into + /// the corresponding required/optional fields in TestParsingMerge. + struct RepeatedFieldsGenerator: Sendable { + // 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: [Proto2Unittest_TestAllTypes] = [] + + var field2: [Proto2Unittest_TestAllTypes] = [] + + var field3: [Proto2Unittest_TestAllTypes] = [] + + var group1: [Proto2Unittest_TestParsingMerge.RepeatedFieldsGenerator.Group1] = [] + + var group2: [Proto2Unittest_TestParsingMerge.RepeatedFieldsGenerator.Group2] = [] + + var ext1: [Proto2Unittest_TestAllTypes] = [] + + var ext2: [Proto2Unittest_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct Group1: Sendable { + // 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: Proto2Unittest_TestAllTypes { + get {_field1 ?? Proto2Unittest_TestAllTypes()} + set {_field1 = newValue} + } + /// Returns true if `field1` has been explicitly set. + var hasField1: Bool {self._field1 != nil} + /// Clears the value of `field1`. Subsequent reads from it will return its default value. + mutating func clearField1() {self._field1 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _field1: Proto2Unittest_TestAllTypes? = nil + } + + struct Group2: Sendable { + // 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: Proto2Unittest_TestAllTypes { + get {_field1 ?? Proto2Unittest_TestAllTypes()} + set {_field1 = newValue} + } + /// Returns true if `field1` has been explicitly set. + var hasField1: Bool {self._field1 != nil} + /// Clears the value of `field1`. Subsequent reads from it will return its default value. + mutating func clearField1() {self._field1 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _field1: Proto2Unittest_TestAllTypes? = nil + } + + init() {} + } + + struct OptionalGroup: Sendable { + // 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 optionalGroupAllTypes: Proto2Unittest_TestAllTypes { + get {_optionalGroupAllTypes ?? Proto2Unittest_TestAllTypes()} + set {_optionalGroupAllTypes = newValue} + } + /// Returns true if `optionalGroupAllTypes` has been explicitly set. + var hasOptionalGroupAllTypes: Bool {self._optionalGroupAllTypes != nil} + /// Clears the value of `optionalGroupAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroupAllTypes() {self._optionalGroupAllTypes = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalGroupAllTypes: Proto2Unittest_TestAllTypes? = nil + } + + struct RepeatedGroup: Sendable { + // 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 repeatedGroupAllTypes: Proto2Unittest_TestAllTypes { + get {_repeatedGroupAllTypes ?? Proto2Unittest_TestAllTypes()} + set {_repeatedGroupAllTypes = newValue} + } + /// Returns true if `repeatedGroupAllTypes` has been explicitly set. + var hasRepeatedGroupAllTypes: Bool {self._repeatedGroupAllTypes != nil} + /// Clears the value of `repeatedGroupAllTypes`. Subsequent reads from it will return its default value. + mutating func clearRepeatedGroupAllTypes() {self._repeatedGroupAllTypes = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _repeatedGroupAllTypes: Proto2Unittest_TestAllTypes? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _requiredAllTypes: Proto2Unittest_TestAllTypes? = nil + fileprivate var _optionalAllTypes: Proto2Unittest_TestAllTypes? = nil + fileprivate var _optionalGroup: Proto2Unittest_TestParsingMerge.OptionalGroup? = nil +} + +/// Test that the correct exception is thrown by parseFrom in a corner case +/// involving merging, extensions, and required fields. +struct Proto2Unittest_TestMergeException: Sendable { + // 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 allExtensions: Proto2Unittest_TestAllExtensions { + get {_allExtensions ?? Proto2Unittest_TestAllExtensions()} + set {_allExtensions = newValue} + } + /// Returns true if `allExtensions` has been explicitly set. + var hasAllExtensions: Bool {self._allExtensions != nil} + /// Clears the value of `allExtensions`. Subsequent reads from it will return its default value. + mutating func clearAllExtensions() {self._allExtensions = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _allExtensions: Proto2Unittest_TestAllExtensions? = nil +} + +struct Proto2Unittest_TestCommentInjectionMessage: Sendable { + // 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. + + /// */ <- This should not close the generated doc comment + var a: String { + get {_a ?? "*/ <- Neither should this."} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: String? = nil +} + +/// Used to check that the c++ code generator re-orders messages to reduce +/// padding. +struct Proto2Unittest_TestMessageSize: Sendable { + // 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 m1: Bool { + get {_m1 ?? false} + set {_m1 = newValue} + } + /// Returns true if `m1` has been explicitly set. + var hasM1: Bool {self._m1 != nil} + /// Clears the value of `m1`. Subsequent reads from it will return its default value. + mutating func clearM1() {self._m1 = nil} + + var m2: Int64 { + get {_m2 ?? 0} + set {_m2 = newValue} + } + /// Returns true if `m2` has been explicitly set. + var hasM2: Bool {self._m2 != nil} + /// Clears the value of `m2`. Subsequent reads from it will return its default value. + mutating func clearM2() {self._m2 = nil} + + var m3: Bool { + get {_m3 ?? false} + set {_m3 = newValue} + } + /// Returns true if `m3` has been explicitly set. + var hasM3: Bool {self._m3 != nil} + /// Clears the value of `m3`. Subsequent reads from it will return its default value. + mutating func clearM3() {self._m3 = nil} + + var m4: String { + get {_m4 ?? String()} + set {_m4 = newValue} + } + /// Returns true if `m4` has been explicitly set. + var hasM4: Bool {self._m4 != nil} + /// Clears the value of `m4`. Subsequent reads from it will return its default value. + mutating func clearM4() {self._m4 = nil} + + var m5: Int32 { + get {_m5 ?? 0} + set {_m5 = newValue} + } + /// Returns true if `m5` has been explicitly set. + var hasM5: Bool {self._m5 != nil} + /// Clears the value of `m5`. Subsequent reads from it will return its default value. + mutating func clearM5() {self._m5 = nil} + + var m6: Int64 { + get {_m6 ?? 0} + set {_m6 = newValue} + } + /// Returns true if `m6` has been explicitly set. + var hasM6: Bool {self._m6 != nil} + /// Clears the value of `m6`. Subsequent reads from it will return its default value. + mutating func clearM6() {self._m6 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _m1: Bool? = nil + fileprivate var _m2: Int64? = nil + fileprivate var _m3: Bool? = nil + fileprivate var _m4: String? = nil + fileprivate var _m5: Int32? = nil + fileprivate var _m6: Int64? = nil +} + +struct Proto2Unittest_OpenEnumMessage: Sendable { + // 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 optOpen: Proto2Unittest_OpenEnumMessage.TestEnum { + get {_optOpen ?? .unknown} + set {_optOpen = newValue} + } + /// Returns true if `optOpen` has been explicitly set. + var hasOptOpen: Bool {self._optOpen != nil} + /// Clears the value of `optOpen`. Subsequent reads from it will return its default value. + mutating func clearOptOpen() {self._optOpen = nil} + + var optClosed: Proto2Unittest_ForeignEnum { + get {_optClosed ?? .foreignFoo} + set {_optClosed = newValue} + } + /// Returns true if `optClosed` has been explicitly set. + var hasOptClosed: Bool {self._optClosed != nil} + /// Clears the value of `optClosed`. Subsequent reads from it will return its default value. + mutating func clearOptClosed() {self._optClosed = nil} + + var repeatedOpen: [Proto2Unittest_OpenEnumMessage.TestEnum] = [] + + var repeatedClosed: [Proto2Unittest_ForeignEnum] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum TestEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case unknown // = 0 + case foo // = 1 + case bar // = 2 + case baz // = 3 + case UNRECOGNIZED(Int) + + init() { + self = .unknown + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .unknown + case 1: self = .foo + case 2: self = .bar + case 3: self = .baz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .unknown: return 0 + case .foo: return 1 + case .bar: return 2 + case .baz: return 3 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Proto2Unittest_OpenEnumMessage.TestEnum] = [ + .unknown, + .foo, + .bar, + .baz, + ] + + } + + init() {} + + fileprivate var _optOpen: Proto2Unittest_OpenEnumMessage.TestEnum? = nil + fileprivate var _optClosed: Proto2Unittest_ForeignEnum? = nil +} + +/// Tests eager verification of a lazy message field. +struct Proto2Unittest_TestEagerlyVerifiedLazyMessage: Sendable { + // 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 lazyMessage: Proto2Unittest_TestEagerlyVerifiedLazyMessage.LazyMessage { + get {_lazyMessage ?? Proto2Unittest_TestEagerlyVerifiedLazyMessage.LazyMessage()} + set {_lazyMessage = newValue} + } + /// Returns true if `lazyMessage` has been explicitly set. + var hasLazyMessage: Bool {self._lazyMessage != nil} + /// Clears the value of `lazyMessage`. Subsequent reads from it will return its default value. + mutating func clearLazyMessage() {self._lazyMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct LazyMessage: Sendable { + // 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 bytesField: Data { + get {_bytesField ?? Data()} + set {_bytesField = newValue} + } + /// Returns true if `bytesField` has been explicitly set. + var hasBytesField: Bool {self._bytesField != nil} + /// Clears the value of `bytesField`. Subsequent reads from it will return its default value. + mutating func clearBytesField() {self._bytesField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _bytesField: Data? = nil + } + + init() {} + + fileprivate var _lazyMessage: Proto2Unittest_TestEagerlyVerifiedLazyMessage.LazyMessage? = nil +} + +/// Test that RPC services work. +struct Proto2Unittest_FooRequest: Sendable { + // 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 Proto2Unittest_FooResponse: Sendable { + // 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 Proto2Unittest_FooClientMessage: Sendable { + // 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 Proto2Unittest_FooServerMessage: Sendable { + // 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 Proto2Unittest_BarRequest: Sendable { + // 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 Proto2Unittest_BarResponse: Sendable { + // 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 Proto2Unittest_TestJsonName: Sendable { + // 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 fieldName1: Int32 { + get {_fieldName1 ?? 0} + set {_fieldName1 = newValue} + } + /// Returns true if `fieldName1` has been explicitly set. + var hasFieldName1: Bool {self._fieldName1 != nil} + /// Clears the value of `fieldName1`. Subsequent reads from it will return its default value. + mutating func clearFieldName1() {self._fieldName1 = nil} + + var fieldName2: Int32 { + get {_fieldName2 ?? 0} + set {_fieldName2 = newValue} + } + /// Returns true if `fieldName2` has been explicitly set. + var hasFieldName2: Bool {self._fieldName2 != nil} + /// Clears the value of `fieldName2`. Subsequent reads from it will return its default value. + mutating func clearFieldName2() {self._fieldName2 = nil} + + var fieldName3: Int32 { + get {_fieldName3 ?? 0} + set {_fieldName3 = newValue} + } + /// Returns true if `fieldName3` has been explicitly set. + var hasFieldName3: Bool {self._fieldName3 != nil} + /// Clears the value of `fieldName3`. Subsequent reads from it will return its default value. + mutating func clearFieldName3() {self._fieldName3 = nil} + + var fieldName4: Int32 { + get {_fieldName4 ?? 0} + set {_fieldName4 = newValue} + } + /// Returns true if `fieldName4` has been explicitly set. + var hasFieldName4: Bool {self._fieldName4 != nil} + /// Clears the value of `fieldName4`. Subsequent reads from it will return its default value. + mutating func clearFieldName4() {self._fieldName4 = nil} + + var fieldName5: Int32 { + get {_fieldName5 ?? 0} + set {_fieldName5 = newValue} + } + /// Returns true if `fieldName5` has been explicitly set. + var hasFieldName5: Bool {self._fieldName5 != nil} + /// Clears the value of `fieldName5`. Subsequent reads from it will return its default value. + mutating func clearFieldName5() {self._fieldName5 = nil} + + var fieldName6: Int32 { + get {_fieldName6 ?? 0} + set {_fieldName6 = newValue} + } + /// Returns true if `fieldName6` has been explicitly set. + var hasFieldName6: Bool {self._fieldName6 != nil} + /// Clears the value of `fieldName6`. Subsequent reads from it will return its default value. + mutating func clearFieldName6() {self._fieldName6 = nil} + + var fieldname7: Int32 { + get {_fieldname7 ?? 0} + set {_fieldname7 = newValue} + } + /// Returns true if `fieldname7` has been explicitly set. + var hasFieldname7: Bool {self._fieldname7 != nil} + /// Clears the value of `fieldname7`. Subsequent reads from it will return its default value. + mutating func clearFieldname7() {self._fieldname7 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _fieldName1: Int32? = nil + fileprivate var _fieldName2: Int32? = nil + fileprivate var _fieldName3: Int32? = nil + fileprivate var _fieldName4: Int32? = nil + fileprivate var _fieldName5: Int32? = nil + fileprivate var _fieldName6: Int32? = nil + fileprivate var _fieldname7: Int32? = nil +} + +struct Proto2Unittest_TestHugeFieldNumbers: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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 optionalInt32: Int32 { + get {_storage._optionalInt32 ?? 0} + set {_uniqueStorage()._optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} + + var fixed32: Int32 { + get {_storage._fixed32 ?? 0} + set {_uniqueStorage()._fixed32 = newValue} + } + /// Returns true if `fixed32` has been explicitly set. + var hasFixed32: Bool {_storage._fixed32 != nil} + /// Clears the value of `fixed32`. Subsequent reads from it will return its default value. + mutating func clearFixed32() {_uniqueStorage()._fixed32 = nil} + + var repeatedInt32: [Int32] { + get {_storage._repeatedInt32} + set {_uniqueStorage()._repeatedInt32 = newValue} + } + + var packedInt32: [Int32] { + get {_storage._packedInt32} + set {_uniqueStorage()._packedInt32 = newValue} + } + + var optionalEnum: Proto2Unittest_ForeignEnum { + get {_storage._optionalEnum ?? .foreignFoo} + set {_uniqueStorage()._optionalEnum = newValue} + } + /// Returns true if `optionalEnum` has been explicitly set. + var hasOptionalEnum: Bool {_storage._optionalEnum != nil} + /// Clears the value of `optionalEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalEnum() {_uniqueStorage()._optionalEnum = nil} + + var optionalString: String { + get {_storage._optionalString ?? String()} + set {_uniqueStorage()._optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {_storage._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} + + var optionalBytes: Data { + get {_storage._optionalBytes ?? Data()} + set {_uniqueStorage()._optionalBytes = newValue} + } + /// Returns true if `optionalBytes` has been explicitly set. + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} + /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} + + var optionalMessage: Proto2Unittest_ForeignMessage { + get {_storage._optionalMessage ?? Proto2Unittest_ForeignMessage()} + set {_uniqueStorage()._optionalMessage = newValue} + } + /// Returns true if `optionalMessage` has been explicitly set. + var hasOptionalMessage: Bool {_storage._optionalMessage != nil} + /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalMessage() {_uniqueStorage()._optionalMessage = nil} + + var optionalGroup: Proto2Unittest_TestHugeFieldNumbers.OptionalGroup { + get {_storage._optionalGroup ?? Proto2Unittest_TestHugeFieldNumbers.OptionalGroup()} + set {_uniqueStorage()._optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {_storage._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {_uniqueStorage()._optionalGroup = nil} + + var stringStringMap: Dictionary { + get {_storage._stringStringMap} + set {_uniqueStorage()._stringStringMap = newValue} + } + + var oneofField: OneOf_OneofField? { + get {return _storage._oneofField} + set {_uniqueStorage()._oneofField = newValue} + } + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} + } + + var oneofTestAllTypes: Proto2Unittest_TestAllTypes { + get { + if case .oneofTestAllTypes(let v)? = _storage._oneofField {return v} + return Proto2Unittest_TestAllTypes() + } + set {_uniqueStorage()._oneofField = .oneofTestAllTypes(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = _storage._oneofField {return v} + return Data() + } + set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} + } + + var optionalBool: Bool { + get {_storage._optionalBool ?? false} + set {_uniqueStorage()._optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {_storage._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} + + var optionalInt64: Int64 { + get {_storage._optionalInt64 ?? 0} + set {_uniqueStorage()._optionalInt64 = newValue} + } + /// Returns true if `optionalInt64` has been explicitly set. + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} + /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} + + var optionalFloat: Float { + get {_storage._optionalFloat ?? 0} + set {_uniqueStorage()._optionalFloat = newValue} + } + /// Returns true if `optionalFloat` has been explicitly set. + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} + /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} + + var optionalDouble: Double { + get {_storage._optionalDouble ?? 0} + set {_uniqueStorage()._optionalDouble = newValue} + } + /// Returns true if `optionalDouble` has been explicitly set. + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} + /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. + mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} + + var optionalUtf8String: String { + get {_storage._optionalUtf8String ?? String()} + set {_uniqueStorage()._optionalUtf8String = newValue} + } + /// Returns true if `optionalUtf8String` has been explicitly set. + var hasOptionalUtf8String: Bool {_storage._optionalUtf8String != nil} + /// Clears the value of `optionalUtf8String`. Subsequent reads from it will return its default value. + mutating func clearOptionalUtf8String() {_uniqueStorage()._optionalUtf8String = nil} + + var optionalCord: String { + get {_storage._optionalCord ?? String()} + set {_uniqueStorage()._optionalCord = newValue} + } + /// Returns true if `optionalCord` has been explicitly set. + var hasOptionalCord: Bool {_storage._optionalCord != nil} + /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. + mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} + + var optionalStringPiece: String { + get {_storage._optionalStringPiece ?? String()} + set {_uniqueStorage()._optionalStringPiece = newValue} + } + /// Returns true if `optionalStringPiece` has been explicitly set. + var hasOptionalStringPiece: Bool {_storage._optionalStringPiece != nil} + /// Clears the value of `optionalStringPiece`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringPiece() {_uniqueStorage()._optionalStringPiece = nil} + + var repeatedUtf8String: [String] { + get {_storage._repeatedUtf8String} + set {_uniqueStorage()._repeatedUtf8String = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofTestAllTypes(Proto2Unittest_TestAllTypes) + case oneofString(String) + case oneofBytes(Data) + + } + + struct OptionalGroup: Sendable { + // 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 groupA: Int32 { + get {_groupA ?? 0} + set {_groupA = newValue} + } + /// Returns true if `groupA` has been explicitly set. + var hasGroupA: Bool {self._groupA != nil} + /// Clears the value of `groupA`. Subsequent reads from it will return its default value. + mutating func clearGroupA() {self._groupA = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupA: Int32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Proto2Unittest_TestExtensionInsideTable: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 {_field1 ?? 0} + set {_field1 = newValue} + } + /// Returns true if `field1` has been explicitly set. + var hasField1: Bool {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 {_field2 ?? 0} + set {_field2 = newValue} + } + /// Returns true if `field2` has been explicitly set. + var hasField2: Bool {self._field2 != nil} + /// Clears the value of `field2`. Subsequent reads from it will return its default value. + mutating func clearField2() {self._field2 = nil} + + var field3: Int32 { + get {_field3 ?? 0} + set {_field3 = newValue} + } + /// Returns true if `field3` has been explicitly set. + var hasField3: Bool {self._field3 != nil} + /// Clears the value of `field3`. Subsequent reads from it will return its default value. + mutating func clearField3() {self._field3 = nil} + + var field4: Int32 { + get {_field4 ?? 0} + set {_field4 = newValue} + } + /// Returns true if `field4` has been explicitly set. + var hasField4: Bool {self._field4 != nil} + /// Clears the value of `field4`. Subsequent reads from it will return its default value. + mutating func clearField4() {self._field4 = nil} + + var field6: Int32 { + get {_field6 ?? 0} + set {_field6 = newValue} + } + /// Returns true if `field6` has been explicitly set. + var hasField6: Bool {self._field6 != nil} + /// Clears the value of `field6`. Subsequent reads from it will return its default value. + mutating func clearField6() {self._field6 = nil} + + var field7: Int32 { + get {_field7 ?? 0} + set {_field7 = newValue} + } + /// Returns true if `field7` has been explicitly set. + var hasField7: Bool {self._field7 != nil} + /// Clears the value of `field7`. Subsequent reads from it will return its default value. + mutating func clearField7() {self._field7 = nil} + + var field8: Int32 { + get {_field8 ?? 0} + set {_field8 = newValue} + } + /// Returns true if `field8` has been explicitly set. + var hasField8: Bool {self._field8 != nil} + /// Clears the value of `field8`. Subsequent reads from it will return its default value. + mutating func clearField8() {self._field8 = nil} + + var field9: Int32 { + get {_field9 ?? 0} + set {_field9 = newValue} + } + /// Returns true if `field9` has been explicitly set. + var hasField9: Bool {self._field9 != nil} + /// Clears the value of `field9`. Subsequent reads from it will return its default value. + mutating func clearField9() {self._field9 = nil} + + var field10: Int32 { + get {_field10 ?? 0} + set {_field10 = newValue} + } + /// Returns true if `field10` has been explicitly set. + var hasField10: Bool {self._field10 != nil} + /// Clears the value of `field10`. Subsequent reads from it will return its default value. + mutating func clearField10() {self._field10 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _field1: Int32? = nil + fileprivate var _field2: Int32? = nil + fileprivate var _field3: Int32? = nil + fileprivate var _field4: Int32? = nil + fileprivate var _field6: Int32? = nil + fileprivate var _field7: Int32? = nil + fileprivate var _field8: Int32? = nil + fileprivate var _field9: Int32? = nil + fileprivate var _field10: Int32? = nil +} + +/// NOTE: Intentionally nested to mirror go/glep. +struct Proto2Unittest_TestNestedGroupExtensionOuter: Sendable { + // 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 layer1OptionalGroup: Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup { + get {_layer1OptionalGroup ?? Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup()} + set {_layer1OptionalGroup = newValue} + } + /// Returns true if `layer1OptionalGroup` has been explicitly set. + var hasLayer1OptionalGroup: Bool {self._layer1OptionalGroup != nil} + /// Clears the value of `layer1OptionalGroup`. Subsequent reads from it will return its default value. + mutating func clearLayer1OptionalGroup() {self._layer1OptionalGroup = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct Layer1OptionalGroup: Sendable { + // 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 layer2RepeatedGroup: [Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2RepeatedGroup] = [] + + var layer2AnotherOptionalRepeatedGroup: [Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2AnotherOptionalRepeatedGroup] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct Layer2RepeatedGroup: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 anotherField: String { + get {_anotherField ?? String()} + set {_anotherField = newValue} + } + /// Returns true if `anotherField` has been explicitly set. + var hasAnotherField: Bool {self._anotherField != nil} + /// Clears the value of `anotherField`. Subsequent reads from it will return its default value. + mutating func clearAnotherField() {self._anotherField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _anotherField: String? = nil + } + + struct Layer2AnotherOptionalRepeatedGroup: Sendable { + // 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 butWhyTho: String { + get {_butWhyTho ?? String()} + set {_butWhyTho = newValue} + } + /// Returns true if `butWhyTho` has been explicitly set. + var hasButWhyTho: Bool {self._butWhyTho != nil} + /// Clears the value of `butWhyTho`. Subsequent reads from it will return its default value. + mutating func clearButWhyTho() {self._butWhyTho = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _butWhyTho: String? = nil + } + + init() {} + } + + init() {} + + fileprivate var _layer1OptionalGroup: Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup? = nil +} + +struct Proto2Unittest_TestNestedGroupExtensionInnerExtension: Sendable { + // 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 innerName: String { + get {_innerName ?? String()} + set {_innerName = newValue} + } + /// Returns true if `innerName` has been explicitly set. + var hasInnerName: Bool {self._innerName != nil} + /// Clears the value of `innerName`. Subsequent reads from it will return its default value. + mutating func clearInnerName() {self._innerName = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _innerName: String? = nil +} + +struct Proto2Unittest_TestExtensionRangeSerialize: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 fooOne: Int32 { + get {_fooOne ?? 0} + set {_fooOne = newValue} + } + /// Returns true if `fooOne` has been explicitly set. + var hasFooOne: Bool {self._fooOne != nil} + /// Clears the value of `fooOne`. Subsequent reads from it will return its default value. + mutating func clearFooOne() {self._fooOne = nil} + + var fooTwo: Int32 { + get {_fooTwo ?? 0} + set {_fooTwo = newValue} + } + /// Returns true if `fooTwo` has been explicitly set. + var hasFooTwo: Bool {self._fooTwo != nil} + /// Clears the value of `fooTwo`. Subsequent reads from it will return its default value. + mutating func clearFooTwo() {self._fooTwo = nil} + + var fooThree: Int32 { + get {_fooThree ?? 0} + set {_fooThree = newValue} + } + /// Returns true if `fooThree` has been explicitly set. + var hasFooThree: Bool {self._fooThree != nil} + /// Clears the value of `fooThree`. Subsequent reads from it will return its default value. + mutating func clearFooThree() {self._fooThree = nil} + + var fooFour: Int32 { + get {_fooFour ?? 0} + set {_fooFour = newValue} + } + /// Returns true if `fooFour` has been explicitly set. + var hasFooFour: Bool {self._fooFour != nil} + /// Clears the value of `fooFour`. Subsequent reads from it will return its default value. + mutating func clearFooFour() {self._fooFour = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _fooOne: Int32? = nil + fileprivate var _fooTwo: Int32? = nil + fileprivate var _fooThree: Int32? = nil + fileprivate var _fooFour: Int32? = nil +} + +struct Proto2Unittest_TestVerifyInt32Simple: Sendable { + // 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 optionalInt321: Int32 { + get {_optionalInt321 ?? 0} + set {_optionalInt321 = newValue} + } + /// Returns true if `optionalInt321` has been explicitly set. + var hasOptionalInt321: Bool {self._optionalInt321 != nil} + /// Clears the value of `optionalInt321`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt321() {self._optionalInt321 = nil} + + var optionalInt322: Int32 { + get {_optionalInt322 ?? 0} + set {_optionalInt322 = newValue} + } + /// Returns true if `optionalInt322` has been explicitly set. + var hasOptionalInt322: Bool {self._optionalInt322 != nil} + /// Clears the value of `optionalInt322`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt322() {self._optionalInt322 = nil} + + var optionalInt3263: Int32 { + get {_optionalInt3263 ?? 0} + set {_optionalInt3263 = newValue} + } + /// Returns true if `optionalInt3263` has been explicitly set. + var hasOptionalInt3263: Bool {self._optionalInt3263 != nil} + /// Clears the value of `optionalInt3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3263() {self._optionalInt3263 = nil} + + var optionalInt3264: Int32 { + get {_optionalInt3264 ?? 0} + set {_optionalInt3264 = newValue} + } + /// Returns true if `optionalInt3264` has been explicitly set. + var hasOptionalInt3264: Bool {self._optionalInt3264 != nil} + /// Clears the value of `optionalInt3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3264() {self._optionalInt3264 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalInt321: Int32? = nil + fileprivate var _optionalInt322: Int32? = nil + fileprivate var _optionalInt3263: Int32? = nil + fileprivate var _optionalInt3264: Int32? = nil +} + +struct Proto2Unittest_TestVerifyInt32: Sendable { + // 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 optionalInt321: Int32 { + get {_optionalInt321 ?? 0} + set {_optionalInt321 = newValue} + } + /// Returns true if `optionalInt321` has been explicitly set. + var hasOptionalInt321: Bool {self._optionalInt321 != nil} + /// Clears the value of `optionalInt321`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt321() {self._optionalInt321 = nil} + + var optionalInt322: Int32 { + get {_optionalInt322 ?? 0} + set {_optionalInt322 = newValue} + } + /// Returns true if `optionalInt322` has been explicitly set. + var hasOptionalInt322: Bool {self._optionalInt322 != nil} + /// Clears the value of `optionalInt322`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt322() {self._optionalInt322 = nil} + + var optionalInt3263: Int32 { + get {_optionalInt3263 ?? 0} + set {_optionalInt3263 = newValue} + } + /// Returns true if `optionalInt3263` has been explicitly set. + var hasOptionalInt3263: Bool {self._optionalInt3263 != nil} + /// Clears the value of `optionalInt3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3263() {self._optionalInt3263 = nil} + + var optionalInt3264: Int32 { + get {_optionalInt3264 ?? 0} + set {_optionalInt3264 = newValue} + } + /// Returns true if `optionalInt3264` has been explicitly set. + var hasOptionalInt3264: Bool {self._optionalInt3264 != nil} + /// Clears the value of `optionalInt3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3264() {self._optionalInt3264 = nil} + + var optionalAllTypes: Proto2Unittest_TestAllTypes { + get {_optionalAllTypes ?? Proto2Unittest_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [Proto2Unittest_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalInt321: Int32? = nil + fileprivate var _optionalInt322: Int32? = nil + fileprivate var _optionalInt3263: Int32? = nil + fileprivate var _optionalInt3264: Int32? = nil + fileprivate var _optionalAllTypes: Proto2Unittest_TestAllTypes? = nil +} + +struct Proto2Unittest_TestVerifyMostlyInt32: Sendable { + // 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 optionalInt6430: Int64 { + get {_optionalInt6430 ?? 0} + set {_optionalInt6430 = newValue} + } + /// Returns true if `optionalInt6430` has been explicitly set. + var hasOptionalInt6430: Bool {self._optionalInt6430 != nil} + /// Clears the value of `optionalInt6430`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt6430() {self._optionalInt6430 = nil} + + var optionalInt321: Int32 { + get {_optionalInt321 ?? 0} + set {_optionalInt321 = newValue} + } + /// Returns true if `optionalInt321` has been explicitly set. + var hasOptionalInt321: Bool {self._optionalInt321 != nil} + /// Clears the value of `optionalInt321`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt321() {self._optionalInt321 = nil} + + var optionalInt322: Int32 { + get {_optionalInt322 ?? 0} + set {_optionalInt322 = newValue} + } + /// Returns true if `optionalInt322` has been explicitly set. + var hasOptionalInt322: Bool {self._optionalInt322 != nil} + /// Clears the value of `optionalInt322`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt322() {self._optionalInt322 = nil} + + var optionalInt323: Int32 { + get {_optionalInt323 ?? 0} + set {_optionalInt323 = newValue} + } + /// Returns true if `optionalInt323` has been explicitly set. + var hasOptionalInt323: Bool {self._optionalInt323 != nil} + /// Clears the value of `optionalInt323`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt323() {self._optionalInt323 = nil} + + var optionalInt324: Int32 { + get {_optionalInt324 ?? 0} + set {_optionalInt324 = newValue} + } + /// Returns true if `optionalInt324` has been explicitly set. + var hasOptionalInt324: Bool {self._optionalInt324 != nil} + /// Clears the value of `optionalInt324`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt324() {self._optionalInt324 = nil} + + var optionalInt3263: Int32 { + get {_optionalInt3263 ?? 0} + set {_optionalInt3263 = newValue} + } + /// Returns true if `optionalInt3263` has been explicitly set. + var hasOptionalInt3263: Bool {self._optionalInt3263 != nil} + /// Clears the value of `optionalInt3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3263() {self._optionalInt3263 = nil} + + var optionalInt3264: Int32 { + get {_optionalInt3264 ?? 0} + set {_optionalInt3264 = newValue} + } + /// Returns true if `optionalInt3264` has been explicitly set. + var hasOptionalInt3264: Bool {self._optionalInt3264 != nil} + /// Clears the value of `optionalInt3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3264() {self._optionalInt3264 = nil} + + var optionalAllTypes: Proto2Unittest_TestAllTypes { + get {_optionalAllTypes ?? Proto2Unittest_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [Proto2Unittest_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalInt6430: Int64? = nil + fileprivate var _optionalInt321: Int32? = nil + fileprivate var _optionalInt322: Int32? = nil + fileprivate var _optionalInt323: Int32? = nil + fileprivate var _optionalInt324: Int32? = nil + fileprivate var _optionalInt3263: Int32? = nil + fileprivate var _optionalInt3264: Int32? = nil + fileprivate var _optionalAllTypes: Proto2Unittest_TestAllTypes? = nil +} + +struct Proto2Unittest_TestVerifyMostlyInt32BigFieldNumber: Sendable { + // 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 optionalInt6430: Int64 { + get {_optionalInt6430 ?? 0} + set {_optionalInt6430 = newValue} + } + /// Returns true if `optionalInt6430` has been explicitly set. + var hasOptionalInt6430: Bool {self._optionalInt6430 != nil} + /// Clears the value of `optionalInt6430`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt6430() {self._optionalInt6430 = nil} + + var optionalInt32300: Int32 { + get {_optionalInt32300 ?? 0} + set {_optionalInt32300 = newValue} + } + /// Returns true if `optionalInt32300` has been explicitly set. + var hasOptionalInt32300: Bool {self._optionalInt32300 != nil} + /// Clears the value of `optionalInt32300`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32300() {self._optionalInt32300 = nil} + + var optionalInt321: Int32 { + get {_optionalInt321 ?? 0} + set {_optionalInt321 = newValue} + } + /// Returns true if `optionalInt321` has been explicitly set. + var hasOptionalInt321: Bool {self._optionalInt321 != nil} + /// Clears the value of `optionalInt321`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt321() {self._optionalInt321 = nil} + + var optionalInt322: Int32 { + get {_optionalInt322 ?? 0} + set {_optionalInt322 = newValue} + } + /// Returns true if `optionalInt322` has been explicitly set. + var hasOptionalInt322: Bool {self._optionalInt322 != nil} + /// Clears the value of `optionalInt322`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt322() {self._optionalInt322 = nil} + + var optionalInt323: Int32 { + get {_optionalInt323 ?? 0} + set {_optionalInt323 = newValue} + } + /// Returns true if `optionalInt323` has been explicitly set. + var hasOptionalInt323: Bool {self._optionalInt323 != nil} + /// Clears the value of `optionalInt323`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt323() {self._optionalInt323 = nil} + + var optionalInt324: Int32 { + get {_optionalInt324 ?? 0} + set {_optionalInt324 = newValue} + } + /// Returns true if `optionalInt324` has been explicitly set. + var hasOptionalInt324: Bool {self._optionalInt324 != nil} + /// Clears the value of `optionalInt324`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt324() {self._optionalInt324 = nil} + + var optionalInt3263: Int32 { + get {_optionalInt3263 ?? 0} + set {_optionalInt3263 = newValue} + } + /// Returns true if `optionalInt3263` has been explicitly set. + var hasOptionalInt3263: Bool {self._optionalInt3263 != nil} + /// Clears the value of `optionalInt3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3263() {self._optionalInt3263 = nil} + + var optionalInt3264: Int32 { + get {_optionalInt3264 ?? 0} + set {_optionalInt3264 = newValue} + } + /// Returns true if `optionalInt3264` has been explicitly set. + var hasOptionalInt3264: Bool {self._optionalInt3264 != nil} + /// Clears the value of `optionalInt3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3264() {self._optionalInt3264 = nil} + + var optionalAllTypes: Proto2Unittest_TestAllTypes { + get {_optionalAllTypes ?? Proto2Unittest_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [Proto2Unittest_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalInt6430: Int64? = nil + fileprivate var _optionalInt32300: Int32? = nil + fileprivate var _optionalInt321: Int32? = nil + fileprivate var _optionalInt322: Int32? = nil + fileprivate var _optionalInt323: Int32? = nil + fileprivate var _optionalInt324: Int32? = nil + fileprivate var _optionalInt3263: Int32? = nil + fileprivate var _optionalInt3264: Int32? = nil + fileprivate var _optionalAllTypes: Proto2Unittest_TestAllTypes? = nil +} + +struct Proto2Unittest_TestVerifyUint32Simple: Sendable { + // 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 optionalUint321: UInt32 { + get {_optionalUint321 ?? 0} + set {_optionalUint321 = newValue} + } + /// Returns true if `optionalUint321` has been explicitly set. + var hasOptionalUint321: Bool {self._optionalUint321 != nil} + /// Clears the value of `optionalUint321`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint321() {self._optionalUint321 = nil} + + var optionalUint322: UInt32 { + get {_optionalUint322 ?? 0} + set {_optionalUint322 = newValue} + } + /// Returns true if `optionalUint322` has been explicitly set. + var hasOptionalUint322: Bool {self._optionalUint322 != nil} + /// Clears the value of `optionalUint322`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint322() {self._optionalUint322 = nil} + + var optionalUint3263: UInt32 { + get {_optionalUint3263 ?? 0} + set {_optionalUint3263 = newValue} + } + /// Returns true if `optionalUint3263` has been explicitly set. + var hasOptionalUint3263: Bool {self._optionalUint3263 != nil} + /// Clears the value of `optionalUint3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3263() {self._optionalUint3263 = nil} + + var optionalUint3264: UInt32 { + get {_optionalUint3264 ?? 0} + set {_optionalUint3264 = newValue} + } + /// Returns true if `optionalUint3264` has been explicitly set. + var hasOptionalUint3264: Bool {self._optionalUint3264 != nil} + /// Clears the value of `optionalUint3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3264() {self._optionalUint3264 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalUint321: UInt32? = nil + fileprivate var _optionalUint322: UInt32? = nil + fileprivate var _optionalUint3263: UInt32? = nil + fileprivate var _optionalUint3264: UInt32? = nil +} + +struct Proto2Unittest_TestVerifyUint32: Sendable { + // 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 optionalUint321: UInt32 { + get {_optionalUint321 ?? 0} + set {_optionalUint321 = newValue} + } + /// Returns true if `optionalUint321` has been explicitly set. + var hasOptionalUint321: Bool {self._optionalUint321 != nil} + /// Clears the value of `optionalUint321`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint321() {self._optionalUint321 = nil} + + var optionalUint322: UInt32 { + get {_optionalUint322 ?? 0} + set {_optionalUint322 = newValue} + } + /// Returns true if `optionalUint322` has been explicitly set. + var hasOptionalUint322: Bool {self._optionalUint322 != nil} + /// Clears the value of `optionalUint322`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint322() {self._optionalUint322 = nil} + + var optionalUint3263: UInt32 { + get {_optionalUint3263 ?? 0} + set {_optionalUint3263 = newValue} + } + /// Returns true if `optionalUint3263` has been explicitly set. + var hasOptionalUint3263: Bool {self._optionalUint3263 != nil} + /// Clears the value of `optionalUint3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3263() {self._optionalUint3263 = nil} + + var optionalUint3264: UInt32 { + get {_optionalUint3264 ?? 0} + set {_optionalUint3264 = newValue} + } + /// Returns true if `optionalUint3264` has been explicitly set. + var hasOptionalUint3264: Bool {self._optionalUint3264 != nil} + /// Clears the value of `optionalUint3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3264() {self._optionalUint3264 = nil} + + var optionalAllTypes: Proto2Unittest_TestAllTypes { + get {_optionalAllTypes ?? Proto2Unittest_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [Proto2Unittest_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalUint321: UInt32? = nil + fileprivate var _optionalUint322: UInt32? = nil + fileprivate var _optionalUint3263: UInt32? = nil + fileprivate var _optionalUint3264: UInt32? = nil + fileprivate var _optionalAllTypes: Proto2Unittest_TestAllTypes? = nil +} + +struct Proto2Unittest_TestVerifyOneUint32: Sendable { + // 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 optionalUint321: UInt32 { + get {_optionalUint321 ?? 0} + set {_optionalUint321 = newValue} + } + /// Returns true if `optionalUint321` has been explicitly set. + var hasOptionalUint321: Bool {self._optionalUint321 != nil} + /// Clears the value of `optionalUint321`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint321() {self._optionalUint321 = nil} + + var optionalInt322: Int32 { + get {_optionalInt322 ?? 0} + set {_optionalInt322 = newValue} + } + /// Returns true if `optionalInt322` has been explicitly set. + var hasOptionalInt322: Bool {self._optionalInt322 != nil} + /// Clears the value of `optionalInt322`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt322() {self._optionalInt322 = nil} + + var optionalInt3263: Int32 { + get {_optionalInt3263 ?? 0} + set {_optionalInt3263 = newValue} + } + /// Returns true if `optionalInt3263` has been explicitly set. + var hasOptionalInt3263: Bool {self._optionalInt3263 != nil} + /// Clears the value of `optionalInt3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3263() {self._optionalInt3263 = nil} + + var optionalInt3264: Int32 { + get {_optionalInt3264 ?? 0} + set {_optionalInt3264 = newValue} + } + /// Returns true if `optionalInt3264` has been explicitly set. + var hasOptionalInt3264: Bool {self._optionalInt3264 != nil} + /// Clears the value of `optionalInt3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3264() {self._optionalInt3264 = nil} + + var optionalAllTypes: Proto2Unittest_TestAllTypes { + get {_optionalAllTypes ?? Proto2Unittest_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [Proto2Unittest_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalUint321: UInt32? = nil + fileprivate var _optionalInt322: Int32? = nil + fileprivate var _optionalInt3263: Int32? = nil + fileprivate var _optionalInt3264: Int32? = nil + fileprivate var _optionalAllTypes: Proto2Unittest_TestAllTypes? = nil +} + +struct Proto2Unittest_TestVerifyOneInt32BigFieldNumber: Sendable { + // 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 optionalInt3265: Int32 { + get {_optionalInt3265 ?? 0} + set {_optionalInt3265 = newValue} + } + /// Returns true if `optionalInt3265` has been explicitly set. + var hasOptionalInt3265: Bool {self._optionalInt3265 != nil} + /// Clears the value of `optionalInt3265`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3265() {self._optionalInt3265 = nil} + + var optionalInt641: Int64 { + get {_optionalInt641 ?? 0} + set {_optionalInt641 = newValue} + } + /// Returns true if `optionalInt641` has been explicitly set. + var hasOptionalInt641: Bool {self._optionalInt641 != nil} + /// Clears the value of `optionalInt641`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt641() {self._optionalInt641 = nil} + + var optionalInt642: Int64 { + get {_optionalInt642 ?? 0} + set {_optionalInt642 = newValue} + } + /// Returns true if `optionalInt642` has been explicitly set. + var hasOptionalInt642: Bool {self._optionalInt642 != nil} + /// Clears the value of `optionalInt642`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt642() {self._optionalInt642 = nil} + + var optionalInt6463: Int64 { + get {_optionalInt6463 ?? 0} + set {_optionalInt6463 = newValue} + } + /// Returns true if `optionalInt6463` has been explicitly set. + var hasOptionalInt6463: Bool {self._optionalInt6463 != nil} + /// Clears the value of `optionalInt6463`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt6463() {self._optionalInt6463 = nil} + + var optionalInt6464: Int64 { + get {_optionalInt6464 ?? 0} + set {_optionalInt6464 = newValue} + } + /// Returns true if `optionalInt6464` has been explicitly set. + var hasOptionalInt6464: Bool {self._optionalInt6464 != nil} + /// Clears the value of `optionalInt6464`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt6464() {self._optionalInt6464 = nil} + + var optionalAllTypes: Proto2Unittest_TestAllTypes { + get {_optionalAllTypes ?? Proto2Unittest_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [Proto2Unittest_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalInt3265: Int32? = nil + fileprivate var _optionalInt641: Int64? = nil + fileprivate var _optionalInt642: Int64? = nil + fileprivate var _optionalInt6463: Int64? = nil + fileprivate var _optionalInt6464: Int64? = nil + fileprivate var _optionalAllTypes: Proto2Unittest_TestAllTypes? = nil +} + +struct Proto2Unittest_TestVerifyInt32BigFieldNumber: Sendable { + // 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 optionalInt321000: Int32 { + get {_optionalInt321000 ?? 0} + set {_optionalInt321000 = newValue} + } + /// Returns true if `optionalInt321000` has been explicitly set. + var hasOptionalInt321000: Bool {self._optionalInt321000 != nil} + /// Clears the value of `optionalInt321000`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt321000() {self._optionalInt321000 = nil} + + var optionalInt3265: Int32 { + get {_optionalInt3265 ?? 0} + set {_optionalInt3265 = newValue} + } + /// Returns true if `optionalInt3265` has been explicitly set. + var hasOptionalInt3265: Bool {self._optionalInt3265 != nil} + /// Clears the value of `optionalInt3265`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3265() {self._optionalInt3265 = nil} + + var optionalInt321: Int32 { + get {_optionalInt321 ?? 0} + set {_optionalInt321 = newValue} + } + /// Returns true if `optionalInt321` has been explicitly set. + var hasOptionalInt321: Bool {self._optionalInt321 != nil} + /// Clears the value of `optionalInt321`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt321() {self._optionalInt321 = nil} + + var optionalInt322: Int32 { + get {_optionalInt322 ?? 0} + set {_optionalInt322 = newValue} + } + /// Returns true if `optionalInt322` has been explicitly set. + var hasOptionalInt322: Bool {self._optionalInt322 != nil} + /// Clears the value of `optionalInt322`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt322() {self._optionalInt322 = nil} + + var optionalInt3263: Int32 { + get {_optionalInt3263 ?? 0} + set {_optionalInt3263 = newValue} + } + /// Returns true if `optionalInt3263` has been explicitly set. + var hasOptionalInt3263: Bool {self._optionalInt3263 != nil} + /// Clears the value of `optionalInt3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3263() {self._optionalInt3263 = nil} + + var optionalInt3264: Int32 { + get {_optionalInt3264 ?? 0} + set {_optionalInt3264 = newValue} + } + /// Returns true if `optionalInt3264` has been explicitly set. + var hasOptionalInt3264: Bool {self._optionalInt3264 != nil} + /// Clears the value of `optionalInt3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt3264() {self._optionalInt3264 = nil} + + var optionalAllTypes: Proto2Unittest_TestAllTypes { + get {_optionalAllTypes ?? Proto2Unittest_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [Proto2Unittest_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalInt321000: Int32? = nil + fileprivate var _optionalInt3265: Int32? = nil + fileprivate var _optionalInt321: Int32? = nil + fileprivate var _optionalInt322: Int32? = nil + fileprivate var _optionalInt3263: Int32? = nil + fileprivate var _optionalInt3264: Int32? = nil + fileprivate var _optionalAllTypes: Proto2Unittest_TestAllTypes? = nil +} + +struct Proto2Unittest_TestVerifyUint32BigFieldNumber: Sendable { + // 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 optionalUint321000: UInt32 { + get {_optionalUint321000 ?? 0} + set {_optionalUint321000 = newValue} + } + /// Returns true if `optionalUint321000` has been explicitly set. + var hasOptionalUint321000: Bool {self._optionalUint321000 != nil} + /// Clears the value of `optionalUint321000`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint321000() {self._optionalUint321000 = nil} + + var optionalUint3265: UInt32 { + get {_optionalUint3265 ?? 0} + set {_optionalUint3265 = newValue} + } + /// Returns true if `optionalUint3265` has been explicitly set. + var hasOptionalUint3265: Bool {self._optionalUint3265 != nil} + /// Clears the value of `optionalUint3265`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3265() {self._optionalUint3265 = nil} + + var optionalUint321: UInt32 { + get {_optionalUint321 ?? 0} + set {_optionalUint321 = newValue} + } + /// Returns true if `optionalUint321` has been explicitly set. + var hasOptionalUint321: Bool {self._optionalUint321 != nil} + /// Clears the value of `optionalUint321`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint321() {self._optionalUint321 = nil} + + var optionalUint322: UInt32 { + get {_optionalUint322 ?? 0} + set {_optionalUint322 = newValue} + } + /// Returns true if `optionalUint322` has been explicitly set. + var hasOptionalUint322: Bool {self._optionalUint322 != nil} + /// Clears the value of `optionalUint322`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint322() {self._optionalUint322 = nil} + + var optionalUint3263: UInt32 { + get {_optionalUint3263 ?? 0} + set {_optionalUint3263 = newValue} + } + /// Returns true if `optionalUint3263` has been explicitly set. + var hasOptionalUint3263: Bool {self._optionalUint3263 != nil} + /// Clears the value of `optionalUint3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3263() {self._optionalUint3263 = nil} + + var optionalUint3264: UInt32 { + get {_optionalUint3264 ?? 0} + set {_optionalUint3264 = newValue} + } + /// Returns true if `optionalUint3264` has been explicitly set. + var hasOptionalUint3264: Bool {self._optionalUint3264 != nil} + /// Clears the value of `optionalUint3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3264() {self._optionalUint3264 = nil} + + var optionalAllTypes: Proto2Unittest_TestAllTypes { + get {_optionalAllTypes ?? Proto2Unittest_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [Proto2Unittest_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalUint321000: UInt32? = nil + fileprivate var _optionalUint3265: UInt32? = nil + fileprivate var _optionalUint321: UInt32? = nil + fileprivate var _optionalUint322: UInt32? = nil + fileprivate var _optionalUint3263: UInt32? = nil + fileprivate var _optionalUint3264: UInt32? = nil + fileprivate var _optionalAllTypes: Proto2Unittest_TestAllTypes? = nil +} + +struct Proto2Unittest_TestVerifyBigFieldNumberUint32: Sendable { + // 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 optionalNested: Proto2Unittest_TestVerifyBigFieldNumberUint32.Nested { + get {_optionalNested ?? Proto2Unittest_TestVerifyBigFieldNumberUint32.Nested()} + set {_optionalNested = newValue} + } + /// Returns true if `optionalNested` has been explicitly set. + var hasOptionalNested: Bool {self._optionalNested != nil} + /// Clears the value of `optionalNested`. Subsequent reads from it will return its default value. + mutating func clearOptionalNested() {self._optionalNested = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct Nested: @unchecked Sendable { + // 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 optionalUint325000: UInt32 { + get {_storage._optionalUint325000 ?? 0} + set {_uniqueStorage()._optionalUint325000 = newValue} + } + /// Returns true if `optionalUint325000` has been explicitly set. + var hasOptionalUint325000: Bool {_storage._optionalUint325000 != nil} + /// Clears the value of `optionalUint325000`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint325000() {_uniqueStorage()._optionalUint325000 = nil} + + var optionalUint321000: UInt32 { + get {_storage._optionalUint321000 ?? 0} + set {_uniqueStorage()._optionalUint321000 = newValue} + } + /// Returns true if `optionalUint321000` has been explicitly set. + var hasOptionalUint321000: Bool {_storage._optionalUint321000 != nil} + /// Clears the value of `optionalUint321000`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint321000() {_uniqueStorage()._optionalUint321000 = nil} + + var optionalUint3266: UInt32 { + get {_storage._optionalUint3266 ?? 0} + set {_uniqueStorage()._optionalUint3266 = newValue} + } + /// Returns true if `optionalUint3266` has been explicitly set. + var hasOptionalUint3266: Bool {_storage._optionalUint3266 != nil} + /// Clears the value of `optionalUint3266`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3266() {_uniqueStorage()._optionalUint3266 = nil} + + var optionalUint3265: UInt32 { + get {_storage._optionalUint3265 ?? 0} + set {_uniqueStorage()._optionalUint3265 = newValue} + } + /// Returns true if `optionalUint3265` has been explicitly set. + var hasOptionalUint3265: Bool {_storage._optionalUint3265 != nil} + /// Clears the value of `optionalUint3265`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3265() {_uniqueStorage()._optionalUint3265 = nil} + + var optionalUint321: UInt32 { + get {_storage._optionalUint321 ?? 0} + set {_uniqueStorage()._optionalUint321 = newValue} + } + /// Returns true if `optionalUint321` has been explicitly set. + var hasOptionalUint321: Bool {_storage._optionalUint321 != nil} + /// Clears the value of `optionalUint321`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint321() {_uniqueStorage()._optionalUint321 = nil} + + var optionalUint322: UInt32 { + get {_storage._optionalUint322 ?? 0} + set {_uniqueStorage()._optionalUint322 = newValue} + } + /// Returns true if `optionalUint322` has been explicitly set. + var hasOptionalUint322: Bool {_storage._optionalUint322 != nil} + /// Clears the value of `optionalUint322`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint322() {_uniqueStorage()._optionalUint322 = nil} + + var optionalUint3263: UInt32 { + get {_storage._optionalUint3263 ?? 0} + set {_uniqueStorage()._optionalUint3263 = newValue} + } + /// Returns true if `optionalUint3263` has been explicitly set. + var hasOptionalUint3263: Bool {_storage._optionalUint3263 != nil} + /// Clears the value of `optionalUint3263`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3263() {_uniqueStorage()._optionalUint3263 = nil} + + var optionalUint3264: UInt32 { + get {_storage._optionalUint3264 ?? 0} + set {_uniqueStorage()._optionalUint3264 = newValue} + } + /// Returns true if `optionalUint3264` has been explicitly set. + var hasOptionalUint3264: Bool {_storage._optionalUint3264 != nil} + /// Clears the value of `optionalUint3264`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint3264() {_uniqueStorage()._optionalUint3264 = nil} + + var optionalNested: Proto2Unittest_TestVerifyBigFieldNumberUint32.Nested { + get {_storage._optionalNested ?? Proto2Unittest_TestVerifyBigFieldNumberUint32.Nested()} + set {_uniqueStorage()._optionalNested = newValue} + } + /// Returns true if `optionalNested` has been explicitly set. + var hasOptionalNested: Bool {_storage._optionalNested != nil} + /// Clears the value of `optionalNested`. Subsequent reads from it will return its default value. + mutating func clearOptionalNested() {_uniqueStorage()._optionalNested = nil} + + var repeatedNested: [Proto2Unittest_TestVerifyBigFieldNumberUint32.Nested] { + get {_storage._repeatedNested} + set {_uniqueStorage()._repeatedNested = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + init() {} + + fileprivate var _optionalNested: Proto2Unittest_TestVerifyBigFieldNumberUint32.Nested? = nil +} + +/// This message contains different kind of enums to exercise the different +/// parsers in table-driven. +struct Proto2Unittest_EnumParseTester: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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 optionalSeqSmall0Lowfield: Proto2Unittest_EnumParseTester.SeqSmall0 { + get {_storage._optionalSeqSmall0Lowfield ?? .default} + set {_uniqueStorage()._optionalSeqSmall0Lowfield = newValue} + } + /// Returns true if `optionalSeqSmall0Lowfield` has been explicitly set. + var hasOptionalSeqSmall0Lowfield: Bool {_storage._optionalSeqSmall0Lowfield != nil} + /// Clears the value of `optionalSeqSmall0Lowfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalSeqSmall0Lowfield() {_uniqueStorage()._optionalSeqSmall0Lowfield = nil} + + var optionalSeqSmall0Midfield: Proto2Unittest_EnumParseTester.SeqSmall0 { + get {_storage._optionalSeqSmall0Midfield ?? .default} + set {_uniqueStorage()._optionalSeqSmall0Midfield = newValue} + } + /// Returns true if `optionalSeqSmall0Midfield` has been explicitly set. + var hasOptionalSeqSmall0Midfield: Bool {_storage._optionalSeqSmall0Midfield != nil} + /// Clears the value of `optionalSeqSmall0Midfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalSeqSmall0Midfield() {_uniqueStorage()._optionalSeqSmall0Midfield = nil} + + var optionalSeqSmall0Hifield: Proto2Unittest_EnumParseTester.SeqSmall0 { + get {_storage._optionalSeqSmall0Hifield ?? .default} + set {_uniqueStorage()._optionalSeqSmall0Hifield = newValue} + } + /// Returns true if `optionalSeqSmall0Hifield` has been explicitly set. + var hasOptionalSeqSmall0Hifield: Bool {_storage._optionalSeqSmall0Hifield != nil} + /// Clears the value of `optionalSeqSmall0Hifield`. Subsequent reads from it will return its default value. + mutating func clearOptionalSeqSmall0Hifield() {_uniqueStorage()._optionalSeqSmall0Hifield = nil} + + var repeatedSeqSmall0Lowfield: [Proto2Unittest_EnumParseTester.SeqSmall0] { + get {_storage._repeatedSeqSmall0Lowfield} + set {_uniqueStorage()._repeatedSeqSmall0Lowfield = newValue} + } + + var repeatedSeqSmall0Midfield: [Proto2Unittest_EnumParseTester.SeqSmall0] { + get {_storage._repeatedSeqSmall0Midfield} + set {_uniqueStorage()._repeatedSeqSmall0Midfield = newValue} + } + + var repeatedSeqSmall0Hifield: [Proto2Unittest_EnumParseTester.SeqSmall0] { + get {_storage._repeatedSeqSmall0Hifield} + set {_uniqueStorage()._repeatedSeqSmall0Hifield = newValue} + } + + var packedSeqSmall0Lowfield: [Proto2Unittest_EnumParseTester.SeqSmall0] { + get {_storage._packedSeqSmall0Lowfield} + set {_uniqueStorage()._packedSeqSmall0Lowfield = newValue} + } + + var packedSeqSmall0Midfield: [Proto2Unittest_EnumParseTester.SeqSmall0] { + get {_storage._packedSeqSmall0Midfield} + set {_uniqueStorage()._packedSeqSmall0Midfield = newValue} + } + + var packedSeqSmall0Hifield: [Proto2Unittest_EnumParseTester.SeqSmall0] { + get {_storage._packedSeqSmall0Hifield} + set {_uniqueStorage()._packedSeqSmall0Hifield = newValue} + } + + var optionalSeqSmall1Lowfield: Proto2Unittest_EnumParseTester.SeqSmall1 { + get {_storage._optionalSeqSmall1Lowfield ?? .default} + set {_uniqueStorage()._optionalSeqSmall1Lowfield = newValue} + } + /// Returns true if `optionalSeqSmall1Lowfield` has been explicitly set. + var hasOptionalSeqSmall1Lowfield: Bool {_storage._optionalSeqSmall1Lowfield != nil} + /// Clears the value of `optionalSeqSmall1Lowfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalSeqSmall1Lowfield() {_uniqueStorage()._optionalSeqSmall1Lowfield = nil} + + var optionalSeqSmall1Midfield: Proto2Unittest_EnumParseTester.SeqSmall1 { + get {_storage._optionalSeqSmall1Midfield ?? .default} + set {_uniqueStorage()._optionalSeqSmall1Midfield = newValue} + } + /// Returns true if `optionalSeqSmall1Midfield` has been explicitly set. + var hasOptionalSeqSmall1Midfield: Bool {_storage._optionalSeqSmall1Midfield != nil} + /// Clears the value of `optionalSeqSmall1Midfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalSeqSmall1Midfield() {_uniqueStorage()._optionalSeqSmall1Midfield = nil} + + var optionalSeqSmall1Hifield: Proto2Unittest_EnumParseTester.SeqSmall1 { + get {_storage._optionalSeqSmall1Hifield ?? .default} + set {_uniqueStorage()._optionalSeqSmall1Hifield = newValue} + } + /// Returns true if `optionalSeqSmall1Hifield` has been explicitly set. + var hasOptionalSeqSmall1Hifield: Bool {_storage._optionalSeqSmall1Hifield != nil} + /// Clears the value of `optionalSeqSmall1Hifield`. Subsequent reads from it will return its default value. + mutating func clearOptionalSeqSmall1Hifield() {_uniqueStorage()._optionalSeqSmall1Hifield = nil} + + var repeatedSeqSmall1Lowfield: [Proto2Unittest_EnumParseTester.SeqSmall1] { + get {_storage._repeatedSeqSmall1Lowfield} + set {_uniqueStorage()._repeatedSeqSmall1Lowfield = newValue} + } + + var repeatedSeqSmall1Midfield: [Proto2Unittest_EnumParseTester.SeqSmall1] { + get {_storage._repeatedSeqSmall1Midfield} + set {_uniqueStorage()._repeatedSeqSmall1Midfield = newValue} + } + + var repeatedSeqSmall1Hifield: [Proto2Unittest_EnumParseTester.SeqSmall1] { + get {_storage._repeatedSeqSmall1Hifield} + set {_uniqueStorage()._repeatedSeqSmall1Hifield = newValue} + } + + var packedSeqSmall1Lowfield: [Proto2Unittest_EnumParseTester.SeqSmall1] { + get {_storage._packedSeqSmall1Lowfield} + set {_uniqueStorage()._packedSeqSmall1Lowfield = newValue} + } + + var packedSeqSmall1Midfield: [Proto2Unittest_EnumParseTester.SeqSmall1] { + get {_storage._packedSeqSmall1Midfield} + set {_uniqueStorage()._packedSeqSmall1Midfield = newValue} + } + + var packedSeqSmall1Hifield: [Proto2Unittest_EnumParseTester.SeqSmall1] { + get {_storage._packedSeqSmall1Hifield} + set {_uniqueStorage()._packedSeqSmall1Hifield = newValue} + } + + var optionalSeqLargeLowfield: Proto2Unittest_EnumParseTester.SeqLarge { + get {_storage._optionalSeqLargeLowfield ?? .default} + set {_uniqueStorage()._optionalSeqLargeLowfield = newValue} + } + /// Returns true if `optionalSeqLargeLowfield` has been explicitly set. + var hasOptionalSeqLargeLowfield: Bool {_storage._optionalSeqLargeLowfield != nil} + /// Clears the value of `optionalSeqLargeLowfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalSeqLargeLowfield() {_uniqueStorage()._optionalSeqLargeLowfield = nil} + + var optionalSeqLargeMidfield: Proto2Unittest_EnumParseTester.SeqLarge { + get {_storage._optionalSeqLargeMidfield ?? .default} + set {_uniqueStorage()._optionalSeqLargeMidfield = newValue} + } + /// Returns true if `optionalSeqLargeMidfield` has been explicitly set. + var hasOptionalSeqLargeMidfield: Bool {_storage._optionalSeqLargeMidfield != nil} + /// Clears the value of `optionalSeqLargeMidfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalSeqLargeMidfield() {_uniqueStorage()._optionalSeqLargeMidfield = nil} + + var optionalSeqLargeHifield: Proto2Unittest_EnumParseTester.SeqLarge { + get {_storage._optionalSeqLargeHifield ?? .default} + set {_uniqueStorage()._optionalSeqLargeHifield = newValue} + } + /// Returns true if `optionalSeqLargeHifield` has been explicitly set. + var hasOptionalSeqLargeHifield: Bool {_storage._optionalSeqLargeHifield != nil} + /// Clears the value of `optionalSeqLargeHifield`. Subsequent reads from it will return its default value. + mutating func clearOptionalSeqLargeHifield() {_uniqueStorage()._optionalSeqLargeHifield = nil} + + var repeatedSeqLargeLowfield: [Proto2Unittest_EnumParseTester.SeqLarge] { + get {_storage._repeatedSeqLargeLowfield} + set {_uniqueStorage()._repeatedSeqLargeLowfield = newValue} + } + + var repeatedSeqLargeMidfield: [Proto2Unittest_EnumParseTester.SeqLarge] { + get {_storage._repeatedSeqLargeMidfield} + set {_uniqueStorage()._repeatedSeqLargeMidfield = newValue} + } + + var repeatedSeqLargeHifield: [Proto2Unittest_EnumParseTester.SeqLarge] { + get {_storage._repeatedSeqLargeHifield} + set {_uniqueStorage()._repeatedSeqLargeHifield = newValue} + } + + var packedSeqLargeLowfield: [Proto2Unittest_EnumParseTester.SeqLarge] { + get {_storage._packedSeqLargeLowfield} + set {_uniqueStorage()._packedSeqLargeLowfield = newValue} + } + + var packedSeqLargeMidfield: [Proto2Unittest_EnumParseTester.SeqLarge] { + get {_storage._packedSeqLargeMidfield} + set {_uniqueStorage()._packedSeqLargeMidfield = newValue} + } + + var packedSeqLargeHifield: [Proto2Unittest_EnumParseTester.SeqLarge] { + get {_storage._packedSeqLargeHifield} + set {_uniqueStorage()._packedSeqLargeHifield = newValue} + } + + var optionalArbitraryLowfield: Proto2Unittest_EnumParseTester.Arbitrary { + get {_storage._optionalArbitraryLowfield ?? .default} + set {_uniqueStorage()._optionalArbitraryLowfield = newValue} + } + /// Returns true if `optionalArbitraryLowfield` has been explicitly set. + var hasOptionalArbitraryLowfield: Bool {_storage._optionalArbitraryLowfield != nil} + /// Clears the value of `optionalArbitraryLowfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalArbitraryLowfield() {_uniqueStorage()._optionalArbitraryLowfield = nil} + + var optionalArbitraryMidfield: Proto2Unittest_EnumParseTester.Arbitrary { + get {_storage._optionalArbitraryMidfield ?? .default} + set {_uniqueStorage()._optionalArbitraryMidfield = newValue} + } + /// Returns true if `optionalArbitraryMidfield` has been explicitly set. + var hasOptionalArbitraryMidfield: Bool {_storage._optionalArbitraryMidfield != nil} + /// Clears the value of `optionalArbitraryMidfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalArbitraryMidfield() {_uniqueStorage()._optionalArbitraryMidfield = nil} + + var optionalArbitraryHifield: Proto2Unittest_EnumParseTester.Arbitrary { + get {_storage._optionalArbitraryHifield ?? .default} + set {_uniqueStorage()._optionalArbitraryHifield = newValue} + } + /// Returns true if `optionalArbitraryHifield` has been explicitly set. + var hasOptionalArbitraryHifield: Bool {_storage._optionalArbitraryHifield != nil} + /// Clears the value of `optionalArbitraryHifield`. Subsequent reads from it will return its default value. + mutating func clearOptionalArbitraryHifield() {_uniqueStorage()._optionalArbitraryHifield = nil} + + var repeatedArbitraryLowfield: [Proto2Unittest_EnumParseTester.Arbitrary] { + get {_storage._repeatedArbitraryLowfield} + set {_uniqueStorage()._repeatedArbitraryLowfield = newValue} + } + + var repeatedArbitraryMidfield: [Proto2Unittest_EnumParseTester.Arbitrary] { + get {_storage._repeatedArbitraryMidfield} + set {_uniqueStorage()._repeatedArbitraryMidfield = newValue} + } + + var repeatedArbitraryHifield: [Proto2Unittest_EnumParseTester.Arbitrary] { + get {_storage._repeatedArbitraryHifield} + set {_uniqueStorage()._repeatedArbitraryHifield = newValue} + } + + var packedArbitraryLowfield: [Proto2Unittest_EnumParseTester.Arbitrary] { + get {_storage._packedArbitraryLowfield} + set {_uniqueStorage()._packedArbitraryLowfield = newValue} + } + + var packedArbitraryMidfield: [Proto2Unittest_EnumParseTester.Arbitrary] { + get {_storage._packedArbitraryMidfield} + set {_uniqueStorage()._packedArbitraryMidfield = newValue} + } + + var packedArbitraryHifield: [Proto2Unittest_EnumParseTester.Arbitrary] { + get {_storage._packedArbitraryHifield} + set {_uniqueStorage()._packedArbitraryHifield = newValue} + } + + /// An arbitrary field we can append to to break the runs of repeated fields. + var otherField: Int32 { + get {_storage._otherField ?? 0} + set {_uniqueStorage()._otherField = newValue} + } + /// Returns true if `otherField` has been explicitly set. + var hasOtherField: Bool {_storage._otherField != nil} + /// Clears the value of `otherField`. Subsequent reads from it will return its default value. + mutating func clearOtherField() {_uniqueStorage()._otherField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum SeqSmall0: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case `default` = 0 + case seqSmall01 = 1 + case seqSmall02 = 2 + + init() { + self = .default + } + + } + + enum SeqSmall1: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case `default` = 1 + case seqSmall12 = 2 + case seqSmall13 = 3 + + init() { + self = .default + } + + } + + enum SeqLarge: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case `default` = -1 + case seqLarge0 = 0 + case seqLarge1 = 1 + case seqLarge2 = 2 + case seqLarge3 = 3 + case seqLarge4 = 4 + case seqLarge5 = 5 + case seqLarge6 = 6 + case seqLarge7 = 7 + case seqLarge8 = 8 + case seqLarge9 = 9 + case seqLarge10 = 10 + case seqLarge11 = 11 + case seqLarge12 = 12 + case seqLarge13 = 13 + case seqLarge14 = 14 + case seqLarge15 = 15 + case seqLarge16 = 16 + case seqLarge17 = 17 + case seqLarge18 = 18 + case seqLarge19 = 19 + case seqLarge20 = 20 + case seqLarge21 = 21 + case seqLarge22 = 22 + case seqLarge23 = 23 + case seqLarge24 = 24 + case seqLarge25 = 25 + case seqLarge26 = 26 + case seqLarge27 = 27 + case seqLarge28 = 28 + case seqLarge29 = 29 + case seqLarge30 = 30 + case seqLarge31 = 31 + case seqLarge32 = 32 + case seqLarge33 = 33 + + init() { + self = .default + } + + } + + enum Arbitrary: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case `default` = -123123 + case arbitrary1 = -123 + case arbitrary2 = 213 + case arbitrary3 = 213213 + case min = -2147483648 + case max = 2147483647 + + init() { + self = .default + } + + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// This message contains different kind of bool fields to exercise the different +/// parsers in table-drived. +struct Proto2Unittest_BoolParseTester: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 optionalBoolLowfield: Bool { + get {_optionalBoolLowfield ?? false} + set {_optionalBoolLowfield = newValue} + } + /// Returns true if `optionalBoolLowfield` has been explicitly set. + var hasOptionalBoolLowfield: Bool {self._optionalBoolLowfield != nil} + /// Clears the value of `optionalBoolLowfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalBoolLowfield() {self._optionalBoolLowfield = nil} + + var optionalBoolMidfield: Bool { + get {_optionalBoolMidfield ?? false} + set {_optionalBoolMidfield = newValue} + } + /// Returns true if `optionalBoolMidfield` has been explicitly set. + var hasOptionalBoolMidfield: Bool {self._optionalBoolMidfield != nil} + /// Clears the value of `optionalBoolMidfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalBoolMidfield() {self._optionalBoolMidfield = nil} + + var optionalBoolHifield: Bool { + get {_optionalBoolHifield ?? false} + set {_optionalBoolHifield = newValue} + } + /// Returns true if `optionalBoolHifield` has been explicitly set. + var hasOptionalBoolHifield: Bool {self._optionalBoolHifield != nil} + /// Clears the value of `optionalBoolHifield`. Subsequent reads from it will return its default value. + mutating func clearOptionalBoolHifield() {self._optionalBoolHifield = nil} + + var repeatedBoolLowfield: [Bool] = [] + + var repeatedBoolMidfield: [Bool] = [] + + var repeatedBoolHifield: [Bool] = [] + + var packedBoolLowfield: [Bool] = [] + + var packedBoolMidfield: [Bool] = [] + + var packedBoolHifield: [Bool] = [] + + /// An arbitrary field we can append to to break the runs of repeated fields. + var otherField: Int32 { + get {_otherField ?? 0} + set {_otherField = newValue} + } + /// Returns true if `otherField` has been explicitly set. + var hasOtherField: Bool {self._otherField != nil} + /// Clears the value of `otherField`. Subsequent reads from it will return its default value. + mutating func clearOtherField() {self._otherField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _optionalBoolLowfield: Bool? = nil + fileprivate var _optionalBoolMidfield: Bool? = nil + fileprivate var _optionalBoolHifield: Bool? = nil + fileprivate var _otherField: Int32? = nil +} + +struct Proto2Unittest_Int32ParseTester: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 optionalInt32Lowfield: Int32 { + get {_optionalInt32Lowfield ?? 0} + set {_optionalInt32Lowfield = newValue} + } + /// Returns true if `optionalInt32Lowfield` has been explicitly set. + var hasOptionalInt32Lowfield: Bool {self._optionalInt32Lowfield != nil} + /// Clears the value of `optionalInt32Lowfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32Lowfield() {self._optionalInt32Lowfield = nil} + + var optionalInt32Midfield: Int32 { + get {_optionalInt32Midfield ?? 0} + set {_optionalInt32Midfield = newValue} + } + /// Returns true if `optionalInt32Midfield` has been explicitly set. + var hasOptionalInt32Midfield: Bool {self._optionalInt32Midfield != nil} + /// Clears the value of `optionalInt32Midfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32Midfield() {self._optionalInt32Midfield = nil} + + var optionalInt32Hifield: Int32 { + get {_optionalInt32Hifield ?? 0} + set {_optionalInt32Hifield = newValue} + } + /// Returns true if `optionalInt32Hifield` has been explicitly set. + var hasOptionalInt32Hifield: Bool {self._optionalInt32Hifield != nil} + /// Clears the value of `optionalInt32Hifield`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32Hifield() {self._optionalInt32Hifield = nil} + + var repeatedInt32Lowfield: [Int32] = [] + + var repeatedInt32Midfield: [Int32] = [] + + var repeatedInt32Hifield: [Int32] = [] + + var packedInt32Lowfield: [Int32] = [] + + var packedInt32Midfield: [Int32] = [] + + var packedInt32Hifield: [Int32] = [] + + /// An arbitrary field we can append to to break the runs of repeated fields. + var otherField: Int32 { + get {_otherField ?? 0} + set {_otherField = newValue} + } + /// Returns true if `otherField` has been explicitly set. + var hasOtherField: Bool {self._otherField != nil} + /// Clears the value of `otherField`. Subsequent reads from it will return its default value. + mutating func clearOtherField() {self._otherField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _optionalInt32Lowfield: Int32? = nil + fileprivate var _optionalInt32Midfield: Int32? = nil + fileprivate var _optionalInt32Hifield: Int32? = nil + fileprivate var _otherField: Int32? = nil +} + +struct Proto2Unittest_Int64ParseTester: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 optionalInt64Lowfield: Int64 { + get {_optionalInt64Lowfield ?? 0} + set {_optionalInt64Lowfield = newValue} + } + /// Returns true if `optionalInt64Lowfield` has been explicitly set. + var hasOptionalInt64Lowfield: Bool {self._optionalInt64Lowfield != nil} + /// Clears the value of `optionalInt64Lowfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64Lowfield() {self._optionalInt64Lowfield = nil} + + var optionalInt64Midfield: Int64 { + get {_optionalInt64Midfield ?? 0} + set {_optionalInt64Midfield = newValue} + } + /// Returns true if `optionalInt64Midfield` has been explicitly set. + var hasOptionalInt64Midfield: Bool {self._optionalInt64Midfield != nil} + /// Clears the value of `optionalInt64Midfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64Midfield() {self._optionalInt64Midfield = nil} + + var optionalInt64Hifield: Int64 { + get {_optionalInt64Hifield ?? 0} + set {_optionalInt64Hifield = newValue} + } + /// Returns true if `optionalInt64Hifield` has been explicitly set. + var hasOptionalInt64Hifield: Bool {self._optionalInt64Hifield != nil} + /// Clears the value of `optionalInt64Hifield`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64Hifield() {self._optionalInt64Hifield = nil} + + var repeatedInt64Lowfield: [Int64] = [] + + var repeatedInt64Midfield: [Int64] = [] + + var repeatedInt64Hifield: [Int64] = [] + + var packedInt64Lowfield: [Int64] = [] + + var packedInt64Midfield: [Int64] = [] + + var packedInt64Hifield: [Int64] = [] + + /// An arbitrary field we can append to to break the runs of repeated fields. + var otherField: Int32 { + get {_otherField ?? 0} + set {_otherField = newValue} + } + /// Returns true if `otherField` has been explicitly set. + var hasOtherField: Bool {self._otherField != nil} + /// Clears the value of `otherField`. Subsequent reads from it will return its default value. + mutating func clearOtherField() {self._otherField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _optionalInt64Lowfield: Int64? = nil + fileprivate var _optionalInt64Midfield: Int64? = nil + fileprivate var _optionalInt64Hifield: Int64? = nil + fileprivate var _otherField: Int32? = nil +} + +struct Proto2Unittest_InlinedStringIdxRegressionProto: @unchecked Sendable { + // 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 mix data to make sure aux ids and inlined string idx do not match. + /// aux_idx == inlined_string_idx == 1 + var str1: String { + get {_storage._str1 ?? String()} + set {_uniqueStorage()._str1 = newValue} + } + /// Returns true if `str1` has been explicitly set. + var hasStr1: Bool {_storage._str1 != nil} + /// Clears the value of `str1`. Subsequent reads from it will return its default value. + mutating func clearStr1() {_uniqueStorage()._str1 = nil} + + /// aux_idx == 2 + var sub: Proto2Unittest_InlinedStringIdxRegressionProto { + get {_storage._sub ?? Proto2Unittest_InlinedStringIdxRegressionProto()} + set {_uniqueStorage()._sub = newValue} + } + /// Returns true if `sub` has been explicitly set. + var hasSub: Bool {_storage._sub != nil} + /// Clears the value of `sub`. Subsequent reads from it will return its default value. + mutating func clearSub() {_uniqueStorage()._sub = nil} + + /// aux_idx == 3, inlined_string_idx == 2 + var str2: String { + get {_storage._str2 ?? String()} + set {_uniqueStorage()._str2 = newValue} + } + /// Returns true if `str2` has been explicitly set. + var hasStr2: Bool {_storage._str2 != nil} + /// Clears the value of `str2`. Subsequent reads from it will return its default value. + mutating func clearStr2() {_uniqueStorage()._str2 = nil} + + /// aux_idx == 4, inlined_string_idx == 3 + var str3: Data { + get {_storage._str3 ?? Data()} + set {_uniqueStorage()._str3 = newValue} + } + /// Returns true if `str3` has been explicitly set. + var hasStr3: Bool {_storage._str3 != nil} + /// Clears the value of `str3`. Subsequent reads from it will return its default value. + mutating func clearStr3() {_uniqueStorage()._str3 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Proto2Unittest_StringParseTester: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 optionalStringLowfield: String { + get {_optionalStringLowfield ?? String()} + set {_optionalStringLowfield = newValue} + } + /// Returns true if `optionalStringLowfield` has been explicitly set. + var hasOptionalStringLowfield: Bool {self._optionalStringLowfield != nil} + /// Clears the value of `optionalStringLowfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringLowfield() {self._optionalStringLowfield = nil} + + var optionalStringMidfield: String { + get {_optionalStringMidfield ?? String()} + set {_optionalStringMidfield = newValue} + } + /// Returns true if `optionalStringMidfield` has been explicitly set. + var hasOptionalStringMidfield: Bool {self._optionalStringMidfield != nil} + /// Clears the value of `optionalStringMidfield`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringMidfield() {self._optionalStringMidfield = nil} + + var optionalStringHifield: String { + get {_optionalStringHifield ?? String()} + set {_optionalStringHifield = newValue} + } + /// Returns true if `optionalStringHifield` has been explicitly set. + var hasOptionalStringHifield: Bool {self._optionalStringHifield != nil} + /// Clears the value of `optionalStringHifield`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringHifield() {self._optionalStringHifield = nil} + + var repeatedStringLowfield: [String] = [] + + var repeatedStringMidfield: [String] = [] + + var repeatedStringHifield: [String] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _optionalStringLowfield: String? = nil + fileprivate var _optionalStringMidfield: String? = nil + fileprivate var _optionalStringHifield: String? = nil +} + +struct Proto2Unittest_BadFieldNames: Sendable { + // 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 optionalInt32: Int32 { + get {_optionalInt32 ?? 0} + set {_optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {self._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {self._optionalInt32 = nil} + + var `for`: Int32 { + get {_for ?? 0} + set {_for = newValue} + } + /// Returns true if ``for`` has been explicitly set. + var hasFor: Bool {self._for != nil} + /// Clears the value of ``for``. Subsequent reads from it will return its default value. + mutating func clearFor() {self._for = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalInt32: Int32? = nil + fileprivate var _for: Int32? = nil +} + +struct Proto2Unittest_TestNestedMessageRedaction: Sendable { + // 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 optionalUnredactedNestedString: String { + get {_optionalUnredactedNestedString ?? String()} + set {_optionalUnredactedNestedString = newValue} + } + /// Returns true if `optionalUnredactedNestedString` has been explicitly set. + var hasOptionalUnredactedNestedString: Bool {self._optionalUnredactedNestedString != nil} + /// Clears the value of `optionalUnredactedNestedString`. Subsequent reads from it will return its default value. + mutating func clearOptionalUnredactedNestedString() {self._optionalUnredactedNestedString = nil} + + var optionalRedactedNestedString: String { + get {_optionalRedactedNestedString ?? String()} + set {_optionalRedactedNestedString = newValue} + } + /// Returns true if `optionalRedactedNestedString` has been explicitly set. + var hasOptionalRedactedNestedString: Bool {self._optionalRedactedNestedString != nil} + /// Clears the value of `optionalRedactedNestedString`. Subsequent reads from it will return its default value. + mutating func clearOptionalRedactedNestedString() {self._optionalRedactedNestedString = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalUnredactedNestedString: String? = nil + fileprivate var _optionalRedactedNestedString: String? = nil +} + +struct Proto2Unittest_RedactedFields: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 optionalRedactedString: String { + get {_optionalRedactedString ?? String()} + set {_optionalRedactedString = newValue} + } + /// Returns true if `optionalRedactedString` has been explicitly set. + var hasOptionalRedactedString: Bool {self._optionalRedactedString != nil} + /// Clears the value of `optionalRedactedString`. Subsequent reads from it will return its default value. + mutating func clearOptionalRedactedString() {self._optionalRedactedString = nil} + + var optionalUnredactedString: String { + get {_optionalUnredactedString ?? String()} + set {_optionalUnredactedString = newValue} + } + /// Returns true if `optionalUnredactedString` has been explicitly set. + var hasOptionalUnredactedString: Bool {self._optionalUnredactedString != nil} + /// Clears the value of `optionalUnredactedString`. Subsequent reads from it will return its default value. + mutating func clearOptionalUnredactedString() {self._optionalUnredactedString = nil} + + var repeatedRedactedString: [String] = [] + + var repeatedUnredactedString: [String] = [] + + var optionalRedactedMessage: Proto2Unittest_TestNestedMessageRedaction { + get {_optionalRedactedMessage ?? Proto2Unittest_TestNestedMessageRedaction()} + set {_optionalRedactedMessage = newValue} + } + /// Returns true if `optionalRedactedMessage` has been explicitly set. + var hasOptionalRedactedMessage: Bool {self._optionalRedactedMessage != nil} + /// Clears the value of `optionalRedactedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalRedactedMessage() {self._optionalRedactedMessage = nil} + + var optionalUnredactedMessage: Proto2Unittest_TestNestedMessageRedaction { + get {_optionalUnredactedMessage ?? Proto2Unittest_TestNestedMessageRedaction()} + set {_optionalUnredactedMessage = newValue} + } + /// Returns true if `optionalUnredactedMessage` has been explicitly set. + var hasOptionalUnredactedMessage: Bool {self._optionalUnredactedMessage != nil} + /// Clears the value of `optionalUnredactedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalUnredactedMessage() {self._optionalUnredactedMessage = nil} + + var repeatedRedactedMessage: [Proto2Unittest_TestNestedMessageRedaction] = [] + + var repeatedUnredactedMessage: [Proto2Unittest_TestNestedMessageRedaction] = [] + + var mapRedactedString: Dictionary = [:] + + var mapUnredactedString: Dictionary = [:] + + var optionalRedactedFalseString: String { + get {_optionalRedactedFalseString ?? String()} + set {_optionalRedactedFalseString = newValue} + } + /// Returns true if `optionalRedactedFalseString` has been explicitly set. + var hasOptionalRedactedFalseString: Bool {self._optionalRedactedFalseString != nil} + /// Clears the value of `optionalRedactedFalseString`. Subsequent reads from it will return its default value. + mutating func clearOptionalRedactedFalseString() {self._optionalRedactedFalseString = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _optionalRedactedString: String? = nil + fileprivate var _optionalUnredactedString: String? = nil + fileprivate var _optionalRedactedMessage: Proto2Unittest_TestNestedMessageRedaction? = nil + fileprivate var _optionalUnredactedMessage: Proto2Unittest_TestNestedMessageRedaction? = nil + fileprivate var _optionalRedactedFalseString: String? = nil +} + +struct Proto2Unittest_TestString: Sendable { + // 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 optionalString: String { + get {_optionalString ?? String()} + set {_optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {self._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {self._optionalString = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalString: String? = nil +} + +struct Proto2Unittest_TestCord: Sendable { + // 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 optionalBytesCord: Data { + get {_optionalBytesCord ?? Data()} + set {_optionalBytesCord = newValue} + } + /// Returns true if `optionalBytesCord` has been explicitly set. + var hasOptionalBytesCord: Bool {self._optionalBytesCord != nil} + /// Clears the value of `optionalBytesCord`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytesCord() {self._optionalBytesCord = nil} + + var optionalBytesCordDefault: Data { + get {_optionalBytesCordDefault ?? Data([104, 101, 108, 108, 111])} + set {_optionalBytesCordDefault = newValue} + } + /// Returns true if `optionalBytesCordDefault` has been explicitly set. + var hasOptionalBytesCordDefault: Bool {self._optionalBytesCordDefault != nil} + /// Clears the value of `optionalBytesCordDefault`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytesCordDefault() {self._optionalBytesCordDefault = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalBytesCord: Data? = nil + fileprivate var _optionalBytesCordDefault: Data? = nil +} + +struct Proto2Unittest_TestPackedEnumSmallRange: Sendable { + // 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 vals: [Proto2Unittest_TestPackedEnumSmallRange.NestedEnum] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unspecified = 0 + case foo = 1 + case bar = 2 + case baz = 3 + + init() { + self = .unspecified + } + + } + + init() {} +} + +struct Proto2Unittest_EnumsForBenchmark: Sendable { + // 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() + + enum Flat: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case a0 = 0 + case a1 = 1 + case a2 = 2 + case a3 = 3 + case a4 = 4 + case a5 = 5 + case a6 = 6 + case a7 = 7 + case a8 = 8 + case a9 = 9 + case a10 = 10 + case a11 = 11 + case a12 = 12 + case a13 = 13 + case a14 = 14 + case a15 = 15 + + init() { + self = .a0 + } + + } + + /// Has a few holes, bitmap can be used. + enum AlmostFlat: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case b0 = 0 + case b1 = 1 + case b2 = 2 + case b3 = 3 + case b5 = 5 + case b6 = 6 + case b7 = 7 + case b8 = 8 + case b9 = 9 + case b11 = 11 + case b12 = 12 + case b13 = 13 + case b14 = 14 + case b15 = 15 + case b17 = 17 + case b19 = 19 + + init() { + self = .b0 + } + + } + + enum Sparse: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case c536 = 536 + case c8387 = 8387 + case c9673 = 9673 + case c10285 = 10285 + case c13318 = 13318 + case c15963 = 15963 + case c16439 = 16439 + case c18197 = 18197 + case c19430 = 19430 + case c20361 = 20361 + case c20706 = 20706 + case c21050 = 21050 + case c21906 = 21906 + case c27265 = 27265 + case c30109 = 30109 + case c31670 = 31670 + + init() { + self = .c536 + } + + } + + init() {} +} + +struct Proto2Unittest_TestMessageWithManyRepeatedPtrFields: @unchecked Sendable { + // 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 repeatedString1: [String] { + get {_storage._repeatedString1} + set {_uniqueStorage()._repeatedString1 = newValue} + } + + var repeatedString2: [String] { + get {_storage._repeatedString2} + set {_uniqueStorage()._repeatedString2 = newValue} + } + + var repeatedString3: [String] { + get {_storage._repeatedString3} + set {_uniqueStorage()._repeatedString3 = newValue} + } + + var repeatedString4: [String] { + get {_storage._repeatedString4} + set {_uniqueStorage()._repeatedString4 = newValue} + } + + var repeatedString5: [String] { + get {_storage._repeatedString5} + set {_uniqueStorage()._repeatedString5 = newValue} + } + + var repeatedString6: [String] { + get {_storage._repeatedString6} + set {_uniqueStorage()._repeatedString6 = newValue} + } + + var repeatedString7: [String] { + get {_storage._repeatedString7} + set {_uniqueStorage()._repeatedString7 = newValue} + } + + var repeatedString8: [String] { + get {_storage._repeatedString8} + set {_uniqueStorage()._repeatedString8 = newValue} + } + + var repeatedString9: [String] { + get {_storage._repeatedString9} + set {_uniqueStorage()._repeatedString9 = newValue} + } + + var repeatedString10: [String] { + get {_storage._repeatedString10} + set {_uniqueStorage()._repeatedString10 = newValue} + } + + var repeatedString11: [String] { + get {_storage._repeatedString11} + set {_uniqueStorage()._repeatedString11 = newValue} + } + + var repeatedString12: [String] { + get {_storage._repeatedString12} + set {_uniqueStorage()._repeatedString12 = newValue} + } + + var repeatedString13: [String] { + get {_storage._repeatedString13} + set {_uniqueStorage()._repeatedString13 = newValue} + } + + var repeatedString14: [String] { + get {_storage._repeatedString14} + set {_uniqueStorage()._repeatedString14 = newValue} + } + + var repeatedString15: [String] { + get {_storage._repeatedString15} + set {_uniqueStorage()._repeatedString15 = newValue} + } + + var repeatedString16: [String] { + get {_storage._repeatedString16} + set {_uniqueStorage()._repeatedString16 = newValue} + } + + var repeatedString17: [String] { + get {_storage._repeatedString17} + set {_uniqueStorage()._repeatedString17 = newValue} + } + + var repeatedString18: [String] { + get {_storage._repeatedString18} + set {_uniqueStorage()._repeatedString18 = newValue} + } + + var repeatedString19: [String] { + get {_storage._repeatedString19} + set {_uniqueStorage()._repeatedString19 = newValue} + } + + var repeatedString20: [String] { + get {_storage._repeatedString20} + set {_uniqueStorage()._repeatedString20 = newValue} + } + + var repeatedString21: [String] { + get {_storage._repeatedString21} + set {_uniqueStorage()._repeatedString21 = newValue} + } + + var repeatedString22: [String] { + get {_storage._repeatedString22} + set {_uniqueStorage()._repeatedString22 = newValue} + } + + var repeatedString23: [String] { + get {_storage._repeatedString23} + set {_uniqueStorage()._repeatedString23 = newValue} + } + + var repeatedString24: [String] { + get {_storage._repeatedString24} + set {_uniqueStorage()._repeatedString24 = newValue} + } + + var repeatedString25: [String] { + get {_storage._repeatedString25} + set {_uniqueStorage()._repeatedString25 = newValue} + } + + var repeatedString26: [String] { + get {_storage._repeatedString26} + set {_uniqueStorage()._repeatedString26 = newValue} + } + + var repeatedString27: [String] { + get {_storage._repeatedString27} + set {_uniqueStorage()._repeatedString27 = newValue} + } + + var repeatedString28: [String] { + get {_storage._repeatedString28} + set {_uniqueStorage()._repeatedString28 = newValue} + } + + var repeatedString29: [String] { + get {_storage._repeatedString29} + set {_uniqueStorage()._repeatedString29 = newValue} + } + + var repeatedString30: [String] { + get {_storage._repeatedString30} + set {_uniqueStorage()._repeatedString30 = newValue} + } + + var repeatedString31: [String] { + get {_storage._repeatedString31} + set {_uniqueStorage()._repeatedString31 = newValue} + } + + var repeatedString32: [String] { + get {_storage._repeatedString32} + set {_uniqueStorage()._repeatedString32 = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Proto2Unittest_MessageCreatorZeroInit: @unchecked Sendable { + // 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 i: Int32 { + get {_storage._i ?? 0} + set {_uniqueStorage()._i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {_storage._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {_uniqueStorage()._i = nil} + + var d: Double { + get {_storage._d ?? 0} + set {_uniqueStorage()._d = newValue} + } + /// Returns true if `d` has been explicitly set. + var hasD: Bool {_storage._d != nil} + /// Clears the value of `d`. Subsequent reads from it will return its default value. + mutating func clearD() {_uniqueStorage()._d = nil} + + var m: Proto2Unittest_MessageCreatorZeroInit { + get {_storage._m ?? Proto2Unittest_MessageCreatorZeroInit()} + set {_uniqueStorage()._m = newValue} + } + /// Returns true if `m` has been explicitly set. + var hasM: Bool {_storage._m != nil} + /// Clears the value of `m`. Subsequent reads from it will return its default value. + mutating func clearM() {_uniqueStorage()._m = nil} + + var one: OneOf_One? { + get {return _storage._one} + set {_uniqueStorage()._one = newValue} + } + + var os: String { + get { + if case .os(let v)? = _storage._one {return v} + return String() + } + set {_uniqueStorage()._one = .os(newValue)} + } + + var oc: String { + get { + if case .oc(let v)? = _storage._one {return v} + return String() + } + set {_uniqueStorage()._one = .oc(newValue)} + } + + var of: UInt64 { + get { + if case .of(let v)? = _storage._one {return v} + return 0 + } + set {_uniqueStorage()._one = .of(newValue)} + } + + var ol: Proto2Unittest_MessageCreatorZeroInit { + get { + if case .ol(let v)? = _storage._one {return v} + return Proto2Unittest_MessageCreatorZeroInit() + } + set {_uniqueStorage()._one = .ol(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_One: Equatable, Sendable { + case os(String) + case oc(String) + case of(UInt64) + case ol(Proto2Unittest_MessageCreatorZeroInit) + + } + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Proto2Unittest_MessageCreatorMemcpy: @unchecked Sendable { + // 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 s: String { + get {_storage._s ?? String()} + set {_uniqueStorage()._s = newValue} + } + /// Returns true if `s` has been explicitly set. + var hasS: Bool {_storage._s != nil} + /// Clears the value of `s`. Subsequent reads from it will return its default value. + mutating func clearS() {_uniqueStorage()._s = nil} + + var i: [Int32] { + get {_storage._i} + set {_uniqueStorage()._i = newValue} + } + + var m: Proto2Unittest_MessageCreatorMemcpy { + get {_storage._m ?? Proto2Unittest_MessageCreatorMemcpy()} + set {_uniqueStorage()._m = newValue} + } + /// Returns true if `m` has been explicitly set. + var hasM: Bool {_storage._m != nil} + /// Clears the value of `m`. Subsequent reads from it will return its default value. + mutating func clearM() {_uniqueStorage()._m = nil} + + var m2: Dictionary { + get {_storage._m2} + set {_uniqueStorage()._m2 = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Proto2Unittest_MessageCreatorFunc: Sendable { + // 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. + + /// This one is ArenaDtorNeeds::kRequired so we must run the constructor. + var c: String { + get {_c ?? String()} + set {_c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {self._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {self._c = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _c: String? = nil +} + +struct Proto2Unittest_FastParseTableCompression: Sendable { + // 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 importantField1: Int32 { + get {_importantField1 ?? 0} + set {_importantField1 = newValue} + } + /// Returns true if `importantField1` has been explicitly set. + var hasImportantField1: Bool {self._importantField1 != nil} + /// Clears the value of `importantField1`. Subsequent reads from it will return its default value. + mutating func clearImportantField1() {self._importantField1 = nil} + + var importantField2: Int32 { + get {_importantField2 ?? 0} + set {_importantField2 = newValue} + } + /// Returns true if `importantField2` has been explicitly set. + var hasImportantField2: Bool {self._importantField2 != nil} + /// Clears the value of `importantField2`. Subsequent reads from it will return its default value. + mutating func clearImportantField2() {self._importantField2 = nil} + + var unimportantField3: Int32 { + get {_unimportantField3 ?? 0} + set {_unimportantField3 = newValue} + } + /// Returns true if `unimportantField3` has been explicitly set. + var hasUnimportantField3: Bool {self._unimportantField3 != nil} + /// Clears the value of `unimportantField3`. Subsequent reads from it will return its default value. + mutating func clearUnimportantField3() {self._unimportantField3 = nil} + + var unimportantField4: Int32 { + get {_unimportantField4 ?? 0} + set {_unimportantField4 = newValue} + } + /// Returns true if `unimportantField4` has been explicitly set. + var hasUnimportantField4: Bool {self._unimportantField4 != nil} + /// Clears the value of `unimportantField4`. Subsequent reads from it will return its default value. + mutating func clearUnimportantField4() {self._unimportantField4 = nil} + + var unimportantField5: Int32 { + get {_unimportantField5 ?? 0} + set {_unimportantField5 = newValue} + } + /// Returns true if `unimportantField5` has been explicitly set. + var hasUnimportantField5: Bool {self._unimportantField5 != nil} + /// Clears the value of `unimportantField5`. Subsequent reads from it will return its default value. + mutating func clearUnimportantField5() {self._unimportantField5 = nil} + + var unimportantField9: Int32 { + get {_unimportantField9 ?? 0} + set {_unimportantField9 = newValue} + } + /// Returns true if `unimportantField9` has been explicitly set. + var hasUnimportantField9: Bool {self._unimportantField9 != nil} + /// Clears the value of `unimportantField9`. Subsequent reads from it will return its default value. + mutating func clearUnimportantField9() {self._unimportantField9 = nil} + + var importantField11: Int32 { + get {_importantField11 ?? 0} + set {_importantField11 = newValue} + } + /// Returns true if `importantField11` has been explicitly set. + var hasImportantField11: Bool {self._importantField11 != nil} + /// Clears the value of `importantField11`. Subsequent reads from it will return its default value. + mutating func clearImportantField11() {self._importantField11 = nil} + + var unimportantField12: Int32 { + get {_unimportantField12 ?? 0} + set {_unimportantField12 = newValue} + } + /// Returns true if `unimportantField12` has been explicitly set. + var hasUnimportantField12: Bool {self._unimportantField12 != nil} + /// Clears the value of `unimportantField12`. Subsequent reads from it will return its default value. + mutating func clearUnimportantField12() {self._unimportantField12 = nil} + + var importantField14: Int32 { + get {_importantField14 ?? 0} + set {_importantField14 = newValue} + } + /// Returns true if `importantField14` has been explicitly set. + var hasImportantField14: Bool {self._importantField14 != nil} + /// Clears the value of `importantField14`. Subsequent reads from it will return its default value. + mutating func clearImportantField14() {self._importantField14 = nil} + + var unimportantField15: Int32 { + get {_unimportantField15 ?? 0} + set {_unimportantField15 = newValue} + } + /// Returns true if `unimportantField15` has been explicitly set. + var hasUnimportantField15: Bool {self._unimportantField15 != nil} + /// Clears the value of `unimportantField15`. Subsequent reads from it will return its default value. + mutating func clearUnimportantField15() {self._unimportantField15 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _importantField1: Int32? = nil + fileprivate var _importantField2: Int32? = nil + fileprivate var _unimportantField3: Int32? = nil + fileprivate var _unimportantField4: Int32? = nil + fileprivate var _unimportantField5: Int32? = nil + fileprivate var _unimportantField9: Int32? = nil + fileprivate var _importantField11: Int32? = nil + fileprivate var _unimportantField12: Int32? = nil + fileprivate var _importantField14: Int32? = nil + fileprivate var _unimportantField15: Int32? = nil +} + +struct Proto2Unittest_TestMessageForMove_Small: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil +} + +struct Proto2Unittest_TestMessageForMove_Large: @unchecked Sendable { + // 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 a1: Int32 { + get {_storage._a1 ?? 0} + set {_uniqueStorage()._a1 = newValue} + } + /// Returns true if `a1` has been explicitly set. + var hasA1: Bool {_storage._a1 != nil} + /// Clears the value of `a1`. Subsequent reads from it will return its default value. + mutating func clearA1() {_uniqueStorage()._a1 = nil} + + var a2: Int32 { + get {_storage._a2 ?? 0} + set {_uniqueStorage()._a2 = newValue} + } + /// Returns true if `a2` has been explicitly set. + var hasA2: Bool {_storage._a2 != nil} + /// Clears the value of `a2`. Subsequent reads from it will return its default value. + mutating func clearA2() {_uniqueStorage()._a2 = nil} + + var a3: Int32 { + get {_storage._a3 ?? 0} + set {_uniqueStorage()._a3 = newValue} + } + /// Returns true if `a3` has been explicitly set. + var hasA3: Bool {_storage._a3 != nil} + /// Clears the value of `a3`. Subsequent reads from it will return its default value. + mutating func clearA3() {_uniqueStorage()._a3 = nil} + + var a4: Int32 { + get {_storage._a4 ?? 0} + set {_uniqueStorage()._a4 = newValue} + } + /// Returns true if `a4` has been explicitly set. + var hasA4: Bool {_storage._a4 != nil} + /// Clears the value of `a4`. Subsequent reads from it will return its default value. + mutating func clearA4() {_uniqueStorage()._a4 = nil} + + var a5: Int32 { + get {_storage._a5 ?? 0} + set {_uniqueStorage()._a5 = newValue} + } + /// Returns true if `a5` has been explicitly set. + var hasA5: Bool {_storage._a5 != nil} + /// Clears the value of `a5`. Subsequent reads from it will return its default value. + mutating func clearA5() {_uniqueStorage()._a5 = nil} + + var a6: Int32 { + get {_storage._a6 ?? 0} + set {_uniqueStorage()._a6 = newValue} + } + /// Returns true if `a6` has been explicitly set. + var hasA6: Bool {_storage._a6 != nil} + /// Clears the value of `a6`. Subsequent reads from it will return its default value. + mutating func clearA6() {_uniqueStorage()._a6 = nil} + + var a7: Int32 { + get {_storage._a7 ?? 0} + set {_uniqueStorage()._a7 = newValue} + } + /// Returns true if `a7` has been explicitly set. + var hasA7: Bool {_storage._a7 != nil} + /// Clears the value of `a7`. Subsequent reads from it will return its default value. + mutating func clearA7() {_uniqueStorage()._a7 = nil} + + var a8: Int32 { + get {_storage._a8 ?? 0} + set {_uniqueStorage()._a8 = newValue} + } + /// Returns true if `a8` has been explicitly set. + var hasA8: Bool {_storage._a8 != nil} + /// Clears the value of `a8`. Subsequent reads from it will return its default value. + mutating func clearA8() {_uniqueStorage()._a8 = nil} + + var a9: Int32 { + get {_storage._a9 ?? 0} + set {_uniqueStorage()._a9 = newValue} + } + /// Returns true if `a9` has been explicitly set. + var hasA9: Bool {_storage._a9 != nil} + /// Clears the value of `a9`. Subsequent reads from it will return its default value. + mutating func clearA9() {_uniqueStorage()._a9 = nil} + + var a11: [Int32] { + get {_storage._a11} + set {_uniqueStorage()._a11 = newValue} + } + + var a12: [Int32] { + get {_storage._a12} + set {_uniqueStorage()._a12 = newValue} + } + + var a13: [Int32] { + get {_storage._a13} + set {_uniqueStorage()._a13 = newValue} + } + + var a14: [Int32] { + get {_storage._a14} + set {_uniqueStorage()._a14 = newValue} + } + + var a15: [Int32] { + get {_storage._a15} + set {_uniqueStorage()._a15 = newValue} + } + + var a16: [Int32] { + get {_storage._a16} + set {_uniqueStorage()._a16 = newValue} + } + + var a17: [Int32] { + get {_storage._a17} + set {_uniqueStorage()._a17 = newValue} + } + + var a18: [Int32] { + get {_storage._a18} + set {_uniqueStorage()._a18 = newValue} + } + + var a19: [Int32] { + get {_storage._a19} + set {_uniqueStorage()._a19 = newValue} + } + + var s101: String { + get {_storage._s101 ?? String()} + set {_uniqueStorage()._s101 = newValue} + } + /// Returns true if `s101` has been explicitly set. + var hasS101: Bool {_storage._s101 != nil} + /// Clears the value of `s101`. Subsequent reads from it will return its default value. + mutating func clearS101() {_uniqueStorage()._s101 = nil} + + var s102: String { + get {_storage._s102 ?? String()} + set {_uniqueStorage()._s102 = newValue} + } + /// Returns true if `s102` has been explicitly set. + var hasS102: Bool {_storage._s102 != nil} + /// Clears the value of `s102`. Subsequent reads from it will return its default value. + mutating func clearS102() {_uniqueStorage()._s102 = nil} + + var s103: String { + get {_storage._s103 ?? String()} + set {_uniqueStorage()._s103 = newValue} + } + /// Returns true if `s103` has been explicitly set. + var hasS103: Bool {_storage._s103 != nil} + /// Clears the value of `s103`. Subsequent reads from it will return its default value. + mutating func clearS103() {_uniqueStorage()._s103 = nil} + + var s104: String { + get {_storage._s104 ?? String()} + set {_uniqueStorage()._s104 = newValue} + } + /// Returns true if `s104` has been explicitly set. + var hasS104: Bool {_storage._s104 != nil} + /// Clears the value of `s104`. Subsequent reads from it will return its default value. + mutating func clearS104() {_uniqueStorage()._s104 = nil} + + var s105: String { + get {_storage._s105 ?? String()} + set {_uniqueStorage()._s105 = newValue} + } + /// Returns true if `s105` has been explicitly set. + var hasS105: Bool {_storage._s105 != nil} + /// Clears the value of `s105`. Subsequent reads from it will return its default value. + mutating func clearS105() {_uniqueStorage()._s105 = nil} + + var s106: String { + get {_storage._s106 ?? String()} + set {_uniqueStorage()._s106 = newValue} + } + /// Returns true if `s106` has been explicitly set. + var hasS106: Bool {_storage._s106 != nil} + /// Clears the value of `s106`. Subsequent reads from it will return its default value. + mutating func clearS106() {_uniqueStorage()._s106 = nil} + + var s107: String { + get {_storage._s107 ?? String()} + set {_uniqueStorage()._s107 = newValue} + } + /// Returns true if `s107` has been explicitly set. + var hasS107: Bool {_storage._s107 != nil} + /// Clears the value of `s107`. Subsequent reads from it will return its default value. + mutating func clearS107() {_uniqueStorage()._s107 = nil} + + var s108: String { + get {_storage._s108 ?? String()} + set {_uniqueStorage()._s108 = newValue} + } + /// Returns true if `s108` has been explicitly set. + var hasS108: Bool {_storage._s108 != nil} + /// Clears the value of `s108`. Subsequent reads from it will return its default value. + mutating func clearS108() {_uniqueStorage()._s108 = nil} + + var s109: String { + get {_storage._s109 ?? String()} + set {_uniqueStorage()._s109 = newValue} + } + /// Returns true if `s109` has been explicitly set. + var hasS109: Bool {_storage._s109 != nil} + /// Clears the value of `s109`. Subsequent reads from it will return its default value. + mutating func clearS109() {_uniqueStorage()._s109 = nil} + + var s111: [String] { + get {_storage._s111} + set {_uniqueStorage()._s111 = newValue} + } + + var s112: [String] { + get {_storage._s112} + set {_uniqueStorage()._s112 = newValue} + } + + var s113: [String] { + get {_storage._s113} + set {_uniqueStorage()._s113 = newValue} + } + + var s114: [String] { + get {_storage._s114} + set {_uniqueStorage()._s114 = newValue} + } + + var s115: [String] { + get {_storage._s115} + set {_uniqueStorage()._s115 = newValue} + } + + var s116: [String] { + get {_storage._s116} + set {_uniqueStorage()._s116 = newValue} + } + + var s117: [String] { + get {_storage._s117} + set {_uniqueStorage()._s117 = newValue} + } + + var s118: [String] { + get {_storage._s118} + set {_uniqueStorage()._s118 = newValue} + } + + var s119: [String] { + get {_storage._s119} + set {_uniqueStorage()._s119 = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Extension support defined in unittest.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 Proto2Unittest_BoolParseTester { + + var Proto2Unittest_BoolParseTester_optionalBoolExt: Bool { + get {return getExtensionValue(ext: Proto2Unittest_BoolParseTester.Extensions.optional_bool_ext) ?? false} + set {setExtensionValue(ext: Proto2Unittest_BoolParseTester.Extensions.optional_bool_ext, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_BoolParseTester.Extensions.optional_bool_ext` + /// has been explicitly set. + var hasProto2Unittest_BoolParseTester_optionalBoolExt: Bool { + return hasExtensionValue(ext: Proto2Unittest_BoolParseTester.Extensions.optional_bool_ext) + } + /// Clears the value of extension `Proto2Unittest_BoolParseTester.Extensions.optional_bool_ext`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_BoolParseTester_optionalBoolExt() { + clearExtensionValue(ext: Proto2Unittest_BoolParseTester.Extensions.optional_bool_ext) + } + + var Proto2Unittest_BoolParseTester_repeatedBoolExt: [Bool] { + get {return getExtensionValue(ext: Proto2Unittest_BoolParseTester.Extensions.repeated_bool_ext) ?? []} + set {setExtensionValue(ext: Proto2Unittest_BoolParseTester.Extensions.repeated_bool_ext, value: newValue)} + } + + var Proto2Unittest_BoolParseTester_packedBoolExt: [Bool] { + get {return getExtensionValue(ext: Proto2Unittest_BoolParseTester.Extensions.packed_bool_ext) ?? []} + set {setExtensionValue(ext: Proto2Unittest_BoolParseTester.Extensions.packed_bool_ext, value: newValue)} + } +} + +extension Proto2Unittest_EnumParseTester { + + var Proto2Unittest_EnumParseTester_optionalArbitraryExt: Proto2Unittest_EnumParseTester.Arbitrary { + get {return getExtensionValue(ext: Proto2Unittest_EnumParseTester.Extensions.optional_arbitrary_ext) ?? .default} + set {setExtensionValue(ext: Proto2Unittest_EnumParseTester.Extensions.optional_arbitrary_ext, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_EnumParseTester.Extensions.optional_arbitrary_ext` + /// has been explicitly set. + var hasProto2Unittest_EnumParseTester_optionalArbitraryExt: Bool { + return hasExtensionValue(ext: Proto2Unittest_EnumParseTester.Extensions.optional_arbitrary_ext) + } + /// Clears the value of extension `Proto2Unittest_EnumParseTester.Extensions.optional_arbitrary_ext`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_EnumParseTester_optionalArbitraryExt() { + clearExtensionValue(ext: Proto2Unittest_EnumParseTester.Extensions.optional_arbitrary_ext) + } + + var Proto2Unittest_EnumParseTester_repeatedArbitraryExt: [Proto2Unittest_EnumParseTester.Arbitrary] { + get {return getExtensionValue(ext: Proto2Unittest_EnumParseTester.Extensions.repeated_arbitrary_ext) ?? []} + set {setExtensionValue(ext: Proto2Unittest_EnumParseTester.Extensions.repeated_arbitrary_ext, value: newValue)} + } + + var Proto2Unittest_EnumParseTester_packedArbitraryExt: [Proto2Unittest_EnumParseTester.Arbitrary] { + get {return getExtensionValue(ext: Proto2Unittest_EnumParseTester.Extensions.packed_arbitrary_ext) ?? []} + set {setExtensionValue(ext: Proto2Unittest_EnumParseTester.Extensions.packed_arbitrary_ext, value: newValue)} + } +} + +extension Proto2Unittest_Int32ParseTester { + + var Proto2Unittest_Int32ParseTester_optionalInt32Ext: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Int32ParseTester.Extensions.optional_int32_ext) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Int32ParseTester.Extensions.optional_int32_ext, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Int32ParseTester.Extensions.optional_int32_ext` + /// has been explicitly set. + var hasProto2Unittest_Int32ParseTester_optionalInt32Ext: Bool { + return hasExtensionValue(ext: Proto2Unittest_Int32ParseTester.Extensions.optional_int32_ext) + } + /// Clears the value of extension `Proto2Unittest_Int32ParseTester.Extensions.optional_int32_ext`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_Int32ParseTester_optionalInt32Ext() { + clearExtensionValue(ext: Proto2Unittest_Int32ParseTester.Extensions.optional_int32_ext) + } + + var Proto2Unittest_Int32ParseTester_repeatedInt32Ext: [Int32] { + get {return getExtensionValue(ext: Proto2Unittest_Int32ParseTester.Extensions.repeated_int32_ext) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Int32ParseTester.Extensions.repeated_int32_ext, value: newValue)} + } + + var Proto2Unittest_Int32ParseTester_packedInt32Ext: [Int32] { + get {return getExtensionValue(ext: Proto2Unittest_Int32ParseTester.Extensions.packed_int32_ext) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Int32ParseTester.Extensions.packed_int32_ext, value: newValue)} + } +} + +extension Proto2Unittest_Int64ParseTester { + + var Proto2Unittest_Int64ParseTester_optionalInt64Ext: Int64 { + get {return getExtensionValue(ext: Proto2Unittest_Int64ParseTester.Extensions.optional_int64_ext) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Int64ParseTester.Extensions.optional_int64_ext, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Int64ParseTester.Extensions.optional_int64_ext` + /// has been explicitly set. + var hasProto2Unittest_Int64ParseTester_optionalInt64Ext: Bool { + return hasExtensionValue(ext: Proto2Unittest_Int64ParseTester.Extensions.optional_int64_ext) + } + /// Clears the value of extension `Proto2Unittest_Int64ParseTester.Extensions.optional_int64_ext`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_Int64ParseTester_optionalInt64Ext() { + clearExtensionValue(ext: Proto2Unittest_Int64ParseTester.Extensions.optional_int64_ext) + } + + var Proto2Unittest_Int64ParseTester_repeatedInt64Ext: [Int64] { + get {return getExtensionValue(ext: Proto2Unittest_Int64ParseTester.Extensions.repeated_int64_ext) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Int64ParseTester.Extensions.repeated_int64_ext, value: newValue)} + } + + var Proto2Unittest_Int64ParseTester_packedInt64Ext: [Int64] { + get {return getExtensionValue(ext: Proto2Unittest_Int64ParseTester.Extensions.packed_int64_ext) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Int64ParseTester.Extensions.packed_int64_ext, value: newValue)} + } +} + +extension Proto2Unittest_RedactedFields { + + var Proto2Unittest_redactedExtension: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_redacted_extension) ?? String()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_redacted_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_redacted_extension` + /// has been explicitly set. + var hasProto2Unittest_redactedExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_redacted_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_redacted_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_redactedExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_redacted_extension) + } +} + +extension Proto2Unittest_StringParseTester { + + var Proto2Unittest_StringParseTester_optionalStringExt: String { + get {return getExtensionValue(ext: Proto2Unittest_StringParseTester.Extensions.optional_string_ext) ?? String()} + set {setExtensionValue(ext: Proto2Unittest_StringParseTester.Extensions.optional_string_ext, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_StringParseTester.Extensions.optional_string_ext` + /// has been explicitly set. + var hasProto2Unittest_StringParseTester_optionalStringExt: Bool { + return hasExtensionValue(ext: Proto2Unittest_StringParseTester.Extensions.optional_string_ext) + } + /// Clears the value of extension `Proto2Unittest_StringParseTester.Extensions.optional_string_ext`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_StringParseTester_optionalStringExt() { + clearExtensionValue(ext: Proto2Unittest_StringParseTester.Extensions.optional_string_ext) + } + + var Proto2Unittest_StringParseTester_repeatedStringExt: [String] { + get {return getExtensionValue(ext: Proto2Unittest_StringParseTester.Extensions.repeated_string_ext) ?? []} + set {setExtensionValue(ext: Proto2Unittest_StringParseTester.Extensions.repeated_string_ext, value: newValue)} + } +} + +extension Proto2Unittest_TestAllExtensions { + + /// Singular + var Proto2Unittest_optionalInt32Extension: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_int32_extension) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_int32_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_int32_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalInt32Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_int32_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_int32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalInt32Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_int32_extension) + } + + var Proto2Unittest_optionalInt64Extension: Int64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_int64_extension) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_int64_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_int64_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalInt64Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_int64_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_int64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalInt64Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_int64_extension) + } + + var Proto2Unittest_optionalUint32Extension: UInt32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_uint32_extension) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_uint32_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_uint32_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalUint32Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_uint32_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_uint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalUint32Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_uint32_extension) + } + + var Proto2Unittest_optionalUint64Extension: UInt64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_uint64_extension) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_uint64_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_uint64_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalUint64Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_uint64_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_uint64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalUint64Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_uint64_extension) + } + + var Proto2Unittest_optionalSint32Extension: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_sint32_extension) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_sint32_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_sint32_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalSint32Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_sint32_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_sint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalSint32Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_sint32_extension) + } + + var Proto2Unittest_optionalSint64Extension: Int64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_sint64_extension) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_sint64_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_sint64_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalSint64Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_sint64_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_sint64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalSint64Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_sint64_extension) + } + + var Proto2Unittest_optionalFixed32Extension: UInt32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_fixed32_extension) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_fixed32_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_fixed32_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalFixed32Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_fixed32_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_fixed32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalFixed32Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_fixed32_extension) + } + + var Proto2Unittest_optionalFixed64Extension: UInt64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_fixed64_extension) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_fixed64_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_fixed64_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalFixed64Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_fixed64_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_fixed64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalFixed64Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_fixed64_extension) + } + + var Proto2Unittest_optionalSfixed32Extension: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_sfixed32_extension) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_sfixed32_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_sfixed32_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalSfixed32Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_sfixed32_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_sfixed32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalSfixed32Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_sfixed32_extension) + } + + var Proto2Unittest_optionalSfixed64Extension: Int64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_sfixed64_extension) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_sfixed64_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_sfixed64_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalSfixed64Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_sfixed64_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_sfixed64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalSfixed64Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_sfixed64_extension) + } + + var Proto2Unittest_optionalFloatExtension: Float { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_float_extension) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_float_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_float_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalFloatExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_float_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_float_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalFloatExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_float_extension) + } + + var Proto2Unittest_optionalDoubleExtension: Double { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_double_extension) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_double_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_double_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalDoubleExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_double_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_double_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalDoubleExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_double_extension) + } + + var Proto2Unittest_optionalBoolExtension: Bool { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_bool_extension) ?? false} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_bool_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_bool_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalBoolExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_bool_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_bool_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalBoolExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_bool_extension) + } + + var Proto2Unittest_optionalStringExtension: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_string_extension) ?? String()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_string_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_string_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalStringExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_string_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_string_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalStringExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_string_extension) + } + + var Proto2Unittest_optionalBytesExtension: Data { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_bytes_extension) ?? Data()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_bytes_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_bytes_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalBytesExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_bytes_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_bytes_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalBytesExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_bytes_extension) + } + + var Proto2Unittest_optionalGroupExtension: Proto2Unittest_OptionalGroup_extension { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_OptionalGroup_extension) ?? Proto2Unittest_OptionalGroup_extension()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_OptionalGroup_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_OptionalGroup_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalGroupExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_OptionalGroup_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_OptionalGroup_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalGroupExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_OptionalGroup_extension) + } + + var Proto2Unittest_optionalNestedMessageExtension: Proto2Unittest_TestAllTypes.NestedMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_nested_message_extension) ?? Proto2Unittest_TestAllTypes.NestedMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_nested_message_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_nested_message_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalNestedMessageExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_nested_message_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_nested_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalNestedMessageExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_nested_message_extension) + } + + var Proto2Unittest_optionalForeignMessageExtension: Proto2Unittest_ForeignMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_foreign_message_extension) ?? Proto2Unittest_ForeignMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_foreign_message_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_foreign_message_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalForeignMessageExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_foreign_message_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_foreign_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalForeignMessageExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_foreign_message_extension) + } + + var Proto2Unittest_optionalImportMessageExtension: Proto2UnittestImport_ImportMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_import_message_extension) ?? Proto2UnittestImport_ImportMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_import_message_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_import_message_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalImportMessageExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_import_message_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_import_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalImportMessageExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_import_message_extension) + } + + var Proto2Unittest_optionalNestedEnumExtension: Proto2Unittest_TestAllTypes.NestedEnum { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_nested_enum_extension) ?? .foo} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_nested_enum_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_nested_enum_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalNestedEnumExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_nested_enum_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_nested_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalNestedEnumExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_nested_enum_extension) + } + + var Proto2Unittest_optionalForeignEnumExtension: Proto2Unittest_ForeignEnum { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_foreign_enum_extension) ?? .foreignFoo} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_foreign_enum_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_foreign_enum_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalForeignEnumExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_foreign_enum_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_foreign_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalForeignEnumExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_foreign_enum_extension) + } + + var Proto2Unittest_optionalImportEnumExtension: Proto2UnittestImport_ImportEnum { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_import_enum_extension) ?? .importFoo} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_import_enum_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_import_enum_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalImportEnumExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_import_enum_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_import_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalImportEnumExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_import_enum_extension) + } + + var Proto2Unittest_optionalStringPieceExtension: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_string_piece_extension) ?? String()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_string_piece_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_string_piece_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalStringPieceExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_string_piece_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_string_piece_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalStringPieceExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_string_piece_extension) + } + + /// TODO: ctype=CORD is not supported for extension. Add + /// ctype=CORD option back after it is supported. + var Proto2Unittest_optionalCordExtension: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_cord_extension) ?? String()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_cord_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_cord_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalCordExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_cord_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_cord_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalCordExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_cord_extension) + } + + var Proto2Unittest_optionalBytesCordExtension: Data { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_bytes_cord_extension) ?? Data()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_bytes_cord_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_bytes_cord_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalBytesCordExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_bytes_cord_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_bytes_cord_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalBytesCordExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_bytes_cord_extension) + } + + var Proto2Unittest_optionalPublicImportMessageExtension: Proto2UnittestImport_PublicImportMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_public_import_message_extension) ?? Proto2UnittestImport_PublicImportMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_public_import_message_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_public_import_message_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalPublicImportMessageExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_public_import_message_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_public_import_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalPublicImportMessageExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_public_import_message_extension) + } + + var Proto2Unittest_optionalLazyMessageExtension: Proto2Unittest_TestAllTypes.NestedMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_lazy_message_extension) ?? Proto2Unittest_TestAllTypes.NestedMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_lazy_message_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_lazy_message_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalLazyMessageExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_lazy_message_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_lazy_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalLazyMessageExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_lazy_message_extension) + } + + var Proto2Unittest_optionalUnverifiedLazyMessageExtension: Proto2Unittest_TestAllTypes.NestedMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_unverified_lazy_message_extension) ?? Proto2Unittest_TestAllTypes.NestedMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_unverified_lazy_message_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_unverified_lazy_message_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalUnverifiedLazyMessageExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_unverified_lazy_message_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_unverified_lazy_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalUnverifiedLazyMessageExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_unverified_lazy_message_extension) + } + + /// Repeated + var Proto2Unittest_repeatedInt32Extension: [Int32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_int32_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_int32_extension, value: newValue)} + } + + var Proto2Unittest_repeatedInt64Extension: [Int64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_int64_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_int64_extension, value: newValue)} + } + + var Proto2Unittest_repeatedUint32Extension: [UInt32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_uint32_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_uint32_extension, value: newValue)} + } + + var Proto2Unittest_repeatedUint64Extension: [UInt64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_uint64_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_uint64_extension, value: newValue)} + } + + var Proto2Unittest_repeatedSint32Extension: [Int32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_sint32_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_sint32_extension, value: newValue)} + } + + var Proto2Unittest_repeatedSint64Extension: [Int64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_sint64_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_sint64_extension, value: newValue)} + } + + var Proto2Unittest_repeatedFixed32Extension: [UInt32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_fixed32_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_fixed32_extension, value: newValue)} + } + + var Proto2Unittest_repeatedFixed64Extension: [UInt64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_fixed64_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_fixed64_extension, value: newValue)} + } + + var Proto2Unittest_repeatedSfixed32Extension: [Int32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_sfixed32_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_sfixed32_extension, value: newValue)} + } + + var Proto2Unittest_repeatedSfixed64Extension: [Int64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_sfixed64_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_sfixed64_extension, value: newValue)} + } + + var Proto2Unittest_repeatedFloatExtension: [Float] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_float_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_float_extension, value: newValue)} + } + + var Proto2Unittest_repeatedDoubleExtension: [Double] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_double_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_double_extension, value: newValue)} + } + + var Proto2Unittest_repeatedBoolExtension: [Bool] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_bool_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_bool_extension, value: newValue)} + } + + var Proto2Unittest_repeatedStringExtension: [String] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_string_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_string_extension, value: newValue)} + } + + var Proto2Unittest_repeatedBytesExtension: [Data] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_bytes_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_bytes_extension, value: newValue)} + } + + var Proto2Unittest_repeatedGroupExtension: [Proto2Unittest_RepeatedGroup_extension] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_RepeatedGroup_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_RepeatedGroup_extension, value: newValue)} + } + + var Proto2Unittest_repeatedNestedMessageExtension: [Proto2Unittest_TestAllTypes.NestedMessage] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_nested_message_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_nested_message_extension, value: newValue)} + } + + var Proto2Unittest_repeatedForeignMessageExtension: [Proto2Unittest_ForeignMessage] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_foreign_message_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_foreign_message_extension, value: newValue)} + } + + var Proto2Unittest_repeatedImportMessageExtension: [Proto2UnittestImport_ImportMessage] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_import_message_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_import_message_extension, value: newValue)} + } + + var Proto2Unittest_repeatedNestedEnumExtension: [Proto2Unittest_TestAllTypes.NestedEnum] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_nested_enum_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_nested_enum_extension, value: newValue)} + } + + var Proto2Unittest_repeatedForeignEnumExtension: [Proto2Unittest_ForeignEnum] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_foreign_enum_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_foreign_enum_extension, value: newValue)} + } + + var Proto2Unittest_repeatedImportEnumExtension: [Proto2UnittestImport_ImportEnum] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_import_enum_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_import_enum_extension, value: newValue)} + } + + var Proto2Unittest_repeatedStringPieceExtension: [String] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_string_piece_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_string_piece_extension, value: newValue)} + } + + /// TODO: ctype=CORD is not supported for extension. Add + /// ctype=CORD option back after it is supported. + var Proto2Unittest_repeatedCordExtension: [String] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_cord_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_cord_extension, value: newValue)} + } + + var Proto2Unittest_repeatedLazyMessageExtension: [Proto2Unittest_TestAllTypes.NestedMessage] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_lazy_message_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_lazy_message_extension, value: newValue)} + } + + /// Singular with defaults + var Proto2Unittest_defaultInt32Extension: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_int32_extension) ?? 41} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_int32_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_int32_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultInt32Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_int32_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_int32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultInt32Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_int32_extension) + } + + var Proto2Unittest_defaultInt64Extension: Int64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_int64_extension) ?? 42} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_int64_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_int64_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultInt64Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_int64_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_int64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultInt64Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_int64_extension) + } + + var Proto2Unittest_defaultUint32Extension: UInt32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_uint32_extension) ?? 43} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_uint32_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_uint32_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultUint32Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_uint32_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_uint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultUint32Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_uint32_extension) + } + + var Proto2Unittest_defaultUint64Extension: UInt64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_uint64_extension) ?? 44} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_uint64_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_uint64_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultUint64Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_uint64_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_uint64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultUint64Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_uint64_extension) + } + + var Proto2Unittest_defaultSint32Extension: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_sint32_extension) ?? -45} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_sint32_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_sint32_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultSint32Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_sint32_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_sint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultSint32Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_sint32_extension) + } + + var Proto2Unittest_defaultSint64Extension: Int64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_sint64_extension) ?? 46} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_sint64_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_sint64_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultSint64Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_sint64_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_sint64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultSint64Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_sint64_extension) + } + + var Proto2Unittest_defaultFixed32Extension: UInt32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_fixed32_extension) ?? 47} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_fixed32_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_fixed32_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultFixed32Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_fixed32_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_fixed32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultFixed32Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_fixed32_extension) + } + + var Proto2Unittest_defaultFixed64Extension: UInt64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_fixed64_extension) ?? 48} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_fixed64_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_fixed64_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultFixed64Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_fixed64_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_fixed64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultFixed64Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_fixed64_extension) + } + + var Proto2Unittest_defaultSfixed32Extension: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_sfixed32_extension) ?? 49} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_sfixed32_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_sfixed32_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultSfixed32Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_sfixed32_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_sfixed32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultSfixed32Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_sfixed32_extension) + } + + var Proto2Unittest_defaultSfixed64Extension: Int64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_sfixed64_extension) ?? -50} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_sfixed64_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_sfixed64_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultSfixed64Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_sfixed64_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_sfixed64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultSfixed64Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_sfixed64_extension) + } + + var Proto2Unittest_defaultFloatExtension: Float { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_float_extension) ?? 51.5} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_float_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_float_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultFloatExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_float_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_float_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultFloatExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_float_extension) + } + + var Proto2Unittest_defaultDoubleExtension: Double { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_double_extension) ?? 52000} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_double_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_double_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultDoubleExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_double_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_double_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultDoubleExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_double_extension) + } + + var Proto2Unittest_defaultBoolExtension: Bool { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_bool_extension) ?? true} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_bool_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_bool_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultBoolExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_bool_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_bool_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultBoolExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_bool_extension) + } + + var Proto2Unittest_defaultStringExtension: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_string_extension) ?? "hello"} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_string_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_string_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultStringExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_string_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_string_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultStringExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_string_extension) + } + + var Proto2Unittest_defaultBytesExtension: Data { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_bytes_extension) ?? Data([119, 111, 114, 108, 100])} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_bytes_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_bytes_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultBytesExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_bytes_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_bytes_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultBytesExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_bytes_extension) + } + + var Proto2Unittest_defaultNestedEnumExtension: Proto2Unittest_TestAllTypes.NestedEnum { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_nested_enum_extension) ?? .bar} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_nested_enum_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_nested_enum_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultNestedEnumExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_nested_enum_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_nested_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultNestedEnumExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_nested_enum_extension) + } + + var Proto2Unittest_defaultForeignEnumExtension: Proto2Unittest_ForeignEnum { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_foreign_enum_extension) ?? .foreignBar} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_foreign_enum_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_foreign_enum_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultForeignEnumExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_foreign_enum_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_foreign_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultForeignEnumExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_foreign_enum_extension) + } + + var Proto2Unittest_defaultImportEnumExtension: Proto2UnittestImport_ImportEnum { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_import_enum_extension) ?? .importBar} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_import_enum_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_import_enum_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultImportEnumExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_import_enum_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_import_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultImportEnumExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_import_enum_extension) + } + + var Proto2Unittest_defaultStringPieceExtension: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_string_piece_extension) ?? "abc"} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_string_piece_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_string_piece_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultStringPieceExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_string_piece_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_string_piece_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultStringPieceExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_string_piece_extension) + } + + /// TODO: ctype=CORD is not supported for extension. Add + /// ctype=CORD option back after it is supported. + var Proto2Unittest_defaultCordExtension: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_cord_extension) ?? "123"} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_cord_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_cord_extension` + /// has been explicitly set. + var hasProto2Unittest_defaultCordExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_cord_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_cord_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultCordExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_cord_extension) + } + + /// For oneof test + var Proto2Unittest_oneofUint32Extension: UInt32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_oneof_uint32_extension) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_oneof_uint32_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_oneof_uint32_extension` + /// has been explicitly set. + var hasProto2Unittest_oneofUint32Extension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_oneof_uint32_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_oneof_uint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_oneofUint32Extension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_oneof_uint32_extension) + } + + var Proto2Unittest_oneofNestedMessageExtension: Proto2Unittest_TestAllTypes.NestedMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_oneof_nested_message_extension) ?? Proto2Unittest_TestAllTypes.NestedMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_oneof_nested_message_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_oneof_nested_message_extension` + /// has been explicitly set. + var hasProto2Unittest_oneofNestedMessageExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_oneof_nested_message_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_oneof_nested_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_oneofNestedMessageExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_oneof_nested_message_extension) + } + + var Proto2Unittest_oneofStringExtension: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_oneof_string_extension) ?? String()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_oneof_string_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_oneof_string_extension` + /// has been explicitly set. + var hasProto2Unittest_oneofStringExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_oneof_string_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_oneof_string_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_oneofStringExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_oneof_string_extension) + } + + var Proto2Unittest_oneofBytesExtension: Data { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_oneof_bytes_extension) ?? Data()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_oneof_bytes_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_oneof_bytes_extension` + /// has been explicitly set. + var hasProto2Unittest_oneofBytesExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_oneof_bytes_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_oneof_bytes_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_oneofBytesExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_oneof_bytes_extension) + } + + var Proto2Unittest_optionalUtf8StringExtension: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_utf8_string_extension) ?? String()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_utf8_string_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_utf8_string_extension` + /// has been explicitly set. + var hasProto2Unittest_optionalUtf8StringExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_utf8_string_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_utf8_string_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalUtf8StringExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_utf8_string_extension) + } + + var Proto2Unittest_repeatedUtf8StringExtension: [String] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_utf8_string_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_utf8_string_extension, value: newValue)} + } + + /// Singular message containing required fields; used to test initialization. + var Proto2Unittest_requiredMessageExtension: Proto2Unittest_TestRequired { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_required_message_extension) ?? Proto2Unittest_TestRequired()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_required_message_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_required_message_extension` + /// has been explicitly set. + var hasProto2Unittest_requiredMessageExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_required_message_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_required_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_requiredMessageExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_required_message_extension) + } + + /// Check for bug where string extensions declared in tested scope did not + /// compile. + var Proto2Unittest_TestNestedExtension_test: String { + get {return getExtensionValue(ext: Proto2Unittest_TestNestedExtension.Extensions.test) ?? "test"} + set {setExtensionValue(ext: Proto2Unittest_TestNestedExtension.Extensions.test, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestNestedExtension.Extensions.test` + /// has been explicitly set. + var hasProto2Unittest_TestNestedExtension_test: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestNestedExtension.Extensions.test) + } + /// Clears the value of extension `Proto2Unittest_TestNestedExtension.Extensions.test`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestNestedExtension_test() { + clearExtensionValue(ext: Proto2Unittest_TestNestedExtension.Extensions.test) + } + + /// Used to test if generated extension name is correct when there are + /// underscores. + var Proto2Unittest_TestNestedExtension_nestedStringExtension: String { + get {return getExtensionValue(ext: Proto2Unittest_TestNestedExtension.Extensions.nested_string_extension) ?? String()} + set {setExtensionValue(ext: Proto2Unittest_TestNestedExtension.Extensions.nested_string_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestNestedExtension.Extensions.nested_string_extension` + /// has been explicitly set. + var hasProto2Unittest_TestNestedExtension_nestedStringExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestNestedExtension.Extensions.nested_string_extension) + } + /// Clears the value of extension `Proto2Unittest_TestNestedExtension.Extensions.nested_string_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestNestedExtension_nestedStringExtension() { + clearExtensionValue(ext: Proto2Unittest_TestNestedExtension.Extensions.nested_string_extension) + } + + var Proto2Unittest_TestRequired_single: Proto2Unittest_TestRequired { + get {return getExtensionValue(ext: Proto2Unittest_TestRequired.Extensions.single) ?? Proto2Unittest_TestRequired()} + set {setExtensionValue(ext: Proto2Unittest_TestRequired.Extensions.single, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestRequired.Extensions.single` + /// has been explicitly set. + var hasProto2Unittest_TestRequired_single: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestRequired.Extensions.single) + } + /// Clears the value of extension `Proto2Unittest_TestRequired.Extensions.single`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestRequired_single() { + clearExtensionValue(ext: Proto2Unittest_TestRequired.Extensions.single) + } + + var Proto2Unittest_TestRequired_multi: [Proto2Unittest_TestRequired] { + get {return getExtensionValue(ext: Proto2Unittest_TestRequired.Extensions.multi) ?? []} + set {setExtensionValue(ext: Proto2Unittest_TestRequired.Extensions.multi, value: newValue)} + } +} + +extension Proto2Unittest_TestExtensionInsideTable { + + var Proto2Unittest_testExtensionInsideTableExtension: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_test_extension_inside_table_extension) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_test_extension_inside_table_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_test_extension_inside_table_extension` + /// has been explicitly set. + var hasProto2Unittest_testExtensionInsideTableExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_test_extension_inside_table_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_test_extension_inside_table_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_testExtensionInsideTableExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_test_extension_inside_table_extension) + } +} + +extension Proto2Unittest_TestExtensionRangeSerialize { + + var Proto2Unittest_TestExtensionRangeSerialize_barOne: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_one) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_one, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_one` + /// has been explicitly set. + var hasProto2Unittest_TestExtensionRangeSerialize_barOne: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_one) + } + /// Clears the value of extension `Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_one`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestExtensionRangeSerialize_barOne() { + clearExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_one) + } + + var Proto2Unittest_TestExtensionRangeSerialize_barTwo: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_two) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_two, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_two` + /// has been explicitly set. + var hasProto2Unittest_TestExtensionRangeSerialize_barTwo: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_two) + } + /// Clears the value of extension `Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_two`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestExtensionRangeSerialize_barTwo() { + clearExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_two) + } + + var Proto2Unittest_TestExtensionRangeSerialize_barThree: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_three) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_three, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_three` + /// has been explicitly set. + var hasProto2Unittest_TestExtensionRangeSerialize_barThree: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_three) + } + /// Clears the value of extension `Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_three`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestExtensionRangeSerialize_barThree() { + clearExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_three) + } + + var Proto2Unittest_TestExtensionRangeSerialize_barFour: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_four) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_four, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_four` + /// has been explicitly set. + var hasProto2Unittest_TestExtensionRangeSerialize_barFour: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_four) + } + /// Clears the value of extension `Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_four`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestExtensionRangeSerialize_barFour() { + clearExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_four) + } + + var Proto2Unittest_TestExtensionRangeSerialize_barFive: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_five) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_five, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_five` + /// has been explicitly set. + var hasProto2Unittest_TestExtensionRangeSerialize_barFive: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_five) + } + /// Clears the value of extension `Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_five`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestExtensionRangeSerialize_barFive() { + clearExtensionValue(ext: Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_five) + } +} + +extension Proto2Unittest_TestFieldOrderings { + + var Proto2Unittest_myExtensionString: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_my_extension_string) ?? String()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_my_extension_string, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_my_extension_string` + /// has been explicitly set. + var hasProto2Unittest_myExtensionString: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_my_extension_string) + } + /// Clears the value of extension `Proto2Unittest_Extensions_my_extension_string`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_myExtensionString() { + clearExtensionValue(ext: Proto2Unittest_Extensions_my_extension_string) + } + + var Proto2Unittest_myExtensionInt: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_my_extension_int) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_my_extension_int, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_my_extension_int` + /// has been explicitly set. + var hasProto2Unittest_myExtensionInt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_my_extension_int) + } + /// Clears the value of extension `Proto2Unittest_Extensions_my_extension_int`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_myExtensionInt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_my_extension_int) + } + + var Proto2Unittest_TestExtensionOrderings1_testExtOrderings1: Proto2Unittest_TestExtensionOrderings1 { + get {return getExtensionValue(ext: Proto2Unittest_TestExtensionOrderings1.Extensions.test_ext_orderings1) ?? Proto2Unittest_TestExtensionOrderings1()} + set {setExtensionValue(ext: Proto2Unittest_TestExtensionOrderings1.Extensions.test_ext_orderings1, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestExtensionOrderings1.Extensions.test_ext_orderings1` + /// has been explicitly set. + var hasProto2Unittest_TestExtensionOrderings1_testExtOrderings1: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestExtensionOrderings1.Extensions.test_ext_orderings1) + } + /// Clears the value of extension `Proto2Unittest_TestExtensionOrderings1.Extensions.test_ext_orderings1`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestExtensionOrderings1_testExtOrderings1() { + clearExtensionValue(ext: Proto2Unittest_TestExtensionOrderings1.Extensions.test_ext_orderings1) + } + + var Proto2Unittest_TestExtensionOrderings2_testExtOrderings2: Proto2Unittest_TestExtensionOrderings2 { + get {return getExtensionValue(ext: Proto2Unittest_TestExtensionOrderings2.Extensions.test_ext_orderings2) ?? Proto2Unittest_TestExtensionOrderings2()} + set {setExtensionValue(ext: Proto2Unittest_TestExtensionOrderings2.Extensions.test_ext_orderings2, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestExtensionOrderings2.Extensions.test_ext_orderings2` + /// has been explicitly set. + var hasProto2Unittest_TestExtensionOrderings2_testExtOrderings2: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestExtensionOrderings2.Extensions.test_ext_orderings2) + } + /// Clears the value of extension `Proto2Unittest_TestExtensionOrderings2.Extensions.test_ext_orderings2`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestExtensionOrderings2_testExtOrderings2() { + clearExtensionValue(ext: Proto2Unittest_TestExtensionOrderings2.Extensions.test_ext_orderings2) + } + + var Proto2Unittest_TestExtensionOrderings2_TestExtensionOrderings3_testExtOrderings3: Proto2Unittest_TestExtensionOrderings2.TestExtensionOrderings3 { + get {return getExtensionValue(ext: Proto2Unittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3) ?? Proto2Unittest_TestExtensionOrderings2.TestExtensionOrderings3()} + set {setExtensionValue(ext: Proto2Unittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3` + /// has been explicitly set. + var hasProto2Unittest_TestExtensionOrderings2_TestExtensionOrderings3_testExtOrderings3: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3) + } + /// Clears the value of extension `Proto2Unittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestExtensionOrderings2_TestExtensionOrderings3_testExtOrderings3() { + clearExtensionValue(ext: Proto2Unittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3) + } +} + +extension Proto2Unittest_TestGroupExtension { + + var Proto2Unittest_TestNestedExtension_optionalGroupExtension: Proto2Unittest_TestNestedExtension.OptionalGroup_extension { + get {return getExtensionValue(ext: Proto2Unittest_TestNestedExtension.Extensions.OptionalGroup_extension) ?? Proto2Unittest_TestNestedExtension.OptionalGroup_extension()} + set {setExtensionValue(ext: Proto2Unittest_TestNestedExtension.Extensions.OptionalGroup_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestNestedExtension.Extensions.OptionalGroup_extension` + /// has been explicitly set. + var hasProto2Unittest_TestNestedExtension_optionalGroupExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestNestedExtension.Extensions.OptionalGroup_extension) + } + /// Clears the value of extension `Proto2Unittest_TestNestedExtension.Extensions.OptionalGroup_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestNestedExtension_optionalGroupExtension() { + clearExtensionValue(ext: Proto2Unittest_TestNestedExtension.Extensions.OptionalGroup_extension) + } + + var Proto2Unittest_TestNestedExtension_optionalForeignEnumExtension: Proto2Unittest_ForeignEnum { + get {return getExtensionValue(ext: Proto2Unittest_TestNestedExtension.Extensions.optional_foreign_enum_extension) ?? .foreignFoo} + set {setExtensionValue(ext: Proto2Unittest_TestNestedExtension.Extensions.optional_foreign_enum_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestNestedExtension.Extensions.optional_foreign_enum_extension` + /// has been explicitly set. + var hasProto2Unittest_TestNestedExtension_optionalForeignEnumExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestNestedExtension.Extensions.optional_foreign_enum_extension) + } + /// Clears the value of extension `Proto2Unittest_TestNestedExtension.Extensions.optional_foreign_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestNestedExtension_optionalForeignEnumExtension() { + clearExtensionValue(ext: Proto2Unittest_TestNestedExtension.Extensions.optional_foreign_enum_extension) + } +} + +extension Proto2Unittest_TestHugeFieldNumbers { + + var Proto2Unittest_testAllTypes: Proto2Unittest_TestAllTypes { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_test_all_types) ?? Proto2Unittest_TestAllTypes()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_test_all_types, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_test_all_types` + /// has been explicitly set. + var hasProto2Unittest_testAllTypes: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_test_all_types) + } + /// Clears the value of extension `Proto2Unittest_Extensions_test_all_types`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_testAllTypes() { + clearExtensionValue(ext: Proto2Unittest_Extensions_test_all_types) + } +} + +extension Proto2Unittest_TestMixedFieldsAndExtensions { + + var Proto2Unittest_TestMixedFieldsAndExtensions_c: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_TestMixedFieldsAndExtensions.Extensions.c) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_TestMixedFieldsAndExtensions.Extensions.c, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestMixedFieldsAndExtensions.Extensions.c` + /// has been explicitly set. + var hasProto2Unittest_TestMixedFieldsAndExtensions_c: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestMixedFieldsAndExtensions.Extensions.c) + } + /// Clears the value of extension `Proto2Unittest_TestMixedFieldsAndExtensions.Extensions.c`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestMixedFieldsAndExtensions_c() { + clearExtensionValue(ext: Proto2Unittest_TestMixedFieldsAndExtensions.Extensions.c) + } + + var Proto2Unittest_TestMixedFieldsAndExtensions_d: [UInt32] { + get {return getExtensionValue(ext: Proto2Unittest_TestMixedFieldsAndExtensions.Extensions.d) ?? []} + set {setExtensionValue(ext: Proto2Unittest_TestMixedFieldsAndExtensions.Extensions.d, value: newValue)} + } +} + +extension Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2RepeatedGroup { + + var Proto2Unittest_inner: Proto2Unittest_TestNestedGroupExtensionInnerExtension { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_inner) ?? Proto2Unittest_TestNestedGroupExtensionInnerExtension()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_inner, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_inner` + /// has been explicitly set. + var hasProto2Unittest_inner: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_inner) + } + /// Clears the value of extension `Proto2Unittest_Extensions_inner`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_inner() { + clearExtensionValue(ext: Proto2Unittest_Extensions_inner) + } +} + +extension Proto2Unittest_TestPackedExtensions { + + var Proto2Unittest_packedInt32Extension: [Int32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_int32_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_int32_extension, value: newValue)} + } + + var Proto2Unittest_packedInt64Extension: [Int64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_int64_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_int64_extension, value: newValue)} + } + + var Proto2Unittest_packedUint32Extension: [UInt32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_uint32_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_uint32_extension, value: newValue)} + } + + var Proto2Unittest_packedUint64Extension: [UInt64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_uint64_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_uint64_extension, value: newValue)} + } + + var Proto2Unittest_packedSint32Extension: [Int32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_sint32_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_sint32_extension, value: newValue)} + } + + var Proto2Unittest_packedSint64Extension: [Int64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_sint64_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_sint64_extension, value: newValue)} + } + + var Proto2Unittest_packedFixed32Extension: [UInt32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_fixed32_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_fixed32_extension, value: newValue)} + } + + var Proto2Unittest_packedFixed64Extension: [UInt64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_fixed64_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_fixed64_extension, value: newValue)} + } + + var Proto2Unittest_packedSfixed32Extension: [Int32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_sfixed32_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_sfixed32_extension, value: newValue)} + } + + var Proto2Unittest_packedSfixed64Extension: [Int64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_sfixed64_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_sfixed64_extension, value: newValue)} + } + + var Proto2Unittest_packedFloatExtension: [Float] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_float_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_float_extension, value: newValue)} + } + + var Proto2Unittest_packedDoubleExtension: [Double] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_double_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_double_extension, value: newValue)} + } + + var Proto2Unittest_packedBoolExtension: [Bool] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_bool_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_bool_extension, value: newValue)} + } + + var Proto2Unittest_packedEnumExtension: [Proto2Unittest_ForeignEnum] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_enum_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_enum_extension, value: newValue)} + } +} + +extension Proto2Unittest_TestParsingMerge { + + var Proto2Unittest_TestParsingMerge_optionalExt: Proto2Unittest_TestAllTypes { + get {return getExtensionValue(ext: Proto2Unittest_TestParsingMerge.Extensions.optional_ext) ?? Proto2Unittest_TestAllTypes()} + set {setExtensionValue(ext: Proto2Unittest_TestParsingMerge.Extensions.optional_ext, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestParsingMerge.Extensions.optional_ext` + /// has been explicitly set. + var hasProto2Unittest_TestParsingMerge_optionalExt: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestParsingMerge.Extensions.optional_ext) + } + /// Clears the value of extension `Proto2Unittest_TestParsingMerge.Extensions.optional_ext`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestParsingMerge_optionalExt() { + clearExtensionValue(ext: Proto2Unittest_TestParsingMerge.Extensions.optional_ext) + } + + var Proto2Unittest_TestParsingMerge_repeatedExt: [Proto2Unittest_TestAllTypes] { + get {return getExtensionValue(ext: Proto2Unittest_TestParsingMerge.Extensions.repeated_ext) ?? []} + set {setExtensionValue(ext: Proto2Unittest_TestParsingMerge.Extensions.repeated_ext, value: newValue)} + } +} + +extension Proto2Unittest_TestUnpackedExtensions { + + var Proto2Unittest_unpackedInt32Extension: [Int32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_unpacked_int32_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_unpacked_int32_extension, value: newValue)} + } + + var Proto2Unittest_unpackedInt64Extension: [Int64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_unpacked_int64_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_unpacked_int64_extension, value: newValue)} + } + + var Proto2Unittest_unpackedUint32Extension: [UInt32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_unpacked_uint32_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_unpacked_uint32_extension, value: newValue)} + } + + var Proto2Unittest_unpackedUint64Extension: [UInt64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_unpacked_uint64_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_unpacked_uint64_extension, value: newValue)} + } + + var Proto2Unittest_unpackedSint32Extension: [Int32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_unpacked_sint32_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_unpacked_sint32_extension, value: newValue)} + } + + var Proto2Unittest_unpackedSint64Extension: [Int64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_unpacked_sint64_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_unpacked_sint64_extension, value: newValue)} + } + + var Proto2Unittest_unpackedFixed32Extension: [UInt32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_unpacked_fixed32_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_unpacked_fixed32_extension, value: newValue)} + } + + var Proto2Unittest_unpackedFixed64Extension: [UInt64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_unpacked_fixed64_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_unpacked_fixed64_extension, value: newValue)} + } + + var Proto2Unittest_unpackedSfixed32Extension: [Int32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_unpacked_sfixed32_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_unpacked_sfixed32_extension, value: newValue)} + } + + var Proto2Unittest_unpackedSfixed64Extension: [Int64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_unpacked_sfixed64_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_unpacked_sfixed64_extension, value: newValue)} + } + + var Proto2Unittest_unpackedFloatExtension: [Float] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_unpacked_float_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_unpacked_float_extension, value: newValue)} + } + + var Proto2Unittest_unpackedDoubleExtension: [Double] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_unpacked_double_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_unpacked_double_extension, value: newValue)} + } + + var Proto2Unittest_unpackedBoolExtension: [Bool] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_unpacked_bool_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_unpacked_bool_extension, value: newValue)} + } + + var Proto2Unittest_unpackedEnumExtension: [Proto2Unittest_ForeignEnum] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_unpacked_enum_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_unpacked_enum_extension, value: newValue)} + } + +} + +// MARK: - File's ExtensionMap: Proto2Unittest_Unittest_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 Proto2Unittest_Unittest_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Proto2Unittest_Extensions_optional_int32_extension, + Proto2Unittest_Extensions_optional_int64_extension, + Proto2Unittest_Extensions_optional_uint32_extension, + Proto2Unittest_Extensions_optional_uint64_extension, + Proto2Unittest_Extensions_optional_sint32_extension, + Proto2Unittest_Extensions_optional_sint64_extension, + Proto2Unittest_Extensions_optional_fixed32_extension, + Proto2Unittest_Extensions_optional_fixed64_extension, + Proto2Unittest_Extensions_optional_sfixed32_extension, + Proto2Unittest_Extensions_optional_sfixed64_extension, + Proto2Unittest_Extensions_optional_float_extension, + Proto2Unittest_Extensions_optional_double_extension, + Proto2Unittest_Extensions_optional_bool_extension, + Proto2Unittest_Extensions_optional_string_extension, + Proto2Unittest_Extensions_optional_bytes_extension, + Proto2Unittest_Extensions_OptionalGroup_extension, + Proto2Unittest_Extensions_optional_nested_message_extension, + Proto2Unittest_Extensions_optional_foreign_message_extension, + Proto2Unittest_Extensions_optional_import_message_extension, + Proto2Unittest_Extensions_optional_nested_enum_extension, + Proto2Unittest_Extensions_optional_foreign_enum_extension, + Proto2Unittest_Extensions_optional_import_enum_extension, + Proto2Unittest_Extensions_optional_string_piece_extension, + Proto2Unittest_Extensions_optional_cord_extension, + Proto2Unittest_Extensions_optional_bytes_cord_extension, + Proto2Unittest_Extensions_optional_public_import_message_extension, + Proto2Unittest_Extensions_optional_lazy_message_extension, + Proto2Unittest_Extensions_optional_unverified_lazy_message_extension, + Proto2Unittest_Extensions_repeated_int32_extension, + Proto2Unittest_Extensions_repeated_int64_extension, + Proto2Unittest_Extensions_repeated_uint32_extension, + Proto2Unittest_Extensions_repeated_uint64_extension, + Proto2Unittest_Extensions_repeated_sint32_extension, + Proto2Unittest_Extensions_repeated_sint64_extension, + Proto2Unittest_Extensions_repeated_fixed32_extension, + Proto2Unittest_Extensions_repeated_fixed64_extension, + Proto2Unittest_Extensions_repeated_sfixed32_extension, + Proto2Unittest_Extensions_repeated_sfixed64_extension, + Proto2Unittest_Extensions_repeated_float_extension, + Proto2Unittest_Extensions_repeated_double_extension, + Proto2Unittest_Extensions_repeated_bool_extension, + Proto2Unittest_Extensions_repeated_string_extension, + Proto2Unittest_Extensions_repeated_bytes_extension, + Proto2Unittest_Extensions_RepeatedGroup_extension, + Proto2Unittest_Extensions_repeated_nested_message_extension, + Proto2Unittest_Extensions_repeated_foreign_message_extension, + Proto2Unittest_Extensions_repeated_import_message_extension, + Proto2Unittest_Extensions_repeated_nested_enum_extension, + Proto2Unittest_Extensions_repeated_foreign_enum_extension, + Proto2Unittest_Extensions_repeated_import_enum_extension, + Proto2Unittest_Extensions_repeated_string_piece_extension, + Proto2Unittest_Extensions_repeated_cord_extension, + Proto2Unittest_Extensions_repeated_lazy_message_extension, + Proto2Unittest_Extensions_default_int32_extension, + Proto2Unittest_Extensions_default_int64_extension, + Proto2Unittest_Extensions_default_uint32_extension, + Proto2Unittest_Extensions_default_uint64_extension, + Proto2Unittest_Extensions_default_sint32_extension, + Proto2Unittest_Extensions_default_sint64_extension, + Proto2Unittest_Extensions_default_fixed32_extension, + Proto2Unittest_Extensions_default_fixed64_extension, + Proto2Unittest_Extensions_default_sfixed32_extension, + Proto2Unittest_Extensions_default_sfixed64_extension, + Proto2Unittest_Extensions_default_float_extension, + Proto2Unittest_Extensions_default_double_extension, + Proto2Unittest_Extensions_default_bool_extension, + Proto2Unittest_Extensions_default_string_extension, + Proto2Unittest_Extensions_default_bytes_extension, + Proto2Unittest_Extensions_default_nested_enum_extension, + Proto2Unittest_Extensions_default_foreign_enum_extension, + Proto2Unittest_Extensions_default_import_enum_extension, + Proto2Unittest_Extensions_default_string_piece_extension, + Proto2Unittest_Extensions_default_cord_extension, + Proto2Unittest_Extensions_oneof_uint32_extension, + Proto2Unittest_Extensions_oneof_nested_message_extension, + Proto2Unittest_Extensions_oneof_string_extension, + Proto2Unittest_Extensions_oneof_bytes_extension, + Proto2Unittest_Extensions_optional_utf8_string_extension, + Proto2Unittest_Extensions_repeated_utf8_string_extension, + Proto2Unittest_Extensions_required_message_extension, + Proto2Unittest_Extensions_my_extension_string, + Proto2Unittest_Extensions_my_extension_int, + Proto2Unittest_Extensions_packed_int32_extension, + Proto2Unittest_Extensions_packed_int64_extension, + Proto2Unittest_Extensions_packed_uint32_extension, + Proto2Unittest_Extensions_packed_uint64_extension, + Proto2Unittest_Extensions_packed_sint32_extension, + Proto2Unittest_Extensions_packed_sint64_extension, + Proto2Unittest_Extensions_packed_fixed32_extension, + Proto2Unittest_Extensions_packed_fixed64_extension, + Proto2Unittest_Extensions_packed_sfixed32_extension, + Proto2Unittest_Extensions_packed_sfixed64_extension, + Proto2Unittest_Extensions_packed_float_extension, + Proto2Unittest_Extensions_packed_double_extension, + Proto2Unittest_Extensions_packed_bool_extension, + Proto2Unittest_Extensions_packed_enum_extension, + Proto2Unittest_Extensions_unpacked_int32_extension, + Proto2Unittest_Extensions_unpacked_int64_extension, + Proto2Unittest_Extensions_unpacked_uint32_extension, + Proto2Unittest_Extensions_unpacked_uint64_extension, + Proto2Unittest_Extensions_unpacked_sint32_extension, + Proto2Unittest_Extensions_unpacked_sint64_extension, + Proto2Unittest_Extensions_unpacked_fixed32_extension, + Proto2Unittest_Extensions_unpacked_fixed64_extension, + Proto2Unittest_Extensions_unpacked_sfixed32_extension, + Proto2Unittest_Extensions_unpacked_sfixed64_extension, + Proto2Unittest_Extensions_unpacked_float_extension, + Proto2Unittest_Extensions_unpacked_double_extension, + Proto2Unittest_Extensions_unpacked_bool_extension, + Proto2Unittest_Extensions_unpacked_enum_extension, + Proto2Unittest_Extensions_test_all_types, + Proto2Unittest_Extensions_test_extension_inside_table_extension, + Proto2Unittest_Extensions_inner, + Proto2Unittest_Extensions_redacted_extension, + Proto2Unittest_TestMixedFieldsAndExtensions.Extensions.c, + Proto2Unittest_TestMixedFieldsAndExtensions.Extensions.d, + Proto2Unittest_TestNestedExtension.Extensions.test, + Proto2Unittest_TestNestedExtension.Extensions.nested_string_extension, + Proto2Unittest_TestNestedExtension.Extensions.OptionalGroup_extension, + Proto2Unittest_TestNestedExtension.Extensions.optional_foreign_enum_extension, + Proto2Unittest_TestRequired.Extensions.single, + Proto2Unittest_TestRequired.Extensions.multi, + Proto2Unittest_TestExtensionOrderings1.Extensions.test_ext_orderings1, + Proto2Unittest_TestExtensionOrderings2.Extensions.test_ext_orderings2, + Proto2Unittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3, + Proto2Unittest_TestParsingMerge.Extensions.optional_ext, + Proto2Unittest_TestParsingMerge.Extensions.repeated_ext, + Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_one, + Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_two, + Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_three, + Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_four, + Proto2Unittest_TestExtensionRangeSerialize.Extensions.bar_five, + Proto2Unittest_EnumParseTester.Extensions.optional_arbitrary_ext, + Proto2Unittest_EnumParseTester.Extensions.repeated_arbitrary_ext, + Proto2Unittest_EnumParseTester.Extensions.packed_arbitrary_ext, + Proto2Unittest_BoolParseTester.Extensions.optional_bool_ext, + Proto2Unittest_BoolParseTester.Extensions.repeated_bool_ext, + Proto2Unittest_BoolParseTester.Extensions.packed_bool_ext, + Proto2Unittest_Int32ParseTester.Extensions.optional_int32_ext, + Proto2Unittest_Int32ParseTester.Extensions.repeated_int32_ext, + Proto2Unittest_Int32ParseTester.Extensions.packed_int32_ext, + Proto2Unittest_Int64ParseTester.Extensions.optional_int64_ext, + Proto2Unittest_Int64ParseTester.Extensions.repeated_int64_ext, + Proto2Unittest_Int64ParseTester.Extensions.packed_int64_ext, + Proto2Unittest_StringParseTester.Extensions.optional_string_ext, + Proto2Unittest_StringParseTester.Extensions.repeated_string_ext +] + +// 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. + +/// Singular +let Proto2Unittest_Extensions_optional_int32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 1, + fieldName: "proto2_unittest.optional_int32_extension" +) + +let Proto2Unittest_Extensions_optional_int64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 2, + fieldName: "proto2_unittest.optional_int64_extension" +) + +let Proto2Unittest_Extensions_optional_uint32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 3, + fieldName: "proto2_unittest.optional_uint32_extension" +) + +let Proto2Unittest_Extensions_optional_uint64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 4, + fieldName: "proto2_unittest.optional_uint64_extension" +) + +let Proto2Unittest_Extensions_optional_sint32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 5, + fieldName: "proto2_unittest.optional_sint32_extension" +) + +let Proto2Unittest_Extensions_optional_sint64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 6, + fieldName: "proto2_unittest.optional_sint64_extension" +) + +let Proto2Unittest_Extensions_optional_fixed32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 7, + fieldName: "proto2_unittest.optional_fixed32_extension" +) + +let Proto2Unittest_Extensions_optional_fixed64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 8, + fieldName: "proto2_unittest.optional_fixed64_extension" +) + +let Proto2Unittest_Extensions_optional_sfixed32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 9, + fieldName: "proto2_unittest.optional_sfixed32_extension" +) + +let Proto2Unittest_Extensions_optional_sfixed64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 10, + fieldName: "proto2_unittest.optional_sfixed64_extension" +) + +let Proto2Unittest_Extensions_optional_float_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 11, + fieldName: "proto2_unittest.optional_float_extension" +) + +let Proto2Unittest_Extensions_optional_double_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 12, + fieldName: "proto2_unittest.optional_double_extension" +) + +let Proto2Unittest_Extensions_optional_bool_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 13, + fieldName: "proto2_unittest.optional_bool_extension" +) + +let Proto2Unittest_Extensions_optional_string_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 14, + fieldName: "proto2_unittest.optional_string_extension" +) + +let Proto2Unittest_Extensions_optional_bytes_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 15, + fieldName: "proto2_unittest.optional_bytes_extension" +) + +let Proto2Unittest_Extensions_OptionalGroup_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 16, + fieldName: "proto2_unittest.optionalgroup_extension" +) + +let Proto2Unittest_Extensions_optional_nested_message_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 18, + fieldName: "proto2_unittest.optional_nested_message_extension" +) + +let Proto2Unittest_Extensions_optional_foreign_message_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 19, + fieldName: "proto2_unittest.optional_foreign_message_extension" +) + +let Proto2Unittest_Extensions_optional_import_message_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 20, + fieldName: "proto2_unittest.optional_import_message_extension" +) + +let Proto2Unittest_Extensions_optional_nested_enum_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 21, + fieldName: "proto2_unittest.optional_nested_enum_extension" +) + +let Proto2Unittest_Extensions_optional_foreign_enum_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 22, + fieldName: "proto2_unittest.optional_foreign_enum_extension" +) + +let Proto2Unittest_Extensions_optional_import_enum_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 23, + fieldName: "proto2_unittest.optional_import_enum_extension" +) + +let Proto2Unittest_Extensions_optional_string_piece_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 24, + fieldName: "proto2_unittest.optional_string_piece_extension" +) + +/// TODO: ctype=CORD is not supported for extension. Add +/// ctype=CORD option back after it is supported. +let Proto2Unittest_Extensions_optional_cord_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 25, + fieldName: "proto2_unittest.optional_cord_extension" +) + +let Proto2Unittest_Extensions_optional_bytes_cord_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 86, + fieldName: "proto2_unittest.optional_bytes_cord_extension" +) + +let Proto2Unittest_Extensions_optional_public_import_message_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 26, + fieldName: "proto2_unittest.optional_public_import_message_extension" +) + +let Proto2Unittest_Extensions_optional_lazy_message_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 27, + fieldName: "proto2_unittest.optional_lazy_message_extension" +) + +let Proto2Unittest_Extensions_optional_unverified_lazy_message_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 28, + fieldName: "proto2_unittest.optional_unverified_lazy_message_extension" +) + +/// Repeated +let Proto2Unittest_Extensions_repeated_int32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 31, + fieldName: "proto2_unittest.repeated_int32_extension" +) + +let Proto2Unittest_Extensions_repeated_int64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 32, + fieldName: "proto2_unittest.repeated_int64_extension" +) + +let Proto2Unittest_Extensions_repeated_uint32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 33, + fieldName: "proto2_unittest.repeated_uint32_extension" +) + +let Proto2Unittest_Extensions_repeated_uint64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 34, + fieldName: "proto2_unittest.repeated_uint64_extension" +) + +let Proto2Unittest_Extensions_repeated_sint32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 35, + fieldName: "proto2_unittest.repeated_sint32_extension" +) + +let Proto2Unittest_Extensions_repeated_sint64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 36, + fieldName: "proto2_unittest.repeated_sint64_extension" +) + +let Proto2Unittest_Extensions_repeated_fixed32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 37, + fieldName: "proto2_unittest.repeated_fixed32_extension" +) + +let Proto2Unittest_Extensions_repeated_fixed64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 38, + fieldName: "proto2_unittest.repeated_fixed64_extension" +) + +let Proto2Unittest_Extensions_repeated_sfixed32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 39, + fieldName: "proto2_unittest.repeated_sfixed32_extension" +) + +let Proto2Unittest_Extensions_repeated_sfixed64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 40, + fieldName: "proto2_unittest.repeated_sfixed64_extension" +) + +let Proto2Unittest_Extensions_repeated_float_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 41, + fieldName: "proto2_unittest.repeated_float_extension" +) + +let Proto2Unittest_Extensions_repeated_double_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 42, + fieldName: "proto2_unittest.repeated_double_extension" +) + +let Proto2Unittest_Extensions_repeated_bool_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 43, + fieldName: "proto2_unittest.repeated_bool_extension" +) + +let Proto2Unittest_Extensions_repeated_string_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 44, + fieldName: "proto2_unittest.repeated_string_extension" +) + +let Proto2Unittest_Extensions_repeated_bytes_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 45, + fieldName: "proto2_unittest.repeated_bytes_extension" +) + +let Proto2Unittest_Extensions_RepeatedGroup_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 46, + fieldName: "proto2_unittest.repeatedgroup_extension" +) + +let Proto2Unittest_Extensions_repeated_nested_message_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 48, + fieldName: "proto2_unittest.repeated_nested_message_extension" +) + +let Proto2Unittest_Extensions_repeated_foreign_message_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 49, + fieldName: "proto2_unittest.repeated_foreign_message_extension" +) + +let Proto2Unittest_Extensions_repeated_import_message_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 50, + fieldName: "proto2_unittest.repeated_import_message_extension" +) + +let Proto2Unittest_Extensions_repeated_nested_enum_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 51, + fieldName: "proto2_unittest.repeated_nested_enum_extension" +) + +let Proto2Unittest_Extensions_repeated_foreign_enum_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 52, + fieldName: "proto2_unittest.repeated_foreign_enum_extension" +) + +let Proto2Unittest_Extensions_repeated_import_enum_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 53, + fieldName: "proto2_unittest.repeated_import_enum_extension" +) + +let Proto2Unittest_Extensions_repeated_string_piece_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 54, + fieldName: "proto2_unittest.repeated_string_piece_extension" +) + +/// TODO: ctype=CORD is not supported for extension. Add +/// ctype=CORD option back after it is supported. +let Proto2Unittest_Extensions_repeated_cord_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 55, + fieldName: "proto2_unittest.repeated_cord_extension" +) + +let Proto2Unittest_Extensions_repeated_lazy_message_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 57, + fieldName: "proto2_unittest.repeated_lazy_message_extension" +) + +/// Singular with defaults +let Proto2Unittest_Extensions_default_int32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 61, + fieldName: "proto2_unittest.default_int32_extension" +) + +let Proto2Unittest_Extensions_default_int64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 62, + fieldName: "proto2_unittest.default_int64_extension" +) + +let Proto2Unittest_Extensions_default_uint32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 63, + fieldName: "proto2_unittest.default_uint32_extension" +) + +let Proto2Unittest_Extensions_default_uint64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 64, + fieldName: "proto2_unittest.default_uint64_extension" +) + +let Proto2Unittest_Extensions_default_sint32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 65, + fieldName: "proto2_unittest.default_sint32_extension" +) + +let Proto2Unittest_Extensions_default_sint64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 66, + fieldName: "proto2_unittest.default_sint64_extension" +) + +let Proto2Unittest_Extensions_default_fixed32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 67, + fieldName: "proto2_unittest.default_fixed32_extension" +) + +let Proto2Unittest_Extensions_default_fixed64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 68, + fieldName: "proto2_unittest.default_fixed64_extension" +) + +let Proto2Unittest_Extensions_default_sfixed32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 69, + fieldName: "proto2_unittest.default_sfixed32_extension" +) + +let Proto2Unittest_Extensions_default_sfixed64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 70, + fieldName: "proto2_unittest.default_sfixed64_extension" +) + +let Proto2Unittest_Extensions_default_float_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 71, + fieldName: "proto2_unittest.default_float_extension" +) + +let Proto2Unittest_Extensions_default_double_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 72, + fieldName: "proto2_unittest.default_double_extension" +) + +let Proto2Unittest_Extensions_default_bool_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 73, + fieldName: "proto2_unittest.default_bool_extension" +) + +let Proto2Unittest_Extensions_default_string_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 74, + fieldName: "proto2_unittest.default_string_extension" +) + +let Proto2Unittest_Extensions_default_bytes_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 75, + fieldName: "proto2_unittest.default_bytes_extension" +) + +let Proto2Unittest_Extensions_default_nested_enum_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 81, + fieldName: "proto2_unittest.default_nested_enum_extension" +) + +let Proto2Unittest_Extensions_default_foreign_enum_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 82, + fieldName: "proto2_unittest.default_foreign_enum_extension" +) + +let Proto2Unittest_Extensions_default_import_enum_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 83, + fieldName: "proto2_unittest.default_import_enum_extension" +) + +let Proto2Unittest_Extensions_default_string_piece_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 84, + fieldName: "proto2_unittest.default_string_piece_extension" +) + +/// TODO: ctype=CORD is not supported for extension. Add +/// ctype=CORD option back after it is supported. +let Proto2Unittest_Extensions_default_cord_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 85, + fieldName: "proto2_unittest.default_cord_extension" +) + +/// For oneof test +let Proto2Unittest_Extensions_oneof_uint32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 111, + fieldName: "proto2_unittest.oneof_uint32_extension" +) + +let Proto2Unittest_Extensions_oneof_nested_message_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 112, + fieldName: "proto2_unittest.oneof_nested_message_extension" +) + +let Proto2Unittest_Extensions_oneof_string_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 113, + fieldName: "proto2_unittest.oneof_string_extension" +) + +let Proto2Unittest_Extensions_oneof_bytes_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 114, + fieldName: "proto2_unittest.oneof_bytes_extension" +) + +let Proto2Unittest_Extensions_optional_utf8_string_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 115, + fieldName: "proto2_unittest.optional_utf8_string_extension" +) + +let Proto2Unittest_Extensions_repeated_utf8_string_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 116, + fieldName: "proto2_unittest.repeated_utf8_string_extension" +) + +/// Singular message containing required fields; used to test initialization. +let Proto2Unittest_Extensions_required_message_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 117, + fieldName: "proto2_unittest.required_message_extension" +) + +let Proto2Unittest_Extensions_my_extension_string = SwiftProtobuf.MessageExtension, Proto2Unittest_TestFieldOrderings>( + _protobuf_fieldNumber: 50, + fieldName: "proto2_unittest.my_extension_string" +) + +let Proto2Unittest_Extensions_my_extension_int = SwiftProtobuf.MessageExtension, Proto2Unittest_TestFieldOrderings>( + _protobuf_fieldNumber: 5, + fieldName: "proto2_unittest.my_extension_int" +) + +let Proto2Unittest_Extensions_packed_int32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensions>( + _protobuf_fieldNumber: 90, + fieldName: "proto2_unittest.packed_int32_extension" +) + +let Proto2Unittest_Extensions_packed_int64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensions>( + _protobuf_fieldNumber: 91, + fieldName: "proto2_unittest.packed_int64_extension" +) + +let Proto2Unittest_Extensions_packed_uint32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensions>( + _protobuf_fieldNumber: 92, + fieldName: "proto2_unittest.packed_uint32_extension" +) + +let Proto2Unittest_Extensions_packed_uint64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensions>( + _protobuf_fieldNumber: 93, + fieldName: "proto2_unittest.packed_uint64_extension" +) + +let Proto2Unittest_Extensions_packed_sint32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensions>( + _protobuf_fieldNumber: 94, + fieldName: "proto2_unittest.packed_sint32_extension" +) + +let Proto2Unittest_Extensions_packed_sint64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensions>( + _protobuf_fieldNumber: 95, + fieldName: "proto2_unittest.packed_sint64_extension" +) + +let Proto2Unittest_Extensions_packed_fixed32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensions>( + _protobuf_fieldNumber: 96, + fieldName: "proto2_unittest.packed_fixed32_extension" +) + +let Proto2Unittest_Extensions_packed_fixed64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensions>( + _protobuf_fieldNumber: 97, + fieldName: "proto2_unittest.packed_fixed64_extension" +) + +let Proto2Unittest_Extensions_packed_sfixed32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensions>( + _protobuf_fieldNumber: 98, + fieldName: "proto2_unittest.packed_sfixed32_extension" +) + +let Proto2Unittest_Extensions_packed_sfixed64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensions>( + _protobuf_fieldNumber: 99, + fieldName: "proto2_unittest.packed_sfixed64_extension" +) + +let Proto2Unittest_Extensions_packed_float_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensions>( + _protobuf_fieldNumber: 100, + fieldName: "proto2_unittest.packed_float_extension" +) + +let Proto2Unittest_Extensions_packed_double_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensions>( + _protobuf_fieldNumber: 101, + fieldName: "proto2_unittest.packed_double_extension" +) + +let Proto2Unittest_Extensions_packed_bool_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensions>( + _protobuf_fieldNumber: 102, + fieldName: "proto2_unittest.packed_bool_extension" +) + +let Proto2Unittest_Extensions_packed_enum_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensions>( + _protobuf_fieldNumber: 103, + fieldName: "proto2_unittest.packed_enum_extension" +) + +let Proto2Unittest_Extensions_unpacked_int32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 90, + fieldName: "proto2_unittest.unpacked_int32_extension" +) + +let Proto2Unittest_Extensions_unpacked_int64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 91, + fieldName: "proto2_unittest.unpacked_int64_extension" +) + +let Proto2Unittest_Extensions_unpacked_uint32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 92, + fieldName: "proto2_unittest.unpacked_uint32_extension" +) + +let Proto2Unittest_Extensions_unpacked_uint64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 93, + fieldName: "proto2_unittest.unpacked_uint64_extension" +) + +let Proto2Unittest_Extensions_unpacked_sint32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 94, + fieldName: "proto2_unittest.unpacked_sint32_extension" +) + +let Proto2Unittest_Extensions_unpacked_sint64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 95, + fieldName: "proto2_unittest.unpacked_sint64_extension" +) + +let Proto2Unittest_Extensions_unpacked_fixed32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 96, + fieldName: "proto2_unittest.unpacked_fixed32_extension" +) + +let Proto2Unittest_Extensions_unpacked_fixed64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 97, + fieldName: "proto2_unittest.unpacked_fixed64_extension" +) + +let Proto2Unittest_Extensions_unpacked_sfixed32_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 98, + fieldName: "proto2_unittest.unpacked_sfixed32_extension" +) + +let Proto2Unittest_Extensions_unpacked_sfixed64_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 99, + fieldName: "proto2_unittest.unpacked_sfixed64_extension" +) + +let Proto2Unittest_Extensions_unpacked_float_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 100, + fieldName: "proto2_unittest.unpacked_float_extension" +) + +let Proto2Unittest_Extensions_unpacked_double_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 101, + fieldName: "proto2_unittest.unpacked_double_extension" +) + +let Proto2Unittest_Extensions_unpacked_bool_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 102, + fieldName: "proto2_unittest.unpacked_bool_extension" +) + +let Proto2Unittest_Extensions_unpacked_enum_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestUnpackedExtensions>( + _protobuf_fieldNumber: 103, + fieldName: "proto2_unittest.unpacked_enum_extension" +) + +let Proto2Unittest_Extensions_test_all_types = SwiftProtobuf.MessageExtension, Proto2Unittest_TestHugeFieldNumbers>( + _protobuf_fieldNumber: 536860000, + fieldName: "proto2_unittest.test_all_types" +) + +let Proto2Unittest_Extensions_test_extension_inside_table_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestExtensionInsideTable>( + _protobuf_fieldNumber: 5, + fieldName: "proto2_unittest.test_extension_inside_table_extension" +) + +let Proto2Unittest_Extensions_inner = SwiftProtobuf.MessageExtension, Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2RepeatedGroup>( + _protobuf_fieldNumber: 3, + fieldName: "proto2_unittest.inner" +) + +let Proto2Unittest_Extensions_redacted_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_RedactedFields>( + _protobuf_fieldNumber: 20, + fieldName: "proto2_unittest.redacted_extension" +) + +extension Proto2Unittest_TestMixedFieldsAndExtensions { + enum Extensions { + static let c = SwiftProtobuf.MessageExtension, Proto2Unittest_TestMixedFieldsAndExtensions>( + _protobuf_fieldNumber: 2, + fieldName: "proto2_unittest.TestMixedFieldsAndExtensions.c" + ) + + static let d = SwiftProtobuf.MessageExtension, Proto2Unittest_TestMixedFieldsAndExtensions>( + _protobuf_fieldNumber: 4, + fieldName: "proto2_unittest.TestMixedFieldsAndExtensions.d" + ) + } +} + +extension Proto2Unittest_TestNestedExtension { + enum Extensions { + /// Check for bug where string extensions declared in tested scope did not + /// compile. + static let test = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 1002, + fieldName: "proto2_unittest.TestNestedExtension.test" + ) + + /// Used to test if generated extension name is correct when there are + /// underscores. + static let nested_string_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 1003, + fieldName: "proto2_unittest.TestNestedExtension.nested_string_extension" + ) + + static let OptionalGroup_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestGroupExtension>( + _protobuf_fieldNumber: 16, + fieldName: "proto2_unittest.TestNestedExtension.optionalgroup_extension" + ) + + static let optional_foreign_enum_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestGroupExtension>( + _protobuf_fieldNumber: 22, + fieldName: "proto2_unittest.TestNestedExtension.optional_foreign_enum_extension" + ) + } +} + +extension Proto2Unittest_TestRequired { + enum Extensions { + static let single = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 1000, + fieldName: "proto2_unittest.TestRequired.single" + ) + + static let multi = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensions>( + _protobuf_fieldNumber: 1001, + fieldName: "proto2_unittest.TestRequired.multi" + ) + } +} + +extension Proto2Unittest_TestExtensionOrderings1 { + enum Extensions { + static let test_ext_orderings1 = SwiftProtobuf.MessageExtension, Proto2Unittest_TestFieldOrderings>( + _protobuf_fieldNumber: 13, + fieldName: "proto2_unittest.TestExtensionOrderings1.test_ext_orderings1" + ) + } +} + +extension Proto2Unittest_TestExtensionOrderings2 { + enum Extensions { + static let test_ext_orderings2 = SwiftProtobuf.MessageExtension, Proto2Unittest_TestFieldOrderings>( + _protobuf_fieldNumber: 12, + fieldName: "proto2_unittest.TestExtensionOrderings2.test_ext_orderings2" + ) + } +} + +extension Proto2Unittest_TestExtensionOrderings2.TestExtensionOrderings3 { + enum Extensions { + static let test_ext_orderings3 = SwiftProtobuf.MessageExtension, Proto2Unittest_TestFieldOrderings>( + _protobuf_fieldNumber: 14, + fieldName: "proto2_unittest.TestExtensionOrderings2.TestExtensionOrderings3.test_ext_orderings3" + ) + } +} + +extension Proto2Unittest_TestParsingMerge { + enum Extensions { + static let optional_ext = SwiftProtobuf.MessageExtension, Proto2Unittest_TestParsingMerge>( + _protobuf_fieldNumber: 1000, + fieldName: "proto2_unittest.TestParsingMerge.optional_ext" + ) + + static let repeated_ext = SwiftProtobuf.MessageExtension, Proto2Unittest_TestParsingMerge>( + _protobuf_fieldNumber: 1001, + fieldName: "proto2_unittest.TestParsingMerge.repeated_ext" + ) + } +} + +extension Proto2Unittest_TestExtensionRangeSerialize { + enum Extensions { + static let bar_one = SwiftProtobuf.MessageExtension, Proto2Unittest_TestExtensionRangeSerialize>( + _protobuf_fieldNumber: 2, + fieldName: "proto2_unittest.TestExtensionRangeSerialize.bar_one" + ) + + static let bar_two = SwiftProtobuf.MessageExtension, Proto2Unittest_TestExtensionRangeSerialize>( + _protobuf_fieldNumber: 4, + fieldName: "proto2_unittest.TestExtensionRangeSerialize.bar_two" + ) + + static let bar_three = SwiftProtobuf.MessageExtension, Proto2Unittest_TestExtensionRangeSerialize>( + _protobuf_fieldNumber: 10, + fieldName: "proto2_unittest.TestExtensionRangeSerialize.bar_three" + ) + + static let bar_four = SwiftProtobuf.MessageExtension, Proto2Unittest_TestExtensionRangeSerialize>( + _protobuf_fieldNumber: 15, + fieldName: "proto2_unittest.TestExtensionRangeSerialize.bar_four" + ) + + static let bar_five = SwiftProtobuf.MessageExtension, Proto2Unittest_TestExtensionRangeSerialize>( + _protobuf_fieldNumber: 19, + fieldName: "proto2_unittest.TestExtensionRangeSerialize.bar_five" + ) + } +} + +extension Proto2Unittest_EnumParseTester { + enum Extensions { + static let optional_arbitrary_ext = SwiftProtobuf.MessageExtension, Proto2Unittest_EnumParseTester>( + _protobuf_fieldNumber: 2000000, + fieldName: "proto2_unittest.EnumParseTester.optional_arbitrary_ext" + ) + + static let repeated_arbitrary_ext = SwiftProtobuf.MessageExtension, Proto2Unittest_EnumParseTester>( + _protobuf_fieldNumber: 2000001, + fieldName: "proto2_unittest.EnumParseTester.repeated_arbitrary_ext" + ) + + static let packed_arbitrary_ext = SwiftProtobuf.MessageExtension, Proto2Unittest_EnumParseTester>( + _protobuf_fieldNumber: 2000002, + fieldName: "proto2_unittest.EnumParseTester.packed_arbitrary_ext" + ) + } +} + +extension Proto2Unittest_BoolParseTester { + enum Extensions { + static let optional_bool_ext = SwiftProtobuf.MessageExtension, Proto2Unittest_BoolParseTester>( + _protobuf_fieldNumber: 2000000, + fieldName: "proto2_unittest.BoolParseTester.optional_bool_ext" + ) + + static let repeated_bool_ext = SwiftProtobuf.MessageExtension, Proto2Unittest_BoolParseTester>( + _protobuf_fieldNumber: 2000001, + fieldName: "proto2_unittest.BoolParseTester.repeated_bool_ext" + ) + + static let packed_bool_ext = SwiftProtobuf.MessageExtension, Proto2Unittest_BoolParseTester>( + _protobuf_fieldNumber: 2000002, + fieldName: "proto2_unittest.BoolParseTester.packed_bool_ext" + ) + } +} + +extension Proto2Unittest_Int32ParseTester { + enum Extensions { + static let optional_int32_ext = SwiftProtobuf.MessageExtension, Proto2Unittest_Int32ParseTester>( + _protobuf_fieldNumber: 2000000, + fieldName: "proto2_unittest.Int32ParseTester.optional_int32_ext" + ) + + static let repeated_int32_ext = SwiftProtobuf.MessageExtension, Proto2Unittest_Int32ParseTester>( + _protobuf_fieldNumber: 2000001, + fieldName: "proto2_unittest.Int32ParseTester.repeated_int32_ext" + ) + + static let packed_int32_ext = SwiftProtobuf.MessageExtension, Proto2Unittest_Int32ParseTester>( + _protobuf_fieldNumber: 2000002, + fieldName: "proto2_unittest.Int32ParseTester.packed_int32_ext" + ) + } +} + +extension Proto2Unittest_Int64ParseTester { + enum Extensions { + static let optional_int64_ext = SwiftProtobuf.MessageExtension, Proto2Unittest_Int64ParseTester>( + _protobuf_fieldNumber: 2000000, + fieldName: "proto2_unittest.Int64ParseTester.optional_int64_ext" + ) + + static let repeated_int64_ext = SwiftProtobuf.MessageExtension, Proto2Unittest_Int64ParseTester>( + _protobuf_fieldNumber: 2000001, + fieldName: "proto2_unittest.Int64ParseTester.repeated_int64_ext" + ) + + static let packed_int64_ext = SwiftProtobuf.MessageExtension, Proto2Unittest_Int64ParseTester>( + _protobuf_fieldNumber: 2000002, + fieldName: "proto2_unittest.Int64ParseTester.packed_int64_ext" + ) + } +} + +extension Proto2Unittest_StringParseTester { + enum Extensions { + static let optional_string_ext = SwiftProtobuf.MessageExtension, Proto2Unittest_StringParseTester>( + _protobuf_fieldNumber: 2000000, + fieldName: "proto2_unittest.StringParseTester.optional_string_ext" + ) + + static let repeated_string_ext = SwiftProtobuf.MessageExtension, Proto2Unittest_StringParseTester>( + _protobuf_fieldNumber: 2000001, + fieldName: "proto2_unittest.StringParseTester.repeated_string_ext" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest" + +extension Proto2Unittest_ForeignEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{4}FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0\u{2}\u{1a}FOREIGN_BAX\0\u{2}`H\u{1e}FOREIGN_LARGE\0") +} + +extension Proto2Unittest_TestReservedEnumFields: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNKNOWN\0") +} + +extension Proto2Unittest_ForeignOpenEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_OPEN_UNKNOWN\0\u{2}\u{4}FOREIGN_OPEN_FOO\0\u{1}FOREIGN_OPEN_BAR\0\u{1}FOREIGN_OPEN_BAZ\0\u{2}\u{1a}FOREIGN_OPEN_BAX\0") +} + +extension Proto2Unittest_TestEnumWithDupValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{9}FOO1\0\u{1}FOO2\0\u{9}BAR1\0\u{1}BAR2\0\u{1}BAZ\0") +} + +extension Proto2Unittest_TestSparseEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}t|r\u{7f}\u{7f}\u{3}SPARSE_E\0\u{2}}B\u{d}SPARSE_D\0\u{2}\u{f}SPARSE_F\0\u{2}\u{2}SPARSE_G\0\u{2}y\u{1}SPARSE_A\0\u{2}kL\u{f}SPARSE_B\0\u{2}LTr/SPARSE_C\0") +} + +extension Proto2Unittest_VeryLargeEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ENUM_LABEL_DEFAULT\0\u{1}ENUM_LABEL_1\0\u{1}ENUM_LABEL_2\0\u{1}ENUM_LABEL_3\0\u{1}ENUM_LABEL_4\0\u{1}ENUM_LABEL_5\0\u{1}ENUM_LABEL_6\0\u{1}ENUM_LABEL_7\0\u{1}ENUM_LABEL_8\0\u{1}ENUM_LABEL_9\0\u{1}ENUM_LABEL_10\0\u{1}ENUM_LABEL_11\0\u{1}ENUM_LABEL_12\0\u{1}ENUM_LABEL_13\0\u{1}ENUM_LABEL_14\0\u{1}ENUM_LABEL_15\0\u{1}ENUM_LABEL_16\0\u{1}ENUM_LABEL_17\0\u{1}ENUM_LABEL_18\0\u{1}ENUM_LABEL_19\0\u{1}ENUM_LABEL_20\0\u{1}ENUM_LABEL_21\0\u{1}ENUM_LABEL_22\0\u{1}ENUM_LABEL_23\0\u{1}ENUM_LABEL_24\0\u{1}ENUM_LABEL_25\0\u{1}ENUM_LABEL_26\0\u{1}ENUM_LABEL_27\0\u{1}ENUM_LABEL_28\0\u{1}ENUM_LABEL_29\0\u{1}ENUM_LABEL_30\0\u{1}ENUM_LABEL_31\0\u{1}ENUM_LABEL_32\0\u{1}ENUM_LABEL_33\0\u{1}ENUM_LABEL_34\0\u{1}ENUM_LABEL_35\0\u{1}ENUM_LABEL_36\0\u{1}ENUM_LABEL_37\0\u{1}ENUM_LABEL_38\0\u{1}ENUM_LABEL_39\0\u{1}ENUM_LABEL_40\0\u{1}ENUM_LABEL_41\0\u{1}ENUM_LABEL_42\0\u{1}ENUM_LABEL_43\0\u{1}ENUM_LABEL_44\0\u{1}ENUM_LABEL_45\0\u{1}ENUM_LABEL_46\0\u{1}ENUM_LABEL_47\0\u{1}ENUM_LABEL_48\0\u{1}ENUM_LABEL_49\0\u{1}ENUM_LABEL_50\0\u{1}ENUM_LABEL_51\0\u{1}ENUM_LABEL_52\0\u{1}ENUM_LABEL_53\0\u{1}ENUM_LABEL_54\0\u{1}ENUM_LABEL_55\0\u{1}ENUM_LABEL_56\0\u{1}ENUM_LABEL_57\0\u{1}ENUM_LABEL_58\0\u{1}ENUM_LABEL_59\0\u{1}ENUM_LABEL_60\0\u{1}ENUM_LABEL_61\0\u{1}ENUM_LABEL_62\0\u{1}ENUM_LABEL_63\0\u{1}ENUM_LABEL_64\0\u{1}ENUM_LABEL_65\0\u{1}ENUM_LABEL_66\0\u{1}ENUM_LABEL_67\0\u{1}ENUM_LABEL_68\0\u{1}ENUM_LABEL_69\0\u{1}ENUM_LABEL_70\0\u{1}ENUM_LABEL_71\0\u{1}ENUM_LABEL_72\0\u{1}ENUM_LABEL_73\0\u{1}ENUM_LABEL_74\0\u{1}ENUM_LABEL_75\0\u{1}ENUM_LABEL_76\0\u{1}ENUM_LABEL_77\0\u{1}ENUM_LABEL_78\0\u{1}ENUM_LABEL_79\0\u{1}ENUM_LABEL_80\0\u{1}ENUM_LABEL_81\0\u{1}ENUM_LABEL_82\0\u{1}ENUM_LABEL_83\0\u{1}ENUM_LABEL_84\0\u{1}ENUM_LABEL_85\0\u{1}ENUM_LABEL_86\0\u{1}ENUM_LABEL_87\0\u{1}ENUM_LABEL_88\0\u{1}ENUM_LABEL_89\0\u{1}ENUM_LABEL_90\0\u{1}ENUM_LABEL_91\0\u{1}ENUM_LABEL_92\0\u{1}ENUM_LABEL_93\0\u{1}ENUM_LABEL_94\0\u{1}ENUM_LABEL_95\0\u{1}ENUM_LABEL_96\0\u{1}ENUM_LABEL_97\0\u{1}ENUM_LABEL_98\0\u{1}ENUM_LABEL_99\0\u{1}ENUM_LABEL_100\0") +} + +extension Proto2Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{7}OptionalGroup\0\u{4}\u{2}optional_nested_message\0\u{3}optional_foreign_message\0\u{3}optional_import_message\0\u{3}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{3}optional_import_enum\0\u{3}optional_string_piece\0\u{3}optional_cord\0\u{3}optional_public_import_message\0\u{3}optional_lazy_message\0\u{3}optional_unverified_lazy_message\0\u{4}\u{3}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{7}RepeatedGroup\0\u{4}\u{2}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{3}repeated_import_message\0\u{3}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{3}repeated_import_enum\0\u{3}repeated_string_piece\0\u{3}repeated_cord\0\u{4}\u{2}repeated_lazy_message\0\u{4}\u{4}default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{4}\u{6}default_nested_enum\0\u{3}default_foreign_enum\0\u{3}default_import_enum\0\u{3}default_string_piece\0\u{3}default_cord\0\u{3}optional_bytes_cord\0\u{4}\u{19}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_cord\0\u{3}oneof_string_piece\0\u{3}oneof_lazy_nested_message\0") + + fileprivate class _StorageClass { + var _optionalInt32: Int32? = nil + var _optionalInt64: Int64? = nil + var _optionalUint32: UInt32? = nil + var _optionalUint64: UInt64? = nil + var _optionalSint32: Int32? = nil + var _optionalSint64: Int64? = nil + var _optionalFixed32: UInt32? = nil + var _optionalFixed64: UInt64? = nil + var _optionalSfixed32: Int32? = nil + var _optionalSfixed64: Int64? = nil + var _optionalFloat: Float? = nil + var _optionalDouble: Double? = nil + var _optionalBool: Bool? = nil + var _optionalString: String? = nil + var _optionalBytes: Data? = nil + var _optionalGroup: Proto2Unittest_TestAllTypes.OptionalGroup? = nil + var _optionalNestedMessage: Proto2Unittest_TestAllTypes.NestedMessage? = nil + var _optionalForeignMessage: Proto2Unittest_ForeignMessage? = nil + var _optionalImportMessage: Proto2UnittestImport_ImportMessage? = nil + var _optionalNestedEnum: Proto2Unittest_TestAllTypes.NestedEnum? = nil + var _optionalForeignEnum: Proto2Unittest_ForeignEnum? = nil + var _optionalImportEnum: Proto2UnittestImport_ImportEnum? = nil + var _optionalStringPiece: String? = nil + var _optionalCord: String? = nil + var _optionalBytesCord: Data? = nil + var _optionalPublicImportMessage: Proto2UnittestImport_PublicImportMessage? = nil + var _optionalLazyMessage: Proto2Unittest_TestAllTypes.NestedMessage? = nil + var _optionalUnverifiedLazyMessage: Proto2Unittest_TestAllTypes.NestedMessage? = nil + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedGroup: [Proto2Unittest_TestAllTypes.RepeatedGroup] = [] + var _repeatedNestedMessage: [Proto2Unittest_TestAllTypes.NestedMessage] = [] + var _repeatedForeignMessage: [Proto2Unittest_ForeignMessage] = [] + var _repeatedImportMessage: [Proto2UnittestImport_ImportMessage] = [] + var _repeatedNestedEnum: [Proto2Unittest_TestAllTypes.NestedEnum] = [] + var _repeatedForeignEnum: [Proto2Unittest_ForeignEnum] = [] + var _repeatedImportEnum: [Proto2UnittestImport_ImportEnum] = [] + var _repeatedStringPiece: [String] = [] + var _repeatedCord: [String] = [] + var _repeatedLazyMessage: [Proto2Unittest_TestAllTypes.NestedMessage] = [] + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + var _defaultNestedEnum: Proto2Unittest_TestAllTypes.NestedEnum? = nil + var _defaultForeignEnum: Proto2Unittest_ForeignEnum? = nil + var _defaultImportEnum: Proto2UnittestImport_ImportEnum? = nil + var _defaultStringPiece: String? = nil + var _defaultCord: String? = nil + var _oneofField: Proto2Unittest_TestAllTypes.OneOf_OneofField? + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalGroup = source._optionalGroup + _optionalNestedMessage = source._optionalNestedMessage + _optionalForeignMessage = source._optionalForeignMessage + _optionalImportMessage = source._optionalImportMessage + _optionalNestedEnum = source._optionalNestedEnum + _optionalForeignEnum = source._optionalForeignEnum + _optionalImportEnum = source._optionalImportEnum + _optionalStringPiece = source._optionalStringPiece + _optionalCord = source._optionalCord + _optionalBytesCord = source._optionalBytesCord + _optionalPublicImportMessage = source._optionalPublicImportMessage + _optionalLazyMessage = source._optionalLazyMessage + _optionalUnverifiedLazyMessage = source._optionalUnverifiedLazyMessage + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedGroup = source._repeatedGroup + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedForeignMessage = source._repeatedForeignMessage + _repeatedImportMessage = source._repeatedImportMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _repeatedForeignEnum = source._repeatedForeignEnum + _repeatedImportEnum = source._repeatedImportEnum + _repeatedStringPiece = source._repeatedStringPiece + _repeatedCord = source._repeatedCord + _repeatedLazyMessage = source._repeatedLazyMessage + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + _defaultNestedEnum = source._defaultNestedEnum + _defaultForeignEnum = source._defaultForeignEnum + _defaultImportEnum = source._defaultImportEnum + _defaultStringPiece = source._defaultStringPiece + _defaultCord = source._defaultCord + _oneofField = source._oneofField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 16: try { try decoder.decodeSingularGroupField(value: &_storage._optionalGroup) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() + case 20: try { try decoder.decodeSingularMessageField(value: &_storage._optionalImportMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() + case 23: try { try decoder.decodeSingularEnumField(value: &_storage._optionalImportEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() + case 26: try { try decoder.decodeSingularMessageField(value: &_storage._optionalPublicImportMessage) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._optionalLazyMessage) }() + case 28: try { try decoder.decodeSingularMessageField(value: &_storage._optionalUnverifiedLazyMessage) }() + case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() + case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() + case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() + case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() + case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() + case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() + case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() + case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() + case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() + case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() + case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() + case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() + case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() + case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() + case 46: try { try decoder.decodeRepeatedGroupField(value: &_storage._repeatedGroup) }() + case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() + case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() + case 50: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedImportMessage) }() + case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() + case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() + case 53: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedImportEnum) }() + case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() + case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() + case 57: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedLazyMessage) }() + case 61: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 62: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 63: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 64: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 65: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 66: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 67: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 68: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 69: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 70: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 71: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 72: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 73: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 74: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 75: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() + case 81: try { try decoder.decodeSingularEnumField(value: &_storage._defaultNestedEnum) }() + case 82: try { try decoder.decodeSingularEnumField(value: &_storage._defaultForeignEnum) }() + case 83: try { try decoder.decodeSingularEnumField(value: &_storage._defaultImportEnum) }() + case 84: try { try decoder.decodeSingularStringField(value: &_storage._defaultStringPiece) }() + case 85: try { try decoder.decodeSingularStringField(value: &_storage._defaultCord) }() + case 86: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytesCord) }() + case 111: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 112: try { + var v: Proto2Unittest_TestAllTypes.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage(v) + } + }() + case 113: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 114: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() + case 115: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofCord(v) + } + }() + case 116: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofStringPiece(v) + } + }() + case 117: try { + var v: Proto2Unittest_TestAllTypes.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofLazyNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofLazyNestedMessage(v) + } + }() + default: break + } + } + } + } + + func traverse(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._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._optionalInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._optionalUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._optionalSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._optionalSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._optionalFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._optionalFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._optionalSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._optionalSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._optionalFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._optionalDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._optionalBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._optionalForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._optionalImportMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 20) + } }() + try { if let v = _storage._optionalNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._optionalForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._optionalImportEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 23) + } }() + try { if let v = _storage._optionalStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._optionalCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._optionalPublicImportMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 26) + } }() + try { if let v = _storage._optionalLazyMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + try { if let v = _storage._optionalUnverifiedLazyMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 28) + } }() + if !_storage._repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + } + if !_storage._repeatedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + } + if !_storage._repeatedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + } + if !_storage._repeatedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + } + if !_storage._repeatedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + } + if !_storage._repeatedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + } + if !_storage._repeatedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + } + if !_storage._repeatedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + } + if !_storage._repeatedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + } + if !_storage._repeatedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + } + if !_storage._repeatedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + } + if !_storage._repeatedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + } + if !_storage._repeatedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + } + if !_storage._repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) + } + if !_storage._repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) + } + if !_storage._repeatedGroup.isEmpty { + try visitor.visitRepeatedGroupField(value: _storage._repeatedGroup, fieldNumber: 46) + } + if !_storage._repeatedNestedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) + } + if !_storage._repeatedForeignMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) + } + if !_storage._repeatedImportMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedImportMessage, fieldNumber: 50) + } + if !_storage._repeatedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + } + if !_storage._repeatedForeignEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) + } + if !_storage._repeatedImportEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedImportEnum, fieldNumber: 53) + } + if !_storage._repeatedStringPiece.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) + } + if !_storage._repeatedCord.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) + } + if !_storage._repeatedLazyMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedLazyMessage, fieldNumber: 57) + } + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 61) + } }() + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 62) + } }() + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 64) + } }() + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 65) + } }() + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 66) + } }() + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 67) + } }() + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 68) + } }() + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 69) + } }() + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 70) + } }() + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 71) + } }() + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 72) + } }() + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 73) + } }() + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 74) + } }() + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 75) + } }() + try { if let v = _storage._defaultNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 81) + } }() + try { if let v = _storage._defaultForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 82) + } }() + try { if let v = _storage._defaultImportEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 83) + } }() + try { if let v = _storage._defaultStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 84) + } }() + try { if let v = _storage._defaultCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 85) + } }() + try { if let v = _storage._optionalBytesCord { + try visitor.visitSingularBytesField(value: v, fieldNumber: 86) + } }() + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case .oneofCord?: try { + guard case .oneofCord(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 115) + }() + case .oneofStringPiece?: try { + guard case .oneofStringPiece(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 116) + }() + case .oneofLazyNestedMessage?: try { + guard case .oneofLazyNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 117) + }() + case nil: break + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestAllTypes, rhs: Proto2Unittest_TestAllTypes) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalGroup != rhs_storage._optionalGroup {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} + if _storage._optionalImportMessage != rhs_storage._optionalImportMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} + if _storage._optionalImportEnum != rhs_storage._optionalImportEnum {return false} + if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} + if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._optionalBytesCord != rhs_storage._optionalBytesCord {return false} + if _storage._optionalPublicImportMessage != rhs_storage._optionalPublicImportMessage {return false} + if _storage._optionalLazyMessage != rhs_storage._optionalLazyMessage {return false} + if _storage._optionalUnverifiedLazyMessage != rhs_storage._optionalUnverifiedLazyMessage {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedGroup != rhs_storage._repeatedGroup {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} + if _storage._repeatedImportMessage != rhs_storage._repeatedImportMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} + if _storage._repeatedImportEnum != rhs_storage._repeatedImportEnum {return false} + if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} + if _storage._repeatedCord != rhs_storage._repeatedCord {return false} + if _storage._repeatedLazyMessage != rhs_storage._repeatedLazyMessage {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} + if _storage._defaultNestedEnum != rhs_storage._defaultNestedEnum {return false} + if _storage._defaultForeignEnum != rhs_storage._defaultForeignEnum {return false} + if _storage._defaultImportEnum != rhs_storage._defaultImportEnum {return false} + if _storage._defaultStringPiece != rhs_storage._defaultStringPiece {return false} + if _storage._defaultCord != rhs_storage._defaultCord {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestAllTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{2}\u{2}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension Proto2Unittest_TestAllTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestAllTypes.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") + + 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._bb) }() + 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 + try { if let v = self._bb { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestAllTypes.NestedMessage, rhs: Proto2Unittest_TestAllTypes.NestedMessage) -> Bool { + if lhs._bb != rhs._bb {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestAllTypes.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestAllTypes.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{11}a\0") + + 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestAllTypes.OptionalGroup, rhs: Proto2Unittest_TestAllTypes.OptionalGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestAllTypes.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestAllTypes.protoMessageName + ".RepeatedGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}/a\0") + + 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 47: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestAllTypes.RepeatedGroup, rhs: Proto2Unittest_TestAllTypes.RepeatedGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NestedTestAllTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}child\0\u{1}payload\0\u{3}repeated_child\0\u{3}lazy_child\0\u{3}eager_child\0") + + fileprivate class _StorageClass { + var _child: Proto2Unittest_NestedTestAllTypes? = nil + var _payload: Proto2Unittest_TestAllTypes? = nil + var _repeatedChild: [Proto2Unittest_NestedTestAllTypes] = [] + var _lazyChild: Proto2Unittest_NestedTestAllTypes? = nil + var _eagerChild: Proto2Unittest_TestAllTypes? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _child = source._child + _payload = source._payload + _repeatedChild = source._repeatedChild + _lazyChild = source._lazyChild + _eagerChild = source._eagerChild + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._child) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._payload) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedChild) }() + case 4: try { try decoder.decodeSingularMessageField(value: &_storage._lazyChild) }() + case 5: try { try decoder.decodeSingularMessageField(value: &_storage._eagerChild) }() + default: break + } + } + } + } + + func traverse(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._child { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._payload { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + if !_storage._repeatedChild.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedChild, fieldNumber: 3) + } + try { if let v = _storage._lazyChild { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._eagerChild { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_NestedTestAllTypes, rhs: Proto2Unittest_NestedTestAllTypes) -> 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._child != rhs_storage._child {return false} + if _storage._payload != rhs_storage._payload {return false} + if _storage._repeatedChild != rhs_storage._repeatedChild {return false} + if _storage._lazyChild != rhs_storage._lazyChild {return false} + if _storage._eagerChild != rhs_storage._eagerChild {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestDeprecatedFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestDeprecatedFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}deprecated_int32\0\u{3}deprecated_int32_in_oneof\0\u{3}deprecated_message\0\u{3}deprecated_repeated_string\0\u{1}nested\0") + + fileprivate class _StorageClass { + var _deprecatedInt32: Int32? = nil + var _deprecatedRepeatedString: [String] = [] + var _deprecatedMessage: Proto2Unittest_TestAllTypes.NestedMessage? = nil + var _oneofFields: Proto2Unittest_TestDeprecatedFields.OneOf_OneofFields? + var _nested: Proto2Unittest_TestDeprecatedFields? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _deprecatedInt32 = source._deprecatedInt32 + _deprecatedRepeatedString = source._deprecatedRepeatedString + _deprecatedMessage = source._deprecatedMessage + _oneofFields = source._oneofFields + _nested = source._nested + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._deprecatedInt32) }() + case 2: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if _storage._oneofFields != nil {try decoder.handleConflictingOneOf()} + _storage._oneofFields = .deprecatedInt32InOneof(v) + } + }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._deprecatedMessage) }() + case 4: try { try decoder.decodeRepeatedStringField(value: &_storage._deprecatedRepeatedString) }() + case 5: try { try decoder.decodeSingularMessageField(value: &_storage._nested) }() + default: break + } + } + } + } + + func traverse(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._deprecatedInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if case .deprecatedInt32InOneof(let v)? = _storage._oneofFields { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._deprecatedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + if !_storage._deprecatedRepeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._deprecatedRepeatedString, fieldNumber: 4) + } + try { if let v = _storage._nested { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestDeprecatedFields, rhs: Proto2Unittest_TestDeprecatedFields) -> 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._deprecatedInt32 != rhs_storage._deprecatedInt32 {return false} + if _storage._deprecatedRepeatedString != rhs_storage._deprecatedRepeatedString {return false} + if _storage._deprecatedMessage != rhs_storage._deprecatedMessage {return false} + if _storage._oneofFields != rhs_storage._oneofFields {return false} + if _storage._nested != rhs_storage._nested {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestDeprecatedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestDeprecatedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestDeprecatedMessage, rhs: Proto2Unittest_TestDeprecatedMessage) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0\u{1}d\0") + + 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._c) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._d) }() + 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 + try { if let v = self._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._d { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_ForeignMessage, rhs: Proto2Unittest_ForeignMessage) -> Bool { + if lhs._c != rhs._c {return false} + if lhs._d != rhs._d {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestReservedFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestReservedFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{b}bar\0\u{b}baz\0\u{c}\u{2}\u{1}\u{c}\u{f}\u{1}\u{c}\u{9}\u{3}") + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestReservedFields, rhs: Proto2Unittest_TestReservedFields) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestAllExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestAllExtensions.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestAllExtensions, rhs: Proto2Unittest_TestAllExtensions) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_OptionalGroup_extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OptionalGroup_extension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{11}a\0") + + 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_OptionalGroup_extension, rhs: Proto2Unittest_OptionalGroup_extension) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_RepeatedGroup_extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".RepeatedGroup_extension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}/a\0") + + 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 47: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_RepeatedGroup_extension, rhs: Proto2Unittest_RepeatedGroup_extension) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMixedFieldsAndExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMixedFieldsAndExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{2}\u{2}b\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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._a) }() + case 3: try { try decoder.decodeRepeatedFixed32Field(value: &self.b) }() + case 2, 4: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestMixedFieldsAndExtensions.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2, end: 3) + if !self.b.isEmpty { + try visitor.visitRepeatedFixed32Field(value: self.b, fieldNumber: 3) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 4, end: 5) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMixedFieldsAndExtensions, rhs: Proto2Unittest_TestMixedFieldsAndExtensions) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.b != rhs.b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TestGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{8}\u{10}OptionalGroup\0\u{4}\u{6}optional_foreign_enum\0") + + 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 16: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() + case 22: try { try decoder.decodeSingularEnumField(value: &self._optionalForeignEnum) }() + 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 + try { if let v = self._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 16) + } }() + try { if let v = self._optionalForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestGroup, rhs: Proto2Unittest_TestGroup) -> Bool { + if lhs._optionalGroup != rhs._optionalGroup {return false} + if lhs._optionalForeignEnum != rhs._optionalForeignEnum {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestGroup.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestGroup.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{11}a\0\u{2}H\u{1}zz\0") + + 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + case 89: try { try decoder.decodeSingularInt32Field(value: &self._zz) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) + } }() + try { if let v = self._zz { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 89) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestGroup.OptionalGroup, rhs: Proto2Unittest_TestGroup.OptionalGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._zz != rhs._zz {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestGroupExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestGroupExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestGroupExtension.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestGroupExtension, rhs: Proto2Unittest_TestGroupExtension) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TestNestedExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestNestedExtension, rhs: Proto2Unittest_TestNestedExtension) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestNestedExtension.OptionalGroup_extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestNestedExtension.protoMessageName + ".OptionalGroup_extension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{11}a\0") + + 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestNestedExtension.OptionalGroup_extension, rhs: Proto2Unittest_TestNestedExtension.OptionalGroup_extension) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestChildExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestChildExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0\u{3}optional_extension\0") + + public var isInitialized: Bool { + if let v = self._optionalExtension, !v.isInitialized {return false} + return true + } + + 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._a) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._b) }() + case 3: try { try decoder.decodeSingularMessageField(value: &self._optionalExtension) }() + 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 + try { if let v = self._a { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalExtension { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestChildExtension, rhs: Proto2Unittest_TestChildExtension) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs._optionalExtension != rhs._optionalExtension {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestChildExtensionData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestChildExtensionData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0\u{3}optional_extension\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._b) }() + case 3: try { try decoder.decodeSingularMessageField(value: &self._optionalExtension) }() + 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 + try { if let v = self._a { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalExtension { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestChildExtensionData, rhs: Proto2Unittest_TestChildExtensionData) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs._optionalExtension != rhs._optionalExtension {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestChildExtensionData.NestedTestAllExtensionsData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestChildExtensionData.protoMessageName + ".NestedTestAllExtensionsData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}@HzZ\u{18}dynamic\0") + + 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 409707008: try { try decoder.decodeSingularMessageField(value: &self._dynamic) }() + 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 + try { if let v = self._dynamic { + try visitor.visitSingularMessageField(value: v, fieldNumber: 409707008) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestChildExtensionData.NestedTestAllExtensionsData, rhs: Proto2Unittest_TestChildExtensionData.NestedTestAllExtensionsData) -> Bool { + if lhs._dynamic != rhs._dynamic {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestChildExtensionData.NestedTestAllExtensionsData.NestedDynamicExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestChildExtensionData.NestedTestAllExtensionsData.protoMessageName + ".NestedDynamicExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestChildExtensionData.NestedTestAllExtensionsData.NestedDynamicExtensions, rhs: Proto2Unittest_TestChildExtensionData.NestedTestAllExtensionsData.NestedDynamicExtensions) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestNestedChildExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedChildExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}child\0") + + public var isInitialized: Bool { + if let v = self._child, !v.isInitialized {return false} + return true + } + + 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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._child) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._child { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestNestedChildExtension, rhs: Proto2Unittest_TestNestedChildExtension) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._child != rhs._child {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestNestedChildExtensionData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedChildExtensionData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}child\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._child) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._child { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestNestedChildExtensionData, rhs: Proto2Unittest_TestNestedChildExtensionData) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._child != rhs._child {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestRequiredEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredEnum" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_enum\0\u{1}a\0") + + public var isInitialized: Bool { + if self._requiredEnum == nil {return false} + return true + } + + 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._requiredEnum) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._requiredEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestRequiredEnum, rhs: Proto2Unittest_TestRequiredEnum) -> Bool { + if lhs._requiredEnum != rhs._requiredEnum {return false} + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestRequiredOpenEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredOpenEnum" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_enum\0\u{1}a\0") + + public var isInitialized: Bool { + if self._requiredEnum == nil {return false} + return true + } + + 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._requiredEnum) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._requiredEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestRequiredOpenEnum, rhs: Proto2Unittest_TestRequiredOpenEnum) -> Bool { + if lhs._requiredEnum != rhs._requiredEnum {return false} + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestRequiredEnumNoMask: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredEnumNoMask" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_enum\0\u{1}a\0") + + public var isInitialized: Bool { + if self._requiredEnum == nil {return false} + return true + } + + 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._requiredEnum) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._requiredEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestRequiredEnumNoMask, rhs: Proto2Unittest_TestRequiredEnumNoMask) -> Bool { + if lhs._requiredEnum != rhs._requiredEnum {return false} + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestRequiredEnumNoMask.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}BAZ\0\u{1}UNSPECIFIED\0\u{2}\u{2}FOO\0\u{2}b\u{1}BAR\0") +} + +extension Proto2Unittest_TestRequiredEnumMulti: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredEnumMulti" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_enum_1\0\u{3}required_enum_2\0\u{3}a_3\0\u{3}required_enum_4\0") + + public var isInitialized: Bool { + if self._requiredEnum4 == nil {return false} + if self._requiredEnum2 == nil {return false} + if self._requiredEnum1 == nil {return false} + return true + } + + 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._requiredEnum1) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self._requiredEnum2) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._a3) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._requiredEnum4) }() + 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 + try { if let v = self._requiredEnum1 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = self._requiredEnum2 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) + } }() + try { if let v = self._a3 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._requiredEnum4 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestRequiredEnumMulti, rhs: Proto2Unittest_TestRequiredEnumMulti) -> Bool { + if lhs._requiredEnum4 != rhs._requiredEnum4 {return false} + if lhs._a3 != rhs._a3 {return false} + if lhs._requiredEnum2 != rhs._requiredEnum2 {return false} + if lhs._requiredEnum1 != rhs._requiredEnum1 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestRequiredEnumMulti.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNSPECIFIED\0\u{1}FOO\0\u{1}BAR\0\u{2}b\u{1}BAZ\0") +} + +extension Proto2Unittest_TestRequiredNoMaskMulti: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredNoMaskMulti" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_enum_1\0\u{3}required_enum_2\0\u{3}a_3\0\u{3}required_enum_4\0\u{4}(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._requiredEnum1) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self._requiredEnum2) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._a3) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._requiredEnum4) }() + case 64: try { try decoder.decodeSingularEnumField(value: &self._requiredEnum64) }() + case 70: try { try decoder.decodeSingularFixed32Field(value: &self._requiredFixed3270) }() + case 80: try { try decoder.decodeSingularFixed32Field(value: &self._requiredFixed3280) }() + 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 + try { if let v = self._requiredEnum1 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = self._requiredEnum2 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) + } }() + try { if let v = self._a3 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._requiredEnum4 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + try { if let v = self._requiredEnum64 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 64) + } }() + try { if let v = self._requiredFixed3270 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 70) + } }() + try { if let v = self._requiredFixed3280 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 80) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestRequiredNoMaskMulti, rhs: Proto2Unittest_TestRequiredNoMaskMulti) -> Bool { + if lhs._requiredFixed3280 != rhs._requiredFixed3280 {return false} + if lhs._requiredFixed3270 != rhs._requiredFixed3270 {return false} + if lhs._requiredEnum64 != rhs._requiredEnum64 {return false} + if lhs._requiredEnum4 != rhs._requiredEnum4 {return false} + if lhs._a3 != rhs._a3 {return false} + if lhs._requiredEnum2 != rhs._requiredEnum2 {return false} + if lhs._requiredEnum1 != rhs._requiredEnum1 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestRequiredNoMaskMulti.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNSPECIFIED\0\u{1}FOO\0\u{1}BAR\0\u{2}b\u{1}BAZ\0") +} + +extension Proto2Unittest_TestRequired: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequired" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}dummy2\0\u{1}b\0\u{1}dummy4\0\u{1}dummy5\0\u{1}dummy6\0\u{1}dummy7\0\u{1}dummy8\0\u{1}dummy9\0\u{1}dummy10\0\u{1}dummy11\0\u{1}dummy12\0\u{1}dummy13\0\u{1}dummy14\0\u{1}dummy15\0\u{1}dummy16\0\u{1}dummy17\0\u{1}dummy18\0\u{1}dummy19\0\u{1}dummy20\0\u{1}dummy21\0\u{1}dummy22\0\u{1}dummy23\0\u{1}dummy24\0\u{1}dummy25\0\u{1}dummy26\0\u{1}dummy27\0\u{1}dummy28\0\u{1}dummy29\0\u{1}dummy30\0\u{1}dummy31\0\u{1}dummy32\0\u{1}c\0\u{3}optional_foreign\0\u{3}map_field\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _dummy2: Int32? = nil + var _b: Int32? = nil + var _dummy4: Int32? = nil + var _dummy5: Int32? = nil + var _dummy6: Int32? = nil + var _dummy7: Int32? = nil + var _dummy8: Int32? = nil + var _dummy9: Int32? = nil + var _dummy10: Int32? = nil + var _dummy11: Int32? = nil + var _dummy12: Int32? = nil + var _dummy13: Int32? = nil + var _dummy14: Int32? = nil + var _dummy15: Int32? = nil + var _dummy16: Int32? = nil + var _dummy17: Int32? = nil + var _dummy18: Int32? = nil + var _dummy19: Int32? = nil + var _dummy20: Int32? = nil + var _dummy21: Int32? = nil + var _dummy22: Int32? = nil + var _dummy23: Int32? = nil + var _dummy24: Int32? = nil + var _dummy25: Int32? = nil + var _dummy26: Int32? = nil + var _dummy27: Int32? = nil + var _dummy28: Int32? = nil + var _dummy29: Int32? = nil + var _dummy30: Int32? = nil + var _dummy31: Int32? = nil + var _dummy32: Int32? = nil + var _c: Int32? = nil + var _optionalForeign: Proto2Unittest_ForeignMessage? = nil + var _mapField: Dictionary = [:] + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _dummy2 = source._dummy2 + _b = source._b + _dummy4 = source._dummy4 + _dummy5 = source._dummy5 + _dummy6 = source._dummy6 + _dummy7 = source._dummy7 + _dummy8 = source._dummy8 + _dummy9 = source._dummy9 + _dummy10 = source._dummy10 + _dummy11 = source._dummy11 + _dummy12 = source._dummy12 + _dummy13 = source._dummy13 + _dummy14 = source._dummy14 + _dummy15 = source._dummy15 + _dummy16 = source._dummy16 + _dummy17 = source._dummy17 + _dummy18 = source._dummy18 + _dummy19 = source._dummy19 + _dummy20 = source._dummy20 + _dummy21 = source._dummy21 + _dummy22 = source._dummy22 + _dummy23 = source._dummy23 + _dummy24 = source._dummy24 + _dummy25 = source._dummy25 + _dummy26 = source._dummy26 + _dummy27 = source._dummy27 + _dummy28 = source._dummy28 + _dummy29 = source._dummy29 + _dummy30 = source._dummy30 + _dummy31 = source._dummy31 + _dummy32 = source._dummy32 + _c = source._c + _optionalForeign = source._optionalForeign + _mapField = source._mapField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._a == nil {return false} + if _storage._b == nil {return false} + if _storage._c == nil {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._mapField) {return false} + return true + } + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy2) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &_storage._b) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy4) }() + case 5: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy5) }() + case 6: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy6) }() + case 7: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy7) }() + case 8: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy8) }() + case 9: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy9) }() + case 10: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy10) }() + case 11: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy11) }() + case 12: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy12) }() + case 13: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy13) }() + case 14: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy14) }() + case 15: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy15) }() + case 16: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy16) }() + case 17: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy17) }() + case 18: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy18) }() + case 19: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy19) }() + case 20: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy20) }() + case 21: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy21) }() + case 22: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy22) }() + case 23: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy23) }() + case 24: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy24) }() + case 25: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy25) }() + case 26: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy26) }() + case 27: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy27) }() + case 28: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy28) }() + case 29: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy29) }() + case 30: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy30) }() + case 31: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy31) }() + case 32: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy32) }() + case 33: try { try decoder.decodeSingularInt32Field(value: &_storage._c) }() + case 34: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeign) }() + case 35: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapField) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._dummy2 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._dummy4 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._dummy5 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._dummy6 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._dummy7 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._dummy8 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._dummy9 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._dummy10 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._dummy11 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._dummy12 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._dummy13 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._dummy14 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._dummy15 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._dummy16 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._dummy17 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) + } }() + try { if let v = _storage._dummy18 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._dummy19 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._dummy20 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 20) + } }() + try { if let v = _storage._dummy21 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._dummy22 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._dummy23 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 23) + } }() + try { if let v = _storage._dummy24 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._dummy25 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._dummy26 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 26) + } }() + try { if let v = _storage._dummy27 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 27) + } }() + try { if let v = _storage._dummy28 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 28) + } }() + try { if let v = _storage._dummy29 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 29) + } }() + try { if let v = _storage._dummy30 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 30) + } }() + try { if let v = _storage._dummy31 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 31) + } }() + try { if let v = _storage._dummy32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 32) + } }() + try { if let v = _storage._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 33) + } }() + try { if let v = _storage._optionalForeign { + try visitor.visitSingularMessageField(value: v, fieldNumber: 34) + } }() + if !_storage._mapField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapField, fieldNumber: 35) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestRequired, rhs: Proto2Unittest_TestRequired) -> 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._a != rhs_storage._a {return false} + if _storage._dummy2 != rhs_storage._dummy2 {return false} + if _storage._b != rhs_storage._b {return false} + if _storage._dummy4 != rhs_storage._dummy4 {return false} + if _storage._dummy5 != rhs_storage._dummy5 {return false} + if _storage._dummy6 != rhs_storage._dummy6 {return false} + if _storage._dummy7 != rhs_storage._dummy7 {return false} + if _storage._dummy8 != rhs_storage._dummy8 {return false} + if _storage._dummy9 != rhs_storage._dummy9 {return false} + if _storage._dummy10 != rhs_storage._dummy10 {return false} + if _storage._dummy11 != rhs_storage._dummy11 {return false} + if _storage._dummy12 != rhs_storage._dummy12 {return false} + if _storage._dummy13 != rhs_storage._dummy13 {return false} + if _storage._dummy14 != rhs_storage._dummy14 {return false} + if _storage._dummy15 != rhs_storage._dummy15 {return false} + if _storage._dummy16 != rhs_storage._dummy16 {return false} + if _storage._dummy17 != rhs_storage._dummy17 {return false} + if _storage._dummy18 != rhs_storage._dummy18 {return false} + if _storage._dummy19 != rhs_storage._dummy19 {return false} + if _storage._dummy20 != rhs_storage._dummy20 {return false} + if _storage._dummy21 != rhs_storage._dummy21 {return false} + if _storage._dummy22 != rhs_storage._dummy22 {return false} + if _storage._dummy23 != rhs_storage._dummy23 {return false} + if _storage._dummy24 != rhs_storage._dummy24 {return false} + if _storage._dummy25 != rhs_storage._dummy25 {return false} + if _storage._dummy26 != rhs_storage._dummy26 {return false} + if _storage._dummy27 != rhs_storage._dummy27 {return false} + if _storage._dummy28 != rhs_storage._dummy28 {return false} + if _storage._dummy29 != rhs_storage._dummy29 {return false} + if _storage._dummy30 != rhs_storage._dummy30 {return false} + if _storage._dummy31 != rhs_storage._dummy31 {return false} + if _storage._dummy32 != rhs_storage._dummy32 {return false} + if _storage._c != rhs_storage._c {return false} + if _storage._optionalForeign != rhs_storage._optionalForeign {return false} + if _storage._mapField != rhs_storage._mapField {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestRequiredForeign: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredForeign" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_message\0\u{3}repeated_message\0\u{1}dummy\0\u{3}optional_lazy_message\0") + + public var isInitialized: Bool { + if let v = self._optionalMessage, !v.isInitialized {return false} + if !SwiftProtobuf.Internal.areAllInitialized(self.repeatedMessage) {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._optionalMessage) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedMessage) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._dummy) }() + case 4: try { try decoder.decodeSingularMessageField(value: &self._optionalLazyMessage) }() + 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 + try { if let v = self._optionalMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + if !self.repeatedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedMessage, fieldNumber: 2) + } + try { if let v = self._dummy { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._optionalLazyMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestRequiredForeign, rhs: Proto2Unittest_TestRequiredForeign) -> Bool { + if lhs._optionalMessage != rhs._optionalMessage {return false} + if lhs.repeatedMessage != rhs.repeatedMessage {return false} + if lhs._dummy != rhs._dummy {return false} + if lhs._optionalLazyMessage != rhs._optionalLazyMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestRequiredMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_message\0\u{3}repeated_message\0\u{3}required_message\0") + + public var isInitialized: Bool { + if self._requiredMessage == nil {return false} + if let v = self._optionalMessage, !v.isInitialized {return false} + if !SwiftProtobuf.Internal.areAllInitialized(self.repeatedMessage) {return false} + if let v = self._requiredMessage, !v.isInitialized {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._optionalMessage) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedMessage) }() + case 3: try { try decoder.decodeSingularMessageField(value: &self._requiredMessage) }() + 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 + try { if let v = self._optionalMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + if !self.repeatedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedMessage, fieldNumber: 2) + } + try { if let v = self._requiredMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestRequiredMessage, rhs: Proto2Unittest_TestRequiredMessage) -> Bool { + if lhs._optionalMessage != rhs._optionalMessage {return false} + if lhs.repeatedMessage != rhs.repeatedMessage {return false} + if lhs._requiredMessage != rhs._requiredMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestRequiredLazyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredLazyMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}child\0\u{1}recurse\0") + + fileprivate class _StorageClass { + var _child: Proto2Unittest_TestRequired? = nil + var _recurse: Proto2Unittest_TestRequiredLazyMessage? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _child = source._child + _recurse = source._recurse + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._child, !v.isInitialized {return false} + if let v = _storage._recurse, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._child) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._recurse) }() + default: break + } + } + } + } + + func traverse(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._child { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._recurse { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestRequiredLazyMessage, rhs: Proto2Unittest_TestRequiredLazyMessage) -> 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._child != rhs_storage._child {return false} + if _storage._recurse != rhs_storage._recurse {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestNestedRequiredForeign: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedRequiredForeign" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}child\0\u{1}payload\0\u{1}dummy\0\u{4}\u{2}required_enum\0\u{3}required_enum_no_mask\0\u{3}required_enum_multi\0\u{4}\u{2}required_no_mask\0") + + fileprivate class _StorageClass { + var _child: Proto2Unittest_TestNestedRequiredForeign? = nil + var _payload: Proto2Unittest_TestRequiredForeign? = nil + var _dummy: Int32? = nil + var _requiredEnum: Proto2Unittest_TestRequiredEnum? = nil + var _requiredEnumNoMask: Proto2Unittest_TestRequiredEnumNoMask? = nil + var _requiredEnumMulti: Proto2Unittest_TestRequiredEnumMulti? = nil + var _requiredNoMask: Proto2Unittest_TestRequiredNoMaskMulti? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _child = source._child + _payload = source._payload + _dummy = source._dummy + _requiredEnum = source._requiredEnum + _requiredEnumNoMask = source._requiredEnumNoMask + _requiredEnumMulti = source._requiredEnumMulti + _requiredNoMask = source._requiredNoMask + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._child, !v.isInitialized {return false} + if let v = _storage._payload, !v.isInitialized {return false} + if let v = _storage._requiredEnum, !v.isInitialized {return false} + if let v = _storage._requiredEnumNoMask, !v.isInitialized {return false} + if let v = _storage._requiredEnumMulti, !v.isInitialized {return false} + if let v = _storage._requiredNoMask, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._child) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._payload) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy) }() + case 5: try { try decoder.decodeSingularMessageField(value: &_storage._requiredEnum) }() + case 6: try { try decoder.decodeSingularMessageField(value: &_storage._requiredEnumNoMask) }() + case 7: try { try decoder.decodeSingularMessageField(value: &_storage._requiredEnumMulti) }() + case 9: try { try decoder.decodeSingularMessageField(value: &_storage._requiredNoMask) }() + default: break + } + } + } + } + + func traverse(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._child { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._payload { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._dummy { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._requiredEnum { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._requiredEnumNoMask { + try visitor.visitSingularMessageField(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._requiredEnumMulti { + try visitor.visitSingularMessageField(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._requiredNoMask { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestNestedRequiredForeign, rhs: Proto2Unittest_TestNestedRequiredForeign) -> 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._child != rhs_storage._child {return false} + if _storage._payload != rhs_storage._payload {return false} + if _storage._dummy != rhs_storage._dummy {return false} + if _storage._requiredEnum != rhs_storage._requiredEnum {return false} + if _storage._requiredEnumNoMask != rhs_storage._requiredEnumNoMask {return false} + if _storage._requiredEnumMulti != rhs_storage._requiredEnumMulti {return false} + if _storage._requiredNoMask != rhs_storage._requiredNoMask {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestForeignNested: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestForeignNested" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}foreign_nested\0") + + 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.decodeSingularMessageField(value: &self._foreignNested) }() + 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 + try { if let v = self._foreignNested { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestForeignNested, rhs: Proto2Unittest_TestForeignNested) -> Bool { + if lhs._foreignNested != rhs._foreignNested {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestEmptyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEmptyMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestEmptyMessage, rhs: Proto2Unittest_TestEmptyMessage) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestEmptyMessageWithExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEmptyMessageWithExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestEmptyMessageWithExtensions.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestEmptyMessageWithExtensions, rhs: Proto2Unittest_TestEmptyMessageWithExtensions) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TestPickleNestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestPickleNestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestPickleNestedMessage, rhs: Proto2Unittest_TestPickleNestedMessage) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestPickleNestedMessage.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestPickleNestedMessage.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") + + 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._bb) }() + 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 + try { if let v = self._bb { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestPickleNestedMessage.NestedMessage, rhs: Proto2Unittest_TestPickleNestedMessage.NestedMessage) -> Bool { + if lhs._bb != rhs._bb {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestPickleNestedMessage.NestedMessage.protoMessageName + ".NestedNestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}cc\0") + + 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._cc) }() + 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 + try { if let v = self._cc { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage, rhs: Proto2Unittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage) -> Bool { + if lhs._cc != rhs._cc {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMultipleExtensionRanges: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMultipleExtensionRanges" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (42 == fieldNumber) || (4143 <= fieldNumber && fieldNumber < 4244) || (65536 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestMultipleExtensionRanges.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 42, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMultipleExtensionRanges, rhs: Proto2Unittest_TestMultipleExtensionRanges) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TestReallyLargeTagNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestReallyLargeTagNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{2}~\u{7f}\u{7f}\u{7f}\u{f}bb\0") + + 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._a) }() + case 268435455: try { try decoder.decodeSingularInt32Field(value: &self._bb) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._bb { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 268435455) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestReallyLargeTagNumber, rhs: Proto2Unittest_TestReallyLargeTagNumber) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._bb != rhs._bb {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestRecursiveMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRecursiveMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}i\0") + + fileprivate class _StorageClass { + var _a: Proto2Unittest_TestRecursiveMessage? = nil + var _i: Int32? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _i = source._i + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._i) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestRecursiveMessage, rhs: Proto2Unittest_TestRecursiveMessage) -> 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._a != rhs_storage._a {return false} + if _storage._i != rhs_storage._i {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMutualRecursionA: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMutualRecursionA" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0\u{7}SubGroup\0\u{8}\u{3}SubGroupR\0") + + fileprivate class _StorageClass { + var _bb: Proto2Unittest_TestMutualRecursionB? = nil + var _subGroup: Proto2Unittest_TestMutualRecursionA.SubGroup? = nil + var _subGroupR: [Proto2Unittest_TestMutualRecursionA.SubGroupR] = [] + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _bb = source._bb + _subGroup = source._subGroup + _subGroupR = source._subGroupR + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._bb) }() + case 2: try { try decoder.decodeSingularGroupField(value: &_storage._subGroup) }() + case 5: try { try decoder.decodeRepeatedGroupField(value: &_storage._subGroupR) }() + default: break + } + } + } + } + + func traverse(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._bb { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._subGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 2) + } }() + if !_storage._subGroupR.isEmpty { + try visitor.visitRepeatedGroupField(value: _storage._subGroupR, fieldNumber: 5) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMutualRecursionA, rhs: Proto2Unittest_TestMutualRecursionA) -> 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._bb != rhs_storage._bb {return false} + if _storage._subGroup != rhs_storage._subGroup {return false} + if _storage._subGroupR != rhs_storage._subGroupR {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMutualRecursionA.SubMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestMutualRecursionA.protoMessageName + ".SubMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}b\0") + + fileprivate class _StorageClass { + var _b: Proto2Unittest_TestMutualRecursionB? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _b = source._b + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._b) }() + default: break + } + } + } + } + + func traverse(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._b { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMutualRecursionA.SubMessage, rhs: Proto2Unittest_TestMutualRecursionA.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._b != rhs_storage._b {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMutualRecursionA.SubGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestMutualRecursionA.protoMessageName + ".SubGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{3}sub_message\0\u{3}not_in_this_scc\0") + + fileprivate class _StorageClass { + var _subMessage: Proto2Unittest_TestMutualRecursionA.SubMessage? = nil + var _notInThisScc: Proto2Unittest_TestAllTypes? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _subMessage = source._subMessage + _notInThisScc = source._notInThisScc + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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 3: try { try decoder.decodeSingularMessageField(value: &_storage._subMessage) }() + case 4: try { try decoder.decodeSingularMessageField(value: &_storage._notInThisScc) }() + default: break + } + } + } + } + + func traverse(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._subMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._notInThisScc { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMutualRecursionA.SubGroup, rhs: Proto2Unittest_TestMutualRecursionA.SubGroup) -> 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._subMessage != rhs_storage._subMessage {return false} + if _storage._notInThisScc != rhs_storage._notInThisScc {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMutualRecursionA.SubGroupR: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestMutualRecursionA.protoMessageName + ".SubGroupR" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{6}payload\0") + + 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 6: try { try decoder.decodeSingularMessageField(value: &self._payload) }() + 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 + try { if let v = self._payload { + try visitor.visitSingularMessageField(value: v, fieldNumber: 6) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMutualRecursionA.SubGroupR, rhs: Proto2Unittest_TestMutualRecursionA.SubGroupR) -> Bool { + if lhs._payload != rhs._payload {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMutualRecursionB: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMutualRecursionB" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{3}optional_int32\0") + + fileprivate class _StorageClass { + var _a: Proto2Unittest_TestMutualRecursionA? = nil + var _optionalInt32: Int32? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _optionalInt32 = source._optionalInt32 + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalInt32) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMutualRecursionB, rhs: Proto2Unittest_TestMutualRecursionB) -> 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._a != rhs_storage._a {return false} + if _storage._optionalInt32 != rhs_storage._optionalInt32 {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestIsInitialized: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestIsInitialized" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}sub_message\0") + + public var isInitialized: Bool { + if let v = self._subMessage, !v.isInitialized {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._subMessage) }() + 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 + try { if let v = self._subMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestIsInitialized, rhs: Proto2Unittest_TestIsInitialized) -> Bool { + if lhs._subMessage != rhs._subMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestIsInitialized.SubMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestIsInitialized.protoMessageName + ".SubMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{7}SubGroup\0") + + public var isInitialized: Bool { + if let v = self._subGroup, !v.isInitialized {return false} + return true + } + + 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.decodeSingularGroupField(value: &self._subGroup) }() + 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 + try { if let v = self._subGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestIsInitialized.SubMessage, rhs: Proto2Unittest_TestIsInitialized.SubMessage) -> Bool { + if lhs._subGroup != rhs._subGroup {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestIsInitialized.SubMessage.SubGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestIsInitialized.SubMessage.protoMessageName + ".SubGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{2}i\0") + + public var isInitialized: Bool { + if self._i == nil {return false} + return true + } + + 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 2: try { try decoder.decodeSingularInt32Field(value: &self._i) }() + 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 + try { if let v = self._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestIsInitialized.SubMessage.SubGroup, rhs: Proto2Unittest_TestIsInitialized.SubMessage.SubGroup) -> Bool { + if lhs._i != rhs._i {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestDupFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestDupFieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{7}Foo\0\u{7}Bar\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularGroupField(value: &self._foo) }() + case 3: try { try decoder.decodeSingularGroupField(value: &self._bar) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._foo { + try visitor.visitSingularGroupField(value: v, fieldNumber: 2) + } }() + try { if let v = self._bar { + try visitor.visitSingularGroupField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestDupFieldNumber, rhs: Proto2Unittest_TestDupFieldNumber) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._foo != rhs._foo {return false} + if lhs._bar != rhs._bar {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestDupFieldNumber.Foo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestDupFieldNumber.protoMessageName + ".Foo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") + + 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._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestDupFieldNumber.Foo, rhs: Proto2Unittest_TestDupFieldNumber.Foo) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestDupFieldNumber.Bar: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestDupFieldNumber.protoMessageName + ".Bar" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") + + 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._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestDupFieldNumber.Bar, rhs: Proto2Unittest_TestDupFieldNumber.Bar) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestEagerMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEagerMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}sub_message\0") + + 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.decodeSingularMessageField(value: &self._subMessage) }() + 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 + try { if let v = self._subMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestEagerMessage, rhs: Proto2Unittest_TestEagerMessage) -> Bool { + if lhs._subMessage != rhs._subMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestLazyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestLazyMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}sub_message\0") + + 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.decodeSingularMessageField(value: &self._subMessage) }() + 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 + try { if let v = self._subMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestLazyMessage, rhs: Proto2Unittest_TestLazyMessage) -> Bool { + if lhs._subMessage != rhs._subMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestLazyRequiredEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestLazyRequiredEnum" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_required_open_enum\0\u{3}optional_required_enum\0\u{3}optional_required_enum_no_mask\0\u{3}optional_required_enum_multi\0\u{3}optional_required_no_mask\0") + + fileprivate class _StorageClass { + var _optionalRequiredOpenEnum: Proto2Unittest_TestRequiredOpenEnum? = nil + var _optionalRequiredEnum: Proto2Unittest_TestRequiredEnum? = nil + var _optionalRequiredEnumNoMask: Proto2Unittest_TestRequiredEnumNoMask? = nil + var _optionalRequiredEnumMulti: Proto2Unittest_TestRequiredEnumMulti? = nil + var _optionalRequiredNoMask: Proto2Unittest_TestRequiredNoMaskMulti? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalRequiredOpenEnum = source._optionalRequiredOpenEnum + _optionalRequiredEnum = source._optionalRequiredEnum + _optionalRequiredEnumNoMask = source._optionalRequiredEnumNoMask + _optionalRequiredEnumMulti = source._optionalRequiredEnumMulti + _optionalRequiredNoMask = source._optionalRequiredNoMask + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._optionalRequiredOpenEnum, !v.isInitialized {return false} + if let v = _storage._optionalRequiredEnum, !v.isInitialized {return false} + if let v = _storage._optionalRequiredEnumNoMask, !v.isInitialized {return false} + if let v = _storage._optionalRequiredEnumMulti, !v.isInitialized {return false} + if let v = _storage._optionalRequiredNoMask, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._optionalRequiredOpenEnum) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._optionalRequiredEnum) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._optionalRequiredEnumNoMask) }() + case 4: try { try decoder.decodeSingularMessageField(value: &_storage._optionalRequiredEnumMulti) }() + case 5: try { try decoder.decodeSingularMessageField(value: &_storage._optionalRequiredNoMask) }() + default: break + } + } + } + } + + func traverse(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._optionalRequiredOpenEnum { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._optionalRequiredEnum { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalRequiredEnumNoMask { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._optionalRequiredEnumMulti { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._optionalRequiredNoMask { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestLazyRequiredEnum, rhs: Proto2Unittest_TestLazyRequiredEnum) -> 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._optionalRequiredOpenEnum != rhs_storage._optionalRequiredOpenEnum {return false} + if _storage._optionalRequiredEnum != rhs_storage._optionalRequiredEnum {return false} + if _storage._optionalRequiredEnumNoMask != rhs_storage._optionalRequiredEnumNoMask {return false} + if _storage._optionalRequiredEnumMulti != rhs_storage._optionalRequiredEnumMulti {return false} + if _storage._optionalRequiredNoMask != rhs_storage._optionalRequiredNoMask {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestLazyMessageRepeated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestLazyMessageRepeated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}repeated_message\0") + + 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.decodeRepeatedMessageField(value: &self.repeatedMessage) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.repeatedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedMessage, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestLazyMessageRepeated, rhs: Proto2Unittest_TestLazyMessageRepeated) -> Bool { + if lhs.repeatedMessage != rhs.repeatedMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestEagerMaybeLazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEagerMaybeLazy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}message_foo\0\u{3}message_bar\0\u{3}message_baz\0") + + 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.decodeSingularMessageField(value: &self._messageFoo) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._messageBar) }() + case 3: try { try decoder.decodeSingularMessageField(value: &self._messageBaz) }() + 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 + try { if let v = self._messageFoo { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = self._messageBar { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = self._messageBaz { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestEagerMaybeLazy, rhs: Proto2Unittest_TestEagerMaybeLazy) -> Bool { + if lhs._messageFoo != rhs._messageFoo {return false} + if lhs._messageBar != rhs._messageBar {return false} + if lhs._messageBaz != rhs._messageBaz {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestEagerMaybeLazy.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestEagerMaybeLazy.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}packed\0") + + 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.decodeSingularMessageField(value: &self._packed) }() + 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 + try { if let v = self._packed { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestEagerMaybeLazy.NestedMessage, rhs: Proto2Unittest_TestEagerMaybeLazy.NestedMessage) -> Bool { + if lhs._packed != rhs._packed {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestNestedMessageHasBits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedMessageHasBits" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_nested_message\0") + + 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.decodeSingularMessageField(value: &self._optionalNestedMessage) }() + 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 + try { if let v = self._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestNestedMessageHasBits, rhs: Proto2Unittest_TestNestedMessageHasBits) -> Bool { + if lhs._optionalNestedMessage != rhs._optionalNestedMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestNestedMessageHasBits.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestNestedMessageHasBits.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}nestedmessage_repeated_int32\0\u{3}nestedmessage_repeated_foreignmessage\0") + + 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.decodeRepeatedInt32Field(value: &self.nestedmessageRepeatedInt32) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.nestedmessageRepeatedForeignmessage) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.nestedmessageRepeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.nestedmessageRepeatedInt32, fieldNumber: 1) + } + if !self.nestedmessageRepeatedForeignmessage.isEmpty { + try visitor.visitRepeatedMessageField(value: self.nestedmessageRepeatedForeignmessage, fieldNumber: 2) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestNestedMessageHasBits.NestedMessage, rhs: Proto2Unittest_TestNestedMessageHasBits.NestedMessage) -> Bool { + if lhs.nestedmessageRepeatedInt32 != rhs.nestedmessageRepeatedInt32 {return false} + if lhs.nestedmessageRepeatedForeignmessage != rhs.nestedmessageRepeatedForeignmessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestCamelCaseFieldNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestCamelCaseFieldNames" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}PrimitiveField\0\u{1}StringField\0\u{1}EnumField\0\u{1}MessageField\0\u{1}StringPieceField\0\u{1}CordField\0\u{1}RepeatedPrimitiveField\0\u{1}RepeatedStringField\0\u{1}RepeatedEnumField\0\u{1}RepeatedMessageField\0\u{1}RepeatedStringPieceField\0\u{1}RepeatedCordField\0") + + 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._primitiveField) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._stringField) }() + case 3: try { try decoder.decodeSingularEnumField(value: &self._enumField) }() + case 4: try { try decoder.decodeSingularMessageField(value: &self._messageField) }() + case 5: try { try decoder.decodeSingularStringField(value: &self._stringPieceField) }() + case 6: try { try decoder.decodeSingularStringField(value: &self._cordField) }() + case 7: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedPrimitiveField) }() + case 8: try { try decoder.decodeRepeatedStringField(value: &self.repeatedStringField) }() + case 9: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedEnumField) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedMessageField) }() + case 11: try { try decoder.decodeRepeatedStringField(value: &self.repeatedStringPieceField) }() + case 12: try { try decoder.decodeRepeatedStringField(value: &self.repeatedCordField) }() + 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 + try { if let v = self._primitiveField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._stringField { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._enumField { + try visitor.visitSingularEnumField(value: v, fieldNumber: 3) + } }() + try { if let v = self._messageField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + try { if let v = self._stringPieceField { + try visitor.visitSingularStringField(value: v, fieldNumber: 5) + } }() + try { if let v = self._cordField { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) + } }() + if !self.repeatedPrimitiveField.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.repeatedPrimitiveField, fieldNumber: 7) + } + if !self.repeatedStringField.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedStringField, fieldNumber: 8) + } + if !self.repeatedEnumField.isEmpty { + try visitor.visitRepeatedEnumField(value: self.repeatedEnumField, fieldNumber: 9) + } + if !self.repeatedMessageField.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedMessageField, fieldNumber: 10) + } + if !self.repeatedStringPieceField.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedStringPieceField, fieldNumber: 11) + } + if !self.repeatedCordField.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedCordField, fieldNumber: 12) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestCamelCaseFieldNames, rhs: Proto2Unittest_TestCamelCaseFieldNames) -> Bool { + if lhs._primitiveField != rhs._primitiveField {return false} + if lhs._stringField != rhs._stringField {return false} + if lhs._enumField != rhs._enumField {return false} + if lhs._messageField != rhs._messageField {return false} + if lhs._stringPieceField != rhs._stringPieceField {return false} + if lhs._cordField != rhs._cordField {return false} + if lhs.repeatedPrimitiveField != rhs.repeatedPrimitiveField {return false} + if lhs.repeatedStringField != rhs.repeatedStringField {return false} + if lhs.repeatedEnumField != rhs.repeatedEnumField {return false} + if lhs.repeatedMessageField != rhs.repeatedMessageField {return false} + if lhs.repeatedStringPieceField != rhs.repeatedStringPieceField {return false} + if lhs.repeatedCordField != rhs.repeatedCordField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestFieldOrderings: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestFieldOrderings" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}my_int\0\u{4}\u{a}my_string\0\u{4}Z\u{1}my_float\0\u{4}c\u{1}optional_nested_message\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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.decodeSingularInt64Field(value: &self._myInt) }() + case 11: try { try decoder.decodeSingularStringField(value: &self._myString) }() + case 101: try { try decoder.decodeSingularFloatField(value: &self._myFloat) }() + case 200: try { try decoder.decodeSingularMessageField(value: &self._optionalNestedMessage) }() + case 2..<11, 12..<101: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestFieldOrderings.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._myInt { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 1) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2, end: 11) + try { if let v = self._myString { + try visitor.visitSingularStringField(value: v, fieldNumber: 11) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 12, end: 101) + try { if let v = self._myFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 101) + } }() + try { if let v = self._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 200) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestFieldOrderings, rhs: Proto2Unittest_TestFieldOrderings) -> Bool { + if lhs._myString != rhs._myString {return false} + if lhs._myInt != rhs._myInt {return false} + if lhs._myFloat != rhs._myFloat {return false} + if lhs._optionalNestedMessage != rhs._optionalNestedMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TestFieldOrderings.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestFieldOrderings.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0\u{1}oo\0") + + 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._bb) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &self._oo) }() + 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 + try { if let v = self._bb { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._oo { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestFieldOrderings.NestedMessage, rhs: Proto2Unittest_TestFieldOrderings.NestedMessage) -> Bool { + if lhs._oo != rhs._oo {return false} + if lhs._bb != rhs._bb {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestExtensionOrderings1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestExtensionOrderings1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}my_string\0") + + 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._myString) }() + 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 + try { if let v = self._myString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestExtensionOrderings1, rhs: Proto2Unittest_TestExtensionOrderings1) -> Bool { + if lhs._myString != rhs._myString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestExtensionOrderings2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestExtensionOrderings2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}my_string\0") + + 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._myString) }() + 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 + try { if let v = self._myString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestExtensionOrderings2, rhs: Proto2Unittest_TestExtensionOrderings2) -> Bool { + if lhs._myString != rhs._myString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestExtensionOrderings2.TestExtensionOrderings3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestExtensionOrderings2.protoMessageName + ".TestExtensionOrderings3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}my_string\0") + + 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._myString) }() + 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 + try { if let v = self._myString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestExtensionOrderings2.TestExtensionOrderings3, rhs: Proto2Unittest_TestExtensionOrderings2.TestExtensionOrderings3) -> Bool { + if lhs._myString != rhs._myString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestExtremeDefaultValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestExtremeDefaultValues" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}escaped_bytes\0\u{3}large_uint32\0\u{3}large_uint64\0\u{3}small_int32\0\u{3}small_int64\0\u{3}utf8_string\0\u{3}zero_float\0\u{3}one_float\0\u{3}small_float\0\u{3}negative_one_float\0\u{3}negative_float\0\u{3}large_float\0\u{3}small_negative_float\0\u{3}inf_double\0\u{3}neg_inf_double\0\u{3}nan_double\0\u{3}inf_float\0\u{3}neg_inf_float\0\u{3}nan_float\0\u{3}cpp_trigraph\0\u{3}really_small_int32\0\u{3}really_small_int64\0\u{3}string_with_zero\0\u{3}bytes_with_zero\0\u{3}string_piece_with_zero\0\u{3}cord_with_zero\0\u{3}replacement_string\0") + + fileprivate class _StorageClass { + var _escapedBytes: Data? = nil + var _largeUint32: UInt32? = nil + var _largeUint64: UInt64? = nil + var _smallInt32: Int32? = nil + var _smallInt64: Int64? = nil + var _reallySmallInt32: Int32? = nil + var _reallySmallInt64: Int64? = nil + var _utf8String: String? = nil + var _zeroFloat: Float? = nil + var _oneFloat: Float? = nil + var _smallFloat: Float? = nil + var _negativeOneFloat: Float? = nil + var _negativeFloat: Float? = nil + var _largeFloat: Float? = nil + var _smallNegativeFloat: Float? = nil + var _infDouble: Double? = nil + var _negInfDouble: Double? = nil + var _nanDouble: Double? = nil + var _infFloat: Float? = nil + var _negInfFloat: Float? = nil + var _nanFloat: Float? = nil + var _cppTrigraph: String? = nil + var _stringWithZero: String? = nil + var _bytesWithZero: Data? = nil + var _stringPieceWithZero: String? = nil + var _cordWithZero: String? = nil + var _replacementString: String? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _escapedBytes = source._escapedBytes + _largeUint32 = source._largeUint32 + _largeUint64 = source._largeUint64 + _smallInt32 = source._smallInt32 + _smallInt64 = source._smallInt64 + _reallySmallInt32 = source._reallySmallInt32 + _reallySmallInt64 = source._reallySmallInt64 + _utf8String = source._utf8String + _zeroFloat = source._zeroFloat + _oneFloat = source._oneFloat + _smallFloat = source._smallFloat + _negativeOneFloat = source._negativeOneFloat + _negativeFloat = source._negativeFloat + _largeFloat = source._largeFloat + _smallNegativeFloat = source._smallNegativeFloat + _infDouble = source._infDouble + _negInfDouble = source._negInfDouble + _nanDouble = source._nanDouble + _infFloat = source._infFloat + _negInfFloat = source._negInfFloat + _nanFloat = source._nanFloat + _cppTrigraph = source._cppTrigraph + _stringWithZero = source._stringWithZero + _bytesWithZero = source._bytesWithZero + _stringPieceWithZero = source._stringPieceWithZero + _cordWithZero = source._cordWithZero + _replacementString = source._replacementString + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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.decodeSingularBytesField(value: &_storage._escapedBytes) }() + case 2: try { try decoder.decodeSingularUInt32Field(value: &_storage._largeUint32) }() + case 3: try { try decoder.decodeSingularUInt64Field(value: &_storage._largeUint64) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &_storage._smallInt32) }() + case 5: try { try decoder.decodeSingularInt64Field(value: &_storage._smallInt64) }() + case 6: try { try decoder.decodeSingularStringField(value: &_storage._utf8String) }() + case 7: try { try decoder.decodeSingularFloatField(value: &_storage._zeroFloat) }() + case 8: try { try decoder.decodeSingularFloatField(value: &_storage._oneFloat) }() + case 9: try { try decoder.decodeSingularFloatField(value: &_storage._smallFloat) }() + case 10: try { try decoder.decodeSingularFloatField(value: &_storage._negativeOneFloat) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._negativeFloat) }() + case 12: try { try decoder.decodeSingularFloatField(value: &_storage._largeFloat) }() + case 13: try { try decoder.decodeSingularFloatField(value: &_storage._smallNegativeFloat) }() + case 14: try { try decoder.decodeSingularDoubleField(value: &_storage._infDouble) }() + case 15: try { try decoder.decodeSingularDoubleField(value: &_storage._negInfDouble) }() + case 16: try { try decoder.decodeSingularDoubleField(value: &_storage._nanDouble) }() + case 17: try { try decoder.decodeSingularFloatField(value: &_storage._infFloat) }() + case 18: try { try decoder.decodeSingularFloatField(value: &_storage._negInfFloat) }() + case 19: try { try decoder.decodeSingularFloatField(value: &_storage._nanFloat) }() + case 20: try { try decoder.decodeSingularStringField(value: &_storage._cppTrigraph) }() + case 21: try { try decoder.decodeSingularInt32Field(value: &_storage._reallySmallInt32) }() + case 22: try { try decoder.decodeSingularInt64Field(value: &_storage._reallySmallInt64) }() + case 23: try { try decoder.decodeSingularStringField(value: &_storage._stringWithZero) }() + case 24: try { try decoder.decodeSingularBytesField(value: &_storage._bytesWithZero) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._stringPieceWithZero) }() + case 26: try { try decoder.decodeSingularStringField(value: &_storage._cordWithZero) }() + case 27: try { try decoder.decodeSingularStringField(value: &_storage._replacementString) }() + default: break + } + } + } + } + + func traverse(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._escapedBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._largeUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._largeUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._smallInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._smallInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._utf8String { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._zeroFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._oneFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._smallFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._negativeOneFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._negativeFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._largeFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._smallNegativeFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._infDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._negInfDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._nanDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._infFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 17) + } }() + try { if let v = _storage._negInfFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._nanFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._cppTrigraph { + try visitor.visitSingularStringField(value: v, fieldNumber: 20) + } }() + try { if let v = _storage._reallySmallInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._reallySmallInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._stringWithZero { + try visitor.visitSingularStringField(value: v, fieldNumber: 23) + } }() + try { if let v = _storage._bytesWithZero { + try visitor.visitSingularBytesField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._stringPieceWithZero { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._cordWithZero { + try visitor.visitSingularStringField(value: v, fieldNumber: 26) + } }() + try { if let v = _storage._replacementString { + try visitor.visitSingularStringField(value: v, fieldNumber: 27) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestExtremeDefaultValues, rhs: Proto2Unittest_TestExtremeDefaultValues) -> 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._escapedBytes != rhs_storage._escapedBytes {return false} + if _storage._largeUint32 != rhs_storage._largeUint32 {return false} + if _storage._largeUint64 != rhs_storage._largeUint64 {return false} + if _storage._smallInt32 != rhs_storage._smallInt32 {return false} + if _storage._smallInt64 != rhs_storage._smallInt64 {return false} + if _storage._reallySmallInt32 != rhs_storage._reallySmallInt32 {return false} + if _storage._reallySmallInt64 != rhs_storage._reallySmallInt64 {return false} + if _storage._utf8String != rhs_storage._utf8String {return false} + if _storage._zeroFloat != rhs_storage._zeroFloat {return false} + if _storage._oneFloat != rhs_storage._oneFloat {return false} + if _storage._smallFloat != rhs_storage._smallFloat {return false} + if _storage._negativeOneFloat != rhs_storage._negativeOneFloat {return false} + if _storage._negativeFloat != rhs_storage._negativeFloat {return false} + if _storage._largeFloat != rhs_storage._largeFloat {return false} + if _storage._smallNegativeFloat != rhs_storage._smallNegativeFloat {return false} + if _storage._infDouble != rhs_storage._infDouble {return false} + if _storage._negInfDouble != rhs_storage._negInfDouble {return false} + if _storage._nanDouble != rhs_storage._nanDouble {return false} + if _storage._infFloat != rhs_storage._infFloat {return false} + if _storage._negInfFloat != rhs_storage._negInfFloat {return false} + if _storage._nanFloat != rhs_storage._nanFloat {return false} + if _storage._cppTrigraph != rhs_storage._cppTrigraph {return false} + if _storage._stringWithZero != rhs_storage._stringWithZero {return false} + if _storage._bytesWithZero != rhs_storage._bytesWithZero {return false} + if _storage._stringPieceWithZero != rhs_storage._stringPieceWithZero {return false} + if _storage._cordWithZero != rhs_storage._cordWithZero {return false} + if _storage._replacementString != rhs_storage._replacementString {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_SparseEnumMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".SparseEnumMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}sparse_enum\0") + + 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._sparseEnum) }() + 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 + try { if let v = self._sparseEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_SparseEnumMessage, rhs: Proto2Unittest_SparseEnumMessage) -> Bool { + if lhs._sparseEnum != rhs._sparseEnum {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_OneString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OneString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_OneString, rhs: Proto2Unittest_OneString) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_MoreString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MoreString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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.decodeRepeatedStringField(value: &self.data) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.data.isEmpty { + try visitor.visitRepeatedStringField(value: self.data, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_MoreString, rhs: Proto2Unittest_MoreString) -> Bool { + if lhs.data != rhs.data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_OneBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OneBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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.decodeSingularBytesField(value: &self._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularBytesField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_OneBytes, rhs: Proto2Unittest_OneBytes) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_MoreBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MoreBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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.decodeRepeatedBytesField(value: &self.data) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.data.isEmpty { + try visitor.visitRepeatedBytesField(value: self.data, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_MoreBytes, rhs: Proto2Unittest_MoreBytes) -> Bool { + if lhs.data != rhs.data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_ManyOptionalString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ManyOptionalString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}str1\0\u{1}str2\0\u{1}str3\0\u{1}str4\0\u{1}str5\0\u{1}str6\0\u{1}str7\0\u{1}str8\0\u{1}str9\0\u{1}str10\0\u{1}str11\0\u{1}str12\0\u{1}str13\0\u{1}str14\0\u{1}str15\0\u{1}str16\0\u{1}str17\0\u{1}str18\0\u{1}str19\0\u{1}str20\0\u{1}str21\0\u{1}str22\0\u{1}str23\0\u{1}str24\0\u{1}str25\0\u{1}str26\0\u{1}str27\0\u{1}str28\0\u{1}str29\0\u{1}str30\0\u{1}str31\0\u{1}str32\0") + + fileprivate class _StorageClass { + var _str1: String? = nil + var _str2: String? = nil + var _str3: String? = nil + var _str4: String? = nil + var _str5: String? = nil + var _str6: String? = nil + var _str7: String? = nil + var _str8: String? = nil + var _str9: String? = nil + var _str10: String? = nil + var _str11: String? = nil + var _str12: String? = nil + var _str13: String? = nil + var _str14: String? = nil + var _str15: String? = nil + var _str16: String? = nil + var _str17: String? = nil + var _str18: String? = nil + var _str19: String? = nil + var _str20: String? = nil + var _str21: String? = nil + var _str22: String? = nil + var _str23: String? = nil + var _str24: String? = nil + var _str25: String? = nil + var _str26: String? = nil + var _str27: String? = nil + var _str28: String? = nil + var _str29: String? = nil + var _str30: String? = nil + var _str31: String? = nil + var _str32: String? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _str1 = source._str1 + _str2 = source._str2 + _str3 = source._str3 + _str4 = source._str4 + _str5 = source._str5 + _str6 = source._str6 + _str7 = source._str7 + _str8 = source._str8 + _str9 = source._str9 + _str10 = source._str10 + _str11 = source._str11 + _str12 = source._str12 + _str13 = source._str13 + _str14 = source._str14 + _str15 = source._str15 + _str16 = source._str16 + _str17 = source._str17 + _str18 = source._str18 + _str19 = source._str19 + _str20 = source._str20 + _str21 = source._str21 + _str22 = source._str22 + _str23 = source._str23 + _str24 = source._str24 + _str25 = source._str25 + _str26 = source._str26 + _str27 = source._str27 + _str28 = source._str28 + _str29 = source._str29 + _str30 = source._str30 + _str31 = source._str31 + _str32 = source._str32 + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._str1) }() + case 2: try { try decoder.decodeSingularStringField(value: &_storage._str2) }() + case 3: try { try decoder.decodeSingularStringField(value: &_storage._str3) }() + case 4: try { try decoder.decodeSingularStringField(value: &_storage._str4) }() + case 5: try { try decoder.decodeSingularStringField(value: &_storage._str5) }() + case 6: try { try decoder.decodeSingularStringField(value: &_storage._str6) }() + case 7: try { try decoder.decodeSingularStringField(value: &_storage._str7) }() + case 8: try { try decoder.decodeSingularStringField(value: &_storage._str8) }() + case 9: try { try decoder.decodeSingularStringField(value: &_storage._str9) }() + case 10: try { try decoder.decodeSingularStringField(value: &_storage._str10) }() + case 11: try { try decoder.decodeSingularStringField(value: &_storage._str11) }() + case 12: try { try decoder.decodeSingularStringField(value: &_storage._str12) }() + case 13: try { try decoder.decodeSingularStringField(value: &_storage._str13) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._str14) }() + case 15: try { try decoder.decodeSingularStringField(value: &_storage._str15) }() + case 16: try { try decoder.decodeSingularStringField(value: &_storage._str16) }() + case 17: try { try decoder.decodeSingularStringField(value: &_storage._str17) }() + case 18: try { try decoder.decodeSingularStringField(value: &_storage._str18) }() + case 19: try { try decoder.decodeSingularStringField(value: &_storage._str19) }() + case 20: try { try decoder.decodeSingularStringField(value: &_storage._str20) }() + case 21: try { try decoder.decodeSingularStringField(value: &_storage._str21) }() + case 22: try { try decoder.decodeSingularStringField(value: &_storage._str22) }() + case 23: try { try decoder.decodeSingularStringField(value: &_storage._str23) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._str24) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._str25) }() + case 26: try { try decoder.decodeSingularStringField(value: &_storage._str26) }() + case 27: try { try decoder.decodeSingularStringField(value: &_storage._str27) }() + case 28: try { try decoder.decodeSingularStringField(value: &_storage._str28) }() + case 29: try { try decoder.decodeSingularStringField(value: &_storage._str29) }() + case 30: try { try decoder.decodeSingularStringField(value: &_storage._str30) }() + case 31: try { try decoder.decodeSingularStringField(value: &_storage._str31) }() + case 32: try { try decoder.decodeSingularStringField(value: &_storage._str32) }() + default: break + } + } + } + } + + func traverse(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._str1 { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._str2 { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._str3 { + try visitor.visitSingularStringField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._str4 { + try visitor.visitSingularStringField(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._str5 { + try visitor.visitSingularStringField(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._str6 { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._str7 { + try visitor.visitSingularStringField(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._str8 { + try visitor.visitSingularStringField(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._str9 { + try visitor.visitSingularStringField(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._str10 { + try visitor.visitSingularStringField(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._str11 { + try visitor.visitSingularStringField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._str12 { + try visitor.visitSingularStringField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._str13 { + try visitor.visitSingularStringField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._str14 { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._str15 { + try visitor.visitSingularStringField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._str16 { + try visitor.visitSingularStringField(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._str17 { + try visitor.visitSingularStringField(value: v, fieldNumber: 17) + } }() + try { if let v = _storage._str18 { + try visitor.visitSingularStringField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._str19 { + try visitor.visitSingularStringField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._str20 { + try visitor.visitSingularStringField(value: v, fieldNumber: 20) + } }() + try { if let v = _storage._str21 { + try visitor.visitSingularStringField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._str22 { + try visitor.visitSingularStringField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._str23 { + try visitor.visitSingularStringField(value: v, fieldNumber: 23) + } }() + try { if let v = _storage._str24 { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._str25 { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._str26 { + try visitor.visitSingularStringField(value: v, fieldNumber: 26) + } }() + try { if let v = _storage._str27 { + try visitor.visitSingularStringField(value: v, fieldNumber: 27) + } }() + try { if let v = _storage._str28 { + try visitor.visitSingularStringField(value: v, fieldNumber: 28) + } }() + try { if let v = _storage._str29 { + try visitor.visitSingularStringField(value: v, fieldNumber: 29) + } }() + try { if let v = _storage._str30 { + try visitor.visitSingularStringField(value: v, fieldNumber: 30) + } }() + try { if let v = _storage._str31 { + try visitor.visitSingularStringField(value: v, fieldNumber: 31) + } }() + try { if let v = _storage._str32 { + try visitor.visitSingularStringField(value: v, fieldNumber: 32) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_ManyOptionalString, rhs: Proto2Unittest_ManyOptionalString) -> 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._str1 != rhs_storage._str1 {return false} + if _storage._str2 != rhs_storage._str2 {return false} + if _storage._str3 != rhs_storage._str3 {return false} + if _storage._str4 != rhs_storage._str4 {return false} + if _storage._str5 != rhs_storage._str5 {return false} + if _storage._str6 != rhs_storage._str6 {return false} + if _storage._str7 != rhs_storage._str7 {return false} + if _storage._str8 != rhs_storage._str8 {return false} + if _storage._str9 != rhs_storage._str9 {return false} + if _storage._str10 != rhs_storage._str10 {return false} + if _storage._str11 != rhs_storage._str11 {return false} + if _storage._str12 != rhs_storage._str12 {return false} + if _storage._str13 != rhs_storage._str13 {return false} + if _storage._str14 != rhs_storage._str14 {return false} + if _storage._str15 != rhs_storage._str15 {return false} + if _storage._str16 != rhs_storage._str16 {return false} + if _storage._str17 != rhs_storage._str17 {return false} + if _storage._str18 != rhs_storage._str18 {return false} + if _storage._str19 != rhs_storage._str19 {return false} + if _storage._str20 != rhs_storage._str20 {return false} + if _storage._str21 != rhs_storage._str21 {return false} + if _storage._str22 != rhs_storage._str22 {return false} + if _storage._str23 != rhs_storage._str23 {return false} + if _storage._str24 != rhs_storage._str24 {return false} + if _storage._str25 != rhs_storage._str25 {return false} + if _storage._str26 != rhs_storage._str26 {return false} + if _storage._str27 != rhs_storage._str27 {return false} + if _storage._str28 != rhs_storage._str28 {return false} + if _storage._str29 != rhs_storage._str29 {return false} + if _storage._str30 != rhs_storage._str30 {return false} + if _storage._str31 != rhs_storage._str31 {return false} + if _storage._str32 != rhs_storage._str32 {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_Int32Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Int32Message" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_Int32Message, rhs: Proto2Unittest_Int32Message) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_Uint32Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Uint32Message" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_Uint32Message, rhs: Proto2Unittest_Uint32Message) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_Int64Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Int64Message" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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.decodeSingularInt64Field(value: &self._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_Int64Message, rhs: Proto2Unittest_Int64Message) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_Uint64Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Uint64Message" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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.decodeSingularUInt64Field(value: &self._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_Uint64Message, rhs: Proto2Unittest_Uint64Message) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_BoolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".BoolMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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.decodeSingularBoolField(value: &self._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_BoolMessage, rhs: Proto2Unittest_BoolMessage) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}foo_int\0\u{3}foo_string\0\u{3}foo_message\0\u{7}FooGroup\0") + + 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: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooInt(v) + } + }() + case 2: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooString(v) + } + }() + case 3: try { + var v: Proto2Unittest_TestAllTypes? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooMessage(v) + } + }() + case 4: try { + var v: Proto2Unittest_TestOneof.FooGroup? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooGroup(let m) = current {v = m} + } + try decoder.decodeSingularGroupField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooGroup(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.foo { + case .fooInt?: try { + guard case .fooInt(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + }() + case .fooString?: try { + guard case .fooString(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + }() + case .fooMessage?: try { + guard case .fooMessage(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + }() + case .fooGroup?: try { + guard case .fooGroup(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularGroupField(value: v, fieldNumber: 4) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestOneof, rhs: Proto2Unittest_TestOneof) -> Bool { + if lhs.foo != rhs.foo {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestOneof.FooGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestOneof.protoMessageName + ".FooGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{5}a\0\u{1}b\0") + + 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 5: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + case 6: try { try decoder.decodeSingularStringField(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = self._b { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestOneof.FooGroup, rhs: Proto2Unittest_TestOneof.FooGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestOneofBackwardsCompatible: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestOneofBackwardsCompatible" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}foo_int\0\u{3}foo_string\0\u{3}foo_message\0\u{7}FooGroup\0") + + 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._fooInt) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._fooString) }() + case 3: try { try decoder.decodeSingularMessageField(value: &self._fooMessage) }() + case 4: try { try decoder.decodeSingularGroupField(value: &self._fooGroup) }() + 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 + try { if let v = self._fooInt { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._fooString { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._fooMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try { if let v = self._fooGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 4) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestOneofBackwardsCompatible, rhs: Proto2Unittest_TestOneofBackwardsCompatible) -> Bool { + if lhs._fooInt != rhs._fooInt {return false} + if lhs._fooString != rhs._fooString {return false} + if lhs._fooMessage != rhs._fooMessage {return false} + if lhs._fooGroup != rhs._fooGroup {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestOneofBackwardsCompatible.FooGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestOneofBackwardsCompatible.protoMessageName + ".FooGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{5}a\0\u{1}b\0") + + 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 5: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + case 6: try { try decoder.decodeSingularStringField(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = self._b { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestOneofBackwardsCompatible.FooGroup, rhs: Proto2Unittest_TestOneofBackwardsCompatible.FooGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestOneof2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestOneof2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}foo_int\0\u{3}foo_string\0\u{3}foo_cord\0\u{3}foo_string_piece\0\u{3}foo_bytes\0\u{3}foo_enum\0\u{3}foo_message\0\u{7}FooGroup\0\u{4}\u{3}foo_lazy_message\0\u{3}bar_int\0\u{3}bar_string\0\u{3}bar_cord\0\u{3}bar_string_piece\0\u{3}bar_bytes\0\u{3}bar_enum\0\u{3}baz_int\0\u{3}baz_string\0\u{3}bar_string_with_empty_default\0\u{3}bar_cord_with_empty_default\0\u{3}bar_string_piece_with_empty_default\0\u{3}bar_bytes_with_empty_default\0\u{4}\u{7}foo_bytes_cord\0") + + 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: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooInt(v) + } + }() + case 2: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooString(v) + } + }() + case 3: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooCord(v) + } + }() + case 4: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooStringPiece(v) + } + }() + case 5: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooBytes(v) + } + }() + case 6: try { + var v: Proto2Unittest_TestOneof2.NestedEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooEnum(v) + } + }() + case 7: try { + var v: Proto2Unittest_TestOneof2.NestedMessage? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooMessage(v) + } + }() + case 8: try { + var v: Proto2Unittest_TestOneof2.FooGroup? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooGroup(let m) = current {v = m} + } + try decoder.decodeSingularGroupField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooGroup(v) + } + }() + case 11: try { + var v: Proto2Unittest_TestOneof2.NestedMessage? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooLazyMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooLazyMessage(v) + } + }() + case 12: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barInt(v) + } + }() + case 13: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barString(v) + } + }() + case 14: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barCord(v) + } + }() + case 15: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barStringPiece(v) + } + }() + case 16: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barBytes(v) + } + }() + case 17: try { + var v: Proto2Unittest_TestOneof2.NestedEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barEnum(v) + } + }() + case 18: try { try decoder.decodeSingularInt32Field(value: &self._bazInt) }() + case 19: try { try decoder.decodeSingularStringField(value: &self._bazString) }() + case 20: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barStringWithEmptyDefault(v) + } + }() + case 21: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barCordWithEmptyDefault(v) + } + }() + case 22: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barStringPieceWithEmptyDefault(v) + } + }() + case 23: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if self.bar != nil {try decoder.handleConflictingOneOf()} + self.bar = .barBytesWithEmptyDefault(v) + } + }() + case 30: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooBytesCord(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.foo { + case .fooInt?: try { + guard case .fooInt(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + }() + case .fooString?: try { + guard case .fooString(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + }() + case .fooCord?: try { + guard case .fooCord(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 3) + }() + case .fooStringPiece?: try { + guard case .fooStringPiece(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 4) + }() + case .fooBytes?: try { + guard case .fooBytes(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 5) + }() + case .fooEnum?: try { + guard case .fooEnum(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + }() + case .fooMessage?: try { + guard case .fooMessage(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 7) + }() + case .fooGroup?: try { + guard case .fooGroup(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularGroupField(value: v, fieldNumber: 8) + }() + case .fooLazyMessage?: try { + guard case .fooLazyMessage(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 11) + }() + default: break + } + switch self.bar { + case .barInt?: try { + guard case .barInt(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 12) + }() + case .barString?: try { + guard case .barString(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 13) + }() + case .barCord?: try { + guard case .barCord(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + }() + case .barStringPiece?: try { + guard case .barStringPiece(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 15) + }() + case .barBytes?: try { + guard case .barBytes(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 16) + }() + case .barEnum?: try { + guard case .barEnum(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 17) + }() + default: break + } + try { if let v = self._bazInt { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 18) + } }() + try { if let v = self._bazString { + try visitor.visitSingularStringField(value: v, fieldNumber: 19) + } }() + switch self.bar { + case .barStringWithEmptyDefault?: try { + guard case .barStringWithEmptyDefault(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 20) + }() + case .barCordWithEmptyDefault?: try { + guard case .barCordWithEmptyDefault(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 21) + }() + case .barStringPieceWithEmptyDefault?: try { + guard case .barStringPieceWithEmptyDefault(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 22) + }() + case .barBytesWithEmptyDefault?: try { + guard case .barBytesWithEmptyDefault(let v)? = self.bar else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 23) + }() + default: break + } + try { if case .fooBytesCord(let v)? = self.foo { + try visitor.visitSingularBytesField(value: v, fieldNumber: 30) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestOneof2, rhs: Proto2Unittest_TestOneof2) -> Bool { + if lhs.foo != rhs.foo {return false} + if lhs.bar != rhs.bar {return false} + if lhs._bazInt != rhs._bazInt {return false} + if lhs._bazString != rhs._bazString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestOneof2.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension Proto2Unittest_TestOneof2.FooGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestOneof2.protoMessageName + ".FooGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{9}a\0\u{1}b\0") + + 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 9: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + case 10: try { try decoder.decodeSingularStringField(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try { if let v = self._b { + try visitor.visitSingularStringField(value: v, fieldNumber: 10) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestOneof2.FooGroup, rhs: Proto2Unittest_TestOneof2.FooGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestOneof2.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestOneof2.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}moo_int\0\u{3}corge_int\0\u{1}child\0") + + fileprivate class _StorageClass { + var _mooInt: Int64? = nil + var _corgeInt: [Int32] = [] + var _child: Proto2Unittest_TestOneof2.NestedMessage? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _mooInt = source._mooInt + _corgeInt = source._corgeInt + _child = source._child + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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.decodeSingularInt64Field(value: &_storage._mooInt) }() + case 2: try { try decoder.decodeRepeatedInt32Field(value: &_storage._corgeInt) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._child) }() + default: break + } + } + } + } + + func traverse(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._mooInt { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 1) + } }() + if !_storage._corgeInt.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._corgeInt, fieldNumber: 2) + } + try { if let v = _storage._child { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestOneof2.NestedMessage, rhs: Proto2Unittest_TestOneof2.NestedMessage) -> 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._mooInt != rhs_storage._mooInt {return false} + if _storage._corgeInt != rhs_storage._corgeInt {return false} + if _storage._child != rhs_storage._child {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestRequiredOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}foo_int\0\u{3}foo_string\0\u{3}foo_message\0\u{3}foo_lazy_message\0") + + public var isInitialized: Bool { + if let v = self.foo, !v.isInitialized {return false} + return true + } + + 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: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooInt(v) + } + }() + case 2: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooString(v) + } + }() + case 3: try { + var v: Proto2Unittest_TestRequiredOneof.NestedMessage? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooMessage(v) + } + }() + case 4: try { + var v: Proto2Unittest_TestRequiredOneof.NestedMessage? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooLazyMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooLazyMessage(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.foo { + case .fooInt?: try { + guard case .fooInt(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + }() + case .fooString?: try { + guard case .fooString(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + }() + case .fooMessage?: try { + guard case .fooMessage(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + }() + case .fooLazyMessage?: try { + guard case .fooLazyMessage(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestRequiredOneof, rhs: Proto2Unittest_TestRequiredOneof) -> Bool { + if lhs.foo != rhs.foo {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestRequiredOneof.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestRequiredOneof.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_double\0") + + public var isInitialized: Bool { + if self._requiredDouble == nil {return false} + return true + } + + 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.decodeSingularDoubleField(value: &self._requiredDouble) }() + 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 + try { if let v = self._requiredDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestRequiredOneof.NestedMessage, rhs: Proto2Unittest_TestRequiredOneof.NestedMessage) -> Bool { + if lhs._requiredDouble != rhs._requiredDouble {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestPackedTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}Z\u{1}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_enum\0") + + 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 90: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32) }() + case 91: try { try decoder.decodeRepeatedInt64Field(value: &self.packedInt64) }() + case 92: try { try decoder.decodeRepeatedUInt32Field(value: &self.packedUint32) }() + case 93: try { try decoder.decodeRepeatedUInt64Field(value: &self.packedUint64) }() + case 94: try { try decoder.decodeRepeatedSInt32Field(value: &self.packedSint32) }() + case 95: try { try decoder.decodeRepeatedSInt64Field(value: &self.packedSint64) }() + case 96: try { try decoder.decodeRepeatedFixed32Field(value: &self.packedFixed32) }() + case 97: try { try decoder.decodeRepeatedFixed64Field(value: &self.packedFixed64) }() + case 98: try { try decoder.decodeRepeatedSFixed32Field(value: &self.packedSfixed32) }() + case 99: try { try decoder.decodeRepeatedSFixed64Field(value: &self.packedSfixed64) }() + case 100: try { try decoder.decodeRepeatedFloatField(value: &self.packedFloat) }() + case 101: try { try decoder.decodeRepeatedDoubleField(value: &self.packedDouble) }() + case 102: try { try decoder.decodeRepeatedBoolField(value: &self.packedBool) }() + case 103: try { try decoder.decodeRepeatedEnumField(value: &self.packedEnum) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: self.packedInt32, fieldNumber: 90) + } + if !self.packedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: self.packedInt64, fieldNumber: 91) + } + if !self.packedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: self.packedUint32, fieldNumber: 92) + } + if !self.packedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: self.packedUint64, fieldNumber: 93) + } + if !self.packedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: self.packedSint32, fieldNumber: 94) + } + if !self.packedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: self.packedSint64, fieldNumber: 95) + } + if !self.packedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: self.packedFixed32, fieldNumber: 96) + } + if !self.packedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: self.packedFixed64, fieldNumber: 97) + } + if !self.packedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: self.packedSfixed32, fieldNumber: 98) + } + if !self.packedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: self.packedSfixed64, fieldNumber: 99) + } + if !self.packedFloat.isEmpty { + try visitor.visitPackedFloatField(value: self.packedFloat, fieldNumber: 100) + } + if !self.packedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: self.packedDouble, fieldNumber: 101) + } + if !self.packedBool.isEmpty { + try visitor.visitPackedBoolField(value: self.packedBool, fieldNumber: 102) + } + if !self.packedEnum.isEmpty { + try visitor.visitPackedEnumField(value: self.packedEnum, fieldNumber: 103) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestPackedTypes, rhs: Proto2Unittest_TestPackedTypes) -> Bool { + if lhs.packedInt32 != rhs.packedInt32 {return false} + if lhs.packedInt64 != rhs.packedInt64 {return false} + if lhs.packedUint32 != rhs.packedUint32 {return false} + if lhs.packedUint64 != rhs.packedUint64 {return false} + if lhs.packedSint32 != rhs.packedSint32 {return false} + if lhs.packedSint64 != rhs.packedSint64 {return false} + if lhs.packedFixed32 != rhs.packedFixed32 {return false} + if lhs.packedFixed64 != rhs.packedFixed64 {return false} + if lhs.packedSfixed32 != rhs.packedSfixed32 {return false} + if lhs.packedSfixed64 != rhs.packedSfixed64 {return false} + if lhs.packedFloat != rhs.packedFloat {return false} + if lhs.packedDouble != rhs.packedDouble {return false} + if lhs.packedBool != rhs.packedBool {return false} + if lhs.packedEnum != rhs.packedEnum {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestUnpackedTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}Z\u{1}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_enum\0") + + 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 90: try { try decoder.decodeRepeatedInt32Field(value: &self.unpackedInt32) }() + case 91: try { try decoder.decodeRepeatedInt64Field(value: &self.unpackedInt64) }() + case 92: try { try decoder.decodeRepeatedUInt32Field(value: &self.unpackedUint32) }() + case 93: try { try decoder.decodeRepeatedUInt64Field(value: &self.unpackedUint64) }() + case 94: try { try decoder.decodeRepeatedSInt32Field(value: &self.unpackedSint32) }() + case 95: try { try decoder.decodeRepeatedSInt64Field(value: &self.unpackedSint64) }() + case 96: try { try decoder.decodeRepeatedFixed32Field(value: &self.unpackedFixed32) }() + case 97: try { try decoder.decodeRepeatedFixed64Field(value: &self.unpackedFixed64) }() + case 98: try { try decoder.decodeRepeatedSFixed32Field(value: &self.unpackedSfixed32) }() + case 99: try { try decoder.decodeRepeatedSFixed64Field(value: &self.unpackedSfixed64) }() + case 100: try { try decoder.decodeRepeatedFloatField(value: &self.unpackedFloat) }() + case 101: try { try decoder.decodeRepeatedDoubleField(value: &self.unpackedDouble) }() + case 102: try { try decoder.decodeRepeatedBoolField(value: &self.unpackedBool) }() + case 103: try { try decoder.decodeRepeatedEnumField(value: &self.unpackedEnum) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.unpackedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.unpackedInt32, fieldNumber: 90) + } + if !self.unpackedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: self.unpackedInt64, fieldNumber: 91) + } + if !self.unpackedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: self.unpackedUint32, fieldNumber: 92) + } + if !self.unpackedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: self.unpackedUint64, fieldNumber: 93) + } + if !self.unpackedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: self.unpackedSint32, fieldNumber: 94) + } + if !self.unpackedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: self.unpackedSint64, fieldNumber: 95) + } + if !self.unpackedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: self.unpackedFixed32, fieldNumber: 96) + } + if !self.unpackedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: self.unpackedFixed64, fieldNumber: 97) + } + if !self.unpackedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: self.unpackedSfixed32, fieldNumber: 98) + } + if !self.unpackedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: self.unpackedSfixed64, fieldNumber: 99) + } + if !self.unpackedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: self.unpackedFloat, fieldNumber: 100) + } + if !self.unpackedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: self.unpackedDouble, fieldNumber: 101) + } + if !self.unpackedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: self.unpackedBool, fieldNumber: 102) + } + if !self.unpackedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: self.unpackedEnum, fieldNumber: 103) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestUnpackedTypes, rhs: Proto2Unittest_TestUnpackedTypes) -> Bool { + if lhs.unpackedInt32 != rhs.unpackedInt32 {return false} + if lhs.unpackedInt64 != rhs.unpackedInt64 {return false} + if lhs.unpackedUint32 != rhs.unpackedUint32 {return false} + if lhs.unpackedUint64 != rhs.unpackedUint64 {return false} + if lhs.unpackedSint32 != rhs.unpackedSint32 {return false} + if lhs.unpackedSint64 != rhs.unpackedSint64 {return false} + if lhs.unpackedFixed32 != rhs.unpackedFixed32 {return false} + if lhs.unpackedFixed64 != rhs.unpackedFixed64 {return false} + if lhs.unpackedSfixed32 != rhs.unpackedSfixed32 {return false} + if lhs.unpackedSfixed64 != rhs.unpackedSfixed64 {return false} + if lhs.unpackedFloat != rhs.unpackedFloat {return false} + if lhs.unpackedDouble != rhs.unpackedDouble {return false} + if lhs.unpackedBool != rhs.unpackedBool {return false} + if lhs.unpackedEnum != rhs.unpackedEnum {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestPackedExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestPackedExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestPackedExtensions.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestPackedExtensions, rhs: Proto2Unittest_TestPackedExtensions) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TestUnpackedExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestUnpackedExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestUnpackedExtensions.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestUnpackedExtensions, rhs: Proto2Unittest_TestUnpackedExtensions) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TestDynamicExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestDynamicExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}P\u{1f}scalar_extension\0\u{3}enum_extension\0\u{3}dynamic_enum_extension\0\u{3}message_extension\0\u{3}dynamic_message_extension\0\u{3}repeated_extension\0\u{3}packed_extension\0") + + 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 2000: try { try decoder.decodeSingularFixed32Field(value: &self._scalarExtension) }() + case 2001: try { try decoder.decodeSingularEnumField(value: &self._enumExtension) }() + case 2002: try { try decoder.decodeSingularEnumField(value: &self._dynamicEnumExtension) }() + case 2003: try { try decoder.decodeSingularMessageField(value: &self._messageExtension) }() + case 2004: try { try decoder.decodeSingularMessageField(value: &self._dynamicMessageExtension) }() + case 2005: try { try decoder.decodeRepeatedStringField(value: &self.repeatedExtension) }() + case 2006: try { try decoder.decodeRepeatedSInt32Field(value: &self.packedExtension) }() + 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 + try { if let v = self._scalarExtension { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 2000) + } }() + try { if let v = self._enumExtension { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2001) + } }() + try { if let v = self._dynamicEnumExtension { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2002) + } }() + try { if let v = self._messageExtension { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2003) + } }() + try { if let v = self._dynamicMessageExtension { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2004) + } }() + if !self.repeatedExtension.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedExtension, fieldNumber: 2005) + } + if !self.packedExtension.isEmpty { + try visitor.visitPackedSInt32Field(value: self.packedExtension, fieldNumber: 2006) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestDynamicExtensions, rhs: Proto2Unittest_TestDynamicExtensions) -> Bool { + if lhs._scalarExtension != rhs._scalarExtension {return false} + if lhs._enumExtension != rhs._enumExtension {return false} + if lhs._dynamicEnumExtension != rhs._dynamicEnumExtension {return false} + if lhs._messageExtension != rhs._messageExtension {return false} + if lhs._dynamicMessageExtension != rhs._dynamicMessageExtension {return false} + if lhs.repeatedExtension != rhs.repeatedExtension {return false} + if lhs.packedExtension != rhs.packedExtension {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestDynamicExtensions.DynamicEnumType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}X\"DYNAMIC_FOO\0\u{1}DYNAMIC_BAR\0\u{1}DYNAMIC_BAZ\0") +} + +extension Proto2Unittest_TestDynamicExtensions.DynamicMessageType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestDynamicExtensions.protoMessageName + ".DynamicMessageType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}t dynamic_field\0") + + 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 2100: try { try decoder.decodeSingularInt32Field(value: &self._dynamicField) }() + 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 + try { if let v = self._dynamicField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2100) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestDynamicExtensions.DynamicMessageType, rhs: Proto2Unittest_TestDynamicExtensions.DynamicMessageType) -> Bool { + if lhs._dynamicField != rhs._dynamicField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestRepeatedString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRepeatedString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}repeated_string1\0\u{3}repeated_string2\0\u{4}\u{9}repeated_bytes11\0\u{3}repeated_bytes12\0") + + 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.decodeRepeatedStringField(value: &self.repeatedString1) }() + case 2: try { try decoder.decodeRepeatedStringField(value: &self.repeatedString2) }() + case 11: try { try decoder.decodeRepeatedBytesField(value: &self.repeatedBytes11) }() + case 12: try { try decoder.decodeRepeatedBytesField(value: &self.repeatedBytes12) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.repeatedString1.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedString1, fieldNumber: 1) + } + if !self.repeatedString2.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedString2, fieldNumber: 2) + } + if !self.repeatedBytes11.isEmpty { + try visitor.visitRepeatedBytesField(value: self.repeatedBytes11, fieldNumber: 11) + } + if !self.repeatedBytes12.isEmpty { + try visitor.visitRepeatedBytesField(value: self.repeatedBytes12, fieldNumber: 12) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestRepeatedString, rhs: Proto2Unittest_TestRepeatedString) -> Bool { + if lhs.repeatedString1 != rhs.repeatedString1 {return false} + if lhs.repeatedString2 != rhs.repeatedString2 {return false} + if lhs.repeatedBytes11 != rhs.repeatedBytes11 {return false} + if lhs.repeatedBytes12 != rhs.repeatedBytes12 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestRepeatedScalarDifferentTagSizes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRepeatedScalarDifferentTagSizes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{c}repeated_fixed32\0\u{3}repeated_int32\0\u{4}q\u{1f}repeated_fixed64\0\u{3}repeated_int64\0\u{4}\u{7f}_?repeated_float\0\u{3}repeated_uint64\0") + + 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 12: try { try decoder.decodeRepeatedFixed32Field(value: &self.repeatedFixed32) }() + case 13: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() + case 2046: try { try decoder.decodeRepeatedFixed64Field(value: &self.repeatedFixed64) }() + case 2047: try { try decoder.decodeRepeatedInt64Field(value: &self.repeatedInt64) }() + case 262142: try { try decoder.decodeRepeatedFloatField(value: &self.repeatedFloat) }() + case 262143: try { try decoder.decodeRepeatedUInt64Field(value: &self.repeatedUint64) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.repeatedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: self.repeatedFixed32, fieldNumber: 12) + } + if !self.repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 13) + } + if !self.repeatedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: self.repeatedFixed64, fieldNumber: 2046) + } + if !self.repeatedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: self.repeatedInt64, fieldNumber: 2047) + } + if !self.repeatedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: self.repeatedFloat, fieldNumber: 262142) + } + if !self.repeatedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: self.repeatedUint64, fieldNumber: 262143) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestRepeatedScalarDifferentTagSizes, rhs: Proto2Unittest_TestRepeatedScalarDifferentTagSizes) -> Bool { + if lhs.repeatedFixed32 != rhs.repeatedFixed32 {return false} + if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} + if lhs.repeatedFixed64 != rhs.repeatedFixed64 {return false} + if lhs.repeatedInt64 != rhs.repeatedInt64 {return false} + if lhs.repeatedFloat != rhs.repeatedFloat {return false} + if lhs.repeatedUint64 != rhs.repeatedUint64 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestParsingMerge: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestParsingMerge" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_all_types\0\u{3}optional_all_types\0\u{3}repeated_all_types\0\u{8}\u{7}OptionalGroup\0\u{8}\u{a}RepeatedGroup\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + if self._requiredAllTypes == nil {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._requiredAllTypes) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 10: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() + case 20: try { try decoder.decodeRepeatedGroupField(value: &self.repeatedGroup) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestParsingMerge.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._requiredAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 3) + } + try { if let v = self._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 10) + } }() + if !self.repeatedGroup.isEmpty { + try visitor.visitRepeatedGroupField(value: self.repeatedGroup, fieldNumber: 20) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestParsingMerge, rhs: Proto2Unittest_TestParsingMerge) -> Bool { + if lhs._requiredAllTypes != rhs._requiredAllTypes {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs._optionalGroup != rhs._optionalGroup {return false} + if lhs.repeatedGroup != rhs.repeatedGroup {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TestParsingMerge.RepeatedFieldsGenerator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestParsingMerge.protoMessageName + ".RepeatedFieldsGenerator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field1\0\u{1}field2\0\u{1}field3\0\u{8}\u{7}Group1\0\u{8}\u{a}Group2\0\u{2}T\u{f}ext1\0\u{1}ext2\0") + + 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.decodeRepeatedMessageField(value: &self.field1) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.field2) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &self.field3) }() + case 10: try { try decoder.decodeRepeatedGroupField(value: &self.group1) }() + case 20: try { try decoder.decodeRepeatedGroupField(value: &self.group2) }() + case 1000: try { try decoder.decodeRepeatedMessageField(value: &self.ext1) }() + case 1001: try { try decoder.decodeRepeatedMessageField(value: &self.ext2) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.field1.isEmpty { + try visitor.visitRepeatedMessageField(value: self.field1, fieldNumber: 1) + } + if !self.field2.isEmpty { + try visitor.visitRepeatedMessageField(value: self.field2, fieldNumber: 2) + } + if !self.field3.isEmpty { + try visitor.visitRepeatedMessageField(value: self.field3, fieldNumber: 3) + } + if !self.group1.isEmpty { + try visitor.visitRepeatedGroupField(value: self.group1, fieldNumber: 10) + } + if !self.group2.isEmpty { + try visitor.visitRepeatedGroupField(value: self.group2, fieldNumber: 20) + } + if !self.ext1.isEmpty { + try visitor.visitRepeatedMessageField(value: self.ext1, fieldNumber: 1000) + } + if !self.ext2.isEmpty { + try visitor.visitRepeatedMessageField(value: self.ext2, fieldNumber: 1001) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestParsingMerge.RepeatedFieldsGenerator, rhs: Proto2Unittest_TestParsingMerge.RepeatedFieldsGenerator) -> Bool { + if lhs.field1 != rhs.field1 {return false} + if lhs.field2 != rhs.field2 {return false} + if lhs.field3 != rhs.field3 {return false} + if lhs.group1 != rhs.group1 {return false} + if lhs.group2 != rhs.group2 {return false} + if lhs.ext1 != rhs.ext1 {return false} + if lhs.ext2 != rhs.ext2 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestParsingMerge.RepeatedFieldsGenerator.Group1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestParsingMerge.RepeatedFieldsGenerator.protoMessageName + ".Group1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{b}field1\0") + + 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 11: try { try decoder.decodeSingularMessageField(value: &self._field1) }() + 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 + try { if let v = self._field1 { + try visitor.visitSingularMessageField(value: v, fieldNumber: 11) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestParsingMerge.RepeatedFieldsGenerator.Group1, rhs: Proto2Unittest_TestParsingMerge.RepeatedFieldsGenerator.Group1) -> Bool { + if lhs._field1 != rhs._field1 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestParsingMerge.RepeatedFieldsGenerator.Group2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestParsingMerge.RepeatedFieldsGenerator.protoMessageName + ".Group2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{15}field1\0") + + 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 21: try { try decoder.decodeSingularMessageField(value: &self._field1) }() + 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 + try { if let v = self._field1 { + try visitor.visitSingularMessageField(value: v, fieldNumber: 21) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestParsingMerge.RepeatedFieldsGenerator.Group2, rhs: Proto2Unittest_TestParsingMerge.RepeatedFieldsGenerator.Group2) -> Bool { + if lhs._field1 != rhs._field1 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestParsingMerge.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestParsingMerge.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{b}optional_group_all_types\0") + + 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 11: try { try decoder.decodeSingularMessageField(value: &self._optionalGroupAllTypes) }() + 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 + try { if let v = self._optionalGroupAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 11) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestParsingMerge.OptionalGroup, rhs: Proto2Unittest_TestParsingMerge.OptionalGroup) -> Bool { + if lhs._optionalGroupAllTypes != rhs._optionalGroupAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestParsingMerge.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestParsingMerge.protoMessageName + ".RepeatedGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{15}repeated_group_all_types\0") + + 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 21: try { try decoder.decodeSingularMessageField(value: &self._repeatedGroupAllTypes) }() + 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 + try { if let v = self._repeatedGroupAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 21) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestParsingMerge.RepeatedGroup, rhs: Proto2Unittest_TestParsingMerge.RepeatedGroup) -> Bool { + if lhs._repeatedGroupAllTypes != rhs._repeatedGroupAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMergeException: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMergeException" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}all_extensions\0") + + public var isInitialized: Bool { + if let v = self._allExtensions, !v.isInitialized {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._allExtensions) }() + 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 + try { if let v = self._allExtensions { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMergeException, rhs: Proto2Unittest_TestMergeException) -> Bool { + if lhs._allExtensions != rhs._allExtensions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestCommentInjectionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestCommentInjectionMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") + + 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._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestCommentInjectionMessage, rhs: Proto2Unittest_TestCommentInjectionMessage) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMessageSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}m1\0\u{1}m2\0\u{1}m3\0\u{1}m4\0\u{1}m5\0\u{1}m6\0") + + 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.decodeSingularBoolField(value: &self._m1) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &self._m2) }() + case 3: try { try decoder.decodeSingularBoolField(value: &self._m3) }() + case 4: try { try decoder.decodeSingularStringField(value: &self._m4) }() + case 5: try { try decoder.decodeSingularInt32Field(value: &self._m5) }() + case 6: try { try decoder.decodeSingularInt64Field(value: &self._m6) }() + 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 + try { if let v = self._m1 { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1) + } }() + try { if let v = self._m2 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._m3 { + try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + } }() + try { if let v = self._m4 { + try visitor.visitSingularStringField(value: v, fieldNumber: 4) + } }() + try { if let v = self._m5 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = self._m6 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 6) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMessageSize, rhs: Proto2Unittest_TestMessageSize) -> Bool { + if lhs._m1 != rhs._m1 {return false} + if lhs._m2 != rhs._m2 {return false} + if lhs._m3 != rhs._m3 {return false} + if lhs._m4 != rhs._m4 {return false} + if lhs._m5 != rhs._m5 {return false} + if lhs._m6 != rhs._m6 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_OpenEnumMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OpenEnumMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}opt_open\0\u{3}opt_closed\0\u{3}repeated_open\0\u{3}repeated_closed\0") + + 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._optOpen) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self._optClosed) }() + case 3: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedOpen) }() + case 4: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedClosed) }() + 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 + try { if let v = self._optOpen { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = self._optClosed { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) + } }() + if !self.repeatedOpen.isEmpty { + try visitor.visitRepeatedEnumField(value: self.repeatedOpen, fieldNumber: 3) + } + if !self.repeatedClosed.isEmpty { + try visitor.visitRepeatedEnumField(value: self.repeatedClosed, fieldNumber: 4) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_OpenEnumMessage, rhs: Proto2Unittest_OpenEnumMessage) -> Bool { + if lhs._optOpen != rhs._optOpen {return false} + if lhs._optClosed != rhs._optClosed {return false} + if lhs.repeatedOpen != rhs.repeatedOpen {return false} + if lhs.repeatedClosed != rhs.repeatedClosed {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_OpenEnumMessage.TestEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNKNOWN\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension Proto2Unittest_TestEagerlyVerifiedLazyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEagerlyVerifiedLazyMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}lazy_message\0") + + 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.decodeSingularMessageField(value: &self._lazyMessage) }() + 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 + try { if let v = self._lazyMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestEagerlyVerifiedLazyMessage, rhs: Proto2Unittest_TestEagerlyVerifiedLazyMessage) -> Bool { + if lhs._lazyMessage != rhs._lazyMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestEagerlyVerifiedLazyMessage.LazyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestEagerlyVerifiedLazyMessage.protoMessageName + ".LazyMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}bytes_field\0") + + 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.decodeSingularBytesField(value: &self._bytesField) }() + 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 + try { if let v = self._bytesField { + try visitor.visitSingularBytesField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestEagerlyVerifiedLazyMessage.LazyMessage, rhs: Proto2Unittest_TestEagerlyVerifiedLazyMessage.LazyMessage) -> Bool { + if lhs._bytesField != rhs._bytesField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_FooRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FooRequest" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_FooRequest, rhs: Proto2Unittest_FooRequest) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_FooResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FooResponse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_FooResponse, rhs: Proto2Unittest_FooResponse) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_FooClientMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FooClientMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_FooClientMessage, rhs: Proto2Unittest_FooClientMessage) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_FooServerMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FooServerMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_FooServerMessage, rhs: Proto2Unittest_FooServerMessage) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_BarRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".BarRequest" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_BarRequest, rhs: Proto2Unittest_BarRequest) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_BarResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".BarResponse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_BarResponse, rhs: Proto2Unittest_BarResponse) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestJsonName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestJsonName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}field_name1\0\u{1}fieldName2\0\u{1}FieldName3\0\u{3}_field_name4\0\u{3}FIELD_NAME5\0\u{5}field_name6\0@type\0\u{1}fieldname7\0") + + 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._fieldName1) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._fieldName2) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._fieldName3) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &self._fieldName4) }() + case 5: try { try decoder.decodeSingularInt32Field(value: &self._fieldName5) }() + case 6: try { try decoder.decodeSingularInt32Field(value: &self._fieldName6) }() + case 7: try { try decoder.decodeSingularInt32Field(value: &self._fieldname7) }() + 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 + try { if let v = self._fieldName1 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._fieldName2 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._fieldName3 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._fieldName4 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try { if let v = self._fieldName5 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = self._fieldName6 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) + } }() + try { if let v = self._fieldname7 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestJsonName, rhs: Proto2Unittest_TestJsonName) -> Bool { + if lhs._fieldName1 != rhs._fieldName1 {return false} + if lhs._fieldName2 != rhs._fieldName2 {return false} + if lhs._fieldName3 != rhs._fieldName3 {return false} + if lhs._fieldName4 != rhs._fieldName4 {return false} + if lhs._fieldName5 != rhs._fieldName5 {return false} + if lhs._fieldName6 != rhs._fieldName6 {return false} + if lhs._fieldname7 != rhs._fieldname7 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestHugeFieldNumbers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestHugeFieldNumbers" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}pq\u{7f}\u{7f}\u{1f}optional_int32\0\u{3}fixed_32\0\u{3}repeated_int32\0\u{3}packed_int32\0\u{3}optional_enum\0\u{3}optional_string\0\u{3}optional_bytes\0\u{3}optional_message\0\u{7}OptionalGroup\0\u{4}\u{2}string_string_map\0\u{3}oneof_uint32\0\u{3}oneof_test_all_types\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}optional_bool\0\u{3}optional_int64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_utf8_string\0\u{3}optional_cord\0\u{3}optional_string_piece\0\u{3}repeated_utf8_string\0") + + fileprivate class _StorageClass { + var _optionalInt32: Int32? = nil + var _fixed32: Int32? = nil + var _repeatedInt32: [Int32] = [] + var _packedInt32: [Int32] = [] + var _optionalEnum: Proto2Unittest_ForeignEnum? = nil + var _optionalString: String? = nil + var _optionalBytes: Data? = nil + var _optionalMessage: Proto2Unittest_ForeignMessage? = nil + var _optionalGroup: Proto2Unittest_TestHugeFieldNumbers.OptionalGroup? = nil + var _stringStringMap: Dictionary = [:] + var _oneofField: Proto2Unittest_TestHugeFieldNumbers.OneOf_OneofField? + var _optionalBool: Bool? = nil + var _optionalInt64: Int64? = nil + var _optionalFloat: Float? = nil + var _optionalDouble: Double? = nil + var _optionalUtf8String: String? = nil + var _optionalCord: String? = nil + var _optionalStringPiece: String? = nil + var _repeatedUtf8String: [String] = [] + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _fixed32 = source._fixed32 + _repeatedInt32 = source._repeatedInt32 + _packedInt32 = source._packedInt32 + _optionalEnum = source._optionalEnum + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalMessage = source._optionalMessage + _optionalGroup = source._optionalGroup + _stringStringMap = source._stringStringMap + _oneofField = source._oneofField + _optionalBool = source._optionalBool + _optionalInt64 = source._optionalInt64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalUtf8String = source._optionalUtf8String + _optionalCord = source._optionalCord + _optionalStringPiece = source._optionalStringPiece + _repeatedUtf8String = source._repeatedUtf8String + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(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 536870000: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalInt32) }() + case 536870001: try { try decoder.decodeSingularInt32Field(value: &_storage._fixed32) }() + case 536870002: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 536870003: try { try decoder.decodeRepeatedInt32Field(value: &_storage._packedInt32) }() + case 536870004: try { try decoder.decodeSingularEnumField(value: &_storage._optionalEnum) }() + case 536870005: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 536870006: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 536870007: try { try decoder.decodeSingularMessageField(value: &_storage._optionalMessage) }() + case 536870008: try { try decoder.decodeSingularGroupField(value: &_storage._optionalGroup) }() + case 536870010: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._stringStringMap) }() + case 536870011: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 536870012: try { + var v: Proto2Unittest_TestAllTypes? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofTestAllTypes(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofTestAllTypes(v) + } + }() + case 536870013: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 536870014: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() + case 536870015: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 536870016: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 536870017: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 536870018: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 536870019: try { try decoder.decodeSingularStringField(value: &_storage._optionalUtf8String) }() + case 536870020: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() + case 536870021: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() + case 536870022: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedUtf8String) }() + case 536860000..<536870000: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestHugeFieldNumbers.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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 visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 536860000, end: 536870000) + try { if let v = _storage._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870000) + } }() + try { if let v = _storage._fixed32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870001) + } }() + if !_storage._repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 536870002) + } + if !_storage._packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._packedInt32, fieldNumber: 536870003) + } + try { if let v = _storage._optionalEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 536870004) + } }() + try { if let v = _storage._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 536870005) + } }() + try { if let v = _storage._optionalBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 536870006) + } }() + try { if let v = _storage._optionalMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 536870007) + } }() + try { if let v = _storage._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 536870008) + } }() + if !_storage._stringStringMap.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._stringStringMap, fieldNumber: 536870010) + } + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 536870011) + }() + case .oneofTestAllTypes?: try { + guard case .oneofTestAllTypes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 536870012) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 536870013) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 536870014) + }() + case nil: break + } + try { if let v = _storage._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 536870015) + } }() + try { if let v = _storage._optionalInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 536870016) + } }() + try { if let v = _storage._optionalFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 536870017) + } }() + try { if let v = _storage._optionalDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 536870018) + } }() + try { if let v = _storage._optionalUtf8String { + try visitor.visitSingularStringField(value: v, fieldNumber: 536870019) + } }() + try { if let v = _storage._optionalCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 536870020) + } }() + try { if let v = _storage._optionalStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 536870021) + } }() + if !_storage._repeatedUtf8String.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedUtf8String, fieldNumber: 536870022) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestHugeFieldNumbers, rhs: Proto2Unittest_TestHugeFieldNumbers) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._fixed32 != rhs_storage._fixed32 {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._packedInt32 != rhs_storage._packedInt32 {return false} + if _storage._optionalEnum != rhs_storage._optionalEnum {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalMessage != rhs_storage._optionalMessage {return false} + if _storage._optionalGroup != rhs_storage._optionalGroup {return false} + if _storage._stringStringMap != rhs_storage._stringStringMap {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalUtf8String != rhs_storage._optionalUtf8String {return false} + if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} + if _storage._repeatedUtf8String != rhs_storage._repeatedUtf8String {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TestHugeFieldNumbers.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestHugeFieldNumbers.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}yq\u{7f}\u{7f}\u{1f}group_a\0") + + 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 536870009: try { try decoder.decodeSingularInt32Field(value: &self._groupA) }() + 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 + try { if let v = self._groupA { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870009) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestHugeFieldNumbers.OptionalGroup, rhs: Proto2Unittest_TestHugeFieldNumbers.OptionalGroup) -> Bool { + if lhs._groupA != rhs._groupA {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestExtensionInsideTable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestExtensionInsideTable" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field1\0\u{1}field2\0\u{1}field3\0\u{1}field4\0\u{2}\u{2}field6\0\u{1}field7\0\u{1}field8\0\u{1}field9\0\u{1}field10\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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._field1) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._field2) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._field3) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &self._field4) }() + case 6: try { try decoder.decodeSingularInt32Field(value: &self._field6) }() + case 7: try { try decoder.decodeSingularInt32Field(value: &self._field7) }() + case 8: try { try decoder.decodeSingularInt32Field(value: &self._field8) }() + case 9: try { try decoder.decodeSingularInt32Field(value: &self._field9) }() + case 10: try { try decoder.decodeSingularInt32Field(value: &self._field10) }() + case 5: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestExtensionInsideTable.self, fieldNumber: fieldNumber) }() + 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 + 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 { if let v = self._field3 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._field4 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 5, end: 6) + try { if let v = self._field6 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) + } }() + try { if let v = self._field7 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) + } }() + try { if let v = self._field8 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 8) + } }() + try { if let v = self._field9 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try { if let v = self._field10 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 10) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestExtensionInsideTable, rhs: Proto2Unittest_TestExtensionInsideTable) -> Bool { + if lhs._field1 != rhs._field1 {return false} + if lhs._field2 != rhs._field2 {return false} + if lhs._field3 != rhs._field3 {return false} + if lhs._field4 != rhs._field4 {return false} + if lhs._field6 != rhs._field6 {return false} + if lhs._field7 != rhs._field7 {return false} + if lhs._field8 != rhs._field8 {return false} + if lhs._field9 != rhs._field9 {return false} + if lhs._field10 != rhs._field10 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TestNestedGroupExtensionOuter: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedGroupExtensionOuter" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{7}Layer1OptionalGroup\0") + + public var isInitialized: Bool { + if let v = self._layer1OptionalGroup, !v.isInitialized {return false} + return true + } + + 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.decodeSingularGroupField(value: &self._layer1OptionalGroup) }() + 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 + try { if let v = self._layer1OptionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestNestedGroupExtensionOuter, rhs: Proto2Unittest_TestNestedGroupExtensionOuter) -> Bool { + if lhs._layer1OptionalGroup != rhs._layer1OptionalGroup {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestNestedGroupExtensionOuter.protoMessageName + ".Layer1OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{8}\u{2}Layer2RepeatedGroup\0\u{8}\u{2}Layer2AnotherOptionalRepeatedGroup\0") + + public var isInitialized: Bool { + if !SwiftProtobuf.Internal.areAllInitialized(self.layer2RepeatedGroup) {return false} + return true + } + + 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 2: try { try decoder.decodeRepeatedGroupField(value: &self.layer2RepeatedGroup) }() + case 4: try { try decoder.decodeRepeatedGroupField(value: &self.layer2AnotherOptionalRepeatedGroup) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.layer2RepeatedGroup.isEmpty { + try visitor.visitRepeatedGroupField(value: self.layer2RepeatedGroup, fieldNumber: 2) + } + if !self.layer2AnotherOptionalRepeatedGroup.isEmpty { + try visitor.visitRepeatedGroupField(value: self.layer2AnotherOptionalRepeatedGroup, fieldNumber: 4) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup, rhs: Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup) -> Bool { + if lhs.layer2RepeatedGroup != rhs.layer2RepeatedGroup {return false} + if lhs.layer2AnotherOptionalRepeatedGroup != rhs.layer2AnotherOptionalRepeatedGroup {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.protoMessageName + ".Layer2RepeatedGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{6}another_field\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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 6: try { try decoder.decodeSingularStringField(value: &self._anotherField) }() + case 3: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2RepeatedGroup.self, fieldNumber: fieldNumber) }() + 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 + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 3, end: 4) + try { if let v = self._anotherField { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2RepeatedGroup, rhs: Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2RepeatedGroup) -> Bool { + if lhs._anotherField != rhs._anotherField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2AnotherOptionalRepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.protoMessageName + ".Layer2AnotherOptionalRepeatedGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{5}but_why_tho\0") + + 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 5: try { try decoder.decodeSingularStringField(value: &self._butWhyTho) }() + 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 + try { if let v = self._butWhyTho { + try visitor.visitSingularStringField(value: v, fieldNumber: 5) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2AnotherOptionalRepeatedGroup, rhs: Proto2Unittest_TestNestedGroupExtensionOuter.Layer1OptionalGroup.Layer2AnotherOptionalRepeatedGroup) -> Bool { + if lhs._butWhyTho != rhs._butWhyTho {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestNestedGroupExtensionInnerExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedGroupExtensionInnerExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}inner_name\0") + + 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._innerName) }() + 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 + try { if let v = self._innerName { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestNestedGroupExtensionInnerExtension, rhs: Proto2Unittest_TestNestedGroupExtensionInnerExtension) -> Bool { + if lhs._innerName != rhs._innerName {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestExtensionRangeSerialize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestExtensionRangeSerialize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}foo_one\0\u{4}\u{5}foo_two\0\u{3}foo_three\0\u{4}\u{6}foo_four\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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._fooOne) }() + case 6: try { try decoder.decodeSingularInt32Field(value: &self._fooTwo) }() + case 7: try { try decoder.decodeSingularInt32Field(value: &self._fooThree) }() + case 13: try { try decoder.decodeSingularInt32Field(value: &self._fooFour) }() + case 2..<5, 9..<11, 15, 17, 19: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestExtensionRangeSerialize.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._fooOne { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2, end: 5) + try { if let v = self._fooTwo { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) + } }() + try { if let v = self._fooThree { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 9, end: 11) + try { if let v = self._fooFour { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 13) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 15, end: 20) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestExtensionRangeSerialize, rhs: Proto2Unittest_TestExtensionRangeSerialize) -> Bool { + if lhs._fooOne != rhs._fooOne {return false} + if lhs._fooTwo != rhs._fooTwo {return false} + if lhs._fooThree != rhs._fooThree {return false} + if lhs._fooFour != rhs._fooFour {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TestVerifyInt32Simple: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyInt32Simple" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32_1\0\u{3}optional_int32_2\0\u{4}=optional_int32_63\0\u{3}optional_int32_64\0") + + 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._optionalInt321) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt322) }() + case 63: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3263) }() + case 64: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3264) }() + 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 + try { if let v = self._optionalInt321 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalInt322 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalInt3263 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalInt3264 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 64) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestVerifyInt32Simple, rhs: Proto2Unittest_TestVerifyInt32Simple) -> Bool { + if lhs._optionalInt321 != rhs._optionalInt321 {return false} + if lhs._optionalInt322 != rhs._optionalInt322 {return false} + if lhs._optionalInt3263 != rhs._optionalInt3263 {return false} + if lhs._optionalInt3264 != rhs._optionalInt3264 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestVerifyInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyInt32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32_1\0\u{3}optional_int32_2\0\u{4}\u{7}optional_all_types\0\u{3}repeated_all_types\0\u{4}5optional_int32_63\0\u{3}optional_int32_64\0") + + 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._optionalInt321) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt322) }() + case 9: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 63: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3263) }() + case 64: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3264) }() + 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 + try { if let v = self._optionalInt321 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalInt322 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 10) + } + try { if let v = self._optionalInt3263 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalInt3264 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 64) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestVerifyInt32, rhs: Proto2Unittest_TestVerifyInt32) -> Bool { + if lhs._optionalInt321 != rhs._optionalInt321 {return false} + if lhs._optionalInt322 != rhs._optionalInt322 {return false} + if lhs._optionalInt3263 != rhs._optionalInt3263 {return false} + if lhs._optionalInt3264 != rhs._optionalInt3264 {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestVerifyMostlyInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyMostlyInt32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32_1\0\u{3}optional_int32_2\0\u{3}optional_int32_3\0\u{3}optional_int32_4\0\u{4}\u{5}optional_all_types\0\u{3}repeated_all_types\0\u{4}\u{14}optional_int64_30\0\u{4}!optional_int32_63\0\u{3}optional_int32_64\0") + + 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._optionalInt321) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt322) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt323) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt324) }() + case 9: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 30: try { try decoder.decodeSingularInt64Field(value: &self._optionalInt6430) }() + case 63: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3263) }() + case 64: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3264) }() + 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 + try { if let v = self._optionalInt321 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalInt322 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalInt323 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._optionalInt324 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 10) + } + try { if let v = self._optionalInt6430 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 30) + } }() + try { if let v = self._optionalInt3263 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalInt3264 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 64) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestVerifyMostlyInt32, rhs: Proto2Unittest_TestVerifyMostlyInt32) -> Bool { + if lhs._optionalInt6430 != rhs._optionalInt6430 {return false} + if lhs._optionalInt321 != rhs._optionalInt321 {return false} + if lhs._optionalInt322 != rhs._optionalInt322 {return false} + if lhs._optionalInt323 != rhs._optionalInt323 {return false} + if lhs._optionalInt324 != rhs._optionalInt324 {return false} + if lhs._optionalInt3263 != rhs._optionalInt3263 {return false} + if lhs._optionalInt3264 != rhs._optionalInt3264 {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestVerifyMostlyInt32BigFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyMostlyInt32BigFieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32_1\0\u{3}optional_int32_2\0\u{3}optional_int32_3\0\u{3}optional_int32_4\0\u{4}\u{5}optional_all_types\0\u{3}repeated_all_types\0\u{4}\u{14}optional_int64_30\0\u{4}!optional_int32_63\0\u{3}optional_int32_64\0\u{4}l\u{3}optional_int32_300\0") + + 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._optionalInt321) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt322) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt323) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt324) }() + case 9: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 30: try { try decoder.decodeSingularInt64Field(value: &self._optionalInt6430) }() + case 63: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3263) }() + case 64: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3264) }() + case 300: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32300) }() + 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 + try { if let v = self._optionalInt321 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalInt322 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalInt323 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._optionalInt324 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 10) + } + try { if let v = self._optionalInt6430 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 30) + } }() + try { if let v = self._optionalInt3263 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalInt3264 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 64) + } }() + try { if let v = self._optionalInt32300 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 300) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestVerifyMostlyInt32BigFieldNumber, rhs: Proto2Unittest_TestVerifyMostlyInt32BigFieldNumber) -> Bool { + if lhs._optionalInt6430 != rhs._optionalInt6430 {return false} + if lhs._optionalInt32300 != rhs._optionalInt32300 {return false} + if lhs._optionalInt321 != rhs._optionalInt321 {return false} + if lhs._optionalInt322 != rhs._optionalInt322 {return false} + if lhs._optionalInt323 != rhs._optionalInt323 {return false} + if lhs._optionalInt324 != rhs._optionalInt324 {return false} + if lhs._optionalInt3263 != rhs._optionalInt3263 {return false} + if lhs._optionalInt3264 != rhs._optionalInt3264 {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestVerifyUint32Simple: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyUint32Simple" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_uint32_1\0\u{3}optional_uint32_2\0\u{4}=optional_uint32_63\0\u{3}optional_uint32_64\0") + + 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._optionalUint321) }() + case 2: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint322) }() + case 63: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint3263) }() + case 64: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint3264) }() + 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 + try { if let v = self._optionalUint321 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalUint322 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalUint3263 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalUint3264 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 64) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestVerifyUint32Simple, rhs: Proto2Unittest_TestVerifyUint32Simple) -> Bool { + if lhs._optionalUint321 != rhs._optionalUint321 {return false} + if lhs._optionalUint322 != rhs._optionalUint322 {return false} + if lhs._optionalUint3263 != rhs._optionalUint3263 {return false} + if lhs._optionalUint3264 != rhs._optionalUint3264 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestVerifyUint32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyUint32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_uint32_1\0\u{3}optional_uint32_2\0\u{4}\u{7}optional_all_types\0\u{3}repeated_all_types\0\u{4}5optional_uint32_63\0\u{3}optional_uint32_64\0") + + 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._optionalUint321) }() + case 2: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint322) }() + case 9: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 63: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint3263) }() + case 64: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint3264) }() + 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 + try { if let v = self._optionalUint321 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalUint322 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 10) + } + try { if let v = self._optionalUint3263 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalUint3264 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 64) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestVerifyUint32, rhs: Proto2Unittest_TestVerifyUint32) -> Bool { + if lhs._optionalUint321 != rhs._optionalUint321 {return false} + if lhs._optionalUint322 != rhs._optionalUint322 {return false} + if lhs._optionalUint3263 != rhs._optionalUint3263 {return false} + if lhs._optionalUint3264 != rhs._optionalUint3264 {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestVerifyOneUint32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyOneUint32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_uint32_1\0\u{3}optional_int32_2\0\u{4}\u{7}optional_all_types\0\u{3}repeated_all_types\0\u{4}5optional_int32_63\0\u{3}optional_int32_64\0") + + 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._optionalUint321) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt322) }() + case 9: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 63: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3263) }() + case 64: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3264) }() + 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 + try { if let v = self._optionalUint321 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalInt322 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 10) + } + try { if let v = self._optionalInt3263 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalInt3264 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 64) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestVerifyOneUint32, rhs: Proto2Unittest_TestVerifyOneUint32) -> Bool { + if lhs._optionalUint321 != rhs._optionalUint321 {return false} + if lhs._optionalInt322 != rhs._optionalInt322 {return false} + if lhs._optionalInt3263 != rhs._optionalInt3263 {return false} + if lhs._optionalInt3264 != rhs._optionalInt3264 {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestVerifyOneInt32BigFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyOneInt32BigFieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int64_1\0\u{3}optional_int64_2\0\u{4}\u{7}optional_all_types\0\u{3}repeated_all_types\0\u{4}5optional_int64_63\0\u{3}optional_int64_64\0\u{3}optional_int32_65\0") + + 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.decodeSingularInt64Field(value: &self._optionalInt641) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &self._optionalInt642) }() + case 9: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 63: try { try decoder.decodeSingularInt64Field(value: &self._optionalInt6463) }() + case 64: try { try decoder.decodeSingularInt64Field(value: &self._optionalInt6464) }() + case 65: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3265) }() + 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 + try { if let v = self._optionalInt641 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalInt642 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 10) + } + try { if let v = self._optionalInt6463 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalInt6464 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 64) + } }() + try { if let v = self._optionalInt3265 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 65) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestVerifyOneInt32BigFieldNumber, rhs: Proto2Unittest_TestVerifyOneInt32BigFieldNumber) -> Bool { + if lhs._optionalInt3265 != rhs._optionalInt3265 {return false} + if lhs._optionalInt641 != rhs._optionalInt641 {return false} + if lhs._optionalInt642 != rhs._optionalInt642 {return false} + if lhs._optionalInt6463 != rhs._optionalInt6463 {return false} + if lhs._optionalInt6464 != rhs._optionalInt6464 {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestVerifyInt32BigFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyInt32BigFieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32_1\0\u{3}optional_int32_2\0\u{4}\u{7}optional_all_types\0\u{3}repeated_all_types\0\u{4}5optional_int32_63\0\u{3}optional_int32_64\0\u{3}optional_int32_65\0\u{4}g\u{e}optional_int32_1000\0") + + 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._optionalInt321) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt322) }() + case 9: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 63: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3263) }() + case 64: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3264) }() + case 65: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt3265) }() + case 1000: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt321000) }() + 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 + try { if let v = self._optionalInt321 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalInt322 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 10) + } + try { if let v = self._optionalInt3263 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalInt3264 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 64) + } }() + try { if let v = self._optionalInt3265 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 65) + } }() + try { if let v = self._optionalInt321000 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1000) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestVerifyInt32BigFieldNumber, rhs: Proto2Unittest_TestVerifyInt32BigFieldNumber) -> Bool { + if lhs._optionalInt321000 != rhs._optionalInt321000 {return false} + if lhs._optionalInt3265 != rhs._optionalInt3265 {return false} + if lhs._optionalInt321 != rhs._optionalInt321 {return false} + if lhs._optionalInt322 != rhs._optionalInt322 {return false} + if lhs._optionalInt3263 != rhs._optionalInt3263 {return false} + if lhs._optionalInt3264 != rhs._optionalInt3264 {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestVerifyUint32BigFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyUint32BigFieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_uint32_1\0\u{3}optional_uint32_2\0\u{4}\u{7}optional_all_types\0\u{3}repeated_all_types\0\u{4}5optional_uint32_63\0\u{3}optional_uint32_64\0\u{3}optional_uint32_65\0\u{4}g\u{e}optional_uint32_1000\0") + + 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._optionalUint321) }() + case 2: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint322) }() + case 9: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 63: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint3263) }() + case 64: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint3264) }() + case 65: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint3265) }() + case 1000: try { try decoder.decodeSingularUInt32Field(value: &self._optionalUint321000) }() + 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 + try { if let v = self._optionalUint321 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalUint322 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 10) + } + try { if let v = self._optionalUint3263 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = self._optionalUint3264 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 64) + } }() + try { if let v = self._optionalUint3265 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 65) + } }() + try { if let v = self._optionalUint321000 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1000) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestVerifyUint32BigFieldNumber, rhs: Proto2Unittest_TestVerifyUint32BigFieldNumber) -> Bool { + if lhs._optionalUint321000 != rhs._optionalUint321000 {return false} + if lhs._optionalUint3265 != rhs._optionalUint3265 {return false} + if lhs._optionalUint321 != rhs._optionalUint321 {return false} + if lhs._optionalUint322 != rhs._optionalUint322 {return false} + if lhs._optionalUint3263 != rhs._optionalUint3263 {return false} + if lhs._optionalUint3264 != rhs._optionalUint3264 {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestVerifyBigFieldNumberUint32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestVerifyBigFieldNumberUint32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_nested\0") + + 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.decodeSingularMessageField(value: &self._optionalNested) }() + 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 + try { if let v = self._optionalNested { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestVerifyBigFieldNumberUint32, rhs: Proto2Unittest_TestVerifyBigFieldNumberUint32) -> Bool { + if lhs._optionalNested != rhs._optionalNested {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestVerifyBigFieldNumberUint32.Nested: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestVerifyBigFieldNumberUint32.protoMessageName + ".Nested" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_uint32_1\0\u{3}optional_uint32_2\0\u{4}\u{7}optional_nested\0\u{3}repeated_nested\0\u{4}5optional_uint32_63\0\u{3}optional_uint32_64\0\u{3}optional_uint32_65\0\u{3}optional_uint32_66\0\u{4}f\u{e}optional_uint32_1000\0\u{4}`>optional_uint32_5000\0") + + fileprivate class _StorageClass { + var _optionalUint325000: UInt32? = nil + var _optionalUint321000: UInt32? = nil + var _optionalUint3266: UInt32? = nil + var _optionalUint3265: UInt32? = nil + var _optionalUint321: UInt32? = nil + var _optionalUint322: UInt32? = nil + var _optionalUint3263: UInt32? = nil + var _optionalUint3264: UInt32? = nil + var _optionalNested: Proto2Unittest_TestVerifyBigFieldNumberUint32.Nested? = nil + var _repeatedNested: [Proto2Unittest_TestVerifyBigFieldNumberUint32.Nested] = [] + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalUint325000 = source._optionalUint325000 + _optionalUint321000 = source._optionalUint321000 + _optionalUint3266 = source._optionalUint3266 + _optionalUint3265 = source._optionalUint3265 + _optionalUint321 = source._optionalUint321 + _optionalUint322 = source._optionalUint322 + _optionalUint3263 = source._optionalUint3263 + _optionalUint3264 = source._optionalUint3264 + _optionalNested = source._optionalNested + _repeatedNested = source._repeatedNested + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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.decodeSingularUInt32Field(value: &_storage._optionalUint321) }() + case 2: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint322) }() + case 9: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNested) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNested) }() + case 63: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint3263) }() + case 64: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint3264) }() + case 65: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint3265) }() + case 66: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint3266) }() + case 1000: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint321000) }() + case 5000: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint325000) }() + default: break + } + } + } + } + + func traverse(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._optionalUint321 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._optionalUint322 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalNested { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + if !_storage._repeatedNested.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNested, fieldNumber: 10) + } + try { if let v = _storage._optionalUint3263 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = _storage._optionalUint3264 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 64) + } }() + try { if let v = _storage._optionalUint3265 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 65) + } }() + try { if let v = _storage._optionalUint3266 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 66) + } }() + try { if let v = _storage._optionalUint321000 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1000) + } }() + try { if let v = _storage._optionalUint325000 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 5000) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestVerifyBigFieldNumberUint32.Nested, rhs: Proto2Unittest_TestVerifyBigFieldNumberUint32.Nested) -> 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._optionalUint325000 != rhs_storage._optionalUint325000 {return false} + if _storage._optionalUint321000 != rhs_storage._optionalUint321000 {return false} + if _storage._optionalUint3266 != rhs_storage._optionalUint3266 {return false} + if _storage._optionalUint3265 != rhs_storage._optionalUint3265 {return false} + if _storage._optionalUint321 != rhs_storage._optionalUint321 {return false} + if _storage._optionalUint322 != rhs_storage._optionalUint322 {return false} + if _storage._optionalUint3263 != rhs_storage._optionalUint3263 {return false} + if _storage._optionalUint3264 != rhs_storage._optionalUint3264 {return false} + if _storage._optionalNested != rhs_storage._optionalNested {return false} + if _storage._repeatedNested != rhs_storage._repeatedNested {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_EnumParseTester: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumParseTester" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_seq_small_0_lowfield\0\u{3}repeated_seq_small_0_lowfield\0\u{3}packed_seq_small_0_lowfield\0\u{3}optional_seq_small_1_lowfield\0\u{3}repeated_seq_small_1_lowfield\0\u{3}packed_seq_small_1_lowfield\0\u{3}optional_seq_large_lowfield\0\u{3}repeated_seq_large_lowfield\0\u{3}packed_seq_large_lowfield\0\u{3}optional_arbitrary_lowfield\0\u{3}repeated_arbitrary_lowfield\0\u{3}packed_arbitrary_lowfield\0\u{4}W\u{1}other_field\0\u{4}F\u{e}optional_seq_small_0_midfield\0\u{3}repeated_seq_small_0_midfield\0\u{3}packed_seq_small_0_midfield\0\u{3}optional_seq_small_1_midfield\0\u{3}repeated_seq_small_1_midfield\0\u{3}packed_seq_small_1_midfield\0\u{3}optional_seq_large_midfield\0\u{3}repeated_seq_large_midfield\0\u{3}packed_seq_large_midfield\0\u{3}optional_arbitrary_midfield\0\u{3}repeated_arbitrary_midfield\0\u{3}packed_arbitrary_midfield\0\u{4}Mys\u{3}optional_seq_small_0_hifield\0\u{3}repeated_seq_small_0_hifield\0\u{3}packed_seq_small_0_hifield\0\u{3}optional_seq_small_1_hifield\0\u{3}repeated_seq_small_1_hifield\0\u{3}packed_seq_small_1_hifield\0\u{3}optional_seq_large_hifield\0\u{3}repeated_seq_large_hifield\0\u{3}packed_seq_large_hifield\0\u{3}optional_arbitrary_hifield\0\u{3}repeated_arbitrary_hifield\0\u{3}packed_arbitrary_hifield\0") + + fileprivate class _StorageClass { + var _optionalSeqSmall0Lowfield: Proto2Unittest_EnumParseTester.SeqSmall0? = nil + var _optionalSeqSmall0Midfield: Proto2Unittest_EnumParseTester.SeqSmall0? = nil + var _optionalSeqSmall0Hifield: Proto2Unittest_EnumParseTester.SeqSmall0? = nil + var _repeatedSeqSmall0Lowfield: [Proto2Unittest_EnumParseTester.SeqSmall0] = [] + var _repeatedSeqSmall0Midfield: [Proto2Unittest_EnumParseTester.SeqSmall0] = [] + var _repeatedSeqSmall0Hifield: [Proto2Unittest_EnumParseTester.SeqSmall0] = [] + var _packedSeqSmall0Lowfield: [Proto2Unittest_EnumParseTester.SeqSmall0] = [] + var _packedSeqSmall0Midfield: [Proto2Unittest_EnumParseTester.SeqSmall0] = [] + var _packedSeqSmall0Hifield: [Proto2Unittest_EnumParseTester.SeqSmall0] = [] + var _optionalSeqSmall1Lowfield: Proto2Unittest_EnumParseTester.SeqSmall1? = nil + var _optionalSeqSmall1Midfield: Proto2Unittest_EnumParseTester.SeqSmall1? = nil + var _optionalSeqSmall1Hifield: Proto2Unittest_EnumParseTester.SeqSmall1? = nil + var _repeatedSeqSmall1Lowfield: [Proto2Unittest_EnumParseTester.SeqSmall1] = [] + var _repeatedSeqSmall1Midfield: [Proto2Unittest_EnumParseTester.SeqSmall1] = [] + var _repeatedSeqSmall1Hifield: [Proto2Unittest_EnumParseTester.SeqSmall1] = [] + var _packedSeqSmall1Lowfield: [Proto2Unittest_EnumParseTester.SeqSmall1] = [] + var _packedSeqSmall1Midfield: [Proto2Unittest_EnumParseTester.SeqSmall1] = [] + var _packedSeqSmall1Hifield: [Proto2Unittest_EnumParseTester.SeqSmall1] = [] + var _optionalSeqLargeLowfield: Proto2Unittest_EnumParseTester.SeqLarge? = nil + var _optionalSeqLargeMidfield: Proto2Unittest_EnumParseTester.SeqLarge? = nil + var _optionalSeqLargeHifield: Proto2Unittest_EnumParseTester.SeqLarge? = nil + var _repeatedSeqLargeLowfield: [Proto2Unittest_EnumParseTester.SeqLarge] = [] + var _repeatedSeqLargeMidfield: [Proto2Unittest_EnumParseTester.SeqLarge] = [] + var _repeatedSeqLargeHifield: [Proto2Unittest_EnumParseTester.SeqLarge] = [] + var _packedSeqLargeLowfield: [Proto2Unittest_EnumParseTester.SeqLarge] = [] + var _packedSeqLargeMidfield: [Proto2Unittest_EnumParseTester.SeqLarge] = [] + var _packedSeqLargeHifield: [Proto2Unittest_EnumParseTester.SeqLarge] = [] + var _optionalArbitraryLowfield: Proto2Unittest_EnumParseTester.Arbitrary? = nil + var _optionalArbitraryMidfield: Proto2Unittest_EnumParseTester.Arbitrary? = nil + var _optionalArbitraryHifield: Proto2Unittest_EnumParseTester.Arbitrary? = nil + var _repeatedArbitraryLowfield: [Proto2Unittest_EnumParseTester.Arbitrary] = [] + var _repeatedArbitraryMidfield: [Proto2Unittest_EnumParseTester.Arbitrary] = [] + var _repeatedArbitraryHifield: [Proto2Unittest_EnumParseTester.Arbitrary] = [] + var _packedArbitraryLowfield: [Proto2Unittest_EnumParseTester.Arbitrary] = [] + var _packedArbitraryMidfield: [Proto2Unittest_EnumParseTester.Arbitrary] = [] + var _packedArbitraryHifield: [Proto2Unittest_EnumParseTester.Arbitrary] = [] + var _otherField: Int32? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalSeqSmall0Lowfield = source._optionalSeqSmall0Lowfield + _optionalSeqSmall0Midfield = source._optionalSeqSmall0Midfield + _optionalSeqSmall0Hifield = source._optionalSeqSmall0Hifield + _repeatedSeqSmall0Lowfield = source._repeatedSeqSmall0Lowfield + _repeatedSeqSmall0Midfield = source._repeatedSeqSmall0Midfield + _repeatedSeqSmall0Hifield = source._repeatedSeqSmall0Hifield + _packedSeqSmall0Lowfield = source._packedSeqSmall0Lowfield + _packedSeqSmall0Midfield = source._packedSeqSmall0Midfield + _packedSeqSmall0Hifield = source._packedSeqSmall0Hifield + _optionalSeqSmall1Lowfield = source._optionalSeqSmall1Lowfield + _optionalSeqSmall1Midfield = source._optionalSeqSmall1Midfield + _optionalSeqSmall1Hifield = source._optionalSeqSmall1Hifield + _repeatedSeqSmall1Lowfield = source._repeatedSeqSmall1Lowfield + _repeatedSeqSmall1Midfield = source._repeatedSeqSmall1Midfield + _repeatedSeqSmall1Hifield = source._repeatedSeqSmall1Hifield + _packedSeqSmall1Lowfield = source._packedSeqSmall1Lowfield + _packedSeqSmall1Midfield = source._packedSeqSmall1Midfield + _packedSeqSmall1Hifield = source._packedSeqSmall1Hifield + _optionalSeqLargeLowfield = source._optionalSeqLargeLowfield + _optionalSeqLargeMidfield = source._optionalSeqLargeMidfield + _optionalSeqLargeHifield = source._optionalSeqLargeHifield + _repeatedSeqLargeLowfield = source._repeatedSeqLargeLowfield + _repeatedSeqLargeMidfield = source._repeatedSeqLargeMidfield + _repeatedSeqLargeHifield = source._repeatedSeqLargeHifield + _packedSeqLargeLowfield = source._packedSeqLargeLowfield + _packedSeqLargeMidfield = source._packedSeqLargeMidfield + _packedSeqLargeHifield = source._packedSeqLargeHifield + _optionalArbitraryLowfield = source._optionalArbitraryLowfield + _optionalArbitraryMidfield = source._optionalArbitraryMidfield + _optionalArbitraryHifield = source._optionalArbitraryHifield + _repeatedArbitraryLowfield = source._repeatedArbitraryLowfield + _repeatedArbitraryMidfield = source._repeatedArbitraryMidfield + _repeatedArbitraryHifield = source._repeatedArbitraryHifield + _packedArbitraryLowfield = source._packedArbitraryLowfield + _packedArbitraryMidfield = source._packedArbitraryMidfield + _packedArbitraryHifield = source._packedArbitraryHifield + _otherField = source._otherField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(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.decodeSingularEnumField(value: &_storage._optionalSeqSmall0Lowfield) }() + case 2: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedSeqSmall0Lowfield) }() + case 3: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedSeqSmall0Lowfield) }() + case 4: try { try decoder.decodeSingularEnumField(value: &_storage._optionalSeqSmall1Lowfield) }() + case 5: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedSeqSmall1Lowfield) }() + case 6: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedSeqSmall1Lowfield) }() + case 7: try { try decoder.decodeSingularEnumField(value: &_storage._optionalSeqLargeLowfield) }() + case 8: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedSeqLargeLowfield) }() + case 9: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedSeqLargeLowfield) }() + case 10: try { try decoder.decodeSingularEnumField(value: &_storage._optionalArbitraryLowfield) }() + case 11: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedArbitraryLowfield) }() + case 12: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedArbitraryLowfield) }() + case 99: try { try decoder.decodeSingularInt32Field(value: &_storage._otherField) }() + case 1001: try { try decoder.decodeSingularEnumField(value: &_storage._optionalSeqSmall0Midfield) }() + case 1002: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedSeqSmall0Midfield) }() + case 1003: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedSeqSmall0Midfield) }() + case 1004: try { try decoder.decodeSingularEnumField(value: &_storage._optionalSeqSmall1Midfield) }() + case 1005: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedSeqSmall1Midfield) }() + case 1006: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedSeqSmall1Midfield) }() + case 1007: try { try decoder.decodeSingularEnumField(value: &_storage._optionalSeqLargeMidfield) }() + case 1008: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedSeqLargeMidfield) }() + case 1009: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedSeqLargeMidfield) }() + case 1010: try { try decoder.decodeSingularEnumField(value: &_storage._optionalArbitraryMidfield) }() + case 1011: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedArbitraryMidfield) }() + case 1012: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedArbitraryMidfield) }() + case 1000001: try { try decoder.decodeSingularEnumField(value: &_storage._optionalSeqSmall0Hifield) }() + case 1000002: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedSeqSmall0Hifield) }() + case 1000003: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedSeqSmall0Hifield) }() + case 1000004: try { try decoder.decodeSingularEnumField(value: &_storage._optionalSeqSmall1Hifield) }() + case 1000005: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedSeqSmall1Hifield) }() + case 1000006: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedSeqSmall1Hifield) }() + case 1000007: try { try decoder.decodeSingularEnumField(value: &_storage._optionalSeqLargeHifield) }() + case 1000008: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedSeqLargeHifield) }() + case 1000009: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedSeqLargeHifield) }() + case 1000010: try { try decoder.decodeSingularEnumField(value: &_storage._optionalArbitraryHifield) }() + case 1000011: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedArbitraryHifield) }() + case 1000012: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedArbitraryHifield) }() + case 2000000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_EnumParseTester.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._optionalSeqSmall0Lowfield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + if !_storage._repeatedSeqSmall0Lowfield.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedSeqSmall0Lowfield, fieldNumber: 2) + } + if !_storage._packedSeqSmall0Lowfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedSeqSmall0Lowfield, fieldNumber: 3) + } + try { if let v = _storage._optionalSeqSmall1Lowfield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + if !_storage._repeatedSeqSmall1Lowfield.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedSeqSmall1Lowfield, fieldNumber: 5) + } + if !_storage._packedSeqSmall1Lowfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedSeqSmall1Lowfield, fieldNumber: 6) + } + try { if let v = _storage._optionalSeqLargeLowfield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 7) + } }() + if !_storage._repeatedSeqLargeLowfield.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedSeqLargeLowfield, fieldNumber: 8) + } + if !_storage._packedSeqLargeLowfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedSeqLargeLowfield, fieldNumber: 9) + } + try { if let v = _storage._optionalArbitraryLowfield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 10) + } }() + if !_storage._repeatedArbitraryLowfield.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedArbitraryLowfield, fieldNumber: 11) + } + if !_storage._packedArbitraryLowfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedArbitraryLowfield, fieldNumber: 12) + } + try { if let v = _storage._otherField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 99) + } }() + try { if let v = _storage._optionalSeqSmall0Midfield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1001) + } }() + if !_storage._repeatedSeqSmall0Midfield.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedSeqSmall0Midfield, fieldNumber: 1002) + } + if !_storage._packedSeqSmall0Midfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedSeqSmall0Midfield, fieldNumber: 1003) + } + try { if let v = _storage._optionalSeqSmall1Midfield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1004) + } }() + if !_storage._repeatedSeqSmall1Midfield.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedSeqSmall1Midfield, fieldNumber: 1005) + } + if !_storage._packedSeqSmall1Midfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedSeqSmall1Midfield, fieldNumber: 1006) + } + try { if let v = _storage._optionalSeqLargeMidfield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1007) + } }() + if !_storage._repeatedSeqLargeMidfield.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedSeqLargeMidfield, fieldNumber: 1008) + } + if !_storage._packedSeqLargeMidfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedSeqLargeMidfield, fieldNumber: 1009) + } + try { if let v = _storage._optionalArbitraryMidfield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1010) + } }() + if !_storage._repeatedArbitraryMidfield.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedArbitraryMidfield, fieldNumber: 1011) + } + if !_storage._packedArbitraryMidfield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedArbitraryMidfield, fieldNumber: 1012) + } + try { if let v = _storage._optionalSeqSmall0Hifield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1000001) + } }() + if !_storage._repeatedSeqSmall0Hifield.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedSeqSmall0Hifield, fieldNumber: 1000002) + } + if !_storage._packedSeqSmall0Hifield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedSeqSmall0Hifield, fieldNumber: 1000003) + } + try { if let v = _storage._optionalSeqSmall1Hifield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1000004) + } }() + if !_storage._repeatedSeqSmall1Hifield.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedSeqSmall1Hifield, fieldNumber: 1000005) + } + if !_storage._packedSeqSmall1Hifield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedSeqSmall1Hifield, fieldNumber: 1000006) + } + try { if let v = _storage._optionalSeqLargeHifield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1000007) + } }() + if !_storage._repeatedSeqLargeHifield.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedSeqLargeHifield, fieldNumber: 1000008) + } + if !_storage._packedSeqLargeHifield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedSeqLargeHifield, fieldNumber: 1000009) + } + try { if let v = _storage._optionalArbitraryHifield { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1000010) + } }() + if !_storage._repeatedArbitraryHifield.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedArbitraryHifield, fieldNumber: 1000011) + } + if !_storage._packedArbitraryHifield.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedArbitraryHifield, fieldNumber: 1000012) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2000000, end: 536870912) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_EnumParseTester, rhs: Proto2Unittest_EnumParseTester) -> 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._optionalSeqSmall0Lowfield != rhs_storage._optionalSeqSmall0Lowfield {return false} + if _storage._optionalSeqSmall0Midfield != rhs_storage._optionalSeqSmall0Midfield {return false} + if _storage._optionalSeqSmall0Hifield != rhs_storage._optionalSeqSmall0Hifield {return false} + if _storage._repeatedSeqSmall0Lowfield != rhs_storage._repeatedSeqSmall0Lowfield {return false} + if _storage._repeatedSeqSmall0Midfield != rhs_storage._repeatedSeqSmall0Midfield {return false} + if _storage._repeatedSeqSmall0Hifield != rhs_storage._repeatedSeqSmall0Hifield {return false} + if _storage._packedSeqSmall0Lowfield != rhs_storage._packedSeqSmall0Lowfield {return false} + if _storage._packedSeqSmall0Midfield != rhs_storage._packedSeqSmall0Midfield {return false} + if _storage._packedSeqSmall0Hifield != rhs_storage._packedSeqSmall0Hifield {return false} + if _storage._optionalSeqSmall1Lowfield != rhs_storage._optionalSeqSmall1Lowfield {return false} + if _storage._optionalSeqSmall1Midfield != rhs_storage._optionalSeqSmall1Midfield {return false} + if _storage._optionalSeqSmall1Hifield != rhs_storage._optionalSeqSmall1Hifield {return false} + if _storage._repeatedSeqSmall1Lowfield != rhs_storage._repeatedSeqSmall1Lowfield {return false} + if _storage._repeatedSeqSmall1Midfield != rhs_storage._repeatedSeqSmall1Midfield {return false} + if _storage._repeatedSeqSmall1Hifield != rhs_storage._repeatedSeqSmall1Hifield {return false} + if _storage._packedSeqSmall1Lowfield != rhs_storage._packedSeqSmall1Lowfield {return false} + if _storage._packedSeqSmall1Midfield != rhs_storage._packedSeqSmall1Midfield {return false} + if _storage._packedSeqSmall1Hifield != rhs_storage._packedSeqSmall1Hifield {return false} + if _storage._optionalSeqLargeLowfield != rhs_storage._optionalSeqLargeLowfield {return false} + if _storage._optionalSeqLargeMidfield != rhs_storage._optionalSeqLargeMidfield {return false} + if _storage._optionalSeqLargeHifield != rhs_storage._optionalSeqLargeHifield {return false} + if _storage._repeatedSeqLargeLowfield != rhs_storage._repeatedSeqLargeLowfield {return false} + if _storage._repeatedSeqLargeMidfield != rhs_storage._repeatedSeqLargeMidfield {return false} + if _storage._repeatedSeqLargeHifield != rhs_storage._repeatedSeqLargeHifield {return false} + if _storage._packedSeqLargeLowfield != rhs_storage._packedSeqLargeLowfield {return false} + if _storage._packedSeqLargeMidfield != rhs_storage._packedSeqLargeMidfield {return false} + if _storage._packedSeqLargeHifield != rhs_storage._packedSeqLargeHifield {return false} + if _storage._optionalArbitraryLowfield != rhs_storage._optionalArbitraryLowfield {return false} + if _storage._optionalArbitraryMidfield != rhs_storage._optionalArbitraryMidfield {return false} + if _storage._optionalArbitraryHifield != rhs_storage._optionalArbitraryHifield {return false} + if _storage._repeatedArbitraryLowfield != rhs_storage._repeatedArbitraryLowfield {return false} + if _storage._repeatedArbitraryMidfield != rhs_storage._repeatedArbitraryMidfield {return false} + if _storage._repeatedArbitraryHifield != rhs_storage._repeatedArbitraryHifield {return false} + if _storage._packedArbitraryLowfield != rhs_storage._packedArbitraryLowfield {return false} + if _storage._packedArbitraryMidfield != rhs_storage._packedArbitraryMidfield {return false} + if _storage._packedArbitraryHifield != rhs_storage._packedArbitraryHifield {return false} + if _storage._otherField != rhs_storage._otherField {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_EnumParseTester.SeqSmall0: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0SEQ_SMALL_0_DEFAULT\0\u{1}SEQ_SMALL_0_1\0\u{1}SEQ_SMALL_0_2\0") +} + +extension Proto2Unittest_EnumParseTester.SeqSmall1: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}SEQ_SMALL_1_DEFAULT\0\u{1}SEQ_SMALL_1_2\0\u{1}SEQ_SMALL_1_3\0") +} + +extension Proto2Unittest_EnumParseTester.SeqLarge: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}SEQ_LARGE_DEFAULT\0\u{1}SEQ_LARGE_0\0\u{1}SEQ_LARGE_1\0\u{1}SEQ_LARGE_2\0\u{1}SEQ_LARGE_3\0\u{1}SEQ_LARGE_4\0\u{1}SEQ_LARGE_5\0\u{1}SEQ_LARGE_6\0\u{1}SEQ_LARGE_7\0\u{1}SEQ_LARGE_8\0\u{1}SEQ_LARGE_9\0\u{1}SEQ_LARGE_10\0\u{1}SEQ_LARGE_11\0\u{1}SEQ_LARGE_12\0\u{1}SEQ_LARGE_13\0\u{1}SEQ_LARGE_14\0\u{1}SEQ_LARGE_15\0\u{1}SEQ_LARGE_16\0\u{1}SEQ_LARGE_17\0\u{1}SEQ_LARGE_18\0\u{1}SEQ_LARGE_19\0\u{1}SEQ_LARGE_20\0\u{1}SEQ_LARGE_21\0\u{1}SEQ_LARGE_22\0\u{1}SEQ_LARGE_23\0\u{1}SEQ_LARGE_24\0\u{1}SEQ_LARGE_25\0\u{1}SEQ_LARGE_26\0\u{1}SEQ_LARGE_27\0\u{1}SEQ_LARGE_28\0\u{1}SEQ_LARGE_29\0\u{1}SEQ_LARGE_30\0\u{1}SEQ_LARGE_31\0\u{1}SEQ_LARGE_32\0\u{1}SEQ_LARGE_33\0") +} + +extension Proto2Unittest_EnumParseTester.Arbitrary: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}@@@@@\u{2}ARBITRARY_MIN\0\u{2}M|a\u{7f}\u{7f}\u{1}ARBITRARY_DEFAULT\0\u{2}xA\u{1e}ARBITRARY_1\0\u{2}P\u{5}ARBITRARY_2\0\u{2}H@4ARBITRARY_3\0\u{2}b|K\u{7f}\u{7f}\u{1}ARBITRARY_MAX\0") +} + +extension Proto2Unittest_BoolParseTester: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".BoolParseTester" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_bool_lowfield\0\u{3}repeated_bool_lowfield\0\u{3}packed_bool_lowfield\0\u{4}`\u{1}other_field\0\u{4}F\u{e}optional_bool_midfield\0\u{3}repeated_bool_midfield\0\u{3}packed_bool_midfield\0\u{4}Vys\u{3}optional_bool_hifield\0\u{3}repeated_bool_hifield\0\u{3}packed_bool_hifield\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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.decodeSingularBoolField(value: &self._optionalBoolLowfield) }() + case 2: try { try decoder.decodeRepeatedBoolField(value: &self.repeatedBoolLowfield) }() + case 3: try { try decoder.decodeRepeatedBoolField(value: &self.packedBoolLowfield) }() + case 99: try { try decoder.decodeSingularInt32Field(value: &self._otherField) }() + case 1001: try { try decoder.decodeSingularBoolField(value: &self._optionalBoolMidfield) }() + case 1002: try { try decoder.decodeRepeatedBoolField(value: &self.repeatedBoolMidfield) }() + case 1003: try { try decoder.decodeRepeatedBoolField(value: &self.packedBoolMidfield) }() + case 1000001: try { try decoder.decodeSingularBoolField(value: &self._optionalBoolHifield) }() + case 1000002: try { try decoder.decodeRepeatedBoolField(value: &self.repeatedBoolHifield) }() + case 1000003: try { try decoder.decodeRepeatedBoolField(value: &self.packedBoolHifield) }() + case 2000000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_BoolParseTester.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._optionalBoolLowfield { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1) + } }() + if !self.repeatedBoolLowfield.isEmpty { + try visitor.visitRepeatedBoolField(value: self.repeatedBoolLowfield, fieldNumber: 2) + } + if !self.packedBoolLowfield.isEmpty { + try visitor.visitPackedBoolField(value: self.packedBoolLowfield, fieldNumber: 3) + } + try { if let v = self._otherField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 99) + } }() + try { if let v = self._optionalBoolMidfield { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1001) + } }() + if !self.repeatedBoolMidfield.isEmpty { + try visitor.visitRepeatedBoolField(value: self.repeatedBoolMidfield, fieldNumber: 1002) + } + if !self.packedBoolMidfield.isEmpty { + try visitor.visitPackedBoolField(value: self.packedBoolMidfield, fieldNumber: 1003) + } + try { if let v = self._optionalBoolHifield { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1000001) + } }() + if !self.repeatedBoolHifield.isEmpty { + try visitor.visitRepeatedBoolField(value: self.repeatedBoolHifield, fieldNumber: 1000002) + } + if !self.packedBoolHifield.isEmpty { + try visitor.visitPackedBoolField(value: self.packedBoolHifield, fieldNumber: 1000003) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2000000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_BoolParseTester, rhs: Proto2Unittest_BoolParseTester) -> Bool { + if lhs._optionalBoolLowfield != rhs._optionalBoolLowfield {return false} + if lhs._optionalBoolMidfield != rhs._optionalBoolMidfield {return false} + if lhs._optionalBoolHifield != rhs._optionalBoolHifield {return false} + if lhs.repeatedBoolLowfield != rhs.repeatedBoolLowfield {return false} + if lhs.repeatedBoolMidfield != rhs.repeatedBoolMidfield {return false} + if lhs.repeatedBoolHifield != rhs.repeatedBoolHifield {return false} + if lhs.packedBoolLowfield != rhs.packedBoolLowfield {return false} + if lhs.packedBoolMidfield != rhs.packedBoolMidfield {return false} + if lhs.packedBoolHifield != rhs.packedBoolHifield {return false} + if lhs._otherField != rhs._otherField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_Int32ParseTester: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Int32ParseTester" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32_lowfield\0\u{3}repeated_int32_lowfield\0\u{3}packed_int32_lowfield\0\u{4}`\u{1}other_field\0\u{4}F\u{e}optional_int32_midfield\0\u{3}repeated_int32_midfield\0\u{3}packed_int32_midfield\0\u{4}Vys\u{3}optional_int32_hifield\0\u{3}repeated_int32_hifield\0\u{3}packed_int32_hifield\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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._optionalInt32Lowfield) }() + case 2: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32Lowfield) }() + case 3: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32Lowfield) }() + case 99: try { try decoder.decodeSingularInt32Field(value: &self._otherField) }() + case 1001: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32Midfield) }() + case 1002: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32Midfield) }() + case 1003: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32Midfield) }() + case 1000001: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32Hifield) }() + case 1000002: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32Hifield) }() + case 1000003: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32Hifield) }() + case 2000000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_Int32ParseTester.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._optionalInt32Lowfield { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + if !self.repeatedInt32Lowfield.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.repeatedInt32Lowfield, fieldNumber: 2) + } + if !self.packedInt32Lowfield.isEmpty { + try visitor.visitPackedInt32Field(value: self.packedInt32Lowfield, fieldNumber: 3) + } + try { if let v = self._otherField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 99) + } }() + try { if let v = self._optionalInt32Midfield { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1001) + } }() + if !self.repeatedInt32Midfield.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.repeatedInt32Midfield, fieldNumber: 1002) + } + if !self.packedInt32Midfield.isEmpty { + try visitor.visitPackedInt32Field(value: self.packedInt32Midfield, fieldNumber: 1003) + } + try { if let v = self._optionalInt32Hifield { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1000001) + } }() + if !self.repeatedInt32Hifield.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.repeatedInt32Hifield, fieldNumber: 1000002) + } + if !self.packedInt32Hifield.isEmpty { + try visitor.visitPackedInt32Field(value: self.packedInt32Hifield, fieldNumber: 1000003) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2000000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_Int32ParseTester, rhs: Proto2Unittest_Int32ParseTester) -> Bool { + if lhs._optionalInt32Lowfield != rhs._optionalInt32Lowfield {return false} + if lhs._optionalInt32Midfield != rhs._optionalInt32Midfield {return false} + if lhs._optionalInt32Hifield != rhs._optionalInt32Hifield {return false} + if lhs.repeatedInt32Lowfield != rhs.repeatedInt32Lowfield {return false} + if lhs.repeatedInt32Midfield != rhs.repeatedInt32Midfield {return false} + if lhs.repeatedInt32Hifield != rhs.repeatedInt32Hifield {return false} + if lhs.packedInt32Lowfield != rhs.packedInt32Lowfield {return false} + if lhs.packedInt32Midfield != rhs.packedInt32Midfield {return false} + if lhs.packedInt32Hifield != rhs.packedInt32Hifield {return false} + if lhs._otherField != rhs._otherField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_Int64ParseTester: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Int64ParseTester" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int64_lowfield\0\u{3}repeated_int64_lowfield\0\u{3}packed_int64_lowfield\0\u{4}`\u{1}other_field\0\u{4}F\u{e}optional_int64_midfield\0\u{3}repeated_int64_midfield\0\u{3}packed_int64_midfield\0\u{4}Vys\u{3}optional_int64_hifield\0\u{3}repeated_int64_hifield\0\u{3}packed_int64_hifield\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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.decodeSingularInt64Field(value: &self._optionalInt64Lowfield) }() + case 2: try { try decoder.decodeRepeatedInt64Field(value: &self.repeatedInt64Lowfield) }() + case 3: try { try decoder.decodeRepeatedInt64Field(value: &self.packedInt64Lowfield) }() + case 99: try { try decoder.decodeSingularInt32Field(value: &self._otherField) }() + case 1001: try { try decoder.decodeSingularInt64Field(value: &self._optionalInt64Midfield) }() + case 1002: try { try decoder.decodeRepeatedInt64Field(value: &self.repeatedInt64Midfield) }() + case 1003: try { try decoder.decodeRepeatedInt64Field(value: &self.packedInt64Midfield) }() + case 1000001: try { try decoder.decodeSingularInt64Field(value: &self._optionalInt64Hifield) }() + case 1000002: try { try decoder.decodeRepeatedInt64Field(value: &self.repeatedInt64Hifield) }() + case 1000003: try { try decoder.decodeRepeatedInt64Field(value: &self.packedInt64Hifield) }() + case 2000000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_Int64ParseTester.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._optionalInt64Lowfield { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 1) + } }() + if !self.repeatedInt64Lowfield.isEmpty { + try visitor.visitRepeatedInt64Field(value: self.repeatedInt64Lowfield, fieldNumber: 2) + } + if !self.packedInt64Lowfield.isEmpty { + try visitor.visitPackedInt64Field(value: self.packedInt64Lowfield, fieldNumber: 3) + } + try { if let v = self._otherField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 99) + } }() + try { if let v = self._optionalInt64Midfield { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 1001) + } }() + if !self.repeatedInt64Midfield.isEmpty { + try visitor.visitRepeatedInt64Field(value: self.repeatedInt64Midfield, fieldNumber: 1002) + } + if !self.packedInt64Midfield.isEmpty { + try visitor.visitPackedInt64Field(value: self.packedInt64Midfield, fieldNumber: 1003) + } + try { if let v = self._optionalInt64Hifield { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 1000001) + } }() + if !self.repeatedInt64Hifield.isEmpty { + try visitor.visitRepeatedInt64Field(value: self.repeatedInt64Hifield, fieldNumber: 1000002) + } + if !self.packedInt64Hifield.isEmpty { + try visitor.visitPackedInt64Field(value: self.packedInt64Hifield, fieldNumber: 1000003) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2000000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_Int64ParseTester, rhs: Proto2Unittest_Int64ParseTester) -> Bool { + if lhs._optionalInt64Lowfield != rhs._optionalInt64Lowfield {return false} + if lhs._optionalInt64Midfield != rhs._optionalInt64Midfield {return false} + if lhs._optionalInt64Hifield != rhs._optionalInt64Hifield {return false} + if lhs.repeatedInt64Lowfield != rhs.repeatedInt64Lowfield {return false} + if lhs.repeatedInt64Midfield != rhs.repeatedInt64Midfield {return false} + if lhs.repeatedInt64Hifield != rhs.repeatedInt64Hifield {return false} + if lhs.packedInt64Lowfield != rhs.packedInt64Lowfield {return false} + if lhs.packedInt64Midfield != rhs.packedInt64Midfield {return false} + if lhs.packedInt64Hifield != rhs.packedInt64Hifield {return false} + if lhs._otherField != rhs._otherField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_InlinedStringIdxRegressionProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".InlinedStringIdxRegressionProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}str1\0\u{1}sub\0\u{1}str2\0\u{1}str3\0") + + fileprivate class _StorageClass { + var _str1: String? = nil + var _sub: Proto2Unittest_InlinedStringIdxRegressionProto? = nil + var _str2: String? = nil + var _str3: Data? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _str1 = source._str1 + _sub = source._sub + _str2 = source._str2 + _str3 = source._str3 + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._str1) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._sub) }() + case 3: try { try decoder.decodeSingularStringField(value: &_storage._str2) }() + case 4: try { try decoder.decodeSingularBytesField(value: &_storage._str3) }() + default: break + } + } + } + } + + func traverse(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._str1 { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._sub { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._str2 { + try visitor.visitSingularStringField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._str3 { + try visitor.visitSingularBytesField(value: v, fieldNumber: 4) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_InlinedStringIdxRegressionProto, rhs: Proto2Unittest_InlinedStringIdxRegressionProto) -> 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._str1 != rhs_storage._str1 {return false} + if _storage._sub != rhs_storage._sub {return false} + if _storage._str2 != rhs_storage._str2 {return false} + if _storage._str3 != rhs_storage._str3 {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_StringParseTester: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".StringParseTester" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_string_lowfield\0\u{3}repeated_string_lowfield\0\u{4}g\u{f}optional_string_midfield\0\u{3}repeated_string_midfield\0\u{4}Wys\u{3}optional_string_hifield\0\u{3}repeated_string_hifield\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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._optionalStringLowfield) }() + case 2: try { try decoder.decodeRepeatedStringField(value: &self.repeatedStringLowfield) }() + case 1001: try { try decoder.decodeSingularStringField(value: &self._optionalStringMidfield) }() + case 1002: try { try decoder.decodeRepeatedStringField(value: &self.repeatedStringMidfield) }() + case 1000001: try { try decoder.decodeSingularStringField(value: &self._optionalStringHifield) }() + case 1000002: try { try decoder.decodeRepeatedStringField(value: &self.repeatedStringHifield) }() + case 2000000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_StringParseTester.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._optionalStringLowfield { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + if !self.repeatedStringLowfield.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedStringLowfield, fieldNumber: 2) + } + try { if let v = self._optionalStringMidfield { + try visitor.visitSingularStringField(value: v, fieldNumber: 1001) + } }() + if !self.repeatedStringMidfield.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedStringMidfield, fieldNumber: 1002) + } + try { if let v = self._optionalStringHifield { + try visitor.visitSingularStringField(value: v, fieldNumber: 1000001) + } }() + if !self.repeatedStringHifield.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedStringHifield, fieldNumber: 1000002) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2000000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_StringParseTester, rhs: Proto2Unittest_StringParseTester) -> Bool { + if lhs._optionalStringLowfield != rhs._optionalStringLowfield {return false} + if lhs._optionalStringMidfield != rhs._optionalStringMidfield {return false} + if lhs._optionalStringHifield != rhs._optionalStringHifield {return false} + if lhs.repeatedStringLowfield != rhs.repeatedStringLowfield {return false} + if lhs.repeatedStringMidfield != rhs.repeatedStringMidfield {return false} + if lhs.repeatedStringHifield != rhs.repeatedStringHifield {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_BadFieldNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".BadFieldNames" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OptionalInt32\0\u{1}for\0") + + 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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._for) }() + 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 + try { if let v = self._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._for { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_BadFieldNames, rhs: Proto2Unittest_BadFieldNames) -> Bool { + if lhs._optionalInt32 != rhs._optionalInt32 {return false} + if lhs._for != rhs._for {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestNestedMessageRedaction: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedMessageRedaction" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_unredacted_nested_string\0\u{3}optional_redacted_nested_string\0") + + 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._optionalUnredactedNestedString) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._optionalRedactedNestedString) }() + 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 + try { if let v = self._optionalUnredactedNestedString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalRedactedNestedString { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestNestedMessageRedaction, rhs: Proto2Unittest_TestNestedMessageRedaction) -> Bool { + if lhs._optionalUnredactedNestedString != rhs._optionalUnredactedNestedString {return false} + if lhs._optionalRedactedNestedString != rhs._optionalRedactedNestedString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_RedactedFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".RedactedFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_redacted_string\0\u{3}optional_unredacted_string\0\u{3}repeated_redacted_string\0\u{3}repeated_unredacted_string\0\u{3}optional_redacted_message\0\u{3}optional_unredacted_message\0\u{3}repeated_redacted_message\0\u{3}repeated_unredacted_message\0\u{3}map_redacted_string\0\u{3}map_unredacted_string\0\u{3}optional_redacted_false_string\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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._optionalRedactedString) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._optionalUnredactedString) }() + case 3: try { try decoder.decodeRepeatedStringField(value: &self.repeatedRedactedString) }() + case 4: try { try decoder.decodeRepeatedStringField(value: &self.repeatedUnredactedString) }() + case 5: try { try decoder.decodeSingularMessageField(value: &self._optionalRedactedMessage) }() + case 6: try { try decoder.decodeSingularMessageField(value: &self._optionalUnredactedMessage) }() + case 7: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedRedactedMessage) }() + case 8: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedUnredactedMessage) }() + case 9: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.mapRedactedString) }() + case 10: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.mapUnredactedString) }() + case 11: try { try decoder.decodeSingularStringField(value: &self._optionalRedactedFalseString) }() + case 20..<31: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_RedactedFields.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._optionalRedactedString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalUnredactedString { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + if !self.repeatedRedactedString.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedRedactedString, fieldNumber: 3) + } + if !self.repeatedUnredactedString.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedUnredactedString, fieldNumber: 4) + } + try { if let v = self._optionalRedactedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + try { if let v = self._optionalUnredactedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 6) + } }() + if !self.repeatedRedactedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedRedactedMessage, fieldNumber: 7) + } + if !self.repeatedUnredactedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedUnredactedMessage, fieldNumber: 8) + } + if !self.mapRedactedString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.mapRedactedString, fieldNumber: 9) + } + if !self.mapUnredactedString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.mapUnredactedString, fieldNumber: 10) + } + try { if let v = self._optionalRedactedFalseString { + try visitor.visitSingularStringField(value: v, fieldNumber: 11) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 20, end: 31) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_RedactedFields, rhs: Proto2Unittest_RedactedFields) -> Bool { + if lhs._optionalRedactedString != rhs._optionalRedactedString {return false} + if lhs._optionalUnredactedString != rhs._optionalUnredactedString {return false} + if lhs.repeatedRedactedString != rhs.repeatedRedactedString {return false} + if lhs.repeatedUnredactedString != rhs.repeatedUnredactedString {return false} + if lhs._optionalRedactedMessage != rhs._optionalRedactedMessage {return false} + if lhs._optionalUnredactedMessage != rhs._optionalUnredactedMessage {return false} + if lhs.repeatedRedactedMessage != rhs.repeatedRedactedMessage {return false} + if lhs.repeatedUnredactedMessage != rhs.repeatedUnredactedMessage {return false} + if lhs.mapRedactedString != rhs.mapRedactedString {return false} + if lhs.mapUnredactedString != rhs.mapUnredactedString {return false} + if lhs._optionalRedactedFalseString != rhs._optionalRedactedFalseString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TestString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_string\0") + + 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._optionalString) }() + 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 + try { if let v = self._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestString, rhs: Proto2Unittest_TestString) -> Bool { + if lhs._optionalString != rhs._optionalString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestCord: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestCord" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_bytes_cord\0\u{3}optional_bytes_cord_default\0") + + 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.decodeSingularBytesField(value: &self._optionalBytesCord) }() + case 2: try { try decoder.decodeSingularBytesField(value: &self._optionalBytesCordDefault) }() + 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 + try { if let v = self._optionalBytesCord { + try visitor.visitSingularBytesField(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalBytesCordDefault { + try visitor.visitSingularBytesField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestCord, rhs: Proto2Unittest_TestCord) -> Bool { + if lhs._optionalBytesCord != rhs._optionalBytesCord {return false} + if lhs._optionalBytesCordDefault != rhs._optionalBytesCordDefault {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestPackedEnumSmallRange: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestPackedEnumSmallRange" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}vals\0") + + 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.decodeRepeatedEnumField(value: &self.vals) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.vals.isEmpty { + try visitor.visitPackedEnumField(value: self.vals, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestPackedEnumSmallRange, rhs: Proto2Unittest_TestPackedEnumSmallRange) -> Bool { + if lhs.vals != rhs.vals {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestPackedEnumSmallRange.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNSPECIFIED\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension Proto2Unittest_EnumsForBenchmark: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumsForBenchmark" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_EnumsForBenchmark, rhs: Proto2Unittest_EnumsForBenchmark) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_EnumsForBenchmark.Flat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0A0\0\u{1}A1\0\u{1}A2\0\u{1}A3\0\u{1}A4\0\u{1}A5\0\u{1}A6\0\u{1}A7\0\u{1}A8\0\u{1}A9\0\u{1}A10\0\u{1}A11\0\u{1}A12\0\u{1}A13\0\u{1}A14\0\u{1}A15\0") +} + +extension Proto2Unittest_EnumsForBenchmark.AlmostFlat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0B0\0\u{1}B1\0\u{1}B2\0\u{1}B3\0\u{2}\u{2}B5\0\u{1}B6\0\u{1}B7\0\u{1}B8\0\u{1}B9\0\u{2}\u{2}B11\0\u{1}B12\0\u{1}B13\0\u{1}B14\0\u{1}B15\0\u{2}\u{2}B17\0\u{2}\u{2}B19\0") +} + +extension Proto2Unittest_EnumsForBenchmark.Sparse: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}X\u{8}C536\0\u{2}kz\u{1}C8387\0\u{2}F\u{14}C9673\0\u{2}d\u{9}C10285\0\u{2}Y/C13318\0\u{2}U)C15963\0\u{2}\\\u{7}C16439\0\u{2}^\u{1b}C18197\0\u{2}Q\u{13}C19430\0\u{2}c\u{e}C20361\0\u{2}Y\u{5}C20706\0\u{2}X\u{5}C21050\0\u{2}X\u{d}C21906\0\u{2}oS\u{1}C27265\0\u{2}\\,C30109\0\u{2}Y\u{18}C31670\0") +} + +extension Proto2Unittest_TestMessageWithManyRepeatedPtrFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageWithManyRepeatedPtrFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}repeated_string_1\0\u{3}repeated_string_2\0\u{3}repeated_string_3\0\u{3}repeated_string_4\0\u{3}repeated_string_5\0\u{3}repeated_string_6\0\u{3}repeated_string_7\0\u{3}repeated_string_8\0\u{3}repeated_string_9\0\u{3}repeated_string_10\0\u{3}repeated_string_11\0\u{3}repeated_string_12\0\u{3}repeated_string_13\0\u{3}repeated_string_14\0\u{3}repeated_string_15\0\u{3}repeated_string_16\0\u{3}repeated_string_17\0\u{3}repeated_string_18\0\u{3}repeated_string_19\0\u{3}repeated_string_20\0\u{3}repeated_string_21\0\u{3}repeated_string_22\0\u{3}repeated_string_23\0\u{3}repeated_string_24\0\u{3}repeated_string_25\0\u{3}repeated_string_26\0\u{3}repeated_string_27\0\u{3}repeated_string_28\0\u{3}repeated_string_29\0\u{3}repeated_string_30\0\u{3}repeated_string_31\0\u{3}repeated_string_32\0") + + fileprivate class _StorageClass { + var _repeatedString1: [String] = [] + var _repeatedString2: [String] = [] + var _repeatedString3: [String] = [] + var _repeatedString4: [String] = [] + var _repeatedString5: [String] = [] + var _repeatedString6: [String] = [] + var _repeatedString7: [String] = [] + var _repeatedString8: [String] = [] + var _repeatedString9: [String] = [] + var _repeatedString10: [String] = [] + var _repeatedString11: [String] = [] + var _repeatedString12: [String] = [] + var _repeatedString13: [String] = [] + var _repeatedString14: [String] = [] + var _repeatedString15: [String] = [] + var _repeatedString16: [String] = [] + var _repeatedString17: [String] = [] + var _repeatedString18: [String] = [] + var _repeatedString19: [String] = [] + var _repeatedString20: [String] = [] + var _repeatedString21: [String] = [] + var _repeatedString22: [String] = [] + var _repeatedString23: [String] = [] + var _repeatedString24: [String] = [] + var _repeatedString25: [String] = [] + var _repeatedString26: [String] = [] + var _repeatedString27: [String] = [] + var _repeatedString28: [String] = [] + var _repeatedString29: [String] = [] + var _repeatedString30: [String] = [] + var _repeatedString31: [String] = [] + var _repeatedString32: [String] = [] + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _repeatedString1 = source._repeatedString1 + _repeatedString2 = source._repeatedString2 + _repeatedString3 = source._repeatedString3 + _repeatedString4 = source._repeatedString4 + _repeatedString5 = source._repeatedString5 + _repeatedString6 = source._repeatedString6 + _repeatedString7 = source._repeatedString7 + _repeatedString8 = source._repeatedString8 + _repeatedString9 = source._repeatedString9 + _repeatedString10 = source._repeatedString10 + _repeatedString11 = source._repeatedString11 + _repeatedString12 = source._repeatedString12 + _repeatedString13 = source._repeatedString13 + _repeatedString14 = source._repeatedString14 + _repeatedString15 = source._repeatedString15 + _repeatedString16 = source._repeatedString16 + _repeatedString17 = source._repeatedString17 + _repeatedString18 = source._repeatedString18 + _repeatedString19 = source._repeatedString19 + _repeatedString20 = source._repeatedString20 + _repeatedString21 = source._repeatedString21 + _repeatedString22 = source._repeatedString22 + _repeatedString23 = source._repeatedString23 + _repeatedString24 = source._repeatedString24 + _repeatedString25 = source._repeatedString25 + _repeatedString26 = source._repeatedString26 + _repeatedString27 = source._repeatedString27 + _repeatedString28 = source._repeatedString28 + _repeatedString29 = source._repeatedString29 + _repeatedString30 = source._repeatedString30 + _repeatedString31 = source._repeatedString31 + _repeatedString32 = source._repeatedString32 + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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.decodeRepeatedStringField(value: &_storage._repeatedString1) }() + case 2: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString2) }() + case 3: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString3) }() + case 4: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString4) }() + case 5: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString5) }() + case 6: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString6) }() + case 7: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString7) }() + case 8: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString8) }() + case 9: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString9) }() + case 10: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString10) }() + case 11: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString11) }() + case 12: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString12) }() + case 13: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString13) }() + case 14: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString14) }() + case 15: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString15) }() + case 16: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString16) }() + case 17: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString17) }() + case 18: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString18) }() + case 19: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString19) }() + case 20: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString20) }() + case 21: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString21) }() + case 22: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString22) }() + case 23: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString23) }() + case 24: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString24) }() + case 25: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString25) }() + case 26: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString26) }() + case 27: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString27) }() + case 28: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString28) }() + case 29: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString29) }() + case 30: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString30) }() + case 31: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString31) }() + case 32: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString32) }() + default: break + } + } + } + } + + func traverse(visitor: inout V) throws { + try withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if !_storage._repeatedString1.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString1, fieldNumber: 1) + } + if !_storage._repeatedString2.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString2, fieldNumber: 2) + } + if !_storage._repeatedString3.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString3, fieldNumber: 3) + } + if !_storage._repeatedString4.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString4, fieldNumber: 4) + } + if !_storage._repeatedString5.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString5, fieldNumber: 5) + } + if !_storage._repeatedString6.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString6, fieldNumber: 6) + } + if !_storage._repeatedString7.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString7, fieldNumber: 7) + } + if !_storage._repeatedString8.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString8, fieldNumber: 8) + } + if !_storage._repeatedString9.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString9, fieldNumber: 9) + } + if !_storage._repeatedString10.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString10, fieldNumber: 10) + } + if !_storage._repeatedString11.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString11, fieldNumber: 11) + } + if !_storage._repeatedString12.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString12, fieldNumber: 12) + } + if !_storage._repeatedString13.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString13, fieldNumber: 13) + } + if !_storage._repeatedString14.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString14, fieldNumber: 14) + } + if !_storage._repeatedString15.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString15, fieldNumber: 15) + } + if !_storage._repeatedString16.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString16, fieldNumber: 16) + } + if !_storage._repeatedString17.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString17, fieldNumber: 17) + } + if !_storage._repeatedString18.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString18, fieldNumber: 18) + } + if !_storage._repeatedString19.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString19, fieldNumber: 19) + } + if !_storage._repeatedString20.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString20, fieldNumber: 20) + } + if !_storage._repeatedString21.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString21, fieldNumber: 21) + } + if !_storage._repeatedString22.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString22, fieldNumber: 22) + } + if !_storage._repeatedString23.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString23, fieldNumber: 23) + } + if !_storage._repeatedString24.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString24, fieldNumber: 24) + } + if !_storage._repeatedString25.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString25, fieldNumber: 25) + } + if !_storage._repeatedString26.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString26, fieldNumber: 26) + } + if !_storage._repeatedString27.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString27, fieldNumber: 27) + } + if !_storage._repeatedString28.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString28, fieldNumber: 28) + } + if !_storage._repeatedString29.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString29, fieldNumber: 29) + } + if !_storage._repeatedString30.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString30, fieldNumber: 30) + } + if !_storage._repeatedString31.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString31, fieldNumber: 31) + } + if !_storage._repeatedString32.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString32, fieldNumber: 32) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMessageWithManyRepeatedPtrFields, rhs: Proto2Unittest_TestMessageWithManyRepeatedPtrFields) -> 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._repeatedString1 != rhs_storage._repeatedString1 {return false} + if _storage._repeatedString2 != rhs_storage._repeatedString2 {return false} + if _storage._repeatedString3 != rhs_storage._repeatedString3 {return false} + if _storage._repeatedString4 != rhs_storage._repeatedString4 {return false} + if _storage._repeatedString5 != rhs_storage._repeatedString5 {return false} + if _storage._repeatedString6 != rhs_storage._repeatedString6 {return false} + if _storage._repeatedString7 != rhs_storage._repeatedString7 {return false} + if _storage._repeatedString8 != rhs_storage._repeatedString8 {return false} + if _storage._repeatedString9 != rhs_storage._repeatedString9 {return false} + if _storage._repeatedString10 != rhs_storage._repeatedString10 {return false} + if _storage._repeatedString11 != rhs_storage._repeatedString11 {return false} + if _storage._repeatedString12 != rhs_storage._repeatedString12 {return false} + if _storage._repeatedString13 != rhs_storage._repeatedString13 {return false} + if _storage._repeatedString14 != rhs_storage._repeatedString14 {return false} + if _storage._repeatedString15 != rhs_storage._repeatedString15 {return false} + if _storage._repeatedString16 != rhs_storage._repeatedString16 {return false} + if _storage._repeatedString17 != rhs_storage._repeatedString17 {return false} + if _storage._repeatedString18 != rhs_storage._repeatedString18 {return false} + if _storage._repeatedString19 != rhs_storage._repeatedString19 {return false} + if _storage._repeatedString20 != rhs_storage._repeatedString20 {return false} + if _storage._repeatedString21 != rhs_storage._repeatedString21 {return false} + if _storage._repeatedString22 != rhs_storage._repeatedString22 {return false} + if _storage._repeatedString23 != rhs_storage._repeatedString23 {return false} + if _storage._repeatedString24 != rhs_storage._repeatedString24 {return false} + if _storage._repeatedString25 != rhs_storage._repeatedString25 {return false} + if _storage._repeatedString26 != rhs_storage._repeatedString26 {return false} + if _storage._repeatedString27 != rhs_storage._repeatedString27 {return false} + if _storage._repeatedString28 != rhs_storage._repeatedString28 {return false} + if _storage._repeatedString29 != rhs_storage._repeatedString29 {return false} + if _storage._repeatedString30 != rhs_storage._repeatedString30 {return false} + if _storage._repeatedString31 != rhs_storage._repeatedString31 {return false} + if _storage._repeatedString32 != rhs_storage._repeatedString32 {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_MessageCreatorZeroInit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MessageCreatorZeroInit" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}i\0\u{1}d\0\u{1}m\0\u{2}\u{7}os\0\u{1}oc\0\u{1}of\0\u{1}ol\0") + + fileprivate class _StorageClass { + var _i: Int32? = nil + var _d: Double? = nil + var _m: Proto2Unittest_MessageCreatorZeroInit? = nil + var _one: Proto2Unittest_MessageCreatorZeroInit.OneOf_One? + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _i = source._i + _d = source._d + _m = source._m + _one = source._one + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._i) }() + case 2: try { try decoder.decodeSingularDoubleField(value: &_storage._d) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._m) }() + case 10: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._one != nil {try decoder.handleConflictingOneOf()} + _storage._one = .os(v) + } + }() + case 11: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._one != nil {try decoder.handleConflictingOneOf()} + _storage._one = .oc(v) + } + }() + case 12: try { + var v: UInt64? + try decoder.decodeSingularFixed64Field(value: &v) + if let v = v { + if _storage._one != nil {try decoder.handleConflictingOneOf()} + _storage._one = .of(v) + } + }() + case 13: try { + var v: Proto2Unittest_MessageCreatorZeroInit? + var hadOneofValue = false + if let current = _storage._one { + hadOneofValue = true + if case .ol(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._one = .ol(v) + } + }() + default: break + } + } + } + } + + func traverse(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._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._d { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._m { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + switch _storage._one { + case .os?: try { + guard case .os(let v)? = _storage._one else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 10) + }() + case .oc?: try { + guard case .oc(let v)? = _storage._one else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 11) + }() + case .of?: try { + guard case .of(let v)? = _storage._one else { preconditionFailure() } + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 12) + }() + case .ol?: try { + guard case .ol(let v)? = _storage._one else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 13) + }() + case nil: break + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_MessageCreatorZeroInit, rhs: Proto2Unittest_MessageCreatorZeroInit) -> 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._i != rhs_storage._i {return false} + if _storage._d != rhs_storage._d {return false} + if _storage._m != rhs_storage._m {return false} + if _storage._one != rhs_storage._one {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_MessageCreatorMemcpy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MessageCreatorMemcpy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}s\0\u{1}i\0\u{1}m\0\u{1}m2\0") + + fileprivate class _StorageClass { + var _s: String? = nil + var _i: [Int32] = [] + var _m: Proto2Unittest_MessageCreatorMemcpy? = nil + var _m2: Dictionary = [:] + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _s = source._s + _i = source._i + _m = source._m + _m2 = source._m2 + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._s) }() + case 2: try { try decoder.decodeRepeatedInt32Field(value: &_storage._i) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._m) }() + case 4: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._m2) }() + default: break + } + } + } + } + + func traverse(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._s { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + if !_storage._i.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._i, fieldNumber: 2) + } + try { if let v = _storage._m { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + if !_storage._m2.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._m2, fieldNumber: 4) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_MessageCreatorMemcpy, rhs: Proto2Unittest_MessageCreatorMemcpy) -> 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._s != rhs_storage._s {return false} + if _storage._i != rhs_storage._i {return false} + if _storage._m != rhs_storage._m {return false} + if _storage._m2 != rhs_storage._m2 {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_MessageCreatorFunc: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MessageCreatorFunc" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{3}c\0") + + 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 3: try { try decoder.decodeSingularStringField(value: &self._c) }() + 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 + try { if let v = self._c { + try visitor.visitSingularStringField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_MessageCreatorFunc, rhs: Proto2Unittest_MessageCreatorFunc) -> Bool { + if lhs._c != rhs._c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_FastParseTableCompression: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FastParseTableCompression" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}important_field_1\0\u{3}important_field_2\0\u{3}unimportant_field_3\0\u{3}unimportant_field_4\0\u{3}unimportant_field_5\0\u{4}\u{4}unimportant_field_9\0\u{4}\u{2}important_field_11\0\u{3}unimportant_field_12\0\u{4}\u{2}important_field_14\0\u{3}unimportant_field_15\0\u{c}\u{6}\u{1}\u{c}\u{7}\u{1}\u{c}\u{8}\u{1}\u{c}\u{a}\u{1}\u{c}\u{d}\u{1}\u{c}\u{10}\u{1}") + + 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._importantField1) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._importantField2) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._unimportantField3) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &self._unimportantField4) }() + case 5: try { try decoder.decodeSingularInt32Field(value: &self._unimportantField5) }() + case 9: try { try decoder.decodeSingularInt32Field(value: &self._unimportantField9) }() + case 11: try { try decoder.decodeSingularInt32Field(value: &self._importantField11) }() + case 12: try { try decoder.decodeSingularInt32Field(value: &self._unimportantField12) }() + case 14: try { try decoder.decodeSingularInt32Field(value: &self._importantField14) }() + case 15: try { try decoder.decodeSingularInt32Field(value: &self._unimportantField15) }() + 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 + try { if let v = self._importantField1 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._importantField2 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._unimportantField3 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._unimportantField4 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try { if let v = self._unimportantField5 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = self._unimportantField9 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try { if let v = self._importantField11 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 11) + } }() + try { if let v = self._unimportantField12 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 12) + } }() + try { if let v = self._importantField14 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 14) + } }() + try { if let v = self._unimportantField15 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 15) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_FastParseTableCompression, rhs: Proto2Unittest_FastParseTableCompression) -> Bool { + if lhs._importantField1 != rhs._importantField1 {return false} + if lhs._importantField2 != rhs._importantField2 {return false} + if lhs._unimportantField3 != rhs._unimportantField3 {return false} + if lhs._unimportantField4 != rhs._unimportantField4 {return false} + if lhs._unimportantField5 != rhs._unimportantField5 {return false} + if lhs._unimportantField9 != rhs._unimportantField9 {return false} + if lhs._importantField11 != rhs._importantField11 {return false} + if lhs._unimportantField12 != rhs._unimportantField12 {return false} + if lhs._importantField14 != rhs._importantField14 {return false} + if lhs._unimportantField15 != rhs._unimportantField15 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMessageForMove_Small: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageForMove_Small" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMessageForMove_Small, rhs: Proto2Unittest_TestMessageForMove_Small) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMessageForMove_Large: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageForMove_Large" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a1\0\u{1}a2\0\u{1}a3\0\u{1}a4\0\u{1}a5\0\u{1}a6\0\u{1}a7\0\u{1}a8\0\u{1}a9\0\u{2}\u{2}a11\0\u{1}a12\0\u{1}a13\0\u{1}a14\0\u{1}a15\0\u{1}a16\0\u{1}a17\0\u{1}a18\0\u{1}a19\0\u{2}R\u{1}s101\0\u{1}s102\0\u{1}s103\0\u{1}s104\0\u{1}s105\0\u{1}s106\0\u{1}s107\0\u{1}s108\0\u{1}s109\0\u{2}\u{2}s111\0\u{1}s112\0\u{1}s113\0\u{1}s114\0\u{1}s115\0\u{1}s116\0\u{1}s117\0\u{1}s118\0\u{1}s119\0") + + fileprivate class _StorageClass { + var _a1: Int32? = nil + var _a2: Int32? = nil + var _a3: Int32? = nil + var _a4: Int32? = nil + var _a5: Int32? = nil + var _a6: Int32? = nil + var _a7: Int32? = nil + var _a8: Int32? = nil + var _a9: Int32? = nil + var _a11: [Int32] = [] + var _a12: [Int32] = [] + var _a13: [Int32] = [] + var _a14: [Int32] = [] + var _a15: [Int32] = [] + var _a16: [Int32] = [] + var _a17: [Int32] = [] + var _a18: [Int32] = [] + var _a19: [Int32] = [] + var _s101: String? = nil + var _s102: String? = nil + var _s103: String? = nil + var _s104: String? = nil + var _s105: String? = nil + var _s106: String? = nil + var _s107: String? = nil + var _s108: String? = nil + var _s109: String? = nil + var _s111: [String] = [] + var _s112: [String] = [] + var _s113: [String] = [] + var _s114: [String] = [] + var _s115: [String] = [] + var _s116: [String] = [] + var _s117: [String] = [] + var _s118: [String] = [] + var _s119: [String] = [] + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a1 = source._a1 + _a2 = source._a2 + _a3 = source._a3 + _a4 = source._a4 + _a5 = source._a5 + _a6 = source._a6 + _a7 = source._a7 + _a8 = source._a8 + _a9 = source._a9 + _a11 = source._a11 + _a12 = source._a12 + _a13 = source._a13 + _a14 = source._a14 + _a15 = source._a15 + _a16 = source._a16 + _a17 = source._a17 + _a18 = source._a18 + _a19 = source._a19 + _s101 = source._s101 + _s102 = source._s102 + _s103 = source._s103 + _s104 = source._s104 + _s105 = source._s105 + _s106 = source._s106 + _s107 = source._s107 + _s108 = source._s108 + _s109 = source._s109 + _s111 = source._s111 + _s112 = source._s112 + _s113 = source._s113 + _s114 = source._s114 + _s115 = source._s115 + _s116 = source._s116 + _s117 = source._s117 + _s118 = source._s118 + _s119 = source._s119 + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._a1) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._a2) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &_storage._a3) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &_storage._a4) }() + case 5: try { try decoder.decodeSingularInt32Field(value: &_storage._a5) }() + case 6: try { try decoder.decodeSingularInt32Field(value: &_storage._a6) }() + case 7: try { try decoder.decodeSingularInt32Field(value: &_storage._a7) }() + case 8: try { try decoder.decodeSingularInt32Field(value: &_storage._a8) }() + case 9: try { try decoder.decodeSingularInt32Field(value: &_storage._a9) }() + case 11: try { try decoder.decodeRepeatedInt32Field(value: &_storage._a11) }() + case 12: try { try decoder.decodeRepeatedInt32Field(value: &_storage._a12) }() + case 13: try { try decoder.decodeRepeatedInt32Field(value: &_storage._a13) }() + case 14: try { try decoder.decodeRepeatedInt32Field(value: &_storage._a14) }() + case 15: try { try decoder.decodeRepeatedInt32Field(value: &_storage._a15) }() + case 16: try { try decoder.decodeRepeatedInt32Field(value: &_storage._a16) }() + case 17: try { try decoder.decodeRepeatedInt32Field(value: &_storage._a17) }() + case 18: try { try decoder.decodeRepeatedInt32Field(value: &_storage._a18) }() + case 19: try { try decoder.decodeRepeatedInt32Field(value: &_storage._a19) }() + case 101: try { try decoder.decodeSingularStringField(value: &_storage._s101) }() + case 102: try { try decoder.decodeSingularStringField(value: &_storage._s102) }() + case 103: try { try decoder.decodeSingularStringField(value: &_storage._s103) }() + case 104: try { try decoder.decodeSingularStringField(value: &_storage._s104) }() + case 105: try { try decoder.decodeSingularStringField(value: &_storage._s105) }() + case 106: try { try decoder.decodeSingularStringField(value: &_storage._s106) }() + case 107: try { try decoder.decodeSingularStringField(value: &_storage._s107) }() + case 108: try { try decoder.decodeSingularStringField(value: &_storage._s108) }() + case 109: try { try decoder.decodeSingularStringField(value: &_storage._s109) }() + case 111: try { try decoder.decodeRepeatedStringField(value: &_storage._s111) }() + case 112: try { try decoder.decodeRepeatedStringField(value: &_storage._s112) }() + case 113: try { try decoder.decodeRepeatedStringField(value: &_storage._s113) }() + case 114: try { try decoder.decodeRepeatedStringField(value: &_storage._s114) }() + case 115: try { try decoder.decodeRepeatedStringField(value: &_storage._s115) }() + case 116: try { try decoder.decodeRepeatedStringField(value: &_storage._s116) }() + case 117: try { try decoder.decodeRepeatedStringField(value: &_storage._s117) }() + case 118: try { try decoder.decodeRepeatedStringField(value: &_storage._s118) }() + case 119: try { try decoder.decodeRepeatedStringField(value: &_storage._s119) }() + default: break + } + } + } + } + + func traverse(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._a1 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._a2 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._a3 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._a4 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._a5 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._a6 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._a7 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._a8 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._a9 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + if !_storage._a11.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._a11, fieldNumber: 11) + } + if !_storage._a12.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._a12, fieldNumber: 12) + } + if !_storage._a13.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._a13, fieldNumber: 13) + } + if !_storage._a14.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._a14, fieldNumber: 14) + } + if !_storage._a15.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._a15, fieldNumber: 15) + } + if !_storage._a16.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._a16, fieldNumber: 16) + } + if !_storage._a17.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._a17, fieldNumber: 17) + } + if !_storage._a18.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._a18, fieldNumber: 18) + } + if !_storage._a19.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._a19, fieldNumber: 19) + } + try { if let v = _storage._s101 { + try visitor.visitSingularStringField(value: v, fieldNumber: 101) + } }() + try { if let v = _storage._s102 { + try visitor.visitSingularStringField(value: v, fieldNumber: 102) + } }() + try { if let v = _storage._s103 { + try visitor.visitSingularStringField(value: v, fieldNumber: 103) + } }() + try { if let v = _storage._s104 { + try visitor.visitSingularStringField(value: v, fieldNumber: 104) + } }() + try { if let v = _storage._s105 { + try visitor.visitSingularStringField(value: v, fieldNumber: 105) + } }() + try { if let v = _storage._s106 { + try visitor.visitSingularStringField(value: v, fieldNumber: 106) + } }() + try { if let v = _storage._s107 { + try visitor.visitSingularStringField(value: v, fieldNumber: 107) + } }() + try { if let v = _storage._s108 { + try visitor.visitSingularStringField(value: v, fieldNumber: 108) + } }() + try { if let v = _storage._s109 { + try visitor.visitSingularStringField(value: v, fieldNumber: 109) + } }() + if !_storage._s111.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._s111, fieldNumber: 111) + } + if !_storage._s112.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._s112, fieldNumber: 112) + } + if !_storage._s113.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._s113, fieldNumber: 113) + } + if !_storage._s114.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._s114, fieldNumber: 114) + } + if !_storage._s115.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._s115, fieldNumber: 115) + } + if !_storage._s116.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._s116, fieldNumber: 116) + } + if !_storage._s117.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._s117, fieldNumber: 117) + } + if !_storage._s118.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._s118, fieldNumber: 118) + } + if !_storage._s119.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._s119, fieldNumber: 119) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMessageForMove_Large, rhs: Proto2Unittest_TestMessageForMove_Large) -> 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._a1 != rhs_storage._a1 {return false} + if _storage._a2 != rhs_storage._a2 {return false} + if _storage._a3 != rhs_storage._a3 {return false} + if _storage._a4 != rhs_storage._a4 {return false} + if _storage._a5 != rhs_storage._a5 {return false} + if _storage._a6 != rhs_storage._a6 {return false} + if _storage._a7 != rhs_storage._a7 {return false} + if _storage._a8 != rhs_storage._a8 {return false} + if _storage._a9 != rhs_storage._a9 {return false} + if _storage._a11 != rhs_storage._a11 {return false} + if _storage._a12 != rhs_storage._a12 {return false} + if _storage._a13 != rhs_storage._a13 {return false} + if _storage._a14 != rhs_storage._a14 {return false} + if _storage._a15 != rhs_storage._a15 {return false} + if _storage._a16 != rhs_storage._a16 {return false} + if _storage._a17 != rhs_storage._a17 {return false} + if _storage._a18 != rhs_storage._a18 {return false} + if _storage._a19 != rhs_storage._a19 {return false} + if _storage._s101 != rhs_storage._s101 {return false} + if _storage._s102 != rhs_storage._s102 {return false} + if _storage._s103 != rhs_storage._s103 {return false} + if _storage._s104 != rhs_storage._s104 {return false} + if _storage._s105 != rhs_storage._s105 {return false} + if _storage._s106 != rhs_storage._s106 {return false} + if _storage._s107 != rhs_storage._s107 {return false} + if _storage._s108 != rhs_storage._s108 {return false} + if _storage._s109 != rhs_storage._s109 {return false} + if _storage._s111 != rhs_storage._s111 {return false} + if _storage._s112 != rhs_storage._s112 {return false} + if _storage._s113 != rhs_storage._s113 {return false} + if _storage._s114 != rhs_storage._s114 {return false} + if _storage._s115 != rhs_storage._s115 {return false} + if _storage._s116 != rhs_storage._s116 {return false} + if _storage._s117 != rhs_storage._s117 {return false} + if _storage._s118 != rhs_storage._s118 {return false} + if _storage._s119 != rhs_storage._s119 {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/google/protobuf/unittest_arena.pb.swift b/Reference/upstream/google/protobuf/unittest_arena.pb.swift similarity index 68% rename from Reference/google/protobuf/unittest_arena.pb.swift rename to Reference/upstream/google/protobuf/unittest_arena.pb.swift index d5a360b82..cb2bac99c 100644 --- a/Reference/google/protobuf/unittest_arena.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_arena.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/unittest_arena.proto @@ -9,35 +10,11 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -import Foundation +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -50,17 +27,17 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct Proto2ArenaUnittest_NestedMessage { +struct Proto2ArenaUnittest_NestedMessage: Sendable { // 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 d: Int32 { - get {return _d ?? 0} + get {_d ?? 0} set {_d = newValue} } /// Returns true if `d` has been explicitly set. - var hasD: Bool {return self._d != nil} + var hasD: Bool {self._d != nil} /// Clears the value of `d`. Subsequent reads from it will return its default value. mutating func clearD() {self._d = nil} @@ -71,7 +48,7 @@ struct Proto2ArenaUnittest_NestedMessage { fileprivate var _d: Int32? = nil } -struct Proto2ArenaUnittest_ArenaMessage { +struct Proto2ArenaUnittest_ArenaMessage: Sendable { // 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. @@ -83,20 +60,13 @@ struct Proto2ArenaUnittest_ArenaMessage { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Proto2ArenaUnittest_NestedMessage: @unchecked Sendable {} -extension Proto2ArenaUnittest_ArenaMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "proto2_arena_unittest" extension Proto2ArenaUnittest_NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "d"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}d\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -130,9 +100,7 @@ extension Proto2ArenaUnittest_NestedMessage: SwiftProtobuf.Message, SwiftProtobu extension Proto2ArenaUnittest_ArenaMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ArenaMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "repeated_nested_message"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}repeated_nested_message\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { diff --git a/Reference/upstream/google/protobuf/unittest_custom_options.pb.swift b/Reference/upstream/google/protobuf/unittest_custom_options.pb.swift new file mode 100644 index 000000000..a5d9da11e --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_custom_options.pb.swift @@ -0,0 +1,2744 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_custom_options.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: benjy@google.com (Benjy Weinberger) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// A proto file used to test the "custom options" feature of google.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 +} + +enum Proto2Unittest_MethodOpt1: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case val1 = 1 + case val2 = 2 + + init() { + self = .val1 + } + +} + +enum Proto2Unittest_AggregateEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case value = 1 + + init() { + self = .value + } + +} + +/// A test message with custom options at all possible locations (and also some +/// regular options, to make sure they interact nicely). +struct Proto2Unittest_TestMessageWithCustomOptions: Sendable { + // 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 {_field1 ?? String()} + set {_field1 = newValue} + } + /// Returns true if `field1` has been explicitly set. + var hasField1: Bool {self._field1 != nil} + /// Clears the value of `field1`. Subsequent reads from it will return its default value. + mutating func clearField1() {self._field1 = nil} + + var anOneof: Proto2Unittest_TestMessageWithCustomOptions.OneOf_AnOneof? = nil + + var oneofField: Int32 { + get { + if case .oneofField(let v)? = anOneof {return v} + return 0 + } + set {anOneof = .oneofField(newValue)} + } + + var mapField: Dictionary = [:] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_AnOneof: Equatable, Sendable { + case oneofField(Int32) + + } + + enum AnEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case val1 = 1 + case val2 = 2 + + init() { + self = .val1 + } + + } + + init() {} + + fileprivate var _field1: String? = nil +} + +/// A test RPC service with custom options at all possible locations (and also +/// some regular options, to make sure they interact nicely). +struct Proto2Unittest_CustomOptionFooRequest: Sendable { + // 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 Proto2Unittest_CustomOptionFooResponse: Sendable { + // 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 Proto2Unittest_CustomOptionFooClientMessage: Sendable { + // 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 Proto2Unittest_CustomOptionFooServerMessage: Sendable { + // 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 Proto2Unittest_DummyMessageContainingEnum: Sendable { + // 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() + + enum TestEnumType: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case testOptionEnumType1 = 22 + case testOptionEnumType2 = -23 + + init() { + self = .testOptionEnumType1 + } + + } + + init() {} +} + +struct Proto2Unittest_DummyMessageInvalidAsOptionType: Sendable { + // 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 Proto2Unittest_CustomOptionMinIntegerValues: Sendable { + // 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 Proto2Unittest_CustomOptionMaxIntegerValues: Sendable { + // 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 Proto2Unittest_CustomOptionOtherValues: Sendable { + // 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 Proto2Unittest_SettingRealsFromPositiveInts: Sendable { + // 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 Proto2Unittest_SettingRealsFromNegativeInts: Sendable { + // 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 Proto2Unittest_SettingRealsFromInf: Sendable { + // 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 Proto2Unittest_SettingRealsFromNegativeInf: Sendable { + // 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 Proto2Unittest_SettingRealsFromNan: Sendable { + // 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 Proto2Unittest_SettingRealsFromNegativeNan: Sendable { + // 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 Proto2Unittest_ComplexOptionType1: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 foo: Int32 { + get {_foo ?? 0} + set {_foo = newValue} + } + /// Returns true if `foo` has been explicitly set. + var hasFoo: Bool {self._foo != nil} + /// Clears the value of `foo`. Subsequent reads from it will return its default value. + mutating func clearFoo() {self._foo = nil} + + var foo2: Int32 { + get {_foo2 ?? 0} + set {_foo2 = newValue} + } + /// Returns true if `foo2` has been explicitly set. + var hasFoo2: Bool {self._foo2 != nil} + /// Clears the value of `foo2`. Subsequent reads from it will return its default value. + mutating func clearFoo2() {self._foo2 = nil} + + var foo3: Int32 { + get {_foo3 ?? 0} + set {_foo3 = newValue} + } + /// Returns true if `foo3` has been explicitly set. + var hasFoo3: Bool {self._foo3 != nil} + /// Clears the value of `foo3`. Subsequent reads from it will return its default value. + mutating func clearFoo3() {self._foo3 = nil} + + var foo4: [Int32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _foo: Int32? = nil + fileprivate var _foo2: Int32? = nil + fileprivate var _foo3: Int32? = nil +} + +struct Proto2Unittest_ComplexOptionType2: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 bar: Proto2Unittest_ComplexOptionType1 { + get {_bar ?? Proto2Unittest_ComplexOptionType1()} + set {_bar = newValue} + } + /// Returns true if `bar` has been explicitly set. + var hasBar: Bool {self._bar != nil} + /// Clears the value of `bar`. Subsequent reads from it will return its default value. + mutating func clearBar() {self._bar = nil} + + var baz: Int32 { + get {_baz ?? 0} + set {_baz = newValue} + } + /// Returns true if `baz` has been explicitly set. + var hasBaz: Bool {self._baz != nil} + /// Clears the value of `baz`. Subsequent reads from it will return its default value. + mutating func clearBaz() {self._baz = nil} + + var fred: Proto2Unittest_ComplexOptionType2.ComplexOptionType4 { + get {_fred ?? Proto2Unittest_ComplexOptionType2.ComplexOptionType4()} + set {_fred = newValue} + } + /// Returns true if `fred` has been explicitly set. + var hasFred: Bool {self._fred != nil} + /// Clears the value of `fred`. Subsequent reads from it will return its default value. + mutating func clearFred() {self._fred = nil} + + var barney: [Proto2Unittest_ComplexOptionType2.ComplexOptionType4] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct ComplexOptionType4: Sendable { + // 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 waldo: Int32 { + get {_waldo ?? 0} + set {_waldo = newValue} + } + /// Returns true if `waldo` has been explicitly set. + var hasWaldo: Bool {self._waldo != nil} + /// Clears the value of `waldo`. Subsequent reads from it will return its default value. + mutating func clearWaldo() {self._waldo = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _waldo: Int32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _bar: Proto2Unittest_ComplexOptionType1? = nil + fileprivate var _baz: Int32? = nil + fileprivate var _fred: Proto2Unittest_ComplexOptionType2.ComplexOptionType4? = nil +} + +struct Proto2Unittest_ComplexOptionType3: Sendable { + // 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 moo: Int32 { + get {_moo ?? 0} + set {_moo = newValue} + } + /// Returns true if `moo` has been explicitly set. + var hasMoo: Bool {self._moo != nil} + /// Clears the value of `moo`. Subsequent reads from it will return its default value. + mutating func clearMoo() {self._moo = nil} + + var complexOptionType5: Proto2Unittest_ComplexOptionType3.ComplexOptionType5 { + get {_complexOptionType5 ?? Proto2Unittest_ComplexOptionType3.ComplexOptionType5()} + set {_complexOptionType5 = newValue} + } + /// Returns true if `complexOptionType5` has been explicitly set. + var hasComplexOptionType5: Bool {self._complexOptionType5 != nil} + /// Clears the value of `complexOptionType5`. Subsequent reads from it will return its default value. + mutating func clearComplexOptionType5() {self._complexOptionType5 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct ComplexOptionType5: Sendable { + // 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 plugh: Int32 { + get {_plugh ?? 0} + set {_plugh = newValue} + } + /// Returns true if `plugh` has been explicitly set. + var hasPlugh: Bool {self._plugh != nil} + /// Clears the value of `plugh`. Subsequent reads from it will return its default value. + mutating func clearPlugh() {self._plugh = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _plugh: Int32? = nil + } + + init() {} + + fileprivate var _moo: Int32? = nil + fileprivate var _complexOptionType5: Proto2Unittest_ComplexOptionType3.ComplexOptionType5? = nil +} + +struct Proto2Unittest_ComplexOpt6: Sendable { + // 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 xyzzy: Int32 { + get {_xyzzy ?? 0} + set {_xyzzy = newValue} + } + /// Returns true if `xyzzy` has been explicitly set. + var hasXyzzy: Bool {self._xyzzy != nil} + /// Clears the value of `xyzzy`. Subsequent reads from it will return its default value. + mutating func clearXyzzy() {self._xyzzy = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _xyzzy: Int32? = nil +} + +/// Note that we try various different ways of naming the same extension. +struct Proto2Unittest_VariousComplexOptions: Sendable { + // 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 Proto2Unittest_AggregateMessageSet: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +struct Proto2Unittest_AggregateMessageSetElement: Sendable { + // 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 s: String { + get {_s ?? String()} + set {_s = newValue} + } + /// Returns true if `s` has been explicitly set. + var hasS: Bool {self._s != nil} + /// Clears the value of `s`. Subsequent reads from it will return its default value. + mutating func clearS() {self._s = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _s: String? = nil +} + +/// A helper type used to test aggregate option parsing +struct Proto2Unittest_Aggregate: @unchecked Sendable { + // 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 i: Int32 { + get {_storage._i ?? 0} + set {_uniqueStorage()._i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {_storage._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {_uniqueStorage()._i = nil} + + var s: String { + get {_storage._s ?? String()} + set {_uniqueStorage()._s = newValue} + } + /// Returns true if `s` has been explicitly set. + var hasS: Bool {_storage._s != nil} + /// Clears the value of `s`. Subsequent reads from it will return its default value. + mutating func clearS() {_uniqueStorage()._s = nil} + + /// A nested object + var sub: Proto2Unittest_Aggregate { + get {_storage._sub ?? Proto2Unittest_Aggregate()} + set {_uniqueStorage()._sub = newValue} + } + /// Returns true if `sub` has been explicitly set. + var hasSub: Bool {_storage._sub != nil} + /// Clears the value of `sub`. Subsequent reads from it will return its default value. + mutating func clearSub() {_uniqueStorage()._sub = nil} + + /// To test the parsing of extensions inside aggregate values + var file: SwiftProtobuf.Google_Protobuf_FileOptions { + get {_storage._file ?? SwiftProtobuf.Google_Protobuf_FileOptions()} + set {_uniqueStorage()._file = newValue} + } + /// Returns true if `file` has been explicitly set. + var hasFile: Bool {_storage._file != nil} + /// Clears the value of `file`. Subsequent reads from it will return its default value. + mutating func clearFile() {_uniqueStorage()._file = nil} + + /// An embedded message set + var mset: Proto2Unittest_AggregateMessageSet { + get {_storage._mset ?? Proto2Unittest_AggregateMessageSet()} + set {_uniqueStorage()._mset = newValue} + } + /// Returns true if `mset` has been explicitly set. + var hasMset: Bool {_storage._mset != nil} + /// Clears the value of `mset`. Subsequent reads from it will return its default value. + mutating func clearMset() {_uniqueStorage()._mset = nil} + + /// An any + var any: SwiftProtobuf.Google_Protobuf_Any { + get {_storage._any ?? SwiftProtobuf.Google_Protobuf_Any()} + set {_uniqueStorage()._any = newValue} + } + /// Returns true if `any` has been explicitly set. + var hasAny: Bool {_storage._any != nil} + /// Clears the value of `any`. Subsequent reads from it will return its default value. + mutating func clearAny() {_uniqueStorage()._any = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Proto2Unittest_AggregateMessage: Sendable { + // 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 fieldname: Int32 { + get {_fieldname ?? 0} + set {_fieldname = newValue} + } + /// Returns true if `fieldname` has been explicitly set. + var hasFieldname: Bool {self._fieldname != nil} + /// Clears the value of `fieldname`. Subsequent reads from it will return its default value. + mutating func clearFieldname() {self._fieldname = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _fieldname: Int32? = nil +} + +/// Test custom options for nested type. +struct Proto2Unittest_NestedOptionType: Sendable { + // 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() + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case value = 1 + + init() { + self = .value + } + + } + + struct NestedMessage: Sendable { + // 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 nestedField: Int32 { + get {_nestedField ?? 0} + set {_nestedField = newValue} + } + /// Returns true if `nestedField` has been explicitly set. + var hasNestedField: Bool {self._nestedField != nil} + /// Clears the value of `nestedField`. Subsequent reads from it will return its default value. + mutating func clearNestedField() {self._nestedField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _nestedField: Int32? = nil + } + + init() {} +} + +/// Custom message option that has a required enum field. +/// WARNING: this is strongly discouraged! +struct Proto2Unittest_OldOptionType: Sendable { + // 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 value: Proto2Unittest_OldOptionType.TestEnum { + get {_value ?? .oldValue} + set {_value = newValue} + } + /// Returns true if `value` has been explicitly set. + var hasValue: Bool {self._value != nil} + /// Clears the value of `value`. Subsequent reads from it will return its default value. + mutating func clearValue() {self._value = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum TestEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case oldValue = 0 + + init() { + self = .oldValue + } + + } + + init() {} + + fileprivate var _value: Proto2Unittest_OldOptionType.TestEnum? = nil +} + +/// Updated version of the custom option above. +struct Proto2Unittest_NewOptionType: Sendable { + // 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 value: Proto2Unittest_NewOptionType.TestEnum { + get {_value ?? .oldValue} + set {_value = newValue} + } + /// Returns true if `value` has been explicitly set. + var hasValue: Bool {self._value != nil} + /// Clears the value of `value`. Subsequent reads from it will return its default value. + mutating func clearValue() {self._value = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum TestEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case oldValue = 0 + case newValue = 1 + + init() { + self = .oldValue + } + + } + + init() {} + + fileprivate var _value: Proto2Unittest_NewOptionType.TestEnum? = nil +} + +/// Test message using the "required_enum_opt" option defined above. +struct Proto2Unittest_TestMessageWithRequiredEnumOption: Sendable { + // 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() {} +} + +// MARK: - Extension support defined in unittest_custom_options.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 Proto2Unittest_AggregateMessageSet { + + var Proto2Unittest_AggregateMessageSetElement_messageSetExtension: Proto2Unittest_AggregateMessageSetElement { + get {return getExtensionValue(ext: Proto2Unittest_AggregateMessageSetElement.Extensions.message_set_extension) ?? Proto2Unittest_AggregateMessageSetElement()} + set {setExtensionValue(ext: Proto2Unittest_AggregateMessageSetElement.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_AggregateMessageSetElement.Extensions.message_set_extension` + /// has been explicitly set. + var hasProto2Unittest_AggregateMessageSetElement_messageSetExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_AggregateMessageSetElement.Extensions.message_set_extension) + } + /// Clears the value of extension `Proto2Unittest_AggregateMessageSetElement.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_AggregateMessageSetElement_messageSetExtension() { + clearExtensionValue(ext: Proto2Unittest_AggregateMessageSetElement.Extensions.message_set_extension) + } +} + +extension Proto2Unittest_ComplexOptionType1 { + + var Proto2Unittest_mooo: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_mooo) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_mooo, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_mooo` + /// has been explicitly set. + var hasProto2Unittest_mooo: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_mooo) + } + /// Clears the value of extension `Proto2Unittest_Extensions_mooo`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_mooo() { + clearExtensionValue(ext: Proto2Unittest_Extensions_mooo) + } + + var Proto2Unittest_corge: Proto2Unittest_ComplexOptionType3 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_corge) ?? Proto2Unittest_ComplexOptionType3()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_corge, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_corge` + /// has been explicitly set. + var hasProto2Unittest_corge: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_corge) + } + /// Clears the value of extension `Proto2Unittest_Extensions_corge`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_corge() { + clearExtensionValue(ext: Proto2Unittest_Extensions_corge) + } +} + +extension Proto2Unittest_ComplexOptionType2 { + + var Proto2Unittest_grault: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_grault) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_grault, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_grault` + /// has been explicitly set. + var hasProto2Unittest_grault: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_grault) + } + /// Clears the value of extension `Proto2Unittest_Extensions_grault`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_grault() { + clearExtensionValue(ext: Proto2Unittest_Extensions_grault) + } + + var Proto2Unittest_garply: Proto2Unittest_ComplexOptionType1 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_garply) ?? Proto2Unittest_ComplexOptionType1()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_garply, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_garply` + /// has been explicitly set. + var hasProto2Unittest_garply: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_garply) + } + /// Clears the value of extension `Proto2Unittest_Extensions_garply`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_garply() { + clearExtensionValue(ext: Proto2Unittest_Extensions_garply) + } +} + +extension SwiftProtobuf.Google_Protobuf_EnumOptions { + + var Proto2Unittest_enumOpt1: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_enum_opt1) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_enum_opt1, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_enum_opt1` + /// has been explicitly set. + var hasProto2Unittest_enumOpt1: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_enum_opt1) + } + /// Clears the value of extension `Proto2Unittest_Extensions_enum_opt1`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_enumOpt1() { + clearExtensionValue(ext: Proto2Unittest_Extensions_enum_opt1) + } + + var Proto2Unittest_enumopt: Proto2Unittest_Aggregate { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_enumopt) ?? Proto2Unittest_Aggregate()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_enumopt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_enumopt` + /// has been explicitly set. + var hasProto2Unittest_enumopt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_enumopt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_enumopt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_enumopt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_enumopt) + } +} + +extension SwiftProtobuf.Google_Protobuf_EnumValueOptions { + + var Proto2Unittest_enumValueOpt1: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_enum_value_opt1) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_enum_value_opt1, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_enum_value_opt1` + /// has been explicitly set. + var hasProto2Unittest_enumValueOpt1: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_enum_value_opt1) + } + /// Clears the value of extension `Proto2Unittest_Extensions_enum_value_opt1`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_enumValueOpt1() { + clearExtensionValue(ext: Proto2Unittest_Extensions_enum_value_opt1) + } + + var Proto2Unittest_enumvalopt: Proto2Unittest_Aggregate { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_enumvalopt) ?? Proto2Unittest_Aggregate()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_enumvalopt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_enumvalopt` + /// has been explicitly set. + var hasProto2Unittest_enumvalopt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_enumvalopt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_enumvalopt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_enumvalopt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_enumvalopt) + } +} + +extension SwiftProtobuf.Google_Protobuf_FieldOptions { + + var Proto2Unittest_fieldOpt1: UInt64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_field_opt1) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_field_opt1, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_field_opt1` + /// has been explicitly set. + var hasProto2Unittest_fieldOpt1: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_field_opt1) + } + /// Clears the value of extension `Proto2Unittest_Extensions_field_opt1`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_fieldOpt1() { + clearExtensionValue(ext: Proto2Unittest_Extensions_field_opt1) + } + + /// This is useful for testing that we correctly register default values for + /// extension options. + var Proto2Unittest_fieldOpt2: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_field_opt2) ?? 42} + set {setExtensionValue(ext: Proto2Unittest_Extensions_field_opt2, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_field_opt2` + /// has been explicitly set. + var hasProto2Unittest_fieldOpt2: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_field_opt2) + } + /// Clears the value of extension `Proto2Unittest_Extensions_field_opt2`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_fieldOpt2() { + clearExtensionValue(ext: Proto2Unittest_Extensions_field_opt2) + } + + var Proto2Unittest_fieldopt: Proto2Unittest_Aggregate { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_fieldopt) ?? Proto2Unittest_Aggregate()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_fieldopt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_fieldopt` + /// has been explicitly set. + var hasProto2Unittest_fieldopt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_fieldopt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_fieldopt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_fieldopt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_fieldopt) + } +} + +extension SwiftProtobuf.Google_Protobuf_FileOptions { + + var Proto2Unittest_fileOpt1: UInt64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_file_opt1) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_file_opt1, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_file_opt1` + /// has been explicitly set. + var hasProto2Unittest_fileOpt1: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_file_opt1) + } + /// Clears the value of extension `Proto2Unittest_Extensions_file_opt1`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_fileOpt1() { + clearExtensionValue(ext: Proto2Unittest_Extensions_file_opt1) + } + + var Proto2Unittest_fileopt: Proto2Unittest_Aggregate { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_fileopt) ?? Proto2Unittest_Aggregate()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_fileopt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_fileopt` + /// has been explicitly set. + var hasProto2Unittest_fileopt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_fileopt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_fileopt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_fileopt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_fileopt) + } + + var Proto2Unittest_Aggregate_nested: Proto2Unittest_Aggregate { + get {return getExtensionValue(ext: Proto2Unittest_Aggregate.Extensions.nested) ?? Proto2Unittest_Aggregate()} + set {setExtensionValue(ext: Proto2Unittest_Aggregate.Extensions.nested, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Aggregate.Extensions.nested` + /// has been explicitly set. + var hasProto2Unittest_Aggregate_nested: Bool { + return hasExtensionValue(ext: Proto2Unittest_Aggregate.Extensions.nested) + } + /// Clears the value of extension `Proto2Unittest_Aggregate.Extensions.nested`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_Aggregate_nested() { + clearExtensionValue(ext: Proto2Unittest_Aggregate.Extensions.nested) + } + + var Proto2Unittest_NestedOptionType_nestedExtension: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_NestedOptionType.Extensions.nested_extension) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_NestedOptionType.Extensions.nested_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_NestedOptionType.Extensions.nested_extension` + /// has been explicitly set. + var hasProto2Unittest_NestedOptionType_nestedExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_NestedOptionType.Extensions.nested_extension) + } + /// Clears the value of extension `Proto2Unittest_NestedOptionType.Extensions.nested_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_NestedOptionType_nestedExtension() { + clearExtensionValue(ext: Proto2Unittest_NestedOptionType.Extensions.nested_extension) + } +} + +extension SwiftProtobuf.Google_Protobuf_MessageOptions { + + var Proto2Unittest_messageOpt1: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_message_opt1) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_message_opt1, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_message_opt1` + /// has been explicitly set. + var hasProto2Unittest_messageOpt1: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_message_opt1) + } + /// Clears the value of extension `Proto2Unittest_Extensions_message_opt1`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_messageOpt1() { + clearExtensionValue(ext: Proto2Unittest_Extensions_message_opt1) + } + + var Proto2Unittest_boolOpt: Bool { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_bool_opt) ?? false} + set {setExtensionValue(ext: Proto2Unittest_Extensions_bool_opt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_bool_opt` + /// has been explicitly set. + var hasProto2Unittest_boolOpt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_bool_opt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_bool_opt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_boolOpt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_bool_opt) + } + + var Proto2Unittest_int32Opt: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_int32_opt) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_int32_opt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_int32_opt` + /// has been explicitly set. + var hasProto2Unittest_int32Opt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_int32_opt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_int32_opt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_int32Opt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_int32_opt) + } + + var Proto2Unittest_int64Opt: Int64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_int64_opt) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_int64_opt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_int64_opt` + /// has been explicitly set. + var hasProto2Unittest_int64Opt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_int64_opt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_int64_opt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_int64Opt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_int64_opt) + } + + var Proto2Unittest_uint32Opt: UInt32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_uint32_opt) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_uint32_opt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_uint32_opt` + /// has been explicitly set. + var hasProto2Unittest_uint32Opt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_uint32_opt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_uint32_opt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_uint32Opt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_uint32_opt) + } + + var Proto2Unittest_uint64Opt: UInt64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_uint64_opt) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_uint64_opt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_uint64_opt` + /// has been explicitly set. + var hasProto2Unittest_uint64Opt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_uint64_opt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_uint64_opt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_uint64Opt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_uint64_opt) + } + + var Proto2Unittest_sint32Opt: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_sint32_opt) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_sint32_opt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_sint32_opt` + /// has been explicitly set. + var hasProto2Unittest_sint32Opt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_sint32_opt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_sint32_opt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_sint32Opt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_sint32_opt) + } + + var Proto2Unittest_sint64Opt: Int64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_sint64_opt) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_sint64_opt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_sint64_opt` + /// has been explicitly set. + var hasProto2Unittest_sint64Opt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_sint64_opt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_sint64_opt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_sint64Opt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_sint64_opt) + } + + var Proto2Unittest_fixed32Opt: UInt32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_fixed32_opt) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_fixed32_opt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_fixed32_opt` + /// has been explicitly set. + var hasProto2Unittest_fixed32Opt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_fixed32_opt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_fixed32_opt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_fixed32Opt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_fixed32_opt) + } + + var Proto2Unittest_fixed64Opt: UInt64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_fixed64_opt) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_fixed64_opt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_fixed64_opt` + /// has been explicitly set. + var hasProto2Unittest_fixed64Opt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_fixed64_opt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_fixed64_opt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_fixed64Opt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_fixed64_opt) + } + + var Proto2Unittest_sfixed32Opt: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_sfixed32_opt) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_sfixed32_opt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_sfixed32_opt` + /// has been explicitly set. + var hasProto2Unittest_sfixed32Opt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_sfixed32_opt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_sfixed32_opt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_sfixed32Opt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_sfixed32_opt) + } + + var Proto2Unittest_sfixed64Opt: Int64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_sfixed64_opt) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_sfixed64_opt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_sfixed64_opt` + /// has been explicitly set. + var hasProto2Unittest_sfixed64Opt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_sfixed64_opt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_sfixed64_opt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_sfixed64Opt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_sfixed64_opt) + } + + var Proto2Unittest_floatOpt: Float { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_float_opt) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_float_opt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_float_opt` + /// has been explicitly set. + var hasProto2Unittest_floatOpt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_float_opt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_float_opt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_floatOpt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_float_opt) + } + + var Proto2Unittest_doubleOpt: Double { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_double_opt) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_double_opt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_double_opt` + /// has been explicitly set. + var hasProto2Unittest_doubleOpt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_double_opt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_double_opt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_doubleOpt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_double_opt) + } + + var Proto2Unittest_stringOpt: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_string_opt) ?? String()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_string_opt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_string_opt` + /// has been explicitly set. + var hasProto2Unittest_stringOpt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_string_opt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_string_opt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_stringOpt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_string_opt) + } + + var Proto2Unittest_bytesOpt: Data { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_bytes_opt) ?? Data()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_bytes_opt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_bytes_opt` + /// has been explicitly set. + var hasProto2Unittest_bytesOpt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_bytes_opt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_bytes_opt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_bytesOpt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_bytes_opt) + } + + var Proto2Unittest_enumOpt: Proto2Unittest_DummyMessageContainingEnum.TestEnumType { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_enum_opt) ?? .testOptionEnumType1} + set {setExtensionValue(ext: Proto2Unittest_Extensions_enum_opt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_enum_opt` + /// has been explicitly set. + var hasProto2Unittest_enumOpt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_enum_opt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_enum_opt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_enumOpt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_enum_opt) + } + + var Proto2Unittest_messageTypeOpt: Proto2Unittest_DummyMessageInvalidAsOptionType { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_message_type_opt) ?? Proto2Unittest_DummyMessageInvalidAsOptionType()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_message_type_opt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_message_type_opt` + /// has been explicitly set. + var hasProto2Unittest_messageTypeOpt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_message_type_opt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_message_type_opt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_messageTypeOpt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_message_type_opt) + } + + var Proto2Unittest_complexOpt1: Proto2Unittest_ComplexOptionType1 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_complex_opt1) ?? Proto2Unittest_ComplexOptionType1()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_complex_opt1, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_complex_opt1` + /// has been explicitly set. + var hasProto2Unittest_complexOpt1: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_complex_opt1) + } + /// Clears the value of extension `Proto2Unittest_Extensions_complex_opt1`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_complexOpt1() { + clearExtensionValue(ext: Proto2Unittest_Extensions_complex_opt1) + } + + var Proto2Unittest_complexOpt2: Proto2Unittest_ComplexOptionType2 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_complex_opt2) ?? Proto2Unittest_ComplexOptionType2()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_complex_opt2, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_complex_opt2` + /// has been explicitly set. + var hasProto2Unittest_complexOpt2: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_complex_opt2) + } + /// Clears the value of extension `Proto2Unittest_Extensions_complex_opt2`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_complexOpt2() { + clearExtensionValue(ext: Proto2Unittest_Extensions_complex_opt2) + } + + var Proto2Unittest_complexOpt3: Proto2Unittest_ComplexOptionType3 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_complex_opt3) ?? Proto2Unittest_ComplexOptionType3()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_complex_opt3, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_complex_opt3` + /// has been explicitly set. + var hasProto2Unittest_complexOpt3: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_complex_opt3) + } + /// Clears the value of extension `Proto2Unittest_Extensions_complex_opt3`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_complexOpt3() { + clearExtensionValue(ext: Proto2Unittest_Extensions_complex_opt3) + } + + var Proto2Unittest_complexOpt6: Proto2Unittest_ComplexOpt6 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_ComplexOpt6) ?? Proto2Unittest_ComplexOpt6()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_ComplexOpt6, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_ComplexOpt6` + /// has been explicitly set. + var hasProto2Unittest_complexOpt6: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_ComplexOpt6) + } + /// Clears the value of extension `Proto2Unittest_Extensions_ComplexOpt6`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_complexOpt6() { + clearExtensionValue(ext: Proto2Unittest_Extensions_ComplexOpt6) + } + + var Proto2Unittest_msgopt: Proto2Unittest_Aggregate { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_msgopt) ?? Proto2Unittest_Aggregate()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_msgopt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_msgopt` + /// has been explicitly set. + var hasProto2Unittest_msgopt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_msgopt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_msgopt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_msgopt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_msgopt) + } + + var Proto2Unittest_requiredEnumOpt: Proto2Unittest_OldOptionType { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_required_enum_opt) ?? Proto2Unittest_OldOptionType()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_required_enum_opt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_required_enum_opt` + /// has been explicitly set. + var hasProto2Unittest_requiredEnumOpt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_required_enum_opt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_required_enum_opt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_requiredEnumOpt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_required_enum_opt) + } + + var Proto2Unittest_ComplexOptionType2_ComplexOptionType4_complexOpt4: Proto2Unittest_ComplexOptionType2.ComplexOptionType4 { + get {return getExtensionValue(ext: Proto2Unittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4) ?? Proto2Unittest_ComplexOptionType2.ComplexOptionType4()} + set {setExtensionValue(ext: Proto2Unittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4` + /// has been explicitly set. + var hasProto2Unittest_ComplexOptionType2_ComplexOptionType4_complexOpt4: Bool { + return hasExtensionValue(ext: Proto2Unittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4) + } + /// Clears the value of extension `Proto2Unittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_ComplexOptionType2_ComplexOptionType4_complexOpt4() { + clearExtensionValue(ext: Proto2Unittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4) + } +} + +extension SwiftProtobuf.Google_Protobuf_MethodOptions { + + var Proto2Unittest_methodOpt1: Proto2Unittest_MethodOpt1 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_method_opt1) ?? .val1} + set {setExtensionValue(ext: Proto2Unittest_Extensions_method_opt1, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_method_opt1` + /// has been explicitly set. + var hasProto2Unittest_methodOpt1: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_method_opt1) + } + /// Clears the value of extension `Proto2Unittest_Extensions_method_opt1`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_methodOpt1() { + clearExtensionValue(ext: Proto2Unittest_Extensions_method_opt1) + } + + var Proto2Unittest_methodopt: Proto2Unittest_Aggregate { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_methodopt) ?? Proto2Unittest_Aggregate()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_methodopt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_methodopt` + /// has been explicitly set. + var hasProto2Unittest_methodopt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_methodopt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_methodopt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_methodopt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_methodopt) + } +} + +extension SwiftProtobuf.Google_Protobuf_OneofOptions { + + var Proto2Unittest_oneofOpt1: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_oneof_opt1) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_oneof_opt1, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_oneof_opt1` + /// has been explicitly set. + var hasProto2Unittest_oneofOpt1: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_oneof_opt1) + } + /// Clears the value of extension `Proto2Unittest_Extensions_oneof_opt1`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_oneofOpt1() { + clearExtensionValue(ext: Proto2Unittest_Extensions_oneof_opt1) + } +} + +extension SwiftProtobuf.Google_Protobuf_ServiceOptions { + + var Proto2Unittest_serviceOpt1: Int64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_service_opt1) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_service_opt1, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_service_opt1` + /// has been explicitly set. + var hasProto2Unittest_serviceOpt1: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_service_opt1) + } + /// Clears the value of extension `Proto2Unittest_Extensions_service_opt1`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_serviceOpt1() { + clearExtensionValue(ext: Proto2Unittest_Extensions_service_opt1) + } + + var Proto2Unittest_serviceopt: Proto2Unittest_Aggregate { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_serviceopt) ?? Proto2Unittest_Aggregate()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_serviceopt, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_serviceopt` + /// has been explicitly set. + var hasProto2Unittest_serviceopt: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_serviceopt) + } + /// Clears the value of extension `Proto2Unittest_Extensions_serviceopt`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_serviceopt() { + clearExtensionValue(ext: Proto2Unittest_Extensions_serviceopt) + } + +} + +// MARK: - File's ExtensionMap: Proto2Unittest_UnittestCustomOptions_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 Proto2Unittest_UnittestCustomOptions_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Proto2Unittest_Extensions_file_opt1, + Proto2Unittest_Extensions_message_opt1, + Proto2Unittest_Extensions_field_opt1, + Proto2Unittest_Extensions_field_opt2, + Proto2Unittest_Extensions_oneof_opt1, + Proto2Unittest_Extensions_enum_opt1, + Proto2Unittest_Extensions_enum_value_opt1, + Proto2Unittest_Extensions_service_opt1, + Proto2Unittest_Extensions_method_opt1, + Proto2Unittest_Extensions_bool_opt, + Proto2Unittest_Extensions_int32_opt, + Proto2Unittest_Extensions_int64_opt, + Proto2Unittest_Extensions_uint32_opt, + Proto2Unittest_Extensions_uint64_opt, + Proto2Unittest_Extensions_sint32_opt, + Proto2Unittest_Extensions_sint64_opt, + Proto2Unittest_Extensions_fixed32_opt, + Proto2Unittest_Extensions_fixed64_opt, + Proto2Unittest_Extensions_sfixed32_opt, + Proto2Unittest_Extensions_sfixed64_opt, + Proto2Unittest_Extensions_float_opt, + Proto2Unittest_Extensions_double_opt, + Proto2Unittest_Extensions_string_opt, + Proto2Unittest_Extensions_bytes_opt, + Proto2Unittest_Extensions_enum_opt, + Proto2Unittest_Extensions_message_type_opt, + Proto2Unittest_Extensions_mooo, + Proto2Unittest_Extensions_corge, + Proto2Unittest_Extensions_grault, + Proto2Unittest_Extensions_garply, + Proto2Unittest_Extensions_complex_opt1, + Proto2Unittest_Extensions_complex_opt2, + Proto2Unittest_Extensions_complex_opt3, + Proto2Unittest_Extensions_ComplexOpt6, + Proto2Unittest_Extensions_fileopt, + Proto2Unittest_Extensions_msgopt, + Proto2Unittest_Extensions_fieldopt, + Proto2Unittest_Extensions_enumopt, + Proto2Unittest_Extensions_enumvalopt, + Proto2Unittest_Extensions_serviceopt, + Proto2Unittest_Extensions_methodopt, + Proto2Unittest_Extensions_required_enum_opt, + Proto2Unittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4, + Proto2Unittest_AggregateMessageSetElement.Extensions.message_set_extension, + Proto2Unittest_Aggregate.Extensions.nested, + Proto2Unittest_NestedOptionType.Extensions.nested_extension +] + +// 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 Proto2Unittest_Extensions_file_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( + _protobuf_fieldNumber: 7736974, + fieldName: "proto2_unittest.file_opt1" +) + +let Proto2Unittest_Extensions_message_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7739036, + fieldName: "proto2_unittest.message_opt1" +) + +let Proto2Unittest_Extensions_field_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FieldOptions>( + _protobuf_fieldNumber: 7740936, + fieldName: "proto2_unittest.field_opt1" +) + +/// This is useful for testing that we correctly register default values for +/// extension options. +let Proto2Unittest_Extensions_field_opt2 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FieldOptions>( + _protobuf_fieldNumber: 7753913, + fieldName: "proto2_unittest.field_opt2" +) + +let Proto2Unittest_Extensions_oneof_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_OneofOptions>( + _protobuf_fieldNumber: 7740111, + fieldName: "proto2_unittest.oneof_opt1" +) + +let Proto2Unittest_Extensions_enum_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_EnumOptions>( + _protobuf_fieldNumber: 7753576, + fieldName: "proto2_unittest.enum_opt1" +) + +let Proto2Unittest_Extensions_enum_value_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_EnumValueOptions>( + _protobuf_fieldNumber: 1560678, + fieldName: "proto2_unittest.enum_value_opt1" +) + +let Proto2Unittest_Extensions_service_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_ServiceOptions>( + _protobuf_fieldNumber: 7887650, + fieldName: "proto2_unittest.service_opt1" +) + +let Proto2Unittest_Extensions_method_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MethodOptions>( + _protobuf_fieldNumber: 7890860, + fieldName: "proto2_unittest.method_opt1" +) + +let Proto2Unittest_Extensions_bool_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7706090, + fieldName: "proto2_unittest.bool_opt" +) + +let Proto2Unittest_Extensions_int32_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7705709, + fieldName: "proto2_unittest.int32_opt" +) + +let Proto2Unittest_Extensions_int64_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7705542, + fieldName: "proto2_unittest.int64_opt" +) + +let Proto2Unittest_Extensions_uint32_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7704880, + fieldName: "proto2_unittest.uint32_opt" +) + +let Proto2Unittest_Extensions_uint64_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7702367, + fieldName: "proto2_unittest.uint64_opt" +) + +let Proto2Unittest_Extensions_sint32_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7701568, + fieldName: "proto2_unittest.sint32_opt" +) + +let Proto2Unittest_Extensions_sint64_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7700863, + fieldName: "proto2_unittest.sint64_opt" +) + +let Proto2Unittest_Extensions_fixed32_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7700307, + fieldName: "proto2_unittest.fixed32_opt" +) + +let Proto2Unittest_Extensions_fixed64_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7700194, + fieldName: "proto2_unittest.fixed64_opt" +) + +let Proto2Unittest_Extensions_sfixed32_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7698645, + fieldName: "proto2_unittest.sfixed32_opt" +) + +let Proto2Unittest_Extensions_sfixed64_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7685475, + fieldName: "proto2_unittest.sfixed64_opt" +) + +let Proto2Unittest_Extensions_float_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7675390, + fieldName: "proto2_unittest.float_opt" +) + +let Proto2Unittest_Extensions_double_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7673293, + fieldName: "proto2_unittest.double_opt" +) + +let Proto2Unittest_Extensions_string_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7673285, + fieldName: "proto2_unittest.string_opt" +) + +let Proto2Unittest_Extensions_bytes_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7673238, + fieldName: "proto2_unittest.bytes_opt" +) + +let Proto2Unittest_Extensions_enum_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7673233, + fieldName: "proto2_unittest.enum_opt" +) + +let Proto2Unittest_Extensions_message_type_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7665967, + fieldName: "proto2_unittest.message_type_opt" +) + +let Proto2Unittest_Extensions_mooo = SwiftProtobuf.MessageExtension, Proto2Unittest_ComplexOptionType1>( + _protobuf_fieldNumber: 7663707, + fieldName: "proto2_unittest.mooo" +) + +let Proto2Unittest_Extensions_corge = SwiftProtobuf.MessageExtension, Proto2Unittest_ComplexOptionType1>( + _protobuf_fieldNumber: 7663442, + fieldName: "proto2_unittest.corge" +) + +let Proto2Unittest_Extensions_grault = SwiftProtobuf.MessageExtension, Proto2Unittest_ComplexOptionType2>( + _protobuf_fieldNumber: 7650927, + fieldName: "proto2_unittest.grault" +) + +let Proto2Unittest_Extensions_garply = SwiftProtobuf.MessageExtension, Proto2Unittest_ComplexOptionType2>( + _protobuf_fieldNumber: 7649992, + fieldName: "proto2_unittest.garply" +) + +let Proto2Unittest_Extensions_complex_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7646756, + fieldName: "proto2_unittest.complex_opt1" +) + +let Proto2Unittest_Extensions_complex_opt2 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7636949, + fieldName: "proto2_unittest.complex_opt2" +) + +let Proto2Unittest_Extensions_complex_opt3 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7636463, + fieldName: "proto2_unittest.complex_opt3" +) + +let Proto2Unittest_Extensions_ComplexOpt6 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7595468, + fieldName: "proto2_unittest.complexopt6" +) + +let Proto2Unittest_Extensions_fileopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( + _protobuf_fieldNumber: 15478479, + fieldName: "proto2_unittest.fileopt" +) + +let Proto2Unittest_Extensions_msgopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 15480088, + fieldName: "proto2_unittest.msgopt" +) + +let Proto2Unittest_Extensions_fieldopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FieldOptions>( + _protobuf_fieldNumber: 15481374, + fieldName: "proto2_unittest.fieldopt" +) + +let Proto2Unittest_Extensions_enumopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_EnumOptions>( + _protobuf_fieldNumber: 15483218, + fieldName: "proto2_unittest.enumopt" +) + +let Proto2Unittest_Extensions_enumvalopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_EnumValueOptions>( + _protobuf_fieldNumber: 15486921, + fieldName: "proto2_unittest.enumvalopt" +) + +let Proto2Unittest_Extensions_serviceopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_ServiceOptions>( + _protobuf_fieldNumber: 15497145, + fieldName: "proto2_unittest.serviceopt" +) + +let Proto2Unittest_Extensions_methodopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MethodOptions>( + _protobuf_fieldNumber: 15512713, + fieldName: "proto2_unittest.methodopt" +) + +let Proto2Unittest_Extensions_required_enum_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 106161807, + fieldName: "proto2_unittest.required_enum_opt" +) + +extension Proto2Unittest_ComplexOptionType2.ComplexOptionType4 { + enum Extensions { + static let complex_opt4 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7633546, + fieldName: "proto2_unittest.ComplexOptionType2.ComplexOptionType4.complex_opt4" + ) + } +} + +extension Proto2Unittest_AggregateMessageSetElement { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_AggregateMessageSet>( + _protobuf_fieldNumber: 15447542, + fieldName: "proto2_unittest.AggregateMessageSetElement" + ) + } +} + +extension Proto2Unittest_Aggregate { + enum Extensions { + static let nested = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( + _protobuf_fieldNumber: 15476903, + fieldName: "proto2_unittest.Aggregate.nested" + ) + } +} + +extension Proto2Unittest_NestedOptionType { + enum Extensions { + static let nested_extension = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( + _protobuf_fieldNumber: 7912573, + fieldName: "proto2_unittest.NestedOptionType.nested_extension" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest" + +extension Proto2Unittest_MethodOpt1: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}METHODOPT1_VAL1\0\u{1}METHODOPT1_VAL2\0") +} + +extension Proto2Unittest_AggregateEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}VALUE\0") +} + +extension Proto2Unittest_TestMessageWithCustomOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageWithCustomOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field1\0\u{3}oneof_field\0\u{3}map_field\0") + + 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._field1) }() + case 2: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.anOneof != nil {try decoder.handleConflictingOneOf()} + self.anOneof = .oneofField(v) + } + }() + case 3: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.mapField) }() + 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 + try { if let v = self._field1 { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if case .oneofField(let v)? = self.anOneof { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + if !self.mapField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.mapField, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMessageWithCustomOptions, rhs: Proto2Unittest_TestMessageWithCustomOptions) -> Bool { + if lhs._field1 != rhs._field1 {return false} + if lhs.anOneof != rhs.anOneof {return false} + if lhs.mapField != rhs.mapField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMessageWithCustomOptions.AnEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ANENUM_VAL1\0\u{1}ANENUM_VAL2\0") +} + +extension Proto2Unittest_CustomOptionFooRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".CustomOptionFooRequest" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_CustomOptionFooRequest, rhs: Proto2Unittest_CustomOptionFooRequest) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_CustomOptionFooResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".CustomOptionFooResponse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_CustomOptionFooResponse, rhs: Proto2Unittest_CustomOptionFooResponse) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_CustomOptionFooClientMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".CustomOptionFooClientMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_CustomOptionFooClientMessage, rhs: Proto2Unittest_CustomOptionFooClientMessage) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_CustomOptionFooServerMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".CustomOptionFooServerMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_CustomOptionFooServerMessage, rhs: Proto2Unittest_CustomOptionFooServerMessage) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_DummyMessageContainingEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".DummyMessageContainingEnum" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_DummyMessageContainingEnum, rhs: Proto2Unittest_DummyMessageContainingEnum) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_DummyMessageContainingEnum.TestEnumType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}i\u{7f}\u{7f}\u{7f}\u{7f}\u{3}TEST_OPTION_ENUM_TYPE2\0\u{2}-TEST_OPTION_ENUM_TYPE1\0") +} + +extension Proto2Unittest_DummyMessageInvalidAsOptionType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".DummyMessageInvalidAsOptionType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_DummyMessageInvalidAsOptionType, rhs: Proto2Unittest_DummyMessageInvalidAsOptionType) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_CustomOptionMinIntegerValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".CustomOptionMinIntegerValues" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_CustomOptionMinIntegerValues, rhs: Proto2Unittest_CustomOptionMinIntegerValues) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_CustomOptionMaxIntegerValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".CustomOptionMaxIntegerValues" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_CustomOptionMaxIntegerValues, rhs: Proto2Unittest_CustomOptionMaxIntegerValues) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_CustomOptionOtherValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".CustomOptionOtherValues" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_CustomOptionOtherValues, rhs: Proto2Unittest_CustomOptionOtherValues) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_SettingRealsFromPositiveInts: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".SettingRealsFromPositiveInts" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_SettingRealsFromPositiveInts, rhs: Proto2Unittest_SettingRealsFromPositiveInts) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_SettingRealsFromNegativeInts: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".SettingRealsFromNegativeInts" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_SettingRealsFromNegativeInts, rhs: Proto2Unittest_SettingRealsFromNegativeInts) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_SettingRealsFromInf: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".SettingRealsFromInf" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_SettingRealsFromInf, rhs: Proto2Unittest_SettingRealsFromInf) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_SettingRealsFromNegativeInf: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".SettingRealsFromNegativeInf" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_SettingRealsFromNegativeInf, rhs: Proto2Unittest_SettingRealsFromNegativeInf) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_SettingRealsFromNan: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".SettingRealsFromNan" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_SettingRealsFromNan, rhs: Proto2Unittest_SettingRealsFromNan) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_SettingRealsFromNegativeNan: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".SettingRealsFromNegativeNan" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_SettingRealsFromNegativeNan, rhs: Proto2Unittest_SettingRealsFromNegativeNan) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_ComplexOptionType1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ComplexOptionType1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}foo\0\u{1}foo2\0\u{1}foo3\0\u{1}foo4\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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._foo) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._foo2) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._foo3) }() + case 4: try { try decoder.decodeRepeatedInt32Field(value: &self.foo4) }() + case 100..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_ComplexOptionType1.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._foo { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._foo2 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._foo3 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + if !self.foo4.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.foo4, fieldNumber: 4) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 100, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_ComplexOptionType1, rhs: Proto2Unittest_ComplexOptionType1) -> Bool { + if lhs._foo != rhs._foo {return false} + if lhs._foo2 != rhs._foo2 {return false} + if lhs._foo3 != rhs._foo3 {return false} + if lhs.foo4 != rhs.foo4 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_ComplexOptionType2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ComplexOptionType2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bar\0\u{1}baz\0\u{1}fred\0\u{1}barney\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + if let v = self._bar, !v.isInitialized {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._bar) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._baz) }() + case 3: try { try decoder.decodeSingularMessageField(value: &self._fred) }() + case 4: try { try decoder.decodeRepeatedMessageField(value: &self.barney) }() + case 100..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_ComplexOptionType2.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._bar { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = self._baz { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._fred { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + if !self.barney.isEmpty { + try visitor.visitRepeatedMessageField(value: self.barney, fieldNumber: 4) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 100, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_ComplexOptionType2, rhs: Proto2Unittest_ComplexOptionType2) -> Bool { + if lhs._bar != rhs._bar {return false} + if lhs._baz != rhs._baz {return false} + if lhs._fred != rhs._fred {return false} + if lhs.barney != rhs.barney {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_ComplexOptionType2.ComplexOptionType4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_ComplexOptionType2.protoMessageName + ".ComplexOptionType4" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}waldo\0") + + 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._waldo) }() + 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 + try { if let v = self._waldo { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_ComplexOptionType2.ComplexOptionType4, rhs: Proto2Unittest_ComplexOptionType2.ComplexOptionType4) -> Bool { + if lhs._waldo != rhs._waldo {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_ComplexOptionType3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ComplexOptionType3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}moo\0\u{7}ComplexOptionType5\0") + + 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._moo) }() + case 2: try { try decoder.decodeSingularGroupField(value: &self._complexOptionType5) }() + 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 + try { if let v = self._moo { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._complexOptionType5 { + try visitor.visitSingularGroupField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_ComplexOptionType3, rhs: Proto2Unittest_ComplexOptionType3) -> Bool { + if lhs._moo != rhs._moo {return false} + if lhs._complexOptionType5 != rhs._complexOptionType5 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_ComplexOptionType3.ComplexOptionType5: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_ComplexOptionType3.protoMessageName + ".ComplexOptionType5" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{3}plugh\0") + + 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 3: try { try decoder.decodeSingularInt32Field(value: &self._plugh) }() + 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 + try { if let v = self._plugh { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_ComplexOptionType3.ComplexOptionType5, rhs: Proto2Unittest_ComplexOptionType3.ComplexOptionType5) -> Bool { + if lhs._plugh != rhs._plugh {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_ComplexOpt6: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ComplexOpt6" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}_\u{7f}}\u{1c}xyzzy\0") + + 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 7593951: try { try decoder.decodeSingularInt32Field(value: &self._xyzzy) }() + 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 + try { if let v = self._xyzzy { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 7593951) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_ComplexOpt6, rhs: Proto2Unittest_ComplexOpt6) -> Bool { + if lhs._xyzzy != rhs._xyzzy {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_VariousComplexOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".VariousComplexOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_VariousComplexOptions, rhs: Proto2Unittest_VariousComplexOptions) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_AggregateMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".AggregateMessageSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_AggregateMessageSet.self) + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_AggregateMessageSet, rhs: Proto2Unittest_AggregateMessageSet) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_AggregateMessageSetElement: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".AggregateMessageSetElement" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}s\0") + + 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._s) }() + 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 + try { if let v = self._s { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_AggregateMessageSetElement, rhs: Proto2Unittest_AggregateMessageSetElement) -> Bool { + if lhs._s != rhs._s {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_Aggregate: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Aggregate" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}i\0\u{1}s\0\u{1}sub\0\u{1}file\0\u{1}mset\0\u{1}any\0") + + fileprivate class _StorageClass { + var _i: Int32? = nil + var _s: String? = nil + var _sub: Proto2Unittest_Aggregate? = nil + var _file: SwiftProtobuf.Google_Protobuf_FileOptions? = nil + var _mset: Proto2Unittest_AggregateMessageSet? = nil + var _any: SwiftProtobuf.Google_Protobuf_Any? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _i = source._i + _s = source._s + _sub = source._sub + _file = source._file + _mset = source._mset + _any = source._any + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._sub, !v.isInitialized {return false} + if let v = _storage._file, !v.isInitialized {return false} + if let v = _storage._mset, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._i) }() + case 2: try { try decoder.decodeSingularStringField(value: &_storage._s) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._sub) }() + case 4: try { try decoder.decodeSingularMessageField(value: &_storage._file) }() + case 5: try { try decoder.decodeSingularMessageField(value: &_storage._mset) }() + case 6: try { try decoder.decodeSingularMessageField(value: &_storage._any) }() + default: break + } + } + } + } + + func traverse(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._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._s { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._sub { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._file { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._mset { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._any { + try visitor.visitSingularMessageField(value: v, fieldNumber: 6) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_Aggregate, rhs: Proto2Unittest_Aggregate) -> 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._i != rhs_storage._i {return false} + if _storage._s != rhs_storage._s {return false} + if _storage._sub != rhs_storage._sub {return false} + if _storage._file != rhs_storage._file {return false} + if _storage._mset != rhs_storage._mset {return false} + if _storage._any != rhs_storage._any {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_AggregateMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".AggregateMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fieldname\0") + + 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._fieldname) }() + 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 + try { if let v = self._fieldname { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_AggregateMessage, rhs: Proto2Unittest_AggregateMessage) -> Bool { + if lhs._fieldname != rhs._fieldname {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_NestedOptionType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NestedOptionType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_NestedOptionType, rhs: Proto2Unittest_NestedOptionType) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_NestedOptionType.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}NESTED_ENUM_VALUE\0") +} + +extension Proto2Unittest_NestedOptionType.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_NestedOptionType.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}nested_field\0") + + 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._nestedField) }() + 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 + try { if let v = self._nestedField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_NestedOptionType.NestedMessage, rhs: Proto2Unittest_NestedOptionType.NestedMessage) -> Bool { + if lhs._nestedField != rhs._nestedField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_OldOptionType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OldOptionType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}value\0") + + public var isInitialized: Bool { + if self._value == nil {return false} + return true + } + + 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._value) }() + 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 + try { if let v = self._value { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_OldOptionType, rhs: Proto2Unittest_OldOptionType) -> Bool { + if lhs._value != rhs._value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_OldOptionType.TestEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0OLD_VALUE\0") +} + +extension Proto2Unittest_NewOptionType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NewOptionType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}value\0") + + public var isInitialized: Bool { + if self._value == nil {return false} + return true + } + + 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._value) }() + 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 + try { if let v = self._value { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_NewOptionType, rhs: Proto2Unittest_NewOptionType) -> Bool { + if lhs._value != rhs._value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_NewOptionType.TestEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0OLD_VALUE\0\u{1}NEW_VALUE\0") +} + +extension Proto2Unittest_TestMessageWithRequiredEnumOption: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageWithRequiredEnumOption" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMessageWithRequiredEnumOption, rhs: Proto2Unittest_TestMessageWithRequiredEnumOption) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/unittest_custom_options_unlinked.pb.swift b/Reference/upstream/google/protobuf/unittest_custom_options_unlinked.pb.swift new file mode 100644 index 000000000..f747abc20 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_custom_options_unlinked.pb.swift @@ -0,0 +1,129 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_custom_options_unlinked.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: benjy@google.com (Benjy Weinberger) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// A proto file used to test the "custom options" feature when not linked in. + +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 +} + +// MARK: - Extension support defined in unittest_custom_options_unlinked.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 Proto2UnittestUnlinked_fieldOpt1: UInt64 { + get {return getExtensionValue(ext: Proto2UnittestUnlinked_Extensions_field_opt1) ?? 0} + set {setExtensionValue(ext: Proto2UnittestUnlinked_Extensions_field_opt1, value: newValue)} + } + /// Returns true if extension `Proto2UnittestUnlinked_Extensions_field_opt1` + /// has been explicitly set. + var hasProto2UnittestUnlinked_fieldOpt1: Bool { + return hasExtensionValue(ext: Proto2UnittestUnlinked_Extensions_field_opt1) + } + /// Clears the value of extension `Proto2UnittestUnlinked_Extensions_field_opt1`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2UnittestUnlinked_fieldOpt1() { + clearExtensionValue(ext: Proto2UnittestUnlinked_Extensions_field_opt1) + } +} + +extension SwiftProtobuf.Google_Protobuf_FileOptions { + + var Proto2UnittestUnlinked_fileOpt1: UInt64 { + get {return getExtensionValue(ext: Proto2UnittestUnlinked_Extensions_file_opt1) ?? 0} + set {setExtensionValue(ext: Proto2UnittestUnlinked_Extensions_file_opt1, value: newValue)} + } + /// Returns true if extension `Proto2UnittestUnlinked_Extensions_file_opt1` + /// has been explicitly set. + var hasProto2UnittestUnlinked_fileOpt1: Bool { + return hasExtensionValue(ext: Proto2UnittestUnlinked_Extensions_file_opt1) + } + /// Clears the value of extension `Proto2UnittestUnlinked_Extensions_file_opt1`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2UnittestUnlinked_fileOpt1() { + clearExtensionValue(ext: Proto2UnittestUnlinked_Extensions_file_opt1) + } +} + +extension SwiftProtobuf.Google_Protobuf_MessageOptions { + + var Proto2UnittestUnlinked_messageOpt1: Int32 { + get {return getExtensionValue(ext: Proto2UnittestUnlinked_Extensions_message_opt1) ?? 0} + set {setExtensionValue(ext: Proto2UnittestUnlinked_Extensions_message_opt1, value: newValue)} + } + /// Returns true if extension `Proto2UnittestUnlinked_Extensions_message_opt1` + /// has been explicitly set. + var hasProto2UnittestUnlinked_messageOpt1: Bool { + return hasExtensionValue(ext: Proto2UnittestUnlinked_Extensions_message_opt1) + } + /// Clears the value of extension `Proto2UnittestUnlinked_Extensions_message_opt1`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2UnittestUnlinked_messageOpt1() { + clearExtensionValue(ext: Proto2UnittestUnlinked_Extensions_message_opt1) + } + +} + +// MARK: - File's ExtensionMap: Proto2UnittestUnlinked_UnittestCustomOptionsUnlinked_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 Proto2UnittestUnlinked_UnittestCustomOptionsUnlinked_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Proto2UnittestUnlinked_Extensions_file_opt1, + Proto2UnittestUnlinked_Extensions_message_opt1, + Proto2UnittestUnlinked_Extensions_field_opt1 +] + +// 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 Proto2UnittestUnlinked_Extensions_file_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( + _protobuf_fieldNumber: 7736975, + fieldName: "proto2_unittest_unlinked.file_opt1" +) + +let Proto2UnittestUnlinked_Extensions_message_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 7739037, + fieldName: "proto2_unittest_unlinked.message_opt1" +) + +let Proto2UnittestUnlinked_Extensions_field_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FieldOptions>( + _protobuf_fieldNumber: 7740937, + fieldName: "proto2_unittest_unlinked.field_opt1" +) diff --git a/Reference/upstream/google/protobuf/unittest_delimited.pb.swift b/Reference/upstream/google/protobuf/unittest_delimited.pb.swift new file mode 100644 index 000000000..17927cf62 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_delimited.pb.swift @@ -0,0 +1,706 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_delimited.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +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 EditionsUnittest_LengthPrefixed: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil +} + +struct EditionsUnittest_NotGroupLikeScope: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil +} + +struct EditionsUnittest_GroupLikeFileScope: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil +} + +struct EditionsUnittest_TestDelimited: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Non-delimited field that otherwise looks group-like. + var lengthprefixed: EditionsUnittest_TestDelimited.LengthPrefixed { + get {_storage._lengthprefixed ?? EditionsUnittest_TestDelimited.LengthPrefixed()} + set {_uniqueStorage()._lengthprefixed = newValue} + } + /// Returns true if `lengthprefixed` has been explicitly set. + var hasLengthprefixed: Bool {_storage._lengthprefixed != nil} + /// Clears the value of `lengthprefixed`. Subsequent reads from it will return its default value. + mutating func clearLengthprefixed() {_uniqueStorage()._lengthprefixed = nil} + + /// Nested field for nested tests. + var nested: EditionsUnittest_TestDelimited { + get {_storage._nested ?? EditionsUnittest_TestDelimited()} + set {_uniqueStorage()._nested = newValue} + } + /// Returns true if `nested` has been explicitly set. + var hasNested: Bool {_storage._nested != nil} + /// Clears the value of `nested`. Subsequent reads from it will return its default value. + mutating func clearNested() {_uniqueStorage()._nested = nil} + + /// Truly group-like field. + var groupLike: EditionsUnittest_TestDelimited.GroupLike { + get {_storage._groupLike ?? EditionsUnittest_TestDelimited.GroupLike()} + set {_uniqueStorage()._groupLike = newValue} + } + /// Returns true if `groupLike` has been explicitly set. + var hasGroupLike: Bool {_storage._groupLike != nil} + /// Clears the value of `groupLike`. Subsequent reads from it will return its default value. + mutating func clearGroupLike() {_uniqueStorage()._groupLike = nil} + + /// Delimited field that isn't group-like solely because of its name. + var notgrouplike: EditionsUnittest_TestDelimited.GroupLike { + get {_storage._notgrouplike ?? EditionsUnittest_TestDelimited.GroupLike()} + set {_uniqueStorage()._notgrouplike = newValue} + } + /// Returns true if `notgrouplike` has been explicitly set. + var hasNotgrouplike: Bool {_storage._notgrouplike != nil} + /// Clears the value of `notgrouplike`. Subsequent reads from it will return its default value. + mutating func clearNotgrouplike() {_uniqueStorage()._notgrouplike = nil} + + /// Delimited field that isn't group-like because of the scope of its type. + var notgrouplikescope: EditionsUnittest_NotGroupLikeScope { + get {_storage._notgrouplikescope ?? EditionsUnittest_NotGroupLikeScope()} + set {_uniqueStorage()._notgrouplikescope = newValue} + } + /// Returns true if `notgrouplikescope` has been explicitly set. + var hasNotgrouplikescope: Bool {_storage._notgrouplikescope != nil} + /// Clears the value of `notgrouplikescope`. Subsequent reads from it will return its default value. + mutating func clearNotgrouplikescope() {_uniqueStorage()._notgrouplikescope = nil} + + /// Delimited field that's grouplike except that it's an imported type. + var messageimport: EditionsUnittest_MessageImport { + get {_storage._messageimport ?? EditionsUnittest_MessageImport()} + set {_uniqueStorage()._messageimport = newValue} + } + /// Returns true if `messageimport` has been explicitly set. + var hasMessageimport: Bool {_storage._messageimport != nil} + /// Clears the value of `messageimport`. Subsequent reads from it will return its default value. + mutating func clearMessageimport() {_uniqueStorage()._messageimport = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct LengthPrefixed: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil + } + + struct GroupLike: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Extension support defined in unittest_delimited.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 EditionsUnittest_TestDelimited { + + /// Non-delimited field that otherwise looks group-like. + var EditionsUnittest_lengthprefixed: EditionsUnittest_LengthPrefixed { + get {return getExtensionValue(ext: EditionsUnittest_Extensions_lengthprefixed) ?? EditionsUnittest_LengthPrefixed()} + set {setExtensionValue(ext: EditionsUnittest_Extensions_lengthprefixed, value: newValue)} + } + /// Returns true if extension `EditionsUnittest_Extensions_lengthprefixed` + /// has been explicitly set. + var hasEditionsUnittest_lengthprefixed: Bool { + return hasExtensionValue(ext: EditionsUnittest_Extensions_lengthprefixed) + } + /// Clears the value of extension `EditionsUnittest_Extensions_lengthprefixed`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionsUnittest_lengthprefixed() { + clearExtensionValue(ext: EditionsUnittest_Extensions_lengthprefixed) + } + + /// Truly group-like extension. + var EditionsUnittest_groupLikeFileScope: EditionsUnittest_GroupLikeFileScope { + get {return getExtensionValue(ext: EditionsUnittest_Extensions_GroupLikeFileScope) ?? EditionsUnittest_GroupLikeFileScope()} + set {setExtensionValue(ext: EditionsUnittest_Extensions_GroupLikeFileScope, value: newValue)} + } + /// Returns true if extension `EditionsUnittest_Extensions_GroupLikeFileScope` + /// has been explicitly set. + var hasEditionsUnittest_groupLikeFileScope: Bool { + return hasExtensionValue(ext: EditionsUnittest_Extensions_GroupLikeFileScope) + } + /// Clears the value of extension `EditionsUnittest_Extensions_GroupLikeFileScope`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionsUnittest_groupLikeFileScope() { + clearExtensionValue(ext: EditionsUnittest_Extensions_GroupLikeFileScope) + } + + /// Delimited extension that isn't group-like because of its name. + var EditionsUnittest_notGroupLikeScope: EditionsUnittest_NotGroupLikeScope { + get {return getExtensionValue(ext: EditionsUnittest_Extensions_not_group_like_scope) ?? EditionsUnittest_NotGroupLikeScope()} + set {setExtensionValue(ext: EditionsUnittest_Extensions_not_group_like_scope, value: newValue)} + } + /// Returns true if extension `EditionsUnittest_Extensions_not_group_like_scope` + /// has been explicitly set. + var hasEditionsUnittest_notGroupLikeScope: Bool { + return hasExtensionValue(ext: EditionsUnittest_Extensions_not_group_like_scope) + } + /// Clears the value of extension `EditionsUnittest_Extensions_not_group_like_scope`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionsUnittest_notGroupLikeScope() { + clearExtensionValue(ext: EditionsUnittest_Extensions_not_group_like_scope) + } + + /// Delimited extension that isn't group-like because of the scope of its type. + var EditionsUnittest_grouplike: EditionsUnittest_TestDelimited.GroupLike { + get {return getExtensionValue(ext: EditionsUnittest_Extensions_grouplike) ?? EditionsUnittest_TestDelimited.GroupLike()} + set {setExtensionValue(ext: EditionsUnittest_Extensions_grouplike, value: newValue)} + } + /// Returns true if extension `EditionsUnittest_Extensions_grouplike` + /// has been explicitly set. + var hasEditionsUnittest_grouplike: Bool { + return hasExtensionValue(ext: EditionsUnittest_Extensions_grouplike) + } + /// Clears the value of extension `EditionsUnittest_Extensions_grouplike`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionsUnittest_grouplike() { + clearExtensionValue(ext: EditionsUnittest_Extensions_grouplike) + } + + /// Delimited extension that's grouplike except that it's an imported type. + var EditionsUnittest_messageimport: EditionsUnittest_MessageImport { + get {return getExtensionValue(ext: EditionsUnittest_Extensions_messageimport) ?? EditionsUnittest_MessageImport()} + set {setExtensionValue(ext: EditionsUnittest_Extensions_messageimport, value: newValue)} + } + /// Returns true if extension `EditionsUnittest_Extensions_messageimport` + /// has been explicitly set. + var hasEditionsUnittest_messageimport: Bool { + return hasExtensionValue(ext: EditionsUnittest_Extensions_messageimport) + } + /// Clears the value of extension `EditionsUnittest_Extensions_messageimport`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionsUnittest_messageimport() { + clearExtensionValue(ext: EditionsUnittest_Extensions_messageimport) + } + +} + +// MARK: - File's ExtensionMap: EditionsUnittest_UnittestDelimited_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 EditionsUnittest_UnittestDelimited_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + EditionsUnittest_Extensions_lengthprefixed, + EditionsUnittest_Extensions_GroupLikeFileScope, + EditionsUnittest_Extensions_not_group_like_scope, + EditionsUnittest_Extensions_grouplike, + EditionsUnittest_Extensions_messageimport +] + +// 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. + +/// Non-delimited field that otherwise looks group-like. +let EditionsUnittest_Extensions_lengthprefixed = SwiftProtobuf.MessageExtension, EditionsUnittest_TestDelimited>( + _protobuf_fieldNumber: 1004, + fieldName: "editions_unittest.lengthprefixed" +) + +/// Truly group-like extension. +let EditionsUnittest_Extensions_GroupLikeFileScope = SwiftProtobuf.MessageExtension, EditionsUnittest_TestDelimited>( + _protobuf_fieldNumber: 1000, + fieldName: "editions_unittest.grouplikefilescope" +) + +/// Delimited extension that isn't group-like because of its name. +let EditionsUnittest_Extensions_not_group_like_scope = SwiftProtobuf.MessageExtension, EditionsUnittest_TestDelimited>( + _protobuf_fieldNumber: 1001, + fieldName: "editions_unittest.not_group_like_scope" +) + +/// Delimited extension that isn't group-like because of the scope of its type. +let EditionsUnittest_Extensions_grouplike = SwiftProtobuf.MessageExtension, EditionsUnittest_TestDelimited>( + _protobuf_fieldNumber: 1002, + fieldName: "editions_unittest.grouplike" +) + +/// Delimited extension that's grouplike except that it's an imported type. +let EditionsUnittest_Extensions_messageimport = SwiftProtobuf.MessageExtension, EditionsUnittest_TestDelimited>( + _protobuf_fieldNumber: 1003, + fieldName: "editions_unittest.messageimport" +) + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "editions_unittest" + +extension EditionsUnittest_LengthPrefixed: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".LengthPrefixed" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_LengthPrefixed, rhs: EditionsUnittest_LengthPrefixed) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionsUnittest_NotGroupLikeScope: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NotGroupLikeScope" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_NotGroupLikeScope, rhs: EditionsUnittest_NotGroupLikeScope) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionsUnittest_GroupLikeFileScope: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GroupLikeFileScope" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_GroupLikeFileScope, rhs: EditionsUnittest_GroupLikeFileScope) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionsUnittest_TestDelimited: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestDelimited" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}lengthprefixed\0\u{1}nested\0\u{7}GroupLike\0\u{1}notgrouplike\0\u{1}notgrouplikescope\0\u{1}messageimport\0") + + fileprivate class _StorageClass { + var _lengthprefixed: EditionsUnittest_TestDelimited.LengthPrefixed? = nil + var _nested: EditionsUnittest_TestDelimited? = nil + var _groupLike: EditionsUnittest_TestDelimited.GroupLike? = nil + var _notgrouplike: EditionsUnittest_TestDelimited.GroupLike? = nil + var _notgrouplikescope: EditionsUnittest_NotGroupLikeScope? = nil + var _messageimport: EditionsUnittest_MessageImport? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _lengthprefixed = source._lengthprefixed + _nested = source._nested + _groupLike = source._groupLike + _notgrouplike = source._notgrouplike + _notgrouplikescope = source._notgrouplikescope + _messageimport = source._messageimport + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._nested, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._lengthprefixed) }() + case 2: try { try decoder.decodeSingularGroupField(value: &_storage._nested) }() + case 3: try { try decoder.decodeSingularGroupField(value: &_storage._groupLike) }() + case 4: try { try decoder.decodeSingularGroupField(value: &_storage._notgrouplike) }() + case 5: try { try decoder.decodeSingularGroupField(value: &_storage._notgrouplikescope) }() + case 6: try { try decoder.decodeSingularGroupField(value: &_storage._messageimport) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionsUnittest_TestDelimited.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._lengthprefixed { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._nested { + try visitor.visitSingularGroupField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._groupLike { + try visitor.visitSingularGroupField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._notgrouplike { + try visitor.visitSingularGroupField(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._notgrouplikescope { + try visitor.visitSingularGroupField(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._messageimport { + try visitor.visitSingularGroupField(value: v, fieldNumber: 6) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_TestDelimited, rhs: EditionsUnittest_TestDelimited) -> 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._lengthprefixed != rhs_storage._lengthprefixed {return false} + if _storage._nested != rhs_storage._nested {return false} + if _storage._groupLike != rhs_storage._groupLike {return false} + if _storage._notgrouplike != rhs_storage._notgrouplike {return false} + if _storage._notgrouplikescope != rhs_storage._notgrouplikescope {return false} + if _storage._messageimport != rhs_storage._messageimport {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionsUnittest_TestDelimited.LengthPrefixed: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionsUnittest_TestDelimited.protoMessageName + ".LengthPrefixed" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_TestDelimited.LengthPrefixed, rhs: EditionsUnittest_TestDelimited.LengthPrefixed) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionsUnittest_TestDelimited.GroupLike: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionsUnittest_TestDelimited.protoMessageName + ".GroupLike" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_TestDelimited.GroupLike, rhs: EditionsUnittest_TestDelimited.GroupLike) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/unittest_delimited_import.pb.swift b/Reference/upstream/google/protobuf/unittest_delimited_import.pb.swift new file mode 100644 index 000000000..7536293b6 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_delimited_import.pb.swift @@ -0,0 +1,95 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_delimited_import.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +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 EditionsUnittest_MessageImport: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "editions_unittest" + +extension EditionsUnittest_MessageImport: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MessageImport" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_MessageImport, rhs: EditionsUnittest_MessageImport) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/google/protobuf/unittest_drop_unknown_fields.pb.swift b/Reference/upstream/google/protobuf/unittest_drop_unknown_fields.pb.swift similarity index 64% rename from Reference/google/protobuf/unittest_drop_unknown_fields.pb.swift rename to Reference/upstream/google/protobuf/unittest_drop_unknown_fields.pb.swift index f84a8cef6..c67d2e879 100644 --- a/Reference/google/protobuf/unittest_drop_unknown_fields.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_drop_unknown_fields.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/unittest_drop_unknown_fields.proto @@ -9,35 +10,11 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -import Foundation +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -50,7 +27,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct UnittestDropUnknownFields_Foo { +struct UnittestDropUnknownFields_Foo: Sendable { // 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. @@ -61,7 +38,7 @@ struct UnittestDropUnknownFields_Foo { var unknownFields = SwiftProtobuf.UnknownStorage() - enum NestedEnum: SwiftProtobuf.Enum { + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foo // = 0 case bar // = 1 @@ -90,25 +67,19 @@ struct UnittestDropUnknownFields_Foo { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [UnittestDropUnknownFields_Foo.NestedEnum] = [ + .foo, + .bar, + .baz, + ] + } init() {} } -#if swift(>=4.2) - -extension UnittestDropUnknownFields_Foo.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [UnittestDropUnknownFields_Foo.NestedEnum] = [ - .foo, - .bar, - .baz, - ] -} - -#endif // swift(>=4.2) - -struct UnittestDropUnknownFields_FooWithExtraFields { +struct UnittestDropUnknownFields_FooWithExtraFields: Sendable { // 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. @@ -121,12 +92,12 @@ struct UnittestDropUnknownFields_FooWithExtraFields { var unknownFields = SwiftProtobuf.UnknownStorage() - enum NestedEnum: SwiftProtobuf.Enum { + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foo // = 0 case bar // = 1 case baz // = 2 - case qux // = 3 + case moo // = 3 case UNRECOGNIZED(Int) init() { @@ -138,7 +109,7 @@ struct UnittestDropUnknownFields_FooWithExtraFields { case 0: self = .foo case 1: self = .bar case 2: self = .baz - case 3: self = .qux + case 3: self = .moo default: self = .UNRECOGNIZED(rawValue) } } @@ -148,47 +119,31 @@ struct UnittestDropUnknownFields_FooWithExtraFields { case .foo: return 0 case .bar: return 1 case .baz: return 2 - case .qux: return 3 + case .moo: return 3 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [UnittestDropUnknownFields_FooWithExtraFields.NestedEnum] = [ + .foo, + .bar, + .baz, + .moo, + ] + } init() {} } -#if swift(>=4.2) - -extension UnittestDropUnknownFields_FooWithExtraFields.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [UnittestDropUnknownFields_FooWithExtraFields.NestedEnum] = [ - .foo, - .bar, - .baz, - .qux, - ] -} - -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension UnittestDropUnknownFields_Foo: @unchecked Sendable {} -extension UnittestDropUnknownFields_Foo.NestedEnum: @unchecked Sendable {} -extension UnittestDropUnknownFields_FooWithExtraFields: @unchecked Sendable {} -extension UnittestDropUnknownFields_FooWithExtraFields.NestedEnum: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "unittest_drop_unknown_fields" extension UnittestDropUnknownFields_Foo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Foo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "int32_value"), - 2: .standard(proto: "enum_value"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}int32_value\0\u{3}enum_value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -222,20 +177,12 @@ extension UnittestDropUnknownFields_Foo: SwiftProtobuf.Message, SwiftProtobuf._M } extension UnittestDropUnknownFields_Foo.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOO\0\u{1}BAR\0\u{1}BAZ\0") } extension UnittestDropUnknownFields_FooWithExtraFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".FooWithExtraFields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "int32_value"), - 2: .standard(proto: "enum_value"), - 3: .standard(proto: "extra_int32_value"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}int32_value\0\u{3}enum_value\0\u{3}extra_int32_value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -274,10 +221,5 @@ extension UnittestDropUnknownFields_FooWithExtraFields: SwiftProtobuf.Message, S } extension UnittestDropUnknownFields_FooWithExtraFields.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - 3: .same(proto: "QUX"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOO\0\u{1}BAR\0\u{1}BAZ\0\u{1}MOO\0") } diff --git a/Reference/google/protobuf/unittest_embed_optimize_for.pb.swift b/Reference/upstream/google/protobuf/unittest_embed_optimize_for.pb.swift similarity index 58% rename from Reference/google/protobuf/unittest_embed_optimize_for.pb.swift rename to Reference/upstream/google/protobuf/unittest_embed_optimize_for.pb.swift index dceee5a77..49ce588ac 100644 --- a/Reference/google/protobuf/unittest_embed_optimize_for.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_embed_optimize_for.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/unittest_embed_optimize_for.proto @@ -9,33 +10,10 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd // Author: kenton@google.com (Kenton Varda) // Based on original Protocol Buffers design by @@ -43,7 +21,6 @@ // // A proto file which imports a proto file that uses optimize_for = CODE_SIZE. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -56,45 +33,38 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_TestEmbedOptimizedForSize { +struct Proto2Unittest_TestEmbedOptimizedForSize: Sendable { // 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. /// Test that embedding a message which has optimize_for = CODE_SIZE into /// one optimized for speed works. - var optionalMessage: ProtobufUnittest_TestOptimizedForSize { - get {return _optionalMessage ?? ProtobufUnittest_TestOptimizedForSize()} + var optionalMessage: Proto2Unittest_TestOptimizedForSize { + get {_optionalMessage ?? Proto2Unittest_TestOptimizedForSize()} set {_optionalMessage = newValue} } /// Returns true if `optionalMessage` has been explicitly set. - var hasOptionalMessage: Bool {return self._optionalMessage != nil} + var hasOptionalMessage: Bool {self._optionalMessage != nil} /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalMessage() {self._optionalMessage = nil} - var repeatedMessage: [ProtobufUnittest_TestOptimizedForSize] = [] + var repeatedMessage: [Proto2Unittest_TestOptimizedForSize] = [] var unknownFields = SwiftProtobuf.UnknownStorage() init() {} - fileprivate var _optionalMessage: ProtobufUnittest_TestOptimizedForSize? = nil + fileprivate var _optionalMessage: Proto2Unittest_TestOptimizedForSize? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_TestEmbedOptimizedForSize: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "proto2_unittest" -extension ProtobufUnittest_TestEmbedOptimizedForSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestEmbedOptimizedForSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestEmbedOptimizedForSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_message"), - 2: .standard(proto: "repeated_message"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_message\0\u{3}repeated_message\0") public var isInitialized: Bool { if let v = self._optionalMessage, !v.isInitialized {return false} @@ -129,7 +99,7 @@ extension ProtobufUnittest_TestEmbedOptimizedForSize: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestEmbedOptimizedForSize, rhs: ProtobufUnittest_TestEmbedOptimizedForSize) -> Bool { + static func ==(lhs: Proto2Unittest_TestEmbedOptimizedForSize, rhs: Proto2Unittest_TestEmbedOptimizedForSize) -> Bool { if lhs._optionalMessage != rhs._optionalMessage {return false} if lhs.repeatedMessage != rhs.repeatedMessage {return false} if lhs.unknownFields != rhs.unknownFields {return false} diff --git a/Reference/upstream/google/protobuf/unittest_empty.pb.swift b/Reference/upstream/google/protobuf/unittest_empty.pb.swift new file mode 100644 index 000000000..826fd255b --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_empty.pb.swift @@ -0,0 +1,27 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_empty.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// NOLINT(no_package_specified): Test proto with no package + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// This file intentionally left blank. (At one point this wouldn't compile +// correctly.) + +// This file contained no messages, enums, or extensions. diff --git a/Reference/google/protobuf/unittest_enormous_descriptor.pb.swift b/Reference/upstream/google/protobuf/unittest_enormous_descriptor.pb.swift similarity index 77% rename from Reference/google/protobuf/unittest_enormous_descriptor.pb.swift rename to Reference/upstream/google/protobuf/unittest_enormous_descriptor.pb.swift index ec8ce6f2b..ec402878e 100644 --- a/Reference/google/protobuf/unittest_enormous_descriptor.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_enormous_descriptor.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/unittest_enormous_descriptor.proto @@ -9,34 +10,12 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// Copyright 2009 Google Inc. All rights reserved. // Author: kenton@google.com (Kenton Varda) // Based on original Protocol Buffers design by // Sanjay Ghemawat, Jeff Dean, and others. @@ -45,7 +24,6 @@ // descriptors over 64k don't break language-specific limits in generated code, // such as the string literal length limit in Java. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -58,9008 +36,9009 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_TestEnormousDescriptor { +/// clang-format off +struct Proto2Unittest_TestEnormousDescriptor: @unchecked Sendable { // 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 longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong2 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong3 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong4 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong5: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong5 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong5 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong5 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong5` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong5: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong5 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong5: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong5 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong5`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong5() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong5 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong6: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong6 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong6 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong6 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong6` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong6: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong6 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong6: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong6 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong6`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong6() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong6 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong7: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong7 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong7 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong7 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong7` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong7: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong7 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong7: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong7 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong7`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong7() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong7 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong8: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong8 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong8 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong8 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong8` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong8: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong8 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong8: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong8 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong8`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong8() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong8 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong9: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong9 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong9 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong9 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong9` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong9: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong9 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong9: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong9 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong9`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong9() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong9 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong10: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong10 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong10 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong10 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong10` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong10: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong10 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong10: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong10 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong10`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong10() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong10 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong11: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong11 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong11 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong11 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong11` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong11: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong11 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong11: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong11 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong11`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong11() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong11 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong12: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong12 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong12 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong12 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong12` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong12: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong12 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong12: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong12 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong12`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong12() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong12 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong13: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong13 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong13 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong13 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong13` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong13: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong13 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong13: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong13 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong13`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong13() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong13 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong14: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong14 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong14 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong14 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong14` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong14: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong14 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong14: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong14 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong14`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong14() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong14 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong15: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong15 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong15 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong15 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong15` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong15: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong15 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong15: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong15 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong15`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong15() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong15 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong16: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong16 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong16 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong16 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong16` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong16: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong16 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong16: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong16 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong16`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong16() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong16 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong17: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong17 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong17 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong17 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong17` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong17: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong17 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong17: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong17 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong17`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong17() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong17 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong18: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong18 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong18 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong18 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong18` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong18: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong18 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong18: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong18 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong18`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong18() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong18 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong19: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong19 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong19 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong19 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong19` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong19: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong19 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong19: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong19 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong19`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong19() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong19 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong20: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong20 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong20 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong20 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong20` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong20: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong20 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong20: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong20 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong20`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong20() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong20 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong21: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong21 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong21 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong21 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong21` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong21: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong21 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong21: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong21 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong21`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong21() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong21 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong22: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong22 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong22 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong22 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong22` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong22: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong22 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong22: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong22 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong22`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong22() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong22 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong23: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong23 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong23 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong23 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong23` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong23: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong23 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong23: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong23 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong23`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong23() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong23 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong24: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong24 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong24 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong24 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong24` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong24: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong24 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong24: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong24 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong24`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong24() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong24 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong25: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong25 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong25 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong25 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong25` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong25: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong25 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong25: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong25 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong25`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong25() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong25 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong26: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong26 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong26 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong26 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong26` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong26: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong26 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong26: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong26 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong26`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong26() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong26 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong27: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong27 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong27 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong27 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong27` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong27: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong27 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong27: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong27 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong27`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong27() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong27 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong28: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong28 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong28 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong28 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong28` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong28: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong28 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong28: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong28 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong28`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong28() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong28 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong29: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong29 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong29 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong29 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong29` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong29: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong29 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong29: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong29 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong29`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong29() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong29 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong30: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong30 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong30 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong30 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong30` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong30: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong30 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong30: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong30 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong30`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong30() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong30 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong31: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong31 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong31 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong31 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong31` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong31: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong31 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong31: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong31 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong31`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong31() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong31 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong32: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong32 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong32 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong32 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong32` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong32: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong32 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong32: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong32 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong32`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong32() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong32 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong33: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong33 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong33 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong33 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong33` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong33: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong33 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong33: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong33 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong33`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong33() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong33 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong34: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong34 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong34 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong34 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong34` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong34: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong34 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong34: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong34 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong34`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong34() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong34 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong35: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong35 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong35 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong35 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong35` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong35: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong35 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong35: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong35 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong35`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong35() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong35 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong36: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong36 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong36 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong36 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong36` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong36: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong36 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong36: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong36 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong36`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong36() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong36 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong37: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong37 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong37 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong37 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong37` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong37: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong37 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong37: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong37 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong37`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong37() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong37 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong38: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong38 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong38 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong38 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong38` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong38: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong38 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong38: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong38 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong38`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong38() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong38 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong39: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong39 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong39 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong39 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong39` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong39: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong39 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong39: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong39 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong39`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong39() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong39 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong40: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong40 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong40 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong40 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong40` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong40: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong40 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong40: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong40 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong40`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong40() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong40 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong41: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong41 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong41 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong41 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong41` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong41: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong41 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong41: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong41 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong41`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong41() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong41 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong42: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong42 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong42 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong42 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong42` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong42: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong42 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong42: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong42 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong42`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong42() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong42 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong43: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong43 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong43 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong43 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong43` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong43: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong43 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong43: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong43 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong43`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong43() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong43 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong44: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong44 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong44 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong44 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong44` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong44: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong44 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong44: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong44 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong44`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong44() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong44 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong45: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong45 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong45 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong45 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong45` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong45: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong45 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong45: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong45 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong45`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong45() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong45 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong46: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong46 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong46 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong46 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong46` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong46: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong46 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong46: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong46 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong46`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong46() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong46 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong47: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong47 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong47 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong47 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong47` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong47: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong47 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong47: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong47 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong47`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong47() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong47 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong48: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong48 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong48 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong48 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong48` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong48: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong48 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong48: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong48 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong48`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong48() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong48 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong49: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong49 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong49 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong49 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong49` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong49: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong49 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong49: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong49 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong49`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong49() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong49 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong50: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong50 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong50 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong50 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong50` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong50: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong50 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong50: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong50 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong50`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong50() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong50 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong51: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong51 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong51 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong51 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong51` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong51: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong51 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong51: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong51 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong51`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong51() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong51 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong52: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong52 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong52 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong52 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong52` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong52: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong52 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong52: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong52 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong52`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong52() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong52 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong53: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong53 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong53 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong53 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong53` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong53: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong53 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong53: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong53 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong53`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong53() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong53 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong54: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong54 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong54 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong54 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong54` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong54: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong54 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong54: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong54 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong54`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong54() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong54 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong55: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong55 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong55 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong55 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong55` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong55: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong55 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong55: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong55 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong55`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong55() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong55 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong56: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong56 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong56 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong56 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong56` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong56: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong56 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong56: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong56 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong56`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong56() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong56 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong57: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong57 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong57 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong57 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong57` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong57: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong57 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong57: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong57 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong57`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong57() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong57 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong58: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong58 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong58 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong58 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong58` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong58: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong58 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong58: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong58 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong58`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong58() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong58 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong59: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong59 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong59 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong59 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong59` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong59: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong59 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong59: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong59 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong59`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong59() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong59 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong60: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong60 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong60 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong60 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong60` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong60: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong60 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong60: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong60 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong60`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong60() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong60 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong61: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong61 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong61 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong61 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong61` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong61: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong61 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong61: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong61 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong61`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong61() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong61 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong62: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong62 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong62 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong62 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong62` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong62: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong62 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong62: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong62 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong62`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong62() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong62 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong63: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong63 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong63 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong63 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong63` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong63: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong63 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong63: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong63 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong63`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong63() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong63 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong64: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong64 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong64 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong64 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong64` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong64: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong64 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong64: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong64 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong64`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong64() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong64 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong65: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong65 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong65 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong65 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong65` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong65: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong65 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong65: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong65 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong65`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong65() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong65 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong66: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong66 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong66 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong66 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong66` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong66: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong66 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong66: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong66 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong66`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong66() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong66 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong67: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong67 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong67 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong67 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong67` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong67: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong67 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong67: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong67 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong67`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong67() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong67 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong68: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong68 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong68 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong68 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong68` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong68: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong68 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong68: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong68 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong68`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong68() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong68 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong69: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong69 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong69 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong69 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong69` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong69: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong69 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong69: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong69 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong69`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong69() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong69 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong70: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong70 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong70 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong70 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong70` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong70: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong70 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong70: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong70 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong70`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong70() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong70 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong71: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong71 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong71 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong71 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong71` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong71: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong71 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong71: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong71 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong71`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong71() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong71 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong72: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong72 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong72 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong72 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong72` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong72: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong72 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong72: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong72 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong72`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong72() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong72 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong73: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong73 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong73 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong73 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong73` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong73: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong73 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong73: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong73 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong73`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong73() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong73 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong74: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong74 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong74 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong74 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong74` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong74: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong74 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong74: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong74 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong74`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong74() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong74 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong75: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong75 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong75 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong75 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong75` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong75: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong75 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong75: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong75 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong75`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong75() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong75 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong76: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong76 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong76 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong76 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong76` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong76: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong76 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong76: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong76 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong76`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong76() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong76 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong77: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong77 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong77 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong77 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong77` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong77: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong77 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong77: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong77 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong77`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong77() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong77 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong78: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong78 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong78 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong78 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong78` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong78: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong78 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong78: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong78 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong78`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong78() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong78 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong79: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong79 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong79 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong79 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong79` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong79: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong79 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong79: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong79 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong79`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong79() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong79 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong80: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong80 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong80 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong80 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong80` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong80: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong80 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong80: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong80 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong80`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong80() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong80 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong81: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong81 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong81 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong81 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong81` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong81: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong81 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong81: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong81 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong81`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong81() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong81 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong82: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong82 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong82 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong82 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong82` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong82: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong82 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong82: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong82 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong82`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong82() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong82 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong83: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong83 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong83 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong83 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong83` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong83: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong83 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong83: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong83 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong83`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong83() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong83 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong84: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong84 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong84 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong84 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong84` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong84: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong84 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong84: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong84 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong84`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong84() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong84 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong85: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong85 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong85 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong85 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong85` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong85: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong85 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong85: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong85 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong85`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong85() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong85 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong86: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong86 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong86 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong86 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong86` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong86: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong86 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong86: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong86 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong86`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong86() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong86 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong87: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong87 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong87 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong87 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong87` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong87: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong87 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong87: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong87 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong87`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong87() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong87 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong88: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong88 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong88 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong88 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong88` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong88: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong88 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong88: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong88 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong88`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong88() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong88 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong89: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong89 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong89 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong89 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong89` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong89: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong89 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong89: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong89 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong89`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong89() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong89 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong90: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong90 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong90 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong90 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong90` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong90: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong90 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong90: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong90 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong90`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong90() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong90 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong91: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong91 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong91 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong91 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong91` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong91: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong91 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong91: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong91 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong91`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong91() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong91 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong92: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong92 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong92 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong92 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong92` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong92: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong92 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong92: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong92 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong92`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong92() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong92 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong93: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong93 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong93 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong93 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong93` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong93: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong93 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong93: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong93 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong93`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong93() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong93 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong94: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong94 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong94 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong94 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong94` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong94: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong94 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong94: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong94 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong94`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong94() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong94 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong95: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong95 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong95 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong95 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong95` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong95: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong95 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong95: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong95 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong95`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong95() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong95 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong96: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong96 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong96 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong96 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong96` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong96: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong96 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong96: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong96 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong96`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong96() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong96 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong97: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong97 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong97 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong97 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong97` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong97: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong97 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong97: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong97 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong97`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong97() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong97 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong98: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong98 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong98 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong98 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong98` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong98: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong98 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong98: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong98 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong98`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong98() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong98 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong99: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong99 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong99 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong99 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong99` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong99: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong99 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong99: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong99 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong99`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong99() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong99 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong100: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong100 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong100 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong100 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong100` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong100: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong100 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong100: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong100 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong100`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong100() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong100 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong101: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong101 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong101 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong101 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong101` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong101: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong101 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong101: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong101 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong101`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong101() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong101 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong102: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong102 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong102 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong102 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong102` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong102: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong102 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong102: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong102 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong102`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong102() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong102 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong103: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong103 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong103 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong103 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong103` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong103: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong103 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong103: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong103 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong103`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong103() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong103 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong104: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong104 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong104 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong104 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong104` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong104: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong104 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong104: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong104 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong104`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong104() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong104 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong105: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong105 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong105 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong105 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong105` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong105: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong105 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong105: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong105 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong105`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong105() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong105 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong106: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong106 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong106 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong106 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong106` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong106: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong106 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong106: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong106 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong106`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong106() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong106 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong107: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong107 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong107 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong107 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong107` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong107: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong107 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong107: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong107 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong107`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong107() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong107 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong108: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong108 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong108 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong108 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong108` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong108: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong108 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong108: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong108 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong108`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong108() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong108 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong109: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong109 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong109 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong109 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong109` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong109: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong109 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong109: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong109 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong109`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong109() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong109 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong110: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong110 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong110 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong110 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong110` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong110: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong110 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong110: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong110 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong110`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong110() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong110 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong111: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong111 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong111 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong111 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong111` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong111: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong111 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong111: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong111 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong111`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong111() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong111 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong112: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong112 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong112 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong112 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong112` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong112: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong112 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong112: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong112 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong112`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong112() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong112 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong113: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong113 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong113 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong113 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong113` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong113: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong113 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong113: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong113 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong113`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong113() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong113 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong114: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong114 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong114 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong114 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong114` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong114: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong114 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong114: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong114 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong114`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong114() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong114 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong115: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong115 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong115 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong115 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong115` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong115: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong115 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong115: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong115 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong115`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong115() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong115 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong116: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong116 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong116 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong116 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong116` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong116: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong116 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong116: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong116 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong116`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong116() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong116 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong117: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong117 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong117 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong117 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong117` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong117: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong117 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong117: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong117 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong117`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong117() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong117 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong118: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong118 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong118 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong118 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong118` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong118: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong118 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong118: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong118 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong118`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong118() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong118 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong119: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong119 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong119 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong119 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong119` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong119: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong119 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong119: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong119 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong119`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong119() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong119 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong120: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong120 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong120 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong120 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong120` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong120: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong120 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong120: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong120 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong120`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong120() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong120 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong121: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong121 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong121 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong121 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong121` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong121: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong121 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong121: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong121 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong121`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong121() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong121 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong122: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong122 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong122 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong122 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong122` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong122: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong122 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong122: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong122 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong122`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong122() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong122 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong123: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong123 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong123 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong123 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong123` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong123: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong123 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong123: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong123 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong123`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong123() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong123 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong124: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong124 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong124 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong124 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong124` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong124: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong124 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong124: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong124 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong124`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong124() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong124 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong125: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong125 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong125 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong125 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong125` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong125: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong125 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong125: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong125 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong125`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong125() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong125 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong126: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong126 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong126 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong126 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong126` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong126: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong126 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong126: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong126 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong126`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong126() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong126 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong127: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong127 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong127 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong127 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong127` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong127: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong127 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong127: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong127 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong127`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong127() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong127 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong128: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong128 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong128 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong128 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong128` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong128: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong128 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong128: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong128 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong128`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong128() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong128 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong129: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong129 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong129 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong129 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong129` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong129: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong129 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong129: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong129 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong129`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong129() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong129 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong130: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong130 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong130 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong130 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong130` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong130: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong130 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong130: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong130 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong130`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong130() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong130 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong131: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong131 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong131 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong131 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong131` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong131: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong131 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong131: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong131 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong131`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong131() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong131 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong132: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong132 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong132 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong132 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong132` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong132: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong132 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong132: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong132 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong132`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong132() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong132 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong133: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong133 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong133 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong133 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong133` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong133: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong133 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong133: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong133 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong133`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong133() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong133 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong134: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong134 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong134 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong134 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong134` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong134: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong134 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong134: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong134 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong134`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong134() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong134 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong135: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong135 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong135 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong135 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong135` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong135: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong135 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong135: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong135 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong135`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong135() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong135 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong136: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong136 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong136 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong136 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong136` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong136: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong136 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong136: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong136 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong136`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong136() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong136 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong137: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong137 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong137 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong137 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong137` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong137: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong137 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong137: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong137 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong137`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong137() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong137 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong138: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong138 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong138 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong138 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong138` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong138: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong138 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong138: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong138 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong138`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong138() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong138 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong139: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong139 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong139 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong139 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong139` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong139: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong139 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong139: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong139 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong139`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong139() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong139 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong140: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong140 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong140 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong140 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong140` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong140: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong140 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong140: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong140 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong140`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong140() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong140 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong141: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong141 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong141 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong141 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong141` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong141: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong141 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong141: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong141 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong141`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong141() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong141 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong142: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong142 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong142 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong142 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong142` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong142: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong142 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong142: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong142 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong142`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong142() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong142 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong143: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong143 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong143 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong143 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong143` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong143: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong143 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong143: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong143 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong143`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong143() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong143 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong144: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong144 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong144 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong144 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong144` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong144: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong144 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong144: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong144 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong144`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong144() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong144 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong145: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong145 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong145 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong145 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong145` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong145: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong145 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong145: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong145 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong145`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong145() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong145 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong146: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong146 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong146 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong146 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong146` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong146: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong146 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong146: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong146 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong146`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong146() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong146 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong147: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong147 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong147 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong147 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong147` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong147: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong147 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong147: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong147 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong147`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong147() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong147 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong148: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong148 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong148 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong148 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong148` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong148: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong148 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong148: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong148 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong148`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong148() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong148 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong149: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong149 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong149 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong149 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong149` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong149: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong149 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong149: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong149 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong149`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong149() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong149 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong150: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong150 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong150 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong150 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong150` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong150: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong150 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong150: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong150 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong150`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong150() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong150 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong151: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong151 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong151 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong151 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong151` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong151: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong151 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong151: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong151 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong151`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong151() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong151 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong152: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong152 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong152 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong152 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong152` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong152: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong152 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong152: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong152 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong152`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong152() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong152 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong153: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong153 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong153 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong153 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong153` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong153: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong153 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong153: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong153 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong153`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong153() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong153 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong154: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong154 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong154 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong154 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong154` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong154: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong154 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong154: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong154 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong154`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong154() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong154 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong155: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong155 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong155 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong155 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong155` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong155: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong155 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong155: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong155 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong155`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong155() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong155 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong156: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong156 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong156 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong156 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong156` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong156: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong156 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong156: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong156 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong156`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong156() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong156 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong157: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong157 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong157 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong157 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong157` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong157: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong157 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong157: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong157 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong157`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong157() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong157 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong158: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong158 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong158 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong158 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong158` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong158: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong158 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong158: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong158 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong158`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong158() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong158 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong159: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong159 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong159 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong159 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong159` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong159: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong159 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong159: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong159 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong159`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong159() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong159 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong160: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong160 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong160 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong160 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong160` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong160: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong160 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong160: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong160 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong160`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong160() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong160 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong161: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong161 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong161 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong161 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong161` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong161: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong161 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong161: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong161 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong161`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong161() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong161 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong162: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong162 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong162 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong162 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong162` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong162: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong162 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong162: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong162 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong162`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong162() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong162 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong163: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong163 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong163 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong163 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong163` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong163: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong163 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong163: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong163 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong163`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong163() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong163 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong164: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong164 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong164 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong164 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong164` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong164: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong164 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong164: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong164 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong164`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong164() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong164 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong165: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong165 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong165 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong165 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong165` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong165: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong165 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong165: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong165 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong165`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong165() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong165 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong166: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong166 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong166 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong166 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong166` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong166: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong166 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong166: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong166 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong166`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong166() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong166 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong167: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong167 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong167 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong167 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong167` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong167: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong167 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong167: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong167 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong167`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong167() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong167 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong168: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong168 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong168 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong168 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong168` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong168: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong168 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong168: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong168 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong168`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong168() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong168 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong169: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong169 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong169 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong169 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong169` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong169: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong169 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong169: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong169 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong169`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong169() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong169 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong170: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong170 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong170 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong170 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong170` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong170: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong170 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong170: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong170 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong170`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong170() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong170 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong171: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong171 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong171 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong171 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong171` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong171: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong171 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong171: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong171 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong171`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong171() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong171 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong172: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong172 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong172 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong172 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong172` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong172: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong172 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong172: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong172 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong172`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong172() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong172 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong173: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong173 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong173 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong173 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong173` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong173: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong173 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong173: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong173 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong173`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong173() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong173 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong174: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong174 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong174 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong174 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong174` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong174: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong174 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong174: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong174 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong174`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong174() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong174 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong175: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong175 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong175 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong175 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong175` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong175: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong175 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong175: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong175 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong175`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong175() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong175 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong176: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong176 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong176 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong176 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong176` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong176: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong176 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong176: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong176 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong176`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong176() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong176 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong177: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong177 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong177 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong177 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong177` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong177: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong177 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong177: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong177 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong177`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong177() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong177 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong178: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong178 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong178 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong178 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong178` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong178: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong178 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong178: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong178 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong178`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong178() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong178 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong179: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong179 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong179 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong179 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong179` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong179: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong179 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong179: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong179 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong179`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong179() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong179 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong180: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong180 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong180 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong180 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong180` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong180: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong180 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong180: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong180 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong180`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong180() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong180 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong181: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong181 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong181 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong181 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong181` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong181: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong181 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong181: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong181 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong181`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong181() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong181 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong182: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong182 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong182 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong182 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong182` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong182: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong182 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong182: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong182 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong182`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong182() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong182 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong183: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong183 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong183 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong183 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong183` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong183: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong183 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong183: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong183 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong183`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong183() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong183 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong184: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong184 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong184 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong184 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong184` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong184: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong184 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong184: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong184 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong184`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong184() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong184 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong185: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong185 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong185 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong185 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong185` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong185: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong185 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong185: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong185 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong185`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong185() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong185 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong186: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong186 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong186 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong186 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong186` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong186: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong186 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong186: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong186 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong186`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong186() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong186 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong187: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong187 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong187 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong187 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong187` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong187: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong187 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong187: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong187 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong187`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong187() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong187 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong188: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong188 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong188 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong188 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong188` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong188: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong188 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong188: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong188 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong188`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong188() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong188 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong189: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong189 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong189 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong189 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong189` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong189: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong189 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong189: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong189 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong189`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong189() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong189 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong190: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong190 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong190 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong190 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong190` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong190: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong190 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong190: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong190 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong190`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong190() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong190 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong191: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong191 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong191 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong191 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong191` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong191: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong191 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong191: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong191 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong191`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong191() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong191 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong192: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong192 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong192 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong192 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong192` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong192: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong192 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong192: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong192 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong192`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong192() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong192 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong193: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong193 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong193 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong193 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong193` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong193: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong193 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong193: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong193 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong193`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong193() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong193 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong194: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong194 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong194 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong194 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong194` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong194: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong194 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong194: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong194 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong194`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong194() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong194 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong195: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong195 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong195 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong195 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong195` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong195: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong195 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong195: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong195 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong195`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong195() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong195 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong196: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong196 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong196 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong196 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong196` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong196: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong196 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong196: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong196 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong196`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong196() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong196 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong197: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong197 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong197 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong197 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong197` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong197: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong197 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong197: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong197 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong197`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong197() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong197 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong198: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong198 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong198 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong198 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong198` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong198: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong198 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong198: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong198 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong198`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong198() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong198 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong199: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong199 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong199 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong199 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong199` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong199: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong199 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong199: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong199 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong199`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong199() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong199 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong200: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong200 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong200 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong200 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong200` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong200: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong200 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong200: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong200 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong200`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong200() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong200 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong201: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong201 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong201 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong201 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong201` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong201: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong201 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong201: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong201 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong201`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong201() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong201 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong202: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong202 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong202 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong202 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong202` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong202: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong202 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong202: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong202 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong202`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong202() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong202 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong203: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong203 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong203 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong203 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong203` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong203: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong203 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong203: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong203 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong203`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong203() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong203 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong204: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong204 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong204 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong204 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong204` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong204: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong204 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong204: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong204 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong204`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong204() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong204 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong205: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong205 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong205 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong205 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong205` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong205: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong205 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong205: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong205 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong205`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong205() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong205 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong206: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong206 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong206 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong206 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong206` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong206: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong206 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong206: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong206 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong206`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong206() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong206 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong207: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong207 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong207 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong207 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong207` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong207: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong207 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong207: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong207 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong207`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong207() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong207 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong208: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong208 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong208 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong208 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong208` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong208: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong208 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong208: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong208 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong208`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong208() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong208 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong209: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong209 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong209 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong209 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong209` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong209: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong209 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong209: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong209 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong209`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong209() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong209 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong210: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong210 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong210 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong210 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong210` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong210: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong210 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong210: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong210 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong210`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong210() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong210 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong211: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong211 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong211 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong211 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong211` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong211: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong211 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong211: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong211 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong211`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong211() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong211 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong212: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong212 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong212 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong212 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong212` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong212: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong212 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong212: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong212 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong212`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong212() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong212 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong213: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong213 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong213 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong213 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong213` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong213: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong213 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong213: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong213 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong213`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong213() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong213 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong214: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong214 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong214 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong214 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong214` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong214: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong214 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong214: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong214 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong214`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong214() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong214 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong215: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong215 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong215 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong215 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong215` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong215: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong215 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong215: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong215 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong215`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong215() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong215 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong216: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong216 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong216 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong216 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong216` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong216: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong216 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong216: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong216 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong216`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong216() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong216 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong217: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong217 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong217 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong217 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong217` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong217: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong217 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong217: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong217 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong217`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong217() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong217 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong218: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong218 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong218 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong218 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong218` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong218: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong218 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong218: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong218 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong218`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong218() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong218 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong219: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong219 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong219 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong219 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong219` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong219: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong219 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong219: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong219 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong219`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong219() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong219 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong220: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong220 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong220 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong220 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong220` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong220: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong220 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong220: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong220 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong220`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong220() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong220 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong221: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong221 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong221 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong221 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong221` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong221: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong221 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong221: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong221 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong221`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong221() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong221 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong222: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong222 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong222 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong222 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong222` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong222: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong222 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong222: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong222 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong222`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong222() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong222 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong223: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong223 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong223 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong223 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong223` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong223: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong223 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong223: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong223 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong223`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong223() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong223 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong224: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong224 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong224 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong224 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong224` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong224: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong224 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong224: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong224 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong224`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong224() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong224 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong225: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong225 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong225 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong225 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong225` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong225: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong225 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong225: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong225 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong225`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong225() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong225 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong226: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong226 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong226 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong226 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong226` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong226: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong226 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong226: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong226 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong226`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong226() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong226 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong227: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong227 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong227 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong227 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong227` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong227: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong227 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong227: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong227 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong227`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong227() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong227 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong228: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong228 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong228 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong228 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong228` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong228: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong228 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong228: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong228 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong228`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong228() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong228 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong229: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong229 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong229 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong229 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong229` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong229: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong229 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong229: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong229 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong229`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong229() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong229 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong230: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong230 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong230 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong230 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong230` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong230: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong230 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong230: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong230 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong230`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong230() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong230 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong231: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong231 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong231 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong231 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong231` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong231: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong231 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong231: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong231 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong231`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong231() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong231 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong232: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong232 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong232 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong232 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong232` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong232: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong232 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong232: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong232 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong232`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong232() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong232 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong233: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong233 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong233 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong233 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong233` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong233: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong233 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong233: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong233 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong233`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong233() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong233 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong234: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong234 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong234 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong234 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong234` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong234: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong234 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong234: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong234 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong234`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong234() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong234 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong235: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong235 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong235 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong235 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong235` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong235: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong235 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong235: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong235 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong235`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong235() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong235 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong236: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong236 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong236 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong236 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong236` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong236: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong236 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong236: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong236 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong236`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong236() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong236 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong237: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong237 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong237 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong237 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong237` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong237: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong237 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong237: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong237 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong237`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong237() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong237 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong238: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong238 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong238 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong238 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong238` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong238: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong238 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong238: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong238 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong238`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong238() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong238 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong239: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong239 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong239 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong239 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong239` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong239: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong239 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong239: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong239 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong239`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong239() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong239 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong240: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong240 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong240 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong240 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong240` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong240: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong240 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong240: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong240 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong240`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong240() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong240 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong241: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong241 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong241 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong241 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong241` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong241: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong241 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong241: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong241 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong241`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong241() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong241 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong242: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong242 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong242 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong242 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong242` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong242: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong242 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong242: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong242 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong242`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong242() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong242 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong243: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong243 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong243 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong243 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong243` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong243: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong243 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong243: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong243 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong243`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong243() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong243 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong244: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong244 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong244 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong244 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong244` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong244: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong244 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong244: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong244 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong244`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong244() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong244 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong245: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong245 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong245 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong245 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong245` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong245: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong245 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong245: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong245 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong245`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong245() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong245 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong246: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong246 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong246 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong246 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong246` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong246: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong246 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong246: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong246 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong246`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong246() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong246 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong247: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong247 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong247 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong247 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong247` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong247: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong247 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong247: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong247 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong247`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong247() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong247 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong248: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong248 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong248 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong248 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong248` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong248: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong248 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong248: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong248 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong248`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong248() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong248 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong249: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong249 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong249 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong249 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong249` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong249: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong249 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong249: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong249 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong249`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong249() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong249 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong250: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong250 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong250 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong250 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong250` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong250: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong250 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong250: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong250 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong250`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong250() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong250 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong251: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong251 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong251 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong251 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong251` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong251: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong251 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong251: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong251 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong251`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong251() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong251 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong252: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong252 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong252 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong252 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong252` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong252: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong252 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong252: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong252 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong252`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong252() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong252 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong253: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong253 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong253 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong253 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong253` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong253: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong253 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong253: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong253 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong253`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong253() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong253 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong254: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong254 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong254 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong254 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong254` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong254: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong254 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong254: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong254 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong254`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong254() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong254 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong255: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong255 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong255 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong255 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong255` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong255: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong255 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong255: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong255 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong255`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong255() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong255 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong256: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong256 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong256 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong256 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong256` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong256: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong256 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong256: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong256 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong256`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong256() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong256 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong257: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong257 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong257 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong257 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong257` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong257: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong257 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong257: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong257 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong257`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong257() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong257 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong258: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong258 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong258 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong258 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong258` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong258: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong258 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong258: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong258 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong258`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong258() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong258 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong259: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong259 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong259 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong259 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong259` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong259: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong259 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong259: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong259 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong259`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong259() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong259 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong260: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong260 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong260 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong260 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong260` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong260: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong260 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong260: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong260 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong260`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong260() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong260 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong261: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong261 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong261 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong261 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong261` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong261: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong261 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong261: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong261 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong261`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong261() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong261 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong262: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong262 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong262 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong262 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong262` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong262: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong262 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong262: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong262 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong262`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong262() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong262 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong263: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong263 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong263 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong263 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong263` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong263: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong263 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong263: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong263 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong263`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong263() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong263 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong264: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong264 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong264 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong264 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong264` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong264: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong264 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong264: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong264 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong264`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong264() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong264 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong265: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong265 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong265 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong265 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong265` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong265: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong265 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong265: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong265 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong265`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong265() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong265 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong266: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong266 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong266 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong266 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong266` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong266: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong266 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong266: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong266 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong266`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong266() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong266 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong267: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong267 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong267 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong267 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong267` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong267: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong267 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong267: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong267 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong267`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong267() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong267 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong268: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong268 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong268 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong268 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong268` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong268: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong268 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong268: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong268 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong268`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong268() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong268 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong269: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong269 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong269 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong269 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong269` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong269: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong269 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong269: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong269 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong269`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong269() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong269 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong270: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong270 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong270 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong270 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong270` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong270: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong270 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong270: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong270 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong270`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong270() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong270 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong271: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong271 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong271 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong271 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong271` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong271: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong271 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong271: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong271 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong271`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong271() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong271 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong272: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong272 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong272 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong272 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong272` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong272: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong272 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong272: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong272 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong272`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong272() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong272 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong273: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong273 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong273 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong273 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong273` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong273: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong273 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong273: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong273 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong273`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong273() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong273 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong274: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong274 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong274 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong274 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong274` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong274: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong274 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong274: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong274 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong274`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong274() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong274 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong275: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong275 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong275 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong275 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong275` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong275: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong275 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong275: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong275 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong275`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong275() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong275 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong276: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong276 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong276 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong276 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong276` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong276: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong276 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong276: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong276 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong276`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong276() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong276 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong277: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong277 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong277 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong277 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong277` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong277: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong277 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong277: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong277 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong277`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong277() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong277 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong278: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong278 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong278 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong278 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong278` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong278: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong278 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong278: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong278 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong278`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong278() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong278 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong279: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong279 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong279 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong279 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong279` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong279: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong279 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong279: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong279 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong279`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong279() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong279 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong280: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong280 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong280 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong280 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong280` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong280: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong280 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong280: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong280 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong280`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong280() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong280 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong281: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong281 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong281 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong281 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong281` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong281: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong281 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong281: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong281 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong281`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong281() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong281 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong282: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong282 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong282 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong282 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong282` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong282: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong282 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong282: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong282 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong282`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong282() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong282 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong283: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong283 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong283 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong283 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong283` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong283: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong283 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong283: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong283 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong283`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong283() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong283 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong284: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong284 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong284 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong284 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong284` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong284: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong284 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong284: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong284 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong284`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong284() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong284 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong285: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong285 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong285 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong285 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong285` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong285: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong285 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong285: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong285 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong285`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong285() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong285 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong286: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong286 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong286 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong286 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong286` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong286: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong286 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong286: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong286 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong286`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong286() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong286 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong287: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong287 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong287 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong287 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong287` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong287: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong287 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong287: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong287 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong287`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong287() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong287 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong288: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong288 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong288 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong288 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong288` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong288: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong288 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong288: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong288 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong288`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong288() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong288 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong289: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong289 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong289 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong289 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong289` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong289: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong289 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong289: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong289 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong289`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong289() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong289 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong290: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong290 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong290 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong290 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong290` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong290: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong290 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong290: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong290 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong290`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong290() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong290 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong291: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong291 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong291 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong291 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong291` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong291: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong291 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong291: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong291 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong291`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong291() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong291 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong292: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong292 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong292 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong292 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong292` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong292: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong292 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong292: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong292 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong292`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong292() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong292 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong293: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong293 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong293 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong293 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong293` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong293: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong293 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong293: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong293 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong293`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong293() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong293 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong294: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong294 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong294 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong294 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong294` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong294: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong294 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong294: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong294 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong294`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong294() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong294 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong295: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong295 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong295 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong295 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong295` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong295: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong295 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong295: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong295 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong295`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong295() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong295 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong296: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong296 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong296 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong296 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong296` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong296: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong296 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong296: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong296 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong296`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong296() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong296 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong297: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong297 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong297 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong297 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong297` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong297: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong297 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong297: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong297 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong297`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong297() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong297 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong298: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong298 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong298 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong298 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong298` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong298: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong298 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong298: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong298 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong298`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong298() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong298 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong299: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong299 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong299 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong299 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong299` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong299: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong299 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong299: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong299 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong299`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong299() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong299 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong300: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong300 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong300 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong300 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong300` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong300: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong300 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong300: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong300 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong300`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong300() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong300 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong301: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong301 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong301 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong301 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong301` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong301: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong301 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong301: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong301 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong301`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong301() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong301 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong302: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong302 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong302 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong302 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong302` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong302: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong302 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong302: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong302 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong302`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong302() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong302 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong303: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong303 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong303 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong303 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong303` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong303: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong303 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong303: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong303 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong303`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong303() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong303 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong304: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong304 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong304 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong304 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong304` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong304: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong304 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong304: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong304 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong304`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong304() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong304 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong305: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong305 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong305 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong305 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong305` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong305: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong305 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong305: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong305 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong305`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong305() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong305 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong306: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong306 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong306 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong306 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong306` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong306: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong306 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong306: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong306 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong306`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong306() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong306 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong307: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong307 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong307 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong307 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong307` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong307: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong307 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong307: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong307 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong307`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong307() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong307 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong308: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong308 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong308 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong308 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong308` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong308: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong308 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong308: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong308 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong308`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong308() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong308 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong309: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong309 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong309 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong309 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong309` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong309: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong309 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong309: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong309 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong309`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong309() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong309 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong310: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong310 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong310 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong310 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong310` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong310: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong310 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong310: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong310 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong310`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong310() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong310 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong311: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong311 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong311 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong311 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong311` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong311: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong311 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong311: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong311 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong311`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong311() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong311 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong312: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong312 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong312 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong312 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong312` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong312: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong312 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong312: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong312 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong312`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong312() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong312 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong313: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong313 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong313 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong313 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong313` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong313: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong313 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong313: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong313 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong313`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong313() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong313 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong314: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong314 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong314 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong314 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong314` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong314: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong314 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong314: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong314 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong314`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong314() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong314 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong315: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong315 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong315 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong315 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong315` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong315: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong315 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong315: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong315 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong315`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong315() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong315 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong316: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong316 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong316 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong316 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong316` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong316: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong316 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong316: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong316 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong316`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong316() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong316 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong317: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong317 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong317 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong317 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong317` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong317: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong317 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong317: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong317 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong317`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong317() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong317 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong318: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong318 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong318 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong318 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong318` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong318: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong318 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong318: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong318 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong318`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong318() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong318 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong319: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong319 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong319 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong319 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong319` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong319: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong319 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong319: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong319 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong319`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong319() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong319 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong320: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong320 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong320 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong320 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong320` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong320: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong320 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong320: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong320 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong320`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong320() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong320 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong321: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong321 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong321 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong321 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong321` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong321: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong321 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong321: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong321 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong321`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong321() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong321 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong322: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong322 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong322 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong322 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong322` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong322: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong322 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong322: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong322 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong322`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong322() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong322 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong323: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong323 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong323 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong323 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong323` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong323: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong323 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong323: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong323 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong323`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong323() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong323 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong324: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong324 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong324 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong324 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong324` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong324: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong324 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong324: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong324 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong324`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong324() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong324 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong325: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong325 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong325 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong325 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong325` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong325: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong325 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong325: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong325 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong325`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong325() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong325 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong326: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong326 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong326 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong326 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong326` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong326: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong326 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong326: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong326 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong326`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong326() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong326 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong327: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong327 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong327 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong327 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong327` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong327: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong327 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong327: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong327 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong327`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong327() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong327 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong328: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong328 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong328 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong328 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong328` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong328: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong328 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong328: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong328 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong328`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong328() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong328 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong329: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong329 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong329 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong329 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong329` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong329: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong329 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong329: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong329 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong329`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong329() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong329 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong330: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong330 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong330 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong330 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong330` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong330: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong330 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong330: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong330 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong330`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong330() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong330 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong331: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong331 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong331 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong331 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong331` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong331: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong331 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong331: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong331 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong331`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong331() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong331 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong332: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong332 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong332 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong332 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong332` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong332: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong332 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong332: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong332 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong332`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong332() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong332 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong333: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong333 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong333 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong333 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong333` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong333: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong333 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong333: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong333 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong333`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong333() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong333 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong334: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong334 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong334 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong334 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong334` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong334: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong334 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong334: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong334 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong334`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong334() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong334 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong335: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong335 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong335 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong335 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong335` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong335: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong335 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong335: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong335 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong335`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong335() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong335 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong336: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong336 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong336 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong336 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong336` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong336: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong336 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong336: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong336 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong336`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong336() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong336 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong337: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong337 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong337 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong337 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong337` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong337: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong337 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong337: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong337 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong337`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong337() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong337 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong338: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong338 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong338 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong338 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong338` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong338: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong338 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong338: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong338 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong338`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong338() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong338 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong339: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong339 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong339 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong339 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong339` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong339: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong339 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong339: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong339 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong339`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong339() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong339 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong340: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong340 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong340 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong340 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong340` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong340: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong340 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong340: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong340 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong340`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong340() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong340 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong341: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong341 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong341 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong341 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong341` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong341: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong341 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong341: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong341 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong341`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong341() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong341 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong342: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong342 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong342 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong342 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong342` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong342: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong342 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong342: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong342 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong342`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong342() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong342 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong343: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong343 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong343 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong343 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong343` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong343: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong343 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong343: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong343 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong343`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong343() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong343 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong344: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong344 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong344 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong344 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong344` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong344: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong344 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong344: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong344 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong344`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong344() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong344 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong345: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong345 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong345 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong345 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong345` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong345: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong345 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong345: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong345 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong345`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong345() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong345 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong346: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong346 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong346 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong346 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong346` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong346: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong346 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong346: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong346 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong346`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong346() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong346 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong347: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong347 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong347 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong347 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong347` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong347: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong347 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong347: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong347 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong347`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong347() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong347 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong348: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong348 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong348 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong348 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong348` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong348: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong348 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong348: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong348 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong348`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong348() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong348 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong349: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong349 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong349 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong349 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong349` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong349: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong349 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong349: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong349 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong349`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong349() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong349 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong350: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong350 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong350 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong350 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong350` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong350: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong350 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong350: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong350 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong350`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong350() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong350 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong351: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong351 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong351 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong351 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong351` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong351: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong351 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong351: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong351 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong351`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong351() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong351 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong352: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong352 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong352 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong352 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong352` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong352: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong352 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong352: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong352 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong352`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong352() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong352 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong353: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong353 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong353 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong353 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong353` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong353: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong353 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong353: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong353 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong353`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong353() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong353 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong354: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong354 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong354 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong354 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong354` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong354: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong354 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong354: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong354 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong354`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong354() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong354 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong355: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong355 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong355 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong355 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong355` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong355: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong355 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong355: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong355 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong355`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong355() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong355 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong356: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong356 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong356 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong356 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong356` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong356: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong356 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong356: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong356 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong356`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong356() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong356 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong357: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong357 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong357 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong357 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong357` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong357: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong357 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong357: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong357 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong357`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong357() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong357 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong358: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong358 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong358 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong358 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong358` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong358: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong358 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong358: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong358 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong358`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong358() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong358 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong359: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong359 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong359 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong359 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong359` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong359: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong359 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong359: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong359 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong359`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong359() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong359 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong360: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong360 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong360 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong360 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong360` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong360: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong360 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong360: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong360 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong360`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong360() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong360 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong361: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong361 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong361 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong361 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong361` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong361: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong361 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong361: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong361 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong361`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong361() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong361 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong362: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong362 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong362 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong362 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong362` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong362: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong362 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong362: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong362 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong362`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong362() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong362 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong363: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong363 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong363 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong363 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong363` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong363: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong363 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong363: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong363 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong363`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong363() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong363 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong364: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong364 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong364 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong364 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong364` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong364: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong364 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong364: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong364 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong364`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong364() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong364 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong365: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong365 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong365 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong365 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong365` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong365: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong365 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong365: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong365 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong365`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong365() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong365 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong366: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong366 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong366 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong366 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong366` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong366: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong366 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong366: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong366 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong366`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong366() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong366 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong367: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong367 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong367 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong367 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong367` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong367: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong367 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong367: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong367 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong367`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong367() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong367 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong368: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong368 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong368 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong368 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong368` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong368: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong368 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong368: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong368 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong368`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong368() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong368 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong369: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong369 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong369 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong369 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong369` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong369: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong369 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong369: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong369 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong369`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong369() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong369 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong370: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong370 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong370 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong370 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong370` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong370: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong370 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong370: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong370 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong370`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong370() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong370 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong371: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong371 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong371 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong371 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong371` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong371: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong371 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong371: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong371 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong371`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong371() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong371 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong372: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong372 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong372 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong372 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong372` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong372: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong372 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong372: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong372 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong372`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong372() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong372 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong373: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong373 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong373 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong373 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong373` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong373: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong373 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong373: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong373 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong373`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong373() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong373 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong374: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong374 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong374 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong374 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong374` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong374: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong374 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong374: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong374 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong374`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong374() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong374 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong375: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong375 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong375 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong375 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong375` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong375: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong375 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong375: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong375 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong375`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong375() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong375 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong376: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong376 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong376 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong376 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong376` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong376: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong376 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong376: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong376 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong376`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong376() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong376 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong377: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong377 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong377 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong377 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong377` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong377: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong377 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong377: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong377 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong377`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong377() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong377 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong378: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong378 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong378 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong378 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong378` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong378: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong378 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong378: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong378 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong378`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong378() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong378 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong379: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong379 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong379 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong379 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong379` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong379: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong379 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong379: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong379 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong379`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong379() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong379 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong380: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong380 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong380 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong380 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong380` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong380: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong380 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong380: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong380 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong380`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong380() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong380 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong381: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong381 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong381 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong381 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong381` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong381: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong381 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong381: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong381 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong381`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong381() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong381 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong382: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong382 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong382 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong382 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong382` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong382: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong382 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong382: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong382 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong382`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong382() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong382 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong383: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong383 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong383 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong383 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong383` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong383: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong383 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong383: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong383 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong383`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong383() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong383 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong384: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong384 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong384 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong384 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong384` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong384: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong384 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong384: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong384 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong384`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong384() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong384 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong385: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong385 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong385 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong385 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong385` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong385: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong385 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong385: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong385 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong385`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong385() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong385 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong386: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong386 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong386 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong386 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong386` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong386: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong386 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong386: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong386 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong386`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong386() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong386 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong387: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong387 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong387 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong387 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong387` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong387: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong387 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong387: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong387 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong387`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong387() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong387 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong388: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong388 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong388 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong388 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong388` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong388: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong388 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong388: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong388 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong388`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong388() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong388 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong389: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong389 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong389 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong389 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong389` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong389: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong389 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong389: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong389 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong389`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong389() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong389 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong390: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong390 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong390 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong390 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong390` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong390: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong390 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong390: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong390 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong390`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong390() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong390 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong391: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong391 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong391 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong391 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong391` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong391: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong391 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong391: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong391 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong391`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong391() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong391 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong392: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong392 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong392 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong392 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong392` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong392: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong392 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong392: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong392 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong392`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong392() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong392 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong393: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong393 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong393 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong393 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong393` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong393: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong393 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong393: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong393 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong393`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong393() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong393 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong394: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong394 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong394 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong394 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong394` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong394: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong394 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong394: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong394 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong394`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong394() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong394 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong395: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong395 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong395 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong395 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong395` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong395: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong395 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong395: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong395 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong395`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong395() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong395 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong396: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong396 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong396 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong396 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong396` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong396: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong396 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong396: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong396 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong396`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong396() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong396 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong397: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong397 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong397 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong397 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong397` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong397: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong397 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong397: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong397 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong397`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong397() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong397 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong398: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong398 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong398 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong398 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong398` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong398: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong398 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong398: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong398 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong398`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong398() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong398 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong399: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong399 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong399 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong399 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong399` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong399: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong399 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong399: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong399 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong399`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong399() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong399 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong400: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong400 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong400 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong400 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong400` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong400: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong400 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong400: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong400 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong400`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong400() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong400 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong401: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong401 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong401 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong401 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong401` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong401: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong401 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong401: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong401 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong401`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong401() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong401 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong402: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong402 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong402 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong402 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong402` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong402: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong402 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong402: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong402 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong402`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong402() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong402 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong403: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong403 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong403 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong403 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong403` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong403: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong403 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong403: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong403 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong403`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong403() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong403 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong404: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong404 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong404 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong404 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong404` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong404: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong404 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong404: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong404 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong404`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong404() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong404 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong405: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong405 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong405 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong405 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong405` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong405: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong405 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong405: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong405 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong405`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong405() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong405 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong406: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong406 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong406 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong406 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong406` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong406: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong406 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong406: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong406 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong406`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong406() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong406 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong407: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong407 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong407 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong407 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong407` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong407: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong407 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong407: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong407 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong407`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong407() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong407 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong408: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong408 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong408 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong408 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong408` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong408: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong408 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong408: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong408 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong408`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong408() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong408 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong409: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong409 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong409 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong409 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong409` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong409: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong409 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong409: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong409 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong409`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong409() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong409 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong410: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong410 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong410 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong410 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong410` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong410: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong410 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong410: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong410 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong410`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong410() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong410 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong411: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong411 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong411 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong411 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong411` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong411: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong411 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong411: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong411 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong411`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong411() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong411 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong412: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong412 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong412 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong412 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong412` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong412: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong412 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong412: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong412 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong412`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong412() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong412 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong413: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong413 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong413 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong413 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong413` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong413: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong413 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong413: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong413 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong413`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong413() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong413 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong414: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong414 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong414 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong414 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong414` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong414: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong414 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong414: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong414 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong414`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong414() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong414 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong415: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong415 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong415 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong415 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong415` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong415: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong415 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong415: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong415 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong415`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong415() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong415 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong416: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong416 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong416 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong416 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong416` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong416: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong416 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong416: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong416 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong416`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong416() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong416 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong417: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong417 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong417 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong417 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong417` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong417: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong417 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong417: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong417 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong417`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong417() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong417 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong418: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong418 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong418 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong418 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong418` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong418: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong418 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong418: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong418 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong418`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong418() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong418 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong419: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong419 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong419 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong419 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong419` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong419: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong419 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong419: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong419 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong419`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong419() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong419 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong420: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong420 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong420 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong420 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong420` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong420: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong420 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong420: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong420 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong420`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong420() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong420 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong421: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong421 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong421 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong421 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong421` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong421: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong421 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong421: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong421 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong421`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong421() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong421 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong422: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong422 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong422 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong422 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong422` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong422: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong422 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong422: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong422 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong422`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong422() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong422 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong423: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong423 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong423 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong423 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong423` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong423: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong423 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong423: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong423 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong423`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong423() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong423 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong424: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong424 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong424 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong424 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong424` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong424: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong424 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong424: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong424 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong424`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong424() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong424 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong425: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong425 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong425 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong425 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong425` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong425: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong425 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong425: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong425 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong425`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong425() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong425 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong426: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong426 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong426 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong426 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong426` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong426: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong426 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong426: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong426 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong426`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong426() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong426 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong427: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong427 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong427 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong427 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong427` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong427: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong427 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong427: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong427 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong427`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong427() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong427 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong428: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong428 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong428 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong428 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong428` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong428: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong428 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong428: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong428 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong428`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong428() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong428 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong429: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong429 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong429 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong429 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong429` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong429: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong429 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong429: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong429 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong429`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong429() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong429 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong430: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong430 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong430 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong430 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong430` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong430: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong430 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong430: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong430 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong430`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong430() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong430 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong431: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong431 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong431 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong431 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong431` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong431: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong431 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong431: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong431 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong431`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong431() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong431 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong432: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong432 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong432 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong432 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong432` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong432: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong432 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong432: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong432 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong432`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong432() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong432 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong433: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong433 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong433 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong433 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong433` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong433: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong433 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong433: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong433 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong433`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong433() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong433 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong434: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong434 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong434 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong434 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong434` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong434: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong434 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong434: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong434 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong434`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong434() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong434 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong435: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong435 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong435 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong435 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong435` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong435: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong435 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong435: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong435 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong435`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong435() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong435 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong436: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong436 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong436 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong436 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong436` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong436: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong436 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong436: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong436 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong436`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong436() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong436 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong437: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong437 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong437 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong437 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong437` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong437: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong437 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong437: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong437 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong437`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong437() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong437 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong438: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong438 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong438 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong438 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong438` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong438: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong438 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong438: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong438 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong438`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong438() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong438 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong439: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong439 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong439 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong439 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong439` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong439: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong439 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong439: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong439 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong439`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong439() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong439 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong440: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong440 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong440 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong440 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong440` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong440: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong440 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong440: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong440 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong440`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong440() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong440 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong441: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong441 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong441 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong441 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong441` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong441: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong441 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong441: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong441 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong441`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong441() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong441 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong442: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong442 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong442 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong442 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong442` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong442: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong442 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong442: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong442 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong442`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong442() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong442 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong443: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong443 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong443 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong443 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong443` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong443: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong443 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong443: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong443 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong443`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong443() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong443 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong444: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong444 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong444 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong444 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong444` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong444: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong444 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong444: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong444 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong444`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong444() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong444 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong445: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong445 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong445 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong445 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong445` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong445: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong445 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong445: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong445 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong445`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong445() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong445 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong446: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong446 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong446 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong446 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong446` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong446: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong446 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong446: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong446 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong446`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong446() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong446 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong447: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong447 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong447 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong447 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong447` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong447: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong447 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong447: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong447 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong447`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong447() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong447 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong448: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong448 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong448 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong448 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong448` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong448: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong448 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong448: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong448 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong448`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong448() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong448 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong449: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong449 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong449 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong449 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong449` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong449: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong449 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong449: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong449 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong449`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong449() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong449 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong450: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong450 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong450 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong450 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong450` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong450: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong450 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong450: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong450 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong450`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong450() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong450 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong451: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong451 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong451 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong451 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong451` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong451: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong451 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong451: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong451 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong451`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong451() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong451 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong452: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong452 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong452 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong452 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong452` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong452: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong452 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong452: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong452 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong452`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong452() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong452 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong453: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong453 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong453 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong453 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong453` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong453: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong453 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong453: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong453 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong453`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong453() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong453 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong454: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong454 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong454 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong454 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong454` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong454: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong454 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong454: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong454 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong454`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong454() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong454 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong455: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong455 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong455 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong455 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong455` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong455: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong455 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong455: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong455 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong455`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong455() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong455 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong456: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong456 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong456 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong456 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong456` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong456: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong456 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong456: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong456 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong456`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong456() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong456 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong457: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong457 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong457 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong457 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong457` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong457: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong457 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong457: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong457 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong457`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong457() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong457 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong458: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong458 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong458 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong458 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong458` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong458: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong458 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong458: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong458 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong458`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong458() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong458 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong459: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong459 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong459 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong459 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong459` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong459: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong459 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong459: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong459 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong459`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong459() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong459 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong460: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong460 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong460 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong460 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong460` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong460: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong460 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong460: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong460 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong460`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong460() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong460 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong461: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong461 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong461 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong461 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong461` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong461: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong461 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong461: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong461 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong461`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong461() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong461 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong462: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong462 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong462 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong462 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong462` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong462: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong462 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong462: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong462 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong462`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong462() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong462 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong463: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong463 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong463 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong463 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong463` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong463: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong463 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong463: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong463 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong463`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong463() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong463 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong464: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong464 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong464 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong464 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong464` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong464: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong464 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong464: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong464 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong464`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong464() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong464 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong465: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong465 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong465 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong465 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong465` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong465: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong465 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong465: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong465 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong465`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong465() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong465 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong466: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong466 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong466 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong466 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong466` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong466: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong466 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong466: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong466 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong466`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong466() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong466 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong467: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong467 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong467 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong467 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong467` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong467: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong467 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong467: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong467 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong467`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong467() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong467 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong468: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong468 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong468 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong468 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong468` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong468: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong468 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong468: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong468 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong468`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong468() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong468 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong469: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong469 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong469 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong469 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong469` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong469: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong469 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong469: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong469 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong469`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong469() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong469 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong470: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong470 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong470 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong470 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong470` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong470: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong470 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong470: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong470 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong470`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong470() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong470 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong471: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong471 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong471 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong471 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong471` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong471: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong471 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong471: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong471 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong471`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong471() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong471 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong472: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong472 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong472 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong472 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong472` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong472: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong472 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong472: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong472 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong472`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong472() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong472 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong473: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong473 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong473 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong473 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong473` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong473: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong473 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong473: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong473 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong473`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong473() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong473 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong474: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong474 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong474 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong474 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong474` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong474: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong474 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong474: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong474 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong474`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong474() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong474 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong475: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong475 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong475 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong475 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong475` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong475: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong475 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong475: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong475 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong475`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong475() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong475 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong476: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong476 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong476 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong476 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong476` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong476: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong476 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong476: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong476 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong476`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong476() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong476 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong477: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong477 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong477 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong477 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong477` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong477: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong477 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong477: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong477 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong477`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong477() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong477 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong478: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong478 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong478 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong478 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong478` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong478: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong478 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong478: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong478 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong478`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong478() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong478 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong479: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong479 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong479 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong479 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong479` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong479: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong479 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong479: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong479 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong479`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong479() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong479 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong480: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong480 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong480 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong480 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong480` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong480: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong480 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong480: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong480 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong480`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong480() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong480 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong481: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong481 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong481 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong481 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong481` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong481: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong481 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong481: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong481 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong481`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong481() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong481 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong482: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong482 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong482 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong482 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong482` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong482: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong482 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong482: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong482 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong482`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong482() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong482 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong483: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong483 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong483 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong483 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong483` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong483: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong483 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong483: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong483 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong483`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong483() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong483 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong484: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong484 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong484 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong484 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong484` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong484: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong484 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong484: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong484 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong484`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong484() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong484 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong485: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong485 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong485 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong485 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong485` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong485: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong485 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong485: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong485 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong485`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong485() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong485 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong486: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong486 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong486 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong486 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong486` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong486: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong486 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong486: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong486 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong486`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong486() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong486 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong487: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong487 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong487 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong487 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong487` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong487: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong487 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong487: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong487 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong487`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong487() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong487 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong488: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong488 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong488 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong488 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong488` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong488: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong488 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong488: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong488 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong488`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong488() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong488 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong489: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong489 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong489 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong489 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong489` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong489: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong489 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong489: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong489 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong489`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong489() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong489 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong490: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong490 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong490 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong490 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong490` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong490: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong490 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong490: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong490 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong490`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong490() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong490 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong491: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong491 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong491 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong491 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong491` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong491: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong491 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong491: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong491 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong491`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong491() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong491 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong492: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong492 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong492 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong492 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong492` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong492: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong492 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong492: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong492 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong492`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong492() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong492 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong493: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong493 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong493 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong493 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong493` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong493: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong493 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong493: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong493 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong493`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong493() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong493 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong494: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong494 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong494 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong494 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong494` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong494: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong494 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong494: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong494 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong494`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong494() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong494 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong495: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong495 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong495 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong495 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong495` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong495: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong495 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong495: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong495 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong495`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong495() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong495 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong496: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong496 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong496 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong496 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong496` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong496: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong496 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong496: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong496 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong496`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong496() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong496 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong497: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong497 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong497 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong497 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong497` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong497: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong497 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong497: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong497 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong497`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong497() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong497 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong498: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong498 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong498 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong498 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong498` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong498: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong498 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong498: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong498 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong498`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong498() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong498 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong499: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong499 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong499 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong499 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong499` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong499: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong499 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong499: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong499 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong499`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong499() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong499 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong500: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong500 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong500 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong500 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong500` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong500: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong500 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong500: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong500 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong500`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong500() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong500 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong501: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong501 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong501 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong501 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong501` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong501: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong501 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong501: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong501 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong501`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong501() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong501 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong502: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong502 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong502 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong502 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong502` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong502: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong502 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong502: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong502 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong502`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong502() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong502 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong503: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong503 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong503 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong503 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong503` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong503: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong503 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong503: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong503 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong503`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong503() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong503 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong504: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong504 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong504 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong504 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong504` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong504: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong504 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong504: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong504 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong504`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong504() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong504 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong505: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong505 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong505 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong505 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong505` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong505: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong505 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong505: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong505 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong505`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong505() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong505 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong506: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong506 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong506 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong506 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong506` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong506: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong506 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong506: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong506 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong506`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong506() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong506 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong507: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong507 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong507 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong507 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong507` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong507: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong507 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong507: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong507 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong507`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong507() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong507 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong508: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong508 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong508 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong508 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong508` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong508: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong508 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong508: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong508 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong508`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong508() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong508 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong509: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong509 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong509 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong509 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong509` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong509: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong509 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong509: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong509 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong509`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong509() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong509 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong510: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong510 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong510 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong510 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong510` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong510: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong510 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong510: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong510 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong510`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong510() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong510 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong511: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong511 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong511 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong511 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong511` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong511: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong511 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong511: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong511 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong511`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong511() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong511 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong512: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong512 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong512 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong512 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong512` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong512: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong512 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong512: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong512 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong512`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong512() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong512 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong513: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong513 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong513 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong513 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong513` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong513: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong513 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong513: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong513 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong513`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong513() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong513 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong514: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong514 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong514 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong514 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong514` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong514: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong514 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong514: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong514 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong514`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong514() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong514 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong515: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong515 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong515 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong515 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong515` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong515: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong515 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong515: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong515 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong515`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong515() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong515 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong516: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong516 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong516 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong516 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong516` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong516: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong516 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong516: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong516 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong516`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong516() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong516 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong517: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong517 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong517 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong517 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong517` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong517: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong517 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong517: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong517 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong517`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong517() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong517 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong518: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong518 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong518 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong518 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong518` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong518: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong518 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong518: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong518 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong518`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong518() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong518 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong519: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong519 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong519 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong519 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong519` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong519: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong519 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong519: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong519 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong519`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong519() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong519 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong520: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong520 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong520 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong520 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong520` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong520: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong520 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong520: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong520 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong520`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong520() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong520 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong521: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong521 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong521 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong521 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong521` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong521: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong521 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong521: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong521 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong521`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong521() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong521 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong522: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong522 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong522 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong522 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong522` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong522: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong522 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong522: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong522 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong522`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong522() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong522 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong523: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong523 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong523 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong523 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong523` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong523: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong523 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong523: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong523 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong523`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong523() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong523 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong524: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong524 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong524 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong524 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong524` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong524: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong524 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong524: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong524 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong524`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong524() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong524 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong525: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong525 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong525 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong525 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong525` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong525: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong525 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong525: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong525 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong525`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong525() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong525 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong526: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong526 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong526 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong526 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong526` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong526: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong526 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong526: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong526 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong526`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong526() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong526 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong527: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong527 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong527 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong527 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong527` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong527: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong527 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong527: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong527 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong527`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong527() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong527 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong528: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong528 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong528 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong528 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong528` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong528: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong528 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong528: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong528 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong528`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong528() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong528 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong529: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong529 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong529 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong529 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong529` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong529: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong529 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong529: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong529 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong529`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong529() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong529 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong530: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong530 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong530 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong530 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong530` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong530: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong530 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong530: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong530 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong530`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong530() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong530 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong531: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong531 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong531 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong531 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong531` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong531: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong531 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong531: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong531 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong531`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong531() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong531 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong532: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong532 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong532 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong532 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong532` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong532: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong532 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong532: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong532 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong532`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong532() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong532 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong533: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong533 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong533 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong533 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong533` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong533: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong533 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong533: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong533 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong533`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong533() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong533 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong534: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong534 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong534 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong534 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong534` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong534: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong534 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong534: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong534 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong534`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong534() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong534 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong535: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong535 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong535 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong535 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong535` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong535: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong535 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong535: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong535 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong535`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong535() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong535 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong536: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong536 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong536 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong536 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong536` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong536: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong536 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong536: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong536 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong536`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong536() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong536 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong537: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong537 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong537 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong537 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong537` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong537: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong537 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong537: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong537 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong537`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong537() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong537 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong538: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong538 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong538 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong538 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong538` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong538: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong538 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong538: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong538 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong538`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong538() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong538 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong539: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong539 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong539 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong539 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong539` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong539: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong539 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong539: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong539 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong539`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong539() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong539 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong540: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong540 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong540 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong540 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong540` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong540: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong540 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong540: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong540 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong540`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong540() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong540 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong541: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong541 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong541 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong541 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong541` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong541: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong541 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong541: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong541 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong541`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong541() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong541 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong542: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong542 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong542 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong542 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong542` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong542: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong542 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong542: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong542 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong542`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong542() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong542 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong543: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong543 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong543 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong543 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong543` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong543: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong543 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong543: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong543 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong543`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong543() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong543 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong544: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong544 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong544 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong544 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong544` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong544: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong544 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong544: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong544 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong544`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong544() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong544 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong545: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong545 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong545 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong545 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong545` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong545: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong545 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong545: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong545 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong545`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong545() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong545 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong546: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong546 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong546 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong546 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong546` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong546: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong546 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong546: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong546 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong546`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong546() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong546 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong547: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong547 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong547 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong547 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong547` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong547: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong547 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong547: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong547 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong547`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong547() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong547 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong548: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong548 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong548 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong548 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong548` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong548: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong548 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong548: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong548 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong548`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong548() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong548 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong549: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong549 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong549 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong549 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong549` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong549: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong549 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong549: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong549 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong549`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong549() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong549 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong550: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong550 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong550 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong550 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong550` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong550: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong550 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong550: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong550 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong550`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong550() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong550 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong551: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong551 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong551 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong551 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong551` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong551: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong551 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong551: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong551 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong551`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong551() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong551 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong552: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong552 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong552 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong552 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong552` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong552: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong552 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong552: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong552 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong552`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong552() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong552 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong553: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong553 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong553 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong553 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong553` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong553: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong553 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong553: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong553 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong553`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong553() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong553 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong554: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong554 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong554 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong554 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong554` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong554: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong554 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong554: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong554 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong554`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong554() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong554 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong555: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong555 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong555 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong555 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong555` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong555: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong555 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong555: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong555 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong555`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong555() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong555 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong556: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong556 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong556 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong556 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong556` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong556: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong556 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong556: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong556 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong556`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong556() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong556 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong557: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong557 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong557 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong557 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong557` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong557: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong557 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong557: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong557 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong557`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong557() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong557 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong558: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong558 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong558 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong558 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong558` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong558: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong558 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong558: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong558 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong558`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong558() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong558 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong559: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong559 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong559 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong559 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong559` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong559: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong559 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong559: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong559 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong559`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong559() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong559 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong560: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong560 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong560 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong560 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong560` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong560: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong560 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong560: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong560 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong560`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong560() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong560 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong561: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong561 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong561 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong561 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong561` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong561: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong561 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong561: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong561 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong561`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong561() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong561 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong562: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong562 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong562 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong562 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong562` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong562: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong562 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong562: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong562 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong562`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong562() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong562 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong563: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong563 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong563 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong563 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong563` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong563: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong563 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong563: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong563 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong563`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong563() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong563 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong564: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong564 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong564 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong564 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong564` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong564: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong564 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong564: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong564 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong564`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong564() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong564 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong565: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong565 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong565 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong565 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong565` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong565: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong565 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong565: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong565 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong565`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong565() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong565 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong566: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong566 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong566 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong566 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong566` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong566: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong566 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong566: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong566 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong566`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong566() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong566 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong567: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong567 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong567 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong567 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong567` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong567: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong567 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong567: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong567 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong567`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong567() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong567 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong568: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong568 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong568 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong568 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong568` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong568: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong568 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong568: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong568 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong568`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong568() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong568 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong569: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong569 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong569 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong569 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong569` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong569: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong569 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong569: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong569 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong569`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong569() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong569 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong570: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong570 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong570 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong570 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong570` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong570: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong570 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong570: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong570 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong570`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong570() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong570 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong571: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong571 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong571 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong571 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong571` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong571: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong571 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong571: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong571 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong571`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong571() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong571 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong572: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong572 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong572 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong572 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong572` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong572: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong572 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong572: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong572 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong572`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong572() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong572 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong573: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong573 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong573 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong573 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong573` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong573: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong573 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong573: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong573 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong573`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong573() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong573 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong574: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong574 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong574 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong574 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong574` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong574: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong574 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong574: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong574 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong574`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong574() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong574 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong575: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong575 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong575 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong575 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong575` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong575: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong575 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong575: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong575 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong575`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong575() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong575 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong576: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong576 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong576 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong576 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong576` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong576: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong576 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong576: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong576 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong576`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong576() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong576 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong577: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong577 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong577 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong577 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong577` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong577: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong577 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong577: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong577 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong577`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong577() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong577 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong578: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong578 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong578 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong578 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong578` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong578: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong578 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong578: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong578 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong578`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong578() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong578 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong579: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong579 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong579 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong579 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong579` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong579: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong579 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong579: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong579 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong579`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong579() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong579 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong580: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong580 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong580 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong580 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong580` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong580: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong580 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong580: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong580 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong580`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong580() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong580 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong581: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong581 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong581 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong581 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong581` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong581: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong581 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong581: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong581 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong581`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong581() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong581 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong582: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong582 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong582 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong582 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong582` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong582: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong582 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong582: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong582 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong582`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong582() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong582 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong583: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong583 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong583 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong583 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong583` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong583: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong583 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong583: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong583 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong583`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong583() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong583 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong584: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong584 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong584 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong584 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong584` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong584: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong584 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong584: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong584 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong584`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong584() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong584 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong585: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong585 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong585 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong585 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong585` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong585: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong585 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong585: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong585 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong585`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong585() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong585 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong586: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong586 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong586 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong586 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong586` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong586: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong586 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong586: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong586 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong586`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong586() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong586 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong587: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong587 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong587 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong587 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong587` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong587: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong587 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong587: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong587 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong587`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong587() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong587 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong588: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong588 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong588 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong588 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong588` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong588: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong588 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong588: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong588 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong588`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong588() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong588 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong589: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong589 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong589 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong589 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong589` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong589: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong589 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong589: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong589 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong589`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong589() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong589 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong590: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong590 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong590 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong590 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong590` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong590: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong590 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong590: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong590 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong590`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong590() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong590 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong591: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong591 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong591 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong591 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong591` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong591: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong591 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong591: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong591 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong591`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong591() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong591 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong592: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong592 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong592 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong592 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong592` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong592: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong592 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong592: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong592 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong592`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong592() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong592 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong593: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong593 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong593 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong593 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong593` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong593: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong593 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong593: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong593 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong593`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong593() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong593 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong594: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong594 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong594 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong594 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong594` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong594: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong594 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong594: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong594 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong594`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong594() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong594 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong595: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong595 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong595 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong595 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong595` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong595: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong595 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong595: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong595 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong595`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong595() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong595 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong596: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong596 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong596 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong596 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong596` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong596: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong596 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong596: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong596 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong596`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong596() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong596 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong597: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong597 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong597 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong597 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong597` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong597: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong597 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong597: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong597 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong597`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong597() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong597 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong598: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong598 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong598 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong598 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong598` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong598: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong598 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong598: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong598 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong598`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong598() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong598 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong599: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong599 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong599 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong599 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong599` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong599: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong599 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong599: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong599 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong599`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong599() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong599 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong600: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong600 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong600 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong600 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong600` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong600: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong600 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong600: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong600 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong600`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong600() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong600 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong601: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong601 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong601 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong601 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong601` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong601: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong601 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong601: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong601 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong601`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong601() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong601 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong602: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong602 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong602 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong602 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong602` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong602: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong602 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong602: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong602 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong602`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong602() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong602 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong603: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong603 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong603 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong603 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong603` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong603: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong603 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong603: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong603 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong603`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong603() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong603 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong604: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong604 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong604 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong604 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong604` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong604: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong604 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong604: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong604 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong604`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong604() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong604 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong605: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong605 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong605 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong605 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong605` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong605: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong605 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong605: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong605 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong605`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong605() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong605 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong606: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong606 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong606 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong606 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong606` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong606: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong606 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong606: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong606 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong606`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong606() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong606 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong607: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong607 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong607 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong607 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong607` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong607: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong607 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong607: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong607 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong607`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong607() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong607 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong608: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong608 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong608 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong608 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong608` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong608: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong608 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong608: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong608 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong608`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong608() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong608 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong609: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong609 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong609 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong609 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong609` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong609: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong609 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong609: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong609 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong609`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong609() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong609 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong610: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong610 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong610 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong610 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong610` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong610: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong610 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong610: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong610 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong610`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong610() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong610 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong611: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong611 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong611 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong611 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong611` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong611: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong611 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong611: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong611 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong611`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong611() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong611 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong612: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong612 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong612 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong612 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong612` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong612: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong612 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong612: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong612 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong612`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong612() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong612 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong613: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong613 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong613 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong613 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong613` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong613: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong613 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong613: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong613 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong613`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong613() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong613 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong614: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong614 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong614 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong614 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong614` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong614: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong614 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong614: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong614 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong614`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong614() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong614 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong615: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong615 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong615 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong615 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong615` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong615: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong615 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong615: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong615 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong615`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong615() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong615 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong616: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong616 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong616 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong616 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong616` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong616: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong616 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong616: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong616 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong616`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong616() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong616 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong617: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong617 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong617 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong617 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong617` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong617: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong617 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong617: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong617 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong617`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong617() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong617 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong618: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong618 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong618 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong618 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong618` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong618: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong618 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong618: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong618 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong618`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong618() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong618 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong619: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong619 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong619 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong619 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong619` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong619: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong619 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong619: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong619 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong619`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong619() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong619 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong620: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong620 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong620 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong620 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong620` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong620: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong620 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong620: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong620 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong620`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong620() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong620 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong621: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong621 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong621 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong621 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong621` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong621: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong621 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong621: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong621 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong621`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong621() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong621 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong622: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong622 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong622 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong622 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong622` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong622: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong622 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong622: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong622 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong622`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong622() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong622 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong623: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong623 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong623 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong623 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong623` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong623: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong623 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong623: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong623 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong623`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong623() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong623 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong624: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong624 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong624 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong624 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong624` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong624: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong624 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong624: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong624 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong624`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong624() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong624 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong625: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong625 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong625 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong625 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong625` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong625: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong625 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong625: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong625 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong625`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong625() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong625 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong626: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong626 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong626 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong626 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong626` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong626: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong626 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong626: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong626 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong626`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong626() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong626 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong627: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong627 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong627 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong627 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong627` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong627: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong627 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong627: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong627 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong627`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong627() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong627 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong628: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong628 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong628 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong628 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong628` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong628: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong628 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong628: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong628 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong628`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong628() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong628 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong629: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong629 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong629 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong629 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong629` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong629: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong629 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong629: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong629 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong629`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong629() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong629 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong630: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong630 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong630 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong630 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong630` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong630: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong630 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong630: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong630 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong630`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong630() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong630 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong631: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong631 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong631 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong631 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong631` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong631: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong631 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong631: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong631 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong631`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong631() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong631 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong632: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong632 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong632 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong632 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong632` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong632: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong632 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong632: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong632 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong632`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong632() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong632 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong633: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong633 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong633 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong633 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong633` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong633: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong633 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong633: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong633 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong633`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong633() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong633 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong634: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong634 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong634 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong634 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong634` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong634: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong634 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong634: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong634 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong634`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong634() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong634 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong635: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong635 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong635 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong635 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong635` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong635: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong635 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong635: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong635 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong635`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong635() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong635 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong636: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong636 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong636 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong636 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong636` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong636: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong636 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong636: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong636 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong636`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong636() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong636 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong637: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong637 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong637 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong637 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong637` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong637: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong637 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong637: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong637 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong637`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong637() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong637 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong638: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong638 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong638 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong638 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong638` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong638: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong638 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong638: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong638 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong638`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong638() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong638 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong639: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong639 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong639 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong639 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong639` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong639: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong639 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong639: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong639 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong639`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong639() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong639 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong640: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong640 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong640 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong640 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong640` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong640: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong640 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong640: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong640 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong640`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong640() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong640 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong641: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong641 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong641 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong641 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong641` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong641: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong641 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong641: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong641 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong641`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong641() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong641 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong642: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong642 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong642 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong642 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong642` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong642: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong642 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong642: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong642 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong642`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong642() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong642 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong643: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong643 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong643 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong643 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong643` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong643: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong643 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong643: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong643 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong643`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong643() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong643 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong644: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong644 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong644 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong644 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong644` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong644: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong644 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong644: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong644 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong644`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong644() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong644 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong645: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong645 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong645 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong645 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong645` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong645: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong645 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong645: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong645 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong645`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong645() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong645 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong646: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong646 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong646 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong646 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong646` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong646: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong646 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong646: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong646 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong646`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong646() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong646 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong647: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong647 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong647 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong647 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong647` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong647: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong647 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong647: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong647 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong647`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong647() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong647 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong648: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong648 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong648 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong648 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong648` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong648: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong648 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong648: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong648 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong648`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong648() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong648 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong649: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong649 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong649 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong649 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong649` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong649: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong649 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong649: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong649 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong649`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong649() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong649 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong650: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong650 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong650 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong650 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong650` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong650: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong650 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong650: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong650 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong650`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong650() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong650 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong651: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong651 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong651 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong651 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong651` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong651: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong651 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong651: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong651 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong651`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong651() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong651 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong652: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong652 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong652 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong652 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong652` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong652: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong652 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong652: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong652 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong652`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong652() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong652 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong653: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong653 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong653 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong653 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong653` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong653: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong653 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong653: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong653 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong653`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong653() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong653 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong654: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong654 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong654 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong654 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong654` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong654: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong654 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong654: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong654 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong654`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong654() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong654 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong655: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong655 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong655 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong655 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong655` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong655: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong655 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong655: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong655 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong655`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong655() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong655 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong656: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong656 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong656 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong656 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong656` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong656: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong656 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong656: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong656 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong656`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong656() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong656 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong657: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong657 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong657 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong657 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong657` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong657: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong657 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong657: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong657 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong657`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong657() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong657 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong658: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong658 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong658 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong658 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong658` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong658: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong658 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong658: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong658 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong658`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong658() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong658 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong659: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong659 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong659 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong659 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong659` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong659: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong659 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong659: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong659 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong659`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong659() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong659 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong660: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong660 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong660 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong660 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong660` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong660: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong660 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong660: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong660 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong660`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong660() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong660 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong661: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong661 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong661 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong661 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong661` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong661: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong661 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong661: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong661 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong661`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong661() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong661 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong662: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong662 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong662 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong662 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong662` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong662: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong662 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong662: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong662 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong662`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong662() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong662 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong663: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong663 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong663 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong663 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong663` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong663: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong663 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong663: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong663 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong663`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong663() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong663 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong664: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong664 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong664 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong664 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong664` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong664: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong664 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong664: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong664 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong664`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong664() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong664 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong665: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong665 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong665 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong665 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong665` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong665: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong665 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong665: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong665 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong665`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong665() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong665 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong666: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong666 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong666 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong666 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong666` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong666: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong666 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong666: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong666 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong666`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong666() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong666 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong667: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong667 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong667 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong667 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong667` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong667: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong667 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong667: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong667 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong667`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong667() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong667 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong668: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong668 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong668 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong668 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong668` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong668: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong668 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong668: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong668 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong668`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong668() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong668 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong669: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong669 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong669 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong669 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong669` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong669: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong669 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong669: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong669 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong669`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong669() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong669 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong670: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong670 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong670 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong670 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong670` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong670: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong670 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong670: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong670 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong670`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong670() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong670 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong671: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong671 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong671 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong671 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong671` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong671: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong671 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong671: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong671 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong671`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong671() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong671 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong672: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong672 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong672 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong672 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong672` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong672: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong672 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong672: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong672 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong672`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong672() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong672 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong673: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong673 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong673 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong673 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong673` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong673: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong673 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong673: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong673 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong673`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong673() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong673 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong674: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong674 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong674 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong674 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong674` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong674: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong674 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong674: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong674 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong674`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong674() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong674 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong675: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong675 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong675 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong675 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong675` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong675: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong675 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong675: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong675 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong675`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong675() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong675 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong676: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong676 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong676 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong676 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong676` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong676: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong676 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong676: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong676 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong676`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong676() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong676 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong677: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong677 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong677 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong677 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong677` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong677: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong677 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong677: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong677 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong677`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong677() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong677 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong678: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong678 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong678 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong678 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong678` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong678: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong678 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong678: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong678 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong678`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong678() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong678 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong679: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong679 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong679 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong679 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong679` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong679: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong679 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong679: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong679 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong679`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong679() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong679 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong680: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong680 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong680 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong680 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong680` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong680: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong680 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong680: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong680 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong680`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong680() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong680 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong681: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong681 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong681 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong681 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong681` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong681: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong681 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong681: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong681 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong681`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong681() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong681 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong682: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong682 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong682 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong682 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong682` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong682: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong682 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong682: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong682 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong682`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong682() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong682 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong683: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong683 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong683 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong683 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong683` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong683: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong683 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong683: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong683 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong683`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong683() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong683 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong684: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong684 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong684 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong684 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong684` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong684: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong684 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong684: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong684 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong684`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong684() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong684 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong685: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong685 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong685 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong685 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong685` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong685: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong685 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong685: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong685 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong685`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong685() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong685 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong686: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong686 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong686 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong686 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong686` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong686: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong686 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong686: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong686 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong686`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong686() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong686 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong687: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong687 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong687 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong687 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong687` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong687: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong687 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong687: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong687 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong687`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong687() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong687 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong688: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong688 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong688 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong688 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong688` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong688: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong688 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong688: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong688 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong688`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong688() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong688 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong689: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong689 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong689 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong689 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong689` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong689: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong689 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong689: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong689 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong689`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong689() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong689 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong690: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong690 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong690 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong690 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong690` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong690: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong690 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong690: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong690 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong690`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong690() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong690 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong691: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong691 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong691 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong691 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong691` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong691: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong691 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong691: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong691 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong691`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong691() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong691 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong692: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong692 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong692 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong692 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong692` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong692: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong692 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong692: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong692 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong692`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong692() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong692 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong693: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong693 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong693 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong693 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong693` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong693: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong693 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong693: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong693 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong693`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong693() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong693 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong694: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong694 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong694 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong694 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong694` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong694: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong694 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong694: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong694 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong694`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong694() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong694 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong695: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong695 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong695 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong695 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong695` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong695: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong695 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong695: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong695 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong695`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong695() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong695 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong696: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong696 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong696 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong696 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong696` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong696: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong696 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong696: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong696 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong696`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong696() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong696 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong697: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong697 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong697 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong697 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong697` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong697: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong697 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong697: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong697 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong697`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong697() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong697 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong698: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong698 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong698 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong698 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong698` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong698: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong698 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong698: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong698 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong698`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong698() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong698 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong699: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong699 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong699 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong699 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong699` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong699: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong699 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong699: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong699 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong699`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong699() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong699 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong700: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong700 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong700 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong700 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong700` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong700: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong700 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong700: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong700 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong700`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong700() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong700 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong701: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong701 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong701 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong701 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong701` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong701: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong701 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong701: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong701 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong701`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong701() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong701 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong702: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong702 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong702 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong702 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong702` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong702: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong702 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong702: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong702 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong702`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong702() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong702 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong703: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong703 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong703 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong703 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong703` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong703: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong703 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong703: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong703 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong703`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong703() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong703 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong704: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong704 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong704 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong704 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong704` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong704: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong704 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong704: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong704 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong704`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong704() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong704 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong705: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong705 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong705 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong705 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong705` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong705: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong705 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong705: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong705 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong705`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong705() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong705 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong706: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong706 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong706 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong706 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong706` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong706: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong706 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong706: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong706 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong706`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong706() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong706 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong707: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong707 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong707 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong707 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong707` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong707: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong707 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong707: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong707 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong707`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong707() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong707 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong708: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong708 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong708 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong708 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong708` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong708: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong708 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong708: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong708 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong708`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong708() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong708 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong709: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong709 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong709 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong709 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong709` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong709: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong709 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong709: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong709 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong709`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong709() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong709 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong710: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong710 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong710 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong710 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong710` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong710: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong710 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong710: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong710 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong710`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong710() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong710 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong711: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong711 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong711 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong711 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong711` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong711: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong711 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong711: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong711 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong711`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong711() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong711 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong712: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong712 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong712 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong712 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong712` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong712: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong712 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong712: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong712 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong712`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong712() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong712 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong713: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong713 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong713 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong713 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong713` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong713: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong713 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong713: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong713 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong713`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong713() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong713 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong714: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong714 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong714 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong714 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong714` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong714: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong714 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong714: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong714 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong714`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong714() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong714 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong715: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong715 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong715 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong715 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong715` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong715: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong715 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong715: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong715 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong715`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong715() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong715 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong716: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong716 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong716 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong716 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong716` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong716: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong716 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong716: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong716 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong716`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong716() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong716 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong717: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong717 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong717 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong717 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong717` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong717: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong717 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong717: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong717 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong717`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong717() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong717 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong718: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong718 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong718 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong718 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong718` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong718: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong718 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong718: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong718 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong718`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong718() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong718 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong719: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong719 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong719 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong719 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong719` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong719: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong719 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong719: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong719 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong719`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong719() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong719 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong720: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong720 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong720 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong720 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong720` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong720: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong720 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong720: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong720 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong720`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong720() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong720 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong721: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong721 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong721 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong721 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong721` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong721: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong721 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong721: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong721 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong721`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong721() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong721 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong722: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong722 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong722 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong722 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong722` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong722: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong722 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong722: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong722 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong722`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong722() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong722 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong723: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong723 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong723 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong723 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong723` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong723: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong723 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong723: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong723 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong723`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong723() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong723 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong724: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong724 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong724 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong724 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong724` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong724: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong724 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong724: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong724 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong724`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong724() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong724 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong725: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong725 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong725 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong725 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong725` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong725: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong725 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong725: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong725 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong725`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong725() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong725 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong726: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong726 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong726 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong726 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong726` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong726: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong726 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong726: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong726 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong726`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong726() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong726 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong727: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong727 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong727 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong727 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong727` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong727: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong727 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong727: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong727 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong727`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong727() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong727 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong728: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong728 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong728 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong728 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong728` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong728: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong728 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong728: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong728 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong728`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong728() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong728 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong729: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong729 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong729 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong729 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong729` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong729: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong729 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong729: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong729 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong729`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong729() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong729 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong730: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong730 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong730 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong730 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong730` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong730: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong730 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong730: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong730 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong730`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong730() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong730 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong731: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong731 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong731 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong731 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong731` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong731: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong731 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong731: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong731 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong731`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong731() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong731 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong732: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong732 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong732 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong732 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong732` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong732: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong732 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong732: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong732 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong732`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong732() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong732 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong733: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong733 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong733 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong733 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong733` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong733: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong733 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong733: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong733 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong733`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong733() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong733 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong734: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong734 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong734 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong734 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong734` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong734: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong734 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong734: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong734 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong734`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong734() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong734 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong735: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong735 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong735 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong735 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong735` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong735: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong735 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong735: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong735 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong735`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong735() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong735 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong736: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong736 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong736 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong736 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong736` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong736: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong736 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong736: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong736 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong736`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong736() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong736 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong737: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong737 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong737 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong737 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong737` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong737: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong737 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong737: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong737 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong737`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong737() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong737 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong738: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong738 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong738 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong738 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong738` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong738: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong738 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong738: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong738 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong738`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong738() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong738 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong739: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong739 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong739 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong739 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong739` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong739: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong739 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong739: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong739 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong739`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong739() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong739 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong740: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong740 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong740 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong740 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong740` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong740: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong740 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong740: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong740 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong740`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong740() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong740 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong741: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong741 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong741 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong741 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong741` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong741: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong741 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong741: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong741 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong741`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong741() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong741 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong742: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong742 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong742 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong742 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong742` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong742: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong742 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong742: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong742 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong742`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong742() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong742 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong743: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong743 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong743 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong743 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong743` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong743: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong743 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong743: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong743 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong743`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong743() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong743 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong744: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong744 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong744 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong744 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong744` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong744: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong744 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong744: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong744 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong744`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong744() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong744 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong745: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong745 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong745 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong745 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong745` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong745: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong745 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong745: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong745 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong745`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong745() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong745 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong746: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong746 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong746 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong746 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong746` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong746: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong746 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong746: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong746 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong746`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong746() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong746 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong747: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong747 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong747 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong747 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong747` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong747: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong747 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong747: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong747 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong747`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong747() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong747 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong748: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong748 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong748 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong748 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong748` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong748: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong748 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong748: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong748 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong748`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong748() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong748 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong749: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong749 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong749 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong749 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong749` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong749: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong749 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong749: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong749 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong749`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong749() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong749 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong750: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong750 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong750 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong750 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong750` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong750: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong750 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong750: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong750 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong750`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong750() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong750 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong751: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong751 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong751 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong751 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong751` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong751: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong751 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong751: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong751 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong751`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong751() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong751 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong752: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong752 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong752 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong752 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong752` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong752: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong752 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong752: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong752 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong752`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong752() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong752 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong753: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong753 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong753 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong753 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong753` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong753: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong753 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong753: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong753 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong753`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong753() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong753 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong754: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong754 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong754 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong754 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong754` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong754: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong754 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong754: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong754 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong754`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong754() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong754 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong755: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong755 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong755 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong755 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong755` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong755: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong755 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong755: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong755 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong755`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong755() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong755 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong756: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong756 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong756 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong756 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong756` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong756: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong756 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong756: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong756 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong756`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong756() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong756 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong757: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong757 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong757 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong757 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong757` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong757: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong757 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong757: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong757 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong757`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong757() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong757 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong758: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong758 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong758 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong758 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong758` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong758: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong758 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong758: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong758 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong758`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong758() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong758 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong759: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong759 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong759 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong759 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong759` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong759: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong759 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong759: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong759 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong759`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong759() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong759 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong760: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong760 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong760 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong760 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong760` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong760: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong760 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong760: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong760 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong760`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong760() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong760 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong761: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong761 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong761 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong761 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong761` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong761: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong761 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong761: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong761 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong761`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong761() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong761 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong762: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong762 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong762 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong762 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong762` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong762: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong762 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong762: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong762 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong762`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong762() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong762 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong763: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong763 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong763 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong763 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong763` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong763: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong763 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong763: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong763 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong763`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong763() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong763 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong764: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong764 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong764 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong764 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong764` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong764: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong764 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong764: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong764 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong764`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong764() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong764 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong765: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong765 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong765 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong765 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong765` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong765: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong765 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong765: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong765 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong765`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong765() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong765 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong766: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong766 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong766 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong766 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong766` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong766: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong766 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong766: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong766 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong766`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong766() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong766 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong767: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong767 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong767 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong767 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong767` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong767: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong767 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong767: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong767 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong767`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong767() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong767 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong768: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong768 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong768 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong768 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong768` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong768: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong768 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong768: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong768 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong768`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong768() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong768 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong769: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong769 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong769 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong769 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong769` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong769: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong769 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong769: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong769 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong769`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong769() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong769 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong770: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong770 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong770 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong770 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong770` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong770: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong770 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong770: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong770 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong770`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong770() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong770 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong771: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong771 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong771 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong771 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong771` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong771: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong771 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong771: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong771 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong771`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong771() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong771 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong772: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong772 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong772 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong772 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong772` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong772: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong772 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong772: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong772 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong772`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong772() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong772 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong773: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong773 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong773 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong773 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong773` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong773: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong773 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong773: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong773 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong773`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong773() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong773 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong774: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong774 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong774 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong774 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong774` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong774: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong774 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong774: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong774 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong774`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong774() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong774 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong775: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong775 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong775 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong775 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong775` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong775: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong775 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong775: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong775 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong775`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong775() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong775 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong776: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong776 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong776 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong776 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong776` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong776: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong776 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong776: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong776 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong776`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong776() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong776 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong777: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong777 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong777 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong777 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong777` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong777: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong777 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong777: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong777 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong777`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong777() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong777 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong778: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong778 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong778 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong778 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong778` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong778: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong778 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong778: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong778 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong778`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong778() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong778 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong779: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong779 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong779 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong779 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong779` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong779: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong779 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong779: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong779 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong779`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong779() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong779 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong780: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong780 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong780 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong780 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong780` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong780: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong780 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong780: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong780 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong780`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong780() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong780 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong781: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong781 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong781 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong781 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong781` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong781: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong781 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong781: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong781 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong781`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong781() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong781 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong782: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong782 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong782 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong782 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong782` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong782: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong782 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong782: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong782 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong782`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong782() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong782 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong783: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong783 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong783 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong783 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong783` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong783: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong783 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong783: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong783 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong783`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong783() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong783 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong784: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong784 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong784 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong784 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong784` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong784: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong784 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong784: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong784 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong784`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong784() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong784 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong785: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong785 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong785 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong785 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong785` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong785: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong785 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong785: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong785 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong785`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong785() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong785 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong786: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong786 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong786 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong786 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong786` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong786: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong786 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong786: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong786 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong786`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong786() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong786 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong787: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong787 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong787 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong787 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong787` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong787: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong787 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong787: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong787 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong787`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong787() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong787 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong788: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong788 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong788 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong788 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong788` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong788: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong788 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong788: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong788 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong788`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong788() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong788 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong789: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong789 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong789 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong789 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong789` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong789: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong789 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong789: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong789 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong789`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong789() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong789 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong790: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong790 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong790 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong790 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong790` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong790: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong790 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong790: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong790 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong790`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong790() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong790 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong791: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong791 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong791 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong791 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong791` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong791: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong791 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong791: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong791 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong791`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong791() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong791 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong792: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong792 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong792 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong792 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong792` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong792: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong792 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong792: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong792 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong792`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong792() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong792 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong793: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong793 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong793 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong793 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong793` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong793: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong793 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong793: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong793 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong793`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong793() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong793 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong794: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong794 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong794 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong794 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong794` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong794: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong794 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong794: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong794 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong794`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong794() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong794 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong795: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong795 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong795 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong795 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong795` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong795: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong795 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong795: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong795 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong795`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong795() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong795 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong796: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong796 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong796 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong796 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong796` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong796: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong796 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong796: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong796 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong796`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong796() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong796 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong797: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong797 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong797 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong797 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong797` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong797: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong797 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong797: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong797 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong797`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong797() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong797 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong798: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong798 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong798 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong798 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong798` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong798: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong798 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong798: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong798 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong798`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong798() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong798 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong799: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong799 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong799 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong799 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong799` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong799: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong799 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong799: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong799 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong799`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong799() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong799 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong800: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong800 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong800 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong800 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong800` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong800: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong800 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong800: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong800 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong800`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong800() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong800 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong801: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong801 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong801 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong801 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong801` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong801: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong801 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong801: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong801 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong801`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong801() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong801 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong802: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong802 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong802 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong802 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong802` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong802: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong802 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong802: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong802 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong802`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong802() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong802 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong803: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong803 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong803 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong803 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong803` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong803: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong803 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong803: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong803 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong803`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong803() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong803 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong804: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong804 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong804 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong804 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong804` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong804: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong804 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong804: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong804 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong804`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong804() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong804 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong805: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong805 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong805 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong805 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong805` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong805: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong805 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong805: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong805 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong805`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong805() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong805 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong806: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong806 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong806 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong806 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong806` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong806: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong806 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong806: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong806 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong806`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong806() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong806 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong807: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong807 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong807 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong807 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong807` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong807: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong807 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong807: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong807 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong807`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong807() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong807 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong808: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong808 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong808 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong808 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong808` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong808: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong808 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong808: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong808 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong808`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong808() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong808 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong809: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong809 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong809 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong809 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong809` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong809: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong809 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong809: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong809 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong809`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong809() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong809 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong810: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong810 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong810 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong810 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong810` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong810: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong810 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong810: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong810 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong810`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong810() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong810 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong811: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong811 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong811 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong811 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong811` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong811: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong811 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong811: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong811 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong811`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong811() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong811 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong812: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong812 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong812 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong812 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong812` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong812: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong812 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong812: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong812 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong812`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong812() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong812 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong813: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong813 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong813 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong813 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong813` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong813: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong813 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong813: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong813 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong813`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong813() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong813 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong814: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong814 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong814 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong814 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong814` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong814: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong814 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong814: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong814 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong814`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong814() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong814 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong815: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong815 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong815 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong815 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong815` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong815: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong815 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong815: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong815 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong815`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong815() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong815 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong816: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong816 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong816 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong816 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong816` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong816: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong816 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong816: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong816 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong816`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong816() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong816 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong817: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong817 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong817 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong817 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong817` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong817: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong817 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong817: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong817 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong817`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong817() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong817 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong818: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong818 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong818 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong818 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong818` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong818: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong818 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong818: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong818 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong818`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong818() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong818 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong819: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong819 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong819 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong819 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong819` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong819: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong819 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong819: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong819 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong819`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong819() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong819 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong820: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong820 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong820 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong820 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong820` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong820: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong820 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong820: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong820 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong820`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong820() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong820 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong821: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong821 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong821 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong821 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong821` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong821: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong821 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong821: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong821 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong821`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong821() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong821 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong822: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong822 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong822 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong822 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong822` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong822: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong822 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong822: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong822 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong822`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong822() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong822 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong823: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong823 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong823 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong823 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong823` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong823: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong823 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong823: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong823 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong823`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong823() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong823 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong824: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong824 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong824 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong824 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong824` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong824: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong824 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong824: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong824 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong824`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong824() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong824 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong825: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong825 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong825 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong825 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong825` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong825: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong825 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong825: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong825 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong825`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong825() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong825 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong826: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong826 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong826 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong826 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong826` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong826: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong826 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong826: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong826 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong826`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong826() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong826 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong827: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong827 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong827 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong827 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong827` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong827: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong827 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong827: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong827 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong827`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong827() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong827 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong828: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong828 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong828 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong828 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong828` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong828: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong828 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong828: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong828 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong828`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong828() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong828 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong829: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong829 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong829 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong829 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong829` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong829: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong829 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong829: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong829 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong829`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong829() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong829 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong830: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong830 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong830 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong830 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong830` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong830: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong830 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong830: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong830 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong830`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong830() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong830 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong831: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong831 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong831 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong831 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong831` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong831: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong831 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong831: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong831 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong831`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong831() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong831 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong832: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong832 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong832 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong832 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong832` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong832: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong832 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong832: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong832 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong832`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong832() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong832 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong833: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong833 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong833 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong833 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong833` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong833: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong833 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong833: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong833 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong833`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong833() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong833 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong834: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong834 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong834 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong834 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong834` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong834: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong834 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong834: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong834 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong834`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong834() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong834 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong835: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong835 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong835 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong835 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong835` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong835: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong835 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong835: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong835 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong835`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong835() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong835 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong836: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong836 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong836 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong836 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong836` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong836: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong836 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong836: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong836 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong836`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong836() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong836 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong837: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong837 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong837 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong837 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong837` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong837: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong837 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong837: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong837 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong837`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong837() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong837 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong838: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong838 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong838 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong838 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong838` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong838: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong838 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong838: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong838 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong838`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong838() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong838 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong839: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong839 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong839 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong839 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong839` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong839: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong839 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong839: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong839 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong839`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong839() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong839 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong840: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong840 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong840 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong840 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong840` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong840: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong840 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong840: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong840 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong840`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong840() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong840 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong841: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong841 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong841 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong841 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong841` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong841: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong841 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong841: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong841 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong841`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong841() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong841 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong842: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong842 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong842 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong842 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong842` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong842: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong842 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong842: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong842 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong842`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong842() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong842 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong843: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong843 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong843 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong843 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong843` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong843: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong843 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong843: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong843 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong843`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong843() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong843 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong844: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong844 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong844 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong844 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong844` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong844: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong844 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong844: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong844 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong844`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong844() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong844 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong845: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong845 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong845 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong845 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong845` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong845: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong845 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong845: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong845 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong845`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong845() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong845 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong846: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong846 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong846 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong846 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong846` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong846: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong846 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong846: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong846 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong846`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong846() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong846 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong847: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong847 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong847 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong847 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong847` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong847: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong847 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong847: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong847 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong847`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong847() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong847 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong848: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong848 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong848 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong848 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong848` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong848: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong848 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong848: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong848 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong848`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong848() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong848 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong849: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong849 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong849 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong849 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong849` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong849: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong849 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong849: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong849 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong849`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong849() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong849 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong850: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong850 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong850 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong850 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong850` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong850: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong850 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong850: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong850 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong850`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong850() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong850 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong851: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong851 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong851 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong851 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong851` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong851: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong851 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong851: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong851 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong851`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong851() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong851 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong852: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong852 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong852 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong852 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong852` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong852: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong852 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong852: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong852 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong852`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong852() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong852 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong853: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong853 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong853 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong853 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong853` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong853: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong853 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong853: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong853 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong853`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong853() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong853 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong854: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong854 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong854 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong854 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong854` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong854: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong854 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong854: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong854 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong854`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong854() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong854 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong855: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong855 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong855 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong855 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong855` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong855: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong855 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong855: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong855 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong855`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong855() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong855 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong856: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong856 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong856 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong856 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong856` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong856: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong856 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong856: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong856 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong856`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong856() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong856 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong857: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong857 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong857 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong857 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong857` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong857: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong857 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong857: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong857 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong857`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong857() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong857 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong858: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong858 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong858 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong858 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong858` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong858: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong858 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong858: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong858 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong858`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong858() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong858 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong859: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong859 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong859 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong859 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong859` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong859: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong859 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong859: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong859 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong859`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong859() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong859 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong860: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong860 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong860 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong860 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong860` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong860: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong860 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong860: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong860 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong860`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong860() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong860 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong861: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong861 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong861 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong861 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong861` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong861: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong861 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong861: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong861 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong861`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong861() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong861 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong862: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong862 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong862 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong862 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong862` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong862: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong862 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong862: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong862 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong862`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong862() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong862 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong863: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong863 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong863 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong863 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong863` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong863: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong863 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong863: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong863 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong863`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong863() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong863 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong864: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong864 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong864 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong864 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong864` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong864: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong864 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong864: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong864 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong864`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong864() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong864 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong865: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong865 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong865 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong865 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong865` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong865: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong865 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong865: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong865 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong865`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong865() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong865 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong866: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong866 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong866 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong866 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong866` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong866: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong866 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong866: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong866 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong866`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong866() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong866 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong867: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong867 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong867 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong867 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong867` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong867: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong867 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong867: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong867 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong867`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong867() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong867 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong868: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong868 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong868 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong868 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong868` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong868: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong868 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong868: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong868 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong868`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong868() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong868 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong869: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong869 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong869 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong869 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong869` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong869: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong869 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong869: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong869 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong869`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong869() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong869 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong870: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong870 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong870 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong870 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong870` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong870: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong870 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong870: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong870 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong870`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong870() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong870 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong871: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong871 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong871 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong871 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong871` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong871: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong871 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong871: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong871 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong871`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong871() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong871 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong872: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong872 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong872 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong872 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong872` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong872: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong872 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong872: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong872 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong872`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong872() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong872 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong873: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong873 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong873 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong873 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong873` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong873: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong873 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong873: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong873 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong873`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong873() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong873 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong874: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong874 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong874 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong874 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong874` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong874: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong874 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong874: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong874 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong874`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong874() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong874 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong875: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong875 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong875 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong875 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong875` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong875: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong875 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong875: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong875 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong875`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong875() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong875 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong876: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong876 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong876 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong876 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong876` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong876: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong876 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong876: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong876 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong876`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong876() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong876 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong877: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong877 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong877 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong877 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong877` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong877: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong877 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong877: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong877 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong877`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong877() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong877 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong878: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong878 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong878 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong878 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong878` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong878: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong878 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong878: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong878 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong878`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong878() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong878 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong879: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong879 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong879 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong879 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong879` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong879: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong879 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong879: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong879 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong879`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong879() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong879 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong880: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong880 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong880 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong880 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong880` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong880: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong880 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong880: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong880 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong880`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong880() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong880 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong881: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong881 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong881 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong881 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong881` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong881: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong881 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong881: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong881 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong881`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong881() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong881 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong882: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong882 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong882 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong882 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong882` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong882: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong882 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong882: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong882 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong882`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong882() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong882 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong883: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong883 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong883 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong883 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong883` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong883: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong883 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong883: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong883 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong883`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong883() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong883 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong884: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong884 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong884 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong884 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong884` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong884: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong884 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong884: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong884 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong884`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong884() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong884 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong885: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong885 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong885 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong885 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong885` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong885: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong885 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong885: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong885 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong885`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong885() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong885 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong886: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong886 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong886 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong886 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong886` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong886: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong886 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong886: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong886 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong886`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong886() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong886 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong887: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong887 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong887 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong887 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong887` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong887: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong887 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong887: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong887 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong887`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong887() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong887 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong888: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong888 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong888 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong888 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong888` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong888: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong888 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong888: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong888 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong888`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong888() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong888 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong889: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong889 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong889 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong889 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong889` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong889: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong889 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong889: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong889 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong889`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong889() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong889 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong890: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong890 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong890 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong890 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong890` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong890: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong890 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong890: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong890 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong890`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong890() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong890 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong891: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong891 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong891 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong891 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong891` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong891: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong891 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong891: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong891 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong891`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong891() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong891 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong892: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong892 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong892 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong892 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong892` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong892: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong892 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong892: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong892 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong892`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong892() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong892 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong893: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong893 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong893 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong893 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong893` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong893: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong893 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong893: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong893 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong893`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong893() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong893 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong894: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong894 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong894 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong894 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong894` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong894: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong894 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong894: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong894 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong894`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong894() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong894 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong895: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong895 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong895 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong895 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong895` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong895: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong895 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong895: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong895 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong895`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong895() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong895 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong896: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong896 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong896 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong896 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong896` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong896: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong896 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong896: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong896 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong896`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong896() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong896 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong897: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong897 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong897 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong897 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong897` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong897: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong897 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong897: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong897 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong897`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong897() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong897 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong898: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong898 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong898 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong898 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong898` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong898: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong898 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong898: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong898 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong898`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong898() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong898 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong899: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong899 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong899 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong899 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong899` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong899: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong899 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong899: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong899 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong899`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong899() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong899 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong900: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong900 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong900 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong900 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong900` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong900: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong900 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong900: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong900 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong900`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong900() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong900 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong901: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong901 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong901 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong901 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong901` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong901: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong901 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong901: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong901 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong901`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong901() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong901 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong902: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong902 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong902 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong902 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong902` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong902: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong902 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong902: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong902 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong902`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong902() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong902 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong903: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong903 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong903 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong903 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong903` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong903: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong903 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong903: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong903 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong903`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong903() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong903 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong904: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong904 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong904 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong904 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong904` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong904: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong904 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong904: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong904 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong904`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong904() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong904 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong905: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong905 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong905 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong905 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong905` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong905: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong905 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong905: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong905 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong905`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong905() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong905 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong906: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong906 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong906 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong906 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong906` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong906: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong906 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong906: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong906 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong906`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong906() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong906 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong907: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong907 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong907 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong907 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong907` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong907: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong907 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong907: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong907 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong907`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong907() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong907 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong908: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong908 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong908 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong908 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong908` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong908: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong908 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong908: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong908 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong908`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong908() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong908 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong909: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong909 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong909 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong909 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong909` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong909: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong909 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong909: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong909 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong909`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong909() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong909 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong910: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong910 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong910 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong910 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong910` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong910: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong910 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong910: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong910 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong910`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong910() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong910 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong911: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong911 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong911 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong911 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong911` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong911: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong911 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong911: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong911 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong911`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong911() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong911 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong912: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong912 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong912 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong912 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong912` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong912: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong912 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong912: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong912 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong912`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong912() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong912 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong913: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong913 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong913 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong913 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong913` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong913: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong913 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong913: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong913 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong913`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong913() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong913 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong914: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong914 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong914 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong914 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong914` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong914: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong914 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong914: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong914 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong914`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong914() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong914 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong915: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong915 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong915 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong915 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong915` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong915: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong915 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong915: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong915 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong915`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong915() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong915 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong916: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong916 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong916 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong916 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong916` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong916: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong916 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong916: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong916 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong916`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong916() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong916 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong917: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong917 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong917 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong917 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong917` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong917: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong917 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong917: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong917 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong917`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong917() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong917 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong918: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong918 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong918 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong918 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong918` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong918: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong918 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong918: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong918 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong918`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong918() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong918 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong919: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong919 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong919 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong919 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong919` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong919: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong919 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong919: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong919 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong919`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong919() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong919 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong920: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong920 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong920 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong920 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong920` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong920: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong920 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong920: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong920 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong920`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong920() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong920 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong921: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong921 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong921 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong921 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong921` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong921: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong921 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong921: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong921 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong921`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong921() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong921 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong922: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong922 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong922 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong922 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong922` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong922: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong922 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong922: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong922 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong922`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong922() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong922 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong923: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong923 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong923 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong923 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong923` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong923: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong923 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong923: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong923 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong923`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong923() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong923 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong924: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong924 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong924 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong924 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong924` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong924: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong924 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong924: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong924 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong924`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong924() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong924 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong925: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong925 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong925 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong925 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong925` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong925: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong925 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong925: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong925 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong925`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong925() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong925 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong926: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong926 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong926 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong926 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong926` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong926: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong926 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong926: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong926 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong926`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong926() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong926 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong927: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong927 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong927 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong927 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong927` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong927: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong927 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong927: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong927 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong927`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong927() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong927 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong928: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong928 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong928 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong928 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong928` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong928: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong928 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong928: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong928 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong928`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong928() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong928 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong929: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong929 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong929 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong929 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong929` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong929: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong929 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong929: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong929 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong929`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong929() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong929 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong930: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong930 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong930 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong930 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong930` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong930: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong930 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong930: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong930 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong930`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong930() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong930 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong931: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong931 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong931 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong931 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong931` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong931: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong931 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong931: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong931 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong931`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong931() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong931 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong932: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong932 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong932 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong932 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong932` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong932: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong932 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong932: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong932 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong932`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong932() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong932 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong933: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong933 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong933 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong933 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong933` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong933: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong933 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong933: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong933 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong933`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong933() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong933 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong934: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong934 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong934 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong934 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong934` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong934: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong934 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong934: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong934 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong934`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong934() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong934 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong935: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong935 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong935 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong935 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong935` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong935: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong935 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong935: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong935 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong935`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong935() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong935 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong936: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong936 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong936 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong936 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong936` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong936: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong936 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong936: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong936 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong936`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong936() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong936 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong937: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong937 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong937 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong937 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong937` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong937: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong937 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong937: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong937 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong937`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong937() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong937 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong938: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong938 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong938 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong938 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong938` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong938: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong938 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong938: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong938 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong938`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong938() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong938 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong939: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong939 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong939 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong939 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong939` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong939: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong939 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong939: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong939 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong939`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong939() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong939 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong940: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong940 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong940 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong940 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong940` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong940: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong940 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong940: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong940 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong940`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong940() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong940 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong941: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong941 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong941 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong941 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong941` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong941: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong941 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong941: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong941 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong941`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong941() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong941 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong942: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong942 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong942 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong942 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong942` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong942: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong942 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong942: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong942 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong942`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong942() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong942 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong943: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong943 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong943 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong943 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong943` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong943: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong943 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong943: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong943 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong943`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong943() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong943 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong944: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong944 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong944 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong944 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong944` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong944: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong944 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong944: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong944 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong944`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong944() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong944 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong945: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong945 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong945 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong945 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong945` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong945: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong945 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong945: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong945 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong945`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong945() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong945 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong946: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong946 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong946 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong946 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong946` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong946: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong946 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong946: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong946 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong946`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong946() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong946 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong947: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong947 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong947 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong947 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong947` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong947: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong947 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong947: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong947 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong947`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong947() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong947 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong948: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong948 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong948 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong948 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong948` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong948: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong948 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong948: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong948 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong948`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong948() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong948 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong949: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong949 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong949 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong949 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong949` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong949: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong949 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong949: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong949 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong949`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong949() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong949 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong950: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong950 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong950 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong950 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong950` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong950: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong950 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong950: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong950 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong950`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong950() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong950 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong951: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong951 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong951 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong951 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong951` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong951: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong951 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong951: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong951 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong951`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong951() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong951 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong952: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong952 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong952 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong952 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong952` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong952: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong952 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong952: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong952 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong952`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong952() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong952 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong953: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong953 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong953 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong953 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong953` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong953: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong953 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong953: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong953 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong953`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong953() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong953 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong954: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong954 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong954 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong954 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong954` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong954: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong954 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong954: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong954 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong954`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong954() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong954 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong955: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong955 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong955 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong955 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong955` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong955: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong955 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong955: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong955 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong955`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong955() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong955 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong956: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong956 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong956 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong956 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong956` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong956: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong956 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong956: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong956 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong956`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong956() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong956 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong957: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong957 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong957 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong957 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong957` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong957: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong957 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong957: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong957 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong957`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong957() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong957 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong958: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong958 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong958 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong958 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong958` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong958: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong958 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong958: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong958 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong958`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong958() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong958 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong959: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong959 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong959 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong959 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong959` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong959: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong959 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong959: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong959 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong959`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong959() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong959 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong960: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong960 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong960 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong960 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong960` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong960: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong960 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong960: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong960 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong960`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong960() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong960 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong961: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong961 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong961 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong961 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong961` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong961: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong961 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong961: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong961 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong961`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong961() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong961 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong962: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong962 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong962 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong962 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong962` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong962: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong962 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong962: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong962 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong962`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong962() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong962 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong963: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong963 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong963 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong963 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong963` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong963: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong963 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong963: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong963 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong963`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong963() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong963 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong964: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong964 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong964 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong964 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong964` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong964: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong964 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong964: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong964 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong964`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong964() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong964 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong965: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong965 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong965 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong965 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong965` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong965: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong965 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong965: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong965 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong965`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong965() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong965 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong966: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong966 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong966 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong966 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong966` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong966: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong966 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong966: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong966 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong966`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong966() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong966 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong967: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong967 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong967 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong967 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong967` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong967: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong967 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong967: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong967 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong967`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong967() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong967 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong968: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong968 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong968 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong968 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong968` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong968: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong968 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong968: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong968 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong968`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong968() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong968 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong969: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong969 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong969 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong969 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong969` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong969: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong969 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong969: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong969 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong969`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong969() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong969 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong970: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong970 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong970 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong970 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong970` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong970: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong970 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong970: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong970 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong970`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong970() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong970 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong971: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong971 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong971 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong971 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong971` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong971: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong971 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong971: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong971 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong971`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong971() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong971 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong972: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong972 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong972 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong972 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong972` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong972: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong972 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong972: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong972 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong972`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong972() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong972 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong973: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong973 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong973 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong973 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong973` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong973: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong973 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong973: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong973 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong973`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong973() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong973 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong974: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong974 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong974 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong974 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong974` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong974: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong974 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong974: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong974 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong974`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong974() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong974 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong975: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong975 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong975 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong975 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong975` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong975: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong975 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong975: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong975 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong975`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong975() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong975 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong976: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong976 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong976 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong976 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong976` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong976: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong976 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong976: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong976 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong976`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong976() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong976 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong977: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong977 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong977 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong977 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong977` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong977: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong977 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong977: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong977 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong977`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong977() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong977 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong978: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong978 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong978 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong978 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong978` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong978: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong978 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong978: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong978 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong978`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong978() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong978 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong979: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong979 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong979 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong979 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong979` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong979: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong979 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong979: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong979 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong979`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong979() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong979 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong980: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong980 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong980 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong980 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong980` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong980: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong980 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong980: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong980 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong980`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong980() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong980 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong981: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong981 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong981 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong981 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong981` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong981: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong981 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong981: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong981 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong981`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong981() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong981 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong982: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong982 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong982 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong982 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong982` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong982: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong982 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong982: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong982 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong982`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong982() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong982 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong983: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong983 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong983 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong983 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong983` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong983: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong983 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong983: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong983 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong983`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong983() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong983 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong984: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong984 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong984 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong984 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong984` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong984: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong984 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong984: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong984 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong984`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong984() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong984 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong985: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong985 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong985 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong985 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong985` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong985: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong985 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong985: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong985 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong985`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong985() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong985 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong986: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong986 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong986 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong986 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong986` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong986: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong986 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong986: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong986 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong986`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong986() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong986 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong987: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong987 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong987 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong987 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong987` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong987: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong987 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong987: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong987 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong987`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong987() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong987 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong988: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong988 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong988 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong988 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong988` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong988: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong988 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong988: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong988 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong988`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong988() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong988 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong989: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong989 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong989 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong989 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong989` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong989: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong989 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong989: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong989 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong989`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong989() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong989 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong990: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong990 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong990 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong990 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong990` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong990: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong990 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong990: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong990 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong990`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong990() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong990 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong991: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong991 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong991 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong991 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong991` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong991: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong991 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong991: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong991 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong991`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong991() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong991 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong992: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong992 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong992 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong992 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong992` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong992: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong992 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong992: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong992 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong992`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong992() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong992 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong993: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong993 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong993 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong993 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong993` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong993: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong993 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong993: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong993 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong993`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong993() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong993 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong994: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong994 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong994 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong994 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong994` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong994: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong994 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong994: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong994 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong994`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong994() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong994 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong995: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong995 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong995 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong995 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong995` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong995: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong995 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong995: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong995 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong995`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong995() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong995 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong996: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong996 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong996 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong996 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong996` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong996: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong996 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong996: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong996 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong996`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong996() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong996 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong997: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong997 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong997 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong997 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong997` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong997: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong997 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong997: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong997 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong997`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong997() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong997 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong998: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong998 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong998 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong998 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong998` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong998: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong998 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong998: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong998 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong998`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong998() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong998 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong999: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong999 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong999 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong999 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong999` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong999: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong999 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong999: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong999 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong999`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong999() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong999 = nil} var longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1000: String { - get {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1000 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} + get {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1000 ?? "long default value is also loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"} set {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1000 = newValue} } /// Returns true if `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1000` has been explicitly set. - var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1000: Bool {return _storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1000 != nil} + var hasLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1000: Bool {_storage._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1000 != nil} /// Clears the value of `longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1000`. Subsequent reads from it will return its default value. mutating func clearLongFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1000() {_uniqueStorage()._longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1000 = nil} @@ -9070,1018 +9049,13 @@ struct ProtobufUnittest_TestEnormousDescriptor { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_TestEnormousDescriptor: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "proto2_unittest" -extension ProtobufUnittest_TestEnormousDescriptor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestEnormousDescriptor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestEnormousDescriptor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_1"), - 2: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_2"), - 3: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_3"), - 4: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_4"), - 5: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_5"), - 6: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_6"), - 7: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_7"), - 8: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_8"), - 9: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_9"), - 10: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_10"), - 11: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_11"), - 12: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_12"), - 13: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_13"), - 14: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_14"), - 15: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_15"), - 16: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_16"), - 17: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_17"), - 18: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_18"), - 19: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_19"), - 20: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_20"), - 21: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_21"), - 22: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_22"), - 23: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_23"), - 24: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_24"), - 25: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_25"), - 26: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_26"), - 27: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_27"), - 28: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_28"), - 29: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_29"), - 30: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_30"), - 31: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_31"), - 32: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_32"), - 33: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_33"), - 34: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_34"), - 35: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_35"), - 36: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_36"), - 37: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_37"), - 38: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_38"), - 39: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_39"), - 40: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_40"), - 41: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_41"), - 42: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_42"), - 43: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_43"), - 44: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_44"), - 45: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_45"), - 46: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_46"), - 47: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_47"), - 48: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_48"), - 49: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_49"), - 50: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_50"), - 51: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_51"), - 52: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_52"), - 53: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_53"), - 54: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_54"), - 55: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_55"), - 56: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_56"), - 57: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_57"), - 58: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_58"), - 59: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_59"), - 60: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_60"), - 61: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_61"), - 62: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_62"), - 63: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_63"), - 64: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_64"), - 65: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_65"), - 66: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_66"), - 67: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_67"), - 68: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_68"), - 69: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_69"), - 70: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_70"), - 71: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_71"), - 72: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_72"), - 73: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_73"), - 74: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_74"), - 75: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_75"), - 76: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_76"), - 77: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_77"), - 78: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_78"), - 79: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_79"), - 80: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_80"), - 81: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_81"), - 82: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_82"), - 83: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_83"), - 84: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_84"), - 85: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_85"), - 86: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_86"), - 87: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_87"), - 88: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_88"), - 89: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_89"), - 90: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_90"), - 91: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_91"), - 92: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_92"), - 93: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_93"), - 94: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_94"), - 95: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_95"), - 96: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_96"), - 97: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_97"), - 98: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_98"), - 99: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_99"), - 100: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_100"), - 101: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_101"), - 102: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_102"), - 103: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_103"), - 104: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_104"), - 105: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_105"), - 106: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_106"), - 107: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_107"), - 108: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_108"), - 109: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_109"), - 110: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_110"), - 111: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_111"), - 112: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_112"), - 113: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_113"), - 114: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_114"), - 115: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_115"), - 116: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_116"), - 117: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_117"), - 118: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_118"), - 119: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_119"), - 120: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_120"), - 121: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_121"), - 122: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_122"), - 123: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_123"), - 124: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_124"), - 125: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_125"), - 126: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_126"), - 127: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_127"), - 128: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_128"), - 129: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_129"), - 130: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_130"), - 131: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_131"), - 132: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_132"), - 133: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_133"), - 134: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_134"), - 135: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_135"), - 136: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_136"), - 137: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_137"), - 138: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_138"), - 139: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_139"), - 140: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_140"), - 141: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_141"), - 142: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_142"), - 143: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_143"), - 144: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_144"), - 145: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_145"), - 146: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_146"), - 147: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_147"), - 148: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_148"), - 149: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_149"), - 150: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_150"), - 151: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_151"), - 152: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_152"), - 153: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_153"), - 154: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_154"), - 155: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_155"), - 156: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_156"), - 157: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_157"), - 158: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_158"), - 159: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_159"), - 160: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_160"), - 161: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_161"), - 162: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_162"), - 163: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_163"), - 164: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_164"), - 165: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_165"), - 166: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_166"), - 167: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_167"), - 168: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_168"), - 169: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_169"), - 170: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_170"), - 171: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_171"), - 172: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_172"), - 173: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_173"), - 174: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_174"), - 175: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_175"), - 176: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_176"), - 177: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_177"), - 178: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_178"), - 179: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_179"), - 180: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_180"), - 181: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_181"), - 182: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_182"), - 183: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_183"), - 184: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_184"), - 185: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_185"), - 186: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_186"), - 187: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_187"), - 188: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_188"), - 189: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_189"), - 190: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_190"), - 191: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_191"), - 192: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_192"), - 193: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_193"), - 194: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_194"), - 195: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_195"), - 196: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_196"), - 197: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_197"), - 198: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_198"), - 199: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_199"), - 200: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_200"), - 201: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_201"), - 202: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_202"), - 203: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_203"), - 204: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_204"), - 205: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_205"), - 206: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_206"), - 207: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_207"), - 208: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_208"), - 209: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_209"), - 210: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_210"), - 211: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_211"), - 212: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_212"), - 213: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_213"), - 214: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_214"), - 215: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_215"), - 216: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_216"), - 217: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_217"), - 218: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_218"), - 219: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_219"), - 220: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_220"), - 221: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_221"), - 222: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_222"), - 223: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_223"), - 224: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_224"), - 225: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_225"), - 226: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_226"), - 227: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_227"), - 228: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_228"), - 229: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_229"), - 230: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_230"), - 231: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_231"), - 232: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_232"), - 233: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_233"), - 234: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_234"), - 235: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_235"), - 236: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_236"), - 237: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_237"), - 238: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_238"), - 239: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_239"), - 240: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_240"), - 241: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_241"), - 242: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_242"), - 243: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_243"), - 244: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_244"), - 245: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_245"), - 246: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_246"), - 247: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_247"), - 248: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_248"), - 249: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_249"), - 250: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_250"), - 251: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_251"), - 252: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_252"), - 253: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_253"), - 254: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_254"), - 255: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_255"), - 256: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_256"), - 257: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_257"), - 258: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_258"), - 259: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_259"), - 260: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_260"), - 261: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_261"), - 262: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_262"), - 263: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_263"), - 264: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_264"), - 265: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_265"), - 266: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_266"), - 267: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_267"), - 268: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_268"), - 269: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_269"), - 270: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_270"), - 271: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_271"), - 272: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_272"), - 273: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_273"), - 274: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_274"), - 275: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_275"), - 276: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_276"), - 277: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_277"), - 278: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_278"), - 279: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_279"), - 280: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_280"), - 281: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_281"), - 282: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_282"), - 283: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_283"), - 284: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_284"), - 285: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_285"), - 286: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_286"), - 287: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_287"), - 288: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_288"), - 289: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_289"), - 290: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_290"), - 291: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_291"), - 292: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_292"), - 293: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_293"), - 294: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_294"), - 295: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_295"), - 296: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_296"), - 297: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_297"), - 298: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_298"), - 299: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_299"), - 300: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_300"), - 301: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_301"), - 302: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_302"), - 303: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_303"), - 304: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_304"), - 305: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_305"), - 306: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_306"), - 307: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_307"), - 308: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_308"), - 309: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_309"), - 310: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_310"), - 311: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_311"), - 312: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_312"), - 313: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_313"), - 314: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_314"), - 315: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_315"), - 316: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_316"), - 317: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_317"), - 318: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_318"), - 319: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_319"), - 320: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_320"), - 321: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_321"), - 322: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_322"), - 323: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_323"), - 324: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_324"), - 325: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_325"), - 326: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_326"), - 327: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_327"), - 328: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_328"), - 329: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_329"), - 330: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_330"), - 331: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_331"), - 332: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_332"), - 333: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_333"), - 334: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_334"), - 335: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_335"), - 336: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_336"), - 337: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_337"), - 338: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_338"), - 339: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_339"), - 340: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_340"), - 341: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_341"), - 342: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_342"), - 343: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_343"), - 344: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_344"), - 345: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_345"), - 346: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_346"), - 347: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_347"), - 348: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_348"), - 349: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_349"), - 350: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_350"), - 351: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_351"), - 352: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_352"), - 353: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_353"), - 354: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_354"), - 355: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_355"), - 356: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_356"), - 357: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_357"), - 358: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_358"), - 359: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_359"), - 360: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_360"), - 361: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_361"), - 362: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_362"), - 363: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_363"), - 364: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_364"), - 365: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_365"), - 366: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_366"), - 367: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_367"), - 368: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_368"), - 369: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_369"), - 370: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_370"), - 371: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_371"), - 372: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_372"), - 373: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_373"), - 374: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_374"), - 375: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_375"), - 376: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_376"), - 377: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_377"), - 378: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_378"), - 379: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_379"), - 380: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_380"), - 381: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_381"), - 382: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_382"), - 383: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_383"), - 384: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_384"), - 385: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_385"), - 386: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_386"), - 387: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_387"), - 388: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_388"), - 389: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_389"), - 390: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_390"), - 391: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_391"), - 392: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_392"), - 393: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_393"), - 394: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_394"), - 395: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_395"), - 396: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_396"), - 397: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_397"), - 398: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_398"), - 399: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_399"), - 400: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_400"), - 401: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_401"), - 402: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_402"), - 403: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_403"), - 404: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_404"), - 405: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_405"), - 406: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_406"), - 407: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_407"), - 408: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_408"), - 409: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_409"), - 410: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_410"), - 411: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_411"), - 412: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_412"), - 413: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_413"), - 414: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_414"), - 415: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_415"), - 416: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_416"), - 417: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_417"), - 418: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_418"), - 419: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_419"), - 420: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_420"), - 421: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_421"), - 422: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_422"), - 423: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_423"), - 424: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_424"), - 425: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_425"), - 426: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_426"), - 427: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_427"), - 428: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_428"), - 429: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_429"), - 430: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_430"), - 431: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_431"), - 432: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_432"), - 433: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_433"), - 434: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_434"), - 435: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_435"), - 436: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_436"), - 437: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_437"), - 438: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_438"), - 439: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_439"), - 440: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_440"), - 441: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_441"), - 442: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_442"), - 443: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_443"), - 444: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_444"), - 445: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_445"), - 446: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_446"), - 447: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_447"), - 448: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_448"), - 449: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_449"), - 450: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_450"), - 451: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_451"), - 452: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_452"), - 453: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_453"), - 454: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_454"), - 455: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_455"), - 456: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_456"), - 457: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_457"), - 458: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_458"), - 459: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_459"), - 460: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_460"), - 461: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_461"), - 462: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_462"), - 463: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_463"), - 464: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_464"), - 465: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_465"), - 466: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_466"), - 467: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_467"), - 468: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_468"), - 469: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_469"), - 470: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_470"), - 471: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_471"), - 472: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_472"), - 473: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_473"), - 474: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_474"), - 475: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_475"), - 476: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_476"), - 477: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_477"), - 478: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_478"), - 479: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_479"), - 480: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_480"), - 481: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_481"), - 482: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_482"), - 483: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_483"), - 484: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_484"), - 485: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_485"), - 486: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_486"), - 487: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_487"), - 488: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_488"), - 489: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_489"), - 490: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_490"), - 491: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_491"), - 492: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_492"), - 493: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_493"), - 494: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_494"), - 495: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_495"), - 496: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_496"), - 497: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_497"), - 498: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_498"), - 499: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_499"), - 500: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_500"), - 501: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_501"), - 502: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_502"), - 503: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_503"), - 504: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_504"), - 505: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_505"), - 506: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_506"), - 507: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_507"), - 508: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_508"), - 509: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_509"), - 510: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_510"), - 511: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_511"), - 512: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_512"), - 513: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_513"), - 514: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_514"), - 515: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_515"), - 516: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_516"), - 517: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_517"), - 518: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_518"), - 519: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_519"), - 520: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_520"), - 521: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_521"), - 522: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_522"), - 523: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_523"), - 524: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_524"), - 525: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_525"), - 526: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_526"), - 527: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_527"), - 528: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_528"), - 529: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_529"), - 530: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_530"), - 531: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_531"), - 532: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_532"), - 533: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_533"), - 534: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_534"), - 535: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_535"), - 536: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_536"), - 537: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_537"), - 538: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_538"), - 539: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_539"), - 540: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_540"), - 541: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_541"), - 542: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_542"), - 543: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_543"), - 544: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_544"), - 545: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_545"), - 546: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_546"), - 547: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_547"), - 548: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_548"), - 549: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_549"), - 550: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_550"), - 551: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_551"), - 552: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_552"), - 553: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_553"), - 554: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_554"), - 555: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_555"), - 556: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_556"), - 557: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_557"), - 558: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_558"), - 559: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_559"), - 560: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_560"), - 561: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_561"), - 562: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_562"), - 563: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_563"), - 564: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_564"), - 565: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_565"), - 566: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_566"), - 567: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_567"), - 568: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_568"), - 569: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_569"), - 570: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_570"), - 571: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_571"), - 572: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_572"), - 573: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_573"), - 574: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_574"), - 575: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_575"), - 576: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_576"), - 577: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_577"), - 578: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_578"), - 579: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_579"), - 580: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_580"), - 581: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_581"), - 582: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_582"), - 583: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_583"), - 584: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_584"), - 585: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_585"), - 586: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_586"), - 587: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_587"), - 588: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_588"), - 589: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_589"), - 590: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_590"), - 591: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_591"), - 592: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_592"), - 593: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_593"), - 594: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_594"), - 595: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_595"), - 596: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_596"), - 597: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_597"), - 598: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_598"), - 599: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_599"), - 600: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_600"), - 601: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_601"), - 602: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_602"), - 603: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_603"), - 604: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_604"), - 605: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_605"), - 606: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_606"), - 607: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_607"), - 608: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_608"), - 609: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_609"), - 610: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_610"), - 611: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_611"), - 612: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_612"), - 613: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_613"), - 614: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_614"), - 615: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_615"), - 616: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_616"), - 617: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_617"), - 618: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_618"), - 619: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_619"), - 620: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_620"), - 621: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_621"), - 622: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_622"), - 623: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_623"), - 624: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_624"), - 625: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_625"), - 626: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_626"), - 627: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_627"), - 628: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_628"), - 629: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_629"), - 630: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_630"), - 631: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_631"), - 632: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_632"), - 633: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_633"), - 634: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_634"), - 635: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_635"), - 636: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_636"), - 637: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_637"), - 638: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_638"), - 639: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_639"), - 640: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_640"), - 641: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_641"), - 642: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_642"), - 643: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_643"), - 644: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_644"), - 645: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_645"), - 646: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_646"), - 647: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_647"), - 648: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_648"), - 649: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_649"), - 650: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_650"), - 651: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_651"), - 652: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_652"), - 653: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_653"), - 654: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_654"), - 655: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_655"), - 656: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_656"), - 657: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_657"), - 658: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_658"), - 659: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_659"), - 660: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_660"), - 661: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_661"), - 662: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_662"), - 663: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_663"), - 664: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_664"), - 665: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_665"), - 666: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_666"), - 667: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_667"), - 668: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_668"), - 669: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_669"), - 670: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_670"), - 671: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_671"), - 672: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_672"), - 673: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_673"), - 674: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_674"), - 675: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_675"), - 676: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_676"), - 677: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_677"), - 678: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_678"), - 679: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_679"), - 680: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_680"), - 681: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_681"), - 682: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_682"), - 683: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_683"), - 684: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_684"), - 685: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_685"), - 686: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_686"), - 687: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_687"), - 688: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_688"), - 689: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_689"), - 690: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_690"), - 691: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_691"), - 692: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_692"), - 693: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_693"), - 694: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_694"), - 695: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_695"), - 696: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_696"), - 697: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_697"), - 698: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_698"), - 699: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_699"), - 700: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_700"), - 701: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_701"), - 702: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_702"), - 703: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_703"), - 704: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_704"), - 705: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_705"), - 706: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_706"), - 707: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_707"), - 708: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_708"), - 709: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_709"), - 710: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_710"), - 711: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_711"), - 712: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_712"), - 713: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_713"), - 714: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_714"), - 715: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_715"), - 716: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_716"), - 717: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_717"), - 718: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_718"), - 719: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_719"), - 720: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_720"), - 721: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_721"), - 722: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_722"), - 723: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_723"), - 724: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_724"), - 725: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_725"), - 726: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_726"), - 727: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_727"), - 728: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_728"), - 729: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_729"), - 730: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_730"), - 731: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_731"), - 732: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_732"), - 733: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_733"), - 734: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_734"), - 735: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_735"), - 736: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_736"), - 737: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_737"), - 738: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_738"), - 739: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_739"), - 740: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_740"), - 741: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_741"), - 742: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_742"), - 743: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_743"), - 744: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_744"), - 745: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_745"), - 746: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_746"), - 747: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_747"), - 748: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_748"), - 749: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_749"), - 750: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_750"), - 751: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_751"), - 752: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_752"), - 753: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_753"), - 754: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_754"), - 755: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_755"), - 756: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_756"), - 757: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_757"), - 758: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_758"), - 759: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_759"), - 760: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_760"), - 761: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_761"), - 762: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_762"), - 763: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_763"), - 764: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_764"), - 765: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_765"), - 766: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_766"), - 767: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_767"), - 768: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_768"), - 769: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_769"), - 770: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_770"), - 771: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_771"), - 772: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_772"), - 773: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_773"), - 774: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_774"), - 775: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_775"), - 776: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_776"), - 777: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_777"), - 778: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_778"), - 779: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_779"), - 780: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_780"), - 781: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_781"), - 782: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_782"), - 783: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_783"), - 784: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_784"), - 785: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_785"), - 786: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_786"), - 787: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_787"), - 788: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_788"), - 789: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_789"), - 790: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_790"), - 791: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_791"), - 792: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_792"), - 793: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_793"), - 794: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_794"), - 795: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_795"), - 796: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_796"), - 797: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_797"), - 798: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_798"), - 799: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_799"), - 800: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_800"), - 801: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_801"), - 802: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_802"), - 803: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_803"), - 804: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_804"), - 805: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_805"), - 806: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_806"), - 807: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_807"), - 808: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_808"), - 809: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_809"), - 810: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_810"), - 811: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_811"), - 812: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_812"), - 813: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_813"), - 814: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_814"), - 815: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_815"), - 816: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_816"), - 817: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_817"), - 818: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_818"), - 819: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_819"), - 820: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_820"), - 821: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_821"), - 822: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_822"), - 823: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_823"), - 824: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_824"), - 825: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_825"), - 826: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_826"), - 827: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_827"), - 828: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_828"), - 829: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_829"), - 830: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_830"), - 831: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_831"), - 832: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_832"), - 833: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_833"), - 834: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_834"), - 835: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_835"), - 836: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_836"), - 837: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_837"), - 838: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_838"), - 839: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_839"), - 840: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_840"), - 841: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_841"), - 842: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_842"), - 843: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_843"), - 844: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_844"), - 845: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_845"), - 846: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_846"), - 847: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_847"), - 848: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_848"), - 849: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_849"), - 850: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_850"), - 851: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_851"), - 852: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_852"), - 853: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_853"), - 854: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_854"), - 855: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_855"), - 856: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_856"), - 857: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_857"), - 858: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_858"), - 859: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_859"), - 860: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_860"), - 861: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_861"), - 862: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_862"), - 863: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_863"), - 864: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_864"), - 865: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_865"), - 866: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_866"), - 867: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_867"), - 868: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_868"), - 869: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_869"), - 870: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_870"), - 871: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_871"), - 872: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_872"), - 873: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_873"), - 874: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_874"), - 875: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_875"), - 876: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_876"), - 877: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_877"), - 878: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_878"), - 879: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_879"), - 880: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_880"), - 881: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_881"), - 882: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_882"), - 883: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_883"), - 884: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_884"), - 885: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_885"), - 886: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_886"), - 887: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_887"), - 888: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_888"), - 889: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_889"), - 890: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_890"), - 891: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_891"), - 892: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_892"), - 893: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_893"), - 894: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_894"), - 895: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_895"), - 896: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_896"), - 897: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_897"), - 898: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_898"), - 899: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_899"), - 900: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_900"), - 901: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_901"), - 902: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_902"), - 903: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_903"), - 904: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_904"), - 905: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_905"), - 906: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_906"), - 907: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_907"), - 908: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_908"), - 909: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_909"), - 910: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_910"), - 911: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_911"), - 912: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_912"), - 913: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_913"), - 914: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_914"), - 915: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_915"), - 916: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_916"), - 917: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_917"), - 918: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_918"), - 919: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_919"), - 920: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_920"), - 921: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_921"), - 922: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_922"), - 923: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_923"), - 924: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_924"), - 925: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_925"), - 926: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_926"), - 927: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_927"), - 928: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_928"), - 929: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_929"), - 930: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_930"), - 931: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_931"), - 932: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_932"), - 933: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_933"), - 934: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_934"), - 935: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_935"), - 936: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_936"), - 937: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_937"), - 938: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_938"), - 939: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_939"), - 940: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_940"), - 941: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_941"), - 942: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_942"), - 943: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_943"), - 944: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_944"), - 945: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_945"), - 946: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_946"), - 947: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_947"), - 948: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_948"), - 949: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_949"), - 950: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_950"), - 951: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_951"), - 952: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_952"), - 953: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_953"), - 954: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_954"), - 955: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_955"), - 956: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_956"), - 957: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_957"), - 958: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_958"), - 959: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_959"), - 960: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_960"), - 961: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_961"), - 962: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_962"), - 963: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_963"), - 964: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_964"), - 965: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_965"), - 966: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_966"), - 967: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_967"), - 968: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_968"), - 969: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_969"), - 970: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_970"), - 971: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_971"), - 972: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_972"), - 973: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_973"), - 974: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_974"), - 975: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_975"), - 976: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_976"), - 977: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_977"), - 978: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_978"), - 979: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_979"), - 980: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_980"), - 981: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_981"), - 982: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_982"), - 983: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_983"), - 984: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_984"), - 985: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_985"), - 986: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_986"), - 987: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_987"), - 988: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_988"), - 989: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_989"), - 990: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_990"), - 991: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_991"), - 992: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_992"), - 993: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_993"), - 994: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_994"), - 995: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_995"), - 996: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_996"), - 997: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_997"), - 998: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_998"), - 999: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_999"), - 1000: .standard(proto: "long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_1000"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_1\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_2\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_3\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_4\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_5\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_6\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_7\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_8\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_9\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_10\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_11\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_12\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_13\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_14\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_15\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_16\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_17\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_18\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_19\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_20\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_21\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_22\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_23\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_24\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_25\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_26\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_27\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_28\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_29\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_30\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_31\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_32\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_33\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_34\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_35\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_36\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_37\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_38\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_39\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_40\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_41\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_42\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_43\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_44\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_45\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_46\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_47\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_48\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_49\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_50\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_51\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_52\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_53\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_54\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_55\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_56\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_57\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_58\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_59\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_60\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_61\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_62\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_63\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_64\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_65\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_66\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_67\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_68\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_69\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_70\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_71\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_72\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_73\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_74\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_75\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_76\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_77\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_78\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_79\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_80\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_81\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_82\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_83\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_84\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_85\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_86\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_87\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_88\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_89\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_90\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_91\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_92\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_93\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_94\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_95\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_96\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_97\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_98\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_99\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_100\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_101\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_102\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_103\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_104\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_105\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_106\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_107\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_108\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_109\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_110\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_111\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_112\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_113\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_114\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_115\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_116\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_117\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_118\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_119\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_120\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_121\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_122\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_123\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_124\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_125\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_126\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_127\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_128\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_129\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_130\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_131\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_132\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_133\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_134\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_135\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_136\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_137\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_138\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_139\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_140\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_141\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_142\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_143\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_144\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_145\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_146\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_147\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_148\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_149\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_150\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_151\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_152\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_153\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_154\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_155\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_156\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_157\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_158\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_159\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_160\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_161\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_162\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_163\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_164\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_165\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_166\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_167\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_168\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_169\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_170\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_171\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_172\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_173\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_174\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_175\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_176\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_177\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_178\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_179\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_180\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_181\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_182\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_183\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_184\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_185\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_186\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_187\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_188\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_189\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_190\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_191\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_192\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_193\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_194\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_195\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_196\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_197\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_198\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_199\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_200\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_201\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_202\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_203\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_204\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_205\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_206\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_207\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_208\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_209\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_210\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_211\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_212\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_213\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_214\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_215\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_216\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_217\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_218\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_219\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_220\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_221\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_222\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_223\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_224\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_225\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_226\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_227\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_228\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_229\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_230\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_231\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_232\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_233\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_234\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_235\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_236\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_237\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_238\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_239\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_240\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_241\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_242\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_243\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_244\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_245\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_246\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_247\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_248\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_249\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_250\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_251\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_252\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_253\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_254\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_255\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_256\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_257\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_258\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_259\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_260\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_261\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_262\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_263\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_264\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_265\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_266\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_267\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_268\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_269\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_270\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_271\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_272\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_273\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_274\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_275\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_276\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_277\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_278\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_279\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_280\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_281\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_282\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_283\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_284\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_285\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_286\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_287\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_288\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_289\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_290\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_291\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_292\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_293\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_294\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_295\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_296\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_297\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_298\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_299\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_300\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_301\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_302\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_303\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_304\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_305\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_306\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_307\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_308\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_309\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_310\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_311\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_312\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_313\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_314\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_315\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_316\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_317\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_318\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_319\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_320\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_321\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_322\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_323\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_324\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_325\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_326\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_327\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_328\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_329\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_330\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_331\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_332\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_333\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_334\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_335\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_336\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_337\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_338\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_339\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_340\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_341\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_342\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_343\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_344\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_345\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_346\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_347\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_348\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_349\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_350\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_351\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_352\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_353\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_354\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_355\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_356\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_357\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_358\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_359\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_360\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_361\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_362\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_363\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_364\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_365\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_366\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_367\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_368\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_369\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_370\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_371\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_372\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_373\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_374\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_375\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_376\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_377\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_378\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_379\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_380\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_381\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_382\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_383\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_384\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_385\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_386\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_387\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_388\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_389\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_390\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_391\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_392\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_393\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_394\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_395\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_396\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_397\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_398\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_399\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_400\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_401\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_402\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_403\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_404\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_405\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_406\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_407\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_408\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_409\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_410\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_411\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_412\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_413\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_414\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_415\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_416\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_417\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_418\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_419\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_420\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_421\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_422\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_423\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_424\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_425\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_426\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_427\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_428\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_429\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_430\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_431\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_432\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_433\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_434\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_435\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_436\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_437\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_438\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_439\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_440\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_441\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_442\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_443\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_444\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_445\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_446\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_447\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_448\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_449\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_450\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_451\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_452\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_453\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_454\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_455\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_456\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_457\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_458\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_459\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_460\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_461\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_462\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_463\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_464\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_465\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_466\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_467\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_468\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_469\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_470\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_471\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_472\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_473\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_474\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_475\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_476\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_477\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_478\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_479\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_480\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_481\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_482\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_483\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_484\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_485\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_486\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_487\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_488\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_489\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_490\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_491\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_492\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_493\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_494\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_495\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_496\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_497\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_498\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_499\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_500\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_501\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_502\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_503\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_504\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_505\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_506\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_507\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_508\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_509\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_510\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_511\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_512\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_513\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_514\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_515\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_516\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_517\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_518\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_519\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_520\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_521\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_522\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_523\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_524\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_525\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_526\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_527\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_528\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_529\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_530\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_531\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_532\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_533\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_534\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_535\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_536\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_537\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_538\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_539\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_540\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_541\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_542\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_543\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_544\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_545\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_546\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_547\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_548\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_549\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_550\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_551\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_552\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_553\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_554\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_555\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_556\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_557\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_558\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_559\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_560\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_561\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_562\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_563\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_564\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_565\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_566\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_567\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_568\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_569\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_570\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_571\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_572\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_573\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_574\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_575\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_576\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_577\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_578\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_579\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_580\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_581\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_582\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_583\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_584\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_585\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_586\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_587\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_588\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_589\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_590\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_591\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_592\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_593\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_594\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_595\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_596\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_597\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_598\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_599\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_600\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_601\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_602\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_603\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_604\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_605\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_606\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_607\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_608\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_609\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_610\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_611\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_612\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_613\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_614\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_615\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_616\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_617\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_618\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_619\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_620\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_621\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_622\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_623\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_624\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_625\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_626\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_627\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_628\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_629\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_630\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_631\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_632\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_633\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_634\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_635\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_636\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_637\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_638\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_639\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_640\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_641\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_642\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_643\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_644\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_645\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_646\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_647\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_648\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_649\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_650\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_651\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_652\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_653\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_654\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_655\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_656\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_657\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_658\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_659\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_660\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_661\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_662\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_663\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_664\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_665\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_666\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_667\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_668\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_669\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_670\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_671\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_672\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_673\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_674\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_675\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_676\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_677\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_678\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_679\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_680\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_681\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_682\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_683\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_684\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_685\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_686\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_687\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_688\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_689\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_690\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_691\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_692\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_693\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_694\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_695\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_696\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_697\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_698\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_699\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_700\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_701\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_702\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_703\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_704\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_705\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_706\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_707\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_708\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_709\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_710\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_711\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_712\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_713\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_714\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_715\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_716\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_717\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_718\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_719\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_720\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_721\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_722\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_723\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_724\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_725\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_726\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_727\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_728\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_729\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_730\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_731\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_732\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_733\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_734\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_735\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_736\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_737\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_738\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_739\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_740\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_741\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_742\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_743\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_744\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_745\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_746\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_747\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_748\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_749\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_750\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_751\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_752\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_753\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_754\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_755\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_756\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_757\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_758\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_759\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_760\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_761\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_762\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_763\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_764\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_765\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_766\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_767\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_768\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_769\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_770\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_771\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_772\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_773\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_774\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_775\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_776\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_777\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_778\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_779\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_780\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_781\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_782\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_783\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_784\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_785\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_786\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_787\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_788\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_789\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_790\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_791\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_792\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_793\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_794\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_795\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_796\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_797\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_798\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_799\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_800\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_801\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_802\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_803\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_804\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_805\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_806\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_807\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_808\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_809\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_810\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_811\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_812\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_813\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_814\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_815\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_816\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_817\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_818\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_819\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_820\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_821\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_822\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_823\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_824\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_825\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_826\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_827\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_828\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_829\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_830\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_831\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_832\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_833\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_834\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_835\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_836\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_837\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_838\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_839\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_840\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_841\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_842\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_843\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_844\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_845\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_846\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_847\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_848\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_849\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_850\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_851\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_852\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_853\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_854\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_855\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_856\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_857\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_858\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_859\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_860\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_861\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_862\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_863\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_864\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_865\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_866\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_867\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_868\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_869\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_870\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_871\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_872\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_873\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_874\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_875\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_876\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_877\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_878\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_879\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_880\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_881\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_882\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_883\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_884\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_885\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_886\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_887\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_888\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_889\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_890\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_891\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_892\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_893\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_894\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_895\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_896\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_897\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_898\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_899\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_900\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_901\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_902\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_903\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_904\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_905\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_906\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_907\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_908\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_909\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_910\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_911\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_912\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_913\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_914\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_915\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_916\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_917\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_918\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_919\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_920\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_921\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_922\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_923\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_924\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_925\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_926\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_927\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_928\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_929\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_930\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_931\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_932\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_933\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_934\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_935\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_936\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_937\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_938\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_939\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_940\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_941\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_942\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_943\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_944\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_945\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_946\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_947\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_948\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_949\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_950\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_951\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_952\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_953\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_954\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_955\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_956\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_957\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_958\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_959\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_960\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_961\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_962\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_963\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_964\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_965\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_966\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_967\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_968\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_969\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_970\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_971\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_972\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_973\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_974\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_975\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_976\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_977\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_978\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_979\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_980\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_981\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_982\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_983\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_984\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_985\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_986\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_987\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_988\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_989\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_990\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_991\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_992\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_993\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_994\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_995\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_996\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_997\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_998\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_999\0\u{3}long_field_name_is_looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong_1000\0") fileprivate class _StorageClass { var _longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1: String? = nil @@ -11085,7 +10059,11 @@ extension ProtobufUnittest_TestEnormousDescriptor: SwiftProtobuf.Message, SwiftP var _longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong999: String? = nil var _longFieldNameIsLooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong1000: String? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -16124,7 +15102,7 @@ extension ProtobufUnittest_TestEnormousDescriptor: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestEnormousDescriptor, rhs: ProtobufUnittest_TestEnormousDescriptor) -> Bool { + static func ==(lhs: Proto2Unittest_TestEnormousDescriptor, rhs: Proto2Unittest_TestEnormousDescriptor) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 diff --git a/Reference/upstream/google/protobuf/unittest_extension_set.pb.swift b/Reference/upstream/google/protobuf/unittest_extension_set.pb.swift new file mode 100644 index 000000000..56749b7f4 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_extension_set.pb.swift @@ -0,0 +1,140 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_extension_set.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// This file contains messages for testing extensions. + +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 +} + +/// A message with message_set_wire_format. +struct Proto2Unittest_TestExtensionSet: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +struct Proto2Unittest_TestExtensionSetContainer: Sendable { + // 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 `extension`: Proto2Unittest_TestExtensionSet { + get {_extension ?? Proto2Unittest_TestExtensionSet()} + set {_extension = newValue} + } + /// Returns true if ``extension`` has been explicitly set. + var hasExtension: Bool {self._extension != nil} + /// Clears the value of ``extension``. Subsequent reads from it will return its default value. + mutating func clearExtension() {self._extension = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _extension: Proto2Unittest_TestExtensionSet? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest" + +extension Proto2Unittest_TestExtensionSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestExtensionSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (4 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestExtensionSet.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 4, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestExtensionSet, rhs: Proto2Unittest_TestExtensionSet) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TestExtensionSetContainer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestExtensionSetContainer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extension\0") + + public var isInitialized: Bool { + if let v = self._extension, !v.isInitialized {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._extension) }() + 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 + try { if let v = self._extension { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestExtensionSetContainer, rhs: Proto2Unittest_TestExtensionSetContainer) -> Bool { + if lhs._extension != rhs._extension {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/unittest_features.pb.swift b/Reference/upstream/google/protobuf/unittest_features.pb.swift new file mode 100644 index 000000000..6ee795d30 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_features.pb.swift @@ -0,0 +1,800 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_features.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2023 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +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 Pb_EnumFeature: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case testEnumFeatureUnknown // = 0 + case value1 // = 1 + case value2 // = 2 + case value3 // = 3 + case value4 // = 4 + case value5 // = 5 + case value6 // = 6 + case value7 // = 7 + case value8 // = 8 + case value9 // = 9 + case value10 // = 10 + case value11 // = 11 + case value12 // = 12 + case value13 // = 13 + case value14 // = 14 + case value15 // = 15 + case UNRECOGNIZED(Int) + + init() { + self = .testEnumFeatureUnknown + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .testEnumFeatureUnknown + case 1: self = .value1 + case 2: self = .value2 + case 3: self = .value3 + case 4: self = .value4 + case 5: self = .value5 + case 6: self = .value6 + case 7: self = .value7 + case 8: self = .value8 + case 9: self = .value9 + case 10: self = .value10 + case 11: self = .value11 + case 12: self = .value12 + case 13: self = .value13 + case 14: self = .value14 + case 15: self = .value15 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .testEnumFeatureUnknown: return 0 + case .value1: return 1 + case .value2: return 2 + case .value3: return 3 + case .value4: return 4 + case .value5: return 5 + case .value6: return 6 + case .value7: return 7 + case .value8: return 8 + case .value9: return 9 + case .value10: return 10 + case .value11: return 11 + case .value12: return 12 + case .value13: return 13 + case .value14: return 14 + case .value15: return 15 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Pb_EnumFeature] = [ + .testEnumFeatureUnknown, + .value1, + .value2, + .value3, + .value4, + .value5, + .value6, + .value7, + .value8, + .value9, + .value10, + .value11, + .value12, + .value13, + .value14, + .value15, + ] + +} + +enum Pb_UnstableEnumFeature: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case testUnstableEnumFeatureUnknown // = 0 + case unstable1 // = 1 + case unstable2 // = 2 + case unstable3 // = 3 + case unstable4 // = 4 + case UNRECOGNIZED(Int) + + init() { + self = .testUnstableEnumFeatureUnknown + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .testUnstableEnumFeatureUnknown + case 1: self = .unstable1 + case 2: self = .unstable2 + case 3: self = .unstable3 + case 4: self = .unstable4 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .testUnstableEnumFeatureUnknown: return 0 + case .unstable1: return 1 + case .unstable2: return 2 + case .unstable3: return 3 + case .unstable4: return 4 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Pb_UnstableEnumFeature] = [ + .testUnstableEnumFeatureUnknown, + .unstable1, + .unstable2, + .unstable3, + .unstable4, + ] + +} + +enum Pb_ValueLifetimeFeature: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case testValueLifetimeUnknown // = 0 + case valueLifetimeInherited // = 1 + case valueLifetimeSupport // = 2 + case valueLifetimeEmptySupport // = 3 + case valueLifetimeFuture // = 4 + case valueLifetimeDeprecated // = 5 + case valueLifetimeRemoved // = 6 + case UNRECOGNIZED(Int) + + init() { + self = .testValueLifetimeUnknown + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .testValueLifetimeUnknown + case 1: self = .valueLifetimeInherited + case 2: self = .valueLifetimeSupport + case 3: self = .valueLifetimeEmptySupport + case 4: self = .valueLifetimeFuture + case 5: self = .valueLifetimeDeprecated + case 6: self = .valueLifetimeRemoved + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .testValueLifetimeUnknown: return 0 + case .valueLifetimeInherited: return 1 + case .valueLifetimeSupport: return 2 + case .valueLifetimeEmptySupport: return 3 + case .valueLifetimeFuture: return 4 + case .valueLifetimeDeprecated: return 5 + case .valueLifetimeRemoved: return 6 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Pb_ValueLifetimeFeature] = [ + .testValueLifetimeUnknown, + .valueLifetimeInherited, + .valueLifetimeSupport, + .valueLifetimeEmptySupport, + .valueLifetimeFuture, + .valueLifetimeDeprecated, + .valueLifetimeRemoved, + ] + +} + +struct Pb_TestMessage: Sendable { + // 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() + + struct Nested: Sendable { + // 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() {} + } + + init() {} +} + +struct Pb_TestFeatures: @unchecked Sendable { + // 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 fileFeature: Pb_EnumFeature { + get {_storage._fileFeature ?? .testEnumFeatureUnknown} + set {_uniqueStorage()._fileFeature = newValue} + } + /// Returns true if `fileFeature` has been explicitly set. + var hasFileFeature: Bool {_storage._fileFeature != nil} + /// Clears the value of `fileFeature`. Subsequent reads from it will return its default value. + mutating func clearFileFeature() {_uniqueStorage()._fileFeature = nil} + + var extensionRangeFeature: Pb_EnumFeature { + get {_storage._extensionRangeFeature ?? .testEnumFeatureUnknown} + set {_uniqueStorage()._extensionRangeFeature = newValue} + } + /// Returns true if `extensionRangeFeature` has been explicitly set. + var hasExtensionRangeFeature: Bool {_storage._extensionRangeFeature != nil} + /// Clears the value of `extensionRangeFeature`. Subsequent reads from it will return its default value. + mutating func clearExtensionRangeFeature() {_uniqueStorage()._extensionRangeFeature = nil} + + var messageFeature: Pb_EnumFeature { + get {_storage._messageFeature ?? .testEnumFeatureUnknown} + set {_uniqueStorage()._messageFeature = newValue} + } + /// Returns true if `messageFeature` has been explicitly set. + var hasMessageFeature: Bool {_storage._messageFeature != nil} + /// Clears the value of `messageFeature`. Subsequent reads from it will return its default value. + mutating func clearMessageFeature() {_uniqueStorage()._messageFeature = nil} + + var fieldFeature: Pb_EnumFeature { + get {_storage._fieldFeature ?? .testEnumFeatureUnknown} + set {_uniqueStorage()._fieldFeature = newValue} + } + /// Returns true if `fieldFeature` has been explicitly set. + var hasFieldFeature: Bool {_storage._fieldFeature != nil} + /// Clears the value of `fieldFeature`. Subsequent reads from it will return its default value. + mutating func clearFieldFeature() {_uniqueStorage()._fieldFeature = nil} + + var oneofFeature: Pb_EnumFeature { + get {_storage._oneofFeature ?? .testEnumFeatureUnknown} + set {_uniqueStorage()._oneofFeature = newValue} + } + /// Returns true if `oneofFeature` has been explicitly set. + var hasOneofFeature: Bool {_storage._oneofFeature != nil} + /// Clears the value of `oneofFeature`. Subsequent reads from it will return its default value. + mutating func clearOneofFeature() {_uniqueStorage()._oneofFeature = nil} + + var enumFeature: Pb_EnumFeature { + get {_storage._enumFeature ?? .testEnumFeatureUnknown} + set {_uniqueStorage()._enumFeature = newValue} + } + /// Returns true if `enumFeature` has been explicitly set. + var hasEnumFeature: Bool {_storage._enumFeature != nil} + /// Clears the value of `enumFeature`. Subsequent reads from it will return its default value. + mutating func clearEnumFeature() {_uniqueStorage()._enumFeature = nil} + + var enumEntryFeature: Pb_EnumFeature { + get {_storage._enumEntryFeature ?? .testEnumFeatureUnknown} + set {_uniqueStorage()._enumEntryFeature = newValue} + } + /// Returns true if `enumEntryFeature` has been explicitly set. + var hasEnumEntryFeature: Bool {_storage._enumEntryFeature != nil} + /// Clears the value of `enumEntryFeature`. Subsequent reads from it will return its default value. + mutating func clearEnumEntryFeature() {_uniqueStorage()._enumEntryFeature = nil} + + var serviceFeature: Pb_EnumFeature { + get {_storage._serviceFeature ?? .testEnumFeatureUnknown} + set {_uniqueStorage()._serviceFeature = newValue} + } + /// Returns true if `serviceFeature` has been explicitly set. + var hasServiceFeature: Bool {_storage._serviceFeature != nil} + /// Clears the value of `serviceFeature`. Subsequent reads from it will return its default value. + mutating func clearServiceFeature() {_uniqueStorage()._serviceFeature = nil} + + var methodFeature: Pb_EnumFeature { + get {_storage._methodFeature ?? .testEnumFeatureUnknown} + set {_uniqueStorage()._methodFeature = newValue} + } + /// Returns true if `methodFeature` has been explicitly set. + var hasMethodFeature: Bool {_storage._methodFeature != nil} + /// Clears the value of `methodFeature`. Subsequent reads from it will return its default value. + mutating func clearMethodFeature() {_uniqueStorage()._methodFeature = nil} + + var multipleFeature: Pb_EnumFeature { + get {_storage._multipleFeature ?? .testEnumFeatureUnknown} + set {_uniqueStorage()._multipleFeature = newValue} + } + /// Returns true if `multipleFeature` has been explicitly set. + var hasMultipleFeature: Bool {_storage._multipleFeature != nil} + /// Clears the value of `multipleFeature`. Subsequent reads from it will return its default value. + mutating func clearMultipleFeature() {_uniqueStorage()._multipleFeature = nil} + + var boolFieldFeature: Bool { + get {_storage._boolFieldFeature ?? false} + set {_uniqueStorage()._boolFieldFeature = newValue} + } + /// Returns true if `boolFieldFeature` has been explicitly set. + var hasBoolFieldFeature: Bool {_storage._boolFieldFeature != nil} + /// Clears the value of `boolFieldFeature`. Subsequent reads from it will return its default value. + mutating func clearBoolFieldFeature() {_uniqueStorage()._boolFieldFeature = nil} + + var sourceFeature: Pb_EnumFeature { + get {_storage._sourceFeature ?? .testEnumFeatureUnknown} + set {_uniqueStorage()._sourceFeature = newValue} + } + /// Returns true if `sourceFeature` has been explicitly set. + var hasSourceFeature: Bool {_storage._sourceFeature != nil} + /// Clears the value of `sourceFeature`. Subsequent reads from it will return its default value. + mutating func clearSourceFeature() {_uniqueStorage()._sourceFeature = nil} + + var sourceFeature2: Pb_EnumFeature { + get {_storage._sourceFeature2 ?? .testEnumFeatureUnknown} + set {_uniqueStorage()._sourceFeature2 = newValue} + } + /// Returns true if `sourceFeature2` has been explicitly set. + var hasSourceFeature2: Bool {_storage._sourceFeature2 != nil} + /// Clears the value of `sourceFeature2`. Subsequent reads from it will return its default value. + mutating func clearSourceFeature2() {_uniqueStorage()._sourceFeature2 = nil} + + var removedFeature: Pb_EnumFeature { + get {_storage._removedFeature ?? .testEnumFeatureUnknown} + set {_uniqueStorage()._removedFeature = newValue} + } + /// Returns true if `removedFeature` has been explicitly set. + var hasRemovedFeature: Bool {_storage._removedFeature != nil} + /// Clears the value of `removedFeature`. Subsequent reads from it will return its default value. + mutating func clearRemovedFeature() {_uniqueStorage()._removedFeature = nil} + + var sameEditionRemovedFeature: Pb_EnumFeature { + get {_storage._sameEditionRemovedFeature ?? .testEnumFeatureUnknown} + set {_uniqueStorage()._sameEditionRemovedFeature = newValue} + } + /// Returns true if `sameEditionRemovedFeature` has been explicitly set. + var hasSameEditionRemovedFeature: Bool {_storage._sameEditionRemovedFeature != nil} + /// Clears the value of `sameEditionRemovedFeature`. Subsequent reads from it will return its default value. + mutating func clearSameEditionRemovedFeature() {_uniqueStorage()._sameEditionRemovedFeature = nil} + + var futureFeature: Pb_EnumFeature { + get {_storage._futureFeature ?? .testEnumFeatureUnknown} + set {_uniqueStorage()._futureFeature = newValue} + } + /// Returns true if `futureFeature` has been explicitly set. + var hasFutureFeature: Bool {_storage._futureFeature != nil} + /// Clears the value of `futureFeature`. Subsequent reads from it will return its default value. + mutating func clearFutureFeature() {_uniqueStorage()._futureFeature = nil} + + var legacyFeature: Pb_EnumFeature { + get {_storage._legacyFeature ?? .testEnumFeatureUnknown} + set {_uniqueStorage()._legacyFeature = newValue} + } + /// Returns true if `legacyFeature` has been explicitly set. + var hasLegacyFeature: Bool {_storage._legacyFeature != nil} + /// Clears the value of `legacyFeature`. Subsequent reads from it will return its default value. + mutating func clearLegacyFeature() {_uniqueStorage()._legacyFeature = nil} + + var valueLifetimeFeature: Pb_ValueLifetimeFeature { + get {_storage._valueLifetimeFeature ?? .testValueLifetimeUnknown} + set {_uniqueStorage()._valueLifetimeFeature = newValue} + } + /// Returns true if `valueLifetimeFeature` has been explicitly set. + var hasValueLifetimeFeature: Bool {_storage._valueLifetimeFeature != nil} + /// Clears the value of `valueLifetimeFeature`. Subsequent reads from it will return its default value. + mutating func clearValueLifetimeFeature() {_uniqueStorage()._valueLifetimeFeature = nil} + + var newUnstableFeature: Pb_UnstableEnumFeature { + get {_storage._newUnstableFeature ?? .testUnstableEnumFeatureUnknown} + set {_uniqueStorage()._newUnstableFeature = newValue} + } + /// Returns true if `newUnstableFeature` has been explicitly set. + var hasNewUnstableFeature: Bool {_storage._newUnstableFeature != nil} + /// Clears the value of `newUnstableFeature`. Subsequent reads from it will return its default value. + mutating func clearNewUnstableFeature() {_uniqueStorage()._newUnstableFeature = nil} + + var unstableExistingFeature: Pb_UnstableEnumFeature { + get {_storage._unstableExistingFeature ?? .testUnstableEnumFeatureUnknown} + set {_uniqueStorage()._unstableExistingFeature = newValue} + } + /// Returns true if `unstableExistingFeature` has been explicitly set. + var hasUnstableExistingFeature: Bool {_storage._unstableExistingFeature != nil} + /// Clears the value of `unstableExistingFeature`. Subsequent reads from it will return its default value. + mutating func clearUnstableExistingFeature() {_uniqueStorage()._unstableExistingFeature = nil} + + var removedUnstableFeature: Pb_UnstableEnumFeature { + get {_storage._removedUnstableFeature ?? .testUnstableEnumFeatureUnknown} + set {_uniqueStorage()._removedUnstableFeature = newValue} + } + /// Returns true if `removedUnstableFeature` has been explicitly set. + var hasRemovedUnstableFeature: Bool {_storage._removedUnstableFeature != nil} + /// Clears the value of `removedUnstableFeature`. Subsequent reads from it will return its default value. + mutating func clearRemovedUnstableFeature() {_uniqueStorage()._removedUnstableFeature = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Extension support defined in unittest_features.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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_FeatureSet { + + var Pb_test: Pb_TestFeatures { + get {return getExtensionValue(ext: Pb_Extensions_test) ?? Pb_TestFeatures()} + set {setExtensionValue(ext: Pb_Extensions_test, value: newValue)} + } + /// Returns true if extension `Pb_Extensions_test` + /// has been explicitly set. + var hasPb_test: Bool { + return hasExtensionValue(ext: Pb_Extensions_test) + } + /// Clears the value of extension `Pb_Extensions_test`. + /// Subsequent reads from it will return its default value. + mutating func clearPb_test() { + clearExtensionValue(ext: Pb_Extensions_test) + } + + var Pb_TestMessage_testMessage: Pb_TestFeatures { + get {return getExtensionValue(ext: Pb_TestMessage.Extensions.test_message) ?? Pb_TestFeatures()} + set {setExtensionValue(ext: Pb_TestMessage.Extensions.test_message, value: newValue)} + } + /// Returns true if extension `Pb_TestMessage.Extensions.test_message` + /// has been explicitly set. + var hasPb_TestMessage_testMessage: Bool { + return hasExtensionValue(ext: Pb_TestMessage.Extensions.test_message) + } + /// Clears the value of extension `Pb_TestMessage.Extensions.test_message`. + /// Subsequent reads from it will return its default value. + mutating func clearPb_TestMessage_testMessage() { + clearExtensionValue(ext: Pb_TestMessage.Extensions.test_message) + } + + var Pb_TestMessage_Nested_testNested: Pb_TestFeatures { + get {return getExtensionValue(ext: Pb_TestMessage.Nested.Extensions.test_nested) ?? Pb_TestFeatures()} + set {setExtensionValue(ext: Pb_TestMessage.Nested.Extensions.test_nested, value: newValue)} + } + /// Returns true if extension `Pb_TestMessage.Nested.Extensions.test_nested` + /// has been explicitly set. + var hasPb_TestMessage_Nested_testNested: Bool { + return hasExtensionValue(ext: Pb_TestMessage.Nested.Extensions.test_nested) + } + /// Clears the value of extension `Pb_TestMessage.Nested.Extensions.test_nested`. + /// Subsequent reads from it will return its default value. + mutating func clearPb_TestMessage_Nested_testNested() { + clearExtensionValue(ext: Pb_TestMessage.Nested.Extensions.test_nested) + } + +} + +// MARK: - File's ExtensionMap: Pb_UnittestFeatures_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 Pb_UnittestFeatures_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Pb_Extensions_test, + Pb_TestMessage.Extensions.test_message, + Pb_TestMessage.Nested.Extensions.test_nested +] + +// 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 Pb_Extensions_test = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FeatureSet>( + _protobuf_fieldNumber: 9999, + fieldName: "pb.test" +) + +extension Pb_TestMessage { + enum Extensions { + static let test_message = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FeatureSet>( + _protobuf_fieldNumber: 9998, + fieldName: "pb.TestMessage.test_message" + ) + } +} + +extension Pb_TestMessage.Nested { + enum Extensions { + static let test_nested = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FeatureSet>( + _protobuf_fieldNumber: 9997, + fieldName: "pb.TestMessage.Nested.test_nested" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "pb" + +extension Pb_EnumFeature: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0TEST_ENUM_FEATURE_UNKNOWN\0\u{1}VALUE1\0\u{1}VALUE2\0\u{1}VALUE3\0\u{1}VALUE4\0\u{1}VALUE5\0\u{1}VALUE6\0\u{1}VALUE7\0\u{1}VALUE8\0\u{1}VALUE9\0\u{1}VALUE10\0\u{1}VALUE11\0\u{1}VALUE12\0\u{1}VALUE13\0\u{1}VALUE14\0\u{1}VALUE15\0") +} + +extension Pb_UnstableEnumFeature: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0TEST_UNSTABLE_ENUM_FEATURE_UNKNOWN\0\u{1}UNSTABLE1\0\u{1}UNSTABLE2\0\u{1}UNSTABLE3\0\u{1}UNSTABLE4\0") +} + +extension Pb_ValueLifetimeFeature: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0TEST_VALUE_LIFETIME_UNKNOWN\0\u{1}VALUE_LIFETIME_INHERITED\0\u{1}VALUE_LIFETIME_SUPPORT\0\u{1}VALUE_LIFETIME_EMPTY_SUPPORT\0\u{1}VALUE_LIFETIME_FUTURE\0\u{1}VALUE_LIFETIME_DEPRECATED\0\u{1}VALUE_LIFETIME_REMOVED\0") +} + +extension Pb_TestMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Pb_TestMessage, rhs: Pb_TestMessage) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Pb_TestMessage.Nested: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Pb_TestMessage.protoMessageName + ".Nested" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Pb_TestMessage.Nested, rhs: Pb_TestMessage.Nested) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Pb_TestFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}file_feature\0\u{3}extension_range_feature\0\u{3}message_feature\0\u{3}field_feature\0\u{3}oneof_feature\0\u{3}enum_feature\0\u{3}enum_entry_feature\0\u{3}service_feature\0\u{3}method_feature\0\u{3}multiple_feature\0\u{3}bool_field_feature\0\u{4}\u{4}source_feature\0\u{3}source_feature2\0\u{3}removed_feature\0\u{3}future_feature\0\u{3}legacy_feature\0\u{3}value_lifetime_feature\0\u{3}same_edition_removed_feature\0\u{3}new_unstable_feature\0\u{3}unstable_existing_feature\0\u{3}removed_unstable_feature\0") + + fileprivate class _StorageClass { + var _fileFeature: Pb_EnumFeature? = nil + var _extensionRangeFeature: Pb_EnumFeature? = nil + var _messageFeature: Pb_EnumFeature? = nil + var _fieldFeature: Pb_EnumFeature? = nil + var _oneofFeature: Pb_EnumFeature? = nil + var _enumFeature: Pb_EnumFeature? = nil + var _enumEntryFeature: Pb_EnumFeature? = nil + var _serviceFeature: Pb_EnumFeature? = nil + var _methodFeature: Pb_EnumFeature? = nil + var _multipleFeature: Pb_EnumFeature? = nil + var _boolFieldFeature: Bool? = nil + var _sourceFeature: Pb_EnumFeature? = nil + var _sourceFeature2: Pb_EnumFeature? = nil + var _removedFeature: Pb_EnumFeature? = nil + var _sameEditionRemovedFeature: Pb_EnumFeature? = nil + var _futureFeature: Pb_EnumFeature? = nil + var _legacyFeature: Pb_EnumFeature? = nil + var _valueLifetimeFeature: Pb_ValueLifetimeFeature? = nil + var _newUnstableFeature: Pb_UnstableEnumFeature? = nil + var _unstableExistingFeature: Pb_UnstableEnumFeature? = nil + var _removedUnstableFeature: Pb_UnstableEnumFeature? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _fileFeature = source._fileFeature + _extensionRangeFeature = source._extensionRangeFeature + _messageFeature = source._messageFeature + _fieldFeature = source._fieldFeature + _oneofFeature = source._oneofFeature + _enumFeature = source._enumFeature + _enumEntryFeature = source._enumEntryFeature + _serviceFeature = source._serviceFeature + _methodFeature = source._methodFeature + _multipleFeature = source._multipleFeature + _boolFieldFeature = source._boolFieldFeature + _sourceFeature = source._sourceFeature + _sourceFeature2 = source._sourceFeature2 + _removedFeature = source._removedFeature + _sameEditionRemovedFeature = source._sameEditionRemovedFeature + _futureFeature = source._futureFeature + _legacyFeature = source._legacyFeature + _valueLifetimeFeature = source._valueLifetimeFeature + _newUnstableFeature = source._newUnstableFeature + _unstableExistingFeature = source._unstableExistingFeature + _removedUnstableFeature = source._removedUnstableFeature + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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.decodeSingularEnumField(value: &_storage._fileFeature) }() + case 2: try { try decoder.decodeSingularEnumField(value: &_storage._extensionRangeFeature) }() + case 3: try { try decoder.decodeSingularEnumField(value: &_storage._messageFeature) }() + case 4: try { try decoder.decodeSingularEnumField(value: &_storage._fieldFeature) }() + case 5: try { try decoder.decodeSingularEnumField(value: &_storage._oneofFeature) }() + case 6: try { try decoder.decodeSingularEnumField(value: &_storage._enumFeature) }() + case 7: try { try decoder.decodeSingularEnumField(value: &_storage._enumEntryFeature) }() + case 8: try { try decoder.decodeSingularEnumField(value: &_storage._serviceFeature) }() + case 9: try { try decoder.decodeSingularEnumField(value: &_storage._methodFeature) }() + case 10: try { try decoder.decodeSingularEnumField(value: &_storage._multipleFeature) }() + case 11: try { try decoder.decodeSingularBoolField(value: &_storage._boolFieldFeature) }() + case 15: try { try decoder.decodeSingularEnumField(value: &_storage._sourceFeature) }() + case 16: try { try decoder.decodeSingularEnumField(value: &_storage._sourceFeature2) }() + case 17: try { try decoder.decodeSingularEnumField(value: &_storage._removedFeature) }() + case 18: try { try decoder.decodeSingularEnumField(value: &_storage._futureFeature) }() + case 19: try { try decoder.decodeSingularEnumField(value: &_storage._legacyFeature) }() + case 20: try { try decoder.decodeSingularEnumField(value: &_storage._valueLifetimeFeature) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._sameEditionRemovedFeature) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._newUnstableFeature) }() + case 23: try { try decoder.decodeSingularEnumField(value: &_storage._unstableExistingFeature) }() + case 24: try { try decoder.decodeSingularEnumField(value: &_storage._removedUnstableFeature) }() + default: break + } + } + } + } + + func traverse(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._fileFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._extensionRangeFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._messageFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._fieldFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._oneofFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._enumFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._enumEntryFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._serviceFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._methodFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._multipleFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._boolFieldFeature { + try visitor.visitSingularBoolField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._sourceFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._sourceFeature2 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._removedFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 17) + } }() + try { if let v = _storage._futureFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._legacyFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._valueLifetimeFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 20) + } }() + try { if let v = _storage._sameEditionRemovedFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._newUnstableFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._unstableExistingFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 23) + } }() + try { if let v = _storage._removedUnstableFeature { + try visitor.visitSingularEnumField(value: v, fieldNumber: 24) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Pb_TestFeatures, rhs: Pb_TestFeatures) -> 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._fileFeature != rhs_storage._fileFeature {return false} + if _storage._extensionRangeFeature != rhs_storage._extensionRangeFeature {return false} + if _storage._messageFeature != rhs_storage._messageFeature {return false} + if _storage._fieldFeature != rhs_storage._fieldFeature {return false} + if _storage._oneofFeature != rhs_storage._oneofFeature {return false} + if _storage._enumFeature != rhs_storage._enumFeature {return false} + if _storage._enumEntryFeature != rhs_storage._enumEntryFeature {return false} + if _storage._serviceFeature != rhs_storage._serviceFeature {return false} + if _storage._methodFeature != rhs_storage._methodFeature {return false} + if _storage._multipleFeature != rhs_storage._multipleFeature {return false} + if _storage._boolFieldFeature != rhs_storage._boolFieldFeature {return false} + if _storage._sourceFeature != rhs_storage._sourceFeature {return false} + if _storage._sourceFeature2 != rhs_storage._sourceFeature2 {return false} + if _storage._removedFeature != rhs_storage._removedFeature {return false} + if _storage._sameEditionRemovedFeature != rhs_storage._sameEditionRemovedFeature {return false} + if _storage._futureFeature != rhs_storage._futureFeature {return false} + if _storage._legacyFeature != rhs_storage._legacyFeature {return false} + if _storage._valueLifetimeFeature != rhs_storage._valueLifetimeFeature {return false} + if _storage._newUnstableFeature != rhs_storage._newUnstableFeature {return false} + if _storage._unstableExistingFeature != rhs_storage._unstableExistingFeature {return false} + if _storage._removedUnstableFeature != rhs_storage._removedUnstableFeature {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/unittest_import.pb.swift b/Reference/upstream/google/protobuf/unittest_import.pb.swift new file mode 100644 index 000000000..a5ca32564 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_import.pb.swift @@ -0,0 +1,124 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_import.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// A proto file which is imported by unittest.proto to test importing. + +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 Proto2UnittestImport_ImportEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case importFoo = 7 + case importBar = 8 + case importBaz = 9 + + init() { + self = .importFoo + } + +} + +/// To use an enum in a map, it must has the first value as 0. +enum Proto2UnittestImport_ImportEnumForMap: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unknown = 0 + case foo = 1 + case bar = 2 + + init() { + self = .unknown + } + +} + +struct Proto2UnittestImport_ImportMessage: Sendable { + // 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 d: Int32 { + get {_d ?? 0} + set {_d = newValue} + } + /// Returns true if `d` has been explicitly set. + var hasD: Bool {self._d != nil} + /// Clears the value of `d`. Subsequent reads from it will return its default value. + mutating func clearD() {self._d = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _d: Int32? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest_import" + +extension Proto2UnittestImport_ImportEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7}IMPORT_FOO\0\u{1}IMPORT_BAR\0\u{1}IMPORT_BAZ\0") +} + +extension Proto2UnittestImport_ImportEnumForMap: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNKNOWN\0\u{1}FOO\0\u{1}BAR\0") +} + +extension Proto2UnittestImport_ImportMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ImportMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}d\0") + + 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._d) }() + 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 + try { if let v = self._d { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2UnittestImport_ImportMessage, rhs: Proto2UnittestImport_ImportMessage) -> Bool { + if lhs._d != rhs._d {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/unittest_import_lite.pb.swift b/Reference/upstream/google/protobuf/unittest_import_lite.pb.swift new file mode 100644 index 000000000..6b3a62036 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_import_lite.pb.swift @@ -0,0 +1,106 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_import_lite.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// +// This is like unittest_import.proto but with optimize_for = LITE_RUNTIME. + +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 Proto2UnittestImport_ImportEnumLite: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case importLiteFoo = 7 + case importLiteBar = 8 + case importLiteBaz = 9 + + init() { + self = .importLiteFoo + } + +} + +struct Proto2UnittestImport_ImportMessageLite: Sendable { + // 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 d: Int32 { + get {_d ?? 0} + set {_d = newValue} + } + /// Returns true if `d` has been explicitly set. + var hasD: Bool {self._d != nil} + /// Clears the value of `d`. Subsequent reads from it will return its default value. + mutating func clearD() {self._d = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _d: Int32? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest_import" + +extension Proto2UnittestImport_ImportEnumLite: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7}IMPORT_LITE_FOO\0\u{1}IMPORT_LITE_BAR\0\u{1}IMPORT_LITE_BAZ\0") +} + +extension Proto2UnittestImport_ImportMessageLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ImportMessageLite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}d\0") + + 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._d) }() + 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 + try { if let v = self._d { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2UnittestImport_ImportMessageLite, rhs: Proto2UnittestImport_ImportMessageLite) -> Bool { + if lhs._d != rhs._d {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/unittest_import_option.pb.swift b/Reference/upstream/google/protobuf/unittest_import_option.pb.swift new file mode 100644 index 000000000..9d251ae11 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_import_option.pb.swift @@ -0,0 +1,92 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_import_option.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +/// Protocol Buffers - Google's data interchange format +/// Copyright 2008 Google Inc. All rights reserved. +/// +/// Use of this source code is governed by a BSD-style +/// license that can be found in the LICENSE file or at +/// https://developers.google.com/open-source/licenses/bsd +/// Author: kenton@google.com (Kenton Varda) +/// Based on original Protocol Buffers design by +/// Sanjay Ghemawat, Jeff Dean, and others. +/// +/// A proto file to test options importing. + +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 Proto2UnittestImportOption_TestMessage: Sendable { + // 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 {_field1 ?? 0} + set {_field1 = newValue} + } + /// Returns true if `field1` has been explicitly set. + var hasField1: Bool {self._field1 != nil} + /// Clears the value of `field1`. Subsequent reads from it will return its default value. + mutating func clearField1() {self._field1 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _field1: Int32? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest_import_option" + +extension Proto2UnittestImportOption_TestMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field1\0") + + 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._field1) }() + 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 + try { if let v = self._field1 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2UnittestImportOption_TestMessage, rhs: Proto2UnittestImportOption_TestMessage) -> Bool { + if lhs._field1 != rhs._field1 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/unittest_import_public.pb.swift b/Reference/upstream/google/protobuf/unittest_import_public.pb.swift new file mode 100644 index 000000000..1c5c6c4a4 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_import_public.pb.swift @@ -0,0 +1,89 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_import_public.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: liujisi@google.com (Pherl Liu) + +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 Proto2UnittestImport_PublicImportMessage: Sendable { + // 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 e: Int32 { + get {_e ?? 0} + set {_e = newValue} + } + /// Returns true if `e` has been explicitly set. + var hasE: Bool {self._e != nil} + /// Clears the value of `e`. Subsequent reads from it will return its default value. + mutating func clearE() {self._e = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _e: Int32? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest_import" + +extension Proto2UnittestImport_PublicImportMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".PublicImportMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}e\0") + + 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._e) }() + 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 + try { if let v = self._e { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2UnittestImport_PublicImportMessage, rhs: Proto2UnittestImport_PublicImportMessage) -> Bool { + if lhs._e != rhs._e {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Tests/SwiftProtobufTests/unittest_import_public_lite.pb.swift b/Reference/upstream/google/protobuf/unittest_import_public_lite.pb.swift similarity index 55% rename from Tests/SwiftProtobufTests/unittest_import_public_lite.pb.swift rename to Reference/upstream/google/protobuf/unittest_import_public_lite.pb.swift index b4f9c4699..8d83e37d7 100644 --- a/Tests/SwiftProtobufTests/unittest_import_public_lite.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_import_public_lite.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/unittest_import_public_lite.proto @@ -9,37 +10,13 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd // Author: liujisi@google.com (Pherl Liu) -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -52,17 +29,17 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittestImport_PublicImportMessageLite { +struct Proto2UnittestImport_PublicImportMessageLite: Sendable { // 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 e: Int32 { - get {return _e ?? 0} + get {_e ?? 0} set {_e = newValue} } /// Returns true if `e` has been explicitly set. - var hasE: Bool {return self._e != nil} + var hasE: Bool {self._e != nil} /// Clears the value of `e`. Subsequent reads from it will return its default value. mutating func clearE() {self._e = nil} @@ -73,19 +50,13 @@ struct ProtobufUnittestImport_PublicImportMessageLite { fileprivate var _e: Int32? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittestImport_PublicImportMessageLite: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest_import" +fileprivate let _protobuf_package = "proto2_unittest_import" -extension ProtobufUnittestImport_PublicImportMessageLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2UnittestImport_PublicImportMessageLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".PublicImportMessageLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "e"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}e\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -110,7 +81,7 @@ extension ProtobufUnittestImport_PublicImportMessageLite: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestImport_PublicImportMessageLite, rhs: ProtobufUnittestImport_PublicImportMessageLite) -> Bool { + static func ==(lhs: Proto2UnittestImport_PublicImportMessageLite, rhs: Proto2UnittestImport_PublicImportMessageLite) -> Bool { if lhs._e != rhs._e {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Reference/upstream/google/protobuf/unittest_invalid_features.pb.swift b/Reference/upstream/google/protobuf/unittest_invalid_features.pb.swift new file mode 100644 index 000000000..8cbde5a56 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_invalid_features.pb.swift @@ -0,0 +1,121 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_invalid_features.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2023 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +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 Pb_TestInvalidFeatures: Sendable { + // 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 repeatedFeature: [Int32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +// MARK: - Extension support defined in unittest_invalid_features.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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_FeatureSet { + + var Pb_testInvalid: Pb_TestInvalidFeatures { + get {return getExtensionValue(ext: Pb_Extensions_test_invalid) ?? Pb_TestInvalidFeatures()} + set {setExtensionValue(ext: Pb_Extensions_test_invalid, value: newValue)} + } + /// Returns true if extension `Pb_Extensions_test_invalid` + /// has been explicitly set. + var hasPb_testInvalid: Bool { + return hasExtensionValue(ext: Pb_Extensions_test_invalid) + } + /// Clears the value of extension `Pb_Extensions_test_invalid`. + /// Subsequent reads from it will return its default value. + mutating func clearPb_testInvalid() { + clearExtensionValue(ext: Pb_Extensions_test_invalid) + } + +} + +// MARK: - File's ExtensionMap: Pb_UnittestInvalidFeatures_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 Pb_UnittestInvalidFeatures_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Pb_Extensions_test_invalid +] + +// 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 Pb_Extensions_test_invalid = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FeatureSet>( + _protobuf_fieldNumber: 9996, + fieldName: "pb.test_invalid" +) + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "pb" + +extension Pb_TestInvalidFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestInvalidFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}repeated_feature\0") + + 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.decodeRepeatedInt32Field(value: &self.repeatedFeature) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.repeatedFeature.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.repeatedFeature, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Pb_TestInvalidFeatures, rhs: Pb_TestInvalidFeatures) -> Bool { + if lhs.repeatedFeature != rhs.repeatedFeature {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/google/protobuf/unittest_lazy_dependencies.pb.swift b/Reference/upstream/google/protobuf/unittest_lazy_dependencies.pb.swift similarity index 55% rename from Reference/google/protobuf/unittest_lazy_dependencies.pb.swift rename to Reference/upstream/google/protobuf/unittest_lazy_dependencies.pb.swift index a9064b80c..df9e5b959 100644 --- a/Reference/google/protobuf/unittest_lazy_dependencies.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_lazy_dependencies.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/unittest_lazy_dependencies.proto @@ -9,33 +10,10 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd // Author: trafacz@google.com (Todd Rafacz) // Based on original Protocol Buffers design by @@ -43,7 +21,6 @@ // // A proto file we will use for unit testing. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -56,17 +33,17 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_LazyImports_ImportedMessage { +struct Proto2Unittest_LazyImports_ImportedMessage: Sendable { // 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 lazyMessage: ProtobufUnittest_LazyImports_LazyMessage { - get {return _lazyMessage ?? ProtobufUnittest_LazyImports_LazyMessage()} + var lazyMessage: Proto2Unittest_LazyImports_LazyMessage { + get {_lazyMessage ?? Proto2Unittest_LazyImports_LazyMessage()} set {_lazyMessage = newValue} } /// Returns true if `lazyMessage` has been explicitly set. - var hasLazyMessage: Bool {return self._lazyMessage != nil} + var hasLazyMessage: Bool {self._lazyMessage != nil} /// Clears the value of `lazyMessage`. Subsequent reads from it will return its default value. mutating func clearLazyMessage() {self._lazyMessage = nil} @@ -74,10 +51,10 @@ struct ProtobufUnittest_LazyImports_ImportedMessage { init() {} - fileprivate var _lazyMessage: ProtobufUnittest_LazyImports_LazyMessage? = nil + fileprivate var _lazyMessage: Proto2Unittest_LazyImports_LazyMessage? = nil } -struct ProtobufUnittest_LazyImports_MessageCustomOption { +struct Proto2Unittest_LazyImports_MessageCustomOption: Sendable { // 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. @@ -87,7 +64,7 @@ struct ProtobufUnittest_LazyImports_MessageCustomOption { init() {} } -struct ProtobufUnittest_LazyImports_MessageCustomOption2 { +struct Proto2Unittest_LazyImports_MessageCustomOption2: Sendable { // 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. @@ -97,21 +74,13 @@ struct ProtobufUnittest_LazyImports_MessageCustomOption2 { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_LazyImports_ImportedMessage: @unchecked Sendable {} -extension ProtobufUnittest_LazyImports_MessageCustomOption: @unchecked Sendable {} -extension ProtobufUnittest_LazyImports_MessageCustomOption2: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest.lazy_imports" +fileprivate let _protobuf_package = "proto2_unittest.lazy_imports" -extension ProtobufUnittest_LazyImports_ImportedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_LazyImports_ImportedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ImportedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "lazy_message"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}lazy_message\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -136,46 +105,46 @@ extension ProtobufUnittest_LazyImports_ImportedMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_LazyImports_ImportedMessage, rhs: ProtobufUnittest_LazyImports_ImportedMessage) -> Bool { + static func ==(lhs: Proto2Unittest_LazyImports_ImportedMessage, rhs: Proto2Unittest_LazyImports_ImportedMessage) -> Bool { if lhs._lazyMessage != rhs._lazyMessage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_LazyImports_MessageCustomOption: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_LazyImports_MessageCustomOption: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MessageCustomOption" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_LazyImports_MessageCustomOption, rhs: ProtobufUnittest_LazyImports_MessageCustomOption) -> Bool { + static func ==(lhs: Proto2Unittest_LazyImports_MessageCustomOption, rhs: Proto2Unittest_LazyImports_MessageCustomOption) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_LazyImports_MessageCustomOption2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_LazyImports_MessageCustomOption2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MessageCustomOption2" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_LazyImports_MessageCustomOption2, rhs: ProtobufUnittest_LazyImports_MessageCustomOption2) -> Bool { + static func ==(lhs: Proto2Unittest_LazyImports_MessageCustomOption2, rhs: Proto2Unittest_LazyImports_MessageCustomOption2) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } diff --git a/Reference/google/protobuf/unittest_lazy_dependencies_custom_option.pb.swift b/Reference/upstream/google/protobuf/unittest_lazy_dependencies_custom_option.pb.swift similarity index 52% rename from Reference/google/protobuf/unittest_lazy_dependencies_custom_option.pb.swift rename to Reference/upstream/google/protobuf/unittest_lazy_dependencies_custom_option.pb.swift index c49075101..1ef6b50f5 100644 --- a/Reference/google/protobuf/unittest_lazy_dependencies_custom_option.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_lazy_dependencies_custom_option.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/unittest_lazy_dependencies_custom_option.proto @@ -9,33 +10,10 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd // Author: trafacz@google.com (Todd Rafacz) // Based on original Protocol Buffers design by @@ -43,7 +21,6 @@ // // A proto file we will use for unit testing. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -56,17 +33,17 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_LazyImports_LazyMessage { +struct Proto2Unittest_LazyImports_LazyMessage: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -77,66 +54,60 @@ struct ProtobufUnittest_LazyImports_LazyMessage { fileprivate var _a: Int32? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_LazyImports_LazyMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_lazy_dependencies_custom_option.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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_MessageOptions { - var ProtobufUnittest_LazyImports_lazyEnumOption: ProtobufUnittest_LazyImports_LazyEnum { - get {return getExtensionValue(ext: ProtobufUnittest_LazyImports_Extensions_lazy_enum_option) ?? .lazyEnum1} - set {setExtensionValue(ext: ProtobufUnittest_LazyImports_Extensions_lazy_enum_option, value: newValue)} + var Proto2Unittest_LazyImports_lazyEnumOption: Proto2Unittest_LazyImports_LazyEnum { + get {return getExtensionValue(ext: Proto2Unittest_LazyImports_Extensions_lazy_enum_option) ?? .lazyEnum1} + set {setExtensionValue(ext: Proto2Unittest_LazyImports_Extensions_lazy_enum_option, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_LazyImports_Extensions_lazy_enum_option` + /// Returns true if extension `Proto2Unittest_LazyImports_Extensions_lazy_enum_option` /// has been explicitly set. - var hasProtobufUnittest_LazyImports_lazyEnumOption: Bool { - return hasExtensionValue(ext: ProtobufUnittest_LazyImports_Extensions_lazy_enum_option) + var hasProto2Unittest_LazyImports_lazyEnumOption: Bool { + return hasExtensionValue(ext: Proto2Unittest_LazyImports_Extensions_lazy_enum_option) } - /// Clears the value of extension `ProtobufUnittest_LazyImports_Extensions_lazy_enum_option`. + /// Clears the value of extension `Proto2Unittest_LazyImports_Extensions_lazy_enum_option`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_LazyImports_lazyEnumOption() { - clearExtensionValue(ext: ProtobufUnittest_LazyImports_Extensions_lazy_enum_option) + mutating func clearProto2Unittest_LazyImports_lazyEnumOption() { + clearExtensionValue(ext: Proto2Unittest_LazyImports_Extensions_lazy_enum_option) } } -// MARK: - File's ExtensionMap: ProtobufUnittest_LazyImports_UnittestLazyDependenciesCustomOption_Extensions +// MARK: - File's ExtensionMap: Proto2Unittest_LazyImports_UnittestLazyDependenciesCustomOption_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 ProtobufUnittest_LazyImports_UnittestLazyDependenciesCustomOption_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_LazyImports_Extensions_lazy_enum_option +let Proto2Unittest_LazyImports_UnittestLazyDependenciesCustomOption_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Proto2Unittest_LazyImports_Extensions_lazy_enum_option ] // 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 ProtobufUnittest_LazyImports_Extensions_lazy_enum_option = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( +let Proto2Unittest_LazyImports_Extensions_lazy_enum_option = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( _protobuf_fieldNumber: 138596335, - fieldName: "protobuf_unittest.lazy_imports.lazy_enum_option" + fieldName: "proto2_unittest.lazy_imports.lazy_enum_option" ) // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest.lazy_imports" +fileprivate let _protobuf_package = "proto2_unittest.lazy_imports" -extension ProtobufUnittest_LazyImports_LazyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_LazyImports_LazyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".LazyMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -161,7 +132,7 @@ extension ProtobufUnittest_LazyImports_LazyMessage: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_LazyImports_LazyMessage, rhs: ProtobufUnittest_LazyImports_LazyMessage) -> Bool { + static func ==(lhs: Proto2Unittest_LazyImports_LazyMessage, rhs: Proto2Unittest_LazyImports_LazyMessage) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Reference/upstream/google/protobuf/unittest_lazy_dependencies_enum.pb.swift b/Reference/upstream/google/protobuf/unittest_lazy_dependencies_enum.pb.swift new file mode 100644 index 000000000..854bfdb63 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_lazy_dependencies_enum.pb.swift @@ -0,0 +1,50 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_lazy_dependencies_enum.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: trafacz@google.com (Todd Rafacz) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// A proto file we will use for unit testing. + +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 Proto2Unittest_LazyImports_LazyEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case lazyEnum0 = 0 + case lazyEnum1 = 1 + + init() { + self = .lazyEnum0 + } + +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension Proto2Unittest_LazyImports_LazyEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0LAZY_ENUM_0\0\u{1}LAZY_ENUM_1\0") +} diff --git a/Reference/upstream/google/protobuf/unittest_legacy_features.pb.swift b/Reference/upstream/google/protobuf/unittest_legacy_features.pb.swift new file mode 100644 index 000000000..77ef69942 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_legacy_features.pb.swift @@ -0,0 +1,149 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_legacy_features.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Test that features with legacy descriptor helpers get properly converted. + +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 LegacyFeaturesUnittest_TestEditionsMessage: @unchecked Sendable { + // 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 requiredField: Int32 { + get {_storage._requiredField ?? 0} + set {_uniqueStorage()._requiredField = newValue} + } + /// Returns true if `requiredField` has been explicitly set. + var hasRequiredField: Bool {_storage._requiredField != nil} + /// Clears the value of `requiredField`. Subsequent reads from it will return its default value. + mutating func clearRequiredField() {_uniqueStorage()._requiredField = nil} + + var delimitedField: LegacyFeaturesUnittest_TestEditionsMessage { + get {_storage._delimitedField ?? LegacyFeaturesUnittest_TestEditionsMessage()} + set {_uniqueStorage()._delimitedField = newValue} + } + /// Returns true if `delimitedField` has been explicitly set. + var hasDelimitedField: Bool {_storage._delimitedField != nil} + /// Clears the value of `delimitedField`. Subsequent reads from it will return its default value. + mutating func clearDelimitedField() {_uniqueStorage()._delimitedField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "legacy_features_unittest" + +extension LegacyFeaturesUnittest_TestEditionsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEditionsMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_field\0\u{3}delimited_field\0") + + fileprivate class _StorageClass { + var _requiredField: Int32? = nil + var _delimitedField: LegacyFeaturesUnittest_TestEditionsMessage? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _requiredField = source._requiredField + _delimitedField = source._delimitedField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._requiredField == nil {return false} + if let v = _storage._delimitedField, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._requiredField) }() + case 2: try { try decoder.decodeSingularGroupField(value: &_storage._delimitedField) }() + default: break + } + } + } + } + + func traverse(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._requiredField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._delimitedField { + try visitor.visitSingularGroupField(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: LegacyFeaturesUnittest_TestEditionsMessage, rhs: LegacyFeaturesUnittest_TestEditionsMessage) -> 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._requiredField != rhs_storage._requiredField {return false} + if _storage._delimitedField != rhs_storage._delimitedField {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/unittest_lite.pb.swift b/Reference/upstream/google/protobuf/unittest_lite.pb.swift new file mode 100644 index 000000000..c9eebadca --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_lite.pb.swift @@ -0,0 +1,5604 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_lite.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// +// This is like unittest.proto but with optimize_for = LITE_RUNTIME. + +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 Proto2Unittest_ForeignEnumLite: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foreignLiteFoo = 4 + case foreignLiteBaz = 6 + case foreignLiteBar = 5 + + init() { + self = .foreignLiteFoo + } + +} + +enum Proto2Unittest_V1EnumLite: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case v1First = 1 + + init() { + self = .v1First + } + +} + +enum Proto2Unittest_V2EnumLite: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case v2First = 1 + case v2Second = 2 + + init() { + self = .v2First + } + +} + +/// Same as TestAllTypes but with the lite runtime. +struct Proto2Unittest_TestAllTypesLite: @unchecked Sendable { + // 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. + + /// Singular + var optionalInt32: Int32 { + get {_storage._optionalInt32 ?? 0} + set {_uniqueStorage()._optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} + + var optionalInt64: Int64 { + get {_storage._optionalInt64 ?? 0} + set {_uniqueStorage()._optionalInt64 = newValue} + } + /// Returns true if `optionalInt64` has been explicitly set. + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} + /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} + + var optionalUint32: UInt32 { + get {_storage._optionalUint32 ?? 0} + set {_uniqueStorage()._optionalUint32 = newValue} + } + /// Returns true if `optionalUint32` has been explicitly set. + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} + /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} + + var optionalUint64: UInt64 { + get {_storage._optionalUint64 ?? 0} + set {_uniqueStorage()._optionalUint64 = newValue} + } + /// Returns true if `optionalUint64` has been explicitly set. + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} + /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} + + var optionalSint32: Int32 { + get {_storage._optionalSint32 ?? 0} + set {_uniqueStorage()._optionalSint32 = newValue} + } + /// Returns true if `optionalSint32` has been explicitly set. + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} + /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} + + var optionalSint64: Int64 { + get {_storage._optionalSint64 ?? 0} + set {_uniqueStorage()._optionalSint64 = newValue} + } + /// Returns true if `optionalSint64` has been explicitly set. + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} + /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} + + var optionalFixed32: UInt32 { + get {_storage._optionalFixed32 ?? 0} + set {_uniqueStorage()._optionalFixed32 = newValue} + } + /// Returns true if `optionalFixed32` has been explicitly set. + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} + /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} + + var optionalFixed64: UInt64 { + get {_storage._optionalFixed64 ?? 0} + set {_uniqueStorage()._optionalFixed64 = newValue} + } + /// Returns true if `optionalFixed64` has been explicitly set. + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} + /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} + + var optionalSfixed32: Int32 { + get {_storage._optionalSfixed32 ?? 0} + set {_uniqueStorage()._optionalSfixed32 = newValue} + } + /// Returns true if `optionalSfixed32` has been explicitly set. + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} + /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} + + var optionalSfixed64: Int64 { + get {_storage._optionalSfixed64 ?? 0} + set {_uniqueStorage()._optionalSfixed64 = newValue} + } + /// Returns true if `optionalSfixed64` has been explicitly set. + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} + /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} + + var optionalFloat: Float { + get {_storage._optionalFloat ?? 0} + set {_uniqueStorage()._optionalFloat = newValue} + } + /// Returns true if `optionalFloat` has been explicitly set. + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} + /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} + + var optionalDouble: Double { + get {_storage._optionalDouble ?? 0} + set {_uniqueStorage()._optionalDouble = newValue} + } + /// Returns true if `optionalDouble` has been explicitly set. + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} + /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. + mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} + + var optionalBool: Bool { + get {_storage._optionalBool ?? false} + set {_uniqueStorage()._optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {_storage._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} + + var optionalString: String { + get {_storage._optionalString ?? String()} + set {_uniqueStorage()._optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {_storage._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} + + var optionalBytes: Data { + get {_storage._optionalBytes ?? Data()} + set {_uniqueStorage()._optionalBytes = newValue} + } + /// Returns true if `optionalBytes` has been explicitly set. + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} + /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} + + var optionalGroup: Proto2Unittest_TestAllTypesLite.OptionalGroup { + get {_storage._optionalGroup ?? Proto2Unittest_TestAllTypesLite.OptionalGroup()} + set {_uniqueStorage()._optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {_storage._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {_uniqueStorage()._optionalGroup = nil} + + var optionalNestedMessage: Proto2Unittest_TestAllTypesLite.NestedMessage { + get {_storage._optionalNestedMessage ?? Proto2Unittest_TestAllTypesLite.NestedMessage()} + set {_uniqueStorage()._optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} + + var optionalForeignMessage: Proto2Unittest_ForeignMessageLite { + get {_storage._optionalForeignMessage ?? Proto2Unittest_ForeignMessageLite()} + set {_uniqueStorage()._optionalForeignMessage = newValue} + } + /// Returns true if `optionalForeignMessage` has been explicitly set. + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} + /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} + + var optionalImportMessage: Proto2UnittestImport_ImportMessageLite { + get {_storage._optionalImportMessage ?? Proto2UnittestImport_ImportMessageLite()} + set {_uniqueStorage()._optionalImportMessage = newValue} + } + /// Returns true if `optionalImportMessage` has been explicitly set. + var hasOptionalImportMessage: Bool {_storage._optionalImportMessage != nil} + /// Clears the value of `optionalImportMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalImportMessage() {_uniqueStorage()._optionalImportMessage = nil} + + var optionalNestedEnum: Proto2Unittest_TestAllTypesLite.NestedEnum { + get {_storage._optionalNestedEnum ?? .foo} + set {_uniqueStorage()._optionalNestedEnum = newValue} + } + /// Returns true if `optionalNestedEnum` has been explicitly set. + var hasOptionalNestedEnum: Bool {_storage._optionalNestedEnum != nil} + /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} + + var optionalForeignEnum: Proto2Unittest_ForeignEnumLite { + get {_storage._optionalForeignEnum ?? .foreignLiteFoo} + set {_uniqueStorage()._optionalForeignEnum = newValue} + } + /// Returns true if `optionalForeignEnum` has been explicitly set. + var hasOptionalForeignEnum: Bool {_storage._optionalForeignEnum != nil} + /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignEnum() {_uniqueStorage()._optionalForeignEnum = nil} + + var optionalImportEnum: Proto2UnittestImport_ImportEnumLite { + get {_storage._optionalImportEnum ?? .importLiteFoo} + set {_uniqueStorage()._optionalImportEnum = newValue} + } + /// Returns true if `optionalImportEnum` has been explicitly set. + var hasOptionalImportEnum: Bool {_storage._optionalImportEnum != nil} + /// Clears the value of `optionalImportEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalImportEnum() {_uniqueStorage()._optionalImportEnum = nil} + + var optionalStringPiece: String { + get {_storage._optionalStringPiece ?? String()} + set {_uniqueStorage()._optionalStringPiece = newValue} + } + /// Returns true if `optionalStringPiece` has been explicitly set. + var hasOptionalStringPiece: Bool {_storage._optionalStringPiece != nil} + /// Clears the value of `optionalStringPiece`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringPiece() {_uniqueStorage()._optionalStringPiece = nil} + + var optionalCord: String { + get {_storage._optionalCord ?? String()} + set {_uniqueStorage()._optionalCord = newValue} + } + /// Returns true if `optionalCord` has been explicitly set. + var hasOptionalCord: Bool {_storage._optionalCord != nil} + /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. + mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} + + var optionalBytesCord: Data { + get {_storage._optionalBytesCord ?? Data()} + set {_uniqueStorage()._optionalBytesCord = newValue} + } + /// Returns true if `optionalBytesCord` has been explicitly set. + var hasOptionalBytesCord: Bool {_storage._optionalBytesCord != nil} + /// Clears the value of `optionalBytesCord`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytesCord() {_uniqueStorage()._optionalBytesCord = nil} + + /// Defined in unittest_import_public.proto + var optionalPublicImportMessage: Proto2UnittestImport_PublicImportMessageLite { + get {_storage._optionalPublicImportMessage ?? Proto2UnittestImport_PublicImportMessageLite()} + set {_uniqueStorage()._optionalPublicImportMessage = newValue} + } + /// Returns true if `optionalPublicImportMessage` has been explicitly set. + var hasOptionalPublicImportMessage: Bool {_storage._optionalPublicImportMessage != nil} + /// Clears the value of `optionalPublicImportMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalPublicImportMessage() {_uniqueStorage()._optionalPublicImportMessage = nil} + + var optionalLazyMessage: Proto2Unittest_TestAllTypesLite.NestedMessage { + get {_storage._optionalLazyMessage ?? Proto2Unittest_TestAllTypesLite.NestedMessage()} + set {_uniqueStorage()._optionalLazyMessage = newValue} + } + /// Returns true if `optionalLazyMessage` has been explicitly set. + var hasOptionalLazyMessage: Bool {_storage._optionalLazyMessage != nil} + /// Clears the value of `optionalLazyMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalLazyMessage() {_uniqueStorage()._optionalLazyMessage = nil} + + var optionalUnverifiedLazyMessage: Proto2Unittest_TestAllTypesLite.NestedMessage { + get {_storage._optionalUnverifiedLazyMessage ?? Proto2Unittest_TestAllTypesLite.NestedMessage()} + set {_uniqueStorage()._optionalUnverifiedLazyMessage = newValue} + } + /// Returns true if `optionalUnverifiedLazyMessage` has been explicitly set. + var hasOptionalUnverifiedLazyMessage: Bool {_storage._optionalUnverifiedLazyMessage != nil} + /// Clears the value of `optionalUnverifiedLazyMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalUnverifiedLazyMessage() {_uniqueStorage()._optionalUnverifiedLazyMessage = nil} + + /// Repeated + var repeatedInt32: [Int32] { + get {_storage._repeatedInt32} + set {_uniqueStorage()._repeatedInt32 = newValue} + } + + var repeatedInt64: [Int64] { + get {_storage._repeatedInt64} + set {_uniqueStorage()._repeatedInt64 = newValue} + } + + var repeatedUint32: [UInt32] { + get {_storage._repeatedUint32} + set {_uniqueStorage()._repeatedUint32 = newValue} + } + + var repeatedUint64: [UInt64] { + get {_storage._repeatedUint64} + set {_uniqueStorage()._repeatedUint64 = newValue} + } + + var repeatedSint32: [Int32] { + get {_storage._repeatedSint32} + set {_uniqueStorage()._repeatedSint32 = newValue} + } + + var repeatedSint64: [Int64] { + get {_storage._repeatedSint64} + set {_uniqueStorage()._repeatedSint64 = newValue} + } + + var repeatedFixed32: [UInt32] { + get {_storage._repeatedFixed32} + set {_uniqueStorage()._repeatedFixed32 = newValue} + } + + var repeatedFixed64: [UInt64] { + get {_storage._repeatedFixed64} + set {_uniqueStorage()._repeatedFixed64 = newValue} + } + + var repeatedSfixed32: [Int32] { + get {_storage._repeatedSfixed32} + set {_uniqueStorage()._repeatedSfixed32 = newValue} + } + + var repeatedSfixed64: [Int64] { + get {_storage._repeatedSfixed64} + set {_uniqueStorage()._repeatedSfixed64 = newValue} + } + + var repeatedFloat: [Float] { + get {_storage._repeatedFloat} + set {_uniqueStorage()._repeatedFloat = newValue} + } + + var repeatedDouble: [Double] { + get {_storage._repeatedDouble} + set {_uniqueStorage()._repeatedDouble = newValue} + } + + var repeatedBool: [Bool] { + get {_storage._repeatedBool} + set {_uniqueStorage()._repeatedBool = newValue} + } + + var repeatedString: [String] { + get {_storage._repeatedString} + set {_uniqueStorage()._repeatedString = newValue} + } + + var repeatedBytes: [Data] { + get {_storage._repeatedBytes} + set {_uniqueStorage()._repeatedBytes = newValue} + } + + var repeatedGroup: [Proto2Unittest_TestAllTypesLite.RepeatedGroup] { + get {_storage._repeatedGroup} + set {_uniqueStorage()._repeatedGroup = newValue} + } + + var repeatedNestedMessage: [Proto2Unittest_TestAllTypesLite.NestedMessage] { + get {_storage._repeatedNestedMessage} + set {_uniqueStorage()._repeatedNestedMessage = newValue} + } + + var repeatedForeignMessage: [Proto2Unittest_ForeignMessageLite] { + get {_storage._repeatedForeignMessage} + set {_uniqueStorage()._repeatedForeignMessage = newValue} + } + + var repeatedImportMessage: [Proto2UnittestImport_ImportMessageLite] { + get {_storage._repeatedImportMessage} + set {_uniqueStorage()._repeatedImportMessage = newValue} + } + + var repeatedNestedEnum: [Proto2Unittest_TestAllTypesLite.NestedEnum] { + get {_storage._repeatedNestedEnum} + set {_uniqueStorage()._repeatedNestedEnum = newValue} + } + + var repeatedForeignEnum: [Proto2Unittest_ForeignEnumLite] { + get {_storage._repeatedForeignEnum} + set {_uniqueStorage()._repeatedForeignEnum = newValue} + } + + var repeatedImportEnum: [Proto2UnittestImport_ImportEnumLite] { + get {_storage._repeatedImportEnum} + set {_uniqueStorage()._repeatedImportEnum = newValue} + } + + var repeatedStringPiece: [String] { + get {_storage._repeatedStringPiece} + set {_uniqueStorage()._repeatedStringPiece = newValue} + } + + var repeatedCord: [String] { + get {_storage._repeatedCord} + set {_uniqueStorage()._repeatedCord = newValue} + } + + var repeatedLazyMessage: [Proto2Unittest_TestAllTypesLite.NestedMessage] { + get {_storage._repeatedLazyMessage} + set {_uniqueStorage()._repeatedLazyMessage = newValue} + } + + /// Singular with defaults + var defaultInt32: Int32 { + get {_storage._defaultInt32 ?? 41} + set {_uniqueStorage()._defaultInt32 = newValue} + } + /// Returns true if `defaultInt32` has been explicitly set. + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} + /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} + + var defaultInt64: Int64 { + get {_storage._defaultInt64 ?? 42} + set {_uniqueStorage()._defaultInt64 = newValue} + } + /// Returns true if `defaultInt64` has been explicitly set. + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} + /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} + + var defaultUint32: UInt32 { + get {_storage._defaultUint32 ?? 43} + set {_uniqueStorage()._defaultUint32 = newValue} + } + /// Returns true if `defaultUint32` has been explicitly set. + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} + /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} + + var defaultUint64: UInt64 { + get {_storage._defaultUint64 ?? 44} + set {_uniqueStorage()._defaultUint64 = newValue} + } + /// Returns true if `defaultUint64` has been explicitly set. + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} + /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} + + var defaultSint32: Int32 { + get {_storage._defaultSint32 ?? -45} + set {_uniqueStorage()._defaultSint32 = newValue} + } + /// Returns true if `defaultSint32` has been explicitly set. + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} + /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} + + var defaultSint64: Int64 { + get {_storage._defaultSint64 ?? 46} + set {_uniqueStorage()._defaultSint64 = newValue} + } + /// Returns true if `defaultSint64` has been explicitly set. + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} + /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} + + var defaultFixed32: UInt32 { + get {_storage._defaultFixed32 ?? 47} + set {_uniqueStorage()._defaultFixed32 = newValue} + } + /// Returns true if `defaultFixed32` has been explicitly set. + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} + /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} + + var defaultFixed64: UInt64 { + get {_storage._defaultFixed64 ?? 48} + set {_uniqueStorage()._defaultFixed64 = newValue} + } + /// Returns true if `defaultFixed64` has been explicitly set. + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} + /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} + + var defaultSfixed32: Int32 { + get {_storage._defaultSfixed32 ?? 49} + set {_uniqueStorage()._defaultSfixed32 = newValue} + } + /// Returns true if `defaultSfixed32` has been explicitly set. + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} + /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} + + var defaultSfixed64: Int64 { + get {_storage._defaultSfixed64 ?? -50} + set {_uniqueStorage()._defaultSfixed64 = newValue} + } + /// Returns true if `defaultSfixed64` has been explicitly set. + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} + /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} + + var defaultFloat: Float { + get {_storage._defaultFloat ?? 51.5} + set {_uniqueStorage()._defaultFloat = newValue} + } + /// Returns true if `defaultFloat` has been explicitly set. + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} + /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. + mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} + + var defaultDouble: Double { + get {_storage._defaultDouble ?? 52000} + set {_uniqueStorage()._defaultDouble = newValue} + } + /// Returns true if `defaultDouble` has been explicitly set. + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} + /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. + mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} + + var defaultBool: Bool { + get {_storage._defaultBool ?? true} + set {_uniqueStorage()._defaultBool = newValue} + } + /// Returns true if `defaultBool` has been explicitly set. + var hasDefaultBool: Bool {_storage._defaultBool != nil} + /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. + mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} + + var defaultString: String { + get {_storage._defaultString ?? "hello"} + set {_uniqueStorage()._defaultString = newValue} + } + /// Returns true if `defaultString` has been explicitly set. + var hasDefaultString: Bool {_storage._defaultString != nil} + /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. + mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} + + var defaultBytes: Data { + get {_storage._defaultBytes ?? Data([119, 111, 114, 108, 100])} + set {_uniqueStorage()._defaultBytes = newValue} + } + /// Returns true if `defaultBytes` has been explicitly set. + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} + /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. + mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} + + var defaultNestedEnum: Proto2Unittest_TestAllTypesLite.NestedEnum { + get {_storage._defaultNestedEnum ?? .bar} + set {_uniqueStorage()._defaultNestedEnum = newValue} + } + /// Returns true if `defaultNestedEnum` has been explicitly set. + var hasDefaultNestedEnum: Bool {_storage._defaultNestedEnum != nil} + /// Clears the value of `defaultNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearDefaultNestedEnum() {_uniqueStorage()._defaultNestedEnum = nil} + + var defaultForeignEnum: Proto2Unittest_ForeignEnumLite { + get {_storage._defaultForeignEnum ?? .foreignLiteBar} + set {_uniqueStorage()._defaultForeignEnum = newValue} + } + /// Returns true if `defaultForeignEnum` has been explicitly set. + var hasDefaultForeignEnum: Bool {_storage._defaultForeignEnum != nil} + /// Clears the value of `defaultForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearDefaultForeignEnum() {_uniqueStorage()._defaultForeignEnum = nil} + + var defaultImportEnum: Proto2UnittestImport_ImportEnumLite { + get {_storage._defaultImportEnum ?? .importLiteBar} + set {_uniqueStorage()._defaultImportEnum = newValue} + } + /// Returns true if `defaultImportEnum` has been explicitly set. + var hasDefaultImportEnum: Bool {_storage._defaultImportEnum != nil} + /// Clears the value of `defaultImportEnum`. Subsequent reads from it will return its default value. + mutating func clearDefaultImportEnum() {_uniqueStorage()._defaultImportEnum = nil} + + var defaultStringPiece: String { + get {_storage._defaultStringPiece ?? "abc"} + set {_uniqueStorage()._defaultStringPiece = newValue} + } + /// Returns true if `defaultStringPiece` has been explicitly set. + var hasDefaultStringPiece: Bool {_storage._defaultStringPiece != nil} + /// Clears the value of `defaultStringPiece`. Subsequent reads from it will return its default value. + mutating func clearDefaultStringPiece() {_uniqueStorage()._defaultStringPiece = nil} + + var defaultCord: String { + get {_storage._defaultCord ?? "123"} + set {_uniqueStorage()._defaultCord = newValue} + } + /// Returns true if `defaultCord` has been explicitly set. + var hasDefaultCord: Bool {_storage._defaultCord != nil} + /// Clears the value of `defaultCord`. Subsequent reads from it will return its default value. + mutating func clearDefaultCord() {_uniqueStorage()._defaultCord = nil} + + /// For oneof test + var oneofField: OneOf_OneofField? { + get {return _storage._oneofField} + set {_uniqueStorage()._oneofField = newValue} + } + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} + } + + var oneofNestedMessage: Proto2Unittest_TestAllTypesLite.NestedMessage { + get { + if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} + return Proto2Unittest_TestAllTypesLite.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = _storage._oneofField {return v} + return Data() + } + set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} + } + + var oneofLazyNestedMessage: Proto2Unittest_TestAllTypesLite.NestedMessage { + get { + if case .oneofLazyNestedMessage(let v)? = _storage._oneofField {return v} + return Proto2Unittest_TestAllTypesLite.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofLazyNestedMessage(newValue)} + } + + var oneofNestedMessage2: Proto2Unittest_TestAllTypesLite.NestedMessage2 { + get { + if case .oneofNestedMessage2(let v)? = _storage._oneofField {return v} + return Proto2Unittest_TestAllTypesLite.NestedMessage2() + } + set {_uniqueStorage()._oneofField = .oneofNestedMessage2(newValue)} + } + + /// Tests toString for non-repeated fields with a list suffix + var deceptivelyNamedList: Int32 { + get {_storage._deceptivelyNamedList ?? 0} + set {_uniqueStorage()._deceptivelyNamedList = newValue} + } + /// Returns true if `deceptivelyNamedList` has been explicitly set. + var hasDeceptivelyNamedList: Bool {_storage._deceptivelyNamedList != nil} + /// Clears the value of `deceptivelyNamedList`. Subsequent reads from it will return its default value. + mutating func clearDeceptivelyNamedList() {_uniqueStorage()._deceptivelyNamedList = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + /// For oneof test + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofNestedMessage(Proto2Unittest_TestAllTypesLite.NestedMessage) + case oneofString(String) + case oneofBytes(Data) + case oneofLazyNestedMessage(Proto2Unittest_TestAllTypesLite.NestedMessage) + case oneofNestedMessage2(Proto2Unittest_TestAllTypesLite.NestedMessage2) + + } + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 1 + case bar = 2 + case baz = 3 + + init() { + self = .foo + } + + } + + struct NestedMessage: Sendable { + // 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 bb: Int32 { + get {_bb ?? 0} + set {_bb = newValue} + } + /// Returns true if `bb` has been explicitly set. + var hasBb: Bool {self._bb != nil} + /// Clears the value of `bb`. Subsequent reads from it will return its default value. + mutating func clearBb() {self._bb = nil} + + var cc: Int64 { + get {_cc ?? 0} + set {_cc = newValue} + } + /// Returns true if `cc` has been explicitly set. + var hasCc: Bool {self._cc != nil} + /// Clears the value of `cc`. Subsequent reads from it will return its default value. + mutating func clearCc() {self._cc = nil} + + var dd: [Int32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _bb: Int32? = nil + fileprivate var _cc: Int64? = nil + } + + struct NestedMessage2: Sendable { + // 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 dd: Int32 { + get {_dd ?? 0} + set {_dd = newValue} + } + /// Returns true if `dd` has been explicitly set. + var hasDd: Bool {self._dd != nil} + /// Clears the value of `dd`. Subsequent reads from it will return its default value. + mutating func clearDd() {self._dd = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _dd: Int32? = nil + } + + struct OptionalGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + struct RepeatedGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Proto2Unittest_ForeignMessageLite: Sendable { + // 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 c: Int32 { + get {_c ?? 0} + set {_c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {self._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {self._c = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _c: Int32? = nil +} + +struct Proto2Unittest_TestPackedTypesLite: Sendable { + // 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 packedInt32: [Int32] = [] + + var packedInt64: [Int64] = [] + + var packedUint32: [UInt32] = [] + + var packedUint64: [UInt64] = [] + + var packedSint32: [Int32] = [] + + var packedSint64: [Int64] = [] + + var packedFixed32: [UInt32] = [] + + var packedFixed64: [UInt64] = [] + + var packedSfixed32: [Int32] = [] + + var packedSfixed64: [Int64] = [] + + var packedFloat: [Float] = [] + + var packedDouble: [Double] = [] + + var packedBool: [Bool] = [] + + var packedEnum: [Proto2Unittest_ForeignEnumLite] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Proto2Unittest_TestAllExtensionsLite: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +struct Proto2Unittest_OptionalGroup_extension_lite: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil +} + +struct Proto2Unittest_RepeatedGroup_extension_lite: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil +} + +struct Proto2Unittest_TestPackedExtensionsLite: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +struct Proto2Unittest_TestNestedExtensionLite: Sendable { + // 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() {} +} + +/// Test that deprecated fields work. We only verify that they compile (at one +/// point this failed). +struct Proto2Unittest_TestDeprecatedLite: @unchecked Sendable { + // 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. + + /// NOTE: This field was marked as deprecated in the .proto file. + var deprecatedField: Int32 { + get {_storage._deprecatedField ?? 0} + set {_uniqueStorage()._deprecatedField = newValue} + } + /// Returns true if `deprecatedField` has been explicitly set. + var hasDeprecatedField: Bool {_storage._deprecatedField != nil} + /// Clears the value of `deprecatedField`. Subsequent reads from it will return its default value. + mutating func clearDeprecatedField() {_uniqueStorage()._deprecatedField = nil} + + /// NOTE: This field was marked as deprecated in the .proto file. + var deprecatedField2: Int32 { + get {_storage._deprecatedField2 ?? 0} + set {_uniqueStorage()._deprecatedField2 = newValue} + } + /// Returns true if `deprecatedField2` has been explicitly set. + var hasDeprecatedField2: Bool {_storage._deprecatedField2 != nil} + /// Clears the value of `deprecatedField2`. Subsequent reads from it will return its default value. + mutating func clearDeprecatedField2() {_uniqueStorage()._deprecatedField2 = nil} + + /// NOTE: This field was marked as deprecated in the .proto file. + var deprecatedField3: String { + get {_storage._deprecatedField3 ?? String()} + set {_uniqueStorage()._deprecatedField3 = newValue} + } + /// Returns true if `deprecatedField3` has been explicitly set. + var hasDeprecatedField3: Bool {_storage._deprecatedField3 != nil} + /// Clears the value of `deprecatedField3`. Subsequent reads from it will return its default value. + mutating func clearDeprecatedField3() {_uniqueStorage()._deprecatedField3 = nil} + + /// NOTE: This field was marked as deprecated in the .proto file. + var deprecatedField4: Proto2Unittest_TestDeprecatedLite { + get {_storage._deprecatedField4 ?? Proto2Unittest_TestDeprecatedLite()} + set {_uniqueStorage()._deprecatedField4 = newValue} + } + /// Returns true if `deprecatedField4` has been explicitly set. + var hasDeprecatedField4: Bool {_storage._deprecatedField4 != nil} + /// Clears the value of `deprecatedField4`. Subsequent reads from it will return its default value. + mutating func clearDeprecatedField4() {_uniqueStorage()._deprecatedField4 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// See the comments of the same type in unittest.proto. +struct Proto2Unittest_TestParsingMergeLite: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 requiredAllTypes: Proto2Unittest_TestAllTypesLite { + get {_requiredAllTypes ?? Proto2Unittest_TestAllTypesLite()} + set {_requiredAllTypes = newValue} + } + /// Returns true if `requiredAllTypes` has been explicitly set. + var hasRequiredAllTypes: Bool {self._requiredAllTypes != nil} + /// Clears the value of `requiredAllTypes`. Subsequent reads from it will return its default value. + mutating func clearRequiredAllTypes() {self._requiredAllTypes = nil} + + var optionalAllTypes: Proto2Unittest_TestAllTypesLite { + get {_optionalAllTypes ?? Proto2Unittest_TestAllTypesLite()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [Proto2Unittest_TestAllTypesLite] = [] + + var optionalGroup: Proto2Unittest_TestParsingMergeLite.OptionalGroup { + get {_optionalGroup ?? Proto2Unittest_TestParsingMergeLite.OptionalGroup()} + set {_optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {self._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {self._optionalGroup = nil} + + var repeatedGroup: [Proto2Unittest_TestParsingMergeLite.RepeatedGroup] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct RepeatedFieldsGenerator: Sendable { + // 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: [Proto2Unittest_TestAllTypesLite] = [] + + var field2: [Proto2Unittest_TestAllTypesLite] = [] + + var field3: [Proto2Unittest_TestAllTypesLite] = [] + + var group1: [Proto2Unittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group1] = [] + + var group2: [Proto2Unittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group2] = [] + + var ext1: [Proto2Unittest_TestAllTypesLite] = [] + + var ext2: [Proto2Unittest_TestAllTypesLite] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct Group1: Sendable { + // 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: Proto2Unittest_TestAllTypesLite { + get {_field1 ?? Proto2Unittest_TestAllTypesLite()} + set {_field1 = newValue} + } + /// Returns true if `field1` has been explicitly set. + var hasField1: Bool {self._field1 != nil} + /// Clears the value of `field1`. Subsequent reads from it will return its default value. + mutating func clearField1() {self._field1 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _field1: Proto2Unittest_TestAllTypesLite? = nil + } + + struct Group2: Sendable { + // 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: Proto2Unittest_TestAllTypesLite { + get {_field1 ?? Proto2Unittest_TestAllTypesLite()} + set {_field1 = newValue} + } + /// Returns true if `field1` has been explicitly set. + var hasField1: Bool {self._field1 != nil} + /// Clears the value of `field1`. Subsequent reads from it will return its default value. + mutating func clearField1() {self._field1 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _field1: Proto2Unittest_TestAllTypesLite? = nil + } + + init() {} + } + + struct OptionalGroup: Sendable { + // 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 optionalGroupAllTypes: Proto2Unittest_TestAllTypesLite { + get {_optionalGroupAllTypes ?? Proto2Unittest_TestAllTypesLite()} + set {_optionalGroupAllTypes = newValue} + } + /// Returns true if `optionalGroupAllTypes` has been explicitly set. + var hasOptionalGroupAllTypes: Bool {self._optionalGroupAllTypes != nil} + /// Clears the value of `optionalGroupAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroupAllTypes() {self._optionalGroupAllTypes = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalGroupAllTypes: Proto2Unittest_TestAllTypesLite? = nil + } + + struct RepeatedGroup: Sendable { + // 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 repeatedGroupAllTypes: Proto2Unittest_TestAllTypesLite { + get {_repeatedGroupAllTypes ?? Proto2Unittest_TestAllTypesLite()} + set {_repeatedGroupAllTypes = newValue} + } + /// Returns true if `repeatedGroupAllTypes` has been explicitly set. + var hasRepeatedGroupAllTypes: Bool {self._repeatedGroupAllTypes != nil} + /// Clears the value of `repeatedGroupAllTypes`. Subsequent reads from it will return its default value. + mutating func clearRepeatedGroupAllTypes() {self._repeatedGroupAllTypes = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _repeatedGroupAllTypes: Proto2Unittest_TestAllTypesLite? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _requiredAllTypes: Proto2Unittest_TestAllTypesLite? = nil + fileprivate var _optionalAllTypes: Proto2Unittest_TestAllTypesLite? = nil + fileprivate var _optionalGroup: Proto2Unittest_TestParsingMergeLite.OptionalGroup? = nil +} + +/// Test that the correct exception is thrown by parseFrom in a corner case +/// involving merging, extensions, and required fields. +struct Proto2Unittest_TestMergeExceptionLite: Sendable { + // 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 allExtensions: Proto2Unittest_TestAllExtensionsLite { + get {_allExtensions ?? Proto2Unittest_TestAllExtensionsLite()} + set {_allExtensions = newValue} + } + /// Returns true if `allExtensions` has been explicitly set. + var hasAllExtensions: Bool {self._allExtensions != nil} + /// Clears the value of `allExtensions`. Subsequent reads from it will return its default value. + mutating func clearAllExtensions() {self._allExtensions = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _allExtensions: Proto2Unittest_TestAllExtensionsLite? = nil +} + +/// TestEmptyMessageLite is used to test unknown fields support in lite mode. +struct Proto2Unittest_TestEmptyMessageLite: Sendable { + // 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() {} +} + +/// Like above, but declare all field numbers as potential extensions. No +/// actual extensions should ever be defined for this type. +struct Proto2Unittest_TestEmptyMessageWithExtensionsLite: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +struct Proto2Unittest_V1MessageLite: Sendable { + // 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 intField: Int32 { + get {_intField ?? 0} + set {_intField = newValue} + } + /// Returns true if `intField` has been explicitly set. + var hasIntField: Bool {self._intField != nil} + /// Clears the value of `intField`. Subsequent reads from it will return its default value. + mutating func clearIntField() {self._intField = nil} + + var enumField: Proto2Unittest_V1EnumLite { + get {_enumField ?? .v1First} + set {_enumField = newValue} + } + /// Returns true if `enumField` has been explicitly set. + var hasEnumField: Bool {self._enumField != nil} + /// Clears the value of `enumField`. Subsequent reads from it will return its default value. + mutating func clearEnumField() {self._enumField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _intField: Int32? = nil + fileprivate var _enumField: Proto2Unittest_V1EnumLite? = nil +} + +struct Proto2Unittest_V2MessageLite: Sendable { + // 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 intField: Int32 { + get {_intField ?? 0} + set {_intField = newValue} + } + /// Returns true if `intField` has been explicitly set. + var hasIntField: Bool {self._intField != nil} + /// Clears the value of `intField`. Subsequent reads from it will return its default value. + mutating func clearIntField() {self._intField = nil} + + var enumField: Proto2Unittest_V2EnumLite { + get {_enumField ?? .v2First} + set {_enumField = newValue} + } + /// Returns true if `enumField` has been explicitly set. + var hasEnumField: Bool {self._enumField != nil} + /// Clears the value of `enumField`. Subsequent reads from it will return its default value. + mutating func clearEnumField() {self._enumField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _intField: Int32? = nil + fileprivate var _enumField: Proto2Unittest_V2EnumLite? = nil +} + +struct Proto2Unittest_TestHugeFieldNumbersLite: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 optionalInt32: Int32 { + get {_optionalInt32 ?? 0} + set {_optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {self._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {self._optionalInt32 = nil} + + var fixed32: Int32 { + get {_fixed32 ?? 0} + set {_fixed32 = newValue} + } + /// Returns true if `fixed32` has been explicitly set. + var hasFixed32: Bool {self._fixed32 != nil} + /// Clears the value of `fixed32`. Subsequent reads from it will return its default value. + mutating func clearFixed32() {self._fixed32 = nil} + + var repeatedInt32: [Int32] = [] + + var packedInt32: [Int32] = [] + + var optionalEnum: Proto2Unittest_ForeignEnumLite { + get {_optionalEnum ?? .foreignLiteFoo} + set {_optionalEnum = newValue} + } + /// Returns true if `optionalEnum` has been explicitly set. + var hasOptionalEnum: Bool {self._optionalEnum != nil} + /// Clears the value of `optionalEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalEnum() {self._optionalEnum = nil} + + var optionalString: String { + get {_optionalString ?? String()} + set {_optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {self._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {self._optionalString = nil} + + var optionalBytes: Data { + get {_optionalBytes ?? Data()} + set {_optionalBytes = newValue} + } + /// Returns true if `optionalBytes` has been explicitly set. + var hasOptionalBytes: Bool {self._optionalBytes != nil} + /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytes() {self._optionalBytes = nil} + + var optionalMessage: Proto2Unittest_ForeignMessageLite { + get {_optionalMessage ?? Proto2Unittest_ForeignMessageLite()} + set {_optionalMessage = newValue} + } + /// Returns true if `optionalMessage` has been explicitly set. + var hasOptionalMessage: Bool {self._optionalMessage != nil} + /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalMessage() {self._optionalMessage = nil} + + var optionalGroup: Proto2Unittest_TestHugeFieldNumbersLite.OptionalGroup { + get {_optionalGroup ?? Proto2Unittest_TestHugeFieldNumbersLite.OptionalGroup()} + set {_optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {self._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {self._optionalGroup = nil} + + var stringStringMap: Dictionary = [:] + + var oneofField: Proto2Unittest_TestHugeFieldNumbersLite.OneOf_OneofField? = nil + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = oneofField {return v} + return 0 + } + set {oneofField = .oneofUint32(newValue)} + } + + var oneofTestAllTypes: Proto2Unittest_TestAllTypesLite { + get { + if case .oneofTestAllTypes(let v)? = oneofField {return v} + return Proto2Unittest_TestAllTypesLite() + } + set {oneofField = .oneofTestAllTypes(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = oneofField {return v} + return String() + } + set {oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = oneofField {return v} + return Data() + } + set {oneofField = .oneofBytes(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofTestAllTypes(Proto2Unittest_TestAllTypesLite) + case oneofString(String) + case oneofBytes(Data) + + } + + struct OptionalGroup: Sendable { + // 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 groupA: Int32 { + get {_groupA ?? 0} + set {_groupA = newValue} + } + /// Returns true if `groupA` has been explicitly set. + var hasGroupA: Bool {self._groupA != nil} + /// Clears the value of `groupA`. Subsequent reads from it will return its default value. + mutating func clearGroupA() {self._groupA = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupA: Int32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _optionalInt32: Int32? = nil + fileprivate var _fixed32: Int32? = nil + fileprivate var _optionalEnum: Proto2Unittest_ForeignEnumLite? = nil + fileprivate var _optionalString: String? = nil + fileprivate var _optionalBytes: Data? = nil + fileprivate var _optionalMessage: Proto2Unittest_ForeignMessageLite? = nil + fileprivate var _optionalGroup: Proto2Unittest_TestHugeFieldNumbersLite.OptionalGroup? = nil +} + +struct Proto2Unittest_TestOneofParsingLite: Sendable { + // 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 oneofField: Proto2Unittest_TestOneofParsingLite.OneOf_OneofField? = nil + + var oneofInt32: Int32 { + get { + if case .oneofInt32(let v)? = oneofField {return v} + return 0 + } + set {oneofField = .oneofInt32(newValue)} + } + + var oneofSubmessage: Proto2Unittest_TestAllTypesLite { + get { + if case .oneofSubmessage(let v)? = oneofField {return v} + return Proto2Unittest_TestAllTypesLite() + } + set {oneofField = .oneofSubmessage(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = oneofField {return v} + return String() + } + set {oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = oneofField {return v} + return Data([100, 101, 102, 97, 117, 108, 116, 32, 98, 121, 116, 101, 115]) + } + set {oneofField = .oneofBytes(newValue)} + } + + var oneofStringCord: String { + get { + if case .oneofStringCord(let v)? = oneofField {return v} + return "default Cord" + } + set {oneofField = .oneofStringCord(newValue)} + } + + var oneofBytesCord: Data { + get { + if case .oneofBytesCord(let v)? = oneofField {return v} + return Data() + } + set {oneofField = .oneofBytesCord(newValue)} + } + + var oneofStringStringPiece: String { + get { + if case .oneofStringStringPiece(let v)? = oneofField {return v} + return String() + } + set {oneofField = .oneofStringStringPiece(newValue)} + } + + var oneofBytesStringPiece: Data { + get { + if case .oneofBytesStringPiece(let v)? = oneofField {return v} + return Data([100, 101, 102, 97, 117, 108, 116, 32, 83, 116, 114, 105, 110, 103, 80, 105, 101, 99, 101]) + } + set {oneofField = .oneofBytesStringPiece(newValue)} + } + + var oneofEnum: Proto2Unittest_V2EnumLite { + get { + if case .oneofEnum(let v)? = oneofField {return v} + return .v2First + } + set {oneofField = .oneofEnum(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case oneofInt32(Int32) + case oneofSubmessage(Proto2Unittest_TestAllTypesLite) + case oneofString(String) + case oneofBytes(Data) + case oneofStringCord(String) + case oneofBytesCord(Data) + case oneofStringStringPiece(String) + case oneofBytesStringPiece(Data) + case oneofEnum(Proto2Unittest_V2EnumLite) + + } + + init() {} +} + +struct Proto2Unittest_TestMessageSetLite: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +/// The following four messages are set up to test for wire compatibility between +/// packed and non-packed repeated fields. We use the field number 2048, because +/// that is large enough to require a 3-byte varint for the tag. +struct Proto2Unittest_PackedInt32: Sendable { + // 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 repeatedInt32: [Int32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Proto2Unittest_NonPackedInt32: Sendable { + // 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 repeatedInt32: [Int32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Proto2Unittest_PackedFixed32: Sendable { + // 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 repeatedFixed32: [UInt32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Proto2Unittest_NonPackedFixed32: Sendable { + // 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 repeatedFixed32: [UInt32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +/// Test an enum that has multiple values with the same number. +struct Proto2Unittest_DupEnum: Sendable { + // 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() + + enum TestEnumWithDupValueLite: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo1 = 1 + case bar1 = 2 + case baz = 3 + static let foo2 = foo1 + static let bar2 = bar1 + + init() { + self = .foo1 + } + + } + + init() {} +} + +struct Proto2Unittest_RecursiveMessage: @unchecked Sendable { + // 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 recurse: Proto2Unittest_RecursiveMessage { + get {_storage._recurse ?? Proto2Unittest_RecursiveMessage()} + set {_uniqueStorage()._recurse = newValue} + } + /// Returns true if `recurse` has been explicitly set. + var hasRecurse: Bool {_storage._recurse != nil} + /// Clears the value of `recurse`. Subsequent reads from it will return its default value. + mutating func clearRecurse() {_uniqueStorage()._recurse = nil} + + var payload: Data { + get {_storage._payload ?? Data()} + set {_uniqueStorage()._payload = newValue} + } + /// Returns true if `payload` has been explicitly set. + var hasPayload: Bool {_storage._payload != nil} + /// Clears the value of `payload`. Subsequent reads from it will return its default value. + mutating func clearPayload() {_uniqueStorage()._payload = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Proto2Unittest_RecursiveGroup: @unchecked Sendable { + // 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 recurse: Proto2Unittest_RecursiveGroup { + get {_storage._recurse ?? Proto2Unittest_RecursiveGroup()} + set {_uniqueStorage()._recurse = newValue} + } + /// Returns true if `recurse` has been explicitly set. + var hasRecurse: Bool {_storage._recurse != nil} + /// Clears the value of `recurse`. Subsequent reads from it will return its default value. + mutating func clearRecurse() {_uniqueStorage()._recurse = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Extension support defined in unittest_lite.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 Proto2Unittest_TestAllExtensionsLite { + + /// Singular + var Proto2Unittest_optionalInt32ExtensionLite: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_int32_extension_lite) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_int32_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_int32_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalInt32ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_int32_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_int32_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalInt32ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_int32_extension_lite) + } + + var Proto2Unittest_optionalInt64ExtensionLite: Int64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_int64_extension_lite) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_int64_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_int64_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalInt64ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_int64_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_int64_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalInt64ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_int64_extension_lite) + } + + var Proto2Unittest_optionalUint32ExtensionLite: UInt32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_uint32_extension_lite) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_uint32_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_uint32_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalUint32ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_uint32_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_uint32_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalUint32ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_uint32_extension_lite) + } + + var Proto2Unittest_optionalUint64ExtensionLite: UInt64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_uint64_extension_lite) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_uint64_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_uint64_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalUint64ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_uint64_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_uint64_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalUint64ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_uint64_extension_lite) + } + + var Proto2Unittest_optionalSint32ExtensionLite: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_sint32_extension_lite) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_sint32_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_sint32_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalSint32ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_sint32_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_sint32_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalSint32ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_sint32_extension_lite) + } + + var Proto2Unittest_optionalSint64ExtensionLite: Int64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_sint64_extension_lite) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_sint64_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_sint64_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalSint64ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_sint64_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_sint64_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalSint64ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_sint64_extension_lite) + } + + var Proto2Unittest_optionalFixed32ExtensionLite: UInt32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_fixed32_extension_lite) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_fixed32_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_fixed32_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalFixed32ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_fixed32_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_fixed32_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalFixed32ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_fixed32_extension_lite) + } + + var Proto2Unittest_optionalFixed64ExtensionLite: UInt64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_fixed64_extension_lite) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_fixed64_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_fixed64_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalFixed64ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_fixed64_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_fixed64_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalFixed64ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_fixed64_extension_lite) + } + + var Proto2Unittest_optionalSfixed32ExtensionLite: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_sfixed32_extension_lite) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_sfixed32_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_sfixed32_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalSfixed32ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_sfixed32_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_sfixed32_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalSfixed32ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_sfixed32_extension_lite) + } + + var Proto2Unittest_optionalSfixed64ExtensionLite: Int64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_sfixed64_extension_lite) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_sfixed64_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_sfixed64_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalSfixed64ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_sfixed64_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_sfixed64_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalSfixed64ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_sfixed64_extension_lite) + } + + var Proto2Unittest_optionalFloatExtensionLite: Float { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_float_extension_lite) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_float_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_float_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalFloatExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_float_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_float_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalFloatExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_float_extension_lite) + } + + var Proto2Unittest_optionalDoubleExtensionLite: Double { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_double_extension_lite) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_double_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_double_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalDoubleExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_double_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_double_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalDoubleExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_double_extension_lite) + } + + var Proto2Unittest_optionalBoolExtensionLite: Bool { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_bool_extension_lite) ?? false} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_bool_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_bool_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalBoolExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_bool_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_bool_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalBoolExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_bool_extension_lite) + } + + var Proto2Unittest_optionalStringExtensionLite: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_string_extension_lite) ?? String()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_string_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_string_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalStringExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_string_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_string_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalStringExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_string_extension_lite) + } + + var Proto2Unittest_optionalBytesExtensionLite: Data { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_bytes_extension_lite) ?? Data()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_bytes_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_bytes_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalBytesExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_bytes_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_bytes_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalBytesExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_bytes_extension_lite) + } + + var Proto2Unittest_optionalGroupExtensionLite: Proto2Unittest_OptionalGroup_extension_lite { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_OptionalGroup_extension_lite) ?? Proto2Unittest_OptionalGroup_extension_lite()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_OptionalGroup_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_OptionalGroup_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalGroupExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_OptionalGroup_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_OptionalGroup_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalGroupExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_OptionalGroup_extension_lite) + } + + var Proto2Unittest_optionalNestedMessageExtensionLite: Proto2Unittest_TestAllTypesLite.NestedMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_nested_message_extension_lite) ?? Proto2Unittest_TestAllTypesLite.NestedMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_nested_message_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_nested_message_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalNestedMessageExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_nested_message_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_nested_message_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalNestedMessageExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_nested_message_extension_lite) + } + + var Proto2Unittest_optionalForeignMessageExtensionLite: Proto2Unittest_ForeignMessageLite { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_foreign_message_extension_lite) ?? Proto2Unittest_ForeignMessageLite()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_foreign_message_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_foreign_message_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalForeignMessageExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_foreign_message_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_foreign_message_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalForeignMessageExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_foreign_message_extension_lite) + } + + var Proto2Unittest_optionalImportMessageExtensionLite: Proto2UnittestImport_ImportMessageLite { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_import_message_extension_lite) ?? Proto2UnittestImport_ImportMessageLite()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_import_message_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_import_message_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalImportMessageExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_import_message_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_import_message_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalImportMessageExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_import_message_extension_lite) + } + + var Proto2Unittest_optionalNestedEnumExtensionLite: Proto2Unittest_TestAllTypesLite.NestedEnum { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_nested_enum_extension_lite) ?? .foo} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_nested_enum_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_nested_enum_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalNestedEnumExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_nested_enum_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_nested_enum_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalNestedEnumExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_nested_enum_extension_lite) + } + + var Proto2Unittest_optionalForeignEnumExtensionLite: Proto2Unittest_ForeignEnumLite { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_foreign_enum_extension_lite) ?? .foreignLiteFoo} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_foreign_enum_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_foreign_enum_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalForeignEnumExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_foreign_enum_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_foreign_enum_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalForeignEnumExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_foreign_enum_extension_lite) + } + + var Proto2Unittest_optionalImportEnumExtensionLite: Proto2UnittestImport_ImportEnumLite { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_import_enum_extension_lite) ?? .importLiteFoo} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_import_enum_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_import_enum_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalImportEnumExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_import_enum_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_import_enum_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalImportEnumExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_import_enum_extension_lite) + } + + var Proto2Unittest_optionalStringPieceExtensionLite: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_string_piece_extension_lite) ?? String()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_string_piece_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_string_piece_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalStringPieceExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_string_piece_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_string_piece_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalStringPieceExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_string_piece_extension_lite) + } + + /// TODO: ctype=CORD is not supported for extension. Add + /// ctype=CORD option back after it is supported. + var Proto2Unittest_optionalCordExtensionLite: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_cord_extension_lite) ?? String()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_cord_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_cord_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalCordExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_cord_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_cord_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalCordExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_cord_extension_lite) + } + + var Proto2Unittest_optionalBytesCordExtensionLite: Data { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_bytes_cord_extension_lite) ?? Data()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_bytes_cord_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_bytes_cord_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalBytesCordExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_bytes_cord_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_bytes_cord_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalBytesCordExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_bytes_cord_extension_lite) + } + + var Proto2Unittest_optionalPublicImportMessageExtensionLite: Proto2UnittestImport_PublicImportMessageLite { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_public_import_message_extension_lite) ?? Proto2UnittestImport_PublicImportMessageLite()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_public_import_message_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_public_import_message_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalPublicImportMessageExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_public_import_message_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_public_import_message_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalPublicImportMessageExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_public_import_message_extension_lite) + } + + var Proto2Unittest_optionalLazyMessageExtensionLite: Proto2Unittest_TestAllTypesLite.NestedMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_lazy_message_extension_lite) ?? Proto2Unittest_TestAllTypesLite.NestedMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_lazy_message_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_lazy_message_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalLazyMessageExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_lazy_message_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_lazy_message_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalLazyMessageExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_lazy_message_extension_lite) + } + + var Proto2Unittest_optionalUnverifiedLazyMessageExtensionLite: Proto2Unittest_TestAllTypesLite.NestedMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_optional_unverified_lazy_message_extension_lite) ?? Proto2Unittest_TestAllTypesLite.NestedMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_optional_unverified_lazy_message_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_optional_unverified_lazy_message_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_optionalUnverifiedLazyMessageExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_optional_unverified_lazy_message_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_optional_unverified_lazy_message_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_optionalUnverifiedLazyMessageExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_optional_unverified_lazy_message_extension_lite) + } + + /// Repeated + var Proto2Unittest_repeatedInt32ExtensionLite: [Int32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_int32_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_int32_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedInt64ExtensionLite: [Int64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_int64_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_int64_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedUint32ExtensionLite: [UInt32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_uint32_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_uint32_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedUint64ExtensionLite: [UInt64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_uint64_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_uint64_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedSint32ExtensionLite: [Int32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_sint32_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_sint32_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedSint64ExtensionLite: [Int64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_sint64_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_sint64_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedFixed32ExtensionLite: [UInt32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_fixed32_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_fixed32_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedFixed64ExtensionLite: [UInt64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_fixed64_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_fixed64_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedSfixed32ExtensionLite: [Int32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_sfixed32_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_sfixed32_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedSfixed64ExtensionLite: [Int64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_sfixed64_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_sfixed64_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedFloatExtensionLite: [Float] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_float_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_float_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedDoubleExtensionLite: [Double] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_double_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_double_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedBoolExtensionLite: [Bool] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_bool_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_bool_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedStringExtensionLite: [String] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_string_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_string_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedBytesExtensionLite: [Data] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_bytes_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_bytes_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedGroupExtensionLite: [Proto2Unittest_RepeatedGroup_extension_lite] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_RepeatedGroup_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_RepeatedGroup_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedNestedMessageExtensionLite: [Proto2Unittest_TestAllTypesLite.NestedMessage] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_nested_message_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_nested_message_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedForeignMessageExtensionLite: [Proto2Unittest_ForeignMessageLite] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_foreign_message_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_foreign_message_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedImportMessageExtensionLite: [Proto2UnittestImport_ImportMessageLite] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_import_message_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_import_message_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedNestedEnumExtensionLite: [Proto2Unittest_TestAllTypesLite.NestedEnum] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_nested_enum_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_nested_enum_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedForeignEnumExtensionLite: [Proto2Unittest_ForeignEnumLite] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_foreign_enum_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_foreign_enum_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedImportEnumExtensionLite: [Proto2UnittestImport_ImportEnumLite] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_import_enum_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_import_enum_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedStringPieceExtensionLite: [String] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_string_piece_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_string_piece_extension_lite, value: newValue)} + } + + /// TODO: ctype=CORD is not supported for extension. Add + /// ctype=CORD option back after it is supported. + var Proto2Unittest_repeatedCordExtensionLite: [String] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_cord_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_cord_extension_lite, value: newValue)} + } + + var Proto2Unittest_repeatedLazyMessageExtensionLite: [Proto2Unittest_TestAllTypesLite.NestedMessage] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_lazy_message_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_lazy_message_extension_lite, value: newValue)} + } + + /// Singular with defaults + var Proto2Unittest_defaultInt32ExtensionLite: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_int32_extension_lite) ?? 41} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_int32_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_int32_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultInt32ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_int32_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_int32_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultInt32ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_int32_extension_lite) + } + + var Proto2Unittest_defaultInt64ExtensionLite: Int64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_int64_extension_lite) ?? 42} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_int64_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_int64_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultInt64ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_int64_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_int64_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultInt64ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_int64_extension_lite) + } + + var Proto2Unittest_defaultUint32ExtensionLite: UInt32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_uint32_extension_lite) ?? 43} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_uint32_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_uint32_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultUint32ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_uint32_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_uint32_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultUint32ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_uint32_extension_lite) + } + + var Proto2Unittest_defaultUint64ExtensionLite: UInt64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_uint64_extension_lite) ?? 44} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_uint64_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_uint64_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultUint64ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_uint64_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_uint64_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultUint64ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_uint64_extension_lite) + } + + var Proto2Unittest_defaultSint32ExtensionLite: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_sint32_extension_lite) ?? -45} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_sint32_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_sint32_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultSint32ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_sint32_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_sint32_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultSint32ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_sint32_extension_lite) + } + + var Proto2Unittest_defaultSint64ExtensionLite: Int64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_sint64_extension_lite) ?? 46} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_sint64_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_sint64_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultSint64ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_sint64_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_sint64_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultSint64ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_sint64_extension_lite) + } + + var Proto2Unittest_defaultFixed32ExtensionLite: UInt32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_fixed32_extension_lite) ?? 47} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_fixed32_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_fixed32_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultFixed32ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_fixed32_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_fixed32_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultFixed32ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_fixed32_extension_lite) + } + + var Proto2Unittest_defaultFixed64ExtensionLite: UInt64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_fixed64_extension_lite) ?? 48} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_fixed64_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_fixed64_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultFixed64ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_fixed64_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_fixed64_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultFixed64ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_fixed64_extension_lite) + } + + var Proto2Unittest_defaultSfixed32ExtensionLite: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_sfixed32_extension_lite) ?? 49} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_sfixed32_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_sfixed32_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultSfixed32ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_sfixed32_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_sfixed32_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultSfixed32ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_sfixed32_extension_lite) + } + + var Proto2Unittest_defaultSfixed64ExtensionLite: Int64 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_sfixed64_extension_lite) ?? -50} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_sfixed64_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_sfixed64_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultSfixed64ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_sfixed64_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_sfixed64_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultSfixed64ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_sfixed64_extension_lite) + } + + var Proto2Unittest_defaultFloatExtensionLite: Float { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_float_extension_lite) ?? 51.5} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_float_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_float_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultFloatExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_float_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_float_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultFloatExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_float_extension_lite) + } + + var Proto2Unittest_defaultDoubleExtensionLite: Double { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_double_extension_lite) ?? 52000} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_double_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_double_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultDoubleExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_double_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_double_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultDoubleExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_double_extension_lite) + } + + var Proto2Unittest_defaultBoolExtensionLite: Bool { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_bool_extension_lite) ?? true} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_bool_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_bool_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultBoolExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_bool_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_bool_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultBoolExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_bool_extension_lite) + } + + var Proto2Unittest_defaultStringExtensionLite: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_string_extension_lite) ?? "hello"} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_string_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_string_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultStringExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_string_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_string_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultStringExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_string_extension_lite) + } + + var Proto2Unittest_defaultBytesExtensionLite: Data { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_bytes_extension_lite) ?? Data([119, 111, 114, 108, 100])} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_bytes_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_bytes_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultBytesExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_bytes_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_bytes_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultBytesExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_bytes_extension_lite) + } + + var Proto2Unittest_defaultNestedEnumExtensionLite: Proto2Unittest_TestAllTypesLite.NestedEnum { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_nested_enum_extension_lite) ?? .bar} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_nested_enum_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_nested_enum_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultNestedEnumExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_nested_enum_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_nested_enum_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultNestedEnumExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_nested_enum_extension_lite) + } + + var Proto2Unittest_defaultForeignEnumExtensionLite: Proto2Unittest_ForeignEnumLite { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_foreign_enum_extension_lite) ?? .foreignLiteBar} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_foreign_enum_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_foreign_enum_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultForeignEnumExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_foreign_enum_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_foreign_enum_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultForeignEnumExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_foreign_enum_extension_lite) + } + + var Proto2Unittest_defaultImportEnumExtensionLite: Proto2UnittestImport_ImportEnumLite { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_import_enum_extension_lite) ?? .importLiteBar} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_import_enum_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_import_enum_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultImportEnumExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_import_enum_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_import_enum_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultImportEnumExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_import_enum_extension_lite) + } + + var Proto2Unittest_defaultStringPieceExtensionLite: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_string_piece_extension_lite) ?? "abc"} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_string_piece_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_string_piece_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultStringPieceExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_string_piece_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_string_piece_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultStringPieceExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_string_piece_extension_lite) + } + + /// TODO: ctype=CORD is not supported for extension. Add + /// ctype=CORD option back after it is supported. + var Proto2Unittest_defaultCordExtensionLite: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_default_cord_extension_lite) ?? "123"} + set {setExtensionValue(ext: Proto2Unittest_Extensions_default_cord_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_default_cord_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_defaultCordExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_default_cord_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_default_cord_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_defaultCordExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_default_cord_extension_lite) + } + + /// For oneof test + var Proto2Unittest_oneofUint32ExtensionLite: UInt32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_oneof_uint32_extension_lite) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_oneof_uint32_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_oneof_uint32_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_oneofUint32ExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_oneof_uint32_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_oneof_uint32_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_oneofUint32ExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_oneof_uint32_extension_lite) + } + + var Proto2Unittest_oneofNestedMessageExtensionLite: Proto2Unittest_TestAllTypesLite.NestedMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_oneof_nested_message_extension_lite) ?? Proto2Unittest_TestAllTypesLite.NestedMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_oneof_nested_message_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_oneof_nested_message_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_oneofNestedMessageExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_oneof_nested_message_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_oneof_nested_message_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_oneofNestedMessageExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_oneof_nested_message_extension_lite) + } + + var Proto2Unittest_oneofStringExtensionLite: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_oneof_string_extension_lite) ?? String()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_oneof_string_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_oneof_string_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_oneofStringExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_oneof_string_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_oneof_string_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_oneofStringExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_oneof_string_extension_lite) + } + + var Proto2Unittest_oneofBytesExtensionLite: Data { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_oneof_bytes_extension_lite) ?? Data()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_oneof_bytes_extension_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_oneof_bytes_extension_lite` + /// has been explicitly set. + var hasProto2Unittest_oneofBytesExtensionLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_oneof_bytes_extension_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_oneof_bytes_extension_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_oneofBytesExtensionLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_oneof_bytes_extension_lite) + } + + var Proto2Unittest_TestNestedExtensionLite_nestedExtension: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_TestNestedExtensionLite.Extensions.nested_extension) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_TestNestedExtensionLite.Extensions.nested_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestNestedExtensionLite.Extensions.nested_extension` + /// has been explicitly set. + var hasProto2Unittest_TestNestedExtensionLite_nestedExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestNestedExtensionLite.Extensions.nested_extension) + } + /// Clears the value of extension `Proto2Unittest_TestNestedExtensionLite.Extensions.nested_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestNestedExtensionLite_nestedExtension() { + clearExtensionValue(ext: Proto2Unittest_TestNestedExtensionLite.Extensions.nested_extension) + } +} + +extension Proto2Unittest_TestHugeFieldNumbersLite { + + var Proto2Unittest_testAllTypesLite: Proto2Unittest_TestAllTypesLite { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_test_all_types_lite) ?? Proto2Unittest_TestAllTypesLite()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_test_all_types_lite, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_test_all_types_lite` + /// has been explicitly set. + var hasProto2Unittest_testAllTypesLite: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_test_all_types_lite) + } + /// Clears the value of extension `Proto2Unittest_Extensions_test_all_types_lite`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_testAllTypesLite() { + clearExtensionValue(ext: Proto2Unittest_Extensions_test_all_types_lite) + } +} + +extension Proto2Unittest_TestPackedExtensionsLite { + + var Proto2Unittest_packedInt32ExtensionLite: [Int32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_int32_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_int32_extension_lite, value: newValue)} + } + + var Proto2Unittest_packedInt64ExtensionLite: [Int64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_int64_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_int64_extension_lite, value: newValue)} + } + + var Proto2Unittest_packedUint32ExtensionLite: [UInt32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_uint32_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_uint32_extension_lite, value: newValue)} + } + + var Proto2Unittest_packedUint64ExtensionLite: [UInt64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_uint64_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_uint64_extension_lite, value: newValue)} + } + + var Proto2Unittest_packedSint32ExtensionLite: [Int32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_sint32_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_sint32_extension_lite, value: newValue)} + } + + var Proto2Unittest_packedSint64ExtensionLite: [Int64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_sint64_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_sint64_extension_lite, value: newValue)} + } + + var Proto2Unittest_packedFixed32ExtensionLite: [UInt32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_fixed32_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_fixed32_extension_lite, value: newValue)} + } + + var Proto2Unittest_packedFixed64ExtensionLite: [UInt64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_fixed64_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_fixed64_extension_lite, value: newValue)} + } + + var Proto2Unittest_packedSfixed32ExtensionLite: [Int32] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_sfixed32_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_sfixed32_extension_lite, value: newValue)} + } + + var Proto2Unittest_packedSfixed64ExtensionLite: [Int64] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_sfixed64_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_sfixed64_extension_lite, value: newValue)} + } + + var Proto2Unittest_packedFloatExtensionLite: [Float] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_float_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_float_extension_lite, value: newValue)} + } + + var Proto2Unittest_packedDoubleExtensionLite: [Double] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_double_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_double_extension_lite, value: newValue)} + } + + var Proto2Unittest_packedBoolExtensionLite: [Bool] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_bool_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_bool_extension_lite, value: newValue)} + } + + var Proto2Unittest_packedEnumExtensionLite: [Proto2Unittest_ForeignEnumLite] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_packed_enum_extension_lite) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_packed_enum_extension_lite, value: newValue)} + } +} + +extension Proto2Unittest_TestParsingMergeLite { + + var Proto2Unittest_TestParsingMergeLite_optionalExt: Proto2Unittest_TestAllTypesLite { + get {return getExtensionValue(ext: Proto2Unittest_TestParsingMergeLite.Extensions.optional_ext) ?? Proto2Unittest_TestAllTypesLite()} + set {setExtensionValue(ext: Proto2Unittest_TestParsingMergeLite.Extensions.optional_ext, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestParsingMergeLite.Extensions.optional_ext` + /// has been explicitly set. + var hasProto2Unittest_TestParsingMergeLite_optionalExt: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestParsingMergeLite.Extensions.optional_ext) + } + /// Clears the value of extension `Proto2Unittest_TestParsingMergeLite.Extensions.optional_ext`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestParsingMergeLite_optionalExt() { + clearExtensionValue(ext: Proto2Unittest_TestParsingMergeLite.Extensions.optional_ext) + } + + var Proto2Unittest_TestParsingMergeLite_repeatedExt: [Proto2Unittest_TestAllTypesLite] { + get {return getExtensionValue(ext: Proto2Unittest_TestParsingMergeLite.Extensions.repeated_ext) ?? []} + set {setExtensionValue(ext: Proto2Unittest_TestParsingMergeLite.Extensions.repeated_ext, value: newValue)} + } + +} + +// MARK: - File's ExtensionMap: Proto2Unittest_UnittestLite_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 Proto2Unittest_UnittestLite_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Proto2Unittest_Extensions_optional_int32_extension_lite, + Proto2Unittest_Extensions_optional_int64_extension_lite, + Proto2Unittest_Extensions_optional_uint32_extension_lite, + Proto2Unittest_Extensions_optional_uint64_extension_lite, + Proto2Unittest_Extensions_optional_sint32_extension_lite, + Proto2Unittest_Extensions_optional_sint64_extension_lite, + Proto2Unittest_Extensions_optional_fixed32_extension_lite, + Proto2Unittest_Extensions_optional_fixed64_extension_lite, + Proto2Unittest_Extensions_optional_sfixed32_extension_lite, + Proto2Unittest_Extensions_optional_sfixed64_extension_lite, + Proto2Unittest_Extensions_optional_float_extension_lite, + Proto2Unittest_Extensions_optional_double_extension_lite, + Proto2Unittest_Extensions_optional_bool_extension_lite, + Proto2Unittest_Extensions_optional_string_extension_lite, + Proto2Unittest_Extensions_optional_bytes_extension_lite, + Proto2Unittest_Extensions_OptionalGroup_extension_lite, + Proto2Unittest_Extensions_optional_nested_message_extension_lite, + Proto2Unittest_Extensions_optional_foreign_message_extension_lite, + Proto2Unittest_Extensions_optional_import_message_extension_lite, + Proto2Unittest_Extensions_optional_nested_enum_extension_lite, + Proto2Unittest_Extensions_optional_foreign_enum_extension_lite, + Proto2Unittest_Extensions_optional_import_enum_extension_lite, + Proto2Unittest_Extensions_optional_string_piece_extension_lite, + Proto2Unittest_Extensions_optional_cord_extension_lite, + Proto2Unittest_Extensions_optional_bytes_cord_extension_lite, + Proto2Unittest_Extensions_optional_public_import_message_extension_lite, + Proto2Unittest_Extensions_optional_lazy_message_extension_lite, + Proto2Unittest_Extensions_optional_unverified_lazy_message_extension_lite, + Proto2Unittest_Extensions_repeated_int32_extension_lite, + Proto2Unittest_Extensions_repeated_int64_extension_lite, + Proto2Unittest_Extensions_repeated_uint32_extension_lite, + Proto2Unittest_Extensions_repeated_uint64_extension_lite, + Proto2Unittest_Extensions_repeated_sint32_extension_lite, + Proto2Unittest_Extensions_repeated_sint64_extension_lite, + Proto2Unittest_Extensions_repeated_fixed32_extension_lite, + Proto2Unittest_Extensions_repeated_fixed64_extension_lite, + Proto2Unittest_Extensions_repeated_sfixed32_extension_lite, + Proto2Unittest_Extensions_repeated_sfixed64_extension_lite, + Proto2Unittest_Extensions_repeated_float_extension_lite, + Proto2Unittest_Extensions_repeated_double_extension_lite, + Proto2Unittest_Extensions_repeated_bool_extension_lite, + Proto2Unittest_Extensions_repeated_string_extension_lite, + Proto2Unittest_Extensions_repeated_bytes_extension_lite, + Proto2Unittest_Extensions_RepeatedGroup_extension_lite, + Proto2Unittest_Extensions_repeated_nested_message_extension_lite, + Proto2Unittest_Extensions_repeated_foreign_message_extension_lite, + Proto2Unittest_Extensions_repeated_import_message_extension_lite, + Proto2Unittest_Extensions_repeated_nested_enum_extension_lite, + Proto2Unittest_Extensions_repeated_foreign_enum_extension_lite, + Proto2Unittest_Extensions_repeated_import_enum_extension_lite, + Proto2Unittest_Extensions_repeated_string_piece_extension_lite, + Proto2Unittest_Extensions_repeated_cord_extension_lite, + Proto2Unittest_Extensions_repeated_lazy_message_extension_lite, + Proto2Unittest_Extensions_default_int32_extension_lite, + Proto2Unittest_Extensions_default_int64_extension_lite, + Proto2Unittest_Extensions_default_uint32_extension_lite, + Proto2Unittest_Extensions_default_uint64_extension_lite, + Proto2Unittest_Extensions_default_sint32_extension_lite, + Proto2Unittest_Extensions_default_sint64_extension_lite, + Proto2Unittest_Extensions_default_fixed32_extension_lite, + Proto2Unittest_Extensions_default_fixed64_extension_lite, + Proto2Unittest_Extensions_default_sfixed32_extension_lite, + Proto2Unittest_Extensions_default_sfixed64_extension_lite, + Proto2Unittest_Extensions_default_float_extension_lite, + Proto2Unittest_Extensions_default_double_extension_lite, + Proto2Unittest_Extensions_default_bool_extension_lite, + Proto2Unittest_Extensions_default_string_extension_lite, + Proto2Unittest_Extensions_default_bytes_extension_lite, + Proto2Unittest_Extensions_default_nested_enum_extension_lite, + Proto2Unittest_Extensions_default_foreign_enum_extension_lite, + Proto2Unittest_Extensions_default_import_enum_extension_lite, + Proto2Unittest_Extensions_default_string_piece_extension_lite, + Proto2Unittest_Extensions_default_cord_extension_lite, + Proto2Unittest_Extensions_oneof_uint32_extension_lite, + Proto2Unittest_Extensions_oneof_nested_message_extension_lite, + Proto2Unittest_Extensions_oneof_string_extension_lite, + Proto2Unittest_Extensions_oneof_bytes_extension_lite, + Proto2Unittest_Extensions_packed_int32_extension_lite, + Proto2Unittest_Extensions_packed_int64_extension_lite, + Proto2Unittest_Extensions_packed_uint32_extension_lite, + Proto2Unittest_Extensions_packed_uint64_extension_lite, + Proto2Unittest_Extensions_packed_sint32_extension_lite, + Proto2Unittest_Extensions_packed_sint64_extension_lite, + Proto2Unittest_Extensions_packed_fixed32_extension_lite, + Proto2Unittest_Extensions_packed_fixed64_extension_lite, + Proto2Unittest_Extensions_packed_sfixed32_extension_lite, + Proto2Unittest_Extensions_packed_sfixed64_extension_lite, + Proto2Unittest_Extensions_packed_float_extension_lite, + Proto2Unittest_Extensions_packed_double_extension_lite, + Proto2Unittest_Extensions_packed_bool_extension_lite, + Proto2Unittest_Extensions_packed_enum_extension_lite, + Proto2Unittest_Extensions_test_all_types_lite, + Proto2Unittest_TestNestedExtensionLite.Extensions.nested_extension, + Proto2Unittest_TestParsingMergeLite.Extensions.optional_ext, + Proto2Unittest_TestParsingMergeLite.Extensions.repeated_ext +] + +// 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. + +/// Singular +let Proto2Unittest_Extensions_optional_int32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 1, + fieldName: "proto2_unittest.optional_int32_extension_lite" +) + +let Proto2Unittest_Extensions_optional_int64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 2, + fieldName: "proto2_unittest.optional_int64_extension_lite" +) + +let Proto2Unittest_Extensions_optional_uint32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 3, + fieldName: "proto2_unittest.optional_uint32_extension_lite" +) + +let Proto2Unittest_Extensions_optional_uint64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 4, + fieldName: "proto2_unittest.optional_uint64_extension_lite" +) + +let Proto2Unittest_Extensions_optional_sint32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 5, + fieldName: "proto2_unittest.optional_sint32_extension_lite" +) + +let Proto2Unittest_Extensions_optional_sint64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 6, + fieldName: "proto2_unittest.optional_sint64_extension_lite" +) + +let Proto2Unittest_Extensions_optional_fixed32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 7, + fieldName: "proto2_unittest.optional_fixed32_extension_lite" +) + +let Proto2Unittest_Extensions_optional_fixed64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 8, + fieldName: "proto2_unittest.optional_fixed64_extension_lite" +) + +let Proto2Unittest_Extensions_optional_sfixed32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 9, + fieldName: "proto2_unittest.optional_sfixed32_extension_lite" +) + +let Proto2Unittest_Extensions_optional_sfixed64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 10, + fieldName: "proto2_unittest.optional_sfixed64_extension_lite" +) + +let Proto2Unittest_Extensions_optional_float_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 11, + fieldName: "proto2_unittest.optional_float_extension_lite" +) + +let Proto2Unittest_Extensions_optional_double_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 12, + fieldName: "proto2_unittest.optional_double_extension_lite" +) + +let Proto2Unittest_Extensions_optional_bool_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 13, + fieldName: "proto2_unittest.optional_bool_extension_lite" +) + +let Proto2Unittest_Extensions_optional_string_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 14, + fieldName: "proto2_unittest.optional_string_extension_lite" +) + +let Proto2Unittest_Extensions_optional_bytes_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 15, + fieldName: "proto2_unittest.optional_bytes_extension_lite" +) + +let Proto2Unittest_Extensions_OptionalGroup_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 16, + fieldName: "proto2_unittest.optionalgroup_extension_lite" +) + +let Proto2Unittest_Extensions_optional_nested_message_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 18, + fieldName: "proto2_unittest.optional_nested_message_extension_lite" +) + +let Proto2Unittest_Extensions_optional_foreign_message_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 19, + fieldName: "proto2_unittest.optional_foreign_message_extension_lite" +) + +let Proto2Unittest_Extensions_optional_import_message_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 20, + fieldName: "proto2_unittest.optional_import_message_extension_lite" +) + +let Proto2Unittest_Extensions_optional_nested_enum_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 21, + fieldName: "proto2_unittest.optional_nested_enum_extension_lite" +) + +let Proto2Unittest_Extensions_optional_foreign_enum_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 22, + fieldName: "proto2_unittest.optional_foreign_enum_extension_lite" +) + +let Proto2Unittest_Extensions_optional_import_enum_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 23, + fieldName: "proto2_unittest.optional_import_enum_extension_lite" +) + +let Proto2Unittest_Extensions_optional_string_piece_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 24, + fieldName: "proto2_unittest.optional_string_piece_extension_lite" +) + +/// TODO: ctype=CORD is not supported for extension. Add +/// ctype=CORD option back after it is supported. +let Proto2Unittest_Extensions_optional_cord_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 25, + fieldName: "proto2_unittest.optional_cord_extension_lite" +) + +let Proto2Unittest_Extensions_optional_bytes_cord_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 86, + fieldName: "proto2_unittest.optional_bytes_cord_extension_lite" +) + +let Proto2Unittest_Extensions_optional_public_import_message_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 26, + fieldName: "proto2_unittest.optional_public_import_message_extension_lite" +) + +let Proto2Unittest_Extensions_optional_lazy_message_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 27, + fieldName: "proto2_unittest.optional_lazy_message_extension_lite" +) + +let Proto2Unittest_Extensions_optional_unverified_lazy_message_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 28, + fieldName: "proto2_unittest.optional_unverified_lazy_message_extension_lite" +) + +/// Repeated +let Proto2Unittest_Extensions_repeated_int32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 31, + fieldName: "proto2_unittest.repeated_int32_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_int64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 32, + fieldName: "proto2_unittest.repeated_int64_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_uint32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 33, + fieldName: "proto2_unittest.repeated_uint32_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_uint64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 34, + fieldName: "proto2_unittest.repeated_uint64_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_sint32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 35, + fieldName: "proto2_unittest.repeated_sint32_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_sint64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 36, + fieldName: "proto2_unittest.repeated_sint64_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_fixed32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 37, + fieldName: "proto2_unittest.repeated_fixed32_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_fixed64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 38, + fieldName: "proto2_unittest.repeated_fixed64_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_sfixed32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 39, + fieldName: "proto2_unittest.repeated_sfixed32_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_sfixed64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 40, + fieldName: "proto2_unittest.repeated_sfixed64_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_float_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 41, + fieldName: "proto2_unittest.repeated_float_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_double_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 42, + fieldName: "proto2_unittest.repeated_double_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_bool_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 43, + fieldName: "proto2_unittest.repeated_bool_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_string_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 44, + fieldName: "proto2_unittest.repeated_string_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_bytes_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 45, + fieldName: "proto2_unittest.repeated_bytes_extension_lite" +) + +let Proto2Unittest_Extensions_RepeatedGroup_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 46, + fieldName: "proto2_unittest.repeatedgroup_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_nested_message_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 48, + fieldName: "proto2_unittest.repeated_nested_message_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_foreign_message_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 49, + fieldName: "proto2_unittest.repeated_foreign_message_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_import_message_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 50, + fieldName: "proto2_unittest.repeated_import_message_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_nested_enum_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 51, + fieldName: "proto2_unittest.repeated_nested_enum_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_foreign_enum_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 52, + fieldName: "proto2_unittest.repeated_foreign_enum_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_import_enum_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 53, + fieldName: "proto2_unittest.repeated_import_enum_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_string_piece_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 54, + fieldName: "proto2_unittest.repeated_string_piece_extension_lite" +) + +/// TODO: ctype=CORD is not supported for extension. Add +/// ctype=CORD option back after it is supported. +let Proto2Unittest_Extensions_repeated_cord_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 55, + fieldName: "proto2_unittest.repeated_cord_extension_lite" +) + +let Proto2Unittest_Extensions_repeated_lazy_message_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 57, + fieldName: "proto2_unittest.repeated_lazy_message_extension_lite" +) + +/// Singular with defaults +let Proto2Unittest_Extensions_default_int32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 61, + fieldName: "proto2_unittest.default_int32_extension_lite" +) + +let Proto2Unittest_Extensions_default_int64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 62, + fieldName: "proto2_unittest.default_int64_extension_lite" +) + +let Proto2Unittest_Extensions_default_uint32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 63, + fieldName: "proto2_unittest.default_uint32_extension_lite" +) + +let Proto2Unittest_Extensions_default_uint64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 64, + fieldName: "proto2_unittest.default_uint64_extension_lite" +) + +let Proto2Unittest_Extensions_default_sint32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 65, + fieldName: "proto2_unittest.default_sint32_extension_lite" +) + +let Proto2Unittest_Extensions_default_sint64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 66, + fieldName: "proto2_unittest.default_sint64_extension_lite" +) + +let Proto2Unittest_Extensions_default_fixed32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 67, + fieldName: "proto2_unittest.default_fixed32_extension_lite" +) + +let Proto2Unittest_Extensions_default_fixed64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 68, + fieldName: "proto2_unittest.default_fixed64_extension_lite" +) + +let Proto2Unittest_Extensions_default_sfixed32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 69, + fieldName: "proto2_unittest.default_sfixed32_extension_lite" +) + +let Proto2Unittest_Extensions_default_sfixed64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 70, + fieldName: "proto2_unittest.default_sfixed64_extension_lite" +) + +let Proto2Unittest_Extensions_default_float_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 71, + fieldName: "proto2_unittest.default_float_extension_lite" +) + +let Proto2Unittest_Extensions_default_double_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 72, + fieldName: "proto2_unittest.default_double_extension_lite" +) + +let Proto2Unittest_Extensions_default_bool_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 73, + fieldName: "proto2_unittest.default_bool_extension_lite" +) + +let Proto2Unittest_Extensions_default_string_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 74, + fieldName: "proto2_unittest.default_string_extension_lite" +) + +let Proto2Unittest_Extensions_default_bytes_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 75, + fieldName: "proto2_unittest.default_bytes_extension_lite" +) + +let Proto2Unittest_Extensions_default_nested_enum_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 81, + fieldName: "proto2_unittest.default_nested_enum_extension_lite" +) + +let Proto2Unittest_Extensions_default_foreign_enum_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 82, + fieldName: "proto2_unittest.default_foreign_enum_extension_lite" +) + +let Proto2Unittest_Extensions_default_import_enum_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 83, + fieldName: "proto2_unittest.default_import_enum_extension_lite" +) + +let Proto2Unittest_Extensions_default_string_piece_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 84, + fieldName: "proto2_unittest.default_string_piece_extension_lite" +) + +/// TODO: ctype=CORD is not supported for extension. Add +/// ctype=CORD option back after it is supported. +let Proto2Unittest_Extensions_default_cord_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 85, + fieldName: "proto2_unittest.default_cord_extension_lite" +) + +/// For oneof test +let Proto2Unittest_Extensions_oneof_uint32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 111, + fieldName: "proto2_unittest.oneof_uint32_extension_lite" +) + +let Proto2Unittest_Extensions_oneof_nested_message_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 112, + fieldName: "proto2_unittest.oneof_nested_message_extension_lite" +) + +let Proto2Unittest_Extensions_oneof_string_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 113, + fieldName: "proto2_unittest.oneof_string_extension_lite" +) + +let Proto2Unittest_Extensions_oneof_bytes_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 114, + fieldName: "proto2_unittest.oneof_bytes_extension_lite" +) + +let Proto2Unittest_Extensions_packed_int32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensionsLite>( + _protobuf_fieldNumber: 90, + fieldName: "proto2_unittest.packed_int32_extension_lite" +) + +let Proto2Unittest_Extensions_packed_int64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensionsLite>( + _protobuf_fieldNumber: 91, + fieldName: "proto2_unittest.packed_int64_extension_lite" +) + +let Proto2Unittest_Extensions_packed_uint32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensionsLite>( + _protobuf_fieldNumber: 92, + fieldName: "proto2_unittest.packed_uint32_extension_lite" +) + +let Proto2Unittest_Extensions_packed_uint64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensionsLite>( + _protobuf_fieldNumber: 93, + fieldName: "proto2_unittest.packed_uint64_extension_lite" +) + +let Proto2Unittest_Extensions_packed_sint32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensionsLite>( + _protobuf_fieldNumber: 94, + fieldName: "proto2_unittest.packed_sint32_extension_lite" +) + +let Proto2Unittest_Extensions_packed_sint64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensionsLite>( + _protobuf_fieldNumber: 95, + fieldName: "proto2_unittest.packed_sint64_extension_lite" +) + +let Proto2Unittest_Extensions_packed_fixed32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensionsLite>( + _protobuf_fieldNumber: 96, + fieldName: "proto2_unittest.packed_fixed32_extension_lite" +) + +let Proto2Unittest_Extensions_packed_fixed64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensionsLite>( + _protobuf_fieldNumber: 97, + fieldName: "proto2_unittest.packed_fixed64_extension_lite" +) + +let Proto2Unittest_Extensions_packed_sfixed32_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensionsLite>( + _protobuf_fieldNumber: 98, + fieldName: "proto2_unittest.packed_sfixed32_extension_lite" +) + +let Proto2Unittest_Extensions_packed_sfixed64_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensionsLite>( + _protobuf_fieldNumber: 99, + fieldName: "proto2_unittest.packed_sfixed64_extension_lite" +) + +let Proto2Unittest_Extensions_packed_float_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensionsLite>( + _protobuf_fieldNumber: 100, + fieldName: "proto2_unittest.packed_float_extension_lite" +) + +let Proto2Unittest_Extensions_packed_double_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensionsLite>( + _protobuf_fieldNumber: 101, + fieldName: "proto2_unittest.packed_double_extension_lite" +) + +let Proto2Unittest_Extensions_packed_bool_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensionsLite>( + _protobuf_fieldNumber: 102, + fieldName: "proto2_unittest.packed_bool_extension_lite" +) + +let Proto2Unittest_Extensions_packed_enum_extension_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestPackedExtensionsLite>( + _protobuf_fieldNumber: 103, + fieldName: "proto2_unittest.packed_enum_extension_lite" +) + +let Proto2Unittest_Extensions_test_all_types_lite = SwiftProtobuf.MessageExtension, Proto2Unittest_TestHugeFieldNumbersLite>( + _protobuf_fieldNumber: 536860000, + fieldName: "proto2_unittest.test_all_types_lite" +) + +extension Proto2Unittest_TestNestedExtensionLite { + enum Extensions { + static let nested_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestAllExtensionsLite>( + _protobuf_fieldNumber: 12345, + fieldName: "proto2_unittest.TestNestedExtensionLite.nested_extension" + ) + } +} + +extension Proto2Unittest_TestParsingMergeLite { + enum Extensions { + static let optional_ext = SwiftProtobuf.MessageExtension, Proto2Unittest_TestParsingMergeLite>( + _protobuf_fieldNumber: 1000, + fieldName: "proto2_unittest.TestParsingMergeLite.optional_ext" + ) + + static let repeated_ext = SwiftProtobuf.MessageExtension, Proto2Unittest_TestParsingMergeLite>( + _protobuf_fieldNumber: 1001, + fieldName: "proto2_unittest.TestParsingMergeLite.repeated_ext" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest" + +extension Proto2Unittest_ForeignEnumLite: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{4}FOREIGN_LITE_FOO\0\u{1}FOREIGN_LITE_BAR\0\u{1}FOREIGN_LITE_BAZ\0") +} + +extension Proto2Unittest_V1EnumLite: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}V1_FIRST\0") +} + +extension Proto2Unittest_V2EnumLite: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}V2_FIRST\0\u{1}V2_SECOND\0") +} + +extension Proto2Unittest_TestAllTypesLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypesLite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{7}OptionalGroup\0\u{4}\u{2}optional_nested_message\0\u{3}optional_foreign_message\0\u{3}optional_import_message\0\u{3}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{3}optional_import_enum\0\u{3}optional_string_piece\0\u{3}optional_cord\0\u{3}optional_public_import_message\0\u{3}optional_lazy_message\0\u{3}optional_unverified_lazy_message\0\u{4}\u{3}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{7}RepeatedGroup\0\u{4}\u{2}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{3}repeated_import_message\0\u{3}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{3}repeated_import_enum\0\u{3}repeated_string_piece\0\u{3}repeated_cord\0\u{4}\u{2}repeated_lazy_message\0\u{4}\u{4}default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{4}\u{6}default_nested_enum\0\u{3}default_foreign_enum\0\u{3}default_import_enum\0\u{3}default_string_piece\0\u{3}default_cord\0\u{3}optional_bytes_cord\0\u{4}\u{19}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_lazy_nested_message\0\u{3}deceptively_named_list\0\u{3}oneof_nested_message2\0") + + fileprivate class _StorageClass { + var _optionalInt32: Int32? = nil + var _optionalInt64: Int64? = nil + var _optionalUint32: UInt32? = nil + var _optionalUint64: UInt64? = nil + var _optionalSint32: Int32? = nil + var _optionalSint64: Int64? = nil + var _optionalFixed32: UInt32? = nil + var _optionalFixed64: UInt64? = nil + var _optionalSfixed32: Int32? = nil + var _optionalSfixed64: Int64? = nil + var _optionalFloat: Float? = nil + var _optionalDouble: Double? = nil + var _optionalBool: Bool? = nil + var _optionalString: String? = nil + var _optionalBytes: Data? = nil + var _optionalGroup: Proto2Unittest_TestAllTypesLite.OptionalGroup? = nil + var _optionalNestedMessage: Proto2Unittest_TestAllTypesLite.NestedMessage? = nil + var _optionalForeignMessage: Proto2Unittest_ForeignMessageLite? = nil + var _optionalImportMessage: Proto2UnittestImport_ImportMessageLite? = nil + var _optionalNestedEnum: Proto2Unittest_TestAllTypesLite.NestedEnum? = nil + var _optionalForeignEnum: Proto2Unittest_ForeignEnumLite? = nil + var _optionalImportEnum: Proto2UnittestImport_ImportEnumLite? = nil + var _optionalStringPiece: String? = nil + var _optionalCord: String? = nil + var _optionalBytesCord: Data? = nil + var _optionalPublicImportMessage: Proto2UnittestImport_PublicImportMessageLite? = nil + var _optionalLazyMessage: Proto2Unittest_TestAllTypesLite.NestedMessage? = nil + var _optionalUnverifiedLazyMessage: Proto2Unittest_TestAllTypesLite.NestedMessage? = nil + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedGroup: [Proto2Unittest_TestAllTypesLite.RepeatedGroup] = [] + var _repeatedNestedMessage: [Proto2Unittest_TestAllTypesLite.NestedMessage] = [] + var _repeatedForeignMessage: [Proto2Unittest_ForeignMessageLite] = [] + var _repeatedImportMessage: [Proto2UnittestImport_ImportMessageLite] = [] + var _repeatedNestedEnum: [Proto2Unittest_TestAllTypesLite.NestedEnum] = [] + var _repeatedForeignEnum: [Proto2Unittest_ForeignEnumLite] = [] + var _repeatedImportEnum: [Proto2UnittestImport_ImportEnumLite] = [] + var _repeatedStringPiece: [String] = [] + var _repeatedCord: [String] = [] + var _repeatedLazyMessage: [Proto2Unittest_TestAllTypesLite.NestedMessage] = [] + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + var _defaultNestedEnum: Proto2Unittest_TestAllTypesLite.NestedEnum? = nil + var _defaultForeignEnum: Proto2Unittest_ForeignEnumLite? = nil + var _defaultImportEnum: Proto2UnittestImport_ImportEnumLite? = nil + var _defaultStringPiece: String? = nil + var _defaultCord: String? = nil + var _oneofField: Proto2Unittest_TestAllTypesLite.OneOf_OneofField? + var _deceptivelyNamedList: Int32? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalGroup = source._optionalGroup + _optionalNestedMessage = source._optionalNestedMessage + _optionalForeignMessage = source._optionalForeignMessage + _optionalImportMessage = source._optionalImportMessage + _optionalNestedEnum = source._optionalNestedEnum + _optionalForeignEnum = source._optionalForeignEnum + _optionalImportEnum = source._optionalImportEnum + _optionalStringPiece = source._optionalStringPiece + _optionalCord = source._optionalCord + _optionalBytesCord = source._optionalBytesCord + _optionalPublicImportMessage = source._optionalPublicImportMessage + _optionalLazyMessage = source._optionalLazyMessage + _optionalUnverifiedLazyMessage = source._optionalUnverifiedLazyMessage + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedGroup = source._repeatedGroup + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedForeignMessage = source._repeatedForeignMessage + _repeatedImportMessage = source._repeatedImportMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _repeatedForeignEnum = source._repeatedForeignEnum + _repeatedImportEnum = source._repeatedImportEnum + _repeatedStringPiece = source._repeatedStringPiece + _repeatedCord = source._repeatedCord + _repeatedLazyMessage = source._repeatedLazyMessage + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + _defaultNestedEnum = source._defaultNestedEnum + _defaultForeignEnum = source._defaultForeignEnum + _defaultImportEnum = source._defaultImportEnum + _defaultStringPiece = source._defaultStringPiece + _defaultCord = source._defaultCord + _oneofField = source._oneofField + _deceptivelyNamedList = source._deceptivelyNamedList + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 16: try { try decoder.decodeSingularGroupField(value: &_storage._optionalGroup) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() + case 20: try { try decoder.decodeSingularMessageField(value: &_storage._optionalImportMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() + case 23: try { try decoder.decodeSingularEnumField(value: &_storage._optionalImportEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() + case 26: try { try decoder.decodeSingularMessageField(value: &_storage._optionalPublicImportMessage) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._optionalLazyMessage) }() + case 28: try { try decoder.decodeSingularMessageField(value: &_storage._optionalUnverifiedLazyMessage) }() + case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() + case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() + case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() + case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() + case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() + case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() + case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() + case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() + case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() + case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() + case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() + case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() + case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() + case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() + case 46: try { try decoder.decodeRepeatedGroupField(value: &_storage._repeatedGroup) }() + case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() + case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() + case 50: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedImportMessage) }() + case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() + case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() + case 53: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedImportEnum) }() + case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() + case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() + case 57: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedLazyMessage) }() + case 61: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 62: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 63: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 64: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 65: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 66: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 67: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 68: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 69: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 70: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 71: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 72: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 73: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 74: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 75: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() + case 81: try { try decoder.decodeSingularEnumField(value: &_storage._defaultNestedEnum) }() + case 82: try { try decoder.decodeSingularEnumField(value: &_storage._defaultForeignEnum) }() + case 83: try { try decoder.decodeSingularEnumField(value: &_storage._defaultImportEnum) }() + case 84: try { try decoder.decodeSingularStringField(value: &_storage._defaultStringPiece) }() + case 85: try { try decoder.decodeSingularStringField(value: &_storage._defaultCord) }() + case 86: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytesCord) }() + case 111: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 112: try { + var v: Proto2Unittest_TestAllTypesLite.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage(v) + } + }() + case 113: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 114: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() + case 115: try { + var v: Proto2Unittest_TestAllTypesLite.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofLazyNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofLazyNestedMessage(v) + } + }() + case 116: try { try decoder.decodeSingularInt32Field(value: &_storage._deceptivelyNamedList) }() + case 117: try { + var v: Proto2Unittest_TestAllTypesLite.NestedMessage2? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage2(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage2(v) + } + }() + default: break + } + } + } + } + + func traverse(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._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._optionalInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._optionalUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._optionalSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._optionalSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._optionalFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._optionalFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._optionalSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._optionalSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._optionalFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._optionalDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._optionalBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._optionalForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._optionalImportMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 20) + } }() + try { if let v = _storage._optionalNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._optionalForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._optionalImportEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 23) + } }() + try { if let v = _storage._optionalStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._optionalCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._optionalPublicImportMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 26) + } }() + try { if let v = _storage._optionalLazyMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + try { if let v = _storage._optionalUnverifiedLazyMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 28) + } }() + if !_storage._repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + } + if !_storage._repeatedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + } + if !_storage._repeatedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + } + if !_storage._repeatedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + } + if !_storage._repeatedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + } + if !_storage._repeatedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + } + if !_storage._repeatedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + } + if !_storage._repeatedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + } + if !_storage._repeatedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + } + if !_storage._repeatedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + } + if !_storage._repeatedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + } + if !_storage._repeatedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + } + if !_storage._repeatedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + } + if !_storage._repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) + } + if !_storage._repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) + } + if !_storage._repeatedGroup.isEmpty { + try visitor.visitRepeatedGroupField(value: _storage._repeatedGroup, fieldNumber: 46) + } + if !_storage._repeatedNestedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) + } + if !_storage._repeatedForeignMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) + } + if !_storage._repeatedImportMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedImportMessage, fieldNumber: 50) + } + if !_storage._repeatedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + } + if !_storage._repeatedForeignEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) + } + if !_storage._repeatedImportEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedImportEnum, fieldNumber: 53) + } + if !_storage._repeatedStringPiece.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) + } + if !_storage._repeatedCord.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) + } + if !_storage._repeatedLazyMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedLazyMessage, fieldNumber: 57) + } + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 61) + } }() + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 62) + } }() + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63) + } }() + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 64) + } }() + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 65) + } }() + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 66) + } }() + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 67) + } }() + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 68) + } }() + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 69) + } }() + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 70) + } }() + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 71) + } }() + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 72) + } }() + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 73) + } }() + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 74) + } }() + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 75) + } }() + try { if let v = _storage._defaultNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 81) + } }() + try { if let v = _storage._defaultForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 82) + } }() + try { if let v = _storage._defaultImportEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 83) + } }() + try { if let v = _storage._defaultStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 84) + } }() + try { if let v = _storage._defaultCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 85) + } }() + try { if let v = _storage._optionalBytesCord { + try visitor.visitSingularBytesField(value: v, fieldNumber: 86) + } }() + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case .oneofLazyNestedMessage?: try { + guard case .oneofLazyNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 115) + }() + default: break + } + try { if let v = _storage._deceptivelyNamedList { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 116) + } }() + try { if case .oneofNestedMessage2(let v)? = _storage._oneofField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 117) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestAllTypesLite, rhs: Proto2Unittest_TestAllTypesLite) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalGroup != rhs_storage._optionalGroup {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} + if _storage._optionalImportMessage != rhs_storage._optionalImportMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} + if _storage._optionalImportEnum != rhs_storage._optionalImportEnum {return false} + if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} + if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._optionalBytesCord != rhs_storage._optionalBytesCord {return false} + if _storage._optionalPublicImportMessage != rhs_storage._optionalPublicImportMessage {return false} + if _storage._optionalLazyMessage != rhs_storage._optionalLazyMessage {return false} + if _storage._optionalUnverifiedLazyMessage != rhs_storage._optionalUnverifiedLazyMessage {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedGroup != rhs_storage._repeatedGroup {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} + if _storage._repeatedImportMessage != rhs_storage._repeatedImportMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} + if _storage._repeatedImportEnum != rhs_storage._repeatedImportEnum {return false} + if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} + if _storage._repeatedCord != rhs_storage._repeatedCord {return false} + if _storage._repeatedLazyMessage != rhs_storage._repeatedLazyMessage {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} + if _storage._defaultNestedEnum != rhs_storage._defaultNestedEnum {return false} + if _storage._defaultForeignEnum != rhs_storage._defaultForeignEnum {return false} + if _storage._defaultImportEnum != rhs_storage._defaultImportEnum {return false} + if _storage._defaultStringPiece != rhs_storage._defaultStringPiece {return false} + if _storage._defaultCord != rhs_storage._defaultCord {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + if _storage._deceptivelyNamedList != rhs_storage._deceptivelyNamedList {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestAllTypesLite.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension Proto2Unittest_TestAllTypesLite.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestAllTypesLite.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0\u{1}cc\0\u{1}dd\0") + + 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._bb) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &self._cc) }() + case 3: try { try decoder.decodeRepeatedInt32Field(value: &self.dd) }() + 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 + try { if let v = self._bb { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._cc { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + if !self.dd.isEmpty { + try visitor.visitPackedInt32Field(value: self.dd, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestAllTypesLite.NestedMessage, rhs: Proto2Unittest_TestAllTypesLite.NestedMessage) -> Bool { + if lhs._bb != rhs._bb {return false} + if lhs._cc != rhs._cc {return false} + if lhs.dd != rhs.dd {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestAllTypesLite.NestedMessage2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestAllTypesLite.protoMessageName + ".NestedMessage2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}dd\0") + + 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._dd) }() + 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 + try { if let v = self._dd { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestAllTypesLite.NestedMessage2, rhs: Proto2Unittest_TestAllTypesLite.NestedMessage2) -> Bool { + if lhs._dd != rhs._dd {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestAllTypesLite.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestAllTypesLite.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{11}a\0") + + 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestAllTypesLite.OptionalGroup, rhs: Proto2Unittest_TestAllTypesLite.OptionalGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestAllTypesLite.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestAllTypesLite.protoMessageName + ".RepeatedGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}/a\0") + + 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 47: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestAllTypesLite.RepeatedGroup, rhs: Proto2Unittest_TestAllTypesLite.RepeatedGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_ForeignMessageLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessageLite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") + + 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._c) }() + 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 + try { if let v = self._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_ForeignMessageLite, rhs: Proto2Unittest_ForeignMessageLite) -> Bool { + if lhs._c != rhs._c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestPackedTypesLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestPackedTypesLite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}Z\u{1}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_enum\0") + + 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 90: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32) }() + case 91: try { try decoder.decodeRepeatedInt64Field(value: &self.packedInt64) }() + case 92: try { try decoder.decodeRepeatedUInt32Field(value: &self.packedUint32) }() + case 93: try { try decoder.decodeRepeatedUInt64Field(value: &self.packedUint64) }() + case 94: try { try decoder.decodeRepeatedSInt32Field(value: &self.packedSint32) }() + case 95: try { try decoder.decodeRepeatedSInt64Field(value: &self.packedSint64) }() + case 96: try { try decoder.decodeRepeatedFixed32Field(value: &self.packedFixed32) }() + case 97: try { try decoder.decodeRepeatedFixed64Field(value: &self.packedFixed64) }() + case 98: try { try decoder.decodeRepeatedSFixed32Field(value: &self.packedSfixed32) }() + case 99: try { try decoder.decodeRepeatedSFixed64Field(value: &self.packedSfixed64) }() + case 100: try { try decoder.decodeRepeatedFloatField(value: &self.packedFloat) }() + case 101: try { try decoder.decodeRepeatedDoubleField(value: &self.packedDouble) }() + case 102: try { try decoder.decodeRepeatedBoolField(value: &self.packedBool) }() + case 103: try { try decoder.decodeRepeatedEnumField(value: &self.packedEnum) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: self.packedInt32, fieldNumber: 90) + } + if !self.packedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: self.packedInt64, fieldNumber: 91) + } + if !self.packedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: self.packedUint32, fieldNumber: 92) + } + if !self.packedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: self.packedUint64, fieldNumber: 93) + } + if !self.packedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: self.packedSint32, fieldNumber: 94) + } + if !self.packedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: self.packedSint64, fieldNumber: 95) + } + if !self.packedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: self.packedFixed32, fieldNumber: 96) + } + if !self.packedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: self.packedFixed64, fieldNumber: 97) + } + if !self.packedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: self.packedSfixed32, fieldNumber: 98) + } + if !self.packedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: self.packedSfixed64, fieldNumber: 99) + } + if !self.packedFloat.isEmpty { + try visitor.visitPackedFloatField(value: self.packedFloat, fieldNumber: 100) + } + if !self.packedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: self.packedDouble, fieldNumber: 101) + } + if !self.packedBool.isEmpty { + try visitor.visitPackedBoolField(value: self.packedBool, fieldNumber: 102) + } + if !self.packedEnum.isEmpty { + try visitor.visitPackedEnumField(value: self.packedEnum, fieldNumber: 103) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestPackedTypesLite, rhs: Proto2Unittest_TestPackedTypesLite) -> Bool { + if lhs.packedInt32 != rhs.packedInt32 {return false} + if lhs.packedInt64 != rhs.packedInt64 {return false} + if lhs.packedUint32 != rhs.packedUint32 {return false} + if lhs.packedUint64 != rhs.packedUint64 {return false} + if lhs.packedSint32 != rhs.packedSint32 {return false} + if lhs.packedSint64 != rhs.packedSint64 {return false} + if lhs.packedFixed32 != rhs.packedFixed32 {return false} + if lhs.packedFixed64 != rhs.packedFixed64 {return false} + if lhs.packedSfixed32 != rhs.packedSfixed32 {return false} + if lhs.packedSfixed64 != rhs.packedSfixed64 {return false} + if lhs.packedFloat != rhs.packedFloat {return false} + if lhs.packedDouble != rhs.packedDouble {return false} + if lhs.packedBool != rhs.packedBool {return false} + if lhs.packedEnum != rhs.packedEnum {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestAllExtensionsLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllExtensionsLite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestAllExtensionsLite.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestAllExtensionsLite, rhs: Proto2Unittest_TestAllExtensionsLite) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_OptionalGroup_extension_lite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OptionalGroup_extension_lite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{11}a\0") + + 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_OptionalGroup_extension_lite, rhs: Proto2Unittest_OptionalGroup_extension_lite) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_RepeatedGroup_extension_lite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".RepeatedGroup_extension_lite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}/a\0") + + 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 47: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_RepeatedGroup_extension_lite, rhs: Proto2Unittest_RepeatedGroup_extension_lite) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestPackedExtensionsLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestPackedExtensionsLite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestPackedExtensionsLite.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestPackedExtensionsLite, rhs: Proto2Unittest_TestPackedExtensionsLite) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TestNestedExtensionLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedExtensionLite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestNestedExtensionLite, rhs: Proto2Unittest_TestNestedExtensionLite) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestDeprecatedLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestDeprecatedLite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}deprecated_field\0\u{3}deprecated_field2\0\u{3}deprecated_field3\0\u{3}deprecated_field4\0") + + fileprivate class _StorageClass { + var _deprecatedField: Int32? = nil + var _deprecatedField2: Int32? = nil + var _deprecatedField3: String? = nil + var _deprecatedField4: Proto2Unittest_TestDeprecatedLite? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _deprecatedField = source._deprecatedField + _deprecatedField2 = source._deprecatedField2 + _deprecatedField3 = source._deprecatedField3 + _deprecatedField4 = source._deprecatedField4 + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._deprecatedField2 == nil {return false} + if let v = _storage._deprecatedField4, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._deprecatedField) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._deprecatedField2) }() + case 3: try { try decoder.decodeSingularStringField(value: &_storage._deprecatedField3) }() + case 4: try { try decoder.decodeSingularMessageField(value: &_storage._deprecatedField4) }() + default: break + } + } + } + } + + func traverse(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._deprecatedField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._deprecatedField2 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._deprecatedField3 { + try visitor.visitSingularStringField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._deprecatedField4 { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestDeprecatedLite, rhs: Proto2Unittest_TestDeprecatedLite) -> 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._deprecatedField != rhs_storage._deprecatedField {return false} + if _storage._deprecatedField2 != rhs_storage._deprecatedField2 {return false} + if _storage._deprecatedField3 != rhs_storage._deprecatedField3 {return false} + if _storage._deprecatedField4 != rhs_storage._deprecatedField4 {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestParsingMergeLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestParsingMergeLite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_all_types\0\u{3}optional_all_types\0\u{3}repeated_all_types\0\u{8}\u{7}OptionalGroup\0\u{8}\u{a}RepeatedGroup\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + if self._requiredAllTypes == nil {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._requiredAllTypes) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 10: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() + case 20: try { try decoder.decodeRepeatedGroupField(value: &self.repeatedGroup) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestParsingMergeLite.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._requiredAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 3) + } + try { if let v = self._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 10) + } }() + if !self.repeatedGroup.isEmpty { + try visitor.visitRepeatedGroupField(value: self.repeatedGroup, fieldNumber: 20) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestParsingMergeLite, rhs: Proto2Unittest_TestParsingMergeLite) -> Bool { + if lhs._requiredAllTypes != rhs._requiredAllTypes {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs._optionalGroup != rhs._optionalGroup {return false} + if lhs.repeatedGroup != rhs.repeatedGroup {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TestParsingMergeLite.RepeatedFieldsGenerator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestParsingMergeLite.protoMessageName + ".RepeatedFieldsGenerator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field1\0\u{1}field2\0\u{1}field3\0\u{8}\u{7}Group1\0\u{8}\u{a}Group2\0\u{2}T\u{f}ext1\0\u{1}ext2\0") + + 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.decodeRepeatedMessageField(value: &self.field1) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.field2) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &self.field3) }() + case 10: try { try decoder.decodeRepeatedGroupField(value: &self.group1) }() + case 20: try { try decoder.decodeRepeatedGroupField(value: &self.group2) }() + case 1000: try { try decoder.decodeRepeatedMessageField(value: &self.ext1) }() + case 1001: try { try decoder.decodeRepeatedMessageField(value: &self.ext2) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.field1.isEmpty { + try visitor.visitRepeatedMessageField(value: self.field1, fieldNumber: 1) + } + if !self.field2.isEmpty { + try visitor.visitRepeatedMessageField(value: self.field2, fieldNumber: 2) + } + if !self.field3.isEmpty { + try visitor.visitRepeatedMessageField(value: self.field3, fieldNumber: 3) + } + if !self.group1.isEmpty { + try visitor.visitRepeatedGroupField(value: self.group1, fieldNumber: 10) + } + if !self.group2.isEmpty { + try visitor.visitRepeatedGroupField(value: self.group2, fieldNumber: 20) + } + if !self.ext1.isEmpty { + try visitor.visitRepeatedMessageField(value: self.ext1, fieldNumber: 1000) + } + if !self.ext2.isEmpty { + try visitor.visitRepeatedMessageField(value: self.ext2, fieldNumber: 1001) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestParsingMergeLite.RepeatedFieldsGenerator, rhs: Proto2Unittest_TestParsingMergeLite.RepeatedFieldsGenerator) -> Bool { + if lhs.field1 != rhs.field1 {return false} + if lhs.field2 != rhs.field2 {return false} + if lhs.field3 != rhs.field3 {return false} + if lhs.group1 != rhs.group1 {return false} + if lhs.group2 != rhs.group2 {return false} + if lhs.ext1 != rhs.ext1 {return false} + if lhs.ext2 != rhs.ext2 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestParsingMergeLite.RepeatedFieldsGenerator.protoMessageName + ".Group1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{b}field1\0") + + 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 11: try { try decoder.decodeSingularMessageField(value: &self._field1) }() + 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 + try { if let v = self._field1 { + try visitor.visitSingularMessageField(value: v, fieldNumber: 11) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group1, rhs: Proto2Unittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group1) -> Bool { + if lhs._field1 != rhs._field1 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestParsingMergeLite.RepeatedFieldsGenerator.protoMessageName + ".Group2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{15}field1\0") + + 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 21: try { try decoder.decodeSingularMessageField(value: &self._field1) }() + 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 + try { if let v = self._field1 { + try visitor.visitSingularMessageField(value: v, fieldNumber: 21) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group2, rhs: Proto2Unittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group2) -> Bool { + if lhs._field1 != rhs._field1 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestParsingMergeLite.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestParsingMergeLite.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{b}optional_group_all_types\0") + + 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 11: try { try decoder.decodeSingularMessageField(value: &self._optionalGroupAllTypes) }() + 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 + try { if let v = self._optionalGroupAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 11) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestParsingMergeLite.OptionalGroup, rhs: Proto2Unittest_TestParsingMergeLite.OptionalGroup) -> Bool { + if lhs._optionalGroupAllTypes != rhs._optionalGroupAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestParsingMergeLite.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestParsingMergeLite.protoMessageName + ".RepeatedGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{15}repeated_group_all_types\0") + + 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 21: try { try decoder.decodeSingularMessageField(value: &self._repeatedGroupAllTypes) }() + 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 + try { if let v = self._repeatedGroupAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 21) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestParsingMergeLite.RepeatedGroup, rhs: Proto2Unittest_TestParsingMergeLite.RepeatedGroup) -> Bool { + if lhs._repeatedGroupAllTypes != rhs._repeatedGroupAllTypes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMergeExceptionLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMergeExceptionLite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}all_extensions\0") + + public var isInitialized: Bool { + if let v = self._allExtensions, !v.isInitialized {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._allExtensions) }() + 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 + try { if let v = self._allExtensions { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMergeExceptionLite, rhs: Proto2Unittest_TestMergeExceptionLite) -> Bool { + if lhs._allExtensions != rhs._allExtensions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestEmptyMessageLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEmptyMessageLite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestEmptyMessageLite, rhs: Proto2Unittest_TestEmptyMessageLite) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestEmptyMessageWithExtensionsLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEmptyMessageWithExtensionsLite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestEmptyMessageWithExtensionsLite.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestEmptyMessageWithExtensionsLite, rhs: Proto2Unittest_TestEmptyMessageWithExtensionsLite) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_V1MessageLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".V1MessageLite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}int_field\0\u{3}enum_field\0") + + public var isInitialized: Bool { + if self._intField == nil {return false} + return true + } + + 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._intField) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self._enumField) }() + 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 + try { if let v = self._intField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._enumField { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_V1MessageLite, rhs: Proto2Unittest_V1MessageLite) -> Bool { + if lhs._intField != rhs._intField {return false} + if lhs._enumField != rhs._enumField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_V2MessageLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".V2MessageLite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}int_field\0\u{3}enum_field\0") + + public var isInitialized: Bool { + if self._intField == nil {return false} + return true + } + + 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._intField) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self._enumField) }() + 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 + try { if let v = self._intField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._enumField { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_V2MessageLite, rhs: Proto2Unittest_V2MessageLite) -> Bool { + if lhs._intField != rhs._intField {return false} + if lhs._enumField != rhs._enumField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestHugeFieldNumbersLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestHugeFieldNumbersLite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}pq\u{7f}\u{7f}\u{1f}optional_int32\0\u{3}fixed_32\0\u{3}repeated_int32\0\u{3}packed_int32\0\u{3}optional_enum\0\u{3}optional_string\0\u{3}optional_bytes\0\u{3}optional_message\0\u{7}OptionalGroup\0\u{4}\u{2}string_string_map\0\u{3}oneof_uint32\0\u{3}oneof_test_all_types\0\u{3}oneof_string\0\u{3}oneof_bytes\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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 536870000: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32) }() + case 536870001: try { try decoder.decodeSingularInt32Field(value: &self._fixed32) }() + case 536870002: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() + case 536870003: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32) }() + case 536870004: try { try decoder.decodeSingularEnumField(value: &self._optionalEnum) }() + case 536870005: try { try decoder.decodeSingularStringField(value: &self._optionalString) }() + case 536870006: try { try decoder.decodeSingularBytesField(value: &self._optionalBytes) }() + case 536870007: try { try decoder.decodeSingularMessageField(value: &self._optionalMessage) }() + case 536870008: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() + case 536870010: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.stringStringMap) }() + case 536870011: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .oneofUint32(v) + } + }() + case 536870012: try { + var v: Proto2Unittest_TestAllTypesLite? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .oneofTestAllTypes(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .oneofTestAllTypes(v) + } + }() + case 536870013: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .oneofString(v) + } + }() + case 536870014: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .oneofBytes(v) + } + }() + case 536860000..<536870000: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestHugeFieldNumbersLite.self, fieldNumber: fieldNumber) }() + 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 + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 536860000, end: 536870000) + try { if let v = self._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870000) + } }() + try { if let v = self._fixed32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870001) + } }() + if !self.repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 536870002) + } + if !self.packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: self.packedInt32, fieldNumber: 536870003) + } + try { if let v = self._optionalEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 536870004) + } }() + try { if let v = self._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 536870005) + } }() + try { if let v = self._optionalBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 536870006) + } }() + try { if let v = self._optionalMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 536870007) + } }() + try { if let v = self._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 536870008) + } }() + if !self.stringStringMap.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.stringStringMap, fieldNumber: 536870010) + } + switch self.oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 536870011) + }() + case .oneofTestAllTypes?: try { + guard case .oneofTestAllTypes(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 536870012) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 536870013) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 536870014) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestHugeFieldNumbersLite, rhs: Proto2Unittest_TestHugeFieldNumbersLite) -> Bool { + if lhs._optionalInt32 != rhs._optionalInt32 {return false} + if lhs._fixed32 != rhs._fixed32 {return false} + if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} + if lhs.packedInt32 != rhs.packedInt32 {return false} + if lhs._optionalEnum != rhs._optionalEnum {return false} + if lhs._optionalString != rhs._optionalString {return false} + if lhs._optionalBytes != rhs._optionalBytes {return false} + if lhs._optionalMessage != rhs._optionalMessage {return false} + if lhs._optionalGroup != rhs._optionalGroup {return false} + if lhs.stringStringMap != rhs.stringStringMap {return false} + if lhs.oneofField != rhs.oneofField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TestHugeFieldNumbersLite.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestHugeFieldNumbersLite.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}yq\u{7f}\u{7f}\u{1f}group_a\0") + + 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 536870009: try { try decoder.decodeSingularInt32Field(value: &self._groupA) }() + 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 + try { if let v = self._groupA { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870009) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestHugeFieldNumbersLite.OptionalGroup, rhs: Proto2Unittest_TestHugeFieldNumbersLite.OptionalGroup) -> Bool { + if lhs._groupA != rhs._groupA {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestOneofParsingLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestOneofParsingLite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}oneof_int32\0\u{3}oneof_submessage\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_string_cord\0\u{3}oneof_bytes_cord\0\u{3}oneof_string_string_piece\0\u{3}oneof_bytes_string_piece\0\u{3}oneof_enum\0") + + 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: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .oneofInt32(v) + } + }() + case 2: try { + var v: Proto2Unittest_TestAllTypesLite? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .oneofSubmessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .oneofSubmessage(v) + } + }() + case 3: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .oneofString(v) + } + }() + case 4: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .oneofBytes(v) + } + }() + case 5: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .oneofStringCord(v) + } + }() + case 6: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .oneofBytesCord(v) + } + }() + case 7: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .oneofStringStringPiece(v) + } + }() + case 8: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .oneofBytesStringPiece(v) + } + }() + case 9: try { + var v: Proto2Unittest_V2EnumLite? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .oneofEnum(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.oneofField { + case .oneofInt32?: try { + guard case .oneofInt32(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + }() + case .oneofSubmessage?: try { + guard case .oneofSubmessage(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 3) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 4) + }() + case .oneofStringCord?: try { + guard case .oneofStringCord(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 5) + }() + case .oneofBytesCord?: try { + guard case .oneofBytesCord(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 6) + }() + case .oneofStringStringPiece?: try { + guard case .oneofStringStringPiece(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 7) + }() + case .oneofBytesStringPiece?: try { + guard case .oneofBytesStringPiece(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 8) + }() + case .oneofEnum?: try { + guard case .oneofEnum(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 9) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestOneofParsingLite, rhs: Proto2Unittest_TestOneofParsingLite) -> Bool { + if lhs.oneofField != rhs.oneofField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMessageSetLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageSetLite" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestMessageSetLite.self) + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 100, end: 2147483647) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMessageSetLite, rhs: Proto2Unittest_TestMessageSetLite) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_PackedInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".PackedInt32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}@ repeated_int32\0") + + 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 2048: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.repeatedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: self.repeatedInt32, fieldNumber: 2048) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_PackedInt32, rhs: Proto2Unittest_PackedInt32) -> Bool { + if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_NonPackedInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NonPackedInt32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}@ repeated_int32\0") + + 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 2048: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 2048) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_NonPackedInt32, rhs: Proto2Unittest_NonPackedInt32) -> Bool { + if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_PackedFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".PackedFixed32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}@ repeated_fixed32\0") + + 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 2048: try { try decoder.decodeRepeatedFixed32Field(value: &self.repeatedFixed32) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.repeatedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: self.repeatedFixed32, fieldNumber: 2048) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_PackedFixed32, rhs: Proto2Unittest_PackedFixed32) -> Bool { + if lhs.repeatedFixed32 != rhs.repeatedFixed32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_NonPackedFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NonPackedFixed32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}@ repeated_fixed32\0") + + 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 2048: try { try decoder.decodeRepeatedFixed32Field(value: &self.repeatedFixed32) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.repeatedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: self.repeatedFixed32, fieldNumber: 2048) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_NonPackedFixed32, rhs: Proto2Unittest_NonPackedFixed32) -> Bool { + if lhs.repeatedFixed32 != rhs.repeatedFixed32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_DupEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".DupEnum" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_DupEnum, rhs: Proto2Unittest_DupEnum) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_DupEnum.TestEnumWithDupValueLite: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{9}FOO1\0\u{1}FOO2\0\u{9}BAR1\0\u{1}BAR2\0\u{1}BAZ\0") +} + +extension Proto2Unittest_RecursiveMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".RecursiveMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}recurse\0\u{1}payload\0") + + fileprivate class _StorageClass { + var _recurse: Proto2Unittest_RecursiveMessage? = nil + var _payload: Data? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _recurse = source._recurse + _payload = source._payload + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._recurse) }() + case 2: try { try decoder.decodeSingularBytesField(value: &_storage._payload) }() + default: break + } + } + } + } + + func traverse(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._recurse { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._payload { + try visitor.visitSingularBytesField(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_RecursiveMessage, rhs: Proto2Unittest_RecursiveMessage) -> 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._recurse != rhs_storage._recurse {return false} + if _storage._payload != rhs_storage._payload {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_RecursiveGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".RecursiveGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}recurse\0") + + fileprivate class _StorageClass { + var _recurse: Proto2Unittest_RecursiveGroup? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _recurse = source._recurse + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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.decodeSingularGroupField(value: &_storage._recurse) }() + default: break + } + } + } + } + + func traverse(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._recurse { + try visitor.visitSingularGroupField(value: v, fieldNumber: 1) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_RecursiveGroup, rhs: Proto2Unittest_RecursiveGroup) -> 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._recurse != rhs_storage._recurse {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/unittest_lite_edition_2024.pb.swift b/Reference/upstream/google/protobuf/unittest_lite_edition_2024.pb.swift new file mode 100644 index 000000000..8dbccd84a --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_lite_edition_2024.pb.swift @@ -0,0 +1,61 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_lite_edition_2024.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +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 Proto2Unittest_EnumNameStringView: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case `default` // = 0 + case anotherValue // = 1 + case UNRECOGNIZED(Int) + + init() { + self = .default + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .default + case 1: self = .anotherValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .default: return 0 + case .anotherValue: return 1 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Proto2Unittest_EnumNameStringView] = [ + .default, + .anotherValue, + ] + +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension Proto2Unittest_EnumNameStringView: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ENUM_NAME_STRING_VIEW_DEFAULT\0\u{1}ENUM_NAME_STRING_VIEW_ANOTHER_VALUE\0") +} diff --git a/Tests/SwiftProtobufTests/unittest_lite_imports_nonlite.pb.swift b/Reference/upstream/google/protobuf/unittest_lite_imports_nonlite.pb.swift similarity index 57% rename from Tests/SwiftProtobufTests/unittest_lite_imports_nonlite.pb.swift rename to Reference/upstream/google/protobuf/unittest_lite_imports_nonlite.pb.swift index b06c51f0d..48807e1c4 100644 --- a/Tests/SwiftProtobufTests/unittest_lite_imports_nonlite.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_lite_imports_nonlite.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/unittest_lite_imports_nonlite.proto @@ -9,39 +10,15 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd // Author: kenton@google.com (Kenton Varda) // // Tests that a "lite" message can import a regular message. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -54,27 +31,27 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_TestLiteImportsNonlite { +struct Proto2Unittest_TestLiteImportsNonlite: Sendable { // 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 message: ProtobufUnittest_TestAllTypes { - get {return _message ?? ProtobufUnittest_TestAllTypes()} + var message: Proto2Unittest_TestAllTypes { + get {_message ?? Proto2Unittest_TestAllTypes()} set {_message = newValue} } /// Returns true if `message` has been explicitly set. - var hasMessage: Bool {return self._message != nil} + var hasMessage: Bool {self._message != nil} /// Clears the value of `message`. Subsequent reads from it will return its default value. mutating func clearMessage() {self._message = nil} /// Verifies that transitive required fields generates valid code. - var messageWithRequired: ProtobufUnittest_TestRequired { - get {return _messageWithRequired ?? ProtobufUnittest_TestRequired()} + var messageWithRequired: Proto2Unittest_TestRequired { + get {_messageWithRequired ?? Proto2Unittest_TestRequired()} set {_messageWithRequired = newValue} } /// Returns true if `messageWithRequired` has been explicitly set. - var hasMessageWithRequired: Bool {return self._messageWithRequired != nil} + var hasMessageWithRequired: Bool {self._messageWithRequired != nil} /// Clears the value of `messageWithRequired`. Subsequent reads from it will return its default value. mutating func clearMessageWithRequired() {self._messageWithRequired = nil} @@ -82,24 +59,17 @@ struct ProtobufUnittest_TestLiteImportsNonlite { init() {} - fileprivate var _message: ProtobufUnittest_TestAllTypes? = nil - fileprivate var _messageWithRequired: ProtobufUnittest_TestRequired? = nil + fileprivate var _message: Proto2Unittest_TestAllTypes? = nil + fileprivate var _messageWithRequired: Proto2Unittest_TestRequired? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_TestLiteImportsNonlite: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "proto2_unittest" -extension ProtobufUnittest_TestLiteImportsNonlite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestLiteImportsNonlite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestLiteImportsNonlite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "message"), - 2: .standard(proto: "message_with_required"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}message\0\u{3}message_with_required\0") public var isInitialized: Bool { if let v = self._messageWithRequired, !v.isInitialized {return false} @@ -133,7 +103,7 @@ extension ProtobufUnittest_TestLiteImportsNonlite: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestLiteImportsNonlite, rhs: ProtobufUnittest_TestLiteImportsNonlite) -> Bool { + static func ==(lhs: Proto2Unittest_TestLiteImportsNonlite, rhs: Proto2Unittest_TestLiteImportsNonlite) -> Bool { if lhs._message != rhs._message {return false} if lhs._messageWithRequired != rhs._messageWithRequired {return false} if lhs.unknownFields != rhs.unknownFields {return false} diff --git a/Reference/upstream/google/protobuf/unittest_mset.pb.swift b/Reference/upstream/google/protobuf/unittest_mset.pb.swift new file mode 100644 index 000000000..3299b8bcb --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_mset.pb.swift @@ -0,0 +1,800 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_mset.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) +// Based on original Protocol Buffers design by +// Sanjay Ghemawat, Jeff Dean, and others. +// +// This file is similar to unittest_mset_wire_format.proto, but does not +// have a TestMessageSet, so it can be downgraded to proto1. + +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 Proto2Unittest_TestMessageSetContainer: Sendable { + // 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 messageSet: Proto2WireformatUnittest_TestMessageSet { + get {_messageSet ?? Proto2WireformatUnittest_TestMessageSet()} + set {_messageSet = newValue} + } + /// Returns true if `messageSet` has been explicitly set. + var hasMessageSet: Bool {self._messageSet != nil} + /// Clears the value of `messageSet`. Subsequent reads from it will return its default value. + mutating func clearMessageSet() {self._messageSet = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _messageSet: Proto2WireformatUnittest_TestMessageSet? = nil +} + +struct Proto2Unittest_NestedTestMessageSetContainer: @unchecked Sendable { + // 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 container: Proto2Unittest_TestMessageSetContainer { + get {_storage._container ?? Proto2Unittest_TestMessageSetContainer()} + set {_uniqueStorage()._container = newValue} + } + /// Returns true if `container` has been explicitly set. + var hasContainer: Bool {_storage._container != nil} + /// Clears the value of `container`. Subsequent reads from it will return its default value. + mutating func clearContainer() {_uniqueStorage()._container = nil} + + var child: Proto2Unittest_NestedTestMessageSetContainer { + get {_storage._child ?? Proto2Unittest_NestedTestMessageSetContainer()} + set {_uniqueStorage()._child = newValue} + } + /// Returns true if `child` has been explicitly set. + var hasChild: Bool {_storage._child != nil} + /// Clears the value of `child`. Subsequent reads from it will return its default value. + mutating func clearChild() {_uniqueStorage()._child = nil} + + var lazyChild: Proto2Unittest_NestedTestMessageSetContainer { + get {_storage._lazyChild ?? Proto2Unittest_NestedTestMessageSetContainer()} + set {_uniqueStorage()._lazyChild = newValue} + } + /// Returns true if `lazyChild` has been explicitly set. + var hasLazyChild: Bool {_storage._lazyChild != nil} + /// Clears the value of `lazyChild`. Subsequent reads from it will return its default value. + mutating func clearLazyChild() {_uniqueStorage()._lazyChild = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Proto2Unittest_NestedTestInt: @unchecked Sendable { + // 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 a: UInt32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var b: Int32 { + get {_storage._b ?? 0} + set {_uniqueStorage()._b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {_storage._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {_uniqueStorage()._b = nil} + + var child: Proto2Unittest_NestedTestInt { + get {_storage._child ?? Proto2Unittest_NestedTestInt()} + set {_uniqueStorage()._child = newValue} + } + /// Returns true if `child` has been explicitly set. + var hasChild: Bool {_storage._child != nil} + /// Clears the value of `child`. Subsequent reads from it will return its default value. + mutating func clearChild() {_uniqueStorage()._child = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Proto2Unittest_TestMessageSetExtension1: Sendable { + // 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 i: Int32 { + get {_i ?? 0} + set {_i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {self._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {self._i = nil} + + var recursive: Proto2WireformatUnittest_TestMessageSet { + get {_recursive ?? Proto2WireformatUnittest_TestMessageSet()} + set {_recursive = newValue} + } + /// Returns true if `recursive` has been explicitly set. + var hasRecursive: Bool {self._recursive != nil} + /// Clears the value of `recursive`. Subsequent reads from it will return its default value. + mutating func clearRecursive() {self._recursive = nil} + + var testAliasing: String { + get {_testAliasing ?? String()} + set {_testAliasing = newValue} + } + /// Returns true if `testAliasing` has been explicitly set. + var hasTestAliasing: Bool {self._testAliasing != nil} + /// Clears the value of `testAliasing`. Subsequent reads from it will return its default value. + mutating func clearTestAliasing() {self._testAliasing = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _i: Int32? = nil + fileprivate var _recursive: Proto2WireformatUnittest_TestMessageSet? = nil + fileprivate var _testAliasing: String? = nil +} + +struct Proto2Unittest_TestMessageSetExtension2: Sendable { + // 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 str: String { + get {_str ?? String()} + set {_str = newValue} + } + /// Returns true if `str` has been explicitly set. + var hasStr: Bool {self._str != nil} + /// Clears the value of `str`. Subsequent reads from it will return its default value. + mutating func clearStr() {self._str = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _str: String? = nil +} + +struct Proto2Unittest_TestMessageSetExtension3: Sendable { + // 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 msg: Proto2Unittest_NestedTestInt { + get {_msg ?? Proto2Unittest_NestedTestInt()} + set {_msg = newValue} + } + /// Returns true if `msg` has been explicitly set. + var hasMsg: Bool {self._msg != nil} + /// Clears the value of `msg`. Subsequent reads from it will return its default value. + mutating func clearMsg() {self._msg = nil} + + var requiredInt: Int32 { + get {_requiredInt ?? 0} + set {_requiredInt = newValue} + } + /// Returns true if `requiredInt` has been explicitly set. + var hasRequiredInt: Bool {self._requiredInt != nil} + /// Clears the value of `requiredInt`. Subsequent reads from it will return its default value. + mutating func clearRequiredInt() {self._requiredInt = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _msg: Proto2Unittest_NestedTestInt? = nil + fileprivate var _requiredInt: Int32? = nil +} + +/// MessageSet wire format is equivalent to this. +struct Proto2Unittest_RawMessageSet: Sendable { + // 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 item: [Proto2Unittest_RawMessageSet.Item] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct Item: Sendable { + // 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 typeID: Int32 { + get {_typeID ?? 0} + set {_typeID = newValue} + } + /// Returns true if `typeID` has been explicitly set. + var hasTypeID: Bool {self._typeID != nil} + /// Clears the value of `typeID`. Subsequent reads from it will return its default value. + mutating func clearTypeID() {self._typeID = nil} + + var message: Data { + get {_message ?? Data()} + set {_message = newValue} + } + /// Returns true if `message` has been explicitly set. + var hasMessage: Bool {self._message != nil} + /// Clears the value of `message`. Subsequent reads from it will return its default value. + mutating func clearMessage() {self._message = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _typeID: Int32? = nil + fileprivate var _message: Data? = nil + } + + init() {} +} + +// MARK: - Extension support defined in unittest_mset.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 Proto2WireformatUnittest_TestMessageSet { + + var Proto2Unittest_TestMessageSetExtension1_messageSetExtension: Proto2Unittest_TestMessageSetExtension1 { + get {return getExtensionValue(ext: Proto2Unittest_TestMessageSetExtension1.Extensions.message_set_extension) ?? Proto2Unittest_TestMessageSetExtension1()} + set {setExtensionValue(ext: Proto2Unittest_TestMessageSetExtension1.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestMessageSetExtension1.Extensions.message_set_extension` + /// has been explicitly set. + var hasProto2Unittest_TestMessageSetExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestMessageSetExtension1.Extensions.message_set_extension) + } + /// Clears the value of extension `Proto2Unittest_TestMessageSetExtension1.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestMessageSetExtension1_messageSetExtension() { + clearExtensionValue(ext: Proto2Unittest_TestMessageSetExtension1.Extensions.message_set_extension) + } + + var Proto2Unittest_TestMessageSetExtension2_messageSetExtension: Proto2Unittest_TestMessageSetExtension2 { + get {return getExtensionValue(ext: Proto2Unittest_TestMessageSetExtension2.Extensions.message_set_extension) ?? Proto2Unittest_TestMessageSetExtension2()} + set {setExtensionValue(ext: Proto2Unittest_TestMessageSetExtension2.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestMessageSetExtension2.Extensions.message_set_extension` + /// has been explicitly set. + var hasProto2Unittest_TestMessageSetExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestMessageSetExtension2.Extensions.message_set_extension) + } + /// Clears the value of extension `Proto2Unittest_TestMessageSetExtension2.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestMessageSetExtension2_messageSetExtension() { + clearExtensionValue(ext: Proto2Unittest_TestMessageSetExtension2.Extensions.message_set_extension) + } + + var Proto2Unittest_TestMessageSetExtension3_messageSetExtension: Proto2Unittest_TestMessageSetExtension3 { + get {return getExtensionValue(ext: Proto2Unittest_TestMessageSetExtension3.Extensions.message_set_extension) ?? Proto2Unittest_TestMessageSetExtension3()} + set {setExtensionValue(ext: Proto2Unittest_TestMessageSetExtension3.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TestMessageSetExtension3.Extensions.message_set_extension` + /// has been explicitly set. + var hasProto2Unittest_TestMessageSetExtension3_messageSetExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestMessageSetExtension3.Extensions.message_set_extension) + } + /// Clears the value of extension `Proto2Unittest_TestMessageSetExtension3.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TestMessageSetExtension3_messageSetExtension() { + clearExtensionValue(ext: Proto2Unittest_TestMessageSetExtension3.Extensions.message_set_extension) + } + +} + +// MARK: - File's ExtensionMap: Proto2Unittest_UnittestMset_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 Proto2Unittest_UnittestMset_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Proto2Unittest_TestMessageSetExtension1.Extensions.message_set_extension, + Proto2Unittest_TestMessageSetExtension2.Extensions.message_set_extension, + Proto2Unittest_TestMessageSetExtension3.Extensions.message_set_extension +] + +// 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. + +extension Proto2Unittest_TestMessageSetExtension1 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, Proto2WireformatUnittest_TestMessageSet>( + _protobuf_fieldNumber: 1545008, + fieldName: "proto2_unittest.TestMessageSetExtension1" + ) + } +} + +extension Proto2Unittest_TestMessageSetExtension2 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, Proto2WireformatUnittest_TestMessageSet>( + _protobuf_fieldNumber: 1547769, + fieldName: "proto2_unittest.TestMessageSetExtension2" + ) + } +} + +extension Proto2Unittest_TestMessageSetExtension3 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, Proto2WireformatUnittest_TestMessageSet>( + _protobuf_fieldNumber: 195273129, + fieldName: "proto2_unittest.TestMessageSetExtension3" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest" + +extension Proto2Unittest_TestMessageSetContainer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageSetContainer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}message_set\0") + + public var isInitialized: Bool { + if let v = self._messageSet, !v.isInitialized {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._messageSet) }() + 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 + try { if let v = self._messageSet { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMessageSetContainer, rhs: Proto2Unittest_TestMessageSetContainer) -> Bool { + if lhs._messageSet != rhs._messageSet {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_NestedTestMessageSetContainer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NestedTestMessageSetContainer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}container\0\u{1}child\0\u{3}lazy_child\0") + + fileprivate class _StorageClass { + var _container: Proto2Unittest_TestMessageSetContainer? = nil + var _child: Proto2Unittest_NestedTestMessageSetContainer? = nil + var _lazyChild: Proto2Unittest_NestedTestMessageSetContainer? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _container = source._container + _child = source._child + _lazyChild = source._lazyChild + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._container, !v.isInitialized {return false} + if let v = _storage._child, !v.isInitialized {return false} + if let v = _storage._lazyChild, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._container) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._child) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._lazyChild) }() + default: break + } + } + } + } + + func traverse(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._container { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._child { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._lazyChild { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_NestedTestMessageSetContainer, rhs: Proto2Unittest_NestedTestMessageSetContainer) -> 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._container != rhs_storage._container {return false} + if _storage._child != rhs_storage._child {return false} + if _storage._lazyChild != rhs_storage._lazyChild {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_NestedTestInt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NestedTestInt" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}child\0\u{1}b\0") + + fileprivate class _StorageClass { + var _a: UInt32? = nil + var _b: Int32? = nil + var _child: Proto2Unittest_NestedTestInt? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _b = source._b + _child = source._child + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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.decodeSingularFixed32Field(value: &_storage._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._child) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &_storage._b) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._child { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_NestedTestInt, rhs: Proto2Unittest_NestedTestInt) -> 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._a != rhs_storage._a {return false} + if _storage._b != rhs_storage._b {return false} + if _storage._child != rhs_storage._child {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMessageSetExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageSetExtension1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{f}i\0\u{1}recursive\0\u{3}test_aliasing\0") + + public var isInitialized: Bool { + if let v = self._recursive, !v.isInitialized {return false} + return true + } + + 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 15: try { try decoder.decodeSingularInt32Field(value: &self._i) }() + case 16: try { try decoder.decodeSingularMessageField(value: &self._recursive) }() + case 17: try { try decoder.decodeSingularStringField(value: &self._testAliasing) }() + 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 + try { if let v = self._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 15) + } }() + try { if let v = self._recursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 16) + } }() + try { if let v = self._testAliasing { + try visitor.visitSingularStringField(value: v, fieldNumber: 17) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMessageSetExtension1, rhs: Proto2Unittest_TestMessageSetExtension1) -> Bool { + if lhs._i != rhs._i {return false} + if lhs._recursive != rhs._recursive {return false} + if lhs._testAliasing != rhs._testAliasing {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMessageSetExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageSetExtension2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{19}str\0") + + 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 25: try { try decoder.decodeSingularStringField(value: &self._str) }() + 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 + try { if let v = self._str { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMessageSetExtension2, rhs: Proto2Unittest_TestMessageSetExtension2) -> Bool { + if lhs._str != rhs._str {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMessageSetExtension3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageSetExtension3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}#msg\0\u{3}required_int\0") + + public var isInitialized: Bool { + if self._requiredInt == nil {return false} + return true + } + + 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 35: try { try decoder.decodeSingularMessageField(value: &self._msg) }() + case 36: try { try decoder.decodeSingularInt32Field(value: &self._requiredInt) }() + 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 + try { if let v = self._msg { + try visitor.visitSingularMessageField(value: v, fieldNumber: 35) + } }() + try { if let v = self._requiredInt { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 36) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMessageSetExtension3, rhs: Proto2Unittest_TestMessageSetExtension3) -> Bool { + if lhs._msg != rhs._msg {return false} + if lhs._requiredInt != rhs._requiredInt {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_RawMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".RawMessageSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{7}Item\0") + + public var isInitialized: Bool { + if !SwiftProtobuf.Internal.areAllInitialized(self.item) {return false} + return true + } + + 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.decodeRepeatedGroupField(value: &self.item) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.item.isEmpty { + try visitor.visitRepeatedGroupField(value: self.item, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_RawMessageSet, rhs: Proto2Unittest_RawMessageSet) -> Bool { + if lhs.item != rhs.item {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_RawMessageSet.Item: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_RawMessageSet.protoMessageName + ".Item" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{2}type_id\0\u{1}message\0") + + public var isInitialized: Bool { + if self._typeID == nil {return false} + if self._message == nil {return false} + return true + } + + 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 2: try { try decoder.decodeSingularInt32Field(value: &self._typeID) }() + case 3: try { try decoder.decodeSingularBytesField(value: &self._message) }() + 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 + try { if let v = self._typeID { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._message { + try visitor.visitSingularBytesField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_RawMessageSet.Item, rhs: Proto2Unittest_RawMessageSet.Item) -> Bool { + if lhs._typeID != rhs._typeID {return false} + if lhs._message != rhs._message {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/google/protobuf/unittest_mset_wire_format.pb.swift b/Reference/upstream/google/protobuf/unittest_mset_wire_format.pb.swift similarity index 72% rename from Reference/google/protobuf/unittest_mset_wire_format.pb.swift rename to Reference/upstream/google/protobuf/unittest_mset_wire_format.pb.swift index c44d6e7a2..6e429e23b 100644 --- a/Reference/google/protobuf/unittest_mset_wire_format.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_mset_wire_format.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/unittest_mset_wire_format.proto @@ -9,33 +10,10 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd // Author: kenton@google.com (Kenton Varda) // Based on original Protocol Buffers design by @@ -43,7 +21,6 @@ // // This file contains messages for testing message_set_wire_format. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -57,7 +34,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP } /// A message with message_set_wire_format. -struct Proto2WireformatUnittest_TestMessageSet: SwiftProtobuf.ExtensibleMessage { +struct Proto2WireformatUnittest_TestMessageSet: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -69,17 +46,17 @@ struct Proto2WireformatUnittest_TestMessageSet: SwiftProtobuf.ExtensibleMessage var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct Proto2WireformatUnittest_TestMessageSetWireFormatContainer { +struct Proto2WireformatUnittest_TestMessageSetWireFormatContainer: Sendable { // 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 messageSet: Proto2WireformatUnittest_TestMessageSet { - get {return _messageSet ?? Proto2WireformatUnittest_TestMessageSet()} + get {_messageSet ?? Proto2WireformatUnittest_TestMessageSet()} set {_messageSet = newValue} } /// Returns true if `messageSet` has been explicitly set. - var hasMessageSet: Bool {return self._messageSet != nil} + var hasMessageSet: Bool {self._messageSet != nil} /// Clears the value of `messageSet`. Subsequent reads from it will return its default value. mutating func clearMessageSet() {self._messageSet = nil} @@ -90,11 +67,6 @@ struct Proto2WireformatUnittest_TestMessageSetWireFormatContainer { fileprivate var _messageSet: Proto2WireformatUnittest_TestMessageSet? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension Proto2WireformatUnittest_TestMessageSet: @unchecked Sendable {} -extension Proto2WireformatUnittest_TestMessageSetWireFormatContainer: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "proto2_wireformat_unittest" @@ -126,9 +98,7 @@ extension Proto2WireformatUnittest_TestMessageSet: SwiftProtobuf.Message, SwiftP extension Proto2WireformatUnittest_TestMessageSetWireFormatContainer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestMessageSetWireFormatContainer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "message_set"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}message_set\0") public var isInitialized: Bool { if let v = self._messageSet, !v.isInitialized {return false} diff --git a/Tests/SwiftProtobufTests/unittest_no_field_presence.pb.swift b/Reference/upstream/google/protobuf/unittest_no_field_presence.pb.swift similarity index 77% rename from Tests/SwiftProtobufTests/unittest_no_field_presence.pb.swift rename to Reference/upstream/google/protobuf/unittest_no_field_presence.pb.swift index a37887f3e..57d90bd18 100644 --- a/Tests/SwiftProtobufTests/unittest_no_field_presence.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_no_field_presence.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/unittest_no_field_presence.proto @@ -9,33 +10,10 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd // A proto file used to test a message type with no explicit field presence. @@ -52,7 +30,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum Proto2NofieldpresenceUnittest_ForeignEnum: SwiftProtobuf.Enum { +enum Proto2NofieldpresenceUnittest_ForeignEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foreignFoo // = 0 case foreignBar // = 1 @@ -81,24 +59,18 @@ enum Proto2NofieldpresenceUnittest_ForeignEnum: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension Proto2NofieldpresenceUnittest_ForeignEnum: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto2NofieldpresenceUnittest_ForeignEnum] = [ + static let allCases: [Proto2NofieldpresenceUnittest_ForeignEnum] = [ .foreignFoo, .foreignBar, .foreignBaz, ] -} -#endif // swift(>=4.2) +} /// This proto includes every type of field in both singular and repeated /// forms. -struct Proto2NofieldpresenceUnittest_TestAllTypes { +struct Proto2NofieldpresenceUnittest_TestAllTypes: @unchecked Sendable { // 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. @@ -107,252 +79,253 @@ struct Proto2NofieldpresenceUnittest_TestAllTypes { /// TODO: remove 'optional' labels as soon as CL 69188077 is LGTM'd to make /// 'optional' optional. var optionalInt32: Int32 { - get {return _storage._optionalInt32} + get {_storage._optionalInt32} set {_uniqueStorage()._optionalInt32 = newValue} } var optionalInt64: Int64 { - get {return _storage._optionalInt64} + get {_storage._optionalInt64} set {_uniqueStorage()._optionalInt64 = newValue} } var optionalUint32: UInt32 { - get {return _storage._optionalUint32} + get {_storage._optionalUint32} set {_uniqueStorage()._optionalUint32 = newValue} } var optionalUint64: UInt64 { - get {return _storage._optionalUint64} + get {_storage._optionalUint64} set {_uniqueStorage()._optionalUint64 = newValue} } var optionalSint32: Int32 { - get {return _storage._optionalSint32} + get {_storage._optionalSint32} set {_uniqueStorage()._optionalSint32 = newValue} } var optionalSint64: Int64 { - get {return _storage._optionalSint64} + get {_storage._optionalSint64} set {_uniqueStorage()._optionalSint64 = newValue} } var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32} + get {_storage._optionalFixed32} set {_uniqueStorage()._optionalFixed32 = newValue} } var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64} + get {_storage._optionalFixed64} set {_uniqueStorage()._optionalFixed64 = newValue} } var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32} + get {_storage._optionalSfixed32} set {_uniqueStorage()._optionalSfixed32 = newValue} } var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64} + get {_storage._optionalSfixed64} set {_uniqueStorage()._optionalSfixed64 = newValue} } var optionalFloat: Float { - get {return _storage._optionalFloat} + get {_storage._optionalFloat} set {_uniqueStorage()._optionalFloat = newValue} } var optionalDouble: Double { - get {return _storage._optionalDouble} + get {_storage._optionalDouble} set {_uniqueStorage()._optionalDouble = newValue} } var optionalBool: Bool { - get {return _storage._optionalBool} + get {_storage._optionalBool} set {_uniqueStorage()._optionalBool = newValue} } var optionalString: String { - get {return _storage._optionalString} + get {_storage._optionalString} set {_uniqueStorage()._optionalString = newValue} } var optionalBytes: Data { - get {return _storage._optionalBytes} + get {_storage._optionalBytes} set {_uniqueStorage()._optionalBytes = newValue} } var optionalNestedMessage: Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage { - get {return _storage._optionalNestedMessage ?? Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage()} + get {_storage._optionalNestedMessage ?? Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage()} set {_uniqueStorage()._optionalNestedMessage = newValue} } /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} var optionalForeignMessage: Proto2NofieldpresenceUnittest_ForeignMessage { - get {return _storage._optionalForeignMessage ?? Proto2NofieldpresenceUnittest_ForeignMessage()} + get {_storage._optionalForeignMessage ?? Proto2NofieldpresenceUnittest_ForeignMessage()} set {_uniqueStorage()._optionalForeignMessage = newValue} } /// Returns true if `optionalForeignMessage` has been explicitly set. - var hasOptionalForeignMessage: Bool {return _storage._optionalForeignMessage != nil} + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} - var optionalProto2Message: ProtobufUnittest_TestAllTypes { - get {return _storage._optionalProto2Message ?? ProtobufUnittest_TestAllTypes()} + var optionalProto2Message: Proto2Unittest_TestAllTypes { + get {_storage._optionalProto2Message ?? Proto2Unittest_TestAllTypes()} set {_uniqueStorage()._optionalProto2Message = newValue} } /// Returns true if `optionalProto2Message` has been explicitly set. - var hasOptionalProto2Message: Bool {return _storage._optionalProto2Message != nil} + var hasOptionalProto2Message: Bool {_storage._optionalProto2Message != nil} /// Clears the value of `optionalProto2Message`. Subsequent reads from it will return its default value. mutating func clearOptionalProto2Message() {_uniqueStorage()._optionalProto2Message = nil} var optionalNestedEnum: Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum { - get {return _storage._optionalNestedEnum} + get {_storage._optionalNestedEnum} set {_uniqueStorage()._optionalNestedEnum = newValue} } /// N.B.: proto2-enum-type fields not allowed, because their default values /// might not be zero. - ///optional protobuf_unittest.ForeignEnum optional_proto2_enum = 23; + /// optional proto2_unittest.ForeignEnum optional_proto2_enum = + /// 23; var optionalForeignEnum: Proto2NofieldpresenceUnittest_ForeignEnum { - get {return _storage._optionalForeignEnum} + get {_storage._optionalForeignEnum} set {_uniqueStorage()._optionalForeignEnum = newValue} } var optionalStringPiece: String { - get {return _storage._optionalStringPiece} + get {_storage._optionalStringPiece} set {_uniqueStorage()._optionalStringPiece = newValue} } var optionalCord: String { - get {return _storage._optionalCord} + get {_storage._optionalCord} set {_uniqueStorage()._optionalCord = newValue} } var optionalLazyMessage: Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage { - get {return _storage._optionalLazyMessage ?? Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage()} + get {_storage._optionalLazyMessage ?? Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage()} set {_uniqueStorage()._optionalLazyMessage = newValue} } /// Returns true if `optionalLazyMessage` has been explicitly set. - var hasOptionalLazyMessage: Bool {return _storage._optionalLazyMessage != nil} + var hasOptionalLazyMessage: Bool {_storage._optionalLazyMessage != nil} /// Clears the value of `optionalLazyMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalLazyMessage() {_uniqueStorage()._optionalLazyMessage = nil} /// Repeated var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } var repeatedNestedMessage: [Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedNestedMessage} + get {_storage._repeatedNestedMessage} set {_uniqueStorage()._repeatedNestedMessage = newValue} } var repeatedForeignMessage: [Proto2NofieldpresenceUnittest_ForeignMessage] { - get {return _storage._repeatedForeignMessage} + get {_storage._repeatedForeignMessage} set {_uniqueStorage()._repeatedForeignMessage = newValue} } - var repeatedProto2Message: [ProtobufUnittest_TestAllTypes] { - get {return _storage._repeatedProto2Message} + var repeatedProto2Message: [Proto2Unittest_TestAllTypes] { + get {_storage._repeatedProto2Message} set {_uniqueStorage()._repeatedProto2Message = newValue} } var repeatedNestedEnum: [Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum] { - get {return _storage._repeatedNestedEnum} + get {_storage._repeatedNestedEnum} set {_uniqueStorage()._repeatedNestedEnum = newValue} } var repeatedForeignEnum: [Proto2NofieldpresenceUnittest_ForeignEnum] { - get {return _storage._repeatedForeignEnum} + get {_storage._repeatedForeignEnum} set {_uniqueStorage()._repeatedForeignEnum = newValue} } var repeatedStringPiece: [String] { - get {return _storage._repeatedStringPiece} + get {_storage._repeatedStringPiece} set {_uniqueStorage()._repeatedStringPiece = newValue} } var repeatedCord: [String] { - get {return _storage._repeatedCord} + get {_storage._repeatedCord} set {_uniqueStorage()._repeatedCord = newValue} } var repeatedLazyMessage: [Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedLazyMessage} + get {_storage._repeatedLazyMessage} set {_uniqueStorage()._repeatedLazyMessage = newValue} } @@ -395,41 +368,15 @@ struct Proto2NofieldpresenceUnittest_TestAllTypes { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case oneofUint32(UInt32) case oneofNestedMessage(Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage) case oneofString(String) case oneofEnum(Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum) - #if !swift(>=4.1) - static func ==(lhs: Proto2NofieldpresenceUnittest_TestAllTypes.OneOf_OneofField, rhs: Proto2NofieldpresenceUnittest_TestAllTypes.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofEnum, .oneofEnum): return { - guard case .oneofEnum(let l) = lhs, case .oneofEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum NestedEnum: SwiftProtobuf.Enum { + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foo // = 0 case bar // = 1 @@ -458,9 +405,16 @@ struct Proto2NofieldpresenceUnittest_TestAllTypes { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum] = [ + .foo, + .bar, + .baz, + ] + } - struct NestedMessage { + struct NestedMessage: Sendable { // 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. @@ -477,30 +431,35 @@ struct Proto2NofieldpresenceUnittest_TestAllTypes { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) +struct Proto2NofieldpresenceUnittest_TestAllMapTypes: Sendable { + // 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 mapInt32Bytes: Dictionary = [:] -extension Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum] = [ - .foo, - .bar, - .baz, - ] -} + var mapInt32ForeignEnum: Dictionary = [:] + + var mapInt32ForeignMessage: Dictionary = [:] -#endif // swift(>=4.2) + var mapInt32ExplicitForeignMessage: Dictionary = [:] -struct Proto2NofieldpresenceUnittest_TestProto2Required { + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Proto2NofieldpresenceUnittest_TestProto2Required: Sendable { // 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 proto2: ProtobufUnittest_TestRequired { - get {return _proto2 ?? ProtobufUnittest_TestRequired()} + var proto2: Proto2Unittest_TestRequired { + get {_proto2 ?? Proto2Unittest_TestRequired()} set {_proto2 = newValue} } /// Returns true if `proto2` has been explicitly set. - var hasProto2: Bool {return self._proto2 != nil} + var hasProto2: Bool {self._proto2 != nil} /// Clears the value of `proto2`. Subsequent reads from it will return its default value. mutating func clearProto2() {self._proto2 = nil} @@ -508,12 +467,12 @@ struct Proto2NofieldpresenceUnittest_TestProto2Required { init() {} - fileprivate var _proto2: ProtobufUnittest_TestRequired? = nil + fileprivate var _proto2: Proto2Unittest_TestRequired? = nil } /// Define these after TestAllTypes to make sure the compiler can handle /// that. -struct Proto2NofieldpresenceUnittest_ForeignMessage { +struct Proto2NofieldpresenceUnittest_ForeignMessage: Sendable { // 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. @@ -525,82 +484,40 @@ struct Proto2NofieldpresenceUnittest_ForeignMessage { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Proto2NofieldpresenceUnittest_ForeignEnum: @unchecked Sendable {} -extension Proto2NofieldpresenceUnittest_TestAllTypes: @unchecked Sendable {} -extension Proto2NofieldpresenceUnittest_TestAllTypes.OneOf_OneofField: @unchecked Sendable {} -extension Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum: @unchecked Sendable {} -extension Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage: @unchecked Sendable {} -extension Proto2NofieldpresenceUnittest_TestProto2Required: @unchecked Sendable {} -extension Proto2NofieldpresenceUnittest_ForeignMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) +/// Same as ForeignMessage, but all fields have explicit presence. +/// It can be useful for testing explicit-implicit presence interop behaviour. +struct Proto2NofieldpresenceUnittest_ExplicitForeignMessage: Sendable { + // 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 c: Int32 { + get {_c ?? 0} + set {_c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {self._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {self._c = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _c: Int32? = nil +} // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "proto2_nofieldpresence_unittest" extension Proto2NofieldpresenceUnittest_ForeignEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOREIGN_FOO"), - 1: .same(proto: "FOREIGN_BAR"), - 2: .same(proto: "FOREIGN_BAZ"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") } extension Proto2NofieldpresenceUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "optional_foreign_message"), - 20: .standard(proto: "optional_proto2_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "optional_foreign_enum"), - 24: .standard(proto: "optional_string_piece"), - 25: .standard(proto: "optional_cord"), - 30: .standard(proto: "optional_lazy_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 48: .standard(proto: "repeated_nested_message"), - 49: .standard(proto: "repeated_foreign_message"), - 50: .standard(proto: "repeated_proto2_message"), - 51: .standard(proto: "repeated_nested_enum"), - 52: .standard(proto: "repeated_foreign_enum"), - 54: .standard(proto: "repeated_string_piece"), - 55: .standard(proto: "repeated_cord"), - 57: .standard(proto: "repeated_lazy_message"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_enum"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{3}optional_proto2_message\0\u{3}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{4}\u{2}optional_string_piece\0\u{3}optional_cord\0\u{4}\u{5}optional_lazy_message\0\u{3}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{3}repeated_proto2_message\0\u{3}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{4}\u{2}repeated_lazy_message\0\u{4}6oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_enum\0") fileprivate class _StorageClass { var _optionalInt32: Int32 = 0 @@ -620,7 +537,7 @@ extension Proto2NofieldpresenceUnittest_TestAllTypes: SwiftProtobuf.Message, Swi var _optionalBytes: Data = Data() var _optionalNestedMessage: Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage? = nil var _optionalForeignMessage: Proto2NofieldpresenceUnittest_ForeignMessage? = nil - var _optionalProto2Message: ProtobufUnittest_TestAllTypes? = nil + var _optionalProto2Message: Proto2Unittest_TestAllTypes? = nil var _optionalNestedEnum: Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum = .foo var _optionalForeignEnum: Proto2NofieldpresenceUnittest_ForeignEnum = .foreignFoo var _optionalStringPiece: String = String() @@ -643,7 +560,7 @@ extension Proto2NofieldpresenceUnittest_TestAllTypes: SwiftProtobuf.Message, Swi var _repeatedBytes: [Data] = [] var _repeatedNestedMessage: [Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage] = [] var _repeatedForeignMessage: [Proto2NofieldpresenceUnittest_ForeignMessage] = [] - var _repeatedProto2Message: [ProtobufUnittest_TestAllTypes] = [] + var _repeatedProto2Message: [Proto2Unittest_TestAllTypes] = [] var _repeatedNestedEnum: [Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum] = [] var _repeatedForeignEnum: [Proto2NofieldpresenceUnittest_ForeignEnum] = [] var _repeatedStringPiece: [String] = [] @@ -651,7 +568,11 @@ extension Proto2NofieldpresenceUnittest_TestAllTypes: SwiftProtobuf.Message, Swi var _repeatedLazyMessage: [Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage] = [] var _oneofField: Proto2NofieldpresenceUnittest_TestAllTypes.OneOf_OneofField? - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -846,10 +767,10 @@ extension Proto2NofieldpresenceUnittest_TestAllTypes: SwiftProtobuf.Message, Swi if _storage._optionalSfixed64 != 0 { try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) } - if _storage._optionalFloat != 0 { + if _storage._optionalFloat.bitPattern != 0 { try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) } - if _storage._optionalDouble != 0 { + if _storage._optionalDouble.bitPattern != 0 { try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) } if _storage._optionalBool != false { @@ -1039,18 +960,12 @@ extension Proto2NofieldpresenceUnittest_TestAllTypes: SwiftProtobuf.Message, Swi } extension Proto2NofieldpresenceUnittest_TestAllTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOO\0\u{1}BAR\0\u{1}BAZ\0") } extension Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = Proto2NofieldpresenceUnittest_TestAllTypes.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1078,11 +993,54 @@ extension Proto2NofieldpresenceUnittest_TestAllTypes.NestedMessage: SwiftProtobu } } +extension Proto2NofieldpresenceUnittest_TestAllMapTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllMapTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}map_int32_bytes\0\u{3}map_int32_foreign_enum\0\u{3}map_int32_foreign_message\0\u{3}map_int32_explicit_foreign_message\0") + + 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.mapInt32Bytes) }() + case 2: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.mapInt32ForeignEnum) }() + case 3: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapInt32ForeignMessage) }() + case 4: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapInt32ExplicitForeignMessage) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.mapInt32Bytes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.mapInt32Bytes, fieldNumber: 1) + } + if !self.mapInt32ForeignEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.mapInt32ForeignEnum, fieldNumber: 2) + } + if !self.mapInt32ForeignMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapInt32ForeignMessage, fieldNumber: 3) + } + if !self.mapInt32ExplicitForeignMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapInt32ExplicitForeignMessage, fieldNumber: 4) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2NofieldpresenceUnittest_TestAllMapTypes, rhs: Proto2NofieldpresenceUnittest_TestAllMapTypes) -> Bool { + if lhs.mapInt32Bytes != rhs.mapInt32Bytes {return false} + if lhs.mapInt32ForeignEnum != rhs.mapInt32ForeignEnum {return false} + if lhs.mapInt32ForeignMessage != rhs.mapInt32ForeignMessage {return false} + if lhs.mapInt32ExplicitForeignMessage != rhs.mapInt32ExplicitForeignMessage {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + extension Proto2NofieldpresenceUnittest_TestProto2Required: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestProto2Required" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "proto2"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}proto2\0") public var isInitialized: Bool { if let v = self._proto2, !v.isInitialized {return false} @@ -1121,9 +1079,7 @@ extension Proto2NofieldpresenceUnittest_TestProto2Required: SwiftProtobuf.Messag extension Proto2NofieldpresenceUnittest_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ForeignMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1150,3 +1106,37 @@ extension Proto2NofieldpresenceUnittest_ForeignMessage: SwiftProtobuf.Message, S return true } } + +extension Proto2NofieldpresenceUnittest_ExplicitForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ExplicitForeignMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") + + 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._c) }() + 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 + try { if let v = self._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2NofieldpresenceUnittest_ExplicitForeignMessage, rhs: Proto2NofieldpresenceUnittest_ExplicitForeignMessage) -> Bool { + if lhs._c != rhs._c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/unittest_no_generic_services.pb.swift b/Reference/upstream/google/protobuf/unittest_no_generic_services.pb.swift new file mode 100644 index 000000000..e2f50cfcb --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_no_generic_services.pb.swift @@ -0,0 +1,159 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_no_generic_services.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +// Author: kenton@google.com (Kenton Varda) + +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 Proto2Unittest_NoGenericServicesTest_TestEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 1 + + init() { + self = .foo + } + +} + +struct Proto2Unittest_NoGenericServicesTest_TestMessage: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _a: Int32? = nil +} + +// MARK: - Extension support defined in unittest_no_generic_services.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 Proto2Unittest_NoGenericServicesTest_TestMessage { + + var Proto2Unittest_NoGenericServicesTest_testExtension: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_NoGenericServicesTest_Extensions_test_extension) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_NoGenericServicesTest_Extensions_test_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_NoGenericServicesTest_Extensions_test_extension` + /// has been explicitly set. + var hasProto2Unittest_NoGenericServicesTest_testExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_NoGenericServicesTest_Extensions_test_extension) + } + /// Clears the value of extension `Proto2Unittest_NoGenericServicesTest_Extensions_test_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_NoGenericServicesTest_testExtension() { + clearExtensionValue(ext: Proto2Unittest_NoGenericServicesTest_Extensions_test_extension) + } + +} + +// MARK: - File's ExtensionMap: Proto2Unittest_NoGenericServicesTest_UnittestNoGenericServices_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 Proto2Unittest_NoGenericServicesTest_UnittestNoGenericServices_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Proto2Unittest_NoGenericServicesTest_Extensions_test_extension +] + +// 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 Proto2Unittest_NoGenericServicesTest_Extensions_test_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_NoGenericServicesTest_TestMessage>( + _protobuf_fieldNumber: 1000, + fieldName: "proto2_unittest.no_generic_services_test.test_extension" +) + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest.no_generic_services_test" + +extension Proto2Unittest_NoGenericServicesTest_TestEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FOO\0") +} + +extension Proto2Unittest_NoGenericServicesTest_TestMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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._a) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_NoGenericServicesTest_TestMessage.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_NoGenericServicesTest_TestMessage, rhs: Proto2Unittest_NoGenericServicesTest_TestMessage) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} diff --git a/Tests/SwiftProtobufTests/unittest_optimize_for.pb.swift b/Reference/upstream/google/protobuf/unittest_optimize_for.pb.swift similarity index 57% rename from Tests/SwiftProtobufTests/unittest_optimize_for.pb.swift rename to Reference/upstream/google/protobuf/unittest_optimize_for.pb.swift index 88d0c5b14..fa13b0f93 100644 --- a/Tests/SwiftProtobufTests/unittest_optimize_for.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_optimize_for.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/unittest_optimize_for.proto @@ -9,33 +10,10 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd // Author: kenton@google.com (Kenton Varda) // Based on original Protocol Buffers design by @@ -43,7 +21,6 @@ // // A proto file which uses optimize_for = CODE_SIZE. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -56,30 +33,30 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_TestOptimizedForSize: SwiftProtobuf.ExtensibleMessage { +struct Proto2Unittest_TestOptimizedForSize: SwiftProtobuf.ExtensibleMessage, Sendable { // 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 i: Int32 { - get {return _i ?? 0} + get {_i ?? 0} set {_i = newValue} } /// Returns true if `i` has been explicitly set. - var hasI: Bool {return self._i != nil} + var hasI: Bool {self._i != nil} /// Clears the value of `i`. Subsequent reads from it will return its default value. mutating func clearI() {self._i = nil} - var msg: ProtobufUnittest_ForeignMessage { - get {return _msg ?? ProtobufUnittest_ForeignMessage()} + var msg: Proto2Unittest_ForeignMessage { + get {_msg ?? Proto2Unittest_ForeignMessage()} set {_msg = newValue} } /// Returns true if `msg` has been explicitly set. - var hasMsg: Bool {return self._msg != nil} + var hasMsg: Bool {self._msg != nil} /// Clears the value of `msg`. Subsequent reads from it will return its default value. mutating func clearMsg() {self._msg = nil} - var foo: ProtobufUnittest_TestOptimizedForSize.OneOf_Foo? = nil + var foo: Proto2Unittest_TestOptimizedForSize.OneOf_Foo? = nil var integerField: Int32 { get { @@ -99,48 +76,30 @@ struct ProtobufUnittest_TestOptimizedForSize: SwiftProtobuf.ExtensibleMessage { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_Foo: Equatable { + enum OneOf_Foo: Equatable, Sendable { case integerField(Int32) case stringField(String) - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestOptimizedForSize.OneOf_Foo, rhs: ProtobufUnittest_TestOptimizedForSize.OneOf_Foo) -> 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 (.integerField, .integerField): return { - guard case .integerField(let l) = lhs, case .integerField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.stringField, .stringField): return { - guard case .stringField(let l) = lhs, case .stringField(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } init() {} var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() fileprivate var _i: Int32? = nil - fileprivate var _msg: ProtobufUnittest_ForeignMessage? = nil + fileprivate var _msg: Proto2Unittest_ForeignMessage? = nil } -struct ProtobufUnittest_TestRequiredOptimizedForSize { +struct Proto2Unittest_TestRequiredOptimizedForSize: Sendable { // 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 x: Int32 { - get {return _x ?? 0} + get {_x ?? 0} set {_x = newValue} } /// Returns true if `x` has been explicitly set. - var hasX: Bool {return self._x != nil} + var hasX: Bool {self._x != nil} /// Clears the value of `x`. Subsequent reads from it will return its default value. mutating func clearX() {self._x = nil} @@ -151,17 +110,17 @@ struct ProtobufUnittest_TestRequiredOptimizedForSize { fileprivate var _x: Int32? = nil } -struct ProtobufUnittest_TestOptionalOptimizedForSize { +struct Proto2Unittest_TestOptionalOptimizedForSize: Sendable { // 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 o: ProtobufUnittest_TestRequiredOptimizedForSize { - get {return _o ?? ProtobufUnittest_TestRequiredOptimizedForSize()} + var o: Proto2Unittest_TestRequiredOptimizedForSize { + get {_o ?? Proto2Unittest_TestRequiredOptimizedForSize()} set {_o = newValue} } /// Returns true if `o` has been explicitly set. - var hasO: Bool {return self._o != nil} + var hasO: Bool {self._o != nil} /// Clears the value of `o`. Subsequent reads from it will return its default value. mutating func clearO() {self._o = nil} @@ -169,100 +128,88 @@ struct ProtobufUnittest_TestOptionalOptimizedForSize { init() {} - fileprivate var _o: ProtobufUnittest_TestRequiredOptimizedForSize? = nil + fileprivate var _o: Proto2Unittest_TestRequiredOptimizedForSize? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_TestOptimizedForSize: @unchecked Sendable {} -extension ProtobufUnittest_TestOptimizedForSize.OneOf_Foo: @unchecked Sendable {} -extension ProtobufUnittest_TestRequiredOptimizedForSize: @unchecked Sendable {} -extension ProtobufUnittest_TestOptionalOptimizedForSize: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_optimize_for.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 ProtobufUnittest_TestOptimizedForSize { +extension Proto2Unittest_TestOptimizedForSize { - var ProtobufUnittest_TestOptimizedForSize_testExtension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension, value: newValue)} + var Proto2Unittest_TestOptimizedForSize_testExtension: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_TestOptimizedForSize.Extensions.test_extension) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_TestOptimizedForSize.Extensions.test_extension, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension` + /// Returns true if extension `Proto2Unittest_TestOptimizedForSize.Extensions.test_extension` /// has been explicitly set. - var hasProtobufUnittest_TestOptimizedForSize_testExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension) + var hasProto2Unittest_TestOptimizedForSize_testExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestOptimizedForSize.Extensions.test_extension) } - /// Clears the value of extension `ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension`. + /// Clears the value of extension `Proto2Unittest_TestOptimizedForSize.Extensions.test_extension`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestOptimizedForSize_testExtension() { - clearExtensionValue(ext: ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension) + mutating func clearProto2Unittest_TestOptimizedForSize_testExtension() { + clearExtensionValue(ext: Proto2Unittest_TestOptimizedForSize.Extensions.test_extension) } - var ProtobufUnittest_TestOptimizedForSize_testExtension2: ProtobufUnittest_TestRequiredOptimizedForSize { - get {return getExtensionValue(ext: ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension2) ?? ProtobufUnittest_TestRequiredOptimizedForSize()} - set {setExtensionValue(ext: ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension2, value: newValue)} + var Proto2Unittest_TestOptimizedForSize_testExtension2: Proto2Unittest_TestRequiredOptimizedForSize { + get {return getExtensionValue(ext: Proto2Unittest_TestOptimizedForSize.Extensions.test_extension2) ?? Proto2Unittest_TestRequiredOptimizedForSize()} + set {setExtensionValue(ext: Proto2Unittest_TestOptimizedForSize.Extensions.test_extension2, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension2` + /// Returns true if extension `Proto2Unittest_TestOptimizedForSize.Extensions.test_extension2` /// has been explicitly set. - var hasProtobufUnittest_TestOptimizedForSize_testExtension2: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension2) + var hasProto2Unittest_TestOptimizedForSize_testExtension2: Bool { + return hasExtensionValue(ext: Proto2Unittest_TestOptimizedForSize.Extensions.test_extension2) } - /// Clears the value of extension `ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension2`. + /// Clears the value of extension `Proto2Unittest_TestOptimizedForSize.Extensions.test_extension2`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestOptimizedForSize_testExtension2() { - clearExtensionValue(ext: ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension2) + mutating func clearProto2Unittest_TestOptimizedForSize_testExtension2() { + clearExtensionValue(ext: Proto2Unittest_TestOptimizedForSize.Extensions.test_extension2) } } -// MARK: - File's ExtensionMap: ProtobufUnittest_UnittestOptimizeFor_Extensions +// MARK: - File's ExtensionMap: Proto2Unittest_UnittestOptimizeFor_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 ProtobufUnittest_UnittestOptimizeFor_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension, - ProtobufUnittest_TestOptimizedForSize.Extensions.test_extension2 +let Proto2Unittest_UnittestOptimizeFor_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Proto2Unittest_TestOptimizedForSize.Extensions.test_extension, + Proto2Unittest_TestOptimizedForSize.Extensions.test_extension2 ] // 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. -extension ProtobufUnittest_TestOptimizedForSize { +extension Proto2Unittest_TestOptimizedForSize { enum Extensions { - static let test_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestOptimizedForSize>( + static let test_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestOptimizedForSize>( _protobuf_fieldNumber: 1234, - fieldName: "protobuf_unittest.TestOptimizedForSize.test_extension" + fieldName: "proto2_unittest.TestOptimizedForSize.test_extension" ) - static let test_extension2 = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestOptimizedForSize>( + static let test_extension2 = SwiftProtobuf.MessageExtension, Proto2Unittest_TestOptimizedForSize>( _protobuf_fieldNumber: 1235, - fieldName: "protobuf_unittest.TestOptimizedForSize.test_extension2" + fieldName: "proto2_unittest.TestOptimizedForSize.test_extension2" ) } } // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "proto2_unittest" -extension ProtobufUnittest_TestOptimizedForSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestOptimizedForSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestOptimizedForSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "i"), - 19: .same(proto: "msg"), - 2: .standard(proto: "integer_field"), - 3: .standard(proto: "string_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}i\0\u{3}integer_field\0\u{3}string_field\0\u{2}\u{10}msg\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} @@ -294,7 +241,7 @@ extension ProtobufUnittest_TestOptimizedForSize: SwiftProtobuf.Message, SwiftPro }() case 19: try { try decoder.decodeSingularMessageField(value: &self._msg) }() case 1000..<536870912: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestOptimizedForSize.self, fieldNumber: fieldNumber) }() + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestOptimizedForSize.self, fieldNumber: fieldNumber) }() default: break } } @@ -326,7 +273,7 @@ extension ProtobufUnittest_TestOptimizedForSize: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestOptimizedForSize, rhs: ProtobufUnittest_TestOptimizedForSize) -> Bool { + static func ==(lhs: Proto2Unittest_TestOptimizedForSize, rhs: Proto2Unittest_TestOptimizedForSize) -> Bool { if lhs._i != rhs._i {return false} if lhs._msg != rhs._msg {return false} if lhs.foo != rhs.foo {return false} @@ -336,11 +283,9 @@ extension ProtobufUnittest_TestOptimizedForSize: SwiftProtobuf.Message, SwiftPro } } -extension ProtobufUnittest_TestRequiredOptimizedForSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestRequiredOptimizedForSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestRequiredOptimizedForSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "x"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}x\0") public var isInitialized: Bool { if self._x == nil {return false} @@ -370,18 +315,16 @@ extension ProtobufUnittest_TestRequiredOptimizedForSize: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestRequiredOptimizedForSize, rhs: ProtobufUnittest_TestRequiredOptimizedForSize) -> Bool { + static func ==(lhs: Proto2Unittest_TestRequiredOptimizedForSize, rhs: Proto2Unittest_TestRequiredOptimizedForSize) -> Bool { if lhs._x != rhs._x {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestOptionalOptimizedForSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestOptionalOptimizedForSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestOptionalOptimizedForSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "o"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}o\0") public var isInitialized: Bool { if let v = self._o, !v.isInitialized {return false} @@ -411,7 +354,7 @@ extension ProtobufUnittest_TestOptionalOptimizedForSize: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestOptionalOptimizedForSize, rhs: ProtobufUnittest_TestOptionalOptimizedForSize) -> Bool { + static func ==(lhs: Proto2Unittest_TestOptionalOptimizedForSize, rhs: Proto2Unittest_TestOptionalOptimizedForSize) -> Bool { if lhs._o != rhs._o {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Reference/google/protobuf/unittest_preserve_unknown_enum.pb.swift b/Reference/upstream/google/protobuf/unittest_preserve_unknown_enum.pb.swift similarity index 68% rename from Reference/google/protobuf/unittest_preserve_unknown_enum.pb.swift rename to Reference/upstream/google/protobuf/unittest_preserve_unknown_enum.pb.swift index d5f420d0f..0fe74d58b 100644 --- a/Reference/google/protobuf/unittest_preserve_unknown_enum.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_preserve_unknown_enum.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/unittest_preserve_unknown_enum.proto @@ -9,35 +10,11 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -import Foundation +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -50,7 +27,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum Proto3PreserveUnknownEnumUnittest_MyEnum: SwiftProtobuf.Enum { +enum Proto3PreserveUnknownEnumUnittest_MyEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foo // = 0 case bar // = 1 @@ -79,22 +56,16 @@ enum Proto3PreserveUnknownEnumUnittest_MyEnum: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension Proto3PreserveUnknownEnumUnittest_MyEnum: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto3PreserveUnknownEnumUnittest_MyEnum] = [ + static let allCases: [Proto3PreserveUnknownEnumUnittest_MyEnum] = [ .foo, .bar, .baz, ] -} -#endif // swift(>=4.2) +} -enum Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra: SwiftProtobuf.Enum { +enum Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case eFoo // = 0 case eBar // = 1 @@ -126,23 +97,17 @@ enum Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra] = [ + static let allCases: [Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra] = [ .eFoo, .eBar, .eBaz, .eExtra, ] -} -#endif // swift(>=4.2) +} -struct Proto3PreserveUnknownEnumUnittest_MyMessage { +struct Proto3PreserveUnknownEnumUnittest_MyMessage: Sendable { // 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. @@ -176,34 +141,16 @@ struct Proto3PreserveUnknownEnumUnittest_MyMessage { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_O: Equatable { + enum OneOf_O: Equatable, Sendable { case oneofE1(Proto3PreserveUnknownEnumUnittest_MyEnum) case oneofE2(Proto3PreserveUnknownEnumUnittest_MyEnum) - #if !swift(>=4.1) - static func ==(lhs: Proto3PreserveUnknownEnumUnittest_MyMessage.OneOf_O, rhs: Proto3PreserveUnknownEnumUnittest_MyMessage.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 (.oneofE1, .oneofE1): return { - guard case .oneofE1(let l) = lhs, case .oneofE1(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofE2, .oneofE2): return { - guard case .oneofE2(let l) = lhs, case .oneofE2(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } init() {} } -struct Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra { +struct Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra: Sendable { // 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. @@ -236,73 +183,30 @@ struct Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_O: Equatable { + enum OneOf_O: Equatable, Sendable { case oneofE1(Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra) case oneofE2(Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra) - #if !swift(>=4.1) - static func ==(lhs: Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra.OneOf_O, rhs: Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra.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 (.oneofE1, .oneofE1): return { - guard case .oneofE1(let l) = lhs, case .oneofE1(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofE2, .oneofE2): return { - guard case .oneofE2(let l) = lhs, case .oneofE2(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Proto3PreserveUnknownEnumUnittest_MyEnum: @unchecked Sendable {} -extension Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra: @unchecked Sendable {} -extension Proto3PreserveUnknownEnumUnittest_MyMessage: @unchecked Sendable {} -extension Proto3PreserveUnknownEnumUnittest_MyMessage.OneOf_O: @unchecked Sendable {} -extension Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra: @unchecked Sendable {} -extension Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra.OneOf_O: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "proto3_preserve_unknown_enum_unittest" extension Proto3PreserveUnknownEnumUnittest_MyEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOO\0\u{1}BAR\0\u{1}BAZ\0") } extension Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "E_FOO"), - 1: .same(proto: "E_BAR"), - 2: .same(proto: "E_BAZ"), - 3: .same(proto: "E_EXTRA"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0E_FOO\0\u{1}E_BAR\0\u{1}E_BAZ\0\u{1}E_EXTRA\0") } extension Proto3PreserveUnknownEnumUnittest_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MyMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "e"), - 2: .standard(proto: "repeated_e"), - 3: .standard(proto: "repeated_packed_e"), - 4: .standard(proto: "repeated_packed_unexpected_e"), - 5: .standard(proto: "oneof_e_1"), - 6: .standard(proto: "oneof_e_2"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}e\0\u{3}repeated_e\0\u{3}repeated_packed_e\0\u{3}repeated_packed_unexpected_e\0\u{3}oneof_e_1\0\u{3}oneof_e_2\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -379,14 +283,7 @@ extension Proto3PreserveUnknownEnumUnittest_MyMessage: SwiftProtobuf.Message, Sw extension Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MyMessagePlusExtra" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "e"), - 2: .standard(proto: "repeated_e"), - 3: .standard(proto: "repeated_packed_e"), - 4: .standard(proto: "repeated_packed_unexpected_e"), - 5: .standard(proto: "oneof_e_1"), - 6: .standard(proto: "oneof_e_2"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}e\0\u{3}repeated_e\0\u{3}repeated_packed_e\0\u{3}repeated_packed_unexpected_e\0\u{3}oneof_e_1\0\u{3}oneof_e_2\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { diff --git a/Reference/upstream/google/protobuf/unittest_preserve_unknown_enum2.pb.swift b/Reference/upstream/google/protobuf/unittest_preserve_unknown_enum2.pb.swift new file mode 100644 index 000000000..d953e5353 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_preserve_unknown_enum2.pb.swift @@ -0,0 +1,176 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_preserve_unknown_enum2.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +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 Proto2PreserveUnknownEnumUnittest_MyEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 + + init() { + self = .foo + } + +} + +struct Proto2PreserveUnknownEnumUnittest_MyMessage: Sendable { + // 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 e: Proto2PreserveUnknownEnumUnittest_MyEnum { + get {_e ?? .foo} + set {_e = newValue} + } + /// Returns true if `e` has been explicitly set. + var hasE: Bool {self._e != nil} + /// Clears the value of `e`. Subsequent reads from it will return its default value. + mutating func clearE() {self._e = nil} + + var repeatedE: [Proto2PreserveUnknownEnumUnittest_MyEnum] = [] + + var repeatedPackedE: [Proto2PreserveUnknownEnumUnittest_MyEnum] = [] + + /// not packed + var repeatedPackedUnexpectedE: [Proto2PreserveUnknownEnumUnittest_MyEnum] = [] + + var o: Proto2PreserveUnknownEnumUnittest_MyMessage.OneOf_O? = nil + + var oneofE1: Proto2PreserveUnknownEnumUnittest_MyEnum { + get { + if case .oneofE1(let v)? = o {return v} + return .foo + } + set {o = .oneofE1(newValue)} + } + + var oneofE2: Proto2PreserveUnknownEnumUnittest_MyEnum { + get { + if case .oneofE2(let v)? = o {return v} + return .foo + } + set {o = .oneofE2(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_O: Equatable, Sendable { + case oneofE1(Proto2PreserveUnknownEnumUnittest_MyEnum) + case oneofE2(Proto2PreserveUnknownEnumUnittest_MyEnum) + + } + + init() {} + + fileprivate var _e: Proto2PreserveUnknownEnumUnittest_MyEnum? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_preserve_unknown_enum_unittest" + +extension Proto2PreserveUnknownEnumUnittest_MyEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension Proto2PreserveUnknownEnumUnittest_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MyMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}e\0\u{3}repeated_e\0\u{3}repeated_packed_e\0\u{3}repeated_packed_unexpected_e\0\u{3}oneof_e_1\0\u{3}oneof_e_2\0") + + 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._e) }() + case 2: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedE) }() + case 3: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedPackedE) }() + case 4: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedPackedUnexpectedE) }() + case 5: try { + var v: Proto2PreserveUnknownEnumUnittest_MyEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if self.o != nil {try decoder.handleConflictingOneOf()} + self.o = .oneofE1(v) + } + }() + case 6: try { + var v: Proto2PreserveUnknownEnumUnittest_MyEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if self.o != nil {try decoder.handleConflictingOneOf()} + self.o = .oneofE2(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 + try { if let v = self._e { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + if !self.repeatedE.isEmpty { + try visitor.visitRepeatedEnumField(value: self.repeatedE, fieldNumber: 2) + } + if !self.repeatedPackedE.isEmpty { + try visitor.visitPackedEnumField(value: self.repeatedPackedE, fieldNumber: 3) + } + if !self.repeatedPackedUnexpectedE.isEmpty { + try visitor.visitRepeatedEnumField(value: self.repeatedPackedUnexpectedE, fieldNumber: 4) + } + switch self.o { + case .oneofE1?: try { + guard case .oneofE1(let v)? = self.o else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + }() + case .oneofE2?: try { + guard case .oneofE2(let v)? = self.o else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2PreserveUnknownEnumUnittest_MyMessage, rhs: Proto2PreserveUnknownEnumUnittest_MyMessage) -> Bool { + if lhs._e != rhs._e {return false} + if lhs.repeatedE != rhs.repeatedE {return false} + if lhs.repeatedPackedE != rhs.repeatedPackedE {return false} + if lhs.repeatedPackedUnexpectedE != rhs.repeatedPackedUnexpectedE {return false} + if lhs.o != rhs.o {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/google/protobuf/unittest_proto3_arena.pb.swift b/Reference/upstream/google/protobuf/unittest_proto3.pb.swift similarity index 52% rename from Reference/google/protobuf/unittest_proto3_arena.pb.swift rename to Reference/upstream/google/protobuf/unittest_proto3.pb.swift index 7519c6c25..7a440ab0d 100644 --- a/Reference/google/protobuf/unittest_proto3_arena.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_proto3.pb.swift @@ -1,41 +1,19 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_proto3_arena.proto +// Source: google/protobuf/unittest_proto3.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd import Foundation import SwiftProtobuf @@ -50,12 +28,15 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum Proto3ArenaUnittest_ForeignEnum: SwiftProtobuf.Enum { +enum Proto3Unittest_ForeignEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foreignZero // = 0 case foreignFoo // = 4 case foreignBar // = 5 case foreignBaz // = 6 + + /// Large enough to escape the Boxed Integer cache. + case foreignLarge // = 123456 case UNRECOGNIZED(Int) init() { @@ -68,6 +49,7 @@ enum Proto3ArenaUnittest_ForeignEnum: SwiftProtobuf.Enum { case 4: self = .foreignFoo case 5: self = .foreignBar case 6: self = .foreignBaz + case 123456: self = .foreignLarge default: self = .UNRECOGNIZED(rawValue) } } @@ -78,433 +60,302 @@ enum Proto3ArenaUnittest_ForeignEnum: SwiftProtobuf.Enum { case .foreignFoo: return 4 case .foreignBar: return 5 case .foreignBaz: return 6 + case .foreignLarge: return 123456 case .UNRECOGNIZED(let i): return i } } -} - -#if swift(>=4.2) - -extension Proto3ArenaUnittest_ForeignEnum: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto3ArenaUnittest_ForeignEnum] = [ + static let allCases: [Proto3Unittest_ForeignEnum] = [ .foreignZero, .foreignFoo, .foreignBar, .foreignBaz, + .foreignLarge, ] -} -#endif // swift(>=4.2) +} /// This proto includes every type of field in both singular and repeated /// forms. -struct Proto3ArenaUnittest_TestAllTypes { +struct Proto3Unittest_TestAllTypes: @unchecked Sendable { // 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. /// Singular var optionalInt32: Int32 { - get {return _storage._optionalInt32} + get {_storage._optionalInt32} set {_uniqueStorage()._optionalInt32 = newValue} } var optionalInt64: Int64 { - get {return _storage._optionalInt64} + get {_storage._optionalInt64} set {_uniqueStorage()._optionalInt64 = newValue} } var optionalUint32: UInt32 { - get {return _storage._optionalUint32} + get {_storage._optionalUint32} set {_uniqueStorage()._optionalUint32 = newValue} } var optionalUint64: UInt64 { - get {return _storage._optionalUint64} + get {_storage._optionalUint64} set {_uniqueStorage()._optionalUint64 = newValue} } var optionalSint32: Int32 { - get {return _storage._optionalSint32} + get {_storage._optionalSint32} set {_uniqueStorage()._optionalSint32 = newValue} } var optionalSint64: Int64 { - get {return _storage._optionalSint64} + get {_storage._optionalSint64} set {_uniqueStorage()._optionalSint64 = newValue} } var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32} + get {_storage._optionalFixed32} set {_uniqueStorage()._optionalFixed32 = newValue} } var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64} + get {_storage._optionalFixed64} set {_uniqueStorage()._optionalFixed64 = newValue} } var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32} + get {_storage._optionalSfixed32} set {_uniqueStorage()._optionalSfixed32 = newValue} } var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64} + get {_storage._optionalSfixed64} set {_uniqueStorage()._optionalSfixed64 = newValue} } var optionalFloat: Float { - get {return _storage._optionalFloat} + get {_storage._optionalFloat} set {_uniqueStorage()._optionalFloat = newValue} } var optionalDouble: Double { - get {return _storage._optionalDouble} + get {_storage._optionalDouble} set {_uniqueStorage()._optionalDouble = newValue} } var optionalBool: Bool { - get {return _storage._optionalBool} + get {_storage._optionalBool} set {_uniqueStorage()._optionalBool = newValue} } var optionalString: String { - get {return _storage._optionalString} + get {_storage._optionalString} set {_uniqueStorage()._optionalString = newValue} } var optionalBytes: Data { - get {return _storage._optionalBytes} + get {_storage._optionalBytes} set {_uniqueStorage()._optionalBytes = newValue} } - var optionalNestedMessage: Proto3ArenaUnittest_TestAllTypes.NestedMessage { - get {return _storage._optionalNestedMessage ?? Proto3ArenaUnittest_TestAllTypes.NestedMessage()} + var optionalNestedMessage: Proto3Unittest_TestAllTypes.NestedMessage { + get {_storage._optionalNestedMessage ?? Proto3Unittest_TestAllTypes.NestedMessage()} set {_uniqueStorage()._optionalNestedMessage = newValue} } /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} - var optionalForeignMessage: Proto3ArenaUnittest_ForeignMessage { - get {return _storage._optionalForeignMessage ?? Proto3ArenaUnittest_ForeignMessage()} + var optionalForeignMessage: Proto3Unittest_ForeignMessage { + get {_storage._optionalForeignMessage ?? Proto3Unittest_ForeignMessage()} set {_uniqueStorage()._optionalForeignMessage = newValue} } /// Returns true if `optionalForeignMessage` has been explicitly set. - var hasOptionalForeignMessage: Bool {return _storage._optionalForeignMessage != nil} + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} - var optionalImportMessage: ProtobufUnittestImport_ImportMessage { - get {return _storage._optionalImportMessage ?? ProtobufUnittestImport_ImportMessage()} + var optionalImportMessage: Proto2UnittestImport_ImportMessage { + get {_storage._optionalImportMessage ?? Proto2UnittestImport_ImportMessage()} set {_uniqueStorage()._optionalImportMessage = newValue} } /// Returns true if `optionalImportMessage` has been explicitly set. - var hasOptionalImportMessage: Bool {return _storage._optionalImportMessage != nil} + var hasOptionalImportMessage: Bool {_storage._optionalImportMessage != nil} /// Clears the value of `optionalImportMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalImportMessage() {_uniqueStorage()._optionalImportMessage = nil} - var optionalNestedEnum: Proto3ArenaUnittest_TestAllTypes.NestedEnum { - get {return _storage._optionalNestedEnum} + var optionalNestedEnum: Proto3Unittest_TestAllTypes.NestedEnum { + get {_storage._optionalNestedEnum} set {_uniqueStorage()._optionalNestedEnum = newValue} } - var optionalForeignEnum: Proto3ArenaUnittest_ForeignEnum { - get {return _storage._optionalForeignEnum} + var optionalForeignEnum: Proto3Unittest_ForeignEnum { + get {_storage._optionalForeignEnum} set {_uniqueStorage()._optionalForeignEnum = newValue} } var optionalStringPiece: String { - get {return _storage._optionalStringPiece} + get {_storage._optionalStringPiece} set {_uniqueStorage()._optionalStringPiece = newValue} } var optionalCord: String { - get {return _storage._optionalCord} + get {_storage._optionalCord} set {_uniqueStorage()._optionalCord = newValue} } /// Defined in unittest_import_public.proto - var optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessage { - get {return _storage._optionalPublicImportMessage ?? ProtobufUnittestImport_PublicImportMessage()} + var optionalPublicImportMessage: Proto2UnittestImport_PublicImportMessage { + get {_storage._optionalPublicImportMessage ?? Proto2UnittestImport_PublicImportMessage()} set {_uniqueStorage()._optionalPublicImportMessage = newValue} } /// Returns true if `optionalPublicImportMessage` has been explicitly set. - var hasOptionalPublicImportMessage: Bool {return _storage._optionalPublicImportMessage != nil} + var hasOptionalPublicImportMessage: Bool {_storage._optionalPublicImportMessage != nil} /// Clears the value of `optionalPublicImportMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalPublicImportMessage() {_uniqueStorage()._optionalPublicImportMessage = nil} - var optionalLazyMessage: Proto3ArenaUnittest_TestAllTypes.NestedMessage { - get {return _storage._optionalLazyMessage ?? Proto3ArenaUnittest_TestAllTypes.NestedMessage()} + var optionalLazyMessage: Proto3Unittest_TestAllTypes.NestedMessage { + get {_storage._optionalLazyMessage ?? Proto3Unittest_TestAllTypes.NestedMessage()} set {_uniqueStorage()._optionalLazyMessage = newValue} } /// Returns true if `optionalLazyMessage` has been explicitly set. - var hasOptionalLazyMessage: Bool {return _storage._optionalLazyMessage != nil} + var hasOptionalLazyMessage: Bool {_storage._optionalLazyMessage != nil} /// Clears the value of `optionalLazyMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalLazyMessage() {_uniqueStorage()._optionalLazyMessage = nil} - var optionalLazyImportMessage: ProtobufUnittestImport_ImportMessage { - get {return _storage._optionalLazyImportMessage ?? ProtobufUnittestImport_ImportMessage()} + var optionalUnverifiedLazyMessage: Proto3Unittest_TestAllTypes.NestedMessage { + get {_storage._optionalUnverifiedLazyMessage ?? Proto3Unittest_TestAllTypes.NestedMessage()} + set {_uniqueStorage()._optionalUnverifiedLazyMessage = newValue} + } + /// Returns true if `optionalUnverifiedLazyMessage` has been explicitly set. + var hasOptionalUnverifiedLazyMessage: Bool {_storage._optionalUnverifiedLazyMessage != nil} + /// Clears the value of `optionalUnverifiedLazyMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalUnverifiedLazyMessage() {_uniqueStorage()._optionalUnverifiedLazyMessage = nil} + + var optionalLazyImportMessage: Proto2UnittestImport_ImportMessage { + get {_storage._optionalLazyImportMessage ?? Proto2UnittestImport_ImportMessage()} set {_uniqueStorage()._optionalLazyImportMessage = newValue} } /// Returns true if `optionalLazyImportMessage` has been explicitly set. - var hasOptionalLazyImportMessage: Bool {return _storage._optionalLazyImportMessage != nil} + var hasOptionalLazyImportMessage: Bool {_storage._optionalLazyImportMessage != nil} /// Clears the value of `optionalLazyImportMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalLazyImportMessage() {_uniqueStorage()._optionalLazyImportMessage = nil} /// Repeated var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } - /// Optional - var proto3OptionalInt32: Int32 { - get {return _storage._proto3OptionalInt32 ?? 0} - set {_uniqueStorage()._proto3OptionalInt32 = newValue} - } - /// Returns true if `proto3OptionalInt32` has been explicitly set. - var hasProto3OptionalInt32: Bool {return _storage._proto3OptionalInt32 != nil} - /// Clears the value of `proto3OptionalInt32`. Subsequent reads from it will return its default value. - mutating func clearProto3OptionalInt32() {_uniqueStorage()._proto3OptionalInt32 = nil} - - var proto3OptionalInt64: Int64 { - get {return _storage._proto3OptionalInt64 ?? 0} - set {_uniqueStorage()._proto3OptionalInt64 = newValue} - } - /// Returns true if `proto3OptionalInt64` has been explicitly set. - var hasProto3OptionalInt64: Bool {return _storage._proto3OptionalInt64 != nil} - /// Clears the value of `proto3OptionalInt64`. Subsequent reads from it will return its default value. - mutating func clearProto3OptionalInt64() {_uniqueStorage()._proto3OptionalInt64 = nil} - - var proto3OptionalUint32: UInt32 { - get {return _storage._proto3OptionalUint32 ?? 0} - set {_uniqueStorage()._proto3OptionalUint32 = newValue} - } - /// Returns true if `proto3OptionalUint32` has been explicitly set. - var hasProto3OptionalUint32: Bool {return _storage._proto3OptionalUint32 != nil} - /// Clears the value of `proto3OptionalUint32`. Subsequent reads from it will return its default value. - mutating func clearProto3OptionalUint32() {_uniqueStorage()._proto3OptionalUint32 = nil} - - var proto3OptionalUint64: UInt64 { - get {return _storage._proto3OptionalUint64 ?? 0} - set {_uniqueStorage()._proto3OptionalUint64 = newValue} - } - /// Returns true if `proto3OptionalUint64` has been explicitly set. - var hasProto3OptionalUint64: Bool {return _storage._proto3OptionalUint64 != nil} - /// Clears the value of `proto3OptionalUint64`. Subsequent reads from it will return its default value. - mutating func clearProto3OptionalUint64() {_uniqueStorage()._proto3OptionalUint64 = nil} - - var proto3OptionalSint32: Int32 { - get {return _storage._proto3OptionalSint32 ?? 0} - set {_uniqueStorage()._proto3OptionalSint32 = newValue} - } - /// Returns true if `proto3OptionalSint32` has been explicitly set. - var hasProto3OptionalSint32: Bool {return _storage._proto3OptionalSint32 != nil} - /// Clears the value of `proto3OptionalSint32`. Subsequent reads from it will return its default value. - mutating func clearProto3OptionalSint32() {_uniqueStorage()._proto3OptionalSint32 = nil} - - var proto3OptionalSint64: Int64 { - get {return _storage._proto3OptionalSint64 ?? 0} - set {_uniqueStorage()._proto3OptionalSint64 = newValue} - } - /// Returns true if `proto3OptionalSint64` has been explicitly set. - var hasProto3OptionalSint64: Bool {return _storage._proto3OptionalSint64 != nil} - /// Clears the value of `proto3OptionalSint64`. Subsequent reads from it will return its default value. - mutating func clearProto3OptionalSint64() {_uniqueStorage()._proto3OptionalSint64 = nil} - - var proto3OptionalFixed32: UInt32 { - get {return _storage._proto3OptionalFixed32 ?? 0} - set {_uniqueStorage()._proto3OptionalFixed32 = newValue} - } - /// Returns true if `proto3OptionalFixed32` has been explicitly set. - var hasProto3OptionalFixed32: Bool {return _storage._proto3OptionalFixed32 != nil} - /// Clears the value of `proto3OptionalFixed32`. Subsequent reads from it will return its default value. - mutating func clearProto3OptionalFixed32() {_uniqueStorage()._proto3OptionalFixed32 = nil} - - var proto3OptionalFixed64: UInt64 { - get {return _storage._proto3OptionalFixed64 ?? 0} - set {_uniqueStorage()._proto3OptionalFixed64 = newValue} - } - /// Returns true if `proto3OptionalFixed64` has been explicitly set. - var hasProto3OptionalFixed64: Bool {return _storage._proto3OptionalFixed64 != nil} - /// Clears the value of `proto3OptionalFixed64`. Subsequent reads from it will return its default value. - mutating func clearProto3OptionalFixed64() {_uniqueStorage()._proto3OptionalFixed64 = nil} - - var proto3OptionalSfixed32: Int32 { - get {return _storage._proto3OptionalSfixed32 ?? 0} - set {_uniqueStorage()._proto3OptionalSfixed32 = newValue} - } - /// Returns true if `proto3OptionalSfixed32` has been explicitly set. - var hasProto3OptionalSfixed32: Bool {return _storage._proto3OptionalSfixed32 != nil} - /// Clears the value of `proto3OptionalSfixed32`. Subsequent reads from it will return its default value. - mutating func clearProto3OptionalSfixed32() {_uniqueStorage()._proto3OptionalSfixed32 = nil} - - var proto3OptionalSfixed64: Int64 { - get {return _storage._proto3OptionalSfixed64 ?? 0} - set {_uniqueStorage()._proto3OptionalSfixed64 = newValue} - } - /// Returns true if `proto3OptionalSfixed64` has been explicitly set. - var hasProto3OptionalSfixed64: Bool {return _storage._proto3OptionalSfixed64 != nil} - /// Clears the value of `proto3OptionalSfixed64`. Subsequent reads from it will return its default value. - mutating func clearProto3OptionalSfixed64() {_uniqueStorage()._proto3OptionalSfixed64 = nil} - - var proto3OptionalFloat: Float { - get {return _storage._proto3OptionalFloat ?? 0} - set {_uniqueStorage()._proto3OptionalFloat = newValue} - } - /// Returns true if `proto3OptionalFloat` has been explicitly set. - var hasProto3OptionalFloat: Bool {return _storage._proto3OptionalFloat != nil} - /// Clears the value of `proto3OptionalFloat`. Subsequent reads from it will return its default value. - mutating func clearProto3OptionalFloat() {_uniqueStorage()._proto3OptionalFloat = nil} - - var proto3OptionalDouble: Double { - get {return _storage._proto3OptionalDouble ?? 0} - set {_uniqueStorage()._proto3OptionalDouble = newValue} - } - /// Returns true if `proto3OptionalDouble` has been explicitly set. - var hasProto3OptionalDouble: Bool {return _storage._proto3OptionalDouble != nil} - /// Clears the value of `proto3OptionalDouble`. Subsequent reads from it will return its default value. - mutating func clearProto3OptionalDouble() {_uniqueStorage()._proto3OptionalDouble = nil} - - var proto3OptionalBool: Bool { - get {return _storage._proto3OptionalBool ?? false} - set {_uniqueStorage()._proto3OptionalBool = newValue} - } - /// Returns true if `proto3OptionalBool` has been explicitly set. - var hasProto3OptionalBool: Bool {return _storage._proto3OptionalBool != nil} - /// Clears the value of `proto3OptionalBool`. Subsequent reads from it will return its default value. - mutating func clearProto3OptionalBool() {_uniqueStorage()._proto3OptionalBool = nil} - - var proto3OptionalString: String { - get {return _storage._proto3OptionalString ?? String()} - set {_uniqueStorage()._proto3OptionalString = newValue} - } - /// Returns true if `proto3OptionalString` has been explicitly set. - var hasProto3OptionalString: Bool {return _storage._proto3OptionalString != nil} - /// Clears the value of `proto3OptionalString`. Subsequent reads from it will return its default value. - mutating func clearProto3OptionalString() {_uniqueStorage()._proto3OptionalString = nil} - - var proto3OptionalBytes: Data { - get {return _storage._proto3OptionalBytes ?? Data()} - set {_uniqueStorage()._proto3OptionalBytes = newValue} - } - /// Returns true if `proto3OptionalBytes` has been explicitly set. - var hasProto3OptionalBytes: Bool {return _storage._proto3OptionalBytes != nil} - /// Clears the value of `proto3OptionalBytes`. Subsequent reads from it will return its default value. - mutating func clearProto3OptionalBytes() {_uniqueStorage()._proto3OptionalBytes = nil} - - var repeatedNestedMessage: [Proto3ArenaUnittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedNestedMessage} + var repeatedNestedMessage: [Proto3Unittest_TestAllTypes.NestedMessage] { + get {_storage._repeatedNestedMessage} set {_uniqueStorage()._repeatedNestedMessage = newValue} } - var repeatedForeignMessage: [Proto3ArenaUnittest_ForeignMessage] { - get {return _storage._repeatedForeignMessage} + var repeatedForeignMessage: [Proto3Unittest_ForeignMessage] { + get {_storage._repeatedForeignMessage} set {_uniqueStorage()._repeatedForeignMessage = newValue} } - var repeatedImportMessage: [ProtobufUnittestImport_ImportMessage] { - get {return _storage._repeatedImportMessage} + var repeatedImportMessage: [Proto2UnittestImport_ImportMessage] { + get {_storage._repeatedImportMessage} set {_uniqueStorage()._repeatedImportMessage = newValue} } - var repeatedNestedEnum: [Proto3ArenaUnittest_TestAllTypes.NestedEnum] { - get {return _storage._repeatedNestedEnum} + var repeatedNestedEnum: [Proto3Unittest_TestAllTypes.NestedEnum] { + get {_storage._repeatedNestedEnum} set {_uniqueStorage()._repeatedNestedEnum = newValue} } - var repeatedForeignEnum: [Proto3ArenaUnittest_ForeignEnum] { - get {return _storage._repeatedForeignEnum} + var repeatedForeignEnum: [Proto3Unittest_ForeignEnum] { + get {_storage._repeatedForeignEnum} set {_uniqueStorage()._repeatedForeignEnum = newValue} } var repeatedStringPiece: [String] { - get {return _storage._repeatedStringPiece} + get {_storage._repeatedStringPiece} set {_uniqueStorage()._repeatedStringPiece = newValue} } var repeatedCord: [String] { - get {return _storage._repeatedCord} + get {_storage._repeatedCord} set {_uniqueStorage()._repeatedCord = newValue} } - var repeatedLazyMessage: [Proto3ArenaUnittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedLazyMessage} + var repeatedLazyMessage: [Proto3Unittest_TestAllTypes.NestedMessage] { + get {_storage._repeatedLazyMessage} set {_uniqueStorage()._repeatedLazyMessage = newValue} } @@ -521,10 +372,10 @@ struct Proto3ArenaUnittest_TestAllTypes { set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} } - var oneofNestedMessage: Proto3ArenaUnittest_TestAllTypes.NestedMessage { + var oneofNestedMessage: Proto3Unittest_TestAllTypes.NestedMessage { get { if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} - return Proto3ArenaUnittest_TestAllTypes.NestedMessage() + return Proto3Unittest_TestAllTypes.NestedMessage() } set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} } @@ -547,41 +398,15 @@ struct Proto3ArenaUnittest_TestAllTypes { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case oneofUint32(UInt32) - case oneofNestedMessage(Proto3ArenaUnittest_TestAllTypes.NestedMessage) + case oneofNestedMessage(Proto3Unittest_TestAllTypes.NestedMessage) case oneofString(String) case oneofBytes(Data) - #if !swift(>=4.1) - static func ==(lhs: Proto3ArenaUnittest_TestAllTypes.OneOf_OneofField, rhs: Proto3ArenaUnittest_TestAllTypes.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum NestedEnum: SwiftProtobuf.Enum { + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case zero // = 0 case foo // = 1 @@ -618,9 +443,18 @@ struct Proto3ArenaUnittest_TestAllTypes { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Proto3Unittest_TestAllTypes.NestedEnum] = [ + .zero, + .foo, + .bar, + .baz, + .neg, + ] + } - struct NestedMessage { + struct NestedMessage: Sendable { // 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. @@ -640,22 +474,7 @@ struct Proto3ArenaUnittest_TestAllTypes { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension Proto3ArenaUnittest_TestAllTypes.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto3ArenaUnittest_TestAllTypes.NestedEnum] = [ - .zero, - .foo, - .bar, - .baz, - .neg, - ] -} - -#endif // swift(>=4.2) - -struct Proto3ArenaUnittest_TestPackedTypes { +struct Proto3Unittest_TestPackedTypes: Sendable { // 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. @@ -686,7 +505,7 @@ struct Proto3ArenaUnittest_TestPackedTypes { var packedBool: [Bool] = [] - var packedEnum: [Proto3ArenaUnittest_ForeignEnum] = [] + var packedEnum: [Proto3Unittest_ForeignEnum] = [] var unknownFields = SwiftProtobuf.UnknownStorage() @@ -694,7 +513,7 @@ struct Proto3ArenaUnittest_TestPackedTypes { } /// Explicitly set packed to false -struct Proto3ArenaUnittest_TestUnpackedTypes { +struct Proto3Unittest_TestUnpackedTypes: Sendable { // 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. @@ -725,7 +544,7 @@ struct Proto3ArenaUnittest_TestUnpackedTypes { var repeatedBool: [Bool] = [] - var repeatedNestedEnum: [Proto3ArenaUnittest_TestAllTypes.NestedEnum] = [] + var repeatedNestedEnum: [Proto3Unittest_TestAllTypes.NestedEnum] = [] var unknownFields = SwiftProtobuf.UnknownStorage() @@ -733,34 +552,29 @@ struct Proto3ArenaUnittest_TestUnpackedTypes { } /// This proto includes a recursively nested message. -struct Proto3ArenaUnittest_NestedTestAllTypes { +struct Proto3Unittest_NestedTestAllTypes: @unchecked Sendable { // 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 child: Proto3ArenaUnittest_NestedTestAllTypes { - get {return _storage._child ?? Proto3ArenaUnittest_NestedTestAllTypes()} + var child: Proto3Unittest_NestedTestAllTypes { + get {_storage._child ?? Proto3Unittest_NestedTestAllTypes()} set {_uniqueStorage()._child = newValue} } /// Returns true if `child` has been explicitly set. - var hasChild: Bool {return _storage._child != nil} + var hasChild: Bool {_storage._child != nil} /// Clears the value of `child`. Subsequent reads from it will return its default value. mutating func clearChild() {_uniqueStorage()._child = nil} - var payload: Proto3ArenaUnittest_TestAllTypes { - get {return _storage._payload ?? Proto3ArenaUnittest_TestAllTypes()} + var payload: Proto3Unittest_TestAllTypes { + get {_storage._payload ?? Proto3Unittest_TestAllTypes()} set {_uniqueStorage()._payload = newValue} } /// Returns true if `payload` has been explicitly set. - var hasPayload: Bool {return _storage._payload != nil} + var hasPayload: Bool {_storage._payload != nil} /// Clears the value of `payload`. Subsequent reads from it will return its default value. mutating func clearPayload() {_uniqueStorage()._payload = nil} - var repeatedChild: [Proto3ArenaUnittest_NestedTestAllTypes] { - get {return _storage._repeatedChild} - set {_uniqueStorage()._repeatedChild = newValue} - } - var unknownFields = SwiftProtobuf.UnknownStorage() init() {} @@ -770,7 +584,7 @@ struct Proto3ArenaUnittest_NestedTestAllTypes { /// Define these after TestAllTypes to make sure the compiler can handle /// that. -struct Proto3ArenaUnittest_ForeignMessage { +struct Proto3Unittest_ForeignMessage: Sendable { // 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. @@ -783,7 +597,7 @@ struct Proto3ArenaUnittest_ForeignMessage { } /// TestEmptyMessage is used to test behavior of unknown fields. -struct Proto3ArenaUnittest_TestEmptyMessage { +struct Proto3Unittest_TestEmptyMessage: Sendable { // 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. @@ -793,141 +607,470 @@ struct Proto3ArenaUnittest_TestEmptyMessage { init() {} } -/// Needed for a Python test. -struct Proto3ArenaUnittest_TestPickleNestedMessage { +/// TestMessageWithDummy is also used to test behavior of unknown fields. +struct Proto3Unittest_TestMessageWithDummy: Sendable { // 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. + /// This field is only here for triggering copy-on-write; it's not intended to + /// be serialized. + var dummy: Bool = false + var unknownFields = SwiftProtobuf.UnknownStorage() - struct NestedMessage { - // 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. + init() {} +} - var bb: Int32 = 0 +/// Same layout as TestOneof2 in unittest.proto to test unknown enum value +/// parsing behavior in oneof. +struct Proto3Unittest_TestOneof2: Sendable { + // 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() + var foo: Proto3Unittest_TestOneof2.OneOf_Foo? = nil + + var fooEnum: Proto3Unittest_TestOneof2.NestedEnum { + get { + if case .fooEnum(let v)? = foo {return v} + return .unknown + } + set {foo = .fooEnum(newValue)} + } - struct NestedNestedMessage { - // 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() - var cc: Int32 = 0 + enum OneOf_Foo: Equatable, Sendable { + case fooEnum(Proto3Unittest_TestOneof2.NestedEnum) - var unknownFields = SwiftProtobuf.UnknownStorage() + } - init() {} + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case unknown // = 0 + case foo // = 1 + case bar // = 2 + case baz // = 3 + case UNRECOGNIZED(Int) + + init() { + self = .unknown } - init() {} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .unknown + case 1: self = .foo + case 2: self = .bar + case 3: self = .baz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .unknown: return 0 + case .foo: return 1 + case .bar: return 2 + case .baz: return 3 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Proto3Unittest_TestOneof2.NestedEnum] = [ + .unknown, + .foo, + .bar, + .baz, + ] + } init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Proto3ArenaUnittest_ForeignEnum: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestAllTypes: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestAllTypes.OneOf_OneofField: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestAllTypes.NestedEnum: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestAllTypes.NestedMessage: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestPackedTypes: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestUnpackedTypes: @unchecked Sendable {} -extension Proto3ArenaUnittest_NestedTestAllTypes: @unchecked Sendable {} -extension Proto3ArenaUnittest_ForeignMessage: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestEmptyMessage: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestPickleNestedMessage: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestPickleNestedMessage.NestedMessage: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) +/// If bool fields are incorrectly assumed to have hasbits, InternalSwap would +/// result in swapping N more 32bit hasbits incorrectly. Considering padding, we +/// need many bool fields to stress this. +struct Proto3Unittest_TestHasbits: @unchecked Sendable { + // 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 b1: Bool { + get {_storage._b1} + set {_uniqueStorage()._b1 = newValue} + } + + var b2: Bool { + get {_storage._b2} + set {_uniqueStorage()._b2 = newValue} + } + + var b3: Bool { + get {_storage._b3} + set {_uniqueStorage()._b3 = newValue} + } + + var b4: Bool { + get {_storage._b4} + set {_uniqueStorage()._b4 = newValue} + } + + var b5: Bool { + get {_storage._b5} + set {_uniqueStorage()._b5 = newValue} + } + + var b6: Bool { + get {_storage._b6} + set {_uniqueStorage()._b6 = newValue} + } + + var b7: Bool { + get {_storage._b7} + set {_uniqueStorage()._b7 = newValue} + } + + var b8: Bool { + get {_storage._b8} + set {_uniqueStorage()._b8 = newValue} + } + + var b9: Bool { + get {_storage._b9} + set {_uniqueStorage()._b9 = newValue} + } + + var b10: Bool { + get {_storage._b10} + set {_uniqueStorage()._b10 = newValue} + } + + var b11: Bool { + get {_storage._b11} + set {_uniqueStorage()._b11 = newValue} + } + + var b12: Bool { + get {_storage._b12} + set {_uniqueStorage()._b12 = newValue} + } + + var b13: Bool { + get {_storage._b13} + set {_uniqueStorage()._b13 = newValue} + } + + var b14: Bool { + get {_storage._b14} + set {_uniqueStorage()._b14 = newValue} + } + + var b15: Bool { + get {_storage._b15} + set {_uniqueStorage()._b15 = newValue} + } + + var b16: Bool { + get {_storage._b16} + set {_uniqueStorage()._b16 = newValue} + } + + var b17: Bool { + get {_storage._b17} + set {_uniqueStorage()._b17 = newValue} + } + + var b18: Bool { + get {_storage._b18} + set {_uniqueStorage()._b18 = newValue} + } + + var b19: Bool { + get {_storage._b19} + set {_uniqueStorage()._b19 = newValue} + } + + var b20: Bool { + get {_storage._b20} + set {_uniqueStorage()._b20 = newValue} + } + + var b21: Bool { + get {_storage._b21} + set {_uniqueStorage()._b21 = newValue} + } + + var b22: Bool { + get {_storage._b22} + set {_uniqueStorage()._b22 = newValue} + } + + var b23: Bool { + get {_storage._b23} + set {_uniqueStorage()._b23 = newValue} + } + + var b24: Bool { + get {_storage._b24} + set {_uniqueStorage()._b24 = newValue} + } + + var b25: Bool { + get {_storage._b25} + set {_uniqueStorage()._b25 = newValue} + } + + var b26: Bool { + get {_storage._b26} + set {_uniqueStorage()._b26 = newValue} + } + + var b27: Bool { + get {_storage._b27} + set {_uniqueStorage()._b27 = newValue} + } + + var b28: Bool { + get {_storage._b28} + set {_uniqueStorage()._b28 = newValue} + } + + var b29: Bool { + get {_storage._b29} + set {_uniqueStorage()._b29 = newValue} + } + + var b30: Bool { + get {_storage._b30} + set {_uniqueStorage()._b30 = newValue} + } + + var b31: Bool { + get {_storage._b31} + set {_uniqueStorage()._b31 = newValue} + } + + var b32: Bool { + get {_storage._b32} + set {_uniqueStorage()._b32 = newValue} + } + + var b33: Bool { + get {_storage._b33} + set {_uniqueStorage()._b33 = newValue} + } + + var b34: Bool { + get {_storage._b34} + set {_uniqueStorage()._b34 = newValue} + } + + var b35: Bool { + get {_storage._b35} + set {_uniqueStorage()._b35 = newValue} + } + + var b36: Bool { + get {_storage._b36} + set {_uniqueStorage()._b36 = newValue} + } + + var b37: Bool { + get {_storage._b37} + set {_uniqueStorage()._b37 = newValue} + } + + var b38: Bool { + get {_storage._b38} + set {_uniqueStorage()._b38 = newValue} + } + + var b39: Bool { + get {_storage._b39} + set {_uniqueStorage()._b39 = newValue} + } + + var b40: Bool { + get {_storage._b40} + set {_uniqueStorage()._b40 = newValue} + } + + var b41: Bool { + get {_storage._b41} + set {_uniqueStorage()._b41 = newValue} + } + + var b42: Bool { + get {_storage._b42} + set {_uniqueStorage()._b42 = newValue} + } + + var b43: Bool { + get {_storage._b43} + set {_uniqueStorage()._b43 = newValue} + } + + var b44: Bool { + get {_storage._b44} + set {_uniqueStorage()._b44 = newValue} + } + + var b45: Bool { + get {_storage._b45} + set {_uniqueStorage()._b45 = newValue} + } + + var b46: Bool { + get {_storage._b46} + set {_uniqueStorage()._b46 = newValue} + } + + var b47: Bool { + get {_storage._b47} + set {_uniqueStorage()._b47 = newValue} + } + + var b48: Bool { + get {_storage._b48} + set {_uniqueStorage()._b48 = newValue} + } + + var b49: Bool { + get {_storage._b49} + set {_uniqueStorage()._b49 = newValue} + } + + var b50: Bool { + get {_storage._b50} + set {_uniqueStorage()._b50 = newValue} + } + + var b51: Bool { + get {_storage._b51} + set {_uniqueStorage()._b51 = newValue} + } + + var b52: Bool { + get {_storage._b52} + set {_uniqueStorage()._b52 = newValue} + } + + var b53: Bool { + get {_storage._b53} + set {_uniqueStorage()._b53 = newValue} + } + + var b54: Bool { + get {_storage._b54} + set {_uniqueStorage()._b54 = newValue} + } + + var b55: Bool { + get {_storage._b55} + set {_uniqueStorage()._b55 = newValue} + } + + var b56: Bool { + get {_storage._b56} + set {_uniqueStorage()._b56 = newValue} + } + + var b57: Bool { + get {_storage._b57} + set {_uniqueStorage()._b57 = newValue} + } + + var b58: Bool { + get {_storage._b58} + set {_uniqueStorage()._b58 = newValue} + } + + var b59: Bool { + get {_storage._b59} + set {_uniqueStorage()._b59 = newValue} + } + + var b60: Bool { + get {_storage._b60} + set {_uniqueStorage()._b60 = newValue} + } + + var b61: Bool { + get {_storage._b61} + set {_uniqueStorage()._b61 = newValue} + } + + var b62: Bool { + get {_storage._b62} + set {_uniqueStorage()._b62 = newValue} + } + + var b63: Bool { + get {_storage._b63} + set {_uniqueStorage()._b63 = newValue} + } + + var b64: Bool { + get {_storage._b64} + set {_uniqueStorage()._b64 = newValue} + } + + var b65: Bool { + get {_storage._b65} + set {_uniqueStorage()._b65 = newValue} + } + + var b66: Bool { + get {_storage._b66} + set {_uniqueStorage()._b66 = newValue} + } + + var b67: Bool { + get {_storage._b67} + set {_uniqueStorage()._b67 = newValue} + } + + var b68: Bool { + get {_storage._b68} + set {_uniqueStorage()._b68 = newValue} + } + + var b69: Bool { + get {_storage._b69} + set {_uniqueStorage()._b69 = newValue} + } + + var child: Proto3Unittest_TestAllTypes { + get {_storage._child ?? Proto3Unittest_TestAllTypes()} + set {_uniqueStorage()._child = newValue} + } + /// Returns true if `child` has been explicitly set. + var hasChild: Bool {_storage._child != nil} + /// Clears the value of `child`. Subsequent reads from it will return its default value. + mutating func clearChild() {_uniqueStorage()._child = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "proto3_arena_unittest" +fileprivate let _protobuf_package = "proto3_unittest" -extension Proto3ArenaUnittest_ForeignEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOREIGN_ZERO"), - 4: .same(proto: "FOREIGN_FOO"), - 5: .same(proto: "FOREIGN_BAR"), - 6: .same(proto: "FOREIGN_BAZ"), - ] +extension Proto3Unittest_ForeignEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_ZERO\0\u{2}\u{4}FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0\u{2}zH\u{1e}FOREIGN_LARGE\0") } -extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "optional_foreign_message"), - 20: .standard(proto: "optional_import_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "optional_foreign_enum"), - 24: .standard(proto: "optional_string_piece"), - 25: .standard(proto: "optional_cord"), - 26: .standard(proto: "optional_public_import_message"), - 27: .standard(proto: "optional_lazy_message"), - 115: .standard(proto: "optional_lazy_import_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 116: .standard(proto: "proto3_optional_int32"), - 117: .standard(proto: "proto3_optional_int64"), - 118: .standard(proto: "proto3_optional_uint32"), - 119: .standard(proto: "proto3_optional_uint64"), - 120: .standard(proto: "proto3_optional_sint32"), - 121: .standard(proto: "proto3_optional_sint64"), - 122: .standard(proto: "proto3_optional_fixed32"), - 123: .standard(proto: "proto3_optional_fixed64"), - 124: .standard(proto: "proto3_optional_sfixed32"), - 125: .standard(proto: "proto3_optional_sfixed64"), - 126: .standard(proto: "proto3_optional_float"), - 127: .standard(proto: "proto3_optional_double"), - 128: .standard(proto: "proto3_optional_bool"), - 129: .standard(proto: "proto3_optional_string"), - 130: .standard(proto: "proto3_optional_bytes"), - 48: .standard(proto: "repeated_nested_message"), - 49: .standard(proto: "repeated_foreign_message"), - 50: .standard(proto: "repeated_import_message"), - 51: .standard(proto: "repeated_nested_enum"), - 52: .standard(proto: "repeated_foreign_enum"), - 54: .standard(proto: "repeated_string_piece"), - 55: .standard(proto: "repeated_cord"), - 57: .standard(proto: "repeated_lazy_message"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{3}optional_import_message\0\u{3}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{4}\u{2}optional_string_piece\0\u{3}optional_cord\0\u{3}optional_public_import_message\0\u{3}optional_lazy_message\0\u{3}optional_unverified_lazy_message\0\u{4}\u{3}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{3}repeated_import_message\0\u{3}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{4}\u{2}repeated_lazy_message\0\u{4}6oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}optional_lazy_import_message\0") fileprivate class _StorageClass { var _optionalInt32: Int32 = 0 @@ -945,16 +1088,17 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf var _optionalBool: Bool = false var _optionalString: String = String() var _optionalBytes: Data = Data() - var _optionalNestedMessage: Proto3ArenaUnittest_TestAllTypes.NestedMessage? = nil - var _optionalForeignMessage: Proto3ArenaUnittest_ForeignMessage? = nil - var _optionalImportMessage: ProtobufUnittestImport_ImportMessage? = nil - var _optionalNestedEnum: Proto3ArenaUnittest_TestAllTypes.NestedEnum = .zero - var _optionalForeignEnum: Proto3ArenaUnittest_ForeignEnum = .foreignZero + var _optionalNestedMessage: Proto3Unittest_TestAllTypes.NestedMessage? = nil + var _optionalForeignMessage: Proto3Unittest_ForeignMessage? = nil + var _optionalImportMessage: Proto2UnittestImport_ImportMessage? = nil + var _optionalNestedEnum: Proto3Unittest_TestAllTypes.NestedEnum = .zero + var _optionalForeignEnum: Proto3Unittest_ForeignEnum = .foreignZero var _optionalStringPiece: String = String() var _optionalCord: String = String() - var _optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessage? = nil - var _optionalLazyMessage: Proto3ArenaUnittest_TestAllTypes.NestedMessage? = nil - var _optionalLazyImportMessage: ProtobufUnittestImport_ImportMessage? = nil + var _optionalPublicImportMessage: Proto2UnittestImport_PublicImportMessage? = nil + var _optionalLazyMessage: Proto3Unittest_TestAllTypes.NestedMessage? = nil + var _optionalUnverifiedLazyMessage: Proto3Unittest_TestAllTypes.NestedMessage? = nil + var _optionalLazyImportMessage: Proto2UnittestImport_ImportMessage? = nil var _repeatedInt32: [Int32] = [] var _repeatedInt64: [Int64] = [] var _repeatedUint32: [UInt32] = [] @@ -970,32 +1114,21 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf var _repeatedBool: [Bool] = [] var _repeatedString: [String] = [] var _repeatedBytes: [Data] = [] - var _proto3OptionalInt32: Int32? = nil - var _proto3OptionalInt64: Int64? = nil - var _proto3OptionalUint32: UInt32? = nil - var _proto3OptionalUint64: UInt64? = nil - var _proto3OptionalSint32: Int32? = nil - var _proto3OptionalSint64: Int64? = nil - var _proto3OptionalFixed32: UInt32? = nil - var _proto3OptionalFixed64: UInt64? = nil - var _proto3OptionalSfixed32: Int32? = nil - var _proto3OptionalSfixed64: Int64? = nil - var _proto3OptionalFloat: Float? = nil - var _proto3OptionalDouble: Double? = nil - var _proto3OptionalBool: Bool? = nil - var _proto3OptionalString: String? = nil - var _proto3OptionalBytes: Data? = nil - var _repeatedNestedMessage: [Proto3ArenaUnittest_TestAllTypes.NestedMessage] = [] - var _repeatedForeignMessage: [Proto3ArenaUnittest_ForeignMessage] = [] - var _repeatedImportMessage: [ProtobufUnittestImport_ImportMessage] = [] - var _repeatedNestedEnum: [Proto3ArenaUnittest_TestAllTypes.NestedEnum] = [] - var _repeatedForeignEnum: [Proto3ArenaUnittest_ForeignEnum] = [] + var _repeatedNestedMessage: [Proto3Unittest_TestAllTypes.NestedMessage] = [] + var _repeatedForeignMessage: [Proto3Unittest_ForeignMessage] = [] + var _repeatedImportMessage: [Proto2UnittestImport_ImportMessage] = [] + var _repeatedNestedEnum: [Proto3Unittest_TestAllTypes.NestedEnum] = [] + var _repeatedForeignEnum: [Proto3Unittest_ForeignEnum] = [] var _repeatedStringPiece: [String] = [] var _repeatedCord: [String] = [] - var _repeatedLazyMessage: [Proto3ArenaUnittest_TestAllTypes.NestedMessage] = [] - var _oneofField: Proto3ArenaUnittest_TestAllTypes.OneOf_OneofField? + var _repeatedLazyMessage: [Proto3Unittest_TestAllTypes.NestedMessage] = [] + var _oneofField: Proto3Unittest_TestAllTypes.OneOf_OneofField? - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1024,6 +1157,7 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf _optionalCord = source._optionalCord _optionalPublicImportMessage = source._optionalPublicImportMessage _optionalLazyMessage = source._optionalLazyMessage + _optionalUnverifiedLazyMessage = source._optionalUnverifiedLazyMessage _optionalLazyImportMessage = source._optionalLazyImportMessage _repeatedInt32 = source._repeatedInt32 _repeatedInt64 = source._repeatedInt64 @@ -1040,21 +1174,6 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf _repeatedBool = source._repeatedBool _repeatedString = source._repeatedString _repeatedBytes = source._repeatedBytes - _proto3OptionalInt32 = source._proto3OptionalInt32 - _proto3OptionalInt64 = source._proto3OptionalInt64 - _proto3OptionalUint32 = source._proto3OptionalUint32 - _proto3OptionalUint64 = source._proto3OptionalUint64 - _proto3OptionalSint32 = source._proto3OptionalSint32 - _proto3OptionalSint64 = source._proto3OptionalSint64 - _proto3OptionalFixed32 = source._proto3OptionalFixed32 - _proto3OptionalFixed64 = source._proto3OptionalFixed64 - _proto3OptionalSfixed32 = source._proto3OptionalSfixed32 - _proto3OptionalSfixed64 = source._proto3OptionalSfixed64 - _proto3OptionalFloat = source._proto3OptionalFloat - _proto3OptionalDouble = source._proto3OptionalDouble - _proto3OptionalBool = source._proto3OptionalBool - _proto3OptionalString = source._proto3OptionalString - _proto3OptionalBytes = source._proto3OptionalBytes _repeatedNestedMessage = source._repeatedNestedMessage _repeatedForeignMessage = source._repeatedForeignMessage _repeatedImportMessage = source._repeatedImportMessage @@ -1106,6 +1225,7 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() case 26: try { try decoder.decodeSingularMessageField(value: &_storage._optionalPublicImportMessage) }() case 27: try { try decoder.decodeSingularMessageField(value: &_storage._optionalLazyMessage) }() + case 28: try { try decoder.decodeSingularMessageField(value: &_storage._optionalUnverifiedLazyMessage) }() case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() @@ -1138,7 +1258,7 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf } }() case 112: try { - var v: Proto3ArenaUnittest_TestAllTypes.NestedMessage? + var v: Proto3Unittest_TestAllTypes.NestedMessage? var hadOneofValue = false if let current = _storage._oneofField { hadOneofValue = true @@ -1167,21 +1287,6 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf } }() case 115: try { try decoder.decodeSingularMessageField(value: &_storage._optionalLazyImportMessage) }() - case 116: try { try decoder.decodeSingularInt32Field(value: &_storage._proto3OptionalInt32) }() - case 117: try { try decoder.decodeSingularInt64Field(value: &_storage._proto3OptionalInt64) }() - case 118: try { try decoder.decodeSingularUInt32Field(value: &_storage._proto3OptionalUint32) }() - case 119: try { try decoder.decodeSingularUInt64Field(value: &_storage._proto3OptionalUint64) }() - case 120: try { try decoder.decodeSingularSInt32Field(value: &_storage._proto3OptionalSint32) }() - case 121: try { try decoder.decodeSingularSInt64Field(value: &_storage._proto3OptionalSint64) }() - case 122: try { try decoder.decodeSingularFixed32Field(value: &_storage._proto3OptionalFixed32) }() - case 123: try { try decoder.decodeSingularFixed64Field(value: &_storage._proto3OptionalFixed64) }() - case 124: try { try decoder.decodeSingularSFixed32Field(value: &_storage._proto3OptionalSfixed32) }() - case 125: try { try decoder.decodeSingularSFixed64Field(value: &_storage._proto3OptionalSfixed64) }() - case 126: try { try decoder.decodeSingularFloatField(value: &_storage._proto3OptionalFloat) }() - case 127: try { try decoder.decodeSingularDoubleField(value: &_storage._proto3OptionalDouble) }() - case 128: try { try decoder.decodeSingularBoolField(value: &_storage._proto3OptionalBool) }() - case 129: try { try decoder.decodeSingularStringField(value: &_storage._proto3OptionalString) }() - case 130: try { try decoder.decodeSingularBytesField(value: &_storage._proto3OptionalBytes) }() default: break } } @@ -1224,10 +1329,10 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf if _storage._optionalSfixed64 != 0 { try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) } - if _storage._optionalFloat != 0 { + if _storage._optionalFloat.bitPattern != 0 { try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) } - if _storage._optionalDouble != 0 { + if _storage._optionalDouble.bitPattern != 0 { try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) } if _storage._optionalBool != false { @@ -1266,6 +1371,9 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf try { if let v = _storage._optionalLazyMessage { try visitor.visitSingularMessageField(value: v, fieldNumber: 27) } }() + try { if let v = _storage._optionalUnverifiedLazyMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 28) + } }() if !_storage._repeatedInt32.isEmpty { try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) } @@ -1357,56 +1465,11 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf try { if let v = _storage._optionalLazyImportMessage { try visitor.visitSingularMessageField(value: v, fieldNumber: 115) } }() - try { if let v = _storage._proto3OptionalInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 116) - } }() - try { if let v = _storage._proto3OptionalInt64 { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 117) - } }() - try { if let v = _storage._proto3OptionalUint32 { - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 118) - } }() - try { if let v = _storage._proto3OptionalUint64 { - try visitor.visitSingularUInt64Field(value: v, fieldNumber: 119) - } }() - try { if let v = _storage._proto3OptionalSint32 { - try visitor.visitSingularSInt32Field(value: v, fieldNumber: 120) - } }() - try { if let v = _storage._proto3OptionalSint64 { - try visitor.visitSingularSInt64Field(value: v, fieldNumber: 121) - } }() - try { if let v = _storage._proto3OptionalFixed32 { - try visitor.visitSingularFixed32Field(value: v, fieldNumber: 122) - } }() - try { if let v = _storage._proto3OptionalFixed64 { - try visitor.visitSingularFixed64Field(value: v, fieldNumber: 123) - } }() - try { if let v = _storage._proto3OptionalSfixed32 { - try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 124) - } }() - try { if let v = _storage._proto3OptionalSfixed64 { - try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 125) - } }() - try { if let v = _storage._proto3OptionalFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 126) - } }() - try { if let v = _storage._proto3OptionalDouble { - try visitor.visitSingularDoubleField(value: v, fieldNumber: 127) - } }() - try { if let v = _storage._proto3OptionalBool { - try visitor.visitSingularBoolField(value: v, fieldNumber: 128) - } }() - try { if let v = _storage._proto3OptionalString { - try visitor.visitSingularStringField(value: v, fieldNumber: 129) - } }() - try { if let v = _storage._proto3OptionalBytes { - try visitor.visitSingularBytesField(value: v, fieldNumber: 130) - } }() } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3ArenaUnittest_TestAllTypes, rhs: Proto3ArenaUnittest_TestAllTypes) -> Bool { + static func ==(lhs: Proto3Unittest_TestAllTypes, rhs: Proto3Unittest_TestAllTypes) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -1435,6 +1498,7 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf if _storage._optionalCord != rhs_storage._optionalCord {return false} if _storage._optionalPublicImportMessage != rhs_storage._optionalPublicImportMessage {return false} if _storage._optionalLazyMessage != rhs_storage._optionalLazyMessage {return false} + if _storage._optionalUnverifiedLazyMessage != rhs_storage._optionalUnverifiedLazyMessage {return false} if _storage._optionalLazyImportMessage != rhs_storage._optionalLazyImportMessage {return false} if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} @@ -1451,21 +1515,6 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf if _storage._repeatedBool != rhs_storage._repeatedBool {return false} if _storage._repeatedString != rhs_storage._repeatedString {return false} if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} - if _storage._proto3OptionalInt32 != rhs_storage._proto3OptionalInt32 {return false} - if _storage._proto3OptionalInt64 != rhs_storage._proto3OptionalInt64 {return false} - if _storage._proto3OptionalUint32 != rhs_storage._proto3OptionalUint32 {return false} - if _storage._proto3OptionalUint64 != rhs_storage._proto3OptionalUint64 {return false} - if _storage._proto3OptionalSint32 != rhs_storage._proto3OptionalSint32 {return false} - if _storage._proto3OptionalSint64 != rhs_storage._proto3OptionalSint64 {return false} - if _storage._proto3OptionalFixed32 != rhs_storage._proto3OptionalFixed32 {return false} - if _storage._proto3OptionalFixed64 != rhs_storage._proto3OptionalFixed64 {return false} - if _storage._proto3OptionalSfixed32 != rhs_storage._proto3OptionalSfixed32 {return false} - if _storage._proto3OptionalSfixed64 != rhs_storage._proto3OptionalSfixed64 {return false} - if _storage._proto3OptionalFloat != rhs_storage._proto3OptionalFloat {return false} - if _storage._proto3OptionalDouble != rhs_storage._proto3OptionalDouble {return false} - if _storage._proto3OptionalBool != rhs_storage._proto3OptionalBool {return false} - if _storage._proto3OptionalString != rhs_storage._proto3OptionalString {return false} - if _storage._proto3OptionalBytes != rhs_storage._proto3OptionalBytes {return false} if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} if _storage._repeatedImportMessage != rhs_storage._repeatedImportMessage {return false} @@ -1484,21 +1533,13 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf } } -extension Proto3ArenaUnittest_TestAllTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -1: .same(proto: "NEG"), - 0: .same(proto: "ZERO"), - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - 3: .same(proto: "BAZ"), - ] +extension Proto3Unittest_TestAllTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}ZERO\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") } -extension Proto3ArenaUnittest_TestAllTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = Proto3ArenaUnittest_TestAllTypes.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - ] +extension Proto3Unittest_TestAllTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto3Unittest_TestAllTypes.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1519,31 +1560,16 @@ extension Proto3ArenaUnittest_TestAllTypes.NestedMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3ArenaUnittest_TestAllTypes.NestedMessage, rhs: Proto3ArenaUnittest_TestAllTypes.NestedMessage) -> Bool { + static func ==(lhs: Proto3Unittest_TestAllTypes.NestedMessage, rhs: Proto3Unittest_TestAllTypes.NestedMessage) -> Bool { if lhs.bb != rhs.bb {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Proto3ArenaUnittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto3Unittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestPackedTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 90: .standard(proto: "packed_int32"), - 91: .standard(proto: "packed_int64"), - 92: .standard(proto: "packed_uint32"), - 93: .standard(proto: "packed_uint64"), - 94: .standard(proto: "packed_sint32"), - 95: .standard(proto: "packed_sint64"), - 96: .standard(proto: "packed_fixed32"), - 97: .standard(proto: "packed_fixed64"), - 98: .standard(proto: "packed_sfixed32"), - 99: .standard(proto: "packed_sfixed64"), - 100: .standard(proto: "packed_float"), - 101: .standard(proto: "packed_double"), - 102: .standard(proto: "packed_bool"), - 103: .standard(proto: "packed_enum"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}Z\u{1}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1616,7 +1642,7 @@ extension Proto3ArenaUnittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3ArenaUnittest_TestPackedTypes, rhs: Proto3ArenaUnittest_TestPackedTypes) -> Bool { + static func ==(lhs: Proto3Unittest_TestPackedTypes, rhs: Proto3Unittest_TestPackedTypes) -> Bool { if lhs.packedInt32 != rhs.packedInt32 {return false} if lhs.packedInt64 != rhs.packedInt64 {return false} if lhs.packedUint32 != rhs.packedUint32 {return false} @@ -1636,24 +1662,9 @@ extension Proto3ArenaUnittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProto } } -extension Proto3ArenaUnittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto3Unittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestUnpackedTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "repeated_int32"), - 2: .standard(proto: "repeated_int64"), - 3: .standard(proto: "repeated_uint32"), - 4: .standard(proto: "repeated_uint64"), - 5: .standard(proto: "repeated_sint32"), - 6: .standard(proto: "repeated_sint64"), - 7: .standard(proto: "repeated_fixed32"), - 8: .standard(proto: "repeated_fixed64"), - 9: .standard(proto: "repeated_sfixed32"), - 10: .standard(proto: "repeated_sfixed64"), - 11: .standard(proto: "repeated_float"), - 12: .standard(proto: "repeated_double"), - 13: .standard(proto: "repeated_bool"), - 14: .standard(proto: "repeated_nested_enum"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_nested_enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1726,7 +1737,7 @@ extension Proto3ArenaUnittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3ArenaUnittest_TestUnpackedTypes, rhs: Proto3ArenaUnittest_TestUnpackedTypes) -> Bool { + static func ==(lhs: Proto3Unittest_TestUnpackedTypes, rhs: Proto3Unittest_TestUnpackedTypes) -> Bool { if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} if lhs.repeatedInt64 != rhs.repeatedInt64 {return false} if lhs.repeatedUint32 != rhs.repeatedUint32 {return false} @@ -1746,27 +1757,25 @@ extension Proto3ArenaUnittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftPro } } -extension Proto3ArenaUnittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto3Unittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".NestedTestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "child"), - 2: .same(proto: "payload"), - 3: .standard(proto: "repeated_child"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}child\0\u{1}payload\0") fileprivate class _StorageClass { - var _child: Proto3ArenaUnittest_NestedTestAllTypes? = nil - var _payload: Proto3ArenaUnittest_TestAllTypes? = nil - var _repeatedChild: [Proto3ArenaUnittest_NestedTestAllTypes] = [] + var _child: Proto3Unittest_NestedTestAllTypes? = nil + var _payload: Proto3Unittest_TestAllTypes? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} init(copying source: _StorageClass) { _child = source._child _payload = source._payload - _repeatedChild = source._repeatedChild } } @@ -1787,7 +1796,6 @@ extension Proto3ArenaUnittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftPr switch fieldNumber { case 1: try { try decoder.decodeSingularMessageField(value: &_storage._child) }() case 2: try { try decoder.decodeSingularMessageField(value: &_storage._payload) }() - case 3: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedChild) }() default: break } } @@ -1806,21 +1814,17 @@ extension Proto3ArenaUnittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftPr try { if let v = _storage._payload { try visitor.visitSingularMessageField(value: v, fieldNumber: 2) } }() - if !_storage._repeatedChild.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedChild, fieldNumber: 3) - } } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3ArenaUnittest_NestedTestAllTypes, rhs: Proto3ArenaUnittest_NestedTestAllTypes) -> Bool { + static func ==(lhs: Proto3Unittest_NestedTestAllTypes, rhs: Proto3Unittest_NestedTestAllTypes) -> 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._child != rhs_storage._child {return false} if _storage._payload != rhs_storage._payload {return false} - if _storage._repeatedChild != rhs_storage._repeatedChild {return false} return true } if !storagesAreEqual {return false} @@ -1830,11 +1834,9 @@ extension Proto3ArenaUnittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftPr } } -extension Proto3ArenaUnittest_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto3Unittest_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ForeignMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1855,56 +1857,65 @@ extension Proto3ArenaUnittest_ForeignMessage: SwiftProtobuf.Message, SwiftProtob try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3ArenaUnittest_ForeignMessage, rhs: Proto3ArenaUnittest_ForeignMessage) -> Bool { + static func ==(lhs: Proto3Unittest_ForeignMessage, rhs: Proto3Unittest_ForeignMessage) -> Bool { if lhs.c != rhs.c {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Proto3ArenaUnittest_TestEmptyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto3Unittest_TestEmptyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestEmptyMessage" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3ArenaUnittest_TestEmptyMessage, rhs: Proto3ArenaUnittest_TestEmptyMessage) -> Bool { + static func ==(lhs: Proto3Unittest_TestEmptyMessage, rhs: Proto3Unittest_TestEmptyMessage) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Proto3ArenaUnittest_TestPickleNestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestPickleNestedMessage" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() +extension Proto3Unittest_TestMessageWithDummy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageWithDummy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{1f}dummy\0") mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { + 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 536870911: try { try decoder.decodeSingularBoolField(value: &self.dummy) }() + default: break + } } } func traverse(visitor: inout V) throws { + if self.dummy != false { + try visitor.visitSingularBoolField(value: self.dummy, fieldNumber: 536870911) + } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3ArenaUnittest_TestPickleNestedMessage, rhs: Proto3ArenaUnittest_TestPickleNestedMessage) -> Bool { + static func ==(lhs: Proto3Unittest_TestMessageWithDummy, rhs: Proto3Unittest_TestMessageWithDummy) -> Bool { + if lhs.dummy != rhs.dummy {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Proto3ArenaUnittest_TestPickleNestedMessage.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = Proto3ArenaUnittest_TestPickleNestedMessage.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - ] +extension Proto3Unittest_TestOneof2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestOneof2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{6}foo_enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1912,53 +1923,589 @@ extension Proto3ArenaUnittest_TestPickleNestedMessage.NestedMessage: SwiftProtob // 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.bb) }() + case 6: try { + var v: Proto3Unittest_TestOneof2.NestedEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooEnum(v) + } + }() default: break } } } func traverse(visitor: inout V) throws { - if self.bb != 0 { - try visitor.visitSingularInt32Field(value: self.bb, fieldNumber: 1) - } + // 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 case .fooEnum(let v)? = self.foo { + try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3ArenaUnittest_TestPickleNestedMessage.NestedMessage, rhs: Proto3ArenaUnittest_TestPickleNestedMessage.NestedMessage) -> Bool { - if lhs.bb != rhs.bb {return false} + static func ==(lhs: Proto3Unittest_TestOneof2, rhs: Proto3Unittest_TestOneof2) -> Bool { + if lhs.foo != rhs.foo {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Proto3ArenaUnittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = Proto3ArenaUnittest_TestPickleNestedMessage.NestedMessage.protoMessageName + ".NestedNestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "cc"), - ] +extension Proto3Unittest_TestOneof2.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNKNOWN\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension Proto3Unittest_TestHasbits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestHasbits" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}b1\0\u{1}b2\0\u{1}b3\0\u{1}b4\0\u{1}b5\0\u{1}b6\0\u{1}b7\0\u{1}b8\0\u{1}b9\0\u{1}b10\0\u{1}b11\0\u{1}b12\0\u{1}b13\0\u{1}b14\0\u{1}b15\0\u{1}b16\0\u{1}b17\0\u{1}b18\0\u{1}b19\0\u{1}b20\0\u{1}b21\0\u{1}b22\0\u{1}b23\0\u{1}b24\0\u{1}b25\0\u{1}b26\0\u{1}b27\0\u{1}b28\0\u{1}b29\0\u{1}b30\0\u{1}b31\0\u{1}b32\0\u{1}b33\0\u{1}b34\0\u{1}b35\0\u{1}b36\0\u{1}b37\0\u{1}b38\0\u{1}b39\0\u{1}b40\0\u{1}b41\0\u{1}b42\0\u{1}b43\0\u{1}b44\0\u{1}b45\0\u{1}b46\0\u{1}b47\0\u{1}b48\0\u{1}b49\0\u{1}b50\0\u{1}b51\0\u{1}b52\0\u{1}b53\0\u{1}b54\0\u{1}b55\0\u{1}b56\0\u{1}b57\0\u{1}b58\0\u{1}b59\0\u{1}b60\0\u{1}b61\0\u{1}b62\0\u{1}b63\0\u{1}b64\0\u{1}b65\0\u{1}b66\0\u{1}b67\0\u{1}b68\0\u{1}b69\0\u{2}\u{1f}child\0") + + fileprivate class _StorageClass { + var _b1: Bool = false + var _b2: Bool = false + var _b3: Bool = false + var _b4: Bool = false + var _b5: Bool = false + var _b6: Bool = false + var _b7: Bool = false + var _b8: Bool = false + var _b9: Bool = false + var _b10: Bool = false + var _b11: Bool = false + var _b12: Bool = false + var _b13: Bool = false + var _b14: Bool = false + var _b15: Bool = false + var _b16: Bool = false + var _b17: Bool = false + var _b18: Bool = false + var _b19: Bool = false + var _b20: Bool = false + var _b21: Bool = false + var _b22: Bool = false + var _b23: Bool = false + var _b24: Bool = false + var _b25: Bool = false + var _b26: Bool = false + var _b27: Bool = false + var _b28: Bool = false + var _b29: Bool = false + var _b30: Bool = false + var _b31: Bool = false + var _b32: Bool = false + var _b33: Bool = false + var _b34: Bool = false + var _b35: Bool = false + var _b36: Bool = false + var _b37: Bool = false + var _b38: Bool = false + var _b39: Bool = false + var _b40: Bool = false + var _b41: Bool = false + var _b42: Bool = false + var _b43: Bool = false + var _b44: Bool = false + var _b45: Bool = false + var _b46: Bool = false + var _b47: Bool = false + var _b48: Bool = false + var _b49: Bool = false + var _b50: Bool = false + var _b51: Bool = false + var _b52: Bool = false + var _b53: Bool = false + var _b54: Bool = false + var _b55: Bool = false + var _b56: Bool = false + var _b57: Bool = false + var _b58: Bool = false + var _b59: Bool = false + var _b60: Bool = false + var _b61: Bool = false + var _b62: Bool = false + var _b63: Bool = false + var _b64: Bool = false + var _b65: Bool = false + var _b66: Bool = false + var _b67: Bool = false + var _b68: Bool = false + var _b69: Bool = false + var _child: Proto3Unittest_TestAllTypes? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _b1 = source._b1 + _b2 = source._b2 + _b3 = source._b3 + _b4 = source._b4 + _b5 = source._b5 + _b6 = source._b6 + _b7 = source._b7 + _b8 = source._b8 + _b9 = source._b9 + _b10 = source._b10 + _b11 = source._b11 + _b12 = source._b12 + _b13 = source._b13 + _b14 = source._b14 + _b15 = source._b15 + _b16 = source._b16 + _b17 = source._b17 + _b18 = source._b18 + _b19 = source._b19 + _b20 = source._b20 + _b21 = source._b21 + _b22 = source._b22 + _b23 = source._b23 + _b24 = source._b24 + _b25 = source._b25 + _b26 = source._b26 + _b27 = source._b27 + _b28 = source._b28 + _b29 = source._b29 + _b30 = source._b30 + _b31 = source._b31 + _b32 = source._b32 + _b33 = source._b33 + _b34 = source._b34 + _b35 = source._b35 + _b36 = source._b36 + _b37 = source._b37 + _b38 = source._b38 + _b39 = source._b39 + _b40 = source._b40 + _b41 = source._b41 + _b42 = source._b42 + _b43 = source._b43 + _b44 = source._b44 + _b45 = source._b45 + _b46 = source._b46 + _b47 = source._b47 + _b48 = source._b48 + _b49 = source._b49 + _b50 = source._b50 + _b51 = source._b51 + _b52 = source._b52 + _b53 = source._b53 + _b54 = source._b54 + _b55 = source._b55 + _b56 = source._b56 + _b57 = source._b57 + _b58 = source._b58 + _b59 = source._b59 + _b60 = source._b60 + _b61 = source._b61 + _b62 = source._b62 + _b63 = source._b63 + _b64 = source._b64 + _b65 = source._b65 + _b66 = source._b66 + _b67 = source._b67 + _b68 = source._b68 + _b69 = source._b69 + _child = source._child + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } 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.cc) }() - default: break + _ = _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.decodeSingularBoolField(value: &_storage._b1) }() + case 2: try { try decoder.decodeSingularBoolField(value: &_storage._b2) }() + case 3: try { try decoder.decodeSingularBoolField(value: &_storage._b3) }() + case 4: try { try decoder.decodeSingularBoolField(value: &_storage._b4) }() + case 5: try { try decoder.decodeSingularBoolField(value: &_storage._b5) }() + case 6: try { try decoder.decodeSingularBoolField(value: &_storage._b6) }() + case 7: try { try decoder.decodeSingularBoolField(value: &_storage._b7) }() + case 8: try { try decoder.decodeSingularBoolField(value: &_storage._b8) }() + case 9: try { try decoder.decodeSingularBoolField(value: &_storage._b9) }() + case 10: try { try decoder.decodeSingularBoolField(value: &_storage._b10) }() + case 11: try { try decoder.decodeSingularBoolField(value: &_storage._b11) }() + case 12: try { try decoder.decodeSingularBoolField(value: &_storage._b12) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._b13) }() + case 14: try { try decoder.decodeSingularBoolField(value: &_storage._b14) }() + case 15: try { try decoder.decodeSingularBoolField(value: &_storage._b15) }() + case 16: try { try decoder.decodeSingularBoolField(value: &_storage._b16) }() + case 17: try { try decoder.decodeSingularBoolField(value: &_storage._b17) }() + case 18: try { try decoder.decodeSingularBoolField(value: &_storage._b18) }() + case 19: try { try decoder.decodeSingularBoolField(value: &_storage._b19) }() + case 20: try { try decoder.decodeSingularBoolField(value: &_storage._b20) }() + case 21: try { try decoder.decodeSingularBoolField(value: &_storage._b21) }() + case 22: try { try decoder.decodeSingularBoolField(value: &_storage._b22) }() + case 23: try { try decoder.decodeSingularBoolField(value: &_storage._b23) }() + case 24: try { try decoder.decodeSingularBoolField(value: &_storage._b24) }() + case 25: try { try decoder.decodeSingularBoolField(value: &_storage._b25) }() + case 26: try { try decoder.decodeSingularBoolField(value: &_storage._b26) }() + case 27: try { try decoder.decodeSingularBoolField(value: &_storage._b27) }() + case 28: try { try decoder.decodeSingularBoolField(value: &_storage._b28) }() + case 29: try { try decoder.decodeSingularBoolField(value: &_storage._b29) }() + case 30: try { try decoder.decodeSingularBoolField(value: &_storage._b30) }() + case 31: try { try decoder.decodeSingularBoolField(value: &_storage._b31) }() + case 32: try { try decoder.decodeSingularBoolField(value: &_storage._b32) }() + case 33: try { try decoder.decodeSingularBoolField(value: &_storage._b33) }() + case 34: try { try decoder.decodeSingularBoolField(value: &_storage._b34) }() + case 35: try { try decoder.decodeSingularBoolField(value: &_storage._b35) }() + case 36: try { try decoder.decodeSingularBoolField(value: &_storage._b36) }() + case 37: try { try decoder.decodeSingularBoolField(value: &_storage._b37) }() + case 38: try { try decoder.decodeSingularBoolField(value: &_storage._b38) }() + case 39: try { try decoder.decodeSingularBoolField(value: &_storage._b39) }() + case 40: try { try decoder.decodeSingularBoolField(value: &_storage._b40) }() + case 41: try { try decoder.decodeSingularBoolField(value: &_storage._b41) }() + case 42: try { try decoder.decodeSingularBoolField(value: &_storage._b42) }() + case 43: try { try decoder.decodeSingularBoolField(value: &_storage._b43) }() + case 44: try { try decoder.decodeSingularBoolField(value: &_storage._b44) }() + case 45: try { try decoder.decodeSingularBoolField(value: &_storage._b45) }() + case 46: try { try decoder.decodeSingularBoolField(value: &_storage._b46) }() + case 47: try { try decoder.decodeSingularBoolField(value: &_storage._b47) }() + case 48: try { try decoder.decodeSingularBoolField(value: &_storage._b48) }() + case 49: try { try decoder.decodeSingularBoolField(value: &_storage._b49) }() + case 50: try { try decoder.decodeSingularBoolField(value: &_storage._b50) }() + case 51: try { try decoder.decodeSingularBoolField(value: &_storage._b51) }() + case 52: try { try decoder.decodeSingularBoolField(value: &_storage._b52) }() + case 53: try { try decoder.decodeSingularBoolField(value: &_storage._b53) }() + case 54: try { try decoder.decodeSingularBoolField(value: &_storage._b54) }() + case 55: try { try decoder.decodeSingularBoolField(value: &_storage._b55) }() + case 56: try { try decoder.decodeSingularBoolField(value: &_storage._b56) }() + case 57: try { try decoder.decodeSingularBoolField(value: &_storage._b57) }() + case 58: try { try decoder.decodeSingularBoolField(value: &_storage._b58) }() + case 59: try { try decoder.decodeSingularBoolField(value: &_storage._b59) }() + case 60: try { try decoder.decodeSingularBoolField(value: &_storage._b60) }() + case 61: try { try decoder.decodeSingularBoolField(value: &_storage._b61) }() + case 62: try { try decoder.decodeSingularBoolField(value: &_storage._b62) }() + case 63: try { try decoder.decodeSingularBoolField(value: &_storage._b63) }() + case 64: try { try decoder.decodeSingularBoolField(value: &_storage._b64) }() + case 65: try { try decoder.decodeSingularBoolField(value: &_storage._b65) }() + case 66: try { try decoder.decodeSingularBoolField(value: &_storage._b66) }() + case 67: try { try decoder.decodeSingularBoolField(value: &_storage._b67) }() + case 68: try { try decoder.decodeSingularBoolField(value: &_storage._b68) }() + case 69: try { try decoder.decodeSingularBoolField(value: &_storage._b69) }() + case 100: try { try decoder.decodeSingularMessageField(value: &_storage._child) }() + default: break + } } } } func traverse(visitor: inout V) throws { - if self.cc != 0 { - try visitor.visitSingularInt32Field(value: self.cc, fieldNumber: 1) + 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 + if _storage._b1 != false { + try visitor.visitSingularBoolField(value: _storage._b1, fieldNumber: 1) + } + if _storage._b2 != false { + try visitor.visitSingularBoolField(value: _storage._b2, fieldNumber: 2) + } + if _storage._b3 != false { + try visitor.visitSingularBoolField(value: _storage._b3, fieldNumber: 3) + } + if _storage._b4 != false { + try visitor.visitSingularBoolField(value: _storage._b4, fieldNumber: 4) + } + if _storage._b5 != false { + try visitor.visitSingularBoolField(value: _storage._b5, fieldNumber: 5) + } + if _storage._b6 != false { + try visitor.visitSingularBoolField(value: _storage._b6, fieldNumber: 6) + } + if _storage._b7 != false { + try visitor.visitSingularBoolField(value: _storage._b7, fieldNumber: 7) + } + if _storage._b8 != false { + try visitor.visitSingularBoolField(value: _storage._b8, fieldNumber: 8) + } + if _storage._b9 != false { + try visitor.visitSingularBoolField(value: _storage._b9, fieldNumber: 9) + } + if _storage._b10 != false { + try visitor.visitSingularBoolField(value: _storage._b10, fieldNumber: 10) + } + if _storage._b11 != false { + try visitor.visitSingularBoolField(value: _storage._b11, fieldNumber: 11) + } + if _storage._b12 != false { + try visitor.visitSingularBoolField(value: _storage._b12, fieldNumber: 12) + } + if _storage._b13 != false { + try visitor.visitSingularBoolField(value: _storage._b13, fieldNumber: 13) + } + if _storage._b14 != false { + try visitor.visitSingularBoolField(value: _storage._b14, fieldNumber: 14) + } + if _storage._b15 != false { + try visitor.visitSingularBoolField(value: _storage._b15, fieldNumber: 15) + } + if _storage._b16 != false { + try visitor.visitSingularBoolField(value: _storage._b16, fieldNumber: 16) + } + if _storage._b17 != false { + try visitor.visitSingularBoolField(value: _storage._b17, fieldNumber: 17) + } + if _storage._b18 != false { + try visitor.visitSingularBoolField(value: _storage._b18, fieldNumber: 18) + } + if _storage._b19 != false { + try visitor.visitSingularBoolField(value: _storage._b19, fieldNumber: 19) + } + if _storage._b20 != false { + try visitor.visitSingularBoolField(value: _storage._b20, fieldNumber: 20) + } + if _storage._b21 != false { + try visitor.visitSingularBoolField(value: _storage._b21, fieldNumber: 21) + } + if _storage._b22 != false { + try visitor.visitSingularBoolField(value: _storage._b22, fieldNumber: 22) + } + if _storage._b23 != false { + try visitor.visitSingularBoolField(value: _storage._b23, fieldNumber: 23) + } + if _storage._b24 != false { + try visitor.visitSingularBoolField(value: _storage._b24, fieldNumber: 24) + } + if _storage._b25 != false { + try visitor.visitSingularBoolField(value: _storage._b25, fieldNumber: 25) + } + if _storage._b26 != false { + try visitor.visitSingularBoolField(value: _storage._b26, fieldNumber: 26) + } + if _storage._b27 != false { + try visitor.visitSingularBoolField(value: _storage._b27, fieldNumber: 27) + } + if _storage._b28 != false { + try visitor.visitSingularBoolField(value: _storage._b28, fieldNumber: 28) + } + if _storage._b29 != false { + try visitor.visitSingularBoolField(value: _storage._b29, fieldNumber: 29) + } + if _storage._b30 != false { + try visitor.visitSingularBoolField(value: _storage._b30, fieldNumber: 30) + } + if _storage._b31 != false { + try visitor.visitSingularBoolField(value: _storage._b31, fieldNumber: 31) + } + if _storage._b32 != false { + try visitor.visitSingularBoolField(value: _storage._b32, fieldNumber: 32) + } + if _storage._b33 != false { + try visitor.visitSingularBoolField(value: _storage._b33, fieldNumber: 33) + } + if _storage._b34 != false { + try visitor.visitSingularBoolField(value: _storage._b34, fieldNumber: 34) + } + if _storage._b35 != false { + try visitor.visitSingularBoolField(value: _storage._b35, fieldNumber: 35) + } + if _storage._b36 != false { + try visitor.visitSingularBoolField(value: _storage._b36, fieldNumber: 36) + } + if _storage._b37 != false { + try visitor.visitSingularBoolField(value: _storage._b37, fieldNumber: 37) + } + if _storage._b38 != false { + try visitor.visitSingularBoolField(value: _storage._b38, fieldNumber: 38) + } + if _storage._b39 != false { + try visitor.visitSingularBoolField(value: _storage._b39, fieldNumber: 39) + } + if _storage._b40 != false { + try visitor.visitSingularBoolField(value: _storage._b40, fieldNumber: 40) + } + if _storage._b41 != false { + try visitor.visitSingularBoolField(value: _storage._b41, fieldNumber: 41) + } + if _storage._b42 != false { + try visitor.visitSingularBoolField(value: _storage._b42, fieldNumber: 42) + } + if _storage._b43 != false { + try visitor.visitSingularBoolField(value: _storage._b43, fieldNumber: 43) + } + if _storage._b44 != false { + try visitor.visitSingularBoolField(value: _storage._b44, fieldNumber: 44) + } + if _storage._b45 != false { + try visitor.visitSingularBoolField(value: _storage._b45, fieldNumber: 45) + } + if _storage._b46 != false { + try visitor.visitSingularBoolField(value: _storage._b46, fieldNumber: 46) + } + if _storage._b47 != false { + try visitor.visitSingularBoolField(value: _storage._b47, fieldNumber: 47) + } + if _storage._b48 != false { + try visitor.visitSingularBoolField(value: _storage._b48, fieldNumber: 48) + } + if _storage._b49 != false { + try visitor.visitSingularBoolField(value: _storage._b49, fieldNumber: 49) + } + if _storage._b50 != false { + try visitor.visitSingularBoolField(value: _storage._b50, fieldNumber: 50) + } + if _storage._b51 != false { + try visitor.visitSingularBoolField(value: _storage._b51, fieldNumber: 51) + } + if _storage._b52 != false { + try visitor.visitSingularBoolField(value: _storage._b52, fieldNumber: 52) + } + if _storage._b53 != false { + try visitor.visitSingularBoolField(value: _storage._b53, fieldNumber: 53) + } + if _storage._b54 != false { + try visitor.visitSingularBoolField(value: _storage._b54, fieldNumber: 54) + } + if _storage._b55 != false { + try visitor.visitSingularBoolField(value: _storage._b55, fieldNumber: 55) + } + if _storage._b56 != false { + try visitor.visitSingularBoolField(value: _storage._b56, fieldNumber: 56) + } + if _storage._b57 != false { + try visitor.visitSingularBoolField(value: _storage._b57, fieldNumber: 57) + } + if _storage._b58 != false { + try visitor.visitSingularBoolField(value: _storage._b58, fieldNumber: 58) + } + if _storage._b59 != false { + try visitor.visitSingularBoolField(value: _storage._b59, fieldNumber: 59) + } + if _storage._b60 != false { + try visitor.visitSingularBoolField(value: _storage._b60, fieldNumber: 60) + } + if _storage._b61 != false { + try visitor.visitSingularBoolField(value: _storage._b61, fieldNumber: 61) + } + if _storage._b62 != false { + try visitor.visitSingularBoolField(value: _storage._b62, fieldNumber: 62) + } + if _storage._b63 != false { + try visitor.visitSingularBoolField(value: _storage._b63, fieldNumber: 63) + } + if _storage._b64 != false { + try visitor.visitSingularBoolField(value: _storage._b64, fieldNumber: 64) + } + if _storage._b65 != false { + try visitor.visitSingularBoolField(value: _storage._b65, fieldNumber: 65) + } + if _storage._b66 != false { + try visitor.visitSingularBoolField(value: _storage._b66, fieldNumber: 66) + } + if _storage._b67 != false { + try visitor.visitSingularBoolField(value: _storage._b67, fieldNumber: 67) + } + if _storage._b68 != false { + try visitor.visitSingularBoolField(value: _storage._b68, fieldNumber: 68) + } + if _storage._b69 != false { + try visitor.visitSingularBoolField(value: _storage._b69, fieldNumber: 69) + } + try { if let v = _storage._child { + try visitor.visitSingularMessageField(value: v, fieldNumber: 100) + } }() } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3ArenaUnittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage, rhs: Proto3ArenaUnittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage) -> Bool { - if lhs.cc != rhs.cc {return false} + static func ==(lhs: Proto3Unittest_TestHasbits, rhs: Proto3Unittest_TestHasbits) -> 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._b1 != rhs_storage._b1 {return false} + if _storage._b2 != rhs_storage._b2 {return false} + if _storage._b3 != rhs_storage._b3 {return false} + if _storage._b4 != rhs_storage._b4 {return false} + if _storage._b5 != rhs_storage._b5 {return false} + if _storage._b6 != rhs_storage._b6 {return false} + if _storage._b7 != rhs_storage._b7 {return false} + if _storage._b8 != rhs_storage._b8 {return false} + if _storage._b9 != rhs_storage._b9 {return false} + if _storage._b10 != rhs_storage._b10 {return false} + if _storage._b11 != rhs_storage._b11 {return false} + if _storage._b12 != rhs_storage._b12 {return false} + if _storage._b13 != rhs_storage._b13 {return false} + if _storage._b14 != rhs_storage._b14 {return false} + if _storage._b15 != rhs_storage._b15 {return false} + if _storage._b16 != rhs_storage._b16 {return false} + if _storage._b17 != rhs_storage._b17 {return false} + if _storage._b18 != rhs_storage._b18 {return false} + if _storage._b19 != rhs_storage._b19 {return false} + if _storage._b20 != rhs_storage._b20 {return false} + if _storage._b21 != rhs_storage._b21 {return false} + if _storage._b22 != rhs_storage._b22 {return false} + if _storage._b23 != rhs_storage._b23 {return false} + if _storage._b24 != rhs_storage._b24 {return false} + if _storage._b25 != rhs_storage._b25 {return false} + if _storage._b26 != rhs_storage._b26 {return false} + if _storage._b27 != rhs_storage._b27 {return false} + if _storage._b28 != rhs_storage._b28 {return false} + if _storage._b29 != rhs_storage._b29 {return false} + if _storage._b30 != rhs_storage._b30 {return false} + if _storage._b31 != rhs_storage._b31 {return false} + if _storage._b32 != rhs_storage._b32 {return false} + if _storage._b33 != rhs_storage._b33 {return false} + if _storage._b34 != rhs_storage._b34 {return false} + if _storage._b35 != rhs_storage._b35 {return false} + if _storage._b36 != rhs_storage._b36 {return false} + if _storage._b37 != rhs_storage._b37 {return false} + if _storage._b38 != rhs_storage._b38 {return false} + if _storage._b39 != rhs_storage._b39 {return false} + if _storage._b40 != rhs_storage._b40 {return false} + if _storage._b41 != rhs_storage._b41 {return false} + if _storage._b42 != rhs_storage._b42 {return false} + if _storage._b43 != rhs_storage._b43 {return false} + if _storage._b44 != rhs_storage._b44 {return false} + if _storage._b45 != rhs_storage._b45 {return false} + if _storage._b46 != rhs_storage._b46 {return false} + if _storage._b47 != rhs_storage._b47 {return false} + if _storage._b48 != rhs_storage._b48 {return false} + if _storage._b49 != rhs_storage._b49 {return false} + if _storage._b50 != rhs_storage._b50 {return false} + if _storage._b51 != rhs_storage._b51 {return false} + if _storage._b52 != rhs_storage._b52 {return false} + if _storage._b53 != rhs_storage._b53 {return false} + if _storage._b54 != rhs_storage._b54 {return false} + if _storage._b55 != rhs_storage._b55 {return false} + if _storage._b56 != rhs_storage._b56 {return false} + if _storage._b57 != rhs_storage._b57 {return false} + if _storage._b58 != rhs_storage._b58 {return false} + if _storage._b59 != rhs_storage._b59 {return false} + if _storage._b60 != rhs_storage._b60 {return false} + if _storage._b61 != rhs_storage._b61 {return false} + if _storage._b62 != rhs_storage._b62 {return false} + if _storage._b63 != rhs_storage._b63 {return false} + if _storage._b64 != rhs_storage._b64 {return false} + if _storage._b65 != rhs_storage._b65 {return false} + if _storage._b66 != rhs_storage._b66 {return false} + if _storage._b67 != rhs_storage._b67 {return false} + if _storage._b68 != rhs_storage._b68 {return false} + if _storage._b69 != rhs_storage._b69 {return false} + if _storage._child != rhs_storage._child {return false} + return true + } + if !storagesAreEqual {return false} + } if lhs.unknownFields != rhs.unknownFields {return false} return true } diff --git a/Tests/SwiftProtobufTests/unittest_proto3_arena.pb.swift b/Reference/upstream/google/protobuf/unittest_proto3_arena.pb.swift similarity index 81% rename from Tests/SwiftProtobufTests/unittest_proto3_arena.pb.swift rename to Reference/upstream/google/protobuf/unittest_proto3_arena.pb.swift index 7519c6c25..09c9a1dcc 100644 --- a/Tests/SwiftProtobufTests/unittest_proto3_arena.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_proto3_arena.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/unittest_proto3_arena.proto @@ -9,33 +10,10 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd import Foundation import SwiftProtobuf @@ -50,12 +28,15 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum Proto3ArenaUnittest_ForeignEnum: SwiftProtobuf.Enum { +enum Proto3ArenaUnittest_ForeignEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foreignZero // = 0 case foreignFoo // = 4 case foreignBar // = 5 case foreignBaz // = 6 + + /// Large enough to escape the Boxed Integer cache. + case foreignLarge // = 123456 case UNRECOGNIZED(Int) init() { @@ -68,6 +49,7 @@ enum Proto3ArenaUnittest_ForeignEnum: SwiftProtobuf.Enum { case 4: self = .foreignFoo case 5: self = .foreignBar case 6: self = .foreignBaz + case 123456: self = .foreignLarge default: self = .UNRECOGNIZED(rawValue) } } @@ -78,433 +60,443 @@ enum Proto3ArenaUnittest_ForeignEnum: SwiftProtobuf.Enum { case .foreignFoo: return 4 case .foreignBar: return 5 case .foreignBaz: return 6 + case .foreignLarge: return 123456 case .UNRECOGNIZED(let i): return i } } -} - -#if swift(>=4.2) - -extension Proto3ArenaUnittest_ForeignEnum: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto3ArenaUnittest_ForeignEnum] = [ + static let allCases: [Proto3ArenaUnittest_ForeignEnum] = [ .foreignZero, .foreignFoo, .foreignBar, .foreignBaz, + .foreignLarge, ] -} -#endif // swift(>=4.2) +} /// This proto includes every type of field in both singular and repeated /// forms. -struct Proto3ArenaUnittest_TestAllTypes { +struct Proto3ArenaUnittest_TestAllTypes: @unchecked Sendable { // 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. /// Singular var optionalInt32: Int32 { - get {return _storage._optionalInt32} + get {_storage._optionalInt32} set {_uniqueStorage()._optionalInt32 = newValue} } var optionalInt64: Int64 { - get {return _storage._optionalInt64} + get {_storage._optionalInt64} set {_uniqueStorage()._optionalInt64 = newValue} } var optionalUint32: UInt32 { - get {return _storage._optionalUint32} + get {_storage._optionalUint32} set {_uniqueStorage()._optionalUint32 = newValue} } var optionalUint64: UInt64 { - get {return _storage._optionalUint64} + get {_storage._optionalUint64} set {_uniqueStorage()._optionalUint64 = newValue} } var optionalSint32: Int32 { - get {return _storage._optionalSint32} + get {_storage._optionalSint32} set {_uniqueStorage()._optionalSint32 = newValue} } var optionalSint64: Int64 { - get {return _storage._optionalSint64} + get {_storage._optionalSint64} set {_uniqueStorage()._optionalSint64 = newValue} } var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32} + get {_storage._optionalFixed32} set {_uniqueStorage()._optionalFixed32 = newValue} } var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64} + get {_storage._optionalFixed64} set {_uniqueStorage()._optionalFixed64 = newValue} } var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32} + get {_storage._optionalSfixed32} set {_uniqueStorage()._optionalSfixed32 = newValue} } var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64} + get {_storage._optionalSfixed64} set {_uniqueStorage()._optionalSfixed64 = newValue} } var optionalFloat: Float { - get {return _storage._optionalFloat} + get {_storage._optionalFloat} set {_uniqueStorage()._optionalFloat = newValue} } var optionalDouble: Double { - get {return _storage._optionalDouble} + get {_storage._optionalDouble} set {_uniqueStorage()._optionalDouble = newValue} } var optionalBool: Bool { - get {return _storage._optionalBool} + get {_storage._optionalBool} set {_uniqueStorage()._optionalBool = newValue} } var optionalString: String { - get {return _storage._optionalString} + get {_storage._optionalString} set {_uniqueStorage()._optionalString = newValue} } var optionalBytes: Data { - get {return _storage._optionalBytes} + get {_storage._optionalBytes} set {_uniqueStorage()._optionalBytes = newValue} } var optionalNestedMessage: Proto3ArenaUnittest_TestAllTypes.NestedMessage { - get {return _storage._optionalNestedMessage ?? Proto3ArenaUnittest_TestAllTypes.NestedMessage()} + get {_storage._optionalNestedMessage ?? Proto3ArenaUnittest_TestAllTypes.NestedMessage()} set {_uniqueStorage()._optionalNestedMessage = newValue} } /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} var optionalForeignMessage: Proto3ArenaUnittest_ForeignMessage { - get {return _storage._optionalForeignMessage ?? Proto3ArenaUnittest_ForeignMessage()} + get {_storage._optionalForeignMessage ?? Proto3ArenaUnittest_ForeignMessage()} set {_uniqueStorage()._optionalForeignMessage = newValue} } /// Returns true if `optionalForeignMessage` has been explicitly set. - var hasOptionalForeignMessage: Bool {return _storage._optionalForeignMessage != nil} + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} - var optionalImportMessage: ProtobufUnittestImport_ImportMessage { - get {return _storage._optionalImportMessage ?? ProtobufUnittestImport_ImportMessage()} + var optionalImportMessage: Proto2UnittestImport_ImportMessage { + get {_storage._optionalImportMessage ?? Proto2UnittestImport_ImportMessage()} set {_uniqueStorage()._optionalImportMessage = newValue} } /// Returns true if `optionalImportMessage` has been explicitly set. - var hasOptionalImportMessage: Bool {return _storage._optionalImportMessage != nil} + var hasOptionalImportMessage: Bool {_storage._optionalImportMessage != nil} /// Clears the value of `optionalImportMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalImportMessage() {_uniqueStorage()._optionalImportMessage = nil} var optionalNestedEnum: Proto3ArenaUnittest_TestAllTypes.NestedEnum { - get {return _storage._optionalNestedEnum} + get {_storage._optionalNestedEnum} set {_uniqueStorage()._optionalNestedEnum = newValue} } var optionalForeignEnum: Proto3ArenaUnittest_ForeignEnum { - get {return _storage._optionalForeignEnum} + get {_storage._optionalForeignEnum} set {_uniqueStorage()._optionalForeignEnum = newValue} } var optionalStringPiece: String { - get {return _storage._optionalStringPiece} + get {_storage._optionalStringPiece} set {_uniqueStorage()._optionalStringPiece = newValue} } var optionalCord: String { - get {return _storage._optionalCord} + get {_storage._optionalCord} set {_uniqueStorage()._optionalCord = newValue} } + var optionalBytesCord: Data { + get {_storage._optionalBytesCord} + set {_uniqueStorage()._optionalBytesCord = newValue} + } + /// Defined in unittest_import_public.proto - var optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessage { - get {return _storage._optionalPublicImportMessage ?? ProtobufUnittestImport_PublicImportMessage()} + var optionalPublicImportMessage: Proto2UnittestImport_PublicImportMessage { + get {_storage._optionalPublicImportMessage ?? Proto2UnittestImport_PublicImportMessage()} set {_uniqueStorage()._optionalPublicImportMessage = newValue} } /// Returns true if `optionalPublicImportMessage` has been explicitly set. - var hasOptionalPublicImportMessage: Bool {return _storage._optionalPublicImportMessage != nil} + var hasOptionalPublicImportMessage: Bool {_storage._optionalPublicImportMessage != nil} /// Clears the value of `optionalPublicImportMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalPublicImportMessage() {_uniqueStorage()._optionalPublicImportMessage = nil} var optionalLazyMessage: Proto3ArenaUnittest_TestAllTypes.NestedMessage { - get {return _storage._optionalLazyMessage ?? Proto3ArenaUnittest_TestAllTypes.NestedMessage()} + get {_storage._optionalLazyMessage ?? Proto3ArenaUnittest_TestAllTypes.NestedMessage()} set {_uniqueStorage()._optionalLazyMessage = newValue} } /// Returns true if `optionalLazyMessage` has been explicitly set. - var hasOptionalLazyMessage: Bool {return _storage._optionalLazyMessage != nil} + var hasOptionalLazyMessage: Bool {_storage._optionalLazyMessage != nil} /// Clears the value of `optionalLazyMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalLazyMessage() {_uniqueStorage()._optionalLazyMessage = nil} - var optionalLazyImportMessage: ProtobufUnittestImport_ImportMessage { - get {return _storage._optionalLazyImportMessage ?? ProtobufUnittestImport_ImportMessage()} + var optionalUnverifiedLazyMessage: Proto3ArenaUnittest_TestAllTypes.NestedMessage { + get {_storage._optionalUnverifiedLazyMessage ?? Proto3ArenaUnittest_TestAllTypes.NestedMessage()} + set {_uniqueStorage()._optionalUnverifiedLazyMessage = newValue} + } + /// Returns true if `optionalUnverifiedLazyMessage` has been explicitly set. + var hasOptionalUnverifiedLazyMessage: Bool {_storage._optionalUnverifiedLazyMessage != nil} + /// Clears the value of `optionalUnverifiedLazyMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalUnverifiedLazyMessage() {_uniqueStorage()._optionalUnverifiedLazyMessage = nil} + + var optionalLazyImportMessage: Proto2UnittestImport_ImportMessage { + get {_storage._optionalLazyImportMessage ?? Proto2UnittestImport_ImportMessage()} set {_uniqueStorage()._optionalLazyImportMessage = newValue} } /// Returns true if `optionalLazyImportMessage` has been explicitly set. - var hasOptionalLazyImportMessage: Bool {return _storage._optionalLazyImportMessage != nil} + var hasOptionalLazyImportMessage: Bool {_storage._optionalLazyImportMessage != nil} /// Clears the value of `optionalLazyImportMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalLazyImportMessage() {_uniqueStorage()._optionalLazyImportMessage = nil} /// Repeated var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } /// Optional var proto3OptionalInt32: Int32 { - get {return _storage._proto3OptionalInt32 ?? 0} + get {_storage._proto3OptionalInt32 ?? 0} set {_uniqueStorage()._proto3OptionalInt32 = newValue} } /// Returns true if `proto3OptionalInt32` has been explicitly set. - var hasProto3OptionalInt32: Bool {return _storage._proto3OptionalInt32 != nil} + var hasProto3OptionalInt32: Bool {_storage._proto3OptionalInt32 != nil} /// Clears the value of `proto3OptionalInt32`. Subsequent reads from it will return its default value. mutating func clearProto3OptionalInt32() {_uniqueStorage()._proto3OptionalInt32 = nil} var proto3OptionalInt64: Int64 { - get {return _storage._proto3OptionalInt64 ?? 0} + get {_storage._proto3OptionalInt64 ?? 0} set {_uniqueStorage()._proto3OptionalInt64 = newValue} } /// Returns true if `proto3OptionalInt64` has been explicitly set. - var hasProto3OptionalInt64: Bool {return _storage._proto3OptionalInt64 != nil} + var hasProto3OptionalInt64: Bool {_storage._proto3OptionalInt64 != nil} /// Clears the value of `proto3OptionalInt64`. Subsequent reads from it will return its default value. mutating func clearProto3OptionalInt64() {_uniqueStorage()._proto3OptionalInt64 = nil} var proto3OptionalUint32: UInt32 { - get {return _storage._proto3OptionalUint32 ?? 0} + get {_storage._proto3OptionalUint32 ?? 0} set {_uniqueStorage()._proto3OptionalUint32 = newValue} } /// Returns true if `proto3OptionalUint32` has been explicitly set. - var hasProto3OptionalUint32: Bool {return _storage._proto3OptionalUint32 != nil} + var hasProto3OptionalUint32: Bool {_storage._proto3OptionalUint32 != nil} /// Clears the value of `proto3OptionalUint32`. Subsequent reads from it will return its default value. mutating func clearProto3OptionalUint32() {_uniqueStorage()._proto3OptionalUint32 = nil} var proto3OptionalUint64: UInt64 { - get {return _storage._proto3OptionalUint64 ?? 0} + get {_storage._proto3OptionalUint64 ?? 0} set {_uniqueStorage()._proto3OptionalUint64 = newValue} } /// Returns true if `proto3OptionalUint64` has been explicitly set. - var hasProto3OptionalUint64: Bool {return _storage._proto3OptionalUint64 != nil} + var hasProto3OptionalUint64: Bool {_storage._proto3OptionalUint64 != nil} /// Clears the value of `proto3OptionalUint64`. Subsequent reads from it will return its default value. mutating func clearProto3OptionalUint64() {_uniqueStorage()._proto3OptionalUint64 = nil} var proto3OptionalSint32: Int32 { - get {return _storage._proto3OptionalSint32 ?? 0} + get {_storage._proto3OptionalSint32 ?? 0} set {_uniqueStorage()._proto3OptionalSint32 = newValue} } /// Returns true if `proto3OptionalSint32` has been explicitly set. - var hasProto3OptionalSint32: Bool {return _storage._proto3OptionalSint32 != nil} + var hasProto3OptionalSint32: Bool {_storage._proto3OptionalSint32 != nil} /// Clears the value of `proto3OptionalSint32`. Subsequent reads from it will return its default value. mutating func clearProto3OptionalSint32() {_uniqueStorage()._proto3OptionalSint32 = nil} var proto3OptionalSint64: Int64 { - get {return _storage._proto3OptionalSint64 ?? 0} + get {_storage._proto3OptionalSint64 ?? 0} set {_uniqueStorage()._proto3OptionalSint64 = newValue} } /// Returns true if `proto3OptionalSint64` has been explicitly set. - var hasProto3OptionalSint64: Bool {return _storage._proto3OptionalSint64 != nil} + var hasProto3OptionalSint64: Bool {_storage._proto3OptionalSint64 != nil} /// Clears the value of `proto3OptionalSint64`. Subsequent reads from it will return its default value. mutating func clearProto3OptionalSint64() {_uniqueStorage()._proto3OptionalSint64 = nil} var proto3OptionalFixed32: UInt32 { - get {return _storage._proto3OptionalFixed32 ?? 0} + get {_storage._proto3OptionalFixed32 ?? 0} set {_uniqueStorage()._proto3OptionalFixed32 = newValue} } /// Returns true if `proto3OptionalFixed32` has been explicitly set. - var hasProto3OptionalFixed32: Bool {return _storage._proto3OptionalFixed32 != nil} + var hasProto3OptionalFixed32: Bool {_storage._proto3OptionalFixed32 != nil} /// Clears the value of `proto3OptionalFixed32`. Subsequent reads from it will return its default value. mutating func clearProto3OptionalFixed32() {_uniqueStorage()._proto3OptionalFixed32 = nil} var proto3OptionalFixed64: UInt64 { - get {return _storage._proto3OptionalFixed64 ?? 0} + get {_storage._proto3OptionalFixed64 ?? 0} set {_uniqueStorage()._proto3OptionalFixed64 = newValue} } /// Returns true if `proto3OptionalFixed64` has been explicitly set. - var hasProto3OptionalFixed64: Bool {return _storage._proto3OptionalFixed64 != nil} + var hasProto3OptionalFixed64: Bool {_storage._proto3OptionalFixed64 != nil} /// Clears the value of `proto3OptionalFixed64`. Subsequent reads from it will return its default value. mutating func clearProto3OptionalFixed64() {_uniqueStorage()._proto3OptionalFixed64 = nil} var proto3OptionalSfixed32: Int32 { - get {return _storage._proto3OptionalSfixed32 ?? 0} + get {_storage._proto3OptionalSfixed32 ?? 0} set {_uniqueStorage()._proto3OptionalSfixed32 = newValue} } /// Returns true if `proto3OptionalSfixed32` has been explicitly set. - var hasProto3OptionalSfixed32: Bool {return _storage._proto3OptionalSfixed32 != nil} + var hasProto3OptionalSfixed32: Bool {_storage._proto3OptionalSfixed32 != nil} /// Clears the value of `proto3OptionalSfixed32`. Subsequent reads from it will return its default value. mutating func clearProto3OptionalSfixed32() {_uniqueStorage()._proto3OptionalSfixed32 = nil} var proto3OptionalSfixed64: Int64 { - get {return _storage._proto3OptionalSfixed64 ?? 0} + get {_storage._proto3OptionalSfixed64 ?? 0} set {_uniqueStorage()._proto3OptionalSfixed64 = newValue} } /// Returns true if `proto3OptionalSfixed64` has been explicitly set. - var hasProto3OptionalSfixed64: Bool {return _storage._proto3OptionalSfixed64 != nil} + var hasProto3OptionalSfixed64: Bool {_storage._proto3OptionalSfixed64 != nil} /// Clears the value of `proto3OptionalSfixed64`. Subsequent reads from it will return its default value. mutating func clearProto3OptionalSfixed64() {_uniqueStorage()._proto3OptionalSfixed64 = nil} var proto3OptionalFloat: Float { - get {return _storage._proto3OptionalFloat ?? 0} + get {_storage._proto3OptionalFloat ?? 0} set {_uniqueStorage()._proto3OptionalFloat = newValue} } /// Returns true if `proto3OptionalFloat` has been explicitly set. - var hasProto3OptionalFloat: Bool {return _storage._proto3OptionalFloat != nil} + var hasProto3OptionalFloat: Bool {_storage._proto3OptionalFloat != nil} /// Clears the value of `proto3OptionalFloat`. Subsequent reads from it will return its default value. mutating func clearProto3OptionalFloat() {_uniqueStorage()._proto3OptionalFloat = nil} var proto3OptionalDouble: Double { - get {return _storage._proto3OptionalDouble ?? 0} + get {_storage._proto3OptionalDouble ?? 0} set {_uniqueStorage()._proto3OptionalDouble = newValue} } /// Returns true if `proto3OptionalDouble` has been explicitly set. - var hasProto3OptionalDouble: Bool {return _storage._proto3OptionalDouble != nil} + var hasProto3OptionalDouble: Bool {_storage._proto3OptionalDouble != nil} /// Clears the value of `proto3OptionalDouble`. Subsequent reads from it will return its default value. mutating func clearProto3OptionalDouble() {_uniqueStorage()._proto3OptionalDouble = nil} var proto3OptionalBool: Bool { - get {return _storage._proto3OptionalBool ?? false} + get {_storage._proto3OptionalBool ?? false} set {_uniqueStorage()._proto3OptionalBool = newValue} } /// Returns true if `proto3OptionalBool` has been explicitly set. - var hasProto3OptionalBool: Bool {return _storage._proto3OptionalBool != nil} + var hasProto3OptionalBool: Bool {_storage._proto3OptionalBool != nil} /// Clears the value of `proto3OptionalBool`. Subsequent reads from it will return its default value. mutating func clearProto3OptionalBool() {_uniqueStorage()._proto3OptionalBool = nil} var proto3OptionalString: String { - get {return _storage._proto3OptionalString ?? String()} + get {_storage._proto3OptionalString ?? String()} set {_uniqueStorage()._proto3OptionalString = newValue} } /// Returns true if `proto3OptionalString` has been explicitly set. - var hasProto3OptionalString: Bool {return _storage._proto3OptionalString != nil} + var hasProto3OptionalString: Bool {_storage._proto3OptionalString != nil} /// Clears the value of `proto3OptionalString`. Subsequent reads from it will return its default value. mutating func clearProto3OptionalString() {_uniqueStorage()._proto3OptionalString = nil} var proto3OptionalBytes: Data { - get {return _storage._proto3OptionalBytes ?? Data()} + get {_storage._proto3OptionalBytes ?? Data()} set {_uniqueStorage()._proto3OptionalBytes = newValue} } /// Returns true if `proto3OptionalBytes` has been explicitly set. - var hasProto3OptionalBytes: Bool {return _storage._proto3OptionalBytes != nil} + var hasProto3OptionalBytes: Bool {_storage._proto3OptionalBytes != nil} /// Clears the value of `proto3OptionalBytes`. Subsequent reads from it will return its default value. mutating func clearProto3OptionalBytes() {_uniqueStorage()._proto3OptionalBytes = nil} var repeatedNestedMessage: [Proto3ArenaUnittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedNestedMessage} + get {_storage._repeatedNestedMessage} set {_uniqueStorage()._repeatedNestedMessage = newValue} } var repeatedForeignMessage: [Proto3ArenaUnittest_ForeignMessage] { - get {return _storage._repeatedForeignMessage} + get {_storage._repeatedForeignMessage} set {_uniqueStorage()._repeatedForeignMessage = newValue} } - var repeatedImportMessage: [ProtobufUnittestImport_ImportMessage] { - get {return _storage._repeatedImportMessage} + var repeatedImportMessage: [Proto2UnittestImport_ImportMessage] { + get {_storage._repeatedImportMessage} set {_uniqueStorage()._repeatedImportMessage = newValue} } var repeatedNestedEnum: [Proto3ArenaUnittest_TestAllTypes.NestedEnum] { - get {return _storage._repeatedNestedEnum} + get {_storage._repeatedNestedEnum} set {_uniqueStorage()._repeatedNestedEnum = newValue} } var repeatedForeignEnum: [Proto3ArenaUnittest_ForeignEnum] { - get {return _storage._repeatedForeignEnum} + get {_storage._repeatedForeignEnum} set {_uniqueStorage()._repeatedForeignEnum = newValue} } var repeatedStringPiece: [String] { - get {return _storage._repeatedStringPiece} + get {_storage._repeatedStringPiece} set {_uniqueStorage()._repeatedStringPiece = newValue} } var repeatedCord: [String] { - get {return _storage._repeatedCord} + get {_storage._repeatedCord} set {_uniqueStorage()._repeatedCord = newValue} } var repeatedLazyMessage: [Proto3ArenaUnittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedLazyMessage} + get {_storage._repeatedLazyMessage} set {_uniqueStorage()._repeatedLazyMessage = newValue} } @@ -547,41 +539,15 @@ struct Proto3ArenaUnittest_TestAllTypes { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case oneofUint32(UInt32) case oneofNestedMessage(Proto3ArenaUnittest_TestAllTypes.NestedMessage) case oneofString(String) case oneofBytes(Data) - #if !swift(>=4.1) - static func ==(lhs: Proto3ArenaUnittest_TestAllTypes.OneOf_OneofField, rhs: Proto3ArenaUnittest_TestAllTypes.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum NestedEnum: SwiftProtobuf.Enum { + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case zero // = 0 case foo // = 1 @@ -618,9 +584,18 @@ struct Proto3ArenaUnittest_TestAllTypes { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Proto3ArenaUnittest_TestAllTypes.NestedEnum] = [ + .zero, + .foo, + .bar, + .baz, + .neg, + ] + } - struct NestedMessage { + struct NestedMessage: Sendable { // 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. @@ -640,22 +615,7 @@ struct Proto3ArenaUnittest_TestAllTypes { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension Proto3ArenaUnittest_TestAllTypes.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto3ArenaUnittest_TestAllTypes.NestedEnum] = [ - .zero, - .foo, - .bar, - .baz, - .neg, - ] -} - -#endif // swift(>=4.2) - -struct Proto3ArenaUnittest_TestPackedTypes { +struct Proto3ArenaUnittest_TestPackedTypes: Sendable { // 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. @@ -694,7 +654,7 @@ struct Proto3ArenaUnittest_TestPackedTypes { } /// Explicitly set packed to false -struct Proto3ArenaUnittest_TestUnpackedTypes { +struct Proto3ArenaUnittest_TestUnpackedTypes: Sendable { // 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. @@ -733,34 +693,43 @@ struct Proto3ArenaUnittest_TestUnpackedTypes { } /// This proto includes a recursively nested message. -struct Proto3ArenaUnittest_NestedTestAllTypes { +struct Proto3ArenaUnittest_NestedTestAllTypes: @unchecked Sendable { // 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 child: Proto3ArenaUnittest_NestedTestAllTypes { - get {return _storage._child ?? Proto3ArenaUnittest_NestedTestAllTypes()} + get {_storage._child ?? Proto3ArenaUnittest_NestedTestAllTypes()} set {_uniqueStorage()._child = newValue} } /// Returns true if `child` has been explicitly set. - var hasChild: Bool {return _storage._child != nil} + var hasChild: Bool {_storage._child != nil} /// Clears the value of `child`. Subsequent reads from it will return its default value. mutating func clearChild() {_uniqueStorage()._child = nil} var payload: Proto3ArenaUnittest_TestAllTypes { - get {return _storage._payload ?? Proto3ArenaUnittest_TestAllTypes()} + get {_storage._payload ?? Proto3ArenaUnittest_TestAllTypes()} set {_uniqueStorage()._payload = newValue} } /// Returns true if `payload` has been explicitly set. - var hasPayload: Bool {return _storage._payload != nil} + var hasPayload: Bool {_storage._payload != nil} /// Clears the value of `payload`. Subsequent reads from it will return its default value. mutating func clearPayload() {_uniqueStorage()._payload = nil} var repeatedChild: [Proto3ArenaUnittest_NestedTestAllTypes] { - get {return _storage._repeatedChild} + get {_storage._repeatedChild} set {_uniqueStorage()._repeatedChild = newValue} } + var lazyPayload: Proto3ArenaUnittest_TestAllTypes { + get {_storage._lazyPayload ?? Proto3ArenaUnittest_TestAllTypes()} + set {_uniqueStorage()._lazyPayload = newValue} + } + /// Returns true if `lazyPayload` has been explicitly set. + var hasLazyPayload: Bool {_storage._lazyPayload != nil} + /// Clears the value of `lazyPayload`. Subsequent reads from it will return its default value. + mutating func clearLazyPayload() {_uniqueStorage()._lazyPayload = nil} + var unknownFields = SwiftProtobuf.UnknownStorage() init() {} @@ -770,7 +739,7 @@ struct Proto3ArenaUnittest_NestedTestAllTypes { /// Define these after TestAllTypes to make sure the compiler can handle /// that. -struct Proto3ArenaUnittest_ForeignMessage { +struct Proto3ArenaUnittest_ForeignMessage: Sendable { // 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. @@ -783,7 +752,7 @@ struct Proto3ArenaUnittest_ForeignMessage { } /// TestEmptyMessage is used to test behavior of unknown fields. -struct Proto3ArenaUnittest_TestEmptyMessage { +struct Proto3ArenaUnittest_TestEmptyMessage: Sendable { // 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. @@ -794,14 +763,14 @@ struct Proto3ArenaUnittest_TestEmptyMessage { } /// Needed for a Python test. -struct Proto3ArenaUnittest_TestPickleNestedMessage { +struct Proto3ArenaUnittest_TestPickleNestedMessage: Sendable { // 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() - struct NestedMessage { + struct NestedMessage: Sendable { // 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. @@ -810,7 +779,7 @@ struct Proto3ArenaUnittest_TestPickleNestedMessage { var unknownFields = SwiftProtobuf.UnknownStorage() - struct NestedNestedMessage { + struct NestedNestedMessage: Sendable { // 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. @@ -828,106 +797,17 @@ struct Proto3ArenaUnittest_TestPickleNestedMessage { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Proto3ArenaUnittest_ForeignEnum: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestAllTypes: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestAllTypes.OneOf_OneofField: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestAllTypes.NestedEnum: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestAllTypes.NestedMessage: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestPackedTypes: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestUnpackedTypes: @unchecked Sendable {} -extension Proto3ArenaUnittest_NestedTestAllTypes: @unchecked Sendable {} -extension Proto3ArenaUnittest_ForeignMessage: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestEmptyMessage: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestPickleNestedMessage: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestPickleNestedMessage.NestedMessage: @unchecked Sendable {} -extension Proto3ArenaUnittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "proto3_arena_unittest" extension Proto3ArenaUnittest_ForeignEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOREIGN_ZERO"), - 4: .same(proto: "FOREIGN_FOO"), - 5: .same(proto: "FOREIGN_BAR"), - 6: .same(proto: "FOREIGN_BAZ"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_ZERO\0\u{2}\u{4}FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0\u{2}zH\u{1e}FOREIGN_LARGE\0") } extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "optional_foreign_message"), - 20: .standard(proto: "optional_import_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "optional_foreign_enum"), - 24: .standard(proto: "optional_string_piece"), - 25: .standard(proto: "optional_cord"), - 26: .standard(proto: "optional_public_import_message"), - 27: .standard(proto: "optional_lazy_message"), - 115: .standard(proto: "optional_lazy_import_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 116: .standard(proto: "proto3_optional_int32"), - 117: .standard(proto: "proto3_optional_int64"), - 118: .standard(proto: "proto3_optional_uint32"), - 119: .standard(proto: "proto3_optional_uint64"), - 120: .standard(proto: "proto3_optional_sint32"), - 121: .standard(proto: "proto3_optional_sint64"), - 122: .standard(proto: "proto3_optional_fixed32"), - 123: .standard(proto: "proto3_optional_fixed64"), - 124: .standard(proto: "proto3_optional_sfixed32"), - 125: .standard(proto: "proto3_optional_sfixed64"), - 126: .standard(proto: "proto3_optional_float"), - 127: .standard(proto: "proto3_optional_double"), - 128: .standard(proto: "proto3_optional_bool"), - 129: .standard(proto: "proto3_optional_string"), - 130: .standard(proto: "proto3_optional_bytes"), - 48: .standard(proto: "repeated_nested_message"), - 49: .standard(proto: "repeated_foreign_message"), - 50: .standard(proto: "repeated_import_message"), - 51: .standard(proto: "repeated_nested_enum"), - 52: .standard(proto: "repeated_foreign_enum"), - 54: .standard(proto: "repeated_string_piece"), - 55: .standard(proto: "repeated_cord"), - 57: .standard(proto: "repeated_lazy_message"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{3}optional_import_message\0\u{3}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{4}\u{2}optional_string_piece\0\u{3}optional_cord\0\u{3}optional_public_import_message\0\u{3}optional_lazy_message\0\u{3}optional_unverified_lazy_message\0\u{4}\u{3}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{3}repeated_import_message\0\u{3}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{4}\u{2}repeated_lazy_message\0\u{4}\u{1d}optional_bytes_cord\0\u{4}\u{19}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}optional_lazy_import_message\0\u{3}proto3_optional_int32\0\u{3}proto3_optional_int64\0\u{3}proto3_optional_uint32\0\u{3}proto3_optional_uint64\0\u{3}proto3_optional_sint32\0\u{3}proto3_optional_sint64\0\u{3}proto3_optional_fixed32\0\u{3}proto3_optional_fixed64\0\u{3}proto3_optional_sfixed32\0\u{3}proto3_optional_sfixed64\0\u{3}proto3_optional_float\0\u{3}proto3_optional_double\0\u{3}proto3_optional_bool\0\u{3}proto3_optional_string\0\u{3}proto3_optional_bytes\0") fileprivate class _StorageClass { var _optionalInt32: Int32 = 0 @@ -947,14 +827,16 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf var _optionalBytes: Data = Data() var _optionalNestedMessage: Proto3ArenaUnittest_TestAllTypes.NestedMessage? = nil var _optionalForeignMessage: Proto3ArenaUnittest_ForeignMessage? = nil - var _optionalImportMessage: ProtobufUnittestImport_ImportMessage? = nil + var _optionalImportMessage: Proto2UnittestImport_ImportMessage? = nil var _optionalNestedEnum: Proto3ArenaUnittest_TestAllTypes.NestedEnum = .zero var _optionalForeignEnum: Proto3ArenaUnittest_ForeignEnum = .foreignZero var _optionalStringPiece: String = String() var _optionalCord: String = String() - var _optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessage? = nil + var _optionalBytesCord: Data = Data() + var _optionalPublicImportMessage: Proto2UnittestImport_PublicImportMessage? = nil var _optionalLazyMessage: Proto3ArenaUnittest_TestAllTypes.NestedMessage? = nil - var _optionalLazyImportMessage: ProtobufUnittestImport_ImportMessage? = nil + var _optionalUnverifiedLazyMessage: Proto3ArenaUnittest_TestAllTypes.NestedMessage? = nil + var _optionalLazyImportMessage: Proto2UnittestImport_ImportMessage? = nil var _repeatedInt32: [Int32] = [] var _repeatedInt64: [Int64] = [] var _repeatedUint32: [UInt32] = [] @@ -987,7 +869,7 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf var _proto3OptionalBytes: Data? = nil var _repeatedNestedMessage: [Proto3ArenaUnittest_TestAllTypes.NestedMessage] = [] var _repeatedForeignMessage: [Proto3ArenaUnittest_ForeignMessage] = [] - var _repeatedImportMessage: [ProtobufUnittestImport_ImportMessage] = [] + var _repeatedImportMessage: [Proto2UnittestImport_ImportMessage] = [] var _repeatedNestedEnum: [Proto3ArenaUnittest_TestAllTypes.NestedEnum] = [] var _repeatedForeignEnum: [Proto3ArenaUnittest_ForeignEnum] = [] var _repeatedStringPiece: [String] = [] @@ -995,7 +877,11 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf var _repeatedLazyMessage: [Proto3ArenaUnittest_TestAllTypes.NestedMessage] = [] var _oneofField: Proto3ArenaUnittest_TestAllTypes.OneOf_OneofField? - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1022,8 +908,10 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf _optionalForeignEnum = source._optionalForeignEnum _optionalStringPiece = source._optionalStringPiece _optionalCord = source._optionalCord + _optionalBytesCord = source._optionalBytesCord _optionalPublicImportMessage = source._optionalPublicImportMessage _optionalLazyMessage = source._optionalLazyMessage + _optionalUnverifiedLazyMessage = source._optionalUnverifiedLazyMessage _optionalLazyImportMessage = source._optionalLazyImportMessage _repeatedInt32 = source._repeatedInt32 _repeatedInt64 = source._repeatedInt64 @@ -1106,6 +994,7 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() case 26: try { try decoder.decodeSingularMessageField(value: &_storage._optionalPublicImportMessage) }() case 27: try { try decoder.decodeSingularMessageField(value: &_storage._optionalLazyMessage) }() + case 28: try { try decoder.decodeSingularMessageField(value: &_storage._optionalUnverifiedLazyMessage) }() case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() @@ -1129,6 +1018,7 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() case 57: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedLazyMessage) }() + case 86: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytesCord) }() case 111: try { var v: UInt32? try decoder.decodeSingularUInt32Field(value: &v) @@ -1224,10 +1114,10 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf if _storage._optionalSfixed64 != 0 { try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) } - if _storage._optionalFloat != 0 { + if _storage._optionalFloat.bitPattern != 0 { try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) } - if _storage._optionalDouble != 0 { + if _storage._optionalDouble.bitPattern != 0 { try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) } if _storage._optionalBool != false { @@ -1266,6 +1156,9 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf try { if let v = _storage._optionalLazyMessage { try visitor.visitSingularMessageField(value: v, fieldNumber: 27) } }() + try { if let v = _storage._optionalUnverifiedLazyMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 28) + } }() if !_storage._repeatedInt32.isEmpty { try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) } @@ -1335,6 +1228,9 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf if !_storage._repeatedLazyMessage.isEmpty { try visitor.visitRepeatedMessageField(value: _storage._repeatedLazyMessage, fieldNumber: 57) } + if !_storage._optionalBytesCord.isEmpty { + try visitor.visitSingularBytesField(value: _storage._optionalBytesCord, fieldNumber: 86) + } switch _storage._oneofField { case .oneofUint32?: try { guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } @@ -1433,8 +1329,10 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._optionalBytesCord != rhs_storage._optionalBytesCord {return false} if _storage._optionalPublicImportMessage != rhs_storage._optionalPublicImportMessage {return false} if _storage._optionalLazyMessage != rhs_storage._optionalLazyMessage {return false} + if _storage._optionalUnverifiedLazyMessage != rhs_storage._optionalUnverifiedLazyMessage {return false} if _storage._optionalLazyImportMessage != rhs_storage._optionalLazyImportMessage {return false} if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} @@ -1485,20 +1383,12 @@ extension Proto3ArenaUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf } extension Proto3ArenaUnittest_TestAllTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -1: .same(proto: "NEG"), - 0: .same(proto: "ZERO"), - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - 3: .same(proto: "BAZ"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}ZERO\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") } extension Proto3ArenaUnittest_TestAllTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = Proto3ArenaUnittest_TestAllTypes.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1528,22 +1418,7 @@ extension Proto3ArenaUnittest_TestAllTypes.NestedMessage: SwiftProtobuf.Message, extension Proto3ArenaUnittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestPackedTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 90: .standard(proto: "packed_int32"), - 91: .standard(proto: "packed_int64"), - 92: .standard(proto: "packed_uint32"), - 93: .standard(proto: "packed_uint64"), - 94: .standard(proto: "packed_sint32"), - 95: .standard(proto: "packed_sint64"), - 96: .standard(proto: "packed_fixed32"), - 97: .standard(proto: "packed_fixed64"), - 98: .standard(proto: "packed_sfixed32"), - 99: .standard(proto: "packed_sfixed64"), - 100: .standard(proto: "packed_float"), - 101: .standard(proto: "packed_double"), - 102: .standard(proto: "packed_bool"), - 103: .standard(proto: "packed_enum"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}Z\u{1}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1638,22 +1513,7 @@ extension Proto3ArenaUnittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProto extension Proto3ArenaUnittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestUnpackedTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "repeated_int32"), - 2: .standard(proto: "repeated_int64"), - 3: .standard(proto: "repeated_uint32"), - 4: .standard(proto: "repeated_uint64"), - 5: .standard(proto: "repeated_sint32"), - 6: .standard(proto: "repeated_sint64"), - 7: .standard(proto: "repeated_fixed32"), - 8: .standard(proto: "repeated_fixed64"), - 9: .standard(proto: "repeated_sfixed32"), - 10: .standard(proto: "repeated_sfixed64"), - 11: .standard(proto: "repeated_float"), - 12: .standard(proto: "repeated_double"), - 13: .standard(proto: "repeated_bool"), - 14: .standard(proto: "repeated_nested_enum"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_nested_enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1748,18 +1608,19 @@ extension Proto3ArenaUnittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftPro extension Proto3ArenaUnittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".NestedTestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "child"), - 2: .same(proto: "payload"), - 3: .standard(proto: "repeated_child"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}child\0\u{1}payload\0\u{3}repeated_child\0\u{3}lazy_payload\0") fileprivate class _StorageClass { var _child: Proto3ArenaUnittest_NestedTestAllTypes? = nil var _payload: Proto3ArenaUnittest_TestAllTypes? = nil var _repeatedChild: [Proto3ArenaUnittest_NestedTestAllTypes] = [] + var _lazyPayload: Proto3ArenaUnittest_TestAllTypes? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1767,6 +1628,7 @@ extension Proto3ArenaUnittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftPr _child = source._child _payload = source._payload _repeatedChild = source._repeatedChild + _lazyPayload = source._lazyPayload } } @@ -1788,6 +1650,7 @@ extension Proto3ArenaUnittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftPr case 1: try { try decoder.decodeSingularMessageField(value: &_storage._child) }() case 2: try { try decoder.decodeSingularMessageField(value: &_storage._payload) }() case 3: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedChild) }() + case 4: try { try decoder.decodeSingularMessageField(value: &_storage._lazyPayload) }() default: break } } @@ -1809,6 +1672,9 @@ extension Proto3ArenaUnittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftPr if !_storage._repeatedChild.isEmpty { try visitor.visitRepeatedMessageField(value: _storage._repeatedChild, fieldNumber: 3) } + try { if let v = _storage._lazyPayload { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() } try unknownFields.traverse(visitor: &visitor) } @@ -1821,6 +1687,7 @@ extension Proto3ArenaUnittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftPr if _storage._child != rhs_storage._child {return false} if _storage._payload != rhs_storage._payload {return false} if _storage._repeatedChild != rhs_storage._repeatedChild {return false} + if _storage._lazyPayload != rhs_storage._lazyPayload {return false} return true } if !storagesAreEqual {return false} @@ -1832,9 +1699,7 @@ extension Proto3ArenaUnittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftPr extension Proto3ArenaUnittest_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ForeignMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1867,8 +1732,8 @@ extension Proto3ArenaUnittest_TestEmptyMessage: SwiftProtobuf.Message, SwiftProt static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { @@ -1886,8 +1751,8 @@ extension Proto3ArenaUnittest_TestPickleNestedMessage: SwiftProtobuf.Message, Sw static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { @@ -1902,9 +1767,7 @@ extension Proto3ArenaUnittest_TestPickleNestedMessage: SwiftProtobuf.Message, Sw extension Proto3ArenaUnittest_TestPickleNestedMessage.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = Proto3ArenaUnittest_TestPickleNestedMessage.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1934,9 +1797,7 @@ extension Proto3ArenaUnittest_TestPickleNestedMessage.NestedMessage: SwiftProtob extension Proto3ArenaUnittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = Proto3ArenaUnittest_TestPickleNestedMessage.NestedMessage.protoMessageName + ".NestedNestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "cc"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}cc\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { diff --git a/Reference/google/protobuf/unittest_proto3_arena_lite.pb.swift b/Reference/upstream/google/protobuf/unittest_proto3_arena_lite.pb.swift similarity index 81% rename from Reference/google/protobuf/unittest_proto3_arena_lite.pb.swift rename to Reference/upstream/google/protobuf/unittest_proto3_arena_lite.pb.swift index f7d7a1eec..6a0c7edc8 100644 --- a/Reference/google/protobuf/unittest_proto3_arena_lite.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_proto3_arena_lite.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/unittest_proto3_arena_lite.proto @@ -9,33 +10,10 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd import Foundation import SwiftProtobuf @@ -50,7 +28,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum Proto3ArenaLiteUnittest_ForeignEnum: SwiftProtobuf.Enum { +enum Proto3ArenaLiteUnittest_ForeignEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foreignZero // = 0 case foreignFoo // = 4 @@ -82,284 +60,278 @@ enum Proto3ArenaLiteUnittest_ForeignEnum: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension Proto3ArenaLiteUnittest_ForeignEnum: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto3ArenaLiteUnittest_ForeignEnum] = [ + static let allCases: [Proto3ArenaLiteUnittest_ForeignEnum] = [ .foreignZero, .foreignFoo, .foreignBar, .foreignBaz, ] -} -#endif // swift(>=4.2) +} /// This proto includes every type of field in both singular and repeated /// forms. -struct Proto3ArenaLiteUnittest_TestAllTypes { +struct Proto3ArenaLiteUnittest_TestAllTypes: @unchecked Sendable { // 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. /// Singular var optionalInt32: Int32 { - get {return _storage._optionalInt32} + get {_storage._optionalInt32} set {_uniqueStorage()._optionalInt32 = newValue} } var optionalInt64: Int64 { - get {return _storage._optionalInt64} + get {_storage._optionalInt64} set {_uniqueStorage()._optionalInt64 = newValue} } var optionalUint32: UInt32 { - get {return _storage._optionalUint32} + get {_storage._optionalUint32} set {_uniqueStorage()._optionalUint32 = newValue} } var optionalUint64: UInt64 { - get {return _storage._optionalUint64} + get {_storage._optionalUint64} set {_uniqueStorage()._optionalUint64 = newValue} } var optionalSint32: Int32 { - get {return _storage._optionalSint32} + get {_storage._optionalSint32} set {_uniqueStorage()._optionalSint32 = newValue} } var optionalSint64: Int64 { - get {return _storage._optionalSint64} + get {_storage._optionalSint64} set {_uniqueStorage()._optionalSint64 = newValue} } var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32} + get {_storage._optionalFixed32} set {_uniqueStorage()._optionalFixed32 = newValue} } var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64} + get {_storage._optionalFixed64} set {_uniqueStorage()._optionalFixed64 = newValue} } var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32} + get {_storage._optionalSfixed32} set {_uniqueStorage()._optionalSfixed32 = newValue} } var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64} + get {_storage._optionalSfixed64} set {_uniqueStorage()._optionalSfixed64 = newValue} } var optionalFloat: Float { - get {return _storage._optionalFloat} + get {_storage._optionalFloat} set {_uniqueStorage()._optionalFloat = newValue} } var optionalDouble: Double { - get {return _storage._optionalDouble} + get {_storage._optionalDouble} set {_uniqueStorage()._optionalDouble = newValue} } var optionalBool: Bool { - get {return _storage._optionalBool} + get {_storage._optionalBool} set {_uniqueStorage()._optionalBool = newValue} } var optionalString: String { - get {return _storage._optionalString} + get {_storage._optionalString} set {_uniqueStorage()._optionalString = newValue} } var optionalBytes: Data { - get {return _storage._optionalBytes} + get {_storage._optionalBytes} set {_uniqueStorage()._optionalBytes = newValue} } var optionalNestedMessage: Proto3ArenaLiteUnittest_TestAllTypes.NestedMessage { - get {return _storage._optionalNestedMessage ?? Proto3ArenaLiteUnittest_TestAllTypes.NestedMessage()} + get {_storage._optionalNestedMessage ?? Proto3ArenaLiteUnittest_TestAllTypes.NestedMessage()} set {_uniqueStorage()._optionalNestedMessage = newValue} } /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} var optionalForeignMessage: Proto3ArenaLiteUnittest_ForeignMessage { - get {return _storage._optionalForeignMessage ?? Proto3ArenaLiteUnittest_ForeignMessage()} + get {_storage._optionalForeignMessage ?? Proto3ArenaLiteUnittest_ForeignMessage()} set {_uniqueStorage()._optionalForeignMessage = newValue} } /// Returns true if `optionalForeignMessage` has been explicitly set. - var hasOptionalForeignMessage: Bool {return _storage._optionalForeignMessage != nil} + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} - var optionalImportMessage: ProtobufUnittestImport_ImportMessage { - get {return _storage._optionalImportMessage ?? ProtobufUnittestImport_ImportMessage()} + var optionalImportMessage: Proto2UnittestImport_ImportMessage { + get {_storage._optionalImportMessage ?? Proto2UnittestImport_ImportMessage()} set {_uniqueStorage()._optionalImportMessage = newValue} } /// Returns true if `optionalImportMessage` has been explicitly set. - var hasOptionalImportMessage: Bool {return _storage._optionalImportMessage != nil} + var hasOptionalImportMessage: Bool {_storage._optionalImportMessage != nil} /// Clears the value of `optionalImportMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalImportMessage() {_uniqueStorage()._optionalImportMessage = nil} var optionalNestedEnum: Proto3ArenaLiteUnittest_TestAllTypes.NestedEnum { - get {return _storage._optionalNestedEnum} + get {_storage._optionalNestedEnum} set {_uniqueStorage()._optionalNestedEnum = newValue} } var optionalForeignEnum: Proto3ArenaLiteUnittest_ForeignEnum { - get {return _storage._optionalForeignEnum} + get {_storage._optionalForeignEnum} set {_uniqueStorage()._optionalForeignEnum = newValue} } var optionalStringPiece: String { - get {return _storage._optionalStringPiece} + get {_storage._optionalStringPiece} set {_uniqueStorage()._optionalStringPiece = newValue} } var optionalCord: String { - get {return _storage._optionalCord} + get {_storage._optionalCord} set {_uniqueStorage()._optionalCord = newValue} } /// Defined in unittest_import_public.proto - var optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessage { - get {return _storage._optionalPublicImportMessage ?? ProtobufUnittestImport_PublicImportMessage()} + var optionalPublicImportMessage: Proto2UnittestImport_PublicImportMessage { + get {_storage._optionalPublicImportMessage ?? Proto2UnittestImport_PublicImportMessage()} set {_uniqueStorage()._optionalPublicImportMessage = newValue} } /// Returns true if `optionalPublicImportMessage` has been explicitly set. - var hasOptionalPublicImportMessage: Bool {return _storage._optionalPublicImportMessage != nil} + var hasOptionalPublicImportMessage: Bool {_storage._optionalPublicImportMessage != nil} /// Clears the value of `optionalPublicImportMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalPublicImportMessage() {_uniqueStorage()._optionalPublicImportMessage = nil} var optionalLazyMessage: Proto3ArenaLiteUnittest_TestAllTypes.NestedMessage { - get {return _storage._optionalLazyMessage ?? Proto3ArenaLiteUnittest_TestAllTypes.NestedMessage()} + get {_storage._optionalLazyMessage ?? Proto3ArenaLiteUnittest_TestAllTypes.NestedMessage()} set {_uniqueStorage()._optionalLazyMessage = newValue} } /// Returns true if `optionalLazyMessage` has been explicitly set. - var hasOptionalLazyMessage: Bool {return _storage._optionalLazyMessage != nil} + var hasOptionalLazyMessage: Bool {_storage._optionalLazyMessage != nil} /// Clears the value of `optionalLazyMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalLazyMessage() {_uniqueStorage()._optionalLazyMessage = nil} /// Repeated var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } var repeatedNestedMessage: [Proto3ArenaLiteUnittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedNestedMessage} + get {_storage._repeatedNestedMessage} set {_uniqueStorage()._repeatedNestedMessage = newValue} } var repeatedForeignMessage: [Proto3ArenaLiteUnittest_ForeignMessage] { - get {return _storage._repeatedForeignMessage} + get {_storage._repeatedForeignMessage} set {_uniqueStorage()._repeatedForeignMessage = newValue} } - var repeatedImportMessage: [ProtobufUnittestImport_ImportMessage] { - get {return _storage._repeatedImportMessage} + var repeatedImportMessage: [Proto2UnittestImport_ImportMessage] { + get {_storage._repeatedImportMessage} set {_uniqueStorage()._repeatedImportMessage = newValue} } var repeatedNestedEnum: [Proto3ArenaLiteUnittest_TestAllTypes.NestedEnum] { - get {return _storage._repeatedNestedEnum} + get {_storage._repeatedNestedEnum} set {_uniqueStorage()._repeatedNestedEnum = newValue} } var repeatedForeignEnum: [Proto3ArenaLiteUnittest_ForeignEnum] { - get {return _storage._repeatedForeignEnum} + get {_storage._repeatedForeignEnum} set {_uniqueStorage()._repeatedForeignEnum = newValue} } var repeatedStringPiece: [String] { - get {return _storage._repeatedStringPiece} + get {_storage._repeatedStringPiece} set {_uniqueStorage()._repeatedStringPiece = newValue} } var repeatedCord: [String] { - get {return _storage._repeatedCord} + get {_storage._repeatedCord} set {_uniqueStorage()._repeatedCord = newValue} } var repeatedLazyMessage: [Proto3ArenaLiteUnittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedLazyMessage} + get {_storage._repeatedLazyMessage} set {_uniqueStorage()._repeatedLazyMessage = newValue} } @@ -402,41 +374,15 @@ struct Proto3ArenaLiteUnittest_TestAllTypes { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case oneofUint32(UInt32) case oneofNestedMessage(Proto3ArenaLiteUnittest_TestAllTypes.NestedMessage) case oneofString(String) case oneofBytes(Data) - #if !swift(>=4.1) - static func ==(lhs: Proto3ArenaLiteUnittest_TestAllTypes.OneOf_OneofField, rhs: Proto3ArenaLiteUnittest_TestAllTypes.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum NestedEnum: SwiftProtobuf.Enum { + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case zero // = 0 case foo // = 1 @@ -473,9 +419,18 @@ struct Proto3ArenaLiteUnittest_TestAllTypes { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Proto3ArenaLiteUnittest_TestAllTypes.NestedEnum] = [ + .zero, + .foo, + .bar, + .baz, + .neg, + ] + } - struct NestedMessage { + struct NestedMessage: Sendable { // 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. @@ -495,22 +450,7 @@ struct Proto3ArenaLiteUnittest_TestAllTypes { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension Proto3ArenaLiteUnittest_TestAllTypes.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto3ArenaLiteUnittest_TestAllTypes.NestedEnum] = [ - .zero, - .foo, - .bar, - .baz, - .neg, - ] -} - -#endif // swift(>=4.2) - -struct Proto3ArenaLiteUnittest_TestPackedTypes { +struct Proto3ArenaLiteUnittest_TestPackedTypes: Sendable { // 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. @@ -549,7 +489,7 @@ struct Proto3ArenaLiteUnittest_TestPackedTypes { } /// Explicitly set packed to false -struct Proto3ArenaLiteUnittest_TestUnpackedTypes { +struct Proto3ArenaLiteUnittest_TestUnpackedTypes: Sendable { // 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. @@ -588,26 +528,26 @@ struct Proto3ArenaLiteUnittest_TestUnpackedTypes { } /// This proto includes a recursively nested message. -struct Proto3ArenaLiteUnittest_NestedTestAllTypes { +struct Proto3ArenaLiteUnittest_NestedTestAllTypes: @unchecked Sendable { // 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 child: Proto3ArenaLiteUnittest_NestedTestAllTypes { - get {return _storage._child ?? Proto3ArenaLiteUnittest_NestedTestAllTypes()} + get {_storage._child ?? Proto3ArenaLiteUnittest_NestedTestAllTypes()} set {_uniqueStorage()._child = newValue} } /// Returns true if `child` has been explicitly set. - var hasChild: Bool {return _storage._child != nil} + var hasChild: Bool {_storage._child != nil} /// Clears the value of `child`. Subsequent reads from it will return its default value. mutating func clearChild() {_uniqueStorage()._child = nil} var payload: Proto3ArenaLiteUnittest_TestAllTypes { - get {return _storage._payload ?? Proto3ArenaLiteUnittest_TestAllTypes()} + get {_storage._payload ?? Proto3ArenaLiteUnittest_TestAllTypes()} set {_uniqueStorage()._payload = newValue} } /// Returns true if `payload` has been explicitly set. - var hasPayload: Bool {return _storage._payload != nil} + var hasPayload: Bool {_storage._payload != nil} /// Clears the value of `payload`. Subsequent reads from it will return its default value. mutating func clearPayload() {_uniqueStorage()._payload = nil} @@ -620,7 +560,7 @@ struct Proto3ArenaLiteUnittest_NestedTestAllTypes { /// Define these after TestAllTypes to make sure the compiler can handle /// that. -struct Proto3ArenaLiteUnittest_ForeignMessage { +struct Proto3ArenaLiteUnittest_ForeignMessage: Sendable { // 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. @@ -633,7 +573,7 @@ struct Proto3ArenaLiteUnittest_ForeignMessage { } /// TestEmptyMessage is used to test behavior of unknown fields. -struct Proto3ArenaLiteUnittest_TestEmptyMessage { +struct Proto3ArenaLiteUnittest_TestEmptyMessage: Sendable { // 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. @@ -643,87 +583,17 @@ struct Proto3ArenaLiteUnittest_TestEmptyMessage { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Proto3ArenaLiteUnittest_ForeignEnum: @unchecked Sendable {} -extension Proto3ArenaLiteUnittest_TestAllTypes: @unchecked Sendable {} -extension Proto3ArenaLiteUnittest_TestAllTypes.OneOf_OneofField: @unchecked Sendable {} -extension Proto3ArenaLiteUnittest_TestAllTypes.NestedEnum: @unchecked Sendable {} -extension Proto3ArenaLiteUnittest_TestAllTypes.NestedMessage: @unchecked Sendable {} -extension Proto3ArenaLiteUnittest_TestPackedTypes: @unchecked Sendable {} -extension Proto3ArenaLiteUnittest_TestUnpackedTypes: @unchecked Sendable {} -extension Proto3ArenaLiteUnittest_NestedTestAllTypes: @unchecked Sendable {} -extension Proto3ArenaLiteUnittest_ForeignMessage: @unchecked Sendable {} -extension Proto3ArenaLiteUnittest_TestEmptyMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "proto3_arena_lite_unittest" extension Proto3ArenaLiteUnittest_ForeignEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOREIGN_ZERO"), - 4: .same(proto: "FOREIGN_FOO"), - 5: .same(proto: "FOREIGN_BAR"), - 6: .same(proto: "FOREIGN_BAZ"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_ZERO\0\u{2}\u{4}FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") } extension Proto3ArenaLiteUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "optional_foreign_message"), - 20: .standard(proto: "optional_import_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "optional_foreign_enum"), - 24: .standard(proto: "optional_string_piece"), - 25: .standard(proto: "optional_cord"), - 26: .standard(proto: "optional_public_import_message"), - 27: .standard(proto: "optional_lazy_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 48: .standard(proto: "repeated_nested_message"), - 49: .standard(proto: "repeated_foreign_message"), - 50: .standard(proto: "repeated_import_message"), - 51: .standard(proto: "repeated_nested_enum"), - 52: .standard(proto: "repeated_foreign_enum"), - 54: .standard(proto: "repeated_string_piece"), - 55: .standard(proto: "repeated_cord"), - 57: .standard(proto: "repeated_lazy_message"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{3}optional_import_message\0\u{3}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{4}\u{2}optional_string_piece\0\u{3}optional_cord\0\u{3}optional_public_import_message\0\u{3}optional_lazy_message\0\u{4}\u{4}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{3}repeated_import_message\0\u{3}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{4}\u{2}repeated_lazy_message\0\u{4}6oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0") fileprivate class _StorageClass { var _optionalInt32: Int32 = 0 @@ -743,12 +613,12 @@ extension Proto3ArenaLiteUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProt var _optionalBytes: Data = Data() var _optionalNestedMessage: Proto3ArenaLiteUnittest_TestAllTypes.NestedMessage? = nil var _optionalForeignMessage: Proto3ArenaLiteUnittest_ForeignMessage? = nil - var _optionalImportMessage: ProtobufUnittestImport_ImportMessage? = nil + var _optionalImportMessage: Proto2UnittestImport_ImportMessage? = nil var _optionalNestedEnum: Proto3ArenaLiteUnittest_TestAllTypes.NestedEnum = .zero var _optionalForeignEnum: Proto3ArenaLiteUnittest_ForeignEnum = .foreignZero var _optionalStringPiece: String = String() var _optionalCord: String = String() - var _optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessage? = nil + var _optionalPublicImportMessage: Proto2UnittestImport_PublicImportMessage? = nil var _optionalLazyMessage: Proto3ArenaLiteUnittest_TestAllTypes.NestedMessage? = nil var _repeatedInt32: [Int32] = [] var _repeatedInt64: [Int64] = [] @@ -767,7 +637,7 @@ extension Proto3ArenaLiteUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProt var _repeatedBytes: [Data] = [] var _repeatedNestedMessage: [Proto3ArenaLiteUnittest_TestAllTypes.NestedMessage] = [] var _repeatedForeignMessage: [Proto3ArenaLiteUnittest_ForeignMessage] = [] - var _repeatedImportMessage: [ProtobufUnittestImport_ImportMessage] = [] + var _repeatedImportMessage: [Proto2UnittestImport_ImportMessage] = [] var _repeatedNestedEnum: [Proto3ArenaLiteUnittest_TestAllTypes.NestedEnum] = [] var _repeatedForeignEnum: [Proto3ArenaLiteUnittest_ForeignEnum] = [] var _repeatedStringPiece: [String] = [] @@ -775,7 +645,11 @@ extension Proto3ArenaLiteUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProt var _repeatedLazyMessage: [Proto3ArenaLiteUnittest_TestAllTypes.NestedMessage] = [] var _oneofField: Proto3ArenaLiteUnittest_TestAllTypes.OneOf_OneofField? - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -972,10 +846,10 @@ extension Proto3ArenaLiteUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProt if _storage._optionalSfixed64 != 0 { try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) } - if _storage._optionalFloat != 0 { + if _storage._optionalFloat.bitPattern != 0 { try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) } - if _storage._optionalDouble != 0 { + if _storage._optionalDouble.bitPattern != 0 { try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) } if _storage._optionalBool != false { @@ -1169,20 +1043,12 @@ extension Proto3ArenaLiteUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProt } extension Proto3ArenaLiteUnittest_TestAllTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -1: .same(proto: "NEG"), - 0: .same(proto: "ZERO"), - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - 3: .same(proto: "BAZ"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}ZERO\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") } extension Proto3ArenaLiteUnittest_TestAllTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = Proto3ArenaLiteUnittest_TestAllTypes.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1212,22 +1078,7 @@ extension Proto3ArenaLiteUnittest_TestAllTypes.NestedMessage: SwiftProtobuf.Mess extension Proto3ArenaLiteUnittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestPackedTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 90: .standard(proto: "packed_int32"), - 91: .standard(proto: "packed_int64"), - 92: .standard(proto: "packed_uint32"), - 93: .standard(proto: "packed_uint64"), - 94: .standard(proto: "packed_sint32"), - 95: .standard(proto: "packed_sint64"), - 96: .standard(proto: "packed_fixed32"), - 97: .standard(proto: "packed_fixed64"), - 98: .standard(proto: "packed_sfixed32"), - 99: .standard(proto: "packed_sfixed64"), - 100: .standard(proto: "packed_float"), - 101: .standard(proto: "packed_double"), - 102: .standard(proto: "packed_bool"), - 103: .standard(proto: "packed_enum"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}Z\u{1}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1322,22 +1173,7 @@ extension Proto3ArenaLiteUnittest_TestPackedTypes: SwiftProtobuf.Message, SwiftP extension Proto3ArenaLiteUnittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestUnpackedTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "repeated_int32"), - 2: .standard(proto: "repeated_int64"), - 3: .standard(proto: "repeated_uint32"), - 4: .standard(proto: "repeated_uint64"), - 5: .standard(proto: "repeated_sint32"), - 6: .standard(proto: "repeated_sint64"), - 7: .standard(proto: "repeated_fixed32"), - 8: .standard(proto: "repeated_fixed64"), - 9: .standard(proto: "repeated_sfixed32"), - 10: .standard(proto: "repeated_sfixed64"), - 11: .standard(proto: "repeated_float"), - 12: .standard(proto: "repeated_double"), - 13: .standard(proto: "repeated_bool"), - 14: .standard(proto: "repeated_nested_enum"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_nested_enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1432,16 +1268,17 @@ extension Proto3ArenaLiteUnittest_TestUnpackedTypes: SwiftProtobuf.Message, Swif extension Proto3ArenaLiteUnittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".NestedTestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "child"), - 2: .same(proto: "payload"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}child\0\u{1}payload\0") fileprivate class _StorageClass { var _child: Proto3ArenaLiteUnittest_NestedTestAllTypes? = nil var _payload: Proto3ArenaLiteUnittest_TestAllTypes? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1508,9 +1345,7 @@ extension Proto3ArenaLiteUnittest_NestedTestAllTypes: SwiftProtobuf.Message, Swi extension Proto3ArenaLiteUnittest_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ForeignMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1543,8 +1378,8 @@ extension Proto3ArenaLiteUnittest_TestEmptyMessage: SwiftProtobuf.Message, Swift static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { diff --git a/Reference/upstream/google/protobuf/unittest_proto3_bad_macros.pb.swift b/Reference/upstream/google/protobuf/unittest_proto3_bad_macros.pb.swift new file mode 100644 index 000000000..99d9eaa57 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_proto3_bad_macros.pb.swift @@ -0,0 +1,277 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_proto3_bad_macros.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2023 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +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 +} + +/// This generates `GID_MAX`, which is a macro in some circumstances. +enum ProtobufUnittest_GID: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case unused // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .unused + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .unused + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .unused: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufUnittest_GID] = [ + .unused, + ] + +} + +/// This generates `UID_MAX`, which is a mcro in some circumstances. +enum ProtobufUnittest_UID: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case unused // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .unused + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .unused + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .unused: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufUnittest_UID] = [ + .unused, + ] + +} + +/// Just a container for bad macro names. Some of these do not follow the normal +/// naming conventions, this is intentional, we just want to trigger a build +/// failure if the macro is left defined. +enum ProtobufUnittest_BadNames: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + + /// autoheader defines this in some circumstances. + case package // = 0 + + /// The comment says "a few common headers define this". + case packed // = 1 + + /// Defined in many Linux system headers. + case linux // = 2 + + /// This is often a macro in ``. + case domain // = 3 + + /// These are defined in both Windows and macOS headers. + case `true` // = 4 + case `false` // = 5 + + /// Sometimes defined in Windows system headers. + case createNew // = 6 + case delete // = 7 + case doubleClick // = 8 + case error // = 9 + case errorBusy // = 10 + case errorInstallFailed // = 11 + case errorNotFound // = 12 + case getClassName // = 13 + case getCurrentTime // = 14 + case getMessage // = 15 + case getObject // = 16 + case ignore // = 17 + case `in` // = 18 + case inputKeyboard // = 19 + case noError // = 20 + case out // = 21 + case `optional` // = 22 + case near // = 23 + case noData // = 24 + case reasonUnknown // = 25 + case serviceDisabled // = 26 + case severityError // = 27 + case statusPending // = 28 + case strict // = 29 + + /// Sometimed defined in macOS system headers. + case typeBool // = 30 + + /// Defined in macOS, Windows, and Linux headers. + case debug // = 31 + case UNRECOGNIZED(Int) + + init() { + self = .package + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .package + case 1: self = .packed + case 2: self = .linux + case 3: self = .domain + case 4: self = .true + case 5: self = .false + case 6: self = .createNew + case 7: self = .delete + case 8: self = .doubleClick + case 9: self = .error + case 10: self = .errorBusy + case 11: self = .errorInstallFailed + case 12: self = .errorNotFound + case 13: self = .getClassName + case 14: self = .getCurrentTime + case 15: self = .getMessage + case 16: self = .getObject + case 17: self = .ignore + case 18: self = .in + case 19: self = .inputKeyboard + case 20: self = .noError + case 21: self = .out + case 22: self = .optional + case 23: self = .near + case 24: self = .noData + case 25: self = .reasonUnknown + case 26: self = .serviceDisabled + case 27: self = .severityError + case 28: self = .statusPending + case 29: self = .strict + case 30: self = .typeBool + case 31: self = .debug + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .package: return 0 + case .packed: return 1 + case .linux: return 2 + case .domain: return 3 + case .true: return 4 + case .false: return 5 + case .createNew: return 6 + case .delete: return 7 + case .doubleClick: return 8 + case .error: return 9 + case .errorBusy: return 10 + case .errorInstallFailed: return 11 + case .errorNotFound: return 12 + case .getClassName: return 13 + case .getCurrentTime: return 14 + case .getMessage: return 15 + case .getObject: return 16 + case .ignore: return 17 + case .in: return 18 + case .inputKeyboard: return 19 + case .noError: return 20 + case .out: return 21 + case .optional: return 22 + case .near: return 23 + case .noData: return 24 + case .reasonUnknown: return 25 + case .serviceDisabled: return 26 + case .severityError: return 27 + case .statusPending: return 28 + case .strict: return 29 + case .typeBool: return 30 + case .debug: return 31 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufUnittest_BadNames] = [ + .package, + .packed, + .linux, + .domain, + .true, + .false, + .createNew, + .delete, + .doubleClick, + .error, + .errorBusy, + .errorInstallFailed, + .errorNotFound, + .getClassName, + .getCurrentTime, + .getMessage, + .getObject, + .ignore, + .in, + .inputKeyboard, + .noError, + .out, + .optional, + .near, + .noData, + .reasonUnknown, + .serviceDisabled, + .severityError, + .statusPending, + .strict, + .typeBool, + .debug, + ] + +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +extension ProtobufUnittest_GID: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0GID_UNUSED\0") +} + +extension ProtobufUnittest_UID: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UID_UNUSED\0") +} + +extension ProtobufUnittest_BadNames: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0PACKAGE\0\u{1}PACKED\0\u{1}linux\0\u{1}DOMAIN\0\u{1}TRUE\0\u{1}FALSE\0\u{1}CREATE_NEW\0\u{1}DELETE\0\u{1}DOUBLE_CLICK\0\u{1}ERROR\0\u{1}ERROR_BUSY\0\u{1}ERROR_INSTALL_FAILED\0\u{1}ERROR_NOT_FOUND\0\u{1}GetClassName\0\u{1}GetCurrentTime\0\u{1}GetMessage\0\u{1}GetObject\0\u{1}IGNORE\0\u{1}IN\0\u{1}INPUT_KEYBOARD\0\u{1}NO_ERROR\0\u{1}OUT\0\u{1}OPTIONAL\0\u{1}NEAR\0\u{1}NO_DATA\0\u{1}REASON_UNKNOWN\0\u{1}SERVICE_DISABLED\0\u{1}SEVERITY_ERROR\0\u{1}STATUS_PENDING\0\u{1}STRICT\0\u{1}TYPE_BOOL\0\u{1}DEBUG\0") +} diff --git a/Reference/upstream/google/protobuf/unittest_proto3_extensions.pb.swift b/Reference/upstream/google/protobuf/unittest_proto3_extensions.pb.swift new file mode 100644 index 000000000..a67f4f6f7 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_proto3_extensions.pb.swift @@ -0,0 +1,117 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_proto3_extensions.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +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 +} + +/// For testing proto3 extension behaviors. +struct ProtobufUnittest_Proto3FileExtensions: Sendable { + // 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() {} +} + +// MARK: - Extension support defined in unittest_proto3_extensions.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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_FileOptions { + + var ProtobufUnittest_Proto3FileExtensions_singularInt: Int32 { + get {return getExtensionValue(ext: ProtobufUnittest_Proto3FileExtensions.Extensions.singular_int) ?? 0} + set {setExtensionValue(ext: ProtobufUnittest_Proto3FileExtensions.Extensions.singular_int, value: newValue)} + } + /// Returns true if extension `ProtobufUnittest_Proto3FileExtensions.Extensions.singular_int` + /// has been explicitly set. + var hasProtobufUnittest_Proto3FileExtensions_singularInt: Bool { + return hasExtensionValue(ext: ProtobufUnittest_Proto3FileExtensions.Extensions.singular_int) + } + /// Clears the value of extension `ProtobufUnittest_Proto3FileExtensions.Extensions.singular_int`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufUnittest_Proto3FileExtensions_singularInt() { + clearExtensionValue(ext: ProtobufUnittest_Proto3FileExtensions.Extensions.singular_int) + } + + var ProtobufUnittest_Proto3FileExtensions_repeatedInt: [Int32] { + get {return getExtensionValue(ext: ProtobufUnittest_Proto3FileExtensions.Extensions.repeated_int) ?? []} + set {setExtensionValue(ext: ProtobufUnittest_Proto3FileExtensions.Extensions.repeated_int, value: newValue)} + } + +} + +// MARK: - File's ExtensionMap: ProtobufUnittest_UnittestProto3Extensions_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 ProtobufUnittest_UnittestProto3Extensions_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + ProtobufUnittest_Proto3FileExtensions.Extensions.singular_int, + ProtobufUnittest_Proto3FileExtensions.Extensions.repeated_int +] + +// 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. + +extension ProtobufUnittest_Proto3FileExtensions { + enum Extensions { + static let singular_int = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( + _protobuf_fieldNumber: 1001, + fieldName: "protobuf_unittest.Proto3FileExtensions.singular_int" + ) + + static let repeated_int = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( + _protobuf_fieldNumber: 1002, + fieldName: "protobuf_unittest.Proto3FileExtensions.repeated_int" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "protobuf_unittest" + +extension ProtobufUnittest_Proto3FileExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Proto3FileExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufUnittest_Proto3FileExtensions, rhs: ProtobufUnittest_Proto3FileExtensions) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/google/protobuf/unittest_proto3_lite.pb.swift b/Reference/upstream/google/protobuf/unittest_proto3_lite.pb.swift similarity index 81% rename from Reference/google/protobuf/unittest_proto3_lite.pb.swift rename to Reference/upstream/google/protobuf/unittest_proto3_lite.pb.swift index 43102b417..b102b1c4c 100644 --- a/Reference/google/protobuf/unittest_proto3_lite.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_proto3_lite.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/unittest_proto3_lite.proto @@ -9,33 +10,10 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd import Foundation import SwiftProtobuf @@ -50,7 +28,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum Proto3LiteUnittest_ForeignEnum: SwiftProtobuf.Enum { +enum Proto3LiteUnittest_ForeignEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foreignZero // = 0 case foreignFoo // = 4 @@ -82,284 +60,278 @@ enum Proto3LiteUnittest_ForeignEnum: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension Proto3LiteUnittest_ForeignEnum: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto3LiteUnittest_ForeignEnum] = [ + static let allCases: [Proto3LiteUnittest_ForeignEnum] = [ .foreignZero, .foreignFoo, .foreignBar, .foreignBaz, ] -} -#endif // swift(>=4.2) +} /// This proto includes every type of field in both singular and repeated /// forms. -struct Proto3LiteUnittest_TestAllTypes { +struct Proto3LiteUnittest_TestAllTypes: @unchecked Sendable { // 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. /// Singular var optionalInt32: Int32 { - get {return _storage._optionalInt32} + get {_storage._optionalInt32} set {_uniqueStorage()._optionalInt32 = newValue} } var optionalInt64: Int64 { - get {return _storage._optionalInt64} + get {_storage._optionalInt64} set {_uniqueStorage()._optionalInt64 = newValue} } var optionalUint32: UInt32 { - get {return _storage._optionalUint32} + get {_storage._optionalUint32} set {_uniqueStorage()._optionalUint32 = newValue} } var optionalUint64: UInt64 { - get {return _storage._optionalUint64} + get {_storage._optionalUint64} set {_uniqueStorage()._optionalUint64 = newValue} } var optionalSint32: Int32 { - get {return _storage._optionalSint32} + get {_storage._optionalSint32} set {_uniqueStorage()._optionalSint32 = newValue} } var optionalSint64: Int64 { - get {return _storage._optionalSint64} + get {_storage._optionalSint64} set {_uniqueStorage()._optionalSint64 = newValue} } var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32} + get {_storage._optionalFixed32} set {_uniqueStorage()._optionalFixed32 = newValue} } var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64} + get {_storage._optionalFixed64} set {_uniqueStorage()._optionalFixed64 = newValue} } var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32} + get {_storage._optionalSfixed32} set {_uniqueStorage()._optionalSfixed32 = newValue} } var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64} + get {_storage._optionalSfixed64} set {_uniqueStorage()._optionalSfixed64 = newValue} } var optionalFloat: Float { - get {return _storage._optionalFloat} + get {_storage._optionalFloat} set {_uniqueStorage()._optionalFloat = newValue} } var optionalDouble: Double { - get {return _storage._optionalDouble} + get {_storage._optionalDouble} set {_uniqueStorage()._optionalDouble = newValue} } var optionalBool: Bool { - get {return _storage._optionalBool} + get {_storage._optionalBool} set {_uniqueStorage()._optionalBool = newValue} } var optionalString: String { - get {return _storage._optionalString} + get {_storage._optionalString} set {_uniqueStorage()._optionalString = newValue} } var optionalBytes: Data { - get {return _storage._optionalBytes} + get {_storage._optionalBytes} set {_uniqueStorage()._optionalBytes = newValue} } var optionalNestedMessage: Proto3LiteUnittest_TestAllTypes.NestedMessage { - get {return _storage._optionalNestedMessage ?? Proto3LiteUnittest_TestAllTypes.NestedMessage()} + get {_storage._optionalNestedMessage ?? Proto3LiteUnittest_TestAllTypes.NestedMessage()} set {_uniqueStorage()._optionalNestedMessage = newValue} } /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} var optionalForeignMessage: Proto3LiteUnittest_ForeignMessage { - get {return _storage._optionalForeignMessage ?? Proto3LiteUnittest_ForeignMessage()} + get {_storage._optionalForeignMessage ?? Proto3LiteUnittest_ForeignMessage()} set {_uniqueStorage()._optionalForeignMessage = newValue} } /// Returns true if `optionalForeignMessage` has been explicitly set. - var hasOptionalForeignMessage: Bool {return _storage._optionalForeignMessage != nil} + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} - var optionalImportMessage: ProtobufUnittestImport_ImportMessage { - get {return _storage._optionalImportMessage ?? ProtobufUnittestImport_ImportMessage()} + var optionalImportMessage: Proto2UnittestImport_ImportMessage { + get {_storage._optionalImportMessage ?? Proto2UnittestImport_ImportMessage()} set {_uniqueStorage()._optionalImportMessage = newValue} } /// Returns true if `optionalImportMessage` has been explicitly set. - var hasOptionalImportMessage: Bool {return _storage._optionalImportMessage != nil} + var hasOptionalImportMessage: Bool {_storage._optionalImportMessage != nil} /// Clears the value of `optionalImportMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalImportMessage() {_uniqueStorage()._optionalImportMessage = nil} var optionalNestedEnum: Proto3LiteUnittest_TestAllTypes.NestedEnum { - get {return _storage._optionalNestedEnum} + get {_storage._optionalNestedEnum} set {_uniqueStorage()._optionalNestedEnum = newValue} } var optionalForeignEnum: Proto3LiteUnittest_ForeignEnum { - get {return _storage._optionalForeignEnum} + get {_storage._optionalForeignEnum} set {_uniqueStorage()._optionalForeignEnum = newValue} } var optionalStringPiece: String { - get {return _storage._optionalStringPiece} + get {_storage._optionalStringPiece} set {_uniqueStorage()._optionalStringPiece = newValue} } var optionalCord: String { - get {return _storage._optionalCord} + get {_storage._optionalCord} set {_uniqueStorage()._optionalCord = newValue} } /// Defined in unittest_import_public.proto - var optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessage { - get {return _storage._optionalPublicImportMessage ?? ProtobufUnittestImport_PublicImportMessage()} + var optionalPublicImportMessage: Proto2UnittestImport_PublicImportMessage { + get {_storage._optionalPublicImportMessage ?? Proto2UnittestImport_PublicImportMessage()} set {_uniqueStorage()._optionalPublicImportMessage = newValue} } /// Returns true if `optionalPublicImportMessage` has been explicitly set. - var hasOptionalPublicImportMessage: Bool {return _storage._optionalPublicImportMessage != nil} + var hasOptionalPublicImportMessage: Bool {_storage._optionalPublicImportMessage != nil} /// Clears the value of `optionalPublicImportMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalPublicImportMessage() {_uniqueStorage()._optionalPublicImportMessage = nil} var optionalLazyMessage: Proto3LiteUnittest_TestAllTypes.NestedMessage { - get {return _storage._optionalLazyMessage ?? Proto3LiteUnittest_TestAllTypes.NestedMessage()} + get {_storage._optionalLazyMessage ?? Proto3LiteUnittest_TestAllTypes.NestedMessage()} set {_uniqueStorage()._optionalLazyMessage = newValue} } /// Returns true if `optionalLazyMessage` has been explicitly set. - var hasOptionalLazyMessage: Bool {return _storage._optionalLazyMessage != nil} + var hasOptionalLazyMessage: Bool {_storage._optionalLazyMessage != nil} /// Clears the value of `optionalLazyMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalLazyMessage() {_uniqueStorage()._optionalLazyMessage = nil} /// Repeated var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } var repeatedNestedMessage: [Proto3LiteUnittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedNestedMessage} + get {_storage._repeatedNestedMessage} set {_uniqueStorage()._repeatedNestedMessage = newValue} } var repeatedForeignMessage: [Proto3LiteUnittest_ForeignMessage] { - get {return _storage._repeatedForeignMessage} + get {_storage._repeatedForeignMessage} set {_uniqueStorage()._repeatedForeignMessage = newValue} } - var repeatedImportMessage: [ProtobufUnittestImport_ImportMessage] { - get {return _storage._repeatedImportMessage} + var repeatedImportMessage: [Proto2UnittestImport_ImportMessage] { + get {_storage._repeatedImportMessage} set {_uniqueStorage()._repeatedImportMessage = newValue} } var repeatedNestedEnum: [Proto3LiteUnittest_TestAllTypes.NestedEnum] { - get {return _storage._repeatedNestedEnum} + get {_storage._repeatedNestedEnum} set {_uniqueStorage()._repeatedNestedEnum = newValue} } var repeatedForeignEnum: [Proto3LiteUnittest_ForeignEnum] { - get {return _storage._repeatedForeignEnum} + get {_storage._repeatedForeignEnum} set {_uniqueStorage()._repeatedForeignEnum = newValue} } var repeatedStringPiece: [String] { - get {return _storage._repeatedStringPiece} + get {_storage._repeatedStringPiece} set {_uniqueStorage()._repeatedStringPiece = newValue} } var repeatedCord: [String] { - get {return _storage._repeatedCord} + get {_storage._repeatedCord} set {_uniqueStorage()._repeatedCord = newValue} } var repeatedLazyMessage: [Proto3LiteUnittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedLazyMessage} + get {_storage._repeatedLazyMessage} set {_uniqueStorage()._repeatedLazyMessage = newValue} } @@ -402,41 +374,15 @@ struct Proto3LiteUnittest_TestAllTypes { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case oneofUint32(UInt32) case oneofNestedMessage(Proto3LiteUnittest_TestAllTypes.NestedMessage) case oneofString(String) case oneofBytes(Data) - #if !swift(>=4.1) - static func ==(lhs: Proto3LiteUnittest_TestAllTypes.OneOf_OneofField, rhs: Proto3LiteUnittest_TestAllTypes.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum NestedEnum: SwiftProtobuf.Enum { + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case zero // = 0 case foo // = 1 @@ -473,9 +419,18 @@ struct Proto3LiteUnittest_TestAllTypes { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Proto3LiteUnittest_TestAllTypes.NestedEnum] = [ + .zero, + .foo, + .bar, + .baz, + .neg, + ] + } - struct NestedMessage { + struct NestedMessage: Sendable { // 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. @@ -495,22 +450,7 @@ struct Proto3LiteUnittest_TestAllTypes { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension Proto3LiteUnittest_TestAllTypes.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto3LiteUnittest_TestAllTypes.NestedEnum] = [ - .zero, - .foo, - .bar, - .baz, - .neg, - ] -} - -#endif // swift(>=4.2) - -struct Proto3LiteUnittest_TestPackedTypes { +struct Proto3LiteUnittest_TestPackedTypes: Sendable { // 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. @@ -549,7 +489,7 @@ struct Proto3LiteUnittest_TestPackedTypes { } /// Explicitly set packed to false -struct Proto3LiteUnittest_TestUnpackedTypes { +struct Proto3LiteUnittest_TestUnpackedTypes: Sendable { // 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. @@ -588,26 +528,26 @@ struct Proto3LiteUnittest_TestUnpackedTypes { } /// This proto includes a recursively nested message. -struct Proto3LiteUnittest_NestedTestAllTypes { +struct Proto3LiteUnittest_NestedTestAllTypes: @unchecked Sendable { // 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 child: Proto3LiteUnittest_NestedTestAllTypes { - get {return _storage._child ?? Proto3LiteUnittest_NestedTestAllTypes()} + get {_storage._child ?? Proto3LiteUnittest_NestedTestAllTypes()} set {_uniqueStorage()._child = newValue} } /// Returns true if `child` has been explicitly set. - var hasChild: Bool {return _storage._child != nil} + var hasChild: Bool {_storage._child != nil} /// Clears the value of `child`. Subsequent reads from it will return its default value. mutating func clearChild() {_uniqueStorage()._child = nil} var payload: Proto3LiteUnittest_TestAllTypes { - get {return _storage._payload ?? Proto3LiteUnittest_TestAllTypes()} + get {_storage._payload ?? Proto3LiteUnittest_TestAllTypes()} set {_uniqueStorage()._payload = newValue} } /// Returns true if `payload` has been explicitly set. - var hasPayload: Bool {return _storage._payload != nil} + var hasPayload: Bool {_storage._payload != nil} /// Clears the value of `payload`. Subsequent reads from it will return its default value. mutating func clearPayload() {_uniqueStorage()._payload = nil} @@ -620,7 +560,7 @@ struct Proto3LiteUnittest_NestedTestAllTypes { /// Define these after TestAllTypes to make sure the compiler can handle /// that. -struct Proto3LiteUnittest_ForeignMessage { +struct Proto3LiteUnittest_ForeignMessage: Sendable { // 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. @@ -633,7 +573,7 @@ struct Proto3LiteUnittest_ForeignMessage { } /// TestEmptyMessage is used to test behavior of unknown fields. -struct Proto3LiteUnittest_TestEmptyMessage { +struct Proto3LiteUnittest_TestEmptyMessage: Sendable { // 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. @@ -643,87 +583,17 @@ struct Proto3LiteUnittest_TestEmptyMessage { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Proto3LiteUnittest_ForeignEnum: @unchecked Sendable {} -extension Proto3LiteUnittest_TestAllTypes: @unchecked Sendable {} -extension Proto3LiteUnittest_TestAllTypes.OneOf_OneofField: @unchecked Sendable {} -extension Proto3LiteUnittest_TestAllTypes.NestedEnum: @unchecked Sendable {} -extension Proto3LiteUnittest_TestAllTypes.NestedMessage: @unchecked Sendable {} -extension Proto3LiteUnittest_TestPackedTypes: @unchecked Sendable {} -extension Proto3LiteUnittest_TestUnpackedTypes: @unchecked Sendable {} -extension Proto3LiteUnittest_NestedTestAllTypes: @unchecked Sendable {} -extension Proto3LiteUnittest_ForeignMessage: @unchecked Sendable {} -extension Proto3LiteUnittest_TestEmptyMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "proto3_lite_unittest" extension Proto3LiteUnittest_ForeignEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOREIGN_ZERO"), - 4: .same(proto: "FOREIGN_FOO"), - 5: .same(proto: "FOREIGN_BAR"), - 6: .same(proto: "FOREIGN_BAZ"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_ZERO\0\u{2}\u{4}FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") } extension Proto3LiteUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "optional_foreign_message"), - 20: .standard(proto: "optional_import_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "optional_foreign_enum"), - 24: .standard(proto: "optional_string_piece"), - 25: .standard(proto: "optional_cord"), - 26: .standard(proto: "optional_public_import_message"), - 27: .standard(proto: "optional_lazy_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 48: .standard(proto: "repeated_nested_message"), - 49: .standard(proto: "repeated_foreign_message"), - 50: .standard(proto: "repeated_import_message"), - 51: .standard(proto: "repeated_nested_enum"), - 52: .standard(proto: "repeated_foreign_enum"), - 54: .standard(proto: "repeated_string_piece"), - 55: .standard(proto: "repeated_cord"), - 57: .standard(proto: "repeated_lazy_message"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{3}optional_import_message\0\u{3}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{4}\u{2}optional_string_piece\0\u{3}optional_cord\0\u{3}optional_public_import_message\0\u{3}optional_lazy_message\0\u{4}\u{4}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{3}repeated_import_message\0\u{3}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{4}\u{2}repeated_lazy_message\0\u{4}6oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0") fileprivate class _StorageClass { var _optionalInt32: Int32 = 0 @@ -743,12 +613,12 @@ extension Proto3LiteUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf. var _optionalBytes: Data = Data() var _optionalNestedMessage: Proto3LiteUnittest_TestAllTypes.NestedMessage? = nil var _optionalForeignMessage: Proto3LiteUnittest_ForeignMessage? = nil - var _optionalImportMessage: ProtobufUnittestImport_ImportMessage? = nil + var _optionalImportMessage: Proto2UnittestImport_ImportMessage? = nil var _optionalNestedEnum: Proto3LiteUnittest_TestAllTypes.NestedEnum = .zero var _optionalForeignEnum: Proto3LiteUnittest_ForeignEnum = .foreignZero var _optionalStringPiece: String = String() var _optionalCord: String = String() - var _optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessage? = nil + var _optionalPublicImportMessage: Proto2UnittestImport_PublicImportMessage? = nil var _optionalLazyMessage: Proto3LiteUnittest_TestAllTypes.NestedMessage? = nil var _repeatedInt32: [Int32] = [] var _repeatedInt64: [Int64] = [] @@ -767,7 +637,7 @@ extension Proto3LiteUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf. var _repeatedBytes: [Data] = [] var _repeatedNestedMessage: [Proto3LiteUnittest_TestAllTypes.NestedMessage] = [] var _repeatedForeignMessage: [Proto3LiteUnittest_ForeignMessage] = [] - var _repeatedImportMessage: [ProtobufUnittestImport_ImportMessage] = [] + var _repeatedImportMessage: [Proto2UnittestImport_ImportMessage] = [] var _repeatedNestedEnum: [Proto3LiteUnittest_TestAllTypes.NestedEnum] = [] var _repeatedForeignEnum: [Proto3LiteUnittest_ForeignEnum] = [] var _repeatedStringPiece: [String] = [] @@ -775,7 +645,11 @@ extension Proto3LiteUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf. var _repeatedLazyMessage: [Proto3LiteUnittest_TestAllTypes.NestedMessage] = [] var _oneofField: Proto3LiteUnittest_TestAllTypes.OneOf_OneofField? - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -972,10 +846,10 @@ extension Proto3LiteUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf. if _storage._optionalSfixed64 != 0 { try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) } - if _storage._optionalFloat != 0 { + if _storage._optionalFloat.bitPattern != 0 { try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) } - if _storage._optionalDouble != 0 { + if _storage._optionalDouble.bitPattern != 0 { try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) } if _storage._optionalBool != false { @@ -1169,20 +1043,12 @@ extension Proto3LiteUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf. } extension Proto3LiteUnittest_TestAllTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -1: .same(proto: "NEG"), - 0: .same(proto: "ZERO"), - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - 3: .same(proto: "BAZ"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}ZERO\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") } extension Proto3LiteUnittest_TestAllTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = Proto3LiteUnittest_TestAllTypes.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1212,22 +1078,7 @@ extension Proto3LiteUnittest_TestAllTypes.NestedMessage: SwiftProtobuf.Message, extension Proto3LiteUnittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestPackedTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 90: .standard(proto: "packed_int32"), - 91: .standard(proto: "packed_int64"), - 92: .standard(proto: "packed_uint32"), - 93: .standard(proto: "packed_uint64"), - 94: .standard(proto: "packed_sint32"), - 95: .standard(proto: "packed_sint64"), - 96: .standard(proto: "packed_fixed32"), - 97: .standard(proto: "packed_fixed64"), - 98: .standard(proto: "packed_sfixed32"), - 99: .standard(proto: "packed_sfixed64"), - 100: .standard(proto: "packed_float"), - 101: .standard(proto: "packed_double"), - 102: .standard(proto: "packed_bool"), - 103: .standard(proto: "packed_enum"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}Z\u{1}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1322,22 +1173,7 @@ extension Proto3LiteUnittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProtob extension Proto3LiteUnittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestUnpackedTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "repeated_int32"), - 2: .standard(proto: "repeated_int64"), - 3: .standard(proto: "repeated_uint32"), - 4: .standard(proto: "repeated_uint64"), - 5: .standard(proto: "repeated_sint32"), - 6: .standard(proto: "repeated_sint64"), - 7: .standard(proto: "repeated_fixed32"), - 8: .standard(proto: "repeated_fixed64"), - 9: .standard(proto: "repeated_sfixed32"), - 10: .standard(proto: "repeated_sfixed64"), - 11: .standard(proto: "repeated_float"), - 12: .standard(proto: "repeated_double"), - 13: .standard(proto: "repeated_bool"), - 14: .standard(proto: "repeated_nested_enum"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_nested_enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1432,16 +1268,17 @@ extension Proto3LiteUnittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProt extension Proto3LiteUnittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".NestedTestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "child"), - 2: .same(proto: "payload"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}child\0\u{1}payload\0") fileprivate class _StorageClass { var _child: Proto3LiteUnittest_NestedTestAllTypes? = nil var _payload: Proto3LiteUnittest_TestAllTypes? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1508,9 +1345,7 @@ extension Proto3LiteUnittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftPro extension Proto3LiteUnittest_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ForeignMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1543,8 +1378,8 @@ extension Proto3LiteUnittest_TestEmptyMessage: SwiftProtobuf.Message, SwiftProto static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { diff --git a/Reference/google/protobuf/unittest_proto3_optional.pb.swift b/Reference/upstream/google/protobuf/unittest_proto3_optional.pb.swift similarity index 68% rename from Reference/google/protobuf/unittest_proto3_optional.pb.swift rename to Reference/upstream/google/protobuf/unittest_proto3_optional.pb.swift index d453ef7d6..48e2018ef 100644 --- a/Reference/google/protobuf/unittest_proto3_optional.pb.swift +++ b/Reference/upstream/google/protobuf/unittest_proto3_optional.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/unittest_proto3_optional.proto @@ -9,33 +10,10 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd import Foundation import SwiftProtobuf @@ -50,197 +28,197 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_TestProto3Optional { +struct Proto2Unittest_TestProto3Optional: @unchecked Sendable { // 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. /// Singular var optionalInt32: Int32 { - get {return _storage._optionalInt32 ?? 0} + get {_storage._optionalInt32 ?? 0} set {_uniqueStorage()._optionalInt32 = newValue} } /// Returns true if `optionalInt32` has been explicitly set. - var hasOptionalInt32: Bool {return _storage._optionalInt32 != nil} + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} var optionalInt64: Int64 { - get {return _storage._optionalInt64 ?? 0} + get {_storage._optionalInt64 ?? 0} set {_uniqueStorage()._optionalInt64 = newValue} } /// Returns true if `optionalInt64` has been explicitly set. - var hasOptionalInt64: Bool {return _storage._optionalInt64 != nil} + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} var optionalUint32: UInt32 { - get {return _storage._optionalUint32 ?? 0} + get {_storage._optionalUint32 ?? 0} set {_uniqueStorage()._optionalUint32 = newValue} } /// Returns true if `optionalUint32` has been explicitly set. - var hasOptionalUint32: Bool {return _storage._optionalUint32 != nil} + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} var optionalUint64: UInt64 { - get {return _storage._optionalUint64 ?? 0} + get {_storage._optionalUint64 ?? 0} set {_uniqueStorage()._optionalUint64 = newValue} } /// Returns true if `optionalUint64` has been explicitly set. - var hasOptionalUint64: Bool {return _storage._optionalUint64 != nil} + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} var optionalSint32: Int32 { - get {return _storage._optionalSint32 ?? 0} + get {_storage._optionalSint32 ?? 0} set {_uniqueStorage()._optionalSint32 = newValue} } /// Returns true if `optionalSint32` has been explicitly set. - var hasOptionalSint32: Bool {return _storage._optionalSint32 != nil} + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} var optionalSint64: Int64 { - get {return _storage._optionalSint64 ?? 0} + get {_storage._optionalSint64 ?? 0} set {_uniqueStorage()._optionalSint64 = newValue} } /// Returns true if `optionalSint64` has been explicitly set. - var hasOptionalSint64: Bool {return _storage._optionalSint64 != nil} + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32 ?? 0} + get {_storage._optionalFixed32 ?? 0} set {_uniqueStorage()._optionalFixed32 = newValue} } /// Returns true if `optionalFixed32` has been explicitly set. - var hasOptionalFixed32: Bool {return _storage._optionalFixed32 != nil} + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64 ?? 0} + get {_storage._optionalFixed64 ?? 0} set {_uniqueStorage()._optionalFixed64 = newValue} } /// Returns true if `optionalFixed64` has been explicitly set. - var hasOptionalFixed64: Bool {return _storage._optionalFixed64 != nil} + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32 ?? 0} + get {_storage._optionalSfixed32 ?? 0} set {_uniqueStorage()._optionalSfixed32 = newValue} } /// Returns true if `optionalSfixed32` has been explicitly set. - var hasOptionalSfixed32: Bool {return _storage._optionalSfixed32 != nil} + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64 ?? 0} + get {_storage._optionalSfixed64 ?? 0} set {_uniqueStorage()._optionalSfixed64 = newValue} } /// Returns true if `optionalSfixed64` has been explicitly set. - var hasOptionalSfixed64: Bool {return _storage._optionalSfixed64 != nil} + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} var optionalFloat: Float { - get {return _storage._optionalFloat ?? 0} + get {_storage._optionalFloat ?? 0} set {_uniqueStorage()._optionalFloat = newValue} } /// Returns true if `optionalFloat` has been explicitly set. - var hasOptionalFloat: Bool {return _storage._optionalFloat != nil} + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} var optionalDouble: Double { - get {return _storage._optionalDouble ?? 0} + get {_storage._optionalDouble ?? 0} set {_uniqueStorage()._optionalDouble = newValue} } /// Returns true if `optionalDouble` has been explicitly set. - var hasOptionalDouble: Bool {return _storage._optionalDouble != nil} + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} var optionalBool: Bool { - get {return _storage._optionalBool ?? false} + get {_storage._optionalBool ?? false} set {_uniqueStorage()._optionalBool = newValue} } /// Returns true if `optionalBool` has been explicitly set. - var hasOptionalBool: Bool {return _storage._optionalBool != nil} + var hasOptionalBool: Bool {_storage._optionalBool != nil} /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} var optionalString: String { - get {return _storage._optionalString ?? String()} + get {_storage._optionalString ?? String()} set {_uniqueStorage()._optionalString = newValue} } /// Returns true if `optionalString` has been explicitly set. - var hasOptionalString: Bool {return _storage._optionalString != nil} + var hasOptionalString: Bool {_storage._optionalString != nil} /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} var optionalBytes: Data { - get {return _storage._optionalBytes ?? Data()} + get {_storage._optionalBytes ?? Data()} set {_uniqueStorage()._optionalBytes = newValue} } /// Returns true if `optionalBytes` has been explicitly set. - var hasOptionalBytes: Bool {return _storage._optionalBytes != nil} + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} var optionalCord: String { - get {return _storage._optionalCord ?? String()} + get {_storage._optionalCord ?? String()} set {_uniqueStorage()._optionalCord = newValue} } /// Returns true if `optionalCord` has been explicitly set. - var hasOptionalCord: Bool {return _storage._optionalCord != nil} + var hasOptionalCord: Bool {_storage._optionalCord != nil} /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} - var optionalNestedMessage: ProtobufUnittest_TestProto3Optional.NestedMessage { - get {return _storage._optionalNestedMessage ?? ProtobufUnittest_TestProto3Optional.NestedMessage()} + var optionalNestedMessage: Proto2Unittest_TestProto3Optional.NestedMessage { + get {_storage._optionalNestedMessage ?? Proto2Unittest_TestProto3Optional.NestedMessage()} set {_uniqueStorage()._optionalNestedMessage = newValue} } /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} - var lazyNestedMessage: ProtobufUnittest_TestProto3Optional.NestedMessage { - get {return _storage._lazyNestedMessage ?? ProtobufUnittest_TestProto3Optional.NestedMessage()} + var lazyNestedMessage: Proto2Unittest_TestProto3Optional.NestedMessage { + get {_storage._lazyNestedMessage ?? Proto2Unittest_TestProto3Optional.NestedMessage()} set {_uniqueStorage()._lazyNestedMessage = newValue} } /// Returns true if `lazyNestedMessage` has been explicitly set. - var hasLazyNestedMessage: Bool {return _storage._lazyNestedMessage != nil} + var hasLazyNestedMessage: Bool {_storage._lazyNestedMessage != nil} /// Clears the value of `lazyNestedMessage`. Subsequent reads from it will return its default value. mutating func clearLazyNestedMessage() {_uniqueStorage()._lazyNestedMessage = nil} - var optionalNestedEnum: ProtobufUnittest_TestProto3Optional.NestedEnum { - get {return _storage._optionalNestedEnum ?? .unspecified} + var optionalNestedEnum: Proto2Unittest_TestProto3Optional.NestedEnum { + get {_storage._optionalNestedEnum ?? .unspecified} set {_uniqueStorage()._optionalNestedEnum = newValue} } /// Returns true if `optionalNestedEnum` has been explicitly set. - var hasOptionalNestedEnum: Bool {return _storage._optionalNestedEnum != nil} + var hasOptionalNestedEnum: Bool {_storage._optionalNestedEnum != nil} /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} /// Add some non-optional fields to verify we can mix them. var singularInt32: Int32 { - get {return _storage._singularInt32} + get {_storage._singularInt32} set {_uniqueStorage()._singularInt32 = newValue} } var singularInt64: Int64 { - get {return _storage._singularInt64} + get {_storage._singularInt64} set {_uniqueStorage()._singularInt64 = newValue} } var unknownFields = SwiftProtobuf.UnknownStorage() - enum NestedEnum: SwiftProtobuf.Enum { + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case unspecified // = 0 case foo // = 1 @@ -277,9 +255,18 @@ struct ProtobufUnittest_TestProto3Optional { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Proto2Unittest_TestProto3Optional.NestedEnum] = [ + .unspecified, + .foo, + .bar, + .baz, + .neg, + ] + } - struct NestedMessage { + struct NestedMessage: Sendable { // 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. @@ -288,11 +275,11 @@ struct ProtobufUnittest_TestProto3Optional { /// a local variable named "b" in one of the generated methods. Doh. /// This file needs to compile in proto1 to test backwards-compatibility. var bb: Int32 { - get {return _bb ?? 0} + get {_bb ?? 0} set {_bb = newValue} } /// Returns true if `bb` has been explicitly set. - var hasBb: Bool {return self._bb != nil} + var hasBb: Bool {self._bb != nil} /// Clears the value of `bb`. Subsequent reads from it will return its default value. mutating func clearBb() {self._bb = nil} @@ -308,47 +295,32 @@ struct ProtobufUnittest_TestProto3Optional { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension ProtobufUnittest_TestProto3Optional.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittest_TestProto3Optional.NestedEnum] = [ - .unspecified, - .foo, - .bar, - .baz, - .neg, - ] -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_TestProto3OptionalMessage { +struct Proto2Unittest_TestProto3OptionalMessage: Sendable { // 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 nestedMessage: ProtobufUnittest_TestProto3OptionalMessage.NestedMessage { - get {return _nestedMessage ?? ProtobufUnittest_TestProto3OptionalMessage.NestedMessage()} + var nestedMessage: Proto2Unittest_TestProto3OptionalMessage.NestedMessage { + get {_nestedMessage ?? Proto2Unittest_TestProto3OptionalMessage.NestedMessage()} set {_nestedMessage = newValue} } /// Returns true if `nestedMessage` has been explicitly set. - var hasNestedMessage: Bool {return self._nestedMessage != nil} + var hasNestedMessage: Bool {self._nestedMessage != nil} /// Clears the value of `nestedMessage`. Subsequent reads from it will return its default value. mutating func clearNestedMessage() {self._nestedMessage = nil} - var optionalNestedMessage: ProtobufUnittest_TestProto3OptionalMessage.NestedMessage { - get {return _optionalNestedMessage ?? ProtobufUnittest_TestProto3OptionalMessage.NestedMessage()} + var optionalNestedMessage: Proto2Unittest_TestProto3OptionalMessage.NestedMessage { + get {_optionalNestedMessage ?? Proto2Unittest_TestProto3OptionalMessage.NestedMessage()} set {_optionalNestedMessage = newValue} } /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return self._optionalNestedMessage != nil} + var hasOptionalNestedMessage: Bool {self._optionalNestedMessage != nil} /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedMessage() {self._optionalNestedMessage = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - struct NestedMessage { + struct NestedMessage: Sendable { // 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. @@ -362,11 +334,11 @@ struct ProtobufUnittest_TestProto3OptionalMessage { init() {} - fileprivate var _nestedMessage: ProtobufUnittest_TestProto3OptionalMessage.NestedMessage? = nil - fileprivate var _optionalNestedMessage: ProtobufUnittest_TestProto3OptionalMessage.NestedMessage? = nil + fileprivate var _nestedMessage: Proto2Unittest_TestProto3OptionalMessage.NestedMessage? = nil + fileprivate var _optionalNestedMessage: Proto2Unittest_TestProto3OptionalMessage.NestedMessage? = nil } -struct ProtobufUnittest_Proto3OptionalExtensions { +struct Proto2Unittest_Proto3OptionalExtensions: Sendable { // 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. @@ -376,116 +348,85 @@ struct ProtobufUnittest_Proto3OptionalExtensions { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_TestProto3Optional: @unchecked Sendable {} -extension ProtobufUnittest_TestProto3Optional.NestedEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestProto3Optional.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestProto3OptionalMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestProto3OptionalMessage.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_Proto3OptionalExtensions: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_proto3_optional.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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_MessageOptions { - var ProtobufUnittest_Proto3OptionalExtensions_extNoOptional: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_no_optional) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_no_optional, value: newValue)} + var Proto2Unittest_Proto3OptionalExtensions_extNoOptional: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Proto3OptionalExtensions.Extensions.ext_no_optional) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Proto3OptionalExtensions.Extensions.ext_no_optional, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_no_optional` + /// Returns true if extension `Proto2Unittest_Proto3OptionalExtensions.Extensions.ext_no_optional` /// has been explicitly set. - var hasProtobufUnittest_Proto3OptionalExtensions_extNoOptional: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_no_optional) + var hasProto2Unittest_Proto3OptionalExtensions_extNoOptional: Bool { + return hasExtensionValue(ext: Proto2Unittest_Proto3OptionalExtensions.Extensions.ext_no_optional) } - /// Clears the value of extension `ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_no_optional`. + /// Clears the value of extension `Proto2Unittest_Proto3OptionalExtensions.Extensions.ext_no_optional`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Proto3OptionalExtensions_extNoOptional() { - clearExtensionValue(ext: ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_no_optional) + mutating func clearProto2Unittest_Proto3OptionalExtensions_extNoOptional() { + clearExtensionValue(ext: Proto2Unittest_Proto3OptionalExtensions.Extensions.ext_no_optional) } - var ProtobufUnittest_Proto3OptionalExtensions_extWithOptional: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_with_optional) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_with_optional, value: newValue)} + var Proto2Unittest_Proto3OptionalExtensions_extWithOptional: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Proto3OptionalExtensions.Extensions.ext_with_optional) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Proto3OptionalExtensions.Extensions.ext_with_optional, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_with_optional` + /// Returns true if extension `Proto2Unittest_Proto3OptionalExtensions.Extensions.ext_with_optional` /// has been explicitly set. - var hasProtobufUnittest_Proto3OptionalExtensions_extWithOptional: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_with_optional) + var hasProto2Unittest_Proto3OptionalExtensions_extWithOptional: Bool { + return hasExtensionValue(ext: Proto2Unittest_Proto3OptionalExtensions.Extensions.ext_with_optional) } - /// Clears the value of extension `ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_with_optional`. + /// Clears the value of extension `Proto2Unittest_Proto3OptionalExtensions.Extensions.ext_with_optional`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Proto3OptionalExtensions_extWithOptional() { - clearExtensionValue(ext: ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_with_optional) + mutating func clearProto2Unittest_Proto3OptionalExtensions_extWithOptional() { + clearExtensionValue(ext: Proto2Unittest_Proto3OptionalExtensions.Extensions.ext_with_optional) } } -// MARK: - File's ExtensionMap: ProtobufUnittest_UnittestProto3Optional_Extensions +// MARK: - File's ExtensionMap: Proto2Unittest_UnittestProto3Optional_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 ProtobufUnittest_UnittestProto3Optional_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_no_optional, - ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_with_optional +let Proto2Unittest_UnittestProto3Optional_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Proto2Unittest_Proto3OptionalExtensions.Extensions.ext_no_optional, + Proto2Unittest_Proto3OptionalExtensions.Extensions.ext_with_optional ] // 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. -extension ProtobufUnittest_Proto3OptionalExtensions { +extension Proto2Unittest_Proto3OptionalExtensions { enum Extensions { static let ext_no_optional = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( _protobuf_fieldNumber: 355886728, - fieldName: "protobuf_unittest.Proto3OptionalExtensions.ext_no_optional" + fieldName: "proto2_unittest.Proto3OptionalExtensions.ext_no_optional" ) static let ext_with_optional = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( _protobuf_fieldNumber: 355886729, - fieldName: "protobuf_unittest.Proto3OptionalExtensions.ext_with_optional" + fieldName: "proto2_unittest.Proto3OptionalExtensions.ext_with_optional" ) } } // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "proto2_unittest" -extension ProtobufUnittest_TestProto3Optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestProto3Optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestProto3Optional" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 16: .standard(proto: "optional_cord"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "lazy_nested_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "singular_int32"), - 23: .standard(proto: "singular_int64"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{3}optional_cord\0\u{4}\u{2}optional_nested_message\0\u{3}lazy_nested_message\0\u{4}\u{2}optional_nested_enum\0\u{3}singular_int32\0\u{3}singular_int64\0") fileprivate class _StorageClass { var _optionalInt32: Int32? = nil @@ -504,13 +445,17 @@ extension ProtobufUnittest_TestProto3Optional: SwiftProtobuf.Message, SwiftProto var _optionalString: String? = nil var _optionalBytes: Data? = nil var _optionalCord: String? = nil - var _optionalNestedMessage: ProtobufUnittest_TestProto3Optional.NestedMessage? = nil - var _lazyNestedMessage: ProtobufUnittest_TestProto3Optional.NestedMessage? = nil - var _optionalNestedEnum: ProtobufUnittest_TestProto3Optional.NestedEnum? = nil + var _optionalNestedMessage: Proto2Unittest_TestProto3Optional.NestedMessage? = nil + var _lazyNestedMessage: Proto2Unittest_TestProto3Optional.NestedMessage? = nil + var _optionalNestedEnum: Proto2Unittest_TestProto3Optional.NestedEnum? = nil var _singularInt32: Int32 = 0 var _singularInt64: Int64 = 0 - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -654,7 +599,7 @@ extension ProtobufUnittest_TestProto3Optional: SwiftProtobuf.Message, SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestProto3Optional, rhs: ProtobufUnittest_TestProto3Optional) -> Bool { + static func ==(lhs: Proto2Unittest_TestProto3Optional, rhs: Proto2Unittest_TestProto3Optional) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -689,21 +634,13 @@ extension ProtobufUnittest_TestProto3Optional: SwiftProtobuf.Message, SwiftProto } } -extension ProtobufUnittest_TestProto3Optional.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -1: .same(proto: "NEG"), - 0: .same(proto: "UNSPECIFIED"), - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - 3: .same(proto: "BAZ"), - ] +extension Proto2Unittest_TestProto3Optional.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}UNSPECIFIED\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") } -extension ProtobufUnittest_TestProto3Optional.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestProto3Optional.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - ] +extension Proto2Unittest_TestProto3Optional.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestProto3Optional.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -728,19 +665,16 @@ extension ProtobufUnittest_TestProto3Optional.NestedMessage: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestProto3Optional.NestedMessage, rhs: ProtobufUnittest_TestProto3Optional.NestedMessage) -> Bool { + static func ==(lhs: Proto2Unittest_TestProto3Optional.NestedMessage, rhs: Proto2Unittest_TestProto3Optional.NestedMessage) -> Bool { if lhs._bb != rhs._bb {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestProto3OptionalMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_TestProto3OptionalMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestProto3OptionalMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "nested_message"), - 2: .standard(proto: "optional_nested_message"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}nested_message\0\u{3}optional_nested_message\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -769,7 +703,7 @@ extension ProtobufUnittest_TestProto3OptionalMessage: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestProto3OptionalMessage, rhs: ProtobufUnittest_TestProto3OptionalMessage) -> Bool { + static func ==(lhs: Proto2Unittest_TestProto3OptionalMessage, rhs: Proto2Unittest_TestProto3OptionalMessage) -> Bool { if lhs._nestedMessage != rhs._nestedMessage {return false} if lhs._optionalNestedMessage != rhs._optionalNestedMessage {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -777,11 +711,9 @@ extension ProtobufUnittest_TestProto3OptionalMessage: SwiftProtobuf.Message, Swi } } -extension ProtobufUnittest_TestProto3OptionalMessage.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestProto3OptionalMessage.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "s"), - ] +extension Proto2Unittest_TestProto3OptionalMessage.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TestProto3OptionalMessage.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}s\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -802,27 +734,27 @@ extension ProtobufUnittest_TestProto3OptionalMessage.NestedMessage: SwiftProtobu try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestProto3OptionalMessage.NestedMessage, rhs: ProtobufUnittest_TestProto3OptionalMessage.NestedMessage) -> Bool { + static func ==(lhs: Proto2Unittest_TestProto3OptionalMessage.NestedMessage, rhs: Proto2Unittest_TestProto3OptionalMessage.NestedMessage) -> Bool { if lhs.s != rhs.s {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Proto3OptionalExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Proto2Unittest_Proto3OptionalExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Proto3OptionalExtensions" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Proto3OptionalExtensions, rhs: ProtobufUnittest_Proto3OptionalExtensions) -> Bool { + static func ==(lhs: Proto2Unittest_Proto3OptionalExtensions, rhs: Proto2Unittest_Proto3OptionalExtensions) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } diff --git a/Reference/upstream/google/protobuf/unittest_redaction.pb.swift b/Reference/upstream/google/protobuf/unittest_redaction.pb.swift new file mode 100644 index 000000000..9622a4817 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_redaction.pb.swift @@ -0,0 +1,576 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_redaction.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +/// Test proto for redaction + +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 Proto2Unittest_MetaAnnotatedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case testNull // = 0 + case testRedactable // = 1 + case testNoRedact // = 2 + case testNoRedactAgain // = 3 + case testRedactableFalse // = 4 + case UNRECOGNIZED(Int) + + init() { + self = .testNull + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .testNull + case 1: self = .testRedactable + case 2: self = .testNoRedact + case 3: self = .testNoRedactAgain + case 4: self = .testRedactableFalse + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .testNull: return 0 + case .testRedactable: return 1 + case .testNoRedact: return 2 + case .testNoRedactAgain: return 3 + case .testRedactableFalse: return 4 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [Proto2Unittest_MetaAnnotatedEnum] = [ + .testNull, + .testRedactable, + .testNoRedact, + .testNoRedactAgain, + .testRedactableFalse, + ] + +} + +struct Proto2Unittest_TestRedactedNestMessage: Sendable { + // 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 foo: String { + get {_foo ?? String()} + set {_foo = newValue} + } + /// Returns true if `foo` has been explicitly set. + var hasFoo: Bool {self._foo != nil} + /// Clears the value of `foo`. Subsequent reads from it will return its default value. + mutating func clearFoo() {self._foo = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _foo: String? = nil +} + +struct Proto2Unittest_TestRepeatedRedactedNestMessage: Sendable { + // 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 bar: String { + get {_bar ?? String()} + set {_bar = newValue} + } + /// Returns true if `bar` has been explicitly set. + var hasBar: Bool {self._bar != nil} + /// Clears the value of `bar`. Subsequent reads from it will return its default value. + mutating func clearBar() {self._bar = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _bar: String? = nil +} + +struct Proto2Unittest_TestMessageEnum: Sendable { + // 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 redactableEnum: [Proto2Unittest_MetaAnnotatedEnum] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct Proto2Unittest_TestNestedMessageEnum: Sendable { + // 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 directEnum: [Proto2Unittest_MetaAnnotatedEnum] = [] + + var nestedEnum: Proto2Unittest_TestMessageEnum { + get {_nestedEnum ?? Proto2Unittest_TestMessageEnum()} + set {_nestedEnum = newValue} + } + /// Returns true if `nestedEnum` has been explicitly set. + var hasNestedEnum: Bool {self._nestedEnum != nil} + /// Clears the value of `nestedEnum`. Subsequent reads from it will return its default value. + mutating func clearNestedEnum() {self._nestedEnum = nil} + + var redactedString: String { + get {_redactedString ?? String()} + set {_redactedString = newValue} + } + /// Returns true if `redactedString` has been explicitly set. + var hasRedactedString: Bool {self._redactedString != nil} + /// Clears the value of `redactedString`. Subsequent reads from it will return its default value. + mutating func clearRedactedString() {self._redactedString = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _nestedEnum: Proto2Unittest_TestMessageEnum? = nil + fileprivate var _redactedString: String? = nil +} + +struct Proto2Unittest_TestRedactedMessage: Sendable { + // 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. + + /// NOTE: This field was marked as deprecated in the .proto file. + var textField: String { + get {_textField ?? String()} + set {_textField = newValue} + } + /// Returns true if `textField` has been explicitly set. + var hasTextField: Bool {self._textField != nil} + /// Clears the value of `textField`. Subsequent reads from it will return its default value. + mutating func clearTextField() {self._textField = nil} + + var metaAnnotated: String { + get {_metaAnnotated ?? String()} + set {_metaAnnotated = newValue} + } + /// Returns true if `metaAnnotated` has been explicitly set. + var hasMetaAnnotated: Bool {self._metaAnnotated != nil} + /// Clears the value of `metaAnnotated`. Subsequent reads from it will return its default value. + mutating func clearMetaAnnotated() {self._metaAnnotated = nil} + + var repeatedMetaAnnotated: String { + get {_repeatedMetaAnnotated ?? String()} + set {_repeatedMetaAnnotated = newValue} + } + /// Returns true if `repeatedMetaAnnotated` has been explicitly set. + var hasRepeatedMetaAnnotated: Bool {self._repeatedMetaAnnotated != nil} + /// Clears the value of `repeatedMetaAnnotated`. Subsequent reads from it will return its default value. + mutating func clearRepeatedMetaAnnotated() {self._repeatedMetaAnnotated = nil} + + var unredactedRepeatedAnnotations: String { + get {_unredactedRepeatedAnnotations ?? String()} + set {_unredactedRepeatedAnnotations = newValue} + } + /// Returns true if `unredactedRepeatedAnnotations` has been explicitly set. + var hasUnredactedRepeatedAnnotations: Bool {self._unredactedRepeatedAnnotations != nil} + /// Clears the value of `unredactedRepeatedAnnotations`. Subsequent reads from it will return its default value. + mutating func clearUnredactedRepeatedAnnotations() {self._unredactedRepeatedAnnotations = nil} + + var unreportedNonMetaDebugRedactField: String { + get {_unreportedNonMetaDebugRedactField ?? String()} + set {_unreportedNonMetaDebugRedactField = newValue} + } + /// Returns true if `unreportedNonMetaDebugRedactField` has been explicitly set. + var hasUnreportedNonMetaDebugRedactField: Bool {self._unreportedNonMetaDebugRedactField != nil} + /// Clears the value of `unreportedNonMetaDebugRedactField`. Subsequent reads from it will return its default value. + mutating func clearUnreportedNonMetaDebugRedactField() {self._unreportedNonMetaDebugRedactField = nil} + + var anyField: SwiftProtobuf.Google_Protobuf_Any { + get {_anyField ?? SwiftProtobuf.Google_Protobuf_Any()} + set {_anyField = newValue} + } + /// Returns true if `anyField` has been explicitly set. + var hasAnyField: Bool {self._anyField != nil} + /// Clears the value of `anyField`. Subsequent reads from it will return its default value. + mutating func clearAnyField() {self._anyField = nil} + + var redactableFalse: String { + get {_redactableFalse ?? String()} + set {_redactableFalse = newValue} + } + /// Returns true if `redactableFalse` has been explicitly set. + var hasRedactableFalse: Bool {self._redactableFalse != nil} + /// Clears the value of `redactableFalse`. Subsequent reads from it will return its default value. + mutating func clearRedactableFalse() {self._redactableFalse = nil} + + var testDirectMessageEnum: String { + get {_testDirectMessageEnum ?? String()} + set {_testDirectMessageEnum = newValue} + } + /// Returns true if `testDirectMessageEnum` has been explicitly set. + var hasTestDirectMessageEnum: Bool {self._testDirectMessageEnum != nil} + /// Clears the value of `testDirectMessageEnum`. Subsequent reads from it will return its default value. + mutating func clearTestDirectMessageEnum() {self._testDirectMessageEnum = nil} + + var testNestedMessageEnum: String { + get {_testNestedMessageEnum ?? String()} + set {_testNestedMessageEnum = newValue} + } + /// Returns true if `testNestedMessageEnum` has been explicitly set. + var hasTestNestedMessageEnum: Bool {self._testNestedMessageEnum != nil} + /// Clears the value of `testNestedMessageEnum`. Subsequent reads from it will return its default value. + mutating func clearTestNestedMessageEnum() {self._testNestedMessageEnum = nil} + + var testRedactedMessageEnum: String { + get {_testRedactedMessageEnum ?? String()} + set {_testRedactedMessageEnum = newValue} + } + /// Returns true if `testRedactedMessageEnum` has been explicitly set. + var hasTestRedactedMessageEnum: Bool {self._testRedactedMessageEnum != nil} + /// Clears the value of `testRedactedMessageEnum`. Subsequent reads from it will return its default value. + mutating func clearTestRedactedMessageEnum() {self._testRedactedMessageEnum = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _textField: String? = nil + fileprivate var _metaAnnotated: String? = nil + fileprivate var _repeatedMetaAnnotated: String? = nil + fileprivate var _unredactedRepeatedAnnotations: String? = nil + fileprivate var _unreportedNonMetaDebugRedactField: String? = nil + fileprivate var _anyField: SwiftProtobuf.Google_Protobuf_Any? = nil + fileprivate var _redactableFalse: String? = nil + fileprivate var _testDirectMessageEnum: String? = nil + fileprivate var _testNestedMessageEnum: String? = nil + fileprivate var _testRedactedMessageEnum: String? = nil +} + +// MARK: - Extension support defined in unittest_redaction.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 Proto2Unittest_metaAnnotatedEnum: Proto2Unittest_MetaAnnotatedEnum { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_meta_annotated_enum) ?? .testNull} + set {setExtensionValue(ext: Proto2Unittest_Extensions_meta_annotated_enum, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_meta_annotated_enum` + /// has been explicitly set. + var hasProto2Unittest_metaAnnotatedEnum: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_meta_annotated_enum) + } + /// Clears the value of extension `Proto2Unittest_Extensions_meta_annotated_enum`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_metaAnnotatedEnum() { + clearExtensionValue(ext: Proto2Unittest_Extensions_meta_annotated_enum) + } + + var Proto2Unittest_repeatedMetaAnnotatedEnum: [Proto2Unittest_MetaAnnotatedEnum] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_meta_annotated_enum) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_meta_annotated_enum, value: newValue)} + } + + var Proto2Unittest_testNestedMessageEnum: Proto2Unittest_TestNestedMessageEnum { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_test_nested_message_enum) ?? Proto2Unittest_TestNestedMessageEnum()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_test_nested_message_enum, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_test_nested_message_enum` + /// has been explicitly set. + var hasProto2Unittest_testNestedMessageEnum: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_test_nested_message_enum) + } + /// Clears the value of extension `Proto2Unittest_Extensions_test_nested_message_enum`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_testNestedMessageEnum() { + clearExtensionValue(ext: Proto2Unittest_Extensions_test_nested_message_enum) + } + +} + +// MARK: - File's ExtensionMap: Proto2Unittest_UnittestRedaction_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 Proto2Unittest_UnittestRedaction_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Proto2Unittest_Extensions_meta_annotated_enum, + Proto2Unittest_Extensions_repeated_meta_annotated_enum, + Proto2Unittest_Extensions_test_nested_message_enum +] + +// 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 Proto2Unittest_Extensions_meta_annotated_enum = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FieldOptions>( + _protobuf_fieldNumber: 535801413, + fieldName: "proto2_unittest.meta_annotated_enum" +) + +let Proto2Unittest_Extensions_repeated_meta_annotated_enum = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FieldOptions>( + _protobuf_fieldNumber: 535801414, + fieldName: "proto2_unittest.repeated_meta_annotated_enum" +) + +let Proto2Unittest_Extensions_test_nested_message_enum = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FieldOptions>( + _protobuf_fieldNumber: 535801415, + fieldName: "proto2_unittest.test_nested_message_enum" +) + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest" + +extension Proto2Unittest_MetaAnnotatedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0TEST_NULL\0\u{1}TEST_REDACTABLE\0\u{1}TEST_NO_REDACT\0\u{1}TEST_NO_REDACT_AGAIN\0\u{1}TEST_REDACTABLE_FALSE\0") +} + +extension Proto2Unittest_TestRedactedNestMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRedactedNestMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}foo\0") + + 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._foo) }() + 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 + try { if let v = self._foo { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestRedactedNestMessage, rhs: Proto2Unittest_TestRedactedNestMessage) -> Bool { + if lhs._foo != rhs._foo {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestRepeatedRedactedNestMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRepeatedRedactedNestMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bar\0") + + 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._bar) }() + 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 + try { if let v = self._bar { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestRepeatedRedactedNestMessage, rhs: Proto2Unittest_TestRepeatedRedactedNestMessage) -> Bool { + if lhs._bar != rhs._bar {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestMessageEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageEnum" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}redactable_enum\0") + + 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.decodeRepeatedEnumField(value: &self.redactableEnum) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.redactableEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: self.redactableEnum, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestMessageEnum, rhs: Proto2Unittest_TestMessageEnum) -> Bool { + if lhs.redactableEnum != rhs.redactableEnum {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestNestedMessageEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedMessageEnum" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}direct_enum\0\u{3}nested_enum\0\u{3}redacted_string\0") + + 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.decodeRepeatedEnumField(value: &self.directEnum) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._nestedEnum) }() + case 3: try { try decoder.decodeSingularStringField(value: &self._redactedString) }() + 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 + if !self.directEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: self.directEnum, fieldNumber: 1) + } + try { if let v = self._nestedEnum { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = self._redactedString { + try visitor.visitSingularStringField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestNestedMessageEnum, rhs: Proto2Unittest_TestNestedMessageEnum) -> Bool { + if lhs.directEnum != rhs.directEnum {return false} + if lhs._nestedEnum != rhs._nestedEnum {return false} + if lhs._redactedString != rhs._redactedString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestRedactedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRedactedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}text_field\0\u{4}\u{7}meta_annotated\0\u{3}repeated_meta_annotated\0\u{3}unredacted_repeated_annotations\0\u{4}\u{7}unreported_non_meta_debug_redact_field\0\u{3}any_field\0\u{3}redactable_false\0\u{4}\u{3}test_direct_message_enum\0\u{3}test_nested_message_enum\0\u{3}test_redacted_message_enum\0") + + 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._textField) }() + case 8: try { try decoder.decodeSingularStringField(value: &self._metaAnnotated) }() + case 9: try { try decoder.decodeSingularStringField(value: &self._repeatedMetaAnnotated) }() + case 10: try { try decoder.decodeSingularStringField(value: &self._unredactedRepeatedAnnotations) }() + case 17: try { try decoder.decodeSingularStringField(value: &self._unreportedNonMetaDebugRedactField) }() + case 18: try { try decoder.decodeSingularMessageField(value: &self._anyField) }() + case 19: try { try decoder.decodeSingularStringField(value: &self._redactableFalse) }() + case 22: try { try decoder.decodeSingularStringField(value: &self._testDirectMessageEnum) }() + case 23: try { try decoder.decodeSingularStringField(value: &self._testNestedMessageEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &self._testRedactedMessageEnum) }() + 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 + try { if let v = self._textField { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = self._metaAnnotated { + try visitor.visitSingularStringField(value: v, fieldNumber: 8) + } }() + try { if let v = self._repeatedMetaAnnotated { + try visitor.visitSingularStringField(value: v, fieldNumber: 9) + } }() + try { if let v = self._unredactedRepeatedAnnotations { + try visitor.visitSingularStringField(value: v, fieldNumber: 10) + } }() + try { if let v = self._unreportedNonMetaDebugRedactField { + try visitor.visitSingularStringField(value: v, fieldNumber: 17) + } }() + try { if let v = self._anyField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = self._redactableFalse { + try visitor.visitSingularStringField(value: v, fieldNumber: 19) + } }() + try { if let v = self._testDirectMessageEnum { + try visitor.visitSingularStringField(value: v, fieldNumber: 22) + } }() + try { if let v = self._testNestedMessageEnum { + try visitor.visitSingularStringField(value: v, fieldNumber: 23) + } }() + try { if let v = self._testRedactedMessageEnum { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestRedactedMessage, rhs: Proto2Unittest_TestRedactedMessage) -> Bool { + if lhs._textField != rhs._textField {return false} + if lhs._metaAnnotated != rhs._metaAnnotated {return false} + if lhs._repeatedMetaAnnotated != rhs._repeatedMetaAnnotated {return false} + if lhs._unredactedRepeatedAnnotations != rhs._unredactedRepeatedAnnotations {return false} + if lhs._unreportedNonMetaDebugRedactField != rhs._unreportedNonMetaDebugRedactField {return false} + if lhs._anyField != rhs._anyField {return false} + if lhs._redactableFalse != rhs._redactableFalse {return false} + if lhs._testDirectMessageEnum != rhs._testDirectMessageEnum {return false} + if lhs._testNestedMessageEnum != rhs._testNestedMessageEnum {return false} + if lhs._testRedactedMessageEnum != rhs._testRedactedMessageEnum {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/unittest_retention.pb.swift b/Reference/upstream/google/protobuf/unittest_retention.pb.swift new file mode 100644 index 000000000..1fcbd7dc0 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_retention.pb.swift @@ -0,0 +1,668 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_retention.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +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 Proto2Unittest_TopLevelEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case topLevelUnknown = 0 + + init() { + self = .topLevelUnknown + } + +} + +/// Retention attributes set on fields nested within a message +struct Proto2Unittest_OptionsMessage: Sendable { + // 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 plainField: Int32 { + get {_plainField ?? 0} + set {_plainField = newValue} + } + /// Returns true if `plainField` has been explicitly set. + var hasPlainField: Bool {self._plainField != nil} + /// Clears the value of `plainField`. Subsequent reads from it will return its default value. + mutating func clearPlainField() {self._plainField = nil} + + var runtimeRetentionField: Int32 { + get {_runtimeRetentionField ?? 0} + set {_runtimeRetentionField = newValue} + } + /// Returns true if `runtimeRetentionField` has been explicitly set. + var hasRuntimeRetentionField: Bool {self._runtimeRetentionField != nil} + /// Clears the value of `runtimeRetentionField`. Subsequent reads from it will return its default value. + mutating func clearRuntimeRetentionField() {self._runtimeRetentionField = nil} + + var sourceRetentionField: Int32 { + get {_sourceRetentionField ?? 0} + set {_sourceRetentionField = newValue} + } + /// Returns true if `sourceRetentionField` has been explicitly set. + var hasSourceRetentionField: Bool {self._sourceRetentionField != nil} + /// Clears the value of `sourceRetentionField`. Subsequent reads from it will return its default value. + mutating func clearSourceRetentionField() {self._sourceRetentionField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _plainField: Int32? = nil + fileprivate var _runtimeRetentionField: Int32? = nil + fileprivate var _sourceRetentionField: Int32? = nil +} + +struct Proto2Unittest_Extendee: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +struct Proto2Unittest_TopLevelMessage: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 f: Float { + get {_f ?? 0} + set {_f = newValue} + } + /// Returns true if `f` has been explicitly set. + var hasF: Bool {self._f != nil} + /// Clears the value of `f`. Subsequent reads from it will return its default value. + mutating func clearF() {self._f = nil} + + var o: Proto2Unittest_TopLevelMessage.OneOf_O? = nil + + var i: Int64 { + get { + if case .i(let v)? = o {return v} + return 0 + } + set {o = .i(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_O: Equatable, Sendable { + case i(Int64) + + } + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case nestedUnknown = 0 + + init() { + self = .nestedUnknown + } + + } + + struct NestedMessage: Sendable { + // 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() {} + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _f: Float? = nil +} + +// MARK: - Extension support defined in unittest_retention.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 Proto2Unittest_Extendee { + + var Proto2Unittest_i: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_i) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_i, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_i` + /// has been explicitly set. + var hasProto2Unittest_i: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_i) + } + /// Clears the value of extension `Proto2Unittest_Extensions_i`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_i() { + clearExtensionValue(ext: Proto2Unittest_Extensions_i) + } + + var Proto2Unittest_TopLevelMessage_s: String { + get {return getExtensionValue(ext: Proto2Unittest_TopLevelMessage.Extensions.s) ?? String()} + set {setExtensionValue(ext: Proto2Unittest_TopLevelMessage.Extensions.s, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_TopLevelMessage.Extensions.s` + /// has been explicitly set. + var hasProto2Unittest_TopLevelMessage_s: Bool { + return hasExtensionValue(ext: Proto2Unittest_TopLevelMessage.Extensions.s) + } + /// Clears the value of extension `Proto2Unittest_TopLevelMessage.Extensions.s`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_TopLevelMessage_s() { + clearExtensionValue(ext: Proto2Unittest_TopLevelMessage.Extensions.s) + } +} + +extension SwiftProtobuf.Google_Protobuf_EnumOptions { + + var Proto2Unittest_enumOption: Proto2Unittest_OptionsMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_enum_option) ?? Proto2Unittest_OptionsMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_enum_option, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_enum_option` + /// has been explicitly set. + var hasProto2Unittest_enumOption: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_enum_option) + } + /// Clears the value of extension `Proto2Unittest_Extensions_enum_option`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_enumOption() { + clearExtensionValue(ext: Proto2Unittest_Extensions_enum_option) + } +} + +extension SwiftProtobuf.Google_Protobuf_EnumValueOptions { + + var Proto2Unittest_enumEntryOption: Proto2Unittest_OptionsMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_enum_entry_option) ?? Proto2Unittest_OptionsMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_enum_entry_option, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_enum_entry_option` + /// has been explicitly set. + var hasProto2Unittest_enumEntryOption: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_enum_entry_option) + } + /// Clears the value of extension `Proto2Unittest_Extensions_enum_entry_option`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_enumEntryOption() { + clearExtensionValue(ext: Proto2Unittest_Extensions_enum_entry_option) + } +} + +extension SwiftProtobuf.Google_Protobuf_ExtensionRangeOptions { + + var Proto2Unittest_extensionRangeOption: Proto2Unittest_OptionsMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_extension_range_option) ?? Proto2Unittest_OptionsMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_extension_range_option, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_extension_range_option` + /// has been explicitly set. + var hasProto2Unittest_extensionRangeOption: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_extension_range_option) + } + /// Clears the value of extension `Proto2Unittest_Extensions_extension_range_option`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_extensionRangeOption() { + clearExtensionValue(ext: Proto2Unittest_Extensions_extension_range_option) + } +} + +extension SwiftProtobuf.Google_Protobuf_FieldOptions { + + var Proto2Unittest_fieldOption: Proto2Unittest_OptionsMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_field_option) ?? Proto2Unittest_OptionsMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_field_option, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_field_option` + /// has been explicitly set. + var hasProto2Unittest_fieldOption: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_field_option) + } + /// Clears the value of extension `Proto2Unittest_Extensions_field_option`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_fieldOption() { + clearExtensionValue(ext: Proto2Unittest_Extensions_field_option) + } +} + +extension SwiftProtobuf.Google_Protobuf_FileOptions { + + var Proto2Unittest_plainOption: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_plain_option) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_plain_option, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_plain_option` + /// has been explicitly set. + var hasProto2Unittest_plainOption: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_plain_option) + } + /// Clears the value of extension `Proto2Unittest_Extensions_plain_option`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_plainOption() { + clearExtensionValue(ext: Proto2Unittest_Extensions_plain_option) + } + + var Proto2Unittest_runtimeRetentionOption: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_runtime_retention_option) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_runtime_retention_option, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_runtime_retention_option` + /// has been explicitly set. + var hasProto2Unittest_runtimeRetentionOption: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_runtime_retention_option) + } + /// Clears the value of extension `Proto2Unittest_Extensions_runtime_retention_option`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_runtimeRetentionOption() { + clearExtensionValue(ext: Proto2Unittest_Extensions_runtime_retention_option) + } + + var Proto2Unittest_sourceRetentionOption: Int32 { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_source_retention_option) ?? 0} + set {setExtensionValue(ext: Proto2Unittest_Extensions_source_retention_option, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_source_retention_option` + /// has been explicitly set. + var hasProto2Unittest_sourceRetentionOption: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_source_retention_option) + } + /// Clears the value of extension `Proto2Unittest_Extensions_source_retention_option`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_sourceRetentionOption() { + clearExtensionValue(ext: Proto2Unittest_Extensions_source_retention_option) + } + + var Proto2Unittest_fileOption: Proto2Unittest_OptionsMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_file_option) ?? Proto2Unittest_OptionsMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_file_option, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_file_option` + /// has been explicitly set. + var hasProto2Unittest_fileOption: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_file_option) + } + /// Clears the value of extension `Proto2Unittest_Extensions_file_option`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_fileOption() { + clearExtensionValue(ext: Proto2Unittest_Extensions_file_option) + } + + var Proto2Unittest_repeatedOptions: [Proto2Unittest_OptionsMessage] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_options) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_options, value: newValue)} + } +} + +extension SwiftProtobuf.Google_Protobuf_MessageOptions { + + var Proto2Unittest_messageOption: Proto2Unittest_OptionsMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_message_option) ?? Proto2Unittest_OptionsMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_message_option, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_message_option` + /// has been explicitly set. + var hasProto2Unittest_messageOption: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_message_option) + } + /// Clears the value of extension `Proto2Unittest_Extensions_message_option`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_messageOption() { + clearExtensionValue(ext: Proto2Unittest_Extensions_message_option) + } +} + +extension SwiftProtobuf.Google_Protobuf_MethodOptions { + + var Proto2Unittest_methodOption: Proto2Unittest_OptionsMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_method_option) ?? Proto2Unittest_OptionsMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_method_option, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_method_option` + /// has been explicitly set. + var hasProto2Unittest_methodOption: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_method_option) + } + /// Clears the value of extension `Proto2Unittest_Extensions_method_option`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_methodOption() { + clearExtensionValue(ext: Proto2Unittest_Extensions_method_option) + } +} + +extension SwiftProtobuf.Google_Protobuf_OneofOptions { + + var Proto2Unittest_oneofOption: Proto2Unittest_OptionsMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_oneof_option) ?? Proto2Unittest_OptionsMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_oneof_option, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_oneof_option` + /// has been explicitly set. + var hasProto2Unittest_oneofOption: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_oneof_option) + } + /// Clears the value of extension `Proto2Unittest_Extensions_oneof_option`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_oneofOption() { + clearExtensionValue(ext: Proto2Unittest_Extensions_oneof_option) + } +} + +extension SwiftProtobuf.Google_Protobuf_ServiceOptions { + + var Proto2Unittest_serviceOption: Proto2Unittest_OptionsMessage { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_service_option) ?? Proto2Unittest_OptionsMessage()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_service_option, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_service_option` + /// has been explicitly set. + var hasProto2Unittest_serviceOption: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_service_option) + } + /// Clears the value of extension `Proto2Unittest_Extensions_service_option`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_serviceOption() { + clearExtensionValue(ext: Proto2Unittest_Extensions_service_option) + } + +} + +// MARK: - File's ExtensionMap: Proto2Unittest_UnittestRetention_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 Proto2Unittest_UnittestRetention_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Proto2Unittest_Extensions_plain_option, + Proto2Unittest_Extensions_runtime_retention_option, + Proto2Unittest_Extensions_source_retention_option, + Proto2Unittest_Extensions_file_option, + Proto2Unittest_Extensions_repeated_options, + Proto2Unittest_Extensions_extension_range_option, + Proto2Unittest_Extensions_message_option, + Proto2Unittest_Extensions_field_option, + Proto2Unittest_Extensions_oneof_option, + Proto2Unittest_Extensions_enum_option, + Proto2Unittest_Extensions_enum_entry_option, + Proto2Unittest_Extensions_service_option, + Proto2Unittest_Extensions_method_option, + Proto2Unittest_Extensions_i, + Proto2Unittest_TopLevelMessage.Extensions.s +] + +// 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 Proto2Unittest_Extensions_plain_option = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( + _protobuf_fieldNumber: 505092806, + fieldName: "proto2_unittest.plain_option" +) + +let Proto2Unittest_Extensions_runtime_retention_option = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( + _protobuf_fieldNumber: 505039132, + fieldName: "proto2_unittest.runtime_retention_option" +) + +let Proto2Unittest_Extensions_source_retention_option = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( + _protobuf_fieldNumber: 504878676, + fieldName: "proto2_unittest.source_retention_option" +) + +let Proto2Unittest_Extensions_file_option = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( + _protobuf_fieldNumber: 504871168, + fieldName: "proto2_unittest.file_option" +) + +let Proto2Unittest_Extensions_repeated_options = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( + _protobuf_fieldNumber: 504823570, + fieldName: "proto2_unittest.repeated_options" +) + +let Proto2Unittest_Extensions_extension_range_option = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_ExtensionRangeOptions>( + _protobuf_fieldNumber: 504822148, + fieldName: "proto2_unittest.extension_range_option" +) + +let Proto2Unittest_Extensions_message_option = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( + _protobuf_fieldNumber: 504820819, + fieldName: "proto2_unittest.message_option" +) + +let Proto2Unittest_Extensions_field_option = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FieldOptions>( + _protobuf_fieldNumber: 504589219, + fieldName: "proto2_unittest.field_option" +) + +let Proto2Unittest_Extensions_oneof_option = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_OneofOptions>( + _protobuf_fieldNumber: 504479153, + fieldName: "proto2_unittest.oneof_option" +) + +let Proto2Unittest_Extensions_enum_option = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_EnumOptions>( + _protobuf_fieldNumber: 504451567, + fieldName: "proto2_unittest.enum_option" +) + +let Proto2Unittest_Extensions_enum_entry_option = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_EnumValueOptions>( + _protobuf_fieldNumber: 504450522, + fieldName: "proto2_unittest.enum_entry_option" +) + +let Proto2Unittest_Extensions_service_option = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_ServiceOptions>( + _protobuf_fieldNumber: 504387709, + fieldName: "proto2_unittest.service_option" +) + +let Proto2Unittest_Extensions_method_option = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MethodOptions>( + _protobuf_fieldNumber: 504349420, + fieldName: "proto2_unittest.method_option" +) + +let Proto2Unittest_Extensions_i = SwiftProtobuf.MessageExtension, Proto2Unittest_Extendee>( + _protobuf_fieldNumber: 1, + fieldName: "proto2_unittest.i" +) + +extension Proto2Unittest_TopLevelMessage { + enum Extensions { + static let s = SwiftProtobuf.MessageExtension, Proto2Unittest_Extendee>( + _protobuf_fieldNumber: 2, + fieldName: "proto2_unittest.TopLevelMessage.s" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest" + +extension Proto2Unittest_TopLevelEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0TOP_LEVEL_UNKNOWN\0") +} + +extension Proto2Unittest_OptionsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OptionsMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}plain_field\0\u{3}runtime_retention_field\0\u{3}source_retention_field\0") + + 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._plainField) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._runtimeRetentionField) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._sourceRetentionField) }() + 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 + try { if let v = self._plainField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._runtimeRetentionField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._sourceRetentionField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_OptionsMessage, rhs: Proto2Unittest_OptionsMessage) -> Bool { + if lhs._plainField != rhs._plainField {return false} + if lhs._runtimeRetentionField != rhs._runtimeRetentionField {return false} + if lhs._sourceRetentionField != rhs._sourceRetentionField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_Extendee: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Extendee" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1 <= fieldNumber && fieldNumber < 3) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_Extendee.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 3) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_Extendee, rhs: Proto2Unittest_Extendee) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TopLevelMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TopLevelMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}f\0\u{1}i\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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.decodeSingularFloatField(value: &self._f) }() + case 2: try { + var v: Int64? + try decoder.decodeSingularInt64Field(value: &v) + if let v = v { + if self.o != nil {try decoder.handleConflictingOneOf()} + self.o = .i(v) + } + }() + case 10..<101: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TopLevelMessage.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._f { + try visitor.visitSingularFloatField(value: v, fieldNumber: 1) + } }() + try { if case .i(let v)? = self.o { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 10, end: 101) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TopLevelMessage, rhs: Proto2Unittest_TopLevelMessage) -> Bool { + if lhs._f != rhs._f {return false} + if lhs.o != rhs.o {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Proto2Unittest_TopLevelMessage.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NESTED_UNKNOWN\0") +} + +extension Proto2Unittest_TopLevelMessage.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = Proto2Unittest_TopLevelMessage.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TopLevelMessage.NestedMessage, rhs: Proto2Unittest_TopLevelMessage.NestedMessage) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/unittest_string_type.pb.swift b/Reference/upstream/google/protobuf/unittest_string_type.pb.swift new file mode 100644 index 000000000..3f8704b80 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_string_type.pb.swift @@ -0,0 +1,88 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_string_type.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +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 Proto2Unittest_EntryProto: Sendable { + // 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 value: Data { + get {_value ?? Data()} + set {_value = newValue} + } + /// Returns true if `value` has been explicitly set. + var hasValue: Bool {self._value != nil} + /// Clears the value of `value`. Subsequent reads from it will return its default value. + mutating func clearValue() {self._value = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _value: Data? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest" + +extension Proto2Unittest_EntryProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EntryProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{3}value\0") + + 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 3: try { try decoder.decodeSingularBytesField(value: &self._value) }() + 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 + try { if let v = self._value { + try visitor.visitSingularBytesField(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_EntryProto, rhs: Proto2Unittest_EntryProto) -> Bool { + if lhs._value != rhs._value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/unittest_string_view.pb.swift b/Reference/upstream/google/protobuf/unittest_string_view.pb.swift new file mode 100644 index 000000000..d7526ee28 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_string_view.pb.swift @@ -0,0 +1,249 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_string_view.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 +} + +/// NEXT_TAG = 6; +struct Proto2Unittest_TestStringView: Sendable { + // 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 singularString: String { + get {_singularString ?? String()} + set {_singularString = newValue} + } + /// Returns true if `singularString` has been explicitly set. + var hasSingularString: Bool {self._singularString != nil} + /// Clears the value of `singularString`. Subsequent reads from it will return its default value. + mutating func clearSingularString() {self._singularString = nil} + + var singularBytes: Data { + get {_singularBytes ?? Data()} + set {_singularBytes = newValue} + } + /// Returns true if `singularBytes` has been explicitly set. + var hasSingularBytes: Bool {self._singularBytes != nil} + /// Clears the value of `singularBytes`. Subsequent reads from it will return its default value. + mutating func clearSingularBytes() {self._singularBytes = nil} + + var implicitPresence: String = String() + + var repeatedString: [String] = [] + + var repeatedBytes: [Data] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _singularString: String? = nil + fileprivate var _singularBytes: Data? = nil +} + +struct Proto2Unittest_TestStringViewExtension: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +// MARK: - Extension support defined in unittest_string_view.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 Proto2Unittest_TestStringViewExtension { + + var Proto2Unittest_singularStringViewExtension: String { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_singular_string_view_extension) ?? String()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_singular_string_view_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_singular_string_view_extension` + /// has been explicitly set. + var hasProto2Unittest_singularStringViewExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_singular_string_view_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_singular_string_view_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_singularStringViewExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_singular_string_view_extension) + } + + var Proto2Unittest_singularBytesViewExtension: Data { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_singular_bytes_view_extension) ?? Data()} + set {setExtensionValue(ext: Proto2Unittest_Extensions_singular_bytes_view_extension, value: newValue)} + } + /// Returns true if extension `Proto2Unittest_Extensions_singular_bytes_view_extension` + /// has been explicitly set. + var hasProto2Unittest_singularBytesViewExtension: Bool { + return hasExtensionValue(ext: Proto2Unittest_Extensions_singular_bytes_view_extension) + } + /// Clears the value of extension `Proto2Unittest_Extensions_singular_bytes_view_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProto2Unittest_singularBytesViewExtension() { + clearExtensionValue(ext: Proto2Unittest_Extensions_singular_bytes_view_extension) + } + + var Proto2Unittest_repeatedStringViewExtension: [String] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_string_view_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_string_view_extension, value: newValue)} + } + + var Proto2Unittest_repeatedBytesViewExtension: [Data] { + get {return getExtensionValue(ext: Proto2Unittest_Extensions_repeated_bytes_view_extension) ?? []} + set {setExtensionValue(ext: Proto2Unittest_Extensions_repeated_bytes_view_extension, value: newValue)} + } + +} + +// MARK: - File's ExtensionMap: Proto2Unittest_UnittestStringView_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 Proto2Unittest_UnittestStringView_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + Proto2Unittest_Extensions_singular_string_view_extension, + Proto2Unittest_Extensions_singular_bytes_view_extension, + Proto2Unittest_Extensions_repeated_string_view_extension, + Proto2Unittest_Extensions_repeated_bytes_view_extension +] + +// 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 Proto2Unittest_Extensions_singular_string_view_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestStringViewExtension>( + _protobuf_fieldNumber: 1, + fieldName: "proto2_unittest.singular_string_view_extension" +) + +let Proto2Unittest_Extensions_singular_bytes_view_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestStringViewExtension>( + _protobuf_fieldNumber: 2, + fieldName: "proto2_unittest.singular_bytes_view_extension" +) + +let Proto2Unittest_Extensions_repeated_string_view_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestStringViewExtension>( + _protobuf_fieldNumber: 3, + fieldName: "proto2_unittest.repeated_string_view_extension" +) + +let Proto2Unittest_Extensions_repeated_bytes_view_extension = SwiftProtobuf.MessageExtension, Proto2Unittest_TestStringViewExtension>( + _protobuf_fieldNumber: 4, + fieldName: "proto2_unittest.repeated_bytes_view_extension" +) + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest" + +extension Proto2Unittest_TestStringView: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestStringView" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}singular_string\0\u{3}singular_bytes\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{3}implicit_presence\0") + + 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._singularString) }() + case 2: try { try decoder.decodeSingularBytesField(value: &self._singularBytes) }() + case 3: try { try decoder.decodeRepeatedStringField(value: &self.repeatedString) }() + case 4: try { try decoder.decodeRepeatedBytesField(value: &self.repeatedBytes) }() + case 5: try { try decoder.decodeSingularStringField(value: &self.implicitPresence) }() + 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 + try { if let v = self._singularString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = self._singularBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 2) + } }() + if !self.repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: self.repeatedString, fieldNumber: 3) + } + if !self.repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: self.repeatedBytes, fieldNumber: 4) + } + if !self.implicitPresence.isEmpty { + try visitor.visitSingularStringField(value: self.implicitPresence, fieldNumber: 5) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestStringView, rhs: Proto2Unittest_TestStringView) -> Bool { + if lhs._singularString != rhs._singularString {return false} + if lhs._singularBytes != rhs._singularBytes {return false} + if lhs.implicitPresence != rhs.implicitPresence {return false} + if lhs.repeatedString != rhs.repeatedString {return false} + if lhs.repeatedBytes != rhs.repeatedBytes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_TestStringViewExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestStringViewExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Proto2Unittest_TestStringViewExtension.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestStringViewExtension, rhs: Proto2Unittest_TestStringViewExtension) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/unittest_well_known_types.pb.swift b/Reference/upstream/google/protobuf/unittest_well_known_types.pb.swift new file mode 100644 index 000000000..46a59a116 --- /dev/null +++ b/Reference/upstream/google/protobuf/unittest_well_known_types.pb.swift @@ -0,0 +1,1511 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/unittest_well_known_types.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +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 +} + +/// Test that we can include all well-known types. +/// Each wrapper type is included separately, as languages +/// map handle different wrappers in different ways. +struct Proto2Unittest_TestWellKnownTypes: @unchecked Sendable { + // 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 anyField: SwiftProtobuf.Google_Protobuf_Any { + get {_storage._anyField ?? SwiftProtobuf.Google_Protobuf_Any()} + set {_uniqueStorage()._anyField = newValue} + } + /// Returns true if `anyField` has been explicitly set. + var hasAnyField: Bool {_storage._anyField != nil} + /// Clears the value of `anyField`. Subsequent reads from it will return its default value. + mutating func clearAnyField() {_uniqueStorage()._anyField = nil} + + var apiField: SwiftProtobuf.Google_Protobuf_Api { + get {_storage._apiField ?? SwiftProtobuf.Google_Protobuf_Api()} + set {_uniqueStorage()._apiField = newValue} + } + /// Returns true if `apiField` has been explicitly set. + var hasApiField: Bool {_storage._apiField != nil} + /// Clears the value of `apiField`. Subsequent reads from it will return its default value. + mutating func clearApiField() {_uniqueStorage()._apiField = nil} + + var durationField: SwiftProtobuf.Google_Protobuf_Duration { + get {_storage._durationField ?? SwiftProtobuf.Google_Protobuf_Duration()} + set {_uniqueStorage()._durationField = newValue} + } + /// Returns true if `durationField` has been explicitly set. + var hasDurationField: Bool {_storage._durationField != nil} + /// Clears the value of `durationField`. Subsequent reads from it will return its default value. + mutating func clearDurationField() {_uniqueStorage()._durationField = nil} + + var emptyField: SwiftProtobuf.Google_Protobuf_Empty { + get {_storage._emptyField ?? SwiftProtobuf.Google_Protobuf_Empty()} + set {_uniqueStorage()._emptyField = newValue} + } + /// Returns true if `emptyField` has been explicitly set. + var hasEmptyField: Bool {_storage._emptyField != nil} + /// Clears the value of `emptyField`. Subsequent reads from it will return its default value. + mutating func clearEmptyField() {_uniqueStorage()._emptyField = nil} + + var fieldMaskField: SwiftProtobuf.Google_Protobuf_FieldMask { + get {_storage._fieldMaskField ?? SwiftProtobuf.Google_Protobuf_FieldMask()} + set {_uniqueStorage()._fieldMaskField = newValue} + } + /// Returns true if `fieldMaskField` has been explicitly set. + var hasFieldMaskField: Bool {_storage._fieldMaskField != nil} + /// Clears the value of `fieldMaskField`. Subsequent reads from it will return its default value. + mutating func clearFieldMaskField() {_uniqueStorage()._fieldMaskField = nil} + + var sourceContextField: SwiftProtobuf.Google_Protobuf_SourceContext { + get {_storage._sourceContextField ?? SwiftProtobuf.Google_Protobuf_SourceContext()} + set {_uniqueStorage()._sourceContextField = newValue} + } + /// Returns true if `sourceContextField` has been explicitly set. + var hasSourceContextField: Bool {_storage._sourceContextField != nil} + /// Clears the value of `sourceContextField`. Subsequent reads from it will return its default value. + mutating func clearSourceContextField() {_uniqueStorage()._sourceContextField = nil} + + var structField: SwiftProtobuf.Google_Protobuf_Struct { + get {_storage._structField ?? SwiftProtobuf.Google_Protobuf_Struct()} + set {_uniqueStorage()._structField = newValue} + } + /// Returns true if `structField` has been explicitly set. + var hasStructField: Bool {_storage._structField != nil} + /// Clears the value of `structField`. Subsequent reads from it will return its default value. + mutating func clearStructField() {_uniqueStorage()._structField = nil} + + var timestampField: SwiftProtobuf.Google_Protobuf_Timestamp { + get {_storage._timestampField ?? SwiftProtobuf.Google_Protobuf_Timestamp()} + set {_uniqueStorage()._timestampField = newValue} + } + /// Returns true if `timestampField` has been explicitly set. + var hasTimestampField: Bool {_storage._timestampField != nil} + /// Clears the value of `timestampField`. Subsequent reads from it will return its default value. + mutating func clearTimestampField() {_uniqueStorage()._timestampField = nil} + + var typeField: SwiftProtobuf.Google_Protobuf_Type { + get {_storage._typeField ?? SwiftProtobuf.Google_Protobuf_Type()} + set {_uniqueStorage()._typeField = newValue} + } + /// Returns true if `typeField` has been explicitly set. + var hasTypeField: Bool {_storage._typeField != nil} + /// Clears the value of `typeField`. Subsequent reads from it will return its default value. + mutating func clearTypeField() {_uniqueStorage()._typeField = nil} + + var doubleField: SwiftProtobuf.Google_Protobuf_DoubleValue { + get {_storage._doubleField ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} + set {_uniqueStorage()._doubleField = newValue} + } + /// Returns true if `doubleField` has been explicitly set. + var hasDoubleField: Bool {_storage._doubleField != nil} + /// Clears the value of `doubleField`. Subsequent reads from it will return its default value. + mutating func clearDoubleField() {_uniqueStorage()._doubleField = nil} + + var floatField: SwiftProtobuf.Google_Protobuf_FloatValue { + get {_storage._floatField ?? SwiftProtobuf.Google_Protobuf_FloatValue()} + set {_uniqueStorage()._floatField = newValue} + } + /// Returns true if `floatField` has been explicitly set. + var hasFloatField: Bool {_storage._floatField != nil} + /// Clears the value of `floatField`. Subsequent reads from it will return its default value. + mutating func clearFloatField() {_uniqueStorage()._floatField = nil} + + var int64Field: SwiftProtobuf.Google_Protobuf_Int64Value { + get {_storage._int64Field ?? SwiftProtobuf.Google_Protobuf_Int64Value()} + set {_uniqueStorage()._int64Field = newValue} + } + /// Returns true if `int64Field` has been explicitly set. + var hasInt64Field: Bool {_storage._int64Field != nil} + /// Clears the value of `int64Field`. Subsequent reads from it will return its default value. + mutating func clearInt64Field() {_uniqueStorage()._int64Field = nil} + + var uint64Field: SwiftProtobuf.Google_Protobuf_UInt64Value { + get {_storage._uint64Field ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} + set {_uniqueStorage()._uint64Field = newValue} + } + /// Returns true if `uint64Field` has been explicitly set. + var hasUint64Field: Bool {_storage._uint64Field != nil} + /// Clears the value of `uint64Field`. Subsequent reads from it will return its default value. + mutating func clearUint64Field() {_uniqueStorage()._uint64Field = nil} + + var int32Field: SwiftProtobuf.Google_Protobuf_Int32Value { + get {_storage._int32Field ?? SwiftProtobuf.Google_Protobuf_Int32Value()} + set {_uniqueStorage()._int32Field = newValue} + } + /// Returns true if `int32Field` has been explicitly set. + var hasInt32Field: Bool {_storage._int32Field != nil} + /// Clears the value of `int32Field`. Subsequent reads from it will return its default value. + mutating func clearInt32Field() {_uniqueStorage()._int32Field = nil} + + var uint32Field: SwiftProtobuf.Google_Protobuf_UInt32Value { + get {_storage._uint32Field ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} + set {_uniqueStorage()._uint32Field = newValue} + } + /// Returns true if `uint32Field` has been explicitly set. + var hasUint32Field: Bool {_storage._uint32Field != nil} + /// Clears the value of `uint32Field`. Subsequent reads from it will return its default value. + mutating func clearUint32Field() {_uniqueStorage()._uint32Field = nil} + + var boolField: SwiftProtobuf.Google_Protobuf_BoolValue { + get {_storage._boolField ?? SwiftProtobuf.Google_Protobuf_BoolValue()} + set {_uniqueStorage()._boolField = newValue} + } + /// Returns true if `boolField` has been explicitly set. + var hasBoolField: Bool {_storage._boolField != nil} + /// Clears the value of `boolField`. Subsequent reads from it will return its default value. + mutating func clearBoolField() {_uniqueStorage()._boolField = nil} + + var stringField: SwiftProtobuf.Google_Protobuf_StringValue { + get {_storage._stringField ?? SwiftProtobuf.Google_Protobuf_StringValue()} + set {_uniqueStorage()._stringField = newValue} + } + /// Returns true if `stringField` has been explicitly set. + var hasStringField: Bool {_storage._stringField != nil} + /// Clears the value of `stringField`. Subsequent reads from it will return its default value. + mutating func clearStringField() {_uniqueStorage()._stringField = nil} + + var bytesField: SwiftProtobuf.Google_Protobuf_BytesValue { + get {_storage._bytesField ?? SwiftProtobuf.Google_Protobuf_BytesValue()} + set {_uniqueStorage()._bytesField = newValue} + } + /// Returns true if `bytesField` has been explicitly set. + var hasBytesField: Bool {_storage._bytesField != nil} + /// Clears the value of `bytesField`. Subsequent reads from it will return its default value. + mutating func clearBytesField() {_uniqueStorage()._bytesField = nil} + + /// Part of struct, but useful to be able to test separately + var valueField: SwiftProtobuf.Google_Protobuf_Value { + get {_storage._valueField ?? SwiftProtobuf.Google_Protobuf_Value()} + set {_uniqueStorage()._valueField = newValue} + } + /// Returns true if `valueField` has been explicitly set. + var hasValueField: Bool {_storage._valueField != nil} + /// Clears the value of `valueField`. Subsequent reads from it will return its default value. + mutating func clearValueField() {_uniqueStorage()._valueField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// A repeated field for each well-known type. +struct Proto2Unittest_RepeatedWellKnownTypes: @unchecked Sendable { + // 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 anyField: [SwiftProtobuf.Google_Protobuf_Any] { + get {_storage._anyField} + set {_uniqueStorage()._anyField = newValue} + } + + var apiField: [SwiftProtobuf.Google_Protobuf_Api] { + get {_storage._apiField} + set {_uniqueStorage()._apiField = newValue} + } + + var durationField: [SwiftProtobuf.Google_Protobuf_Duration] { + get {_storage._durationField} + set {_uniqueStorage()._durationField = newValue} + } + + var emptyField: [SwiftProtobuf.Google_Protobuf_Empty] { + get {_storage._emptyField} + set {_uniqueStorage()._emptyField = newValue} + } + + var fieldMaskField: [SwiftProtobuf.Google_Protobuf_FieldMask] { + get {_storage._fieldMaskField} + set {_uniqueStorage()._fieldMaskField = newValue} + } + + var sourceContextField: [SwiftProtobuf.Google_Protobuf_SourceContext] { + get {_storage._sourceContextField} + set {_uniqueStorage()._sourceContextField = newValue} + } + + var structField: [SwiftProtobuf.Google_Protobuf_Struct] { + get {_storage._structField} + set {_uniqueStorage()._structField = newValue} + } + + var timestampField: [SwiftProtobuf.Google_Protobuf_Timestamp] { + get {_storage._timestampField} + set {_uniqueStorage()._timestampField = newValue} + } + + var typeField: [SwiftProtobuf.Google_Protobuf_Type] { + get {_storage._typeField} + set {_uniqueStorage()._typeField = newValue} + } + + /// These don't actually make a lot of sense, but they're not prohibited... + var doubleField: [SwiftProtobuf.Google_Protobuf_DoubleValue] { + get {_storage._doubleField} + set {_uniqueStorage()._doubleField = newValue} + } + + var floatField: [SwiftProtobuf.Google_Protobuf_FloatValue] { + get {_storage._floatField} + set {_uniqueStorage()._floatField = newValue} + } + + var int64Field: [SwiftProtobuf.Google_Protobuf_Int64Value] { + get {_storage._int64Field} + set {_uniqueStorage()._int64Field = newValue} + } + + var uint64Field: [SwiftProtobuf.Google_Protobuf_UInt64Value] { + get {_storage._uint64Field} + set {_uniqueStorage()._uint64Field = newValue} + } + + var int32Field: [SwiftProtobuf.Google_Protobuf_Int32Value] { + get {_storage._int32Field} + set {_uniqueStorage()._int32Field = newValue} + } + + var uint32Field: [SwiftProtobuf.Google_Protobuf_UInt32Value] { + get {_storage._uint32Field} + set {_uniqueStorage()._uint32Field = newValue} + } + + var boolField: [SwiftProtobuf.Google_Protobuf_BoolValue] { + get {_storage._boolField} + set {_uniqueStorage()._boolField = newValue} + } + + var stringField: [SwiftProtobuf.Google_Protobuf_StringValue] { + get {_storage._stringField} + set {_uniqueStorage()._stringField = newValue} + } + + var bytesField: [SwiftProtobuf.Google_Protobuf_BytesValue] { + get {_storage._bytesField} + set {_uniqueStorage()._bytesField = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct Proto2Unittest_OneofWellKnownTypes: Sendable { + // 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 oneofField: Proto2Unittest_OneofWellKnownTypes.OneOf_OneofField? = nil + + var anyField: SwiftProtobuf.Google_Protobuf_Any { + get { + if case .anyField(let v)? = oneofField {return v} + return SwiftProtobuf.Google_Protobuf_Any() + } + set {oneofField = .anyField(newValue)} + } + + var apiField: SwiftProtobuf.Google_Protobuf_Api { + get { + if case .apiField(let v)? = oneofField {return v} + return SwiftProtobuf.Google_Protobuf_Api() + } + set {oneofField = .apiField(newValue)} + } + + var durationField: SwiftProtobuf.Google_Protobuf_Duration { + get { + if case .durationField(let v)? = oneofField {return v} + return SwiftProtobuf.Google_Protobuf_Duration() + } + set {oneofField = .durationField(newValue)} + } + + var emptyField: SwiftProtobuf.Google_Protobuf_Empty { + get { + if case .emptyField(let v)? = oneofField {return v} + return SwiftProtobuf.Google_Protobuf_Empty() + } + set {oneofField = .emptyField(newValue)} + } + + var fieldMaskField: SwiftProtobuf.Google_Protobuf_FieldMask { + get { + if case .fieldMaskField(let v)? = oneofField {return v} + return SwiftProtobuf.Google_Protobuf_FieldMask() + } + set {oneofField = .fieldMaskField(newValue)} + } + + var sourceContextField: SwiftProtobuf.Google_Protobuf_SourceContext { + get { + if case .sourceContextField(let v)? = oneofField {return v} + return SwiftProtobuf.Google_Protobuf_SourceContext() + } + set {oneofField = .sourceContextField(newValue)} + } + + var structField: SwiftProtobuf.Google_Protobuf_Struct { + get { + if case .structField(let v)? = oneofField {return v} + return SwiftProtobuf.Google_Protobuf_Struct() + } + set {oneofField = .structField(newValue)} + } + + var timestampField: SwiftProtobuf.Google_Protobuf_Timestamp { + get { + if case .timestampField(let v)? = oneofField {return v} + return SwiftProtobuf.Google_Protobuf_Timestamp() + } + set {oneofField = .timestampField(newValue)} + } + + var typeField: SwiftProtobuf.Google_Protobuf_Type { + get { + if case .typeField(let v)? = oneofField {return v} + return SwiftProtobuf.Google_Protobuf_Type() + } + set {oneofField = .typeField(newValue)} + } + + var doubleField: SwiftProtobuf.Google_Protobuf_DoubleValue { + get { + if case .doubleField(let v)? = oneofField {return v} + return SwiftProtobuf.Google_Protobuf_DoubleValue() + } + set {oneofField = .doubleField(newValue)} + } + + var floatField: SwiftProtobuf.Google_Protobuf_FloatValue { + get { + if case .floatField(let v)? = oneofField {return v} + return SwiftProtobuf.Google_Protobuf_FloatValue() + } + set {oneofField = .floatField(newValue)} + } + + var int64Field: SwiftProtobuf.Google_Protobuf_Int64Value { + get { + if case .int64Field(let v)? = oneofField {return v} + return SwiftProtobuf.Google_Protobuf_Int64Value() + } + set {oneofField = .int64Field(newValue)} + } + + var uint64Field: SwiftProtobuf.Google_Protobuf_UInt64Value { + get { + if case .uint64Field(let v)? = oneofField {return v} + return SwiftProtobuf.Google_Protobuf_UInt64Value() + } + set {oneofField = .uint64Field(newValue)} + } + + var int32Field: SwiftProtobuf.Google_Protobuf_Int32Value { + get { + if case .int32Field(let v)? = oneofField {return v} + return SwiftProtobuf.Google_Protobuf_Int32Value() + } + set {oneofField = .int32Field(newValue)} + } + + var uint32Field: SwiftProtobuf.Google_Protobuf_UInt32Value { + get { + if case .uint32Field(let v)? = oneofField {return v} + return SwiftProtobuf.Google_Protobuf_UInt32Value() + } + set {oneofField = .uint32Field(newValue)} + } + + var boolField: SwiftProtobuf.Google_Protobuf_BoolValue { + get { + if case .boolField(let v)? = oneofField {return v} + return SwiftProtobuf.Google_Protobuf_BoolValue() + } + set {oneofField = .boolField(newValue)} + } + + var stringField: SwiftProtobuf.Google_Protobuf_StringValue { + get { + if case .stringField(let v)? = oneofField {return v} + return SwiftProtobuf.Google_Protobuf_StringValue() + } + set {oneofField = .stringField(newValue)} + } + + var bytesField: SwiftProtobuf.Google_Protobuf_BytesValue { + get { + if case .bytesField(let v)? = oneofField {return v} + return SwiftProtobuf.Google_Protobuf_BytesValue() + } + set {oneofField = .bytesField(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case anyField(SwiftProtobuf.Google_Protobuf_Any) + case apiField(SwiftProtobuf.Google_Protobuf_Api) + case durationField(SwiftProtobuf.Google_Protobuf_Duration) + case emptyField(SwiftProtobuf.Google_Protobuf_Empty) + case fieldMaskField(SwiftProtobuf.Google_Protobuf_FieldMask) + case sourceContextField(SwiftProtobuf.Google_Protobuf_SourceContext) + case structField(SwiftProtobuf.Google_Protobuf_Struct) + case timestampField(SwiftProtobuf.Google_Protobuf_Timestamp) + case typeField(SwiftProtobuf.Google_Protobuf_Type) + case doubleField(SwiftProtobuf.Google_Protobuf_DoubleValue) + case floatField(SwiftProtobuf.Google_Protobuf_FloatValue) + case int64Field(SwiftProtobuf.Google_Protobuf_Int64Value) + case uint64Field(SwiftProtobuf.Google_Protobuf_UInt64Value) + case int32Field(SwiftProtobuf.Google_Protobuf_Int32Value) + case uint32Field(SwiftProtobuf.Google_Protobuf_UInt32Value) + case boolField(SwiftProtobuf.Google_Protobuf_BoolValue) + case stringField(SwiftProtobuf.Google_Protobuf_StringValue) + case bytesField(SwiftProtobuf.Google_Protobuf_BytesValue) + + } + + init() {} +} + +/// A map field for each well-known type. We only +/// need to worry about the value part of the map being the +/// well-known types, as messages can't be map keys. +struct Proto2Unittest_MapWellKnownTypes: @unchecked Sendable { + // 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 anyField: Dictionary { + get {_storage._anyField} + set {_uniqueStorage()._anyField = newValue} + } + + var apiField: Dictionary { + get {_storage._apiField} + set {_uniqueStorage()._apiField = newValue} + } + + var durationField: Dictionary { + get {_storage._durationField} + set {_uniqueStorage()._durationField = newValue} + } + + var emptyField: Dictionary { + get {_storage._emptyField} + set {_uniqueStorage()._emptyField = newValue} + } + + var fieldMaskField: Dictionary { + get {_storage._fieldMaskField} + set {_uniqueStorage()._fieldMaskField = newValue} + } + + var sourceContextField: Dictionary { + get {_storage._sourceContextField} + set {_uniqueStorage()._sourceContextField = newValue} + } + + var structField: Dictionary { + get {_storage._structField} + set {_uniqueStorage()._structField = newValue} + } + + var timestampField: Dictionary { + get {_storage._timestampField} + set {_uniqueStorage()._timestampField = newValue} + } + + var typeField: Dictionary { + get {_storage._typeField} + set {_uniqueStorage()._typeField = newValue} + } + + var doubleField: Dictionary { + get {_storage._doubleField} + set {_uniqueStorage()._doubleField = newValue} + } + + var floatField: Dictionary { + get {_storage._floatField} + set {_uniqueStorage()._floatField = newValue} + } + + var int64Field: Dictionary { + get {_storage._int64Field} + set {_uniqueStorage()._int64Field = newValue} + } + + var uint64Field: Dictionary { + get {_storage._uint64Field} + set {_uniqueStorage()._uint64Field = newValue} + } + + var int32Field: Dictionary { + get {_storage._int32Field} + set {_uniqueStorage()._int32Field = newValue} + } + + var uint32Field: Dictionary { + get {_storage._uint32Field} + set {_uniqueStorage()._uint32Field = newValue} + } + + var boolField: Dictionary { + get {_storage._boolField} + set {_uniqueStorage()._boolField = newValue} + } + + var stringField: Dictionary { + get {_storage._stringField} + set {_uniqueStorage()._stringField = newValue} + } + + var bytesField: Dictionary { + get {_storage._bytesField} + set {_uniqueStorage()._bytesField = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "proto2_unittest" + +extension Proto2Unittest_TestWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestWellKnownTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}any_field\0\u{3}api_field\0\u{3}duration_field\0\u{3}empty_field\0\u{3}field_mask_field\0\u{3}source_context_field\0\u{3}struct_field\0\u{3}timestamp_field\0\u{3}type_field\0\u{3}double_field\0\u{3}float_field\0\u{3}int64_field\0\u{3}uint64_field\0\u{3}int32_field\0\u{3}uint32_field\0\u{3}bool_field\0\u{3}string_field\0\u{3}bytes_field\0\u{3}value_field\0") + + fileprivate class _StorageClass { + var _anyField: SwiftProtobuf.Google_Protobuf_Any? = nil + var _apiField: SwiftProtobuf.Google_Protobuf_Api? = nil + var _durationField: SwiftProtobuf.Google_Protobuf_Duration? = nil + var _emptyField: SwiftProtobuf.Google_Protobuf_Empty? = nil + var _fieldMaskField: SwiftProtobuf.Google_Protobuf_FieldMask? = nil + var _sourceContextField: SwiftProtobuf.Google_Protobuf_SourceContext? = nil + var _structField: SwiftProtobuf.Google_Protobuf_Struct? = nil + var _timestampField: SwiftProtobuf.Google_Protobuf_Timestamp? = nil + var _typeField: SwiftProtobuf.Google_Protobuf_Type? = nil + var _doubleField: SwiftProtobuf.Google_Protobuf_DoubleValue? = nil + var _floatField: SwiftProtobuf.Google_Protobuf_FloatValue? = nil + var _int64Field: SwiftProtobuf.Google_Protobuf_Int64Value? = nil + var _uint64Field: SwiftProtobuf.Google_Protobuf_UInt64Value? = nil + var _int32Field: SwiftProtobuf.Google_Protobuf_Int32Value? = nil + var _uint32Field: SwiftProtobuf.Google_Protobuf_UInt32Value? = nil + var _boolField: SwiftProtobuf.Google_Protobuf_BoolValue? = nil + var _stringField: SwiftProtobuf.Google_Protobuf_StringValue? = nil + var _bytesField: SwiftProtobuf.Google_Protobuf_BytesValue? = nil + var _valueField: SwiftProtobuf.Google_Protobuf_Value? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _anyField = source._anyField + _apiField = source._apiField + _durationField = source._durationField + _emptyField = source._emptyField + _fieldMaskField = source._fieldMaskField + _sourceContextField = source._sourceContextField + _structField = source._structField + _timestampField = source._timestampField + _typeField = source._typeField + _doubleField = source._doubleField + _floatField = source._floatField + _int64Field = source._int64Field + _uint64Field = source._uint64Field + _int32Field = source._int32Field + _uint32Field = source._uint32Field + _boolField = source._boolField + _stringField = source._stringField + _bytesField = source._bytesField + _valueField = source._valueField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._anyField) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._apiField) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._durationField) }() + case 4: try { try decoder.decodeSingularMessageField(value: &_storage._emptyField) }() + case 5: try { try decoder.decodeSingularMessageField(value: &_storage._fieldMaskField) }() + case 6: try { try decoder.decodeSingularMessageField(value: &_storage._sourceContextField) }() + case 7: try { try decoder.decodeSingularMessageField(value: &_storage._structField) }() + case 8: try { try decoder.decodeSingularMessageField(value: &_storage._timestampField) }() + case 9: try { try decoder.decodeSingularMessageField(value: &_storage._typeField) }() + case 10: try { try decoder.decodeSingularMessageField(value: &_storage._doubleField) }() + case 11: try { try decoder.decodeSingularMessageField(value: &_storage._floatField) }() + case 12: try { try decoder.decodeSingularMessageField(value: &_storage._int64Field) }() + case 13: try { try decoder.decodeSingularMessageField(value: &_storage._uint64Field) }() + case 14: try { try decoder.decodeSingularMessageField(value: &_storage._int32Field) }() + case 15: try { try decoder.decodeSingularMessageField(value: &_storage._uint32Field) }() + case 16: try { try decoder.decodeSingularMessageField(value: &_storage._boolField) }() + case 17: try { try decoder.decodeSingularMessageField(value: &_storage._stringField) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._bytesField) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._valueField) }() + default: break + } + } + } + } + + func traverse(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._anyField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._apiField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._durationField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._emptyField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._fieldMaskField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._sourceContextField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._structField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._timestampField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._typeField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._doubleField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._floatField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._int64Field { + try visitor.visitSingularMessageField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._uint64Field { + try visitor.visitSingularMessageField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._int32Field { + try visitor.visitSingularMessageField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._uint32Field { + try visitor.visitSingularMessageField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._boolField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._stringField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 17) + } }() + try { if let v = _storage._bytesField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._valueField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_TestWellKnownTypes, rhs: Proto2Unittest_TestWellKnownTypes) -> 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._anyField != rhs_storage._anyField {return false} + if _storage._apiField != rhs_storage._apiField {return false} + if _storage._durationField != rhs_storage._durationField {return false} + if _storage._emptyField != rhs_storage._emptyField {return false} + if _storage._fieldMaskField != rhs_storage._fieldMaskField {return false} + if _storage._sourceContextField != rhs_storage._sourceContextField {return false} + if _storage._structField != rhs_storage._structField {return false} + if _storage._timestampField != rhs_storage._timestampField {return false} + if _storage._typeField != rhs_storage._typeField {return false} + if _storage._doubleField != rhs_storage._doubleField {return false} + if _storage._floatField != rhs_storage._floatField {return false} + if _storage._int64Field != rhs_storage._int64Field {return false} + if _storage._uint64Field != rhs_storage._uint64Field {return false} + if _storage._int32Field != rhs_storage._int32Field {return false} + if _storage._uint32Field != rhs_storage._uint32Field {return false} + if _storage._boolField != rhs_storage._boolField {return false} + if _storage._stringField != rhs_storage._stringField {return false} + if _storage._bytesField != rhs_storage._bytesField {return false} + if _storage._valueField != rhs_storage._valueField {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_RepeatedWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".RepeatedWellKnownTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}any_field\0\u{3}api_field\0\u{3}duration_field\0\u{3}empty_field\0\u{3}field_mask_field\0\u{3}source_context_field\0\u{3}struct_field\0\u{3}timestamp_field\0\u{3}type_field\0\u{3}double_field\0\u{3}float_field\0\u{3}int64_field\0\u{3}uint64_field\0\u{3}int32_field\0\u{3}uint32_field\0\u{3}bool_field\0\u{3}string_field\0\u{3}bytes_field\0") + + fileprivate class _StorageClass { + var _anyField: [SwiftProtobuf.Google_Protobuf_Any] = [] + var _apiField: [SwiftProtobuf.Google_Protobuf_Api] = [] + var _durationField: [SwiftProtobuf.Google_Protobuf_Duration] = [] + var _emptyField: [SwiftProtobuf.Google_Protobuf_Empty] = [] + var _fieldMaskField: [SwiftProtobuf.Google_Protobuf_FieldMask] = [] + var _sourceContextField: [SwiftProtobuf.Google_Protobuf_SourceContext] = [] + var _structField: [SwiftProtobuf.Google_Protobuf_Struct] = [] + var _timestampField: [SwiftProtobuf.Google_Protobuf_Timestamp] = [] + var _typeField: [SwiftProtobuf.Google_Protobuf_Type] = [] + var _doubleField: [SwiftProtobuf.Google_Protobuf_DoubleValue] = [] + var _floatField: [SwiftProtobuf.Google_Protobuf_FloatValue] = [] + var _int64Field: [SwiftProtobuf.Google_Protobuf_Int64Value] = [] + var _uint64Field: [SwiftProtobuf.Google_Protobuf_UInt64Value] = [] + var _int32Field: [SwiftProtobuf.Google_Protobuf_Int32Value] = [] + var _uint32Field: [SwiftProtobuf.Google_Protobuf_UInt32Value] = [] + var _boolField: [SwiftProtobuf.Google_Protobuf_BoolValue] = [] + var _stringField: [SwiftProtobuf.Google_Protobuf_StringValue] = [] + var _bytesField: [SwiftProtobuf.Google_Protobuf_BytesValue] = [] + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _anyField = source._anyField + _apiField = source._apiField + _durationField = source._durationField + _emptyField = source._emptyField + _fieldMaskField = source._fieldMaskField + _sourceContextField = source._sourceContextField + _structField = source._structField + _timestampField = source._timestampField + _typeField = source._typeField + _doubleField = source._doubleField + _floatField = source._floatField + _int64Field = source._int64Field + _uint64Field = source._uint64Field + _int32Field = source._int32Field + _uint32Field = source._uint32Field + _boolField = source._boolField + _stringField = source._stringField + _bytesField = source._bytesField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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.decodeRepeatedMessageField(value: &_storage._anyField) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &_storage._apiField) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &_storage._durationField) }() + case 4: try { try decoder.decodeRepeatedMessageField(value: &_storage._emptyField) }() + case 5: try { try decoder.decodeRepeatedMessageField(value: &_storage._fieldMaskField) }() + case 6: try { try decoder.decodeRepeatedMessageField(value: &_storage._sourceContextField) }() + case 7: try { try decoder.decodeRepeatedMessageField(value: &_storage._structField) }() + case 8: try { try decoder.decodeRepeatedMessageField(value: &_storage._timestampField) }() + case 9: try { try decoder.decodeRepeatedMessageField(value: &_storage._typeField) }() + case 10: try { try decoder.decodeRepeatedMessageField(value: &_storage._doubleField) }() + case 11: try { try decoder.decodeRepeatedMessageField(value: &_storage._floatField) }() + case 12: try { try decoder.decodeRepeatedMessageField(value: &_storage._int64Field) }() + case 13: try { try decoder.decodeRepeatedMessageField(value: &_storage._uint64Field) }() + case 14: try { try decoder.decodeRepeatedMessageField(value: &_storage._int32Field) }() + case 15: try { try decoder.decodeRepeatedMessageField(value: &_storage._uint32Field) }() + case 16: try { try decoder.decodeRepeatedMessageField(value: &_storage._boolField) }() + case 17: try { try decoder.decodeRepeatedMessageField(value: &_storage._stringField) }() + case 18: try { try decoder.decodeRepeatedMessageField(value: &_storage._bytesField) }() + default: break + } + } + } + } + + func traverse(visitor: inout V) throws { + try withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if !_storage._anyField.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._anyField, fieldNumber: 1) + } + if !_storage._apiField.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._apiField, fieldNumber: 2) + } + if !_storage._durationField.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._durationField, fieldNumber: 3) + } + if !_storage._emptyField.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._emptyField, fieldNumber: 4) + } + if !_storage._fieldMaskField.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._fieldMaskField, fieldNumber: 5) + } + if !_storage._sourceContextField.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._sourceContextField, fieldNumber: 6) + } + if !_storage._structField.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._structField, fieldNumber: 7) + } + if !_storage._timestampField.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._timestampField, fieldNumber: 8) + } + if !_storage._typeField.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._typeField, fieldNumber: 9) + } + if !_storage._doubleField.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._doubleField, fieldNumber: 10) + } + if !_storage._floatField.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._floatField, fieldNumber: 11) + } + if !_storage._int64Field.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._int64Field, fieldNumber: 12) + } + if !_storage._uint64Field.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._uint64Field, fieldNumber: 13) + } + if !_storage._int32Field.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._int32Field, fieldNumber: 14) + } + if !_storage._uint32Field.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._uint32Field, fieldNumber: 15) + } + if !_storage._boolField.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._boolField, fieldNumber: 16) + } + if !_storage._stringField.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._stringField, fieldNumber: 17) + } + if !_storage._bytesField.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._bytesField, fieldNumber: 18) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_RepeatedWellKnownTypes, rhs: Proto2Unittest_RepeatedWellKnownTypes) -> 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._anyField != rhs_storage._anyField {return false} + if _storage._apiField != rhs_storage._apiField {return false} + if _storage._durationField != rhs_storage._durationField {return false} + if _storage._emptyField != rhs_storage._emptyField {return false} + if _storage._fieldMaskField != rhs_storage._fieldMaskField {return false} + if _storage._sourceContextField != rhs_storage._sourceContextField {return false} + if _storage._structField != rhs_storage._structField {return false} + if _storage._timestampField != rhs_storage._timestampField {return false} + if _storage._typeField != rhs_storage._typeField {return false} + if _storage._doubleField != rhs_storage._doubleField {return false} + if _storage._floatField != rhs_storage._floatField {return false} + if _storage._int64Field != rhs_storage._int64Field {return false} + if _storage._uint64Field != rhs_storage._uint64Field {return false} + if _storage._int32Field != rhs_storage._int32Field {return false} + if _storage._uint32Field != rhs_storage._uint32Field {return false} + if _storage._boolField != rhs_storage._boolField {return false} + if _storage._stringField != rhs_storage._stringField {return false} + if _storage._bytesField != rhs_storage._bytesField {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_OneofWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OneofWellKnownTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}any_field\0\u{3}api_field\0\u{3}duration_field\0\u{3}empty_field\0\u{3}field_mask_field\0\u{3}source_context_field\0\u{3}struct_field\0\u{3}timestamp_field\0\u{3}type_field\0\u{3}double_field\0\u{3}float_field\0\u{3}int64_field\0\u{3}uint64_field\0\u{3}int32_field\0\u{3}uint32_field\0\u{3}bool_field\0\u{3}string_field\0\u{3}bytes_field\0") + + 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: SwiftProtobuf.Google_Protobuf_Any? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .anyField(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .anyField(v) + } + }() + case 2: try { + var v: SwiftProtobuf.Google_Protobuf_Api? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .apiField(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .apiField(v) + } + }() + case 3: try { + var v: SwiftProtobuf.Google_Protobuf_Duration? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .durationField(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .durationField(v) + } + }() + case 4: try { + var v: SwiftProtobuf.Google_Protobuf_Empty? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .emptyField(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .emptyField(v) + } + }() + case 5: try { + var v: SwiftProtobuf.Google_Protobuf_FieldMask? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .fieldMaskField(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .fieldMaskField(v) + } + }() + case 6: try { + var v: SwiftProtobuf.Google_Protobuf_SourceContext? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .sourceContextField(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .sourceContextField(v) + } + }() + case 7: try { + var v: SwiftProtobuf.Google_Protobuf_Struct? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .structField(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .structField(v) + } + }() + case 8: try { + var v: SwiftProtobuf.Google_Protobuf_Timestamp? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .timestampField(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .timestampField(v) + } + }() + case 9: try { + var v: SwiftProtobuf.Google_Protobuf_Type? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .typeField(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .typeField(v) + } + }() + case 10: try { + var v: SwiftProtobuf.Google_Protobuf_DoubleValue? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .doubleField(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .doubleField(v) + } + }() + case 11: try { + var v: SwiftProtobuf.Google_Protobuf_FloatValue? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .floatField(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .floatField(v) + } + }() + case 12: try { + var v: SwiftProtobuf.Google_Protobuf_Int64Value? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .int64Field(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .int64Field(v) + } + }() + case 13: try { + var v: SwiftProtobuf.Google_Protobuf_UInt64Value? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .uint64Field(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .uint64Field(v) + } + }() + case 14: try { + var v: SwiftProtobuf.Google_Protobuf_Int32Value? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .int32Field(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .int32Field(v) + } + }() + case 15: try { + var v: SwiftProtobuf.Google_Protobuf_UInt32Value? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .uint32Field(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .uint32Field(v) + } + }() + case 16: try { + var v: SwiftProtobuf.Google_Protobuf_BoolValue? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .boolField(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .boolField(v) + } + }() + case 17: try { + var v: SwiftProtobuf.Google_Protobuf_StringValue? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .stringField(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .stringField(v) + } + }() + case 18: try { + var v: SwiftProtobuf.Google_Protobuf_BytesValue? + var hadOneofValue = false + if let current = self.oneofField { + hadOneofValue = true + if case .bytesField(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.oneofField = .bytesField(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.oneofField { + case .anyField?: try { + guard case .anyField(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + }() + case .apiField?: try { + guard case .apiField(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + }() + case .durationField?: try { + guard case .durationField(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + }() + case .emptyField?: try { + guard case .emptyField(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + }() + case .fieldMaskField?: try { + guard case .fieldMaskField(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + }() + case .sourceContextField?: try { + guard case .sourceContextField(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 6) + }() + case .structField?: try { + guard case .structField(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 7) + }() + case .timestampField?: try { + guard case .timestampField(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 8) + }() + case .typeField?: try { + guard case .typeField(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 9) + }() + case .doubleField?: try { + guard case .doubleField(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 10) + }() + case .floatField?: try { + guard case .floatField(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 11) + }() + case .int64Field?: try { + guard case .int64Field(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 12) + }() + case .uint64Field?: try { + guard case .uint64Field(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 13) + }() + case .int32Field?: try { + guard case .int32Field(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 14) + }() + case .uint32Field?: try { + guard case .uint32Field(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 15) + }() + case .boolField?: try { + guard case .boolField(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 16) + }() + case .stringField?: try { + guard case .stringField(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 17) + }() + case .bytesField?: try { + guard case .bytesField(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_OneofWellKnownTypes, rhs: Proto2Unittest_OneofWellKnownTypes) -> Bool { + if lhs.oneofField != rhs.oneofField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Proto2Unittest_MapWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MapWellKnownTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}any_field\0\u{3}api_field\0\u{3}duration_field\0\u{3}empty_field\0\u{3}field_mask_field\0\u{3}source_context_field\0\u{3}struct_field\0\u{3}timestamp_field\0\u{3}type_field\0\u{3}double_field\0\u{3}float_field\0\u{3}int64_field\0\u{3}uint64_field\0\u{3}int32_field\0\u{3}uint32_field\0\u{3}bool_field\0\u{3}string_field\0\u{3}bytes_field\0") + + fileprivate class _StorageClass { + var _anyField: Dictionary = [:] + var _apiField: Dictionary = [:] + var _durationField: Dictionary = [:] + var _emptyField: Dictionary = [:] + var _fieldMaskField: Dictionary = [:] + var _sourceContextField: Dictionary = [:] + var _structField: Dictionary = [:] + var _timestampField: Dictionary = [:] + var _typeField: Dictionary = [:] + var _doubleField: Dictionary = [:] + var _floatField: Dictionary = [:] + var _int64Field: Dictionary = [:] + var _uint64Field: Dictionary = [:] + var _int32Field: Dictionary = [:] + var _uint32Field: Dictionary = [:] + var _boolField: Dictionary = [:] + var _stringField: Dictionary = [:] + var _bytesField: Dictionary = [:] + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _anyField = source._anyField + _apiField = source._apiField + _durationField = source._durationField + _emptyField = source._emptyField + _fieldMaskField = source._fieldMaskField + _sourceContextField = source._sourceContextField + _structField = source._structField + _timestampField = source._timestampField + _typeField = source._typeField + _doubleField = source._doubleField + _floatField = source._floatField + _int64Field = source._int64Field + _uint64Field = source._uint64Field + _int32Field = source._int32Field + _uint32Field = source._uint32Field + _boolField = source._boolField + _stringField = source._stringField + _bytesField = source._bytesField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._anyField) }() + case 2: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._apiField) }() + case 3: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._durationField) }() + case 4: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._emptyField) }() + case 5: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._fieldMaskField) }() + case 6: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._sourceContextField) }() + case 7: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._structField) }() + case 8: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._timestampField) }() + case 9: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._typeField) }() + case 10: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._doubleField) }() + case 11: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._floatField) }() + case 12: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._int64Field) }() + case 13: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._uint64Field) }() + case 14: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._int32Field) }() + case 15: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._uint32Field) }() + case 16: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._boolField) }() + case 17: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._stringField) }() + case 18: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._bytesField) }() + default: break + } + } + } + } + + func traverse(visitor: inout V) throws { + try withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if !_storage._anyField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._anyField, fieldNumber: 1) + } + if !_storage._apiField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._apiField, fieldNumber: 2) + } + if !_storage._durationField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._durationField, fieldNumber: 3) + } + if !_storage._emptyField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._emptyField, fieldNumber: 4) + } + if !_storage._fieldMaskField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._fieldMaskField, fieldNumber: 5) + } + if !_storage._sourceContextField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._sourceContextField, fieldNumber: 6) + } + if !_storage._structField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._structField, fieldNumber: 7) + } + if !_storage._timestampField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._timestampField, fieldNumber: 8) + } + if !_storage._typeField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._typeField, fieldNumber: 9) + } + if !_storage._doubleField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._doubleField, fieldNumber: 10) + } + if !_storage._floatField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._floatField, fieldNumber: 11) + } + if !_storage._int64Field.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._int64Field, fieldNumber: 12) + } + if !_storage._uint64Field.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._uint64Field, fieldNumber: 13) + } + if !_storage._int32Field.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._int32Field, fieldNumber: 14) + } + if !_storage._uint32Field.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._uint32Field, fieldNumber: 15) + } + if !_storage._boolField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._boolField, fieldNumber: 16) + } + if !_storage._stringField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._stringField, fieldNumber: 17) + } + if !_storage._bytesField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._bytesField, fieldNumber: 18) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Proto2Unittest_MapWellKnownTypes, rhs: Proto2Unittest_MapWellKnownTypes) -> 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._anyField != rhs_storage._anyField {return false} + if _storage._apiField != rhs_storage._apiField {return false} + if _storage._durationField != rhs_storage._durationField {return false} + if _storage._emptyField != rhs_storage._emptyField {return false} + if _storage._fieldMaskField != rhs_storage._fieldMaskField {return false} + if _storage._sourceContextField != rhs_storage._sourceContextField {return false} + if _storage._structField != rhs_storage._structField {return false} + if _storage._timestampField != rhs_storage._timestampField {return false} + if _storage._typeField != rhs_storage._typeField {return false} + if _storage._doubleField != rhs_storage._doubleField {return false} + if _storage._floatField != rhs_storage._floatField {return false} + if _storage._int64Field != rhs_storage._int64Field {return false} + if _storage._uint64Field != rhs_storage._uint64Field {return false} + if _storage._int32Field != rhs_storage._int32Field {return false} + if _storage._uint32Field != rhs_storage._uint32Field {return false} + if _storage._boolField != rhs_storage._boolField {return false} + if _storage._stringField != rhs_storage._stringField {return false} + if _storage._bytesField != rhs_storage._bytesField {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Reference/upstream/google/protobuf/wrappers.pb.swift b/Reference/upstream/google/protobuf/wrappers.pb.swift new file mode 100644 index 000000000..1c8a092e9 --- /dev/null +++ b/Reference/upstream/google/protobuf/wrappers.pb.swift @@ -0,0 +1,514 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: google/protobuf/wrappers.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Wrappers for primitive (non-message) types. These types were needed +// for legacy reasons and are not recommended for use in new APIs. +// +// Historically these wrappers were useful to have presence on proto3 primitive +// fields, but proto3 syntax has been updated to support the `optional` keyword. +// Using that keyword is now the strongly preferred way to add presence to +// proto3 primitive fields. +// +// A secondary usecase was to embed primitives in the `google.protobuf.Any` +// type: it is now recommended that you embed your value in your own wrapper +// message which can be specifically documented. +// +// These wrappers have no meaningful use within repeated fields as they lack +// the ability to detect presence on individual elements. +// These wrappers have no meaningful use within a map or a oneof since +// individual entries of a map or fields of a oneof can already detect presence. + +import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. + +// 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: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} + typealias Version = _2 +} + +/// Wrapper message for `double`. +/// +/// The JSON representation for `DoubleValue` is JSON number. +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +struct Google_Protobuf_DoubleValue: Sendable { + // 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. + + /// The double value. + var value: Double = 0 + + var unknownFields = UnknownStorage() + + init() {} +} + +/// Wrapper message for `float`. +/// +/// The JSON representation for `FloatValue` is JSON number. +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +struct Google_Protobuf_FloatValue: Sendable { + // 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. + + /// The float value. + var value: Float = 0 + + var unknownFields = UnknownStorage() + + init() {} +} + +/// Wrapper message for `int64`. +/// +/// The JSON representation for `Int64Value` is JSON string. +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +struct Google_Protobuf_Int64Value: Sendable { + // 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. + + /// The int64 value. + var value: Int64 = 0 + + var unknownFields = UnknownStorage() + + init() {} +} + +/// Wrapper message for `uint64`. +/// +/// The JSON representation for `UInt64Value` is JSON string. +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +struct Google_Protobuf_UInt64Value: Sendable { + // 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. + + /// The uint64 value. + var value: UInt64 = 0 + + var unknownFields = UnknownStorage() + + init() {} +} + +/// Wrapper message for `int32`. +/// +/// The JSON representation for `Int32Value` is JSON number. +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +struct Google_Protobuf_Int32Value: Sendable { + // 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. + + /// The int32 value. + var value: Int32 = 0 + + var unknownFields = UnknownStorage() + + init() {} +} + +/// Wrapper message for `uint32`. +/// +/// The JSON representation for `UInt32Value` is JSON number. +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +struct Google_Protobuf_UInt32Value: Sendable { + // 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. + + /// The uint32 value. + var value: UInt32 = 0 + + var unknownFields = UnknownStorage() + + init() {} +} + +/// Wrapper message for `bool`. +/// +/// The JSON representation for `BoolValue` is JSON `true` and `false`. +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +struct Google_Protobuf_BoolValue: Sendable { + // 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. + + /// The bool value. + var value: Bool = false + + var unknownFields = UnknownStorage() + + init() {} +} + +/// Wrapper message for `string`. +/// +/// The JSON representation for `StringValue` is JSON string. +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +struct Google_Protobuf_StringValue: Sendable { + // 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. + + /// The string value. + var value: String = String() + + var unknownFields = UnknownStorage() + + init() {} +} + +/// Wrapper message for `bytes`. +/// +/// The JSON representation for `BytesValue` is JSON string. +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +struct Google_Protobuf_BytesValue: Sendable { + // 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. + + /// The bytes value. + var value: Data = Data() + + var unknownFields = UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "google.protobuf" + +extension Google_Protobuf_DoubleValue: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".DoubleValue" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") + + 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.decodeSingularDoubleField(value: &self.value) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.value.bitPattern != 0 { + try visitor.visitSingularDoubleField(value: self.value, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_DoubleValue, rhs: Google_Protobuf_DoubleValue) -> Bool { + if lhs.value != rhs.value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_FloatValue: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".FloatValue" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") + + 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.decodeSingularFloatField(value: &self.value) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.value.bitPattern != 0 { + try visitor.visitSingularFloatField(value: self.value, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_FloatValue, rhs: Google_Protobuf_FloatValue) -> Bool { + if lhs.value != rhs.value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_Int64Value: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Int64Value" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") + + 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.decodeSingularInt64Field(value: &self.value) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.value != 0 { + try visitor.visitSingularInt64Field(value: self.value, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_Int64Value, rhs: Google_Protobuf_Int64Value) -> Bool { + if lhs.value != rhs.value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_UInt64Value: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".UInt64Value" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") + + 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.decodeSingularUInt64Field(value: &self.value) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.value != 0 { + try visitor.visitSingularUInt64Field(value: self.value, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_UInt64Value, rhs: Google_Protobuf_UInt64Value) -> Bool { + if lhs.value != rhs.value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_Int32Value: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Int32Value" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") + + 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.value) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.value != 0 { + try visitor.visitSingularInt32Field(value: self.value, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_Int32Value, rhs: Google_Protobuf_Int32Value) -> Bool { + if lhs.value != rhs.value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_UInt32Value: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".UInt32Value" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") + + 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.value) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.value != 0 { + try visitor.visitSingularUInt32Field(value: self.value, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_UInt32Value, rhs: Google_Protobuf_UInt32Value) -> Bool { + if lhs.value != rhs.value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_BoolValue: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".BoolValue" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") + + 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.decodeSingularBoolField(value: &self.value) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.value != false { + try visitor.visitSingularBoolField(value: self.value, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_BoolValue, rhs: Google_Protobuf_BoolValue) -> Bool { + if lhs.value != rhs.value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_StringValue: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".StringValue" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") + + 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.value) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.value.isEmpty { + try visitor.visitSingularStringField(value: self.value, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_StringValue, rhs: Google_Protobuf_StringValue) -> Bool { + if lhs.value != rhs.value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_BytesValue: Message, _MessageImplementationBase, _ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".BytesValue" + static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") + + 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.decodeSingularBytesField(value: &self.value) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.value.isEmpty { + try visitor.visitSingularBytesField(value: self.value, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Google_Protobuf_BytesValue, rhs: Google_Protobuf_BytesValue) -> Bool { + if lhs.value != rhs.value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Sources/Conformance/Docs.docc/index.md b/Sources/Conformance/Docs.docc/index.md new file mode 100644 index 000000000..b2cbb57c0 --- /dev/null +++ b/Sources/Conformance/Docs.docc/index.md @@ -0,0 +1,4 @@ +# Conformance + +Test program for use with Google's Protobuf Conformance suite. + diff --git a/Sources/Conformance/conformance.pb.swift b/Sources/Conformance/conformance.pb.swift index d19d0cca6..d1e311190 100644 --- a/Sources/Conformance/conformance.pb.swift +++ b/Sources/Conformance/conformance.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: conformance/conformance.proto @@ -9,33 +10,10 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd import Foundation import SwiftProtobuf @@ -50,13 +28,13 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum Conformance_WireFormat: SwiftProtobuf.Enum { +enum Conformance_WireFormat: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case unspecified // = 0 case protobuf // = 1 case json // = 2 - /// Google internal only. Opensource testees just skip it. + /// Only used inside Google. Opensource testees just skip it. case jspb // = 3 case textFormat // = 4 case UNRECOGNIZED(Int) @@ -87,24 +65,18 @@ enum Conformance_WireFormat: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension Conformance_WireFormat: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Conformance_WireFormat] = [ + static let allCases: [Conformance_WireFormat] = [ .unspecified, .protobuf, .json, .jspb, .textFormat, ] -} -#endif // swift(>=4.2) +} -enum Conformance_TestCategory: SwiftProtobuf.Enum { +enum Conformance_TestCategory: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case unspecifiedTest // = 0 @@ -121,7 +93,8 @@ enum Conformance_TestCategory: SwiftProtobuf.Enum { /// for more detail. case jsonIgnoreUnknownParsingTest // = 3 - /// Test jspb wire format. Google internal only. Opensource testees just skip it. + /// Test jspb wire format. Only used inside Google. Opensource testees just + /// skip it. case jspbTest // = 4 /// Test text format. For cpp, java and python, testees can already deal with @@ -157,13 +130,8 @@ enum Conformance_TestCategory: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension Conformance_TestCategory: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Conformance_TestCategory] = [ + static let allCases: [Conformance_TestCategory] = [ .unspecifiedTest, .binaryTest, .jsonTest, @@ -171,19 +139,39 @@ extension Conformance_TestCategory: CaseIterable { .jspbTest, .textFormatTest, ] + } -#endif // swift(>=4.2) +/// Meant to encapsulate all types of tests: successes, skips, failures, etc. +/// Therefore, this may or may not have a failure message. Failure messages +/// may be truncated for our failure lists. +struct Conformance_TestStatus: Sendable { + // 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 name: String = String() + + var failureMessage: String = String() + + /// What an actual test name matched to in a failure list. Can be wildcarded or + /// an exact match without wildcards. + var matchedName: String = String() + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} /// The conformance runner will request a list of failures as the first request. /// This will be known by message_type == "conformance.FailureSet", a conformance /// test should return a serialized FailureSet in protobuf_payload. -struct Conformance_FailureSet { +struct Conformance_FailureSet: Sendable { // 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 failure: [String] = [] + var test: [Conformance_TestStatus] = [] var unknownFields = SwiftProtobuf.UnknownStorage() @@ -195,7 +183,7 @@ struct Conformance_FailureSet { /// 1. parse this proto (which should always succeed) /// 2. parse the protobuf or JSON payload in "payload" (which may fail) /// 3. if the parse succeeded, serialize the message in the requested format. -struct Conformance_ConformanceRequest { +struct Conformance_ConformanceRequest: Sendable { // 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. @@ -203,10 +191,6 @@ struct Conformance_ConformanceRequest { /// The payload (whether protobuf of JSON) is always for a /// protobuf_test_messages.proto3.TestAllTypes proto (as defined in /// src/google/protobuf/proto3_test_messages.proto). - /// - /// TODO(haberman): if/when we expand the conformance tests to support proto2, - /// we will want to include a field that lets the payload/response be a - /// protobuf_test_messages.google.protobuf.TestAllTypes message instead. var payload: Conformance_ConformanceRequest.OneOf_Payload? = nil var protobufPayload: Data { @@ -225,7 +209,7 @@ struct Conformance_ConformanceRequest { set {payload = .jsonPayload(newValue)} } - /// Google internal only. Opensource testees just skip it. + /// Only used inside Google. Opensource testees just skip it. var jspbPayload: String { get { if case .jspbPayload(let v)? = payload {return v} @@ -247,21 +231,24 @@ struct Conformance_ConformanceRequest { /// The full name for the test message to use; for the moment, either: /// protobuf_test_messages.proto3.TestAllTypesProto3 or - /// protobuf_test_messages.google.protobuf.TestAllTypesProto2. + /// protobuf_test_messages.proto2.TestAllTypesProto2 or + /// protobuf_test_messages.editions.proto2.TestAllTypesProto2 or + /// protobuf_test_messages.editions.proto3.TestAllTypesProto3 or + /// protobuf_test_messages.editions.TestAllTypesEdition2023. var messageType: String = String() /// Each test is given a specific test category. Some category may need - /// specific support in testee programs. Refer to the definition of TestCategory - /// for more information. + /// specific support in testee programs. Refer to the definition of + /// TestCategory for more information. var testCategory: Conformance_TestCategory = .unspecifiedTest /// Specify details for how to encode jspb. var jspbEncodingOptions: Conformance_JspbEncodingConfig { - get {return _jspbEncodingOptions ?? Conformance_JspbEncodingConfig()} + get {_jspbEncodingOptions ?? Conformance_JspbEncodingConfig()} set {_jspbEncodingOptions = newValue} } /// Returns true if `jspbEncodingOptions` has been explicitly set. - var hasJspbEncodingOptions: Bool {return self._jspbEncodingOptions != nil} + var hasJspbEncodingOptions: Bool {self._jspbEncodingOptions != nil} /// Clears the value of `jspbEncodingOptions`. Subsequent reads from it will return its default value. mutating func clearJspbEncodingOptions() {self._jspbEncodingOptions = nil} @@ -274,43 +261,13 @@ struct Conformance_ConformanceRequest { /// The payload (whether protobuf of JSON) is always for a /// protobuf_test_messages.proto3.TestAllTypes proto (as defined in /// src/google/protobuf/proto3_test_messages.proto). - /// - /// TODO(haberman): if/when we expand the conformance tests to support proto2, - /// we will want to include a field that lets the payload/response be a - /// protobuf_test_messages.google.protobuf.TestAllTypes message instead. - enum OneOf_Payload: Equatable { + enum OneOf_Payload: Equatable, Sendable { case protobufPayload(Data) case jsonPayload(String) - /// Google internal only. Opensource testees just skip it. + /// Only used inside Google. Opensource testees just skip it. case jspbPayload(String) case textPayload(String) - #if !swift(>=4.1) - static func ==(lhs: Conformance_ConformanceRequest.OneOf_Payload, rhs: Conformance_ConformanceRequest.OneOf_Payload) -> 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 (.protobufPayload, .protobufPayload): return { - guard case .protobufPayload(let l) = lhs, case .protobufPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.jsonPayload, .jsonPayload): return { - guard case .jsonPayload(let l) = lhs, case .jsonPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.jspbPayload, .jspbPayload): return { - guard case .jspbPayload(let l) = lhs, case .jspbPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.textPayload, .textPayload): return { - guard case .textPayload(let l) = lhs, case .textPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } init() {} @@ -319,7 +276,7 @@ struct Conformance_ConformanceRequest { } /// Represents a single test case's output. -struct Conformance_ConformanceResponse { +struct Conformance_ConformanceResponse: Sendable { // 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. @@ -350,6 +307,17 @@ struct Conformance_ConformanceResponse { set {result = .serializeError(newValue)} } + /// This should be set if the test program timed out. The string should + /// provide more information about what the child process was doing when it + /// was killed. + var timeoutError: String { + get { + if case .timeoutError(let v)? = result {return v} + return String() + } + set {result = .timeoutError(newValue)} + } + /// This should be set if some other error occurred. This will always /// indicate that the test failed. The string can provide more information /// about the failure. @@ -392,8 +360,8 @@ struct Conformance_ConformanceResponse { } /// If the input was successfully parsed and the requested output was JSPB, - /// serialize to JSPB and set it in this field. JSPB is google internal only - /// format. Opensource testees can just skip it. + /// serialize to JSPB and set it in this field. JSPB is only used inside + /// Google. Opensource testees can just skip it. var jspbPayload: String { get { if case .jspbPayload(let v)? = result {return v} @@ -414,7 +382,7 @@ struct Conformance_ConformanceResponse { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_Result: Equatable { + enum OneOf_Result: Equatable, Sendable { /// This string should be set to indicate parsing failed. The string can /// provide more information about the parse error if it is available. /// @@ -425,6 +393,10 @@ struct Conformance_ConformanceResponse { /// serializing it to the requested output format, set the error message in /// this field. case serializeError(String) + /// This should be set if the test program timed out. The string should + /// provide more information about what the child process was doing when it + /// was killed. + case timeoutError(String) /// This should be set if some other error occurred. This will always /// indicate that the test failed. The string can provide more information /// about the failure. @@ -439,62 +411,20 @@ struct Conformance_ConformanceResponse { /// wasn't supported, like JSON input/output. case skipped(String) /// If the input was successfully parsed and the requested output was JSPB, - /// serialize to JSPB and set it in this field. JSPB is google internal only - /// format. Opensource testees can just skip it. + /// serialize to JSPB and set it in this field. JSPB is only used inside + /// Google. Opensource testees can just skip it. case jspbPayload(String) /// If the input was successfully parsed and the requested output was /// TEXT_FORMAT, serialize to TEXT_FORMAT and set it in this field. case textPayload(String) - #if !swift(>=4.1) - static func ==(lhs: Conformance_ConformanceResponse.OneOf_Result, rhs: Conformance_ConformanceResponse.OneOf_Result) -> 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 (.parseError, .parseError): return { - guard case .parseError(let l) = lhs, case .parseError(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.serializeError, .serializeError): return { - guard case .serializeError(let l) = lhs, case .serializeError(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.runtimeError, .runtimeError): return { - guard case .runtimeError(let l) = lhs, case .runtimeError(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.protobufPayload, .protobufPayload): return { - guard case .protobufPayload(let l) = lhs, case .protobufPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.jsonPayload, .jsonPayload): return { - guard case .jsonPayload(let l) = lhs, case .jsonPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.skipped, .skipped): return { - guard case .skipped(let l) = lhs, case .skipped(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.jspbPayload, .jspbPayload): return { - guard case .jspbPayload(let l) = lhs, case .jspbPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.textPayload, .textPayload): return { - guard case .textPayload(let l) = lhs, case .textPayload(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } init() {} } /// Encoding options for jspb format. -struct Conformance_JspbEncodingConfig { +struct Conformance_JspbEncodingConfig: Sendable { // 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. @@ -507,47 +437,61 @@ struct Conformance_JspbEncodingConfig { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Conformance_WireFormat: @unchecked Sendable {} -extension Conformance_TestCategory: @unchecked Sendable {} -extension Conformance_FailureSet: @unchecked Sendable {} -extension Conformance_ConformanceRequest: @unchecked Sendable {} -extension Conformance_ConformanceRequest.OneOf_Payload: @unchecked Sendable {} -extension Conformance_ConformanceResponse: @unchecked Sendable {} -extension Conformance_ConformanceResponse.OneOf_Result: @unchecked Sendable {} -extension Conformance_JspbEncodingConfig: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "conformance" extension Conformance_WireFormat: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "UNSPECIFIED"), - 1: .same(proto: "PROTOBUF"), - 2: .same(proto: "JSON"), - 3: .same(proto: "JSPB"), - 4: .same(proto: "TEXT_FORMAT"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNSPECIFIED\0\u{1}PROTOBUF\0\u{1}JSON\0\u{1}JSPB\0\u{1}TEXT_FORMAT\0") } extension Conformance_TestCategory: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "UNSPECIFIED_TEST"), - 1: .same(proto: "BINARY_TEST"), - 2: .same(proto: "JSON_TEST"), - 3: .same(proto: "JSON_IGNORE_UNKNOWN_PARSING_TEST"), - 4: .same(proto: "JSPB_TEST"), - 5: .same(proto: "TEXT_FORMAT_TEST"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0UNSPECIFIED_TEST\0\u{1}BINARY_TEST\0\u{1}JSON_TEST\0\u{1}JSON_IGNORE_UNKNOWN_PARSING_TEST\0\u{1}JSPB_TEST\0\u{1}TEXT_FORMAT_TEST\0") +} + +extension Conformance_TestStatus: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestStatus" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}name\0\u{3}failure_message\0\u{3}matched_name\0") + + 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.name) }() + case 2: try { try decoder.decodeSingularStringField(value: &self.failureMessage) }() + case 3: try { try decoder.decodeSingularStringField(value: &self.matchedName) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.name.isEmpty { + try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) + } + if !self.failureMessage.isEmpty { + try visitor.visitSingularStringField(value: self.failureMessage, fieldNumber: 2) + } + if !self.matchedName.isEmpty { + try visitor.visitSingularStringField(value: self.matchedName, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: Conformance_TestStatus, rhs: Conformance_TestStatus) -> Bool { + if lhs.name != rhs.name {return false} + if lhs.failureMessage != rhs.failureMessage {return false} + if lhs.matchedName != rhs.matchedName {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } } extension Conformance_FailureSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".FailureSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "failure"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{2}test\0\u{c}\u{1}\u{1}") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -555,21 +499,21 @@ extension Conformance_FailureSet: SwiftProtobuf.Message, SwiftProtobuf._MessageI // 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.decodeRepeatedStringField(value: &self.failure) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.test) }() default: break } } } func traverse(visitor: inout V) throws { - if !self.failure.isEmpty { - try visitor.visitRepeatedStringField(value: self.failure, fieldNumber: 1) + if !self.test.isEmpty { + try visitor.visitRepeatedMessageField(value: self.test, fieldNumber: 2) } try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Conformance_FailureSet, rhs: Conformance_FailureSet) -> Bool { - if lhs.failure != rhs.failure {return false} + if lhs.test != rhs.test {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } @@ -577,17 +521,7 @@ extension Conformance_FailureSet: SwiftProtobuf.Message, SwiftProtobuf._MessageI extension Conformance_ConformanceRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ConformanceRequest" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "protobuf_payload"), - 2: .standard(proto: "json_payload"), - 7: .standard(proto: "jspb_payload"), - 8: .standard(proto: "text_payload"), - 3: .standard(proto: "requested_output_format"), - 4: .standard(proto: "message_type"), - 5: .standard(proto: "test_category"), - 6: .standard(proto: "jspb_encoding_options"), - 9: .standard(proto: "print_unknown_fields"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}protobuf_payload\0\u{3}json_payload\0\u{3}requested_output_format\0\u{3}message_type\0\u{3}test_category\0\u{3}jspb_encoding_options\0\u{3}jspb_payload\0\u{3}text_payload\0\u{3}print_unknown_fields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -696,16 +630,7 @@ extension Conformance_ConformanceRequest: SwiftProtobuf.Message, SwiftProtobuf._ extension Conformance_ConformanceResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ConformanceResponse" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "parse_error"), - 6: .standard(proto: "serialize_error"), - 2: .standard(proto: "runtime_error"), - 3: .standard(proto: "protobuf_payload"), - 4: .standard(proto: "json_payload"), - 5: .same(proto: "skipped"), - 7: .standard(proto: "jspb_payload"), - 8: .standard(proto: "text_payload"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}parse_error\0\u{3}runtime_error\0\u{3}protobuf_payload\0\u{3}json_payload\0\u{1}skipped\0\u{3}serialize_error\0\u{3}jspb_payload\0\u{3}text_payload\0\u{3}timeout_error\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -777,6 +702,14 @@ extension Conformance_ConformanceResponse: SwiftProtobuf.Message, SwiftProtobuf. self.result = .textPayload(v) } }() + case 9: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.result != nil {try decoder.handleConflictingOneOf()} + self.result = .timeoutError(v) + } + }() default: break } } @@ -820,6 +753,10 @@ extension Conformance_ConformanceResponse: SwiftProtobuf.Message, SwiftProtobuf. guard case .textPayload(let v)? = self.result else { preconditionFailure() } try visitor.visitSingularStringField(value: v, fieldNumber: 8) }() + case .timeoutError?: try { + guard case .timeoutError(let v)? = self.result else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 9) + }() case nil: break } try unknownFields.traverse(visitor: &visitor) @@ -834,9 +771,7 @@ extension Conformance_ConformanceResponse: SwiftProtobuf.Message, SwiftProtobuf. extension Conformance_JspbEncodingConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".JspbEncodingConfig" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "use_jspb_array_any_format"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}use_jspb_array_any_format\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { diff --git a/Sources/Conformance/failure_list_swift.txt b/Sources/Conformance/failure_list_swift.txt index 1c270799d..c0b6cb901 100644 --- a/Sources/Conformance/failure_list_swift.txt +++ b/Sources/Conformance/failure_list_swift.txt @@ -1 +1,4 @@ -# No known failures +# Tracking in #1798 +Recommended.*.JsonInput.FieldNameDuplicate # Should have failed to parse, but didn't. +Recommended.*.JsonInput.FieldNameDuplicateDifferentCasing1 # Should have failed to parse, but didn't. +Recommended.*.JsonInput.FieldNameDuplicateDifferentCasing2 # Should have failed to parse, but didn't. diff --git a/Sources/Conformance/main.swift b/Sources/Conformance/main.swift index ab13c1616..dc384d6a4 100644 --- a/Sources/Conformance/main.swift +++ b/Sources/Conformance/main.swift @@ -15,38 +15,56 @@ /// // ----------------------------------------------------------------------------- -#if os(Linux) -import Glibc -#else -import Darwin.C -#endif - import Foundation import SwiftProtobuf +extension FileHandle { + fileprivate func _read(count: Int) -> Data? { + if #available(macOS 10.15.4, *) { + do { + guard let result = try read(upToCount: count), + result.count == count + else { + return nil + } + return result + } catch { + return nil + } + } else { + let result = readData(ofLength: count) + guard result.count == count else { + return nil + } + return result + } + } +} + func readRequest() -> Data? { - var rawCount: UInt32 = 0 - let read1 = fread(&rawCount, 1, 4, stdin) - let count = Int(rawCount) - if read1 < 4 { + let stdIn = FileHandle.standardInput + guard let countLEData = stdIn._read(count: 4) else { return nil } - var buff = [UInt8](repeating: 0, count: count) - let read2 = fread(&buff, 1, count, stdin) - if read2 < count { + let countLE: UInt32 = countLEData.withUnsafeBytes { rawBuffer in + rawBuffer.loadUnaligned(as: UInt32.self) + } + let count = UInt32(littleEndian: countLE) + guard count < Int.max, + let result = stdIn._read(count: Int(count)) + else { return nil } - return Data(buff) + return result } func writeResponse(data: Data) { - let bytes = [UInt8](data) - var count = UInt32(bytes.count) - fwrite(&count, 4, 1, stdout) - _ = bytes.withUnsafeBufferPointer { bp in - fwrite(bp.baseAddress, Int(count), 1, stdout) - } - fflush(stdout) + let count = UInt32(data.count) + var countLE = count.littleEndian + let countLEData = Data(bytes: &countLE, count: MemoryLayout.size(ofValue: countLE)) + let stdOut = FileHandle.standardOutput + stdOut.write(countLEData) + stdOut.write(data) } func buildResponse(serializedData: Data) -> Conformance_ConformanceResponse { @@ -54,7 +72,7 @@ func buildResponse(serializedData: Data) -> Conformance_ConformanceResponse { let request: Conformance_ConformanceRequest do { - request = try Conformance_ConformanceRequest(serializedData: serializedData) + request = try Conformance_ConformanceRequest(serializedBytes: serializedData) } catch { response.runtimeError = "Failed to parse conformance request" return response @@ -79,13 +97,13 @@ func buildResponse(serializedData: Data) -> Conformance_ConformanceResponse { return response case .UNRECOGNIZED(let x): response.runtimeError = - "ConformanceRequest had a new testCategory (\(x)); regenerate conformance.pb.swift" - + " and see what support needs to be added." + "ConformanceRequest had a new testCategory (\(x)); regenerate conformance.pb.swift" + + " and see what support needs to be added." return response } - let msgType: SwiftProtobuf.Message.Type - let extensions: SwiftProtobuf.ExtensionMap + let msgType: any SwiftProtobuf.Message.Type + let extensions: any SwiftProtobuf.ExtensionMap switch request.messageType { case "": // Note: This case is here to cover using a old version of the conformance test @@ -97,16 +115,25 @@ func buildResponse(serializedData: Data) -> Conformance_ConformanceResponse { case ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName: msgType = ProtobufTestMessages_Proto2_TestAllTypesProto2.self extensions = ProtobufTestMessages_Proto2_TestMessagesProto2_Extensions + case ProtobufTestMessages_Editions_TestAllTypesEdition2023.protoMessageName: + msgType = ProtobufTestMessages_Editions_TestAllTypesEdition2023.self + extensions = ProtobufTestMessages_Editions_TestMessagesEdition2023_Extensions + case ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.protoMessageName: + msgType = ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.self + extensions = SwiftProtobuf.SimpleExtensionMap() + case ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName: + msgType = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.self + extensions = ProtobufTestMessages_Editions_Proto2_TestMessagesProto2Editions_Extensions default: response.runtimeError = "Unexpected message type: \(request.messageType)" return response } - let testMessage: SwiftProtobuf.Message + let testMessage: any SwiftProtobuf.Message switch request.payload { case .protobufPayload(let data)?: do { - testMessage = try msgType.init(serializedData: data, extensions: extensions) + testMessage = try msgType.init(serializedBytes: data, extensions: extensions) } catch let e { response.parseError = "Protobuf failed to parse: \(e)" return response @@ -115,9 +142,11 @@ func buildResponse(serializedData: Data) -> Conformance_ConformanceResponse { var options = JSONDecodingOptions() options.ignoreUnknownFields = (request.testCategory == .jsonIgnoreUnknownParsingTest) do { - testMessage = try msgType.init(jsonString: json, - extensions: extensions, - options: options) + testMessage = try msgType.init( + jsonString: json, + extensions: extensions, + options: options + ) } catch let e { response.parseError = "JSON failed to parse: \(e)" return response @@ -131,7 +160,7 @@ func buildResponse(serializedData: Data) -> Conformance_ConformanceResponse { do { testMessage = try msgType.init(textFormatString: textFormat, extensions: extensions) } catch let e { - response.parseError = "Protobuf failed to parse: \(e)" + response.parseError = "TextFormat failed to parse: \(e)" return response } case nil: @@ -142,7 +171,7 @@ func buildResponse(serializedData: Data) -> Conformance_ConformanceResponse { switch request.requestedOutputFormat { case .protobuf: do { - response.protobufPayload = try testMessage.serializedData() + response.protobufPayload = try testMessage.serializedBytes() } catch let e { response.serializeError = "Failed to serialize: \(e)" } @@ -169,18 +198,18 @@ func buildResponse(serializedData: Data) -> Conformance_ConformanceResponse { } func singleTest() throws -> Bool { - if let indata = readRequest() { - let response = buildResponse(serializedData: indata) - let outdata = try response.serializedData() - writeResponse(data: outdata) - return true - } else { - return false - } + if let indata = readRequest() { + let response = buildResponse(serializedData: indata) + let outdata: Data = try response.serializedData() + writeResponse(data: outdata) + return true + } else { + return false + } } Google_Protobuf_Any.register(messageType: ProtobufTestMessages_Proto3_TestAllTypesProto3.self) +Google_Protobuf_Any.register(messageType: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.self) while try singleTest() { } - diff --git a/Sources/Conformance/test_messages_edition2023.pb.swift b/Sources/Conformance/test_messages_edition2023.pb.swift new file mode 100644 index 000000000..e9601952b --- /dev/null +++ b/Sources/Conformance/test_messages_edition2023.pb.swift @@ -0,0 +1,2073 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: conformance/test_protos/test_messages_edition2023.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protocol Buffers - Google's data interchange format +// Copyright 2024 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd + +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 ProtobufTestMessages_Editions_ForeignEnumEdition2023: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foreignFoo // = 0 + case foreignBar // = 1 + case foreignBaz // = 2 + case UNRECOGNIZED(Int) + + init() { + self = .foreignFoo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .foreignFoo + case 1: self = .foreignBar + case 2: self = .foreignBaz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .foreignFoo: return 0 + case .foreignBar: return 1 + case .foreignBaz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Editions_ForeignEnumEdition2023] = [ + .foreignFoo, + .foreignBar, + .foreignBaz, + ] + +} + +struct ProtobufTestMessages_Editions_ComplexMessage: Sendable { + // 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 d: Int32 { + get {_d ?? 0} + set {_d = newValue} + } + /// Returns true if `d` has been explicitly set. + var hasD: Bool {self._d != nil} + /// Clears the value of `d`. Subsequent reads from it will return its default value. + mutating func clearD() {self._d = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _d: Int32? = nil +} + +struct ProtobufTestMessages_Editions_TestAllTypesEdition2023: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Singular + var optionalInt32: Int32 { + get {_storage._optionalInt32 ?? 0} + set {_uniqueStorage()._optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} + + var optionalInt64: Int64 { + get {_storage._optionalInt64 ?? 0} + set {_uniqueStorage()._optionalInt64 = newValue} + } + /// Returns true if `optionalInt64` has been explicitly set. + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} + /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} + + var optionalUint32: UInt32 { + get {_storage._optionalUint32 ?? 0} + set {_uniqueStorage()._optionalUint32 = newValue} + } + /// Returns true if `optionalUint32` has been explicitly set. + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} + /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} + + var optionalUint64: UInt64 { + get {_storage._optionalUint64 ?? 0} + set {_uniqueStorage()._optionalUint64 = newValue} + } + /// Returns true if `optionalUint64` has been explicitly set. + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} + /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} + + var optionalSint32: Int32 { + get {_storage._optionalSint32 ?? 0} + set {_uniqueStorage()._optionalSint32 = newValue} + } + /// Returns true if `optionalSint32` has been explicitly set. + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} + /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} + + var optionalSint64: Int64 { + get {_storage._optionalSint64 ?? 0} + set {_uniqueStorage()._optionalSint64 = newValue} + } + /// Returns true if `optionalSint64` has been explicitly set. + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} + /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} + + var optionalFixed32: UInt32 { + get {_storage._optionalFixed32 ?? 0} + set {_uniqueStorage()._optionalFixed32 = newValue} + } + /// Returns true if `optionalFixed32` has been explicitly set. + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} + /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} + + var optionalFixed64: UInt64 { + get {_storage._optionalFixed64 ?? 0} + set {_uniqueStorage()._optionalFixed64 = newValue} + } + /// Returns true if `optionalFixed64` has been explicitly set. + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} + /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} + + var optionalSfixed32: Int32 { + get {_storage._optionalSfixed32 ?? 0} + set {_uniqueStorage()._optionalSfixed32 = newValue} + } + /// Returns true if `optionalSfixed32` has been explicitly set. + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} + /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} + + var optionalSfixed64: Int64 { + get {_storage._optionalSfixed64 ?? 0} + set {_uniqueStorage()._optionalSfixed64 = newValue} + } + /// Returns true if `optionalSfixed64` has been explicitly set. + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} + /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} + + var optionalFloat: Float { + get {_storage._optionalFloat ?? 0} + set {_uniqueStorage()._optionalFloat = newValue} + } + /// Returns true if `optionalFloat` has been explicitly set. + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} + /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} + + var optionalDouble: Double { + get {_storage._optionalDouble ?? 0} + set {_uniqueStorage()._optionalDouble = newValue} + } + /// Returns true if `optionalDouble` has been explicitly set. + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} + /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. + mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} + + var optionalBool: Bool { + get {_storage._optionalBool ?? false} + set {_uniqueStorage()._optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {_storage._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} + + var optionalString: String { + get {_storage._optionalString ?? String()} + set {_uniqueStorage()._optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {_storage._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} + + var optionalBytes: Data { + get {_storage._optionalBytes ?? Data()} + set {_uniqueStorage()._optionalBytes = newValue} + } + /// Returns true if `optionalBytes` has been explicitly set. + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} + /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} + + var optionalNestedMessage: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage { + get {_storage._optionalNestedMessage ?? ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage()} + set {_uniqueStorage()._optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} + + var optionalForeignMessage: ProtobufTestMessages_Editions_ForeignMessageEdition2023 { + get {_storage._optionalForeignMessage ?? ProtobufTestMessages_Editions_ForeignMessageEdition2023()} + set {_uniqueStorage()._optionalForeignMessage = newValue} + } + /// Returns true if `optionalForeignMessage` has been explicitly set. + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} + /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} + + var optionalNestedEnum: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum { + get {_storage._optionalNestedEnum ?? .foo} + set {_uniqueStorage()._optionalNestedEnum = newValue} + } + /// Returns true if `optionalNestedEnum` has been explicitly set. + var hasOptionalNestedEnum: Bool {_storage._optionalNestedEnum != nil} + /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} + + var optionalForeignEnum: ProtobufTestMessages_Editions_ForeignEnumEdition2023 { + get {_storage._optionalForeignEnum ?? .foreignFoo} + set {_uniqueStorage()._optionalForeignEnum = newValue} + } + /// Returns true if `optionalForeignEnum` has been explicitly set. + var hasOptionalForeignEnum: Bool {_storage._optionalForeignEnum != nil} + /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignEnum() {_uniqueStorage()._optionalForeignEnum = nil} + + var optionalStringPiece: String { + get {_storage._optionalStringPiece ?? String()} + set {_uniqueStorage()._optionalStringPiece = newValue} + } + /// Returns true if `optionalStringPiece` has been explicitly set. + var hasOptionalStringPiece: Bool {_storage._optionalStringPiece != nil} + /// Clears the value of `optionalStringPiece`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringPiece() {_uniqueStorage()._optionalStringPiece = nil} + + var optionalCord: String { + get {_storage._optionalCord ?? String()} + set {_uniqueStorage()._optionalCord = newValue} + } + /// Returns true if `optionalCord` has been explicitly set. + var hasOptionalCord: Bool {_storage._optionalCord != nil} + /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. + mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} + + var recursiveMessage: ProtobufTestMessages_Editions_TestAllTypesEdition2023 { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Editions_TestAllTypesEdition2023()} + set {_uniqueStorage()._recursiveMessage = newValue} + } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} + + /// Repeated + var repeatedInt32: [Int32] { + get {_storage._repeatedInt32} + set {_uniqueStorage()._repeatedInt32 = newValue} + } + + var repeatedInt64: [Int64] { + get {_storage._repeatedInt64} + set {_uniqueStorage()._repeatedInt64 = newValue} + } + + var repeatedUint32: [UInt32] { + get {_storage._repeatedUint32} + set {_uniqueStorage()._repeatedUint32 = newValue} + } + + var repeatedUint64: [UInt64] { + get {_storage._repeatedUint64} + set {_uniqueStorage()._repeatedUint64 = newValue} + } + + var repeatedSint32: [Int32] { + get {_storage._repeatedSint32} + set {_uniqueStorage()._repeatedSint32 = newValue} + } + + var repeatedSint64: [Int64] { + get {_storage._repeatedSint64} + set {_uniqueStorage()._repeatedSint64 = newValue} + } + + var repeatedFixed32: [UInt32] { + get {_storage._repeatedFixed32} + set {_uniqueStorage()._repeatedFixed32 = newValue} + } + + var repeatedFixed64: [UInt64] { + get {_storage._repeatedFixed64} + set {_uniqueStorage()._repeatedFixed64 = newValue} + } + + var repeatedSfixed32: [Int32] { + get {_storage._repeatedSfixed32} + set {_uniqueStorage()._repeatedSfixed32 = newValue} + } + + var repeatedSfixed64: [Int64] { + get {_storage._repeatedSfixed64} + set {_uniqueStorage()._repeatedSfixed64 = newValue} + } + + var repeatedFloat: [Float] { + get {_storage._repeatedFloat} + set {_uniqueStorage()._repeatedFloat = newValue} + } + + var repeatedDouble: [Double] { + get {_storage._repeatedDouble} + set {_uniqueStorage()._repeatedDouble = newValue} + } + + var repeatedBool: [Bool] { + get {_storage._repeatedBool} + set {_uniqueStorage()._repeatedBool = newValue} + } + + var repeatedString: [String] { + get {_storage._repeatedString} + set {_uniqueStorage()._repeatedString = newValue} + } + + var repeatedBytes: [Data] { + get {_storage._repeatedBytes} + set {_uniqueStorage()._repeatedBytes = newValue} + } + + var repeatedNestedMessage: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage] { + get {_storage._repeatedNestedMessage} + set {_uniqueStorage()._repeatedNestedMessage = newValue} + } + + var repeatedForeignMessage: [ProtobufTestMessages_Editions_ForeignMessageEdition2023] { + get {_storage._repeatedForeignMessage} + set {_uniqueStorage()._repeatedForeignMessage = newValue} + } + + var repeatedNestedEnum: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] { + get {_storage._repeatedNestedEnum} + set {_uniqueStorage()._repeatedNestedEnum = newValue} + } + + var repeatedForeignEnum: [ProtobufTestMessages_Editions_ForeignEnumEdition2023] { + get {_storage._repeatedForeignEnum} + set {_uniqueStorage()._repeatedForeignEnum = newValue} + } + + var repeatedStringPiece: [String] { + get {_storage._repeatedStringPiece} + set {_uniqueStorage()._repeatedStringPiece = newValue} + } + + var repeatedCord: [String] { + get {_storage._repeatedCord} + set {_uniqueStorage()._repeatedCord = newValue} + } + + /// Packed + var packedInt32: [Int32] { + get {_storage._packedInt32} + set {_uniqueStorage()._packedInt32 = newValue} + } + + var packedInt64: [Int64] { + get {_storage._packedInt64} + set {_uniqueStorage()._packedInt64 = newValue} + } + + var packedUint32: [UInt32] { + get {_storage._packedUint32} + set {_uniqueStorage()._packedUint32 = newValue} + } + + var packedUint64: [UInt64] { + get {_storage._packedUint64} + set {_uniqueStorage()._packedUint64 = newValue} + } + + var packedSint32: [Int32] { + get {_storage._packedSint32} + set {_uniqueStorage()._packedSint32 = newValue} + } + + var packedSint64: [Int64] { + get {_storage._packedSint64} + set {_uniqueStorage()._packedSint64 = newValue} + } + + var packedFixed32: [UInt32] { + get {_storage._packedFixed32} + set {_uniqueStorage()._packedFixed32 = newValue} + } + + var packedFixed64: [UInt64] { + get {_storage._packedFixed64} + set {_uniqueStorage()._packedFixed64 = newValue} + } + + var packedSfixed32: [Int32] { + get {_storage._packedSfixed32} + set {_uniqueStorage()._packedSfixed32 = newValue} + } + + var packedSfixed64: [Int64] { + get {_storage._packedSfixed64} + set {_uniqueStorage()._packedSfixed64 = newValue} + } + + var packedFloat: [Float] { + get {_storage._packedFloat} + set {_uniqueStorage()._packedFloat = newValue} + } + + var packedDouble: [Double] { + get {_storage._packedDouble} + set {_uniqueStorage()._packedDouble = newValue} + } + + var packedBool: [Bool] { + get {_storage._packedBool} + set {_uniqueStorage()._packedBool = newValue} + } + + var packedNestedEnum: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] { + get {_storage._packedNestedEnum} + set {_uniqueStorage()._packedNestedEnum = newValue} + } + + /// Unpacked + var unpackedInt32: [Int32] { + get {_storage._unpackedInt32} + set {_uniqueStorage()._unpackedInt32 = newValue} + } + + var unpackedInt64: [Int64] { + get {_storage._unpackedInt64} + set {_uniqueStorage()._unpackedInt64 = newValue} + } + + var unpackedUint32: [UInt32] { + get {_storage._unpackedUint32} + set {_uniqueStorage()._unpackedUint32 = newValue} + } + + var unpackedUint64: [UInt64] { + get {_storage._unpackedUint64} + set {_uniqueStorage()._unpackedUint64 = newValue} + } + + var unpackedSint32: [Int32] { + get {_storage._unpackedSint32} + set {_uniqueStorage()._unpackedSint32 = newValue} + } + + var unpackedSint64: [Int64] { + get {_storage._unpackedSint64} + set {_uniqueStorage()._unpackedSint64 = newValue} + } + + var unpackedFixed32: [UInt32] { + get {_storage._unpackedFixed32} + set {_uniqueStorage()._unpackedFixed32 = newValue} + } + + var unpackedFixed64: [UInt64] { + get {_storage._unpackedFixed64} + set {_uniqueStorage()._unpackedFixed64 = newValue} + } + + var unpackedSfixed32: [Int32] { + get {_storage._unpackedSfixed32} + set {_uniqueStorage()._unpackedSfixed32 = newValue} + } + + var unpackedSfixed64: [Int64] { + get {_storage._unpackedSfixed64} + set {_uniqueStorage()._unpackedSfixed64 = newValue} + } + + var unpackedFloat: [Float] { + get {_storage._unpackedFloat} + set {_uniqueStorage()._unpackedFloat = newValue} + } + + var unpackedDouble: [Double] { + get {_storage._unpackedDouble} + set {_uniqueStorage()._unpackedDouble = newValue} + } + + var unpackedBool: [Bool] { + get {_storage._unpackedBool} + set {_uniqueStorage()._unpackedBool = newValue} + } + + var unpackedNestedEnum: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] { + get {_storage._unpackedNestedEnum} + set {_uniqueStorage()._unpackedNestedEnum = newValue} + } + + /// Map + var mapInt32Int32: Dictionary { + get {_storage._mapInt32Int32} + set {_uniqueStorage()._mapInt32Int32 = newValue} + } + + var mapInt64Int64: Dictionary { + get {_storage._mapInt64Int64} + set {_uniqueStorage()._mapInt64Int64 = newValue} + } + + var mapUint32Uint32: Dictionary { + get {_storage._mapUint32Uint32} + set {_uniqueStorage()._mapUint32Uint32 = newValue} + } + + var mapUint64Uint64: Dictionary { + get {_storage._mapUint64Uint64} + set {_uniqueStorage()._mapUint64Uint64 = newValue} + } + + var mapSint32Sint32: Dictionary { + get {_storage._mapSint32Sint32} + set {_uniqueStorage()._mapSint32Sint32 = newValue} + } + + var mapSint64Sint64: Dictionary { + get {_storage._mapSint64Sint64} + set {_uniqueStorage()._mapSint64Sint64 = newValue} + } + + var mapFixed32Fixed32: Dictionary { + get {_storage._mapFixed32Fixed32} + set {_uniqueStorage()._mapFixed32Fixed32 = newValue} + } + + var mapFixed64Fixed64: Dictionary { + get {_storage._mapFixed64Fixed64} + set {_uniqueStorage()._mapFixed64Fixed64 = newValue} + } + + var mapSfixed32Sfixed32: Dictionary { + get {_storage._mapSfixed32Sfixed32} + set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} + } + + var mapSfixed64Sfixed64: Dictionary { + get {_storage._mapSfixed64Sfixed64} + set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} + } + + var mapInt32Float: Dictionary { + get {_storage._mapInt32Float} + set {_uniqueStorage()._mapInt32Float = newValue} + } + + var mapInt32Double: Dictionary { + get {_storage._mapInt32Double} + set {_uniqueStorage()._mapInt32Double = newValue} + } + + var mapBoolBool: Dictionary { + get {_storage._mapBoolBool} + set {_uniqueStorage()._mapBoolBool = newValue} + } + + var mapStringString: Dictionary { + get {_storage._mapStringString} + set {_uniqueStorage()._mapStringString = newValue} + } + + var mapStringBytes: Dictionary { + get {_storage._mapStringBytes} + set {_uniqueStorage()._mapStringBytes = newValue} + } + + var mapStringNestedMessage: Dictionary { + get {_storage._mapStringNestedMessage} + set {_uniqueStorage()._mapStringNestedMessage = newValue} + } + + var mapStringForeignMessage: Dictionary { + get {_storage._mapStringForeignMessage} + set {_uniqueStorage()._mapStringForeignMessage = newValue} + } + + var mapStringNestedEnum: Dictionary { + get {_storage._mapStringNestedEnum} + set {_uniqueStorage()._mapStringNestedEnum = newValue} + } + + var mapStringForeignEnum: Dictionary { + get {_storage._mapStringForeignEnum} + set {_uniqueStorage()._mapStringForeignEnum = newValue} + } + + var oneofField: OneOf_OneofField? { + get {return _storage._oneofField} + set {_uniqueStorage()._oneofField = newValue} + } + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} + } + + var oneofNestedMessage: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage { + get { + if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} + return ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = _storage._oneofField {return v} + return Data() + } + set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} + } + + var oneofBool: Bool { + get { + if case .oneofBool(let v)? = _storage._oneofField {return v} + return false + } + set {_uniqueStorage()._oneofField = .oneofBool(newValue)} + } + + var oneofUint64: UInt64 { + get { + if case .oneofUint64(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint64(newValue)} + } + + var oneofFloat: Float { + get { + if case .oneofFloat(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofFloat(newValue)} + } + + var oneofDouble: Double { + get { + if case .oneofDouble(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofDouble(newValue)} + } + + var oneofEnum: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum { + get { + if case .oneofEnum(let v)? = _storage._oneofField {return v} + return .foo + } + set {_uniqueStorage()._oneofField = .oneofEnum(newValue)} + } + + var groupLikeType: ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType { + get {_storage._groupLikeType ?? ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType()} + set {_uniqueStorage()._groupLikeType = newValue} + } + /// Returns true if `groupLikeType` has been explicitly set. + var hasGroupLikeType: Bool {_storage._groupLikeType != nil} + /// Clears the value of `groupLikeType`. Subsequent reads from it will return its default value. + mutating func clearGroupLikeType() {_uniqueStorage()._groupLikeType = nil} + + var delimitedField: ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType { + get {_storage._delimitedField ?? ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType()} + set {_uniqueStorage()._delimitedField = newValue} + } + /// Returns true if `delimitedField` has been explicitly set. + var hasDelimitedField: Bool {_storage._delimitedField != nil} + /// Clears the value of `delimitedField`. Subsequent reads from it will return its default value. + mutating func clearDelimitedField() {_uniqueStorage()._delimitedField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofNestedMessage(ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage) + case oneofString(String) + case oneofBytes(Data) + case oneofBool(Bool) + case oneofUint64(UInt64) + case oneofFloat(Float) + case oneofDouble(Double) + case oneofEnum(ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum) + + fileprivate var isInitialized: Bool { + guard case .oneofNestedMessage(let v) = self else {return true} + return v.isInitialized + } + + } + + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foo // = 0 + case bar // = 1 + case baz // = 2 + + /// Intentionally negative. + case neg // = -1 + case UNRECOGNIZED(Int) + + init() { + self = .foo + } + + init?(rawValue: Int) { + switch rawValue { + case -1: self = .neg + case 0: self = .foo + case 1: self = .bar + case 2: self = .baz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .neg: return -1 + case .foo: return 0 + case .bar: return 1 + case .baz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] = [ + .foo, + .bar, + .baz, + .neg, + ] + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var corecursive: ProtobufTestMessages_Editions_TestAllTypesEdition2023 { + get {_storage._corecursive ?? ProtobufTestMessages_Editions_TestAllTypesEdition2023()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + /// groups + struct GroupLikeType: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct ProtobufTestMessages_Editions_ForeignMessageEdition2023: Sendable { + // 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 c: Int32 { + get {_c ?? 0} + set {_c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {self._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {self._c = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _c: Int32? = nil +} + +struct ProtobufTestMessages_Editions_GroupLikeType: Sendable { + // 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 c: Int32 { + get {_c ?? 0} + set {_c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {self._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {self._c = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _c: Int32? = nil +} + +// MARK: - Extension support defined in test_messages_edition2023.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 ProtobufTestMessages_Editions_TestAllTypesEdition2023 { + + var ProtobufTestMessages_Editions_extensionInt32: Int32 { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_extension_int32) ?? 0} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_extension_int32, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Extensions_extension_int32` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_extensionInt32: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_extension_int32) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Extensions_extension_int32`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_extensionInt32() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_extension_int32) + } + + var ProtobufTestMessages_Editions_groupLikeType: ProtobufTestMessages_Editions_GroupLikeType { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_GroupLikeType) ?? ProtobufTestMessages_Editions_GroupLikeType()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_GroupLikeType, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Extensions_GroupLikeType` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_groupLikeType: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_GroupLikeType) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Extensions_GroupLikeType`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_groupLikeType() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_GroupLikeType) + } + + var ProtobufTestMessages_Editions_delimitedExt: ProtobufTestMessages_Editions_GroupLikeType { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_delimited_ext) ?? ProtobufTestMessages_Editions_GroupLikeType()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_delimited_ext, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Extensions_delimited_ext` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_delimitedExt: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_delimited_ext) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Extensions_delimited_ext`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_delimitedExt() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Extensions_delimited_ext) + } + +} + +// MARK: - File's ExtensionMap: ProtobufTestMessages_Editions_TestMessagesEdition2023_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 ProtobufTestMessages_Editions_TestMessagesEdition2023_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + ProtobufTestMessages_Editions_Extensions_extension_int32, + ProtobufTestMessages_Editions_Extensions_GroupLikeType, + ProtobufTestMessages_Editions_Extensions_delimited_ext +] + +// 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 ProtobufTestMessages_Editions_Extensions_extension_int32 = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_TestAllTypesEdition2023>( + _protobuf_fieldNumber: 120, + fieldName: "protobuf_test_messages.editions.extension_int32" +) + +let ProtobufTestMessages_Editions_Extensions_GroupLikeType = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_TestAllTypesEdition2023>( + _protobuf_fieldNumber: 121, + fieldName: "protobuf_test_messages.editions.groupliketype" +) + +let ProtobufTestMessages_Editions_Extensions_delimited_ext = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_TestAllTypesEdition2023>( + _protobuf_fieldNumber: 122, + fieldName: "protobuf_test_messages.editions.delimited_ext" +) + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "protobuf_test_messages.editions" + +extension ProtobufTestMessages_Editions_ForeignEnumEdition2023: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") +} + +extension ProtobufTestMessages_Editions_ComplexMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ComplexMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}d\0") + + 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._d) }() + 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 + try { if let v = self._d { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_ComplexMessage, rhs: ProtobufTestMessages_Editions_ComplexMessage) -> Bool { + if lhs._d != rhs._d {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_TestAllTypesEdition2023: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypesEdition2023" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{4}\u{2}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{4}\u{2}optional_string_piece\0\u{3}optional_cord\0\u{4}\u{2}recursive_message\0\u{4}\u{4}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{4}\u{2}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_nested_message\0\u{3}map_string_foreign_message\0\u{3}map_string_nested_enum\0\u{3}map_string_foreign_enum\0\u{3}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_nested_enum\0\u{3}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_nested_enum\0\u{4}\u{9}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_bool\0\u{3}oneof_uint64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_enum\0\u{8}R\u{1}GroupLikeType\0\u{3}delimited_field\0") + + fileprivate class _StorageClass { + var _optionalInt32: Int32? = nil + var _optionalInt64: Int64? = nil + var _optionalUint32: UInt32? = nil + var _optionalUint64: UInt64? = nil + var _optionalSint32: Int32? = nil + var _optionalSint64: Int64? = nil + var _optionalFixed32: UInt32? = nil + var _optionalFixed64: UInt64? = nil + var _optionalSfixed32: Int32? = nil + var _optionalSfixed64: Int64? = nil + var _optionalFloat: Float? = nil + var _optionalDouble: Double? = nil + var _optionalBool: Bool? = nil + var _optionalString: String? = nil + var _optionalBytes: Data? = nil + var _optionalNestedMessage: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage? = nil + var _optionalForeignMessage: ProtobufTestMessages_Editions_ForeignMessageEdition2023? = nil + var _optionalNestedEnum: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum? = nil + var _optionalForeignEnum: ProtobufTestMessages_Editions_ForeignEnumEdition2023? = nil + var _optionalStringPiece: String? = nil + var _optionalCord: String? = nil + var _recursiveMessage: ProtobufTestMessages_Editions_TestAllTypesEdition2023? = nil + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedNestedMessage: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage] = [] + var _repeatedForeignMessage: [ProtobufTestMessages_Editions_ForeignMessageEdition2023] = [] + var _repeatedNestedEnum: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] = [] + var _repeatedForeignEnum: [ProtobufTestMessages_Editions_ForeignEnumEdition2023] = [] + var _repeatedStringPiece: [String] = [] + var _repeatedCord: [String] = [] + var _packedInt32: [Int32] = [] + var _packedInt64: [Int64] = [] + var _packedUint32: [UInt32] = [] + var _packedUint64: [UInt64] = [] + var _packedSint32: [Int32] = [] + var _packedSint64: [Int64] = [] + var _packedFixed32: [UInt32] = [] + var _packedFixed64: [UInt64] = [] + var _packedSfixed32: [Int32] = [] + var _packedSfixed64: [Int64] = [] + var _packedFloat: [Float] = [] + var _packedDouble: [Double] = [] + var _packedBool: [Bool] = [] + var _packedNestedEnum: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] = [] + var _unpackedInt32: [Int32] = [] + var _unpackedInt64: [Int64] = [] + var _unpackedUint32: [UInt32] = [] + var _unpackedUint64: [UInt64] = [] + var _unpackedSint32: [Int32] = [] + var _unpackedSint64: [Int64] = [] + var _unpackedFixed32: [UInt32] = [] + var _unpackedFixed64: [UInt64] = [] + var _unpackedSfixed32: [Int32] = [] + var _unpackedSfixed64: [Int64] = [] + var _unpackedFloat: [Float] = [] + var _unpackedDouble: [Double] = [] + var _unpackedBool: [Bool] = [] + var _unpackedNestedEnum: [ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum] = [] + var _mapInt32Int32: Dictionary = [:] + var _mapInt64Int64: Dictionary = [:] + var _mapUint32Uint32: Dictionary = [:] + var _mapUint64Uint64: Dictionary = [:] + var _mapSint32Sint32: Dictionary = [:] + var _mapSint64Sint64: Dictionary = [:] + var _mapFixed32Fixed32: Dictionary = [:] + var _mapFixed64Fixed64: Dictionary = [:] + var _mapSfixed32Sfixed32: Dictionary = [:] + var _mapSfixed64Sfixed64: Dictionary = [:] + var _mapInt32Float: Dictionary = [:] + var _mapInt32Double: Dictionary = [:] + var _mapBoolBool: Dictionary = [:] + var _mapStringString: Dictionary = [:] + var _mapStringBytes: Dictionary = [:] + var _mapStringNestedMessage: Dictionary = [:] + var _mapStringForeignMessage: Dictionary = [:] + var _mapStringNestedEnum: Dictionary = [:] + var _mapStringForeignEnum: Dictionary = [:] + var _oneofField: ProtobufTestMessages_Editions_TestAllTypesEdition2023.OneOf_OneofField? + var _groupLikeType: ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType? = nil + var _delimitedField: ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalNestedMessage = source._optionalNestedMessage + _optionalForeignMessage = source._optionalForeignMessage + _optionalNestedEnum = source._optionalNestedEnum + _optionalForeignEnum = source._optionalForeignEnum + _optionalStringPiece = source._optionalStringPiece + _optionalCord = source._optionalCord + _recursiveMessage = source._recursiveMessage + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedForeignMessage = source._repeatedForeignMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _repeatedForeignEnum = source._repeatedForeignEnum + _repeatedStringPiece = source._repeatedStringPiece + _repeatedCord = source._repeatedCord + _packedInt32 = source._packedInt32 + _packedInt64 = source._packedInt64 + _packedUint32 = source._packedUint32 + _packedUint64 = source._packedUint64 + _packedSint32 = source._packedSint32 + _packedSint64 = source._packedSint64 + _packedFixed32 = source._packedFixed32 + _packedFixed64 = source._packedFixed64 + _packedSfixed32 = source._packedSfixed32 + _packedSfixed64 = source._packedSfixed64 + _packedFloat = source._packedFloat + _packedDouble = source._packedDouble + _packedBool = source._packedBool + _packedNestedEnum = source._packedNestedEnum + _unpackedInt32 = source._unpackedInt32 + _unpackedInt64 = source._unpackedInt64 + _unpackedUint32 = source._unpackedUint32 + _unpackedUint64 = source._unpackedUint64 + _unpackedSint32 = source._unpackedSint32 + _unpackedSint64 = source._unpackedSint64 + _unpackedFixed32 = source._unpackedFixed32 + _unpackedFixed64 = source._unpackedFixed64 + _unpackedSfixed32 = source._unpackedSfixed32 + _unpackedSfixed64 = source._unpackedSfixed64 + _unpackedFloat = source._unpackedFloat + _unpackedDouble = source._unpackedDouble + _unpackedBool = source._unpackedBool + _unpackedNestedEnum = source._unpackedNestedEnum + _mapInt32Int32 = source._mapInt32Int32 + _mapInt64Int64 = source._mapInt64Int64 + _mapUint32Uint32 = source._mapUint32Uint32 + _mapUint64Uint64 = source._mapUint64Uint64 + _mapSint32Sint32 = source._mapSint32Sint32 + _mapSint64Sint64 = source._mapSint64Sint64 + _mapFixed32Fixed32 = source._mapFixed32Fixed32 + _mapFixed64Fixed64 = source._mapFixed64Fixed64 + _mapSfixed32Sfixed32 = source._mapSfixed32Sfixed32 + _mapSfixed64Sfixed64 = source._mapSfixed64Sfixed64 + _mapInt32Float = source._mapInt32Float + _mapInt32Double = source._mapInt32Double + _mapBoolBool = source._mapBoolBool + _mapStringString = source._mapStringString + _mapStringBytes = source._mapStringBytes + _mapStringNestedMessage = source._mapStringNestedMessage + _mapStringForeignMessage = source._mapStringForeignMessage + _mapStringNestedEnum = source._mapStringNestedEnum + _mapStringForeignEnum = source._mapStringForeignEnum + _oneofField = source._oneofField + _groupLikeType = source._groupLikeType + _delimitedField = source._delimitedField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._optionalNestedMessage, !v.isInitialized {return false} + if let v = _storage._recursiveMessage, !v.isInitialized {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._repeatedNestedMessage) {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._mapStringNestedMessage) {return false} + if let v = _storage._oneofField, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() + case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() + case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() + case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() + case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() + case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() + case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() + case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() + case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() + case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() + case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() + case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() + case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() + case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() + case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() + case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() + case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() + case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() + case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() + case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() + case 56: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Int32) }() + case 57: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() + case 58: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() + case 59: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Uint64) }() + case 60: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Sint32) }() + case 61: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Sint64) }() + case 62: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Fixed32) }() + case 63: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Fixed64) }() + case 64: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Sfixed32) }() + case 65: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Sfixed64) }() + case 66: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Float) }() + case 67: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Double) }() + case 68: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() + case 69: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() + case 70: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() + case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringNestedMessage) }() + case 72: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() + case 73: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringNestedEnum) }() + case 74: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringForeignEnum) }() + case 75: try { try decoder.decodeRepeatedInt32Field(value: &_storage._packedInt32) }() + case 76: try { try decoder.decodeRepeatedInt64Field(value: &_storage._packedInt64) }() + case 77: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._packedUint32) }() + case 78: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._packedUint64) }() + case 79: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._packedSint32) }() + case 80: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._packedSint64) }() + case 81: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._packedFixed32) }() + case 82: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._packedFixed64) }() + case 83: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._packedSfixed32) }() + case 84: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._packedSfixed64) }() + case 85: try { try decoder.decodeRepeatedFloatField(value: &_storage._packedFloat) }() + case 86: try { try decoder.decodeRepeatedDoubleField(value: &_storage._packedDouble) }() + case 87: try { try decoder.decodeRepeatedBoolField(value: &_storage._packedBool) }() + case 88: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedNestedEnum) }() + case 89: try { try decoder.decodeRepeatedInt32Field(value: &_storage._unpackedInt32) }() + case 90: try { try decoder.decodeRepeatedInt64Field(value: &_storage._unpackedInt64) }() + case 91: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._unpackedUint32) }() + case 92: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._unpackedUint64) }() + case 93: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._unpackedSint32) }() + case 94: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._unpackedSint64) }() + case 95: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._unpackedFixed32) }() + case 96: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._unpackedFixed64) }() + case 97: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._unpackedSfixed32) }() + case 98: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._unpackedSfixed64) }() + case 99: try { try decoder.decodeRepeatedFloatField(value: &_storage._unpackedFloat) }() + case 100: try { try decoder.decodeRepeatedDoubleField(value: &_storage._unpackedDouble) }() + case 101: try { try decoder.decodeRepeatedBoolField(value: &_storage._unpackedBool) }() + case 102: try { try decoder.decodeRepeatedEnumField(value: &_storage._unpackedNestedEnum) }() + case 111: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 112: try { + var v: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage(v) + } + }() + case 113: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 114: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() + case 115: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBool(v) + } + }() + case 116: try { + var v: UInt64? + try decoder.decodeSingularUInt64Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint64(v) + } + }() + case 117: try { + var v: Float? + try decoder.decodeSingularFloatField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofFloat(v) + } + }() + case 118: try { + var v: Double? + try decoder.decodeSingularDoubleField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofDouble(v) + } + }() + case 119: try { + var v: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofEnum(v) + } + }() + case 201: try { try decoder.decodeSingularGroupField(value: &_storage._groupLikeType) }() + case 202: try { try decoder.decodeSingularGroupField(value: &_storage._delimitedField) }() + case 120..<201: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Editions_TestAllTypesEdition2023.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._optionalInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._optionalUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._optionalSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._optionalSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._optionalFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._optionalFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._optionalSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._optionalSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._optionalFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._optionalDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._optionalBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._optionalForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._optionalNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._optionalForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._optionalStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._optionalCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + if !_storage._repeatedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + } + if !_storage._repeatedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + } + if !_storage._repeatedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + } + if !_storage._repeatedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + } + if !_storage._repeatedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + } + if !_storage._repeatedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + } + if !_storage._repeatedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + } + if !_storage._repeatedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + } + if !_storage._repeatedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + } + if !_storage._repeatedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + } + if !_storage._repeatedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + } + if !_storage._repeatedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + } + if !_storage._repeatedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + } + if !_storage._repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) + } + if !_storage._repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) + } + if !_storage._repeatedNestedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) + } + if !_storage._repeatedForeignMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) + } + if !_storage._repeatedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + } + if !_storage._repeatedForeignEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) + } + if !_storage._repeatedStringPiece.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) + } + if !_storage._repeatedCord.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) + } + if !_storage._mapInt32Int32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Int32, fieldNumber: 56) + } + if !_storage._mapInt64Int64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Int64, fieldNumber: 57) + } + if !_storage._mapUint32Uint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Uint32, fieldNumber: 58) + } + if !_storage._mapUint64Uint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Uint64, fieldNumber: 59) + } + if !_storage._mapSint32Sint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Sint32, fieldNumber: 60) + } + if !_storage._mapSint64Sint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Sint64, fieldNumber: 61) + } + if !_storage._mapFixed32Fixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Fixed32, fieldNumber: 62) + } + if !_storage._mapFixed64Fixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Fixed64, fieldNumber: 63) + } + if !_storage._mapSfixed32Sfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 64) + } + if !_storage._mapSfixed64Sfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 65) + } + if !_storage._mapInt32Float.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Float, fieldNumber: 66) + } + if !_storage._mapInt32Double.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Double, fieldNumber: 67) + } + if !_storage._mapBoolBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolBool, fieldNumber: 68) + } + if !_storage._mapStringString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringString, fieldNumber: 69) + } + if !_storage._mapStringBytes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 70) + } + if !_storage._mapStringNestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringNestedMessage, fieldNumber: 71) + } + if !_storage._mapStringForeignMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 72) + } + if !_storage._mapStringNestedEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringNestedEnum, fieldNumber: 73) + } + if !_storage._mapStringForeignEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringForeignEnum, fieldNumber: 74) + } + if !_storage._packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._packedInt32, fieldNumber: 75) + } + if !_storage._packedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._packedInt64, fieldNumber: 76) + } + if !_storage._packedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._packedUint32, fieldNumber: 77) + } + if !_storage._packedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._packedUint64, fieldNumber: 78) + } + if !_storage._packedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._packedSint32, fieldNumber: 79) + } + if !_storage._packedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._packedSint64, fieldNumber: 80) + } + if !_storage._packedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._packedFixed32, fieldNumber: 81) + } + if !_storage._packedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._packedFixed64, fieldNumber: 82) + } + if !_storage._packedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._packedSfixed32, fieldNumber: 83) + } + if !_storage._packedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._packedSfixed64, fieldNumber: 84) + } + if !_storage._packedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._packedFloat, fieldNumber: 85) + } + if !_storage._packedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._packedDouble, fieldNumber: 86) + } + if !_storage._packedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._packedBool, fieldNumber: 87) + } + if !_storage._packedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedNestedEnum, fieldNumber: 88) + } + if !_storage._unpackedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._unpackedInt32, fieldNumber: 89) + } + if !_storage._unpackedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._unpackedInt64, fieldNumber: 90) + } + if !_storage._unpackedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._unpackedUint32, fieldNumber: 91) + } + if !_storage._unpackedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._unpackedUint64, fieldNumber: 92) + } + if !_storage._unpackedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._unpackedSint32, fieldNumber: 93) + } + if !_storage._unpackedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._unpackedSint64, fieldNumber: 94) + } + if !_storage._unpackedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._unpackedFixed32, fieldNumber: 95) + } + if !_storage._unpackedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._unpackedFixed64, fieldNumber: 96) + } + if !_storage._unpackedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._unpackedSfixed32, fieldNumber: 97) + } + if !_storage._unpackedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._unpackedSfixed64, fieldNumber: 98) + } + if !_storage._unpackedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._unpackedFloat, fieldNumber: 99) + } + if !_storage._unpackedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._unpackedDouble, fieldNumber: 100) + } + if !_storage._unpackedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._unpackedBool, fieldNumber: 101) + } + if !_storage._unpackedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._unpackedNestedEnum, fieldNumber: 102) + } + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case .oneofBool?: try { + guard case .oneofBool(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 115) + }() + case .oneofUint64?: try { + guard case .oneofUint64(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 116) + }() + case .oneofFloat?: try { + guard case .oneofFloat(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularFloatField(value: v, fieldNumber: 117) + }() + case .oneofDouble?: try { + guard case .oneofDouble(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularDoubleField(value: v, fieldNumber: 118) + }() + case .oneofEnum?: try { + guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 119) + }() + case nil: break + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201) + try { if let v = _storage._groupLikeType { + try visitor.visitSingularGroupField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._delimitedField { + try visitor.visitSingularGroupField(value: v, fieldNumber: 202) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_TestAllTypesEdition2023, rhs: ProtobufTestMessages_Editions_TestAllTypesEdition2023) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} + if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} + if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} + if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} + if _storage._repeatedCord != rhs_storage._repeatedCord {return false} + if _storage._packedInt32 != rhs_storage._packedInt32 {return false} + if _storage._packedInt64 != rhs_storage._packedInt64 {return false} + if _storage._packedUint32 != rhs_storage._packedUint32 {return false} + if _storage._packedUint64 != rhs_storage._packedUint64 {return false} + if _storage._packedSint32 != rhs_storage._packedSint32 {return false} + if _storage._packedSint64 != rhs_storage._packedSint64 {return false} + if _storage._packedFixed32 != rhs_storage._packedFixed32 {return false} + if _storage._packedFixed64 != rhs_storage._packedFixed64 {return false} + if _storage._packedSfixed32 != rhs_storage._packedSfixed32 {return false} + if _storage._packedSfixed64 != rhs_storage._packedSfixed64 {return false} + if _storage._packedFloat != rhs_storage._packedFloat {return false} + if _storage._packedDouble != rhs_storage._packedDouble {return false} + if _storage._packedBool != rhs_storage._packedBool {return false} + if _storage._packedNestedEnum != rhs_storage._packedNestedEnum {return false} + if _storage._unpackedInt32 != rhs_storage._unpackedInt32 {return false} + if _storage._unpackedInt64 != rhs_storage._unpackedInt64 {return false} + if _storage._unpackedUint32 != rhs_storage._unpackedUint32 {return false} + if _storage._unpackedUint64 != rhs_storage._unpackedUint64 {return false} + if _storage._unpackedSint32 != rhs_storage._unpackedSint32 {return false} + if _storage._unpackedSint64 != rhs_storage._unpackedSint64 {return false} + if _storage._unpackedFixed32 != rhs_storage._unpackedFixed32 {return false} + if _storage._unpackedFixed64 != rhs_storage._unpackedFixed64 {return false} + if _storage._unpackedSfixed32 != rhs_storage._unpackedSfixed32 {return false} + if _storage._unpackedSfixed64 != rhs_storage._unpackedSfixed64 {return false} + if _storage._unpackedFloat != rhs_storage._unpackedFloat {return false} + if _storage._unpackedDouble != rhs_storage._unpackedDouble {return false} + if _storage._unpackedBool != rhs_storage._unpackedBool {return false} + if _storage._unpackedNestedEnum != rhs_storage._unpackedNestedEnum {return false} + if _storage._mapInt32Int32 != rhs_storage._mapInt32Int32 {return false} + if _storage._mapInt64Int64 != rhs_storage._mapInt64Int64 {return false} + if _storage._mapUint32Uint32 != rhs_storage._mapUint32Uint32 {return false} + if _storage._mapUint64Uint64 != rhs_storage._mapUint64Uint64 {return false} + if _storage._mapSint32Sint32 != rhs_storage._mapSint32Sint32 {return false} + if _storage._mapSint64Sint64 != rhs_storage._mapSint64Sint64 {return false} + if _storage._mapFixed32Fixed32 != rhs_storage._mapFixed32Fixed32 {return false} + if _storage._mapFixed64Fixed64 != rhs_storage._mapFixed64Fixed64 {return false} + if _storage._mapSfixed32Sfixed32 != rhs_storage._mapSfixed32Sfixed32 {return false} + if _storage._mapSfixed64Sfixed64 != rhs_storage._mapSfixed64Sfixed64 {return false} + if _storage._mapInt32Float != rhs_storage._mapInt32Float {return false} + if _storage._mapInt32Double != rhs_storage._mapInt32Double {return false} + if _storage._mapBoolBool != rhs_storage._mapBoolBool {return false} + if _storage._mapStringString != rhs_storage._mapStringString {return false} + if _storage._mapStringBytes != rhs_storage._mapStringBytes {return false} + if _storage._mapStringNestedMessage != rhs_storage._mapStringNestedMessage {return false} + if _storage._mapStringForeignMessage != rhs_storage._mapStringForeignMessage {return false} + if _storage._mapStringNestedEnum != rhs_storage._mapStringNestedEnum {return false} + if _storage._mapStringForeignEnum != rhs_storage._mapStringForeignEnum {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + if _storage._groupLikeType != rhs_storage._groupLikeType {return false} + if _storage._delimitedField != rhs_storage._delimitedField {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_TestAllTypesEdition2023.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _corecursive: ProtobufTestMessages_Editions_TestAllTypesEdition2023? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._corecursive, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage, rhs: ProtobufTestMessages_Editions_TestAllTypesEdition2023.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_TestAllTypesEdition2023.protoMessageName + ".GroupLikeType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}J\u{3}group_int32\0\u{3}group_uint32\0") + + 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 202: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 203: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 202) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 203) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType, rhs: ProtobufTestMessages_Editions_TestAllTypesEdition2023.GroupLikeType) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_ForeignMessageEdition2023: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessageEdition2023" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") + + 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._c) }() + 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 + try { if let v = self._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_ForeignMessageEdition2023, rhs: ProtobufTestMessages_Editions_ForeignMessageEdition2023) -> Bool { + if lhs._c != rhs._c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_GroupLikeType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GroupLikeType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") + + 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._c) }() + 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 + try { if let v = self._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_GroupLikeType, rhs: ProtobufTestMessages_Editions_GroupLikeType) -> Bool { + if lhs._c != rhs._c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Sources/Conformance/test_messages_proto2.pb.swift b/Sources/Conformance/test_messages_proto2.pb.swift index 0ca42f176..2ea8fa80e 100644 --- a/Sources/Conformance/test_messages_proto2.pb.swift +++ b/Sources/Conformance/test_messages_proto2.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/test_messages_proto2.proto @@ -9,33 +10,10 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd // // Test schema for proto2 messages. This test schema is used by: // @@ -56,43 +34,17 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum ProtobufTestMessages_Proto2_ForeignEnumProto2: SwiftProtobuf.Enum { - typealias RawValue = Int - case foreignFoo // = 0 - case foreignBar // = 1 - case foreignBaz // = 2 +enum ProtobufTestMessages_Proto2_ForeignEnumProto2: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foreignFoo = 0 + case foreignBar = 1 + case foreignBaz = 2 init() { self = .foreignFoo } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .foreignFoo - case 1: self = .foreignBar - case 2: self = .foreignBaz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foreignFoo: return 0 - case .foreignBar: return 1 - case .foreignBaz: return 2 - } - } - } -#if swift(>=4.2) - -extension ProtobufTestMessages_Proto2_ForeignEnumProto2: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - /// This proto includes every type of field in both singular and repeated /// forms. /// @@ -100,551 +52,561 @@ extension ProtobufTestMessages_Proto2_ForeignEnumProto2: CaseIterable { /// submessages of this message. So for example, a fuzz test of TestAllTypes /// could trigger bugs that occur in any message type in this file. We verify /// this stays true in a unit test. -struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleMessage { +struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { // 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. /// Singular var optionalInt32: Int32 { - get {return _storage._optionalInt32 ?? 0} + get {_storage._optionalInt32 ?? 0} set {_uniqueStorage()._optionalInt32 = newValue} } /// Returns true if `optionalInt32` has been explicitly set. - var hasOptionalInt32: Bool {return _storage._optionalInt32 != nil} + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} var optionalInt64: Int64 { - get {return _storage._optionalInt64 ?? 0} + get {_storage._optionalInt64 ?? 0} set {_uniqueStorage()._optionalInt64 = newValue} } /// Returns true if `optionalInt64` has been explicitly set. - var hasOptionalInt64: Bool {return _storage._optionalInt64 != nil} + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} var optionalUint32: UInt32 { - get {return _storage._optionalUint32 ?? 0} + get {_storage._optionalUint32 ?? 0} set {_uniqueStorage()._optionalUint32 = newValue} } /// Returns true if `optionalUint32` has been explicitly set. - var hasOptionalUint32: Bool {return _storage._optionalUint32 != nil} + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} var optionalUint64: UInt64 { - get {return _storage._optionalUint64 ?? 0} + get {_storage._optionalUint64 ?? 0} set {_uniqueStorage()._optionalUint64 = newValue} } /// Returns true if `optionalUint64` has been explicitly set. - var hasOptionalUint64: Bool {return _storage._optionalUint64 != nil} + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} var optionalSint32: Int32 { - get {return _storage._optionalSint32 ?? 0} + get {_storage._optionalSint32 ?? 0} set {_uniqueStorage()._optionalSint32 = newValue} } /// Returns true if `optionalSint32` has been explicitly set. - var hasOptionalSint32: Bool {return _storage._optionalSint32 != nil} + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} var optionalSint64: Int64 { - get {return _storage._optionalSint64 ?? 0} + get {_storage._optionalSint64 ?? 0} set {_uniqueStorage()._optionalSint64 = newValue} } /// Returns true if `optionalSint64` has been explicitly set. - var hasOptionalSint64: Bool {return _storage._optionalSint64 != nil} + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32 ?? 0} + get {_storage._optionalFixed32 ?? 0} set {_uniqueStorage()._optionalFixed32 = newValue} } /// Returns true if `optionalFixed32` has been explicitly set. - var hasOptionalFixed32: Bool {return _storage._optionalFixed32 != nil} + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64 ?? 0} + get {_storage._optionalFixed64 ?? 0} set {_uniqueStorage()._optionalFixed64 = newValue} } /// Returns true if `optionalFixed64` has been explicitly set. - var hasOptionalFixed64: Bool {return _storage._optionalFixed64 != nil} + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32 ?? 0} + get {_storage._optionalSfixed32 ?? 0} set {_uniqueStorage()._optionalSfixed32 = newValue} } /// Returns true if `optionalSfixed32` has been explicitly set. - var hasOptionalSfixed32: Bool {return _storage._optionalSfixed32 != nil} + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64 ?? 0} + get {_storage._optionalSfixed64 ?? 0} set {_uniqueStorage()._optionalSfixed64 = newValue} } /// Returns true if `optionalSfixed64` has been explicitly set. - var hasOptionalSfixed64: Bool {return _storage._optionalSfixed64 != nil} + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} var optionalFloat: Float { - get {return _storage._optionalFloat ?? 0} + get {_storage._optionalFloat ?? 0} set {_uniqueStorage()._optionalFloat = newValue} } /// Returns true if `optionalFloat` has been explicitly set. - var hasOptionalFloat: Bool {return _storage._optionalFloat != nil} + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} var optionalDouble: Double { - get {return _storage._optionalDouble ?? 0} + get {_storage._optionalDouble ?? 0} set {_uniqueStorage()._optionalDouble = newValue} } /// Returns true if `optionalDouble` has been explicitly set. - var hasOptionalDouble: Bool {return _storage._optionalDouble != nil} + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} var optionalBool: Bool { - get {return _storage._optionalBool ?? false} + get {_storage._optionalBool ?? false} set {_uniqueStorage()._optionalBool = newValue} } /// Returns true if `optionalBool` has been explicitly set. - var hasOptionalBool: Bool {return _storage._optionalBool != nil} + var hasOptionalBool: Bool {_storage._optionalBool != nil} /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} var optionalString: String { - get {return _storage._optionalString ?? String()} + get {_storage._optionalString ?? String()} set {_uniqueStorage()._optionalString = newValue} } /// Returns true if `optionalString` has been explicitly set. - var hasOptionalString: Bool {return _storage._optionalString != nil} + var hasOptionalString: Bool {_storage._optionalString != nil} /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} var optionalBytes: Data { - get {return _storage._optionalBytes ?? Data()} + get {_storage._optionalBytes ?? Data()} set {_uniqueStorage()._optionalBytes = newValue} } /// Returns true if `optionalBytes` has been explicitly set. - var hasOptionalBytes: Bool {return _storage._optionalBytes != nil} + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} var optionalNestedMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage { - get {return _storage._optionalNestedMessage ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage()} + get {_storage._optionalNestedMessage ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage()} set {_uniqueStorage()._optionalNestedMessage = newValue} } /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} var optionalForeignMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2 { - get {return _storage._optionalForeignMessage ?? ProtobufTestMessages_Proto2_ForeignMessageProto2()} + get {_storage._optionalForeignMessage ?? ProtobufTestMessages_Proto2_ForeignMessageProto2()} set {_uniqueStorage()._optionalForeignMessage = newValue} } /// Returns true if `optionalForeignMessage` has been explicitly set. - var hasOptionalForeignMessage: Bool {return _storage._optionalForeignMessage != nil} + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} var optionalNestedEnum: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum { - get {return _storage._optionalNestedEnum ?? .foo} + get {_storage._optionalNestedEnum ?? .foo} set {_uniqueStorage()._optionalNestedEnum = newValue} } /// Returns true if `optionalNestedEnum` has been explicitly set. - var hasOptionalNestedEnum: Bool {return _storage._optionalNestedEnum != nil} + var hasOptionalNestedEnum: Bool {_storage._optionalNestedEnum != nil} /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} var optionalForeignEnum: ProtobufTestMessages_Proto2_ForeignEnumProto2 { - get {return _storage._optionalForeignEnum ?? .foreignFoo} + get {_storage._optionalForeignEnum ?? .foreignFoo} set {_uniqueStorage()._optionalForeignEnum = newValue} } /// Returns true if `optionalForeignEnum` has been explicitly set. - var hasOptionalForeignEnum: Bool {return _storage._optionalForeignEnum != nil} + var hasOptionalForeignEnum: Bool {_storage._optionalForeignEnum != nil} /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. mutating func clearOptionalForeignEnum() {_uniqueStorage()._optionalForeignEnum = nil} var optionalStringPiece: String { - get {return _storage._optionalStringPiece ?? String()} + get {_storage._optionalStringPiece ?? String()} set {_uniqueStorage()._optionalStringPiece = newValue} } /// Returns true if `optionalStringPiece` has been explicitly set. - var hasOptionalStringPiece: Bool {return _storage._optionalStringPiece != nil} + var hasOptionalStringPiece: Bool {_storage._optionalStringPiece != nil} /// Clears the value of `optionalStringPiece`. Subsequent reads from it will return its default value. mutating func clearOptionalStringPiece() {_uniqueStorage()._optionalStringPiece = nil} var optionalCord: String { - get {return _storage._optionalCord ?? String()} + get {_storage._optionalCord ?? String()} set {_uniqueStorage()._optionalCord = newValue} } /// Returns true if `optionalCord` has been explicitly set. - var hasOptionalCord: Bool {return _storage._optionalCord != nil} + var hasOptionalCord: Bool {_storage._optionalCord != nil} /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} var recursiveMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2 { - get {return _storage._recursiveMessage ?? ProtobufTestMessages_Proto2_TestAllTypesProto2()} + get {_storage._recursiveMessage ?? ProtobufTestMessages_Proto2_TestAllTypesProto2()} set {_uniqueStorage()._recursiveMessage = newValue} } /// Returns true if `recursiveMessage` has been explicitly set. - var hasRecursiveMessage: Bool {return _storage._recursiveMessage != nil} + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} /// Repeated var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } var repeatedNestedMessage: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage] { - get {return _storage._repeatedNestedMessage} + get {_storage._repeatedNestedMessage} set {_uniqueStorage()._repeatedNestedMessage = newValue} } var repeatedForeignMessage: [ProtobufTestMessages_Proto2_ForeignMessageProto2] { - get {return _storage._repeatedForeignMessage} + get {_storage._repeatedForeignMessage} set {_uniqueStorage()._repeatedForeignMessage = newValue} } var repeatedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] { - get {return _storage._repeatedNestedEnum} + get {_storage._repeatedNestedEnum} set {_uniqueStorage()._repeatedNestedEnum = newValue} } var repeatedForeignEnum: [ProtobufTestMessages_Proto2_ForeignEnumProto2] { - get {return _storage._repeatedForeignEnum} + get {_storage._repeatedForeignEnum} set {_uniqueStorage()._repeatedForeignEnum = newValue} } var repeatedStringPiece: [String] { - get {return _storage._repeatedStringPiece} + get {_storage._repeatedStringPiece} set {_uniqueStorage()._repeatedStringPiece = newValue} } var repeatedCord: [String] { - get {return _storage._repeatedCord} + get {_storage._repeatedCord} set {_uniqueStorage()._repeatedCord = newValue} } /// Packed var packedInt32: [Int32] { - get {return _storage._packedInt32} + get {_storage._packedInt32} set {_uniqueStorage()._packedInt32 = newValue} } var packedInt64: [Int64] { - get {return _storage._packedInt64} + get {_storage._packedInt64} set {_uniqueStorage()._packedInt64 = newValue} } var packedUint32: [UInt32] { - get {return _storage._packedUint32} + get {_storage._packedUint32} set {_uniqueStorage()._packedUint32 = newValue} } var packedUint64: [UInt64] { - get {return _storage._packedUint64} + get {_storage._packedUint64} set {_uniqueStorage()._packedUint64 = newValue} } var packedSint32: [Int32] { - get {return _storage._packedSint32} + get {_storage._packedSint32} set {_uniqueStorage()._packedSint32 = newValue} } var packedSint64: [Int64] { - get {return _storage._packedSint64} + get {_storage._packedSint64} set {_uniqueStorage()._packedSint64 = newValue} } var packedFixed32: [UInt32] { - get {return _storage._packedFixed32} + get {_storage._packedFixed32} set {_uniqueStorage()._packedFixed32 = newValue} } var packedFixed64: [UInt64] { - get {return _storage._packedFixed64} + get {_storage._packedFixed64} set {_uniqueStorage()._packedFixed64 = newValue} } var packedSfixed32: [Int32] { - get {return _storage._packedSfixed32} + get {_storage._packedSfixed32} set {_uniqueStorage()._packedSfixed32 = newValue} } var packedSfixed64: [Int64] { - get {return _storage._packedSfixed64} + get {_storage._packedSfixed64} set {_uniqueStorage()._packedSfixed64 = newValue} } var packedFloat: [Float] { - get {return _storage._packedFloat} + get {_storage._packedFloat} set {_uniqueStorage()._packedFloat = newValue} } var packedDouble: [Double] { - get {return _storage._packedDouble} + get {_storage._packedDouble} set {_uniqueStorage()._packedDouble = newValue} } var packedBool: [Bool] { - get {return _storage._packedBool} + get {_storage._packedBool} set {_uniqueStorage()._packedBool = newValue} } var packedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] { - get {return _storage._packedNestedEnum} + get {_storage._packedNestedEnum} set {_uniqueStorage()._packedNestedEnum = newValue} } /// Unpacked var unpackedInt32: [Int32] { - get {return _storage._unpackedInt32} + get {_storage._unpackedInt32} set {_uniqueStorage()._unpackedInt32 = newValue} } var unpackedInt64: [Int64] { - get {return _storage._unpackedInt64} + get {_storage._unpackedInt64} set {_uniqueStorage()._unpackedInt64 = newValue} } var unpackedUint32: [UInt32] { - get {return _storage._unpackedUint32} + get {_storage._unpackedUint32} set {_uniqueStorage()._unpackedUint32 = newValue} } var unpackedUint64: [UInt64] { - get {return _storage._unpackedUint64} + get {_storage._unpackedUint64} set {_uniqueStorage()._unpackedUint64 = newValue} } var unpackedSint32: [Int32] { - get {return _storage._unpackedSint32} + get {_storage._unpackedSint32} set {_uniqueStorage()._unpackedSint32 = newValue} } var unpackedSint64: [Int64] { - get {return _storage._unpackedSint64} + get {_storage._unpackedSint64} set {_uniqueStorage()._unpackedSint64 = newValue} } var unpackedFixed32: [UInt32] { - get {return _storage._unpackedFixed32} + get {_storage._unpackedFixed32} set {_uniqueStorage()._unpackedFixed32 = newValue} } var unpackedFixed64: [UInt64] { - get {return _storage._unpackedFixed64} + get {_storage._unpackedFixed64} set {_uniqueStorage()._unpackedFixed64 = newValue} } var unpackedSfixed32: [Int32] { - get {return _storage._unpackedSfixed32} + get {_storage._unpackedSfixed32} set {_uniqueStorage()._unpackedSfixed32 = newValue} } var unpackedSfixed64: [Int64] { - get {return _storage._unpackedSfixed64} + get {_storage._unpackedSfixed64} set {_uniqueStorage()._unpackedSfixed64 = newValue} } var unpackedFloat: [Float] { - get {return _storage._unpackedFloat} + get {_storage._unpackedFloat} set {_uniqueStorage()._unpackedFloat = newValue} } var unpackedDouble: [Double] { - get {return _storage._unpackedDouble} + get {_storage._unpackedDouble} set {_uniqueStorage()._unpackedDouble = newValue} } var unpackedBool: [Bool] { - get {return _storage._unpackedBool} + get {_storage._unpackedBool} set {_uniqueStorage()._unpackedBool = newValue} } var unpackedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] { - get {return _storage._unpackedNestedEnum} + get {_storage._unpackedNestedEnum} set {_uniqueStorage()._unpackedNestedEnum = newValue} } /// Map var mapInt32Int32: Dictionary { - get {return _storage._mapInt32Int32} + get {_storage._mapInt32Int32} set {_uniqueStorage()._mapInt32Int32 = newValue} } var mapInt64Int64: Dictionary { - get {return _storage._mapInt64Int64} + get {_storage._mapInt64Int64} set {_uniqueStorage()._mapInt64Int64 = newValue} } var mapUint32Uint32: Dictionary { - get {return _storage._mapUint32Uint32} + get {_storage._mapUint32Uint32} set {_uniqueStorage()._mapUint32Uint32 = newValue} } var mapUint64Uint64: Dictionary { - get {return _storage._mapUint64Uint64} + get {_storage._mapUint64Uint64} set {_uniqueStorage()._mapUint64Uint64 = newValue} } var mapSint32Sint32: Dictionary { - get {return _storage._mapSint32Sint32} + get {_storage._mapSint32Sint32} set {_uniqueStorage()._mapSint32Sint32 = newValue} } var mapSint64Sint64: Dictionary { - get {return _storage._mapSint64Sint64} + get {_storage._mapSint64Sint64} set {_uniqueStorage()._mapSint64Sint64 = newValue} } var mapFixed32Fixed32: Dictionary { - get {return _storage._mapFixed32Fixed32} + get {_storage._mapFixed32Fixed32} set {_uniqueStorage()._mapFixed32Fixed32 = newValue} } var mapFixed64Fixed64: Dictionary { - get {return _storage._mapFixed64Fixed64} + get {_storage._mapFixed64Fixed64} set {_uniqueStorage()._mapFixed64Fixed64 = newValue} } var mapSfixed32Sfixed32: Dictionary { - get {return _storage._mapSfixed32Sfixed32} + get {_storage._mapSfixed32Sfixed32} set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} } var mapSfixed64Sfixed64: Dictionary { - get {return _storage._mapSfixed64Sfixed64} + get {_storage._mapSfixed64Sfixed64} set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} } + var mapInt32Bool: Dictionary { + get {_storage._mapInt32Bool} + set {_uniqueStorage()._mapInt32Bool = newValue} + } + var mapInt32Float: Dictionary { - get {return _storage._mapInt32Float} + get {_storage._mapInt32Float} set {_uniqueStorage()._mapInt32Float = newValue} } var mapInt32Double: Dictionary { - get {return _storage._mapInt32Double} + get {_storage._mapInt32Double} set {_uniqueStorage()._mapInt32Double = newValue} } + var mapInt32NestedMessage: Dictionary { + get {_storage._mapInt32NestedMessage} + set {_uniqueStorage()._mapInt32NestedMessage = newValue} + } + var mapBoolBool: Dictionary { - get {return _storage._mapBoolBool} + get {_storage._mapBoolBool} set {_uniqueStorage()._mapBoolBool = newValue} } var mapStringString: Dictionary { - get {return _storage._mapStringString} + get {_storage._mapStringString} set {_uniqueStorage()._mapStringString = newValue} } var mapStringBytes: Dictionary { - get {return _storage._mapStringBytes} + get {_storage._mapStringBytes} set {_uniqueStorage()._mapStringBytes = newValue} } var mapStringNestedMessage: Dictionary { - get {return _storage._mapStringNestedMessage} + get {_storage._mapStringNestedMessage} set {_uniqueStorage()._mapStringNestedMessage = newValue} } var mapStringForeignMessage: Dictionary { - get {return _storage._mapStringForeignMessage} + get {_storage._mapStringForeignMessage} set {_uniqueStorage()._mapStringForeignMessage = newValue} } var mapStringNestedEnum: Dictionary { - get {return _storage._mapStringNestedEnum} + get {_storage._mapStringNestedEnum} set {_uniqueStorage()._mapStringNestedEnum = newValue} } var mapStringForeignEnum: Dictionary { - get {return _storage._mapStringForeignEnum} + get {_storage._mapStringForeignEnum} set {_uniqueStorage()._mapStringForeignEnum = newValue} } @@ -726,181 +688,335 @@ struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleM } var data: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage { - get {return _storage._data ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage()} + get {_storage._data ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage()} set {_uniqueStorage()._data = newValue} } /// Returns true if `data` has been explicitly set. - var hasData: Bool {return _storage._data != nil} + var hasData: Bool {_storage._data != nil} /// Clears the value of `data`. Subsequent reads from it will return its default value. mutating func clearData() {_uniqueStorage()._data = nil} + var multiWordGroupField: ProtobufTestMessages_Proto2_TestAllTypesProto2.MultiWordGroupField { + get {_storage._multiWordGroupField ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.MultiWordGroupField()} + set {_uniqueStorage()._multiWordGroupField = newValue} + } + /// Returns true if `multiWordGroupField` has been explicitly set. + var hasMultiWordGroupField: Bool {_storage._multiWordGroupField != nil} + /// Clears the value of `multiWordGroupField`. Subsequent reads from it will return its default value. + mutating func clearMultiWordGroupField() {_uniqueStorage()._multiWordGroupField = nil} + + /// default values + var defaultInt32: Int32 { + get {_storage._defaultInt32 ?? -123456789} + set {_uniqueStorage()._defaultInt32 = newValue} + } + /// Returns true if `defaultInt32` has been explicitly set. + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} + /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} + + var defaultInt64: Int64 { + get {_storage._defaultInt64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultInt64 = newValue} + } + /// Returns true if `defaultInt64` has been explicitly set. + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} + /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} + + var defaultUint32: UInt32 { + get {_storage._defaultUint32 ?? 2123456789} + set {_uniqueStorage()._defaultUint32 = newValue} + } + /// Returns true if `defaultUint32` has been explicitly set. + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} + /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} + + var defaultUint64: UInt64 { + get {_storage._defaultUint64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultUint64 = newValue} + } + /// Returns true if `defaultUint64` has been explicitly set. + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} + /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} + + var defaultSint32: Int32 { + get {_storage._defaultSint32 ?? -123456789} + set {_uniqueStorage()._defaultSint32 = newValue} + } + /// Returns true if `defaultSint32` has been explicitly set. + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} + /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} + + var defaultSint64: Int64 { + get {_storage._defaultSint64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSint64 = newValue} + } + /// Returns true if `defaultSint64` has been explicitly set. + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} + /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} + + var defaultFixed32: UInt32 { + get {_storage._defaultFixed32 ?? 2123456789} + set {_uniqueStorage()._defaultFixed32 = newValue} + } + /// Returns true if `defaultFixed32` has been explicitly set. + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} + /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} + + var defaultFixed64: UInt64 { + get {_storage._defaultFixed64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultFixed64 = newValue} + } + /// Returns true if `defaultFixed64` has been explicitly set. + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} + /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} + + var defaultSfixed32: Int32 { + get {_storage._defaultSfixed32 ?? -123456789} + set {_uniqueStorage()._defaultSfixed32 = newValue} + } + /// Returns true if `defaultSfixed32` has been explicitly set. + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} + /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} + + var defaultSfixed64: Int64 { + get {_storage._defaultSfixed64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSfixed64 = newValue} + } + /// Returns true if `defaultSfixed64` has been explicitly set. + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} + /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} + + var defaultFloat: Float { + get {_storage._defaultFloat ?? 9e+09} + set {_uniqueStorage()._defaultFloat = newValue} + } + /// Returns true if `defaultFloat` has been explicitly set. + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} + /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. + mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} + + var defaultDouble: Double { + get {_storage._defaultDouble ?? 7e+22} + set {_uniqueStorage()._defaultDouble = newValue} + } + /// Returns true if `defaultDouble` has been explicitly set. + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} + /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. + mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} + + var defaultBool: Bool { + get {_storage._defaultBool ?? true} + set {_uniqueStorage()._defaultBool = newValue} + } + /// Returns true if `defaultBool` has been explicitly set. + var hasDefaultBool: Bool {_storage._defaultBool != nil} + /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. + mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} + + var defaultString: String { + get {_storage._defaultString ?? "Rosebud"} + set {_uniqueStorage()._defaultString = newValue} + } + /// Returns true if `defaultString` has been explicitly set. + var hasDefaultString: Bool {_storage._defaultString != nil} + /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. + mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} + + var defaultBytes: Data { + get {_storage._defaultBytes ?? Data([106, 111, 115, 104, 117, 97])} + set {_uniqueStorage()._defaultBytes = newValue} + } + /// Returns true if `defaultBytes` has been explicitly set. + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} + /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. + mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} + /// Test field-name-to-JSON-name convention. /// (protobuf says names can be any valid C/C++ identifier.) var fieldname1: Int32 { - get {return _storage._fieldname1 ?? 0} + get {_storage._fieldname1 ?? 0} set {_uniqueStorage()._fieldname1 = newValue} } /// Returns true if `fieldname1` has been explicitly set. - var hasFieldname1: Bool {return _storage._fieldname1 != nil} + var hasFieldname1: Bool {_storage._fieldname1 != nil} /// Clears the value of `fieldname1`. Subsequent reads from it will return its default value. mutating func clearFieldname1() {_uniqueStorage()._fieldname1 = nil} var fieldName2: Int32 { - get {return _storage._fieldName2 ?? 0} + get {_storage._fieldName2 ?? 0} set {_uniqueStorage()._fieldName2 = newValue} } /// Returns true if `fieldName2` has been explicitly set. - var hasFieldName2: Bool {return _storage._fieldName2 != nil} + var hasFieldName2: Bool {_storage._fieldName2 != nil} /// Clears the value of `fieldName2`. Subsequent reads from it will return its default value. mutating func clearFieldName2() {_uniqueStorage()._fieldName2 = nil} var fieldName3: Int32 { - get {return _storage._fieldName3 ?? 0} + get {_storage._fieldName3 ?? 0} set {_uniqueStorage()._fieldName3 = newValue} } /// Returns true if `fieldName3` has been explicitly set. - var hasFieldName3: Bool {return _storage._fieldName3 != nil} + var hasFieldName3: Bool {_storage._fieldName3 != nil} /// Clears the value of `fieldName3`. Subsequent reads from it will return its default value. mutating func clearFieldName3() {_uniqueStorage()._fieldName3 = nil} var field_Name4_: Int32 { - get {return _storage._field_Name4_ ?? 0} + get {_storage._field_Name4_ ?? 0} set {_uniqueStorage()._field_Name4_ = newValue} } /// Returns true if `field_Name4_` has been explicitly set. - var hasField_Name4_: Bool {return _storage._field_Name4_ != nil} + var hasField_Name4_: Bool {_storage._field_Name4_ != nil} /// Clears the value of `field_Name4_`. Subsequent reads from it will return its default value. mutating func clearField_Name4_() {_uniqueStorage()._field_Name4_ = nil} var field0Name5: Int32 { - get {return _storage._field0Name5 ?? 0} + get {_storage._field0Name5 ?? 0} set {_uniqueStorage()._field0Name5 = newValue} } /// Returns true if `field0Name5` has been explicitly set. - var hasField0Name5: Bool {return _storage._field0Name5 != nil} + var hasField0Name5: Bool {_storage._field0Name5 != nil} /// Clears the value of `field0Name5`. Subsequent reads from it will return its default value. mutating func clearField0Name5() {_uniqueStorage()._field0Name5 = nil} var field0Name6: Int32 { - get {return _storage._field0Name6 ?? 0} + get {_storage._field0Name6 ?? 0} set {_uniqueStorage()._field0Name6 = newValue} } /// Returns true if `field0Name6` has been explicitly set. - var hasField0Name6: Bool {return _storage._field0Name6 != nil} + var hasField0Name6: Bool {_storage._field0Name6 != nil} /// Clears the value of `field0Name6`. Subsequent reads from it will return its default value. mutating func clearField0Name6() {_uniqueStorage()._field0Name6 = nil} var fieldName7: Int32 { - get {return _storage._fieldName7 ?? 0} + get {_storage._fieldName7 ?? 0} set {_uniqueStorage()._fieldName7 = newValue} } /// Returns true if `fieldName7` has been explicitly set. - var hasFieldName7: Bool {return _storage._fieldName7 != nil} + var hasFieldName7: Bool {_storage._fieldName7 != nil} /// Clears the value of `fieldName7`. Subsequent reads from it will return its default value. mutating func clearFieldName7() {_uniqueStorage()._fieldName7 = nil} var fieldName8: Int32 { - get {return _storage._fieldName8 ?? 0} + get {_storage._fieldName8 ?? 0} set {_uniqueStorage()._fieldName8 = newValue} } /// Returns true if `fieldName8` has been explicitly set. - var hasFieldName8: Bool {return _storage._fieldName8 != nil} + var hasFieldName8: Bool {_storage._fieldName8 != nil} /// Clears the value of `fieldName8`. Subsequent reads from it will return its default value. mutating func clearFieldName8() {_uniqueStorage()._fieldName8 = nil} var fieldName9: Int32 { - get {return _storage._fieldName9 ?? 0} + get {_storage._fieldName9 ?? 0} set {_uniqueStorage()._fieldName9 = newValue} } /// Returns true if `fieldName9` has been explicitly set. - var hasFieldName9: Bool {return _storage._fieldName9 != nil} + var hasFieldName9: Bool {_storage._fieldName9 != nil} /// Clears the value of `fieldName9`. Subsequent reads from it will return its default value. mutating func clearFieldName9() {_uniqueStorage()._fieldName9 = nil} var fieldName10: Int32 { - get {return _storage._fieldName10 ?? 0} + get {_storage._fieldName10 ?? 0} set {_uniqueStorage()._fieldName10 = newValue} } /// Returns true if `fieldName10` has been explicitly set. - var hasFieldName10: Bool {return _storage._fieldName10 != nil} + var hasFieldName10: Bool {_storage._fieldName10 != nil} /// Clears the value of `fieldName10`. Subsequent reads from it will return its default value. mutating func clearFieldName10() {_uniqueStorage()._fieldName10 = nil} var fieldName11: Int32 { - get {return _storage._fieldName11 ?? 0} + get {_storage._fieldName11 ?? 0} set {_uniqueStorage()._fieldName11 = newValue} } /// Returns true if `fieldName11` has been explicitly set. - var hasFieldName11: Bool {return _storage._fieldName11 != nil} + var hasFieldName11: Bool {_storage._fieldName11 != nil} /// Clears the value of `fieldName11`. Subsequent reads from it will return its default value. mutating func clearFieldName11() {_uniqueStorage()._fieldName11 = nil} var fieldName12: Int32 { - get {return _storage._fieldName12 ?? 0} + get {_storage._fieldName12 ?? 0} set {_uniqueStorage()._fieldName12 = newValue} } /// Returns true if `fieldName12` has been explicitly set. - var hasFieldName12: Bool {return _storage._fieldName12 != nil} + var hasFieldName12: Bool {_storage._fieldName12 != nil} /// Clears the value of `fieldName12`. Subsequent reads from it will return its default value. mutating func clearFieldName12() {_uniqueStorage()._fieldName12 = nil} var _FieldName13: Int32 { - get {return _storage.__FieldName13 ?? 0} + get {_storage.__FieldName13 ?? 0} set {_uniqueStorage().__FieldName13 = newValue} } /// Returns true if `_FieldName13` has been explicitly set. - var has_FieldName13: Bool {return _storage.__FieldName13 != nil} + var has_FieldName13: Bool {_storage.__FieldName13 != nil} /// Clears the value of `_FieldName13`. Subsequent reads from it will return its default value. mutating func clear_FieldName13() {_uniqueStorage().__FieldName13 = nil} var _FieldName14: Int32 { - get {return _storage.__FieldName14 ?? 0} + get {_storage.__FieldName14 ?? 0} set {_uniqueStorage().__FieldName14 = newValue} } /// Returns true if `_FieldName14` has been explicitly set. - var has_FieldName14: Bool {return _storage.__FieldName14 != nil} + var has_FieldName14: Bool {_storage.__FieldName14 != nil} /// Clears the value of `_FieldName14`. Subsequent reads from it will return its default value. mutating func clear_FieldName14() {_uniqueStorage().__FieldName14 = nil} var field_Name15: Int32 { - get {return _storage._field_Name15 ?? 0} + get {_storage._field_Name15 ?? 0} set {_uniqueStorage()._field_Name15 = newValue} } /// Returns true if `field_Name15` has been explicitly set. - var hasField_Name15: Bool {return _storage._field_Name15 != nil} + var hasField_Name15: Bool {_storage._field_Name15 != nil} /// Clears the value of `field_Name15`. Subsequent reads from it will return its default value. mutating func clearField_Name15() {_uniqueStorage()._field_Name15 = nil} var field_Name16: Int32 { - get {return _storage._field_Name16 ?? 0} + get {_storage._field_Name16 ?? 0} set {_uniqueStorage()._field_Name16 = newValue} } /// Returns true if `field_Name16` has been explicitly set. - var hasField_Name16: Bool {return _storage._field_Name16 != nil} + var hasField_Name16: Bool {_storage._field_Name16 != nil} /// Clears the value of `field_Name16`. Subsequent reads from it will return its default value. mutating func clearField_Name16() {_uniqueStorage()._field_Name16 = nil} var fieldName17__: Int32 { - get {return _storage._fieldName17__ ?? 0} + get {_storage._fieldName17__ ?? 0} set {_uniqueStorage()._fieldName17__ = newValue} } /// Returns true if `fieldName17__` has been explicitly set. - var hasFieldName17__: Bool {return _storage._fieldName17__ != nil} + var hasFieldName17__: Bool {_storage._fieldName17__ != nil} /// Clears the value of `fieldName17__`. Subsequent reads from it will return its default value. mutating func clearFieldName17__() {_uniqueStorage()._fieldName17__ = nil} var fieldName18__: Int32 { - get {return _storage._fieldName18__ ?? 0} + get {_storage._fieldName18__ ?? 0} set {_uniqueStorage()._fieldName18__ = newValue} } /// Returns true if `fieldName18__` has been explicitly set. - var hasFieldName18__: Bool {return _storage._fieldName18__ != nil} + var hasFieldName18__: Bool {_storage._fieldName18__ != nil} /// Clears the value of `fieldName18__`. Subsequent reads from it will return its default value. mutating func clearFieldName18__() {_uniqueStorage()._fieldName18__ = nil} + var messageSetCorrect: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect { + get {_storage._messageSetCorrect ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect()} + set {_uniqueStorage()._messageSetCorrect = newValue} + } + /// Returns true if `messageSetCorrect` has been explicitly set. + var hasMessageSetCorrect: Bool {_storage._messageSetCorrect != nil} + /// Clears the value of `messageSetCorrect`. Subsequent reads from it will return its default value. + mutating func clearMessageSetCorrect() {_uniqueStorage()._messageSetCorrect = nil} + var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case oneofUint32(UInt32) case oneofNestedMessage(ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage) case oneofString(String) @@ -916,108 +1032,42 @@ struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleM return v.isInitialized } - #if !swift(>=4.1) - static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.OneOf_OneofField, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBool, .oneofBool): return { - guard case .oneofBool(let l) = lhs, case .oneofBool(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint64, .oneofUint64): return { - guard case .oneofUint64(let l) = lhs, case .oneofUint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFloat, .oneofFloat): return { - guard case .oneofFloat(let l) = lhs, case .oneofFloat(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofDouble, .oneofDouble): return { - guard case .oneofDouble(let l) = lhs, case .oneofDouble(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofEnum, .oneofEnum): return { - guard case .oneofEnum(let l) = lhs, case .oneofEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum NestedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 0 - case bar // = 1 - case baz // = 2 + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 /// Intentionally negative. - case neg // = -1 + case neg = -1 init() { self = .foo } - init?(rawValue: Int) { - switch rawValue { - case -1: self = .neg - case 0: self = .foo - case 1: self = .bar - case 2: self = .baz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .neg: return -1 - case .foo: return 0 - case .bar: return 1 - case .baz: return 2 - } - } - } - struct NestedMessage { + struct NestedMessage: @unchecked Sendable { // 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 a: Int32 { - get {return _storage._a ?? 0} + get {_storage._a ?? 0} set {_uniqueStorage()._a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return _storage._a != nil} + var hasA: Bool {_storage._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {_uniqueStorage()._a = nil} var corecursive: ProtobufTestMessages_Proto2_TestAllTypesProto2 { - get {return _storage._corecursive ?? ProtobufTestMessages_Proto2_TestAllTypesProto2()} + get {_storage._corecursive ?? ProtobufTestMessages_Proto2_TestAllTypesProto2()} set {_uniqueStorage()._corecursive = newValue} } /// Returns true if `corecursive` has been explicitly set. - var hasCorecursive: Bool {return _storage._corecursive != nil} + var hasCorecursive: Bool {_storage._corecursive != nil} /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} @@ -1029,26 +1079,57 @@ struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleM } /// groups - struct DataMessage { + struct DataMessage: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + struct MultiWordGroupField: Sendable { // 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 groupInt32: Int32 { - get {return _groupInt32 ?? 0} + get {_groupInt32 ?? 0} set {_groupInt32 = newValue} } /// Returns true if `groupInt32` has been explicitly set. - var hasGroupInt32: Bool {return self._groupInt32 != nil} + var hasGroupInt32: Bool {self._groupInt32 != nil} /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. mutating func clearGroupInt32() {self._groupInt32 = nil} var groupUint32: UInt32 { - get {return _groupUint32 ?? 0} + get {_groupUint32 ?? 0} set {_groupUint32 = newValue} } /// Returns true if `groupUint32` has been explicitly set. - var hasGroupUint32: Bool {return self._groupUint32 != nil} + var hasGroupUint32: Bool {self._groupUint32 != nil} /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. mutating func clearGroupUint32() {self._groupUint32 = nil} @@ -1061,7 +1142,7 @@ struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleM } /// message_set test case. - struct MessageSetCorrect: SwiftProtobuf.ExtensibleMessage { + struct MessageSetCorrect: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -1073,17 +1154,17 @@ struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleM var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } - struct MessageSetCorrectExtension1 { + struct MessageSetCorrectExtension1: Sendable { // 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 str: String { - get {return _str ?? String()} + get {_str ?? String()} set {_str = newValue} } /// Returns true if `str` has been explicitly set. - var hasStr: Bool {return self._str != nil} + var hasStr: Bool {self._str != nil} /// Clears the value of `str`. Subsequent reads from it will return its default value. mutating func clearStr() {self._str = nil} @@ -1094,17 +1175,17 @@ struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleM fileprivate var _str: String? = nil } - struct MessageSetCorrectExtension2 { + struct MessageSetCorrectExtension2: Sendable { // 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 i: Int32 { - get {return _i ?? 0} + get {_i ?? 0} set {_i = newValue} } /// Returns true if `i` has been explicitly set. - var hasI: Bool {return self._i != nil} + var hasI: Bool {self._i != nil} /// Clears the value of `i`. Subsequent reads from it will return its default value. mutating func clearI() {self._i = nil} @@ -1115,31 +1196,57 @@ struct ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleM fileprivate var _i: Int32? = nil } + struct ExtensionWithOneof: Sendable { + // 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 oneofField: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.OneOf_OneofField? = nil + + var a: Int32 { + get { + if case .a(let v)? = oneofField {return v} + return 0 + } + set {oneofField = .a(newValue)} + } + + var b: Int32 { + get { + if case .b(let v)? = oneofField {return v} + return 0 + } + set {oneofField = .b(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case a(Int32) + case b(Int32) + + } + + init() {} + } + init() {} var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufTestMessages_Proto2_ForeignMessageProto2 { +struct ProtobufTestMessages_Proto2_ForeignMessageProto2: Sendable { // 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 c: Int32 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -1150,53 +1257,84 @@ struct ProtobufTestMessages_Proto2_ForeignMessageProto2 { fileprivate var _c: Int32? = nil } -struct ProtobufTestMessages_Proto2_UnknownToTestAllTypes { +struct ProtobufTestMessages_Proto2_GroupField: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil +} + +struct ProtobufTestMessages_Proto2_UnknownToTestAllTypes: Sendable { // 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 optionalInt32: Int32 { - get {return _optionalInt32 ?? 0} + get {_optionalInt32 ?? 0} set {_optionalInt32 = newValue} } /// Returns true if `optionalInt32` has been explicitly set. - var hasOptionalInt32: Bool {return self._optionalInt32 != nil} + var hasOptionalInt32: Bool {self._optionalInt32 != nil} /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. mutating func clearOptionalInt32() {self._optionalInt32 = nil} var optionalString: String { - get {return _optionalString ?? String()} + get {_optionalString ?? String()} set {_optionalString = newValue} } /// Returns true if `optionalString` has been explicitly set. - var hasOptionalString: Bool {return self._optionalString != nil} + var hasOptionalString: Bool {self._optionalString != nil} /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. mutating func clearOptionalString() {self._optionalString = nil} var nestedMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2 { - get {return _nestedMessage ?? ProtobufTestMessages_Proto2_ForeignMessageProto2()} + get {_nestedMessage ?? ProtobufTestMessages_Proto2_ForeignMessageProto2()} set {_nestedMessage = newValue} } /// Returns true if `nestedMessage` has been explicitly set. - var hasNestedMessage: Bool {return self._nestedMessage != nil} + var hasNestedMessage: Bool {self._nestedMessage != nil} /// Clears the value of `nestedMessage`. Subsequent reads from it will return its default value. mutating func clearNestedMessage() {self._nestedMessage = nil} var optionalGroup: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup { - get {return _optionalGroup ?? ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup()} + get {_optionalGroup ?? ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup()} set {_optionalGroup = newValue} } /// Returns true if `optionalGroup` has been explicitly set. - var hasOptionalGroup: Bool {return self._optionalGroup != nil} + var hasOptionalGroup: Bool {self._optionalGroup != nil} /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. mutating func clearOptionalGroup() {self._optionalGroup = nil} var optionalBool: Bool { - get {return _optionalBool ?? false} + get {_optionalBool ?? false} set {_optionalBool = newValue} } /// Returns true if `optionalBool` has been explicitly set. - var hasOptionalBool: Bool {return self._optionalBool != nil} + var hasOptionalBool: Bool {self._optionalBool != nil} /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. mutating func clearOptionalBool() {self._optionalBool = nil} @@ -1204,17 +1342,17 @@ struct ProtobufTestMessages_Proto2_UnknownToTestAllTypes { var unknownFields = SwiftProtobuf.UnknownStorage() - struct OptionalGroup { + struct OptionalGroup: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -1234,7 +1372,7 @@ struct ProtobufTestMessages_Proto2_UnknownToTestAllTypes { fileprivate var _optionalBool: Bool? = nil } -struct ProtobufTestMessages_Proto2_NullHypothesisProto2 { +struct ProtobufTestMessages_Proto2_NullHypothesisProto2: Sendable { // 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. @@ -1244,556 +1382,1205 @@ struct ProtobufTestMessages_Proto2_NullHypothesisProto2 { init() {} } -struct ProtobufTestMessages_Proto2_EnumOnlyProto2 { +struct ProtobufTestMessages_Proto2_EnumOnlyProto2: Sendable { // 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() - enum BoolEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case kFalse // = 0 - case kTrue // = 1 + enum BoolEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case kFalse = 0 + case kTrue = 1 init() { self = .kFalse } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .kFalse - case 1: self = .kTrue - default: return nil - } - } - - var rawValue: Int { - switch self { - case .kFalse: return 0 - case .kTrue: return 1 - } - } - } init() {} } -#if swift(>=4.2) - -extension ProtobufTestMessages_Proto2_EnumOnlyProto2.BoolEnum: CaseIterable { - // Support synthesized by the compiler. -} +struct ProtobufTestMessages_Proto2_OneStringProto2: Sendable { + // 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. -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufTestMessages_Proto2_ForeignEnumProto2: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_ForeignMessageProto2: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_NullHypothesisProto2: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_EnumOnlyProto2: @unchecked Sendable {} -extension ProtobufTestMessages_Proto2_EnumOnlyProto2.BoolEnum: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) + var data: String { + get {_data ?? String()} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} -// MARK: - Extension support defined in test_messages_proto2.proto. + var unknownFields = SwiftProtobuf.UnknownStorage() -// MARK: - Extension Properties + init() {} -// 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. + fileprivate var _data: String? = nil +} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2 { +struct ProtobufTestMessages_Proto2_ProtoWithKeywords: Sendable { + // 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 ProtobufTestMessages_Proto2_extensionInt32: Int32 { - get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32) ?? 0} - set {setExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32, value: newValue)} - } - /// Returns true if extension `ProtobufTestMessages_Proto2_Extensions_extension_int32` - /// has been explicitly set. - var hasProtobufTestMessages_Proto2_extensionInt32: Bool { - return hasExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32) + var inline: Int32 { + get {_inline ?? 0} + set {_inline = newValue} } - /// Clears the value of extension `ProtobufTestMessages_Proto2_Extensions_extension_int32`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufTestMessages_Proto2_extensionInt32() { - clearExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32) + /// Returns true if `inline` has been explicitly set. + var hasInline: Bool {self._inline != nil} + /// Clears the value of `inline`. Subsequent reads from it will return its default value. + mutating func clearInline() {self._inline = nil} + + var concept: String { + get {_concept ?? String()} + set {_concept = newValue} } + /// Returns true if `concept` has been explicitly set. + var hasConcept: Bool {self._concept != nil} + /// Clears the value of `concept`. Subsequent reads from it will return its default value. + mutating func clearConcept() {self._concept = nil} + + var requires: [String] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _inline: Int32? = nil + fileprivate var _concept: String? = nil } -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect { +struct ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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 ProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1 { - get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1()} - set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, value: newValue)} - } - /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension` - /// has been explicitly set. - var hasProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension: Bool { - return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) - } - /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension() { - clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + /// Singular + var requiredInt32: Int32 { + get {_storage._requiredInt32 ?? 0} + set {_uniqueStorage()._requiredInt32 = newValue} + } + /// Returns true if `requiredInt32` has been explicitly set. + var hasRequiredInt32: Bool {_storage._requiredInt32 != nil} + /// Clears the value of `requiredInt32`. Subsequent reads from it will return its default value. + mutating func clearRequiredInt32() {_uniqueStorage()._requiredInt32 = nil} + + var requiredInt64: Int64 { + get {_storage._requiredInt64 ?? 0} + set {_uniqueStorage()._requiredInt64 = newValue} + } + /// Returns true if `requiredInt64` has been explicitly set. + var hasRequiredInt64: Bool {_storage._requiredInt64 != nil} + /// Clears the value of `requiredInt64`. Subsequent reads from it will return its default value. + mutating func clearRequiredInt64() {_uniqueStorage()._requiredInt64 = nil} + + var requiredUint32: UInt32 { + get {_storage._requiredUint32 ?? 0} + set {_uniqueStorage()._requiredUint32 = newValue} + } + /// Returns true if `requiredUint32` has been explicitly set. + var hasRequiredUint32: Bool {_storage._requiredUint32 != nil} + /// Clears the value of `requiredUint32`. Subsequent reads from it will return its default value. + mutating func clearRequiredUint32() {_uniqueStorage()._requiredUint32 = nil} + + var requiredUint64: UInt64 { + get {_storage._requiredUint64 ?? 0} + set {_uniqueStorage()._requiredUint64 = newValue} + } + /// Returns true if `requiredUint64` has been explicitly set. + var hasRequiredUint64: Bool {_storage._requiredUint64 != nil} + /// Clears the value of `requiredUint64`. Subsequent reads from it will return its default value. + mutating func clearRequiredUint64() {_uniqueStorage()._requiredUint64 = nil} + + var requiredSint32: Int32 { + get {_storage._requiredSint32 ?? 0} + set {_uniqueStorage()._requiredSint32 = newValue} + } + /// Returns true if `requiredSint32` has been explicitly set. + var hasRequiredSint32: Bool {_storage._requiredSint32 != nil} + /// Clears the value of `requiredSint32`. Subsequent reads from it will return its default value. + mutating func clearRequiredSint32() {_uniqueStorage()._requiredSint32 = nil} + + var requiredSint64: Int64 { + get {_storage._requiredSint64 ?? 0} + set {_uniqueStorage()._requiredSint64 = newValue} + } + /// Returns true if `requiredSint64` has been explicitly set. + var hasRequiredSint64: Bool {_storage._requiredSint64 != nil} + /// Clears the value of `requiredSint64`. Subsequent reads from it will return its default value. + mutating func clearRequiredSint64() {_uniqueStorage()._requiredSint64 = nil} + + var requiredFixed32: UInt32 { + get {_storage._requiredFixed32 ?? 0} + set {_uniqueStorage()._requiredFixed32 = newValue} + } + /// Returns true if `requiredFixed32` has been explicitly set. + var hasRequiredFixed32: Bool {_storage._requiredFixed32 != nil} + /// Clears the value of `requiredFixed32`. Subsequent reads from it will return its default value. + mutating func clearRequiredFixed32() {_uniqueStorage()._requiredFixed32 = nil} + + var requiredFixed64: UInt64 { + get {_storage._requiredFixed64 ?? 0} + set {_uniqueStorage()._requiredFixed64 = newValue} + } + /// Returns true if `requiredFixed64` has been explicitly set. + var hasRequiredFixed64: Bool {_storage._requiredFixed64 != nil} + /// Clears the value of `requiredFixed64`. Subsequent reads from it will return its default value. + mutating func clearRequiredFixed64() {_uniqueStorage()._requiredFixed64 = nil} + + var requiredSfixed32: Int32 { + get {_storage._requiredSfixed32 ?? 0} + set {_uniqueStorage()._requiredSfixed32 = newValue} + } + /// Returns true if `requiredSfixed32` has been explicitly set. + var hasRequiredSfixed32: Bool {_storage._requiredSfixed32 != nil} + /// Clears the value of `requiredSfixed32`. Subsequent reads from it will return its default value. + mutating func clearRequiredSfixed32() {_uniqueStorage()._requiredSfixed32 = nil} + + var requiredSfixed64: Int64 { + get {_storage._requiredSfixed64 ?? 0} + set {_uniqueStorage()._requiredSfixed64 = newValue} + } + /// Returns true if `requiredSfixed64` has been explicitly set. + var hasRequiredSfixed64: Bool {_storage._requiredSfixed64 != nil} + /// Clears the value of `requiredSfixed64`. Subsequent reads from it will return its default value. + mutating func clearRequiredSfixed64() {_uniqueStorage()._requiredSfixed64 = nil} + + var requiredFloat: Float { + get {_storage._requiredFloat ?? 0} + set {_uniqueStorage()._requiredFloat = newValue} + } + /// Returns true if `requiredFloat` has been explicitly set. + var hasRequiredFloat: Bool {_storage._requiredFloat != nil} + /// Clears the value of `requiredFloat`. Subsequent reads from it will return its default value. + mutating func clearRequiredFloat() {_uniqueStorage()._requiredFloat = nil} + + var requiredDouble: Double { + get {_storage._requiredDouble ?? 0} + set {_uniqueStorage()._requiredDouble = newValue} + } + /// Returns true if `requiredDouble` has been explicitly set. + var hasRequiredDouble: Bool {_storage._requiredDouble != nil} + /// Clears the value of `requiredDouble`. Subsequent reads from it will return its default value. + mutating func clearRequiredDouble() {_uniqueStorage()._requiredDouble = nil} + + var requiredBool: Bool { + get {_storage._requiredBool ?? false} + set {_uniqueStorage()._requiredBool = newValue} + } + /// Returns true if `requiredBool` has been explicitly set. + var hasRequiredBool: Bool {_storage._requiredBool != nil} + /// Clears the value of `requiredBool`. Subsequent reads from it will return its default value. + mutating func clearRequiredBool() {_uniqueStorage()._requiredBool = nil} + + var requiredString: String { + get {_storage._requiredString ?? String()} + set {_uniqueStorage()._requiredString = newValue} + } + /// Returns true if `requiredString` has been explicitly set. + var hasRequiredString: Bool {_storage._requiredString != nil} + /// Clears the value of `requiredString`. Subsequent reads from it will return its default value. + mutating func clearRequiredString() {_uniqueStorage()._requiredString = nil} + + var requiredBytes: Data { + get {_storage._requiredBytes ?? Data()} + set {_uniqueStorage()._requiredBytes = newValue} + } + /// Returns true if `requiredBytes` has been explicitly set. + var hasRequiredBytes: Bool {_storage._requiredBytes != nil} + /// Clears the value of `requiredBytes`. Subsequent reads from it will return its default value. + mutating func clearRequiredBytes() {_uniqueStorage()._requiredBytes = nil} + + var requiredNestedMessage: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage { + get {_storage._requiredNestedMessage ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage()} + set {_uniqueStorage()._requiredNestedMessage = newValue} + } + /// Returns true if `requiredNestedMessage` has been explicitly set. + var hasRequiredNestedMessage: Bool {_storage._requiredNestedMessage != nil} + /// Clears the value of `requiredNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearRequiredNestedMessage() {_uniqueStorage()._requiredNestedMessage = nil} + + var requiredForeignMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2 { + get {_storage._requiredForeignMessage ?? ProtobufTestMessages_Proto2_ForeignMessageProto2()} + set {_uniqueStorage()._requiredForeignMessage = newValue} + } + /// Returns true if `requiredForeignMessage` has been explicitly set. + var hasRequiredForeignMessage: Bool {_storage._requiredForeignMessage != nil} + /// Clears the value of `requiredForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearRequiredForeignMessage() {_uniqueStorage()._requiredForeignMessage = nil} + + var requiredNestedEnum: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedEnum { + get {_storage._requiredNestedEnum ?? .foo} + set {_uniqueStorage()._requiredNestedEnum = newValue} + } + /// Returns true if `requiredNestedEnum` has been explicitly set. + var hasRequiredNestedEnum: Bool {_storage._requiredNestedEnum != nil} + /// Clears the value of `requiredNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredNestedEnum() {_uniqueStorage()._requiredNestedEnum = nil} + + var requiredForeignEnum: ProtobufTestMessages_Proto2_ForeignEnumProto2 { + get {_storage._requiredForeignEnum ?? .foreignFoo} + set {_uniqueStorage()._requiredForeignEnum = newValue} + } + /// Returns true if `requiredForeignEnum` has been explicitly set. + var hasRequiredForeignEnum: Bool {_storage._requiredForeignEnum != nil} + /// Clears the value of `requiredForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredForeignEnum() {_uniqueStorage()._requiredForeignEnum = nil} + + var requiredStringPiece: String { + get {_storage._requiredStringPiece ?? String()} + set {_uniqueStorage()._requiredStringPiece = newValue} + } + /// Returns true if `requiredStringPiece` has been explicitly set. + var hasRequiredStringPiece: Bool {_storage._requiredStringPiece != nil} + /// Clears the value of `requiredStringPiece`. Subsequent reads from it will return its default value. + mutating func clearRequiredStringPiece() {_uniqueStorage()._requiredStringPiece = nil} + + var requiredCord: String { + get {_storage._requiredCord ?? String()} + set {_uniqueStorage()._requiredCord = newValue} + } + /// Returns true if `requiredCord` has been explicitly set. + var hasRequiredCord: Bool {_storage._requiredCord != nil} + /// Clears the value of `requiredCord`. Subsequent reads from it will return its default value. + mutating func clearRequiredCord() {_uniqueStorage()._requiredCord = nil} + + var recursiveMessage: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2 { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._recursiveMessage = newValue} } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} - var ProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2 { - get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2()} - set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, value: newValue)} - } - /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension` - /// has been explicitly set. - var hasProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension: Bool { - return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + var optionalRecursiveMessage: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2 { + get {_storage._optionalRecursiveMessage ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._optionalRecursiveMessage = newValue} } - /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension() { - clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + /// Returns true if `optionalRecursiveMessage` has been explicitly set. + var hasOptionalRecursiveMessage: Bool {_storage._optionalRecursiveMessage != nil} + /// Clears the value of `optionalRecursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalRecursiveMessage() {_uniqueStorage()._optionalRecursiveMessage = nil} + + var data: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage { + get {_storage._data ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage()} + set {_uniqueStorage()._data = newValue} } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {_storage._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {_uniqueStorage()._data = nil} -} + /// default values + var defaultInt32: Int32 { + get {_storage._defaultInt32 ?? -123456789} + set {_uniqueStorage()._defaultInt32 = newValue} + } + /// Returns true if `defaultInt32` has been explicitly set. + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} + /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} + + var defaultInt64: Int64 { + get {_storage._defaultInt64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultInt64 = newValue} + } + /// Returns true if `defaultInt64` has been explicitly set. + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} + /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} + + var defaultUint32: UInt32 { + get {_storage._defaultUint32 ?? 2123456789} + set {_uniqueStorage()._defaultUint32 = newValue} + } + /// Returns true if `defaultUint32` has been explicitly set. + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} + /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} + + var defaultUint64: UInt64 { + get {_storage._defaultUint64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultUint64 = newValue} + } + /// Returns true if `defaultUint64` has been explicitly set. + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} + /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} + + var defaultSint32: Int32 { + get {_storage._defaultSint32 ?? -123456789} + set {_uniqueStorage()._defaultSint32 = newValue} + } + /// Returns true if `defaultSint32` has been explicitly set. + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} + /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} + + var defaultSint64: Int64 { + get {_storage._defaultSint64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSint64 = newValue} + } + /// Returns true if `defaultSint64` has been explicitly set. + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} + /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} + + var defaultFixed32: UInt32 { + get {_storage._defaultFixed32 ?? 2123456789} + set {_uniqueStorage()._defaultFixed32 = newValue} + } + /// Returns true if `defaultFixed32` has been explicitly set. + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} + /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} + + var defaultFixed64: UInt64 { + get {_storage._defaultFixed64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultFixed64 = newValue} + } + /// Returns true if `defaultFixed64` has been explicitly set. + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} + /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} + + var defaultSfixed32: Int32 { + get {_storage._defaultSfixed32 ?? -123456789} + set {_uniqueStorage()._defaultSfixed32 = newValue} + } + /// Returns true if `defaultSfixed32` has been explicitly set. + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} + /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} + + var defaultSfixed64: Int64 { + get {_storage._defaultSfixed64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSfixed64 = newValue} + } + /// Returns true if `defaultSfixed64` has been explicitly set. + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} + /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} + + var defaultFloat: Float { + get {_storage._defaultFloat ?? 9e+09} + set {_uniqueStorage()._defaultFloat = newValue} + } + /// Returns true if `defaultFloat` has been explicitly set. + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} + /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. + mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} + + var defaultDouble: Double { + get {_storage._defaultDouble ?? 7e+22} + set {_uniqueStorage()._defaultDouble = newValue} + } + /// Returns true if `defaultDouble` has been explicitly set. + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} + /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. + mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} + + var defaultBool: Bool { + get {_storage._defaultBool ?? true} + set {_uniqueStorage()._defaultBool = newValue} + } + /// Returns true if `defaultBool` has been explicitly set. + var hasDefaultBool: Bool {_storage._defaultBool != nil} + /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. + mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} + + var defaultString: String { + get {_storage._defaultString ?? "Rosebud"} + set {_uniqueStorage()._defaultString = newValue} + } + /// Returns true if `defaultString` has been explicitly set. + var hasDefaultString: Bool {_storage._defaultString != nil} + /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. + mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} + + var defaultBytes: Data { + get {_storage._defaultBytes ?? Data([106, 111, 115, 104, 117, 97])} + set {_uniqueStorage()._defaultBytes = newValue} + } + /// Returns true if `defaultBytes` has been explicitly set. + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} + /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. + mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} -// MARK: - File's ExtensionMap: ProtobufTestMessages_Proto2_TestMessagesProto2_Extensions + var unknownFields = SwiftProtobuf.UnknownStorage() -/// 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 ProtobufTestMessages_Proto2_TestMessagesProto2_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufTestMessages_Proto2_Extensions_extension_int32, - ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, - ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension -] + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 -// 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. + /// Intentionally negative. + case neg = -1 -let ProtobufTestMessages_Proto2_Extensions_extension_int32 = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2>( - _protobuf_fieldNumber: 120, - fieldName: "protobuf_test_messages.proto2.extension_int32" -) + init() { + self = .foo + } -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1 { - enum Extensions { - static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect>( - _protobuf_fieldNumber: 1547769, - fieldName: "protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension1" - ) } -} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2 { - enum Extensions { - static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect>( - _protobuf_fieldNumber: 4135312, - fieldName: "protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension2" - ) - } -} + struct NestedMessage: @unchecked Sendable { + // 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. -// MARK: - Code below here is support for the SwiftProtobuf runtime. + var a: Int32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} -fileprivate let _protobuf_package = "protobuf_test_messages.proto2" + var corecursive: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2 { + get {_storage._corecursive ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} -extension ProtobufTestMessages_Proto2_ForeignEnumProto2: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOREIGN_FOO"), - 1: .same(proto: "FOREIGN_BAR"), - 2: .same(proto: "FOREIGN_BAZ"), - ] -} + var optionalCorecursive: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2 { + get {_storage._optionalCorecursive ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._optionalCorecursive = newValue} + } + /// Returns true if `optionalCorecursive` has been explicitly set. + var hasOptionalCorecursive: Bool {_storage._optionalCorecursive != nil} + /// Clears the value of `optionalCorecursive`. Subsequent reads from it will return its default value. + mutating func clearOptionalCorecursive() {_uniqueStorage()._optionalCorecursive = nil} -extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestAllTypesProto2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "optional_foreign_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "optional_foreign_enum"), - 24: .standard(proto: "optional_string_piece"), - 25: .standard(proto: "optional_cord"), - 27: .standard(proto: "recursive_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 48: .standard(proto: "repeated_nested_message"), - 49: .standard(proto: "repeated_foreign_message"), - 51: .standard(proto: "repeated_nested_enum"), - 52: .standard(proto: "repeated_foreign_enum"), - 54: .standard(proto: "repeated_string_piece"), - 55: .standard(proto: "repeated_cord"), - 75: .standard(proto: "packed_int32"), - 76: .standard(proto: "packed_int64"), - 77: .standard(proto: "packed_uint32"), - 78: .standard(proto: "packed_uint64"), - 79: .standard(proto: "packed_sint32"), - 80: .standard(proto: "packed_sint64"), - 81: .standard(proto: "packed_fixed32"), - 82: .standard(proto: "packed_fixed64"), - 83: .standard(proto: "packed_sfixed32"), - 84: .standard(proto: "packed_sfixed64"), - 85: .standard(proto: "packed_float"), - 86: .standard(proto: "packed_double"), - 87: .standard(proto: "packed_bool"), - 88: .standard(proto: "packed_nested_enum"), - 89: .standard(proto: "unpacked_int32"), - 90: .standard(proto: "unpacked_int64"), - 91: .standard(proto: "unpacked_uint32"), - 92: .standard(proto: "unpacked_uint64"), - 93: .standard(proto: "unpacked_sint32"), - 94: .standard(proto: "unpacked_sint64"), - 95: .standard(proto: "unpacked_fixed32"), - 96: .standard(proto: "unpacked_fixed64"), - 97: .standard(proto: "unpacked_sfixed32"), - 98: .standard(proto: "unpacked_sfixed64"), - 99: .standard(proto: "unpacked_float"), - 100: .standard(proto: "unpacked_double"), - 101: .standard(proto: "unpacked_bool"), - 102: .standard(proto: "unpacked_nested_enum"), - 56: .standard(proto: "map_int32_int32"), - 57: .standard(proto: "map_int64_int64"), - 58: .standard(proto: "map_uint32_uint32"), - 59: .standard(proto: "map_uint64_uint64"), - 60: .standard(proto: "map_sint32_sint32"), - 61: .standard(proto: "map_sint64_sint64"), - 62: .standard(proto: "map_fixed32_fixed32"), - 63: .standard(proto: "map_fixed64_fixed64"), - 64: .standard(proto: "map_sfixed32_sfixed32"), - 65: .standard(proto: "map_sfixed64_sfixed64"), - 66: .standard(proto: "map_int32_float"), - 67: .standard(proto: "map_int32_double"), - 68: .standard(proto: "map_bool_bool"), - 69: .standard(proto: "map_string_string"), - 70: .standard(proto: "map_string_bytes"), - 71: .standard(proto: "map_string_nested_message"), - 72: .standard(proto: "map_string_foreign_message"), - 73: .standard(proto: "map_string_nested_enum"), - 74: .standard(proto: "map_string_foreign_enum"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - 115: .standard(proto: "oneof_bool"), - 116: .standard(proto: "oneof_uint64"), - 117: .standard(proto: "oneof_float"), - 118: .standard(proto: "oneof_double"), - 119: .standard(proto: "oneof_enum"), - 201: .unique(proto: "Data", json: "data"), - 401: .same(proto: "fieldname1"), - 402: .standard(proto: "field_name2"), - 403: .standard(proto: "_field_name3"), - 404: .standard(proto: "field__name4_"), - 405: .same(proto: "field0name5"), - 406: .standard(proto: "field_0_name6"), - 407: .same(proto: "fieldName7"), - 408: .same(proto: "FieldName8"), - 409: .standard(proto: "field_Name9"), - 410: .standard(proto: "Field_Name10"), - 411: .standard(proto: "FIELD_NAME11"), - 412: .standard(proto: "FIELD_name12"), - 413: .standard(proto: "__field_name13"), - 414: .standard(proto: "__Field_name14"), - 415: .standard(proto: "field__name15"), - 416: .standard(proto: "field__Name16"), - 417: .standard(proto: "field_name17__"), - 418: .standard(proto: "Field_name18__"), - ] + var unknownFields = SwiftProtobuf.UnknownStorage() - fileprivate class _StorageClass { - var _optionalInt32: Int32? = nil - var _optionalInt64: Int64? = nil - var _optionalUint32: UInt32? = nil - var _optionalUint64: UInt64? = nil - var _optionalSint32: Int32? = nil - var _optionalSint64: Int64? = nil - var _optionalFixed32: UInt32? = nil - var _optionalFixed64: UInt64? = nil - var _optionalSfixed32: Int32? = nil - var _optionalSfixed64: Int64? = nil - var _optionalFloat: Float? = nil - var _optionalDouble: Double? = nil - var _optionalBool: Bool? = nil - var _optionalString: String? = nil - var _optionalBytes: Data? = nil - var _optionalNestedMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage? = nil - var _optionalForeignMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2? = nil - var _optionalNestedEnum: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum? = nil - var _optionalForeignEnum: ProtobufTestMessages_Proto2_ForeignEnumProto2? = nil - var _optionalStringPiece: String? = nil - var _optionalCord: String? = nil - var _recursiveMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2? = nil - var _repeatedInt32: [Int32] = [] - var _repeatedInt64: [Int64] = [] - var _repeatedUint32: [UInt32] = [] - var _repeatedUint64: [UInt64] = [] - var _repeatedSint32: [Int32] = [] - var _repeatedSint64: [Int64] = [] - var _repeatedFixed32: [UInt32] = [] - var _repeatedFixed64: [UInt64] = [] - var _repeatedSfixed32: [Int32] = [] - var _repeatedSfixed64: [Int64] = [] - var _repeatedFloat: [Float] = [] - var _repeatedDouble: [Double] = [] - var _repeatedBool: [Bool] = [] - var _repeatedString: [String] = [] - var _repeatedBytes: [Data] = [] - var _repeatedNestedMessage: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage] = [] - var _repeatedForeignMessage: [ProtobufTestMessages_Proto2_ForeignMessageProto2] = [] - var _repeatedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] = [] - var _repeatedForeignEnum: [ProtobufTestMessages_Proto2_ForeignEnumProto2] = [] - var _repeatedStringPiece: [String] = [] - var _repeatedCord: [String] = [] - var _packedInt32: [Int32] = [] - var _packedInt64: [Int64] = [] - var _packedUint32: [UInt32] = [] - var _packedUint64: [UInt64] = [] - var _packedSint32: [Int32] = [] - var _packedSint64: [Int64] = [] - var _packedFixed32: [UInt32] = [] - var _packedFixed64: [UInt64] = [] - var _packedSfixed32: [Int32] = [] - var _packedSfixed64: [Int64] = [] - var _packedFloat: [Float] = [] - var _packedDouble: [Double] = [] - var _packedBool: [Bool] = [] - var _packedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] = [] - var _unpackedInt32: [Int32] = [] - var _unpackedInt64: [Int64] = [] - var _unpackedUint32: [UInt32] = [] - var _unpackedUint64: [UInt64] = [] - var _unpackedSint32: [Int32] = [] - var _unpackedSint64: [Int64] = [] - var _unpackedFixed32: [UInt32] = [] - var _unpackedFixed64: [UInt64] = [] - var _unpackedSfixed32: [Int32] = [] - var _unpackedSfixed64: [Int64] = [] - var _unpackedFloat: [Float] = [] - var _unpackedDouble: [Double] = [] - var _unpackedBool: [Bool] = [] - var _unpackedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] = [] - var _mapInt32Int32: Dictionary = [:] - var _mapInt64Int64: Dictionary = [:] - var _mapUint32Uint32: Dictionary = [:] - var _mapUint64Uint64: Dictionary = [:] - var _mapSint32Sint32: Dictionary = [:] - var _mapSint64Sint64: Dictionary = [:] - var _mapFixed32Fixed32: Dictionary = [:] - var _mapFixed64Fixed64: Dictionary = [:] - var _mapSfixed32Sfixed32: Dictionary = [:] - var _mapSfixed64Sfixed64: Dictionary = [:] - var _mapInt32Float: Dictionary = [:] - var _mapInt32Double: Dictionary = [:] - var _mapBoolBool: Dictionary = [:] - var _mapStringString: Dictionary = [:] - var _mapStringBytes: Dictionary = [:] - var _mapStringNestedMessage: Dictionary = [:] - var _mapStringForeignMessage: Dictionary = [:] - var _mapStringNestedEnum: Dictionary = [:] - var _mapStringForeignEnum: Dictionary = [:] - var _oneofField: ProtobufTestMessages_Proto2_TestAllTypesProto2.OneOf_OneofField? - var _data: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage? = nil - var _fieldname1: Int32? = nil - var _fieldName2: Int32? = nil - var _fieldName3: Int32? = nil - var _field_Name4_: Int32? = nil - var _field0Name5: Int32? = nil - var _field0Name6: Int32? = nil - var _fieldName7: Int32? = nil - var _fieldName8: Int32? = nil - var _fieldName9: Int32? = nil - var _fieldName10: Int32? = nil - var _fieldName11: Int32? = nil - var _fieldName12: Int32? = nil - var __FieldName13: Int32? = nil - var __FieldName14: Int32? = nil - var _field_Name15: Int32? = nil - var _field_Name16: Int32? = nil - var _fieldName17__: Int32? = nil - var _fieldName18__: Int32? = nil + init() {} - static let defaultInstance = _StorageClass() + fileprivate var _storage = _StorageClass.defaultInstance + } - private init() {} + /// groups + struct DataMessage: Sendable { + // 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. - init(copying source: _StorageClass) { - _optionalInt32 = source._optionalInt32 - _optionalInt64 = source._optionalInt64 - _optionalUint32 = source._optionalUint32 - _optionalUint64 = source._optionalUint64 - _optionalSint32 = source._optionalSint32 - _optionalSint64 = source._optionalSint64 - _optionalFixed32 = source._optionalFixed32 - _optionalFixed64 = source._optionalFixed64 - _optionalSfixed32 = source._optionalSfixed32 - _optionalSfixed64 = source._optionalSfixed64 - _optionalFloat = source._optionalFloat - _optionalDouble = source._optionalDouble - _optionalBool = source._optionalBool - _optionalString = source._optionalString - _optionalBytes = source._optionalBytes - _optionalNestedMessage = source._optionalNestedMessage - _optionalForeignMessage = source._optionalForeignMessage - _optionalNestedEnum = source._optionalNestedEnum - _optionalForeignEnum = source._optionalForeignEnum - _optionalStringPiece = source._optionalStringPiece - _optionalCord = source._optionalCord - _recursiveMessage = source._recursiveMessage - _repeatedInt32 = source._repeatedInt32 - _repeatedInt64 = source._repeatedInt64 - _repeatedUint32 = source._repeatedUint32 - _repeatedUint64 = source._repeatedUint64 - _repeatedSint32 = source._repeatedSint32 - _repeatedSint64 = source._repeatedSint64 - _repeatedFixed32 = source._repeatedFixed32 - _repeatedFixed64 = source._repeatedFixed64 - _repeatedSfixed32 = source._repeatedSfixed32 - _repeatedSfixed64 = source._repeatedSfixed64 - _repeatedFloat = source._repeatedFloat - _repeatedDouble = source._repeatedDouble - _repeatedBool = source._repeatedBool - _repeatedString = source._repeatedString - _repeatedBytes = source._repeatedBytes - _repeatedNestedMessage = source._repeatedNestedMessage - _repeatedForeignMessage = source._repeatedForeignMessage - _repeatedNestedEnum = source._repeatedNestedEnum - _repeatedForeignEnum = source._repeatedForeignEnum - _repeatedStringPiece = source._repeatedStringPiece - _repeatedCord = source._repeatedCord - _packedInt32 = source._packedInt32 - _packedInt64 = source._packedInt64 - _packedUint32 = source._packedUint32 - _packedUint64 = source._packedUint64 - _packedSint32 = source._packedSint32 - _packedSint64 = source._packedSint64 - _packedFixed32 = source._packedFixed32 - _packedFixed64 = source._packedFixed64 - _packedSfixed32 = source._packedSfixed32 - _packedSfixed64 = source._packedSfixed64 - _packedFloat = source._packedFloat - _packedDouble = source._packedDouble - _packedBool = source._packedBool - _packedNestedEnum = source._packedNestedEnum - _unpackedInt32 = source._unpackedInt32 - _unpackedInt64 = source._unpackedInt64 - _unpackedUint32 = source._unpackedUint32 - _unpackedUint64 = source._unpackedUint64 - _unpackedSint32 = source._unpackedSint32 - _unpackedSint64 = source._unpackedSint64 - _unpackedFixed32 = source._unpackedFixed32 - _unpackedFixed64 = source._unpackedFixed64 - _unpackedSfixed32 = source._unpackedSfixed32 - _unpackedSfixed64 = source._unpackedSfixed64 - _unpackedFloat = source._unpackedFloat - _unpackedDouble = source._unpackedDouble - _unpackedBool = source._unpackedBool - _unpackedNestedEnum = source._unpackedNestedEnum - _mapInt32Int32 = source._mapInt32Int32 - _mapInt64Int64 = source._mapInt64Int64 - _mapUint32Uint32 = source._mapUint32Uint32 - _mapUint64Uint64 = source._mapUint64Uint64 - _mapSint32Sint32 = source._mapSint32Sint32 - _mapSint64Sint64 = source._mapSint64Sint64 - _mapFixed32Fixed32 = source._mapFixed32Fixed32 - _mapFixed64Fixed64 = source._mapFixed64Fixed64 - _mapSfixed32Sfixed32 = source._mapSfixed32Sfixed32 - _mapSfixed64Sfixed64 = source._mapSfixed64Sfixed64 - _mapInt32Float = source._mapInt32Float - _mapInt32Double = source._mapInt32Double - _mapBoolBool = source._mapBoolBool - _mapStringString = source._mapStringString - _mapStringBytes = source._mapStringBytes - _mapStringNestedMessage = source._mapStringNestedMessage - _mapStringForeignMessage = source._mapStringForeignMessage - _mapStringNestedEnum = source._mapStringNestedEnum - _mapStringForeignEnum = source._mapStringForeignEnum - _oneofField = source._oneofField - _data = source._data - _fieldname1 = source._fieldname1 - _fieldName2 = source._fieldName2 - _fieldName3 = source._fieldName3 - _field_Name4_ = source._field_Name4_ - _field0Name5 = source._field0Name5 - _field0Name6 = source._field0Name6 - _fieldName7 = source._fieldName7 - _fieldName8 = source._fieldName8 - _fieldName9 = source._fieldName9 - _fieldName10 = source._fieldName10 - _fieldName11 = source._fieldName11 - _fieldName12 = source._fieldName12 - __FieldName13 = source.__FieldName13 - __FieldName14 = source.__FieldName14 - _field_Name15 = source._field_Name15 - _field_Name16 = source._field_Name16 - _fieldName17__ = source._fieldName17__ - _fieldName18__ = source._fieldName18__ + var groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} } - } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} } - return _storage - } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return withExtendedLifetime(_storage) { (_storage: _StorageClass) in - if let v = _storage._optionalNestedMessage, !v.isInitialized {return false} - if let v = _storage._recursiveMessage, !v.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(_storage._repeatedNestedMessage) {return false} - if !SwiftProtobuf.Internal.areAllInitialized(_storage._mapStringNestedMessage) {return false} - if let v = _storage._oneofField, !v.isInitialized {return false} - return true - } + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil } - mutating func decodeMessage(decoder: inout D) throws { - _ = _uniqueStorage() - try withExtendedLifetime(_storage) { (_storage: _StorageClass) in - while let fieldNumber = try decoder.nextFieldNumber() { + /// message_set test case. + struct MessageSetCorrect: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() + } + + struct MessageSetCorrectExtension1: Sendable { + // 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 str: String { + get {_str ?? String()} + set {_str = newValue} + } + /// Returns true if `str` has been explicitly set. + var hasStr: Bool {self._str != nil} + /// Clears the value of `str`. Subsequent reads from it will return its default value. + mutating func clearStr() {self._str = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _str: String? = nil + } + + struct MessageSetCorrectExtension2: Sendable { + // 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 i: Int32 { + get {_i ?? 0} + set {_i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {self._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {self._i = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _i: Int32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct ProtobufTestMessages_Proto2_TestLargeOneof: Sendable { + // 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 largeOneof: ProtobufTestMessages_Proto2_TestLargeOneof.OneOf_LargeOneof? = nil + + var a1: ProtobufTestMessages_Proto2_TestLargeOneof.A1 { + get { + if case .a1(let v)? = largeOneof {return v} + return ProtobufTestMessages_Proto2_TestLargeOneof.A1() + } + set {largeOneof = .a1(newValue)} + } + + var a2: ProtobufTestMessages_Proto2_TestLargeOneof.A2 { + get { + if case .a2(let v)? = largeOneof {return v} + return ProtobufTestMessages_Proto2_TestLargeOneof.A2() + } + set {largeOneof = .a2(newValue)} + } + + var a3: ProtobufTestMessages_Proto2_TestLargeOneof.A3 { + get { + if case .a3(let v)? = largeOneof {return v} + return ProtobufTestMessages_Proto2_TestLargeOneof.A3() + } + set {largeOneof = .a3(newValue)} + } + + var a4: ProtobufTestMessages_Proto2_TestLargeOneof.A4 { + get { + if case .a4(let v)? = largeOneof {return v} + return ProtobufTestMessages_Proto2_TestLargeOneof.A4() + } + set {largeOneof = .a4(newValue)} + } + + var a5: ProtobufTestMessages_Proto2_TestLargeOneof.A5 { + get { + if case .a5(let v)? = largeOneof {return v} + return ProtobufTestMessages_Proto2_TestLargeOneof.A5() + } + set {largeOneof = .a5(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_LargeOneof: Equatable, Sendable { + case a1(ProtobufTestMessages_Proto2_TestLargeOneof.A1) + case a2(ProtobufTestMessages_Proto2_TestLargeOneof.A2) + case a3(ProtobufTestMessages_Proto2_TestLargeOneof.A3) + case a4(ProtobufTestMessages_Proto2_TestLargeOneof.A4) + case a5(ProtobufTestMessages_Proto2_TestLargeOneof.A5) + + } + + struct A1: Sendable { + // 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 A2: Sendable { + // 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 A3: Sendable { + // 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 A4: Sendable { + // 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 A5: Sendable { + // 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() {} + } + + init() {} +} + +// MARK: - Extension support defined in test_messages_proto2.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect { + + var ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension1_messageSetExtension: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1 { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1()} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension1_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension2_messageSetExtension: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2 { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) ?? ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2()} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension2_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2 { + + var ProtobufTestMessages_Proto2_extensionInt32: Int32 { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32) ?? 0} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_Extensions_extension_int32` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_extensionInt32: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_Extensions_extension_int32`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_extensionInt32() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_extension_int32) + } + + var ProtobufTestMessages_Proto2_groupField: ProtobufTestMessages_Proto2_GroupField { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_GroupField) ?? ProtobufTestMessages_Proto2_GroupField()} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_GroupField, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_Extensions_GroupField` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_groupField: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_GroupField) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_Extensions_GroupField`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_groupField() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_Extensions_GroupField) + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect { + + var ProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1 { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1()} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2 { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2()} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Proto2_TestAllTypesProto2_ExtensionWithOneof_extensionWithOneof: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof { + get {return getExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof) ?? ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof()} + set {setExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof` + /// has been explicitly set. + var hasProtobufTestMessages_Proto2_TestAllTypesProto2_ExtensionWithOneof_extensionWithOneof: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof) + } + /// Clears the value of extension `ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Proto2_TestAllTypesProto2_ExtensionWithOneof_extensionWithOneof() { + clearExtensionValue(ext: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof) + } + +} + +// MARK: - File's ExtensionMap: ProtobufTestMessages_Proto2_TestMessagesProto2_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 ProtobufTestMessages_Proto2_TestMessagesProto2_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + ProtobufTestMessages_Proto2_Extensions_extension_int32, + ProtobufTestMessages_Proto2_Extensions_GroupField, + ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, + ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, + ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof, + ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, + ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension +] + +// 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 ProtobufTestMessages_Proto2_Extensions_extension_int32 = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2>( + _protobuf_fieldNumber: 120, + fieldName: "protobuf_test_messages.proto2.extension_int32" +) + +let ProtobufTestMessages_Proto2_Extensions_GroupField = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2>( + _protobuf_fieldNumber: 121, + fieldName: "protobuf_test_messages.proto2.groupfield" +) + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 1547769, + fieldName: "protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension1" + ) + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 4135312, + fieldName: "protobuf_test_messages.proto2.TestAllTypesProto2.MessageSetCorrectExtension2" + ) + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof { + enum Extensions { + static let extension_with_oneof = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 123456789, + fieldName: "protobuf_test_messages.proto2.TestAllTypesProto2.ExtensionWithOneof" + ) + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 1547769, + fieldName: "protobuf_test_messages.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension1" + ) + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 4135312, + fieldName: "protobuf_test_messages.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension2" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "protobuf_test_messages.proto2" + +extension ProtobufTestMessages_Proto2_ForeignEnumProto2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypesProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{4}\u{2}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{4}\u{2}optional_string_piece\0\u{3}optional_cord\0\u{4}\u{2}recursive_message\0\u{4}\u{4}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{4}\u{2}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_nested_message\0\u{3}map_string_foreign_message\0\u{3}map_string_nested_enum\0\u{3}map_string_foreign_enum\0\u{3}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_nested_enum\0\u{3}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_nested_enum\0\u{3}map_int32_nested_message\0\u{3}map_int32_bool\0\u{4}\u{7}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_bool\0\u{3}oneof_uint64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_enum\0\u{8}R\u{1}Data\0\u{8}\u{3}MultiWordGroupField\0\u{4}%default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{2}R\u{2}fieldname1\0\u{3}field_name2\0\u{3}_field_name3\0\u{3}field__name4_\0\u{1}field0name5\0\u{3}field_0_name6\0\u{1}fieldName7\0\u{1}FieldName8\0\u{3}field_Name9\0\u{3}Field_Name10\0\u{3}FIELD_NAME11\0\u{3}FIELD_name12\0\u{3}__field_name13\0\u{3}__Field_name14\0\u{3}field__name15\0\u{3}field__Name16\0\u{3}field_name17__\0\u{3}Field_name18__\0\u{4}R\u{1}message_set_correct\0\u{b}reserved_field\0\u{c}h\u{f}hL\u{2}\u{c}\u{7f}Ht\u{3}\u{1}") + + fileprivate class _StorageClass { + var _optionalInt32: Int32? = nil + var _optionalInt64: Int64? = nil + var _optionalUint32: UInt32? = nil + var _optionalUint64: UInt64? = nil + var _optionalSint32: Int32? = nil + var _optionalSint64: Int64? = nil + var _optionalFixed32: UInt32? = nil + var _optionalFixed64: UInt64? = nil + var _optionalSfixed32: Int32? = nil + var _optionalSfixed64: Int64? = nil + var _optionalFloat: Float? = nil + var _optionalDouble: Double? = nil + var _optionalBool: Bool? = nil + var _optionalString: String? = nil + var _optionalBytes: Data? = nil + var _optionalNestedMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage? = nil + var _optionalForeignMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2? = nil + var _optionalNestedEnum: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum? = nil + var _optionalForeignEnum: ProtobufTestMessages_Proto2_ForeignEnumProto2? = nil + var _optionalStringPiece: String? = nil + var _optionalCord: String? = nil + var _recursiveMessage: ProtobufTestMessages_Proto2_TestAllTypesProto2? = nil + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedNestedMessage: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage] = [] + var _repeatedForeignMessage: [ProtobufTestMessages_Proto2_ForeignMessageProto2] = [] + var _repeatedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _repeatedForeignEnum: [ProtobufTestMessages_Proto2_ForeignEnumProto2] = [] + var _repeatedStringPiece: [String] = [] + var _repeatedCord: [String] = [] + var _packedInt32: [Int32] = [] + var _packedInt64: [Int64] = [] + var _packedUint32: [UInt32] = [] + var _packedUint64: [UInt64] = [] + var _packedSint32: [Int32] = [] + var _packedSint64: [Int64] = [] + var _packedFixed32: [UInt32] = [] + var _packedFixed64: [UInt64] = [] + var _packedSfixed32: [Int32] = [] + var _packedSfixed64: [Int64] = [] + var _packedFloat: [Float] = [] + var _packedDouble: [Double] = [] + var _packedBool: [Bool] = [] + var _packedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _unpackedInt32: [Int32] = [] + var _unpackedInt64: [Int64] = [] + var _unpackedUint32: [UInt32] = [] + var _unpackedUint64: [UInt64] = [] + var _unpackedSint32: [Int32] = [] + var _unpackedSint64: [Int64] = [] + var _unpackedFixed32: [UInt32] = [] + var _unpackedFixed64: [UInt64] = [] + var _unpackedSfixed32: [Int32] = [] + var _unpackedSfixed64: [Int64] = [] + var _unpackedFloat: [Float] = [] + var _unpackedDouble: [Double] = [] + var _unpackedBool: [Bool] = [] + var _unpackedNestedEnum: [ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _mapInt32Int32: Dictionary = [:] + var _mapInt64Int64: Dictionary = [:] + var _mapUint32Uint32: Dictionary = [:] + var _mapUint64Uint64: Dictionary = [:] + var _mapSint32Sint32: Dictionary = [:] + var _mapSint64Sint64: Dictionary = [:] + var _mapFixed32Fixed32: Dictionary = [:] + var _mapFixed64Fixed64: Dictionary = [:] + var _mapSfixed32Sfixed32: Dictionary = [:] + var _mapSfixed64Sfixed64: Dictionary = [:] + var _mapInt32Bool: Dictionary = [:] + var _mapInt32Float: Dictionary = [:] + var _mapInt32Double: Dictionary = [:] + var _mapInt32NestedMessage: Dictionary = [:] + var _mapBoolBool: Dictionary = [:] + var _mapStringString: Dictionary = [:] + var _mapStringBytes: Dictionary = [:] + var _mapStringNestedMessage: Dictionary = [:] + var _mapStringForeignMessage: Dictionary = [:] + var _mapStringNestedEnum: Dictionary = [:] + var _mapStringForeignEnum: Dictionary = [:] + var _oneofField: ProtobufTestMessages_Proto2_TestAllTypesProto2.OneOf_OneofField? + var _data: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage? = nil + var _multiWordGroupField: ProtobufTestMessages_Proto2_TestAllTypesProto2.MultiWordGroupField? = nil + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + var _fieldname1: Int32? = nil + var _fieldName2: Int32? = nil + var _fieldName3: Int32? = nil + var _field_Name4_: Int32? = nil + var _field0Name5: Int32? = nil + var _field0Name6: Int32? = nil + var _fieldName7: Int32? = nil + var _fieldName8: Int32? = nil + var _fieldName9: Int32? = nil + var _fieldName10: Int32? = nil + var _fieldName11: Int32? = nil + var _fieldName12: Int32? = nil + var __FieldName13: Int32? = nil + var __FieldName14: Int32? = nil + var _field_Name15: Int32? = nil + var _field_Name16: Int32? = nil + var _fieldName17__: Int32? = nil + var _fieldName18__: Int32? = nil + var _messageSetCorrect: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalNestedMessage = source._optionalNestedMessage + _optionalForeignMessage = source._optionalForeignMessage + _optionalNestedEnum = source._optionalNestedEnum + _optionalForeignEnum = source._optionalForeignEnum + _optionalStringPiece = source._optionalStringPiece + _optionalCord = source._optionalCord + _recursiveMessage = source._recursiveMessage + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedForeignMessage = source._repeatedForeignMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _repeatedForeignEnum = source._repeatedForeignEnum + _repeatedStringPiece = source._repeatedStringPiece + _repeatedCord = source._repeatedCord + _packedInt32 = source._packedInt32 + _packedInt64 = source._packedInt64 + _packedUint32 = source._packedUint32 + _packedUint64 = source._packedUint64 + _packedSint32 = source._packedSint32 + _packedSint64 = source._packedSint64 + _packedFixed32 = source._packedFixed32 + _packedFixed64 = source._packedFixed64 + _packedSfixed32 = source._packedSfixed32 + _packedSfixed64 = source._packedSfixed64 + _packedFloat = source._packedFloat + _packedDouble = source._packedDouble + _packedBool = source._packedBool + _packedNestedEnum = source._packedNestedEnum + _unpackedInt32 = source._unpackedInt32 + _unpackedInt64 = source._unpackedInt64 + _unpackedUint32 = source._unpackedUint32 + _unpackedUint64 = source._unpackedUint64 + _unpackedSint32 = source._unpackedSint32 + _unpackedSint64 = source._unpackedSint64 + _unpackedFixed32 = source._unpackedFixed32 + _unpackedFixed64 = source._unpackedFixed64 + _unpackedSfixed32 = source._unpackedSfixed32 + _unpackedSfixed64 = source._unpackedSfixed64 + _unpackedFloat = source._unpackedFloat + _unpackedDouble = source._unpackedDouble + _unpackedBool = source._unpackedBool + _unpackedNestedEnum = source._unpackedNestedEnum + _mapInt32Int32 = source._mapInt32Int32 + _mapInt64Int64 = source._mapInt64Int64 + _mapUint32Uint32 = source._mapUint32Uint32 + _mapUint64Uint64 = source._mapUint64Uint64 + _mapSint32Sint32 = source._mapSint32Sint32 + _mapSint64Sint64 = source._mapSint64Sint64 + _mapFixed32Fixed32 = source._mapFixed32Fixed32 + _mapFixed64Fixed64 = source._mapFixed64Fixed64 + _mapSfixed32Sfixed32 = source._mapSfixed32Sfixed32 + _mapSfixed64Sfixed64 = source._mapSfixed64Sfixed64 + _mapInt32Bool = source._mapInt32Bool + _mapInt32Float = source._mapInt32Float + _mapInt32Double = source._mapInt32Double + _mapInt32NestedMessage = source._mapInt32NestedMessage + _mapBoolBool = source._mapBoolBool + _mapStringString = source._mapStringString + _mapStringBytes = source._mapStringBytes + _mapStringNestedMessage = source._mapStringNestedMessage + _mapStringForeignMessage = source._mapStringForeignMessage + _mapStringNestedEnum = source._mapStringNestedEnum + _mapStringForeignEnum = source._mapStringForeignEnum + _oneofField = source._oneofField + _data = source._data + _multiWordGroupField = source._multiWordGroupField + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + _fieldname1 = source._fieldname1 + _fieldName2 = source._fieldName2 + _fieldName3 = source._fieldName3 + _field_Name4_ = source._field_Name4_ + _field0Name5 = source._field0Name5 + _field0Name6 = source._field0Name6 + _fieldName7 = source._fieldName7 + _fieldName8 = source._fieldName8 + _fieldName9 = source._fieldName9 + _fieldName10 = source._fieldName10 + _fieldName11 = source._fieldName11 + _fieldName12 = source._fieldName12 + __FieldName13 = source.__FieldName13 + __FieldName14 = source.__FieldName14 + _field_Name15 = source._field_Name15 + _field_Name16 = source._field_Name16 + _fieldName17__ = source._fieldName17__ + _fieldName18__ = source._fieldName18__ + _messageSetCorrect = source._messageSetCorrect + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._optionalNestedMessage, !v.isInitialized {return false} + if let v = _storage._recursiveMessage, !v.isInitialized {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._repeatedNestedMessage) {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._mapInt32NestedMessage) {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._mapStringNestedMessage) {return false} + if let v = _storage._oneofField, !v.isInitialized {return false} + if let v = _storage._messageSetCorrect, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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 @@ -1888,6 +2675,8 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, case 100: try { try decoder.decodeRepeatedDoubleField(value: &_storage._unpackedDouble) }() case 101: try { try decoder.decodeRepeatedBoolField(value: &_storage._unpackedBool) }() case 102: try { try decoder.decodeRepeatedEnumField(value: &_storage._unpackedNestedEnum) }() + case 103: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32NestedMessage) }() + case 104: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bool) }() case 111: try { var v: UInt32? try decoder.decodeSingularUInt32Field(value: &v) @@ -1966,6 +2755,22 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, } }() case 201: try { try decoder.decodeSingularGroupField(value: &_storage._data) }() + case 204: try { try decoder.decodeSingularGroupField(value: &_storage._multiWordGroupField) }() + case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 242: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 243: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 244: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 245: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 246: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 247: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 248: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 249: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 250: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 251: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 252: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 253: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 254: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 255: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldname1) }() case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName2) }() case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName3) }() @@ -1984,6 +2789,7 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name16) }() case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName17__) }() case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName18__) }() + case 500: try { try decoder.decodeSingularMessageField(value: &_storage._messageSetCorrect) }() case 120..<201: try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Proto2_TestAllTypesProto2.self, fieldNumber: fieldNumber) }() default: break @@ -2229,261 +3035,1328 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, if !_storage._unpackedInt32.isEmpty { try visitor.visitRepeatedInt32Field(value: _storage._unpackedInt32, fieldNumber: 89) } - if !_storage._unpackedInt64.isEmpty { - try visitor.visitRepeatedInt64Field(value: _storage._unpackedInt64, fieldNumber: 90) + if !_storage._unpackedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._unpackedInt64, fieldNumber: 90) + } + if !_storage._unpackedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._unpackedUint32, fieldNumber: 91) + } + if !_storage._unpackedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._unpackedUint64, fieldNumber: 92) + } + if !_storage._unpackedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._unpackedSint32, fieldNumber: 93) + } + if !_storage._unpackedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._unpackedSint64, fieldNumber: 94) + } + if !_storage._unpackedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._unpackedFixed32, fieldNumber: 95) + } + if !_storage._unpackedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._unpackedFixed64, fieldNumber: 96) + } + if !_storage._unpackedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._unpackedSfixed32, fieldNumber: 97) + } + if !_storage._unpackedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._unpackedSfixed64, fieldNumber: 98) + } + if !_storage._unpackedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._unpackedFloat, fieldNumber: 99) + } + if !_storage._unpackedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._unpackedDouble, fieldNumber: 100) + } + if !_storage._unpackedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._unpackedBool, fieldNumber: 101) + } + if !_storage._unpackedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._unpackedNestedEnum, fieldNumber: 102) + } + if !_storage._mapInt32NestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32NestedMessage, fieldNumber: 103) + } + if !_storage._mapInt32Bool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bool, fieldNumber: 104) + } + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case .oneofBool?: try { + guard case .oneofBool(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 115) + }() + case .oneofUint64?: try { + guard case .oneofUint64(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 116) + }() + case .oneofFloat?: try { + guard case .oneofFloat(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularFloatField(value: v, fieldNumber: 117) + }() + case .oneofDouble?: try { + guard case .oneofDouble(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularDoubleField(value: v, fieldNumber: 118) + }() + case .oneofEnum?: try { + guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 119) + }() + case nil: break + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201) + try { if let v = _storage._data { + try visitor.visitSingularGroupField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._multiWordGroupField { + try visitor.visitSingularGroupField(value: v, fieldNumber: 204) + } }() + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 241) + } }() + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 242) + } }() + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 243) + } }() + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 244) + } }() + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 245) + } }() + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 246) + } }() + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 247) + } }() + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 248) + } }() + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 249) + } }() + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 250) + } }() + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 251) + } }() + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 252) + } }() + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 253) + } }() + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 254) + } }() + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 255) + } }() + try { if let v = _storage._fieldname1 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 401) + } }() + try { if let v = _storage._fieldName2 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 402) + } }() + try { if let v = _storage._fieldName3 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 403) + } }() + try { if let v = _storage._field_Name4_ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 404) + } }() + try { if let v = _storage._field0Name5 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 405) + } }() + try { if let v = _storage._field0Name6 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 406) + } }() + try { if let v = _storage._fieldName7 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 407) + } }() + try { if let v = _storage._fieldName8 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 408) + } }() + try { if let v = _storage._fieldName9 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 409) + } }() + try { if let v = _storage._fieldName10 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 410) + } }() + try { if let v = _storage._fieldName11 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 411) + } }() + try { if let v = _storage._fieldName12 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 412) + } }() + try { if let v = _storage.__FieldName13 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 413) + } }() + try { if let v = _storage.__FieldName14 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 414) + } }() + try { if let v = _storage._field_Name15 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 415) + } }() + try { if let v = _storage._field_Name16 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 416) + } }() + try { if let v = _storage._fieldName17__ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 417) + } }() + try { if let v = _storage._fieldName18__ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 418) + } }() + try { if let v = _storage._messageSetCorrect { + try visitor.visitSingularMessageField(value: v, fieldNumber: 500) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} + if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} + if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} + if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} + if _storage._repeatedCord != rhs_storage._repeatedCord {return false} + if _storage._packedInt32 != rhs_storage._packedInt32 {return false} + if _storage._packedInt64 != rhs_storage._packedInt64 {return false} + if _storage._packedUint32 != rhs_storage._packedUint32 {return false} + if _storage._packedUint64 != rhs_storage._packedUint64 {return false} + if _storage._packedSint32 != rhs_storage._packedSint32 {return false} + if _storage._packedSint64 != rhs_storage._packedSint64 {return false} + if _storage._packedFixed32 != rhs_storage._packedFixed32 {return false} + if _storage._packedFixed64 != rhs_storage._packedFixed64 {return false} + if _storage._packedSfixed32 != rhs_storage._packedSfixed32 {return false} + if _storage._packedSfixed64 != rhs_storage._packedSfixed64 {return false} + if _storage._packedFloat != rhs_storage._packedFloat {return false} + if _storage._packedDouble != rhs_storage._packedDouble {return false} + if _storage._packedBool != rhs_storage._packedBool {return false} + if _storage._packedNestedEnum != rhs_storage._packedNestedEnum {return false} + if _storage._unpackedInt32 != rhs_storage._unpackedInt32 {return false} + if _storage._unpackedInt64 != rhs_storage._unpackedInt64 {return false} + if _storage._unpackedUint32 != rhs_storage._unpackedUint32 {return false} + if _storage._unpackedUint64 != rhs_storage._unpackedUint64 {return false} + if _storage._unpackedSint32 != rhs_storage._unpackedSint32 {return false} + if _storage._unpackedSint64 != rhs_storage._unpackedSint64 {return false} + if _storage._unpackedFixed32 != rhs_storage._unpackedFixed32 {return false} + if _storage._unpackedFixed64 != rhs_storage._unpackedFixed64 {return false} + if _storage._unpackedSfixed32 != rhs_storage._unpackedSfixed32 {return false} + if _storage._unpackedSfixed64 != rhs_storage._unpackedSfixed64 {return false} + if _storage._unpackedFloat != rhs_storage._unpackedFloat {return false} + if _storage._unpackedDouble != rhs_storage._unpackedDouble {return false} + if _storage._unpackedBool != rhs_storage._unpackedBool {return false} + if _storage._unpackedNestedEnum != rhs_storage._unpackedNestedEnum {return false} + if _storage._mapInt32Int32 != rhs_storage._mapInt32Int32 {return false} + if _storage._mapInt64Int64 != rhs_storage._mapInt64Int64 {return false} + if _storage._mapUint32Uint32 != rhs_storage._mapUint32Uint32 {return false} + if _storage._mapUint64Uint64 != rhs_storage._mapUint64Uint64 {return false} + if _storage._mapSint32Sint32 != rhs_storage._mapSint32Sint32 {return false} + if _storage._mapSint64Sint64 != rhs_storage._mapSint64Sint64 {return false} + if _storage._mapFixed32Fixed32 != rhs_storage._mapFixed32Fixed32 {return false} + if _storage._mapFixed64Fixed64 != rhs_storage._mapFixed64Fixed64 {return false} + if _storage._mapSfixed32Sfixed32 != rhs_storage._mapSfixed32Sfixed32 {return false} + if _storage._mapSfixed64Sfixed64 != rhs_storage._mapSfixed64Sfixed64 {return false} + if _storage._mapInt32Bool != rhs_storage._mapInt32Bool {return false} + if _storage._mapInt32Float != rhs_storage._mapInt32Float {return false} + if _storage._mapInt32Double != rhs_storage._mapInt32Double {return false} + if _storage._mapInt32NestedMessage != rhs_storage._mapInt32NestedMessage {return false} + if _storage._mapBoolBool != rhs_storage._mapBoolBool {return false} + if _storage._mapStringString != rhs_storage._mapStringString {return false} + if _storage._mapStringBytes != rhs_storage._mapStringBytes {return false} + if _storage._mapStringNestedMessage != rhs_storage._mapStringNestedMessage {return false} + if _storage._mapStringForeignMessage != rhs_storage._mapStringForeignMessage {return false} + if _storage._mapStringNestedEnum != rhs_storage._mapStringNestedEnum {return false} + if _storage._mapStringForeignEnum != rhs_storage._mapStringForeignEnum {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + if _storage._data != rhs_storage._data {return false} + if _storage._multiWordGroupField != rhs_storage._multiWordGroupField {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} + if _storage._fieldname1 != rhs_storage._fieldname1 {return false} + if _storage._fieldName2 != rhs_storage._fieldName2 {return false} + if _storage._fieldName3 != rhs_storage._fieldName3 {return false} + if _storage._field_Name4_ != rhs_storage._field_Name4_ {return false} + if _storage._field0Name5 != rhs_storage._field0Name5 {return false} + if _storage._field0Name6 != rhs_storage._field0Name6 {return false} + if _storage._fieldName7 != rhs_storage._fieldName7 {return false} + if _storage._fieldName8 != rhs_storage._fieldName8 {return false} + if _storage._fieldName9 != rhs_storage._fieldName9 {return false} + if _storage._fieldName10 != rhs_storage._fieldName10 {return false} + if _storage._fieldName11 != rhs_storage._fieldName11 {return false} + if _storage._fieldName12 != rhs_storage._fieldName12 {return false} + if _storage.__FieldName13 != rhs_storage.__FieldName13 {return false} + if _storage.__FieldName14 != rhs_storage.__FieldName14 {return false} + if _storage._field_Name15 != rhs_storage._field_Name15 {return false} + if _storage._field_Name16 != rhs_storage._field_Name16 {return false} + if _storage._fieldName17__ != rhs_storage._fieldName17__ {return false} + if _storage._fieldName18__ != rhs_storage._fieldName18__ {return false} + if _storage._messageSetCorrect != rhs_storage._messageSetCorrect {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _corecursive: ProtobufTestMessages_Proto2_TestAllTypesProto2? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._corecursive, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + default: break + } } - if !_storage._unpackedUint32.isEmpty { - try visitor.visitRepeatedUInt32Field(value: _storage._unpackedUint32, fieldNumber: 91) + } + } + + func traverse(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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + return true } - if !_storage._unpackedUint64.isEmpty { - try visitor.visitRepeatedUInt64Field(value: _storage._unpackedUint64, fieldNumber: 92) + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}J\u{3}group_int32\0\u{3}group_uint32\0") + + 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 202: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 203: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + default: break } - if !_storage._unpackedSint32.isEmpty { - try visitor.visitRepeatedSInt32Field(value: _storage._unpackedSint32, fieldNumber: 93) + } + } + + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 202) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 203) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MultiWordGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".MultiWordGroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}M\u{3}group_int32\0\u{3}group_uint32\0") + + 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 205: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 206: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + default: break } - if !_storage._unpackedSint64.isEmpty { - try visitor.visitRepeatedSInt64Field(value: _storage._unpackedSint64, fieldNumber: 94) + } + } + + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 205) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 206) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MultiWordGroupField, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MultiWordGroupField) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect.self) + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrectExtension1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{19}str\0") + + 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 25: try { try decoder.decodeSingularStringField(value: &self._str) }() + default: break } - if !_storage._unpackedFixed32.isEmpty { - try visitor.visitRepeatedFixed32Field(value: _storage._unpackedFixed32, fieldNumber: 95) + } + } + + 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 + try { if let v = self._str { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1) -> Bool { + if lhs._str != rhs._str {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrectExtension2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{9}i\0") + + 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 9: try { try decoder.decodeSingularInt32Field(value: &self._i) }() + default: break } - if !_storage._unpackedFixed64.isEmpty { - try visitor.visitRepeatedFixed64Field(value: _storage._unpackedFixed64, fieldNumber: 96) + } + } + + 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 + try { if let v = self._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2) -> Bool { + if lhs._i != rhs._i {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".ExtensionWithOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .a(v) + } + }() + case 2: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .b(v) + } + }() + default: break } - if !_storage._unpackedSfixed32.isEmpty { - try visitor.visitRepeatedSFixed32Field(value: _storage._unpackedSfixed32, fieldNumber: 97) + } + } + + 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.oneofField { + case .a?: try { + guard case .a(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + }() + case .b?: try { + guard case .b(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.ExtensionWithOneof) -> Bool { + if lhs.oneofField != rhs.oneofField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_ForeignMessageProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessageProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") + + 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._c) }() + default: break } - if !_storage._unpackedSfixed64.isEmpty { - try visitor.visitRepeatedSFixed64Field(value: _storage._unpackedSfixed64, fieldNumber: 98) + } + } + + 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 + try { if let v = self._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_ForeignMessageProto2, rhs: ProtobufTestMessages_Proto2_ForeignMessageProto2) -> Bool { + if lhs._c != rhs._c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_GroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}z\u{1}group_int32\0\u{3}group_uint32\0") + + 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 122: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 123: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + default: break } - if !_storage._unpackedFloat.isEmpty { - try visitor.visitRepeatedFloatField(value: _storage._unpackedFloat, fieldNumber: 99) + } + } + + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 122) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 123) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_GroupField, rhs: ProtobufTestMessages_Proto2_GroupField) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".UnknownToTestAllTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}i\u{f}optional_int32\0\u{3}optional_string\0\u{3}nested_message\0\u{7}OptionalGroup\0\u{4}\u{2}optional_bool\0\u{4}\u{5}repeated_int32\0") + + 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 1001: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32) }() + case 1002: try { try decoder.decodeSingularStringField(value: &self._optionalString) }() + case 1003: try { try decoder.decodeSingularMessageField(value: &self._nestedMessage) }() + case 1004: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() + case 1006: try { try decoder.decodeSingularBoolField(value: &self._optionalBool) }() + case 1011: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() + default: break } - if !_storage._unpackedDouble.isEmpty { - try visitor.visitRepeatedDoubleField(value: _storage._unpackedDouble, fieldNumber: 100) + } + } + + 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 + try { if let v = self._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1001) + } }() + try { if let v = self._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1002) + } }() + try { if let v = self._nestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1003) + } }() + try { if let v = self._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 1004) + } }() + try { if let v = self._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1006) + } }() + if !self.repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 1011) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes, rhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes) -> Bool { + if lhs._optionalInt32 != rhs._optionalInt32 {return false} + if lhs._optionalString != rhs._optionalString {return false} + if lhs._nestedMessage != rhs._nestedMessage {return false} + if lhs._optionalGroup != rhs._optionalGroup {return false} + if lhs._optionalBool != rhs._optionalBool {return false} + if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_UnknownToTestAllTypes.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") + + 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._a) }() + default: break } - if !_storage._unpackedBool.isEmpty { - try visitor.visitRepeatedBoolField(value: _storage._unpackedBool, fieldNumber: 101) + } + } + + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup, rhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_NullHypothesisProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NullHypothesisProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_NullHypothesisProto2, rhs: ProtobufTestMessages_Proto2_NullHypothesisProto2) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_EnumOnlyProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumOnlyProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_EnumOnlyProto2, rhs: ProtobufTestMessages_Proto2_EnumOnlyProto2) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_EnumOnlyProto2.BoolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0kFalse\0\u{1}kTrue\0") +} + +extension ProtobufTestMessages_Proto2_OneStringProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OneStringProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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._data) }() + default: break } - if !_storage._unpackedNestedEnum.isEmpty { - try visitor.visitRepeatedEnumField(value: _storage._unpackedNestedEnum, fieldNumber: 102) + } + } + + 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 + try { if let v = self._data { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_OneStringProto2, rhs: ProtobufTestMessages_Proto2_OneStringProto2) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_ProtoWithKeywords: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ProtoWithKeywords" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}inline\0\u{1}concept\0\u{1}requires\0") + + 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._inline) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._concept) }() + case 3: try { try decoder.decodeRepeatedStringField(value: &self.requires) }() + default: break } - switch _storage._oneofField { - case .oneofUint32?: try { - guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) - }() - case .oneofNestedMessage?: try { - guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 112) - }() - case .oneofString?: try { - guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 113) - }() - case .oneofBytes?: try { - guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 114) - }() - case .oneofBool?: try { - guard case .oneofBool(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularBoolField(value: v, fieldNumber: 115) - }() - case .oneofUint64?: try { - guard case .oneofUint64(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularUInt64Field(value: v, fieldNumber: 116) - }() - case .oneofFloat?: try { - guard case .oneofFloat(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularFloatField(value: v, fieldNumber: 117) - }() - case .oneofDouble?: try { - guard case .oneofDouble(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularDoubleField(value: v, fieldNumber: 118) - }() - case .oneofEnum?: try { - guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularEnumField(value: v, fieldNumber: 119) - }() - case nil: 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 + try { if let v = self._inline { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._concept { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + if !self.requires.isEmpty { + try visitor.visitRepeatedStringField(value: self.requires, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_ProtoWithKeywords, rhs: ProtobufTestMessages_Proto2_ProtoWithKeywords) -> Bool { + if lhs._inline != rhs._inline {return false} + if lhs._concept != rhs._concept {return false} + if lhs.requires != rhs.requires {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllRequiredTypesProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_int32\0\u{3}required_int64\0\u{3}required_uint32\0\u{3}required_uint64\0\u{3}required_sint32\0\u{3}required_sint64\0\u{3}required_fixed32\0\u{3}required_fixed64\0\u{3}required_sfixed32\0\u{3}required_sfixed64\0\u{3}required_float\0\u{3}required_double\0\u{3}required_bool\0\u{3}required_string\0\u{3}required_bytes\0\u{4}\u{3}required_nested_message\0\u{3}required_foreign_message\0\u{4}\u{2}required_nested_enum\0\u{3}required_foreign_enum\0\u{4}\u{2}required_string_piece\0\u{3}required_cord\0\u{4}\u{2}recursive_message\0\u{3}optional_recursive_message\0\u{8}m\u{2}Data\0\u{4}(default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{c}h\u{f}hL\u{2}") + + fileprivate class _StorageClass { + var _requiredInt32: Int32? = nil + var _requiredInt64: Int64? = nil + var _requiredUint32: UInt32? = nil + var _requiredUint64: UInt64? = nil + var _requiredSint32: Int32? = nil + var _requiredSint64: Int64? = nil + var _requiredFixed32: UInt32? = nil + var _requiredFixed64: UInt64? = nil + var _requiredSfixed32: Int32? = nil + var _requiredSfixed64: Int64? = nil + var _requiredFloat: Float? = nil + var _requiredDouble: Double? = nil + var _requiredBool: Bool? = nil + var _requiredString: String? = nil + var _requiredBytes: Data? = nil + var _requiredNestedMessage: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage? = nil + var _requiredForeignMessage: ProtobufTestMessages_Proto2_ForeignMessageProto2? = nil + var _requiredNestedEnum: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedEnum? = nil + var _requiredForeignEnum: ProtobufTestMessages_Proto2_ForeignEnumProto2? = nil + var _requiredStringPiece: String? = nil + var _requiredCord: String? = nil + var _recursiveMessage: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2? = nil + var _optionalRecursiveMessage: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2? = nil + var _data: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage? = nil + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _requiredInt32 = source._requiredInt32 + _requiredInt64 = source._requiredInt64 + _requiredUint32 = source._requiredUint32 + _requiredUint64 = source._requiredUint64 + _requiredSint32 = source._requiredSint32 + _requiredSint64 = source._requiredSint64 + _requiredFixed32 = source._requiredFixed32 + _requiredFixed64 = source._requiredFixed64 + _requiredSfixed32 = source._requiredSfixed32 + _requiredSfixed64 = source._requiredSfixed64 + _requiredFloat = source._requiredFloat + _requiredDouble = source._requiredDouble + _requiredBool = source._requiredBool + _requiredString = source._requiredString + _requiredBytes = source._requiredBytes + _requiredNestedMessage = source._requiredNestedMessage + _requiredForeignMessage = source._requiredForeignMessage + _requiredNestedEnum = source._requiredNestedEnum + _requiredForeignEnum = source._requiredForeignEnum + _requiredStringPiece = source._requiredStringPiece + _requiredCord = source._requiredCord + _recursiveMessage = source._recursiveMessage + _optionalRecursiveMessage = source._optionalRecursiveMessage + _data = source._data + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._requiredInt32 == nil {return false} + if _storage._requiredInt64 == nil {return false} + if _storage._requiredUint32 == nil {return false} + if _storage._requiredUint64 == nil {return false} + if _storage._requiredSint32 == nil {return false} + if _storage._requiredSint64 == nil {return false} + if _storage._requiredFixed32 == nil {return false} + if _storage._requiredFixed64 == nil {return false} + if _storage._requiredSfixed32 == nil {return false} + if _storage._requiredSfixed64 == nil {return false} + if _storage._requiredFloat == nil {return false} + if _storage._requiredDouble == nil {return false} + if _storage._requiredBool == nil {return false} + if _storage._requiredString == nil {return false} + if _storage._requiredBytes == nil {return false} + if _storage._requiredNestedMessage == nil {return false} + if _storage._requiredForeignMessage == nil {return false} + if _storage._requiredNestedEnum == nil {return false} + if _storage._requiredForeignEnum == nil {return false} + if _storage._requiredStringPiece == nil {return false} + if _storage._requiredCord == nil {return false} + if _storage._recursiveMessage == nil {return false} + if _storage._data == nil {return false} + if _storage._defaultInt32 == nil {return false} + if _storage._defaultInt64 == nil {return false} + if _storage._defaultUint32 == nil {return false} + if _storage._defaultUint64 == nil {return false} + if _storage._defaultSint32 == nil {return false} + if _storage._defaultSint64 == nil {return false} + if _storage._defaultFixed32 == nil {return false} + if _storage._defaultFixed64 == nil {return false} + if _storage._defaultSfixed32 == nil {return false} + if _storage._defaultSfixed64 == nil {return false} + if _storage._defaultFloat == nil {return false} + if _storage._defaultDouble == nil {return false} + if _storage._defaultBool == nil {return false} + if _storage._defaultString == nil {return false} + if _storage._defaultBytes == nil {return false} + if let v = _storage._requiredNestedMessage, !v.isInitialized {return false} + if let v = _storage._recursiveMessage, !v.isInitialized {return false} + if let v = _storage._optionalRecursiveMessage, !v.isInitialized {return false} + if let v = _storage._data, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._requiredInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._requiredInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._requiredUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._requiredUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._requiredSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._requiredSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._requiredFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._requiredFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._requiredSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._requiredSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._requiredFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._requiredDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._requiredBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._requiredString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._requiredBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._requiredNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._requiredForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._requiredNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._requiredForeignEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._requiredStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._requiredCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 28: try { try decoder.decodeSingularMessageField(value: &_storage._optionalRecursiveMessage) }() + case 201: try { try decoder.decodeSingularGroupField(value: &_storage._data) }() + case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 242: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 243: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 244: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 245: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 246: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 247: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 248: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 249: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 250: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 251: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 252: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 253: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 254: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 255: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() + case 120..<201: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.self, fieldNumber: fieldNumber) }() + default: break + } } - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201) - try { if let v = _storage._data { - try visitor.visitSingularGroupField(value: v, fieldNumber: 201) + } + } + + func traverse(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._requiredInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) } }() - try { if let v = _storage._fieldname1 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 401) + try { if let v = _storage._requiredInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) } }() - try { if let v = _storage._fieldName2 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 402) + try { if let v = _storage._requiredUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) } }() - try { if let v = _storage._fieldName3 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 403) + try { if let v = _storage._requiredUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) } }() - try { if let v = _storage._field_Name4_ { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 404) + try { if let v = _storage._requiredSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) } }() - try { if let v = _storage._field0Name5 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 405) + try { if let v = _storage._requiredSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) } }() - try { if let v = _storage._field0Name6 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 406) + try { if let v = _storage._requiredFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) } }() - try { if let v = _storage._fieldName7 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 407) + try { if let v = _storage._requiredFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) } }() - try { if let v = _storage._fieldName8 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 408) + try { if let v = _storage._requiredSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) } }() - try { if let v = _storage._fieldName9 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 409) + try { if let v = _storage._requiredSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) } }() - try { if let v = _storage._fieldName10 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 410) + try { if let v = _storage._requiredFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) } }() - try { if let v = _storage._fieldName11 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 411) + try { if let v = _storage._requiredDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) } }() - try { if let v = _storage._fieldName12 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 412) + try { if let v = _storage._requiredBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) } }() - try { if let v = _storage.__FieldName13 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 413) + try { if let v = _storage._requiredString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) } }() - try { if let v = _storage.__FieldName14 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 414) + try { if let v = _storage._requiredBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) } }() - try { if let v = _storage._field_Name15 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 415) + try { if let v = _storage._requiredNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) } }() - try { if let v = _storage._field_Name16 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 416) + try { if let v = _storage._requiredForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._requiredNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._requiredForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._requiredStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._requiredCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + try { if let v = _storage._optionalRecursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 28) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201) + try { if let v = _storage._data { + try visitor.visitSingularGroupField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 241) + } }() + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 242) + } }() + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 243) + } }() + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 244) + } }() + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 245) + } }() + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 246) + } }() + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 247) + } }() + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 248) + } }() + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 249) + } }() + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 250) + } }() + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 251) + } }() + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 252) + } }() + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 253) } }() - try { if let v = _storage._fieldName17__ { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 417) + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 254) } }() - try { if let v = _storage._fieldName18__ { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 418) + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 255) } }() } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2) -> Bool { + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} - if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} - if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} - if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} - if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} - if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} - if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} - if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} - if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} - if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} - if _storage._optionalFloat != rhs_storage._optionalFloat {return false} - if _storage._optionalDouble != rhs_storage._optionalDouble {return false} - if _storage._optionalBool != rhs_storage._optionalBool {return false} - if _storage._optionalString != rhs_storage._optionalString {return false} - if _storage._optionalBytes != rhs_storage._optionalBytes {return false} - if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} - if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} - if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} - if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} - if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} - if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._requiredInt32 != rhs_storage._requiredInt32 {return false} + if _storage._requiredInt64 != rhs_storage._requiredInt64 {return false} + if _storage._requiredUint32 != rhs_storage._requiredUint32 {return false} + if _storage._requiredUint64 != rhs_storage._requiredUint64 {return false} + if _storage._requiredSint32 != rhs_storage._requiredSint32 {return false} + if _storage._requiredSint64 != rhs_storage._requiredSint64 {return false} + if _storage._requiredFixed32 != rhs_storage._requiredFixed32 {return false} + if _storage._requiredFixed64 != rhs_storage._requiredFixed64 {return false} + if _storage._requiredSfixed32 != rhs_storage._requiredSfixed32 {return false} + if _storage._requiredSfixed64 != rhs_storage._requiredSfixed64 {return false} + if _storage._requiredFloat != rhs_storage._requiredFloat {return false} + if _storage._requiredDouble != rhs_storage._requiredDouble {return false} + if _storage._requiredBool != rhs_storage._requiredBool {return false} + if _storage._requiredString != rhs_storage._requiredString {return false} + if _storage._requiredBytes != rhs_storage._requiredBytes {return false} + if _storage._requiredNestedMessage != rhs_storage._requiredNestedMessage {return false} + if _storage._requiredForeignMessage != rhs_storage._requiredForeignMessage {return false} + if _storage._requiredNestedEnum != rhs_storage._requiredNestedEnum {return false} + if _storage._requiredForeignEnum != rhs_storage._requiredForeignEnum {return false} + if _storage._requiredStringPiece != rhs_storage._requiredStringPiece {return false} + if _storage._requiredCord != rhs_storage._requiredCord {return false} if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} - if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} - if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} - if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} - if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} - if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} - if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} - if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} - if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} - if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} - if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} - if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} - if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} - if _storage._repeatedBool != rhs_storage._repeatedBool {return false} - if _storage._repeatedString != rhs_storage._repeatedString {return false} - if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} - if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} - if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} - if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} - if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} - if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} - if _storage._repeatedCord != rhs_storage._repeatedCord {return false} - if _storage._packedInt32 != rhs_storage._packedInt32 {return false} - if _storage._packedInt64 != rhs_storage._packedInt64 {return false} - if _storage._packedUint32 != rhs_storage._packedUint32 {return false} - if _storage._packedUint64 != rhs_storage._packedUint64 {return false} - if _storage._packedSint32 != rhs_storage._packedSint32 {return false} - if _storage._packedSint64 != rhs_storage._packedSint64 {return false} - if _storage._packedFixed32 != rhs_storage._packedFixed32 {return false} - if _storage._packedFixed64 != rhs_storage._packedFixed64 {return false} - if _storage._packedSfixed32 != rhs_storage._packedSfixed32 {return false} - if _storage._packedSfixed64 != rhs_storage._packedSfixed64 {return false} - if _storage._packedFloat != rhs_storage._packedFloat {return false} - if _storage._packedDouble != rhs_storage._packedDouble {return false} - if _storage._packedBool != rhs_storage._packedBool {return false} - if _storage._packedNestedEnum != rhs_storage._packedNestedEnum {return false} - if _storage._unpackedInt32 != rhs_storage._unpackedInt32 {return false} - if _storage._unpackedInt64 != rhs_storage._unpackedInt64 {return false} - if _storage._unpackedUint32 != rhs_storage._unpackedUint32 {return false} - if _storage._unpackedUint64 != rhs_storage._unpackedUint64 {return false} - if _storage._unpackedSint32 != rhs_storage._unpackedSint32 {return false} - if _storage._unpackedSint64 != rhs_storage._unpackedSint64 {return false} - if _storage._unpackedFixed32 != rhs_storage._unpackedFixed32 {return false} - if _storage._unpackedFixed64 != rhs_storage._unpackedFixed64 {return false} - if _storage._unpackedSfixed32 != rhs_storage._unpackedSfixed32 {return false} - if _storage._unpackedSfixed64 != rhs_storage._unpackedSfixed64 {return false} - if _storage._unpackedFloat != rhs_storage._unpackedFloat {return false} - if _storage._unpackedDouble != rhs_storage._unpackedDouble {return false} - if _storage._unpackedBool != rhs_storage._unpackedBool {return false} - if _storage._unpackedNestedEnum != rhs_storage._unpackedNestedEnum {return false} - if _storage._mapInt32Int32 != rhs_storage._mapInt32Int32 {return false} - if _storage._mapInt64Int64 != rhs_storage._mapInt64Int64 {return false} - if _storage._mapUint32Uint32 != rhs_storage._mapUint32Uint32 {return false} - if _storage._mapUint64Uint64 != rhs_storage._mapUint64Uint64 {return false} - if _storage._mapSint32Sint32 != rhs_storage._mapSint32Sint32 {return false} - if _storage._mapSint64Sint64 != rhs_storage._mapSint64Sint64 {return false} - if _storage._mapFixed32Fixed32 != rhs_storage._mapFixed32Fixed32 {return false} - if _storage._mapFixed64Fixed64 != rhs_storage._mapFixed64Fixed64 {return false} - if _storage._mapSfixed32Sfixed32 != rhs_storage._mapSfixed32Sfixed32 {return false} - if _storage._mapSfixed64Sfixed64 != rhs_storage._mapSfixed64Sfixed64 {return false} - if _storage._mapInt32Float != rhs_storage._mapInt32Float {return false} - if _storage._mapInt32Double != rhs_storage._mapInt32Double {return false} - if _storage._mapBoolBool != rhs_storage._mapBoolBool {return false} - if _storage._mapStringString != rhs_storage._mapStringString {return false} - if _storage._mapStringBytes != rhs_storage._mapStringBytes {return false} - if _storage._mapStringNestedMessage != rhs_storage._mapStringNestedMessage {return false} - if _storage._mapStringForeignMessage != rhs_storage._mapStringForeignMessage {return false} - if _storage._mapStringNestedEnum != rhs_storage._mapStringNestedEnum {return false} - if _storage._mapStringForeignEnum != rhs_storage._mapStringForeignEnum {return false} - if _storage._oneofField != rhs_storage._oneofField {return false} + if _storage._optionalRecursiveMessage != rhs_storage._optionalRecursiveMessage {return false} if _storage._data != rhs_storage._data {return false} - if _storage._fieldname1 != rhs_storage._fieldname1 {return false} - if _storage._fieldName2 != rhs_storage._fieldName2 {return false} - if _storage._fieldName3 != rhs_storage._fieldName3 {return false} - if _storage._field_Name4_ != rhs_storage._field_Name4_ {return false} - if _storage._field0Name5 != rhs_storage._field0Name5 {return false} - if _storage._field0Name6 != rhs_storage._field0Name6 {return false} - if _storage._fieldName7 != rhs_storage._fieldName7 {return false} - if _storage._fieldName8 != rhs_storage._fieldName8 {return false} - if _storage._fieldName9 != rhs_storage._fieldName9 {return false} - if _storage._fieldName10 != rhs_storage._fieldName10 {return false} - if _storage._fieldName11 != rhs_storage._fieldName11 {return false} - if _storage._fieldName12 != rhs_storage._fieldName12 {return false} - if _storage.__FieldName13 != rhs_storage.__FieldName13 {return false} - if _storage.__FieldName14 != rhs_storage.__FieldName14 {return false} - if _storage._field_Name15 != rhs_storage._field_Name15 {return false} - if _storage._field_Name16 != rhs_storage._field_Name16 {return false} - if _storage._fieldName17__ != rhs_storage._fieldName17__ {return false} - if _storage._fieldName18__ != rhs_storage._fieldName18__ {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} return true } if !storagesAreEqual {return false} @@ -2494,33 +4367,31 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, } } -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -1: .same(proto: "NEG"), - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - ] +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") } -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 2: .same(proto: "corecursive"), - ] +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0\u{3}optional_corecursive\0") fileprivate class _StorageClass { var _a: Int32? = nil - var _corecursive: ProtobufTestMessages_Proto2_TestAllTypesProto2? = nil + var _corecursive: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2? = nil + var _optionalCorecursive: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} init(copying source: _StorageClass) { _a = source._a _corecursive = source._corecursive + _optionalCorecursive = source._optionalCorecursive } } @@ -2533,7 +4404,10 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage: SwiftPro public var isInitialized: Bool { return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._a == nil {return false} + if _storage._corecursive == nil {return false} if let v = _storage._corecursive, !v.isInitialized {return false} + if let v = _storage._optionalCorecursive, !v.isInitialized {return false} return true } } @@ -2548,6 +4422,7 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage: SwiftPro switch fieldNumber { case 1: try { try decoder.decodeSingularInt32Field(value: &_storage._a) }() case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._optionalCorecursive) }() default: break } } @@ -2566,17 +4441,21 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage: SwiftPro try { if let v = _storage._corecursive { try visitor.visitSingularMessageField(value: v, fieldNumber: 2) } }() + try { if let v = _storage._optionalCorecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage) -> Bool { + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.NestedMessage) -> 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._a != rhs_storage._a {return false} if _storage._corecursive != rhs_storage._corecursive {return false} + if _storage._optionalCorecursive != rhs_storage._optionalCorecursive {return false} return true } if !storagesAreEqual {return false} @@ -2586,12 +4465,15 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.NestedMessage: SwiftPro } } -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".Data" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 202: .standard(proto: "group_int32"), - 203: .standard(proto: "group_uint32"), - ] +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}J\u{3}group_int32\0\u{3}group_uint32\0") + + public var isInitialized: Bool { + if self._groupInt32 == nil {return false} + if self._groupUint32 == nil {return false} + return true + } mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -2620,7 +4502,7 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage: SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage) -> Bool { + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.DataMessage) -> Bool { if lhs._groupInt32 != rhs._groupInt32 {return false} if lhs._groupUint32 != rhs._groupUint32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -2628,8 +4510,8 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.DataMessage: SwiftProto } } -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrect" +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".MessageSetCorrect" static let _protobuf_nameMap = SwiftProtobuf._NameMap() public var isInitialized: Bool { @@ -2638,7 +4520,7 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect: Swif } mutating func decodeMessage(decoder: inout D) throws { - try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect.self) + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect.self) } func traverse(visitor: inout V) throws { @@ -2646,18 +4528,21 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrect) -> Bool { + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrectExtension1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 25: .same(proto: "str"), - ] +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".MessageSetCorrectExtension1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{19}str\0") + + public var isInitialized: Bool { + if self._str == nil {return false} + return true + } mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -2682,18 +4567,21 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtens try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1) -> Bool { + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1) -> Bool { if lhs._str != rhs._str {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrectExtension2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 9: .same(proto: "i"), - ] +extension ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".MessageSetCorrectExtension2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{9}i\0") + + public var isInitialized: Bool { + if self._i == nil {return false} + return true + } mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -2718,18 +4606,16 @@ extension ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtens try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2, rhs: ProtobufTestMessages_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2) -> Bool { + static func ==(lhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2, rhs: ProtobufTestMessages_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2) -> Bool { if lhs._i != rhs._i {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufTestMessages_Proto2_ForeignMessageProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ForeignMessageProto2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - ] +extension ProtobufTestMessages_Proto2_TestLargeOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestLargeOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a1\0\u{1}a2\0\u{1}a3\0\u{1}a4\0\u{1}a5\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -2737,7 +4623,71 @@ extension ProtobufTestMessages_Proto2_ForeignMessageProto2: SwiftProtobuf.Messag // 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._c) }() + case 1: try { + var v: ProtobufTestMessages_Proto2_TestLargeOneof.A1? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a1(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a1(v) + } + }() + case 2: try { + var v: ProtobufTestMessages_Proto2_TestLargeOneof.A2? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a2(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a2(v) + } + }() + case 3: try { + var v: ProtobufTestMessages_Proto2_TestLargeOneof.A3? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a3(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a3(v) + } + }() + case 4: try { + var v: ProtobufTestMessages_Proto2_TestLargeOneof.A4? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a4(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a4(v) + } + }() + case 5: try { + var v: ProtobufTestMessages_Proto2_TestLargeOneof.A5? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a5(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a5(v) + } + }() default: break } } @@ -2748,162 +4698,130 @@ extension ProtobufTestMessages_Proto2_ForeignMessageProto2: SwiftProtobuf.Messag // 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._c { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() + switch self.largeOneof { + case .a1?: try { + guard case .a1(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + }() + case .a2?: try { + guard case .a2(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + }() + case .a3?: try { + guard case .a3(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + }() + case .a4?: try { + guard case .a4(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + }() + case .a5?: try { + guard case .a5(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + }() + case nil: break + } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufTestMessages_Proto2_ForeignMessageProto2, rhs: ProtobufTestMessages_Proto2_ForeignMessageProto2) -> Bool { - if lhs._c != rhs._c {return false} + static func ==(lhs: ProtobufTestMessages_Proto2_TestLargeOneof, rhs: ProtobufTestMessages_Proto2_TestLargeOneof) -> Bool { + if lhs.largeOneof != rhs.largeOneof {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".UnknownToTestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1001: .standard(proto: "optional_int32"), - 1002: .standard(proto: "optional_string"), - 1003: .standard(proto: "nested_message"), - 1004: .unique(proto: "OptionalGroup", json: "optionalgroup"), - 1006: .standard(proto: "optional_bool"), - 1011: .standard(proto: "repeated_int32"), - ] +extension ProtobufTestMessages_Proto2_TestLargeOneof.A1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestLargeOneof.protoMessageName + ".A1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() 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 1001: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32) }() - case 1002: try { try decoder.decodeSingularStringField(value: &self._optionalString) }() - case 1003: try { try decoder.decodeSingularMessageField(value: &self._nestedMessage) }() - case 1004: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() - case 1006: try { try decoder.decodeSingularBoolField(value: &self._optionalBool) }() - case 1011: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() - default: break - } - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } 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 - try { if let v = self._optionalInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1001) - } }() - try { if let v = self._optionalString { - try visitor.visitSingularStringField(value: v, fieldNumber: 1002) - } }() - try { if let v = self._nestedMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1003) - } }() - try { if let v = self._optionalGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 1004) - } }() - try { if let v = self._optionalBool { - try visitor.visitSingularBoolField(value: v, fieldNumber: 1006) - } }() - if !self.repeatedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 1011) - } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes, rhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes) -> Bool { - if lhs._optionalInt32 != rhs._optionalInt32 {return false} - if lhs._optionalString != rhs._optionalString {return false} - if lhs._nestedMessage != rhs._nestedMessage {return false} - if lhs._optionalGroup != rhs._optionalGroup {return false} - if lhs._optionalBool != rhs._optionalBool {return false} - if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} + static func ==(lhs: ProtobufTestMessages_Proto2_TestLargeOneof.A1, rhs: ProtobufTestMessages_Proto2_TestLargeOneof.A1) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufTestMessages_Proto2_UnknownToTestAllTypes.protoMessageName + ".OptionalGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] +extension ProtobufTestMessages_Proto2_TestLargeOneof.A2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestLargeOneof.protoMessageName + ".A2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() 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._a) }() - default: break - } - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup, rhs: ProtobufTestMessages_Proto2_UnknownToTestAllTypes.OptionalGroup) -> Bool { - if lhs._a != rhs._a {return false} + static func ==(lhs: ProtobufTestMessages_Proto2_TestLargeOneof.A2, rhs: ProtobufTestMessages_Proto2_TestLargeOneof.A2) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufTestMessages_Proto2_NullHypothesisProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".NullHypothesisProto2" +extension ProtobufTestMessages_Proto2_TestLargeOneof.A3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestLargeOneof.protoMessageName + ".A3" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufTestMessages_Proto2_NullHypothesisProto2, rhs: ProtobufTestMessages_Proto2_NullHypothesisProto2) -> Bool { + static func ==(lhs: ProtobufTestMessages_Proto2_TestLargeOneof.A3, rhs: ProtobufTestMessages_Proto2_TestLargeOneof.A3) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufTestMessages_Proto2_EnumOnlyProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".EnumOnlyProto2" +extension ProtobufTestMessages_Proto2_TestLargeOneof.A4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestLargeOneof.protoMessageName + ".A4" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufTestMessages_Proto2_EnumOnlyProto2, rhs: ProtobufTestMessages_Proto2_EnumOnlyProto2) -> Bool { + static func ==(lhs: ProtobufTestMessages_Proto2_TestLargeOneof.A4, rhs: ProtobufTestMessages_Proto2_TestLargeOneof.A4) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufTestMessages_Proto2_EnumOnlyProto2.BoolEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "kFalse"), - 1: .same(proto: "kTrue"), - ] +extension ProtobufTestMessages_Proto2_TestLargeOneof.A5: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Proto2_TestLargeOneof.protoMessageName + ".A5" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Proto2_TestLargeOneof.A5, rhs: ProtobufTestMessages_Proto2_TestLargeOneof.A5) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } } diff --git a/Sources/Conformance/test_messages_proto2_editions.pb.swift b/Sources/Conformance/test_messages_proto2_editions.pb.swift new file mode 100644 index 000000000..d586d6b91 --- /dev/null +++ b/Sources/Conformance/test_messages_proto2_editions.pb.swift @@ -0,0 +1,4828 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: editions/test_messages_proto2_editions.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// clang-format off +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Test schema for proto2 messages. This test schema is used by: +// +// - conformance tests + +// LINT: ALLOW_GROUPS + +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 ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foreignFoo = 0 + case foreignBar = 1 + case foreignBaz = 2 + + init() { + self = .foreignFoo + } + +} + +/// This proto includes every type of field in both singular and repeated +/// forms. +/// +/// Also, crucially, all messages and enums in this file are eventually +/// submessages of this message. So for example, a fuzz test of TestAllTypes +/// could trigger bugs that occur in any message type in this file. We verify +/// this stays true in a unit test. +struct ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Singular + var optionalInt32: Int32 { + get {_storage._optionalInt32 ?? 0} + set {_uniqueStorage()._optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} + + var optionalInt64: Int64 { + get {_storage._optionalInt64 ?? 0} + set {_uniqueStorage()._optionalInt64 = newValue} + } + /// Returns true if `optionalInt64` has been explicitly set. + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} + /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} + + var optionalUint32: UInt32 { + get {_storage._optionalUint32 ?? 0} + set {_uniqueStorage()._optionalUint32 = newValue} + } + /// Returns true if `optionalUint32` has been explicitly set. + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} + /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} + + var optionalUint64: UInt64 { + get {_storage._optionalUint64 ?? 0} + set {_uniqueStorage()._optionalUint64 = newValue} + } + /// Returns true if `optionalUint64` has been explicitly set. + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} + /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} + + var optionalSint32: Int32 { + get {_storage._optionalSint32 ?? 0} + set {_uniqueStorage()._optionalSint32 = newValue} + } + /// Returns true if `optionalSint32` has been explicitly set. + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} + /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} + + var optionalSint64: Int64 { + get {_storage._optionalSint64 ?? 0} + set {_uniqueStorage()._optionalSint64 = newValue} + } + /// Returns true if `optionalSint64` has been explicitly set. + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} + /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} + + var optionalFixed32: UInt32 { + get {_storage._optionalFixed32 ?? 0} + set {_uniqueStorage()._optionalFixed32 = newValue} + } + /// Returns true if `optionalFixed32` has been explicitly set. + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} + /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} + + var optionalFixed64: UInt64 { + get {_storage._optionalFixed64 ?? 0} + set {_uniqueStorage()._optionalFixed64 = newValue} + } + /// Returns true if `optionalFixed64` has been explicitly set. + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} + /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} + + var optionalSfixed32: Int32 { + get {_storage._optionalSfixed32 ?? 0} + set {_uniqueStorage()._optionalSfixed32 = newValue} + } + /// Returns true if `optionalSfixed32` has been explicitly set. + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} + /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} + + var optionalSfixed64: Int64 { + get {_storage._optionalSfixed64 ?? 0} + set {_uniqueStorage()._optionalSfixed64 = newValue} + } + /// Returns true if `optionalSfixed64` has been explicitly set. + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} + /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. + mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} + + var optionalFloat: Float { + get {_storage._optionalFloat ?? 0} + set {_uniqueStorage()._optionalFloat = newValue} + } + /// Returns true if `optionalFloat` has been explicitly set. + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} + /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} + + var optionalDouble: Double { + get {_storage._optionalDouble ?? 0} + set {_uniqueStorage()._optionalDouble = newValue} + } + /// Returns true if `optionalDouble` has been explicitly set. + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} + /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. + mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} + + var optionalBool: Bool { + get {_storage._optionalBool ?? false} + set {_uniqueStorage()._optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {_storage._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} + + var optionalString: String { + get {_storage._optionalString ?? String()} + set {_uniqueStorage()._optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {_storage._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} + + var optionalBytes: Data { + get {_storage._optionalBytes ?? Data()} + set {_uniqueStorage()._optionalBytes = newValue} + } + /// Returns true if `optionalBytes` has been explicitly set. + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} + /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} + + var optionalNestedMessage: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage { + get {_storage._optionalNestedMessage ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage()} + set {_uniqueStorage()._optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} + + var optionalForeignMessage: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2 { + get {_storage._optionalForeignMessage ?? ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2()} + set {_uniqueStorage()._optionalForeignMessage = newValue} + } + /// Returns true if `optionalForeignMessage` has been explicitly set. + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} + /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} + + var optionalNestedEnum: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum { + get {_storage._optionalNestedEnum ?? .foo} + set {_uniqueStorage()._optionalNestedEnum = newValue} + } + /// Returns true if `optionalNestedEnum` has been explicitly set. + var hasOptionalNestedEnum: Bool {_storage._optionalNestedEnum != nil} + /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} + + var optionalForeignEnum: ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2 { + get {_storage._optionalForeignEnum ?? .foreignFoo} + set {_uniqueStorage()._optionalForeignEnum = newValue} + } + /// Returns true if `optionalForeignEnum` has been explicitly set. + var hasOptionalForeignEnum: Bool {_storage._optionalForeignEnum != nil} + /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignEnum() {_uniqueStorage()._optionalForeignEnum = nil} + + var optionalStringPiece: String { + get {_storage._optionalStringPiece ?? String()} + set {_uniqueStorage()._optionalStringPiece = newValue} + } + /// Returns true if `optionalStringPiece` has been explicitly set. + var hasOptionalStringPiece: Bool {_storage._optionalStringPiece != nil} + /// Clears the value of `optionalStringPiece`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringPiece() {_uniqueStorage()._optionalStringPiece = nil} + + var optionalCord: String { + get {_storage._optionalCord ?? String()} + set {_uniqueStorage()._optionalCord = newValue} + } + /// Returns true if `optionalCord` has been explicitly set. + var hasOptionalCord: Bool {_storage._optionalCord != nil} + /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. + mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} + + var recursiveMessage: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2 { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2()} + set {_uniqueStorage()._recursiveMessage = newValue} + } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} + + /// Repeated + var repeatedInt32: [Int32] { + get {_storage._repeatedInt32} + set {_uniqueStorage()._repeatedInt32 = newValue} + } + + var repeatedInt64: [Int64] { + get {_storage._repeatedInt64} + set {_uniqueStorage()._repeatedInt64 = newValue} + } + + var repeatedUint32: [UInt32] { + get {_storage._repeatedUint32} + set {_uniqueStorage()._repeatedUint32 = newValue} + } + + var repeatedUint64: [UInt64] { + get {_storage._repeatedUint64} + set {_uniqueStorage()._repeatedUint64 = newValue} + } + + var repeatedSint32: [Int32] { + get {_storage._repeatedSint32} + set {_uniqueStorage()._repeatedSint32 = newValue} + } + + var repeatedSint64: [Int64] { + get {_storage._repeatedSint64} + set {_uniqueStorage()._repeatedSint64 = newValue} + } + + var repeatedFixed32: [UInt32] { + get {_storage._repeatedFixed32} + set {_uniqueStorage()._repeatedFixed32 = newValue} + } + + var repeatedFixed64: [UInt64] { + get {_storage._repeatedFixed64} + set {_uniqueStorage()._repeatedFixed64 = newValue} + } + + var repeatedSfixed32: [Int32] { + get {_storage._repeatedSfixed32} + set {_uniqueStorage()._repeatedSfixed32 = newValue} + } + + var repeatedSfixed64: [Int64] { + get {_storage._repeatedSfixed64} + set {_uniqueStorage()._repeatedSfixed64 = newValue} + } + + var repeatedFloat: [Float] { + get {_storage._repeatedFloat} + set {_uniqueStorage()._repeatedFloat = newValue} + } + + var repeatedDouble: [Double] { + get {_storage._repeatedDouble} + set {_uniqueStorage()._repeatedDouble = newValue} + } + + var repeatedBool: [Bool] { + get {_storage._repeatedBool} + set {_uniqueStorage()._repeatedBool = newValue} + } + + var repeatedString: [String] { + get {_storage._repeatedString} + set {_uniqueStorage()._repeatedString = newValue} + } + + var repeatedBytes: [Data] { + get {_storage._repeatedBytes} + set {_uniqueStorage()._repeatedBytes = newValue} + } + + var repeatedNestedMessage: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage] { + get {_storage._repeatedNestedMessage} + set {_uniqueStorage()._repeatedNestedMessage = newValue} + } + + var repeatedForeignMessage: [ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2] { + get {_storage._repeatedForeignMessage} + set {_uniqueStorage()._repeatedForeignMessage = newValue} + } + + var repeatedNestedEnum: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum] { + get {_storage._repeatedNestedEnum} + set {_uniqueStorage()._repeatedNestedEnum = newValue} + } + + var repeatedForeignEnum: [ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2] { + get {_storage._repeatedForeignEnum} + set {_uniqueStorage()._repeatedForeignEnum = newValue} + } + + var repeatedStringPiece: [String] { + get {_storage._repeatedStringPiece} + set {_uniqueStorage()._repeatedStringPiece = newValue} + } + + var repeatedCord: [String] { + get {_storage._repeatedCord} + set {_uniqueStorage()._repeatedCord = newValue} + } + + /// Packed + var packedInt32: [Int32] { + get {_storage._packedInt32} + set {_uniqueStorage()._packedInt32 = newValue} + } + + var packedInt64: [Int64] { + get {_storage._packedInt64} + set {_uniqueStorage()._packedInt64 = newValue} + } + + var packedUint32: [UInt32] { + get {_storage._packedUint32} + set {_uniqueStorage()._packedUint32 = newValue} + } + + var packedUint64: [UInt64] { + get {_storage._packedUint64} + set {_uniqueStorage()._packedUint64 = newValue} + } + + var packedSint32: [Int32] { + get {_storage._packedSint32} + set {_uniqueStorage()._packedSint32 = newValue} + } + + var packedSint64: [Int64] { + get {_storage._packedSint64} + set {_uniqueStorage()._packedSint64 = newValue} + } + + var packedFixed32: [UInt32] { + get {_storage._packedFixed32} + set {_uniqueStorage()._packedFixed32 = newValue} + } + + var packedFixed64: [UInt64] { + get {_storage._packedFixed64} + set {_uniqueStorage()._packedFixed64 = newValue} + } + + var packedSfixed32: [Int32] { + get {_storage._packedSfixed32} + set {_uniqueStorage()._packedSfixed32 = newValue} + } + + var packedSfixed64: [Int64] { + get {_storage._packedSfixed64} + set {_uniqueStorage()._packedSfixed64 = newValue} + } + + var packedFloat: [Float] { + get {_storage._packedFloat} + set {_uniqueStorage()._packedFloat = newValue} + } + + var packedDouble: [Double] { + get {_storage._packedDouble} + set {_uniqueStorage()._packedDouble = newValue} + } + + var packedBool: [Bool] { + get {_storage._packedBool} + set {_uniqueStorage()._packedBool = newValue} + } + + var packedNestedEnum: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum] { + get {_storage._packedNestedEnum} + set {_uniqueStorage()._packedNestedEnum = newValue} + } + + /// Unpacked + var unpackedInt32: [Int32] { + get {_storage._unpackedInt32} + set {_uniqueStorage()._unpackedInt32 = newValue} + } + + var unpackedInt64: [Int64] { + get {_storage._unpackedInt64} + set {_uniqueStorage()._unpackedInt64 = newValue} + } + + var unpackedUint32: [UInt32] { + get {_storage._unpackedUint32} + set {_uniqueStorage()._unpackedUint32 = newValue} + } + + var unpackedUint64: [UInt64] { + get {_storage._unpackedUint64} + set {_uniqueStorage()._unpackedUint64 = newValue} + } + + var unpackedSint32: [Int32] { + get {_storage._unpackedSint32} + set {_uniqueStorage()._unpackedSint32 = newValue} + } + + var unpackedSint64: [Int64] { + get {_storage._unpackedSint64} + set {_uniqueStorage()._unpackedSint64 = newValue} + } + + var unpackedFixed32: [UInt32] { + get {_storage._unpackedFixed32} + set {_uniqueStorage()._unpackedFixed32 = newValue} + } + + var unpackedFixed64: [UInt64] { + get {_storage._unpackedFixed64} + set {_uniqueStorage()._unpackedFixed64 = newValue} + } + + var unpackedSfixed32: [Int32] { + get {_storage._unpackedSfixed32} + set {_uniqueStorage()._unpackedSfixed32 = newValue} + } + + var unpackedSfixed64: [Int64] { + get {_storage._unpackedSfixed64} + set {_uniqueStorage()._unpackedSfixed64 = newValue} + } + + var unpackedFloat: [Float] { + get {_storage._unpackedFloat} + set {_uniqueStorage()._unpackedFloat = newValue} + } + + var unpackedDouble: [Double] { + get {_storage._unpackedDouble} + set {_uniqueStorage()._unpackedDouble = newValue} + } + + var unpackedBool: [Bool] { + get {_storage._unpackedBool} + set {_uniqueStorage()._unpackedBool = newValue} + } + + var unpackedNestedEnum: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum] { + get {_storage._unpackedNestedEnum} + set {_uniqueStorage()._unpackedNestedEnum = newValue} + } + + /// Map + var mapInt32Int32: Dictionary { + get {_storage._mapInt32Int32} + set {_uniqueStorage()._mapInt32Int32 = newValue} + } + + var mapInt64Int64: Dictionary { + get {_storage._mapInt64Int64} + set {_uniqueStorage()._mapInt64Int64 = newValue} + } + + var mapUint32Uint32: Dictionary { + get {_storage._mapUint32Uint32} + set {_uniqueStorage()._mapUint32Uint32 = newValue} + } + + var mapUint64Uint64: Dictionary { + get {_storage._mapUint64Uint64} + set {_uniqueStorage()._mapUint64Uint64 = newValue} + } + + var mapSint32Sint32: Dictionary { + get {_storage._mapSint32Sint32} + set {_uniqueStorage()._mapSint32Sint32 = newValue} + } + + var mapSint64Sint64: Dictionary { + get {_storage._mapSint64Sint64} + set {_uniqueStorage()._mapSint64Sint64 = newValue} + } + + var mapFixed32Fixed32: Dictionary { + get {_storage._mapFixed32Fixed32} + set {_uniqueStorage()._mapFixed32Fixed32 = newValue} + } + + var mapFixed64Fixed64: Dictionary { + get {_storage._mapFixed64Fixed64} + set {_uniqueStorage()._mapFixed64Fixed64 = newValue} + } + + var mapSfixed32Sfixed32: Dictionary { + get {_storage._mapSfixed32Sfixed32} + set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} + } + + var mapSfixed64Sfixed64: Dictionary { + get {_storage._mapSfixed64Sfixed64} + set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} + } + + var mapInt32Bool: Dictionary { + get {_storage._mapInt32Bool} + set {_uniqueStorage()._mapInt32Bool = newValue} + } + + var mapInt32Float: Dictionary { + get {_storage._mapInt32Float} + set {_uniqueStorage()._mapInt32Float = newValue} + } + + var mapInt32Double: Dictionary { + get {_storage._mapInt32Double} + set {_uniqueStorage()._mapInt32Double = newValue} + } + + var mapInt32NestedMessage: Dictionary { + get {_storage._mapInt32NestedMessage} + set {_uniqueStorage()._mapInt32NestedMessage = newValue} + } + + var mapBoolBool: Dictionary { + get {_storage._mapBoolBool} + set {_uniqueStorage()._mapBoolBool = newValue} + } + + var mapStringString: Dictionary { + get {_storage._mapStringString} + set {_uniqueStorage()._mapStringString = newValue} + } + + var mapStringBytes: Dictionary { + get {_storage._mapStringBytes} + set {_uniqueStorage()._mapStringBytes = newValue} + } + + var mapStringNestedMessage: Dictionary { + get {_storage._mapStringNestedMessage} + set {_uniqueStorage()._mapStringNestedMessage = newValue} + } + + var mapStringForeignMessage: Dictionary { + get {_storage._mapStringForeignMessage} + set {_uniqueStorage()._mapStringForeignMessage = newValue} + } + + var mapStringNestedEnum: Dictionary { + get {_storage._mapStringNestedEnum} + set {_uniqueStorage()._mapStringNestedEnum = newValue} + } + + var mapStringForeignEnum: Dictionary { + get {_storage._mapStringForeignEnum} + set {_uniqueStorage()._mapStringForeignEnum = newValue} + } + + var oneofField: OneOf_OneofField? { + get {return _storage._oneofField} + set {_uniqueStorage()._oneofField = newValue} + } + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} + } + + var oneofNestedMessage: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage { + get { + if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} + return ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = _storage._oneofField {return v} + return Data() + } + set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} + } + + var oneofBool: Bool { + get { + if case .oneofBool(let v)? = _storage._oneofField {return v} + return false + } + set {_uniqueStorage()._oneofField = .oneofBool(newValue)} + } + + var oneofUint64: UInt64 { + get { + if case .oneofUint64(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint64(newValue)} + } + + var oneofFloat: Float { + get { + if case .oneofFloat(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofFloat(newValue)} + } + + var oneofDouble: Double { + get { + if case .oneofDouble(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofDouble(newValue)} + } + + var oneofEnum: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum { + get { + if case .oneofEnum(let v)? = _storage._oneofField {return v} + return .foo + } + set {_uniqueStorage()._oneofField = .oneofEnum(newValue)} + } + + var data: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.DataMessage { + get {_storage._data ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.DataMessage()} + set {_uniqueStorage()._data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {_storage._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {_uniqueStorage()._data = nil} + + var multiWordGroupField: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MultiWordGroupField { + get {_storage._multiWordGroupField ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MultiWordGroupField()} + set {_uniqueStorage()._multiWordGroupField = newValue} + } + /// Returns true if `multiWordGroupField` has been explicitly set. + var hasMultiWordGroupField: Bool {_storage._multiWordGroupField != nil} + /// Clears the value of `multiWordGroupField`. Subsequent reads from it will return its default value. + mutating func clearMultiWordGroupField() {_uniqueStorage()._multiWordGroupField = nil} + + /// default values + var defaultInt32: Int32 { + get {_storage._defaultInt32 ?? -123456789} + set {_uniqueStorage()._defaultInt32 = newValue} + } + /// Returns true if `defaultInt32` has been explicitly set. + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} + /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} + + var defaultInt64: Int64 { + get {_storage._defaultInt64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultInt64 = newValue} + } + /// Returns true if `defaultInt64` has been explicitly set. + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} + /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} + + var defaultUint32: UInt32 { + get {_storage._defaultUint32 ?? 2123456789} + set {_uniqueStorage()._defaultUint32 = newValue} + } + /// Returns true if `defaultUint32` has been explicitly set. + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} + /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} + + var defaultUint64: UInt64 { + get {_storage._defaultUint64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultUint64 = newValue} + } + /// Returns true if `defaultUint64` has been explicitly set. + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} + /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} + + var defaultSint32: Int32 { + get {_storage._defaultSint32 ?? -123456789} + set {_uniqueStorage()._defaultSint32 = newValue} + } + /// Returns true if `defaultSint32` has been explicitly set. + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} + /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} + + var defaultSint64: Int64 { + get {_storage._defaultSint64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSint64 = newValue} + } + /// Returns true if `defaultSint64` has been explicitly set. + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} + /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} + + var defaultFixed32: UInt32 { + get {_storage._defaultFixed32 ?? 2123456789} + set {_uniqueStorage()._defaultFixed32 = newValue} + } + /// Returns true if `defaultFixed32` has been explicitly set. + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} + /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} + + var defaultFixed64: UInt64 { + get {_storage._defaultFixed64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultFixed64 = newValue} + } + /// Returns true if `defaultFixed64` has been explicitly set. + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} + /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} + + var defaultSfixed32: Int32 { + get {_storage._defaultSfixed32 ?? -123456789} + set {_uniqueStorage()._defaultSfixed32 = newValue} + } + /// Returns true if `defaultSfixed32` has been explicitly set. + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} + /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} + + var defaultSfixed64: Int64 { + get {_storage._defaultSfixed64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSfixed64 = newValue} + } + /// Returns true if `defaultSfixed64` has been explicitly set. + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} + /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} + + var defaultFloat: Float { + get {_storage._defaultFloat ?? 9e+09} + set {_uniqueStorage()._defaultFloat = newValue} + } + /// Returns true if `defaultFloat` has been explicitly set. + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} + /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. + mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} + + var defaultDouble: Double { + get {_storage._defaultDouble ?? 7e+22} + set {_uniqueStorage()._defaultDouble = newValue} + } + /// Returns true if `defaultDouble` has been explicitly set. + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} + /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. + mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} + + var defaultBool: Bool { + get {_storage._defaultBool ?? true} + set {_uniqueStorage()._defaultBool = newValue} + } + /// Returns true if `defaultBool` has been explicitly set. + var hasDefaultBool: Bool {_storage._defaultBool != nil} + /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. + mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} + + var defaultString: String { + get {_storage._defaultString ?? "Rosebud"} + set {_uniqueStorage()._defaultString = newValue} + } + /// Returns true if `defaultString` has been explicitly set. + var hasDefaultString: Bool {_storage._defaultString != nil} + /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. + mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} + + var defaultBytes: Data { + get {_storage._defaultBytes ?? Data([106, 111, 115, 104, 117, 97])} + set {_uniqueStorage()._defaultBytes = newValue} + } + /// Returns true if `defaultBytes` has been explicitly set. + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} + /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. + mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} + + /// Test field-name-to-JSON-name convention. + /// (protobuf says names can be any valid C/C++ identifier.) + var fieldname1: Int32 { + get {_storage._fieldname1 ?? 0} + set {_uniqueStorage()._fieldname1 = newValue} + } + /// Returns true if `fieldname1` has been explicitly set. + var hasFieldname1: Bool {_storage._fieldname1 != nil} + /// Clears the value of `fieldname1`. Subsequent reads from it will return its default value. + mutating func clearFieldname1() {_uniqueStorage()._fieldname1 = nil} + + var fieldName2: Int32 { + get {_storage._fieldName2 ?? 0} + set {_uniqueStorage()._fieldName2 = newValue} + } + /// Returns true if `fieldName2` has been explicitly set. + var hasFieldName2: Bool {_storage._fieldName2 != nil} + /// Clears the value of `fieldName2`. Subsequent reads from it will return its default value. + mutating func clearFieldName2() {_uniqueStorage()._fieldName2 = nil} + + var fieldName3: Int32 { + get {_storage._fieldName3 ?? 0} + set {_uniqueStorage()._fieldName3 = newValue} + } + /// Returns true if `fieldName3` has been explicitly set. + var hasFieldName3: Bool {_storage._fieldName3 != nil} + /// Clears the value of `fieldName3`. Subsequent reads from it will return its default value. + mutating func clearFieldName3() {_uniqueStorage()._fieldName3 = nil} + + var field_Name4_: Int32 { + get {_storage._field_Name4_ ?? 0} + set {_uniqueStorage()._field_Name4_ = newValue} + } + /// Returns true if `field_Name4_` has been explicitly set. + var hasField_Name4_: Bool {_storage._field_Name4_ != nil} + /// Clears the value of `field_Name4_`. Subsequent reads from it will return its default value. + mutating func clearField_Name4_() {_uniqueStorage()._field_Name4_ = nil} + + var field0Name5: Int32 { + get {_storage._field0Name5 ?? 0} + set {_uniqueStorage()._field0Name5 = newValue} + } + /// Returns true if `field0Name5` has been explicitly set. + var hasField0Name5: Bool {_storage._field0Name5 != nil} + /// Clears the value of `field0Name5`. Subsequent reads from it will return its default value. + mutating func clearField0Name5() {_uniqueStorage()._field0Name5 = nil} + + var field0Name6: Int32 { + get {_storage._field0Name6 ?? 0} + set {_uniqueStorage()._field0Name6 = newValue} + } + /// Returns true if `field0Name6` has been explicitly set. + var hasField0Name6: Bool {_storage._field0Name6 != nil} + /// Clears the value of `field0Name6`. Subsequent reads from it will return its default value. + mutating func clearField0Name6() {_uniqueStorage()._field0Name6 = nil} + + var fieldName7: Int32 { + get {_storage._fieldName7 ?? 0} + set {_uniqueStorage()._fieldName7 = newValue} + } + /// Returns true if `fieldName7` has been explicitly set. + var hasFieldName7: Bool {_storage._fieldName7 != nil} + /// Clears the value of `fieldName7`. Subsequent reads from it will return its default value. + mutating func clearFieldName7() {_uniqueStorage()._fieldName7 = nil} + + var fieldName8: Int32 { + get {_storage._fieldName8 ?? 0} + set {_uniqueStorage()._fieldName8 = newValue} + } + /// Returns true if `fieldName8` has been explicitly set. + var hasFieldName8: Bool {_storage._fieldName8 != nil} + /// Clears the value of `fieldName8`. Subsequent reads from it will return its default value. + mutating func clearFieldName8() {_uniqueStorage()._fieldName8 = nil} + + var fieldName9: Int32 { + get {_storage._fieldName9 ?? 0} + set {_uniqueStorage()._fieldName9 = newValue} + } + /// Returns true if `fieldName9` has been explicitly set. + var hasFieldName9: Bool {_storage._fieldName9 != nil} + /// Clears the value of `fieldName9`. Subsequent reads from it will return its default value. + mutating func clearFieldName9() {_uniqueStorage()._fieldName9 = nil} + + var fieldName10: Int32 { + get {_storage._fieldName10 ?? 0} + set {_uniqueStorage()._fieldName10 = newValue} + } + /// Returns true if `fieldName10` has been explicitly set. + var hasFieldName10: Bool {_storage._fieldName10 != nil} + /// Clears the value of `fieldName10`. Subsequent reads from it will return its default value. + mutating func clearFieldName10() {_uniqueStorage()._fieldName10 = nil} + + var fieldName11: Int32 { + get {_storage._fieldName11 ?? 0} + set {_uniqueStorage()._fieldName11 = newValue} + } + /// Returns true if `fieldName11` has been explicitly set. + var hasFieldName11: Bool {_storage._fieldName11 != nil} + /// Clears the value of `fieldName11`. Subsequent reads from it will return its default value. + mutating func clearFieldName11() {_uniqueStorage()._fieldName11 = nil} + + var fieldName12: Int32 { + get {_storage._fieldName12 ?? 0} + set {_uniqueStorage()._fieldName12 = newValue} + } + /// Returns true if `fieldName12` has been explicitly set. + var hasFieldName12: Bool {_storage._fieldName12 != nil} + /// Clears the value of `fieldName12`. Subsequent reads from it will return its default value. + mutating func clearFieldName12() {_uniqueStorage()._fieldName12 = nil} + + var _FieldName13: Int32 { + get {_storage.__FieldName13 ?? 0} + set {_uniqueStorage().__FieldName13 = newValue} + } + /// Returns true if `_FieldName13` has been explicitly set. + var has_FieldName13: Bool {_storage.__FieldName13 != nil} + /// Clears the value of `_FieldName13`. Subsequent reads from it will return its default value. + mutating func clear_FieldName13() {_uniqueStorage().__FieldName13 = nil} + + var _FieldName14: Int32 { + get {_storage.__FieldName14 ?? 0} + set {_uniqueStorage().__FieldName14 = newValue} + } + /// Returns true if `_FieldName14` has been explicitly set. + var has_FieldName14: Bool {_storage.__FieldName14 != nil} + /// Clears the value of `_FieldName14`. Subsequent reads from it will return its default value. + mutating func clear_FieldName14() {_uniqueStorage().__FieldName14 = nil} + + var field_Name15: Int32 { + get {_storage._field_Name15 ?? 0} + set {_uniqueStorage()._field_Name15 = newValue} + } + /// Returns true if `field_Name15` has been explicitly set. + var hasField_Name15: Bool {_storage._field_Name15 != nil} + /// Clears the value of `field_Name15`. Subsequent reads from it will return its default value. + mutating func clearField_Name15() {_uniqueStorage()._field_Name15 = nil} + + var field_Name16: Int32 { + get {_storage._field_Name16 ?? 0} + set {_uniqueStorage()._field_Name16 = newValue} + } + /// Returns true if `field_Name16` has been explicitly set. + var hasField_Name16: Bool {_storage._field_Name16 != nil} + /// Clears the value of `field_Name16`. Subsequent reads from it will return its default value. + mutating func clearField_Name16() {_uniqueStorage()._field_Name16 = nil} + + var fieldName17__: Int32 { + get {_storage._fieldName17__ ?? 0} + set {_uniqueStorage()._fieldName17__ = newValue} + } + /// Returns true if `fieldName17__` has been explicitly set. + var hasFieldName17__: Bool {_storage._fieldName17__ != nil} + /// Clears the value of `fieldName17__`. Subsequent reads from it will return its default value. + mutating func clearFieldName17__() {_uniqueStorage()._fieldName17__ = nil} + + var fieldName18__: Int32 { + get {_storage._fieldName18__ ?? 0} + set {_uniqueStorage()._fieldName18__ = newValue} + } + /// Returns true if `fieldName18__` has been explicitly set. + var hasFieldName18__: Bool {_storage._fieldName18__ != nil} + /// Clears the value of `fieldName18__`. Subsequent reads from it will return its default value. + mutating func clearFieldName18__() {_uniqueStorage()._fieldName18__ = nil} + + var messageSetCorrect: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect { + get {_storage._messageSetCorrect ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect()} + set {_uniqueStorage()._messageSetCorrect = newValue} + } + /// Returns true if `messageSetCorrect` has been explicitly set. + var hasMessageSetCorrect: Bool {_storage._messageSetCorrect != nil} + /// Clears the value of `messageSetCorrect`. Subsequent reads from it will return its default value. + mutating func clearMessageSetCorrect() {_uniqueStorage()._messageSetCorrect = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofNestedMessage(ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage) + case oneofString(String) + case oneofBytes(Data) + case oneofBool(Bool) + case oneofUint64(UInt64) + case oneofFloat(Float) + case oneofDouble(Double) + case oneofEnum(ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum) + + fileprivate var isInitialized: Bool { + guard case .oneofNestedMessage(let v) = self else {return true} + return v.isInitialized + } + + } + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 + + /// Intentionally negative. + case neg = -1 + + init() { + self = .foo + } + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var corecursive: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2 { + get {_storage._corecursive ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + /// groups + struct DataMessage: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + struct MultiWordGroupField: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + /// message_set test case. + struct MessageSetCorrect: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() + } + + struct MessageSetCorrectExtension1: Sendable { + // 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 str: String { + get {_str ?? String()} + set {_str = newValue} + } + /// Returns true if `str` has been explicitly set. + var hasStr: Bool {self._str != nil} + /// Clears the value of `str`. Subsequent reads from it will return its default value. + mutating func clearStr() {self._str = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _str: String? = nil + } + + struct MessageSetCorrectExtension2: Sendable { + // 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 i: Int32 { + get {_i ?? 0} + set {_i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {self._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {self._i = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _i: Int32? = nil + } + + struct ExtensionWithOneof: Sendable { + // 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 oneofField: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.OneOf_OneofField? = nil + + var a: Int32 { + get { + if case .a(let v)? = oneofField {return v} + return 0 + } + set {oneofField = .a(newValue)} + } + + var b: Int32 { + get { + if case .b(let v)? = oneofField {return v} + return 0 + } + set {oneofField = .b(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case a(Int32) + case b(Int32) + + } + + init() {} + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2: Sendable { + // 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 c: Int32 { + get {_c ?? 0} + set {_c = newValue} + } + /// Returns true if `c` has been explicitly set. + var hasC: Bool {self._c != nil} + /// Clears the value of `c`. Subsequent reads from it will return its default value. + mutating func clearC() {self._c = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _c: Int32? = nil +} + +struct ProtobufTestMessages_Editions_Proto2_GroupField: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil +} + +struct ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes: Sendable { + // 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 optionalInt32: Int32 { + get {_optionalInt32 ?? 0} + set {_optionalInt32 = newValue} + } + /// Returns true if `optionalInt32` has been explicitly set. + var hasOptionalInt32: Bool {self._optionalInt32 != nil} + /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32() {self._optionalInt32 = nil} + + var optionalString: String { + get {_optionalString ?? String()} + set {_optionalString = newValue} + } + /// Returns true if `optionalString` has been explicitly set. + var hasOptionalString: Bool {self._optionalString != nil} + /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. + mutating func clearOptionalString() {self._optionalString = nil} + + var nestedMessage: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2 { + get {_nestedMessage ?? ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2()} + set {_nestedMessage = newValue} + } + /// Returns true if `nestedMessage` has been explicitly set. + var hasNestedMessage: Bool {self._nestedMessage != nil} + /// Clears the value of `nestedMessage`. Subsequent reads from it will return its default value. + mutating func clearNestedMessage() {self._nestedMessage = nil} + + var optionalGroup: ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.OptionalGroup { + get {_optionalGroup ?? ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.OptionalGroup()} + set {_optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {self._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {self._optionalGroup = nil} + + var optionalBool: Bool { + get {_optionalBool ?? false} + set {_optionalBool = newValue} + } + /// Returns true if `optionalBool` has been explicitly set. + var hasOptionalBool: Bool {self._optionalBool != nil} + /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. + mutating func clearOptionalBool() {self._optionalBool = nil} + + var repeatedInt32: [Int32] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct OptionalGroup: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + } + + init() {} + + fileprivate var _optionalInt32: Int32? = nil + fileprivate var _optionalString: String? = nil + fileprivate var _nestedMessage: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2? = nil + fileprivate var _optionalGroup: ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.OptionalGroup? = nil + fileprivate var _optionalBool: Bool? = nil +} + +struct ProtobufTestMessages_Editions_Proto2_NullHypothesisProto2: Sendable { + // 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 ProtobufTestMessages_Editions_Proto2_EnumOnlyProto2: Sendable { + // 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() + + enum BoolEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case kFalse = 0 + case kTrue = 1 + + init() { + self = .kFalse + } + + } + + init() {} +} + +struct ProtobufTestMessages_Editions_Proto2_OneStringProto2: Sendable { + // 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 data: String { + get {_data ?? String()} + set {_data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {self._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {self._data = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _data: String? = nil +} + +struct ProtobufTestMessages_Editions_Proto2_ProtoWithKeywords: Sendable { + // 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 inline: Int32 { + get {_inline ?? 0} + set {_inline = newValue} + } + /// Returns true if `inline` has been explicitly set. + var hasInline: Bool {self._inline != nil} + /// Clears the value of `inline`. Subsequent reads from it will return its default value. + mutating func clearInline() {self._inline = nil} + + var concept: String { + get {_concept ?? String()} + set {_concept = newValue} + } + /// Returns true if `concept` has been explicitly set. + var hasConcept: Bool {self._concept != nil} + /// Clears the value of `concept`. Subsequent reads from it will return its default value. + mutating func clearConcept() {self._concept = nil} + + var requires: [String] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _inline: Int32? = nil + fileprivate var _concept: String? = nil +} + +struct ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Singular + var requiredInt32: Int32 { + get {_storage._requiredInt32 ?? 0} + set {_uniqueStorage()._requiredInt32 = newValue} + } + /// Returns true if `requiredInt32` has been explicitly set. + var hasRequiredInt32: Bool {_storage._requiredInt32 != nil} + /// Clears the value of `requiredInt32`. Subsequent reads from it will return its default value. + mutating func clearRequiredInt32() {_uniqueStorage()._requiredInt32 = nil} + + var requiredInt64: Int64 { + get {_storage._requiredInt64 ?? 0} + set {_uniqueStorage()._requiredInt64 = newValue} + } + /// Returns true if `requiredInt64` has been explicitly set. + var hasRequiredInt64: Bool {_storage._requiredInt64 != nil} + /// Clears the value of `requiredInt64`. Subsequent reads from it will return its default value. + mutating func clearRequiredInt64() {_uniqueStorage()._requiredInt64 = nil} + + var requiredUint32: UInt32 { + get {_storage._requiredUint32 ?? 0} + set {_uniqueStorage()._requiredUint32 = newValue} + } + /// Returns true if `requiredUint32` has been explicitly set. + var hasRequiredUint32: Bool {_storage._requiredUint32 != nil} + /// Clears the value of `requiredUint32`. Subsequent reads from it will return its default value. + mutating func clearRequiredUint32() {_uniqueStorage()._requiredUint32 = nil} + + var requiredUint64: UInt64 { + get {_storage._requiredUint64 ?? 0} + set {_uniqueStorage()._requiredUint64 = newValue} + } + /// Returns true if `requiredUint64` has been explicitly set. + var hasRequiredUint64: Bool {_storage._requiredUint64 != nil} + /// Clears the value of `requiredUint64`. Subsequent reads from it will return its default value. + mutating func clearRequiredUint64() {_uniqueStorage()._requiredUint64 = nil} + + var requiredSint32: Int32 { + get {_storage._requiredSint32 ?? 0} + set {_uniqueStorage()._requiredSint32 = newValue} + } + /// Returns true if `requiredSint32` has been explicitly set. + var hasRequiredSint32: Bool {_storage._requiredSint32 != nil} + /// Clears the value of `requiredSint32`. Subsequent reads from it will return its default value. + mutating func clearRequiredSint32() {_uniqueStorage()._requiredSint32 = nil} + + var requiredSint64: Int64 { + get {_storage._requiredSint64 ?? 0} + set {_uniqueStorage()._requiredSint64 = newValue} + } + /// Returns true if `requiredSint64` has been explicitly set. + var hasRequiredSint64: Bool {_storage._requiredSint64 != nil} + /// Clears the value of `requiredSint64`. Subsequent reads from it will return its default value. + mutating func clearRequiredSint64() {_uniqueStorage()._requiredSint64 = nil} + + var requiredFixed32: UInt32 { + get {_storage._requiredFixed32 ?? 0} + set {_uniqueStorage()._requiredFixed32 = newValue} + } + /// Returns true if `requiredFixed32` has been explicitly set. + var hasRequiredFixed32: Bool {_storage._requiredFixed32 != nil} + /// Clears the value of `requiredFixed32`. Subsequent reads from it will return its default value. + mutating func clearRequiredFixed32() {_uniqueStorage()._requiredFixed32 = nil} + + var requiredFixed64: UInt64 { + get {_storage._requiredFixed64 ?? 0} + set {_uniqueStorage()._requiredFixed64 = newValue} + } + /// Returns true if `requiredFixed64` has been explicitly set. + var hasRequiredFixed64: Bool {_storage._requiredFixed64 != nil} + /// Clears the value of `requiredFixed64`. Subsequent reads from it will return its default value. + mutating func clearRequiredFixed64() {_uniqueStorage()._requiredFixed64 = nil} + + var requiredSfixed32: Int32 { + get {_storage._requiredSfixed32 ?? 0} + set {_uniqueStorage()._requiredSfixed32 = newValue} + } + /// Returns true if `requiredSfixed32` has been explicitly set. + var hasRequiredSfixed32: Bool {_storage._requiredSfixed32 != nil} + /// Clears the value of `requiredSfixed32`. Subsequent reads from it will return its default value. + mutating func clearRequiredSfixed32() {_uniqueStorage()._requiredSfixed32 = nil} + + var requiredSfixed64: Int64 { + get {_storage._requiredSfixed64 ?? 0} + set {_uniqueStorage()._requiredSfixed64 = newValue} + } + /// Returns true if `requiredSfixed64` has been explicitly set. + var hasRequiredSfixed64: Bool {_storage._requiredSfixed64 != nil} + /// Clears the value of `requiredSfixed64`. Subsequent reads from it will return its default value. + mutating func clearRequiredSfixed64() {_uniqueStorage()._requiredSfixed64 = nil} + + var requiredFloat: Float { + get {_storage._requiredFloat ?? 0} + set {_uniqueStorage()._requiredFloat = newValue} + } + /// Returns true if `requiredFloat` has been explicitly set. + var hasRequiredFloat: Bool {_storage._requiredFloat != nil} + /// Clears the value of `requiredFloat`. Subsequent reads from it will return its default value. + mutating func clearRequiredFloat() {_uniqueStorage()._requiredFloat = nil} + + var requiredDouble: Double { + get {_storage._requiredDouble ?? 0} + set {_uniqueStorage()._requiredDouble = newValue} + } + /// Returns true if `requiredDouble` has been explicitly set. + var hasRequiredDouble: Bool {_storage._requiredDouble != nil} + /// Clears the value of `requiredDouble`. Subsequent reads from it will return its default value. + mutating func clearRequiredDouble() {_uniqueStorage()._requiredDouble = nil} + + var requiredBool: Bool { + get {_storage._requiredBool ?? false} + set {_uniqueStorage()._requiredBool = newValue} + } + /// Returns true if `requiredBool` has been explicitly set. + var hasRequiredBool: Bool {_storage._requiredBool != nil} + /// Clears the value of `requiredBool`. Subsequent reads from it will return its default value. + mutating func clearRequiredBool() {_uniqueStorage()._requiredBool = nil} + + var requiredString: String { + get {_storage._requiredString ?? String()} + set {_uniqueStorage()._requiredString = newValue} + } + /// Returns true if `requiredString` has been explicitly set. + var hasRequiredString: Bool {_storage._requiredString != nil} + /// Clears the value of `requiredString`. Subsequent reads from it will return its default value. + mutating func clearRequiredString() {_uniqueStorage()._requiredString = nil} + + var requiredBytes: Data { + get {_storage._requiredBytes ?? Data()} + set {_uniqueStorage()._requiredBytes = newValue} + } + /// Returns true if `requiredBytes` has been explicitly set. + var hasRequiredBytes: Bool {_storage._requiredBytes != nil} + /// Clears the value of `requiredBytes`. Subsequent reads from it will return its default value. + mutating func clearRequiredBytes() {_uniqueStorage()._requiredBytes = nil} + + var requiredNestedMessage: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedMessage { + get {_storage._requiredNestedMessage ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedMessage()} + set {_uniqueStorage()._requiredNestedMessage = newValue} + } + /// Returns true if `requiredNestedMessage` has been explicitly set. + var hasRequiredNestedMessage: Bool {_storage._requiredNestedMessage != nil} + /// Clears the value of `requiredNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearRequiredNestedMessage() {_uniqueStorage()._requiredNestedMessage = nil} + + var requiredForeignMessage: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2 { + get {_storage._requiredForeignMessage ?? ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2()} + set {_uniqueStorage()._requiredForeignMessage = newValue} + } + /// Returns true if `requiredForeignMessage` has been explicitly set. + var hasRequiredForeignMessage: Bool {_storage._requiredForeignMessage != nil} + /// Clears the value of `requiredForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearRequiredForeignMessage() {_uniqueStorage()._requiredForeignMessage = nil} + + var requiredNestedEnum: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedEnum { + get {_storage._requiredNestedEnum ?? .foo} + set {_uniqueStorage()._requiredNestedEnum = newValue} + } + /// Returns true if `requiredNestedEnum` has been explicitly set. + var hasRequiredNestedEnum: Bool {_storage._requiredNestedEnum != nil} + /// Clears the value of `requiredNestedEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredNestedEnum() {_uniqueStorage()._requiredNestedEnum = nil} + + var requiredForeignEnum: ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2 { + get {_storage._requiredForeignEnum ?? .foreignFoo} + set {_uniqueStorage()._requiredForeignEnum = newValue} + } + /// Returns true if `requiredForeignEnum` has been explicitly set. + var hasRequiredForeignEnum: Bool {_storage._requiredForeignEnum != nil} + /// Clears the value of `requiredForeignEnum`. Subsequent reads from it will return its default value. + mutating func clearRequiredForeignEnum() {_uniqueStorage()._requiredForeignEnum = nil} + + var requiredStringPiece: String { + get {_storage._requiredStringPiece ?? String()} + set {_uniqueStorage()._requiredStringPiece = newValue} + } + /// Returns true if `requiredStringPiece` has been explicitly set. + var hasRequiredStringPiece: Bool {_storage._requiredStringPiece != nil} + /// Clears the value of `requiredStringPiece`. Subsequent reads from it will return its default value. + mutating func clearRequiredStringPiece() {_uniqueStorage()._requiredStringPiece = nil} + + var requiredCord: String { + get {_storage._requiredCord ?? String()} + set {_uniqueStorage()._requiredCord = newValue} + } + /// Returns true if `requiredCord` has been explicitly set. + var hasRequiredCord: Bool {_storage._requiredCord != nil} + /// Clears the value of `requiredCord`. Subsequent reads from it will return its default value. + mutating func clearRequiredCord() {_uniqueStorage()._requiredCord = nil} + + var recursiveMessage: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2 { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._recursiveMessage = newValue} + } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} + + var optionalRecursiveMessage: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2 { + get {_storage._optionalRecursiveMessage ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._optionalRecursiveMessage = newValue} + } + /// Returns true if `optionalRecursiveMessage` has been explicitly set. + var hasOptionalRecursiveMessage: Bool {_storage._optionalRecursiveMessage != nil} + /// Clears the value of `optionalRecursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalRecursiveMessage() {_uniqueStorage()._optionalRecursiveMessage = nil} + + var data: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.DataMessage { + get {_storage._data ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.DataMessage()} + set {_uniqueStorage()._data = newValue} + } + /// Returns true if `data` has been explicitly set. + var hasData: Bool {_storage._data != nil} + /// Clears the value of `data`. Subsequent reads from it will return its default value. + mutating func clearData() {_uniqueStorage()._data = nil} + + /// default values + var defaultInt32: Int32 { + get {_storage._defaultInt32 ?? -123456789} + set {_uniqueStorage()._defaultInt32 = newValue} + } + /// Returns true if `defaultInt32` has been explicitly set. + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} + /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} + + var defaultInt64: Int64 { + get {_storage._defaultInt64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultInt64 = newValue} + } + /// Returns true if `defaultInt64` has been explicitly set. + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} + /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. + mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} + + var defaultUint32: UInt32 { + get {_storage._defaultUint32 ?? 2123456789} + set {_uniqueStorage()._defaultUint32 = newValue} + } + /// Returns true if `defaultUint32` has been explicitly set. + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} + /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} + + var defaultUint64: UInt64 { + get {_storage._defaultUint64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultUint64 = newValue} + } + /// Returns true if `defaultUint64` has been explicitly set. + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} + /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} + + var defaultSint32: Int32 { + get {_storage._defaultSint32 ?? -123456789} + set {_uniqueStorage()._defaultSint32 = newValue} + } + /// Returns true if `defaultSint32` has been explicitly set. + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} + /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} + + var defaultSint64: Int64 { + get {_storage._defaultSint64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSint64 = newValue} + } + /// Returns true if `defaultSint64` has been explicitly set. + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} + /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} + + var defaultFixed32: UInt32 { + get {_storage._defaultFixed32 ?? 2123456789} + set {_uniqueStorage()._defaultFixed32 = newValue} + } + /// Returns true if `defaultFixed32` has been explicitly set. + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} + /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} + + var defaultFixed64: UInt64 { + get {_storage._defaultFixed64 ?? 10123456789123456789} + set {_uniqueStorage()._defaultFixed64 = newValue} + } + /// Returns true if `defaultFixed64` has been explicitly set. + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} + /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} + + var defaultSfixed32: Int32 { + get {_storage._defaultSfixed32 ?? -123456789} + set {_uniqueStorage()._defaultSfixed32 = newValue} + } + /// Returns true if `defaultSfixed32` has been explicitly set. + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} + /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} + + var defaultSfixed64: Int64 { + get {_storage._defaultSfixed64 ?? -9123456789123456789} + set {_uniqueStorage()._defaultSfixed64 = newValue} + } + /// Returns true if `defaultSfixed64` has been explicitly set. + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} + /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. + mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} + + var defaultFloat: Float { + get {_storage._defaultFloat ?? 9e+09} + set {_uniqueStorage()._defaultFloat = newValue} + } + /// Returns true if `defaultFloat` has been explicitly set. + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} + /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. + mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} + + var defaultDouble: Double { + get {_storage._defaultDouble ?? 7e+22} + set {_uniqueStorage()._defaultDouble = newValue} + } + /// Returns true if `defaultDouble` has been explicitly set. + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} + /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. + mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} + + var defaultBool: Bool { + get {_storage._defaultBool ?? true} + set {_uniqueStorage()._defaultBool = newValue} + } + /// Returns true if `defaultBool` has been explicitly set. + var hasDefaultBool: Bool {_storage._defaultBool != nil} + /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. + mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} + + var defaultString: String { + get {_storage._defaultString ?? "Rosebud"} + set {_uniqueStorage()._defaultString = newValue} + } + /// Returns true if `defaultString` has been explicitly set. + var hasDefaultString: Bool {_storage._defaultString != nil} + /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. + mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} + + var defaultBytes: Data { + get {_storage._defaultBytes ?? Data([106, 111, 115, 104, 117, 97])} + set {_uniqueStorage()._defaultBytes = newValue} + } + /// Returns true if `defaultBytes` has been explicitly set. + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} + /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. + mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 + + /// Intentionally negative. + case neg = -1 + + init() { + self = .foo + } + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a ?? 0} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} + + var corecursive: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2 { + get {_storage._corecursive ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var optionalCorecursive: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2 { + get {_storage._optionalCorecursive ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2()} + set {_uniqueStorage()._optionalCorecursive = newValue} + } + /// Returns true if `optionalCorecursive` has been explicitly set. + var hasOptionalCorecursive: Bool {_storage._optionalCorecursive != nil} + /// Clears the value of `optionalCorecursive`. Subsequent reads from it will return its default value. + mutating func clearOptionalCorecursive() {_uniqueStorage()._optionalCorecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + /// groups + struct DataMessage: Sendable { + // 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 groupInt32: Int32 { + get {_groupInt32 ?? 0} + set {_groupInt32 = newValue} + } + /// Returns true if `groupInt32` has been explicitly set. + var hasGroupInt32: Bool {self._groupInt32 != nil} + /// Clears the value of `groupInt32`. Subsequent reads from it will return its default value. + mutating func clearGroupInt32() {self._groupInt32 = nil} + + var groupUint32: UInt32 { + get {_groupUint32 ?? 0} + set {_groupUint32 = newValue} + } + /// Returns true if `groupUint32` has been explicitly set. + var hasGroupUint32: Bool {self._groupUint32 != nil} + /// Clears the value of `groupUint32`. Subsequent reads from it will return its default value. + mutating func clearGroupUint32() {self._groupUint32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _groupInt32: Int32? = nil + fileprivate var _groupUint32: UInt32? = nil + } + + /// message_set test case. + struct MessageSetCorrect: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() + } + + struct MessageSetCorrectExtension1: Sendable { + // 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 str: String { + get {_str ?? String()} + set {_str = newValue} + } + /// Returns true if `str` has been explicitly set. + var hasStr: Bool {self._str != nil} + /// Clears the value of `str`. Subsequent reads from it will return its default value. + mutating func clearStr() {self._str = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _str: String? = nil + } + + struct MessageSetCorrectExtension2: Sendable { + // 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 i: Int32 { + get {_i ?? 0} + set {_i = newValue} + } + /// Returns true if `i` has been explicitly set. + var hasI: Bool {self._i != nil} + /// Clears the value of `i`. Subsequent reads from it will return its default value. + mutating func clearI() {self._i = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _i: Int32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct ProtobufTestMessages_Editions_Proto2_TestLargeOneof: Sendable { + // 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 largeOneof: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.OneOf_LargeOneof? = nil + + var a1: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1 { + get { + if case .a1(let v)? = largeOneof {return v} + return ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1() + } + set {largeOneof = .a1(newValue)} + } + + var a2: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2 { + get { + if case .a2(let v)? = largeOneof {return v} + return ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2() + } + set {largeOneof = .a2(newValue)} + } + + var a3: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3 { + get { + if case .a3(let v)? = largeOneof {return v} + return ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3() + } + set {largeOneof = .a3(newValue)} + } + + var a4: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4 { + get { + if case .a4(let v)? = largeOneof {return v} + return ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4() + } + set {largeOneof = .a4(newValue)} + } + + var a5: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5 { + get { + if case .a5(let v)? = largeOneof {return v} + return ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5() + } + set {largeOneof = .a5(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_LargeOneof: Equatable, Sendable { + case a1(ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1) + case a2(ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2) + case a3(ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3) + case a4(ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4) + case a5(ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5) + + } + + struct A1: Sendable { + // 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 A2: Sendable { + // 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 A3: Sendable { + // 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 A4: Sendable { + // 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 A5: Sendable { + // 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() {} + } + + init() {} +} + +// MARK: - Extension support defined in test_messages_proto2_editions.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect { + + var ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension1_messageSetExtension: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1 { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension1_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension2_messageSetExtension: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2 { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) ?? ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2_MessageSetCorrectExtension2_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2 { + + var ProtobufTestMessages_Editions_Proto2_extensionInt32: Int32 { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32) ?? 0} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_extensionInt32: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_extensionInt32() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32) + } + + var ProtobufTestMessages_Editions_Proto2_groupField: ProtobufTestMessages_Editions_Proto2_GroupField { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_GroupField) ?? ProtobufTestMessages_Editions_Proto2_GroupField()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_GroupField, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_Extensions_GroupField` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_groupField: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_GroupField) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_Extensions_GroupField`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_groupField() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_Extensions_GroupField) + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect { + + var ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1 { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_MessageSetCorrectExtension1_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2 { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_MessageSetCorrectExtension2_messageSetExtension() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension) + } + + var ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_ExtensionWithOneof_extensionWithOneof: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof { + get {return getExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof) ?? ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof()} + set {setExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof, value: newValue)} + } + /// Returns true if extension `ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof` + /// has been explicitly set. + var hasProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_ExtensionWithOneof_extensionWithOneof: Bool { + return hasExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof) + } + /// Clears the value of extension `ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof`. + /// Subsequent reads from it will return its default value. + mutating func clearProtobufTestMessages_Editions_Proto2_TestAllTypesProto2_ExtensionWithOneof_extensionWithOneof() { + clearExtensionValue(ext: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof) + } + +} + +// MARK: - File's ExtensionMap: ProtobufTestMessages_Editions_Proto2_TestMessagesProto2Editions_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 ProtobufTestMessages_Editions_Proto2_TestMessagesProto2Editions_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32, + ProtobufTestMessages_Editions_Proto2_Extensions_GroupField, + ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, + ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension, + ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof.Extensions.extension_with_oneof, + ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1.Extensions.message_set_extension, + ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2.Extensions.message_set_extension +] + +// 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 ProtobufTestMessages_Editions_Proto2_Extensions_extension_int32 = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2>( + _protobuf_fieldNumber: 120, + fieldName: "protobuf_test_messages.editions.proto2.extension_int32" +) + +let ProtobufTestMessages_Editions_Proto2_Extensions_GroupField = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2>( + _protobuf_fieldNumber: 121, + fieldName: "protobuf_test_messages.editions.proto2.groupfield" +) + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 1547769, + fieldName: "protobuf_test_messages.editions.proto2.TestAllTypesProto2.MessageSetCorrectExtension1" + ) + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 4135312, + fieldName: "protobuf_test_messages.editions.proto2.TestAllTypesProto2.MessageSetCorrectExtension2" + ) + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof { + enum Extensions { + static let extension_with_oneof = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 123456789, + fieldName: "protobuf_test_messages.editions.proto2.TestAllTypesProto2.ExtensionWithOneof" + ) + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 1547769, + fieldName: "protobuf_test_messages.editions.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension1" + ) + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect>( + _protobuf_fieldNumber: 4135312, + fieldName: "protobuf_test_messages.editions.proto2.TestAllRequiredTypesProto2.MessageSetCorrectExtension2" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "protobuf_test_messages.editions.proto2" + +extension ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypesProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{4}\u{2}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{4}\u{2}optional_string_piece\0\u{3}optional_cord\0\u{4}\u{2}recursive_message\0\u{4}\u{4}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{4}\u{2}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_nested_message\0\u{3}map_string_foreign_message\0\u{3}map_string_nested_enum\0\u{3}map_string_foreign_enum\0\u{3}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_nested_enum\0\u{3}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_nested_enum\0\u{3}map_int32_nested_message\0\u{3}map_int32_bool\0\u{4}\u{7}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_bool\0\u{3}oneof_uint64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_enum\0\u{8}R\u{1}Data\0\u{8}\u{3}MultiWordGroupField\0\u{4}%default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{2}R\u{2}fieldname1\0\u{3}field_name2\0\u{3}_field_name3\0\u{3}field__name4_\0\u{1}field0name5\0\u{3}field_0_name6\0\u{1}fieldName7\0\u{1}FieldName8\0\u{3}field_Name9\0\u{3}Field_Name10\0\u{3}FIELD_NAME11\0\u{3}FIELD_name12\0\u{3}__field_name13\0\u{3}__Field_name14\0\u{3}field__name15\0\u{3}field__Name16\0\u{3}field_name17__\0\u{3}Field_name18__\0\u{4}R\u{1}message_set_correct\0\u{b}reserved_field\0\u{c}h\u{f}hL\u{2}\u{c}\u{7f}Ht\u{3}\u{1}") + + fileprivate class _StorageClass { + var _optionalInt32: Int32? = nil + var _optionalInt64: Int64? = nil + var _optionalUint32: UInt32? = nil + var _optionalUint64: UInt64? = nil + var _optionalSint32: Int32? = nil + var _optionalSint64: Int64? = nil + var _optionalFixed32: UInt32? = nil + var _optionalFixed64: UInt64? = nil + var _optionalSfixed32: Int32? = nil + var _optionalSfixed64: Int64? = nil + var _optionalFloat: Float? = nil + var _optionalDouble: Double? = nil + var _optionalBool: Bool? = nil + var _optionalString: String? = nil + var _optionalBytes: Data? = nil + var _optionalNestedMessage: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage? = nil + var _optionalForeignMessage: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2? = nil + var _optionalNestedEnum: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum? = nil + var _optionalForeignEnum: ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2? = nil + var _optionalStringPiece: String? = nil + var _optionalCord: String? = nil + var _recursiveMessage: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2? = nil + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedNestedMessage: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage] = [] + var _repeatedForeignMessage: [ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2] = [] + var _repeatedNestedEnum: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _repeatedForeignEnum: [ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2] = [] + var _repeatedStringPiece: [String] = [] + var _repeatedCord: [String] = [] + var _packedInt32: [Int32] = [] + var _packedInt64: [Int64] = [] + var _packedUint32: [UInt32] = [] + var _packedUint64: [UInt64] = [] + var _packedSint32: [Int32] = [] + var _packedSint64: [Int64] = [] + var _packedFixed32: [UInt32] = [] + var _packedFixed64: [UInt64] = [] + var _packedSfixed32: [Int32] = [] + var _packedSfixed64: [Int64] = [] + var _packedFloat: [Float] = [] + var _packedDouble: [Double] = [] + var _packedBool: [Bool] = [] + var _packedNestedEnum: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _unpackedInt32: [Int32] = [] + var _unpackedInt64: [Int64] = [] + var _unpackedUint32: [UInt32] = [] + var _unpackedUint64: [UInt64] = [] + var _unpackedSint32: [Int32] = [] + var _unpackedSint64: [Int64] = [] + var _unpackedFixed32: [UInt32] = [] + var _unpackedFixed64: [UInt64] = [] + var _unpackedSfixed32: [Int32] = [] + var _unpackedSfixed64: [Int64] = [] + var _unpackedFloat: [Float] = [] + var _unpackedDouble: [Double] = [] + var _unpackedBool: [Bool] = [] + var _unpackedNestedEnum: [ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum] = [] + var _mapInt32Int32: Dictionary = [:] + var _mapInt64Int64: Dictionary = [:] + var _mapUint32Uint32: Dictionary = [:] + var _mapUint64Uint64: Dictionary = [:] + var _mapSint32Sint32: Dictionary = [:] + var _mapSint64Sint64: Dictionary = [:] + var _mapFixed32Fixed32: Dictionary = [:] + var _mapFixed64Fixed64: Dictionary = [:] + var _mapSfixed32Sfixed32: Dictionary = [:] + var _mapSfixed64Sfixed64: Dictionary = [:] + var _mapInt32Bool: Dictionary = [:] + var _mapInt32Float: Dictionary = [:] + var _mapInt32Double: Dictionary = [:] + var _mapInt32NestedMessage: Dictionary = [:] + var _mapBoolBool: Dictionary = [:] + var _mapStringString: Dictionary = [:] + var _mapStringBytes: Dictionary = [:] + var _mapStringNestedMessage: Dictionary = [:] + var _mapStringForeignMessage: Dictionary = [:] + var _mapStringNestedEnum: Dictionary = [:] + var _mapStringForeignEnum: Dictionary = [:] + var _oneofField: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.OneOf_OneofField? + var _data: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.DataMessage? = nil + var _multiWordGroupField: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MultiWordGroupField? = nil + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + var _fieldname1: Int32? = nil + var _fieldName2: Int32? = nil + var _fieldName3: Int32? = nil + var _field_Name4_: Int32? = nil + var _field0Name5: Int32? = nil + var _field0Name6: Int32? = nil + var _fieldName7: Int32? = nil + var _fieldName8: Int32? = nil + var _fieldName9: Int32? = nil + var _fieldName10: Int32? = nil + var _fieldName11: Int32? = nil + var _fieldName12: Int32? = nil + var __FieldName13: Int32? = nil + var __FieldName14: Int32? = nil + var _field_Name15: Int32? = nil + var _field_Name16: Int32? = nil + var _fieldName17__: Int32? = nil + var _fieldName18__: Int32? = nil + var _messageSetCorrect: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalNestedMessage = source._optionalNestedMessage + _optionalForeignMessage = source._optionalForeignMessage + _optionalNestedEnum = source._optionalNestedEnum + _optionalForeignEnum = source._optionalForeignEnum + _optionalStringPiece = source._optionalStringPiece + _optionalCord = source._optionalCord + _recursiveMessage = source._recursiveMessage + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedForeignMessage = source._repeatedForeignMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _repeatedForeignEnum = source._repeatedForeignEnum + _repeatedStringPiece = source._repeatedStringPiece + _repeatedCord = source._repeatedCord + _packedInt32 = source._packedInt32 + _packedInt64 = source._packedInt64 + _packedUint32 = source._packedUint32 + _packedUint64 = source._packedUint64 + _packedSint32 = source._packedSint32 + _packedSint64 = source._packedSint64 + _packedFixed32 = source._packedFixed32 + _packedFixed64 = source._packedFixed64 + _packedSfixed32 = source._packedSfixed32 + _packedSfixed64 = source._packedSfixed64 + _packedFloat = source._packedFloat + _packedDouble = source._packedDouble + _packedBool = source._packedBool + _packedNestedEnum = source._packedNestedEnum + _unpackedInt32 = source._unpackedInt32 + _unpackedInt64 = source._unpackedInt64 + _unpackedUint32 = source._unpackedUint32 + _unpackedUint64 = source._unpackedUint64 + _unpackedSint32 = source._unpackedSint32 + _unpackedSint64 = source._unpackedSint64 + _unpackedFixed32 = source._unpackedFixed32 + _unpackedFixed64 = source._unpackedFixed64 + _unpackedSfixed32 = source._unpackedSfixed32 + _unpackedSfixed64 = source._unpackedSfixed64 + _unpackedFloat = source._unpackedFloat + _unpackedDouble = source._unpackedDouble + _unpackedBool = source._unpackedBool + _unpackedNestedEnum = source._unpackedNestedEnum + _mapInt32Int32 = source._mapInt32Int32 + _mapInt64Int64 = source._mapInt64Int64 + _mapUint32Uint32 = source._mapUint32Uint32 + _mapUint64Uint64 = source._mapUint64Uint64 + _mapSint32Sint32 = source._mapSint32Sint32 + _mapSint64Sint64 = source._mapSint64Sint64 + _mapFixed32Fixed32 = source._mapFixed32Fixed32 + _mapFixed64Fixed64 = source._mapFixed64Fixed64 + _mapSfixed32Sfixed32 = source._mapSfixed32Sfixed32 + _mapSfixed64Sfixed64 = source._mapSfixed64Sfixed64 + _mapInt32Bool = source._mapInt32Bool + _mapInt32Float = source._mapInt32Float + _mapInt32Double = source._mapInt32Double + _mapInt32NestedMessage = source._mapInt32NestedMessage + _mapBoolBool = source._mapBoolBool + _mapStringString = source._mapStringString + _mapStringBytes = source._mapStringBytes + _mapStringNestedMessage = source._mapStringNestedMessage + _mapStringForeignMessage = source._mapStringForeignMessage + _mapStringNestedEnum = source._mapStringNestedEnum + _mapStringForeignEnum = source._mapStringForeignEnum + _oneofField = source._oneofField + _data = source._data + _multiWordGroupField = source._multiWordGroupField + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + _fieldname1 = source._fieldname1 + _fieldName2 = source._fieldName2 + _fieldName3 = source._fieldName3 + _field_Name4_ = source._field_Name4_ + _field0Name5 = source._field0Name5 + _field0Name6 = source._field0Name6 + _fieldName7 = source._fieldName7 + _fieldName8 = source._fieldName8 + _fieldName9 = source._fieldName9 + _fieldName10 = source._fieldName10 + _fieldName11 = source._fieldName11 + _fieldName12 = source._fieldName12 + __FieldName13 = source.__FieldName13 + __FieldName14 = source.__FieldName14 + _field_Name15 = source._field_Name15 + _field_Name16 = source._field_Name16 + _fieldName17__ = source._fieldName17__ + _fieldName18__ = source._fieldName18__ + _messageSetCorrect = source._messageSetCorrect + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._optionalNestedMessage, !v.isInitialized {return false} + if let v = _storage._recursiveMessage, !v.isInitialized {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._repeatedNestedMessage) {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._mapInt32NestedMessage) {return false} + if !SwiftProtobuf.Internal.areAllInitialized(_storage._mapStringNestedMessage) {return false} + if let v = _storage._oneofField, !v.isInitialized {return false} + if let v = _storage._messageSetCorrect, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() + case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() + case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() + case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() + case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() + case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() + case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() + case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() + case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() + case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() + case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() + case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() + case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() + case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() + case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() + case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() + case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() + case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() + case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() + case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() + case 56: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Int32) }() + case 57: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() + case 58: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() + case 59: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Uint64) }() + case 60: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Sint32) }() + case 61: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Sint64) }() + case 62: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Fixed32) }() + case 63: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Fixed64) }() + case 64: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Sfixed32) }() + case 65: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Sfixed64) }() + case 66: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Float) }() + case 67: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Double) }() + case 68: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() + case 69: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() + case 70: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() + case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringNestedMessage) }() + case 72: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() + case 73: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringNestedEnum) }() + case 74: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringForeignEnum) }() + case 75: try { try decoder.decodeRepeatedInt32Field(value: &_storage._packedInt32) }() + case 76: try { try decoder.decodeRepeatedInt64Field(value: &_storage._packedInt64) }() + case 77: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._packedUint32) }() + case 78: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._packedUint64) }() + case 79: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._packedSint32) }() + case 80: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._packedSint64) }() + case 81: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._packedFixed32) }() + case 82: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._packedFixed64) }() + case 83: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._packedSfixed32) }() + case 84: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._packedSfixed64) }() + case 85: try { try decoder.decodeRepeatedFloatField(value: &_storage._packedFloat) }() + case 86: try { try decoder.decodeRepeatedDoubleField(value: &_storage._packedDouble) }() + case 87: try { try decoder.decodeRepeatedBoolField(value: &_storage._packedBool) }() + case 88: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedNestedEnum) }() + case 89: try { try decoder.decodeRepeatedInt32Field(value: &_storage._unpackedInt32) }() + case 90: try { try decoder.decodeRepeatedInt64Field(value: &_storage._unpackedInt64) }() + case 91: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._unpackedUint32) }() + case 92: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._unpackedUint64) }() + case 93: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._unpackedSint32) }() + case 94: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._unpackedSint64) }() + case 95: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._unpackedFixed32) }() + case 96: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._unpackedFixed64) }() + case 97: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._unpackedSfixed32) }() + case 98: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._unpackedSfixed64) }() + case 99: try { try decoder.decodeRepeatedFloatField(value: &_storage._unpackedFloat) }() + case 100: try { try decoder.decodeRepeatedDoubleField(value: &_storage._unpackedDouble) }() + case 101: try { try decoder.decodeRepeatedBoolField(value: &_storage._unpackedBool) }() + case 102: try { try decoder.decodeRepeatedEnumField(value: &_storage._unpackedNestedEnum) }() + case 103: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32NestedMessage) }() + case 104: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bool) }() + case 111: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 112: try { + var v: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage(v) + } + }() + case 113: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 114: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() + case 115: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBool(v) + } + }() + case 116: try { + var v: UInt64? + try decoder.decodeSingularUInt64Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint64(v) + } + }() + case 117: try { + var v: Float? + try decoder.decodeSingularFloatField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofFloat(v) + } + }() + case 118: try { + var v: Double? + try decoder.decodeSingularDoubleField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofDouble(v) + } + }() + case 119: try { + var v: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofEnum(v) + } + }() + case 201: try { try decoder.decodeSingularGroupField(value: &_storage._data) }() + case 204: try { try decoder.decodeSingularGroupField(value: &_storage._multiWordGroupField) }() + case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 242: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 243: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 244: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 245: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 246: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 247: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 248: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 249: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 250: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 251: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 252: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 253: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 254: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 255: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() + case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldname1) }() + case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName2) }() + case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName3) }() + case 404: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name4_) }() + case 405: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name5) }() + case 406: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name6) }() + case 407: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName7) }() + case 408: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName8) }() + case 409: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName9) }() + case 410: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName10) }() + case 411: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName11) }() + case 412: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName12) }() + case 413: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName13) }() + case 414: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName14) }() + case 415: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name15) }() + case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name16) }() + case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName17__) }() + case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName18__) }() + case 500: try { try decoder.decodeSingularMessageField(value: &_storage._messageSetCorrect) }() + case 120..<201: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._optionalInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._optionalUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._optionalSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._optionalSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._optionalFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._optionalFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._optionalSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._optionalSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._optionalFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._optionalDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._optionalBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._optionalForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._optionalNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._optionalForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._optionalStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._optionalCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + if !_storage._repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + } + if !_storage._repeatedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + } + if !_storage._repeatedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + } + if !_storage._repeatedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + } + if !_storage._repeatedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + } + if !_storage._repeatedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + } + if !_storage._repeatedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + } + if !_storage._repeatedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + } + if !_storage._repeatedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + } + if !_storage._repeatedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + } + if !_storage._repeatedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + } + if !_storage._repeatedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + } + if !_storage._repeatedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + } + if !_storage._repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) + } + if !_storage._repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) + } + if !_storage._repeatedNestedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) + } + if !_storage._repeatedForeignMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) + } + if !_storage._repeatedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + } + if !_storage._repeatedForeignEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) + } + if !_storage._repeatedStringPiece.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) + } + if !_storage._repeatedCord.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) + } + if !_storage._mapInt32Int32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Int32, fieldNumber: 56) + } + if !_storage._mapInt64Int64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Int64, fieldNumber: 57) + } + if !_storage._mapUint32Uint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Uint32, fieldNumber: 58) + } + if !_storage._mapUint64Uint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Uint64, fieldNumber: 59) + } + if !_storage._mapSint32Sint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Sint32, fieldNumber: 60) + } + if !_storage._mapSint64Sint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Sint64, fieldNumber: 61) + } + if !_storage._mapFixed32Fixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Fixed32, fieldNumber: 62) + } + if !_storage._mapFixed64Fixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Fixed64, fieldNumber: 63) + } + if !_storage._mapSfixed32Sfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 64) + } + if !_storage._mapSfixed64Sfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 65) + } + if !_storage._mapInt32Float.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Float, fieldNumber: 66) + } + if !_storage._mapInt32Double.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Double, fieldNumber: 67) + } + if !_storage._mapBoolBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolBool, fieldNumber: 68) + } + if !_storage._mapStringString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringString, fieldNumber: 69) + } + if !_storage._mapStringBytes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 70) + } + if !_storage._mapStringNestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringNestedMessage, fieldNumber: 71) + } + if !_storage._mapStringForeignMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 72) + } + if !_storage._mapStringNestedEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringNestedEnum, fieldNumber: 73) + } + if !_storage._mapStringForeignEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringForeignEnum, fieldNumber: 74) + } + if !_storage._packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._packedInt32, fieldNumber: 75) + } + if !_storage._packedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._packedInt64, fieldNumber: 76) + } + if !_storage._packedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._packedUint32, fieldNumber: 77) + } + if !_storage._packedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._packedUint64, fieldNumber: 78) + } + if !_storage._packedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._packedSint32, fieldNumber: 79) + } + if !_storage._packedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._packedSint64, fieldNumber: 80) + } + if !_storage._packedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._packedFixed32, fieldNumber: 81) + } + if !_storage._packedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._packedFixed64, fieldNumber: 82) + } + if !_storage._packedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._packedSfixed32, fieldNumber: 83) + } + if !_storage._packedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._packedSfixed64, fieldNumber: 84) + } + if !_storage._packedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._packedFloat, fieldNumber: 85) + } + if !_storage._packedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._packedDouble, fieldNumber: 86) + } + if !_storage._packedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._packedBool, fieldNumber: 87) + } + if !_storage._packedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedNestedEnum, fieldNumber: 88) + } + if !_storage._unpackedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._unpackedInt32, fieldNumber: 89) + } + if !_storage._unpackedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._unpackedInt64, fieldNumber: 90) + } + if !_storage._unpackedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._unpackedUint32, fieldNumber: 91) + } + if !_storage._unpackedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._unpackedUint64, fieldNumber: 92) + } + if !_storage._unpackedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._unpackedSint32, fieldNumber: 93) + } + if !_storage._unpackedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._unpackedSint64, fieldNumber: 94) + } + if !_storage._unpackedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._unpackedFixed32, fieldNumber: 95) + } + if !_storage._unpackedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._unpackedFixed64, fieldNumber: 96) + } + if !_storage._unpackedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._unpackedSfixed32, fieldNumber: 97) + } + if !_storage._unpackedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._unpackedSfixed64, fieldNumber: 98) + } + if !_storage._unpackedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._unpackedFloat, fieldNumber: 99) + } + if !_storage._unpackedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._unpackedDouble, fieldNumber: 100) + } + if !_storage._unpackedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._unpackedBool, fieldNumber: 101) + } + if !_storage._unpackedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._unpackedNestedEnum, fieldNumber: 102) + } + if !_storage._mapInt32NestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32NestedMessage, fieldNumber: 103) + } + if !_storage._mapInt32Bool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bool, fieldNumber: 104) + } + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case .oneofBool?: try { + guard case .oneofBool(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 115) + }() + case .oneofUint64?: try { + guard case .oneofUint64(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 116) + }() + case .oneofFloat?: try { + guard case .oneofFloat(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularFloatField(value: v, fieldNumber: 117) + }() + case .oneofDouble?: try { + guard case .oneofDouble(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularDoubleField(value: v, fieldNumber: 118) + }() + case .oneofEnum?: try { + guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 119) + }() + case nil: break + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201) + try { if let v = _storage._data { + try visitor.visitSingularGroupField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._multiWordGroupField { + try visitor.visitSingularGroupField(value: v, fieldNumber: 204) + } }() + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 241) + } }() + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 242) + } }() + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 243) + } }() + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 244) + } }() + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 245) + } }() + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 246) + } }() + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 247) + } }() + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 248) + } }() + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 249) + } }() + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 250) + } }() + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 251) + } }() + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 252) + } }() + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 253) + } }() + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 254) + } }() + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 255) + } }() + try { if let v = _storage._fieldname1 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 401) + } }() + try { if let v = _storage._fieldName2 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 402) + } }() + try { if let v = _storage._fieldName3 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 403) + } }() + try { if let v = _storage._field_Name4_ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 404) + } }() + try { if let v = _storage._field0Name5 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 405) + } }() + try { if let v = _storage._field0Name6 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 406) + } }() + try { if let v = _storage._fieldName7 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 407) + } }() + try { if let v = _storage._fieldName8 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 408) + } }() + try { if let v = _storage._fieldName9 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 409) + } }() + try { if let v = _storage._fieldName10 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 410) + } }() + try { if let v = _storage._fieldName11 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 411) + } }() + try { if let v = _storage._fieldName12 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 412) + } }() + try { if let v = _storage.__FieldName13 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 413) + } }() + try { if let v = _storage.__FieldName14 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 414) + } }() + try { if let v = _storage._field_Name15 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 415) + } }() + try { if let v = _storage._field_Name16 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 416) + } }() + try { if let v = _storage._fieldName17__ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 417) + } }() + try { if let v = _storage._fieldName18__ { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 418) + } }() + try { if let v = _storage._messageSetCorrect { + try visitor.visitSingularMessageField(value: v, fieldNumber: 500) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} + if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} + if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} + if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} + if _storage._repeatedCord != rhs_storage._repeatedCord {return false} + if _storage._packedInt32 != rhs_storage._packedInt32 {return false} + if _storage._packedInt64 != rhs_storage._packedInt64 {return false} + if _storage._packedUint32 != rhs_storage._packedUint32 {return false} + if _storage._packedUint64 != rhs_storage._packedUint64 {return false} + if _storage._packedSint32 != rhs_storage._packedSint32 {return false} + if _storage._packedSint64 != rhs_storage._packedSint64 {return false} + if _storage._packedFixed32 != rhs_storage._packedFixed32 {return false} + if _storage._packedFixed64 != rhs_storage._packedFixed64 {return false} + if _storage._packedSfixed32 != rhs_storage._packedSfixed32 {return false} + if _storage._packedSfixed64 != rhs_storage._packedSfixed64 {return false} + if _storage._packedFloat != rhs_storage._packedFloat {return false} + if _storage._packedDouble != rhs_storage._packedDouble {return false} + if _storage._packedBool != rhs_storage._packedBool {return false} + if _storage._packedNestedEnum != rhs_storage._packedNestedEnum {return false} + if _storage._unpackedInt32 != rhs_storage._unpackedInt32 {return false} + if _storage._unpackedInt64 != rhs_storage._unpackedInt64 {return false} + if _storage._unpackedUint32 != rhs_storage._unpackedUint32 {return false} + if _storage._unpackedUint64 != rhs_storage._unpackedUint64 {return false} + if _storage._unpackedSint32 != rhs_storage._unpackedSint32 {return false} + if _storage._unpackedSint64 != rhs_storage._unpackedSint64 {return false} + if _storage._unpackedFixed32 != rhs_storage._unpackedFixed32 {return false} + if _storage._unpackedFixed64 != rhs_storage._unpackedFixed64 {return false} + if _storage._unpackedSfixed32 != rhs_storage._unpackedSfixed32 {return false} + if _storage._unpackedSfixed64 != rhs_storage._unpackedSfixed64 {return false} + if _storage._unpackedFloat != rhs_storage._unpackedFloat {return false} + if _storage._unpackedDouble != rhs_storage._unpackedDouble {return false} + if _storage._unpackedBool != rhs_storage._unpackedBool {return false} + if _storage._unpackedNestedEnum != rhs_storage._unpackedNestedEnum {return false} + if _storage._mapInt32Int32 != rhs_storage._mapInt32Int32 {return false} + if _storage._mapInt64Int64 != rhs_storage._mapInt64Int64 {return false} + if _storage._mapUint32Uint32 != rhs_storage._mapUint32Uint32 {return false} + if _storage._mapUint64Uint64 != rhs_storage._mapUint64Uint64 {return false} + if _storage._mapSint32Sint32 != rhs_storage._mapSint32Sint32 {return false} + if _storage._mapSint64Sint64 != rhs_storage._mapSint64Sint64 {return false} + if _storage._mapFixed32Fixed32 != rhs_storage._mapFixed32Fixed32 {return false} + if _storage._mapFixed64Fixed64 != rhs_storage._mapFixed64Fixed64 {return false} + if _storage._mapSfixed32Sfixed32 != rhs_storage._mapSfixed32Sfixed32 {return false} + if _storage._mapSfixed64Sfixed64 != rhs_storage._mapSfixed64Sfixed64 {return false} + if _storage._mapInt32Bool != rhs_storage._mapInt32Bool {return false} + if _storage._mapInt32Float != rhs_storage._mapInt32Float {return false} + if _storage._mapInt32Double != rhs_storage._mapInt32Double {return false} + if _storage._mapInt32NestedMessage != rhs_storage._mapInt32NestedMessage {return false} + if _storage._mapBoolBool != rhs_storage._mapBoolBool {return false} + if _storage._mapStringString != rhs_storage._mapStringString {return false} + if _storage._mapStringBytes != rhs_storage._mapStringBytes {return false} + if _storage._mapStringNestedMessage != rhs_storage._mapStringNestedMessage {return false} + if _storage._mapStringForeignMessage != rhs_storage._mapStringForeignMessage {return false} + if _storage._mapStringNestedEnum != rhs_storage._mapStringNestedEnum {return false} + if _storage._mapStringForeignEnum != rhs_storage._mapStringForeignEnum {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + if _storage._data != rhs_storage._data {return false} + if _storage._multiWordGroupField != rhs_storage._multiWordGroupField {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} + if _storage._fieldname1 != rhs_storage._fieldname1 {return false} + if _storage._fieldName2 != rhs_storage._fieldName2 {return false} + if _storage._fieldName3 != rhs_storage._fieldName3 {return false} + if _storage._field_Name4_ != rhs_storage._field_Name4_ {return false} + if _storage._field0Name5 != rhs_storage._field0Name5 {return false} + if _storage._field0Name6 != rhs_storage._field0Name6 {return false} + if _storage._fieldName7 != rhs_storage._fieldName7 {return false} + if _storage._fieldName8 != rhs_storage._fieldName8 {return false} + if _storage._fieldName9 != rhs_storage._fieldName9 {return false} + if _storage._fieldName10 != rhs_storage._fieldName10 {return false} + if _storage._fieldName11 != rhs_storage._fieldName11 {return false} + if _storage._fieldName12 != rhs_storage._fieldName12 {return false} + if _storage.__FieldName13 != rhs_storage.__FieldName13 {return false} + if _storage.__FieldName14 != rhs_storage.__FieldName14 {return false} + if _storage._field_Name15 != rhs_storage._field_Name15 {return false} + if _storage._field_Name16 != rhs_storage._field_Name16 {return false} + if _storage._fieldName17__ != rhs_storage._fieldName17__ {return false} + if _storage._fieldName18__ != rhs_storage._fieldName18__ {return false} + if _storage._messageSetCorrect != rhs_storage._messageSetCorrect {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _corecursive: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._corecursive, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}J\u{3}group_int32\0\u{3}group_uint32\0") + + 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 202: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 203: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 202) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 203) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.DataMessage, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.DataMessage) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MultiWordGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".MultiWordGroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}M\u{3}group_int32\0\u{3}group_uint32\0") + + 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 205: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 206: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 205) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 206) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MultiWordGroupField, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MultiWordGroupField) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect.self) + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrect) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrectExtension1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{19}str\0") + + 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 25: try { try decoder.decodeSingularStringField(value: &self._str) }() + 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 + try { if let v = self._str { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension1) -> Bool { + if lhs._str != rhs._str {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".MessageSetCorrectExtension2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{9}i\0") + + 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 9: try { try decoder.decodeSingularInt32Field(value: &self._i) }() + 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 + try { if let v = self._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.MessageSetCorrectExtension2) -> Bool { + if lhs._i != rhs._i {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.protoMessageName + ".ExtensionWithOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .a(v) + } + }() + case 2: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.oneofField != nil {try decoder.handleConflictingOneOf()} + self.oneofField = .b(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.oneofField { + case .a?: try { + guard case .a(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + }() + case .b?: try { + guard case .b(let v)? = self.oneofField else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof, rhs: ProtobufTestMessages_Editions_Proto2_TestAllTypesProto2.ExtensionWithOneof) -> Bool { + if lhs.oneofField != rhs.oneofField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessageProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") + + 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._c) }() + 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 + try { if let v = self._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2, rhs: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2) -> Bool { + if lhs._c != rhs._c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_GroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}z\u{1}group_int32\0\u{3}group_uint32\0") + + 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 122: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 123: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 122) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 123) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_GroupField, rhs: ProtobufTestMessages_Editions_Proto2_GroupField) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".UnknownToTestAllTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}i\u{f}optional_int32\0\u{3}optional_string\0\u{3}nested_message\0\u{7}OptionalGroup\0\u{4}\u{2}optional_bool\0\u{4}\u{5}repeated_int32\0") + + 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 1001: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32) }() + case 1002: try { try decoder.decodeSingularStringField(value: &self._optionalString) }() + case 1003: try { try decoder.decodeSingularMessageField(value: &self._nestedMessage) }() + case 1004: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() + case 1006: try { try decoder.decodeSingularBoolField(value: &self._optionalBool) }() + case 1011: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() + 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 + try { if let v = self._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1001) + } }() + try { if let v = self._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 1002) + } }() + try { if let v = self._nestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1003) + } }() + try { if let v = self._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 1004) + } }() + try { if let v = self._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1006) + } }() + if !self.repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 1011) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes, rhs: ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes) -> Bool { + if lhs._optionalInt32 != rhs._optionalInt32 {return false} + if lhs._optionalString != rhs._optionalString {return false} + if lhs._nestedMessage != rhs._nestedMessage {return false} + if lhs._optionalGroup != rhs._optionalGroup {return false} + if lhs._optionalBool != rhs._optionalBool {return false} + if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") + + 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._a) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.OptionalGroup, rhs: ProtobufTestMessages_Editions_Proto2_UnknownToTestAllTypes.OptionalGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_NullHypothesisProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NullHypothesisProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_NullHypothesisProto2, rhs: ProtobufTestMessages_Editions_Proto2_NullHypothesisProto2) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_EnumOnlyProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumOnlyProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_EnumOnlyProto2, rhs: ProtobufTestMessages_Editions_Proto2_EnumOnlyProto2) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_EnumOnlyProto2.BoolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0kFalse\0\u{1}kTrue\0") +} + +extension ProtobufTestMessages_Editions_Proto2_OneStringProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OneStringProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") + + 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._data) }() + 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 + try { if let v = self._data { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_OneStringProto2, rhs: ProtobufTestMessages_Editions_Proto2_OneStringProto2) -> Bool { + if lhs._data != rhs._data {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_ProtoWithKeywords: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ProtoWithKeywords" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}inline\0\u{1}concept\0\u{1}requires\0") + + 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._inline) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._concept) }() + case 3: try { try decoder.decodeRepeatedStringField(value: &self.requires) }() + 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 + try { if let v = self._inline { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._concept { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + if !self.requires.isEmpty { + try visitor.visitRepeatedStringField(value: self.requires, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_ProtoWithKeywords, rhs: ProtobufTestMessages_Editions_Proto2_ProtoWithKeywords) -> Bool { + if lhs._inline != rhs._inline {return false} + if lhs._concept != rhs._concept {return false} + if lhs.requires != rhs.requires {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllRequiredTypesProto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_int32\0\u{3}required_int64\0\u{3}required_uint32\0\u{3}required_uint64\0\u{3}required_sint32\0\u{3}required_sint64\0\u{3}required_fixed32\0\u{3}required_fixed64\0\u{3}required_sfixed32\0\u{3}required_sfixed64\0\u{3}required_float\0\u{3}required_double\0\u{3}required_bool\0\u{3}required_string\0\u{3}required_bytes\0\u{4}\u{3}required_nested_message\0\u{3}required_foreign_message\0\u{4}\u{2}required_nested_enum\0\u{3}required_foreign_enum\0\u{4}\u{2}required_string_piece\0\u{3}required_cord\0\u{4}\u{2}recursive_message\0\u{3}optional_recursive_message\0\u{8}m\u{2}Data\0\u{4}(default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{c}h\u{f}hL\u{2}") + + fileprivate class _StorageClass { + var _requiredInt32: Int32? = nil + var _requiredInt64: Int64? = nil + var _requiredUint32: UInt32? = nil + var _requiredUint64: UInt64? = nil + var _requiredSint32: Int32? = nil + var _requiredSint64: Int64? = nil + var _requiredFixed32: UInt32? = nil + var _requiredFixed64: UInt64? = nil + var _requiredSfixed32: Int32? = nil + var _requiredSfixed64: Int64? = nil + var _requiredFloat: Float? = nil + var _requiredDouble: Double? = nil + var _requiredBool: Bool? = nil + var _requiredString: String? = nil + var _requiredBytes: Data? = nil + var _requiredNestedMessage: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedMessage? = nil + var _requiredForeignMessage: ProtobufTestMessages_Editions_Proto2_ForeignMessageProto2? = nil + var _requiredNestedEnum: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedEnum? = nil + var _requiredForeignEnum: ProtobufTestMessages_Editions_Proto2_ForeignEnumProto2? = nil + var _requiredStringPiece: String? = nil + var _requiredCord: String? = nil + var _recursiveMessage: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2? = nil + var _optionalRecursiveMessage: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2? = nil + var _data: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.DataMessage? = nil + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _requiredInt32 = source._requiredInt32 + _requiredInt64 = source._requiredInt64 + _requiredUint32 = source._requiredUint32 + _requiredUint64 = source._requiredUint64 + _requiredSint32 = source._requiredSint32 + _requiredSint64 = source._requiredSint64 + _requiredFixed32 = source._requiredFixed32 + _requiredFixed64 = source._requiredFixed64 + _requiredSfixed32 = source._requiredSfixed32 + _requiredSfixed64 = source._requiredSfixed64 + _requiredFloat = source._requiredFloat + _requiredDouble = source._requiredDouble + _requiredBool = source._requiredBool + _requiredString = source._requiredString + _requiredBytes = source._requiredBytes + _requiredNestedMessage = source._requiredNestedMessage + _requiredForeignMessage = source._requiredForeignMessage + _requiredNestedEnum = source._requiredNestedEnum + _requiredForeignEnum = source._requiredForeignEnum + _requiredStringPiece = source._requiredStringPiece + _requiredCord = source._requiredCord + _recursiveMessage = source._recursiveMessage + _optionalRecursiveMessage = source._optionalRecursiveMessage + _data = source._data + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._requiredInt32 == nil {return false} + if _storage._requiredInt64 == nil {return false} + if _storage._requiredUint32 == nil {return false} + if _storage._requiredUint64 == nil {return false} + if _storage._requiredSint32 == nil {return false} + if _storage._requiredSint64 == nil {return false} + if _storage._requiredFixed32 == nil {return false} + if _storage._requiredFixed64 == nil {return false} + if _storage._requiredSfixed32 == nil {return false} + if _storage._requiredSfixed64 == nil {return false} + if _storage._requiredFloat == nil {return false} + if _storage._requiredDouble == nil {return false} + if _storage._requiredBool == nil {return false} + if _storage._requiredString == nil {return false} + if _storage._requiredBytes == nil {return false} + if _storage._requiredNestedMessage == nil {return false} + if _storage._requiredForeignMessage == nil {return false} + if _storage._requiredNestedEnum == nil {return false} + if _storage._requiredForeignEnum == nil {return false} + if _storage._requiredStringPiece == nil {return false} + if _storage._requiredCord == nil {return false} + if _storage._recursiveMessage == nil {return false} + if _storage._data == nil {return false} + if _storage._defaultInt32 == nil {return false} + if _storage._defaultInt64 == nil {return false} + if _storage._defaultUint32 == nil {return false} + if _storage._defaultUint64 == nil {return false} + if _storage._defaultSint32 == nil {return false} + if _storage._defaultSint64 == nil {return false} + if _storage._defaultFixed32 == nil {return false} + if _storage._defaultFixed64 == nil {return false} + if _storage._defaultSfixed32 == nil {return false} + if _storage._defaultSfixed64 == nil {return false} + if _storage._defaultFloat == nil {return false} + if _storage._defaultDouble == nil {return false} + if _storage._defaultBool == nil {return false} + if _storage._defaultString == nil {return false} + if _storage._defaultBytes == nil {return false} + if let v = _storage._requiredNestedMessage, !v.isInitialized {return false} + if let v = _storage._recursiveMessage, !v.isInitialized {return false} + if let v = _storage._optionalRecursiveMessage, !v.isInitialized {return false} + if let v = _storage._data, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._requiredInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._requiredInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._requiredUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._requiredUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._requiredSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._requiredSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._requiredFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._requiredFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._requiredSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._requiredSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._requiredFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._requiredDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._requiredBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._requiredString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._requiredBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._requiredNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._requiredForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._requiredNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._requiredForeignEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._requiredStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._requiredCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 28: try { try decoder.decodeSingularMessageField(value: &_storage._optionalRecursiveMessage) }() + case 201: try { try decoder.decodeSingularGroupField(value: &_storage._data) }() + case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 242: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 243: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 244: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 245: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 246: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 247: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 248: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 249: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 250: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 251: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 252: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 253: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 254: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 255: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() + case 120..<201: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._requiredInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._requiredInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._requiredUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._requiredUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._requiredSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._requiredSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._requiredFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._requiredFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._requiredSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._requiredSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._requiredFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._requiredDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._requiredBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._requiredString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._requiredBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._requiredNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._requiredForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._requiredNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._requiredForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._requiredStringPiece { + try visitor.visitSingularStringField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._requiredCord { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + try { if let v = _storage._optionalRecursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 28) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 120, end: 201) + try { if let v = _storage._data { + try visitor.visitSingularGroupField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 241) + } }() + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 242) + } }() + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 243) + } }() + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 244) + } }() + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 245) + } }() + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 246) + } }() + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 247) + } }() + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 248) + } }() + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 249) + } }() + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 250) + } }() + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 251) + } }() + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 252) + } }() + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 253) + } }() + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 254) + } }() + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 255) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2, rhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2) -> 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._requiredInt32 != rhs_storage._requiredInt32 {return false} + if _storage._requiredInt64 != rhs_storage._requiredInt64 {return false} + if _storage._requiredUint32 != rhs_storage._requiredUint32 {return false} + if _storage._requiredUint64 != rhs_storage._requiredUint64 {return false} + if _storage._requiredSint32 != rhs_storage._requiredSint32 {return false} + if _storage._requiredSint64 != rhs_storage._requiredSint64 {return false} + if _storage._requiredFixed32 != rhs_storage._requiredFixed32 {return false} + if _storage._requiredFixed64 != rhs_storage._requiredFixed64 {return false} + if _storage._requiredSfixed32 != rhs_storage._requiredSfixed32 {return false} + if _storage._requiredSfixed64 != rhs_storage._requiredSfixed64 {return false} + if _storage._requiredFloat != rhs_storage._requiredFloat {return false} + if _storage._requiredDouble != rhs_storage._requiredDouble {return false} + if _storage._requiredBool != rhs_storage._requiredBool {return false} + if _storage._requiredString != rhs_storage._requiredString {return false} + if _storage._requiredBytes != rhs_storage._requiredBytes {return false} + if _storage._requiredNestedMessage != rhs_storage._requiredNestedMessage {return false} + if _storage._requiredForeignMessage != rhs_storage._requiredForeignMessage {return false} + if _storage._requiredNestedEnum != rhs_storage._requiredNestedEnum {return false} + if _storage._requiredForeignEnum != rhs_storage._requiredForeignEnum {return false} + if _storage._requiredStringPiece != rhs_storage._requiredStringPiece {return false} + if _storage._requiredCord != rhs_storage._requiredCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._optionalRecursiveMessage != rhs_storage._optionalRecursiveMessage {return false} + if _storage._data != rhs_storage._data {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0\u{3}optional_corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _corecursive: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2? = nil + var _optionalCorecursive: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + _optionalCorecursive = source._optionalCorecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._a == nil {return false} + if _storage._corecursive == nil {return false} + if let v = _storage._corecursive, !v.isInitialized {return false} + if let v = _storage._optionalCorecursive, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._optionalCorecursive) }() + default: break + } + } + } + } + + func traverse(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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._optionalCorecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedMessage, rhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + if _storage._optionalCorecursive != rhs_storage._optionalCorecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}J\u{3}group_int32\0\u{3}group_uint32\0") + + public var isInitialized: Bool { + if self._groupInt32 == nil {return false} + if self._groupUint32 == nil {return false} + return true + } + + 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 202: try { try decoder.decodeSingularInt32Field(value: &self._groupInt32) }() + case 203: try { try decoder.decodeSingularUInt32Field(value: &self._groupUint32) }() + 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 + try { if let v = self._groupInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 202) + } }() + try { if let v = self._groupUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 203) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.DataMessage, rhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.DataMessage) -> Bool { + if lhs._groupInt32 != rhs._groupInt32 {return false} + if lhs._groupUint32 != rhs._groupUint32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".MessageSetCorrect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect.self) + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect, rhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrect) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".MessageSetCorrectExtension1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{19}str\0") + + public var isInitialized: Bool { + if self._str == nil {return false} + return true + } + + 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 25: try { try decoder.decodeSingularStringField(value: &self._str) }() + 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 + try { if let v = self._str { + try visitor.visitSingularStringField(value: v, fieldNumber: 25) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1, rhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension1) -> Bool { + if lhs._str != rhs._str {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.protoMessageName + ".MessageSetCorrectExtension2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{9}i\0") + + public var isInitialized: Bool { + if self._i == nil {return false} + return true + } + + 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 9: try { try decoder.decodeSingularInt32Field(value: &self._i) }() + 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 + try { if let v = self._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2, rhs: ProtobufTestMessages_Editions_Proto2_TestAllRequiredTypesProto2.MessageSetCorrectExtension2) -> Bool { + if lhs._i != rhs._i {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestLargeOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestLargeOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a1\0\u{1}a2\0\u{1}a3\0\u{1}a4\0\u{1}a5\0") + + 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: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a1(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a1(v) + } + }() + case 2: try { + var v: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a2(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a2(v) + } + }() + case 3: try { + var v: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a3(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a3(v) + } + }() + case 4: try { + var v: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a4(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a4(v) + } + }() + case 5: try { + var v: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5? + var hadOneofValue = false + if let current = self.largeOneof { + hadOneofValue = true + if case .a5(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.largeOneof = .a5(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.largeOneof { + case .a1?: try { + guard case .a1(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + }() + case .a2?: try { + guard case .a2(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + }() + case .a3?: try { + guard case .a3(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + }() + case .a4?: try { + guard case .a4(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + }() + case .a5?: try { + guard case .a5(let v)? = self.largeOneof else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + }() + case nil: break + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof, rhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof) -> Bool { + if lhs.largeOneof != rhs.largeOneof {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestLargeOneof.protoMessageName + ".A1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1, rhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A1) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestLargeOneof.protoMessageName + ".A2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2, rhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A2) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestLargeOneof.protoMessageName + ".A3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3, rhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A3) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestLargeOneof.protoMessageName + ".A4" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4, rhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A4) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto2_TestLargeOneof.protoMessageName + ".A5" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5, rhs: ProtobufTestMessages_Editions_Proto2_TestLargeOneof.A5) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Sources/Conformance/test_messages_proto3.pb.swift b/Sources/Conformance/test_messages_proto3.pb.swift index 4bd18c700..6e42eff19 100644 --- a/Sources/Conformance/test_messages_proto3.pb.swift +++ b/Sources/Conformance/test_messages_proto3.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/test_messages_proto3.proto @@ -9,33 +10,10 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd // // Test schema for proto3 messages. This test schema is used by: // @@ -56,7 +34,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum ProtobufTestMessages_Proto3_ForeignEnum: SwiftProtobuf.Enum { +enum ProtobufTestMessages_Proto3_ForeignEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foreignFoo // = 0 case foreignBar // = 1 @@ -85,20 +63,14 @@ enum ProtobufTestMessages_Proto3_ForeignEnum: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension ProtobufTestMessages_Proto3_ForeignEnum: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufTestMessages_Proto3_ForeignEnum] = [ + static let allCases: [ProtobufTestMessages_Proto3_ForeignEnum] = [ .foreignFoo, .foreignBar, .foreignBaz, ] -} -#endif // swift(>=4.2) +} /// This proto includes every type of field in both singular and repeated /// forms. @@ -107,480 +79,481 @@ extension ProtobufTestMessages_Proto3_ForeignEnum: CaseIterable { /// submessages of this message. So for example, a fuzz test of TestAllTypes /// could trigger bugs that occur in any message type in this file. We verify /// this stays true in a unit test. -struct ProtobufTestMessages_Proto3_TestAllTypesProto3 { +struct ProtobufTestMessages_Proto3_TestAllTypesProto3: @unchecked Sendable { // 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. /// Singular + /// test [kotlin] comment var optionalInt32: Int32 { - get {return _storage._optionalInt32} + get {_storage._optionalInt32} set {_uniqueStorage()._optionalInt32 = newValue} } var optionalInt64: Int64 { - get {return _storage._optionalInt64} + get {_storage._optionalInt64} set {_uniqueStorage()._optionalInt64 = newValue} } var optionalUint32: UInt32 { - get {return _storage._optionalUint32} + get {_storage._optionalUint32} set {_uniqueStorage()._optionalUint32 = newValue} } var optionalUint64: UInt64 { - get {return _storage._optionalUint64} + get {_storage._optionalUint64} set {_uniqueStorage()._optionalUint64 = newValue} } var optionalSint32: Int32 { - get {return _storage._optionalSint32} + get {_storage._optionalSint32} set {_uniqueStorage()._optionalSint32 = newValue} } var optionalSint64: Int64 { - get {return _storage._optionalSint64} + get {_storage._optionalSint64} set {_uniqueStorage()._optionalSint64 = newValue} } var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32} + get {_storage._optionalFixed32} set {_uniqueStorage()._optionalFixed32 = newValue} } var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64} + get {_storage._optionalFixed64} set {_uniqueStorage()._optionalFixed64 = newValue} } var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32} + get {_storage._optionalSfixed32} set {_uniqueStorage()._optionalSfixed32 = newValue} } var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64} + get {_storage._optionalSfixed64} set {_uniqueStorage()._optionalSfixed64 = newValue} } var optionalFloat: Float { - get {return _storage._optionalFloat} + get {_storage._optionalFloat} set {_uniqueStorage()._optionalFloat = newValue} } var optionalDouble: Double { - get {return _storage._optionalDouble} + get {_storage._optionalDouble} set {_uniqueStorage()._optionalDouble = newValue} } var optionalBool: Bool { - get {return _storage._optionalBool} + get {_storage._optionalBool} set {_uniqueStorage()._optionalBool = newValue} } var optionalString: String { - get {return _storage._optionalString} + get {_storage._optionalString} set {_uniqueStorage()._optionalString = newValue} } var optionalBytes: Data { - get {return _storage._optionalBytes} + get {_storage._optionalBytes} set {_uniqueStorage()._optionalBytes = newValue} } var optionalNestedMessage: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage { - get {return _storage._optionalNestedMessage ?? ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage()} + get {_storage._optionalNestedMessage ?? ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage()} set {_uniqueStorage()._optionalNestedMessage = newValue} } /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} var optionalForeignMessage: ProtobufTestMessages_Proto3_ForeignMessage { - get {return _storage._optionalForeignMessage ?? ProtobufTestMessages_Proto3_ForeignMessage()} + get {_storage._optionalForeignMessage ?? ProtobufTestMessages_Proto3_ForeignMessage()} set {_uniqueStorage()._optionalForeignMessage = newValue} } /// Returns true if `optionalForeignMessage` has been explicitly set. - var hasOptionalForeignMessage: Bool {return _storage._optionalForeignMessage != nil} + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} var optionalNestedEnum: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum { - get {return _storage._optionalNestedEnum} + get {_storage._optionalNestedEnum} set {_uniqueStorage()._optionalNestedEnum = newValue} } var optionalForeignEnum: ProtobufTestMessages_Proto3_ForeignEnum { - get {return _storage._optionalForeignEnum} + get {_storage._optionalForeignEnum} set {_uniqueStorage()._optionalForeignEnum = newValue} } var optionalAliasedEnum: ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum { - get {return _storage._optionalAliasedEnum} + get {_storage._optionalAliasedEnum} set {_uniqueStorage()._optionalAliasedEnum = newValue} } var optionalStringPiece: String { - get {return _storage._optionalStringPiece} + get {_storage._optionalStringPiece} set {_uniqueStorage()._optionalStringPiece = newValue} } var optionalCord: String { - get {return _storage._optionalCord} + get {_storage._optionalCord} set {_uniqueStorage()._optionalCord = newValue} } var recursiveMessage: ProtobufTestMessages_Proto3_TestAllTypesProto3 { - get {return _storage._recursiveMessage ?? ProtobufTestMessages_Proto3_TestAllTypesProto3()} + get {_storage._recursiveMessage ?? ProtobufTestMessages_Proto3_TestAllTypesProto3()} set {_uniqueStorage()._recursiveMessage = newValue} } /// Returns true if `recursiveMessage` has been explicitly set. - var hasRecursiveMessage: Bool {return _storage._recursiveMessage != nil} + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} /// Repeated var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } var repeatedNestedMessage: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage] { - get {return _storage._repeatedNestedMessage} + get {_storage._repeatedNestedMessage} set {_uniqueStorage()._repeatedNestedMessage = newValue} } var repeatedForeignMessage: [ProtobufTestMessages_Proto3_ForeignMessage] { - get {return _storage._repeatedForeignMessage} + get {_storage._repeatedForeignMessage} set {_uniqueStorage()._repeatedForeignMessage = newValue} } var repeatedNestedEnum: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] { - get {return _storage._repeatedNestedEnum} + get {_storage._repeatedNestedEnum} set {_uniqueStorage()._repeatedNestedEnum = newValue} } var repeatedForeignEnum: [ProtobufTestMessages_Proto3_ForeignEnum] { - get {return _storage._repeatedForeignEnum} + get {_storage._repeatedForeignEnum} set {_uniqueStorage()._repeatedForeignEnum = newValue} } var repeatedStringPiece: [String] { - get {return _storage._repeatedStringPiece} + get {_storage._repeatedStringPiece} set {_uniqueStorage()._repeatedStringPiece = newValue} } var repeatedCord: [String] { - get {return _storage._repeatedCord} + get {_storage._repeatedCord} set {_uniqueStorage()._repeatedCord = newValue} } /// Packed var packedInt32: [Int32] { - get {return _storage._packedInt32} + get {_storage._packedInt32} set {_uniqueStorage()._packedInt32 = newValue} } var packedInt64: [Int64] { - get {return _storage._packedInt64} + get {_storage._packedInt64} set {_uniqueStorage()._packedInt64 = newValue} } var packedUint32: [UInt32] { - get {return _storage._packedUint32} + get {_storage._packedUint32} set {_uniqueStorage()._packedUint32 = newValue} } var packedUint64: [UInt64] { - get {return _storage._packedUint64} + get {_storage._packedUint64} set {_uniqueStorage()._packedUint64 = newValue} } var packedSint32: [Int32] { - get {return _storage._packedSint32} + get {_storage._packedSint32} set {_uniqueStorage()._packedSint32 = newValue} } var packedSint64: [Int64] { - get {return _storage._packedSint64} + get {_storage._packedSint64} set {_uniqueStorage()._packedSint64 = newValue} } var packedFixed32: [UInt32] { - get {return _storage._packedFixed32} + get {_storage._packedFixed32} set {_uniqueStorage()._packedFixed32 = newValue} } var packedFixed64: [UInt64] { - get {return _storage._packedFixed64} + get {_storage._packedFixed64} set {_uniqueStorage()._packedFixed64 = newValue} } var packedSfixed32: [Int32] { - get {return _storage._packedSfixed32} + get {_storage._packedSfixed32} set {_uniqueStorage()._packedSfixed32 = newValue} } var packedSfixed64: [Int64] { - get {return _storage._packedSfixed64} + get {_storage._packedSfixed64} set {_uniqueStorage()._packedSfixed64 = newValue} } var packedFloat: [Float] { - get {return _storage._packedFloat} + get {_storage._packedFloat} set {_uniqueStorage()._packedFloat = newValue} } var packedDouble: [Double] { - get {return _storage._packedDouble} + get {_storage._packedDouble} set {_uniqueStorage()._packedDouble = newValue} } var packedBool: [Bool] { - get {return _storage._packedBool} + get {_storage._packedBool} set {_uniqueStorage()._packedBool = newValue} } var packedNestedEnum: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] { - get {return _storage._packedNestedEnum} + get {_storage._packedNestedEnum} set {_uniqueStorage()._packedNestedEnum = newValue} } /// Unpacked var unpackedInt32: [Int32] { - get {return _storage._unpackedInt32} + get {_storage._unpackedInt32} set {_uniqueStorage()._unpackedInt32 = newValue} } var unpackedInt64: [Int64] { - get {return _storage._unpackedInt64} + get {_storage._unpackedInt64} set {_uniqueStorage()._unpackedInt64 = newValue} } var unpackedUint32: [UInt32] { - get {return _storage._unpackedUint32} + get {_storage._unpackedUint32} set {_uniqueStorage()._unpackedUint32 = newValue} } var unpackedUint64: [UInt64] { - get {return _storage._unpackedUint64} + get {_storage._unpackedUint64} set {_uniqueStorage()._unpackedUint64 = newValue} } var unpackedSint32: [Int32] { - get {return _storage._unpackedSint32} + get {_storage._unpackedSint32} set {_uniqueStorage()._unpackedSint32 = newValue} } var unpackedSint64: [Int64] { - get {return _storage._unpackedSint64} + get {_storage._unpackedSint64} set {_uniqueStorage()._unpackedSint64 = newValue} } var unpackedFixed32: [UInt32] { - get {return _storage._unpackedFixed32} + get {_storage._unpackedFixed32} set {_uniqueStorage()._unpackedFixed32 = newValue} } var unpackedFixed64: [UInt64] { - get {return _storage._unpackedFixed64} + get {_storage._unpackedFixed64} set {_uniqueStorage()._unpackedFixed64 = newValue} } var unpackedSfixed32: [Int32] { - get {return _storage._unpackedSfixed32} + get {_storage._unpackedSfixed32} set {_uniqueStorage()._unpackedSfixed32 = newValue} } var unpackedSfixed64: [Int64] { - get {return _storage._unpackedSfixed64} + get {_storage._unpackedSfixed64} set {_uniqueStorage()._unpackedSfixed64 = newValue} } var unpackedFloat: [Float] { - get {return _storage._unpackedFloat} + get {_storage._unpackedFloat} set {_uniqueStorage()._unpackedFloat = newValue} } var unpackedDouble: [Double] { - get {return _storage._unpackedDouble} + get {_storage._unpackedDouble} set {_uniqueStorage()._unpackedDouble = newValue} } var unpackedBool: [Bool] { - get {return _storage._unpackedBool} + get {_storage._unpackedBool} set {_uniqueStorage()._unpackedBool = newValue} } var unpackedNestedEnum: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] { - get {return _storage._unpackedNestedEnum} + get {_storage._unpackedNestedEnum} set {_uniqueStorage()._unpackedNestedEnum = newValue} } /// Map var mapInt32Int32: Dictionary { - get {return _storage._mapInt32Int32} + get {_storage._mapInt32Int32} set {_uniqueStorage()._mapInt32Int32 = newValue} } var mapInt64Int64: Dictionary { - get {return _storage._mapInt64Int64} + get {_storage._mapInt64Int64} set {_uniqueStorage()._mapInt64Int64 = newValue} } var mapUint32Uint32: Dictionary { - get {return _storage._mapUint32Uint32} + get {_storage._mapUint32Uint32} set {_uniqueStorage()._mapUint32Uint32 = newValue} } var mapUint64Uint64: Dictionary { - get {return _storage._mapUint64Uint64} + get {_storage._mapUint64Uint64} set {_uniqueStorage()._mapUint64Uint64 = newValue} } var mapSint32Sint32: Dictionary { - get {return _storage._mapSint32Sint32} + get {_storage._mapSint32Sint32} set {_uniqueStorage()._mapSint32Sint32 = newValue} } var mapSint64Sint64: Dictionary { - get {return _storage._mapSint64Sint64} + get {_storage._mapSint64Sint64} set {_uniqueStorage()._mapSint64Sint64 = newValue} } var mapFixed32Fixed32: Dictionary { - get {return _storage._mapFixed32Fixed32} + get {_storage._mapFixed32Fixed32} set {_uniqueStorage()._mapFixed32Fixed32 = newValue} } var mapFixed64Fixed64: Dictionary { - get {return _storage._mapFixed64Fixed64} + get {_storage._mapFixed64Fixed64} set {_uniqueStorage()._mapFixed64Fixed64 = newValue} } var mapSfixed32Sfixed32: Dictionary { - get {return _storage._mapSfixed32Sfixed32} + get {_storage._mapSfixed32Sfixed32} set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} } var mapSfixed64Sfixed64: Dictionary { - get {return _storage._mapSfixed64Sfixed64} + get {_storage._mapSfixed64Sfixed64} set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} } var mapInt32Float: Dictionary { - get {return _storage._mapInt32Float} + get {_storage._mapInt32Float} set {_uniqueStorage()._mapInt32Float = newValue} } var mapInt32Double: Dictionary { - get {return _storage._mapInt32Double} + get {_storage._mapInt32Double} set {_uniqueStorage()._mapInt32Double = newValue} } var mapBoolBool: Dictionary { - get {return _storage._mapBoolBool} + get {_storage._mapBoolBool} set {_uniqueStorage()._mapBoolBool = newValue} } var mapStringString: Dictionary { - get {return _storage._mapStringString} + get {_storage._mapStringString} set {_uniqueStorage()._mapStringString = newValue} } var mapStringBytes: Dictionary { - get {return _storage._mapStringBytes} + get {_storage._mapStringBytes} set {_uniqueStorage()._mapStringBytes = newValue} } var mapStringNestedMessage: Dictionary { - get {return _storage._mapStringNestedMessage} + get {_storage._mapStringNestedMessage} set {_uniqueStorage()._mapStringNestedMessage = newValue} } var mapStringForeignMessage: Dictionary { - get {return _storage._mapStringForeignMessage} + get {_storage._mapStringForeignMessage} set {_uniqueStorage()._mapStringForeignMessage = newValue} } var mapStringNestedEnum: Dictionary { - get {return _storage._mapStringNestedEnum} + get {_storage._mapStringNestedEnum} set {_uniqueStorage()._mapStringNestedEnum = newValue} } var mapStringForeignEnum: Dictionary { - get {return _storage._mapStringForeignEnum} + get {_storage._mapStringForeignEnum} set {_uniqueStorage()._mapStringForeignEnum = newValue} } @@ -671,320 +644,320 @@ struct ProtobufTestMessages_Proto3_TestAllTypesProto3 { /// Well-known types var optionalBoolWrapper: SwiftProtobuf.Google_Protobuf_BoolValue { - get {return _storage._optionalBoolWrapper ?? SwiftProtobuf.Google_Protobuf_BoolValue()} + get {_storage._optionalBoolWrapper ?? SwiftProtobuf.Google_Protobuf_BoolValue()} set {_uniqueStorage()._optionalBoolWrapper = newValue} } /// Returns true if `optionalBoolWrapper` has been explicitly set. - var hasOptionalBoolWrapper: Bool {return _storage._optionalBoolWrapper != nil} + var hasOptionalBoolWrapper: Bool {_storage._optionalBoolWrapper != nil} /// Clears the value of `optionalBoolWrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalBoolWrapper() {_uniqueStorage()._optionalBoolWrapper = nil} var optionalInt32Wrapper: SwiftProtobuf.Google_Protobuf_Int32Value { - get {return _storage._optionalInt32Wrapper ?? SwiftProtobuf.Google_Protobuf_Int32Value()} + get {_storage._optionalInt32Wrapper ?? SwiftProtobuf.Google_Protobuf_Int32Value()} set {_uniqueStorage()._optionalInt32Wrapper = newValue} } /// Returns true if `optionalInt32Wrapper` has been explicitly set. - var hasOptionalInt32Wrapper: Bool {return _storage._optionalInt32Wrapper != nil} + var hasOptionalInt32Wrapper: Bool {_storage._optionalInt32Wrapper != nil} /// Clears the value of `optionalInt32Wrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalInt32Wrapper() {_uniqueStorage()._optionalInt32Wrapper = nil} var optionalInt64Wrapper: SwiftProtobuf.Google_Protobuf_Int64Value { - get {return _storage._optionalInt64Wrapper ?? SwiftProtobuf.Google_Protobuf_Int64Value()} + get {_storage._optionalInt64Wrapper ?? SwiftProtobuf.Google_Protobuf_Int64Value()} set {_uniqueStorage()._optionalInt64Wrapper = newValue} } /// Returns true if `optionalInt64Wrapper` has been explicitly set. - var hasOptionalInt64Wrapper: Bool {return _storage._optionalInt64Wrapper != nil} + var hasOptionalInt64Wrapper: Bool {_storage._optionalInt64Wrapper != nil} /// Clears the value of `optionalInt64Wrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalInt64Wrapper() {_uniqueStorage()._optionalInt64Wrapper = nil} var optionalUint32Wrapper: SwiftProtobuf.Google_Protobuf_UInt32Value { - get {return _storage._optionalUint32Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} + get {_storage._optionalUint32Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} set {_uniqueStorage()._optionalUint32Wrapper = newValue} } /// Returns true if `optionalUint32Wrapper` has been explicitly set. - var hasOptionalUint32Wrapper: Bool {return _storage._optionalUint32Wrapper != nil} + var hasOptionalUint32Wrapper: Bool {_storage._optionalUint32Wrapper != nil} /// Clears the value of `optionalUint32Wrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalUint32Wrapper() {_uniqueStorage()._optionalUint32Wrapper = nil} var optionalUint64Wrapper: SwiftProtobuf.Google_Protobuf_UInt64Value { - get {return _storage._optionalUint64Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} + get {_storage._optionalUint64Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} set {_uniqueStorage()._optionalUint64Wrapper = newValue} } /// Returns true if `optionalUint64Wrapper` has been explicitly set. - var hasOptionalUint64Wrapper: Bool {return _storage._optionalUint64Wrapper != nil} + var hasOptionalUint64Wrapper: Bool {_storage._optionalUint64Wrapper != nil} /// Clears the value of `optionalUint64Wrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalUint64Wrapper() {_uniqueStorage()._optionalUint64Wrapper = nil} var optionalFloatWrapper: SwiftProtobuf.Google_Protobuf_FloatValue { - get {return _storage._optionalFloatWrapper ?? SwiftProtobuf.Google_Protobuf_FloatValue()} + get {_storage._optionalFloatWrapper ?? SwiftProtobuf.Google_Protobuf_FloatValue()} set {_uniqueStorage()._optionalFloatWrapper = newValue} } /// Returns true if `optionalFloatWrapper` has been explicitly set. - var hasOptionalFloatWrapper: Bool {return _storage._optionalFloatWrapper != nil} + var hasOptionalFloatWrapper: Bool {_storage._optionalFloatWrapper != nil} /// Clears the value of `optionalFloatWrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalFloatWrapper() {_uniqueStorage()._optionalFloatWrapper = nil} var optionalDoubleWrapper: SwiftProtobuf.Google_Protobuf_DoubleValue { - get {return _storage._optionalDoubleWrapper ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} + get {_storage._optionalDoubleWrapper ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} set {_uniqueStorage()._optionalDoubleWrapper = newValue} } /// Returns true if `optionalDoubleWrapper` has been explicitly set. - var hasOptionalDoubleWrapper: Bool {return _storage._optionalDoubleWrapper != nil} + var hasOptionalDoubleWrapper: Bool {_storage._optionalDoubleWrapper != nil} /// Clears the value of `optionalDoubleWrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalDoubleWrapper() {_uniqueStorage()._optionalDoubleWrapper = nil} var optionalStringWrapper: SwiftProtobuf.Google_Protobuf_StringValue { - get {return _storage._optionalStringWrapper ?? SwiftProtobuf.Google_Protobuf_StringValue()} + get {_storage._optionalStringWrapper ?? SwiftProtobuf.Google_Protobuf_StringValue()} set {_uniqueStorage()._optionalStringWrapper = newValue} } /// Returns true if `optionalStringWrapper` has been explicitly set. - var hasOptionalStringWrapper: Bool {return _storage._optionalStringWrapper != nil} + var hasOptionalStringWrapper: Bool {_storage._optionalStringWrapper != nil} /// Clears the value of `optionalStringWrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalStringWrapper() {_uniqueStorage()._optionalStringWrapper = nil} var optionalBytesWrapper: SwiftProtobuf.Google_Protobuf_BytesValue { - get {return _storage._optionalBytesWrapper ?? SwiftProtobuf.Google_Protobuf_BytesValue()} + get {_storage._optionalBytesWrapper ?? SwiftProtobuf.Google_Protobuf_BytesValue()} set {_uniqueStorage()._optionalBytesWrapper = newValue} } /// Returns true if `optionalBytesWrapper` has been explicitly set. - var hasOptionalBytesWrapper: Bool {return _storage._optionalBytesWrapper != nil} + var hasOptionalBytesWrapper: Bool {_storage._optionalBytesWrapper != nil} /// Clears the value of `optionalBytesWrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalBytesWrapper() {_uniqueStorage()._optionalBytesWrapper = nil} var repeatedBoolWrapper: [SwiftProtobuf.Google_Protobuf_BoolValue] { - get {return _storage._repeatedBoolWrapper} + get {_storage._repeatedBoolWrapper} set {_uniqueStorage()._repeatedBoolWrapper = newValue} } var repeatedInt32Wrapper: [SwiftProtobuf.Google_Protobuf_Int32Value] { - get {return _storage._repeatedInt32Wrapper} + get {_storage._repeatedInt32Wrapper} set {_uniqueStorage()._repeatedInt32Wrapper = newValue} } var repeatedInt64Wrapper: [SwiftProtobuf.Google_Protobuf_Int64Value] { - get {return _storage._repeatedInt64Wrapper} + get {_storage._repeatedInt64Wrapper} set {_uniqueStorage()._repeatedInt64Wrapper = newValue} } var repeatedUint32Wrapper: [SwiftProtobuf.Google_Protobuf_UInt32Value] { - get {return _storage._repeatedUint32Wrapper} + get {_storage._repeatedUint32Wrapper} set {_uniqueStorage()._repeatedUint32Wrapper = newValue} } var repeatedUint64Wrapper: [SwiftProtobuf.Google_Protobuf_UInt64Value] { - get {return _storage._repeatedUint64Wrapper} + get {_storage._repeatedUint64Wrapper} set {_uniqueStorage()._repeatedUint64Wrapper = newValue} } var repeatedFloatWrapper: [SwiftProtobuf.Google_Protobuf_FloatValue] { - get {return _storage._repeatedFloatWrapper} + get {_storage._repeatedFloatWrapper} set {_uniqueStorage()._repeatedFloatWrapper = newValue} } var repeatedDoubleWrapper: [SwiftProtobuf.Google_Protobuf_DoubleValue] { - get {return _storage._repeatedDoubleWrapper} + get {_storage._repeatedDoubleWrapper} set {_uniqueStorage()._repeatedDoubleWrapper = newValue} } var repeatedStringWrapper: [SwiftProtobuf.Google_Protobuf_StringValue] { - get {return _storage._repeatedStringWrapper} + get {_storage._repeatedStringWrapper} set {_uniqueStorage()._repeatedStringWrapper = newValue} } var repeatedBytesWrapper: [SwiftProtobuf.Google_Protobuf_BytesValue] { - get {return _storage._repeatedBytesWrapper} + get {_storage._repeatedBytesWrapper} set {_uniqueStorage()._repeatedBytesWrapper = newValue} } var optionalDuration: SwiftProtobuf.Google_Protobuf_Duration { - get {return _storage._optionalDuration ?? SwiftProtobuf.Google_Protobuf_Duration()} + get {_storage._optionalDuration ?? SwiftProtobuf.Google_Protobuf_Duration()} set {_uniqueStorage()._optionalDuration = newValue} } /// Returns true if `optionalDuration` has been explicitly set. - var hasOptionalDuration: Bool {return _storage._optionalDuration != nil} + var hasOptionalDuration: Bool {_storage._optionalDuration != nil} /// Clears the value of `optionalDuration`. Subsequent reads from it will return its default value. mutating func clearOptionalDuration() {_uniqueStorage()._optionalDuration = nil} var optionalTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp { - get {return _storage._optionalTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()} + get {_storage._optionalTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()} set {_uniqueStorage()._optionalTimestamp = newValue} } /// Returns true if `optionalTimestamp` has been explicitly set. - var hasOptionalTimestamp: Bool {return _storage._optionalTimestamp != nil} + var hasOptionalTimestamp: Bool {_storage._optionalTimestamp != nil} /// Clears the value of `optionalTimestamp`. Subsequent reads from it will return its default value. mutating func clearOptionalTimestamp() {_uniqueStorage()._optionalTimestamp = nil} var optionalFieldMask: SwiftProtobuf.Google_Protobuf_FieldMask { - get {return _storage._optionalFieldMask ?? SwiftProtobuf.Google_Protobuf_FieldMask()} + get {_storage._optionalFieldMask ?? SwiftProtobuf.Google_Protobuf_FieldMask()} set {_uniqueStorage()._optionalFieldMask = newValue} } /// Returns true if `optionalFieldMask` has been explicitly set. - var hasOptionalFieldMask: Bool {return _storage._optionalFieldMask != nil} + var hasOptionalFieldMask: Bool {_storage._optionalFieldMask != nil} /// Clears the value of `optionalFieldMask`. Subsequent reads from it will return its default value. mutating func clearOptionalFieldMask() {_uniqueStorage()._optionalFieldMask = nil} var optionalStruct: SwiftProtobuf.Google_Protobuf_Struct { - get {return _storage._optionalStruct ?? SwiftProtobuf.Google_Protobuf_Struct()} + get {_storage._optionalStruct ?? SwiftProtobuf.Google_Protobuf_Struct()} set {_uniqueStorage()._optionalStruct = newValue} } /// Returns true if `optionalStruct` has been explicitly set. - var hasOptionalStruct: Bool {return _storage._optionalStruct != nil} + var hasOptionalStruct: Bool {_storage._optionalStruct != nil} /// Clears the value of `optionalStruct`. Subsequent reads from it will return its default value. mutating func clearOptionalStruct() {_uniqueStorage()._optionalStruct = nil} var optionalAny: SwiftProtobuf.Google_Protobuf_Any { - get {return _storage._optionalAny ?? SwiftProtobuf.Google_Protobuf_Any()} + get {_storage._optionalAny ?? SwiftProtobuf.Google_Protobuf_Any()} set {_uniqueStorage()._optionalAny = newValue} } /// Returns true if `optionalAny` has been explicitly set. - var hasOptionalAny: Bool {return _storage._optionalAny != nil} + var hasOptionalAny: Bool {_storage._optionalAny != nil} /// Clears the value of `optionalAny`. Subsequent reads from it will return its default value. mutating func clearOptionalAny() {_uniqueStorage()._optionalAny = nil} var optionalValue: SwiftProtobuf.Google_Protobuf_Value { - get {return _storage._optionalValue ?? SwiftProtobuf.Google_Protobuf_Value()} + get {_storage._optionalValue ?? SwiftProtobuf.Google_Protobuf_Value()} set {_uniqueStorage()._optionalValue = newValue} } /// Returns true if `optionalValue` has been explicitly set. - var hasOptionalValue: Bool {return _storage._optionalValue != nil} + var hasOptionalValue: Bool {_storage._optionalValue != nil} /// Clears the value of `optionalValue`. Subsequent reads from it will return its default value. mutating func clearOptionalValue() {_uniqueStorage()._optionalValue = nil} var optionalNullValue: SwiftProtobuf.Google_Protobuf_NullValue { - get {return _storage._optionalNullValue} + get {_storage._optionalNullValue} set {_uniqueStorage()._optionalNullValue = newValue} } var repeatedDuration: [SwiftProtobuf.Google_Protobuf_Duration] { - get {return _storage._repeatedDuration} + get {_storage._repeatedDuration} set {_uniqueStorage()._repeatedDuration = newValue} } var repeatedTimestamp: [SwiftProtobuf.Google_Protobuf_Timestamp] { - get {return _storage._repeatedTimestamp} + get {_storage._repeatedTimestamp} set {_uniqueStorage()._repeatedTimestamp = newValue} } var repeatedFieldmask: [SwiftProtobuf.Google_Protobuf_FieldMask] { - get {return _storage._repeatedFieldmask} + get {_storage._repeatedFieldmask} set {_uniqueStorage()._repeatedFieldmask = newValue} } var repeatedStruct: [SwiftProtobuf.Google_Protobuf_Struct] { - get {return _storage._repeatedStruct} + get {_storage._repeatedStruct} set {_uniqueStorage()._repeatedStruct = newValue} } var repeatedAny: [SwiftProtobuf.Google_Protobuf_Any] { - get {return _storage._repeatedAny} + get {_storage._repeatedAny} set {_uniqueStorage()._repeatedAny = newValue} } var repeatedValue: [SwiftProtobuf.Google_Protobuf_Value] { - get {return _storage._repeatedValue} + get {_storage._repeatedValue} set {_uniqueStorage()._repeatedValue = newValue} } var repeatedListValue: [SwiftProtobuf.Google_Protobuf_ListValue] { - get {return _storage._repeatedListValue} + get {_storage._repeatedListValue} set {_uniqueStorage()._repeatedListValue = newValue} } /// Test field-name-to-JSON-name convention. /// (protobuf says names can be any valid C/C++ identifier.) var fieldname1: Int32 { - get {return _storage._fieldname1} + get {_storage._fieldname1} set {_uniqueStorage()._fieldname1 = newValue} } var fieldName2: Int32 { - get {return _storage._fieldName2} + get {_storage._fieldName2} set {_uniqueStorage()._fieldName2 = newValue} } var fieldName3: Int32 { - get {return _storage._fieldName3} + get {_storage._fieldName3} set {_uniqueStorage()._fieldName3 = newValue} } var field_Name4_: Int32 { - get {return _storage._field_Name4_} + get {_storage._field_Name4_} set {_uniqueStorage()._field_Name4_ = newValue} } var field0Name5: Int32 { - get {return _storage._field0Name5} + get {_storage._field0Name5} set {_uniqueStorage()._field0Name5 = newValue} } var field0Name6: Int32 { - get {return _storage._field0Name6} + get {_storage._field0Name6} set {_uniqueStorage()._field0Name6 = newValue} } var fieldName7: Int32 { - get {return _storage._fieldName7} + get {_storage._fieldName7} set {_uniqueStorage()._fieldName7 = newValue} } var fieldName8: Int32 { - get {return _storage._fieldName8} + get {_storage._fieldName8} set {_uniqueStorage()._fieldName8 = newValue} } var fieldName9: Int32 { - get {return _storage._fieldName9} + get {_storage._fieldName9} set {_uniqueStorage()._fieldName9 = newValue} } var fieldName10: Int32 { - get {return _storage._fieldName10} + get {_storage._fieldName10} set {_uniqueStorage()._fieldName10 = newValue} } var fieldName11: Int32 { - get {return _storage._fieldName11} + get {_storage._fieldName11} set {_uniqueStorage()._fieldName11 = newValue} } var fieldName12: Int32 { - get {return _storage._fieldName12} + get {_storage._fieldName12} set {_uniqueStorage()._fieldName12 = newValue} } var _FieldName13: Int32 { - get {return _storage.__FieldName13} + get {_storage.__FieldName13} set {_uniqueStorage().__FieldName13 = newValue} } var _FieldName14: Int32 { - get {return _storage.__FieldName14} + get {_storage.__FieldName14} set {_uniqueStorage().__FieldName14 = newValue} } var field_Name15: Int32 { - get {return _storage._field_Name15} + get {_storage._field_Name15} set {_uniqueStorage()._field_Name15 = newValue} } var field_Name16: Int32 { - get {return _storage._field_Name16} + get {_storage._field_Name16} set {_uniqueStorage()._field_Name16 = newValue} } var fieldName17__: Int32 { - get {return _storage._fieldName17__} + get {_storage._fieldName17__} set {_uniqueStorage()._fieldName17__ = newValue} } var fieldName18__: Int32 { - get {return _storage._fieldName18__} + get {_storage._fieldName18__} set {_uniqueStorage()._fieldName18__ = newValue} } var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case oneofUint32(UInt32) case oneofNestedMessage(ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage) case oneofString(String) @@ -996,59 +969,9 @@ struct ProtobufTestMessages_Proto3_TestAllTypesProto3 { case oneofEnum(ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum) case oneofNullValue(SwiftProtobuf.Google_Protobuf_NullValue) - #if !swift(>=4.1) - static func ==(lhs: ProtobufTestMessages_Proto3_TestAllTypesProto3.OneOf_OneofField, rhs: ProtobufTestMessages_Proto3_TestAllTypesProto3.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBool, .oneofBool): return { - guard case .oneofBool(let l) = lhs, case .oneofBool(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint64, .oneofUint64): return { - guard case .oneofUint64(let l) = lhs, case .oneofUint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFloat, .oneofFloat): return { - guard case .oneofFloat(let l) = lhs, case .oneofFloat(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofDouble, .oneofDouble): return { - guard case .oneofDouble(let l) = lhs, case .oneofDouble(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofEnum, .oneofEnum): return { - guard case .oneofEnum(let l) = lhs, case .oneofEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNullValue, .oneofNullValue): return { - guard case .oneofNullValue(let l) = lhs, case .oneofNullValue(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum NestedEnum: SwiftProtobuf.Enum { + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foo // = 0 case bar // = 1 @@ -1082,14 +1005,22 @@ struct ProtobufTestMessages_Proto3_TestAllTypesProto3 { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] = [ + .foo, + .bar, + .baz, + .neg, + ] + } - enum AliasedEnum: SwiftProtobuf.Enum { + enum AliasedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case aliasFoo // = 0 case aliasBar // = 1 case aliasBaz // = 2 - static let qux = aliasBaz + static let moo = aliasBaz static let bAz = aliasBaz case UNRECOGNIZED(Int) @@ -1115,24 +1046,31 @@ struct ProtobufTestMessages_Proto3_TestAllTypesProto3 { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum] = [ + .aliasFoo, + .aliasBar, + .aliasBaz, + ] + } - struct NestedMessage { + struct NestedMessage: @unchecked Sendable { // 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 a: Int32 { - get {return _storage._a} + get {_storage._a} set {_uniqueStorage()._a = newValue} } var corecursive: ProtobufTestMessages_Proto3_TestAllTypesProto3 { - get {return _storage._corecursive ?? ProtobufTestMessages_Proto3_TestAllTypesProto3()} + get {_storage._corecursive ?? ProtobufTestMessages_Proto3_TestAllTypesProto3()} set {_uniqueStorage()._corecursive = newValue} } /// Returns true if `corecursive` has been explicitly set. - var hasCorecursive: Bool {return _storage._corecursive != nil} + var hasCorecursive: Bool {_storage._corecursive != nil} /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} @@ -1148,30 +1086,7 @@ struct ProtobufTestMessages_Proto3_TestAllTypesProto3 { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] = [ - .foo, - .bar, - .baz, - .neg, - ] -} - -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum] = [ - .aliasFoo, - .aliasBar, - .aliasBaz, - ] -} - -#endif // swift(>=4.2) - -struct ProtobufTestMessages_Proto3_ForeignMessage { +struct ProtobufTestMessages_Proto3_ForeignMessage: Sendable { // 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. @@ -1183,7 +1098,7 @@ struct ProtobufTestMessages_Proto3_ForeignMessage { init() {} } -struct ProtobufTestMessages_Proto3_NullHypothesisProto3 { +struct ProtobufTestMessages_Proto3_NullHypothesisProto3: Sendable { // 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. @@ -1193,14 +1108,14 @@ struct ProtobufTestMessages_Proto3_NullHypothesisProto3 { init() {} } -struct ProtobufTestMessages_Proto3_EnumOnlyProto3 { +struct ProtobufTestMessages_Proto3_EnumOnlyProto3: Sendable { // 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() - enum BoolEnum: SwiftProtobuf.Enum { + enum BoolEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case kFalse // = 0 case kTrue // = 1 @@ -1226,203 +1141,28 @@ struct ProtobufTestMessages_Proto3_EnumOnlyProto3 { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Proto3_EnumOnlyProto3.BoolEnum] = [ + .kFalse, + .kTrue, + ] + } init() {} } -#if swift(>=4.2) - -extension ProtobufTestMessages_Proto3_EnumOnlyProto3.BoolEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufTestMessages_Proto3_EnumOnlyProto3.BoolEnum] = [ - .kFalse, - .kTrue, - ] -} - -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufTestMessages_Proto3_ForeignEnum: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_TestAllTypesProto3: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_ForeignMessage: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_NullHypothesisProto3: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_EnumOnlyProto3: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_EnumOnlyProto3.BoolEnum: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "protobuf_test_messages.proto3" extension ProtobufTestMessages_Proto3_ForeignEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOREIGN_FOO"), - 1: .same(proto: "FOREIGN_BAR"), - 2: .same(proto: "FOREIGN_BAZ"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") } extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestAllTypesProto3" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "optional_foreign_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "optional_foreign_enum"), - 23: .standard(proto: "optional_aliased_enum"), - 24: .standard(proto: "optional_string_piece"), - 25: .standard(proto: "optional_cord"), - 27: .standard(proto: "recursive_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 48: .standard(proto: "repeated_nested_message"), - 49: .standard(proto: "repeated_foreign_message"), - 51: .standard(proto: "repeated_nested_enum"), - 52: .standard(proto: "repeated_foreign_enum"), - 54: .standard(proto: "repeated_string_piece"), - 55: .standard(proto: "repeated_cord"), - 75: .standard(proto: "packed_int32"), - 76: .standard(proto: "packed_int64"), - 77: .standard(proto: "packed_uint32"), - 78: .standard(proto: "packed_uint64"), - 79: .standard(proto: "packed_sint32"), - 80: .standard(proto: "packed_sint64"), - 81: .standard(proto: "packed_fixed32"), - 82: .standard(proto: "packed_fixed64"), - 83: .standard(proto: "packed_sfixed32"), - 84: .standard(proto: "packed_sfixed64"), - 85: .standard(proto: "packed_float"), - 86: .standard(proto: "packed_double"), - 87: .standard(proto: "packed_bool"), - 88: .standard(proto: "packed_nested_enum"), - 89: .standard(proto: "unpacked_int32"), - 90: .standard(proto: "unpacked_int64"), - 91: .standard(proto: "unpacked_uint32"), - 92: .standard(proto: "unpacked_uint64"), - 93: .standard(proto: "unpacked_sint32"), - 94: .standard(proto: "unpacked_sint64"), - 95: .standard(proto: "unpacked_fixed32"), - 96: .standard(proto: "unpacked_fixed64"), - 97: .standard(proto: "unpacked_sfixed32"), - 98: .standard(proto: "unpacked_sfixed64"), - 99: .standard(proto: "unpacked_float"), - 100: .standard(proto: "unpacked_double"), - 101: .standard(proto: "unpacked_bool"), - 102: .standard(proto: "unpacked_nested_enum"), - 56: .standard(proto: "map_int32_int32"), - 57: .standard(proto: "map_int64_int64"), - 58: .standard(proto: "map_uint32_uint32"), - 59: .standard(proto: "map_uint64_uint64"), - 60: .standard(proto: "map_sint32_sint32"), - 61: .standard(proto: "map_sint64_sint64"), - 62: .standard(proto: "map_fixed32_fixed32"), - 63: .standard(proto: "map_fixed64_fixed64"), - 64: .standard(proto: "map_sfixed32_sfixed32"), - 65: .standard(proto: "map_sfixed64_sfixed64"), - 66: .standard(proto: "map_int32_float"), - 67: .standard(proto: "map_int32_double"), - 68: .standard(proto: "map_bool_bool"), - 69: .standard(proto: "map_string_string"), - 70: .standard(proto: "map_string_bytes"), - 71: .standard(proto: "map_string_nested_message"), - 72: .standard(proto: "map_string_foreign_message"), - 73: .standard(proto: "map_string_nested_enum"), - 74: .standard(proto: "map_string_foreign_enum"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - 115: .standard(proto: "oneof_bool"), - 116: .standard(proto: "oneof_uint64"), - 117: .standard(proto: "oneof_float"), - 118: .standard(proto: "oneof_double"), - 119: .standard(proto: "oneof_enum"), - 120: .standard(proto: "oneof_null_value"), - 201: .standard(proto: "optional_bool_wrapper"), - 202: .standard(proto: "optional_int32_wrapper"), - 203: .standard(proto: "optional_int64_wrapper"), - 204: .standard(proto: "optional_uint32_wrapper"), - 205: .standard(proto: "optional_uint64_wrapper"), - 206: .standard(proto: "optional_float_wrapper"), - 207: .standard(proto: "optional_double_wrapper"), - 208: .standard(proto: "optional_string_wrapper"), - 209: .standard(proto: "optional_bytes_wrapper"), - 211: .standard(proto: "repeated_bool_wrapper"), - 212: .standard(proto: "repeated_int32_wrapper"), - 213: .standard(proto: "repeated_int64_wrapper"), - 214: .standard(proto: "repeated_uint32_wrapper"), - 215: .standard(proto: "repeated_uint64_wrapper"), - 216: .standard(proto: "repeated_float_wrapper"), - 217: .standard(proto: "repeated_double_wrapper"), - 218: .standard(proto: "repeated_string_wrapper"), - 219: .standard(proto: "repeated_bytes_wrapper"), - 301: .standard(proto: "optional_duration"), - 302: .standard(proto: "optional_timestamp"), - 303: .standard(proto: "optional_field_mask"), - 304: .standard(proto: "optional_struct"), - 305: .standard(proto: "optional_any"), - 306: .standard(proto: "optional_value"), - 307: .standard(proto: "optional_null_value"), - 311: .standard(proto: "repeated_duration"), - 312: .standard(proto: "repeated_timestamp"), - 313: .standard(proto: "repeated_fieldmask"), - 324: .standard(proto: "repeated_struct"), - 315: .standard(proto: "repeated_any"), - 316: .standard(proto: "repeated_value"), - 317: .standard(proto: "repeated_list_value"), - 401: .same(proto: "fieldname1"), - 402: .standard(proto: "field_name2"), - 403: .standard(proto: "_field_name3"), - 404: .standard(proto: "field__name4_"), - 405: .same(proto: "field0name5"), - 406: .standard(proto: "field_0_name6"), - 407: .same(proto: "fieldName7"), - 408: .same(proto: "FieldName8"), - 409: .standard(proto: "field_Name9"), - 410: .standard(proto: "Field_Name10"), - 411: .standard(proto: "FIELD_NAME11"), - 412: .standard(proto: "FIELD_name12"), - 413: .standard(proto: "__field_name13"), - 414: .standard(proto: "__Field_name14"), - 415: .standard(proto: "field__name15"), - 416: .standard(proto: "field__Name16"), - 417: .standard(proto: "field_name17__"), - 418: .standard(proto: "Field_name18__"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{4}\u{2}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{3}optional_aliased_enum\0\u{3}optional_string_piece\0\u{3}optional_cord\0\u{4}\u{2}recursive_message\0\u{4}\u{4}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{4}\u{2}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_nested_message\0\u{3}map_string_foreign_message\0\u{3}map_string_nested_enum\0\u{3}map_string_foreign_enum\0\u{3}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_nested_enum\0\u{3}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_nested_enum\0\u{4}\u{9}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_bool\0\u{3}oneof_uint64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_enum\0\u{3}oneof_null_value\0\u{4}Q\u{1}optional_bool_wrapper\0\u{3}optional_int32_wrapper\0\u{3}optional_int64_wrapper\0\u{3}optional_uint32_wrapper\0\u{3}optional_uint64_wrapper\0\u{3}optional_float_wrapper\0\u{3}optional_double_wrapper\0\u{3}optional_string_wrapper\0\u{3}optional_bytes_wrapper\0\u{4}\u{2}repeated_bool_wrapper\0\u{3}repeated_int32_wrapper\0\u{3}repeated_int64_wrapper\0\u{3}repeated_uint32_wrapper\0\u{3}repeated_uint64_wrapper\0\u{3}repeated_float_wrapper\0\u{3}repeated_double_wrapper\0\u{3}repeated_string_wrapper\0\u{3}repeated_bytes_wrapper\0\u{4}R\u{1}optional_duration\0\u{3}optional_timestamp\0\u{3}optional_field_mask\0\u{3}optional_struct\0\u{3}optional_any\0\u{3}optional_value\0\u{3}optional_null_value\0\u{4}\u{4}repeated_duration\0\u{3}repeated_timestamp\0\u{3}repeated_fieldmask\0\u{4}\u{2}repeated_any\0\u{3}repeated_value\0\u{3}repeated_list_value\0\u{4}\u{7}repeated_struct\0\u{2}M\u{1}fieldname1\0\u{3}field_name2\0\u{3}_field_name3\0\u{3}field__name4_\0\u{1}field0name5\0\u{3}field_0_name6\0\u{1}fieldName7\0\u{1}FieldName8\0\u{3}field_Name9\0\u{3}Field_Name10\0\u{3}FIELD_NAME11\0\u{3}FIELD_name12\0\u{3}__field_name13\0\u{3}__Field_name14\0\u{3}field__name15\0\u{3}field__Name16\0\u{3}field_name17__\0\u{3}Field_name18__\0\u{b}reserved_field\0\u{c}u\u{7}\u{a}\u{c}\u{7f}Ht\u{3}\u{1}") fileprivate class _StorageClass { var _optionalInt32: Int32 = 0 @@ -1568,7 +1308,11 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, var _fieldName17__: Int32 = 0 var _fieldName18__: Int32 = 0 - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -2001,10 +1745,10 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, if _storage._optionalSfixed64 != 0 { try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) } - if _storage._optionalFloat != 0 { + if _storage._optionalFloat.bitPattern != 0 { try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) } - if _storage._optionalDouble != 0 { + if _storage._optionalDouble.bitPattern != 0 { try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) } if _storage._optionalBool != false { @@ -2598,34 +2342,26 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, } extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -1: .same(proto: "NEG"), - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") } extension ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ALIAS_FOO"), - 1: .same(proto: "ALIAS_BAR"), - 2: .aliased(proto: "ALIAS_BAZ", aliases: ["QUX", "qux", "bAz"]), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ALIAS_FOO\0\u{1}ALIAS_BAR\0\u{9}ALIAS_BAZ\0\u{3}MOO\0moo\0bAz\0") } extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = ProtobufTestMessages_Proto3_TestAllTypesProto3.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 2: .same(proto: "corecursive"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0") fileprivate class _StorageClass { var _a: Int32 = 0 var _corecursive: ProtobufTestMessages_Proto3_TestAllTypesProto3? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -2692,9 +2428,7 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage: SwiftPro extension ProtobufTestMessages_Proto3_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ForeignMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -2727,8 +2461,8 @@ extension ProtobufTestMessages_Proto3_NullHypothesisProto3: SwiftProtobuf.Messag static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { @@ -2746,8 +2480,8 @@ extension ProtobufTestMessages_Proto3_EnumOnlyProto3: SwiftProtobuf.Message, Swi static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { @@ -2761,8 +2495,5 @@ extension ProtobufTestMessages_Proto3_EnumOnlyProto3: SwiftProtobuf.Message, Swi } extension ProtobufTestMessages_Proto3_EnumOnlyProto3.BoolEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "kFalse"), - 1: .same(proto: "kTrue"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0kFalse\0\u{1}kTrue\0") } diff --git a/Sources/Conformance/test_messages_proto3_editions.pb.swift b/Sources/Conformance/test_messages_proto3_editions.pb.swift new file mode 100644 index 000000000..122771d23 --- /dev/null +++ b/Sources/Conformance/test_messages_proto3_editions.pb.swift @@ -0,0 +1,2500 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: editions/test_messages_proto3_editions.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// clang-format off +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd +// +// Test schema for proto3 messages. This test schema is used by: +// +// - benchmarks +// - fuzz tests +// - conformance tests + +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 ProtobufTestMessages_Editions_Proto3_ForeignEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foreignFoo // = 0 + case foreignBar // = 1 + case foreignBaz // = 2 + case UNRECOGNIZED(Int) + + init() { + self = .foreignFoo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .foreignFoo + case 1: self = .foreignBar + case 2: self = .foreignBaz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .foreignFoo: return 0 + case .foreignBar: return 1 + case .foreignBaz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Editions_Proto3_ForeignEnum] = [ + .foreignFoo, + .foreignBar, + .foreignBaz, + ] + +} + +/// This proto includes every type of field in both singular and repeated +/// forms. +/// +/// Also, crucially, all messages and enums in this file are eventually +/// submessages of this message. So for example, a fuzz test of TestAllTypes +/// could trigger bugs that occur in any message type in this file. We verify +/// this stays true in a unit test. +struct ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3: @unchecked Sendable { + // 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. + + /// Singular + /// test [kotlin] comment + var optionalInt32: Int32 { + get {_storage._optionalInt32} + set {_uniqueStorage()._optionalInt32 = newValue} + } + + var optionalInt64: Int64 { + get {_storage._optionalInt64} + set {_uniqueStorage()._optionalInt64 = newValue} + } + + var optionalUint32: UInt32 { + get {_storage._optionalUint32} + set {_uniqueStorage()._optionalUint32 = newValue} + } + + var optionalUint64: UInt64 { + get {_storage._optionalUint64} + set {_uniqueStorage()._optionalUint64 = newValue} + } + + var optionalSint32: Int32 { + get {_storage._optionalSint32} + set {_uniqueStorage()._optionalSint32 = newValue} + } + + var optionalSint64: Int64 { + get {_storage._optionalSint64} + set {_uniqueStorage()._optionalSint64 = newValue} + } + + var optionalFixed32: UInt32 { + get {_storage._optionalFixed32} + set {_uniqueStorage()._optionalFixed32 = newValue} + } + + var optionalFixed64: UInt64 { + get {_storage._optionalFixed64} + set {_uniqueStorage()._optionalFixed64 = newValue} + } + + var optionalSfixed32: Int32 { + get {_storage._optionalSfixed32} + set {_uniqueStorage()._optionalSfixed32 = newValue} + } + + var optionalSfixed64: Int64 { + get {_storage._optionalSfixed64} + set {_uniqueStorage()._optionalSfixed64 = newValue} + } + + var optionalFloat: Float { + get {_storage._optionalFloat} + set {_uniqueStorage()._optionalFloat = newValue} + } + + var optionalDouble: Double { + get {_storage._optionalDouble} + set {_uniqueStorage()._optionalDouble = newValue} + } + + var optionalBool: Bool { + get {_storage._optionalBool} + set {_uniqueStorage()._optionalBool = newValue} + } + + var optionalString: String { + get {_storage._optionalString} + set {_uniqueStorage()._optionalString = newValue} + } + + var optionalBytes: Data { + get {_storage._optionalBytes} + set {_uniqueStorage()._optionalBytes = newValue} + } + + var optionalNestedMessage: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage { + get {_storage._optionalNestedMessage ?? ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage()} + set {_uniqueStorage()._optionalNestedMessage = newValue} + } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} + + var optionalForeignMessage: ProtobufTestMessages_Editions_Proto3_ForeignMessage { + get {_storage._optionalForeignMessage ?? ProtobufTestMessages_Editions_Proto3_ForeignMessage()} + set {_uniqueStorage()._optionalForeignMessage = newValue} + } + /// Returns true if `optionalForeignMessage` has been explicitly set. + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} + /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} + + var optionalNestedEnum: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum { + get {_storage._optionalNestedEnum} + set {_uniqueStorage()._optionalNestedEnum = newValue} + } + + var optionalForeignEnum: ProtobufTestMessages_Editions_Proto3_ForeignEnum { + get {_storage._optionalForeignEnum} + set {_uniqueStorage()._optionalForeignEnum = newValue} + } + + var optionalAliasedEnum: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.AliasedEnum { + get {_storage._optionalAliasedEnum} + set {_uniqueStorage()._optionalAliasedEnum = newValue} + } + + var optionalStringPiece: String { + get {_storage._optionalStringPiece} + set {_uniqueStorage()._optionalStringPiece = newValue} + } + + var optionalCord: String { + get {_storage._optionalCord} + set {_uniqueStorage()._optionalCord = newValue} + } + + var recursiveMessage: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3 { + get {_storage._recursiveMessage ?? ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3()} + set {_uniqueStorage()._recursiveMessage = newValue} + } + /// Returns true if `recursiveMessage` has been explicitly set. + var hasRecursiveMessage: Bool {_storage._recursiveMessage != nil} + /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. + mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} + + /// Repeated + var repeatedInt32: [Int32] { + get {_storage._repeatedInt32} + set {_uniqueStorage()._repeatedInt32 = newValue} + } + + var repeatedInt64: [Int64] { + get {_storage._repeatedInt64} + set {_uniqueStorage()._repeatedInt64 = newValue} + } + + var repeatedUint32: [UInt32] { + get {_storage._repeatedUint32} + set {_uniqueStorage()._repeatedUint32 = newValue} + } + + var repeatedUint64: [UInt64] { + get {_storage._repeatedUint64} + set {_uniqueStorage()._repeatedUint64 = newValue} + } + + var repeatedSint32: [Int32] { + get {_storage._repeatedSint32} + set {_uniqueStorage()._repeatedSint32 = newValue} + } + + var repeatedSint64: [Int64] { + get {_storage._repeatedSint64} + set {_uniqueStorage()._repeatedSint64 = newValue} + } + + var repeatedFixed32: [UInt32] { + get {_storage._repeatedFixed32} + set {_uniqueStorage()._repeatedFixed32 = newValue} + } + + var repeatedFixed64: [UInt64] { + get {_storage._repeatedFixed64} + set {_uniqueStorage()._repeatedFixed64 = newValue} + } + + var repeatedSfixed32: [Int32] { + get {_storage._repeatedSfixed32} + set {_uniqueStorage()._repeatedSfixed32 = newValue} + } + + var repeatedSfixed64: [Int64] { + get {_storage._repeatedSfixed64} + set {_uniqueStorage()._repeatedSfixed64 = newValue} + } + + var repeatedFloat: [Float] { + get {_storage._repeatedFloat} + set {_uniqueStorage()._repeatedFloat = newValue} + } + + var repeatedDouble: [Double] { + get {_storage._repeatedDouble} + set {_uniqueStorage()._repeatedDouble = newValue} + } + + var repeatedBool: [Bool] { + get {_storage._repeatedBool} + set {_uniqueStorage()._repeatedBool = newValue} + } + + var repeatedString: [String] { + get {_storage._repeatedString} + set {_uniqueStorage()._repeatedString = newValue} + } + + var repeatedBytes: [Data] { + get {_storage._repeatedBytes} + set {_uniqueStorage()._repeatedBytes = newValue} + } + + var repeatedNestedMessage: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage] { + get {_storage._repeatedNestedMessage} + set {_uniqueStorage()._repeatedNestedMessage = newValue} + } + + var repeatedForeignMessage: [ProtobufTestMessages_Editions_Proto3_ForeignMessage] { + get {_storage._repeatedForeignMessage} + set {_uniqueStorage()._repeatedForeignMessage = newValue} + } + + var repeatedNestedEnum: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] { + get {_storage._repeatedNestedEnum} + set {_uniqueStorage()._repeatedNestedEnum = newValue} + } + + var repeatedForeignEnum: [ProtobufTestMessages_Editions_Proto3_ForeignEnum] { + get {_storage._repeatedForeignEnum} + set {_uniqueStorage()._repeatedForeignEnum = newValue} + } + + var repeatedStringPiece: [String] { + get {_storage._repeatedStringPiece} + set {_uniqueStorage()._repeatedStringPiece = newValue} + } + + var repeatedCord: [String] { + get {_storage._repeatedCord} + set {_uniqueStorage()._repeatedCord = newValue} + } + + /// Packed + var packedInt32: [Int32] { + get {_storage._packedInt32} + set {_uniqueStorage()._packedInt32 = newValue} + } + + var packedInt64: [Int64] { + get {_storage._packedInt64} + set {_uniqueStorage()._packedInt64 = newValue} + } + + var packedUint32: [UInt32] { + get {_storage._packedUint32} + set {_uniqueStorage()._packedUint32 = newValue} + } + + var packedUint64: [UInt64] { + get {_storage._packedUint64} + set {_uniqueStorage()._packedUint64 = newValue} + } + + var packedSint32: [Int32] { + get {_storage._packedSint32} + set {_uniqueStorage()._packedSint32 = newValue} + } + + var packedSint64: [Int64] { + get {_storage._packedSint64} + set {_uniqueStorage()._packedSint64 = newValue} + } + + var packedFixed32: [UInt32] { + get {_storage._packedFixed32} + set {_uniqueStorage()._packedFixed32 = newValue} + } + + var packedFixed64: [UInt64] { + get {_storage._packedFixed64} + set {_uniqueStorage()._packedFixed64 = newValue} + } + + var packedSfixed32: [Int32] { + get {_storage._packedSfixed32} + set {_uniqueStorage()._packedSfixed32 = newValue} + } + + var packedSfixed64: [Int64] { + get {_storage._packedSfixed64} + set {_uniqueStorage()._packedSfixed64 = newValue} + } + + var packedFloat: [Float] { + get {_storage._packedFloat} + set {_uniqueStorage()._packedFloat = newValue} + } + + var packedDouble: [Double] { + get {_storage._packedDouble} + set {_uniqueStorage()._packedDouble = newValue} + } + + var packedBool: [Bool] { + get {_storage._packedBool} + set {_uniqueStorage()._packedBool = newValue} + } + + var packedNestedEnum: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] { + get {_storage._packedNestedEnum} + set {_uniqueStorage()._packedNestedEnum = newValue} + } + + /// Unpacked + var unpackedInt32: [Int32] { + get {_storage._unpackedInt32} + set {_uniqueStorage()._unpackedInt32 = newValue} + } + + var unpackedInt64: [Int64] { + get {_storage._unpackedInt64} + set {_uniqueStorage()._unpackedInt64 = newValue} + } + + var unpackedUint32: [UInt32] { + get {_storage._unpackedUint32} + set {_uniqueStorage()._unpackedUint32 = newValue} + } + + var unpackedUint64: [UInt64] { + get {_storage._unpackedUint64} + set {_uniqueStorage()._unpackedUint64 = newValue} + } + + var unpackedSint32: [Int32] { + get {_storage._unpackedSint32} + set {_uniqueStorage()._unpackedSint32 = newValue} + } + + var unpackedSint64: [Int64] { + get {_storage._unpackedSint64} + set {_uniqueStorage()._unpackedSint64 = newValue} + } + + var unpackedFixed32: [UInt32] { + get {_storage._unpackedFixed32} + set {_uniqueStorage()._unpackedFixed32 = newValue} + } + + var unpackedFixed64: [UInt64] { + get {_storage._unpackedFixed64} + set {_uniqueStorage()._unpackedFixed64 = newValue} + } + + var unpackedSfixed32: [Int32] { + get {_storage._unpackedSfixed32} + set {_uniqueStorage()._unpackedSfixed32 = newValue} + } + + var unpackedSfixed64: [Int64] { + get {_storage._unpackedSfixed64} + set {_uniqueStorage()._unpackedSfixed64 = newValue} + } + + var unpackedFloat: [Float] { + get {_storage._unpackedFloat} + set {_uniqueStorage()._unpackedFloat = newValue} + } + + var unpackedDouble: [Double] { + get {_storage._unpackedDouble} + set {_uniqueStorage()._unpackedDouble = newValue} + } + + var unpackedBool: [Bool] { + get {_storage._unpackedBool} + set {_uniqueStorage()._unpackedBool = newValue} + } + + var unpackedNestedEnum: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] { + get {_storage._unpackedNestedEnum} + set {_uniqueStorage()._unpackedNestedEnum = newValue} + } + + /// Map + var mapInt32Int32: Dictionary { + get {_storage._mapInt32Int32} + set {_uniqueStorage()._mapInt32Int32 = newValue} + } + + var mapInt64Int64: Dictionary { + get {_storage._mapInt64Int64} + set {_uniqueStorage()._mapInt64Int64 = newValue} + } + + var mapUint32Uint32: Dictionary { + get {_storage._mapUint32Uint32} + set {_uniqueStorage()._mapUint32Uint32 = newValue} + } + + var mapUint64Uint64: Dictionary { + get {_storage._mapUint64Uint64} + set {_uniqueStorage()._mapUint64Uint64 = newValue} + } + + var mapSint32Sint32: Dictionary { + get {_storage._mapSint32Sint32} + set {_uniqueStorage()._mapSint32Sint32 = newValue} + } + + var mapSint64Sint64: Dictionary { + get {_storage._mapSint64Sint64} + set {_uniqueStorage()._mapSint64Sint64 = newValue} + } + + var mapFixed32Fixed32: Dictionary { + get {_storage._mapFixed32Fixed32} + set {_uniqueStorage()._mapFixed32Fixed32 = newValue} + } + + var mapFixed64Fixed64: Dictionary { + get {_storage._mapFixed64Fixed64} + set {_uniqueStorage()._mapFixed64Fixed64 = newValue} + } + + var mapSfixed32Sfixed32: Dictionary { + get {_storage._mapSfixed32Sfixed32} + set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} + } + + var mapSfixed64Sfixed64: Dictionary { + get {_storage._mapSfixed64Sfixed64} + set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} + } + + var mapInt32Float: Dictionary { + get {_storage._mapInt32Float} + set {_uniqueStorage()._mapInt32Float = newValue} + } + + var mapInt32Double: Dictionary { + get {_storage._mapInt32Double} + set {_uniqueStorage()._mapInt32Double = newValue} + } + + var mapBoolBool: Dictionary { + get {_storage._mapBoolBool} + set {_uniqueStorage()._mapBoolBool = newValue} + } + + var mapStringString: Dictionary { + get {_storage._mapStringString} + set {_uniqueStorage()._mapStringString = newValue} + } + + var mapStringBytes: Dictionary { + get {_storage._mapStringBytes} + set {_uniqueStorage()._mapStringBytes = newValue} + } + + var mapStringNestedMessage: Dictionary { + get {_storage._mapStringNestedMessage} + set {_uniqueStorage()._mapStringNestedMessage = newValue} + } + + var mapStringForeignMessage: Dictionary { + get {_storage._mapStringForeignMessage} + set {_uniqueStorage()._mapStringForeignMessage = newValue} + } + + var mapStringNestedEnum: Dictionary { + get {_storage._mapStringNestedEnum} + set {_uniqueStorage()._mapStringNestedEnum = newValue} + } + + var mapStringForeignEnum: Dictionary { + get {_storage._mapStringForeignEnum} + set {_uniqueStorage()._mapStringForeignEnum = newValue} + } + + var oneofField: OneOf_OneofField? { + get {return _storage._oneofField} + set {_uniqueStorage()._oneofField = newValue} + } + + var oneofUint32: UInt32 { + get { + if case .oneofUint32(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} + } + + var oneofNestedMessage: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage { + get { + if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} + return ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage() + } + set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} + } + + var oneofString: String { + get { + if case .oneofString(let v)? = _storage._oneofField {return v} + return String() + } + set {_uniqueStorage()._oneofField = .oneofString(newValue)} + } + + var oneofBytes: Data { + get { + if case .oneofBytes(let v)? = _storage._oneofField {return v} + return Data() + } + set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} + } + + var oneofBool: Bool { + get { + if case .oneofBool(let v)? = _storage._oneofField {return v} + return false + } + set {_uniqueStorage()._oneofField = .oneofBool(newValue)} + } + + var oneofUint64: UInt64 { + get { + if case .oneofUint64(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofUint64(newValue)} + } + + var oneofFloat: Float { + get { + if case .oneofFloat(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofFloat(newValue)} + } + + var oneofDouble: Double { + get { + if case .oneofDouble(let v)? = _storage._oneofField {return v} + return 0 + } + set {_uniqueStorage()._oneofField = .oneofDouble(newValue)} + } + + var oneofEnum: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum { + get { + if case .oneofEnum(let v)? = _storage._oneofField {return v} + return .foo + } + set {_uniqueStorage()._oneofField = .oneofEnum(newValue)} + } + + var oneofNullValue: SwiftProtobuf.Google_Protobuf_NullValue { + get { + if case .oneofNullValue(let v)? = _storage._oneofField {return v} + return .nullValue + } + set {_uniqueStorage()._oneofField = .oneofNullValue(newValue)} + } + + /// Well-known types + var optionalBoolWrapper: SwiftProtobuf.Google_Protobuf_BoolValue { + get {_storage._optionalBoolWrapper ?? SwiftProtobuf.Google_Protobuf_BoolValue()} + set {_uniqueStorage()._optionalBoolWrapper = newValue} + } + /// Returns true if `optionalBoolWrapper` has been explicitly set. + var hasOptionalBoolWrapper: Bool {_storage._optionalBoolWrapper != nil} + /// Clears the value of `optionalBoolWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalBoolWrapper() {_uniqueStorage()._optionalBoolWrapper = nil} + + var optionalInt32Wrapper: SwiftProtobuf.Google_Protobuf_Int32Value { + get {_storage._optionalInt32Wrapper ?? SwiftProtobuf.Google_Protobuf_Int32Value()} + set {_uniqueStorage()._optionalInt32Wrapper = newValue} + } + /// Returns true if `optionalInt32Wrapper` has been explicitly set. + var hasOptionalInt32Wrapper: Bool {_storage._optionalInt32Wrapper != nil} + /// Clears the value of `optionalInt32Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt32Wrapper() {_uniqueStorage()._optionalInt32Wrapper = nil} + + var optionalInt64Wrapper: SwiftProtobuf.Google_Protobuf_Int64Value { + get {_storage._optionalInt64Wrapper ?? SwiftProtobuf.Google_Protobuf_Int64Value()} + set {_uniqueStorage()._optionalInt64Wrapper = newValue} + } + /// Returns true if `optionalInt64Wrapper` has been explicitly set. + var hasOptionalInt64Wrapper: Bool {_storage._optionalInt64Wrapper != nil} + /// Clears the value of `optionalInt64Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalInt64Wrapper() {_uniqueStorage()._optionalInt64Wrapper = nil} + + var optionalUint32Wrapper: SwiftProtobuf.Google_Protobuf_UInt32Value { + get {_storage._optionalUint32Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} + set {_uniqueStorage()._optionalUint32Wrapper = newValue} + } + /// Returns true if `optionalUint32Wrapper` has been explicitly set. + var hasOptionalUint32Wrapper: Bool {_storage._optionalUint32Wrapper != nil} + /// Clears the value of `optionalUint32Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint32Wrapper() {_uniqueStorage()._optionalUint32Wrapper = nil} + + var optionalUint64Wrapper: SwiftProtobuf.Google_Protobuf_UInt64Value { + get {_storage._optionalUint64Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} + set {_uniqueStorage()._optionalUint64Wrapper = newValue} + } + /// Returns true if `optionalUint64Wrapper` has been explicitly set. + var hasOptionalUint64Wrapper: Bool {_storage._optionalUint64Wrapper != nil} + /// Clears the value of `optionalUint64Wrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalUint64Wrapper() {_uniqueStorage()._optionalUint64Wrapper = nil} + + var optionalFloatWrapper: SwiftProtobuf.Google_Protobuf_FloatValue { + get {_storage._optionalFloatWrapper ?? SwiftProtobuf.Google_Protobuf_FloatValue()} + set {_uniqueStorage()._optionalFloatWrapper = newValue} + } + /// Returns true if `optionalFloatWrapper` has been explicitly set. + var hasOptionalFloatWrapper: Bool {_storage._optionalFloatWrapper != nil} + /// Clears the value of `optionalFloatWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalFloatWrapper() {_uniqueStorage()._optionalFloatWrapper = nil} + + var optionalDoubleWrapper: SwiftProtobuf.Google_Protobuf_DoubleValue { + get {_storage._optionalDoubleWrapper ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} + set {_uniqueStorage()._optionalDoubleWrapper = newValue} + } + /// Returns true if `optionalDoubleWrapper` has been explicitly set. + var hasOptionalDoubleWrapper: Bool {_storage._optionalDoubleWrapper != nil} + /// Clears the value of `optionalDoubleWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalDoubleWrapper() {_uniqueStorage()._optionalDoubleWrapper = nil} + + var optionalStringWrapper: SwiftProtobuf.Google_Protobuf_StringValue { + get {_storage._optionalStringWrapper ?? SwiftProtobuf.Google_Protobuf_StringValue()} + set {_uniqueStorage()._optionalStringWrapper = newValue} + } + /// Returns true if `optionalStringWrapper` has been explicitly set. + var hasOptionalStringWrapper: Bool {_storage._optionalStringWrapper != nil} + /// Clears the value of `optionalStringWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalStringWrapper() {_uniqueStorage()._optionalStringWrapper = nil} + + var optionalBytesWrapper: SwiftProtobuf.Google_Protobuf_BytesValue { + get {_storage._optionalBytesWrapper ?? SwiftProtobuf.Google_Protobuf_BytesValue()} + set {_uniqueStorage()._optionalBytesWrapper = newValue} + } + /// Returns true if `optionalBytesWrapper` has been explicitly set. + var hasOptionalBytesWrapper: Bool {_storage._optionalBytesWrapper != nil} + /// Clears the value of `optionalBytesWrapper`. Subsequent reads from it will return its default value. + mutating func clearOptionalBytesWrapper() {_uniqueStorage()._optionalBytesWrapper = nil} + + var repeatedBoolWrapper: [SwiftProtobuf.Google_Protobuf_BoolValue] { + get {_storage._repeatedBoolWrapper} + set {_uniqueStorage()._repeatedBoolWrapper = newValue} + } + + var repeatedInt32Wrapper: [SwiftProtobuf.Google_Protobuf_Int32Value] { + get {_storage._repeatedInt32Wrapper} + set {_uniqueStorage()._repeatedInt32Wrapper = newValue} + } + + var repeatedInt64Wrapper: [SwiftProtobuf.Google_Protobuf_Int64Value] { + get {_storage._repeatedInt64Wrapper} + set {_uniqueStorage()._repeatedInt64Wrapper = newValue} + } + + var repeatedUint32Wrapper: [SwiftProtobuf.Google_Protobuf_UInt32Value] { + get {_storage._repeatedUint32Wrapper} + set {_uniqueStorage()._repeatedUint32Wrapper = newValue} + } + + var repeatedUint64Wrapper: [SwiftProtobuf.Google_Protobuf_UInt64Value] { + get {_storage._repeatedUint64Wrapper} + set {_uniqueStorage()._repeatedUint64Wrapper = newValue} + } + + var repeatedFloatWrapper: [SwiftProtobuf.Google_Protobuf_FloatValue] { + get {_storage._repeatedFloatWrapper} + set {_uniqueStorage()._repeatedFloatWrapper = newValue} + } + + var repeatedDoubleWrapper: [SwiftProtobuf.Google_Protobuf_DoubleValue] { + get {_storage._repeatedDoubleWrapper} + set {_uniqueStorage()._repeatedDoubleWrapper = newValue} + } + + var repeatedStringWrapper: [SwiftProtobuf.Google_Protobuf_StringValue] { + get {_storage._repeatedStringWrapper} + set {_uniqueStorage()._repeatedStringWrapper = newValue} + } + + var repeatedBytesWrapper: [SwiftProtobuf.Google_Protobuf_BytesValue] { + get {_storage._repeatedBytesWrapper} + set {_uniqueStorage()._repeatedBytesWrapper = newValue} + } + + var optionalDuration: SwiftProtobuf.Google_Protobuf_Duration { + get {_storage._optionalDuration ?? SwiftProtobuf.Google_Protobuf_Duration()} + set {_uniqueStorage()._optionalDuration = newValue} + } + /// Returns true if `optionalDuration` has been explicitly set. + var hasOptionalDuration: Bool {_storage._optionalDuration != nil} + /// Clears the value of `optionalDuration`. Subsequent reads from it will return its default value. + mutating func clearOptionalDuration() {_uniqueStorage()._optionalDuration = nil} + + var optionalTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp { + get {_storage._optionalTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()} + set {_uniqueStorage()._optionalTimestamp = newValue} + } + /// Returns true if `optionalTimestamp` has been explicitly set. + var hasOptionalTimestamp: Bool {_storage._optionalTimestamp != nil} + /// Clears the value of `optionalTimestamp`. Subsequent reads from it will return its default value. + mutating func clearOptionalTimestamp() {_uniqueStorage()._optionalTimestamp = nil} + + var optionalFieldMask: SwiftProtobuf.Google_Protobuf_FieldMask { + get {_storage._optionalFieldMask ?? SwiftProtobuf.Google_Protobuf_FieldMask()} + set {_uniqueStorage()._optionalFieldMask = newValue} + } + /// Returns true if `optionalFieldMask` has been explicitly set. + var hasOptionalFieldMask: Bool {_storage._optionalFieldMask != nil} + /// Clears the value of `optionalFieldMask`. Subsequent reads from it will return its default value. + mutating func clearOptionalFieldMask() {_uniqueStorage()._optionalFieldMask = nil} + + var optionalStruct: SwiftProtobuf.Google_Protobuf_Struct { + get {_storage._optionalStruct ?? SwiftProtobuf.Google_Protobuf_Struct()} + set {_uniqueStorage()._optionalStruct = newValue} + } + /// Returns true if `optionalStruct` has been explicitly set. + var hasOptionalStruct: Bool {_storage._optionalStruct != nil} + /// Clears the value of `optionalStruct`. Subsequent reads from it will return its default value. + mutating func clearOptionalStruct() {_uniqueStorage()._optionalStruct = nil} + + var optionalAny: SwiftProtobuf.Google_Protobuf_Any { + get {_storage._optionalAny ?? SwiftProtobuf.Google_Protobuf_Any()} + set {_uniqueStorage()._optionalAny = newValue} + } + /// Returns true if `optionalAny` has been explicitly set. + var hasOptionalAny: Bool {_storage._optionalAny != nil} + /// Clears the value of `optionalAny`. Subsequent reads from it will return its default value. + mutating func clearOptionalAny() {_uniqueStorage()._optionalAny = nil} + + var optionalValue: SwiftProtobuf.Google_Protobuf_Value { + get {_storage._optionalValue ?? SwiftProtobuf.Google_Protobuf_Value()} + set {_uniqueStorage()._optionalValue = newValue} + } + /// Returns true if `optionalValue` has been explicitly set. + var hasOptionalValue: Bool {_storage._optionalValue != nil} + /// Clears the value of `optionalValue`. Subsequent reads from it will return its default value. + mutating func clearOptionalValue() {_uniqueStorage()._optionalValue = nil} + + var optionalNullValue: SwiftProtobuf.Google_Protobuf_NullValue { + get {_storage._optionalNullValue} + set {_uniqueStorage()._optionalNullValue = newValue} + } + + var repeatedDuration: [SwiftProtobuf.Google_Protobuf_Duration] { + get {_storage._repeatedDuration} + set {_uniqueStorage()._repeatedDuration = newValue} + } + + var repeatedTimestamp: [SwiftProtobuf.Google_Protobuf_Timestamp] { + get {_storage._repeatedTimestamp} + set {_uniqueStorage()._repeatedTimestamp = newValue} + } + + var repeatedFieldmask: [SwiftProtobuf.Google_Protobuf_FieldMask] { + get {_storage._repeatedFieldmask} + set {_uniqueStorage()._repeatedFieldmask = newValue} + } + + var repeatedStruct: [SwiftProtobuf.Google_Protobuf_Struct] { + get {_storage._repeatedStruct} + set {_uniqueStorage()._repeatedStruct = newValue} + } + + var repeatedAny: [SwiftProtobuf.Google_Protobuf_Any] { + get {_storage._repeatedAny} + set {_uniqueStorage()._repeatedAny = newValue} + } + + var repeatedValue: [SwiftProtobuf.Google_Protobuf_Value] { + get {_storage._repeatedValue} + set {_uniqueStorage()._repeatedValue = newValue} + } + + var repeatedListValue: [SwiftProtobuf.Google_Protobuf_ListValue] { + get {_storage._repeatedListValue} + set {_uniqueStorage()._repeatedListValue = newValue} + } + + /// Test field-name-to-JSON-name convention. + /// (protobuf says names can be any valid C/C++ identifier.) + var fieldname1: Int32 { + get {_storage._fieldname1} + set {_uniqueStorage()._fieldname1 = newValue} + } + + var fieldName2: Int32 { + get {_storage._fieldName2} + set {_uniqueStorage()._fieldName2 = newValue} + } + + var fieldName3: Int32 { + get {_storage._fieldName3} + set {_uniqueStorage()._fieldName3 = newValue} + } + + var field_Name4_: Int32 { + get {_storage._field_Name4_} + set {_uniqueStorage()._field_Name4_ = newValue} + } + + var field0Name5: Int32 { + get {_storage._field0Name5} + set {_uniqueStorage()._field0Name5 = newValue} + } + + var field0Name6: Int32 { + get {_storage._field0Name6} + set {_uniqueStorage()._field0Name6 = newValue} + } + + var fieldName7: Int32 { + get {_storage._fieldName7} + set {_uniqueStorage()._fieldName7 = newValue} + } + + var fieldName8: Int32 { + get {_storage._fieldName8} + set {_uniqueStorage()._fieldName8 = newValue} + } + + var fieldName9: Int32 { + get {_storage._fieldName9} + set {_uniqueStorage()._fieldName9 = newValue} + } + + var fieldName10: Int32 { + get {_storage._fieldName10} + set {_uniqueStorage()._fieldName10 = newValue} + } + + var fieldName11: Int32 { + get {_storage._fieldName11} + set {_uniqueStorage()._fieldName11 = newValue} + } + + var fieldName12: Int32 { + get {_storage._fieldName12} + set {_uniqueStorage()._fieldName12 = newValue} + } + + var _FieldName13: Int32 { + get {_storage.__FieldName13} + set {_uniqueStorage().__FieldName13 = newValue} + } + + var _FieldName14: Int32 { + get {_storage.__FieldName14} + set {_uniqueStorage().__FieldName14 = newValue} + } + + var field_Name15: Int32 { + get {_storage._field_Name15} + set {_uniqueStorage()._field_Name15 = newValue} + } + + var field_Name16: Int32 { + get {_storage._field_Name16} + set {_uniqueStorage()._field_Name16 = newValue} + } + + var fieldName17__: Int32 { + get {_storage._fieldName17__} + set {_uniqueStorage()._fieldName17__ = newValue} + } + + var fieldName18__: Int32 { + get {_storage._fieldName18__} + set {_uniqueStorage()._fieldName18__ = newValue} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_OneofField: Equatable, Sendable { + case oneofUint32(UInt32) + case oneofNestedMessage(ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage) + case oneofString(String) + case oneofBytes(Data) + case oneofBool(Bool) + case oneofUint64(UInt64) + case oneofFloat(Float) + case oneofDouble(Double) + case oneofEnum(ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum) + case oneofNullValue(SwiftProtobuf.Google_Protobuf_NullValue) + + } + + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case foo // = 0 + case bar // = 1 + case baz // = 2 + + /// Intentionally negative. + case neg // = -1 + case UNRECOGNIZED(Int) + + init() { + self = .foo + } + + init?(rawValue: Int) { + switch rawValue { + case -1: self = .neg + case 0: self = .foo + case 1: self = .bar + case 2: self = .baz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .neg: return -1 + case .foo: return 0 + case .bar: return 1 + case .baz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] = [ + .foo, + .bar, + .baz, + .neg, + ] + + } + + enum AliasedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case aliasFoo // = 0 + case aliasBar // = 1 + case aliasBaz // = 2 + static let moo = aliasBaz + static let bAz = aliasBaz + case UNRECOGNIZED(Int) + + init() { + self = .aliasFoo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .aliasFoo + case 1: self = .aliasBar + case 2: self = .aliasBaz + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .aliasFoo: return 0 + case .aliasBar: return 1 + case .aliasBaz: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.AliasedEnum] = [ + .aliasFoo, + .aliasBar, + .aliasBaz, + ] + + } + + struct NestedMessage: @unchecked Sendable { + // 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 a: Int32 { + get {_storage._a} + set {_uniqueStorage()._a = newValue} + } + + var corecursive: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3 { + get {_storage._corecursive ?? ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3()} + set {_uniqueStorage()._corecursive = newValue} + } + /// Returns true if `corecursive` has been explicitly set. + var hasCorecursive: Bool {_storage._corecursive != nil} + /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. + mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +struct ProtobufTestMessages_Editions_Proto3_ForeignMessage: Sendable { + // 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 c: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +struct ProtobufTestMessages_Editions_Proto3_NullHypothesisProto3: Sendable { + // 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 ProtobufTestMessages_Editions_Proto3_EnumOnlyProto3: Sendable { + // 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() + + enum BoolEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case kFalse // = 0 + case kTrue // = 1 + case UNRECOGNIZED(Int) + + init() { + self = .kFalse + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .kFalse + case 1: self = .kTrue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .kFalse: return 0 + case .kTrue: return 1 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [ProtobufTestMessages_Editions_Proto3_EnumOnlyProto3.BoolEnum] = [ + .kFalse, + .kTrue, + ] + + } + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "protobuf_test_messages.editions.proto3" + +extension ProtobufTestMessages_Editions_Proto3_ForeignEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") +} + +extension ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypesProto3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{4}\u{2}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{3}optional_aliased_enum\0\u{3}optional_string_piece\0\u{3}optional_cord\0\u{4}\u{2}recursive_message\0\u{4}\u{4}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{4}\u{2}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4}\u{2}repeated_string_piece\0\u{3}repeated_cord\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_nested_message\0\u{3}map_string_foreign_message\0\u{3}map_string_nested_enum\0\u{3}map_string_foreign_enum\0\u{3}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_nested_enum\0\u{3}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_nested_enum\0\u{4}\u{9}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_bool\0\u{3}oneof_uint64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_enum\0\u{3}oneof_null_value\0\u{4}Q\u{1}optional_bool_wrapper\0\u{3}optional_int32_wrapper\0\u{3}optional_int64_wrapper\0\u{3}optional_uint32_wrapper\0\u{3}optional_uint64_wrapper\0\u{3}optional_float_wrapper\0\u{3}optional_double_wrapper\0\u{3}optional_string_wrapper\0\u{3}optional_bytes_wrapper\0\u{4}\u{2}repeated_bool_wrapper\0\u{3}repeated_int32_wrapper\0\u{3}repeated_int64_wrapper\0\u{3}repeated_uint32_wrapper\0\u{3}repeated_uint64_wrapper\0\u{3}repeated_float_wrapper\0\u{3}repeated_double_wrapper\0\u{3}repeated_string_wrapper\0\u{3}repeated_bytes_wrapper\0\u{4}R\u{1}optional_duration\0\u{3}optional_timestamp\0\u{3}optional_field_mask\0\u{3}optional_struct\0\u{3}optional_any\0\u{3}optional_value\0\u{3}optional_null_value\0\u{4}\u{4}repeated_duration\0\u{3}repeated_timestamp\0\u{3}repeated_fieldmask\0\u{4}\u{2}repeated_any\0\u{3}repeated_value\0\u{3}repeated_list_value\0\u{4}\u{7}repeated_struct\0\u{2}M\u{1}fieldname1\0\u{3}field_name2\0\u{3}_field_name3\0\u{3}field__name4_\0\u{1}field0name5\0\u{3}field_0_name6\0\u{1}fieldName7\0\u{1}FieldName8\0\u{3}field_Name9\0\u{3}Field_Name10\0\u{3}FIELD_NAME11\0\u{3}FIELD_name12\0\u{3}__field_name13\0\u{3}__Field_name14\0\u{3}field__name15\0\u{3}field__Name16\0\u{3}field_name17__\0\u{3}Field_name18__\0\u{b}reserved_field\0\u{c}u\u{7}\u{a}\u{c}\u{7f}Ht\u{3}\u{1}") + + fileprivate class _StorageClass { + var _optionalInt32: Int32 = 0 + var _optionalInt64: Int64 = 0 + var _optionalUint32: UInt32 = 0 + var _optionalUint64: UInt64 = 0 + var _optionalSint32: Int32 = 0 + var _optionalSint64: Int64 = 0 + var _optionalFixed32: UInt32 = 0 + var _optionalFixed64: UInt64 = 0 + var _optionalSfixed32: Int32 = 0 + var _optionalSfixed64: Int64 = 0 + var _optionalFloat: Float = 0 + var _optionalDouble: Double = 0 + var _optionalBool: Bool = false + var _optionalString: String = String() + var _optionalBytes: Data = Data() + var _optionalNestedMessage: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage? = nil + var _optionalForeignMessage: ProtobufTestMessages_Editions_Proto3_ForeignMessage? = nil + var _optionalNestedEnum: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum = .foo + var _optionalForeignEnum: ProtobufTestMessages_Editions_Proto3_ForeignEnum = .foreignFoo + var _optionalAliasedEnum: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.AliasedEnum = .aliasFoo + var _optionalStringPiece: String = String() + var _optionalCord: String = String() + var _recursiveMessage: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3? = nil + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedNestedMessage: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage] = [] + var _repeatedForeignMessage: [ProtobufTestMessages_Editions_Proto3_ForeignMessage] = [] + var _repeatedNestedEnum: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] = [] + var _repeatedForeignEnum: [ProtobufTestMessages_Editions_Proto3_ForeignEnum] = [] + var _repeatedStringPiece: [String] = [] + var _repeatedCord: [String] = [] + var _packedInt32: [Int32] = [] + var _packedInt64: [Int64] = [] + var _packedUint32: [UInt32] = [] + var _packedUint64: [UInt64] = [] + var _packedSint32: [Int32] = [] + var _packedSint64: [Int64] = [] + var _packedFixed32: [UInt32] = [] + var _packedFixed64: [UInt64] = [] + var _packedSfixed32: [Int32] = [] + var _packedSfixed64: [Int64] = [] + var _packedFloat: [Float] = [] + var _packedDouble: [Double] = [] + var _packedBool: [Bool] = [] + var _packedNestedEnum: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] = [] + var _unpackedInt32: [Int32] = [] + var _unpackedInt64: [Int64] = [] + var _unpackedUint32: [UInt32] = [] + var _unpackedUint64: [UInt64] = [] + var _unpackedSint32: [Int32] = [] + var _unpackedSint64: [Int64] = [] + var _unpackedFixed32: [UInt32] = [] + var _unpackedFixed64: [UInt64] = [] + var _unpackedSfixed32: [Int32] = [] + var _unpackedSfixed64: [Int64] = [] + var _unpackedFloat: [Float] = [] + var _unpackedDouble: [Double] = [] + var _unpackedBool: [Bool] = [] + var _unpackedNestedEnum: [ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum] = [] + var _mapInt32Int32: Dictionary = [:] + var _mapInt64Int64: Dictionary = [:] + var _mapUint32Uint32: Dictionary = [:] + var _mapUint64Uint64: Dictionary = [:] + var _mapSint32Sint32: Dictionary = [:] + var _mapSint64Sint64: Dictionary = [:] + var _mapFixed32Fixed32: Dictionary = [:] + var _mapFixed64Fixed64: Dictionary = [:] + var _mapSfixed32Sfixed32: Dictionary = [:] + var _mapSfixed64Sfixed64: Dictionary = [:] + var _mapInt32Float: Dictionary = [:] + var _mapInt32Double: Dictionary = [:] + var _mapBoolBool: Dictionary = [:] + var _mapStringString: Dictionary = [:] + var _mapStringBytes: Dictionary = [:] + var _mapStringNestedMessage: Dictionary = [:] + var _mapStringForeignMessage: Dictionary = [:] + var _mapStringNestedEnum: Dictionary = [:] + var _mapStringForeignEnum: Dictionary = [:] + var _oneofField: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.OneOf_OneofField? + var _optionalBoolWrapper: SwiftProtobuf.Google_Protobuf_BoolValue? = nil + var _optionalInt32Wrapper: SwiftProtobuf.Google_Protobuf_Int32Value? = nil + var _optionalInt64Wrapper: SwiftProtobuf.Google_Protobuf_Int64Value? = nil + var _optionalUint32Wrapper: SwiftProtobuf.Google_Protobuf_UInt32Value? = nil + var _optionalUint64Wrapper: SwiftProtobuf.Google_Protobuf_UInt64Value? = nil + var _optionalFloatWrapper: SwiftProtobuf.Google_Protobuf_FloatValue? = nil + var _optionalDoubleWrapper: SwiftProtobuf.Google_Protobuf_DoubleValue? = nil + var _optionalStringWrapper: SwiftProtobuf.Google_Protobuf_StringValue? = nil + var _optionalBytesWrapper: SwiftProtobuf.Google_Protobuf_BytesValue? = nil + var _repeatedBoolWrapper: [SwiftProtobuf.Google_Protobuf_BoolValue] = [] + var _repeatedInt32Wrapper: [SwiftProtobuf.Google_Protobuf_Int32Value] = [] + var _repeatedInt64Wrapper: [SwiftProtobuf.Google_Protobuf_Int64Value] = [] + var _repeatedUint32Wrapper: [SwiftProtobuf.Google_Protobuf_UInt32Value] = [] + var _repeatedUint64Wrapper: [SwiftProtobuf.Google_Protobuf_UInt64Value] = [] + var _repeatedFloatWrapper: [SwiftProtobuf.Google_Protobuf_FloatValue] = [] + var _repeatedDoubleWrapper: [SwiftProtobuf.Google_Protobuf_DoubleValue] = [] + var _repeatedStringWrapper: [SwiftProtobuf.Google_Protobuf_StringValue] = [] + var _repeatedBytesWrapper: [SwiftProtobuf.Google_Protobuf_BytesValue] = [] + var _optionalDuration: SwiftProtobuf.Google_Protobuf_Duration? = nil + var _optionalTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp? = nil + var _optionalFieldMask: SwiftProtobuf.Google_Protobuf_FieldMask? = nil + var _optionalStruct: SwiftProtobuf.Google_Protobuf_Struct? = nil + var _optionalAny: SwiftProtobuf.Google_Protobuf_Any? = nil + var _optionalValue: SwiftProtobuf.Google_Protobuf_Value? = nil + var _optionalNullValue: SwiftProtobuf.Google_Protobuf_NullValue = .nullValue + var _repeatedDuration: [SwiftProtobuf.Google_Protobuf_Duration] = [] + var _repeatedTimestamp: [SwiftProtobuf.Google_Protobuf_Timestamp] = [] + var _repeatedFieldmask: [SwiftProtobuf.Google_Protobuf_FieldMask] = [] + var _repeatedStruct: [SwiftProtobuf.Google_Protobuf_Struct] = [] + var _repeatedAny: [SwiftProtobuf.Google_Protobuf_Any] = [] + var _repeatedValue: [SwiftProtobuf.Google_Protobuf_Value] = [] + var _repeatedListValue: [SwiftProtobuf.Google_Protobuf_ListValue] = [] + var _fieldname1: Int32 = 0 + var _fieldName2: Int32 = 0 + var _fieldName3: Int32 = 0 + var _field_Name4_: Int32 = 0 + var _field0Name5: Int32 = 0 + var _field0Name6: Int32 = 0 + var _fieldName7: Int32 = 0 + var _fieldName8: Int32 = 0 + var _fieldName9: Int32 = 0 + var _fieldName10: Int32 = 0 + var _fieldName11: Int32 = 0 + var _fieldName12: Int32 = 0 + var __FieldName13: Int32 = 0 + var __FieldName14: Int32 = 0 + var _field_Name15: Int32 = 0 + var _field_Name16: Int32 = 0 + var _fieldName17__: Int32 = 0 + var _fieldName18__: Int32 = 0 + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalNestedMessage = source._optionalNestedMessage + _optionalForeignMessage = source._optionalForeignMessage + _optionalNestedEnum = source._optionalNestedEnum + _optionalForeignEnum = source._optionalForeignEnum + _optionalAliasedEnum = source._optionalAliasedEnum + _optionalStringPiece = source._optionalStringPiece + _optionalCord = source._optionalCord + _recursiveMessage = source._recursiveMessage + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedForeignMessage = source._repeatedForeignMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _repeatedForeignEnum = source._repeatedForeignEnum + _repeatedStringPiece = source._repeatedStringPiece + _repeatedCord = source._repeatedCord + _packedInt32 = source._packedInt32 + _packedInt64 = source._packedInt64 + _packedUint32 = source._packedUint32 + _packedUint64 = source._packedUint64 + _packedSint32 = source._packedSint32 + _packedSint64 = source._packedSint64 + _packedFixed32 = source._packedFixed32 + _packedFixed64 = source._packedFixed64 + _packedSfixed32 = source._packedSfixed32 + _packedSfixed64 = source._packedSfixed64 + _packedFloat = source._packedFloat + _packedDouble = source._packedDouble + _packedBool = source._packedBool + _packedNestedEnum = source._packedNestedEnum + _unpackedInt32 = source._unpackedInt32 + _unpackedInt64 = source._unpackedInt64 + _unpackedUint32 = source._unpackedUint32 + _unpackedUint64 = source._unpackedUint64 + _unpackedSint32 = source._unpackedSint32 + _unpackedSint64 = source._unpackedSint64 + _unpackedFixed32 = source._unpackedFixed32 + _unpackedFixed64 = source._unpackedFixed64 + _unpackedSfixed32 = source._unpackedSfixed32 + _unpackedSfixed64 = source._unpackedSfixed64 + _unpackedFloat = source._unpackedFloat + _unpackedDouble = source._unpackedDouble + _unpackedBool = source._unpackedBool + _unpackedNestedEnum = source._unpackedNestedEnum + _mapInt32Int32 = source._mapInt32Int32 + _mapInt64Int64 = source._mapInt64Int64 + _mapUint32Uint32 = source._mapUint32Uint32 + _mapUint64Uint64 = source._mapUint64Uint64 + _mapSint32Sint32 = source._mapSint32Sint32 + _mapSint64Sint64 = source._mapSint64Sint64 + _mapFixed32Fixed32 = source._mapFixed32Fixed32 + _mapFixed64Fixed64 = source._mapFixed64Fixed64 + _mapSfixed32Sfixed32 = source._mapSfixed32Sfixed32 + _mapSfixed64Sfixed64 = source._mapSfixed64Sfixed64 + _mapInt32Float = source._mapInt32Float + _mapInt32Double = source._mapInt32Double + _mapBoolBool = source._mapBoolBool + _mapStringString = source._mapStringString + _mapStringBytes = source._mapStringBytes + _mapStringNestedMessage = source._mapStringNestedMessage + _mapStringForeignMessage = source._mapStringForeignMessage + _mapStringNestedEnum = source._mapStringNestedEnum + _mapStringForeignEnum = source._mapStringForeignEnum + _oneofField = source._oneofField + _optionalBoolWrapper = source._optionalBoolWrapper + _optionalInt32Wrapper = source._optionalInt32Wrapper + _optionalInt64Wrapper = source._optionalInt64Wrapper + _optionalUint32Wrapper = source._optionalUint32Wrapper + _optionalUint64Wrapper = source._optionalUint64Wrapper + _optionalFloatWrapper = source._optionalFloatWrapper + _optionalDoubleWrapper = source._optionalDoubleWrapper + _optionalStringWrapper = source._optionalStringWrapper + _optionalBytesWrapper = source._optionalBytesWrapper + _repeatedBoolWrapper = source._repeatedBoolWrapper + _repeatedInt32Wrapper = source._repeatedInt32Wrapper + _repeatedInt64Wrapper = source._repeatedInt64Wrapper + _repeatedUint32Wrapper = source._repeatedUint32Wrapper + _repeatedUint64Wrapper = source._repeatedUint64Wrapper + _repeatedFloatWrapper = source._repeatedFloatWrapper + _repeatedDoubleWrapper = source._repeatedDoubleWrapper + _repeatedStringWrapper = source._repeatedStringWrapper + _repeatedBytesWrapper = source._repeatedBytesWrapper + _optionalDuration = source._optionalDuration + _optionalTimestamp = source._optionalTimestamp + _optionalFieldMask = source._optionalFieldMask + _optionalStruct = source._optionalStruct + _optionalAny = source._optionalAny + _optionalValue = source._optionalValue + _optionalNullValue = source._optionalNullValue + _repeatedDuration = source._repeatedDuration + _repeatedTimestamp = source._repeatedTimestamp + _repeatedFieldmask = source._repeatedFieldmask + _repeatedStruct = source._repeatedStruct + _repeatedAny = source._repeatedAny + _repeatedValue = source._repeatedValue + _repeatedListValue = source._repeatedListValue + _fieldname1 = source._fieldname1 + _fieldName2 = source._fieldName2 + _fieldName3 = source._fieldName3 + _field_Name4_ = source._field_Name4_ + _field0Name5 = source._field0Name5 + _field0Name6 = source._field0Name6 + _fieldName7 = source._fieldName7 + _fieldName8 = source._fieldName8 + _fieldName9 = source._fieldName9 + _fieldName10 = source._fieldName10 + _fieldName11 = source._fieldName11 + _fieldName12 = source._fieldName12 + __FieldName13 = source.__FieldName13 + __FieldName14 = source.__FieldName14 + _field_Name15 = source._field_Name15 + _field_Name16 = source._field_Name16 + _fieldName17__ = source._fieldName17__ + _fieldName18__ = source._fieldName18__ + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() + case 23: try { try decoder.decodeSingularEnumField(value: &_storage._optionalAliasedEnum) }() + case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() + case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() + case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() + case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() + case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() + case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() + case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() + case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() + case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() + case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() + case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() + case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() + case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() + case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() + case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() + case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() + case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() + case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() + case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() + case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() + case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() + case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() + case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() + case 56: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Int32) }() + case 57: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() + case 58: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() + case 59: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Uint64) }() + case 60: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Sint32) }() + case 61: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Sint64) }() + case 62: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Fixed32) }() + case 63: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Fixed64) }() + case 64: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Sfixed32) }() + case 65: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Sfixed64) }() + case 66: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Float) }() + case 67: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Double) }() + case 68: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() + case 69: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() + case 70: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() + case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringNestedMessage) }() + case 72: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() + case 73: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringNestedEnum) }() + case 74: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringForeignEnum) }() + case 75: try { try decoder.decodeRepeatedInt32Field(value: &_storage._packedInt32) }() + case 76: try { try decoder.decodeRepeatedInt64Field(value: &_storage._packedInt64) }() + case 77: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._packedUint32) }() + case 78: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._packedUint64) }() + case 79: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._packedSint32) }() + case 80: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._packedSint64) }() + case 81: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._packedFixed32) }() + case 82: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._packedFixed64) }() + case 83: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._packedSfixed32) }() + case 84: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._packedSfixed64) }() + case 85: try { try decoder.decodeRepeatedFloatField(value: &_storage._packedFloat) }() + case 86: try { try decoder.decodeRepeatedDoubleField(value: &_storage._packedDouble) }() + case 87: try { try decoder.decodeRepeatedBoolField(value: &_storage._packedBool) }() + case 88: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedNestedEnum) }() + case 89: try { try decoder.decodeRepeatedInt32Field(value: &_storage._unpackedInt32) }() + case 90: try { try decoder.decodeRepeatedInt64Field(value: &_storage._unpackedInt64) }() + case 91: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._unpackedUint32) }() + case 92: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._unpackedUint64) }() + case 93: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._unpackedSint32) }() + case 94: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._unpackedSint64) }() + case 95: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._unpackedFixed32) }() + case 96: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._unpackedFixed64) }() + case 97: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._unpackedSfixed32) }() + case 98: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._unpackedSfixed64) }() + case 99: try { try decoder.decodeRepeatedFloatField(value: &_storage._unpackedFloat) }() + case 100: try { try decoder.decodeRepeatedDoubleField(value: &_storage._unpackedDouble) }() + case 101: try { try decoder.decodeRepeatedBoolField(value: &_storage._unpackedBool) }() + case 102: try { try decoder.decodeRepeatedEnumField(value: &_storage._unpackedNestedEnum) }() + case 111: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 112: try { + var v: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage(v) + } + }() + case 113: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 114: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() + case 115: try { + var v: Bool? + try decoder.decodeSingularBoolField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBool(v) + } + }() + case 116: try { + var v: UInt64? + try decoder.decodeSingularUInt64Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint64(v) + } + }() + case 117: try { + var v: Float? + try decoder.decodeSingularFloatField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofFloat(v) + } + }() + case 118: try { + var v: Double? + try decoder.decodeSingularDoubleField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofDouble(v) + } + }() + case 119: try { + var v: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofEnum(v) + } + }() + case 120: try { + var v: SwiftProtobuf.Google_Protobuf_NullValue? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNullValue(v) + } + }() + case 201: try { try decoder.decodeSingularMessageField(value: &_storage._optionalBoolWrapper) }() + case 202: try { try decoder.decodeSingularMessageField(value: &_storage._optionalInt32Wrapper) }() + case 203: try { try decoder.decodeSingularMessageField(value: &_storage._optionalInt64Wrapper) }() + case 204: try { try decoder.decodeSingularMessageField(value: &_storage._optionalUint32Wrapper) }() + case 205: try { try decoder.decodeSingularMessageField(value: &_storage._optionalUint64Wrapper) }() + case 206: try { try decoder.decodeSingularMessageField(value: &_storage._optionalFloatWrapper) }() + case 207: try { try decoder.decodeSingularMessageField(value: &_storage._optionalDoubleWrapper) }() + case 208: try { try decoder.decodeSingularMessageField(value: &_storage._optionalStringWrapper) }() + case 209: try { try decoder.decodeSingularMessageField(value: &_storage._optionalBytesWrapper) }() + case 211: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedBoolWrapper) }() + case 212: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedInt32Wrapper) }() + case 213: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedInt64Wrapper) }() + case 214: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedUint32Wrapper) }() + case 215: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedUint64Wrapper) }() + case 216: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedFloatWrapper) }() + case 217: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedDoubleWrapper) }() + case 218: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedStringWrapper) }() + case 219: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedBytesWrapper) }() + case 301: try { try decoder.decodeSingularMessageField(value: &_storage._optionalDuration) }() + case 302: try { try decoder.decodeSingularMessageField(value: &_storage._optionalTimestamp) }() + case 303: try { try decoder.decodeSingularMessageField(value: &_storage._optionalFieldMask) }() + case 304: try { try decoder.decodeSingularMessageField(value: &_storage._optionalStruct) }() + case 305: try { try decoder.decodeSingularMessageField(value: &_storage._optionalAny) }() + case 306: try { try decoder.decodeSingularMessageField(value: &_storage._optionalValue) }() + case 307: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNullValue) }() + case 311: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedDuration) }() + case 312: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedTimestamp) }() + case 313: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedFieldmask) }() + case 315: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedAny) }() + case 316: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedValue) }() + case 317: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedListValue) }() + case 324: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedStruct) }() + case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldname1) }() + case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName2) }() + case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName3) }() + case 404: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name4_) }() + case 405: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name5) }() + case 406: try { try decoder.decodeSingularInt32Field(value: &_storage._field0Name6) }() + case 407: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName7) }() + case 408: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName8) }() + case 409: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName9) }() + case 410: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName10) }() + case 411: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName11) }() + case 412: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName12) }() + case 413: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName13) }() + case 414: try { try decoder.decodeSingularInt32Field(value: &_storage.__FieldName14) }() + case 415: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name15) }() + case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._field_Name16) }() + case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName17__) }() + case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName18__) }() + default: break + } + } + } + } + + func traverse(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 + if _storage._optionalInt32 != 0 { + try visitor.visitSingularInt32Field(value: _storage._optionalInt32, fieldNumber: 1) + } + if _storage._optionalInt64 != 0 { + try visitor.visitSingularInt64Field(value: _storage._optionalInt64, fieldNumber: 2) + } + if _storage._optionalUint32 != 0 { + try visitor.visitSingularUInt32Field(value: _storage._optionalUint32, fieldNumber: 3) + } + if _storage._optionalUint64 != 0 { + try visitor.visitSingularUInt64Field(value: _storage._optionalUint64, fieldNumber: 4) + } + if _storage._optionalSint32 != 0 { + try visitor.visitSingularSInt32Field(value: _storage._optionalSint32, fieldNumber: 5) + } + if _storage._optionalSint64 != 0 { + try visitor.visitSingularSInt64Field(value: _storage._optionalSint64, fieldNumber: 6) + } + if _storage._optionalFixed32 != 0 { + try visitor.visitSingularFixed32Field(value: _storage._optionalFixed32, fieldNumber: 7) + } + if _storage._optionalFixed64 != 0 { + try visitor.visitSingularFixed64Field(value: _storage._optionalFixed64, fieldNumber: 8) + } + if _storage._optionalSfixed32 != 0 { + try visitor.visitSingularSFixed32Field(value: _storage._optionalSfixed32, fieldNumber: 9) + } + if _storage._optionalSfixed64 != 0 { + try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) + } + if _storage._optionalFloat.bitPattern != 0 { + try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) + } + if _storage._optionalDouble.bitPattern != 0 { + try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) + } + if _storage._optionalBool != false { + try visitor.visitSingularBoolField(value: _storage._optionalBool, fieldNumber: 13) + } + if !_storage._optionalString.isEmpty { + try visitor.visitSingularStringField(value: _storage._optionalString, fieldNumber: 14) + } + if !_storage._optionalBytes.isEmpty { + try visitor.visitSingularBytesField(value: _storage._optionalBytes, fieldNumber: 15) + } + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._optionalForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + if _storage._optionalNestedEnum != .foo { + try visitor.visitSingularEnumField(value: _storage._optionalNestedEnum, fieldNumber: 21) + } + if _storage._optionalForeignEnum != .foreignFoo { + try visitor.visitSingularEnumField(value: _storage._optionalForeignEnum, fieldNumber: 22) + } + if _storage._optionalAliasedEnum != .aliasFoo { + try visitor.visitSingularEnumField(value: _storage._optionalAliasedEnum, fieldNumber: 23) + } + if !_storage._optionalStringPiece.isEmpty { + try visitor.visitSingularStringField(value: _storage._optionalStringPiece, fieldNumber: 24) + } + if !_storage._optionalCord.isEmpty { + try visitor.visitSingularStringField(value: _storage._optionalCord, fieldNumber: 25) + } + try { if let v = _storage._recursiveMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 27) + } }() + if !_storage._repeatedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + } + if !_storage._repeatedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + } + if !_storage._repeatedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + } + if !_storage._repeatedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + } + if !_storage._repeatedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + } + if !_storage._repeatedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + } + if !_storage._repeatedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + } + if !_storage._repeatedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + } + if !_storage._repeatedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + } + if !_storage._repeatedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + } + if !_storage._repeatedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + } + if !_storage._repeatedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + } + if !_storage._repeatedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + } + if !_storage._repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) + } + if !_storage._repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) + } + if !_storage._repeatedNestedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) + } + if !_storage._repeatedForeignMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) + } + if !_storage._repeatedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + } + if !_storage._repeatedForeignEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) + } + if !_storage._repeatedStringPiece.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) + } + if !_storage._repeatedCord.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) + } + if !_storage._mapInt32Int32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Int32, fieldNumber: 56) + } + if !_storage._mapInt64Int64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Int64, fieldNumber: 57) + } + if !_storage._mapUint32Uint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Uint32, fieldNumber: 58) + } + if !_storage._mapUint64Uint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Uint64, fieldNumber: 59) + } + if !_storage._mapSint32Sint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Sint32, fieldNumber: 60) + } + if !_storage._mapSint64Sint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Sint64, fieldNumber: 61) + } + if !_storage._mapFixed32Fixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Fixed32, fieldNumber: 62) + } + if !_storage._mapFixed64Fixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Fixed64, fieldNumber: 63) + } + if !_storage._mapSfixed32Sfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 64) + } + if !_storage._mapSfixed64Sfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 65) + } + if !_storage._mapInt32Float.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Float, fieldNumber: 66) + } + if !_storage._mapInt32Double.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Double, fieldNumber: 67) + } + if !_storage._mapBoolBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolBool, fieldNumber: 68) + } + if !_storage._mapStringString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringString, fieldNumber: 69) + } + if !_storage._mapStringBytes.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 70) + } + if !_storage._mapStringNestedMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringNestedMessage, fieldNumber: 71) + } + if !_storage._mapStringForeignMessage.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 72) + } + if !_storage._mapStringNestedEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringNestedEnum, fieldNumber: 73) + } + if !_storage._mapStringForeignEnum.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringForeignEnum, fieldNumber: 74) + } + if !_storage._packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: _storage._packedInt32, fieldNumber: 75) + } + if !_storage._packedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: _storage._packedInt64, fieldNumber: 76) + } + if !_storage._packedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: _storage._packedUint32, fieldNumber: 77) + } + if !_storage._packedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: _storage._packedUint64, fieldNumber: 78) + } + if !_storage._packedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: _storage._packedSint32, fieldNumber: 79) + } + if !_storage._packedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: _storage._packedSint64, fieldNumber: 80) + } + if !_storage._packedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: _storage._packedFixed32, fieldNumber: 81) + } + if !_storage._packedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: _storage._packedFixed64, fieldNumber: 82) + } + if !_storage._packedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: _storage._packedSfixed32, fieldNumber: 83) + } + if !_storage._packedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: _storage._packedSfixed64, fieldNumber: 84) + } + if !_storage._packedFloat.isEmpty { + try visitor.visitPackedFloatField(value: _storage._packedFloat, fieldNumber: 85) + } + if !_storage._packedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: _storage._packedDouble, fieldNumber: 86) + } + if !_storage._packedBool.isEmpty { + try visitor.visitPackedBoolField(value: _storage._packedBool, fieldNumber: 87) + } + if !_storage._packedNestedEnum.isEmpty { + try visitor.visitPackedEnumField(value: _storage._packedNestedEnum, fieldNumber: 88) + } + if !_storage._unpackedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._unpackedInt32, fieldNumber: 89) + } + if !_storage._unpackedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._unpackedInt64, fieldNumber: 90) + } + if !_storage._unpackedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._unpackedUint32, fieldNumber: 91) + } + if !_storage._unpackedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._unpackedUint64, fieldNumber: 92) + } + if !_storage._unpackedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._unpackedSint32, fieldNumber: 93) + } + if !_storage._unpackedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._unpackedSint64, fieldNumber: 94) + } + if !_storage._unpackedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._unpackedFixed32, fieldNumber: 95) + } + if !_storage._unpackedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._unpackedFixed64, fieldNumber: 96) + } + if !_storage._unpackedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._unpackedSfixed32, fieldNumber: 97) + } + if !_storage._unpackedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._unpackedSfixed64, fieldNumber: 98) + } + if !_storage._unpackedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._unpackedFloat, fieldNumber: 99) + } + if !_storage._unpackedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._unpackedDouble, fieldNumber: 100) + } + if !_storage._unpackedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._unpackedBool, fieldNumber: 101) + } + if !_storage._unpackedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._unpackedNestedEnum, fieldNumber: 102) + } + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case .oneofBool?: try { + guard case .oneofBool(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBoolField(value: v, fieldNumber: 115) + }() + case .oneofUint64?: try { + guard case .oneofUint64(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 116) + }() + case .oneofFloat?: try { + guard case .oneofFloat(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularFloatField(value: v, fieldNumber: 117) + }() + case .oneofDouble?: try { + guard case .oneofDouble(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularDoubleField(value: v, fieldNumber: 118) + }() + case .oneofEnum?: try { + guard case .oneofEnum(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 119) + }() + case .oneofNullValue?: try { + guard case .oneofNullValue(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularEnumField(value: v, fieldNumber: 120) + }() + case nil: break + } + try { if let v = _storage._optionalBoolWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 201) + } }() + try { if let v = _storage._optionalInt32Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 202) + } }() + try { if let v = _storage._optionalInt64Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 203) + } }() + try { if let v = _storage._optionalUint32Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 204) + } }() + try { if let v = _storage._optionalUint64Wrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 205) + } }() + try { if let v = _storage._optionalFloatWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 206) + } }() + try { if let v = _storage._optionalDoubleWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 207) + } }() + try { if let v = _storage._optionalStringWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 208) + } }() + try { if let v = _storage._optionalBytesWrapper { + try visitor.visitSingularMessageField(value: v, fieldNumber: 209) + } }() + if !_storage._repeatedBoolWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedBoolWrapper, fieldNumber: 211) + } + if !_storage._repeatedInt32Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedInt32Wrapper, fieldNumber: 212) + } + if !_storage._repeatedInt64Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedInt64Wrapper, fieldNumber: 213) + } + if !_storage._repeatedUint32Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedUint32Wrapper, fieldNumber: 214) + } + if !_storage._repeatedUint64Wrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedUint64Wrapper, fieldNumber: 215) + } + if !_storage._repeatedFloatWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedFloatWrapper, fieldNumber: 216) + } + if !_storage._repeatedDoubleWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedDoubleWrapper, fieldNumber: 217) + } + if !_storage._repeatedStringWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedStringWrapper, fieldNumber: 218) + } + if !_storage._repeatedBytesWrapper.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedBytesWrapper, fieldNumber: 219) + } + try { if let v = _storage._optionalDuration { + try visitor.visitSingularMessageField(value: v, fieldNumber: 301) + } }() + try { if let v = _storage._optionalTimestamp { + try visitor.visitSingularMessageField(value: v, fieldNumber: 302) + } }() + try { if let v = _storage._optionalFieldMask { + try visitor.visitSingularMessageField(value: v, fieldNumber: 303) + } }() + try { if let v = _storage._optionalStruct { + try visitor.visitSingularMessageField(value: v, fieldNumber: 304) + } }() + try { if let v = _storage._optionalAny { + try visitor.visitSingularMessageField(value: v, fieldNumber: 305) + } }() + try { if let v = _storage._optionalValue { + try visitor.visitSingularMessageField(value: v, fieldNumber: 306) + } }() + if _storage._optionalNullValue != .nullValue { + try visitor.visitSingularEnumField(value: _storage._optionalNullValue, fieldNumber: 307) + } + if !_storage._repeatedDuration.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedDuration, fieldNumber: 311) + } + if !_storage._repeatedTimestamp.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedTimestamp, fieldNumber: 312) + } + if !_storage._repeatedFieldmask.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedFieldmask, fieldNumber: 313) + } + if !_storage._repeatedAny.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedAny, fieldNumber: 315) + } + if !_storage._repeatedValue.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedValue, fieldNumber: 316) + } + if !_storage._repeatedListValue.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedListValue, fieldNumber: 317) + } + if !_storage._repeatedStruct.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedStruct, fieldNumber: 324) + } + if _storage._fieldname1 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldname1, fieldNumber: 401) + } + if _storage._fieldName2 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName2, fieldNumber: 402) + } + if _storage._fieldName3 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName3, fieldNumber: 403) + } + if _storage._field_Name4_ != 0 { + try visitor.visitSingularInt32Field(value: _storage._field_Name4_, fieldNumber: 404) + } + if _storage._field0Name5 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field0Name5, fieldNumber: 405) + } + if _storage._field0Name6 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field0Name6, fieldNumber: 406) + } + if _storage._fieldName7 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName7, fieldNumber: 407) + } + if _storage._fieldName8 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName8, fieldNumber: 408) + } + if _storage._fieldName9 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName9, fieldNumber: 409) + } + if _storage._fieldName10 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName10, fieldNumber: 410) + } + if _storage._fieldName11 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName11, fieldNumber: 411) + } + if _storage._fieldName12 != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName12, fieldNumber: 412) + } + if _storage.__FieldName13 != 0 { + try visitor.visitSingularInt32Field(value: _storage.__FieldName13, fieldNumber: 413) + } + if _storage.__FieldName14 != 0 { + try visitor.visitSingularInt32Field(value: _storage.__FieldName14, fieldNumber: 414) + } + if _storage._field_Name15 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field_Name15, fieldNumber: 415) + } + if _storage._field_Name16 != 0 { + try visitor.visitSingularInt32Field(value: _storage._field_Name16, fieldNumber: 416) + } + if _storage._fieldName17__ != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName17__, fieldNumber: 417) + } + if _storage._fieldName18__ != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldName18__, fieldNumber: 418) + } + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3, rhs: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} + if _storage._optionalAliasedEnum != rhs_storage._optionalAliasedEnum {return false} + if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} + if _storage._optionalCord != rhs_storage._optionalCord {return false} + if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} + if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} + if _storage._repeatedCord != rhs_storage._repeatedCord {return false} + if _storage._packedInt32 != rhs_storage._packedInt32 {return false} + if _storage._packedInt64 != rhs_storage._packedInt64 {return false} + if _storage._packedUint32 != rhs_storage._packedUint32 {return false} + if _storage._packedUint64 != rhs_storage._packedUint64 {return false} + if _storage._packedSint32 != rhs_storage._packedSint32 {return false} + if _storage._packedSint64 != rhs_storage._packedSint64 {return false} + if _storage._packedFixed32 != rhs_storage._packedFixed32 {return false} + if _storage._packedFixed64 != rhs_storage._packedFixed64 {return false} + if _storage._packedSfixed32 != rhs_storage._packedSfixed32 {return false} + if _storage._packedSfixed64 != rhs_storage._packedSfixed64 {return false} + if _storage._packedFloat != rhs_storage._packedFloat {return false} + if _storage._packedDouble != rhs_storage._packedDouble {return false} + if _storage._packedBool != rhs_storage._packedBool {return false} + if _storage._packedNestedEnum != rhs_storage._packedNestedEnum {return false} + if _storage._unpackedInt32 != rhs_storage._unpackedInt32 {return false} + if _storage._unpackedInt64 != rhs_storage._unpackedInt64 {return false} + if _storage._unpackedUint32 != rhs_storage._unpackedUint32 {return false} + if _storage._unpackedUint64 != rhs_storage._unpackedUint64 {return false} + if _storage._unpackedSint32 != rhs_storage._unpackedSint32 {return false} + if _storage._unpackedSint64 != rhs_storage._unpackedSint64 {return false} + if _storage._unpackedFixed32 != rhs_storage._unpackedFixed32 {return false} + if _storage._unpackedFixed64 != rhs_storage._unpackedFixed64 {return false} + if _storage._unpackedSfixed32 != rhs_storage._unpackedSfixed32 {return false} + if _storage._unpackedSfixed64 != rhs_storage._unpackedSfixed64 {return false} + if _storage._unpackedFloat != rhs_storage._unpackedFloat {return false} + if _storage._unpackedDouble != rhs_storage._unpackedDouble {return false} + if _storage._unpackedBool != rhs_storage._unpackedBool {return false} + if _storage._unpackedNestedEnum != rhs_storage._unpackedNestedEnum {return false} + if _storage._mapInt32Int32 != rhs_storage._mapInt32Int32 {return false} + if _storage._mapInt64Int64 != rhs_storage._mapInt64Int64 {return false} + if _storage._mapUint32Uint32 != rhs_storage._mapUint32Uint32 {return false} + if _storage._mapUint64Uint64 != rhs_storage._mapUint64Uint64 {return false} + if _storage._mapSint32Sint32 != rhs_storage._mapSint32Sint32 {return false} + if _storage._mapSint64Sint64 != rhs_storage._mapSint64Sint64 {return false} + if _storage._mapFixed32Fixed32 != rhs_storage._mapFixed32Fixed32 {return false} + if _storage._mapFixed64Fixed64 != rhs_storage._mapFixed64Fixed64 {return false} + if _storage._mapSfixed32Sfixed32 != rhs_storage._mapSfixed32Sfixed32 {return false} + if _storage._mapSfixed64Sfixed64 != rhs_storage._mapSfixed64Sfixed64 {return false} + if _storage._mapInt32Float != rhs_storage._mapInt32Float {return false} + if _storage._mapInt32Double != rhs_storage._mapInt32Double {return false} + if _storage._mapBoolBool != rhs_storage._mapBoolBool {return false} + if _storage._mapStringString != rhs_storage._mapStringString {return false} + if _storage._mapStringBytes != rhs_storage._mapStringBytes {return false} + if _storage._mapStringNestedMessage != rhs_storage._mapStringNestedMessage {return false} + if _storage._mapStringForeignMessage != rhs_storage._mapStringForeignMessage {return false} + if _storage._mapStringNestedEnum != rhs_storage._mapStringNestedEnum {return false} + if _storage._mapStringForeignEnum != rhs_storage._mapStringForeignEnum {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + if _storage._optionalBoolWrapper != rhs_storage._optionalBoolWrapper {return false} + if _storage._optionalInt32Wrapper != rhs_storage._optionalInt32Wrapper {return false} + if _storage._optionalInt64Wrapper != rhs_storage._optionalInt64Wrapper {return false} + if _storage._optionalUint32Wrapper != rhs_storage._optionalUint32Wrapper {return false} + if _storage._optionalUint64Wrapper != rhs_storage._optionalUint64Wrapper {return false} + if _storage._optionalFloatWrapper != rhs_storage._optionalFloatWrapper {return false} + if _storage._optionalDoubleWrapper != rhs_storage._optionalDoubleWrapper {return false} + if _storage._optionalStringWrapper != rhs_storage._optionalStringWrapper {return false} + if _storage._optionalBytesWrapper != rhs_storage._optionalBytesWrapper {return false} + if _storage._repeatedBoolWrapper != rhs_storage._repeatedBoolWrapper {return false} + if _storage._repeatedInt32Wrapper != rhs_storage._repeatedInt32Wrapper {return false} + if _storage._repeatedInt64Wrapper != rhs_storage._repeatedInt64Wrapper {return false} + if _storage._repeatedUint32Wrapper != rhs_storage._repeatedUint32Wrapper {return false} + if _storage._repeatedUint64Wrapper != rhs_storage._repeatedUint64Wrapper {return false} + if _storage._repeatedFloatWrapper != rhs_storage._repeatedFloatWrapper {return false} + if _storage._repeatedDoubleWrapper != rhs_storage._repeatedDoubleWrapper {return false} + if _storage._repeatedStringWrapper != rhs_storage._repeatedStringWrapper {return false} + if _storage._repeatedBytesWrapper != rhs_storage._repeatedBytesWrapper {return false} + if _storage._optionalDuration != rhs_storage._optionalDuration {return false} + if _storage._optionalTimestamp != rhs_storage._optionalTimestamp {return false} + if _storage._optionalFieldMask != rhs_storage._optionalFieldMask {return false} + if _storage._optionalStruct != rhs_storage._optionalStruct {return false} + if _storage._optionalAny != rhs_storage._optionalAny {return false} + if _storage._optionalValue != rhs_storage._optionalValue {return false} + if _storage._optionalNullValue != rhs_storage._optionalNullValue {return false} + if _storage._repeatedDuration != rhs_storage._repeatedDuration {return false} + if _storage._repeatedTimestamp != rhs_storage._repeatedTimestamp {return false} + if _storage._repeatedFieldmask != rhs_storage._repeatedFieldmask {return false} + if _storage._repeatedStruct != rhs_storage._repeatedStruct {return false} + if _storage._repeatedAny != rhs_storage._repeatedAny {return false} + if _storage._repeatedValue != rhs_storage._repeatedValue {return false} + if _storage._repeatedListValue != rhs_storage._repeatedListValue {return false} + if _storage._fieldname1 != rhs_storage._fieldname1 {return false} + if _storage._fieldName2 != rhs_storage._fieldName2 {return false} + if _storage._fieldName3 != rhs_storage._fieldName3 {return false} + if _storage._field_Name4_ != rhs_storage._field_Name4_ {return false} + if _storage._field0Name5 != rhs_storage._field0Name5 {return false} + if _storage._field0Name6 != rhs_storage._field0Name6 {return false} + if _storage._fieldName7 != rhs_storage._fieldName7 {return false} + if _storage._fieldName8 != rhs_storage._fieldName8 {return false} + if _storage._fieldName9 != rhs_storage._fieldName9 {return false} + if _storage._fieldName10 != rhs_storage._fieldName10 {return false} + if _storage._fieldName11 != rhs_storage._fieldName11 {return false} + if _storage._fieldName12 != rhs_storage._fieldName12 {return false} + if _storage.__FieldName13 != rhs_storage.__FieldName13 {return false} + if _storage.__FieldName14 != rhs_storage.__FieldName14 {return false} + if _storage._field_Name15 != rhs_storage._field_Name15 {return false} + if _storage._field_Name16 != rhs_storage._field_Name16 {return false} + if _storage._fieldName17__ != rhs_storage._fieldName17__ {return false} + if _storage._fieldName18__ != rhs_storage._fieldName18__ {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") +} + +extension ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.AliasedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ALIAS_FOO\0\u{1}ALIAS_BAR\0\u{9}ALIAS_BAZ\0\u{3}MOO\0moo\0bAz\0") +} + +extension ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0") + + fileprivate class _StorageClass { + var _a: Int32 = 0 + var _corecursive: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _corecursive = source._corecursive + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._corecursive) }() + default: break + } + } + } + } + + func traverse(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 + if _storage._a != 0 { + try visitor.visitSingularInt32Field(value: _storage._a, fieldNumber: 1) + } + try { if let v = _storage._corecursive { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage, rhs: ProtobufTestMessages_Editions_Proto3_TestAllTypesProto3.NestedMessage) -> 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._a != rhs_storage._a {return false} + if _storage._corecursive != rhs_storage._corecursive {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto3_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") + + 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.c) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.c != 0 { + try visitor.visitSingularInt32Field(value: self.c, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto3_ForeignMessage, rhs: ProtobufTestMessages_Editions_Proto3_ForeignMessage) -> Bool { + if lhs.c != rhs.c {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto3_NullHypothesisProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NullHypothesisProto3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto3_NullHypothesisProto3, rhs: ProtobufTestMessages_Editions_Proto3_NullHypothesisProto3) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto3_EnumOnlyProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EnumOnlyProto3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: ProtobufTestMessages_Editions_Proto3_EnumOnlyProto3, rhs: ProtobufTestMessages_Editions_Proto3_EnumOnlyProto3) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension ProtobufTestMessages_Editions_Proto3_EnumOnlyProto3.BoolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0kFalse\0\u{1}kTrue\0") +} diff --git a/Sources/Conformance/text_format_failure_list_swift.txt b/Sources/Conformance/text_format_failure_list_swift.txt index 1c270799d..a2f881b47 100644 --- a/Sources/Conformance/text_format_failure_list_swift.txt +++ b/Sources/Conformance/text_format_failure_list_swift.txt @@ -1 +1 @@ -# No known failures +# No known failures. diff --git a/Sources/SwiftProtobuf/AnyMessageStorage.swift b/Sources/SwiftProtobuf/AnyMessageStorage.swift index 754a3f065..6b961a95e 100644 --- a/Sources/SwiftProtobuf/AnyMessageStorage.swift +++ b/Sources/SwiftProtobuf/AnyMessageStorage.swift @@ -1,4 +1,4 @@ -// Sources/SwiftProtobuf/AnyMessageStorage.swift - Custom stroage for Any WKT +// Sources/SwiftProtobuf/AnyMessageStorage.swift - Custom storage for Any WKT // // Copyright (c) 2014 - 2017 Apple Inc. and the project authors // Licensed under Apache License v2.0 with Runtime Library Exception @@ -15,299 +15,313 @@ import Foundation -#if !swift(>=4.2) -private let i_2166136261 = Int(bitPattern: 2166136261) -private let i_16777619 = Int(16777619) -#endif - -fileprivate func serializeAnyJSON( - for message: Message, - typeURL: String, - options: JSONEncodingOptions +private func serializeAnyJSON( + for message: any Message, + typeURL: String, + options: JSONEncodingOptions ) throws -> String { - var visitor = try JSONEncodingVisitor(type: type(of: message), options: options) - visitor.startObject(message: message) - visitor.encodeField(name: "@type", stringValue: typeURL) - if let m = message as? _CustomJSONCodable { - let value = try m.encodedJSONString(options: options) - visitor.encodeField(name: "value", jsonText: value) - } else { - try message.traverse(visitor: &visitor) - } - visitor.endObject() - return visitor.stringResult + var visitor = try JSONEncodingVisitor(type: type(of: message), options: options) + visitor.startObject(message: message) + visitor.encodeField(name: "@type", stringValue: typeURL) + if let m = message as? (any _CustomJSONCodable) { + let value = try m.encodedJSONString(options: options) + visitor.encodeField(name: "value", jsonText: value) + } else { + try message.traverse(visitor: &visitor) + } + visitor.endObject() + return visitor.stringResult } -fileprivate func emitVerboseTextForm(visitor: inout TextFormatEncodingVisitor, message: Message, typeURL: String) { - let url: String - if typeURL.isEmpty { - url = buildTypeURL(forMessage: message, typePrefix: defaultAnyTypeURLPrefix) - } else { - url = typeURL - } - visitor.visitAnyVerbose(value: message, typeURL: url) +private func emitVerboseTextForm(visitor: inout TextFormatEncodingVisitor, message: any Message, typeURL: String) { + let url: String + if typeURL.isEmpty { + url = buildTypeURL(forMessage: message, typePrefix: defaultAnyTypeURLPrefix) + } else { + url = typeURL + } + visitor.visitAnyVerbose(value: message, typeURL: url) } -fileprivate func asJSONObject(body: Data) -> Data { - let asciiOpenCurlyBracket = UInt8(ascii: "{") - let asciiCloseCurlyBracket = UInt8(ascii: "}") - var result = Data([asciiOpenCurlyBracket]) - result.append(body) - result.append(asciiCloseCurlyBracket) - return result +private func asJSONObject(body: [UInt8]) -> Data { + let asciiOpenCurlyBracket = UInt8(ascii: "{") + let asciiCloseCurlyBracket = UInt8(ascii: "}") + var result = [asciiOpenCurlyBracket] + result.append(contentsOf: body) + result.append(asciiCloseCurlyBracket) + return Data(result) } -fileprivate func unpack(contentJSON: Data, - extensions: ExtensionMap, - options: JSONDecodingOptions, - as messageType: Message.Type) throws -> Message { - guard messageType is _CustomJSONCodable.Type else { - let contentJSONAsObject = asJSONObject(body: contentJSON) - return try messageType.init(jsonUTF8Data: contentJSONAsObject, extensions: extensions, options: options) - } - - var value = String() - try contentJSON.withUnsafeBytes { (body: UnsafeRawBufferPointer) in - if body.count > 0 { - // contentJSON will be the valid JSON for inside an object (everything but - // the '{' and '}', so minimal validation is needed. - var scanner = JSONScanner(source: body, options: options, extensions: extensions) - while !scanner.complete { - let key = try scanner.nextQuotedString() - try scanner.skipRequiredColon() - if key == "value" { - value = try scanner.skip() - break - } - if !options.ignoreUnknownFields { - // The only thing within a WKT should be "value". - throw AnyUnpackError.malformedWellKnownTypeJSON +private func unpack( + contentJSON: [UInt8], + extensions: any ExtensionMap, + options: JSONDecodingOptions, + as messageType: any Message.Type +) throws -> any Message { + guard messageType is any _CustomJSONCodable.Type else { + let contentJSONAsObject = asJSONObject(body: contentJSON) + return try messageType.init(jsonUTF8Bytes: contentJSONAsObject, extensions: extensions, options: options) + } + + var value = String() + try contentJSON.withUnsafeBytes { (body: UnsafeRawBufferPointer) in + if body.count > 0 { + // contentJSON will be the valid JSON for inside an object (everything but + // the '{' and '}', so minimal validation is needed. + var scanner = JSONScanner(source: body, options: options, extensions: extensions) + while !scanner.complete { + let key = try scanner.nextQuotedString() + try scanner.skipRequiredColon() + if key == "value" { + value = try scanner.skip() + break + } + if !options.ignoreUnknownFields { + // The only thing within a WKT should be "value". + throw AnyUnpackError.malformedWellKnownTypeJSON + } + let _ = try scanner.skip() + try scanner.skipRequiredComma() + } + if !options.ignoreUnknownFields && !scanner.complete { + // If that wasn't the end, then there was another key, and WKTs should + // only have the one when not skipping unknowns. + throw AnyUnpackError.malformedWellKnownTypeJSON + } } - let _ = try scanner.skip() - try scanner.skipRequiredComma() - } - if !options.ignoreUnknownFields && !scanner.complete { - // If that wasn't the end, then there was another key, and WKTs should - // only have the one when not skipping unknowns. - throw AnyUnpackError.malformedWellKnownTypeJSON - } } - } - return try messageType.init(jsonString: value, extensions: extensions, options: options) + return try messageType.init(jsonString: value, extensions: extensions, options: options) } internal class AnyMessageStorage { - // The two properties generated Google_Protobuf_Any will reference. - var _typeURL = String() - var _value: Data { - // Remapped to the internal `state`. - get { - switch state { - case .binary(let value): - return value - case .message(let message): - do { - return try message.serializedData(partial: true) - } catch { - return Data() - } - case .contentJSON(let contentJSON, let options): - guard let messageType = Google_Protobuf_Any.messageType(forTypeURL: _typeURL) else { - return Data() + // The two properties generated Google_Protobuf_Any will reference. + var _typeURL = String() + var _value: Data { + // Remapped to the internal `state`. + get { + switch state { + case .binary(let value): + return Data(value) + case .message(let message): + do { + return try message.serializedBytes(partial: true) + } catch { + return Data() + } + case .contentJSON(let contentJSON, let options): + guard let messageType = Google_Protobuf_Any.messageType(forTypeURL: _typeURL) else { + return Data() + } + do { + let m = try unpack( + contentJSON: contentJSON, + extensions: SimpleExtensionMap(), + options: options, + as: messageType + ) + return try m.serializedBytes(partial: true) + } catch { + return Data() + } + } } - do { - let m = try unpack(contentJSON: contentJSON, - extensions: SimpleExtensionMap(), - options: options, - as: messageType) - return try m.serializedData(partial: true) - } catch { - return Data() + set { + state = .binary(newValue) } - } } - set { - state = .binary(newValue) + + enum InternalState { + // a serialized binary + // Note: Unlike contentJSON below, binary does not bother to capture the + // decoding options. This is because the actual binary format is the binary + // blob, i.e. - when decoding from binary, the spec doesn't include decoding + // the binary blob, it is pass through. Instead there is a public api for + // unpacking that takes new options when a developer decides to decode it. + case binary(Data) + // a message + case message(any Message) + // parsed JSON with the @type removed and the decoding options. + case contentJSON([UInt8], JSONDecodingOptions) } - } - - enum InternalState { - // a serialized binary - // Note: Unlike contentJSON below, binary does not bother to capture the - // decoding options. This is because the actual binary format is the binary - // blob, i.e. - when decoding from binary, the spec doesn't include decoding - // the binary blob, it is pass through. Instead there is a public api for - // unpacking that takes new options when a developer decides to decode it. - case binary(Data) - // a message - case message(Message) - // parsed JSON with the @type removed and the decoding options. - case contentJSON(Data, JSONDecodingOptions) - } - var state: InternalState = .binary(Data()) - - static let defaultInstance = AnyMessageStorage() - - private init() {} - - init(copying source: AnyMessageStorage) { - _typeURL = source._typeURL - state = source.state - } - - func isA(_ type: M.Type) -> Bool { - if _typeURL.isEmpty { - return false + var state: InternalState = .binary(Data()) + + // 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 = AnyMessageStorage() + + private init() {} + + init(copying source: AnyMessageStorage) { + _typeURL = source._typeURL + state = source.state } - let encodedType = typeName(fromURL: _typeURL) - return encodedType == M.protoMessageName - } - - // This is only ever called with the expectation that target will be fully - // replaced during the unpacking and never as a merge. - func unpackTo( - target: inout M, - extensions: ExtensionMap?, - options: BinaryDecodingOptions - ) throws { - guard isA(M.self) else { - throw AnyUnpackError.typeMismatch + + func isA(_ type: M.Type) -> Bool { + if _typeURL.isEmpty { + return false + } + let encodedType = typeName(fromURL: _typeURL) + return encodedType == M.protoMessageName } - switch state { - case .binary(let data): - target = try M(serializedData: data, extensions: extensions, partial: true, options: options) - - case .message(let msg): - if let message = msg as? M { - // Already right type, copy it over. - target = message - } else { - // Different type, serialize and parse. - let data = try msg.serializedData(partial: true) - target = try M(serializedData: data, extensions: extensions, partial: true) - } - - case .contentJSON(let contentJSON, let options): - target = try unpack(contentJSON: contentJSON, - extensions: extensions ?? SimpleExtensionMap(), - options: options, - as: M.self) as! M + // This is only ever called with the expectation that target will be fully + // replaced during the unpacking and never as a merge. + func unpackTo( + target: inout M, + extensions: (any ExtensionMap)?, + options: BinaryDecodingOptions + ) throws { + guard isA(M.self) else { + throw AnyUnpackError.typeMismatch + } + + switch state { + case .binary(let data): + target = try M(serializedBytes: data, extensions: extensions, partial: true, options: options) + + case .message(let msg): + if let message = msg as? M { + // Already right type, copy it over. + target = message + } else { + // Different type, serialize and parse. + let bytes: [UInt8] = try msg.serializedBytes(partial: true) + target = try M(serializedBytes: bytes, extensions: extensions, partial: true) + } + + case .contentJSON(let contentJSON, let options): + target = + try unpack( + contentJSON: contentJSON, + extensions: extensions ?? SimpleExtensionMap(), + options: options, + as: M.self + ) as! M + } } - } - - // Called before the message is traversed to do any error preflights. - // Since traverse() will use _value, this is our chance to throw - // when _value can't. - func preTraverse() throws { - switch state { - case .binary: - // Nothing to be checked. - break - - case .message: - // When set from a developer provided message, partial support - // is done. Any message that comes in from another format isn't - // checked, and transcoding the isInitialized requirement is - // never inserted. - break - - case .contentJSON(let contentJSON, let options): - // contentJSON requires we have the type available for decoding - guard let messageType = Google_Protobuf_Any.messageType(forTypeURL: _typeURL) else { - throw BinaryEncodingError.anyTranscodeFailure - } - do { - // Decodes the full JSON and then discard the result. - // The regular traversal will decode this again by querying the - // `value` field, but that has no way to fail. As a result, - // we need this to accurately handle decode errors. - _ = try unpack(contentJSON: contentJSON, - extensions: SimpleExtensionMap(), - options: options, - as: messageType) - } catch { - throw BinaryEncodingError.anyTranscodeFailure - } + + // Called before the message is traversed to do any error preflights. + // Since traverse() will use _value, this is our chance to throw + // when _value can't. + func preTraverse() throws { + switch state { + case .binary: + // Nothing to be checked. + break + + case .message: + // When set from a developer provided message, partial support + // is done. Any message that comes in from another format isn't + // checked, and transcoding the isInitialized requirement is + // never inserted. + break + + case .contentJSON(let contentJSON, let options): + // contentJSON requires we have the type available for decoding. + guard let messageType = Google_Protobuf_Any.messageType(forTypeURL: _typeURL) else { + throw BinaryEncodingError.anyTranscodeFailure + } + do { + // Decodes the full JSON and then discard the result. + // The regular traversal will decode this again by querying the + // `value` field, but that has no way to fail. As a result, + // we need this to accurately handle decode errors. + _ = try unpack( + contentJSON: contentJSON, + extensions: SimpleExtensionMap(), + options: options, + as: messageType + ) + } catch { + throw BinaryEncodingError.anyTranscodeFailure + } + } } - } } /// Custom handling for Text format. extension AnyMessageStorage { - func decodeTextFormat(typeURL url: String, decoder: inout TextFormatDecoder) throws { - // Decoding the verbose form requires knowing the type. - _typeURL = url - guard let messageType = Google_Protobuf_Any.messageType(forTypeURL: url) else { - // The type wasn't registered, can't parse it. - throw TextFormatDecodingError.malformedText - } - let terminator = try decoder.scanner.skipObjectStart() - var subDecoder = try TextFormatDecoder(messageType: messageType, scanner: decoder.scanner, terminator: terminator) - if messageType == Google_Protobuf_Any.self { - var any = Google_Protobuf_Any() - try any.decodeTextFormat(decoder: &subDecoder) - state = .message(any) - } else { - var m = messageType.init() - try m.decodeMessage(decoder: &subDecoder) - state = .message(m) - } - decoder.scanner = subDecoder.scanner - if try decoder.nextFieldNumber() != nil { - // Verbose any can never have additional keys. - throw TextFormatDecodingError.malformedText - } - } - - // Specialized traverse for writing out a Text form of the Any. - // This prefers the more-legible "verbose" format if it can - // use it, otherwise will fall back to simpler forms. - internal func textTraverse(visitor: inout TextFormatEncodingVisitor) { - switch state { - case .binary(let valueData): - if let messageType = Google_Protobuf_Any.messageType(forTypeURL: _typeURL) { - // If we can decode it, we can write the readable verbose form: - do { - let m = try messageType.init(serializedData: valueData, partial: true) - emitVerboseTextForm(visitor: &visitor, message: m, typeURL: _typeURL) - return - } catch { - // Fall through to just print the type and raw binary data + func decodeTextFormat(typeURL url: String, decoder: inout TextFormatDecoder) throws { + // Decoding the verbose form requires knowing the type. + _typeURL = url + guard let messageType = Google_Protobuf_Any.messageType(forTypeURL: url) else { + // The type wasn't registered, can't parse it. + throw TextFormatDecodingError.malformedText } - } - if !_typeURL.isEmpty { - try! visitor.visitSingularStringField(value: _typeURL, fieldNumber: 1) - } - if !valueData.isEmpty { - try! visitor.visitSingularBytesField(value: valueData, fieldNumber: 2) - } - - case .message(let msg): - emitVerboseTextForm(visitor: &visitor, message: msg, typeURL: _typeURL) - - case .contentJSON(let contentJSON, let options): - // If we can decode it, we can write the readable verbose form: - if let messageType = Google_Protobuf_Any.messageType(forTypeURL: _typeURL) { - do { - let m = try unpack(contentJSON: contentJSON, - extensions: SimpleExtensionMap(), - options: options, - as: messageType) - emitVerboseTextForm(visitor: &visitor, message: m, typeURL: _typeURL) - return - } catch { - // Fall through to just print the raw JSON data + let terminator = try decoder.scanner.skipObjectStart() + var subDecoder = try TextFormatDecoder( + messageType: messageType, + scanner: decoder.scanner, + terminator: terminator + ) + if messageType == Google_Protobuf_Any.self { + var any = Google_Protobuf_Any() + try any.decodeTextFormat(decoder: &subDecoder) + state = .message(any) + } else { + var m = messageType.init() + try m.decodeMessage(decoder: &subDecoder) + state = .message(m) + } + decoder.scanner = subDecoder.scanner + if try decoder.nextFieldNumber() != nil { + // Verbose any can never have additional keys. + throw TextFormatDecodingError.malformedText + } + } + + // Specialized traverse for writing out a Text form of the Any. + // This prefers the more-legible "verbose" format if it can + // use it, otherwise will fall back to simpler forms. + internal func textTraverse(visitor: inout TextFormatEncodingVisitor) { + switch state { + case .binary(let valueData): + if let messageType = Google_Protobuf_Any.messageType(forTypeURL: _typeURL) { + // If we can decode it, we can write the readable verbose form: + do { + let m = try messageType.init(serializedBytes: valueData, partial: true) + emitVerboseTextForm(visitor: &visitor, message: m, typeURL: _typeURL) + return + } catch { + // Fall through to just print the type and raw binary data. + } + } + if !_typeURL.isEmpty { + try! visitor.visitSingularStringField(value: _typeURL, fieldNumber: 1) + } + if !valueData.isEmpty { + try! visitor.visitSingularBytesField(value: valueData, fieldNumber: 2) + } + + case .message(let msg): + emitVerboseTextForm(visitor: &visitor, message: msg, typeURL: _typeURL) + + case .contentJSON(let contentJSON, let options): + // If we can decode it, we can write the readable verbose form: + if let messageType = Google_Protobuf_Any.messageType(forTypeURL: _typeURL) { + do { + let m = try unpack( + contentJSON: contentJSON, + extensions: SimpleExtensionMap(), + options: options, + as: messageType + ) + emitVerboseTextForm(visitor: &visitor, message: m, typeURL: _typeURL) + return + } catch { + // Fall through to just print the raw JSON data + } + } + if !_typeURL.isEmpty { + try! visitor.visitSingularStringField(value: _typeURL, fieldNumber: 1) + } + // Build a readable form of the JSON: + let contentJSONAsObject = asJSONObject(body: contentJSON) + visitor.visitAnyJSONBytesField(value: contentJSONAsObject) } - } - if !_typeURL.isEmpty { - try! visitor.visitSingularStringField(value: _typeURL, fieldNumber: 1) - } - // Build a readable form of the JSON: - let contentJSONAsObject = asJSONObject(body: contentJSON) - visitor.visitAnyJSONDataField(value: contentJSONAsObject) } - } } /// The obvious goal for Hashable/Equatable conformance would be for @@ -323,175 +337,197 @@ extension AnyMessageStorage { /// test. Of course, regardless of the above, we must guarantee that /// hashValue is compatible with equality. extension AnyMessageStorage { -#if swift(>=4.2) - // Can't use _valueData for a few reasons: - // 1. Since decode is done on demand, two objects could be equal - // but created differently (one from JSON, one for Message, etc.), - // and the hash values have to be equal even if we don't have data - // yet. - // 2. map<> serialization order is undefined. At the time of writing - // the Swift, Objective-C, and Go runtimes all tend to have random - // orders, so the messages could be identical, but in binary form - // they could differ. - public func hash(into hasher: inout Hasher) { - if !_typeURL.isEmpty { - hasher.combine(_typeURL) - } - } -#else // swift(>=4.2) - var hashValue: Int { - var hash: Int = i_2166136261 - if !_typeURL.isEmpty { - hash = (hash &* i_16777619) ^ _typeURL.hashValue + // Can't use _valueData for a few reasons: + // 1. Since decode is done on demand, two objects could be equal + // but created differently (one from JSON, one for Message, etc.), + // and the hash values have to be equal even if we don't have data + // yet. + // 2. map<> serialization order is undefined. At the time of writing + // the Swift, Objective-C, and Go runtimes all tend to have random + // orders, so the messages could be identical, but in binary form + // they could differ. + public func hash(into hasher: inout Hasher) { + if !_typeURL.isEmpty { + hasher.combine(_typeURL) + } } - return hash - } -#endif // swift(>=4.2) - func isEqualTo(other: AnyMessageStorage) -> Bool { - if (_typeURL != other._typeURL) { - return false - } + func isEqualTo(other: AnyMessageStorage) -> Bool { + if _typeURL != other._typeURL { + return false + } - // Since the library does lazy Any decode, equality is a very hard problem. - // It things exactly match, that's pretty easy, otherwise, one ends up having - // to error on saying they aren't equal. - // - // The best option would be to have Message forms and compare those, as that - // removes issues like map<> serialization order, some other protocol buffer - // implementation details/bugs around serialized form order, etc.; but that - // would also greatly slow down equality tests. - // - // Do our best to compare what is present have... - - // If both have messages, check if they are the same. - if case .message(let myMsg) = state, case .message(let otherMsg) = other.state, type(of: myMsg) == type(of: otherMsg) { - // Since the messages are known to be same type, we can claim both equal and - // not equal based on the equality comparison. - return myMsg.isEqualTo(message: otherMsg) - } + // Since the library does lazy Any decode, equality is a very hard problem. + // It things exactly match, that's pretty easy, otherwise, one ends up having + // to error on saying they aren't equal. + // + // The best option would be to have Message forms and compare those, as that + // removes issues like map<> serialization order, some other protocol buffer + // implementation details/bugs around serialized form order, etc.; but that + // would also greatly slow down equality tests. + // + // Do our best to compare what is present have... + + // If both have messages, check if they are the same. + if case .message(let myMsg) = state, case .message(let otherMsg) = other.state, + type(of: myMsg) == type(of: otherMsg) + { + // Since the messages are known to be same type, we can claim both equal and + // not equal based on the equality comparison. + return myMsg.isEqualTo(message: otherMsg) + } - // If both have serialized data, and they exactly match; the messages are equal. - // Because there could be map in the message, the fact that the data isn't the - // same doesn't always mean the messages aren't equal. Likewise, the binary could - // have been created by a library that doesn't order the fields, or the binary was - // created using the appending ability in of the binary format. - if case .binary(let myValue) = state, case .binary(let otherValue) = other.state, myValue == otherValue { - return true - } + // If both have serialized data, and they exactly match; the messages are equal. + // Because there could be map in the message, the fact that the data isn't the + // same doesn't always mean the messages aren't equal. Likewise, the binary could + // have been created by a library that doesn't order the fields, or the binary was + // created using the appending ability in of the binary format. + if case .binary(let myValue) = state, case .binary(let otherValue) = other.state, myValue == otherValue { + return true + } - // If both have contentJSON, and they exactly match; the messages are equal. - // Because there could be map in the message (or the JSON could just be in a different - // order), the fact that the JSON isn't the same doesn't always mean the messages - // aren't equal. - if case .contentJSON(let myJSON, _) = state, - case .contentJSON(let otherJSON, _) = other.state, - myJSON == otherJSON { - return true - } + // If both have contentJSON, and they exactly match; the messages are equal. + // Because there could be map in the message (or the JSON could just be in a different + // order), the fact that the JSON isn't the same doesn't always mean the messages + // aren't equal. + if case .contentJSON(let myJSON, _) = state, + case .contentJSON(let otherJSON, _) = other.state, + myJSON == otherJSON + { + return true + } - // Out of options. To do more compares, the states conversions would have to be - // done to do comparisions; and since equality can be used somewhat removed from - // a developer (if they put protos in a Set, use them as keys to a Dictionary, etc), - // the conversion cost might be to high for those uses. Give up and say they aren't equal. - return false - } + // Out of options. To do more compares, the states conversions would have to be + // done to do comparisons; and since equality can be used somewhat removed from + // a developer (if they put protos in a Set, use them as keys to a Dictionary, etc), + // the conversion cost might be to high for those uses. Give up and say they aren't equal. + return false + } } // _CustomJSONCodable support for Google_Protobuf_Any extension AnyMessageStorage { - // Override the traversal-based JSON encoding - // This builds an Any JSON representation from one of: - // * The message we were initialized with, - // * The JSON fields we last deserialized, or - // * The protobuf field we were deserialized from. - // The last case requires locating the type, deserializing - // into an object, then reserializing back to JSON. - func encodedJSONString(options: JSONEncodingOptions) throws -> String { - switch state { - case .binary(let valueData): - // Follow the C++ protostream_objectsource.cc's - // ProtoStreamObjectSource::RenderAny() special casing of an empty value. - guard !valueData.isEmpty else { - if _typeURL.isEmpty { - return "{}" - } - var jsonEncoder = JSONEncoder() - jsonEncoder.startField(name: "@type") - jsonEncoder.putStringValue(value: _typeURL) - jsonEncoder.endObject() - return jsonEncoder.stringResult - } - // Transcode by decoding the binary data to a message object - // and then recode back into JSON. - guard let messageType = Google_Protobuf_Any.messageType(forTypeURL: _typeURL) else { - // If we don't have the type available, we can't decode the - // binary value, so we're stuck. (The Google spec does not - // provide a way to just package the binary value for someone - // else to decode later.) - throw JSONEncodingError.anyTranscodeFailure - } - let m = try messageType.init(serializedData: valueData, partial: true) - return try serializeAnyJSON(for: m, typeURL: _typeURL, options: options) - - case .message(let msg): - // We should have been initialized with a typeURL, but - // ensure it wasn't cleared. - let url = !_typeURL.isEmpty ? _typeURL : buildTypeURL(forMessage: msg, typePrefix: defaultAnyTypeURLPrefix) - return try serializeAnyJSON(for: msg, typeURL: url, options: options) - - case .contentJSON(let contentJSON, _): - var jsonEncoder = JSONEncoder() - jsonEncoder.startObject() - jsonEncoder.startField(name: "@type") - jsonEncoder.putStringValue(value: _typeURL) - if !contentJSON.isEmpty { - jsonEncoder.append(staticText: ",") - // NOTE: This doesn't really take `options` into account since it is - // just reflecting out what was taken in originally. - jsonEncoder.append(utf8Data: contentJSON) - } - jsonEncoder.endObject() - return jsonEncoder.stringResult + // Spec for Any says this should contain atleast one slash. Looking at upstream languages, most + // actually look up the value in their runtime registries, but since we do deferred parsing + // we can't assume the registry is complete, thus just do this minimal validation check. + fileprivate func isTypeURLValid() -> Bool { + _typeURL.contains("/") } - } - - // TODO: If the type is well-known or has already been registered, - // we should consider decoding eagerly. Eager decoding would - // catch certain errors earlier (good) but would probably be - // a performance hit if the Any contents were never accessed (bad). - // Of course, we can't always decode eagerly (we don't always have the - // message type available), so the deferred logic here is still needed. - func decodeJSON(from decoder: inout JSONDecoder) throws { - try decoder.scanner.skipRequiredObjectStart() - // Reset state - _typeURL = String() - state = .binary(Data()) - if decoder.scanner.skipOptionalObjectEnd() { - return + + // Override the traversal-based JSON encoding + // This builds an Any JSON representation from one of: + // * The message we were initialized with, + // * The JSON fields we last deserialized, or + // * The protobuf field we were deserialized from. + // The last case requires locating the type, deserializing + // into an object, then reserializing back to JSON. + func encodedJSONString(options: JSONEncodingOptions) throws -> String { + switch state { + case .binary(let valueData): + // Follow the C++ protostream_objectsource.cc's + // ProtoStreamObjectSource::RenderAny() special casing of an empty value. + if valueData.isEmpty && _typeURL.isEmpty { + return "{}" + } + guard isTypeURLValid() else { + if _typeURL.isEmpty { + throw SwiftProtobufError.JSONEncoding.emptyAnyTypeURL() + } + throw SwiftProtobufError.JSONEncoding.invalidAnyTypeURL(type_url: _typeURL) + } + if valueData.isEmpty { + var jsonEncoder = JSONEncoder() + jsonEncoder.startObject() + jsonEncoder.startField(name: "@type") + jsonEncoder.putStringValue(value: _typeURL) + jsonEncoder.endObject() + return jsonEncoder.stringResult + } + // Transcode by decoding the binary data to a message object + // and then recode back into JSON. + guard let messageType = Google_Protobuf_Any.messageType(forTypeURL: _typeURL) else { + // If we don't have the type available, we can't decode the + // binary value, so we're stuck. (The Google spec does not + // provide a way to just package the binary value for someone + // else to decode later.) + throw JSONEncodingError.anyTranscodeFailure + } + let m = try messageType.init(serializedBytes: valueData, partial: true) + return try serializeAnyJSON(for: m, typeURL: _typeURL, options: options) + + case .message(let msg): + // We should have been initialized with a typeURL, make sure it is valid. + if !_typeURL.isEmpty && !isTypeURLValid() { + throw SwiftProtobufError.JSONEncoding.invalidAnyTypeURL(type_url: _typeURL) + } + // If it was cleared, default it. + let url = !_typeURL.isEmpty ? _typeURL : buildTypeURL(forMessage: msg, typePrefix: defaultAnyTypeURLPrefix) + return try serializeAnyJSON(for: msg, typeURL: url, options: options) + + case .contentJSON(let contentJSON, _): + guard isTypeURLValid() else { + if _typeURL.isEmpty { + throw SwiftProtobufError.JSONEncoding.emptyAnyTypeURL() + } + throw SwiftProtobufError.JSONEncoding.invalidAnyTypeURL(type_url: _typeURL) + } + var jsonEncoder = JSONEncoder() + jsonEncoder.startObject() + jsonEncoder.startField(name: "@type") + jsonEncoder.putStringValue(value: _typeURL) + if !contentJSON.isEmpty { + jsonEncoder.append(staticText: ",") + // NOTE: This doesn't really take `options` into account since it is + // just reflecting out what was taken in originally. + jsonEncoder.append(utf8Bytes: contentJSON) + } + jsonEncoder.endObject() + return jsonEncoder.stringResult + } } - var jsonEncoder = JSONEncoder() - while true { - let key = try decoder.scanner.nextQuotedString() - try decoder.scanner.skipRequiredColon() - if key == "@type" { - _typeURL = try decoder.scanner.nextQuotedString() - } else { - jsonEncoder.startField(name: key) - let keyValueJSON = try decoder.scanner.skip() - jsonEncoder.append(text: keyValueJSON) - } - if decoder.scanner.skipOptionalObjectEnd() { - // Capture the options, but set the messageDepthLimit to be what - // was left right now, as that is the limit when the JSON is finally - // parsed. - var updatedOptions = decoder.options - updatedOptions.messageDepthLimit = decoder.scanner.recursionBudget - state = .contentJSON(jsonEncoder.dataResult, updatedOptions) - return - } - try decoder.scanner.skipRequiredComma() + // TODO: If the type is well-known or has already been registered, + // we should consider decoding eagerly. Eager decoding would + // catch certain errors earlier (good) but would probably be + // a performance hit if the Any contents were never accessed (bad). + // Of course, we can't always decode eagerly (we don't always have the + // message type available), so the deferred logic here is still needed. + func decodeJSON(from decoder: inout JSONDecoder) throws { + try decoder.scanner.skipRequiredObjectStart() + // Reset state + _typeURL = String() + state = .binary(Data()) + if decoder.scanner.skipOptionalObjectEnd() { + return + } + + var jsonEncoder = JSONEncoder() + while true { + let key = try decoder.scanner.nextQuotedString() + try decoder.scanner.skipRequiredColon() + if key == "@type" { + _typeURL = try decoder.scanner.nextQuotedString() + guard isTypeURLValid() else { + throw SwiftProtobufError.JSONDecoding.invalidAnyTypeURL(type_url: _typeURL) + } + } else { + jsonEncoder.startField(name: key) + let keyValueJSON = try decoder.scanner.skip() + jsonEncoder.append(text: keyValueJSON) + } + if decoder.scanner.skipOptionalObjectEnd() { + if _typeURL.isEmpty { + throw SwiftProtobufError.JSONDecoding.emptyAnyTypeURL() + } + // Capture the options, but set the messageDepthLimit to be what + // was left right now, as that is the limit when the JSON is finally + // parsed. + var updatedOptions = decoder.options + updatedOptions.messageDepthLimit = decoder.scanner.recursionBudget + state = .contentJSON(Array(jsonEncoder.dataResult), updatedOptions) + return + } + try decoder.scanner.skipRequiredComma() + } } - } } diff --git a/Sources/SwiftProtobuf/AnyUnpackError.swift b/Sources/SwiftProtobuf/AnyUnpackError.swift index 738b0fe9a..a67f4055a 100644 --- a/Sources/SwiftProtobuf/AnyUnpackError.swift +++ b/Sources/SwiftProtobuf/AnyUnpackError.swift @@ -22,16 +22,16 @@ /// regular decoding operation. There are also other errors that can occur due /// to problems with the `Any` value's structure. public enum AnyUnpackError: Error { - /// The `type_url` field in the `Google_Protobuf_Any` message did not match - /// the message type provided to the `unpack()` method. - case typeMismatch + /// The `type_url` field in the `Google_Protobuf_Any` message did not match + /// the message type provided to the `unpack()` method. + case typeMismatch - /// Well-known types being decoded from JSON must have only two fields: the - /// `@type` field and a `value` field containing the specialized JSON coding - /// of the well-known type. - case malformedWellKnownTypeJSON + /// Well-known types being decoded from JSON must have only two fields: the + /// `@type` field and a `value` field containing the specialized JSON coding + /// of the well-known type. + case malformedWellKnownTypeJSON - /// The `Google_Protobuf_Any` message was malformed in some other way not - /// covered by the other error cases. - case malformedAnyField + /// The `Google_Protobuf_Any` message was malformed in some other way not + /// covered by the other error cases. + case malformedAnyField } diff --git a/Sources/SwiftProtobuf/AsyncMessageSequence.swift b/Sources/SwiftProtobuf/AsyncMessageSequence.swift new file mode 100644 index 000000000..c54ecce33 --- /dev/null +++ b/Sources/SwiftProtobuf/AsyncMessageSequence.swift @@ -0,0 +1,217 @@ +// +// Sources/SwiftProtobuf/AsyncMessageSequence.swift - Async sequence over binary delimited protobuf +// +// Copyright (c) 2023 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// An async sequence of messages decoded from a binary delimited protobuf stream. +/// +// ----------------------------------------------------------------------------- + +@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) +extension AsyncSequence where Element == UInt8 { + /// Creates an asynchronous sequence of size-delimited messages from this sequence of bytes. + /// Delimited format allows a single file or stream to contain multiple messages. A delimited message + /// is a varint encoding the message size followed by a message of exactly that size. + /// + /// - Parameters: + /// - messageType: The type of message to read. + /// - extensions: An ``ExtensionMap`` used to look up and decode any extensions in + /// messages encoded by this sequence, or in messages nested within these messages. + /// - partial: If `false` (the default), after decoding a message, ``Message/isInitialized-6abgi` + /// will be checked to ensure all fields are present. + /// - options: The ``BinaryDecodingOptions`` to use. + /// - Returns: An asynchronous sequence of messages read from the `AsyncSequence` of bytes. + @inlinable + public func binaryProtobufDelimitedMessages( + of messageType: M.Type = M.self, + extensions: (any ExtensionMap)? = nil, + partial: Bool = false, + options: BinaryDecodingOptions = BinaryDecodingOptions() + ) -> AsyncMessageSequence { + AsyncMessageSequence( + base: self, + extensions: extensions, + partial: partial, + options: options + ) + } +} + +/// An asynchronous sequence of messages decoded from an asynchronous sequence of bytes. +@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) +public struct AsyncMessageSequence< + Base: AsyncSequence, + M: Message +>: AsyncSequence where Base.Element == UInt8 { + + /// The message type in this asynchronous sequence. + public typealias Element = M + + private let base: Base + private let extensions: (any ExtensionMap)? + private let partial: Bool + private let options: BinaryDecodingOptions + + /// Reads size-delimited messages from the given sequence of bytes. Delimited + /// format allows a single file or stream to contain multiple messages. A delimited message + /// is a varint encoding the message size followed by a message of exactly that size. + /// + /// - Parameters: + /// - baseSequence: The `AsyncSequence` to read messages from. + /// - extensions: An ``ExtensionMap`` used to look up and decode any extensions in + /// messages encoded by this sequence, or in messages nested within these messages. + /// - partial: If `false` (the default), after decoding a message, ``Message/isInitialized-6abgi`` + /// will be checked to ensure all fields are present. + /// - options: The ``BinaryDecodingOptions`` to use. + /// - Returns: An asynchronous sequence of messages read from the `AsyncSequence` of bytes. + public init( + base: Base, + extensions: (any ExtensionMap)? = nil, + partial: Bool = false, + options: BinaryDecodingOptions = BinaryDecodingOptions() + ) { + self.base = base + self.extensions = extensions + self.partial = partial + self.options = options + } + + /// An asynchronous iterator that produces the messages of this asynchronous sequence. + public struct AsyncIterator: AsyncIteratorProtocol { + @usableFromInline + var iterator: Base.AsyncIterator? + @usableFromInline + let extensions: (any ExtensionMap)? + @usableFromInline + let partial: Bool + @usableFromInline + let options: BinaryDecodingOptions + + init( + iterator: Base.AsyncIterator, + extensions: (any ExtensionMap)?, + partial: Bool, + options: BinaryDecodingOptions + ) { + self.iterator = iterator + self.extensions = extensions + self.partial = partial + self.options = options + } + + /// Asynchronously reads the next varint. + @inlinable + mutating func nextVarInt() async throws -> UInt64? { + var messageSize: UInt64 = 0 + var shift: UInt64 = 0 + + while let byte = try await iterator?.next() { + messageSize |= UInt64(byte & 0x7f) << shift + shift += UInt64(7) + if shift > 35 { + iterator = nil + throw SwiftProtobufError.BinaryStreamDecoding.malformedLength() + } + if byte & 0x80 == 0 { + return messageSize + } + } + if shift > 0 { + // The stream has ended inside a varint. + iterator = nil + throw BinaryDelimited.Error.truncated + } + return nil // End of stream reached. + } + + /// Helper to read the given number of bytes. + @usableFromInline + mutating func readBytes(_ size: Int) async throws -> [UInt8] { + // Even though the bytes are read in chunks, things can still hard fail if + // there isn't enough memory to append to have all the bytes at once for + // parsing; but this at least catches some possible OOM attacks. + var bytesNeeded = size + var buffer = [UInt8]() + let kChunkSize = 16 * 1024 * 1024 + var chunk = [UInt8](repeating: 0, count: Swift.min(bytesNeeded, kChunkSize)) + while bytesNeeded > 0 { + var consumedBytes = 0 + let maxLength = Swift.min(bytesNeeded, chunk.count) + while consumedBytes < maxLength { + guard let byte = try await iterator?.next() else { + // The iterator hit the end, but the chunk wasn't filled, so the full + // payload wasn't read. + throw BinaryDelimited.Error.truncated + } + chunk[consumedBytes] = byte + consumedBytes += 1 + } + if consumedBytes < chunk.count { + buffer += chunk[0.. M? { + guard let messageSize = try await nextVarInt() else { + iterator = nil + return nil + } + guard messageSize <= UInt64(0x7fff_ffff) else { + iterator = nil + throw SwiftProtobufError.BinaryDecoding.tooLarge() + } + if messageSize == 0 { + return try M( + serializedBytes: [], + extensions: extensions, + partial: partial, + options: options + ) + } + let buffer = try await readBytes(Int(messageSize)) + return try M( + serializedBytes: buffer, + extensions: extensions, + partial: partial, + options: options + ) + } + } + + /// Creates the asynchronous iterator that produces elements of this + /// asynchronous sequence. + /// + /// - Returns: An instance of the `AsyncIterator` type used to produce + /// messages in the asynchronous sequence. + public func makeAsyncIterator() -> AsyncMessageSequence.AsyncIterator { + AsyncIterator( + iterator: base.makeAsyncIterator(), + extensions: extensions, + partial: partial, + options: options + ) + } +} + +@available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) +extension AsyncMessageSequence: Sendable where Base: Sendable {} + +@available(*, unavailable) +extension AsyncMessageSequence.AsyncIterator: Sendable {} diff --git a/Sources/SwiftProtobuf/BinaryDecoder.swift b/Sources/SwiftProtobuf/BinaryDecoder.swift index d5b0ebc8b..3407f73ab 100644 --- a/Sources/SwiftProtobuf/BinaryDecoder.swift +++ b/Sources/SwiftProtobuf/BinaryDecoder.swift @@ -19,13 +19,13 @@ import Foundation internal struct BinaryDecoder: Decoder { // Current position - private var p : UnsafeRawPointer + private var p: UnsafeRawPointer // Remaining bytes in input. - private var available : Int + private var available: Int // Position of start of field currently being parsed - private var fieldStartP : UnsafeRawPointer + private var fieldStartP: UnsafeRawPointer // Position of end of field currently being parsed, nil if we don't know. - private var fieldEndP : UnsafeRawPointer? + private var fieldEndP: UnsafeRawPointer? // Whether or not the field value has actually been parsed private var consumed = true // Wire format for last-examined field @@ -33,7 +33,7 @@ internal struct BinaryDecoder: Decoder { // Field number for last-parsed field tag private var fieldNumber: Int = 0 // Collection of extension fields for this decode - private var extensions: ExtensionMap? + private var extensions: (any ExtensionMap)? // The current group number. See decodeFullGroup(group:fieldNumber:) for how // this is used. private var groupFieldNumber: Int? @@ -48,13 +48,13 @@ internal struct BinaryDecoder: Decoder { // packed repeated enums; see below private var unknownOverride: Data? - private var complete: Bool {return available == 0} + private var complete: Bool { available == 0 } internal init( - forReadingFrom pointer: UnsafeRawPointer, - count: Int, - options: BinaryDecodingOptions, - extensions: ExtensionMap? = nil + forReadingFrom pointer: UnsafeRawPointer, + count: Int, + options: BinaryDecodingOptions, + extensions: (any ExtensionMap)? = nil ) { // Assuming baseAddress is not nil. p = pointer @@ -66,15 +66,17 @@ internal struct BinaryDecoder: Decoder { } internal init( - forReadingFrom pointer: UnsafeRawPointer, - count: Int, - parent: BinaryDecoder + forReadingFrom pointer: UnsafeRawPointer, + count: Int, + parent: BinaryDecoder ) { - self.init(forReadingFrom: pointer, - count: count, - options: parent.options, - extensions: parent.extensions) - recursionBudget = parent.recursionBudget + self.init( + forReadingFrom: pointer, + count: count, + options: parent.options, + extensions: parent.extensions + ) + recursionBudget = parent.recursionBudget } private mutating func incrementRecursionDepth() throws { @@ -153,27 +155,27 @@ internal struct BinaryDecoder: Decoder { let c1 = start[1] if (c1 & 0x80) == 0 { p += 2 - available -= 2 - fieldNumber |= Int(c1) << 4 + available &-= 2 + fieldNumber |= Int(c1) &<< 4 } else { - fieldNumber |= Int(c1 & 0x7f) << 4 + fieldNumber |= Int(c1 & 0x7f) &<< 4 if available < 3 { throw BinaryDecodingError.malformedProtobuf } let c2 = start[2] - fieldNumber |= Int(c2 & 0x7f) << 11 + fieldNumber |= Int(c2 & 0x7f) &<< 11 if (c2 & 0x80) == 0 { p += 3 - available -= 3 + available &-= 3 } else { if available < 4 { throw BinaryDecodingError.malformedProtobuf } let c3 = start[3] - fieldNumber |= Int(c3 & 0x7f) << 18 + fieldNumber |= Int(c3 & 0x7f) &<< 18 if (c3 & 0x80) == 0 { p += 4 - available -= 4 + available &-= 4 } else { if available < 5 { throw BinaryDecodingError.malformedProtobuf @@ -182,9 +184,9 @@ internal struct BinaryDecoder: Decoder { if c4 > 15 { throw BinaryDecodingError.malformedProtobuf } - fieldNumber |= Int(c4 & 0x7f) << 25 + fieldNumber |= Int(c4 & 0x7f) &<< 25 p += 5 - available -= 5 + available &-= 5 } } } @@ -212,7 +214,7 @@ internal struct BinaryDecoder: Decoder { guard fieldWireFormat == WireFormat.fixed32 else { return } - try decodeFourByteNumber(value: &value) + value = try decodeFloat() consumed = true } @@ -537,9 +539,7 @@ internal struct BinaryDecoder: Decoder { guard fieldWireFormat == WireFormat.fixed32 else { return } - var i: UInt32 = 0 - try decodeFourByteNumber(value: &i) - value = UInt32(littleEndian: i) + value = try decodeLittleEndianInteger() consumed = true } @@ -547,28 +547,22 @@ internal struct BinaryDecoder: Decoder { guard fieldWireFormat == WireFormat.fixed32 else { return } - var i: UInt32 = 0 - try decodeFourByteNumber(value: &i) - value = UInt32(littleEndian: i) + value = try decodeLittleEndianInteger() consumed = true } internal mutating func decodeRepeatedFixed32Field(value: inout [UInt32]) throws { switch fieldWireFormat { case WireFormat.fixed32: - var i: UInt32 = 0 - try decodeFourByteNumber(value: &i) - value.append(UInt32(littleEndian: i)) + value.append(try decodeLittleEndianInteger()) consumed = true case WireFormat.lengthDelimited: var n: Int = 0 let p = try getFieldBodyBytes(count: &n) value.reserveCapacity(value.count + n / MemoryLayout.size) var decoder = BinaryDecoder(forReadingFrom: p, count: n, parent: self) - var i: UInt32 = 0 while !decoder.complete { - try decoder.decodeFourByteNumber(value: &i) - value.append(UInt32(littleEndian: i)) + value.append(try decoder.decodeLittleEndianInteger()) } consumed = true default: @@ -580,9 +574,7 @@ internal struct BinaryDecoder: Decoder { guard fieldWireFormat == WireFormat.fixed64 else { return } - var i: UInt64 = 0 - try decodeEightByteNumber(value: &i) - value = UInt64(littleEndian: i) + value = try decodeLittleEndianInteger() consumed = true } @@ -590,28 +582,22 @@ internal struct BinaryDecoder: Decoder { guard fieldWireFormat == WireFormat.fixed64 else { return } - var i: UInt64 = 0 - try decodeEightByteNumber(value: &i) - value = UInt64(littleEndian: i) + value = try decodeLittleEndianInteger() consumed = true } internal mutating func decodeRepeatedFixed64Field(value: inout [UInt64]) throws { switch fieldWireFormat { case WireFormat.fixed64: - var i: UInt64 = 0 - try decodeEightByteNumber(value: &i) - value.append(UInt64(littleEndian: i)) + value.append(try decodeLittleEndianInteger()) consumed = true case WireFormat.lengthDelimited: var n: Int = 0 let p = try getFieldBodyBytes(count: &n) value.reserveCapacity(value.count + n / MemoryLayout.size) var decoder = BinaryDecoder(forReadingFrom: p, count: n, parent: self) - var i: UInt64 = 0 while !decoder.complete { - try decoder.decodeEightByteNumber(value: &i) - value.append(UInt64(littleEndian: i)) + value.append(try decoder.decodeLittleEndianInteger()) } consumed = true default: @@ -623,9 +609,7 @@ internal struct BinaryDecoder: Decoder { guard fieldWireFormat == WireFormat.fixed32 else { return } - var i: Int32 = 0 - try decodeFourByteNumber(value: &i) - value = Int32(littleEndian: i) + value = try decodeLittleEndianInteger() consumed = true } @@ -633,28 +617,22 @@ internal struct BinaryDecoder: Decoder { guard fieldWireFormat == WireFormat.fixed32 else { return } - var i: Int32 = 0 - try decodeFourByteNumber(value: &i) - value = Int32(littleEndian: i) + value = try decodeLittleEndianInteger() consumed = true } internal mutating func decodeRepeatedSFixed32Field(value: inout [Int32]) throws { switch fieldWireFormat { case WireFormat.fixed32: - var i: Int32 = 0 - try decodeFourByteNumber(value: &i) - value.append(Int32(littleEndian: i)) + value.append(try decodeLittleEndianInteger()) consumed = true case WireFormat.lengthDelimited: var n: Int = 0 let p = try getFieldBodyBytes(count: &n) value.reserveCapacity(value.count + n / MemoryLayout.size) var decoder = BinaryDecoder(forReadingFrom: p, count: n, parent: self) - var i: Int32 = 0 while !decoder.complete { - try decoder.decodeFourByteNumber(value: &i) - value.append(Int32(littleEndian: i)) + value.append(try decoder.decodeLittleEndianInteger()) } consumed = true default: @@ -666,9 +644,7 @@ internal struct BinaryDecoder: Decoder { guard fieldWireFormat == WireFormat.fixed64 else { return } - var i: Int64 = 0 - try decodeEightByteNumber(value: &i) - value = Int64(littleEndian: i) + value = try decodeLittleEndianInteger() consumed = true } @@ -676,28 +652,22 @@ internal struct BinaryDecoder: Decoder { guard fieldWireFormat == WireFormat.fixed64 else { return } - var i: Int64 = 0 - try decodeEightByteNumber(value: &i) - value = Int64(littleEndian: i) + value = try decodeLittleEndianInteger() consumed = true } internal mutating func decodeRepeatedSFixed64Field(value: inout [Int64]) throws { switch fieldWireFormat { case WireFormat.fixed64: - var i: Int64 = 0 - try decodeEightByteNumber(value: &i) - value.append(Int64(littleEndian: i)) + value.append(try decodeLittleEndianInteger()) consumed = true case WireFormat.lengthDelimited: var n: Int = 0 let p = try getFieldBodyBytes(count: &n) value.reserveCapacity(value.count + n / MemoryLayout.size) var decoder = BinaryDecoder(forReadingFrom: p, count: n, parent: self) - var i: Int64 = 0 while !decoder.complete { - try decoder.decodeEightByteNumber(value: &i) - value.append(Int64(littleEndian: i)) + value.append(try decoder.decodeLittleEndianInteger()) } consumed = true default: @@ -821,18 +791,18 @@ internal struct BinaryDecoder: Decoder { internal mutating func decodeSingularEnumField(value: inout E?) throws where E.RawValue == Int { guard fieldWireFormat == WireFormat.varint else { - return - } + return + } let varint = try decodeVarint() if let v = E(rawValue: Int(Int32(truncatingIfNeeded: varint))) { value = v consumed = true } - } + } internal mutating func decodeSingularEnumField(value: inout E) throws where E.RawValue == Int { guard fieldWireFormat == WireFormat.varint else { - return + return } let varint = try decodeVarint() if let v = E(rawValue: Int(Int32(truncatingIfNeeded: varint))) { @@ -871,17 +841,16 @@ internal struct BinaryDecoder: Decoder { if let extras = extras { let fieldTag = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) let bodySize = extras.reduce(0) { $0 + Varint.encodedSize(of: Int64($1)) } - let fieldSize = Varint.encodedSize(of: fieldTag.rawValue) + Varint.encodedSize(of: Int64(bodySize)) + bodySize + let fieldSize = + Varint.encodedSize(of: fieldTag.rawValue) + Varint.encodedSize(of: Int64(bodySize)) + bodySize var field = Data(count: fieldSize) field.withUnsafeMutableBytes { (body: UnsafeMutableRawBufferPointer) in - if let baseAddress = body.baseAddress, body.count > 0 { - var encoder = BinaryEncoder(forWritingInto: baseAddress) + var encoder = BinaryEncoder(forWritingInto: body) encoder.startField(tag: fieldTag) encoder.putVarInt(value: Int64(bodySize)) for v in extras { encoder.putVarInt(value: Int64(v)) } - } } unknownOverride = field } @@ -919,16 +888,16 @@ internal struct BinaryDecoder: Decoder { } internal mutating func decodeFullMessage(message: inout M) throws { - assert(unknownData == nil) - try incrementRecursionDepth() - try message.decodeMessage(decoder: &self) - decrementRecursionDepth() - guard complete else { - throw BinaryDecodingError.trailingGarbage - } - if let unknownData = unknownData { - message.unknownFields.append(protobufData: unknownData) - } + assert(unknownData == nil) + try incrementRecursionDepth() + try message.decodeMessage(decoder: &self) + decrementRecursionDepth() + guard complete else { + throw BinaryDecodingError.trailingGarbage + } + if let unknownData = unknownData { + message.unknownFields.append(protobufData: unknownData) + } } internal mutating func decodeSingularGroupField(value: inout G?) throws { @@ -981,7 +950,10 @@ internal struct BinaryDecoder: Decoder { return true } - internal mutating func decodeMapField(fieldType: _ProtobufMap.Type, value: inout _ProtobufMap.BaseType) throws { + internal mutating func decodeMapField( + fieldType: _ProtobufMap.Type, + value: inout _ProtobufMap.BaseType + ) throws { guard fieldWireFormat == WireFormat.lengthDelimited else { return } @@ -1000,7 +972,7 @@ internal struct BinaryDecoder: Decoder { try KeyType.decodeSingular(value: &k, from: &subdecoder) case 2: try ValueType.decodeSingular(value: &v, from: &subdecoder) - default: // Skip any other fields within the map entry object + default: // Skip any other fields within the map entry object try subdecoder.skip() } } @@ -1016,7 +988,10 @@ internal struct BinaryDecoder: Decoder { consumed = true } - internal mutating func decodeMapField(fieldType: _ProtobufEnumMap.Type, value: inout _ProtobufEnumMap.BaseType) throws where ValueType.RawValue == Int { + internal mutating func decodeMapField( + fieldType: _ProtobufEnumMap.Type, + value: inout _ProtobufEnumMap.BaseType + ) throws where ValueType.RawValue == Int { guard fieldWireFormat == WireFormat.lengthDelimited else { return } @@ -1031,9 +1006,9 @@ internal struct BinaryDecoder: Decoder { } let fieldNumber = tag.fieldNumber switch fieldNumber { - case 1: // Keys are basic types + case 1: // Keys are basic types try KeyType.decodeSingular(value: &k, from: &subdecoder) - case 2: // Value is an Enum type + case 2: // Value is an Enum type try subdecoder.decodeSingularEnumField(value: &v) if v == nil && tag.wireFormat == .varint { // Enum decode fail and wire format was varint, so this had to @@ -1043,7 +1018,7 @@ internal struct BinaryDecoder: Decoder { // the map entry. return } - default: // Skip any other fields within the map entry object + default: // Skip any other fields within the map entry object try subdecoder.skip() } } @@ -1056,7 +1031,10 @@ internal struct BinaryDecoder: Decoder { consumed = true } - internal mutating func decodeMapField(fieldType: _ProtobufMessageMap.Type, value: inout _ProtobufMessageMap.BaseType) throws { + internal mutating func decodeMapField( + fieldType: _ProtobufMessageMap.Type, + value: inout _ProtobufMessageMap.BaseType + ) throws { guard fieldWireFormat == WireFormat.lengthDelimited else { return } @@ -1071,11 +1049,11 @@ internal struct BinaryDecoder: Decoder { } let fieldNumber = tag.fieldNumber switch fieldNumber { - case 1: // Keys are basic types + case 1: // Keys are basic types try KeyType.decodeSingular(value: &k, from: &subdecoder) - case 2: // Value is a message type + case 2: // Value is a message type try subdecoder.decodeSingularMessageField(value: &v) - default: // Skip any other fields within the map entry object + default: // Skip any other fields within the map entry object try subdecoder.skip() } } @@ -1089,24 +1067,26 @@ internal struct BinaryDecoder: Decoder { } internal mutating func decodeExtensionField( - values: inout ExtensionFieldValueSet, - messageType: Message.Type, - fieldNumber: Int + values: inout ExtensionFieldValueSet, + messageType: any Message.Type, + fieldNumber: Int ) throws { if let ext = extensions?[messageType, fieldNumber] { - try decodeExtensionField(values: &values, - messageType: messageType, - fieldNumber: fieldNumber, - messageExtension: ext) + try decodeExtensionField( + values: &values, + messageType: messageType, + fieldNumber: fieldNumber, + messageExtension: ext + ) } } /// Helper to reuse between Extension decoding and MessageSet Extension decoding. private mutating func decodeExtensionField( - values: inout ExtensionFieldValueSet, - messageType: Message.Type, - fieldNumber: Int, - messageExtension ext: AnyMessageExtension + values: inout ExtensionFieldValueSet, + messageType: any Message.Type, + fieldNumber: Int, + messageExtension ext: any AnyMessageExtension ) throws { assert(!consumed) assert(fieldNumber == ext.fieldNumber) @@ -1130,60 +1110,77 @@ internal struct BinaryDecoder: Decoder { } internal mutating func decodeExtensionFieldsAsMessageSet( - values: inout ExtensionFieldValueSet, - messageType: Message.Type + values: inout ExtensionFieldValueSet, + messageType: any Message.Type ) throws { - // Spin looking for the Item group, everything else will end up in unknown fields. + // Anything not in an acceptable form will go into unknown fields while let fieldNumber = try self.nextFieldNumber() { - guard fieldNumber == WireFormat.MessageSet.FieldNumbers.item && - fieldWireFormat == WireFormat.startGroup else { - continue - } - - // This is similiar to decodeFullGroup + // Normal MessageSet wire format (nested in a group) + if fieldNumber == WireFormat.MessageSet.FieldNumbers.item && fieldWireFormat == WireFormat.startGroup { + // This is similar to decodeFullGroup + + try incrementRecursionDepth() + var subDecoder = self + subDecoder.groupFieldNumber = fieldNumber + subDecoder.consumed = true + + let itemResult = try subDecoder.decodeMessageSetItem( + values: &values, + messageType: messageType + ) + switch itemResult { + case .success: + // Advance over what was parsed. + consume(length: available - subDecoder.available) + consumed = true + case .handleAsUnknown: + // Nothing to do. + break + + case .malformed: + throw BinaryDecodingError.malformedProtobuf + } - try incrementRecursionDepth() - var subDecoder = self - subDecoder.groupFieldNumber = fieldNumber - subDecoder.consumed = true - - let itemResult = try subDecoder.decodeMessageSetItem(values: &values, - messageType: messageType) - switch itemResult { - case .success: - // Advance over what was parsed. - consume(length: available - subDecoder.available) - consumed = true - case .handleAsUnknown: - // Nothing to do. - break - - case .malformed: - throw BinaryDecodingError.malformedProtobuf + assert(recursionBudget == subDecoder.recursionBudget) + decrementRecursionDepth() + } else if fieldWireFormat == WireFormat.lengthDelimited, + let ext = extensions?[messageType, fieldNumber] + { + // This was a raw extension field, this is possible if some encoder doesn't + // know the MessageSet wire format. Since we know the extension, promote it. + // _upb_Decoder_FindField() has this same basic logic. + try decodeExtensionField( + values: &values, + messageType: messageType, + fieldNumber: fieldNumber, + messageExtension: ext + ) + if !consumed { + throw BinaryDecodingError.malformedProtobuf + } } - - assert(recursionBudget == subDecoder.recursionBudget) - decrementRecursionDepth() } } private enum DecodeMessageSetItemResult { - case success - case handleAsUnknown - case malformed + case success + case handleAsUnknown + case malformed } private mutating func decodeMessageSetItem( - values: inout ExtensionFieldValueSet, - messageType: Message.Type + values: inout ExtensionFieldValueSet, + messageType: any Message.Type ) throws -> DecodeMessageSetItemResult { // This is loosely based on the C++: // ExtensionSet::ParseMessageSetItem() // WireFormat::ParseAndMergeMessageSetItem() - // (yes, there have two versions that are almost the same) + // And more implementation seem to draw from: + // upb_Decoder_DecodeMessageSetItem() - var msgExtension: AnyMessageExtension? + var msgExtension: (any AnyMessageExtension)? var fieldData: Data? + var gotData: Bool = false // In this loop, if wire types are wrong, things don't decode, // just bail instead of letting things go into unknown fields. @@ -1195,8 +1192,18 @@ internal struct BinaryDecoder: Decoder { var extensionFieldNumber: Int32 = 0 try decodeSingularInt32Field(value: &extensionFieldNumber) if extensionFieldNumber == 0 { return .malformed } + if let _ = msgExtension { + // The field appears more than once, only the first value counts. + continue + } guard let ext = extensions?[messageType, Int(extensionFieldNumber)] else { - return .handleAsUnknown // Unknown extension. + // At this point it is an unknown extension, so it will be treated as + // an unknown field. + // + // NOTE: There are other repeated `type_id` or `message` fields within + // the group they are preserved. No attempt is made to prune them down + // to be conformant. + return .handleAsUnknown } msgExtension = ext @@ -1204,19 +1211,23 @@ internal struct BinaryDecoder: Decoder { if let data = fieldData { var wasDecoded = false try data.withUnsafeBytes { (body: UnsafeRawBufferPointer) in - if let baseAddress = body.baseAddress, body.count > 0 { - var extDecoder = BinaryDecoder(forReadingFrom: baseAddress, - count: body.count, - parent: self) - // Prime the decode to be correct. - extDecoder.consumed = false - extDecoder.fieldWireFormat = .lengthDelimited - try extDecoder.decodeExtensionField(values: &values, - messageType: messageType, - fieldNumber: fieldNumber, - messageExtension: ext) - wasDecoded = extDecoder.consumed - } + if let baseAddress = body.baseAddress, body.count > 0 { + var extDecoder = BinaryDecoder( + forReadingFrom: baseAddress, + count: body.count, + parent: self + ) + // Prime the decode to be correct. + extDecoder.consumed = false + extDecoder.fieldWireFormat = .lengthDelimited + try extDecoder.decodeExtensionField( + values: &values, + messageType: messageType, + fieldNumber: ext.fieldNumber, + messageExtension: ext + ) + wasDecoded = extDecoder.consumed + } } if !wasDecoded { return .malformed @@ -1225,39 +1236,38 @@ internal struct BinaryDecoder: Decoder { } case WireFormat.MessageSet.FieldNumbers.message: - if let ext = msgExtension { + if gotData { + // first one sticks, skip any additional occurances of the field. + guard fieldWireFormat == .lengthDelimited else { return .malformed } + try skip() + consumed = true + } else if let ext = msgExtension { assert(consumed == false) - try decodeExtensionField(values: &values, - messageType: messageType, - fieldNumber: ext.fieldNumber, - messageExtension: ext) + gotData = true + try decodeExtensionField( + values: &values, + messageType: messageType, + fieldNumber: ext.fieldNumber, + messageExtension: ext + ) if !consumed { return .malformed } } else { - // The C++ references ends up appending the blocks together as length - // delimited blocks, but the parsing will only use the first block. - // So just capture a block, and then skip any others that happen to - // be found. - if fieldData == nil { - var d: Data? - try decodeSingularBytesField(value: &d) - guard let data = d else { return .malformed } - // Save it as length delimited - let payloadSize = Varint.encodedSize(of: Int64(data.count)) + data.count - var payload = Data(count: payloadSize) - payload.withUnsafeMutableBytes { (body: UnsafeMutableRawBufferPointer) in - if let baseAddress = body.baseAddress, body.count > 0 { - var encoder = BinaryEncoder(forWritingInto: baseAddress) - encoder.putBytesValue(value: data) - } - } - fieldData = payload - } else { - guard fieldWireFormat == .lengthDelimited else { return .malformed } - try skip() - consumed = true + // Haven't gotten the type_id yet, to cache the data for later. + assert(fieldData == .none) + var d: Data? + try decodeSingularBytesField(value: &d) + guard let data = d else { return .malformed } + // Save it as length delimited + let payloadSize = Varint.encodedSize(of: Int64(data.count)) + data.count + var payload = Data(count: payloadSize) + payload.withUnsafeMutableBytes { (body: UnsafeMutableRawBufferPointer) in + var encoder = BinaryEncoder(forWritingInto: body) + encoder.putBytesValue(value: data) } + fieldData = payload + gotData = true } default: @@ -1325,7 +1335,7 @@ internal struct BinaryDecoder: Decoder { } } case .endGroup: - throw BinaryDecodingError.malformedProtobuf + throw BinaryDecodingError.truncated case .fixed32: if available < 4 { throw BinaryDecodingError.truncated @@ -1366,7 +1376,7 @@ internal struct BinaryDecoder: Decoder { var length = available var c = start.load(fromByteOffset: 0, as: UInt8.self) start += 1 - length -= 1 + length &-= 1 if c & 0x80 == 0 { p = start available = length @@ -1380,14 +1390,14 @@ internal struct BinaryDecoder: Decoder { } c = start.load(fromByteOffset: 0, as: UInt8.self) start += 1 - length -= 1 - value |= UInt64(c & 0x7f) << shift + length &-= 1 + value |= UInt64(c & 0x7f) &<< shift if c & 0x80 == 0 { p = start available = length return value } - shift += 7 + shift &+= 7 } } @@ -1426,56 +1436,51 @@ internal struct BinaryDecoder: Decoder { return Data(bytes: fieldStartP, count: fieldEndP! - fieldStartP) } - /// Private: decode a fixed-length four-byte number. This generic - /// helper handles all four-byte number types. - private mutating func decodeFourByteNumber(value: inout T) throws { - guard available >= 4 else {throw BinaryDecodingError.truncated} - withUnsafeMutableBytes(of: &value) { dest -> Void in - dest.copyMemory(from: UnsafeRawBufferPointer(start: p, count: 4)) - } - consume(length: 4) - } - - /// Private: decode a fixed-length eight-byte number. This generic - /// helper handles all eight-byte number types. - private mutating func decodeEightByteNumber(value: inout T) throws { - guard available >= 8 else {throw BinaryDecodingError.truncated} - withUnsafeMutableBytes(of: &value) { dest -> Void in - dest.copyMemory(from: UnsafeRawBufferPointer(start: p, count: 8)) - } - consume(length: 8) + /// Private: decode a fixed-length number. + private mutating func decodeLittleEndianInteger() throws -> T { + let size = MemoryLayout.size + assert(size == 4 || size == 8) + guard available >= size else { throw BinaryDecodingError.truncated } + defer { consume(length: size) } + return T(littleEndian: p.loadUnaligned(as: T.self)) } private mutating func decodeFloat() throws -> Float { - var littleEndianBytes: UInt32 = 0 - try decodeFourByteNumber(value: &littleEndianBytes) - var nativeEndianBytes = UInt32(littleEndian: littleEndianBytes) - var float: Float = 0 - let n = MemoryLayout.size - memcpy(&float, &nativeEndianBytes, n) - return float + let nativeEndianBytes: UInt32 = try decodeLittleEndianInteger() + return Float(bitPattern: nativeEndianBytes) } private mutating func decodeDouble() throws -> Double { - var littleEndianBytes: UInt64 = 0 - try decodeEightByteNumber(value: &littleEndianBytes) - var nativeEndianBytes = UInt64(littleEndian: littleEndianBytes) - var double: Double = 0 - let n = MemoryLayout.size - memcpy(&double, &nativeEndianBytes, n) - return double + let nativeEndianBytes: UInt64 = try decodeLittleEndianInteger() + return Double(bitPattern: nativeEndianBytes) } /// Private: Get the start and length for the body of - // a length-delimited field. + /// a length-delimited field. private mutating func getFieldBodyBytes(count: inout Int) throws -> UnsafeRawPointer { let length = try decodeVarint() - if length <= UInt64(available) { - count = Int(length) - let body = p - consume(length: count) - return body + + // Bytes and Strings have a max size of 2GB. And since messages are on + // the wire as bytes/length delimited, they also have a 2GB size limit. + // The upstream C++ does the same sort of enforcement (see + // parse_context, delimited_message_util, message_lite, etc.). + // https://protobuf.dev/programming-guides/encoding/#cheat-sheet + // + // This function does get called in some package decode handling, but + // that is length delimited on the wire, so the spec would imply + // the limit still applies. + guard length < 0x7fff_ffff else { + // Reuse existing error to avoid breaking change of changing thrown error + throw BinaryDecodingError.malformedProtobuf } - throw BinaryDecodingError.truncated + + guard length <= UInt64(available) else { + throw BinaryDecodingError.truncated + } + + count = Int(length) + let body = p + consume(length: count) + return body } } diff --git a/Sources/SwiftProtobuf/BinaryDecodingError.swift b/Sources/SwiftProtobuf/BinaryDecodingError.swift index 016d8ad70..3b19f8303 100644 --- a/Sources/SwiftProtobuf/BinaryDecodingError.swift +++ b/Sources/SwiftProtobuf/BinaryDecodingError.swift @@ -14,31 +14,31 @@ /// Describes errors that can occur when decoding a message from binary format. public enum BinaryDecodingError: Error { - /// Extraneous data remained after decoding should have been complete. - case trailingGarbage + /// Extraneous data remained after decoding should have been complete. + case trailingGarbage - /// The decoder unexpectedly reached the end of the data before it was - /// expected. - case truncated + /// The decoder unexpectedly reached the end of the data before it was + /// expected. + case truncated - /// A string field was not encoded as valid UTF-8. - case invalidUTF8 + /// A string field was not encoded as valid UTF-8. + case invalidUTF8 - /// The binary data was malformed in some way, such as an invalid wire format - /// or field tag. - case malformedProtobuf + /// The binary data was malformed in some way, such as an invalid wire format + /// or field tag. + case malformedProtobuf - /// The definition of the message or one of its nested messages has required - /// fields but the binary data did not include values for them. You must pass - /// `partial: true` during decoding if you wish to explicitly ignore missing - /// required fields. - case missingRequiredFields + /// The definition of the message or one of its nested messages has required + /// fields but the binary data did not include values for them. You must pass + /// `partial: true` during decoding if you wish to explicitly ignore missing + /// required fields. + case missingRequiredFields - /// An internal error happened while decoding. If this is ever encountered, - /// please file an issue with SwiftProtobuf with as much details as possible - /// for what happened (proto definitions, bytes being decoded (if possible)). - case internalExtensionError + /// An internal error happened while decoding. If this is ever encountered, + /// please file an issue with SwiftProtobuf with as much details as possible + /// for what happened (proto definitions, bytes being decoded (if possible)). + case internalExtensionError - /// Reached the nesting limit for messages within messages while decoding. - case messageDepthLimit + /// Reached the nesting limit for messages within messages while decoding. + case messageDepthLimit } diff --git a/Sources/SwiftProtobuf/BinaryDecodingOptions.swift b/Sources/SwiftProtobuf/BinaryDecodingOptions.swift index f00d65026..d78f9080c 100644 --- a/Sources/SwiftProtobuf/BinaryDecodingOptions.swift +++ b/Sources/SwiftProtobuf/BinaryDecodingOptions.swift @@ -13,27 +13,27 @@ // ----------------------------------------------------------------------------- /// Options for binary decoding. -public struct BinaryDecodingOptions { - /// The maximum nesting of message with messages. The default is 100. - /// - /// To prevent corrupt or malicious messages from causing stack overflows, - /// this controls how deep messages can be nested within other messages - /// while parsing. - public var messageDepthLimit: Int = 100 +public struct BinaryDecodingOptions: Sendable { + /// The maximum nesting of message with messages. The default is 100. + /// + /// To prevent corrupt or malicious messages from causing stack overflows, + /// this controls how deep messages can be nested within other messages + /// while parsing. + public var messageDepthLimit: Int = 100 - /// Discard unknown fields while parsing. The default is false, so parsering - /// does not discard unknown fields. - /// - /// The Protobuf binary format allows unknown fields to be still parsed - /// so the schema can be expanded without requiring all readers to be updated. - /// This works in part by haivng any unknown fields preserved so they can - /// be relayed on without loss. For a while the proto3 syntax definition - /// called for unknown fields to be dropped, but that lead to problems in - /// some case. The default is to follow the spec and keep them, but setting - /// this option to `true` allows a developer to strip them during a parse - /// in case they have a specific need to drop the unknown fields from the - /// object graph being created. - public var discardUnknownFields: Bool = false + /// Discard unknown fields while parsing. The default is false, so parsering + /// does not discard unknown fields. + /// + /// The Protobuf binary format allows unknown fields to be still parsed + /// so the schema can be expanded without requiring all readers to be updated. + /// This works in part by having any unknown fields preserved so they can + /// be relayed on without loss. For a while the proto3 syntax definition + /// called for unknown fields to be dropped, but that lead to problems in + /// some case. The default is to follow the spec and keep them, but setting + /// this option to `true` allows a developer to strip them during a parse + /// in case they have a specific need to drop the unknown fields from the + /// object graph being created. + public var discardUnknownFields: Bool = false - public init() {} + public init() {} } diff --git a/Sources/SwiftProtobuf/BinaryDelimited.swift b/Sources/SwiftProtobuf/BinaryDelimited.swift index 10eaf0526..2b46c40cb 100644 --- a/Sources/SwiftProtobuf/BinaryDelimited.swift +++ b/Sources/SwiftProtobuf/BinaryDelimited.swift @@ -14,221 +14,247 @@ #if !os(WASI) import Foundation +#endif /// Helper methods for reading/writing messages with a length prefix. public enum BinaryDelimited { - /// Additional errors for delimited message handing. - public enum Error: Swift.Error { - /// If a read/write to the stream fails, but the stream's `streamError` is nil, - /// this error will be throw instead since the stream didn't provide anything - /// more specific. A common cause for this can be failing to open the stream - /// before trying to read/write to it. - case unknownStreamError - - /// While reading/writing to the stream, less than the expected bytes was - /// read/written. - case truncated - } + /// Additional errors for delimited message handing. + public enum Error: Swift.Error { + /// If a read/write to the stream fails, but the stream's `streamError` is nil, + /// this error will be throw instead since the stream didn't provide anything + /// more specific. A common cause for this can be failing to open the stream + /// before trying to read/write to it. + case unknownStreamError - /// Serialize a single size-delimited message from the given stream. Delimited - /// format allows a single file or stream to contain multiple messages, - /// whereas normally writing multiple non-delimited messages to the same - /// stream would cause them to be merged. A delimited message is a varint - /// encoding the message size followed by a message of exactly that size. - /// - /// - Parameters: - /// - message: The message to be written. - /// - to: The `OutputStream` to write the message to. The stream is - /// is assumed to be ready to be written to. - /// - partial: If `false` (the default), this method will check - /// `Message.isInitialized` before encoding to verify that all required - /// fields are present. If any are missing, this method throws - /// `BinaryEncodingError.missingRequiredFields`. - /// - Throws: `BinaryEncodingError` if encoding fails, throws - /// `BinaryDelimited.Error` for some writing errors, or the - /// underlying `OutputStream.streamError` for a stream error. - public static func serialize( - message: Message, - to stream: OutputStream, - partial: Bool = false - ) throws { - // TODO: Revisit to avoid the extra buffering when encoding is streamed in general. - let serialized = try message.serializedData(partial: partial) - let totalSize = Varint.encodedSize(of: UInt64(serialized.count)) + serialized.count - var data = Data(count: totalSize) - data.withUnsafeMutableBytes { (body: UnsafeMutableRawBufferPointer) in - if let baseAddress = body.baseAddress, body.count > 0 { - var encoder = BinaryEncoder(forWritingInto: baseAddress) - encoder.putBytesValue(value: serialized) - } + /// While reading/writing to the stream, less than the expected bytes was + /// read/written. + case truncated } - var written: Int = 0 - data.withUnsafeBytes { (body: UnsafeRawBufferPointer) in - if let baseAddress = body.baseAddress, body.count > 0 { - // This assumingMemoryBound is technically unsafe, but without SR-11078 - // (https://bugs.swift.org/browse/SR-11087) we don't have another option. - // It should be "safe enough". - let pointer = baseAddress.assumingMemoryBound(to: UInt8.self) - written = stream.write(pointer, maxLength: totalSize) - } - } - - if written != totalSize { - if written == -1 { - if let streamError = stream.streamError { - throw streamError + #if !os(WASI) + /// Serialize a single size-delimited message to the given stream. Delimited + /// format allows a single file or stream to contain multiple messages, + /// whereas normally writing multiple non-delimited messages to the same + /// stream would cause them to be merged. A delimited message is a varint + /// encoding the message size followed by a message of exactly that size. + /// + /// - Parameters: + /// - message: The message to be written. + /// - to: The `OutputStream` to write the message to. The stream is + /// is assumed to be ready to be written to. + /// - partial: If `false` (the default), this method will check + /// ``Message/isInitialized-6abgi`` before encoding to verify that all required + /// fields are present. If any are missing, this method throws + /// ``BinaryDelimited/Error/missingRequiredFields``. + /// - Throws: ``BinaryDelimited/Error`` if encoding fails or some writing errors occur; or the + /// underlying `OutputStream.streamError` for a stream error. + public static func serialize( + message: any Message, + to stream: OutputStream, + partial: Bool = false + ) throws { + // TODO: Revisit to avoid the extra buffering when encoding is streamed in general. + let serialized: [UInt8] = try message.serializedBytes(partial: partial) + let totalSize = Varint.encodedSize(of: UInt64(serialized.count)) + serialized.count + var bytes: [UInt8] = Array(repeating: 0, count: totalSize) + bytes.withUnsafeMutableBytes { (body: UnsafeMutableRawBufferPointer) in + var encoder = BinaryEncoder(forWritingInto: body) + encoder.putBytesValue(value: serialized) } - throw BinaryDelimited.Error.unknownStreamError - } - throw BinaryDelimited.Error.truncated - } - } - /// Reads a single size-delimited message from the given stream. Delimited - /// format allows a single file or stream to contain multiple messages, - /// whereas normally parsing consumes the entire input. A delimited message - /// is a varint encoding the message size followed by a message of exactly - /// exactly that size. - /// - /// - Parameters: - /// - messageType: The type of message to read. - /// - from: The `InputStream` to read the data from. The stream is assumed - /// to be ready to read from. - /// - extensions: An `ExtensionMap` used to look up and decode any - /// extensions in this message or messages nested within this message's - /// fields. - /// - partial: If `false` (the default), this method will check - /// `Message.isInitialized` before encoding to verify that all required - /// fields are present. If any are missing, this method throws - /// `BinaryEncodingError.missingRequiredFields`. - /// - options: The BinaryDecodingOptions to use. - /// - Returns: The message read. - /// - Throws: `BinaryDecodingError` if decoding fails, throws - /// `BinaryDelimited.Error` for some reading errors, and the - /// underlying InputStream.streamError for a stream error. - public static func parse( - messageType: M.Type, - from stream: InputStream, - extensions: ExtensionMap? = nil, - partial: Bool = false, - options: BinaryDecodingOptions = BinaryDecodingOptions() - ) throws -> M { - var message = M() - try merge(into: &message, - from: stream, - extensions: extensions, - partial: partial, - options: options) - return message - } + var written: Int = 0 + bytes.withUnsafeBytes { (body: UnsafeRawBufferPointer) in + if let baseAddress = body.baseAddress, body.count > 0 { + // This assumingMemoryBound is technically unsafe, but without SR-11078 + // (https://bugs.swift.org/browse/SR-11087) we don't have another option. + // It should be "safe enough". + let pointer = baseAddress.assumingMemoryBound(to: UInt8.self) + written = stream.write(pointer, maxLength: totalSize) + } + } - /// Updates the message by reading a single size-delimited message from - /// the given stream. Delimited format allows a single file or stream to - /// contain multiple messages, whereas normally parsing consumes the entire - /// input. A delimited message is a varint encoding the message size - /// followed by a message of exactly that size. - /// - /// - Note: If this method throws an error, the message may still have been - /// partially mutated by the binary data that was decoded before the error - /// occurred. - /// - /// - Parameters: - /// - mergingTo: The message to merge the data into. - /// - from: The `InputStream` to read the data from. The stream is assumed - /// to be ready to read from. - /// - extensions: An `ExtensionMap` used to look up and decode any - /// extensions in this message or messages nested within this message's - /// fields. - /// - partial: If `false` (the default), this method will check - /// `Message.isInitialized` before encoding to verify that all required - /// fields are present. If any are missing, this method throws - /// `BinaryEncodingError.missingRequiredFields`. - /// - options: The BinaryDecodingOptions to use. - /// - Throws: `BinaryDecodingError` if decoding fails, throws - /// `BinaryDelimited.Error` for some reading errors, and the - /// underlying InputStream.streamError for a stream error. - public static func merge( - into message: inout M, - from stream: InputStream, - extensions: ExtensionMap? = nil, - partial: Bool = false, - options: BinaryDecodingOptions = BinaryDecodingOptions() - ) throws { - let length = try Int(decodeVarint(stream)) - if length == 0 { - // The message was all defaults, nothing to actually read. - return + if written != totalSize { + if written == -1 { + if let streamError = stream.streamError { + throw streamError + } + throw BinaryDelimited.Error.unknownStreamError + } + throw BinaryDelimited.Error.truncated + } } - var data = Data(count: length) - var bytesRead: Int = 0 - data.withUnsafeMutableBytes { (body: UnsafeMutableRawBufferPointer) in - if let baseAddress = body.baseAddress, body.count > 0 { - // This assumingMemoryBound is technically unsafe, but without SR-11078 - // (https://bugs.swift.org/browse/SR-11087) we don't have another option. - // It should be "safe enough". - let pointer = baseAddress.assumingMemoryBound(to: UInt8.self) - bytesRead = stream.read(pointer, maxLength: length) - } + /// Reads a single size-delimited message from the given stream. Delimited + /// format allows a single file or stream to contain multiple messages, + /// whereas normally parsing consumes the entire input. A delimited message + /// is a varint encoding the message size followed by a message of exactly + /// exactly that size. + /// + /// - Parameters: + /// - messageType: The type of message to read. + /// - from: The `InputStream` to read the data from. The stream is assumed + /// to be ready to read from. + /// - extensions: An ``ExtensionMap`` used to look up and decode any + /// extensions in this message or messages nested within this message's + /// fields. + /// - partial: If `false` (the default), this method will check + /// ``Message/isInitialized-6abgi`` after decoding to verify that all required + /// fields are present. If any are missing, this method throws + /// ``BinaryDecodingError/missingRequiredFields``. + /// - options: The ``BinaryDecodingOptions`` to use. + /// - Returns: The message read. + /// - Throws: ``BinaryDelimited/Error`` or ``SwiftProtobufError`` if decoding fails, + /// some reading errors; or the underlying `InputStream.streamError` for a stream error. + public static func parse( + messageType: M.Type, + from stream: InputStream, + extensions: (any ExtensionMap)? = nil, + partial: Bool = false, + options: BinaryDecodingOptions = BinaryDecodingOptions() + ) throws -> M { + var message = M() + try merge( + into: &message, + from: stream, + extensions: extensions, + partial: partial, + options: options + ) + return message } - if bytesRead != length { - if bytesRead == -1 { - if let streamError = stream.streamError { - throw streamError + /// Updates the message by reading a single size-delimited message from + /// the given stream. Delimited format allows a single file or stream to + /// contain multiple messages, whereas normally parsing consumes the entire + /// input. A delimited message is a varint encoding the message size + /// followed by a message of exactly that size. + /// + /// - Note: If this method throws an error, the message may still have been + /// partially mutated by the binary data that was decoded before the error + /// occurred. + /// + /// - Parameters: + /// - mergingTo: The message to merge the data into. + /// - from: The `InputStream` to read the data from. The stream is assumed + /// to be ready to read from. + /// - extensions: An ``ExtensionMap`` used to look up and decode any + /// extensions in this message or messages nested within this message's + /// fields. + /// - partial: If `false` (the default), this method will check + /// ``Message/isInitialized-6abgi`` after decoding to verify that all required + /// fields are present. If any are missing, this method throws + /// ``BinaryDelimited/Error/missingRequiredFields``. + /// - options: The BinaryDecodingOptions to use. + /// - Throws: ``BinaryDelimited/Error`` or ``SwiftProtobufError`` if decoding fails, + /// and for some reading errors; or the underlying `InputStream.streamError` for a stream error. + public static func merge( + into message: inout M, + from stream: InputStream, + extensions: (any ExtensionMap)? = nil, + partial: Bool = false, + options: BinaryDecodingOptions = BinaryDecodingOptions() + ) throws { + let unsignedLength = try decodeVarint(stream) + if unsignedLength == 0 { + // The message was all defaults, nothing to actually read. + return } - throw BinaryDelimited.Error.unknownStreamError - } - throw BinaryDelimited.Error.truncated - } + guard unsignedLength <= 0x7fff_ffff else { + // Adding a new case is a breaking change, reuse malformedProtobuf. + throw BinaryDecodingError.malformedProtobuf + } + let length = Int(unsignedLength) + + // TODO: Consider doing a version with getBuffer:length: if the InputStream + // support it and thus avoiding this local copy. - try message.merge(serializedData: data, - extensions: extensions, - partial: partial, - options: options) - } + // Even though the bytes are read in chunks, things can still hard fail if + // there isn't enough memory to append to have all the bytes at once for + // parsing. + var data = [UInt8]() + let kChunkSize = 16 * 1024 * 1024 + var chunk = [UInt8](repeating: 0, count: min(length, kChunkSize)) + var bytesNeeded = length + while bytesNeeded > 0 { + let maxLength = min(bytesNeeded, chunk.count) + var bytesRead: Int = 0 + chunk.withUnsafeMutableBytes { (body: UnsafeMutableRawBufferPointer) in + if let baseAddress = body.baseAddress, body.count > 0 { + let pointer = baseAddress.assumingMemoryBound(to: UInt8.self) + bytesRead = stream.read(pointer, maxLength: maxLength) + } + } + if bytesRead == -1 { + if let streamError = stream.streamError { + throw streamError + } + throw BinaryDelimited.Error.unknownStreamError + } + if bytesRead == 0 { + // Hit the end of the stream + throw BinaryDelimited.Error.truncated + } + if bytesRead < chunk.count { + data += chunk[0.. UInt64 { - // Buffer to reuse within nextByte. - let readBuffer = UnsafeMutablePointer.allocate(capacity: 1) - #if swift(>=4.1) + // Buffer to reuse within nextByte. + let readBuffer = UnsafeMutablePointer.allocate(capacity: 1) defer { readBuffer.deallocate() } - #else - defer { readBuffer.deallocate(capacity: 1) } - #endif - func nextByte() throws -> UInt8 { - let bytesRead = stream.read(readBuffer, maxLength: 1) - if bytesRead != 1 { - if bytesRead == -1 { - if let streamError = stream.streamError { - throw streamError + func nextByte() throws -> UInt8? { + let bytesRead = stream.read(readBuffer, maxLength: 1) + switch bytesRead { + case 1: + return readBuffer[0] + case 0: + return nil + default: + precondition(bytesRead == -1) + if let streamError = stream.streamError { + throw streamError + } + throw BinaryDelimited.Error.unknownStreamError } - throw BinaryDelimited.Error.unknownStreamError - } - throw BinaryDelimited.Error.truncated } - return readBuffer[0] - } - var value: UInt64 = 0 - var shift: UInt64 = 0 - while true { - let c = try nextByte() - value |= UInt64(c & 0x7f) << shift - if c & 0x80 == 0 { - return value - } - shift += 7 - if shift > 63 { - throw BinaryDecodingError.malformedProtobuf + var value: UInt64 = 0 + var shift: UInt64 = 0 + while true { + guard let c = try nextByte() else { + if shift == 0 { + throw SwiftProtobufError.BinaryStreamDecoding.noBytesAvailable() + } + throw BinaryDelimited.Error.truncated + } + value |= UInt64(c & 0x7f) << shift + if c & 0x80 == 0 { + return value + } + shift += 7 + if shift > 63 { + throw BinaryDecodingError.malformedProtobuf + } } - } } -#endif +#endif // !os(WASI) diff --git a/Sources/SwiftProtobuf/BinaryEncoder.swift b/Sources/SwiftProtobuf/BinaryEncoder.swift index a3809c28c..40c0703da 100644 --- a/Sources/SwiftProtobuf/BinaryEncoder.swift +++ b/Sources/SwiftProtobuf/BinaryEncoder.swift @@ -18,9 +18,11 @@ import Foundation /// Encoder for Binary Protocol Buffer format internal struct BinaryEncoder { private var pointer: UnsafeMutableRawPointer + private var buffer: UnsafeMutableRawBufferPointer - init(forWritingInto pointer: UnsafeMutableRawPointer) { - self.pointer = pointer + init(forWritingInto buffer: UnsafeMutableRawBufferPointer) { + self.buffer = buffer + self.pointer = buffer.baseAddress! } private mutating func append(_ byte: UInt8) { @@ -28,29 +30,40 @@ internal struct BinaryEncoder { pointer = pointer.advanced(by: 1) } - private mutating func append(contentsOf data: Data) { - data.withUnsafeBytes { dataPointer in + private mutating func append(contentsOf bytes: Bytes) { + bytes.withUnsafeBytes { dataPointer in if let baseAddress = dataPointer.baseAddress, dataPointer.count > 0 { pointer.copyMemory(from: baseAddress, byteCount: dataPointer.count) - pointer = pointer.advanced(by: dataPointer.count) + advance(dataPointer.count) } } } + internal var used: Int { + buffer.baseAddress!.distance(to: pointer) + } + + internal var remainder: UnsafeMutableRawBufferPointer { + UnsafeMutableRawBufferPointer( + start: pointer, + count: buffer.count - used + ) + } + + internal mutating func advance(_ bytes: Int) { + pointer = pointer.advanced(by: bytes) + } + @discardableResult private mutating func append(contentsOf bufferPointer: UnsafeRawBufferPointer) -> Int { let count = bufferPointer.count if let baseAddress = bufferPointer.baseAddress, count > 0 { - memcpy(pointer, baseAddress, count) + pointer.copyMemory(from: baseAddress, byteCount: count) } pointer = pointer.advanced(by: count) return count } - func distance(pointer: UnsafeMutableRawPointer) -> Int { - return pointer.distance(to: self.pointer) - } - mutating func appendUnknown(data: Data) { append(contentsOf: data) } @@ -92,61 +105,51 @@ internal struct BinaryEncoder { mutating func putFixedUInt64(value: UInt64) { var v = value.littleEndian let n = MemoryLayout.size - memcpy(pointer, &v, n) + pointer.copyMemory(from: &v, byteCount: n) pointer = pointer.advanced(by: n) } mutating func putFixedUInt32(value: UInt32) { var v = value.littleEndian let n = MemoryLayout.size - memcpy(pointer, &v, n) + pointer.copyMemory(from: &v, byteCount: n) pointer = pointer.advanced(by: n) } mutating func putFloatValue(value: Float) { let n = MemoryLayout.size - var v = value - var nativeBytes: UInt32 = 0 - memcpy(&nativeBytes, &v, n) - var littleEndianBytes = nativeBytes.littleEndian - memcpy(pointer, &littleEndianBytes, n) + var v = value.bitPattern.littleEndian + pointer.copyMemory(from: &v, byteCount: n) pointer = pointer.advanced(by: n) } mutating func putDoubleValue(value: Double) { let n = MemoryLayout.size - var v = value - var nativeBytes: UInt64 = 0 - memcpy(&nativeBytes, &v, n) - var littleEndianBytes = nativeBytes.littleEndian - memcpy(pointer, &littleEndianBytes, n) + var v = value.bitPattern.littleEndian + pointer.copyMemory(from: &v, byteCount: n) pointer = pointer.advanced(by: n) } // Write a string field, including the leading index/tag value. mutating func putStringValue(value: String) { let utf8 = value.utf8 - #if swift(>=5.0) - // If the String does not support an internal representation in a form - // of contiguous storage, body is not called and nil is returned. - let isAvailable = utf8.withContiguousStorageIfAvailable { (body: UnsafeBufferPointer) -> Int in - putVarInt(value: body.count) - return append(contentsOf: UnsafeRawBufferPointer(body)) - } - #else - let isAvailable: Int? = nil - #endif - if isAvailable == nil { - let count = utf8.count - putVarInt(value: count) - for b in utf8 { - pointer.storeBytes(of: b, as: UInt8.self) - pointer = pointer.advanced(by: 1) - } + // If the String does not support an internal representation in a form + // of contiguous storage, body is not called and nil is returned. + let isAvailable = utf8.withContiguousStorageIfAvailable { (body: UnsafeBufferPointer) -> Int in + putVarInt(value: body.count) + return append(contentsOf: UnsafeRawBufferPointer(body)) + } + if isAvailable == nil { + let count = utf8.count + putVarInt(value: count) + for b in utf8 { + pointer.storeBytes(of: b, as: UInt8.self) + pointer = pointer.advanced(by: 1) } + } } - mutating func putBytesValue(value: Data) { + mutating func putBytesValue(value: Bytes) { putVarInt(value: value.count) append(contentsOf: value) } diff --git a/Sources/SwiftProtobuf/BinaryEncodingError.swift b/Sources/SwiftProtobuf/BinaryEncodingError.swift index cbf29b5a8..68f1eb62b 100644 --- a/Sources/SwiftProtobuf/BinaryEncodingError.swift +++ b/Sources/SwiftProtobuf/BinaryEncodingError.swift @@ -13,15 +13,12 @@ // ----------------------------------------------------------------------------- /// Describes errors that can occur when decoding a message from binary format. -public enum BinaryEncodingError: Error { - /// `Any` fields that were decoded from JSON cannot be re-encoded to binary - /// unless the object they hold is a well-known type or a type registered via - /// `Google_Protobuf_Any.register()`. - case anyTranscodeFailure - - /// The definition of the message or one of its nested messages has required - /// fields but the message being encoded did not include values for them. You - /// must pass `partial: true` during encoding if you wish to explicitly ignore - /// missing required fields. - case missingRequiredFields +public enum BinaryEncodingError: Error, Hashable { + /// An unexpected failure when deserializing a `Google_Protobuf_Any`. + case anyTranscodeFailure + /// The definition of the message or one of its nested messages has required + /// fields but the message being encoded did not include values for them. You + /// must pass `partial: true` during encoding if you wish to explicitly ignore + /// missing required fields. + case missingRequiredFields } diff --git a/Sources/SwiftProtobuf/BinaryEncodingOptions.swift b/Sources/SwiftProtobuf/BinaryEncodingOptions.swift new file mode 100644 index 000000000..e766150aa --- /dev/null +++ b/Sources/SwiftProtobuf/BinaryEncodingOptions.swift @@ -0,0 +1,32 @@ +// Sources/SwiftProtobuf/BinaryEncodingOptions.swift - Binary encoding options +// +// Copyright (c) 2014 - 2023 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// Binary encoding options +/// +// ----------------------------------------------------------------------------- + +/// Options for binary encoding. +public struct BinaryEncodingOptions: Sendable { + /// Whether to use deterministic ordering when serializing. + /// + /// Note that the deterministic serialization is NOT canonical across languages. + /// It is NOT guaranteed to remain stable over time. It is unstable across + /// different builds with schema changes due to unknown fields. Users who need + /// canonical serialization (e.g., persistent storage in a canonical form, + /// fingerprinting, etc.) should define their own canonicalization specification + /// and implement their own serializer rather than relying on this API. + /// + /// If deterministic serialization is requested, map entries will be sorted + /// by keys in lexicographical order. This is an implementation detail + /// and subject to change. + public var useDeterministicOrdering: Bool = false + + public init() {} +} diff --git a/Sources/SwiftProtobuf/BinaryEncodingSizeVisitor.swift b/Sources/SwiftProtobuf/BinaryEncodingSizeVisitor.swift index 2db485d27..e3e8714fb 100644 --- a/Sources/SwiftProtobuf/BinaryEncodingSizeVisitor.swift +++ b/Sources/SwiftProtobuf/BinaryEncodingSizeVisitor.swift @@ -20,454 +20,486 @@ import Foundation /// serialization. internal struct BinaryEncodingSizeVisitor: Visitor { - /// Accumulates the required size of the message during traversal. - var serializedSize: Int = 0 - - init() {} - - mutating func visitUnknown(bytes: Data) throws { - serializedSize += bytes.count - } - - mutating func visitSingularFloatField(value: Float, fieldNumber: Int) throws { - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed32).encodedSize - serializedSize += tagSize + MemoryLayout.size - } - - mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws { - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed64).encodedSize - serializedSize += tagSize + MemoryLayout.size - } - - mutating func visitSingularInt32Field(value: Int32, fieldNumber: Int) throws { - try visitSingularInt64Field(value: Int64(value), fieldNumber: fieldNumber) - } - - mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws { - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize - serializedSize += tagSize + Varint.encodedSize(of: value) - } - - mutating func visitSingularUInt32Field(value: UInt32, fieldNumber: Int) throws { - try visitSingularUInt64Field(value: UInt64(value), fieldNumber: fieldNumber) - } - - mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws { - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize - serializedSize += tagSize + Varint.encodedSize(of: value) - } - - mutating func visitSingularSInt32Field(value: Int32, fieldNumber: Int) throws { - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize - serializedSize += tagSize + Varint.encodedSize(of: ZigZag.encoded(value)) - } - - mutating func visitSingularSInt64Field(value: Int64, fieldNumber: Int) throws { - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize - serializedSize += tagSize + Varint.encodedSize(of: ZigZag.encoded(value)) - } - - mutating func visitSingularFixed32Field(value: UInt32, fieldNumber: Int) throws { - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed32).encodedSize - serializedSize += tagSize + MemoryLayout.size - } - - mutating func visitSingularFixed64Field(value: UInt64, fieldNumber: Int) throws { - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed64).encodedSize - serializedSize += tagSize + MemoryLayout.size - } - - mutating func visitSingularSFixed32Field(value: Int32, fieldNumber: Int) throws { - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed32).encodedSize - serializedSize += tagSize + MemoryLayout.size - } - - mutating func visitSingularSFixed64Field(value: Int64, fieldNumber: Int) throws { - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed64).encodedSize - serializedSize += tagSize + MemoryLayout.size - } - - mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws { - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize - serializedSize += tagSize + 1 - } - - mutating func visitSingularStringField(value: String, fieldNumber: Int) throws { - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize - let count = value.utf8.count - serializedSize += tagSize + Varint.encodedSize(of: Int64(count)) + count - } - - mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws { - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize - let count = value.count - serializedSize += tagSize + Varint.encodedSize(of: Int64(count)) + count - } - - // The default impls for visitRepeated*Field would work, but by implementing - // these directly, the calculation for the tag overhead can be optimized and - // the fixed width fields can be simple multiplication. - - mutating func visitRepeatedFloatField(value: [Float], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed32).encodedSize - serializedSize += tagSize * value.count + MemoryLayout.size * value.count - } - - mutating func visitRepeatedDoubleField(value: [Double], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed64).encodedSize - serializedSize += tagSize * value.count + MemoryLayout.size * value.count - } - - mutating func visitRepeatedInt32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize - let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } - serializedSize += tagSize * value.count + dataSize - } - - mutating func visitRepeatedInt64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize - let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } - serializedSize += tagSize * value.count + dataSize - } - - mutating func visitRepeatedUInt32Field(value: [UInt32], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize - let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } - serializedSize += tagSize * value.count + dataSize - } - - mutating func visitRepeatedUInt64Field(value: [UInt64], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize - let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } - serializedSize += tagSize * value.count + dataSize - } - - mutating func visitRepeatedSInt32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize - let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: ZigZag.encoded($1)) } - serializedSize += tagSize * value.count + dataSize - } - - mutating func visitRepeatedSInt64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize - let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: ZigZag.encoded($1)) } - serializedSize += tagSize * value.count + dataSize - } - - mutating func visitRepeatedFixed32Field(value: [UInt32], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed32).encodedSize - serializedSize += tagSize * value.count + MemoryLayout.size * value.count - } - - mutating func visitRepeatedFixed64Field(value: [UInt64], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed64).encodedSize - serializedSize += tagSize * value.count + MemoryLayout.size * value.count - } - - mutating func visitRepeatedSFixed32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed32).encodedSize - serializedSize += tagSize * value.count + MemoryLayout.size * value.count - } - - mutating func visitRepeatedSFixed64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed64).encodedSize - serializedSize += tagSize * value.count + MemoryLayout.size * value.count - } - - mutating func visitRepeatedBoolField(value: [Bool], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize - serializedSize += tagSize * value.count + 1 * value.count - } - - mutating func visitRepeatedStringField(value: [String], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize - let dataSize = value.reduce(0) { - let count = $1.utf8.count - return $0 + Varint.encodedSize(of: Int64(count)) + count - } - serializedSize += tagSize * value.count + dataSize - } - - mutating func visitRepeatedBytesField(value: [Data], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize - let dataSize = value.reduce(0) { - let count = $1.count - return $0 + Varint.encodedSize(of: Int64(count)) + count - } - serializedSize += tagSize * value.count + dataSize - } - - // Packed field handling. - - mutating func visitPackedFloatField(value: [Float], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize - let dataSize = value.count * MemoryLayout.size - serializedSize += tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize - } - - mutating func visitPackedDoubleField(value: [Double], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize - let dataSize = value.count * MemoryLayout.size - serializedSize += tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize - } - - mutating func visitPackedInt32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize - let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } - serializedSize += - tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize - } - - mutating func visitPackedInt64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize - let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } - serializedSize += - tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize - } - - mutating func visitPackedSInt32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize - let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: ZigZag.encoded($1)) } - serializedSize += - tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize - } - - mutating func visitPackedSInt64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize - let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: ZigZag.encoded($1)) } - serializedSize += - tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize - } - - mutating func visitPackedUInt32Field(value: [UInt32], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize - let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } - serializedSize += - tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize - } - - mutating func visitPackedUInt64Field(value: [UInt64], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize - let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } - serializedSize += - tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize - } - - mutating func visitPackedFixed32Field(value: [UInt32], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize - let dataSize = value.count * MemoryLayout.size - serializedSize += tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize - } - - mutating func visitPackedFixed64Field(value: [UInt64], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize - let dataSize = value.count * MemoryLayout.size - serializedSize += tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize - } - - mutating func visitPackedSFixed32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize - let dataSize = value.count * MemoryLayout.size - serializedSize += tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize - } - - mutating func visitPackedSFixed64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize - let dataSize = value.count * MemoryLayout.size - serializedSize += tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize - } - - mutating func visitPackedBoolField(value: [Bool], fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize - let dataSize = value.count - serializedSize += tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize - } - - mutating func visitSingularEnumField(value: E, - fieldNumber: Int) throws { - let tagSize = FieldTag(fieldNumber: fieldNumber, - wireFormat: .varint).encodedSize - serializedSize += tagSize - let dataSize = Varint.encodedSize(of: Int32(truncatingIfNeeded: value.rawValue)) - serializedSize += dataSize - } - - mutating func visitRepeatedEnumField(value: [E], - fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, - wireFormat: .varint).encodedSize - serializedSize += value.count * tagSize - let dataSize = value.reduce(0) { - $0 + Varint.encodedSize(of: Int32(truncatingIfNeeded: $1.rawValue)) - } - serializedSize += dataSize - } - - mutating func visitPackedEnumField(value: [E], - fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, - wireFormat: .varint).encodedSize - serializedSize += tagSize - let dataSize = value.reduce(0) { - $0 + Varint.encodedSize(of: Int32(truncatingIfNeeded: $1.rawValue)) - } - serializedSize += Varint.encodedSize(of: Int64(dataSize)) + dataSize - } - - mutating func visitSingularMessageField(value: M, - fieldNumber: Int) throws { - let tagSize = FieldTag(fieldNumber: fieldNumber, - wireFormat: .lengthDelimited).encodedSize - let messageSize = try value.serializedDataSize() - serializedSize += - tagSize + Varint.encodedSize(of: UInt64(messageSize)) + messageSize - } - - mutating func visitRepeatedMessageField(value: [M], - fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, - wireFormat: .lengthDelimited).encodedSize - serializedSize += value.count * tagSize - let dataSize = try value.reduce(0) { - let messageSize = try $1.serializedDataSize() - return $0 + Varint.encodedSize(of: UInt64(messageSize)) + messageSize - } - serializedSize += dataSize - } - - mutating func visitSingularGroupField(value: G, fieldNumber: Int) throws { - // The wire format doesn't matter here because the encoded size of the - // integer won't change based on the low three bits. - let tagSize = FieldTag(fieldNumber: fieldNumber, - wireFormat: .startGroup).encodedSize - serializedSize += 2 * tagSize - try value.traverse(visitor: &self) - } - - mutating func visitRepeatedGroupField(value: [G], - fieldNumber: Int) throws { - assert(!value.isEmpty) - let tagSize = FieldTag(fieldNumber: fieldNumber, - wireFormat: .startGroup).encodedSize - serializedSize += 2 * value.count * tagSize - for v in value { - try v.traverse(visitor: &self) - } - } - - mutating func visitMapField( - fieldType: _ProtobufMap.Type, - value: _ProtobufMap.BaseType, - fieldNumber: Int - ) throws { - let tagSize = FieldTag(fieldNumber: fieldNumber, - wireFormat: .lengthDelimited).encodedSize - for (k,v) in value { - var sizer = BinaryEncodingSizeVisitor() - try KeyType.visitSingular(value: k, fieldNumber: 1, with: &sizer) - try ValueType.visitSingular(value: v, fieldNumber: 2, with: &sizer) - let entrySize = sizer.serializedSize - serializedSize += Varint.encodedSize(of: Int64(entrySize)) + entrySize - } - serializedSize += value.count * tagSize - } - - mutating func visitMapField( - fieldType: _ProtobufEnumMap.Type, - value: _ProtobufEnumMap.BaseType, - fieldNumber: Int - ) throws where ValueType.RawValue == Int { - let tagSize = FieldTag(fieldNumber: fieldNumber, - wireFormat: .lengthDelimited).encodedSize - for (k,v) in value { - var sizer = BinaryEncodingSizeVisitor() - try KeyType.visitSingular(value: k, fieldNumber: 1, with: &sizer) - try sizer.visitSingularEnumField(value: v, fieldNumber: 2) - let entrySize = sizer.serializedSize - serializedSize += Varint.encodedSize(of: Int64(entrySize)) + entrySize - } - serializedSize += value.count * tagSize - } - - mutating func visitMapField( - fieldType: _ProtobufMessageMap.Type, - value: _ProtobufMessageMap.BaseType, - fieldNumber: Int - ) throws { - let tagSize = FieldTag(fieldNumber: fieldNumber, - wireFormat: .lengthDelimited).encodedSize - for (k,v) in value { - var sizer = BinaryEncodingSizeVisitor() - try KeyType.visitSingular(value: k, fieldNumber: 1, with: &sizer) - try sizer.visitSingularMessageField(value: v, fieldNumber: 2) - let entrySize = sizer.serializedSize - serializedSize += Varint.encodedSize(of: Int64(entrySize)) + entrySize - } - serializedSize += value.count * tagSize - } - - mutating func visitExtensionFieldsAsMessageSet( - fields: ExtensionFieldValueSet, - start: Int, - end: Int - ) throws { - var sizer = BinaryEncodingMessageSetSizeVisitor() - try fields.traverse(visitor: &sizer, start: start, end: end) - serializedSize += sizer.serializedSize - } + /// Accumulates the required size of the message during traversal. + var serializedSize: Int = 0 + + init() {} + + mutating func visitUnknown(bytes: Data) throws { + serializedSize += bytes.count + } + + mutating func visitSingularFloatField(value: Float, fieldNumber: Int) throws { + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed32).encodedSize + serializedSize += tagSize + MemoryLayout.size + } + + mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws { + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed64).encodedSize + serializedSize += tagSize + MemoryLayout.size + } + + mutating func visitSingularInt32Field(value: Int32, fieldNumber: Int) throws { + try visitSingularInt64Field(value: Int64(value), fieldNumber: fieldNumber) + } + + mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws { + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize + serializedSize += tagSize + Varint.encodedSize(of: value) + } + + mutating func visitSingularUInt32Field(value: UInt32, fieldNumber: Int) throws { + try visitSingularUInt64Field(value: UInt64(value), fieldNumber: fieldNumber) + } + + mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws { + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize + serializedSize += tagSize + Varint.encodedSize(of: value) + } + + mutating func visitSingularSInt32Field(value: Int32, fieldNumber: Int) throws { + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize + serializedSize += tagSize + Varint.encodedSize(of: ZigZag.encoded(value)) + } + + mutating func visitSingularSInt64Field(value: Int64, fieldNumber: Int) throws { + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize + serializedSize += tagSize + Varint.encodedSize(of: ZigZag.encoded(value)) + } + + mutating func visitSingularFixed32Field(value: UInt32, fieldNumber: Int) throws { + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed32).encodedSize + serializedSize += tagSize + MemoryLayout.size + } + + mutating func visitSingularFixed64Field(value: UInt64, fieldNumber: Int) throws { + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed64).encodedSize + serializedSize += tagSize + MemoryLayout.size + } + + mutating func visitSingularSFixed32Field(value: Int32, fieldNumber: Int) throws { + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed32).encodedSize + serializedSize += tagSize + MemoryLayout.size + } + + mutating func visitSingularSFixed64Field(value: Int64, fieldNumber: Int) throws { + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed64).encodedSize + serializedSize += tagSize + MemoryLayout.size + } + + mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws { + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize + serializedSize += tagSize + 1 + } + + mutating func visitSingularStringField(value: String, fieldNumber: Int) throws { + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize + let count = value.utf8.count + serializedSize += tagSize + Varint.encodedSize(of: Int64(count)) + count + } + + mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws { + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize + let count = value.count + serializedSize += tagSize + Varint.encodedSize(of: Int64(count)) + count + } + + // The default impls for visitRepeated*Field would work, but by implementing + // these directly, the calculation for the tag overhead can be optimized and + // the fixed width fields can be simple multiplication. + + mutating func visitRepeatedFloatField(value: [Float], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed32).encodedSize + serializedSize += tagSize * value.count + MemoryLayout.size * value.count + } + + mutating func visitRepeatedDoubleField(value: [Double], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed64).encodedSize + serializedSize += tagSize * value.count + MemoryLayout.size * value.count + } + + mutating func visitRepeatedInt32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize + let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } + serializedSize += tagSize * value.count + dataSize + } + + mutating func visitRepeatedInt64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize + let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } + serializedSize += tagSize * value.count + dataSize + } + + mutating func visitRepeatedUInt32Field(value: [UInt32], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize + let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } + serializedSize += tagSize * value.count + dataSize + } + + mutating func visitRepeatedUInt64Field(value: [UInt64], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize + let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } + serializedSize += tagSize * value.count + dataSize + } + + mutating func visitRepeatedSInt32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize + let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: ZigZag.encoded($1)) } + serializedSize += tagSize * value.count + dataSize + } + + mutating func visitRepeatedSInt64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize + let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: ZigZag.encoded($1)) } + serializedSize += tagSize * value.count + dataSize + } + + mutating func visitRepeatedFixed32Field(value: [UInt32], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed32).encodedSize + serializedSize += tagSize * value.count + MemoryLayout.size * value.count + } + + mutating func visitRepeatedFixed64Field(value: [UInt64], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed64).encodedSize + serializedSize += tagSize * value.count + MemoryLayout.size * value.count + } + + mutating func visitRepeatedSFixed32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed32).encodedSize + serializedSize += tagSize * value.count + MemoryLayout.size * value.count + } + + mutating func visitRepeatedSFixed64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .fixed64).encodedSize + serializedSize += tagSize * value.count + MemoryLayout.size * value.count + } + + mutating func visitRepeatedBoolField(value: [Bool], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .varint).encodedSize + serializedSize += tagSize * value.count + 1 * value.count + } + + mutating func visitRepeatedStringField(value: [String], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize + let dataSize = value.reduce(0) { + let count = $1.utf8.count + return $0 + Varint.encodedSize(of: Int64(count)) + count + } + serializedSize += tagSize * value.count + dataSize + } + + mutating func visitRepeatedBytesField(value: [Data], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize + let dataSize = value.reduce(0) { + let count = $1.count + return $0 + Varint.encodedSize(of: Int64(count)) + count + } + serializedSize += tagSize * value.count + dataSize + } + + // Packed field handling. + + mutating func visitPackedFloatField(value: [Float], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize + let dataSize = value.count * MemoryLayout.size + serializedSize += tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize + } + + mutating func visitPackedDoubleField(value: [Double], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize + let dataSize = value.count * MemoryLayout.size + serializedSize += tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize + } + + mutating func visitPackedInt32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize + let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } + serializedSize += + tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize + } + + mutating func visitPackedInt64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize + let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } + serializedSize += + tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize + } + + mutating func visitPackedSInt32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize + let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: ZigZag.encoded($1)) } + serializedSize += + tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize + } + + mutating func visitPackedSInt64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize + let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: ZigZag.encoded($1)) } + serializedSize += + tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize + } + + mutating func visitPackedUInt32Field(value: [UInt32], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize + let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } + serializedSize += + tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize + } + + mutating func visitPackedUInt64Field(value: [UInt64], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize + let dataSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } + serializedSize += + tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize + } + + mutating func visitPackedFixed32Field(value: [UInt32], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize + let dataSize = value.count * MemoryLayout.size + serializedSize += tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize + } + + mutating func visitPackedFixed64Field(value: [UInt64], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize + let dataSize = value.count * MemoryLayout.size + serializedSize += tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize + } + + mutating func visitPackedSFixed32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize + let dataSize = value.count * MemoryLayout.size + serializedSize += tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize + } + + mutating func visitPackedSFixed64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize + let dataSize = value.count * MemoryLayout.size + serializedSize += tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize + } + + mutating func visitPackedBoolField(value: [Bool], fieldNumber: Int) throws { + assert(!value.isEmpty) + let tagSize = FieldTag(fieldNumber: fieldNumber, wireFormat: .lengthDelimited).encodedSize + let dataSize = value.count + serializedSize += tagSize + Varint.encodedSize(of: Int64(dataSize)) + dataSize + } + + mutating func visitSingularEnumField( + value: E, + fieldNumber: Int + ) throws { + let tagSize = FieldTag( + fieldNumber: fieldNumber, + wireFormat: .varint + ).encodedSize + serializedSize += tagSize + let dataSize = Varint.encodedSize(of: Int32(truncatingIfNeeded: value.rawValue)) + serializedSize += dataSize + } + + mutating func visitRepeatedEnumField( + value: [E], + fieldNumber: Int + ) throws { + assert(!value.isEmpty) + let tagSize = FieldTag( + fieldNumber: fieldNumber, + wireFormat: .varint + ).encodedSize + serializedSize += value.count * tagSize + let dataSize = value.reduce(0) { + $0 + Varint.encodedSize(of: Int32(truncatingIfNeeded: $1.rawValue)) + } + serializedSize += dataSize + } + + mutating func visitPackedEnumField( + value: [E], + fieldNumber: Int + ) throws { + assert(!value.isEmpty) + let tagSize = FieldTag( + fieldNumber: fieldNumber, + wireFormat: .varint + ).encodedSize + serializedSize += tagSize + let dataSize = value.reduce(0) { + $0 + Varint.encodedSize(of: Int32(truncatingIfNeeded: $1.rawValue)) + } + serializedSize += Varint.encodedSize(of: Int64(dataSize)) + dataSize + } + + mutating func visitSingularMessageField( + value: M, + fieldNumber: Int + ) throws { + let tagSize = FieldTag( + fieldNumber: fieldNumber, + wireFormat: .lengthDelimited + ).encodedSize + let messageSize = try value.serializedDataSize() + serializedSize += + tagSize + Varint.encodedSize(of: UInt64(messageSize)) + messageSize + } + + mutating func visitRepeatedMessageField( + value: [M], + fieldNumber: Int + ) throws { + assert(!value.isEmpty) + let tagSize = FieldTag( + fieldNumber: fieldNumber, + wireFormat: .lengthDelimited + ).encodedSize + serializedSize += value.count * tagSize + let dataSize = try value.reduce(0) { + let messageSize = try $1.serializedDataSize() + return $0 + Varint.encodedSize(of: UInt64(messageSize)) + messageSize + } + serializedSize += dataSize + } + + mutating func visitSingularGroupField(value: G, fieldNumber: Int) throws { + // The wire format doesn't matter here because the encoded size of the + // integer won't change based on the low three bits. + let tagSize = FieldTag( + fieldNumber: fieldNumber, + wireFormat: .startGroup + ).encodedSize + serializedSize += 2 * tagSize + try value.traverse(visitor: &self) + } + + mutating func visitRepeatedGroupField( + value: [G], + fieldNumber: Int + ) throws { + assert(!value.isEmpty) + let tagSize = FieldTag( + fieldNumber: fieldNumber, + wireFormat: .startGroup + ).encodedSize + serializedSize += 2 * value.count * tagSize + for v in value { + try v.traverse(visitor: &self) + } + } + + mutating func visitMapField( + fieldType: _ProtobufMap.Type, + value: _ProtobufMap.BaseType, + fieldNumber: Int + ) throws { + let tagSize = FieldTag( + fieldNumber: fieldNumber, + wireFormat: .lengthDelimited + ).encodedSize + for (k, v) in value { + var sizer = BinaryEncodingSizeVisitor() + try KeyType.visitSingular(value: k, fieldNumber: 1, with: &sizer) + try ValueType.visitSingular(value: v, fieldNumber: 2, with: &sizer) + let entrySize = sizer.serializedSize + serializedSize += Varint.encodedSize(of: Int64(entrySize)) + entrySize + } + serializedSize += value.count * tagSize + } + + mutating func visitMapField( + fieldType: _ProtobufEnumMap.Type, + value: _ProtobufEnumMap.BaseType, + fieldNumber: Int + ) throws where ValueType.RawValue == Int { + let tagSize = FieldTag( + fieldNumber: fieldNumber, + wireFormat: .lengthDelimited + ).encodedSize + for (k, v) in value { + var sizer = BinaryEncodingSizeVisitor() + try KeyType.visitSingular(value: k, fieldNumber: 1, with: &sizer) + try sizer.visitSingularEnumField(value: v, fieldNumber: 2) + let entrySize = sizer.serializedSize + serializedSize += Varint.encodedSize(of: Int64(entrySize)) + entrySize + } + serializedSize += value.count * tagSize + } + + mutating func visitMapField( + fieldType: _ProtobufMessageMap.Type, + value: _ProtobufMessageMap.BaseType, + fieldNumber: Int + ) throws { + let tagSize = FieldTag( + fieldNumber: fieldNumber, + wireFormat: .lengthDelimited + ).encodedSize + for (k, v) in value { + var sizer = BinaryEncodingSizeVisitor() + try KeyType.visitSingular(value: k, fieldNumber: 1, with: &sizer) + try sizer.visitSingularMessageField(value: v, fieldNumber: 2) + let entrySize = sizer.serializedSize + serializedSize += Varint.encodedSize(of: Int64(entrySize)) + entrySize + } + serializedSize += value.count * tagSize + } + + mutating func visitExtensionFieldsAsMessageSet( + fields: ExtensionFieldValueSet, + start: Int, + end: Int + ) throws { + var sizer = BinaryEncodingMessageSetSizeVisitor() + try fields.traverse(visitor: &sizer, start: start, end: end) + serializedSize += sizer.serializedSize + } } extension BinaryEncodingSizeVisitor { - // Helper Visitor to compute the sizes when writing out the extensions as MessageSets. - internal struct BinaryEncodingMessageSetSizeVisitor: SelectiveVisitor { - var serializedSize: Int = 0 + // Helper Visitor to compute the sizes when writing out the extensions as MessageSets. + internal struct BinaryEncodingMessageSetSizeVisitor: SelectiveVisitor { + var serializedSize: Int = 0 - init() {} + init() {} - mutating func visitSingularMessageField(value: M, fieldNumber: Int) throws { - var groupSize = WireFormat.MessageSet.itemTagsEncodedSize + mutating func visitSingularMessageField(value: M, fieldNumber: Int) throws { + var groupSize = WireFormat.MessageSet.itemTagsEncodedSize - groupSize += Varint.encodedSize(of: Int32(fieldNumber)) + groupSize += Varint.encodedSize(of: Int32(fieldNumber)) - let messageSize = try value.serializedDataSize() - groupSize += Varint.encodedSize(of: UInt64(messageSize)) + messageSize + let messageSize = try value.serializedDataSize() + groupSize += Varint.encodedSize(of: UInt64(messageSize)) + messageSize - serializedSize += groupSize - } + serializedSize += groupSize + } - // SelectiveVisitor handles the rest. - } + // SelectiveVisitor handles the rest. + } } diff --git a/Sources/SwiftProtobuf/BinaryEncodingVisitor.swift b/Sources/SwiftProtobuf/BinaryEncodingVisitor.swift index 748de2538..81fd97dcd 100644 --- a/Sources/SwiftProtobuf/BinaryEncodingVisitor.swift +++ b/Sources/SwiftProtobuf/BinaryEncodingVisitor.swift @@ -17,339 +17,386 @@ import Foundation /// Visitor that encodes a message graph in the protobuf binary wire format. internal struct BinaryEncodingVisitor: Visitor { + private let options: BinaryEncodingOptions - var encoder: BinaryEncoder - - /// Creates a new visitor that writes the binary-coded message into the memory - /// at the given pointer. - /// - /// - Precondition: `pointer` must point to an allocated block of memory that - /// is large enough to hold the entire encoded message. For performance - /// reasons, the encoder does not make any attempts to verify this. - init(forWritingInto pointer: UnsafeMutableRawPointer) { - encoder = BinaryEncoder(forWritingInto: pointer) - } - - init(encoder: BinaryEncoder) { - self.encoder = encoder - } - - mutating func visitUnknown(bytes: Data) throws { - encoder.appendUnknown(data: bytes) - } - - mutating func visitSingularFloatField(value: Float, fieldNumber: Int) throws { - encoder.startField(fieldNumber: fieldNumber, wireFormat: .fixed32) - encoder.putFloatValue(value: value) - } - - mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws { - encoder.startField(fieldNumber: fieldNumber, wireFormat: .fixed64) - encoder.putDoubleValue(value: value) - } - - mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws { - try visitSingularUInt64Field(value: UInt64(bitPattern: value), fieldNumber: fieldNumber) - } - - mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws { - encoder.startField(fieldNumber: fieldNumber, wireFormat: .varint) - encoder.putVarInt(value: value) - } - - mutating func visitSingularSInt32Field(value: Int32, fieldNumber: Int) throws { - try visitSingularSInt64Field(value: Int64(value), fieldNumber: fieldNumber) - } - - mutating func visitSingularSInt64Field(value: Int64, fieldNumber: Int) throws { - try visitSingularUInt64Field(value: ZigZag.encoded(value), fieldNumber: fieldNumber) - } - - mutating func visitSingularFixed32Field(value: UInt32, fieldNumber: Int) throws { - encoder.startField(fieldNumber: fieldNumber, wireFormat: .fixed32) - encoder.putFixedUInt32(value: value) - } - - mutating func visitSingularFixed64Field(value: UInt64, fieldNumber: Int) throws { - encoder.startField(fieldNumber: fieldNumber, wireFormat: .fixed64) - encoder.putFixedUInt64(value: value) - } - - mutating func visitSingularSFixed32Field(value: Int32, fieldNumber: Int) throws { - try visitSingularFixed32Field(value: UInt32(bitPattern: value), fieldNumber: fieldNumber) - } - - mutating func visitSingularSFixed64Field(value: Int64, fieldNumber: Int) throws { - try visitSingularFixed64Field(value: UInt64(bitPattern: value), fieldNumber: fieldNumber) - } - - mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws { - try visitSingularUInt64Field(value: value ? 1 : 0, fieldNumber: fieldNumber) - } - - mutating func visitSingularStringField(value: String, fieldNumber: Int) throws { - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - encoder.putStringValue(value: value) - } - - mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws { - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - encoder.putBytesValue(value: value) - } - - mutating func visitSingularEnumField(value: E, - fieldNumber: Int) throws { - try visitSingularUInt64Field(value: UInt64(bitPattern: Int64(value.rawValue)), - fieldNumber: fieldNumber) - } - - mutating func visitSingularMessageField(value: M, - fieldNumber: Int) throws { - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - let length = try value.serializedDataSize() - encoder.putVarInt(value: length) - try value.traverse(visitor: &self) - } - - mutating func visitSingularGroupField(value: G, fieldNumber: Int) throws { - encoder.startField(fieldNumber: fieldNumber, wireFormat: .startGroup) - try value.traverse(visitor: &self) - encoder.startField(fieldNumber: fieldNumber, wireFormat: .endGroup) - } - - // Repeated fields are handled by the default implementations in Visitor.swift - - - // Packed Fields - - mutating func visitPackedFloatField(value: [Float], fieldNumber: Int) throws { - assert(!value.isEmpty) - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - encoder.putVarInt(value: value.count * MemoryLayout.size) - for v in value { - encoder.putFloatValue(value: v) - } - } - - mutating func visitPackedDoubleField(value: [Double], fieldNumber: Int) throws { - assert(!value.isEmpty) - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - encoder.putVarInt(value: value.count * MemoryLayout.size) - for v in value { - encoder.putDoubleValue(value: v) - } - } - - mutating func visitPackedInt32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - let packedSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } - encoder.putVarInt(value: packedSize) - for v in value { - encoder.putVarInt(value: Int64(v)) - } - } - - mutating func visitPackedInt64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - let packedSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } - encoder.putVarInt(value: packedSize) - for v in value { - encoder.putVarInt(value: v) - } - } - - mutating func visitPackedSInt32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - let packedSize = value.reduce(0) { $0 + Varint.encodedSize(of: ZigZag.encoded($1)) } - encoder.putVarInt(value: packedSize) - for v in value { - encoder.putZigZagVarInt(value: Int64(v)) - } - } - - mutating func visitPackedSInt64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - let packedSize = value.reduce(0) { $0 + Varint.encodedSize(of: ZigZag.encoded($1)) } - encoder.putVarInt(value: packedSize) - for v in value { - encoder.putZigZagVarInt(value: v) - } - } - - mutating func visitPackedUInt32Field(value: [UInt32], fieldNumber: Int) throws { - assert(!value.isEmpty) - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - let packedSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } - encoder.putVarInt(value: packedSize) - for v in value { - encoder.putVarInt(value: UInt64(v)) - } - } - - mutating func visitPackedUInt64Field(value: [UInt64], fieldNumber: Int) throws { - assert(!value.isEmpty) - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - let packedSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } - encoder.putVarInt(value: packedSize) - for v in value { - encoder.putVarInt(value: v) - } - } - - mutating func visitPackedFixed32Field(value: [UInt32], fieldNumber: Int) throws { - assert(!value.isEmpty) - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - encoder.putVarInt(value: value.count * MemoryLayout.size) - for v in value { - encoder.putFixedUInt32(value: v) - } - } - - mutating func visitPackedFixed64Field(value: [UInt64], fieldNumber: Int) throws { - assert(!value.isEmpty) - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - encoder.putVarInt(value: value.count * MemoryLayout.size) - for v in value { - encoder.putFixedUInt64(value: v) - } - } - - mutating func visitPackedSFixed32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - encoder.putVarInt(value: value.count * MemoryLayout.size) - for v in value { - encoder.putFixedUInt32(value: UInt32(bitPattern: v)) - } - } - - mutating func visitPackedSFixed64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - encoder.putVarInt(value: value.count * MemoryLayout.size) - for v in value { - encoder.putFixedUInt64(value: UInt64(bitPattern: v)) - } - } - - mutating func visitPackedBoolField(value: [Bool], fieldNumber: Int) throws { - assert(!value.isEmpty) - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - encoder.putVarInt(value: value.count) - for v in value { - encoder.putVarInt(value: v ? 1 : 0) - } - } - - mutating func visitPackedEnumField(value: [E], fieldNumber: Int) throws { - assert(!value.isEmpty) - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - let packedSize = value.reduce(0) { - $0 + Varint.encodedSize(of: Int32(truncatingIfNeeded: $1.rawValue)) - } - encoder.putVarInt(value: packedSize) - for v in value { - encoder.putVarInt(value: v.rawValue) - } - } - - mutating func visitMapField( - fieldType: _ProtobufMap.Type, - value: _ProtobufMap.BaseType, - fieldNumber: Int - ) throws { - for (k,v) in value { - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - var sizer = BinaryEncodingSizeVisitor() - try KeyType.visitSingular(value: k, fieldNumber: 1, with: &sizer) - try ValueType.visitSingular(value: v, fieldNumber: 2, with: &sizer) - let entrySize = sizer.serializedSize - encoder.putVarInt(value: entrySize) - try KeyType.visitSingular(value: k, fieldNumber: 1, with: &self) - try ValueType.visitSingular(value: v, fieldNumber: 2, with: &self) - } - } - - mutating func visitMapField( - fieldType: _ProtobufEnumMap.Type, - value: _ProtobufEnumMap.BaseType, - fieldNumber: Int - ) throws where ValueType.RawValue == Int { - for (k,v) in value { - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - var sizer = BinaryEncodingSizeVisitor() - try KeyType.visitSingular(value: k, fieldNumber: 1, with: &sizer) - try sizer.visitSingularEnumField(value: v, fieldNumber: 2) - let entrySize = sizer.serializedSize - encoder.putVarInt(value: entrySize) - try KeyType.visitSingular(value: k, fieldNumber: 1, with: &self) - try visitSingularEnumField(value: v, fieldNumber: 2) - } - } - - mutating func visitMapField( - fieldType: _ProtobufMessageMap.Type, - value: _ProtobufMessageMap.BaseType, - fieldNumber: Int - ) throws { - for (k,v) in value { - encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) - var sizer = BinaryEncodingSizeVisitor() - try KeyType.visitSingular(value: k, fieldNumber: 1, with: &sizer) - try sizer.visitSingularMessageField(value: v, fieldNumber: 2) - let entrySize = sizer.serializedSize - encoder.putVarInt(value: entrySize) - try KeyType.visitSingular(value: k, fieldNumber: 1, with: &self) - try visitSingularMessageField(value: v, fieldNumber: 2) - } - } - - mutating func visitExtensionFieldsAsMessageSet( - fields: ExtensionFieldValueSet, - start: Int, - end: Int - ) throws { - var subVisitor = BinaryEncodingMessageSetVisitor(encoder: encoder) - try fields.traverse(visitor: &subVisitor, start: start, end: end) - encoder = subVisitor.encoder - } -} + var encoder: BinaryEncoder -extension BinaryEncodingVisitor { + /// Creates a new visitor that writes the binary-coded message into the memory + /// at the given pointer. + /// + /// - Precondition: `pointer` must point to an allocated block of memory that + /// is large enough to hold the entire encoded message. For performance + /// reasons, the encoder does not make any attempts to verify this. + init(forWritingInto buffer: UnsafeMutableRawBufferPointer, options: BinaryEncodingOptions) { + self.encoder = BinaryEncoder(forWritingInto: buffer) + self.options = options + } - // Helper Visitor to when writing out the extensions as MessageSets. - internal struct BinaryEncodingMessageSetVisitor: SelectiveVisitor { - var encoder: BinaryEncoder + mutating func visitUnknown(bytes: Data) throws { + encoder.appendUnknown(data: bytes) + } - init(encoder: BinaryEncoder) { - self.encoder = encoder + mutating func visitSingularFloatField(value: Float, fieldNumber: Int) throws { + encoder.startField(fieldNumber: fieldNumber, wireFormat: .fixed32) + encoder.putFloatValue(value: value) } - mutating func visitSingularMessageField(value: M, fieldNumber: Int) throws { - encoder.putVarInt(value: Int64(WireFormat.MessageSet.Tags.itemStart.rawValue)) + mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws { + encoder.startField(fieldNumber: fieldNumber, wireFormat: .fixed64) + encoder.putDoubleValue(value: value) + } - encoder.putVarInt(value: Int64(WireFormat.MessageSet.Tags.typeId.rawValue)) - encoder.putVarInt(value: fieldNumber) + mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws { + try visitSingularUInt64Field(value: UInt64(bitPattern: value), fieldNumber: fieldNumber) + } - encoder.putVarInt(value: Int64(WireFormat.MessageSet.Tags.message.rawValue)) + mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws { + encoder.startField(fieldNumber: fieldNumber, wireFormat: .varint) + encoder.putVarInt(value: value) + } - // Use a normal BinaryEncodingVisitor so any message fields end up in the - // normal wire format (instead of MessageSet format). - let length = try value.serializedDataSize() - encoder.putVarInt(value: length) - // Create the sub encoder after writing the length. - var subVisitor = BinaryEncodingVisitor(encoder: encoder) - try value.traverse(visitor: &subVisitor) - encoder = subVisitor.encoder + mutating func visitSingularSInt32Field(value: Int32, fieldNumber: Int) throws { + try visitSingularSInt64Field(value: Int64(value), fieldNumber: fieldNumber) + } - encoder.putVarInt(value: Int64(WireFormat.MessageSet.Tags.itemEnd.rawValue)) + mutating func visitSingularSInt64Field(value: Int64, fieldNumber: Int) throws { + try visitSingularUInt64Field(value: ZigZag.encoded(value), fieldNumber: fieldNumber) } - // SelectiveVisitor handles the rest. - } + mutating func visitSingularFixed32Field(value: UInt32, fieldNumber: Int) throws { + encoder.startField(fieldNumber: fieldNumber, wireFormat: .fixed32) + encoder.putFixedUInt32(value: value) + } + + mutating func visitSingularFixed64Field(value: UInt64, fieldNumber: Int) throws { + encoder.startField(fieldNumber: fieldNumber, wireFormat: .fixed64) + encoder.putFixedUInt64(value: value) + } + + mutating func visitSingularSFixed32Field(value: Int32, fieldNumber: Int) throws { + try visitSingularFixed32Field(value: UInt32(bitPattern: value), fieldNumber: fieldNumber) + } + + mutating func visitSingularSFixed64Field(value: Int64, fieldNumber: Int) throws { + try visitSingularFixed64Field(value: UInt64(bitPattern: value), fieldNumber: fieldNumber) + } + + mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws { + try visitSingularUInt64Field(value: value ? 1 : 0, fieldNumber: fieldNumber) + } + + mutating func visitSingularStringField(value: String, fieldNumber: Int) throws { + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + encoder.putStringValue(value: value) + } + + mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws { + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + encoder.putBytesValue(value: value) + } + + mutating func visitSingularEnumField( + value: E, + fieldNumber: Int + ) throws { + try visitSingularUInt64Field( + value: UInt64(bitPattern: Int64(value.rawValue)), + fieldNumber: fieldNumber + ) + } + + mutating func visitSingularMessageField( + value: M, + fieldNumber: Int + ) throws { + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + let length = try value.serializedDataSize() + encoder.putVarInt(value: length) + try value.traverse(visitor: &self) + } + + mutating func visitSingularGroupField(value: G, fieldNumber: Int) throws { + encoder.startField(fieldNumber: fieldNumber, wireFormat: .startGroup) + try value.traverse(visitor: &self) + encoder.startField(fieldNumber: fieldNumber, wireFormat: .endGroup) + } + + // Repeated fields are handled by the default implementations in Visitor.swift + + // Packed Fields + + mutating func visitPackedFloatField(value: [Float], fieldNumber: Int) throws { + assert(!value.isEmpty) + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + encoder.putVarInt(value: value.count * MemoryLayout.size) + for v in value { + encoder.putFloatValue(value: v) + } + } + + mutating func visitPackedDoubleField(value: [Double], fieldNumber: Int) throws { + assert(!value.isEmpty) + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + encoder.putVarInt(value: value.count * MemoryLayout.size) + for v in value { + encoder.putDoubleValue(value: v) + } + } + + mutating func visitPackedInt32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + let packedSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } + encoder.putVarInt(value: packedSize) + for v in value { + encoder.putVarInt(value: Int64(v)) + } + } + + mutating func visitPackedInt64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + let packedSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } + encoder.putVarInt(value: packedSize) + for v in value { + encoder.putVarInt(value: v) + } + } + + mutating func visitPackedSInt32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + let packedSize = value.reduce(0) { $0 + Varint.encodedSize(of: ZigZag.encoded($1)) } + encoder.putVarInt(value: packedSize) + for v in value { + encoder.putZigZagVarInt(value: Int64(v)) + } + } + mutating func visitPackedSInt64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + let packedSize = value.reduce(0) { $0 + Varint.encodedSize(of: ZigZag.encoded($1)) } + encoder.putVarInt(value: packedSize) + for v in value { + encoder.putZigZagVarInt(value: v) + } + } + + mutating func visitPackedUInt32Field(value: [UInt32], fieldNumber: Int) throws { + assert(!value.isEmpty) + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + let packedSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } + encoder.putVarInt(value: packedSize) + for v in value { + encoder.putVarInt(value: UInt64(v)) + } + } + + mutating func visitPackedUInt64Field(value: [UInt64], fieldNumber: Int) throws { + assert(!value.isEmpty) + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + let packedSize = value.reduce(0) { $0 + Varint.encodedSize(of: $1) } + encoder.putVarInt(value: packedSize) + for v in value { + encoder.putVarInt(value: v) + } + } + + mutating func visitPackedFixed32Field(value: [UInt32], fieldNumber: Int) throws { + assert(!value.isEmpty) + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + encoder.putVarInt(value: value.count * MemoryLayout.size) + for v in value { + encoder.putFixedUInt32(value: v) + } + } + + mutating func visitPackedFixed64Field(value: [UInt64], fieldNumber: Int) throws { + assert(!value.isEmpty) + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + encoder.putVarInt(value: value.count * MemoryLayout.size) + for v in value { + encoder.putFixedUInt64(value: v) + } + } + + mutating func visitPackedSFixed32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + encoder.putVarInt(value: value.count * MemoryLayout.size) + for v in value { + encoder.putFixedUInt32(value: UInt32(bitPattern: v)) + } + } + + mutating func visitPackedSFixed64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + encoder.putVarInt(value: value.count * MemoryLayout.size) + for v in value { + encoder.putFixedUInt64(value: UInt64(bitPattern: v)) + } + } + + mutating func visitPackedBoolField(value: [Bool], fieldNumber: Int) throws { + assert(!value.isEmpty) + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + encoder.putVarInt(value: value.count) + for v in value { + encoder.putVarInt(value: v ? 1 : 0) + } + } + + mutating func visitPackedEnumField(value: [E], fieldNumber: Int) throws { + assert(!value.isEmpty) + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + let packedSize = value.reduce(0) { + $0 + Varint.encodedSize(of: Int32(truncatingIfNeeded: $1.rawValue)) + } + encoder.putVarInt(value: packedSize) + for v in value { + encoder.putVarInt(value: v.rawValue) + } + } + + mutating func visitMapField( + fieldType: _ProtobufMap.Type, + value: _ProtobufMap.BaseType, + fieldNumber: Int + ) throws { + try iterateAndEncode( + map: value, + fieldNumber: fieldNumber, + isOrderedBefore: KeyType._lessThan, + encodeWithSizer: { sizer, key, value in + try KeyType.visitSingular(value: key, fieldNumber: 1, with: &sizer) + try ValueType.visitSingular(value: value, fieldNumber: 2, with: &sizer) + }, + encodeWithVisitor: { visitor, key, value in + try KeyType.visitSingular(value: key, fieldNumber: 1, with: &visitor) + try ValueType.visitSingular(value: value, fieldNumber: 2, with: &visitor) + } + ) + } + + mutating func visitMapField( + fieldType: _ProtobufEnumMap.Type, + value: _ProtobufEnumMap.BaseType, + fieldNumber: Int + ) throws where ValueType.RawValue == Int { + try iterateAndEncode( + map: value, + fieldNumber: fieldNumber, + isOrderedBefore: KeyType._lessThan, + encodeWithSizer: { sizer, key, value in + try KeyType.visitSingular(value: key, fieldNumber: 1, with: &sizer) + try sizer.visitSingularEnumField(value: value, fieldNumber: 2) + }, + encodeWithVisitor: { visitor, key, value in + try KeyType.visitSingular(value: key, fieldNumber: 1, with: &visitor) + try visitor.visitSingularEnumField(value: value, fieldNumber: 2) + } + ) + } + + mutating func visitMapField( + fieldType: _ProtobufMessageMap.Type, + value: _ProtobufMessageMap.BaseType, + fieldNumber: Int + ) throws { + try iterateAndEncode( + map: value, + fieldNumber: fieldNumber, + isOrderedBefore: KeyType._lessThan, + encodeWithSizer: { sizer, key, value in + try KeyType.visitSingular(value: key, fieldNumber: 1, with: &sizer) + try sizer.visitSingularMessageField(value: value, fieldNumber: 2) + }, + encodeWithVisitor: { visitor, key, value in + try KeyType.visitSingular(value: key, fieldNumber: 1, with: &visitor) + try visitor.visitSingularMessageField(value: value, fieldNumber: 2) + } + ) + } + + /// Helper to encapsulate the common structure of iterating over a map + /// and encoding the keys and values. + private mutating func iterateAndEncode( + map: [K: V], + fieldNumber: Int, + isOrderedBefore: (K, K) -> Bool, + encodeWithSizer: (inout BinaryEncodingSizeVisitor, K, V) throws -> Void, + encodeWithVisitor: (inout BinaryEncodingVisitor, K, V) throws -> Void + ) throws { + if options.useDeterministicOrdering { + for (k, v) in map.sorted(by: { isOrderedBefore($0.0, $1.0) }) { + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + var sizer = BinaryEncodingSizeVisitor() + try encodeWithSizer(&sizer, k, v) + let entrySize = sizer.serializedSize + encoder.putVarInt(value: entrySize) + try encodeWithVisitor(&self, k, v) + } + } else { + for (k, v) in map { + encoder.startField(fieldNumber: fieldNumber, wireFormat: .lengthDelimited) + var sizer = BinaryEncodingSizeVisitor() + try encodeWithSizer(&sizer, k, v) + let entrySize = sizer.serializedSize + encoder.putVarInt(value: entrySize) + try encodeWithVisitor(&self, k, v) + } + } + } + + mutating func visitExtensionFieldsAsMessageSet( + fields: ExtensionFieldValueSet, + start: Int, + end: Int + ) throws { + var subVisitor = BinaryEncodingMessageSetVisitor(encoder: encoder, options: options) + try fields.traverse(visitor: &subVisitor, start: start, end: end) + encoder = subVisitor.encoder + } +} + +extension BinaryEncodingVisitor { + + // Helper Visitor to when writing out the extensions as MessageSets. + internal struct BinaryEncodingMessageSetVisitor: SelectiveVisitor { + private let options: BinaryEncodingOptions + + var encoder: BinaryEncoder + + init(encoder: BinaryEncoder, options: BinaryEncodingOptions) { + self.options = options + self.encoder = encoder + } + + mutating func visitSingularMessageField(value: M, fieldNumber: Int) throws { + encoder.putVarInt(value: Int64(WireFormat.MessageSet.Tags.itemStart.rawValue)) + + encoder.putVarInt(value: Int64(WireFormat.MessageSet.Tags.typeId.rawValue)) + encoder.putVarInt(value: fieldNumber) + + encoder.putVarInt(value: Int64(WireFormat.MessageSet.Tags.message.rawValue)) + + // Use a normal BinaryEncodingVisitor so any message fields end up in the + // normal wire format (instead of MessageSet format). + let length = try value.serializedDataSize() + encoder.putVarInt(value: length) + // Create the sub encoder after writing the length. + var subVisitor = BinaryEncodingVisitor( + forWritingInto: encoder.remainder, + options: options + ) + try value.traverse(visitor: &subVisitor) + encoder.advance(subVisitor.encoder.used) + + encoder.putVarInt(value: Int64(WireFormat.MessageSet.Tags.itemEnd.rawValue)) + } + + // SelectiveVisitor handles the rest. + } } diff --git a/Sources/SwiftProtobuf/BytecodeInterpreter.swift b/Sources/SwiftProtobuf/BytecodeInterpreter.swift new file mode 100644 index 000000000..9ddcb6807 --- /dev/null +++ b/Sources/SwiftProtobuf/BytecodeInterpreter.swift @@ -0,0 +1,63 @@ +// Sources/SwiftProtobuf/BytecodeInterpreter.swift - Internal bytecode interpreter +// +// Copyright (c) 2014 - 2025 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +/// Interprets SwiftProtobuf bytecode that is a stream of "instructions" and "operands". +/// +/// Bytecode interpreters are generic over an `Instruction` type, which must be something (typically +/// an `enum`) that has `UInt64` raw values. The only restriction on these values is that the raw +/// value zero is reserved, so all instructions must have raw values of one or greater. +/// +/// The current version of the bytecode stream (program format 0) is represented as a `StaticString` +/// where non-textual information is binary-encoded in a way that is still guaranteed to be valid +/// UTF-8. Specifically, +/// +/// - Integers are encoded in a varint-like format similar to protobuf, except that only the low +/// 7 bits are used. The most-significant bit is always clear, and the second-most-significant +/// bit is used as the continuation bit. +/// - Strings are length-delimited, where the length is an integer (see above) that precedes the +/// string content, which is standard UTF-8. There is no null termination. +/// - The stream always begins with an integer that indicates the "program format" for the stream. +/// Currently, the only valid value is zero. +package struct BytecodeInterpreter +where Instruction.RawValue == UInt64 { + /// The bytecode program being executed. + private let program: StaticString + + /// Creates a new bytecode interpreter that will execute the given program. + package init(program: StaticString) { + self.program = program + } + + /// Executes the program by translating its opcodes into instructions of the `Instruction` type, + /// invoking the given `handleInstruction` function on each instruction until the program has + /// been completely read. + /// + /// - Parameter handleInstruction: The function that will be invoked for each instruction that + /// is read from the bytecode stream. The function takes two arguments: the `Instruction` that + /// was read, and an `inout BytecodeReader` that the function should use to read operands and + /// advance the stream. + package func execute(handleInstruction: (Instruction, inout BytecodeReader) -> Void) { + guard program.hasPointerRepresentation else { + // The only way this could happen is if the program were a single byte, meaning that it + // only has a 6-bits-or-fewer format specifier and nothing else. In other words, there + // are no instructions, and we can simply return as there is nothing to execute. We + // should still verify that the program format is valid, however. + BytecodeReader.checkProgramFormat(UInt64(program.unicodeScalar.value)) + return + } + program.withUTF8Buffer { programBuffer in + var reader = BytecodeReader(remainingProgram: programBuffer[...]) + while reader.hasData { + let instruction = reader.nextInstruction() + handleInstruction(instruction, &reader) + } + } + } +} diff --git a/Sources/SwiftProtobuf/BytecodeReader.swift b/Sources/SwiftProtobuf/BytecodeReader.swift new file mode 100644 index 000000000..b43b9c50c --- /dev/null +++ b/Sources/SwiftProtobuf/BytecodeReader.swift @@ -0,0 +1,157 @@ +// Sources/SwiftProtobuf/BytecodeReader.swift - Internal bytecode reader +// +// Copyright (c) 2014 - 2025 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +/// Reads values encoded in a SwiftProtobuf bytecode stream. +package struct BytecodeReader where Instruction.RawValue == UInt64 { + /// The remaining slice of the program that has not yet been read. + private var remainingProgram: UnsafeBufferPointer.SubSequence + + /// Indicates whether or not there is still data that hasn't yet been read in the bytecode + /// stream. + package var hasData: Bool { + !remainingProgram.isEmpty + } + + /// Creates a new bytecode reader that reads the given bytecode stream. + package init(remainingProgram: UnsafeBufferPointer.SubSequence) { + self.remainingProgram = remainingProgram + + // We reserve the first integer of the program text as a "format specifier". This + // future-proofs us if we ever want to change the way programs themselves are encoded + // (for example, compressing them). + Self.checkProgramFormat(nextUInt64()) + } + + /// Checks that the given program format is valid (i.e., not greater than the runtime supports), + /// trapping if it is invalid. + static func checkProgramFormat(_ programFormat: UInt64) { + if programFormat > latestBytecodeProgramFormat { + fatalError("Unexpected bytecode program format \(programFormat)") + } + } + + /// Reads and returns the next instruction from the bytecode stream. + /// + /// - Precondition: The reader must not be at the end of the bytecode stream, and the next + /// opcode must not be zero. + /// + /// - Returns: The instruction that was read from the bytecode stream. + package mutating func nextInstruction() -> Instruction { + precondition(hasData, "Unexpected end of bytecode stream") + + let opcode = nextUInt64() + precondition(opcode != 0, "Opcode 0 is reserved; do not use it in your own instructions") + guard let instruction = Instruction(rawValue: opcode) else { + fatalError("Unexpected opcode \(opcode) for instruction set \(Instruction.self)") + } + return instruction + } + + /// Reads and returns the next signed 32-bit integer from the bytecode stream. + /// + /// This is provided as its own primitive operation because 32-bit values are extremely common + /// as field numbers (0 to 2^29-1) and enum cases (-2^31 to 2^31-1). In particular for enum + /// cases, using this function specifically for those cases avoids making mistakes involving + /// sign- vs. zero-extension between differently-sized integers. + /// + /// - Precondition: The reader must not be at the end of the bytecode stream. + /// + /// - Returns: The signed 32-bit integer that was read from the bytecode stream. + package mutating func nextInt32() -> Int32 { + // `Int32`s are stored by converting them bit-wise to a `UInt32` and then zero-extended to + // `UInt64`, since this representation is smaller than sign-extending them to 64 bits. + let uint64Value = nextUInt64() + assert(uint64Value < UInt64(0x1_0000_0000), "nextInt32() read a value larger than 32 bits") + return Int32(bitPattern: UInt32(truncatingIfNeeded: uint64Value)) + } + + /// Reads and returns the next unsigned 64-bit integer from the bytecode stream. + /// + /// - Precondition: The reader must not be at the end of the bytecode stream. + /// + /// - Returns: The unsigned 64-bit integer that was read from the bytecode stream. + package mutating func nextUInt64() -> UInt64 { + precondition(hasData, "Unexpected end of bytecode stream") + + // We store our programs as `StaticString`s, but those are still required to be UTF-8 + // encoded. This means we can't use a standard varint encoding for integers (because we + // cannot arbitrarily use the most significant bit), but we can use a slightly modified + // version that always keeps the MSB clear and uses the next-to-MSB as the continuation bit. + let byte = UInt64(remainingProgram.first!) + remainingProgram = remainingProgram.dropFirst() + precondition(byte & 0x80 == 0, "Invalid integer leading byte \(byte)") + + if byte & 0x40 == 0 { + return byte + } + var value: UInt64 = byte & 0x3f + var shift: UInt64 = 6 + while true { + let byte = remainingProgram.first! + remainingProgram = remainingProgram.dropFirst() + value |= UInt64(byte & 0x3f) &<< shift + precondition(byte & 0x80 == 0, "Invalid integer leading byte \(byte)") + if byte & 0x40 == 0 { + return value + } + shift &+= 6 + guard shift < 64 else { + fatalError("Bytecode value too large to fit into UInt64") + } + } + } + + /// Reads and returns the next null-terminated string from the bytecode stream. + /// + /// - Precondition: The reader must not be at the end of the bytecode stream. + /// + /// - Returns: An `UnsafeBufferPointer` containing the string that was read from the bytecode + /// stream. This pointer is rebased -- its base address is the start of the string that was + /// just read, not the start of the entire stream -- but its lifetime is still tied to that of + /// the original bytecode stream (which is immortal if it originated from a static string). + package mutating func nextNullTerminatedString() -> UnsafeBufferPointer { + precondition(hasData, "Unexpected end of bytecode stream") + + guard let nullIndex = remainingProgram.firstIndex(of: 0) else { + preconditionFailure("Unexpected end of bytecode stream while looking for end of string") + } + let endIndex = remainingProgram.index(after: nullIndex) + defer { remainingProgram = remainingProgram[endIndex...] } + return .init(rebasing: remainingProgram[.. [UnsafeBufferPointer] { + precondition(hasData, "Unexpected end of bytecode stream") + + let count = Int(nextUInt64()) + return [UnsafeBufferPointer](unsafeUninitializedCapacity: count) { + (buffer, initializedCount) in + for index in 0.. String - mutating func decodeJSON(from: inout JSONDecoder) throws + func encodedJSONString(options: JSONEncodingOptions) throws -> String + mutating func decodeJSON(from: inout JSONDecoder) throws - /// Called when the JSON `null` literal is encountered in a position where - /// a message of the conforming type is expected. The message type can then - /// handle the `null` value differently, if needed; for example, - /// `Google_Protobuf_Value` returns a special instance whose `kind` is set to - /// `.nullValue(.nullValue)`. - /// - /// The default behavior is to return `nil`, which indicates that `null` - /// should be treated as the absence of a message. - static func decodedFromJSONNull() throws -> Self? + /// Called when the JSON `null` literal is encountered in a position where + /// a message of the conforming type is expected. The message type can then + /// handle the `null` value differently, if needed; for example, + /// `Google_Protobuf_Value` returns a special instance whose `kind` is set to + /// `.nullValue(.nullValue)`. + /// + /// The default behavior is to return `nil`, which indicates that `null` + /// should be treated as the absence of a message. + static func decodedFromJSONNull() throws -> Self? } extension _CustomJSONCodable { - internal static func decodedFromJSONNull() -> Self? { - // Return nil by default. Concrete types can provide custom logic. - return nil - } + internal static func decodedFromJSONNull() -> Self? { + // Return nil by default. Concrete types can provide custom logic. + nil + } } diff --git a/Sources/SwiftProtobuf/Data+Extensions.swift b/Sources/SwiftProtobuf/Data+Extensions.swift deleted file mode 100644 index 3e359d732..000000000 --- a/Sources/SwiftProtobuf/Data+Extensions.swift +++ /dev/null @@ -1,34 +0,0 @@ -// Sources/SwiftProtobuf/Data+Extensions.swift - Extension exposing new Data API -// -// Copyright (c) 2014 - 2019 Apple Inc. and the project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See LICENSE.txt for license information: -// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt -// -// ----------------------------------------------------------------------------- -/// -/// Extension exposing new Data API to Swift versions < 5.0. -/// -// ----------------------------------------------------------------------------- - -import Foundation - -#if !swift(>=5.0) -internal extension Data { - @usableFromInline - func withUnsafeBytes(_ body: (UnsafeRawBufferPointer) throws -> T) rethrows -> T { - let c = count - return try withUnsafeBytes { (p: UnsafePointer) throws -> T in - try body(UnsafeRawBufferPointer(start: p, count: c)) - } - } - - mutating func withUnsafeMutableBytes(_ body: (UnsafeMutableRawBufferPointer) throws -> T) rethrows -> T { - let c = count - return try withUnsafeMutableBytes { (p: UnsafeMutablePointer) throws -> T in - try body(UnsafeMutableRawBufferPointer(start: p, count: c)) - } - } -} -#endif diff --git a/Sources/SwiftProtobuf/Decoder.swift b/Sources/SwiftProtobuf/Decoder.swift index 76c28f310..7b4d489a3 100644 --- a/Sources/SwiftProtobuf/Decoder.swift +++ b/Sources/SwiftProtobuf/Decoder.swift @@ -16,7 +16,7 @@ import Foundation -/// This is the abstract protocol used by the generated code +/// Abstract protocol used by the generated code /// to deserialize data. /// /// The generated code looks roughly like this: @@ -29,9 +29,20 @@ import Foundation /// } /// ``` /// -/// For performance, this is mostly broken out into a separate method -/// for singular/repeated fields of every supported type. Note that -/// we don't distinguish "packed" here, since all existing decoders +/// In particular, note that the decoder must provide field _numbers_ +/// corresponding to the numbers in the original proto file. +/// For formats such as Protobuf Binary format that encode field numbers +/// directly, this is trivial. Decoders for formats such as Protobuf +/// Text Format or JSON must use auxiliary information attached to +/// the message type to translate string field names to field numbers. +/// +/// For performance, the field decoding provides three separate methods +/// for every primitive type: +/// * Repeated support accepts an inout Array for repeated fields +/// * Singular support that accepts an inout `Optional`, for proto2 +/// * Singular support that accepts an inout non-`Optional`, for proto3 +/// +/// Note that we don't distinguish "packed" here, since all existing decoders /// treat "packed" the same as "repeated" at this level. (That is, /// even when the serializer distinguishes packed and non-packed /// forms, the deserializer always accepts both.) @@ -44,107 +55,191 @@ import Foundation /// polluting the generated `Enum` and `Message` types with all of the /// necessary generic methods to support this. public protocol Decoder { - /// Called by a `oneof` when it already has a value and is being asked to - /// accept a new value. Some formats require `oneof` decoding to fail in this - /// case. - mutating func handleConflictingOneOf() throws - - /// Returns the next field number, or nil when the end of the input is - /// reached. - /// - /// For JSON and text format, the decoder translates the field name to a - /// number at this point, based on information it obtained from the message - /// when it was initialized. - mutating func nextFieldNumber() throws -> Int? - - // Primitive field decoders - mutating func decodeSingularFloatField(value: inout Float) throws - mutating func decodeSingularFloatField(value: inout Float?) throws - mutating func decodeRepeatedFloatField(value: inout [Float]) throws - mutating func decodeSingularDoubleField(value: inout Double) throws - mutating func decodeSingularDoubleField(value: inout Double?) throws - mutating func decodeRepeatedDoubleField(value: inout [Double]) throws - mutating func decodeSingularInt32Field(value: inout Int32) throws - mutating func decodeSingularInt32Field(value: inout Int32?) throws - mutating func decodeRepeatedInt32Field(value: inout [Int32]) throws - mutating func decodeSingularInt64Field(value: inout Int64) throws - mutating func decodeSingularInt64Field(value: inout Int64?) throws - mutating func decodeRepeatedInt64Field(value: inout [Int64]) throws - mutating func decodeSingularUInt32Field(value: inout UInt32) throws - mutating func decodeSingularUInt32Field(value: inout UInt32?) throws - mutating func decodeRepeatedUInt32Field(value: inout [UInt32]) throws - mutating func decodeSingularUInt64Field(value: inout UInt64) throws - mutating func decodeSingularUInt64Field(value: inout UInt64?) throws - mutating func decodeRepeatedUInt64Field(value: inout [UInt64]) throws - mutating func decodeSingularSInt32Field(value: inout Int32) throws - mutating func decodeSingularSInt32Field(value: inout Int32?) throws - mutating func decodeRepeatedSInt32Field(value: inout [Int32]) throws - mutating func decodeSingularSInt64Field(value: inout Int64) throws - mutating func decodeSingularSInt64Field(value: inout Int64?) throws - mutating func decodeRepeatedSInt64Field(value: inout [Int64]) throws - mutating func decodeSingularFixed32Field(value: inout UInt32) throws - mutating func decodeSingularFixed32Field(value: inout UInt32?) throws - mutating func decodeRepeatedFixed32Field(value: inout [UInt32]) throws - mutating func decodeSingularFixed64Field(value: inout UInt64) throws - mutating func decodeSingularFixed64Field(value: inout UInt64?) throws - mutating func decodeRepeatedFixed64Field(value: inout [UInt64]) throws - mutating func decodeSingularSFixed32Field(value: inout Int32) throws - mutating func decodeSingularSFixed32Field(value: inout Int32?) throws - mutating func decodeRepeatedSFixed32Field(value: inout [Int32]) throws - mutating func decodeSingularSFixed64Field(value: inout Int64) throws - mutating func decodeSingularSFixed64Field(value: inout Int64?) throws - mutating func decodeRepeatedSFixed64Field(value: inout [Int64]) throws - mutating func decodeSingularBoolField(value: inout Bool) throws - mutating func decodeSingularBoolField(value: inout Bool?) throws - mutating func decodeRepeatedBoolField(value: inout [Bool]) throws - mutating func decodeSingularStringField(value: inout String) throws - mutating func decodeSingularStringField(value: inout String?) throws - mutating func decodeRepeatedStringField(value: inout [String]) throws - mutating func decodeSingularBytesField(value: inout Data) throws - mutating func decodeSingularBytesField(value: inout Data?) throws - mutating func decodeRepeatedBytesField(value: inout [Data]) throws - - // Decode Enum fields - mutating func decodeSingularEnumField(value: inout E) throws where E.RawValue == Int - mutating func decodeSingularEnumField(value: inout E?) throws where E.RawValue == Int - mutating func decodeRepeatedEnumField(value: inout [E]) throws where E.RawValue == Int - - // Decode Message fields - mutating func decodeSingularMessageField(value: inout M?) throws - mutating func decodeRepeatedMessageField(value: inout [M]) throws - - // Decode Group fields - mutating func decodeSingularGroupField(value: inout G?) throws - mutating func decodeRepeatedGroupField(value: inout [G]) throws - - // Decode Map fields. - // This is broken into separate methods depending on whether the value - // type is primitive (_ProtobufMap), enum (_ProtobufEnumMap), or message - // (_ProtobufMessageMap) - mutating func decodeMapField(fieldType: _ProtobufMap.Type, value: inout _ProtobufMap.BaseType) throws - mutating func decodeMapField(fieldType: _ProtobufEnumMap.Type, value: inout _ProtobufEnumMap.BaseType) throws where ValueType.RawValue == Int - mutating func decodeMapField(fieldType: _ProtobufMessageMap.Type, value: inout _ProtobufMessageMap.BaseType) throws - - // Decode extension fields - mutating func decodeExtensionField(values: inout ExtensionFieldValueSet, messageType: Message.Type, fieldNumber: Int) throws - - // Run a decode loop decoding the MessageSet format for Extensions. - mutating func decodeExtensionFieldsAsMessageSet(values: inout ExtensionFieldValueSet, - messageType: Message.Type) throws + /// Called by a `oneof` when it already has a value and is being asked to + /// accept a new value. Some formats require `oneof` decoding to fail in this + /// case. + mutating func handleConflictingOneOf() throws + + /// Returns the next field number, or nil when the end of the input is + /// reached. + /// + /// For JSON and text format, the decoder translates the field name to a + /// number at this point, based on information it obtained from the message + /// when it was initialized. + mutating func nextFieldNumber() throws -> Int? + + /// Decode a float value to non-`Optional` field storage + mutating func decodeSingularFloatField(value: inout Float) throws + /// Decode a float value to `Optional` field storage + mutating func decodeSingularFloatField(value: inout Float?) throws + /// Decode float values to repeated field storage + mutating func decodeRepeatedFloatField(value: inout [Float]) throws + /// Decode a double value to non-`Optional` field storage + mutating func decodeSingularDoubleField(value: inout Double) throws + /// Decode a double value to `Optional` field storage + mutating func decodeSingularDoubleField(value: inout Double?) throws + /// Decode double values to repeated field storage + mutating func decodeRepeatedDoubleField(value: inout [Double]) throws + /// Decode an int32 value to non-`Optional` field storage + mutating func decodeSingularInt32Field(value: inout Int32) throws + /// Decode an int32 value to `Optional` field storage + mutating func decodeSingularInt32Field(value: inout Int32?) throws + /// Decode int32 values to repeated field storage + mutating func decodeRepeatedInt32Field(value: inout [Int32]) throws + /// Decode an int64 value to non-`Optional` field storage + mutating func decodeSingularInt64Field(value: inout Int64) throws + /// Decode an int64 value to `Optional` field storage + mutating func decodeSingularInt64Field(value: inout Int64?) throws + /// Decode int64 values to repeated field storage + mutating func decodeRepeatedInt64Field(value: inout [Int64]) throws + /// Decode a uint32 value to non-`Optional` field storage + mutating func decodeSingularUInt32Field(value: inout UInt32) throws + /// Decode a uint32 value to `Optional` field storage + mutating func decodeSingularUInt32Field(value: inout UInt32?) throws + /// Decode uint32 values to repeated field storage + mutating func decodeRepeatedUInt32Field(value: inout [UInt32]) throws + /// Decode a uint64 value to non-`Optional` field storage + mutating func decodeSingularUInt64Field(value: inout UInt64) throws + /// Decode a uint64 value to `Optional` field storage + mutating func decodeSingularUInt64Field(value: inout UInt64?) throws + /// Decode uint64 values to repeated field storage + mutating func decodeRepeatedUInt64Field(value: inout [UInt64]) throws + /// Decode an sint32 value to non-`Optional` field storage + mutating func decodeSingularSInt32Field(value: inout Int32) throws + /// Decode an sint32 value to `Optional` field storage + mutating func decodeSingularSInt32Field(value: inout Int32?) throws + /// Decode sint32 values to repeated field storage + mutating func decodeRepeatedSInt32Field(value: inout [Int32]) throws + /// Decode an sint64 value to non-`Optional` field storage + mutating func decodeSingularSInt64Field(value: inout Int64) throws + /// Decode an sint64 value to `Optional` field storage + mutating func decodeSingularSInt64Field(value: inout Int64?) throws + /// Decode sint64 values to repeated field storage + mutating func decodeRepeatedSInt64Field(value: inout [Int64]) throws + /// Decode a fixed32 value to non-`Optional` field storage + mutating func decodeSingularFixed32Field(value: inout UInt32) throws + /// Decode a fixed32 value to `Optional` field storage + mutating func decodeSingularFixed32Field(value: inout UInt32?) throws + /// Decode fixed32 values to repeated field storage + mutating func decodeRepeatedFixed32Field(value: inout [UInt32]) throws + /// Decode a fixed64 value to non-`Optional` field storage + mutating func decodeSingularFixed64Field(value: inout UInt64) throws + /// Decode a fixed64 value to `Optional` field storage + mutating func decodeSingularFixed64Field(value: inout UInt64?) throws + /// Decode fixed64 values to repeated field storage + mutating func decodeRepeatedFixed64Field(value: inout [UInt64]) throws + /// Decode an sfixed32 value to non-`Optional` field storage + mutating func decodeSingularSFixed32Field(value: inout Int32) throws + /// Decode an sfixed32 value to `Optional` field storage + mutating func decodeSingularSFixed32Field(value: inout Int32?) throws + /// Decode sfixed32 values to repeated field storage + mutating func decodeRepeatedSFixed32Field(value: inout [Int32]) throws + /// Decode an sfixed64 value to non-`Optional` field storage + mutating func decodeSingularSFixed64Field(value: inout Int64) throws + /// Decode an sfixed64 value to `Optional` field storage + mutating func decodeSingularSFixed64Field(value: inout Int64?) throws + /// Decode sfixed64 values to repeated field storage + mutating func decodeRepeatedSFixed64Field(value: inout [Int64]) throws + /// Decode a bool value to non-`Optional` field storage + mutating func decodeSingularBoolField(value: inout Bool) throws + /// Decode a bool value to `Optional` field storage + mutating func decodeSingularBoolField(value: inout Bool?) throws + /// Decode bool values to repeated field storage + mutating func decodeRepeatedBoolField(value: inout [Bool]) throws + /// Decode a string value to non-`Optional` field storage + mutating func decodeSingularStringField(value: inout String) throws + /// Decode a string value to `Optional` field storage + mutating func decodeSingularStringField(value: inout String?) throws + /// Decode string values to repeated field storage + mutating func decodeRepeatedStringField(value: inout [String]) throws + /// Decode a bytes value to non-`Optional` field storage + mutating func decodeSingularBytesField(value: inout Data) throws + /// Decode a bytes value to `Optional` field storage + mutating func decodeSingularBytesField(value: inout Data?) throws + /// Decode bytes values to repeated field storage + mutating func decodeRepeatedBytesField(value: inout [Data]) throws + + // Decode Enum fields + + /// Decode an enum value to non-`Optional` field storage + mutating func decodeSingularEnumField(value: inout E) throws where E.RawValue == Int + /// Decode an enum value to `Optional` field storage + mutating func decodeSingularEnumField(value: inout E?) throws where E.RawValue == Int + /// Decode enum values to repeated field storage + mutating func decodeRepeatedEnumField(value: inout [E]) throws where E.RawValue == Int + + // Decode Message fields + + /// Decode a message value to `Optional` field storage. + /// + /// Unlike the primitive types, message fields are always stored + /// as Swift `Optional` values. + mutating func decodeSingularMessageField(value: inout M?) throws + /// Decode message values to repeated field storage + mutating func decodeRepeatedMessageField(value: inout [M]) throws + + // Decode Group fields + + /// Decode a group value to `Optional` field storage. + /// + /// Unlike the primitive types, message fields are always stored + /// as Swift `Optional` values. + /// Note that groups are only used in proto2. + mutating func decodeSingularGroupField(value: inout G?) throws + /// Decode group values to repeated field storage + mutating func decodeRepeatedGroupField(value: inout [G]) throws + + // Decode Map fields. + // This is broken into separate methods depending on whether the value + // type is primitive (_ProtobufMap), enum (_ProtobufEnumMap), or message + // (_ProtobufMessageMap) + + /// Decode a map whose values are primitive types (including string and bytes) + mutating func decodeMapField( + fieldType: _ProtobufMap.Type, + value: inout _ProtobufMap.BaseType + ) throws + /// Decode a map whose values are protobuf enum types + mutating func decodeMapField( + fieldType: _ProtobufEnumMap.Type, + value: inout _ProtobufEnumMap.BaseType + ) throws where ValueType.RawValue == Int + /// Decode a map whose values are protobuf message types + mutating func decodeMapField( + fieldType: _ProtobufMessageMap.Type, + value: inout _ProtobufMessageMap.BaseType + ) throws + + // Decode extension fields + + /// Decode an extension field + mutating func decodeExtensionField( + values: inout ExtensionFieldValueSet, + messageType: any Message.Type, + fieldNumber: Int + ) throws + + // Run a decode loop decoding the MessageSet format for Extensions. + mutating func decodeExtensionFieldsAsMessageSet( + values: inout ExtensionFieldValueSet, + messageType: any Message.Type + ) throws } /// Most Decoders won't care about Extension handing as in MessageSet /// format, so provide a default implementation simply looping on the /// fieldNumbers and feeding through to extension decoding. extension Decoder { - public mutating func decodeExtensionFieldsAsMessageSet( - values: inout ExtensionFieldValueSet, - messageType: Message.Type - ) throws { - while let fieldNumber = try self.nextFieldNumber() { - try self.decodeExtensionField(values: &values, - messageType: messageType, - fieldNumber: fieldNumber) + public mutating func decodeExtensionFieldsAsMessageSet( + values: inout ExtensionFieldValueSet, + messageType: any Message.Type + ) throws { + while let fieldNumber = try self.nextFieldNumber() { + try self.decodeExtensionField( + values: &values, + messageType: messageType, + fieldNumber: fieldNumber + ) + } } - } } diff --git a/Sources/SwiftProtobuf/Docs.docc/API.md b/Sources/SwiftProtobuf/Docs.docc/API.md new file mode 100644 index 000000000..9866ecf6e --- /dev/null +++ b/Sources/SwiftProtobuf/Docs.docc/API.md @@ -0,0 +1,708 @@ +# API Overview + +--- + +This document explains how you use the code generated by the SwiftProtobuf plugin. + +The generated code relies very heavily on the associated SwiftProtobuf library. +Apart from the actual properties themselves, most of the methods described +below are not explicit in the generated code. +Rather, most of them appear in common shared protocols in the runtime library. +They're collected here to make it easier to understand. + +## Message API + +Messages in the input proto file generate Swift structs in the result. +These structs conform to `SwiftProtobuf.Message` and provide Swift properties for every +field, basic information about the message, standard initializers, and +serialization and deserialization methods. + +Here is a simple proto3 syntax input file to motivate the example below: + +```protobuf +syntax = "proto3"; +message Example { + enum E { + DEFAULT = 0; + } + int32 field1 = 1; + repeated string field2 = 2; +} +``` + +Here is the API for the struct generated from the above. +(As mentioned above, this is not what you'll see if you +open up the generated Swift code in your editor. +This includes a lot of methods from extensions located +in the library, and omits many details of the generated +code that are intended purely for internal use by the library.) + +```swift +public struct Example: SwiftProtobuf.Message { + // The generated struct carries constant properties reflecting + // basic information about the message: + public var protoMessageName: String {return "Example"} + + // Nested enum and message types are nested in the generated Swift + public enum E: SwiftProtobuf.Enum { ... } + + // A public property is created for each field in the proto. + public var field1: Int32 { get set } + public var field2: [String] { get set } + + // Default Initializer + public init() + + // A convenience factory method for constructing + // immutable objects. You can use it like this: + // + // let e = Example.with { + // $0.field1 = 7 + // $0.field2 = ["foo", "bar"] + // } + public static with(_ configurator: (inout Example) -> ()); + + // Messages can be serialized or deserialized to Data objects + // using protobuf binary format. + // Setting `partial` to `true` will suppress checks for required fields. + // An extension map may be needed when decoding nested + // proto2-format messages that utilize extensions. + // See below for more details. + func serializedData() throws -> Data + init(serializedBytes: Bytes) throws { + init(serializedBytes: Bytes, extensions: ExtensionMap? = nil, partial: Bool = false) throws + + // Messages can be serialized or deserialized to JSON format + // as either UTF8-encoded Data objects or as Strings. + func jsonUTF8Bytes(options:) throws -> Bytes + init(jsonUTF8Bytes: Bytes) throws + func jsonString() throws -> String + init(jsonString: String) throws + + // Messages can be serialized or deserialized to Protobuf TextFormat: + func textFormatString() -> String + init(textFormatString: String) throws + + // These are the generated methods used internally by the + // serialization and deserialization mechanisms. + // You should generally not call them directly. + public func decodeMessage(decoder: inout D) throws + public func traverse(visitor: inout V) throws +} + +func ==(lhs: Example, rhs: Example) -> Bool +``` + +### Generated struct name + +The name of generated struct is based on the name of the +message in the proto file. + +For top-level messages, the name is prefixed with the proto package +name as specified in any `package` statements. The name is converted +to camel case with underscore separators to preserve the structure. + +For example, +```protobuf + syntax = "proto3"; + package my_company.cool_project; + message FooBar { + ... + message Baz { + ... + } + } +``` +will by default generate a struct named `MyCompany_CoolProject_FooBar` +with another `Baz` struct nested inside it. +Note that `Baz` is not prefixed because it will be scoped to the parent type. + +You can change the prefix with the `option swift_prefix` statement +in your proto file: +```protobuf + syntax = "proto3"; + package my_company.cool_project; + option swift_prefix="My"; + message FooBar { + ... + } +``` +will generate a struct named `MyFooBar`. +(Note: `swift_prefix` is only supported by protoc 3.2 or later.) + +:warning: The `swift_prefix` option has proven problematic in practice. +Because it ignores the `package` directive, it can easily lead to name +conflicts and other confusion as your shared proto definitions evolve over +time. For example, say you have a file that defines "User" and/or "Settings", +that will work great without the package prefix until you use a second proto +file that defined a different "User" and/or "Settings". Protocol buffers solved +this by having the `package` in the first place, so by overriding that with a +custom Swift prefix makes you that much more likely to have collisions in the +future. If you are considering a prefix just to make the type names +_shorter_/_nicer_, then instead consider using a Swift `typealias` within your +source to remap the names locally where they are used, but keeping the richer +name for the full build to thus avoid the conflicts. + +If the resulting name would collide with a Swift reserved word +or would otherwise cause problems in the generated code, +then the word `Message` is appended to the name. +For example, a `message Int` in the proto file will cause the +generator to emit a `struct IntMessage` to the generated Swift file. + +## Enum API + +Proto enums are translated to Swift enums in a fairly straightforward manner. +The resulting Swift enums conform to the `SwiftProtobuf.Enum` protocol which extends +`RawRepresentable` with a `RawValue` of `Int`. +The generated Swift enum will have a case for each enum value in the proto file. + +Proto3 syntax enums have an additional `UNRECOGNIZED(Int)` case that is used whenever +an unrecognized value is parsed from protobuf serialization or from other +serializations that store integer enum values. +Proto2 enums lack this extra case. + +If deserialization encounters an unknown value: +- For JSON, if the value was in _string_ form, it causes a parsing error as + it can't be mapped to a value. If the value was an integer value, then a + proto3 syntax enum can still capture it via the `UNRECOGNIZED(Int)` case. +- For protobuf binary, the value is handled as an unknown field. + +```swift +public enum MyEnum: SwiftProtobuf.Enum { + public typealias RawValue = Int + + // Case for each value + // Names are translated to a lowerCamelCase convention from + // the UPPER_CASE convention in the proto file: + case default + case other + case andMore + case UNRECOGNIZED(Int) // Only in proto3 enums + + // Initializer selects the default value (see proto2 and proto3 + // language guides for details). + public init() + + public init?(rawValue: Int) + public var rawValue: Int + public var hashValue: Int + public var debugDescription: String +} +``` + +### Enum and enum case naming + +The name of the Swift enum is copied directly from the name in the proto file, +prefixed with the package name or the name from `option swift_prefix` +as documented above for messages. +If that name would conflict with a Swift reserved word or otherwise +cause problems for the generated code, the word `Enum` will +be appended to the name. + +Enum case names are converted from `UPPER_SNAKE_CASE` conventions +in the proto file to `lowerCamelCase` in the Swift code. + +If the enum case name includes the enum name as a prefix (ignoring case +and underscore characters), that prefix is stripped. +If the stripped name would conflict with another entry in the +same enum, the conflicting cases will have their respective numeric values +appended to ensure the results are unique. +For example: +```protobuf +syntax = "proto3"; +enum TestEnum { + TEST_ENUM_FOO = 0; + TESTENUM_BAR = 1; + BAZ = 2; + BAR = -3; +} +``` +becomes +```swift +enum TestEnum { + case foo = 0 + case bar_1 = 1 + case baz = 2 + case bar_n3 = -3 // 'n' for "negative" +} +``` + +Note #1: Enum aliases can potentially result in conflicting names +even after appending the case numeric value. +Since aliases are only supported to provide alternate names for +the same underlying numeric value, SwiftProtobuf simply drops +the alias in such cases. +See the protobuf documentation for `allow_alias` for more information +about enum case aliases. + +Note #2: In most cases where an enum case name might conflict with a +Swift reserved word, or otherwise cause problems, the code generator +will protect the enum case name by surrounding it with backticks. +In the few cases where this is insufficient, the code generator +will append an additional underscore `_` to the converted name. + +## Message Fields + +Each message field in the `proto` file is compiled into a corresponding +property on the generated struct. +Field names are converted from `snake_case` conventions in the proto +file to `lowerCamelCase` property names in the Swift file. + +Note: In many cases where the resulting name would cause a problem in +the generated Swift, the code generator will protect the field name by +surrounding it with backticks. +Sometimes, this is insufficient and the code generator will append +a `_p` to the converted name. + +Types in the proto file are mapped to Swift types as follows: + +### Basic types + +| Proto type | Swift Type | +| ------------------------- | ------------------ | +| int32 | Int32 | +| sint32 | Int32 | +| sfixed32 | Int32 | +| uint32 | UInt32 | +| fixed32 | UInt32 | +| int64 | Int64 | +| sint64 | Int64 | +| sfixed64 | Int64 | +| uint64 | UInt64 | +| fixed64 | UInt64 | +| bool | Bool | +| float | Float | +| double | Double | +| string | String | +| bytes | Data | + +### Generated Types + +Enums in the proto file generate Int-valued enums in the Swift code. + +Groups in the proto file generate Swift structs that conform to `SwiftProtobuf.Message`. + +Messages in the proto file generate Swift structs that conform to +`SwiftProtobuf.Message`. + +Note: There is also a `SwiftProtobuf._MessageImplementationBase` +protocol. You should not refer to that directly; use +`SwiftProtobuf.Message` when you need to work with arbitrary groups or +messages. + +### Type modifiers + +**Proto3 singular fields** generate properties of the corresponding type above. +These properties are initialized to the appropriate default value as specified +in the proto3 specification: + +* Numeric fields are initialized to zero. +* Boolean fields are initialize to false. +* String fields are initialized to the empty string. +* Bytes fields are initialized to an empty Data() object. +* Enum fields are initialized to the default value (the value corresponding to + zero, which must be the first item in the enum). +* Message fields are initialized to an empty message of the appropriate type. + +Notes: For performance, the field may be initialized lazily, but this is +invisible to the user. The property will be serialized if it has a non-default +value. + +**Proto2 `optional` fields** generate properties of the corresponding +type above. +It also generates `has` and `clear` methods that can be used to +test whether the field has a value or to reset it to it's default. +If a default value was specified in the proto file, the field will be +initialized to that value, and will be reset to that value when +you invoke the `clear` method. +If no default value was specified, the default value is the same +as for proto3 singular fields above. + +**Proto2 `required` fields** Required fields behave the same as +optional fields, except that binary serialization or deserialization may +fail if the field is not provided. + +To illustrate the handling of proto2 fields, consider the following +short example: +```protobuf +syntax = "proto2"; +message ExampleProto2 { + optional int32 item_count = 1 [default = 12]; + optional string item_label = 2; +} +``` + +This will generate the following field structure in the Swift code: +```swift +public struct ExampleProto2 { + public var itemCount: Int32 = 12 + public var hasItemCount: Bool + public mutating func clearItemCount() + + public var itemLabel: String = ""; + public var hasItemLabel: Bool + public mutating func clearItemLabel() +} +``` + +### Compound types + +**Singular message fields** generate simple properties of the corresponding +Swift struct type. +The fields are initialized with default instances of the struct. +(This initialization is usually done lazily the first time you read such +a field.) +Message fields generate `has` and `clear` methods as above for both proto2 +and proto3 syntax files. + +**Proto2 groups** act exactly like messages in all respects, except that +they are serialized differently when they appear as a field value. + +**Proto `repeated` fields** generate simple properties of type `Array` where +T is the base type from above. +Repeated fields are always initialized to an empty array. + +**Proto `map` fields** generate simple properties of type `Dictionary` +where T and U are the respective key and value types from above. +Map fields are always initialized to an empty map. + +### Oneof fields + +Oneof fields generate an enum with a case for each associated field. +These enums conform to `ProtobufOneofEnum`. +Every case has an associated value corresponding to the declared field. + +The message will have a read/write property named after the enum which contains +the enum value; this property has an optional type and will be `nil` if no oneof field is set. + +It also will contain a separate read/write +computed property for each member field of the enum. + +Here is a simple example of a message with a `oneof` structure: +```protobuf +syntax = "proto3"; +message ExampleOneOf { + int32 field1 = 1; + oneof alternatives { + int64 id = 2; + string name = 3; + } +} +``` + +And here is the corresponding generated Swift code. +Note that the two fields `id` and `name` above share storage, thanks +to the generated `OneOf_Alternatives` enum type. +Also note that you can access the `alternatives` property here +directly if you want to use a `switch` construct to analyze +the fields contained in the oneof: +```swift +public struct ExampleOneOf: SwiftProtobuf.Message { + enum OneOf_Alternatives { + case id(Int32) + case name(String) + } + + var field1: Int32 = 0 + var alternatives: OneOf_Alternatives? + + var id: Int32 { + get { + if case .id(let v)? = alternatives {return v} + else {return 0} + } + set { + alternatives = .id(newValue) + } + } + var name: String { + get { + if case .name(let v)? = alternatives {return v} + else {return ""} + } + set { + alternatives = .name(newValue) + } + } +} +``` + +## Well-Known Types + +For most of the proto3 well-known types, the Swift API is exactly what you would +expect from the corresponding proto definitions. (In fact, the runtime library +version for most of these is simply generated.) For convenience, most of these +also have hand-written extensions that expand the functionality with various +convenience methods. The variations from the default generated behavior are described below. + +| Proto Type | Swift Type | +| ------------------------- | ----------------------- | +| google.protobuf.Any | Google_Protobuf_Any | +| google.protobuf.Api | Google_Protobuf_Api | +| google.protobuf.BoolValue | Google_Protobuf_BoolValue | +| google.protobuf.BytesValue | Google_Protobuf_BytesValue | +| google.protobuf.DoubleValue | Google_Protobuf_DoubleValue | +| google.protobuf.Duration | Google_Protobuf_Duration | +| google.protobuf.Empty | Google_Protobuf_Empty | +| google.protobuf.FieldMask | Google_Protobuf_FieldMask | +| google.protobuf.FloatValue | Google_Protobuf_FloatValue | +| google.protobuf.Int64Value | Google_Protobuf_Int64Value | +| google.protobuf.ListValue | Google_Protobuf_ListValue | +| google.protobuf.StringValue | Google_Protobuf_StringValue | +| google.protobuf.Struct | Google_Protobuf_Struct | +| google.protobuf.Timestamp | Google_Protobuf_Timestamp | +| google.protobuf.Type | Google_Protobuf_Type | +| google.protobuf.UInt32Value | Google_Protobuf_UInt32Value | +| google.protobuf.UInt64Value | Google_Protobuf_UInt64Value | +| google.protobuf.Value | Google_Protobuf_Value | + + +For most of these types, you should refer to Google's documentation. +Details are provided here to explain details of how these are +implemented by SwiftProtobuf. + +### Google_Protobuf_Value, Google_Protobuf_Struct, Google_Protobuf_ArrayValue + +These types can be used for ad hoc encoding and decoding of arbitrary +JSON structures. + +They are particularly useful when dealing with legacy JSON formats where +the bulk of the structure is well-defined and maps cleanly into protobuf +JSON conventions but there are occasional fields that may contain +arbitrary data. + +```protobuf +syntax = "proto3"; +message ExampleAdHocJSON { + int32 id = 1; + string name = 2; + google.protobuf.Struct jsonObject = 3; +} +``` + +`Google_Protobuf_NullValue` is a simple single-value enum that +corresponds to `null` in JSON syntax. +In particular, `NullValue` and `Value` are the only ways +to determine if a `null` appeared in JSON. +(In all other circumstances, protobuf JSON decoders treat JSON `null` +as either illegal or as a default value for the field.) + +`Google_Protobuf_Struct` contains a single `fields` dictionary +mapping strings to `Google_Protobuf_Value` objects. +It also conforms to `ExpressibleByDictionaryLiteral` and +provides a `subscript` for directly accessing the values by name. + +`Google_Protobuf_ArrayValue` is similar, it conforms to `ExpressibleByArrayLiteral` +and provides an integer-keyed `subscript` for accessing values by index. + +The `Google_Protobuf_Value` type can support any JSON type and provides +a `oneof` view of the contents. + +### Google_Protobuf_Any + +The `google.protobuf.Any` proto type is provided as `Google_Protobuf_Any`. +This type serves as a general container that can store any protobuf +message type. + +For example, suppose you have a message that contains such a field, as defined +in the following proto file: +```protobuf +syntax = "proto3"; +import "google/protobuf/any.proto"; +message ExampleAny { + string message = 1; + google.protobuf.Any detail = 2; +} +``` + +If you have some other (separately-defined) message type `Foo`, you can +store one of those objects in the `ExampleAny` struct by wrapping +it in a `Google_Protobuf_Any` as follows: +```swift + let foo = Foo() + var exampleAny = ExampleAny() + exampleAny.detail = Google_Protobuf_Any(message: foo) +``` + +You can then encode or decode the `exampleAny` as usual, even on systems +that do not have the definition for `Foo`. + +Of course, after decoding an `ExampleAny`, you need to inspect the +`detail` field and then extract the inner message yourself: +```swift + let anyObject = decodedExampleAny.detail + if anyObject.isA(Foo.self) { + let foo = try Foo(unpackingAny: anyObject) + } +``` + +Caveat: The inner object is not actually decoded until you +call the `unpackingAny` initializer. +In particular, it is possible for the outer object to decode +successfully even when the inner object is malformed. + +You can also, of course, have `repeated` Any fields or +use them in other more complex structures. + +When coded to JSON format, the Any field will be written +in a verbose form that expands the JSON encoding of the +contained object. +This makes the result easier to read and easier to interoperate +with non-protobuf JSON implementations, but means that you +cannot translate between binary and JSON encodings without +having the type information available. +If you need to translate objects between binary and JSON +encodings, you should carefully read the documentation +comments for `Google_Protobuf_Any.register()` which explains +how to make your custom types available to the decode/encode machinery +for this purpose. + +Note: Google's C++ implementation will not decode JSON +unless it understands the types of all inner objects. +SwiftProtobuf can decode JSON in this case and can re-encode +back to JSON. It only needs the types when translating +between dissimilar encodings. + +Caveat: SwiftProtobuf's Text format decoding will currently +ignore Any fields if the types are not registered. + +### Google_Protobuf_Duration, Google_Protobuf_Timestamp + +The `Google_Protobuf_Duration` and `Google_Protobuf_Timestamp` structs provide +standard ways to exchange durations and timestamps between systems. + +Following Google's specification, serializing one of these objects to JSON +will throw an error if the duration is greater +than 315576000000 seconds or if the timestamp is before `0001-01-01T00:00:00Z` +or after `9999-12-31T23:59:59.999999999Z` in the Gregorian proleptic calendar. + +The `Google_Protobuf_Duration` type conforms to +`ExpressibleByFloatLiteral`; it can be initialized with a double representing +the number of seconds. + +A `Google_Protobuf_Duration` can be converted to and from a Foundation `TimeInterval`: +```swift +extension Google_Protobuf_Duration { + public init(timeInterval: TimeInterval) + public var timeInterval: TimeInterval {get} +} +``` + +A `Google_Protobuf_Timestamp` can be converted to and from common Foundation timestamp +representations: +```swift +extension Google_Protobuf_Timestamp { + /// To/From a Foundation `Date` object + public init(date: Date) + public var date: Date + /// Relative to POSIX epoch of 00:00:00UTC 1 Jan 1970 + public init(timeIntervalSince1970: TimeInterval) + public var timeIntervalSince1970: TimeInterval {get} + /// Relative to Foundation's "reference date" of 00:00:00UTC 1 Jan 2001 + public init(timeIntervalSinceReferenceDate: TimeInterval) + public var timeIntervalSinceReferenceDate: TimeInterval {get} +} +``` + +There are also overrides for simple arithmetic with durations and timestamps: + +```swift +func -(lhs: Google_Protobuf_Timestamp, rhs: Google_Protobuf_Timestamp) -> Google_Protobuf_Duration +func -(lhs: Google_Protobuf_Duration, rhs: Google_Protobuf_Duration) -> Google_Protobuf_Duration +public func +(lhs: Google_Protobuf_Duration, rhs: Google_Protobuf_Duration) -> Google_Protobuf_Duration +public func -(operand: Google_Protobuf_Duration) -> Google_Protobuf_Duration +public func -(lhs: Google_Protobuf_Timestamp, rhs: Google_Protobuf_Duration) -> Google_Protobuf_Timestamp +public func +(lhs: Google_Protobuf_Timestamp, rhs: Google_Protobuf_Duration) -> Google_Protobuf_Timestamp +``` + + +## Extensions + +Extensions are used to add additional properties to messages defined elsewhere. +They are fully supported in proto2 files. + +They are supported in proto3 syntax only when extending the standard Descriptor type. + +Extensions are ignored when serializing or deserializing to JSON. + +They are defined in proto2 files as follows: + +```protobuf +/// File sample.proto +syntax="proto2"; +message CanBeExtended { + extensions 100 to 200; +} + +extend CanBeExtended { + optional int32 extensionField = 100; +} +``` + +There are several pieces to the extension support: + +* **Extensible Messages** (such as `CanBeExtended` above) conform to + [`ExtensibleMessage`](https://github.com/apple/swift-protobuf/blob/main/Sources/SwiftProtobuf/ExtensibleMessage.swift) + and define some additional methods needed by the other components. You + should _not_ need to use these methods directly. + +* **Extension objects** are opaque objects that define the extension itself, + including storage and serialization details. Because proto allows extension + names to be reused in different scopes, these objects appear in the scope + corresponding to the context where the proto extension was defined (file + level or within the message that wrapped the `extend` directive); generally + it does not correspond to that of the message being extended. In the above + example, the extension object would be `Extensions_extensionField` at the + file scope. Most common Swift code accessing Extensions won't have to access + these directly. + +* **Extension properties** use Swift's `extension` capability to add properties + to the message that is being extended. In most cases, you can simply use + the extension properties without understanding any of the other extension + machinery. The above example creates a Swift extension of `CanBeExtended` + that defines a new property `extensionField` of type `Int32`. + +* **Extension maps** are collections of extension objects indexed by the target + message and field number. An extension map is generated for every file that + defined proto extensions and included as a static global variable. It is + named based on the proto package, filename, and then ends in `_Extensions`, + so the above file would be `Sample_Extensions`. These maps are then used + by the `Message` apis for parsing/merging extension fields in the binary + data; if a mapping isn't found, the extension field ends up in the + `unknownFields` on the message. + + If you need to handle extensions defined in multiple files, you can build up + your own `ExtensionMap` will all the data by using + [`SimpleExtensionMap`](https://github.com/apple/swift-protobuf/blob/main/Sources/SwiftProtobuf/SimpleExtensionMap.swift). + The easiest way is to create a new `SimpleExtensionMap` passing in a list + of the generated `*_Extensions` `ExtensionMap`s that were generated for you + in each file (i.e. - `let myMap = SimpleExtensionMap(Sample_Extensions, …)`). + +## Descriptors + +Some other languages expose _Descriptor_ objects for messages, enums, fields, +and oneof, but not all languages. The `.proto` language also allows developers +to add options to messages, fields, etc. that can be looked up at runtime in +those descriptors. + +Support for descriptors ends up requiring some amount of code, but more +importantly it requires capturing a large binary blob of data for every +message, enum, oneof, etc. That data has two potential issues, it bloats the +binaries, and it is something that can be extracted from the binary to help +reverse engineer details about the binary. + +For these reasons, SwiftProtobuf does not current support anything like the +Descriptor objects. It is something that could get revisited in the future, +but will need careful consideration; the bloat/size issues is of the most +concern because of Swift's common use for mobile applications. + +## Aside: proto2 vs. proto3 syntax + +The terms *proto2* and *proto3* refer to two different dialects of the proto +*language.* The older proto2 language dates back to 2008, the proto3 language +was introduced in 2015. These should not be confused with versions of the +protobuf *project* or the protoc *software*. In particular, the protoc 3.x +software has solid support for both proto2 and proto3 language dialects. Many +people continue to use the proto2 language with protoc 3.x software because they have +existing systems that depend on particular features of the proto2 language that +were changed in the proto3 language. diff --git a/Sources/SwiftProtobuf/Docs.docc/index.md b/Sources/SwiftProtobuf/Docs.docc/index.md new file mode 100644 index 000000000..17b09de1d --- /dev/null +++ b/Sources/SwiftProtobuf/Docs.docc/index.md @@ -0,0 +1,18 @@ +# ``SwiftProtobuf`` + +Support library for Swift code generated by protoc-gen-swift. + +## Getting Started + +.... + +## Topics + +### Stuff + +- + +- ``protoc-gen-swift`` +- ``Sometopic`` +- ``API Overview`` +- ``Message`` diff --git a/Sources/SwiftProtobuf/DoubleParser.swift b/Sources/SwiftProtobuf/DoubleParser.swift index 92edb15dd..e7960c6b1 100644 --- a/Sources/SwiftProtobuf/DoubleParser.swift +++ b/Sources/SwiftProtobuf/DoubleParser.swift @@ -17,43 +17,58 @@ import Foundation /// Support parsing float/double values from UTF-8 internal class DoubleParser { // Temporary buffer so we can null-terminate the UTF-8 string - // before calling the C standard libray to parse it. + // before calling the C standard library to parse it. + // // In theory, JSON writers should be able to represent any IEEE Double // in at most 25 bytes, but many writers will emit more digits than - // necessary, so we size this generously. - private var work = - UnsafeMutableBufferPointer.allocate(capacity: 128) + // necessary, so we size this generously; but we could still fail to + // parse if someone crafts something really long (especially for + // TextFormat due to overflows (see below)). + private var work = + UnsafeMutableBufferPointer.allocate(capacity: 128) deinit { work.deallocate() } - func utf8ToDouble(bytes: UnsafeRawBufferPointer, - start: UnsafeRawBufferPointer.Index, - end: UnsafeRawBufferPointer.Index) -> Double? { - return utf8ToDouble(bytes: UnsafeRawBufferPointer(rebasing: bytes[start.. Double? { + utf8ToDouble(bytes: UnsafeRawBufferPointer(rebasing: bytes[start.. Double? { + func utf8ToDouble(bytes: UnsafeRawBufferPointer, finiteOnly: Bool = true) -> Double? { // Reject unreasonably long or short UTF8 number if work.count <= bytes.count || bytes.count < 1 { return nil } - #if swift(>=4.1) - UnsafeMutableRawBufferPointer(work).copyMemory(from: bytes) - #else - UnsafeMutableRawBufferPointer(work).copyBytes(from: bytes) - #endif + UnsafeMutableRawBufferPointer(work).copyMemory(from: bytes) work[bytes.count] = 0 // Use C library strtod() to parse it var e: UnsafeMutablePointer? = work.baseAddress let d = strtod(work.baseAddress!, &e) - // Fail if strtod() did not consume everything we expected - // or if strtod() thought the number was out of range. - if e != work.baseAddress! + bytes.count || !d.isFinite { + // Fail if strtod() did not consume everything we expected. + guard e == work.baseAddress! + bytes.count else { + return nil + } + + // If strtod() thought the number was out of range, it will return + // a non-finite number... + // + // TextFormat specifically calls out handling for overflows for + // float/double fields: + // https://protobuf.dev/reference/protobuf/textformat-spec/#value + // + // > Overflows are treated as infinity or -infinity. + // + // But the JSON protobuf spec doesn't mention anything: + // https://protobuf.dev/programming-guides/proto3/#json + if finiteOnly && !d.isFinite { return nil } return d diff --git a/Sources/SwiftProtobuf/Enum.swift b/Sources/SwiftProtobuf/Enum.swift index d5965bc7c..1cd45dc29 100644 --- a/Sources/SwiftProtobuf/Enum.swift +++ b/Sources/SwiftProtobuf/Enum.swift @@ -15,81 +15,76 @@ /// // ----------------------------------------------------------------------------- -// TODO: `Enum` should require `Sendable` but we cannot do so yet without possibly breaking compatibility. - /// Generated enum types conform to this protocol. -public protocol Enum: RawRepresentable, Hashable { - /// Creates a new instance of the enum initialized to its default value. - init() +@preconcurrency +public protocol Enum: RawRepresentable, Hashable, Sendable { + /// Creates a new instance of the enum initialized to its default value. + init() - /// Creates a new instance of the enum from the given raw integer value. - /// - /// For proto2 enums, this initializer will fail if the raw value does not - /// correspond to a valid enum value. For proto3 enums, this initializer never - /// fails; unknown values are created as instances of the `UNRECOGNIZED` case. - /// - /// - Parameter rawValue: The raw integer value from which to create the enum - /// value. - init?(rawValue: Int) + /// Creates a new instance of the enum from the given raw integer value. + /// + /// For proto2 enums, this initializer will fail if the raw value does not + /// correspond to a valid enum value. For proto3 enums, this initializer never + /// fails; unknown values are created as instances of the `UNRECOGNIZED` case. + /// + /// - Parameter rawValue: The raw integer value from which to create the enum + /// value. + init?(rawValue: Int) - /// The raw integer value of the enum value. - /// - /// For a recognized enum case, this is the integer value of the case as - /// defined in the .proto file. For `UNRECOGNIZED` cases in proto3, this is - /// the value that was originally decoded. - var rawValue: Int { get } + /// The raw integer value of the enum value. + /// + /// For a recognized enum case, this is the integer value of the case as + /// defined in the .proto file. For `UNRECOGNIZED` cases in proto3, this is + /// the value that was originally decoded. + var rawValue: Int { get } } extension Enum { -#if swift(>=4.2) - public func hash(into hasher: inout Hasher) { - hasher.combine(rawValue) - } -#else // swift(>=4.2) - public var hashValue: Int { - return rawValue - } -#endif // swift(>=4.2) + public func hash(into hasher: inout Hasher) { + hasher.combine(rawValue) + } - /// Internal convenience property representing the name of the enum value (or - /// `nil` if it is an `UNRECOGNIZED` value or doesn't provide names). - /// - /// Since the text format and JSON names are always identical, we don't need - /// to distinguish them. - internal var name: _NameMap.Name? { - guard let nameProviding = Self.self as? _ProtoNameProviding.Type else { - return nil + /// Internal convenience property representing the name of the enum value (or + /// `nil` if it is an `UNRECOGNIZED` value or doesn't provide names). + /// + /// Since the text format and JSON names are always identical, we don't need + /// to distinguish them. + package var name: _NameMap.Name? { + guard let nameProviding = Self.self as? any _ProtoNameProviding.Type else { + return nil + } + return nameProviding._protobuf_nameMap.names(for: rawValue)?.proto } - return nameProviding._protobuf_nameMap.names(for: rawValue)?.proto - } - /// Internal convenience initializer that returns the enum value with the - /// given name, if it provides names. - /// - /// Since the text format and JSON names are always identical, we don't need - /// to distinguish them. - /// - /// - Parameter name: The name of the enum case. - internal init?(name: String) { - guard let nameProviding = Self.self as? _ProtoNameProviding.Type, - let number = nameProviding._protobuf_nameMap.number(forJSONName: name) else { - return nil + /// Internal convenience initializer that returns the enum value with the + /// given name, if it provides names. + /// + /// Since the text format and JSON names are always identical, we don't need + /// to distinguish them. + /// + /// - Parameter name: The name of the enum case. + internal init?(name: String) { + guard let nameProviding = Self.self as? any _ProtoNameProviding.Type, + let number = nameProviding._protobuf_nameMap.number(forJSONName: name) + else { + return nil + } + self.init(rawValue: number) } - self.init(rawValue: number) - } - /// Internal convenience initializer that returns the enum value with the - /// given name, if it provides names. - /// - /// Since the text format and JSON names are always identical, we don't need - /// to distinguish them. - /// - /// - Parameter name: Buffer holding the UTF-8 bytes of the desired name. - internal init?(rawUTF8: UnsafeRawBufferPointer) { - guard let nameProviding = Self.self as? _ProtoNameProviding.Type, - let number = nameProviding._protobuf_nameMap.number(forJSONName: rawUTF8) else { - return nil + /// Internal convenience initializer that returns the enum value with the + /// given name, if it provides names. + /// + /// Since the text format and JSON names are always identical, we don't need + /// to distinguish them. + /// + /// - Parameter name: Buffer holding the UTF-8 bytes of the desired name. + internal init?(rawUTF8: UnsafeRawBufferPointer) { + guard let nameProviding = Self.self as? any _ProtoNameProviding.Type, + let number = nameProviding._protobuf_nameMap.number(forJSONName: rawUTF8) + else { + return nil + } + self.init(rawValue: number) } - self.init(rawValue: number) - } } diff --git a/Sources/SwiftProtobuf/ExtensibleMessage.swift b/Sources/SwiftProtobuf/ExtensibleMessage.swift index f1fb99149..4fbe56cce 100644 --- a/Sources/SwiftProtobuf/ExtensibleMessage.swift +++ b/Sources/SwiftProtobuf/ExtensibleMessage.swift @@ -13,6 +13,7 @@ // ----------------------------------------------------------------------------- // Messages that support extensions implement this protocol +@preconcurrency public protocol ExtensibleMessage: Message { var _protobuf_extensionFieldValues: ExtensionFieldValueSet { get set } } @@ -24,13 +25,13 @@ extension ExtensibleMessage { public func getExtensionValue(ext: MessageExtension) -> F.ValueType? { if let fieldValue = _protobuf_extensionFieldValues[ext.fieldNumber] as? F { - return fieldValue.value + return fieldValue.value } return nil } public func hasExtensionValue(ext: MessageExtension) -> Bool { - return _protobuf_extensionFieldValues[ext.fieldNumber] is F + _protobuf_extensionFieldValues[ext.fieldNumber] is F } public mutating func clearExtensionValue(ext: MessageExtension) { @@ -41,12 +42,16 @@ extension ExtensibleMessage { // Additional specializations for the different types of repeated fields so // setting them to an empty array clears them from the map. extension ExtensibleMessage { - public mutating func setExtensionValue(ext: MessageExtension, Self>, value: [T.BaseType]) { + public mutating func setExtensionValue( + ext: MessageExtension, Self>, + value: [T.BaseType] + ) { _protobuf_extensionFieldValues[ext.fieldNumber] = value.isEmpty ? nil : RepeatedExtensionField(protobufExtension: ext, value: value) } - public mutating func setExtensionValue(ext: MessageExtension, Self>, value: [T.BaseType]) { + public mutating func setExtensionValue(ext: MessageExtension, Self>, value: [T.BaseType]) + { _protobuf_extensionFieldValues[ext.fieldNumber] = value.isEmpty ? nil : PackedExtensionField(protobufExtension: ext, value: value) } @@ -61,7 +66,8 @@ extension ExtensibleMessage { value.isEmpty ? nil : PackedEnumExtensionField(protobufExtension: ext, value: value) } - public mutating func setExtensionValue(ext: MessageExtension, Self>, value: [M]) { + public mutating func setExtensionValue(ext: MessageExtension, Self>, value: [M]) + { _protobuf_extensionFieldValues[ext.fieldNumber] = value.isEmpty ? nil : RepeatedMessageExtensionField(protobufExtension: ext, value: value) } diff --git a/Sources/SwiftProtobuf/ExtensionFieldValueSet.swift b/Sources/SwiftProtobuf/ExtensionFieldValueSet.swift index fc48b0e2b..69d8450b2 100644 --- a/Sources/SwiftProtobuf/ExtensionFieldValueSet.swift +++ b/Sources/SwiftProtobuf/ExtensionFieldValueSet.swift @@ -14,84 +14,76 @@ /// // ----------------------------------------------------------------------------- -// TODO: `ExtensionFieldValueSet` should be `Sendable` but we cannot do so yet without possibly breaking compatibility. +public struct ExtensionFieldValueSet: Hashable, Sendable { + fileprivate var values = [Int: any AnyExtensionField]() -public struct ExtensionFieldValueSet: Hashable { - fileprivate var values = [Int : AnyExtensionField]() - - public static func ==(lhs: ExtensionFieldValueSet, - rhs: ExtensionFieldValueSet) -> Bool { - guard lhs.values.count == rhs.values.count else { - return false - } - for (index, l) in lhs.values { - if let r = rhs.values[index] { - if type(of: l) != type(of: r) { - return false + public static func == ( + lhs: ExtensionFieldValueSet, + rhs: ExtensionFieldValueSet + ) -> Bool { + guard lhs.values.count == rhs.values.count else { + return false } - if !l.isEqual(other: r) { - return false + for (index, l) in lhs.values { + if let r = rhs.values[index] { + if type(of: l) != type(of: r) { + return false + } + if !l.isEqual(other: r) { + return false + } + } else { + return false + } } - } else { - return false - } + return true } - return true - } - public init() {} + public init() {} -#if swift(>=4.2) - public func hash(into hasher: inout Hasher) { - // AnyExtensionField is not Hashable, and the Self constraint that would - // add breaks some of the uses of it; so the only choice is to manually - // mix things in. However, one must remember to do things in an order - // independent manner. - var hash = 16777619 - for (fieldNumber, v) in values { - var localHasher = hasher - localHasher.combine(fieldNumber) - v.hash(into: &localHasher) - hash = hash &+ localHasher.finalize() - } - hasher.combine(hash) - } -#else // swift(>=4.2) - public var hashValue: Int { - var hash = 16777619 - for (fieldNumber, v) in values { - // Note: This calculation cannot depend on the order of the items. - hash = hash &+ fieldNumber &+ v.hashValue + public func hash(into hasher: inout Hasher) { + // AnyExtensionField is not Hashable, and the Self constraint that would + // add breaks some of the uses of it; so the only choice is to manually + // mix things in. However, one must remember to do things in an order + // independent manner. + var hash = 16_777_619 + for (fieldNumber, v) in values { + var localHasher = hasher + localHasher.combine(fieldNumber) + v.hash(into: &localHasher) + hash = hash &+ localHasher.finalize() + } + hasher.combine(hash) } - return hash - } -#endif // swift(>=4.2) - public func traverse(visitor: inout V, start: Int, end: Int) throws { - let validIndexes = values.keys.filter {$0 >= start && $0 < end} - for i in validIndexes.sorted() { - let value = values[i]! - try value.traverse(visitor: &visitor) + public func traverse(visitor: inout V, start: Int, end: Int) throws { + let validIndexes = values.keys.filter { $0 >= start && $0 < end } + for i in validIndexes.sorted() { + let value = values[i]! + try value.traverse(visitor: &visitor) + } } - } - public subscript(index: Int) -> AnyExtensionField? { - get { return values[index] } - set { values[index] = newValue } - } + public subscript(index: Int) -> (any AnyExtensionField)? { + get { values[index] } + set { values[index] = newValue } + } - mutating func modify(index: Int, _ modifier: (inout AnyExtensionField?) throws -> ReturnType) rethrows -> ReturnType { - // This internal helper exists to invoke the _modify accessor on Dictionary for the given operation, which can avoid CoWs - // during the modification operation. - return try modifier(&values[index]) - } + mutating func modify( + index: Int, + _ modifier: (inout (any AnyExtensionField)?) throws -> ReturnType + ) rethrows -> ReturnType { + // This internal helper exists to invoke the _modify accessor on Dictionary for the given operation, which can avoid CoWs + // during the modification operation. + try modifier(&values[index]) + } - public var isInitialized: Bool { - for (_, v) in values { - if !v.isInitialized { - return false - } + public var isInitialized: Bool { + for (_, v) in values { + if !v.isInitialized { + return false + } + } + return true } - return true - } } diff --git a/Sources/SwiftProtobuf/ExtensionFields.swift b/Sources/SwiftProtobuf/ExtensionFields.swift index 7aefd00c1..17c7ff0f2 100644 --- a/Sources/SwiftProtobuf/ExtensionFields.swift +++ b/Sources/SwiftProtobuf/ExtensionFields.swift @@ -12,13 +12,6 @@ /// // ----------------------------------------------------------------------------- -#if !swift(>=4.2) -private let i_2166136261 = Int(bitPattern: 2166136261) -private let i_16777619 = Int(16777619) -#endif - -// TODO: `AnyExtensionField` should require `Sendable` but we cannot do so yet without possibly breaking compatibility. - // // Type-erased Extension field implementation. // Note that it has no "self or associated type" references, so can @@ -29,163 +22,153 @@ private let i_16777619 = Int(16777619) // equality with some other extension field; but it's type-sealed // so you can't actually access the contained value itself. // -public protocol AnyExtensionField: CustomDebugStringConvertible { -#if swift(>=4.2) - func hash(into hasher: inout Hasher) -#else - var hashValue: Int { get } -#endif - var protobufExtension: AnyMessageExtension { get } - func isEqual(other: AnyExtensionField) -> Bool - - /// Merging field decoding - mutating func decodeExtensionField(decoder: inout T) throws - - /// Fields know their own type, so can dispatch to a visitor - func traverse(visitor: inout V) throws - - /// Check if the field is initialized. - var isInitialized: Bool { get } +@preconcurrency +public protocol AnyExtensionField: Sendable, CustomDebugStringConvertible { + func hash(into hasher: inout Hasher) + var protobufExtension: any AnyMessageExtension { get } + func isEqual(other: any AnyExtensionField) -> Bool + + /// Merging field decoding + mutating func decodeExtensionField(decoder: inout T) throws + + /// Fields know their own type, so can dispatch to a visitor + func traverse(visitor: inout V) throws + + /// Check if the field is initialized. + var isInitialized: Bool { get } } extension AnyExtensionField { - // Default implementation for extensions fields. The message types below provide - // custom versions. - public var isInitialized: Bool { return true } + // Default implementation for extensions fields. The message types below provide + // custom versions. + public var isInitialized: Bool { true } } /// /// The regular ExtensionField type exposes the value directly. /// +@preconcurrency public protocol ExtensionField: AnyExtensionField, Hashable { - associatedtype ValueType - var value: ValueType { get set } - init(protobufExtension: AnyMessageExtension, value: ValueType) - init?(protobufExtension: AnyMessageExtension, decoder: inout D) throws + associatedtype ValueType + var value: ValueType { get set } + init(protobufExtension: any AnyMessageExtension, value: ValueType) + init?(protobufExtension: any AnyMessageExtension, decoder: inout D) throws } /// /// Singular field /// public struct OptionalExtensionField: ExtensionField { - public typealias BaseType = T.BaseType - public typealias ValueType = BaseType - public var value: ValueType - public var protobufExtension: AnyMessageExtension - - public static func ==(lhs: OptionalExtensionField, - rhs: OptionalExtensionField) -> Bool { - return lhs.value == rhs.value - } - - public init(protobufExtension: AnyMessageExtension, value: ValueType) { - self.protobufExtension = protobufExtension - self.value = value - } - - public var debugDescription: String { - get { - return String(reflecting: value) - } - } - -#if swift(>=4.2) - public func hash(into hasher: inout Hasher) { - hasher.combine(value) - } -#else // swift(>=4.2) - public var hashValue: Int { - get { return value.hashValue } - } -#endif // swift(>=4.2) - - public func isEqual(other: AnyExtensionField) -> Bool { - let o = other as! OptionalExtensionField - return self == o - } - - public mutating func decodeExtensionField(decoder: inout D) throws { - var v: ValueType? - try T.decodeSingular(value: &v, from: &decoder) - if let v = v { - value = v - } - } - - public init?(protobufExtension: AnyMessageExtension, decoder: inout D) throws { - var v: ValueType? - try T.decodeSingular(value: &v, from: &decoder) - if let v = v { - self.init(protobufExtension: protobufExtension, value: v) - } else { - return nil - } - } - - public func traverse(visitor: inout V) throws { - try T.visitSingular(value: value, fieldNumber: protobufExtension.fieldNumber, with: &visitor) - } + public typealias BaseType = T.BaseType + public typealias ValueType = BaseType + public var value: ValueType + public var protobufExtension: any AnyMessageExtension + + public static func == ( + lhs: OptionalExtensionField, + rhs: OptionalExtensionField + ) -> Bool { + lhs.value == rhs.value + } + + public init(protobufExtension: any AnyMessageExtension, value: ValueType) { + self.protobufExtension = protobufExtension + self.value = value + } + + public var debugDescription: String { + #if DEBUG + return String(reflecting: value) + #else + return String(reflecting: type(of: self)) + #endif + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(value) + } + + public func isEqual(other: any AnyExtensionField) -> Bool { + let o = other as! OptionalExtensionField + return self == o + } + + public mutating func decodeExtensionField(decoder: inout D) throws { + var v: ValueType? + try T.decodeSingular(value: &v, from: &decoder) + if let v = v { + value = v + } + } + + public init?(protobufExtension: any AnyMessageExtension, decoder: inout D) throws { + var v: ValueType? + try T.decodeSingular(value: &v, from: &decoder) + if let v = v { + self.init(protobufExtension: protobufExtension, value: v) + } else { + return nil + } + } + + public func traverse(visitor: inout V) throws { + try T.visitSingular(value: value, fieldNumber: protobufExtension.fieldNumber, with: &visitor) + } } /// /// Repeated fields /// public struct RepeatedExtensionField: ExtensionField { - public typealias BaseType = T.BaseType - public typealias ValueType = [BaseType] - public var value: ValueType - public var protobufExtension: AnyMessageExtension - - public static func ==(lhs: RepeatedExtensionField, - rhs: RepeatedExtensionField) -> Bool { - return lhs.value == rhs.value - } - - public init(protobufExtension: AnyMessageExtension, value: ValueType) { - self.protobufExtension = protobufExtension - self.value = value - } - -#if swift(>=4.2) - public func hash(into hasher: inout Hasher) { - hasher.combine(value) - } -#else // swift(>=4.2) - public var hashValue: Int { - get { - var hash = i_2166136261 - for e in value { - hash = (hash &* i_16777619) ^ e.hashValue - } - return hash - } - } -#endif // swift(>=4.2) - - public func isEqual(other: AnyExtensionField) -> Bool { - let o = other as! RepeatedExtensionField - return self == o - } - - public var debugDescription: String { - return "[" + value.map{String(reflecting: $0)}.joined(separator: ",") + "]" - } - - public mutating func decodeExtensionField(decoder: inout D) throws { - try T.decodeRepeated(value: &value, from: &decoder) - } - - public init?(protobufExtension: AnyMessageExtension, decoder: inout D) throws { - var v: ValueType = [] - try T.decodeRepeated(value: &v, from: &decoder) - self.init(protobufExtension: protobufExtension, value: v) - } - - public func traverse(visitor: inout V) throws { - if value.count > 0 { - try T.visitRepeated(value: value, fieldNumber: protobufExtension.fieldNumber, with: &visitor) - } - } + public typealias BaseType = T.BaseType + public typealias ValueType = [BaseType] + public var value: ValueType + public var protobufExtension: any AnyMessageExtension + + public static func == ( + lhs: RepeatedExtensionField, + rhs: RepeatedExtensionField + ) -> Bool { + lhs.value == rhs.value + } + + public init(protobufExtension: any AnyMessageExtension, value: ValueType) { + self.protobufExtension = protobufExtension + self.value = value + } + + public var debugDescription: String { + #if DEBUG + return "[" + value.map { String(reflecting: $0) }.joined(separator: ",") + "]" + #else + return String(reflecting: type(of: self)) + #endif + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(value) + } + + public func isEqual(other: any AnyExtensionField) -> Bool { + let o = other as! RepeatedExtensionField + return self == o + } + + public mutating func decodeExtensionField(decoder: inout D) throws { + try T.decodeRepeated(value: &value, from: &decoder) + } + + public init?(protobufExtension: any AnyMessageExtension, decoder: inout D) throws { + var v: ValueType = [] + try T.decodeRepeated(value: &v, from: &decoder) + self.init(protobufExtension: protobufExtension, value: v) + } + + public func traverse(visitor: inout V) throws { + if value.count > 0 { + try T.visitRepeated(value: value, fieldNumber: protobufExtension.fieldNumber, with: &visitor) + } + } } /// @@ -195,189 +178,177 @@ public struct RepeatedExtensionField: ExtensionField { /// find a way to collapse the implementations. /// public struct PackedExtensionField: ExtensionField { - public typealias BaseType = T.BaseType - public typealias ValueType = [BaseType] - public var value: ValueType - public var protobufExtension: AnyMessageExtension - - public static func ==(lhs: PackedExtensionField, - rhs: PackedExtensionField) -> Bool { - return lhs.value == rhs.value - } - - public init(protobufExtension: AnyMessageExtension, value: ValueType) { - self.protobufExtension = protobufExtension - self.value = value - } - -#if swift(>=4.2) - public func hash(into hasher: inout Hasher) { - hasher.combine(value) - } -#else // swift(>=4.2) - public var hashValue: Int { - get { - var hash = i_2166136261 - for e in value { - hash = (hash &* i_16777619) ^ e.hashValue - } - return hash - } - } -#endif // swift(>=4.2) - - public func isEqual(other: AnyExtensionField) -> Bool { - let o = other as! PackedExtensionField - return self == o - } - - public var debugDescription: String { - return "[" + value.map{String(reflecting: $0)}.joined(separator: ",") + "]" - } - - public mutating func decodeExtensionField(decoder: inout D) throws { - try T.decodeRepeated(value: &value, from: &decoder) - } - - public init?(protobufExtension: AnyMessageExtension, decoder: inout D) throws { - var v: ValueType = [] - try T.decodeRepeated(value: &v, from: &decoder) - self.init(protobufExtension: protobufExtension, value: v) - } - - public func traverse(visitor: inout V) throws { - if value.count > 0 { - try T.visitPacked(value: value, fieldNumber: protobufExtension.fieldNumber, with: &visitor) - } - } + public typealias BaseType = T.BaseType + public typealias ValueType = [BaseType] + public var value: ValueType + public var protobufExtension: any AnyMessageExtension + + public static func == ( + lhs: PackedExtensionField, + rhs: PackedExtensionField + ) -> Bool { + lhs.value == rhs.value + } + + public init(protobufExtension: any AnyMessageExtension, value: ValueType) { + self.protobufExtension = protobufExtension + self.value = value + } + + public var debugDescription: String { + #if DEBUG + return "[" + value.map { String(reflecting: $0) }.joined(separator: ",") + "]" + #else + return String(reflecting: type(of: self)) + #endif + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(value) + } + + public func isEqual(other: any AnyExtensionField) -> Bool { + let o = other as! PackedExtensionField + return self == o + } + + public mutating func decodeExtensionField(decoder: inout D) throws { + try T.decodeRepeated(value: &value, from: &decoder) + } + + public init?(protobufExtension: any AnyMessageExtension, decoder: inout D) throws { + var v: ValueType = [] + try T.decodeRepeated(value: &v, from: &decoder) + self.init(protobufExtension: protobufExtension, value: v) + } + + public func traverse(visitor: inout V) throws { + if value.count > 0 { + try T.visitPacked(value: value, fieldNumber: protobufExtension.fieldNumber, with: &visitor) + } + } } /// /// Enum extensions /// public struct OptionalEnumExtensionField: ExtensionField where E.RawValue == Int { - public typealias BaseType = E - public typealias ValueType = E - public var value: ValueType - public var protobufExtension: AnyMessageExtension - - public static func ==(lhs: OptionalEnumExtensionField, - rhs: OptionalEnumExtensionField) -> Bool { - return lhs.value == rhs.value - } - - public init(protobufExtension: AnyMessageExtension, value: ValueType) { - self.protobufExtension = protobufExtension - self.value = value - } - - public var debugDescription: String { - get { - return String(reflecting: value) - } - } - -#if swift(>=4.2) - public func hash(into hasher: inout Hasher) { - hasher.combine(value) - } -#else // swift(>=4.2) - public var hashValue: Int { - get { return value.hashValue } - } -#endif // swift(>=4.2) - - public func isEqual(other: AnyExtensionField) -> Bool { - let o = other as! OptionalEnumExtensionField - return self == o - } - - public mutating func decodeExtensionField(decoder: inout D) throws { - var v: ValueType? - try decoder.decodeSingularEnumField(value: &v) - if let v = v { - value = v - } - } - - public init?(protobufExtension: AnyMessageExtension, decoder: inout D) throws { - var v: ValueType? - try decoder.decodeSingularEnumField(value: &v) - if let v = v { - self.init(protobufExtension: protobufExtension, value: v) - } else { - return nil - } - } - - public func traverse(visitor: inout V) throws { - try visitor.visitSingularEnumField( - value: value, - fieldNumber: protobufExtension.fieldNumber) - } + public typealias BaseType = E + public typealias ValueType = E + public var value: ValueType + public var protobufExtension: any AnyMessageExtension + + public static func == ( + lhs: OptionalEnumExtensionField, + rhs: OptionalEnumExtensionField + ) -> Bool { + lhs.value == rhs.value + } + + public init(protobufExtension: any AnyMessageExtension, value: ValueType) { + self.protobufExtension = protobufExtension + self.value = value + } + + public var debugDescription: String { + #if DEBUG + return String(reflecting: value) + #else + return String(reflecting: type(of: self)) + #endif + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(value) + } + + public func isEqual(other: any AnyExtensionField) -> Bool { + let o = other as! OptionalEnumExtensionField + return self == o + } + + public mutating func decodeExtensionField(decoder: inout D) throws { + var v: ValueType? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + value = v + } + } + + public init?(protobufExtension: any AnyMessageExtension, decoder: inout D) throws { + var v: ValueType? + try decoder.decodeSingularEnumField(value: &v) + if let v = v { + self.init(protobufExtension: protobufExtension, value: v) + } else { + return nil + } + } + + public func traverse(visitor: inout V) throws { + try visitor.visitSingularEnumField( + value: value, + fieldNumber: protobufExtension.fieldNumber + ) + } } /// /// Repeated Enum fields /// public struct RepeatedEnumExtensionField: ExtensionField where E.RawValue == Int { - public typealias BaseType = E - public typealias ValueType = [E] - public var value: ValueType - public var protobufExtension: AnyMessageExtension - - public static func ==(lhs: RepeatedEnumExtensionField, - rhs: RepeatedEnumExtensionField) -> Bool { - return lhs.value == rhs.value - } - - public init(protobufExtension: AnyMessageExtension, value: ValueType) { - self.protobufExtension = protobufExtension - self.value = value - } - -#if swift(>=4.2) - public func hash(into hasher: inout Hasher) { - hasher.combine(value) - } -#else // swift(>=4.2) - public var hashValue: Int { - get { - var hash = i_2166136261 - for e in value { - hash = (hash &* i_16777619) ^ e.hashValue - } - return hash - } - } -#endif // swift(>=4.2) - - public func isEqual(other: AnyExtensionField) -> Bool { - let o = other as! RepeatedEnumExtensionField - return self == o - } - - public var debugDescription: String { - return "[" + value.map{String(reflecting: $0)}.joined(separator: ",") + "]" - } - - public mutating func decodeExtensionField(decoder: inout D) throws { - try decoder.decodeRepeatedEnumField(value: &value) - } - - public init?(protobufExtension: AnyMessageExtension, decoder: inout D) throws { - var v: ValueType = [] - try decoder.decodeRepeatedEnumField(value: &v) - self.init(protobufExtension: protobufExtension, value: v) - } - - public func traverse(visitor: inout V) throws { - if value.count > 0 { - try visitor.visitRepeatedEnumField( - value: value, - fieldNumber: protobufExtension.fieldNumber) - } - } + public typealias BaseType = E + public typealias ValueType = [E] + public var value: ValueType + public var protobufExtension: any AnyMessageExtension + + public static func == ( + lhs: RepeatedEnumExtensionField, + rhs: RepeatedEnumExtensionField + ) -> Bool { + lhs.value == rhs.value + } + + public init(protobufExtension: any AnyMessageExtension, value: ValueType) { + self.protobufExtension = protobufExtension + self.value = value + } + + public var debugDescription: String { + #if DEBUG + return "[" + value.map { String(reflecting: $0) }.joined(separator: ",") + "]" + #else + return String(reflecting: type(of: self)) + #endif + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(value) + } + + public func isEqual(other: any AnyExtensionField) -> Bool { + let o = other as! RepeatedEnumExtensionField + return self == o + } + + public mutating func decodeExtensionField(decoder: inout D) throws { + try decoder.decodeRepeatedEnumField(value: &value) + } + + public init?(protobufExtension: any AnyMessageExtension, decoder: inout D) throws { + var v: ValueType = [] + try decoder.decodeRepeatedEnumField(value: &v) + self.init(protobufExtension: protobufExtension, value: v) + } + + public func traverse(visitor: inout V) throws { + if value.count > 0 { + try visitor.visitRepeatedEnumField( + value: value, + fieldNumber: protobufExtension.fieldNumber + ) + } + } } /// @@ -387,196 +358,191 @@ public struct RepeatedEnumExtensionField: ExtensionField where E.RawVal /// find a way to collapse the implementations. /// public struct PackedEnumExtensionField: ExtensionField where E.RawValue == Int { - public typealias BaseType = E - public typealias ValueType = [E] - public var value: ValueType - public var protobufExtension: AnyMessageExtension - - public static func ==(lhs: PackedEnumExtensionField, - rhs: PackedEnumExtensionField) -> Bool { - return lhs.value == rhs.value - } - - public init(protobufExtension: AnyMessageExtension, value: ValueType) { - self.protobufExtension = protobufExtension - self.value = value - } - -#if swift(>=4.2) - public func hash(into hasher: inout Hasher) { - hasher.combine(value) - } -#else // swift(>=4.2) - public var hashValue: Int { - get { - var hash = i_2166136261 - for e in value { - hash = (hash &* i_16777619) ^ e.hashValue - } - return hash - } - } -#endif // swift(>=4.2) - - public func isEqual(other: AnyExtensionField) -> Bool { - let o = other as! PackedEnumExtensionField - return self == o - } - - public var debugDescription: String { - return "[" + value.map{String(reflecting: $0)}.joined(separator: ",") + "]" - } - - public mutating func decodeExtensionField(decoder: inout D) throws { - try decoder.decodeRepeatedEnumField(value: &value) - } - - public init?(protobufExtension: AnyMessageExtension, decoder: inout D) throws { - var v: ValueType = [] - try decoder.decodeRepeatedEnumField(value: &v) - self.init(protobufExtension: protobufExtension, value: v) - } - - public func traverse(visitor: inout V) throws { - if value.count > 0 { - try visitor.visitPackedEnumField( - value: value, - fieldNumber: protobufExtension.fieldNumber) - } - } + public typealias BaseType = E + public typealias ValueType = [E] + public var value: ValueType + public var protobufExtension: any AnyMessageExtension + + public static func == ( + lhs: PackedEnumExtensionField, + rhs: PackedEnumExtensionField + ) -> Bool { + lhs.value == rhs.value + } + + public init(protobufExtension: any AnyMessageExtension, value: ValueType) { + self.protobufExtension = protobufExtension + self.value = value + } + + public var debugDescription: String { + #if DEBUG + return "[" + value.map { String(reflecting: $0) }.joined(separator: ",") + "]" + #else + return String(reflecting: type(of: self)) + #endif + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(value) + } + + public func isEqual(other: any AnyExtensionField) -> Bool { + let o = other as! PackedEnumExtensionField + return self == o + } + + public mutating func decodeExtensionField(decoder: inout D) throws { + try decoder.decodeRepeatedEnumField(value: &value) + } + + public init?(protobufExtension: any AnyMessageExtension, decoder: inout D) throws { + var v: ValueType = [] + try decoder.decodeRepeatedEnumField(value: &v) + self.init(protobufExtension: protobufExtension, value: v) + } + + public func traverse(visitor: inout V) throws { + if value.count > 0 { + try visitor.visitPackedEnumField( + value: value, + fieldNumber: protobufExtension.fieldNumber + ) + } + } } // // ========== Message ========== // public struct OptionalMessageExtensionField: - ExtensionField { - public typealias BaseType = M - public typealias ValueType = BaseType - public var value: ValueType - public var protobufExtension: AnyMessageExtension - - public static func ==(lhs: OptionalMessageExtensionField, - rhs: OptionalMessageExtensionField) -> Bool { - return lhs.value == rhs.value - } - - public init(protobufExtension: AnyMessageExtension, value: ValueType) { - self.protobufExtension = protobufExtension - self.value = value - } - - public var debugDescription: String { - get { - return String(reflecting: value) - } - } - -#if swift(>=4.2) - public func hash(into hasher: inout Hasher) { - value.hash(into: &hasher) - } -#else // swift(>=4.2) - public var hashValue: Int {return value.hashValue} -#endif // swift(>=4.2) - - public func isEqual(other: AnyExtensionField) -> Bool { - let o = other as! OptionalMessageExtensionField - return self == o - } - - public mutating func decodeExtensionField(decoder: inout D) throws { - var v: ValueType? = value - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - self.value = v - } - } - - public init?(protobufExtension: AnyMessageExtension, decoder: inout D) throws { - var v: ValueType? - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - self.init(protobufExtension: protobufExtension, value: v) - } else { - return nil - } - } - - public func traverse(visitor: inout V) throws { - try visitor.visitSingularMessageField( - value: value, fieldNumber: protobufExtension.fieldNumber) - } - - public var isInitialized: Bool { - return value.isInitialized - } + ExtensionField +{ + public typealias BaseType = M + public typealias ValueType = BaseType + public var value: ValueType + public var protobufExtension: any AnyMessageExtension + + public static func == ( + lhs: OptionalMessageExtensionField, + rhs: OptionalMessageExtensionField + ) -> Bool { + lhs.value == rhs.value + } + + public init(protobufExtension: any AnyMessageExtension, value: ValueType) { + self.protobufExtension = protobufExtension + self.value = value + } + + public var debugDescription: String { + #if DEBUG + return String(reflecting: value) + #else + return String(reflecting: type(of: self)) + #endif + } + + public func hash(into hasher: inout Hasher) { + value.hash(into: &hasher) + } + + public func isEqual(other: any AnyExtensionField) -> Bool { + let o = other as! OptionalMessageExtensionField + return self == o + } + + public mutating func decodeExtensionField(decoder: inout D) throws { + var v: ValueType? = value + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + self.value = v + } + } + + public init?(protobufExtension: any AnyMessageExtension, decoder: inout D) throws { + var v: ValueType? + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + self.init(protobufExtension: protobufExtension, value: v) + } else { + return nil + } + } + + public func traverse(visitor: inout V) throws { + try visitor.visitSingularMessageField( + value: value, + fieldNumber: protobufExtension.fieldNumber + ) + } + + public var isInitialized: Bool { + value.isInitialized + } } public struct RepeatedMessageExtensionField: - ExtensionField { - public typealias BaseType = M - public typealias ValueType = [BaseType] - public var value: ValueType - public var protobufExtension: AnyMessageExtension - - public static func ==(lhs: RepeatedMessageExtensionField, - rhs: RepeatedMessageExtensionField) -> Bool { - return lhs.value == rhs.value - } - - public init(protobufExtension: AnyMessageExtension, value: ValueType) { - self.protobufExtension = protobufExtension - self.value = value - } - -#if swift(>=4.2) - public func hash(into hasher: inout Hasher) { - for e in value { - e.hash(into: &hasher) - } - } -#else // swift(>=4.2) - public var hashValue: Int { - get { - var hash = i_2166136261 - for e in value { - hash = (hash &* i_16777619) ^ e.hashValue - } - return hash - } - } -#endif // swift(>=4.2) - - public func isEqual(other: AnyExtensionField) -> Bool { - let o = other as! RepeatedMessageExtensionField - return self == o - } - - public var debugDescription: String { - return "[" + value.map{String(reflecting: $0)}.joined(separator: ",") + "]" - } - - public mutating func decodeExtensionField(decoder: inout D) throws { - try decoder.decodeRepeatedMessageField(value: &value) - } - - public init?(protobufExtension: AnyMessageExtension, decoder: inout D) throws { - var v: ValueType = [] - try decoder.decodeRepeatedMessageField(value: &v) - self.init(protobufExtension: protobufExtension, value: v) - } - - public func traverse(visitor: inout V) throws { - if value.count > 0 { - try visitor.visitRepeatedMessageField( - value: value, fieldNumber: protobufExtension.fieldNumber) - } - } - - public var isInitialized: Bool { - return Internal.areAllInitialized(value) - } + ExtensionField +{ + public typealias BaseType = M + public typealias ValueType = [BaseType] + public var value: ValueType + public var protobufExtension: any AnyMessageExtension + + public static func == ( + lhs: RepeatedMessageExtensionField, + rhs: RepeatedMessageExtensionField + ) -> Bool { + lhs.value == rhs.value + } + + public init(protobufExtension: any AnyMessageExtension, value: ValueType) { + self.protobufExtension = protobufExtension + self.value = value + } + + public var debugDescription: String { + #if DEBUG + return "[" + value.map { String(reflecting: $0) }.joined(separator: ",") + "]" + #else + return String(reflecting: type(of: self)) + #endif + } + + public func hash(into hasher: inout Hasher) { + for e in value { + e.hash(into: &hasher) + } + } + + public func isEqual(other: any AnyExtensionField) -> Bool { + let o = other as! RepeatedMessageExtensionField + return self == o + } + + public mutating func decodeExtensionField(decoder: inout D) throws { + try decoder.decodeRepeatedMessageField(value: &value) + } + + public init?(protobufExtension: any AnyMessageExtension, decoder: inout D) throws { + var v: ValueType = [] + try decoder.decodeRepeatedMessageField(value: &v) + self.init(protobufExtension: protobufExtension, value: v) + } + + public func traverse(visitor: inout V) throws { + if value.count > 0 { + try visitor.visitRepeatedMessageField( + value: value, + fieldNumber: protobufExtension.fieldNumber + ) + } + } + + public var isInitialized: Bool { + Internal.areAllInitialized(value) + } } // @@ -586,125 +552,129 @@ public struct RepeatedMessageExtensionField: // they serialize very differently, so we have separate serialization // handling here... public struct OptionalGroupExtensionField: - ExtensionField { - public typealias BaseType = G - public typealias ValueType = BaseType - public var value: G - public var protobufExtension: AnyMessageExtension - - public static func ==(lhs: OptionalGroupExtensionField, - rhs: OptionalGroupExtensionField) -> Bool { - return lhs.value == rhs.value - } - - public init(protobufExtension: AnyMessageExtension, value: ValueType) { - self.protobufExtension = protobufExtension - self.value = value - } - -#if swift(>=4.2) - public func hash(into hasher: inout Hasher) { - hasher.combine(value) - } -#else // swift(>=4.2) - public var hashValue: Int {return value.hashValue} -#endif // swift(>=4.2) - - public var debugDescription: String { get {return value.debugDescription} } - - public func isEqual(other: AnyExtensionField) -> Bool { - let o = other as! OptionalGroupExtensionField - return self == o - } - - public mutating func decodeExtensionField(decoder: inout D) throws { - var v: ValueType? = value - try decoder.decodeSingularGroupField(value: &v) - if let v = v { - value = v - } - } - - public init?(protobufExtension: AnyMessageExtension, decoder: inout D) throws { - var v: ValueType? - try decoder.decodeSingularGroupField(value: &v) - if let v = v { - self.init(protobufExtension: protobufExtension, value: v) - } else { - return nil - } - } - - public func traverse(visitor: inout V) throws { - try visitor.visitSingularGroupField( - value: value, fieldNumber: protobufExtension.fieldNumber) - } - - public var isInitialized: Bool { - return value.isInitialized - } + ExtensionField +{ + public typealias BaseType = G + public typealias ValueType = BaseType + public var value: G + public var protobufExtension: any AnyMessageExtension + + public static func == ( + lhs: OptionalGroupExtensionField, + rhs: OptionalGroupExtensionField + ) -> Bool { + lhs.value == rhs.value + } + + public init(protobufExtension: any AnyMessageExtension, value: ValueType) { + self.protobufExtension = protobufExtension + self.value = value + } + + public var debugDescription: String { + #if DEBUG + return value.debugDescription + #else + return String(reflecting: type(of: self)) + #endif + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(value) + } + + public func isEqual(other: any AnyExtensionField) -> Bool { + let o = other as! OptionalGroupExtensionField + return self == o + } + + public mutating func decodeExtensionField(decoder: inout D) throws { + var v: ValueType? = value + try decoder.decodeSingularGroupField(value: &v) + if let v = v { + value = v + } + } + + public init?(protobufExtension: any AnyMessageExtension, decoder: inout D) throws { + var v: ValueType? + try decoder.decodeSingularGroupField(value: &v) + if let v = v { + self.init(protobufExtension: protobufExtension, value: v) + } else { + return nil + } + } + + public func traverse(visitor: inout V) throws { + try visitor.visitSingularGroupField( + value: value, + fieldNumber: protobufExtension.fieldNumber + ) + } + + public var isInitialized: Bool { + value.isInitialized + } } public struct RepeatedGroupExtensionField: - ExtensionField { - public typealias BaseType = G - public typealias ValueType = [BaseType] - public var value: ValueType - public var protobufExtension: AnyMessageExtension - - public static func ==(lhs: RepeatedGroupExtensionField, - rhs: RepeatedGroupExtensionField) -> Bool { - return lhs.value == rhs.value - } - - public init(protobufExtension: AnyMessageExtension, value: ValueType) { - self.protobufExtension = protobufExtension - self.value = value - } - -#if swift(>=4.2) - public func hash(into hasher: inout Hasher) { - hasher.combine(value) - } -#else // swift(>=4.2) - public var hashValue: Int { - get { - var hash = i_2166136261 - for e in value { - hash = (hash &* i_16777619) ^ e.hashValue - } - return hash - } - } -#endif // swift(>=4.2) - - public var debugDescription: String { - return "[" + value.map{$0.debugDescription}.joined(separator: ",") + "]" - } - - public func isEqual(other: AnyExtensionField) -> Bool { - let o = other as! RepeatedGroupExtensionField - return self == o - } - - public mutating func decodeExtensionField(decoder: inout D) throws { - try decoder.decodeRepeatedGroupField(value: &value) - } - - public init?(protobufExtension: AnyMessageExtension, decoder: inout D) throws { - var v: ValueType = [] - try decoder.decodeRepeatedGroupField(value: &v) - self.init(protobufExtension: protobufExtension, value: v) - } - - public func traverse(visitor: inout V) throws { - if value.count > 0 { - try visitor.visitRepeatedGroupField( - value: value, fieldNumber: protobufExtension.fieldNumber) - } - } - - public var isInitialized: Bool { - return Internal.areAllInitialized(value) - } + ExtensionField +{ + public typealias BaseType = G + public typealias ValueType = [BaseType] + public var value: ValueType + public var protobufExtension: any AnyMessageExtension + + public static func == ( + lhs: RepeatedGroupExtensionField, + rhs: RepeatedGroupExtensionField + ) -> Bool { + lhs.value == rhs.value + } + + public init(protobufExtension: any AnyMessageExtension, value: ValueType) { + self.protobufExtension = protobufExtension + self.value = value + } + + public var debugDescription: String { + #if DEBUG + return "[" + value.map { $0.debugDescription }.joined(separator: ",") + "]" + #else + return String(reflecting: type(of: self)) + #endif + } + + public func hash(into hasher: inout Hasher) { + hasher.combine(value) + } + + public func isEqual(other: any AnyExtensionField) -> Bool { + let o = other as! RepeatedGroupExtensionField + return self == o + } + + public mutating func decodeExtensionField(decoder: inout D) throws { + try decoder.decodeRepeatedGroupField(value: &value) + } + + public init?(protobufExtension: any AnyMessageExtension, decoder: inout D) throws { + var v: ValueType = [] + try decoder.decodeRepeatedGroupField(value: &v) + self.init(protobufExtension: protobufExtension, value: v) + } + + public func traverse(visitor: inout V) throws { + if value.count > 0 { + try visitor.visitRepeatedGroupField( + value: value, + fieldNumber: protobufExtension.fieldNumber + ) + } + } + + public var isInitialized: Bool { + Internal.areAllInitialized(value) + } } diff --git a/Sources/SwiftProtobuf/ExtensionMap.swift b/Sources/SwiftProtobuf/ExtensionMap.swift index e83b1c91d..12a810b6b 100644 --- a/Sources/SwiftProtobuf/ExtensionMap.swift +++ b/Sources/SwiftProtobuf/ExtensionMap.swift @@ -22,9 +22,10 @@ /// This is a protocol so that developers can build their own /// extension handling if they need something more complex than the /// standard `SimpleExtensionMap` implementation. -public protocol ExtensionMap { +@preconcurrency +public protocol ExtensionMap: Sendable { /// Returns the extension object describing an extension or nil - subscript(messageType: Message.Type, fieldNumber: Int) -> AnyMessageExtension? { get } + subscript(messageType: any Message.Type, fieldNumber: Int) -> (any AnyMessageExtension)? { get } /// Returns the field number for a message with a specific field name /// @@ -34,5 +35,5 @@ public protocol ExtensionMap { /// for the proto file and `message` is the name of the message in /// which the extension was defined. (This is different from the /// message that is being extended!) - func fieldNumberForProto(messageType: Message.Type, protoFieldName: String) -> Int? + func fieldNumberForProto(messageType: any Message.Type, protoFieldName: String) -> Int? } diff --git a/Sources/SwiftProtobuf/FieldTag.swift b/Sources/SwiftProtobuf/FieldTag.swift index 0a92cbb8e..e4a6c06e5 100644 --- a/Sources/SwiftProtobuf/FieldTag.swift +++ b/Sources/SwiftProtobuf/FieldTag.swift @@ -19,51 +19,51 @@ /// improper field number (such as zero) or wire format (such as 6 or 7) to /// exist. In other words, a `FieldTag`'s properties never need to be tested /// for validity because they are guaranteed correct at initialization time. -internal struct FieldTag: RawRepresentable { +package struct FieldTag: RawRepresentable { - typealias RawValue = UInt32 + package typealias RawValue = UInt32 - /// The raw numeric value of the tag, which contains both the field number and - /// wire format. - let rawValue: UInt32 + /// The raw numeric value of the tag, which contains both the field number and + /// wire format. + package let rawValue: UInt32 - /// The field number component of the tag. - var fieldNumber: Int { - return Int(rawValue >> 3) - } + /// The field number component of the tag. + package var fieldNumber: Int { + Int(rawValue >> 3) + } - /// The wire format component of the tag. - var wireFormat: WireFormat { - // This force-unwrap is safe because there are only two initialization - // paths: one that takes a WireFormat directly (and is guaranteed valid at - // compile-time), or one that takes a raw value but which only lets valid - // wire formats through. - return WireFormat(rawValue: UInt8(rawValue & 7))! - } + /// The wire format component of the tag. + package var wireFormat: WireFormat { + // This force-unwrap is safe because there are only two initialization + // paths: one that takes a WireFormat directly (and is guaranteed valid at + // compile-time), or one that takes a raw value but which only lets valid + // wire formats through. + WireFormat(rawValue: UInt8(rawValue & 7))! + } - /// A helper property that returns the number of bytes required to - /// varint-encode this tag. - var encodedSize: Int { - return Varint.encodedSize(of: rawValue) - } + /// A helper property that returns the number of bytes required to + /// varint-encode this tag. + package var encodedSize: Int { + Varint.encodedSize(of: rawValue) + } - /// Creates a new tag from its raw numeric representation. - /// - /// Note that if the raw value given here is not a valid tag (for example, it - /// has an invalid wire format), this initializer will fail. - init?(rawValue: UInt32) { - // Verify that the field number and wire format are valid and fail if they - // are not. - guard rawValue & ~0x07 != 0, - let _ = WireFormat(rawValue: UInt8(rawValue % 8)) else { - return nil + /// Creates a new tag from its raw numeric representation. + /// + /// Note that if the raw value given here is not a valid tag (for example, it + /// has an invalid wire format), this initializer will fail. + package init?(rawValue: UInt32) { + // Verify that the field number and wire format are valid and fail if they + // are not. + guard rawValue & ~0x07 != 0, + let _ = WireFormat(rawValue: UInt8(rawValue % 8)) + else { + return nil + } + self.rawValue = rawValue } - self.rawValue = rawValue - } - /// Creates a new tag by composing the given field number and wire format. - init(fieldNumber: Int, wireFormat: WireFormat) { - self.rawValue = UInt32(truncatingIfNeeded: fieldNumber) << 3 | - UInt32(wireFormat.rawValue) - } + /// Creates a new tag by composing the given field number and wire format. + package init(fieldNumber: Int, wireFormat: WireFormat) { + self.rawValue = UInt32(truncatingIfNeeded: fieldNumber) << 3 | UInt32(wireFormat.rawValue) + } } diff --git a/Sources/SwiftProtobuf/FieldTypes.swift b/Sources/SwiftProtobuf/FieldTypes.swift index 7fedcff83..a9bbe3cc1 100644 --- a/Sources/SwiftProtobuf/FieldTypes.swift +++ b/Sources/SwiftProtobuf/FieldTypes.swift @@ -24,14 +24,13 @@ import Foundation -// TODO: `FieldType` and `FieldType.BaseType` should require `Sendable` but we cannot do so yet without possibly breaking compatibility. - // Note: The protobuf- and JSON-specific methods here are defined // in ProtobufTypeAdditions.swift and JSONTypeAdditions.swift -public protocol FieldType { +@preconcurrency +public protocol FieldType: Sendable { // The Swift type used to store data for this field. For example, // proto "sint32" fields use Swift "Int32" type. - associatedtype BaseType: Hashable + associatedtype BaseType: Hashable, Sendable // The default value for this field type before it has been set. // This is also used, for example, when JSON decodes a "null" @@ -51,8 +50,9 @@ public protocol FieldType { /// /// Marker protocol for types that can be used as map keys /// +@preconcurrency public protocol MapKeyType: FieldType { - /// A comparision function for where order is needed. Can't use `Comparable` + /// A comparison function for where order is needed. Can't use `Comparable` /// because `Bool` doesn't conform, and since it is `public` there is no way /// to add a conformance internal to SwiftProtobuf. static func _lessThan(lhs: BaseType, rhs: BaseType) -> Bool @@ -61,13 +61,14 @@ public protocol MapKeyType: FieldType { // Default impl for anything `Comparable` extension MapKeyType where BaseType: Comparable { public static func _lessThan(lhs: BaseType, rhs: BaseType) -> Bool { - return lhs < rhs + lhs < rhs } } /// /// Marker Protocol for types that can be used as map values. /// +@preconcurrency public protocol MapValueType: FieldType { } @@ -81,7 +82,7 @@ public protocol MapValueType: FieldType { /// public struct ProtobufFloat: FieldType, MapValueType { public typealias BaseType = Float - public static var proto3DefaultValue: Float {return 0.0} + public static var proto3DefaultValue: Float { 0.0 } public static func decodeSingular(value: inout BaseType?, from decoder: inout D) throws { try decoder.decodeSingularFloatField(value: &value) } @@ -104,7 +105,7 @@ public struct ProtobufFloat: FieldType, MapValueType { /// public struct ProtobufDouble: FieldType, MapValueType { public typealias BaseType = Double - public static var proto3DefaultValue: Double {return 0.0} + public static var proto3DefaultValue: Double { 0.0 } public static func decodeSingular(value: inout BaseType?, from decoder: inout D) throws { try decoder.decodeSingularDoubleField(value: &value) } @@ -127,7 +128,7 @@ public struct ProtobufDouble: FieldType, MapValueType { /// public struct ProtobufInt32: FieldType, MapKeyType, MapValueType { public typealias BaseType = Int32 - public static var proto3DefaultValue: Int32 {return 0} + public static var proto3DefaultValue: Int32 { 0 } public static func decodeSingular(value: inout BaseType?, from decoder: inout D) throws { try decoder.decodeSingularInt32Field(value: &value) } @@ -151,7 +152,7 @@ public struct ProtobufInt32: FieldType, MapKeyType, MapValueType { public struct ProtobufInt64: FieldType, MapKeyType, MapValueType { public typealias BaseType = Int64 - public static var proto3DefaultValue: Int64 {return 0} + public static var proto3DefaultValue: Int64 { 0 } public static func decodeSingular(value: inout BaseType?, from decoder: inout D) throws { try decoder.decodeSingularInt64Field(value: &value) } @@ -174,7 +175,7 @@ public struct ProtobufInt64: FieldType, MapKeyType, MapValueType { /// public struct ProtobufUInt32: FieldType, MapKeyType, MapValueType { public typealias BaseType = UInt32 - public static var proto3DefaultValue: UInt32 {return 0} + public static var proto3DefaultValue: UInt32 { 0 } public static func decodeSingular(value: inout BaseType?, from decoder: inout D) throws { try decoder.decodeSingularUInt32Field(value: &value) } @@ -198,7 +199,7 @@ public struct ProtobufUInt32: FieldType, MapKeyType, MapValueType { public struct ProtobufUInt64: FieldType, MapKeyType, MapValueType { public typealias BaseType = UInt64 - public static var proto3DefaultValue: UInt64 {return 0} + public static var proto3DefaultValue: UInt64 { 0 } public static func decodeSingular(value: inout BaseType?, from decoder: inout D) throws { try decoder.decodeSingularUInt64Field(value: &value) } @@ -221,7 +222,7 @@ public struct ProtobufUInt64: FieldType, MapKeyType, MapValueType { /// public struct ProtobufSInt32: FieldType, MapKeyType, MapValueType { public typealias BaseType = Int32 - public static var proto3DefaultValue: Int32 {return 0} + public static var proto3DefaultValue: Int32 { 0 } public static func decodeSingular(value: inout BaseType?, from decoder: inout D) throws { try decoder.decodeSingularSInt32Field(value: &value) } @@ -245,7 +246,7 @@ public struct ProtobufSInt32: FieldType, MapKeyType, MapValueType { public struct ProtobufSInt64: FieldType, MapKeyType, MapValueType { public typealias BaseType = Int64 - public static var proto3DefaultValue: Int64 {return 0} + public static var proto3DefaultValue: Int64 { 0 } public static func decodeSingular(value: inout BaseType?, from decoder: inout D) throws { try decoder.decodeSingularSInt64Field(value: &value) } @@ -268,7 +269,7 @@ public struct ProtobufSInt64: FieldType, MapKeyType, MapValueType { /// public struct ProtobufFixed32: FieldType, MapKeyType, MapValueType { public typealias BaseType = UInt32 - public static var proto3DefaultValue: UInt32 {return 0} + public static var proto3DefaultValue: UInt32 { 0 } public static func decodeSingular(value: inout BaseType?, from decoder: inout D) throws { try decoder.decodeSingularFixed32Field(value: &value) } @@ -291,7 +292,7 @@ public struct ProtobufFixed32: FieldType, MapKeyType, MapValueType { /// public struct ProtobufFixed64: FieldType, MapKeyType, MapValueType { public typealias BaseType = UInt64 - public static var proto3DefaultValue: UInt64 {return 0} + public static var proto3DefaultValue: UInt64 { 0 } public static func decodeSingular(value: inout BaseType?, from decoder: inout D) throws { try decoder.decodeSingularFixed64Field(value: &value) } @@ -314,7 +315,7 @@ public struct ProtobufFixed64: FieldType, MapKeyType, MapValueType { /// public struct ProtobufSFixed32: FieldType, MapKeyType, MapValueType { public typealias BaseType = Int32 - public static var proto3DefaultValue: Int32 {return 0} + public static var proto3DefaultValue: Int32 { 0 } public static func decodeSingular(value: inout BaseType?, from decoder: inout D) throws { try decoder.decodeSingularSFixed32Field(value: &value) } @@ -337,7 +338,7 @@ public struct ProtobufSFixed32: FieldType, MapKeyType, MapValueType { /// public struct ProtobufSFixed64: FieldType, MapKeyType, MapValueType { public typealias BaseType = Int64 - public static var proto3DefaultValue: Int64 {return 0} + public static var proto3DefaultValue: Int64 { 0 } public static func decodeSingular(value: inout BaseType?, from decoder: inout D) throws { try decoder.decodeSingularSFixed64Field(value: &value) } @@ -360,7 +361,7 @@ public struct ProtobufSFixed64: FieldType, MapKeyType, MapValueType { /// public struct ProtobufBool: FieldType, MapKeyType, MapValueType { public typealias BaseType = Bool - public static var proto3DefaultValue: Bool {return false} + public static var proto3DefaultValue: Bool { false } public static func decodeSingular(value: inout BaseType?, from decoder: inout D) throws { try decoder.decodeSingularBoolField(value: &value) } @@ -391,7 +392,7 @@ public struct ProtobufBool: FieldType, MapKeyType, MapValueType { /// public struct ProtobufString: FieldType, MapKeyType, MapValueType { public typealias BaseType = String - public static var proto3DefaultValue: String {return String()} + public static var proto3DefaultValue: String { String() } public static func decodeSingular(value: inout BaseType?, from decoder: inout D) throws { try decoder.decodeSingularStringField(value: &value) } @@ -414,7 +415,7 @@ public struct ProtobufString: FieldType, MapKeyType, MapValueType { /// public struct ProtobufBytes: FieldType, MapValueType { public typealias BaseType = Data - public static var proto3DefaultValue: Data {return Data()} + public static var proto3DefaultValue: Data { Data() } public static func decodeSingular(value: inout BaseType?, from decoder: inout D) throws { try decoder.decodeSingularBytesField(value: &value) } diff --git a/Sources/SwiftProtobuf/Google_Protobuf_Any+Extensions.swift b/Sources/SwiftProtobuf/Google_Protobuf_Any+Extensions.swift index b680088c7..6ece63b67 100644 --- a/Sources/SwiftProtobuf/Google_Protobuf_Any+Extensions.swift +++ b/Sources/SwiftProtobuf/Google_Protobuf_Any+Extensions.swift @@ -19,156 +19,153 @@ import Foundation public let defaultAnyTypeURLPrefix: String = "type.googleapis.com" extension Google_Protobuf_Any { - /// Initialize an Any object from the provided message. - /// - /// This corresponds to the `pack` operation in the C++ API. - /// - /// Unlike the C++ implementation, the message is not immediately - /// serialized; it is merely stored until the Any object itself - /// needs to be serialized. This design avoids unnecessary - /// decoding/recoding when writing JSON format. - /// - /// - Parameters: - /// - partial: If `false` (the default), this method will check - /// `Message.isInitialized` before encoding to verify that all required - /// fields are present. If any are missing, this method throws - /// `BinaryEncodingError.missingRequiredFields`. - /// - typePrefix: The prefix to be used when building the `type_url`. - /// Defaults to "type.googleapis.com". - /// - Throws: `BinaryEncodingError.missingRequiredFields` if `partial` is - /// false and `message` wasn't fully initialized. - public init( - message: Message, - partial: Bool = false, - typePrefix: String = defaultAnyTypeURLPrefix - ) throws { - if !partial && !message.isInitialized { - throw BinaryEncodingError.missingRequiredFields + /// Initialize an Any object from the provided message. + /// + /// This corresponds to the `pack` operation in the C++ API. + /// + /// Unlike the C++ implementation, the message is not immediately + /// serialized; it is merely stored until the Any object itself + /// needs to be serialized. This design avoids unnecessary + /// decoding/recoding when writing JSON format. + /// + /// - Parameters: + /// - partial: If `false` (the default), this method will check + /// ``Message/isInitialized-6abgi`` before encoding to verify that all required + /// fields are present. If any are missing, this method throws + /// ``BinaryEncodingError/missingRequiredFields``. + /// - typePrefix: The prefix to be used when building the `type_url`. + /// Defaults to "type.googleapis.com". + /// - Throws: ``BinaryEncodingError/missingRequiredFields`` if + /// `partial` is false and `message` wasn't fully initialized. + public init( + message: any Message, + partial: Bool = false, + typePrefix: String = defaultAnyTypeURLPrefix + ) throws { + if !partial && !message.isInitialized { + throw BinaryEncodingError.missingRequiredFields + } + self.init() + typeURL = buildTypeURL(forMessage: message, typePrefix: typePrefix) + _storage.state = .message(message) } - self.init() - typeURL = buildTypeURL(forMessage:message, typePrefix: typePrefix) - _storage.state = .message(message) - } - /// Creates a new `Google_Protobuf_Any` by decoding the given string - /// containing a serialized message in Protocol Buffer text format. - /// - /// - Parameters: - /// - textFormatString: The text format string to decode. - /// - extensions: An `ExtensionMap` used to look up and decode any - /// extensions in this message or messages nested within this message's - /// fields. - /// - Throws: an instance of `TextFormatDecodingError` on failure. - public init( - textFormatString: String, - extensions: ExtensionMap? = nil - ) throws { - // TODO: Remove this api and default the options instead. This api has to - // exist for anything compiled against an older version of the library. - try self.init(textFormatString: textFormatString, - options: TextFormatDecodingOptions(), - extensions: extensions) - } + /// Creates a new `Google_Protobuf_Any` by decoding the given string + /// containing a serialized message in Protocol Buffer text format. + /// + /// - Parameters: + /// - textFormatString: The text format string to decode. + /// - extensions: An `ExtensionMap` used to look up and decode any + /// extensions in this message or messages nested within this message's + /// fields. + /// - Throws: an instance of `TextFormatDecodingError` on failure. + @_disfavoredOverload + public init( + textFormatString: String, + extensions: (any ExtensionMap)? = nil + ) throws { + // TODO: Remove this api and default the options instead when we do a major release. + try self.init( + textFormatString: textFormatString, + options: TextFormatDecodingOptions(), + extensions: extensions + ) + } - /// Creates a new `Google_Protobuf_Any` by decoding the given string - /// containing a serialized message in Protocol Buffer text format. - /// - /// - Parameters: - /// - textFormatString: The text format string to decode. - /// - options: The `TextFormatDencodingOptions` to use. - /// - extensions: An `ExtensionMap` used to look up and decode any - /// extensions in this message or messages nested within this message's - /// fields. - /// - Throws: an instance of `TextFormatDecodingError` on failure. - public init( - textFormatString: String, - options: TextFormatDecodingOptions, - extensions: ExtensionMap? = nil - ) throws { - self.init() - if !textFormatString.isEmpty { - if let data = textFormatString.data(using: String.Encoding.utf8) { - try data.withUnsafeBytes { (body: UnsafeRawBufferPointer) in - if let baseAddress = body.baseAddress, body.count > 0 { - var textDecoder = try TextFormatDecoder( - messageType: Google_Protobuf_Any.self, - utf8Pointer: baseAddress, - count: body.count, - options: options, - extensions: extensions) - try decodeTextFormat(decoder: &textDecoder) - if !textDecoder.complete { - throw TextFormatDecodingError.trailingGarbage + /// Creates a new `Google_Protobuf_Any` by decoding the given string + /// containing a serialized message in Protocol Buffer text format. + /// + /// - Parameters: + /// - textFormatString: The text format string to decode. + /// - options: The ``TextFormatDecodingOptions`` to use. + /// - extensions: An ``ExtensionMap`` used to look up and decode any + /// extensions in this message or messages nested within this message's + /// fields. + /// - Throws: ``TextFormatDecodingError`` on failure. + public init( + textFormatString: String, + options: TextFormatDecodingOptions = TextFormatDecodingOptions(), + extensions: (any ExtensionMap)? = nil + ) throws { + self.init() + if !textFormatString.isEmpty { + if let data = textFormatString.data(using: String.Encoding.utf8) { + try data.withUnsafeBytes { (body: UnsafeRawBufferPointer) in + if let baseAddress = body.baseAddress, body.count > 0 { + var textDecoder = try TextFormatDecoder( + messageType: Google_Protobuf_Any.self, + utf8Pointer: baseAddress, + count: body.count, + options: options, + extensions: extensions + ) + try decodeTextFormat(decoder: &textDecoder) + if !textDecoder.complete { + throw TextFormatDecodingError.trailingGarbage + } + } + } } - } } - } } - } - /// Returns true if this `Google_Protobuf_Any` message contains the given - /// message type. - /// - /// The check is performed by looking at the passed `Message.Type` and the - /// `typeURL` of this message. - /// - /// - Parameter type: The concrete message type. - /// - Returns: True if the receiver contains the given message type. - public func isA(_ type: M.Type) -> Bool { - return _storage.isA(type) - } + /// Returns true if this `Google_Protobuf_Any` message contains the given + /// message type. + /// + /// The check is performed by looking at the passed `Message.Type` and the + /// `typeURL` of this message. + /// + /// - Parameter type: The concrete message type. + /// - Returns: True if the receiver contains the given message type. + public func isA(_ type: M.Type) -> Bool { + _storage.isA(type) + } -#if swift(>=4.2) - public func hash(into hasher: inout Hasher) { - _storage.hash(into: &hasher) - } -#else // swift(>=4.2) - public var hashValue: Int { - return _storage.hashValue - } -#endif // swift(>=4.2) + public func hash(into hasher: inout Hasher) { + _storage.hash(into: &hasher) + } } extension Google_Protobuf_Any { - internal func textTraverse(visitor: inout TextFormatEncodingVisitor) { - _storage.textTraverse(visitor: &visitor) - try! unknownFields.traverse(visitor: &visitor) - } + internal func textTraverse(visitor: inout TextFormatEncodingVisitor) { + _storage.textTraverse(visitor: &visitor) + try! unknownFields.traverse(visitor: &visitor) + } } extension Google_Protobuf_Any { - // Custom text format decoding support for Any objects. - // (Note: This is not a part of any protocol; it's invoked - // directly from TextFormatDecoder whenever it sees an attempt - // to decode an Any object) - internal mutating func decodeTextFormat( - decoder: inout TextFormatDecoder - ) throws { - // First, check if this uses the "verbose" Any encoding. - // If it does, and we have the type available, we can - // eagerly decode the contained Message object. - if let url = try decoder.scanner.nextOptionalAnyURL() { - try _uniqueStorage().decodeTextFormat(typeURL: url, decoder: &decoder) - } else { - // This is not using the specialized encoding, so we can use the - // standard path to decode the binary value. - // First, clear the fields so we don't waste time re-serializing - // the previous contents as this instances get replaced with a - // new value (can happen when a field name/number is repeated in - // the TextFormat input). - self.typeURL = "" - self.value = Data() - try decodeMessage(decoder: &decoder) + // Custom text format decoding support for Any objects. + // (Note: This is not a part of any protocol; it's invoked + // directly from TextFormatDecoder whenever it sees an attempt + // to decode an Any object) + internal mutating func decodeTextFormat( + decoder: inout TextFormatDecoder + ) throws { + // First, check if this uses the "verbose" Any encoding. + // If it does, and we have the type available, we can + // eagerly decode the contained Message object. + if let url = try decoder.scanner.nextOptionalAnyURL() { + try _uniqueStorage().decodeTextFormat(typeURL: url, decoder: &decoder) + } else { + // This is not using the specialized encoding, so we can use the + // standard path to decode the binary value. + // First, clear the fields so we don't waste time re-serializing + // the previous contents as this instances get replaced with a + // new value (can happen when a field name/number is repeated in + // the TextFormat input). + self.typeURL = "" + self.value = Data() + try decodeMessage(decoder: &decoder) + } } - } } extension Google_Protobuf_Any: _CustomJSONCodable { - internal func encodedJSONString(options: JSONEncodingOptions) throws -> String { - return try _storage.encodedJSONString(options: options) - } + internal func encodedJSONString(options: JSONEncodingOptions) throws -> String { + try _storage.encodedJSONString(options: options) + } - internal mutating func decodeJSON(from decoder: inout JSONDecoder) throws { - try _uniqueStorage().decodeJSON(from: &decoder) - } + internal mutating func decodeJSON(from decoder: inout JSONDecoder) throws { + try _uniqueStorage().decodeJSON(from: &decoder) + } } diff --git a/Sources/SwiftProtobuf/Google_Protobuf_Any+Registry.swift b/Sources/SwiftProtobuf/Google_Protobuf_Any+Registry.swift index 74fc010d6..ade82cd0c 100644 --- a/Sources/SwiftProtobuf/Google_Protobuf_Any+Registry.swift +++ b/Sources/SwiftProtobuf/Google_Protobuf_Any+Registry.swift @@ -14,65 +14,82 @@ // ----------------------------------------------------------------------------- import Foundation + +#if !os(WASI) #if canImport(Dispatch) import Dispatch -fileprivate var knownTypesQueue = - DispatchQueue(label: "org.swift.protobuf.typeRegistry", - attributes: .concurrent) +private let knownTypesQueue = + DispatchQueue( + label: "org.swift.protobuf.typeRegistry", + attributes: .concurrent + ) +#endif #endif // TODO: Should these first four be exposed as methods to go with // the general registry support? -internal func buildTypeURL(forMessage message: Message, typePrefix: String) -> String { - var url = typePrefix - let needsSlash = typePrefix.isEmpty || typePrefix.last != "/" - if needsSlash { - url += "/" - } - return url + typeName(fromMessage: message) +internal func buildTypeURL(forMessage message: any Message, typePrefix: String) -> String { + var url = typePrefix + let needsSlash = typePrefix.isEmpty || typePrefix.last != "/" + if needsSlash { + url += "/" + } + return url + typeName(fromMessage: message) } -internal func typeName(fromMessage message: Message) -> String { - let messageType = type(of: message) - return messageType.protoMessageName +internal func typeName(fromMessage message: any Message) -> String { + let messageType = type(of: message) + return messageType.protoMessageName } internal func typeName(fromURL s: String) -> String { - var typeStart = s.startIndex - var i = typeStart - while i < s.endIndex { - let c = s[i] - i = s.index(after: i) - if c == "/" { - typeStart = i + var typeStart = s.startIndex + var i = typeStart + while i < s.endIndex { + let c = s[i] + i = s.index(after: i) + if c == "/" { + typeStart = i + } } - } - return String(s[typeStart.. { + var wrappedValue: Wrapped + init(_ wrappedValue: Wrapped) { + self.wrappedValue = wrappedValue + } +} + +extension UnsafeMutableTransferBox: @unchecked Sendable {} + // All access to this should be done on `knownTypesQueue`. -fileprivate var knownTypes: [String:Message.Type] = [ - // Seeded with the Well Known Types. - "google.protobuf.Any": Google_Protobuf_Any.self, - "google.protobuf.BoolValue": Google_Protobuf_BoolValue.self, - "google.protobuf.BytesValue": Google_Protobuf_BytesValue.self, - "google.protobuf.DoubleValue": Google_Protobuf_DoubleValue.self, - "google.protobuf.Duration": Google_Protobuf_Duration.self, - "google.protobuf.Empty": Google_Protobuf_Empty.self, - "google.protobuf.FieldMask": Google_Protobuf_FieldMask.self, - "google.protobuf.FloatValue": Google_Protobuf_FloatValue.self, - "google.protobuf.Int32Value": Google_Protobuf_Int32Value.self, - "google.protobuf.Int64Value": Google_Protobuf_Int64Value.self, - "google.protobuf.ListValue": Google_Protobuf_ListValue.self, - "google.protobuf.StringValue": Google_Protobuf_StringValue.self, - "google.protobuf.Struct": Google_Protobuf_Struct.self, - "google.protobuf.Timestamp": Google_Protobuf_Timestamp.self, - "google.protobuf.UInt32Value": Google_Protobuf_UInt32Value.self, - "google.protobuf.UInt64Value": Google_Protobuf_UInt64Value.self, - "google.protobuf.Value": Google_Protobuf_Value.self, -] +private let knownTypes: UnsafeMutableTransferBox<[String: any Message.Type]> = .init([ + // Seeded with the Well Known Types. + "google.protobuf.Any": Google_Protobuf_Any.self, + "google.protobuf.BoolValue": Google_Protobuf_BoolValue.self, + "google.protobuf.BytesValue": Google_Protobuf_BytesValue.self, + "google.protobuf.DoubleValue": Google_Protobuf_DoubleValue.self, + "google.protobuf.Duration": Google_Protobuf_Duration.self, + "google.protobuf.Empty": Google_Protobuf_Empty.self, + "google.protobuf.FieldMask": Google_Protobuf_FieldMask.self, + "google.protobuf.FloatValue": Google_Protobuf_FloatValue.self, + "google.protobuf.Int32Value": Google_Protobuf_Int32Value.self, + "google.protobuf.Int64Value": Google_Protobuf_Int64Value.self, + "google.protobuf.ListValue": Google_Protobuf_ListValue.self, + "google.protobuf.StringValue": Google_Protobuf_StringValue.self, + "google.protobuf.Struct": Google_Protobuf_Struct.self, + "google.protobuf.Timestamp": Google_Protobuf_Timestamp.self, + "google.protobuf.UInt32Value": Google_Protobuf_UInt32Value.self, + "google.protobuf.UInt64Value": Google_Protobuf_UInt64Value.self, + "google.protobuf.Value": Google_Protobuf_Value.self, +]) extension Google_Protobuf_Any { @@ -103,17 +120,17 @@ extension Google_Protobuf_Any { /// /// Returns: true if the type was registered, false if something /// else was already registered for the messageName. - @discardableResult public static func register(messageType: Message.Type) -> Bool { + @discardableResult public static func register(messageType: any Message.Type) -> Bool { let messageTypeName = messageType.protoMessageName var result: Bool = false execute(flags: .barrier) { - if let alreadyRegistered = knownTypes[messageTypeName] { + if let alreadyRegistered = knownTypes.wrappedValue[messageTypeName] { // Success/failure when something was already registered is // based on if they are registering the same class or trying // to register a different type result = alreadyRegistered == messageType } else { - knownTypes[messageTypeName] = messageType + knownTypes.wrappedValue[messageTypeName] = messageType result = true } } @@ -122,28 +139,28 @@ extension Google_Protobuf_Any { } /// Returns the Message.Type expected for the given type URL. - public static func messageType(forTypeURL url: String) -> Message.Type? { - let messageTypeName = typeName(fromURL: url) - return messageType(forMessageName: messageTypeName) + public static func messageType(forTypeURL url: String) -> (any Message.Type)? { + let messageTypeName = typeName(fromURL: url) + return messageType(forMessageName: messageTypeName) } /// Returns the Message.Type expected for the given proto message name. - public static func messageType(forMessageName name: String) -> Message.Type? { - var result: Message.Type? + public static func messageType(forMessageName name: String) -> (any Message.Type)? { + var result: (any Message.Type)? execute(flags: .none) { - result = knownTypes[name] + result = knownTypes.wrappedValue[name] } return result } } -fileprivate enum DispatchFlags { +private enum DispatchFlags { case barrier case none } -fileprivate func execute(flags: DispatchFlags, _ closure: () -> Void) { +private func execute(flags: DispatchFlags, _ closure: () -> Void) { #if !os(WASI) switch flags { case .barrier: diff --git a/Sources/SwiftProtobuf/Google_Protobuf_Duration+Extensions.swift b/Sources/SwiftProtobuf/Google_Protobuf_Duration+Extensions.swift index f957f7f03..2fc0073b8 100644 --- a/Sources/SwiftProtobuf/Google_Protobuf_Duration+Extensions.swift +++ b/Sources/SwiftProtobuf/Google_Protobuf_Duration+Extensions.swift @@ -17,210 +17,294 @@ import Foundation private let minDurationSeconds: Int64 = -maxDurationSeconds -private let maxDurationSeconds: Int64 = 315576000000 +private let maxDurationSeconds: Int64 = 315_576_000_000 +private let minDurationNanos: Int32 = -maxDurationNanos +private let maxDurationNanos: Int32 = 999_999_999 private func parseDuration(text: String) throws -> (Int64, Int32) { - var digits = [Character]() - var digitCount = 0 - var total = 0 - var chars = text.makeIterator() - var seconds: Int64? - var nanos: Int32 = 0 - while let c = chars.next() { - switch c { - case "-": - // Only accept '-' as very first character - if total > 0 { - throw JSONDecodingError.malformedDuration - } - digits.append(c) - case "0", "1", "2", "3", "4", "5", "6", "7", "8", "9": - digits.append(c) - digitCount += 1 - case ".": - if let _ = seconds { - throw JSONDecodingError.malformedDuration - } - let digitString = String(digits) - if let s = Int64(digitString), - s >= minDurationSeconds && s <= maxDurationSeconds { - seconds = s - } else { - throw JSONDecodingError.malformedDuration - } - digits.removeAll() - digitCount = 0 - case "s": - if let seconds = seconds { - // Seconds already set, digits holds nanos - while (digitCount < 9) { - digits.append(Character("0")) - digitCount += 1 + var digits = [Character]() + var digitCount = 0 + var total = 0 + var chars = text.makeIterator() + var seconds: Int64? + var nanos: Int32 = 0 + var isNegative = false + while let c = chars.next() { + switch c { + case "-": + // Only accept '-' as very first character + if total > 0 { + throw JSONDecodingError.malformedDuration + } + digits.append(c) + isNegative = true + case "0", "1", "2", "3", "4", "5", "6", "7", "8", "9": + digits.append(c) + digitCount += 1 + case ".": + if let _ = seconds { + throw JSONDecodingError.malformedDuration + } + let digitString = String(digits) + if let s = Int64(digitString), + s >= minDurationSeconds && s <= maxDurationSeconds + { + seconds = s + } else { + throw JSONDecodingError.malformedDuration + } + digits.removeAll() + digitCount = 0 + case "s": + if let _ = seconds { + // Seconds already set, digits holds nanos + while digitCount < 9 { + digits.append(Character("0")) + digitCount += 1 + } + while digitCount > 9 { + digits.removeLast() + digitCount -= 1 + } + let digitString = String(digits) + if let rawNanos = Int32(digitString) { + if isNegative { + nanos = -rawNanos + } else { + nanos = rawNanos + } + } else { + throw JSONDecodingError.malformedDuration + } + } else { + // No fraction, we just have an integral number of seconds + let digitString = String(digits) + if let s = Int64(digitString), + s >= minDurationSeconds && s <= maxDurationSeconds + { + seconds = s + } else { + throw JSONDecodingError.malformedDuration + } + } + // Fail if there are characters after 's' + if chars.next() != nil { + throw JSONDecodingError.malformedDuration + } + return (seconds!, nanos) + default: + throw JSONDecodingError.malformedDuration } - while digitCount > 9 { - digits.removeLast() - digitCount -= 1 - } - let digitString = String(digits) - if let rawNanos = Int32(digitString) { - if seconds < 0 { - nanos = -rawNanos - } else { - nanos = rawNanos - } - } else { - throw JSONDecodingError.malformedDuration - } - } else { - // No fraction, we just have an integral number of seconds - let digitString = String(digits) - if let s = Int64(digitString), - s >= minDurationSeconds && s <= maxDurationSeconds { - seconds = s - } else { - throw JSONDecodingError.malformedDuration - } - } - // Fail if there are characters after 's' - if chars.next() != nil { - throw JSONDecodingError.malformedDuration - } - return (seconds!, nanos) - default: - throw JSONDecodingError.malformedDuration + total += 1 } - total += 1 - } - throw JSONDecodingError.malformedDuration + throw JSONDecodingError.malformedDuration } private func formatDuration(seconds: Int64, nanos: Int32) -> String? { - let (seconds, nanos) = normalizeForDuration(seconds: seconds, nanos: nanos) - guard seconds >= minDurationSeconds && seconds <= maxDurationSeconds else { - return nil - } - let nanosString = nanosToString(nanos: nanos) // Includes leading '.' if needed - return "\(seconds)\(nanosString)s" + // Upstream's json file unparse.cc:WriteDuration() for these checks for reference. + + // Range check... + guard + (seconds >= minDurationSeconds && seconds <= maxDurationSeconds) + && (nanos >= minDurationNanos && nanos <= maxDurationNanos) + else { + return nil + } + // Either seconds or nanos has to be zero otherwise the signs must match. + guard (seconds == 0) || (nanos == 0) || ((seconds < 0) == (nanos < 0)) else { + return nil + } + let nanosString = nanosToString(nanos: nanos) // Includes leading '.' if needed + if seconds == 0 && nanos < 0 { + return "-0\(nanosString)s" + } + return "\(seconds)\(nanosString)s" } extension Google_Protobuf_Duration { - /// Creates a new `Google_Protobuf_Duration` equal to the given number of - /// seconds and nanoseconds. - /// - /// - Parameter seconds: The number of seconds. - /// - Parameter nanos: The number of nanoseconds. - public init(seconds: Int64 = 0, nanos: Int32 = 0) { - self.init() - self.seconds = seconds - self.nanos = nanos - } + /// Creates a new `Google_Protobuf_Duration` equal to the given number of + /// seconds and nanoseconds. + /// + /// - Parameter seconds: The number of seconds. + /// - Parameter nanos: The number of nanoseconds. + public init(seconds: Int64 = 0, nanos: Int32 = 0) { + self.init() + self.seconds = seconds + self.nanos = nanos + } } extension Google_Protobuf_Duration: _CustomJSONCodable { - mutating func decodeJSON(from decoder: inout JSONDecoder) throws { - let s = try decoder.scanner.nextQuotedString() - (seconds, nanos) = try parseDuration(text: s) - } - func encodedJSONString(options: JSONEncodingOptions) throws -> String { - if let formatted = formatDuration(seconds: seconds, nanos: nanos) { - return "\"\(formatted)\"" - } else { - throw JSONEncodingError.durationRange + mutating func decodeJSON(from decoder: inout JSONDecoder) throws { + let s = try decoder.scanner.nextQuotedString() + (seconds, nanos) = try parseDuration(text: s) + } + func encodedJSONString(options: JSONEncodingOptions) throws -> String { + if let formatted = formatDuration(seconds: seconds, nanos: nanos) { + return "\"\(formatted)\"" + } else { + throw JSONEncodingError.durationRange + } } - } } extension Google_Protobuf_Duration: ExpressibleByFloatLiteral { - public typealias FloatLiteralType = Double - - /// Creates a new `Google_Protobuf_Duration` from a floating point literal - /// that is interpreted as a duration in seconds, rounded to the nearest - /// nanosecond. - public init(floatLiteral value: Double) { - let sd = trunc(value) - let nd = round((value - sd) * TimeInterval(nanosPerSecond)) - let (s, n) = normalizeForDuration(seconds: Int64(sd), nanos: Int32(nd)) - self.init(seconds: s, nanos: n) - } + public typealias FloatLiteralType = Double + + /// Creates a new `Google_Protobuf_Duration` from a floating point literal + /// that is interpreted as a duration in seconds, rounded to the nearest + /// nanosecond. + public init(floatLiteral value: Double) { + self.init(rounding: value, rule: .toNearestOrAwayFromZero) + } +} + +extension Google_Protobuf_Duration { + #if !REMOVE_DEPRECATED_APIS + /// Creates a new `Google_Protobuf_Duration` that is equal to the given + /// `TimeInterval` (measured in seconds), rounded to the nearest nanosecond. + /// + /// - Parameter timeInterval: The `TimeInterval`. + @available(*, deprecated, renamed: "init(rounding:rule:)") + public init(timeInterval: TimeInterval) { + self.init(rounding: timeInterval, rule: .toNearestOrAwayFromZero) + } + #endif // !REMOVE_DEPRECATED_APIS + + /// Creates a new `Google_Protobuf_Duration` that is equal to the given + /// `TimeInterval` (measured in seconds), rounded to the nearest nanosecond + /// according to the given rounding rule. + /// + /// - Parameters: + /// - timeInterval: The `TimeInterval`. + /// - rule: The rounding rule to use. + public init( + rounding timeInterval: TimeInterval, + rule: FloatingPointRoundingRule = .toNearestOrAwayFromZero + ) { + let sd = Int64(timeInterval) + let nd = ((timeInterval - Double(sd)) * TimeInterval(nanosPerSecond)).rounded(rule) + // Normalize is here incase things round up to a full second worth of nanos. + let (s, n) = normalizeForDuration(seconds: sd, nanos: Int32(nd)) + self.init(seconds: s, nanos: n) + } + + /// The `TimeInterval` (measured in seconds) equal to this duration. + public var timeInterval: TimeInterval { + TimeInterval(self.seconds) + TimeInterval(self.nanos) / TimeInterval(nanosPerSecond) + } } +@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) extension Google_Protobuf_Duration { - /// Creates a new `Google_Protobuf_Duration` that is equal to the given - /// `TimeInterval` (measured in seconds), rounded to the nearest nanosecond. - /// - /// - Parameter timeInterval: The `TimeInterval`. - public init(timeInterval: TimeInterval) { - let sd = trunc(timeInterval) - let nd = round((timeInterval - sd) * TimeInterval(nanosPerSecond)) - let (s, n) = normalizeForDuration(seconds: Int64(sd), nanos: Int32(nd)) - self.init(seconds: s, nanos: n) - } - - /// The `TimeInterval` (measured in seconds) equal to this duration. - public var timeInterval: TimeInterval { - return TimeInterval(self.seconds) + - TimeInterval(self.nanos) / TimeInterval(nanosPerSecond) - } + /// Creates a new `Google_Protobuf_Duration` by rounding a `Duration` to + /// the nearest nanosecond according to the given rounding rule. + /// + /// - Parameters: + /// - duration: The `Duration`. + /// - rule: The rounding rule to use. + public init( + rounding duration: Duration, + rule: FloatingPointRoundingRule = .toNearestOrAwayFromZero + ) { + let secs = duration.components.seconds + let attos = duration.components.attoseconds + let fracNanos = + (Double(attos % attosPerNanosecond) / Double(attosPerNanosecond)).rounded(rule) + let nanos = Int32(attos / attosPerNanosecond) + Int32(fracNanos) + // Normalize is here incase things round up to a full second worth of nanos. + let (s, n) = normalizeForDuration(seconds: secs, nanos: nanos) + self.init(seconds: s, nanos: n) + } +} + +@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) +extension Duration { + /// Creates a new `Duration` that is equal to the given duration. + /// + /// Swift `Duration` has a strictly higher precision than `Google_Protobuf_Duration` + /// (attoseconds vs. nanoseconds, respectively), so this conversion is always + /// value-preserving. + /// + /// - Parameters: + /// - duration: The `Google_Protobuf_Duration`. + public init(_ duration: Google_Protobuf_Duration) { + self.init( + secondsComponent: duration.seconds, + attosecondsComponent: Int64(duration.nanos) * attosPerNanosecond + ) + } } private func normalizeForDuration( - seconds: Int64, - nanos: Int32 + seconds: Int64, + nanos: Int32 ) -> (seconds: Int64, nanos: Int32) { - var s = seconds - var n = nanos - - // If the magnitude of n exceeds a second then - // we need to factor it into s instead. - if n >= nanosPerSecond || n <= -nanosPerSecond { - s += Int64(n / nanosPerSecond) - n = n % nanosPerSecond - } - - // The Duration spec says that when s != 0, s and - // n must have the same sign. - if s > 0 && n < 0 { - n += nanosPerSecond - s -= 1 - } else if s < 0 && n > 0 { - n -= nanosPerSecond - s += 1 - } - - return (seconds: s, nanos: n) + var s = seconds + var n = nanos + + // If the magnitude of n exceeds a second then + // we need to factor it into s instead. + if n >= nanosPerSecond || n <= -nanosPerSecond { + s += Int64(n / nanosPerSecond) + n = n % nanosPerSecond + } + + // The Duration spec says that when s != 0, s and + // n must have the same sign. + if s > 0 && n < 0 { + n += nanosPerSecond + s -= 1 + } else if s < 0 && n > 0 { + n -= nanosPerSecond + s += 1 + } + + return (seconds: s, nanos: n) } public prefix func - ( - operand: Google_Protobuf_Duration + operand: Google_Protobuf_Duration ) -> Google_Protobuf_Duration { - let (s, n) = normalizeForDuration(seconds: -operand.seconds, - nanos: -operand.nanos) - return Google_Protobuf_Duration(seconds: s, nanos: n) + // This gets normalized (thus allowing an otherwise non-logical input) so it matches what would + // happen if doing `Duration(0,0) - operand` because that has to normalize to handle roll + // over/under. + let (s, n) = normalizeForDuration( + seconds: -operand.seconds, + nanos: -operand.nanos + ) + return Google_Protobuf_Duration(seconds: s, nanos: n) } public func + ( - lhs: Google_Protobuf_Duration, - rhs: Google_Protobuf_Duration + lhs: Google_Protobuf_Duration, + rhs: Google_Protobuf_Duration ) -> Google_Protobuf_Duration { - let (s, n) = normalizeForDuration(seconds: lhs.seconds + rhs.seconds, - nanos: lhs.nanos + rhs.nanos) - return Google_Protobuf_Duration(seconds: s, nanos: n) + let (s, n) = normalizeForDuration( + seconds: lhs.seconds + rhs.seconds, + nanos: lhs.nanos + rhs.nanos + ) + return Google_Protobuf_Duration(seconds: s, nanos: n) } public func - ( - lhs: Google_Protobuf_Duration, - rhs: Google_Protobuf_Duration + lhs: Google_Protobuf_Duration, + rhs: Google_Protobuf_Duration ) -> Google_Protobuf_Duration { - let (s, n) = normalizeForDuration(seconds: lhs.seconds - rhs.seconds, - nanos: lhs.nanos - rhs.nanos) - return Google_Protobuf_Duration(seconds: s, nanos: n) + let (s, n) = normalizeForDuration( + seconds: lhs.seconds - rhs.seconds, + nanos: lhs.nanos - rhs.nanos + ) + return Google_Protobuf_Duration(seconds: s, nanos: n) } public func - ( - lhs: Google_Protobuf_Timestamp, - rhs: Google_Protobuf_Timestamp + lhs: Google_Protobuf_Timestamp, + rhs: Google_Protobuf_Timestamp ) -> Google_Protobuf_Duration { - let (s, n) = normalizeForDuration(seconds: lhs.seconds - rhs.seconds, - nanos: lhs.nanos - rhs.nanos) - return Google_Protobuf_Duration(seconds: s, nanos: n) + let (s, n) = normalizeForDuration( + seconds: lhs.seconds - rhs.seconds, + nanos: lhs.nanos - rhs.nanos + ) + return Google_Protobuf_Duration(seconds: s, nanos: n) } diff --git a/Sources/SwiftProtobuf/Google_Protobuf_FieldMask+Extensions.swift b/Sources/SwiftProtobuf/Google_Protobuf_FieldMask+Extensions.swift index 985f2154f..0fb9121f1 100644 --- a/Sources/SwiftProtobuf/Google_Protobuf_FieldMask+Extensions.swift +++ b/Sources/SwiftProtobuf/Google_Protobuf_FieldMask+Extensions.swift @@ -13,178 +13,355 @@ /// // ----------------------------------------------------------------------------- -// TODO: We should have utilities to apply a fieldmask to an arbitrary -// message, intersect two fieldmasks, etc. -// Google's C++ implementation does this by having utilities -// to build a tree of field paths that can be easily intersected, -// unioned, traversed to apply to submessages, etc. - // True if the string only contains printable (non-control) // ASCII characters. Note: This follows the ASCII standard; // space is not a "printable" character. private func isPrintableASCII(_ s: String) -> Bool { - for u in s.utf8 { - if u <= 0x20 || u >= 0x7f { - return false + for u in s.utf8 { + if u <= 0x20 || u >= 0x7f { + return false + } } - } - return true + return true } private func ProtoToJSON(name: String) -> String? { - guard isPrintableASCII(name) else { return nil } - var jsonPath = String() - var chars = name.makeIterator() - while let c = chars.next() { - switch c { - case "_": - if let toupper = chars.next() { - switch toupper { - case "a"..."z": - jsonPath.append(String(toupper).uppercased()) + guard isPrintableASCII(name) else { return nil } + var jsonPath = String() + var chars = name.makeIterator() + while let c = chars.next() { + switch c { + case "_": + if let toupper = chars.next() { + switch toupper { + case "a"..."z": + jsonPath.append(String(toupper).uppercased()) + default: + return nil + } + } else { + return nil + } + case "A"..."Z": + return nil + case "a"..."z", "0"..."9", ".", "(", ")": + jsonPath.append(c) default: - return nil + // TODO: Change this to `return nil` + // once we know everything legal is handled + // above. + jsonPath.append(c) } - } else { - return nil - } - case "A"..."Z": - return nil - case "a"..."z","0"..."9",".","(",")": - jsonPath.append(c) - default: - // TODO: Change this to `return nil` - // once we know everything legal is handled - // above. - jsonPath.append(c) - } - } - return jsonPath + } + return jsonPath } private func JSONToProto(name: String) -> String? { - guard isPrintableASCII(name) else { return nil } - var path = String() - for c in name { - switch c { - case "_": - return nil - case "A"..."Z": - path.append(Character("_")) - path.append(String(c).lowercased()) - case "a"..."z","0"..."9",".","(",")": - path.append(c) - default: - // TODO: Change to `return nil` once - // we know everything legal is being - // handled above - path.append(c) - } - } - return path + guard isPrintableASCII(name) else { return nil } + var path = String() + for c in name { + switch c { + case "_": + return nil + case "A"..."Z": + path.append(Character("_")) + path.append(String(c).lowercased()) + case "a"..."z", "0"..."9", ".", "(", ")": + path.append(c) + default: + // TODO: Change to `return nil` once + // we know everything legal is being + // handled above + path.append(c) + } + } + return path } private func parseJSONFieldNames(names: String) -> [String]? { - // An empty field mask is the empty string (no paths). - guard !names.isEmpty else { return [] } - var fieldNameCount = 0 - var fieldName = String() - var split = [String]() - for c in names { - switch c { - case ",": - if fieldNameCount == 0 { + // An empty field mask is the empty string (no paths). + guard !names.isEmpty else { return [] } + var fieldNameCount = 0 + var fieldName = String() + var split = [String]() + for c in names { + switch c { + case ",": + if fieldNameCount == 0 { + return nil + } + if let pbName = JSONToProto(name: fieldName) { + split.append(pbName) + } else { + return nil + } + fieldName = String() + fieldNameCount = 0 + default: + fieldName.append(c) + fieldNameCount += 1 + } + } + if fieldNameCount == 0 { // Last field name can't be empty return nil - } - if let pbName = JSONToProto(name: fieldName) { + } + if let pbName = JSONToProto(name: fieldName) { split.append(pbName) - } else { + } else { return nil - } - fieldName = String() - fieldNameCount = 0 - default: - fieldName.append(c) - fieldNameCount += 1 - } - } - if fieldNameCount == 0 { // Last field name can't be empty - return nil - } - if let pbName = JSONToProto(name: fieldName) { - split.append(pbName) - } else { - return nil - } - return split + } + return split } extension Google_Protobuf_FieldMask { - /// Creates a new `Google_Protobuf_FieldMask` from the given array of paths. - /// - /// The paths should match the names used in the .proto file, which may be - /// different than the corresponding Swift property names. - /// - /// - Parameter protoPaths: The paths from which to create the field mask, - /// defined using the .proto names for the fields. - public init(protoPaths: [String]) { - self.init() - paths = protoPaths - } - - /// Creates a new `Google_Protobuf_FieldMask` from the given paths. - /// - /// The paths should match the names used in the .proto file, which may be - /// different than the corresponding Swift property names. - /// - /// - Parameter protoPaths: The paths from which to create the field mask, - /// defined using the .proto names for the fields. - public init(protoPaths: String...) { - self.init(protoPaths: protoPaths) - } - - /// Creates a new `Google_Protobuf_FieldMask` from the given paths. - /// - /// The paths should match the JSON names of the fields, which may be - /// different than the corresponding Swift property names. - /// - /// - Parameter jsonPaths: The paths from which to create the field mask, - /// defined using the JSON names for the fields. - public init?(jsonPaths: String...) { - // TODO: This should fail if any of the conversions from JSON fails - #if swift(>=4.1) - self.init(protoPaths: jsonPaths.compactMap(JSONToProto)) - #else - self.init(protoPaths: jsonPaths.flatMap(JSONToProto)) - #endif - } - - // It would be nice if to have an initializer that accepted Swift property - // names, but translating between swift and protobuf/json property - // names is not entirely deterministic. + /// Creates a new `Google_Protobuf_FieldMask` from the given array of paths. + /// + /// The paths should match the names used in the .proto file, which may be + /// different than the corresponding Swift property names. + /// + /// - Parameter protoPaths: The paths from which to create the field mask, + /// defined using the .proto names for the fields. + public init(protoPaths: [String]) { + self.init() + paths = protoPaths + } + + /// Creates a new `Google_Protobuf_FieldMask` from the given paths. + /// + /// The paths should match the names used in the .proto file, which may be + /// different than the corresponding Swift property names. + /// + /// - Parameter protoPaths: The paths from which to create the field mask, + /// defined using the .proto names for the fields. + public init(protoPaths: String...) { + self.init(protoPaths: protoPaths) + } + + /// Creates a new `Google_Protobuf_FieldMask` from the given paths. + /// + /// The paths should match the JSON names of the fields, which may be + /// different than the corresponding Swift property names. + /// + /// - Parameter jsonPaths: The paths from which to create the field mask, + /// defined using the JSON names for the fields. + public init?(jsonPaths: String...) { + // TODO: This should fail if any of the conversions from JSON fails + self.init(protoPaths: jsonPaths.compactMap(JSONToProto)) + } + + // It would be nice if to have an initializer that accepted Swift property + // names, but translating between swift and protobuf/json property + // names is not entirely deterministic. } extension Google_Protobuf_FieldMask: _CustomJSONCodable { - mutating func decodeJSON(from decoder: inout JSONDecoder) throws { - let s = try decoder.scanner.nextQuotedString() - if let names = parseJSONFieldNames(names: s) { - paths = names - } else { - throw JSONDecodingError.malformedFieldMask - } - } - - func encodedJSONString(options: JSONEncodingOptions) throws -> String { - // Note: Proto requires alphanumeric field names, so there - // cannot be a ',' or '"' character to mess up this formatting. - var jsonPaths = [String]() - for p in paths { - if let jsonPath = ProtoToJSON(name: p) { - jsonPaths.append(jsonPath) - } else { - throw JSONEncodingError.fieldMaskConversion - } - } - return "\"" + jsonPaths.joined(separator: ",") + "\"" - } + mutating func decodeJSON(from decoder: inout JSONDecoder) throws { + let s = try decoder.scanner.nextQuotedString() + if let names = parseJSONFieldNames(names: s) { + paths = names + } else { + throw JSONDecodingError.malformedFieldMask + } + } + + func encodedJSONString(options: JSONEncodingOptions) throws -> String { + // Note: Proto requires alphanumeric field names, so there + // cannot be a ',' or '"' character to mess up this formatting. + var jsonPaths = [String]() + for p in paths { + if let jsonPath = ProtoToJSON(name: p) { + jsonPaths.append(jsonPath) + } else { + throw JSONEncodingError.fieldMaskConversion + } + } + return "\"" + jsonPaths.joined(separator: ",") + "\"" + } +} + +extension Google_Protobuf_FieldMask { + + /// Initiates a field mask with all fields of the message type. + /// + /// - Parameter messageType: Message type to get all paths from. + public init( + allFieldsOf messageType: M.Type + ) { + self = .with { mask in + mask.paths = M.allProtoNames + } + } + + /// Initiates a field mask from some particular field numbers of a message + /// + /// - Parameters: + /// - messageType: Message type to get all paths from. + /// - fieldNumbers: Field numbers of paths to be included. + /// - Returns: Field mask that include paths of corresponding field numbers. + /// - Throws: `FieldMaskError.invalidFieldNumber` if the field number + /// is not on the message + public init( + fieldNumbers: [Int], + of messageType: M.Type + ) throws { + var paths: [String] = [] + for number in fieldNumbers { + guard let name = M.protoName(for: number) else { + throw FieldMaskError.invalidFieldNumber + } + paths.append(name) + } + self = .with { mask in + mask.paths = paths + } + } +} + +extension Google_Protobuf_FieldMask { + + /// Adds a path to FieldMask after checking whether the given path is valid. + /// This method check-fails if the path is not a valid path for Message type. + /// + /// - Parameters: + /// - path: Path to be added to FieldMask. + /// - messageType: Message type to check validity. + public mutating func addPath( + _ path: String, + of messageType: M.Type + ) throws { + guard M.isPathValid(path) else { + throw FieldMaskError.invalidPath + } + paths.append(path) + } + + /// Converts a FieldMask to the canonical form. It will: + /// 1. Remove paths that are covered by another path. For example, + /// "foo.bar" is covered by "foo" and will be removed if "foo" + /// is also in the FieldMask. + /// 2. Sort all paths in alphabetical order. + public var canonical: Google_Protobuf_FieldMask { + var mask = Google_Protobuf_FieldMask() + let sortedPaths = self.paths.sorted() + for path in sortedPaths { + if let lastPath = mask.paths.last { + if path != lastPath, !path.hasPrefix("\(lastPath).") { + mask.paths.append(path) + } + } else { + mask.paths.append(path) + } + } + return mask + } + + /// Creates an union of two FieldMasks. + /// + /// - Parameter mask: FieldMask to union with. + /// - Returns: FieldMask with union of two path sets. + public func union( + _ mask: Google_Protobuf_FieldMask + ) -> Google_Protobuf_FieldMask { + var buffer: Set = .init() + var paths: [String] = [] + let allPaths = self.paths + mask.paths + for path in allPaths where !buffer.contains(path) { + buffer.insert(path) + paths.append(path) + } + return .with { mask in + mask.paths = paths + } + } + + /// Creates an intersection of two FieldMasks. + /// + /// - Parameter mask: FieldMask to intersect with. + /// - Returns: FieldMask with intersection of two path sets. + public func intersect( + _ mask: Google_Protobuf_FieldMask + ) -> Google_Protobuf_FieldMask { + let set = Set(mask.paths) + var paths: [String] = [] + var buffer = Set() + for path in self.paths where set.contains(path) && !buffer.contains(path) { + buffer.insert(path) + paths.append(path) + } + return .with { mask in + mask.paths = paths + } + } + + /// Creates a FieldMasks with paths of the original FieldMask + /// that does not included in mask. + /// + /// - Parameter mask: FieldMask with paths should be substracted. + /// - Returns: FieldMask with all paths does not included in mask. + public func subtract( + _ mask: Google_Protobuf_FieldMask + ) -> Google_Protobuf_FieldMask { + let set = Set(mask.paths) + var paths: [String] = [] + var buffer = Set() + for path in self.paths where !set.contains(path) && !buffer.contains(path) { + buffer.insert(path) + paths.append(path) + } + return .with { mask in + mask.paths = paths + } + } + + /// Returns true if path is covered by the given FieldMask. Note that path + /// "foo.bar" covers all paths like "foo.bar.baz", "foo.bar.quz.x", etc. + /// Also note that parent paths are not covered by explicit child path, i.e. + /// "foo.bar" does NOT cover "foo", even if "bar" is the only child. + /// + /// - Parameter path: Path to be checked. + /// - Returns: Boolean determines is path covered. + public func contains(_ path: String) -> Bool { + for fieldMaskPath in paths { + if path.hasPrefix("\(fieldMaskPath).") || fieldMaskPath == path { + return true + } + } + return false + } +} + +extension Google_Protobuf_FieldMask { + + /// Checks whether the given FieldMask is valid for type M. + /// + /// - Parameter messageType: Message type to paths check with. + /// - Returns: Boolean determines FieldMask is valid. + public func isValid( + for messageType: M.Type + ) -> Bool { + var message = M() + return paths.allSatisfy { path in + message.isPathValid(path) + } + } +} + +/// Describes errors could happen during FieldMask utilities. +public enum FieldMaskError: Error { + + /// Describes a path is invalid for a Message type. + case invalidPath + + /// Describes a fieldNumber is invalid for a Message type. + case invalidFieldNumber +} + +extension Message where Self: _ProtoNameProviding { + fileprivate static func protoName(for number: Int) -> String? { + Self._protobuf_nameMap.names(for: number)?.proto.description + } + + fileprivate static var allProtoNames: [String] { + Self._protobuf_nameMap.names.map(\.description) + } } diff --git a/Sources/SwiftProtobuf/Google_Protobuf_ListValue+Extensions.swift b/Sources/SwiftProtobuf/Google_Protobuf_ListValue+Extensions.swift index a26e0d730..559b99dd8 100644 --- a/Sources/SwiftProtobuf/Google_Protobuf_ListValue+Extensions.swift +++ b/Sources/SwiftProtobuf/Google_Protobuf_ListValue+Extensions.swift @@ -14,72 +14,72 @@ // ----------------------------------------------------------------------------- extension Google_Protobuf_ListValue: ExpressibleByArrayLiteral { - // TODO: Give this a direct array interface by proxying the interesting - // bits down to values - public typealias Element = Google_Protobuf_Value + // TODO: Give this a direct array interface by proxying the interesting + // bits down to values + public typealias Element = Google_Protobuf_Value - /// Creates a new `Google_Protobuf_ListValue` from an array literal containing - /// `Google_Protobuf_Value` elements. - public init(arrayLiteral elements: Element...) { - self.init(values: elements) - } + /// Creates a new `Google_Protobuf_ListValue` from an array literal containing + /// `Google_Protobuf_Value` elements. + public init(arrayLiteral elements: Element...) { + self.init(values: elements) + } } extension Google_Protobuf_ListValue: _CustomJSONCodable { - internal func encodedJSONString(options: JSONEncodingOptions) throws -> String { - var jsonEncoder = JSONEncoder() - jsonEncoder.append(text: "[") - var separator: StaticString = "" - for v in values { - jsonEncoder.append(staticText: separator) - try v.serializeJSONValue(to: &jsonEncoder, options: options) - separator = "," + internal func encodedJSONString(options: JSONEncodingOptions) throws -> String { + var jsonEncoder = JSONEncoder() + jsonEncoder.append(text: "[") + var separator: StaticString = "" + for v in values { + jsonEncoder.append(staticText: separator) + try v.serializeJSONValue(to: &jsonEncoder, options: options) + separator = "," + } + jsonEncoder.append(text: "]") + return jsonEncoder.stringResult } - jsonEncoder.append(text: "]") - return jsonEncoder.stringResult - } - internal mutating func decodeJSON(from decoder: inout JSONDecoder) throws { - if decoder.scanner.skipOptionalNull() { - return - } - try decoder.scanner.skipRequiredArrayStart() - // Since we override the JSON decoding, we can't rely - // on the default recursion depth tracking. - try decoder.scanner.incrementRecursionDepth() - if decoder.scanner.skipOptionalArrayEnd() { - decoder.scanner.decrementRecursionDepth() - return - } - while true { - var v = Google_Protobuf_Value() - try v.decodeJSON(from: &decoder) - values.append(v) - if decoder.scanner.skipOptionalArrayEnd() { - decoder.scanner.decrementRecursionDepth() - return - } - try decoder.scanner.skipRequiredComma() + internal mutating func decodeJSON(from decoder: inout JSONDecoder) throws { + if decoder.scanner.skipOptionalNull() { + return + } + try decoder.scanner.skipRequiredArrayStart() + // Since we override the JSON decoding, we can't rely + // on the default recursion depth tracking. + try decoder.scanner.incrementRecursionDepth() + if decoder.scanner.skipOptionalArrayEnd() { + decoder.scanner.decrementRecursionDepth() + return + } + while true { + var v = Google_Protobuf_Value() + try v.decodeJSON(from: &decoder) + values.append(v) + if decoder.scanner.skipOptionalArrayEnd() { + decoder.scanner.decrementRecursionDepth() + return + } + try decoder.scanner.skipRequiredComma() + } } - } } extension Google_Protobuf_ListValue { - /// Creates a new `Google_Protobuf_ListValue` from the given array of - /// `Google_Protobuf_Value` elements. - /// - /// - Parameter values: The list of `Google_Protobuf_Value` messages from - /// which to create the `Google_Protobuf_ListValue`. - public init(values: [Google_Protobuf_Value]) { - self.init() - self.values = values - } + /// Creates a new `Google_Protobuf_ListValue` from the given array of + /// `Google_Protobuf_Value` elements. + /// + /// - Parameter values: The list of `Google_Protobuf_Value` messages from + /// which to create the `Google_Protobuf_ListValue`. + public init(values: [Google_Protobuf_Value]) { + self.init() + self.values = values + } - /// Accesses the `Google_Protobuf_Value` at the specified position. - /// - /// - Parameter index: The position of the element to access. - public subscript(index: Int) -> Google_Protobuf_Value { - get {return values[index]} - set(newValue) {values[index] = newValue} - } + /// Accesses the `Google_Protobuf_Value` at the specified position. + /// + /// - Parameter index: The position of the element to access. + public subscript(index: Int) -> Google_Protobuf_Value { + get { values[index] } + set(newValue) { values[index] = newValue } + } } diff --git a/Sources/SwiftProtobuf/Google_Protobuf_NullValue+Extensions.swift b/Sources/SwiftProtobuf/Google_Protobuf_NullValue+Extensions.swift index 3e88bfd36..9d80b13a1 100644 --- a/Sources/SwiftProtobuf/Google_Protobuf_NullValue+Extensions.swift +++ b/Sources/SwiftProtobuf/Google_Protobuf_NullValue+Extensions.swift @@ -14,15 +14,15 @@ // ----------------------------------------------------------------------------- extension Google_Protobuf_NullValue: _CustomJSONCodable { - internal func encodedJSONString(options: JSONEncodingOptions) throws -> String { - return "null" - } - internal mutating func decodeJSON(from decoder: inout JSONDecoder) throws { - if decoder.scanner.skipOptionalNull() { - return + internal func encodedJSONString(options: JSONEncodingOptions) throws -> String { + "null" + } + internal mutating func decodeJSON(from decoder: inout JSONDecoder) throws { + if decoder.scanner.skipOptionalNull() { + return + } + } + static func decodedFromJSONNull() -> Google_Protobuf_NullValue? { + .nullValue } - } - static func decodedFromJSONNull() -> Google_Protobuf_NullValue? { - return .nullValue - } } diff --git a/Sources/SwiftProtobuf/Google_Protobuf_Struct+Extensions.swift b/Sources/SwiftProtobuf/Google_Protobuf_Struct+Extensions.swift index 681f82142..1c334393b 100644 --- a/Sources/SwiftProtobuf/Google_Protobuf_Struct+Extensions.swift +++ b/Sources/SwiftProtobuf/Google_Protobuf_Struct+Extensions.swift @@ -14,72 +14,72 @@ // ----------------------------------------------------------------------------- extension Google_Protobuf_Struct: ExpressibleByDictionaryLiteral { - public typealias Key = String - public typealias Value = Google_Protobuf_Value + public typealias Key = String + public typealias Value = Google_Protobuf_Value - /// Creates a new `Google_Protobuf_Struct` from a dictionary of string keys to - /// values of type `Google_Protobuf_Value`. - public init(dictionaryLiteral: (String, Google_Protobuf_Value)...) { - self.init() - for (k,v) in dictionaryLiteral { - fields[k] = v + /// Creates a new `Google_Protobuf_Struct` from a dictionary of string keys to + /// values of type `Google_Protobuf_Value`. + public init(dictionaryLiteral: (String, Google_Protobuf_Value)...) { + self.init() + for (k, v) in dictionaryLiteral { + fields[k] = v + } } - } } extension Google_Protobuf_Struct: _CustomJSONCodable { - internal func encodedJSONString(options: JSONEncodingOptions) throws -> String { - var jsonEncoder = JSONEncoder() - jsonEncoder.startObject() - var mapVisitor = JSONMapEncodingVisitor(encoder: jsonEncoder, options: options) - for (k,v) in fields { - try mapVisitor.visitSingularStringField(value: k, fieldNumber: 1) - try mapVisitor.visitSingularMessageField(value: v, fieldNumber: 2) + internal func encodedJSONString(options: JSONEncodingOptions) throws -> String { + var jsonEncoder = JSONEncoder() + jsonEncoder.startObject() + var mapVisitor = JSONMapEncodingVisitor(encoder: jsonEncoder, options: options) + for (k, v) in fields { + try mapVisitor.visitSingularStringField(value: k, fieldNumber: 1) + try mapVisitor.visitSingularMessageField(value: v, fieldNumber: 2) + } + mapVisitor.encoder.endObject() + return mapVisitor.encoder.stringResult } - mapVisitor.encoder.endObject() - return mapVisitor.encoder.stringResult - } - internal mutating func decodeJSON(from decoder: inout JSONDecoder) throws { - try decoder.scanner.skipRequiredObjectStart() - if decoder.scanner.skipOptionalObjectEnd() { - return + internal mutating func decodeJSON(from decoder: inout JSONDecoder) throws { + try decoder.scanner.skipRequiredObjectStart() + if decoder.scanner.skipOptionalObjectEnd() { + return + } + while true { + let key = try decoder.scanner.nextQuotedString() + try decoder.scanner.skipRequiredColon() + var value = Google_Protobuf_Value() + try value.decodeJSON(from: &decoder) + fields[key] = value + if decoder.scanner.skipOptionalObjectEnd() { + return + } + try decoder.scanner.skipRequiredComma() + } } - while true { - let key = try decoder.scanner.nextQuotedString() - try decoder.scanner.skipRequiredColon() - var value = Google_Protobuf_Value() - try value.decodeJSON(from: &decoder) - fields[key] = value - if decoder.scanner.skipOptionalObjectEnd() { - return - } - try decoder.scanner.skipRequiredComma() - } - } } extension Google_Protobuf_Struct { - /// Creates a new `Google_Protobuf_Struct` from a dictionary of string keys to - /// values of type `Google_Protobuf_Value`. - /// - /// - Parameter fields: The dictionary from field names to - /// `Google_Protobuf_Value` messages that should be used to create the - /// `Struct`. - public init(fields: [String: Google_Protobuf_Value]) { - self.init() - self.fields = fields - } + /// Creates a new `Google_Protobuf_Struct` from a dictionary of string keys to + /// values of type `Google_Protobuf_Value`. + /// + /// - Parameter fields: The dictionary from field names to + /// `Google_Protobuf_Value` messages that should be used to create the + /// `Struct`. + public init(fields: [String: Google_Protobuf_Value]) { + self.init() + self.fields = fields + } - /// Accesses the `Google_Protobuf_Value` with the given key for reading and - /// writing. - /// - /// This key-based subscript returns the `Value` for the given key if the key - /// is found in the `Struct`, or nil if the key is not found. If you assign - /// nil as the `Value` for the given key, the `Struct` removes that key and - /// its associated `Value`. - public subscript(key: String) -> Google_Protobuf_Value? { - get {return fields[key]} - set(newValue) {fields[key] = newValue} - } + /// Accesses the `Google_Protobuf_Value` with the given key for reading and + /// writing. + /// + /// This key-based subscript returns the `Value` for the given key if the key + /// is found in the `Struct`, or nil if the key is not found. If you assign + /// nil as the `Value` for the given key, the `Struct` removes that key and + /// its associated `Value`. + public subscript(key: String) -> Google_Protobuf_Value? { + get { fields[key] } + set(newValue) { fields[key] = newValue } + } } diff --git a/Sources/SwiftProtobuf/Google_Protobuf_Timestamp+Extensions.swift b/Sources/SwiftProtobuf/Google_Protobuf_Timestamp+Extensions.swift index ab0a68b87..2a4a24b9f 100644 --- a/Sources/SwiftProtobuf/Google_Protobuf_Timestamp+Extensions.swift +++ b/Sources/SwiftProtobuf/Google_Protobuf_Timestamp+Extensions.swift @@ -15,317 +15,380 @@ import Foundation -private let minTimestampSeconds: Int64 = -62135596800 // 0001-01-01T00:00:00Z -private let maxTimestampSeconds: Int64 = 253402300799 // 9999-12-31T23:59:59Z +private let minTimestampSeconds: Int64 = -62_135_596_800 // 0001-01-01T00:00:00Z +private let maxTimestampSeconds: Int64 = 253_402_300_799 // 9999-12-31T23:59:59Z +// From timestamp.proto: +// Non-negative fractions of a second at nanosecond resolution. Negative +// second values with fractions must still have non-negative nanos values +// that count forward in time. Must be from 0 to 999,999,999 +// inclusive. +private let minTimestampNanos: Int32 = 0 +private let maxTimestampNanos: Int32 = 999_999_999 // TODO: Add convenience methods to interoperate with standard // date/time classes: an initializer that accepts Unix timestamp as // Int or Double, an easy way to convert to/from Foundation's // NSDateTime (on Apple platforms only?), others? - // Parse an RFC3339 timestamp into a pair of seconds-since-1970 and nanos. private func parseTimestamp(s: String) throws -> (Int64, Int32) { - // Convert to an array of integer character values - let value = s.utf8.map{Int($0)} - if value.count < 20 { - throw JSONDecodingError.malformedTimestamp - } - // Since the format is fixed-layout, we can just decode - // directly as follows. - let zero = Int(48) - let nine = Int(57) - let dash = Int(45) - let colon = Int(58) - let plus = Int(43) - let letterT = Int(84) - let letterZ = Int(90) - let period = Int(46) - - func fromAscii2(_ digit0: Int, _ digit1: Int) throws -> Int { - if digit0 < zero || digit0 > nine || digit1 < zero || digit1 > nine { - throw JSONDecodingError.malformedTimestamp + // Convert to an array of integer character values + let value = s.utf8.map { Int($0) } + if value.count < 20 { + throw JSONDecodingError.malformedTimestamp + } + // Since the format is fixed-layout, we can just decode + // directly as follows. + let zero = Int(48) + let nine = Int(57) + let dash = Int(45) + let colon = Int(58) + let plus = Int(43) + let letterT = Int(84) + let letterZ = Int(90) + let period = Int(46) + + func fromAscii2(_ digit0: Int, _ digit1: Int) throws -> Int { + if digit0 < zero || digit0 > nine || digit1 < zero || digit1 > nine { + throw JSONDecodingError.malformedTimestamp + } + return digit0 * 10 + digit1 - 528 + } + + func fromAscii4( + _ digit0: Int, + _ digit1: Int, + _ digit2: Int, + _ digit3: Int + ) throws -> Int { + if digit0 < zero || digit0 > nine + || digit1 < zero || digit1 > nine + || digit2 < zero || digit2 > nine + || digit3 < zero || digit3 > nine + { + throw JSONDecodingError.malformedTimestamp + } + return digit0 * 1000 + digit1 * 100 + digit2 * 10 + digit3 - 53328 + } + + // Year: 4 digits followed by '-' + let year = try fromAscii4(value[0], value[1], value[2], value[3]) + if value[4] != dash || year < Int(1) || year > Int(9999) { + throw JSONDecodingError.malformedTimestamp + } + + // Month: 2 digits followed by '-' + let month = try fromAscii2(value[5], value[6]) + if value[7] != dash || month < Int(1) || month > Int(12) { + throw JSONDecodingError.malformedTimestamp + } + + // Day: 2 digits followed by 'T' + let mday = try fromAscii2(value[8], value[9]) + if value[10] != letterT || mday < Int(1) || mday > Int(31) { + throw JSONDecodingError.malformedTimestamp } - return digit0 * 10 + digit1 - 528 - } - - func fromAscii4( - _ digit0: Int, - _ digit1: Int, - _ digit2: Int, - _ digit3: Int - ) throws -> Int { - if (digit0 < zero || digit0 > nine - || digit1 < zero || digit1 > nine - || digit2 < zero || digit2 > nine - || digit3 < zero || digit3 > nine) { - throw JSONDecodingError.malformedTimestamp + + // Hour: 2 digits followed by ':' + let hour = try fromAscii2(value[11], value[12]) + if value[13] != colon || hour > Int(23) { + throw JSONDecodingError.malformedTimestamp } - return digit0 * 1000 + digit1 * 100 + digit2 * 10 + digit3 - 53328 - } - - // Year: 4 digits followed by '-' - let year = try fromAscii4(value[0], value[1], value[2], value[3]) - if value[4] != dash || year < Int(1) || year > Int(9999) { - throw JSONDecodingError.malformedTimestamp - } - - // Month: 2 digits followed by '-' - let month = try fromAscii2(value[5], value[6]) - if value[7] != dash || month < Int(1) || month > Int(12) { - throw JSONDecodingError.malformedTimestamp - } - - // Day: 2 digits followed by 'T' - let mday = try fromAscii2(value[8], value[9]) - if value[10] != letterT || mday < Int(1) || mday > Int(31) { - throw JSONDecodingError.malformedTimestamp - } - - // Hour: 2 digits followed by ':' - let hour = try fromAscii2(value[11], value[12]) - if value[13] != colon || hour > Int(23) { - throw JSONDecodingError.malformedTimestamp - } - - // Minute: 2 digits followed by ':' - let minute = try fromAscii2(value[14], value[15]) - if value[16] != colon || minute > Int(59) { - throw JSONDecodingError.malformedTimestamp - } - - // Second: 2 digits (following char is checked below) - let second = try fromAscii2(value[17], value[18]) - if second > Int(61) { - throw JSONDecodingError.malformedTimestamp - } - - // timegm() is almost entirely useless. It's nonexistent on - // some platforms, broken on others. Everything else I've tried - // is even worse. Hence the code below. - // (If you have a better way to do this, try it and see if it - // passes the test suite on both Linux and OS X.) - - // Day of year - let mdayStart: [Int] = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334] - var yday = Int64(mdayStart[month - 1]) - let isleap = (year % 400 == 0) || ((year % 100 != 0) && (year % 4 == 0)) - if isleap && (month > 2) { - yday += 1 - } - yday += Int64(mday - 1) - - // Days since start of epoch (including leap days) - var daysSinceEpoch = yday - daysSinceEpoch += Int64(365 * year) - Int64(719527) - daysSinceEpoch += Int64((year - 1) / 4) - daysSinceEpoch -= Int64((year - 1) / 100) - daysSinceEpoch += Int64((year - 1) / 400) - - // Second within day - var daySec = Int64(hour) - daySec *= 60 - daySec += Int64(minute) - daySec *= 60 - daySec += Int64(second) - - // Seconds since start of epoch - let t = daysSinceEpoch * Int64(86400) + daySec - - // After seconds, comes various optional bits - var pos = 19 - - var nanos: Int32 = 0 - if value[pos] == period { // "." begins fractional seconds - pos += 1 - var digitValue = 100000000 - while pos < value.count && value[pos] >= zero && value[pos] <= nine { - nanos += Int32(digitValue * (value[pos] - zero)) - digitValue /= 10 - pos += 1 + + // Minute: 2 digits followed by ':' + let minute = try fromAscii2(value[14], value[15]) + if value[16] != colon || minute > Int(59) { + throw JSONDecodingError.malformedTimestamp } - } - - var seconds: Int64 = 0 - // "Z" or "+" or "-" starts Timezone offset - if pos >= value.count { - throw JSONDecodingError.malformedTimestamp - } else if value[pos] == plus || value[pos] == dash { - if pos + 6 > value.count { - throw JSONDecodingError.malformedTimestamp + + // Second: 2 digits (following char is checked below) + let second = try fromAscii2(value[17], value[18]) + if second > Int(61) { + throw JSONDecodingError.malformedTimestamp + } + + // timegm() is almost entirely useless. It's nonexistent on + // some platforms, broken on others. Everything else I've tried + // is even worse. Hence the code below. + // (If you have a better way to do this, try it and see if it + // passes the test suite on both Linux and OS X.) + + // Day of year + let mdayStart: [Int] = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334] + var yday = Int64(mdayStart[month - 1]) + let isleap = (year % 400 == 0) || ((year % 100 != 0) && (year % 4 == 0)) + if isleap && (month > 2) { + yday += 1 } - let hourOffset = try fromAscii2(value[pos + 1], value[pos + 2]) - let minuteOffset = try fromAscii2(value[pos + 4], value[pos + 5]) - if hourOffset > Int(13) || minuteOffset > Int(59) || value[pos + 3] != colon { - throw JSONDecodingError.malformedTimestamp + yday += Int64(mday - 1) + + // Days since start of epoch (including leap days) + var daysSinceEpoch = yday + daysSinceEpoch += Int64(365 * year) - Int64(719527) + daysSinceEpoch += Int64((year - 1) / 4) + daysSinceEpoch -= Int64((year - 1) / 100) + daysSinceEpoch += Int64((year - 1) / 400) + + // Second within day + var daySec = Int64(hour) + daySec *= 60 + daySec += Int64(minute) + daySec *= 60 + daySec += Int64(second) + + // Seconds since start of epoch + let t = daysSinceEpoch * Int64(86400) + daySec + + // After seconds, comes various optional bits + var pos = 19 + + var nanos: Int32 = 0 + if value[pos] == period { // "." begins fractional seconds + pos += 1 + var digitValue = 100_000_000 + while pos < value.count && value[pos] >= zero && value[pos] <= nine { + nanos += Int32(digitValue * (value[pos] - zero)) + digitValue /= 10 + pos += 1 + } } - var adjusted: Int64 = t - if value[pos] == plus { - adjusted -= Int64(hourOffset) * Int64(3600) - adjusted -= Int64(minuteOffset) * Int64(60) + + var seconds: Int64 = 0 + // "Z" or "+" or "-" starts Timezone offset + if pos >= value.count { + throw JSONDecodingError.malformedTimestamp + } else if value[pos] == plus || value[pos] == dash { + if pos + 6 > value.count { + throw JSONDecodingError.malformedTimestamp + } + let hourOffset = try fromAscii2(value[pos + 1], value[pos + 2]) + let minuteOffset = try fromAscii2(value[pos + 4], value[pos + 5]) + if hourOffset > Int(13) || minuteOffset > Int(59) || value[pos + 3] != colon { + throw JSONDecodingError.malformedTimestamp + } + var adjusted: Int64 = t + if value[pos] == plus { + adjusted -= Int64(hourOffset) * Int64(3600) + adjusted -= Int64(minuteOffset) * Int64(60) + } else { + adjusted += Int64(hourOffset) * Int64(3600) + adjusted += Int64(minuteOffset) * Int64(60) + } + seconds = adjusted + pos += 6 + } else if value[pos] == letterZ { // "Z" indicator for UTC + seconds = t + pos += 1 } else { - adjusted += Int64(hourOffset) * Int64(3600) - adjusted += Int64(minuteOffset) * Int64(60) + throw JSONDecodingError.malformedTimestamp + } + if pos != value.count { + throw JSONDecodingError.malformedTimestamp } - if adjusted < minTimestampSeconds || adjusted > maxTimestampSeconds { - throw JSONDecodingError.malformedTimestamp + guard seconds >= minTimestampSeconds && seconds <= maxTimestampSeconds else { + throw JSONDecodingError.malformedTimestamp } - seconds = adjusted - pos += 6 - } else if value[pos] == letterZ { // "Z" indicator for UTC - seconds = t - pos += 1 - } else { - throw JSONDecodingError.malformedTimestamp - } - if pos != value.count { - throw JSONDecodingError.malformedTimestamp - } - return (seconds, nanos) + return (seconds, nanos) } private func formatTimestamp(seconds: Int64, nanos: Int32) -> String? { - let (seconds, nanos) = normalizeForTimestamp(seconds: seconds, nanos: nanos) - guard seconds >= minTimestampSeconds && seconds <= maxTimestampSeconds else { - return nil - } + guard + (seconds >= minTimestampSeconds && seconds <= maxTimestampSeconds) + && (nanos >= minTimestampNanos && nanos <= maxTimestampNanos) + else { + return nil + } - let (hh, mm, ss) = timeOfDayFromSecondsSince1970(seconds: seconds) - let (YY, MM, DD) = gregorianDateFromSecondsSince1970(seconds: seconds) + let (hh, mm, ss) = timeOfDayFromSecondsSince1970(seconds: seconds) + let (YY, MM, DD) = gregorianDateFromSecondsSince1970(seconds: seconds) - let dateString = "\(fourDigit(YY))-\(twoDigit(MM))-\(twoDigit(DD))" - let timeString = "\(twoDigit(hh)):\(twoDigit(mm)):\(twoDigit(ss))" - let nanosString = nanosToString(nanos: nanos) // Includes leading '.' if needed + let dateString = "\(fourDigit(YY))-\(twoDigit(MM))-\(twoDigit(DD))" + let timeString = "\(twoDigit(hh)):\(twoDigit(mm)):\(twoDigit(ss))" + let nanosString = nanosToString(nanos: nanos) // Includes leading '.' if needed - return "\(dateString)T\(timeString)\(nanosString)Z" + return "\(dateString)T\(timeString)\(nanosString)Z" } extension Google_Protobuf_Timestamp { - /// Creates a new `Google_Protobuf_Timestamp` equal to the given number of - /// seconds and nanoseconds. - /// - /// - Parameter seconds: The number of seconds. - /// - Parameter nanos: The number of nanoseconds. - public init(seconds: Int64 = 0, nanos: Int32 = 0) { - self.init() - self.seconds = seconds - self.nanos = nanos - } + /// Creates a new `Google_Protobuf_Timestamp` equal to the given number of + /// seconds and nanoseconds. + /// + /// - Parameter seconds: The number of seconds. + /// - Parameter nanos: The number of nanoseconds. + public init(seconds: Int64 = 0, nanos: Int32 = 0) { + self.init() + self.seconds = seconds + self.nanos = nanos + } } extension Google_Protobuf_Timestamp: _CustomJSONCodable { - mutating func decodeJSON(from decoder: inout JSONDecoder) throws { - let s = try decoder.scanner.nextQuotedString() - (seconds, nanos) = try parseTimestamp(s: s) - } - - func encodedJSONString(options: JSONEncodingOptions) throws -> String { - if let formatted = formatTimestamp(seconds: seconds, nanos: nanos) { - return "\"\(formatted)\"" - } else { - throw JSONEncodingError.timestampRange + mutating func decodeJSON(from decoder: inout JSONDecoder) throws { + let s = try decoder.scanner.nextQuotedString() + (seconds, nanos) = try parseTimestamp(s: s) + } + + func encodedJSONString(options: JSONEncodingOptions) throws -> String { + if let formatted = formatTimestamp(seconds: seconds, nanos: nanos) { + return "\"\(formatted)\"" + } else { + throw JSONEncodingError.timestampRange + } } - } } extension Google_Protobuf_Timestamp { - /// Creates a new `Google_Protobuf_Timestamp` initialized relative to 00:00:00 - /// UTC on 1 January 1970 by a given number of seconds. - /// - /// - Parameter timeIntervalSince1970: The `TimeInterval`, interpreted as - /// seconds relative to 00:00:00 UTC on 1 January 1970. - public init(timeIntervalSince1970: TimeInterval) { - let sd = floor(timeIntervalSince1970) - let nd = round((timeIntervalSince1970 - sd) * TimeInterval(nanosPerSecond)) - let (s, n) = normalizeForTimestamp(seconds: Int64(sd), nanos: Int32(nd)) - self.init(seconds: s, nanos: n) - } - - /// Creates a new `Google_Protobuf_Timestamp` initialized relative to 00:00:00 - /// UTC on 1 January 2001 by a given number of seconds. - /// - /// - Parameter timeIntervalSinceReferenceDate: The `TimeInterval`, - /// interpreted as seconds relative to 00:00:00 UTC on 1 January 2001. - public init(timeIntervalSinceReferenceDate: TimeInterval) { - let sd = floor(timeIntervalSinceReferenceDate) - let nd = round( - (timeIntervalSinceReferenceDate - sd) * TimeInterval(nanosPerSecond)) - // The addition of timeIntervalBetween1970And... is deliberately delayed - // until the input is separated into an integer part and a fraction - // part, so that we don't unnecessarily lose precision. - let (s, n) = normalizeForTimestamp( - seconds: Int64(sd) + Int64(Date.timeIntervalBetween1970AndReferenceDate), - nanos: Int32(nd)) - self.init(seconds: s, nanos: n) - } - - /// Creates a new `Google_Protobuf_Timestamp` initialized to the same time as - /// the given `Date`. - /// - /// - Parameter date: The `Date` with which to initialize the timestamp. - public init(date: Date) { - // Note: Internally, Date uses the "reference date," not the 1970 date. - // We use it when interacting with Dates so that Date doesn't perform - // any double arithmetic on our behalf, which might cost us precision. - self.init( - timeIntervalSinceReferenceDate: date.timeIntervalSinceReferenceDate) - } - - /// The interval between the timestamp and 00:00:00 UTC on 1 January 1970. - public var timeIntervalSince1970: TimeInterval { - return TimeInterval(self.seconds) + - TimeInterval(self.nanos) / TimeInterval(nanosPerSecond) - } - - /// The interval between the timestamp and 00:00:00 UTC on 1 January 2001. - public var timeIntervalSinceReferenceDate: TimeInterval { - return TimeInterval( - self.seconds - Int64(Date.timeIntervalBetween1970AndReferenceDate)) + - TimeInterval(self.nanos) / TimeInterval(nanosPerSecond) - } - - /// A `Date` initialized to the same time as the timestamp. - public var date: Date { - return Date( - timeIntervalSinceReferenceDate: self.timeIntervalSinceReferenceDate) - } + #if !REMOVE_DEPRECATED_APIS + /// Creates a new `Google_Protobuf_Timestamp` initialized relative to 00:00:00 + /// UTC on 1 January 1970 by a given number of seconds. + /// + /// - Parameter timeIntervalSince1970: The `TimeInterval`, interpreted as + /// seconds relative to 00:00:00 UTC on 1 January 1970. + @available(*, deprecated, renamed: "init(roundingTimeIntervalSince1970:rule:)") + public init(timeIntervalSince1970: TimeInterval) { + self.init(roundingTimeIntervalSince1970: timeIntervalSince1970, rule: .toNearestOrAwayFromZero) + } + #endif // !REMOVE_DEPRECATED_APIS + + /// Creates a new `Google_Protobuf_Timestamp` initialized relative to 00:00:00 + /// UTC on 1 January 1970 by a given number of seconds, rounded to the nearest + /// nanosecond according to the given rounding rule. + /// + /// - Parameters: + /// - timeIntervalSince1970: The `TimeInterval`, interpreted as + /// seconds relative to 00:00:00 UTC on 1 January 1970. + /// - rule: The rounding rule to use. + public init( + roundingTimeIntervalSince1970 timeIntervalSince1970: TimeInterval, + rule: FloatingPointRoundingRule = .toNearestOrAwayFromZero + ) { + let sd = Int64(timeIntervalSince1970) + let nd = ((timeIntervalSince1970 - Double(sd)) * TimeInterval(nanosPerSecond)).rounded(rule) + // Normalize is here incase things round to a full second worth of nanos. + let (s, n) = normalizeForTimestamp(seconds: sd, nanos: Int32(nd)) + self.init(seconds: s, nanos: n) + } + + #if !REMOVE_DEPRECATED_APIS + /// Creates a new `Google_Protobuf_Timestamp` initialized relative to 00:00:00 + /// UTC on 1 January 2001 by a given number of seconds. + /// + /// - Parameter timeIntervalSinceReferenceDate: The `TimeInterval`, + /// interpreted as seconds relative to 00:00:00 UTC on 1 January 2001. + @available(*, deprecated, renamed: "init(roundingTimeIntervalSinceReferenceDate:rule:)") + public init(timeIntervalSinceReferenceDate: TimeInterval) { + self.init( + roundingTimeIntervalSinceReferenceDate: timeIntervalSinceReferenceDate, + rule: .toNearestOrAwayFromZero + ) + } + #endif // !REMOVE_DEPRECATED_APIS + + /// Creates a new `Google_Protobuf_Timestamp` initialized relative to 00:00:00 + /// UTC on 1 January 2001 by a given number of seconds, rounded to the nearest + /// nanosecond according to the given rounding rule. + /// + /// - Parameters: + /// - timeIntervalSinceReferenceDate: The `TimeInterval`, + /// interpreted as seconds relative to 00:00:00 UTC on 1 January 2001. + /// - rule: The rounding rule to use. + public init( + roundingTimeIntervalSinceReferenceDate timeIntervalSinceReferenceDate: TimeInterval, + rule: FloatingPointRoundingRule = .toNearestOrAwayFromZero + ) { + let sd = Int64(timeIntervalSinceReferenceDate) + let nd = ((timeIntervalSinceReferenceDate - Double(sd)) * TimeInterval(nanosPerSecond)).rounded(rule) + + // The addition of timeIntervalBetween1970And... is deliberately delayed + // until the input is separated into an integer part and a fraction + // part, so that we don't unnecessarily lose precision. + // + // Normalize is here incase things round to a full second worth of nanos. + let (s, n) = normalizeForTimestamp( + seconds: sd + Int64(Date.timeIntervalBetween1970AndReferenceDate), + nanos: Int32(nd) + ) + self.init(seconds: s, nanos: n) + } + + /// Creates a new `Google_Protobuf_Timestamp` initialized to the same time as + /// the given `Date`. + /// + /// - Parameter date: The `Date` with which to initialize the timestamp. + public init(date: Date) { + // Note: Internally, Date uses the "reference date," not the 1970 date. + // We use it when interacting with Dates so that Date doesn't perform + // any double arithmetic on our behalf, which might cost us precision. + // + // Even though this goes through a rounding api, the api doesn't bother + // to expose any controls on it. `Date` doesn't seem to document the + // internal precision and looking at current (Jan 2025) Foundation + // sources, the precision of the operations used just to get the + // _current_ time are platform-dependent. So it doesn't seem + // like exposing the control for something that vague is worthwhile. + self.init(roundingTimeIntervalSinceReferenceDate: date.timeIntervalSinceReferenceDate) + } + + /// The interval between the timestamp and 00:00:00 UTC on 1 January 1970. + public var timeIntervalSince1970: TimeInterval { + TimeInterval(self.seconds) + TimeInterval(self.nanos) / TimeInterval(nanosPerSecond) + } + + /// The interval between the timestamp and 00:00:00 UTC on 1 January 2001. + public var timeIntervalSinceReferenceDate: TimeInterval { + TimeInterval( + self.seconds - Int64(Date.timeIntervalBetween1970AndReferenceDate) + ) + TimeInterval(self.nanos) / TimeInterval(nanosPerSecond) + } + + /// A `Date` initialized to the same time as the timestamp. + public var date: Date { + Date( + timeIntervalSinceReferenceDate: self.timeIntervalSinceReferenceDate + ) + } } private func normalizeForTimestamp( - seconds: Int64, - nanos: Int32 + seconds: Int64, + nanos: Int32 ) -> (seconds: Int64, nanos: Int32) { - // The Timestamp spec says that nanos must be in the range [0, 999999999), - // as in actual modular arithmetic. - - let s = seconds + Int64(div(nanos, nanosPerSecond)) - let n = mod(nanos, nanosPerSecond) - return (seconds: s, nanos: n) + // The Timestamp spec says that nanos must be in the range [0, 999999999), + // as in actual modular arithmetic. + let s = seconds + Int64(div(nanos, nanosPerSecond)) + let n = mod(nanos, nanosPerSecond) + return (seconds: s, nanos: n) } public func + ( - lhs: Google_Protobuf_Timestamp, - rhs: Google_Protobuf_Duration + lhs: Google_Protobuf_Timestamp, + rhs: Google_Protobuf_Duration ) -> Google_Protobuf_Timestamp { - let (s, n) = normalizeForTimestamp(seconds: lhs.seconds + rhs.seconds, - nanos: lhs.nanos + rhs.nanos) - return Google_Protobuf_Timestamp(seconds: s, nanos: n) + let (s, n) = normalizeForTimestamp( + seconds: lhs.seconds + rhs.seconds, + nanos: lhs.nanos + rhs.nanos + ) + return Google_Protobuf_Timestamp(seconds: s, nanos: n) } public func + ( - lhs: Google_Protobuf_Duration, - rhs: Google_Protobuf_Timestamp + lhs: Google_Protobuf_Duration, + rhs: Google_Protobuf_Timestamp ) -> Google_Protobuf_Timestamp { - let (s, n) = normalizeForTimestamp(seconds: lhs.seconds + rhs.seconds, - nanos: lhs.nanos + rhs.nanos) - return Google_Protobuf_Timestamp(seconds: s, nanos: n) + let (s, n) = normalizeForTimestamp( + seconds: lhs.seconds + rhs.seconds, + nanos: lhs.nanos + rhs.nanos + ) + return Google_Protobuf_Timestamp(seconds: s, nanos: n) } public func - ( - lhs: Google_Protobuf_Timestamp, - rhs: Google_Protobuf_Duration + lhs: Google_Protobuf_Timestamp, + rhs: Google_Protobuf_Duration ) -> Google_Protobuf_Timestamp { - let (s, n) = normalizeForTimestamp(seconds: lhs.seconds - rhs.seconds, - nanos: lhs.nanos - rhs.nanos) - return Google_Protobuf_Timestamp(seconds: s, nanos: n) + let (s, n) = normalizeForTimestamp( + seconds: lhs.seconds - rhs.seconds, + nanos: lhs.nanos - rhs.nanos + ) + return Google_Protobuf_Timestamp(seconds: s, nanos: n) } diff --git a/Sources/SwiftProtobuf/Google_Protobuf_Value+Extensions.swift b/Sources/SwiftProtobuf/Google_Protobuf_Value+Extensions.swift index 63301dcca..65b5b74f7 100644 --- a/Sources/SwiftProtobuf/Google_Protobuf_Value+Extensions.swift +++ b/Sources/SwiftProtobuf/Google_Protobuf_Value+Extensions.swift @@ -14,150 +14,154 @@ // ----------------------------------------------------------------------------- extension Google_Protobuf_Value: ExpressibleByIntegerLiteral { - public typealias IntegerLiteralType = Int64 + public typealias IntegerLiteralType = Int64 - /// Creates a new `Google_Protobuf_Value` from an integer literal. - public init(integerLiteral value: Int64) { - self.init(kind: .numberValue(Double(value))) - } + /// Creates a new `Google_Protobuf_Value` from an integer literal. + public init(integerLiteral value: Int64) { + self.init(kind: .numberValue(Double(value))) + } } extension Google_Protobuf_Value: ExpressibleByFloatLiteral { - public typealias FloatLiteralType = Double + public typealias FloatLiteralType = Double - /// Creates a new `Google_Protobuf_Value` from a floating point literal. - public init(floatLiteral value: Double) { - self.init(kind: .numberValue(value)) - } + /// Creates a new `Google_Protobuf_Value` from a floating point literal. + public init(floatLiteral value: Double) { + self.init(kind: .numberValue(value)) + } } extension Google_Protobuf_Value: ExpressibleByBooleanLiteral { - public typealias BooleanLiteralType = Bool + public typealias BooleanLiteralType = Bool - /// Creates a new `Google_Protobuf_Value` from a boolean literal. - public init(booleanLiteral value: Bool) { - self.init(kind: .boolValue(value)) - } + /// Creates a new `Google_Protobuf_Value` from a boolean literal. + public init(booleanLiteral value: Bool) { + self.init(kind: .boolValue(value)) + } } extension Google_Protobuf_Value: ExpressibleByStringLiteral { - public typealias StringLiteralType = String - public typealias ExtendedGraphemeClusterLiteralType = String - public typealias UnicodeScalarLiteralType = String - - /// Creates a new `Google_Protobuf_Value` from a string literal. - public init(stringLiteral value: String) { - self.init(kind: .stringValue(value)) - } - - /// Creates a new `Google_Protobuf_Value` from a Unicode scalar literal. - public init(unicodeScalarLiteral value: String) { - self.init(kind: .stringValue(value)) - } - - /// Creates a new `Google_Protobuf_Value` from a character literal. - public init(extendedGraphemeClusterLiteral value: String) { - self.init(kind: .stringValue(value)) - } + public typealias StringLiteralType = String + public typealias ExtendedGraphemeClusterLiteralType = String + public typealias UnicodeScalarLiteralType = String + + /// Creates a new `Google_Protobuf_Value` from a string literal. + public init(stringLiteral value: String) { + self.init(kind: .stringValue(value)) + } + + /// Creates a new `Google_Protobuf_Value` from a Unicode scalar literal. + public init(unicodeScalarLiteral value: String) { + self.init(kind: .stringValue(value)) + } + + /// Creates a new `Google_Protobuf_Value` from a character literal. + public init(extendedGraphemeClusterLiteral value: String) { + self.init(kind: .stringValue(value)) + } } extension Google_Protobuf_Value: ExpressibleByNilLiteral { - /// Creates a new `Google_Protobuf_Value` from the nil literal. - public init(nilLiteral: ()) { - self.init(kind: .nullValue(.nullValue)) - } + /// Creates a new `Google_Protobuf_Value` from the nil literal. + public init(nilLiteral: ()) { + self.init(kind: .nullValue(.nullValue)) + } } extension Google_Protobuf_Value: _CustomJSONCodable { - internal func encodedJSONString(options: JSONEncodingOptions) throws -> String { - var jsonEncoder = JSONEncoder() - try serializeJSONValue(to: &jsonEncoder, options: options) - return jsonEncoder.stringResult - } - - internal mutating func decodeJSON(from decoder: inout JSONDecoder) throws { - let c = try decoder.scanner.peekOneCharacter() - switch c { - case "n": - if !decoder.scanner.skipOptionalNull() { - throw JSONDecodingError.failure - } - kind = .nullValue(.nullValue) - case "[": - var l = Google_Protobuf_ListValue() - try l.decodeJSON(from: &decoder) - kind = .listValue(l) - case "{": - var s = Google_Protobuf_Struct() - try s.decodeJSON(from: &decoder) - kind = .structValue(s) - case "t", "f": - let b = try decoder.scanner.nextBool() - kind = .boolValue(b) - case "\"": - let s = try decoder.scanner.nextQuotedString() - kind = .stringValue(s) - default: - let d = try decoder.scanner.nextDouble() - kind = .numberValue(d) - } - } - - internal static func decodedFromJSONNull() -> Google_Protobuf_Value? { - return Google_Protobuf_Value(kind: .nullValue(.nullValue)) - } + internal func encodedJSONString(options: JSONEncodingOptions) throws -> String { + var jsonEncoder = JSONEncoder() + try serializeJSONValue(to: &jsonEncoder, options: options) + return jsonEncoder.stringResult + } + + internal mutating func decodeJSON(from decoder: inout JSONDecoder) throws { + let c = try decoder.scanner.peekOneCharacter() + switch c { + case "n": + if !decoder.scanner.skipOptionalNull() { + throw JSONDecodingError.failure + } + kind = .nullValue(.nullValue) + case "[": + var l = Google_Protobuf_ListValue() + try l.decodeJSON(from: &decoder) + kind = .listValue(l) + case "{": + var s = Google_Protobuf_Struct() + try s.decodeJSON(from: &decoder) + kind = .structValue(s) + case "t", "f": + let b = try decoder.scanner.nextBool() + kind = .boolValue(b) + case "\"": + let s = try decoder.scanner.nextQuotedString() + kind = .stringValue(s) + default: + let d = try decoder.scanner.nextDouble() + kind = .numberValue(d) + } + } + + internal static func decodedFromJSONNull() -> Google_Protobuf_Value? { + Google_Protobuf_Value(kind: .nullValue(.nullValue)) + } } extension Google_Protobuf_Value { - /// Creates a new `Google_Protobuf_Value` with the given kind. - fileprivate init(kind: OneOf_Kind) { - self.init() - self.kind = kind - } - - /// Creates a new `Google_Protobuf_Value` whose `kind` is `numberValue` with - /// the given floating-point value. - public init(numberValue: Double) { - self.init(kind: .numberValue(numberValue)) - } - - /// Creates a new `Google_Protobuf_Value` whose `kind` is `stringValue` with - /// the given string value. - public init(stringValue: String) { - self.init(kind: .stringValue(stringValue)) - } - - /// Creates a new `Google_Protobuf_Value` whose `kind` is `boolValue` with the - /// given boolean value. - public init(boolValue: Bool) { - self.init(kind: .boolValue(boolValue)) - } - - /// Creates a new `Google_Protobuf_Value` whose `kind` is `structValue` with - /// the given `Google_Protobuf_Struct` value. - public init(structValue: Google_Protobuf_Struct) { - self.init(kind: .structValue(structValue)) - } - - /// Creates a new `Google_Protobuf_Value` whose `kind` is `listValue` with the - /// given `Google_Struct_ListValue` value. - public init(listValue: Google_Protobuf_ListValue) { - self.init(kind: .listValue(listValue)) - } - - /// Writes out the JSON representation of the value to the given encoder. - internal func serializeJSONValue( - to encoder: inout JSONEncoder, - options: JSONEncodingOptions - ) throws { - switch kind { - case .nullValue?: encoder.putNullValue() - case .numberValue(let v)?: encoder.putDoubleValue(value: v) - case .stringValue(let v)?: encoder.putStringValue(value: v) - case .boolValue(let v)?: encoder.putBoolValue(value: v) - case .structValue(let v)?: encoder.append(text: try v.jsonString(options: options)) - case .listValue(let v)?: encoder.append(text: try v.jsonString(options: options)) - case nil: throw JSONEncodingError.missingValue - } - } + /// Creates a new `Google_Protobuf_Value` with the given kind. + fileprivate init(kind: OneOf_Kind) { + self.init() + self.kind = kind + } + + /// Creates a new `Google_Protobuf_Value` whose `kind` is `numberValue` with + /// the given floating-point value. + public init(numberValue: Double) { + self.init(kind: .numberValue(numberValue)) + } + + /// Creates a new `Google_Protobuf_Value` whose `kind` is `stringValue` with + /// the given string value. + public init(stringValue: String) { + self.init(kind: .stringValue(stringValue)) + } + + /// Creates a new `Google_Protobuf_Value` whose `kind` is `boolValue` with the + /// given boolean value. + public init(boolValue: Bool) { + self.init(kind: .boolValue(boolValue)) + } + + /// Creates a new `Google_Protobuf_Value` whose `kind` is `structValue` with + /// the given `Google_Protobuf_Struct` value. + public init(structValue: Google_Protobuf_Struct) { + self.init(kind: .structValue(structValue)) + } + + /// Creates a new `Google_Protobuf_Value` whose `kind` is `listValue` with the + /// given `Google_Struct_ListValue` value. + public init(listValue: Google_Protobuf_ListValue) { + self.init(kind: .listValue(listValue)) + } + + /// Writes out the JSON representation of the value to the given encoder. + internal func serializeJSONValue( + to encoder: inout JSONEncoder, + options: JSONEncodingOptions + ) throws { + switch kind { + case .nullValue?: encoder.putNullValue() + case .numberValue(let v)?: + guard v.isFinite else { + throw JSONEncodingError.valueNumberNotFinite + } + encoder.putDoubleValue(value: v) + case .stringValue(let v)?: encoder.putStringValue(value: v) + case .boolValue(let v)?: encoder.putNonQuotedBoolValue(value: v) + case .structValue(let v)?: encoder.append(text: try v.jsonString(options: options)) + case .listValue(let v)?: encoder.append(text: try v.jsonString(options: options)) + case nil: throw JSONEncodingError.missingValue + } + } } diff --git a/Sources/SwiftProtobuf/Google_Protobuf_Wrappers+Extensions.swift b/Sources/SwiftProtobuf/Google_Protobuf_Wrappers+Extensions.swift index 625262db9..f3c3ba1f7 100644 --- a/Sources/SwiftProtobuf/Google_Protobuf_Wrappers+Extensions.swift +++ b/Sources/SwiftProtobuf/Google_Protobuf_Wrappers+Extensions.swift @@ -19,229 +19,245 @@ import Foundation /// wrapper types extended below. protocol ProtobufWrapper { - /// The wrapped protobuf type (for example, `ProtobufDouble`). - associatedtype WrappedType: FieldType + /// The wrapped protobuf type (for example, `ProtobufDouble`). + associatedtype WrappedType: FieldType - /// Exposes the generated property to the extensions here. - var value: WrappedType.BaseType { get set } + /// Exposes the generated property to the extensions here. + var value: WrappedType.BaseType { get set } - /// Exposes the parameterless initializer to the extensions here. - init() + /// Exposes the parameterless initializer to the extensions here. + init() - /// Creates a new instance of the wrapper with the given value. - init(_ value: WrappedType.BaseType) + /// Creates a new instance of the wrapper with the given value. + init(_ value: WrappedType.BaseType) } extension ProtobufWrapper { - mutating func decodeJSON(from decoder: inout JSONDecoder) throws { - var v: WrappedType.BaseType? - try WrappedType.decodeSingular(value: &v, from: &decoder) - value = v ?? WrappedType.proto3DefaultValue - } + mutating func decodeJSON(from decoder: inout JSONDecoder) throws { + var v: WrappedType.BaseType? + try WrappedType.decodeSingular(value: &v, from: &decoder) + value = v ?? WrappedType.proto3DefaultValue + } } extension Google_Protobuf_DoubleValue: - ProtobufWrapper, ExpressibleByFloatLiteral, _CustomJSONCodable { - - public typealias WrappedType = ProtobufDouble - public typealias FloatLiteralType = WrappedType.BaseType - - public init(_ value: WrappedType.BaseType) { - self.init() - self.value = value - } - - public init(floatLiteral: FloatLiteralType) { - self.init(floatLiteral) - } - - func encodedJSONString(options: JSONEncodingOptions) throws -> String { - if value.isFinite { - // Swift 4.2 and later guarantees that this is accurate - // enough to parse back to the exact value on the other end. - return value.description - } else { - // Protobuf-specific handling of NaN and infinities - var encoder = JSONEncoder() - encoder.putDoubleValue(value: value) - return encoder.stringResult - } - } + ProtobufWrapper, ExpressibleByFloatLiteral, _CustomJSONCodable +{ + + public typealias WrappedType = ProtobufDouble + public typealias FloatLiteralType = WrappedType.BaseType + + public init(_ value: WrappedType.BaseType) { + self.init() + self.value = value + } + + public init(floatLiteral: FloatLiteralType) { + self.init(floatLiteral) + } + + func encodedJSONString(options: JSONEncodingOptions) throws -> String { + if value.isFinite { + // Swift 4.2 and later guarantees that this is accurate + // enough to parse back to the exact value on the other end. + return value.description + } else { + // Protobuf-specific handling of NaN and infinities + var encoder = JSONEncoder() + encoder.putDoubleValue(value: value) + return encoder.stringResult + } + } } extension Google_Protobuf_FloatValue: - ProtobufWrapper, ExpressibleByFloatLiteral, _CustomJSONCodable { - - public typealias WrappedType = ProtobufFloat - public typealias FloatLiteralType = Float - - public init(_ value: WrappedType.BaseType) { - self.init() - self.value = value - } - - public init(floatLiteral: FloatLiteralType) { - self.init(floatLiteral) - } - - func encodedJSONString(options: JSONEncodingOptions) throws -> String { - if value.isFinite { - // Swift 4.2 and later guarantees that this is accurate - // enough to parse back to the exact value on the other end. - return value.description - } else { - // Protobuf-specific handling of NaN and infinities - var encoder = JSONEncoder() - encoder.putFloatValue(value: value) - return encoder.stringResult - } - } + ProtobufWrapper, ExpressibleByFloatLiteral, _CustomJSONCodable +{ + + public typealias WrappedType = ProtobufFloat + public typealias FloatLiteralType = Float + + public init(_ value: WrappedType.BaseType) { + self.init() + self.value = value + } + + public init(floatLiteral: FloatLiteralType) { + self.init(floatLiteral) + } + + func encodedJSONString(options: JSONEncodingOptions) throws -> String { + if value.isFinite { + // Swift 4.2 and later guarantees that this is accurate + // enough to parse back to the exact value on the other end. + return value.description + } else { + // Protobuf-specific handling of NaN and infinities + var encoder = JSONEncoder() + encoder.putFloatValue(value: value) + return encoder.stringResult + } + } } extension Google_Protobuf_Int64Value: - ProtobufWrapper, ExpressibleByIntegerLiteral, _CustomJSONCodable { + ProtobufWrapper, ExpressibleByIntegerLiteral, _CustomJSONCodable +{ - public typealias WrappedType = ProtobufInt64 - public typealias IntegerLiteralType = WrappedType.BaseType + public typealias WrappedType = ProtobufInt64 + public typealias IntegerLiteralType = WrappedType.BaseType - public init(_ value: WrappedType.BaseType) { - self.init() - self.value = value - } + public init(_ value: WrappedType.BaseType) { + self.init() + self.value = value + } - public init(integerLiteral: IntegerLiteralType) { - self.init(integerLiteral) - } + public init(integerLiteral: IntegerLiteralType) { + self.init(integerLiteral) + } - func encodedJSONString(options: JSONEncodingOptions) throws -> String { - return "\"" + String(value) + "\"" - } + func encodedJSONString(options: JSONEncodingOptions) throws -> String { + var encoded = value.description + if !options.alwaysPrintInt64sAsNumbers { + encoded = "\"" + encoded + "\"" + } + return encoded + } } extension Google_Protobuf_UInt64Value: - ProtobufWrapper, ExpressibleByIntegerLiteral, _CustomJSONCodable { + ProtobufWrapper, ExpressibleByIntegerLiteral, _CustomJSONCodable +{ - public typealias WrappedType = ProtobufUInt64 - public typealias IntegerLiteralType = WrappedType.BaseType + public typealias WrappedType = ProtobufUInt64 + public typealias IntegerLiteralType = WrappedType.BaseType - public init(_ value: WrappedType.BaseType) { - self.init() - self.value = value - } + public init(_ value: WrappedType.BaseType) { + self.init() + self.value = value + } - public init(integerLiteral: IntegerLiteralType) { - self.init(integerLiteral) - } + public init(integerLiteral: IntegerLiteralType) { + self.init(integerLiteral) + } - func encodedJSONString(options: JSONEncodingOptions) throws -> String { - return "\"" + String(value) + "\"" - } + func encodedJSONString(options: JSONEncodingOptions) throws -> String { + var encoded = String(value) + if !options.alwaysPrintInt64sAsNumbers { + encoded = "\"" + encoded + "\"" + } + return encoded + } } extension Google_Protobuf_Int32Value: - ProtobufWrapper, ExpressibleByIntegerLiteral, _CustomJSONCodable { + ProtobufWrapper, ExpressibleByIntegerLiteral, _CustomJSONCodable +{ - public typealias WrappedType = ProtobufInt32 - public typealias IntegerLiteralType = WrappedType.BaseType + public typealias WrappedType = ProtobufInt32 + public typealias IntegerLiteralType = WrappedType.BaseType - public init(_ value: WrappedType.BaseType) { - self.init() - self.value = value - } + public init(_ value: WrappedType.BaseType) { + self.init() + self.value = value + } - public init(integerLiteral: IntegerLiteralType) { - self.init(integerLiteral) - } + public init(integerLiteral: IntegerLiteralType) { + self.init(integerLiteral) + } - func encodedJSONString(options: JSONEncodingOptions) throws -> String { - return String(value) - } + func encodedJSONString(options: JSONEncodingOptions) throws -> String { + String(value) + } } extension Google_Protobuf_UInt32Value: - ProtobufWrapper, ExpressibleByIntegerLiteral, _CustomJSONCodable { + ProtobufWrapper, ExpressibleByIntegerLiteral, _CustomJSONCodable +{ - public typealias WrappedType = ProtobufUInt32 - public typealias IntegerLiteralType = WrappedType.BaseType + public typealias WrappedType = ProtobufUInt32 + public typealias IntegerLiteralType = WrappedType.BaseType - public init(_ value: WrappedType.BaseType) { - self.init() - self.value = value - } + public init(_ value: WrappedType.BaseType) { + self.init() + self.value = value + } - public init(integerLiteral: IntegerLiteralType) { - self.init(integerLiteral) - } + public init(integerLiteral: IntegerLiteralType) { + self.init(integerLiteral) + } - func encodedJSONString(options: JSONEncodingOptions) throws -> String { - return String(value) - } + func encodedJSONString(options: JSONEncodingOptions) throws -> String { + String(value) + } } extension Google_Protobuf_BoolValue: - ProtobufWrapper, ExpressibleByBooleanLiteral, _CustomJSONCodable { + ProtobufWrapper, ExpressibleByBooleanLiteral, _CustomJSONCodable +{ - public typealias WrappedType = ProtobufBool - public typealias BooleanLiteralType = Bool + public typealias WrappedType = ProtobufBool + public typealias BooleanLiteralType = Bool - public init(_ value: WrappedType.BaseType) { - self.init() - self.value = value - } + public init(_ value: WrappedType.BaseType) { + self.init() + self.value = value + } - public init(booleanLiteral: Bool) { - self.init(booleanLiteral) - } + public init(booleanLiteral: Bool) { + self.init(booleanLiteral) + } - func encodedJSONString(options: JSONEncodingOptions) throws -> String { - return value ? "true" : "false" - } + func encodedJSONString(options: JSONEncodingOptions) throws -> String { + value ? "true" : "false" + } } extension Google_Protobuf_StringValue: - ProtobufWrapper, ExpressibleByStringLiteral, _CustomJSONCodable { - - public typealias WrappedType = ProtobufString - public typealias StringLiteralType = String - public typealias ExtendedGraphemeClusterLiteralType = String - public typealias UnicodeScalarLiteralType = String - - public init(_ value: WrappedType.BaseType) { - self.init() - self.value = value - } - - public init(stringLiteral: String) { - self.init(stringLiteral) - } - - public init(extendedGraphemeClusterLiteral: String) { - self.init(extendedGraphemeClusterLiteral) - } - - public init(unicodeScalarLiteral: String) { - self.init(unicodeScalarLiteral) - } - - func encodedJSONString(options: JSONEncodingOptions) throws -> String { - var encoder = JSONEncoder() - encoder.putStringValue(value: value) - return encoder.stringResult - } + ProtobufWrapper, ExpressibleByStringLiteral, _CustomJSONCodable +{ + + public typealias WrappedType = ProtobufString + public typealias StringLiteralType = String + public typealias ExtendedGraphemeClusterLiteralType = String + public typealias UnicodeScalarLiteralType = String + + public init(_ value: WrappedType.BaseType) { + self.init() + self.value = value + } + + public init(stringLiteral: String) { + self.init(stringLiteral) + } + + public init(extendedGraphemeClusterLiteral: String) { + self.init(extendedGraphemeClusterLiteral) + } + + public init(unicodeScalarLiteral: String) { + self.init(unicodeScalarLiteral) + } + + func encodedJSONString(options: JSONEncodingOptions) throws -> String { + var encoder = JSONEncoder() + encoder.putStringValue(value: value) + return encoder.stringResult + } } extension Google_Protobuf_BytesValue: ProtobufWrapper, _CustomJSONCodable { - public typealias WrappedType = ProtobufBytes + public typealias WrappedType = ProtobufBytes - public init(_ value: WrappedType.BaseType) { - self.init() - self.value = value - } + public init(_ value: WrappedType.BaseType) { + self.init() + self.value = value + } - func encodedJSONString(options: JSONEncodingOptions) throws -> String { - var encoder = JSONEncoder() - encoder.putBytesValue(value: value) - return encoder.stringResult - } + func encodedJSONString(options: JSONEncodingOptions) throws -> String { + var encoder = JSONEncoder() + encoder.putBytesValue(value: value) + return encoder.stringResult + } } diff --git a/Sources/SwiftProtobuf/HashVisitor.swift b/Sources/SwiftProtobuf/HashVisitor.swift index 395af2acf..47f2a0acd 100644 --- a/Sources/SwiftProtobuf/HashVisitor.swift +++ b/Sources/SwiftProtobuf/HashVisitor.swift @@ -15,8 +15,8 @@ import Foundation -private let i_2166136261 = Int(bitPattern: 2166136261) -private let i_16777619 = Int(16777619) +private let i_2166136261 = Int(bitPattern: 2_166_136_261) +private let i_16777619 = Int(16_777_619) /// Computes the hash of a message by visiting its fields recursively. /// @@ -27,400 +27,195 @@ private let i_16777619 = Int(16777619) /// message fields they want to include. internal struct HashVisitor: Visitor { -#if swift(>=4.2) - internal private(set) var hasher: Hasher -#else // swift(>=4.2) - // Roughly based on FNV hash: http://tools.ietf.org/html/draft-eastlake-fnv-03 - private(set) var hashValue = i_2166136261 - - private mutating func mix(_ hash: Int) { - hashValue = (hashValue ^ hash) &* i_16777619 - } - - private mutating func mixMap(map: Dictionary) { - var mapHash = 0 - for (k, v) in map { - // Note: This calculation cannot depend on the order of the items. - mapHash = mapHash &+ (k.hashValue ^ v.hashValue) + internal private(set) var hasher: Hasher + + init(_ hasher: Hasher) { + self.hasher = hasher + } + + mutating func visitUnknown(bytes: Data) throws { + hasher.combine(bytes) + } + + mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws { + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws { + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws { + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws { + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitSingularStringField(value: String, fieldNumber: Int) throws { + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws { + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitSingularEnumField( + value: E, + fieldNumber: Int + ) { + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitSingularMessageField(value: M, fieldNumber: Int) { + hasher.combine(fieldNumber) + value.hash(into: &hasher) + } + + mutating func visitRepeatedFloatField(value: [Float], fieldNumber: Int) throws { + assert(!value.isEmpty) + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitRepeatedDoubleField(value: [Double], fieldNumber: Int) throws { + assert(!value.isEmpty) + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitRepeatedInt32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitRepeatedInt64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitRepeatedUInt32Field(value: [UInt32], fieldNumber: Int) throws { + assert(!value.isEmpty) + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitRepeatedUInt64Field(value: [UInt64], fieldNumber: Int) throws { + assert(!value.isEmpty) + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitRepeatedSInt32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitRepeatedSInt64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitRepeatedFixed32Field(value: [UInt32], fieldNumber: Int) throws { + assert(!value.isEmpty) + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitRepeatedFixed64Field(value: [UInt64], fieldNumber: Int) throws { + assert(!value.isEmpty) + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitRepeatedSFixed32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitRepeatedSFixed64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitRepeatedBoolField(value: [Bool], fieldNumber: Int) throws { + assert(!value.isEmpty) + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitRepeatedStringField(value: [String], fieldNumber: Int) throws { + assert(!value.isEmpty) + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitRepeatedBytesField(value: [Data], fieldNumber: Int) throws { + assert(!value.isEmpty) + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitRepeatedEnumField(value: [E], fieldNumber: Int) throws { + assert(!value.isEmpty) + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitRepeatedMessageField(value: [M], fieldNumber: Int) throws { + assert(!value.isEmpty) + hasher.combine(fieldNumber) + for v in value { + v.hash(into: &hasher) + } + } + + mutating func visitRepeatedGroupField(value: [G], fieldNumber: Int) throws { + assert(!value.isEmpty) + hasher.combine(fieldNumber) + for v in value { + v.hash(into: &hasher) + } + } + + mutating func visitMapField( + fieldType: _ProtobufMap.Type, + value: _ProtobufMap.BaseType, + fieldNumber: Int + ) throws { + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitMapField( + fieldType: _ProtobufEnumMap.Type, + value: _ProtobufEnumMap.BaseType, + fieldNumber: Int + ) throws where ValueType.RawValue == Int { + hasher.combine(fieldNumber) + hasher.combine(value) + } + + mutating func visitMapField( + fieldType: _ProtobufMessageMap.Type, + value: _ProtobufMessageMap.BaseType, + fieldNumber: Int + ) throws { + hasher.combine(fieldNumber) + hasher.combine(value) } - mix(mapHash) - } -#endif // swift(>=4.2) - -#if swift(>=4.2) - init(_ hasher: Hasher) { - self.hasher = hasher - } -#else - init() {} -#endif - - mutating func visitUnknown(bytes: Data) throws { - #if swift(>=4.2) - hasher.combine(bytes) - #else - mix(bytes.hashValue) - #endif - } - - mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws { - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - mix(value.hashValue) - #endif - } - - mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws { - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - mix(value.hashValue) - #endif - } - - mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws { - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - mix(value.hashValue) - #endif - } - - mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws { - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - mix(value.hashValue) - #endif - } - - mutating func visitSingularStringField(value: String, fieldNumber: Int) throws { - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - mix(value.hashValue) - #endif - } - - mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws { - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - mix(value.hashValue) - #endif - } - - mutating func visitSingularEnumField(value: E, - fieldNumber: Int) { - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - mix(value.hashValue) - #endif - } - - mutating func visitSingularMessageField(value: M, fieldNumber: Int) { - #if swift(>=4.2) - hasher.combine(fieldNumber) - value.hash(into: &hasher) - #else - mix(fieldNumber) - mix(value.hashValue) - #endif - } - - mutating func visitRepeatedFloatField(value: [Float], fieldNumber: Int) throws { - assert(!value.isEmpty) - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - for v in value { - mix(v.hashValue) - } - #endif - } - - mutating func visitRepeatedDoubleField(value: [Double], fieldNumber: Int) throws { - assert(!value.isEmpty) - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - for v in value { - mix(v.hashValue) - } - #endif - } - - mutating func visitRepeatedInt32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - for v in value { - mix(v.hashValue) - } - #endif - } - - mutating func visitRepeatedInt64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - for v in value { - mix(v.hashValue) - } - #endif - } - - mutating func visitRepeatedUInt32Field(value: [UInt32], fieldNumber: Int) throws { - assert(!value.isEmpty) - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - for v in value { - mix(v.hashValue) - } - #endif - } - - mutating func visitRepeatedUInt64Field(value: [UInt64], fieldNumber: Int) throws { - assert(!value.isEmpty) - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - for v in value { - mix(v.hashValue) - } - #endif - } - - mutating func visitRepeatedSInt32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - for v in value { - mix(v.hashValue) - } - #endif - } - - mutating func visitRepeatedSInt64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - for v in value { - mix(v.hashValue) - } - #endif - } - - mutating func visitRepeatedFixed32Field(value: [UInt32], fieldNumber: Int) throws { - assert(!value.isEmpty) - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - for v in value { - mix(v.hashValue) - } - #endif - } - - mutating func visitRepeatedFixed64Field(value: [UInt64], fieldNumber: Int) throws { - assert(!value.isEmpty) - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - for v in value { - mix(v.hashValue) - } - #endif - } - - mutating func visitRepeatedSFixed32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - for v in value { - mix(v.hashValue) - } - #endif - } - - mutating func visitRepeatedSFixed64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - for v in value { - mix(v.hashValue) - } - #endif - } - - mutating func visitRepeatedBoolField(value: [Bool], fieldNumber: Int) throws { - assert(!value.isEmpty) - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - for v in value { - mix(v.hashValue) - } - #endif - } - - mutating func visitRepeatedStringField(value: [String], fieldNumber: Int) throws { - assert(!value.isEmpty) - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - for v in value { - mix(v.hashValue) - } - #endif - } - - mutating func visitRepeatedBytesField(value: [Data], fieldNumber: Int) throws { - assert(!value.isEmpty) - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - for v in value { - mix(v.hashValue) - } - #endif - } - - mutating func visitRepeatedEnumField(value: [E], fieldNumber: Int) throws { - assert(!value.isEmpty) - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - for v in value { - mix(v.hashValue) - } - #endif - } - - mutating func visitRepeatedMessageField(value: [M], fieldNumber: Int) throws { - assert(!value.isEmpty) - #if swift(>=4.2) - hasher.combine(fieldNumber) - for v in value { - v.hash(into: &hasher) - } - #else - mix(fieldNumber) - for v in value { - mix(v.hashValue) - } - #endif - } - - mutating func visitRepeatedGroupField(value: [G], fieldNumber: Int) throws { - assert(!value.isEmpty) - #if swift(>=4.2) - hasher.combine(fieldNumber) - for v in value { - v.hash(into: &hasher) - } - #else - mix(fieldNumber) - for v in value { - mix(v.hashValue) - } - #endif - } - - mutating func visitMapField( - fieldType: _ProtobufMap.Type, - value: _ProtobufMap.BaseType, - fieldNumber: Int - ) throws { - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - mixMap(map: value) - #endif - } - - mutating func visitMapField( - fieldType: _ProtobufEnumMap.Type, - value: _ProtobufEnumMap.BaseType, - fieldNumber: Int - ) throws where ValueType.RawValue == Int { - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - mixMap(map: value) - #endif - } - - mutating func visitMapField( - fieldType: _ProtobufMessageMap.Type, - value: _ProtobufMessageMap.BaseType, - fieldNumber: Int - ) throws { - #if swift(>=4.2) - hasher.combine(fieldNumber) - hasher.combine(value) - #else - mix(fieldNumber) - mixMap(map: value) - #endif - } } diff --git a/Sources/SwiftProtobuf/Internal.swift b/Sources/SwiftProtobuf/Internal.swift index 8619bbd9b..959a74193 100644 --- a/Sources/SwiftProtobuf/Internal.swift +++ b/Sources/SwiftProtobuf/Internal.swift @@ -16,36 +16,45 @@ import Foundation -/// Functions that are public only because they are used by generated message -/// implementations. NOT INTENDED TO BE CALLED BY CLIENTS. +/// Functions that are public only because they are used by generated message implementations. +/// - Important: NOT INTENDED TO BE CALLED BY CLIENTS. public enum Internal { - /// A singleton instance of an empty data that is used by the generated code - /// for default values. This is a performance enhancement to work around the - /// fact that the `Data` type in Swift involves a new heap allocation every - /// time an empty instance is initialized, instead of sharing a common empty - /// backing storage. - public static let emptyData = Data() + #if !REMOVE_DEPRECATED_APIS + /// A singleton instance of an empty data that is used by the generated code + /// for default values. This is a performance enhancement to work around the + /// fact that the `Data` type in Swift involves a new heap allocation every + /// time an empty instance is initialized, instead of sharing a common empty + /// backing storage. + /// - Note: This isn't really used any longer - it's only here to support code generated by 1.10.2 and earlier. + @available( + *, + deprecated, + message: + "Internal.emptyData isn't used any longer in newer versions of the generator. Generate code with a version later than 1.10.2 to get performance improvements. See https://github.com/apple/swift-protobuf/pull/1028 for more information." + ) + public static let emptyData = Data() + #endif // !REMOVE_DEPRECATED_APIS - /// Helper to loop over a list of Messages to see if they are all - /// initialized (see Message.isInitialized for what that means). - public static func areAllInitialized(_ listOfMessages: [Message]) -> Bool { - for msg in listOfMessages { - if !msg.isInitialized { - return false - } + /// Helper to loop over a list of Messages to see if they are all + /// initialized (see Message.isInitialized for what that means). + public static func areAllInitialized(_ listOfMessages: [any Message]) -> Bool { + for msg in listOfMessages { + if !msg.isInitialized { + return false + } + } + return true } - return true - } - /// Helper to loop over dictionary with values that are Messages to see if - /// they are all initialized (see Message.isInitialized for what that means). - public static func areAllInitialized(_ mapToMessages: [K: Message]) -> Bool { - for (_, msg) in mapToMessages { - if !msg.isInitialized { - return false - } + /// Helper to loop over dictionary with values that are Messages to see if + /// they are all initialized (see Message.isInitialized for what that means). + public static func areAllInitialized(_ mapToMessages: [K: any Message]) -> Bool { + for (_, msg) in mapToMessages { + if !msg.isInitialized { + return false + } + } + return true } - return true - } } diff --git a/Sources/SwiftProtobuf/JSONDecoder.swift b/Sources/SwiftProtobuf/JSONDecoder.swift index 5f085e451..d8fd4e0a8 100644 --- a/Sources/SwiftProtobuf/JSONDecoder.swift +++ b/Sources/SwiftProtobuf/JSONDecoder.swift @@ -15,721 +15,742 @@ import Foundation internal struct JSONDecoder: Decoder { - internal var scanner: JSONScanner - internal var messageType: Message.Type - private var fieldCount = 0 - private var isMapKey = false - private var fieldNameMap: _NameMap? - - internal var options: JSONDecodingOptions { - return scanner.options - } - - mutating func handleConflictingOneOf() throws { - throw JSONDecodingError.conflictingOneOf - } - - internal init(source: UnsafeRawBufferPointer, options: JSONDecodingOptions, - messageType: Message.Type, extensions: ExtensionMap?) { - let scanner = JSONScanner(source: source, - options: options, - extensions: extensions) - self.init(scanner: scanner, messageType: messageType) - } - - private init(scanner: JSONScanner, messageType: Message.Type) { - self.scanner = scanner - self.messageType = messageType - } - - mutating func nextFieldNumber() throws -> Int? { - if scanner.skipOptionalObjectEnd() { - return nil - } - if fieldCount > 0 { - try scanner.skipRequiredComma() - } - let fieldNumber = try scanner.nextFieldNumber(names: fieldNameMap!, - messageType: messageType) - if let fieldNumber = fieldNumber { - fieldCount += 1 - return fieldNumber - } - return nil - } - - mutating func decodeSingularFloatField(value: inout Float) throws { - if scanner.skipOptionalNull() { - value = 0 - return - } - value = try scanner.nextFloat() - } - - mutating func decodeSingularFloatField(value: inout Float?) throws { - if scanner.skipOptionalNull() { - value = nil - return - } - value = try scanner.nextFloat() - } - - mutating func decodeRepeatedFloatField(value: inout [Float]) throws { - if scanner.skipOptionalNull() { - return - } - try scanner.skipRequiredArrayStart() - if scanner.skipOptionalArrayEnd() { - return - } - while true { - let n = try scanner.nextFloat() - value.append(n) - if scanner.skipOptionalArrayEnd() { - return - } - try scanner.skipRequiredComma() - } - } - - mutating func decodeSingularDoubleField(value: inout Double) throws { - if scanner.skipOptionalNull() { - value = 0 - return - } - value = try scanner.nextDouble() - } - - mutating func decodeSingularDoubleField(value: inout Double?) throws { - if scanner.skipOptionalNull() { - value = nil - return - } - value = try scanner.nextDouble() - } - - mutating func decodeRepeatedDoubleField(value: inout [Double]) throws { - if scanner.skipOptionalNull() { - return - } - try scanner.skipRequiredArrayStart() - if scanner.skipOptionalArrayEnd() { - return - } - while true { - let n = try scanner.nextDouble() - value.append(n) - if scanner.skipOptionalArrayEnd() { - return - } - try scanner.skipRequiredComma() - } - } - - mutating func decodeSingularInt32Field(value: inout Int32) throws { - if scanner.skipOptionalNull() { - value = 0 - return - } - let n = try scanner.nextSInt() - if n > Int64(Int32.max) || n < Int64(Int32.min) { - throw JSONDecodingError.numberRange - } - value = Int32(truncatingIfNeeded: n) - } - - mutating func decodeSingularInt32Field(value: inout Int32?) throws { - if scanner.skipOptionalNull() { - value = nil - return - } - let n = try scanner.nextSInt() - if n > Int64(Int32.max) || n < Int64(Int32.min) { - throw JSONDecodingError.numberRange - } - value = Int32(truncatingIfNeeded: n) - } - - mutating func decodeRepeatedInt32Field(value: inout [Int32]) throws { - if scanner.skipOptionalNull() { - return - } - try scanner.skipRequiredArrayStart() - if scanner.skipOptionalArrayEnd() { - return - } - while true { - let n = try scanner.nextSInt() - if n > Int64(Int32.max) || n < Int64(Int32.min) { - throw JSONDecodingError.numberRange - } - value.append(Int32(truncatingIfNeeded: n)) - if scanner.skipOptionalArrayEnd() { - return - } - try scanner.skipRequiredComma() - } - } - - mutating func decodeSingularInt64Field(value: inout Int64) throws { - if scanner.skipOptionalNull() { - value = 0 - return - } - value = try scanner.nextSInt() - } - - mutating func decodeSingularInt64Field(value: inout Int64?) throws { - if scanner.skipOptionalNull() { - value = nil - return - } - value = try scanner.nextSInt() - } - - mutating func decodeRepeatedInt64Field(value: inout [Int64]) throws { - if scanner.skipOptionalNull() { - return - } - try scanner.skipRequiredArrayStart() - if scanner.skipOptionalArrayEnd() { - return - } - while true { - let n = try scanner.nextSInt() - value.append(n) - if scanner.skipOptionalArrayEnd() { - return - } - try scanner.skipRequiredComma() - } - } - - mutating func decodeSingularUInt32Field(value: inout UInt32) throws { - if scanner.skipOptionalNull() { - value = 0 - return - } - let n = try scanner.nextUInt() - if n > UInt64(UInt32.max) { - throw JSONDecodingError.numberRange - } - value = UInt32(truncatingIfNeeded: n) - } - - mutating func decodeSingularUInt32Field(value: inout UInt32?) throws { - if scanner.skipOptionalNull() { - value = nil - return - } - let n = try scanner.nextUInt() - if n > UInt64(UInt32.max) { - throw JSONDecodingError.numberRange - } - value = UInt32(truncatingIfNeeded: n) - } - - mutating func decodeRepeatedUInt32Field(value: inout [UInt32]) throws { - if scanner.skipOptionalNull() { - return - } - try scanner.skipRequiredArrayStart() - if scanner.skipOptionalArrayEnd() { - return - } - while true { - let n = try scanner.nextUInt() - if n > UInt64(UInt32.max) { - throw JSONDecodingError.numberRange - } - value.append(UInt32(truncatingIfNeeded: n)) - if scanner.skipOptionalArrayEnd() { - return - } - try scanner.skipRequiredComma() - } - } - - mutating func decodeSingularUInt64Field(value: inout UInt64) throws { - if scanner.skipOptionalNull() { - value = 0 - return - } - value = try scanner.nextUInt() - } - - mutating func decodeSingularUInt64Field(value: inout UInt64?) throws { - if scanner.skipOptionalNull() { - value = nil - return - } - value = try scanner.nextUInt() - } - - mutating func decodeRepeatedUInt64Field(value: inout [UInt64]) throws { - if scanner.skipOptionalNull() { - return - } - try scanner.skipRequiredArrayStart() - if scanner.skipOptionalArrayEnd() { - return - } - while true { - let n = try scanner.nextUInt() - value.append(n) - if scanner.skipOptionalArrayEnd() { - return - } - try scanner.skipRequiredComma() - } - } - - mutating func decodeSingularSInt32Field(value: inout Int32) throws { - try decodeSingularInt32Field(value: &value) - } - - mutating func decodeSingularSInt32Field(value: inout Int32?) throws { - try decodeSingularInt32Field(value: &value) - } - - mutating func decodeRepeatedSInt32Field(value: inout [Int32]) throws { - try decodeRepeatedInt32Field(value: &value) - } - - mutating func decodeSingularSInt64Field(value: inout Int64) throws { - try decodeSingularInt64Field(value: &value) - } - - mutating func decodeSingularSInt64Field(value: inout Int64?) throws { - try decodeSingularInt64Field(value: &value) - } - - mutating func decodeRepeatedSInt64Field(value: inout [Int64]) throws { - try decodeRepeatedInt64Field(value: &value) - } - - mutating func decodeSingularFixed32Field(value: inout UInt32) throws { - try decodeSingularUInt32Field(value: &value) - } - - mutating func decodeSingularFixed32Field(value: inout UInt32?) throws { - try decodeSingularUInt32Field(value: &value) - } - - mutating func decodeRepeatedFixed32Field(value: inout [UInt32]) throws { - try decodeRepeatedUInt32Field(value: &value) - } - - mutating func decodeSingularFixed64Field(value: inout UInt64) throws { - try decodeSingularUInt64Field(value: &value) - } - - mutating func decodeSingularFixed64Field(value: inout UInt64?) throws { - try decodeSingularUInt64Field(value: &value) - } - - mutating func decodeRepeatedFixed64Field(value: inout [UInt64]) throws { - try decodeRepeatedUInt64Field(value: &value) - } - - mutating func decodeSingularSFixed32Field(value: inout Int32) throws { - try decodeSingularInt32Field(value: &value) - } - - mutating func decodeSingularSFixed32Field(value: inout Int32?) throws { - try decodeSingularInt32Field(value: &value) - } - - mutating func decodeRepeatedSFixed32Field(value: inout [Int32]) throws { - try decodeRepeatedInt32Field(value: &value) - } - - mutating func decodeSingularSFixed64Field(value: inout Int64) throws { - try decodeSingularInt64Field(value: &value) - } + internal var scanner: JSONScanner + internal var messageType: any Message.Type + private var fieldCount = 0 + private var isMapKey = false + private var fieldNameMap: _NameMap? - mutating func decodeSingularSFixed64Field(value: inout Int64?) throws { - try decodeSingularInt64Field(value: &value) - } - - mutating func decodeRepeatedSFixed64Field(value: inout [Int64]) throws { - try decodeRepeatedInt64Field(value: &value) - } - - mutating func decodeSingularBoolField(value: inout Bool) throws { - if scanner.skipOptionalNull() { - value = false - return - } - if isMapKey { - value = try scanner.nextQuotedBool() - } else { - value = try scanner.nextBool() - } - } - - mutating func decodeSingularBoolField(value: inout Bool?) throws { - if scanner.skipOptionalNull() { - value = nil - return - } - if isMapKey { - value = try scanner.nextQuotedBool() - } else { - value = try scanner.nextBool() - } - } - - mutating func decodeRepeatedBoolField(value: inout [Bool]) throws { - if scanner.skipOptionalNull() { - return - } - try scanner.skipRequiredArrayStart() - if scanner.skipOptionalArrayEnd() { - return - } - while true { - let n = try scanner.nextBool() - value.append(n) - if scanner.skipOptionalArrayEnd() { - return - } - try scanner.skipRequiredComma() - } - } - - mutating func decodeSingularStringField(value: inout String) throws { - if scanner.skipOptionalNull() { - value = String() - return - } - value = try scanner.nextQuotedString() - } - - mutating func decodeSingularStringField(value: inout String?) throws { - if scanner.skipOptionalNull() { - value = nil - return - } - value = try scanner.nextQuotedString() - } - - mutating func decodeRepeatedStringField(value: inout [String]) throws { - if scanner.skipOptionalNull() { - return - } - try scanner.skipRequiredArrayStart() - if scanner.skipOptionalArrayEnd() { - return - } - while true { - let n = try scanner.nextQuotedString() - value.append(n) - if scanner.skipOptionalArrayEnd() { - return - } - try scanner.skipRequiredComma() - } - } - - mutating func decodeSingularBytesField(value: inout Data) throws { - if scanner.skipOptionalNull() { - value = Data() - return - } - value = try scanner.nextBytesValue() - } - - mutating func decodeSingularBytesField(value: inout Data?) throws { - if scanner.skipOptionalNull() { - value = nil - return - } - value = try scanner.nextBytesValue() - } - - mutating func decodeRepeatedBytesField(value: inout [Data]) throws { - if scanner.skipOptionalNull() { - return - } - try scanner.skipRequiredArrayStart() - if scanner.skipOptionalArrayEnd() { - return - } - while true { - let n = try scanner.nextBytesValue() - value.append(n) - if scanner.skipOptionalArrayEnd() { - return - } - try scanner.skipRequiredComma() - } - } - - mutating func decodeSingularEnumField(value: inout E?) throws - where E.RawValue == Int { - if scanner.skipOptionalNull() { - if let customDecodable = E.self as? _CustomJSONCodable.Type { - value = try customDecodable.decodedFromJSONNull() as? E - return - } - value = nil - return - } - value = try scanner.nextEnumValue() as E - } - - mutating func decodeSingularEnumField(value: inout E) throws - where E.RawValue == Int { - if scanner.skipOptionalNull() { - if let customDecodable = E.self as? _CustomJSONCodable.Type { - value = try customDecodable.decodedFromJSONNull() as! E - return - } - value = E() - return - } - value = try scanner.nextEnumValue() - } - - mutating func decodeRepeatedEnumField(value: inout [E]) throws - where E.RawValue == Int { - if scanner.skipOptionalNull() { - return - } - try scanner.skipRequiredArrayStart() - if scanner.skipOptionalArrayEnd() { - return - } - let maybeCustomDecodable = E.self as? _CustomJSONCodable.Type - while true { - if scanner.skipOptionalNull() { - if let customDecodable = maybeCustomDecodable { - let e = try customDecodable.decodedFromJSONNull() as! E - value.append(e) + internal var options: JSONDecodingOptions { + scanner.options + } + + mutating func handleConflictingOneOf() throws { + throw JSONDecodingError.conflictingOneOf + } + + internal init( + source: UnsafeRawBufferPointer, + options: JSONDecodingOptions, + messageType: any Message.Type, + extensions: (any ExtensionMap)? + ) { + let scanner = JSONScanner( + source: source, + options: options, + extensions: extensions + ) + self.init(scanner: scanner, messageType: messageType) + } + + private init(scanner: JSONScanner, messageType: any Message.Type) { + self.scanner = scanner + self.messageType = messageType + } + + mutating func nextFieldNumber() throws -> Int? { + if scanner.skipOptionalObjectEnd() { + return nil + } + if fieldCount > 0 { + try scanner.skipRequiredComma() + } + let fieldNumber = try scanner.nextFieldNumber( + names: fieldNameMap!, + messageType: messageType + ) + if let fieldNumber = fieldNumber { + fieldCount += 1 + return fieldNumber + } + return nil + } + + mutating func decodeSingularFloatField(value: inout Float) throws { + if scanner.skipOptionalNull() { + value = 0 + return + } + value = try scanner.nextFloat() + } + + mutating func decodeSingularFloatField(value: inout Float?) throws { + if scanner.skipOptionalNull() { + value = nil + return + } + value = try scanner.nextFloat() + } + + mutating func decodeRepeatedFloatField(value: inout [Float]) throws { + if scanner.skipOptionalNull() { + return + } + try scanner.skipRequiredArrayStart() + if scanner.skipOptionalArrayEnd() { + return + } + while true { + let n = try scanner.nextFloat() + value.append(n) + if scanner.skipOptionalArrayEnd() { + return + } + try scanner.skipRequiredComma() + } + } + + mutating func decodeSingularDoubleField(value: inout Double) throws { + if scanner.skipOptionalNull() { + value = 0 + return + } + value = try scanner.nextDouble() + } + + mutating func decodeSingularDoubleField(value: inout Double?) throws { + if scanner.skipOptionalNull() { + value = nil + return + } + value = try scanner.nextDouble() + } + + mutating func decodeRepeatedDoubleField(value: inout [Double]) throws { + if scanner.skipOptionalNull() { + return + } + try scanner.skipRequiredArrayStart() + if scanner.skipOptionalArrayEnd() { + return + } + while true { + let n = try scanner.nextDouble() + value.append(n) + if scanner.skipOptionalArrayEnd() { + return + } + try scanner.skipRequiredComma() + } + } + + mutating func decodeSingularInt32Field(value: inout Int32) throws { + if scanner.skipOptionalNull() { + value = 0 + return + } + let n = try scanner.nextSInt() + if n > Int64(Int32.max) || n < Int64(Int32.min) { + throw JSONDecodingError.numberRange + } + value = Int32(truncatingIfNeeded: n) + } + + mutating func decodeSingularInt32Field(value: inout Int32?) throws { + if scanner.skipOptionalNull() { + value = nil + return + } + let n = try scanner.nextSInt() + if n > Int64(Int32.max) || n < Int64(Int32.min) { + throw JSONDecodingError.numberRange + } + value = Int32(truncatingIfNeeded: n) + } + + mutating func decodeRepeatedInt32Field(value: inout [Int32]) throws { + if scanner.skipOptionalNull() { + return + } + try scanner.skipRequiredArrayStart() + if scanner.skipOptionalArrayEnd() { + return + } + while true { + let n = try scanner.nextSInt() + if n > Int64(Int32.max) || n < Int64(Int32.min) { + throw JSONDecodingError.numberRange + } + value.append(Int32(truncatingIfNeeded: n)) + if scanner.skipOptionalArrayEnd() { + return + } + try scanner.skipRequiredComma() + } + } + + mutating func decodeSingularInt64Field(value: inout Int64) throws { + if scanner.skipOptionalNull() { + value = 0 + return + } + value = try scanner.nextSInt() + } + + mutating func decodeSingularInt64Field(value: inout Int64?) throws { + if scanner.skipOptionalNull() { + value = nil + return + } + value = try scanner.nextSInt() + } + + mutating func decodeRepeatedInt64Field(value: inout [Int64]) throws { + if scanner.skipOptionalNull() { + return + } + try scanner.skipRequiredArrayStart() + if scanner.skipOptionalArrayEnd() { + return + } + while true { + let n = try scanner.nextSInt() + value.append(n) + if scanner.skipOptionalArrayEnd() { + return + } + try scanner.skipRequiredComma() + } + } + + mutating func decodeSingularUInt32Field(value: inout UInt32) throws { + if scanner.skipOptionalNull() { + value = 0 + return + } + let n = try scanner.nextUInt() + if n > UInt64(UInt32.max) { + throw JSONDecodingError.numberRange + } + value = UInt32(truncatingIfNeeded: n) + } + + mutating func decodeSingularUInt32Field(value: inout UInt32?) throws { + if scanner.skipOptionalNull() { + value = nil + return + } + let n = try scanner.nextUInt() + if n > UInt64(UInt32.max) { + throw JSONDecodingError.numberRange + } + value = UInt32(truncatingIfNeeded: n) + } + + mutating func decodeRepeatedUInt32Field(value: inout [UInt32]) throws { + if scanner.skipOptionalNull() { + return + } + try scanner.skipRequiredArrayStart() + if scanner.skipOptionalArrayEnd() { + return + } + while true { + let n = try scanner.nextUInt() + if n > UInt64(UInt32.max) { + throw JSONDecodingError.numberRange + } + value.append(UInt32(truncatingIfNeeded: n)) + if scanner.skipOptionalArrayEnd() { + return + } + try scanner.skipRequiredComma() + } + } + + mutating func decodeSingularUInt64Field(value: inout UInt64) throws { + if scanner.skipOptionalNull() { + value = 0 + return + } + value = try scanner.nextUInt() + } + + mutating func decodeSingularUInt64Field(value: inout UInt64?) throws { + if scanner.skipOptionalNull() { + value = nil + return + } + value = try scanner.nextUInt() + } + + mutating func decodeRepeatedUInt64Field(value: inout [UInt64]) throws { + if scanner.skipOptionalNull() { + return + } + try scanner.skipRequiredArrayStart() + if scanner.skipOptionalArrayEnd() { + return + } + while true { + let n = try scanner.nextUInt() + value.append(n) + if scanner.skipOptionalArrayEnd() { + return + } + try scanner.skipRequiredComma() + } + } + + mutating func decodeSingularSInt32Field(value: inout Int32) throws { + try decodeSingularInt32Field(value: &value) + } + + mutating func decodeSingularSInt32Field(value: inout Int32?) throws { + try decodeSingularInt32Field(value: &value) + } + + mutating func decodeRepeatedSInt32Field(value: inout [Int32]) throws { + try decodeRepeatedInt32Field(value: &value) + } + + mutating func decodeSingularSInt64Field(value: inout Int64) throws { + try decodeSingularInt64Field(value: &value) + } + + mutating func decodeSingularSInt64Field(value: inout Int64?) throws { + try decodeSingularInt64Field(value: &value) + } + + mutating func decodeRepeatedSInt64Field(value: inout [Int64]) throws { + try decodeRepeatedInt64Field(value: &value) + } + + mutating func decodeSingularFixed32Field(value: inout UInt32) throws { + try decodeSingularUInt32Field(value: &value) + } + + mutating func decodeSingularFixed32Field(value: inout UInt32?) throws { + try decodeSingularUInt32Field(value: &value) + } + + mutating func decodeRepeatedFixed32Field(value: inout [UInt32]) throws { + try decodeRepeatedUInt32Field(value: &value) + } + + mutating func decodeSingularFixed64Field(value: inout UInt64) throws { + try decodeSingularUInt64Field(value: &value) + } + + mutating func decodeSingularFixed64Field(value: inout UInt64?) throws { + try decodeSingularUInt64Field(value: &value) + } + + mutating func decodeRepeatedFixed64Field(value: inout [UInt64]) throws { + try decodeRepeatedUInt64Field(value: &value) + } + + mutating func decodeSingularSFixed32Field(value: inout Int32) throws { + try decodeSingularInt32Field(value: &value) + } + + mutating func decodeSingularSFixed32Field(value: inout Int32?) throws { + try decodeSingularInt32Field(value: &value) + } + + mutating func decodeRepeatedSFixed32Field(value: inout [Int32]) throws { + try decodeRepeatedInt32Field(value: &value) + } + + mutating func decodeSingularSFixed64Field(value: inout Int64) throws { + try decodeSingularInt64Field(value: &value) + } + + mutating func decodeSingularSFixed64Field(value: inout Int64?) throws { + try decodeSingularInt64Field(value: &value) + } + + mutating func decodeRepeatedSFixed64Field(value: inout [Int64]) throws { + try decodeRepeatedInt64Field(value: &value) + } + + mutating func decodeSingularBoolField(value: inout Bool) throws { + if scanner.skipOptionalNull() { + value = false + return + } + if isMapKey { + value = try scanner.nextQuotedBool() + } else { + value = try scanner.nextBool() + } + } + + mutating func decodeSingularBoolField(value: inout Bool?) throws { + if scanner.skipOptionalNull() { + value = nil + return + } + if isMapKey { + value = try scanner.nextQuotedBool() + } else { + value = try scanner.nextBool() + } + } + + mutating func decodeRepeatedBoolField(value: inout [Bool]) throws { + if scanner.skipOptionalNull() { + return + } + try scanner.skipRequiredArrayStart() + if scanner.skipOptionalArrayEnd() { + return + } + while true { + let n = try scanner.nextBool() + value.append(n) + if scanner.skipOptionalArrayEnd() { + return + } + try scanner.skipRequiredComma() + } + } + + mutating func decodeSingularStringField(value: inout String) throws { + if scanner.skipOptionalNull() { + value = String() + return + } + value = try scanner.nextQuotedString() + } + + mutating func decodeSingularStringField(value: inout String?) throws { + if scanner.skipOptionalNull() { + value = nil + return + } + value = try scanner.nextQuotedString() + } + + mutating func decodeRepeatedStringField(value: inout [String]) throws { + if scanner.skipOptionalNull() { + return + } + try scanner.skipRequiredArrayStart() + if scanner.skipOptionalArrayEnd() { + return + } + while true { + let n = try scanner.nextQuotedString() + value.append(n) + if scanner.skipOptionalArrayEnd() { + return + } + try scanner.skipRequiredComma() + } + } + + mutating func decodeSingularBytesField(value: inout Data) throws { + if scanner.skipOptionalNull() { + value = Data() + return + } + value = try scanner.nextBytesValue() + } + + mutating func decodeSingularBytesField(value: inout Data?) throws { + if scanner.skipOptionalNull() { + value = nil + return + } + value = try scanner.nextBytesValue() + } + + mutating func decodeRepeatedBytesField(value: inout [Data]) throws { + if scanner.skipOptionalNull() { + return + } + try scanner.skipRequiredArrayStart() + if scanner.skipOptionalArrayEnd() { + return + } + while true { + let n = try scanner.nextBytesValue() + value.append(n) + if scanner.skipOptionalArrayEnd() { + return + } + try scanner.skipRequiredComma() + } + } + + mutating func decodeSingularEnumField(value: inout E?) throws + where E.RawValue == Int { + if scanner.skipOptionalNull() { + if let customDecodable = E.self as? any _CustomJSONCodable.Type { + value = try customDecodable.decodedFromJSONNull() as? E + return + } + value = nil + return + } + // Only change the value if a value was read. + if let e: E = try scanner.nextEnumValue() { + value = e + } + } + + mutating func decodeSingularEnumField(value: inout E) throws + where E.RawValue == Int { + if scanner.skipOptionalNull() { + if let customDecodable = E.self as? any _CustomJSONCodable.Type { + value = try customDecodable.decodedFromJSONNull() as! E + return + } + value = E() + return + } + if let e: E = try scanner.nextEnumValue() { + value = e + } + + } + + mutating func decodeRepeatedEnumField(value: inout [E]) throws + where E.RawValue == Int { + if scanner.skipOptionalNull() { + return + } + try scanner.skipRequiredArrayStart() + if scanner.skipOptionalArrayEnd() { + return + } + let maybeCustomDecodable = E.self as? any _CustomJSONCodable.Type + while true { + if scanner.skipOptionalNull() { + if let customDecodable = maybeCustomDecodable { + let e = try customDecodable.decodedFromJSONNull() as! E + value.append(e) + } else { + throw JSONDecodingError.illegalNull + } + } else { + if let e: E = try scanner.nextEnumValue() { + value.append(e) + } + } + if scanner.skipOptionalArrayEnd() { + return + } + try scanner.skipRequiredComma() + } + } + + internal mutating func decodeFullObject(message: inout M) throws { + guard let nameProviding = (M.self as? any _ProtoNameProviding.Type) else { + throw JSONDecodingError.missingFieldNames + } + fieldNameMap = nameProviding._protobuf_nameMap + if let m = message as? (any _CustomJSONCodable) { + var customCodable = m + try customCodable.decodeJSON(from: &self) + message = customCodable as! M } else { - throw JSONDecodingError.illegalNull - } - } else { - let e: E = try scanner.nextEnumValue() - value.append(e) - } - if scanner.skipOptionalArrayEnd() { - return - } - try scanner.skipRequiredComma() - } - } - - internal mutating func decodeFullObject(message: inout M) throws { - guard let nameProviding = (M.self as? _ProtoNameProviding.Type) else { - throw JSONDecodingError.missingFieldNames - } - fieldNameMap = nameProviding._protobuf_nameMap - if let m = message as? _CustomJSONCodable { - var customCodable = m - try customCodable.decodeJSON(from: &self) - message = customCodable as! M - } else { - try scanner.skipRequiredObjectStart() - if scanner.skipOptionalObjectEnd() { - return - } - try message.decodeMessage(decoder: &self) - } - } - - mutating func decodeSingularMessageField(value: inout M?) throws { - if scanner.skipOptionalNull() { - if M.self is _CustomJSONCodable.Type { - value = - try (M.self as! _CustomJSONCodable.Type).decodedFromJSONNull() as? M - return - } - // All other message field types treat 'null' as an unset - value = nil - return - } - if value == nil { - value = M() - } - var subDecoder = JSONDecoder(scanner: scanner, messageType: M.self) - try subDecoder.decodeFullObject(message: &value!) - assert(scanner.recursionBudget == subDecoder.scanner.recursionBudget) - scanner = subDecoder.scanner - } - - mutating func decodeRepeatedMessageField( - value: inout [M] - ) throws { - if scanner.skipOptionalNull() { - return - } - try scanner.skipRequiredArrayStart() - if scanner.skipOptionalArrayEnd() { - return - } - while true { - if scanner.skipOptionalNull() { - var appended = false - if M.self is _CustomJSONCodable.Type { - if let message = try (M.self as! _CustomJSONCodable.Type) - .decodedFromJSONNull() as? M { - value.append(message) - appended = true - } - } - if !appended { - throw JSONDecodingError.illegalNull - } - } else { - var message = M() + try scanner.skipRequiredObjectStart() + if scanner.skipOptionalObjectEnd() { + return + } + try message.decodeMessage(decoder: &self) + } + } + + mutating func decodeSingularMessageField(value: inout M?) throws { + if scanner.skipOptionalNull() { + if M.self is any _CustomJSONCodable.Type { + value = + try (M.self as! any _CustomJSONCodable.Type).decodedFromJSONNull() as? M + return + } + // All other message field types treat 'null' as an unset + value = nil + return + } + if value == nil { + value = M() + } var subDecoder = JSONDecoder(scanner: scanner, messageType: M.self) - try subDecoder.decodeFullObject(message: &message) - value.append(message) + try subDecoder.decodeFullObject(message: &value!) assert(scanner.recursionBudget == subDecoder.scanner.recursionBudget) scanner = subDecoder.scanner - } - if scanner.skipOptionalArrayEnd() { - return - } - try scanner.skipRequiredComma() - } - } - - mutating func decodeSingularGroupField(value: inout G?) throws { - throw JSONDecodingError.schemaMismatch - } - - mutating func decodeRepeatedGroupField(value: inout [G]) throws { - throw JSONDecodingError.schemaMismatch - } - - mutating func decodeMapField( - fieldType: _ProtobufMap.Type, - value: inout _ProtobufMap.BaseType - ) throws { - if scanner.skipOptionalNull() { - return - } - try scanner.skipRequiredObjectStart() - if scanner.skipOptionalObjectEnd() { - return - } - while true { - // Next character must be double quote, because - // map keys must always be quoted strings. - let c = try scanner.peekOneCharacter() - if c != "\"" { - throw JSONDecodingError.unquotedMapKey - } - isMapKey = true - var keyField: KeyType.BaseType? - try KeyType.decodeSingular(value: &keyField, from: &self) - isMapKey = false - try scanner.skipRequiredColon() - var valueField: ValueType.BaseType? - try ValueType.decodeSingular(value: &valueField, from: &self) - if let keyField = keyField, let valueField = valueField { - value[keyField] = valueField - } else { - throw JSONDecodingError.malformedMap - } - if scanner.skipOptionalObjectEnd() { - return - } - try scanner.skipRequiredComma() - } - } - - mutating func decodeMapField( - fieldType: _ProtobufEnumMap.Type, - value: inout _ProtobufEnumMap.BaseType - ) throws where ValueType.RawValue == Int { - if scanner.skipOptionalNull() { - return - } - try scanner.skipRequiredObjectStart() - if scanner.skipOptionalObjectEnd() { - return - } - while true { - // Next character must be double quote, because - // map keys must always be quoted strings. - let c = try scanner.peekOneCharacter() - if c != "\"" { - throw JSONDecodingError.unquotedMapKey - } - isMapKey = true - var keyField: KeyType.BaseType? - try KeyType.decodeSingular(value: &keyField, from: &self) - isMapKey = false - try scanner.skipRequiredColon() - var valueField: ValueType? - try decodeSingularEnumField(value: &valueField) - if let keyField = keyField, let valueField = valueField { - value[keyField] = valueField - } else { - throw JSONDecodingError.malformedMap - } - if scanner.skipOptionalObjectEnd() { - return - } - try scanner.skipRequiredComma() - } - } - - mutating func decodeMapField( - fieldType: _ProtobufMessageMap.Type, - value: inout _ProtobufMessageMap.BaseType - ) throws { - if scanner.skipOptionalNull() { - return - } - try scanner.skipRequiredObjectStart() - if scanner.skipOptionalObjectEnd() { - return - } - while true { - // Next character must be double quote, because - // map keys must always be quoted strings. - let c = try scanner.peekOneCharacter() - if c != "\"" { - throw JSONDecodingError.unquotedMapKey - } - isMapKey = true - var keyField: KeyType.BaseType? - try KeyType.decodeSingular(value: &keyField, from: &self) - isMapKey = false - try scanner.skipRequiredColon() - var valueField: ValueType? - try decodeSingularMessageField(value: &valueField) - if let keyField = keyField, let valueField = valueField { - value[keyField] = valueField - } else { - throw JSONDecodingError.malformedMap - } - if scanner.skipOptionalObjectEnd() { - return - } - try scanner.skipRequiredComma() - } - } - - mutating func decodeExtensionField( - values: inout ExtensionFieldValueSet, - messageType: Message.Type, - fieldNumber: Int - ) throws { - // Force-unwrap: we can only get here if the extension exists. - let ext = scanner.extensions[messageType, fieldNumber]! - - try values.modify(index: fieldNumber) { fieldValue in - if fieldValue != nil { - try fieldValue!.decodeExtensionField(decoder: &self) - } else { - fieldValue = try ext._protobuf_newField(decoder: &self) - } - } - } + } + + mutating func decodeRepeatedMessageField( + value: inout [M] + ) throws { + if scanner.skipOptionalNull() { + return + } + try scanner.skipRequiredArrayStart() + if scanner.skipOptionalArrayEnd() { + return + } + while true { + if scanner.skipOptionalNull() { + var appended = false + if M.self is any _CustomJSONCodable.Type { + if let message = try (M.self as! any _CustomJSONCodable.Type) + .decodedFromJSONNull() as? M + { + value.append(message) + appended = true + } + } + if !appended { + throw JSONDecodingError.illegalNull + } + } else { + var message = M() + var subDecoder = JSONDecoder(scanner: scanner, messageType: M.self) + try subDecoder.decodeFullObject(message: &message) + value.append(message) + assert(scanner.recursionBudget == subDecoder.scanner.recursionBudget) + scanner = subDecoder.scanner + } + if scanner.skipOptionalArrayEnd() { + return + } + try scanner.skipRequiredComma() + } + } + + mutating func decodeSingularGroupField(value: inout G?) throws { + try decodeSingularMessageField(value: &value) + } + + mutating func decodeRepeatedGroupField(value: inout [G]) throws { + try decodeRepeatedMessageField(value: &value) + } + + mutating func decodeMapField( + fieldType: _ProtobufMap.Type, + value: inout _ProtobufMap.BaseType + ) throws { + if scanner.skipOptionalNull() { + return + } + try scanner.skipRequiredObjectStart() + if scanner.skipOptionalObjectEnd() { + return + } + while true { + // Next character must be double quote, because + // map keys must always be quoted strings. + let c = try scanner.peekOneCharacter() + if c != "\"" { + throw JSONDecodingError.unquotedMapKey + } + isMapKey = true + var keyField: KeyType.BaseType? + try KeyType.decodeSingular(value: &keyField, from: &self) + isMapKey = false + try scanner.skipRequiredColon() + var valueField: ValueType.BaseType? + try ValueType.decodeSingular(value: &valueField, from: &self) + if let keyField = keyField, let valueField = valueField { + value[keyField] = valueField + } else { + throw JSONDecodingError.malformedMap + } + if scanner.skipOptionalObjectEnd() { + return + } + try scanner.skipRequiredComma() + } + } + + mutating func decodeMapField( + fieldType: _ProtobufEnumMap.Type, + value: inout _ProtobufEnumMap.BaseType + ) throws where ValueType.RawValue == Int { + if scanner.skipOptionalNull() { + return + } + try scanner.skipRequiredObjectStart() + if scanner.skipOptionalObjectEnd() { + return + } + while true { + // Next character must be double quote, because + // map keys must always be quoted strings. + let c = try scanner.peekOneCharacter() + if c != "\"" { + throw JSONDecodingError.unquotedMapKey + } + isMapKey = true + var keyFieldOpt: KeyType.BaseType? + try KeyType.decodeSingular(value: &keyFieldOpt, from: &self) + guard let keyField = keyFieldOpt else { + throw JSONDecodingError.malformedMap + } + isMapKey = false + try scanner.skipRequiredColon() + var valueField: ValueType? + try decodeSingularEnumField(value: &valueField) + if let valueField = valueField { + value[keyField] = valueField + } else { + // Nothing, the only way ``decodeSingularEnumField(value:)`` leaves + // it as nil is if ignoreUnknownFields option is enabled which also + // means to ignore unknown enum values. + } + if scanner.skipOptionalObjectEnd() { + return + } + try scanner.skipRequiredComma() + } + } + + mutating func decodeMapField( + fieldType: _ProtobufMessageMap.Type, + value: inout _ProtobufMessageMap.BaseType + ) throws { + if scanner.skipOptionalNull() { + return + } + try scanner.skipRequiredObjectStart() + if scanner.skipOptionalObjectEnd() { + return + } + while true { + // Next character must be double quote, because + // map keys must always be quoted strings. + let c = try scanner.peekOneCharacter() + if c != "\"" { + throw JSONDecodingError.unquotedMapKey + } + isMapKey = true + var keyField: KeyType.BaseType? + try KeyType.decodeSingular(value: &keyField, from: &self) + isMapKey = false + try scanner.skipRequiredColon() + var valueField: ValueType? + try decodeSingularMessageField(value: &valueField) + if let keyField = keyField, let valueField = valueField { + value[keyField] = valueField + } else { + throw JSONDecodingError.malformedMap + } + if scanner.skipOptionalObjectEnd() { + return + } + try scanner.skipRequiredComma() + } + } + + mutating func decodeExtensionField( + values: inout ExtensionFieldValueSet, + messageType: any Message.Type, + fieldNumber: Int + ) throws { + // Force-unwrap: we can only get here if the extension exists. + let ext = scanner.extensions[messageType, fieldNumber]! + + try values.modify(index: fieldNumber) { fieldValue in + if fieldValue != nil { + try fieldValue!.decodeExtensionField(decoder: &self) + } else { + fieldValue = try ext._protobuf_newField(decoder: &self) + } + } + } } diff --git a/Sources/SwiftProtobuf/JSONDecodingOptions.swift b/Sources/SwiftProtobuf/JSONDecodingOptions.swift index 2f06e39fe..16cf6a41b 100644 --- a/Sources/SwiftProtobuf/JSONDecodingOptions.swift +++ b/Sources/SwiftProtobuf/JSONDecodingOptions.swift @@ -13,17 +13,19 @@ // ----------------------------------------------------------------------------- /// Options for JSONDecoding. -public struct JSONDecodingOptions { - /// The maximum nesting of message with messages. The default is 100. - /// - /// To prevent corrupt or malicious messages from causing stack overflows, - /// this controls how deep messages can be nested within other messages - /// while parsing. - public var messageDepthLimit: Int = 100 +public struct JSONDecodingOptions: Sendable { + /// The maximum nesting of message with messages. The default is 100. + /// + /// To prevent corrupt or malicious messages from causing stack overflows, + /// this controls how deep messages can be nested within other messages + /// while parsing. + public var messageDepthLimit: Int = 100 - /// If unknown fields in the JSON should be ignored. If they aren't - /// ignored, an error will be raised if one is encountered. - public var ignoreUnknownFields: Bool = false + /// If unknown fields in the JSON should be ignored. If they aren't + /// ignored, an error will be raised if one is encountered. This also + /// causes unknown enum values (especially string values) to be silently + /// ignored. + public var ignoreUnknownFields: Bool = false - public init() {} + public init() {} } diff --git a/Sources/SwiftProtobuf/JSONEncoder.swift b/Sources/SwiftProtobuf/JSONEncoder.swift index 61c53f702..d7d5ac103 100644 --- a/Sources/SwiftProtobuf/JSONEncoder.swift +++ b/Sources/SwiftProtobuf/JSONEncoder.swift @@ -69,14 +69,16 @@ internal struct JSONEncoder { internal init() {} - internal var dataResult: Data { return Data(data) } + internal var dataResult: [UInt8] { data } internal var stringResult: String { get { - return String(bytes: data, encoding: String.Encoding.utf8)! + String(decoding: data, as: UTF8.self) } } + internal var bytesResult: [UInt8] { data } + /// Append a `StaticString` to the JSON text. Because /// `StaticString` is already UTF8 internally, this is faster /// than appending a regular `String`. @@ -105,7 +107,12 @@ internal struct JSONEncoder { data.append(contentsOf: utf8Data) } - /// Begin a new field whose name is given as a `_NameMap.Name` + /// Append a raw utf8 in a `[UInt8]` to the JSON text. + internal mutating func append(utf8Bytes: [UInt8]) { + data.append(contentsOf: utf8Bytes) + } + + /// Begin a new field whose name is given as a `_NameMap.Name`. internal mutating func startField(name: _NameMap.Name) { if let s = separator { data.append(s) @@ -128,7 +135,7 @@ internal struct JSONEncoder { separator = asciiComma } - /// Begin a new extension field + /// Begin a new extension field. internal mutating func startExtensionField(name: String) { if let s = separator { data.append(s) @@ -238,18 +245,22 @@ internal struct JSONEncoder { } } - /// Write an Enum as an int. + /// Write an Enum as an Int. internal mutating func putEnumInt(value: Int) { appendInt(value: Int64(value)) } /// Write an `Int64` using protobuf JSON quoting conventions. - internal mutating func putInt64(value: Int64) { + internal mutating func putQuotedInt64(value: Int64) { data.append(asciiDoubleQuote) appendInt(value: value) data.append(asciiDoubleQuote) } + internal mutating func putNonQuotedInt64(value: Int64) { + appendInt(value: value) + } + /// Write an `Int32` with quoting suitable for /// using the value as a map key. internal mutating func putQuotedInt32(value: Int32) { @@ -259,17 +270,21 @@ internal struct JSONEncoder { } /// Write an `Int32` in the default format. - internal mutating func putInt32(value: Int32) { + internal mutating func putNonQuotedInt32(value: Int32) { appendInt(value: Int64(value)) } /// Write a `UInt64` using protobuf JSON quoting conventions. - internal mutating func putUInt64(value: UInt64) { + internal mutating func putQuotedUInt64(value: UInt64) { data.append(asciiDoubleQuote) appendUInt(value: value) data.append(asciiDoubleQuote) } + internal mutating func putNonQuotedUInt64(value: UInt64) { + appendUInt(value: value) + } + /// Write a `UInt32` with quoting suitable for /// using the value as a map key. internal mutating func putQuotedUInt32(value: UInt32) { @@ -279,7 +294,7 @@ internal struct JSONEncoder { } /// Write a `UInt32` in the default format. - internal mutating func putUInt32(value: UInt32) { + internal mutating func putNonQuotedUInt32(value: UInt32) { appendUInt(value: UInt64(value)) } @@ -287,12 +302,12 @@ internal struct JSONEncoder { /// using the value as a map key. internal mutating func putQuotedBoolValue(value: Bool) { data.append(asciiDoubleQuote) - putBoolValue(value: value) + putNonQuotedBoolValue(value: value) data.append(asciiDoubleQuote) } /// Write a `Bool` in the default format. - internal mutating func putBoolValue(value: Bool) { + internal mutating func putNonQuotedBoolValue(value: Bool) { if value { append(staticText: "true") } else { @@ -313,7 +328,7 @@ internal struct JSONEncoder { case 13: append(staticText: "\\r") case 34: append(staticText: "\\\"") case 92: append(staticText: "\\\\") - case 0...31, 127...159: // Hex form for C0 control chars + case 0...31, 127...159: // Hex form for C0 control chars append(staticText: "\\u00") data.append(hexDigits[Int(c.value / 16)]) data.append(hexDigits[Int(c.value & 15)]) @@ -337,50 +352,49 @@ internal struct JSONEncoder { } /// Append a bytes value using protobuf JSON Base-64 encoding. - internal mutating func putBytesValue(value: Data) { + internal mutating func putBytesValue(value: Bytes) { data.append(asciiDoubleQuote) if value.count > 0 { value.withUnsafeBytes { (body: UnsafeRawBufferPointer) in - if let p = body.baseAddress, body.count > 0 { - var t: Int = 0 - var bytesInGroup: Int = 0 - for i in 0.. 0 { + var t: Int = 0 + var bytesInGroup: Int = 0 + for i in 0..> 18) & 63]) + data.append(base64Digits[(t >> 12) & 63]) + data.append(base64Digits[(t >> 6) & 63]) + data.append(base64Digits[t & 63]) + t = 0 + bytesInGroup = 0 + } + t = (t << 8) + Int(p[i]) + bytesInGroup += 1 + } + switch bytesInGroup { + case 3: data.append(base64Digits[(t >> 18) & 63]) data.append(base64Digits[(t >> 12) & 63]) data.append(base64Digits[(t >> 6) & 63]) data.append(base64Digits[t & 63]) - t = 0 - bytesInGroup = 0 + case 2: + t <<= 8 + data.append(base64Digits[(t >> 18) & 63]) + data.append(base64Digits[(t >> 12) & 63]) + data.append(base64Digits[(t >> 6) & 63]) + data.append(asciiEquals) + case 1: + t <<= 16 + data.append(base64Digits[(t >> 18) & 63]) + data.append(base64Digits[(t >> 12) & 63]) + data.append(asciiEquals) + data.append(asciiEquals) + default: + break } - t = (t << 8) + Int(p[i]) - bytesInGroup += 1 } - switch bytesInGroup { - case 3: - data.append(base64Digits[(t >> 18) & 63]) - data.append(base64Digits[(t >> 12) & 63]) - data.append(base64Digits[(t >> 6) & 63]) - data.append(base64Digits[t & 63]) - case 2: - t <<= 8 - data.append(base64Digits[(t >> 18) & 63]) - data.append(base64Digits[(t >> 12) & 63]) - data.append(base64Digits[(t >> 6) & 63]) - data.append(asciiEquals) - case 1: - t <<= 16 - data.append(base64Digits[(t >> 18) & 63]) - data.append(base64Digits[(t >> 12) & 63]) - data.append(asciiEquals) - data.append(asciiEquals) - default: - break - } - } } } data.append(asciiDoubleQuote) } } - diff --git a/Sources/SwiftProtobuf/JSONEncodingError.swift b/Sources/SwiftProtobuf/JSONEncodingError.swift index 567f949e9..aec00d5d1 100644 --- a/Sources/SwiftProtobuf/JSONEncodingError.swift +++ b/Sources/SwiftProtobuf/JSONEncodingError.swift @@ -12,7 +12,7 @@ /// // ----------------------------------------------------------------------------- -public enum JSONEncodingError: Error { +public enum JSONEncodingError: Error, Hashable { /// Any fields that were decoded from binary format cannot be /// re-encoded into JSON unless the object they hold is a /// well-known type or a type registered with via @@ -32,4 +32,7 @@ public enum JSONEncodingError: Error { /// valid `kind` (that is, they represent a null value, number, boolean, /// string, struct, or list). case missingValue + /// google.protobuf.Value cannot encode double values for infinity or nan, + /// because they would be parsed as a string. + case valueNumberNotFinite } diff --git a/Sources/SwiftProtobuf/JSONEncodingOptions.swift b/Sources/SwiftProtobuf/JSONEncodingOptions.swift index 95419096d..ebc9671e2 100644 --- a/Sources/SwiftProtobuf/JSONEncodingOptions.swift +++ b/Sources/SwiftProtobuf/JSONEncodingOptions.swift @@ -13,14 +13,33 @@ // ----------------------------------------------------------------------------- /// Options for JSONEncoding. -public struct JSONEncodingOptions { +public struct JSONEncodingOptions: Sendable { - /// Always print enums as ints. By default they are printed as strings. - public var alwaysPrintEnumsAsInts: Bool = false + /// Always prints int64s values as numbers. + /// By default, they are printed as strings as per proto3 JSON mapping rules. + /// NB: When used as Map keys, int64s will be printed as strings as expected. + public var alwaysPrintInt64sAsNumbers: Bool = false - /// Whether to preserve proto field names. - /// By default they are converted to JSON(lowerCamelCase) names. - public var preserveProtoFieldNames: Bool = false + /// Always print enums as ints. By default they are printed as strings. + public var alwaysPrintEnumsAsInts: Bool = false - public init() {} + /// Whether to preserve proto field names. + /// By default they are converted to JSON(lowerCamelCase) names. + public var preserveProtoFieldNames: Bool = false + + /// Whether to use deterministic ordering when serializing. + /// + /// Note that the deterministic serialization is NOT canonical across languages. + /// It is NOT guaranteed to remain stable over time. It is unstable across + /// different builds with schema changes due to unknown fields. Users who need + /// canonical serialization (e.g., persistent storage in a canonical form, + /// fingerprinting, etc.) should define their own canonicalization specification + /// and implement their own serializer rather than relying on this API. + /// + /// If deterministic serialization is requested, map entries will be sorted + /// by keys in lexicographical order. This is an implementation detail + /// and subject to change. + public var useDeterministicOrdering: Bool = false + + public init() {} } diff --git a/Sources/SwiftProtobuf/JSONEncodingVisitor.swift b/Sources/SwiftProtobuf/JSONEncodingVisitor.swift index b250314e2..6ffb13afc 100644 --- a/Sources/SwiftProtobuf/JSONEncodingVisitor.swift +++ b/Sources/SwiftProtobuf/JSONEncodingVisitor.swift @@ -17,384 +17,423 @@ import Foundation /// Visitor that serializes a message into JSON format. internal struct JSONEncodingVisitor: Visitor { - private var encoder = JSONEncoder() - private var nameMap: _NameMap - private var extensions: ExtensionFieldValueSet? - private let options: JSONEncodingOptions - - /// The JSON text produced by the visitor, as raw UTF8 bytes. - var dataResult: Data { - return encoder.dataResult - } - - /// The JSON text produced by the visitor, as a String. - internal var stringResult: String { - return encoder.stringResult - } - - /// Creates a new visitor for serializing a message of the given type to JSON - /// format. - init(type: Message.Type, options: JSONEncodingOptions) throws { - if let nameProviding = type as? _ProtoNameProviding.Type { - self.nameMap = nameProviding._protobuf_nameMap - } else { - throw JSONEncodingError.missingFieldNames - } - self.options = options - } - - mutating func startArray() { - encoder.startArray() - } - - mutating func endArray() { - encoder.endArray() - } - - mutating func startObject(message: Message) { - self.extensions = (message as? ExtensibleMessage)?._protobuf_extensionFieldValues - encoder.startObject() - } - - mutating func startArrayObject(message: Message) { - self.extensions = (message as? ExtensibleMessage)?._protobuf_extensionFieldValues - encoder.startArrayObject() - } - - mutating func endObject() { - encoder.endObject() - } - - mutating func encodeField(name: String, stringValue value: String) { - encoder.startField(name: name) - encoder.putStringValue(value: value) - } - - mutating func encodeField(name: String, jsonText text: String) { - encoder.startField(name: name) - encoder.append(text: text) - } - - mutating func visitUnknown(bytes: Data) throws { - // JSON encoding has no provision for carrying proto2 unknown fields. - } - - mutating func visitSingularFloatField(value: Float, fieldNumber: Int) throws { - try startField(for: fieldNumber) - encoder.putFloatValue(value: value) - } - - mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws { - try startField(for: fieldNumber) - encoder.putDoubleValue(value: value) - } - - mutating func visitSingularInt32Field(value: Int32, fieldNumber: Int) throws { - try startField(for: fieldNumber) - encoder.putInt32(value: value) - } - - mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws { - try startField(for: fieldNumber) - encoder.putInt64(value: value) - } - - mutating func visitSingularUInt32Field(value: UInt32, fieldNumber: Int) throws { - try startField(for: fieldNumber) - encoder.putUInt32(value: value) - } - - mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws { - try startField(for: fieldNumber) - encoder.putUInt64(value: value) - } - - mutating func visitSingularFixed32Field(value: UInt32, fieldNumber: Int) throws { - try startField(for: fieldNumber) - encoder.putUInt32(value: value) - } - - mutating func visitSingularSFixed32Field(value: Int32, fieldNumber: Int) throws { - try startField(for: fieldNumber) - encoder.putInt32(value: value) - } - - mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws { - try startField(for: fieldNumber) - encoder.putBoolValue(value: value) - } - - mutating func visitSingularStringField(value: String, fieldNumber: Int) throws { - try startField(for: fieldNumber) - encoder.putStringValue(value: value) - } - - mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws { - try startField(for: fieldNumber) - encoder.putBytesValue(value: value) - } - - private mutating func _visitRepeated( - value: [T], - fieldNumber: Int, - encode: (inout JSONEncoder, T) throws -> () - ) throws { - assert(!value.isEmpty) - try startField(for: fieldNumber) - var comma = false - encoder.startArray() - for v in value { - if comma { - encoder.comma() - } - comma = true - try encode(&encoder, v) - } - encoder.endArray() - } - - mutating func visitSingularEnumField(value: E, fieldNumber: Int) throws { - try startField(for: fieldNumber) - if let e = value as? _CustomJSONCodable { - let json = try e.encodedJSONString(options: options) - encoder.append(text: json) - } else if !options.alwaysPrintEnumsAsInts, let n = value.name { - encoder.appendQuoted(name: n) - } else { - encoder.putEnumInt(value: value.rawValue) - } - } - - mutating func visitSingularMessageField(value: M, fieldNumber: Int) throws { - try startField(for: fieldNumber) - if let m = value as? _CustomJSONCodable { - let json = try m.encodedJSONString(options: options) - encoder.append(text: json) - } else if let newNameMap = (M.self as? _ProtoNameProviding.Type)?._protobuf_nameMap { - // Preserve outer object's name and extension maps; restore them before returning - let oldNameMap = self.nameMap - let oldExtensions = self.extensions - // Install inner object's name and extension maps - self.nameMap = newNameMap - startObject(message: value) - try value.traverse(visitor: &self) - endObject() - self.nameMap = oldNameMap - self.extensions = oldExtensions - } else { - throw JSONEncodingError.missingFieldNames - } - } - - mutating func visitSingularGroupField(value: G, fieldNumber: Int) throws { - // Google does not serialize groups into JSON - } - - mutating func visitRepeatedFloatField(value: [Float], fieldNumber: Int) throws { - try _visitRepeated(value: value, fieldNumber: fieldNumber) { - (encoder: inout JSONEncoder, v: Float) in - encoder.putFloatValue(value: v) - } - } - - mutating func visitRepeatedDoubleField(value: [Double], fieldNumber: Int) throws { - try _visitRepeated(value: value, fieldNumber: fieldNumber) { - (encoder: inout JSONEncoder, v: Double) in - encoder.putDoubleValue(value: v) - } - } - - mutating func visitRepeatedInt32Field(value: [Int32], fieldNumber: Int) throws { - try _visitRepeated(value: value, fieldNumber: fieldNumber) { - (encoder: inout JSONEncoder, v: Int32) in - encoder.putInt32(value: v) - } - } - - mutating func visitRepeatedInt64Field(value: [Int64], fieldNumber: Int) throws { - try _visitRepeated(value: value, fieldNumber: fieldNumber) { - (encoder: inout JSONEncoder, v: Int64) in - encoder.putInt64(value: v) - } - } - - mutating func visitRepeatedUInt32Field(value: [UInt32], fieldNumber: Int) throws { - try _visitRepeated(value: value, fieldNumber: fieldNumber) { - (encoder: inout JSONEncoder, v: UInt32) in - encoder.putUInt32(value: v) - } - } - - mutating func visitRepeatedUInt64Field(value: [UInt64], fieldNumber: Int) throws { - try _visitRepeated(value: value, fieldNumber: fieldNumber) { - (encoder: inout JSONEncoder, v: UInt64) in - encoder.putUInt64(value: v) - } - } - - mutating func visitRepeatedSInt32Field(value: [Int32], fieldNumber: Int) throws { - try visitRepeatedInt32Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitRepeatedSInt64Field(value: [Int64], fieldNumber: Int) throws { - try visitRepeatedInt64Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitRepeatedFixed32Field(value: [UInt32], fieldNumber: Int) throws { - try visitRepeatedUInt32Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitRepeatedFixed64Field(value: [UInt64], fieldNumber: Int) throws { - try visitRepeatedUInt64Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitRepeatedSFixed32Field(value: [Int32], fieldNumber: Int) throws { - try visitRepeatedInt32Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitRepeatedSFixed64Field(value: [Int64], fieldNumber: Int) throws { - try visitRepeatedInt64Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitRepeatedBoolField(value: [Bool], fieldNumber: Int) throws { - try _visitRepeated(value: value, fieldNumber: fieldNumber) { - (encoder: inout JSONEncoder, v: Bool) in - encoder.putBoolValue(value: v) - } - } - - mutating func visitRepeatedStringField(value: [String], fieldNumber: Int) throws { - try _visitRepeated(value: value, fieldNumber: fieldNumber) { - (encoder: inout JSONEncoder, v: String) in - encoder.putStringValue(value: v) - } - } - - mutating func visitRepeatedBytesField(value: [Data], fieldNumber: Int) throws { - try _visitRepeated(value: value, fieldNumber: fieldNumber) { - (encoder: inout JSONEncoder, v: Data) in - encoder.putBytesValue(value: v) - } - } - - mutating func visitRepeatedEnumField(value: [E], fieldNumber: Int) throws { - if let _ = E.self as? _CustomJSONCodable.Type { - let options = self.options - try _visitRepeated(value: value, fieldNumber: fieldNumber) { - (encoder: inout JSONEncoder, v: E) throws in - let e = v as! _CustomJSONCodable - let json = try e.encodedJSONString(options: options) - encoder.append(text: json) - } - } else { - let alwaysPrintEnumsAsInts = options.alwaysPrintEnumsAsInts - try _visitRepeated(value: value, fieldNumber: fieldNumber) { - (encoder: inout JSONEncoder, v: E) throws in - if !alwaysPrintEnumsAsInts, let n = v.name { - encoder.appendQuoted(name: n) + private var encoder = JSONEncoder() + private var nameMap: _NameMap + private var extensions: ExtensionFieldValueSet? + private let options: JSONEncodingOptions + + /// The JSON text produced by the visitor, as raw UTF8 bytes. + var dataResult: [UInt8] { + encoder.dataResult + } + + /// The JSON text produced by the visitor, as a String. + internal var stringResult: String { + encoder.stringResult + } + + /// Creates a new visitor for serializing a message of the given type to JSON + /// format. + init(type: any Message.Type, options: JSONEncodingOptions) throws { + if let nameProviding = type as? any _ProtoNameProviding.Type { + self.nameMap = nameProviding._protobuf_nameMap } else { - encoder.putEnumInt(value: v.rawValue) - } - } - } - } - - mutating func visitRepeatedMessageField(value: [M], fieldNumber: Int) throws { - assert(!value.isEmpty) - try startField(for: fieldNumber) - var comma = false - encoder.startArray() - if let _ = M.self as? _CustomJSONCodable.Type { - for v in value { - if comma { - encoder.comma() + throw JSONEncodingError.missingFieldNames } - comma = true - let json = try v.jsonString(options: options) - encoder.append(text: json) - } - } else if let newNameMap = (M.self as? _ProtoNameProviding.Type)?._protobuf_nameMap { - // Preserve name and extension maps for outer object - let oldNameMap = self.nameMap - let oldExtensions = self.extensions - self.nameMap = newNameMap - for v in value { - startArrayObject(message: v) - try v.traverse(visitor: &self) + self.options = options + } + + mutating func startArray() { + encoder.startArray() + } + + mutating func endArray() { + encoder.endArray() + } + + mutating func startObject(message: any Message) { + self.extensions = (message as? (any ExtensibleMessage))?._protobuf_extensionFieldValues + encoder.startObject() + } + + mutating func startArrayObject(message: any Message) { + self.extensions = (message as? (any ExtensibleMessage))?._protobuf_extensionFieldValues + encoder.startArrayObject() + } + + mutating func endObject() { encoder.endObject() - } - // Restore outer object's name and extension maps before returning - self.nameMap = oldNameMap - self.extensions = oldExtensions - } else { - throw JSONEncodingError.missingFieldNames - } - encoder.endArray() - } - - mutating func visitRepeatedGroupField(value: [G], fieldNumber: Int) throws { - assert(!value.isEmpty) - // Google does not serialize groups into JSON - } - - // Packed fields are handled the same as non-packed fields, so JSON just - // relies on the default implementations in Visitor.swift - - - - mutating func visitMapField(fieldType: _ProtobufMap.Type, value: _ProtobufMap.BaseType, fieldNumber: Int) throws { - try startField(for: fieldNumber) - encoder.append(text: "{") - var mapVisitor = JSONMapEncodingVisitor(encoder: encoder, options: options) - for (k,v) in value { - try KeyType.visitSingular(value: k, fieldNumber: 1, with: &mapVisitor) - try ValueType.visitSingular(value: v, fieldNumber: 2, with: &mapVisitor) - } - encoder = mapVisitor.encoder - encoder.append(text: "}") - } - - mutating func visitMapField(fieldType: _ProtobufEnumMap.Type, value: _ProtobufEnumMap.BaseType, fieldNumber: Int) throws where ValueType.RawValue == Int { - try startField(for: fieldNumber) - encoder.append(text: "{") - var mapVisitor = JSONMapEncodingVisitor(encoder: encoder, options: options) - for (k, v) in value { - try KeyType.visitSingular(value: k, fieldNumber: 1, with: &mapVisitor) - try mapVisitor.visitSingularEnumField(value: v, fieldNumber: 2) - } - encoder = mapVisitor.encoder - encoder.append(text: "}") - } - - mutating func visitMapField(fieldType: _ProtobufMessageMap.Type, value: _ProtobufMessageMap.BaseType, fieldNumber: Int) throws { - try startField(for: fieldNumber) - encoder.append(text: "{") - var mapVisitor = JSONMapEncodingVisitor(encoder: encoder, options: options) - for (k,v) in value { - try KeyType.visitSingular(value: k, fieldNumber: 1, with: &mapVisitor) - try mapVisitor.visitSingularMessageField(value: v, fieldNumber: 2) - } - encoder = mapVisitor.encoder - encoder.append(text: "}") - } - - /// Helper function that throws an error if the field number could not be - /// resolved. - private mutating func startField(for number: Int) throws { - let name: _NameMap.Name? - - if options.preserveProtoFieldNames { - name = nameMap.names(for: number)?.proto - } else { - name = nameMap.names(for: number)?.json - } - - if let name = name { + } + + mutating func encodeField(name: String, stringValue value: String) { encoder.startField(name: name) - } else if let name = extensions?[number]?.protobufExtension.fieldName { - encoder.startExtensionField(name: name) - } else { - throw JSONEncodingError.missingFieldNames + encoder.putStringValue(value: value) + } + + mutating func encodeField(name: String, jsonText text: String) { + encoder.startField(name: name) + encoder.append(text: text) + } + + mutating func visitUnknown(bytes: Data) throws { + // JSON encoding has no provision for carrying proto2 unknown fields. + } + + mutating func visitSingularFloatField(value: Float, fieldNumber: Int) throws { + try startField(for: fieldNumber) + encoder.putFloatValue(value: value) + } + + mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws { + try startField(for: fieldNumber) + encoder.putDoubleValue(value: value) + } + + mutating func visitSingularInt32Field(value: Int32, fieldNumber: Int) throws { + try startField(for: fieldNumber) + encoder.putNonQuotedInt32(value: value) + } + + mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws { + try startField(for: fieldNumber) + options.alwaysPrintInt64sAsNumbers + ? encoder.putNonQuotedInt64(value: value) + : encoder.putQuotedInt64(value: value) + } + + mutating func visitSingularUInt32Field(value: UInt32, fieldNumber: Int) throws { + try startField(for: fieldNumber) + encoder.putNonQuotedUInt32(value: value) + } + + mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws { + try startField(for: fieldNumber) + options.alwaysPrintInt64sAsNumbers + ? encoder.putNonQuotedUInt64(value: value) + : encoder.putQuotedUInt64(value: value) + } + + mutating func visitSingularFixed32Field(value: UInt32, fieldNumber: Int) throws { + try startField(for: fieldNumber) + encoder.putNonQuotedUInt32(value: value) + } + + mutating func visitSingularSFixed32Field(value: Int32, fieldNumber: Int) throws { + try startField(for: fieldNumber) + encoder.putNonQuotedInt32(value: value) + } + + mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws { + try startField(for: fieldNumber) + encoder.putNonQuotedBoolValue(value: value) + } + + mutating func visitSingularStringField(value: String, fieldNumber: Int) throws { + try startField(for: fieldNumber) + encoder.putStringValue(value: value) + } + + mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws { + try startField(for: fieldNumber) + encoder.putBytesValue(value: value) + } + + private mutating func _visitRepeated( + value: [T], + fieldNumber: Int, + encode: (inout JSONEncoder, T) throws -> Void + ) throws { + assert(!value.isEmpty) + try startField(for: fieldNumber) + var comma = false + encoder.startArray() + for v in value { + if comma { + encoder.comma() + } + comma = true + try encode(&encoder, v) + } + encoder.endArray() + } + + mutating func visitSingularEnumField(value: E, fieldNumber: Int) throws { + try startField(for: fieldNumber) + if let e = value as? (any _CustomJSONCodable) { + let json = try e.encodedJSONString(options: options) + encoder.append(text: json) + } else if !options.alwaysPrintEnumsAsInts, let n = value.name { + encoder.appendQuoted(name: n) + } else { + encoder.putEnumInt(value: value.rawValue) + } + } + + mutating func visitSingularMessageField(value: M, fieldNumber: Int) throws { + try startField(for: fieldNumber) + if let m = value as? (any _CustomJSONCodable) { + let json = try m.encodedJSONString(options: options) + encoder.append(text: json) + } else if let newNameMap = (M.self as? any _ProtoNameProviding.Type)?._protobuf_nameMap { + // Preserve outer object's name and extension maps; restore them before returning + let oldNameMap = self.nameMap + let oldExtensions = self.extensions + // Install inner object's name and extension maps + self.nameMap = newNameMap + startObject(message: value) + try value.traverse(visitor: &self) + endObject() + self.nameMap = oldNameMap + self.extensions = oldExtensions + } else { + throw JSONEncodingError.missingFieldNames + } + } + + mutating func visitSingularGroupField(value: G, fieldNumber: Int) throws { + try visitSingularMessageField(value: value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedFloatField(value: [Float], fieldNumber: Int) throws { + try _visitRepeated(value: value, fieldNumber: fieldNumber) { + (encoder: inout JSONEncoder, v: Float) in + encoder.putFloatValue(value: v) + } + } + + mutating func visitRepeatedDoubleField(value: [Double], fieldNumber: Int) throws { + try _visitRepeated(value: value, fieldNumber: fieldNumber) { + (encoder: inout JSONEncoder, v: Double) in + encoder.putDoubleValue(value: v) + } + } + + mutating func visitRepeatedInt32Field(value: [Int32], fieldNumber: Int) throws { + try _visitRepeated(value: value, fieldNumber: fieldNumber) { + (encoder: inout JSONEncoder, v: Int32) in + encoder.putNonQuotedInt32(value: v) + } + } + + mutating func visitRepeatedInt64Field(value: [Int64], fieldNumber: Int) throws { + if options.alwaysPrintInt64sAsNumbers { + try _visitRepeated(value: value, fieldNumber: fieldNumber) { + (encoder: inout JSONEncoder, v: Int64) in + encoder.putNonQuotedInt64(value: v) + } + } else { + try _visitRepeated(value: value, fieldNumber: fieldNumber) { + (encoder: inout JSONEncoder, v: Int64) in + encoder.putQuotedInt64(value: v) + } + } + } + + mutating func visitRepeatedUInt32Field(value: [UInt32], fieldNumber: Int) throws { + try _visitRepeated(value: value, fieldNumber: fieldNumber) { + (encoder: inout JSONEncoder, v: UInt32) in + encoder.putNonQuotedUInt32(value: v) + } + } + + mutating func visitRepeatedUInt64Field(value: [UInt64], fieldNumber: Int) throws { + if options.alwaysPrintInt64sAsNumbers { + try _visitRepeated(value: value, fieldNumber: fieldNumber) { + (encoder: inout JSONEncoder, v: UInt64) in + encoder.putNonQuotedUInt64(value: v) + } + } else { + try _visitRepeated(value: value, fieldNumber: fieldNumber) { + (encoder: inout JSONEncoder, v: UInt64) in + encoder.putQuotedUInt64(value: v) + } + } + } + + mutating func visitRepeatedSInt32Field(value: [Int32], fieldNumber: Int) throws { + try visitRepeatedInt32Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedSInt64Field(value: [Int64], fieldNumber: Int) throws { + try visitRepeatedInt64Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedFixed32Field(value: [UInt32], fieldNumber: Int) throws { + try visitRepeatedUInt32Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedFixed64Field(value: [UInt64], fieldNumber: Int) throws { + try visitRepeatedUInt64Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedSFixed32Field(value: [Int32], fieldNumber: Int) throws { + try visitRepeatedInt32Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedSFixed64Field(value: [Int64], fieldNumber: Int) throws { + try visitRepeatedInt64Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedBoolField(value: [Bool], fieldNumber: Int) throws { + try _visitRepeated(value: value, fieldNumber: fieldNumber) { + (encoder: inout JSONEncoder, v: Bool) in + encoder.putNonQuotedBoolValue(value: v) + } + } + + mutating func visitRepeatedStringField(value: [String], fieldNumber: Int) throws { + try _visitRepeated(value: value, fieldNumber: fieldNumber) { + (encoder: inout JSONEncoder, v: String) in + encoder.putStringValue(value: v) + } + } + + mutating func visitRepeatedBytesField(value: [Data], fieldNumber: Int) throws { + try _visitRepeated(value: value, fieldNumber: fieldNumber) { + (encoder: inout JSONEncoder, v: Data) in + encoder.putBytesValue(value: v) + } + } + + mutating func visitRepeatedEnumField(value: [E], fieldNumber: Int) throws { + if let _ = E.self as? any _CustomJSONCodable.Type { + let options = self.options + try _visitRepeated(value: value, fieldNumber: fieldNumber) { + (encoder: inout JSONEncoder, v: E) throws in + let e = v as! (any _CustomJSONCodable) + let json = try e.encodedJSONString(options: options) + encoder.append(text: json) + } + } else { + let alwaysPrintEnumsAsInts = options.alwaysPrintEnumsAsInts + try _visitRepeated(value: value, fieldNumber: fieldNumber) { + (encoder: inout JSONEncoder, v: E) throws in + if !alwaysPrintEnumsAsInts, let n = v.name { + encoder.appendQuoted(name: n) + } else { + encoder.putEnumInt(value: v.rawValue) + } + } + } + } + + mutating func visitRepeatedMessageField(value: [M], fieldNumber: Int) throws { + assert(!value.isEmpty) + try startField(for: fieldNumber) + var comma = false + encoder.startArray() + if let _ = M.self as? any _CustomJSONCodable.Type { + for v in value { + if comma { + encoder.comma() + } + comma = true + let json = try v.jsonString(options: options) + encoder.append(text: json) + } + } else if let newNameMap = (M.self as? any _ProtoNameProviding.Type)?._protobuf_nameMap { + // Preserve name and extension maps for outer object + let oldNameMap = self.nameMap + let oldExtensions = self.extensions + self.nameMap = newNameMap + for v in value { + startArrayObject(message: v) + try v.traverse(visitor: &self) + encoder.endObject() + } + // Restore outer object's name and extension maps before returning + self.nameMap = oldNameMap + self.extensions = oldExtensions + } else { + throw JSONEncodingError.missingFieldNames + } + encoder.endArray() + } + + mutating func visitRepeatedGroupField(value: [G], fieldNumber: Int) throws { + try visitRepeatedMessageField(value: value, fieldNumber: fieldNumber) + } + + // Packed fields are handled the same as non-packed fields, so JSON just + // relies on the default implementations in Visitor.swift + + mutating func visitMapField( + fieldType: _ProtobufMap.Type, + value: _ProtobufMap.BaseType, + fieldNumber: Int + ) throws { + try iterateAndEncode(map: value, fieldNumber: fieldNumber, isOrderedBefore: KeyType._lessThan) { + (visitor: inout JSONMapEncodingVisitor, key, value) throws -> Void in + try KeyType.visitSingular(value: key, fieldNumber: 1, with: &visitor) + try ValueType.visitSingular(value: value, fieldNumber: 2, with: &visitor) + } + } + + mutating func visitMapField( + fieldType: _ProtobufEnumMap.Type, + value: _ProtobufEnumMap.BaseType, + fieldNumber: Int + ) throws where ValueType.RawValue == Int { + try iterateAndEncode(map: value, fieldNumber: fieldNumber, isOrderedBefore: KeyType._lessThan) { + (visitor: inout JSONMapEncodingVisitor, key, value) throws -> Void in + try KeyType.visitSingular(value: key, fieldNumber: 1, with: &visitor) + try visitor.visitSingularEnumField(value: value, fieldNumber: 2) + } + } + + mutating func visitMapField( + fieldType: _ProtobufMessageMap.Type, + value: _ProtobufMessageMap.BaseType, + fieldNumber: Int + ) throws { + try iterateAndEncode(map: value, fieldNumber: fieldNumber, isOrderedBefore: KeyType._lessThan) { + (visitor: inout JSONMapEncodingVisitor, key, value) throws -> Void in + try KeyType.visitSingular(value: key, fieldNumber: 1, with: &visitor) + try visitor.visitSingularMessageField(value: value, fieldNumber: 2) + } + } + + /// Helper to encapsulate the common structure of iterating over a map + /// and encoding the keys and values. + private mutating func iterateAndEncode( + map: [K: V], + fieldNumber: Int, + isOrderedBefore: (K, K) -> Bool, + encode: (inout JSONMapEncodingVisitor, K, V) throws -> Void + ) throws { + try startField(for: fieldNumber) + encoder.append(text: "{") + var mapVisitor = JSONMapEncodingVisitor(encoder: JSONEncoder(), options: options) + if options.useDeterministicOrdering { + for (k, v) in map.sorted(by: { isOrderedBefore($0.0, $1.0) }) { + try encode(&mapVisitor, k, v) + } + } else { + for (k, v) in map { + try encode(&mapVisitor, k, v) + } + } + encoder.append(utf8Bytes: mapVisitor.bytesResult) + encoder.append(text: "}") + } + + /// Helper function that throws an error if the field number could not be + /// resolved. + private mutating func startField(for number: Int) throws { + let name: _NameMap.Name? + + if options.preserveProtoFieldNames { + name = nameMap.names(for: number)?.proto + } else { + name = nameMap.names(for: number)?.json + } + + if let name = name { + encoder.startField(name: name) + } else if let name = extensions?[number]?.protobufExtension.fieldName { + encoder.startExtensionField(name: name) + } else { + throw JSONEncodingError.missingFieldNames + } } - } } diff --git a/Sources/SwiftProtobuf/JSONMapEncodingVisitor.swift b/Sources/SwiftProtobuf/JSONMapEncodingVisitor.swift index e15ac035c..f09656f77 100644 --- a/Sources/SwiftProtobuf/JSONMapEncodingVisitor.swift +++ b/Sources/SwiftProtobuf/JSONMapEncodingVisitor.swift @@ -21,154 +21,165 @@ import Foundation /// as `fieldNumber:1`, values should be identified as `fieldNumber:2` /// internal struct JSONMapEncodingVisitor: SelectiveVisitor { - private var separator: StaticString? - internal var encoder: JSONEncoder - private let options: JSONEncodingOptions - - init(encoder: JSONEncoder, options: JSONEncodingOptions) { - self.encoder = encoder - self.options = options - } - - private mutating func startKey() { - if let s = separator { - encoder.append(staticText: s) - } else { - separator = "," - } - } - - private mutating func startValue() { - encoder.append(staticText: ":") - } - - mutating func visitSingularFloatField(value: Float, fieldNumber: Int) throws { - // Doubles/Floats can never be map keys, only values - assert(fieldNumber == 2) - startValue() - encoder.putFloatValue(value: value) - } - - mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws { - // Doubles/Floats can never be map keys, only values - assert(fieldNumber == 2) - startValue() - encoder.putDoubleValue(value: value) - } - - mutating func visitSingularInt32Field(value: Int32, fieldNumber: Int) throws { - if fieldNumber == 1 { - startKey() - encoder.putQuotedInt32(value: value) - } else { - startValue() - encoder.putInt32(value: value) - } - } - - mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws { - if fieldNumber == 1 { - startKey() - } else { - startValue() - } - // Int64 fields are always quoted anyway - encoder.putInt64(value: value) - } - - mutating func visitSingularUInt32Field(value: UInt32, fieldNumber: Int) throws { - if fieldNumber == 1 { - startKey() - encoder.putQuotedUInt32(value: value) - } else { - startValue() - encoder.putUInt32(value: value) - } - } - - mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws { - if fieldNumber == 1 { - startKey() - } else { - startValue() - } - encoder.putUInt64(value: value) - } - - mutating func visitSingularSInt32Field(value: Int32, fieldNumber: Int) throws { - try visitSingularInt32Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitSingularSInt64Field(value: Int64, fieldNumber: Int) throws { - try visitSingularInt64Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitSingularFixed32Field(value: UInt32, fieldNumber: Int) throws { - try visitSingularUInt32Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitSingularFixed64Field(value: UInt64, fieldNumber: Int) throws { - try visitSingularUInt64Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitSingularSFixed32Field(value: Int32, fieldNumber: Int) throws { - try visitSingularInt32Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitSingularSFixed64Field(value: Int64, fieldNumber: Int) throws { - try visitSingularInt64Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws { - if fieldNumber == 1 { - startKey() - encoder.putQuotedBoolValue(value: value) - } else { - startValue() - encoder.putBoolValue(value: value) - } - } - - mutating func visitSingularStringField(value: String, fieldNumber: Int) throws { - if fieldNumber == 1 { - startKey() - } else { - startValue() - } - encoder.putStringValue(value: value) - } - - mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws { - // Bytes can only be map values, never keys - assert(fieldNumber == 2) - startValue() - encoder.putBytesValue(value: value) - } - - mutating func visitSingularEnumField(value: E, fieldNumber: Int) throws { - // Enums can only be map values, never keys - assert(fieldNumber == 2) - startValue() - if !options.alwaysPrintEnumsAsInts, let n = value.name { - encoder.putStringValue(value: String(describing: n)) - } else { - encoder.putEnumInt(value: value.rawValue) - } - } - - mutating func visitSingularMessageField(value: M, fieldNumber: Int) throws { - // Messages can only be map values, never keys - assert(fieldNumber == 2) - startValue() - let json = try value.jsonString(options: options) - encoder.append(text: json) - } - - // SelectiveVisitor will block: - // - single Groups - // - everything repeated - // - everything packed - // - all maps - // - unknown fields - // - extensions + private var separator: StaticString? + internal var encoder: JSONEncoder + private let options: JSONEncodingOptions + + init(encoder: JSONEncoder, options: JSONEncodingOptions) { + self.encoder = encoder + self.options = options + } + + internal var bytesResult: [UInt8] { + get { + encoder.bytesResult + } + } + + private mutating func startKey() { + if let s = separator { + encoder.append(staticText: s) + } else { + separator = "," + } + } + + private mutating func startValue() { + encoder.append(staticText: ":") + } + + mutating func visitSingularFloatField(value: Float, fieldNumber: Int) throws { + // Doubles/Floats can never be map keys, only values + assert(fieldNumber == 2) + startValue() + encoder.putFloatValue(value: value) + } + + mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws { + // Doubles/Floats can never be map keys, only values + assert(fieldNumber == 2) + startValue() + encoder.putDoubleValue(value: value) + } + + mutating func visitSingularInt32Field(value: Int32, fieldNumber: Int) throws { + if fieldNumber == 1 { + startKey() + encoder.putQuotedInt32(value: value) + } else { + startValue() + encoder.putNonQuotedInt32(value: value) + } + } + + mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws { + if fieldNumber == 1 { + startKey() + encoder.putQuotedInt64(value: value) + } else { + startValue() + options.alwaysPrintInt64sAsNumbers + ? encoder.putNonQuotedInt64(value: value) + : encoder.putQuotedInt64(value: value) + } + } + + mutating func visitSingularUInt32Field(value: UInt32, fieldNumber: Int) throws { + if fieldNumber == 1 { + startKey() + encoder.putQuotedUInt32(value: value) + } else { + startValue() + encoder.putNonQuotedUInt32(value: value) + } + } + + mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws { + if fieldNumber == 1 { + startKey() + encoder.putQuotedUInt64(value: value) + } else { + startValue() + options.alwaysPrintInt64sAsNumbers + ? encoder.putNonQuotedUInt64(value: value) + : encoder.putQuotedUInt64(value: value) + } + } + + mutating func visitSingularSInt32Field(value: Int32, fieldNumber: Int) throws { + try visitSingularInt32Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitSingularSInt64Field(value: Int64, fieldNumber: Int) throws { + try visitSingularInt64Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitSingularFixed32Field(value: UInt32, fieldNumber: Int) throws { + try visitSingularUInt32Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitSingularFixed64Field(value: UInt64, fieldNumber: Int) throws { + try visitSingularUInt64Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitSingularSFixed32Field(value: Int32, fieldNumber: Int) throws { + try visitSingularInt32Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitSingularSFixed64Field(value: Int64, fieldNumber: Int) throws { + try visitSingularInt64Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws { + if fieldNumber == 1 { + startKey() + encoder.putQuotedBoolValue(value: value) + } else { + startValue() + encoder.putNonQuotedBoolValue(value: value) + } + } + + mutating func visitSingularStringField(value: String, fieldNumber: Int) throws { + if fieldNumber == 1 { + startKey() + } else { + startValue() + } + encoder.putStringValue(value: value) + } + + mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws { + // Bytes can only be map values, never keys + assert(fieldNumber == 2) + startValue() + encoder.putBytesValue(value: value) + } + + mutating func visitSingularEnumField(value: E, fieldNumber: Int) throws { + // Enums can only be map values, never keys + assert(fieldNumber == 2) + startValue() + if !options.alwaysPrintEnumsAsInts, let n = value.name { + encoder.putStringValue(value: String(describing: n)) + } else { + encoder.putEnumInt(value: value.rawValue) + } + } + + mutating func visitSingularMessageField(value: M, fieldNumber: Int) throws { + // Messages can only be map values, never keys + assert(fieldNumber == 2) + startValue() + let json = try value.jsonString(options: options) + encoder.append(text: json) + } + + // SelectiveVisitor will block: + // - single Groups + // - everything repeated + // - everything packed + // - all maps + // - unknown fields + // - extensions } diff --git a/Sources/SwiftProtobuf/JSONScanner.swift b/Sources/SwiftProtobuf/JSONScanner.swift index 8960a4092..e98687a33 100644 --- a/Sources/SwiftProtobuf/JSONScanner.swift +++ b/Sources/SwiftProtobuf/JSONScanner.swift @@ -64,20 +64,20 @@ private let asciiLowerZ = UInt8(ascii: "z") private let asciiUpperZ = UInt8(ascii: "Z") private func fromHexDigit(_ c: UnicodeScalar) -> UInt32? { - let n = c.value - if n >= 48 && n <= 57 { - return UInt32(n - 48) - } - switch n { - case 65, 97: return 10 - case 66, 98: return 11 - case 67, 99: return 12 - case 68, 100: return 13 - case 69, 101: return 14 - case 70, 102: return 15 - default: - return nil - } + let n = c.value + if n >= 48 && n <= 57 { + return UInt32(n - 48) + } + switch n { + case 65, 97: return 10 + case 66, 98: return 11 + case 67, 99: return 12 + case 68, 100: return 13 + case 69, 101: return 14 + case 70, 102: return 15 + default: + return nil + } } // Decode both the RFC 4648 section 4 Base 64 encoding and the RFC @@ -85,23 +85,24 @@ private func fromHexDigit(_ c: UnicodeScalar) -> UInt32? { // known as "base64url" or the "URL-safe alphabet". // Note that both "-" and "+" decode to 62 and "/" and "_" both // decode as 63. +// swift-format-ignore: NoBlockComments let base64Values: [Int] = [ -/* 0x00 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -/* 0x10 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -/* 0x20 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, 62, -1, 63, -/* 0x30 */ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -/* 0x40 */ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, -/* 0x50 */ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63, -/* 0x60 */ -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, -/* 0x70 */ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1, -/* 0x80 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -/* 0x90 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -/* 0xa0 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -/* 0xb0 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -/* 0xc0 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -/* 0xd0 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -/* 0xe0 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -/* 0xf0 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /* 0x00 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /* 0x10 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /* 0x20 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, 62, -1, 63, + /* 0x30 */ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, + /* 0x40 */ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + /* 0x50 */ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63, + /* 0x60 */ -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + /* 0x70 */ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1, + /* 0x80 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /* 0x90 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /* 0xa0 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /* 0xb0 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /* 0xc0 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /* 0xd0 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /* 0xe0 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + /* 0xf0 */ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ] /// Returns a `Data` value containing bytes equivalent to the given @@ -116,9 +117,9 @@ let base64Values: [Int] = [ /// Base 64 encoding and the "URL and Filename Safe Alphabet" variant. /// private func parseBytes( - source: UnsafeRawBufferPointer, - index: inout UnsafeRawBufferPointer.Index, - end: UnsafeRawBufferPointer.Index + source: UnsafeRawBufferPointer, + index: inout UnsafeRawBufferPointer.Index, + end: UnsafeRawBufferPointer.Index ) throws -> Data { let c = source[index] if c != asciiDoubleQuote { @@ -191,83 +192,83 @@ private func parseBytes( index = digitsStart try value.withUnsafeMutableBytes { (body: UnsafeMutableRawBufferPointer) in - if var p = body.baseAddress, body.count > 0 { - var n = 0 - var chars = 0 // # chars in current group - var padding = 0 // # padding '=' chars - digits: while true { - let digit = source[index] - var k = base64Values[Int(digit)] - if k < 0 { - switch digit { - case asciiDoubleQuote: - break digits - case asciiBackslash: - source.formIndex(after: &index) - let escaped = source[index] - switch escaped { - case asciiForwardSlash: - k = base64Values[Int(escaped)] - default: - // Note: Invalid backslash escapes were caught - // above; we should never get here. - throw JSONDecodingError.malformedString - } - case asciiSpace: - source.formIndex(after: &index) - continue digits - case asciiEqualSign: // Count padding - while true { - switch source[index] { - case asciiDoubleQuote: - break digits - case asciiSpace: - break - case 61: - padding += 1 - default: // Only '=' and whitespace permitted + if var p = body.baseAddress, body.count > 0 { + var n = 0 + var chars = 0 // # chars in current group + var padding = 0 // # padding '=' chars + digits: while true { + let digit = source[index] + var k = base64Values[Int(digit)] + if k < 0 { + switch digit { + case asciiDoubleQuote: + break digits + case asciiBackslash: + source.formIndex(after: &index) + let escaped = source[index] + switch escaped { + case asciiForwardSlash: + k = base64Values[Int(escaped)] + default: + // Note: Invalid backslash escapes were caught + // above; we should never get here. throw JSONDecodingError.malformedString } + case asciiSpace: source.formIndex(after: &index) + continue digits + case asciiEqualSign: // Count padding + while true { + switch source[index] { + case asciiDoubleQuote: + break digits + case asciiSpace: + break + case 61: + padding += 1 + default: // Only '=' and whitespace permitted + throw JSONDecodingError.malformedString + } + source.formIndex(after: &index) + } + default: + throw JSONDecodingError.malformedString } - default: - throw JSONDecodingError.malformedString } + n <<= 6 + n |= k + chars += 1 + if chars == 4 { + p[0] = UInt8(truncatingIfNeeded: n >> 16) + p[1] = UInt8(truncatingIfNeeded: n >> 8) + p[2] = UInt8(truncatingIfNeeded: n) + p += 3 + chars = 0 + n = 0 + } + source.formIndex(after: &index) } - n <<= 6 - n |= k - chars += 1 - if chars == 4 { - p[0] = UInt8(truncatingIfNeeded: n >> 16) - p[1] = UInt8(truncatingIfNeeded: n >> 8) - p[2] = UInt8(truncatingIfNeeded: n) - p += 3 - chars = 0 - n = 0 - } - source.formIndex(after: &index) - } - switch chars { - case 3: - p[0] = UInt8(truncatingIfNeeded: n >> 10) - p[1] = UInt8(truncatingIfNeeded: n >> 2) - if padding == 1 || padding == 0 { - return - } - case 2: - p[0] = UInt8(truncatingIfNeeded: n >> 4) - if padding == 2 || padding == 0 { - return - } - case 0: - if padding == 0 { - return + switch chars { + case 3: + p[0] = UInt8(truncatingIfNeeded: n >> 10) + p[1] = UInt8(truncatingIfNeeded: n >> 2) + if padding == 1 || padding == 0 { + return + } + case 2: + p[0] = UInt8(truncatingIfNeeded: n >> 4) + if padding == 2 || padding == 0 { + return + } + case 0: + if padding == 0 { + return + } + default: + break } - default: - break + throw JSONDecodingError.malformedString } - throw JSONDecodingError.malformedString - } } source.formIndex(after: &index) return value @@ -276,1262 +277,1299 @@ private func parseBytes( // JSON encoding allows a variety of \-escapes, including // escaping UTF-16 code points (which may be surrogate pairs). private func decodeString(_ s: String) -> String? { - var out = String.UnicodeScalarView() - var chars = s.unicodeScalars.makeIterator() - while let c = chars.next() { - switch c.value { - case UInt32(asciiBackslash): // backslash - if let escaped = chars.next() { - switch escaped.value { - case UInt32(asciiLowerU): // "\u" - // Exactly 4 hex digits: - if let digit1 = chars.next(), - let d1 = fromHexDigit(digit1), - let digit2 = chars.next(), - let d2 = fromHexDigit(digit2), - let digit3 = chars.next(), - let d3 = fromHexDigit(digit3), - let digit4 = chars.next(), - let d4 = fromHexDigit(digit4) { - let codePoint = ((d1 * 16 + d2) * 16 + d3) * 16 + d4 - if let scalar = UnicodeScalar(codePoint) { - out.append(scalar) - } else if codePoint < 0xD800 || codePoint >= 0xE000 { - // Not a valid Unicode scalar. - return nil - } else if codePoint >= 0xDC00 { - // Low surrogate without a preceding high surrogate. - return nil - } else { - // We have a high surrogate (in the range 0xD800..<0xDC00), so - // verify that it is followed by a low surrogate. - guard chars.next() == "\\", chars.next() == "u" else { - // High surrogate was not followed by a Unicode escape sequence. - return nil - } - if let digit1 = chars.next(), - let d1 = fromHexDigit(digit1), - let digit2 = chars.next(), - let d2 = fromHexDigit(digit2), - let digit3 = chars.next(), - let d3 = fromHexDigit(digit3), - let digit4 = chars.next(), - let d4 = fromHexDigit(digit4) { - let follower = ((d1 * 16 + d2) * 16 + d3) * 16 + d4 - guard 0xDC00 <= follower && follower < 0xE000 else { - // High surrogate was not followed by a low surrogate. - return nil - } - let high = codePoint - 0xD800 - let low = follower - 0xDC00 - let composed = 0x10000 | high << 10 | low - guard let composedScalar = UnicodeScalar(composed) else { - // Composed value is not a valid Unicode scalar. - return nil + var out = String.UnicodeScalarView() + var chars = s.unicodeScalars.makeIterator() + while let c = chars.next() { + switch c.value { + case UInt32(asciiBackslash): // backslash + if let escaped = chars.next() { + switch escaped.value { + case UInt32(asciiLowerU): // "\u" + // Exactly 4 hex digits: + if let digit1 = chars.next(), + let d1 = fromHexDigit(digit1), + let digit2 = chars.next(), + let d2 = fromHexDigit(digit2), + let digit3 = chars.next(), + let d3 = fromHexDigit(digit3), + let digit4 = chars.next(), + let d4 = fromHexDigit(digit4) + { + let codePoint = ((d1 * 16 + d2) * 16 + d3) * 16 + d4 + if let scalar = UnicodeScalar(codePoint) { + out.append(scalar) + } else if codePoint < 0xD800 || codePoint >= 0xE000 { + // Not a valid Unicode scalar. + return nil + } else if codePoint >= 0xDC00 { + // Low surrogate without a preceding high surrogate. + return nil + } else { + // We have a high surrogate (in the range 0xD800..<0xDC00), so + // verify that it is followed by a low surrogate. + guard chars.next() == "\\", chars.next() == "u" else { + // High surrogate was not followed by a Unicode escape sequence. + return nil + } + if let digit1 = chars.next(), + let d1 = fromHexDigit(digit1), + let digit2 = chars.next(), + let d2 = fromHexDigit(digit2), + let digit3 = chars.next(), + let d3 = fromHexDigit(digit3), + let digit4 = chars.next(), + let d4 = fromHexDigit(digit4) + { + let follower = ((d1 * 16 + d2) * 16 + d3) * 16 + d4 + guard 0xDC00 <= follower && follower < 0xE000 else { + // High surrogate was not followed by a low surrogate. + return nil + } + let high = codePoint - 0xD800 + let low = follower - 0xDC00 + let composed = 0x10000 | high << 10 | low + guard let composedScalar = UnicodeScalar(composed) else { + // Composed value is not a valid Unicode scalar. + return nil + } + out.append(composedScalar) + } else { + // Malformed \u escape for low surrogate + return nil + } + } + } else { + // Malformed \u escape + return nil + } + case UInt32(asciiLowerB): // \b + out.append("\u{08}") + case UInt32(asciiLowerF): // \f + out.append("\u{0c}") + case UInt32(asciiLowerN): // \n + out.append("\u{0a}") + case UInt32(asciiLowerR): // \r + out.append("\u{0d}") + case UInt32(asciiLowerT): // \t + out.append("\u{09}") + case UInt32(asciiDoubleQuote), UInt32(asciiBackslash), + UInt32(asciiForwardSlash): // " \ / + out.append(escaped) + default: + return nil // Unrecognized escape } - out.append(composedScalar) - } else { - // Malformed \u escape for low surrogate - return nil - } + } else { + return nil // Input ends with backslash } - } else { - // Malformed \u escape - return nil - } - case UInt32(asciiLowerB): // \b - out.append("\u{08}") - case UInt32(asciiLowerF): // \f - out.append("\u{0c}") - case UInt32(asciiLowerN): // \n - out.append("\u{0a}") - case UInt32(asciiLowerR): // \r - out.append("\u{0d}") - case UInt32(asciiLowerT): // \t - out.append("\u{09}") - case UInt32(asciiDoubleQuote), UInt32(asciiBackslash), - UInt32(asciiForwardSlash): // " \ / - out.append(escaped) default: - return nil // Unrecognized escape + out.append(c) } - } else { - return nil // Input ends with backslash - } - default: - out.append(c) } - } - return String(out) + return String(out) } /// /// The basic scanner support is entirely private /// /// For performance, it works directly against UTF-8 bytes in memory. -/// internal struct JSONScanner { - private let source: UnsafeRawBufferPointer - private var index: UnsafeRawBufferPointer.Index - private var numberParser = DoubleParser() - internal let options: JSONDecodingOptions - internal let extensions: ExtensionMap - internal var recursionBudget: Int + private let source: UnsafeRawBufferPointer + private var index: UnsafeRawBufferPointer.Index + private var numberParser = DoubleParser() + internal let options: JSONDecodingOptions + internal let extensions: any ExtensionMap + internal var recursionBudget: Int - /// True if the scanner has read all of the data from the source, with the - /// exception of any trailing whitespace (which is consumed by reading this - /// property). - internal var complete: Bool { - mutating get { - skipWhitespace() - return !hasMoreContent + /// True if the scanner has read all of the data from the source, with the + /// exception of any trailing whitespace (which is consumed by reading this + /// property). + internal var complete: Bool { + mutating get { + skipWhitespace() + return !hasMoreContent + } } - } - - /// True if the scanner has not yet reached the end of the source. - private var hasMoreContent: Bool { - return index != source.endIndex - } - /// The byte (UTF-8 code unit) at the scanner's current position. - private var currentByte: UInt8 { - return source[index] - } + /// True if the scanner has not yet reached the end of the source. + private var hasMoreContent: Bool { + index != source.endIndex + } - internal init( - source: UnsafeRawBufferPointer, - options: JSONDecodingOptions, - extensions: ExtensionMap? - ) { - self.source = source - self.index = source.startIndex - self.recursionBudget = options.messageDepthLimit - self.options = options - self.extensions = extensions ?? SimpleExtensionMap() - } + /// The byte (UTF-8 code unit) at the scanner's current position. + private var currentByte: UInt8 { + source[index] + } - internal mutating func incrementRecursionDepth() throws { - recursionBudget -= 1 - if recursionBudget < 0 { - throw JSONDecodingError.messageDepthLimit + internal init( + source: UnsafeRawBufferPointer, + options: JSONDecodingOptions, + extensions: (any ExtensionMap)? + ) { + self.source = source + self.index = source.startIndex + self.recursionBudget = options.messageDepthLimit + self.options = options + self.extensions = extensions ?? SimpleExtensionMap() } - } - internal mutating func decrementRecursionDepth() { - recursionBudget += 1 - // This should never happen, if it does, something is probably corrupting memory, and - // simply throwing doesn't make much sense. - if recursionBudget > options.messageDepthLimit { - fatalError("Somehow JSONDecoding unwound more objects than it started") + internal mutating func incrementRecursionDepth() throws { + recursionBudget -= 1 + if recursionBudget < 0 { + throw JSONDecodingError.messageDepthLimit + } } - } - /// Advances the scanner to the next position in the source. - private mutating func advance() { - source.formIndex(after: &index) - } + internal mutating func decrementRecursionDepth() { + recursionBudget += 1 + // This should never happen, if it does, something is probably corrupting memory, and + // simply throwing doesn't make much sense. + if recursionBudget > options.messageDepthLimit { + fatalError("Somehow JSONDecoding unwound more objects than it started") + } + } - /// Skip whitespace - private mutating func skipWhitespace() { - while hasMoreContent { - let u = currentByte - switch u { - case asciiSpace, asciiTab, asciiNewLine, asciiCarriageReturn: - advance() - default: - return - } + /// Advances the scanner to the next position in the source. + private mutating func advance() { + source.formIndex(after: &index) } - } - /// Returns (but does not consume) the next non-whitespace - /// character. This is used by google.protobuf.Value, for - /// example, for custom JSON parsing. - internal mutating func peekOneCharacter() throws -> Character { - skipWhitespace() - guard hasMoreContent else { - throw JSONDecodingError.truncated + /// Skip whitespace. + private mutating func skipWhitespace() { + while hasMoreContent { + let u = currentByte + switch u { + case asciiSpace, asciiTab, asciiNewLine, asciiCarriageReturn: + advance() + default: + return + } + } } - return Character(UnicodeScalar(UInt32(currentByte))!) - } - // Parse the leading UInt64 from the provided utf8 bytes. - // - // This is called in three different situations: - // - // * Unquoted number. - // - // * Simple quoted number. If a number is quoted but has no - // backslashes, the caller can use this directly on the UTF8 by - // just verifying the quote marks. This code returns `nil` if it - // sees a backslash, in which case the caller will need to handle ... - // - // * Complex quoted number. In this case, the caller must parse the - // quoted value as a string, then convert the string to utf8 and - // use this to parse the result. This is slow but fortunately - // rare. - // - // In the common case where the number is written in integer form, - // this code does a simple straight conversion. If the number is in - // floating-point format, this uses a slower and less accurate - // approach: it identifies a substring comprising a float, and then - // uses Double() and UInt64() to convert that string to an unsigned - // integer. In particular, it cannot preserve full 64-bit integer - // values when they are written in floating-point format. - // - // If it encounters a "\" backslash character, it returns a nil. This - // is used by callers that are parsing quoted numbers. See nextSInt() - // and nextUInt() below. - private func parseBareUInt64( - source: UnsafeRawBufferPointer, - index: inout UnsafeRawBufferPointer.Index, - end: UnsafeRawBufferPointer.Index - ) throws -> UInt64? { - if index == end { - throw JSONDecodingError.truncated + /// Returns (but does not consume) the next non-whitespace + /// character. This is used by google.protobuf.Value, for + /// example, for custom JSON parsing. + internal mutating func peekOneCharacter() throws -> Character { + skipWhitespace() + guard hasMoreContent else { + throw JSONDecodingError.truncated + } + return Character(UnicodeScalar(UInt32(currentByte))!) } - let start = index - let c = source[index] - switch c { - case asciiZero: // 0 - source.formIndex(after: &index) - if index != end { - let after = source[index] - switch after { - case asciiZero...asciiNine: // 0...9 - // leading '0' forbidden unless it is the only digit - throw JSONDecodingError.leadingZero - case asciiPeriod, asciiLowerE, asciiUpperE: // . e - // Slow path: JSON numbers can be written in floating-point notation - index = start - if let d = try parseBareDouble(source: source, - index: &index, - end: end) { - if let u = UInt64(exactly: d) { - return u + + // Parse the leading UInt64 from the provided utf8 bytes. + // + // This is called in three different situations: + // + // * Unquoted number. + // + // * Simple quoted number. If a number is quoted but has no + // backslashes, the caller can use this directly on the UTF8 by + // just verifying the quote marks. This code returns `nil` if it + // sees a backslash, in which case the caller will need to handle ... + // + // * Complex quoted number. In this case, the caller must parse the + // quoted value as a string, then convert the string to utf8 and + // use this to parse the result. This is slow but fortunately + // rare. + // + // In the common case where the number is written in integer form, + // this code does a simple straight conversion. If the number is in + // floating-point format, this uses a slower and less accurate + // approach: it identifies a substring comprising a float, and then + // uses Double() and UInt64() to convert that string to an unsigned + // integer. In particular, it cannot preserve full 64-bit integer + // values when they are written in floating-point format. + // + // If it encounters a "\" backslash character, it returns a nil. This + // is used by callers that are parsing quoted numbers. See nextSInt() + // and nextUInt() below. + private func parseBareUInt64( + source: UnsafeRawBufferPointer, + index: inout UnsafeRawBufferPointer.Index, + end: UnsafeRawBufferPointer.Index + ) throws -> UInt64? { + if index == end { + throw JSONDecodingError.truncated + } + let start = index + let c = source[index] + switch c { + case asciiZero: // 0 + source.formIndex(after: &index) + if index != end { + let after = source[index] + switch after { + case asciiZero...asciiNine: // 0...9 + // leading '0' forbidden unless it is the only digit + throw JSONDecodingError.leadingZero + case asciiPeriod, asciiLowerE, asciiUpperE: // . e + // Slow path: JSON numbers can be written in floating-point notation + index = start + if let d = try parseBareDouble( + source: source, + index: &index, + end: end + ) { + if let u = UInt64(exactly: d) { + return u + } + } + throw JSONDecodingError.malformedNumber + case asciiBackslash: + return nil + default: + return 0 + } } - } - throw JSONDecodingError.malformedNumber - case asciiBackslash: - return nil - default: - return 0 - } - } - return 0 - case asciiOne...asciiNine: // 1...9 - var n = 0 as UInt64 - while index != end { - let digit = source[index] - switch digit { - case asciiZero...asciiNine: // 0...9 - let val = UInt64(digit - asciiZero) - if n > UInt64.max / 10 || n * 10 > UInt64.max - val { - throw JSONDecodingError.numberRange - } - source.formIndex(after: &index) - n = n * 10 + val - case asciiPeriod, asciiLowerE, asciiUpperE: // . e - // Slow path: JSON allows floating-point notation for integers - index = start - if let d = try parseBareDouble(source: source, - index: &index, - end: end) { - if let u = UInt64(exactly: d) { - return u + return 0 + case asciiOne...asciiNine: // 1...9 + var n = 0 as UInt64 + while index != end { + let digit = source[index] + switch digit { + case asciiZero...asciiNine: // 0...9 + let val = UInt64(digit - asciiZero) + if n > UInt64.max / 10 || n * 10 > UInt64.max - val { + throw JSONDecodingError.numberRange + } + source.formIndex(after: &index) + n = n * 10 + val + case asciiPeriod, asciiLowerE, asciiUpperE: // . e + // Slow path: JSON allows floating-point notation for integers + index = start + if let d = try parseBareDouble( + source: source, + index: &index, + end: end + ) { + if let u = UInt64(exactly: d) { + return u + } + } + throw JSONDecodingError.malformedNumber + case asciiBackslash: + return nil + default: + return n + } } - } - throw JSONDecodingError.malformedNumber + return n case asciiBackslash: - return nil + return nil default: - return n + throw JSONDecodingError.malformedNumber } - } - return n - case asciiBackslash: - return nil - default: - throw JSONDecodingError.malformedNumber } - } - // Parse the leading Int64 from the provided utf8. - // - // This uses parseBareUInt64() to do the heavy lifting; - // we just check for a leading minus and negate the result - // as necessary. - // - // As with parseBareUInt64(), if it encounters a "\" backslash - // character, it returns a nil. This allows callers to use this to - // do a "fast-path" decode of simple quoted numbers by parsing the - // UTF8 directly, only falling back to a full String decode when - // absolutely necessary. - private func parseBareSInt64( - source: UnsafeRawBufferPointer, - index: inout UnsafeRawBufferPointer.Index, - end: UnsafeRawBufferPointer.Index - ) throws -> Int64? { - if index == end { - throw JSONDecodingError.truncated - } - let c = source[index] - if c == asciiMinus { // - - source.formIndex(after: &index) - if index == end { - throw JSONDecodingError.truncated - } - // character after '-' must be digit - let digit = source[index] - if digit < asciiZero || digit > asciiNine { - throw JSONDecodingError.malformedNumber - } - if let n = try parseBareUInt64(source: source, index: &index, end: end) { - let limit: UInt64 = 0x8000000000000000 // -Int64.min - if n >= limit { - if n > limit { - // Too large negative number - throw JSONDecodingError.numberRange - } else { - return Int64.min // Special case for Int64.min - } - } - return -Int64(bitPattern: n) - } else { - return nil - } - } else if let n = try parseBareUInt64(source: source, index: &index, end: end) { - if n > UInt64(bitPattern: Int64.max) { - throw JSONDecodingError.numberRange - } - return Int64(bitPattern: n) - } else { - return nil + // Parse the leading Int64 from the provided utf8. + // + // This uses parseBareUInt64() to do the heavy lifting; + // we just check for a leading minus and negate the result + // as necessary. + // + // As with parseBareUInt64(), if it encounters a "\" backslash + // character, it returns a nil. This allows callers to use this to + // do a "fast-path" decode of simple quoted numbers by parsing the + // UTF8 directly, only falling back to a full String decode when + // absolutely necessary. + private func parseBareSInt64( + source: UnsafeRawBufferPointer, + index: inout UnsafeRawBufferPointer.Index, + end: UnsafeRawBufferPointer.Index + ) throws -> Int64? { + if index == end { + throw JSONDecodingError.truncated + } + let c = source[index] + if c == asciiMinus { // - + source.formIndex(after: &index) + if index == end { + throw JSONDecodingError.truncated + } + // character after '-' must be digit + let digit = source[index] + if digit < asciiZero || digit > asciiNine { + throw JSONDecodingError.malformedNumber + } + if let n = try parseBareUInt64(source: source, index: &index, end: end) { + let limit: UInt64 = 0x8000_0000_0000_0000 // -Int64.min + if n >= limit { + if n > limit { + // Too large negative number + throw JSONDecodingError.numberRange + } else { + return Int64.min // Special case for Int64.min + } + } + return -Int64(bitPattern: n) + } else { + return nil + } + } else if let n = try parseBareUInt64(source: source, index: &index, end: end) { + if n > UInt64(bitPattern: Int64.max) { + throw JSONDecodingError.numberRange + } + return Int64(bitPattern: n) + } else { + return nil + } } - } - // Identify a floating-point token in the upcoming UTF8 bytes. - // - // This implements the full grammar defined by the JSON RFC 7159. - // Note that Swift's string-to-number conversions are much more - // lenient, so this is necessary if we want to accurately reject - // malformed JSON numbers. - // - // This is used by nextDouble() and nextFloat() to parse double and - // floating-point values, including values that happen to be in quotes. - // It's also used by the slow path in parseBareSInt64() and parseBareUInt64() - // above to handle integer values that are written in float-point notation. - private func parseBareDouble( - source: UnsafeRawBufferPointer, - index: inout UnsafeRawBufferPointer.Index, - end: UnsafeRawBufferPointer.Index - ) throws -> Double? { - // RFC 7159 defines the grammar for JSON numbers as: - // number = [ minus ] int [ frac ] [ exp ] - if index == end { - throw JSONDecodingError.truncated - } - let start = index - var c = source[index] - if c == asciiBackslash { - return nil - } + // Identify a floating-point token in the upcoming UTF8 bytes. + // + // This implements the full grammar defined by the JSON RFC 7159. + // Note that Swift's string-to-number conversions are much more + // lenient, so this is necessary if we want to accurately reject + // malformed JSON numbers. + // + // This is used by nextDouble() and nextFloat() to parse double and + // floating-point values, including values that happen to be in quotes. + // It's also used by the slow path in parseBareSInt64() and parseBareUInt64() + // above to handle integer values that are written in float-point notation. + private func parseBareDouble( + source: UnsafeRawBufferPointer, + index: inout UnsafeRawBufferPointer.Index, + end: UnsafeRawBufferPointer.Index + ) throws -> Double? { + // RFC 7159 defines the grammar for JSON numbers as: + // number = [ minus ] int [ frac ] [ exp ] + if index == end { + throw JSONDecodingError.truncated + } + let start = index + var c = source[index] + if c == asciiBackslash { + return nil + } - // Optional leading minus sign - if c == asciiMinus { // - - source.formIndex(after: &index) - if index == end { - index = start - throw JSONDecodingError.truncated - } - c = source[index] - if c == asciiBackslash { - return nil - } - } else if c == asciiUpperN { // Maybe NaN? - // Return nil, let the caller deal with it. - return nil - } + // Optional leading minus sign + if c == asciiMinus { // - + source.formIndex(after: &index) + if index == end { + index = start + throw JSONDecodingError.truncated + } + c = source[index] + if c == asciiBackslash { + return nil + } + } else if c == asciiUpperN { // Maybe NaN? + // Return nil, let the caller deal with it. + return nil + } - if c == asciiUpperI { // Maybe Infinity, Inf, -Infinity, or -Inf ? - // Return nil, let the caller deal with it. - return nil - } + if c == asciiUpperI { // Maybe Infinity, Inf, -Infinity, or -Inf ? + // Return nil, let the caller deal with it. + return nil + } - // Integer part can be zero or a series of digits not starting with zero - // int = zero / (digit1-9 *DIGIT) - switch c { - case asciiZero: - // First digit can be zero only if not followed by a digit - source.formIndex(after: &index) - if index == end { - return 0.0 - } - c = source[index] - if c == asciiBackslash { - return nil - } - if c >= asciiZero && c <= asciiNine { - throw JSONDecodingError.leadingZero - } - case asciiOne...asciiNine: - while c >= asciiZero && c <= asciiNine { - source.formIndex(after: &index) - if index == end { - if let d = numberParser.utf8ToDouble(bytes: source, start: start, end: index) { + // Integer part can be zero or a series of digits not starting with zero + // int = zero / (digit1-9 *DIGIT) + switch c { + case asciiZero: + // First digit can be zero only if not followed by a digit + source.formIndex(after: &index) + if index == end { + return 0.0 + } + c = source[index] + if c == asciiBackslash { + return nil + } + if c >= asciiZero && c <= asciiNine { + throw JSONDecodingError.leadingZero + } + case asciiOne...asciiNine: + while c >= asciiZero && c <= asciiNine { + source.formIndex(after: &index) + if index == end { + if let d = numberParser.utf8ToDouble(bytes: source, start: start, end: index) { + return d + } else { + throw JSONDecodingError.invalidUTF8 + } + } + c = source[index] + if c == asciiBackslash { + return nil + } + } + default: + // Integer part cannot be empty + throw JSONDecodingError.malformedNumber + } + + // frac = decimal-point 1*DIGIT + if c == asciiPeriod { + source.formIndex(after: &index) + if index == end { + // decimal point must have a following digit + throw JSONDecodingError.truncated + } + c = source[index] + switch c { + case asciiZero...asciiNine: // 0...9 + while c >= asciiZero && c <= asciiNine { + source.formIndex(after: &index) + if index == end { + if let d = numberParser.utf8ToDouble(bytes: source, start: start, end: index) { + return d + } else { + throw JSONDecodingError.invalidUTF8 + } + } + c = source[index] + if c == asciiBackslash { + return nil + } + } + case asciiBackslash: + return nil + default: + // decimal point must be followed by at least one digit + throw JSONDecodingError.malformedNumber + } + } + + // exp = e [ minus / plus ] 1*DIGIT + if c == asciiLowerE || c == asciiUpperE { + source.formIndex(after: &index) + if index == end { + // "e" must be followed by +,-, or digit + throw JSONDecodingError.truncated + } + c = source[index] + if c == asciiBackslash { + return nil + } + if c == asciiPlus || c == asciiMinus { // + - + source.formIndex(after: &index) + if index == end { + // must be at least one digit in exponent + throw JSONDecodingError.truncated + } + c = source[index] + if c == asciiBackslash { + return nil + } + } + switch c { + case asciiZero...asciiNine: + while c >= asciiZero && c <= asciiNine { + source.formIndex(after: &index) + if index == end { + if let d = numberParser.utf8ToDouble(bytes: source, start: start, end: index) { + return d + } else { + throw JSONDecodingError.invalidUTF8 + } + } + c = source[index] + if c == asciiBackslash { + return nil + } + } + default: + // must be at least one digit in exponent + throw JSONDecodingError.malformedNumber + } + } + if let d = numberParser.utf8ToDouble(bytes: source, start: start, end: index) { return d - } else { + } else { throw JSONDecodingError.invalidUTF8 - } } - c = source[index] - if c == asciiBackslash { - return nil + } + + /// Returns a fully-parsed string with all backslash escapes + /// correctly processed, or nil if next token is not a string. + /// + /// Assumes the leading quote has been verified (but not consumed) + private mutating func parseOptionalQuotedString() -> String? { + // Caller has already asserted that currentByte == quote here + var sawBackslash = false + advance() + let start = index + while hasMoreContent { + switch currentByte { + case asciiDoubleQuote: // " + let s = utf8ToString(bytes: source, start: start, end: index) + advance() + if let t = s { + if sawBackslash { + return decodeString(t) + } else { + return t + } + } else { + return nil // Invalid UTF8 + } + case asciiBackslash: // \ + advance() + guard hasMoreContent else { + return nil // Unterminated escape + } + sawBackslash = true + default: + break + } + advance() } - } - default: - // Integer part cannot be empty - throw JSONDecodingError.malformedNumber + return nil // Unterminated quoted string } - // frac = decimal-point 1*DIGIT - if c == asciiPeriod { - source.formIndex(after: &index) - if index == end { - // decimal point must have a following digit - throw JSONDecodingError.truncated - } - c = source[index] - switch c { - case asciiZero...asciiNine: // 0...9 - while c >= asciiZero && c <= asciiNine { - source.formIndex(after: &index) - if index == end { - if let d = numberParser.utf8ToDouble(bytes: source, start: start, end: index) { - return d + /// Parse an unsigned integer, whether or not its quoted. + /// This also handles cases such as quoted numbers that have + /// backslash escapes in them. + /// + /// This supports the full range of UInt64 (whether quoted or not) + /// unless the number is written in floating-point format. In that + /// case, we decode it with only Double precision. + internal mutating func nextUInt() throws -> UInt64 { + skipWhitespace() + guard hasMoreContent else { + throw JSONDecodingError.truncated + } + let c = currentByte + if c == asciiDoubleQuote { + let start = index + advance() + if let u = try parseBareUInt64( + source: source, + index: &index, + end: source.endIndex + ) { + guard hasMoreContent else { + throw JSONDecodingError.truncated + } + if currentByte != asciiDoubleQuote { + throw JSONDecodingError.malformedNumber + } + advance() + return u } else { - throw JSONDecodingError.invalidUTF8 + // Couldn't parse because it had a "\" in the string, + // so parse out the quoted string and then reparse + // the result to get a UInt. + index = start + let s = try nextQuotedString() + let raw = s.data(using: String.Encoding.utf8)! + let n = try raw.withUnsafeBytes { + (body: UnsafeRawBufferPointer) -> UInt64? in + if body.count > 0 { + var index = body.startIndex + let end = body.endIndex + if let u = try parseBareUInt64( + source: body, + index: &index, + end: end + ) { + if index == end { + return u + } + } + } + return nil + } + if let n = n { + return n + } } - } - c = source[index] - if c == asciiBackslash { - return nil - } + } else if let u = try parseBareUInt64( + source: source, + index: &index, + end: source.endIndex + ) { + return u } - case asciiBackslash: - return nil - default: - // decimal point must be followed by at least one digit throw JSONDecodingError.malformedNumber - } } - // exp = e [ minus / plus ] 1*DIGIT - if c == asciiLowerE || c == asciiUpperE { - source.formIndex(after: &index) - if index == end { - // "e" must be followed by +,-, or digit - throw JSONDecodingError.truncated - } - c = source[index] - if c == asciiBackslash { - return nil - } - if c == asciiPlus || c == asciiMinus { // + - - source.formIndex(after: &index) - if index == end { - // must be at least one digit in exponent - throw JSONDecodingError.truncated + /// Parse a signed integer, quoted or not, including handling + /// backslash escapes for quoted values. + /// + /// This supports the full range of Int64 (whether quoted or not) + /// unless the number is written in floating-point format. In that + /// case, we decode it with only Double precision. + internal mutating func nextSInt() throws -> Int64 { + skipWhitespace() + guard hasMoreContent else { + throw JSONDecodingError.truncated } - c = source[index] - if c == asciiBackslash { - return nil - } - } - switch c { - case asciiZero...asciiNine: - while c >= asciiZero && c <= asciiNine { - source.formIndex(after: &index) - if index == end { - if let d = numberParser.utf8ToDouble(bytes: source, start: start, end: index) { - return d + let c = currentByte + if c == asciiDoubleQuote { + let start = index + advance() + if let s = try parseBareSInt64( + source: source, + index: &index, + end: source.endIndex + ) { + guard hasMoreContent else { + throw JSONDecodingError.truncated + } + if currentByte != asciiDoubleQuote { + throw JSONDecodingError.malformedNumber + } + advance() + return s } else { - throw JSONDecodingError.invalidUTF8 + // Couldn't parse because it had a "\" in the string, + // so parse out the quoted string and then reparse + // the result as an SInt. + index = start + let s = try nextQuotedString() + let raw = s.data(using: String.Encoding.utf8)! + let n = try raw.withUnsafeBytes { + (body: UnsafeRawBufferPointer) -> Int64? in + if body.count > 0 { + var index = body.startIndex + let end = body.endIndex + if let s = try parseBareSInt64( + source: body, + index: &index, + end: end + ) { + if index == end { + return s + } + } + } + return nil + } + if let n = n { + return n + } } - } - c = source[index] - if c == asciiBackslash { - return nil - } + } else if let s = try parseBareSInt64( + source: source, + index: &index, + end: source.endIndex + ) { + return s } - default: - // must be at least one digit in exponent throw JSONDecodingError.malformedNumber - } } - if let d = numberParser.utf8ToDouble(bytes: source, start: start, end: index) { - return d - } else { - throw JSONDecodingError.invalidUTF8 + + /// Parse the next Float value, regardless of whether it + /// is quoted, including handling backslash escapes for + /// quoted strings. + internal mutating func nextFloat() throws -> Float { + skipWhitespace() + guard hasMoreContent else { + throw JSONDecodingError.truncated + } + let c = currentByte + if c == asciiDoubleQuote { // " + let start = index + advance() + if let d = try parseBareDouble( + source: source, + index: &index, + end: source.endIndex + ) { + guard hasMoreContent else { + throw JSONDecodingError.truncated + } + if currentByte != asciiDoubleQuote { + throw JSONDecodingError.malformedNumber + } + advance() + return Float(d) + } else { + // Slow Path: parseBareDouble returned nil: It might be + // a valid float, but had something that + // parseBareDouble cannot directly handle. So we reset, + // try a full string parse, then examine the result: + index = start + let s = try nextQuotedString() + switch s { + case "NaN": return Float.nan + case "Inf": return Float.infinity + case "-Inf": return -Float.infinity + case "Infinity": return Float.infinity + case "-Infinity": return -Float.infinity + default: + let raw = s.data(using: String.Encoding.utf8)! + let n = try raw.withUnsafeBytes { + (body: UnsafeRawBufferPointer) -> Float? in + if body.count > 0 { + var index = body.startIndex + let end = body.endIndex + if let d = try parseBareDouble( + source: body, + index: &index, + end: end + ) { + let f = Float(d) + if index == end && f.isFinite { + return f + } + } + } + return nil + } + if let n = n { + return n + } + } + } + } else { + if let d = try parseBareDouble( + source: source, + index: &index, + end: source.endIndex + ) { + let f = Float(d) + if f.isFinite { + return f + } + } + } + throw JSONDecodingError.malformedNumber } - } - /// Returns a fully-parsed string with all backslash escapes - /// correctly processed, or nil if next token is not a string. - /// - /// Assumes the leading quote has been verified (but not consumed) - private mutating func parseOptionalQuotedString() -> String? { - // Caller has already asserted that currentByte == quote here - var sawBackslash = false - advance() - let start = index - while hasMoreContent { - switch currentByte { - case asciiDoubleQuote: // " - let s = utf8ToString(bytes: source, start: start, end: index) - advance() - if let t = s { - if sawBackslash { - return decodeString(t) - } else { - return t - } + /// Parse the next Double value, regardless of whether it + /// is quoted, including handling backslash escapes for + /// quoted strings. + internal mutating func nextDouble() throws -> Double { + skipWhitespace() + guard hasMoreContent else { + throw JSONDecodingError.truncated + } + let c = currentByte + if c == asciiDoubleQuote { // " + let start = index + advance() + if let d = try parseBareDouble( + source: source, + index: &index, + end: source.endIndex + ) { + guard hasMoreContent else { + throw JSONDecodingError.truncated + } + if currentByte != asciiDoubleQuote { + throw JSONDecodingError.malformedNumber + } + advance() + return d + } else { + // Slow Path: parseBareDouble returned nil: It might be + // a valid float, but had something that + // parseBareDouble cannot directly handle. So we reset, + // try a full string parse, then examine the result: + index = start + let s = try nextQuotedString() + switch s { + case "NaN": return Double.nan + case "Inf": return Double.infinity + case "-Inf": return -Double.infinity + case "Infinity": return Double.infinity + case "-Infinity": return -Double.infinity + default: + let raw = s.data(using: String.Encoding.utf8)! + let n = try raw.withUnsafeBytes { + (body: UnsafeRawBufferPointer) -> Double? in + if body.count > 0 { + var index = body.startIndex + let end = body.endIndex + if let d = try parseBareDouble( + source: body, + index: &index, + end: end + ) { + if index == end { + return d + } + } + } + return nil + } + if let n = n { + return n + } + } + } } else { - return nil // Invalid UTF8 + if let d = try parseBareDouble( + source: source, + index: &index, + end: source.endIndex + ) { + return d + } } - case asciiBackslash: // \ - advance() + throw JSONDecodingError.malformedNumber + } + + /// Return the contents of the following quoted string, + /// or throw an error if the next token is not a string. + internal mutating func nextQuotedString() throws -> String { + skipWhitespace() guard hasMoreContent else { - return nil // Unterminated escape + throw JSONDecodingError.truncated + } + let c = currentByte + if c != asciiDoubleQuote { + throw JSONDecodingError.malformedString + } + if let s = parseOptionalQuotedString() { + return s + } else { + throw JSONDecodingError.malformedString } - sawBackslash = true - default: - break - } - advance() } - return nil // Unterminated quoted string - } - /// Parse an unsigned integer, whether or not its quoted. - /// This also handles cases such as quoted numbers that have - /// backslash escapes in them. - /// - /// This supports the full range of UInt64 (whether quoted or not) - /// unless the number is written in floating-point format. In that - /// case, we decode it with only Double precision. - internal mutating func nextUInt() throws -> UInt64 { - skipWhitespace() - guard hasMoreContent else { - throw JSONDecodingError.truncated + /// Return the contents of the following quoted string, + /// or nil if the next token is not a string. + /// This will only throw an error if the next token starts + /// out as a string but is malformed in some way. + internal mutating func nextOptionalQuotedString() throws -> String? { + skipWhitespace() + guard hasMoreContent else { + return nil + } + let c = currentByte + if c != asciiDoubleQuote { + return nil + } + return try nextQuotedString() } - let c = currentByte - if c == asciiDoubleQuote { - let start = index - advance() - if let u = try parseBareUInt64(source: source, - index: &index, - end: source.endIndex) { + + /// Return a Data with the decoded contents of the + /// following base-64 string. + /// + /// Notes on Google's implementation: + /// * Google's C++ implementation accepts arbitrary whitespace + /// mixed in with the base-64 characters + /// * Google's C++ implementation ignores missing '=' characters + /// but if present, there must be the exact correct number of them. + /// * Google's C++ implementation accepts both "regular" and + /// "web-safe" base-64 variants (it seems to prefer the + /// web-safe version as defined in RFC 4648 + internal mutating func nextBytesValue() throws -> Data { + skipWhitespace() guard hasMoreContent else { - throw JSONDecodingError.truncated + throw JSONDecodingError.truncated } - if currentByte != asciiDoubleQuote { - throw JSONDecodingError.malformedNumber + return try parseBytes(source: source, index: &index, end: source.endIndex) + } + + /// Private function to help parse keywords. + private mutating func skipOptionalKeyword(bytes: [UInt8]) -> Bool { + let start = index + for b in bytes { + guard hasMoreContent else { + index = start + return false + } + let c = currentByte + if c != b { + index = start + return false + } + advance() } - advance() - return u - } else { - // Couldn't parse because it had a "\" in the string, - // so parse out the quoted string and then reparse - // the result to get a UInt - index = start - let s = try nextQuotedString() - let raw = s.data(using: String.Encoding.utf8)! - let n = try raw.withUnsafeBytes { - (body: UnsafeRawBufferPointer) -> UInt64? in - if body.count > 0 { - var index = body.startIndex - let end = body.endIndex - if let u = try parseBareUInt64(source: body, - index: &index, - end: end) { - if index == end { - return u - } + if hasMoreContent { + let c = currentByte + if (c >= asciiUpperA && c <= asciiUpperZ) || (c >= asciiLowerA && c <= asciiLowerZ) { + index = start + return false } - } - return nil } - if let n = n { - return n + return true + } + + /// If the next token is the identifier "null", consume it and return true. + internal mutating func skipOptionalNull() -> Bool { + skipWhitespace() + if hasMoreContent && currentByte == asciiLowerN { + return skipOptionalKeyword(bytes: [ + asciiLowerN, asciiLowerU, asciiLowerL, asciiLowerL, + ]) } - } - } else if let u = try parseBareUInt64(source: source, - index: &index, - end: source.endIndex) { - return u + return false } - throw JSONDecodingError.malformedNumber - } - /// Parse a signed integer, quoted or not, including handling - /// backslash escapes for quoted values. - /// - /// This supports the full range of Int64 (whether quoted or not) - /// unless the number is written in floating-point format. In that - /// case, we decode it with only Double precision. - internal mutating func nextSInt() throws -> Int64 { - skipWhitespace() - guard hasMoreContent else { - throw JSONDecodingError.truncated + /// Return the following Bool "true" or "false", including + /// full processing of quoted boolean values. (Used in map + /// keys, for instance.) + internal mutating func nextBool() throws -> Bool { + skipWhitespace() + guard hasMoreContent else { + throw JSONDecodingError.truncated + } + let c = currentByte + switch c { + case asciiLowerF: // f + if skipOptionalKeyword(bytes: [ + asciiLowerF, asciiLowerA, asciiLowerL, asciiLowerS, asciiLowerE, + ]) { + return false + } + case asciiLowerT: // t + if skipOptionalKeyword(bytes: [ + asciiLowerT, asciiLowerR, asciiLowerU, asciiLowerE, + ]) { + return true + } + default: + break + } + throw JSONDecodingError.malformedBool } - let c = currentByte - if c == asciiDoubleQuote { - let start = index - advance() - if let s = try parseBareSInt64(source: source, - index: &index, - end: source.endIndex) { + + /// Return the following Bool "true" or "false", including + /// full processing of quoted boolean values. (Used in map + /// keys, for instance.) + internal mutating func nextQuotedBool() throws -> Bool { + skipWhitespace() guard hasMoreContent else { - throw JSONDecodingError.truncated + throw JSONDecodingError.truncated } if currentByte != asciiDoubleQuote { - throw JSONDecodingError.malformedNumber + throw JSONDecodingError.unquotedMapKey } - advance() - return s - } else { - // Couldn't parse because it had a "\" in the string, - // so parse out the quoted string and then reparse - // the result as an SInt - index = start - let s = try nextQuotedString() - let raw = s.data(using: String.Encoding.utf8)! - let n = try raw.withUnsafeBytes { - (body: UnsafeRawBufferPointer) -> Int64? in - if body.count > 0 { - var index = body.startIndex - let end = body.endIndex - if let s = try parseBareSInt64(source: body, - index: &index, - end: end) { - if index == end { - return s - } + if let s = parseOptionalQuotedString() { + switch s { + case "false": return false + case "true": return true + default: break } - } - return nil - } - if let n = n { - return n } - } - } else if let s = try parseBareSInt64(source: source, - index: &index, - end: source.endIndex) { - return s + throw JSONDecodingError.malformedBool } - throw JSONDecodingError.malformedNumber - } - /// Parse the next Float value, regardless of whether it - /// is quoted, including handling backslash escapes for - /// quoted strings. - internal mutating func nextFloat() throws -> Float { - skipWhitespace() - guard hasMoreContent else { - throw JSONDecodingError.truncated - } - let c = currentByte - if c == asciiDoubleQuote { // " - let start = index - advance() - if let d = try parseBareDouble(source: source, - index: &index, - end: source.endIndex) { + /// Returns pointer/count spanning the UTF8 bytes of the next regular + /// key or nil if the key contains a backslash (and therefore requires + /// the full string-parsing logic to properly parse). + private mutating func nextOptionalKey() throws -> UnsafeRawBufferPointer? { + skipWhitespace() + let stringStart = index guard hasMoreContent else { - throw JSONDecodingError.truncated + throw JSONDecodingError.truncated } if currentByte != asciiDoubleQuote { - throw JSONDecodingError.malformedNumber + return nil } advance() - return Float(d) - } else { - // Slow Path: parseBareDouble returned nil: It might be - // a valid float, but had something that - // parseBareDouble cannot directly handle. So we reset, - // try a full string parse, then examine the result: - index = start - let s = try nextQuotedString() - switch s { - case "NaN": return Float.nan - case "Inf": return Float.infinity - case "-Inf": return -Float.infinity - case "Infinity": return Float.infinity - case "-Infinity": return -Float.infinity - default: - let raw = s.data(using: String.Encoding.utf8)! - let n = try raw.withUnsafeBytes { - (body: UnsafeRawBufferPointer) -> Float? in - if body.count > 0 { - var index = body.startIndex - let end = body.endIndex - if let d = try parseBareDouble(source: body, - index: &index, - end: end) { - let f = Float(d) - if index == end && f.isFinite { - return f - } - } + let nameStart = index + while hasMoreContent && currentByte != asciiDoubleQuote { + if currentByte == asciiBackslash { + index = stringStart // Reset to open quote + return nil } - return nil - } - if let n = n { - return n - } - } - } - } else { - if let d = try parseBareDouble(source: source, - index: &index, - end: source.endIndex) { - let f = Float(d) - if f.isFinite { - return f - } - } + advance() + } + guard hasMoreContent else { + throw JSONDecodingError.truncated + } + let buff = UnsafeRawBufferPointer( + start: source.baseAddress! + nameStart, + count: index - nameStart + ) + advance() + return buff } - throw JSONDecodingError.malformedNumber - } - /// Parse the next Double value, regardless of whether it - /// is quoted, including handling backslash escapes for - /// quoted strings. - internal mutating func nextDouble() throws -> Double { - skipWhitespace() - guard hasMoreContent else { - throw JSONDecodingError.truncated + /// Parse a field name, look it up in the provided field name map, + /// and return the corresponding field number. + /// + /// Throws if field name cannot be parsed. + /// If it encounters an unknown field name, it throws + /// unless `options.ignoreUnknownFields` is set, in which case + /// it silently skips it. + internal mutating func nextFieldNumber( + names: _NameMap, + messageType: any Message.Type + ) throws -> Int? { + while true { + var fieldName: String + if let key = try nextOptionalKey() { + // Fast path: We parsed it as UTF8 bytes... + try skipRequiredCharacter(asciiColon) // : + if let fieldNumber = names.number(forJSONName: key) { + return fieldNumber + } + if let s = utf8ToString(bytes: key.baseAddress!, count: key.count) { + fieldName = s + } else { + throw JSONDecodingError.invalidUTF8 + } + } else { + // Slow path: We parsed a String; lookups from String are slower. + fieldName = try nextQuotedString() + try skipRequiredCharacter(asciiColon) // : + if let fieldNumber = names.number(forJSONName: fieldName) { + return fieldNumber + } + } + if let first = fieldName.utf8.first, first == UInt8(ascii: "["), + let last = fieldName.utf8.last, last == UInt8(ascii: "]") + { + fieldName.removeFirst() + fieldName.removeLast() + if let fieldNumber = extensions.fieldNumberForProto(messageType: messageType, protoFieldName: fieldName) + { + return fieldNumber + } + } + if !options.ignoreUnknownFields { + throw JSONDecodingError.unknownField(fieldName) + } + // Unknown field, skip it and try to parse the next field name + try skipValue() + if skipOptionalObjectEnd() { + return nil + } + try skipRequiredComma() + } } - let c = currentByte - if c == asciiDoubleQuote { // " - let start = index - advance() - if let d = try parseBareDouble(source: source, - index: &index, - end: source.endIndex) { - guard hasMoreContent else { - throw JSONDecodingError.truncated + + /// Parse the next token as a string or numeric enum value. Throws + /// unrecognizedEnumValue if the string/number can't initialize the + /// enum. Will throw other errors if the JSON is malformed. + internal mutating func nextEnumValue() throws -> E? { + func throwOrIgnore() throws -> E? { + if options.ignoreUnknownFields { + return nil + } else { + throw JSONDecodingError.unrecognizedEnumValue + } } - if currentByte != asciiDoubleQuote { - throw JSONDecodingError.malformedNumber + skipWhitespace() + guard hasMoreContent else { + throw JSONDecodingError.truncated } - advance() - return d - } else { - // Slow Path: parseBareDouble returned nil: It might be - // a valid float, but had something that - // parseBareDouble cannot directly handle. So we reset, - // try a full string parse, then examine the result: - index = start - let s = try nextQuotedString() - switch s { - case "NaN": return Double.nan - case "Inf": return Double.infinity - case "-Inf": return -Double.infinity - case "Infinity": return Double.infinity - case "-Infinity": return -Double.infinity - default: - let raw = s.data(using: String.Encoding.utf8)! - let n = try raw.withUnsafeBytes { - (body: UnsafeRawBufferPointer) -> Double? in - if body.count > 0 { - var index = body.startIndex - let end = body.endIndex - if let d = try parseBareDouble(source: body, - index: &index, - end: end) { - if index == end { - return d + if currentByte == asciiDoubleQuote { + if let name = try nextOptionalKey() { + if let e = E(rawUTF8: name) { + return e + } else { + return try throwOrIgnore() } - } } - return nil - } - if let n = n { - return n - } - } - } - } else { - if let d = try parseBareDouble(source: source, - index: &index, - end: source.endIndex) { - return d - } + let name = try nextQuotedString() + if let e = E(name: name) { + return e + } else { + return try throwOrIgnore() + } + } else { + let n = try nextSInt() + if let i = Int(exactly: n) { + if let e = E(rawValue: i) { + return e + } else { + return try throwOrIgnore() + } + } else { + throw JSONDecodingError.numberRange + } + } } - throw JSONDecodingError.malformedNumber - } - /// Return the contents of the following quoted string, - /// or throw an error if the next token is not a string. - internal mutating func nextQuotedString() throws -> String { - skipWhitespace() - guard hasMoreContent else { - throw JSONDecodingError.truncated - } - let c = currentByte - if c != asciiDoubleQuote { - throw JSONDecodingError.malformedString - } - if let s = parseOptionalQuotedString() { - return s - } else { - throw JSONDecodingError.malformedString + /// Helper for skipping a single-character token. + private mutating func skipRequiredCharacter(_ required: UInt8) throws { + skipWhitespace() + guard hasMoreContent else { + throw JSONDecodingError.truncated + } + let next = currentByte + if next == required { + advance() + return + } + throw JSONDecodingError.failure } - } - /// Return the contents of the following quoted string, - /// or nil if the next token is not a string. - /// This will only throw an error if the next token starts - /// out as a string but is malformed in some way. - internal mutating func nextOptionalQuotedString() throws -> String? { - skipWhitespace() - guard hasMoreContent else { - return nil + /// Skip "{", throw if that's not the next character. + internal mutating func skipRequiredObjectStart() throws { + try skipRequiredCharacter(asciiOpenCurlyBracket) // { + try incrementRecursionDepth() } - let c = currentByte - if c != asciiDoubleQuote { - return nil - } - return try nextQuotedString() - } - /// Return a Data with the decoded contents of the - /// following base-64 string. - /// - /// Notes on Google's implementation: - /// * Google's C++ implementation accepts arbitrary whitespace - /// mixed in with the base-64 characters - /// * Google's C++ implementation ignores missing '=' characters - /// but if present, there must be the exact correct number of them. - /// * Google's C++ implementation accepts both "regular" and - /// "web-safe" base-64 variants (it seems to prefer the - /// web-safe version as defined in RFC 4648 - internal mutating func nextBytesValue() throws -> Data { - skipWhitespace() - guard hasMoreContent else { - throw JSONDecodingError.truncated + /// Skip ",", throw if that's not the next character. + internal mutating func skipRequiredComma() throws { + try skipRequiredCharacter(asciiComma) } - return try parseBytes(source: source, index: &index, end: source.endIndex) - } - /// Private function to help parse keywords. - private mutating func skipOptionalKeyword(bytes: [UInt8]) -> Bool { - let start = index - for b in bytes { - guard hasMoreContent else { - index = start - return false - } - let c = currentByte - if c != b { - index = start - return false - } - advance() + /// Skip ":", throw if that's not the next character. + internal mutating func skipRequiredColon() throws { + try skipRequiredCharacter(asciiColon) } - if hasMoreContent { - let c = currentByte - if (c >= asciiUpperA && c <= asciiUpperZ) || - (c >= asciiLowerA && c <= asciiLowerZ) { - index = start - return false - } - } - return true - } - /// If the next token is the identifier "null", consume it and return true. - internal mutating func skipOptionalNull() -> Bool { - skipWhitespace() - if hasMoreContent && currentByte == asciiLowerN { - return skipOptionalKeyword(bytes: [ - asciiLowerN, asciiLowerU, asciiLowerL, asciiLowerL - ]) + /// Skip "[", throw if that's not the next character. + internal mutating func skipRequiredArrayStart() throws { + try skipRequiredCharacter(asciiOpenSquareBracket) // [ } - return false - } - /// Return the following Bool "true" or "false", including - /// full processing of quoted boolean values. (Used in map - /// keys, for instance.) - internal mutating func nextBool() throws -> Bool { - skipWhitespace() - guard hasMoreContent else { - throw JSONDecodingError.truncated - } - let c = currentByte - switch c { - case asciiLowerF: // f - if skipOptionalKeyword(bytes: [ - asciiLowerF, asciiLowerA, asciiLowerL, asciiLowerS, asciiLowerE - ]) { + /// Helper for skipping optional single-character tokens. + private mutating func skipOptionalCharacter(_ c: UInt8) -> Bool { + skipWhitespace() + if hasMoreContent && currentByte == c { + advance() + return true + } return false - } - case asciiLowerT: // t - if skipOptionalKeyword(bytes: [ - asciiLowerT, asciiLowerR, asciiLowerU, asciiLowerE - ]) { - return true - } - default: - break } - throw JSONDecodingError.malformedBool - } - /// Return the following Bool "true" or "false", including - /// full processing of quoted boolean values. (Used in map - /// keys, for instance.) - internal mutating func nextQuotedBool() throws -> Bool { - skipWhitespace() - guard hasMoreContent else { - throw JSONDecodingError.truncated - } - if currentByte != asciiDoubleQuote { - throw JSONDecodingError.unquotedMapKey + /// If the next non-whitespace character is "[", skip it + /// and return true. Otherwise, return false. + internal mutating func skipOptionalArrayStart() -> Bool { + skipOptionalCharacter(asciiOpenSquareBracket) } - if let s = parseOptionalQuotedString() { - switch s { - case "false": return false - case "true": return true - default: break - } - } - throw JSONDecodingError.malformedBool - } - /// Returns pointer/count spanning the UTF8 bytes of the next regular - /// key or nil if the key contains a backslash (and therefore requires - /// the full string-parsing logic to properly parse). - private mutating func nextOptionalKey() throws -> UnsafeRawBufferPointer? { - skipWhitespace() - let stringStart = index - guard hasMoreContent else { - throw JSONDecodingError.truncated - } - if currentByte != asciiDoubleQuote { - return nil - } - advance() - let nameStart = index - while hasMoreContent && currentByte != asciiDoubleQuote { - if currentByte == asciiBackslash { - index = stringStart // Reset to open quote - return nil - } - advance() - } - guard hasMoreContent else { - throw JSONDecodingError.truncated + /// If the next non-whitespace character is "]", skip it + /// and return true. Otherwise, return false. + internal mutating func skipOptionalArrayEnd() -> Bool { + skipOptionalCharacter(asciiCloseSquareBracket) // ]// ] } - let buff = UnsafeRawBufferPointer( - start: source.baseAddress! + nameStart, - count: index - nameStart) - advance() - return buff - } - /// Parse a field name, look it up in the provided field name map, - /// and return the corresponding field number. - /// - /// Throws if field name cannot be parsed. - /// If it encounters an unknown field name, it throws - /// unless `options.ignoreUnknownFields` is set, in which case - /// it silently skips it. - internal mutating func nextFieldNumber( - names: _NameMap, - messageType: Message.Type - ) throws -> Int? { - while true { - var fieldName: String - if let key = try nextOptionalKey() { - // Fast path: We parsed it as UTF8 bytes... - try skipRequiredCharacter(asciiColon) // : - if let fieldNumber = names.number(forJSONName: key) { - return fieldNumber - } - if let s = utf8ToString(bytes: key.baseAddress!, count: key.count) { - fieldName = s - } else { - throw JSONDecodingError.invalidUTF8 - } - } else { - // Slow path: We parsed a String; lookups from String are slower. - fieldName = try nextQuotedString() - try skipRequiredCharacter(asciiColon) // : - if let fieldNumber = names.number(forJSONName: fieldName) { - return fieldNumber - } - } - if let first = fieldName.utf8.first, first == UInt8(ascii: "["), - let last = fieldName.utf8.last, last == UInt8(ascii: "]") - { - fieldName.removeFirst() - fieldName.removeLast() - if let fieldNumber = extensions.fieldNumberForProto(messageType: messageType, protoFieldName: fieldName) { - return fieldNumber - } - } - if !options.ignoreUnknownFields { - throw JSONDecodingError.unknownField(fieldName) - } - // Unknown field, skip it and try to parse the next field name - try skipValue() - if skipOptionalObjectEnd() { - return nil - } - try skipRequiredComma() + /// If the next non-whitespace character is "}", skip it + /// and return true. Otherwise, return false. + internal mutating func skipOptionalObjectEnd() -> Bool { + let result = skipOptionalCharacter(asciiCloseCurlyBracket) // } + if result { + decrementRecursionDepth() + } + return result } - } - /// Parse the next token as a string or numeric enum value. Throws - /// unrecognizedEnumValue if the string/number can't initialize the - /// enum. Will throw other errors if the JSON is malformed. - internal mutating func nextEnumValue() throws -> E { - skipWhitespace() - guard hasMoreContent else { - throw JSONDecodingError.truncated - } - if currentByte == asciiDoubleQuote { - if let name = try nextOptionalKey() { - if let e = E(rawUTF8: name) { - return e + /// Return the next complete JSON structure as a string. + /// For example, this might return "true", or "123.456", + /// or "{\"foo\": 7, \"bar\": [8, 9]}" + /// + /// Used by Any to get the upcoming JSON value as a string. + /// Note: The value might be an object or array. + internal mutating func skip() throws -> String { + skipWhitespace() + let start = index + try skipValue() + if let s = utf8ToString(bytes: source, start: start, end: index) { + return s } else { - throw JSONDecodingError.unrecognizedEnumValue - } - } - let name = try nextQuotedString() - if let e = E(name: name) { - return e - } else { - throw JSONDecodingError.unrecognizedEnumValue - } - } else { - let n = try nextSInt() - if let i = Int(exactly: n) { - if let e = E(rawValue: i) { - return e - } else { - throw JSONDecodingError.unrecognizedEnumValue + throw JSONDecodingError.invalidUTF8 } - } else { - throw JSONDecodingError.numberRange - } - } - } - - /// Helper for skipping a single-character token. - private mutating func skipRequiredCharacter(_ required: UInt8) throws { - skipWhitespace() - guard hasMoreContent else { - throw JSONDecodingError.truncated - } - let next = currentByte - if next == required { - advance() - return - } - throw JSONDecodingError.failure - } - - /// Skip "{", throw if that's not the next character - internal mutating func skipRequiredObjectStart() throws { - try skipRequiredCharacter(asciiOpenCurlyBracket) // { - try incrementRecursionDepth() - } - - /// Skip ",", throw if that's not the next character - internal mutating func skipRequiredComma() throws { - try skipRequiredCharacter(asciiComma) - } - - /// Skip ":", throw if that's not the next character - internal mutating func skipRequiredColon() throws { - try skipRequiredCharacter(asciiColon) - } - - /// Skip "[", throw if that's not the next character - internal mutating func skipRequiredArrayStart() throws { - try skipRequiredCharacter(asciiOpenSquareBracket) // [ - } - - /// Helper for skipping optional single-character tokens - private mutating func skipOptionalCharacter(_ c: UInt8) -> Bool { - skipWhitespace() - if hasMoreContent && currentByte == c { - advance() - return true - } - return false - } - - /// If the next non-whitespace character is "[", skip it - /// and return true. Otherwise, return false. - internal mutating func skipOptionalArrayStart() -> Bool { - return skipOptionalCharacter(asciiOpenSquareBracket) - } - - /// If the next non-whitespace character is "]", skip it - /// and return true. Otherwise, return false. - internal mutating func skipOptionalArrayEnd() -> Bool { - return skipOptionalCharacter(asciiCloseSquareBracket) // ] - } - - /// If the next non-whitespace character is "}", skip it - /// and return true. Otherwise, return false. - internal mutating func skipOptionalObjectEnd() -> Bool { - let result = skipOptionalCharacter(asciiCloseCurlyBracket) // } - if result { - decrementRecursionDepth() - } - return result - } - - /// Return the next complete JSON structure as a string. - /// For example, this might return "true", or "123.456", - /// or "{\"foo\": 7, \"bar\": [8, 9]}" - /// - /// Used by Any to get the upcoming JSON value as a string. - /// Note: The value might be an object or array. - internal mutating func skip() throws -> String { - skipWhitespace() - let start = index - try skipValue() - if let s = utf8ToString(bytes: source, start: start, end: index) { - return s - } else { - throw JSONDecodingError.invalidUTF8 } - } - /// Advance index past the next value. This is used - /// by skip() and by unknown field handling. - /// Note: This handles objects {...} recursively but arrays [...] non-recursively - /// This avoids us requiring excessive stack space for deeply nested - /// arrays (which are not included in the recursion budget check). - private mutating func skipValue() throws { - skipWhitespace() - var totalArrayDepth = 0 - while true { - var arrayDepth = 0 - while skipOptionalArrayStart() { - arrayDepth += 1 - } - guard hasMoreContent else { - throw JSONDecodingError.truncated - } - switch currentByte { - case asciiDoubleQuote: // " begins a string - try skipString() - case asciiOpenCurlyBracket: // { begins an object - try skipObject() - case asciiCloseSquareBracket: // ] ends an empty array - if arrayDepth == 0 { - throw JSONDecodingError.failure - } - // We also close out [[]] or [[[]]] here - while arrayDepth > 0 && skipOptionalArrayEnd() { - arrayDepth -= 1 + /// Advance index past the next value. This is used + /// by skip() and by unknown field handling. + /// Note: This handles objects {...} recursively but arrays [...] non-recursively + /// This avoids us requiring excessive stack space for deeply nested + /// arrays (which are not included in the recursion budget check). + private mutating func skipValue() throws { + skipWhitespace() + var totalArrayDepth = 0 + while true { + var arrayDepth = 0 + while skipOptionalArrayStart() { + arrayDepth += 1 } - case asciiLowerN: // n must be null - if !skipOptionalKeyword(bytes: [ - asciiLowerN, asciiLowerU, asciiLowerL, asciiLowerL - ]) { + guard hasMoreContent else { throw JSONDecodingError.truncated } - case asciiLowerF: // f must be false - if !skipOptionalKeyword(bytes: [ - asciiLowerF, asciiLowerA, asciiLowerL, asciiLowerS, asciiLowerE - ]) { - throw JSONDecodingError.truncated + switch currentByte { + case asciiDoubleQuote: // " begins a string + try skipString() + case asciiOpenCurlyBracket: // { begins an object + try skipObject() + case asciiCloseSquareBracket: // ] ends an empty array + if arrayDepth == 0 { + throw JSONDecodingError.failure + } + // We also close out [[]] or [[[]]] here + while arrayDepth > 0 && skipOptionalArrayEnd() { + arrayDepth -= 1 + } + case asciiLowerN: // n must be null + if !skipOptionalKeyword(bytes: [ + asciiLowerN, asciiLowerU, asciiLowerL, asciiLowerL, + ]) { + throw JSONDecodingError.truncated + } + case asciiLowerF: // f must be false + if !skipOptionalKeyword(bytes: [ + asciiLowerF, asciiLowerA, asciiLowerL, asciiLowerS, asciiLowerE, + ]) { + throw JSONDecodingError.truncated + } + case asciiLowerT: // t must be true + if !skipOptionalKeyword(bytes: [ + asciiLowerT, asciiLowerR, asciiLowerU, asciiLowerE, + ]) { + throw JSONDecodingError.truncated + } + default: // everything else is a number token + _ = try nextDouble() } - case asciiLowerT: // t must be true - if !skipOptionalKeyword(bytes: [ - asciiLowerT, asciiLowerR, asciiLowerU, asciiLowerE - ]) { - throw JSONDecodingError.truncated + totalArrayDepth += arrayDepth + while totalArrayDepth > 0 && skipOptionalArrayEnd() { + totalArrayDepth -= 1 + } + if totalArrayDepth > 0 { + try skipRequiredComma() + } else { + return } - default: // everything else is a number token - _ = try nextDouble() } - totalArrayDepth += arrayDepth - while totalArrayDepth > 0 && skipOptionalArrayEnd() { - totalArrayDepth -= 1 + } + + /// Advance the index past the next complete {...} construct. + private mutating func skipObject() throws { + try skipRequiredObjectStart() + if skipOptionalObjectEnd() { + return } - if totalArrayDepth > 0 { + while true { + skipWhitespace() + try skipString() + try skipRequiredColon() + try skipValue() + if skipOptionalObjectEnd() { + return + } try skipRequiredComma() - } else { - return } } - } - - /// Advance the index past the next complete {...} construct. - private mutating func skipObject() throws { - try skipRequiredObjectStart() - if skipOptionalObjectEnd() { - return - } - while true { - skipWhitespace() - try skipString() - try skipRequiredColon() - try skipValue() - if skipOptionalObjectEnd() { - return - } - try skipRequiredComma() - } - } - /// Advance the index past the next complete quoted string. - /// - // Caveat: This does not fully validate; it will accept - // strings that have malformed \ escapes. - // - // It would be nice to do better, but I don't think it's critical, - // since there are many reasons that strings (and other tokens for - // that matter) may be skippable but not parseable. For example: - // Old clients that don't know new field types will skip fields - // they don't know; newer clients may reject the same input due to - // schema mismatches or other issues. - private mutating func skipString() throws { - guard hasMoreContent else { - throw JSONDecodingError.truncated - } - if currentByte != asciiDoubleQuote { - throw JSONDecodingError.malformedString - } - advance() - while hasMoreContent { - let c = currentByte - switch c { - case asciiDoubleQuote: - advance() - return - case asciiBackslash: - advance() + /// Advance the index past the next complete quoted string. + /// + // Caveat: This does not fully validate; it will accept + // strings that have malformed \ escapes. + // + // It would be nice to do better, but I don't think it's critical, + // since there are many reasons that strings (and other tokens for + // that matter) may be skippable but not parsable. For example: + // Old clients that don't know new field types will skip fields + // they don't know; newer clients may reject the same input due to + // schema mismatches or other issues. + private mutating func skipString() throws { guard hasMoreContent else { - throw JSONDecodingError.truncated + throw JSONDecodingError.truncated + } + if currentByte != asciiDoubleQuote { + throw JSONDecodingError.malformedString } advance() - default: - advance() - } + while hasMoreContent { + let c = currentByte + switch c { + case asciiDoubleQuote: + advance() + return + case asciiBackslash: + advance() + guard hasMoreContent else { + throw JSONDecodingError.truncated + } + advance() + default: + advance() + } + } + throw JSONDecodingError.truncated } - throw JSONDecodingError.truncated - } } diff --git a/Sources/SwiftProtobuf/MathUtils.swift b/Sources/SwiftProtobuf/MathUtils.swift index 2e8550b9c..cb8da925b 100644 --- a/Sources/SwiftProtobuf/MathUtils.swift +++ b/Sources/SwiftProtobuf/MathUtils.swift @@ -21,7 +21,7 @@ import Foundation /// - a: The dividend. Can be positive, 0 or negative. /// - b: The divisor. This must be positive, and is an error if 0 or negative. /// - Returns: The unique value r such that 0 <= r < b and b * q + r = a for some q. -internal func mod(_ a: T, _ b: T) -> T { +internal func mod(_ a: T, _ b: T) -> T { assert(b > 0) let r = a % b return r >= 0 ? r : r + b @@ -34,7 +34,7 @@ internal func mod(_ a: T, _ b: T) -> T { /// - a: The dividend. Can be positive, 0 or negative. /// - b: The divisor. This must be positive, and is an error if 0 or negative. /// - Returns: The unique value q such that for some 0 <= r < b, b * q + r = a. -internal func div(_ a: T, _ b: T) -> T { +internal func div(_ a: T, _ b: T) -> T { assert(b > 0) return a >= 0 ? a / b : (a + 1) / b - 1 } diff --git a/Sources/SwiftProtobuf/Message+AnyAdditions.swift b/Sources/SwiftProtobuf/Message+AnyAdditions.swift index 67d317820..be0946620 100644 --- a/Sources/SwiftProtobuf/Message+AnyAdditions.swift +++ b/Sources/SwiftProtobuf/Message+AnyAdditions.swift @@ -13,33 +13,33 @@ // ----------------------------------------------------------------------------- extension Message { - /// Initialize this message from the provided `google.protobuf.Any` - /// well-known type. - /// - /// This corresponds to the `unpack` method in the Google C++ API. - /// - /// If the Any object was decoded from Protobuf Binary or JSON - /// format, then the enclosed field data was stored and is not - /// fully decoded until you unpack the Any object into a message. - /// As such, this method will typically need to perform a full - /// deserialization of the enclosed data and can fail for any - /// reason that deserialization can fail. - /// - /// See `Google_Protobuf_Any.unpackTo()` for more discussion. - /// - /// - Parameter unpackingAny: the message to decode. - /// - Parameter extensions: An `ExtensionMap` used to look up and decode any - /// extensions in this message or messages nested within this message's - /// fields. - /// - Parameter options: The BinaryDecodingOptions to use. - /// - Throws: an instance of `AnyUnpackError`, `JSONDecodingError`, or - /// `BinaryDecodingError` on failure. - public init( - unpackingAny: Google_Protobuf_Any, - extensions: ExtensionMap? = nil, - options: BinaryDecodingOptions = BinaryDecodingOptions() - ) throws { - self.init() - try unpackingAny._storage.unpackTo(target: &self, extensions: extensions, options: options) - } + /// Initialize this message from the provided `google.protobuf.Any` + /// well-known type. + /// + /// This corresponds to the `unpack` method in the Google C++ API. + /// + /// If the Any object was decoded from Protobuf Binary or JSON + /// format, then the enclosed field data was stored and is not + /// fully decoded until you unpack the Any object into a message. + /// As such, this method will typically need to perform a full + /// deserialization of the enclosed data and can fail for any + /// reason that deserialization can fail. + /// + /// See `Google_Protobuf_Any.unpackTo()` for more discussion. + /// + /// - Parameter unpackingAny: the message to decode. + /// - Parameter extensions: An `ExtensionMap` used to look up and decode any + /// extensions in this message or messages nested within this message's + /// fields. + /// - Parameter options: The BinaryDecodingOptions to use. + /// - Throws: an instance of ``AnyUnpackError``, ``JSONDecodingError``, or + /// ``BinaryDecodingError`` on failure. + public init( + unpackingAny: Google_Protobuf_Any, + extensions: (any ExtensionMap)? = nil, + options: BinaryDecodingOptions = BinaryDecodingOptions() + ) throws { + self.init() + try unpackingAny._storage.unpackTo(target: &self, extensions: extensions, options: options) + } } diff --git a/Sources/SwiftProtobuf/Message+BinaryAdditions.swift b/Sources/SwiftProtobuf/Message+BinaryAdditions.swift index 173cff947..00522652d 100644 --- a/Sources/SwiftProtobuf/Message+BinaryAdditions.swift +++ b/Sources/SwiftProtobuf/Message+BinaryAdditions.swift @@ -16,189 +16,204 @@ import Foundation /// Binary encoding and decoding methods for messages. extension Message { - /// Returns a `Data` value containing the Protocol Buffer binary format - /// serialization of the message. - /// - /// - Parameters: - /// - partial: If `false` (the default), this method will check - /// `Message.isInitialized` before encoding to verify that all required - /// fields are present. If any are missing, this method throws - /// `BinaryEncodingError.missingRequiredFields`. - /// - Returns: A `Data` value containing the binary serialization of the - /// message. - /// - Throws: `BinaryEncodingError` if encoding fails. - public func serializedData(partial: Bool = false) throws -> Data { - if !partial && !isInitialized { - throw BinaryEncodingError.missingRequiredFields + /// Returns a ``SwiftProtobufContiguousBytes`` instance containing the Protocol Buffer binary + /// format serialization of the message. + /// + /// - Parameters: + /// - partial: If `false` (the default), this method will check + /// `Message.isInitialized` before encoding to verify that all required + /// fields are present. If any are missing, this method throws. + /// ``BinaryEncodingError/missingRequiredFields``. + /// - options: The ``BinaryEncodingOptions`` to use. + /// - Returns: A ``SwiftProtobufContiguousBytes`` instance containing the binary serialization + /// of the message. + /// + /// - Throws: ``SwiftProtobufError`` or ``BinaryEncodingError`` if encoding fails. + public func serializedBytes( + partial: Bool = false, + options: BinaryEncodingOptions = BinaryEncodingOptions() + ) throws -> Bytes { + if !partial && !isInitialized { + throw BinaryEncodingError.missingRequiredFields + } + + // Note that this assumes `options` will not change the required size. + let requiredSize = try serializedDataSize() + + // Messages have a 2GB limit in encoded size, the upstread C++ code + // (message_lite, etc.) does this enforcement also. + // https://protobuf.dev/programming-guides/encoding/#cheat-sheet + // + // Testing here enables the limit without adding extra conditionals to all + // the places that encode message fields (or strings/bytes fields), keeping + // the overhead of the check to a minimum. + guard requiredSize < 0x7fff_ffff else { + // Adding a new error is a breaking change. + throw BinaryEncodingError.missingRequiredFields + } + + var data = Bytes(repeating: 0, count: requiredSize) + try data.withUnsafeMutableBytes { (body: UnsafeMutableRawBufferPointer) in + var visitor = BinaryEncodingVisitor(forWritingInto: body, options: options) + try traverse(visitor: &visitor) + // Currently not exposing this from the api because it really would be + // an internal error in the library and should never happen. + assert(visitor.encoder.remainder.count == 0) + } + return data } - let requiredSize = try serializedDataSize() - var data = Data(count: requiredSize) - try data.withUnsafeMutableBytes { (body: UnsafeMutableRawBufferPointer) in - if let baseAddress = body.baseAddress, body.count > 0 { - var visitor = BinaryEncodingVisitor(forWritingInto: baseAddress) + + /// Returns the size in bytes required to encode the message in binary format. + /// This is used by `serializedData()` to precalculate the size of the buffer + /// so that encoding can proceed without bounds checks or reallocation. + internal func serializedDataSize() throws -> Int { + // Note: since this api is internal, it doesn't currently worry about + // needing a partial argument to handle required fields. If this become + // public, it will need that added. + var visitor = BinaryEncodingSizeVisitor() try traverse(visitor: &visitor) - // Currently not exposing this from the api because it really would be - // an internal error in the library and should never happen. - assert(requiredSize == visitor.encoder.distance(pointer: baseAddress)) - } + return visitor.serializedSize } - return data - } - /// Returns the size in bytes required to encode the message in binary format. - /// This is used by `serializedData()` to precalculate the size of the buffer - /// so that encoding can proceed without bounds checks or reallocation. - internal func serializedDataSize() throws -> Int { - // Note: since this api is internal, it doesn't currently worry about - // needing a partial argument to handle proto2 syntax required fields. - // If this become public, it will need that added. - var visitor = BinaryEncodingSizeVisitor() - try traverse(visitor: &visitor) - return visitor.serializedSize - } - - /// Creates a new message by decoding the given `Data` value containing a - /// serialized message in Protocol Buffer binary format. - /// - /// - Parameters: - /// - serializedData: The binary-encoded message data to decode. - /// - extensions: An `ExtensionMap` used to look up and decode any - /// extensions in this message or messages nested within this message's - /// fields. - /// - partial: If `false` (the default), this method will check - /// `Message.isInitialized` before encoding to verify that all required - /// fields are present. If any are missing, this method throws - /// `BinaryEncodingError.missingRequiredFields`. - /// - options: The BinaryDecodingOptions to use. - /// - Throws: `BinaryDecodingError` if decoding fails. - @inlinable - public init( - serializedData data: Data, - extensions: ExtensionMap? = nil, - partial: Bool = false, - options: BinaryDecodingOptions = BinaryDecodingOptions() - ) throws { - self.init() -#if swift(>=5.0) - try merge(contiguousBytes: data, extensions: extensions, partial: partial, options: options) -#else - try merge(serializedData: data, extensions: extensions, partial: partial, options: options) -#endif - } - -#if swift(>=5.0) - /// Creates a new message by decoding the given `ContiguousBytes` value - /// containing a serialized message in Protocol Buffer binary format. - /// - /// - Parameters: - /// - contiguousBytes: The binary-encoded message data to decode. - /// - extensions: An `ExtensionMap` used to look up and decode any - /// extensions in this message or messages nested within this message's - /// fields. - /// - partial: If `false` (the default), this method will check - /// `Message.isInitialized` before encoding to verify that all required - /// fields are present. If any are missing, this method throws - /// `BinaryEncodingError.missingRequiredFields`. - /// - options: The BinaryDecodingOptions to use. - /// - Throws: `BinaryDecodingError` if decoding fails. - @inlinable - public init( - contiguousBytes bytes: Bytes, - extensions: ExtensionMap? = nil, - partial: Bool = false, - options: BinaryDecodingOptions = BinaryDecodingOptions() - ) throws { - self.init() - try merge(contiguousBytes: bytes, extensions: extensions, partial: partial, options: options) - } -#endif // #if swift(>=5.0) + /// Creates a new message by decoding the given `SwiftProtobufContiguousBytes` value + /// containing a serialized message in Protocol Buffer binary format. + /// + /// - Parameters: + /// - serializedBytes: The binary-encoded message data to decode. + /// - extensions: An ``ExtensionMap`` used to look up and decode any + /// extensions in this message or messages nested within this message's + /// fields. + /// - partial: If `false` (the default), this method will check + /// ``Message/isInitialized-6abgi`` after decoding to verify that all required + /// fields are present. If any are missing, this method throws + /// ``BinaryDecodingError/missingRequiredFields``. + /// - options: The ``BinaryDecodingOptions`` to use. + /// - Throws: ``BinaryDecodingError`` if decoding fails. + @inlinable + public init( + serializedBytes bytes: Bytes, + extensions: (any ExtensionMap)? = nil, + partial: Bool = false, + options: BinaryDecodingOptions = BinaryDecodingOptions() + ) throws { + self.init() + try merge(serializedBytes: bytes, extensions: extensions, partial: partial, options: options) + } - /// Updates the message by decoding the given `Data` value containing a - /// serialized message in Protocol Buffer binary format into the receiver. - /// - /// - Note: If this method throws an error, the message may still have been - /// partially mutated by the binary data that was decoded before the error - /// occurred. - /// - /// - Parameters: - /// - serializedData: The binary-encoded message data to decode. - /// - extensions: An `ExtensionMap` used to look up and decode any - /// extensions in this message or messages nested within this message's - /// fields. - /// - partial: If `false` (the default), this method will check - /// `Message.isInitialized` before encoding to verify that all required - /// fields are present. If any are missing, this method throws - /// `BinaryEncodingError.missingRequiredFields`. - /// - options: The BinaryDecodingOptions to use. - /// - Throws: `BinaryDecodingError` if decoding fails. - @inlinable - public mutating func merge( - serializedData data: Data, - extensions: ExtensionMap? = nil, - partial: Bool = false, - options: BinaryDecodingOptions = BinaryDecodingOptions() - ) throws { -#if swift(>=5.0) - try merge(contiguousBytes: data, extensions: extensions, partial: partial, options: options) -#else - try data.withUnsafeBytes { (body: UnsafeRawBufferPointer) in - try _merge(rawBuffer: body, extensions: extensions, partial: partial, options: options) + #if compiler(>=6.2) + /// Creates a new message by decoding the bytes provided by a `RawSpan` + /// containing a serialized message in Protocol Buffer binary format. + /// + /// - Parameters: + /// - serializedBytes: The `RawSpan` of binary-encoded message data to decode. + /// - extensions: An ``ExtensionMap`` used to look up and decode any + /// extensions in this message or messages nested within this message's + /// fields. + /// - partial: If `false` (the default), this method will check + /// ``Message/isInitialized-6abgi`` after decoding to verify that all required + /// fields are present. If any are missing, this method throws + /// ``BinaryDecodingError/missingRequiredFields``. + /// - options: The ``BinaryDecodingOptions`` to use. + /// - Throws: ``BinaryDecodingError`` if decoding fails. + @inlinable + @available(macOS 10.14.4, iOS 12.2, watchOS 5.2, tvOS 12.2, visionOS 1.0, *) + public init( + serializedBytes bytes: RawSpan, + extensions: (any ExtensionMap)? = nil, + partial: Bool = false, + options: BinaryDecodingOptions = BinaryDecodingOptions() + ) throws { + self.init() + try merge(serializedBytes: bytes, extensions: extensions, partial: partial, options: options) } -#endif // swift(>=5.0) - } + #endif -#if swift(>=5.0) - /// Updates the message by decoding the given `ContiguousBytes` value - /// containing a serialized message in Protocol Buffer binary format into the - /// receiver. - /// - /// - Note: If this method throws an error, the message may still have been - /// partially mutated by the binary data that was decoded before the error - /// occurred. - /// - /// - Parameters: - /// - contiguousBytes: The binary-encoded message data to decode. - /// - extensions: An `ExtensionMap` used to look up and decode any - /// extensions in this message or messages nested within this message's - /// fields. - /// - partial: If `false` (the default), this method will check - /// `Message.isInitialized` before encoding to verify that all required - /// fields are present. If any are missing, this method throws - /// `BinaryEncodingError.missingRequiredFields`. - /// - options: The BinaryDecodingOptions to use. - /// - Throws: `BinaryDecodingError` if decoding fails. - @inlinable - public mutating func merge( - contiguousBytes bytes: Bytes, - extensions: ExtensionMap? = nil, - partial: Bool = false, - options: BinaryDecodingOptions = BinaryDecodingOptions() - ) throws { - try bytes.withUnsafeBytes { (body: UnsafeRawBufferPointer) in - try _merge(rawBuffer: body, extensions: extensions, partial: partial, options: options) + /// Updates the message by decoding the given `SwiftProtobufContiguousBytes` value + /// containing a serialized message in Protocol Buffer binary format into the + /// receiver. + /// + /// - Note: If this method throws an error, the message may still have been + /// partially mutated by the binary data that was decoded before the error + /// occurred. + /// + /// - Parameters: + /// - serializedBytes: The binary-encoded message data to decode. + /// - extensions: An ``ExtensionMap`` used to look up and decode any + /// extensions in this message or messages nested within this message's + /// fields. + /// - partial: If `false` (the default), this method will check + /// ``Message/isInitialized-6abgi`` after decoding to verify that all required + /// fields are present. If any are missing, this method throws + /// ``BinaryDecodingError/missingRequiredFields``. + /// - options: The ``BinaryDecodingOptions`` to use. + /// - Throws: ``BinaryDecodingError`` if decoding fails. + @inlinable + public mutating func merge( + serializedBytes bytes: Bytes, + extensions: (any ExtensionMap)? = nil, + partial: Bool = false, + options: BinaryDecodingOptions = BinaryDecodingOptions() + ) throws { + try bytes.withUnsafeBytes { (body: UnsafeRawBufferPointer) in + try _merge(rawBuffer: body, extensions: extensions, partial: partial, options: options) + } } - } -#endif // swift(>=5.0) - // Helper for `merge()`s to keep the Decoder internal to SwiftProtobuf while - // allowing the generic over ContiguousBytes to get better codegen from the - // compiler by being `@inlinable`. - @usableFromInline - internal mutating func _merge( - rawBuffer body: UnsafeRawBufferPointer, - extensions: ExtensionMap?, - partial: Bool, - options: BinaryDecodingOptions - ) throws { - if let baseAddress = body.baseAddress, body.count > 0 { - var decoder = BinaryDecoder(forReadingFrom: baseAddress, - count: body.count, - options: options, - extensions: extensions) - try decoder.decodeFullMessage(message: &self) + #if compiler(>=6.2) + /// Updates the message by decoding the bytes provided by a `RawSpan` containing + /// a serialized message in Protocol Buffer binary format into the receiver. + /// + /// - Note: If this method throws an error, the message may still have been + /// partially mutated by the binary data that was decoded before the error + /// occurred. + /// + /// - Parameters: + /// - serializedBytes: The `RawSpan` of binary-encoded message data to decode. + /// - extensions: An ``ExtensionMap`` used to look up and decode any + /// extensions in this message or messages nested within this message's + /// fields. + /// - partial: If `false` (the default), this method will check + /// ``Message/isInitialized-6abgi`` after decoding to verify that all required + /// fields are present. If any are missing, this method throws + /// ``BinaryDecodingError/missingRequiredFields``. + /// - options: The ``BinaryDecodingOptions`` to use. + /// - Throws: ``BinaryDecodingError`` if decoding fails. + @inlinable + @available(macOS 10.14.4, iOS 12.2, watchOS 5.2, tvOS 12.2, visionOS 1.0, *) + public mutating func merge( + serializedBytes bytes: RawSpan, + extensions: (any ExtensionMap)? = nil, + partial: Bool = false, + options: BinaryDecodingOptions = BinaryDecodingOptions() + ) throws { + try bytes.withUnsafeBytes { (body: UnsafeRawBufferPointer) in + try _merge(rawBuffer: body, extensions: extensions, partial: partial, options: options) + } } - if !partial && !isInitialized { - throw BinaryDecodingError.missingRequiredFields + #endif + + // Helper for `merge()`s to keep the Decoder internal to SwiftProtobuf while + // allowing the generic over `SwiftProtobufContiguousBytes` to get better codegen from the + // compiler by being `@inlinable`. For some discussion on this see + // https://github.com/apple/swift-protobuf/pull/914#issuecomment-555458153 + @usableFromInline + internal mutating func _merge( + rawBuffer body: UnsafeRawBufferPointer, + extensions: (any ExtensionMap)?, + partial: Bool, + options: BinaryDecodingOptions + ) throws { + if let baseAddress = body.baseAddress, body.count > 0 { + var decoder = BinaryDecoder( + forReadingFrom: baseAddress, + count: body.count, + options: options, + extensions: extensions + ) + try decoder.decodeFullMessage(message: &self) + } + if !partial && !isInitialized { + throw BinaryDecodingError.missingRequiredFields + } } - } } diff --git a/Sources/SwiftProtobuf/Message+BinaryAdditions_Data.swift b/Sources/SwiftProtobuf/Message+BinaryAdditions_Data.swift new file mode 100644 index 000000000..d1ba7ce58 --- /dev/null +++ b/Sources/SwiftProtobuf/Message+BinaryAdditions_Data.swift @@ -0,0 +1,237 @@ +// Sources/SwiftProtobuf/Message+BinaryAdditions_Data.swift - Per-type binary coding +// +// Copyright (c) 2022 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// Extensions to `Message` to provide binary coding and decoding using ``Foundation/Data``. +/// +// ----------------------------------------------------------------------------- + +import Foundation + +/// Binary encoding and decoding methods for messages. +extension Message { + #if !REMOVE_DEPRECATED_APIS + /// Creates a new message by decoding the given `Data` value + /// containing a serialized message in Protocol Buffer binary format. + /// + /// - Parameters: + /// - serializedData: The binary-encoded message `Data` to decode. + /// - extensions: An ``ExtensionMap`` used to look up and decode any + /// extensions in this message or messages nested within this message's + /// fields. + /// - partial: If `false` (the default), this method will check + /// ``Message/isInitialized-6abgi`` after decoding to verify that all required + /// fields are present. If any are missing, this method throws + /// ``BinaryDecodingError/missingRequiredFields``. + /// - options: The ``BinaryDecodingOptions`` to use. + /// - Throws: ``BinaryDecodingError`` if decoding fails. + @inlinable + @available(*, deprecated, renamed: "init(serializedBytes:extensions:partial:options:)") + public init( + serializedData data: Data, + extensions: (any ExtensionMap)? = nil, + partial: Bool = false, + options: BinaryDecodingOptions = BinaryDecodingOptions() + ) throws { + self.init() + try merge(serializedBytes: data, extensions: extensions, partial: partial, options: options) + } + + /// Creates a new message by decoding the given `Foundation/ContiguousBytes` value + /// containing a serialized message in Protocol Buffer binary format. + /// + /// - Parameters: + /// - contiguousBytes: The binary-encoded message data to decode. + /// - extensions: An ``ExtensionMap`` used to look up and decode any + /// extensions in this message or messages nested within this message's + /// fields. + /// - partial: If `false` (the default), this method will check + /// ``Message/isInitialized-6abgi`` after decoding to verify that all required + /// fields are present. If any are missing, this method throws + /// ``SwiftProtobufError/BinaryDecoding/missingRequiredFields``. + /// - options: The ``BinaryDecodingOptions`` to use. + /// - Throws: ``SwiftProtobufError`` if decoding fails. + @inlinable + @_disfavoredOverload + @available(*, deprecated, renamed: "init(serializedBytes:extensions:partial:options:)") + public init( + contiguousBytes bytes: Bytes, + extensions: (any ExtensionMap)? = nil, + partial: Bool = false, + options: BinaryDecodingOptions = BinaryDecodingOptions() + ) throws { + self.init() + try merge(serializedBytes: bytes, extensions: extensions, partial: partial, options: options) + } + + /// Creates a new message by decoding the given `Foundation/ContiguousBytes` value + /// containing a serialized message in Protocol Buffer binary format. + /// + /// - Parameters: + /// - serializedBytes: The binary-encoded message data to decode. + /// - extensions: An ``ExtensionMap`` used to look up and decode any + /// extensions in this message or messages nested within this message's + /// fields. + /// - partial: If `false` (the default), this method will check + /// ``Message/isInitialized-6abgi`` after decoding to verify that all required + /// fields are present. If any are missing, this method throws + /// ``SwiftProtobufError/BinaryDecoding/missingRequiredFields``. + /// - options: The ``BinaryDecodingOptions`` to use. + /// - Throws: ``SwiftProtobufError`` if decoding fails. + @inlinable + @_disfavoredOverload + @available( + *, + deprecated, + message: + "Please conform your Bytes type to `SwiftProtobufContiguousBytes` instead of `Foundation.ContiguousBytes`." + ) + public init( + serializedBytes bytes: Bytes, + extensions: (any ExtensionMap)? = nil, + partial: Bool = false, + options: BinaryDecodingOptions = BinaryDecodingOptions() + ) throws { + self.init() + try merge(serializedBytes: bytes, extensions: extensions, partial: partial, options: options) + } + + /// Updates the message by decoding the given `Foundation/ContiguousBytes` value + /// containing a serialized message in Protocol Buffer binary format into the + /// receiver. + /// + /// - Note: If this method throws an error, the message may still have been + /// partially mutated by the binary data that was decoded before the error + /// occurred. + /// + /// - Parameters: + /// - contiguousBytes: The binary-encoded message data to decode. + /// - extensions: An ``ExtensionMap`` used to look up and decode any + /// extensions in this message or messages nested within this message's + /// fields. + /// - partial: If `false` (the default), this method will check + /// ``Message/isInitialized-6abgi`` after decoding to verify that all required + /// fields are present. If any are missing, this method throws + /// ``SwiftProtobufError/BinaryDecoding/missingRequiredFields``. + /// - options: The ``BinaryDecodingOptions`` to use. + /// - Throws: ``SwiftProtobufError`` if decoding fails. + @inlinable + @_disfavoredOverload + @available(*, deprecated, renamed: "merge(serializedBytes:extensions:partial:options:)") + public mutating func merge( + contiguousBytes bytes: Bytes, + extensions: (any ExtensionMap)? = nil, + partial: Bool = false, + options: BinaryDecodingOptions = BinaryDecodingOptions() + ) throws { + try bytes.withUnsafeBytes { (body: UnsafeRawBufferPointer) in + try _merge(rawBuffer: body, extensions: extensions, partial: partial, options: options) + } + } + + /// Updates the message by decoding the given `Foundation/ContiguousBytes` value + /// containing a serialized message in Protocol Buffer binary format into the + /// receiver. + /// + /// - Note: If this method throws an error, the message may still have been + /// partially mutated by the binary data that was decoded before the error + /// occurred. + /// + /// - Parameters: + /// - serializedBytes: The binary-encoded message data to decode. + /// - extensions: An ``ExtensionMap`` used to look up and decode any + /// extensions in this message or messages nested within this message's + /// fields. + /// - partial: If `false` (the default), this method will check + /// ``Message/isInitialized-6abgi`` after decoding to verify that all required + /// fields are present. If any are missing, this method throws + /// ``SwiftProtobufError/BinaryDecoding/missingRequiredFields``. + /// - options: The ``BinaryDecodingOptions`` to use. + /// - Throws: ``SwiftProtobufError`` if decoding fails. + @inlinable + @_disfavoredOverload + @available( + *, + deprecated, + message: + "Please conform your Bytes type to `SwiftProtobufContiguousBytes` instead of `Foundation.ContiguousBytes`." + ) + public mutating func merge( + serializedBytes bytes: Bytes, + extensions: (any ExtensionMap)? = nil, + partial: Bool = false, + options: BinaryDecodingOptions = BinaryDecodingOptions() + ) throws { + try bytes.withUnsafeBytes { (body: UnsafeRawBufferPointer) in + try _merge(rawBuffer: body, extensions: extensions, partial: partial, options: options) + } + } + #endif // !REMOVE_DEPRECATED_APIS + + /// Updates the message by decoding the given `Data` value + /// containing a serialized message in Protocol Buffer binary format into the + /// receiver. + /// + /// - Note: If this method throws an error, the message may still have been + /// partially mutated by the binary data that was decoded before the error + /// occurred. + /// + /// - Parameters: + /// - serializedData: The binary-encoded message data to decode. + /// - extensions: An ``ExtensionMap`` used to look up and decode any + /// extensions in this message or messages nested within this message's + /// fields. + /// - partial: If `false` (the default), this method will check + /// ``Message/isInitialized-6abgi`` after decoding to verify that all required + /// fields are present. If any are missing, this method throws + /// ``BinaryDecodingError/missingRequiredFields``. + /// - options: The ``BinaryDecodingOptions`` to use. + /// - Throws: ``BinaryDecodingError`` if decoding fails. + @inlinable + public mutating func merge( + serializedData data: Data, + extensions: (any ExtensionMap)? = nil, + partial: Bool = false, + options: BinaryDecodingOptions = BinaryDecodingOptions() + ) throws { + try merge(serializedBytes: data, extensions: extensions, partial: partial, options: options) + } + + /// Returns a `Data` instance containing the Protocol Buffer binary + /// format serialization of the message. + /// + /// - Parameters: + /// - partial: If `false` (the default), this method will check + /// ``Message/isInitialized-6abgi`` before encoding to verify that all required + /// fields are present. If any are missing, this method throws + /// ``BinaryEncodingError/missingRequiredFields``. + /// - Returns: A `Data` instance containing the binary serialization of the message. + /// - Throws: ``BinaryEncodingError`` if encoding fails. + public func serializedData(partial: Bool = false) throws -> Data { + try serializedBytes(partial: partial, options: BinaryEncodingOptions()) + } + + /// Returns a `Data` instance containing the Protocol Buffer binary + /// format serialization of the message. + /// + /// - Parameters: + /// - partial: If `false` (the default), this method will check + /// ``Message/isInitialized-6abgi`` before encoding to verify that all required + /// fields are present. If any are missing, this method throws + /// ``BinaryEncodingError/missingRequiredFields``. + /// - options: The ``BinaryEncodingOptions`` to use. + /// - Returns: A `Data` instance containing the binary serialization of the message. + /// - Throws: ``BinaryEncodingError`` if encoding fails. + public func serializedData( + partial: Bool = false, + options: BinaryEncodingOptions = BinaryEncodingOptions() + ) throws -> Data { + try serializedBytes(partial: partial, options: options) + } +} diff --git a/Sources/SwiftProtobuf/Message+FieldMask.swift b/Sources/SwiftProtobuf/Message+FieldMask.swift new file mode 100644 index 000000000..3ac8ac92f --- /dev/null +++ b/Sources/SwiftProtobuf/Message+FieldMask.swift @@ -0,0 +1,133 @@ +// Sources/SwiftProtobuf/Message+FieldMask.swift - Message field mask extensions +// +// Copyright (c) 2014 - 2023 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// Extend the Message types with FieldMask utilities. +/// +// ----------------------------------------------------------------------------- + +import Foundation + +extension Message { + + /// Checks whether the given path is valid for Message type. + /// + /// - Parameter path: Path to be checked + /// - Returns: Boolean determines path is valid. + public static func isPathValid( + _ path: String + ) -> Bool { + var message = Self() + return message.hasPath(path: path) + } + + internal mutating func hasPath(path: String) -> Bool { + do { + try set(path: path, value: nil, mergeOption: .init()) + return true + } catch let error as PathDecodingError { + return error != .pathNotFound + } catch { + return false + } + } + + internal mutating func isPathValid( + _ path: String + ) -> Bool { + hasPath(path: path) + } +} + +extension Google_Protobuf_FieldMask { + + /// Defines available options for merging two messages. + public struct MergeOptions { + + public init() {} + + /// The default merging behavior will append entries from the source + /// repeated field to the destination repeated field. If you only want + /// to keep the entries from the source repeated field, set this flag + /// to true. + public var replaceRepeatedFields = false + } +} + +extension Message { + + /// Merges fields specified in a FieldMask into another message. + /// + /// - Parameters: + /// - source: Message that should be merged to the original one. + /// - fieldMask: FieldMask specifies which fields should be merged. + public mutating func merge( + from source: Self, + fieldMask: Google_Protobuf_FieldMask, + mergeOption: Google_Protobuf_FieldMask.MergeOptions = .init() + ) throws { + var visitor = PathVisitor() + try source.traverse(visitor: &visitor) + let values = visitor.values + // TODO: setting all values with only one decoding + for path in fieldMask.paths { + try? set( + path: path, + value: values[path], + mergeOption: mergeOption + ) + } + } +} + +extension Message where Self: Equatable, Self: _ProtoNameProviding { + + // TODO: Re-implement using clear fields instead of copying message + + /// Removes from 'message' any field that is not represented in the given + /// FieldMask. If the FieldMask is empty, does nothing. + /// + /// - Parameter fieldMask: FieldMask specifies which fields should be kept. + /// - Returns: Boolean determines if the message is modified + @discardableResult + public mutating func trim( + keeping fieldMask: Google_Protobuf_FieldMask + ) -> Bool { + if !fieldMask.isValid(for: Self.self) { + return false + } + if fieldMask.paths.isEmpty { + return false + } + var tmp = Self(removingAllFieldsOf: self) + do { + try tmp.merge(from: self, fieldMask: fieldMask) + let changed = tmp != self + self = tmp + return changed + } catch { + return false + } + } +} + +extension Message { + fileprivate init(removingAllFieldsOf message: Self) { + let newMessage: Self = .init() + if var newExtensible = newMessage as? any ExtensibleMessage, + let extensible = message as? any ExtensibleMessage + { + newExtensible._protobuf_extensionFieldValues = extensible._protobuf_extensionFieldValues + self = newExtensible as? Self ?? newMessage + } else { + self = newMessage + } + self.unknownFields = message.unknownFields + } +} diff --git a/Sources/SwiftProtobuf/Message+JSONAdditions.swift b/Sources/SwiftProtobuf/Message+JSONAdditions.swift index 56236db73..a8c14cd37 100644 --- a/Sources/SwiftProtobuf/Message+JSONAdditions.swift +++ b/Sources/SwiftProtobuf/Message+JSONAdditions.swift @@ -16,135 +16,138 @@ import Foundation /// JSON encoding and decoding methods for messages. extension Message { - /// Returns a string containing the JSON serialization of the message. - /// - /// Unlike binary encoding, presence of required fields is not enforced when - /// serializing to JSON. - /// - /// - Returns: A string containing the JSON serialization of the message. - /// - Parameters: - /// - options: The JSONEncodingOptions to use. - /// - Throws: `JSONEncodingError` if encoding fails. - public func jsonString( - options: JSONEncodingOptions = JSONEncodingOptions() - ) throws -> String { - if let m = self as? _CustomJSONCodable { - return try m.encodedJSONString(options: options) + /// Returns a string containing the JSON serialization of the message. + /// + /// Unlike binary encoding, presence of required fields is not enforced when + /// serializing to JSON. + /// + /// - Returns: A string containing the JSON serialization of the message. + /// - Parameters: + /// - options: The JSONEncodingOptions to use. + /// - Throws: ``SwiftProtobufError`` or ``JSONEncodingError`` if encoding fails. + public func jsonString( + options: JSONEncodingOptions = JSONEncodingOptions() + ) throws -> String { + if let m = self as? (any _CustomJSONCodable) { + return try m.encodedJSONString(options: options) + } + let data: [UInt8] = try jsonUTF8Bytes(options: options) + return String(decoding: data, as: UTF8.self) } - let data = try jsonUTF8Data(options: options) - return String(data: data, encoding: String.Encoding.utf8)! - } - /// Returns a Data containing the UTF-8 JSON serialization of the message. - /// - /// Unlike binary encoding, presence of required fields is not enforced when - /// serializing to JSON. - /// - /// - Returns: A Data containing the JSON serialization of the message. - /// - Parameters: - /// - options: The JSONEncodingOptions to use. - /// - Throws: `JSONEncodingError` if encoding fails. - public func jsonUTF8Data( - options: JSONEncodingOptions = JSONEncodingOptions() - ) throws -> Data { - if let m = self as? _CustomJSONCodable { - let string = try m.encodedJSONString(options: options) - let data = string.data(using: String.Encoding.utf8)! // Cannot fail! - return data + /// Returns a `SwiftProtobufContiguousBytes` containing the UTF-8 JSON serialization of the message. + /// + /// Unlike binary encoding, presence of required fields is not enforced when + /// serializing to JSON. + /// + /// - Returns: A `SwiftProtobufContiguousBytes` containing the JSON serialization of the message. + /// - Parameters: + /// - options: The JSONEncodingOptions to use. + /// - Throws: ``SwiftProtobufError`` or ``JSONEncodingError`` if encoding fails. + public func jsonUTF8Bytes( + options: JSONEncodingOptions = JSONEncodingOptions() + ) throws -> Bytes { + if let m = self as? (any _CustomJSONCodable) { + let string = try m.encodedJSONString(options: options) + return Bytes(string.utf8) + } + var visitor = try JSONEncodingVisitor(type: Self.self, options: options) + visitor.startObject(message: self) + try traverse(visitor: &visitor) + visitor.endObject() + return Bytes(visitor.dataResult) } - var visitor = try JSONEncodingVisitor(type: Self.self, options: options) - visitor.startObject(message: self) - try traverse(visitor: &visitor) - visitor.endObject() - return visitor.dataResult - } - /// Creates a new message by decoding the given string containing a - /// serialized message in JSON format. - /// - /// - Parameter jsonString: The JSON-formatted string to decode. - /// - Parameter options: The JSONDecodingOptions to use. - /// - Throws: `JSONDecodingError` if decoding fails. + /// Creates a new message by decoding the given string containing a + /// serialized message in JSON format. + /// + /// - Parameter jsonString: The JSON-formatted string to decode. + /// - Parameter options: The JSONDecodingOptions to use. + /// - Throws: ``SwiftProtobufError`` or ``JSONDecodingError`` if decoding fails. public init( - jsonString: String, - options: JSONDecodingOptions = JSONDecodingOptions() - ) throws { - try self.init(jsonString: jsonString, extensions: nil, options: options) - } - - /// Creates a new message by decoding the given string containing a - /// serialized message in JSON format. - /// - /// - Parameter jsonString: The JSON-formatted string to decode. - /// - Parameter extensions: An ExtensionMap for looking up extensions by name - /// - Parameter options: The JSONDecodingOptions to use. - /// - Throws: `JSONDecodingError` if decoding fails. - public init( - jsonString: String, - extensions: ExtensionMap? = nil, - options: JSONDecodingOptions = JSONDecodingOptions() - ) throws { - if jsonString.isEmpty { - throw JSONDecodingError.truncated + jsonString: String, + options: JSONDecodingOptions = JSONDecodingOptions() + ) throws { + try self.init(jsonString: jsonString, extensions: nil, options: options) } - if let data = jsonString.data(using: String.Encoding.utf8) { - try self.init(jsonUTF8Data: data, extensions: extensions, options: options) - } else { - throw JSONDecodingError.truncated + + /// Creates a new message by decoding the given string containing a + /// serialized message in JSON format. + /// + /// - Parameter jsonString: The JSON-formatted string to decode. + /// - Parameter extensions: An ExtensionMap for looking up extensions by name + /// - Parameter options: The JSONDecodingOptions to use. + /// - Throws: ``SwiftProtobufError`` or ``JSONDecodingError`` if decoding fails. + public init( + jsonString: String, + extensions: (any ExtensionMap)? = nil, + options: JSONDecodingOptions = JSONDecodingOptions() + ) throws { + if jsonString.isEmpty { + throw JSONDecodingError.truncated + } + if let data = jsonString.data(using: String.Encoding.utf8) { + try self.init(jsonUTF8Bytes: data, extensions: extensions, options: options) + } else { + throw JSONDecodingError.truncated + } } - } - /// Creates a new message by decoding the given `Data` containing a - /// serialized message in JSON format, interpreting the data as UTF-8 encoded - /// text. - /// - /// - Parameter jsonUTF8Data: The JSON-formatted data to decode, represented - /// as UTF-8 encoded text. - /// - Parameter options: The JSONDecodingOptions to use. - /// - Throws: `JSONDecodingError` if decoding fails. - public init( - jsonUTF8Data: Data, - options: JSONDecodingOptions = JSONDecodingOptions() - ) throws { - try self.init(jsonUTF8Data: jsonUTF8Data, extensions: nil, options: options) - } + /// Creates a new message by decoding the given `SwiftProtobufContiguousBytes` + /// containing a serialized message in JSON format, interpreting the data as UTF-8 encoded + /// text. + /// + /// - Parameter jsonUTF8Bytes: The JSON-formatted data to decode, represented + /// as UTF-8 encoded text. + /// - Parameter options: The JSONDecodingOptions to use. + /// - Throws: ``SwiftProtobufError`` or ``JSONDecodingError`` if decoding fails. + public init( + jsonUTF8Bytes: Bytes, + options: JSONDecodingOptions = JSONDecodingOptions() + ) throws { + try self.init(jsonUTF8Bytes: jsonUTF8Bytes, extensions: nil, options: options) + } - /// Creates a new message by decoding the given `Data` containing a - /// serialized message in JSON format, interpreting the data as UTF-8 encoded - /// text. - /// - /// - Parameter jsonUTF8Data: The JSON-formatted data to decode, represented - /// as UTF-8 encoded text. - /// - Parameter extensions: The extension map to use with this decode - /// - Parameter options: The JSONDecodingOptions to use. - /// - Throws: `JSONDecodingError` if decoding fails. - public init( - jsonUTF8Data: Data, - extensions: ExtensionMap? = nil, - options: JSONDecodingOptions = JSONDecodingOptions() - ) throws { - self.init() - try jsonUTF8Data.withUnsafeBytes { (body: UnsafeRawBufferPointer) in - // Empty input is valid for binary, but not for JSON. - guard body.count > 0 else { - throw JSONDecodingError.truncated - } - var decoder = JSONDecoder(source: body, options: options, - messageType: Self.self, extensions: extensions) - if decoder.scanner.skipOptionalNull() { - if let customCodable = Self.self as? _CustomJSONCodable.Type, - let message = try customCodable.decodedFromJSONNull() { - self = message as! Self - } else { - throw JSONDecodingError.illegalNull + /// Creates a new message by decoding the given `SwiftProtobufContiguousBytes` + /// containing a serialized message in JSON format, interpreting the data as UTF-8 encoded + /// text. + /// + /// - Parameter jsonUTF8Bytes: The JSON-formatted data to decode, represented + /// as UTF-8 encoded text. + /// - Parameter extensions: The extension map to use with this decode + /// - Parameter options: The JSONDecodingOptions to use. + /// - Throws: ``SwiftProtobufError`` or ``JSONDecodingError`` if decoding fails. + public init( + jsonUTF8Bytes: Bytes, + extensions: (any ExtensionMap)? = nil, + options: JSONDecodingOptions = JSONDecodingOptions() + ) throws { + self.init() + try jsonUTF8Bytes.withUnsafeBytes { (body: UnsafeRawBufferPointer) in + // Empty input is valid for binary, but not for JSON. + guard body.count > 0 else { + throw JSONDecodingError.truncated + } + var decoder = JSONDecoder( + source: body, + options: options, + messageType: Self.self, + extensions: extensions + ) + if decoder.scanner.skipOptionalNull() { + if let customCodable = Self.self as? any _CustomJSONCodable.Type, + let message = try customCodable.decodedFromJSONNull() + { + self = message as! Self + } else { + throw JSONDecodingError.illegalNull + } + } else { + try decoder.decodeFullObject(message: &self) + } + if !decoder.scanner.complete { + throw JSONDecodingError.trailingGarbage + } } - } else { - try decoder.decodeFullObject(message: &self) - } - if !decoder.scanner.complete { - throw JSONDecodingError.trailingGarbage - } } - } } - diff --git a/Sources/SwiftProtobuf/Message+JSONAdditions_Data.swift b/Sources/SwiftProtobuf/Message+JSONAdditions_Data.swift new file mode 100644 index 000000000..3c1c01a3a --- /dev/null +++ b/Sources/SwiftProtobuf/Message+JSONAdditions_Data.swift @@ -0,0 +1,63 @@ +// Sources/SwiftProtobuf/Message+JSONAdditions_Data.swift - JSON format primitive types +// +// Copyright (c) 2022 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// Extensions to `Message` to support JSON encoding/decoding using ``Foundation/Data``. +/// +// ----------------------------------------------------------------------------- + +import Foundation + +/// JSON encoding and decoding methods for messages. +extension Message { + /// Creates a new message by decoding the given `Data` containing a serialized message + /// in JSON format, interpreting the data as UTF-8 encoded text. + /// + /// - Parameter jsonUTF8Data: The JSON-formatted data to decode, represented + /// as UTF-8 encoded text. + /// - Parameter options: The JSONDecodingOptions to use. + /// - Throws: ``SwiftProtobufError`` or ``JSONDecodingError`` if decoding fails. + public init( + jsonUTF8Data: Data, + options: JSONDecodingOptions = JSONDecodingOptions() + ) throws { + try self.init(jsonUTF8Bytes: jsonUTF8Data, extensions: nil, options: options) + } + + /// Creates a new message by decoding the given `Data` containing a serialized message + /// in JSON format, interpreting the data as UTF-8 encoded text. + /// + /// - Parameter jsonUTF8Data: The JSON-formatted data to decode, represented + /// as UTF-8 encoded text. + /// - Parameter extensions: The extension map to use with this decode + /// - Parameter options: The JSONDecodingOptions to use. + /// - Throws: ``SwiftProtobufError`` or ``JSONDecodingError`` if decoding fails. + public init( + jsonUTF8Data: Data, + extensions: (any ExtensionMap)? = nil, + options: JSONDecodingOptions = JSONDecodingOptions() + ) throws { + try self.init(jsonUTF8Bytes: jsonUTF8Data, extensions: extensions, options: options) + } + + /// Returns a Data containing the UTF-8 JSON serialization of the message. + /// + /// Unlike binary encoding, presence of required fields is not enforced when + /// serializing to JSON. + /// + /// - Returns: A Data containing the JSON serialization of the message. + /// - Parameters: + /// - options: The JSONEncodingOptions to use. + /// - Throws: ``SwiftProtobufError`` or ``JSONEncodingError`` if encoding fails. + public func jsonUTF8Data( + options: JSONEncodingOptions = JSONEncodingOptions() + ) throws -> Data { + try jsonUTF8Bytes(options: options) + } +} diff --git a/Sources/SwiftProtobuf/Message+JSONArrayAdditions.swift b/Sources/SwiftProtobuf/Message+JSONArrayAdditions.swift index 4579bf430..05a52437c 100644 --- a/Sources/SwiftProtobuf/Message+JSONArrayAdditions.swift +++ b/Sources/SwiftProtobuf/Message+JSONArrayAdditions.swift @@ -16,131 +16,139 @@ import Foundation /// JSON encoding and decoding methods for arrays of messages. extension Message { - /// Returns a string containing the JSON serialization of the messages. - /// - /// Unlike binary encoding, presence of required fields is not enforced when - /// serializing to JSON. - /// - /// - Returns: A string containing the JSON serialization of the messages. - /// - Parameters: - /// - collection: The list of messages to encode. - /// - options: The JSONEncodingOptions to use. - /// - Throws: `JSONEncodingError` if encoding fails. - public static func jsonString( - from collection: C, - options: JSONEncodingOptions = JSONEncodingOptions() - ) throws -> String where C.Iterator.Element == Self { - let data = try jsonUTF8Data(from: collection, options: options) - return String(data: data, encoding: String.Encoding.utf8)! - } + /// Returns a string containing the JSON serialization of the messages. + /// + /// Unlike binary encoding, presence of required fields is not enforced when + /// serializing to JSON. + /// + /// - Returns: A string containing the JSON serialization of the messages. + /// - Parameters: + /// - collection: The list of messages to encode. + /// - options: The JSONEncodingOptions to use. + /// - Throws: ``SwiftProtobufError`` or ``JSONEncodingError`` if encoding fails. + public static func jsonString( + from collection: C, + options: JSONEncodingOptions = JSONEncodingOptions() + ) throws -> String where C.Iterator.Element == Self { + let data: [UInt8] = try jsonUTF8Bytes(from: collection, options: options) + return String(decoding: data, as: UTF8.self) + } - /// Returns a Data containing the UTF-8 JSON serialization of the messages. - /// - /// Unlike binary encoding, presence of required fields is not enforced when - /// serializing to JSON. - /// - /// - Returns: A Data containing the JSON serialization of the messages. - /// - Parameters: - /// - collection: The list of messages to encode. - /// - options: The JSONEncodingOptions to use. - /// - Throws: `JSONEncodingError` if encoding fails. - public static func jsonUTF8Data( - from collection: C, - options: JSONEncodingOptions = JSONEncodingOptions() - ) throws -> Data where C.Iterator.Element == Self { - var visitor = try JSONEncodingVisitor(type: Self.self, options: options) - visitor.startArray() - for message in collection { - visitor.startArrayObject(message: message) - try message.traverse(visitor: &visitor) - visitor.endObject() + /// Returns a `SwiftProtobufContiguousBytes` containing the UTF-8 JSON serialization of the messages. + /// + /// Unlike binary encoding, presence of required fields is not enforced when + /// serializing to JSON. + /// + /// - Returns: A `SwiftProtobufContiguousBytes` containing the JSON serialization of the messages. + /// - Parameters: + /// - collection: The list of messages to encode. + /// - options: The JSONEncodingOptions to use. + /// - Throws: ``SwiftProtobufError`` or ``JSONEncodingError`` if encoding fails. + public static func jsonUTF8Bytes( + from collection: C, + options: JSONEncodingOptions = JSONEncodingOptions() + ) throws -> Bytes where C.Iterator.Element == Self { + var visitor = try JSONEncodingVisitor(type: Self.self, options: options) + visitor.startArray() + for message in collection { + visitor.startArrayObject(message: message) + try message.traverse(visitor: &visitor) + visitor.endObject() + } + visitor.endArray() + return Bytes(visitor.dataResult) } - visitor.endArray() - return visitor.dataResult - } - /// Creates a new array of messages by decoding the given string containing a - /// serialized array of messages in JSON format. - /// - /// - Parameter jsonString: The JSON-formatted string to decode. - /// - Parameter options: The JSONDecodingOptions to use. - /// - Throws: `JSONDecodingError` if decoding fails. - public static func array( - fromJSONString jsonString: String, - options: JSONDecodingOptions = JSONDecodingOptions() - ) throws -> [Self] { - return try self.array(fromJSONString: jsonString, - extensions: SimpleExtensionMap(), - options: options) - } + /// Creates a new array of messages by decoding the given string containing a + /// serialized array of messages in JSON format. + /// + /// - Parameter jsonString: The JSON-formatted string to decode. + /// - Parameter options: The JSONDecodingOptions to use. + /// - Throws: ``SwiftProtobufError`` or ``JSONDecodingError`` if decoding fails. + public static func array( + fromJSONString jsonString: String, + options: JSONDecodingOptions = JSONDecodingOptions() + ) throws -> [Self] { + try self.array( + fromJSONString: jsonString, + extensions: SimpleExtensionMap(), + options: options + ) + } - /// Creates a new array of messages by decoding the given string containing a - /// serialized array of messages in JSON format. - /// - /// - Parameter jsonString: The JSON-formatted string to decode. - /// - Parameter extensions: The extension map to use with this decode - /// - Parameter options: The JSONDecodingOptions to use. - /// - Throws: `JSONDecodingError` if decoding fails. - public static func array( - fromJSONString jsonString: String, - extensions: ExtensionMap = SimpleExtensionMap(), - options: JSONDecodingOptions = JSONDecodingOptions() - ) throws -> [Self] { - if jsonString.isEmpty { - throw JSONDecodingError.truncated + /// Creates a new array of messages by decoding the given string containing a + /// serialized array of messages in JSON format. + /// + /// - Parameter jsonString: The JSON-formatted string to decode. + /// - Parameter extensions: The extension map to use with this decode + /// - Parameter options: The JSONDecodingOptions to use. + /// - Throws: ``SwiftProtobufError`` or ``JSONDecodingError`` if decoding fails. + public static func array( + fromJSONString jsonString: String, + extensions: any ExtensionMap = SimpleExtensionMap(), + options: JSONDecodingOptions = JSONDecodingOptions() + ) throws -> [Self] { + if jsonString.isEmpty { + throw JSONDecodingError.truncated + } + if let data = jsonString.data(using: String.Encoding.utf8) { + return try array(fromJSONUTF8Bytes: data, extensions: extensions, options: options) + } else { + throw JSONDecodingError.truncated + } } - if let data = jsonString.data(using: String.Encoding.utf8) { - return try array(fromJSONUTF8Data: data, extensions: extensions, options: options) - } else { - throw JSONDecodingError.truncated + + /// Creates a new array of messages by decoding the given ``SwiftProtobufContiguousBytes`` + /// containing a serialized array of messages in JSON format, interpreting the data as + /// UTF-8 encoded text. + /// + /// - Parameter jsonUTF8Bytes: The JSON-formatted data to decode, represented + /// as UTF-8 encoded text. + /// - Parameter options: The JSONDecodingOptions to use. + /// - Throws: ``SwiftProtobufError`` or ``JSONDecodingError`` if decoding fails. + public static func array( + fromJSONUTF8Bytes jsonUTF8Bytes: Bytes, + options: JSONDecodingOptions = JSONDecodingOptions() + ) throws -> [Self] { + try self.array( + fromJSONUTF8Bytes: jsonUTF8Bytes, + extensions: SimpleExtensionMap(), + options: options + ) } - } - /// Creates a new array of messages by decoding the given `Data` containing a - /// serialized array of messages in JSON format, interpreting the data as - /// UTF-8 encoded text. - /// - /// - Parameter jsonUTF8Data: The JSON-formatted data to decode, represented - /// as UTF-8 encoded text. - /// - Parameter options: The JSONDecodingOptions to use. - /// - Throws: `JSONDecodingError` if decoding fails. - public static func array( - fromJSONUTF8Data jsonUTF8Data: Data, - options: JSONDecodingOptions = JSONDecodingOptions() - ) throws -> [Self] { - return try self.array(fromJSONUTF8Data: jsonUTF8Data, - extensions: SimpleExtensionMap(), - options: options) - } + /// Creates a new array of messages by decoding the given ``SwiftProtobufContiguousBytes`` + /// containing a serialized array of messages in JSON format, interpreting the data as + /// UTF-8 encoded text. + /// + /// - Parameter jsonUTF8Bytes: The JSON-formatted data to decode, represented + /// as UTF-8 encoded text. + /// - Parameter extensions: The extension map to use with this decode + /// - Parameter options: The JSONDecodingOptions to use. + /// - Throws: ``SwiftProtobufError`` or ``JSONDecodingError`` if decoding fails. + public static func array( + fromJSONUTF8Bytes jsonUTF8Bytes: Bytes, + extensions: any ExtensionMap = SimpleExtensionMap(), + options: JSONDecodingOptions = JSONDecodingOptions() + ) throws -> [Self] { + try jsonUTF8Bytes.withUnsafeBytes { (body: UnsafeRawBufferPointer) in + var array = [Self]() - /// Creates a new array of messages by decoding the given `Data` containing a - /// serialized array of messages in JSON format, interpreting the data as - /// UTF-8 encoded text. - /// - /// - Parameter jsonUTF8Data: The JSON-formatted data to decode, represented - /// as UTF-8 encoded text. - /// - Parameter extensions: The extension map to use with this decode - /// - Parameter options: The JSONDecodingOptions to use. - /// - Throws: `JSONDecodingError` if decoding fails. - public static func array( - fromJSONUTF8Data jsonUTF8Data: Data, - extensions: ExtensionMap = SimpleExtensionMap(), - options: JSONDecodingOptions = JSONDecodingOptions() - ) throws -> [Self] { - return try jsonUTF8Data.withUnsafeBytes { (body: UnsafeRawBufferPointer) in - var array = [Self]() + if body.count > 0 { + var decoder = JSONDecoder( + source: body, + options: options, + messageType: Self.self, + extensions: extensions + ) + try decoder.decodeRepeatedMessageField(value: &array) + if !decoder.scanner.complete { + throw JSONDecodingError.trailingGarbage + } + } - if body.count > 0 { - var decoder = JSONDecoder(source: body, options: options, - messageType: Self.self, extensions: extensions) - try decoder.decodeRepeatedMessageField(value: &array) - if !decoder.scanner.complete { - throw JSONDecodingError.trailingGarbage + return array } - } - - return array } - } } diff --git a/Sources/SwiftProtobuf/Message+JSONArrayAdditions_Data.swift b/Sources/SwiftProtobuf/Message+JSONArrayAdditions_Data.swift new file mode 100644 index 000000000..4003f60df --- /dev/null +++ b/Sources/SwiftProtobuf/Message+JSONArrayAdditions_Data.swift @@ -0,0 +1,75 @@ +// Sources/SwiftProtobuf/Message+JSONArrayAdditions_Data.swift - JSON format primitive types +// +// Copyright (c) 2014 - 2017 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// Extensions to `Array` to support JSON encoding/decoding. +/// +// ----------------------------------------------------------------------------- + +import Foundation + +/// JSON encoding and decoding methods for arrays of messages. +extension Message { + /// Creates a new array of messages by decoding the given `Data` + /// containing a serialized array of messages in JSON format, interpreting the data as + /// UTF-8 encoded text. + /// + /// - Parameter jsonUTF8Data: The JSON-formatted data to decode, represented + /// as UTF-8 encoded text. + /// - Parameter options: The JSONDecodingOptions to use. + /// - Throws: ``SwiftProtobufError`` or ``JSONDecodingError`` if decoding fails. + public static func array( + fromJSONUTF8Data jsonUTF8Data: Data, + options: JSONDecodingOptions = JSONDecodingOptions() + ) throws -> [Self] { + try self.array( + fromJSONUTF8Bytes: jsonUTF8Data, + extensions: SimpleExtensionMap(), + options: options + ) + } + + /// Creates a new array of messages by decoding the given `Data` + /// containing a serialized array of messages in JSON format, interpreting the data as + /// UTF-8 encoded text. + /// + /// - Parameter jsonUTF8Data: The JSON-formatted data to decode, represented + /// as UTF-8 encoded text. + /// - Parameter extensions: The extension map to use with this decode + /// - Parameter options: The JSONDecodingOptions to use. + /// - Throws: ``SwiftProtobufError`` or ``JSONDecodingError`` if decoding fails. + public static func array( + fromJSONUTF8Data jsonUTF8Data: Data, + extensions: any ExtensionMap = SimpleExtensionMap(), + options: JSONDecodingOptions = JSONDecodingOptions() + ) throws -> [Self] { + try array( + fromJSONUTF8Bytes: jsonUTF8Data, + extensions: extensions, + options: options + ) + } + + /// Returns a Data containing the UTF-8 JSON serialization of the messages. + /// + /// Unlike binary encoding, presence of required fields is not enforced when + /// serializing to JSON. + /// + /// - Returns: A Data containing the JSON serialization of the messages. + /// - Parameters: + /// - collection: The list of messages to encode. + /// - options: The JSONEncodingOptions to use. + /// - Throws: ``SwiftProtobufError`` or ``JSONEncodingError`` if encoding fails. + public static func jsonUTF8Data( + from collection: C, + options: JSONEncodingOptions = JSONEncodingOptions() + ) throws -> Data where C.Iterator.Element == Self { + try jsonUTF8Bytes(from: collection, options: options) + } +} diff --git a/Sources/SwiftProtobuf/Message+TextFormatAdditions.swift b/Sources/SwiftProtobuf/Message+TextFormatAdditions.swift index 7a9dc5377..a31502ef1 100644 --- a/Sources/SwiftProtobuf/Message+TextFormatAdditions.swift +++ b/Sources/SwiftProtobuf/Message+TextFormatAdditions.swift @@ -16,96 +16,99 @@ import Foundation /// Text format encoding and decoding methods for messages. extension Message { - /// Returns a string containing the Protocol Buffer text format serialization - /// of the message. - /// - /// Unlike binary encoding, presence of required fields is not enforced when - /// serializing to text format. - /// - /// - Returns: A string containing the text format serialization of the - /// message. - public func textFormatString() -> String { - // This is implemented as a separate zero-argument function - // to preserve binary compatibility. - return textFormatString(options: TextFormatEncodingOptions()) - } + /// Returns a string containing the Protocol Buffer text format serialization + /// of the message. + /// + /// Unlike binary encoding, presence of required fields is not enforced when + /// serializing to text format. + /// + /// - Returns: A string containing the text format serialization of the + /// message. + public func textFormatString() -> String { + // This is implemented as a separate zero-argument function + // to preserve binary compatibility. + textFormatString(options: TextFormatEncodingOptions()) + } - /// Returns a string containing the Protocol Buffer text format serialization - /// of the message. - /// - /// Unlike binary encoding, presence of required fields is not enforced when - /// serializing to JSON. - /// - /// - Returns: A string containing the text format serialization of the message. - /// - Parameters: - /// - options: The TextFormatEncodingOptions to use. - public func textFormatString( - options: TextFormatEncodingOptions - ) -> String { - var visitor = TextFormatEncodingVisitor(message: self, options: options) - if let any = self as? Google_Protobuf_Any { - any._storage.textTraverse(visitor: &visitor) - } else { - // Although the general traversal/encoding infrastructure supports - // throwing errors (needed for JSON/Binary WKTs support, binary format - // missing required fields); TextEncoding never actually does throw. - try! traverse(visitor: &visitor) + /// Returns a string containing the Protocol Buffer text format serialization + /// of the message. + /// + /// Unlike binary encoding, presence of required fields is not enforced when + /// serializing to text format. + /// + /// - Returns: A string containing the text format serialization of the message. + /// - Parameters: + /// - options: The TextFormatEncodingOptions to use. + public func textFormatString( + options: TextFormatEncodingOptions + ) -> String { + var visitor = TextFormatEncodingVisitor(message: self, options: options) + if let any = self as? Google_Protobuf_Any { + any._storage.textTraverse(visitor: &visitor) + } else { + // Although the general traversal/encoding infrastructure supports + // throwing errors (needed for JSON/Binary WKTs support, binary format + // missing required fields); TextEncoding never actually does throw. + try! traverse(visitor: &visitor) + } + return visitor.result } - return visitor.result - } - /// Creates a new message by decoding the given string containing a - /// serialized message in Protocol Buffer text format. - /// - /// - Parameters: - /// - textFormatString: The text format string to decode. - /// - extensions: An `ExtensionMap` used to look up and decode any - /// extensions in this message or messages nested within this message's - /// fields. - /// - Throws: an instance of `TextFormatDecodingError` on failure. - public init( - textFormatString: String, - extensions: ExtensionMap? = nil - ) throws { - // TODO: Remove this api and default the options instead. This api has to - // exist for anything compiled against an older version of the library. - try self.init(textFormatString: textFormatString, - options: TextFormatDecodingOptions(), - extensions: extensions) - } + /// Creates a new message by decoding the given string containing a + /// serialized message in Protocol Buffer text format. + /// + /// - Parameters: + /// - textFormatString: The text format string to decode. + /// - extensions: An ``ExtensionMap`` used to look up and decode any + /// extensions in this message or messages nested within this message's + /// fields. + /// - Throws: ``SwiftProtobufError`` on failure. + // TODO: delete this (and keep the one with the extra param instead) when we break API + public init( + textFormatString: String, + extensions: (any ExtensionMap)? = nil + ) throws { + try self.init( + textFormatString: textFormatString, + options: TextFormatDecodingOptions(), + extensions: extensions + ) + } - /// Creates a new message by decoding the given string containing a - /// serialized message in Protocol Buffer text format. - /// - /// - Parameters: - /// - textFormatString: The text format string to decode. - /// - options: The `TextFormatDencodingOptions` to use. - /// - extensions: An `ExtensionMap` used to look up and decode any - /// extensions in this message or messages nested within this message's - /// fields. - /// - Throws: an instance of `TextFormatDecodingError` on failure. - public init( - textFormatString: String, - options: TextFormatDecodingOptions, - extensions: ExtensionMap? = nil - ) throws { - self.init() - if !textFormatString.isEmpty { - if let data = textFormatString.data(using: String.Encoding.utf8) { - try data.withUnsafeBytes { (body: UnsafeRawBufferPointer) in - if let baseAddress = body.baseAddress, body.count > 0 { - var decoder = try TextFormatDecoder(messageType: Self.self, - utf8Pointer: baseAddress, - count: body.count, - options: options, - extensions: extensions) - try decodeMessage(decoder: &decoder) - if !decoder.complete { - throw TextFormatDecodingError.trailingGarbage + /// Creates a new message by decoding the given string containing a + /// serialized message in Protocol Buffer text format. + /// + /// - Parameters: + /// - textFormatString: The text format string to decode. + /// - options: The ``TextFormatDecodingOptions`` to use. + /// - extensions: An ``ExtensionMap`` used to look up and decode any + /// extensions in this message or messages nested within this message's + /// fields. + /// - Throws: ``TextFormatDecodingError`` on failure. + public init( + textFormatString: String, + options: TextFormatDecodingOptions = TextFormatDecodingOptions(), + extensions: (any ExtensionMap)? = nil + ) throws { + self.init() + if !textFormatString.isEmpty { + if let data = textFormatString.data(using: String.Encoding.utf8) { + try data.withUnsafeBytes { (body: UnsafeRawBufferPointer) in + if let baseAddress = body.baseAddress, body.count > 0 { + var decoder = try TextFormatDecoder( + messageType: Self.self, + utf8Pointer: baseAddress, + count: body.count, + options: options, + extensions: extensions + ) + try decodeMessage(decoder: &decoder) + if !decoder.complete { + throw TextFormatDecodingError.trailingGarbage + } + } + } } - } } - } } - } } diff --git a/Sources/SwiftProtobuf/Message.swift b/Sources/SwiftProtobuf/Message.swift index 995162c27..4d59ab93c 100644 --- a/Sources/SwiftProtobuf/Message.swift +++ b/Sources/SwiftProtobuf/Message.swift @@ -7,8 +7,6 @@ // https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt // -// TODO: `Message` should require `Sendable` but we cannot do so yet without possibly breaking compatibility. - /// The protocol which all generated protobuf messages implement. /// `Message` is the protocol type you should use whenever /// you need an argument or variable which holds "some message". @@ -33,152 +31,143 @@ /// /// The actual functionality is implemented either in the generated code or in /// default implementations of the below methods and properties. -public protocol Message: CustomDebugStringConvertible { - /// Creates a new message with all of its fields initialized to their default - /// values. - init() - - // Metadata - // Basic facts about this class and the proto message it was generated from - // Used by various encoders and decoders - - /// The fully-scoped name of the message from the original .proto file, - /// including any relevant package name. - static var protoMessageName: String { get } - - /// True if all required fields (if any) on this message and any nested - /// messages (recursively) have values set; otherwise, false. - var isInitialized: Bool { get } - - /// Some formats include enough information to transport fields that were - /// not known at generation time. When encountered, they are stored here. - var unknownFields: UnknownStorage { get set } - - // - // General serialization/deserialization machinery - // - - /// Decode all of the fields from the given decoder. - /// - /// This is a simple loop that repeatedly gets the next field number - /// from `decoder.nextFieldNumber()` and then uses the number returned - /// and the type information from the original .proto file to decide - /// what type of data should be decoded for that field. The corresponding - /// method on the decoder is then called to get the field value. - /// - /// This is the core method used by the deserialization machinery. It is - /// `public` to enable users to implement their own encoding formats by - /// conforming to `Decoder`; it should not be called otherwise. - /// - /// Note that this is not specific to binary encodng; formats that use - /// textual identifiers translate those to field numbers and also go - /// through this to decode messages. - /// - /// - Parameters: - /// - decoder: a `Decoder`; the `Message` will call the method - /// corresponding to the type of this field. - /// - Throws: an error on failure or type mismatch. The type of error - /// thrown depends on which decoder is used. - mutating func decodeMessage(decoder: inout D) throws - - /// Traverses the fields of the message, calling the appropriate methods - /// of the passed `Visitor` object. - /// - /// This is used internally by: - /// - /// * Protobuf binary serialization - /// * JSON serialization (with some twists to account for specialty JSON) - /// * Protobuf Text serialization - /// * `Hashable` computation - /// - /// Conceptually, serializers create visitor objects that are - /// then passed recursively to every message and field via generated - /// `traverse` methods. The details get a little involved due to - /// the need to allow particular messages to override particular - /// behaviors for specific encodings, but the general idea is quite simple. - func traverse(visitor: inout V) throws - - // Standard utility properties and methods. - // Most of these are simple wrappers on top of the visitor machinery. - // They are implemented in the protocol, not in the generated structs, - // so can be overridden in user code by defining custom extensions to - // the generated struct. - -#if swift(>=4.2) - /// An implementation of hash(into:) to provide conformance with the - /// `Hashable` protocol. - func hash(into hasher: inout Hasher) -#else // swift(>=4.2) - /// The hash value generated from this message's contents, for conformance - /// with the `Hashable` protocol. - var hashValue: Int { get } -#endif // swift(>=4.2) - - /// Helper to compare `Message`s when not having a specific type to use - /// normal `Equatable`. `Equatable` is provided with specific generated - /// types. - func isEqualTo(message: Message) -> Bool +@preconcurrency +public protocol Message: Sendable, CustomDebugStringConvertible { + /// Creates a new message with all of its fields initialized to their default + /// values. + init() + + // Metadata + // Basic facts about this class and the proto message it was generated from + // Used by various encoders and decoders + + /// The fully-scoped name of the message from the original .proto file, + /// including any relevant package name. + static var protoMessageName: String { get } + + /// True if all required fields (if any) on this message and any nested + /// messages (recursively) have values set; otherwise, false. + var isInitialized: Bool { get } + + /// Some formats include enough information to transport fields that were + /// not known at generation time. When encountered, they are stored here. + var unknownFields: UnknownStorage { get set } + + // + // General serialization/deserialization machinery + // + + /// Decode all of the fields from the given decoder. + /// + /// This is a simple loop that repeatedly gets the next field number + /// from `decoder.nextFieldNumber()` and then uses the number returned + /// and the type information from the original .proto file to decide + /// what type of data should be decoded for that field. The corresponding + /// method on the decoder is then called to get the field value. + /// + /// This is the core method used by the deserialization machinery. It is + /// `public` to enable users to implement their own encoding formats by + /// conforming to `Decoder`; it should not be called otherwise. + /// + /// Note that this is not specific to binary encodng; formats that use + /// textual identifiers translate those to field numbers and also go + /// through this to decode messages. + /// + /// - Parameters: + /// - decoder: a `Decoder`; the `Message` will call the method + /// corresponding to the type of this field. + /// - Throws: an error on failure or type mismatch. The type of error + /// thrown depends on which decoder is used. + mutating func decodeMessage(decoder: inout D) throws + + /// Traverses the fields of the message, calling the appropriate methods + /// of the passed `Visitor` object. + /// + /// This is used internally by: + /// + /// * Protobuf binary serialization + /// * JSON serialization (with some twists to account for specialty JSON) + /// * Protobuf Text serialization + /// * `Hashable` computation + /// + /// Conceptually, serializers create visitor objects that are + /// then passed recursively to every message and field via generated + /// `traverse` methods. The details get a little involved due to + /// the need to allow particular messages to override particular + /// behaviors for specific encodings, but the general idea is quite simple. + func traverse(visitor: inout V) throws + + // Standard utility properties and methods. + // Most of these are simple wrappers on top of the visitor machinery. + // They are implemented in the protocol, not in the generated structs, + // so can be overridden in user code by defining custom extensions to + // the generated struct. + + /// An implementation of hash(into:) to provide conformance with the + /// `Hashable` protocol. + func hash(into hasher: inout Hasher) + + /// Helper to compare `Message`s when not having a specific type to use + /// normal `Equatable`. `Equatable` is provided with specific generated + /// types. + func isEqualTo(message: any Message) -> Bool } extension Message { - /// Generated proto2 messages that contain required fields, nested messages - /// that contain required fields, and/or extensions will provide their own - /// implementation of this property that tests that all required fields are - /// set. Users of the generated code SHOULD NOT override this property. - public var isInitialized: Bool { - // The generated code will include a specialization as needed. - return true - } - - /// A hash based on the message's full contents. -#if swift(>=4.2) - public func hash(into hasher: inout Hasher) { - var visitor = HashVisitor(hasher) - try? traverse(visitor: &visitor) - hasher = visitor.hasher - } -#else // swift(>=4.2) - public var hashValue: Int { - var visitor = HashVisitor() - try? traverse(visitor: &visitor) - return visitor.hashValue - } -#endif // swift(>=4.2) - - /// A description generated by recursively visiting all fields in the message, - /// including messages. - public var debugDescription: String { - // TODO Ideally there would be something like serializeText() that can - // take a prefix so we could do something like: - // [class name]( - // [text format] - // ) - let className = String(reflecting: type(of: self)) - let header = "\(className):\n" - return header + textFormatString() - } - - /// Creates an instance of the message type on which this method is called, - /// executes the given block passing the message in as its sole `inout` - /// argument, and then returns the message. - /// - /// This method acts essentially as a "builder" in that the initialization of - /// the message is captured within the block, allowing the returned value to - /// be set in an immutable variable. For example, - /// - /// let msg = MyMessage.with { $0.myField = "foo" } - /// msg.myOtherField = 5 // error: msg is immutable - /// - /// - Parameter populator: A block or function that populates the new message, - /// which is passed into the block as an `inout` argument. - /// - Returns: The message after execution of the block. - public static func with( - _ populator: (inout Self) throws -> () - ) rethrows -> Self { - var message = Self() - try populator(&message) - return message - } + /// Generated proto2 messages that contain required fields, nested messages + /// that contain required fields, and/or extensions will provide their own + /// implementation of this property that tests that all required fields are + /// set. Users of the generated code SHOULD NOT override this property. + public var isInitialized: Bool { + // The generated code will include a specialization as needed. + true + } + + /// A hash based on the message's full contents. + public func hash(into hasher: inout Hasher) { + var visitor = HashVisitor(hasher) + try? traverse(visitor: &visitor) + hasher = visitor.hasher + } + + /// A description generated by recursively visiting all fields in the message, + /// including messages. + public var debugDescription: String { + #if DEBUG + // TODO Ideally there would be something like serializeText() that can + // take a prefix so we could do something like: + // [class name]( + // [text format] + // ) + let className = String(reflecting: type(of: self)) + let header = "\(className):\n" + return header + textFormatString() + #else + return String(reflecting: type(of: self)) + #endif + } + + /// Creates an instance of the message type on which this method is called, + /// executes the given block passing the message in as its sole `inout` + /// argument, and then returns the message. + /// + /// This method acts essentially as a "builder" in that the initialization of + /// the message is captured within the block, allowing the returned value to + /// be set in an immutable variable. For example, + /// + /// let msg = MyMessage.with { $0.myField = "foo" } + /// msg.myOtherField = 5 // error: msg is immutable + /// + /// - Parameter populator: A block or function that populates the new message, + /// which is passed into the block as an `inout` argument. + /// - Returns: The message after execution of the block. + public static func with( + _ populator: (inout Self) throws -> Void + ) rethrows -> Self { + var message = Self() + try populator(&message) + return message + } } /// Implementation base for all messages; not intended for client use. @@ -189,30 +178,31 @@ extension Message { /// generic constraints if you need to write generic code that can be applied to /// multiple message types that uses equality tests, puts messages in a `Set`, /// or uses them as `Dictionary` keys. +@preconcurrency public protocol _MessageImplementationBase: Message, Hashable { - // Legacy function; no longer used, but left to maintain source compatibility. - func _protobuf_generated_isEqualTo(other: Self) -> Bool + // Legacy function; no longer used, but left to maintain source compatibility. + func _protobuf_generated_isEqualTo(other: Self) -> Bool } extension _MessageImplementationBase { - public func isEqualTo(message: Message) -> Bool { - guard let other = message as? Self else { - return false + public func isEqualTo(message: any Message) -> Bool { + guard let other = message as? Self else { + return false + } + return self == other + } + + // Legacy default implementation that is used by old generated code, current + // versions of the plugin/generator provide this directly, but this is here + // just to avoid breaking source compatibility. + public static func == (lhs: Self, rhs: Self) -> Bool { + lhs._protobuf_generated_isEqualTo(other: rhs) + } + + // Legacy function that is generated by old versions of the plugin/generator, + // defaulted to keep things simple without changing the api surface. + public func _protobuf_generated_isEqualTo(other: Self) -> Bool { + self == other } - return self == other - } - - // Legacy default implementation that is used by old generated code, current - // versions of the plugin/generator provide this directly, but this is here - // just to avoid breaking source compatibility. - public static func ==(lhs: Self, rhs: Self) -> Bool { - return lhs._protobuf_generated_isEqualTo(other: rhs) - } - - // Legacy function that is generated by old versions of the plugin/generator, - // defaulted to keep things simple without changing the api surface. - public func _protobuf_generated_isEqualTo(other: Self) -> Bool { - return self == other - } } diff --git a/Sources/SwiftProtobuf/MessageExtension.swift b/Sources/SwiftProtobuf/MessageExtension.swift index ae35d6c29..9d05d0987 100644 --- a/Sources/SwiftProtobuf/MessageExtension.swift +++ b/Sources/SwiftProtobuf/MessageExtension.swift @@ -15,29 +15,28 @@ /// // ----------------------------------------------------------------------------- -// TODO: `AnyMessageExtension` should require `Sendable` but we cannot do so yet without possibly breaking compatibility. - /// Type-erased MessageExtension field implementation. -public protocol AnyMessageExtension { +@preconcurrency +public protocol AnyMessageExtension: Sendable { var fieldNumber: Int { get } var fieldName: String { get } - var messageType: Message.Type { get } - func _protobuf_newField(decoder: inout D) throws -> AnyExtensionField? + var messageType: any Message.Type { get } + func _protobuf_newField(decoder: inout D) throws -> (any AnyExtensionField)? } /// A "Message Extension" relates a particular extension field to /// a particular message. The generic constraints allow /// compile-time compatibility checks. -public class MessageExtension: AnyMessageExtension { +public final class MessageExtension: AnyMessageExtension { public let fieldNumber: Int public let fieldName: String - public let messageType: Message.Type + public let messageType: any Message.Type public init(_protobuf_fieldNumber: Int, fieldName: String) { self.fieldNumber = _protobuf_fieldNumber self.fieldName = fieldName self.messageType = MessageType.self } - public func _protobuf_newField(decoder: inout D) throws -> AnyExtensionField? { - return try FieldType(protobufExtension: self, decoder: &decoder) + public func _protobuf_newField(decoder: inout D) throws -> (any AnyExtensionField)? { + try FieldType(protobufExtension: self, decoder: &decoder) } } diff --git a/Sources/SwiftProtobuf/NameMap.swift b/Sources/SwiftProtobuf/NameMap.swift index f2822e893..09a7ece7d 100644 --- a/Sources/SwiftProtobuf/NameMap.swift +++ b/Sources/SwiftProtobuf/NameMap.swift @@ -14,77 +14,155 @@ /// use this data. We should develop and publicize a suitable API /// for that purpose. (Which might be the same as the internal API.) -/// This must be exactly the same as the corresponding code in the -/// protoc-gen-swift code generator. Changing it will break -/// compatibility of the library with older generated code. +/// This must produce exactly the same outputs as the corresponding +/// code in the protoc-gen-swift code generator. Changing it will +/// break compatibility of the library with older generated code. /// /// It does not necessarily need to match protoc's JSON field naming /// logic, however. -private func toJsonFieldName(_ s: String) -> String { - var result = String() +private func toJSONFieldName(_ s: UnsafeBufferPointer) -> String { + var result = String.UnicodeScalarView() var capitalizeNext = false for c in s { - if c == "_" { + if c == UInt8(ascii: "_") { capitalizeNext = true } else if capitalizeNext { - result.append(String(c).uppercased()) + result.append(Unicode.Scalar(c).uppercasedAssumingASCII) capitalizeNext = false } else { - result.append(String(c)) + result.append(Unicode.Scalar(c)) } } - return result + return String(result) } +#if !REMOVE_LEGACY_NAMEMAP_INITIALIZERS +private func toJSONFieldName(_ s: StaticString) -> String { + guard s.hasPointerRepresentation else { + // If it's a single code point, it wouldn't be changed by the above algorithm. + // Return it as-is. + return s.description + } + return toJSONFieldName(UnsafeBufferPointer(start: s.utf8Start, count: s.utf8CodeUnitCount)) +} +#endif // !REMOVE_LEGACY_NAMEMAP_INITIALIZERS /// Allocate static memory buffers to intern UTF-8 /// string data. Track the buffers and release all of those buffers /// in case we ever get deallocated. -fileprivate class InternPool { - private var interned = [UnsafeRawBufferPointer]() - - func intern(utf8: String.UTF8View) -> UnsafeRawBufferPointer { - #if swift(>=4.1) - let mutable = UnsafeMutableRawBufferPointer.allocate(byteCount: utf8.count, - alignment: MemoryLayout.alignment) - #else - let mutable = UnsafeMutableRawBufferPointer.allocate(count: utf8.count) - #endif - mutable.copyBytes(from: utf8) - let immutable = UnsafeRawBufferPointer(mutable) - interned.append(immutable) - return immutable - } - - func intern(utf8Ptr: UnsafeBufferPointer) -> UnsafeRawBufferPointer { - #if swift(>=4.1) - let mutable = UnsafeMutableRawBufferPointer.allocate(byteCount: utf8Ptr.count, - alignment: MemoryLayout.alignment) - #else - let mutable = UnsafeMutableRawBufferPointer.allocate(count: utf8.count) - #endif - mutable.copyBytes(from: utf8Ptr) - let immutable = UnsafeRawBufferPointer(mutable) - interned.append(immutable) - return immutable - } - - deinit { - for buff in interned { - #if swift(>=4.1) - buff.deallocate() - #else - let p = UnsafeMutableRawPointer(mutating: buff.baseAddress)! - p.deallocate(bytes: buff.count, alignedTo: 1) - #endif +private class InternPool { + private var interned = [UnsafeRawBufferPointer]() + + func intern(utf8: String.UTF8View) -> UnsafeRawBufferPointer { + let mutable = UnsafeMutableRawBufferPointer.allocate( + byteCount: utf8.count, + alignment: MemoryLayout.alignment + ) + mutable.copyBytes(from: utf8) + let immutable = UnsafeRawBufferPointer(mutable) + interned.append(immutable) + return immutable + } + + func intern(utf8Ptr: UnsafeBufferPointer) -> UnsafeRawBufferPointer { + let mutable = UnsafeMutableRawBufferPointer.allocate( + byteCount: utf8Ptr.count, + alignment: MemoryLayout.alignment + ) + mutable.copyBytes(from: utf8Ptr) + let immutable = UnsafeRawBufferPointer(mutable) + interned.append(immutable) + return immutable + } + + deinit { + for buff in interned { + buff.deallocate() + } } - } } -#if !swift(>=4.2) -// Constants for FNV hash http://tools.ietf.org/html/draft-eastlake-fnv-03 -private let i_2166136261 = Int(bitPattern: 2166136261) -private let i_16777619 = Int(16777619) -#endif +/// Instructions used in bytecode streams that define proto name mappings. +/// +/// Since field and enum case names are encoded in numeric order, field and case number operands in +/// the bytecode are stored as adjacent differences. Most messages/enums use densely packed +/// numbers, so we've optimized the opcodes for that; each instruction that takes a single +/// field/case number has two forms: one that assumes the next number is +1 from the previous +/// number, and a second form that takes an arbitrary delta from the previous number. +/// +/// This has package visibility so that it is also visible to the generator. +package enum ProtoNameInstruction: UInt64, CaseIterable { + /// The proto (text format) name and the JSON name are the same string. + /// + /// ## Operands + /// * (Delta only) An integer representing the (delta from the previous) field or enum case + /// number. + /// * A string containing the single text format and JSON name. + case sameNext = 1 + case sameDelta = 2 + + /// The JSON name can be computed from the proto string. + /// + /// ## Operands + /// * (Delta only) An integer representing the (delta from the previous) field or enum case + /// number. + /// * A string containing the single text format name, from which the JSON name will be + /// dynamically computed. + case standardNext = 3 + case standardDelta = 4 + + /// The JSON and text format names are just different. + /// + /// ## Operands + /// * (Delta only) An integer representing the (delta from the previous) field or enum case + /// number. + /// * A string containing the text format name. + /// * A string containing the JSON name. + case uniqueNext = 5 + case uniqueDelta = 6 + + /// Used for group fields only to represent the message type name of a group. + /// + /// ## Operands + /// * (Delta only) An integer representing the (delta from the previous) field number. + /// * A string containing the (UpperCamelCase by convention) message type name, from which the + /// text format and JSON names can be derived (lowercase). + case groupNext = 7 + case groupDelta = 8 + + /// Used for enum cases only to represent a value's primary proto name (the first defined case) + /// and its aliases. The JSON and text format names for enums are always the same. + /// + /// ## Operands + /// * (Delta only) An integer representing the (delta from the previous) enum case number. + /// * An integer `aliasCount` representing the number of aliases. + /// * A string containing the text format/JSON name (the first defined case with this number). + /// * `aliasCount` strings containing other text format/JSON names that are aliases. + case aliasNext = 9 + case aliasDelta = 10 + + /// Represents a reserved name in a proto message. + /// + /// ## Operands + /// * The name of a reserved field. + case reservedName = 11 + + /// Represents a range of reserved field numbers or enum case numbers in a proto message. + /// + /// ## Operands + /// * An integer representing the lower bound (inclusive) of the reserved number range. + /// * An integer representing the delta between the upper bound (exclusive) and the lower bound + /// of the reserved number range. + case reservedNumbers = 12 + + /// Indicates whether the opcode represents an instruction that has an explicit delta encoded + /// as its first operand. + var hasExplicitDelta: Bool { + switch self { + case .sameDelta, .standardDelta, .uniqueDelta, .groupDelta, .aliasDelta: return true + default: return false + } + } +} /// An immutable bidirectional mapping between field/enum-case names /// and numbers, used to record field names for text-based @@ -93,218 +171,386 @@ private let i_16777619 = Int(16777619) /// users who do not use text-based serialization formats. public struct _NameMap: ExpressibleByDictionaryLiteral { - /// An immutable interned string container. The `utf8Start` pointer - /// is guaranteed valid for the lifetime of the `NameMap` that you - /// fetched it from. Since `NameMap`s are only instantiated as - /// immutable static values, that should be the lifetime of the - /// program. - /// - /// Internally, this uses `StaticString` (which refers to a fixed - /// block of UTF-8 data) where possible. In cases where the string - /// has to be computed, it caches the UTF-8 bytes in an - /// unmovable and immutable heap area. - internal struct Name: Hashable, CustomStringConvertible { - // This should not be used outside of this file, as it requires - // coordinating the lifecycle with the lifecycle of the pool - // where the raw UTF8 gets interned. - fileprivate init(staticString: StaticString, pool: InternPool) { - self.nameString = .staticString(staticString) - if staticString.hasPointerRepresentation { - self.utf8Buffer = UnsafeRawBufferPointer(start: staticString.utf8Start, - count: staticString.utf8CodeUnitCount) - } else { - self.utf8Buffer = staticString.withUTF8Buffer { pool.intern(utf8Ptr: $0) } + /// An immutable interned string container. The `utf8Start` pointer + /// is guaranteed valid for the lifetime of the `NameMap` that you + /// fetched it from. Since `NameMap`s are only instantiated as + /// immutable static values, that should be the lifetime of the + /// program. + /// + /// Internally, this uses `StaticString` (which refers to a fixed + /// block of UTF-8 data) where possible. In cases where the string + /// has to be computed, it caches the UTF-8 bytes in an + /// unmovable and immutable heap area. + package struct Name: Hashable, CustomStringConvertible { + #if !REMOVE_LEGACY_NAMEMAP_INITIALIZERS + // This should not be used outside of this file, as it requires + // coordinating the lifecycle with the lifecycle of the pool + // where the raw UTF8 gets interned. + fileprivate init(staticString: StaticString, pool: InternPool) { + if staticString.hasPointerRepresentation { + self.utf8Buffer = UnsafeRawBufferPointer( + start: staticString.utf8Start, + count: staticString.utf8CodeUnitCount + ) + } else { + self.utf8Buffer = staticString.withUTF8Buffer { pool.intern(utf8Ptr: $0) } + } + } + #endif // !REMOVE_LEGACY_NAMEMAP_INITIALIZERS + + // This should not be used outside of this file, as it requires + // coordinating the lifecycle with the lifecycle of the pool + // where the raw UTF8 gets interned. + fileprivate init(string: String, pool: InternPool) { + let utf8 = string.utf8 + self.utf8Buffer = pool.intern(utf8: utf8) + } + + // This is for building a transient `Name` object sufficient for lookup purposes. + // It MUST NOT be exposed outside of this file. + fileprivate init(transientUtf8Buffer: UnsafeRawBufferPointer) { + self.utf8Buffer = transientUtf8Buffer + } + + // This is for building a `Name` object from a slice of a bytecode `StaticString`. + // It MUST NOT be exposed outside of this file. + fileprivate init(bytecodeUTF8Buffer: UnsafeBufferPointer) { + self.utf8Buffer = UnsafeRawBufferPointer(bytecodeUTF8Buffer) + } + + internal let utf8Buffer: UnsafeRawBufferPointer + + public var description: String { + String(decoding: self.utf8Buffer, as: UTF8.self) + } + + public func hash(into hasher: inout Hasher) { + for byte in utf8Buffer { + hasher.combine(byte) + } + } + + public static func == (lhs: Name, rhs: Name) -> Bool { + if lhs.utf8Buffer.count != rhs.utf8Buffer.count { + return false + } + return lhs.utf8Buffer.elementsEqual(rhs.utf8Buffer) } } - // This should not be used outside of this file, as it requires - // coordinating the lifecycle with the lifecycle of the pool - // where the raw UTF8 gets interned. - fileprivate init(string: String, pool: InternPool) { - let utf8 = string.utf8 - self.utf8Buffer = pool.intern(utf8: utf8) - self.nameString = .string(string) + /// The JSON and proto names for a particular field, enum case, or extension. + internal struct Names { + private(set) var json: Name? + private(set) var proto: Name } - // This is for building a transient `Name` object sufficient for lookup purposes. - // It MUST NOT be exposed outside of this file. - fileprivate init(transientUtf8Buffer: UnsafeRawBufferPointer) { - self.nameString = .staticString("") - self.utf8Buffer = transientUtf8Buffer + #if !REMOVE_LEGACY_NAMEMAP_INITIALIZERS + + /// A description of the names for a particular field or enum case. + /// The different forms here let us minimize the amount of string + /// data that we store in the binary. + /// + /// These are only used in the generated code to initialize a NameMap. + public enum NameDescription { + + /// The proto (text format) name and the JSON name are the same string. + case same(proto: StaticString) + + /// The JSON name can be computed from the proto string + case standard(proto: StaticString) + + /// The JSON and text format names are just different. + case unique(proto: StaticString, json: StaticString) + + /// Used for enum cases only to represent a value's primary proto name (the + /// first defined case) and its aliases. The JSON and text format names for + /// enums are always the same. + case aliased(proto: StaticString, aliases: [StaticString]) } - private(set) var utf8Buffer: UnsafeRawBufferPointer + #endif // !REMOVE_LEGACY_NAMEMAP_INITIALIZERS + + private var internPool = InternPool() + + /// The mapping from field/enum-case numbers to names. + private var numberToNameMap: [Int: Names] = [:] + + /// The mapping from proto/text names to field/enum-case numbers. + private var protoToNumberMap: [Name: Int] = [:] + + /// The mapping from JSON names to field/enum-case numbers. + /// Note that this also contains all of the proto/text names, + /// as required by Google's spec for protobuf JSON. + private var jsonToNumberMap: [Name: Int] = [:] + + /// The reserved names in for this object. Currently only used for Message to + /// support TextFormat's requirement to skip these names in all cases. + private var reservedNames: [String] = [] - private enum NameString { - case string(String) - case staticString(StaticString) + /// The reserved numbers in for this object. Currently only used for Message to + /// support TextFormat's requirement to skip these numbers in all cases. + private var reservedRanges: [Range] = [] + + /// Creates a new empty field/enum-case name/number mapping. + public init() {} + + #if REMOVE_LEGACY_NAMEMAP_INITIALIZERS + + // Provide a dummy for ExpressibleByDictionaryLiteral conformance. + public init(dictionaryLiteral elements: (Int, Int)...) { + fatalError("Support compiled out removed") } - private var nameString: NameString - public var description: String { - switch nameString { - case .string(let s): return s - case .staticString(let s): return s.description - } + #else // !REMOVE_LEGACY_NAMEMAP_INITIALIZERS + + /// Build the bidirectional maps between numbers and proto/JSON names. + @available( + *, + deprecated, + message: "Please regenerate your .pb.swift files with the current version of the SwiftProtobuf protoc plugin." + ) + public init( + reservedNames: [String], + reservedRanges: [Range], + numberNameMappings: KeyValuePairs + ) { + self.reservedNames = reservedNames + self.reservedRanges = reservedRanges + + initHelper(numberNameMappings) } - #if swift(>=4.2) - public func hash(into hasher: inout Hasher) { - for byte in utf8Buffer { - hasher.combine(byte) - } + /// Build the bidirectional maps between numbers and proto/JSON names. + @available( + *, + deprecated, + message: "Please regenerate your .pb.swift files with the current version of the SwiftProtobuf protoc plugin." + ) + public init(dictionaryLiteral elements: (Int, NameDescription)...) { + initHelper(elements) } - #else // swift(>=4.2) - public var hashValue: Int { - var h = i_2166136261 - for byte in utf8Buffer { - h = (h ^ Int(byte)) &* i_16777619 - } - return h + + /// Helper to share the building of mappings between the two initializers. + private mutating func initHelper( + _ elements: Pairs + ) where Pairs.Element == (key: Int, value: NameDescription) { + for (number, description) in elements { + switch description { + + case .same(proto: let p): + let protoName = Name(staticString: p, pool: internPool) + let names = Names(json: protoName, proto: protoName) + numberToNameMap[number] = names + protoToNumberMap[protoName] = number + jsonToNumberMap[protoName] = number + + case .standard(proto: let p): + let protoName = Name(staticString: p, pool: internPool) + let jsonString = toJSONFieldName(p) + let jsonName = Name(string: jsonString, pool: internPool) + let names = Names(json: jsonName, proto: protoName) + numberToNameMap[number] = names + protoToNumberMap[protoName] = number + jsonToNumberMap[protoName] = number + jsonToNumberMap[jsonName] = number + + case .unique(proto: let p, json: let j): + let jsonName = Name(staticString: j, pool: internPool) + let protoName = Name(staticString: p, pool: internPool) + let names = Names(json: jsonName, proto: protoName) + numberToNameMap[number] = names + protoToNumberMap[protoName] = number + jsonToNumberMap[protoName] = number + jsonToNumberMap[jsonName] = number + + case .aliased(proto: let p, let aliases): + let protoName = Name(staticString: p, pool: internPool) + let names = Names(json: protoName, proto: protoName) + numberToNameMap[number] = names + protoToNumberMap[protoName] = number + jsonToNumberMap[protoName] = number + for alias in aliases { + let protoName = Name(staticString: alias, pool: internPool) + protoToNumberMap[protoName] = number + jsonToNumberMap[protoName] = number + } + } + } } - #endif // swift(>=4.2) - public static func ==(lhs: Name, rhs: Name) -> Bool { - if lhs.utf8Buffer.count != rhs.utf8Buffer.count { - return false - } - return lhs.utf8Buffer.elementsEqual(rhs.utf8Buffer) + #endif // !REMOVE_LEGACY_NAMEMAP_INITIALIZERS + + public init(bytecode: StaticString) { + var previousNumber = 0 + BytecodeInterpreter(program: bytecode).execute { instruction, reader in + func nextNumber() -> Int { + let next: Int + if instruction.hasExplicitDelta { + next = previousNumber + Int(reader.nextInt32()) + } else { + next = previousNumber + 1 + } + previousNumber = next + return next + } + + switch instruction { + case .sameNext, .sameDelta: + let number = nextNumber() + let protoName = Name(bytecodeUTF8Buffer: reader.nextNullTerminatedString()) + numberToNameMap[number] = Names(json: protoName, proto: protoName) + protoToNumberMap[protoName] = number + jsonToNumberMap[protoName] = number + + case .standardNext, .standardDelta: + let number = nextNumber() + let protoNameBuffer = reader.nextNullTerminatedString() + let protoName = Name(bytecodeUTF8Buffer: protoNameBuffer) + let jsonString = toJSONFieldName(protoNameBuffer) + let jsonName = Name(string: jsonString, pool: internPool) + numberToNameMap[number] = Names(json: jsonName, proto: protoName) + protoToNumberMap[protoName] = number + jsonToNumberMap[protoName] = number + jsonToNumberMap[jsonName] = number + + case .uniqueNext, .uniqueDelta: + let number = nextNumber() + let protoName = Name(bytecodeUTF8Buffer: reader.nextNullTerminatedString()) + let jsonName = Name(bytecodeUTF8Buffer: reader.nextNullTerminatedString()) + numberToNameMap[number] = Names(json: jsonName, proto: protoName) + protoToNumberMap[protoName] = number + jsonToNumberMap[protoName] = number + jsonToNumberMap[jsonName] = number + + case .groupNext, .groupDelta: + let number = nextNumber() + let protoNameBuffer = reader.nextNullTerminatedString() + let protoName = Name(bytecodeUTF8Buffer: protoNameBuffer) + protoToNumberMap[protoName] = number + jsonToNumberMap[protoName] = number + + let lowercaseName: Name + let hasUppercase = protoNameBuffer.contains { (UInt8(ascii: "A")...UInt8(ascii: "Z")).contains($0) } + if hasUppercase { + lowercaseName = Name( + string: String(decoding: protoNameBuffer, as: UTF8.self).lowercased(), + pool: internPool + ) + protoToNumberMap[lowercaseName] = number + jsonToNumberMap[lowercaseName] = number + } else { + // No need to convert and intern a separate copy of the string + // if it would be identical. + lowercaseName = protoName + } + numberToNameMap[number] = Names(json: lowercaseName, proto: protoName) + + case .aliasNext, .aliasDelta: + let number = nextNumber() + let protoName = Name(bytecodeUTF8Buffer: reader.nextNullTerminatedString()) + numberToNameMap[number] = Names(json: protoName, proto: protoName) + protoToNumberMap[protoName] = number + jsonToNumberMap[protoName] = number + for alias in reader.nextNullTerminatedStringArray() { + let protoName = Name(bytecodeUTF8Buffer: alias) + protoToNumberMap[protoName] = number + jsonToNumberMap[protoName] = number + } + + case .reservedName: + let name = String(decoding: reader.nextNullTerminatedString(), as: UTF8.self) + reservedNames.append(name) + + case .reservedNumbers: + let lowerBound = reader.nextInt32() + let upperBound = lowerBound + reader.nextInt32() + reservedRanges.append(lowerBound.. Names? { + numberToNameMap[number] + } - /// A description of the names for a particular field or enum case. - /// The different forms here let us minimize the amount of string - /// data that we store in the binary. - /// - /// These are only used in the generated code to initialize a NameMap. - public enum NameDescription { + /// Returns the field/enum-case number that has the given JSON name, + /// or `nil` if there is no match. + /// + /// This is used by the Text format parser to look up field or enum + /// names using a direct reference to the un-decoded UTF8 bytes. + internal func number(forProtoName raw: UnsafeRawBufferPointer) -> Int? { + let n = Name(transientUtf8Buffer: raw) + return protoToNumberMap[n] + } - /// The proto (text format) name and the JSON name are the same string. - case same(proto: StaticString) + /// Returns the field/enum-case number that has the given JSON name, + /// or `nil` if there is no match. + /// + /// This accepts a regular `String` and is used in JSON parsing + /// only when a field name or enum name was decoded from a string + /// containing backslash escapes. + /// + /// JSON parsing must interpret *both* the JSON name of the + /// field/enum-case provided by the descriptor *as well as* its + /// original proto/text name. + internal func number(forJSONName name: String) -> Int? { + let utf8 = Array(name.utf8) + return utf8.withUnsafeBytes { (buffer: UnsafeRawBufferPointer) in + let n = Name(transientUtf8Buffer: buffer) + return jsonToNumberMap[n] + } + } - /// The JSON name can be computed from the proto string - case standard(proto: StaticString) + /// Returns the field/enum-case number that has the given JSON name, + /// or `nil` if there is no match. + /// + /// This is used by the JSON parser when a field name or enum name + /// required no special processing. As a result, we can avoid + /// copying the name and look up the number using a direct reference + /// to the un-decoded UTF8 bytes. + internal func number(forJSONName raw: UnsafeRawBufferPointer) -> Int? { + let n = Name(transientUtf8Buffer: raw) + return jsonToNumberMap[n] + } - /// The JSON and text format names are just different. - case unique(proto: StaticString, json: StaticString) - - /// Used for enum cases only to represent a value's primary proto name (the - /// first defined case) and its aliases. The JSON and text format names for - /// enums are always the same. - case aliased(proto: StaticString, aliases: [StaticString]) - } - - private var internPool = InternPool() - - /// The mapping from field/enum-case numbers to names. - private var numberToNameMap: [Int: Names] = [:] - - /// The mapping from proto/text names to field/enum-case numbers. - private var protoToNumberMap: [Name: Int] = [:] - - /// The mapping from JSON names to field/enum-case numbers. - /// Note that this also contains all of the proto/text names, - /// as required by Google's spec for protobuf JSON. - private var jsonToNumberMap: [Name: Int] = [:] - - /// Creates a new empty field/enum-case name/number mapping. - public init() {} - - /// Build the bidirectional maps between numbers and proto/JSON names. - public init(dictionaryLiteral elements: (Int, NameDescription)...) { - for (number, description) in elements { - switch description { - - case .same(proto: let p): - let protoName = Name(staticString: p, pool: internPool) - let names = Names(json: protoName, proto: protoName) - numberToNameMap[number] = names - protoToNumberMap[protoName] = number - jsonToNumberMap[protoName] = number - - case .standard(proto: let p): - let protoName = Name(staticString: p, pool: internPool) - let jsonString = toJsonFieldName(protoName.description) - let jsonName = Name(string: jsonString, pool: internPool) - let names = Names(json: jsonName, proto: protoName) - numberToNameMap[number] = names - protoToNumberMap[protoName] = number - jsonToNumberMap[protoName] = number - jsonToNumberMap[jsonName] = number - - case .unique(proto: let p, json: let j): - let jsonName = Name(staticString: j, pool: internPool) - let protoName = Name(staticString: p, pool: internPool) - let names = Names(json: jsonName, proto: protoName) - numberToNameMap[number] = names - protoToNumberMap[protoName] = number - jsonToNumberMap[protoName] = number - jsonToNumberMap[jsonName] = number - - case .aliased(proto: let p, aliases: let aliases): - let protoName = Name(staticString: p, pool: internPool) - let names = Names(json: protoName, proto: protoName) - numberToNameMap[number] = names - protoToNumberMap[protoName] = number - jsonToNumberMap[protoName] = number - for alias in aliases { - let protoName = Name(staticString: alias, pool: internPool) - protoToNumberMap[protoName] = number - jsonToNumberMap[protoName] = number + /// Returns all proto names + internal var names: [Name] { + numberToNameMap.map(\.value.proto) + } + + /// Returns if the given name was reserved. + internal func isReserved(name: UnsafeRawBufferPointer) -> Bool { + guard !reservedNames.isEmpty, + let baseAddress = name.baseAddress, + let s = utf8ToString(bytes: baseAddress, count: name.count) + else { + return false } - } + return reservedNames.contains(s) } - } - - /// Returns the name bundle for the field/enum-case with the given number, or - /// `nil` if there is no match. - internal func names(for number: Int) -> Names? { - return numberToNameMap[number] - } - - /// Returns the field/enum-case number that has the given JSON name, - /// or `nil` if there is no match. - /// - /// This is used by the Text format parser to look up field or enum - /// names using a direct reference to the un-decoded UTF8 bytes. - internal func number(forProtoName raw: UnsafeRawBufferPointer) -> Int? { - let n = Name(transientUtf8Buffer: raw) - return protoToNumberMap[n] - } - - /// Returns the field/enum-case number that has the given JSON name, - /// or `nil` if there is no match. - /// - /// This accepts a regular `String` and is used in JSON parsing - /// only when a field name or enum name was decoded from a string - /// containing backslash escapes. - /// - /// JSON parsing must interpret *both* the JSON name of the - /// field/enum-case provided by the descriptor *as well as* its - /// original proto/text name. - internal func number(forJSONName name: String) -> Int? { - let utf8 = Array(name.utf8) - return utf8.withUnsafeBytes { (buffer: UnsafeRawBufferPointer) in - let n = Name(transientUtf8Buffer: buffer) - return jsonToNumberMap[n] + + /// Returns if the given number was reserved. + internal func isReserved(number: Int32) -> Bool { + for range in reservedRanges { + if range.contains(number) { + return true + } + } + return false } - } - - /// Returns the field/enum-case number that has the given JSON name, - /// or `nil` if there is no match. - /// - /// This is used by the JSON parser when a field name or enum name - /// required no special processing. As a result, we can avoid - /// copying the name and look up the number using a direct reference - /// to the un-decoded UTF8 bytes. - internal func number(forJSONName raw: UnsafeRawBufferPointer) -> Int? { - let n = Name(transientUtf8Buffer: raw) - return jsonToNumberMap[n] - } } + +// The `_NameMap` (and supporting types) are only mutated during their initial +// creation, then for the lifetime of the a process they are constant. Swift +// 5.10 flags the generated `_protobuf_nameMap` usages as a problem +// (https://github.com/apple/swift-protobuf/issues/1560) so this silences those +// warnings since the usage has been deemed safe. +// +// https://github.com/apple/swift-protobuf/issues/1561 is also opened to revisit +// the `_NameMap` generally as it dates back to the days before Swift perferred +// the UTF-8 internal encoding. +extension _NameMap: Sendable {} +extension _NameMap.Name: @unchecked Sendable {} +extension InternPool: @unchecked Sendable {} diff --git a/Sources/SwiftProtobuf/PathDecoder.swift b/Sources/SwiftProtobuf/PathDecoder.swift new file mode 100644 index 000000000..f486623a5 --- /dev/null +++ b/Sources/SwiftProtobuf/PathDecoder.swift @@ -0,0 +1,443 @@ +// Sources/SwiftProtobuf/PathDecoder.swift - Path decoder +// +// Copyright (c) 2014 - 2023 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// Decoder which sets value of a field by its path. +/// +// ----------------------------------------------------------------------------- + +import Foundation + +/// Describes errors can occure during decoding a proto by path. +public enum PathDecodingError: Error { + + /// Describes a mismatch in type of the fields. + /// + /// If a value of type A is applied to a path with type B. + /// this error will be thrown. + case typeMismatch + + /// Describes path is not found in message type. + /// + /// If a message has no field with the given path this + /// error will be thrown. + case pathNotFound +} + +extension Message { + static func number(for field: String) -> Int? { + guard let type = Self.self as? any _ProtoNameProviding.Type else { + return nil + } + guard + let number = Array(field.utf8).withUnsafeBytes({ bytes in + type._protobuf_nameMap.number(forProtoName: bytes) + }) + else { + return nil + } + if type._protobuf_nameMap.names(for: number)?.proto.description != field { + return nil + } + return number + } + + static func name(for field: Int) -> String? { + guard let type = Self.self as? any _ProtoNameProviding.Type else { + return nil + } + return type._protobuf_nameMap.names(for: field)?.proto.description + } +} + +// Decoder that set value of a message field by the given path +struct PathDecoder: Decoder { + + // The value should be set to the path + private let value: Any? + + // Field number should be overriden by decoder + private var number: Int? + + // The path only including sub-paths + private let nextPath: [String] + + // Merge options to be concidered while setting value + private let mergeOption: Google_Protobuf_FieldMask.MergeOptions + + private var replaceRepeatedFields: Bool { + mergeOption.replaceRepeatedFields + } + + init( + path: [String], + value: Any?, + mergeOption: Google_Protobuf_FieldMask.MergeOptions + ) throws { + if let firstComponent = path.first, + let number = T.number(for: firstComponent) + { + self.number = number + self.nextPath = .init(path.dropFirst()) + } else { + throw PathDecodingError.pathNotFound + } + self.value = value + self.mergeOption = mergeOption + } + + private func setValue(_ value: inout V, defaultValue: V) throws { + if !nextPath.isEmpty { + throw PathDecodingError.pathNotFound + } + if self.value == nil { + value = defaultValue + return + } + guard let castedValue = self.value as? V else { + throw PathDecodingError.typeMismatch + } + value = castedValue + } + + private func setRepeatedValue(_ value: inout [V]) throws { + if !nextPath.isEmpty { + throw PathDecodingError.pathNotFound + } + var castedValue: [V] = [] + if self.value != nil { + guard let v = self.value as? [V] else { + throw PathDecodingError.typeMismatch + } + castedValue = v + } + if replaceRepeatedFields { + value = castedValue + } else { + value.append(contentsOf: castedValue) + } + } + + private func setMapValue( + _ value: inout [K: V] + ) throws { + if !nextPath.isEmpty { + throw PathDecodingError.pathNotFound + } + var castedValue: [K: V] = [:] + if self.value != nil { + guard let v = self.value as? [K: V] else { + throw PathDecodingError.typeMismatch + } + castedValue = v + } + if replaceRepeatedFields { + value = castedValue + } else { + value.merge(castedValue) { _, new in + new + } + } + } + + private func setMessageValue( + _ value: inout M? + ) throws { + if nextPath.isEmpty { + try setValue(&value, defaultValue: nil) + return + } + var decoder = try PathDecoder( + path: nextPath, + value: self.value, + mergeOption: mergeOption + ) + if value == nil { + value = .init() + } + try value?.decodeMessage(decoder: &decoder) + } + + mutating func handleConflictingOneOf() throws {} + + mutating func nextFieldNumber() throws -> Int? { + defer { number = nil } + return number + } + + mutating func decodeSingularFloatField(value: inout Float) throws { + try setValue(&value, defaultValue: .init()) + } + + mutating func decodeSingularFloatField(value: inout Float?) throws { + try setValue(&value, defaultValue: nil) + } + + mutating func decodeRepeatedFloatField(value: inout [Float]) throws { + try setRepeatedValue(&value) + } + + mutating func decodeSingularDoubleField(value: inout Double) throws { + try setValue(&value, defaultValue: .init()) + } + + mutating func decodeSingularDoubleField(value: inout Double?) throws { + try setValue(&value, defaultValue: nil) + } + + mutating func decodeRepeatedDoubleField(value: inout [Double]) throws { + try setRepeatedValue(&value) + } + + mutating func decodeSingularInt32Field(value: inout Int32) throws { + try setValue(&value, defaultValue: .init()) + } + + mutating func decodeSingularInt32Field(value: inout Int32?) throws { + try setValue(&value, defaultValue: nil) + } + + mutating func decodeRepeatedInt32Field(value: inout [Int32]) throws { + try setRepeatedValue(&value) + } + + mutating func decodeSingularInt64Field(value: inout Int64) throws { + try setValue(&value, defaultValue: .init()) + } + + mutating func decodeSingularInt64Field(value: inout Int64?) throws { + try setValue(&value, defaultValue: nil) + } + + mutating func decodeRepeatedInt64Field(value: inout [Int64]) throws { + try setRepeatedValue(&value) + } + + mutating func decodeSingularUInt32Field(value: inout UInt32) throws { + try setValue(&value, defaultValue: .init()) + } + + mutating func decodeSingularUInt32Field(value: inout UInt32?) throws { + try setValue(&value, defaultValue: nil) + } + + mutating func decodeRepeatedUInt32Field(value: inout [UInt32]) throws { + try setRepeatedValue(&value) + } + + mutating func decodeSingularUInt64Field(value: inout UInt64) throws { + try setValue(&value, defaultValue: .init()) + } + + mutating func decodeSingularUInt64Field(value: inout UInt64?) throws { + try setValue(&value, defaultValue: nil) + } + + mutating func decodeRepeatedUInt64Field(value: inout [UInt64]) throws { + try setRepeatedValue(&value) + } + + mutating func decodeSingularSInt32Field(value: inout Int32) throws { + try setValue(&value, defaultValue: .init()) + } + + mutating func decodeSingularSInt32Field(value: inout Int32?) throws { + try setValue(&value, defaultValue: nil) + } + + mutating func decodeRepeatedSInt32Field(value: inout [Int32]) throws { + try setRepeatedValue(&value) + } + + mutating func decodeSingularSInt64Field(value: inout Int64) throws { + try setValue(&value, defaultValue: .init()) + } + + mutating func decodeSingularSInt64Field(value: inout Int64?) throws { + try setValue(&value, defaultValue: nil) + } + + mutating func decodeRepeatedSInt64Field(value: inout [Int64]) throws { + try setRepeatedValue(&value) + } + + mutating func decodeSingularFixed32Field(value: inout UInt32) throws { + try setValue(&value, defaultValue: .init()) + } + + mutating func decodeSingularFixed32Field(value: inout UInt32?) throws { + try setValue(&value, defaultValue: nil) + } + + mutating func decodeRepeatedFixed32Field(value: inout [UInt32]) throws { + try setRepeatedValue(&value) + } + + mutating func decodeSingularFixed64Field(value: inout UInt64) throws { + try setValue(&value, defaultValue: .init()) + } + + mutating func decodeSingularFixed64Field(value: inout UInt64?) throws { + try setValue(&value, defaultValue: nil) + } + + mutating func decodeRepeatedFixed64Field(value: inout [UInt64]) throws { + try setRepeatedValue(&value) + } + + mutating func decodeSingularSFixed32Field(value: inout Int32) throws { + try setValue(&value, defaultValue: .init()) + } + + mutating func decodeSingularSFixed32Field(value: inout Int32?) throws { + try setValue(&value, defaultValue: nil) + } + + mutating func decodeRepeatedSFixed32Field(value: inout [Int32]) throws { + try setRepeatedValue(&value) + } + + mutating func decodeSingularSFixed64Field(value: inout Int64) throws { + try setValue(&value, defaultValue: .init()) + } + + mutating func decodeSingularSFixed64Field(value: inout Int64?) throws { + try setValue(&value, defaultValue: nil) + } + + mutating func decodeRepeatedSFixed64Field(value: inout [Int64]) throws { + try setRepeatedValue(&value) + } + + mutating func decodeSingularBoolField(value: inout Bool) throws { + try setValue(&value, defaultValue: .init()) + } + + mutating func decodeSingularBoolField(value: inout Bool?) throws { + try setValue(&value, defaultValue: nil) + } + + mutating func decodeRepeatedBoolField(value: inout [Bool]) throws { + try setRepeatedValue(&value) + } + + mutating func decodeSingularStringField(value: inout String) throws { + try setValue(&value, defaultValue: .init()) + } + + mutating func decodeSingularStringField(value: inout String?) throws { + try setValue(&value, defaultValue: nil) + } + + mutating func decodeRepeatedStringField(value: inout [String]) throws { + try setRepeatedValue(&value) + } + + mutating func decodeSingularBytesField(value: inout Data) throws { + try setValue(&value, defaultValue: .init()) + } + + mutating func decodeSingularBytesField(value: inout Data?) throws { + try setValue(&value, defaultValue: nil) + } + + mutating func decodeRepeatedBytesField(value: inout [Data]) throws { + try setRepeatedValue(&value) + } + + mutating func decodeSingularEnumField( + value: inout E + ) throws where E: Enum, E.RawValue == Int { + try setValue(&value, defaultValue: .init()) + } + + mutating func decodeSingularEnumField( + value: inout E? + ) throws where E: Enum, E.RawValue == Int { + try setValue(&value, defaultValue: nil) + } + + mutating func decodeRepeatedEnumField( + value: inout [E] + ) throws where E: Enum, E.RawValue == Int { + try setRepeatedValue(&value) + } + + mutating func decodeSingularMessageField( + value: inout M? + ) throws where M: Message { + try setMessageValue(&value) + } + + mutating func decodeRepeatedMessageField( + value: inout [M] + ) throws where M: Message { + try setRepeatedValue(&value) + } + + mutating func decodeSingularGroupField( + value: inout G? + ) throws where G: Message { + try setMessageValue(&value) + } + + mutating func decodeRepeatedGroupField( + value: inout [G] + ) throws where G: Message { + try setRepeatedValue(&value) + } + + mutating func decodeMapField( + fieldType: _ProtobufMap.Type, + value: inout _ProtobufMap.BaseType + ) throws where KeyType: MapKeyType, ValueType: MapValueType { + try setMapValue(&value) + } + + mutating func decodeMapField( + fieldType: _ProtobufEnumMap.Type, + value: inout _ProtobufEnumMap.BaseType + ) throws where KeyType: MapKeyType, ValueType: Enum, ValueType.RawValue == Int { + try setMapValue(&value) + } + + mutating func decodeMapField( + fieldType: _ProtobufMessageMap.Type, + value: inout _ProtobufMessageMap.BaseType + ) throws where KeyType: MapKeyType, ValueType: Hashable, ValueType: Message { + try setMapValue(&value) + } + + mutating func decodeExtensionField( + values: inout ExtensionFieldValueSet, + messageType: any Message.Type, + fieldNumber: Int + ) throws { + preconditionFailure( + "Internal Error: Path decoder should never decode an extension field" + ) + } + +} + +extension Message { + mutating func `set`( + path: String, + value: Any?, + mergeOption: Google_Protobuf_FieldMask.MergeOptions + ) throws { + let _path = path.components(separatedBy: ".") + var decoder = try PathDecoder( + path: _path, + value: value, + mergeOption: mergeOption + ) + try decodeMessage(decoder: &decoder) + } +} diff --git a/Sources/SwiftProtobuf/PathVisitor.swift b/Sources/SwiftProtobuf/PathVisitor.swift new file mode 100644 index 000000000..54069c9a4 --- /dev/null +++ b/Sources/SwiftProtobuf/PathVisitor.swift @@ -0,0 +1,284 @@ +// Sources/SwiftProtobuf/PathVisitor.swift - Path visitor +// +// Copyright (c) 2014 - 2023 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// Visitor which captures a pair of paths and their values. +/// +// ----------------------------------------------------------------------------- + +import Foundation + +// Visitor captures all values of message with their paths +struct PathVisitor: Visitor { + + // The path contains parent components + private let prevPath: String? + + // Captured values after visiting will be stored in this property + private(set) var values: [String: Any] = [:] + + internal init(prevPath: String? = nil) { + self.prevPath = prevPath + } + + mutating private func visit(_ value: Any, fieldNumber: Int) { + guard let name = T.name(for: fieldNumber) else { + return + } + if let prevPath { + values["\(prevPath).\(name)"] = value + } else { + values[name] = value + } + } + + mutating private func visitMessageField( + _ value: M, + fieldNumber: Int + ) { + guard var path = T.name(for: fieldNumber) else { + return + } + if let prevPath { + path = "\(prevPath).\(path)" + } + values[path] = value + var visitor = PathVisitor(prevPath: path) + try? value.traverse(visitor: &visitor) + values.merge(visitor.values) { _, new in + new + } + } + + mutating func visitUnknown(bytes: Data) throws {} + + mutating func visitSingularFloatField(value: Float, fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitSingularInt32Field(value: Int32, fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitSingularUInt32Field(value: UInt32, fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitSingularSInt32Field(value: Int32, fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitSingularSInt64Field(value: Int64, fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitSingularFixed32Field(value: UInt32, fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitSingularFixed64Field(value: UInt64, fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitSingularSFixed32Field(value: Int32, fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitSingularSFixed64Field(value: Int64, fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitSingularStringField(value: String, fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitSingularEnumField(value: E, fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitSingularMessageField(value: M, fieldNumber: Int) throws { + visitMessageField(value, fieldNumber: fieldNumber) + } + + mutating func visitSingularGroupField(value: G, fieldNumber: Int) throws { + visitMessageField(value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedFloatField(value: [Float], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedDoubleField(value: [Double], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedInt32Field(value: [Int32], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedInt64Field(value: [Int64], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedUInt32Field(value: [UInt32], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedUInt64Field(value: [UInt64], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedSInt32Field(value: [Int32], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedSInt64Field(value: [Int64], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedFixed32Field(value: [UInt32], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedFixed64Field(value: [UInt64], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedSFixed32Field(value: [Int32], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedSFixed64Field(value: [Int64], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedBoolField(value: [Bool], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedStringField(value: [String], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedBytesField(value: [Data], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedEnumField(value: [E], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedMessageField(value: [M], fieldNumber: Int) throws where M: Message { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedGroupField(value: [G], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitPackedFloatField(value: [Float], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitPackedDoubleField(value: [Double], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitPackedInt32Field(value: [Int32], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitPackedInt64Field(value: [Int64], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitPackedUInt32Field(value: [UInt32], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitPackedUInt64Field(value: [UInt64], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitPackedSInt32Field(value: [Int32], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitPackedSInt64Field(value: [Int64], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitPackedFixed32Field(value: [UInt32], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitPackedFixed64Field(value: [UInt64], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitPackedSFixed32Field(value: [Int32], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitPackedSFixed64Field(value: [Int64], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitPackedBoolField(value: [Bool], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitPackedEnumField(value: [E], fieldNumber: Int) throws { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitMapField( + fieldType: _ProtobufMap.Type, + value: _ProtobufMap.BaseType, + fieldNumber: Int + ) throws where KeyType: MapKeyType, ValueType: MapValueType { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitMapField( + fieldType: _ProtobufEnumMap.Type, + value: _ProtobufEnumMap.BaseType, + fieldNumber: Int + ) throws where KeyType: MapKeyType, ValueType: Enum, ValueType.RawValue == Int { + visit(value, fieldNumber: fieldNumber) + } + + mutating func visitMapField( + fieldType: _ProtobufMessageMap.Type, + value: _ProtobufMessageMap.BaseType, + fieldNumber: Int + ) throws where KeyType: MapKeyType, ValueType: Hashable, ValueType: Message { + visit(value, fieldNumber: fieldNumber) + } +} diff --git a/SwiftProtobuf.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/Sources/SwiftProtobuf/PrivacyInfo.xcprivacy similarity index 50% rename from SwiftProtobuf.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist rename to Sources/SwiftProtobuf/PrivacyInfo.xcprivacy index 18d981003..e54075072 100644 --- a/SwiftProtobuf.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist +++ b/Sources/SwiftProtobuf/PrivacyInfo.xcprivacy @@ -2,7 +2,13 @@ - IDEDidComputeMac32BitWarning - + NSPrivacyTracking + + NSPrivacyAccessedAPITypes + + NSPrivacyCollectedDataTypes + + NSPrivacyTrackingDomains + diff --git a/Sources/SwiftProtobuf/ProtoNameProviding.swift b/Sources/SwiftProtobuf/ProtoNameProviding.swift index 8b5a81c15..e0eb4dd5b 100644 --- a/Sources/SwiftProtobuf/ProtoNameProviding.swift +++ b/Sources/SwiftProtobuf/ProtoNameProviding.swift @@ -8,7 +8,6 @@ // // ----------------------------------------------------------------------------- - /// SwiftProtobuf Internal: Common support looking up field names. /// /// Messages conform to this protocol to provide the proto/text and JSON field @@ -17,7 +16,7 @@ /// (reducing bloat and minimizing leaks of field names). public protocol _ProtoNameProviding { - /// The mapping between field numbers and proto/JSON field names defined in - /// the conforming message type. - static var _protobuf_nameMap: _NameMap { get } + /// The mapping between field numbers and proto/JSON field names defined in + /// the conforming message type. + static var _protobuf_nameMap: _NameMap { get } } diff --git a/Sources/SwiftProtobuf/ProtobufAPIVersionCheck.swift b/Sources/SwiftProtobuf/ProtobufAPIVersionCheck.swift index 480305e68..4ef92dd03 100644 --- a/Sources/SwiftProtobuf/ProtobufAPIVersionCheck.swift +++ b/Sources/SwiftProtobuf/ProtobufAPIVersionCheck.swift @@ -19,7 +19,6 @@ /// // ----------------------------------------------------------------------------- - /// An empty protocol that encodes the version of the runtime library. /// /// This protocol will be replaced with one containing a different version @@ -39,5 +38,5 @@ public protocol ProtobufAPIVersion_2 {} /// causing a compile-time error (with reasonable diagnostics) if they are /// incompatible. public protocol ProtobufAPIVersionCheck { - associatedtype Version: ProtobufAPIVersion_2 + associatedtype Version: ProtobufAPIVersion_2 } diff --git a/Sources/SwiftProtobuf/ProtobufMap.swift b/Sources/SwiftProtobuf/ProtobufMap.swift index a9c4d80ef..d1181287a 100644 --- a/Sources/SwiftProtobuf/ProtobufMap.swift +++ b/Sources/SwiftProtobuf/ProtobufMap.swift @@ -15,25 +15,22 @@ import Foundation /// SwiftProtobuf Internal: Support for Encoding/Decoding. -public struct _ProtobufMap -{ +public struct _ProtobufMap { public typealias Key = KeyType.BaseType public typealias Value = ValueType.BaseType - public typealias BaseType = Dictionary + public typealias BaseType = [Key: Value] } /// SwiftProtobuf Internal: Support for Encoding/Decoding. -public struct _ProtobufMessageMap -{ +public struct _ProtobufMessageMap { public typealias Key = KeyType.BaseType public typealias Value = ValueType - public typealias BaseType = Dictionary + public typealias BaseType = [Key: Value] } /// SwiftProtobuf Internal: Support for Encoding/Decoding. -public struct _ProtobufEnumMap -{ +public struct _ProtobufEnumMap { public typealias Key = KeyType.BaseType public typealias Value = ValueType - public typealias BaseType = Dictionary + public typealias BaseType = [Key: Value] } diff --git a/Sources/SwiftProtobuf/SelectiveVisitor.swift b/Sources/SwiftProtobuf/SelectiveVisitor.swift index e8dc4073a..a85dc674a 100644 --- a/Sources/SwiftProtobuf/SelectiveVisitor.swift +++ b/Sources/SwiftProtobuf/SelectiveVisitor.swift @@ -16,7 +16,7 @@ import Foundation /// A base for Visitors that only expects a subset of things to called. internal protocol SelectiveVisitor: Visitor { - // Adds nothing. + // Adds nothing. } /// Default impls for everything so things using this only have to write the @@ -27,242 +27,243 @@ internal protocol SelectiveVisitor: Visitor { /// provided by Visitor to bridge packed->repeated, repeated->singular, etc /// won't kick in. extension SelectiveVisitor { - internal mutating func visitSingularFloatField(value: Float, fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitSingularFloatField(value: Float, fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitSingularInt32Field(value: Int32, fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitSingularInt32Field(value: Int32, fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitSingularUInt32Field(value: UInt32, fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitSingularUInt32Field(value: UInt32, fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitSingularSInt32Field(value: Int32, fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitSingularSInt32Field(value: Int32, fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitSingularSInt64Field(value: Int64, fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitSingularSInt64Field(value: Int64, fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitSingularFixed32Field(value: UInt32, fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitSingularFixed32Field(value: UInt32, fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitSingularFixed64Field(value: UInt64, fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitSingularFixed64Field(value: UInt64, fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitSingularSFixed32Field(value: Int32, fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitSingularSFixed32Field(value: Int32, fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitSingularSFixed64Field(value: Int64, fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitSingularSFixed64Field(value: Int64, fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitSingularStringField(value: String, fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitSingularStringField(value: String, fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitSingularEnumField(value: E, fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitSingularEnumField(value: E, fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitSingularMessageField(value: M, fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitSingularMessageField(value: M, fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitSingularGroupField(value: G, fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitSingularGroupField(value: G, fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitRepeatedFloatField(value: [Float], fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitRepeatedFloatField(value: [Float], fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitRepeatedDoubleField(value: [Double], fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitRepeatedDoubleField(value: [Double], fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitRepeatedInt32Field(value: [Int32], fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitRepeatedInt32Field(value: [Int32], fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitRepeatedInt64Field(value: [Int64], fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitRepeatedInt64Field(value: [Int64], fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitRepeatedUInt32Field(value: [UInt32], fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitRepeatedUInt32Field(value: [UInt32], fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitRepeatedUInt64Field(value: [UInt64], fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitRepeatedUInt64Field(value: [UInt64], fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitRepeatedSInt32Field(value: [Int32], fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitRepeatedSInt32Field(value: [Int32], fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitRepeatedSInt64Field(value: [Int64], fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitRepeatedSInt64Field(value: [Int64], fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitRepeatedFixed32Field(value: [UInt32], fieldNumber: Int) throws { - assert(false) - } + internal mutating func visitRepeatedFixed32Field(value: [UInt32], fieldNumber: Int) throws { + assert(false) + } - internal mutating func visitRepeatedFixed64Field(value: [UInt64], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitRepeatedSFixed32Field(value: [Int32], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitRepeatedSFixed64Field(value: [Int64], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitRepeatedBoolField(value: [Bool], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitRepeatedStringField(value: [String], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitRepeatedBytesField(value: [Data], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitRepeatedEnumField(value: [E], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitRepeatedMessageField(value: [M], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitRepeatedGroupField(value: [G], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitPackedFloatField(value: [Float], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitPackedDoubleField(value: [Double], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitPackedInt32Field(value: [Int32], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitPackedInt64Field(value: [Int64], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitPackedUInt32Field(value: [UInt32], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitPackedUInt64Field(value: [UInt64], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitPackedSInt32Field(value: [Int32], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitPackedSInt64Field(value: [Int64], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitPackedFixed32Field(value: [UInt32], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitPackedFixed64Field(value: [UInt64], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitPackedSFixed32Field(value: [Int32], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitPackedSFixed64Field(value: [Int64], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitPackedBoolField(value: [Bool], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitPackedEnumField(value: [E], fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitMapField( - fieldType: _ProtobufMap.Type, - value: _ProtobufMap.BaseType, - fieldNumber: Int) throws { - assert(false) - } - - internal mutating func visitMapField( - fieldType: _ProtobufEnumMap.Type, - value: _ProtobufEnumMap.BaseType, - fieldNumber: Int - ) throws where ValueType.RawValue == Int { - assert(false) - } - - internal mutating func visitMapField( - fieldType: _ProtobufMessageMap.Type, - value: _ProtobufMessageMap.BaseType, - fieldNumber: Int - ) throws { - assert(false) - } - - internal mutating func visitExtensionFields(fields: ExtensionFieldValueSet, start: Int, end: Int) throws { - assert(false) - } - - internal mutating func visitExtensionFieldsAsMessageSet( - fields: ExtensionFieldValueSet, - start: Int, - end: Int - ) throws { - assert(false) - } - - internal mutating func visitUnknown(bytes: Data) throws { - assert(false) - } + internal mutating func visitRepeatedFixed64Field(value: [UInt64], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitRepeatedSFixed32Field(value: [Int32], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitRepeatedSFixed64Field(value: [Int64], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitRepeatedBoolField(value: [Bool], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitRepeatedStringField(value: [String], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitRepeatedBytesField(value: [Data], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitRepeatedEnumField(value: [E], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitRepeatedMessageField(value: [M], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitRepeatedGroupField(value: [G], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitPackedFloatField(value: [Float], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitPackedDoubleField(value: [Double], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitPackedInt32Field(value: [Int32], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitPackedInt64Field(value: [Int64], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitPackedUInt32Field(value: [UInt32], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitPackedUInt64Field(value: [UInt64], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitPackedSInt32Field(value: [Int32], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitPackedSInt64Field(value: [Int64], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitPackedFixed32Field(value: [UInt32], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitPackedFixed64Field(value: [UInt64], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitPackedSFixed32Field(value: [Int32], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitPackedSFixed64Field(value: [Int64], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitPackedBoolField(value: [Bool], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitPackedEnumField(value: [E], fieldNumber: Int) throws { + assert(false) + } + + internal mutating func visitMapField( + fieldType: _ProtobufMap.Type, + value: _ProtobufMap.BaseType, + fieldNumber: Int + ) throws { + assert(false) + } + + internal mutating func visitMapField( + fieldType: _ProtobufEnumMap.Type, + value: _ProtobufEnumMap.BaseType, + fieldNumber: Int + ) throws where ValueType.RawValue == Int { + assert(false) + } + + internal mutating func visitMapField( + fieldType: _ProtobufMessageMap.Type, + value: _ProtobufMessageMap.BaseType, + fieldNumber: Int + ) throws { + assert(false) + } + + internal mutating func visitExtensionFields(fields: ExtensionFieldValueSet, start: Int, end: Int) throws { + assert(false) + } + + internal mutating func visitExtensionFieldsAsMessageSet( + fields: ExtensionFieldValueSet, + start: Int, + end: Int + ) throws { + assert(false) + } + + internal mutating func visitUnknown(bytes: Data) throws { + assert(false) + } } diff --git a/Sources/SwiftProtobuf/SimpleExtensionMap.swift b/Sources/SwiftProtobuf/SimpleExtensionMap.swift index ad4708602..62ed45aa1 100644 --- a/Sources/SwiftProtobuf/SimpleExtensionMap.swift +++ b/Sources/SwiftProtobuf/SimpleExtensionMap.swift @@ -12,27 +12,26 @@ /// // ----------------------------------------------------------------------------- - // Note: The generated code only relies on ExpressibleByArrayLiteral -public struct SimpleExtensionMap: ExtensionMap, ExpressibleByArrayLiteral, CustomDebugStringConvertible { +public struct SimpleExtensionMap: ExtensionMap, ExpressibleByArrayLiteral { public typealias Element = AnyMessageExtension // Since type objects aren't Hashable, we can't do much better than this... - internal var fields = [Int: Array]() + package var fields = [Int: [any AnyMessageExtension]]() public init() {} - public init(arrayLiteral: Element...) { + public init(arrayLiteral: any Element...) { insert(contentsOf: arrayLiteral) } public init(_ others: SimpleExtensionMap...) { - for other in others { - formUnion(other) - } + for other in others { + formUnion(other) + } } - public subscript(messageType: Message.Type, fieldNumber: Int) -> AnyMessageExtension? { + public subscript(messageType: any Message.Type, fieldNumber: Int) -> (any AnyMessageExtension)? { get { if let l = fields[fieldNumber] { for e in l { @@ -45,7 +44,7 @@ public struct SimpleExtensionMap: ExtensionMap, ExpressibleByArrayLiteral, Custo } } - public func fieldNumberForProto(messageType: Message.Type, protoFieldName: String) -> Int? { + public func fieldNumberForProto(messageType: any Message.Type, protoFieldName: String) -> Int? { // TODO: Make this faster... for (_, list) in fields { for e in list { @@ -57,11 +56,11 @@ public struct SimpleExtensionMap: ExtensionMap, ExpressibleByArrayLiteral, Custo return nil } - public mutating func insert(_ newValue: Element) { + public mutating func insert(_ newValue: any Element) { let fieldNumber = newValue.fieldNumber if let l = fields[fieldNumber] { let messageType = newValue.messageType - var newL = l.filter { return $0.messageType != messageType } + var newL = l.filter { $0.messageType != messageType } newL.append(newValue) fields[fieldNumber] = newL } else { @@ -69,7 +68,7 @@ public struct SimpleExtensionMap: ExtensionMap, ExpressibleByArrayLiteral, Custo } } - public mutating func insert(contentsOf: [Element]) { + public mutating func insert(contentsOf: [any Element]) { for e in contentsOf { insert(e) } @@ -98,7 +97,11 @@ public struct SimpleExtensionMap: ExtensionMap, ExpressibleByArrayLiteral, Custo return out } +} + +extension SimpleExtensionMap: CustomDebugStringConvertible { public var debugDescription: String { + #if DEBUG var names = [String]() for (_, list) in fields { for e in list { @@ -107,6 +110,8 @@ public struct SimpleExtensionMap: ExtensionMap, ExpressibleByArrayLiteral, Custo } let d = names.joined(separator: ",") return "SimpleExtensionMap(\(d))" + #else + return String(reflecting: type(of: self)) + #endif } - } diff --git a/Sources/SwiftProtobuf/StringUtils.swift b/Sources/SwiftProtobuf/StringUtils.swift index aea5feef6..063989166 100644 --- a/Sources/SwiftProtobuf/StringUtils.swift +++ b/Sources/SwiftProtobuf/StringUtils.swift @@ -26,43 +26,42 @@ import Foundation // Note: We're trying to avoid Foundation's String(format:) since that's not // universally available. -fileprivate func formatZeroPaddedInt(_ value: Int32, digits: Int) -> String { - precondition(value >= 0) - let s = String(value) - if s.count >= digits { - return s - } else { - let pad = String(repeating: "0", count: digits - s.count) - return pad + s - } +private func formatZeroPaddedInt(_ value: Int32, digits: Int) -> String { + precondition(value >= 0) + let s = String(value) + if s.count >= digits { + return s + } else { + let pad = String(repeating: "0", count: digits - s.count) + return pad + s + } } internal func twoDigit(_ value: Int32) -> String { - return formatZeroPaddedInt(value, digits: 2) + formatZeroPaddedInt(value, digits: 2) } internal func threeDigit(_ value: Int32) -> String { - return formatZeroPaddedInt(value, digits: 3) + formatZeroPaddedInt(value, digits: 3) } internal func fourDigit(_ value: Int32) -> String { - return formatZeroPaddedInt(value, digits: 4) + formatZeroPaddedInt(value, digits: 4) } internal func sixDigit(_ value: Int32) -> String { - return formatZeroPaddedInt(value, digits: 6) + formatZeroPaddedInt(value, digits: 6) } internal func nineDigit(_ value: Int32) -> String { - return formatZeroPaddedInt(value, digits: 9) + formatZeroPaddedInt(value, digits: 9) } // Wrapper that takes a buffer and start/end offsets internal func utf8ToString( - bytes: UnsafeRawBufferPointer, - start: UnsafeRawBufferPointer.Index, - end: UnsafeRawBufferPointer.Index + bytes: UnsafeRawBufferPointer, + start: UnsafeRawBufferPointer.Index, + end: UnsafeRawBufferPointer.Index ) -> String? { - return utf8ToString(bytes: bytes.baseAddress! + start, count: end - start) + utf8ToString(bytes: bytes.baseAddress! + start, count: end - start) } - // Swift 4 introduced new faster String facilities // that seem to work consistently across all platforms. @@ -79,28 +78,38 @@ internal func utf8ToString( // slower than on macOS, so this is a much bigger // win there. internal func utf8ToString(bytes: UnsafeRawPointer, count: Int) -> String? { - if count == 0 { - return String() - } - let codeUnits = UnsafeRawBufferPointer(start: bytes, count: count) - let sourceEncoding = Unicode.UTF8.self + if count == 0 { + return String() + } + let codeUnits = UnsafeRawBufferPointer(start: bytes, count: count) + let sourceEncoding = Unicode.UTF8.self - // Verify that the UTF-8 is valid. - var p = sourceEncoding.ForwardParser() - var i = codeUnits.makeIterator() - Loop: - while true { - switch p.parseScalar(from: &i) { - case .valid(_): - break - case .error: - return nil - case .emptyInput: - break Loop + // Verify that the UTF-8 is valid. + var p = sourceEncoding.ForwardParser() + var i = codeUnits.makeIterator() + Loop: while true { + switch p.parseScalar(from: &i) { + case .valid(_): + break + case .error: + return nil + case .emptyInput: + break Loop + } } - } - // This initializer is fast but does not reject broken - // UTF-8 (which is why we validate the UTF-8 above). - return String(decoding: codeUnits, as: sourceEncoding) - } + // This initializer is fast but does not reject broken + // UTF-8 (which is why we validate the UTF-8 above). + return String(decoding: codeUnits, as: sourceEncoding) +} + +extension Unicode.Scalar { + /// Assuming the given scalar is ASCII, this is the uppercased equivalent (unchanged if it is + /// not a lowercase alphabetic character). + var uppercasedAssumingASCII: Unicode.Scalar { + guard "a" <= self && self <= "z" else { + return self + } + return Self(value & 0x5f)! + } +} diff --git a/Sources/SwiftProtobuf/SwiftProtobufContiguousBytes.swift b/Sources/SwiftProtobuf/SwiftProtobufContiguousBytes.swift new file mode 100644 index 000000000..380a592d7 --- /dev/null +++ b/Sources/SwiftProtobuf/SwiftProtobufContiguousBytes.swift @@ -0,0 +1,57 @@ +// Sources/SwiftProtobuf/SwiftProtobufContiguousBytes.swift +// +// Copyright (c) 2022 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +import Foundation + +/// Conformance to this protocol gives users a way to provide their own "bag of bytes" types +/// to be used for serialization and deserialization of protobufs. +/// It provides a general interface for bytes since the Swift Standard Library currently does not +/// provide such a protocol. +/// +/// By conforming your own types to this protocol, you will be able to pass instances of said types +/// directly to `SwiftProtobuf.Message`'s deserialisation methods +/// (i.e. `init(contiguousBytes:)` for binary format and `init(jsonUTF8Bytes:)` for JSON). +public protocol SwiftProtobufContiguousBytes { + /// An initializer for a bag of bytes type. + /// + /// - Parameters: + /// - repeating: the byte value to be repeated. + /// - count: the number of times to repeat the byte value. + init(repeating: UInt8, count: Int) + + /// An initializer for a bag of bytes type, given a sequence of bytes. + /// + /// - Parameters: + /// - sequence: a sequence of UInt8 from which the bag of bytes should be constructed. + init(_ sequence: S) where S.Element == UInt8 + + /// The number of bytes in the bag of bytes. + var count: Int { get } + + /// Calls the given closure with the contents of underlying storage. + /// + /// - note: Calling `withUnsafeBytes` multiple times does not guarantee that + /// the same buffer pointer will be passed in every time. + /// - warning: The buffer argument to the body should not be stored or used + /// outside of the lifetime of the call to the closure. + func withUnsafeBytes(_ body: (UnsafeRawBufferPointer) throws -> R) rethrows -> R + + /// Calls the given closure with the contents of underlying storage. + /// + /// - note: Calling `withUnsafeBytes` multiple times does not guarantee that + /// the same buffer pointer will be passed in every time. + /// - warning: The buffer argument to the body should not be stored or used + /// outside of the lifetime of the call to the closure. + mutating func withUnsafeMutableBytes(_ body: (UnsafeMutableRawBufferPointer) throws -> R) rethrows -> R +} + +extension Array: SwiftProtobufContiguousBytes where Array.Element == UInt8 {} + +extension Data: SwiftProtobufContiguousBytes {} diff --git a/Sources/SwiftProtobuf/SwiftProtobufError.swift b/Sources/SwiftProtobuf/SwiftProtobufError.swift new file mode 100644 index 000000000..695feaa9e --- /dev/null +++ b/Sources/SwiftProtobuf/SwiftProtobufError.swift @@ -0,0 +1,318 @@ +// Sources/SwiftProtobuf/SwiftProtobufError.swift +// +// Copyright (c) 2024 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +/// A SwiftProtobuf specific error. +/// +/// All errors have a high-level ``SwiftProtobufError/Code-swift.struct`` which identifies the domain +/// of the error. For example, an issue when encoding a proto into binary data will result in a +/// ``SwiftProtobufError/Code-swift.struct/binaryEncodingError`` error code. +/// Errors also include a message describing what went wrong and how to remedy it (if applicable). The +/// ``SwiftProtobufError/message`` is not static and may include dynamic information such as the +/// type URL for a type that could not be decoded, for example. +public struct SwiftProtobufError: Error, @unchecked Sendable { + // Note: @unchecked because we use a backing class for storage. + + private var storage: Storage + private mutating func ensureStorageIsUnique() { + if !isKnownUniquelyReferenced(&self.storage) { + self.storage = self.storage.copy() + } + } + + private final class Storage { + var code: Code + var message: String + var location: SourceLocation + + init( + code: Code, + message: String, + location: SourceLocation + ) { + self.code = code + self.message = message + self.location = location + } + + func copy() -> Self { + Self( + code: self.code, + message: self.message, + location: self.location + ) + } + } + + /// A high-level error code to provide broad a classification. + public var code: Code { + get { self.storage.code } + set { + self.ensureStorageIsUnique() + self.storage.code = newValue + } + } + + /// A message describing what went wrong and how it may be remedied. + package var message: String { + get { self.storage.message } + set { + self.ensureStorageIsUnique() + self.storage.message = newValue + } + } + + private var location: SourceLocation { + get { self.storage.location } + set { + self.ensureStorageIsUnique() + self.storage.location = newValue + } + } + + public init( + code: Code, + message: String, + location: SourceLocation + ) { + self.storage = Storage(code: code, message: message, location: location) + } +} + +extension SwiftProtobufError { + /// A high level indication of the kind of error being thrown. + public struct Code: Hashable, Sendable, CustomStringConvertible { + private enum Wrapped: Hashable, Sendable, CustomStringConvertible { + case binaryDecodingError + case binaryStreamDecodingError + case jsonDecodingError + case jsonEncodingError + + var description: String { + switch self { + case .binaryDecodingError: + return "Binary decoding error" + case .binaryStreamDecodingError: + return "Stream decoding error" + case .jsonDecodingError: + return "JSON decoding error" + case .jsonEncodingError: + return "JSON encoding error" + } + } + } + + /// This Code's description. + public var description: String { + String(describing: self.code) + } + + private var code: Wrapped + private init(_ code: Wrapped) { + self.code = code + } + + /// Errors arising from binary decoding of data into protobufs. + public static var binaryDecodingError: Self { + Self(.binaryDecodingError) + } + + /// Errors arising from decoding streams of binary messages. These errors have to do with the framing + /// of the messages in the stream, or the stream as a whole. + public static var binaryStreamDecodingError: Self { + Self(.binaryStreamDecodingError) + } + + /// Errors arising from JSON decoding of data into protobufs. + public static var jsonDecodingError: Self { + Self(.jsonDecodingError) + } + + /// Errors arising from JSON encoding of messages. + public static var jsonEncodingError: Self { + Self(.jsonEncodingError) + } + } + + /// A location within source code. + public struct SourceLocation: Sendable, Hashable { + /// The function in which the error was thrown. + public var function: String + + /// The file in which the error was thrown. + public var file: String + + /// The line on which the error was thrown. + public var line: Int + + public init(function: String, file: String, line: Int) { + self.function = function + self.file = file + self.line = line + } + + @usableFromInline + internal static func here( + function: String = #function, + file: String = #fileID, + line: Int = #line + ) -> Self { + SourceLocation(function: function, file: file, line: line) + } + } +} + +extension SwiftProtobufError: CustomStringConvertible { + public var description: String { + "\(self.code) (at \(self.location)): \(self.message)" + } +} + +extension SwiftProtobufError: CustomDebugStringConvertible { + public var debugDescription: String { + "\(String(reflecting: self.code)) (at \(String(reflecting: self.location))): \(String(reflecting: self.message))" + } +} + +// - MARK: Common errors + +extension SwiftProtobufError { + /// Errors arising from binary decoding of data into protobufs. + public enum BinaryDecoding { + /// Message is too large. Bytes and Strings have a max size of 2GB. + public static func tooLarge( + function: String = #function, + file: String = #fileID, + line: Int = #line + ) -> SwiftProtobufError { + SwiftProtobufError( + code: .binaryDecodingError, + message: "Message too large: Bytes and Strings have a max size of 2GB.", + location: SourceLocation(function: function, file: file, line: line) + ) + } + } + + /// Errors arising from decoding streams of binary messages. These errors have to do with the framing + /// of the messages in the stream, or the stream as a whole. + public enum BinaryStreamDecoding { + /// Message is too large. Bytes and Strings have a max size of 2GB. + public static func tooLarge( + function: String = #function, + file: String = #fileID, + line: Int = #line + ) -> SwiftProtobufError { + SwiftProtobufError( + code: .binaryStreamDecodingError, + message: "Message too large: Bytes and Strings have a max size of 2GB.", + location: SourceLocation(function: function, file: file, line: line) + ) + } + + /// While attempting to read the length of a message on the stream, the + /// bytes were malformed for the protobuf format. + public static func malformedLength( + function: String = #function, + file: String = #fileID, + line: Int = #line + ) -> SwiftProtobufError { + SwiftProtobufError( + code: .binaryStreamDecodingError, + message: """ + While attempting to read the length of a binary-delimited message \ + on the stream, the bytes were malformed for the protobuf format. + """, + location: .init(function: function, file: file, line: line) + ) + } + + /// This isn't really an error. `InputStream` documents that + /// `hasBytesAvailable` _may_ return `True` if a read is needed to + /// determine if there really are bytes available. So this "error" is thrown + /// when a `parse` or `merge` fails because there were no bytes available. + /// If this is raised, the callers should decide via what ever other means + /// are correct if the stream has completely ended or if more bytes might + /// eventually show up. + public static func noBytesAvailable( + function: String = #function, + file: String = #fileID, + line: Int = #line + ) -> SwiftProtobufError { + SwiftProtobufError( + code: .binaryStreamDecodingError, + message: """ + This is not really an error: please read the documentation for + `SwiftProtobufError/BinaryStreamDecoding/noBytesAvailable` for more information. + """, + location: .init(function: function, file: file, line: line) + ) + } + } + + /// Errors arising from JSON decoding of data into protobufs. + public enum JSONDecoding { + /// While decoding a `google.protobuf.Any` encountered a malformed `@type` key for + /// the `type_url` field. + public static func invalidAnyTypeURL( + type_url: String, + function: String = #function, + file: String = #fileID, + line: Int = #line + ) -> SwiftProtobufError { + SwiftProtobufError( + code: .jsonDecodingError, + message: "google.protobuf.Any '@type' was invalid: \(type_url).", + location: SourceLocation(function: function, file: file, line: line) + ) + } + + /// While decoding a `google.protobuf.Any` no `@type` field but the message had other fields. + public static func emptyAnyTypeURL( + function: String = #function, + file: String = #fileID, + line: Int = #line + ) -> SwiftProtobufError { + SwiftProtobufError( + code: .jsonDecodingError, + message: "google.protobuf.Any '@type' was must be present if if the object is not empty.", + location: SourceLocation(function: function, file: file, line: line) + ) + } + } + + /// Errors arising from JSON encoding of messages. + public enum JSONEncoding { + /// While encoding a `google.protobuf.Any` encountered a malformed `type_url` field. + public static func invalidAnyTypeURL( + type_url: String, + function: String = #function, + file: String = #fileID, + line: Int = #line + ) -> SwiftProtobufError { + SwiftProtobufError( + code: .jsonEncodingError, + message: "google.protobuf.Any 'type_url' was invalid: \(type_url).", + location: SourceLocation(function: function, file: file, line: line) + ) + } + + /// While encoding a `google.protobuf.Any` encountered an empty `type_url` field. + public static func emptyAnyTypeURL( + function: String = #function, + file: String = #fileID, + line: Int = #line + ) -> SwiftProtobufError { + SwiftProtobufError( + code: .jsonEncodingError, + message: "google.protobuf.Any 'type_url' was empty, only allowed for empty objects.", + location: SourceLocation(function: function, file: file, line: line) + ) + } + } +} diff --git a/Sources/SwiftProtobuf/TextFormatDecoder.swift b/Sources/SwiftProtobuf/TextFormatDecoder.swift index 1c99cf4e7..81e1ac72e 100644 --- a/Sources/SwiftProtobuf/TextFormatDecoder.swift +++ b/Sources/SwiftProtobuf/TextFormatDecoder.swift @@ -23,35 +23,36 @@ import Foundation internal struct TextFormatDecoder: Decoder { internal var scanner: TextFormatScanner private var fieldCount = 0 - private var terminator: UInt8? - private var fieldNameMap: _NameMap? - private var messageType: Message.Type? + private let terminator: UInt8? + private let fieldNameMap: _NameMap + private let messageType: any Message.Type - internal var complete: Bool { - mutating get { - return scanner.complete - } + internal var options: TextFormatDecodingOptions { + scanner.options } + internal var complete: Bool { scanner.complete } + internal init( - messageType: Message.Type, - utf8Pointer: UnsafeRawPointer, - count: Int, - options: TextFormatDecodingOptions, - extensions: ExtensionMap? + messageType: any Message.Type, + utf8Pointer: UnsafeRawPointer, + count: Int, + options: TextFormatDecodingOptions, + extensions: (any ExtensionMap)? ) throws { scanner = TextFormatScanner(utf8Pointer: utf8Pointer, count: count, options: options, extensions: extensions) - guard let nameProviding = (messageType as? _ProtoNameProviding.Type) else { + guard let nameProviding = (messageType as? any _ProtoNameProviding.Type) else { throw TextFormatDecodingError.missingFieldNames } fieldNameMap = nameProviding._protobuf_nameMap self.messageType = messageType + self.terminator = nil } - internal init(messageType: Message.Type, scanner: TextFormatScanner, terminator: UInt8?) throws { + internal init(messageType: any Message.Type, scanner: TextFormatScanner, terminator: UInt8?) throws { self.scanner = scanner self.terminator = terminator - guard let nameProviding = (messageType as? _ProtoNameProviding.Type) else { + guard let nameProviding = (messageType as? any _ProtoNameProviding.Type) else { throw TextFormatDecodingError.missingFieldNames } fieldNameMap = nameProviding._protobuf_nameMap @@ -63,31 +64,19 @@ internal struct TextFormatDecoder: Decoder { } mutating func nextFieldNumber() throws -> Int? { - if let terminator = terminator { - if scanner.skipOptionalObjectEnd(terminator) { - return nil - } - } if fieldCount > 0 { scanner.skipOptionalSeparator() } - if let key = try scanner.nextOptionalExtensionKey() { - // Extension key; look up in the extension registry - if let fieldNumber = scanner.extensions?.fieldNumberForProto(messageType: messageType!, protoFieldName: key) { - fieldCount += 1 - return fieldNumber - } else { - throw TextFormatDecodingError.unknownField - } - } else if let fieldNumber = try scanner.nextFieldNumber(names: fieldNameMap!) { + if let fieldNumber = try scanner.nextFieldNumber( + names: fieldNameMap, + messageType: messageType, + terminator: terminator + ) { fieldCount += 1 return fieldNumber - } else if terminator == nil { - return nil } else { - throw TextFormatDecodingError.truncated + return nil } - } mutating func decodeSingularFloatField(value: inout Float) throws { @@ -559,10 +548,14 @@ internal struct TextFormatDecoder: Decoder { try decodeRepeatedMessageField(value: &value) } - private mutating func decodeMapEntry(mapType: _ProtobufMap.Type, value: inout _ProtobufMap.BaseType) throws { + private mutating func decodeMapEntry( + mapType: _ProtobufMap.Type, + value: inout _ProtobufMap.BaseType + ) throws { var keyField: KeyType.BaseType? var valueField: ValueType.BaseType? let terminator = try scanner.skipObjectStart() + let ignoreExtensionFields = options.ignoreUnknownExtensionFields while true { if scanner.skipOptionalObjectEnd(terminator) { if let keyField = keyField, let valueField = valueField { @@ -572,14 +565,20 @@ internal struct TextFormatDecoder: Decoder { throw TextFormatDecodingError.malformedText } } - if let key = try scanner.nextKey() { + if let key = try scanner.nextKey(allowExtensions: ignoreExtensionFields) { switch key { case "key", "1": try KeyType.decodeSingular(value: &keyField, from: &self) case "value", "2": try ValueType.decodeSingular(value: &valueField, from: &self) default: - throw TextFormatDecodingError.unknownField + if ignoreExtensionFields && key.hasPrefix("[") { + try scanner.skipUnknownFieldValue() + } else if options.ignoreUnknownFields && !key.hasPrefix("[") { + try scanner.skipUnknownFieldValue() + } else { + throw TextFormatDecodingError.unknownField + } } scanner.skipOptionalSeparator() } else { @@ -588,7 +587,10 @@ internal struct TextFormatDecoder: Decoder { } } - mutating func decodeMapField(fieldType: _ProtobufMap.Type, value: inout _ProtobufMap.BaseType) throws { + mutating func decodeMapField( + fieldType: _ProtobufMap.Type, + value: inout _ProtobufMap.BaseType + ) throws { _ = scanner.skipOptionalColon() if scanner.skipOptionalBeginArray() { var firstItem = true @@ -608,10 +610,14 @@ internal struct TextFormatDecoder: Decoder { } } - private mutating func decodeMapEntry(mapType: _ProtobufEnumMap.Type, value: inout _ProtobufEnumMap.BaseType) throws where ValueType.RawValue == Int { + private mutating func decodeMapEntry( + mapType: _ProtobufEnumMap.Type, + value: inout _ProtobufEnumMap.BaseType + ) throws where ValueType.RawValue == Int { var keyField: KeyType.BaseType? var valueField: ValueType? let terminator = try scanner.skipObjectStart() + let ignoreExtensionFields = options.ignoreUnknownExtensionFields while true { if scanner.skipOptionalObjectEnd(terminator) { if let keyField = keyField, let valueField = valueField { @@ -621,14 +627,20 @@ internal struct TextFormatDecoder: Decoder { throw TextFormatDecodingError.malformedText } } - if let key = try scanner.nextKey() { + if let key = try scanner.nextKey(allowExtensions: ignoreExtensionFields) { switch key { case "key", "1": try KeyType.decodeSingular(value: &keyField, from: &self) case "value", "2": try decodeSingularEnumField(value: &valueField) default: - throw TextFormatDecodingError.unknownField + if ignoreExtensionFields && key.hasPrefix("[") { + try scanner.skipUnknownFieldValue() + } else if options.ignoreUnknownFields && !key.hasPrefix("[") { + try scanner.skipUnknownFieldValue() + } else { + throw TextFormatDecodingError.unknownField + } } scanner.skipOptionalSeparator() } else { @@ -637,7 +649,10 @@ internal struct TextFormatDecoder: Decoder { } } - mutating func decodeMapField(fieldType: _ProtobufEnumMap.Type, value: inout _ProtobufEnumMap.BaseType) throws where ValueType.RawValue == Int { + mutating func decodeMapField( + fieldType: _ProtobufEnumMap.Type, + value: inout _ProtobufEnumMap.BaseType + ) throws where ValueType.RawValue == Int { _ = scanner.skipOptionalColon() if scanner.skipOptionalBeginArray() { var firstItem = true @@ -657,10 +672,14 @@ internal struct TextFormatDecoder: Decoder { } } - private mutating func decodeMapEntry(mapType: _ProtobufMessageMap.Type, value: inout _ProtobufMessageMap.BaseType) throws { + private mutating func decodeMapEntry( + mapType: _ProtobufMessageMap.Type, + value: inout _ProtobufMessageMap.BaseType + ) throws { var keyField: KeyType.BaseType? var valueField: ValueType? let terminator = try scanner.skipObjectStart() + let ignoreExtensionFields = options.ignoreUnknownExtensionFields while true { if scanner.skipOptionalObjectEnd(terminator) { if let keyField = keyField, let valueField = valueField { @@ -670,14 +689,20 @@ internal struct TextFormatDecoder: Decoder { throw TextFormatDecodingError.malformedText } } - if let key = try scanner.nextKey() { + if let key = try scanner.nextKey(allowExtensions: ignoreExtensionFields) { switch key { case "key", "1": try KeyType.decodeSingular(value: &keyField, from: &self) case "value", "2": try decodeSingularMessageField(value: &valueField) default: - throw TextFormatDecodingError.unknownField + if ignoreExtensionFields && key.hasPrefix("[") { + try scanner.skipUnknownFieldValue() + } else if options.ignoreUnknownFields && !key.hasPrefix("[") { + try scanner.skipUnknownFieldValue() + } else { + throw TextFormatDecodingError.unknownField + } } scanner.skipOptionalSeparator() } else { @@ -686,7 +711,10 @@ internal struct TextFormatDecoder: Decoder { } } - mutating func decodeMapField(fieldType: _ProtobufMessageMap.Type, value: inout _ProtobufMessageMap.BaseType) throws { + mutating func decodeMapField( + fieldType: _ProtobufMessageMap.Type, + value: inout _ProtobufMessageMap.BaseType + ) throws { _ = scanner.skipOptionalColon() if scanner.skipOptionalBeginArray() { var firstItem = true @@ -706,7 +734,11 @@ internal struct TextFormatDecoder: Decoder { } } - mutating func decodeExtensionField(values: inout ExtensionFieldValueSet, messageType: Message.Type, fieldNumber: Int) throws { + mutating func decodeExtensionField( + values: inout ExtensionFieldValueSet, + messageType: any Message.Type, + fieldNumber: Int + ) throws { if let ext = scanner.extensions?[messageType, fieldNumber] { try values.modify(index: fieldNumber) { fieldValue in if fieldValue != nil { diff --git a/Sources/SwiftProtobuf/TextFormatDecodingOptions.swift b/Sources/SwiftProtobuf/TextFormatDecodingOptions.swift index 4713eba43..fbd5cc9e3 100644 --- a/Sources/SwiftProtobuf/TextFormatDecodingOptions.swift +++ b/Sources/SwiftProtobuf/TextFormatDecodingOptions.swift @@ -13,13 +13,27 @@ // ----------------------------------------------------------------------------- /// Options for TextFormatDecoding. -public struct TextFormatDecodingOptions { - /// The maximum nesting of message with messages. The default is 100. - /// - /// To prevent corrupt or malicious messages from causing stack overflows, - /// this controls how deep messages can be nested within other messages - /// while parsing. - public var messageDepthLimit: Int = 100 +public struct TextFormatDecodingOptions: Sendable { + /// The maximum nesting of message with messages. The default is 100. + /// + /// To prevent corrupt or malicious messages from causing stack overflows, + /// this controls how deep messages can be nested within other messages + /// while parsing. + public var messageDepthLimit: Int = 100 - public init() {} + /// If unknown fields in the TextFormat should be ignored. If they aren't + /// ignored, an error will be raised if one is encountered. + /// + /// Note: This is a lossy option, enabling it means part of the TextFormat + /// is silently skipped. + public var ignoreUnknownFields: Bool = false + + /// If unknown extension fields in the TextFormat should be ignored. If they + /// aren't ignored, an error will be raised if one is encountered. + /// + /// Note: This is a lossy option, enabling it means part of the TextFormat + /// is silently skipped. + public var ignoreUnknownExtensionFields: Bool = false + + public init() {} } diff --git a/Sources/SwiftProtobuf/TextFormatEncoder.swift b/Sources/SwiftProtobuf/TextFormatEncoder.swift index 6fe217cdf..4ab5052ae 100644 --- a/Sources/SwiftProtobuf/TextFormatEncoder.swift +++ b/Sources/SwiftProtobuf/TextFormatEncoder.swift @@ -37,7 +37,7 @@ internal struct TextFormatEncoder { private var indentString: [UInt8] = [] var stringResult: String { get { - return String(bytes: data, encoding: String.Encoding.utf8)! + String(decoding: data, as: UTF8.self) } } @@ -231,7 +231,7 @@ internal struct TextFormatEncoder { append(staticText: "\\\"") case 92: append(staticText: "\\\\") - case 0...31, 127: // Octal form for C0 control chars + case 0...31, 127: // Octal form for C0 control chars data.append(asciiBackslash) data.append(asciiZero + UInt8(c.value / 64)) data.append(asciiZero + UInt8(c.value / 8 % 8)) @@ -258,39 +258,38 @@ internal struct TextFormatEncoder { mutating func putBytesValue(value: Data) { data.append(asciiDoubleQuote) value.withUnsafeBytes { (body: UnsafeRawBufferPointer) in - if let p = body.baseAddress, body.count > 0 { - for i in 0.. 0 { + for i in 0.. [UInt8] { - var bytes = [UInt8]() - if let protoName = nameMap?.names(for: fieldNumber)?.proto { - bytes.append(contentsOf: protoName.utf8Buffer) - } else if let protoName = nameResolver[fieldNumber] { - let buff = UnsafeBufferPointer(start: protoName.utf8Start, count: protoName.utf8CodeUnitCount) - bytes.append(contentsOf: buff) - } else if let extensionName = extensions?[fieldNumber]?.protobufExtension.fieldName { - bytes.append(UInt8(ascii: "[")) - bytes.append(contentsOf: extensionName.utf8) - bytes.append(UInt8(ascii: "]")) - } else { - bytes.append(contentsOf: fieldNumber.description.utf8) - } - return bytes - } - - private mutating func emitFieldName(lookingUp fieldNumber: Int) { - if let protoName = nameMap?.names(for: fieldNumber)?.proto { - encoder.emitFieldName(name: protoName.utf8Buffer) - } else if let protoName = nameResolver[fieldNumber] { - encoder.emitFieldName(name: protoName) - } else if let extensionName = extensions?[fieldNumber]?.protobufExtension.fieldName { - encoder.emitExtensionFieldName(name: extensionName) - } else { - encoder.emitFieldNumber(number: fieldNumber) - } - } - - mutating func visitUnknown(bytes: Data) throws { - if options.printUnknownFields { - try bytes.withUnsafeBytes { (body: UnsafeRawBufferPointer) -> () in - if let baseAddress = body.baseAddress, body.count > 0 { - // All fields will be directly handled, so there is no need for - // the unknown field buffering/collection (when scannings to see - // if something is a message, this would be extremely wasteful). - var binaryOptions = BinaryDecodingOptions() - binaryOptions.discardUnknownFields = true - var decoder = BinaryDecoder(forReadingFrom: baseAddress, - count: body.count, - options: binaryOptions) - try visitUnknown(decoder: &decoder) + private var encoder: TextFormatEncoder + private var nameMap: _NameMap? + private var nameResolver: [Int: StaticString] + private var extensions: ExtensionFieldValueSet? + private let options: TextFormatEncodingOptions + + /// The protobuf text produced by the visitor. + var result: String { + encoder.stringResult + } + + /// Creates a new visitor that serializes the given message to protobuf text + /// format. + init(message: any Message, options: TextFormatEncodingOptions) { + let nameMap: _NameMap? + if let nameProviding = message as? (any _ProtoNameProviding) { + nameMap = type(of: nameProviding)._protobuf_nameMap + } else { + nameMap = nil + } + let extensions = (message as? (any ExtensibleMessage))?._protobuf_extensionFieldValues + + self.nameMap = nameMap + self.nameResolver = [:] + self.extensions = extensions + self.encoder = TextFormatEncoder() + self.options = options + } + + // TODO: This largely duplicates emitFieldName() below. + // But, it's slower so we don't want to just have emitFieldName() use + // formatFieldName(). Also, we need to measure whether the optimization + // this provides to repeated fields is worth the effort; consider just + // removing this and having repeated fields just re-run emitFieldName() + // for each item. + private func formatFieldName(lookingUp fieldNumber: Int) -> [UInt8] { + var bytes = [UInt8]() + if let protoName = nameMap?.names(for: fieldNumber)?.proto { + bytes.append(contentsOf: protoName.utf8Buffer) + } else if let protoName = nameResolver[fieldNumber] { + let buff = UnsafeBufferPointer(start: protoName.utf8Start, count: protoName.utf8CodeUnitCount) + bytes.append(contentsOf: buff) + } else if let extensionName = extensions?[fieldNumber]?.protobufExtension.fieldName { + bytes.append(UInt8(ascii: "[")) + bytes.append(contentsOf: extensionName.utf8) + bytes.append(UInt8(ascii: "]")) + } else { + bytes.append(contentsOf: fieldNumber.description.utf8) + } + return bytes + } + + private mutating func emitFieldName(lookingUp fieldNumber: Int) { + if let protoName = nameMap?.names(for: fieldNumber)?.proto { + encoder.emitFieldName(name: protoName.utf8Buffer) + } else if let protoName = nameResolver[fieldNumber] { + encoder.emitFieldName(name: protoName) + } else if let extensionName = extensions?[fieldNumber]?.protobufExtension.fieldName { + encoder.emitExtensionFieldName(name: extensionName) + } else { + encoder.emitFieldNumber(number: fieldNumber) + } + } + + mutating func visitUnknown(bytes: Data) throws { + if options.printUnknownFields { + try bytes.withUnsafeBytes { (body: UnsafeRawBufferPointer) -> Void in + if let baseAddress = body.baseAddress, body.count > 0 { + // All fields will be directly handled, so there is no need for + // the unknown field buffering/collection (when scannings to see + // if something is a message, this would be extremely wasteful). + var binaryOptions = BinaryDecodingOptions() + binaryOptions.discardUnknownFields = true + var decoder = BinaryDecoder( + forReadingFrom: baseAddress, + count: body.count, + options: binaryOptions + ) + try visitUnknown(decoder: &decoder) + } + } + } + } + + /// Helper for printing out unknowns. + /// + /// The implementation tries to be "helpful" and if a length delimited field + /// appears to be a submessage, it prints it as such. However, that opens the + /// door to someone sending a message with an unknown field that is a stack + /// bomb, i.e. - it causes this code to recurse, exhausting the stack and + /// thus opening up an attack vector. To keep this "help", but avoid the + /// attack, a limit is placed on how many times it will recurse before just + /// treating the length delimited fields as bytes and not trying to decode + /// them. + private mutating func visitUnknown( + decoder: inout BinaryDecoder, + recursionBudget: Int = 10 + ) throws { + // This stack serves to avoid recursion for groups within groups within + // groups..., this avoid the stack attack that the message detection + // hits. No limit is placed on this because there is no stack risk with + // recursion, and because if a limit was hit, there is no other way to + // encode the group (the message field can just print as length + // delimited, groups don't have an option like that). + var groupFieldNumberStack: [Int] = [] + + while let tag = try decoder.getTag() { + switch tag.wireFormat { + case .varint: + encoder.emitFieldNumber(number: tag.fieldNumber) + var value: UInt64 = 0 + encoder.startRegularField() + try decoder.decodeSingularUInt64Field(value: &value) + encoder.putUInt64(value: value) + encoder.endRegularField() + case .fixed64: + encoder.emitFieldNumber(number: tag.fieldNumber) + var value: UInt64 = 0 + encoder.startRegularField() + try decoder.decodeSingularFixed64Field(value: &value) + encoder.putUInt64Hex(value: value, digits: 16) + encoder.endRegularField() + case .lengthDelimited: + encoder.emitFieldNumber(number: tag.fieldNumber) + var bytes = Data() + try decoder.decodeSingularBytesField(value: &bytes) + var encodeAsBytes = true + if bytes.count > 0 && recursionBudget > 0 { + bytes.withUnsafeBytes { (body: UnsafeRawBufferPointer) -> Void in + if let baseAddress = body.baseAddress, body.count > 0 { + do { + // Walk all the fields to test if it looks like a message + var testDecoder = BinaryDecoder( + forReadingFrom: baseAddress, + count: body.count, + parent: decoder + ) + while let _ = try testDecoder.nextFieldNumber() { + } + // No error? Output the message body. + encodeAsBytes = false + var subDecoder = BinaryDecoder( + forReadingFrom: baseAddress, + count: bytes.count, + parent: decoder + ) + encoder.startMessageField() + try visitUnknown( + decoder: &subDecoder, + recursionBudget: recursionBudget - 1 + ) + encoder.endMessageField() + } catch { + encodeAsBytes = true + } + } + } + } + if encodeAsBytes { + encoder.startRegularField() + encoder.putBytesValue(value: bytes) + encoder.endRegularField() + } + case .startGroup: + encoder.emitFieldNumber(number: tag.fieldNumber) + encoder.startMessageField() + groupFieldNumberStack.append(tag.fieldNumber) + case .endGroup: + let groupFieldNumber = groupFieldNumberStack.popLast() + // Unknown data is scanned and verified by the + // binary parser, so this can never fail. + assert(tag.fieldNumber == groupFieldNumber) + encoder.endMessageField() + case .fixed32: + encoder.emitFieldNumber(number: tag.fieldNumber) + var value: UInt32 = 0 + encoder.startRegularField() + try decoder.decodeSingularFixed32Field(value: &value) + encoder.putUInt64Hex(value: UInt64(value), digits: 8) + encoder.endRegularField() + } + } + + // Unknown data is scanned and verified by the binary parser, so this can + // never fail. + assert(groupFieldNumberStack.isEmpty) + } + + // Visitor.swift defines default versions for other singular field types + // that simply widen and dispatch to one of the following. Since Text format + // does not distinguish e.g., Fixed64 vs. UInt64, this is sufficient. + + mutating func visitSingularFloatField(value: Float, fieldNumber: Int) throws { + emitFieldName(lookingUp: fieldNumber) + encoder.startRegularField() + encoder.putFloatValue(value: value) + encoder.endRegularField() + } + + mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws { + emitFieldName(lookingUp: fieldNumber) + encoder.startRegularField() + encoder.putDoubleValue(value: value) + encoder.endRegularField() + } + + mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws { + emitFieldName(lookingUp: fieldNumber) + encoder.startRegularField() + encoder.putInt64(value: value) + encoder.endRegularField() + } + + mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws { + emitFieldName(lookingUp: fieldNumber) + encoder.startRegularField() + encoder.putUInt64(value: value) + encoder.endRegularField() + } + + mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws { + emitFieldName(lookingUp: fieldNumber) + encoder.startRegularField() + encoder.putBoolValue(value: value) + encoder.endRegularField() + } + + mutating func visitSingularStringField(value: String, fieldNumber: Int) throws { + emitFieldName(lookingUp: fieldNumber) + encoder.startRegularField() + encoder.putStringValue(value: value) + encoder.endRegularField() + } + + mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws { + emitFieldName(lookingUp: fieldNumber) + encoder.startRegularField() + encoder.putBytesValue(value: value) + encoder.endRegularField() + } + + mutating func visitSingularEnumField(value: E, fieldNumber: Int) throws { + emitFieldName(lookingUp: fieldNumber) + encoder.startRegularField() + encoder.putEnumValue(value: value) + encoder.endRegularField() + } + + mutating func visitSingularMessageField( + value: M, + fieldNumber: Int + ) throws { + emitFieldName(lookingUp: fieldNumber) + + // Cache old visitor configuration + let oldNameMap = self.nameMap + let oldNameResolver = self.nameResolver + let oldExtensions = self.extensions + // Update configuration for new message + self.nameMap = (M.self as? any _ProtoNameProviding.Type)?._protobuf_nameMap + self.nameResolver = [:] + self.extensions = (value as? (any ExtensibleMessage))?._protobuf_extensionFieldValues + // Encode submessage + encoder.startMessageField() + if let any = value as? Google_Protobuf_Any { + any.textTraverse(visitor: &self) + } else { + try! value.traverse(visitor: &self) + } + encoder.endMessageField() + // Restore configuration before returning + self.extensions = oldExtensions + self.nameResolver = oldNameResolver + self.nameMap = oldNameMap + } + + // Emit the full "verbose" form of an Any. This writes the typeURL + // as a field name in `[...]` followed by the fields of the + // contained message. + internal mutating func visitAnyVerbose(value: any Message, typeURL: String) { + encoder.emitExtensionFieldName(name: typeURL) + encoder.startMessageField() + + // Cache old visitor configuration + let oldNameMap = self.nameMap + let oldNameResolver = self.nameResolver + let oldExtensions = self.extensions + // Update configuration for new message + self.nameMap = (type(of: value) as? any _ProtoNameProviding.Type)?._protobuf_nameMap + self.nameResolver = [:] + self.extensions = (value as? (any ExtensibleMessage))?._protobuf_extensionFieldValues + + if let any = value as? Google_Protobuf_Any { + any.textTraverse(visitor: &self) + } else { + try! value.traverse(visitor: &self) + } + + // Restore configuration before returning + self.extensions = oldExtensions + self.nameResolver = oldNameResolver + self.nameMap = oldNameMap + + encoder.endMessageField() + } + + // Write a single special field called "#json". This + // is used for Any objects with undecoded JSON contents. + internal mutating func visitAnyJSONBytesField(value: Data) { + encoder.indent() + encoder.append(staticText: "#json: ") + encoder.putBytesValue(value: value) + encoder.append(staticText: "\n") + } + + // The default implementations in Visitor.swift provide the correct + // results, but we get significantly better performance by only doing + // the name lookup once for the array, rather than once for each element: + + mutating func visitRepeatedFloatField(value: [Float], fieldNumber: Int) throws { + assert(!value.isEmpty) + let fieldName = formatFieldName(lookingUp: fieldNumber) + for v in value { + encoder.emitFieldName(name: fieldName) + encoder.startRegularField() + encoder.putFloatValue(value: v) + encoder.endRegularField() + } + } + + mutating func visitRepeatedDoubleField(value: [Double], fieldNumber: Int) throws { + assert(!value.isEmpty) + let fieldName = formatFieldName(lookingUp: fieldNumber) + for v in value { + encoder.emitFieldName(name: fieldName) + encoder.startRegularField() + encoder.putDoubleValue(value: v) + encoder.endRegularField() + } + } + + mutating func visitRepeatedInt32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + let fieldName = formatFieldName(lookingUp: fieldNumber) + for v in value { + encoder.emitFieldName(name: fieldName) + encoder.startRegularField() + encoder.putInt64(value: Int64(v)) + encoder.endRegularField() + } + } + + mutating func visitRepeatedInt64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + let fieldName = formatFieldName(lookingUp: fieldNumber) + for v in value { + encoder.emitFieldName(name: fieldName) + encoder.startRegularField() + encoder.putInt64(value: v) + encoder.endRegularField() + } + } + + mutating func visitRepeatedUInt32Field(value: [UInt32], fieldNumber: Int) throws { + assert(!value.isEmpty) + let fieldName = formatFieldName(lookingUp: fieldNumber) + for v in value { + encoder.emitFieldName(name: fieldName) + encoder.startRegularField() + encoder.putUInt64(value: UInt64(v)) + encoder.endRegularField() + } + } + + mutating func visitRepeatedUInt64Field(value: [UInt64], fieldNumber: Int) throws { + assert(!value.isEmpty) + let fieldName = formatFieldName(lookingUp: fieldNumber) + for v in value { + encoder.emitFieldName(name: fieldName) + encoder.startRegularField() + encoder.putUInt64(value: v) + encoder.endRegularField() + } + } + + mutating func visitRepeatedSInt32Field(value: [Int32], fieldNumber: Int) throws { + try visitRepeatedInt32Field(value: value, fieldNumber: fieldNumber) + } + mutating func visitRepeatedSInt64Field(value: [Int64], fieldNumber: Int) throws { + try visitRepeatedInt64Field(value: value, fieldNumber: fieldNumber) + } + mutating func visitRepeatedFixed32Field(value: [UInt32], fieldNumber: Int) throws { + try visitRepeatedUInt32Field(value: value, fieldNumber: fieldNumber) + } + mutating func visitRepeatedFixed64Field(value: [UInt64], fieldNumber: Int) throws { + try visitRepeatedUInt64Field(value: value, fieldNumber: fieldNumber) + } + mutating func visitRepeatedSFixed32Field(value: [Int32], fieldNumber: Int) throws { + try visitRepeatedInt32Field(value: value, fieldNumber: fieldNumber) + } + mutating func visitRepeatedSFixed64Field(value: [Int64], fieldNumber: Int) throws { + try visitRepeatedInt64Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitRepeatedBoolField(value: [Bool], fieldNumber: Int) throws { + assert(!value.isEmpty) + let fieldName = formatFieldName(lookingUp: fieldNumber) + for v in value { + encoder.emitFieldName(name: fieldName) + encoder.startRegularField() + encoder.putBoolValue(value: v) + encoder.endRegularField() + } + } + + mutating func visitRepeatedStringField(value: [String], fieldNumber: Int) throws { + assert(!value.isEmpty) + let fieldName = formatFieldName(lookingUp: fieldNumber) + for v in value { + encoder.emitFieldName(name: fieldName) + encoder.startRegularField() + encoder.putStringValue(value: v) + encoder.endRegularField() + } + } + + mutating func visitRepeatedBytesField(value: [Data], fieldNumber: Int) throws { + assert(!value.isEmpty) + let fieldName = formatFieldName(lookingUp: fieldNumber) + for v in value { + encoder.emitFieldName(name: fieldName) + encoder.startRegularField() + encoder.putBytesValue(value: v) + encoder.endRegularField() + } + } + + mutating func visitRepeatedEnumField(value: [E], fieldNumber: Int) throws { + assert(!value.isEmpty) + let fieldName = formatFieldName(lookingUp: fieldNumber) + for v in value { + encoder.emitFieldName(name: fieldName) + encoder.startRegularField() + encoder.putEnumValue(value: v) + encoder.endRegularField() + } + } + + // Messages and groups + mutating func visitRepeatedMessageField( + value: [M], + fieldNumber: Int + ) throws { + assert(!value.isEmpty) + // Look up field name against outer message encoding state + let fieldName = formatFieldName(lookingUp: fieldNumber) + // Cache old visitor state + let oldNameMap = self.nameMap + let oldNameResolver = self.nameResolver + let oldExtensions = self.extensions + // Update encoding state for new message type + self.nameMap = (M.self as? any _ProtoNameProviding.Type)?._protobuf_nameMap + self.nameResolver = [:] + self.extensions = (value as? (any ExtensibleMessage))?._protobuf_extensionFieldValues + // Iterate and encode each message + for v in value { + encoder.emitFieldName(name: fieldName) + encoder.startMessageField() + if let any = v as? Google_Protobuf_Any { + any.textTraverse(visitor: &self) + } else { + try! v.traverse(visitor: &self) } - } - } - } - - /// Helper for printing out unknowns. - /// - /// The implementation tries to be "helpful" and if a length delimited field - /// appears to be a submessage, it prints it as such. However, that opens the - /// door to someone sending a message with an unknown field that is a stack - /// bomb, i.e. - it causes this code to recurse, exhausing the stack and - /// thus opening up an attack vector. To keep this "help", but avoid the - /// attack, a limit is placed on how many times it will recurse before just - /// treating the length delimted fields as bytes and not trying to decode - /// them. - private mutating func visitUnknown( - decoder: inout BinaryDecoder, - recursionBudget: Int = 10 - ) throws { - // This stack serves to avoid recursion for groups within groups within - // groups..., this avoid the stack attack that the message detection - // hits. No limit is placed on this because there is no stack risk with - // recursion, and because if a limit was hit, there is no other way to - // encode the group (the message field can just print as length - // delimited, groups don't have an option like that). - var groupFieldNumberStack: [Int] = [] - - while let tag = try decoder.getTag() { - switch tag.wireFormat { - case .varint: - encoder.emitFieldNumber(number: tag.fieldNumber) - var value: UInt64 = 0 - encoder.startRegularField() - try decoder.decodeSingularUInt64Field(value: &value) - encoder.putUInt64(value: value) - encoder.endRegularField() - case .fixed64: - encoder.emitFieldNumber(number: tag.fieldNumber) - var value: UInt64 = 0 - encoder.startRegularField() - try decoder.decodeSingularFixed64Field(value: &value) - encoder.putUInt64Hex(value: value, digits: 16) - encoder.endRegularField() - case .lengthDelimited: - encoder.emitFieldNumber(number: tag.fieldNumber) - var bytes = Data() - try decoder.decodeSingularBytesField(value: &bytes) - bytes.withUnsafeBytes { (body: UnsafeRawBufferPointer) -> () in - if let baseAddress = body.baseAddress, body.count > 0 { - var encodeAsBytes: Bool - if (recursionBudget > 0) { - do { - // Walk all the fields to test if it looks like a message - var testDecoder = BinaryDecoder(forReadingFrom: baseAddress, - count: body.count, - parent: decoder) - while let _ = try testDecoder.nextFieldNumber() { - } - // No error? Output the message body. - encodeAsBytes = false - var subDecoder = BinaryDecoder(forReadingFrom: baseAddress, - count: bytes.count, - parent: decoder) - encoder.startMessageField() - try visitUnknown(decoder: &subDecoder, - recursionBudget: recursionBudget - 1) - encoder.endMessageField() - } catch { - encodeAsBytes = true - } - } else { - encodeAsBytes = true - } - if (encodeAsBytes) { - encoder.startRegularField() - encoder.putBytesValue(value: bytes) - encoder.endRegularField() - } - } - } - case .startGroup: - encoder.emitFieldNumber(number: tag.fieldNumber) - encoder.startMessageField() - groupFieldNumberStack.append(tag.fieldNumber) - case .endGroup: - let groupFieldNumber = groupFieldNumberStack.popLast() - // Unknown data is scanned and verified by the - // binary parser, so this can never fail. - assert(tag.fieldNumber == groupFieldNumber) - encoder.endMessageField() - case .fixed32: - encoder.emitFieldNumber(number: tag.fieldNumber) - var value: UInt32 = 0 - encoder.startRegularField() - try decoder.decodeSingularFixed32Field(value: &value) - encoder.putUInt64Hex(value: UInt64(value), digits: 8) - encoder.endRegularField() - } - } - - // Unknown data is scanned and verified by the binary parser, so this can - // never fail. - assert(groupFieldNumberStack.isEmpty) - } - - // Visitor.swift defines default versions for other singular field types - // that simply widen and dispatch to one of the following. Since Text format - // does not distinguish e.g., Fixed64 vs. UInt64, this is sufficient. - - mutating func visitSingularFloatField(value: Float, fieldNumber: Int) throws { - emitFieldName(lookingUp: fieldNumber) - encoder.startRegularField() - encoder.putFloatValue(value: value) - encoder.endRegularField() - } - - mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws { - emitFieldName(lookingUp: fieldNumber) - encoder.startRegularField() - encoder.putDoubleValue(value: value) - encoder.endRegularField() - } - - mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws { - emitFieldName(lookingUp: fieldNumber) - encoder.startRegularField() - encoder.putInt64(value: value) - encoder.endRegularField() - } - - mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws { - emitFieldName(lookingUp: fieldNumber) - encoder.startRegularField() - encoder.putUInt64(value: value) - encoder.endRegularField() - } - - mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws { - emitFieldName(lookingUp: fieldNumber) - encoder.startRegularField() - encoder.putBoolValue(value: value) - encoder.endRegularField() - } - - mutating func visitSingularStringField(value: String, fieldNumber: Int) throws { - emitFieldName(lookingUp: fieldNumber) - encoder.startRegularField() - encoder.putStringValue(value: value) - encoder.endRegularField() - } - - mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws { - emitFieldName(lookingUp: fieldNumber) - encoder.startRegularField() - encoder.putBytesValue(value: value) - encoder.endRegularField() - } - - mutating func visitSingularEnumField(value: E, fieldNumber: Int) throws { - emitFieldName(lookingUp: fieldNumber) - encoder.startRegularField() - encoder.putEnumValue(value: value) - encoder.endRegularField() - } - - mutating func visitSingularMessageField(value: M, - fieldNumber: Int) throws { - emitFieldName(lookingUp: fieldNumber) - - // Cache old encoder state - let oldNameMap = self.nameMap - let oldNameResolver = self.nameResolver - let oldExtensions = self.extensions - // Update encoding state for new message - self.nameMap = (M.self as? _ProtoNameProviding.Type)?._protobuf_nameMap - self.nameResolver = [:] - self.extensions = (value as? ExtensibleMessage)?._protobuf_extensionFieldValues - // Encode submessage - encoder.startMessageField() - if let any = value as? Google_Protobuf_Any { - any.textTraverse(visitor: &self) - } else { - try! value.traverse(visitor: &self) - } - encoder.endMessageField() - // Restore state before returning - self.extensions = oldExtensions - self.nameResolver = oldNameResolver - self.nameMap = oldNameMap - } - - // Emit the full "verbose" form of an Any. This writes the typeURL - // as a field name in `[...]` followed by the fields of the - // contained message. - internal mutating func visitAnyVerbose(value: Message, typeURL: String) { - encoder.emitExtensionFieldName(name: typeURL) - encoder.startMessageField() - var visitor = TextFormatEncodingVisitor(message: value, encoder: encoder, options: options) - if let any = value as? Google_Protobuf_Any { - any.textTraverse(visitor: &visitor) - } else { - try! value.traverse(visitor: &visitor) - } - encoder = visitor.encoder - encoder.endMessageField() - } - - // Write a single special field called "#json". This - // is used for Any objects with undecoded JSON contents. - internal mutating func visitAnyJSONDataField(value: Data) { - encoder.indent() - encoder.append(staticText: "#json: ") - encoder.putBytesValue(value: value) - encoder.append(staticText: "\n") - } - - // The default implementations in Visitor.swift provide the correct - // results, but we get significantly better performance by only doing - // the name lookup once for the array, rather than once for each element: - - mutating func visitRepeatedFloatField(value: [Float], fieldNumber: Int) throws { - assert(!value.isEmpty) - let fieldName = formatFieldName(lookingUp: fieldNumber) - for v in value { - encoder.emitFieldName(name: fieldName) - encoder.startRegularField() - encoder.putFloatValue(value: v) - encoder.endRegularField() - } - } - - mutating func visitRepeatedDoubleField(value: [Double], fieldNumber: Int) throws { - assert(!value.isEmpty) - let fieldName = formatFieldName(lookingUp: fieldNumber) - for v in value { - encoder.emitFieldName(name: fieldName) - encoder.startRegularField() - encoder.putDoubleValue(value: v) - encoder.endRegularField() - } - } - - mutating func visitRepeatedInt32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - let fieldName = formatFieldName(lookingUp: fieldNumber) - for v in value { - encoder.emitFieldName(name: fieldName) - encoder.startRegularField() - encoder.putInt64(value: Int64(v)) - encoder.endRegularField() - } - } - - mutating func visitRepeatedInt64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - let fieldName = formatFieldName(lookingUp: fieldNumber) - for v in value { - encoder.emitFieldName(name: fieldName) - encoder.startRegularField() - encoder.putInt64(value: v) - encoder.endRegularField() - } - } - - mutating func visitRepeatedUInt32Field(value: [UInt32], fieldNumber: Int) throws { - assert(!value.isEmpty) - let fieldName = formatFieldName(lookingUp: fieldNumber) - for v in value { - encoder.emitFieldName(name: fieldName) - encoder.startRegularField() - encoder.putUInt64(value: UInt64(v)) - encoder.endRegularField() - } - } - - mutating func visitRepeatedUInt64Field(value: [UInt64], fieldNumber: Int) throws { - assert(!value.isEmpty) - let fieldName = formatFieldName(lookingUp: fieldNumber) - for v in value { - encoder.emitFieldName(name: fieldName) - encoder.startRegularField() - encoder.putUInt64(value: v) - encoder.endRegularField() - } - } - - mutating func visitRepeatedSInt32Field(value: [Int32], fieldNumber: Int) throws { - try visitRepeatedInt32Field(value: value, fieldNumber: fieldNumber) - } - mutating func visitRepeatedSInt64Field(value: [Int64], fieldNumber: Int) throws { - try visitRepeatedInt64Field(value: value, fieldNumber: fieldNumber) - } - mutating func visitRepeatedFixed32Field(value: [UInt32], fieldNumber: Int) throws { - try visitRepeatedUInt32Field(value: value, fieldNumber: fieldNumber) - } - mutating func visitRepeatedFixed64Field(value: [UInt64], fieldNumber: Int) throws { - try visitRepeatedUInt64Field(value: value, fieldNumber: fieldNumber) - } - mutating func visitRepeatedSFixed32Field(value: [Int32], fieldNumber: Int) throws { - try visitRepeatedInt32Field(value: value, fieldNumber: fieldNumber) - } - mutating func visitRepeatedSFixed64Field(value: [Int64], fieldNumber: Int) throws { - try visitRepeatedInt64Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitRepeatedBoolField(value: [Bool], fieldNumber: Int) throws { - assert(!value.isEmpty) - let fieldName = formatFieldName(lookingUp: fieldNumber) - for v in value { - encoder.emitFieldName(name: fieldName) - encoder.startRegularField() - encoder.putBoolValue(value: v) - encoder.endRegularField() - } - } - - mutating func visitRepeatedStringField(value: [String], fieldNumber: Int) throws { - assert(!value.isEmpty) - let fieldName = formatFieldName(lookingUp: fieldNumber) - for v in value { - encoder.emitFieldName(name: fieldName) - encoder.startRegularField() - encoder.putStringValue(value: v) - encoder.endRegularField() - } - } - - mutating func visitRepeatedBytesField(value: [Data], fieldNumber: Int) throws { - assert(!value.isEmpty) - let fieldName = formatFieldName(lookingUp: fieldNumber) - for v in value { - encoder.emitFieldName(name: fieldName) - encoder.startRegularField() - encoder.putBytesValue(value: v) - encoder.endRegularField() - } - } - - mutating func visitRepeatedEnumField(value: [E], fieldNumber: Int) throws { - assert(!value.isEmpty) - let fieldName = formatFieldName(lookingUp: fieldNumber) - for v in value { - encoder.emitFieldName(name: fieldName) - encoder.startRegularField() - encoder.putEnumValue(value: v) - encoder.endRegularField() - } - } - - // Messages and groups - mutating func visitRepeatedMessageField(value: [M], - fieldNumber: Int) throws { - assert(!value.isEmpty) - // Look up field name against outer message encoding state - let fieldName = formatFieldName(lookingUp: fieldNumber) - // Cache old encoder state - let oldNameMap = self.nameMap - let oldNameResolver = self.nameResolver - let oldExtensions = self.extensions - // Update encoding state for new message type - self.nameMap = (M.self as? _ProtoNameProviding.Type)?._protobuf_nameMap - self.nameResolver = [:] - self.extensions = (value as? ExtensibleMessage)?._protobuf_extensionFieldValues - // Iterate and encode each message - for v in value { - encoder.emitFieldName(name: fieldName) - encoder.startMessageField() - if let any = v as? Google_Protobuf_Any { - any.textTraverse(visitor: &self) - } else { - try! v.traverse(visitor: &self) - } - encoder.endMessageField() - } - // Restore state - self.extensions = oldExtensions - self.nameResolver = oldNameResolver - self.nameMap = oldNameMap - } - - // Google's C++ implementation of Text format supports two formats - // for repeated numeric fields: "short" format writes the list as a - // single field with values enclosed in `[...]`, "long" format - // writes a separate field name/value for each item. They provide - // an option for callers to select which output version they prefer. - - // Since this distinction mirrors the difference in Protobuf Binary - // between "packed" and "non-packed", I've chosen to use the short - // format for packed fields and the long version for repeated - // fields. This provides a clear visual distinction between these - // fields (including proto3's default use of packed) without - // introducing the baggage of a separate option. - - private mutating func _visitPacked( - value: [T], fieldNumber: Int, - encode: (T, inout TextFormatEncoder) -> () - ) throws { - assert(!value.isEmpty) - emitFieldName(lookingUp: fieldNumber) - encoder.startRegularField() - var firstItem = true - encoder.startArray() - for v in value { - if !firstItem { - encoder.arraySeparator() - } - encode(v, &encoder) - firstItem = false - } - encoder.endArray() - encoder.endRegularField() - } - - mutating func visitPackedFloatField(value: [Float], fieldNumber: Int) throws { - try _visitPacked(value: value, fieldNumber: fieldNumber) { - (v: Float, encoder: inout TextFormatEncoder) in - encoder.putFloatValue(value: v) - } - } - - mutating func visitPackedDoubleField(value: [Double], fieldNumber: Int) throws { - try _visitPacked(value: value, fieldNumber: fieldNumber) { - (v: Double, encoder: inout TextFormatEncoder) in - encoder.putDoubleValue(value: v) - } - } - - mutating func visitPackedInt32Field(value: [Int32], fieldNumber: Int) throws { - try _visitPacked(value: value, fieldNumber: fieldNumber) { - (v: Int32, encoder: inout TextFormatEncoder) in - encoder.putInt64(value: Int64(v)) - } - } - - mutating func visitPackedInt64Field(value: [Int64], fieldNumber: Int) throws { - try _visitPacked(value: value, fieldNumber: fieldNumber) { - (v: Int64, encoder: inout TextFormatEncoder) in - encoder.putInt64(value: v) - } - } - - mutating func visitPackedUInt32Field(value: [UInt32], fieldNumber: Int) throws { - try _visitPacked(value: value, fieldNumber: fieldNumber) { - (v: UInt32, encoder: inout TextFormatEncoder) in - encoder.putUInt64(value: UInt64(v)) - } - } - - mutating func visitPackedUInt64Field(value: [UInt64], fieldNumber: Int) throws { - try _visitPacked(value: value, fieldNumber: fieldNumber) { - (v: UInt64, encoder: inout TextFormatEncoder) in - encoder.putUInt64(value: v) - } - } - - mutating func visitPackedSInt32Field(value: [Int32], fieldNumber: Int) throws { - try visitPackedInt32Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitPackedSInt64Field(value: [Int64], fieldNumber: Int) throws { - try visitPackedInt64Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitPackedFixed32Field(value: [UInt32], fieldNumber: Int) throws { - try visitPackedUInt32Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitPackedFixed64Field(value: [UInt64], fieldNumber: Int) throws { - try visitPackedUInt64Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitPackedSFixed32Field(value: [Int32], fieldNumber: Int) throws { - try visitPackedInt32Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitPackedSFixed64Field(value: [Int64], fieldNumber: Int) throws { - try visitPackedInt64Field(value: value, fieldNumber: fieldNumber) - } - - mutating func visitPackedBoolField(value: [Bool], fieldNumber: Int) throws { - try _visitPacked(value: value, fieldNumber: fieldNumber) { - (v: Bool, encoder: inout TextFormatEncoder) in - encoder.putBoolValue(value: v) - } - } - - mutating func visitPackedEnumField(value: [E], fieldNumber: Int) throws { - try _visitPacked(value: value, fieldNumber: fieldNumber) { - (v: E, encoder: inout TextFormatEncoder) in - encoder.putEnumValue(value: v) - } - } - - /// Helper to encapsulate the common structure of iterating over a map - /// and encoding the keys and values. - private mutating func _visitMap( - map: Dictionary, - fieldNumber: Int, - isOrderedBefore: (K, K) -> Bool, - coder: (inout TextFormatEncodingVisitor, K, V) throws -> () - ) throws { - for (k,v) in map.sorted(by: { isOrderedBefore( $0.0, $1.0) }) { - emitFieldName(lookingUp: fieldNumber) - encoder.startMessageField() - var visitor = TextFormatEncodingVisitor(nameMap: nil, nameResolver: mapNameResolver, extensions: nil, encoder: encoder, options: options) - try coder(&visitor, k, v) - encoder = visitor.encoder - encoder.endMessageField() - } - } - - mutating func visitMapField( - fieldType: _ProtobufMap.Type, - value: _ProtobufMap.BaseType, - fieldNumber: Int - ) throws { - try _visitMap(map: value, fieldNumber: fieldNumber, isOrderedBefore: KeyType._lessThan) { - (visitor: inout TextFormatEncodingVisitor, key, value) throws -> () in - try KeyType.visitSingular(value: key, fieldNumber: 1, with: &visitor) - try ValueType.visitSingular(value: value, fieldNumber: 2, with: &visitor) - } - } - - mutating func visitMapField( - fieldType: _ProtobufEnumMap.Type, - value: _ProtobufEnumMap.BaseType, - fieldNumber: Int - ) throws where ValueType.RawValue == Int { - try _visitMap(map: value, fieldNumber: fieldNumber, isOrderedBefore: KeyType._lessThan) { - (visitor: inout TextFormatEncodingVisitor, key, value) throws -> () in - try KeyType.visitSingular(value: key, fieldNumber: 1, with: &visitor) - try visitor.visitSingularEnumField(value: value, fieldNumber: 2) - } - } - - mutating func visitMapField( - fieldType: _ProtobufMessageMap.Type, - value: _ProtobufMessageMap.BaseType, - fieldNumber: Int - ) throws { - try _visitMap(map: value, fieldNumber: fieldNumber, isOrderedBefore: KeyType._lessThan) { - (visitor: inout TextFormatEncodingVisitor, key, value) throws -> () in - try KeyType.visitSingular(value: key, fieldNumber: 1, with: &visitor) - try visitor.visitSingularMessageField(value: value, fieldNumber: 2) - } - } + encoder.endMessageField() + } + // Restore state + self.extensions = oldExtensions + self.nameResolver = oldNameResolver + self.nameMap = oldNameMap + } + + // Google's C++ implementation of Text format supports two formats + // for repeated numeric fields: "short" format writes the list as a + // single field with values enclosed in `[...]`, "long" format + // writes a separate field name/value for each item. They provide + // an option for callers to select which output version they prefer. + + // Since this distinction mirrors the difference in Protobuf Binary + // between "packed" and "non-packed", I've chosen to use the short + // format for packed fields and the long version for repeated + // fields. This provides a clear visual distinction between these + // fields (including proto3's default use of packed) without + // introducing the baggage of a separate option. + + private mutating func iterateAndEncode( + packedValue: [T], + fieldNumber: Int, + encode: (T, inout TextFormatEncoder) -> Void + ) throws { + assert(!packedValue.isEmpty) + emitFieldName(lookingUp: fieldNumber) + encoder.startRegularField() + var firstItem = true + encoder.startArray() + for v in packedValue { + if !firstItem { + encoder.arraySeparator() + } + encode(v, &encoder) + firstItem = false + } + encoder.endArray() + encoder.endRegularField() + } + + mutating func visitPackedFloatField(value: [Float], fieldNumber: Int) throws { + try iterateAndEncode(packedValue: value, fieldNumber: fieldNumber) { + (v: Float, encoder: inout TextFormatEncoder) in + encoder.putFloatValue(value: v) + } + } + + mutating func visitPackedDoubleField(value: [Double], fieldNumber: Int) throws { + try iterateAndEncode(packedValue: value, fieldNumber: fieldNumber) { + (v: Double, encoder: inout TextFormatEncoder) in + encoder.putDoubleValue(value: v) + } + } + + mutating func visitPackedInt32Field(value: [Int32], fieldNumber: Int) throws { + try iterateAndEncode(packedValue: value, fieldNumber: fieldNumber) { + (v: Int32, encoder: inout TextFormatEncoder) in + encoder.putInt64(value: Int64(v)) + } + } + + mutating func visitPackedInt64Field(value: [Int64], fieldNumber: Int) throws { + try iterateAndEncode(packedValue: value, fieldNumber: fieldNumber) { + (v: Int64, encoder: inout TextFormatEncoder) in + encoder.putInt64(value: v) + } + } + + mutating func visitPackedUInt32Field(value: [UInt32], fieldNumber: Int) throws { + try iterateAndEncode(packedValue: value, fieldNumber: fieldNumber) { + (v: UInt32, encoder: inout TextFormatEncoder) in + encoder.putUInt64(value: UInt64(v)) + } + } + + mutating func visitPackedUInt64Field(value: [UInt64], fieldNumber: Int) throws { + try iterateAndEncode(packedValue: value, fieldNumber: fieldNumber) { + (v: UInt64, encoder: inout TextFormatEncoder) in + encoder.putUInt64(value: v) + } + } + + mutating func visitPackedSInt32Field(value: [Int32], fieldNumber: Int) throws { + try visitPackedInt32Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitPackedSInt64Field(value: [Int64], fieldNumber: Int) throws { + try visitPackedInt64Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitPackedFixed32Field(value: [UInt32], fieldNumber: Int) throws { + try visitPackedUInt32Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitPackedFixed64Field(value: [UInt64], fieldNumber: Int) throws { + try visitPackedUInt64Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitPackedSFixed32Field(value: [Int32], fieldNumber: Int) throws { + try visitPackedInt32Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitPackedSFixed64Field(value: [Int64], fieldNumber: Int) throws { + try visitPackedInt64Field(value: value, fieldNumber: fieldNumber) + } + + mutating func visitPackedBoolField(value: [Bool], fieldNumber: Int) throws { + try iterateAndEncode(packedValue: value, fieldNumber: fieldNumber) { + (v: Bool, encoder: inout TextFormatEncoder) in + encoder.putBoolValue(value: v) + } + } + + mutating func visitPackedEnumField(value: [E], fieldNumber: Int) throws { + try iterateAndEncode(packedValue: value, fieldNumber: fieldNumber) { + (v: E, encoder: inout TextFormatEncoder) in + encoder.putEnumValue(value: v) + } + } + + /// Helper to encapsulate the common structure of iterating over a map + /// and encoding the keys and values. + private mutating func iterateAndEncode( + map: [K: V], + fieldNumber: Int, + isOrderedBefore: (K, K) -> Bool, + encode: (inout TextFormatEncodingVisitor, K, V) throws -> Void + ) throws { + // Cache old visitor configuration + let oldNameMap = self.nameMap + let oldNameResolver = self.nameResolver + let oldExtensions = self.extensions + + for (k, v) in map.sorted(by: { isOrderedBefore($0.0, $1.0) }) { + emitFieldName(lookingUp: fieldNumber) + encoder.startMessageField() + + // Update visitor configuration for map + self.nameMap = nil + self.nameResolver = mapNameResolver + self.extensions = nil + + try encode(&self, k, v) + + // Restore configuration before resuming containing message + self.extensions = oldExtensions + self.nameResolver = oldNameResolver + self.nameMap = oldNameMap + + encoder.endMessageField() + } + } + + mutating func visitMapField( + fieldType: _ProtobufMap.Type, + value: _ProtobufMap.BaseType, + fieldNumber: Int + ) throws { + try iterateAndEncode(map: value, fieldNumber: fieldNumber, isOrderedBefore: KeyType._lessThan) { + (visitor: inout TextFormatEncodingVisitor, key, value) throws -> Void in + try KeyType.visitSingular(value: key, fieldNumber: 1, with: &visitor) + try ValueType.visitSingular(value: value, fieldNumber: 2, with: &visitor) + } + } + + mutating func visitMapField( + fieldType: _ProtobufEnumMap.Type, + value: _ProtobufEnumMap.BaseType, + fieldNumber: Int + ) throws where ValueType.RawValue == Int { + try iterateAndEncode(map: value, fieldNumber: fieldNumber, isOrderedBefore: KeyType._lessThan) { + (visitor: inout TextFormatEncodingVisitor, key, value) throws -> Void in + try KeyType.visitSingular(value: key, fieldNumber: 1, with: &visitor) + try visitor.visitSingularEnumField(value: value, fieldNumber: 2) + } + } + + mutating func visitMapField( + fieldType: _ProtobufMessageMap.Type, + value: _ProtobufMessageMap.BaseType, + fieldNumber: Int + ) throws { + try iterateAndEncode(map: value, fieldNumber: fieldNumber, isOrderedBefore: KeyType._lessThan) { + (visitor: inout TextFormatEncodingVisitor, key, value) throws -> Void in + try KeyType.visitSingular(value: key, fieldNumber: 1, with: &visitor) + try visitor.visitSingularMessageField(value: value, fieldNumber: 2) + } + } } diff --git a/Sources/SwiftProtobuf/TextFormatScanner.swift b/Sources/SwiftProtobuf/TextFormatScanner.swift index e2bbbf6e8..0b08c0108 100644 --- a/Sources/SwiftProtobuf/TextFormatScanner.swift +++ b/Sources/SwiftProtobuf/TextFormatScanner.swift @@ -68,24 +68,29 @@ private let asciiLowerY = UInt8(ascii: "y") private let asciiLowerZ = UInt8(ascii: "z") private let asciiUpperZ = UInt8(ascii: "Z") +// https://protobuf.dev/programming-guides/proto2/#assigning +// Fields can be between 1 and 536,870,911. So we can stop parsing +// a raw number if we go over this (it also avoid rollover). +private let maxFieldNumLength: Int = 9 + private func fromHexDigit(_ c: UInt8) -> UInt8? { - if c >= asciiZero && c <= asciiNine { - return c - asciiZero - } - if c >= asciiUpperA && c <= asciiUpperF { - return c - asciiUpperA + UInt8(10) - } - if c >= asciiLowerA && c <= asciiLowerF { - return c - asciiLowerA + UInt8(10) - } - return nil + if c >= asciiZero && c <= asciiNine { + return c - asciiZero + } + if c >= asciiUpperA && c <= asciiUpperF { + return c - asciiUpperA + UInt8(10) + } + if c >= asciiLowerA && c <= asciiLowerF { + return c - asciiLowerA + UInt8(10) + } + return nil } private func uint32FromHexDigit(_ c: UInt8) -> UInt32? { - guard let u8 = fromHexDigit(c) else { - return nil - } - return UInt32(u8) + guard let u8 = fromHexDigit(c) else { + return nil + } + return UInt32(u8) } // Protobuf Text encoding assumes that you're working directly @@ -94,163 +99,162 @@ private func uint32FromHexDigit(_ c: UInt8) -> UInt32? { // it back into a string. private func decodeString(_ s: String) -> String? { - // Helper to read 4 hex digits as a UInt32 - func read4HexDigits(_ i: inout String.UTF8View.Iterator) -> UInt32? { - if let digit1 = i.next(), - let d1 = uint32FromHexDigit(digit1), - let digit2 = i.next(), - let d2 = uint32FromHexDigit(digit2), - let digit3 = i.next(), - let d3 = uint32FromHexDigit(digit3), - let digit4 = i.next(), - let d4 = uint32FromHexDigit(digit4) { - return (d1 << 12) + (d2 << 8) + (d3 << 4) + d4 + // Helper to read 4 hex digits as a UInt32 + func read4HexDigits(_ i: inout String.UTF8View.Iterator) -> UInt32? { + if let digit1 = i.next(), + let d1 = uint32FromHexDigit(digit1), + let digit2 = i.next(), + let d2 = uint32FromHexDigit(digit2), + let digit3 = i.next(), + let d3 = uint32FromHexDigit(digit3), + let digit4 = i.next(), + let d4 = uint32FromHexDigit(digit4) + { + return (d1 << 12) + (d2 << 8) + (d3 << 4) + d4 + } + return nil } - return nil - } - - var out = [UInt8]() - var bytes = s.utf8.makeIterator() - while let byte = bytes.next() { - switch byte { - case asciiBackslash: // backslash - if let escaped = bytes.next() { - switch escaped { - case asciiZero...asciiSeven: // 0...7 - // C standard allows 1, 2, or 3 octal digits. - let savedPosition = bytes - let digit1 = escaped - let digit1Value = digit1 - asciiZero - if let digit2 = bytes.next(), - digit2 >= asciiZero && digit2 <= asciiSeven { - let digit2Value = digit2 - asciiZero - let innerSavedPosition = bytes - if let digit3 = bytes.next(), - digit3 >= asciiZero && digit3 <= asciiSeven { - let digit3Value = digit3 - asciiZero - // The max octal digit is actually \377, but looking at the C++ - // protobuf code in strutil.cc:UnescapeCEscapeSequences(), it - // decodes with rollover, so just duplicate that behavior for - // consistency between languages. - let n = digit1Value &* 64 &+ digit2Value &* 8 &+ digit3Value - out.append(n) - } else { - let n = digit1Value * 8 + digit2Value - out.append(n) - bytes = innerSavedPosition - } - } else { - let n = digit1Value - out.append(n) - bytes = savedPosition - } - case asciiLowerU, asciiUpperU: // "u" - // \u - 4 hex digits, \U 8 hex digits: - guard let first = read4HexDigits(&bytes) else { return nil } - var codePoint = first - if escaped == asciiUpperU { - guard let second = read4HexDigits(&bytes) else { return nil } - codePoint = (codePoint << 16) + second - } - switch codePoint { - case 0...0x7f: - // 1 byte encoding - out.append(UInt8(truncatingIfNeeded: codePoint)) - case 0x80...0x7ff: - // 2 byte encoding - out.append(0xC0 + UInt8(truncatingIfNeeded: codePoint >> 6)) - out.append(0x80 + UInt8(truncatingIfNeeded: codePoint & 0x3F)) - case 0x800...0xffff: - // 3 byte encoding - out.append(0xE0 + UInt8(truncatingIfNeeded: codePoint >> 12)) - out.append(0x80 + UInt8(truncatingIfNeeded: (codePoint >> 6) & 0x3F)) - out.append(0x80 + UInt8(truncatingIfNeeded: codePoint & 0x3F)) - case 0x10000...0x10FFFF: - // 4 byte encoding - out.append(0xF0 + UInt8(truncatingIfNeeded: codePoint >> 18)) - out.append(0x80 + UInt8(truncatingIfNeeded: (codePoint >> 12) & 0x3F)) - out.append(0x80 + UInt8(truncatingIfNeeded: (codePoint >> 6) & 0x3F)) - out.append(0x80 + UInt8(truncatingIfNeeded: codePoint & 0x3F)) - default: - return nil - } - case asciiLowerX: // "x" - // Unlike C/C++, protobuf only allows 1 or 2 digits here: - if let byte = bytes.next(), let digit = fromHexDigit(byte) { - var n = digit - let savedPosition = bytes - if let byte = bytes.next(), let digit = fromHexDigit(byte) { - n = n &* 16 + digit + + var out = [UInt8]() + var bytes = s.utf8.makeIterator() + while let byte = bytes.next() { + switch byte { + case asciiBackslash: // backslash + if let escaped = bytes.next() { + switch escaped { + case asciiZero...asciiSeven: // 0...7 + // C standard allows 1, 2, or 3 octal digits. + let savedPosition = bytes + let digit1 = escaped + let digit1Value = digit1 - asciiZero + if let digit2 = bytes.next(), + digit2 >= asciiZero && digit2 <= asciiSeven + { + let digit2Value = digit2 - asciiZero + let innerSavedPosition = bytes + if let digit3 = bytes.next(), + digit3 >= asciiZero && digit3 <= asciiSeven + { + let digit3Value = digit3 - asciiZero + // The max octal digit is actually \377, but looking at the C++ + // protobuf code in strutil.cc:UnescapeCEscapeSequences(), it + // decodes with rollover, so just duplicate that behavior for + // consistency between languages. + let n = digit1Value &* 64 &+ digit2Value &* 8 &+ digit3Value + out.append(n) + } else { + let n = digit1Value * 8 + digit2Value + out.append(n) + bytes = innerSavedPosition + } + } else { + let n = digit1Value + out.append(n) + bytes = savedPosition + } + case asciiLowerU, asciiUpperU: // "u" + // \u - 4 hex digits, \U 8 hex digits: + guard let first = read4HexDigits(&bytes) else { return nil } + var codePoint = first + if escaped == asciiUpperU { + guard let second = read4HexDigits(&bytes) else { return nil } + codePoint = (codePoint << 16) + second + } + switch codePoint { + case 0...0x7f: + // 1 byte encoding + out.append(UInt8(truncatingIfNeeded: codePoint)) + case 0x80...0x7ff: + // 2 byte encoding + out.append(0xC0 + UInt8(truncatingIfNeeded: codePoint >> 6)) + out.append(0x80 + UInt8(truncatingIfNeeded: codePoint & 0x3F)) + case 0x800...0xffff: + // 3 byte encoding + out.append(0xE0 + UInt8(truncatingIfNeeded: codePoint >> 12)) + out.append(0x80 + UInt8(truncatingIfNeeded: (codePoint >> 6) & 0x3F)) + out.append(0x80 + UInt8(truncatingIfNeeded: codePoint & 0x3F)) + case 0x10000...0x10FFFF: + // 4 byte encoding + out.append(0xF0 + UInt8(truncatingIfNeeded: codePoint >> 18)) + out.append(0x80 + UInt8(truncatingIfNeeded: (codePoint >> 12) & 0x3F)) + out.append(0x80 + UInt8(truncatingIfNeeded: (codePoint >> 6) & 0x3F)) + out.append(0x80 + UInt8(truncatingIfNeeded: codePoint & 0x3F)) + default: + return nil + } + case asciiLowerX: // "x" + // Unlike C/C++, protobuf only allows 1 or 2 digits here: + if let byte = bytes.next(), let digit = fromHexDigit(byte) { + var n = digit + let savedPosition = bytes + if let byte = bytes.next(), let digit = fromHexDigit(byte) { + n = n &* 16 + digit + } else { + // No second digit; reset the iterator + bytes = savedPosition + } + out.append(n) + } else { + return nil // Hex escape must have at least 1 digit + } + case asciiLowerA: // \a + out.append(asciiBell) + case asciiLowerB: // \b + out.append(asciiBackspace) + case asciiLowerF: // \f + out.append(asciiFormFeed) + case asciiLowerN: // \n + out.append(asciiNewLine) + case asciiLowerR: // \r + out.append(asciiCarriageReturn) + case asciiLowerT: // \t + out.append(asciiTab) + case asciiLowerV: // \v + out.append(asciiVerticalTab) + case asciiDoubleQuote, + asciiSingleQuote, + asciiQuestionMark, + asciiBackslash: // " ' ? \ + out.append(escaped) + default: + return nil // Unrecognized escape + } } else { - // No second digit; reset the iterator - bytes = savedPosition + return nil // Input ends with backslash } - out.append(n) - } else { - return nil // Hex escape must have at least 1 digit - } - case asciiLowerA: // \a - out.append(asciiBell) - case asciiLowerB: // \b - out.append(asciiBackspace) - case asciiLowerF: // \f - out.append(asciiFormFeed) - case asciiLowerN: // \n - out.append(asciiNewLine) - case asciiLowerR: // \r - out.append(asciiCarriageReturn) - case asciiLowerT: // \t - out.append(asciiTab) - case asciiLowerV: // \v - out.append(asciiVerticalTab) - case asciiDoubleQuote, - asciiSingleQuote, - asciiQuestionMark, - asciiBackslash: // " ' ? \ - out.append(escaped) default: - return nil // Unrecognized escape + out.append(byte) } - } else { - return nil // Input ends with backslash - } - default: - out.append(byte) } - } - // There has got to be an easier way to convert a [UInt8] into a String. - return out.withUnsafeBufferPointer { ptr in - if let addr = ptr.baseAddress { - return utf8ToString(bytes: addr, count: ptr.count) - } else { - return String() + // There has got to be an easier way to convert a [UInt8] into a String. + return out.withUnsafeBufferPointer { ptr in + if let addr = ptr.baseAddress { + return utf8ToString(bytes: addr, count: ptr.count) + } else { + return String() + } } - } } /// /// TextFormatScanner has no public members. /// internal struct TextFormatScanner { - internal var extensions: ExtensionMap? + internal let extensions: (any ExtensionMap)? private var p: UnsafeRawPointer - private var end: UnsafeRawPointer - private var doubleParser = DoubleParser() + private let end: UnsafeRawPointer + private let doubleParser = DoubleParser() - private let options: TextFormatDecodingOptions + internal let options: TextFormatDecodingOptions internal var recursionBudget: Int - internal var complete: Bool { - mutating get { - return p == end - } - } + internal var complete: Bool { p == end } internal init( - utf8Pointer: UnsafeRawPointer, - count: Int, - options: TextFormatDecodingOptions, - extensions: ExtensionMap? = nil + utf8Pointer: UnsafeRawPointer, + count: Int, + options: TextFormatDecodingOptions, + extensions: (any ExtensionMap)? = nil ) { p = utf8Pointer end = p + count @@ -284,11 +288,11 @@ internal struct TextFormatScanner { let u = p[0] switch u { case asciiSpace, - asciiTab, - asciiNewLine, - asciiCarriageReturn: // space, tab, NL, CR + asciiTab, + asciiNewLine, + asciiCarriageReturn: // space, tab, NL, CR p += 1 - case asciiHash: // # comment + case asciiHash: // # comment p += 1 while p != end { // Skip until end of line @@ -313,9 +317,9 @@ internal struct TextFormatScanner { let c = p[0] switch c { case asciiLowerA...asciiLowerZ, - asciiUpperA...asciiUpperZ, - asciiZero...asciiNine, - asciiUnderscore: + asciiUpperA...asciiUpperZ, + asciiZero...asciiNine, + asciiUnderscore: p += 1 default: break loop @@ -334,140 +338,106 @@ internal struct TextFormatScanner { return s! } - /// Parse the rest of an [extension_field_name] in the input, assuming the - /// initial "[" character has already been read (and is in the prefix) - /// This is also used for AnyURL, so we include "/", "." - private mutating func parseExtensionKey() -> String? { - let start = p - if p == end { - return nil - } - let c = p[0] - switch c { - case asciiLowerA...asciiLowerZ, asciiUpperA...asciiUpperZ: - p += 1 - default: - return nil - } - while p != end { - let c = p[0] - switch c { - case asciiLowerA...asciiLowerZ, - asciiUpperA...asciiUpperZ, - asciiZero...asciiNine, - asciiUnderscore, - asciiPeriod, - asciiForwardSlash: - p += 1 - case asciiCloseSquareBracket: // ] - return utf8ToString(bytes: start, count: p - start) - default: - return nil - } - } - return nil - } - /// Scan a string that encodes a byte field, return a count of /// the number of bytes that should be decoded from it private mutating func validateAndCountBytesFromString(terminator: UInt8, sawBackslash: inout Bool) throws -> Int { - var count = 0 - let start = p - sawBackslash = false - while p != end { - let byte = p[0] - p += 1 - if byte == terminator { - p = start - return count - } - switch byte { - case asciiNewLine, asciiCarriageReturn: - // Can't have a newline in the middle of a bytes string. - throw TextFormatDecodingError.malformedText - case asciiBackslash: // "\\" - sawBackslash = true - if p != end { - let escaped = p[0] + var count = 0 + let start = p + sawBackslash = false + while p != end { + let byte = p[0] p += 1 - switch escaped { - case asciiZero...asciiSeven: // '0'...'7' - // C standard allows 1, 2, or 3 octal digits. - if p != end, p[0] >= asciiZero, p[0] <= asciiSeven { - p += 1 - if p != end, p[0] >= asciiZero, p[0] <= asciiSeven { - if escaped > asciiThree { - // Out of range octal: three digits and first digit is greater than 3 - throw TextFormatDecodingError.malformedText - } - p += 1 - } - } - count += 1 - case asciiLowerU, asciiUpperU: // 'u' or 'U' unicode escape - let numDigits = (escaped == asciiLowerU) ? 4 : 8 - guard (end - p) >= numDigits else { - throw TextFormatDecodingError.malformedText // unicode escape must 4/8 digits - } - var codePoint: UInt32 = 0 - for i in 0..= asciiZero, p[0] <= asciiSeven { + p += 1 + if p != end, p[0] >= asciiZero, p[0] <= asciiSeven { + if escaped > asciiThree { + // Out of range octal: three digits and first digit is greater than 3 + throw TextFormatDecodingError.malformedText + } + p += 1 + } + } + count += 1 + case asciiLowerU, asciiUpperU: // 'u' or 'U' unicode escape + let numDigits = (escaped == asciiLowerU) ? 4 : 8 + guard (end - p) >= numDigits else { + throw TextFormatDecodingError.malformedText // unicode escape must 4/8 digits + } + var codePoint: UInt32 = 0 + for i in 0.. 0 { - while p[0] != terminator { - let byte = p[0] - p += 1 - switch byte { - case asciiBackslash: // "\\" - let escaped = p[0] - p += 1 - switch escaped { - case asciiZero...asciiSeven: // '0'...'7' - // C standard allows 1, 2, or 3 octal digits. - let digit1Value = escaped - asciiZero - let digit2 = p[0] - if digit2 >= asciiZero, digit2 <= asciiSeven { - p += 1 - let digit2Value = digit2 - asciiZero - let digit3 = p[0] - if digit3 >= asciiZero, digit3 <= asciiSeven { + data.withUnsafeMutableBytes { + (body: UnsafeMutableRawBufferPointer) in + if var out = body.baseAddress, body.count > 0 { + while p[0] != terminator { + let byte = p[0] p += 1 - let digit3Value = digit3 - asciiZero - out[0] = digit1Value &* 64 + digit2Value * 8 + digit3Value - out += 1 - } else { - out[0] = digit1Value * 8 + digit2Value - out += 1 - } - } else { - out[0] = digit1Value - out += 1 - } - case asciiLowerU, asciiUpperU: - let numDigits = (escaped == asciiLowerU) ? 4 : 8 - var codePoint: UInt32 = 0 - for i in 0..> 6) - out[1] = 0x80 + UInt8(truncatingIfNeeded: codePoint & 0x3F) - out += 2 - case 0x800...0xffff: - // 3 byte encoding - out[0] = 0xE0 + UInt8(truncatingIfNeeded: codePoint >> 12) - out[1] = 0x80 + UInt8(truncatingIfNeeded: (codePoint >> 6) & 0x3F) - out[2] = 0x80 + UInt8(truncatingIfNeeded: codePoint & 0x3F) - out += 3 - case 0x10000...0x10FFFF: - // 4 byte encoding - out[0] = 0xF0 + UInt8(truncatingIfNeeded: codePoint >> 18) - out[1] = 0x80 + UInt8(truncatingIfNeeded: (codePoint >> 12) & 0x3F) - out[2] = 0x80 + UInt8(truncatingIfNeeded: (codePoint >> 6) & 0x3F) - out[3] = 0x80 + UInt8(truncatingIfNeeded: codePoint & 0x3F) - out += 4 - default: - preconditionFailure() // Already validated, can't happen - } - case asciiLowerX: // 'x' hexadecimal escape - // We already validated, so we know there's at least one digit: - var n = fromHexDigit(p[0])! - p += 1 - if let digit = fromHexDigit(p[0]) { - n = n &* 16 &+ digit - p += 1 + switch byte { + case asciiBackslash: // "\\" + let escaped = p[0] + p += 1 + switch escaped { + case asciiZero...asciiSeven: // '0'...'7' + // C standard allows 1, 2, or 3 octal digits. + let digit1Value = escaped - asciiZero + let digit2 = p[0] + if digit2 >= asciiZero, digit2 <= asciiSeven { + p += 1 + let digit2Value = digit2 - asciiZero + let digit3 = p[0] + if digit3 >= asciiZero, digit3 <= asciiSeven { + p += 1 + let digit3Value = digit3 - asciiZero + out[0] = digit1Value &* 64 + digit2Value * 8 + digit3Value + out += 1 + } else { + out[0] = digit1Value * 8 + digit2Value + out += 1 + } + } else { + out[0] = digit1Value + out += 1 + } + case asciiLowerU, asciiUpperU: + let numDigits = (escaped == asciiLowerU) ? 4 : 8 + var codePoint: UInt32 = 0 + for i in 0..> 6) + out[1] = 0x80 + UInt8(truncatingIfNeeded: codePoint & 0x3F) + out += 2 + case 0x800...0xffff: + // 3 byte encoding + out[0] = 0xE0 + UInt8(truncatingIfNeeded: codePoint >> 12) + out[1] = 0x80 + UInt8(truncatingIfNeeded: (codePoint >> 6) & 0x3F) + out[2] = 0x80 + UInt8(truncatingIfNeeded: codePoint & 0x3F) + out += 3 + case 0x10000...0x10FFFF: + // 4 byte encoding + out[0] = 0xF0 + UInt8(truncatingIfNeeded: codePoint >> 18) + out[1] = 0x80 + UInt8(truncatingIfNeeded: (codePoint >> 12) & 0x3F) + out[2] = 0x80 + UInt8(truncatingIfNeeded: (codePoint >> 6) & 0x3F) + out[3] = 0x80 + UInt8(truncatingIfNeeded: codePoint & 0x3F) + out += 4 + default: + preconditionFailure() // Already validated, can't happen + } + case asciiLowerX: // 'x' hexadecimal escape + // We already validated, so we know there's at least one digit: + var n = fromHexDigit(p[0])! + p += 1 + if let digit = fromHexDigit(p[0]) { + n = n &* 16 &+ digit + p += 1 + } + out[0] = n + out += 1 + case asciiLowerA: // \a ("alert") + out[0] = asciiBell + out += 1 + case asciiLowerB: // \b + out[0] = asciiBackspace + out += 1 + case asciiLowerF: // \f + out[0] = asciiFormFeed + out += 1 + case asciiLowerN: // \n + out[0] = asciiNewLine + out += 1 + case asciiLowerR: // \r + out[0] = asciiCarriageReturn + out += 1 + case asciiLowerT: // \t + out[0] = asciiTab + out += 1 + case asciiLowerV: // \v + out[0] = asciiVerticalTab + out += 1 + default: + out[0] = escaped + out += 1 + } + default: + out[0] = byte + out += 1 + } } - out[0] = n - out += 1 - case asciiLowerA: // \a ("alert") - out[0] = asciiBell - out += 1 - case asciiLowerB: // \b - out[0] = asciiBackspace - out += 1 - case asciiLowerF: // \f - out[0] = asciiFormFeed - out += 1 - case asciiLowerN: // \n - out[0] = asciiNewLine - out += 1 - case asciiLowerR: // \r - out[0] = asciiCarriageReturn - out += 1 - case asciiLowerT: // \t - out[0] = asciiTab - out += 1 - case asciiLowerV: // \v - out[0] = asciiVerticalTab - out += 1 - default: - out[0] = escaped - out += 1 - } - default: - out[0] = byte - out += 1 + p += 1 // Consume terminator } - } - p += 1 // Consume terminator } - } } /// Assumes the leading quote has already been consumed @@ -604,7 +574,7 @@ internal struct TextFormatScanner { } } p += 1 - if c == asciiBackslash { // \ + if c == asciiBackslash { // \ if p == end { return nil } @@ -616,7 +586,7 @@ internal struct TextFormatScanner { return nil } } - return nil // Unterminated quoted string + return nil // Unterminated quoted string } internal mutating func nextUInt() throws -> UInt64 { @@ -625,28 +595,24 @@ internal struct TextFormatScanner { } let c = p[0] p += 1 - if c == asciiZero { // leading '0' precedes octal or hex + if c == asciiZero { // leading '0' precedes octal or hex if p == end { // The TextFormat ended with a field value of zero. return 0 } - if p[0] == asciiLowerX { // 'x' => hex + if p[0] == asciiLowerX { // 'x' => hex p += 1 var n: UInt64 = 0 while p != end { let digit = p[0] let val: UInt64 switch digit { - case asciiZero...asciiNine: // 0...9 + case asciiZero...asciiNine: // 0...9 val = UInt64(digit - asciiZero) - case asciiLowerA...asciiLowerF: // a...f + case asciiLowerA...asciiLowerF: // a...f val = UInt64(digit - asciiLowerA + 10) case asciiUpperA...asciiUpperF: val = UInt64(digit - asciiUpperA + 10) - case asciiLowerU: // trailing 'u' - p += 1 - skipWhitespace() - return n default: skipWhitespace() return n @@ -659,18 +625,13 @@ internal struct TextFormatScanner { } skipWhitespace() return n - } else { // octal + } else { // octal var n: UInt64 = 0 while p != end { let digit = p[0] - if digit == asciiLowerU { // trailing 'u' - p += 1 - skipWhitespace() - return n - } if digit < asciiZero || digit > asciiSeven { skipWhitespace() - return n // not octal digit + return n // not octal digit } let val = UInt64(digit - asciiZero) if n > UInt64.max / 8 { @@ -682,18 +643,13 @@ internal struct TextFormatScanner { skipWhitespace() return n } - } else if c > asciiZero && c <= asciiNine { // 1...9 + } else if c > asciiZero && c <= asciiNine { // 1...9 var n = UInt64(c - asciiZero) while p != end { let digit = p[0] - if digit == asciiLowerU { // trailing 'u' - p += 1 - skipWhitespace() - return n - } if digit < asciiZero || digit > asciiNine { skipWhitespace() - return n // not a digit + return n // not a digit } let val = UInt64(digit - asciiZero) if n > UInt64.max / 10 || n * 10 > UInt64.max - val { @@ -713,7 +669,7 @@ internal struct TextFormatScanner { throw TextFormatDecodingError.malformedNumber } let c = p[0] - if c == asciiMinus { // - + if c == asciiMinus { // - p += 1 if p == end { throw TextFormatDecodingError.malformedNumber @@ -724,13 +680,13 @@ internal struct TextFormatScanner { throw TextFormatDecodingError.malformedNumber } let n = try nextUInt() - let limit: UInt64 = 0x8000000000000000 // -Int64.min + let limit: UInt64 = 0x8000_0000_0000_0000 // -Int64.min if n >= limit { if n > limit { // Too large negative number throw TextFormatDecodingError.malformedNumber } else { - return Int64.min // Special case for Int64.min + return Int64.min // Special case for Int64.min } } return -Int64(bitPattern: n) @@ -797,11 +753,11 @@ internal struct TextFormatScanner { var sawBackslash = false let n = try validateAndCountBytesFromString(terminator: c, sawBackslash: &sawBackslash) if sawBackslash { - result = Data(count: n) - parseBytesFromString(terminator: c, into: &result) + result = Data(count: n) + parseBytesFromString(terminator: c, into: &result) } else { - result = Data(bytes: p, count: n) - p += n + 1 // Skip string body + close quote + result = Data(bytes: p, count: n) + p += n + 1 // Skip string body + close quote } // If there are more strings, decode them @@ -819,12 +775,12 @@ internal struct TextFormatScanner { var sawBackslash = false let n = try validateAndCountBytesFromString(terminator: c, sawBackslash: &sawBackslash) if sawBackslash { - var b = Data(count: n) - parseBytesFromString(terminator: c, into: &b) - result.append(b) + var b = Data(count: n) + parseBytesFromString(terminator: c, into: &b) + result.append(b) } else { - result.append(Data(bytes: p, count: n)) - p += n + 1 // Skip string body + close quote + result.append(Data(bytes: p, count: n)) + p += n + 1 // Skip string body + close quote } } } @@ -832,26 +788,32 @@ internal struct TextFormatScanner { // Tries to identify a sequence of UTF8 characters // that represent a numeric floating-point value. private mutating func tryParseFloatString() -> Double? { - guard p != end else {return nil} + guard p != end else { return nil } let start = p var c = p[0] if c == asciiMinus { p += 1 - guard p != end else {p = start; return nil} + guard p != end else { + p = start + return nil + } c = p[0] } switch c { - case asciiZero: // '0' as first character is not allowed followed by digit + case asciiZero: // '0' as first character is not allowed followed by digit p += 1 - guard p != end else {break} + guard p != end else { break } c = p[0] if c >= asciiZero && c <= asciiNine { p = start return nil } - case asciiPeriod: // '.' as first char only if followed by digit + case asciiPeriod: // '.' as first char only if followed by digit p += 1 - guard p != end else {p = start; return nil} + guard p != end else { + p = start + return nil + } c = p[0] if c < asciiZero || c > asciiNine { p = start @@ -867,16 +829,21 @@ internal struct TextFormatScanner { let c = p[0] switch c { case asciiZero...asciiNine, - asciiPeriod, - asciiPlus, - asciiMinus, - asciiLowerE, - asciiUpperE: // 0...9, ., +, -, e, E + asciiPeriod, + asciiPlus, + asciiMinus, + asciiLowerE, + asciiUpperE: // 0...9, ., +, -, e, E p += 1 - case asciiLowerF: // f - // proto1 allowed floats to be suffixed with 'f' - let d = doubleParser.utf8ToDouble(bytes: UnsafeRawBufferPointer(start: start, count: p - start)) - // Just skip the 'f' + case asciiLowerF, asciiUpperF: // f or F + let d = doubleParser.utf8ToDouble( + bytes: UnsafeRawBufferPointer( + start: start, + count: p - start + ), + finiteOnly: false + ) + // Just skip the 'f'/'F' p += 1 skipWhitespace() return d @@ -884,7 +851,13 @@ internal struct TextFormatScanner { break loop } } - let d = doubleParser.utf8ToDouble(bytes: UnsafeRawBufferPointer(start: start, count: p - start)) + let d = doubleParser.utf8ToDouble( + bytes: UnsafeRawBufferPointer( + start: start, + count: p - start + ), + finiteOnly: false + ) skipWhitespace() return d } @@ -926,8 +899,9 @@ internal struct TextFormatScanner { return true } let c = p[0] - if ((c >= asciiUpperA && c <= asciiUpperZ) - || (c >= asciiLowerA && c <= asciiLowerZ)) { + if (c >= asciiUpperA && c <= asciiUpperZ) + || (c >= asciiLowerA && c <= asciiLowerZ) + { p = start return false } @@ -937,8 +911,18 @@ internal struct TextFormatScanner { // If the next token is the identifier "nan", return true. private mutating func skipOptionalNaN() -> Bool { - return skipOptionalKeyword(bytes: - [asciiLowerN, asciiLowerA, asciiLowerN]) + let start = p + // "-nan" doesn't mean anything, but upstream handles it, so skip + // over any leading minus when checking for "nan". + if p != end && p[0] == asciiMinus { + p += 1 + } + if skipOptionalKeyword(bytes: [asciiLowerN, asciiLowerA, asciiLowerN]) { + return true + } else { + p = start // It wasn't "nan", rewind incase we skipped a minus sign. + return false + } } // If the next token is a recognized spelling of "infinity", @@ -947,6 +931,7 @@ internal struct TextFormatScanner { if p == end { return nil } + let start = p let c = p[0] let negated: Bool if c == asciiMinus { @@ -956,12 +941,16 @@ internal struct TextFormatScanner { negated = false } let inf = [asciiLowerI, asciiLowerN, asciiLowerF] - let infinity = [asciiLowerI, asciiLowerN, asciiLowerF, asciiLowerI, - asciiLowerN, asciiLowerI, asciiLowerT, asciiLowerY] - if (skipOptionalKeyword(bytes: inf) - || skipOptionalKeyword(bytes: infinity)) { + let infinity = [ + asciiLowerI, asciiLowerN, asciiLowerF, asciiLowerI, + asciiLowerN, asciiLowerI, asciiLowerT, asciiLowerY, + ] + if skipOptionalKeyword(bytes: inf) + || skipOptionalKeyword(bytes: infinity) + { return negated ? -Float.infinity : Float.infinity } + p = start return nil } @@ -1024,15 +1013,15 @@ internal struct TextFormatScanner { } switch p[0] { case asciiSpace, - asciiTab, - asciiNewLine, - asciiCarriageReturn, - asciiHash, - asciiComma, - asciiSemicolon, - asciiCloseSquareBracket, - asciiCloseCurlyBracket, - asciiCloseAngleBracket: + asciiTab, + asciiNewLine, + asciiCarriageReturn, + asciiHash, + asciiComma, + asciiSemicolon, + asciiCloseSquareBracket, + asciiCloseCurlyBracket, + asciiCloseAngleBracket: skipWhitespace() return result default: @@ -1056,7 +1045,7 @@ internal struct TextFormatScanner { /// Any URLs are syntactically (almost) identical to extension /// keys, so we share the code for those. internal mutating func nextOptionalAnyURL() throws -> String? { - return try nextOptionalExtensionKey() + try nextOptionalExtensionKey() } /// Returns next extension key or nil if end-of-input or @@ -1075,43 +1064,88 @@ internal struct TextFormatScanner { if p == end { return nil } - if p[0] == asciiOpenSquareBracket { // [ + guard p[0] == asciiOpenSquareBracket else { // [ + return nil + } + return try parseExtensionKey() + } + + /// Parse the rest of an [extension_field_name] in the input, assuming the + /// initial "[" character has already been read (and is in the prefix) + /// This is also used for AnyURL, so we include "/". + private mutating func parseExtensionKey() throws -> String { + assert(p[0] == asciiOpenSquareBracket) + p += 1 + if p == end { + throw TextFormatDecodingError.malformedText + } + let start = p + switch p[0] { + case asciiLowerA...asciiLowerZ, asciiUpperA...asciiUpperZ: p += 1 - if let s = parseExtensionKey() { - if p == end || p[0] != asciiCloseSquareBracket { - throw TextFormatDecodingError.malformedText - } - // Skip ] + default: + throw TextFormatDecodingError.malformedText + } + loop: while p != end { + switch p[0] { + case asciiLowerA...asciiLowerZ, + asciiUpperA...asciiUpperZ, + asciiZero...asciiNine, + asciiUnderscore, + asciiPeriod, + asciiForwardSlash: p += 1 - skipWhitespace() - return s - } else { + case asciiCloseSquareBracket: // ] + break loop + default: throw TextFormatDecodingError.malformedText } } - return nil + if p == end || p[0] != asciiCloseSquareBracket { + throw TextFormatDecodingError.malformedText + } + guard let extensionName = utf8ToString(bytes: start, count: p - start) else { + throw TextFormatDecodingError.malformedText + } + p += 1 // Skip ] + skipWhitespace() + return extensionName } /// Returns text of next regular key or nil if end-of-input. - /// This considers an extension key [keyname] to be an - /// error, so call nextOptionalExtensionKey first if you - /// want to handle extension keys. - /// - /// This is only used by map parsing; we should be able to - /// rework that to use nextFieldNumber instead. - internal mutating func nextKey() throws -> String? { + internal mutating func nextKey(allowExtensions: Bool) throws -> String? { skipWhitespace() if p == end { return nil } let c = p[0] switch c { - case asciiOpenSquareBracket: // [ - throw TextFormatDecodingError.malformedText + case asciiOpenSquareBracket: // [ + if allowExtensions { + return "[\(try parseExtensionKey())]" + } + throw TextFormatDecodingError.unknownField case asciiLowerA...asciiLowerZ, - asciiUpperA...asciiUpperZ, - asciiOne...asciiNine: // a...z, A...Z, 1...9 + asciiUpperA...asciiUpperZ: // a...z, A...Z return parseIdentifier() + case asciiOne...asciiNine: // 1...9 (field numbers are 123, not 0123) + let start = p + p += 1 + while p != end { + let c = p[0] + if c < asciiZero || c > asciiNine { + break + } + p += 1 + if p - start > maxFieldNumLength { + throw TextFormatDecodingError.malformedText + } + } + let buff = UnsafeRawBufferPointer(start: start, count: p - start) + skipWhitespace() + let s = utf8ToString(bytes: buff.baseAddress!, count: buff.count) + // Safe, can't be invalid UTF-8 given the input. + return s! default: throw TextFormatDecodingError.malformedText } @@ -1127,46 +1161,233 @@ internal struct TextFormatScanner { /// /// This function accounts for as much as 2/3 of the total run /// time of the entire parse. - internal mutating func nextFieldNumber(names: _NameMap) throws -> Int? { - if p == end { - return nil + internal mutating func nextFieldNumber( + names: _NameMap, + messageType: any Message.Type, + terminator: UInt8? + ) throws -> Int? { + while true { + skipWhitespace() + if p == end { + if terminator == nil { + return nil + } else { + // Never got the terminator. + throw TextFormatDecodingError.malformedText + } + } + var isReserved = false + let c = p[0] + switch c { + case asciiLowerA...asciiLowerZ, + asciiUpperA...asciiUpperZ: // a...z, A...Z + let key = parseUTF8Identifier() + if let fieldNumber = names.number(forProtoName: key) { + return fieldNumber + } + if !options.ignoreUnknownFields { + if names.isReserved(name: key) { + isReserved = true + } else { + throw TextFormatDecodingError.unknownField + } + } + // Unknown field name or reserved, break and skip + break + case asciiOpenSquareBracket: // Start of an extension field + let key = try parseExtensionKey() + if let fieldNumber = extensions?.fieldNumberForProto(messageType: messageType, protoFieldName: key) { + return fieldNumber + } + if !options.ignoreUnknownExtensionFields { + throw TextFormatDecodingError.unknownField + } + // Unknown field name, break and skip + break + case asciiOne...asciiNine: // 1-9 (field numbers are 123, not 0123) + let start = p + var fieldNum = Int(c) - Int(asciiZero) + p += 1 + while p != end { + let c = p[0] + if c >= asciiZero && c <= asciiNine { + fieldNum = fieldNum &* 10 &+ (Int(c) - Int(asciiZero)) + } else { + break + } + p += 1 + if p - start > maxFieldNumLength { + throw TextFormatDecodingError.malformedText + } + } + skipWhitespace() + if names.names(for: fieldNum) != nil { + return fieldNum + } + if !options.ignoreUnknownFields { + // fieldNumber is range checked while parsing, so safe can truncate. + if names.isReserved(number: Int32(truncatingIfNeeded: fieldNum)) { + isReserved = true + } else { + throw TextFormatDecodingError.unknownField + } + } + // Unknown field name or reserved, break and skip + break + default: + if c == terminator { + let _ = skipOptionalObjectEnd(c) + return nil + } + throw TextFormatDecodingError.malformedText + } + + assert(options.ignoreUnknownFields || options.ignoreUnknownExtensionFields || isReserved) + try skipUnknownFieldValue() + // Skip any separator before looping around to try for another field. + skipOptionalSeparator() + } + } + + // Helper to skip past an unknown field value, when called `p` will be pointing + // at the first character after the unknown field name. + internal mutating func skipUnknownFieldValue() throws { + // This is modeled after the C++ text_format.cpp `ConsumeField()` + // + // Guess the type of this field: + // - If this field is not a message, there should be a ":" between the + // field name and the field value and also the field value should not + // start with "{" or "<" which indicates the beginning of a message body. + // - If there is no ":" or there is a "{" or "<" after ":", this field has + // to be a message or the input is ill-formed. + + skipWhitespace() + if skipOptionalColon() { + if p == end { + // Nothing after the ':'? + throw TextFormatDecodingError.malformedText + } + let c = p[0] + if c != asciiOpenAngleBracket && c != asciiOpenCurlyBracket { + try skipUnknownPrimativeFieldValue() + } else { + try skipUnknownMessageFieldValue() + } + } else { + try skipUnknownMessageFieldValue() + } + } + + /// Helper to see if this could be the start of a hex or octal number so unknown field + /// value parsing can decide how to parse/validate. + private func mustParseNumberAsDecimal() -> Bool { + // NOTE: If we run out of characters/can't tell; then just say it doesn't have + // to be decimal, and let the other code error handle it. + var scan = p + var c = scan[0] + + // Floats or decimals can have leading '-' + if c == asciiMinus { + scan += 1 + if scan == end { return false } + c = scan[0] + } + + if c == asciiPeriod { + return false // "(-)." : clearly a float + } + + if c == asciiZero { + scan += 1 + if scan == end { return true } // "(-)0[end]" : parse it as decimal + c = scan[0] + if c == asciiLowerX // "(-)0x" : hex - must parse as decimal + || (c >= asciiZero && c <= asciiSeven) + { // "(-)0[0-7]" : octal - must parse as decimal + return true + } + if c == asciiPeriod { + return false // "(-)0." : clearly a float + } } + + // At this point, it doesn't realy matter what comes next. We'll call it a floating + // point value since even if it was a decimal, it might be too large for a UInt64 but + // would still be valid for a float/double field. + return false + } + + private mutating func skipUnknownPrimativeFieldValue(canBeList: Bool = true) throws { + // This is modeled after the C++ text_format.cpp `SkipFieldValue()` let c = p[0] - switch c { - case asciiLowerA...asciiLowerZ, - asciiUpperA...asciiUpperZ: // a...z, A...Z - let key = parseUTF8Identifier() - if let fieldNumber = names.number(forProtoName: key) { - return fieldNumber + + if c == asciiSingleQuote || c == asciiDoubleQuote { + // Note: the field could be 'bytes', so we can't parse that as a string + // as it might fail. + let _ = try nextBytesValue() + return + } + + if skipOptionalBeginArray() { + guard canBeList else { + // Have encounted an array as an element in an array, that isn't legal. + throw TextFormatDecodingError.malformedText + } + if skipOptionalEndArray() { + return + } + while true { + if p == end { + throw TextFormatDecodingError.malformedText + } + let c = p[0] + if c != asciiOpenAngleBracket && c != asciiOpenCurlyBracket { + try skipUnknownPrimativeFieldValue(canBeList: false) + } else { + try skipUnknownMessageFieldValue() + } + if skipOptionalEndArray() { + return + } + try skipRequiredComma() + } + } + + // NOTE: This will also cover "true", "false" for booleans, "nan"/"inf" for floats. + if let _ = try nextOptionalEnumName() { + skipWhitespace() // `nextOptionalEnumName()` doesn't skip trailing whitespace + return + } + + // NOTE: We don't need to special case "-nan"/"-inf", as they won't be forced + // to parse as decimal, and `nextDouble()` already supports them. + if mustParseNumberAsDecimal() { + if c == asciiMinus { + let _ = try nextSInt() } else { - throw TextFormatDecodingError.unknownField + let _ = try nextUInt() } - case asciiOne...asciiNine: // 1-9 (field numbers are 123, not 0123) - var fieldNum = Int(c) - Int(asciiZero) - p += 1 - while p != end { - let c = p[0] - if c >= asciiZero && c <= asciiNine { - fieldNum = fieldNum &* 10 &+ (Int(c) - Int(asciiZero)) - } else { - break - } - p += 1 + } else { + let _ = try nextDouble() + } + } + + private mutating func skipUnknownMessageFieldValue() throws { + // This is modeled after the C++ text_format.cpp `SkipFieldMessage()` + + let terminator = try skipObjectStart() + while !skipOptionalObjectEnd(terminator) { + if p == end { + throw TextFormatDecodingError.malformedText } - skipWhitespace() - if names.names(for: fieldNum) != nil { - return fieldNum + if let _ = try nextKey(allowExtensions: true) { + // Got a valid field name or extension name ("[ext.name]") } else { - // It was a number that isn't a known field. - // The C++ version (TextFormat::Parser::ParserImpl::ConsumeField()), - // supports an option to file or skip the field's value (this is true - // of unknown names or numbers). - throw TextFormatDecodingError.unknownField + throw TextFormatDecodingError.malformedText } - default: - break + try skipUnknownFieldValue() + skipOptionalSeparator() } - throw TextFormatDecodingError.malformedText } private mutating func skipRequiredCharacter(_ c: UInt8) throws { @@ -1197,15 +1418,15 @@ internal struct TextFormatScanner { } internal mutating func skipOptionalColon() -> Bool { - return skipOptionalCharacter(asciiColon) + skipOptionalCharacter(asciiColon) } internal mutating func skipOptionalEndArray() -> Bool { - return skipOptionalCharacter(asciiCloseSquareBracket) + skipOptionalCharacter(asciiCloseSquareBracket) } internal mutating func skipOptionalBeginArray() -> Bool { - return skipOptionalCharacter(asciiOpenSquareBracket) + skipOptionalCharacter(asciiOpenSquareBracket) } internal mutating func skipOptionalObjectEnd(_ c: UInt8) -> Bool { @@ -1219,7 +1440,7 @@ internal struct TextFormatScanner { internal mutating func skipOptionalSeparator() { if p != end { let c = p[0] - if c == asciiComma || c == asciiSemicolon { // comma or semicolon + if c == asciiComma || c == asciiSemicolon { // comma or semicolon p += 1 skipWhitespace() } @@ -1235,10 +1456,10 @@ internal struct TextFormatScanner { p += 1 skipWhitespace() switch c { - case asciiOpenCurlyBracket: // { - return asciiCloseCurlyBracket // } - case asciiOpenAngleBracket: // < - return asciiCloseAngleBracket // > + case asciiOpenCurlyBracket: // { + return asciiCloseCurlyBracket // } + case asciiOpenAngleBracket: // < + return asciiCloseAngleBracket // > default: break } diff --git a/Sources/SwiftProtobuf/TimeUtils.swift b/Sources/SwiftProtobuf/TimeUtils.swift index a7d142b40..bccd13fb9 100644 --- a/Sources/SwiftProtobuf/TimeUtils.swift +++ b/Sources/SwiftProtobuf/TimeUtils.swift @@ -17,7 +17,8 @@ let minutesPerHour: Int32 = 60 let secondsPerDay: Int32 = 86400 let secondsPerHour: Int32 = 3600 let secondsPerMinute: Int32 = 60 -let nanosPerSecond: Int32 = 1000000000 +let nanosPerSecond: Int32 = 1_000_000_000 +let attosPerNanosecond: Int64 = 1_000_000_000 internal func timeOfDayFromSecondsSince1970(seconds: Int64) -> (hh: Int32, mm: Int32, ss: Int32) { let secondsSinceMidnight = Int32(mod(seconds, Int64(secondsPerDay))) @@ -31,7 +32,7 @@ internal func timeOfDayFromSecondsSince1970(seconds: Int64) -> (hh: Int32, mm: I internal func julianDayNumberFromSecondsSince1970(seconds: Int64) -> Int64 { // January 1, 1970 is Julian Day Number 2440588. // See http://aa.usno.navy.mil/faq/docs/JD_Formula.php - return div(seconds + 2440588 * Int64(secondsPerDay), Int64(secondsPerDay)) + div(seconds + 2_440_588 * Int64(secondsPerDay), Int64(secondsPerDay)) } internal func gregorianDateFromSecondsSince1970(seconds: Int64) -> (YY: Int32, MM: Int32, DD: Int32) { @@ -53,13 +54,13 @@ internal func gregorianDateFromSecondsSince1970(seconds: Int64) -> (YY: Int32, M } internal func nanosToString(nanos: Int32) -> String { - if nanos == 0 { - return "" - } else if nanos % 1000000 == 0 { - return ".\(threeDigit(abs(nanos) / 1000000))" - } else if nanos % 1000 == 0 { - return ".\(sixDigit(abs(nanos) / 1000))" - } else { - return ".\(nineDigit(abs(nanos)))" - } -} \ No newline at end of file + if nanos == 0 { + return "" + } else if nanos % 1_000_000 == 0 { + return ".\(threeDigit(abs(nanos) / 1_000_000))" + } else if nanos % 1000 == 0 { + return ".\(sixDigit(abs(nanos) / 1000))" + } else { + return ".\(nineDigit(abs(nanos)))" + } +} diff --git a/Sources/SwiftProtobuf/UnknownStorage.swift b/Sources/SwiftProtobuf/UnknownStorage.swift index 7829733c8..b2008dbdb 100644 --- a/Sources/SwiftProtobuf/UnknownStorage.swift +++ b/Sources/SwiftProtobuf/UnknownStorage.swift @@ -16,33 +16,26 @@ import Foundation -// TODO: `UnknownStorage` should be `Sendable` but we cannot do so yet without possibly breaking compatibility. - /// Contains any unknown fields in a decoded message; that is, fields that were /// sent on the wire but were not recognized by the generated message /// implementation or were valid field numbers but with mismatching wire /// formats (for example, a field encoded as a varint when a fixed32 integer /// was expected). -public struct UnknownStorage: Equatable { - /// The raw protocol buffer binary-encoded bytes that represent the unknown - /// fields of a decoded message. - public private(set) var data = Data() +public struct UnknownStorage: Equatable, Sendable { -#if !swift(>=4.1) - public static func ==(lhs: UnknownStorage, rhs: UnknownStorage) -> Bool { - return lhs.data == rhs.data - } -#endif + /// The raw protocol buffer binary-encoded bytes that represent the unknown + /// fields of a decoded message. + public private(set) var data = Data() - public init() {} + public init() {} - internal mutating func append(protobufData: Data) { - data.append(protobufData) - } + package mutating func append(protobufData: Data) { + data.append(protobufData) + } - public func traverse(visitor: inout V) throws { - if !data.isEmpty { - try visitor.visitUnknown(bytes: data) + public func traverse(visitor: inout V) throws { + if !data.isEmpty { + try visitor.visitUnknown(bytes: data) + } } - } } diff --git a/Sources/SwiftProtobuf/UnsafeBufferPointer+Shims.swift b/Sources/SwiftProtobuf/UnsafeBufferPointer+Shims.swift deleted file mode 100644 index 64f3b8188..000000000 --- a/Sources/SwiftProtobuf/UnsafeBufferPointer+Shims.swift +++ /dev/null @@ -1,37 +0,0 @@ -// Sources/SwiftProtobuf/UnsafeBufferPointer+Shims.swift - Shims for UnsafeBufferPointer -// -// Copyright (c) 2019 Apple Inc. and the project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See LICENSE.txt for license information: -// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt -// -// ----------------------------------------------------------------------------- -/// -/// Shims for UnsafeBufferPointer -/// -// ----------------------------------------------------------------------------- - - -extension UnsafeMutableBufferPointer { - #if !swift(>=4.2) - internal static func allocate(capacity: Int) -> UnsafeMutableBufferPointer { - let pointer = UnsafeMutablePointer.allocate(capacity: capacity) - return UnsafeMutableBufferPointer(start: pointer, count: capacity) - } - #endif - - #if !swift(>=4.1) - internal func deallocate() { - self.baseAddress?.deallocate(capacity: self.count) - } - #endif -} - -extension UnsafeMutableRawBufferPointer { - #if !swift(>=4.1) - internal func copyMemory(from source: C) where C.Element == UInt8 { - self.copyBytes(from: source) - } - #endif -} diff --git a/Sources/SwiftProtobuf/UnsafeRawPointer+Shims.swift b/Sources/SwiftProtobuf/UnsafeRawPointer+Shims.swift index 9818bced3..da70bd8ce 100644 --- a/Sources/SwiftProtobuf/UnsafeRawPointer+Shims.swift +++ b/Sources/SwiftProtobuf/UnsafeRawPointer+Shims.swift @@ -12,14 +12,13 @@ /// // ----------------------------------------------------------------------------- - extension UnsafeRawPointer { /// A shim subscript for UnsafeRawPointer aiming to maintain code consistency. /// /// We can remove this shim when we rewrite the code to use buffer pointers. internal subscript(_ offset: Int) -> UInt8 { get { - return self.load(fromByteOffset: offset, as: UInt8.self) + self.load(fromByteOffset: offset, as: UInt8.self) } } } @@ -30,16 +29,10 @@ extension UnsafeMutableRawPointer { /// We can remove this shim when we rewrite the code to use buffer pointers. internal subscript(_ offset: Int) -> UInt8 { get { - return self.load(fromByteOffset: offset, as: UInt8.self) + self.load(fromByteOffset: offset, as: UInt8.self) } set { self.storeBytes(of: newValue, toByteOffset: offset, as: UInt8.self) } } - - #if !swift(>=4.1) - internal mutating func copyMemory(from source: UnsafeRawPointer, byteCount: Int) { - self.copyBytes(from: source, count: byteCount) - } - #endif } diff --git a/Sources/SwiftProtobuf/Varint.swift b/Sources/SwiftProtobuf/Varint.swift index d928d9383..a7f593ff0 100644 --- a/Sources/SwiftProtobuf/Varint.swift +++ b/Sources/SwiftProtobuf/Varint.swift @@ -12,97 +12,67 @@ /// // ----------------------------------------------------------------------------- - /// Contains helper methods to varint-encode and decode integers. -internal enum Varint { +package enum Varint { - /// Computes the number of bytes that would be needed to store a 32-bit varint. - /// - /// - Parameter value: The number whose varint size should be calculated. - /// - Returns: The size, in bytes, of the 32-bit varint. - static func encodedSize(of value: UInt32) -> Int { - if (value & (~0 << 7)) == 0 { - return 1 - } - if (value & (~0 << 14)) == 0 { - return 2 - } - if (value & (~0 << 21)) == 0 { - return 3 + /// Computes the number of bytes that would be needed to store a 32-bit varint. + /// + /// - Parameter value: The number whose varint size should be calculated. + /// - Returns: The size, in bytes, of the 32-bit varint. + @usableFromInline + package static func encodedSize(of value: UInt32) -> Int { + // This logic comes from the upstream C++ for CodedOutputStream::VarintSize32(uint32_t), + // it provides a branchless calculation of the size. + let clz = value.leadingZeroBitCount + return ((UInt32.bitWidth &* 9 &+ 64) &- (clz &* 9)) / 64 } - if (value & (~0 << 28)) == 0 { - return 4 - } - return 5 - } - /// Computes the number of bytes that would be needed to store a signed 32-bit varint, if it were - /// treated as an unsigned integer with the same bit pattern. - /// - /// - Parameter value: The number whose varint size should be calculated. - /// - Returns: The size, in bytes, of the 32-bit varint. - static func encodedSize(of value: Int32) -> Int { - if value >= 0 { - return encodedSize(of: UInt32(bitPattern: value)) - } else { - // Must sign-extend. - return encodedSize(of: Int64(value)) + /// Computes the number of bytes that would be needed to store a signed 32-bit varint, if it were + /// treated as an unsigned integer with the same bit pattern. + /// + /// - Parameter value: The number whose varint size should be calculated. + /// - Returns: The size, in bytes, of the 32-bit varint. + @inline(__always) + package static func encodedSize(of value: Int32) -> Int { + // Must sign-extend. + encodedSize(of: Int64(value)) } - } - /// Computes the number of bytes that would be needed to store a 64-bit varint. - /// - /// - Parameter value: The number whose varint size should be calculated. - /// - Returns: The size, in bytes, of the 64-bit varint. - static func encodedSize(of value: Int64) -> Int { - // Handle two common special cases up front. - if (value & (~0 << 7)) == 0 { - return 1 - } - if value < 0 { - return 10 + /// Computes the number of bytes that would be needed to store a 64-bit varint. + /// + /// - Parameter value: The number whose varint size should be calculated. + /// - Returns: The size, in bytes, of the 64-bit varint. + @inline(__always) + static func encodedSize(of value: Int64) -> Int { + encodedSize(of: UInt64(bitPattern: value)) } - // Divide and conquer the remaining eight cases. - var value = value - var n = 2 - - if (value & (~0 << 35)) != 0 { - n += 4 - value >>= 28 - } - if (value & (~0 << 21)) != 0 { - n += 2 - value >>= 14 + /// Computes the number of bytes that would be needed to store an unsigned 64-bit varint, if it + /// were treated as a signed integer with the same bit pattern. + /// + /// - Parameter value: The number whose varint size should be calculated. + /// - Returns: The size, in bytes, of the 64-bit varint. + @usableFromInline + static func encodedSize(of value: UInt64) -> Int { + // This logic comes from the upstream C++ for CodedOutputStream::VarintSize64(uint64_t), + // it provides a branchless calculation of the size. + let clz = value.leadingZeroBitCount + return ((UInt64.bitWidth &* 9 &+ 64) &- (clz &* 9)) / 64 } - if (value & (~0 << 14)) != 0 { - n += 1 - } - return n - } - - /// Computes the number of bytes that would be needed to store an unsigned 64-bit varint, if it - /// were treated as a signed integer witht he same bit pattern. - /// - /// - Parameter value: The number whose varint size should be calculated. - /// - Returns: The size, in bytes, of the 64-bit varint. - static func encodedSize(of value: UInt64) -> Int { - return encodedSize(of: Int64(bitPattern: value)) - } - /// Counts the number of distinct varints in a packed byte buffer. - static func countVarintsInBuffer(start: UnsafeRawPointer, count: Int) -> Int { - // We don't need to decode all the varints to count how many there - // are. Just observe that every varint has exactly one byte with - // value < 128. So we just count those... - var n = 0 - var ints = 0 - while n < count { - if start.load(fromByteOffset: n, as: UInt8.self) < 128 { - ints += 1 - } - n += 1 + /// Counts the number of distinct varints in a packed byte buffer. + static func countVarintsInBuffer(start: UnsafeRawPointer, count: Int) -> Int { + // We don't need to decode all the varints to count how many there + // are. Just observe that every varint has exactly one byte with + // value < 128. So we just count those... + var n = 0 + var ints = 0 + while n < count { + if start.load(fromByteOffset: n, as: UInt8.self) < 128 { + ints &+= 1 + } + n &+= 1 + } + return ints } - return ints - } } diff --git a/Sources/SwiftProtobuf/Version.swift b/Sources/SwiftProtobuf/Version.swift index 25e33ef44..51e38afee 100644 --- a/Sources/SwiftProtobuf/Version.swift +++ b/Sources/SwiftProtobuf/Version.swift @@ -16,13 +16,13 @@ import Foundation // Expose version information about the library. public struct Version { - /// Major version. - public static let major = 1 - /// Minor version. - public static let minor = 18 - /// Revision number. - public static let revision = 0 + /// Major version. + public static let major = 1 + /// Minor version. + public static let minor = 33 + /// Revision number. + public static let revision = 3 - /// String form of the version number. - public static let versionString = "\(major).\(minor).\(revision)" + /// String form of the version number. + public static let versionString = "\(major).\(minor).\(revision)" } diff --git a/Sources/SwiftProtobuf/Visitor.swift b/Sources/SwiftProtobuf/Visitor.swift index b41c7c949..5955e5672 100644 --- a/Sources/SwiftProtobuf/Visitor.swift +++ b/Sources/SwiftProtobuf/Visitor.swift @@ -32,694 +32,705 @@ import Foundation /// Protobuf Binary, Protobuf Text, JSON, and the Hash encoder. public protocol Visitor { - /// Called for each non-repeated float field - /// - /// A default implementation is provided that just widens the value - /// and calls `visitSingularDoubleField` - mutating func visitSingularFloatField(value: Float, fieldNumber: Int) throws - - /// Called for each non-repeated double field - /// - /// There is no default implementation. This must be implemented. - mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws - - /// Called for each non-repeated int32 field - /// - /// A default implementation is provided that just widens the value - /// and calls `visitSingularInt64Field` - mutating func visitSingularInt32Field(value: Int32, fieldNumber: Int) throws - - /// Called for each non-repeated int64 field - /// - /// There is no default implementation. This must be implemented. - mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws - - /// Called for each non-repeated uint32 field - /// - /// A default implementation is provided that just widens the value - /// and calls `visitSingularUInt64Field` - mutating func visitSingularUInt32Field(value: UInt32, fieldNumber: Int) throws - - /// Called for each non-repeated uint64 field - /// - /// There is no default implementation. This must be implemented. - mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws - - /// Called for each non-repeated sint32 field - /// - /// A default implementation is provided that just forwards to - /// `visitSingularInt32Field` - mutating func visitSingularSInt32Field(value: Int32, fieldNumber: Int) throws - - /// Called for each non-repeated sint64 field - /// - /// A default implementation is provided that just forwards to - /// `visitSingularInt64Field` - mutating func visitSingularSInt64Field(value: Int64, fieldNumber: Int) throws - - /// Called for each non-repeated fixed32 field - /// - /// A default implementation is provided that just forwards to - /// `visitSingularUInt32Field` - mutating func visitSingularFixed32Field(value: UInt32, fieldNumber: Int) throws - - /// Called for each non-repeated fixed64 field - /// - /// A default implementation is provided that just forwards to - /// `visitSingularUInt64Field` - mutating func visitSingularFixed64Field(value: UInt64, fieldNumber: Int) throws - - /// Called for each non-repeated sfixed32 field - /// - /// A default implementation is provided that just forwards to - /// `visitSingularInt32Field` - mutating func visitSingularSFixed32Field(value: Int32, fieldNumber: Int) throws - - /// Called for each non-repeated sfixed64 field - /// - /// A default implementation is provided that just forwards to - /// `visitSingularInt64Field` - mutating func visitSingularSFixed64Field(value: Int64, fieldNumber: Int) throws - - /// Called for each non-repeated bool field - /// - /// There is no default implementation. This must be implemented. - mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws - - /// Called for each non-repeated string field - /// - /// There is no default implementation. This must be implemented. - mutating func visitSingularStringField(value: String, fieldNumber: Int) throws - - /// Called for each non-repeated bytes field - /// - /// There is no default implementation. This must be implemented. - mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws - - /// Called for each non-repeated enum field - /// - /// There is no default implementation. This must be implemented. - mutating func visitSingularEnumField(value: E, fieldNumber: Int) throws - - /// Called for each non-repeated nested message field. - /// - /// There is no default implementation. This must be implemented. - mutating func visitSingularMessageField(value: M, fieldNumber: Int) throws - - /// Called for each non-repeated proto2 group field. - /// - /// A default implementation is provided that simply forwards to - /// `visitSingularMessageField`. Implementors who need to handle groups - /// differently than nested messages can override this and provide distinct - /// implementations. - mutating func visitSingularGroupField(value: G, fieldNumber: Int) throws - - // Called for each non-packed repeated float field. - /// The method is called once with the complete array of values for - /// the field. - /// - /// A default implementation is provided that simply calls - /// `visitSingularFloatField` once for each item in the array. - mutating func visitRepeatedFloatField(value: [Float], fieldNumber: Int) throws - - // Called for each non-packed repeated double field. - /// The method is called once with the complete array of values for - /// the field. - /// - /// A default implementation is provided that simply calls - /// `visitSingularDoubleField` once for each item in the array. - mutating func visitRepeatedDoubleField(value: [Double], fieldNumber: Int) throws - - // Called for each non-packed repeated int32 field. - /// The method is called once with the complete array of values for - /// the field. - /// - /// A default implementation is provided that simply calls - /// `visitSingularInt32Field` once for each item in the array. - mutating func visitRepeatedInt32Field(value: [Int32], fieldNumber: Int) throws - - // Called for each non-packed repeated int64 field. - /// The method is called once with the complete array of values for - /// the field. - /// - /// A default implementation is provided that simply calls - /// `visitSingularInt64Field` once for each item in the array. - mutating func visitRepeatedInt64Field(value: [Int64], fieldNumber: Int) throws - - // Called for each non-packed repeated uint32 field. - /// The method is called once with the complete array of values for - /// the field. - /// - /// A default implementation is provided that simply calls - /// `visitSingularUInt32Field` once for each item in the array. - mutating func visitRepeatedUInt32Field(value: [UInt32], fieldNumber: Int) throws - - // Called for each non-packed repeated uint64 field. - /// The method is called once with the complete array of values for - /// the field. - /// - /// A default implementation is provided that simply calls - /// `visitSingularUInt64Field` once for each item in the array. - mutating func visitRepeatedUInt64Field(value: [UInt64], fieldNumber: Int) throws - - // Called for each non-packed repeated sint32 field. - /// The method is called once with the complete array of values for - /// the field. - /// - /// A default implementation is provided that simply calls - /// `visitSingularSInt32Field` once for each item in the array. - mutating func visitRepeatedSInt32Field(value: [Int32], fieldNumber: Int) throws - - // Called for each non-packed repeated sint64 field. - /// The method is called once with the complete array of values for - /// the field. - /// - /// A default implementation is provided that simply calls - /// `visitSingularSInt64Field` once for each item in the array. - mutating func visitRepeatedSInt64Field(value: [Int64], fieldNumber: Int) throws - - // Called for each non-packed repeated fixed32 field. - /// The method is called once with the complete array of values for - /// the field. - /// - /// A default implementation is provided that simply calls - /// `visitSingularFixed32Field` once for each item in the array. - mutating func visitRepeatedFixed32Field(value: [UInt32], fieldNumber: Int) throws - - // Called for each non-packed repeated fixed64 field. - /// The method is called once with the complete array of values for - /// the field. - /// - /// A default implementation is provided that simply calls - /// `visitSingularFixed64Field` once for each item in the array. - mutating func visitRepeatedFixed64Field(value: [UInt64], fieldNumber: Int) throws - - // Called for each non-packed repeated sfixed32 field. - /// The method is called once with the complete array of values for - /// the field. - /// - /// A default implementation is provided that simply calls - /// `visitSingularSFixed32Field` once for each item in the array. - mutating func visitRepeatedSFixed32Field(value: [Int32], fieldNumber: Int) throws - - // Called for each non-packed repeated sfixed64 field. - /// The method is called once with the complete array of values for - /// the field. - /// - /// A default implementation is provided that simply calls - /// `visitSingularSFixed64Field` once for each item in the array. - mutating func visitRepeatedSFixed64Field(value: [Int64], fieldNumber: Int) throws - - // Called for each non-packed repeated bool field. - /// The method is called once with the complete array of values for - /// the field. - /// - /// A default implementation is provided that simply calls - /// `visitSingularBoolField` once for each item in the array. - mutating func visitRepeatedBoolField(value: [Bool], fieldNumber: Int) throws - - // Called for each non-packed repeated string field. - /// The method is called once with the complete array of values for - /// the field. - /// - /// A default implementation is provided that simply calls - /// `visitSingularStringField` once for each item in the array. - mutating func visitRepeatedStringField(value: [String], fieldNumber: Int) throws - - // Called for each non-packed repeated bytes field. - /// The method is called once with the complete array of values for - /// the field. - /// - /// A default implementation is provided that simply calls - /// `visitSingularBytesField` once for each item in the array. - mutating func visitRepeatedBytesField(value: [Data], fieldNumber: Int) throws - - /// Called for each repeated, unpacked enum field. - /// The method is called once with the complete array of values for - /// the field. - /// - /// A default implementation is provided that simply calls - /// `visitSingularEnumField` once for each item in the array. - mutating func visitRepeatedEnumField(value: [E], fieldNumber: Int) throws - - /// Called for each repeated nested message field. The method is called once - /// with the complete array of values for the field. - /// - /// A default implementation is provided that simply calls - /// `visitSingularMessageField` once for each item in the array. - mutating func visitRepeatedMessageField(value: [M], - fieldNumber: Int) throws - - /// Called for each repeated proto2 group field. - /// - /// A default implementation is provided that simply calls - /// `visitSingularGroupField` once for each item in the array. - mutating func visitRepeatedGroupField(value: [G], fieldNumber: Int) throws - - // Called for each packed, repeated float field. - /// - /// This is called once with the complete array of values for - /// the field. - /// - /// There is a default implementation that forwards to the non-packed - /// function. - mutating func visitPackedFloatField(value: [Float], fieldNumber: Int) throws - - // Called for each packed, repeated double field. - /// - /// This is called once with the complete array of values for - /// the field. - /// - /// There is a default implementation that forwards to the non-packed - /// function. - mutating func visitPackedDoubleField(value: [Double], fieldNumber: Int) throws - - // Called for each packed, repeated int32 field. - /// - /// This is called once with the complete array of values for - /// the field. - /// - /// There is a default implementation that forwards to the non-packed - /// function. - mutating func visitPackedInt32Field(value: [Int32], fieldNumber: Int) throws - - // Called for each packed, repeated int64 field. - /// - /// This is called once with the complete array of values for - /// the field. - /// - /// There is a default implementation that forwards to the non-packed - /// function. - mutating func visitPackedInt64Field(value: [Int64], fieldNumber: Int) throws - - // Called for each packed, repeated uint32 field. - /// - /// This is called once with the complete array of values for - /// the field. - /// - /// There is a default implementation that forwards to the non-packed - /// function. - mutating func visitPackedUInt32Field(value: [UInt32], fieldNumber: Int) throws - - // Called for each packed, repeated uint64 field. - /// - /// This is called once with the complete array of values for - /// the field. - /// - /// There is a default implementation that forwards to the non-packed - /// function. - mutating func visitPackedUInt64Field(value: [UInt64], fieldNumber: Int) throws - - // Called for each packed, repeated sint32 field. - /// - /// This is called once with the complete array of values for - /// the field. - /// - /// There is a default implementation that forwards to the non-packed - /// function. - mutating func visitPackedSInt32Field(value: [Int32], fieldNumber: Int) throws - - // Called for each packed, repeated sint64 field. - /// - /// This is called once with the complete array of values for - /// the field. - /// - /// There is a default implementation that forwards to the non-packed - /// function. - mutating func visitPackedSInt64Field(value: [Int64], fieldNumber: Int) throws - - // Called for each packed, repeated fixed32 field. - /// - /// This is called once with the complete array of values for - /// the field. - /// - /// There is a default implementation that forwards to the non-packed - /// function. - mutating func visitPackedFixed32Field(value: [UInt32], fieldNumber: Int) throws - - // Called for each packed, repeated fixed64 field. - /// - /// This is called once with the complete array of values for - /// the field. - /// - /// There is a default implementation that forwards to the non-packed - /// function. - mutating func visitPackedFixed64Field(value: [UInt64], fieldNumber: Int) throws - - // Called for each packed, repeated sfixed32 field. - /// - /// This is called once with the complete array of values for - /// the field. - /// - /// There is a default implementation that forwards to the non-packed - /// function. - mutating func visitPackedSFixed32Field(value: [Int32], fieldNumber: Int) throws - - // Called for each packed, repeated sfixed64 field. - /// - /// This is called once with the complete array of values for - /// the field. - /// - /// There is a default implementation that forwards to the non-packed - /// function. - mutating func visitPackedSFixed64Field(value: [Int64], fieldNumber: Int) throws - - // Called for each packed, repeated bool field. - /// - /// This is called once with the complete array of values for - /// the field. - /// - /// There is a default implementation that forwards to the non-packed - /// function. - mutating func visitPackedBoolField(value: [Bool], fieldNumber: Int) throws - - /// Called for each repeated, packed enum field. - /// The method is called once with the complete array of values for - /// the field. - /// - /// A default implementation is provided that simply forwards to - /// `visitRepeatedEnumField`. Implementors who need to handle packed fields - /// differently than unpacked fields can override this and provide distinct - /// implementations. - mutating func visitPackedEnumField(value: [E], fieldNumber: Int) throws - - /// Called for each map field with primitive values. The method is - /// called once with the complete dictionary of keys/values for the - /// field. - /// - /// There is no default implementation. This must be implemented. - mutating func visitMapField( - fieldType: _ProtobufMap.Type, - value: _ProtobufMap.BaseType, - fieldNumber: Int) throws - - /// Called for each map field with enum values. The method is called - /// once with the complete dictionary of keys/values for the field. - /// - /// There is no default implementation. This must be implemented. - mutating func visitMapField( - fieldType: _ProtobufEnumMap.Type, - value: _ProtobufEnumMap.BaseType, - fieldNumber: Int) throws where ValueType.RawValue == Int - - /// Called for each map field with message values. The method is - /// called once with the complete dictionary of keys/values for the - /// field. - /// - /// There is no default implementation. This must be implemented. - mutating func visitMapField( - fieldType: _ProtobufMessageMap.Type, - value: _ProtobufMessageMap.BaseType, - fieldNumber: Int) throws - - /// Called for each extension range. - mutating func visitExtensionFields(fields: ExtensionFieldValueSet, start: Int, end: Int) throws - - /// Called for each extension range. - mutating func visitExtensionFieldsAsMessageSet( - fields: ExtensionFieldValueSet, - start: Int, - end: Int) throws - - /// Called with the raw bytes that represent any unknown fields. - mutating func visitUnknown(bytes: Data) throws + /// Called for each non-repeated float field + /// + /// A default implementation is provided that just widens the value + /// and calls `visitSingularDoubleField` + mutating func visitSingularFloatField(value: Float, fieldNumber: Int) throws + + /// Called for each non-repeated double field + /// + /// There is no default implementation. This must be implemented. + mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws + + /// Called for each non-repeated int32 field + /// + /// A default implementation is provided that just widens the value + /// and calls `visitSingularInt64Field` + mutating func visitSingularInt32Field(value: Int32, fieldNumber: Int) throws + + /// Called for each non-repeated int64 field + /// + /// There is no default implementation. This must be implemented. + mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws + + /// Called for each non-repeated uint32 field + /// + /// A default implementation is provided that just widens the value + /// and calls `visitSingularUInt64Field` + mutating func visitSingularUInt32Field(value: UInt32, fieldNumber: Int) throws + + /// Called for each non-repeated uint64 field + /// + /// There is no default implementation. This must be implemented. + mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws + + /// Called for each non-repeated sint32 field + /// + /// A default implementation is provided that just forwards to + /// `visitSingularInt32Field` + mutating func visitSingularSInt32Field(value: Int32, fieldNumber: Int) throws + + /// Called for each non-repeated sint64 field + /// + /// A default implementation is provided that just forwards to + /// `visitSingularInt64Field` + mutating func visitSingularSInt64Field(value: Int64, fieldNumber: Int) throws + + /// Called for each non-repeated fixed32 field + /// + /// A default implementation is provided that just forwards to + /// `visitSingularUInt32Field` + mutating func visitSingularFixed32Field(value: UInt32, fieldNumber: Int) throws + + /// Called for each non-repeated fixed64 field + /// + /// A default implementation is provided that just forwards to + /// `visitSingularUInt64Field` + mutating func visitSingularFixed64Field(value: UInt64, fieldNumber: Int) throws + + /// Called for each non-repeated sfixed32 field + /// + /// A default implementation is provided that just forwards to + /// `visitSingularInt32Field` + mutating func visitSingularSFixed32Field(value: Int32, fieldNumber: Int) throws + + /// Called for each non-repeated sfixed64 field + /// + /// A default implementation is provided that just forwards to + /// `visitSingularInt64Field` + mutating func visitSingularSFixed64Field(value: Int64, fieldNumber: Int) throws + + /// Called for each non-repeated bool field + /// + /// There is no default implementation. This must be implemented. + mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws + + /// Called for each non-repeated string field + /// + /// There is no default implementation. This must be implemented. + mutating func visitSingularStringField(value: String, fieldNumber: Int) throws + + /// Called for each non-repeated bytes field + /// + /// There is no default implementation. This must be implemented. + mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws + + /// Called for each non-repeated enum field + /// + /// There is no default implementation. This must be implemented. + mutating func visitSingularEnumField(value: E, fieldNumber: Int) throws + + /// Called for each non-repeated nested message field. + /// + /// There is no default implementation. This must be implemented. + mutating func visitSingularMessageField(value: M, fieldNumber: Int) throws + + /// Called for each non-repeated proto2 group field. + /// + /// A default implementation is provided that simply forwards to + /// `visitSingularMessageField`. Implementors who need to handle groups + /// differently than nested messages can override this and provide distinct + /// implementations. + mutating func visitSingularGroupField(value: G, fieldNumber: Int) throws + + // Called for each non-packed repeated float field. + /// The method is called once with the complete array of values for + /// the field. + /// + /// A default implementation is provided that simply calls + /// `visitSingularFloatField` once for each item in the array. + mutating func visitRepeatedFloatField(value: [Float], fieldNumber: Int) throws + + // Called for each non-packed repeated double field. + /// The method is called once with the complete array of values for + /// the field. + /// + /// A default implementation is provided that simply calls + /// `visitSingularDoubleField` once for each item in the array. + mutating func visitRepeatedDoubleField(value: [Double], fieldNumber: Int) throws + + // Called for each non-packed repeated int32 field. + /// The method is called once with the complete array of values for + /// the field. + /// + /// A default implementation is provided that simply calls + /// `visitSingularInt32Field` once for each item in the array. + mutating func visitRepeatedInt32Field(value: [Int32], fieldNumber: Int) throws + + // Called for each non-packed repeated int64 field. + /// The method is called once with the complete array of values for + /// the field. + /// + /// A default implementation is provided that simply calls + /// `visitSingularInt64Field` once for each item in the array. + mutating func visitRepeatedInt64Field(value: [Int64], fieldNumber: Int) throws + + // Called for each non-packed repeated uint32 field. + /// The method is called once with the complete array of values for + /// the field. + /// + /// A default implementation is provided that simply calls + /// `visitSingularUInt32Field` once for each item in the array. + mutating func visitRepeatedUInt32Field(value: [UInt32], fieldNumber: Int) throws + + // Called for each non-packed repeated uint64 field. + /// The method is called once with the complete array of values for + /// the field. + /// + /// A default implementation is provided that simply calls + /// `visitSingularUInt64Field` once for each item in the array. + mutating func visitRepeatedUInt64Field(value: [UInt64], fieldNumber: Int) throws + + // Called for each non-packed repeated sint32 field. + /// The method is called once with the complete array of values for + /// the field. + /// + /// A default implementation is provided that simply calls + /// `visitSingularSInt32Field` once for each item in the array. + mutating func visitRepeatedSInt32Field(value: [Int32], fieldNumber: Int) throws + + // Called for each non-packed repeated sint64 field. + /// The method is called once with the complete array of values for + /// the field. + /// + /// A default implementation is provided that simply calls + /// `visitSingularSInt64Field` once for each item in the array. + mutating func visitRepeatedSInt64Field(value: [Int64], fieldNumber: Int) throws + + // Called for each non-packed repeated fixed32 field. + /// The method is called once with the complete array of values for + /// the field. + /// + /// A default implementation is provided that simply calls + /// `visitSingularFixed32Field` once for each item in the array. + mutating func visitRepeatedFixed32Field(value: [UInt32], fieldNumber: Int) throws + + // Called for each non-packed repeated fixed64 field. + /// The method is called once with the complete array of values for + /// the field. + /// + /// A default implementation is provided that simply calls + /// `visitSingularFixed64Field` once for each item in the array. + mutating func visitRepeatedFixed64Field(value: [UInt64], fieldNumber: Int) throws + + // Called for each non-packed repeated sfixed32 field. + /// The method is called once with the complete array of values for + /// the field. + /// + /// A default implementation is provided that simply calls + /// `visitSingularSFixed32Field` once for each item in the array. + mutating func visitRepeatedSFixed32Field(value: [Int32], fieldNumber: Int) throws + + // Called for each non-packed repeated sfixed64 field. + /// The method is called once with the complete array of values for + /// the field. + /// + /// A default implementation is provided that simply calls + /// `visitSingularSFixed64Field` once for each item in the array. + mutating func visitRepeatedSFixed64Field(value: [Int64], fieldNumber: Int) throws + + // Called for each non-packed repeated bool field. + /// The method is called once with the complete array of values for + /// the field. + /// + /// A default implementation is provided that simply calls + /// `visitSingularBoolField` once for each item in the array. + mutating func visitRepeatedBoolField(value: [Bool], fieldNumber: Int) throws + + // Called for each non-packed repeated string field. + /// The method is called once with the complete array of values for + /// the field. + /// + /// A default implementation is provided that simply calls + /// `visitSingularStringField` once for each item in the array. + mutating func visitRepeatedStringField(value: [String], fieldNumber: Int) throws + + // Called for each non-packed repeated bytes field. + /// The method is called once with the complete array of values for + /// the field. + /// + /// A default implementation is provided that simply calls + /// `visitSingularBytesField` once for each item in the array. + mutating func visitRepeatedBytesField(value: [Data], fieldNumber: Int) throws + + /// Called for each repeated, unpacked enum field. + /// The method is called once with the complete array of values for + /// the field. + /// + /// A default implementation is provided that simply calls + /// `visitSingularEnumField` once for each item in the array. + mutating func visitRepeatedEnumField(value: [E], fieldNumber: Int) throws + + /// Called for each repeated nested message field. The method is called once + /// with the complete array of values for the field. + /// + /// A default implementation is provided that simply calls + /// `visitSingularMessageField` once for each item in the array. + mutating func visitRepeatedMessageField( + value: [M], + fieldNumber: Int + ) throws + + /// Called for each repeated proto2 group field. + /// + /// A default implementation is provided that simply calls + /// `visitSingularGroupField` once for each item in the array. + mutating func visitRepeatedGroupField(value: [G], fieldNumber: Int) throws + + // Called for each packed, repeated float field. + /// + /// This is called once with the complete array of values for + /// the field. + /// + /// There is a default implementation that forwards to the non-packed + /// function. + mutating func visitPackedFloatField(value: [Float], fieldNumber: Int) throws + + // Called for each packed, repeated double field. + /// + /// This is called once with the complete array of values for + /// the field. + /// + /// There is a default implementation that forwards to the non-packed + /// function. + mutating func visitPackedDoubleField(value: [Double], fieldNumber: Int) throws + + // Called for each packed, repeated int32 field. + /// + /// This is called once with the complete array of values for + /// the field. + /// + /// There is a default implementation that forwards to the non-packed + /// function. + mutating func visitPackedInt32Field(value: [Int32], fieldNumber: Int) throws + + // Called for each packed, repeated int64 field. + /// + /// This is called once with the complete array of values for + /// the field. + /// + /// There is a default implementation that forwards to the non-packed + /// function. + mutating func visitPackedInt64Field(value: [Int64], fieldNumber: Int) throws + + // Called for each packed, repeated uint32 field. + /// + /// This is called once with the complete array of values for + /// the field. + /// + /// There is a default implementation that forwards to the non-packed + /// function. + mutating func visitPackedUInt32Field(value: [UInt32], fieldNumber: Int) throws + + // Called for each packed, repeated uint64 field. + /// + /// This is called once with the complete array of values for + /// the field. + /// + /// There is a default implementation that forwards to the non-packed + /// function. + mutating func visitPackedUInt64Field(value: [UInt64], fieldNumber: Int) throws + + // Called for each packed, repeated sint32 field. + /// + /// This is called once with the complete array of values for + /// the field. + /// + /// There is a default implementation that forwards to the non-packed + /// function. + mutating func visitPackedSInt32Field(value: [Int32], fieldNumber: Int) throws + + // Called for each packed, repeated sint64 field. + /// + /// This is called once with the complete array of values for + /// the field. + /// + /// There is a default implementation that forwards to the non-packed + /// function. + mutating func visitPackedSInt64Field(value: [Int64], fieldNumber: Int) throws + + // Called for each packed, repeated fixed32 field. + /// + /// This is called once with the complete array of values for + /// the field. + /// + /// There is a default implementation that forwards to the non-packed + /// function. + mutating func visitPackedFixed32Field(value: [UInt32], fieldNumber: Int) throws + + // Called for each packed, repeated fixed64 field. + /// + /// This is called once with the complete array of values for + /// the field. + /// + /// There is a default implementation that forwards to the non-packed + /// function. + mutating func visitPackedFixed64Field(value: [UInt64], fieldNumber: Int) throws + + // Called for each packed, repeated sfixed32 field. + /// + /// This is called once with the complete array of values for + /// the field. + /// + /// There is a default implementation that forwards to the non-packed + /// function. + mutating func visitPackedSFixed32Field(value: [Int32], fieldNumber: Int) throws + + // Called for each packed, repeated sfixed64 field. + /// + /// This is called once with the complete array of values for + /// the field. + /// + /// There is a default implementation that forwards to the non-packed + /// function. + mutating func visitPackedSFixed64Field(value: [Int64], fieldNumber: Int) throws + + // Called for each packed, repeated bool field. + /// + /// This is called once with the complete array of values for + /// the field. + /// + /// There is a default implementation that forwards to the non-packed + /// function. + mutating func visitPackedBoolField(value: [Bool], fieldNumber: Int) throws + + /// Called for each repeated, packed enum field. + /// The method is called once with the complete array of values for + /// the field. + /// + /// A default implementation is provided that simply forwards to + /// `visitRepeatedEnumField`. Implementors who need to handle packed fields + /// differently than unpacked fields can override this and provide distinct + /// implementations. + mutating func visitPackedEnumField(value: [E], fieldNumber: Int) throws + + /// Called for each map field with primitive values. The method is + /// called once with the complete dictionary of keys/values for the + /// field. + /// + /// There is no default implementation. This must be implemented. + mutating func visitMapField( + fieldType: _ProtobufMap.Type, + value: _ProtobufMap.BaseType, + fieldNumber: Int + ) throws + + /// Called for each map field with enum values. The method is called + /// once with the complete dictionary of keys/values for the field. + /// + /// There is no default implementation. This must be implemented. + mutating func visitMapField( + fieldType: _ProtobufEnumMap.Type, + value: _ProtobufEnumMap.BaseType, + fieldNumber: Int + ) throws where ValueType.RawValue == Int + + /// Called for each map field with message values. The method is + /// called once with the complete dictionary of keys/values for the + /// field. + /// + /// There is no default implementation. This must be implemented. + mutating func visitMapField( + fieldType: _ProtobufMessageMap.Type, + value: _ProtobufMessageMap.BaseType, + fieldNumber: Int + ) throws + + /// Called for each extension range. + mutating func visitExtensionFields(fields: ExtensionFieldValueSet, start: Int, end: Int) throws + + /// Called for each extension range. + mutating func visitExtensionFieldsAsMessageSet( + fields: ExtensionFieldValueSet, + start: Int, + end: Int + ) throws + + /// Called with the raw bytes that represent any unknown fields. + mutating func visitUnknown(bytes: Data) throws } /// Forwarding default implementations of some visitor methods, for convenience. extension Visitor { - // Default definitions of numeric serializations. - // - // The 32-bit versions widen and delegate to 64-bit versions. - // The specialized integer codings delegate to standard Int/UInt. - // - // These "just work" for Hash and Text formats. Most of these work - // for JSON (32-bit integers are overridden to suppress quoting), - // and a few even work for Protobuf Binary (thanks to varint coding - // which erases the size difference between 32-bit and 64-bit ints). - - public mutating func visitSingularFloatField(value: Float, fieldNumber: Int) throws { - try visitSingularDoubleField(value: Double(value), fieldNumber: fieldNumber) - } - public mutating func visitSingularInt32Field(value: Int32, fieldNumber: Int) throws { - try visitSingularInt64Field(value: Int64(value), fieldNumber: fieldNumber) - } - public mutating func visitSingularUInt32Field(value: UInt32, fieldNumber: Int) throws { - try visitSingularUInt64Field(value: UInt64(value), fieldNumber: fieldNumber) - } - public mutating func visitSingularSInt32Field(value: Int32, fieldNumber: Int) throws { - try visitSingularInt32Field(value: value, fieldNumber: fieldNumber) - } - public mutating func visitSingularSInt64Field(value: Int64, fieldNumber: Int) throws { - try visitSingularInt64Field(value: value, fieldNumber: fieldNumber) - } - public mutating func visitSingularFixed32Field(value: UInt32, fieldNumber: Int) throws { - try visitSingularUInt32Field(value: value, fieldNumber: fieldNumber) - } - public mutating func visitSingularFixed64Field(value: UInt64, fieldNumber: Int) throws { - try visitSingularUInt64Field(value: value, fieldNumber: fieldNumber) - } - public mutating func visitSingularSFixed32Field(value: Int32, fieldNumber: Int) throws { - try visitSingularInt32Field(value: value, fieldNumber: fieldNumber) - } - public mutating func visitSingularSFixed64Field(value: Int64, fieldNumber: Int) throws { - try visitSingularInt64Field(value: value, fieldNumber: fieldNumber) - } - - // Default definitions of repeated serializations that just iterate and - // invoke the singular encoding. These "just work" for Protobuf Binary (encoder - // and size visitor), Protobuf Text, and Hash visitors. JSON format stores - // repeated values differently from singular, so overrides these. - - public mutating func visitRepeatedFloatField(value: [Float], fieldNumber: Int) throws { - assert(!value.isEmpty) - for v in value { - try visitSingularFloatField(value: v, fieldNumber: fieldNumber) - } - } - - public mutating func visitRepeatedDoubleField(value: [Double], fieldNumber: Int) throws { - assert(!value.isEmpty) - for v in value { - try visitSingularDoubleField(value: v, fieldNumber: fieldNumber) - } - } - - public mutating func visitRepeatedInt32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - for v in value { - try visitSingularInt32Field(value: v, fieldNumber: fieldNumber) - } - } - - public mutating func visitRepeatedInt64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - for v in value { - try visitSingularInt64Field(value: v, fieldNumber: fieldNumber) - } - } - - public mutating func visitRepeatedUInt32Field(value: [UInt32], fieldNumber: Int) throws { - assert(!value.isEmpty) - for v in value { - try visitSingularUInt32Field(value: v, fieldNumber: fieldNumber) - } - } - - public mutating func visitRepeatedUInt64Field(value: [UInt64], fieldNumber: Int) throws { - assert(!value.isEmpty) - for v in value { - try visitSingularUInt64Field(value: v, fieldNumber: fieldNumber) - } - } - - public mutating func visitRepeatedSInt32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - for v in value { - try visitSingularSInt32Field(value: v, fieldNumber: fieldNumber) - } - } - - public mutating func visitRepeatedSInt64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - for v in value { - try visitSingularSInt64Field(value: v, fieldNumber: fieldNumber) - } - } - - public mutating func visitRepeatedFixed32Field(value: [UInt32], fieldNumber: Int) throws { - assert(!value.isEmpty) - for v in value { - try visitSingularFixed32Field(value: v, fieldNumber: fieldNumber) - } - } - - public mutating func visitRepeatedFixed64Field(value: [UInt64], fieldNumber: Int) throws { - assert(!value.isEmpty) - for v in value { - try visitSingularFixed64Field(value: v, fieldNumber: fieldNumber) - } - } - - public mutating func visitRepeatedSFixed32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - for v in value { - try visitSingularSFixed32Field(value: v, fieldNumber: fieldNumber) - } - } - - public mutating func visitRepeatedSFixed64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - for v in value { - try visitSingularSFixed64Field(value: v, fieldNumber: fieldNumber) - } - } - - public mutating func visitRepeatedBoolField(value: [Bool], fieldNumber: Int) throws { - assert(!value.isEmpty) - for v in value { - try visitSingularBoolField(value: v, fieldNumber: fieldNumber) - } - } - - public mutating func visitRepeatedStringField(value: [String], fieldNumber: Int) throws { - assert(!value.isEmpty) - for v in value { - try visitSingularStringField(value: v, fieldNumber: fieldNumber) - } - } - - public mutating func visitRepeatedBytesField(value: [Data], fieldNumber: Int) throws { - assert(!value.isEmpty) - for v in value { - try visitSingularBytesField(value: v, fieldNumber: fieldNumber) - } - } - - public mutating func visitRepeatedEnumField(value: [E], fieldNumber: Int) throws { - assert(!value.isEmpty) - for v in value { - try visitSingularEnumField(value: v, fieldNumber: fieldNumber) - } - } - - public mutating func visitRepeatedMessageField(value: [M], fieldNumber: Int) throws { - assert(!value.isEmpty) - for v in value { - try visitSingularMessageField(value: v, fieldNumber: fieldNumber) - } - } - - public mutating func visitRepeatedGroupField(value: [G], fieldNumber: Int) throws { - assert(!value.isEmpty) - for v in value { - try visitSingularGroupField(value: v, fieldNumber: fieldNumber) - } - } - - // Default definitions of packed serialization just defer to the - // repeated implementation. This works for Hash and JSON visitors - // (which do not distinguish packed vs. non-packed) but are - // overridden by Protobuf Binary and Text. - - public mutating func visitPackedFloatField(value: [Float], fieldNumber: Int) throws { - assert(!value.isEmpty) - try visitRepeatedFloatField(value: value, fieldNumber: fieldNumber) - } - - public mutating func visitPackedDoubleField(value: [Double], fieldNumber: Int) throws { - assert(!value.isEmpty) - try visitRepeatedDoubleField(value: value, fieldNumber: fieldNumber) - } - - public mutating func visitPackedInt32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - try visitRepeatedInt32Field(value: value, fieldNumber: fieldNumber) - } - - public mutating func visitPackedInt64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - try visitRepeatedInt64Field(value: value, fieldNumber: fieldNumber) - } - - public mutating func visitPackedUInt32Field(value: [UInt32], fieldNumber: Int) throws { - assert(!value.isEmpty) - try visitRepeatedUInt32Field(value: value, fieldNumber: fieldNumber) - } - - public mutating func visitPackedUInt64Field(value: [UInt64], fieldNumber: Int) throws { - assert(!value.isEmpty) - try visitRepeatedUInt64Field(value: value, fieldNumber: fieldNumber) - } - - public mutating func visitPackedSInt32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - try visitPackedInt32Field(value: value, fieldNumber: fieldNumber) - } - - public mutating func visitPackedSInt64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - try visitPackedInt64Field(value: value, fieldNumber: fieldNumber) - } - - public mutating func visitPackedFixed32Field(value: [UInt32], fieldNumber: Int) throws { - assert(!value.isEmpty) - try visitPackedUInt32Field(value: value, fieldNumber: fieldNumber) - } - - public mutating func visitPackedFixed64Field(value: [UInt64], fieldNumber: Int) throws { - assert(!value.isEmpty) - try visitPackedUInt64Field(value: value, fieldNumber: fieldNumber) - } - - public mutating func visitPackedSFixed32Field(value: [Int32], fieldNumber: Int) throws { - assert(!value.isEmpty) - try visitPackedInt32Field(value: value, fieldNumber: fieldNumber) - } - - public mutating func visitPackedSFixed64Field(value: [Int64], fieldNumber: Int) throws { - assert(!value.isEmpty) - try visitPackedInt64Field(value: value, fieldNumber: fieldNumber) - } - - public mutating func visitPackedBoolField(value: [Bool], fieldNumber: Int) throws { - assert(!value.isEmpty) - try visitRepeatedBoolField(value: value, fieldNumber: fieldNumber) - } - - public mutating func visitPackedEnumField(value: [E], - fieldNumber: Int) throws { - assert(!value.isEmpty) - try visitRepeatedEnumField(value: value, fieldNumber: fieldNumber) - } - - // Default handling for Groups is to treat them just like messages. - // This works for Text and Hash, but is overridden by Protobuf Binary - // format (which has a different encoding for groups) and JSON - // (which explicitly ignores all groups). - - public mutating func visitSingularGroupField(value: G, - fieldNumber: Int) throws { - try visitSingularMessageField(value: value, fieldNumber: fieldNumber) - } - - // Default handling of Extensions as a MessageSet to handing them just - // as plain extensions. Formats that what custom behavior can override - // it. - - public mutating func visitExtensionFieldsAsMessageSet( - fields: ExtensionFieldValueSet, - start: Int, - end: Int) throws { - try visitExtensionFields(fields: fields, start: start, end: end) - } - - // Default handling for Extensions is to forward the traverse to - // the ExtensionFieldValueSet. Formats that don't care about extensions - // can override to avoid it. - - /// Called for each extension range. - public mutating func visitExtensionFields(fields: ExtensionFieldValueSet, start: Int, end: Int) throws { - try fields.traverse(visitor: &self, start: start, end: end) - } + // Default definitions of numeric serializations. + // + // The 32-bit versions widen and delegate to 64-bit versions. + // The specialized integer codings delegate to standard Int/UInt. + // + // These "just work" for Hash and Text formats. Most of these work + // for JSON (32-bit integers are overridden to suppress quoting), + // and a few even work for Protobuf Binary (thanks to varint coding + // which erases the size difference between 32-bit and 64-bit ints). + + public mutating func visitSingularFloatField(value: Float, fieldNumber: Int) throws { + try visitSingularDoubleField(value: Double(value), fieldNumber: fieldNumber) + } + public mutating func visitSingularInt32Field(value: Int32, fieldNumber: Int) throws { + try visitSingularInt64Field(value: Int64(value), fieldNumber: fieldNumber) + } + public mutating func visitSingularUInt32Field(value: UInt32, fieldNumber: Int) throws { + try visitSingularUInt64Field(value: UInt64(value), fieldNumber: fieldNumber) + } + public mutating func visitSingularSInt32Field(value: Int32, fieldNumber: Int) throws { + try visitSingularInt32Field(value: value, fieldNumber: fieldNumber) + } + public mutating func visitSingularSInt64Field(value: Int64, fieldNumber: Int) throws { + try visitSingularInt64Field(value: value, fieldNumber: fieldNumber) + } + public mutating func visitSingularFixed32Field(value: UInt32, fieldNumber: Int) throws { + try visitSingularUInt32Field(value: value, fieldNumber: fieldNumber) + } + public mutating func visitSingularFixed64Field(value: UInt64, fieldNumber: Int) throws { + try visitSingularUInt64Field(value: value, fieldNumber: fieldNumber) + } + public mutating func visitSingularSFixed32Field(value: Int32, fieldNumber: Int) throws { + try visitSingularInt32Field(value: value, fieldNumber: fieldNumber) + } + public mutating func visitSingularSFixed64Field(value: Int64, fieldNumber: Int) throws { + try visitSingularInt64Field(value: value, fieldNumber: fieldNumber) + } + + // Default definitions of repeated serializations that just iterate and + // invoke the singular encoding. These "just work" for Protobuf Binary (encoder + // and size visitor), Protobuf Text, and Hash visitors. JSON format stores + // repeated values differently from singular, so overrides these. + + public mutating func visitRepeatedFloatField(value: [Float], fieldNumber: Int) throws { + assert(!value.isEmpty) + for v in value { + try visitSingularFloatField(value: v, fieldNumber: fieldNumber) + } + } + + public mutating func visitRepeatedDoubleField(value: [Double], fieldNumber: Int) throws { + assert(!value.isEmpty) + for v in value { + try visitSingularDoubleField(value: v, fieldNumber: fieldNumber) + } + } + + public mutating func visitRepeatedInt32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + for v in value { + try visitSingularInt32Field(value: v, fieldNumber: fieldNumber) + } + } + + public mutating func visitRepeatedInt64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + for v in value { + try visitSingularInt64Field(value: v, fieldNumber: fieldNumber) + } + } + + public mutating func visitRepeatedUInt32Field(value: [UInt32], fieldNumber: Int) throws { + assert(!value.isEmpty) + for v in value { + try visitSingularUInt32Field(value: v, fieldNumber: fieldNumber) + } + } + + public mutating func visitRepeatedUInt64Field(value: [UInt64], fieldNumber: Int) throws { + assert(!value.isEmpty) + for v in value { + try visitSingularUInt64Field(value: v, fieldNumber: fieldNumber) + } + } + + public mutating func visitRepeatedSInt32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + for v in value { + try visitSingularSInt32Field(value: v, fieldNumber: fieldNumber) + } + } + + public mutating func visitRepeatedSInt64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + for v in value { + try visitSingularSInt64Field(value: v, fieldNumber: fieldNumber) + } + } + + public mutating func visitRepeatedFixed32Field(value: [UInt32], fieldNumber: Int) throws { + assert(!value.isEmpty) + for v in value { + try visitSingularFixed32Field(value: v, fieldNumber: fieldNumber) + } + } + + public mutating func visitRepeatedFixed64Field(value: [UInt64], fieldNumber: Int) throws { + assert(!value.isEmpty) + for v in value { + try visitSingularFixed64Field(value: v, fieldNumber: fieldNumber) + } + } + + public mutating func visitRepeatedSFixed32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + for v in value { + try visitSingularSFixed32Field(value: v, fieldNumber: fieldNumber) + } + } + + public mutating func visitRepeatedSFixed64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + for v in value { + try visitSingularSFixed64Field(value: v, fieldNumber: fieldNumber) + } + } + + public mutating func visitRepeatedBoolField(value: [Bool], fieldNumber: Int) throws { + assert(!value.isEmpty) + for v in value { + try visitSingularBoolField(value: v, fieldNumber: fieldNumber) + } + } + + public mutating func visitRepeatedStringField(value: [String], fieldNumber: Int) throws { + assert(!value.isEmpty) + for v in value { + try visitSingularStringField(value: v, fieldNumber: fieldNumber) + } + } + + public mutating func visitRepeatedBytesField(value: [Data], fieldNumber: Int) throws { + assert(!value.isEmpty) + for v in value { + try visitSingularBytesField(value: v, fieldNumber: fieldNumber) + } + } + + public mutating func visitRepeatedEnumField(value: [E], fieldNumber: Int) throws { + assert(!value.isEmpty) + for v in value { + try visitSingularEnumField(value: v, fieldNumber: fieldNumber) + } + } + + public mutating func visitRepeatedMessageField(value: [M], fieldNumber: Int) throws { + assert(!value.isEmpty) + for v in value { + try visitSingularMessageField(value: v, fieldNumber: fieldNumber) + } + } + + public mutating func visitRepeatedGroupField(value: [G], fieldNumber: Int) throws { + assert(!value.isEmpty) + for v in value { + try visitSingularGroupField(value: v, fieldNumber: fieldNumber) + } + } + + // Default definitions of packed serialization just defer to the + // repeated implementation. This works for Hash and JSON visitors + // (which do not distinguish packed vs. non-packed) but are + // overridden by Protobuf Binary and Text. + + public mutating func visitPackedFloatField(value: [Float], fieldNumber: Int) throws { + assert(!value.isEmpty) + try visitRepeatedFloatField(value: value, fieldNumber: fieldNumber) + } + + public mutating func visitPackedDoubleField(value: [Double], fieldNumber: Int) throws { + assert(!value.isEmpty) + try visitRepeatedDoubleField(value: value, fieldNumber: fieldNumber) + } + + public mutating func visitPackedInt32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + try visitRepeatedInt32Field(value: value, fieldNumber: fieldNumber) + } + + public mutating func visitPackedInt64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + try visitRepeatedInt64Field(value: value, fieldNumber: fieldNumber) + } + + public mutating func visitPackedUInt32Field(value: [UInt32], fieldNumber: Int) throws { + assert(!value.isEmpty) + try visitRepeatedUInt32Field(value: value, fieldNumber: fieldNumber) + } + + public mutating func visitPackedUInt64Field(value: [UInt64], fieldNumber: Int) throws { + assert(!value.isEmpty) + try visitRepeatedUInt64Field(value: value, fieldNumber: fieldNumber) + } + + public mutating func visitPackedSInt32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + try visitPackedInt32Field(value: value, fieldNumber: fieldNumber) + } + + public mutating func visitPackedSInt64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + try visitPackedInt64Field(value: value, fieldNumber: fieldNumber) + } + + public mutating func visitPackedFixed32Field(value: [UInt32], fieldNumber: Int) throws { + assert(!value.isEmpty) + try visitPackedUInt32Field(value: value, fieldNumber: fieldNumber) + } + + public mutating func visitPackedFixed64Field(value: [UInt64], fieldNumber: Int) throws { + assert(!value.isEmpty) + try visitPackedUInt64Field(value: value, fieldNumber: fieldNumber) + } + + public mutating func visitPackedSFixed32Field(value: [Int32], fieldNumber: Int) throws { + assert(!value.isEmpty) + try visitPackedInt32Field(value: value, fieldNumber: fieldNumber) + } + + public mutating func visitPackedSFixed64Field(value: [Int64], fieldNumber: Int) throws { + assert(!value.isEmpty) + try visitPackedInt64Field(value: value, fieldNumber: fieldNumber) + } + + public mutating func visitPackedBoolField(value: [Bool], fieldNumber: Int) throws { + assert(!value.isEmpty) + try visitRepeatedBoolField(value: value, fieldNumber: fieldNumber) + } + + public mutating func visitPackedEnumField( + value: [E], + fieldNumber: Int + ) throws { + assert(!value.isEmpty) + try visitRepeatedEnumField(value: value, fieldNumber: fieldNumber) + } + + // Default handling for Groups is to treat them just like messages. + // This works for Text and Hash, but is overridden by Protobuf Binary + // format (which has a different encoding for groups) and JSON + // (which explicitly ignores all groups). + + public mutating func visitSingularGroupField( + value: G, + fieldNumber: Int + ) throws { + try visitSingularMessageField(value: value, fieldNumber: fieldNumber) + } + + // Default handling of Extensions as a MessageSet to handing them just + // as plain extensions. Formats that what custom behavior can override + // it. + + public mutating func visitExtensionFieldsAsMessageSet( + fields: ExtensionFieldValueSet, + start: Int, + end: Int + ) throws { + try visitExtensionFields(fields: fields, start: start, end: end) + } + + // Default handling for Extensions is to forward the traverse to + // the ExtensionFieldValueSet. Formats that don't care about extensions + // can override to avoid it. + + /// Called for each extension range. + public mutating func visitExtensionFields(fields: ExtensionFieldValueSet, start: Int, end: Int) throws { + try fields.traverse(visitor: &self, start: start, end: end) + } } diff --git a/Sources/SwiftProtobuf/WireFormat.swift b/Sources/SwiftProtobuf/WireFormat.swift index d1e67ac4b..5b3af0928 100644 --- a/Sources/SwiftProtobuf/WireFormat.swift +++ b/Sources/SwiftProtobuf/WireFormat.swift @@ -13,58 +13,56 @@ // ----------------------------------------------------------------------------- /// Denotes the wire format by which a value is encoded in binary form. -internal enum WireFormat: UInt8 { - case varint = 0 - case fixed64 = 1 - case lengthDelimited = 2 - case startGroup = 3 - case endGroup = 4 - case fixed32 = 5 +package enum WireFormat: UInt8 { + case varint = 0 + case fixed64 = 1 + case lengthDelimited = 2 + case startGroup = 3 + case endGroup = 4 + case fixed32 = 5 } extension WireFormat { - /// Information about the "MessageSet" format. Used when a Message has - /// the message_set_wire_format option enabled. - /// - /// Writing in MessageSet form means instead of writing the Extesions - /// normally as a simple fields, each gets written wrapped in a group: - /// repeated group Item = 1 { - /// required int32 type_id = 2; - /// required bytes message = 3; - /// } - /// Where the field number is the type_id, and the message is serilaized - /// into the bytes. - /// - /// The handling of unknown fields is ill defined. In proto1, they were - /// dropped. In the C++ for proto2, since it stores them in the unknowns - /// storage, if preserves any that are length delimited data (since that's - /// how the message also goes out). While the C++ is parsing, where the - /// unknowns fall in the flow of the group, sorta decides what happens. - /// Since it is ill defined, currently SwiftProtobuf will reflect out - /// anything set in the unknownStorage. During parsing, unknowns on the - /// message are preserved, but unknowns within the group are dropped (like - /// map items). Any extension in the MessageSet that isn't in the Regisry - /// being used at parse time will remain in a group and go into the - /// Messages's unknown fields (this way it reflects back out correctly). - internal enum MessageSet { + /// Information about the "MessageSet" format. Used when a Message has + /// the message_set_wire_format option enabled. + /// + /// Writing in MessageSet form means instead of writing the Extesions + /// normally as a simple fields, each gets written wrapped in a group: + /// repeated group Item = 1 { + /// required int32 type_id = 2; + /// required bytes message = 3; + /// } + /// Where the field number is the type_id, and the message is serilaized + /// into the bytes. + /// + /// The handling of unknown fields is ill defined. In proto1, they were + /// dropped. In the C++ for proto2, since it stores them in the unknowns + /// storage, if preserves any that are length delimited data (since that's + /// how the message also goes out). While the C++ is parsing, where the + /// unknowns fall in the flow of the group, sorta decides what happens. + /// Since it is ill defined, currently SwiftProtobuf will reflect out + /// anything set in the unknownStorage. During parsing, unknowns on the + /// message are preserved, but unknowns within the group are dropped (like + /// map items). Any extension in the MessageSet that isn't in the Regisry + /// being used at parse time will remain in a group and go into the + /// Messages's unknown fields (this way it reflects back out correctly). + internal enum MessageSet { - enum FieldNumbers { - static let item = 1; - static let typeId = 2; - static let message = 3; - } + enum FieldNumbers { + static let item = 1 + static let typeId = 2 + static let message = 3 + } - enum Tags { - static let itemStart = FieldTag(fieldNumber: FieldNumbers.item, wireFormat: .startGroup) - static let itemEnd = FieldTag(fieldNumber: FieldNumbers.item, wireFormat: .endGroup) - static let typeId = FieldTag(fieldNumber: FieldNumbers.typeId, wireFormat: .varint) - static let message = FieldTag(fieldNumber: FieldNumbers.message, wireFormat: .lengthDelimited) - } + enum Tags { + static let itemStart = FieldTag(fieldNumber: FieldNumbers.item, wireFormat: .startGroup) + static let itemEnd = FieldTag(fieldNumber: FieldNumbers.item, wireFormat: .endGroup) + static let typeId = FieldTag(fieldNumber: FieldNumbers.typeId, wireFormat: .varint) + static let message = FieldTag(fieldNumber: FieldNumbers.message, wireFormat: .lengthDelimited) + } - // The size of all the tags needed to write out an Extension in MessageSet format. - static let itemTagsEncodedSize = - Tags.itemStart.encodedSize + Tags.itemEnd.encodedSize + - Tags.typeId.encodedSize + - Tags.message.encodedSize - } + // The size of all the tags needed to write out an Extension in MessageSet format. + static let itemTagsEncodedSize = + Tags.itemStart.encodedSize + Tags.itemEnd.encodedSize + Tags.typeId.encodedSize + Tags.message.encodedSize + } } diff --git a/Sources/SwiftProtobuf/ZigZag.swift b/Sources/SwiftProtobuf/ZigZag.swift index e5a534bb3..93c30c4d6 100644 --- a/Sources/SwiftProtobuf/ZigZag.swift +++ b/Sources/SwiftProtobuf/ZigZag.swift @@ -12,7 +12,6 @@ /// // ----------------------------------------------------------------------------- - /// Contains helper methods to ZigZag encode and decode signed integers. internal enum ZigZag { @@ -25,7 +24,7 @@ internal enum ZigZag { /// - Parameter value: A signed 32-bit integer. /// - Returns: An unsigned 32-bit integer representing the ZigZag-encoded value. static func encoded(_ value: Int32) -> UInt32 { - return UInt32(bitPattern: (value << 1) ^ (value >> 31)) + UInt32(bitPattern: (value << 1) ^ (value >> 31)) } /// Return a 64-bit ZigZag-encoded value. @@ -37,7 +36,7 @@ internal enum ZigZag { /// - Parameter value: A signed 64-bit integer. /// - Returns: An unsigned 64-bit integer representing the ZigZag-encoded value. static func encoded(_ value: Int64) -> UInt64 { - return UInt64(bitPattern: (value << 1) ^ (value >> 63)) + UInt64(bitPattern: (value << 1) ^ (value >> 63)) } /// Return a 32-bit ZigZag-decoded value. @@ -49,7 +48,7 @@ internal enum ZigZag { /// - Parameter value: An unsigned 32-bit ZagZag-encoded integer. /// - Returns: The signed 32-bit decoded value. static func decoded(_ value: UInt32) -> Int32 { - return Int32(value >> 1) ^ -Int32(value & 1) + Int32(value >> 1) ^ -Int32(value & 1) } /// Return a 64-bit ZigZag-decoded value. @@ -61,6 +60,6 @@ internal enum ZigZag { /// - Parameter value: An unsigned 64-bit ZigZag-encoded integer. /// - Returns: The signed 64-bit decoded value. static func decoded(_ value: UInt64) -> Int64 { - return Int64(value >> 1) ^ -Int64(value & 1) + Int64(value >> 1) ^ -Int64(value & 1) } } diff --git a/Sources/SwiftProtobuf/any.pb.swift b/Sources/SwiftProtobuf/any.pb.swift index 0c840f888..c0983d969 100644 --- a/Sources/SwiftProtobuf/any.pb.swift +++ b/Sources/SwiftProtobuf/any.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/any.proto @@ -38,14 +39,15 @@ // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } @@ -73,6 +75,10 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// if (any.is(Foo.class)) { /// foo = any.unpack(Foo.class); /// } +/// // or ... +/// if (any.isSameTypeAs(Foo.getDefaultInstance())) { +/// foo = any.unpack(Foo.getDefaultInstance()); +/// } /// /// Example 3: Pack and unpack a message in Python. /// @@ -103,7 +109,6 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// in the type URL, for example "foo.bar.com/x/y.z" will yield type /// name "y.z". /// -/// /// JSON /// ==== /// The JSON representation of an `Any` value uses the regular @@ -131,7 +136,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// "@type": "type.googleapis.com/google.protobuf.Duration", /// "value": "1.212s" /// } -public struct Google_Protobuf_Any { +public struct Google_Protobuf_Any: @unchecked Sendable { // 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. @@ -159,42 +164,36 @@ public struct Google_Protobuf_Any { /// /// Note: this functionality is not currently available in the official /// protobuf release, and it is not used for type URLs beginning with - /// type.googleapis.com. + /// type.googleapis.com. As of May 2023, there are no widely used type server + /// implementations and no plans to implement one. /// /// Schemes other than `http`, `https` (or the empty scheme) might be /// used with implementation specific semantics. public var typeURL: String { - get {return _storage._typeURL} + get {_storage._typeURL} set {_uniqueStorage()._typeURL = newValue} } /// Must be a valid serialized protocol buffer of the above specified type. public var value: Data { - get {return _storage._value} + get {_storage._value} set {_uniqueStorage()._value = newValue} } - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} internal var _storage = _StorageClass.defaultInstance } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_Any: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_Any: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Any: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".Any" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "type_url"), - 2: .same(proto: "value"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}type_url\0\u{1}value\0") typealias _StorageClass = AnyMessageStorage @@ -205,7 +204,7 @@ extension Google_Protobuf_Any: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl return _storage } - public mutating func decodeMessage(decoder: inout D) throws { + public mutating func decodeMessage(decoder: inout D) throws { _ = _uniqueStorage() try withExtendedLifetime(_storage) { (_storage: _StorageClass) in while let fieldNumber = try decoder.nextFieldNumber() { @@ -221,7 +220,7 @@ extension Google_Protobuf_Any: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { try withExtendedLifetime(_storage) { (_storage: _StorageClass) in try _storage.preTraverse() if !_storage._typeURL.isEmpty { diff --git a/Sources/SwiftProtobuf/api.pb.swift b/Sources/SwiftProtobuf/api.pb.swift index 619d39c39..a31385567 100644 --- a/Sources/SwiftProtobuf/api.pb.swift +++ b/Sources/SwiftProtobuf/api.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/api.proto @@ -37,15 +38,15 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } @@ -58,7 +59,12 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// sometimes simply referred to as "APIs" in other contexts, such as the name of /// this message itself. See https://cloud.google.com/apis/design/glossary for /// detailed terminology. -public struct Google_Protobuf_Api { +/// +/// New usages of this message as an alternative to ServiceDescriptorProto are +/// strongly discouraged. This message does not reliability preserve all +/// information necessary to model the schema and preserve semantics. Instead +/// make use of FileDescriptorSet which preserves the necessary information. +public struct Google_Protobuf_Api: Sendable { // 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. @@ -97,11 +103,11 @@ public struct Google_Protobuf_Api { /// Source context for the protocol buffer service represented by this /// message. public var sourceContext: Google_Protobuf_SourceContext { - get {return _sourceContext ?? Google_Protobuf_SourceContext()} + get {_sourceContext ?? Google_Protobuf_SourceContext()} set {_sourceContext = newValue} } /// Returns true if `sourceContext` has been explicitly set. - public var hasSourceContext: Bool {return self._sourceContext != nil} + public var hasSourceContext: Bool {self._sourceContext != nil} /// Clears the value of `sourceContext`. Subsequent reads from it will return its default value. public mutating func clearSourceContext() {self._sourceContext = nil} @@ -111,7 +117,10 @@ public struct Google_Protobuf_Api { /// The source syntax of the service. public var syntax: Google_Protobuf_Syntax = .proto2 - public var unknownFields = SwiftProtobuf.UnknownStorage() + /// The source edition string, only valid when syntax is SYNTAX_EDITIONS. + public var edition: String = String() + + public var unknownFields = UnknownStorage() public init() {} @@ -119,7 +128,12 @@ public struct Google_Protobuf_Api { } /// Method represents a method of an API interface. -public struct Google_Protobuf_Method { +/// +/// New usages of this message as an alternative to MethodDescriptorProto are +/// strongly discouraged. This message does not reliability preserve all +/// information necessary to model the schema and preserve semantics. Instead +/// make use of FileDescriptorSet which preserves the necessary information. +public struct Google_Protobuf_Method: Sendable { // 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. @@ -143,9 +157,22 @@ public struct Google_Protobuf_Method { public var options: [Google_Protobuf_Option] = [] /// The source syntax of this method. + /// + /// This field should be ignored, instead the syntax should be inherited from + /// Api. This is similar to Field and EnumValue. + /// + /// NOTE: This field was marked as deprecated in the .proto file. public var syntax: Google_Protobuf_Syntax = .proto2 - public var unknownFields = SwiftProtobuf.UnknownStorage() + /// The source edition string, only valid when syntax is SYNTAX_EDITIONS. + /// + /// This field should be ignored, instead the edition should be inherited from + /// Api. This is similar to Field and EnumValue. + /// + /// NOTE: This field was marked as deprecated in the .proto file. + public var edition: String = String() + + public var unknownFields = UnknownStorage() public init() {} } @@ -228,7 +255,7 @@ public struct Google_Protobuf_Method { /// } /// ... /// } -public struct Google_Protobuf_Mixin { +public struct Google_Protobuf_Mixin: Sendable { // 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. @@ -240,34 +267,20 @@ public struct Google_Protobuf_Mixin { /// are rooted. public var root: String = String() - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_Api: @unchecked Sendable {} -extension Google_Protobuf_Method: @unchecked Sendable {} -extension Google_Protobuf_Mixin: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_Api: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Api: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".Api" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "methods"), - 3: .same(proto: "options"), - 4: .same(proto: "version"), - 5: .standard(proto: "source_context"), - 6: .same(proto: "mixins"), - 7: .same(proto: "syntax"), - ] - - public mutating func decodeMessage(decoder: inout D) throws { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}methods\0\u{1}options\0\u{1}version\0\u{3}source_context\0\u{1}mixins\0\u{1}syntax\0\u{1}edition\0") + + public 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 @@ -280,12 +293,13 @@ extension Google_Protobuf_Api: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl case 5: try { try decoder.decodeSingularMessageField(value: &self._sourceContext) }() case 6: try { try decoder.decodeRepeatedMessageField(value: &self.mixins) }() case 7: try { try decoder.decodeSingularEnumField(value: &self.syntax) }() + case 8: try { try decoder.decodeSingularStringField(value: &self.edition) }() default: break } } } - public func traverse(visitor: inout V) throws { + public 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 @@ -311,6 +325,9 @@ extension Google_Protobuf_Api: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl if self.syntax != .proto2 { try visitor.visitSingularEnumField(value: self.syntax, fieldNumber: 7) } + if !self.edition.isEmpty { + try visitor.visitSingularStringField(value: self.edition, fieldNumber: 8) + } try unknownFields.traverse(visitor: &visitor) } @@ -322,24 +339,17 @@ extension Google_Protobuf_Api: SwiftProtobuf.Message, SwiftProtobuf._MessageImpl if lhs._sourceContext != rhs._sourceContext {return false} if lhs.mixins != rhs.mixins {return false} if lhs.syntax != rhs.syntax {return false} + if lhs.edition != rhs.edition {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_Method: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Method: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".Method" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .standard(proto: "request_type_url"), - 3: .standard(proto: "request_streaming"), - 4: .standard(proto: "response_type_url"), - 5: .standard(proto: "response_streaming"), - 6: .same(proto: "options"), - 7: .same(proto: "syntax"), - ] - - public mutating func decodeMessage(decoder: inout D) throws { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{3}request_type_url\0\u{3}request_streaming\0\u{3}response_type_url\0\u{3}response_streaming\0\u{1}options\0\u{1}syntax\0\u{1}edition\0") + + public 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 @@ -352,12 +362,13 @@ extension Google_Protobuf_Method: SwiftProtobuf.Message, SwiftProtobuf._MessageI case 5: try { try decoder.decodeSingularBoolField(value: &self.responseStreaming) }() case 6: try { try decoder.decodeRepeatedMessageField(value: &self.options) }() case 7: try { try decoder.decodeSingularEnumField(value: &self.syntax) }() + case 8: try { try decoder.decodeSingularStringField(value: &self.edition) }() default: break } } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if !self.name.isEmpty { try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) } @@ -379,6 +390,9 @@ extension Google_Protobuf_Method: SwiftProtobuf.Message, SwiftProtobuf._MessageI if self.syntax != .proto2 { try visitor.visitSingularEnumField(value: self.syntax, fieldNumber: 7) } + if !self.edition.isEmpty { + try visitor.visitSingularStringField(value: self.edition, fieldNumber: 8) + } try unknownFields.traverse(visitor: &visitor) } @@ -390,19 +404,17 @@ extension Google_Protobuf_Method: SwiftProtobuf.Message, SwiftProtobuf._MessageI if lhs.responseStreaming != rhs.responseStreaming {return false} if lhs.options != rhs.options {return false} if lhs.syntax != rhs.syntax {return false} + if lhs.edition != rhs.edition {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_Mixin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Mixin: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".Mixin" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "root"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}root\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -415,7 +427,7 @@ extension Google_Protobuf_Mixin: SwiftProtobuf.Message, SwiftProtobuf._MessageIm } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if !self.name.isEmpty { try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) } diff --git a/Sources/SwiftProtobuf/descriptor.pb.swift b/Sources/SwiftProtobuf/descriptor.pb.swift index b2c1ddb89..f7a1e7ec1 100644 --- a/Sources/SwiftProtobuf/descriptor.pb.swift +++ b/Sources/SwiftProtobuf/descriptor.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/descriptor.proto @@ -46,54 +47,118 @@ // without any other information (e.g. without reading its imports). import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } +/// The full set of known editions. +public enum Google_Protobuf_Edition: Int, Enum, Swift.CaseIterable { + + /// A placeholder for an unknown edition value. + case unknown = 0 + + /// A placeholder edition for specifying default behaviors *before* a feature + /// was first introduced. This is effectively an "infinite past". + case legacy = 900 + + /// Legacy syntax "editions". These pre-date editions, but behave much like + /// distinct editions. These can't be used to specify the edition of proto + /// files, but feature definitions must supply proto2/proto3 defaults for + /// backwards compatibility. + case proto2 = 998 + case proto3 = 999 + + /// Editions that have been released. The specific values are arbitrary and + /// should not be depended on, but they will always be time-ordered for easy + /// comparison. + case edition2023 = 1000 + case edition2024 = 1001 + + /// A placeholder edition for developing and testing unscheduled features. + case unstable = 9999 + + /// Placeholder editions for testing feature resolution. These should not be + /// used or relied on outside of tests. + case edition1TestOnly = 1 + case edition2TestOnly = 2 + case edition99997TestOnly = 99997 + case edition99998TestOnly = 99998 + case edition99999TestOnly = 99999 + + /// Placeholder for specifying unbounded edition support. This should only + /// ever be used by plugins that can expect to never require any changes to + /// support a new edition. + case max = 2147483647 + + public init() { + self = .unknown + } + +} + +/// Describes the 'visibility' of a symbol with respect to the proto import +/// system. Symbols can only be imported when the visibility rules do not prevent +/// it (ex: local symbols cannot be imported). Visibility modifiers can only set +/// on `message` and `enum` as they are the only types available to be referenced +/// from other files. +public enum Google_Protobuf_SymbolVisibility: Int, Enum, Swift.CaseIterable { + case visibilityUnset = 0 + case visibilityLocal = 1 + case visibilityExport = 2 + + public init() { + self = .visibilityUnset + } + +} + /// The protocol compiler can output a FileDescriptorSet containing the .proto /// files it parses. -public struct Google_Protobuf_FileDescriptorSet { +public struct Google_Protobuf_FileDescriptorSet: ExtensibleMessage, Sendable { // 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. public var file: [Google_Protobuf_FileDescriptorProto] = [] - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} + + public var _protobuf_extensionFieldValues = ExtensionFieldValueSet() } /// Describes a complete .proto file. -public struct Google_Protobuf_FileDescriptorProto { +public struct Google_Protobuf_FileDescriptorProto: Sendable { // 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. /// file name, relative to root of source tree public var name: String { - get {return _name ?? String()} + get {_name ?? String()} set {_name = newValue} } /// Returns true if `name` has been explicitly set. - public var hasName: Bool {return self._name != nil} + public var hasName: Bool {self._name != nil} /// Clears the value of `name`. Subsequent reads from it will return its default value. public mutating func clearName() {self._name = nil} /// e.g. "foo", "foo.bar", etc. public var package: String { - get {return _package ?? String()} + get {_package ?? String()} set {_package = newValue} } /// Returns true if `package` has been explicitly set. - public var hasPackage: Bool {return self._package != nil} + public var hasPackage: Bool {self._package != nil} /// Clears the value of `package`. Subsequent reads from it will return its default value. public mutating func clearPackage() {self._package = nil} @@ -107,6 +172,10 @@ public struct Google_Protobuf_FileDescriptorProto { /// For Google-internal migration only. Do not use. public var weakDependency: [Int32] = [] + /// Names of files imported by this file purely for the purpose of providing + /// option extensions. These are excluded from the dependency list above. + public var optionDependency: [String] = [] + /// All top-level definitions in this file. public var messageType: [Google_Protobuf_DescriptorProto] = [] @@ -117,11 +186,11 @@ public struct Google_Protobuf_FileDescriptorProto { public var `extension`: [Google_Protobuf_FieldDescriptorProto] = [] public var options: Google_Protobuf_FileOptions { - get {return _options ?? Google_Protobuf_FileOptions()} + get {_options ?? Google_Protobuf_FileOptions()} set {_options = newValue} } /// Returns true if `options` has been explicitly set. - public var hasOptions: Bool {return self._options != nil} + public var hasOptions: Bool {self._options != nil} /// Clears the value of `options`. Subsequent reads from it will return its default value. public mutating func clearOptions() {self._options = nil} @@ -130,26 +199,44 @@ public struct Google_Protobuf_FileDescriptorProto { /// functionality of the descriptors -- the information is needed only by /// development tools. public var sourceCodeInfo: Google_Protobuf_SourceCodeInfo { - get {return _sourceCodeInfo ?? Google_Protobuf_SourceCodeInfo()} + get {_sourceCodeInfo ?? Google_Protobuf_SourceCodeInfo()} set {_sourceCodeInfo = newValue} } /// Returns true if `sourceCodeInfo` has been explicitly set. - public var hasSourceCodeInfo: Bool {return self._sourceCodeInfo != nil} + public var hasSourceCodeInfo: Bool {self._sourceCodeInfo != nil} /// Clears the value of `sourceCodeInfo`. Subsequent reads from it will return its default value. public mutating func clearSourceCodeInfo() {self._sourceCodeInfo = nil} /// The syntax of the proto file. - /// The supported values are "proto2" and "proto3". + /// The supported values are "proto2", "proto3", and "editions". + /// + /// If `edition` is present, this value must be "editions". + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. public var syntax: String { - get {return _syntax ?? String()} + get {_syntax ?? String()} set {_syntax = newValue} } /// Returns true if `syntax` has been explicitly set. - public var hasSyntax: Bool {return self._syntax != nil} + public var hasSyntax: Bool {self._syntax != nil} /// Clears the value of `syntax`. Subsequent reads from it will return its default value. public mutating func clearSyntax() {self._syntax = nil} - public var unknownFields = SwiftProtobuf.UnknownStorage() + /// The edition of the proto file. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + public var edition: Google_Protobuf_Edition { + get {_edition ?? .unknown} + set {_edition = newValue} + } + /// Returns true if `edition` has been explicitly set. + public var hasEdition: Bool {self._edition != nil} + /// Clears the value of `edition`. Subsequent reads from it will return its default value. + public mutating func clearEdition() {self._edition = nil} + + public var unknownFields = UnknownStorage() public init() {} @@ -158,87 +245,122 @@ public struct Google_Protobuf_FileDescriptorProto { fileprivate var _options: Google_Protobuf_FileOptions? = nil fileprivate var _sourceCodeInfo: Google_Protobuf_SourceCodeInfo? = nil fileprivate var _syntax: String? = nil + fileprivate var _edition: Google_Protobuf_Edition? = nil } /// Describes a message type. -public struct Google_Protobuf_DescriptorProto { +public struct Google_Protobuf_DescriptorProto: @unchecked Sendable { // 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. public var name: String { - get {return _name ?? String()} - set {_name = newValue} + get {_storage._name ?? String()} + set {_uniqueStorage()._name = newValue} } /// Returns true if `name` has been explicitly set. - public var hasName: Bool {return self._name != nil} + public var hasName: Bool {_storage._name != nil} /// Clears the value of `name`. Subsequent reads from it will return its default value. - public mutating func clearName() {self._name = nil} + public mutating func clearName() {_uniqueStorage()._name = nil} - public var field: [Google_Protobuf_FieldDescriptorProto] = [] + public var field: [Google_Protobuf_FieldDescriptorProto] { + get {_storage._field} + set {_uniqueStorage()._field = newValue} + } - public var `extension`: [Google_Protobuf_FieldDescriptorProto] = [] + public var `extension`: [Google_Protobuf_FieldDescriptorProto] { + get {_storage._extension} + set {_uniqueStorage()._extension = newValue} + } - public var nestedType: [Google_Protobuf_DescriptorProto] = [] + public var nestedType: [Google_Protobuf_DescriptorProto] { + get {_storage._nestedType} + set {_uniqueStorage()._nestedType = newValue} + } - public var enumType: [Google_Protobuf_EnumDescriptorProto] = [] + public var enumType: [Google_Protobuf_EnumDescriptorProto] { + get {_storage._enumType} + set {_uniqueStorage()._enumType = newValue} + } - public var extensionRange: [Google_Protobuf_DescriptorProto.ExtensionRange] = [] + public var extensionRange: [Google_Protobuf_DescriptorProto.ExtensionRange] { + get {_storage._extensionRange} + set {_uniqueStorage()._extensionRange = newValue} + } - public var oneofDecl: [Google_Protobuf_OneofDescriptorProto] = [] + public var oneofDecl: [Google_Protobuf_OneofDescriptorProto] { + get {_storage._oneofDecl} + set {_uniqueStorage()._oneofDecl = newValue} + } public var options: Google_Protobuf_MessageOptions { - get {return _options ?? Google_Protobuf_MessageOptions()} - set {_options = newValue} + get {_storage._options ?? Google_Protobuf_MessageOptions()} + set {_uniqueStorage()._options = newValue} } /// Returns true if `options` has been explicitly set. - public var hasOptions: Bool {return self._options != nil} + public var hasOptions: Bool {_storage._options != nil} /// Clears the value of `options`. Subsequent reads from it will return its default value. - public mutating func clearOptions() {self._options = nil} + public mutating func clearOptions() {_uniqueStorage()._options = nil} - public var reservedRange: [Google_Protobuf_DescriptorProto.ReservedRange] = [] + public var reservedRange: [Google_Protobuf_DescriptorProto.ReservedRange] { + get {_storage._reservedRange} + set {_uniqueStorage()._reservedRange = newValue} + } /// Reserved field names, which may not be used by fields in the same message. /// A given name may only be reserved once. - public var reservedName: [String] = [] + public var reservedName: [String] { + get {_storage._reservedName} + set {_uniqueStorage()._reservedName = newValue} + } - public var unknownFields = SwiftProtobuf.UnknownStorage() + /// Support for `export` and `local` keywords on enums. + public var visibility: Google_Protobuf_SymbolVisibility { + get {_storage._visibility ?? .visibilityUnset} + set {_uniqueStorage()._visibility = newValue} + } + /// Returns true if `visibility` has been explicitly set. + public var hasVisibility: Bool {_storage._visibility != nil} + /// Clears the value of `visibility`. Subsequent reads from it will return its default value. + public mutating func clearVisibility() {_uniqueStorage()._visibility = nil} + + public var unknownFields = UnknownStorage() - public struct ExtensionRange { + public struct ExtensionRange: Sendable { // 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. /// Inclusive. public var start: Int32 { - get {return _start ?? 0} + get {_start ?? 0} set {_start = newValue} } /// Returns true if `start` has been explicitly set. - public var hasStart: Bool {return self._start != nil} + public var hasStart: Bool {self._start != nil} /// Clears the value of `start`. Subsequent reads from it will return its default value. public mutating func clearStart() {self._start = nil} /// Exclusive. public var end: Int32 { - get {return _end ?? 0} + get {_end ?? 0} set {_end = newValue} } /// Returns true if `end` has been explicitly set. - public var hasEnd: Bool {return self._end != nil} + public var hasEnd: Bool {self._end != nil} /// Clears the value of `end`. Subsequent reads from it will return its default value. public mutating func clearEnd() {self._end = nil} public var options: Google_Protobuf_ExtensionRangeOptions { - get {return _options ?? Google_Protobuf_ExtensionRangeOptions()} + get {_options ?? Google_Protobuf_ExtensionRangeOptions()} set {_options = newValue} } /// Returns true if `options` has been explicitly set. - public var hasOptions: Bool {return self._options != nil} + public var hasOptions: Bool {self._options != nil} /// Clears the value of `options`. Subsequent reads from it will return its default value. public mutating func clearOptions() {self._options = nil} - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} @@ -250,32 +372,32 @@ public struct Google_Protobuf_DescriptorProto { /// Range of reserved tag numbers. Reserved tag numbers may not be used by /// fields or extension ranges in the same message. Reserved ranges may /// not overlap. - public struct ReservedRange { + public struct ReservedRange: Sendable { // 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. /// Inclusive. public var start: Int32 { - get {return _start ?? 0} + get {_start ?? 0} set {_start = newValue} } /// Returns true if `start` has been explicitly set. - public var hasStart: Bool {return self._start != nil} + public var hasStart: Bool {self._start != nil} /// Clears the value of `start`. Subsequent reads from it will return its default value. public mutating func clearStart() {self._start = nil} /// Exclusive. public var end: Int32 { - get {return _end ?? 0} + get {_end ?? 0} set {_end = newValue} } /// Returns true if `end` has been explicitly set. - public var hasEnd: Bool {return self._end != nil} + public var hasEnd: Bool {self._end != nil} /// Clears the value of `end`. Subsequent reads from it will return its default value. public mutating func clearEnd() {self._end = nil} - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} @@ -285,11 +407,10 @@ public struct Google_Protobuf_DescriptorProto { public init() {} - fileprivate var _name: String? = nil - fileprivate var _options: Google_Protobuf_MessageOptions? = nil + fileprivate var _storage = _StorageClass.defaultInstance } -public struct Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.ExtensibleMessage { +public struct Google_Protobuf_ExtensionRangeOptions: ExtensibleMessage, Sendable { // 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. @@ -297,56 +418,170 @@ public struct Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.ExtensibleMes /// The parser stores options it doesn't recognize here. See above. public var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] - public var unknownFields = SwiftProtobuf.UnknownStorage() + /// For external users: DO NOT USE. We are in the process of open sourcing + /// extension declaration and executing internal cleanups before it can be + /// used externally. + public var declaration: [Google_Protobuf_ExtensionRangeOptions.Declaration] = [] + + /// Any features defined in the specific edition. + public var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + public var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + public mutating func clearFeatures() {self._features = nil} + + /// The verification state of the range. + /// TODO: flip the default to DECLARATION once all empty ranges + /// are marked as UNVERIFIED. + public var verification: Google_Protobuf_ExtensionRangeOptions.VerificationState { + get {_verification ?? .unverified} + set {_verification = newValue} + } + /// Returns true if `verification` has been explicitly set. + public var hasVerification: Bool {self._verification != nil} + /// Clears the value of `verification`. Subsequent reads from it will return its default value. + public mutating func clearVerification() {self._verification = nil} + + public var unknownFields = UnknownStorage() + + /// The verification state of the extension range. + public enum VerificationState: Int, Enum, Swift.CaseIterable { + + /// All the extensions of the range must be declared. + case declaration = 0 + case unverified = 1 + + public init() { + self = .declaration + } + + } + + public struct Declaration: Sendable { + // 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. + + /// The extension number declared within the extension range. + public var number: Int32 { + get {_number ?? 0} + set {_number = newValue} + } + /// Returns true if `number` has been explicitly set. + public var hasNumber: Bool {self._number != nil} + /// Clears the value of `number`. Subsequent reads from it will return its default value. + public mutating func clearNumber() {self._number = nil} + + /// The fully-qualified name of the extension field. There must be a leading + /// dot in front of the full name. + public var fullName: String { + get {_fullName ?? String()} + set {_fullName = newValue} + } + /// Returns true if `fullName` has been explicitly set. + public var hasFullName: Bool {self._fullName != nil} + /// Clears the value of `fullName`. Subsequent reads from it will return its default value. + public mutating func clearFullName() {self._fullName = nil} + + /// The fully-qualified type name of the extension field. Unlike + /// Metadata.type, Declaration.type must have a leading dot for messages + /// and enums. + public var type: String { + get {_type ?? String()} + set {_type = newValue} + } + /// Returns true if `type` has been explicitly set. + public var hasType: Bool {self._type != nil} + /// Clears the value of `type`. Subsequent reads from it will return its default value. + public mutating func clearType() {self._type = nil} + + /// If true, indicates that the number is reserved in the extension range, + /// and any extension field with the number will fail to compile. Set this + /// when a declared extension field is deleted. + public var reserved: Bool { + get {_reserved ?? false} + set {_reserved = newValue} + } + /// Returns true if `reserved` has been explicitly set. + public var hasReserved: Bool {self._reserved != nil} + /// Clears the value of `reserved`. Subsequent reads from it will return its default value. + public mutating func clearReserved() {self._reserved = nil} + + /// If true, indicates that the extension must be defined as repeated. + /// Otherwise the extension must be defined as optional. + public var repeated: Bool { + get {_repeated ?? false} + set {_repeated = newValue} + } + /// Returns true if `repeated` has been explicitly set. + public var hasRepeated: Bool {self._repeated != nil} + /// Clears the value of `repeated`. Subsequent reads from it will return its default value. + public mutating func clearRepeated() {self._repeated = nil} + + public var unknownFields = UnknownStorage() + + public init() {} + + fileprivate var _number: Int32? = nil + fileprivate var _fullName: String? = nil + fileprivate var _type: String? = nil + fileprivate var _reserved: Bool? = nil + fileprivate var _repeated: Bool? = nil + } public init() {} - public var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + public var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _features: Google_Protobuf_FeatureSet? = nil + fileprivate var _verification: Google_Protobuf_ExtensionRangeOptions.VerificationState? = nil } /// Describes a field within a message. -public struct Google_Protobuf_FieldDescriptorProto { +public struct Google_Protobuf_FieldDescriptorProto: Sendable { // 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. public var name: String { - get {return _storage._name ?? String()} - set {_uniqueStorage()._name = newValue} + get {_name ?? String()} + set {_name = newValue} } /// Returns true if `name` has been explicitly set. - public var hasName: Bool {return _storage._name != nil} + public var hasName: Bool {self._name != nil} /// Clears the value of `name`. Subsequent reads from it will return its default value. - public mutating func clearName() {_uniqueStorage()._name = nil} + public mutating func clearName() {self._name = nil} public var number: Int32 { - get {return _storage._number ?? 0} - set {_uniqueStorage()._number = newValue} + get {_number ?? 0} + set {_number = newValue} } /// Returns true if `number` has been explicitly set. - public var hasNumber: Bool {return _storage._number != nil} + public var hasNumber: Bool {self._number != nil} /// Clears the value of `number`. Subsequent reads from it will return its default value. - public mutating func clearNumber() {_uniqueStorage()._number = nil} + public mutating func clearNumber() {self._number = nil} public var label: Google_Protobuf_FieldDescriptorProto.Label { - get {return _storage._label ?? .optional} - set {_uniqueStorage()._label = newValue} + get {_label ?? .optional} + set {_label = newValue} } /// Returns true if `label` has been explicitly set. - public var hasLabel: Bool {return _storage._label != nil} + public var hasLabel: Bool {self._label != nil} /// Clears the value of `label`. Subsequent reads from it will return its default value. - public mutating func clearLabel() {_uniqueStorage()._label = nil} + public mutating func clearLabel() {self._label = nil} /// If type_name is set, this need not be set. If both this and type_name /// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP. public var type: Google_Protobuf_FieldDescriptorProto.TypeEnum { - get {return _storage._type ?? .double} - set {_uniqueStorage()._type = newValue} + get {_type ?? .double} + set {_type = newValue} } /// Returns true if `type` has been explicitly set. - public var hasType: Bool {return _storage._type != nil} + public var hasType: Bool {self._type != nil} /// Clears the value of `type`. Subsequent reads from it will return its default value. - public mutating func clearType() {_uniqueStorage()._type = nil} + public mutating func clearType() {self._type = nil} /// For message and enum types, this is the name of the type. If the name /// starts with a '.', it is fully-qualified. Otherwise, C++-like scoping @@ -354,81 +589,80 @@ public struct Google_Protobuf_FieldDescriptorProto { /// message are searched, then within the parent, on up to the root /// namespace). public var typeName: String { - get {return _storage._typeName ?? String()} - set {_uniqueStorage()._typeName = newValue} + get {_typeName ?? String()} + set {_typeName = newValue} } /// Returns true if `typeName` has been explicitly set. - public var hasTypeName: Bool {return _storage._typeName != nil} + public var hasTypeName: Bool {self._typeName != nil} /// Clears the value of `typeName`. Subsequent reads from it will return its default value. - public mutating func clearTypeName() {_uniqueStorage()._typeName = nil} + public mutating func clearTypeName() {self._typeName = nil} /// For extensions, this is the name of the type being extended. It is /// resolved in the same manner as type_name. public var extendee: String { - get {return _storage._extendee ?? String()} - set {_uniqueStorage()._extendee = newValue} + get {_extendee ?? String()} + set {_extendee = newValue} } /// Returns true if `extendee` has been explicitly set. - public var hasExtendee: Bool {return _storage._extendee != nil} + public var hasExtendee: Bool {self._extendee != nil} /// Clears the value of `extendee`. Subsequent reads from it will return its default value. - public mutating func clearExtendee() {_uniqueStorage()._extendee = nil} + public mutating func clearExtendee() {self._extendee = nil} /// For numeric types, contains the original text representation of the value. /// For booleans, "true" or "false". /// For strings, contains the default text contents (not escaped in any way). /// For bytes, contains the C escaped value. All bytes >= 128 are escaped. - /// TODO(kenton): Base-64 encode? public var defaultValue: String { - get {return _storage._defaultValue ?? String()} - set {_uniqueStorage()._defaultValue = newValue} + get {_defaultValue ?? String()} + set {_defaultValue = newValue} } /// Returns true if `defaultValue` has been explicitly set. - public var hasDefaultValue: Bool {return _storage._defaultValue != nil} + public var hasDefaultValue: Bool {self._defaultValue != nil} /// Clears the value of `defaultValue`. Subsequent reads from it will return its default value. - public mutating func clearDefaultValue() {_uniqueStorage()._defaultValue = nil} + public mutating func clearDefaultValue() {self._defaultValue = nil} /// If set, gives the index of a oneof in the containing type's oneof_decl /// list. This field is a member of that oneof. public var oneofIndex: Int32 { - get {return _storage._oneofIndex ?? 0} - set {_uniqueStorage()._oneofIndex = newValue} + get {_oneofIndex ?? 0} + set {_oneofIndex = newValue} } /// Returns true if `oneofIndex` has been explicitly set. - public var hasOneofIndex: Bool {return _storage._oneofIndex != nil} + public var hasOneofIndex: Bool {self._oneofIndex != nil} /// Clears the value of `oneofIndex`. Subsequent reads from it will return its default value. - public mutating func clearOneofIndex() {_uniqueStorage()._oneofIndex = nil} + public mutating func clearOneofIndex() {self._oneofIndex = nil} /// JSON name of this field. The value is set by protocol compiler. If the /// user has set a "json_name" option on this field, that option's value /// will be used. Otherwise, it's deduced from the field's name by converting /// it to camelCase. public var jsonName: String { - get {return _storage._jsonName ?? String()} - set {_uniqueStorage()._jsonName = newValue} + get {_jsonName ?? String()} + set {_jsonName = newValue} } /// Returns true if `jsonName` has been explicitly set. - public var hasJsonName: Bool {return _storage._jsonName != nil} + public var hasJsonName: Bool {self._jsonName != nil} /// Clears the value of `jsonName`. Subsequent reads from it will return its default value. - public mutating func clearJsonName() {_uniqueStorage()._jsonName = nil} + public mutating func clearJsonName() {self._jsonName = nil} public var options: Google_Protobuf_FieldOptions { - get {return _storage._options ?? Google_Protobuf_FieldOptions()} - set {_uniqueStorage()._options = newValue} + get {_options ?? Google_Protobuf_FieldOptions()} + set {_options = newValue} } /// Returns true if `options` has been explicitly set. - public var hasOptions: Bool {return _storage._options != nil} + public var hasOptions: Bool {self._options != nil} /// Clears the value of `options`. Subsequent reads from it will return its default value. - public mutating func clearOptions() {_uniqueStorage()._options = nil} + public mutating func clearOptions() {self._options = nil} /// If true, this is a proto3 "optional". When a proto3 field is optional, it /// tracks presence regardless of field type. /// - /// When proto3_optional is true, this field must be belong to a oneof to - /// signal to old proto3 clients that presence is tracked for this field. This - /// oneof is known as a "synthetic" oneof, and this field must be its sole - /// member (each proto3 optional field gets its own synthetic oneof). Synthetic - /// oneofs exist in the descriptor only, and do not generate any API. Synthetic - /// oneofs must be ordered after all "real" oneofs. + /// When proto3_optional is true, this field must belong to a oneof to signal + /// to old proto3 clients that presence is tracked for this field. This oneof + /// is known as a "synthetic" oneof, and this field must be its sole member + /// (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs + /// exist in the descriptor only, and do not generate any API. Synthetic oneofs + /// must be ordered after all "real" oneofs. /// /// For message fields, proto3_optional doesn't create any semantic change, /// since non-repeated message fields always track presence. However it still @@ -442,185 +676,122 @@ public struct Google_Protobuf_FieldDescriptorProto { /// Proto2 optional fields do not set this flag, because they already indicate /// optional with `LABEL_OPTIONAL`. public var proto3Optional: Bool { - get {return _storage._proto3Optional ?? false} - set {_uniqueStorage()._proto3Optional = newValue} + get {_proto3Optional ?? false} + set {_proto3Optional = newValue} } /// Returns true if `proto3Optional` has been explicitly set. - public var hasProto3Optional: Bool {return _storage._proto3Optional != nil} + public var hasProto3Optional: Bool {self._proto3Optional != nil} /// Clears the value of `proto3Optional`. Subsequent reads from it will return its default value. - public mutating func clearProto3Optional() {_uniqueStorage()._proto3Optional = nil} + public mutating func clearProto3Optional() {self._proto3Optional = nil} - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() - public enum TypeEnum: SwiftProtobuf.Enum { - public typealias RawValue = Int + public enum TypeEnum: Int, Enum, Swift.CaseIterable { /// 0 is reserved for errors. /// Order is weird for historical reasons. - case double // = 1 - case float // = 2 + case double = 1 + case float = 2 /// Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if /// negative values are likely. - case int64 // = 3 - case uint64 // = 4 + case int64 = 3 + case uint64 = 4 /// Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if /// negative values are likely. - case int32 // = 5 - case fixed64 // = 6 - case fixed32 // = 7 - case bool // = 8 - case string // = 9 + case int32 = 5 + case fixed64 = 6 + case fixed32 = 7 + case bool = 8 + case string = 9 /// Tag-delimited aggregate. - /// Group type is deprecated and not supported in proto3. However, Proto3 + /// Group type is deprecated and not supported after google.protobuf. However, Proto3 /// implementations should still be able to parse the group wire format and - /// treat group fields as unknown fields. - case group // = 10 + /// treat group fields as unknown fields. In Editions, the group wire format + /// can be enabled via the `message_encoding` feature. + case group = 10 /// Length-delimited aggregate. - case message // = 11 + case message = 11 /// New in version 2. - case bytes // = 12 - case uint32 // = 13 - case `enum` // = 14 - case sfixed32 // = 15 - case sfixed64 // = 16 + case bytes = 12 + case uint32 = 13 + case `enum` = 14 + case sfixed32 = 15 + case sfixed64 = 16 /// Uses ZigZag encoding. - case sint32 // = 17 + case sint32 = 17 /// Uses ZigZag encoding. - case sint64 // = 18 + case sint64 = 18 public init() { self = .double } - public init?(rawValue: Int) { - switch rawValue { - case 1: self = .double - case 2: self = .float - case 3: self = .int64 - case 4: self = .uint64 - case 5: self = .int32 - case 6: self = .fixed64 - case 7: self = .fixed32 - case 8: self = .bool - case 9: self = .string - case 10: self = .group - case 11: self = .message - case 12: self = .bytes - case 13: self = .uint32 - case 14: self = .enum - case 15: self = .sfixed32 - case 16: self = .sfixed64 - case 17: self = .sint32 - case 18: self = .sint64 - default: return nil - } - } - - public var rawValue: Int { - switch self { - case .double: return 1 - case .float: return 2 - case .int64: return 3 - case .uint64: return 4 - case .int32: return 5 - case .fixed64: return 6 - case .fixed32: return 7 - case .bool: return 8 - case .string: return 9 - case .group: return 10 - case .message: return 11 - case .bytes: return 12 - case .uint32: return 13 - case .enum: return 14 - case .sfixed32: return 15 - case .sfixed64: return 16 - case .sint32: return 17 - case .sint64: return 18 - } - } - } - public enum Label: SwiftProtobuf.Enum { - public typealias RawValue = Int + public enum Label: Int, Enum, Swift.CaseIterable { /// 0 is reserved for errors - case `optional` // = 1 - case `required` // = 2 - case repeated // = 3 + case `optional` = 1 + case repeated = 3 + + /// The required label is only allowed in google.protobuf. In proto3 and Editions + /// it's explicitly prohibited. In Editions, the `field_presence` feature + /// can be used to get this behavior. + case `required` = 2 public init() { self = .optional } - public init?(rawValue: Int) { - switch rawValue { - case 1: self = .optional - case 2: self = .required - case 3: self = .repeated - default: return nil - } - } - - public var rawValue: Int { - switch self { - case .optional: return 1 - case .required: return 2 - case .repeated: return 3 - } - } - } public init() {} - fileprivate var _storage = _StorageClass.defaultInstance -} - -#if swift(>=4.2) - -extension Google_Protobuf_FieldDescriptorProto.TypeEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension Google_Protobuf_FieldDescriptorProto.Label: CaseIterable { - // Support synthesized by the compiler. + fileprivate var _name: String? = nil + fileprivate var _number: Int32? = nil + fileprivate var _label: Google_Protobuf_FieldDescriptorProto.Label? = nil + fileprivate var _type: Google_Protobuf_FieldDescriptorProto.TypeEnum? = nil + fileprivate var _typeName: String? = nil + fileprivate var _extendee: String? = nil + fileprivate var _defaultValue: String? = nil + fileprivate var _oneofIndex: Int32? = nil + fileprivate var _jsonName: String? = nil + fileprivate var _options: Google_Protobuf_FieldOptions? = nil + fileprivate var _proto3Optional: Bool? = nil } -#endif // swift(>=4.2) - /// Describes a oneof. -public struct Google_Protobuf_OneofDescriptorProto { +public struct Google_Protobuf_OneofDescriptorProto: Sendable { // 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. public var name: String { - get {return _name ?? String()} + get {_name ?? String()} set {_name = newValue} } /// Returns true if `name` has been explicitly set. - public var hasName: Bool {return self._name != nil} + public var hasName: Bool {self._name != nil} /// Clears the value of `name`. Subsequent reads from it will return its default value. public mutating func clearName() {self._name = nil} public var options: Google_Protobuf_OneofOptions { - get {return _options ?? Google_Protobuf_OneofOptions()} + get {_options ?? Google_Protobuf_OneofOptions()} set {_options = newValue} } /// Returns true if `options` has been explicitly set. - public var hasOptions: Bool {return self._options != nil} + public var hasOptions: Bool {self._options != nil} /// Clears the value of `options`. Subsequent reads from it will return its default value. public mutating func clearOptions() {self._options = nil} - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} @@ -629,41 +800,60 @@ public struct Google_Protobuf_OneofDescriptorProto { } /// Describes an enum type. -public struct Google_Protobuf_EnumDescriptorProto { +public struct Google_Protobuf_EnumDescriptorProto: @unchecked Sendable { // 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. public var name: String { - get {return _name ?? String()} - set {_name = newValue} + get {_storage._name ?? String()} + set {_uniqueStorage()._name = newValue} } /// Returns true if `name` has been explicitly set. - public var hasName: Bool {return self._name != nil} + public var hasName: Bool {_storage._name != nil} /// Clears the value of `name`. Subsequent reads from it will return its default value. - public mutating func clearName() {self._name = nil} + public mutating func clearName() {_uniqueStorage()._name = nil} - public var value: [Google_Protobuf_EnumValueDescriptorProto] = [] + public var value: [Google_Protobuf_EnumValueDescriptorProto] { + get {_storage._value} + set {_uniqueStorage()._value = newValue} + } public var options: Google_Protobuf_EnumOptions { - get {return _options ?? Google_Protobuf_EnumOptions()} - set {_options = newValue} + get {_storage._options ?? Google_Protobuf_EnumOptions()} + set {_uniqueStorage()._options = newValue} } /// Returns true if `options` has been explicitly set. - public var hasOptions: Bool {return self._options != nil} + public var hasOptions: Bool {_storage._options != nil} /// Clears the value of `options`. Subsequent reads from it will return its default value. - public mutating func clearOptions() {self._options = nil} + public mutating func clearOptions() {_uniqueStorage()._options = nil} /// Range of reserved numeric values. Reserved numeric values may not be used /// by enum values in the same enum declaration. Reserved ranges may not /// overlap. - public var reservedRange: [Google_Protobuf_EnumDescriptorProto.EnumReservedRange] = [] + public var reservedRange: [Google_Protobuf_EnumDescriptorProto.EnumReservedRange] { + get {_storage._reservedRange} + set {_uniqueStorage()._reservedRange = newValue} + } /// Reserved enum value names, which may not be reused. A given name may only /// be reserved once. - public var reservedName: [String] = [] + public var reservedName: [String] { + get {_storage._reservedName} + set {_uniqueStorage()._reservedName = newValue} + } - public var unknownFields = SwiftProtobuf.UnknownStorage() + /// Support for `export` and `local` keywords on enums. + public var visibility: Google_Protobuf_SymbolVisibility { + get {_storage._visibility ?? .visibilityUnset} + set {_uniqueStorage()._visibility = newValue} + } + /// Returns true if `visibility` has been explicitly set. + public var hasVisibility: Bool {_storage._visibility != nil} + /// Clears the value of `visibility`. Subsequent reads from it will return its default value. + public mutating func clearVisibility() {_uniqueStorage()._visibility = nil} + + public var unknownFields = UnknownStorage() /// Range of reserved numeric values. Reserved values may not be used by /// entries in the same enum. Reserved ranges may not overlap. @@ -671,32 +861,32 @@ public struct Google_Protobuf_EnumDescriptorProto { /// Note that this is distinct from DescriptorProto.ReservedRange in that it /// is inclusive such that it can appropriately represent the entire int32 /// domain. - public struct EnumReservedRange { + public struct EnumReservedRange: Sendable { // 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. /// Inclusive. public var start: Int32 { - get {return _start ?? 0} + get {_start ?? 0} set {_start = newValue} } /// Returns true if `start` has been explicitly set. - public var hasStart: Bool {return self._start != nil} + public var hasStart: Bool {self._start != nil} /// Clears the value of `start`. Subsequent reads from it will return its default value. public mutating func clearStart() {self._start = nil} /// Inclusive. public var end: Int32 { - get {return _end ?? 0} + get {_end ?? 0} set {_end = newValue} } /// Returns true if `end` has been explicitly set. - public var hasEnd: Bool {return self._end != nil} + public var hasEnd: Bool {self._end != nil} /// Clears the value of `end`. Subsequent reads from it will return its default value. public mutating func clearEnd() {self._end = nil} - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} @@ -706,79 +896,76 @@ public struct Google_Protobuf_EnumDescriptorProto { public init() {} - fileprivate var _name: String? = nil - fileprivate var _options: Google_Protobuf_EnumOptions? = nil + fileprivate var _storage = _StorageClass.defaultInstance } /// Describes a value within an enum. -public struct Google_Protobuf_EnumValueDescriptorProto { +public struct Google_Protobuf_EnumValueDescriptorProto: @unchecked Sendable { // 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. public var name: String { - get {return _name ?? String()} - set {_name = newValue} + get {_storage._name ?? String()} + set {_uniqueStorage()._name = newValue} } /// Returns true if `name` has been explicitly set. - public var hasName: Bool {return self._name != nil} + public var hasName: Bool {_storage._name != nil} /// Clears the value of `name`. Subsequent reads from it will return its default value. - public mutating func clearName() {self._name = nil} + public mutating func clearName() {_uniqueStorage()._name = nil} public var number: Int32 { - get {return _number ?? 0} - set {_number = newValue} + get {_storage._number ?? 0} + set {_uniqueStorage()._number = newValue} } /// Returns true if `number` has been explicitly set. - public var hasNumber: Bool {return self._number != nil} + public var hasNumber: Bool {_storage._number != nil} /// Clears the value of `number`. Subsequent reads from it will return its default value. - public mutating func clearNumber() {self._number = nil} + public mutating func clearNumber() {_uniqueStorage()._number = nil} public var options: Google_Protobuf_EnumValueOptions { - get {return _options ?? Google_Protobuf_EnumValueOptions()} - set {_options = newValue} + get {_storage._options ?? Google_Protobuf_EnumValueOptions()} + set {_uniqueStorage()._options = newValue} } /// Returns true if `options` has been explicitly set. - public var hasOptions: Bool {return self._options != nil} + public var hasOptions: Bool {_storage._options != nil} /// Clears the value of `options`. Subsequent reads from it will return its default value. - public mutating func clearOptions() {self._options = nil} + public mutating func clearOptions() {_uniqueStorage()._options = nil} - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} - fileprivate var _name: String? = nil - fileprivate var _number: Int32? = nil - fileprivate var _options: Google_Protobuf_EnumValueOptions? = nil + fileprivate var _storage = _StorageClass.defaultInstance } /// Describes a service. -public struct Google_Protobuf_ServiceDescriptorProto { +public struct Google_Protobuf_ServiceDescriptorProto: Sendable { // 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. public var name: String { - get {return _name ?? String()} + get {_name ?? String()} set {_name = newValue} } /// Returns true if `name` has been explicitly set. - public var hasName: Bool {return self._name != nil} + public var hasName: Bool {self._name != nil} /// Clears the value of `name`. Subsequent reads from it will return its default value. public mutating func clearName() {self._name = nil} public var method: [Google_Protobuf_MethodDescriptorProto] = [] public var options: Google_Protobuf_ServiceOptions { - get {return _options ?? Google_Protobuf_ServiceOptions()} + get {_options ?? Google_Protobuf_ServiceOptions()} set {_options = newValue} } /// Returns true if `options` has been explicitly set. - public var hasOptions: Bool {return self._options != nil} + public var hasOptions: Bool {self._options != nil} /// Clears the value of `options`. Subsequent reads from it will return its default value. public mutating func clearOptions() {self._options = nil} - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} @@ -787,70 +974,70 @@ public struct Google_Protobuf_ServiceDescriptorProto { } /// Describes a method of a service. -public struct Google_Protobuf_MethodDescriptorProto { +public struct Google_Protobuf_MethodDescriptorProto: Sendable { // 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. public var name: String { - get {return _name ?? String()} + get {_name ?? String()} set {_name = newValue} } /// Returns true if `name` has been explicitly set. - public var hasName: Bool {return self._name != nil} + public var hasName: Bool {self._name != nil} /// Clears the value of `name`. Subsequent reads from it will return its default value. public mutating func clearName() {self._name = nil} /// Input and output type names. These are resolved in the same way as /// FieldDescriptorProto.type_name, but must refer to a message type. public var inputType: String { - get {return _inputType ?? String()} + get {_inputType ?? String()} set {_inputType = newValue} } /// Returns true if `inputType` has been explicitly set. - public var hasInputType: Bool {return self._inputType != nil} + public var hasInputType: Bool {self._inputType != nil} /// Clears the value of `inputType`. Subsequent reads from it will return its default value. public mutating func clearInputType() {self._inputType = nil} public var outputType: String { - get {return _outputType ?? String()} + get {_outputType ?? String()} set {_outputType = newValue} } /// Returns true if `outputType` has been explicitly set. - public var hasOutputType: Bool {return self._outputType != nil} + public var hasOutputType: Bool {self._outputType != nil} /// Clears the value of `outputType`. Subsequent reads from it will return its default value. public mutating func clearOutputType() {self._outputType = nil} public var options: Google_Protobuf_MethodOptions { - get {return _options ?? Google_Protobuf_MethodOptions()} + get {_options ?? Google_Protobuf_MethodOptions()} set {_options = newValue} } /// Returns true if `options` has been explicitly set. - public var hasOptions: Bool {return self._options != nil} + public var hasOptions: Bool {self._options != nil} /// Clears the value of `options`. Subsequent reads from it will return its default value. public mutating func clearOptions() {self._options = nil} /// Identifies if client streams multiple client messages public var clientStreaming: Bool { - get {return _clientStreaming ?? false} + get {_clientStreaming ?? false} set {_clientStreaming = newValue} } /// Returns true if `clientStreaming` has been explicitly set. - public var hasClientStreaming: Bool {return self._clientStreaming != nil} + public var hasClientStreaming: Bool {self._clientStreaming != nil} /// Clears the value of `clientStreaming`. Subsequent reads from it will return its default value. public mutating func clearClientStreaming() {self._clientStreaming = nil} /// Identifies if server streams multiple server messages public var serverStreaming: Bool { - get {return _serverStreaming ?? false} + get {_serverStreaming ?? false} set {_serverStreaming = newValue} } /// Returns true if `serverStreaming` has been explicitly set. - public var hasServerStreaming: Bool {return self._serverStreaming != nil} + public var hasServerStreaming: Bool {self._serverStreaming != nil} /// Clears the value of `serverStreaming`. Subsequent reads from it will return its default value. public mutating func clearServerStreaming() {self._serverStreaming = nil} - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} @@ -862,7 +1049,7 @@ public struct Google_Protobuf_MethodDescriptorProto { fileprivate var _serverStreaming: Bool? = nil } -public struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { +public struct Google_Protobuf_FileOptions: ExtensibleMessage, @unchecked Sendable { // 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. @@ -872,11 +1059,11 @@ public struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { /// inappropriate because proto packages do not normally start with backwards /// domain names. public var javaPackage: String { - get {return _storage._javaPackage ?? String()} + get {_storage._javaPackage ?? String()} set {_uniqueStorage()._javaPackage = newValue} } /// Returns true if `javaPackage` has been explicitly set. - public var hasJavaPackage: Bool {return _storage._javaPackage != nil} + public var hasJavaPackage: Bool {_storage._javaPackage != nil} /// Clears the value of `javaPackage`. Subsequent reads from it will return its default value. public mutating func clearJavaPackage() {_uniqueStorage()._javaPackage = nil} @@ -886,11 +1073,11 @@ public struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { /// If java_multiple_files is disabled, then all the other classes from the /// .proto file will be nested inside the single wrapper outer class. public var javaOuterClassname: String { - get {return _storage._javaOuterClassname ?? String()} + get {_storage._javaOuterClassname ?? String()} set {_uniqueStorage()._javaOuterClassname = newValue} } /// Returns true if `javaOuterClassname` has been explicitly set. - public var hasJavaOuterClassname: Bool {return _storage._javaOuterClassname != nil} + public var hasJavaOuterClassname: Bool {_storage._javaOuterClassname != nil} /// Clears the value of `javaOuterClassname`. Subsequent reads from it will return its default value. public mutating func clearJavaOuterClassname() {_uniqueStorage()._javaOuterClassname = nil} @@ -901,45 +1088,51 @@ public struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { /// generated to contain the file's getDescriptor() method as well as any /// top-level extensions defined in the file. public var javaMultipleFiles: Bool { - get {return _storage._javaMultipleFiles ?? false} + get {_storage._javaMultipleFiles ?? false} set {_uniqueStorage()._javaMultipleFiles = newValue} } /// Returns true if `javaMultipleFiles` has been explicitly set. - public var hasJavaMultipleFiles: Bool {return _storage._javaMultipleFiles != nil} + public var hasJavaMultipleFiles: Bool {_storage._javaMultipleFiles != nil} /// Clears the value of `javaMultipleFiles`. Subsequent reads from it will return its default value. public mutating func clearJavaMultipleFiles() {_uniqueStorage()._javaMultipleFiles = nil} /// This option does nothing. + /// + /// NOTE: This field was marked as deprecated in the .proto file. public var javaGenerateEqualsAndHash: Bool { - get {return _storage._javaGenerateEqualsAndHash ?? false} + get {_storage._javaGenerateEqualsAndHash ?? false} set {_uniqueStorage()._javaGenerateEqualsAndHash = newValue} } /// Returns true if `javaGenerateEqualsAndHash` has been explicitly set. - public var hasJavaGenerateEqualsAndHash: Bool {return _storage._javaGenerateEqualsAndHash != nil} + public var hasJavaGenerateEqualsAndHash: Bool {_storage._javaGenerateEqualsAndHash != nil} /// Clears the value of `javaGenerateEqualsAndHash`. Subsequent reads from it will return its default value. public mutating func clearJavaGenerateEqualsAndHash() {_uniqueStorage()._javaGenerateEqualsAndHash = nil} - /// If set true, then the Java2 code generator will generate code that - /// throws an exception whenever an attempt is made to assign a non-UTF-8 - /// byte sequence to a string field. - /// Message reflection will do the same. - /// However, an extension field still accepts non-UTF-8 byte sequences. - /// This option has no effect on when used with the lite runtime. + /// A proto2 file can set this to true to opt in to UTF-8 checking for Java, + /// which will throw an exception if invalid UTF-8 is parsed from the wire or + /// assigned to a string field. + /// + /// TODO: clarify exactly what kinds of field types this option + /// applies to, and update these docs accordingly. + /// + /// Proto3 files already perform these checks. Setting the option explicitly to + /// false has no effect: it cannot be used to opt proto3 files out of UTF-8 + /// checks. public var javaStringCheckUtf8: Bool { - get {return _storage._javaStringCheckUtf8 ?? false} + get {_storage._javaStringCheckUtf8 ?? false} set {_uniqueStorage()._javaStringCheckUtf8 = newValue} } /// Returns true if `javaStringCheckUtf8` has been explicitly set. - public var hasJavaStringCheckUtf8: Bool {return _storage._javaStringCheckUtf8 != nil} + public var hasJavaStringCheckUtf8: Bool {_storage._javaStringCheckUtf8 != nil} /// Clears the value of `javaStringCheckUtf8`. Subsequent reads from it will return its default value. public mutating func clearJavaStringCheckUtf8() {_uniqueStorage()._javaStringCheckUtf8 = nil} public var optimizeFor: Google_Protobuf_FileOptions.OptimizeMode { - get {return _storage._optimizeFor ?? .speed} + get {_storage._optimizeFor ?? .speed} set {_uniqueStorage()._optimizeFor = newValue} } /// Returns true if `optimizeFor` has been explicitly set. - public var hasOptimizeFor: Bool {return _storage._optimizeFor != nil} + public var hasOptimizeFor: Bool {_storage._optimizeFor != nil} /// Clears the value of `optimizeFor`. Subsequent reads from it will return its default value. public mutating func clearOptimizeFor() {_uniqueStorage()._optimizeFor = nil} @@ -949,11 +1142,11 @@ public struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { /// - Otherwise, the package statement in the .proto file, if present. /// - Otherwise, the basename of the .proto file, without extension. public var goPackage: String { - get {return _storage._goPackage ?? String()} + get {_storage._goPackage ?? String()} set {_uniqueStorage()._goPackage = newValue} } /// Returns true if `goPackage` has been explicitly set. - public var hasGoPackage: Bool {return _storage._goPackage != nil} + public var hasGoPackage: Bool {_storage._goPackage != nil} /// Clears the value of `goPackage`. Subsequent reads from it will return its default value. public mutating func clearGoPackage() {_uniqueStorage()._goPackage = nil} @@ -968,83 +1161,74 @@ public struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { /// these default to false. Old code which depends on generic services should /// explicitly set them to true. public var ccGenericServices: Bool { - get {return _storage._ccGenericServices ?? false} + get {_storage._ccGenericServices ?? false} set {_uniqueStorage()._ccGenericServices = newValue} } /// Returns true if `ccGenericServices` has been explicitly set. - public var hasCcGenericServices: Bool {return _storage._ccGenericServices != nil} + public var hasCcGenericServices: Bool {_storage._ccGenericServices != nil} /// Clears the value of `ccGenericServices`. Subsequent reads from it will return its default value. public mutating func clearCcGenericServices() {_uniqueStorage()._ccGenericServices = nil} public var javaGenericServices: Bool { - get {return _storage._javaGenericServices ?? false} + get {_storage._javaGenericServices ?? false} set {_uniqueStorage()._javaGenericServices = newValue} } /// Returns true if `javaGenericServices` has been explicitly set. - public var hasJavaGenericServices: Bool {return _storage._javaGenericServices != nil} + public var hasJavaGenericServices: Bool {_storage._javaGenericServices != nil} /// Clears the value of `javaGenericServices`. Subsequent reads from it will return its default value. public mutating func clearJavaGenericServices() {_uniqueStorage()._javaGenericServices = nil} public var pyGenericServices: Bool { - get {return _storage._pyGenericServices ?? false} + get {_storage._pyGenericServices ?? false} set {_uniqueStorage()._pyGenericServices = newValue} } /// Returns true if `pyGenericServices` has been explicitly set. - public var hasPyGenericServices: Bool {return _storage._pyGenericServices != nil} + public var hasPyGenericServices: Bool {_storage._pyGenericServices != nil} /// Clears the value of `pyGenericServices`. Subsequent reads from it will return its default value. public mutating func clearPyGenericServices() {_uniqueStorage()._pyGenericServices = nil} - public var phpGenericServices: Bool { - get {return _storage._phpGenericServices ?? false} - set {_uniqueStorage()._phpGenericServices = newValue} - } - /// Returns true if `phpGenericServices` has been explicitly set. - public var hasPhpGenericServices: Bool {return _storage._phpGenericServices != nil} - /// Clears the value of `phpGenericServices`. Subsequent reads from it will return its default value. - public mutating func clearPhpGenericServices() {_uniqueStorage()._phpGenericServices = nil} - /// Is this file deprecated? /// Depending on the target platform, this can emit Deprecated annotations /// for everything in the file, or it will be completely ignored; in the very /// least, this is a formalization for deprecating files. public var deprecated: Bool { - get {return _storage._deprecated ?? false} + get {_storage._deprecated ?? false} set {_uniqueStorage()._deprecated = newValue} } /// Returns true if `deprecated` has been explicitly set. - public var hasDeprecated: Bool {return _storage._deprecated != nil} + public var hasDeprecated: Bool {_storage._deprecated != nil} /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. public mutating func clearDeprecated() {_uniqueStorage()._deprecated = nil} /// Enables the use of arenas for the proto messages in this file. This applies /// only to generated classes for C++. public var ccEnableArenas: Bool { - get {return _storage._ccEnableArenas ?? true} + get {_storage._ccEnableArenas ?? true} set {_uniqueStorage()._ccEnableArenas = newValue} } /// Returns true if `ccEnableArenas` has been explicitly set. - public var hasCcEnableArenas: Bool {return _storage._ccEnableArenas != nil} + public var hasCcEnableArenas: Bool {_storage._ccEnableArenas != nil} /// Clears the value of `ccEnableArenas`. Subsequent reads from it will return its default value. public mutating func clearCcEnableArenas() {_uniqueStorage()._ccEnableArenas = nil} /// Sets the objective c class prefix which is prepended to all objective c /// generated classes from this .proto. There is no default. public var objcClassPrefix: String { - get {return _storage._objcClassPrefix ?? String()} + get {_storage._objcClassPrefix ?? String()} set {_uniqueStorage()._objcClassPrefix = newValue} } /// Returns true if `objcClassPrefix` has been explicitly set. - public var hasObjcClassPrefix: Bool {return _storage._objcClassPrefix != nil} + public var hasObjcClassPrefix: Bool {_storage._objcClassPrefix != nil} /// Clears the value of `objcClassPrefix`. Subsequent reads from it will return its default value. public mutating func clearObjcClassPrefix() {_uniqueStorage()._objcClassPrefix = nil} /// Namespace for generated classes; defaults to the package. public var csharpNamespace: String { - get {return _storage._csharpNamespace ?? String()} + get {_storage._csharpNamespace ?? String()} set {_uniqueStorage()._csharpNamespace = newValue} } /// Returns true if `csharpNamespace` has been explicitly set. - public var hasCsharpNamespace: Bool {return _storage._csharpNamespace != nil} + public var hasCsharpNamespace: Bool {_storage._csharpNamespace != nil} /// Clears the value of `csharpNamespace`. Subsequent reads from it will return its default value. public mutating func clearCsharpNamespace() {_uniqueStorage()._csharpNamespace = nil} @@ -1053,22 +1237,22 @@ public struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { /// defined. When this options is provided, they will use this value instead /// to prefix the types/symbols defined. public var swiftPrefix: String { - get {return _storage._swiftPrefix ?? String()} + get {_storage._swiftPrefix ?? String()} set {_uniqueStorage()._swiftPrefix = newValue} } /// Returns true if `swiftPrefix` has been explicitly set. - public var hasSwiftPrefix: Bool {return _storage._swiftPrefix != nil} + public var hasSwiftPrefix: Bool {_storage._swiftPrefix != nil} /// Clears the value of `swiftPrefix`. Subsequent reads from it will return its default value. public mutating func clearSwiftPrefix() {_uniqueStorage()._swiftPrefix = nil} /// Sets the php class prefix which is prepended to all php generated classes /// from this .proto. Default is empty. public var phpClassPrefix: String { - get {return _storage._phpClassPrefix ?? String()} + get {_storage._phpClassPrefix ?? String()} set {_uniqueStorage()._phpClassPrefix = newValue} } /// Returns true if `phpClassPrefix` has been explicitly set. - public var hasPhpClassPrefix: Bool {return _storage._phpClassPrefix != nil} + public var hasPhpClassPrefix: Bool {_storage._phpClassPrefix != nil} /// Clears the value of `phpClassPrefix`. Subsequent reads from it will return its default value. public mutating func clearPhpClassPrefix() {_uniqueStorage()._phpClassPrefix = nil} @@ -1076,11 +1260,11 @@ public struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { /// is empty. When this option is empty, the package name will be used for /// determining the namespace. public var phpNamespace: String { - get {return _storage._phpNamespace ?? String()} + get {_storage._phpNamespace ?? String()} set {_uniqueStorage()._phpNamespace = newValue} } /// Returns true if `phpNamespace` has been explicitly set. - public var hasPhpNamespace: Bool {return _storage._phpNamespace != nil} + public var hasPhpNamespace: Bool {_storage._phpNamespace != nil} /// Clears the value of `phpNamespace`. Subsequent reads from it will return its default value. public mutating func clearPhpNamespace() {_uniqueStorage()._phpNamespace = nil} @@ -1088,11 +1272,11 @@ public struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { /// Default is empty. When this option is empty, the proto file name will be /// used for determining the namespace. public var phpMetadataNamespace: String { - get {return _storage._phpMetadataNamespace ?? String()} + get {_storage._phpMetadataNamespace ?? String()} set {_uniqueStorage()._phpMetadataNamespace = newValue} } /// Returns true if `phpMetadataNamespace` has been explicitly set. - public var hasPhpMetadataNamespace: Bool {return _storage._phpMetadataNamespace != nil} + public var hasPhpMetadataNamespace: Bool {_storage._phpMetadataNamespace != nil} /// Clears the value of `phpMetadataNamespace`. Subsequent reads from it will return its default value. public mutating func clearPhpMetadataNamespace() {_uniqueStorage()._phpMetadataNamespace = nil} @@ -1100,74 +1284,61 @@ public struct Google_Protobuf_FileOptions: SwiftProtobuf.ExtensibleMessage { /// is empty. When this option is not set, the package name will be used for /// determining the ruby package. public var rubyPackage: String { - get {return _storage._rubyPackage ?? String()} + get {_storage._rubyPackage ?? String()} set {_uniqueStorage()._rubyPackage = newValue} } /// Returns true if `rubyPackage` has been explicitly set. - public var hasRubyPackage: Bool {return _storage._rubyPackage != nil} + public var hasRubyPackage: Bool {_storage._rubyPackage != nil} /// Clears the value of `rubyPackage`. Subsequent reads from it will return its default value. public mutating func clearRubyPackage() {_uniqueStorage()._rubyPackage = nil} + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + public var features: Google_Protobuf_FeatureSet { + get {_storage._features ?? Google_Protobuf_FeatureSet()} + set {_uniqueStorage()._features = newValue} + } + /// Returns true if `features` has been explicitly set. + public var hasFeatures: Bool {_storage._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + public mutating func clearFeatures() {_uniqueStorage()._features = nil} + /// The parser stores options it doesn't recognize here. /// See the documentation for the "Options" section above. public var uninterpretedOption: [Google_Protobuf_UninterpretedOption] { - get {return _storage._uninterpretedOption} + get {_storage._uninterpretedOption} set {_uniqueStorage()._uninterpretedOption = newValue} } - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() /// Generated classes can be optimized for speed or code size. - public enum OptimizeMode: SwiftProtobuf.Enum { - public typealias RawValue = Int + public enum OptimizeMode: Int, Enum, Swift.CaseIterable { /// Generate complete code for parsing, serialization, - case speed // = 1 + case speed = 1 /// etc. - case codeSize // = 2 + case codeSize = 2 /// Generate code using MessageLite and the lite runtime. - case liteRuntime // = 3 + case liteRuntime = 3 public init() { self = .speed } - public init?(rawValue: Int) { - switch rawValue { - case 1: self = .speed - case 2: self = .codeSize - case 3: self = .liteRuntime - default: return nil - } - } - - public var rawValue: Int { - switch self { - case .speed: return 1 - case .codeSize: return 2 - case .liteRuntime: return 3 - } - } - } public init() {} - public var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + public var _protobuf_extensionFieldValues = ExtensionFieldValueSet() fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension Google_Protobuf_FileOptions.OptimizeMode: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -public struct Google_Protobuf_MessageOptions: SwiftProtobuf.ExtensibleMessage { +public struct Google_Protobuf_MessageOptions: ExtensibleMessage, Sendable { // 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. @@ -1191,11 +1362,11 @@ public struct Google_Protobuf_MessageOptions: SwiftProtobuf.ExtensibleMessage { /// Because this is an option, the above two restrictions are not enforced by /// the protocol compiler. public var messageSetWireFormat: Bool { - get {return _messageSetWireFormat ?? false} + get {_messageSetWireFormat ?? false} set {_messageSetWireFormat = newValue} } /// Returns true if `messageSetWireFormat` has been explicitly set. - public var hasMessageSetWireFormat: Bool {return self._messageSetWireFormat != nil} + public var hasMessageSetWireFormat: Bool {self._messageSetWireFormat != nil} /// Clears the value of `messageSetWireFormat`. Subsequent reads from it will return its default value. public mutating func clearMessageSetWireFormat() {self._messageSetWireFormat = nil} @@ -1203,11 +1374,11 @@ public struct Google_Protobuf_MessageOptions: SwiftProtobuf.ExtensibleMessage { /// conflict with a field of the same name. This is meant to make migration /// from proto1 easier; new code should avoid fields named "descriptor". public var noStandardDescriptorAccessor: Bool { - get {return _noStandardDescriptorAccessor ?? false} + get {_noStandardDescriptorAccessor ?? false} set {_noStandardDescriptorAccessor = newValue} } /// Returns true if `noStandardDescriptorAccessor` has been explicitly set. - public var hasNoStandardDescriptorAccessor: Bool {return self._noStandardDescriptorAccessor != nil} + public var hasNoStandardDescriptorAccessor: Bool {self._noStandardDescriptorAccessor != nil} /// Clears the value of `noStandardDescriptorAccessor`. Subsequent reads from it will return its default value. public mutating func clearNoStandardDescriptorAccessor() {self._noStandardDescriptorAccessor = nil} @@ -1216,11 +1387,11 @@ public struct Google_Protobuf_MessageOptions: SwiftProtobuf.ExtensibleMessage { /// for the message, or it will be completely ignored; in the very least, /// this is a formalization for deprecating messages. public var deprecated: Bool { - get {return _deprecated ?? false} + get {_deprecated ?? false} set {_deprecated = newValue} } /// Returns true if `deprecated` has been explicitly set. - public var hasDeprecated: Bool {return self._deprecated != nil} + public var hasDeprecated: Bool {self._deprecated != nil} /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. public mutating func clearDeprecated() {self._deprecated = nil} @@ -1246,59 +1417,100 @@ public struct Google_Protobuf_MessageOptions: SwiftProtobuf.ExtensibleMessage { /// instead. The option should only be implicitly set by the proto compiler /// parser. public var mapEntry: Bool { - get {return _mapEntry ?? false} + get {_mapEntry ?? false} set {_mapEntry = newValue} } /// Returns true if `mapEntry` has been explicitly set. - public var hasMapEntry: Bool {return self._mapEntry != nil} + public var hasMapEntry: Bool {self._mapEntry != nil} /// Clears the value of `mapEntry`. Subsequent reads from it will return its default value. public mutating func clearMapEntry() {self._mapEntry = nil} + /// Enable the legacy handling of JSON field name conflicts. This lowercases + /// and strips underscored from the fields before comparison in proto3 only. + /// The new behavior takes `json_name` into account and applies to proto2 as + /// well. + /// + /// This should only be used as a temporary measure against broken builds due + /// to the change in behavior for JSON field name conflicts. + /// + /// TODO This is legacy behavior we plan to remove once downstream + /// teams have had time to migrate. + /// + /// NOTE: This field was marked as deprecated in the .proto file. + public var deprecatedLegacyJsonFieldConflicts: Bool { + get {_deprecatedLegacyJsonFieldConflicts ?? false} + set {_deprecatedLegacyJsonFieldConflicts = newValue} + } + /// Returns true if `deprecatedLegacyJsonFieldConflicts` has been explicitly set. + public var hasDeprecatedLegacyJsonFieldConflicts: Bool {self._deprecatedLegacyJsonFieldConflicts != nil} + /// Clears the value of `deprecatedLegacyJsonFieldConflicts`. Subsequent reads from it will return its default value. + public mutating func clearDeprecatedLegacyJsonFieldConflicts() {self._deprecatedLegacyJsonFieldConflicts = nil} + + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + public var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + public var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + public mutating func clearFeatures() {self._features = nil} + /// The parser stores options it doesn't recognize here. See above. public var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} - public var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + public var _protobuf_extensionFieldValues = ExtensionFieldValueSet() fileprivate var _messageSetWireFormat: Bool? = nil fileprivate var _noStandardDescriptorAccessor: Bool? = nil fileprivate var _deprecated: Bool? = nil fileprivate var _mapEntry: Bool? = nil + fileprivate var _deprecatedLegacyJsonFieldConflicts: Bool? = nil + fileprivate var _features: Google_Protobuf_FeatureSet? = nil } -public struct Google_Protobuf_FieldOptions: SwiftProtobuf.ExtensibleMessage { +public struct Google_Protobuf_FieldOptions: ExtensibleMessage, @unchecked Sendable { // 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. + /// NOTE: ctype is deprecated. Use `features.(pb.cpp).string_type` instead. /// The ctype option instructs the C++ code generator to use a different /// representation of the field than it normally would. See the specific - /// options below. This option is not yet implemented in the open source - /// release -- sorry, we'll try to include it in a future version! + /// options below. This option is only implemented to support use of + /// [ctype=CORD] and [ctype=STRING] (the default) on non-repeated fields of + /// type "bytes" in the open source release. + /// TODO: make ctype actually deprecated. public var ctype: Google_Protobuf_FieldOptions.CType { - get {return _ctype ?? .string} - set {_ctype = newValue} + get {_storage._ctype ?? .string} + set {_uniqueStorage()._ctype = newValue} } /// Returns true if `ctype` has been explicitly set. - public var hasCtype: Bool {return self._ctype != nil} + public var hasCtype: Bool {_storage._ctype != nil} /// Clears the value of `ctype`. Subsequent reads from it will return its default value. - public mutating func clearCtype() {self._ctype = nil} + public mutating func clearCtype() {_uniqueStorage()._ctype = nil} /// The packed option can be enabled for repeated primitive fields to enable /// a more efficient representation on the wire. Rather than repeatedly /// writing the tag and type for each element, the entire array is encoded as /// a single length-delimited blob. In proto3, only explicit setting it to - /// false will avoid using packed encoding. + /// false will avoid using packed encoding. This option is prohibited in + /// Editions, but the `repeated_field_encoding` feature can be used to control + /// the behavior. public var packed: Bool { - get {return _packed ?? false} - set {_packed = newValue} + get {_storage._packed ?? false} + set {_uniqueStorage()._packed = newValue} } /// Returns true if `packed` has been explicitly set. - public var hasPacked: Bool {return self._packed != nil} + public var hasPacked: Bool {_storage._packed != nil} /// Clears the value of `packed`. Subsequent reads from it will return its default value. - public mutating func clearPacked() {self._packed = nil} + public mutating func clearPacked() {_uniqueStorage()._packed = nil} /// The jstype option determines the JavaScript type used for values of the /// field. The option is permitted only for 64 bit integral and fixed types @@ -1312,13 +1524,13 @@ public struct Google_Protobuf_FieldOptions: SwiftProtobuf.ExtensibleMessage { /// This option is an enum to permit additional types to be added, e.g. /// goog.math.Integer. public var jstype: Google_Protobuf_FieldOptions.JSType { - get {return _jstype ?? .jsNormal} - set {_jstype = newValue} + get {_storage._jstype ?? .jsNormal} + set {_uniqueStorage()._jstype = newValue} } /// Returns true if `jstype` has been explicitly set. - public var hasJstype: Bool {return self._jstype != nil} + public var hasJstype: Bool {_storage._jstype != nil} /// Clears the value of `jstype`. Subsequent reads from it will return its default value. - public mutating func clearJstype() {self._jstype = nil} + public mutating func clearJstype() {_uniqueStorage()._jstype = nil} /// Should this field be parsed lazily? Lazy applies only to message-type /// fields. It means that when the outer message is initially parsed, the @@ -1337,159 +1549,330 @@ public struct Google_Protobuf_FieldOptions: SwiftProtobuf.ExtensibleMessage { /// call from multiple threads concurrently, while non-const methods continue /// to require exclusive access. /// - /// - /// Note that implementations may choose not to check required fields within - /// a lazy sub-message. That is, calling IsInitialized() on the outer message - /// may return true even if the inner message has missing required fields. - /// This is necessary because otherwise the inner message would have to be - /// parsed in order to perform the check, defeating the purpose of lazy - /// parsing. An implementation which chooses not to check required fields - /// must be consistent about it. That is, for any particular sub-message, the - /// implementation must either *always* check its required fields, or *never* - /// check its required fields, regardless of whether or not the message has - /// been parsed. + /// Note that lazy message fields are still eagerly verified to check + /// ill-formed wireformat or missing required fields. Calling IsInitialized() + /// on the outer message would fail if the inner message has missing required + /// fields. Failed verification would result in parsing failure (except when + /// uninitialized messages are acceptable). public var lazy: Bool { - get {return _lazy ?? false} - set {_lazy = newValue} + get {_storage._lazy ?? false} + set {_uniqueStorage()._lazy = newValue} } /// Returns true if `lazy` has been explicitly set. - public var hasLazy: Bool {return self._lazy != nil} + public var hasLazy: Bool {_storage._lazy != nil} /// Clears the value of `lazy`. Subsequent reads from it will return its default value. - public mutating func clearLazy() {self._lazy = nil} + public mutating func clearLazy() {_uniqueStorage()._lazy = nil} + + /// unverified_lazy does no correctness checks on the byte stream. This should + /// only be used where lazy with verification is prohibitive for performance + /// reasons. + public var unverifiedLazy: Bool { + get {_storage._unverifiedLazy ?? false} + set {_uniqueStorage()._unverifiedLazy = newValue} + } + /// Returns true if `unverifiedLazy` has been explicitly set. + public var hasUnverifiedLazy: Bool {_storage._unverifiedLazy != nil} + /// Clears the value of `unverifiedLazy`. Subsequent reads from it will return its default value. + public mutating func clearUnverifiedLazy() {_uniqueStorage()._unverifiedLazy = nil} /// Is this field deprecated? /// Depending on the target platform, this can emit Deprecated annotations /// for accessors, or it will be completely ignored; in the very least, this /// is a formalization for deprecating fields. public var deprecated: Bool { - get {return _deprecated ?? false} - set {_deprecated = newValue} + get {_storage._deprecated ?? false} + set {_uniqueStorage()._deprecated = newValue} } /// Returns true if `deprecated` has been explicitly set. - public var hasDeprecated: Bool {return self._deprecated != nil} + public var hasDeprecated: Bool {_storage._deprecated != nil} /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. - public mutating func clearDeprecated() {self._deprecated = nil} + public mutating func clearDeprecated() {_uniqueStorage()._deprecated = nil} + /// DEPRECATED. DO NOT USE! /// For Google-internal migration only. Do not use. + /// + /// NOTE: This field was marked as deprecated in the .proto file. public var weak: Bool { - get {return _weak ?? false} - set {_weak = newValue} + get {_storage._weak ?? false} + set {_uniqueStorage()._weak = newValue} } /// Returns true if `weak` has been explicitly set. - public var hasWeak: Bool {return self._weak != nil} + public var hasWeak: Bool {_storage._weak != nil} /// Clears the value of `weak`. Subsequent reads from it will return its default value. - public mutating func clearWeak() {self._weak = nil} + public mutating func clearWeak() {_uniqueStorage()._weak = nil} + + /// Indicate that the field value should not be printed out when using debug + /// formats, e.g. when the field contains sensitive credentials. + public var debugRedact: Bool { + get {_storage._debugRedact ?? false} + set {_uniqueStorage()._debugRedact = newValue} + } + /// Returns true if `debugRedact` has been explicitly set. + public var hasDebugRedact: Bool {_storage._debugRedact != nil} + /// Clears the value of `debugRedact`. Subsequent reads from it will return its default value. + public mutating func clearDebugRedact() {_uniqueStorage()._debugRedact = nil} + + public var retention: Google_Protobuf_FieldOptions.OptionRetention { + get {_storage._retention ?? .retentionUnknown} + set {_uniqueStorage()._retention = newValue} + } + /// Returns true if `retention` has been explicitly set. + public var hasRetention: Bool {_storage._retention != nil} + /// Clears the value of `retention`. Subsequent reads from it will return its default value. + public mutating func clearRetention() {_uniqueStorage()._retention = nil} + + public var targets: [Google_Protobuf_FieldOptions.OptionTargetType] { + get {_storage._targets} + set {_uniqueStorage()._targets = newValue} + } + + public var editionDefaults: [Google_Protobuf_FieldOptions.EditionDefault] { + get {_storage._editionDefaults} + set {_uniqueStorage()._editionDefaults = newValue} + } + + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + public var features: Google_Protobuf_FeatureSet { + get {_storage._features ?? Google_Protobuf_FeatureSet()} + set {_uniqueStorage()._features = newValue} + } + /// Returns true if `features` has been explicitly set. + public var hasFeatures: Bool {_storage._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + public mutating func clearFeatures() {_uniqueStorage()._features = nil} + + public var featureSupport: Google_Protobuf_FieldOptions.FeatureSupport { + get {_storage._featureSupport ?? Google_Protobuf_FieldOptions.FeatureSupport()} + set {_uniqueStorage()._featureSupport = newValue} + } + /// Returns true if `featureSupport` has been explicitly set. + public var hasFeatureSupport: Bool {_storage._featureSupport != nil} + /// Clears the value of `featureSupport`. Subsequent reads from it will return its default value. + public mutating func clearFeatureSupport() {_uniqueStorage()._featureSupport = nil} /// The parser stores options it doesn't recognize here. See above. - public var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] + public var uninterpretedOption: [Google_Protobuf_UninterpretedOption] { + get {_storage._uninterpretedOption} + set {_uniqueStorage()._uninterpretedOption = newValue} + } - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() - public enum CType: SwiftProtobuf.Enum { - public typealias RawValue = Int + public enum CType: Int, Enum, Swift.CaseIterable { /// Default mode. - case string // = 0 - case cord // = 1 - case stringPiece // = 2 + case string = 0 + + /// The option [ctype=CORD] may be applied to a non-repeated field of type + /// "bytes". It indicates that in C++, the data should be stored in a Cord + /// instead of a string. For very large strings, this may reduce memory + /// fragmentation. It may also allow better performance when parsing from a + /// Cord, or when parsing with aliasing enabled, as the parsed Cord may then + /// alias the original buffer. + case cord = 1 + case stringPiece = 2 public init() { self = .string } - public init?(rawValue: Int) { - switch rawValue { - case 0: self = .string - case 1: self = .cord - case 2: self = .stringPiece - default: return nil - } - } - - public var rawValue: Int { - switch self { - case .string: return 0 - case .cord: return 1 - case .stringPiece: return 2 - } - } - } - public enum JSType: SwiftProtobuf.Enum { - public typealias RawValue = Int + public enum JSType: Int, Enum, Swift.CaseIterable { /// Use the default type. - case jsNormal // = 0 + case jsNormal = 0 /// Use JavaScript strings. - case jsString // = 1 + case jsString = 1 /// Use JavaScript numbers. - case jsNumber // = 2 + case jsNumber = 2 public init() { self = .jsNormal } - public init?(rawValue: Int) { - switch rawValue { - case 0: self = .jsNormal - case 1: self = .jsString - case 2: self = .jsNumber - default: return nil - } + } + + /// If set to RETENTION_SOURCE, the option will be omitted from the binary. + public enum OptionRetention: Int, Enum, Swift.CaseIterable { + case retentionUnknown = 0 + case retentionRuntime = 1 + case retentionSource = 2 + + public init() { + self = .retentionUnknown } - public var rawValue: Int { - switch self { - case .jsNormal: return 0 - case .jsString: return 1 - case .jsNumber: return 2 - } + } + + /// This indicates the types of entities that the field may apply to when used + /// as an option. If it is unset, then the field may be freely used as an + /// option on any kind of entity. + public enum OptionTargetType: Int, Enum, Swift.CaseIterable { + case targetTypeUnknown = 0 + case targetTypeFile = 1 + case targetTypeExtensionRange = 2 + case targetTypeMessage = 3 + case targetTypeField = 4 + case targetTypeOneof = 5 + case targetTypeEnum = 6 + case targetTypeEnumEntry = 7 + case targetTypeService = 8 + case targetTypeMethod = 9 + + public init() { + self = .targetTypeUnknown } } - public init() {} + public struct EditionDefault: Sendable { + // 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. - public var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _ctype: Google_Protobuf_FieldOptions.CType? = nil - fileprivate var _packed: Bool? = nil - fileprivate var _jstype: Google_Protobuf_FieldOptions.JSType? = nil - fileprivate var _lazy: Bool? = nil - fileprivate var _deprecated: Bool? = nil - fileprivate var _weak: Bool? = nil -} + public var edition: Google_Protobuf_Edition { + get {_edition ?? .unknown} + set {_edition = newValue} + } + /// Returns true if `edition` has been explicitly set. + public var hasEdition: Bool {self._edition != nil} + /// Clears the value of `edition`. Subsequent reads from it will return its default value. + public mutating func clearEdition() {self._edition = nil} + + /// Textproto value. + public var value: String { + get {_value ?? String()} + set {_value = newValue} + } + /// Returns true if `value` has been explicitly set. + public var hasValue: Bool {self._value != nil} + /// Clears the value of `value`. Subsequent reads from it will return its default value. + public mutating func clearValue() {self._value = nil} -#if swift(>=4.2) + public var unknownFields = UnknownStorage() -extension Google_Protobuf_FieldOptions.CType: CaseIterable { - // Support synthesized by the compiler. -} + public init() {} -extension Google_Protobuf_FieldOptions.JSType: CaseIterable { - // Support synthesized by the compiler. -} + fileprivate var _edition: Google_Protobuf_Edition? = nil + fileprivate var _value: String? = nil + } + + /// Information about the support window of a feature. + public struct FeatureSupport: Sendable { + // 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. + + /// The edition that this feature was first available in. In editions + /// earlier than this one, the default assigned to EDITION_LEGACY will be + /// used, and proto files will not be able to override it. + public var editionIntroduced: Google_Protobuf_Edition { + get {_editionIntroduced ?? .unknown} + set {_editionIntroduced = newValue} + } + /// Returns true if `editionIntroduced` has been explicitly set. + public var hasEditionIntroduced: Bool {self._editionIntroduced != nil} + /// Clears the value of `editionIntroduced`. Subsequent reads from it will return its default value. + public mutating func clearEditionIntroduced() {self._editionIntroduced = nil} + + /// The edition this feature becomes deprecated in. Using this after this + /// edition may trigger warnings. + public var editionDeprecated: Google_Protobuf_Edition { + get {_editionDeprecated ?? .unknown} + set {_editionDeprecated = newValue} + } + /// Returns true if `editionDeprecated` has been explicitly set. + public var hasEditionDeprecated: Bool {self._editionDeprecated != nil} + /// Clears the value of `editionDeprecated`. Subsequent reads from it will return its default value. + public mutating func clearEditionDeprecated() {self._editionDeprecated = nil} + + /// The deprecation warning text if this feature is used after the edition it + /// was marked deprecated in. + public var deprecationWarning: String { + get {_deprecationWarning ?? String()} + set {_deprecationWarning = newValue} + } + /// Returns true if `deprecationWarning` has been explicitly set. + public var hasDeprecationWarning: Bool {self._deprecationWarning != nil} + /// Clears the value of `deprecationWarning`. Subsequent reads from it will return its default value. + public mutating func clearDeprecationWarning() {self._deprecationWarning = nil} + + /// The edition this feature is no longer available in. In editions after + /// this one, the last default assigned will be used, and proto files will + /// not be able to override it. + public var editionRemoved: Google_Protobuf_Edition { + get {_editionRemoved ?? .unknown} + set {_editionRemoved = newValue} + } + /// Returns true if `editionRemoved` has been explicitly set. + public var hasEditionRemoved: Bool {self._editionRemoved != nil} + /// Clears the value of `editionRemoved`. Subsequent reads from it will return its default value. + public mutating func clearEditionRemoved() {self._editionRemoved = nil} + + /// The removal error text if this feature is used after the edition it was + /// removed in. + public var removalError: String { + get {_removalError ?? String()} + set {_removalError = newValue} + } + /// Returns true if `removalError` has been explicitly set. + public var hasRemovalError: Bool {self._removalError != nil} + /// Clears the value of `removalError`. Subsequent reads from it will return its default value. + public mutating func clearRemovalError() {self._removalError = nil} + + public var unknownFields = UnknownStorage() + + public init() {} + + fileprivate var _editionIntroduced: Google_Protobuf_Edition? = nil + fileprivate var _editionDeprecated: Google_Protobuf_Edition? = nil + fileprivate var _deprecationWarning: String? = nil + fileprivate var _editionRemoved: Google_Protobuf_Edition? = nil + fileprivate var _removalError: String? = nil + } -#endif // swift(>=4.2) + public init() {} + + public var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} -public struct Google_Protobuf_OneofOptions: SwiftProtobuf.ExtensibleMessage { +public struct Google_Protobuf_OneofOptions: ExtensibleMessage, Sendable { // 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. + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + public var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + public var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + public mutating func clearFeatures() {self._features = nil} + /// The parser stores options it doesn't recognize here. See above. public var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} - public var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + public var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _features: Google_Protobuf_FeatureSet? = nil } -public struct Google_Protobuf_EnumOptions: SwiftProtobuf.ExtensibleMessage { +public struct Google_Protobuf_EnumOptions: ExtensibleMessage, Sendable { // 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. @@ -1497,11 +1880,11 @@ public struct Google_Protobuf_EnumOptions: SwiftProtobuf.ExtensibleMessage { /// Set this option to true to allow mapping different tag names to the same /// value. public var allowAlias: Bool { - get {return _allowAlias ?? false} + get {_allowAlias ?? false} set {_allowAlias = newValue} } /// Returns true if `allowAlias` has been explicitly set. - public var hasAllowAlias: Bool {return self._allowAlias != nil} + public var hasAllowAlias: Bool {self._allowAlias != nil} /// Clears the value of `allowAlias`. Subsequent reads from it will return its default value. public mutating func clearAllowAlias() {self._allowAlias = nil} @@ -1510,27 +1893,59 @@ public struct Google_Protobuf_EnumOptions: SwiftProtobuf.ExtensibleMessage { /// for the enum, or it will be completely ignored; in the very least, this /// is a formalization for deprecating enums. public var deprecated: Bool { - get {return _deprecated ?? false} + get {_deprecated ?? false} set {_deprecated = newValue} } /// Returns true if `deprecated` has been explicitly set. - public var hasDeprecated: Bool {return self._deprecated != nil} + public var hasDeprecated: Bool {self._deprecated != nil} /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. public mutating func clearDeprecated() {self._deprecated = nil} + /// Enable the legacy handling of JSON field name conflicts. This lowercases + /// and strips underscored from the fields before comparison in proto3 only. + /// The new behavior takes `json_name` into account and applies to proto2 as + /// well. + /// TODO Remove this legacy behavior once downstream teams have + /// had time to migrate. + /// + /// NOTE: This field was marked as deprecated in the .proto file. + public var deprecatedLegacyJsonFieldConflicts: Bool { + get {_deprecatedLegacyJsonFieldConflicts ?? false} + set {_deprecatedLegacyJsonFieldConflicts = newValue} + } + /// Returns true if `deprecatedLegacyJsonFieldConflicts` has been explicitly set. + public var hasDeprecatedLegacyJsonFieldConflicts: Bool {self._deprecatedLegacyJsonFieldConflicts != nil} + /// Clears the value of `deprecatedLegacyJsonFieldConflicts`. Subsequent reads from it will return its default value. + public mutating func clearDeprecatedLegacyJsonFieldConflicts() {self._deprecatedLegacyJsonFieldConflicts = nil} + + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + public var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + public var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + public mutating func clearFeatures() {self._features = nil} + /// The parser stores options it doesn't recognize here. See above. public var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} - public var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + public var _protobuf_extensionFieldValues = ExtensionFieldValueSet() fileprivate var _allowAlias: Bool? = nil fileprivate var _deprecated: Bool? = nil + fileprivate var _deprecatedLegacyJsonFieldConflicts: Bool? = nil + fileprivate var _features: Google_Protobuf_FeatureSet? = nil } -public struct Google_Protobuf_EnumValueOptions: SwiftProtobuf.ExtensibleMessage { +public struct Google_Protobuf_EnumValueOptions: ExtensibleMessage, Sendable { // 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. @@ -1540,55 +1955,107 @@ public struct Google_Protobuf_EnumValueOptions: SwiftProtobuf.ExtensibleMessage /// for the enum value, or it will be completely ignored; in the very least, /// this is a formalization for deprecating enum values. public var deprecated: Bool { - get {return _deprecated ?? false} + get {_deprecated ?? false} set {_deprecated = newValue} } /// Returns true if `deprecated` has been explicitly set. - public var hasDeprecated: Bool {return self._deprecated != nil} + public var hasDeprecated: Bool {self._deprecated != nil} /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. public mutating func clearDeprecated() {self._deprecated = nil} + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + public var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + public var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + public mutating func clearFeatures() {self._features = nil} + + /// Indicate that fields annotated with this enum value should not be printed + /// out when using debug formats, e.g. when the field contains sensitive + /// credentials. + public var debugRedact: Bool { + get {_debugRedact ?? false} + set {_debugRedact = newValue} + } + /// Returns true if `debugRedact` has been explicitly set. + public var hasDebugRedact: Bool {self._debugRedact != nil} + /// Clears the value of `debugRedact`. Subsequent reads from it will return its default value. + public mutating func clearDebugRedact() {self._debugRedact = nil} + + /// Information about the support window of a feature value. + public var featureSupport: Google_Protobuf_FieldOptions.FeatureSupport { + get {_featureSupport ?? Google_Protobuf_FieldOptions.FeatureSupport()} + set {_featureSupport = newValue} + } + /// Returns true if `featureSupport` has been explicitly set. + public var hasFeatureSupport: Bool {self._featureSupport != nil} + /// Clears the value of `featureSupport`. Subsequent reads from it will return its default value. + public mutating func clearFeatureSupport() {self._featureSupport = nil} + /// The parser stores options it doesn't recognize here. See above. public var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} - public var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + public var _protobuf_extensionFieldValues = ExtensionFieldValueSet() fileprivate var _deprecated: Bool? = nil + fileprivate var _features: Google_Protobuf_FeatureSet? = nil + fileprivate var _debugRedact: Bool? = nil + fileprivate var _featureSupport: Google_Protobuf_FieldOptions.FeatureSupport? = nil } -public struct Google_Protobuf_ServiceOptions: SwiftProtobuf.ExtensibleMessage { +public struct Google_Protobuf_ServiceOptions: ExtensibleMessage, Sendable { // 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. + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + public var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + public var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + public mutating func clearFeatures() {self._features = nil} + /// Is this service deprecated? /// Depending on the target platform, this can emit Deprecated annotations /// for the service, or it will be completely ignored; in the very least, /// this is a formalization for deprecating services. public var deprecated: Bool { - get {return _deprecated ?? false} + get {_deprecated ?? false} set {_deprecated = newValue} } /// Returns true if `deprecated` has been explicitly set. - public var hasDeprecated: Bool {return self._deprecated != nil} + public var hasDeprecated: Bool {self._deprecated != nil} /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. public mutating func clearDeprecated() {self._deprecated = nil} /// The parser stores options it doesn't recognize here. See above. public var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} - public var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + public var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _features: Google_Protobuf_FeatureSet? = nil fileprivate var _deprecated: Bool? = nil } -public struct Google_Protobuf_MethodOptions: SwiftProtobuf.ExtensibleMessage { +public struct Google_Protobuf_MethodOptions: ExtensibleMessage, Sendable { // 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. @@ -1598,86 +2065,74 @@ public struct Google_Protobuf_MethodOptions: SwiftProtobuf.ExtensibleMessage { /// for the method, or it will be completely ignored; in the very least, /// this is a formalization for deprecating methods. public var deprecated: Bool { - get {return _deprecated ?? false} + get {_deprecated ?? false} set {_deprecated = newValue} } /// Returns true if `deprecated` has been explicitly set. - public var hasDeprecated: Bool {return self._deprecated != nil} + public var hasDeprecated: Bool {self._deprecated != nil} /// Clears the value of `deprecated`. Subsequent reads from it will return its default value. public mutating func clearDeprecated() {self._deprecated = nil} public var idempotencyLevel: Google_Protobuf_MethodOptions.IdempotencyLevel { - get {return _idempotencyLevel ?? .idempotencyUnknown} + get {_idempotencyLevel ?? .idempotencyUnknown} set {_idempotencyLevel = newValue} } /// Returns true if `idempotencyLevel` has been explicitly set. - public var hasIdempotencyLevel: Bool {return self._idempotencyLevel != nil} + public var hasIdempotencyLevel: Bool {self._idempotencyLevel != nil} /// Clears the value of `idempotencyLevel`. Subsequent reads from it will return its default value. public mutating func clearIdempotencyLevel() {self._idempotencyLevel = nil} + /// Any features defined in the specific edition. + /// WARNING: This field should only be used by protobuf plugins or special + /// cases like the proto compiler. Other uses are discouraged and + /// developers should rely on the protoreflect APIs for their client language. + public var features: Google_Protobuf_FeatureSet { + get {_features ?? Google_Protobuf_FeatureSet()} + set {_features = newValue} + } + /// Returns true if `features` has been explicitly set. + public var hasFeatures: Bool {self._features != nil} + /// Clears the value of `features`. Subsequent reads from it will return its default value. + public mutating func clearFeatures() {self._features = nil} + /// The parser stores options it doesn't recognize here. See above. public var uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() /// Is this method side-effect-free (or safe in HTTP parlance), or idempotent, /// or neither? HTTP based RPC implementation may choose GET verb for safe /// methods, and PUT verb for idempotent methods instead of the default POST. - public enum IdempotencyLevel: SwiftProtobuf.Enum { - public typealias RawValue = Int - case idempotencyUnknown // = 0 + public enum IdempotencyLevel: Int, Enum, Swift.CaseIterable { + case idempotencyUnknown = 0 /// implies idempotent - case noSideEffects // = 1 + case noSideEffects = 1 /// idempotent, but may have side effects - case idempotent // = 2 + case idempotent = 2 public init() { self = .idempotencyUnknown } - public init?(rawValue: Int) { - switch rawValue { - case 0: self = .idempotencyUnknown - case 1: self = .noSideEffects - case 2: self = .idempotent - default: return nil - } - } - - public var rawValue: Int { - switch self { - case .idempotencyUnknown: return 0 - case .noSideEffects: return 1 - case .idempotent: return 2 - } - } - } public init() {} - public var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + public var _protobuf_extensionFieldValues = ExtensionFieldValueSet() fileprivate var _deprecated: Bool? = nil fileprivate var _idempotencyLevel: Google_Protobuf_MethodOptions.IdempotencyLevel? = nil + fileprivate var _features: Google_Protobuf_FeatureSet? = nil } -#if swift(>=4.2) - -extension Google_Protobuf_MethodOptions.IdempotencyLevel: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - /// A message representing a option the parser does not recognize. This only /// appears in options protos created by the compiler::Parser class. /// DescriptorPool resolves these when building Descriptor objects. Therefore, /// options protos in descriptor objects (e.g. returned by Descriptor::options(), /// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions /// in them. -public struct Google_Protobuf_UninterpretedOption { +public struct Google_Protobuf_UninterpretedOption: Sendable { // 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. @@ -1687,90 +2142,90 @@ public struct Google_Protobuf_UninterpretedOption { /// The value of the uninterpreted option, in whatever type the tokenizer /// identified it as during parsing. Exactly one of these should be set. public var identifierValue: String { - get {return _identifierValue ?? String()} + get {_identifierValue ?? String()} set {_identifierValue = newValue} } /// Returns true if `identifierValue` has been explicitly set. - public var hasIdentifierValue: Bool {return self._identifierValue != nil} + public var hasIdentifierValue: Bool {self._identifierValue != nil} /// Clears the value of `identifierValue`. Subsequent reads from it will return its default value. public mutating func clearIdentifierValue() {self._identifierValue = nil} public var positiveIntValue: UInt64 { - get {return _positiveIntValue ?? 0} + get {_positiveIntValue ?? 0} set {_positiveIntValue = newValue} } /// Returns true if `positiveIntValue` has been explicitly set. - public var hasPositiveIntValue: Bool {return self._positiveIntValue != nil} + public var hasPositiveIntValue: Bool {self._positiveIntValue != nil} /// Clears the value of `positiveIntValue`. Subsequent reads from it will return its default value. public mutating func clearPositiveIntValue() {self._positiveIntValue = nil} public var negativeIntValue: Int64 { - get {return _negativeIntValue ?? 0} + get {_negativeIntValue ?? 0} set {_negativeIntValue = newValue} } /// Returns true if `negativeIntValue` has been explicitly set. - public var hasNegativeIntValue: Bool {return self._negativeIntValue != nil} + public var hasNegativeIntValue: Bool {self._negativeIntValue != nil} /// Clears the value of `negativeIntValue`. Subsequent reads from it will return its default value. public mutating func clearNegativeIntValue() {self._negativeIntValue = nil} public var doubleValue: Double { - get {return _doubleValue ?? 0} + get {_doubleValue ?? 0} set {_doubleValue = newValue} } /// Returns true if `doubleValue` has been explicitly set. - public var hasDoubleValue: Bool {return self._doubleValue != nil} + public var hasDoubleValue: Bool {self._doubleValue != nil} /// Clears the value of `doubleValue`. Subsequent reads from it will return its default value. public mutating func clearDoubleValue() {self._doubleValue = nil} public var stringValue: Data { - get {return _stringValue ?? Data()} + get {_stringValue ?? Data()} set {_stringValue = newValue} } /// Returns true if `stringValue` has been explicitly set. - public var hasStringValue: Bool {return self._stringValue != nil} + public var hasStringValue: Bool {self._stringValue != nil} /// Clears the value of `stringValue`. Subsequent reads from it will return its default value. public mutating func clearStringValue() {self._stringValue = nil} public var aggregateValue: String { - get {return _aggregateValue ?? String()} + get {_aggregateValue ?? String()} set {_aggregateValue = newValue} } /// Returns true if `aggregateValue` has been explicitly set. - public var hasAggregateValue: Bool {return self._aggregateValue != nil} + public var hasAggregateValue: Bool {self._aggregateValue != nil} /// Clears the value of `aggregateValue`. Subsequent reads from it will return its default value. public mutating func clearAggregateValue() {self._aggregateValue = nil} - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() /// The name of the uninterpreted option. Each string represents a segment in /// a dot-separated name. is_extension is true iff a segment represents an /// extension (denoted with parentheses in options specs in .proto files). - /// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents - /// "foo.(bar.baz).qux". - public struct NamePart { + /// E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents + /// "foo.(bar.baz).moo". + public struct NamePart: Sendable { // 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. public var namePart: String { - get {return _namePart ?? String()} + get {_namePart ?? String()} set {_namePart = newValue} } /// Returns true if `namePart` has been explicitly set. - public var hasNamePart: Bool {return self._namePart != nil} + public var hasNamePart: Bool {self._namePart != nil} /// Clears the value of `namePart`. Subsequent reads from it will return its default value. public mutating func clearNamePart() {self._namePart = nil} public var isExtension: Bool { - get {return _isExtension ?? false} + get {_isExtension ?? false} set {_isExtension = newValue} } /// Returns true if `isExtension` has been explicitly set. - public var hasIsExtension: Bool {return self._isExtension != nil} + public var hasIsExtension: Bool {self._isExtension != nil} /// Clears the value of `isExtension`. Subsequent reads from it will return its default value. public mutating func clearIsExtension() {self._isExtension = nil} - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} @@ -1788,20 +2243,315 @@ public struct Google_Protobuf_UninterpretedOption { fileprivate var _aggregateValue: String? = nil } -/// Encapsulates information about the original source file from which a -/// FileDescriptorProto was generated. -public struct Google_Protobuf_SourceCodeInfo { +/// TODO Enums in C++ gencode (and potentially other languages) are +/// not well scoped. This means that each of the feature enums below can clash +/// with each other. The short names we've chosen maximize call-site +/// readability, but leave us very open to this scenario. A future feature will +/// be designed and implemented to handle this, hopefully before we ever hit a +/// conflict here. +public struct Google_Protobuf_FeatureSet: ExtensibleMessage, Sendable { // 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. - /// A Location identifies a piece of source code in a .proto file which - /// corresponds to a particular definition. This information is intended - /// to be useful to IDEs, code indexers, documentation generators, and similar - /// tools. - /// - /// For example, say we have a file like: - /// message Foo { + public var fieldPresence: Google_Protobuf_FeatureSet.FieldPresence { + get {_fieldPresence ?? .unknown} + set {_fieldPresence = newValue} + } + /// Returns true if `fieldPresence` has been explicitly set. + public var hasFieldPresence: Bool {self._fieldPresence != nil} + /// Clears the value of `fieldPresence`. Subsequent reads from it will return its default value. + public mutating func clearFieldPresence() {self._fieldPresence = nil} + + public var enumType: Google_Protobuf_FeatureSet.EnumType { + get {_enumType ?? .unknown} + set {_enumType = newValue} + } + /// Returns true if `enumType` has been explicitly set. + public var hasEnumType: Bool {self._enumType != nil} + /// Clears the value of `enumType`. Subsequent reads from it will return its default value. + public mutating func clearEnumType() {self._enumType = nil} + + public var repeatedFieldEncoding: Google_Protobuf_FeatureSet.RepeatedFieldEncoding { + get {_repeatedFieldEncoding ?? .unknown} + set {_repeatedFieldEncoding = newValue} + } + /// Returns true if `repeatedFieldEncoding` has been explicitly set. + public var hasRepeatedFieldEncoding: Bool {self._repeatedFieldEncoding != nil} + /// Clears the value of `repeatedFieldEncoding`. Subsequent reads from it will return its default value. + public mutating func clearRepeatedFieldEncoding() {self._repeatedFieldEncoding = nil} + + public var utf8Validation: Google_Protobuf_FeatureSet.Utf8Validation { + get {_utf8Validation ?? .unknown} + set {_utf8Validation = newValue} + } + /// Returns true if `utf8Validation` has been explicitly set. + public var hasUtf8Validation: Bool {self._utf8Validation != nil} + /// Clears the value of `utf8Validation`. Subsequent reads from it will return its default value. + public mutating func clearUtf8Validation() {self._utf8Validation = nil} + + public var messageEncoding: Google_Protobuf_FeatureSet.MessageEncoding { + get {_messageEncoding ?? .unknown} + set {_messageEncoding = newValue} + } + /// Returns true if `messageEncoding` has been explicitly set. + public var hasMessageEncoding: Bool {self._messageEncoding != nil} + /// Clears the value of `messageEncoding`. Subsequent reads from it will return its default value. + public mutating func clearMessageEncoding() {self._messageEncoding = nil} + + public var jsonFormat: Google_Protobuf_FeatureSet.JsonFormat { + get {_jsonFormat ?? .unknown} + set {_jsonFormat = newValue} + } + /// Returns true if `jsonFormat` has been explicitly set. + public var hasJsonFormat: Bool {self._jsonFormat != nil} + /// Clears the value of `jsonFormat`. Subsequent reads from it will return its default value. + public mutating func clearJsonFormat() {self._jsonFormat = nil} + + public var enforceNamingStyle: Google_Protobuf_FeatureSet.EnforceNamingStyle { + get {_enforceNamingStyle ?? .unknown} + set {_enforceNamingStyle = newValue} + } + /// Returns true if `enforceNamingStyle` has been explicitly set. + public var hasEnforceNamingStyle: Bool {self._enforceNamingStyle != nil} + /// Clears the value of `enforceNamingStyle`. Subsequent reads from it will return its default value. + public mutating func clearEnforceNamingStyle() {self._enforceNamingStyle = nil} + + public var defaultSymbolVisibility: Google_Protobuf_FeatureSet.VisibilityFeature.DefaultSymbolVisibility { + get {_defaultSymbolVisibility ?? .unknown} + set {_defaultSymbolVisibility = newValue} + } + /// Returns true if `defaultSymbolVisibility` has been explicitly set. + public var hasDefaultSymbolVisibility: Bool {self._defaultSymbolVisibility != nil} + /// Clears the value of `defaultSymbolVisibility`. Subsequent reads from it will return its default value. + public mutating func clearDefaultSymbolVisibility() {self._defaultSymbolVisibility = nil} + + public var unknownFields = UnknownStorage() + + public enum FieldPresence: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case explicit = 1 + case implicit = 2 + case legacyRequired = 3 + + public init() { + self = .unknown + } + + } + + public enum EnumType: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case `open` = 1 + case closed = 2 + + public init() { + self = .unknown + } + + } + + public enum RepeatedFieldEncoding: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case packed = 1 + case expanded = 2 + + public init() { + self = .unknown + } + + } + + public enum Utf8Validation: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case verify = 2 + case none = 3 + + public init() { + self = .unknown + } + + } + + public enum MessageEncoding: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case lengthPrefixed = 1 + case delimited = 2 + + public init() { + self = .unknown + } + + } + + public enum JsonFormat: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case allow = 1 + case legacyBestEffort = 2 + + public init() { + self = .unknown + } + + } + + public enum EnforceNamingStyle: Int, Enum, Swift.CaseIterable { + case unknown = 0 + case style2024 = 1 + case styleLegacy = 2 + + public init() { + self = .unknown + } + + } + + public struct VisibilityFeature: Sendable { + // 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. + + public var unknownFields = UnknownStorage() + + public enum DefaultSymbolVisibility: Int, Enum, Swift.CaseIterable { + case unknown = 0 + + /// Default pre-EDITION_2024, all UNSET visibility are export. + case exportAll = 1 + + /// All top-level symbols default to export, nested default to local. + case exportTopLevel = 2 + + /// All symbols default to local. + case localAll = 3 + + /// All symbols local by default. Nested types cannot be exported. + /// With special case caveat for message { enum {} reserved 1 to max; } + /// This is the recommended setting for new protos. + case strict = 4 + + public init() { + self = .unknown + } + + } + + public init() {} + } + + public init() {} + + public var _protobuf_extensionFieldValues = ExtensionFieldValueSet() + fileprivate var _fieldPresence: Google_Protobuf_FeatureSet.FieldPresence? = nil + fileprivate var _enumType: Google_Protobuf_FeatureSet.EnumType? = nil + fileprivate var _repeatedFieldEncoding: Google_Protobuf_FeatureSet.RepeatedFieldEncoding? = nil + fileprivate var _utf8Validation: Google_Protobuf_FeatureSet.Utf8Validation? = nil + fileprivate var _messageEncoding: Google_Protobuf_FeatureSet.MessageEncoding? = nil + fileprivate var _jsonFormat: Google_Protobuf_FeatureSet.JsonFormat? = nil + fileprivate var _enforceNamingStyle: Google_Protobuf_FeatureSet.EnforceNamingStyle? = nil + fileprivate var _defaultSymbolVisibility: Google_Protobuf_FeatureSet.VisibilityFeature.DefaultSymbolVisibility? = nil +} + +/// A compiled specification for the defaults of a set of features. These +/// messages are generated from FeatureSet extensions and can be used to seed +/// feature resolution. The resolution with this object becomes a simple search +/// for the closest matching edition, followed by proto merges. +public struct Google_Protobuf_FeatureSetDefaults: Sendable { + // 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. + + public var defaults: [Google_Protobuf_FeatureSetDefaults.FeatureSetEditionDefault] = [] + + /// The minimum supported edition (inclusive) when this was constructed. + /// Editions before this will not have defaults. + public var minimumEdition: Google_Protobuf_Edition { + get {_minimumEdition ?? .unknown} + set {_minimumEdition = newValue} + } + /// Returns true if `minimumEdition` has been explicitly set. + public var hasMinimumEdition: Bool {self._minimumEdition != nil} + /// Clears the value of `minimumEdition`. Subsequent reads from it will return its default value. + public mutating func clearMinimumEdition() {self._minimumEdition = nil} + + /// The maximum known edition (inclusive) when this was constructed. Editions + /// after this will not have reliable defaults. + public var maximumEdition: Google_Protobuf_Edition { + get {_maximumEdition ?? .unknown} + set {_maximumEdition = newValue} + } + /// Returns true if `maximumEdition` has been explicitly set. + public var hasMaximumEdition: Bool {self._maximumEdition != nil} + /// Clears the value of `maximumEdition`. Subsequent reads from it will return its default value. + public mutating func clearMaximumEdition() {self._maximumEdition = nil} + + public var unknownFields = UnknownStorage() + + /// A map from every known edition with a unique set of defaults to its + /// defaults. Not all editions may be contained here. For a given edition, + /// the defaults at the closest matching edition ordered at or before it should + /// be used. This field must be in strict ascending order by edition. + public struct FeatureSetEditionDefault: @unchecked Sendable { + // 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. + + public var edition: Google_Protobuf_Edition { + get {_storage._edition ?? .unknown} + set {_uniqueStorage()._edition = newValue} + } + /// Returns true if `edition` has been explicitly set. + public var hasEdition: Bool {_storage._edition != nil} + /// Clears the value of `edition`. Subsequent reads from it will return its default value. + public mutating func clearEdition() {_uniqueStorage()._edition = nil} + + /// Defaults of features that can be overridden in this edition. + public var overridableFeatures: Google_Protobuf_FeatureSet { + get {_storage._overridableFeatures ?? Google_Protobuf_FeatureSet()} + set {_uniqueStorage()._overridableFeatures = newValue} + } + /// Returns true if `overridableFeatures` has been explicitly set. + public var hasOverridableFeatures: Bool {_storage._overridableFeatures != nil} + /// Clears the value of `overridableFeatures`. Subsequent reads from it will return its default value. + public mutating func clearOverridableFeatures() {_uniqueStorage()._overridableFeatures = nil} + + /// Defaults of features that can't be overridden in this edition. + public var fixedFeatures: Google_Protobuf_FeatureSet { + get {_storage._fixedFeatures ?? Google_Protobuf_FeatureSet()} + set {_uniqueStorage()._fixedFeatures = newValue} + } + /// Returns true if `fixedFeatures` has been explicitly set. + public var hasFixedFeatures: Bool {_storage._fixedFeatures != nil} + /// Clears the value of `fixedFeatures`. Subsequent reads from it will return its default value. + public mutating func clearFixedFeatures() {_uniqueStorage()._fixedFeatures = nil} + + public var unknownFields = UnknownStorage() + + public init() {} + + fileprivate var _storage = _StorageClass.defaultInstance + } + + public init() {} + + fileprivate var _minimumEdition: Google_Protobuf_Edition? = nil + fileprivate var _maximumEdition: Google_Protobuf_Edition? = nil +} + +/// Encapsulates information about the original source file from which a +/// FileDescriptorProto was generated. +public struct Google_Protobuf_SourceCodeInfo: ExtensibleMessage, Sendable { + // 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. + + /// A Location identifies a piece of source code in a .proto file which + /// corresponds to a particular definition. This information is intended + /// to be useful to IDEs, code indexers, documentation generators, and similar + /// tools. + /// + /// For example, say we have a file like: + /// message Foo { /// optional string foo = 1; /// } /// Let's look at just the field definition: @@ -1840,9 +2590,9 @@ public struct Google_Protobuf_SourceCodeInfo { /// be recorded in the future. public var location: [Google_Protobuf_SourceCodeInfo.Location] = [] - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() - public struct Location { + public struct Location: Sendable { // 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. @@ -1851,8 +2601,8 @@ public struct Google_Protobuf_SourceCodeInfo { /// location. /// /// Each element is a field number or an index. They form a path from - /// the root FileDescriptorProto to the place where the definition. For - /// example, this path: + /// the root FileDescriptorProto to the place where the definition appears. + /// For example, this path: /// [ 4, 3, 2, 7, 1 ] /// refers to: /// file.message_type(3) // 4, 3 @@ -1906,13 +2656,13 @@ public struct Google_Protobuf_SourceCodeInfo { /// // Comment attached to baz. /// // Another line attached to baz. /// - /// // Comment attached to qux. + /// // Comment attached to moo. /// // - /// // Another line attached to qux. - /// optional double qux = 4; + /// // Another line attached to moo. + /// optional double moo = 4; /// /// // Detached comment for corge. This is not leading or trailing comments - /// // to qux or corge because there are blank lines separating it from + /// // to moo or corge because there are blank lines separating it from /// // both. /// /// // Detached comment for corge paragraph 2. @@ -1927,26 +2677,26 @@ public struct Google_Protobuf_SourceCodeInfo { /// /// // ignored detached comments. public var leadingComments: String { - get {return _leadingComments ?? String()} + get {_leadingComments ?? String()} set {_leadingComments = newValue} } /// Returns true if `leadingComments` has been explicitly set. - public var hasLeadingComments: Bool {return self._leadingComments != nil} + public var hasLeadingComments: Bool {self._leadingComments != nil} /// Clears the value of `leadingComments`. Subsequent reads from it will return its default value. public mutating func clearLeadingComments() {self._leadingComments = nil} public var trailingComments: String { - get {return _trailingComments ?? String()} + get {_trailingComments ?? String()} set {_trailingComments = newValue} } /// Returns true if `trailingComments` has been explicitly set. - public var hasTrailingComments: Bool {return self._trailingComments != nil} + public var hasTrailingComments: Bool {self._trailingComments != nil} /// Clears the value of `trailingComments`. Subsequent reads from it will return its default value. public mutating func clearTrailingComments() {self._trailingComments = nil} public var leadingDetachedComments: [String] = [] - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} @@ -1955,12 +2705,14 @@ public struct Google_Protobuf_SourceCodeInfo { } public init() {} + + public var _protobuf_extensionFieldValues = ExtensionFieldValueSet() } /// Describes the relationship between generated code and its original source /// file. A GeneratedCodeInfo message is associated with only one generated /// source file, but may contain references to different source .proto files. -public struct Google_Protobuf_GeneratedCodeInfo { +public struct Google_Protobuf_GeneratedCodeInfo: Sendable { // 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. @@ -1969,9 +2721,9 @@ public struct Google_Protobuf_GeneratedCodeInfo { /// of its generating .proto file. public var annotation: [Google_Protobuf_GeneratedCodeInfo.Annotation] = [] - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() - public struct Annotation { + public struct Annotation: Sendable { // 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. @@ -1982,153 +2734,145 @@ public struct Google_Protobuf_GeneratedCodeInfo { /// Identifies the filesystem path to the original source .proto. public var sourceFile: String { - get {return _sourceFile ?? String()} + get {_sourceFile ?? String()} set {_sourceFile = newValue} } /// Returns true if `sourceFile` has been explicitly set. - public var hasSourceFile: Bool {return self._sourceFile != nil} + public var hasSourceFile: Bool {self._sourceFile != nil} /// Clears the value of `sourceFile`. Subsequent reads from it will return its default value. public mutating func clearSourceFile() {self._sourceFile = nil} /// Identifies the starting offset in bytes in the generated code /// that relates to the identified object. public var begin: Int32 { - get {return _begin ?? 0} + get {_begin ?? 0} set {_begin = newValue} } /// Returns true if `begin` has been explicitly set. - public var hasBegin: Bool {return self._begin != nil} + public var hasBegin: Bool {self._begin != nil} /// Clears the value of `begin`. Subsequent reads from it will return its default value. public mutating func clearBegin() {self._begin = nil} /// Identifies the ending offset in bytes in the generated code that - /// relates to the identified offset. The end offset should be one past + /// relates to the identified object. The end offset should be one past /// the last relevant byte (so the length of the text = end - begin). public var end: Int32 { - get {return _end ?? 0} + get {_end ?? 0} set {_end = newValue} } /// Returns true if `end` has been explicitly set. - public var hasEnd: Bool {return self._end != nil} + public var hasEnd: Bool {self._end != nil} /// Clears the value of `end`. Subsequent reads from it will return its default value. public mutating func clearEnd() {self._end = nil} - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var semantic: Google_Protobuf_GeneratedCodeInfo.Annotation.Semantic { + get {_semantic ?? .none} + set {_semantic = newValue} + } + /// Returns true if `semantic` has been explicitly set. + public var hasSemantic: Bool {self._semantic != nil} + /// Clears the value of `semantic`. Subsequent reads from it will return its default value. + public mutating func clearSemantic() {self._semantic = nil} + + public var unknownFields = UnknownStorage() + + /// Represents the identified object's effect on the element in the original + /// .proto file. + public enum Semantic: Int, Enum, Swift.CaseIterable { + + /// There is no effect or the effect is indescribable. + case none = 0 + + /// The element is set or otherwise mutated. + case set = 1 + + /// An alias to the element is returned. + case alias = 2 + + public init() { + self = .none + } + + } public init() {} fileprivate var _sourceFile: String? = nil fileprivate var _begin: Int32? = nil fileprivate var _end: Int32? = nil + fileprivate var _semantic: Google_Protobuf_GeneratedCodeInfo.Annotation.Semantic? = nil } public init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_FileDescriptorSet: @unchecked Sendable {} -extension Google_Protobuf_FileDescriptorProto: @unchecked Sendable {} -extension Google_Protobuf_DescriptorProto: @unchecked Sendable {} -extension Google_Protobuf_DescriptorProto.ExtensionRange: @unchecked Sendable {} -extension Google_Protobuf_DescriptorProto.ReservedRange: @unchecked Sendable {} -extension Google_Protobuf_ExtensionRangeOptions: @unchecked Sendable {} -extension Google_Protobuf_FieldDescriptorProto: @unchecked Sendable {} -extension Google_Protobuf_FieldDescriptorProto.TypeEnum: @unchecked Sendable {} -extension Google_Protobuf_FieldDescriptorProto.Label: @unchecked Sendable {} -extension Google_Protobuf_OneofDescriptorProto: @unchecked Sendable {} -extension Google_Protobuf_EnumDescriptorProto: @unchecked Sendable {} -extension Google_Protobuf_EnumDescriptorProto.EnumReservedRange: @unchecked Sendable {} -extension Google_Protobuf_EnumValueDescriptorProto: @unchecked Sendable {} -extension Google_Protobuf_ServiceDescriptorProto: @unchecked Sendable {} -extension Google_Protobuf_MethodDescriptorProto: @unchecked Sendable {} -extension Google_Protobuf_FileOptions: @unchecked Sendable {} -extension Google_Protobuf_FileOptions.OptimizeMode: @unchecked Sendable {} -extension Google_Protobuf_MessageOptions: @unchecked Sendable {} -extension Google_Protobuf_FieldOptions: @unchecked Sendable {} -extension Google_Protobuf_FieldOptions.CType: @unchecked Sendable {} -extension Google_Protobuf_FieldOptions.JSType: @unchecked Sendable {} -extension Google_Protobuf_OneofOptions: @unchecked Sendable {} -extension Google_Protobuf_EnumOptions: @unchecked Sendable {} -extension Google_Protobuf_EnumValueOptions: @unchecked Sendable {} -extension Google_Protobuf_ServiceOptions: @unchecked Sendable {} -extension Google_Protobuf_MethodOptions: @unchecked Sendable {} -extension Google_Protobuf_MethodOptions.IdempotencyLevel: @unchecked Sendable {} -extension Google_Protobuf_UninterpretedOption: @unchecked Sendable {} -extension Google_Protobuf_UninterpretedOption.NamePart: @unchecked Sendable {} -extension Google_Protobuf_SourceCodeInfo: @unchecked Sendable {} -extension Google_Protobuf_SourceCodeInfo.Location: @unchecked Sendable {} -extension Google_Protobuf_GeneratedCodeInfo: @unchecked Sendable {} -extension Google_Protobuf_GeneratedCodeInfo.Annotation: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_FileDescriptorSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Edition: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0EDITION_UNKNOWN\0\u{1}EDITION_1_TEST_ONLY\0\u{1}EDITION_2_TEST_ONLY\0\u{2}B\u{e}EDITION_LEGACY\0\u{2}b\u{1}EDITION_PROTO2\0\u{1}EDITION_PROTO3\0\u{1}EDITION_2023\0\u{1}EDITION_2024\0\u{2}fL\u{2}EDITION_UNSTABLE\0\u{2}N~\u{15}EDITION_99997_TEST_ONLY\0\u{1}EDITION_99998_TEST_ONLY\0\u{1}EDITION_99999_TEST_ONLY\0\u{2}`eg\u{7f}\u{7f}\u{1}EDITION_MAX\0") +} + +extension Google_Protobuf_SymbolVisibility: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0VISIBILITY_UNSET\0\u{1}VISIBILITY_LOCAL\0\u{1}VISIBILITY_EXPORT\0") +} + +extension Google_Protobuf_FileDescriptorSet: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".FileDescriptorSet" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "file"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}file\0") public var isInitialized: Bool { - if !SwiftProtobuf.Internal.areAllInitialized(self.file) {return false} + if !_protobuf_extensionFieldValues.isInitialized {return false} + if !Internal.areAllInitialized(self.file) {return false} return true } - public mutating func decodeMessage(decoder: inout D) throws { + public 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.decodeRepeatedMessageField(value: &self.file) }() + case 536000000: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_FileDescriptorSet.self, fieldNumber: fieldNumber) }() default: break } } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if !self.file.isEmpty { try visitor.visitRepeatedMessageField(value: self.file, fieldNumber: 1) } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 536000000, end: 536000001) try unknownFields.traverse(visitor: &visitor) } public static func ==(lhs: Google_Protobuf_FileDescriptorSet, rhs: Google_Protobuf_FileDescriptorSet) -> Bool { if lhs.file != rhs.file {return false} if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_FileDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".FileDescriptorProto" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "package"), - 3: .same(proto: "dependency"), - 10: .standard(proto: "public_dependency"), - 11: .standard(proto: "weak_dependency"), - 4: .standard(proto: "message_type"), - 5: .standard(proto: "enum_type"), - 6: .same(proto: "service"), - 7: .same(proto: "extension"), - 8: .same(proto: "options"), - 9: .standard(proto: "source_code_info"), - 12: .same(proto: "syntax"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}package\0\u{1}dependency\0\u{3}message_type\0\u{3}enum_type\0\u{1}service\0\u{1}extension\0\u{1}options\0\u{3}source_code_info\0\u{3}public_dependency\0\u{3}weak_dependency\0\u{1}syntax\0\u{2}\u{2}edition\0\u{3}option_dependency\0") public var isInitialized: Bool { - if !SwiftProtobuf.Internal.areAllInitialized(self.messageType) {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.enumType) {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.service) {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.`extension`) {return false} + if !Internal.areAllInitialized(self.messageType) {return false} + if !Internal.areAllInitialized(self.enumType) {return false} + if !Internal.areAllInitialized(self.service) {return false} + if !Internal.areAllInitialized(self.`extension`) {return false} if let v = self._options, !v.isInitialized {return false} + if let v = self._sourceCodeInfo, !v.isInitialized {return false} return true } - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -2146,12 +2890,14 @@ extension Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Message, SwiftProto case 10: try { try decoder.decodeRepeatedInt32Field(value: &self.publicDependency) }() case 11: try { try decoder.decodeRepeatedInt32Field(value: &self.weakDependency) }() case 12: try { try decoder.decodeSingularStringField(value: &self._syntax) }() + case 14: try { try decoder.decodeSingularEnumField(value: &self._edition) }() + case 15: try { try decoder.decodeRepeatedStringField(value: &self.optionDependency) }() default: break } } } - public func traverse(visitor: inout V) throws { + public 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 @@ -2192,6 +2938,12 @@ extension Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Message, SwiftProto try { if let v = self._syntax { try visitor.visitSingularStringField(value: v, fieldNumber: 12) } }() + try { if let v = self._edition { + try visitor.visitSingularEnumField(value: v, fieldNumber: 14) + } }() + if !self.optionDependency.isEmpty { + try visitor.visitRepeatedStringField(value: self.optionDependency, fieldNumber: 15) + } try unknownFields.traverse(visitor: &visitor) } @@ -2201,6 +2953,7 @@ extension Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Message, SwiftProto if lhs.dependency != rhs.dependency {return false} if lhs.publicDependency != rhs.publicDependency {return false} if lhs.weakDependency != rhs.weakDependency {return false} + if lhs.optionDependency != rhs.optionDependency {return false} if lhs.messageType != rhs.messageType {return false} if lhs.enumType != rhs.enumType {return false} if lhs.service != rhs.service {return false} @@ -2208,126 +2961,175 @@ extension Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Message, SwiftProto if lhs._options != rhs._options {return false} if lhs._sourceCodeInfo != rhs._sourceCodeInfo {return false} if lhs._syntax != rhs._syntax {return false} + if lhs._edition != rhs._edition {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_DescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_DescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".DescriptorProto" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "field"), - 6: .same(proto: "extension"), - 3: .standard(proto: "nested_type"), - 4: .standard(proto: "enum_type"), - 5: .standard(proto: "extension_range"), - 8: .standard(proto: "oneof_decl"), - 7: .same(proto: "options"), - 9: .standard(proto: "reserved_range"), - 10: .standard(proto: "reserved_name"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}field\0\u{3}nested_type\0\u{3}enum_type\0\u{3}extension_range\0\u{1}extension\0\u{1}options\0\u{3}oneof_decl\0\u{3}reserved_range\0\u{3}reserved_name\0\u{1}visibility\0") - public var isInitialized: Bool { - if !SwiftProtobuf.Internal.areAllInitialized(self.field) {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.`extension`) {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.nestedType) {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.enumType) {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.extensionRange) {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.oneofDecl) {return false} - if let v = self._options, !v.isInitialized {return false} - return true - } + fileprivate class _StorageClass { + var _name: String? = nil + var _field: [Google_Protobuf_FieldDescriptorProto] = [] + var _extension: [Google_Protobuf_FieldDescriptorProto] = [] + var _nestedType: [Google_Protobuf_DescriptorProto] = [] + var _enumType: [Google_Protobuf_EnumDescriptorProto] = [] + var _extensionRange: [Google_Protobuf_DescriptorProto.ExtensionRange] = [] + var _oneofDecl: [Google_Protobuf_OneofDescriptorProto] = [] + var _options: Google_Protobuf_MessageOptions? = nil + var _reservedRange: [Google_Protobuf_DescriptorProto.ReservedRange] = [] + var _reservedName: [String] = [] + var _visibility: Google_Protobuf_SymbolVisibility? = nil + + // 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() - public 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._name) }() - case 2: try { try decoder.decodeRepeatedMessageField(value: &self.field) }() - case 3: try { try decoder.decodeRepeatedMessageField(value: &self.nestedType) }() - case 4: try { try decoder.decodeRepeatedMessageField(value: &self.enumType) }() - case 5: try { try decoder.decodeRepeatedMessageField(value: &self.extensionRange) }() - case 6: try { try decoder.decodeRepeatedMessageField(value: &self.`extension`) }() - case 7: try { try decoder.decodeSingularMessageField(value: &self._options) }() - case 8: try { try decoder.decodeRepeatedMessageField(value: &self.oneofDecl) }() - case 9: try { try decoder.decodeRepeatedMessageField(value: &self.reservedRange) }() - case 10: try { try decoder.decodeRepeatedStringField(value: &self.reservedName) }() - default: break - } + private init() {} + + init(copying source: _StorageClass) { + _name = source._name + _field = source._field + _extension = source._extension + _nestedType = source._nestedType + _enumType = source._enumType + _extensionRange = source._extensionRange + _oneofDecl = source._oneofDecl + _options = source._options + _reservedRange = source._reservedRange + _reservedName = source._reservedName + _visibility = source._visibility } } - public 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 - try { if let v = self._name { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - if !self.field.isEmpty { - try visitor.visitRepeatedMessageField(value: self.field, fieldNumber: 2) - } - if !self.nestedType.isEmpty { - try visitor.visitRepeatedMessageField(value: self.nestedType, fieldNumber: 3) - } - if !self.enumType.isEmpty { - try visitor.visitRepeatedMessageField(value: self.enumType, fieldNumber: 4) - } - if !self.extensionRange.isEmpty { - try visitor.visitRepeatedMessageField(value: self.extensionRange, fieldNumber: 5) - } - if !self.`extension`.isEmpty { - try visitor.visitRepeatedMessageField(value: self.`extension`, fieldNumber: 6) + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) } - try { if let v = self._options { - try visitor.visitSingularMessageField(value: v, fieldNumber: 7) - } }() - if !self.oneofDecl.isEmpty { - try visitor.visitRepeatedMessageField(value: self.oneofDecl, fieldNumber: 8) + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if !Internal.areAllInitialized(_storage._field) {return false} + if !Internal.areAllInitialized(_storage._extension) {return false} + if !Internal.areAllInitialized(_storage._nestedType) {return false} + if !Internal.areAllInitialized(_storage._enumType) {return false} + if !Internal.areAllInitialized(_storage._extensionRange) {return false} + if !Internal.areAllInitialized(_storage._oneofDecl) {return false} + if let v = _storage._options, !v.isInitialized {return false} + return true } - if !self.reservedRange.isEmpty { - try visitor.visitRepeatedMessageField(value: self.reservedRange, fieldNumber: 9) + } + + public mutating func decodeMessage(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._name) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &_storage._field) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &_storage._nestedType) }() + case 4: try { try decoder.decodeRepeatedMessageField(value: &_storage._enumType) }() + case 5: try { try decoder.decodeRepeatedMessageField(value: &_storage._extensionRange) }() + case 6: try { try decoder.decodeRepeatedMessageField(value: &_storage._extension) }() + case 7: try { try decoder.decodeSingularMessageField(value: &_storage._options) }() + case 8: try { try decoder.decodeRepeatedMessageField(value: &_storage._oneofDecl) }() + case 9: try { try decoder.decodeRepeatedMessageField(value: &_storage._reservedRange) }() + case 10: try { try decoder.decodeRepeatedStringField(value: &_storage._reservedName) }() + case 11: try { try decoder.decodeSingularEnumField(value: &_storage._visibility) }() + default: break + } + } } - if !self.reservedName.isEmpty { - try visitor.visitRepeatedStringField(value: self.reservedName, fieldNumber: 10) + } + + public func traverse(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._name { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + if !_storage._field.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._field, fieldNumber: 2) + } + if !_storage._nestedType.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._nestedType, fieldNumber: 3) + } + if !_storage._enumType.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._enumType, fieldNumber: 4) + } + if !_storage._extensionRange.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._extensionRange, fieldNumber: 5) + } + if !_storage._extension.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._extension, fieldNumber: 6) + } + try { if let v = _storage._options { + try visitor.visitSingularMessageField(value: v, fieldNumber: 7) + } }() + if !_storage._oneofDecl.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._oneofDecl, fieldNumber: 8) + } + if !_storage._reservedRange.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._reservedRange, fieldNumber: 9) + } + if !_storage._reservedName.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._reservedName, fieldNumber: 10) + } + try { if let v = _storage._visibility { + try visitor.visitSingularEnumField(value: v, fieldNumber: 11) + } }() } try unknownFields.traverse(visitor: &visitor) } public static func ==(lhs: Google_Protobuf_DescriptorProto, rhs: Google_Protobuf_DescriptorProto) -> Bool { - if lhs._name != rhs._name {return false} - if lhs.field != rhs.field {return false} - if lhs.`extension` != rhs.`extension` {return false} - if lhs.nestedType != rhs.nestedType {return false} - if lhs.enumType != rhs.enumType {return false} - if lhs.extensionRange != rhs.extensionRange {return false} - if lhs.oneofDecl != rhs.oneofDecl {return false} - if lhs._options != rhs._options {return false} - if lhs.reservedRange != rhs.reservedRange {return false} - if lhs.reservedName != rhs.reservedName {return false} + 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._name != rhs_storage._name {return false} + if _storage._field != rhs_storage._field {return false} + if _storage._extension != rhs_storage._extension {return false} + if _storage._nestedType != rhs_storage._nestedType {return false} + if _storage._enumType != rhs_storage._enumType {return false} + if _storage._extensionRange != rhs_storage._extensionRange {return false} + if _storage._oneofDecl != rhs_storage._oneofDecl {return false} + if _storage._options != rhs_storage._options {return false} + if _storage._reservedRange != rhs_storage._reservedRange {return false} + if _storage._reservedName != rhs_storage._reservedName {return false} + if _storage._visibility != rhs_storage._visibility {return false} + return true + } + if !storagesAreEqual {return false} + } if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_DescriptorProto.ExtensionRange: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_DescriptorProto.ExtensionRange: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = Google_Protobuf_DescriptorProto.protoMessageName + ".ExtensionRange" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "start"), - 2: .same(proto: "end"), - 3: .same(proto: "options"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}start\0\u{1}end\0\u{1}options\0") public var isInitialized: Bool { if let v = self._options, !v.isInitialized {return false} return true } - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -2341,7 +3143,7 @@ extension Google_Protobuf_DescriptorProto.ExtensionRange: SwiftProtobuf.Message, } } - public func traverse(visitor: inout V) throws { + public 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 @@ -2367,14 +3169,11 @@ extension Google_Protobuf_DescriptorProto.ExtensionRange: SwiftProtobuf.Message, } } -extension Google_Protobuf_DescriptorProto.ReservedRange: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_DescriptorProto.ReservedRange: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = Google_Protobuf_DescriptorProto.protoMessageName + ".ReservedRange" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "start"), - 2: .same(proto: "end"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}start\0\u{1}end\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -2387,7 +3186,7 @@ extension Google_Protobuf_DescriptorProto.ReservedRange: SwiftProtobuf.Message, } } - public func traverse(visitor: inout V) throws { + public 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 @@ -2409,24 +3208,26 @@ extension Google_Protobuf_DescriptorProto.ReservedRange: SwiftProtobuf.Message, } } -extension Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_ExtensionRangeOptions: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".ExtensionRangeOptions" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 999: .standard(proto: "uninterpreted_option"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\u{2}declaration\0\u{1}verification\0\u{2}/features\0\u{4}u\u{e}uninterpreted_option\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.uninterpretedOption) {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} + if let v = self._features, !v.isInitialized {return false} return true } - public mutating func decodeMessage(decoder: inout D) throws { + public 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 2: try { try decoder.decodeRepeatedMessageField(value: &self.declaration) }() + case 3: try { try decoder.decodeSingularEnumField(value: &self._verification) }() + case 50: try { try decoder.decodeSingularMessageField(value: &self._features) }() case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() case 1000..<536870912: try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_ExtensionRangeOptions.self, fieldNumber: fieldNumber) }() @@ -2435,7 +3236,20 @@ extension Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.Message, SwiftPro } } - public func traverse(visitor: inout V) throws { + public 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 + if !self.declaration.isEmpty { + try visitor.visitRepeatedMessageField(value: self.declaration, fieldNumber: 2) + } + try { if let v = self._verification { + try visitor.visitSingularEnumField(value: v, fieldNumber: 3) + } }() + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 50) + } }() if !self.uninterpretedOption.isEmpty { try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) } @@ -2445,224 +3259,105 @@ extension Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.Message, SwiftPro public static func ==(lhs: Google_Protobuf_ExtensionRangeOptions, rhs: Google_Protobuf_ExtensionRangeOptions) -> Bool { if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} + if lhs.declaration != rhs.declaration {return false} + if lhs._features != rhs._features {return false} + if lhs._verification != rhs._verification {return false} if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension Google_Protobuf_FieldDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - public static let protoMessageName: String = _protobuf_package + ".FieldDescriptorProto" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 3: .same(proto: "number"), - 4: .same(proto: "label"), - 5: .same(proto: "type"), - 6: .standard(proto: "type_name"), - 2: .same(proto: "extendee"), - 7: .standard(proto: "default_value"), - 9: .standard(proto: "oneof_index"), - 10: .standard(proto: "json_name"), - 8: .same(proto: "options"), - 17: .standard(proto: "proto3_optional"), - ] - - fileprivate class _StorageClass { - var _name: String? = nil - var _number: Int32? = nil - var _label: Google_Protobuf_FieldDescriptorProto.Label? = nil - var _type: Google_Protobuf_FieldDescriptorProto.TypeEnum? = nil - var _typeName: String? = nil - var _extendee: String? = nil - var _defaultValue: String? = nil - var _oneofIndex: Int32? = nil - var _jsonName: String? = nil - var _options: Google_Protobuf_FieldOptions? = nil - var _proto3Optional: Bool? = nil - - static let defaultInstance = _StorageClass() +extension Google_Protobuf_ExtensionRangeOptions.VerificationState: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0DECLARATION\0\u{1}UNVERIFIED\0") +} - private init() {} +extension Google_Protobuf_ExtensionRangeOptions.Declaration: Message, _MessageImplementationBase, _ProtoNameProviding { + public static let protoMessageName: String = Google_Protobuf_ExtensionRangeOptions.protoMessageName + ".Declaration" + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}number\0\u{3}full_name\0\u{1}type\0\u{2}\u{2}reserved\0\u{1}repeated\0\u{c}\u{4}\u{1}") - init(copying source: _StorageClass) { - _name = source._name - _number = source._number - _label = source._label - _type = source._type - _typeName = source._typeName - _extendee = source._extendee - _defaultValue = source._defaultValue - _oneofIndex = source._oneofIndex - _jsonName = source._jsonName - _options = source._options - _proto3Optional = source._proto3Optional + public 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._number) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._fullName) }() + case 3: try { try decoder.decodeSingularStringField(value: &self._type) }() + case 5: try { try decoder.decodeSingularBoolField(value: &self._reserved) }() + case 6: try { try decoder.decodeSingularBoolField(value: &self._repeated) }() + default: break + } } } - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage + public 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 + try { if let v = self._number { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._fullName { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._type { + try visitor.visitSingularStringField(value: v, fieldNumber: 3) + } }() + try { if let v = self._reserved { + try visitor.visitSingularBoolField(value: v, fieldNumber: 5) + } }() + try { if let v = self._repeated { + try visitor.visitSingularBoolField(value: v, fieldNumber: 6) + } }() + try unknownFields.traverse(visitor: &visitor) } - public var isInitialized: Bool { - return withExtendedLifetime(_storage) { (_storage: _StorageClass) in - if let v = _storage._options, !v.isInitialized {return false} - return true - } - } - - public mutating func decodeMessage(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._name) }() - case 2: try { try decoder.decodeSingularStringField(value: &_storage._extendee) }() - case 3: try { try decoder.decodeSingularInt32Field(value: &_storage._number) }() - case 4: try { try decoder.decodeSingularEnumField(value: &_storage._label) }() - case 5: try { try decoder.decodeSingularEnumField(value: &_storage._type) }() - case 6: try { try decoder.decodeSingularStringField(value: &_storage._typeName) }() - case 7: try { try decoder.decodeSingularStringField(value: &_storage._defaultValue) }() - case 8: try { try decoder.decodeSingularMessageField(value: &_storage._options) }() - case 9: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofIndex) }() - case 10: try { try decoder.decodeSingularStringField(value: &_storage._jsonName) }() - case 17: try { try decoder.decodeSingularBoolField(value: &_storage._proto3Optional) }() - default: break - } - } - } - } - - public func traverse(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._name { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._extendee { - try visitor.visitSingularStringField(value: v, fieldNumber: 2) - } }() - try { if let v = _storage._number { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) - } }() - try { if let v = _storage._label { - try visitor.visitSingularEnumField(value: v, fieldNumber: 4) - } }() - try { if let v = _storage._type { - try visitor.visitSingularEnumField(value: v, fieldNumber: 5) - } }() - try { if let v = _storage._typeName { - try visitor.visitSingularStringField(value: v, fieldNumber: 6) - } }() - try { if let v = _storage._defaultValue { - try visitor.visitSingularStringField(value: v, fieldNumber: 7) - } }() - try { if let v = _storage._options { - try visitor.visitSingularMessageField(value: v, fieldNumber: 8) - } }() - try { if let v = _storage._oneofIndex { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) - } }() - try { if let v = _storage._jsonName { - try visitor.visitSingularStringField(value: v, fieldNumber: 10) - } }() - try { if let v = _storage._proto3Optional { - try visitor.visitSingularBoolField(value: v, fieldNumber: 17) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - public static func ==(lhs: Google_Protobuf_FieldDescriptorProto, rhs: Google_Protobuf_FieldDescriptorProto) -> 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._name != rhs_storage._name {return false} - if _storage._number != rhs_storage._number {return false} - if _storage._label != rhs_storage._label {return false} - if _storage._type != rhs_storage._type {return false} - if _storage._typeName != rhs_storage._typeName {return false} - if _storage._extendee != rhs_storage._extendee {return false} - if _storage._defaultValue != rhs_storage._defaultValue {return false} - if _storage._oneofIndex != rhs_storage._oneofIndex {return false} - if _storage._jsonName != rhs_storage._jsonName {return false} - if _storage._options != rhs_storage._options {return false} - if _storage._proto3Optional != rhs_storage._proto3Optional {return false} - return true - } - if !storagesAreEqual {return false} - } + public static func ==(lhs: Google_Protobuf_ExtensionRangeOptions.Declaration, rhs: Google_Protobuf_ExtensionRangeOptions.Declaration) -> Bool { + if lhs._number != rhs._number {return false} + if lhs._fullName != rhs._fullName {return false} + if lhs._type != rhs._type {return false} + if lhs._reserved != rhs._reserved {return false} + if lhs._repeated != rhs._repeated {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_FieldDescriptorProto.TypeEnum: SwiftProtobuf._ProtoNameProviding { - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TYPE_DOUBLE"), - 2: .same(proto: "TYPE_FLOAT"), - 3: .same(proto: "TYPE_INT64"), - 4: .same(proto: "TYPE_UINT64"), - 5: .same(proto: "TYPE_INT32"), - 6: .same(proto: "TYPE_FIXED64"), - 7: .same(proto: "TYPE_FIXED32"), - 8: .same(proto: "TYPE_BOOL"), - 9: .same(proto: "TYPE_STRING"), - 10: .same(proto: "TYPE_GROUP"), - 11: .same(proto: "TYPE_MESSAGE"), - 12: .same(proto: "TYPE_BYTES"), - 13: .same(proto: "TYPE_UINT32"), - 14: .same(proto: "TYPE_ENUM"), - 15: .same(proto: "TYPE_SFIXED32"), - 16: .same(proto: "TYPE_SFIXED64"), - 17: .same(proto: "TYPE_SINT32"), - 18: .same(proto: "TYPE_SINT64"), - ] -} - -extension Google_Protobuf_FieldDescriptorProto.Label: SwiftProtobuf._ProtoNameProviding { - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "LABEL_OPTIONAL"), - 2: .same(proto: "LABEL_REQUIRED"), - 3: .same(proto: "LABEL_REPEATED"), - ] -} - -extension Google_Protobuf_OneofDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - public static let protoMessageName: String = _protobuf_package + ".OneofDescriptorProto" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "options"), - ] +extension Google_Protobuf_FieldDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { + public static let protoMessageName: String = _protobuf_package + ".FieldDescriptorProto" + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}extendee\0\u{1}number\0\u{1}label\0\u{1}type\0\u{3}type_name\0\u{3}default_value\0\u{1}options\0\u{3}oneof_index\0\u{3}json_name\0\u{4}\u{7}proto3_optional\0") public var isInitialized: Bool { if let v = self._options, !v.isInitialized {return false} return true } - public mutating func decodeMessage(decoder: inout D) throws { + public 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._name) }() - case 2: try { try decoder.decodeSingularMessageField(value: &self._options) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._extendee) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._number) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._label) }() + case 5: try { try decoder.decodeSingularEnumField(value: &self._type) }() + case 6: try { try decoder.decodeSingularStringField(value: &self._typeName) }() + case 7: try { try decoder.decodeSingularStringField(value: &self._defaultValue) }() + case 8: try { try decoder.decodeSingularMessageField(value: &self._options) }() + case 9: try { try decoder.decodeSingularInt32Field(value: &self._oneofIndex) }() + case 10: try { try decoder.decodeSingularStringField(value: &self._jsonName) }() + case 17: try { try decoder.decodeSingularBoolField(value: &self._proto3Optional) }() default: break } } } - public func traverse(visitor: inout V) throws { + public 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 @@ -2670,53 +3365,87 @@ extension Google_Protobuf_OneofDescriptorProto: SwiftProtobuf.Message, SwiftProt try { if let v = self._name { try visitor.visitSingularStringField(value: v, fieldNumber: 1) } }() + try { if let v = self._extendee { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + } }() + try { if let v = self._number { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._label { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + try { if let v = self._type { + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + } }() + try { if let v = self._typeName { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) + } }() + try { if let v = self._defaultValue { + try visitor.visitSingularStringField(value: v, fieldNumber: 7) + } }() try { if let v = self._options { - try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + try visitor.visitSingularMessageField(value: v, fieldNumber: 8) + } }() + try { if let v = self._oneofIndex { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try { if let v = self._jsonName { + try visitor.visitSingularStringField(value: v, fieldNumber: 10) + } }() + try { if let v = self._proto3Optional { + try visitor.visitSingularBoolField(value: v, fieldNumber: 17) } }() try unknownFields.traverse(visitor: &visitor) } - public static func ==(lhs: Google_Protobuf_OneofDescriptorProto, rhs: Google_Protobuf_OneofDescriptorProto) -> Bool { + public static func ==(lhs: Google_Protobuf_FieldDescriptorProto, rhs: Google_Protobuf_FieldDescriptorProto) -> Bool { if lhs._name != rhs._name {return false} + if lhs._number != rhs._number {return false} + if lhs._label != rhs._label {return false} + if lhs._type != rhs._type {return false} + if lhs._typeName != rhs._typeName {return false} + if lhs._extendee != rhs._extendee {return false} + if lhs._defaultValue != rhs._defaultValue {return false} + if lhs._oneofIndex != rhs._oneofIndex {return false} + if lhs._jsonName != rhs._jsonName {return false} if lhs._options != rhs._options {return false} + if lhs._proto3Optional != rhs._proto3Optional {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_EnumDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - public static let protoMessageName: String = _protobuf_package + ".EnumDescriptorProto" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "value"), - 3: .same(proto: "options"), - 4: .standard(proto: "reserved_range"), - 5: .standard(proto: "reserved_name"), - ] +extension Google_Protobuf_FieldDescriptorProto.TypeEnum: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}TYPE_DOUBLE\0\u{1}TYPE_FLOAT\0\u{1}TYPE_INT64\0\u{1}TYPE_UINT64\0\u{1}TYPE_INT32\0\u{1}TYPE_FIXED64\0\u{1}TYPE_FIXED32\0\u{1}TYPE_BOOL\0\u{1}TYPE_STRING\0\u{1}TYPE_GROUP\0\u{1}TYPE_MESSAGE\0\u{1}TYPE_BYTES\0\u{1}TYPE_UINT32\0\u{1}TYPE_ENUM\0\u{1}TYPE_SFIXED32\0\u{1}TYPE_SFIXED64\0\u{1}TYPE_SINT32\0\u{1}TYPE_SINT64\0") +} + +extension Google_Protobuf_FieldDescriptorProto.Label: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}LABEL_OPTIONAL\0\u{1}LABEL_REQUIRED\0\u{1}LABEL_REPEATED\0") +} + +extension Google_Protobuf_OneofDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { + public static let protoMessageName: String = _protobuf_package + ".OneofDescriptorProto" + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}options\0") public var isInitialized: Bool { - if !SwiftProtobuf.Internal.areAllInitialized(self.value) {return false} if let v = self._options, !v.isInitialized {return false} return true } - public mutating func decodeMessage(decoder: inout D) throws { + public 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._name) }() - case 2: try { try decoder.decodeRepeatedMessageField(value: &self.value) }() - case 3: try { try decoder.decodeSingularMessageField(value: &self._options) }() - case 4: try { try decoder.decodeRepeatedMessageField(value: &self.reservedRange) }() - case 5: try { try decoder.decodeRepeatedStringField(value: &self.reservedName) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._options) }() default: break } } } - public func traverse(visitor: inout V) throws { + public 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 @@ -2724,40 +3453,138 @@ extension Google_Protobuf_EnumDescriptorProto: SwiftProtobuf.Message, SwiftProto try { if let v = self._name { try visitor.visitSingularStringField(value: v, fieldNumber: 1) } }() - if !self.value.isEmpty { - try visitor.visitRepeatedMessageField(value: self.value, fieldNumber: 2) - } try { if let v = self._options { - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) } }() - if !self.reservedRange.isEmpty { - try visitor.visitRepeatedMessageField(value: self.reservedRange, fieldNumber: 4) + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: Google_Protobuf_OneofDescriptorProto, rhs: Google_Protobuf_OneofDescriptorProto) -> Bool { + if lhs._name != rhs._name {return false} + if lhs._options != rhs._options {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_EnumDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { + public static let protoMessageName: String = _protobuf_package + ".EnumDescriptorProto" + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}value\0\u{1}options\0\u{3}reserved_range\0\u{3}reserved_name\0\u{1}visibility\0") + + fileprivate class _StorageClass { + var _name: String? = nil + var _value: [Google_Protobuf_EnumValueDescriptorProto] = [] + var _options: Google_Protobuf_EnumOptions? = nil + var _reservedRange: [Google_Protobuf_EnumDescriptorProto.EnumReservedRange] = [] + var _reservedName: [String] = [] + var _visibility: Google_Protobuf_SymbolVisibility? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _name = source._name + _value = source._value + _options = source._options + _reservedRange = source._reservedRange + _reservedName = source._reservedName + _visibility = source._visibility + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) } - if !self.reservedName.isEmpty { - try visitor.visitRepeatedStringField(value: self.reservedName, fieldNumber: 5) + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if !Internal.areAllInitialized(_storage._value) {return false} + if let v = _storage._options, !v.isInitialized {return false} + return true + } + } + + public mutating func decodeMessage(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._name) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &_storage._value) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._options) }() + case 4: try { try decoder.decodeRepeatedMessageField(value: &_storage._reservedRange) }() + case 5: try { try decoder.decodeRepeatedStringField(value: &_storage._reservedName) }() + case 6: try { try decoder.decodeSingularEnumField(value: &_storage._visibility) }() + default: break + } + } + } + } + + public func traverse(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._name { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + if !_storage._value.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._value, fieldNumber: 2) + } + try { if let v = _storage._options { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + if !_storage._reservedRange.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._reservedRange, fieldNumber: 4) + } + if !_storage._reservedName.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._reservedName, fieldNumber: 5) + } + try { if let v = _storage._visibility { + try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + } }() } try unknownFields.traverse(visitor: &visitor) } public static func ==(lhs: Google_Protobuf_EnumDescriptorProto, rhs: Google_Protobuf_EnumDescriptorProto) -> Bool { - if lhs._name != rhs._name {return false} - if lhs.value != rhs.value {return false} - if lhs._options != rhs._options {return false} - if lhs.reservedRange != rhs.reservedRange {return false} - if lhs.reservedName != rhs.reservedName {return false} + 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._name != rhs_storage._name {return false} + if _storage._value != rhs_storage._value {return false} + if _storage._options != rhs_storage._options {return false} + if _storage._reservedRange != rhs_storage._reservedRange {return false} + if _storage._reservedName != rhs_storage._reservedName {return false} + if _storage._visibility != rhs_storage._visibility {return false} + return true + } + if !storagesAreEqual {return false} + } if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_EnumDescriptorProto.EnumReservedRange: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_EnumDescriptorProto.EnumReservedRange: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = Google_Protobuf_EnumDescriptorProto.protoMessageName + ".EnumReservedRange" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "start"), - 2: .same(proto: "end"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}start\0\u{1}end\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -2770,7 +3597,7 @@ extension Google_Protobuf_EnumDescriptorProto.EnumReservedRange: SwiftProtobuf.M } } - public func traverse(visitor: inout V) throws { + public 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 @@ -2792,74 +3619,108 @@ extension Google_Protobuf_EnumDescriptorProto.EnumReservedRange: SwiftProtobuf.M } } -extension Google_Protobuf_EnumValueDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_EnumValueDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".EnumValueDescriptorProto" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "number"), - 3: .same(proto: "options"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}number\0\u{1}options\0") + + fileprivate class _StorageClass { + var _name: String? = nil + var _number: Int32? = nil + var _options: Google_Protobuf_EnumValueOptions? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _name = source._name + _number = source._number + _options = source._options + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } public var isInitialized: Bool { - if let v = self._options, !v.isInitialized {return false} - return true + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._options, !v.isInitialized {return false} + return true + } } - public 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._name) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &self._number) }() - case 3: try { try decoder.decodeSingularMessageField(value: &self._options) }() - default: break + public mutating func decodeMessage(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._name) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._number) }() + case 3: try { try decoder.decodeSingularMessageField(value: &_storage._options) }() + default: break + } } } } - public 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 - try { if let v = self._name { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try { if let v = self._number { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try { if let v = self._options { - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - } }() + public func traverse(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._name { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._number { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._options { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() + } try unknownFields.traverse(visitor: &visitor) } public static func ==(lhs: Google_Protobuf_EnumValueDescriptorProto, rhs: Google_Protobuf_EnumValueDescriptorProto) -> Bool { - if lhs._name != rhs._name {return false} - if lhs._number != rhs._number {return false} - if lhs._options != rhs._options {return false} + 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._name != rhs_storage._name {return false} + if _storage._number != rhs_storage._number {return false} + if _storage._options != rhs_storage._options {return false} + return true + } + if !storagesAreEqual {return false} + } if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_ServiceDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".ServiceDescriptorProto" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "method"), - 3: .same(proto: "options"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}method\0\u{1}options\0\u{b}stream\0\u{c}\u{4}\u{1}") public var isInitialized: Bool { - if !SwiftProtobuf.Internal.areAllInitialized(self.method) {return false} + if !Internal.areAllInitialized(self.method) {return false} if let v = self._options, !v.isInitialized {return false} return true } - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -2873,7 +3734,7 @@ extension Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf.Message, SwiftPr } } - public func traverse(visitor: inout V) throws { + public 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 @@ -2899,23 +3760,16 @@ extension Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf.Message, SwiftPr } } -extension Google_Protobuf_MethodDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_MethodDescriptorProto: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".MethodDescriptorProto" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .standard(proto: "input_type"), - 3: .standard(proto: "output_type"), - 4: .same(proto: "options"), - 5: .standard(proto: "client_streaming"), - 6: .standard(proto: "server_streaming"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{3}input_type\0\u{3}output_type\0\u{1}options\0\u{3}client_streaming\0\u{3}server_streaming\0") public var isInitialized: Bool { if let v = self._options, !v.isInitialized {return false} return true } - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -2932,7 +3786,7 @@ extension Google_Protobuf_MethodDescriptorProto: SwiftProtobuf.Message, SwiftPro } } - public func traverse(visitor: inout V) throws { + public 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 @@ -2970,31 +3824,9 @@ extension Google_Protobuf_MethodDescriptorProto: SwiftProtobuf.Message, SwiftPro } } -extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_FileOptions: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".FileOptions" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "java_package"), - 8: .standard(proto: "java_outer_classname"), - 10: .standard(proto: "java_multiple_files"), - 20: .standard(proto: "java_generate_equals_and_hash"), - 27: .standard(proto: "java_string_check_utf8"), - 9: .standard(proto: "optimize_for"), - 11: .standard(proto: "go_package"), - 16: .standard(proto: "cc_generic_services"), - 17: .standard(proto: "java_generic_services"), - 18: .standard(proto: "py_generic_services"), - 42: .standard(proto: "php_generic_services"), - 23: .same(proto: "deprecated"), - 31: .standard(proto: "cc_enable_arenas"), - 36: .standard(proto: "objc_class_prefix"), - 37: .standard(proto: "csharp_namespace"), - 39: .standard(proto: "swift_prefix"), - 40: .standard(proto: "php_class_prefix"), - 41: .standard(proto: "php_namespace"), - 44: .standard(proto: "php_metadata_namespace"), - 45: .standard(proto: "ruby_package"), - 999: .standard(proto: "uninterpreted_option"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}java_package\0\u{4}\u{7}java_outer_classname\0\u{3}optimize_for\0\u{3}java_multiple_files\0\u{3}go_package\0\u{4}\u{5}cc_generic_services\0\u{3}java_generic_services\0\u{3}py_generic_services\0\u{4}\u{2}java_generate_equals_and_hash\0\u{2}\u{3}deprecated\0\u{4}\u{4}java_string_check_utf8\0\u{4}\u{4}cc_enable_arenas\0\u{4}\u{5}objc_class_prefix\0\u{3}csharp_namespace\0\u{4}\u{2}swift_prefix\0\u{3}php_class_prefix\0\u{3}php_namespace\0\u{4}\u{3}php_metadata_namespace\0\u{3}ruby_package\0\u{2}\u{5}features\0\u{4}u\u{e}uninterpreted_option\0\u{b}php_generic_services\0\u{c}*\u{1}\u{c}&\u{1}") fileprivate class _StorageClass { var _javaPackage: String? = nil @@ -3007,7 +3839,6 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes var _ccGenericServices: Bool? = nil var _javaGenericServices: Bool? = nil var _pyGenericServices: Bool? = nil - var _phpGenericServices: Bool? = nil var _deprecated: Bool? = nil var _ccEnableArenas: Bool? = nil var _objcClassPrefix: String? = nil @@ -3017,9 +3848,14 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes var _phpNamespace: String? = nil var _phpMetadataNamespace: String? = nil var _rubyPackage: String? = nil + var _features: Google_Protobuf_FeatureSet? = nil var _uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -3034,7 +3870,6 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes _ccGenericServices = source._ccGenericServices _javaGenericServices = source._javaGenericServices _pyGenericServices = source._pyGenericServices - _phpGenericServices = source._phpGenericServices _deprecated = source._deprecated _ccEnableArenas = source._ccEnableArenas _objcClassPrefix = source._objcClassPrefix @@ -3044,6 +3879,7 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes _phpNamespace = source._phpNamespace _phpMetadataNamespace = source._phpMetadataNamespace _rubyPackage = source._rubyPackage + _features = source._features _uninterpretedOption = source._uninterpretedOption } } @@ -3058,12 +3894,13 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} return withExtendedLifetime(_storage) { (_storage: _StorageClass) in - if !SwiftProtobuf.Internal.areAllInitialized(_storage._uninterpretedOption) {return false} + if let v = _storage._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(_storage._uninterpretedOption) {return false} return true } } - public mutating func decodeMessage(decoder: inout D) throws { + public mutating func decodeMessage(decoder: inout D) throws { _ = _uniqueStorage() try withExtendedLifetime(_storage) { (_storage: _StorageClass) in while let fieldNumber = try decoder.nextFieldNumber() { @@ -3088,9 +3925,9 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes case 39: try { try decoder.decodeSingularStringField(value: &_storage._swiftPrefix) }() case 40: try { try decoder.decodeSingularStringField(value: &_storage._phpClassPrefix) }() case 41: try { try decoder.decodeSingularStringField(value: &_storage._phpNamespace) }() - case 42: try { try decoder.decodeSingularBoolField(value: &_storage._phpGenericServices) }() case 44: try { try decoder.decodeSingularStringField(value: &_storage._phpMetadataNamespace) }() case 45: try { try decoder.decodeSingularStringField(value: &_storage._rubyPackage) }() + case 50: try { try decoder.decodeSingularMessageField(value: &_storage._features) }() case 999: try { try decoder.decodeRepeatedMessageField(value: &_storage._uninterpretedOption) }() case 1000..<536870912: try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_FileOptions.self, fieldNumber: fieldNumber) }() @@ -3100,7 +3937,7 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes } } - public func traverse(visitor: inout V) throws { + public func traverse(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 @@ -3157,15 +3994,15 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes try { if let v = _storage._phpNamespace { try visitor.visitSingularStringField(value: v, fieldNumber: 41) } }() - try { if let v = _storage._phpGenericServices { - try visitor.visitSingularBoolField(value: v, fieldNumber: 42) - } }() try { if let v = _storage._phpMetadataNamespace { try visitor.visitSingularStringField(value: v, fieldNumber: 44) } }() try { if let v = _storage._rubyPackage { try visitor.visitSingularStringField(value: v, fieldNumber: 45) } }() + try { if let v = _storage._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 50) + } }() if !_storage._uninterpretedOption.isEmpty { try visitor.visitRepeatedMessageField(value: _storage._uninterpretedOption, fieldNumber: 999) } @@ -3189,7 +4026,6 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes if _storage._ccGenericServices != rhs_storage._ccGenericServices {return false} if _storage._javaGenericServices != rhs_storage._javaGenericServices {return false} if _storage._pyGenericServices != rhs_storage._pyGenericServices {return false} - if _storage._phpGenericServices != rhs_storage._phpGenericServices {return false} if _storage._deprecated != rhs_storage._deprecated {return false} if _storage._ccEnableArenas != rhs_storage._ccEnableArenas {return false} if _storage._objcClassPrefix != rhs_storage._objcClassPrefix {return false} @@ -3199,6 +4035,260 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes if _storage._phpNamespace != rhs_storage._phpNamespace {return false} if _storage._phpMetadataNamespace != rhs_storage._phpMetadataNamespace {return false} if _storage._rubyPackage != rhs_storage._rubyPackage {return false} + if _storage._features != rhs_storage._features {return false} + if _storage._uninterpretedOption != rhs_storage._uninterpretedOption {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Google_Protobuf_FileOptions.OptimizeMode: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}SPEED\0\u{1}CODE_SIZE\0\u{1}LITE_RUNTIME\0") +} + +extension Google_Protobuf_MessageOptions: Message, _MessageImplementationBase, _ProtoNameProviding { + public static let protoMessageName: String = _protobuf_package + ".MessageOptions" + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}message_set_wire_format\0\u{3}no_standard_descriptor_accessor\0\u{1}deprecated\0\u{4}\u{4}map_entry\0\u{4}\u{4}deprecated_legacy_json_field_conflicts\0\u{1}features\0\u{4}[\u{f}uninterpreted_option\0\u{c}\u{4}\u{1}\u{c}\u{5}\u{1}\u{c}\u{6}\u{1}\u{c}\u{8}\u{1}\u{c}\u{9}\u{1}") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + if let v = self._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} + return true + } + + public 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.decodeSingularBoolField(value: &self._messageSetWireFormat) }() + case 2: try { try decoder.decodeSingularBoolField(value: &self._noStandardDescriptorAccessor) }() + case 3: try { try decoder.decodeSingularBoolField(value: &self._deprecated) }() + case 7: try { try decoder.decodeSingularBoolField(value: &self._mapEntry) }() + case 11: try { try decoder.decodeSingularBoolField(value: &self._deprecatedLegacyJsonFieldConflicts) }() + case 12: try { try decoder.decodeSingularMessageField(value: &self._features) }() + case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_MessageOptions.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + + public 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 + try { if let v = self._messageSetWireFormat { + try visitor.visitSingularBoolField(value: v, fieldNumber: 1) + } }() + try { if let v = self._noStandardDescriptorAccessor { + try visitor.visitSingularBoolField(value: v, fieldNumber: 2) + } }() + try { if let v = self._deprecated { + try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + } }() + try { if let v = self._mapEntry { + try visitor.visitSingularBoolField(value: v, fieldNumber: 7) + } }() + try { if let v = self._deprecatedLegacyJsonFieldConflicts { + try visitor.visitSingularBoolField(value: v, fieldNumber: 11) + } }() + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 12) + } }() + if !self.uninterpretedOption.isEmpty { + try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: Google_Protobuf_MessageOptions, rhs: Google_Protobuf_MessageOptions) -> Bool { + if lhs._messageSetWireFormat != rhs._messageSetWireFormat {return false} + if lhs._noStandardDescriptorAccessor != rhs._noStandardDescriptorAccessor {return false} + if lhs._deprecated != rhs._deprecated {return false} + if lhs._mapEntry != rhs._mapEntry {return false} + if lhs._deprecatedLegacyJsonFieldConflicts != rhs._deprecatedLegacyJsonFieldConflicts {return false} + if lhs._features != rhs._features {return false} + if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Google_Protobuf_FieldOptions: Message, _MessageImplementationBase, _ProtoNameProviding { + public static let protoMessageName: String = _protobuf_package + ".FieldOptions" + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}ctype\0\u{1}packed\0\u{1}deprecated\0\u{2}\u{2}lazy\0\u{1}jstype\0\u{2}\u{4}weak\0\u{4}\u{5}unverified_lazy\0\u{3}debug_redact\0\u{1}retention\0\u{2}\u{2}targets\0\u{3}edition_defaults\0\u{1}features\0\u{3}feature_support\0\u{4}Q\u{f}uninterpreted_option\0\u{c}\u{4}\u{1}\u{c}\u{12}\u{1}") + + fileprivate class _StorageClass { + var _ctype: Google_Protobuf_FieldOptions.CType? = nil + var _packed: Bool? = nil + var _jstype: Google_Protobuf_FieldOptions.JSType? = nil + var _lazy: Bool? = nil + var _unverifiedLazy: Bool? = nil + var _deprecated: Bool? = nil + var _weak: Bool? = nil + var _debugRedact: Bool? = nil + var _retention: Google_Protobuf_FieldOptions.OptionRetention? = nil + var _targets: [Google_Protobuf_FieldOptions.OptionTargetType] = [] + var _editionDefaults: [Google_Protobuf_FieldOptions.EditionDefault] = [] + var _features: Google_Protobuf_FeatureSet? = nil + var _featureSupport: Google_Protobuf_FieldOptions.FeatureSupport? = nil + var _uninterpretedOption: [Google_Protobuf_UninterpretedOption] = [] + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _ctype = source._ctype + _packed = source._packed + _jstype = source._jstype + _lazy = source._lazy + _unverifiedLazy = source._unverifiedLazy + _deprecated = source._deprecated + _weak = source._weak + _debugRedact = source._debugRedact + _retention = source._retention + _targets = source._targets + _editionDefaults = source._editionDefaults + _features = source._features + _featureSupport = source._featureSupport + _uninterpretedOption = source._uninterpretedOption + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(_storage._uninterpretedOption) {return false} + return true + } + } + + public mutating func decodeMessage(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.decodeSingularEnumField(value: &_storage._ctype) }() + case 2: try { try decoder.decodeSingularBoolField(value: &_storage._packed) }() + case 3: try { try decoder.decodeSingularBoolField(value: &_storage._deprecated) }() + case 5: try { try decoder.decodeSingularBoolField(value: &_storage._lazy) }() + case 6: try { try decoder.decodeSingularEnumField(value: &_storage._jstype) }() + case 10: try { try decoder.decodeSingularBoolField(value: &_storage._weak) }() + case 15: try { try decoder.decodeSingularBoolField(value: &_storage._unverifiedLazy) }() + case 16: try { try decoder.decodeSingularBoolField(value: &_storage._debugRedact) }() + case 17: try { try decoder.decodeSingularEnumField(value: &_storage._retention) }() + case 19: try { try decoder.decodeRepeatedEnumField(value: &_storage._targets) }() + case 20: try { try decoder.decodeRepeatedMessageField(value: &_storage._editionDefaults) }() + case 21: try { try decoder.decodeSingularMessageField(value: &_storage._features) }() + case 22: try { try decoder.decodeSingularMessageField(value: &_storage._featureSupport) }() + case 999: try { try decoder.decodeRepeatedMessageField(value: &_storage._uninterpretedOption) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_FieldOptions.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + public func traverse(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._ctype { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._packed { + try visitor.visitSingularBoolField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._deprecated { + try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._lazy { + try visitor.visitSingularBoolField(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._jstype { + try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._weak { + try visitor.visitSingularBoolField(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._unverifiedLazy { + try visitor.visitSingularBoolField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._debugRedact { + try visitor.visitSingularBoolField(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._retention { + try visitor.visitSingularEnumField(value: v, fieldNumber: 17) + } }() + if !_storage._targets.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._targets, fieldNumber: 19) + } + if !_storage._editionDefaults.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._editionDefaults, fieldNumber: 20) + } + try { if let v = _storage._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._featureSupport { + try visitor.visitSingularMessageField(value: v, fieldNumber: 22) + } }() + if !_storage._uninterpretedOption.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._uninterpretedOption, fieldNumber: 999) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + } + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: Google_Protobuf_FieldOptions, rhs: Google_Protobuf_FieldOptions) -> 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._ctype != rhs_storage._ctype {return false} + if _storage._packed != rhs_storage._packed {return false} + if _storage._jstype != rhs_storage._jstype {return false} + if _storage._lazy != rhs_storage._lazy {return false} + if _storage._unverifiedLazy != rhs_storage._unverifiedLazy {return false} + if _storage._deprecated != rhs_storage._deprecated {return false} + if _storage._weak != rhs_storage._weak {return false} + if _storage._debugRedact != rhs_storage._debugRedact {return false} + if _storage._retention != rhs_storage._retention {return false} + if _storage._targets != rhs_storage._targets {return false} + if _storage._editionDefaults != rhs_storage._editionDefaults {return false} + if _storage._features != rhs_storage._features {return false} + if _storage._featureSupport != rhs_storage._featureSupport {return false} if _storage._uninterpretedOption != rhs_storage._uninterpretedOption {return false} return true } @@ -3210,200 +4300,133 @@ extension Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes } } -extension Google_Protobuf_FileOptions.OptimizeMode: SwiftProtobuf._ProtoNameProviding { - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "SPEED"), - 2: .same(proto: "CODE_SIZE"), - 3: .same(proto: "LITE_RUNTIME"), - ] +extension Google_Protobuf_FieldOptions.CType: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0STRING\0\u{1}CORD\0\u{1}STRING_PIECE\0") } -extension Google_Protobuf_MessageOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - public static let protoMessageName: String = _protobuf_package + ".MessageOptions" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "message_set_wire_format"), - 2: .standard(proto: "no_standard_descriptor_accessor"), - 3: .same(proto: "deprecated"), - 7: .standard(proto: "map_entry"), - 999: .standard(proto: "uninterpreted_option"), - ] +extension Google_Protobuf_FieldOptions.JSType: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0JS_NORMAL\0\u{1}JS_STRING\0\u{1}JS_NUMBER\0") +} - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.uninterpretedOption) {return false} - return true - } +extension Google_Protobuf_FieldOptions.OptionRetention: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0RETENTION_UNKNOWN\0\u{1}RETENTION_RUNTIME\0\u{1}RETENTION_SOURCE\0") +} + +extension Google_Protobuf_FieldOptions.OptionTargetType: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0TARGET_TYPE_UNKNOWN\0\u{1}TARGET_TYPE_FILE\0\u{1}TARGET_TYPE_EXTENSION_RANGE\0\u{1}TARGET_TYPE_MESSAGE\0\u{1}TARGET_TYPE_FIELD\0\u{1}TARGET_TYPE_ONEOF\0\u{1}TARGET_TYPE_ENUM\0\u{1}TARGET_TYPE_ENUM_ENTRY\0\u{1}TARGET_TYPE_SERVICE\0\u{1}TARGET_TYPE_METHOD\0") +} + +extension Google_Protobuf_FieldOptions.EditionDefault: Message, _MessageImplementationBase, _ProtoNameProviding { + public static let protoMessageName: String = Google_Protobuf_FieldOptions.protoMessageName + ".EditionDefault" + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\u{2}value\0\u{1}edition\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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.decodeSingularBoolField(value: &self._messageSetWireFormat) }() - case 2: try { try decoder.decodeSingularBoolField(value: &self._noStandardDescriptorAccessor) }() - case 3: try { try decoder.decodeSingularBoolField(value: &self._deprecated) }() - case 7: try { try decoder.decodeSingularBoolField(value: &self._mapEntry) }() - case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() - case 1000..<536870912: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_MessageOptions.self, fieldNumber: fieldNumber) }() + case 2: try { try decoder.decodeSingularStringField(value: &self._value) }() + case 3: try { try decoder.decodeSingularEnumField(value: &self._edition) }() default: break } } } - public func traverse(visitor: inout V) throws { + public 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 - try { if let v = self._messageSetWireFormat { - try visitor.visitSingularBoolField(value: v, fieldNumber: 1) - } }() - try { if let v = self._noStandardDescriptorAccessor { - try visitor.visitSingularBoolField(value: v, fieldNumber: 2) - } }() - try { if let v = self._deprecated { - try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + try { if let v = self._value { + try visitor.visitSingularStringField(value: v, fieldNumber: 2) } }() - try { if let v = self._mapEntry { - try visitor.visitSingularBoolField(value: v, fieldNumber: 7) + try { if let v = self._edition { + try visitor.visitSingularEnumField(value: v, fieldNumber: 3) } }() - if !self.uninterpretedOption.isEmpty { - try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) - } - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) try unknownFields.traverse(visitor: &visitor) } - public static func ==(lhs: Google_Protobuf_MessageOptions, rhs: Google_Protobuf_MessageOptions) -> Bool { - if lhs._messageSetWireFormat != rhs._messageSetWireFormat {return false} - if lhs._noStandardDescriptorAccessor != rhs._noStandardDescriptorAccessor {return false} - if lhs._deprecated != rhs._deprecated {return false} - if lhs._mapEntry != rhs._mapEntry {return false} - if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} + public static func ==(lhs: Google_Protobuf_FieldOptions.EditionDefault, rhs: Google_Protobuf_FieldOptions.EditionDefault) -> Bool { + if lhs._edition != rhs._edition {return false} + if lhs._value != rhs._value {return false} if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension Google_Protobuf_FieldOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - public static let protoMessageName: String = _protobuf_package + ".FieldOptions" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ctype"), - 2: .same(proto: "packed"), - 6: .same(proto: "jstype"), - 5: .same(proto: "lazy"), - 3: .same(proto: "deprecated"), - 10: .same(proto: "weak"), - 999: .standard(proto: "uninterpreted_option"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.uninterpretedOption) {return false} - return true - } +extension Google_Protobuf_FieldOptions.FeatureSupport: Message, _MessageImplementationBase, _ProtoNameProviding { + public static let protoMessageName: String = Google_Protobuf_FieldOptions.protoMessageName + ".FeatureSupport" + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}edition_introduced\0\u{3}edition_deprecated\0\u{3}deprecation_warning\0\u{3}edition_removed\0\u{3}removal_error\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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._ctype) }() - case 2: try { try decoder.decodeSingularBoolField(value: &self._packed) }() - case 3: try { try decoder.decodeSingularBoolField(value: &self._deprecated) }() - case 5: try { try decoder.decodeSingularBoolField(value: &self._lazy) }() - case 6: try { try decoder.decodeSingularEnumField(value: &self._jstype) }() - case 10: try { try decoder.decodeSingularBoolField(value: &self._weak) }() - case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() - case 1000..<536870912: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_FieldOptions.self, fieldNumber: fieldNumber) }() + case 1: try { try decoder.decodeSingularEnumField(value: &self._editionIntroduced) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self._editionDeprecated) }() + case 3: try { try decoder.decodeSingularStringField(value: &self._deprecationWarning) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._editionRemoved) }() + case 5: try { try decoder.decodeSingularStringField(value: &self._removalError) }() default: break } } } - public func traverse(visitor: inout V) throws { + public 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 - try { if let v = self._ctype { + try { if let v = self._editionIntroduced { try visitor.visitSingularEnumField(value: v, fieldNumber: 1) } }() - try { if let v = self._packed { - try visitor.visitSingularBoolField(value: v, fieldNumber: 2) - } }() - try { if let v = self._deprecated { - try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + try { if let v = self._editionDeprecated { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) } }() - try { if let v = self._lazy { - try visitor.visitSingularBoolField(value: v, fieldNumber: 5) + try { if let v = self._deprecationWarning { + try visitor.visitSingularStringField(value: v, fieldNumber: 3) } }() - try { if let v = self._jstype { - try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + try { if let v = self._editionRemoved { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) } }() - try { if let v = self._weak { - try visitor.visitSingularBoolField(value: v, fieldNumber: 10) + try { if let v = self._removalError { + try visitor.visitSingularStringField(value: v, fieldNumber: 5) } }() - if !self.uninterpretedOption.isEmpty { - try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) - } - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) try unknownFields.traverse(visitor: &visitor) } - public static func ==(lhs: Google_Protobuf_FieldOptions, rhs: Google_Protobuf_FieldOptions) -> Bool { - if lhs._ctype != rhs._ctype {return false} - if lhs._packed != rhs._packed {return false} - if lhs._jstype != rhs._jstype {return false} - if lhs._lazy != rhs._lazy {return false} - if lhs._deprecated != rhs._deprecated {return false} - if lhs._weak != rhs._weak {return false} - if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} + public static func ==(lhs: Google_Protobuf_FieldOptions.FeatureSupport, rhs: Google_Protobuf_FieldOptions.FeatureSupport) -> Bool { + if lhs._editionIntroduced != rhs._editionIntroduced {return false} + if lhs._editionDeprecated != rhs._editionDeprecated {return false} + if lhs._deprecationWarning != rhs._deprecationWarning {return false} + if lhs._editionRemoved != rhs._editionRemoved {return false} + if lhs._removalError != rhs._removalError {return false} if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension Google_Protobuf_FieldOptions.CType: SwiftProtobuf._ProtoNameProviding { - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "STRING"), - 1: .same(proto: "CORD"), - 2: .same(proto: "STRING_PIECE"), - ] -} - -extension Google_Protobuf_FieldOptions.JSType: SwiftProtobuf._ProtoNameProviding { - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "JS_NORMAL"), - 1: .same(proto: "JS_STRING"), - 2: .same(proto: "JS_NUMBER"), - ] -} - -extension Google_Protobuf_OneofOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_OneofOptions: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".OneofOptions" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 999: .standard(proto: "uninterpreted_option"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}features\0\u{4}f\u{f}uninterpreted_option\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.uninterpretedOption) {return false} + if let v = self._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} return true } - public mutating func decodeMessage(decoder: inout D) throws { + public 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.decodeSingularMessageField(value: &self._features) }() case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() case 1000..<536870912: try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_OneofOptions.self, fieldNumber: fieldNumber) }() @@ -3412,7 +4435,14 @@ extension Google_Protobuf_OneofOptions: SwiftProtobuf.Message, SwiftProtobuf._Me } } - public func traverse(visitor: inout V) throws { + public 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 + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() if !self.uninterpretedOption.isEmpty { try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) } @@ -3421,6 +4451,7 @@ extension Google_Protobuf_OneofOptions: SwiftProtobuf.Message, SwiftProtobuf._Me } public static func ==(lhs: Google_Protobuf_OneofOptions, rhs: Google_Protobuf_OneofOptions) -> Bool { + if lhs._features != rhs._features {return false} if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} @@ -3428,21 +4459,18 @@ extension Google_Protobuf_OneofOptions: SwiftProtobuf.Message, SwiftProtobuf._Me } } -extension Google_Protobuf_EnumOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_EnumOptions: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".EnumOptions" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2: .standard(proto: "allow_alias"), - 3: .same(proto: "deprecated"), - 999: .standard(proto: "uninterpreted_option"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{4}\u{2}allow_alias\0\u{1}deprecated\0\u{4}\u{3}deprecated_legacy_json_field_conflicts\0\u{1}features\0\u{4}`\u{f}uninterpreted_option\0\u{c}\u{5}\u{1}") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.uninterpretedOption) {return false} + if let v = self._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} return true } - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -3450,6 +4478,8 @@ extension Google_Protobuf_EnumOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes switch fieldNumber { case 2: try { try decoder.decodeSingularBoolField(value: &self._allowAlias) }() case 3: try { try decoder.decodeSingularBoolField(value: &self._deprecated) }() + case 6: try { try decoder.decodeSingularBoolField(value: &self._deprecatedLegacyJsonFieldConflicts) }() + case 7: try { try decoder.decodeSingularMessageField(value: &self._features) }() case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() case 1000..<536870912: try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_EnumOptions.self, fieldNumber: fieldNumber) }() @@ -3458,7 +4488,7 @@ extension Google_Protobuf_EnumOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes } } - public func traverse(visitor: inout V) throws { + public 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 @@ -3469,6 +4499,12 @@ extension Google_Protobuf_EnumOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes try { if let v = self._deprecated { try visitor.visitSingularBoolField(value: v, fieldNumber: 3) } }() + try { if let v = self._deprecatedLegacyJsonFieldConflicts { + try visitor.visitSingularBoolField(value: v, fieldNumber: 6) + } }() + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 7) + } }() if !self.uninterpretedOption.isEmpty { try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) } @@ -3479,6 +4515,8 @@ extension Google_Protobuf_EnumOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes public static func ==(lhs: Google_Protobuf_EnumOptions, rhs: Google_Protobuf_EnumOptions) -> Bool { if lhs._allowAlias != rhs._allowAlias {return false} if lhs._deprecated != rhs._deprecated {return false} + if lhs._deprecatedLegacyJsonFieldConflicts != rhs._deprecatedLegacyJsonFieldConflicts {return false} + if lhs._features != rhs._features {return false} if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} @@ -3486,26 +4524,27 @@ extension Google_Protobuf_EnumOptions: SwiftProtobuf.Message, SwiftProtobuf._Mes } } -extension Google_Protobuf_EnumValueOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_EnumValueOptions: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".EnumValueOptions" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "deprecated"), - 999: .standard(proto: "uninterpreted_option"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}deprecated\0\u{1}features\0\u{3}debug_redact\0\u{3}feature_support\0\u{4}c\u{f}uninterpreted_option\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.uninterpretedOption) {return false} + if let v = self._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} return true } - public mutating func decodeMessage(decoder: inout D) throws { + public 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.decodeSingularBoolField(value: &self._deprecated) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._features) }() + case 3: try { try decoder.decodeSingularBoolField(value: &self._debugRedact) }() + case 4: try { try decoder.decodeSingularMessageField(value: &self._featureSupport) }() case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() case 1000..<536870912: try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_EnumValueOptions.self, fieldNumber: fieldNumber) }() @@ -3514,7 +4553,7 @@ extension Google_Protobuf_EnumValueOptions: SwiftProtobuf.Message, SwiftProtobuf } } - public func traverse(visitor: inout V) throws { + public 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 @@ -3522,6 +4561,15 @@ extension Google_Protobuf_EnumValueOptions: SwiftProtobuf.Message, SwiftProtobuf try { if let v = self._deprecated { try visitor.visitSingularBoolField(value: v, fieldNumber: 1) } }() + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + try { if let v = self._debugRedact { + try visitor.visitSingularBoolField(value: v, fieldNumber: 3) + } }() + try { if let v = self._featureSupport { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() if !self.uninterpretedOption.isEmpty { try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) } @@ -3531,6 +4579,9 @@ extension Google_Protobuf_EnumValueOptions: SwiftProtobuf.Message, SwiftProtobuf public static func ==(lhs: Google_Protobuf_EnumValueOptions, rhs: Google_Protobuf_EnumValueOptions) -> Bool { if lhs._deprecated != rhs._deprecated {return false} + if lhs._features != rhs._features {return false} + if lhs._debugRedact != rhs._debugRedact {return false} + if lhs._featureSupport != rhs._featureSupport {return false} if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} @@ -3538,26 +4589,25 @@ extension Google_Protobuf_EnumValueOptions: SwiftProtobuf.Message, SwiftProtobuf } } -extension Google_Protobuf_ServiceOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_ServiceOptions: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".ServiceOptions" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 33: .same(proto: "deprecated"), - 999: .standard(proto: "uninterpreted_option"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}!deprecated\0\u{1}features\0\u{4}E\u{f}uninterpreted_option\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.uninterpretedOption) {return false} + if let v = self._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} return true } - public mutating func decodeMessage(decoder: inout D) throws { + public 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 33: try { try decoder.decodeSingularBoolField(value: &self._deprecated) }() + case 34: try { try decoder.decodeSingularMessageField(value: &self._features) }() case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() case 1000..<536870912: try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_ServiceOptions.self, fieldNumber: fieldNumber) }() @@ -3566,7 +4616,7 @@ extension Google_Protobuf_ServiceOptions: SwiftProtobuf.Message, SwiftProtobuf._ } } - public func traverse(visitor: inout V) throws { + public 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 @@ -3574,6 +4624,9 @@ extension Google_Protobuf_ServiceOptions: SwiftProtobuf.Message, SwiftProtobuf._ try { if let v = self._deprecated { try visitor.visitSingularBoolField(value: v, fieldNumber: 33) } }() + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 34) + } }() if !self.uninterpretedOption.isEmpty { try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) } @@ -3582,6 +4635,7 @@ extension Google_Protobuf_ServiceOptions: SwiftProtobuf.Message, SwiftProtobuf._ } public static func ==(lhs: Google_Protobuf_ServiceOptions, rhs: Google_Protobuf_ServiceOptions) -> Bool { + if lhs._features != rhs._features {return false} if lhs._deprecated != rhs._deprecated {return false} if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -3590,21 +4644,18 @@ extension Google_Protobuf_ServiceOptions: SwiftProtobuf.Message, SwiftProtobuf._ } } -extension Google_Protobuf_MethodOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_MethodOptions: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".MethodOptions" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 33: .same(proto: "deprecated"), - 34: .standard(proto: "idempotency_level"), - 999: .standard(proto: "uninterpreted_option"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}!deprecated\0\u{3}idempotency_level\0\u{1}features\0\u{4}D\u{f}uninterpreted_option\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.uninterpretedOption) {return false} + if let v = self._features, !v.isInitialized {return false} + if !Internal.areAllInitialized(self.uninterpretedOption) {return false} return true } - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -3612,6 +4663,7 @@ extension Google_Protobuf_MethodOptions: SwiftProtobuf.Message, SwiftProtobuf._M switch fieldNumber { case 33: try { try decoder.decodeSingularBoolField(value: &self._deprecated) }() case 34: try { try decoder.decodeSingularEnumField(value: &self._idempotencyLevel) }() + case 35: try { try decoder.decodeSingularMessageField(value: &self._features) }() case 999: try { try decoder.decodeRepeatedMessageField(value: &self.uninterpretedOption) }() case 1000..<536870912: try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_MethodOptions.self, fieldNumber: fieldNumber) }() @@ -3620,7 +4672,7 @@ extension Google_Protobuf_MethodOptions: SwiftProtobuf.Message, SwiftProtobuf._M } } - public func traverse(visitor: inout V) throws { + public 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 @@ -3631,6 +4683,9 @@ extension Google_Protobuf_MethodOptions: SwiftProtobuf.Message, SwiftProtobuf._M try { if let v = self._idempotencyLevel { try visitor.visitSingularEnumField(value: v, fieldNumber: 34) } }() + try { if let v = self._features { + try visitor.visitSingularMessageField(value: v, fieldNumber: 35) + } }() if !self.uninterpretedOption.isEmpty { try visitor.visitRepeatedMessageField(value: self.uninterpretedOption, fieldNumber: 999) } @@ -3641,6 +4696,7 @@ extension Google_Protobuf_MethodOptions: SwiftProtobuf.Message, SwiftProtobuf._M public static func ==(lhs: Google_Protobuf_MethodOptions, rhs: Google_Protobuf_MethodOptions) -> Bool { if lhs._deprecated != rhs._deprecated {return false} if lhs._idempotencyLevel != rhs._idempotencyLevel {return false} + if lhs._features != rhs._features {return false} if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} @@ -3648,32 +4704,20 @@ extension Google_Protobuf_MethodOptions: SwiftProtobuf.Message, SwiftProtobuf._M } } -extension Google_Protobuf_MethodOptions.IdempotencyLevel: SwiftProtobuf._ProtoNameProviding { - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "IDEMPOTENCY_UNKNOWN"), - 1: .same(proto: "NO_SIDE_EFFECTS"), - 2: .same(proto: "IDEMPOTENT"), - ] +extension Google_Protobuf_MethodOptions.IdempotencyLevel: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0IDEMPOTENCY_UNKNOWN\0\u{1}NO_SIDE_EFFECTS\0\u{1}IDEMPOTENT\0") } -extension Google_Protobuf_UninterpretedOption: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_UninterpretedOption: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".UninterpretedOption" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2: .same(proto: "name"), - 3: .standard(proto: "identifier_value"), - 4: .standard(proto: "positive_int_value"), - 5: .standard(proto: "negative_int_value"), - 6: .standard(proto: "double_value"), - 7: .standard(proto: "string_value"), - 8: .standard(proto: "aggregate_value"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\u{2}name\0\u{3}identifier_value\0\u{3}positive_int_value\0\u{3}negative_int_value\0\u{3}double_value\0\u{3}string_value\0\u{3}aggregate_value\0") public var isInitialized: Bool { - if !SwiftProtobuf.Internal.areAllInitialized(self.name) {return false} + if !Internal.areAllInitialized(self.name) {return false} return true } - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -3691,7 +4735,7 @@ extension Google_Protobuf_UninterpretedOption: SwiftProtobuf.Message, SwiftProto } } - public func traverse(visitor: inout V) throws { + public 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 @@ -3733,12 +4777,9 @@ extension Google_Protobuf_UninterpretedOption: SwiftProtobuf.Message, SwiftProto } } -extension Google_Protobuf_UninterpretedOption.NamePart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_UninterpretedOption.NamePart: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = Google_Protobuf_UninterpretedOption.protoMessageName + ".NamePart" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "name_part"), - 2: .standard(proto: "is_extension"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}name_part\0\u{3}is_extension\0") public var isInitialized: Bool { if self._namePart == nil {return false} @@ -3746,7 +4787,7 @@ extension Google_Protobuf_UninterpretedOption.NamePart: SwiftProtobuf.Message, S return true } - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -3759,7 +4800,7 @@ extension Google_Protobuf_UninterpretedOption.NamePart: SwiftProtobuf.Message, S } } - public func traverse(visitor: inout V) throws { + public 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 @@ -3781,49 +4822,320 @@ extension Google_Protobuf_UninterpretedOption.NamePart: SwiftProtobuf.Message, S } } -extension Google_Protobuf_SourceCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_FeatureSet: Message, _MessageImplementationBase, _ProtoNameProviding { + public static let protoMessageName: String = _protobuf_package + ".FeatureSet" + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}field_presence\0\u{3}enum_type\0\u{3}repeated_field_encoding\0\u{3}utf8_validation\0\u{3}message_encoding\0\u{3}json_format\0\u{3}enforce_naming_style\0\u{3}default_symbol_visibility\0\u{c}g\u{f}\u{1}") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + public 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._fieldPresence) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self._enumType) }() + case 3: try { try decoder.decodeSingularEnumField(value: &self._repeatedFieldEncoding) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._utf8Validation) }() + case 5: try { try decoder.decodeSingularEnumField(value: &self._messageEncoding) }() + case 6: try { try decoder.decodeSingularEnumField(value: &self._jsonFormat) }() + case 7: try { try decoder.decodeSingularEnumField(value: &self._enforceNamingStyle) }() + case 8: try { try decoder.decodeSingularEnumField(value: &self._defaultSymbolVisibility) }() + case 1000..<10001: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_FeatureSet.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + + public 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 + try { if let v = self._fieldPresence { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = self._enumType { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) + } }() + try { if let v = self._repeatedFieldEncoding { + try visitor.visitSingularEnumField(value: v, fieldNumber: 3) + } }() + try { if let v = self._utf8Validation { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + try { if let v = self._messageEncoding { + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + } }() + try { if let v = self._jsonFormat { + try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + } }() + try { if let v = self._enforceNamingStyle { + try visitor.visitSingularEnumField(value: v, fieldNumber: 7) + } }() + try { if let v = self._defaultSymbolVisibility { + try visitor.visitSingularEnumField(value: v, fieldNumber: 8) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 10001) + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: Google_Protobuf_FeatureSet, rhs: Google_Protobuf_FeatureSet) -> Bool { + if lhs._fieldPresence != rhs._fieldPresence {return false} + if lhs._enumType != rhs._enumType {return false} + if lhs._repeatedFieldEncoding != rhs._repeatedFieldEncoding {return false} + if lhs._utf8Validation != rhs._utf8Validation {return false} + if lhs._messageEncoding != rhs._messageEncoding {return false} + if lhs._jsonFormat != rhs._jsonFormat {return false} + if lhs._enforceNamingStyle != rhs._enforceNamingStyle {return false} + if lhs._defaultSymbolVisibility != rhs._defaultSymbolVisibility {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension Google_Protobuf_FeatureSet.FieldPresence: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0FIELD_PRESENCE_UNKNOWN\0\u{1}EXPLICIT\0\u{1}IMPLICIT\0\u{1}LEGACY_REQUIRED\0") +} + +extension Google_Protobuf_FeatureSet.EnumType: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0ENUM_TYPE_UNKNOWN\0\u{1}OPEN\0\u{1}CLOSED\0") +} + +extension Google_Protobuf_FeatureSet.RepeatedFieldEncoding: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0REPEATED_FIELD_ENCODING_UNKNOWN\0\u{1}PACKED\0\u{1}EXPANDED\0") +} + +extension Google_Protobuf_FeatureSet.Utf8Validation: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0UTF8_VALIDATION_UNKNOWN\0\u{2}\u{2}VERIFY\0\u{1}NONE\0") +} + +extension Google_Protobuf_FeatureSet.MessageEncoding: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0MESSAGE_ENCODING_UNKNOWN\0\u{1}LENGTH_PREFIXED\0\u{1}DELIMITED\0") +} + +extension Google_Protobuf_FeatureSet.JsonFormat: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0JSON_FORMAT_UNKNOWN\0\u{1}ALLOW\0\u{1}LEGACY_BEST_EFFORT\0") +} + +extension Google_Protobuf_FeatureSet.EnforceNamingStyle: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0ENFORCE_NAMING_STYLE_UNKNOWN\0\u{1}STYLE2024\0\u{1}STYLE_LEGACY\0") +} + +extension Google_Protobuf_FeatureSet.VisibilityFeature: Message, _MessageImplementationBase, _ProtoNameProviding { + public static let protoMessageName: String = Google_Protobuf_FeatureSet.protoMessageName + ".VisibilityFeature" + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{c}\u{1}\u{7f}\u{7f}\u{7f}\u{7f}\u{1f}") + + public mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + public func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: Google_Protobuf_FeatureSet.VisibilityFeature, rhs: Google_Protobuf_FeatureSet.VisibilityFeature) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_FeatureSet.VisibilityFeature.DefaultSymbolVisibility: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0DEFAULT_SYMBOL_VISIBILITY_UNKNOWN\0\u{1}EXPORT_ALL\0\u{1}EXPORT_TOP_LEVEL\0\u{1}LOCAL_ALL\0\u{1}STRICT\0") +} + +extension Google_Protobuf_FeatureSetDefaults: Message, _MessageImplementationBase, _ProtoNameProviding { + public static let protoMessageName: String = _protobuf_package + ".FeatureSetDefaults" + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}defaults\0\u{4}\u{3}minimum_edition\0\u{3}maximum_edition\0") + + public var isInitialized: Bool { + if !Internal.areAllInitialized(self.defaults) {return false} + return true + } + + public 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.decodeRepeatedMessageField(value: &self.defaults) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._minimumEdition) }() + case 5: try { try decoder.decodeSingularEnumField(value: &self._maximumEdition) }() + default: break + } + } + } + + public 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 + if !self.defaults.isEmpty { + try visitor.visitRepeatedMessageField(value: self.defaults, fieldNumber: 1) + } + try { if let v = self._minimumEdition { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + try { if let v = self._maximumEdition { + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: Google_Protobuf_FeatureSetDefaults, rhs: Google_Protobuf_FeatureSetDefaults) -> Bool { + if lhs.defaults != rhs.defaults {return false} + if lhs._minimumEdition != rhs._minimumEdition {return false} + if lhs._maximumEdition != rhs._maximumEdition {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_FeatureSetDefaults.FeatureSetEditionDefault: Message, _MessageImplementationBase, _ProtoNameProviding { + public static let protoMessageName: String = Google_Protobuf_FeatureSetDefaults.protoMessageName + ".FeatureSetEditionDefault" + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\u{3}edition\0\u{3}overridable_features\0\u{3}fixed_features\0\u{b}features\0\u{c}\u{1}\u{1}\u{c}\u{2}\u{1}") + + fileprivate class _StorageClass { + var _edition: Google_Protobuf_Edition? = nil + var _overridableFeatures: Google_Protobuf_FeatureSet? = nil + var _fixedFeatures: Google_Protobuf_FeatureSet? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _edition = source._edition + _overridableFeatures = source._overridableFeatures + _fixedFeatures = source._fixedFeatures + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._overridableFeatures, !v.isInitialized {return false} + if let v = _storage._fixedFeatures, !v.isInitialized {return false} + return true + } + } + + public mutating func decodeMessage(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 3: try { try decoder.decodeSingularEnumField(value: &_storage._edition) }() + case 4: try { try decoder.decodeSingularMessageField(value: &_storage._overridableFeatures) }() + case 5: try { try decoder.decodeSingularMessageField(value: &_storage._fixedFeatures) }() + default: break + } + } + } + } + + public func traverse(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._edition { + try visitor.visitSingularEnumField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._overridableFeatures { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._fixedFeatures { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + public static func ==(lhs: Google_Protobuf_FeatureSetDefaults.FeatureSetEditionDefault, rhs: Google_Protobuf_FeatureSetDefaults.FeatureSetEditionDefault) -> 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._edition != rhs_storage._edition {return false} + if _storage._overridableFeatures != rhs_storage._overridableFeatures {return false} + if _storage._fixedFeatures != rhs_storage._fixedFeatures {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension Google_Protobuf_SourceCodeInfo: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".SourceCodeInfo" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "location"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}location\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } - public mutating func decodeMessage(decoder: inout D) throws { + public 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.decodeRepeatedMessageField(value: &self.location) }() + case 536000000: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Google_Protobuf_SourceCodeInfo.self, fieldNumber: fieldNumber) }() default: break } } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if !self.location.isEmpty { try visitor.visitRepeatedMessageField(value: self.location, fieldNumber: 1) } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 536000000, end: 536000001) try unknownFields.traverse(visitor: &visitor) } public static func ==(lhs: Google_Protobuf_SourceCodeInfo, rhs: Google_Protobuf_SourceCodeInfo) -> Bool { if lhs.location != rhs.location {return false} if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension Google_Protobuf_SourceCodeInfo.Location: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_SourceCodeInfo.Location: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = Google_Protobuf_SourceCodeInfo.protoMessageName + ".Location" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "path"), - 2: .same(proto: "span"), - 3: .standard(proto: "leading_comments"), - 4: .standard(proto: "trailing_comments"), - 6: .standard(proto: "leading_detached_comments"), - ] - - public mutating func decodeMessage(decoder: inout D) throws { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}path\0\u{1}span\0\u{3}leading_comments\0\u{3}trailing_comments\0\u{4}\u{2}leading_detached_comments\0") + + public 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 @@ -3839,7 +5151,7 @@ extension Google_Protobuf_SourceCodeInfo.Location: SwiftProtobuf.Message, SwiftP } } - public func traverse(visitor: inout V) throws { + public 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 @@ -3873,13 +5185,11 @@ extension Google_Protobuf_SourceCodeInfo.Location: SwiftProtobuf.Message, SwiftP } } -extension Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_GeneratedCodeInfo: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".GeneratedCodeInfo" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "annotation"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}annotation\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -3891,7 +5201,7 @@ extension Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf.Message, SwiftProtobu } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if !self.annotation.isEmpty { try visitor.visitRepeatedMessageField(value: self.annotation, fieldNumber: 1) } @@ -3905,16 +5215,11 @@ extension Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf.Message, SwiftProtobu } } -extension Google_Protobuf_GeneratedCodeInfo.Annotation: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_GeneratedCodeInfo.Annotation: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = Google_Protobuf_GeneratedCodeInfo.protoMessageName + ".Annotation" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "path"), - 2: .standard(proto: "source_file"), - 3: .same(proto: "begin"), - 4: .same(proto: "end"), - ] - - public mutating func decodeMessage(decoder: inout D) throws { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}path\0\u{3}source_file\0\u{1}begin\0\u{1}end\0\u{1}semantic\0") + + public 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 @@ -3924,12 +5229,13 @@ extension Google_Protobuf_GeneratedCodeInfo.Annotation: SwiftProtobuf.Message, S case 2: try { try decoder.decodeSingularStringField(value: &self._sourceFile) }() case 3: try { try decoder.decodeSingularInt32Field(value: &self._begin) }() case 4: try { try decoder.decodeSingularInt32Field(value: &self._end) }() + case 5: try { try decoder.decodeSingularEnumField(value: &self._semantic) }() default: break } } } - public func traverse(visitor: inout V) throws { + public 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 @@ -3946,6 +5252,9 @@ extension Google_Protobuf_GeneratedCodeInfo.Annotation: SwiftProtobuf.Message, S try { if let v = self._end { try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) } }() + try { if let v = self._semantic { + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + } }() try unknownFields.traverse(visitor: &visitor) } @@ -3954,7 +5263,12 @@ extension Google_Protobuf_GeneratedCodeInfo.Annotation: SwiftProtobuf.Message, S if lhs._sourceFile != rhs._sourceFile {return false} if lhs._begin != rhs._begin {return false} if lhs._end != rhs._end {return false} + if lhs._semantic != rhs._semantic {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } + +extension Google_Protobuf_GeneratedCodeInfo.Annotation.Semantic: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0NONE\0\u{1}SET\0\u{1}ALIAS\0") +} diff --git a/Sources/SwiftProtobuf/duration.pb.swift b/Sources/SwiftProtobuf/duration.pb.swift index bbde204b4..0acfc1800 100644 --- a/Sources/SwiftProtobuf/duration.pb.swift +++ b/Sources/SwiftProtobuf/duration.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/duration.proto @@ -37,15 +38,15 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } @@ -107,7 +108,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should /// be expressed in JSON format as "3.000000001s", and 3 seconds and 1 /// microsecond should be expressed in JSON format as "3.000001s". -public struct Google_Protobuf_Duration { +public struct Google_Protobuf_Duration: Sendable { // 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. @@ -125,27 +126,20 @@ public struct Google_Protobuf_Duration { /// to +999,999,999 inclusive. public var nanos: Int32 = 0 - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_Duration: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_Duration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Duration: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".Duration" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "seconds"), - 2: .same(proto: "nanos"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}seconds\0\u{1}nanos\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -158,7 +152,7 @@ extension Google_Protobuf_Duration: SwiftProtobuf.Message, SwiftProtobuf._Messag } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if self.seconds != 0 { try visitor.visitSingularInt64Field(value: self.seconds, fieldNumber: 1) } diff --git a/Sources/SwiftProtobuf/empty.pb.swift b/Sources/SwiftProtobuf/empty.pb.swift index d99089dac..151e4d44a 100644 --- a/Sources/SwiftProtobuf/empty.pb.swift +++ b/Sources/SwiftProtobuf/empty.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/empty.proto @@ -37,15 +38,15 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } @@ -56,36 +57,30 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// service Foo { /// rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); /// } -/// -/// The JSON representation for `Empty` is empty JSON object `{}`. -public struct Google_Protobuf_Empty { +public struct Google_Protobuf_Empty: Sendable { // 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. - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_Empty: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_Empty: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Empty: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".Empty" - public static let _protobuf_nameMap = SwiftProtobuf._NameMap() + public static let _protobuf_nameMap = _NameMap() - public mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + public mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } diff --git a/Sources/SwiftProtobuf/field_mask.pb.swift b/Sources/SwiftProtobuf/field_mask.pb.swift index 31128db44..f748e2865 100644 --- a/Sources/SwiftProtobuf/field_mask.pb.swift +++ b/Sources/SwiftProtobuf/field_mask.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/field_mask.proto @@ -37,15 +38,15 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } @@ -248,7 +249,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// The implementation of any API method which has a FieldMask type field in the /// request should verify the included field paths, and return an /// `INVALID_ARGUMENT` error if any path is unmappable. -public struct Google_Protobuf_FieldMask { +public struct Google_Protobuf_FieldMask: Sendable { // 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. @@ -256,26 +257,20 @@ public struct Google_Protobuf_FieldMask { /// The set of field mask paths. public var paths: [String] = [] - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_FieldMask: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_FieldMask: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_FieldMask: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".FieldMask" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "paths"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}paths\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -287,7 +282,7 @@ extension Google_Protobuf_FieldMask: SwiftProtobuf.Message, SwiftProtobuf._Messa } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if !self.paths.isEmpty { try visitor.visitRepeatedStringField(value: self.paths, fieldNumber: 1) } diff --git a/Sources/SwiftProtobuf/source_context.pb.swift b/Sources/SwiftProtobuf/source_context.pb.swift index f7070bb40..442a1e1f6 100644 --- a/Sources/SwiftProtobuf/source_context.pb.swift +++ b/Sources/SwiftProtobuf/source_context.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/source_context.proto @@ -37,21 +38,21 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } /// `SourceContext` represents information about the source of a /// protobuf element, like the file in which it is defined. -public struct Google_Protobuf_SourceContext { +public struct Google_Protobuf_SourceContext: Sendable { // 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. @@ -60,26 +61,20 @@ public struct Google_Protobuf_SourceContext { /// protobuf element. For example: `"google/protobuf/source_context.proto"`. public var fileName: String = String() - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_SourceContext: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_SourceContext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_SourceContext: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".SourceContext" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "file_name"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}file_name\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -91,7 +86,7 @@ extension Google_Protobuf_SourceContext: SwiftProtobuf.Message, SwiftProtobuf._M } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if !self.fileName.isEmpty { try visitor.visitSingularStringField(value: self.fileName, fieldNumber: 1) } diff --git a/Sources/SwiftProtobuf/struct.pb.swift b/Sources/SwiftProtobuf/struct.pb.swift index b6049b2d0..c4475b0a4 100644 --- a/Sources/SwiftProtobuf/struct.pb.swift +++ b/Sources/SwiftProtobuf/struct.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/struct.proto @@ -37,23 +38,23 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } /// `NullValue` is a singleton enumeration to represent the null value for the /// `Value` type union. /// -/// The JSON representation for `NullValue` is JSON `null`. -public enum Google_Protobuf_NullValue: SwiftProtobuf.Enum { +/// The JSON representation for `NullValue` is JSON `null`. +public enum Google_Protobuf_NullValue: Enum, Swift.CaseIterable { public typealias RawValue = Int /// Null value. @@ -78,18 +79,12 @@ public enum Google_Protobuf_NullValue: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension Google_Protobuf_NullValue: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - public static var allCases: [Google_Protobuf_NullValue] = [ + public static let allCases: [Google_Protobuf_NullValue] = [ .nullValue, ] -} -#endif // swift(>=4.2) +} /// `Struct` represents a structured data value, consisting of fields /// which map to dynamically typed values. In some languages, `Struct` @@ -99,7 +94,7 @@ extension Google_Protobuf_NullValue: CaseIterable { /// with the proto support for the language. /// /// The JSON representation for `Struct` is JSON object. -public struct Google_Protobuf_Struct { +public struct Google_Protobuf_Struct: Sendable { // 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. @@ -107,7 +102,7 @@ public struct Google_Protobuf_Struct { /// Unordered map of dynamically typed values. public var fields: Dictionary = [:] - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} } @@ -118,7 +113,7 @@ public struct Google_Protobuf_Struct { /// variants. Absence of any variant indicates an error. /// /// The JSON representation for `Value` is JSON value. -public struct Google_Protobuf_Value { +public struct Google_Protobuf_Value: Sendable { // 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. @@ -180,10 +175,10 @@ public struct Google_Protobuf_Value { set {kind = .listValue(newValue)} } - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() /// The kind of value. - public enum OneOf_Kind: Equatable { + public enum OneOf_Kind: Equatable, Sendable { /// Represents a null value. case nullValue(Google_Protobuf_NullValue) /// Represents a double value. @@ -197,40 +192,6 @@ public struct Google_Protobuf_Value { /// Represents a repeated `Value`. case listValue(Google_Protobuf_ListValue) - #if !swift(>=4.1) - public static func ==(lhs: Google_Protobuf_Value.OneOf_Kind, rhs: Google_Protobuf_Value.OneOf_Kind) -> 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 (.nullValue, .nullValue): return { - guard case .nullValue(let l) = lhs, case .nullValue(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.numberValue, .numberValue): return { - guard case .numberValue(let l) = lhs, case .numberValue(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.stringValue, .stringValue): return { - guard case .stringValue(let l) = lhs, case .stringValue(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.boolValue, .boolValue): return { - guard case .boolValue(let l) = lhs, case .boolValue(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.structValue, .structValue): return { - guard case .structValue(let l) = lhs, case .structValue(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.listValue, .listValue): return { - guard case .listValue(let l) = lhs, case .listValue(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } public init() {} @@ -239,7 +200,7 @@ public struct Google_Protobuf_Value { /// `ListValue` is a wrapper around a repeated field of values. /// /// The JSON representation for `ListValue` is JSON array. -public struct Google_Protobuf_ListValue { +public struct Google_Protobuf_ListValue: Sendable { // 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. @@ -247,50 +208,38 @@ public struct Google_Protobuf_ListValue { /// Repeated field of dynamically typed values. public var values: [Google_Protobuf_Value] = [] - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_NullValue: @unchecked Sendable {} -extension Google_Protobuf_Struct: @unchecked Sendable {} -extension Google_Protobuf_Value: @unchecked Sendable {} -extension Google_Protobuf_Value.OneOf_Kind: @unchecked Sendable {} -extension Google_Protobuf_ListValue: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_NullValue: SwiftProtobuf._ProtoNameProviding { - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NULL_VALUE"), - ] +extension Google_Protobuf_NullValue: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0NULL_VALUE\0") } -extension Google_Protobuf_Struct: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Struct: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".Struct" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fields"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}fields\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.fields) }() + case 1: try { try decoder.decodeMapField(fieldType: _ProtobufMessageMap.self, value: &self.fields) }() default: break } } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if !self.fields.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.fields, fieldNumber: 1) + try visitor.visitMapField(fieldType: _ProtobufMessageMap.self, value: self.fields, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } @@ -302,18 +251,11 @@ extension Google_Protobuf_Struct: SwiftProtobuf.Message, SwiftProtobuf._MessageI } } -extension Google_Protobuf_Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Value: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".Value" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "null_value"), - 2: .standard(proto: "number_value"), - 3: .standard(proto: "string_value"), - 4: .standard(proto: "bool_value"), - 5: .standard(proto: "struct_value"), - 6: .standard(proto: "list_value"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{3}null_value\0\u{3}number_value\0\u{3}string_value\0\u{3}bool_value\0\u{3}struct_value\0\u{3}list_value\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -382,7 +324,7 @@ extension Google_Protobuf_Value: SwiftProtobuf.Message, SwiftProtobuf._MessageIm } } - public func traverse(visitor: inout V) throws { + public 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 @@ -424,13 +366,11 @@ extension Google_Protobuf_Value: SwiftProtobuf.Message, SwiftProtobuf._MessageIm } } -extension Google_Protobuf_ListValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_ListValue: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".ListValue" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "values"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}values\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -442,7 +382,7 @@ extension Google_Protobuf_ListValue: SwiftProtobuf.Message, SwiftProtobuf._Messa } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if !self.values.isEmpty { try visitor.visitRepeatedMessageField(value: self.values, fieldNumber: 1) } diff --git a/Sources/SwiftProtobuf/timestamp.pb.swift b/Sources/SwiftProtobuf/timestamp.pb.swift index 1562c0ed4..c0d34a4f7 100644 --- a/Sources/SwiftProtobuf/timestamp.pb.swift +++ b/Sources/SwiftProtobuf/timestamp.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/timestamp.proto @@ -37,15 +38,15 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } @@ -99,7 +100,6 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) /// .setNanos((int) ((millis % 1000) * 1000000)).build(); /// -/// /// Example 5: Compute Timestamp from Java `Instant.now()`. /// /// Instant now = Instant.now(); @@ -108,7 +108,6 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// Timestamp.newBuilder().setSeconds(now.getEpochSecond()) /// .setNanos(now.getNano()).build(); /// -/// /// Example 6: Compute Timestamp from current time in Python. /// /// timestamp = Timestamp() @@ -123,8 +122,8 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional /// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), /// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone -/// is required. A proto3 JSON serializer should always use UTC (as indicated by -/// "Z") when printing the Timestamp type and a proto3 JSON parser should be +/// is required. A ProtoJSON serializer should always use UTC (as indicated by +/// "Z") when printing the Timestamp type and a ProtoJSON parser should be /// able to accept both UTC and other timezones (as indicated by an offset). /// /// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past @@ -138,45 +137,39 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with /// the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use /// the Joda Time's [`ISODateTimeFormat.dateTime()`]( -/// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D +/// http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime() /// ) to obtain a formatter capable of generating timestamps in this format. -public struct Google_Protobuf_Timestamp { +public struct Google_Protobuf_Timestamp: Sendable { // 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. - /// Represents seconds of UTC time since Unix epoch - /// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to - /// 9999-12-31T23:59:59Z inclusive. + /// Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must + /// be between -62135596800 and 253402300799 inclusive (which corresponds to + /// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z). public var seconds: Int64 = 0 - /// Non-negative fractions of a second at nanosecond resolution. Negative - /// second values with fractions must still have non-negative nanos values - /// that count forward in time. Must be from 0 to 999,999,999 + /// Non-negative fractions of a second at nanosecond resolution. This field is + /// the nanosecond portion of the duration, not an alternative to seconds. + /// Negative second values with fractions must still have non-negative nanos + /// values that count forward in time. Must be between 0 and 999,999,999 /// inclusive. public var nanos: Int32 = 0 - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_Timestamp: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_Timestamp: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Timestamp: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".Timestamp" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "seconds"), - 2: .same(proto: "nanos"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}seconds\0\u{1}nanos\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -189,7 +182,7 @@ extension Google_Protobuf_Timestamp: SwiftProtobuf.Message, SwiftProtobuf._Messa } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if self.seconds != 0 { try visitor.visitSingularInt64Field(value: self.seconds, fieldNumber: 1) } diff --git a/Sources/SwiftProtobuf/type.pb.swift b/Sources/SwiftProtobuf/type.pb.swift index d781272bd..47f3d936c 100644 --- a/Sources/SwiftProtobuf/type.pb.swift +++ b/Sources/SwiftProtobuf/type.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/type.proto @@ -37,20 +38,20 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } /// The syntax in which a protocol buffer element is defined. -public enum Google_Protobuf_Syntax: SwiftProtobuf.Enum { +public enum Google_Protobuf_Syntax: Enum, Swift.CaseIterable { public typealias RawValue = Int /// Syntax `proto2`. @@ -58,6 +59,9 @@ public enum Google_Protobuf_Syntax: SwiftProtobuf.Enum { /// Syntax `proto3`. case proto3 // = 1 + + /// Syntax `editions`. + case editions // = 2 case UNRECOGNIZED(Int) public init() { @@ -68,6 +72,7 @@ public enum Google_Protobuf_Syntax: SwiftProtobuf.Enum { switch rawValue { case 0: self = .proto2 case 1: self = .proto3 + case 2: self = .editions default: self = .UNRECOGNIZED(rawValue) } } @@ -76,26 +81,27 @@ public enum Google_Protobuf_Syntax: SwiftProtobuf.Enum { switch self { case .proto2: return 0 case .proto3: return 1 + case .editions: return 2 case .UNRECOGNIZED(let i): return i } } -} - -#if swift(>=4.2) - -extension Google_Protobuf_Syntax: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - public static var allCases: [Google_Protobuf_Syntax] = [ + public static let allCases: [Google_Protobuf_Syntax] = [ .proto2, .proto3, + .editions, ] -} -#endif // swift(>=4.2) +} /// A protocol buffer message type. -public struct Google_Protobuf_Type { +/// +/// New usages of this message as an alternative to DescriptorProto are strongly +/// discouraged. This message does not reliability preserve all information +/// necessary to model the schema and preserve semantics. Instead make use of +/// FileDescriptorSet which preserves the necessary information. +public struct Google_Protobuf_Type: Sendable { // 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. @@ -114,18 +120,21 @@ public struct Google_Protobuf_Type { /// The source context. public var sourceContext: Google_Protobuf_SourceContext { - get {return _sourceContext ?? Google_Protobuf_SourceContext()} + get {_sourceContext ?? Google_Protobuf_SourceContext()} set {_sourceContext = newValue} } /// Returns true if `sourceContext` has been explicitly set. - public var hasSourceContext: Bool {return self._sourceContext != nil} + public var hasSourceContext: Bool {self._sourceContext != nil} /// Clears the value of `sourceContext`. Subsequent reads from it will return its default value. public mutating func clearSourceContext() {self._sourceContext = nil} /// The source syntax. public var syntax: Google_Protobuf_Syntax = .proto2 - public var unknownFields = SwiftProtobuf.UnknownStorage() + /// The source edition string, only valid when syntax is SYNTAX_EDITIONS. + public var edition: String = String() + + public var unknownFields = UnknownStorage() public init() {} @@ -133,7 +142,12 @@ public struct Google_Protobuf_Type { } /// A single field of a message type. -public struct Google_Protobuf_Field { +/// +/// New usages of this message as an alternative to FieldDescriptorProto are +/// strongly discouraged. This message does not reliability preserve all +/// information necessary to model the schema and preserve semantics. Instead +/// make use of FileDescriptorSet which preserves the necessary information. +public struct Google_Protobuf_Field: Sendable { // 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. @@ -170,10 +184,10 @@ public struct Google_Protobuf_Field { /// The string value of the default value of this field. Proto2 syntax only. public var defaultValue: String = String() - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() /// Basic field types. - public enum Kind: SwiftProtobuf.Enum { + public enum Kind: Enum, Swift.CaseIterable { public typealias RawValue = Int /// Field type unknown. @@ -288,10 +302,33 @@ public struct Google_Protobuf_Field { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + public static let allCases: [Google_Protobuf_Field.Kind] = [ + .typeUnknown, + .typeDouble, + .typeFloat, + .typeInt64, + .typeUint64, + .typeInt32, + .typeFixed64, + .typeFixed32, + .typeBool, + .typeString, + .typeGroup, + .typeMessage, + .typeBytes, + .typeUint32, + .typeEnum, + .typeSfixed32, + .typeSfixed64, + .typeSint32, + .typeSint64, + ] + } /// Whether a field is optional, required, or repeated. - public enum Cardinality: SwiftProtobuf.Enum { + public enum Cardinality: Enum, Swift.CaseIterable { public typealias RawValue = Int /// For fields with unknown cardinality. @@ -331,52 +368,26 @@ public struct Google_Protobuf_Field { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + public static let allCases: [Google_Protobuf_Field.Cardinality] = [ + .unknown, + .optional, + .required, + .repeated, + ] + } public init() {} } -#if swift(>=4.2) - -extension Google_Protobuf_Field.Kind: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - public static var allCases: [Google_Protobuf_Field.Kind] = [ - .typeUnknown, - .typeDouble, - .typeFloat, - .typeInt64, - .typeUint64, - .typeInt32, - .typeFixed64, - .typeFixed32, - .typeBool, - .typeString, - .typeGroup, - .typeMessage, - .typeBytes, - .typeUint32, - .typeEnum, - .typeSfixed32, - .typeSfixed64, - .typeSint32, - .typeSint64, - ] -} - -extension Google_Protobuf_Field.Cardinality: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - public static var allCases: [Google_Protobuf_Field.Cardinality] = [ - .unknown, - .optional, - .required, - .repeated, - ] -} - -#endif // swift(>=4.2) - /// Enum type definition. -public struct Google_Protobuf_Enum { +/// +/// New usages of this message as an alternative to EnumDescriptorProto are +/// strongly discouraged. This message does not reliability preserve all +/// information necessary to model the schema and preserve semantics. Instead +/// make use of FileDescriptorSet which preserves the necessary information. +public struct Google_Protobuf_Enum: Sendable { // 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. @@ -392,18 +403,21 @@ public struct Google_Protobuf_Enum { /// The source context. public var sourceContext: Google_Protobuf_SourceContext { - get {return _sourceContext ?? Google_Protobuf_SourceContext()} + get {_sourceContext ?? Google_Protobuf_SourceContext()} set {_sourceContext = newValue} } /// Returns true if `sourceContext` has been explicitly set. - public var hasSourceContext: Bool {return self._sourceContext != nil} + public var hasSourceContext: Bool {self._sourceContext != nil} /// Clears the value of `sourceContext`. Subsequent reads from it will return its default value. public mutating func clearSourceContext() {self._sourceContext = nil} /// The source syntax. public var syntax: Google_Protobuf_Syntax = .proto2 - public var unknownFields = SwiftProtobuf.UnknownStorage() + /// The source edition string, only valid when syntax is SYNTAX_EDITIONS. + public var edition: String = String() + + public var unknownFields = UnknownStorage() public init() {} @@ -411,7 +425,12 @@ public struct Google_Protobuf_Enum { } /// Enum value definition. -public struct Google_Protobuf_EnumValue { +/// +/// New usages of this message as an alternative to EnumValueDescriptorProto are +/// strongly discouraged. This message does not reliability preserve all +/// information necessary to model the schema and preserve semantics. Instead +/// make use of FileDescriptorSet which preserves the necessary information. +public struct Google_Protobuf_EnumValue: Sendable { // 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. @@ -425,14 +444,18 @@ public struct Google_Protobuf_EnumValue { /// Protocol buffer options. public var options: [Google_Protobuf_Option] = [] - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} } /// A protocol buffer option, which can be attached to a message, field, /// enumeration, etc. -public struct Google_Protobuf_Option { +/// +/// New usages of this message as an alternative to FileOptions, MessageOptions, +/// FieldOptions, EnumOptions, EnumValueOptions, ServiceOptions, or MethodOptions +/// are strongly discouraged. +public struct Google_Protobuf_Option: Sendable { // 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. @@ -448,55 +471,34 @@ public struct Google_Protobuf_Option { /// should be used. If the value is an enum, it should be stored as an int32 /// value using the google.protobuf.Int32Value type. public var value: Google_Protobuf_Any { - get {return _value ?? Google_Protobuf_Any()} + get {_value ?? Google_Protobuf_Any()} set {_value = newValue} } /// Returns true if `value` has been explicitly set. - public var hasValue: Bool {return self._value != nil} + public var hasValue: Bool {self._value != nil} /// Clears the value of `value`. Subsequent reads from it will return its default value. public mutating func clearValue() {self._value = nil} - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} fileprivate var _value: Google_Protobuf_Any? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_Syntax: @unchecked Sendable {} -extension Google_Protobuf_Type: @unchecked Sendable {} -extension Google_Protobuf_Field: @unchecked Sendable {} -extension Google_Protobuf_Field.Kind: @unchecked Sendable {} -extension Google_Protobuf_Field.Cardinality: @unchecked Sendable {} -extension Google_Protobuf_Enum: @unchecked Sendable {} -extension Google_Protobuf_EnumValue: @unchecked Sendable {} -extension Google_Protobuf_Option: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_Syntax: SwiftProtobuf._ProtoNameProviding { - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "SYNTAX_PROTO2"), - 1: .same(proto: "SYNTAX_PROTO3"), - ] +extension Google_Protobuf_Syntax: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0SYNTAX_PROTO2\0\u{1}SYNTAX_PROTO3\0\u{1}SYNTAX_EDITIONS\0") } -extension Google_Protobuf_Type: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Type: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".Type" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "fields"), - 3: .same(proto: "oneofs"), - 4: .same(proto: "options"), - 5: .standard(proto: "source_context"), - 6: .same(proto: "syntax"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}fields\0\u{1}oneofs\0\u{1}options\0\u{3}source_context\0\u{1}syntax\0\u{1}edition\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -508,12 +510,13 @@ extension Google_Protobuf_Type: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 4: try { try decoder.decodeRepeatedMessageField(value: &self.options) }() case 5: try { try decoder.decodeSingularMessageField(value: &self._sourceContext) }() case 6: try { try decoder.decodeSingularEnumField(value: &self.syntax) }() + case 7: try { try decoder.decodeSingularStringField(value: &self.edition) }() default: break } } } - public func traverse(visitor: inout V) throws { + public 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 @@ -536,6 +539,9 @@ extension Google_Protobuf_Type: SwiftProtobuf.Message, SwiftProtobuf._MessageImp if self.syntax != .proto2 { try visitor.visitSingularEnumField(value: self.syntax, fieldNumber: 6) } + if !self.edition.isEmpty { + try visitor.visitSingularStringField(value: self.edition, fieldNumber: 7) + } try unknownFields.traverse(visitor: &visitor) } @@ -546,27 +552,17 @@ extension Google_Protobuf_Type: SwiftProtobuf.Message, SwiftProtobuf._MessageImp if lhs.options != rhs.options {return false} if lhs._sourceContext != rhs._sourceContext {return false} if lhs.syntax != rhs.syntax {return false} + if lhs.edition != rhs.edition {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Field: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".Field" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "kind"), - 2: .same(proto: "cardinality"), - 3: .same(proto: "number"), - 4: .same(proto: "name"), - 6: .standard(proto: "type_url"), - 7: .standard(proto: "oneof_index"), - 8: .same(proto: "packed"), - 9: .same(proto: "options"), - 10: .standard(proto: "json_name"), - 11: .standard(proto: "default_value"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}kind\0\u{1}cardinality\0\u{1}number\0\u{1}name\0\u{4}\u{2}type_url\0\u{3}oneof_index\0\u{1}packed\0\u{1}options\0\u{3}json_name\0\u{3}default_value\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -587,7 +583,7 @@ extension Google_Protobuf_Field: SwiftProtobuf.Message, SwiftProtobuf._MessageIm } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if self.kind != .typeUnknown { try visitor.visitSingularEnumField(value: self.kind, fieldNumber: 1) } @@ -637,50 +633,19 @@ extension Google_Protobuf_Field: SwiftProtobuf.Message, SwiftProtobuf._MessageIm } } -extension Google_Protobuf_Field.Kind: SwiftProtobuf._ProtoNameProviding { - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "TYPE_UNKNOWN"), - 1: .same(proto: "TYPE_DOUBLE"), - 2: .same(proto: "TYPE_FLOAT"), - 3: .same(proto: "TYPE_INT64"), - 4: .same(proto: "TYPE_UINT64"), - 5: .same(proto: "TYPE_INT32"), - 6: .same(proto: "TYPE_FIXED64"), - 7: .same(proto: "TYPE_FIXED32"), - 8: .same(proto: "TYPE_BOOL"), - 9: .same(proto: "TYPE_STRING"), - 10: .same(proto: "TYPE_GROUP"), - 11: .same(proto: "TYPE_MESSAGE"), - 12: .same(proto: "TYPE_BYTES"), - 13: .same(proto: "TYPE_UINT32"), - 14: .same(proto: "TYPE_ENUM"), - 15: .same(proto: "TYPE_SFIXED32"), - 16: .same(proto: "TYPE_SFIXED64"), - 17: .same(proto: "TYPE_SINT32"), - 18: .same(proto: "TYPE_SINT64"), - ] +extension Google_Protobuf_Field.Kind: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0TYPE_UNKNOWN\0\u{1}TYPE_DOUBLE\0\u{1}TYPE_FLOAT\0\u{1}TYPE_INT64\0\u{1}TYPE_UINT64\0\u{1}TYPE_INT32\0\u{1}TYPE_FIXED64\0\u{1}TYPE_FIXED32\0\u{1}TYPE_BOOL\0\u{1}TYPE_STRING\0\u{1}TYPE_GROUP\0\u{1}TYPE_MESSAGE\0\u{1}TYPE_BYTES\0\u{1}TYPE_UINT32\0\u{1}TYPE_ENUM\0\u{1}TYPE_SFIXED32\0\u{1}TYPE_SFIXED64\0\u{1}TYPE_SINT32\0\u{1}TYPE_SINT64\0") } -extension Google_Protobuf_Field.Cardinality: SwiftProtobuf._ProtoNameProviding { - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "CARDINALITY_UNKNOWN"), - 1: .same(proto: "CARDINALITY_OPTIONAL"), - 2: .same(proto: "CARDINALITY_REQUIRED"), - 3: .same(proto: "CARDINALITY_REPEATED"), - ] +extension Google_Protobuf_Field.Cardinality: _ProtoNameProviding { + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{2}\0CARDINALITY_UNKNOWN\0\u{1}CARDINALITY_OPTIONAL\0\u{1}CARDINALITY_REQUIRED\0\u{1}CARDINALITY_REPEATED\0") } -extension Google_Protobuf_Enum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Enum: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".Enum" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "enumvalue"), - 3: .same(proto: "options"), - 4: .standard(proto: "source_context"), - 5: .same(proto: "syntax"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}enumvalue\0\u{1}options\0\u{3}source_context\0\u{1}syntax\0\u{1}edition\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -691,12 +656,13 @@ extension Google_Protobuf_Enum: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 3: try { try decoder.decodeRepeatedMessageField(value: &self.options) }() case 4: try { try decoder.decodeSingularMessageField(value: &self._sourceContext) }() case 5: try { try decoder.decodeSingularEnumField(value: &self.syntax) }() + case 6: try { try decoder.decodeSingularStringField(value: &self.edition) }() default: break } } } - public func traverse(visitor: inout V) throws { + public 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 @@ -716,6 +682,9 @@ extension Google_Protobuf_Enum: SwiftProtobuf.Message, SwiftProtobuf._MessageImp if self.syntax != .proto2 { try visitor.visitSingularEnumField(value: self.syntax, fieldNumber: 5) } + if !self.edition.isEmpty { + try visitor.visitSingularStringField(value: self.edition, fieldNumber: 6) + } try unknownFields.traverse(visitor: &visitor) } @@ -725,20 +694,17 @@ extension Google_Protobuf_Enum: SwiftProtobuf.Message, SwiftProtobuf._MessageImp if lhs.options != rhs.options {return false} if lhs._sourceContext != rhs._sourceContext {return false} if lhs.syntax != rhs.syntax {return false} + if lhs.edition != rhs.edition {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Google_Protobuf_EnumValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_EnumValue: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".EnumValue" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "number"), - 3: .same(proto: "options"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}number\0\u{1}options\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -752,7 +718,7 @@ extension Google_Protobuf_EnumValue: SwiftProtobuf.Message, SwiftProtobuf._Messa } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if !self.name.isEmpty { try visitor.visitSingularStringField(value: self.name, fieldNumber: 1) } @@ -774,14 +740,11 @@ extension Google_Protobuf_EnumValue: SwiftProtobuf.Message, SwiftProtobuf._Messa } } -extension Google_Protobuf_Option: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Option: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".Option" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .same(proto: "value"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}name\0\u{1}value\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -794,7 +757,7 @@ extension Google_Protobuf_Option: SwiftProtobuf.Message, SwiftProtobuf._MessageI } } - public func traverse(visitor: inout V) throws { + public 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 diff --git a/Sources/SwiftProtobuf/wrappers.pb.swift b/Sources/SwiftProtobuf/wrappers.pb.swift index 312fc3a22..6e7e5624a 100644 --- a/Sources/SwiftProtobuf/wrappers.pb.swift +++ b/Sources/SwiftProtobuf/wrappers.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/wrappers.proto @@ -36,11 +37,18 @@ // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Wrappers for primitive (non-message) types. These types are useful -// for embedding primitives in the `google.protobuf.Any` type and for places -// where we need to distinguish between the absence of a primitive -// typed field and its default value. +// +// Wrappers for primitive (non-message) types. These types were needed +// for legacy reasons and are not recommended for use in new APIs. +// +// Historically these wrappers were useful to have presence on proto3 primitive +// fields, but proto3 syntax has been updated to support the `optional` keyword. +// Using that keyword is now the strongly preferred way to add presence to +// proto3 primitive fields. +// +// A secondary usecase was to embed primitives in the `google.protobuf.Any` +// type: it is now recommended that you embed your value in your own wrapper +// message which can be specifically documented. // // These wrappers have no meaningful use within repeated fields as they lack // the ability to detect presence on individual elements. @@ -48,21 +56,25 @@ // individual entries of a map or fields of a oneof can already detect presence. import Foundation +// 'import SwiftProtobuf' suppressed, this proto file is meant to be bundled in the runtime. // 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 {} +fileprivate struct _GeneratedWithProtocGenSwiftVersion: ProtobufAPIVersionCheck { + struct _2: ProtobufAPIVersion_2 {} typealias Version = _2 } /// Wrapper message for `double`. /// /// The JSON representation for `DoubleValue` is JSON number. -public struct Google_Protobuf_DoubleValue { +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +public struct Google_Protobuf_DoubleValue: Sendable { // 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. @@ -70,7 +82,7 @@ public struct Google_Protobuf_DoubleValue { /// The double value. public var value: Double = 0 - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} } @@ -78,7 +90,10 @@ public struct Google_Protobuf_DoubleValue { /// Wrapper message for `float`. /// /// The JSON representation for `FloatValue` is JSON number. -public struct Google_Protobuf_FloatValue { +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +public struct Google_Protobuf_FloatValue: Sendable { // 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. @@ -86,7 +101,7 @@ public struct Google_Protobuf_FloatValue { /// The float value. public var value: Float = 0 - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} } @@ -94,7 +109,10 @@ public struct Google_Protobuf_FloatValue { /// Wrapper message for `int64`. /// /// The JSON representation for `Int64Value` is JSON string. -public struct Google_Protobuf_Int64Value { +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +public struct Google_Protobuf_Int64Value: Sendable { // 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. @@ -102,7 +120,7 @@ public struct Google_Protobuf_Int64Value { /// The int64 value. public var value: Int64 = 0 - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} } @@ -110,7 +128,10 @@ public struct Google_Protobuf_Int64Value { /// Wrapper message for `uint64`. /// /// The JSON representation for `UInt64Value` is JSON string. -public struct Google_Protobuf_UInt64Value { +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +public struct Google_Protobuf_UInt64Value: Sendable { // 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. @@ -118,7 +139,7 @@ public struct Google_Protobuf_UInt64Value { /// The uint64 value. public var value: UInt64 = 0 - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} } @@ -126,7 +147,10 @@ public struct Google_Protobuf_UInt64Value { /// Wrapper message for `int32`. /// /// The JSON representation for `Int32Value` is JSON number. -public struct Google_Protobuf_Int32Value { +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +public struct Google_Protobuf_Int32Value: Sendable { // 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. @@ -134,7 +158,7 @@ public struct Google_Protobuf_Int32Value { /// The int32 value. public var value: Int32 = 0 - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} } @@ -142,7 +166,10 @@ public struct Google_Protobuf_Int32Value { /// Wrapper message for `uint32`. /// /// The JSON representation for `UInt32Value` is JSON number. -public struct Google_Protobuf_UInt32Value { +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +public struct Google_Protobuf_UInt32Value: Sendable { // 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. @@ -150,7 +177,7 @@ public struct Google_Protobuf_UInt32Value { /// The uint32 value. public var value: UInt32 = 0 - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} } @@ -158,7 +185,10 @@ public struct Google_Protobuf_UInt32Value { /// Wrapper message for `bool`. /// /// The JSON representation for `BoolValue` is JSON `true` and `false`. -public struct Google_Protobuf_BoolValue { +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +public struct Google_Protobuf_BoolValue: Sendable { // 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. @@ -166,7 +196,7 @@ public struct Google_Protobuf_BoolValue { /// The bool value. public var value: Bool = false - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} } @@ -174,7 +204,10 @@ public struct Google_Protobuf_BoolValue { /// Wrapper message for `string`. /// /// The JSON representation for `StringValue` is JSON string. -public struct Google_Protobuf_StringValue { +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +public struct Google_Protobuf_StringValue: Sendable { // 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. @@ -182,7 +215,7 @@ public struct Google_Protobuf_StringValue { /// The string value. public var value: String = String() - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} } @@ -190,7 +223,10 @@ public struct Google_Protobuf_StringValue { /// Wrapper message for `bytes`. /// /// The JSON representation for `BytesValue` is JSON string. -public struct Google_Protobuf_BytesValue { +/// +/// Not recommended for use in new APIs, but still useful for legacy APIs and +/// has no plan to be removed. +public struct Google_Protobuf_BytesValue: Sendable { // 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. @@ -198,34 +234,20 @@ public struct Google_Protobuf_BytesValue { /// The bytes value. public var value: Data = Data() - public var unknownFields = SwiftProtobuf.UnknownStorage() + public var unknownFields = UnknownStorage() public init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_DoubleValue: @unchecked Sendable {} -extension Google_Protobuf_FloatValue: @unchecked Sendable {} -extension Google_Protobuf_Int64Value: @unchecked Sendable {} -extension Google_Protobuf_UInt64Value: @unchecked Sendable {} -extension Google_Protobuf_Int32Value: @unchecked Sendable {} -extension Google_Protobuf_UInt32Value: @unchecked Sendable {} -extension Google_Protobuf_BoolValue: @unchecked Sendable {} -extension Google_Protobuf_StringValue: @unchecked Sendable {} -extension Google_Protobuf_BytesValue: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf" -extension Google_Protobuf_DoubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_DoubleValue: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".DoubleValue" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -237,8 +259,8 @@ extension Google_Protobuf_DoubleValue: SwiftProtobuf.Message, SwiftProtobuf._Mes } } - public func traverse(visitor: inout V) throws { - if self.value != 0 { + public func traverse(visitor: inout V) throws { + if self.value.bitPattern != 0 { try visitor.visitSingularDoubleField(value: self.value, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) @@ -251,13 +273,11 @@ extension Google_Protobuf_DoubleValue: SwiftProtobuf.Message, SwiftProtobuf._Mes } } -extension Google_Protobuf_FloatValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_FloatValue: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".FloatValue" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -269,8 +289,8 @@ extension Google_Protobuf_FloatValue: SwiftProtobuf.Message, SwiftProtobuf._Mess } } - public func traverse(visitor: inout V) throws { - if self.value != 0 { + public func traverse(visitor: inout V) throws { + if self.value.bitPattern != 0 { try visitor.visitSingularFloatField(value: self.value, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) @@ -283,13 +303,11 @@ extension Google_Protobuf_FloatValue: SwiftProtobuf.Message, SwiftProtobuf._Mess } } -extension Google_Protobuf_Int64Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Int64Value: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".Int64Value" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -301,7 +319,7 @@ extension Google_Protobuf_Int64Value: SwiftProtobuf.Message, SwiftProtobuf._Mess } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if self.value != 0 { try visitor.visitSingularInt64Field(value: self.value, fieldNumber: 1) } @@ -315,13 +333,11 @@ extension Google_Protobuf_Int64Value: SwiftProtobuf.Message, SwiftProtobuf._Mess } } -extension Google_Protobuf_UInt64Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_UInt64Value: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".UInt64Value" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -333,7 +349,7 @@ extension Google_Protobuf_UInt64Value: SwiftProtobuf.Message, SwiftProtobuf._Mes } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if self.value != 0 { try visitor.visitSingularUInt64Field(value: self.value, fieldNumber: 1) } @@ -347,13 +363,11 @@ extension Google_Protobuf_UInt64Value: SwiftProtobuf.Message, SwiftProtobuf._Mes } } -extension Google_Protobuf_Int32Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_Int32Value: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".Int32Value" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -365,7 +379,7 @@ extension Google_Protobuf_Int32Value: SwiftProtobuf.Message, SwiftProtobuf._Mess } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if self.value != 0 { try visitor.visitSingularInt32Field(value: self.value, fieldNumber: 1) } @@ -379,13 +393,11 @@ extension Google_Protobuf_Int32Value: SwiftProtobuf.Message, SwiftProtobuf._Mess } } -extension Google_Protobuf_UInt32Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_UInt32Value: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".UInt32Value" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -397,7 +409,7 @@ extension Google_Protobuf_UInt32Value: SwiftProtobuf.Message, SwiftProtobuf._Mes } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if self.value != 0 { try visitor.visitSingularUInt32Field(value: self.value, fieldNumber: 1) } @@ -411,13 +423,11 @@ extension Google_Protobuf_UInt32Value: SwiftProtobuf.Message, SwiftProtobuf._Mes } } -extension Google_Protobuf_BoolValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_BoolValue: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".BoolValue" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -429,7 +439,7 @@ extension Google_Protobuf_BoolValue: SwiftProtobuf.Message, SwiftProtobuf._Messa } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if self.value != false { try visitor.visitSingularBoolField(value: self.value, fieldNumber: 1) } @@ -443,13 +453,11 @@ extension Google_Protobuf_BoolValue: SwiftProtobuf.Message, SwiftProtobuf._Messa } } -extension Google_Protobuf_StringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_StringValue: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".StringValue" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -461,7 +469,7 @@ extension Google_Protobuf_StringValue: SwiftProtobuf.Message, SwiftProtobuf._Mes } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if !self.value.isEmpty { try visitor.visitSingularStringField(value: self.value, fieldNumber: 1) } @@ -475,13 +483,11 @@ extension Google_Protobuf_StringValue: SwiftProtobuf.Message, SwiftProtobuf._Mes } } -extension Google_Protobuf_BytesValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension Google_Protobuf_BytesValue: Message, _MessageImplementationBase, _ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".BytesValue" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] + public static let _protobuf_nameMap = _NameMap(bytecode: "\0\u{1}value\0") - public mutating func decodeMessage(decoder: inout D) throws { + public 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 @@ -493,7 +499,7 @@ extension Google_Protobuf_BytesValue: SwiftProtobuf.Message, SwiftProtobuf._Mess } } - public func traverse(visitor: inout V) throws { + public func traverse(visitor: inout V) throws { if !self.value.isEmpty { try visitor.visitSingularBytesField(value: self.value, fieldNumber: 1) } diff --git a/Sources/SwiftProtobufPluginLibrary/Array+Extensions.swift b/Sources/SwiftProtobufPluginLibrary/Array+Extensions.swift deleted file mode 100644 index 048e2bed4..000000000 --- a/Sources/SwiftProtobufPluginLibrary/Array+Extensions.swift +++ /dev/null @@ -1,52 +0,0 @@ -// Sources/SwiftProtobufPluginLibrary/Array+Extensions.swift - Additions to Arrays -// -// Copyright (c) 2014 - 2017 Apple Inc. and the project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See LICENSE.txt for license information: -// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt -// -// ----------------------------------------------------------------------------- - -import Foundation - -extension Array { - - /// Like map, but calls the transform with the index and value. - /// - /// NOTE: It would seem like doing: - /// return self.enumerated().map { - /// return try transform($0.index, $0.element) - /// } - /// would seem like a simple thing to avoid extension. However as of Xcode 8.3.2 - /// (Swift 3.1), building/running 5000000 interation test (macOS) of the differences - /// are rather large - - /// Release build: - /// Using enumerated: 3.694987967 - /// Using enumeratedMap: 0.961241992 - /// Debug build: - /// Using enumerated: 20.038512905 - /// Using enumeratedMap: 8.521299144 - func enumeratedMap(_ transform: (Int, Element) throws -> T) rethrows -> [T] { - var i: Int = -1 - return try map { - i += 1 - return try transform(i, $0) - } - } -} - -#if !swift(>=4.2) -extension Array { - func firstIndex(where predicate: (Element) throws -> Bool) rethrows -> Int? { - var i = self.startIndex - while i < self.endIndex { - if try predicate(self[i]) { - return i - } - self.formIndex(after: &i) - } - return nil - } -} -#endif // !swift(>=4.2) diff --git a/Sources/SwiftProtobufPluginLibrary/CodeGenerator.swift b/Sources/SwiftProtobufPluginLibrary/CodeGenerator.swift new file mode 100644 index 000000000..bffc95bfc --- /dev/null +++ b/Sources/SwiftProtobufPluginLibrary/CodeGenerator.swift @@ -0,0 +1,354 @@ +// Sources/SwiftProtobufPluginLibrary/CodeGenerator.swift +// +// Copyright (c) 2014 - 2023 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// This provides the basic interface for writing a CodeGenerator. +/// +// ----------------------------------------------------------------------------- + +import Foundation +import SwiftProtobuf + +/// A protocol that generator should conform to then get easy support for +/// being a protocol buffer compiler pluign. +public protocol CodeGenerator { + init() + + /// Generates code for the given proto files. + /// + /// - Parameters: + /// - parameter: The parameter (or paramenters) passed for the generator. + /// This is for parameters specific to this generator, + /// `parse(parameter:)` (below) can be used to split back out + /// multiple parameters into the combined for the protocol buffer + /// compiler uses. + /// - protoCompilerContext: Context information about the protocol buffer + /// compiler being used. + /// - generatorOutputs: A object that can be used to send back the + /// generated outputs. + /// + /// - Throws: Can throw any `Error` to fail generate. `String(describing:)` + /// will be called on the error to provide the error string reported + /// to the user attempting to generate sources. + func generate( + files: [FileDescriptor], + parameter: any CodeGeneratorParameter, + protoCompilerContext: any ProtoCompilerContext, + generatorOutputs: any GeneratorOutputs + ) throws + + /// The list of features this CodeGenerator support to be reported back to + /// the protocol buffer compiler. + var supportedFeatures: [Google_Protobuf_Compiler_CodeGeneratorResponse.Feature] { get } + + /// The Protobuf Edition range that this generator can handle. Attempting + /// to generate for an Edition outside this range will cause protoc to + /// error. + var supportedEditionRange: ClosedRange { get } + + /// A list of extensions that define Custom Options + /// (https://protobuf.dev/programming-guides/proto2/#customoptions) for this generator so + /// they will be exposed on the `Descriptor` options. + var customOptionExtensions: [any AnyMessageExtension] { get } + + /// If provided, the argument parsing will support `--version` and report + /// this value. + var version: String? { get } + + /// If provided and `printHelp` isn't provide, this value will be including in + /// default output for the `--help` output. + var projectURL: String? { get } + + /// If provided and `printHelp` isn't provide, this value will be including in + /// default output for the `--help` output. + var copyrightLine: String? { get } + + /// Will be called for `-h` or `--help`, should `print()` out whatever is + /// desired; there is a default implementation that uses the above info + /// when provided. + func printHelp() +} + +extension CommandLine { + /// Get the command-line arguments passed to this process in a non mutable + /// form. Idea from https://github.com/swiftlang/swift/issues/66213 + /// + /// - Returns: An array of command-line arguments. + fileprivate static let safeArguments: [String] = + UnsafeBufferPointer(start: unsafeArgv, count: Int(argc)).compactMap { + String(validatingUTF8: $0!) + } +} + +extension CodeGenerator { + var programName: String { + guard let name = CommandLine.safeArguments.first?.split(separator: "/").last else { + return "" + } + return String(name) + } + + /// Runs as a protocol buffer compiler plugin based on the given arguments + /// or falls back to `CommandLine.arguments`. + public func main(_ args: [String]?) { + let args = args ?? Array(CommandLine.safeArguments.dropFirst()) + + for arg in args { + if arg == "--version", let version = version { + print("\(programName) \(version)") + return + } + if arg == "-h" || arg == "--help" { + printHelp() + return + } + // Could look at bringing back the support for recorded requests, but + // haven't needed it in a long time. + var stderr = StandardErrorOutputStream() + print("Unknown argument: \(arg)", to: &stderr) + return + } + + var extensionMap = SimpleExtensionMap() + if !customOptionExtensions.isEmpty { + for e in customOptionExtensions { + // Don't include Google_Protobuf_FeatureSet, that will be handing via custom features. + precondition( + e.messageType == Google_Protobuf_EnumOptions.self + || e.messageType == Google_Protobuf_EnumValueOptions.self + || e.messageType == Google_Protobuf_ExtensionRangeOptions.self + || e.messageType == Google_Protobuf_FieldOptions.self + || e.messageType == Google_Protobuf_FileOptions.self + || e.messageType == Google_Protobuf_MessageOptions.self + || e.messageType == Google_Protobuf_MethodOptions.self + || e.messageType == Google_Protobuf_OneofOptions.self + || e.messageType == Google_Protobuf_ServiceOptions.self, + "CodeGenerator `customOptionExtensions` must only extend the descriptor.proto 'Options' messages \(e.messageType)." + ) + } + extensionMap.insert(contentsOf: customOptionExtensions) + } + + let request: Google_Protobuf_Compiler_CodeGeneratorRequest + do { + request = try Google_Protobuf_Compiler_CodeGeneratorRequest( + serializedBytes: FileHandle.standardInput.readDataToEndOfFile(), + extensions: extensionMap + ) + } catch let e { + var stderr = StandardErrorOutputStream() + print("\(programName): Received an unparsable request from the compiler: \(e)", to: &stderr) + return + } + + let response = generateCode(request: request, generator: self) + let serializedResponse: Data + do { + serializedResponse = try response.serializedBytes() + } catch let e { + var stderr = StandardErrorOutputStream() + print("\(programName): Failure while serializing response: \(e)", to: &stderr) + return + } + FileHandle.standardOutput.write(serializedResponse) + } + + /// Runs as a protocol buffer compiler plugin; reading the generation request + /// off stdin and sending the response on stdout. + /// + /// Instead of calling this, just add `@main` to your `CodeGenerator`. + public static func main() { + let generator = Self() + generator.main(nil) + } +} + +// Provide default implementation for things so `CodeGenerator`s only have to +// provide them if they wish too. +extension CodeGenerator { + public var supportedEditionRange: ClosedRange { + // Default impl of unknown so generator don't have to provide this until + // they support editions. + Google_Protobuf_Edition.unknown...Google_Protobuf_Edition.unknown + } + public var customOptionExtensions: [any AnyMessageExtension] { [] } + public var version: String? { nil } + public var projectURL: String? { nil } + public var copyrightLine: String? { nil } + + public func printHelp() { + print("\(programName): A plugin for protoc and should not normally be run directly.") + if let copyright = copyrightLine { + print("\(copyright)") + } + if let projectURL = projectURL { + print( + """ + + For more information on the usage of this plugin, please see: + \(projectURL) + + """ + ) + } + } +} + +/// Uses the given `Google_Protobuf_Compiler_CodeGeneratorRequest` and +/// `CodeGenerator` to get code generated and create the +/// `Google_Protobuf_Compiler_CodeGeneratorResponse`. If there is a failure, +/// the failure will be used in the response to be returned to the protocol +/// buffer compiler to then be reported. +/// +/// - Parameters: +/// - request: The request proto as generated by the protocol buffer compiler. +/// - geneator: The `CodeGenerator` to use for generation. +/// +/// - Returns a filled out response with the success or failure of the +/// generation. +public func generateCode( + request: Google_Protobuf_Compiler_CodeGeneratorRequest, + generator: any CodeGenerator +) -> Google_Protobuf_Compiler_CodeGeneratorResponse { + + var response = Google_Protobuf_Compiler_CodeGeneratorResponse() + + // TODO: Could supportedFeatures be completely handled within library? + // - The only "hard" part around hiding the proto3 optional support is making + // sure the oneof index related bits aren't leaked from FieldDescriptors. + // Otherwise the oneof related apis could likely take over the "realOneof" + // jobs and just never vend the synthetic information. + // - The editions support bit likely could be computed based on the values + // `supportedEditionRange` having been overridden. + let supportedFeatures = generator.supportedFeatures + response.supportedFeatures = supportedFeatures.reduce(0) { $0 | UInt64($1.rawValue) } + + if supportedFeatures.contains(.supportsEditions) { + let supportedEditions = generator.supportedEditionRange + precondition( + supportedEditions.upperBound != .unknown, + "For a CodeGenerator to support Editions, it must override `supportedEditionRange`" + ) + precondition( + DescriptorSet.bundledEditionsSupport.contains(supportedEditions.lowerBound), + "A CodeGenerator can't claim to support an Edition before what the library supports: \(supportedEditions.lowerBound) vs \(DescriptorSet.bundledEditionsSupport)" + ) + precondition( + DescriptorSet.bundledEditionsSupport.contains(supportedEditions.upperBound), + "A CodeGenerator can't claim to support an Edition after what the library supports: \(supportedEditions.upperBound) vs \(DescriptorSet.bundledEditionsSupport)" + ) + response.minimumEdition = Int32(supportedEditions.lowerBound.rawValue) + response.maximumEdition = Int32(supportedEditions.upperBound.rawValue) + } + + // TODO: This will need update to language specific features. + + let descriptorSet = DescriptorSet(protos: request.protoFile) + + var files = [FileDescriptor]() + for name in request.fileToGenerate { + guard let fileDescriptor = descriptorSet.fileDescriptor(named: name) else { + response.error = + "protoc asked plugin to generate a file but did not provide a descriptor for the file: \(name)" + return response + } + files.append(fileDescriptor) + } + + let context = InternalProtoCompilerContext(request: request) + let outputs = InternalGeneratorOutputs() + let parameter = InternalCodeGeneratorParameter(request.parameter) + + do { + try generator.generate( + files: files, + parameter: parameter, + protoCompilerContext: context, + generatorOutputs: outputs + ) + response.file = outputs.files + } catch let e { + // Use the description from whatever the Generator threw as the error message. + response.error = String(describing: e) + } + + return response +} + +// MARK: Internal supporting types + +/// Internal implementation of `CodeGeneratorParameter` for +/// `generateCode(request:generator:)` +struct InternalCodeGeneratorParameter: CodeGeneratorParameter { + let parameter: String + + init(_ parameter: String) { + self.parameter = parameter + } + + var parsedPairs: [(key: String, value: String)] { + guard !parameter.isEmpty else { + return [] + } + let parts = parameter.components(separatedBy: ",") + return parts.map { s -> (key: String, value: String) in + guard let index = s.range(of: "=")?.lowerBound else { + // Key only, no value ("baz" in example). + return (trimWhitespace(s), "") + } + return ( + key: trimWhitespace(s[.. = [] + + func add(fileName: String, contents: String) throws { + guard !fileNames.contains(fileName) else { + throw OutputError.duplicateName(fileName) + } + fileNames.insert(fileName) + files.append( + Google_Protobuf_Compiler_CodeGeneratorResponse.File( + name: fileName, + content: contents + ) + ) + } +} diff --git a/Sources/SwiftProtobufPluginLibrary/CodeGeneratorParameter.swift b/Sources/SwiftProtobufPluginLibrary/CodeGeneratorParameter.swift new file mode 100644 index 000000000..e21565cf7 --- /dev/null +++ b/Sources/SwiftProtobufPluginLibrary/CodeGeneratorParameter.swift @@ -0,0 +1,40 @@ +// Sources/SwiftProtobufPluginLibrary/CodeGeneratorParameter.swift +// +// Copyright (c) 2014 - 2023 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// This provides the basic interface for a CodeGeneratorParameter. This is +/// passed to the `CodeGenerator` to get any command line options. +/// +// ----------------------------------------------------------------------------- + +import Foundation + +/// The the generator specific parameter that was passed to the protocol +/// compiler invocation. The protocol buffer compiler supports providing +/// parameters via the `--[LANG]_out` or `--[LANG]_opt` command line flags. +/// The compiler will relay those through as a _parameter_ string. +public protocol CodeGeneratorParameter { + /// The raw value from the compiler as a single string, if multiple values + /// were passed, they are joined into a single string. See `parsedPairs` as + /// that is likely a better option for consuming the parameters. + var parameter: String { get } + + /// The protocol buffer compiler will combine multiple `--[LANG]_opt` + /// directives into a "single" parameter by joining them with commas. This + /// vends the parameter split back back out into the individual arguments: + /// i.e., + /// "foo=bar,baz,mumble=blah" + /// becomes: + /// [ + /// (key: "foo", value: "bar"), + /// (key: "baz", value: ""), + /// (key: "mumble", value: "blah") + /// ] + var parsedPairs: [(key: String, value: String)] { get } +} diff --git a/Sources/SwiftProtobufPluginLibrary/CodePrinter.swift b/Sources/SwiftProtobufPluginLibrary/CodePrinter.swift index 7b965a466..348f860ec 100644 --- a/Sources/SwiftProtobufPluginLibrary/CodePrinter.swift +++ b/Sources/SwiftProtobufPluginLibrary/CodePrinter.swift @@ -17,63 +17,212 @@ /// `outdent`. public struct CodePrinter { - /// Reserve an initial buffer of 64KB scalars to eliminate some reallocations - /// in smaller files. - private static let initialBufferSize = 65536 - - /// The string content that was printed. - public var content: String { - return String(contentScalars) - } - - /// See if anything was printed. - public var isEmpty: Bool { return content.isEmpty } - - /// The Unicode scalar buffer used to build up the printed contents. - private var contentScalars = String.UnicodeScalarView() - - /// The `UnicodeScalarView` representing a single indentation step. - private let singleIndent: String.UnicodeScalarView - - /// The current indentation level (a collection of spaces). - private var indentation = String.UnicodeScalarView() - - /// Keeps track of whether the printer is currently sitting at the beginning - /// of a line. - private var atLineStart = true - - public init(indent: String.UnicodeScalarView = " ".unicodeScalars) { - contentScalars.reserveCapacity(CodePrinter.initialBufferSize) - singleIndent = indent - } - - /// Writes the given strings to the printer. - /// - /// - Parameter text: A variable-length list of strings to be printed. - public mutating func print(_ text: String...) { - for t in text { - for scalar in t.unicodeScalars { - // Indent at the start of a new line, unless it's a blank line. - if atLineStart && scalar != "\n" { - contentScalars.append(contentsOf: indentation) + /// Reserve an initial buffer of 64KB scalars to eliminate some reallocations + /// in smaller files. + private static let initialBufferSize = 65536 + + private static let kNewline: String.UnicodeScalarView.Element = "\n" + + /// The string content that was printed. + public var content: String { + String(contentScalars) + } + + /// See if anything was printed. + public var isEmpty: Bool { contentScalars.isEmpty } + + /// The Unicode scalar buffer used to build up the printed contents. + private var contentScalars = String.UnicodeScalarView() + + /// The `UnicodeScalarView` representing a single indentation step. + private let singleIndent: String.UnicodeScalarView + + /// The current indentation level (a collection of spaces). + private var indentation = String.UnicodeScalarView() + + /// Keeps track of whether the printer is currently sitting at the beginning + /// of a line. + private var atLineStart = true + + /// Keeps track of if a newline should be added after each string to the + /// print apis. + private let newlines: Bool + + public init(indent: String.UnicodeScalarView = " ".unicodeScalars) { + contentScalars.reserveCapacity(CodePrinter.initialBufferSize) + singleIndent = indent + newlines = false + } + + /// Initialize the printer for use. + /// + /// - Parameters: + /// - indent: A string (usually spaces) to use for the indentation amount. + /// - newlines: A boolean indicating if every `print` and `printIndented` + /// should automatically add newlines to the end of the strings. + public init( + indent: String.UnicodeScalarView = " ".unicodeScalars, + addNewlines newlines: Bool + ) { + contentScalars.reserveCapacity(CodePrinter.initialBufferSize) + singleIndent = indent + self.newlines = newlines + } + + /// Initialize a new printer using the existing state from another printer. + /// + /// This can be useful to use with generation subtasks, so see if they + /// actually generate something (via `isEmpty`) to then optionally add it + /// back into the parent with whatever surounding content. + /// + /// This is most useful to then use `append` to add the new content. + /// + /// - Parameter parent: The other printer to copy the configuration/state + /// from. + public init(_ parent: CodePrinter) { + self.init(parent, addNewlines: parent.newlines) + } + + /// Initialize a new printer using the existing state from another printer + /// but with support to control the behavior of `addNewlines`. + /// + /// This can be useful to use with generation subtasks, so see if they + /// actually generate something (via `isEmpty`) to then optionally add it + /// back into the parent with whatever surounding content. + /// + /// This is most useful to then use `append` to add the new content. + /// + /// - Parameters: + /// - parent: The other printer to copy the configuration/state + /// from. + /// - newlines: A boolean indicating if every `print` and `printIndented` + /// should automatically add newlines to the end of the strings. + public init(_ parent: CodePrinter, addNewlines newlines: Bool) { + self.init(indent: parent.singleIndent, addNewlines: newlines) + indentation = parent.indentation + } + + /// Writes the given strings to the printer, adding a newline after each + /// string. + /// + /// Newlines within the strings are honored and indentention is applied. + /// + /// The `addNewlines` value from initializing the printer controls if + /// newlines are appended after each string. + /// + /// If called with no strings, a blank line is added to the printer + /// (even is `addNewlines` was false at initialization of the printer. + /// + /// - Parameter text: A variable-length list of strings to be printed. + public mutating func print(_ text: String...) { + if text.isEmpty { + contentScalars.append(CodePrinter.kNewline) + atLineStart = true + } else { + for t in text { + printInternal(t.unicodeScalars, addNewline: newlines) + } } - contentScalars.append(scalar) - atLineStart = (scalar == "\n") - } } - } - - /// Increases the printer's indentation level. - public mutating func indent() { - indentation.append(contentsOf: singleIndent) - } - - /// Decreases the printer's indentation level. - /// - /// - Precondition: The printer must not have an indentation level. - public mutating func outdent() { - let indentCount = singleIndent.count - precondition(indentation.count >= indentCount, "Cannot outdent past the left margin") - indentation.removeLast(indentCount) - } + + /// Writes the given strings to the printer, optionally adding a newline + /// after each string. If called with no strings, a blank line is added to + /// the printer. + /// + /// Newlines within the strings are honored and indentention is applied. + /// + /// - Parameters + /// - text: A variable-length list of strings to be printed. + /// - newlines: Boolean to control adding newlines after each string. This + /// is an explicit override of the `addNewlines` value using to + /// initialize this `CodePrinter`. + public mutating func print(_ text: String..., newlines: Bool) { + if text.isEmpty { + assert( + newlines, + "Disabling newlines with no strings doesn't make sense." + ) + contentScalars.append(CodePrinter.kNewline) + atLineStart = true + } else { + for t in text { + printInternal(t.unicodeScalars, addNewline: newlines) + } + } + } + + /// Indents, writes the given strings to the printer, and then outdents. + /// + /// Newlines within the strings are honored and indentention is applied. + /// + /// The `addNewlines` value from initializing the printer controls if + /// newlines are appended after each string. + /// + /// - Parameter text: A variable-length list of strings to be printed. + public mutating func printIndented(_ text: String...) { + indent() + for t in text { + printInternal(t.unicodeScalars, addNewline: newlines) + } + outdent() + } + + private mutating func printInternal( + _ scalars: String.UnicodeScalarView, + addNewline: Bool + ) { + for scalar in scalars { + // Indent at the start of a new line, unless it's a blank line. + if atLineStart && scalar != CodePrinter.kNewline { + contentScalars.append(contentsOf: indentation) + } + contentScalars.append(scalar) + atLineStart = (scalar == CodePrinter.kNewline) + } + if addNewline { + contentScalars.append(CodePrinter.kNewline) + atLineStart = true + } + } + + /// Appended the content of another `CodePrinter`to this one. + /// + /// - Parameters: + /// - printer: The other `CodePrinter` to copy from. + /// - indenting: Boolean, if the text being appended should be reindented + /// to the current state of this printer. If the `printer` was + /// initialized off of this printer, there isn't a need to reindent. + public mutating func append(_ printer: CodePrinter, indenting: Bool = false) { + if indenting { + printInternal(printer.contentScalars, addNewline: false) + } else { + contentScalars.append(contentsOf: printer.contentScalars) + atLineStart = printer.atLineStart + } + } + + /// Increases the printer's indentation level. + public mutating func indent() { + indentation.append(contentsOf: singleIndent) + } + + /// Decreases the printer's indentation level. + /// + /// - Precondition: The printer must not have an indentation level. + public mutating func outdent() { + let indentCount = singleIndent.count + precondition(indentation.count >= indentCount, "Cannot outdent past the left margin") + indentation.removeLast(indentCount) + } + + /// Indents, calls `body` to do other work relaying along the printer, and + /// the outdents after wards. + /// + /// - Parameter body: A closure that is invoked after the indent is + /// increasted. + public mutating func withIndentation(body: (_ p: inout CodePrinter) -> Void) { + indent() + body(&self) + outdent() + } } diff --git a/Sources/SwiftProtobufPluginLibrary/Descriptor+Extensions.swift b/Sources/SwiftProtobufPluginLibrary/Descriptor+Extensions.swift index e5e096f34..f92d8d141 100644 --- a/Sources/SwiftProtobufPluginLibrary/Descriptor+Extensions.swift +++ b/Sources/SwiftProtobufPluginLibrary/Descriptor+Extensions.swift @@ -12,106 +12,175 @@ import Foundation import SwiftProtobuf extension FileDescriptor: ProvidesSourceCodeLocation { - public var sourceCodeInfoLocation: Google_Protobuf_SourceCodeInfo.Location? { - // google/protobuf's descriptor.cc says it should be an empty path. - return sourceCodeInfoLocation(path: IndexPath()) - } + public var sourceCodeInfoLocation: Google_Protobuf_SourceCodeInfo.Location? { + // google/protobuf's descriptor.cc says it should be an empty path. + sourceCodeInfoLocation(path: IndexPath()) + } } -extension Descriptor: ProvidesLocationPath, ProvidesSourceCodeLocation { - public func getLocationPath(path: inout IndexPath) { - if let containingType = containingType { - containingType.getLocationPath(path: &path) - path.append(Google_Protobuf_DescriptorProto.FieldNumbers.nestedType) - } else { - path.append(Google_Protobuf_FileDescriptorProto.FieldNumbers.messageType) +extension Descriptor: ProvidesLocationPath, ProvidesSourceCodeLocation, TypeOrFileProvidesDeprecationComment { + public func getLocationPath(path: inout IndexPath) { + if let containingType = containingType { + containingType.getLocationPath(path: &path) + path.append(Google_Protobuf_DescriptorProto.FieldNumbers.nestedType) + } else { + path.append(Google_Protobuf_FileDescriptorProto.FieldNumbers.messageType) + } + path.append(index) } - path.append(index) - } + + public var typeName: String { "message" } + public var isDeprecated: Bool { options.deprecated } } -extension EnumDescriptor: ProvidesLocationPath, ProvidesSourceCodeLocation { - public func getLocationPath(path: inout IndexPath) { - if let containingType = containingType { - containingType.getLocationPath(path: &path) - path.append(Google_Protobuf_DescriptorProto.FieldNumbers.enumType) - } else { - path.append(Google_Protobuf_FileDescriptorProto.FieldNumbers.enumType) +extension Descriptor.ExtensionRange: ProvidesLocationPath, ProvidesSourceCodeLocation { + public func getLocationPath(path: inout IndexPath) { + containingType.getLocationPath(path: &path) + path.append(Google_Protobuf_DescriptorProto.FieldNumbers.extensionRange) + path.append(index) } - path.append(index) - } } -extension EnumValueDescriptor: ProvidesLocationPath, ProvidesSourceCodeLocation { - public func getLocationPath(path: inout IndexPath) { - enumType.getLocationPath(path: &path) - path.append(Google_Protobuf_EnumDescriptorProto.FieldNumbers.value) - path.append(index) - } +extension EnumDescriptor: ProvidesLocationPath, ProvidesSourceCodeLocation, TypeOrFileProvidesDeprecationComment { + public func getLocationPath(path: inout IndexPath) { + if let containingType = containingType { + containingType.getLocationPath(path: &path) + path.append(Google_Protobuf_DescriptorProto.FieldNumbers.enumType) + } else { + path.append(Google_Protobuf_FileDescriptorProto.FieldNumbers.enumType) + } + path.append(index) + } + + public var typeName: String { "enum" } + public var isDeprecated: Bool { options.deprecated } +} + +extension EnumValueDescriptor: ProvidesLocationPath, ProvidesSourceCodeLocation, SimpleProvidesDeprecationComment { + public func getLocationPath(path: inout IndexPath) { + enumType.getLocationPath(path: &path) + path.append(Google_Protobuf_EnumDescriptorProto.FieldNumbers.value) + path.append(index) + } + + public var typeName: String { "enum value" } + public var isDeprecated: Bool { options.deprecated } } extension OneofDescriptor: ProvidesLocationPath, ProvidesSourceCodeLocation { - public func getLocationPath(path: inout IndexPath) { - containingType.getLocationPath(path: &path) - path.append(Google_Protobuf_DescriptorProto.FieldNumbers.oneofDecl) - path.append(index) - } + public func getLocationPath(path: inout IndexPath) { + containingType.getLocationPath(path: &path) + path.append(Google_Protobuf_DescriptorProto.FieldNumbers.oneofDecl) + path.append(index) + } } -extension FieldDescriptor: ProvidesLocationPath, ProvidesSourceCodeLocation { - public func getLocationPath(path: inout IndexPath) { - if isExtension { - if let extensionScope = extensionScope { - extensionScope.getLocationPath(path: &path) - path.append(Google_Protobuf_DescriptorProto.FieldNumbers.extension) - } else { - path.append(Google_Protobuf_FileDescriptorProto.FieldNumbers.extension) - } - } else { - containingType.getLocationPath(path: &path) - path.append(Google_Protobuf_DescriptorProto.FieldNumbers.field) +extension FieldDescriptor: ProvidesLocationPath, ProvidesSourceCodeLocation, ProvidesDeprecationComment { + public func getLocationPath(path: inout IndexPath) { + if isExtension { + if let extensionScope = extensionScope { + extensionScope.getLocationPath(path: &path) + path.append(Google_Protobuf_DescriptorProto.FieldNumbers.extension) + } else { + path.append(Google_Protobuf_FileDescriptorProto.FieldNumbers.extension) + } + } else { + containingType.getLocationPath(path: &path) + path.append(Google_Protobuf_DescriptorProto.FieldNumbers.field) + } + path.append(index) + } + + public func deprecationComment(commentPrefix: String) -> String { + // FieldDesciptor can be an extension field or a normal field, so it needs + // a custom imply to only look at the file for extentsion fields. + if options.deprecated { + return + "\(commentPrefix) NOTE: This \(isExtension ? "extension field" : "field") was marked as deprecated in the .proto file.\n" + } + if isExtension && file.options.deprecated { + return + "\(commentPrefix) NOTE: The whole .proto file that defined this extension field was marked as deprecated.\n" + } + return String() } - path.append(index) - } - - /// Returns true if the type can be used for a Packed field. - static func isPackable(type: Google_Protobuf_FieldDescriptorProto.TypeEnum) -> Bool { - // This logic comes from the C++ FieldDescriptor::IsTypePackable() impl. - switch type { - case .string, .group, .message, .bytes: - return false - default: - return true + + /// Returns true if the type can be used for a Packed field. + static func isPackable(type: Google_Protobuf_FieldDescriptorProto.TypeEnum) -> Bool { + // This logic comes from the C++ FieldDescriptor::IsTypePackable() impl. + switch type { + case .string, .group, .message, .bytes: + return false + default: + return true + } + } + + /// Helper to return the name to as the "base" for naming of generated fields. + /// + /// Groups use the underlying message's name. The way groups are declared in + /// proto files, the filed names is derived by lowercasing the Group's name, + /// so there are no underscores, etc. to rebuild a camel case name from. + var namingBase: String { isGroupLike ? messageType!.name : name } + + /// TODO: Remove this when it is safe to make breaking changes. + @available(*, deprecated, message: "Please open a GitHub issue if you think functionality is missing.") + public var internal_isGroupLike: Bool { isGroupLike } + + /// Helper to see if this is "group-like". Edition 2024 will likely provide + /// a new feature to better deal with this. See upsteam protobuf for more + /// details on the problem. + /// + /// This models upstream internal::cpp::IsGroupLike(). + package var isGroupLike: Bool { + guard type == .group else { + return false + } + // `messageType` can't realy be nil once we know it's a group. + let messageType = messageType! + + // The original proto2 syntax concept of a group always has a field name + // that is the exact lowercasing of the message name. + guard name == messageType.name.lowercased() else { + return false + } + + // The message defined by a group is at the same scope as the field. So... + if isExtension { + if extensionScope == nil { + // Top level extension, so the message made by the group has to be the + // same file and also a type level type. + return messageType.file === file && messageType.containingType == nil + } else { + // Extension field was scoped to a message, so the group will be also + // nested under that same message. + return messageType.containingType === extensionScope + } + } else { + // A regular message field, the message made by the group has to be + // nested under this same message. + return messageType.containingType === containingType + } } - } - - /// Is this field packable. - var isPackable: Bool { - // This logic comes from the C++ FieldDescriptor::is_packable() impl. - return label == .repeated && FieldDescriptor.isPackable(type: type) - } - - /// Helper to return the name to as the "base" for naming of generated fields. - /// - /// Groups use the underlying message's name. The way groups are declared in - /// proto files, the filed names is derived by lowercasing the Group's name, - /// so there are no underscores, etc. to rebuild a camel case name from. - var namingBase: String { - return type == .group ? messageType.name : name - } } -extension ServiceDescriptor: ProvidesLocationPath, ProvidesSourceCodeLocation { - public func getLocationPath(path: inout IndexPath) { - path.append(Google_Protobuf_FileDescriptorProto.FieldNumbers.service) - path.append(index) - } +extension ServiceDescriptor: ProvidesLocationPath, ProvidesSourceCodeLocation, TypeOrFileProvidesDeprecationComment { + public func getLocationPath(path: inout IndexPath) { + path.append(Google_Protobuf_FileDescriptorProto.FieldNumbers.service) + path.append(index) + } + + public var typeName: String { "service" } + public var isDeprecated: Bool { options.deprecated } } -extension MethodDescriptor: ProvidesLocationPath, ProvidesSourceCodeLocation { - public func getLocationPath(path: inout IndexPath) { - service.getLocationPath(path: &path) - path.append(Google_Protobuf_ServiceDescriptorProto.FieldNumbers.method) - path.append(index) - } +extension MethodDescriptor: ProvidesLocationPath, ProvidesSourceCodeLocation, SimpleProvidesDeprecationComment { + public func getLocationPath(path: inout IndexPath) { + service.getLocationPath(path: &path) + path.append(Google_Protobuf_ServiceDescriptorProto.FieldNumbers.method) + path.append(index) + } + + public var typeName: String { "method" } + public var isDeprecated: Bool { options.deprecated } } diff --git a/Sources/SwiftProtobufPluginLibrary/Descriptor.swift b/Sources/SwiftProtobufPluginLibrary/Descriptor.swift index 9f284c449..2f97e61dd 100644 --- a/Sources/SwiftProtobufPluginLibrary/Descriptor.swift +++ b/Sources/SwiftProtobufPluginLibrary/Descriptor.swift @@ -15,655 +15,1582 @@ /// `service` messages). It is *not* the intent for these to eventually be used /// as part of some reflection or generate message api. /// +/// Unlike the C++ Descriptors, the intent is for these to *only* be used within +/// the context of a protoc plugin, meaning, the +/// `Google_Protobuf_FileDescriptorSet` used to create these will be *always* +/// be well formed by protoc and the guarentees it provides. +/// // ----------------------------------------------------------------------------- -// NOTES: -// 1. `lazy` and `weak` (or `unowned`) doesn't seem to work, so the impl here -// can't simply keep the `Resolver` and look things up when first accessed -// instead `bind()` is used to force those lookups to happen. -// 2. Despite the Swift docs seeming to say `unowned` should work, there are -// compile errors, `weak` ends up being used even though this code doesn't -// need the zeroing behaviors. If it did, things will be a little faster -// as the tracking for weak references wouldn't be needed. - import Foundation import SwiftProtobuf +/// The front interface for building/getting descriptors. The objects +/// vended from the here are different from the raw +/// `Google_Protobuf_*Proto` types in that they have all the cross object +/// references resolved or wired up, making for an easier to use object +/// model. +/// +/// This is like the `DescriptorPool` class in the C++ protobuf library. public final class DescriptorSet { - public let files: [FileDescriptor] - private let registry = Registry() - - public convenience init(proto: Google_Protobuf_FileDescriptorSet) { - self.init(protos: proto.file) - } - - public init(protos: [Google_Protobuf_FileDescriptorProto]) { - let registry = self.registry - self.files = protos.map { return FileDescriptor(proto: $0, registry: registry) } - } - - public func lookupFileDescriptor(protoName name: String) -> FileDescriptor { - return registry.fileDescriptor(name: name) - } - public func lookupDescriptor(protoName name: String) -> Descriptor { - return registry.descriptor(name: name) - } - public func lookupEnumDescriptor(protoName name: String) -> EnumDescriptor { - return registry.enumDescriptor(name: name) - } - public func lookupServiceDescriptor(protoName name: String) -> ServiceDescriptor { - return registry.serviceDescriptor(name: name) - } + /// The list of `FileDescriptor`s in this set. + public let files: [FileDescriptor] + private let registry = Registry() + + // Construct out of a `Google_Protobuf_FileDescriptorSet` likely + // created by protoc. + public convenience init(proto: Google_Protobuf_FileDescriptorSet) { + self.init(protos: proto.file) + } + + /// The bundled in `google.protobuf.FeatureSetDefault` that defines what + /// the plugin library can support. + private static let bundledFeatureSetDefaults = + // Decoding the bundle defaults better never fail + try! Google_Protobuf_FeatureSetDefaults(serializedBytes: bundledFeatureSetDefaultBytes) + + /// The range of Editions that the library can support. + /// + /// This will limit what edition versions a plugin can claim to support. + public static var bundledEditionsSupport: ClosedRange { + bundledFeatureSetDefaults.minimumEdition...bundledFeatureSetDefaults.maximumEdition + } + + /// Construct out of a ordered list of + /// `Google_Protobuf_FileDescriptorProto`s likely created by protoc. + public convenience init(protos: [Google_Protobuf_FileDescriptorProto]) { + self.init( + protos: protos, + featureSetDefaults: DescriptorSet.bundledFeatureSetDefaults + ) + } + + /// Construct out of a ordered list of + /// `Google_Protobuf_FileDescriptorProto`s likely created by protoc. Since + /// .proto files can import other .proto files, the imports have to be + /// listed before the things that use them so the graph can be + /// reconstructed. + /// + /// - Parameters: + /// - protos: An ordered list of `Google_Protobuf_FileDescriptorProto`. + /// They must be order such that a file is provided before another file + /// that depends on it. + /// - featureSetDefaults: A `Google_Protobuf_FeatureSetDefaults` that provides + /// the Feature defaults to use when parsing the give File protos. + /// - featureExtensions: A list of Protobuf Extension extensions to + /// `google.protobuf.FeatureSet` that define custom features. If used, the + /// `defaults` should have been parsed with the extensions being + /// supported. + public init( + protos: [Google_Protobuf_FileDescriptorProto], + featureSetDefaults: Google_Protobuf_FeatureSetDefaults, + featureExtensions: [any AnyMessageExtension] = [] + ) { + precondition( + Self.bundledEditionsSupport.contains(featureSetDefaults.minimumEdition), + "Attempt to use a FeatureSetDefault minimumEdition that isn't supported by the library." + ) + precondition( + Self.bundledEditionsSupport.contains(featureSetDefaults.maximumEdition), + "Attempt to use a FeatureSetDefault maximumEdition that isn't supported by the library." + ) + // If a protoc is too old ≤v26, it might have `features` instead of `overridable_features` and + // `fixed_features`, try to catch that. + precondition( + nil == featureSetDefaults.defaults.first(where: { !$0.hasOverridableFeatures && !$0.hasFixedFeatures }), + "These FeatureSetDefault don't appear valid, make sure you are using a new enough protoc to generate them. " + ) + let registry = self.registry + self.files = protos.map { + FileDescriptor( + proto: $0, + featureSetDefaults: featureSetDefaults, + featureExtensions: featureExtensions, + registry: registry + ) + } + } + + /// Lookup a specific file. The names for files are what was captured in + /// the `Google_Protobuf_FileDescriptorProto` when it was created, protoc + /// uses the path name for how the file was found. + /// + /// This is a legacy api since it requires the file to be found or it aborts. + /// Mainly kept for grpc-swift compatibility. + @available(*, deprecated, renamed: "fileDescriptor(named:)") + public func lookupFileDescriptor(protoName name: String) -> FileDescriptor { + registry.fileDescriptor(named: name)! + } + + /// Find a specific file. The names for files are what was captured in + /// the `Google_Protobuf_FileDescriptorProto` when it was created, protoc + /// uses the path name for how the file was found. + public func fileDescriptor(named name: String) -> FileDescriptor? { + registry.fileDescriptor(named: name) + } + + /// Find the `Descriptor` for a named proto message. + /// + /// This is a legacy api since it requires the proto to be found or it aborts. + /// Mainly kept for grpc-swift compatibility. + @available(*, deprecated, renamed: "descriptor(named:)") + public func lookupDescriptor(protoName: String) -> Descriptor { + self.descriptor(named: protoName)! + } + + /// Find the `Descriptor` for a named proto message. + public func descriptor(named fullName: String) -> Descriptor? { + registry.descriptor(named: ".\(fullName)") + } + + /// Find the `EnumDescriptor` for a named proto enum. + /// + /// This is a legacy api since it requires the enum to be found or it aborts. + /// Mainly kept for grpc-swift compatibility. + @available(*, deprecated, renamed: "enumDescriptor(named:)") + public func lookupEnumDescriptor(protoName: String) -> EnumDescriptor { + enumDescriptor(named: protoName)! + } + + /// Find the `EnumDescriptor` for a named proto enum. + public func enumDescriptor(named fullName: String) -> EnumDescriptor? { + registry.enumDescriptor(named: ".\(fullName)") + } + + /// Find the `ServiceDescriptor` for a named proto service. + /// + /// This is a legacy api since it requires the enum to be found or it aborts. + /// Mainly kept for grpc-swift compatibility. + @available(*, deprecated, renamed: "serviceDescriptor(named:)") + public func lookupServiceDescriptor(protoName: String) -> ServiceDescriptor { + serviceDescriptor(named: protoName)! + } + + /// Find the `ServiceDescriptor` for a named proto service. + public func serviceDescriptor(named fullName: String) -> ServiceDescriptor? { + registry.serviceDescriptor(named: ".\(fullName)") + } +} + +/// Options for collected a proto object from a Descriptor. +public struct ExtractProtoOptions { + + /// If the `SourceCodeInfo` should also be included in the proto file. + /// + /// If embedding the descriptor in a binary for some reason, normally the `SourceCodeInfo` + /// isn't needed and would just be an increas in binary size. + public var includeSourceCodeInfo: Bool = false + + /// Copy on the _header_ for the descriptor. This mainly means leave out any of the nested + /// descriptors (messages, enums, etc.). + public var headerOnly: Bool = false + + // NOTE: in the future maybe add toggles to model the behavior of the *Descriptor::Copy*To() + // apis. + + public init() {} } +/// Models a .proto file. `FileDescriptor`s are not directly created, +/// instead they are constructed/fetched via the `DescriptorSet` or +/// they are directly accessed via a `file` property on all the other +/// types of descriptors. public final class FileDescriptor { - public enum Syntax: String { - case proto2 - case proto3 - - public init?(rawValue: String) { - switch rawValue { - case "proto2", "": - self = .proto2 - case "proto3": - self = .proto3 - default: - return nil - } - } - } - - public let proto: Google_Protobuf_FileDescriptorProto - public var name: String { return proto.name } - public var package: String { return proto.package } - - public let syntax: Syntax - - public let dependencies: [FileDescriptor] - public var publicDependencies: [FileDescriptor] { return proto.publicDependency.map { dependencies[Int($0)] } } - public var weakDependencies: [FileDescriptor] { return proto.weakDependency.map { dependencies[Int($0)] } } - - public let enums: [EnumDescriptor] - public let messages: [Descriptor] - public let extensions: [FieldDescriptor] - public let services: [ServiceDescriptor] - - public var fileOptions: Google_Protobuf_FileOptions { return proto.options } - public var isDeprecated: Bool { return proto.options.deprecated } - - fileprivate init(proto: Google_Protobuf_FileDescriptorProto, registry: Registry) { - self.proto = proto - self.syntax = Syntax(rawValue: proto.syntax)! - - let prefix: String - let protoPackage = proto.package - if protoPackage.isEmpty { - prefix = "" - } else { - prefix = "." + protoPackage - } - - self.enums = proto.enumType.enumeratedMap { - return EnumDescriptor(proto: $1, index: $0, registry: registry, fullNamePrefix: prefix) - } - self.messages = proto.messageType.enumeratedMap { - return Descriptor(proto: $1, index: $0, registry: registry, fullNamePrefix: prefix) - } - self.extensions = proto.extension.enumeratedMap { - return FieldDescriptor(proto: $1, index: $0, registry: registry, isExtension: true) - } - self.services = proto.service.enumeratedMap { - return ServiceDescriptor(proto: $1, index: $0, registry: registry, fullNamePrefix: prefix) - } - - // The compiler ensures there aren't cycles between a file and dependencies, so - // this doesn't run the risk of creating any retain cycles that would force these - // to have to be weak. - self.dependencies = proto.dependency.map { return registry.fileDescriptor(name: $0) } - - // Done initializing, register ourselves. - registry.register(file: self) - - // descriptor.proto documents the files will be in deps order. That means we - // any external reference will have been in the previous files in the set. - self.enums.forEach { $0.bind(file: self, registry: registry, containingType: nil) } - self.messages.forEach { $0.bind(file: self, registry: registry, containingType: nil) } - self.extensions.forEach { $0.bind(file: self, registry: registry, containingType: nil) } - self.services.forEach { $0.bind(file: self, registry: registry) } - } - - public func sourceCodeInfoLocation(path: IndexPath) -> Google_Protobuf_SourceCodeInfo.Location? { - guard let location = locationMap[path] else { - return nil - } - return location - } - - // Lazy so this can be computed on demand, as the imported files won't need - // comments during generation. - private lazy var locationMap: [IndexPath:Google_Protobuf_SourceCodeInfo.Location] = { - var result: [IndexPath:Google_Protobuf_SourceCodeInfo.Location] = [:] - for loc in self.proto.sourceCodeInfo.location { - let intList = loc.path.map { return Int($0) } - result[IndexPath(indexes: intList)] = loc - } - return result - }() + @available(*, deprecated, message: "This enum has been deprecated. Use `Google_Protobuf_Edition` instead.") + public enum Syntax: String { + case proto2 + case proto3 + + public init?(rawValue: String) { + switch rawValue { + case "proto2", "": + self = .proto2 + case "proto3": + self = .proto3 + default: + return nil + } + } + } + + /// The filename used with protoc. + public let name: String + /// The proto package. + public let package: String + + @available(*, deprecated, message: "This property has been deprecated. Use `edition` instead.") + public var syntax: Syntax { + Syntax(rawValue: self._proto.syntax)! + } + + /// The edition of the file. + public let edition: Google_Protobuf_Edition + + /// The resolved features for this File. + public let features: Google_Protobuf_FeatureSet + + /// The imports for this file. + public let dependencies: [FileDescriptor] + /// The subset of the imports that were declared `public`. + public let publicDependencies: [FileDescriptor] + /// The subset of the imports that were declared `weak`. + public let weakDependencies: [FileDescriptor] + + /// The enum defintions at the file scope level. + public let enums: [EnumDescriptor] + /// The message defintions at the file scope level. + public let messages: [Descriptor] + /// The extension field defintions at the file scope level. + public let extensions: [FieldDescriptor] + /// The service defintions at the file scope level. + public let services: [ServiceDescriptor] + + /// The `Google_Protobuf_FileOptions` set on this file. + @available(*, deprecated, renamed: "options") + public var fileOptions: Google_Protobuf_FileOptions { self.options } + + /// The `Google_Protobuf_FileOptions` set on this file. + public let options: Google_Protobuf_FileOptions + + private let sourceCodeInfo: Google_Protobuf_SourceCodeInfo + + /// Extract contents of this descriptor in Proto form. + /// + /// - Parameters: + /// - options: Controls what information is include/excluded when creating the Proto version. + /// + /// - Returns: A `Google_Protobuf_FileDescriptorProto`. + public func extractProto( + options: ExtractProtoOptions = ExtractProtoOptions() + ) -> Google_Protobuf_FileDescriptorProto { + // In the future it might make sense to model this like the C++, where the protos is built up + // on demand instead of keeping the object around. + var result = _proto + + if !options.includeSourceCodeInfo { + result.clearSourceCodeInfo() + } + + if options.headerOnly { + // For FileDescriptor, make `headerOnly` mean the same things as C++ + // `FileDescriptor::CopyHeaderTo()`. + result.dependency = [] + result.publicDependency = [] + result.weakDependency = [] + result.messageType = [] + result.enumType = [] + result.messageType = [] + result.service = [] + result.extension = [] + } + + return result + } + + /// The proto version of the descriptor that defines this File. + @available(*, deprecated, renamed: "extractProto()") + public var proto: Google_Protobuf_FileDescriptorProto { _proto } + private let _proto: Google_Protobuf_FileDescriptorProto + + @available(*, deprecated, message: "Use `fileOptions/deprecated` instead.") + public var isDeprecated: Bool { proto.options.deprecated } + + fileprivate init( + proto: Google_Protobuf_FileDescriptorProto, + featureSetDefaults: Google_Protobuf_FeatureSetDefaults, + featureExtensions: [any AnyMessageExtension], + registry: Registry + ) { + self.name = proto.name + self.package = proto.package + + // This logic comes from upstream `DescriptorBuilder::BuildFileImpl()`. + if proto.hasEdition { + self.edition = proto.edition + } else { + switch proto.syntax { + case "", "proto2": + self.edition = .proto2 + case "proto3": + self.edition = .proto3 + default: + self.edition = .unknown + fatalError( + "protoc provided an expected value (\"\(proto.syntax)\") for syntax/edition: \(proto.name)" + ) + } + } + // TODO: Revsit capturing the error here and see about exposing it out + // to be reported via plugins. + let featureResolver: FeatureResolver + do { + featureResolver = try FeatureResolver( + edition: self.edition, + featureSetDefaults: featureSetDefaults, + featureExtensions: featureExtensions + ) + } catch let e { + fatalError("Failed to make a FeatureResolver for \(self.name): \(e)") + } + let resolvedFeatures = featureResolver.resolve(proto.options) + self.features = resolvedFeatures + self.options = proto.options + + let protoPackage = proto.package + self.enums = proto.enumType.enumerated().map { + EnumDescriptor( + proto: $0.element, + index: $0.offset, + parentFeatures: resolvedFeatures, + featureResolver: featureResolver, + registry: registry, + scope: protoPackage + ) + } + self.messages = proto.messageType.enumerated().map { + Descriptor( + proto: $0.element, + index: $0.offset, + parentFeatures: resolvedFeatures, + featureResolver: featureResolver, + registry: registry, + scope: protoPackage + ) + } + self.extensions = proto.extension.enumerated().map { + FieldDescriptor( + extension: $0.element, + index: $0.offset, + parentFeatures: resolvedFeatures, + featureResolver: featureResolver, + registry: registry + ) + } + self.services = proto.service.enumerated().map { + ServiceDescriptor( + proto: $0.element, + index: $0.offset, + fileFeatures: resolvedFeatures, + featureResolver: featureResolver, + registry: registry, + scope: protoPackage + ) + } + + // The compiler ensures there aren't cycles between a file and dependencies, so + // this doesn't run the risk of creating any retain cycles that would force these + // to have to be weak. + let dependencies = proto.dependency.map { registry.fileDescriptor(named: $0)! } + self.dependencies = dependencies + self.publicDependencies = proto.publicDependency.map { dependencies[Int($0)] } + self.weakDependencies = proto.weakDependency.map { dependencies[Int($0)] } + + self.sourceCodeInfo = proto.sourceCodeInfo + + self._proto = proto + + // Done initializing, register ourselves. + registry.register(file: self) + + // descriptor.proto documents the files will be in deps order. That means we + // any external reference will have been in the previous files in the set. + for e in enums { e.bind(file: self, registry: registry, containingType: nil) } + for m in messages { m.bind(file: self, registry: registry, containingType: nil) } + for e in extensions { e.bind(file: self, registry: registry, containingType: nil) } + for s in services { s.bind(file: self, registry: registry) } + } + + /// Fetch the source information for a give path. For more details on the paths + /// and what this information is, see `Google_Protobuf_SourceCodeInfo`. + /// + /// For simpler access to the comments for give message, fields, enums; see + /// `Descriptor+Extensions.swift` and the `ProvidesLocationPath` and + /// `ProvidesSourceCodeLocation` protocols. + public func sourceCodeInfoLocation(path: IndexPath) -> Google_Protobuf_SourceCodeInfo.Location? { + guard let location = locationMap[path] else { + return nil + } + return location + } + + // Lazy so this can be computed on demand, as the imported files won't need + // comments during generation. + private lazy var locationMap: [IndexPath: Google_Protobuf_SourceCodeInfo.Location] = { + var result: [IndexPath: Google_Protobuf_SourceCodeInfo.Location] = [:] + for loc in sourceCodeInfo.location { + let intList = loc.path.map { Int($0) } + result[IndexPath(indexes: intList)] = loc + } + return result + }() } +/// Describes a type of protocol message, or a particular group within a +/// message. `Descriptor`s are not directly created, instead they are +/// constructed/fetched via the `DescriptorSet` or they are directly accessed +/// via a `messageType` property on `FieldDescriptor`s, etc. public final class Descriptor { - public let proto: Google_Protobuf_DescriptorProto - let index: Int - public let fullName: String - public var name: String { return proto.name } - public private(set) weak var file: FileDescriptor! - public private(set) weak var containingType: Descriptor? - - public let enums: [EnumDescriptor] - public let messages: [Descriptor] - public let fields: [FieldDescriptor] - public let oneofs: [OneofDescriptor] - /// Non synthetic oneofs. - /// - /// These always come first (enforced by the C++ Descriptor code). So this is always a - /// leading subset of `oneofs` (or the same if there are no synthetic entries). - public private(set) lazy var realOneofs: [OneofDescriptor] = { - // Lazy because `isSynthetic` can't be called until after `bind()`. - return self.oneofs.filter { !$0.isSynthetic } - }() - public let extensions: [FieldDescriptor] - - public var extensionRanges: [Google_Protobuf_DescriptorProto.ExtensionRange] { - return proto.extensionRange - } - /// The `extensionRanges` are in the order they appear in the original .proto - /// file; this orders them and then merges any ranges that are actually - /// contiguious (i.e. - [(21,30),(10,20)] -> [(10,30)]) - public private(set) lazy var normalizedExtensionRanges: [Google_Protobuf_DescriptorProto.ExtensionRange] = { - var ordered = self.extensionRanges.sorted(by: { return $0.start < $1.start }) - if ordered.count > 1 { - for i in (0..<(ordered.count - 1)).reversed() { - if ordered[i].end == ordered[i+1].start { - ordered[i].end = ordered[i+1].end - ordered.remove(at: i + 1) - } - } - } - return ordered - }() - - /// The `extensionRanges` from `normalizedExtensionRanges`, but takes a step - /// further in that any ranges that do _not_ have any fields inbetween them - /// are also merged together. These can then be used in context where it is - /// ok to include field numbers that have to be extension or unknown fields. - public private(set) lazy var ambitiousExtensionRanges: [Google_Protobuf_DescriptorProto.ExtensionRange] = { - var merged = self.normalizedExtensionRanges - var sortedFields = self.fields.sorted {$0.number < $1.number} - if merged.count > 1 { - var fieldNumbersReversedIterator = - self.fields.map({ Int($0.number) }).sorted(by: { $0 > $1 }).makeIterator() - var nextFieldNumber = fieldNumbersReversedIterator.next() - while nextFieldNumber != nil && merged.last!.start < nextFieldNumber! { - nextFieldNumber = fieldNumbersReversedIterator.next() - } - - for i in (0..<(merged.count - 1)).reversed() { - if nextFieldNumber == nil || merged[i].start > nextFieldNumber! { - // No fields left or range starts after the next field, merge it with - // the previous one. - merged[i].end = merged[i+1].end - merged.remove(at: i + 1) - } else { - // can't merge, find the next field number below this range. - while nextFieldNumber != nil && merged[i].start < nextFieldNumber! { - nextFieldNumber = fieldNumbersReversedIterator.next() - } - } - } - } - return merged - }() - - /// True/False if this Message is just for a `map<>` entry. - public var isMapEntry: Bool { return proto.options.mapEntry } - - /// Returns the `FieldDescriptor`s for the "key" and "value" fields. If - /// this isn't a map entry field, returns nil. - public var mapKeyAndValue: (key: FieldDescriptor, value: FieldDescriptor)? { - guard isMapEntry else { return nil } - assert(fields.count == 2) - return (key: fields[0], value: fields[1]) - } - - public var useMessageSetWireFormat: Bool { return proto.options.messageSetWireFormat } - - fileprivate init(proto: Google_Protobuf_DescriptorProto, - index: Int, - registry: Registry, - fullNamePrefix prefix: String) { - self.proto = proto - self.index = index - let fullName = "\(prefix).\(proto.name)" - self.fullName = fullName - - self.enums = proto.enumType.enumeratedMap { - return EnumDescriptor(proto: $1, index: $0, registry: registry, fullNamePrefix: fullName) - } - self.messages = proto.nestedType.enumeratedMap { - return Descriptor(proto: $1, index: $0, registry: registry, fullNamePrefix: fullName) - } - self.fields = proto.field.enumeratedMap { - return FieldDescriptor(proto: $1, index: $0, registry: registry) - } - self.oneofs = proto.oneofDecl.enumeratedMap { - return OneofDescriptor(proto: $1, index: $0, registry: registry) - } - self.extensions = proto.extension.enumeratedMap { - return FieldDescriptor(proto: $1, index: $0, registry: registry, isExtension: true) - } - - // Done initializing, register ourselves. - registry.register(message: self) - } - - fileprivate func bind(file: FileDescriptor, registry: Registry, containingType: Descriptor?) { - self.file = file - self.containingType = containingType - self.enums.forEach { $0.bind(file: file, registry: registry, containingType: self) } - self.messages.forEach { $0.bind(file: file, registry: registry, containingType: self) } - self.fields.forEach { $0.bind(file: file, registry: registry, containingType: self) } - self.oneofs.forEach { $0.bind(registry: registry, containingType: self) } - self.extensions.forEach { $0.bind(file: file, registry: registry, containingType: self) } - - // Synthetic oneofs come after normal oneofs. The C++ Descriptor enforces this, only - // here as a secondary validation because other code can rely on it. - var seenSynthetic = false - for o in self.oneofs { - if o.isSynthetic { - seenSynthetic = true - } else { - assert(!seenSynthetic) - } - } - } + // We can't assign a value directly to `proto` in the init because we get the + // deprecation warning. This private prop only exists as a workaround to avoid + // this warning and preserve backwards compatibility - it should be removed + // when removing `proto`. + private let _proto: Google_Protobuf_DescriptorProto + @available(*, deprecated, message: "Please open a GitHub issue if you think functionality is missing.") + public var proto: Google_Protobuf_DescriptorProto { + _proto + } + + /// The type of this Message. + public enum WellKnownType: String { + /// An instance of google.protobuf.DoubleValue. + case doubleValue = "google.protobuf.DoubleValue" + /// An instance of google.protobuf.FloatValue. + case floatValue = "google.protobuf.FloatValue" + /// An instance of google.protobuf.Int64Value. + case int64Value = "google.protobuf.Int64Value" + /// An instance of google.protobuf.UInt64Value. + case uint64Value = "google.protobuf.UInt64Value" + /// An instance of google.protobuf.Int32Value. + case int32Value = "google.protobuf.Int32Value" + /// An instance of google.protobuf.UInt32Value. + case uint32Value = "google.protobuf.UInt32Value" + /// An instance of google.protobuf.StringValue. + case stringValue = "google.protobuf.StringValue" + /// An instance of google.protobuf.BytesValue. + case bytesValue = "google.protobuf.BytesValue" + /// An instance of google.protobuf.BoolValue. + case boolValue = "google.protobuf.BoolValue" + + /// An instance of google.protobuf.Any. + case any = "google.protobuf.Any" + /// An instance of google.protobuf.FieldMask. + case fieldMask = "google.protobuf.FieldMask" + /// An instance of google.protobuf.Duration. + case duration = "google.protobuf.Duration" + /// An instance of google.protobuf.Timestamp. + case timestamp = "google.protobuf.Timestamp" + /// An instance of google.protobuf.Value. + case value = "google.protobuf.Value" + /// An instance of google.protobuf.ListValue. + case listValue = "google.protobuf.ListValue" + /// An instance of google.protobuf.Struct. + case `struct` = "google.protobuf.Struct" + } + + /// Describes an extension range of a message. `ExtensionRange`s are not + /// directly created, instead they are constructed/fetched via the + /// `Descriptor`. + public final class ExtensionRange { + /// The start field number of this range (inclusive). + public let start: Int32 + + // The end field number of this range (exclusive). + public fileprivate(set) var end: Int32 + + // Tndex of this extension range within the message's extension range array. + public let index: Int + + /// The resolved features for this ExtensionRange. + public let features: Google_Protobuf_FeatureSet + + /// The `Google_Protobuf_ExtensionRangeOptions` set on this ExtensionRange. + public let options: Google_Protobuf_ExtensionRangeOptions + + /// The name of the containing type, not including its scope. + public var name: String { containingType.name } + /// The fully-qualified name of the containing type, scope delimited by + /// periods. + public var fullName: String { containingType.fullName } + + /// The .proto file in which this ExtensionRange was defined. + public var file: FileDescriptor! { containingType.file } + /// The descriptor that owns with ExtensionRange. + public var containingType: Descriptor { _containingType! } + + // Storage for `containingType`, will be set by bind() + private unowned var _containingType: Descriptor? + + fileprivate init( + proto: Google_Protobuf_DescriptorProto.ExtensionRange, + index: Int, + features: Google_Protobuf_FeatureSet + ) { + self.start = proto.start + self.end = proto.end + self.index = index + self.features = features + self.options = proto.options + } + + fileprivate func bind(containingType: Descriptor, registry: Registry) { + self._containingType = containingType + } + } + + /// The name of the message type, not including its scope. + public let name: String + /// The fully-qualified name of the message type, scope delimited by + /// periods. For example, message type "Foo" which is declared in package + /// "bar" has full name "bar.Foo". If a type "Baz" is nested within + /// Foo, Baz's `fullName` is "bar.Foo.Baz". To get only the part that + /// comes after the last '.', use name(). + public let fullName: String + /// Index of this descriptor within the file or containing type's message + /// type array. + public let index: Int + + /// The .proto file in which this message type was defined. + public var file: FileDescriptor! { _file! } + /// If this Descriptor describes a nested type, this returns the type + /// in which it is nested. + public private(set) unowned var containingType: Descriptor? + + /// The resolved features for this Descriptor. + public let features: Google_Protobuf_FeatureSet + + /// The `Google_Protobuf_MessageOptions` set on this Message. + public let options: Google_Protobuf_MessageOptions + + // If this descriptor represents a well known type, which type it is. + public let wellKnownType: WellKnownType? + + /// The enum defintions under this message. + public let enums: [EnumDescriptor] + /// The message defintions under this message. In the C++ Descriptor this + /// is `nested_type`. + public let messages: [Descriptor] + /// The fields of this message. + public let fields: [FieldDescriptor] + /// The oneofs in this message. This can include synthetic oneofs. + public let oneofs: [OneofDescriptor] + /// Non synthetic oneofs. + /// + /// These always come first (enforced by the C++ Descriptor code). So this is always a + /// leading subset of `oneofs` (or the same if there are no synthetic entries). + public private(set) lazy var realOneofs: [OneofDescriptor] = { + // Lazy because `isSynthetic` can't be called until after `bind()`. + self.oneofs.filter { !$0._isSynthetic } + }() + /// The extension field defintions under this message. + public let extensions: [FieldDescriptor] + + /// The extension ranges declared for this message. They are returned in + /// the order they are defined in the .proto file. + public let messageExtensionRanges: [ExtensionRange] + + /// The extension ranges declared for this message. They are returned in + /// the order they are defined in the .proto file. + @available(*, deprecated, message: "This property is now deprecated: please use proto.extensionRange instead.") + public var extensionRanges: [Google_Protobuf_DescriptorProto.ExtensionRange] { + proto.extensionRange + } + + /// The `extensionRanges` are in the order they appear in the original .proto + /// file; this orders them and then merges any ranges that are actually + /// contiguious (i.e. - [(21,30),(10,20)] -> [(10,30)]) + @available(*, deprecated, message: "Please open a GitHub issue if you think functionality is missing.") + public private(set) lazy var normalizedExtensionRanges: [Google_Protobuf_DescriptorProto.ExtensionRange] = { + var ordered = self.extensionRanges.sorted(by: { $0.start < $1.start }) + if ordered.count > 1 { + for i in (0..<(ordered.count - 1)).reversed() { + if ordered[i].end == ordered[i + 1].start { + // This is why we need `end`'s setter to be `fileprivate` instead of + // having it be a `let`. + // We should turn it back into a let once we get rid of this prop. + ordered[i].end = ordered[i + 1].end + ordered.remove(at: i + 1) + } + } + } + return ordered + }() + + /// The `extensionRanges` from `normalizedExtensionRanges`, but takes a step + /// further in that any ranges that do _not_ have any fields inbetween them + /// are also merged together. These can then be used in context where it is + /// ok to include field numbers that have to be extension or unknown fields. + @available(*, deprecated, message: "Please open a GitHub issue if you think functionality is missing.") + public private(set) lazy var ambitiousExtensionRanges: [Google_Protobuf_DescriptorProto.ExtensionRange] = { + var merged = self.normalizedExtensionRanges + var sortedFields = self.fields.sorted { $0.number < $1.number } + if merged.count > 1 { + var fieldNumbersReversedIterator = + self.fields.map({ Int($0.number) }).sorted(by: { $0 > $1 }).makeIterator() + var nextFieldNumber = fieldNumbersReversedIterator.next() + while nextFieldNumber != nil && merged.last!.start < nextFieldNumber! { + nextFieldNumber = fieldNumbersReversedIterator.next() + } + + for i in (0..<(merged.count - 1)).reversed() { + if nextFieldNumber == nil || merged[i].start > nextFieldNumber! { + // No fields left or range starts after the next field, merge it with + // the previous one. + merged[i].end = merged[i + 1].end + merged.remove(at: i + 1) + } else { + // can't merge, find the next field number below this range. + while nextFieldNumber != nil && merged[i].start < nextFieldNumber! { + nextFieldNumber = fieldNumbersReversedIterator.next() + } + } + } + } + return merged + }() + + /// The reserved field number ranges for this message. These are returned + /// in the order they are defined in the .proto file. + public let reservedRanges: [Range] + /// The reserved field names for this message. These are returned in the + /// order they are defined in the .proto file. + public let reservedNames: [String] + + /// True/False if this Message is just for a `map<>` entry. + @available(*, deprecated, renamed: "options.mapEntry") + public var isMapEntry: Bool { options.mapEntry } + + /// Returns the `FieldDescriptor`s for the "key" and "value" fields. If + /// this isn't a map entry field, returns nil. + /// + /// This is like the C++ Descriptor `map_key()` and `map_value()` methods. + public var mapKeyAndValue: (key: FieldDescriptor, value: FieldDescriptor)? { + guard options.mapEntry else { return nil } + precondition(fields.count == 2) + return (key: fields[0], value: fields[1]) + } + + // Storage for `file`, will be set by bind() + private unowned var _file: FileDescriptor? + + @available(*, deprecated, renamed: "options.messageSetWireFormat") + public var useMessageSetWireFormat: Bool { options.messageSetWireFormat } + + fileprivate init( + proto: Google_Protobuf_DescriptorProto, + index: Int, + parentFeatures: Google_Protobuf_FeatureSet, + featureResolver: FeatureResolver, + registry: Registry, + scope: String + ) { + self._proto = proto + self.name = proto.name + let fullName = scope.isEmpty ? proto.name : "\(scope).\(proto.name)" + self.fullName = fullName + self.index = index + let resolvedFeatures = featureResolver.resolve(proto.options, resolvedParent: parentFeatures) + self.features = resolvedFeatures + self.options = proto.options + self.wellKnownType = WellKnownType(rawValue: fullName) + self.reservedRanges = proto.reservedRange.map { $0.start..<$0.end } + self.reservedNames = proto.reservedName + + // TODO: This can skip the synthetic oneofs as no features can be set on + // them to inherrit things. + let oneofFeatures = proto.oneofDecl.map { + featureResolver.resolve($0.options, resolvedParent: resolvedFeatures) + } + + self.messageExtensionRanges = proto.extensionRange.enumerated().map { + ExtensionRange( + proto: $0.element, + index: $0.offset, + features: featureResolver.resolve( + $0.element.options, + resolvedParent: resolvedFeatures + ) + ) + } + self.enums = proto.enumType.enumerated().map { + EnumDescriptor( + proto: $0.element, + index: $0.offset, + parentFeatures: resolvedFeatures, + featureResolver: featureResolver, + registry: registry, + scope: fullName + ) + } + self.messages = proto.nestedType.enumerated().map { + Descriptor( + proto: $0.element, + index: $0.offset, + parentFeatures: resolvedFeatures, + featureResolver: featureResolver, + registry: registry, + scope: fullName + ) + } + self.fields = proto.field.enumerated().map { + // For field Features inherrit from the parent oneof or message. A + // synthetic oneof (for proto3 optional) can't get features, so those + // don't come into play. + let inRealOneof = $0.element.hasOneofIndex && !$0.element.proto3Optional + return FieldDescriptor( + messageField: $0.element, + index: $0.offset, + parentFeatures: inRealOneof ? oneofFeatures[Int($0.element.oneofIndex)] : resolvedFeatures, + featureResolver: featureResolver, + registry: registry + ) + } + self.oneofs = proto.oneofDecl.enumerated().map { + OneofDescriptor( + proto: $0.element, + index: $0.offset, + features: oneofFeatures[$0.offset], + registry: registry + ) + } + self.extensions = proto.extension.enumerated().map { + FieldDescriptor( + extension: $0.element, + index: $0.offset, + parentFeatures: resolvedFeatures, + featureResolver: featureResolver, + registry: registry + ) + } + + // Done initializing, register ourselves. + registry.register(message: self) + } + + fileprivate func bind(file: FileDescriptor, registry: Registry, containingType: Descriptor?) { + _file = file + self.containingType = containingType + for e in messageExtensionRanges { e.bind(containingType: self, registry: registry) } + for e in enums { e.bind(file: file, registry: registry, containingType: self) } + for m in messages { m.bind(file: file, registry: registry, containingType: self) } + for f in fields { f.bind(file: file, registry: registry, containingType: self) } + for o in oneofs { o.bind(registry: registry, containingType: self) } + for e in extensions { e.bind(file: file, registry: registry, containingType: self) } + + // Synthetic oneofs come after normal oneofs. The C++ Descriptor enforces this, only + // here as a secondary validation because other code can rely on it. + var seenSynthetic = false + for o in oneofs { + if seenSynthetic { + // Once we've seen one synthetic, all the rest must also be synthetic. + precondition(o._isSynthetic) + } else { + seenSynthetic = o._isSynthetic + } + } + } } +/// Describes a type of protocol enum. `EnumDescriptor`s are not directly +/// created, instead they are constructed/fetched via the `DescriptorSet` or +/// they are directly accessed via a `EnumType` property on `FieldDescriptor`s, +/// etc. public final class EnumDescriptor { - public let proto: Google_Protobuf_EnumDescriptorProto - let index: Int - public let fullName: String - public var name: String { return proto.name } - public private(set) weak var file: FileDescriptor! - public private(set) weak var containingType: Descriptor? - - // This is lazy so it is they are created only when needed, that way an - // import doesn't have to do all this work unless the enum is used by - // the importer. - public private(set) lazy var values: [EnumValueDescriptor] = { - var firstValues = [Int32:EnumValueDescriptor]() - var result = [EnumValueDescriptor]() - var i = 0 - for p in self.proto.value { - let aliasing = firstValues[p.number] - let d = EnumValueDescriptor(proto: p, index: i, enumType: self, aliasing: aliasing) - result.append(d) - i += 1 - - if let aliasing = aliasing { - aliasing.aliases.append(d) - } else { - firstValues[d.number] = d - } - } - return result - }() - - public var defaultValue: EnumValueDescriptor { - // The compiler requires the be atleast one value, so force unwrap is safe. - return values.first! - } - - fileprivate init(proto: Google_Protobuf_EnumDescriptorProto, - index: Int, - registry: Registry, - fullNamePrefix prefix: String) { - self.proto = proto - self.index = index - self.fullName = "\(prefix).\(proto.name)" - - // Done initializing, register ourselves. - registry.register(enum: self) - } - - fileprivate func bind(file: FileDescriptor, registry: Registry, containingType: Descriptor?) { - self.file = file - self.containingType = containingType - } + // We can't assign a value directly to `proto` in the init because we get the + // deprecation warning. This private prop only exists as a workaround to avoid + // this warning and preserve backwards compatibility - it should be removed + // when removing `proto`. + private let _proto: Google_Protobuf_EnumDescriptorProto + @available(*, deprecated, message: "Please open a GitHub issue if you think functionality is missing.") + public var proto: Google_Protobuf_EnumDescriptorProto { + _proto + } + + /// The name of this enum type in the containing scope. + public let name: String + /// The fully-qualified name of the enum type, scope delimited by periods. + public let fullName: String + /// Index of this enum within the file or containing message's enums. + public let index: Int + + /// The .proto file in which this message type was defined. + public var file: FileDescriptor! { _file! } + /// If this Descriptor describes a nested type, this returns the type + /// in which it is nested. + public private(set) unowned var containingType: Descriptor? + + /// The resolved features for this Enum. + public let features: Google_Protobuf_FeatureSet + + /// The values defined for this enum. Guaranteed (by protoc) to be atleast + /// one item. These are returned in the order they were defined in the .proto + /// file. + public let values: [EnumValueDescriptor] + + /// The `Google_Protobuf_MessageOptions` set on this enum. + public let options: Google_Protobuf_EnumOptions + + /// The reserved value ranges for this enum. These are returned in the order + /// they are defined in the .proto file. + public let reservedRanges: [ClosedRange] + /// The reserved value names for this enum. These are returned in the order + /// they are defined in the .proto file. + public let reservedNames: [String] + + /// Returns true whether this is a "closed" enum, meaning that it: + /// - Has a fixed set of named values. + /// - Encountering values not in this set causes them to be treated as unknown + /// fields. + /// - The first value (i.e., the default) may be nonzero. + public var isClosed: Bool { + // Implementation comes from C++ EnumDescriptor::is_closed(). + features.enumType == .closed + } + + // Storage for `file`, will be set by bind() + private unowned var _file: FileDescriptor? + + @available(*, deprecated, message: "Please open a GitHub issue if you think functionality is missing.") + public var defaultValue: EnumValueDescriptor { + // The compiler requires the be atleast one value, so force unwrap is safe. + values.first! + } + + fileprivate init( + proto: Google_Protobuf_EnumDescriptorProto, + index: Int, + parentFeatures: Google_Protobuf_FeatureSet, + featureResolver: FeatureResolver, + registry: Registry, + scope: String + ) { + self._proto = proto + self.name = proto.name + self.fullName = scope.isEmpty ? proto.name : "\(scope).\(proto.name)" + self.index = index + let resolvedFeatures = featureResolver.resolve(proto.options, resolvedParent: parentFeatures) + self.features = resolvedFeatures + self.options = proto.options + self.reservedRanges = proto.reservedRange.map { $0.start...$0.end } + self.reservedNames = proto.reservedName + + self.values = proto.value.enumerated().map { + EnumValueDescriptor( + proto: $0.element, + index: $0.offset, + features: featureResolver.resolve( + $0.element.options, + resolvedParent: resolvedFeatures + ), + scope: scope + ) + } + + // Done initializing, register ourselves. + registry.register(enum: self) + + for v in values { v.bind(enumType: self) } + } + + fileprivate func bind(file: FileDescriptor, registry: Registry, containingType: Descriptor?) { + _file = file + self.containingType = containingType + } } +/// Describes an individual enum constant of a particular type. To get the +/// `EnumValueDescriptor` for a given enum value, first get the `EnumDescriptor` +/// for its type. public final class EnumValueDescriptor { - public let proto: Google_Protobuf_EnumValueDescriptorProto - let index: Int - public private(set) weak var enumType: EnumDescriptor! - public weak var file: FileDescriptor! { return enumType.file } - - public var name: String { return proto.name } - public var fullName: String - public var number: Int32 { return proto.number } - - public private(set) weak var aliasOf: EnumValueDescriptor? - public fileprivate(set) var aliases: [EnumValueDescriptor] = [] - - fileprivate init(proto: Google_Protobuf_EnumValueDescriptorProto, - index: Int, - enumType: EnumDescriptor, - aliasing: EnumValueDescriptor?) { - self.proto = proto - self.index = index - self.enumType = enumType - aliasOf = aliasing - - let fullName = "\(enumType.fullName).\(proto.name)" - self.fullName = fullName - } + // We can't assign a value directly to `proto` in the init because we get the + // deprecation warning. This private prop only exists as a workaround to avoid + // this warning and preserve backwards compatibility - it should be removed + // when removing `proto`. + private let _proto: Google_Protobuf_EnumValueDescriptorProto + @available(*, deprecated, message: "Please open a GitHub issue if you think functionality is missing.") + public var proto: Google_Protobuf_EnumValueDescriptorProto { + _proto + } + + /// Name of this enum constant. + public let name: String + + private var _fullName: String + /// The full_name of an enum value is a sibling symbol of the enum type. + /// e.g. the full name of FieldDescriptorProto::TYPE_INT32 is actually + /// "google.protobuf.FieldDescriptorProto.TYPE_INT32", NOT + /// "google.protobuf.FieldDescriptorProto.Type.TYPE_INT32". This is to conform + /// with C++ scoping rules for enums. + public var fullName: String { + get { + self._fullName + } + + @available(*, deprecated, message: "fullName is now read-only") + set { + self._fullName = newValue + } + } + /// Index within the enums's `EnumDescriptor`. + public let index: Int + /// Numeric value of this enum constant. + public let number: Int32 + + @available(*, deprecated, message: "Please open a GitHub issue if you think functionality is missing.") + public private(set) weak var aliasOf: EnumValueDescriptor? + @available(*, deprecated, message: "Please open a GitHub issue if you think functionality is missing.") + public fileprivate(set) var aliases: [EnumValueDescriptor] = [] + + /// The resolved features for this EnumValue. + public let features: Google_Protobuf_FeatureSet + + /// The .proto file in which this message type was defined. + public var file: FileDescriptor! { enumType.file } + /// The type of this value. + public var enumType: EnumDescriptor! { _enumType! } + + /// The `Google_Protobuf_EnumValueOptions` set on this value. + public let options: Google_Protobuf_EnumValueOptions + + // Storage for `enumType`, will be set by bind() + private unowned var _enumType: EnumDescriptor? + + fileprivate init( + proto: Google_Protobuf_EnumValueDescriptorProto, + index: Int, + features: Google_Protobuf_FeatureSet, + scope: String + ) { + self._proto = proto + self.name = proto.name + self._fullName = scope.isEmpty ? proto.name : "\(scope).\(proto.name)" + self.index = index + self.features = features + self.number = proto.number + self.options = proto.options + } + + fileprivate func bind(enumType: EnumDescriptor) { + self._enumType = enumType + } } +/// Describes a oneof defined in a message type. public final class OneofDescriptor { - public let proto: Google_Protobuf_OneofDescriptorProto - let index: Int - public private(set) weak var containingType: Descriptor! - public weak var file: FileDescriptor! { return containingType.file } - - public var name: String { return proto.name } - - /// Returns whether this oneof was inserted by the compiler to wrap a proto3 - /// optional field. If this returns true, code generators should *not* emit it. - public var isSynthetic: Bool { - return fields.count == 1 && fields.first!.proto3Optional - } - - public private(set) lazy var fields: [FieldDescriptor] = { - let myIndex = Int32(self.index) - return self.containingType.fields.filter { $0.oneofIndex == myIndex } - }() - - fileprivate init(proto: Google_Protobuf_OneofDescriptorProto, - index: Int, - registry: Registry) { - self.proto = proto - self.index = index - } - - fileprivate func bind(registry: Registry, containingType: Descriptor) { - self.containingType = containingType - } + // We can't assign a value directly to `proto` in the init because we get the + // deprecation warning. This private prop only exists as a workaround to avoid + // this warning and preserve backwards compatibility - it should be removed + // when removing `proto`. + private let _proto: Google_Protobuf_OneofDescriptorProto + @available(*, deprecated, message: "Please open a GitHub issue if you think functionality is missing.") + public var proto: Google_Protobuf_OneofDescriptorProto { + _proto + } + + /// Name of this oneof. + public let name: String + /// Fully-qualified name of the oneof. + public var fullName: String { "\(containingType.fullName).\(name)" } + /// Index of this oneof within the message's oneofs. + public let index: Int + + /// The resolved features for this Oneof. + public let features: Google_Protobuf_FeatureSet + + /// Returns whether this oneof was inserted by the compiler to wrap a proto3 + /// optional field. If this returns true, code generators should *not* emit it. + var _isSynthetic: Bool { + fields.count == 1 && fields.first!.proto3Optional + } + @available(*, deprecated, message: "Please open a GitHub issue if you think functionality is missing.") + public var isSynthetic: Bool { + _isSynthetic + } + + /// The .proto file in which this oneof type was defined. + public var file: FileDescriptor! { containingType.file } + /// The Descriptor of the message that defines this oneof. + public var containingType: Descriptor! { _containingType! } + + /// The `Google_Protobuf_OneofOptions` set on this oneof. + public let options: Google_Protobuf_OneofOptions + + /// The members of this oneof, in the order in which they were declared in the + /// .proto file. + public private(set) lazy var fields: [FieldDescriptor] = { + let myIndex = Int32(self.index) + return containingType.fields.filter { $0.oneofIndex == myIndex } + }() + + // Storage for `containingType`, will be set by bind() + private unowned var _containingType: Descriptor? + + fileprivate init( + proto: Google_Protobuf_OneofDescriptorProto, + index: Int, + features: Google_Protobuf_FeatureSet, + registry: Registry + ) { + self._proto = proto + self.name = proto.name + self.index = index + self.features = features + self.options = proto.options + } + + fileprivate func bind(registry: Registry, containingType: Descriptor) { + _containingType = containingType + } } +/// Describes a single field of a message. To get the descriptor for a given +/// field, first get the `Descriptor` for the message in which it is defined, +/// then find the field. To get a `FieldDescriptor` for an extension, get the +/// `Descriptor` or `FileDescriptor` for its containing scope, find the +/// extension. public final class FieldDescriptor { - public let proto: Google_Protobuf_FieldDescriptorProto - let index: Int - public private(set) weak var file: FileDescriptor! - /// The Descriptor of the message which this is a field of. For extensions, - /// this is the extended type. - public private(set) weak var containingType: Descriptor! - - public var name: String { return proto.name } - public var number: Int32 { return proto.number } - public var label: Google_Protobuf_FieldDescriptorProto.Label { return proto.label } - public var type: Google_Protobuf_FieldDescriptorProto.TypeEnum { return proto.type } - - var proto3Optional: Bool { return proto.proto3Optional } - - /// Returns true if this field was syntactically written with "optional" in the - /// .proto file. Excludes singular proto3 fields that do not have a label. - public var hasOptionalKeyword: Bool { - return proto3Optional || - (file.syntax == .proto2 && label == .optional && oneofIndex == nil) - } - - /// Returns true if this field tracks presence, ie. does the field - /// distinguish between "unset" and "present with default value." - /// This includes required, optional, and oneof fields. It excludes maps, - /// repeated fields, and singular proto3 fields without "optional". - public var hasPresence: Bool { - guard label != .repeated else { return false } - switch type { - case .group, .message: - // Groups/messages always get field presence. - return true - default: - return file.syntax == .proto2 || oneofIndex != nil - } - } - - public var fullName: String { - // Since the fullName isn't needed on Fields that often, compute it on demand. - let prefix: String - if isExtension { - if let extensionScope = extensionScope { - prefix = extensionScope.fullName - } else { + // We can't assign a value directly to `proto` in the init because we get the + // deprecation warning. This private prop only exists as a workaround to avoid + // this warning and preserve backwards compatibility - it should be removed + // when removing `proto`. + private let _proto: Google_Protobuf_FieldDescriptorProto + @available(*, deprecated, message: "Please open a GitHub issue if you think functionality is missing.") + public var proto: Google_Protobuf_FieldDescriptorProto { + _proto + } + + /// Name of this field within the message. + public let name: String + /// Fully-qualified name of the field. + public var fullName: String { + // Since the fullName isn't needed on fields that often, compute it on demand. + guard isExtension else { + // Normal field on a message. + return "\(containingType.fullName).\(name)" + } + if let extensionScope = extensionScope { + return "\(extensionScope.fullName).\(name)" + } let package = file.package - if package.isEmpty { - prefix = "" + return package.isEmpty ? name : "\(package).\(name)" + } + /// JSON name of this field. + public let jsonName: String? + + public let features: Google_Protobuf_FeatureSet + + /// File in which this field was defined. + public var file: FileDescriptor! { _file! } + + /// If this is an extension field. + public let isExtension: Bool + /// The field number. + public let number: Int32 + + /// Valid field numbers are positive integers up to kMaxNumber. + static let kMaxNumber: Int = (1 << 29) - 1 + + /// First field number reserved for the protocol buffer library + /// implementation. Users may not declare fields that use reserved numbers. + static let kFirstReservedNumber: Int = 19000 + /// Last field number reserved for the protocol buffer library implementation. + /// Users may not declare fields that use reserved numbers. + static let kLastReservedNumber: Int = 19999 + + /// Declared type of this field. + public private(set) var type: Google_Protobuf_FieldDescriptorProto.TypeEnum + + /// This should never be called directly. Use isRequired and isRepeated + /// helper methods instead. + @available(*, deprecated, message: "Use isRequired or isRepeated instead.") + public var label: Google_Protobuf_FieldDescriptorProto.Label { + if isRepeated { + return .repeated + } else if isRequired { + return .required } else { - prefix = ".\(package)" - } - } - } else { - prefix = containingType.fullName - } - return "\(prefix).\(proto.name)" - } - - public var jsonName: String? { - guard proto.hasJsonName else { return nil } - return proto.jsonName - } - - /// The default value (string) set in the proto file. - public var explicitDefaultValue: String? { - if !proto.hasDefaultValue { - return nil - } - return proto.defaultValue - } - - /// True if this field is a map. - public var isMap: Bool { - // Maps are releated messages. - if label != .repeated || type != .message { - return false - } - return messageType.isMapEntry - } - - /// If this is an extension field. - public let isExtension: Bool - /// Extensions can be declared within the scope of another message. If this - /// is an extension field, then this will be the scope it was declared in - /// nil if was declared at a global scope. - public private(set) weak var extensionScope: Descriptor? - - /// The index in a oneof this field is in. - public let oneofIndex: Int32? - - /// The oneof this field is a member of. - public var oneof: OneofDescriptor? { - guard let oneofIndex = oneofIndex else { return nil } - assert(!isExtension) - return containingType!.oneofs[Int(oneofIndex)] - } - - /// The non synthetic oneof this field is a member of. - public var realOneof: OneofDescriptor? { - guard let oneof = oneof, !oneof.isSynthetic else { return nil } - return oneof - } - - /// When this is a message field, the message's desciptor. - public private(set) weak var messageType: Descriptor! - /// When this is a enum field, the enum's desciptor. - public private(set) weak var enumType: EnumDescriptor! - - /// Should this field be packed format. - public var isPacked: Bool { - // NOTE: As of May 2017, the proto3 spec says: - // - // https://developers.google.com/protocol-buffers/docs/proto3#specifying-field-rules - - // "In proto3, repeated fields of scalar numeric types use packed encoding by default." - // - // But this does not result in the field option for packed being set by protoc. Instead - // there is some interesting logic in the C++ desciptor classes that causes the field - // to be packed, but does leave the door open for it not to be backed. So the logic - // here and in the helpers this cases duplicates that logic. - - // This logic comes from the C++ FieldDescriptor::is_packed() impl. - guard isPackable else { return false } - if file.syntax == .proto2 { - return proto.hasOptions && proto.options.packed - } else { - return !proto.hasOptions || !proto.options.hasPacked || proto.options.packed - } - } - - public var options: Google_Protobuf_FieldOptions { return proto.options } - - fileprivate init(proto: Google_Protobuf_FieldDescriptorProto, - index: Int, - registry: Registry, - isExtension: Bool = false) { - self.proto = proto - self.index = index - self.isExtension = isExtension - if proto.hasOneofIndex { - assert(!isExtension) - oneofIndex = proto.oneofIndex - } else { - oneofIndex = nil - // FieldDescriptorProto is used for fields or extensions, generally - // .proto3Optional only makes sense on fields if it is in a oneof. But - // It is allowed on extensions. For information on that, see - // https://github.com/protocolbuffers/protobuf/issues/8234#issuecomment-774224376 - // The C++ Descriptor code encorces the field/oneof part, but nothing - // is checked on the oneof side. - assert(!proto.proto3Optional || isExtension) - } - } - - fileprivate func bind(file: FileDescriptor, registry: Registry, containingType: Descriptor?) { - self.file = file - - assert(isExtension == !proto.extendee.isEmpty) - if isExtension { - extensionScope = containingType - self.containingType = registry.descriptor(name: proto.extendee) - } else { - self.containingType = containingType - } - - switch type { - case .group, .message: - messageType = registry.descriptor(name: proto.typeName) - case .enum: - enumType = registry.enumDescriptor(name: proto.typeName) - default: - break - } - } -} + return .optional + } + } -public final class ServiceDescriptor { - public let proto: Google_Protobuf_ServiceDescriptorProto - let index: Int - public let fullName: String - public var name: String { return proto.name } - public private(set) weak var file: FileDescriptor! - - public let methods: [MethodDescriptor] - - fileprivate init(proto: Google_Protobuf_ServiceDescriptorProto, - index: Int, - registry: Registry, - fullNamePrefix prefix: String) { - self.proto = proto - self.index = index - let fullName = "\(prefix).\(proto.name)" - self.fullName = fullName - - self.methods = proto.method.enumeratedMap { - return MethodDescriptor(proto: $1, index: $0, registry: registry) - } - - // Done initializing, register ourselves. - registry.register(service: self) - } - - fileprivate func bind(file: FileDescriptor, registry: Registry) { - self.file = file - methods.forEach { $0.bind(service: self, registry: registry) } - } + // Storage for `label`, used by other apis. + private var _label: Google_Protobuf_FieldDescriptorProto.Label + + /// Whether or not the field is required. For proto2 required fields and + /// Editions `LEGACY_REQUIRED` fields. + public var isRequired: Bool { + // Implementation comes from FieldDescriptor::is_required() + features.fieldPresence == .legacyRequired + } + /// Whether or not the field is repeated/map field. + public var isRepeated: Bool { _label == .repeated } + + /// Use !isRequired() && !isRepeated() instead. + @available(*, deprecated, message: "Use !isRequired && !isRepeated instead.") + public var isOptional: Bool { label == .optional } + + /// Is this field packable. + public var isPackable: Bool { + // This logic comes from the C++ FieldDescriptor::is_packable() impl. + isRepeated && FieldDescriptor.isPackable(type: type) + } + /// If this field is packable and packed. + public var isPacked: Bool { + // This logic comes from the C++ FieldDescriptor::is_packed() impl. + guard isPackable else { return false } + return features.repeatedFieldEncoding == .packed + } + /// True if this field is a map. + public var isMap: Bool { + // This logic comes from the C++ FieldDescriptor::is_map() impl. + type == .message && messageType!.options.mapEntry + } + + /// Returns true if this field was syntactically written with "optional" in the + /// .proto file. Excludes singular proto3 fields that do not have a label. + package var _hasOptionalKeyword: Bool { + // This logic comes from the C++ FieldDescriptor::has_optional_keyword() + // impl. + proto3Optional || (file.edition == .proto2 && !isRequired && !isRepeated && oneofIndex == nil) + } + @available(*, deprecated, message: "Please open a GitHub issue if you think functionality is missing.") + public var hasOptionalKeyword: Bool { + _hasOptionalKeyword + } + + /// Returns true if this field tracks presence, ie. does the field + /// distinguish between "unset" and "present with default value." + /// This includes required, optional, and oneof fields. It excludes maps, + /// repeated fields, and singular proto3 fields without "optional". + public var hasPresence: Bool { + // This logic comes from the C++ FieldDescriptor::has_presence() impl. + guard !isRepeated else { return false } + switch type { + case .group, .message: + // Groups/messages always get field presence. + return true + default: + break + } + return isExtension || oneofIndex != nil || features.fieldPresence != .implicit + } + + /// Returns true if this is a string field and should do UTF-8 validation. + /// + /// This api is for completeness, but it likely should never be used. The + /// concept comes from the C++ FieldDescriptory::requires_utf8_validation(), + /// but doesn't make a lot of sense for Swift Protobuf because `string` fields + /// are modeled as Swift `String` objects, and thus they always have to be + /// valid UTF-8. If something were to try putting something else in the field, + /// the library won't be able to parse it. While that sounds bad, other + /// languages have similar issues with their _string_ types and thus have the + /// same issues. + public var requiresUTF8Validation: Bool { + type == .string && features.utf8Validation == .verify + } + + /// Index of this field within the message's fields, or the file or + /// extension scope's extensions. + public let index: Int + + /// The explicitly declared default value for this field. + /// + /// This is the *raw* string value from the .proto file that was listed as + /// the default, it is up to the consumer to convert it correctly for the + /// type of this field. The C++ FieldDescriptor does offer some apis to + /// help with that, but at this time, that is not provided here. + @available(*, deprecated, renamed: "defaultValue") + public var explicitDefaultValue: String? { + defaultValue + } + + /// The explicitly declared default value for this field. + /// + /// This is the *raw* string value from the .proto file that was listed as + /// the default, it is up to the consumer to convert it correctly for the + /// type of this field. The C++ FieldDescriptor does offer some apis to + /// help with that, but at this time, that is not provided here. + public let defaultValue: String? + + /// The `Descriptor` of the message which this is a field of. For extensions, + /// this is the extended type. + public var containingType: Descriptor! { _containingType! } + + /// The oneof this field is a member of. + @available(*, deprecated, renamed: "containingOneof") + public var oneof: OneofDescriptor? { + containingOneof + } + /// The oneof this field is a member of. + public var containingOneof: OneofDescriptor? { + guard let oneofIndex = oneofIndex else { return nil } + return containingType.oneofs[Int(oneofIndex)] + } + + /// The non synthetic oneof this field is a member of. + @available(*, deprecated, renamed: "realContainingOneof") + public var realOneof: OneofDescriptor? { + realContainingOneof + } + /// The non synthetic oneof this field is a member of. + public var realContainingOneof: OneofDescriptor? { + guard let oneof = containingOneof, !oneof._isSynthetic else { return nil } + return oneof + } + /// The index in a oneof this field is in. + public let oneofIndex: Int32? + + // This builds basically a union for the storage for `extensionScope` + // and the value to look it up with. + private enum ExtensionScopeStorage { + case extendee(String) // The value to be used for looked up during `bind()`. + case message(UnownedBox) + } + private var _extensionScopeStorage: ExtensionScopeStorage? + + /// Extensions can be declared within the scope of another message. If this + /// is an extension field, then this will be the scope it was declared in + /// nil if was declared at a global scope. + public var extensionScope: Descriptor? { + guard case .message(let boxed) = _extensionScopeStorage else { return nil } + return boxed.value + } + + // This builds basically a union for the storage for `messageType` + // and `enumType` since only one can needed at a time. + private enum FieldTypeStorage { + case typeName(String) // The value to be looked up during `bind()`. + case message(UnownedBox) + case `enum`(UnownedBox) + } + private var _fieldTypeStorage: FieldTypeStorage? + + /// When this is a message/group field, that message's `Descriptor`. + public var messageType: Descriptor! { + guard case .message(let boxed) = _fieldTypeStorage else { return nil } + return boxed.value + } + /// When this is a enum field, that enum's `EnumDescriptor`. + public var enumType: EnumDescriptor! { + guard case .enum(let boxed) = _fieldTypeStorage else { return nil } + return boxed.value + } + + /// The FieldOptions for this field. + public var options: Google_Protobuf_FieldOptions + + let proto3Optional: Bool + + // Storage for `containingType`, will be set by bind() + private unowned var _containingType: Descriptor? + // Storage for `file`, will be set by bind() + private unowned var _file: FileDescriptor? + + fileprivate convenience init( + messageField proto: Google_Protobuf_FieldDescriptorProto, + index: Int, + parentFeatures: Google_Protobuf_FeatureSet, + featureResolver: FeatureResolver, + registry: Registry + ) { + precondition(proto.extendee.isEmpty) // Only for extensions + + // On regular fields, it only makes sense to get `.proto3Optional` + // when also in a (synthetic) oneof. So...no oneof index, it better + // not be `.proto3Optional` + precondition(proto.hasOneofIndex || !proto.proto3Optional) + + self.init( + proto: proto, + index: index, + parentFeatures: parentFeatures, + featureResolver: featureResolver, + registry: registry, + isExtension: false + ) + } + + fileprivate convenience init( + extension proto: Google_Protobuf_FieldDescriptorProto, + index: Int, + parentFeatures: Google_Protobuf_FeatureSet, + featureResolver: FeatureResolver, + registry: Registry + ) { + precondition(!proto.extendee.isEmpty) // Required for extensions + + // FieldDescriptorProto is used for fields or extensions, generally + // .proto3Optional only makes sense on fields if it is in a oneof. But, + // it is allowed on extensions. For information on that, see + // https://github.com/protocolbuffers/protobuf/issues/8234#issuecomment-774224376 + // The C++ Descriptor code encorces the field/oneof part, but nothing + // is checked on the oneof side. + precondition(!proto.hasOneofIndex) + + self.init( + proto: proto, + index: index, + parentFeatures: parentFeatures, + featureResolver: featureResolver, + registry: registry, + isExtension: true + ) + } + + private init( + proto: Google_Protobuf_FieldDescriptorProto, + index: Int, + parentFeatures: Google_Protobuf_FeatureSet, + featureResolver: FeatureResolver, + registry: Registry, + isExtension: Bool + ) { + self._proto = proto + self.name = proto.name + self.index = index + self.features = featureResolver.resolve(proto, resolvedParent: parentFeatures) + self.defaultValue = proto.hasDefaultValue ? proto.defaultValue : nil + precondition(proto.hasJsonName) // protoc should always set the name + self.jsonName = proto.jsonName + self.isExtension = isExtension + self.number = proto.number + // This remapping is based follow part of what upstream + // `DescriptorBuilder::PostProcessFieldFeatures()` does. It is needed to + // help ensure basic transforms from .proto2 to .edition2023 generate the + // same code/behaviors. + if proto.type == .message && self.features.messageEncoding == .delimited { + self.type = .group + } else { + self.type = proto.type + } + // This remapping is based follow part of what upstream + // `DescriptorBuilder::PostProcessFieldFeatures()` does. If generators use + // helper instead of access `label` directly, they won't need this, but for + // consistency, remap `label` to expose the pre Editions/Features value. + if self.features.fieldPresence == .legacyRequired && proto.label == .optional { + self._label = .required + } else { + self._label = proto.label + } + self.options = proto.options + self.oneofIndex = proto.hasOneofIndex ? proto.oneofIndex : nil + self.proto3Optional = proto.proto3Optional + self._extensionScopeStorage = isExtension ? .extendee(proto.extendee) : nil + switch type { + case .group, .message, .enum: + _fieldTypeStorage = .typeName(proto.typeName) + default: + _fieldTypeStorage = nil + } + } + + fileprivate func bind(file: FileDescriptor, registry: Registry, containingType: Descriptor?) { + _file = file + + // See the defintions of `containingType` and `extensionScope`, this + // dance can otherwise be a little confusing. + if case .extendee(let extendee) = _extensionScopeStorage { + _containingType = registry.descriptor(named: extendee)! + if let containingType = containingType { + _extensionScopeStorage = .message(UnownedBox(value: containingType)) + } else { + _extensionScopeStorage = nil // Top level + } + } else { + _containingType = containingType + } + + if case .typeName(let typeName) = _fieldTypeStorage { + if type == .enum { + _fieldTypeStorage = .enum(UnownedBox(value: registry.enumDescriptor(named: typeName)!)) + } else { + let msgtype = registry.descriptor(named: typeName)! + _fieldTypeStorage = .message(UnownedBox(value: msgtype)) + if type == .group + && (msgtype.options.mapEntry || (_containingType != nil && _containingType!.options.mapEntry)) + { + type = .message + } + } + } + } } -public final class MethodDescriptor { - public let proto: Google_Protobuf_MethodDescriptorProto - let index: Int - public private(set) weak var service: ServiceDescriptor! - public weak var file: FileDescriptor! { return service.file } +/// Describes an RPC service. +/// +/// SwiftProtobuf does *not* generate anything for these (or methods), but +/// they are here to support things that generate based off RPCs defined in +/// .proto file (gRPC, etc.). +public final class ServiceDescriptor { + // We can't assign a value directly to `proto` in the init because we get the + // deprecation warning. This private prop only exists as a workaround to avoid + // this warning and preserve backwards compatibility - it should be removed + // when removing `proto`. + private let _proto: Google_Protobuf_ServiceDescriptorProto + @available(*, deprecated, message: "Please open a GitHub issue if you think functionality is missing.") + public var proto: Google_Protobuf_ServiceDescriptorProto { + _proto + } - public var name: String { return proto.name } + /// The name of the service, not including its containing scope. + public let name: String + /// The fully-qualified name of the service, scope delimited by periods. + public let fullName: String + /// Index of this service within the file's services. + public let index: Int + + /// The .proto file in which this service was defined + public var file: FileDescriptor! { _file! } + + /// The resolved features for this Service. + public let features: Google_Protobuf_FeatureSet + + /// Get `Google_Protobuf_ServiceOptions` for this service. + public let options: Google_Protobuf_ServiceOptions + + /// The methods defined on this service. These are returned in the order they + /// were defined in the .proto file. + public let methods: [MethodDescriptor] + + // Storage for `file`, will be set by bind() + private unowned var _file: FileDescriptor? + + fileprivate init( + proto: Google_Protobuf_ServiceDescriptorProto, + index: Int, + fileFeatures: Google_Protobuf_FeatureSet, + featureResolver: FeatureResolver, + registry: Registry, + scope: String + ) { + self._proto = proto + self.name = proto.name + self.fullName = scope.isEmpty ? proto.name : "\(scope).\(proto.name)" + self.index = index + let resolvedFeatures = featureResolver.resolve(proto.options, resolvedParent: fileFeatures) + self.features = resolvedFeatures + self.options = proto.options + + self.methods = proto.method.enumerated().map { + MethodDescriptor( + proto: $0.element, + index: $0.offset, + features: featureResolver.resolve($0.element.options, resolvedParent: resolvedFeatures), + registry: registry + ) + } - public private(set) var inputType: Descriptor! - public private(set) var outputType: Descriptor! + // Done initializing, register ourselves. + registry.register(service: self) + } - fileprivate init(proto: Google_Protobuf_MethodDescriptorProto, - index: Int, - registry: Registry) { - self.proto = proto - self.index = index - } + fileprivate func bind(file: FileDescriptor, registry: Registry) { + _file = file + for m in methods { m.bind(service: self, registry: registry) } + } +} - fileprivate func bind(service: ServiceDescriptor, registry: Registry) { - self.service = service - inputType = registry.descriptor(name: proto.inputType) - outputType = registry.descriptor(name: proto.outputType) - } +/// Describes an individual service method. +/// +/// SwiftProtobuf does *not* generate anything for these (or services), but +/// they are here to support things that generate based off RPCs defined in +/// .proto file (gRPC, etc.). +public final class MethodDescriptor { + /// The name of the method, not including its containing scope. + public let name: String + /// The fully-qualified name of the method, scope delimited by periods. + public var fullName: String { "\(service.fullName).\(name)" } + /// Index of this service within the file's services. + public let index: Int + + /// The .proto file in which this service was defined + public var file: FileDescriptor! { service.file } + /// The service tha defines this method. + public var service: ServiceDescriptor! { _service! } + + /// The resolved features for this Method. + public let features: Google_Protobuf_FeatureSet + + /// Get `Google_Protobuf_MethodOptions` for this method. + public let options: Google_Protobuf_MethodOptions + + /// The type of protocol message which this method accepts as input. + public private(set) var inputType: Descriptor! + /// The type of protocol message which this message produces as output. + public private(set) var outputType: Descriptor! + + /// Whether the client streams multiple requests. + public let clientStreaming: Bool + // Whether the server streams multiple responses. + public let serverStreaming: Bool + + /// The proto version of the descriptor that defines this method. + @available( + *, + deprecated, + message: "Use the properties directly or open a GitHub issue for something missing" + ) + public var proto: Google_Protobuf_MethodDescriptorProto { _proto } + private let _proto: Google_Protobuf_MethodDescriptorProto + + // Storage for `service`, will be set by bind() + private unowned var _service: ServiceDescriptor? + + fileprivate init( + proto: Google_Protobuf_MethodDescriptorProto, + index: Int, + features: Google_Protobuf_FeatureSet, + registry: Registry + ) { + self.name = proto.name + self.index = index + self.features = features + self.options = proto.options + self.clientStreaming = proto.clientStreaming + self.serverStreaming = proto.serverStreaming + // Can look these up because all the Descriptors are already registered + self.inputType = registry.descriptor(named: proto.inputType)! + self.outputType = registry.descriptor(named: proto.outputType)! + + self._proto = proto + } + fileprivate func bind(service: ServiceDescriptor, registry: Registry) { + self._service = service + } } /// Helper used under the hood to build the mapping tables and look things up. -fileprivate final class Registry { - private var fileMap = [String:FileDescriptor]() - private var messageMap = [String:Descriptor]() - private var enumMap = [String:EnumDescriptor]() - private var serviceMap = [String:ServiceDescriptor]() - - init() {} - - func register(file: FileDescriptor) { - fileMap[file.name] = file - } - func register(message: Descriptor) { - messageMap[message.fullName] = message - } - func register(enum e: EnumDescriptor) { - enumMap[e.fullName] = e - } - func register(service: ServiceDescriptor) { - serviceMap[service.fullName] = service - } - - // These are forced unwraps as the FileDescriptorSet should always be valid from protoc. - func fileDescriptor(name: String) -> FileDescriptor { - return fileMap[name]! - } - func descriptor(name: String) -> Descriptor { - return messageMap[name]! - } - func enumDescriptor(name: String) -> EnumDescriptor { - return enumMap[name]! - } - func serviceDescriptor(name: String) -> ServiceDescriptor { - return serviceMap[name]! - } +/// +/// All fullNames are like defined in descriptor.proto, they start with a +/// leading '.'. This simplifies the string ops when assembling the message +/// graph. +private final class Registry { + private var fileMap = [String: FileDescriptor]() + // These three are all keyed by the full_name prefixed with a '.'. + private var messageMap = [String: Descriptor]() + private var enumMap = [String: EnumDescriptor]() + private var serviceMap = [String: ServiceDescriptor]() + + init() {} + + func register(file: FileDescriptor) { + fileMap[file.name] = file + } + func register(message: Descriptor) { + messageMap[".\(message.fullName)"] = message + } + func register(enum e: EnumDescriptor) { + enumMap[".\(e.fullName)"] = e + } + func register(service: ServiceDescriptor) { + serviceMap[".\(service.fullName)"] = service + } + + func fileDescriptor(named name: String) -> FileDescriptor? { + fileMap[name] + } + func descriptor(named fullName: String) -> Descriptor? { + messageMap[fullName] + } + func enumDescriptor(named fullName: String) -> EnumDescriptor? { + enumMap[fullName] + } + func serviceDescriptor(named fullName: String) -> ServiceDescriptor? { + serviceMap[fullName] + } +} + +/// Helper for making an enum associated value `unowned`. +private struct UnownedBox { + unowned let value: T } diff --git a/Sources/SwiftProtobufPluginLibrary/Docs.docc/index.md b/Sources/SwiftProtobufPluginLibrary/Docs.docc/index.md new file mode 100644 index 000000000..11de1028a --- /dev/null +++ b/Sources/SwiftProtobufPluginLibrary/Docs.docc/index.md @@ -0,0 +1,12 @@ +# ``SwiftProtobufPluginLibrary`` + +A reusable framework for building `protoc` plugins in Swift. + +## Overview + +The `protoc-gen-swift` program is run by `protoc` to generate Swift code +from the parsed proto data. +This library encapsulates many of the common elements needed to build +such programs. +It's separated out here so that other people can reuse it. + diff --git a/Sources/SwiftProtobufPluginLibrary/FeatureResolver.swift b/Sources/SwiftProtobufPluginLibrary/FeatureResolver.swift new file mode 100644 index 000000000..3d209d18a --- /dev/null +++ b/Sources/SwiftProtobufPluginLibrary/FeatureResolver.swift @@ -0,0 +1,188 @@ +// Sources/SwiftProtobufPluginLibrary/FeatureResolve.swift - Feature helpers +// +// Copyright (c) 2014 - 2024 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +import SwiftProtobuf + +protocol ProvidesFeatureSets { + var features: Google_Protobuf_FeatureSet { get } + var hasFeatures: Bool { get } +} + +// Skip `Google_Protobuf_FileOptions`, special case of `resolve`. +extension Google_Protobuf_MessageOptions: ProvidesFeatureSets {} +extension Google_Protobuf_EnumOptions: ProvidesFeatureSets {} +// Skip `Google_Protobuf_FieldOptions`, Field is special case of `resolve`. +extension Google_Protobuf_OneofOptions: ProvidesFeatureSets {} +extension Google_Protobuf_ExtensionRangeOptions: ProvidesFeatureSets {} +extension Google_Protobuf_EnumValueOptions: ProvidesFeatureSets {} +extension Google_Protobuf_ServiceOptions: ProvidesFeatureSets {} +extension Google_Protobuf_MethodOptions: ProvidesFeatureSets {} + +/// Encapsulates the process of Feature resolution, sorta like the upstream +/// `feature_resolver.cpp`. +package class FeatureResolver { + + package enum Error: Swift.Error, Equatable, CustomStringConvertible { + case unsupported( + edition: Google_Protobuf_Edition, + supported: ClosedRange + ) + case noDefault(edition: Google_Protobuf_Edition) + case invalidExtension(type: String) + + package var description: String { + switch self { + case .unsupported(let edition, let supported): + return "Edition \(edition) is not in the supported range (\(supported))" + case .noDefault(let edition): + return "No default value found for edition \(edition)" + case .invalidExtension(let type): + return "Passed an extension that wasn't to google.protobuf.FeatureSet: \(type)" + } + } + } + + /// The requested Edition. + package let edition: Google_Protobuf_Edition + /// The detaults to use for this edition. + package let defaultFeatureSet: Google_Protobuf_FeatureSet + + private let extensionMap: (any ExtensionMap)? + + /// Construct a resolver for a given edition with the correct defaults. + /// + /// - Parameters: + /// - edition: The edition of defaults desired. + /// - defaults: A `Google_Protobuf_FeatureSetDefaults` created by protoc + /// from one or more proto files that define `Google_Protobuf_FeatureSet` + /// and any extensions. + /// - extensions: A list of Protobuf Extension extensions to + /// `google.protobuf.FeatureSet` that define custom features. If used, the + /// `defaults` should have been parsed with the extensions being + /// supported. + /// - Returns: A configured resolver for the given edition/defaults. + /// - Throws: `FeatureResolver.Error` if there edition requested can't be + /// supported by the given defaults. + package init( + edition: Google_Protobuf_Edition, + featureSetDefaults defaults: Google_Protobuf_FeatureSetDefaults, + featureExtensions extensions: [any AnyMessageExtension] = [] + ) throws { + guard edition >= defaults.minimumEdition && (edition <= defaults.maximumEdition || edition == .unstable) else { + throw Error.unsupported( + edition: edition, + supported: defaults.minimumEdition...defaults.maximumEdition + ) + } + + // When protoc generates defaults, they are ordered, so find the last one. + var found: Google_Protobuf_FeatureSetDefaults.FeatureSetEditionDefault? + for d in defaults.defaults { + guard d.edition <= edition else { break } + found = d + } + + guard let found = found else { + throw Error.noDefault(edition: edition) + } + self.edition = edition + + if extensions.isEmpty { + extensionMap = nil + } else { + for e in extensions { + if e.messageType != Google_Protobuf_FeatureSet.self { + throw Error.invalidExtension(type: e.messageType.protoMessageName) + } + } + var simpleMap = SimpleExtensionMap() + simpleMap.insert(contentsOf: extensions) + extensionMap = simpleMap + } + + var features = found.fixedFeatures + // Don't yet have a message level merge, so bounce through serialization. + let bytes: [UInt8] = try! found.overridableFeatures.serializedBytes() + try! features.merge(serializedBytes: bytes, extensions: extensionMap) + defaultFeatureSet = features + } + + /// Resolve the Features for a File. + func resolve(_ options: Google_Protobuf_FileOptions) -> Google_Protobuf_FeatureSet { + /// There is no parent, so the default options are used. + resolve( + features: options.hasFeatures ? options.features : nil, + resolvedParent: defaultFeatureSet + ) + } + + /// Resolve the Features for a Field. + /// + /// This needs to the full FieldDescriptorProto incase it has to do fallback + /// inference. + package func resolve( + _ proto: Google_Protobuf_FieldDescriptorProto, + resolvedParent: Google_Protobuf_FeatureSet + ) -> Google_Protobuf_FeatureSet { + if edition >= .edition2023 { + return resolve( + features: proto.options.hasFeatures ? proto.options.features : nil, + resolvedParent: resolvedParent + ) + } + // For `.proto2` and `.proto3`, some of the field behaviors have to be + // figured out as they can't be captured in the defaults and inherrited. + // See `InferLegacyProtoFeatures` in the C++ descriptor.cc implementation + // for this logic. + var features = Google_Protobuf_FeatureSet() + if proto.label == .required { + features.fieldPresence = .legacyRequired + } + if proto.type == .group { + features.messageEncoding = .delimited + } + let options = proto.options + if options.packed { + features.repeatedFieldEncoding = .packed + } + if edition == .proto3 && options.hasPacked && !options.packed { + features.repeatedFieldEncoding = .expanded + } + // Now now merge the rest of the inherrited info from the defaults. + return resolve(features: features, resolvedParent: defaultFeatureSet) + } + + /// Resolve the Features for a given descriptor's options, the resolvedParent + /// values used to inherrit from. + func resolve( + _ options: T, + resolvedParent: Google_Protobuf_FeatureSet + ) -> Google_Protobuf_FeatureSet { + resolve( + features: options.hasFeatures ? options.features : nil, + resolvedParent: resolvedParent + ) + } + + /// Helper to do the merging. + package func resolve( + features: Google_Protobuf_FeatureSet?, + resolvedParent: Google_Protobuf_FeatureSet + ) -> Google_Protobuf_FeatureSet { + var result = resolvedParent + if let features = features { + // Don't yet have a message level merge, so bounce through serialization. + let bytes: [UInt8] = try! features.serializedBytes() + try! result.merge(serializedBytes: bytes, extensions: extensionMap) + } + return result + } + +} diff --git a/Sources/SwiftProtobufPluginLibrary/FieldNumbers.swift b/Sources/SwiftProtobufPluginLibrary/FieldNumbers.swift index f82ea3c9d..731f888ca 100644 --- a/Sources/SwiftProtobufPluginLibrary/FieldNumbers.swift +++ b/Sources/SwiftProtobufPluginLibrary/FieldNumbers.swift @@ -16,32 +16,33 @@ import Foundation import SwiftProtobuf extension Google_Protobuf_FileDescriptorProto { - struct FieldNumbers { - static let messageType: Int = 4 - static let enumType: Int = 5 - static let service: Int = 6 - static let `extension`: Int = 7 - } + struct FieldNumbers { + static let messageType: Int = 4 + static let enumType: Int = 5 + static let service: Int = 6 + static let `extension`: Int = 7 + } } extension Google_Protobuf_DescriptorProto { - struct FieldNumbers { - static let field: Int = 2 - static let nestedType: Int = 3 - static let enumType: Int = 4 - static let `extension`: Int = 6 - static let oneofDecl: Int = 8 - } + struct FieldNumbers { + static let field: Int = 2 + static let nestedType: Int = 3 + static let enumType: Int = 4 + static let extensionRange: Int = 4 + static let `extension`: Int = 6 + static let oneofDecl: Int = 8 + } } extension Google_Protobuf_EnumDescriptorProto { - struct FieldNumbers { - static let value: Int = 2 - } + struct FieldNumbers { + static let value: Int = 2 + } } extension Google_Protobuf_ServiceDescriptorProto { - struct FieldNumbers { - static let method: Int = 2 - } + struct FieldNumbers { + static let method: Int = 2 + } } diff --git a/Sources/SwiftProtobufPluginLibrary/GeneratorOutputs.swift b/Sources/SwiftProtobufPluginLibrary/GeneratorOutputs.swift new file mode 100644 index 000000000..cce1b04eb --- /dev/null +++ b/Sources/SwiftProtobufPluginLibrary/GeneratorOutputs.swift @@ -0,0 +1,32 @@ +// Sources/SwiftProtobufPluginLibrary/GeneratorOutputs.swift +// +// Copyright (c) 2014 - 2023 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// This provides the basic interface for providing the generation outputs. +/// +// ----------------------------------------------------------------------------- + +import Foundation + +/// Abstract interface for receiving generation outputs. +public protocol GeneratorOutputs { + /// Add the a file with the given `name` and `contents` to the outputs. + /// + /// - Parameters: + /// - fileName: The name of the file. + /// - contents: The body of the file. + /// + /// - Throws May throw errors for duplicate file names or any other problem. + /// Generally `CodeGenerator`s do *not* need to catch these, and instead + /// they are ripple all the way out to the code calling the + /// `CodeGenerator`. + func add(fileName: String, contents: String) throws + + // TODO: Consider adding apis to stream things like C++ protobuf does? +} diff --git a/Sources/SwiftProtobufPluginLibrary/Google_Protobuf_Compiler_CodeGeneratorResponse+Extensions.swift b/Sources/SwiftProtobufPluginLibrary/Google_Protobuf_Compiler_CodeGeneratorResponse+Extensions.swift index 363524aee..fb6309cb9 100644 --- a/Sources/SwiftProtobufPluginLibrary/Google_Protobuf_Compiler_CodeGeneratorResponse+Extensions.swift +++ b/Sources/SwiftProtobufPluginLibrary/Google_Protobuf_Compiler_CodeGeneratorResponse+Extensions.swift @@ -13,33 +13,36 @@ // ----------------------------------------------------------------------------- extension Google_Protobuf_Compiler_CodeGeneratorResponse { - /// Helper to make a response with an error. - public init(error: String) { - self.init() - self.error = error - } + /// Helper to make a response with an error. + @available(*, deprecated, message: "Please move your plugin to the CodeGenerator interface") + public init(error: String) { + self.init() + self.error = error + } - /// Helper to make a response with a set of files - public init(files: [Google_Protobuf_Compiler_CodeGeneratorResponse.File]) { - self.init(files: files, supportedFeatures: []) - } + /// Helper to make a response with a set of files + @available(*, deprecated, message: "Please move your plugin to the CodeGenerator interface") + public init(files: [Google_Protobuf_Compiler_CodeGeneratorResponse.File]) { + self.init(files: files, supportedFeatures: []) + } - /// Helper to make a response with a set of files and supported features. - public init( - files: [Google_Protobuf_Compiler_CodeGeneratorResponse.File], - supportedFeatures: [Google_Protobuf_Compiler_CodeGeneratorResponse.Feature] = [] - ) { - self.init() - self.file = files - self.supportedFeatures = supportedFeatures.reduce(0) { $0 | UInt64($1.rawValue) } - } + /// Helper to make a response with a set of files and supported features. + @available(*, deprecated, message: "Please move your plugin to the CodeGenerator interface") + public init( + files: [Google_Protobuf_Compiler_CodeGeneratorResponse.File], + supportedFeatures: [Google_Protobuf_Compiler_CodeGeneratorResponse.Feature] = [] + ) { + self.init() + self.file = files + self.supportedFeatures = supportedFeatures.reduce(0) { $0 | UInt64($1.rawValue) } + } } extension Google_Protobuf_Compiler_CodeGeneratorResponse.File { - /// Helper to make a Response.File with specific content. - public init(name: String, content: String) { - self.init() - self.name = name - self.content = content - } + /// Helper to make a Response.File with specific content. + public init(name: String, content: String) { + self.init() + self.name = name + self.content = content + } } diff --git a/Sources/SwiftProtobufPluginLibrary/Google_Protobuf_Edition+Extensions.swift b/Sources/SwiftProtobufPluginLibrary/Google_Protobuf_Edition+Extensions.swift new file mode 100644 index 000000000..ec4e5194b --- /dev/null +++ b/Sources/SwiftProtobufPluginLibrary/Google_Protobuf_Edition+Extensions.swift @@ -0,0 +1,24 @@ +// Sources/SwiftProtobufPluginLibrary/Google_Protobuf_Edition+Extensions.swift - Google_Protobuf_Edition extensions +// +// Copyright (c) 2014 - 2024 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// Extensions to `Google_Protobuf_Edition` provide some simple helpers. +/// +// ----------------------------------------------------------------------------- + +import Foundation +import SwiftProtobuf + +/// The spec for editions calls out them being ordered and comparable. +/// https://github.com/protocolbuffers/protobuf/blob/main/docs/design/editions/edition-naming.md +extension Google_Protobuf_Edition: Comparable { + public static func < (lhs: Google_Protobuf_Edition, rhs: Google_Protobuf_Edition) -> Bool { + lhs.rawValue < rhs.rawValue + } +} diff --git a/Sources/SwiftProtobufPluginLibrary/Google_Protobuf_SourceCodeInfo+Extensions.swift b/Sources/SwiftProtobufPluginLibrary/Google_Protobuf_SourceCodeInfo+Extensions.swift index d8560ab2d..f4c06c6f7 100644 --- a/Sources/SwiftProtobufPluginLibrary/Google_Protobuf_SourceCodeInfo+Extensions.swift +++ b/Sources/SwiftProtobufPluginLibrary/Google_Protobuf_SourceCodeInfo+Extensions.swift @@ -13,58 +13,60 @@ import SwiftProtobuf extension Google_Protobuf_SourceCodeInfo.Location { - /// Builds a source comment out of the location's comment fields. - /// - /// If leadingDetachedPrefix is not provided, those comments won't - /// be collected. - public func asSourceComment(commentPrefix: String, - leadingDetachedPrefix: String? = nil) -> String { - func escapeMarkup(_ text: String) -> String { - // Proto file comments don't really have any markup associated with - // them. Swift uses something like MarkDown: - // "Markup Formatting Reference" - // https://developer.apple.com/library/content/documentation/Xcode/Reference/xcode_markup_formatting_ref/index.html - // Sadly that format doesn't really lend itself to any form of - // escaping to ensure comments are interpreted markup when they - // really aren't. About the only thing that could be done is to - // try and escape some set of things that could start directives, - // and that gets pretty chatty/ugly pretty quickly. - return text - } + /// Builds a source comment out of the location's comment fields. + /// + /// If leadingDetachedPrefix is not provided, those comments won't + /// be collected. + public func asSourceComment( + commentPrefix: String, + leadingDetachedPrefix: String? = nil + ) -> String { + func escapeMarkup(_ text: String) -> String { + // Proto file comments don't really have any markup associated with + // them. Swift uses something like MarkDown: + // "Markup Formatting Reference" + // https://developer.apple.com/library/content/documentation/Xcode/Reference/xcode_markup_formatting_ref/index.html + // Sadly that format doesn't really lend itself to any form of + // escaping to ensure comments are interpreted markup when they + // really aren't. About the only thing that could be done is to + // try and escape some set of things that could start directives, + // and that gets pretty chatty/ugly pretty quickly. + text + } - func prefixLines(text: String, prefix: String) -> String { - var result = String() - // Protoc doesn't normalize newlines in the comments, make sure CRLF - // doesn't insert blank lines and the generated file is hopefully then - // consistent in using '\n'. - var lines = - text.replacingOccurrences(of: "\r\n", with: "\n").components(separatedBy: .newlines) - // Trim any blank lines off the end. - while !lines.isEmpty && lines.last!.trimmingCharacters(in: .whitespaces).isEmpty { - lines.removeLast() - } - for line in lines { - result.append(prefix + line + "\n") - } - return result - } + func prefixLines(text: String, prefix: String) -> String { + var result = String() + // Protoc doesn't normalize newlines in the comments, make sure CRLF + // doesn't insert blank lines and the generated file is hopefully then + // consistent in using '\n'. + var lines = + text.replacingOccurrences(of: "\r\n", with: "\n").components(separatedBy: .newlines) + // Trim any blank lines off the end. + while !lines.isEmpty && lines.last!.trimmingCharacters(in: .whitespaces).isEmpty { + lines.removeLast() + } + for line in lines { + result.append(prefix + line + "\n") + } + return result + } - var result = String() + var result = String() - if let leadingDetachedPrefix = leadingDetachedPrefix { - for detached in leadingDetachedComments { - let comment = prefixLines(text: detached, prefix: leadingDetachedPrefix) - if !comment.isEmpty { - result += comment - // Detached comments have blank lines between then (and - // anything that follows them). - result += "\n" + if let leadingDetachedPrefix = leadingDetachedPrefix { + for detached in leadingDetachedComments { + let comment = prefixLines(text: detached, prefix: leadingDetachedPrefix) + if !comment.isEmpty { + result += comment + // Detached comments have blank lines between then (and + // anything that follows them). + result += "\n" + } + } } - } - } - let comments = hasLeadingComments ? leadingComments : trailingComments - result += prefixLines(text: escapeMarkup(comments), prefix: commentPrefix) - return result - } + let comments = hasLeadingComments ? leadingComments : trailingComments + result += prefixLines(text: escapeMarkup(comments), prefix: commentPrefix) + return result + } } diff --git a/Sources/SwiftProtobufPluginLibrary/NamingUtils.swift b/Sources/SwiftProtobufPluginLibrary/NamingUtils.swift index 54b5fba69..5c9d0706e 100644 --- a/Sources/SwiftProtobufPluginLibrary/NamingUtils.swift +++ b/Sources/SwiftProtobufPluginLibrary/NamingUtils.swift @@ -23,141 +23,151 @@ import SwiftProtobuf /// /// We won't generate types (structs, enums) with these names: /// -fileprivate let reservedTypeNames: Set = { - () -> Set in - var names: Set = [] - - // Main SwiftProtobuf namespace - // Shadowing this leads to Bad Things. - names.insert("SwiftProtobuf") - - // Subtype of many messages, used to scope nested extensions - names.insert("Extensions") - - // Subtypes are static references, so can conflict with static - // class properties: - names.insert("protoMessageName") - - // Methods on Message that we need to avoid shadowing. Testing - // shows we do not need to avoid `serializedData` or `isEqualTo`, - // but it's not obvious to me what's different about them. Maybe - // because these two are generic? Because they throw? - names.insert("decodeMessage") - names.insert("traverse") - - // Basic Message properties we don't want to shadow: - names.insert("isInitialized") - names.insert("unknownFields") - - // Standard Swift property names we don't want - // to conflict with: - names.insert("debugDescription") - names.insert("description") - names.insert("dynamicType") - names.insert("hashValue") - - // We don't need to protect all of these keywords, just the ones - // that interfere with type expressions: - // names = names.union(swiftKeywordsReservedInParticularContexts) - names.insert("Type") - names.insert("Protocol") - - names = names.union(swiftKeywordsUsedInDeclarations) - names = names.union(swiftKeywordsUsedInStatements) - names = names.union(swiftKeywordsUsedInExpressionsAndTypes) - names = names.union(swiftCommonTypes) - names = names.union(swiftSpecialVariables) - return names +private let reservedTypeNames: Set = { + () -> Set in + var names: Set = [] + + // Main SwiftProtobuf namespace + // Shadowing this leads to Bad Things. + names.insert("SwiftProtobuf") + + // Subtype of many messages, used to scope nested extensions + names.insert("Extensions") + + // Subtypes are static references, so can conflict with static + // class properties: + names.insert("protoMessageName") + + // Methods on Message that we need to avoid shadowing. Testing + // shows we do not need to avoid `serializedData` or `isEqualTo`, + // but it's not obvious to me what's different about them. Maybe + // because these two are generic? Because they throw? + names.insert("decodeMessage") + names.insert("traverse") + + // Basic Message properties we don't want to shadow: + names.insert("isInitialized") + names.insert("unknownFields") + + // Standard Swift property names we don't want + // to conflict with: + names.insert("debugDescription") + names.insert("description") + names.insert("dynamicType") + names.insert("hashValue") + + // We don't need to protect all of these keywords, just the ones + // that interfere with type expressions: + // names = names.union(swiftKeywordsReservedInParticularContexts) + names.insert("Type") + names.insert("Protocol") + + // Getting something called "Swift" would be bad as it blocks access + // to built in things. + names.insert("Swift") + + // And getting things on some of the common protocols could create + // some odd confusion. + names.insert("Equatable") + names.insert("Hashable") + names.insert("Sendable") + + names = names.union(swiftKeywordsUsedInDeclarations) + names = names.union(swiftKeywordsUsedInStatements) + names = names.union(swiftKeywordsUsedInExpressionsAndTypes) + names = names.union(swiftCommonTypes) + names = names.union(swiftSpecialVariables) + return names }() /// /// Many Swift reserved words can be used as fields names if we put backticks /// around them: /// -fileprivate let quotableFieldNames: Set = { - () -> Set in - var names: Set = [] - - names = names.union(swiftKeywordsUsedInDeclarations) - names = names.union(swiftKeywordsUsedInStatements) - names = names.union(swiftKeywordsUsedInExpressionsAndTypes) - return names +private let quotableFieldNames: Set = { + () -> Set in + var names: Set = [] + + names = names.union(swiftKeywordsUsedInDeclarations) + names = names.union(swiftKeywordsUsedInStatements) + names = names.union(swiftKeywordsUsedInExpressionsAndTypes) + return names }() -fileprivate let reservedFieldNames: Set = { - () -> Set in - var names: Set = [] - - // Properties are instance names, so can't shadow static class - // properties such as `protoMessageName`. - - // Properties can't shadow methods. For example, we don't need to - // avoid `isEqualTo` as a field name. - - // Basic Message properties that we don't want to shadow - names.insert("isInitialized") - names.insert("unknownFields") - - // Standard Swift property names we don't want - // to conflict with: - names.insert("debugDescription") - names.insert("description") - names.insert("dynamicType") - names.insert("hashValue") - names.insert("init") - names.insert("self") - - // We don't need to protect all of these keywords, just the ones - // that interfere with type expressions: - // names = names.union(swiftKeywordsReservedInParticularContexts) - names.insert("Type") - names.insert("Protocol") - - names = names.union(swiftCommonTypes) - names = names.union(swiftSpecialVariables) - return names +private let reservedFieldNames: Set = { + () -> Set in + var names: Set = [] + + // Properties are instance names, so can't shadow static class + // properties such as `protoMessageName`. + + // Properties can't shadow methods. For example, we don't need to + // avoid `isEqualTo` as a field name. + + // Basic Message properties that we don't want to shadow + names.insert("isInitialized") + names.insert("unknownFields") + + // Standard Swift property names we don't want + // to conflict with: + names.insert("debugDescription") + names.insert("description") + names.insert("dynamicType") + names.insert("hashValue") + names.insert("init") + names.insert("self") + + // We don't need to protect all of these keywords, just the ones + // that interfere with type expressions: + // names = names.union(swiftKeywordsReservedInParticularContexts) + names.insert("Type") + names.insert("Protocol") + + names = names.union(swiftCommonTypes) + names = names.union(swiftSpecialVariables) + return names }() /// /// Many Swift reserved words can be used as enum cases if we put quotes /// around them: /// -fileprivate let quotableEnumCases: Set = { - () -> Set in - var names: Set = [] - - // We don't need to protect all of these keywords, just the ones - // that interfere with enum cases: - // names = names.union(swiftKeywordsReservedInParticularContexts) - names.insert("associativity") - names.insert("dynamicType") - names.insert("optional") - names.insert("required") - - names = names.union(swiftKeywordsUsedInDeclarations) - names = names.union(swiftKeywordsUsedInStatements) - names = names.union(swiftKeywordsUsedInExpressionsAndTypes) - // Common type and variable names don't cause problems as enum - // cases, because enum case names only appear in special contexts: - // names = names.union(swiftCommonTypes) - // names = names.union(swiftSpecialVariables) - return names +private let quotableEnumCases: Set = { + () -> Set in + var names: Set = [] + + // We don't need to protect all of these keywords, just the ones + // that interfere with enum cases: + // names = names.union(swiftKeywordsReservedInParticularContexts) + names.insert("associativity") + names.insert("dynamicType") + names.insert("optional") + names.insert("required") + + names = names.union(swiftKeywordsUsedInDeclarations) + names = names.union(swiftKeywordsUsedInStatements) + names = names.union(swiftKeywordsUsedInExpressionsAndTypes) + // Common type and variable names don't cause problems as enum + // cases, because enum case names only appear in special contexts: + // names = names.union(swiftCommonTypes) + // names = names.union(swiftSpecialVariables) + return names }() /// /// Some words cannot be used for enum cases, even if they are quoted with /// backticks: /// -fileprivate let reservedEnumCases: Set = [ - // Don't conflict with standard Swift property names: - "allCases", - "debugDescription", - "description", - "dynamicType", - "hashValue", - "init", - "rawValue", - "self", +private let reservedEnumCases: Set = [ + // Don't conflict with standard Swift property names: + "allCases", + "debugDescription", + "description", + "dynamicType", + "hashValue", + "init", + "rawValue", + "self", ] /// @@ -165,429 +175,438 @@ fileprivate let reservedEnumCases: Set = [ /// Extensions { ... }`, so we resuse the same sets for backticks and reserved /// words. /// -fileprivate let quotableMessageScopedExtensionNames: Set = quotableEnumCases -fileprivate let reservedMessageScopedExtensionNames: Set = reservedEnumCases - - -fileprivate func isAllUnderscore(_ s: String) -> Bool { - if s.isEmpty { - return false - } - for c in s.unicodeScalars { - if c != "_" {return false} - } - return true +private let quotableMessageScopedExtensionNames: Set = quotableEnumCases +private let reservedMessageScopedExtensionNames: Set = reservedEnumCases + +private func isAllUnderscore(_ s: String) -> Bool { + if s.isEmpty { + return false + } + for c in s.unicodeScalars { + if c != "_" { return false } + } + return true } -fileprivate func sanitizeTypeName(_ s: String, disambiguator: String, forbiddenTypeNames: Set) -> String { - // NOTE: This code relies on the protoc validation of _identifier_ is defined - // (in Tokenizer::Next() as `[a-zA-Z_][a-zA-Z0-9_]*`, so this does not need - // any complex validation or handing of characters outside those ranges. Since - // those rules prevent a leading digit; nothing needs to be done, and any - // explicitly use Message or Enum name will be valid. The one exception is - // this code is also used for determining the OneOf enums, but that code is - // responsible for dealing with the issues in the transforms it makes. - if reservedTypeNames.contains(s) { - return s + disambiguator - } else if isAllUnderscore(s) { - return s + disambiguator - } else if s.hasSuffix(disambiguator) { - // If `foo` and `fooMessage` both exist, and `foo` gets - // expanded to `fooMessage`, then we also should expand - // `fooMessage` to `fooMessageMessage` to avoid creating a new - // conflict. This can be resolved recursively by stripping - // the disambiguator, sanitizing the root, then re-adding the - // disambiguator: - let e = s.index(s.endIndex, offsetBy: -disambiguator.count) - let truncated = String(s[..) -> String { + // NOTE: This code relies on the protoc validation of _identifier_ is defined + // (in Tokenizer::Next() as `[a-zA-Z_][a-zA-Z0-9_]*`, so this does not need + // any complex validation or handing of characters outside those ranges. Since + // those rules prevent a leading digit; nothing needs to be done, and any + // explicitly use Message or Enum name will be valid. The one exception is + // this code is also used for determining the OneOf enums, but that code is + // responsible for dealing with the issues in the transforms it makes. + if reservedTypeNames.contains(s) { + return s + disambiguator + } else if isAllUnderscore(s) { + return s + disambiguator + } else if s.hasSuffix(disambiguator) { + // If `foo` and `fooMessage` both exist, and `foo` gets + // expanded to `fooMessage`, then we also should expand + // `fooMessage` to `fooMessageMessage` to avoid creating a new + // conflict. This can be resolved recursively by stripping + // the disambiguator, sanitizing the root, then re-adding the + // disambiguator: + let e = s.index(s.endIndex, offsetBy: -disambiguator.count) + let truncated = String(s[.. Bool { - let scalars = s.unicodeScalars - let start = scalars.index(scalars.startIndex, offsetBy: index) - if start == scalars.endIndex { - // it ended, so just say the next character wasn't uppercase. - return false - } - return scalars[start].isASCUppercase +private func isCharacterUppercase(_ s: String, index: Int) -> Bool { + let scalars = s.unicodeScalars + let start = scalars.index(scalars.startIndex, offsetBy: index) + if start == scalars.endIndex { + // it ended, so just say the next character wasn't uppercase. + return false + } + return scalars[start].isASCUppercase } -fileprivate func makeUnicodeScalarView( - from unicodeScalar: UnicodeScalar +private func makeUnicodeScalarView( + from unicodeScalar: UnicodeScalar ) -> String.UnicodeScalarView { - var view = String.UnicodeScalarView() - view.append(unicodeScalar) - return view + var view = String.UnicodeScalarView() + view.append(unicodeScalar) + return view } -fileprivate enum CamelCaser { - // Abbreviation that should be all uppercase when camelcasing. Used in - // camelCased(:initialUpperCase:). - static let appreviations: Set = ["url", "http", "https", "id"] - - // The diffent "classes" a character can belong in for segmenting. - enum CharClass { - case digit - case lower - case upper - case underscore - case other - - init(_ from: UnicodeScalar) { - switch from { - case "0"..."9": - self = .digit - case "a"..."z": - self = .lower - case "A"..."Z": - self = .upper - case "_": - self = .underscore - default: - self = .other - } - } - } - - /// Transforms the input into a camelcase name that is a valid Swift - /// identifier. The input is assumed to be a protocol buffer identifier (or - /// something like that), meaning that it is a "snake_case_name" and the - /// underscores and be used to split into segements and then capitalize as - /// needed. The splits happen based on underscores and/or changes in case - /// and/or use of digits. If underscores are repeated, then the "extras" - /// (past the first) are carried over into the output. - /// - /// NOTE: protoc validation of an _identifier_ is defined (in Tokenizer::Next() - /// as `[a-zA-Z_][a-zA-Z0-9_]*`, Since leading underscores are removed, it does - /// have to handle if things would have started with a digit. If that happens, - /// then an underscore is added before it (which matches what the proto file - /// would have had to have a valid identifier also). - static func transform(_ s: String, initialUpperCase: Bool) -> String { - var result = String() - var current = String.UnicodeScalarView() // Collects in lowercase. - var lastClass = CharClass("\0") - - func addCurrent() { - guard !current.isEmpty else { - return - } - var currentAsString = String(current) - if result.isEmpty && !initialUpperCase { - // Nothing, want it to stay lowercase. - } else if appreviations.contains(currentAsString) { - currentAsString = currentAsString.uppercased() - } else { - currentAsString = NamingUtils.uppercaseFirstCharacter(currentAsString) - } - result += String(currentAsString) - current = String.UnicodeScalarView() +private enum CamelCaser { + // Abbreviation that should be all uppercase when camelcasing. Used in + // camelCased(:initialUpperCase:). + static let appreviations: Set = ["url", "http", "https", "id"] + + // The diffent "classes" a character can belong in for segmenting. + enum CharClass { + case digit + case lower + case upper + case underscore + case other + + init(_ from: UnicodeScalar) { + switch from { + case "0"..."9": + self = .digit + case "a"..."z": + self = .lower + case "A"..."Z": + self = .upper + case "_": + self = .underscore + default: + self = .other + } + } } - for scalar in s.unicodeScalars { - let scalarClass = CharClass(scalar) - switch scalarClass { - case .digit: - if lastClass != .digit { - addCurrent() - } - if result.isEmpty { - // Don't want to start with a number for the very first thing. - result += "_" + /// Transforms the input into a camelcase name that is a valid Swift + /// identifier. The input is assumed to be a protocol buffer identifier (or + /// something like that), meaning that it is a "snake_case_name" and the + /// underscores and be used to split into segements and then capitalize as + /// needed. The splits happen based on underscores and/or changes in case + /// and/or use of digits. If underscores are repeated, then the "extras" + /// (past the first) are carried over into the output. + /// + /// NOTE: protoc validation of an _identifier_ is defined (in Tokenizer::Next() + /// as `[a-zA-Z_][a-zA-Z0-9_]*`, Since leading underscores are removed, it does + /// have to handle if things would have started with a digit. If that happens, + /// then an underscore is added before it (which matches what the proto file + /// would have had to have a valid identifier also). + static func transform(_ s: String, initialUpperCase: Bool) -> String { + var result = String() + var current = String.UnicodeScalarView() // Collects in lowercase. + var lastClass = CharClass("\0") + + func addCurrent() { + guard !current.isEmpty else { + return + } + var currentAsString = String(current) + if result.isEmpty && !initialUpperCase { + // Nothing, want it to stay lowercase. + } else if appreviations.contains(currentAsString) { + currentAsString = currentAsString.uppercased() + } else { + currentAsString = NamingUtils.uppercaseFirstCharacter(currentAsString) + } + result += String(currentAsString) + current = String.UnicodeScalarView() } - current.append(scalar) - case .upper: - if lastClass != .upper { - addCurrent() - } - current.append(scalar.ascLowercased()) - case .lower: - if lastClass != .lower && lastClass != .upper { - addCurrent() + + for scalar in s.unicodeScalars { + let scalarClass = CharClass(scalar) + switch scalarClass { + case .digit: + if lastClass != .digit { + addCurrent() + } + if result.isEmpty { + // Don't want to start with a number for the very first thing. + result += "_" + } + current.append(scalar) + case .upper: + if lastClass != .upper { + addCurrent() + } + current.append(scalar.ascLowercased()) + case .lower: + if lastClass != .lower && lastClass != .upper { + addCurrent() + } + current.append(scalar) + case .underscore: + addCurrent() + if lastClass == .underscore { + result += "_" + } + case .other: + addCurrent() + let escapeIt = + result.isEmpty + ? !isSwiftIdentifierHeadCharacter(scalar) + : !isSwiftIdentifierCharacter(scalar) + if escapeIt { + result.append("_u\(scalar.value)") + } else { + current.append(scalar) + } + } + + lastClass = scalarClass } - current.append(scalar) - case .underscore: + + // Add the last segment collected. addCurrent() + + // If things end in an underscore, add one also. if lastClass == .underscore { - result += "_" - } - case .other: - addCurrent() - let escapeIt = - result.isEmpty - ? !isSwiftIdentifierHeadCharacter(scalar) - : !isSwiftIdentifierCharacter(scalar) - if escapeIt { - result.append("_u\(scalar.value)") - } else { - current.append(scalar) + result += "_" } - } - lastClass = scalarClass + return result } +} + +// Scope for the utilies to they are less likely to conflict when imported into +// generators. +public enum NamingUtils { - // Add the last segment collected. - addCurrent() + // Returns the type prefix to use for a given + package static func typePrefix(protoPackage: String, fileOptions: Google_Protobuf_FileOptions) -> String { + // Explicit option (including blank), wins. + if fileOptions.hasSwiftPrefix { + return fileOptions.swiftPrefix + } - // If things end in an underscore, add one also. - if lastClass == .underscore { - result += "_" + if protoPackage.isEmpty { + return String() + } + + // NOTE: This code relies on the protoc validation of proto packages. Look + // at Parser::ParsePackage() to see the logic, it comes down to reading + // _identifiers_ joined by '.'. And _identifier_ is defined (in + // Tokenizer::Next() as `[a-zA-Z_][a-zA-Z0-9_]*`, so this does not need + // any complex validation or handing of characters outside those ranges. + // It just has to deal with ended up with a leading digit after the pruning + // of '_'s. + + // Transforms: + // "package.name" -> "Package_Name" + // "package_name" -> "PackageName" + // "pacakge.some_name" -> "Package_SomeName" + var prefix = String.UnicodeScalarView() + var makeUpper = true + for c in protoPackage.unicodeScalars { + if c == "_" { + makeUpper = true + } else if c == "." { + makeUpper = true + prefix.append("_") + } else { + if prefix.isEmpty && c.isASCDigit { + // If the first character is going to be a digit, add an underscore + // to ensure it is a valid Swift identifier. + prefix.append("_") + } + if makeUpper { + prefix.append(c.ascUppercased()) + makeUpper = false + } else { + prefix.append(c) + } + } + } + // End in an underscore to split off anything that gets added to it. + return String(prefix) + "_" } - return result - } -} + /// Helper a proto prefix from strings. A proto prefix means underscores + /// and letter case are ignored. + /// + /// NOTE: Since this is acting on proto enum names and enum cases, we know + /// the values must be _identifier_s which is defined (in Tokenizer::Next() as + /// `[a-zA-Z_][a-zA-Z0-9_]*`, so this code is based on that limited input. + package struct PrefixStripper { + private let prefixChars: String.UnicodeScalarView + + package init(prefix: String) { + self.prefixChars = prefix.lowercased().replacingOccurrences(of: "_", with: "").unicodeScalars + } -fileprivate let backtickCharacterSet = CharacterSet(charactersIn: "`") + /// Strip the prefix and return the result, or return nil if it can't + /// be stripped. + package func strip(from: String) -> String? { + var prefixIndex = prefixChars.startIndex + let prefixEnd = prefixChars.endIndex + + let fromChars = from.lowercased().unicodeScalars + var fromIndex = fromChars.startIndex + let fromEnd = fromChars.endIndex + + while prefixIndex != prefixEnd { + if fromIndex == fromEnd { + // Reached the end of the string while still having prefix to go + // nothing to strip. + return nil + } + + if fromChars[fromIndex] == "_" { + fromIndex = fromChars.index(after: fromIndex) + continue + } + + if prefixChars[prefixIndex] != fromChars[fromIndex] { + // They differed before the end of the prefix, can't drop. + return nil + } + + prefixIndex = prefixChars.index(after: prefixIndex) + fromIndex = fromChars.index(after: fromIndex) + } + + // Remove any more underscores. + while fromIndex != fromEnd && fromChars[fromIndex] == "_" { + fromIndex = fromChars.index(after: fromIndex) + } + + if fromIndex == fromEnd { + // They matched, can't strip. + return nil + } + + guard fromChars[fromIndex].isASCLowercase else { + // Next character isn't a lowercase letter (it must be a digit + // (fromChars was lowercased)), that would mean to make an enum value it + // would have to get prefixed with an underscore which most folks + // wouldn't consider to be a better Swift naming, so don't strip the + // prefix. + return nil + } + + let count = fromChars.distance(from: fromChars.startIndex, to: fromIndex) + let idx = from.index(from.startIndex, offsetBy: count) + return String(from[idx..) -> String { + sanitizeTypeName(s, disambiguator: "Message", forbiddenTypeNames: forbiddenTypeNames) + } - // Returns the type prefix to use for a given - static func typePrefix(protoPackage: String, fileOptions: Google_Protobuf_FileOptions) -> String { - // Explicit option (including blank), wins. - if fileOptions.hasSwiftPrefix { - return fileOptions.swiftPrefix + package static func sanitize(enumName s: String, forbiddenTypeNames: Set) -> String { + sanitizeTypeName(s, disambiguator: "Enum", forbiddenTypeNames: forbiddenTypeNames) } - if protoPackage.isEmpty { - return String() + package static func sanitize(oneofName s: String, forbiddenTypeNames: Set) -> String { + sanitizeTypeName(s, disambiguator: "Oneof", forbiddenTypeNames: forbiddenTypeNames) } - // NOTE: This code relies on the protoc validation of proto packages. Look - // at Parser::ParsePackage() to see the logic, it comes down to reading - // _identifiers_ joined by '.'. And _identifier_ is defined (in - // Tokenizer::Next() as `[a-zA-Z_][a-zA-Z0-9_]*`, so this does not need - // any complex validation or handing of characters outside those ranges. - // It just has to deal with ended up with a leading digit after the pruning - // of '_'s. - - // Transforms: - // "package.name" -> "Package_Name" - // "package_name" -> "PackageName" - // "pacakge.some_name" -> "Package_SomeName" - var prefix = String.UnicodeScalarView() - var makeUpper = true - for c in protoPackage.unicodeScalars { - if c == "_" { - makeUpper = true - } else if c == "." { - makeUpper = true - prefix.append("_") - } else { - if prefix.isEmpty && c.isASCDigit { - // If the first character is going to be a digit, add an underscore - // to ensure it is a valid Swift identifier. - prefix.append("_") - } - if makeUpper { - prefix.append(c.ascUppercased()) - makeUpper = false + package static func sanitize(fieldName s: String, basedOn: String) -> String { + if basedOn.hasPrefix("clear") && isCharacterUppercase(basedOn, index: 5) { + return s + "_p" + } else if basedOn.hasPrefix("has") && isCharacterUppercase(basedOn, index: 3) { + return s + "_p" + } else if reservedFieldNames.contains(basedOn) { + return s + "_p" + } else if basedOn == s && quotableFieldNames.contains(basedOn) { + // backticks are only used on the base names, if we're sanitizing based on something else + // this is skipped (the "hasFoo" doesn't get backticks just because the "foo" does). + return "`\(s)`" + } else if isAllUnderscore(basedOn) { + return s + "__" } else { - prefix.append(c) + return s } - } } - // End in an underscore to split off anything that gets added to it. - return String(prefix) + "_" - } - - /// Helper a proto prefix from strings. A proto prefix means underscores - /// and letter case are ignored. - /// - /// NOTE: Since this is acting on proto enum names and enum cases, we know - /// the values must be _identifier_s which is defined (in Tokenizer::Next() as - /// `[a-zA-Z_][a-zA-Z0-9_]*`, so this code is based on that limited input. - struct PrefixStripper { - private let prefixChars: String.UnicodeScalarView - - init(prefix: String) { - self.prefixChars = prefix.lowercased().replacingOccurrences(of: "_", with: "").unicodeScalars + + package static func sanitize(fieldName s: String) -> String { + sanitize(fieldName: s, basedOn: s) } - /// Strip the prefix and return the result, or return nil if it can't - /// be stripped. - func strip(from: String) -> String? { - var prefixIndex = prefixChars.startIndex - let prefixEnd = prefixChars.endIndex - - let fromChars = from.lowercased().unicodeScalars - var fromIndex = fromChars.startIndex - let fromEnd = fromChars.endIndex - - while (prefixIndex != prefixEnd) { - if (fromIndex == fromEnd) { - // Reached the end of the string while still having prefix to go - // nothing to strip. - return nil + package static func sanitize(enumCaseName s: String) -> String { + if reservedEnumCases.contains(s) { + return "\(s)_" + } else if quotableEnumCases.contains(s) { + return "`\(s)`" + } else if isAllUnderscore(s) { + return s + "__" + } else { + return s } + } - if fromChars[fromIndex] == "_" { - fromIndex = fromChars.index(after: fromIndex) - continue + package static func sanitize(messageScopedExtensionName s: String) -> String { + if reservedMessageScopedExtensionNames.contains(s) { + return "\(s)_" + } else if quotableMessageScopedExtensionNames.contains(s) { + return "`\(s)`" + } else if isAllUnderscore(s) { + return s + "__" + } else { + return s } + } - if prefixChars[prefixIndex] != fromChars[fromIndex] { - // They differed before the end of the prefix, can't drop. - return nil + /// Forces the first character to be uppercase (if possible) and leaves + /// the rest of the characters in their existing case. + /// + /// Use toUpperCamelCase() to get leading "HTTP", "URL", etc. correct. + package static func uppercaseFirstCharacter(_ s: String) -> String { + let out = s.unicodeScalars + if let first = out.first { + var result = makeUnicodeScalarView(from: first.ascUppercased()) + result.append( + contentsOf: out[out.index(after: out.startIndex)..) -> String { - return sanitizeTypeName(s, disambiguator: "Message", forbiddenTypeNames: forbiddenTypeNames) - } - - static func sanitize(enumName s: String, forbiddenTypeNames: Set) -> String { - return sanitizeTypeName(s, disambiguator: "Enum", forbiddenTypeNames: forbiddenTypeNames) - } - - static func sanitize(oneofName s: String, forbiddenTypeNames: Set) -> String { - return sanitizeTypeName(s, disambiguator: "Oneof", forbiddenTypeNames: forbiddenTypeNames) - } - - static func sanitize(fieldName s: String, basedOn: String) -> String { - if basedOn.hasPrefix("clear") && isCharacterUppercase(basedOn, index: 5) { - return s + "_p" - } else if basedOn.hasPrefix("has") && isCharacterUppercase(basedOn, index: 3) { - return s + "_p" - } else if reservedFieldNames.contains(basedOn) { - return s + "_p" - } else if basedOn == s && quotableFieldNames.contains(basedOn) { - // backticks are only used on the base names, if we're sanitizing based on something else - // this is skipped (the "hasFoo" doesn't get backticks just because the "foo" does). - return "`\(s)`" - } else if isAllUnderscore(basedOn) { - return s + "__" - } else { - return s } - } - static func sanitize(fieldName s: String) -> String { - return sanitize(fieldName: s, basedOn: s) - } + /// Accepts any inputs and tranforms form it into a leading + /// UpperCaseCamelCased Swift identifier. It follows the same conventions as + /// that are used for mapping field names into the Message property names. + public static func toUpperCamelCase(_ s: String) -> String { + CamelCaser.transform(s, initialUpperCase: true) + } - static func sanitize(enumCaseName s: String) -> String { - if reservedEnumCases.contains(s) { - return "\(s)_" - } else if quotableEnumCases.contains(s) { - return "`\(s)`" - } else if isAllUnderscore(s) { - return s + "__" - } else { - return s + /// Accepts any inputs and tranforms form it into a leading + /// lowerCaseCamelCased Swift identifier. It follows the same conventions as + /// that are used for mapping field names into the Message property names. + public static func toLowerCamelCase(_ s: String) -> String { + CamelCaser.transform(s, initialUpperCase: false) } - } - static func sanitize(messageScopedExtensionName s: String) -> String { - if reservedMessageScopedExtensionNames.contains(s) { - return "\(s)_" - } else if quotableMessageScopedExtensionNames.contains(s) { - return "`\(s)`" - } else if isAllUnderscore(s) { - return s + "__" - } else { - return s + package static func trimBackticks(_ s: String) -> String { + // This only has to deal with the backticks added when computing relative names, so + // they are always matched and a single set. + let backtick = "`" + guard s.hasPrefix(backtick) else { + assert(!s.hasSuffix(backtick)) + return s + } + assert(s.hasSuffix(backtick)) + let result = s.dropFirst().dropLast() + assert(!result.hasPrefix(backtick) && !result.hasSuffix(backtick)) + return String(result) } - } - - /// Forces the first character to be uppercase (if possible) and leaves - /// the rest of the characters in their existing case. - /// - /// Use toUpperCamelCase() to get leading "HTTP", "URL", etc. correct. - static func uppercaseFirstCharacter(_ s: String) -> String { - let out = s.unicodeScalars - if let first = out.first { - var result = makeUnicodeScalarView(from: first.ascUppercased()) - result.append( - contentsOf: out[out.index(after: out.startIndex).. String { + s.replacingOccurrences(of: ".", with: "_") } - } - - /// Accepts any inputs and tranforms form it into a leading - /// UpperCaseCamelCased Swift identifier. It follows the same conventions as - /// that are used for mapping field names into the Message property names. - public static func toUpperCamelCase(_ s: String) -> String { - return CamelCaser.transform(s, initialUpperCase: true) - } - - /// Accepts any inputs and tranforms form it into a leading - /// lowerCaseCamelCased Swift identifier. It follows the same conventions as - /// that are used for mapping field names into the Message property names. - public static func toLowerCamelCase(_ s: String) -> String { - return CamelCaser.transform(s, initialUpperCase: false) - } - - static func trimBackticks(_ s: String) -> String { - return s.trimmingCharacters(in: backtickCharacterSet) - } - - static func periodsToUnderscores(_ s: String) -> String { - return s.replacingOccurrences(of: ".", with: "_") - } - - /// This must be exactly the same as the corresponding code in the - /// SwiftProtobuf library. Changing it will break compatibility of - /// the generated code with old library version. - public static func toJsonFieldName(_ s: String) -> String { - var result = String.UnicodeScalarView() - var capitalizeNext = false - for c in s.unicodeScalars { - if c == "_" { - capitalizeNext = true - } else if capitalizeNext { - result.append(c.ascUppercased()) - capitalizeNext = false - } else { - result.append(c) - } + /// This must be exactly the same as the corresponding code in the + /// SwiftProtobuf library. Changing it will break compatibility of + /// the generated code with old library version. + public static func toJsonFieldName(_ s: String) -> String { + var result = String.UnicodeScalarView() + var capitalizeNext = false + + for c in s.unicodeScalars { + if c == "_" { + capitalizeNext = true + } else if capitalizeNext { + result.append(c.ascUppercased()) + capitalizeNext = false + } else { + result.append(c) + } + } + return String(result) } - return String(result) - } } diff --git a/Sources/SwiftProtobufPluginLibrary/PluginLibEditionDefaults.swift b/Sources/SwiftProtobufPluginLibrary/PluginLibEditionDefaults.swift new file mode 100644 index 000000000..77e04753c --- /dev/null +++ b/Sources/SwiftProtobufPluginLibrary/PluginLibEditionDefaults.swift @@ -0,0 +1,14 @@ +// See Makefile how this is generated. +// swift-format-ignore-file +import Foundation +let bundledFeatureSetDefaultBytes: [UInt8] = [ + 0x0a, 0x17, 0x18, 0x84, 0x07, 0x22, 0x00, 0x2a, 0x10, 0x08, 0x01, 0x10, + 0x02, 0x18, 0x02, 0x20, 0x03, 0x28, 0x01, 0x30, 0x02, 0x38, 0x02, 0x40, + 0x01, 0x0a, 0x17, 0x18, 0xe7, 0x07, 0x22, 0x00, 0x2a, 0x10, 0x08, 0x02, + 0x10, 0x01, 0x18, 0x01, 0x20, 0x02, 0x28, 0x01, 0x30, 0x01, 0x38, 0x02, + 0x40, 0x01, 0x0a, 0x17, 0x18, 0xe8, 0x07, 0x22, 0x0c, 0x08, 0x01, 0x10, + 0x01, 0x18, 0x01, 0x20, 0x02, 0x28, 0x01, 0x30, 0x01, 0x2a, 0x04, 0x38, + 0x02, 0x40, 0x01, 0x0a, 0x17, 0x18, 0xe9, 0x07, 0x22, 0x10, 0x08, 0x01, + 0x10, 0x01, 0x18, 0x01, 0x20, 0x02, 0x28, 0x01, 0x30, 0x01, 0x38, 0x01, + 0x40, 0x02, 0x2a, 0x00, 0x20, 0xe6, 0x07, 0x28, 0xe9, 0x07 +] diff --git a/Sources/SwiftProtobufPluginLibrary/PrivacyInfo.xcprivacy b/Sources/SwiftProtobufPluginLibrary/PrivacyInfo.xcprivacy new file mode 100644 index 000000000..e54075072 --- /dev/null +++ b/Sources/SwiftProtobufPluginLibrary/PrivacyInfo.xcprivacy @@ -0,0 +1,14 @@ + + + + + NSPrivacyTracking + + NSPrivacyAccessedAPITypes + + NSPrivacyCollectedDataTypes + + NSPrivacyTrackingDomains + + + diff --git a/Sources/SwiftProtobufPluginLibrary/ProtoCompilerContext.swift b/Sources/SwiftProtobufPluginLibrary/ProtoCompilerContext.swift new file mode 100644 index 000000000..9c03ab366 --- /dev/null +++ b/Sources/SwiftProtobufPluginLibrary/ProtoCompilerContext.swift @@ -0,0 +1,24 @@ +// Sources/SwiftProtobufPluginLibrary/ProtoCompilerContext.swift +// +// Copyright (c) 2014 - 2023 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// This provides some basic interface about the protocol buffer compiler +/// being used to generate. +/// +// ----------------------------------------------------------------------------- + +import Foundation + +/// Abstact interface to get information about the protocol buffer compiler +/// being used for generation. +public protocol ProtoCompilerContext { + /// The version of the protocol buffer compiler (if it was provided in the + /// generation request). + var version: Google_Protobuf_Compiler_Version? { get } +} diff --git a/Sources/SwiftProtobufPluginLibrary/ProtoFileToModuleMappings.swift b/Sources/SwiftProtobufPluginLibrary/ProtoFileToModuleMappings.swift index 4ef92c3b5..441fd5e55 100644 --- a/Sources/SwiftProtobufPluginLibrary/ProtoFileToModuleMappings.swift +++ b/Sources/SwiftProtobufPluginLibrary/ProtoFileToModuleMappings.swift @@ -19,147 +19,173 @@ private let defaultSwiftProtobufModuleName = "SwiftProtobuf" /// Handles the mapping of proto files to the modules they will be compiled into. public struct ProtoFileToModuleMappings { - /// Errors raised from parsing mappings - public enum LoadError: Error { - /// Raised if the path wasn't found. - case failToOpen(path: String) - /// Raised if an mapping entry in the protobuf doesn't have a module name. - /// mappingIndex is the index (0-N) of the mapping. - case entryMissingModuleName(mappingIndex: Int) - /// Raised if an mapping entry in the protobuf doesn't have any proto files listed. - /// mappingIndex is the index (0-N) of the mapping. - case entryHasNoProtoPaths(mappingIndex: Int) - /// The given proto path was listed for both modules. - case duplicateProtoPathMapping(path: String, firstModule: String, secondModule: String) - } - - /// Proto file name to module name. - /// This is really `private` to this type, it is just `internal` so the tests can - /// access it to verify things. - let mappings: [String:String] - - /// The name of the runtime module for SwiftProtobuf (usually "SwiftProtobuf"). - /// We expect to find the WKTs in the module named here. - public let swiftProtobufModuleName: String - - /// Loads and parses the given module mapping from disk. Raises LoadError - /// or TextFormatDecodingError. - public init(path: String) throws { - try self.init(path: path, swiftProtobufModuleName: nil) - } - - /// Loads and parses the given module mapping from disk. Raises LoadError - /// or TextFormatDecodingError. - public init(path: String, swiftProtobufModuleName: String?) throws { - let content: String - do { - content = try String(contentsOfFile: path, encoding: String.Encoding.utf8) - } catch { - throw LoadError.failToOpen(path: path) + /// Errors raised from parsing mappings + public enum LoadError: Error, Equatable { + /// Raised if the path wasn't found. + case failToOpen(path: String) + /// Raised if an mapping entry in the protobuf doesn't have a module name. + /// mappingIndex is the index (0-N) of the mapping. + case entryMissingModuleName(mappingIndex: Int) + /// Raised if an mapping entry in the protobuf doesn't have any proto files listed. + /// mappingIndex is the index (0-N) of the mapping. + case entryHasNoProtoPaths(mappingIndex: Int) + /// The given proto path was listed for both modules. + case duplicateProtoPathMapping(path: String, firstModule: String, secondModule: String) } - let mappingsProto = try SwiftProtobuf_GenSwift_ModuleMappings(textFormatString: content) - try self.init(moduleMappingsProto: mappingsProto, swiftProtobufModuleName: swiftProtobufModuleName) - } - - /// Parses the given module mapping. Raises LoadError. - public init(moduleMappingsProto mappings: SwiftProtobuf_GenSwift_ModuleMappings) throws { - try self.init(moduleMappingsProto: mappings, swiftProtobufModuleName: nil) - } - - /// Parses the given module mapping. Raises LoadError. - public init(moduleMappingsProto mappings: SwiftProtobuf_GenSwift_ModuleMappings, swiftProtobufModuleName: String?) throws { - self.swiftProtobufModuleName = swiftProtobufModuleName ?? defaultSwiftProtobufModuleName - var builder = wktMappings(swiftProtobufModuleName: self.swiftProtobufModuleName) - for (idx, mapping) in mappings.mapping.lazy.enumerated() { - if mapping.moduleName.isEmpty { - throw LoadError.entryMissingModuleName(mappingIndex: idx) - } - if mapping.protoFilePath.isEmpty { - throw LoadError.entryHasNoProtoPaths(mappingIndex: idx) - } - for path in mapping.protoFilePath { - if let existing = builder[path] { - if existing != mapping.moduleName { - throw LoadError.duplicateProtoPathMapping(path: path, - firstModule: existing, - secondModule: mapping.moduleName) - } - // Was a repeat, just allow it. - } else { - builder[path] = mapping.moduleName - } - } - } - self.mappings = builder - } - - public init() { - try! self.init(moduleMappingsProto: SwiftProtobuf_GenSwift_ModuleMappings(), swiftProtobufModuleName: nil) - } - - public init(swiftProtobufModuleName: String?) { - try! self.init(moduleMappingsProto: SwiftProtobuf_GenSwift_ModuleMappings(), swiftProtobufModuleName: swiftProtobufModuleName) - } - - /// Looks up the module a given file is in. - public func moduleName(forFile file: FileDescriptor) -> String? { - return mappings[file.name] - } - - /// Returns the list of modules that need to be imported for a given file based on - /// the dependencies it has. - public func neededModules(forFile file: FileDescriptor) -> [String]? { - if file.dependencies.isEmpty { - return nil + /// Proto file name to module name. + /// This is really `private` to this type, it is just `internal` so the tests can + /// access it to verify things. + package let mappings: [String: String] + + /// A Boolean value that indicates that there were developer provided + /// mappings. + /// + /// Since `mappings` will have the bundled proto files also, this is used + /// to track whether there are any provided mappings. + public let hasMappings: Bool + + /// The name of the runtime module for SwiftProtobuf (usually "SwiftProtobuf"). + /// We expect to find the WKTs in the module named here. + public let swiftProtobufModuleName: String + + /// Loads and parses the given module mapping from disk. Raises LoadError + /// or TextFormatDecodingError. + public init(path: String) throws { + try self.init(path: path, swiftProtobufModuleName: nil) } - var collector = Set() + /// Loads and parses the given module mapping from disk. Raises LoadError + /// or TextFormatDecodingError. + public init(path: String, swiftProtobufModuleName: String?) throws { + let content: String + do { + content = try String(contentsOfFile: path, encoding: String.Encoding.utf8) + } catch { + throw LoadError.failToOpen(path: path) + } + + let mappingsProto = try SwiftProtobuf_GenSwift_ModuleMappings(textFormatString: content) + try self.init(moduleMappingsProto: mappingsProto, swiftProtobufModuleName: swiftProtobufModuleName) + } - for dependency in file.dependencies { - if let depModule = mappings[dependency.name] { - collector.insert(depModule) - } + /// Parses the given module mapping. Raises LoadError. + public init(moduleMappingsProto mappings: SwiftProtobuf_GenSwift_ModuleMappings) throws { + try self.init(moduleMappingsProto: mappings, swiftProtobufModuleName: nil) } - // Protocol Buffers has the concept of "public imports", these are imports - // into a file that expose everything from within the file to the new - // context. From the docs - - // https://developers.google.com/protocol-buffers/docs/proto#importing-definitions - // `import public` dependencies can be transitively relied upon by anyone - // importing the proto containing the import public statement. - // To properly expose the types for use, it means in each file, the public imports - // from the dependencies have to be hoisted and also imported. - var visited = Set() - var toScan = file.dependencies - while let dep = toScan.popLast() { - for pubDep in dep.publicDependencies { - let pubDepName = pubDep.name - if visited.contains(pubDepName) { continue } - visited.insert(pubDepName) - toScan.append(pubDep) - if let pubDepModule = mappings[pubDepName] { - collector.insert(pubDepModule) + /// Parses the given module mapping. Raises LoadError. + public init( + moduleMappingsProto mappings: SwiftProtobuf_GenSwift_ModuleMappings, + swiftProtobufModuleName: String? + ) throws { + self.swiftProtobufModuleName = swiftProtobufModuleName ?? defaultSwiftProtobufModuleName + var builder = wktMappings(swiftProtobufModuleName: self.swiftProtobufModuleName) + let initialCount = builder.count + for (idx, mapping) in mappings.mapping.lazy.enumerated() { + if mapping.moduleName.isEmpty { + throw LoadError.entryMissingModuleName(mappingIndex: idx) + } + if mapping.protoFilePath.isEmpty { + throw LoadError.entryHasNoProtoPaths(mappingIndex: idx) + } + for path in mapping.protoFilePath { + if let existing = builder[path] { + if existing != mapping.moduleName { + throw LoadError.duplicateProtoPathMapping( + path: path, + firstModule: existing, + secondModule: mapping.moduleName + ) + } + // Was a repeat, just allow it. + } else { + builder[path] = mapping.moduleName + } + } } - } + self.mappings = builder + self.hasMappings = initialCount != builder.count } - if let moduleForThisFile = mappings[file.name] { - collector.remove(moduleForThisFile) + public init() { + try! self.init(moduleMappingsProto: SwiftProtobuf_GenSwift_ModuleMappings(), swiftProtobufModuleName: nil) } - // The library itself (happens if the import one of the WKTs). - collector.remove(self.swiftProtobufModuleName) + public init(swiftProtobufModuleName: String?) { + try! self.init( + moduleMappingsProto: SwiftProtobuf_GenSwift_ModuleMappings(), + swiftProtobufModuleName: swiftProtobufModuleName + ) + } - if collector.isEmpty { - return nil + /// Looks up the module a given file is in. + public func moduleName(forFile file: FileDescriptor) -> String? { + mappings[file.name] } - return collector.sorted() - } + /// Returns the list of modules that need to be imported for a given file based on + /// the dependencies it has. + public func neededModules(forFile file: FileDescriptor) -> [String]? { + guard hasMappings else { return nil } + if file.dependencies.isEmpty { + return nil + } + + var collector = Set() + + for dependency in file.dependencies { + if let depModule = mappings[dependency.name] { + collector.insert(depModule) + } + } + + // NOTE: This api is only used by gRPC (or things like it), with + // `import public` now re-exporting things, this likely can go away or just + // be reduced just the above loop, without the need for special casing the + // `import public` cases. It will come down to what should expectations + // be for protobuf messages, enums, and extensions with repsect to something + // that generates on top if it. i.e. - should they re-export things or + // should only the generated proto code do it? + + // Protocol Buffers has the concept of "public imports", these are imports + // into a file that expose everything from within the file to the new + // context. From the docs - + // https://protobuf.dev/programming-guides/proto/#importing + // `import public` dependencies can be transitively relied upon by anyone + // importing the proto containing the import public statement. + // To properly expose the types for use, it means in each file, the public imports + // from the dependencies have to be hoisted and also imported. + var visited = Set() + var toScan = file.dependencies + while let dep = toScan.popLast() { + for pubDep in dep.publicDependencies { + let pubDepName = pubDep.name + if visited.contains(pubDepName) { continue } + visited.insert(pubDepName) + toScan.append(pubDep) + if let pubDepModule = mappings[pubDepName] { + collector.insert(pubDepModule) + } + } + } + + if let moduleForThisFile = mappings[file.name] { + collector.remove(moduleForThisFile) + } + + // The library itself (happens if the import one of the WKTs). + collector.remove(self.swiftProtobufModuleName) + + if collector.isEmpty { + return nil + } + + return collector.sorted() + } } // Used to seed the mappings, the wkt are all part of the main library. -private func wktMappings(swiftProtobufModuleName: String) -> [String:String] { - return SwiftProtobufInfo.bundledProtoFiles.reduce(into: [:]) { $0[$1] = swiftProtobufModuleName } +private func wktMappings(swiftProtobufModuleName: String) -> [String: String] { + SwiftProtobufInfo.bundledProtoFiles.reduce(into: [:]) { $0[$1] = swiftProtobufModuleName } } diff --git a/Sources/SwiftProtobufPluginLibrary/ProvidesDeprecationComment.swift b/Sources/SwiftProtobufPluginLibrary/ProvidesDeprecationComment.swift new file mode 100644 index 000000000..7d0f56984 --- /dev/null +++ b/Sources/SwiftProtobufPluginLibrary/ProvidesDeprecationComment.swift @@ -0,0 +1,76 @@ +// Sources/SwiftProtobufPluginLibrary/ProvidesDeprecationComment.swift +// +// Copyright (c) 2014 - 2017 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +import Foundation + +/// Protocol that all the Descriptors conform to provide deprecation comments +public protocol ProvidesDeprecationComment { + /// Returns the deprecation comment to be used. + func deprecationComment(commentPrefix: String) -> String +} + +/// Protocol that a Descriptor can confirm to when only the Type controls depecation. +public protocol SimpleProvidesDeprecationComment: ProvidesDeprecationComment { + /// Name used in the generated message. + var typeName: String { get } + /// If the type is deprecated. + var isDeprecated: Bool { get } +} + +extension SimpleProvidesDeprecationComment { + /// Default implementation to provide the depectation comment. + public func deprecationComment(commentPrefix: String) -> String { + guard isDeprecated else { return String() } + return "\(commentPrefix) NOTE: This \(typeName) was marked as deprecated in the .proto file\n" + } +} + +/// Protocol that a Descriptor can confirm to when the Type or the File controls depecation. +public protocol TypeOrFileProvidesDeprecationComment: ProvidesDeprecationComment { + /// Name used in the generated message. + var typeName: String { get } + /// If the type is deprecated. + var isDeprecated: Bool { get } + /// Returns the File this conforming object is in. + var file: FileDescriptor! { get } +} + +extension TypeOrFileProvidesDeprecationComment { + /// Default implementation to provide the depectation comment. + public func deprecationComment(commentPrefix: String) -> String { + if isDeprecated { + return "\(commentPrefix) NOTE: This \(typeName) was marked as deprecated in the .proto file.\n" + } + guard file.options.deprecated else { return String() } + return "\(commentPrefix) NOTE: The whole .proto file that defined this \(typeName) was marked as deprecated.\n" + } +} + +extension ProvidesDeprecationComment where Self: ProvidesSourceCodeLocation { + /// Helper to get the protoSourceComments combined with any depectation comment. + public func protoSourceCommentsWithDeprecation( + commentPrefix: String = "///", + leadingDetachedPrefix: String? = nil + ) -> String { + let protoSourceComments = protoSourceComments( + commentPrefix: commentPrefix, + leadingDetachedPrefix: leadingDetachedPrefix + ) + let deprecationComments = deprecationComment(commentPrefix: commentPrefix) + + if deprecationComments.isEmpty { + return protoSourceComments + } + if protoSourceComments.isEmpty { + return deprecationComments + } + return "\(protoSourceComments)\(commentPrefix)\n\(deprecationComments)" + } +} diff --git a/Sources/SwiftProtobufPluginLibrary/ProvidesLocationPath.swift b/Sources/SwiftProtobufPluginLibrary/ProvidesLocationPath.swift index 724102b59..727879c6a 100644 --- a/Sources/SwiftProtobufPluginLibrary/ProvidesLocationPath.swift +++ b/Sources/SwiftProtobufPluginLibrary/ProvidesLocationPath.swift @@ -10,7 +10,13 @@ import Foundation +/// Protocol that all the Descriptors conform to for original .proto file +/// location lookup. public protocol ProvidesLocationPath { - func getLocationPath(path: inout IndexPath) - var file: FileDescriptor! { get } + /// Updates `path` to the source location of the complete extent of + /// the object conforming to this protocol. This is a replacement for + /// `GetSourceLocation()` in the C++ Descriptor apis. + func getLocationPath(path: inout IndexPath) + /// Returns the File this conforming object is in. + var file: FileDescriptor! { get } } diff --git a/Sources/SwiftProtobufPluginLibrary/ProvidesSourceCodeLocation.swift b/Sources/SwiftProtobufPluginLibrary/ProvidesSourceCodeLocation.swift index 9796c6383..b80f21ed9 100644 --- a/Sources/SwiftProtobufPluginLibrary/ProvidesSourceCodeLocation.swift +++ b/Sources/SwiftProtobufPluginLibrary/ProvidesSourceCodeLocation.swift @@ -11,27 +11,32 @@ import Foundation import SwiftProtobuf +/// Protocol that all the Descriptors conform to for original .proto file +/// location lookup. public protocol ProvidesSourceCodeLocation { - var sourceCodeInfoLocation: Google_Protobuf_SourceCodeInfo.Location? { get } + /// Returns the Location of a given object (Descriptor). + var sourceCodeInfoLocation: Google_Protobuf_SourceCodeInfo.Location? { get } } -// Default implementation for things that support ProvidesLocationPath. +/// Default implementation for things that support ProvidesLocationPath. extension ProvidesSourceCodeLocation where Self: ProvidesLocationPath { - public var sourceCodeInfoLocation: Google_Protobuf_SourceCodeInfo.Location? { - var path = IndexPath() - getLocationPath(path: &path) - return file.sourceCodeInfoLocation(path: path) - } + public var sourceCodeInfoLocation: Google_Protobuf_SourceCodeInfo.Location? { + var path = IndexPath() + getLocationPath(path: &path) + return file.sourceCodeInfoLocation(path: path) + } } -// Helper to get source comments out of ProvidesSourceCodeLocation extension ProvidesSourceCodeLocation { - public func protoSourceComments(commentPrefix: String = "///", - leadingDetachedPrefix: String? = nil) -> String { - if let loc = sourceCodeInfoLocation { - return loc.asSourceComment(commentPrefix: commentPrefix, - leadingDetachedPrefix: leadingDetachedPrefix) + /// Helper to get a source comments as a string. + public func protoSourceComments( + commentPrefix: String = "///", + leadingDetachedPrefix: String? = nil + ) -> String { + guard let loc = sourceCodeInfoLocation else { return String() } + return loc.asSourceComment( + commentPrefix: commentPrefix, + leadingDetachedPrefix: leadingDetachedPrefix + ) } - return String() - } } diff --git a/Sources/SwiftProtobufPluginLibrary/StandardErrorOutputStream.swift b/Sources/SwiftProtobufPluginLibrary/StandardErrorOutputStream.swift new file mode 100644 index 000000000..4c137a4f3 --- /dev/null +++ b/Sources/SwiftProtobufPluginLibrary/StandardErrorOutputStream.swift @@ -0,0 +1,20 @@ +// Sources/SwiftProtobufPluginLibrary/StandardErrorOutputStream.swift +// +// Copyright (c) 2014 - 2023 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// + +import Foundation + +class StandardErrorOutputStream: TextOutputStream { + func write(_ string: String) { + if #available(macOS 10.15.4, iOS 13.4, watchOS 6.2, tvOS 13.4, *) { + try! FileHandle.standardError.write(contentsOf: Data(string.utf8)) + } else { + FileHandle.standardError.write(Data(string.utf8)) + } + } +} diff --git a/Sources/SwiftProtobufPluginLibrary/StringUtils.swift b/Sources/SwiftProtobufPluginLibrary/StringUtils.swift new file mode 100644 index 000000000..62479dfee --- /dev/null +++ b/Sources/SwiftProtobufPluginLibrary/StringUtils.swift @@ -0,0 +1,21 @@ +// Sources/SwiftProtobufPluginLibrary/StringUtils.swift - String processing utilities +// +// Copyright (c) 2014 - 2016 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +import Foundation + +@inlinable +func trimWhitespace(_ s: String) -> String { + s.trimmingCharacters(in: .whitespacesAndNewlines) +} + +@inlinable +func trimWhitespace(_ s: String.SubSequence) -> String { + s.trimmingCharacters(in: .whitespacesAndNewlines) +} diff --git a/Sources/SwiftProtobufPluginLibrary/SwiftLanguage.swift b/Sources/SwiftProtobufPluginLibrary/SwiftLanguage.swift index 90aab1609..cfbe7a397 100644 --- a/Sources/SwiftProtobufPluginLibrary/SwiftLanguage.swift +++ b/Sources/SwiftProtobufPluginLibrary/SwiftLanguage.swift @@ -12,7 +12,6 @@ /// // ----------------------------------------------------------------------------- -import Swift import Foundation /// Used to check if a character is a valid identifier head character. @@ -125,24 +124,27 @@ public let swiftKeywordsUsedInDeclarations: Set = [ "associatedtype", "class", "deinit", "enum", "extension", "fileprivate", "func", "import", "init", "inout", "internal", "let", "open", "operator", "private", "protocol", "public", - "static", "struct", "subscript", "typealias", "var" + "static", "struct", "subscript", "typealias", "var", ] -public let swiftKeywordsUsedInStatements: Set = [ "break", "case", +public let swiftKeywordsUsedInStatements: Set = [ + "break", "case", "continue", "default", "defer", "do", "else", "fallthrough", "for", "guard", "if", "in", "repeat", "return", "switch", "where", - "while" + "while", ] -public let swiftKeywordsUsedInExpressionsAndTypes: Set = [ "as", +public let swiftKeywordsUsedInExpressionsAndTypes: Set = [ + "as", "Any", "catch", "false", "is", "nil", "rethrows", "super", "self", - "Self", "throw", "throws", "true", "try" + "Self", "throw", "throws", "true", "try", ] -public let swiftKeywordsWithNumberSign: Set = [ "#available", +public let swiftKeywordsWithNumberSign: Set = [ + "#available", "#colorLiteral", "#column", "#else", "#elseif", "#endif", "#file", "#fileLiteral", "#function", "#if", "#imageLiteral", "#line", - "#selector", "#sourceLocation" + "#selector", "#sourceLocation", ] public let swiftKeywordsReservedInParticularContexts: Set = [ @@ -150,18 +152,20 @@ public let swiftKeywordsReservedInParticularContexts: Set = [ "get", "infix", "indirect", "lazy", "left", "mutating", "none", "nonmutating", "optional", "override", "postfix", "precedence", "prefix", "Protocol", "required", "right", "set", "Type", - "unowned", "weak", "willSet" + "unowned", "weak", "willSet", ] /// These are standard Swift types that are heavily used, although /// they are not technically reserved. Defining fields or structs /// with these names would break our generated code quite badly: -public let swiftCommonTypes: Set = [ "Bool", "Data", "Double", "Float", "Int", +public let swiftCommonTypes: Set = [ + "Bool", "Data", "Double", "Float", "Int", "Int32", "Int64", "String", "UInt", "UInt32", "UInt64", ] /// Special magic variables defined by the compiler that we don't /// really want to interfere with: -public let swiftSpecialVariables: Set = [ "__COLUMN__", +public let swiftSpecialVariables: Set = [ + "__COLUMN__", "__FILE__", "__FUNCTION__", "__LINE__", ] diff --git a/Sources/SwiftProtobufPluginLibrary/SwiftProtobufInfo.swift b/Sources/SwiftProtobufPluginLibrary/SwiftProtobufInfo.swift index ffe8f71f1..1ca846032 100644 --- a/Sources/SwiftProtobufPluginLibrary/SwiftProtobufInfo.swift +++ b/Sources/SwiftProtobufPluginLibrary/SwiftProtobufInfo.swift @@ -15,28 +15,34 @@ import Foundation import SwiftProtobuf -/// Scope for helpers about the library. +/// Helpers about the library. public enum SwiftProtobufInfo { - /// Proto Files that ship with the library. - public static let bundledProtoFiles: Set = [ - "google/protobuf/any.proto", - "google/protobuf/api.proto", - // Even though descriptor.proto is *not* a WKT, it is included in the - // library so developers trying to compile .proto files with message, - // field, or file extensions don't have to generate it. - "google/protobuf/descriptor.proto", - "google/protobuf/duration.proto", - "google/protobuf/empty.proto", - "google/protobuf/field_mask.proto", - "google/protobuf/source_context.proto", - "google/protobuf/struct.proto", - "google/protobuf/timestamp.proto", - "google/protobuf/type.proto", - "google/protobuf/wrappers.proto", - ] + /// Proto Files that ship with the library. + public static let bundledProtoFiles: Set = [ + "google/protobuf/any.proto", + "google/protobuf/api.proto", + // Even though descriptor.proto is *not* a WKT, it is included in the + // library so developers trying to compile .proto files with message, + // field, or file extensions don't have to generate it. + "google/protobuf/descriptor.proto", + "google/protobuf/duration.proto", + "google/protobuf/empty.proto", + "google/protobuf/field_mask.proto", + "google/protobuf/source_context.proto", + "google/protobuf/struct.proto", + "google/protobuf/timestamp.proto", + "google/protobuf/type.proto", + "google/protobuf/wrappers.proto", + ] - // Checks if a FileDescriptor is a library bundled proto file. - public static func isBundledProto(file: Google_Protobuf_FileDescriptorProto) -> Bool { - return file.package == "google.protobuf" && bundledProtoFiles.contains(file.name) - } + /// Checks if a `Google_Protobuf_FileDescriptorProto` is a library bundled proto file. + @available(*, deprecated, message: "Use the version that takes a FileDescriptor instead.") + public static func isBundledProto(file: Google_Protobuf_FileDescriptorProto) -> Bool { + file.package == "google.protobuf" && bundledProtoFiles.contains(file.name) + } + + /// Checks if a `FileDescriptor` is a library bundled proto file. + public static func isBundledProto(file: FileDescriptor) -> Bool { + file.package == "google.protobuf" && bundledProtoFiles.contains(file.name) + } } diff --git a/Sources/SwiftProtobufPluginLibrary/SwiftProtobufNamer.swift b/Sources/SwiftProtobufPluginLibrary/SwiftProtobufNamer.swift index c1198e044..60bc27a60 100644 --- a/Sources/SwiftProtobufPluginLibrary/SwiftProtobufNamer.swift +++ b/Sources/SwiftProtobufPluginLibrary/SwiftProtobufNamer.swift @@ -15,338 +15,356 @@ import Foundation public final class SwiftProtobufNamer { - var filePrefixCache = [String:String]() - var enumValueRelativeNameCache = [String:String]() - var mappings: ProtoFileToModuleMappings - var targetModule: String - - public var swiftProtobufModuleName: String { return mappings.swiftProtobufModuleName } - - /// Initializes a a new namer, assuming everything will be in the same Swift module. - public convenience init() { - self.init(protoFileToModuleMappings: ProtoFileToModuleMappings(), targetModule: "") - } - - /// Initializes a a new namer. All names will be generated as from the pov of the - /// given file using the provided file to module mapper. - public convenience init( - currentFile file: FileDescriptor, - protoFileToModuleMappings mappings: ProtoFileToModuleMappings - ) { - let targetModule = mappings.moduleName(forFile: file) ?? "" - self.init(protoFileToModuleMappings: mappings, targetModule: targetModule) - } - - /// Internal initializer. - init( - protoFileToModuleMappings mappings: ProtoFileToModuleMappings, - targetModule: String - ) { - self.mappings = mappings - self.targetModule = targetModule - } - - /// Calculate the relative name for the given message. - public func relativeName(message: Descriptor) -> String { - if message.containingType != nil { - return NamingUtils.sanitize(messageName: message.name, forbiddenTypeNames: [self.swiftProtobufModuleName]) - } else { - let prefix = typePrefix(forFile: message.file) - return NamingUtils.sanitize(messageName: prefix + message.name, forbiddenTypeNames: [self.swiftProtobufModuleName]) + var filePrefixCache = [String: String]() + var enumValueRelativeNameCache = [String: String]() + public let mappings: ProtoFileToModuleMappings + public let targetModule: String + + public var swiftProtobufModuleName: String { mappings.swiftProtobufModuleName } + + public var swiftProtobufModulePrefix: String { + guard targetModule != mappings.swiftProtobufModuleName else { + return "" + } + return "\(mappings.swiftProtobufModuleName)." } - } - /// Calculate the full name for the given message. - public func fullName(message: Descriptor) -> String { - let relativeName = self.relativeName(message: message) - guard let containingType = message.containingType else { - return modulePrefix(file: message.file) + relativeName + /// Initializes a a new namer, assuming everything will be in the same Swift module. + public convenience init() { + self.init(protoFileToModuleMappings: ProtoFileToModuleMappings(), targetModule: "") } - return fullName(message:containingType) + "." + relativeName - } - - /// Calculate the relative name for the given enum. - public func relativeName(enum e: EnumDescriptor) -> String { - if e.containingType != nil { - return NamingUtils.sanitize(enumName: e.name, forbiddenTypeNames: [self.swiftProtobufModuleName]) - } else { - let prefix = typePrefix(forFile: e.file) - return NamingUtils.sanitize(enumName: prefix + e.name, forbiddenTypeNames: [self.swiftProtobufModuleName]) + + /// Initializes a a new namer. All names will be generated as from the pov of the + /// given file using the provided file to module mapper. + public convenience init( + currentFile file: FileDescriptor, + protoFileToModuleMappings mappings: ProtoFileToModuleMappings + ) { + let targetModule = mappings.moduleName(forFile: file) ?? "" + self.init(protoFileToModuleMappings: mappings, targetModule: targetModule) } - } - /// Calculate the full name for the given enum. - public func fullName(enum e: EnumDescriptor) -> String { - let relativeName = self.relativeName(enum: e) - guard let containingType = e.containingType else { - return modulePrefix(file: e.file) + relativeName + /// Internal initializer. + init( + protoFileToModuleMappings mappings: ProtoFileToModuleMappings, + targetModule: String + ) { + self.mappings = mappings + self.targetModule = targetModule } - return fullName(message: containingType) + "." + relativeName - } - - /// Compute the short names to use for the values of this enum. - private func computeRelativeNames(enum e: EnumDescriptor) { - let stripper = NamingUtils.PrefixStripper(prefix: e.name) - - /// Determine the initial candidate name for the name before - /// doing duplicate checks. - func candidateName(_ enumValue: EnumValueDescriptor) -> String { - let baseName = enumValue.name - if let stripped = stripper.strip(from: baseName) { - return NamingUtils.toLowerCamelCase(stripped) - } - return NamingUtils.toLowerCamelCase(baseName) + + /// Calculate the relative name for the given message. + public func relativeName(message: Descriptor) -> String { + if message.containingType != nil { + return NamingUtils.sanitize(messageName: message.name, forbiddenTypeNames: [self.swiftProtobufModuleName]) + } else { + let prefix = typePrefix(forFile: message.file) + return NamingUtils.sanitize( + messageName: prefix + message.name, + forbiddenTypeNames: [self.swiftProtobufModuleName] + ) + } } - // Bucketed based on candidate names to check for duplicates. - let candidates :[String:[EnumValueDescriptor]] = e.values.reduce(into: [:]) { - $0[candidateName($1), default:[]].append($1) + /// Calculate the full name for the given message. + public func fullName(message: Descriptor) -> String { + let relativeName = self.relativeName(message: message) + guard let containingType = message.containingType else { + return modulePrefix(file: message.file) + relativeName + } + return fullName(message: containingType) + "." + relativeName } - for (camelCased, enumValues) in candidates { - // If there is only one, sanitize and cache it. - guard enumValues.count > 1 else { - enumValueRelativeNameCache[enumValues.first!.fullName] = - NamingUtils.sanitize(enumCaseName: camelCased) - continue - } - - // There are two possible cases: - // 1. There is the main entry and then all aliases for it that - // happen to be the same after the prefix was stripped. - // 2. There are atleast two values (there could also be aliases). - // - // For the first case, there's no need to do anything, we'll go - // with just one Swift version. For the second, append "_#" to - // the names to help make the different Swift versions clear - // which they are. - let firstValue = enumValues.first!.number - let hasMultipleValues = enumValues.contains(where: { return $0.number != firstValue }) - - guard hasMultipleValues else { - // Was the first case, all one value, just aliases that mapped - // to the same name. - let name = NamingUtils.sanitize(enumCaseName: camelCased) - for e in enumValues { - enumValueRelativeNameCache[e.fullName] = name + /// Calculate the relative name for the given enum. + public func relativeName(enum e: EnumDescriptor) -> String { + if e.containingType != nil { + return NamingUtils.sanitize(enumName: e.name, forbiddenTypeNames: [self.swiftProtobufModuleName]) + } else { + let prefix = typePrefix(forFile: e.file) + return NamingUtils.sanitize(enumName: prefix + e.name, forbiddenTypeNames: [self.swiftProtobufModuleName]) } - continue - } - - for e in enumValues { - // Can't put a negative size, so use "n" and make the number - // positive. - let suffix = e.number >= 0 ? "_\(e.number)" : "_n\(-e.number)" - enumValueRelativeNameCache[e.fullName] = - NamingUtils.sanitize(enumCaseName: camelCased + suffix) - } } - } - /// Calculate the relative name for the given enum value. - public func relativeName(enumValue: EnumValueDescriptor) -> String { - if let name = enumValueRelativeNameCache[enumValue.fullName] { - return name + /// Calculate the full name for the given enum. + public func fullName(enum e: EnumDescriptor) -> String { + let relativeName = self.relativeName(enum: e) + guard let containingType = e.containingType else { + return modulePrefix(file: e.file) + relativeName + } + return fullName(message: containingType) + "." + relativeName } - computeRelativeNames(enum: enumValue.enumType) - return enumValueRelativeNameCache[enumValue.fullName]! - } - - /// Calculate the full name for the given enum value. - public func fullName(enumValue: EnumValueDescriptor) -> String { - return fullName(enum: enumValue.enumType) + "." + relativeName(enumValue: enumValue) - } - - /// The relative name with a leading dot so it can be used where - /// the type is known. - public func dottedRelativeName(enumValue: EnumValueDescriptor) -> String { - let relativeName = self.relativeName(enumValue: enumValue) - return "." + NamingUtils.trimBackticks(relativeName) - } - - /// Filters the Enum's values to those that will have unique Swift - /// names. Only poorly named proto enum alias values get filtered - /// away, so the assumption is they aren't really needed from an - /// api pov. - public func uniquelyNamedValues(enum e: EnumDescriptor) -> [EnumValueDescriptor] { - return e.values.filter { - // Original are kept as is. The computations for relative - // name already adds values for collisions with different - // values. - guard let aliasOf = $0.aliasOf else { return true } - let relativeName = self.relativeName(enumValue: $0) - let aliasOfRelativeName = self.relativeName(enumValue: aliasOf) - // If the relative name matches for the alias and original, drop - // the alias. - guard relativeName != aliasOfRelativeName else { return false } - // Only include this alias if it is the first one with this name. - // (handles alias with different cases in their names that get - // mangled to a single Swift name.) - let firstAlias = aliasOf.aliases.firstIndex { - let otherRelativeName = self.relativeName(enumValue: $0) - return relativeName == otherRelativeName - } - return aliasOf.aliases[firstAlias!] === $0 + + /// Compute the short names to use for the values of this enum. + private func computeRelativeNames(enum e: EnumDescriptor) { + let stripper = NamingUtils.PrefixStripper(prefix: e.name) + + /// Determine the initial candidate name for the name before + /// doing duplicate checks. + func candidateName(_ enumValue: EnumValueDescriptor) -> String { + let baseName = enumValue.name + if let stripped = stripper.strip(from: baseName) { + return NamingUtils.toLowerCamelCase(stripped) + } + return NamingUtils.toLowerCamelCase(baseName) + } + + // Bucketed based on candidate names to check for duplicates. + let candidates: [String: [EnumValueDescriptor]] = e.values.reduce(into: [:]) { + $0[candidateName($1), default: []].append($1) + } + + for (camelCased, enumValues) in candidates { + // If there is only one, sanitize and cache it. + guard enumValues.count > 1 else { + let fullName = enumValues.first!.fullName + enumValueRelativeNameCache[fullName] = NamingUtils.sanitize(enumCaseName: camelCased) + continue + } + + // There are two possible cases: + // 1. There is the main entry and then all aliases for it that + // happen to be the same after the prefix was stripped. + // 2. There are atleast two values (there could also be aliases). + // + // For the first case, there's no need to do anything, we'll go + // with just one Swift version. For the second, append "_#" to + // the names to help make the different Swift versions clear + // which they are. + let firstValue = enumValues.first!.number + let hasMultipleValues = enumValues.contains(where: { $0.number != firstValue }) + + guard hasMultipleValues else { + // Was the first case, all one value, just aliases that mapped + // to the same name. + let name = NamingUtils.sanitize(enumCaseName: camelCased) + for e in enumValues { + let fullName = e.fullName + enumValueRelativeNameCache[fullName] = name + } + continue + } + + for e in enumValues { + // Can't put a negative size, so use "n" and make the number + // positive. + let suffix = e.number >= 0 ? "_\(e.number)" : "_n\(-e.number)" + let fullName = e.fullName + enumValueRelativeNameCache[fullName] = NamingUtils.sanitize(enumCaseName: camelCased + suffix) + } + } } - } - - /// Calculate the relative name for the given oneof. - public func relativeName(oneof: OneofDescriptor) -> String { - let camelCase = NamingUtils.toUpperCamelCase(oneof.name) - return NamingUtils.sanitize(oneofName: "OneOf_\(camelCase)", forbiddenTypeNames: [self.swiftProtobufModuleName]) - } - - /// Calculate the full name for the given oneof. - public func fullName(oneof: OneofDescriptor) -> String { - return fullName(message: oneof.containingType) + "." + relativeName(oneof: oneof) - } - - /// Calculate the relative name for the given entension. - /// - /// - Precondition: `extensionField` must be FieldDescriptor for an extension. - public func relativeName(extensionField field: FieldDescriptor) -> String { - precondition(field.isExtension) - - if field.extensionScope != nil { - return NamingUtils.sanitize(messageScopedExtensionName: field.namingBase) - } else { - let swiftPrefix = typePrefix(forFile: field.file) - return swiftPrefix + "Extensions_" + field.namingBase + + /// Calculate the relative name for the given enum value. + public func relativeName(enumValue: EnumValueDescriptor) -> String { + if let name = enumValueRelativeNameCache[enumValue.fullName] { + return name + } + computeRelativeNames(enum: enumValue.enumType) + return enumValueRelativeNameCache[enumValue.fullName]! } - } - /// Calculate the full name for the given extension. - /// - /// - Precondition: `extensionField` must be FieldDescriptor for an extension. - public func fullName(extensionField field: FieldDescriptor) -> String { - precondition(field.isExtension) + /// Calculate the full name for the given enum value. + public func fullName(enumValue: EnumValueDescriptor) -> String { + fullName(enum: enumValue.enumType) + "." + relativeName(enumValue: enumValue) + } - let relativeName = self.relativeName(extensionField: field) - guard let extensionScope = field.extensionScope else { - return modulePrefix(file: field.file) + relativeName + /// The relative name with a leading dot so it can be used where + /// the type is known. + public func dottedRelativeName(enumValue: EnumValueDescriptor) -> String { + let relativeName = self.relativeName(enumValue: enumValue) + return "." + NamingUtils.trimBackticks(relativeName) } - let extensionScopeSwiftFullName = fullName(message: extensionScope) - let relativeNameNoBackticks = NamingUtils.trimBackticks(relativeName) - return extensionScopeSwiftFullName + ".Extensions." + relativeNameNoBackticks - } - - public typealias MessageFieldNames = (name: String, prefixed: String, has: String, clear: String) - - /// Calculate the names to use for the Swift fields on the message. - /// - /// If `prefixed` is not empty, the name prefixed with that will also be included. - /// - /// If `includeHasAndClear` is False, the has:, clear: values in the result will - /// be the empty string. - /// - /// - Precondition: `field` must be FieldDescriptor that's isn't for an extension. - public func messagePropertyNames(field: FieldDescriptor, - prefixed: String, - includeHasAndClear: Bool) -> MessageFieldNames { - precondition(!field.isExtension) - - let lowerName = NamingUtils.toLowerCamelCase(field.namingBase) - let fieldName = NamingUtils.sanitize(fieldName: lowerName) - let prefixedFieldName = - prefixed.isEmpty ? "" : NamingUtils.sanitize(fieldName: "\(prefixed)\(lowerName)", basedOn: lowerName) - - if !includeHasAndClear { - return MessageFieldNames(name: fieldName, prefixed: prefixedFieldName, has: "", clear: "") + + /// Filters the Enum's values to those that will have unique Swift + /// names. Only poorly named proto enum alias values get filtered + /// away, so the assumption is they aren't really needed from an + /// api pov. + @available(*, deprecated, message: "Please open a GitHub issue if you think functionality is missing.") + public func uniquelyNamedValues(enum e: EnumDescriptor) -> [EnumValueDescriptor] { + e.values.filter { + // Original are kept as is. The computations for relative + // name already adds values for collisions with different + // values. + guard let aliasOf = $0.aliasOf else { return true } + let relativeName = self.relativeName(enumValue: $0) + let aliasOfRelativeName = self.relativeName(enumValue: aliasOf) + // If the relative name matches for the alias and original, drop + // the alias. + guard relativeName != aliasOfRelativeName else { return false } + // Only include this alias if it is the first one with this name. + // (handles alias with different cases in their names that get + // mangled to a single Swift name.) + let firstAlias = aliasOf.aliases.firstIndex { + let otherRelativeName = self.relativeName(enumValue: $0) + return relativeName == otherRelativeName + } + return aliasOf.aliases[firstAlias!] === $0 + } } - let upperName = NamingUtils.toUpperCamelCase(field.namingBase) - let hasName = NamingUtils.sanitize(fieldName: "has\(upperName)", basedOn: lowerName) - let clearName = NamingUtils.sanitize(fieldName: "clear\(upperName)", basedOn: lowerName) - - return MessageFieldNames(name: fieldName, prefixed: prefixedFieldName, has: hasName, clear: clearName) - } - - public typealias OneofFieldNames = (name: String, prefixed: String) - - /// Calculate the name to use for the Swift field on the message. - public func messagePropertyName(oneof: OneofDescriptor, prefixed: String = "_") -> OneofFieldNames { - let lowerName = NamingUtils.toLowerCamelCase(oneof.name) - let fieldName = NamingUtils.sanitize(fieldName: lowerName) - let prefixedFieldName = NamingUtils.sanitize(fieldName: "\(prefixed)\(lowerName)", basedOn: lowerName) - return OneofFieldNames(name: fieldName, prefixed: prefixedFieldName) - } - - public typealias MessageExtensionNames = (value: String, has: String, clear: String) - - /// Calculate the names to use for the Swift Extension on the extended - /// message. - /// - /// - Precondition: `extensionField` must be FieldDescriptor for an extension. - public func messagePropertyNames(extensionField field: FieldDescriptor) -> MessageExtensionNames { - precondition(field.isExtension) - - let fieldBaseName = NamingUtils.toLowerCamelCase(field.namingBase) - - let fieldName: String - let hasName: String - let clearName: String - - if let extensionScope = field.extensionScope { - let extensionScopeSwiftFullName = fullName(message: extensionScope) - // Don't worry about any sanitize api on these names; since there is a - // Message name on the front, it should never hit a reserved word. - // - // fieldBaseName is the lowerCase name even though we put more on the - // front, this seems to help make the field name stick out a little - // compared to the message name scoping it on the front. - fieldName = NamingUtils.periodsToUnderscores(extensionScopeSwiftFullName + "_" + fieldBaseName) - let fieldNameFirstUp = NamingUtils.uppercaseFirstCharacter(fieldName) - hasName = "has" + fieldNameFirstUp - clearName = "clear" + fieldNameFirstUp - } else { - // If there was no package and no prefix, fieldBaseName could be a reserved - // word, so sanitize. These's also the slim chance the prefix plus the - // extension name resulted in a reserved word, so the sanitize is always - // needed. - let swiftPrefix = typePrefix(forFile: field.file) - fieldName = NamingUtils.sanitize(fieldName: swiftPrefix + fieldBaseName) - if swiftPrefix.isEmpty { - // No prefix, so got back to UpperCamelCasing the extension name, and then - // sanitize it like we did for the lower form. - let upperCleaned = NamingUtils.sanitize(fieldName: NamingUtils.toUpperCamelCase(field.namingBase), - basedOn: fieldBaseName) - hasName = "has" + upperCleaned - clearName = "clear" + upperCleaned - } else { - // Since there was a prefix, just add has/clear and ensure the first letter - // was capitalized. - let fieldNameFirstUp = NamingUtils.uppercaseFirstCharacter(fieldName) - hasName = "has" + fieldNameFirstUp - clearName = "clear" + fieldNameFirstUp - } + /// Calculate the relative name for the given oneof. + public func relativeName(oneof: OneofDescriptor) -> String { + let camelCase = NamingUtils.toUpperCamelCase(oneof.name) + return NamingUtils.sanitize(oneofName: "OneOf_\(camelCase)", forbiddenTypeNames: [self.swiftProtobufModuleName]) } - return MessageExtensionNames(value: fieldName, has: hasName, clear: clearName) - } + /// Calculate the full name for the given oneof. + public func fullName(oneof: OneofDescriptor) -> String { + fullName(message: oneof.containingType) + "." + relativeName(oneof: oneof) + } - /// Calculate the prefix to use for this file, it is derived from the - /// proto package or swift_prefix file option. - public func typePrefix(forFile file: FileDescriptor) -> String { - if let result = filePrefixCache[file.name] { - return result + /// Calculate the relative name for the given entension. + /// + /// - Precondition: `extensionField` must be FieldDescriptor for an extension. + public func relativeName(extensionField field: FieldDescriptor) -> String { + precondition(field.isExtension) + + if field.extensionScope != nil { + return NamingUtils.sanitize(messageScopedExtensionName: field.namingBase) + } else { + let swiftPrefix = typePrefix(forFile: field.file) + return swiftPrefix + "Extensions_" + field.namingBase + } } - let result = NamingUtils.typePrefix(protoPackage: file.package, - fileOptions: file.fileOptions) - filePrefixCache[file.name] = result - return result - } + /// Calculate the full name for the given extension. + /// + /// - Precondition: `extensionField` must be FieldDescriptor for an extension. + public func fullName(extensionField field: FieldDescriptor) -> String { + precondition(field.isExtension) - /// Internal helper to find the module prefix for a symbol given a file. - func modulePrefix(file: FileDescriptor) -> String { - guard let prefix = mappings.moduleName(forFile: file) else { - return String() + let relativeName = self.relativeName(extensionField: field) + guard let extensionScope = field.extensionScope else { + return modulePrefix(file: field.file) + relativeName + } + let extensionScopeSwiftFullName = fullName(message: extensionScope) + let relativeNameNoBackticks = NamingUtils.trimBackticks(relativeName) + return extensionScopeSwiftFullName + ".Extensions." + relativeNameNoBackticks + } + + public typealias MessageFieldNames = (name: String, prefixed: String, has: String, clear: String) + + /// Calculate the names to use for the Swift fields on the message. + /// + /// If `prefixed` is not empty, the name prefixed with that will also be included. + /// + /// If `includeHasAndClear` is False, the has:, clear: values in the result will + /// be the empty string. + /// + /// - Precondition: `field` must be FieldDescriptor that's isn't for an extension. + public func messagePropertyNames( + field: FieldDescriptor, + prefixed: String, + includeHasAndClear: Bool + ) -> MessageFieldNames { + precondition(!field.isExtension) + + let lowerName = NamingUtils.toLowerCamelCase(field.namingBase) + let fieldName = NamingUtils.sanitize(fieldName: lowerName) + let prefixedFieldName = + prefixed.isEmpty ? "" : NamingUtils.sanitize(fieldName: "\(prefixed)\(lowerName)", basedOn: lowerName) + + if !includeHasAndClear { + return MessageFieldNames(name: fieldName, prefixed: prefixedFieldName, has: "", clear: "") + } + + let upperName = NamingUtils.toUpperCamelCase(field.namingBase) + let hasName = NamingUtils.sanitize(fieldName: "has\(upperName)", basedOn: lowerName) + let clearName = NamingUtils.sanitize(fieldName: "clear\(upperName)", basedOn: lowerName) + + return MessageFieldNames(name: fieldName, prefixed: prefixedFieldName, has: hasName, clear: clearName) + } + + public typealias OneofFieldNames = (name: String, prefixed: String) + + /// Calculate the name to use for the Swift field on the message. + public func messagePropertyName(oneof: OneofDescriptor, prefixed: String = "_") -> OneofFieldNames { + let lowerName = NamingUtils.toLowerCamelCase(oneof.name) + let fieldName = NamingUtils.sanitize(fieldName: lowerName) + let prefixedFieldName = NamingUtils.sanitize(fieldName: "\(prefixed)\(lowerName)", basedOn: lowerName) + return OneofFieldNames(name: fieldName, prefixed: prefixedFieldName) + } + + public typealias MessageExtensionNames = (value: String, has: String, clear: String) + + /// Calculate the names to use for the Swift Extension on the extended + /// message. + /// + /// - Precondition: `extensionField` must be FieldDescriptor for an extension. + public func messagePropertyNames(extensionField field: FieldDescriptor) -> MessageExtensionNames { + precondition(field.isExtension) + + let fieldBaseName = NamingUtils.toLowerCamelCase(field.namingBase) + + let fieldName: String + let hasName: String + let clearName: String + + if let extensionScope = field.extensionScope { + let extensionScopeSwiftFullName = fullName(message: extensionScope) + // Don't worry about any sanitize api on these names; since there is a + // Message name on the front, it should never hit a reserved word. + // + // fieldBaseName is the lowerCase name even though we put more on the + // front, this seems to help make the field name stick out a little + // compared to the message name scoping it on the front. + fieldName = NamingUtils.periodsToUnderscores(extensionScopeSwiftFullName + "_" + fieldBaseName) + let fieldNameFirstUp = NamingUtils.uppercaseFirstCharacter(fieldName) + hasName = "has" + fieldNameFirstUp + clearName = "clear" + fieldNameFirstUp + } else { + // If there was no package and no prefix, fieldBaseName could be a reserved + // word, so sanitize. These's also the slim chance the prefix plus the + // extension name resulted in a reserved word, so the sanitize is always + // needed. + let swiftPrefix = typePrefix(forFile: field.file) + fieldName = NamingUtils.sanitize(fieldName: swiftPrefix + fieldBaseName) + if swiftPrefix.isEmpty { + // No prefix, so got back to UpperCamelCasing the extension name, and then + // sanitize it like we did for the lower form. + let upperCleaned = NamingUtils.sanitize( + fieldName: NamingUtils.toUpperCamelCase(field.namingBase), + basedOn: fieldBaseName + ) + hasName = "has" + upperCleaned + clearName = "clear" + upperCleaned + } else { + // Since there was a prefix, just add has/clear and ensure the first letter + // was capitalized. + let fieldNameFirstUp = NamingUtils.uppercaseFirstCharacter(fieldName) + hasName = "has" + fieldNameFirstUp + clearName = "clear" + fieldNameFirstUp + } + } + + return MessageExtensionNames(value: fieldName, has: hasName, clear: clearName) } - if prefix == targetModule { - return String() + /// Calculate the prefix to use for this file, it is derived from the + /// proto package or swift_prefix file option. + public func typePrefix(forFile file: FileDescriptor) -> String { + if let result = filePrefixCache[file.name] { + return result + } + + let result = NamingUtils.typePrefix( + protoPackage: file.package, + fileOptions: file.options + ) + filePrefixCache[file.name] = result + return result } - return "\(prefix)." - } + /// Internal helper to find the module prefix for a symbol given a file. + func modulePrefix(file: FileDescriptor) -> String { + guard let prefix = mappings.moduleName(forFile: file) else { + return String() + } + + if prefix == targetModule { + return String() + } + + return "\(prefix)." + } } diff --git a/Sources/SwiftProtobufPluginLibrary/UnicodeScalar+Extensions.swift b/Sources/SwiftProtobufPluginLibrary/UnicodeScalar+Extensions.swift index 903fec9ed..49c46b699 100644 --- a/Sources/SwiftProtobufPluginLibrary/UnicodeScalar+Extensions.swift +++ b/Sources/SwiftProtobufPluginLibrary/UnicodeScalar+Extensions.swift @@ -18,41 +18,41 @@ extension UnicodeScalar { - /// True if the receiver is a numeric digit. - var isASCDigit: Bool { - if case "0"..."9" = self { return true } - return false - } + /// True if the receiver is a numeric digit. + var isASCDigit: Bool { + if case "0"..."9" = self { return true } + return false + } - /// True if the receiver is a lowercase character. - var isASCLowercase: Bool { - if case "a"..."z" = self { return true } - return false - } + /// True if the receiver is a lowercase character. + var isASCLowercase: Bool { + if case "a"..."z" = self { return true } + return false + } - /// True if the receiver is an uppercase character. - var isASCUppercase: Bool { - if case "A"..."Z" = self { return true } - return false - } + /// True if the receiver is an uppercase character. + var isASCUppercase: Bool { + if case "A"..."Z" = self { return true } + return false + } - /// Returns the lowercased version of the receiver, or the receiver itself if - /// it is not a cased character. - /// - /// - Precondition: The receiver is 7-bit ASCII. - /// - Returns: The lowercased version of the receiver, or `self`. - func ascLowercased() -> UnicodeScalar { - if isASCUppercase { return UnicodeScalar(value + 0x20)! } - return self - } + /// Returns the lowercased version of the receiver, or the receiver itself if + /// it is not a cased character. + /// + /// - Precondition: The receiver is 7-bit ASCII. + /// - Returns: The lowercased version of the receiver, or `self`. + func ascLowercased() -> UnicodeScalar { + if isASCUppercase { return UnicodeScalar(value + 0x20)! } + return self + } - /// Returns the uppercased version of the receiver, or the receiver itself if - /// it is not a cased character. - /// - /// - Precondition: The receiver is 7-bit ASCII. - /// - Returns: The uppercased version of the receiver, or `self`. - func ascUppercased() -> UnicodeScalar { - if isASCLowercase { return UnicodeScalar(value - 0x20)! } - return self - } + /// Returns the uppercased version of the receiver, or the receiver itself if + /// it is not a cased character. + /// + /// - Precondition: The receiver is 7-bit ASCII. + /// - Returns: The uppercased version of the receiver, or `self`. + func ascUppercased() -> UnicodeScalar { + if isASCLowercase { return UnicodeScalar(value - 0x20)! } + return self + } } diff --git a/Sources/SwiftProtobufPluginLibrary/plugin.pb.swift b/Sources/SwiftProtobufPluginLibrary/plugin.pb.swift index 56b072ffb..545d02d2b 100644 --- a/Sources/SwiftProtobufPluginLibrary/plugin.pb.swift +++ b/Sources/SwiftProtobufPluginLibrary/plugin.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: google/protobuf/compiler/plugin.proto @@ -9,39 +10,13 @@ // Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ // -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file or at +// https://developers.google.com/open-source/licenses/bsd // Author: kenton@google.com (Kenton Varda) // -// WARNING: The plugin interface is currently EXPERIMENTAL and is subject to -// change. -// // protoc (aka the Protocol Compiler) can be extended via plugins. A plugin is // just a program that reads a CodeGeneratorRequest from stdin and writes a // CodeGeneratorResponse to stdout. @@ -53,7 +28,6 @@ // plugin should be named "protoc-gen-$NAME", and will then be used when the // flag "--${NAME}_out" is passed to protoc. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -67,46 +41,46 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP } /// The version number of protocol compiler. -public struct Google_Protobuf_Compiler_Version { +public struct Google_Protobuf_Compiler_Version: Sendable { // 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. public var major: Int32 { - get {return _major ?? 0} + get {_major ?? 0} set {_major = newValue} } /// Returns true if `major` has been explicitly set. - public var hasMajor: Bool {return self._major != nil} + public var hasMajor: Bool {self._major != nil} /// Clears the value of `major`. Subsequent reads from it will return its default value. public mutating func clearMajor() {self._major = nil} public var minor: Int32 { - get {return _minor ?? 0} + get {_minor ?? 0} set {_minor = newValue} } /// Returns true if `minor` has been explicitly set. - public var hasMinor: Bool {return self._minor != nil} + public var hasMinor: Bool {self._minor != nil} /// Clears the value of `minor`. Subsequent reads from it will return its default value. public mutating func clearMinor() {self._minor = nil} public var patch: Int32 { - get {return _patch ?? 0} + get {_patch ?? 0} set {_patch = newValue} } /// Returns true if `patch` has been explicitly set. - public var hasPatch: Bool {return self._patch != nil} + public var hasPatch: Bool {self._patch != nil} /// Clears the value of `patch`. Subsequent reads from it will return its default value. public mutating func clearPatch() {self._patch = nil} /// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should /// be empty for mainline stable releases. public var suffix: String { - get {return _suffix ?? String()} + get {_suffix ?? String()} set {_suffix = newValue} } /// Returns true if `suffix` has been explicitly set. - public var hasSuffix: Bool {return self._suffix != nil} + public var hasSuffix: Bool {self._suffix != nil} /// Clears the value of `suffix`. Subsequent reads from it will return its default value. public mutating func clearSuffix() {self._suffix = nil} @@ -121,7 +95,7 @@ public struct Google_Protobuf_Compiler_Version { } /// An encoded CodeGeneratorRequest is written to the plugin's stdin. -public struct Google_Protobuf_Compiler_CodeGeneratorRequest { +public struct Google_Protobuf_Compiler_CodeGeneratorRequest: Sendable { // 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. @@ -133,11 +107,11 @@ public struct Google_Protobuf_Compiler_CodeGeneratorRequest { /// The generator parameter passed on the command-line. public var parameter: String { - get {return _parameter ?? String()} + get {_parameter ?? String()} set {_parameter = newValue} } /// Returns true if `parameter` has been explicitly set. - public var hasParameter: Bool {return self._parameter != nil} + public var hasParameter: Bool {self._parameter != nil} /// Clears the value of `parameter`. Subsequent reads from it will return its default value. public mutating func clearParameter() {self._parameter = nil} @@ -145,6 +119,11 @@ public struct Google_Protobuf_Compiler_CodeGeneratorRequest { /// they import. The files will appear in topological order, so each file /// appears before any file that imports it. /// + /// Note: the files listed in files_to_generate will include runtime-retention + /// options only, but all other files will include source-retention options. + /// The source_file_descriptors field below is available in case you need + /// source-retention options for files_to_generate. + /// /// protoc guarantees that all proto_files will be written after /// the fields above, even though this is not technically guaranteed by the /// protobuf wire format. This theoretically could allow a plugin to stream @@ -157,13 +136,18 @@ public struct Google_Protobuf_Compiler_CodeGeneratorRequest { /// fully qualified. public var protoFile: [SwiftProtobuf.Google_Protobuf_FileDescriptorProto] = [] + /// File descriptors with all options, including source-retention options. + /// These descriptors are only provided for the files listed in + /// files_to_generate. + public var sourceFileDescriptors: [SwiftProtobuf.Google_Protobuf_FileDescriptorProto] = [] + /// The version number of protocol compiler. public var compilerVersion: Google_Protobuf_Compiler_Version { - get {return _compilerVersion ?? Google_Protobuf_Compiler_Version()} + get {_compilerVersion ?? Google_Protobuf_Compiler_Version()} set {_compilerVersion = newValue} } /// Returns true if `compilerVersion` has been explicitly set. - public var hasCompilerVersion: Bool {return self._compilerVersion != nil} + public var hasCompilerVersion: Bool {self._compilerVersion != nil} /// Clears the value of `compilerVersion`. Subsequent reads from it will return its default value. public mutating func clearCompilerVersion() {self._compilerVersion = nil} @@ -176,7 +160,7 @@ public struct Google_Protobuf_Compiler_CodeGeneratorRequest { } /// The plugin writes an encoded CodeGeneratorResponse to stdout. -public struct Google_Protobuf_Compiler_CodeGeneratorResponse { +public struct Google_Protobuf_Compiler_CodeGeneratorResponse: Sendable { // 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. @@ -190,58 +174,69 @@ public struct Google_Protobuf_Compiler_CodeGeneratorResponse { /// unparseable -- should be reported by writing a message to stderr and /// exiting with a non-zero status code. public var error: String { - get {return _error ?? String()} + get {_error ?? String()} set {_error = newValue} } /// Returns true if `error` has been explicitly set. - public var hasError: Bool {return self._error != nil} + public var hasError: Bool {self._error != nil} /// Clears the value of `error`. Subsequent reads from it will return its default value. public mutating func clearError() {self._error = nil} /// A bitmask of supported features that the code generator supports. /// This is a bitwise "or" of values from the Feature enum. public var supportedFeatures: UInt64 { - get {return _supportedFeatures ?? 0} + get {_supportedFeatures ?? 0} set {_supportedFeatures = newValue} } /// Returns true if `supportedFeatures` has been explicitly set. - public var hasSupportedFeatures: Bool {return self._supportedFeatures != nil} + public var hasSupportedFeatures: Bool {self._supportedFeatures != nil} /// Clears the value of `supportedFeatures`. Subsequent reads from it will return its default value. public mutating func clearSupportedFeatures() {self._supportedFeatures = nil} + /// The minimum edition this plugin supports. This will be treated as an + /// Edition enum, but we want to allow unknown values. It should be specified + /// according the edition enum value, *not* the edition number. Only takes + /// effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + public var minimumEdition: Int32 { + get {_minimumEdition ?? 0} + set {_minimumEdition = newValue} + } + /// Returns true if `minimumEdition` has been explicitly set. + public var hasMinimumEdition: Bool {self._minimumEdition != nil} + /// Clears the value of `minimumEdition`. Subsequent reads from it will return its default value. + public mutating func clearMinimumEdition() {self._minimumEdition = nil} + + /// The maximum edition this plugin supports. This will be treated as an + /// Edition enum, but we want to allow unknown values. It should be specified + /// according the edition enum value, *not* the edition number. Only takes + /// effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. + public var maximumEdition: Int32 { + get {_maximumEdition ?? 0} + set {_maximumEdition = newValue} + } + /// Returns true if `maximumEdition` has been explicitly set. + public var hasMaximumEdition: Bool {self._maximumEdition != nil} + /// Clears the value of `maximumEdition`. Subsequent reads from it will return its default value. + public mutating func clearMaximumEdition() {self._maximumEdition = nil} + public var file: [Google_Protobuf_Compiler_CodeGeneratorResponse.File] = [] public var unknownFields = SwiftProtobuf.UnknownStorage() /// Sync with code_generator.h. - public enum Feature: SwiftProtobuf.Enum { - public typealias RawValue = Int - case none // = 0 - case proto3Optional // = 1 + public enum Feature: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case none = 0 + case proto3Optional = 1 + case supportsEditions = 2 public init() { self = .none } - public init?(rawValue: Int) { - switch rawValue { - case 0: self = .none - case 1: self = .proto3Optional - default: return nil - } - } - - public var rawValue: Int { - switch self { - case .none: return 0 - case .proto3Optional: return 1 - } - } - } /// Represents a single generated file. - public struct File { + public struct File: Sendable { // 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. @@ -258,11 +253,11 @@ public struct Google_Protobuf_Compiler_CodeGeneratorResponse { /// this writing protoc does not optimize for this -- it will read the entire /// CodeGeneratorResponse before writing files to disk. public var name: String { - get {return _name ?? String()} + get {_name ?? String()} set {_name = newValue} } /// Returns true if `name` has been explicitly set. - public var hasName: Bool {return self._name != nil} + public var hasName: Bool {self._name != nil} /// Clears the value of `name`. Subsequent reads from it will return its default value. public mutating func clearName() {self._name = nil} @@ -304,21 +299,21 @@ public struct Google_Protobuf_Compiler_CodeGeneratorResponse { /// /// If |insertion_point| is present, |name| must also be present. public var insertionPoint: String { - get {return _insertionPoint ?? String()} + get {_insertionPoint ?? String()} set {_insertionPoint = newValue} } /// Returns true if `insertionPoint` has been explicitly set. - public var hasInsertionPoint: Bool {return self._insertionPoint != nil} + public var hasInsertionPoint: Bool {self._insertionPoint != nil} /// Clears the value of `insertionPoint`. Subsequent reads from it will return its default value. public mutating func clearInsertionPoint() {self._insertionPoint = nil} /// The file contents. public var content: String { - get {return _content ?? String()} + get {_content ?? String()} set {_content = newValue} } /// Returns true if `content` has been explicitly set. - public var hasContent: Bool {return self._content != nil} + public var hasContent: Bool {self._content != nil} /// Clears the value of `content`. Subsequent reads from it will return its default value. public mutating func clearContent() {self._content = nil} @@ -326,11 +321,11 @@ public struct Google_Protobuf_Compiler_CodeGeneratorResponse { /// point is used, this information will be appropriately offset and inserted /// into the code generation metadata for the generated files. public var generatedCodeInfo: SwiftProtobuf.Google_Protobuf_GeneratedCodeInfo { - get {return _generatedCodeInfo ?? SwiftProtobuf.Google_Protobuf_GeneratedCodeInfo()} + get {_generatedCodeInfo ?? SwiftProtobuf.Google_Protobuf_GeneratedCodeInfo()} set {_generatedCodeInfo = newValue} } /// Returns true if `generatedCodeInfo` has been explicitly set. - public var hasGeneratedCodeInfo: Bool {return self._generatedCodeInfo != nil} + public var hasGeneratedCodeInfo: Bool {self._generatedCodeInfo != nil} /// Clears the value of `generatedCodeInfo`. Subsequent reads from it will return its default value. public mutating func clearGeneratedCodeInfo() {self._generatedCodeInfo = nil} @@ -348,36 +343,17 @@ public struct Google_Protobuf_Compiler_CodeGeneratorResponse { fileprivate var _error: String? = nil fileprivate var _supportedFeatures: UInt64? = nil + fileprivate var _minimumEdition: Int32? = nil + fileprivate var _maximumEdition: Int32? = nil } -#if swift(>=4.2) - -extension Google_Protobuf_Compiler_CodeGeneratorResponse.Feature: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension Google_Protobuf_Compiler_Version: @unchecked Sendable {} -extension Google_Protobuf_Compiler_CodeGeneratorRequest: @unchecked Sendable {} -extension Google_Protobuf_Compiler_CodeGeneratorResponse: @unchecked Sendable {} -extension Google_Protobuf_Compiler_CodeGeneratorResponse.Feature: @unchecked Sendable {} -extension Google_Protobuf_Compiler_CodeGeneratorResponse.File: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "google.protobuf.compiler" extension Google_Protobuf_Compiler_Version: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".Version" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "major"), - 2: .same(proto: "minor"), - 3: .same(proto: "patch"), - 4: .same(proto: "suffix"), - ] + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}major\0\u{1}minor\0\u{1}patch\0\u{1}suffix\0") public mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -426,15 +402,11 @@ extension Google_Protobuf_Compiler_Version: SwiftProtobuf.Message, SwiftProtobuf extension Google_Protobuf_Compiler_CodeGeneratorRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".CodeGeneratorRequest" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "file_to_generate"), - 2: .same(proto: "parameter"), - 15: .standard(proto: "proto_file"), - 3: .standard(proto: "compiler_version"), - ] + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}file_to_generate\0\u{1}parameter\0\u{3}compiler_version\0\u{4}\u{c}proto_file\0\u{4}\u{2}source_file_descriptors\0") public var isInitialized: Bool { if !SwiftProtobuf.Internal.areAllInitialized(self.protoFile) {return false} + if !SwiftProtobuf.Internal.areAllInitialized(self.sourceFileDescriptors) {return false} return true } @@ -448,6 +420,7 @@ extension Google_Protobuf_Compiler_CodeGeneratorRequest: SwiftProtobuf.Message, case 2: try { try decoder.decodeSingularStringField(value: &self._parameter) }() case 3: try { try decoder.decodeSingularMessageField(value: &self._compilerVersion) }() case 15: try { try decoder.decodeRepeatedMessageField(value: &self.protoFile) }() + case 17: try { try decoder.decodeRepeatedMessageField(value: &self.sourceFileDescriptors) }() default: break } } @@ -470,6 +443,9 @@ extension Google_Protobuf_Compiler_CodeGeneratorRequest: SwiftProtobuf.Message, if !self.protoFile.isEmpty { try visitor.visitRepeatedMessageField(value: self.protoFile, fieldNumber: 15) } + if !self.sourceFileDescriptors.isEmpty { + try visitor.visitRepeatedMessageField(value: self.sourceFileDescriptors, fieldNumber: 17) + } try unknownFields.traverse(visitor: &visitor) } @@ -477,6 +453,7 @@ extension Google_Protobuf_Compiler_CodeGeneratorRequest: SwiftProtobuf.Message, if lhs.fileToGenerate != rhs.fileToGenerate {return false} if lhs._parameter != rhs._parameter {return false} if lhs.protoFile != rhs.protoFile {return false} + if lhs.sourceFileDescriptors != rhs.sourceFileDescriptors {return false} if lhs._compilerVersion != rhs._compilerVersion {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true @@ -485,11 +462,7 @@ extension Google_Protobuf_Compiler_CodeGeneratorRequest: SwiftProtobuf.Message, extension Google_Protobuf_Compiler_CodeGeneratorResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".CodeGeneratorResponse" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "error"), - 2: .standard(proto: "supported_features"), - 15: .same(proto: "file"), - ] + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}error\0\u{3}supported_features\0\u{3}minimum_edition\0\u{3}maximum_edition\0\u{2}\u{b}file\0") public mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -499,6 +472,8 @@ extension Google_Protobuf_Compiler_CodeGeneratorResponse: SwiftProtobuf.Message, switch fieldNumber { case 1: try { try decoder.decodeSingularStringField(value: &self._error) }() case 2: try { try decoder.decodeSingularUInt64Field(value: &self._supportedFeatures) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._minimumEdition) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &self._maximumEdition) }() case 15: try { try decoder.decodeRepeatedMessageField(value: &self.file) }() default: break } @@ -516,6 +491,12 @@ extension Google_Protobuf_Compiler_CodeGeneratorResponse: SwiftProtobuf.Message, try { if let v = self._supportedFeatures { try visitor.visitSingularUInt64Field(value: v, fieldNumber: 2) } }() + try { if let v = self._minimumEdition { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._maximumEdition { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() if !self.file.isEmpty { try visitor.visitRepeatedMessageField(value: self.file, fieldNumber: 15) } @@ -525,6 +506,8 @@ extension Google_Protobuf_Compiler_CodeGeneratorResponse: SwiftProtobuf.Message, public static func ==(lhs: Google_Protobuf_Compiler_CodeGeneratorResponse, rhs: Google_Protobuf_Compiler_CodeGeneratorResponse) -> Bool { if lhs._error != rhs._error {return false} if lhs._supportedFeatures != rhs._supportedFeatures {return false} + if lhs._minimumEdition != rhs._minimumEdition {return false} + if lhs._maximumEdition != rhs._maximumEdition {return false} if lhs.file != rhs.file {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true @@ -532,20 +515,12 @@ extension Google_Protobuf_Compiler_CodeGeneratorResponse: SwiftProtobuf.Message, } extension Google_Protobuf_Compiler_CodeGeneratorResponse.Feature: SwiftProtobuf._ProtoNameProviding { - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FEATURE_NONE"), - 1: .same(proto: "FEATURE_PROTO3_OPTIONAL"), - ] + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FEATURE_NONE\0\u{1}FEATURE_PROTO3_OPTIONAL\0\u{1}FEATURE_SUPPORTS_EDITIONS\0") } extension Google_Protobuf_Compiler_CodeGeneratorResponse.File: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { public static let protoMessageName: String = Google_Protobuf_Compiler_CodeGeneratorResponse.protoMessageName + ".File" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - 2: .standard(proto: "insertion_point"), - 15: .same(proto: "content"), - 16: .standard(proto: "generated_code_info"), - ] + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}name\0\u{3}insertion_point\0\u{2}\u{d}content\0\u{3}generated_code_info\0") public mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { diff --git a/Sources/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.pb.swift b/Sources/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.pb.swift index f4ab30b20..feaf1b53f 100644 --- a/Sources/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.pb.swift +++ b/Sources/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.proto +// Source: swift_protobuf_module_mappings.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -17,7 +18,6 @@ // See http://swift.org/LICENSE.txt for license information // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -32,7 +32,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// Configuration used to define the mappings for generated proto files /// to the Swift module they will be included in. -public struct SwiftProtobuf_GenSwift_ModuleMappings { +public struct SwiftProtobuf_GenSwift_ModuleMappings: Sendable { // 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. @@ -44,7 +44,7 @@ public struct SwiftProtobuf_GenSwift_ModuleMappings { /// Individual listing of the module name and the files that will go /// into it. - public struct Entry { + public struct Entry: Sendable { // 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. @@ -67,20 +67,13 @@ public struct SwiftProtobuf_GenSwift_ModuleMappings { public init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension SwiftProtobuf_GenSwift_ModuleMappings: @unchecked Sendable {} -extension SwiftProtobuf_GenSwift_ModuleMappings.Entry: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. fileprivate let _protobuf_package = "swift_protobuf.gen_swift" extension SwiftProtobuf_GenSwift_ModuleMappings: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { public static let protoMessageName: String = _protobuf_package + ".ModuleMappings" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mapping"), - ] + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mapping\0") public mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -110,10 +103,7 @@ extension SwiftProtobuf_GenSwift_ModuleMappings: SwiftProtobuf.Message, SwiftPro extension SwiftProtobuf_GenSwift_ModuleMappings.Entry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { public static let protoMessageName: String = SwiftProtobuf_GenSwift_ModuleMappings.protoMessageName + ".Entry" - public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "module_name"), - 2: .standard(proto: "proto_file_path"), - ] + public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}module_name\0\u{3}proto_file_path\0") public mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { diff --git a/Sources/SwiftProtobufTestHelpers/Descriptor+TestHelpers.swift b/Sources/SwiftProtobufTestHelpers/Descriptor+TestHelpers.swift new file mode 100644 index 000000000..e7cdd3c26 --- /dev/null +++ b/Sources/SwiftProtobufTestHelpers/Descriptor+TestHelpers.swift @@ -0,0 +1,45 @@ +// Sources/protoc-gen-swift/Descriptor+TestHelpers.swift - Additions to Descriptors +// +// Copyright (c) 2014 - 2017 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +import SwiftProtobuf + +extension Google_Protobuf_FileDescriptorProto { + package init(name: String, dependencies: [String] = [], publicDependencies: [Int32] = [], package: String = "") { + for idx in publicDependencies { precondition(Int(idx) <= dependencies.count) } + self.init() + self.name = name + self.dependency = dependencies + self.publicDependency = publicDependencies + self.package = package + } + package init(textFormatStrings: [String]) throws { + let s = textFormatStrings.joined(separator: "\n") + "\n" + try self.init(textFormatString: s) + } +} + +extension Google_Protobuf_FileDescriptorSet { + package init(files: [Google_Protobuf_FileDescriptorProto]) { + self.init() + self.file = files + } + package init(file: Google_Protobuf_FileDescriptorProto) { + self.init() + self.file = [file] + } +} + +extension Google_Protobuf_EnumValueDescriptorProto { + package init(name: String, number: Int32) { + self.init() + self.name = name + self.number = number + } +} diff --git a/Sources/protobuf/abseil b/Sources/protobuf/abseil new file mode 160000 index 000000000..76bb24329 --- /dev/null +++ b/Sources/protobuf/abseil @@ -0,0 +1 @@ +Subproject commit 76bb24329e8bf5f39704eb10d21b9a80befa7c81 diff --git a/Sources/protobuf/protobuf b/Sources/protobuf/protobuf new file mode 160000 index 000000000..a79f2d2e9 --- /dev/null +++ b/Sources/protobuf/protobuf @@ -0,0 +1 @@ +Subproject commit a79f2d2e9fadd75e94f3fe40a0399bf0a5d90551 diff --git a/Sources/protoc-gen-swift/BytecodeWriter.swift b/Sources/protoc-gen-swift/BytecodeWriter.swift new file mode 100644 index 000000000..d2139b297 --- /dev/null +++ b/Sources/protoc-gen-swift/BytecodeWriter.swift @@ -0,0 +1,114 @@ +// Sources/SwiftProtobufPluginLibrary/BytecodeCompiler.swift - Internal bytecode compiler +// +// Copyright (c) 2014 - 2025 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +import Foundation +import SwiftProtobuf + +/// Writes bytecode into a string that is suitable for use as a Swift string literal (i.e., for +/// appending to generated code). +/// +/// See `SwiftProtobuf.BytecodeInterpreter` for more information on the format used here. +package struct BytecodeWriter where Instruction.RawValue == UInt64 { + /// The Swift string literal that represents the written bytecode, including the delimiting + /// quotes. + package var stringLiteral: String { #""\#(code)""# } + + /// The contents of the Swift string literal representing the written bytecode, without the + /// delimiting quotes. + private var code: String = "" { + didSet { + hasData = true + } + } + + /// Indicates whether any data other than the program format identifier has been written to the + /// bytecode stream. + package var hasData: Bool = false + + /// Creates a new bytecode writer, writing the program format as the first value in the stream. + package init() { + writeUInt64(latestBytecodeProgramFormat) + + // Clear this back out, because we only want to track writes that come after the program + // format. + self.hasData = false + } + + /// Writes the integer opcode corresponding to the given instruction to the bytecode stream. + package mutating func writeOpcode(of instruction: Instruction) { + writeUInt64(instruction.rawValue) + } + + /// Writes a signed 32-bit integer to the bytecode stream. + /// + /// This is provided as its own primitive operation because 32-bit values are extremely common + /// as field numbers (0 to 2^29-1) and enum cases (-2^31 to 2^31-1). In particular for enum + /// cases, using this function specifically for those cases avoids making mistakes involving + /// sign- vs. zero-extension between differently-sized integers. + package mutating func writeInt32(_ value: Int32) { + // `Int32`s are stored by converting them bit-wise to a `UInt32` and then zero-extended to + // `UInt64`, since this representation is smaller than sign-extending them to 64 bits. + writeUInt64(UInt64(UInt32(bitPattern: value))) + } + + /// Writes an unsigned 64-bit integer to the bytecode stream. + package mutating func writeUInt64(_ value: UInt64) { + func append(_ value: UInt64) { + // Print the normal scalar if it's ASCII-printable so that we only use longer `\u{...}` + // sequences for those that are not. + if value == 0 { + code.append("\\0") + } else if isprint(Int32(truncatingIfNeeded: value)) != 0 { + self.append(escapingIfNecessary: UnicodeScalar(UInt32(truncatingIfNeeded: value))!) + } else { + code.append(String(format: "\\u{%x}", value)) + } + } + var v = value + while v > 0x3f { + append(v & 0x3f | 0x40) + v &>>= 6 + } + append(v) + } + + /// Writes the given string literal into the bytecode stream with null termination. + /// + /// - Precondition: `string` must not have any embedded zero code points. + package mutating func writeNullTerminatedString(_ string: String) { + for scalar in string.unicodeScalars { + append(escapingIfNecessary: scalar) + } + writeUInt64(0) + } + + /// Writes the given collection of null-terminated strings to the bytecode stream. + /// + /// The format of a string collection is to write the number of strings first as an integer, + /// then write that many null-terminated strings without delimiters. + package mutating func writeNullTerminatedStringArray(_ strings: some Collection) { + writeUInt64(UInt64(strings.count)) + for string in strings { + writeNullTerminatedString(string) + } + } + + /// Appends the given Unicode scalar to the bytecode literal, escaping it if necessary for use + /// in Swift code. + private mutating func append(escapingIfNecessary scalar: Unicode.Scalar) { + switch scalar { + case "\\", "\"": + code.unicodeScalars.append("\\") + code.unicodeScalars.append(scalar) + default: + code.unicodeScalars.append(scalar) + } + } +} diff --git a/Sources/protoc-gen-swift/CMakeLists.txt b/Sources/protoc-gen-swift/CMakeLists.txt index aaf799d4d..4ed225870 100644 --- a/Sources/protoc-gen-swift/CMakeLists.txt +++ b/Sources/protoc-gen-swift/CMakeLists.txt @@ -8,7 +8,6 @@ add_executable(protoc-gen-swift FileIo.swift GenerationError.swift GeneratorOptions.swift - Google_Protobuf_DescriptorProto+Extensions.swift Google_Protobuf_FileDescriptorProto+Extensions.swift main.swift MessageFieldGenerator.swift @@ -16,6 +15,7 @@ add_executable(protoc-gen-swift MessageStorageClassGenerator.swift MessageStorageDecision.swift OneofGenerator.swift + Range+Extensions.swift StringUtils.swift Version.swift) target_link_libraries(protoc-gen-swift PRIVATE diff --git a/Sources/protoc-gen-swift/CommandLine+Extensions.swift b/Sources/protoc-gen-swift/CommandLine+Extensions.swift index c3f21da91..3c3f31fbe 100644 --- a/Sources/protoc-gen-swift/CommandLine+Extensions.swift +++ b/Sources/protoc-gen-swift/CommandLine+Extensions.swift @@ -11,12 +11,20 @@ import Foundation extension CommandLine { - static var programName: String { - guard let base = arguments.first else { - return "protoc-gen-swift" + + static var programName: String { + // Get the command-line arguments passed to this process in a non mutable + // form. Idea from https://github.com/swiftlang/swift/issues/66213 + let safeArgs: [String] = + UnsafeBufferPointer(start: unsafeArgv, count: Int(argc)).compactMap { + String(validatingUTF8: $0!) + } + + guard let base = safeArgs.first else { + return "protoc-gen-swift" + } + // Strip it down to just the leaf if it was a path. + let parts = splitPath(pathname: base) + return parts.base + parts.suffix } - // Strip it down to just the leaf if it was a path. - let parts = splitPath(pathname: base) - return parts.base + parts.suffix - } } diff --git a/Sources/protoc-gen-swift/Descriptor+Extensions.swift b/Sources/protoc-gen-swift/Descriptor+Extensions.swift index ba1434a0d..c6298c74e 100644 --- a/Sources/protoc-gen-swift/Descriptor+Extensions.swift +++ b/Sources/protoc-gen-swift/Descriptor+Extensions.swift @@ -11,267 +11,512 @@ import SwiftProtobufPluginLibrary extension FileDescriptor { - /// True if this file should perserve unknown enums within the enum. - var hasUnknownEnumPreservingSemantics: Bool { - return syntax == .proto3 - } - - var isBundledProto: Bool { - return SwiftProtobufInfo.isBundledProto(file: proto) - } -} + var isBundledProto: Bool { + SwiftProtobufInfo.isBundledProto(file: self) + } -extension Descriptor { - /// Returns True if this is the Any WKT - var isAnyMessage: Bool { - return (file.syntax == .proto3 && - fullName == ".google.protobuf.Any" && - file.name == "google/protobuf/any.proto") - } - - /// Returns True if this message recurisvely contains a required field. - /// This is a helper for generating isInitialized methods. - /// - /// The logic for this check comes from google/protobuf; the C++ and Java - /// generators specificly. - func containsRequiredFields() -> Bool { - var alreadySeen = Set() - - func helper(_ descriptor: Descriptor) -> Bool { - if alreadySeen.contains(descriptor.fullName) { - // First required thing found causes this to return true, so one can - // assume if it is already visited and and wasn't cached, it is part - // of a recursive cycle, so return false without caching to allow - // the evalutation to continue on other fields of the message. - return false - } - alreadySeen.insert(descriptor.fullName) - - // If it can support extensions, then return true as an extension could - // have a required field. - if !descriptor.extensionRanges.isEmpty { - return true - } - - for f in descriptor.fields { - if f.label == .required { - return true + // Returns true if the file will need to import Foundation. + // + // `bytes` fields are modeled as `Data`, that is currently the only reason + // why the generated sources need to `import Foundation`. + var needsFoundationImport: Bool { + if extensions.contains(where: { $0.type == .bytes }) { + return true } - switch f.type { - case .group, .message: - if helper(f.messageType) { + + if messages.contains(where: { $0.needsFoundationImport }) { return true - } - default: - break } - } - return false + return false } - return helper(self) - } - - /// A `String` containing a comma-delimited list of Swift expressions - /// covering the extension ranges for this message. - /// - /// This expression list is suitable as a pattern match in a `case` - /// statement. For example, `"case 5..<10, 15, 20..<30:"`. - var swiftExtensionRangeCaseExpressions: String { - return normalizedExtensionRanges.lazy.map { - $0.swiftCaseExpression - }.joined(separator: ", ") - } - - /// A `String` containing a Swift Boolean expression that tests if the given - /// variable is in any of the extension ranges for this message. - /// - /// - Parameter variable: The name of the variable to test in the expression. - /// - Returns: A `String` containing the Boolean expression. - func swiftExtensionRangeBooleanExpression(variable: String) -> String { - return normalizedExtensionRanges.lazy.map { - "(\($0.swiftBooleanExpression(variable: variable)))" - }.joined(separator: " || ") - } -} + // Returns a string of any import lines for the give file based on the file's + // imports. The string may include multiple lines. + // + // Protocol Buffers has the concept of "public imports", these are imports + // into a file that expose everything from within the file to the new + // context. From the docs - + // https://protobuf.dev/programming-guides/proto/#importing + // `import public` dependencies can be transitively relied upon by anyone + // importing the proto containing the import public statement. + // To properly expose the types for use, it means in each file, the public + // imports from the dependencies (recursively) have to be hoisted and + // reexported. This way someone importing a given module still sees the type + // even when moved. + // + // NOTE: There is a weakness for Swift with protobuf extensions. To make + // the protobuf extensions easier to use, a Swift extension is declared with + // field exposed as a property on the extended message. There is no way + // to reexport the Swift `extension` and/or added properties. But the raw + // types are re-exported to minimize the breaking of code if a type is moved + // between files/modules. + // + // `reexportPublicImports` will cause the `import public` types to be + // reexported to avoid breaking downstream code using a type that might have + // moved between .proto files. + // + // `asImplementationOnly` will cause all of the import directives to be + // marked as `@_implementationOnly`. It will also cause all of the `file`'s + // `publicDependencies` to instead be recursively pulled up as direct imports + // to ensure the generate file compiles, and no `import public` files are + // re-exported. + // + // Aside: This could be moved into the plugin library, but it doesn't seem + // like anyone else would need the logic. Swift GRPC support probably stick + // with the support for the module mappings. + package func computeImports( + namer: SwiftProtobufNamer, + directive: GeneratorOptions.ImportDirective, + reexportPublicImports: Bool + ) -> String { + // The namer should be configured with the module this file generated for. + assert(namer.targetModule == (namer.mappings.moduleName(forFile: self) ?? "")) + // Both options can't be enabled. + assert(!reexportPublicImports || directive != .implementationOnly) -extension FieldDescriptor { - func swiftType(namer: SwiftProtobufNamer) -> String { - if case (let keyField, let valueField)? = messageType?.mapKeyAndValue { - let keyType = keyField.swiftType(namer: namer) - let valueType = valueField.swiftType(namer: namer) - return "Dictionary<" + keyType + "," + valueType + ">" + guard namer.mappings.hasMappings else { + // No module mappings? Everything must be the same module, so no Swift + // imports will be needed. + return "" + } + + if dependencies.isEmpty { + // No proto dependencies (imports), then no Swift imports will be needed. + return "" + } + + let importSnippet = directive.snippet + var imports = Set() + for dependency in dependencies { + if SwiftProtobufInfo.isBundledProto(file: dependency) { + continue // No import needed for the runtime, that's always added. + } + if reexportPublicImports && publicDependencies.contains(where: { $0 === dependency }) { + // When re-exporting, the `import public` types will be imported + // instead of importing the module. + continue + } + if let depModule = namer.mappings.moduleName(forFile: dependency), + depModule != namer.targetModule + { + // Different module, import it. + imports.insert("\(importSnippet) \(depModule)") + } + } + + // If not re-exporting imports, then there is nothing special needed for + // `import public` files, as any transitive `import public` directives + // would have already re-exported the types, so everything this file needs + // will be covered by the above imports. + let exportingImports: [String] = + reexportPublicImports + ? computeSymbolReExports( + namer: namer, + useAccessLevelOnImports: directive.isAccessLevel + ) + : [String]() + + var result = imports.sorted().joined(separator: "\n") + if !exportingImports.isEmpty { + if !result.isEmpty { + result.append("\n") + } + result.append("// Use of 'import public' causes re-exports:\n") + result.append(exportingImports.sorted().joined(separator: "\n")) + } + return result } - let result: String - switch type { - case .double: result = "Double" - case .float: result = "Float" - case .int64: result = "Int64" - case .uint64: result = "UInt64" - case .int32: result = "Int32" - case .fixed64: result = "UInt64" - case .fixed32: result = "UInt32" - case .bool: result = "Bool" - case .string: result = "String" - case .group: result = namer.fullName(message: messageType) - case .message: result = namer.fullName(message: messageType) - case .bytes: result = "Data" - case .uint32: result = "UInt32" - case .enum: result = namer.fullName(enum: enumType) - case .sfixed32: result = "Int32" - case .sfixed64: result = "Int64" - case .sint32: result = "Int32" - case .sint64: result = "Int64" + // Internal helper to `computeImports(...)`. + private func computeSymbolReExports(namer: SwiftProtobufNamer, useAccessLevelOnImports: Bool) -> [String] { + var result = [String]() + + // To handle re-exporting, recursively walk all the `import public` files + // and make this module do a Swift exporting import of the specific + // symbols. That will keep any type that gets moved between .proto files + // still exposed from the same modules so as not to break developer + // authored code. + var toScan = publicDependencies + var visited = Set() + let exportedImportDirective = "@_exported\(useAccessLevelOnImports ? " public" : "") import" + while let dependency = toScan.popLast() { + let dependencyName = dependency.name + if visited.contains(dependencyName) { continue } + visited.insert(dependencyName) + + if SwiftProtobufInfo.isBundledProto(file: dependency) { + continue // Bundlined file, nothing to do. + } + guard let depModule = namer.mappings.moduleName(forFile: dependency) else { + continue // No mapping, assume same module, nothing to do. + } + if depModule == namer.targetModule { + // Same module, nothing to do (that generated file will do any re-exports). + continue + } + + toScan.append(contentsOf: dependency.publicDependencies) + + // NOTE: This re-exports/imports from the module that defines the type. + // If Xcode/SwiftPM ever were to do some sort of "layering checks" to + // ensure there is a direct dependency on the thing being imported, this + // could be updated do the re-export/import from the middle step in + // chained imports. + + for m in dependency.messages { + result.append("\(exportedImportDirective) struct \(namer.fullName(message: m))") + } + for e in dependency.enums { + result.append("\(exportedImportDirective) enum \(namer.fullName(enum: e))") + } + // There is nothing we can do for the Swift extensions declared on the + // extended Messages, best we can do is expose the raw extensions + // themselves. + for e in dependency.extensions { + result.append("\(exportedImportDirective) let \(namer.fullName(extensionField: e))") + } + } + return result } +} + +extension Descriptor { + /// Returns true if the message should use the message set wireformat. + var useMessageSetWireFormat: Bool { options.messageSetWireFormat } + + /// Returns true if the file will need to import Foundation. + /// + /// `bytes` fields are modeled as `Data`, that is currently the only reason + /// why the generated sources need to `import Foundation`. + var needsFoundationImport: Bool { + if fields.contains(where: { $0.type == .bytes }) { + return true + } + if extensions.contains(where: { $0.type == .bytes }) { + return true + } - if label == .repeated { - return "[\(result)]" + // Now recurse through sub-messages. + if messages.contains(where: { $0.needsFoundationImport }) { + return true + } + + return false } - return result - } - - func swiftStorageType(namer: SwiftProtobufNamer) -> String { - let swiftType = self.swiftType(namer: namer) - switch label { - case .repeated: - return swiftType - case .optional, .required: - guard realOneof == nil else { - return swiftType - } - if hasPresence { - return "\(swiftType)?" - } else { - return swiftType - } + + /// Returns True if this message recursively contains a required field. + /// This is a helper for generating isInitialized methods. + /// + /// The logic for this check comes from google/protobuf; the C++ and Java + /// generators specifically + func containsRequiredFields() -> Bool { + var alreadySeen = Set() + + func helper(_ descriptor: Descriptor) -> Bool { + if alreadySeen.contains(descriptor.fullName) { + // First required thing found causes this to return true, so one can + // assume if it is already visited and and wasn't cached, it is part + // of a recursive cycle, so return false without caching to allow + // the evaluation to continue on other fields of the message. + return false + } + alreadySeen.insert(descriptor.fullName) + + // If it can support extensions, then return true as an extension could + // have a required field. + if !descriptor.messageExtensionRanges.isEmpty { + return true + } + + for f in descriptor.fields { + if f.isRequired { + return true + } + if let messageType = f.messageType, helper(messageType) { + return true + } + } + + return false + } + + return helper(self) } - } - - var protoGenericType: String { - precondition(!isMap) - - switch type { - case .double: return "Double" - case .float: return "Float" - case .int64: return "Int64" - case .uint64: return "UInt64" - case .int32: return "Int32" - case .fixed64: return "Fixed64" - case .fixed32: return "Fixed32" - case .bool: return "Bool" - case .string: return "String" - case .group: return "Group" - case .message: return "Message" - case .bytes: return "Bytes" - case .uint32: return "UInt32" - case .enum: return "Enum" - case .sfixed32: return "SFixed32" - case .sfixed64: return "SFixed64" - case .sint32: return "SInt32" - case .sint64: return "SInt64" + + /// The `extensionRanges` are in the order they appear in the original .proto + /// file; this orders them and then merges any ranges that are actually + /// contiguous (i.e. - [(21,30),(10,20)] -> [(10,30)]) + /// + /// This also uses Range<> since the options that could be on + /// `extensionRanges` no longer can apply as the things have been merged. + package var _normalizedExtensionRanges: [Range] { + self.messageExtensionRanges.map({ $0.start..<$0.end }).sortAndMergeContinuous() } - } - func swiftDefaultValue(namer: SwiftProtobufNamer) -> String { - if isMap { - return "[:]" + /// The `extensionRanges` from `normalizedExtensionRanges`, but takes a step + /// further in that any ranges that do _not_ have any fields inbetween them + /// are also merged together. These can then be used in context where it is + /// ok to include field numbers that have to be extension or unknown fields. + /// + /// This also uses Range<> since the options that could be on + /// `extensionRanges` no longer can apply as the things have been merged. + package var _ambitiousExtensionRanges: [Range] { + var merged = self._normalizedExtensionRanges + if merged.count > 1 { + var fieldNumbersReversedIterator = + self.fields.map({ Int($0.number) }).sorted(by: { $0 > $1 }).makeIterator() + var nextFieldNumber = fieldNumbersReversedIterator.next() + while nextFieldNumber != nil && merged.last!.lowerBound < nextFieldNumber! { + nextFieldNumber = fieldNumbersReversedIterator.next() + } + + for i in (0..<(merged.count - 1)).reversed() { + if nextFieldNumber == nil || merged[i].lowerBound > nextFieldNumber! { + // No fields left or range starts after the next field, merge it with + // the previous one. + merged[i] = merged[i].lowerBound.. String { + if case (let keyField, let valueField)? = messageType?.mapKeyAndValue { + let keyType = keyField.swiftType(namer: namer) + let valueType = valueField.swiftType(namer: namer) + return "Dictionary<" + keyType + "," + valueType + ">" + } + + let result: String + switch type { + case .double: result = "Double" + case .float: result = "Float" + case .int64: result = "Int64" + case .uint64: result = "UInt64" + case .int32: result = "Int32" + case .fixed64: result = "UInt64" + case .fixed32: result = "UInt32" + case .bool: result = "Bool" + case .string: result = "String" + case .group: result = namer.fullName(message: messageType!) + case .message: result = namer.fullName(message: messageType!) + case .bytes: result = "Data" + case .uint32: result = "UInt32" + case .enum: result = namer.fullName(enum: enumType!) + case .sfixed32: result = "Int32" + case .sfixed64: result = "Int64" + case .sint32: result = "Int32" + case .sint64: result = "Int64" + } + + if isRepeated { + return "[\(result)]" + } + return result } - if let defaultValue = explicitDefaultValue { - switch type { - case .double: - switch defaultValue { - case "inf": return "Double.infinity" - case "-inf": return "-Double.infinity" - case "nan": return "Double.nan" - default: return defaultValue + func swiftStorageType(namer: SwiftProtobufNamer) -> String { + let swiftType = self.swiftType(namer: namer) + if isRepeated { + return swiftType + } + guard realContainingOneof == nil else { + return swiftType } - case .float: - switch defaultValue { - case "inf": return "Float.infinity" - case "-inf": return "-Float.infinity" - case "nan": return "Float.nan" - default: return defaultValue + if hasPresence { + return "\(swiftType)?" + } else { + return swiftType } - case .string: - return stringToEscapedStringLiteral(defaultValue) - case .bytes: - return escapedToDataLiteral(defaultValue) - case .enum: - let enumValue = enumType.value(named: defaultValue)! - return namer.dottedRelativeName(enumValue: enumValue) - default: - return defaultValue - } } - switch type { - case .bool: return "false" - case .string: return "String()" - case .bytes: return "Data()" - case .group, .message: - return namer.fullName(message: messageType) + "()" - case .enum: - return namer.dottedRelativeName(enumValue: enumType.defaultValue) - default: - return "0" + var protoGenericType: String { + precondition(!isMap) + + switch type { + case .double: return "Double" + case .float: return "Float" + case .int64: return "Int64" + case .uint64: return "UInt64" + case .int32: return "Int32" + case .fixed64: return "Fixed64" + case .fixed32: return "Fixed32" + case .bool: return "Bool" + case .string: return "String" + case .group: return "Group" + case .message: return "Message" + case .bytes: return "Bytes" + case .uint32: return "UInt32" + case .enum: return "Enum" + case .sfixed32: return "SFixed32" + case .sfixed64: return "SFixed64" + case .sint32: return "SInt32" + case .sint64: return "SInt64" + } } - } - - /// Calculates the traits type used for maps and extensions, they - /// are used in decoding and visiting. - func traitsType(namer: SwiftProtobufNamer) -> String { - if case (let keyField, let valueField)? = messageType?.mapKeyAndValue { - let keyTraits = keyField.traitsType(namer: namer) - let valueTraits = valueField.traitsType(namer: namer) - switch valueField.type { - case .message: // Map's can't have a group as the value - return "\(namer.swiftProtobufModuleName)._ProtobufMessageMap<\(keyTraits),\(valueTraits)>" - case .enum: - return "\(namer.swiftProtobufModuleName)._ProtobufEnumMap<\(keyTraits),\(valueTraits)>" - default: - return "\(namer.swiftProtobufModuleName)._ProtobufMap<\(keyTraits),\(valueTraits)>" - } + + func swiftDefaultValue(namer: SwiftProtobufNamer) -> String { + if isMap { + return "[:]" + } + if isRepeated { + return "[]" + } + + if let defaultValue = defaultValue { + switch type { + case .double: + switch defaultValue { + case "inf": return "Double.infinity" + case "-inf": return "-Double.infinity" + case "nan": return "Double.nan" + case "-nan": return "Double.nan" + default: return defaultValue + } + case .float: + switch defaultValue { + case "inf": return "Float.infinity" + case "-inf": return "-Float.infinity" + case "nan": return "Float.nan" + case "-nan": return "Float.nan" + default: return defaultValue + } + case .string: + return stringToEscapedStringLiteral(defaultValue) + case .bytes: + return escapedToDataLiteral(defaultValue) + case .enum: + let enumValue = enumType!.value(named: defaultValue)! + return namer.dottedRelativeName(enumValue: enumValue) + default: + return defaultValue + } + } + + switch type { + case .bool: return "false" + case .string: return "String()" + case .bytes: return "Data()" + case .group, .message: + return namer.fullName(message: messageType!) + "()" + case .enum: + return namer.dottedRelativeName(enumValue: enumType!.values.first!) + default: + return "0" + } } - switch type { - case .double: return "\(namer.swiftProtobufModuleName).ProtobufDouble" - case .float: return "\(namer.swiftProtobufModuleName).ProtobufFloat" - case .int64: return "\(namer.swiftProtobufModuleName).ProtobufInt64" - case .uint64: return "\(namer.swiftProtobufModuleName).ProtobufUInt64" - case .int32: return "\(namer.swiftProtobufModuleName).ProtobufInt32" - case .fixed64: return "\(namer.swiftProtobufModuleName).ProtobufFixed64" - case .fixed32: return "\(namer.swiftProtobufModuleName).ProtobufFixed32" - case .bool: return "\(namer.swiftProtobufModuleName).ProtobufBool" - case .string: return "\(namer.swiftProtobufModuleName).ProtobufString" - case .group, .message: return namer.fullName(message: messageType) - case .bytes: return "\(namer.swiftProtobufModuleName).ProtobufBytes" - case .uint32: return "\(namer.swiftProtobufModuleName).ProtobufUInt32" - case .enum: return namer.fullName(enum: enumType) - case .sfixed32: return "\(namer.swiftProtobufModuleName).ProtobufSFixed32" - case .sfixed64: return "\(namer.swiftProtobufModuleName).ProtobufSFixed64" - case .sint32: return "\(namer.swiftProtobufModuleName).ProtobufSInt32" - case .sint64: return "\(namer.swiftProtobufModuleName).ProtobufSInt64" + + /// Calculates the traits type used for maps and extensions, they + /// are used in decoding and visiting. + func traitsType(namer: SwiftProtobufNamer) -> String { + if case (let keyField, let valueField)? = messageType?.mapKeyAndValue { + let keyTraits = keyField.traitsType(namer: namer) + let valueTraits = valueField.traitsType(namer: namer) + switch valueField.type { + case .message: // Map's can't have a group as the value + return "\(namer.swiftProtobufModulePrefix)_ProtobufMessageMap<\(keyTraits),\(valueTraits)>" + case .enum: + return "\(namer.swiftProtobufModulePrefix)_ProtobufEnumMap<\(keyTraits),\(valueTraits)>" + default: + return "\(namer.swiftProtobufModulePrefix)_ProtobufMap<\(keyTraits),\(valueTraits)>" + } + } + switch type { + case .double: return "\(namer.swiftProtobufModulePrefix)ProtobufDouble" + case .float: return "\(namer.swiftProtobufModulePrefix)ProtobufFloat" + case .int64: return "\(namer.swiftProtobufModulePrefix)ProtobufInt64" + case .uint64: return "\(namer.swiftProtobufModulePrefix)ProtobufUInt64" + case .int32: return "\(namer.swiftProtobufModulePrefix)ProtobufInt32" + case .fixed64: return "\(namer.swiftProtobufModulePrefix)ProtobufFixed64" + case .fixed32: return "\(namer.swiftProtobufModulePrefix)ProtobufFixed32" + case .bool: return "\(namer.swiftProtobufModulePrefix)ProtobufBool" + case .string: return "\(namer.swiftProtobufModulePrefix)ProtobufString" + case .group, .message: return namer.fullName(message: messageType!) + case .bytes: return "\(namer.swiftProtobufModulePrefix)ProtobufBytes" + case .uint32: return "\(namer.swiftProtobufModulePrefix)ProtobufUInt32" + case .enum: return namer.fullName(enum: enumType!) + case .sfixed32: return "\(namer.swiftProtobufModulePrefix)ProtobufSFixed32" + case .sfixed64: return "\(namer.swiftProtobufModulePrefix)ProtobufSFixed64" + case .sint32: return "\(namer.swiftProtobufModulePrefix)ProtobufSInt32" + case .sint64: return "\(namer.swiftProtobufModulePrefix)ProtobufSInt64" + } } - } } extension EnumDescriptor { - // True if this enum should perserve unknown enums within the enum. - var hasUnknownPreservingSemantics: Bool { - return file.hasUnknownEnumPreservingSemantics - } - - func value(named: String) -> EnumValueDescriptor? { - for v in values { - if v.name == named { - return v - } + + func value(named: String) -> EnumValueDescriptor? { + for v in values { + if v.name == named { + return v + } + } + return nil } - return nil - } + + /// Helper object that computes the alias relationships of + /// `EnumValueDescriptor`s for a given `EnumDescriptor`. + package final class ValueAliasInfo { + /// The `EnumValueDescriptor`s that are not aliases of another value. In + /// the same order as the values on the `EnumDescriptor`. + package let mainValues: [EnumValueDescriptor] + + /// Find the alias values for the given value. + /// + /// - Parameter value: The value descriptor to look up. + /// - Returns The list of value descriptors that are aliases for this + /// value, or `nil` if there are no alias (or if this was an alias). + package func aliases(_ value: EnumValueDescriptor) -> [EnumValueDescriptor]? { + assert(mainValues.first!.enumType === value.enumType) + return aliasesMap[value.index] + } + + /// Find the original for an alias. + /// + /// - Parameter value: The value descriptor to look up. + /// - Returns The original/main value if this was an alias otherwise `nil`. + package func original(of: EnumValueDescriptor) -> EnumValueDescriptor? { + assert(mainValues.first!.enumType === of.enumType) + return aliasOfMap[of.index] + } + + /// Mapping from index of a "main" value to the aliases for it. + private let aliasesMap: [Int: [EnumValueDescriptor]] + + /// Mapping from value's index the main value if it was an alias. + private let aliasOfMap: [Int: EnumValueDescriptor] + + /// Initialize the mappings for the given `EnumDescriptor`. + package init(enumDescriptor descriptor: EnumDescriptor) { + var mainValues = [EnumValueDescriptor]() + var aliasesMap = [Int: [EnumValueDescriptor]]() + var aliasOfMap = [Int: EnumValueDescriptor]() + + var firstValues = [Int32: EnumValueDescriptor]() + for v in descriptor.values { + if let aliasing = firstValues[v.number] { + aliasesMap[aliasing.index, default: []].append(v) + aliasOfMap[v.index] = aliasing + } else { + firstValues[v.number] = v + mainValues.append(v) + } + } + + self.mainValues = mainValues + self.aliasesMap = aliasesMap + self.aliasOfMap = aliasOfMap + } + } + } diff --git a/Sources/protoc-gen-swift/Docs.docc/index.md b/Sources/protoc-gen-swift/Docs.docc/index.md new file mode 100644 index 000000000..beba84898 --- /dev/null +++ b/Sources/protoc-gen-swift/Docs.docc/index.md @@ -0,0 +1,262 @@ +# ``protoc_gen_swift`` + +@Metadata { + @DisplayName("protoc-gen-swift") +} + +Code generation helper for use with Google's `protoc` command. + +## Overview + +The `protoc-gen-swift` program is a _plugin_ to Google's protoc +compiler that works with protoc to translate proto files into +Swift code. + +## Getting Started + +If you've worked with Protocol Buffers in other programming +languages before, adding Swift support is +very simple: you just need to build the `protoc-gen-swift` program and +copy it into any directory in your PATH. The protoc program will find +and use it automatically, allowing you to build Swift sources for your +proto files. You will also, of course, need to add the corresponding +Swift runtime library to your project. + +### System Requirements + +To use Swift with Protocol buffers, you'll need: + +* A recent Swift compiler that includes the Swift Package Manager. + We recommend using the latest release build from + [Swift.org](https://swift.org) or the command-line tools included + with the latest version of Xcode. + +* Google's protoc compiler. You can get recent versions from + [Google's github repository](https://github.com/protocolbuffers/protobuf). + +### Build and Install + +Building the plugin should be simple on any supported Swift platform: + +```sh +$ git clone https://github.com/apple/swift-protobuf +$ cd swift-protobuf +$ swift build -c release +``` + +This will create a binary called `protoc-gen-swift` in the +`.build/release` directory. To install, just copy this one executable +anywhere in your PATH. + +### Converting .proto files into Swift + +To generate Swift output for your .proto files, you run the `protoc` +command as usual, using the `--swift_out=` option: + +```sh +$ protoc --swift_out=. my.proto +``` + +The `protoc` program will automatically look for `protoc-gen-swift` in your +`PATH` and use it. + +Each `.proto` input file will get translated to a corresponding `.pb.swift` file +in the output directory. + +#### How to Specify Code-Generation Options + +The plugin tries to use reasonable default behaviors for the code it +generates, but there are a few things that can be configured to +specific needs. + +You can use the `--swift_opt` argument to `protoc` to pass options to the +Swift code generator as follows: +```sh +$ protoc --swift_opt=[NAME]=[VALUE] --swift_out:. foo/bar/*.proto mumble/*.proto +``` + +If you need to specify multiple options, you can use more than one +`--swift_opt` argument: +``` +$ protoc \ + --swift_opt=[NAME1]=[VALUE1] \ + --swift_opt=[NAME2]=[VALUE2] \ + --swift_out=. foo/bar/*.proto mumble/*.proto +``` + +_NOTE:_ protoc 3.2.0 does not recognize `--swift_opt` if you rely on +`protoc-gen-swift` being found on the `PATH`. To work around this, you need to +explicitly add the argument `--plugin=[PATH-TO-protoc-gen-swift]` to the +command line, then the `--swift_opt` argument will be understood. If you are +using protoc 3.2.1 or later, then this workaround is _not_ needed. + +##### Generation Option: `FileNaming` - Naming of Generated Sources + +By default, the paths to the proto files are maintained on the +generated files. So if you pass `foo/bar/my.proto`, you will get +`foo/bar/my.pb.swift` in the output directory. The Swift plugin +supports an option to control the generated file names, the option is +given as part of the `--swift_opt` argument like this: + +``` +$ protoc --swift_opt=FileNaming=[value] --swift_out=. foo/bar/*.proto mumble/*.proto +``` + +The possible values for `FileNaming` are: + +* `FullPath` (default): Like all other languages, "foo/bar/baz.proto" makes + "foo/bar/baz.pb.swift. +* `PathToUnderscores`: To help with things like the Swift Package + Manager where someone might want all the files in one directory; + "foo/bar/baz.proto" makes "foo_bar_baz.pb.swift". +* `DropPath`: Drop the path from the input and just write all files + into the output directory; "foo/bar/baz.proto" makes "baz.pb.swift". + +##### Generation Option: `Visibility` - Visibility of Generated Types + +By default, SwiftProtobuf does not specify a visibility for the +generated types, methods, and properties. As a result, these will end +up with the default (`internal`) access. You can change this with the +`Visibility` option: + +``` +$ protoc --swift_opt=Visibility=[value] --swift_out=. foo/bar/*.proto mumble/*.proto +``` + +The possible values for `Visibility` are: + +* `Internal` (default): No visibility is set for the types, so they get the + default internal visibility. +* `Public`: The visibility on the types is set to `public` so the types will + be exposed outside the module they are compiled into. + + +##### Generation Option: `ProtoPathModuleMappings` - Swift Module names for proto paths + +By default, the code generator assumes all of the resulting Swift files will +be put into the same module. However, since protos can reference types from +another proto file, those generated files might end up in different modules. +This option allows you to specify that the code generated from the proto +files will be distributed in multiple modules. This data is used during +generation to then `import` the module and scope the types. This option +takes the path of a file providing the mapping: + +``` +$ protoc --swift_opt=ProtoPathModuleMappings=[path.asciipb] --swift_out=. foo/bar/*.proto +``` + +The format of that mapping file is defined in +[swift_protobuf_module_mappings.proto](../Protos/SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.proto), +and files would look something like: + +``` +mapping { + module_name: "MyModule" + proto_file_path: "foo/bar.proto" +} +mapping { + module_name: "OtherModule" + proto_file_path: "mumble.proto" + proto_file_path: "other/file.proto" +} +``` + +The `proto_file_path` values here should match the paths used in the proto file +`import` statements. + + +##### Generation Option: `ImplementationOnlyImports` - `@_implementationOnly`-annotated imports + +By default, the code generator does not annotate any imports with `@_implementationOnly`. +However, in some scenarios, such as when distributing an `XCFramework`, imports +for types used only internally should be annotated as `@_implementationOnly` to +avoid exposing internal symbols to clients. +You can change this with the `ImplementationOnlyImports` option: + +``` +$ protoc --swift_opt=ImplementationOnlyImports=[value] --swift_out=. foo/bar/*.proto mumble/*.proto +``` + +The possible values for `ImplementationOnlyImports` are: + +* `false` (default): The `@_implementationOnly` annotation will never be used. +* `true`: Imports of internal dependencies and any modules defined in the module +mappings will be annotated as `@_implementationOnly`. + +**Important:** Modules cannot be imported as implementation-only if they're +exposed via public API, so even if `ImplementationOnlyImports` is set to `true`, +this will only work if the `Visibility` is set to `internal`. + + +##### Generation Option: `UseAccessLevelOnImports` - imports preceded by a visibility modifier (`public`, `package`, `internal`) + +The default behavior depends on the Swift version the plugin is compiled with. +For Swift versions below 6.0 the default is `false` and the code generator does not precede any imports with a visibility modifier. +You can change this by explicitly setting the `UseAccessLevelOnImports` option: + +``` +$ protoc --swift_opt=UseAccessLevelOnImports=[value] --swift_out=. foo/bar/*.proto mumble/*.proto +``` + +The possible values for `UseAccessLevelOnImports` are: + +* `false`: Generates plain import directives without a visibility modifier. +* `true`: Imports of internal dependencies and any modules defined in the module +mappings will be preceded by a visibility modifier corresponding to the visibility of the generated types - see `Visibility` option. + +**Important:** It is strongly encouraged to use `internal` imports instead of `@_implementationOnly` imports. +Hence `UseAccessLevelOnImports` and `ImplementationOnlyImports` options exclude each other. + + +### Building your project + +After copying the `.pb.swift` files into your project, you will need +to add the +[SwiftProtobuf library](https://github.com/apple/swift-protobuf) to +your project to support the generated code. If you are using the +Swift Package Manager, you should first check what version of +`protoc-gen-swift` you are currently using: + +``` +$ protoc-gen-swift --version +protoc-gen-swift 1.0.1 +``` + +And then add a dependency to your Package.swift file. Adjust the +`Version()` here to match the `protoc-gen-swift` version you checked +above: + +```swift +dependencies: [ + .package(name: "SwiftProtobuf", url: "https://github.com/apple/swift-protobuf.git", from: "1.6.0"), +] +``` + +If you are using Xcode, then you should: + +* Add the Swift source files generated from your protos directly to your + project. +* Add this SwiftPM package as dependency of your xcode project: + [Apple Docs](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app) + + + +## Internals + +When you give `protoc` an option of the form `--XYZ-out`, +it will find and run a program called `protoc-gen-XYZ`. + +The `protoc` program then proceeds to read, parse, and validate +all of your proto files. +It feeds this information (as a set of "Descriptor" objects) +to the `protoc-gen-XYZ` program and expects the program to +produce one or more source code files +that `protoc` will then save to the correct output location. + +The `protoc-gen-swift` program relies heavily +on the `SwiftProtobuf` library to handle serializing and +deserializing the protobuf-encoded data used to +communicate with `protoc`. +It also relies on another library called `SwiftProtobufPluginLibrary` +that incorporates a lot of the key knowledge about how +to produce Swift source code. diff --git a/Sources/protoc-gen-swift/Docs.docc/spm-plugin.md b/Sources/protoc-gen-swift/Docs.docc/spm-plugin.md new file mode 100644 index 000000000..eb4629dcf --- /dev/null +++ b/Sources/protoc-gen-swift/Docs.docc/spm-plugin.md @@ -0,0 +1,147 @@ +# Using the Swift Package Manager plugin + +The Swift Package Manager introduced new plugin capabilities in Swift 5.6, enabling the extension of +the build process with custom build tools. Learn how to use the SwiftProtobuf plugin for the +Swift Package Manager. + +## Overview + +> Warning: Due to limitations of binary executable discovery with Xcode we only recommend using the Swift Package Manager +plugin in leaf packages. For more information, read the `Defining the path to the protoc binary` section of +this article. + +The plugin works by running the system installed `protoc` compiler with the `protoc-gen-swift` plugin +for specified `.proto` files in your targets source folder. Furthermore, the plugin allows defining a +configuration file which will be used to customize the invocation of `protoc`. + +### Installing the protoc compiler + +First, you must ensure that you have the `protoc` compiler installed. +There are multiple ways to do this. Some of the easiest are: + +1. If you are on macOS, installing it via `brew install protobuf` +2. Download the binary from [Google's github repository](https://github.com/protocolbuffers/protobuf). + +### Adding the plugin to your manifest + +First, you need to add a dependency on `swift-protobuf`. Afterwards, you can declare the usage of the plugin +for your target. Here is an example snippet of a `Package.swift` manifest: + +```swift +let package = Package( + name: "YourPackage", + products: [...], + dependencies: [ + ... + .package(url: "https://github.com/apple/swift-protobuf", from: "2.0.0"), + ... + ], + targets: [ + ... + .executableTarget( + name: "YourTarget", + plugins: [ + .plugin(name: "SwiftProtobufPlugin", package: "swift-protobuf") + ] + ), + ... +) + +``` + +### Configuring the plugin + +Configuring the plugin is done by adding a `swift-protobuf-config.json` file anywhere in your target's sources. +Before you start configuring the plugin, you need to add the `.proto` files to your sources. You should also commit these +files to your git repository since the generated types are now generated on demand. +It's also important to note that the proto files in your configuration should be in +the same directory as the config file. Let's see an example to have a better understanding. + +Here's an example file structure that looks like this: + +```text +Sources +├── main.swift +├── ProtoBuf + ├── swift-protobuf-config.json + ├── foo.proto + └── Bar + └── Bar.proto +``` + +So, the configuration file would look something like this: + +```json +{ + "invocations": [ + { + "protoFiles": [ + "Foo.proto", + ], + "visibility": "internal", + "implementationOnlyImports": true + }, + { + "protoFiles": [ + "Bar/Bar.proto" + ], + "visibility": "public", + "fileNaming": "pathToUnderscores" + } + ] +} + +``` +As you can see in the above configuration, the paths are relative with respect to the `ProtoBuf` folder and not the root folder. +If you add a file in the `Sources` folder, the plugin would be unable to access it as the path is computed relative to +the `swift-protobuf-config.json` file. + +> Note: paths to your `.proto` files will have to include the relative path from the config file directory to the `.proto` file location. +> Files **must** be contained within the same directory as the config file. + +In the above configuration, you declared two invocations to the `protoc` compiler. The first invocation +is generating Swift types for the `Foo.proto` file with `internal` visibility. The second invocation +is generating Swift types for the `Bar.proto` file with the `public` visibility. Furthermore, the second +invocation is using the `pathToUnderscores` file naming option. This option can be used to solve +problems where a single target contains two or more proto files with the same name. + +### Overriding the path to the protoc binary + +The plugin needs to be able to invoke the `protoc` binary to generate the Swift types. +By default the plugin will use the latest `protoc` binary distributed as an +artifact bundle from the [swift-protobuf releases](https://github.com/apple/swift-protobuf/releases). + +There are several ways for you to override the path to the `protoc` binary. + +* Set an environment variable `PROTOC_PATH` that gets picked up by the plugin. +Here are two examples of how you can achieve this: + +```shell +# swift build +env PROTOC_PATH=/opt/homebrew/bin/protoc swift build + +# To start Xcode (Xcode MUST NOT be running before invoking this) +env PROTOC_PATH=/opt/homebrew/bin/protoc xed . + +# xcodebuild +env PROTOC_PATH=/opt/homebrew/bin/protoc xcodebuild +``` + +* Point the plugin to the concrete location of the `protoc` compiler is by changing +the configuration file. This is only advisable for applications and not libaries +since it forces the user of the library to install `protoc` into the expected location. + +```json +{ + "protocPath": "/path/to/protoc", + "invocations": [...] +} +``` + +### Known Issues + +- The configuration file _must not_ be excluded from the list of sources for the + target in the package manifest (that is, it should not be present in the + `exclude` argument for the target). The build system does not have access to + the file if it is excluded, however, `swift build` will result in a warning + that the file should be excluded. diff --git a/Sources/protoc-gen-swift/EnumGenerator.swift b/Sources/protoc-gen-swift/EnumGenerator.swift index 7b024b2e9..e5d31d32d 100644 --- a/Sources/protoc-gen-swift/EnumGenerator.swift +++ b/Sources/protoc-gen-swift/EnumGenerator.swift @@ -13,8 +13,8 @@ // ----------------------------------------------------------------------------- import Foundation -import SwiftProtobufPluginLibrary import SwiftProtobuf +import SwiftProtobufPluginLibrary /// The name of the case used to represent unrecognized values in proto3. /// This case has an associated value containing the raw integer value. @@ -22,241 +22,229 @@ private let unrecognizedCaseName = "UNRECOGNIZED" /// Generates a Swift enum from a protobuf enum descriptor. class EnumGenerator { - private let enumDescriptor: EnumDescriptor - private let generatorOptions: GeneratorOptions - private let namer: SwiftProtobufNamer - - /// The values that aren't aliases, as ordered in the .proto. - private let mainEnumValueDescriptors: [EnumValueDescriptor] - /// The values that aren't aliases, sorted by number. - private let mainEnumValueDescriptorsSorted: [EnumValueDescriptor] - - private let swiftRelativeName: String - private let swiftFullName: String - - init(descriptor: EnumDescriptor, - generatorOptions: GeneratorOptions, - namer: SwiftProtobufNamer - ) { - self.enumDescriptor = descriptor - self.generatorOptions = generatorOptions - self.namer = namer - - mainEnumValueDescriptors = descriptor.values.filter({ - return $0.aliasOf == nil - }) - mainEnumValueDescriptorsSorted = mainEnumValueDescriptors.sorted(by: { - return $0.number < $1.number - }) - - swiftRelativeName = namer.relativeName(enum: descriptor) - swiftFullName = namer.fullName(enum: descriptor) - } - - func generateMainEnum(printer p: inout CodePrinter) { - let visibility = generatorOptions.visibilitySourceSnippet - - p.print("\n") - p.print(enumDescriptor.protoSourceComments()) - p.print("\(visibility)enum \(swiftRelativeName): \(namer.swiftProtobufModuleName).Enum {\n") - p.indent() - p.print("\(visibility)typealias RawValue = Int\n") + // TODO: Move these conformances back onto the `Enum` protocol when we do a major release. + private static let requiredProtocolConformancesForEnums = ["Swift.CaseIterable"].joined(separator: ", ") + + private let enumDescriptor: EnumDescriptor + private let generatorOptions: GeneratorOptions + private let namer: SwiftProtobufNamer + + /// The aliasInfo for the values. + private let aliasInfo: EnumDescriptor.ValueAliasInfo + /// The values that aren't aliases, sorted by number. + private let mainEnumValueDescriptorsSorted: [EnumValueDescriptor] + + private let swiftRelativeName: String + private let swiftFullName: String + + init( + descriptor: EnumDescriptor, + generatorOptions: GeneratorOptions, + namer: SwiftProtobufNamer + ) { + self.enumDescriptor = descriptor + self.generatorOptions = generatorOptions + self.namer = namer + aliasInfo = EnumDescriptor.ValueAliasInfo(enumDescriptor: descriptor) + + mainEnumValueDescriptorsSorted = aliasInfo.mainValues.sorted(by: { + $0.number < $1.number + }) + + swiftRelativeName = namer.relativeName(enum: descriptor) + swiftFullName = namer.fullName(enum: descriptor) + } - // Cases/aliases - generateCasesOrAliases(printer: &p) + func generateMainEnum(printer p: inout CodePrinter) { + let visibility = generatorOptions.visibilitySourceSnippet - // Generate the default initializer. - p.print("\n") - p.print("\(visibility)init() {\n") - p.indent() - let dottedDefault = namer.dottedRelativeName(enumValue: enumDescriptor.defaultValue) - p.print("self = \(dottedDefault)\n") - p.outdent() - p.print("}\n") + p.print( + "", + "\(enumDescriptor.protoSourceCommentsWithDeprecation(generatorOptions: generatorOptions))\(visibility)enum \(swiftRelativeName): \(enumDescriptor.isClosed ? "Int, " : "")\(namer.swiftProtobufModulePrefix)Enum, \(Self.requiredProtocolConformancesForEnums) {" + ) + p.withIndentation { p in + if !enumDescriptor.isClosed { + p.print("\(visibility)typealias RawValue = Int") + } - p.print("\n") - generateInitRawValue(printer: &p) + // Cases/aliases + generateCasesOrAliases(printer: &p) - p.print("\n") - generateRawValueProperty(printer: &p) + // Generate the default initializer. + p.print( + "", + "\(visibility)init() {" + ) + p.printIndented("self = \(namer.dottedRelativeName(enumValue: enumDescriptor.values.first!))") + p.print("}") - p.outdent() - p.print("\n") - p.print("}\n") - } + if !enumDescriptor.isClosed { + p.print() + generateInitRawValue(printer: &p) - func generateCaseIterable( - printer p: inout CodePrinter, - includeGuards: Bool = true - ) { - // NOTE: When we can assume Swift 4.2, this should move from an extension - // to being directly done when declaring the type. + p.print() + generateRawValueProperty(printer: &p) + } - let visibility = generatorOptions.visibilitySourceSnippet + maybeGenerateCaseIterable(printer: &p) - p.print("\n") - if includeGuards { - p.print("#if swift(>=4.2)\n\n") - } - p.print("extension \(swiftFullName): CaseIterable {\n") - p.indent() - if enumDescriptor.hasUnknownPreservingSemantics { - p.print("// The compiler won't synthesize support with the \(unrecognizedCaseName) case.\n") - p.print("\(visibility)static var allCases: [\(swiftFullName)] = [\n") - for v in mainEnumValueDescriptors { - let dottedName = namer.dottedRelativeName(enumValue: v) - p.print(" \(dottedName),\n") - } - p.print("]\n") - } else { - p.print("// Support synthesized by the compiler.\n") - } - p.outdent() - p.print("}\n") - if includeGuards { - p.print("\n#endif // swift(>=4.2)\n") + } + p.print( + "", + "}" + ) } - } - - func generateSendable(printer p: inout CodePrinter) { - // Once our minimum supported version has Data be Sendable, @unchecked could be removed. - p.print("extension \(swiftFullName): @unchecked Sendable {}\n") - } - - func generateRuntimeSupport(printer p: inout CodePrinter) { - p.print("\n") - p.print("extension \(swiftFullName): \(namer.swiftProtobufModuleName)._ProtoNameProviding {\n") - p.indent() - generateProtoNameProviding(printer: &p) - p.outdent() - p.print("}\n") - } - /// Generates the cases or statics (for alias) for the values. - /// - /// - Parameter p: The code printer. - private func generateCasesOrAliases(printer p: inout CodePrinter) { - let visibility = generatorOptions.visibilitySourceSnippet - for enumValueDescriptor in namer.uniquelyNamedValues(enum: enumDescriptor) { - let comments = enumValueDescriptor.protoSourceComments() - if !comments.isEmpty { - p.print("\n", comments) - } - let relativeName = namer.relativeName(enumValue: enumValueDescriptor) - if let aliasOf = enumValueDescriptor.aliasOf { - let aliasOfName = namer.relativeName(enumValue: aliasOf) - p.print("\(visibility)static let \(relativeName) = \(aliasOfName)\n") - } else { - p.print("case \(relativeName) // = \(enumValueDescriptor.number)\n") - } - } - if enumDescriptor.hasUnknownPreservingSemantics { - p.print("case \(unrecognizedCaseName)(Int)\n") + func maybeGenerateCaseIterable(printer p: inout CodePrinter) { + guard !enumDescriptor.isClosed else { return } + + let visibility = generatorOptions.visibilitySourceSnippet + p.print( + "", + "// The compiler won't synthesize support with the \(unrecognizedCaseName) case.", + "\(visibility)static let allCases: [\(swiftFullName)] = [" + ) + p.withIndentation { p in + for v in aliasInfo.mainValues { + let dottedName = namer.dottedRelativeName(enumValue: v) + p.print("\(dottedName),") + } + } + p.print("]") } - } - /// Generates the mapping from case numbers to their text/JSON names. - /// - /// - Parameter p: The code printer. - private func generateProtoNameProviding(printer p: inout CodePrinter) { - let visibility = generatorOptions.visibilitySourceSnippet - - p.print("\(visibility)static let _protobuf_nameMap: \(namer.swiftProtobufModuleName)._NameMap = [\n") - p.indent() - for v in mainEnumValueDescriptorsSorted { - if v.aliases.isEmpty { - p.print("\(v.number): .same(proto: \"\(v.name)\"),\n") - } else { - let aliasNames = v.aliases.map({ "\"\($0.name)\"" }).joined(separator: ", ") - p.print("\(v.number): .aliased(proto: \"\(v.name)\", aliases: [\(aliasNames)]),\n") - } + func generateRuntimeSupport(printer p: inout CodePrinter) { + p.print( + "", + "extension \(swiftFullName): \(namer.swiftProtobufModulePrefix)_ProtoNameProviding {" + ) + p.withIndentation { p in + generateProtoNameProviding(printer: &p) + } + p.print("}") } - p.outdent() - p.print("]\n") - } - /// Generates `init?(rawValue:)` for the enum. - /// - /// - Parameter p: The code printer. - private func generateInitRawValue(printer p: inout CodePrinter) { - let visibility = generatorOptions.visibilitySourceSnippet - - p.print("\(visibility)init?(rawValue: Int) {\n") - p.indent() - p.print("switch rawValue {\n") - for v in mainEnumValueDescriptorsSorted { - let dottedName = namer.dottedRelativeName(enumValue: v) - p.print("case \(v.number): self = \(dottedName)\n") - } - if enumDescriptor.hasUnknownPreservingSemantics { - p.print("default: self = .\(unrecognizedCaseName)(rawValue)\n") - } else { - p.print("default: return nil\n") + /// Generates the cases or statics (for alias) for the values. + /// + /// - Parameter p: The code printer. + private func generateCasesOrAliases(printer p: inout CodePrinter) { + let visibility = generatorOptions.visibilitySourceSnippet + for enumValueDescriptor in namer.uniquelyNamedValues(valueAliasInfo: aliasInfo) { + let comments = enumValueDescriptor.protoSourceCommentsWithDeprecation(generatorOptions: generatorOptions) + if !comments.isEmpty { + p.print() + } + let relativeName = namer.relativeName(enumValue: enumValueDescriptor) + if let aliasOf = aliasInfo.original(of: enumValueDescriptor) { + let aliasOfName = namer.relativeName(enumValue: aliasOf) + p.print("\(comments)\(visibility)static let \(relativeName) = \(aliasOfName)") + } else if enumDescriptor.isClosed { + p.print("\(comments)case \(relativeName) = \(enumValueDescriptor.number)") + } else { + p.print("\(comments)case \(relativeName) // = \(enumValueDescriptor.number)") + } + } + if !enumDescriptor.isClosed { + p.print("case \(unrecognizedCaseName)(Int)") + } } - p.print("}\n") - p.outdent() - p.print("}\n") - } - /// Generates the `rawValue` property of the enum. - /// - /// - Parameter p: The code printer. - private func generateRawValueProperty(printer p: inout CodePrinter) { - let visibility = generatorOptions.visibilitySourceSnippet - - // See https://github.com/apple/swift-protobuf/issues/904 for the full - // details on why the default has to get added even though the switch - // is complete. - - // This is a "magic" value, currently picked based on the Swift 5.1 - // compiler, it will need ensure the warning doesn't trigger on all - // versions of the compiler, meaning if the error starts to show up - // again, all one can do is lower the limit. - let maxCasesInSwitch = 500 + /// Generates the mapping from case numbers to their text/JSON names. + /// + /// - Parameter p: The code printer. + private func generateProtoNameProviding(printer p: inout CodePrinter) { + let visibility = generatorOptions.visibilitySourceSnippet + + var writer = ProtoNameInstructionWriter() + for v in mainEnumValueDescriptorsSorted { + if let aliases = aliasInfo.aliases(v) { + writer.writeAliased(v, aliases: aliases) + } else { + writer.writeSame(number: v.number, name: v.name) + } + } + p.print( + "\(visibility)static let _protobuf_nameMap = \(namer.swiftProtobufModulePrefix)_NameMap(bytecode: \(writer.bytecode.stringLiteral))" + ) + } - let neededCases = mainEnumValueDescriptorsSorted.count + - (enumDescriptor.hasUnknownPreservingSemantics ? 1 : 0) - let useMultipleSwitches = neededCases > maxCasesInSwitch + /// Generates `init?(rawValue:)` for the enum. + /// + /// - Parameter p: The code printer. + private func generateInitRawValue(printer p: inout CodePrinter) { + let visibility = generatorOptions.visibilitySourceSnippet + + p.print("\(visibility)init?(rawValue: Int) {") + p.withIndentation { p in + p.print("switch rawValue {") + for v in mainEnumValueDescriptorsSorted { + let dottedName = namer.dottedRelativeName(enumValue: v) + p.print("case \(v.number): self = \(dottedName)") + } + if !enumDescriptor.isClosed { + p.print("default: self = .\(unrecognizedCaseName)(rawValue)") + } else { + p.print("default: return nil") + } + p.print("}") + } + p.print("}") + } - p.print("\(visibility)var rawValue: Int {\n") - p.indent() + /// Generates the `rawValue` property of the enum. + /// + /// - Parameter p: The code printer. + private func generateRawValueProperty(printer p: inout CodePrinter) { + let visibility = generatorOptions.visibilitySourceSnippet + + // See https://github.com/apple/swift-protobuf/issues/904 for full + // details on why maxCasesInSwitch is necessary. + let maxCasesInSwitch = generatorOptions.maxCasesInSwitch + let neededCases = mainEnumValueDescriptorsSorted.count + (enumDescriptor.isClosed ? 0 : 1) + let useMultipleSwitches = neededCases > maxCasesInSwitch + + p.print("\(visibility)var rawValue: Int {") + p.withIndentation { p in + if useMultipleSwitches { + for (i, v) in mainEnumValueDescriptorsSorted.enumerated() { + if (i % maxCasesInSwitch) == 0 { + if i > 0 { + p.print( + "default: break", + "}" + ) + } + p.print("switch self {") + } + let dottedName = namer.dottedRelativeName(enumValue: v) + p.print("case \(dottedName): return \(v.number)") + } + if !enumDescriptor.isClosed { + p.print("case .\(unrecognizedCaseName)(let i): return i") + } + p.print( + """ + default: break + } + + // Can't get here, all the cases are listed in the above switches. + // See https://github.com/apple/swift-protobuf/issues/904 for more details. + fatalError() + """ + ) + } else { + p.print("switch self {") + for v in mainEnumValueDescriptorsSorted { + let dottedName = namer.dottedRelativeName(enumValue: v) + p.print("case \(dottedName): return \(v.number)") + } + if !enumDescriptor.isClosed { + p.print("case .\(unrecognizedCaseName)(let i): return i") + } + p.print("}") + } - if useMultipleSwitches { - for (i, v) in mainEnumValueDescriptorsSorted.enumerated() { - if (i % maxCasesInSwitch) == 0 { - if i > 0 { - p.print( - "default: break\n", - "}\n") - } - p.print("switch self {\n") } - let dottedName = namer.dottedRelativeName(enumValue: v) - p.print("case \(dottedName): return \(v.number)\n") - } - if enumDescriptor.hasUnknownPreservingSemantics { - p.print("case .\(unrecognizedCaseName)(let i): return i\n") - } - p.print( - "default: break\n", - "}\n", - "\n", - "// Can't get here, all the cases are listed in the above switches.\n", - "// See https://github.com/apple/swift-protobuf/issues/904 for more details.\n", - "fatalError()\n") - } else { - p.print("switch self {\n") - for v in mainEnumValueDescriptorsSorted { - let dottedName = namer.dottedRelativeName(enumValue: v) - p.print("case \(dottedName): return \(v.number)\n") - } - if enumDescriptor.hasUnknownPreservingSemantics { - p.print("case .\(unrecognizedCaseName)(let i): return i\n") - } - p.print("}\n") + p.print("}") } - - p.outdent() - p.print("}\n") - } } diff --git a/Sources/protoc-gen-swift/ExtensionSetGenerator.swift b/Sources/protoc-gen-swift/ExtensionSetGenerator.swift index 09ff06717..0b30255bc 100644 --- a/Sources/protoc-gen-swift/ExtensionSetGenerator.swift +++ b/Sources/protoc-gen-swift/ExtensionSetGenerator.swift @@ -15,10 +15,10 @@ /// // ----------------------------------------------------------------------------- import Foundation -import SwiftProtobufPluginLibrary import SwiftProtobuf +import SwiftProtobufPluginLibrary -/// Provides the generation for proto2 syntax extensions in a file. +/// Provides the generation for extensions in a file. class ExtensionSetGenerator { /// Private helper used for the ExtensionSetGenerator. @@ -33,10 +33,12 @@ class ExtensionSetGenerator { var extensionFieldType: String { let label: String - switch fieldDescriptor.label { - case .optional: label = "Optional" - case .required: label = "Required" - case .repeated: label = fieldDescriptor.isPacked ? "Packed" : "Repeated" + if fieldDescriptor.isRequired { + label = "Required" + } else if fieldDescriptor.isRepeated { + label = fieldDescriptor.isPacked ? "Packed" : "Repeated" + } else { + label = "Optional" } let modifier: String @@ -47,7 +49,7 @@ class ExtensionSetGenerator { default: modifier = "" } - return "\(namer.swiftProtobufModuleName).\(label)\(modifier)ExtensionField" + return "\(namer.swiftProtobufModulePrefix)\(label)\(modifier)ExtensionField" } init(descriptor: FieldDescriptor, generatorOptions: GeneratorOptions, namer: SwiftProtobufNamer) { @@ -57,7 +59,7 @@ class ExtensionSetGenerator { swiftFullExtensionName = namer.fullName(extensionField: descriptor) - comments = descriptor.protoSourceComments() + comments = descriptor.protoSourceCommentsWithDeprecation(generatorOptions: generatorOptions) containingTypeSwiftFullName = namer.fullName(message: fieldDescriptor.containingType) } @@ -68,26 +70,23 @@ class ExtensionSetGenerator { let swiftRelativeExtensionName = namer.relativeName(extensionField: fieldDescriptor) var fieldNamePath: String - if fieldDescriptor.containingType.useMessageSetWireFormat && - fieldDescriptor.type == .message && - fieldDescriptor.label == .optional && - fieldDescriptor.messageType === fieldDescriptor.extensionScope { - fieldNamePath = fieldDescriptor.messageType.fullName + if fieldDescriptor.containingType.useMessageSetWireFormat && fieldDescriptor.type == .message + && (!fieldDescriptor.isRepeated && !fieldDescriptor.isRequired) + && fieldDescriptor.messageType === fieldDescriptor.extensionScope + { + fieldNamePath = fieldDescriptor.messageType!.fullName } else { fieldNamePath = fieldDescriptor.fullName } - assert(fieldNamePath.hasPrefix(".")) - fieldNamePath.remove(at: fieldNamePath.startIndex) // Remove the leading '.' p.print( - comments, - "\(visibility)\(scope)let \(swiftRelativeExtensionName) = \(namer.swiftProtobufModuleName).MessageExtension<\(extensionFieldType)<\(traitsType)>, \(containingTypeSwiftFullName)>(\n") - p.indent() - p.print( - "_protobuf_fieldNumber: \(fieldDescriptor.number),\n", - "fieldName: \"\(fieldNamePath)\"\n") - p.outdent() - p.print(")\n") + "\(comments)\(visibility)\(scope)let \(swiftRelativeExtensionName) = \(namer.swiftProtobufModulePrefix)MessageExtension<\(extensionFieldType)<\(traitsType)>, \(containingTypeSwiftFullName)>(" + ) + p.printIndented( + "_protobuf_fieldNumber: \(fieldDescriptor.number),", + "fieldName: \"\(fieldNamePath)\"" + ) + p.print(")") } func generateMessageSwiftExtension(printer p: inout CodePrinter) { @@ -99,31 +98,33 @@ class ExtensionSetGenerator { // ExtensionSetGenerator provides the context to write out the properties. p.print( - "\n", - comments, - "\(visibility)var \(extensionNames.value): \(apiType) {\n") - p.indent() - p.print( - "get {return getExtensionValue(ext: \(swiftFullExtensionName)) ?? \(defaultValue)}\n", - "set {setExtensionValue(ext: \(swiftFullExtensionName), value: newValue)}\n") - p.outdent() - p.print("}\n") - - p.print( - "/// Returns true if extension `\(swiftFullExtensionName)`\n/// has been explicitly set.\n", - "\(visibility)var \(extensionNames.has): Bool {\n") - p.indent() - p.print("return hasExtensionValue(ext: \(swiftFullExtensionName))\n") - p.outdent() - p.print("}\n") + "", + "\(comments)\(visibility)var \(extensionNames.value): \(apiType) {" + ) + p.printIndented( + "get {return getExtensionValue(ext: \(swiftFullExtensionName)) ?? \(defaultValue)}", + "set {setExtensionValue(ext: \(swiftFullExtensionName), value: newValue)}" + ) + p.print("}") + + // Repeated extension fields can use .isEmpty and clear by setting to the empty list. + // Everything else gets a "has" helper. + if !fieldDescriptor.isRepeated { + p.print( + "/// Returns true if extension `\(swiftFullExtensionName)`\n/// has been explicitly set.", + "\(visibility)var \(extensionNames.has): Bool {" + ) + p.printIndented("return hasExtensionValue(ext: \(swiftFullExtensionName))") + p.print("}") - p.print( - "/// Clears the value of extension `\(swiftFullExtensionName)`.\n/// Subsequent reads from it will return its default value.\n", - "\(visibility)mutating func \(extensionNames.clear)() {\n") - p.indent() - p.print("clearExtensionValue(ext: \(swiftFullExtensionName))\n") - p.outdent() - p.print("}\n") + p.print( + "/// Clears the value of extension `\(swiftFullExtensionName)`.", + "/// Subsequent reads from it will return its default value.", + "\(visibility)mutating func \(extensionNames.clear)() {" + ) + p.printIndented("clearExtensionValue(ext: \(swiftFullExtensionName))") + p.print("}") + } } } @@ -135,12 +136,12 @@ class ExtensionSetGenerator { // where they were declared. private var extensions: [ExtensionGenerator] = [] - var isEmpty: Bool { return extensions.isEmpty } + var isEmpty: Bool { extensions.isEmpty } init( - fileDescriptor: FileDescriptor, - generatorOptions: GeneratorOptions, - namer: SwiftProtobufNamer + fileDescriptor: FileDescriptor, + generatorOptions: GeneratorOptions, + namer: SwiftProtobufNamer ) { self.fileDescriptor = fileDescriptor self.generatorOptions = generatorOptions @@ -149,10 +150,11 @@ class ExtensionSetGenerator { func add(extensionFields: [FieldDescriptor]) { for e in extensionFields { - assert(e.isExtension) - let extensionGenerator = ExtensionGenerator(descriptor: e, - generatorOptions: generatorOptions, - namer: namer) + let extensionGenerator = ExtensionGenerator( + descriptor: e, + generatorOptions: generatorOptions, + namer: namer + ) extensions.append(extensionGenerator) } } @@ -161,13 +163,16 @@ class ExtensionSetGenerator { guard !extensions.isEmpty else { return } p.print( - "\n", - "// MARK: - Extension Properties\n", - "\n", - "// Swift Extensions on the exteneded Messages to add easy access to the declared\n", - "// extension fields. The names are based on the extension field name from the proto\n", - "// declaration. To avoid naming collisions, the names are prefixed with the name of\n", - "// the scope where the extend directive occurs.\n") + """ + + // MARK: - Extension Properties + + // Swift Extensions on the extended 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. + """ + ) // Reorder the list so they are grouped by the Message being extended, but // maintaining the order they were within the file within those groups. @@ -181,7 +186,7 @@ class ExtensionSetGenerator { }.map { // Now strip off the original index to just get the list of ExtensionGenerators // again. - return $0.element + $0.element } // Loop through the group list and each time a new containing type is hit, @@ -193,88 +198,95 @@ class ExtensionSetGenerator { if currentType != e.containingTypeSwiftFullName { if !currentType.isEmpty { p.outdent() - p.print("}\n") + p.print("}") } currentType = e.containingTypeSwiftFullName p.print( - "\n", - "extension \(currentType) {\n") + "", + "extension \(currentType) {" + ) p.indent() } e.generateMessageSwiftExtension(printer: &p) } p.outdent() p.print( - "\n", - "}\n") + "", + "}" + ) } func generateFileProtobufExtensionRegistry(printer p: inout CodePrinter) { guard !extensions.isEmpty else { return } let pathParts = splitPath(pathname: fileDescriptor.name) - let filenameAsIdentifer = NamingUtils.toUpperCamelCase(pathParts.base) + let filenameAsIdentifier = NamingUtils.toUpperCamelCase(pathParts.base) let filePrefix = namer.typePrefix(forFile: fileDescriptor) p.print( - "\n", - "// MARK: - File's ExtensionMap: \(filePrefix)\(filenameAsIdentifer)_Extensions\n", - "\n", - "/// A `SwiftProtobuf.SimpleExtensionMap` that includes all of the extensions defined by\n", - "/// this .proto file. It can be used any place an `SwiftProtobuf.ExtensionMap` is needed\n", - "/// in parsing, or it can be combined with other `SwiftProtobuf.SimpleExtensionMap`s to create\n", - "/// a larger `SwiftProtobuf.SimpleExtensionMap`.\n", - "\(generatorOptions.visibilitySourceSnippet)let \(filePrefix)\(filenameAsIdentifer)_Extensions: \(namer.swiftProtobufModuleName).SimpleExtensionMap = [\n") - p.indent() - var separator = "" - for e in extensions { - p.print(separator, e.swiftFullExtensionName) - separator = ",\n" + """ + + // MARK: - File's ExtensionMap: \(filePrefix)\(filenameAsIdentifier)_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`. + \(generatorOptions.visibilitySourceSnippet)let \(filePrefix)\(filenameAsIdentifier)_Extensions: \(namer.swiftProtobufModulePrefix)SimpleExtensionMap = [ + """ + ) + p.withIndentation { p in + let lastIndex = extensions.count - 1 + for (i, e) in extensions.enumerated() { + p.print("\(e.swiftFullExtensionName)\(i != lastIndex ? "," : "")") + } } - p.print("\n") - p.outdent() - p.print("]\n") + p.print("]") } func generateProtobufExtensionDeclarations(printer p: inout CodePrinter) { - guard !extensions.isEmpty else { return } - - p.print( - "\n", - "// Extension Objects - The only reason these might be needed is when manually\n", - "// constructing a `SimpleExtensionMap`, otherwise, use the above _Extension Properties_\n", - "// accessors for the extension fields on the messages directly.\n") - - func endScope() { - p.outdent() - p.print("}\n") - p.outdent() - p.print("}\n") - } - - let visibility = generatorOptions.visibilitySourceSnippet - var currentScope: Descriptor? = nil - var addNewline = true - for e in extensions { - if currentScope !== e.fieldDescriptor.extensionScope { - if currentScope != nil { endScope() } - currentScope = e.fieldDescriptor.extensionScope - let scopeSwiftFullName = namer.fullName(message: currentScope!) - p.print( - "\n", - "extension \(scopeSwiftFullName) {\n") - p.indent() - p.print("\(visibility)enum Extensions {\n") - p.indent() - addNewline = false + guard !extensions.isEmpty else { return } + + p.print( + """ + + // 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. + """ + ) + + func endScope() { + p.outdent() + p.print("}") + p.outdent() + p.print("}") } - if addNewline { - p.print("\n") - } else { - addNewline = true + let visibility = generatorOptions.visibilitySourceSnippet + var currentScope: Descriptor? = nil + var addNewline = true + for e in extensions { + if currentScope !== e.fieldDescriptor.extensionScope { + if currentScope != nil { endScope() } + currentScope = e.fieldDescriptor.extensionScope + let scopeSwiftFullName = namer.fullName(message: currentScope!) + p.print( + "", + "extension \(scopeSwiftFullName) {" + ) + p.indent() + p.print("\(visibility)enum Extensions {") + p.indent() + addNewline = false + } + + if addNewline { + p.print() + } else { + addNewline = true + } + e.generateProtobufExtensionDeclarations(printer: &p) } - e.generateProtobufExtensionDeclarations(printer: &p) - } - if currentScope != nil { endScope() } + if currentScope != nil { endScope() } } } diff --git a/Sources/protoc-gen-swift/FieldGenerator.swift b/Sources/protoc-gen-swift/FieldGenerator.swift index 2dfa5efbf..be8e695cc 100644 --- a/Sources/protoc-gen-swift/FieldGenerator.swift +++ b/Sources/protoc-gen-swift/FieldGenerator.swift @@ -14,88 +14,94 @@ // ----------------------------------------------------------------------------- import Foundation -import SwiftProtobufPluginLibrary import SwiftProtobuf - +import SwiftProtobufPluginLibrary /// Interface for field generators. protocol FieldGenerator { - var number: Int { get } + var number: Int { get } - /// Name mapping entry for the field. - var fieldMapNames: String { get } + /// Writes the field's name information to the given bytecode stream. + func writeProtoNameInstruction(to writer: inout ProtoNameInstructionWriter) - /// Generate the interface for this field, this is includes any extra methods (has/clear). - func generateInterface(printer: inout CodePrinter) + /// Generate the interface for this field, this is includes any extra methods (has/clear). + func generateInterface(printer: inout CodePrinter) - /// Generate any additional storage needed for this field. - func generateStorage(printer: inout CodePrinter) + /// Generate any additional storage needed for this field. + func generateStorage(printer: inout CodePrinter) - /// Generate the line to copy this field during a _StorageClass clone. - func generateStorageClassClone(printer: inout CodePrinter) + /// Generate the line to copy this field during a _StorageClass clone. + func generateStorageClassClone(printer: inout CodePrinter) - /// Generate the case and decoder invoke needed for this field. - func generateDecodeFieldCase(printer: inout CodePrinter) + /// Generate the case and decoder invoke needed for this field. + func generateDecodeFieldCase(printer: inout CodePrinter) - /// True/False for if the generated traverse code will need use any locals. - /// See https://github.com/apple/swift-protobuf/issues/1034 and - /// https://github.com/apple/swift-protobuf/issues/1182 for more information. - var generateTraverseUsesLocals: Bool { get } + /// True/False for if the generated traverse code will need use any locals. + /// See https://github.com/apple/swift-protobuf/issues/1034 and + /// https://github.com/apple/swift-protobuf/issues/1182 for more information. + var generateTraverseUsesLocals: Bool { get } - /// Generate the support for traversing this field. - func generateTraverse(printer: inout CodePrinter) + /// Generate the support for traversing this field. + func generateTraverse(printer: inout CodePrinter) - /// Generate support for comparing this field's value. - /// The generated code should return false in the current scope if the field's don't match. - func generateFieldComparison(printer: inout CodePrinter) + /// Generate support for comparing this field's value. + /// The generated code should return false in the current scope if the field's don't match. + func generateFieldComparison(printer: inout CodePrinter) - /// Generate any support needed to ensure required fields are set. - /// The generated code should return false the field isn't set. - func generateRequiredFieldCheck(printer: inout CodePrinter) + /// Generate any support needed to ensure required fields are set. + /// The generated code should return false the field isn't set. + func generateRequiredFieldCheck(printer: inout CodePrinter) - /// Generate any support needed to this field's value is initialized. - /// The generated code should return false if it isn't set. - func generateIsInitializedCheck(printer: inout CodePrinter) + /// Generate any support needed to this field's value is initialized. + /// The generated code should return false if it isn't set. + func generateIsInitializedCheck(printer: inout CodePrinter) } -/// Simple base class for FieldGenerators that also provides fieldMapNames. +/// Simple base class for FieldGenerators that also provides `writeProtoNameInstruction(to:)`. class FieldGeneratorBase { - let number: Int - let fieldDescriptor: FieldDescriptor - - var fieldMapNames: String { - // Protobuf Text uses the unqualified group name for the field - // name instead of the field name provided by protoc. As far - // as I can tell, no one uses the fieldname provided by protoc, - // so let's just put the field name that Protobuf Text - // actually uses here. - let protoName: String - if fieldDescriptor.type == .group { - protoName = fieldDescriptor.messageType.name - } else { - protoName = fieldDescriptor.name + let number: Int + let fieldDescriptor: FieldDescriptor + + func writeProtoNameInstruction(to writer: inout ProtoNameInstructionWriter) { + // Protobuf Text uses the unqualified group name for the field + // name instead of the field name provided by protoc. As far + // as I can tell, no one uses the fieldname provided by protoc, + // so let's just put the field name that Protobuf Text + // actually uses here. + let protoName: String + if fieldDescriptor.isGroupLike { + protoName = fieldDescriptor.messageType!.name + } else { + protoName = fieldDescriptor.name + } + let jsonName = fieldDescriptor.jsonName + + if fieldDescriptor.isGroupLike { + // This behavior is guaranteed by the spec/proto compiler, so we + // rely on it. Fail if this is ever not the case. + assert( + jsonName == protoName.lowercased(), + "The JSON name of a group should always be the lowercased message name" + ) + writer.writeGroup(number: Int32(number), name: protoName) + } else if jsonName == protoName { + // The proto and JSON names are identical. + writer.writeSame(number: Int32(number), name: protoName) + } else { + let libraryGeneratedJsonName = NamingUtils.toJsonFieldName(protoName) + if jsonName == libraryGeneratedJsonName { + // The library will generate the same thing protoc gave, so + // we can let the library recompute this. + writer.writeStandard(number: Int32(number), name: protoName) + } else { + // The library's generation didn't match, so specify this explicitly. + writer.writeUnique(number: Int32(number), protoName: protoName, jsonName: jsonName) + } + } } - let jsonName = fieldDescriptor.jsonName ?? protoName - if jsonName == protoName { - /// The proto and JSON names are identical: - return ".same(proto: \"\(protoName)\")" - } else { - let libraryGeneratedJsonName = NamingUtils.toJsonFieldName(protoName) - if jsonName == libraryGeneratedJsonName { - /// The library will generate the same thing protoc gave, so - /// we can let the library recompute this: - return ".standard(proto: \"\(protoName)\")" - } else { - /// The library's generation didn't match, so specify this explicitly. - return ".unique(proto: \"\(protoName)\", json: \"\(jsonName)\")" - } + init(descriptor: FieldDescriptor) { + number = Int(descriptor.number) + fieldDescriptor = descriptor } - } - - init(descriptor: FieldDescriptor) { - precondition(!descriptor.isExtension) - number = Int(descriptor.number) - fieldDescriptor = descriptor - } } diff --git a/Sources/protoc-gen-swift/FileGenerator.swift b/Sources/protoc-gen-swift/FileGenerator.swift index 87c05aa71..7554cd6d7 100644 --- a/Sources/protoc-gen-swift/FileGenerator.swift +++ b/Sources/protoc-gen-swift/FileGenerator.swift @@ -15,9 +15,8 @@ /// // ----------------------------------------------------------------------------- import Foundation -import SwiftProtobufPluginLibrary import SwiftProtobuf - +import SwiftProtobufPluginLibrary class FileGenerator { private let fileDescriptor: FileDescriptor @@ -39,33 +38,46 @@ class FileGenerator { } } - init(fileDescriptor: FileDescriptor, - generatorOptions: GeneratorOptions) { + init( + fileDescriptor: FileDescriptor, + generatorOptions: GeneratorOptions + ) { self.fileDescriptor = fileDescriptor self.generatorOptions = generatorOptions - namer = SwiftProtobufNamer(currentFile: fileDescriptor, - protoFileToModuleMappings: generatorOptions.protoToModuleMappings) + namer = SwiftProtobufNamer( + currentFile: fileDescriptor, + protoFileToModuleMappings: generatorOptions.protoToModuleMappings + ) } /// Generate, if `errorString` gets filled in, then report error instead of using /// what written into `printer`. func generateOutputFile(printer p: inout CodePrinter, errorString: inout String?) { - guard fileDescriptor.fileOptions.swiftPrefix.isEmpty || - isValidSwiftIdentifier(fileDescriptor.fileOptions.swiftPrefix, - allowQuoted: false) else { - errorString = "\(fileDescriptor.name) has an 'swift_prefix' that isn't a valid Swift identifier (\(fileDescriptor.fileOptions.swiftPrefix))." - return + guard + fileDescriptor.options.swiftPrefix.isEmpty + || isValidSwiftIdentifier( + fileDescriptor.options.swiftPrefix, + allowQuoted: false + ) + else { + errorString = + "\(fileDescriptor.name) has an 'swift_prefix' that isn't a valid Swift identifier (\(fileDescriptor.options.swiftPrefix))." + return } p.print( - "// DO NOT EDIT.\n", - "// swift-format-ignore-file\n", - "//\n", - "// Generated by the Swift generator plugin for the protocol buffer compiler.\n", - "// Source: \(fileDescriptor.name)\n", - "//\n", - "// For information on using the generated types, please see the documentation:\n", - "// https://github.com/apple/swift-protobuf/\n", - "\n") + """ + // DO NOT EDIT. + // swift-format-ignore-file + // swiftlint:disable all + // + // Generated by the Swift generator plugin for the protocol buffer compiler. + // Source: \(fileDescriptor.name) + // + // For information on using the generated types, please see the documentation: + // https://github.com/apple/swift-protobuf/ + + """ + ) // Attempt to bring over the comments at the top of the .proto file as // they likely contain copyrights/preamble/etc. @@ -73,94 +85,113 @@ class FileGenerator { // The C++ FileDescriptor::GetSourceLocation(), says the location for // the file is an empty path. That never seems to have comments on it. // https://github.com/protocolbuffers/protobuf/issues/2249 opened to - // figure out the right way to do this since the syntax entry is - // optional. + // figure out the right way to do this but going forward best bet seems + // to be to look for the "edition" or the "syntax" decl. + let editionPath = IndexPath(index: Google_Protobuf_FileDescriptorProto.FieldNumbers.edition) let syntaxPath = IndexPath(index: Google_Protobuf_FileDescriptorProto.FieldNumbers.syntax) - if let syntaxLocation = fileDescriptor.sourceCodeInfoLocation(path: syntaxPath) { - let comments = syntaxLocation.asSourceComment(commentPrefix: "///", - leadingDetachedPrefix: "//") - if !comments.isEmpty { - p.print(comments) - // If the was a leading or tailing comment it won't have a blank - // line, after it, so ensure there is one. - if !comments.hasSuffix("\n\n") { - p.print("\n") - } - } + var commentLocation: Google_Protobuf_SourceCodeInfo.Location? = nil + if self.generatorOptions.experimentalStripNonfunctionalCodegen { + // Comments are inherently non-functional, and may change subtly on + // transformations. + } else if let location = fileDescriptor.sourceCodeInfoLocation(path: editionPath) { + commentLocation = location + } else if let location = fileDescriptor.sourceCodeInfoLocation(path: syntaxPath) { + commentLocation = location + } + if let commentLocation = commentLocation { + let comments = commentLocation.asSourceComment( + commentPrefix: "///", + leadingDetachedPrefix: "//" + ) + if !comments.isEmpty { + // If the was a leading or tailing comment it won't have a blank + // line, after it, so ensure there is one. + p.print(comments, newlines: !comments.hasSuffix("\n\n")) + } } - p.print("import Foundation\n") - if !fileDescriptor.isBundledProto { - // The well known types ship with the runtime, everything else needs - // to import the runtime. - p.print("import \(namer.swiftProtobufModuleName)\n") + let fileDefinesTypes = + !fileDescriptor.enums.isEmpty || !fileDescriptor.messages.isEmpty || !fileDescriptor.extensions.isEmpty + + var hasImports = false + if fileDescriptor.needsFoundationImport { + p.print("\(generatorOptions.importDirective.snippet) Foundation") + hasImports = true } - if let neededImports = generatorOptions.protoToModuleMappings.neededModules(forFile: fileDescriptor) { - p.print("\n") - for i in neededImports { - p.print("import \(i)\n") + + if fileDescriptor.isBundledProto { + p.print( + "// 'import \(namer.swiftProtobufModuleName)' suppressed, this proto file is meant to be bundled in the runtime." + ) + hasImports = true + } else if fileDefinesTypes { + p.print("\(generatorOptions.importDirective.snippet) \(namer.swiftProtobufModuleName)") + hasImports = true + } + + let neededImports = fileDescriptor.computeImports( + namer: namer, + directive: generatorOptions.importDirective, + reexportPublicImports: generatorOptions.visibility != .internal + ) + if !neededImports.isEmpty { + if hasImports { + p.print() } + p.print(neededImports) + hasImports = true } - p.print("\n") + // If there is nothing to generate, then just record that and be done (usually means + // there just was one or more services). + guard fileDefinesTypes else { + if hasImports { + p.print() + } + p.print("// This file contained no messages, enums, or extensions.") + return + } + + p.print() generateVersionCheck(printer: &p) let extensionSet = - ExtensionSetGenerator(fileDescriptor: fileDescriptor, - generatorOptions: generatorOptions, - namer: namer) + ExtensionSetGenerator( + fileDescriptor: fileDescriptor, + generatorOptions: generatorOptions, + namer: namer + ) extensionSet.add(extensionFields: fileDescriptor.extensions) let enums = fileDescriptor.enums.map { - return EnumGenerator(descriptor: $0, generatorOptions: generatorOptions, namer: namer) + EnumGenerator(descriptor: $0, generatorOptions: generatorOptions, namer: namer) } let messages = fileDescriptor.messages.map { - return MessageGenerator(descriptor: $0, - generatorOptions: generatorOptions, - namer: namer, - extensionSet: extensionSet) + MessageGenerator( + descriptor: $0, + generatorOptions: generatorOptions, + namer: namer, + extensionSet: extensionSet + ) } for e in enums { e.generateMainEnum(printer: &p) - e.generateCaseIterable(printer: &p) } for m in messages { m.generateMainStruct(printer: &p, parent: nil, errorString: &errorString) - - var caseIterablePrinter = CodePrinter() - m.generateEnumCaseIterable(printer: &caseIterablePrinter) - if !caseIterablePrinter.isEmpty { - p.print("\n#if swift(>=4.2)\n") - p.print(caseIterablePrinter.content) - p.print("\n#endif // swift(>=4.2)\n") - } - } - - var sendablePrinter = CodePrinter() - for e in enums { - e.generateSendable(printer: &sendablePrinter) - } - - for m in messages { - m.generateSendable(printer: &sendablePrinter) - } - - if !sendablePrinter.isEmpty { - p.print("\n#if swift(>=5.5) && canImport(_Concurrency)\n") - p.print(sendablePrinter.content) - p.print("#endif // swift(>=5.5) && canImport(_Concurrency)\n") } if !extensionSet.isEmpty { let pathParts = splitPath(pathname: fileDescriptor.name) let filename = pathParts.base + pathParts.suffix p.print( - "\n", - "// MARK: - Extension support defined in \(filename).\n") + "", + "// MARK: - Extension support defined in \(filename)." + ) // Generate the Swift Extensions on the Messages that provide the api // for using the protobuf extension. @@ -181,12 +212,14 @@ class FileGenerator { let needsProtoPackage: Bool = !protoPackage.isEmpty && !messages.isEmpty if needsProtoPackage || !enums.isEmpty || !messages.isEmpty { p.print( - "\n", - "// MARK: - Code below here is support for the SwiftProtobuf runtime.\n") + "", + "// MARK: - Code below here is support for the SwiftProtobuf runtime." + ) if needsProtoPackage { p.print( - "\n", - "fileprivate let _protobuf_package = \"\(protoPackage)\"\n") + "", + "fileprivate let _protobuf_package = \"\(protoPackage)\"" + ) } for e in enums { e.generateRuntimeSupport(printer: &p) @@ -200,17 +233,19 @@ class FileGenerator { private func generateVersionCheck(printer p: inout CodePrinter) { let v = Version.compatibilityVersion p.print( - "// If the compiler emits an error on this type, it is because this file\n", - "// was generated by a version of the `protoc` Swift plug-in that is\n", - "// incompatible with the version of SwiftProtobuf to which you are linking.\n", - "// Please ensure that you are building against the same version of the API\n", - "// that was used to generate this file.\n", - "fileprivate struct _GeneratedWithProtocGenSwiftVersion: \(namer.swiftProtobufModuleName).ProtobufAPIVersionCheck {\n") - p.indent() - p.print( - "struct _\(v): \(namer.swiftProtobufModuleName).ProtobufAPIVersion_\(v) {}\n", - "typealias Version = _\(v)\n") - p.outdent() - p.print("}\n") + """ + // 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: \(namer.swiftProtobufModulePrefix)ProtobufAPIVersionCheck { + """ + ) + p.printIndented( + "struct _\(v): \(namer.swiftProtobufModulePrefix)ProtobufAPIVersion_\(v) {}", + "typealias Version = _\(v)" + ) + p.print("}") } } diff --git a/Sources/protoc-gen-swift/FileIo.swift b/Sources/protoc-gen-swift/FileIo.swift index d6c551dee..67321bb39 100644 --- a/Sources/protoc-gen-swift/FileIo.swift +++ b/Sources/protoc-gen-swift/FileIo.swift @@ -15,12 +15,12 @@ import Foundation class Stderr { - static func print(_ s: String) { - let out = "\(CommandLine.programName): \(s)\n" - if let data = out.data(using: .utf8) { - FileHandle.standardError.write(data) + static func print(_ s: String) { + let out = "\(CommandLine.programName): \(s)\n" + if let data = out.data(using: .utf8) { + FileHandle.standardError.write(data) + } } - } } func readFileData(filename: String) throws -> Data { diff --git a/Sources/protoc-gen-swift/GenerationError.swift b/Sources/protoc-gen-swift/GenerationError.swift index 2ebf4e2a6..b9578b20c 100644 --- a/Sources/protoc-gen-swift/GenerationError.swift +++ b/Sources/protoc-gen-swift/GenerationError.swift @@ -8,11 +8,26 @@ // // ----------------------------------------------------------------------------- -enum GenerationError: Error { - /// Raised when parsing the parameter string and found an unknown key - case unknownParameter(name: String) - /// Raised when a parameter was giving an invalid value - case invalidParameterValue(name: String, value: String) - /// Raised to wrap another error but provide a context message. - case wrappedError(message: String, error: Error) +enum GenerationError: Error, CustomStringConvertible { + /// Raised when parsing the parameter string and found an unknown key. + case unknownParameter(name: String) + /// Raised when a parameter was given an invalid value. + case invalidParameterValue(name: String, value: String) + /// Raised to wrap another error but provide a context message. + case wrappedError(message: String, error: any Error) + /// Raised with an specific message + case message(message: String) + + var description: String { + switch self { + case .unknownParameter(let name): + return "Unknown generation parameter '\(name)'" + case .invalidParameterValue(let name, let value): + return "Unknown value for generation parameter '\(name)': '\(value)'" + case .wrappedError(let message, let error): + return "\(message): \(error)" + case .message(let message): + return message + } + } } diff --git a/Sources/protoc-gen-swift/GeneratorOptions.swift b/Sources/protoc-gen-swift/GeneratorOptions.swift index 5b0380e3f..ed9f0d0d2 100644 --- a/Sources/protoc-gen-swift/GeneratorOptions.swift +++ b/Sources/protoc-gen-swift/GeneratorOptions.swift @@ -10,86 +10,229 @@ import SwiftProtobufPluginLibrary -class GeneratorOptions { - enum OutputNaming : String { - case fullPath = "FullPath" - case pathToUnderscores = "PathToUnderscores" - case dropPath = "DropPath" - } - - enum Visibility : String { - case `internal` = "Internal" - case `public` = "Public" - } - - let outputNaming: OutputNaming - let protoToModuleMappings: ProtoFileToModuleMappings - let visibility: Visibility - - /// A string snippet to insert for the visibility - let visibilitySourceSnippet: String - - init(parameter: String?) throws { - var outputNaming: OutputNaming = .fullPath - var moduleMapPath: String? - var visibility: Visibility = .internal - var swiftProtobufModuleName: String? = nil - - for pair in parseParameter(string:parameter) { - switch pair.key { - case "FileNaming": - if let naming = OutputNaming(rawValue: pair.value) { - outputNaming = naming - } else { - throw GenerationError.invalidParameterValue(name: pair.key, - value: pair.value) +package class GeneratorOptions { + enum OutputNaming { + case fullPath + case pathToUnderscores + case dropPath + + init?(flag: String) { + switch flag.lowercased() { + case "fullpath", "full_path": + self = .fullPath + case "pathtounderscores", "path_to_underscores": + self = .pathToUnderscores + case "droppath", "drop_path": + self = .dropPath + default: + return nil + } } - case "ProtoPathModuleMappings": - if !pair.value.isEmpty { - moduleMapPath = pair.value + } + + package enum Visibility: String { + case `internal` + case `public` + case `package` + + init?(flag: String) { + self.init(rawValue: flag.lowercased()) } - case "Visibility": - if let value = Visibility(rawValue: pair.value) { - visibility = value - } else { - throw GenerationError.invalidParameterValue(name: pair.key, - value: pair.value) + } + + package enum ImportDirective: Equatable { + case accessLevel(Visibility) + case plain + case implementationOnly + + var isAccessLevel: Bool { + switch self { + case .accessLevel: return true + default: return false + } } - case "SwiftProtobufModuleName": - // This option is not documented in PLUGIN.md, because it's a feature - // that would ordinarily not be required for a given adopter. - if isValidSwiftIdentifier(pair.value) { - swiftProtobufModuleName = pair.value - } else { - throw GenerationError.invalidParameterValue(name: pair.key, - value: pair.value) + + var snippet: String { + switch self { + case let .accessLevel(visibility): + return "\(visibility.rawValue) import" + case .plain: + return "import" + case .implementationOnly: + return "@_implementationOnly import" + } } - default: - throw GenerationError.unknownParameter(name: pair.key) - } } - if let moduleMapPath = moduleMapPath { - do { - self.protoToModuleMappings = try ProtoFileToModuleMappings(path: moduleMapPath, swiftProtobufModuleName: swiftProtobufModuleName) - } catch let e { - throw GenerationError.wrappedError( - message: "Parameter 'ProtoPathModuleMappings=\(moduleMapPath)'", - error: e) - } - } else { - self.protoToModuleMappings = ProtoFileToModuleMappings(swiftProtobufModuleName: swiftProtobufModuleName) - } + let outputNaming: OutputNaming + let protoToModuleMappings: ProtoFileToModuleMappings + let visibility: Visibility + let importDirective: ImportDirective + let experimentalStripNonfunctionalCodegen: Bool - self.outputNaming = outputNaming - self.visibility = visibility + // The Swift compiler may fail when checking whether large switch statements + // are exhaustive. See + // https://github.com/apple/swift-protobuf/issues/904 + // https://github.com/apple/swift-protobuf/issues/1856 + // for more details. + // This is a "magic" value, currently picked based on the Swift 6.2 + // compiler, meaning if the error starts to show up + // again, all one can do is lower the limit. + let maxCasesInSwitch = 500 - switch visibility { - case .internal: - visibilitySourceSnippet = "" - case .public: - visibilitySourceSnippet = "public " - } + /// A string snippet to insert for the visibility + let visibilitySourceSnippet: String + + init(parameter: any CodeGeneratorParameter) throws { + var outputNaming: OutputNaming = .fullPath + var moduleMapPath: String? + var visibility: Visibility = .internal + var swiftProtobufModuleName: String? = nil + var implementationOnlyImports: Bool = false + var useAccessLevelOnImports = false + var experimentalStripNonfunctionalCodegen: Bool = false - } + for pair in parameter.parsedPairs { + switch pair.key { + case "FileNaming": + if let naming = OutputNaming(flag: pair.value) { + outputNaming = naming + } else { + throw GenerationError.invalidParameterValue( + name: pair.key, + value: pair.value + ) + } + case "ProtoPathModuleMappings": + if !pair.value.isEmpty { + moduleMapPath = pair.value + } + case "Visibility": + if let value = Visibility(flag: pair.value) { + visibility = value + } else { + throw GenerationError.invalidParameterValue( + name: pair.key, + value: pair.value + ) + } + case "SwiftProtobufModuleName": + // This option is not documented in PLUGIN.md, because it's a feature + // that would ordinarily not be required for a given adopter. + if isValidSwiftIdentifier(pair.value) { + swiftProtobufModuleName = pair.value + } else { + throw GenerationError.invalidParameterValue( + name: pair.key, + value: pair.value + ) + } + case "ImplementationOnlyImports": + if let value = Bool(pair.value) { + implementationOnlyImports = value + } else { + throw GenerationError.invalidParameterValue( + name: pair.key, + value: pair.value + ) + } + case "UseAccessLevelOnImports": + if let value = Bool(pair.value) { + useAccessLevelOnImports = value + } else { + throw GenerationError.invalidParameterValue( + name: pair.key, + value: pair.value + ) + } + case "experimental_strip_nonfunctional_codegen": + if pair.value.isEmpty { // Also support option without any value. + experimentalStripNonfunctionalCodegen = true + } else if let value = Bool(pair.value) { + experimentalStripNonfunctionalCodegen = value + } else { + throw GenerationError.invalidParameterValue( + name: pair.key, + value: pair.value + ) + } + default: + throw GenerationError.unknownParameter(name: pair.key) + } + } + + if let moduleMapPath = moduleMapPath { + do { + self.protoToModuleMappings = try ProtoFileToModuleMappings( + path: moduleMapPath, + swiftProtobufModuleName: swiftProtobufModuleName + ) + } catch let e { + throw GenerationError.wrappedError( + message: "Parameter 'ProtoPathModuleMappings=\(moduleMapPath)'", + error: e + ) + } + } else { + self.protoToModuleMappings = ProtoFileToModuleMappings(swiftProtobufModuleName: swiftProtobufModuleName) + } + + self.outputNaming = outputNaming + self.visibility = visibility + + switch visibility { + case .internal: + visibilitySourceSnippet = "" + case .public: + visibilitySourceSnippet = "public " + case .package: + visibilitySourceSnippet = "package " + } + + self.experimentalStripNonfunctionalCodegen = experimentalStripNonfunctionalCodegen + + switch (implementationOnlyImports, useAccessLevelOnImports) { + case (false, false): self.importDirective = .plain + case (false, true): self.importDirective = .accessLevel(visibility) + case (true, false): self.importDirective = .implementationOnly + case (true, true): + throw GenerationError.message( + message: """ + When using access levels on imports the @_implementationOnly option is unnecessary. + Disable @_implementationOnly imports. + """ + ) + } + + // ------------------------------------------------------------------------ + // Now do "cross option" validations. + + if implementationOnlyImports && self.visibility != .internal { + throw GenerationError.message( + message: """ + Cannot use @_implementationOnly imports when the proto visibility is public or package. + Either change the visibility to internal, or disable @_implementationOnly imports. + """ + ) + } + + // The majority case is that if `self.protoToModuleMappings.hasMappings` is + // true, then `self.visibility` should be either `.public` or `.package`. + // However, it is possible for someone to put top most proto files (ones + // not imported into other proto files) in a different module, and use + // internal visibility there. i.e. - + // + // module One: + // - foo.pb.swift from foo.proto generated with "public" visibility. + // module Two: + // - bar.pb.swift from bar.proto (which does `import foo.proto`) + // generated with "internal" visibility. + // + // Since this support is possible/valid, there's no good way a "bad" case + // (i.e. - if foo.pb.swift was generated with "internal" visibility). So + // no options validation here, and instead developers would have to figure + // this out via the compiler errors around missing type (when bar.pb.swift + // gets unknown reference for thing that should be in module One via + // foo.pb.swift). + } } diff --git a/Sources/protoc-gen-swift/Google_Protobuf_DescriptorProto+Extensions.swift b/Sources/protoc-gen-swift/Google_Protobuf_DescriptorProto+Extensions.swift deleted file mode 100644 index e8e9947ec..000000000 --- a/Sources/protoc-gen-swift/Google_Protobuf_DescriptorProto+Extensions.swift +++ /dev/null @@ -1,42 +0,0 @@ -// Sources/protoc-gen-swift/Google_Protobuf_DescriptorProto+Extensions.swift - Descriptor extensions -// -// Copyright (c) 2014 - 2016 Apple Inc. and the project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See LICENSE.txt for license information: -// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt -// -// ----------------------------------------------------------------------------- -/// -/// Extensions to `DescriptorProto` that provide Swift-generation-specific -/// functionality. -/// -// ----------------------------------------------------------------------------- - -import Foundation -import SwiftProtobufPluginLibrary -import SwiftProtobuf - -extension Google_Protobuf_DescriptorProto.ExtensionRange { - - /// A `String` containing the Swift expression that represents this - /// extension range to be used in a `case` statement. - var swiftCaseExpression: String { - if start == end - 1 { - return "\(start)" - } - return "\(start)..<\(end)" - } - - /// A `String` containing the Swift Boolean expression that tests the given - /// variable for containment within this extension range. - /// - /// - Parameter variable: The name of the variable to test in the expression. - /// - Returns: A `String` containing the Boolean expression. - func swiftBooleanExpression(variable: String) -> String { - if start == end - 1 { - return "\(start) == \(variable)" - } - return "\(start) <= \(variable) && \(variable) < \(end)" - } -} diff --git a/Sources/protoc-gen-swift/Google_Protobuf_FileDescriptorProto+Extensions.swift b/Sources/protoc-gen-swift/Google_Protobuf_FileDescriptorProto+Extensions.swift index 1a61b7ced..e9832bb1b 100644 --- a/Sources/protoc-gen-swift/Google_Protobuf_FileDescriptorProto+Extensions.swift +++ b/Sources/protoc-gen-swift/Google_Protobuf_FileDescriptorProto+Extensions.swift @@ -13,12 +13,13 @@ /// // ----------------------------------------------------------------------------- -import SwiftProtobufPluginLibrary import SwiftProtobuf +import SwiftProtobufPluginLibrary extension Google_Protobuf_FileDescriptorProto { - // Field numbers used to collect .proto file comments. - struct FieldNumbers { - static let syntax: Int = 12 - } + // Field numbers used to collect .proto file comments. + struct FieldNumbers { + static let syntax: Int = 12 + static let edition: Int = 14 + } } diff --git a/Sources/protoc-gen-swift/MessageFieldGenerator.swift b/Sources/protoc-gen-swift/MessageFieldGenerator.swift index 2d5cd4113..19282c670 100644 --- a/Sources/protoc-gen-swift/MessageFieldGenerator.swift +++ b/Sources/protoc-gen-swift/MessageFieldGenerator.swift @@ -13,9 +13,8 @@ /// // ----------------------------------------------------------------------------- import Foundation -import SwiftProtobufPluginLibrary import SwiftProtobuf - +import SwiftProtobufPluginLibrary class MessageFieldGenerator: FieldGeneratorBase, FieldGenerator { private let generatorOptions: GeneratorOptions @@ -34,35 +33,38 @@ class MessageFieldGenerator: FieldGeneratorBase, FieldGenerator { private let traitsType: String private let comments: String - private var isMap: Bool {return fieldDescriptor.isMap} - private var isPacked: Bool { return fieldDescriptor.isPacked } + private var isMap: Bool { fieldDescriptor.isMap } + private var isPacked: Bool { fieldDescriptor.isPacked } // Note: this could still be a map (since those are repeated message fields - private var isRepeated: Bool {return fieldDescriptor.label == .repeated} + private var isRepeated: Bool { fieldDescriptor.isRepeated } private var isGroupOrMessage: Bool { - switch fieldDescriptor.type { - case .group, .message: - return true - default: - return false - } + switch fieldDescriptor.type { + case .group, .message: + return true + default: + return false + } } - init(descriptor: FieldDescriptor, - generatorOptions: GeneratorOptions, - namer: SwiftProtobufNamer, - usesHeapStorage: Bool) - { - precondition(descriptor.realOneof == nil) + init( + descriptor: FieldDescriptor, + generatorOptions: GeneratorOptions, + namer: SwiftProtobufNamer, + usesHeapStorage: Bool + ) { + precondition(descriptor.realContainingOneof == nil) self.generatorOptions = generatorOptions self.usesHeapStorage = usesHeapStorage self.namer = namer - hasFieldPresence = descriptor.hasPresence && descriptor.realOneof == nil - let names = namer.messagePropertyNames(field: descriptor, - prefixed: "_", - includeHasAndClear: hasFieldPresence) + hasFieldPresence = descriptor.hasPresence + let names = namer.messagePropertyNames( + field: descriptor, + prefixed: "_", + includeHasAndClear: hasFieldPresence + ) swiftName = names.name underscoreSwiftName = names.prefixed swiftHasName = names.has @@ -71,7 +73,7 @@ class MessageFieldGenerator: FieldGeneratorBase, FieldGenerator { swiftStorageType = descriptor.swiftStorageType(namer: namer) swiftDefaultValue = descriptor.swiftDefaultValue(namer: namer) traitsType = descriptor.traitsType(namer: namer) - comments = descriptor.protoSourceComments() + comments = descriptor.protoSourceCommentsWithDeprecation(generatorOptions: generatorOptions) if usesHeapStorage { storedProperty = "_storage.\(underscoreSwiftName)" @@ -85,41 +87,37 @@ class MessageFieldGenerator: FieldGeneratorBase, FieldGenerator { func generateStorage(printer p: inout CodePrinter) { let defaultValue = hasFieldPresence ? "nil" : swiftDefaultValue if usesHeapStorage { - p.print("var \(underscoreSwiftName): \(swiftStorageType) = \(defaultValue)\n") + p.print("var \(underscoreSwiftName): \(swiftStorageType) = \(defaultValue)") } else { - // If this field has field presence, the there is a private storage variable. - if hasFieldPresence { - p.print("fileprivate var \(underscoreSwiftName): \(swiftStorageType) = \(defaultValue)\n") - } + // If this field has field presence, the there is a private storage variable. + if hasFieldPresence { + p.print("fileprivate var \(underscoreSwiftName): \(swiftStorageType) = \(defaultValue)") + } } } func generateInterface(printer p: inout CodePrinter) { let visibility = generatorOptions.visibilitySourceSnippet - p.print("\n", comments) - + p.print() if usesHeapStorage { - p.print( - "\(visibility)var \(swiftName): \(swiftType) {\n") - p.indent() + p.print("\(comments)\(visibility)var \(swiftName): \(swiftType) {") let defaultClause = hasFieldPresence ? " ?? \(swiftDefaultValue)" : "" - p.print( - "get {return _storage.\(underscoreSwiftName)\(defaultClause)}\n", - "set {_uniqueStorage().\(underscoreSwiftName) = newValue}\n") - p.outdent() - p.print("}\n") + p.printIndented( + "get {_storage.\(underscoreSwiftName)\(defaultClause)}", + "set {_uniqueStorage().\(underscoreSwiftName) = newValue}" + ) + p.print("}") } else { if hasFieldPresence { - p.print("\(visibility)var \(swiftName): \(swiftType) {\n") - p.indent() - p.print( - "get {return \(underscoreSwiftName) ?? \(swiftDefaultValue)}\n", - "set {\(underscoreSwiftName) = newValue}\n") - p.outdent() - p.print("}\n") + p.print("\(comments)\(visibility)var \(swiftName): \(swiftType) {") + p.printIndented( + "get {\(underscoreSwiftName) ?? \(swiftDefaultValue)}", + "set {\(underscoreSwiftName) = newValue}" + ) + p.print("}") } else { - p.print("\(visibility)var \(swiftName): \(swiftStorageType) = \(swiftDefaultValue)\n") + p.print("\(comments)\(visibility)var \(swiftName): \(swiftStorageType) = \(swiftDefaultValue)") } } @@ -127,17 +125,19 @@ class MessageFieldGenerator: FieldGeneratorBase, FieldGenerator { let immutableStoragePrefix = usesHeapStorage ? "_storage." : "self." p.print( - "/// Returns true if `\(swiftName)` has been explicitly set.\n", - "\(visibility)var \(swiftHasName): Bool {return \(immutableStoragePrefix)\(underscoreSwiftName) != nil}\n") + "/// Returns true if `\(swiftName)` has been explicitly set.", + "\(visibility)var \(swiftHasName): Bool {\(immutableStoragePrefix)\(underscoreSwiftName) != nil}" + ) let mutableStoragePrefix = usesHeapStorage ? "_uniqueStorage()." : "self." p.print( - "/// Clears the value of `\(swiftName)`. Subsequent reads from it will return its default value.\n", - "\(visibility)mutating func \(swiftClearName)() {\(mutableStoragePrefix)\(underscoreSwiftName) = nil}\n") + "/// Clears the value of `\(swiftName)`. Subsequent reads from it will return its default value.", + "\(visibility)mutating func \(swiftClearName)() {\(mutableStoragePrefix)\(underscoreSwiftName) = nil}" + ) } func generateStorageClassClone(printer p: inout CodePrinter) { - p.print("\(underscoreSwiftName) = source.\(underscoreSwiftName)\n") + p.print("\(underscoreSwiftName) = source.\(underscoreSwiftName)") } func generateFieldComparison(printer p: inout CodePrinter) { @@ -151,21 +151,23 @@ class MessageFieldGenerator: FieldGeneratorBase, FieldGenerator { otherStoredProperty = "rhs.\(hasFieldPresence ? underscoreSwiftName : swiftName)" } - p.print("if \(lhsProperty) != \(otherStoredProperty) {return false}\n") + p.print("if \(lhsProperty) != \(otherStoredProperty) {return false}") } - func generateRequiredFieldCheck(printer p: inout CodePrinter) { - guard fieldDescriptor.label == .required else { return } - p.print("if \(storedProperty) == nil {return false}\n") + func generateRequiredFieldCheck(printer p: inout CodePrinter) { + guard fieldDescriptor.isRequired else { return } + p.print("if \(storedProperty) == nil {return false}") } func generateIsInitializedCheck(printer p: inout CodePrinter) { - guard isGroupOrMessage && fieldDescriptor.messageType.containsRequiredFields() else { return } + guard isGroupOrMessage && fieldDescriptor.messageType!.containsRequiredFields() else { return } if isRepeated { // Map or Array - p.print("if !\(namer.swiftProtobufModuleName).Internal.areAllInitialized(\(storedProperty)) {return false}\n") + p.print( + "if !\(namer.swiftProtobufModulePrefix)Internal.areAllInitialized(\(storedProperty)) {return false}" + ) } else { - p.print("if let v = \(storedProperty), !v.isInitialized {return false}\n") + p.print("if let v = \(storedProperty), !v.isInitialized {return false}") } } @@ -181,11 +183,11 @@ class MessageFieldGenerator: FieldGeneratorBase, FieldGenerator { traitsArg = "" } - p.print("case \(number): try { try decoder.\(decoderMethod)(\(traitsArg)value: &\(storedProperty)) }()\n") + p.print("case \(number): try { try decoder.\(decoderMethod)(\(traitsArg)value: &\(storedProperty)) }()") } var generateTraverseUsesLocals: Bool { - return !isRepeated && hasFieldPresence + !isRepeated && hasFieldPresence } func generateTraverse(printer p: inout CodePrinter) { @@ -210,24 +212,30 @@ class MessageFieldGenerator: FieldGeneratorBase, FieldGenerator { conditional = "let v = \(storedProperty)" usesLocals = true } else { - // At this point, the fields would be a primative type, and should only + // At this point, the fields would be a primitive type, and should only // be visted if it is the non default value. - assert(fieldDescriptor.file.syntax == .proto3) switch fieldDescriptor.type { case .string, .bytes: - conditional = ("!\(varName).isEmpty") + conditional = "!\(varName).isEmpty" + case .float, .double: + // https://protobuf.dev/programming-guides/proto3/#default ends with: + // If a float or double value is set to +0 it will not be serialized, + // but -0 is considered distinct and will be serialized. + // Editions still ensures that implicit presence doesn't get a default + // value so the hardcoded zero here is safe and mirrors the upstream + // C++ generator: + // https://github.com/protocolbuffers/protobuf/blob/1b06cefe337f73ca8c78c855c02f15caf6210c9b/src/google/protobuf/compiler/cpp/message.cc#L204-L209 + conditional = "\(varName).bitPattern != 0" default: - conditional = ("\(varName) != \(swiftDefaultValue)") + conditional = "\(varName) != \(swiftDefaultValue)" } } assert(usesLocals == generateTraverseUsesLocals) let prefix = usesLocals ? "try { " : "" let suffix = usesLocals ? " }()" : "" - p.print("\(prefix)if \(conditional) {\n") - p.indent() - p.print("try visitor.\(visitMethod)(\(traitsArg)value: \(varName), fieldNumber: \(number))\n") - p.outdent() - p.print("}\(suffix)\n") + p.print("\(prefix)if \(conditional) {") + p.printIndented("try visitor.\(visitMethod)(\(traitsArg)value: \(varName), fieldNumber: \(number))") + p.print("}\(suffix)") } } diff --git a/Sources/protoc-gen-swift/MessageGenerator.swift b/Sources/protoc-gen-swift/MessageGenerator.swift index f75f1265e..8f723fac6 100644 --- a/Sources/protoc-gen-swift/MessageGenerator.swift +++ b/Sources/protoc-gen-swift/MessageGenerator.swift @@ -15,554 +15,575 @@ // ----------------------------------------------------------------------------- import Foundation -import SwiftProtobufPluginLibrary import SwiftProtobuf +import SwiftProtobufPluginLibrary class MessageGenerator { - private let descriptor: Descriptor - private let generatorOptions: GeneratorOptions - private let namer: SwiftProtobufNamer - private let visibility: String - private let swiftFullName: String - private let swiftRelativeName: String - private let fields: [FieldGenerator] - private let fieldsSortedByNumber: [FieldGenerator] - private let oneofs: [OneofGenerator] - private let storage: MessageStorageClassGenerator? - private let enums: [EnumGenerator] - private let messages: [MessageGenerator] - private let isExtensible: Bool - - init( - descriptor: Descriptor, - generatorOptions: GeneratorOptions, - namer: SwiftProtobufNamer, - extensionSet: ExtensionSetGenerator - ) { - self.descriptor = descriptor - self.generatorOptions = generatorOptions - self.namer = namer - - visibility = generatorOptions.visibilitySourceSnippet - isExtensible = !descriptor.extensionRanges.isEmpty - swiftRelativeName = namer.relativeName(message: descriptor) - swiftFullName = namer.fullName(message: descriptor) - - let useHeapStorage = - MessageStorageDecision.shouldUseHeapStorage(descriptor: descriptor) - - oneofs = descriptor.realOneofs.map { - return OneofGenerator(descriptor: $0, generatorOptions: generatorOptions, namer: namer, usesHeapStorage: useHeapStorage) - } + private let descriptor: Descriptor + private let generatorOptions: GeneratorOptions + private let namer: SwiftProtobufNamer + private let visibility: String + private let swiftFullName: String + private let swiftRelativeName: String + private let fields: [any FieldGenerator] + private let fieldsSortedByNumber: [any FieldGenerator] + private let oneofs: [OneofGenerator] + private let storage: MessageStorageClassGenerator? + private let enums: [EnumGenerator] + private let messages: [MessageGenerator] + private let isExtensible: Bool + + init( + descriptor: Descriptor, + generatorOptions: GeneratorOptions, + namer: SwiftProtobufNamer, + extensionSet: ExtensionSetGenerator + ) { + self.descriptor = descriptor + self.generatorOptions = generatorOptions + self.namer = namer + + visibility = generatorOptions.visibilitySourceSnippet + isExtensible = !descriptor.messageExtensionRanges.isEmpty + swiftRelativeName = namer.relativeName(message: descriptor) + swiftFullName = namer.fullName(message: descriptor) + + let useHeapStorage = + MessageStorageDecision.shouldUseHeapStorage(descriptor: descriptor) + + oneofs = descriptor.realOneofs.map { + OneofGenerator( + descriptor: $0, + generatorOptions: generatorOptions, + namer: namer, + usesHeapStorage: useHeapStorage + ) + } - let factory = MessageFieldFactory(generatorOptions: generatorOptions, - namer: namer, - useHeapStorage: useHeapStorage, - oneofGenerators: oneofs) - fields = descriptor.fields.map { - return factory.make(forFieldDescriptor: $0) - } - fieldsSortedByNumber = fields.sorted {$0.number < $1.number} + let factory = MessageFieldFactory( + generatorOptions: generatorOptions, + namer: namer, + useHeapStorage: useHeapStorage, + oneofGenerators: oneofs + ) + fields = descriptor.fields.map { + factory.make(forFieldDescriptor: $0) + } + fieldsSortedByNumber = fields.sorted { $0.number < $1.number } - extensionSet.add(extensionFields: descriptor.extensions) + extensionSet.add(extensionFields: descriptor.extensions) - enums = descriptor.enums.map { - return EnumGenerator(descriptor: $0, generatorOptions: generatorOptions, namer: namer) - } + enums = descriptor.enums.map { + EnumGenerator(descriptor: $0, generatorOptions: generatorOptions, namer: namer) + } - messages = descriptor.messages.filter { return !$0.isMapEntry }.map { - return MessageGenerator(descriptor: $0, - generatorOptions: generatorOptions, - namer: namer, - extensionSet: extensionSet) - } + messages = descriptor.messages.filter { !$0.options.mapEntry }.map { + MessageGenerator( + descriptor: $0, + generatorOptions: generatorOptions, + namer: namer, + extensionSet: extensionSet + ) + } - if descriptor.isAnyMessage { - precondition(useHeapStorage) - storage = AnyMessageStorageClassGenerator(fields: fields) - } else if useHeapStorage { - storage = MessageStorageClassGenerator(fields: fields) - } else { - storage = nil - } - } - - func generateMainStruct( - printer p: inout CodePrinter, - parent: MessageGenerator?, - errorString: inout String? - ) { - // protoc does this validation; this is just here as a safety net because what is - // generated and how the runtime works assumes this. - if descriptor.useMessageSetWireFormat { - guard fields.isEmpty else { - errorString = "\(descriptor.fullName) has the option message_set_wire_format but it also has fields." - return - } - } - for e in descriptor.extensions { - guard e.containingType.useMessageSetWireFormat else { continue } - - guard e.type == .message else { - errorString = "\(e.containingType.fullName) has the option message_set_wire_format but \(e.fullName) is a non message extension field." - return - } - guard e.label == .optional else { - errorString = "\(e.containingType.fullName) has the option message_set_wire_format but \(e.fullName) is not a \"optional\" extension field." - return - } + if descriptor.wellKnownType == .any { + precondition(useHeapStorage) + storage = AnyMessageStorageClassGenerator(fields: fields) + } else if useHeapStorage { + storage = MessageStorageClassGenerator(fields: fields) + } else { + storage = nil + } } - let conformances: String - if isExtensible { - conformances = ": \(namer.swiftProtobufModuleName).ExtensibleMessage" - } else { - conformances = "" - } - p.print( - "\n", - descriptor.protoSourceComments(), - "\(visibility)struct \(swiftRelativeName)\(conformances) {\n") - p.indent() - p.print("// \(namer.swiftProtobufModuleName).Message conformance is added in an extension below. See the\n", - "// `Message` and `Message+*Additions` files in the SwiftProtobuf library for\n", - "// methods supported on all messages.\n") - - for f in fields { - f.generateInterface(printer: &p) - } + func generateMainStruct( + printer p: inout CodePrinter, + parent: MessageGenerator?, + errorString: inout String? + ) { + // protoc does this validation; this is just here as a safety net because what is + // generated and how the runtime works assumes this. + if descriptor.useMessageSetWireFormat { + guard fields.isEmpty else { + errorString = "\(descriptor.fullName) has the option message_set_wire_format but it also has fields." + return + } + } + for e in descriptor.extensions { + guard e.containingType.useMessageSetWireFormat else { continue } + + guard e.type == .message else { + errorString = + "\(e.containingType.fullName) has the option message_set_wire_format but \(e.fullName) is a non message extension field." + return + } + guard !e.isRequired && !e.isRepeated else { + errorString = + "\(e.containingType.fullName) has the option message_set_wire_format but \(e.fullName) cannot be required nor repeated extension field." + return + } + } - p.print( - "\n", - "\(visibility)var unknownFields = \(namer.swiftProtobufModuleName).UnknownStorage()\n") + var conformances = [String]() + if isExtensible { + conformances.append("\(namer.swiftProtobufModulePrefix)ExtensibleMessage") + } - for o in oneofs { - o.generateMainEnum(printer: &p) - } + // Messages that have a storage class will always need @unchecked. + let needsUnchecked = storage != nil + conformances.append(needsUnchecked ? "@unchecked Sendable" : "Sendable") - // Nested enums - for e in enums { - e.generateMainEnum(printer: &p) + p.print( + "", + "\(descriptor.protoSourceCommentsWithDeprecation(generatorOptions: generatorOptions))\(visibility)struct \(swiftRelativeName): \(conformances.joined(separator: ", ")) {" + ) + p.withIndentation { p in + p.print( + """ + // \(namer.swiftProtobufModuleName).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. + """ + ) + + for f in fields { + f.generateInterface(printer: &p) + } + + p.print( + "", + "\(visibility)var unknownFields = \(namer.swiftProtobufModulePrefix)UnknownStorage()" + ) + + for o in oneofs { + o.generateMainEnum(printer: &p) + } + + // Nested enums + for e in enums { + e.generateMainEnum(printer: &p) + } + + // Nested messages + for m in messages { + m.generateMainStruct(printer: &p, parent: self, errorString: &errorString) + } + + // Generate the default initializer. If we don't, Swift seems to sometimes + // generate it along with others that can take public proprerties. When it + // generates the others doesn't seem to be documented. + p.print( + "", + "\(visibility)init() {}" + ) + + // Optional extension support + if isExtensible { + p.print( + "", + "\(visibility)var _protobuf_extensionFieldValues = \(namer.swiftProtobufModulePrefix)ExtensionFieldValueSet()" + ) + } + if let storage = storage { + if !isExtensible { + p.print() + } + p.print("\(storage.storageVisibility) var _storage = _StorageClass.defaultInstance") + } else { + var subMessagePrinter = CodePrinter(p) + for f in fields { + f.generateStorage(printer: &subMessagePrinter) + } + if !subMessagePrinter.isEmpty { + if !isExtensible { + p.print() + } + p.append(subMessagePrinter) + } + } + } + p.print("}") } - // Nested messages - for m in messages { - m.generateMainStruct(printer: &p, parent: self, errorString: &errorString) - } + func generateRuntimeSupport(printer p: inout CodePrinter, file: FileGenerator, parent: MessageGenerator?) { + p.print( + "", + "extension \(swiftFullName): \(namer.swiftProtobufModulePrefix)Message, \(namer.swiftProtobufModulePrefix)_MessageImplementationBase, \(namer.swiftProtobufModulePrefix)_ProtoNameProviding {" + ) + p.withIndentation { p in + if let parent = parent { + p.print( + "\(visibility)static let protoMessageName: String = \(parent.swiftFullName).protoMessageName + \".\(descriptor.name)\"" + ) + } else if !descriptor.file.package.isEmpty { + p.print( + "\(visibility)static let protoMessageName: String = _protobuf_package + \".\(descriptor.name)\"" + ) + } else { + p.print("\(visibility)static let protoMessageName: String = \"\(descriptor.name)\"") + } + generateProtoNameProviding(printer: &p) + if let storage = storage { + p.print() + storage.generateTypeDeclaration(printer: &p) + p.print() + storage.generateUniqueStorage(printer: &p) + } + p.print() + generateIsInitialized(printer: &p) + // generateIsInitialized provides a blank line after itself. + generateDecodeMessage(printer: &p) + p.print() + generateTraverse(printer: &p) + p.print() + generateMessageEquality(printer: &p) + } + p.print("}") - // Generate the default initializer. If we don't, Swift seems to sometimes - // generate it along with others that can take public proprerties. When it - // generates the others doesn't seem to be documented. - p.print( - "\n", - "\(visibility)init() {}\n") - - // Optional extension support - if isExtensible { - p.print( - "\n", - "\(visibility)var _protobuf_extensionFieldValues = \(namer.swiftProtobufModuleName).ExtensionFieldValueSet()\n") - } - if let storage = storage { - if !isExtensible { - p.print("\n") - } - p.print("\(storage.storageVisibility) var _storage = _StorageClass.defaultInstance\n") - } else { - var subMessagePrinter = CodePrinter() - for f in fields { - f.generateStorage(printer: &subMessagePrinter) - } - if !subMessagePrinter.isEmpty { - if !isExtensible { - p.print("\n") + // Nested enums and messages + for e in enums { + e.generateRuntimeSupport(printer: &p) + } + for m in messages { + m.generateRuntimeSupport(printer: &p, file: file, parent: self) } - p.print(subMessagePrinter.content) - } } - p.outdent() - p.print("}\n") - } - - func generateEnumCaseIterable(printer p: inout CodePrinter) { - for e in enums { - e.generateCaseIterable(printer: &p, includeGuards: false) - } - for m in messages { - m.generateEnumCaseIterable(printer: &p) - } - } - - func generateSendable(printer p: inout CodePrinter) { - // Once our minimum supported version has Data be Sendable, @unchecked - // will not be needed for all messages, provided that the extension types - // in the library are marked Sendable. - // - // Messages that have a storage class will always need @unchecked. - p.print("extension \(swiftFullName): @unchecked Sendable {}\n") - - for o in oneofs { - o.generateSendable(printer: &p) + private func generateProtoNameProviding(printer p: inout CodePrinter) { + var writer = ProtoNameInstructionWriter() + for f in fieldsSortedByNumber { + f.writeProtoNameInstruction(to: &writer) + } + for name in descriptor.reservedNames { + writer.writeReservedName(name) + } + for range in descriptor.reservedRanges { + writer.writeReservedNumbers(range) + } + if writer.shouldUseEmptyNameMapInitializer { + p.print("\(visibility)static let _protobuf_nameMap = \(namer.swiftProtobufModulePrefix)_NameMap()") + } else { + p.print( + "\(visibility)static let _protobuf_nameMap = \(namer.swiftProtobufModulePrefix)_NameMap(bytecode: \(writer.bytecode.stringLiteral))" + ) + } } - for e in enums { - e.generateSendable(printer: &p) + /// Generates the `decodeMessage` method for the message. + /// + /// - Parameter p: The code printer. + private func generateDecodeMessage(printer p: inout CodePrinter) { + p.print( + "\(visibility)mutating func decodeMessage(decoder: inout D) throws {" + ) + p.withIndentation { p in + if storage != nil { + p.print("_ = _uniqueStorage()") + } + + // protoc allows message_set_wire_format without any extension ranges; no clue what that + // actually would mean (since message_set_wire_format can't have fields), but make sure + // there are extensions ranges as that is what provides the extension support in the + // rest of the generation. + if descriptor.useMessageSetWireFormat && isExtensible { + + // MessageSet hands off the decode to the decoder to do the custom logic into the extensions. + p.print( + "try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: \(swiftFullName).self)" + ) + + } else { + + if fields.isEmpty && !isExtensible { + p.print( + "// Load everything into unknown fields", + "while try decoder.nextFieldNumber() != nil {}" + ) + } else { + generateWithLifetimeExtension(printer: &p, throws: true) { p in + p.print("while let fieldNumber = try decoder.nextFieldNumber() {") + p.withIndentation { p in + // If a message only has extensions and there are multiple extension + // ranges, get more compact source gen by still using the `switch..case` + // code. This also avoids typechecking performance issues if there are + // dozens of ranges because we aren't constructing a single large + // expression containing untyped integer literals. + let normalizedExtensionRanges = descriptor._normalizedExtensionRanges + if !fields.isEmpty || normalizedExtensionRanges.count > 3 { + p.print( + """ + // 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 { + """ + ) + for f in fieldsSortedByNumber { + f.generateDecodeFieldCase(printer: &p) + } + if isExtensible { + p.print("case \(normalizedExtensionRanges.swiftCaseExpression):") + p.printIndented( + "try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: \(swiftFullName).self, fieldNumber: fieldNumber) }()" + ) + } + p.print( + "default: break", + "}" + ) + } else if isExtensible { + // Just output a simple if-statement if the message had no fields of its + // own but we still need to generate a decode statement for extensions. + p.print( + "if \(normalizedExtensionRanges.swiftBooleanExpression(variable: "fieldNumber")) {" + ) + p.printIndented( + "try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: \(swiftFullName).self, fieldNumber: fieldNumber)" + ) + p.print("}") + } + } + p.print("}") + } + } + + } + } + p.print("}") + } + + /// Generates the `traverse` method for the message. + /// + /// - Parameter p: The code printer. + private func generateTraverse(printer p: inout CodePrinter) { + p.print("\(visibility)func traverse(visitor: inout V) throws {") + p.withIndentation { p in + generateWithLifetimeExtension(printer: &p, throws: true) { p in + if let storage = storage { + storage.generatePreTraverse(printer: &p) + } + + let visitExtensionsName = + descriptor.useMessageSetWireFormat ? "visitExtensionFieldsAsMessageSet" : "visitExtensionFields" + + let usesLocals = fields.reduce(false) { $0 || $1.generateTraverseUsesLocals } + if usesLocals { + p.print( + """ + // 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 + """ + ) + } + + // Use the "ambitious" ranges because for visit because subranges with no + // intermixed fields can be merged to reduce the number of calls for + // extension visitation. + var ranges = descriptor._ambitiousExtensionRanges.makeIterator() + var nextRange = ranges.next() + for f in fieldsSortedByNumber { + while nextRange != nil && Int(nextRange!.lowerBound) < f.number { + p.print( + "try visitor.\(visitExtensionsName)(fields: _protobuf_extensionFieldValues, start: \(nextRange!.lowerBound), end: \(nextRange!.upperBound))" + ) + nextRange = ranges.next() + } + f.generateTraverse(printer: &p) + } + while nextRange != nil { + p.print( + "try visitor.\(visitExtensionsName)(fields: _protobuf_extensionFieldValues, start: \(nextRange!.lowerBound), end: \(nextRange!.upperBound))" + ) + nextRange = ranges.next() + } + } + p.print("try unknownFields.traverse(visitor: &visitor)") + } + p.print("}") + } + + private func generateMessageEquality(printer p: inout CodePrinter) { + p.print("\(visibility)static func ==(lhs: \(swiftFullName), rhs: \(swiftFullName)) -> Bool {") + p.withIndentation { p in + var compareFields = true + if let storage = storage { + p.print("if lhs._storage !== rhs._storage {") + p.indent() + p.print("let storagesAreEqual: Bool = ", newlines: false) + if storage.storageProvidesEqualTo { + p.print("lhs._storage.isEqualTo(other: rhs._storage)") + compareFields = false + } + } + if compareFields { + generateWithLifetimeExtension( + printer: &p, + alsoCapturing: "rhs", + selfQualifier: "lhs" + ) { p in + for f in fields { + f.generateFieldComparison(printer: &p) + } + if storage != nil { + p.print("return true") + } + } + } + if storage != nil { + p.print("if !storagesAreEqual {return false}") + p.outdent() + p.print("}") + } + p.print("if lhs.unknownFields != rhs.unknownFields {return false}") + if isExtensible { + p.print("if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false}") + } + p.print("return true") + } + p.print("}") } - for m in messages { - m.generateSendable(printer: &p) - } - } - - func generateRuntimeSupport(printer p: inout CodePrinter, file: FileGenerator, parent: MessageGenerator?) { - p.print( - "\n", - "extension \(swiftFullName): \(namer.swiftProtobufModuleName).Message, \(namer.swiftProtobufModuleName)._MessageImplementationBase, \(namer.swiftProtobufModuleName)._ProtoNameProviding {\n") - p.indent() - - if let parent = parent { - p.print("\(visibility)static let protoMessageName: String = \(parent.swiftFullName).protoMessageName + \".\(descriptor.name)\"\n") - } else if !descriptor.file.package.isEmpty { - p.print("\(visibility)static let protoMessageName: String = _protobuf_package + \".\(descriptor.name)\"\n") - } else { - p.print("\(visibility)static let protoMessageName: String = \"\(descriptor.name)\"\n") - } - generateProtoNameProviding(printer: &p) - if let storage = storage { - p.print("\n") - storage.generateTypeDeclaration(printer: &p) - p.print("\n") - storage.generateUniqueStorage(printer: &p) - } - p.print("\n") - generateIsInitialized(printer:&p) - // generateIsInitialized provides a blank line after itself. - generateDecodeMessage(printer: &p) - p.print("\n") - generateTraverse(printer: &p) - p.print("\n") - generateMessageEquality(printer: &p) - p.outdent() - p.print("}\n") - - // Nested enums and messages - for e in enums { - e.generateRuntimeSupport(printer: &p) - } - for m in messages { - m.generateRuntimeSupport(printer: &p, file: file, parent: self) - } - } - - private func generateProtoNameProviding(printer p: inout CodePrinter) { - if fields.isEmpty { - p.print("\(visibility)static let _protobuf_nameMap = \(namer.swiftProtobufModuleName)._NameMap()\n") - } else { - p.print("\(visibility)static let _protobuf_nameMap: \(namer.swiftProtobufModuleName)._NameMap = [\n") - p.indent() - for f in fields { - p.print("\(f.number): \(f.fieldMapNames),\n") - } - p.outdent() - p.print("]\n") - } - } + /// Generates the `isInitialized` property for the message, if needed. + /// + /// This may generate nothing, if the `isInitialized` property is not + /// needed. + /// + /// - Parameter printer: The code printer. + private func generateIsInitialized(printer p: inout CodePrinter) { + var fieldCheckPrinter = CodePrinter(addNewlines: true) - /// Generates the `decodeMessage` method for the message. - /// - /// - Parameter p: The code printer. - private func generateDecodeMessage(printer p: inout CodePrinter) { - p.print("\(visibility)mutating func decodeMessage(decoder: inout D) throws {\n") - p.indent() - if storage != nil { - p.print("_ = _uniqueStorage()\n") - } + // The check is done in two passes, so a missing required field can fail + // faster without recursing through the message fields to ensure they are + // initialized. - // protoc allows message_set_wire_format without any extension ranges; no clue what that - // actually would mean (since message_set_wire_format can't have fields), but make sure - // there are extensions ranges as that is what provides the extension support in the - // rest of the generation. - if descriptor.useMessageSetWireFormat && isExtensible { - - // MessageSet hands off the decode to the decoder to do the custom logic into the extensions. - p.print("try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: \(swiftFullName).self)\n") - - } else { - - let varName: String - if fields.isEmpty && !isExtensible { - varName = "_" - } else { - varName = "fieldNumber" - } - generateWithLifetimeExtension(printer: &p, throws: true) { p in - p.print("while let \(varName) = try decoder.nextFieldNumber() {\n") - p.indent() - // If a message only has extensions and there are multiple extension - // ranges, get more compact source gen by still using the `switch..case` - // code. This also avoids typechecking performance issues if there are - // dozens of ranges because we aren't constructing a single large - // expression containing untyped integer literals. - if !fields.isEmpty || descriptor.extensionRanges.count > 3 { - p.print( - "// The use of inline closures is to circumvent an issue where the compiler\n", - "// allocates stack space for every case branch when no optimizations are\n", - "// enabled. https://github.com/apple/swift-protobuf/issues/1034\n", - "switch fieldNumber {\n") - for f in fieldsSortedByNumber { - f.generateDecodeFieldCase(printer: &p) - } - if isExtensible { - p.print("case \(descriptor.swiftExtensionRangeCaseExpressions):\n") - p.indent() - p.print("try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: \(swiftFullName).self, fieldNumber: fieldNumber) }()\n") - p.outdent() - } - p.print("default: break\n", - "}\n") - } else if isExtensible { - // Just output a simple if-statement if the message had no fields of its - // own but we still need to generate a decode statement for extensions. - p.print("if \(descriptor.swiftExtensionRangeBooleanExpression(variable: "fieldNumber")) {\n") - p.indent() - p.print("try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: \(swiftFullName).self, fieldNumber: fieldNumber)\n") - p.outdent() - p.print("}\n") + // Ensure required fields are set. + for f in fields { + f.generateRequiredFieldCheck(printer: &fieldCheckPrinter) } - p.outdent() - p.print("}\n") - } - } - p.outdent() - p.print("}\n") - } - - /// Generates the `traverse` method for the message. - /// - /// - Parameter p: The code printer. - private func generateTraverse(printer p: inout CodePrinter) { - p.print("\(visibility)func traverse(visitor: inout V) throws {\n") - p.indent() - generateWithLifetimeExtension(printer: &p, throws: true) { p in - if let storage = storage { - storage.generatePreTraverse(printer: &p) - } - - let visitExtensionsName = - descriptor.useMessageSetWireFormat ? "visitExtensionFieldsAsMessageSet" : "visitExtensionFields" - - let usesLocals = fields.reduce(false) { $0 || $1.generateTraverseUsesLocals } - if usesLocals { - p.print( - "// The use of inline closures is to circumvent an issue where the compiler\n", - "// allocates stack space for every if/case branch local when no optimizations\n", - "// are enabled. https://github.com/apple/swift-protobuf/issues/1034 and\n", - "// https://github.com/apple/swift-protobuf/issues/1182\n") - } - - // Use the "ambitious" ranges because for visit because subranges with no - // intermixed fields can be merged to reduce the number of calls for - // extension visitation. - var ranges = descriptor.ambitiousExtensionRanges.makeIterator() - var nextRange = ranges.next() - for f in fieldsSortedByNumber { - while nextRange != nil && Int(nextRange!.start) < f.number { - p.print("try visitor.\(visitExtensionsName)(fields: _protobuf_extensionFieldValues, start: \(nextRange!.start), end: \(nextRange!.end))\n") - nextRange = ranges.next() - } - f.generateTraverse(printer: &p) - } - while nextRange != nil { - p.print("try visitor.\(visitExtensionsName)(fields: _protobuf_extensionFieldValues, start: \(nextRange!.start), end: \(nextRange!.end))\n") - nextRange = ranges.next() - } - } - p.print("try unknownFields.traverse(visitor: &visitor)\n") - p.outdent() - p.print("}\n") - } - - private func generateMessageEquality(printer p: inout CodePrinter) { - p.print("\(visibility)static func ==(lhs: \(swiftFullName), rhs: \(swiftFullName)) -> Bool {\n") - p.indent() - var compareFields = true - if let storage = storage { - p.print("if lhs._storage !== rhs._storage {\n") - p.indent() - p.print("let storagesAreEqual: Bool = ") - if storage.storageProvidesEqualTo { - p.print("lhs._storage.isEqualTo(other: rhs._storage)\n") - compareFields = false - } - } - if compareFields { - generateWithLifetimeExtension(printer: &p, - alsoCapturing: "rhs", - selfQualifier: "lhs") { p in for f in fields { - f.generateFieldComparison(printer: &p) - } - if storage != nil { - p.print("return true\n") + f.generateIsInitializedCheck(printer: &fieldCheckPrinter) } - } - } - if storage != nil { - p.print("if !storagesAreEqual {return false}\n") - p.outdent() - p.print("}\n") - } - p.print("if lhs.unknownFields != rhs.unknownFields {return false}\n") - if isExtensible { - p.print("if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false}\n") - } - p.print("return true\n") - p.outdent() - p.print("}\n") - } - - /// Generates the `isInitialized` property for the message, if needed. - /// - /// This may generate nothing, if the `isInitialized` property is not - /// needed. - /// - /// - Parameter printer: The code printer. - private func generateIsInitialized(printer p: inout CodePrinter) { - - var fieldCheckPrinter = CodePrinter() - - // The check is done in two passes, so a missing required field can fail - // faster without recursing through the message fields to ensure they are - // initialized. - - if descriptor.file.syntax == .proto2 { - // Only proto2 syntax can have field presence (required fields); ensure required - // fields have values. - for f in fields { - f.generateRequiredFieldCheck(printer: &fieldCheckPrinter) - } - } - - for f in fields { - f.generateIsInitializedCheck(printer: &fieldCheckPrinter) - } - let generatedChecks = !fieldCheckPrinter.isEmpty + let generatedChecks = !fieldCheckPrinter.isEmpty - if !isExtensible && !generatedChecks { - // No need to generate isInitialized. - return - } + if !isExtensible && !generatedChecks { + // No need to generate isInitialized. + return + } - p.print( - "public var isInitialized: Bool {\n") - p.indent() - if isExtensible { - p.print("if !_protobuf_extensionFieldValues.isInitialized {return false}\n") - } - if generatedChecks { - generateWithLifetimeExtension(printer: &p, returns: true) { p in - p.print(fieldCheckPrinter.content) - p.print("return true\n") - } - } else { - p.print("return true\n") - } - p.outdent() - p.print("}\n", - "\n") - } - - /// Executes the given closure, wrapping the code that it prints in a call - /// to `withExtendedLifetime` for the storage object if the message uses - /// one. - /// - /// - Parameter p: The code printer. - /// - Parameter canThrow: Indicates whether the code that will be printed - /// inside the block can throw; if so, the printed call to - /// `withExtendedLifetime` will be preceded by `try`. - /// - Parameter returns: Indicates whether the code that will be printed - /// inside the block returns a value; if so, the printed call to - /// `withExtendedLifetime` will be preceded by `return`. - /// - Parameter capturedVariable: The name of another variable (which is - /// assumed to be the same type as `self`) whose storage should also be - /// captured (used for equality testing, where two messages are operated - /// on simultaneously). - /// - Parameter body: A closure that takes the code printer as its sole - /// `inout` argument. - private func generateWithLifetimeExtension( - printer p: inout CodePrinter, - throws canThrow: Bool = false, - returns: Bool = false, - alsoCapturing capturedVariable: String? = nil, - selfQualifier qualifier: String? = nil, - body: (inout CodePrinter) -> Void - ) { - if storage != nil { - let prefixKeywords = "\(returns ? "return " : "")" + - "\(canThrow ? "try " : "")" - p.print(prefixKeywords) - - let selfQualifier: String - if let qualifier = qualifier { - selfQualifier = "\(qualifier)." - } else { - selfQualifier = "" - } - - if let capturedVariable = capturedVariable { - // withExtendedLifetime can only pass a single argument, - // so we have to build and deconstruct a tuple in this case: - let actualArgs = "(\(selfQualifier)_storage, \(capturedVariable)._storage)" - let formalArgs = "(_args: (_StorageClass, _StorageClass))" - p.print("withExtendedLifetime(\(actualArgs)) { \(formalArgs) in\n") - p.indent() - p.print("let _storage = _args.0\n") - p.print("let \(capturedVariable)_storage = _args.1\n") - } else { - // Single argument can be passed directly: - p.print("withExtendedLifetime(\(selfQualifier)_storage) { (_storage: _StorageClass) in\n") - p.indent() - } - } + p.print("public var isInitialized: Bool {") + p.withIndentation { p in + if isExtensible { + p.print("if !_protobuf_extensionFieldValues.isInitialized {return false}") + } + if generatedChecks { + generateWithLifetimeExtension(printer: &p, returns: true) { p in + p.append(fieldCheckPrinter, indenting: true) + p.print("return true") + } + } else { + p.print("return true") + } + } + p.print( + "}", + "" + ) + } + + /// Executes the given closure, wrapping the code that it prints in a call + /// to `withExtendedLifetime` for the storage object if the message uses + /// one. + /// + /// - Parameter p: The code printer. + /// - Parameter canThrow: Indicates whether the code that will be printed + /// inside the block can throw; if so, the printed call to + /// `withExtendedLifetime` will be preceded by `try`. + /// - Parameter returns: Indicates whether the code that will be printed + /// inside the block returns a value; if so, the printed call to + /// `withExtendedLifetime` will be preceded by `return`. + /// - Parameter capturedVariable: The name of another variable (which is + /// assumed to be the same type as `self`) whose storage should also be + /// captured (used for equality testing, where two messages are operated + /// on simultaneously). + /// - Parameter body: A closure that takes the code printer as its sole + /// `inout` argument. + private func generateWithLifetimeExtension( + printer p: inout CodePrinter, + throws canThrow: Bool = false, + returns: Bool = false, + alsoCapturing capturedVariable: String? = nil, + selfQualifier qualifier: String? = nil, + body: (inout CodePrinter) -> Void + ) { + if storage != nil { + let prefixKeywords = "\(returns ? "return " : "")\(canThrow ? "try " : "")" + + let selfQualifier: String + if let qualifier = qualifier { + selfQualifier = "\(qualifier)." + } else { + selfQualifier = "" + } + + if let capturedVariable = capturedVariable { + // withExtendedLifetime can only pass a single argument, + // so we have to build and deconstruct a tuple in this case: + let actualArgs = "(\(selfQualifier)_storage, \(capturedVariable)._storage)" + let formalArgs = "(_args: (_StorageClass, _StorageClass))" + p.print("\(prefixKeywords)withExtendedLifetime(\(actualArgs)) { \(formalArgs) in") + p.indent() + p.print("let _storage = _args.0") + p.print("let \(capturedVariable)_storage = _args.1") + } else { + // Single argument can be passed directly: + p.print( + "\(prefixKeywords)withExtendedLifetime(\(selfQualifier)_storage) { (_storage: _StorageClass) in" + ) + p.indent() + } + } - body(&p) + body(&p) - if storage != nil { - p.outdent() - p.print("}\n") + if storage != nil { + p.outdent() + p.print("}") + } } - } } -fileprivate struct MessageFieldFactory { - private let generatorOptions: GeneratorOptions - private let namer: SwiftProtobufNamer - private let useHeapStorage: Bool - private let oneofs: [OneofGenerator] - - init( - generatorOptions: GeneratorOptions, - namer: SwiftProtobufNamer, - useHeapStorage: Bool, - oneofGenerators: [OneofGenerator] - ) { - self.generatorOptions = generatorOptions - self.namer = namer - self.useHeapStorage = useHeapStorage - oneofs = oneofGenerators - } - - func make(forFieldDescriptor field: FieldDescriptor) -> FieldGenerator { - guard field.realOneof == nil else { - return oneofs[Int(field.oneofIndex!)].fieldGenerator(forFieldNumber: Int(field.number)) +private struct MessageFieldFactory { + private let generatorOptions: GeneratorOptions + private let namer: SwiftProtobufNamer + private let useHeapStorage: Bool + private let oneofs: [OneofGenerator] + + init( + generatorOptions: GeneratorOptions, + namer: SwiftProtobufNamer, + useHeapStorage: Bool, + oneofGenerators: [OneofGenerator] + ) { + self.generatorOptions = generatorOptions + self.namer = namer + self.useHeapStorage = useHeapStorage + oneofs = oneofGenerators + } + + func make(forFieldDescriptor field: FieldDescriptor) -> any FieldGenerator { + guard field.realContainingOneof == nil else { + return oneofs[Int(field.oneofIndex!)].fieldGenerator(forFieldNumber: Int(field.number)) + } + return MessageFieldGenerator( + descriptor: field, + generatorOptions: generatorOptions, + namer: namer, + usesHeapStorage: useHeapStorage + ) } - return MessageFieldGenerator(descriptor: field, - generatorOptions: generatorOptions, - namer: namer, - usesHeapStorage: useHeapStorage) - } } diff --git a/Sources/protoc-gen-swift/MessageStorageClassGenerator.swift b/Sources/protoc-gen-swift/MessageStorageClassGenerator.swift index 34fe7baa4..28d65750b 100644 --- a/Sources/protoc-gen-swift/MessageStorageClassGenerator.swift +++ b/Sources/protoc-gen-swift/MessageStorageClassGenerator.swift @@ -14,106 +14,109 @@ // ----------------------------------------------------------------------------- import Foundation -import SwiftProtobufPluginLibrary import SwiftProtobuf +import SwiftProtobufPluginLibrary /// Generates the `_StorageClass` used for messages that employ copy-on-write /// logic for some of their fields. class MessageStorageClassGenerator { - private let fields: [FieldGenerator] - - /// Creates a new `MessageStorageClassGenerator`. - init(fields: [FieldGenerator]) { - self.fields = fields - } - - /// Visibility of the storage within the Message. - var storageVisibility: String { - return "fileprivate" - } - - /// If the storage wants to manually implement equality. - var storageProvidesEqualTo: Bool { return false } - - /// Generates the full code for the storage class. - /// - /// - Parameter p: The code printer. - func generateTypeDeclaration(printer p: inout CodePrinter) { - p.print("fileprivate class _StorageClass {\n") - p.indent() - - generateStoredProperties(printer: &p) - - // Generate a default instance to be used so the heap allocation is - // delayed until mutation is needed. This is the largest savings when - // the message is used as a field in another message as it causes - // returning the default to not require that heap allocation, i.e. - - // readonly usage never causes the allocation. - p.print( - "\n", - "static let defaultInstance = _StorageClass()\n", - "\n", - "private init() {}\n", - "\n") - generateClone(printer: &p) - - p.outdent() - p.print("}\n") - } - - /// Generated the uniqueStorage() implementation. - func generateUniqueStorage(printer p: inout CodePrinter) { - p.print("\(storageVisibility) mutating func _uniqueStorage() -> _StorageClass {\n") - p.indent() - p.print("if !isKnownUniquelyReferenced(&_storage) {\n") - p.indent() - p.print("_storage = _StorageClass(copying: _storage)\n") - p.outdent() - p.print( - "}\n", - "return _storage\n") - p.outdent() - p.print("}\n") - } - - func generatePreTraverse(printer p: inout CodePrinter) { - // Nothing - } - - /// Generates the stored properties for the storage class. - /// - /// - Parameter p: The code printer. - private func generateStoredProperties(printer p: inout CodePrinter) { - for f in fields { - f.generateStorage(printer: &p) + private let fields: [any FieldGenerator] + + /// Creates a new `MessageStorageClassGenerator`. + init(fields: [any FieldGenerator]) { + self.fields = fields + } + + /// Visibility of the storage within the Message. + var storageVisibility: String { + "fileprivate" + } + + /// If the storage wants to manually implement equality. + var storageProvidesEqualTo: Bool { false } + + /// Generates the full code for the storage class. + /// + /// - Parameter p: The code printer. + func generateTypeDeclaration(printer p: inout CodePrinter) { + p.print("fileprivate class _StorageClass {") + p.withIndentation { p in + generateStoredProperties(printer: &p) + // Generate a default instance to be used so the heap allocation is + // delayed until mutation is needed. This is the largest savings when + // the message is used as a field in another message as it causes + // returning the default to not require that heap allocation, i.e. - + // readonly usage never causes the allocation. + p.print( + """ + + // 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() + + private init() {} + + """ + ) + generateClone(printer: &p) + } + p.print("}") + } + + /// Generated the uniqueStorage() implementation. + func generateUniqueStorage(printer p: inout CodePrinter) { + p.print("\(storageVisibility) mutating func _uniqueStorage() -> _StorageClass {") + p.withIndentation { p in + p.print("if !isKnownUniquelyReferenced(&_storage) {") + p.printIndented("_storage = _StorageClass(copying: _storage)") + p.print( + "}", + "return _storage" + ) + } + p.print("}") } - } - - /// Generates the `init(copying:)` method of the storage class. - /// - /// - Parameter p: The code printer. - private func generateClone(printer p: inout CodePrinter) { - p.print("init(copying source: _StorageClass) {\n") - p.indent() - for f in fields { - f.generateStorageClassClone(printer: &p) + + func generatePreTraverse(printer p: inout CodePrinter) { + // Nothing + } + + /// Generates the stored properties for the storage class. + /// + /// - Parameter p: The code printer. + private func generateStoredProperties(printer p: inout CodePrinter) { + for f in fields { + f.generateStorage(printer: &p) + } + } + + /// Generates the `init(copying:)` method of the storage class. + /// + /// - Parameter p: The code printer. + private func generateClone(printer p: inout CodePrinter) { + p.print("init(copying source: _StorageClass) {") + p.withIndentation { p in + for f in fields { + f.generateStorageClassClone(printer: &p) + } + } + p.print("}") } - p.outdent() - p.print("}\n") - } } /// Custom generator for storage of an google.protobuf.Any. -class AnyMessageStorageClassGenerator : MessageStorageClassGenerator { - override var storageVisibility: String { return "internal" } - override var storageProvidesEqualTo: Bool { return true } - - override func generateTypeDeclaration(printer p: inout CodePrinter) { - // Just need an alias to the hand coded Storage. - p.print("typealias _StorageClass = AnyMessageStorage\n") - } - - override func generatePreTraverse(printer p: inout CodePrinter) { - p.print("try _storage.preTraverse()\n") - } +class AnyMessageStorageClassGenerator: MessageStorageClassGenerator { + override var storageVisibility: String { "internal" } + override var storageProvidesEqualTo: Bool { true } + + override func generateTypeDeclaration(printer p: inout CodePrinter) { + // Just need an alias to the hand coded Storage. + p.print("typealias _StorageClass = AnyMessageStorage") + } + + override func generatePreTraverse(printer p: inout CodePrinter) { + p.print("try _storage.preTraverse()") + } } diff --git a/Sources/protoc-gen-swift/MessageStorageDecision.swift b/Sources/protoc-gen-swift/MessageStorageDecision.swift index d43b71fcf..d471975c0 100644 --- a/Sources/protoc-gen-swift/MessageStorageDecision.swift +++ b/Sources/protoc-gen-swift/MessageStorageDecision.swift @@ -11,180 +11,192 @@ import SwiftProtobufPluginLibrary // The file attempts to isolate the decisions around when to use heap based -// storage vs. inlining it into the value times. At the moment the decicions +// storage vs. inlining it into the value times. At the moment the decisions // are entirely based on field counts and language requires, but this could be // revised in the future to better account for the actually *real* memory // impacts. -/// Wraps the calcuation of the "cost" of fields. +/// Wraps the calculation of the "cost" of fields. /// -/// As mentioned in the file comment, these numbers can be revised in the futute +/// As mentioned in the file comment, these numbers can be revised in the future /// to compute a real stack/heap cost if desired. -fileprivate enum FieldCost { - /// Of a repeated field. - static let repeated = 1 - /// Of a map field. - static let map = 1 - - /// Of "Plan Old Data" (ints, floating point) field that is 64 bits - static let singlePOD32 = 1 - /// Of "Plan Old Data" (ints, floating point) field that is 64 bits - static let singlePOD64 = 1 - /// Of bool field. - static let singleBool = 1 - /// Of a `string` field. - static let singleString = 1 - /// Of a `bytes` field. - static let singleBytes = 1 - - /// A single Message field where the message in question uses storgage. - static let singleMessageFieldUsingStorage = 1 - - static func estimate(_ field: FieldDescriptor) -> Int { - guard field.label != .repeated else { - // Repeated fields don't count the exact types, just fixed costs. - return field.isMap ? FieldCost.map : FieldCost.repeated - } +private enum FieldCost { + /// Of a repeated field. + static let repeated = 1 + /// Of a map field. + static let map = 1 + + /// Of "Plan Old Data" (ints, floating point) field that is 64 bits + static let singlePOD32 = 1 + /// Of "Plan Old Data" (ints, floating point) field that is 64 bits + static let singlePOD64 = 1 + /// Of bool field. + static let singleBool = 1 + /// Of a `string` field. + static let singleString = 1 + /// Of a `bytes` field. + static let singleBytes = 1 + + /// A single Message field where the message in question uses storage. + static let singleMessageFieldUsingStorage = 1 + + static func estimate(_ field: FieldDescriptor) -> Int { + guard !field.isRepeated else { + // Repeated fields don't count the exact types, just fixed costs. + return field.isMap ? FieldCost.map : FieldCost.repeated + } - switch field.type { - case .bool: - return 1 - case .int32, .sint32, .uint32, .fixed32, .sfixed32, .float, .enum: - return FieldCost.singlePOD32 - case .int64, .sint64, .uint64, .fixed64, .sfixed64, .double: - return FieldCost.singlePOD64 - case .string: - return FieldCost.singleString - case .bytes: - return FieldCost.singleBytes - case .group, .message: - return analyze(descriptor: field.messageType!).costAsField + switch field.type { + case .bool: + return 1 + case .int32, .sint32, .uint32, .fixed32, .sfixed32, .float, .enum: + return FieldCost.singlePOD32 + case .int64, .sint64, .uint64, .fixed64, .sfixed64, .double: + return FieldCost.singlePOD64 + case .string: + return FieldCost.singleString + case .bytes: + return FieldCost.singleBytes + case .group, .message: + return analyze(descriptor: field.messageType!).costAsField + } } - } } -/// Maxium computed cost of a Message's fields allow before it uses Storage. -fileprivate let totalFieldCostRequiringStorage = 17 +/// Maximum computed cost of a Message's fields allow before it uses Storage. +private let totalFieldCostRequiringStorage = 17 /// The result of analysis, if the message should use heap storage and the /// cost of the message when used as a field in other messages. -fileprivate struct AnalyzeResult { - let usesStorage: Bool - let costAsField: Int - - init(usesStorage: Bool, costAsField: Int) { - precondition(costAsField < totalFieldCostRequiringStorage || usesStorage) - self.usesStorage = usesStorage - self.costAsField = costAsField - } - - @inlinable - init(_ costAsField: Int) { - self.init(usesStorage: false, costAsField: costAsField) - } - - /// The message should use storage. - static let useStorage = - AnalyzeResult(usesStorage: true, costAsField: FieldCost.singleMessageFieldUsingStorage) +private struct AnalyzeResult { + let usesStorage: Bool + let costAsField: Int + + init(usesStorage: Bool, costAsField: Int) { + precondition(costAsField < totalFieldCostRequiringStorage || usesStorage) + self.usesStorage = usesStorage + self.costAsField = costAsField + } + + @inlinable + init(_ costAsField: Int) { + self.init(usesStorage: false, costAsField: costAsField) + } + + /// The message should use storage. + static let useStorage = + AnalyzeResult(usesStorage: true, costAsField: FieldCost.singleMessageFieldUsingStorage) } +// This is adapted from SwiftNIO so sendable checks don't flag issues with +// `analysisCache`. Another option would be something like NIO's +// `LockedValueBox` or moving the entire handling to a Task. +private final class UnsafeMutableTransferBox { + var wrappedValue: Wrapped + init(_ wrappedValue: Wrapped) { + self.wrappedValue = wrappedValue + } +} + +extension UnsafeMutableTransferBox: @unchecked Sendable {} + /// Cache for the `analyze(descriptor:)` results to avoid doing them multiple /// times. -fileprivate var analysisCache: Dictionary = [ - // google.protobuf.Any can be seeded. - ".google.protobuf.Any": .useStorage, -] +private let analysisCache: UnsafeMutableTransferBox<[String: AnalyzeResult]> = .init([ + // google.protobuf.Any can be seeded. + "google.protobuf.Any": .useStorage +]) /// Analyze the given descriptor to decide if it should use storage and what /// the cost of it will be when appearing as a single field in another message. -fileprivate func analyze(descriptor: Descriptor) -> AnalyzeResult { - if let analysis = analysisCache[descriptor.fullName] { - return analysis - } - - func containsRecursiveSingularField(_ descriptor: Descriptor) -> Bool { - let initialFile = descriptor.file! - - func recursionHelper(_ descriptor: Descriptor, messageStack: [Descriptor]) -> Bool { - var messageStack = messageStack - messageStack.append(descriptor) - return descriptor.fields.contains { - guard $0.label != .repeated else { return false } - // Ignore fields that aren’t messages or groups. - guard $0.type == .message || $0.type == .group else { return false } - guard let messageType = $0.messageType else { return false } - - // Proto files are a graph without cycles, to be recursive, the messages - // in the cycle must be defined in the same file. - guard messageType.file === initialFile else { return false } - - // Did things recurse? - if let first = messageStack.firstIndex(where: { $0 === messageType }) { - // Mark all those in the loop as using storage. - for msg in messageStack[first.. AnalyzeResult { + if let analysis = analysisCache.wrappedValue[descriptor.fullName] { + return analysis } - return recursionHelper(descriptor, messageStack: []) - } + func containsRecursiveSingularField(_ descriptor: Descriptor) -> Bool { + let initialFile = descriptor.file + + func recursionHelper(_ descriptor: Descriptor, messageStack: [Descriptor]) -> Bool { + var messageStack = messageStack + messageStack.append(descriptor) + return descriptor.fields.contains { + guard !$0.isRepeated else { return false } + // Ignore fields that aren’t messages or groups. + guard $0.type == .message || $0.type == .group else { return false } + guard let messageType = $0.messageType else { return false } + + // Proto files are a graph without cycles, to be recursive, the messages + // in the cycle must be defined in the same file. + guard messageType.file === initialFile else { return false } + + // Did things recurse? + if let first = messageStack.firstIndex(where: { $0 === messageType }) { + // Mark all those in the loop as using storage. + for msg in messageStack[first.. AnalyzeResult { - if containsRecursiveSingularField(descriptor) { - return .useStorage + return recursionHelper(descriptor, messageStack: []) } - var fieldsCost: Int = 0 + func helper(_ descriptor: Descriptor) -> AnalyzeResult { + if containsRecursiveSingularField(descriptor) { + return .useStorage + } - // Compute a cost for all the fields that aren't in a oneof. - for f in descriptor.fields { - guard f.oneofIndex == nil else { continue } - fieldsCost += FieldCost.estimate(f) - if fieldsCost >= totalFieldCostRequiringStorage { - return .useStorage - } - } + var fieldsCost: Int = 0 - // Add in the cost of the largest field of each oneof. - for o in descriptor.oneofs { - var oneofCost: Int = 0 - for f in o.fields { - oneofCost = max(oneofCost, FieldCost.estimate(f)) - if (fieldsCost + oneofCost) >= totalFieldCostRequiringStorage { - return .useStorage + // Compute a cost for all the fields that aren't in a oneof. + for f in descriptor.fields { + guard f.oneofIndex == nil else { continue } + fieldsCost += FieldCost.estimate(f) + if fieldsCost >= totalFieldCostRequiringStorage { + return .useStorage + } } - } - fieldsCost += oneofCost - } - assert(fieldsCost <= totalFieldCostRequiringStorage) - return AnalyzeResult(fieldsCost) - } + // Add in the cost of the largest field of each oneof. + for o in descriptor.oneofs { + var oneofCost: Int = 0 + for f in o.fields { + oneofCost = max(oneofCost, FieldCost.estimate(f)) + if (fieldsCost + oneofCost) >= totalFieldCostRequiringStorage { + return .useStorage + } + } + fieldsCost += oneofCost + } + assert(fieldsCost <= totalFieldCostRequiringStorage) - let result = helper(descriptor) - analysisCache[descriptor.fullName] = result - return result + return AnalyzeResult(fieldsCost) + } + + let result = helper(descriptor) + analysisCache.wrappedValue[descriptor.fullName] = result + return result } /// Encapsulates the decision choices around when a Message should use /// heap based storage. enum MessageStorageDecision { - /// Compute if a message should use heap based sortage or not. - static func shouldUseHeapStorage(descriptor: Descriptor) -> Bool { - return analyze(descriptor: descriptor).usesStorage - } + /// Compute if a message should use heap based storage or not. + static func shouldUseHeapStorage(descriptor: Descriptor) -> Bool { + analyze(descriptor: descriptor).usesStorage + } } diff --git a/Sources/protoc-gen-swift/OneofGenerator.swift b/Sources/protoc-gen-swift/OneofGenerator.swift index 703389b7b..f7998481a 100644 --- a/Sources/protoc-gen-swift/OneofGenerator.swift +++ b/Sources/protoc-gen-swift/OneofGenerator.swift @@ -13,8 +13,8 @@ /// // ----------------------------------------------------------------------------- import Foundation -import SwiftProtobufPluginLibrary import SwiftProtobuf +import SwiftProtobufPluginLibrary class OneofGenerator { /// Custom FieldGenerator that caches come calculated strings, and bridges @@ -40,24 +40,26 @@ class OneofGenerator { } // Only valid on message fields. - var messageType: Descriptor { return fieldDescriptor.messageType } + var messageType: Descriptor? { fieldDescriptor.messageType } - init(descriptor: FieldDescriptor, namer: SwiftProtobufNamer) { + init(descriptor: FieldDescriptor, generatorOptions: GeneratorOptions, namer: SwiftProtobufNamer) { precondition(descriptor.oneofIndex != nil) // Set after creation. oneof = nil group = -1 - let names = namer.messagePropertyNames(field: descriptor, - prefixed: ".", - includeHasAndClear: false) + let names = namer.messagePropertyNames( + field: descriptor, + prefixed: ".", + includeHasAndClear: false + ) swiftName = names.name dottedSwiftName = names.prefixed swiftType = descriptor.swiftType(namer: namer) swiftDefaultValue = descriptor.swiftDefaultValue(namer: namer) protoGenericType = descriptor.protoGenericType - comments = descriptor.protoSourceComments() + comments = descriptor.protoSourceCommentsWithDeprecation(generatorOptions: generatorOptions) super.init(descriptor: descriptor) } @@ -98,7 +100,7 @@ class OneofGenerator { } var generateTraverseUsesLocals: Bool { - return oneof.generateTraverseUsesLocals + oneof.generateTraverseUsesLocals } func generateTraverse(printer p: inout CodePrinter) { @@ -123,14 +125,18 @@ class OneofGenerator { private let underscoreSwiftFieldName: String private let storedProperty: String - init(descriptor: OneofDescriptor, generatorOptions: GeneratorOptions, namer: SwiftProtobufNamer, usesHeapStorage: Bool) { - precondition(!descriptor.isSynthetic) + init( + descriptor: OneofDescriptor, + generatorOptions: GeneratorOptions, + namer: SwiftProtobufNamer, + usesHeapStorage: Bool + ) { self.oneofDescriptor = descriptor self.generatorOptions = generatorOptions self.namer = namer self.usesHeapStorage = usesHeapStorage - comments = descriptor.protoSourceComments() + comments = descriptor.protoSourceComments(generatorOptions: generatorOptions) swiftRelativeName = namer.relativeName(oneof: descriptor) swiftFullName = namer.fullName(oneof: descriptor) @@ -145,33 +151,39 @@ class OneofGenerator { } fields = descriptor.fields.map { - return MemberFieldGenerator(descriptor: $0, namer: namer) + MemberFieldGenerator( + descriptor: $0, + generatorOptions: generatorOptions, + namer: namer + ) } - fieldsSortedByNumber = fields.sorted {$0.number < $1.number} + fieldsSortedByNumber = fields.sorted { $0.number < $1.number } // Bucked these fields in continuous chunks based on the other fields // in the parent and the parent's extension ranges. Insert the `start` // from each extension range as an easy way to check for them being // mixed in between the fields. var parentNumbers = descriptor.containingType.fields.map { Int($0.number) } - parentNumbers.append(contentsOf: descriptor.containingType.normalizedExtensionRanges.map { Int($0.start) }) + parentNumbers.append( + contentsOf: descriptor.containingType._normalizedExtensionRanges.map { Int($0.lowerBound) } + ) var parentNumbersIterator = parentNumbers.sorted(by: { $0 < $1 }).makeIterator() var nextParentFieldNumber = parentNumbersIterator.next() var grouped = [[MemberFieldGenerator]]() var currentGroup = [MemberFieldGenerator]() for f in fieldsSortedByNumber { - let nextFieldNumber = f.number - if nextParentFieldNumber != nextFieldNumber { - if !currentGroup.isEmpty { - grouped.append(currentGroup) - currentGroup.removeAll() - } - while nextParentFieldNumber != nextFieldNumber { - nextParentFieldNumber = parentNumbersIterator.next() + let nextFieldNumber = f.number + if nextParentFieldNumber != nextFieldNumber { + if !currentGroup.isEmpty { + grouped.append(currentGroup) + currentGroup.removeAll() + } + while nextParentFieldNumber != nextFieldNumber { + nextParentFieldNumber = parentNumbersIterator.next() + } } - } - currentGroup.append(f) - nextParentFieldNumber = parentNumbersIterator.next() + currentGroup.append(f) + nextParentFieldNumber = parentNumbersIterator.next() } if !currentGroup.isEmpty { grouped.append(currentGroup) @@ -188,7 +200,7 @@ class OneofGenerator { } } - func fieldGenerator(forFieldNumber fieldNumber: Int) -> FieldGenerator { + func fieldGenerator(forFieldNumber fieldNumber: Int) -> any FieldGenerator { for f in fields { if f.number == fieldNumber { return f @@ -203,118 +215,78 @@ class OneofGenerator { // Repeat the comment from the oneof to provide some context // to this enum we generated. p.print( - "\n", - comments, - "\(visibility)enum \(swiftRelativeName): Equatable {\n") - p.indent() - - // Oneof case for each ivar - for f in fields { - p.print( - f.comments, - "case \(f.swiftName)(\(f.swiftType))\n") - } - - // A helper for isInitialized - let fieldsToCheck = fields.filter { - $0.isGroupOrMessage && $0.messageType.containsRequiredFields() - } - if !fieldsToCheck.isEmpty { - p.print( - "\n", - "fileprivate var isInitialized: Bool {\n") - p.indent() - if fieldsToCheck.count == 1 { - let f = fieldsToCheck.first! - p.print( - "guard case \(f.dottedSwiftName)(let v) = self else {return true}\n", - "return v.isInitialized\n") - } else if fieldsToCheck.count > 1 { - p.print( - "// The use of inline closures is to circumvent an issue where the compiler\n", - "// allocates stack space for every case branch when no optimizations are\n", - "// enabled. https://github.com/apple/swift-protobuf/issues/1034\n", - "switch self {\n") - for f in fieldsToCheck { - p.print("case \(f.dottedSwiftName): return {\n") - p.indent() - p.print("guard case \(f.dottedSwiftName)(let v) = self else { preconditionFailure() }\n") - p.print("return v.isInitialized\n") - p.outdent() - p.print("}()\n") - } - // If there were other cases, add a default. - if fieldsToCheck.count != fields.count { - p.print("default: return true\n") - } - p.print("}\n") - } - p.outdent() - p.print("}\n") - } + "", + "\(comments)\(visibility)enum \(swiftRelativeName): Equatable, Sendable {" + ) + p.withIndentation { p in + // Oneof case for each ivar + for f in fields { + p.print("\(f.comments)case \(f.swiftName)(\(f.swiftType))") + } - // Equatable conformance - p.print("\n") - p.outdent() - p.print("#if !swift(>=4.1)\n") - p.indent() - p.print( - "\(visibility)static func ==(lhs: \(swiftFullName), rhs: \(swiftFullName)) -> Bool {\n") - p.indent() - p.print( - "// The use of inline closures is to circumvent an issue where the compiler\n", - "// allocates stack space for every case branch when no optimizations are\n", - "// enabled. https://github.com/apple/swift-protobuf/issues/1034\n", - "switch (lhs, rhs) {\n") - for f in fields { - p.print( - "case (\(f.dottedSwiftName), \(f.dottedSwiftName)): return {\n") - p.indent() - p.print( - "guard case \(f.dottedSwiftName)(let l) = lhs, case \(f.dottedSwiftName)(let r) = rhs else { preconditionFailure() }\n", - "return l == r\n") - p.outdent() - p.print( - "}()\n") - } - if fields.count > 1 { - // A tricky edge case: If the oneof only has a single case, then - // the case pattern generated above is exhaustive and generating a - // default produces a compiler error. If there is more than one - // case, then the case patterns are not exhaustive (because we - // don't compare mismatched pairs), and we have to include a - // default. - p.print("default: return false\n") + // A helper for isInitialized + let fieldsToCheck = fields.filter { + $0.isGroupOrMessage && $0.messageType!.containsRequiredFields() + } + if !fieldsToCheck.isEmpty { + p.print( + "", + "fileprivate var isInitialized: Bool {" + ) + p.withIndentation { p in + if fieldsToCheck.count == 1 { + let f = fieldsToCheck.first! + p.print( + "guard case \(f.dottedSwiftName)(let v) = self else {return true}", + "return v.isInitialized" + ) + } else if fieldsToCheck.count > 1 { + p.print( + """ + // 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 self { + """ + ) + for f in fieldsToCheck { + p.print("case \(f.dottedSwiftName): return {") + p.printIndented( + "guard case \(f.dottedSwiftName)(let v) = self else { preconditionFailure() }", + "return v.isInitialized" + ) + p.print("}()") + } + // If there were other cases, add a default. + if fieldsToCheck.count != fields.count { + p.print("default: return true") + } + p.print("}") + } + } + p.print("}") + } + p.print() } - p.print("}\n") - p.outdent() - p.print("}\n") - p.outdent() - p.print("#endif\n") - p.print("}\n") - } - - func generateSendable(printer p: inout CodePrinter) { - // Once our minimum supported version has Data be Sendable, @unchecked could be removed. - p.print("extension \(swiftFullName): @unchecked Sendable {}\n") + p.print("}") } private func gerenateOneofEnumProperty(printer p: inout CodePrinter) { let visibility = generatorOptions.visibilitySourceSnippet - p.print("\n", comments) - + p.print() if usesHeapStorage { p.print( - "\(visibility)var \(swiftFieldName): \(swiftRelativeName)? {\n") - p.indent() - p.print( - "get {return _storage.\(underscoreSwiftFieldName)}\n", - "set {_uniqueStorage().\(underscoreSwiftFieldName) = newValue}\n") - p.outdent() - p.print("}\n") + "\(comments)\(visibility)var \(swiftFieldName): \(swiftRelativeName)? {" + ) + p.printIndented( + "get {return _storage.\(underscoreSwiftFieldName)}", + "set {_uniqueStorage().\(underscoreSwiftFieldName) = newValue}" + ) + p.print("}") } else { p.print( - "\(visibility)var \(swiftFieldName): \(swiftFullName)? = nil\n") + "\(comments)\(visibility)var \(swiftFieldName): \(swiftFullName)? = nil" + ) } } @@ -323,33 +295,36 @@ class OneofGenerator { func generateInterface(printer p: inout CodePrinter, field: MemberFieldGenerator) { // First field causes the oneof enum to get generated. if field === fields.first { - gerenateOneofEnumProperty(printer: &p) + gerenateOneofEnumProperty(printer: &p) } let getter = usesHeapStorage ? "_storage.\(underscoreSwiftFieldName)" : swiftFieldName // Within `set` below, if the oneof name was "newValue" then it has to // be qualified with `self.` to avoid the collision with the setter // parameter. - let setter = usesHeapStorage ? "_uniqueStorage().\(underscoreSwiftFieldName)" : (swiftFieldName == "newValue" ? "self.newValue" : swiftFieldName) + let setter = + usesHeapStorage + ? "_uniqueStorage().\(underscoreSwiftFieldName)" + : (swiftFieldName == "newValue" ? "self.newValue" : swiftFieldName) let visibility = generatorOptions.visibilitySourceSnippet p.print( - "\n", - field.comments, - "\(visibility)var \(field.swiftName): \(field.swiftType) {\n") - p.indent() - p.print("get {\n") - p.indent() - p.print( - "if case \(field.dottedSwiftName)(let v)? = \(getter) {return v}\n", - "return \(field.swiftDefaultValue)\n") - p.outdent() - p.print( - "}\n", - "set {\(setter) = \(field.dottedSwiftName)(newValue)}\n") - p.outdent() - p.print("}\n") + "", + "\(field.comments)\(visibility)var \(field.swiftName): \(field.swiftType) {" + ) + p.withIndentation { p in + p.print("get {") + p.printIndented( + "if case \(field.dottedSwiftName)(let v)? = \(getter) {return v}", + "return \(field.swiftDefaultValue)" + ) + p.print( + "}", + "set {\(setter) = \(field.dottedSwiftName)(newValue)}" + ) + } + p.print("}") } func generateStorage(printer p: inout CodePrinter, field: MemberFieldGenerator) { @@ -357,9 +332,9 @@ class OneofGenerator { guard field === fields.first else { return } if usesHeapStorage { - p.print("var \(underscoreSwiftFieldName): \(swiftFullName)?\n") + p.print("var \(underscoreSwiftFieldName): \(swiftFullName)?") } else { - // When not using heap stroage, no extra storage is needed because + // When not using heap storage, no extra storage is needed because // the public property for the oneof is the storage. } } @@ -368,47 +343,46 @@ class OneofGenerator { // First field causes the output. guard field === fields.first else { return } - p.print("\(underscoreSwiftFieldName) = source.\(underscoreSwiftFieldName)\n") + p.print("\(underscoreSwiftFieldName) = source.\(underscoreSwiftFieldName)") } func generateDecodeFieldCase(printer p: inout CodePrinter, field: MemberFieldGenerator) { - p.print("case \(field.number): try {\n") - p.indent() + p.print("case \(field.number): try {") + p.withIndentation { p in + let hadValueTest: String + if field.isGroupOrMessage { + // Messages need to fetch the current value so new fields are merged into the existing + // value + p.print( + "var v: \(field.swiftType)?", + "var hadOneofValue = false", + "if let current = \(storedProperty) {" + ) + p.printIndented( + "hadOneofValue = true", + "if case \(field.dottedSwiftName)(let m) = current {v = m}" + ) + p.print("}") + hadValueTest = "hadOneofValue" + } else { + p.print("var v: \(field.swiftType)?") + hadValueTest = "\(storedProperty) != nil" + } - let hadValueTest: String - if field.isGroupOrMessage { - // Messages need to fetch the current value so new fields are merged into the existing - // value - p.print( - "var v: \(field.swiftType)?\n", - "var hadOneofValue = false\n", - "if let current = \(storedProperty) {\n") - p.indent() p.print( - "hadOneofValue = true\n", - "if case \(field.dottedSwiftName)(let m) = current {v = m}\n") - p.outdent() - p.print("}\n") - hadValueTest = "hadOneofValue" - } else { - p.print("var v: \(field.swiftType)?\n") - hadValueTest = "\(storedProperty) != nil" + "try decoder.decodeSingular\(field.protoGenericType)Field(value: &v)", + "if let v = v {" + ) + p.printIndented( + "if \(hadValueTest) {try decoder.handleConflictingOneOf()}", + "\(storedProperty) = \(field.dottedSwiftName)(v)" + ) + p.print("}") } - - p.print( - "try decoder.decodeSingular\(field.protoGenericType)Field(value: &v)\n", - "if let v = v {\n") - p.indent() - p.print( - "if \(hadValueTest) {try decoder.handleConflictingOneOf()}\n", - "\(storedProperty) = \(field.dottedSwiftName)(v)\n") - p.outdent() - p.print("}\n") - p.outdent() - p.print("}()\n") + p.print("}()") } - var generateTraverseUsesLocals: Bool { return true } + var generateTraverseUsesLocals: Bool { true } func generateTraverse(printer p: inout CodePrinter, field: MemberFieldGenerator) { // First field in the group causes the output. @@ -416,29 +390,42 @@ class OneofGenerator { guard field === group.first else { return } if group.count == 1 { - p.print("try { if case \(field.dottedSwiftName)(let v)? = \(storedProperty) {\n") - p.indent() - p.print("try visitor.visitSingular\(field.protoGenericType)Field(value: v, fieldNumber: \(field.number))\n") - p.outdent() - p.print("} }()\n") + p.print("try { if case \(field.dottedSwiftName)(let v)? = \(storedProperty) {") + p.printIndented( + "try visitor.visitSingular\(field.protoGenericType)Field(value: v, fieldNumber: \(field.number))" + ) + p.print("} }()") } else { - p.print("switch \(storedProperty) {\n") - for f in group { - p.print("case \(f.dottedSwiftName)?: try {\n") - p.indent() - p.print("guard case \(f.dottedSwiftName)(let v)? = \(storedProperty) else { preconditionFailure() }\n") - p.print("try visitor.visitSingular\(f.protoGenericType)Field(value: v, fieldNumber: \(f.number))\n") - p.outdent() - p.print("}()\n") + let isOnlyGroup = fieldSortedGrouped.count == 1 + let maxCasesInSwitch = generatorOptions.maxCasesInSwitch + p.print("switch \(storedProperty) {") + for (idx, f) in group.enumerated() { + // Break up the switch stmt if we're past the limit. + // Only necessary with single group because we already + // use a default case with multiple groups + if isOnlyGroup, idx > 0, (idx % maxCasesInSwitch) == 0 { + p.print( + "default: break", + "}" + ) + p.print("switch \(storedProperty) {") + } + p.print("case \(f.dottedSwiftName)?: try {") + p.printIndented( + "guard case \(f.dottedSwiftName)(let v)? = \(storedProperty) else { preconditionFailure() }", + "try visitor.visitSingular\(f.protoGenericType)Field(value: v, fieldNumber: \(f.number))" + ) + p.print("}()") } - if fieldSortedGrouped.count == 1 { + if isOnlyGroup && group.count <= maxCasesInSwitch { // Cover not being set. - p.print("case nil: break\n") + p.print("case nil: break") } else { - // Multiple groups, cover other cases (or not being set). - p.print("default: break\n") + // Either we broke up the switch stmt or + // multiple groups, cover other cases (or not being set). + p.print("default: break") } - p.print("}\n") + p.print("}") } } @@ -449,14 +436,14 @@ class OneofGenerator { let lhsProperty: String let otherStoredProperty: String if usesHeapStorage { - lhsProperty = "_storage.\(underscoreSwiftFieldName)" - otherStoredProperty = "rhs_storage.\(underscoreSwiftFieldName)" + lhsProperty = "_storage.\(underscoreSwiftFieldName)" + otherStoredProperty = "rhs_storage.\(underscoreSwiftFieldName)" } else { - lhsProperty = "lhs.\(swiftFieldName)" - otherStoredProperty = "rhs.\(swiftFieldName)" + lhsProperty = "lhs.\(swiftFieldName)" + otherStoredProperty = "rhs.\(swiftFieldName)" } - p.print("if \(lhsProperty) != \(otherStoredProperty) {return false}\n") + p.print("if \(lhsProperty) != \(otherStoredProperty) {return false}") } func generateIsInitializedCheck(printer p: inout CodePrinter, field: MemberFieldGenerator) { @@ -465,10 +452,10 @@ class OneofGenerator { // Confirm there is message field with required fields. let firstRequired = fields.first { - $0.isGroupOrMessage && $0.messageType.containsRequiredFields() + $0.isGroupOrMessage && $0.messageType!.containsRequiredFields() } guard firstRequired != nil else { return } - p.print("if let v = \(storedProperty), !v.isInitialized {return false}\n") + p.print("if let v = \(storedProperty), !v.isInitialized {return false}") } } diff --git a/Sources/protoc-gen-swift/ProtoNameInstructionWriter.swift b/Sources/protoc-gen-swift/ProtoNameInstructionWriter.swift new file mode 100644 index 000000000..91610b962 --- /dev/null +++ b/Sources/protoc-gen-swift/ProtoNameInstructionWriter.swift @@ -0,0 +1,108 @@ +// Sources/protoc-gen-swift/ProtoNameInstructionWriter.swift - Name instruction writing helpers +// +// Copyright (c) 2014 - 2025 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +import SwiftProtobuf +import SwiftProtobufPluginLibrary + +/// A convenience wrapper that adds operations to write `ProtoNameInstruction`s and their operands +/// into bytecode streams. +struct ProtoNameInstructionWriter { + private(set) var bytecode = BytecodeWriter() + + /// The previous field or case number written to the stream, which is used to compute deltas. + private var previousNumber: Int32? = nil + + /// Indicates whether the parameterless `NameMap` initializer can be use because no instructions + /// were written to the bytecode stream. + var shouldUseEmptyNameMapInitializer: Bool { + !bytecode.hasData + } + + mutating func writeSame(number: Int32, name: String) { + let delta = delta(updatingToNextNumber: number) + if delta == 1 { + bytecode.writeOpcode(of: .sameNext) + } else { + bytecode.writeOpcode(of: .sameDelta) + bytecode.writeInt32(delta) + } + bytecode.writeNullTerminatedString(name) + } + + mutating func writeStandard(number: Int32, name: String) { + let delta = delta(updatingToNextNumber: number) + if delta == 1 { + bytecode.writeOpcode(of: .standardNext) + } else { + bytecode.writeOpcode(of: .standardDelta) + bytecode.writeInt32(delta) + } + bytecode.writeNullTerminatedString(name) + } + + mutating func writeUnique(number: Int32, protoName: String, jsonName: String?) { + let delta = delta(updatingToNextNumber: number) + if delta == 1 { + bytecode.writeOpcode(of: .uniqueNext) + } else { + bytecode.writeOpcode(of: .uniqueDelta) + bytecode.writeInt32(delta) + } + bytecode.writeNullTerminatedString(protoName) + bytecode.writeNullTerminatedString(jsonName ?? "") + } + + mutating func writeGroup(number: Int32, name: String) { + let delta = delta(updatingToNextNumber: number) + if delta == 1 { + bytecode.writeOpcode(of: .groupNext) + } else { + bytecode.writeOpcode(of: .groupDelta) + bytecode.writeInt32(delta) + } + bytecode.writeNullTerminatedString(name) + } + + mutating func writeAliased(_ descriptor: EnumValueDescriptor, aliases: [EnumValueDescriptor]) { + let delta = delta(updatingToNextNumber: descriptor.number) + if delta == 1 { + bytecode.writeOpcode(of: .aliasNext) + } else { + bytecode.writeOpcode(of: .aliasDelta) + bytecode.writeInt32(delta) + } + bytecode.writeNullTerminatedString(descriptor.name) + bytecode.writeNullTerminatedStringArray(aliases.map(\.name)) + } + + mutating func writeReservedName(_ name: String) { + bytecode.writeOpcode(of: .reservedName) + bytecode.writeNullTerminatedString(name) + } + + mutating func writeReservedNumbers(_ range: Range) { + bytecode.writeOpcode(of: .reservedNumbers) + bytecode.writeInt32(range.lowerBound) + bytecode.writeInt32(range.upperBound - range.lowerBound) + } + + /// Returns the delta between the given field/case number and the previous number, updating the + /// previous number afterwards to the new value. + private mutating func delta(updatingToNextNumber number: Int32) -> Int32 { + guard let previousNumber else { + previousNumber = number + return number + } + precondition(number >= previousNumber, "field/case numbers must be written in ascending order") + let delta = number - previousNumber + self.previousNumber = number + return delta + } +} diff --git a/Sources/protoc-gen-swift/ProvidesDeprecationComment+Extensions.swift b/Sources/protoc-gen-swift/ProvidesDeprecationComment+Extensions.swift new file mode 100644 index 000000000..fc10a05ec --- /dev/null +++ b/Sources/protoc-gen-swift/ProvidesDeprecationComment+Extensions.swift @@ -0,0 +1,30 @@ +// Sources/protoc-gen-swift/ProvidesSourceCodeLocation+Extensions.swift +// +// Copyright (c) 2014 - 2024 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +import Foundation +import SwiftProtobufPluginLibrary + +extension ProvidesSourceCodeLocation { + func protoSourceComments( + generatorOptions: GeneratorOptions, + commentPrefix: String = "///", + leadingDetachedPrefix: String? = nil + ) -> String { + if generatorOptions.experimentalStripNonfunctionalCodegen { + // Comments are inherently non-functional, and may change subtly on + // transformations. + return String() + } + return protoSourceComments( + commentPrefix: commentPrefix, + leadingDetachedPrefix: leadingDetachedPrefix + ) + } +} diff --git a/Sources/protoc-gen-swift/ProvidesSourceCodeLocation+Extensions.swift b/Sources/protoc-gen-swift/ProvidesSourceCodeLocation+Extensions.swift new file mode 100644 index 000000000..f9740c3f9 --- /dev/null +++ b/Sources/protoc-gen-swift/ProvidesSourceCodeLocation+Extensions.swift @@ -0,0 +1,31 @@ +// Sources/protoc-gen-swift/ProvidesDeprecationComment+Extensions.swift +// +// Copyright (c) 2014 - 2024 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +import Foundation +import SwiftProtobufPluginLibrary + +extension ProvidesDeprecationComment where Self: ProvidesSourceCodeLocation { + func protoSourceCommentsWithDeprecation( + generatorOptions: GeneratorOptions, + commentPrefix: String = "///", + leadingDetachedPrefix: String? = nil + ) -> String { + if generatorOptions.experimentalStripNonfunctionalCodegen { + // Comments are inherently non-functional, and may change subtly on + // transformations. + return deprecationComment(commentPrefix: commentPrefix) + } + + return protoSourceCommentsWithDeprecation( + commentPrefix: commentPrefix, + leadingDetachedPrefix: leadingDetachedPrefix + ) + } +} diff --git a/Sources/protoc-gen-swift/Range+Extensions.swift b/Sources/protoc-gen-swift/Range+Extensions.swift new file mode 100644 index 000000000..e60c0f58f --- /dev/null +++ b/Sources/protoc-gen-swift/Range+Extensions.swift @@ -0,0 +1,83 @@ +// Sources/protoc-gen-swift/Range+Extensions.swift - Descriptor extensions +// +// Copyright (c) 2014 - 2016 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// Extensions to `Range` that provide Swift-generation-specific +/// functionality. +/// +// ----------------------------------------------------------------------------- + +import Foundation +import SwiftProtobuf +import SwiftProtobufPluginLibrary + +extension Range where Bound == Int32 { + + /// A `String` containing the Swift expression that represents this range to + /// be used in a `case` statement. + var swiftCaseExpression: String { + if lowerBound == upperBound - 1 { + return "\(lowerBound)" + } + return "\(lowerBound)..<\(upperBound)" + } + + /// A `String` containing the Swift Boolean expression that tests the given + /// variable for containment within this range. + /// + /// - Parameter variable: The name of the variable to test in the expression. + /// - Returns: A `String` containing the Boolean expression. + func swiftBooleanExpression(variable: String) -> String { + if lowerBound == upperBound - 1 { + return "\(lowerBound) == \(variable)" + } + return "\(lowerBound) <= \(variable) && \(variable) < \(upperBound)" + } + +} + +extension Array where Element == Range { + + /// A `String` containing a comma-delimited list of Swift expressions for + /// the ranges. + /// + /// This expression list is suitable as a pattern match in a `case` + /// statement. For example, `"case 5..<10, 15, 20..<30:"`. + /// + /// - Returns: A `String` containing the comma-delimited expressions. + var swiftCaseExpression: String { + map { $0.swiftCaseExpression }.joined(separator: ", ") + } + + /// A `String` containing a Swift Boolean expression that tests if the given + /// variable is in any of ranges. + /// + /// - Parameter variable: The name of the variable to test in the expression. + /// - Returns: A `String` containing the Boolean expression. + func swiftBooleanExpression(variable: String) -> String { + map { + "(\($0.swiftBooleanExpression(variable: variable)))" + }.joined(separator: " || ") + } + + /// Helper tha will take an array of Ranges and sort them and then merge any that are + /// continuous (i.e. - [(21,30),(10,20)] -> [(10,30)]) + func sortAndMergeContinuous() -> [Range] { + var ordered = self.sorted(by: { $0.lowerBound < $1.lowerBound }) + if ordered.count > 1 { + for i in (0..<(ordered.count - 1)).reversed() { + if ordered[i].upperBound == ordered[i + 1].lowerBound { + ordered[i] = ordered[i].lowerBound.. (dir:String, base:String, suffix:String) { - var dir = "" - var base = "" - var suffix = "" - for c in pathname { - if c == "/" { - dir += base + suffix + String(c) - base = "" - suffix = "" - } else if c == "." { - base += suffix - suffix = String(c) - } else { - suffix += String(c) +func splitPath(pathname: String) -> (dir: String, base: String, suffix: String) { + var dir = "" + var base = "" + var suffix = "" + for c in pathname { + if c == "/" { + dir += base + suffix + String(c) + base = "" + suffix = "" + } else if c == "." { + base += suffix + suffix = String(c) + } else { + suffix += String(c) + } } - } - let validSuffix = suffix.isEmpty || suffix.first == "." - if !validSuffix { - base += suffix - suffix = "" - } - return (dir: dir, base: base, suffix: suffix) -} - -func partition(string: String, atFirstOccurrenceOf substring: String) -> (String, String) { - guard let index = string.range(of: substring)?.lowerBound else { - return (string, "") - } - return (String(string[.. [(key:String, value:String)] { - guard let string = string, !string.isEmpty else { - return [] - } - let parts = string.components(separatedBy: ",") - let asPairs = parts.map { partition(string: $0, atFirstOccurrenceOf: "=") } - let result = asPairs.map { (key:trimWhitespace($0), value:trimWhitespace($1)) } - return result -} - -func trimWhitespace(_ s: String) -> String { - return s.trimmingCharacters(in: .whitespacesAndNewlines) + let validSuffix = suffix.isEmpty || suffix.first == "." + if !validSuffix { + base += suffix + suffix = "" + } + return (dir: dir, base: base, suffix: suffix) } /// The protoc parser emits byte literals using an escaped C convention. /// Fortunately, it uses only a limited subset of the C escapse: /// \n\r\t\\\'\" and three-digit octal escapes but nothing else. func escapedToDataLiteral(_ s: String) -> String { - if s.isEmpty { - return "Data()" - } - var out = "Data([" - var separator = "" - var escape = false - var octal = 0 - var octalAccumulator = 0 - for c in s.utf8 { - if octal > 0 { - precondition(c >= 48 && c < 56) - octalAccumulator <<= 3 - octalAccumulator |= (Int(c) - 48) - octal -= 1 - if octal == 0 { - out += separator - out += "\(octalAccumulator)" - separator = ", " - } - } else if escape { - switch c { - case 110: - out += separator - out += "10" - separator = ", " - case 114: - out += separator - out += "13" - separator = ", " - case 116: - out += separator - out += "9" - separator = ", " - case 48..<56: - octal = 2 // 2 more digits - octalAccumulator = Int(c) - 48 - default: - out += separator - out += "\(c)" - separator = ", " - } - escape = false - } else if c == 92 { // backslash - escape = true - } else { - out += separator - out += "\(c)" - separator = ", " + if s.isEmpty { + return "Data()" } - } - out += "])" - return out + var out = "Data([" + var separator = "" + var escape = false + var octal = 0 + var octalAccumulator = 0 + for c in s.utf8 { + if octal > 0 { + precondition(c >= 48 && c < 56) + octalAccumulator <<= 3 + octalAccumulator |= (Int(c) - 48) + octal -= 1 + if octal == 0 { + out += separator + out += "\(octalAccumulator)" + separator = ", " + } + } else if escape { + switch c { + case 110: + out += separator + out += "10" + separator = ", " + case 114: + out += separator + out += "13" + separator = ", " + case 116: + out += separator + out += "9" + separator = ", " + case 48..<56: + octal = 2 // 2 more digits + octalAccumulator = Int(c) - 48 + default: + out += separator + out += "\(c)" + separator = ", " + } + escape = false + } else if c == 92 { // backslash + escape = true + } else { + out += separator + out += "\(c)" + separator = ", " + } + } + out += "])" + return out } /// Generate a Swift string literal suitable for including in @@ -120,26 +98,26 @@ func escapedToDataLiteral(_ s: String) -> String { private let hexdigits = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"] func stringToEscapedStringLiteral(_ s: String) -> String { - if s.isEmpty { - return "String()" - } - var out = "\"" - for c in s.unicodeScalars { - switch c.value { - case 0: - out += "\\0" - case 1..<32: - let n = Int(c.value) - let hex1 = hexdigits[(n >> 4) & 15] - let hex2 = hexdigits[n & 15] - out += "\\u{" + hex1 + hex2 + "}" - case 34: - out += "\\\"" - case 92: - out += "\\\\" - default: - out.append(String(c)) + if s.isEmpty { + return "String()" + } + var out = "\"" + for c in s.unicodeScalars { + switch c.value { + case 0: + out += "\\0" + case 1..<32: + let n = Int(c.value) + let hex1 = hexdigits[(n >> 4) & 15] + let hex2 = hexdigits[n & 15] + out += "\\u{" + hex1 + hex2 + "}" + case 34: + out += "\\\"" + case 92: + out += "\\\\" + default: + out.append(String(c)) + } } - } - return out + "\"" + return out + "\"" } diff --git a/Sources/protoc-gen-swift/SwiftGeneratorPlugin.swift b/Sources/protoc-gen-swift/SwiftGeneratorPlugin.swift new file mode 100644 index 000000000..86ed878e8 --- /dev/null +++ b/Sources/protoc-gen-swift/SwiftGeneratorPlugin.swift @@ -0,0 +1,108 @@ +// Sources/protoc-gen-swift/SwiftGeneratorPlugin.swift +// +// Copyright (c) 2014 - 2016 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// A protoc plugin is a code generator that accepts a protobuf-encoded +/// request on stdin and writes the protobuf-encoded response to stdout. +/// When protoc sees a command-line option of the form `--foo_out=`, +/// it will run a program called `protoc-gen-foo` as the corresponding +/// plugin. +/// +// ----------------------------------------------------------------------------- + +import Foundation +import SwiftProtobuf +import SwiftProtobufPluginLibrary + +@main +struct SwiftGeneratorPlugin: CodeGenerator { + + func generate( + files: [SwiftProtobufPluginLibrary.FileDescriptor], + parameter: any CodeGeneratorParameter, + protoCompilerContext: any SwiftProtobufPluginLibrary.ProtoCompilerContext, + generatorOutputs: any SwiftProtobufPluginLibrary.GeneratorOutputs + ) throws { + let options = try GeneratorOptions(parameter: parameter) + + auditProtoCVersion(context: protoCompilerContext) + var errorString: String? = nil + for fileDescriptor in files { + let fileGenerator = FileGenerator(fileDescriptor: fileDescriptor, generatorOptions: options) + var printer = CodePrinter(addNewlines: true) + fileGenerator.generateOutputFile(printer: &printer, errorString: &errorString) + if let errorString = errorString { + // If generating multiple files, scope the message with the file that triggered it. + let fullError = files.count > 1 ? "\(fileDescriptor.name): \(errorString)" : errorString + throw GenerationError.message(message: fullError) + } + try generatorOutputs.add(fileName: fileGenerator.outputFilename, contents: printer.content) + } + } + + var supportedFeatures: [SwiftProtobufPluginLibrary.Google_Protobuf_Compiler_CodeGeneratorResponse.Feature] = [ + .proto3Optional, .supportsEditions, + ] + + var supportedEditionRange: ClosedRange { + Google_Protobuf_Edition.proto2...Google_Protobuf_Edition.edition2024 + } + + var version: String? { "\(SwiftProtobuf.Version.versionString)" } + var copyrightLine: String? { "\(Version.copyright)" } + var projectURL: String? { "https://github.com/apple/swift-protobuf" } + + private func auditProtoCVersion(context: any SwiftProtobufPluginLibrary.ProtoCompilerContext) { + guard context.version != nil else { + Stderr.print("WARNING: unknown version of protoc, use 3.2.x or later to ensure JSON support is correct.") + return + } + // 3.2.x is what added the compiler_version, so there is no need to + // ensure that the version of protoc being used is newer, if the field + // is there, the JSON support should be good. + } + + // Provide an expanded version of help. + func printHelp() { + print( + """ + \(CommandLine.programName): Convert parsed proto definitions into Swift + + \(Version.copyright) + + Note: This is a plugin for protoc and should not normally be run + directly. + + If you invoke a recent version of protoc with the --swift_out= + option, then protoc will search the current PATH for protoc-gen-swift + and use it to generate Swift output. + + In particular, if you have renamed this program, you will need to + adjust the protoc command-line option accordingly. + + The generated Swift output requires the SwiftProtobuf \(version!) + library be included in your project. + + If you use `swift build` to compile your project, add this to + Package.swift: + + dependencies: [ + .package(name: "SwiftProtobuf", url: "https://github.com/apple/swift-protobuf.git", from: "\(version!)"), + ] + + Usage: \(CommandLine.programName) [options] [filename...] + + -h|--help: Print this help message + --version: Print the program version + + """ + ) + } + +} diff --git a/Sources/protoc-gen-swift/SwiftProtobufNamer+Extensions.swift b/Sources/protoc-gen-swift/SwiftProtobufNamer+Extensions.swift new file mode 100644 index 000000000..2f54bda48 --- /dev/null +++ b/Sources/protoc-gen-swift/SwiftProtobufNamer+Extensions.swift @@ -0,0 +1,46 @@ +// Sources/SwiftProtobufPluginLibrary/SwiftProtobufNamer.swift - A helper that generates SwiftProtobuf names. +// +// Copyright (c) 2014 - 2017 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// A helper that can generate SwiftProtobuf names from types. +/// +// ----------------------------------------------------------------------------- + +import SwiftProtobufPluginLibrary + +extension SwiftProtobufNamer { + + /// Filters the Enum's values to those that will have unique Swift + /// names. Only poorly named proto enum alias values get filtered + /// away, so the assumption is they aren't really needed from an + /// api pov. + package func uniquelyNamedValues( + valueAliasInfo aliasInfo: EnumDescriptor.ValueAliasInfo + ) -> [EnumValueDescriptor] { + aliasInfo.mainValues.first!.enumType.values.filter { + // Original are kept as is. The computations for relative + // name already adds values for collisions with different + // values. + guard let aliasOf = aliasInfo.original(of: $0) else { return true } + let relativeName = self.relativeName(enumValue: $0) + let aliasOfRelativeName = self.relativeName(enumValue: aliasOf) + // If the relative name matches for the alias and original, drop + // the alias. + guard relativeName != aliasOfRelativeName else { return false } + // Only include this alias if it is the first one with this name. + // (handles alias with different cases in their names that get + // mangled to a single Swift name.) + let firstAlias = aliasInfo.aliases(aliasOf)!.firstIndex { + let otherRelativeName = self.relativeName(enumValue: $0) + return relativeName == otherRelativeName + } + return aliasInfo.aliases(aliasOf)![firstAlias!] === $0 + } + } +} diff --git a/Sources/protoc-gen-swift/Version.swift b/Sources/protoc-gen-swift/Version.swift index ef32a3e01..59f9735e7 100644 --- a/Sources/protoc-gen-swift/Version.swift +++ b/Sources/protoc-gen-swift/Version.swift @@ -15,16 +15,14 @@ import SwiftProtobuf struct Version { - // The "compatibility version" of the runtime library, which must be - // incremented every time a breaking change (either behavioral or - // API-changing) is introduced. + // The "compatibility version" of the runtime library, which must be incremented + // every time a breaking change (either behavioral or API-changing) is introduced + // and the current runtime can no longer support older generated code. // - // We guarantee that generated protos that contain this version token will - // be compatible with the runtime library containing the matching token. - // Therefore, this number (and the corresponding one in the runtime - // library) should not be updated for *every* version of Swift Protobuf, - // but only for those that introduce breaking changes (either behavioral - // or API-changing). + // This matches the value in the runtime library itself, this is what is recorded + // into the generated code. This library ensures that generated code from a given + // version will work with the current and future versions (that share this + // `compatibilityVersion` value), but may not work with older versions. static let compatibilityVersion = 2 static let copyright = "Copyright (C) 2014-2017 Apple Inc. and the project authors" diff --git a/Sources/protoc-gen-swift/main.swift b/Sources/protoc-gen-swift/main.swift deleted file mode 100644 index f01ee65cc..000000000 --- a/Sources/protoc-gen-swift/main.swift +++ /dev/null @@ -1,273 +0,0 @@ -// Sources/protoc-gen-swift/main.swift - Protoc plugin main -// -// Copyright (c) 2014 - 2016 Apple Inc. and the project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See LICENSE.txt for license information: -// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt -// -// ----------------------------------------------------------------------------- -/// -/// A protoc plugin is a code generator that accepts a protobuf-encoded -/// request on stdin and writes the protobuf-encoded response to stdout. -/// When protoc sees a command-line option of the form --foo_out=, -/// it will run a program called `protoc-gen-foo` as the corresponding -/// plugin. -/// -/// The request contains FileDescriptors with the parsed proto files -/// to be processed and some additional processing information. -/// -// ----------------------------------------------------------------------------- - -import Foundation -import SwiftProtobuf -import SwiftProtobufPluginLibrary - -extension Google_Protobuf_Compiler_Version { - fileprivate var versionString: String { - if !suffix.isEmpty { - return "\(major).\(minor).\(patch).\(suffix)" - } - return "\(major).\(minor).\(patch)" - } -} - -struct GeneratorPlugin { - private enum Mode { - case showHelp - case showVersion - case generateFromStdin - case generateFromFiles(paths: [String]) - } - - func run(args: [String]) -> Int32 { - var result: Int32 = 0 - - let mode = parseCommandLine(args: args) - switch mode { - case .showHelp: - showHelp() - case .showVersion: - showVersion() - case .generateFromStdin: - result = generateFromStdin() - case .generateFromFiles(let paths): - result = generateFromFiles(paths) - } - - return result - } - - private func parseCommandLine(args: [String]) -> Mode { - var paths: [String] = [] - for arg in args { - switch arg { - case "-h", "--help": - return .showHelp - case "--version": - return .showVersion - default: - if arg.hasPrefix("-") { - Stderr.print("Unknown argument: \"\(arg)\"") - return .showHelp - } else { - paths.append(arg) - } - } - } - return paths.isEmpty ? .generateFromStdin : .generateFromFiles(paths: paths) - } - - private func showHelp() { - print("\(CommandLine.programName): Convert parsed proto definitions into Swift") - print("") - showVersion() - print(Version.copyright) - print("") - - let version = SwiftProtobuf.Version.self - let packageVersion = "\(version.major),\(version.minor),\(version.revision)" - - let help = ( - "Note: This is a plugin for protoc and should not normally be run\n" - + "directly.\n" - + "\n" - + "If you invoke a recent version of protoc with the --swift_out=\n" - + "option, then protoc will search the current PATH for protoc-gen-swift\n" - + "and use it to generate Swift output.\n" - + "\n" - + "In particular, if you have renamed this program, you will need to\n" - + "adjust the protoc command-line option accordingly.\n" - + "\n" - + "The generated Swift output requires the SwiftProtobuf \(SwiftProtobuf.Version.versionString)\n" - + "library be included in your project.\n" - + "\n" - + "If you use `swift build` to compile your project, add this to\n" - + "Package.swift:\n" - + "\n" - + " dependencies: [\n" - + " .package(name: \"SwiftProtobuf\", url: \"https://github.com/apple/swift-protobuf.git\", from: \"\(packageVersion)\")," - + " ]\n" - + "\n" - + "\n" - + "Usage: \(CommandLine.programName) [options] [filename...]\n" - + "\n" - + " -h|--help: Print this help message\n" - + " --version: Print the program version\n" - + "\n" - + "Filenames specified on the command line indicate binary-encoded\n" - + "google.protobuf.compiler.CodeGeneratorRequest objects that will\n" - + "be read and converted to Swift source code. The source text will be\n" - + "written directly to stdout.\n" - + "\n" - + "When invoked with no filenames, it will read a single binary-encoded\n" - + "google.protobuf.compiler.CodeGeneratorRequest object from stdin and\n" - + "emit the corresponding CodeGeneratorResponse object to stdout.\n") - - print(help) - } - - private func showVersion() { - print("\(CommandLine.programName) \(SwiftProtobuf.Version.versionString)") - } - - private func generateFromStdin() -> Int32 { - let requestData = FileHandle.standardInput.readDataToEndOfFile() - - // Support for loggin the request. Useful when protoc/protoc-gen-swift are - // being invoked from some build system/script. protoc-gen-swift supports - // loading a request as a command line argument to simplify debugging/etc. - if let dumpPath = ProcessInfo.processInfo.environment["PROTOC_GEN_SWIFT_LOG_REQUEST"], !dumpPath.isEmpty { - let dumpURL = URL(fileURLWithPath: dumpPath) - do { - try requestData.write(to: dumpURL) - } catch let e { - Stderr.print("Failed to write request to '\(dumpPath)', \(e)") - } - } - - let request: Google_Protobuf_Compiler_CodeGeneratorRequest - do { - request = try Google_Protobuf_Compiler_CodeGeneratorRequest(serializedData: requestData) - } catch let e { - Stderr.print("Request failed to decode: \(e)") - return 1 - } - - auditProtoCVersion(request: request) - let response = generate(request: request) - guard sendReply(response: response) else { return 1 } - return 0 - } - - private func generateFromFiles(_ paths: [String]) -> Int32 { - var result: Int32 = 0 - - for p in paths { - let requestData: Data - do { - requestData = try readFileData(filename: p) - } catch let e { - Stderr.print("Error reading from \(p) - \(e)") - result = 1 - continue - } - Stderr.print("Read request: \(requestData.count) bytes from \(p)") - - let request: Google_Protobuf_Compiler_CodeGeneratorRequest - do { - request = try Google_Protobuf_Compiler_CodeGeneratorRequest(serializedData: requestData) - } catch let e { - Stderr.print("Request failed to decode \(p): \(e)") - result = 1 - continue - } - - let response = generate(request: request) - if response.hasError { - Stderr.print("Error while generating from \(p) - \(response.error)") - result = 1 - } else { - for f in response.file { - print("+++ Begin File: \(f.name) +++") - print(!f.content.isEmpty ? f.content : "") - print("+++ End File: \(f.name) +++") - } - } - } - - return result - } - - private func generate( - request: Google_Protobuf_Compiler_CodeGeneratorRequest - ) -> Google_Protobuf_Compiler_CodeGeneratorResponse { - let options: GeneratorOptions - do { - options = try GeneratorOptions(parameter: request.parameter) - } catch GenerationError.unknownParameter(let name) { - return Google_Protobuf_Compiler_CodeGeneratorResponse( - error: "Unknown generation parameter '\(name)'") - } catch GenerationError.invalidParameterValue(let name, let value) { - return Google_Protobuf_Compiler_CodeGeneratorResponse( - error: "Unknown value for generation parameter '\(name)': '\(value)'") - } catch GenerationError.wrappedError(let message, let e) { - return Google_Protobuf_Compiler_CodeGeneratorResponse(error: "\(message): \(e)") - } catch let e { - return Google_Protobuf_Compiler_CodeGeneratorResponse( - error: "Internal Error parsing request options: \(e)") - } - - let descriptorSet = DescriptorSet(protos: request.protoFile) - - var errorString: String? = nil - var responseFiles: [Google_Protobuf_Compiler_CodeGeneratorResponse.File] = [] - for name in request.fileToGenerate { - let fileDescriptor = descriptorSet.lookupFileDescriptor(protoName: name) - let fileGenerator = FileGenerator(fileDescriptor: fileDescriptor, generatorOptions: options) - var printer = CodePrinter() - fileGenerator.generateOutputFile(printer: &printer, errorString: &errorString) - if let errorString = errorString { - // If generating multiple files, scope the message with the file that triggered it. - let fullError = request.fileToGenerate.count > 1 ? "\(name): \(errorString)" : errorString - return Google_Protobuf_Compiler_CodeGeneratorResponse(error: fullError) - } - responseFiles.append( - Google_Protobuf_Compiler_CodeGeneratorResponse.File(name: fileGenerator.outputFilename, - content: printer.content)) - } - return Google_Protobuf_Compiler_CodeGeneratorResponse(files: responseFiles, - supportedFeatures: [.proto3Optional]) - } - - private func auditProtoCVersion(request: Google_Protobuf_Compiler_CodeGeneratorRequest) { - guard request.hasCompilerVersion else { - Stderr.print("WARNING: unknown version of protoc, use 3.2.x or later to ensure JSON support is correct.") - return - } - // 3.2.x is what added the compiler_version, so there is no need to - // ensure that the version of protoc being used is newer, if the field - // is there, the JSON support should be good. - } - - private func sendReply(response: Google_Protobuf_Compiler_CodeGeneratorResponse) -> Bool { - let serializedResponse: Data - do { - serializedResponse = try response.serializedData() - } catch let e { - Stderr.print("Failure while serializing response: \(e)") - return false - } - FileHandle.standardOutput.write(serializedResponse) - return true - } - -} - -// MARK: - Hand off to the GeneratorPlugin - -// Drop the program name off to get the arguments only. -let args: [String] = [String](CommandLine.arguments.dropFirst(1)) -let plugin = GeneratorPlugin() -let result = plugin.run(args: args) -exit(result) diff --git a/SwiftProtobuf.podspec b/SwiftProtobuf.podspec index d26bbbb54..5f8379962 100644 --- a/SwiftProtobuf.podspec +++ b/SwiftProtobuf.podspec @@ -1,21 +1,28 @@ Pod::Spec.new do |s| s.name = 'SwiftProtobuf' - s.version = '1.18.0' + s.version = '1.33.3' s.license = { :type => 'Apache 2.0', :file => 'LICENSE.txt' } - s.summary = 'Swift Protobuf code generator plugin and runtime library' + s.summary = 'Swift Protobuf Runtime Library' s.homepage = 'https://github.com/apple/swift-protobuf' s.author = 'Apple Inc.' s.source = { :git => 'https://github.com/apple/swift-protobuf.git', :tag => s.version } s.requires_arc = true - s.ios.deployment_target = '9.0' - s.osx.deployment_target = '10.9' - s.tvos.deployment_target = '9.0' - s.watchos.deployment_target = '2.0' + s.ios.deployment_target = '11.0' + s.osx.deployment_target = '10.13' + s.tvos.deployment_target = '11.0' + s.watchos.deployment_target = '4.0' + s.visionos.deployment_target = "1.0" - s.cocoapods_version = '>= 1.7.0' + s.cocoapods_version = '>= 1.13.0' + + # Support `package` visibility. + s.pod_target_xcconfig = { + 'OTHER_SWIFT_FLAGS' => '-package-name SwiftProtobuf' + } s.source_files = 'Sources/SwiftProtobuf/**/*.swift' + s.resource_bundle = {'SwiftProtobuf' => ['Sources/SwiftProtobuf/PrivacyInfo.xcprivacy']} - s.swift_versions = ['4.0', '4.2', '5.0'] + s.swift_versions = ['5.0'] end diff --git a/SwiftProtobuf.xcodeproj/ProtobufTestSuite_Info.plist b/SwiftProtobuf.xcodeproj/ProtobufTestSuite_Info.plist deleted file mode 100644 index 7c23420d0..000000000 --- a/SwiftProtobuf.xcodeproj/ProtobufTestSuite_Info.plist +++ /dev/null @@ -1,25 +0,0 @@ - - - - CFBundleDevelopmentRegion - en - CFBundleExecutable - $(EXECUTABLE_NAME) - CFBundleIdentifier - $(PRODUCT_BUNDLE_IDENTIFIER) - CFBundleInfoDictionaryVersion - 6.0 - CFBundleName - $(PRODUCT_NAME) - CFBundlePackageType - BNDL - CFBundleShortVersionString - 1.0 - CFBundleSignature - ???? - CFBundleVersion - $(CURRENT_PROJECT_VERSION) - NSPrincipalClass - - - diff --git a/SwiftProtobuf.xcodeproj/Protobuf_Info.plist b/SwiftProtobuf.xcodeproj/Protobuf_Info.plist deleted file mode 100644 index 57ada9f9d..000000000 --- a/SwiftProtobuf.xcodeproj/Protobuf_Info.plist +++ /dev/null @@ -1,25 +0,0 @@ - - - - CFBundleDevelopmentRegion - en - CFBundleExecutable - $(EXECUTABLE_NAME) - CFBundleIdentifier - $(PRODUCT_BUNDLE_IDENTIFIER) - CFBundleInfoDictionaryVersion - 6.0 - CFBundleName - $(PRODUCT_NAME) - CFBundlePackageType - FMWK - CFBundleShortVersionString - 1.0 - CFBundleSignature - ???? - CFBundleVersion - $(CURRENT_PROJECT_VERSION) - NSPrincipalClass - - - diff --git a/SwiftProtobuf.xcodeproj/project.pbxproj b/SwiftProtobuf.xcodeproj/project.pbxproj deleted file mode 100644 index 97ff78912..000000000 --- a/SwiftProtobuf.xcodeproj/project.pbxproj +++ /dev/null @@ -1,2369 +0,0 @@ -// !$*UTF8*$! -{ - archiveVersion = 1; - classes = { - }; - objectVersion = 46; - objects = { - -/* Begin PBXBuildFile section */ - 0353A1CE1E81623B00067996 /* any.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA43F1E7AE4AC004F6E95 /* any.pb.swift */; }; - 0353A1CF1E81624F00067996 /* any.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA43F1E7AE4AC004F6E95 /* any.pb.swift */; }; - 0353A1D01E81625400067996 /* any.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA43F1E7AE4AC004F6E95 /* any.pb.swift */; }; - 6583D6E4246E04A200353AF4 /* Test_JSON_Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 6583D6E3246E04A200353AF4 /* Test_JSON_Extensions.swift */; }; - 6583D6E5246E04A200353AF4 /* Test_JSON_Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 6583D6E3246E04A200353AF4 /* Test_JSON_Extensions.swift */; }; - 6583D6E6246E04A200353AF4 /* Test_JSON_Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 6583D6E3246E04A200353AF4 /* Test_JSON_Extensions.swift */; }; - 8037FC952507E4F4003B7FAC /* unittest_swift_json.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8037FC942507E4F4003B7FAC /* unittest_swift_json.pb.swift */; }; - 8037FC962507E4F4003B7FAC /* unittest_swift_json.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8037FC942507E4F4003B7FAC /* unittest_swift_json.pb.swift */; }; - 8037FC972507E4F4003B7FAC /* unittest_swift_json.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8037FC942507E4F4003B7FAC /* unittest_swift_json.pb.swift */; }; - 8DC1CA0D1E54B80800CA8A26 /* MathUtils.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8DC1CA0C1E54B80800CA8A26 /* MathUtils.swift */; }; - 8DC1CA0F1E54B81400CA8A26 /* TimeUtils.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8DC1CA0E1E54B81400CA8A26 /* TimeUtils.swift */; }; - 9C0B366B1E5FAB910094E128 /* JSONMapEncodingVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C0B366A1E5FAB910094E128 /* JSONMapEncodingVisitor.swift */; }; - 9C0B366C1E5FAB910094E128 /* JSONMapEncodingVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C0B366A1E5FAB910094E128 /* JSONMapEncodingVisitor.swift */; }; - 9C0B366D1E5FAB910094E128 /* JSONMapEncodingVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C0B366A1E5FAB910094E128 /* JSONMapEncodingVisitor.swift */; }; - 9C0B366E1E5FAB910094E128 /* JSONMapEncodingVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C0B366A1E5FAB910094E128 /* JSONMapEncodingVisitor.swift */; }; - 9C2F237B1D7780D1008524F2 /* api.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/api.pb.swift /* api.pb.swift */; }; - 9C2F237C1D7780D1008524F2 /* duration.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/duration.pb.swift /* duration.pb.swift */; }; - 9C2F237D1D7780D1008524F2 /* empty.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/empty.pb.swift /* empty.pb.swift */; }; - 9C2F237E1D7780D1008524F2 /* field_mask.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/field_mask.pb.swift /* field_mask.pb.swift */; }; - 9C2F23801D7780D1008524F2 /* Google_Protobuf_Duration+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/Google_Protobuf_Duration_Extensions.swift /* Google_Protobuf_Duration+Extensions.swift */; }; - 9C2F23811D7780D1008524F2 /* Google_Protobuf_FieldMask+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/Google_Protobuf_FieldMask_Extensions.swift /* Google_Protobuf_FieldMask+Extensions.swift */; }; - 9C2F23821D7780D1008524F2 /* Google_Protobuf_Struct+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/Google_Protobuf_Struct.swift /* Google_Protobuf_Struct+Extensions.swift */; }; - 9C2F23831D7780D1008524F2 /* Google_Protobuf_Timestamp+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/Google_Protobuf_Timestamp_Extensions.swift /* Google_Protobuf_Timestamp+Extensions.swift */; }; - 9C2F23851D7780D1008524F2 /* BinaryDecoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufBinaryDecoding.swift /* BinaryDecoder.swift */; }; - 9C2F23861D7780D1008524F2 /* BinaryEncoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufBinaryEncoding.swift /* BinaryEncoder.swift */; }; - 9C2F23871D7780D1008524F2 /* Message+BinaryAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufBinaryTypes.swift /* Message+BinaryAdditions.swift */; }; - 9C2F23891D7780D1008524F2 /* Enum.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufEnum.swift /* Enum.swift */; }; - 9C2F238B1D7780D1008524F2 /* ExtensionFields.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufExtensionFields.swift /* ExtensionFields.swift */; }; - 9C2F238C1D7780D1008524F2 /* MessageExtension.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufExtensions.swift /* MessageExtension.swift */; }; - 9C2F238D1D7780D1008524F2 /* Decoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufFieldDecoder.swift /* Decoder.swift */; }; - 9C2F238F1D7780D1008524F2 /* HashVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufHash.swift /* HashVisitor.swift */; }; - 9C2F23911D7780D1008524F2 /* JSONEncoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufJSONEncoding.swift /* JSONEncoder.swift */; }; - 9C2F23921D7780D1008524F2 /* Message+JSONAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufJSONTypes.swift /* Message+JSONAdditions.swift */; }; - 9C2F23931D7780D1008524F2 /* Message.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufMessage.swift /* Message.swift */; }; - 9C2F23981D7780D1008524F2 /* FieldTypes.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufTypes.swift /* FieldTypes.swift */; }; - 9C2F23991D7780D1008524F2 /* UnknownStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufUnknown.swift /* UnknownStorage.swift */; }; - 9C2F239B1D7780D1008524F2 /* source_context.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/source_context.pb.swift /* source_context.pb.swift */; }; - 9C2F239C1D7780D1008524F2 /* timestamp.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/timestamp.pb.swift /* timestamp.pb.swift */; }; - 9C2F239D1D7780D1008524F2 /* type.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/type.pb.swift /* type.pb.swift */; }; - 9C4178611E809DA2007830C3 /* ExtensionMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C4178601E809DA2007830C3 /* ExtensionMap.swift */; }; - 9C4178621E809DA2007830C3 /* ExtensionMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C4178601E809DA2007830C3 /* ExtensionMap.swift */; }; - 9C4178631E809DA2007830C3 /* ExtensionMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C4178601E809DA2007830C3 /* ExtensionMap.swift */; }; - 9C4178641E809DA2007830C3 /* ExtensionMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C4178601E809DA2007830C3 /* ExtensionMap.swift */; }; - 9C5890A71DFF5FFC001CFC34 /* Test_TextFormat_proto2_extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C5890A51DFF5EC8001CFC34 /* Test_TextFormat_proto2_extensions.swift */; }; - 9C5890A81DFF6375001CFC34 /* TextFormatDecoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = BCCA0E661DB1210E00957D74 /* TextFormatDecoder.swift */; }; - 9C5890A91DFF6375001CFC34 /* TextFormatEncoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = BCCA0E671DB1210E00957D74 /* TextFormatEncoder.swift */; }; - 9C5890AA1DFF6375001CFC34 /* TextFormatEncodingVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CEB0D671DF5E934002D80F0 /* TextFormatEncodingVisitor.swift */; }; - 9C5890AB1DFF6375001CFC34 /* TextFormatScanner.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CEB0D6B1DF5F921002D80F0 /* TextFormatScanner.swift */; }; - 9C5890AD1DFF6375001CFC34 /* Message+TextFormatAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = BCCA0E681DB1210E00957D74 /* Message+TextFormatAdditions.swift */; }; - 9C5890AE1DFF6384001CFC34 /* TextFormatDecoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = BCCA0E661DB1210E00957D74 /* TextFormatDecoder.swift */; }; - 9C5890AF1DFF6384001CFC34 /* TextFormatEncoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = BCCA0E671DB1210E00957D74 /* TextFormatEncoder.swift */; }; - 9C5890B01DFF6384001CFC34 /* TextFormatEncodingVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CEB0D671DF5E934002D80F0 /* TextFormatEncodingVisitor.swift */; }; - 9C5890B11DFF6384001CFC34 /* TextFormatScanner.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CEB0D6B1DF5F921002D80F0 /* TextFormatScanner.swift */; }; - 9C5890B31DFF6384001CFC34 /* Message+TextFormatAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = BCCA0E681DB1210E00957D74 /* Message+TextFormatAdditions.swift */; }; - 9C5890B41DFF6389001CFC34 /* TextFormatDecoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = BCCA0E661DB1210E00957D74 /* TextFormatDecoder.swift */; }; - 9C5890B51DFF6389001CFC34 /* TextFormatEncoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = BCCA0E671DB1210E00957D74 /* TextFormatEncoder.swift */; }; - 9C5890B61DFF6389001CFC34 /* TextFormatEncodingVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CEB0D671DF5E934002D80F0 /* TextFormatEncodingVisitor.swift */; }; - 9C5890B71DFF6389001CFC34 /* TextFormatScanner.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CEB0D6B1DF5F921002D80F0 /* TextFormatScanner.swift */; }; - 9C5890B91DFF6389001CFC34 /* Message+TextFormatAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = BCCA0E681DB1210E00957D74 /* Message+TextFormatAdditions.swift */; }; - 9C60CBE81DF8AC3F00F7B14E /* Test_TextFormat_Map_proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C60CBE71DF8AC3F00F7B14E /* Test_TextFormat_Map_proto3.swift */; }; - 9C60CBE91DF8AC3F00F7B14E /* Test_TextFormat_Map_proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C60CBE71DF8AC3F00F7B14E /* Test_TextFormat_Map_proto3.swift */; }; - 9C60CBEA1DF8AC3F00F7B14E /* Test_TextFormat_Map_proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C60CBE71DF8AC3F00F7B14E /* Test_TextFormat_Map_proto3.swift */; }; - 9C60CBEC1DF9DEEA00F7B14E /* Test_TextFormat_proto2.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C60CBEB1DF9DEEA00F7B14E /* Test_TextFormat_proto2.swift */; }; - 9C60CBED1DF9DEEA00F7B14E /* Test_TextFormat_proto2.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C60CBEB1DF9DEEA00F7B14E /* Test_TextFormat_proto2.swift */; }; - 9C60CBEE1DF9DEEA00F7B14E /* Test_TextFormat_proto2.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C60CBEB1DF9DEEA00F7B14E /* Test_TextFormat_proto2.swift */; }; - 9C667A911E4C203D008B974F /* JSONDecodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C667A8E1E4C203D008B974F /* JSONDecodingError.swift */; }; - 9C667A921E4C203D008B974F /* JSONDecodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C667A8E1E4C203D008B974F /* JSONDecodingError.swift */; }; - 9C667A931E4C203D008B974F /* JSONDecodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C667A8E1E4C203D008B974F /* JSONDecodingError.swift */; }; - 9C667A941E4C203D008B974F /* JSONDecodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C667A8E1E4C203D008B974F /* JSONDecodingError.swift */; }; - 9C667A951E4C203D008B974F /* BinaryDecodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C667A8F1E4C203D008B974F /* BinaryDecodingError.swift */; }; - 9C667A961E4C203D008B974F /* BinaryDecodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C667A8F1E4C203D008B974F /* BinaryDecodingError.swift */; }; - 9C667A971E4C203D008B974F /* BinaryDecodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C667A8F1E4C203D008B974F /* BinaryDecodingError.swift */; }; - 9C667A981E4C203D008B974F /* BinaryDecodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C667A8F1E4C203D008B974F /* BinaryDecodingError.swift */; }; - 9C667A991E4C203D008B974F /* TextFormatDecodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C667A901E4C203D008B974F /* TextFormatDecodingError.swift */; }; - 9C667A9A1E4C203D008B974F /* TextFormatDecodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C667A901E4C203D008B974F /* TextFormatDecodingError.swift */; }; - 9C667A9B1E4C203D008B974F /* TextFormatDecodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C667A901E4C203D008B974F /* TextFormatDecodingError.swift */; }; - 9C667A9C1E4C203D008B974F /* TextFormatDecodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C667A901E4C203D008B974F /* TextFormatDecodingError.swift */; }; - 9C7254661E5F9B1600486C98 /* Test_TextFormat_Unknown.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C7254651E5F9B1600486C98 /* Test_TextFormat_Unknown.swift */; }; - 9C7254671E5F9B1600486C98 /* Test_TextFormat_Unknown.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C7254651E5F9B1600486C98 /* Test_TextFormat_Unknown.swift */; }; - 9C7254681E5F9B1600486C98 /* Test_TextFormat_Unknown.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C7254651E5F9B1600486C98 /* Test_TextFormat_Unknown.swift */; }; - 9C75F8801DDBE0DE005CCFF2 /* Visitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F87F1DDBE0DE005CCFF2 /* Visitor.swift */; }; - 9C75F8811DDBE0FC005CCFF2 /* Visitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F87F1DDBE0DE005CCFF2 /* Visitor.swift */; }; - 9C75F8821DDBE10D005CCFF2 /* Visitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F87F1DDBE0DE005CCFF2 /* Visitor.swift */; }; - 9C75F8831DDBE118005CCFF2 /* Visitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F87F1DDBE0DE005CCFF2 /* Visitor.swift */; }; - 9C75F8851DDD3045005CCFF2 /* SimpleExtensionMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F8841DDD3045005CCFF2 /* SimpleExtensionMap.swift */; }; - 9C75F8861DDD3045005CCFF2 /* SimpleExtensionMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F8841DDD3045005CCFF2 /* SimpleExtensionMap.swift */; }; - 9C75F8871DDD3045005CCFF2 /* SimpleExtensionMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F8841DDD3045005CCFF2 /* SimpleExtensionMap.swift */; }; - 9C75F8881DDD3045005CCFF2 /* SimpleExtensionMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F8841DDD3045005CCFF2 /* SimpleExtensionMap.swift */; }; - 9C75F88A1DDD30A5005CCFF2 /* ExtensionFieldValueSet.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F8891DDD30A5005CCFF2 /* ExtensionFieldValueSet.swift */; }; - 9C75F88B1DDD30A5005CCFF2 /* ExtensionFieldValueSet.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F8891DDD30A5005CCFF2 /* ExtensionFieldValueSet.swift */; }; - 9C75F88C1DDD30A5005CCFF2 /* ExtensionFieldValueSet.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F8891DDD30A5005CCFF2 /* ExtensionFieldValueSet.swift */; }; - 9C75F88D1DDD30A5005CCFF2 /* ExtensionFieldValueSet.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F8891DDD30A5005CCFF2 /* ExtensionFieldValueSet.swift */; }; - 9C75F88F1DDD3108005CCFF2 /* ExtensibleMessage.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F88E1DDD3108005CCFF2 /* ExtensibleMessage.swift */; }; - 9C75F8901DDD3108005CCFF2 /* ExtensibleMessage.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F88E1DDD3108005CCFF2 /* ExtensibleMessage.swift */; }; - 9C75F8911DDD3108005CCFF2 /* ExtensibleMessage.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F88E1DDD3108005CCFF2 /* ExtensibleMessage.swift */; }; - 9C75F8921DDD3108005CCFF2 /* ExtensibleMessage.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F88E1DDD3108005CCFF2 /* ExtensibleMessage.swift */; }; - 9C75F8941DDD3D20005CCFF2 /* BinaryEncodingVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F8931DDD3D20005CCFF2 /* BinaryEncodingVisitor.swift */; }; - 9C75F8951DDD3D20005CCFF2 /* BinaryEncodingVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F8931DDD3D20005CCFF2 /* BinaryEncodingVisitor.swift */; }; - 9C75F8961DDD3D20005CCFF2 /* BinaryEncodingVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F8931DDD3D20005CCFF2 /* BinaryEncodingVisitor.swift */; }; - 9C75F8971DDD3D20005CCFF2 /* BinaryEncodingVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F8931DDD3D20005CCFF2 /* BinaryEncodingVisitor.swift */; }; - 9C75F89E1DDD3FA3005CCFF2 /* JSONDecoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F89D1DDD3FA3005CCFF2 /* JSONDecoder.swift */; }; - 9C75F89F1DDD3FA3005CCFF2 /* JSONDecoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F89D1DDD3FA3005CCFF2 /* JSONDecoder.swift */; }; - 9C75F8A01DDD3FA3005CCFF2 /* JSONDecoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F89D1DDD3FA3005CCFF2 /* JSONDecoder.swift */; }; - 9C75F8A11DDD3FA3005CCFF2 /* JSONDecoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F89D1DDD3FA3005CCFF2 /* JSONDecoder.swift */; }; - 9C75F8A31DDD44A1005CCFF2 /* ProtobufMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F8A21DDD44A1005CCFF2 /* ProtobufMap.swift */; }; - 9C75F8A41DDD44A1005CCFF2 /* ProtobufMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F8A21DDD44A1005CCFF2 /* ProtobufMap.swift */; }; - 9C75F8A51DDD44A1005CCFF2 /* ProtobufMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F8A21DDD44A1005CCFF2 /* ProtobufMap.swift */; }; - 9C75F8A61DDD44A1005CCFF2 /* ProtobufMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C75F8A21DDD44A1005CCFF2 /* ProtobufMap.swift */; }; - 9C84E48F1E5E3ABD00513BE0 /* BinaryEncodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C84E48C1E5E3ABD00513BE0 /* BinaryEncodingError.swift */; }; - 9C84E4901E5E3ABD00513BE0 /* BinaryEncodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C84E48C1E5E3ABD00513BE0 /* BinaryEncodingError.swift */; }; - 9C84E4911E5E3ABD00513BE0 /* BinaryEncodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C84E48C1E5E3ABD00513BE0 /* BinaryEncodingError.swift */; }; - 9C84E4921E5E3ABD00513BE0 /* BinaryEncodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C84E48C1E5E3ABD00513BE0 /* BinaryEncodingError.swift */; }; - 9C84E4931E5E3ABD00513BE0 /* JSONEncodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C84E48D1E5E3ABD00513BE0 /* JSONEncodingError.swift */; }; - 9C84E4941E5E3ABD00513BE0 /* JSONEncodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C84E48D1E5E3ABD00513BE0 /* JSONEncodingError.swift */; }; - 9C84E4951E5E3ABD00513BE0 /* JSONEncodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C84E48D1E5E3ABD00513BE0 /* JSONEncodingError.swift */; }; - 9C84E4961E5E3ABD00513BE0 /* JSONEncodingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C84E48D1E5E3ABD00513BE0 /* JSONEncodingError.swift */; }; - 9C8CDA171D7A288E00E207CA /* SwiftProtobuf.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = "_____Product_Protobuf_iOS" /* SwiftProtobuf.framework */; }; - 9C8CDA1D1D7A28F600E207CA /* any_test.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/any_test.pb.swift /* any_test.pb.swift */; }; - 9C8CDA1E1D7A28F600E207CA /* conformance.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/conformance.pb.swift /* conformance.pb.swift */; }; - 9C8CDA201D7A28F600E207CA /* TestHelpers.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/TestHelpers.swift /* TestHelpers.swift */; }; - 9C8CDA211D7A28F600E207CA /* map_unittest.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/map_unittest.pb.swift /* map_unittest.pb.swift */; }; - 9C8CDA231D7A28F600E207CA /* Test_AllTypes.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_AllTypes.swift /* Test_AllTypes.swift */; }; - 9C8CDA241D7A28F600E207CA /* Test_AllTypes_Proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_AllTypes_Proto3.swift /* Test_AllTypes_Proto3.swift */; }; - 9C8CDA251D7A28F600E207CA /* Test_Any.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Any.swift /* Test_Any.swift */; }; - 9C8CDA261D7A28F600E207CA /* Test_Api.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Api.swift /* Test_Api.swift */; }; - 9C8CDA271D7A28F600E207CA /* Test_Conformance.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Conformance.swift /* Test_Conformance.swift */; }; - 9C8CDA291D7A28F600E207CA /* Test_Duration.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Duration.swift /* Test_Duration.swift */; }; - 9C8CDA2A1D7A28F600E207CA /* Test_Empty.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Empty.swift /* Test_Empty.swift */; }; - 9C8CDA2B1D7A28F600E207CA /* Test_Enum.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Enum.swift /* Test_Enum.swift */; }; - 9C8CDA2C1D7A28F600E207CA /* Test_Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Extensions.swift /* Test_Extensions.swift */; }; - 9C8CDA2D1D7A28F600E207CA /* Test_ExtremeDefaultValues.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_ExtremeDefaultValues.swift /* Test_ExtremeDefaultValues.swift */; }; - 9C8CDA2E1D7A28F600E207CA /* Test_FieldMask.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_FieldMask.swift /* Test_FieldMask.swift */; }; - 9C8CDA2F1D7A28F600E207CA /* Test_FieldOrdering.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_FieldOrdering.swift /* Test_FieldOrdering.swift */; }; - 9C8CDA301D7A28F600E207CA /* Test_JSON.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_JSON.swift /* Test_JSON.swift */; }; - 9C8CDA311D7A28F600E207CA /* Test_JSON_Conformance.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_JSON_Conformance.swift /* Test_JSON_Conformance.swift */; }; - 9C8CDA321D7A28F600E207CA /* Test_JSON_Group.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_JSON_Group.swift /* Test_JSON_Group.swift */; }; - 9C8CDA341D7A28F600E207CA /* Test_Map.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Map.swift /* Test_Map.swift */; }; - 9C8CDA351D7A28F600E207CA /* Test_Map_JSON.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Map_JSON.swift /* Test_Map_JSON.swift */; }; - 9C8CDA361D7A28F600E207CA /* Test_Packed.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Packed.swift /* Test_Packed.swift */; }; - 9C8CDA371D7A28F600E207CA /* Test_ParsingMerge.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_ParsingMerge.swift /* Test_ParsingMerge.swift */; }; - 9C8CDA391D7A28F600E207CA /* Test_ReallyLargeTagNumber.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_ReallyLargeTagNumber.swift /* Test_ReallyLargeTagNumber.swift */; }; - 9C8CDA3A1D7A28F600E207CA /* Test_RecursiveMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_RecursiveMap.swift /* Test_RecursiveMap.swift */; }; - 9C8CDA3B1D7A28F600E207CA /* Test_Required.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Required.swift /* Test_Required.swift */; }; - 9C8CDA3C1D7A28F600E207CA /* Test_Reserved.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Reserved.swift /* Test_Reserved.swift */; }; - 9C8CDA3D1D7A28F600E207CA /* Test_Struct.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Struct.swift /* Test_Struct.swift */; }; - 9C8CDA3E1D7A28F600E207CA /* Test_Timestamp.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Timestamp.swift /* Test_Timestamp.swift */; }; - 9C8CDA3F1D7A28F600E207CA /* Test_Type.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Type.swift /* Test_Type.swift */; }; - 9C8CDA401D7A28F600E207CA /* Test_Unknown_proto2.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Unknown_proto2.swift /* Test_Unknown_proto2.swift */; }; - 9C8CDA411D7A28F600E207CA /* Test_Unknown_proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Unknown_proto3.swift /* Test_Unknown_proto3.swift */; }; - 9C8CDA421D7A28F600E207CA /* Test_Wrappers.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Wrappers.swift /* Test_Wrappers.swift */; }; - 9C8CDA431D7A28F600E207CA /* unittest.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest.pb.swift /* unittest.pb.swift */; }; - 9C8CDA441D7A28F600E207CA /* unittest_arena.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_arena.pb.swift /* unittest_arena.pb.swift */; }; - 9C8CDA451D7A28F600E207CA /* unittest_custom_options.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_custom_options.pb.swift /* unittest_custom_options.pb.swift */; }; - 9C8CDA461D7A28F600E207CA /* unittest_drop_unknown_fields.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_drop_unknown_fields.pb.swift /* unittest_drop_unknown_fields.pb.swift */; }; - 9C8CDA471D7A28F600E207CA /* unittest_embed_optimize_for.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_embed_optimize_for.pb.swift /* unittest_embed_optimize_for.pb.swift */; }; - 9C8CDA481D7A28F600E207CA /* unittest_empty.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_empty.pb.swift /* unittest_empty.pb.swift */; }; - 9C8CDA491D7A28F600E207CA /* unittest_import.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_import.pb.swift /* unittest_import.pb.swift */; }; - 9C8CDA4A1D7A28F600E207CA /* unittest_import_lite.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_import_lite.pb.swift /* unittest_import_lite.pb.swift */; }; - 9C8CDA4C1D7A28F600E207CA /* unittest_import_public.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_import_public.pb.swift /* unittest_import_public.pb.swift */; }; - 9C8CDA4D1D7A28F600E207CA /* unittest_import_public_lite.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_import_public_lite.pb.swift /* unittest_import_public_lite.pb.swift */; }; - 9C8CDA4F1D7A28F600E207CA /* unittest_lite.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_lite.pb.swift /* unittest_lite.pb.swift */; }; - 9C8CDA501D7A28F600E207CA /* unittest_lite_imports_nonlite.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_lite_imports_nonlite.pb.swift /* unittest_lite_imports_nonlite.pb.swift */; }; - 9C8CDA511D7A28F600E207CA /* unittest_mset.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_mset.pb.swift /* unittest_mset.pb.swift */; }; - 9C8CDA521D7A28F600E207CA /* unittest_mset_wire_format.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_mset_wire_format.pb.swift /* unittest_mset_wire_format.pb.swift */; }; - 9C8CDA561D7A28F600E207CA /* unittest_no_field_presence.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_no_field_presence.pb.swift /* unittest_no_field_presence.pb.swift */; }; - 9C8CDA571D7A28F600E207CA /* unittest_no_generic_services.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_no_generic_services.pb.swift /* unittest_no_generic_services.pb.swift */; }; - 9C8CDA581D7A28F600E207CA /* unittest_optimize_for.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_optimize_for.pb.swift /* unittest_optimize_for.pb.swift */; }; - 9C8CDA591D7A28F600E207CA /* unittest_preserve_unknown_enum.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_preserve_unknown_enum.pb.swift /* unittest_preserve_unknown_enum.pb.swift */; }; - 9C8CDA5A1D7A28F600E207CA /* unittest_preserve_unknown_enum2.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_preserve_unknown_enum2.pb.swift /* unittest_preserve_unknown_enum2.pb.swift */; }; - 9C8CDA5B1D7A28F600E207CA /* unittest_proto3.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_proto3.pb.swift /* unittest_proto3.pb.swift */; }; - 9C8CDA5C1D7A28F600E207CA /* unittest_proto3_arena.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_proto3_arena.pb.swift /* unittest_proto3_arena.pb.swift */; }; - 9C8CDA5D1D7A28F600E207CA /* unittest_swift_all_required_types.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_all_required_types.pb.swift /* unittest_swift_all_required_types.pb.swift */; }; - 9C8CDA5E1D7A28F600E207CA /* unittest_swift_cycle.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_cycle.pb.swift /* unittest_swift_cycle.pb.swift */; }; - 9C8CDA5F1D7A28F600E207CA /* unittest_swift_enum.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_enum.pb.swift /* unittest_swift_enum.pb.swift */; }; - 9C8CDA601D7A28F600E207CA /* unittest_swift_enum_optional_default.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_enum_optional_default.pb.swift /* unittest_swift_enum_optional_default.pb.swift */; }; - 9C8CDA611D7A28F600E207CA /* unittest_swift_extension.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_extension.pb.swift /* unittest_swift_extension.pb.swift */; }; - 9C8CDA621D7A28F600E207CA /* unittest_swift_fieldorder.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_fieldorder.pb.swift /* unittest_swift_fieldorder.pb.swift */; }; - 9C8CDA631D7A28F600E207CA /* unittest_swift_groups.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_groups.pb.swift /* unittest_swift_groups.pb.swift */; }; - 9C8CDA641D7A28F600E207CA /* unittest_swift_naming.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_naming.pb.swift /* unittest_swift_naming.pb.swift */; }; - 9C8CDA651D7A28F600E207CA /* unittest_swift_performance.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_performance.pb.swift /* unittest_swift_performance.pb.swift */; }; - 9C8CDA661D7A28F600E207CA /* unittest_swift_reserved.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_reserved.pb.swift /* unittest_swift_reserved.pb.swift */; }; - 9C8CDA671D7A28F600E207CA /* unittest_swift_runtime_proto2.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_runtime_proto2.pb.swift /* unittest_swift_runtime_proto2.pb.swift */; }; - 9C8CDA681D7A28F600E207CA /* unittest_swift_runtime_proto3.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_runtime_proto3.pb.swift /* unittest_swift_runtime_proto3.pb.swift */; }; - 9C8CDA691D7A28F600E207CA /* unittest_swift_startup.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_startup.pb.swift /* unittest_swift_startup.pb.swift */; }; - 9C8CDA6A1D7A28F600E207CA /* unittest_well_known_types.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_well_known_types.pb.swift /* unittest_well_known_types.pb.swift */; }; - 9CA424421E286D4E00C0E5B4 /* StringUtils.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CA424411E286D4E00C0E5B4 /* StringUtils.swift */; }; - 9CA424431E286D4E00C0E5B4 /* StringUtils.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CA424411E286D4E00C0E5B4 /* StringUtils.swift */; }; - 9CA424441E286D4E00C0E5B4 /* StringUtils.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CA424411E286D4E00C0E5B4 /* StringUtils.swift */; }; - 9CA424451E286D4E00C0E5B4 /* StringUtils.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CA424411E286D4E00C0E5B4 /* StringUtils.swift */; }; - 9CC8CAAC1EC512A0008EF45F /* generated_swift_names_enum_cases.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CC8CAA81EC512A0008EF45F /* generated_swift_names_enum_cases.pb.swift */; }; - 9CC8CAAD1EC512A0008EF45F /* generated_swift_names_enum_cases.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CC8CAA81EC512A0008EF45F /* generated_swift_names_enum_cases.pb.swift */; }; - 9CC8CAAE1EC512A0008EF45F /* generated_swift_names_enum_cases.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CC8CAA81EC512A0008EF45F /* generated_swift_names_enum_cases.pb.swift */; }; - 9CC8CAAF1EC512A0008EF45F /* generated_swift_names_enums.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CC8CAA91EC512A0008EF45F /* generated_swift_names_enums.pb.swift */; }; - 9CC8CAB01EC512A0008EF45F /* generated_swift_names_enums.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CC8CAA91EC512A0008EF45F /* generated_swift_names_enums.pb.swift */; }; - 9CC8CAB11EC512A0008EF45F /* generated_swift_names_enums.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CC8CAA91EC512A0008EF45F /* generated_swift_names_enums.pb.swift */; }; - 9CC8CAB21EC512A0008EF45F /* generated_swift_names_fields.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CC8CAAA1EC512A0008EF45F /* generated_swift_names_fields.pb.swift */; }; - 9CC8CAB31EC512A0008EF45F /* generated_swift_names_fields.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CC8CAAA1EC512A0008EF45F /* generated_swift_names_fields.pb.swift */; }; - 9CC8CAB41EC512A0008EF45F /* generated_swift_names_fields.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CC8CAAA1EC512A0008EF45F /* generated_swift_names_fields.pb.swift */; }; - 9CC8CAB51EC512A0008EF45F /* generated_swift_names_messages.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CC8CAAB1EC512A0008EF45F /* generated_swift_names_messages.pb.swift */; }; - 9CC8CAB61EC512A0008EF45F /* generated_swift_names_messages.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CC8CAAB1EC512A0008EF45F /* generated_swift_names_messages.pb.swift */; }; - 9CC8CAB71EC512A0008EF45F /* generated_swift_names_messages.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CC8CAAB1EC512A0008EF45F /* generated_swift_names_messages.pb.swift */; }; - 9CCD5F931E008203002D1940 /* Test_TextFormat_WKT_proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CCD5F921E008203002D1940 /* Test_TextFormat_WKT_proto3.swift */; }; - 9CCD5F941E008203002D1940 /* Test_TextFormat_WKT_proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CCD5F921E008203002D1940 /* Test_TextFormat_WKT_proto3.swift */; }; - 9CCD5F951E008203002D1940 /* Test_TextFormat_WKT_proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CCD5F921E008203002D1940 /* Test_TextFormat_WKT_proto3.swift */; }; - 9CE4C56824EF34F200471257 /* Google_Protobuf_NullValue+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CE4C56724EF34F200471257 /* Google_Protobuf_NullValue+Extensions.swift */; }; - 9CE4C56924EF34F200471257 /* Google_Protobuf_NullValue+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CE4C56724EF34F200471257 /* Google_Protobuf_NullValue+Extensions.swift */; }; - 9CE4C56A24EF34F200471257 /* Google_Protobuf_NullValue+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CE4C56724EF34F200471257 /* Google_Protobuf_NullValue+Extensions.swift */; }; - 9CE4C56B24EF34F200471257 /* Google_Protobuf_NullValue+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CE4C56724EF34F200471257 /* Google_Protobuf_NullValue+Extensions.swift */; }; - 9CE9CF371E32C9F8004FBED6 /* JSONScanner.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CE9CF361E32C9F8004FBED6 /* JSONScanner.swift */; }; - 9CEB0D681DF5E934002D80F0 /* TextFormatEncodingVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CEB0D671DF5E934002D80F0 /* TextFormatEncodingVisitor.swift */; }; - 9CEB0D6C1DF5F921002D80F0 /* TextFormatScanner.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CEB0D6B1DF5F921002D80F0 /* TextFormatScanner.swift */; }; - AA05BF4A1DAEB7E400619042 /* WireFormat.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA05BF491DAEB7E400619042 /* WireFormat.swift */; }; - AA05BF4B1DAEB7E400619042 /* WireFormat.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA05BF491DAEB7E400619042 /* WireFormat.swift */; }; - AA05BF4C1DAEB7E400619042 /* WireFormat.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA05BF491DAEB7E400619042 /* WireFormat.swift */; }; - AA05BF4D1DAEB7E400619042 /* WireFormat.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA05BF491DAEB7E400619042 /* WireFormat.swift */; }; - AA05BF4F1DAEB7E800619042 /* FieldTag.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA05BF4E1DAEB7E800619042 /* FieldTag.swift */; }; - AA05BF501DAEB7E800619042 /* FieldTag.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA05BF4E1DAEB7E800619042 /* FieldTag.swift */; }; - AA05BF511DAEB7E800619042 /* FieldTag.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA05BF4E1DAEB7E800619042 /* FieldTag.swift */; }; - AA05BF521DAEB7E800619042 /* FieldTag.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA05BF4E1DAEB7E800619042 /* FieldTag.swift */; }; - AA28A4A61DA30E5900C866D9 /* ZigZag.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA28A4A51DA30E5900C866D9 /* ZigZag.swift */; }; - AA28A4A71DA30E5900C866D9 /* ZigZag.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA28A4A51DA30E5900C866D9 /* ZigZag.swift */; }; - AA28A4A91DA40B0900C866D9 /* Varint.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA28A4A81DA40B0900C866D9 /* Varint.swift */; }; - AA28A4AA1DA40B0900C866D9 /* Varint.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA28A4A81DA40B0900C866D9 /* Varint.swift */; }; - AA28A4AC1DA454DA00C866D9 /* BinaryEncodingSizeVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA28A4AB1DA454DA00C866D9 /* BinaryEncodingSizeVisitor.swift */; }; - AA28A4AD1DA454DA00C866D9 /* BinaryEncodingSizeVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA28A4AB1DA454DA00C866D9 /* BinaryEncodingSizeVisitor.swift */; }; - AA3640911E60D043000C3CF4 /* struct.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA3640901E60D043000C3CF4 /* struct.pb.swift */; }; - AA3640921E60D592000C3CF4 /* struct.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA3640901E60D043000C3CF4 /* struct.pb.swift */; }; - AA3640931E60D593000C3CF4 /* struct.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA3640901E60D043000C3CF4 /* struct.pb.swift */; }; - AA3640941E60D593000C3CF4 /* struct.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA3640901E60D043000C3CF4 /* struct.pb.swift */; }; - AA3640961E60EBB0000C3CF4 /* Test_Merge.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA3640951E60EBB0000C3CF4 /* Test_Merge.swift */; }; - AA3640971E60EBB0000C3CF4 /* Test_Merge.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA3640951E60EBB0000C3CF4 /* Test_Merge.swift */; }; - AA3640981E60EBB0000C3CF4 /* Test_Merge.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA3640951E60EBB0000C3CF4 /* Test_Merge.swift */; }; - AA6CF6F51DB6D227007DF26B /* Test_Enum_Proto2.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA6CF6F01DB6D1F8007DF26B /* Test_Enum_Proto2.swift */; }; - AA6CF6F61DB6D228007DF26B /* Test_Enum_Proto2.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA6CF6F01DB6D1F8007DF26B /* Test_Enum_Proto2.swift */; }; - AA6CF6F71DB6D229007DF26B /* Test_Enum_Proto2.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA6CF6F01DB6D1F8007DF26B /* Test_Enum_Proto2.swift */; }; - AA78AD361E84C5B4001C43F9 /* Message+AnyAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA78AD351E84C5B4001C43F9 /* Message+AnyAdditions.swift */; }; - AA78AD371E84C5B4001C43F9 /* Message+AnyAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA78AD351E84C5B4001C43F9 /* Message+AnyAdditions.swift */; }; - AA78AD381E84C5B4001C43F9 /* Message+AnyAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA78AD351E84C5B4001C43F9 /* Message+AnyAdditions.swift */; }; - AA78AD391E84C5B4001C43F9 /* Message+AnyAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA78AD351E84C5B4001C43F9 /* Message+AnyAdditions.swift */; }; - AA86F6FA1E0A0F0B006CC38A /* JSONEncodingVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA86F6F91E0A0F0B006CC38A /* JSONEncodingVisitor.swift */; }; - AA86F6FB1E0A0F0B006CC38A /* JSONEncodingVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA86F6F91E0A0F0B006CC38A /* JSONEncodingVisitor.swift */; }; - AA86F6FC1E0A0F0B006CC38A /* JSONEncodingVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA86F6F91E0A0F0B006CC38A /* JSONEncodingVisitor.swift */; }; - AA86F6FD1E0A0F0B006CC38A /* JSONEncodingVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA86F6F91E0A0F0B006CC38A /* JSONEncodingVisitor.swift */; }; - AAABA40B1E4A42CD00365CDF /* ProtobufAPIVersionCheck.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAABA40A1E4A42CD00365CDF /* ProtobufAPIVersionCheck.swift */; }; - AAABA40C1E4A42CD00365CDF /* ProtobufAPIVersionCheck.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAABA40A1E4A42CD00365CDF /* ProtobufAPIVersionCheck.swift */; }; - AAABA40D1E4A42CD00365CDF /* ProtobufAPIVersionCheck.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAABA40A1E4A42CD00365CDF /* ProtobufAPIVersionCheck.swift */; }; - AAABA40E1E4A42CD00365CDF /* ProtobufAPIVersionCheck.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAABA40A1E4A42CD00365CDF /* ProtobufAPIVersionCheck.swift */; }; - AAB979F51E7066D8003DC2F4 /* Google_Protobuf_ListValue+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAB979F41E7066D8003DC2F4 /* Google_Protobuf_ListValue+Extensions.swift */; }; - AAB979F61E7066D8003DC2F4 /* Google_Protobuf_ListValue+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAB979F41E7066D8003DC2F4 /* Google_Protobuf_ListValue+Extensions.swift */; }; - AAB979F71E7066D8003DC2F4 /* Google_Protobuf_ListValue+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAB979F41E7066D8003DC2F4 /* Google_Protobuf_ListValue+Extensions.swift */; }; - AAB979F81E7066D8003DC2F4 /* Google_Protobuf_ListValue+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAB979F41E7066D8003DC2F4 /* Google_Protobuf_ListValue+Extensions.swift */; }; - AAE0F4DF1E6A3886005240E0 /* Test_EnumWithAliases.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAE0F4DE1E6A3886005240E0 /* Test_EnumWithAliases.swift */; }; - AAE0F4E01E6A3886005240E0 /* Test_EnumWithAliases.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAE0F4DE1E6A3886005240E0 /* Test_EnumWithAliases.swift */; }; - AAE0F4E11E6A3886005240E0 /* Test_EnumWithAliases.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAE0F4DE1E6A3886005240E0 /* Test_EnumWithAliases.swift */; }; - AAE0F4E31E6F5CB9005240E0 /* Google_Protobuf_Value+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAE0F4E21E6F5CB9005240E0 /* Google_Protobuf_Value+Extensions.swift */; }; - AAE0F4E41E6F5CB9005240E0 /* Google_Protobuf_Value+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAE0F4E21E6F5CB9005240E0 /* Google_Protobuf_Value+Extensions.swift */; }; - AAE0F4E51E6F5CB9005240E0 /* Google_Protobuf_Value+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAE0F4E21E6F5CB9005240E0 /* Google_Protobuf_Value+Extensions.swift */; }; - AAE0F4E61E6F5CB9005240E0 /* Google_Protobuf_Value+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAE0F4E21E6F5CB9005240E0 /* Google_Protobuf_Value+Extensions.swift */; }; - AAEA52201DA5BB81003F318F /* Message+UInt8ArrayHelpers.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAEA521F1DA5BB81003F318F /* Message+UInt8ArrayHelpers.swift */; }; - AAEA52211DA5BB81003F318F /* Message+UInt8ArrayHelpers.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAEA521F1DA5BB81003F318F /* Message+UInt8ArrayHelpers.swift */; }; - AAEA52721DA80DD4003F318F /* Google_Protobuf_Wrappers+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAEA52711DA80DD4003F318F /* Google_Protobuf_Wrappers+Extensions.swift */; }; - AAEA52741DA80DEA003F318F /* wrappers.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAEA52731DA80DEA003F318F /* wrappers.pb.swift */; }; - AAEA52771DA832A8003F318F /* wrappers.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAEA52731DA80DEA003F318F /* wrappers.pb.swift */; }; - AAF2ED3A1DEF3FBC007B510F /* NameMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAF2ED391DEF3FBC007B510F /* NameMap.swift */; }; - AAF2ED3B1DEF3FBC007B510F /* NameMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAF2ED391DEF3FBC007B510F /* NameMap.swift */; }; - AAF2ED3C1DEF3FBC007B510F /* NameMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAF2ED391DEF3FBC007B510F /* NameMap.swift */; }; - AAF2ED3D1DEF3FBC007B510F /* NameMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAF2ED391DEF3FBC007B510F /* NameMap.swift */; }; - AAF2ED3F1DEF4D94007B510F /* ProtoNameProviding.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAF2ED3E1DEF4D94007B510F /* ProtoNameProviding.swift */; }; - AAF2ED401DEF4D94007B510F /* ProtoNameProviding.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAF2ED3E1DEF4D94007B510F /* ProtoNameProviding.swift */; }; - AAF2ED411DEF4D94007B510F /* ProtoNameProviding.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAF2ED3E1DEF4D94007B510F /* ProtoNameProviding.swift */; }; - AAF2ED421DEF4D94007B510F /* ProtoNameProviding.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAF2ED3E1DEF4D94007B510F /* ProtoNameProviding.swift */; }; - BCCA0E691DB1210E00957D74 /* TextFormatDecoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = BCCA0E661DB1210E00957D74 /* TextFormatDecoder.swift */; }; - BCCA0E6A1DB1210E00957D74 /* TextFormatEncoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = BCCA0E671DB1210E00957D74 /* TextFormatEncoder.swift */; }; - BCCA0E6B1DB1210E00957D74 /* Message+TextFormatAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = BCCA0E681DB1210E00957D74 /* Message+TextFormatAdditions.swift */; }; - BCCA0E7A1DB124B800957D74 /* Test_TextFormat_proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = BCCA0E751DB123F800957D74 /* Test_TextFormat_proto3.swift */; }; - DB2E0AFA1EB24C7600F59319 /* Test_JSON_Array.swift in Sources */ = {isa = PBXBuildFile; fileRef = DB2E0AF91EB24C7600F59319 /* Test_JSON_Array.swift */; }; - DB2E0AFB1EB24C7600F59319 /* Test_JSON_Array.swift in Sources */ = {isa = PBXBuildFile; fileRef = DB2E0AF91EB24C7600F59319 /* Test_JSON_Array.swift */; }; - DB2E0AFC1EB24C7600F59319 /* Test_JSON_Array.swift in Sources */ = {isa = PBXBuildFile; fileRef = DB2E0AF91EB24C7600F59319 /* Test_JSON_Array.swift */; }; - DB2E0AFE1EB25D1D00F59319 /* Message+JSONArrayAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = DB2E0AFD1EB25D1D00F59319 /* Message+JSONArrayAdditions.swift */; }; - DB2E0AFF1EB25D1D00F59319 /* Message+JSONArrayAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = DB2E0AFD1EB25D1D00F59319 /* Message+JSONArrayAdditions.swift */; }; - DB2E0B001EB25D1D00F59319 /* Message+JSONArrayAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = DB2E0AFD1EB25D1D00F59319 /* Message+JSONArrayAdditions.swift */; }; - DB2E0B011EB25D1D00F59319 /* Message+JSONArrayAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = DB2E0AFD1EB25D1D00F59319 /* Message+JSONArrayAdditions.swift */; }; - E7038A24224D7F1000B68775 /* Data+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = E7038A23224D7F1000B68775 /* Data+Extensions.swift */; }; - E7038A25224D7F1000B68775 /* Data+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = E7038A23224D7F1000B68775 /* Data+Extensions.swift */; }; - E7038A26224D7F1000B68775 /* Data+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = E7038A23224D7F1000B68775 /* Data+Extensions.swift */; }; - E7038A27224D7F1000B68775 /* Data+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = E7038A23224D7F1000B68775 /* Data+Extensions.swift */; }; - ECBC5C491DF6ABC500F658E8 /* Google_Protobuf_Wrappers+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAEA52711DA80DD4003F318F /* Google_Protobuf_Wrappers+Extensions.swift */; }; - ECBC5C4A1DF6ABC500F658E8 /* Google_Protobuf_Struct+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/Google_Protobuf_Struct.swift /* Google_Protobuf_Struct+Extensions.swift */; }; - ECBC5C4B1DF6ABC500F658E8 /* timestamp.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/timestamp.pb.swift /* timestamp.pb.swift */; }; - ECBC5C4C1DF6ABC500F658E8 /* Varint.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA28A4A81DA40B0900C866D9 /* Varint.swift */; }; - ECBC5C4D1DF6ABC500F658E8 /* Google_Protobuf_Timestamp+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/Google_Protobuf_Timestamp_Extensions.swift /* Google_Protobuf_Timestamp+Extensions.swift */; }; - ECBC5C4E1DF6ABC500F658E8 /* type.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/type.pb.swift /* type.pb.swift */; }; - ECBC5C4F1DF6ABC500F658E8 /* ZigZag.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA28A4A51DA30E5900C866D9 /* ZigZag.swift */; }; - ECBC5C501DF6ABC500F658E8 /* source_context.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/source_context.pb.swift /* source_context.pb.swift */; }; - ECBC5C511DF6ABC500F658E8 /* wrappers.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAEA52731DA80DEA003F318F /* wrappers.pb.swift */; }; - F40D33EA2017ED2100ABAF0F /* unittest_swift_enum_proto3.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F40D33E82017ECD300ABAF0F /* unittest_swift_enum_proto3.pb.swift */; }; - F40D33EB2017ED2200ABAF0F /* unittest_swift_enum_proto3.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F40D33E82017ECD300ABAF0F /* unittest_swift_enum_proto3.pb.swift */; }; - F40D33EC2017ED2300ABAF0F /* unittest_swift_enum_proto3.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F40D33E82017ECD300ABAF0F /* unittest_swift_enum_proto3.pb.swift */; }; - F411FE9C1EDDD706001AE6B2 /* JSONDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4584DB71EDDCAD600803AB6 /* JSONDecodingOptions.swift */; }; - F411FE9D1EDDD706001AE6B2 /* JSONDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4584DB71EDDCAD600803AB6 /* JSONDecodingOptions.swift */; }; - F411FE9E1EDDD707001AE6B2 /* JSONDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4584DB71EDDCAD600803AB6 /* JSONDecodingOptions.swift */; }; - F411FE9F1EDDD83B001AE6B2 /* BinaryDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F411FE941EDDD6AA001AE6B2 /* BinaryDecodingOptions.swift */; }; - F411FEA01EDDD83C001AE6B2 /* BinaryDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F411FE941EDDD6AA001AE6B2 /* BinaryDecodingOptions.swift */; }; - F411FEA11EDDD83D001AE6B2 /* BinaryDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F411FE941EDDD6AA001AE6B2 /* BinaryDecodingOptions.swift */; }; - F411FEA21EDDD83E001AE6B2 /* BinaryDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F411FE941EDDD6AA001AE6B2 /* BinaryDecodingOptions.swift */; }; - F411FEAC1EDDDC61001AE6B2 /* Test_BinaryDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F411FEAA1EDDDC5D001AE6B2 /* Test_BinaryDecodingOptions.swift */; }; - F411FEAD1EDDDC61001AE6B2 /* Test_BinaryDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F411FEAA1EDDDC5D001AE6B2 /* Test_BinaryDecodingOptions.swift */; }; - F411FEAE1EDDDC62001AE6B2 /* Test_BinaryDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F411FEAA1EDDDC5D001AE6B2 /* Test_BinaryDecodingOptions.swift */; }; - F4151F661EF3197100EEA00B /* Test_SimpleExtensionMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4151F641EF3193F00EEA00B /* Test_SimpleExtensionMap.swift */; }; - F4151F671EF3197200EEA00B /* Test_SimpleExtensionMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4151F641EF3193F00EEA00B /* Test_SimpleExtensionMap.swift */; }; - F4151F681EF3197300EEA00B /* Test_SimpleExtensionMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4151F641EF3193F00EEA00B /* Test_SimpleExtensionMap.swift */; }; - F4151F711EFAB83400EEA00B /* BinaryDelimited.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4151F701EFAB83400EEA00B /* BinaryDelimited.swift */; }; - F4151F721EFAB83900EEA00B /* BinaryDelimited.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4151F701EFAB83400EEA00B /* BinaryDelimited.swift */; }; - F4151F731EFAB83A00EEA00B /* BinaryDelimited.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4151F701EFAB83400EEA00B /* BinaryDelimited.swift */; }; - F4151F741EFAB83A00EEA00B /* BinaryDelimited.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4151F701EFAB83400EEA00B /* BinaryDelimited.swift */; }; - F4151F771EFAD85A00EEA00B /* Test_BinaryDelimited.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4151F751EFAD85600EEA00B /* Test_BinaryDelimited.swift */; }; - F4151F781EFAD85B00EEA00B /* Test_BinaryDelimited.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4151F751EFAD85600EEA00B /* Test_BinaryDelimited.swift */; }; - F4151F791EFAD85C00EEA00B /* Test_BinaryDelimited.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4151F751EFAD85600EEA00B /* Test_BinaryDelimited.swift */; }; - F41BA3FC1E76F635004F6E95 /* Google_Protobuf_Any+Registry.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA3FB1E76F635004F6E95 /* Google_Protobuf_Any+Registry.swift */; }; - F41BA3FD1E76F639004F6E95 /* Google_Protobuf_Any+Registry.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA3FB1E76F635004F6E95 /* Google_Protobuf_Any+Registry.swift */; }; - F41BA3FE1E76F639004F6E95 /* Google_Protobuf_Any+Registry.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA3FB1E76F635004F6E95 /* Google_Protobuf_Any+Registry.swift */; }; - F41BA3FF1E76F63A004F6E95 /* Google_Protobuf_Any+Registry.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA3FB1E76F635004F6E95 /* Google_Protobuf_Any+Registry.swift */; }; - F41BA4131E79BDCA004F6E95 /* Google_Protobuf_Any+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA4121E79BDCA004F6E95 /* Google_Protobuf_Any+Extensions.swift */; }; - F41BA4141E79BE54004F6E95 /* Google_Protobuf_Any+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA4121E79BDCA004F6E95 /* Google_Protobuf_Any+Extensions.swift */; }; - F41BA4151E79BE55004F6E95 /* Google_Protobuf_Any+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA4121E79BDCA004F6E95 /* Google_Protobuf_Any+Extensions.swift */; }; - F41BA4161E79BE56004F6E95 /* Google_Protobuf_Any+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA4121E79BDCA004F6E95 /* Google_Protobuf_Any+Extensions.swift */; }; - F41BA4181E79C568004F6E95 /* AnyUnpackError.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA4171E79C568004F6E95 /* AnyUnpackError.swift */; }; - F41BA4191E79C59A004F6E95 /* AnyUnpackError.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA4171E79C568004F6E95 /* AnyUnpackError.swift */; }; - F41BA41A1E79C59B004F6E95 /* AnyUnpackError.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA4171E79C568004F6E95 /* AnyUnpackError.swift */; }; - F41BA41B1E79C59B004F6E95 /* AnyUnpackError.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA4171E79C568004F6E95 /* AnyUnpackError.swift */; }; - F41BA4401E7AE4AC004F6E95 /* any.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA43F1E7AE4AC004F6E95 /* any.pb.swift */; }; - F41BA4421E7AE53C004F6E95 /* AnyMessageStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA4411E7AE53C004F6E95 /* AnyMessageStorage.swift */; }; - F41BA4431E7B35C6004F6E95 /* AnyMessageStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA4411E7AE53C004F6E95 /* AnyMessageStorage.swift */; }; - F41BA4441E7B35C7004F6E95 /* AnyMessageStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA4411E7AE53C004F6E95 /* AnyMessageStorage.swift */; }; - F41BA4451E7B35C8004F6E95 /* AnyMessageStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = F41BA4411E7AE53C004F6E95 /* AnyMessageStorage.swift */; }; - F430B11C262764D400C9EE2A /* fuzz_testing.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F430B11A262764D300C9EE2A /* fuzz_testing.pb.swift */; }; - F430B11D262764D400C9EE2A /* fuzz_testing.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F430B11A262764D300C9EE2A /* fuzz_testing.pb.swift */; }; - F430B11E262764D400C9EE2A /* fuzz_testing.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F430B11A262764D300C9EE2A /* fuzz_testing.pb.swift */; }; - F430B11F262764D400C9EE2A /* Test_FuzzTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = F430B11B262764D300C9EE2A /* Test_FuzzTests.swift */; }; - F430B120262764D400C9EE2A /* Test_FuzzTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = F430B11B262764D300C9EE2A /* Test_FuzzTests.swift */; }; - F430B121262764D400C9EE2A /* Test_FuzzTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = F430B11B262764D300C9EE2A /* Test_FuzzTests.swift */; }; - F44F93691DAD7FA500BC5B85 /* Google_Protobuf_Wrappers+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAEA52711DA80DD4003F318F /* Google_Protobuf_Wrappers+Extensions.swift */; }; - F44F93771DAEA76700BC5B85 /* api.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/api.pb.swift /* api.pb.swift */; }; - F44F93781DAEA76700BC5B85 /* duration.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/duration.pb.swift /* duration.pb.swift */; }; - F44F93791DAEA76700BC5B85 /* empty.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/empty.pb.swift /* empty.pb.swift */; }; - F44F937A1DAEA76700BC5B85 /* field_mask.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/field_mask.pb.swift /* field_mask.pb.swift */; }; - F44F937C1DAEA76700BC5B85 /* Google_Protobuf_Duration+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/Google_Protobuf_Duration_Extensions.swift /* Google_Protobuf_Duration+Extensions.swift */; }; - F44F937D1DAEA76700BC5B85 /* Google_Protobuf_FieldMask+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/Google_Protobuf_FieldMask_Extensions.swift /* Google_Protobuf_FieldMask+Extensions.swift */; }; - F44F937E1DAEA76700BC5B85 /* Google_Protobuf_Struct+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/Google_Protobuf_Struct.swift /* Google_Protobuf_Struct+Extensions.swift */; }; - F44F937F1DAEA76700BC5B85 /* Google_Protobuf_Timestamp+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/Google_Protobuf_Timestamp_Extensions.swift /* Google_Protobuf_Timestamp+Extensions.swift */; }; - F44F93801DAEA76700BC5B85 /* Google_Protobuf_Wrappers+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAEA52711DA80DD4003F318F /* Google_Protobuf_Wrappers+Extensions.swift */; }; - F44F93811DAEA76700BC5B85 /* BinaryDecoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufBinaryDecoding.swift /* BinaryDecoder.swift */; }; - F44F93821DAEA76700BC5B85 /* BinaryEncoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufBinaryEncoding.swift /* BinaryEncoder.swift */; }; - F44F93831DAEA76700BC5B85 /* BinaryEncodingSizeVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA28A4AB1DA454DA00C866D9 /* BinaryEncodingSizeVisitor.swift */; }; - F44F93841DAEA76700BC5B85 /* Message+BinaryAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufBinaryTypes.swift /* Message+BinaryAdditions.swift */; }; - F44F93861DAEA76700BC5B85 /* Enum.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufEnum.swift /* Enum.swift */; }; - F44F93881DAEA76700BC5B85 /* ExtensionFields.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufExtensionFields.swift /* ExtensionFields.swift */; }; - F44F93891DAEA76700BC5B85 /* MessageExtension.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufExtensions.swift /* MessageExtension.swift */; }; - F44F938A1DAEA76700BC5B85 /* Decoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufFieldDecoder.swift /* Decoder.swift */; }; - F44F938B1DAEA76700BC5B85 /* HashVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufHash.swift /* HashVisitor.swift */; }; - F44F938D1DAEA76700BC5B85 /* JSONEncoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufJSONEncoding.swift /* JSONEncoder.swift */; }; - F44F938E1DAEA76700BC5B85 /* Message+JSONAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufJSONTypes.swift /* Message+JSONAdditions.swift */; }; - F44F938F1DAEA76700BC5B85 /* Message.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufMessage.swift /* Message.swift */; }; - F44F93931DAEA76700BC5B85 /* FieldTypes.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufTypes.swift /* FieldTypes.swift */; }; - F44F93941DAEA76700BC5B85 /* UnknownStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufUnknown.swift /* UnknownStorage.swift */; }; - F44F93951DAEA76700BC5B85 /* source_context.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/source_context.pb.swift /* source_context.pb.swift */; }; - F44F93961DAEA76700BC5B85 /* timestamp.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/timestamp.pb.swift /* timestamp.pb.swift */; }; - F44F93971DAEA76700BC5B85 /* type.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/type.pb.swift /* type.pb.swift */; }; - F44F93981DAEA76700BC5B85 /* Varint.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA28A4A81DA40B0900C866D9 /* Varint.swift */; }; - F44F93991DAEA76700BC5B85 /* wrappers.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAEA52731DA80DEA003F318F /* wrappers.pb.swift */; }; - F44F939A1DAEA76700BC5B85 /* ZigZag.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA28A4A51DA30E5900C866D9 /* ZigZag.swift */; }; - F44F93A41DAEA7C500BC5B85 /* SwiftProtobuf.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F44F936F1DAEA53900BC5B85 /* SwiftProtobuf.framework */; }; - F44F93AA1DAEA8C900BC5B85 /* any_test.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/any_test.pb.swift /* any_test.pb.swift */; }; - F44F93AB1DAEA8C900BC5B85 /* conformance.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/conformance.pb.swift /* conformance.pb.swift */; }; - F44F93AD1DAEA8C900BC5B85 /* TestHelpers.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/TestHelpers.swift /* TestHelpers.swift */; }; - F44F93AF1DAEA8C900BC5B85 /* map_unittest.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/map_unittest.pb.swift /* map_unittest.pb.swift */; }; - F44F93B01DAEA8C900BC5B85 /* Message+UInt8ArrayHelpers.swift in Sources */ = {isa = PBXBuildFile; fileRef = AAEA521F1DA5BB81003F318F /* Message+UInt8ArrayHelpers.swift */; }; - F44F93B11DAEA8C900BC5B85 /* Test_AllTypes_Proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_AllTypes_Proto3.swift /* Test_AllTypes_Proto3.swift */; }; - F44F93B21DAEA8C900BC5B85 /* Test_AllTypes.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_AllTypes.swift /* Test_AllTypes.swift */; }; - F44F93B31DAEA8C900BC5B85 /* Test_Any.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Any.swift /* Test_Any.swift */; }; - F44F93B41DAEA8C900BC5B85 /* Test_Api.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Api.swift /* Test_Api.swift */; }; - F44F93B51DAEA8C900BC5B85 /* Test_Conformance.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Conformance.swift /* Test_Conformance.swift */; }; - F44F93B71DAEA8C900BC5B85 /* Test_Duration.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Duration.swift /* Test_Duration.swift */; }; - F44F93B81DAEA8C900BC5B85 /* Test_Empty.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Empty.swift /* Test_Empty.swift */; }; - F44F93B91DAEA8C900BC5B85 /* Test_Enum.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Enum.swift /* Test_Enum.swift */; }; - F44F93BA1DAEA8C900BC5B85 /* Test_Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Extensions.swift /* Test_Extensions.swift */; }; - F44F93BB1DAEA8C900BC5B85 /* Test_ExtremeDefaultValues.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_ExtremeDefaultValues.swift /* Test_ExtremeDefaultValues.swift */; }; - F44F93BC1DAEA8C900BC5B85 /* Test_FieldMask.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_FieldMask.swift /* Test_FieldMask.swift */; }; - F44F93BD1DAEA8C900BC5B85 /* Test_FieldOrdering.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_FieldOrdering.swift /* Test_FieldOrdering.swift */; }; - F44F93BE1DAEA8C900BC5B85 /* Test_JSON_Conformance.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_JSON_Conformance.swift /* Test_JSON_Conformance.swift */; }; - F44F93BF1DAEA8C900BC5B85 /* Test_JSON_Group.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_JSON_Group.swift /* Test_JSON_Group.swift */; }; - F44F93C11DAEA8C900BC5B85 /* Test_JSON.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_JSON.swift /* Test_JSON.swift */; }; - F44F93C21DAEA8C900BC5B85 /* Test_Map_JSON.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Map_JSON.swift /* Test_Map_JSON.swift */; }; - F44F93C31DAEA8C900BC5B85 /* Test_Map.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Map.swift /* Test_Map.swift */; }; - F44F93C41DAEA8C900BC5B85 /* Test_Packed.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Packed.swift /* Test_Packed.swift */; }; - F44F93C51DAEA8C900BC5B85 /* Test_ParsingMerge.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_ParsingMerge.swift /* Test_ParsingMerge.swift */; }; - F44F93C71DAEA8C900BC5B85 /* Test_ReallyLargeTagNumber.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_ReallyLargeTagNumber.swift /* Test_ReallyLargeTagNumber.swift */; }; - F44F93C81DAEA8C900BC5B85 /* Test_RecursiveMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_RecursiveMap.swift /* Test_RecursiveMap.swift */; }; - F44F93C91DAEA8C900BC5B85 /* Test_Required.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Required.swift /* Test_Required.swift */; }; - F44F93CA1DAEA8C900BC5B85 /* Test_Reserved.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Reserved.swift /* Test_Reserved.swift */; }; - F44F93CB1DAEA8C900BC5B85 /* Test_Struct.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Struct.swift /* Test_Struct.swift */; }; - F44F93CC1DAEA8C900BC5B85 /* Test_Timestamp.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Timestamp.swift /* Test_Timestamp.swift */; }; - F44F93CD1DAEA8C900BC5B85 /* Test_Type.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Type.swift /* Test_Type.swift */; }; - F44F93CE1DAEA8C900BC5B85 /* Test_Unknown_proto2.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Unknown_proto2.swift /* Test_Unknown_proto2.swift */; }; - F44F93CF1DAEA8C900BC5B85 /* Test_Unknown_proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Unknown_proto3.swift /* Test_Unknown_proto3.swift */; }; - F44F93D01DAEA8C900BC5B85 /* Test_Wrappers.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Wrappers.swift /* Test_Wrappers.swift */; }; - F44F93D11DAEA8C900BC5B85 /* unittest_arena.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_arena.pb.swift /* unittest_arena.pb.swift */; }; - F44F93D21DAEA8C900BC5B85 /* unittest_custom_options.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_custom_options.pb.swift /* unittest_custom_options.pb.swift */; }; - F44F93D31DAEA8C900BC5B85 /* unittest_drop_unknown_fields.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_drop_unknown_fields.pb.swift /* unittest_drop_unknown_fields.pb.swift */; }; - F44F93D41DAEA8C900BC5B85 /* unittest_embed_optimize_for.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_embed_optimize_for.pb.swift /* unittest_embed_optimize_for.pb.swift */; }; - F44F93D51DAEA8C900BC5B85 /* unittest_empty.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_empty.pb.swift /* unittest_empty.pb.swift */; }; - F44F93D61DAEA8C900BC5B85 /* unittest_import_lite.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_import_lite.pb.swift /* unittest_import_lite.pb.swift */; }; - F44F93D81DAEA8C900BC5B85 /* unittest_import_public_lite.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_import_public_lite.pb.swift /* unittest_import_public_lite.pb.swift */; }; - F44F93DA1DAEA8C900BC5B85 /* unittest_import_public.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_import_public.pb.swift /* unittest_import_public.pb.swift */; }; - F44F93DB1DAEA8C900BC5B85 /* unittest_import.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_import.pb.swift /* unittest_import.pb.swift */; }; - F44F93DC1DAEA8C900BC5B85 /* unittest_lite_imports_nonlite.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_lite_imports_nonlite.pb.swift /* unittest_lite_imports_nonlite.pb.swift */; }; - F44F93DD1DAEA8C900BC5B85 /* unittest_lite.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_lite.pb.swift /* unittest_lite.pb.swift */; }; - F44F93DE1DAEA8C900BC5B85 /* unittest_mset_wire_format.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_mset_wire_format.pb.swift /* unittest_mset_wire_format.pb.swift */; }; - F44F93DF1DAEA8C900BC5B85 /* unittest_mset.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_mset.pb.swift /* unittest_mset.pb.swift */; }; - F44F93E31DAEA8C900BC5B85 /* unittest_no_field_presence.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_no_field_presence.pb.swift /* unittest_no_field_presence.pb.swift */; }; - F44F93E41DAEA8C900BC5B85 /* unittest_no_generic_services.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_no_generic_services.pb.swift /* unittest_no_generic_services.pb.swift */; }; - F44F93E51DAEA8C900BC5B85 /* unittest_optimize_for.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_optimize_for.pb.swift /* unittest_optimize_for.pb.swift */; }; - F44F93E61DAEA8C900BC5B85 /* unittest_preserve_unknown_enum.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_preserve_unknown_enum.pb.swift /* unittest_preserve_unknown_enum.pb.swift */; }; - F44F93E71DAEA8C900BC5B85 /* unittest_preserve_unknown_enum2.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_preserve_unknown_enum2.pb.swift /* unittest_preserve_unknown_enum2.pb.swift */; }; - F44F93E81DAEA8C900BC5B85 /* unittest_proto3_arena.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_proto3_arena.pb.swift /* unittest_proto3_arena.pb.swift */; }; - F44F93E91DAEA8C900BC5B85 /* unittest_proto3.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_proto3.pb.swift /* unittest_proto3.pb.swift */; }; - F44F93EA1DAEA8C900BC5B85 /* unittest_swift_all_required_types.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_all_required_types.pb.swift /* unittest_swift_all_required_types.pb.swift */; }; - F44F93EB1DAEA8C900BC5B85 /* unittest_swift_cycle.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_cycle.pb.swift /* unittest_swift_cycle.pb.swift */; }; - F44F93EC1DAEA8C900BC5B85 /* unittest_swift_enum_optional_default.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_enum_optional_default.pb.swift /* unittest_swift_enum_optional_default.pb.swift */; }; - F44F93ED1DAEA8C900BC5B85 /* unittest_swift_enum.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_enum.pb.swift /* unittest_swift_enum.pb.swift */; }; - F44F93EE1DAEA8C900BC5B85 /* unittest_swift_extension.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_extension.pb.swift /* unittest_swift_extension.pb.swift */; }; - F44F93EF1DAEA8C900BC5B85 /* unittest_swift_fieldorder.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_fieldorder.pb.swift /* unittest_swift_fieldorder.pb.swift */; }; - F44F93F01DAEA8C900BC5B85 /* unittest_swift_groups.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_groups.pb.swift /* unittest_swift_groups.pb.swift */; }; - F44F93F11DAEA8C900BC5B85 /* unittest_swift_naming.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_naming.pb.swift /* unittest_swift_naming.pb.swift */; }; - F44F93F21DAEA8C900BC5B85 /* unittest_swift_performance.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_performance.pb.swift /* unittest_swift_performance.pb.swift */; }; - F44F93F31DAEA8C900BC5B85 /* unittest_swift_reserved.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_reserved.pb.swift /* unittest_swift_reserved.pb.swift */; }; - F44F93F41DAEA8C900BC5B85 /* unittest_swift_runtime_proto2.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_runtime_proto2.pb.swift /* unittest_swift_runtime_proto2.pb.swift */; }; - F44F93F51DAEA8C900BC5B85 /* unittest_swift_runtime_proto3.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_runtime_proto3.pb.swift /* unittest_swift_runtime_proto3.pb.swift */; }; - F44F93F61DAEA8C900BC5B85 /* unittest_swift_startup.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_startup.pb.swift /* unittest_swift_startup.pb.swift */; }; - F44F93F71DAEA8C900BC5B85 /* unittest_well_known_types.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_well_known_types.pb.swift /* unittest_well_known_types.pb.swift */; }; - F44F93F81DAEA8C900BC5B85 /* unittest.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest.pb.swift /* unittest.pb.swift */; }; - F44F94061DAEB23500BC5B85 /* api.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/api.pb.swift /* api.pb.swift */; }; - F44F94071DAEB23500BC5B85 /* duration.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/duration.pb.swift /* duration.pb.swift */; }; - F44F94081DAEB23500BC5B85 /* empty.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/empty.pb.swift /* empty.pb.swift */; }; - F44F94091DAEB23500BC5B85 /* field_mask.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/field_mask.pb.swift /* field_mask.pb.swift */; }; - F44F940B1DAEB23500BC5B85 /* Google_Protobuf_Duration+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/Google_Protobuf_Duration_Extensions.swift /* Google_Protobuf_Duration+Extensions.swift */; }; - F44F940C1DAEB23500BC5B85 /* Google_Protobuf_FieldMask+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/Google_Protobuf_FieldMask_Extensions.swift /* Google_Protobuf_FieldMask+Extensions.swift */; }; - F44F94101DAEB23500BC5B85 /* BinaryDecoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufBinaryDecoding.swift /* BinaryDecoder.swift */; }; - F44F94111DAEB23500BC5B85 /* BinaryEncoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufBinaryEncoding.swift /* BinaryEncoder.swift */; }; - F44F94121DAEB23500BC5B85 /* BinaryEncodingSizeVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA28A4AB1DA454DA00C866D9 /* BinaryEncodingSizeVisitor.swift */; }; - F44F94131DAEB23500BC5B85 /* Message+BinaryAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufBinaryTypes.swift /* Message+BinaryAdditions.swift */; }; - F44F94151DAEB23500BC5B85 /* Enum.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufEnum.swift /* Enum.swift */; }; - F44F94171DAEB23500BC5B85 /* ExtensionFields.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufExtensionFields.swift /* ExtensionFields.swift */; }; - F44F94181DAEB23500BC5B85 /* MessageExtension.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufExtensions.swift /* MessageExtension.swift */; }; - F44F94191DAEB23500BC5B85 /* Decoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufFieldDecoder.swift /* Decoder.swift */; }; - F44F941A1DAEB23500BC5B85 /* HashVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufHash.swift /* HashVisitor.swift */; }; - F44F941C1DAEB23500BC5B85 /* JSONEncoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufJSONEncoding.swift /* JSONEncoder.swift */; }; - F44F941D1DAEB23500BC5B85 /* Message+JSONAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufJSONTypes.swift /* Message+JSONAdditions.swift */; }; - F44F941E1DAEB23500BC5B85 /* Message.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufMessage.swift /* Message.swift */; }; - F44F94221DAEB23500BC5B85 /* FieldTypes.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufTypes.swift /* FieldTypes.swift */; }; - F44F94231DAEB23500BC5B85 /* UnknownStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufUnknown.swift /* UnknownStorage.swift */; }; - F44F94351DBF9AEA00BC5B85 /* Test_BasicFields_Access_Proto2.swift in Sources */ = {isa = PBXBuildFile; fileRef = F44F94341DBF9AEA00BC5B85 /* Test_BasicFields_Access_Proto2.swift */; }; - F44F94361DBF9AEA00BC5B85 /* Test_BasicFields_Access_Proto2.swift in Sources */ = {isa = PBXBuildFile; fileRef = F44F94341DBF9AEA00BC5B85 /* Test_BasicFields_Access_Proto2.swift */; }; - F44F94371DBF9AEA00BC5B85 /* Test_BasicFields_Access_Proto2.swift in Sources */ = {isa = PBXBuildFile; fileRef = F44F94341DBF9AEA00BC5B85 /* Test_BasicFields_Access_Proto2.swift */; }; - F44F943A1DBFBB7400BC5B85 /* Test_BasicFields_Access_Proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = F44F94381DBFBB6800BC5B85 /* Test_BasicFields_Access_Proto3.swift */; }; - F44F943B1DBFBB7500BC5B85 /* Test_BasicFields_Access_Proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = F44F94381DBFBB6800BC5B85 /* Test_BasicFields_Access_Proto3.swift */; }; - F44F943C1DBFBB7700BC5B85 /* Test_BasicFields_Access_Proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = F44F94381DBFBB6800BC5B85 /* Test_BasicFields_Access_Proto3.swift */; }; - F44F943E1DBFC2CF00BC5B85 /* Test_OneofFields_Access_Proto2.swift in Sources */ = {isa = PBXBuildFile; fileRef = F44F943D1DBFC2CF00BC5B85 /* Test_OneofFields_Access_Proto2.swift */; }; - F44F943F1DBFC2CF00BC5B85 /* Test_OneofFields_Access_Proto2.swift in Sources */ = {isa = PBXBuildFile; fileRef = F44F943D1DBFC2CF00BC5B85 /* Test_OneofFields_Access_Proto2.swift */; }; - F44F94401DBFC2CF00BC5B85 /* Test_OneofFields_Access_Proto2.swift in Sources */ = {isa = PBXBuildFile; fileRef = F44F943D1DBFC2CF00BC5B85 /* Test_OneofFields_Access_Proto2.swift */; }; - F44F94431DBFE0BE00BC5B85 /* Test_OneofFields_Access_Proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = F44F94411DBFE0BA00BC5B85 /* Test_OneofFields_Access_Proto3.swift */; }; - F44F94441DBFE0BF00BC5B85 /* Test_OneofFields_Access_Proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = F44F94411DBFE0BA00BC5B85 /* Test_OneofFields_Access_Proto3.swift */; }; - F44F94451DBFE0C000BC5B85 /* Test_OneofFields_Access_Proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = F44F94411DBFE0BA00BC5B85 /* Test_OneofFields_Access_Proto3.swift */; }; - F44F94481DBFF17F00BC5B85 /* Test_MapFields_Access_Proto2.swift in Sources */ = {isa = PBXBuildFile; fileRef = F44F94461DBFF17B00BC5B85 /* Test_MapFields_Access_Proto2.swift */; }; - F44F94491DBFF18000BC5B85 /* Test_MapFields_Access_Proto2.swift in Sources */ = {isa = PBXBuildFile; fileRef = F44F94461DBFF17B00BC5B85 /* Test_MapFields_Access_Proto2.swift */; }; - F44F944A1DBFF18100BC5B85 /* Test_MapFields_Access_Proto2.swift in Sources */ = {isa = PBXBuildFile; fileRef = F44F94461DBFF17B00BC5B85 /* Test_MapFields_Access_Proto2.swift */; }; - F44F944D1DBFF8DB00BC5B85 /* Test_MapFields_Access_Proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = F44F944B1DBFF8D000BC5B85 /* Test_MapFields_Access_Proto3.swift */; }; - F44F944E1DBFF8DC00BC5B85 /* Test_MapFields_Access_Proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = F44F944B1DBFF8D000BC5B85 /* Test_MapFields_Access_Proto3.swift */; }; - F44F944F1DBFF8DC00BC5B85 /* Test_MapFields_Access_Proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = F44F944B1DBFF8D000BC5B85 /* Test_MapFields_Access_Proto3.swift */; }; - F451074623A288E400488257 /* UnsafeRawPointer+Shims.swift in Sources */ = {isa = PBXBuildFile; fileRef = F451074423A288E400488257 /* UnsafeRawPointer+Shims.swift */; }; - F451074723A288E400488257 /* UnsafeRawPointer+Shims.swift in Sources */ = {isa = PBXBuildFile; fileRef = F451074423A288E400488257 /* UnsafeRawPointer+Shims.swift */; }; - F451074823A288E400488257 /* UnsafeRawPointer+Shims.swift in Sources */ = {isa = PBXBuildFile; fileRef = F451074423A288E400488257 /* UnsafeRawPointer+Shims.swift */; }; - F451074923A288E400488257 /* UnsafeRawPointer+Shims.swift in Sources */ = {isa = PBXBuildFile; fileRef = F451074423A288E400488257 /* UnsafeRawPointer+Shims.swift */; }; - F451074A23A288E400488257 /* UnsafeBufferPointer+Shims.swift in Sources */ = {isa = PBXBuildFile; fileRef = F451074523A288E400488257 /* UnsafeBufferPointer+Shims.swift */; }; - F451074B23A288E400488257 /* UnsafeBufferPointer+Shims.swift in Sources */ = {isa = PBXBuildFile; fileRef = F451074523A288E400488257 /* UnsafeBufferPointer+Shims.swift */; }; - F451074C23A288E400488257 /* UnsafeBufferPointer+Shims.swift in Sources */ = {isa = PBXBuildFile; fileRef = F451074523A288E400488257 /* UnsafeBufferPointer+Shims.swift */; }; - F451074D23A288E400488257 /* UnsafeBufferPointer+Shims.swift in Sources */ = {isa = PBXBuildFile; fileRef = F451074523A288E400488257 /* UnsafeBufferPointer+Shims.swift */; }; - F451075823A2B9B500488257 /* Data+TestHelpers.swift in Sources */ = {isa = PBXBuildFile; fileRef = F451075723A2B9B500488257 /* Data+TestHelpers.swift */; }; - F451075923A2B9B500488257 /* Data+TestHelpers.swift in Sources */ = {isa = PBXBuildFile; fileRef = F451075723A2B9B500488257 /* Data+TestHelpers.swift */; }; - F451075A23A2B9B500488257 /* Data+TestHelpers.swift in Sources */ = {isa = PBXBuildFile; fileRef = F451075723A2B9B500488257 /* Data+TestHelpers.swift */; }; - F4539D261E688B030076251F /* Test_GroupWithGroups.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4539D241E688B000076251F /* Test_GroupWithGroups.swift */; }; - F4539D271E688B040076251F /* Test_GroupWithGroups.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4539D241E688B000076251F /* Test_GroupWithGroups.swift */; }; - F4539D281E688B050076251F /* Test_GroupWithGroups.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4539D241E688B000076251F /* Test_GroupWithGroups.swift */; }; - F4539D2A1E6F5DC70076251F /* CustomJSONCodable.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4539D291E6F5DC70076251F /* CustomJSONCodable.swift */; }; - F4539D2B1E6F5DD40076251F /* CustomJSONCodable.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4539D291E6F5DC70076251F /* CustomJSONCodable.swift */; }; - F4539D2C1E6F5DD50076251F /* CustomJSONCodable.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4539D291E6F5DC70076251F /* CustomJSONCodable.swift */; }; - F4539D2D1E6F5DD60076251F /* CustomJSONCodable.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4539D291E6F5DC70076251F /* CustomJSONCodable.swift */; }; - F4584D3B1ECA4FC600803AB6 /* unittest_swift_oneof_merging.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4584D391ECA4FB400803AB6 /* unittest_swift_oneof_merging.pb.swift */; }; - F4584D3C1ECA4FC700803AB6 /* unittest_swift_oneof_merging.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4584D391ECA4FB400803AB6 /* unittest_swift_oneof_merging.pb.swift */; }; - F4584D3D1ECA4FC800803AB6 /* unittest_swift_oneof_merging.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4584D391ECA4FB400803AB6 /* unittest_swift_oneof_merging.pb.swift */; }; - F4584DB41EDDCA8700803AB6 /* Test_JSONDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4584DB21EDDC9D400803AB6 /* Test_JSONDecodingOptions.swift */; }; - F4584DB51EDDCA8800803AB6 /* Test_JSONDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4584DB21EDDC9D400803AB6 /* Test_JSONDecodingOptions.swift */; }; - F4584DB61EDDCA8900803AB6 /* Test_JSONDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4584DB21EDDC9D400803AB6 /* Test_JSONDecodingOptions.swift */; }; - F4584DB81EDDCAD600803AB6 /* JSONDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4584DB71EDDCAD600803AB6 /* JSONDecodingOptions.swift */; }; - F45D73FD1EE9984A00E0A231 /* Test_MessageSet.swift in Sources */ = {isa = PBXBuildFile; fileRef = F45D73FB1EE994C700E0A231 /* Test_MessageSet.swift */; }; - F45D73FE1EE9984B00E0A231 /* Test_MessageSet.swift in Sources */ = {isa = PBXBuildFile; fileRef = F45D73FB1EE994C700E0A231 /* Test_MessageSet.swift */; }; - F45D73FF1EE9984C00E0A231 /* Test_MessageSet.swift in Sources */ = {isa = PBXBuildFile; fileRef = F45D73FB1EE994C700E0A231 /* Test_MessageSet.swift */; }; - F4618B562154151700E5FABA /* JSONEncodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4618B552154151700E5FABA /* JSONEncodingOptions.swift */; }; - F4618B572154151700E5FABA /* JSONEncodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4618B552154151700E5FABA /* JSONEncodingOptions.swift */; }; - F4618B582154151700E5FABA /* JSONEncodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4618B552154151700E5FABA /* JSONEncodingOptions.swift */; }; - F4618B592154151700E5FABA /* JSONEncodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4618B552154151700E5FABA /* JSONEncodingOptions.swift */; }; - F4618B642154245600E5FABA /* Test_JSONEncodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4618B632154245500E5FABA /* Test_JSONEncodingOptions.swift */; }; - F4618B652154245600E5FABA /* Test_JSONEncodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4618B632154245500E5FABA /* Test_JSONEncodingOptions.swift */; }; - F4618B662154245600E5FABA /* Test_JSONEncodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4618B632154245500E5FABA /* Test_JSONEncodingOptions.swift */; }; - F47138961E4E56AC00C8492C /* Internal.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47138951E4E56AC00C8492C /* Internal.swift */; }; - F47138971E4E56AC00C8492C /* Internal.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47138951E4E56AC00C8492C /* Internal.swift */; }; - F47138981E4E56AC00C8492C /* Internal.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47138951E4E56AC00C8492C /* Internal.swift */; }; - F47138991E4E56AC00C8492C /* Internal.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47138951E4E56AC00C8492C /* Internal.swift */; }; - F47C42B52437A3C700C08579 /* unittest_proto3_optional.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47C42B42437A3C700C08579 /* unittest_proto3_optional.pb.swift */; }; - F47C42B62437A3C700C08579 /* unittest_proto3_optional.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47C42B42437A3C700C08579 /* unittest_proto3_optional.pb.swift */; }; - F47C42B72437A3C700C08579 /* unittest_proto3_optional.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47C42B42437A3C700C08579 /* unittest_proto3_optional.pb.swift */; }; - F47C42C22437A73000C08579 /* Test_AllTypes_Proto3_Optional.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47C42C12437A73000C08579 /* Test_AllTypes_Proto3_Optional.swift */; }; - F47C42C32437A73000C08579 /* Test_AllTypes_Proto3_Optional.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47C42C12437A73000C08579 /* Test_AllTypes_Proto3_Optional.swift */; }; - F47C42C42437A73000C08579 /* Test_AllTypes_Proto3_Optional.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47C42C12437A73000C08579 /* Test_AllTypes_Proto3_Optional.swift */; }; - F47CF9A123E88DD000C7B24C /* unittest_swift_naming_number_prefix.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47CF9A023E88DD000C7B24C /* unittest_swift_naming_number_prefix.pb.swift */; }; - F47CF9A223E88DD000C7B24C /* unittest_swift_naming_number_prefix.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47CF9A023E88DD000C7B24C /* unittest_swift_naming_number_prefix.pb.swift */; }; - F47CF9A323E88DD000C7B24C /* unittest_swift_naming_number_prefix.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47CF9A023E88DD000C7B24C /* unittest_swift_naming_number_prefix.pb.swift */; }; - F482B6791E856D2600A25EF8 /* unittest_swift_reserved_ext.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F482B6771E856D1700A25EF8 /* unittest_swift_reserved_ext.pb.swift */; }; - F482B67A1E856D2700A25EF8 /* unittest_swift_reserved_ext.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F482B6771E856D1700A25EF8 /* unittest_swift_reserved_ext.pb.swift */; }; - F482B67B1E856D2700A25EF8 /* unittest_swift_reserved_ext.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F482B6771E856D1700A25EF8 /* unittest_swift_reserved_ext.pb.swift */; }; - F482B6931E857BC100A25EF8 /* unittest_swift_naming_no_prefix.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F482B6911E857BBC00A25EF8 /* unittest_swift_naming_no_prefix.pb.swift */; }; - F482B6941E857BC100A25EF8 /* unittest_swift_naming_no_prefix.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F482B6911E857BBC00A25EF8 /* unittest_swift_naming_no_prefix.pb.swift */; }; - F482B6951E857BC200A25EF8 /* unittest_swift_naming_no_prefix.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F482B6911E857BBC00A25EF8 /* unittest_swift_naming_no_prefix.pb.swift */; }; - F482B6B31E89940E00A25EF8 /* Version.swift in Sources */ = {isa = PBXBuildFile; fileRef = F482B6B21E89940E00A25EF8 /* Version.swift */; }; - F482B6B61E89941500A25EF8 /* Version.swift in Sources */ = {isa = PBXBuildFile; fileRef = F482B6B21E89940E00A25EF8 /* Version.swift */; }; - F482B6B71E89941600A25EF8 /* Version.swift in Sources */ = {isa = PBXBuildFile; fileRef = F482B6B21E89940E00A25EF8 /* Version.swift */; }; - F482B6B81E89941600A25EF8 /* Version.swift in Sources */ = {isa = PBXBuildFile; fileRef = F482B6B21E89940E00A25EF8 /* Version.swift */; }; - F48769F823020B7D00D44224 /* descriptor.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F48769F723020B7D00D44224 /* descriptor.pb.swift */; }; - F48769F923020B7D00D44224 /* descriptor.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F48769F723020B7D00D44224 /* descriptor.pb.swift */; }; - F48769FA23020B7D00D44224 /* descriptor.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F48769F723020B7D00D44224 /* descriptor.pb.swift */; }; - F48769FB23020B7D00D44224 /* descriptor.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F48769F723020B7D00D44224 /* descriptor.pb.swift */; }; - F48FDD241E4D17ED0061D5C1 /* JSONScanner.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CE9CF361E32C9F8004FBED6 /* JSONScanner.swift */; }; - F48FDD251E4D17EE0061D5C1 /* JSONScanner.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CE9CF361E32C9F8004FBED6 /* JSONScanner.swift */; }; - F48FDD261E4D17EF0061D5C1 /* JSONScanner.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9CE9CF361E32C9F8004FBED6 /* JSONScanner.swift */; }; - F48FDD271E4D18060061D5C1 /* Test_TextFormat_proto2_extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C5890A51DFF5EC8001CFC34 /* Test_TextFormat_proto2_extensions.swift */; }; - F48FDD281E4D18060061D5C1 /* Test_TextFormat_proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = BCCA0E751DB123F800957D74 /* Test_TextFormat_proto3.swift */; }; - F48FDD291E4D18080061D5C1 /* Test_TextFormat_proto2_extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9C5890A51DFF5EC8001CFC34 /* Test_TextFormat_proto2_extensions.swift */; }; - F48FDD2A1E4D18080061D5C1 /* Test_TextFormat_proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = BCCA0E751DB123F800957D74 /* Test_TextFormat_proto3.swift */; }; - F49B576B2252771700350FFD /* TextFormatEncodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F49B576A2252771700350FFD /* TextFormatEncodingOptions.swift */; }; - F49B576C2252771700350FFD /* TextFormatEncodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F49B576A2252771700350FFD /* TextFormatEncodingOptions.swift */; }; - F49B576D2252771700350FFD /* TextFormatEncodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F49B576A2252771700350FFD /* TextFormatEncodingOptions.swift */; }; - F49B576E2252771700350FFD /* TextFormatEncodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F49B576A2252771700350FFD /* TextFormatEncodingOptions.swift */; }; - F4A07B2C1E4A3E620035678A /* test_messages_proto3.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4A07B2A1E4A3E500035678A /* test_messages_proto3.pb.swift */; }; - F4A07B2D1E4A3E630035678A /* test_messages_proto3.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4A07B2A1E4A3E500035678A /* test_messages_proto3.pb.swift */; }; - F4A07B2E1E4A3E640035678A /* test_messages_proto3.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4A07B2A1E4A3E500035678A /* test_messages_proto3.pb.swift */; }; - F4A1A8AD1E65E2EF0022E078 /* map_proto2_unittest.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4A1A8AB1E65E2EA0022E078 /* map_proto2_unittest.pb.swift */; }; - F4A1A8AE1E65E2F00022E078 /* map_proto2_unittest.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4A1A8AB1E65E2EA0022E078 /* map_proto2_unittest.pb.swift */; }; - F4A1A8AF1E65E2F10022E078 /* map_proto2_unittest.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4A1A8AB1E65E2EA0022E078 /* map_proto2_unittest.pb.swift */; }; - F4C3A9711E96A08E006BB610 /* unittest_swift_oneof_all_required.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4C3A96F1E969F79006BB610 /* unittest_swift_oneof_all_required.pb.swift */; }; - F4C3A9721E96A08F006BB610 /* unittest_swift_oneof_all_required.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4C3A96F1E969F79006BB610 /* unittest_swift_oneof_all_required.pb.swift */; }; - F4C3A9731E96A090006BB610 /* unittest_swift_oneof_all_required.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4C3A96F1E969F79006BB610 /* unittest_swift_oneof_all_required.pb.swift */; }; - F4CECDD2262A141B008B05BC /* TextFormatDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4CECDD1262A141B008B05BC /* TextFormatDecodingOptions.swift */; }; - F4CECDD3262A141B008B05BC /* TextFormatDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4CECDD1262A141B008B05BC /* TextFormatDecodingOptions.swift */; }; - F4CECDD4262A141B008B05BC /* TextFormatDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4CECDD1262A141B008B05BC /* TextFormatDecodingOptions.swift */; }; - F4CECDD5262A141B008B05BC /* TextFormatDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4CECDD1262A141B008B05BC /* TextFormatDecodingOptions.swift */; }; - F4CECDDE262A1442008B05BC /* Test_TextFormatDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4CECDDD262A1442008B05BC /* Test_TextFormatDecodingOptions.swift */; }; - F4CECDDF262A1442008B05BC /* Test_TextFormatDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4CECDDD262A1442008B05BC /* Test_TextFormatDecodingOptions.swift */; }; - F4CECDE0262A1442008B05BC /* Test_TextFormatDecodingOptions.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4CECDDD262A1442008B05BC /* Test_TextFormatDecodingOptions.swift */; }; - F4D315471DEC8117005D4A80 /* unittest_swift_extension2.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4D315431DEC8110005D4A80 /* unittest_swift_extension2.pb.swift */; }; - F4D315481DEC8117005D4A80 /* unittest_swift_extension3.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4D315441DEC8110005D4A80 /* unittest_swift_extension3.pb.swift */; }; - F4D315491DEC811B005D4A80 /* unittest_swift_extension2.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4D315431DEC8110005D4A80 /* unittest_swift_extension2.pb.swift */; }; - F4D3154A1DEC811B005D4A80 /* unittest_swift_extension3.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4D315441DEC8110005D4A80 /* unittest_swift_extension3.pb.swift */; }; - F4D3154B1DEC811C005D4A80 /* unittest_swift_extension2.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4D315431DEC8110005D4A80 /* unittest_swift_extension2.pb.swift */; }; - F4D3154C1DEC811C005D4A80 /* unittest_swift_extension3.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4D315441DEC8110005D4A80 /* unittest_swift_extension3.pb.swift */; }; - F4D315541DECA0EA005D4A80 /* unittest_swift_extension4.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4D315521DECA0E5005D4A80 /* unittest_swift_extension4.pb.swift */; }; - F4D315551DECA0EA005D4A80 /* unittest_swift_extension4.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4D315521DECA0E5005D4A80 /* unittest_swift_extension4.pb.swift */; }; - F4D315561DECA0EB005D4A80 /* unittest_swift_extension4.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4D315521DECA0E5005D4A80 /* unittest_swift_extension4.pb.swift */; }; - F4E852B61EE9D83C00AE837E /* SelectiveVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4E852B51EE9D83C00AE837E /* SelectiveVisitor.swift */; }; - F4E852B71EE9D84800AE837E /* SelectiveVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4E852B51EE9D83C00AE837E /* SelectiveVisitor.swift */; }; - F4E852B81EE9D84900AE837E /* SelectiveVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4E852B51EE9D83C00AE837E /* SelectiveVisitor.swift */; }; - F4E852B91EE9D84A00AE837E /* SelectiveVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4E852B51EE9D83C00AE837E /* SelectiveVisitor.swift */; }; - F4EDCC2B22DF896500A1ECB7 /* DoubleParser.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4EDCC2A22DF896500A1ECB7 /* DoubleParser.swift */; }; - F4EDCC2C22DF896500A1ECB7 /* DoubleParser.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4EDCC2A22DF896500A1ECB7 /* DoubleParser.swift */; }; - F4EDCC2D22DF896500A1ECB7 /* DoubleParser.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4EDCC2A22DF896500A1ECB7 /* DoubleParser.swift */; }; - F4EDCC2E22DF896500A1ECB7 /* DoubleParser.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4EDCC2A22DF896500A1ECB7 /* DoubleParser.swift */; }; - F4F4F1181E5633E7006C6CAD /* Test_Naming.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4F4F1161E5633E3006C6CAD /* Test_Naming.swift */; }; - F4F4F1191E5633E8006C6CAD /* Test_Naming.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4F4F1161E5633E3006C6CAD /* Test_Naming.swift */; }; - F4F4F11A1E5633EA006C6CAD /* Test_Naming.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4F4F1161E5633E3006C6CAD /* Test_Naming.swift */; }; - F4F4F11B1E5C7556006C6CAD /* TimeUtils.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8DC1CA0E1E54B81400CA8A26 /* TimeUtils.swift */; }; - F4F4F11C1E5C7556006C6CAD /* TimeUtils.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8DC1CA0E1E54B81400CA8A26 /* TimeUtils.swift */; }; - F4F4F11D1E5C7557006C6CAD /* TimeUtils.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8DC1CA0E1E54B81400CA8A26 /* TimeUtils.swift */; }; - F4F4F11E1E5C7562006C6CAD /* MathUtils.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8DC1CA0C1E54B80800CA8A26 /* MathUtils.swift */; }; - F4F4F11F1E5C7563006C6CAD /* MathUtils.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8DC1CA0C1E54B80800CA8A26 /* MathUtils.swift */; }; - F4F4F1201E5C7565006C6CAD /* MathUtils.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8DC1CA0C1E54B80800CA8A26 /* MathUtils.swift */; }; - _LinkFileRef_Protobuf_via_ProtobufTestSuite /* SwiftProtobuf.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = "_____Product_Protobuf_macOS" /* SwiftProtobuf.framework */; }; - __src_cc_ref_Sources/Protobuf/Google_Protobuf_Duration_Extensions.swift /* Google_Protobuf_Duration+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/Google_Protobuf_Duration_Extensions.swift /* Google_Protobuf_Duration+Extensions.swift */; }; - __src_cc_ref_Sources/Protobuf/Google_Protobuf_FieldMask_Extensions.swift /* Google_Protobuf_FieldMask+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/Google_Protobuf_FieldMask_Extensions.swift /* Google_Protobuf_FieldMask+Extensions.swift */; }; - __src_cc_ref_Sources/Protobuf/Google_Protobuf_Struct.swift /* Google_Protobuf_Struct+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/Google_Protobuf_Struct.swift /* Google_Protobuf_Struct+Extensions.swift */; }; - __src_cc_ref_Sources/Protobuf/Google_Protobuf_Timestamp_Extensions.swift /* Google_Protobuf_Timestamp+Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/Google_Protobuf_Timestamp_Extensions.swift /* Google_Protobuf_Timestamp+Extensions.swift */; }; - __src_cc_ref_Sources/Protobuf/ProtobufBinaryDecoding.swift /* BinaryDecoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufBinaryDecoding.swift /* BinaryDecoder.swift */; }; - __src_cc_ref_Sources/Protobuf/ProtobufBinaryEncoding.swift /* BinaryEncoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufBinaryEncoding.swift /* BinaryEncoder.swift */; }; - __src_cc_ref_Sources/Protobuf/ProtobufBinaryTypes.swift /* Message+BinaryAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufBinaryTypes.swift /* Message+BinaryAdditions.swift */; }; - __src_cc_ref_Sources/Protobuf/ProtobufEnum.swift /* Enum.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufEnum.swift /* Enum.swift */; }; - __src_cc_ref_Sources/Protobuf/ProtobufExtensionFields.swift /* ExtensionFields.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufExtensionFields.swift /* ExtensionFields.swift */; }; - __src_cc_ref_Sources/Protobuf/ProtobufExtensions.swift /* MessageExtension.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufExtensions.swift /* MessageExtension.swift */; }; - __src_cc_ref_Sources/Protobuf/ProtobufFieldDecoder.swift /* Decoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufFieldDecoder.swift /* Decoder.swift */; }; - __src_cc_ref_Sources/Protobuf/ProtobufHash.swift /* HashVisitor.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufHash.swift /* HashVisitor.swift */; }; - __src_cc_ref_Sources/Protobuf/ProtobufJSONEncoding.swift /* JSONEncoder.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufJSONEncoding.swift /* JSONEncoder.swift */; }; - __src_cc_ref_Sources/Protobuf/ProtobufJSONTypes.swift /* Message+JSONAdditions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufJSONTypes.swift /* Message+JSONAdditions.swift */; }; - __src_cc_ref_Sources/Protobuf/ProtobufMessage.swift /* Message.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufMessage.swift /* Message.swift */; }; - __src_cc_ref_Sources/Protobuf/ProtobufTypes.swift /* FieldTypes.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufTypes.swift /* FieldTypes.swift */; }; - __src_cc_ref_Sources/Protobuf/ProtobufUnknown.swift /* UnknownStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/ProtobufUnknown.swift /* UnknownStorage.swift */; }; - __src_cc_ref_Sources/Protobuf/api.pb.swift /* api.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/api.pb.swift /* api.pb.swift */; }; - __src_cc_ref_Sources/Protobuf/duration.pb.swift /* duration.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/duration.pb.swift /* duration.pb.swift */; }; - __src_cc_ref_Sources/Protobuf/empty.pb.swift /* empty.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/empty.pb.swift /* empty.pb.swift */; }; - __src_cc_ref_Sources/Protobuf/field_mask.pb.swift /* field_mask.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/field_mask.pb.swift /* field_mask.pb.swift */; }; - __src_cc_ref_Sources/Protobuf/source_context.pb.swift /* source_context.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/source_context.pb.swift /* source_context.pb.swift */; }; - __src_cc_ref_Sources/Protobuf/timestamp.pb.swift /* timestamp.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/timestamp.pb.swift /* timestamp.pb.swift */; }; - __src_cc_ref_Sources/Protobuf/type.pb.swift /* type.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Sources/Protobuf/type.pb.swift /* type.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/TestHelpers.swift /* TestHelpers.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/TestHelpers.swift /* TestHelpers.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_AllTypes.swift /* Test_AllTypes.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_AllTypes.swift /* Test_AllTypes.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_AllTypes_Proto3.swift /* Test_AllTypes_Proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_AllTypes_Proto3.swift /* Test_AllTypes_Proto3.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_Any.swift /* Test_Any.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Any.swift /* Test_Any.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_Api.swift /* Test_Api.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Api.swift /* Test_Api.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_Conformance.swift /* Test_Conformance.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Conformance.swift /* Test_Conformance.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_Duration.swift /* Test_Duration.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Duration.swift /* Test_Duration.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_Empty.swift /* Test_Empty.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Empty.swift /* Test_Empty.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_Enum.swift /* Test_Enum.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Enum.swift /* Test_Enum.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_Extensions.swift /* Test_Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Extensions.swift /* Test_Extensions.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_ExtremeDefaultValues.swift /* Test_ExtremeDefaultValues.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_ExtremeDefaultValues.swift /* Test_ExtremeDefaultValues.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_FieldMask.swift /* Test_FieldMask.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_FieldMask.swift /* Test_FieldMask.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_FieldOrdering.swift /* Test_FieldOrdering.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_FieldOrdering.swift /* Test_FieldOrdering.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_JSON.swift /* Test_JSON.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_JSON.swift /* Test_JSON.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_JSON_Conformance.swift /* Test_JSON_Conformance.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_JSON_Conformance.swift /* Test_JSON_Conformance.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_JSON_Group.swift /* Test_JSON_Group.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_JSON_Group.swift /* Test_JSON_Group.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_Map.swift /* Test_Map.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Map.swift /* Test_Map.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_Map_JSON.swift /* Test_Map_JSON.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Map_JSON.swift /* Test_Map_JSON.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_Packed.swift /* Test_Packed.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Packed.swift /* Test_Packed.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_ParsingMerge.swift /* Test_ParsingMerge.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_ParsingMerge.swift /* Test_ParsingMerge.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_ReallyLargeTagNumber.swift /* Test_ReallyLargeTagNumber.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_ReallyLargeTagNumber.swift /* Test_ReallyLargeTagNumber.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_RecursiveMap.swift /* Test_RecursiveMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_RecursiveMap.swift /* Test_RecursiveMap.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_Required.swift /* Test_Required.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Required.swift /* Test_Required.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_Reserved.swift /* Test_Reserved.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Reserved.swift /* Test_Reserved.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_Struct.swift /* Test_Struct.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Struct.swift /* Test_Struct.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_Timestamp.swift /* Test_Timestamp.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Timestamp.swift /* Test_Timestamp.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_Type.swift /* Test_Type.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Type.swift /* Test_Type.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_Unknown_proto2.swift /* Test_Unknown_proto2.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Unknown_proto2.swift /* Test_Unknown_proto2.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_Unknown_proto3.swift /* Test_Unknown_proto3.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Unknown_proto3.swift /* Test_Unknown_proto3.swift */; }; - __src_cc_ref_Tests/ProtobufTests/Test_Wrappers.swift /* Test_Wrappers.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/Test_Wrappers.swift /* Test_Wrappers.swift */; }; - __src_cc_ref_Tests/ProtobufTests/any_test.pb.swift /* any_test.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/any_test.pb.swift /* any_test.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/conformance.pb.swift /* conformance.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/conformance.pb.swift /* conformance.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/map_unittest.pb.swift /* map_unittest.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/map_unittest.pb.swift /* map_unittest.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest.pb.swift /* unittest.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest.pb.swift /* unittest.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_arena.pb.swift /* unittest_arena.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_arena.pb.swift /* unittest_arena.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_custom_options.pb.swift /* unittest_custom_options.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_custom_options.pb.swift /* unittest_custom_options.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_drop_unknown_fields.pb.swift /* unittest_drop_unknown_fields.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_drop_unknown_fields.pb.swift /* unittest_drop_unknown_fields.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_embed_optimize_for.pb.swift /* unittest_embed_optimize_for.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_embed_optimize_for.pb.swift /* unittest_embed_optimize_for.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_empty.pb.swift /* unittest_empty.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_empty.pb.swift /* unittest_empty.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_import.pb.swift /* unittest_import.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_import.pb.swift /* unittest_import.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_import_lite.pb.swift /* unittest_import_lite.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_import_lite.pb.swift /* unittest_import_lite.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_import_public.pb.swift /* unittest_import_public.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_import_public.pb.swift /* unittest_import_public.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_import_public_lite.pb.swift /* unittest_import_public_lite.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_import_public_lite.pb.swift /* unittest_import_public_lite.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_lite.pb.swift /* unittest_lite.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_lite.pb.swift /* unittest_lite.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_lite_imports_nonlite.pb.swift /* unittest_lite_imports_nonlite.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_lite_imports_nonlite.pb.swift /* unittest_lite_imports_nonlite.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_mset.pb.swift /* unittest_mset.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_mset.pb.swift /* unittest_mset.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_mset_wire_format.pb.swift /* unittest_mset_wire_format.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_mset_wire_format.pb.swift /* unittest_mset_wire_format.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_no_field_presence.pb.swift /* unittest_no_field_presence.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_no_field_presence.pb.swift /* unittest_no_field_presence.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_no_generic_services.pb.swift /* unittest_no_generic_services.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_no_generic_services.pb.swift /* unittest_no_generic_services.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_optimize_for.pb.swift /* unittest_optimize_for.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_optimize_for.pb.swift /* unittest_optimize_for.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_preserve_unknown_enum.pb.swift /* unittest_preserve_unknown_enum.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_preserve_unknown_enum.pb.swift /* unittest_preserve_unknown_enum.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_preserve_unknown_enum2.pb.swift /* unittest_preserve_unknown_enum2.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_preserve_unknown_enum2.pb.swift /* unittest_preserve_unknown_enum2.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_proto3.pb.swift /* unittest_proto3.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_proto3.pb.swift /* unittest_proto3.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_proto3_arena.pb.swift /* unittest_proto3_arena.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_proto3_arena.pb.swift /* unittest_proto3_arena.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_swift_all_required_types.pb.swift /* unittest_swift_all_required_types.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_all_required_types.pb.swift /* unittest_swift_all_required_types.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_swift_cycle.pb.swift /* unittest_swift_cycle.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_cycle.pb.swift /* unittest_swift_cycle.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_swift_enum.pb.swift /* unittest_swift_enum.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_enum.pb.swift /* unittest_swift_enum.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_swift_enum_optional_default.pb.swift /* unittest_swift_enum_optional_default.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_enum_optional_default.pb.swift /* unittest_swift_enum_optional_default.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_swift_extension.pb.swift /* unittest_swift_extension.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_extension.pb.swift /* unittest_swift_extension.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_swift_fieldorder.pb.swift /* unittest_swift_fieldorder.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_fieldorder.pb.swift /* unittest_swift_fieldorder.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_swift_groups.pb.swift /* unittest_swift_groups.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_groups.pb.swift /* unittest_swift_groups.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_swift_naming.pb.swift /* unittest_swift_naming.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_naming.pb.swift /* unittest_swift_naming.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_swift_performance.pb.swift /* unittest_swift_performance.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_performance.pb.swift /* unittest_swift_performance.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_swift_reserved.pb.swift /* unittest_swift_reserved.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_reserved.pb.swift /* unittest_swift_reserved.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_swift_runtime_proto2.pb.swift /* unittest_swift_runtime_proto2.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_runtime_proto2.pb.swift /* unittest_swift_runtime_proto2.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_swift_runtime_proto3.pb.swift /* unittest_swift_runtime_proto3.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_runtime_proto3.pb.swift /* unittest_swift_runtime_proto3.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_swift_startup.pb.swift /* unittest_swift_startup.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_swift_startup.pb.swift /* unittest_swift_startup.pb.swift */; }; - __src_cc_ref_Tests/ProtobufTests/unittest_well_known_types.pb.swift /* unittest_well_known_types.pb.swift in Sources */ = {isa = PBXBuildFile; fileRef = __PBXFileRef_Tests/ProtobufTests/unittest_well_known_types.pb.swift /* unittest_well_known_types.pb.swift */; }; -/* End PBXBuildFile section */ - -/* Begin PBXContainerItemProxy section */ - 9C8CDA181D7A288E00E207CA /* PBXContainerItemProxy */ = { - isa = PBXContainerItemProxy; - containerPortal = __RootObject_ /* Project object */; - proxyType = 1; - remoteGlobalIDString = BD12FD351D767BA0001815C7; - remoteInfo = Protobuf_iOS; - }; - 9CAEA5251D25B35600EB832A /* PBXContainerItemProxy */ = { - isa = PBXContainerItemProxy; - containerPortal = __RootObject_ /* Project object */; - proxyType = 1; - remoteGlobalIDString = "______Target_Protobuf"; - remoteInfo = Protobuf; - }; - F44F93A51DAEA7C500BC5B85 /* PBXContainerItemProxy */ = { - isa = PBXContainerItemProxy; - containerPortal = __RootObject_ /* Project object */; - proxyType = 1; - remoteGlobalIDString = F44F936E1DAEA53900BC5B85; - remoteInfo = SwiftProtobuf_tvOS; - }; -/* End PBXContainerItemProxy section */ - -/* Begin PBXFileReference section */ - 5A82E3442455D26900EB0A70 /* Base.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = Base.xcconfig; path = SwiftProtobuf.xcodeproj/xcconfigs/Base.xcconfig; sourceTree = ""; }; - 5A82E3452455D26900EB0A70 /* SwiftProtobuf_watchOS.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = SwiftProtobuf_watchOS.xcconfig; path = SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobuf_watchOS.xcconfig; sourceTree = ""; }; - 5A82E3462455D26900EB0A70 /* SwiftProtobuf_iOS.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = SwiftProtobuf_iOS.xcconfig; path = SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobuf_iOS.xcconfig; sourceTree = ""; }; - 5A82E3472455D26900EB0A70 /* SwiftProtobufTestSuite_macOS.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = SwiftProtobufTestSuite_macOS.xcconfig; path = SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobufTestSuite_macOS.xcconfig; sourceTree = ""; }; - 5A82E3482455D26900EB0A70 /* SwiftProtobuf_macOS.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = SwiftProtobuf_macOS.xcconfig; path = SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobuf_macOS.xcconfig; sourceTree = ""; }; - 5A82E3492455D26900EB0A70 /* SwiftProtobuf_tvOS.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = SwiftProtobuf_tvOS.xcconfig; path = SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobuf_tvOS.xcconfig; sourceTree = ""; }; - 5A82E34A2455D26900EB0A70 /* SwiftProtobufTestSuite_tvOS.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = SwiftProtobufTestSuite_tvOS.xcconfig; path = SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobufTestSuite_tvOS.xcconfig; sourceTree = ""; }; - 5A82E34B2455D26900EB0A70 /* SwiftProtobufTestSuite_iOS.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = SwiftProtobufTestSuite_iOS.xcconfig; path = SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobufTestSuite_iOS.xcconfig; sourceTree = ""; }; - 5A82E34C2455D71400EB0A70 /* Base_Debug.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = Base_Debug.xcconfig; path = SwiftProtobuf.xcodeproj/xcconfigs/Base_Debug.xcconfig; sourceTree = ""; }; - 5A82E34D2455D71400EB0A70 /* Base_Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = Base_Release.xcconfig; path = SwiftProtobuf.xcodeproj/xcconfigs/Base_Release.xcconfig; sourceTree = ""; }; - 6583D6E3246E04A200353AF4 /* Test_JSON_Extensions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_JSON_Extensions.swift; sourceTree = ""; }; - 8037FC942507E4F4003B7FAC /* unittest_swift_json.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = unittest_swift_json.pb.swift; sourceTree = ""; }; - 8DC1CA0C1E54B80800CA8A26 /* MathUtils.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = MathUtils.swift; sourceTree = ""; }; - 8DC1CA0E1E54B81400CA8A26 /* TimeUtils.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TimeUtils.swift; sourceTree = ""; }; - 9C0B366A1E5FAB910094E128 /* JSONMapEncodingVisitor.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JSONMapEncodingVisitor.swift; sourceTree = ""; }; - 9C4178601E809DA2007830C3 /* ExtensionMap.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ExtensionMap.swift; sourceTree = ""; }; - 9C5890A51DFF5EC8001CFC34 /* Test_TextFormat_proto2_extensions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_TextFormat_proto2_extensions.swift; sourceTree = ""; }; - 9C60CBE71DF8AC3F00F7B14E /* Test_TextFormat_Map_proto3.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_TextFormat_Map_proto3.swift; sourceTree = ""; }; - 9C60CBEB1DF9DEEA00F7B14E /* Test_TextFormat_proto2.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_TextFormat_proto2.swift; sourceTree = ""; }; - 9C667A8E1E4C203D008B974F /* JSONDecodingError.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JSONDecodingError.swift; sourceTree = ""; }; - 9C667A8F1E4C203D008B974F /* BinaryDecodingError.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = BinaryDecodingError.swift; sourceTree = ""; }; - 9C667A901E4C203D008B974F /* TextFormatDecodingError.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TextFormatDecodingError.swift; sourceTree = ""; }; - 9C7254651E5F9B1600486C98 /* Test_TextFormat_Unknown.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_TextFormat_Unknown.swift; sourceTree = ""; }; - 9C75F87F1DDBE0DE005CCFF2 /* Visitor.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Visitor.swift; sourceTree = ""; }; - 9C75F8841DDD3045005CCFF2 /* SimpleExtensionMap.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SimpleExtensionMap.swift; sourceTree = ""; }; - 9C75F8891DDD30A5005CCFF2 /* ExtensionFieldValueSet.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ExtensionFieldValueSet.swift; sourceTree = ""; }; - 9C75F88E1DDD3108005CCFF2 /* ExtensibleMessage.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ExtensibleMessage.swift; sourceTree = ""; }; - 9C75F8931DDD3D20005CCFF2 /* BinaryEncodingVisitor.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = BinaryEncodingVisitor.swift; sourceTree = ""; }; - 9C75F89D1DDD3FA3005CCFF2 /* JSONDecoder.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JSONDecoder.swift; sourceTree = ""; }; - 9C75F8A21DDD44A1005CCFF2 /* ProtobufMap.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ProtobufMap.swift; sourceTree = ""; }; - 9C84E48C1E5E3ABD00513BE0 /* BinaryEncodingError.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = BinaryEncodingError.swift; sourceTree = ""; }; - 9C84E48D1E5E3ABD00513BE0 /* JSONEncodingError.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JSONEncodingError.swift; sourceTree = ""; }; - 9CA424411E286D4E00C0E5B4 /* StringUtils.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = StringUtils.swift; sourceTree = ""; }; - 9CC8CAA81EC512A0008EF45F /* generated_swift_names_enum_cases.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = generated_swift_names_enum_cases.pb.swift; sourceTree = ""; }; - 9CC8CAA91EC512A0008EF45F /* generated_swift_names_enums.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = generated_swift_names_enums.pb.swift; sourceTree = ""; }; - 9CC8CAAA1EC512A0008EF45F /* generated_swift_names_fields.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = generated_swift_names_fields.pb.swift; sourceTree = ""; }; - 9CC8CAAB1EC512A0008EF45F /* generated_swift_names_messages.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = generated_swift_names_messages.pb.swift; sourceTree = ""; }; - 9CCD5F921E008203002D1940 /* Test_TextFormat_WKT_proto3.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_TextFormat_WKT_proto3.swift; sourceTree = ""; }; - 9CE4C56724EF34F200471257 /* Google_Protobuf_NullValue+Extensions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Google_Protobuf_NullValue+Extensions.swift"; sourceTree = ""; }; - 9CE9CF361E32C9F8004FBED6 /* JSONScanner.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JSONScanner.swift; sourceTree = ""; }; - 9CEB0D671DF5E934002D80F0 /* TextFormatEncodingVisitor.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TextFormatEncodingVisitor.swift; sourceTree = ""; }; - 9CEB0D6B1DF5F921002D80F0 /* TextFormatScanner.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TextFormatScanner.swift; sourceTree = ""; }; - AA05BF491DAEB7E400619042 /* WireFormat.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = WireFormat.swift; sourceTree = ""; }; - AA05BF4E1DAEB7E800619042 /* FieldTag.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = FieldTag.swift; sourceTree = ""; }; - AA28A4A51DA30E5900C866D9 /* ZigZag.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ZigZag.swift; sourceTree = ""; }; - AA28A4A81DA40B0900C866D9 /* Varint.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Varint.swift; sourceTree = ""; }; - AA28A4AB1DA454DA00C866D9 /* BinaryEncodingSizeVisitor.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = BinaryEncodingSizeVisitor.swift; sourceTree = ""; }; - AA3640901E60D043000C3CF4 /* struct.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = struct.pb.swift; sourceTree = ""; }; - AA3640951E60EBB0000C3CF4 /* Test_Merge.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_Merge.swift; sourceTree = ""; }; - AA6CF6F01DB6D1F8007DF26B /* Test_Enum_Proto2.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_Enum_Proto2.swift; sourceTree = ""; }; - AA78AD351E84C5B4001C43F9 /* Message+AnyAdditions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Message+AnyAdditions.swift"; sourceTree = ""; }; - AA86F6F91E0A0F0B006CC38A /* JSONEncodingVisitor.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JSONEncodingVisitor.swift; sourceTree = ""; }; - AAABA40A1E4A42CD00365CDF /* ProtobufAPIVersionCheck.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ProtobufAPIVersionCheck.swift; sourceTree = ""; }; - AAB979F41E7066D8003DC2F4 /* Google_Protobuf_ListValue+Extensions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Google_Protobuf_ListValue+Extensions.swift"; sourceTree = ""; }; - AAE0F4DE1E6A3886005240E0 /* Test_EnumWithAliases.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_EnumWithAliases.swift; sourceTree = ""; }; - AAE0F4E21E6F5CB9005240E0 /* Google_Protobuf_Value+Extensions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Google_Protobuf_Value+Extensions.swift"; sourceTree = ""; }; - AAEA521F1DA5BB81003F318F /* Message+UInt8ArrayHelpers.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Message+UInt8ArrayHelpers.swift"; sourceTree = ""; }; - AAEA52711DA80DD4003F318F /* Google_Protobuf_Wrappers+Extensions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Google_Protobuf_Wrappers+Extensions.swift"; sourceTree = ""; }; - AAEA52731DA80DEA003F318F /* wrappers.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = wrappers.pb.swift; sourceTree = ""; }; - AAF2ED391DEF3FBC007B510F /* NameMap.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = NameMap.swift; sourceTree = ""; }; - AAF2ED3E1DEF4D94007B510F /* ProtoNameProviding.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ProtoNameProviding.swift; sourceTree = ""; }; - BCCA0E661DB1210E00957D74 /* TextFormatDecoder.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TextFormatDecoder.swift; sourceTree = ""; }; - BCCA0E671DB1210E00957D74 /* TextFormatEncoder.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TextFormatEncoder.swift; sourceTree = ""; }; - BCCA0E681DB1210E00957D74 /* Message+TextFormatAdditions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Message+TextFormatAdditions.swift"; sourceTree = ""; }; - BCCA0E751DB123F800957D74 /* Test_TextFormat_proto3.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_TextFormat_proto3.swift; sourceTree = ""; }; - DB2E0AF91EB24C7600F59319 /* Test_JSON_Array.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_JSON_Array.swift; sourceTree = ""; }; - DB2E0AFD1EB25D1D00F59319 /* Message+JSONArrayAdditions.swift */ = {isa = PBXFileReference; fileEncoding = 4; indentWidth = 2; lastKnownFileType = sourcecode.swift; path = "Message+JSONArrayAdditions.swift"; sourceTree = ""; tabWidth = 2; }; - E7038A23224D7F1000B68775 /* Data+Extensions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Data+Extensions.swift"; sourceTree = ""; }; - F40D33E82017ECD300ABAF0F /* unittest_swift_enum_proto3.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = unittest_swift_enum_proto3.pb.swift; sourceTree = ""; }; - F411FE941EDDD6AA001AE6B2 /* BinaryDecodingOptions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = BinaryDecodingOptions.swift; sourceTree = ""; }; - F411FEAA1EDDDC5D001AE6B2 /* Test_BinaryDecodingOptions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_BinaryDecodingOptions.swift; sourceTree = ""; }; - F4151F641EF3193F00EEA00B /* Test_SimpleExtensionMap.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_SimpleExtensionMap.swift; sourceTree = ""; }; - F4151F701EFAB83400EEA00B /* BinaryDelimited.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = BinaryDelimited.swift; sourceTree = ""; }; - F4151F751EFAD85600EEA00B /* Test_BinaryDelimited.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_BinaryDelimited.swift; sourceTree = ""; }; - F41BA3FB1E76F635004F6E95 /* Google_Protobuf_Any+Registry.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Google_Protobuf_Any+Registry.swift"; sourceTree = ""; }; - F41BA4121E79BDCA004F6E95 /* Google_Protobuf_Any+Extensions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Google_Protobuf_Any+Extensions.swift"; sourceTree = ""; }; - F41BA4171E79C568004F6E95 /* AnyUnpackError.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = AnyUnpackError.swift; sourceTree = ""; }; - F41BA43F1E7AE4AC004F6E95 /* any.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = any.pb.swift; sourceTree = ""; }; - F41BA4411E7AE53C004F6E95 /* AnyMessageStorage.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = AnyMessageStorage.swift; sourceTree = ""; }; - F430B11A262764D300C9EE2A /* fuzz_testing.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = fuzz_testing.pb.swift; sourceTree = ""; }; - F430B11B262764D300C9EE2A /* Test_FuzzTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_FuzzTests.swift; sourceTree = ""; }; - F44F936F1DAEA53900BC5B85 /* SwiftProtobuf.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = SwiftProtobuf.framework; sourceTree = BUILT_PRODUCTS_DIR; }; - F44F939F1DAEA7C500BC5B85 /* SwiftProtobufTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = SwiftProtobufTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; - F44F93FE1DAEB13F00BC5B85 /* SwiftProtobuf.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = SwiftProtobuf.framework; sourceTree = BUILT_PRODUCTS_DIR; }; - F44F94341DBF9AEA00BC5B85 /* Test_BasicFields_Access_Proto2.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_BasicFields_Access_Proto2.swift; sourceTree = ""; }; - F44F94381DBFBB6800BC5B85 /* Test_BasicFields_Access_Proto3.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_BasicFields_Access_Proto3.swift; sourceTree = ""; }; - F44F943D1DBFC2CF00BC5B85 /* Test_OneofFields_Access_Proto2.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_OneofFields_Access_Proto2.swift; sourceTree = ""; }; - F44F94411DBFE0BA00BC5B85 /* Test_OneofFields_Access_Proto3.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_OneofFields_Access_Proto3.swift; sourceTree = ""; }; - F44F94461DBFF17B00BC5B85 /* Test_MapFields_Access_Proto2.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_MapFields_Access_Proto2.swift; sourceTree = ""; }; - F44F944B1DBFF8D000BC5B85 /* Test_MapFields_Access_Proto3.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_MapFields_Access_Proto3.swift; sourceTree = ""; }; - F451074423A288E400488257 /* UnsafeRawPointer+Shims.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "UnsafeRawPointer+Shims.swift"; sourceTree = ""; }; - F451074523A288E400488257 /* UnsafeBufferPointer+Shims.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "UnsafeBufferPointer+Shims.swift"; sourceTree = ""; }; - F451075723A2B9B500488257 /* Data+TestHelpers.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "Data+TestHelpers.swift"; sourceTree = ""; }; - F4539D241E688B000076251F /* Test_GroupWithGroups.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_GroupWithGroups.swift; sourceTree = ""; }; - F4539D291E6F5DC70076251F /* CustomJSONCodable.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = CustomJSONCodable.swift; sourceTree = ""; }; - F4584D391ECA4FB400803AB6 /* unittest_swift_oneof_merging.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = unittest_swift_oneof_merging.pb.swift; sourceTree = ""; }; - F4584DB21EDDC9D400803AB6 /* Test_JSONDecodingOptions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_JSONDecodingOptions.swift; sourceTree = ""; }; - F4584DB71EDDCAD600803AB6 /* JSONDecodingOptions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JSONDecodingOptions.swift; sourceTree = ""; }; - F45D73FB1EE994C700E0A231 /* Test_MessageSet.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_MessageSet.swift; sourceTree = ""; }; - F4618B552154151700E5FABA /* JSONEncodingOptions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JSONEncodingOptions.swift; sourceTree = ""; }; - F4618B632154245500E5FABA /* Test_JSONEncodingOptions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_JSONEncodingOptions.swift; sourceTree = ""; }; - F47138951E4E56AC00C8492C /* Internal.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Internal.swift; sourceTree = ""; }; - F47C42B42437A3C700C08579 /* unittest_proto3_optional.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = unittest_proto3_optional.pb.swift; sourceTree = ""; }; - F47C42C12437A73000C08579 /* Test_AllTypes_Proto3_Optional.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_AllTypes_Proto3_Optional.swift; sourceTree = ""; }; - F47CF9A023E88DD000C7B24C /* unittest_swift_naming_number_prefix.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = unittest_swift_naming_number_prefix.pb.swift; sourceTree = ""; }; - F482B6771E856D1700A25EF8 /* unittest_swift_reserved_ext.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = unittest_swift_reserved_ext.pb.swift; sourceTree = ""; }; - F482B6911E857BBC00A25EF8 /* unittest_swift_naming_no_prefix.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = unittest_swift_naming_no_prefix.pb.swift; sourceTree = ""; }; - F482B6B21E89940E00A25EF8 /* Version.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Version.swift; sourceTree = ""; }; - F48769F723020B7D00D44224 /* descriptor.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = descriptor.pb.swift; sourceTree = ""; }; - F49B576A2252771700350FFD /* TextFormatEncodingOptions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TextFormatEncodingOptions.swift; sourceTree = ""; }; - F4A07B2A1E4A3E500035678A /* test_messages_proto3.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = test_messages_proto3.pb.swift; sourceTree = ""; }; - F4A1A8AB1E65E2EA0022E078 /* map_proto2_unittest.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = map_proto2_unittest.pb.swift; sourceTree = ""; }; - F4C3A96F1E969F79006BB610 /* unittest_swift_oneof_all_required.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = unittest_swift_oneof_all_required.pb.swift; sourceTree = ""; }; - F4CECDD1262A141B008B05BC /* TextFormatDecodingOptions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TextFormatDecodingOptions.swift; sourceTree = ""; }; - F4CECDDD262A1442008B05BC /* Test_TextFormatDecodingOptions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_TextFormatDecodingOptions.swift; sourceTree = ""; }; - F4D315431DEC8110005D4A80 /* unittest_swift_extension2.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = unittest_swift_extension2.pb.swift; sourceTree = ""; }; - F4D315441DEC8110005D4A80 /* unittest_swift_extension3.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = unittest_swift_extension3.pb.swift; sourceTree = ""; }; - F4D315521DECA0E5005D4A80 /* unittest_swift_extension4.pb.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = unittest_swift_extension4.pb.swift; sourceTree = ""; }; - F4E852B51EE9D83C00AE837E /* SelectiveVisitor.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SelectiveVisitor.swift; sourceTree = ""; }; - F4EDCC2A22DF896500A1ECB7 /* DoubleParser.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = DoubleParser.swift; sourceTree = ""; }; - F4F4F1161E5633E3006C6CAD /* Test_Naming.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Test_Naming.swift; sourceTree = ""; }; - __PBXFileRef_Package.swift /* Package.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Package.swift; sourceTree = ""; }; - __PBXFileRef_ProtobufTestSuite_Info.plist /* ProtobufTestSuite_Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; name = ProtobufTestSuite_Info.plist; path = SwiftProtobuf.xcodeproj/ProtobufTestSuite_Info.plist; sourceTree = SOURCE_ROOT; }; - __PBXFileRef_Protobuf_Info.plist /* Protobuf_Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; name = Protobuf_Info.plist; path = SwiftProtobuf.xcodeproj/Protobuf_Info.plist; sourceTree = SOURCE_ROOT; }; - __PBXFileRef_Sources/Protobuf/Google_Protobuf_Duration_Extensions.swift /* Google_Protobuf_Duration+Extensions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Google_Protobuf_Duration+Extensions.swift"; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/Google_Protobuf_FieldMask_Extensions.swift /* Google_Protobuf_FieldMask+Extensions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Google_Protobuf_FieldMask+Extensions.swift"; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/Google_Protobuf_Struct.swift /* Google_Protobuf_Struct+Extensions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Google_Protobuf_Struct+Extensions.swift"; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/Google_Protobuf_Timestamp_Extensions.swift /* Google_Protobuf_Timestamp+Extensions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Google_Protobuf_Timestamp+Extensions.swift"; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/ProtobufBinaryDecoding.swift /* BinaryDecoder.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BinaryDecoder.swift; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/ProtobufBinaryEncoding.swift /* BinaryEncoder.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BinaryEncoder.swift; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/ProtobufBinaryTypes.swift /* Message+BinaryAdditions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Message+BinaryAdditions.swift"; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/ProtobufEnum.swift /* Enum.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Enum.swift; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/ProtobufExtensionFields.swift /* ExtensionFields.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ExtensionFields.swift; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/ProtobufExtensions.swift /* MessageExtension.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MessageExtension.swift; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/ProtobufFieldDecoder.swift /* Decoder.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Decoder.swift; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/ProtobufHash.swift /* HashVisitor.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HashVisitor.swift; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/ProtobufJSONEncoding.swift /* JSONEncoder.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JSONEncoder.swift; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/ProtobufJSONTypes.swift /* Message+JSONAdditions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Message+JSONAdditions.swift"; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/ProtobufMessage.swift /* Message.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Message.swift; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/ProtobufTypes.swift /* FieldTypes.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FieldTypes.swift; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/ProtobufUnknown.swift /* UnknownStorage.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UnknownStorage.swift; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/api.pb.swift /* api.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = api.pb.swift; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/duration.pb.swift /* duration.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = duration.pb.swift; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/empty.pb.swift /* empty.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = empty.pb.swift; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/field_mask.pb.swift /* field_mask.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = field_mask.pb.swift; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/source_context.pb.swift /* source_context.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = source_context.pb.swift; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/timestamp.pb.swift /* timestamp.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = timestamp.pb.swift; sourceTree = ""; }; - __PBXFileRef_Sources/Protobuf/type.pb.swift /* type.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = type.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/TestHelpers.swift /* TestHelpers.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TestHelpers.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_AllTypes.swift /* Test_AllTypes.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_AllTypes.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_AllTypes_Proto3.swift /* Test_AllTypes_Proto3.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_AllTypes_Proto3.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_Any.swift /* Test_Any.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_Any.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_Api.swift /* Test_Api.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_Api.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_Conformance.swift /* Test_Conformance.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_Conformance.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_Duration.swift /* Test_Duration.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_Duration.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_Empty.swift /* Test_Empty.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_Empty.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_Enum.swift /* Test_Enum.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_Enum.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_Extensions.swift /* Test_Extensions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_Extensions.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_ExtremeDefaultValues.swift /* Test_ExtremeDefaultValues.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_ExtremeDefaultValues.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_FieldMask.swift /* Test_FieldMask.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_FieldMask.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_FieldOrdering.swift /* Test_FieldOrdering.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_FieldOrdering.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_JSON.swift /* Test_JSON.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_JSON.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_JSON_Conformance.swift /* Test_JSON_Conformance.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_JSON_Conformance.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_JSON_Group.swift /* Test_JSON_Group.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_JSON_Group.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_Map.swift /* Test_Map.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_Map.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_Map_JSON.swift /* Test_Map_JSON.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_Map_JSON.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_Packed.swift /* Test_Packed.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_Packed.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_ParsingMerge.swift /* Test_ParsingMerge.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_ParsingMerge.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_ReallyLargeTagNumber.swift /* Test_ReallyLargeTagNumber.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_ReallyLargeTagNumber.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_RecursiveMap.swift /* Test_RecursiveMap.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_RecursiveMap.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_Required.swift /* Test_Required.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_Required.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_Reserved.swift /* Test_Reserved.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_Reserved.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_Struct.swift /* Test_Struct.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_Struct.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_Timestamp.swift /* Test_Timestamp.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_Timestamp.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_Type.swift /* Test_Type.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_Type.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_Unknown_proto2.swift /* Test_Unknown_proto2.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_Unknown_proto2.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_Unknown_proto3.swift /* Test_Unknown_proto3.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_Unknown_proto3.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/Test_Wrappers.swift /* Test_Wrappers.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Test_Wrappers.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/any_test.pb.swift /* any_test.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = any_test.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/conformance.pb.swift /* conformance.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = conformance.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/map_unittest.pb.swift /* map_unittest.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = map_unittest.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest.pb.swift /* unittest.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_arena.pb.swift /* unittest_arena.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_arena.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_custom_options.pb.swift /* unittest_custom_options.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_custom_options.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_drop_unknown_fields.pb.swift /* unittest_drop_unknown_fields.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_drop_unknown_fields.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_embed_optimize_for.pb.swift /* unittest_embed_optimize_for.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_embed_optimize_for.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_empty.pb.swift /* unittest_empty.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_empty.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_import.pb.swift /* unittest_import.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_import.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_import_lite.pb.swift /* unittest_import_lite.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_import_lite.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_import_public.pb.swift /* unittest_import_public.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_import_public.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_import_public_lite.pb.swift /* unittest_import_public_lite.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_import_public_lite.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_lite.pb.swift /* unittest_lite.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_lite.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_lite_imports_nonlite.pb.swift /* unittest_lite_imports_nonlite.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_lite_imports_nonlite.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_mset.pb.swift /* unittest_mset.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_mset.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_mset_wire_format.pb.swift /* unittest_mset_wire_format.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_mset_wire_format.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_no_field_presence.pb.swift /* unittest_no_field_presence.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_no_field_presence.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_no_generic_services.pb.swift /* unittest_no_generic_services.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_no_generic_services.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_optimize_for.pb.swift /* unittest_optimize_for.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_optimize_for.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_preserve_unknown_enum.pb.swift /* unittest_preserve_unknown_enum.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_preserve_unknown_enum.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_preserve_unknown_enum2.pb.swift /* unittest_preserve_unknown_enum2.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_preserve_unknown_enum2.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_proto3.pb.swift /* unittest_proto3.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_proto3.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_proto3_arena.pb.swift /* unittest_proto3_arena.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_proto3_arena.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_swift_all_required_types.pb.swift /* unittest_swift_all_required_types.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_swift_all_required_types.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_swift_cycle.pb.swift /* unittest_swift_cycle.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_swift_cycle.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_swift_enum.pb.swift /* unittest_swift_enum.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_swift_enum.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_swift_enum_optional_default.pb.swift /* unittest_swift_enum_optional_default.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_swift_enum_optional_default.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_swift_extension.pb.swift /* unittest_swift_extension.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_swift_extension.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_swift_fieldorder.pb.swift /* unittest_swift_fieldorder.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_swift_fieldorder.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_swift_groups.pb.swift /* unittest_swift_groups.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_swift_groups.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_swift_naming.pb.swift /* unittest_swift_naming.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_swift_naming.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_swift_performance.pb.swift /* unittest_swift_performance.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_swift_performance.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_swift_reserved.pb.swift /* unittest_swift_reserved.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_swift_reserved.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_swift_runtime_proto2.pb.swift /* unittest_swift_runtime_proto2.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_swift_runtime_proto2.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_swift_runtime_proto3.pb.swift /* unittest_swift_runtime_proto3.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_swift_runtime_proto3.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_swift_startup.pb.swift /* unittest_swift_startup.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_swift_startup.pb.swift; sourceTree = ""; }; - __PBXFileRef_Tests/ProtobufTests/unittest_well_known_types.pb.swift /* unittest_well_known_types.pb.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = unittest_well_known_types.pb.swift; sourceTree = ""; }; - "_____Product_ProtobufTestSuite_iOS" /* SwiftProtobufTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = SwiftProtobufTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; - "_____Product_ProtobufTestSuite_macOS" /* SwiftProtobufTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; path = SwiftProtobufTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; - "_____Product_Protobuf_iOS" /* SwiftProtobuf.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = SwiftProtobuf.framework; sourceTree = BUILT_PRODUCTS_DIR; }; - "_____Product_Protobuf_macOS" /* SwiftProtobuf.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; path = SwiftProtobuf.framework; sourceTree = BUILT_PRODUCTS_DIR; }; -/* End PBXFileReference section */ - -/* Begin PBXFrameworksBuildPhase section */ - 9C8CDA0F1D7A288E00E207CA /* Frameworks */ = { - isa = PBXFrameworksBuildPhase; - buildActionMask = 2147483647; - files = ( - 9C8CDA171D7A288E00E207CA /* SwiftProtobuf.framework in Frameworks */, - ); - runOnlyForDeploymentPostprocessing = 0; - }; - F44F939C1DAEA7C500BC5B85 /* Frameworks */ = { - isa = PBXFrameworksBuildPhase; - buildActionMask = 2147483647; - files = ( - F44F93A41DAEA7C500BC5B85 /* SwiftProtobuf.framework in Frameworks */, - ); - runOnlyForDeploymentPostprocessing = 0; - }; - "___LinkPhase_ProtobufTestSuite" /* Frameworks */ = { - isa = PBXFrameworksBuildPhase; - buildActionMask = 0; - files = ( - _LinkFileRef_Protobuf_via_ProtobufTestSuite /* SwiftProtobuf.framework in Frameworks */, - ); - runOnlyForDeploymentPostprocessing = 0; - }; -/* End PBXFrameworksBuildPhase section */ - -/* Begin PBXGroup section */ - "___RootGroup_" = { - isa = PBXGroup; - children = ( - __PBXFileRef_Package.swift /* Package.swift */, - "_____Sources_" /* Sources */, - "_______Tests_" /* Tests */, - "_____Configs_" /* Resources */, - "____Products_" /* Products */, - ); - sourceTree = ""; - }; - "____Products_" /* Products */ = { - isa = PBXGroup; - children = ( - "_____Product_Protobuf_macOS" /* SwiftProtobuf.framework */, - "_____Product_ProtobufTestSuite_macOS" /* SwiftProtobufTests.xctest */, - "_____Product_Protobuf_iOS" /* SwiftProtobuf.framework */, - "_____Product_ProtobufTestSuite_iOS" /* SwiftProtobufTests.xctest */, - F44F936F1DAEA53900BC5B85 /* SwiftProtobuf.framework */, - F44F939F1DAEA7C500BC5B85 /* SwiftProtobufTests.xctest */, - F44F93FE1DAEB13F00BC5B85 /* SwiftProtobuf.framework */, - ); - name = Products; - sourceTree = ""; - }; - "_____Configs_" /* Resources */ = { - isa = PBXGroup; - children = ( - 5A82E3442455D26900EB0A70 /* Base.xcconfig */, - 5A82E34C2455D71400EB0A70 /* Base_Debug.xcconfig */, - 5A82E34D2455D71400EB0A70 /* Base_Release.xcconfig */, - 5A82E3482455D26900EB0A70 /* SwiftProtobuf_macOS.xcconfig */, - 5A82E3472455D26900EB0A70 /* SwiftProtobufTestSuite_macOS.xcconfig */, - 5A82E3462455D26900EB0A70 /* SwiftProtobuf_iOS.xcconfig */, - 5A82E34B2455D26900EB0A70 /* SwiftProtobufTestSuite_iOS.xcconfig */, - 5A82E3492455D26900EB0A70 /* SwiftProtobuf_tvOS.xcconfig */, - 5A82E34A2455D26900EB0A70 /* SwiftProtobufTestSuite_tvOS.xcconfig */, - 5A82E3452455D26900EB0A70 /* SwiftProtobuf_watchOS.xcconfig */, - __PBXFileRef_Protobuf_Info.plist /* Protobuf_Info.plist */, - __PBXFileRef_ProtobufTestSuite_Info.plist /* ProtobufTestSuite_Info.plist */, - ); - name = Resources; - sourceTree = ""; - }; - "_____Sources_" /* Sources */ = { - isa = PBXGroup; - children = ( - "_______Group_Protobuf" /* SwiftProtobuf */, - ); - name = Sources; - sourceTree = ""; - }; - "_______Group_Protobuf" /* SwiftProtobuf */ = { - isa = PBXGroup; - children = ( - F41BA43F1E7AE4AC004F6E95 /* any.pb.swift */, - F41BA4411E7AE53C004F6E95 /* AnyMessageStorage.swift */, - F41BA4171E79C568004F6E95 /* AnyUnpackError.swift */, - __PBXFileRef_Sources/Protobuf/api.pb.swift /* api.pb.swift */, - __PBXFileRef_Sources/Protobuf/ProtobufBinaryDecoding.swift /* BinaryDecoder.swift */, - 9C667A8F1E4C203D008B974F /* BinaryDecodingError.swift */, - F411FE941EDDD6AA001AE6B2 /* BinaryDecodingOptions.swift */, - F4151F701EFAB83400EEA00B /* BinaryDelimited.swift */, - __PBXFileRef_Sources/Protobuf/ProtobufBinaryEncoding.swift /* BinaryEncoder.swift */, - 9C84E48C1E5E3ABD00513BE0 /* BinaryEncodingError.swift */, - AA28A4AB1DA454DA00C866D9 /* BinaryEncodingSizeVisitor.swift */, - 9C75F8931DDD3D20005CCFF2 /* BinaryEncodingVisitor.swift */, - F4539D291E6F5DC70076251F /* CustomJSONCodable.swift */, - E7038A23224D7F1000B68775 /* Data+Extensions.swift */, - __PBXFileRef_Sources/Protobuf/ProtobufFieldDecoder.swift /* Decoder.swift */, - F48769F723020B7D00D44224 /* descriptor.pb.swift */, - F4EDCC2A22DF896500A1ECB7 /* DoubleParser.swift */, - __PBXFileRef_Sources/Protobuf/duration.pb.swift /* duration.pb.swift */, - __PBXFileRef_Sources/Protobuf/empty.pb.swift /* empty.pb.swift */, - __PBXFileRef_Sources/Protobuf/ProtobufEnum.swift /* Enum.swift */, - 9C75F88E1DDD3108005CCFF2 /* ExtensibleMessage.swift */, - __PBXFileRef_Sources/Protobuf/ProtobufExtensionFields.swift /* ExtensionFields.swift */, - 9C75F8891DDD30A5005CCFF2 /* ExtensionFieldValueSet.swift */, - 9C4178601E809DA2007830C3 /* ExtensionMap.swift */, - __PBXFileRef_Sources/Protobuf/field_mask.pb.swift /* field_mask.pb.swift */, - AA05BF4E1DAEB7E800619042 /* FieldTag.swift */, - __PBXFileRef_Sources/Protobuf/ProtobufTypes.swift /* FieldTypes.swift */, - F41BA4121E79BDCA004F6E95 /* Google_Protobuf_Any+Extensions.swift */, - F41BA3FB1E76F635004F6E95 /* Google_Protobuf_Any+Registry.swift */, - __PBXFileRef_Sources/Protobuf/Google_Protobuf_Duration_Extensions.swift /* Google_Protobuf_Duration+Extensions.swift */, - __PBXFileRef_Sources/Protobuf/Google_Protobuf_FieldMask_Extensions.swift /* Google_Protobuf_FieldMask+Extensions.swift */, - AAB979F41E7066D8003DC2F4 /* Google_Protobuf_ListValue+Extensions.swift */, - 9CE4C56724EF34F200471257 /* Google_Protobuf_NullValue+Extensions.swift */, - __PBXFileRef_Sources/Protobuf/Google_Protobuf_Struct.swift /* Google_Protobuf_Struct+Extensions.swift */, - __PBXFileRef_Sources/Protobuf/Google_Protobuf_Timestamp_Extensions.swift /* Google_Protobuf_Timestamp+Extensions.swift */, - AAE0F4E21E6F5CB9005240E0 /* Google_Protobuf_Value+Extensions.swift */, - AAEA52711DA80DD4003F318F /* Google_Protobuf_Wrappers+Extensions.swift */, - __PBXFileRef_Sources/Protobuf/ProtobufHash.swift /* HashVisitor.swift */, - F47138951E4E56AC00C8492C /* Internal.swift */, - 9C75F89D1DDD3FA3005CCFF2 /* JSONDecoder.swift */, - 9C667A8E1E4C203D008B974F /* JSONDecodingError.swift */, - F4584DB71EDDCAD600803AB6 /* JSONDecodingOptions.swift */, - __PBXFileRef_Sources/Protobuf/ProtobufJSONEncoding.swift /* JSONEncoder.swift */, - 9C84E48D1E5E3ABD00513BE0 /* JSONEncodingError.swift */, - F4618B552154151700E5FABA /* JSONEncodingOptions.swift */, - AA86F6F91E0A0F0B006CC38A /* JSONEncodingVisitor.swift */, - 9C0B366A1E5FAB910094E128 /* JSONMapEncodingVisitor.swift */, - 9CE9CF361E32C9F8004FBED6 /* JSONScanner.swift */, - 8DC1CA0C1E54B80800CA8A26 /* MathUtils.swift */, - __PBXFileRef_Sources/Protobuf/ProtobufMessage.swift /* Message.swift */, - AA78AD351E84C5B4001C43F9 /* Message+AnyAdditions.swift */, - __PBXFileRef_Sources/Protobuf/ProtobufBinaryTypes.swift /* Message+BinaryAdditions.swift */, - __PBXFileRef_Sources/Protobuf/ProtobufJSONTypes.swift /* Message+JSONAdditions.swift */, - DB2E0AFD1EB25D1D00F59319 /* Message+JSONArrayAdditions.swift */, - BCCA0E681DB1210E00957D74 /* Message+TextFormatAdditions.swift */, - __PBXFileRef_Sources/Protobuf/ProtobufExtensions.swift /* MessageExtension.swift */, - AAF2ED391DEF3FBC007B510F /* NameMap.swift */, - AAABA40A1E4A42CD00365CDF /* ProtobufAPIVersionCheck.swift */, - 9C75F8A21DDD44A1005CCFF2 /* ProtobufMap.swift */, - AAF2ED3E1DEF4D94007B510F /* ProtoNameProviding.swift */, - F4E852B51EE9D83C00AE837E /* SelectiveVisitor.swift */, - 9C75F8841DDD3045005CCFF2 /* SimpleExtensionMap.swift */, - __PBXFileRef_Sources/Protobuf/source_context.pb.swift /* source_context.pb.swift */, - 9CA424411E286D4E00C0E5B4 /* StringUtils.swift */, - AA3640901E60D043000C3CF4 /* struct.pb.swift */, - BCCA0E661DB1210E00957D74 /* TextFormatDecoder.swift */, - 9C667A901E4C203D008B974F /* TextFormatDecodingError.swift */, - F4CECDD1262A141B008B05BC /* TextFormatDecodingOptions.swift */, - BCCA0E671DB1210E00957D74 /* TextFormatEncoder.swift */, - F49B576A2252771700350FFD /* TextFormatEncodingOptions.swift */, - 9CEB0D671DF5E934002D80F0 /* TextFormatEncodingVisitor.swift */, - 9CEB0D6B1DF5F921002D80F0 /* TextFormatScanner.swift */, - __PBXFileRef_Sources/Protobuf/timestamp.pb.swift /* timestamp.pb.swift */, - 8DC1CA0E1E54B81400CA8A26 /* TimeUtils.swift */, - __PBXFileRef_Sources/Protobuf/type.pb.swift /* type.pb.swift */, - __PBXFileRef_Sources/Protobuf/ProtobufUnknown.swift /* UnknownStorage.swift */, - F451074523A288E400488257 /* UnsafeBufferPointer+Shims.swift */, - F451074423A288E400488257 /* UnsafeRawPointer+Shims.swift */, - AA28A4A81DA40B0900C866D9 /* Varint.swift */, - F482B6B21E89940E00A25EF8 /* Version.swift */, - 9C75F87F1DDBE0DE005CCFF2 /* Visitor.swift */, - AA05BF491DAEB7E400619042 /* WireFormat.swift */, - AAEA52731DA80DEA003F318F /* wrappers.pb.swift */, - AA28A4A51DA30E5900C866D9 /* ZigZag.swift */, - ); - name = SwiftProtobuf; - path = Sources/SwiftProtobuf; - sourceTree = ""; - }; - "_______Group_ProtobufTestSuite" /* SwiftProtobufTests */ = { - isa = PBXGroup; - children = ( - __PBXFileRef_Tests/ProtobufTests/any_test.pb.swift /* any_test.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/conformance.pb.swift /* conformance.pb.swift */, - F451075723A2B9B500488257 /* Data+TestHelpers.swift */, - F430B11A262764D300C9EE2A /* fuzz_testing.pb.swift */, - 9CC8CAA81EC512A0008EF45F /* generated_swift_names_enum_cases.pb.swift */, - 9CC8CAA91EC512A0008EF45F /* generated_swift_names_enums.pb.swift */, - 9CC8CAAA1EC512A0008EF45F /* generated_swift_names_fields.pb.swift */, - 9CC8CAAB1EC512A0008EF45F /* generated_swift_names_messages.pb.swift */, - F4A1A8AB1E65E2EA0022E078 /* map_proto2_unittest.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/map_unittest.pb.swift /* map_unittest.pb.swift */, - AAEA521F1DA5BB81003F318F /* Message+UInt8ArrayHelpers.swift */, - F47C42C12437A73000C08579 /* Test_AllTypes_Proto3_Optional.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_AllTypes_Proto3.swift /* Test_AllTypes_Proto3.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_AllTypes.swift /* Test_AllTypes.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_Any.swift /* Test_Any.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_Api.swift /* Test_Api.swift */, - F44F94341DBF9AEA00BC5B85 /* Test_BasicFields_Access_Proto2.swift */, - F44F94381DBFBB6800BC5B85 /* Test_BasicFields_Access_Proto3.swift */, - F411FEAA1EDDDC5D001AE6B2 /* Test_BinaryDecodingOptions.swift */, - F4151F751EFAD85600EEA00B /* Test_BinaryDelimited.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_Conformance.swift /* Test_Conformance.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_Duration.swift /* Test_Duration.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_Empty.swift /* Test_Empty.swift */, - AA6CF6F01DB6D1F8007DF26B /* Test_Enum_Proto2.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_Enum.swift /* Test_Enum.swift */, - AAE0F4DE1E6A3886005240E0 /* Test_EnumWithAliases.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_Extensions.swift /* Test_Extensions.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_ExtremeDefaultValues.swift /* Test_ExtremeDefaultValues.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_FieldMask.swift /* Test_FieldMask.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_FieldOrdering.swift /* Test_FieldOrdering.swift */, - F430B11B262764D300C9EE2A /* Test_FuzzTests.swift */, - F4539D241E688B000076251F /* Test_GroupWithGroups.swift */, - DB2E0AF91EB24C7600F59319 /* Test_JSON_Array.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_JSON_Conformance.swift /* Test_JSON_Conformance.swift */, - 6583D6E3246E04A200353AF4 /* Test_JSON_Extensions.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_JSON_Group.swift /* Test_JSON_Group.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_JSON.swift /* Test_JSON.swift */, - F4584DB21EDDC9D400803AB6 /* Test_JSONDecodingOptions.swift */, - F4618B632154245500E5FABA /* Test_JSONEncodingOptions.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_Map_JSON.swift /* Test_Map_JSON.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_Map.swift /* Test_Map.swift */, - F44F94461DBFF17B00BC5B85 /* Test_MapFields_Access_Proto2.swift */, - F44F944B1DBFF8D000BC5B85 /* Test_MapFields_Access_Proto3.swift */, - AA3640951E60EBB0000C3CF4 /* Test_Merge.swift */, - F4A07B2A1E4A3E500035678A /* test_messages_proto3.pb.swift */, - F45D73FB1EE994C700E0A231 /* Test_MessageSet.swift */, - F4F4F1161E5633E3006C6CAD /* Test_Naming.swift */, - F44F943D1DBFC2CF00BC5B85 /* Test_OneofFields_Access_Proto2.swift */, - F44F94411DBFE0BA00BC5B85 /* Test_OneofFields_Access_Proto3.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_Packed.swift /* Test_Packed.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_ParsingMerge.swift /* Test_ParsingMerge.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_ReallyLargeTagNumber.swift /* Test_ReallyLargeTagNumber.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_RecursiveMap.swift /* Test_RecursiveMap.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_Required.swift /* Test_Required.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_Reserved.swift /* Test_Reserved.swift */, - F4151F641EF3193F00EEA00B /* Test_SimpleExtensionMap.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_Struct.swift /* Test_Struct.swift */, - F4CECDDD262A1442008B05BC /* Test_TextFormatDecodingOptions.swift */, - 9C60CBE71DF8AC3F00F7B14E /* Test_TextFormat_Map_proto3.swift */, - 9C5890A51DFF5EC8001CFC34 /* Test_TextFormat_proto2_extensions.swift */, - 9C60CBEB1DF9DEEA00F7B14E /* Test_TextFormat_proto2.swift */, - BCCA0E751DB123F800957D74 /* Test_TextFormat_proto3.swift */, - 9C7254651E5F9B1600486C98 /* Test_TextFormat_Unknown.swift */, - 9CCD5F921E008203002D1940 /* Test_TextFormat_WKT_proto3.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_Timestamp.swift /* Test_Timestamp.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_Type.swift /* Test_Type.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_Unknown_proto2.swift /* Test_Unknown_proto2.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_Unknown_proto3.swift /* Test_Unknown_proto3.swift */, - __PBXFileRef_Tests/ProtobufTests/Test_Wrappers.swift /* Test_Wrappers.swift */, - __PBXFileRef_Tests/ProtobufTests/TestHelpers.swift /* TestHelpers.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_arena.pb.swift /* unittest_arena.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_custom_options.pb.swift /* unittest_custom_options.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_drop_unknown_fields.pb.swift /* unittest_drop_unknown_fields.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_embed_optimize_for.pb.swift /* unittest_embed_optimize_for.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_empty.pb.swift /* unittest_empty.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_import_lite.pb.swift /* unittest_import_lite.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_import_public_lite.pb.swift /* unittest_import_public_lite.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_import_public.pb.swift /* unittest_import_public.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_import.pb.swift /* unittest_import.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_lite_imports_nonlite.pb.swift /* unittest_lite_imports_nonlite.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_lite.pb.swift /* unittest_lite.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_mset_wire_format.pb.swift /* unittest_mset_wire_format.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_mset.pb.swift /* unittest_mset.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_no_field_presence.pb.swift /* unittest_no_field_presence.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_no_generic_services.pb.swift /* unittest_no_generic_services.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_optimize_for.pb.swift /* unittest_optimize_for.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_preserve_unknown_enum.pb.swift /* unittest_preserve_unknown_enum.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_preserve_unknown_enum2.pb.swift /* unittest_preserve_unknown_enum2.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_proto3_arena.pb.swift /* unittest_proto3_arena.pb.swift */, - F47C42B42437A3C700C08579 /* unittest_proto3_optional.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_proto3.pb.swift /* unittest_proto3.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_swift_all_required_types.pb.swift /* unittest_swift_all_required_types.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_swift_cycle.pb.swift /* unittest_swift_cycle.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_swift_enum_optional_default.pb.swift /* unittest_swift_enum_optional_default.pb.swift */, - F40D33E82017ECD300ABAF0F /* unittest_swift_enum_proto3.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_swift_enum.pb.swift /* unittest_swift_enum.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_swift_extension.pb.swift /* unittest_swift_extension.pb.swift */, - F4D315431DEC8110005D4A80 /* unittest_swift_extension2.pb.swift */, - F4D315441DEC8110005D4A80 /* unittest_swift_extension3.pb.swift */, - F4D315521DECA0E5005D4A80 /* unittest_swift_extension4.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_swift_fieldorder.pb.swift /* unittest_swift_fieldorder.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_swift_groups.pb.swift /* unittest_swift_groups.pb.swift */, - 8037FC942507E4F4003B7FAC /* unittest_swift_json.pb.swift */, - F482B6911E857BBC00A25EF8 /* unittest_swift_naming_no_prefix.pb.swift */, - F47CF9A023E88DD000C7B24C /* unittest_swift_naming_number_prefix.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_swift_naming.pb.swift /* unittest_swift_naming.pb.swift */, - F4C3A96F1E969F79006BB610 /* unittest_swift_oneof_all_required.pb.swift */, - F4584D391ECA4FB400803AB6 /* unittest_swift_oneof_merging.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_swift_performance.pb.swift /* unittest_swift_performance.pb.swift */, - F482B6771E856D1700A25EF8 /* unittest_swift_reserved_ext.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_swift_reserved.pb.swift /* unittest_swift_reserved.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_swift_runtime_proto2.pb.swift /* unittest_swift_runtime_proto2.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_swift_runtime_proto3.pb.swift /* unittest_swift_runtime_proto3.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_swift_startup.pb.swift /* unittest_swift_startup.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest_well_known_types.pb.swift /* unittest_well_known_types.pb.swift */, - __PBXFileRef_Tests/ProtobufTests/unittest.pb.swift /* unittest.pb.swift */, - ); - name = SwiftProtobufTests; - path = Tests/SwiftProtobufTests; - sourceTree = ""; - }; - "_______Tests_" /* Tests */ = { - isa = PBXGroup; - children = ( - "_______Group_ProtobufTestSuite" /* SwiftProtobufTests */, - ); - name = Tests; - sourceTree = ""; - }; -/* End PBXGroup section */ - -/* Begin PBXNativeTarget section */ - 9C8CDA111D7A288E00E207CA /* SwiftProtobufTestSuite_iOS */ = { - isa = PBXNativeTarget; - buildConfigurationList = 9C8CDA1A1D7A288E00E207CA /* Build configuration list for PBXNativeTarget "SwiftProtobufTestSuite_iOS" */; - buildPhases = ( - 9C8CDA0E1D7A288E00E207CA /* Sources */, - 9C8CDA0F1D7A288E00E207CA /* Frameworks */, - ); - buildRules = ( - ); - dependencies = ( - 9C8CDA191D7A288E00E207CA /* PBXTargetDependency */, - ); - name = SwiftProtobufTestSuite_iOS; - productName = ProtobufTestSuite_iOS; - productReference = "_____Product_ProtobufTestSuite_iOS" /* SwiftProtobufTests.xctest */; - productType = "com.apple.product-type.bundle.unit-test"; - }; - BD12FD351D767BA0001815C7 /* SwiftProtobuf_iOS */ = { - isa = PBXNativeTarget; - buildConfigurationList = BD12FD3D1D767BA1001815C7 /* Build configuration list for PBXNativeTarget "SwiftProtobuf_iOS" */; - buildPhases = ( - BD12FD311D767BA0001815C7 /* Sources */, - ); - buildRules = ( - ); - dependencies = ( - ); - name = SwiftProtobuf_iOS; - productName = Protobuf_iOS; - productReference = "_____Product_Protobuf_iOS" /* SwiftProtobuf.framework */; - productType = "com.apple.product-type.framework"; - }; - F44F936E1DAEA53900BC5B85 /* SwiftProtobuf_tvOS */ = { - isa = PBXNativeTarget; - buildConfigurationList = F44F93761DAEA53900BC5B85 /* Build configuration list for PBXNativeTarget "SwiftProtobuf_tvOS" */; - buildPhases = ( - F44F936A1DAEA53900BC5B85 /* Sources */, - ); - buildRules = ( - ); - dependencies = ( - ); - name = SwiftProtobuf_tvOS; - productName = SwiftProtobuf_tvOS; - productReference = F44F936F1DAEA53900BC5B85 /* SwiftProtobuf.framework */; - productType = "com.apple.product-type.framework"; - }; - F44F939E1DAEA7C500BC5B85 /* SwiftProtobufTestSuite_tvOS */ = { - isa = PBXNativeTarget; - buildConfigurationList = F44F93A71DAEA7C500BC5B85 /* Build configuration list for PBXNativeTarget "SwiftProtobufTestSuite_tvOS" */; - buildPhases = ( - F44F939B1DAEA7C500BC5B85 /* Sources */, - F44F939C1DAEA7C500BC5B85 /* Frameworks */, - ); - buildRules = ( - ); - dependencies = ( - F44F93A61DAEA7C500BC5B85 /* PBXTargetDependency */, - ); - name = SwiftProtobufTestSuite_tvOS; - productName = SwiftProtobufTestSuite_tvOS; - productReference = F44F939F1DAEA7C500BC5B85 /* SwiftProtobufTests.xctest */; - productType = "com.apple.product-type.bundle.unit-test"; - }; - F44F93FD1DAEB13F00BC5B85 /* SwiftProtobuf_watchOS */ = { - isa = PBXNativeTarget; - buildConfigurationList = F44F94051DAEB13F00BC5B85 /* Build configuration list for PBXNativeTarget "SwiftProtobuf_watchOS" */; - buildPhases = ( - F44F93F91DAEB13F00BC5B85 /* Sources */, - ); - buildRules = ( - ); - dependencies = ( - ); - name = SwiftProtobuf_watchOS; - productName = SwiftProtobuf_watchOS; - productReference = F44F93FE1DAEB13F00BC5B85 /* SwiftProtobuf.framework */; - productType = "com.apple.product-type.framework"; - }; - "______Target_Protobuf" /* SwiftProtobuf_macOS */ = { - isa = PBXNativeTarget; - buildConfigurationList = "_______Confs_Protobuf" /* Build configuration list for PBXNativeTarget "SwiftProtobuf_macOS" */; - buildPhases = ( - CompilePhase_Protobuf /* Sources */, - ); - buildRules = ( - ); - dependencies = ( - ); - name = SwiftProtobuf_macOS; - productName = Protobuf; - productReference = "_____Product_Protobuf_macOS" /* SwiftProtobuf.framework */; - productType = "com.apple.product-type.framework"; - }; - "______Target_ProtobufTestSuite" /* SwiftProtobufTestSuite_macOS */ = { - isa = PBXNativeTarget; - buildConfigurationList = "_______Confs_ProtobufTestSuite" /* Build configuration list for PBXNativeTarget "SwiftProtobufTestSuite_macOS" */; - buildPhases = ( - CompilePhase_ProtobufTestSuite /* Sources */, - "___LinkPhase_ProtobufTestSuite" /* Frameworks */, - ); - buildRules = ( - ); - dependencies = ( - __Dependency_Protobuf /* PBXTargetDependency */, - ); - name = SwiftProtobufTestSuite_macOS; - productName = ProtobufTestSuite; - productReference = "_____Product_ProtobufTestSuite_macOS" /* SwiftProtobufTests.xctest */; - productType = "com.apple.product-type.bundle.unit-test"; - }; -/* End PBXNativeTarget section */ - -/* Begin PBXProject section */ - __RootObject_ /* Project object */ = { - isa = PBXProject; - attributes = { - LastSwiftUpdateCheck = 0800; - LastUpgradeCheck = 1320; - TargetAttributes = { - 9C8CDA111D7A288E00E207CA = { - CreatedOnToolsVersion = 8.0; - ProvisioningStyle = Automatic; - }; - BD12FD351D767BA0001815C7 = { - CreatedOnToolsVersion = 8.0; - ProvisioningStyle = Manual; - }; - F44F936E1DAEA53900BC5B85 = { - CreatedOnToolsVersion = 8.0; - ProvisioningStyle = Manual; - }; - F44F939E1DAEA7C500BC5B85 = { - CreatedOnToolsVersion = 8.0; - ProvisioningStyle = Automatic; - }; - F44F93FD1DAEB13F00BC5B85 = { - CreatedOnToolsVersion = 8.0; - ProvisioningStyle = Manual; - }; - "______Target_Protobuf" = { - LastSwiftMigration = 1010; - }; - "______Target_ProtobufTestSuite" = { - LastSwiftMigration = 1010; - }; - }; - }; - buildConfigurationList = "___RootConfs_" /* Build configuration list for PBXProject "SwiftProtobuf" */; - compatibilityVersion = "Xcode 3.2"; - developmentRegion = en; - hasScannedForEncodings = 0; - knownRegions = ( - en, - ); - mainGroup = "___RootGroup_"; - productRefGroup = "____Products_" /* Products */; - projectDirPath = ""; - projectRoot = ""; - targets = ( - "______Target_Protobuf" /* SwiftProtobuf_macOS */, - "______Target_ProtobufTestSuite" /* SwiftProtobufTestSuite_macOS */, - BD12FD351D767BA0001815C7 /* SwiftProtobuf_iOS */, - 9C8CDA111D7A288E00E207CA /* SwiftProtobufTestSuite_iOS */, - F44F936E1DAEA53900BC5B85 /* SwiftProtobuf_tvOS */, - F44F939E1DAEA7C500BC5B85 /* SwiftProtobufTestSuite_tvOS */, - F44F93FD1DAEB13F00BC5B85 /* SwiftProtobuf_watchOS */, - ); - }; -/* End PBXProject section */ - -/* Begin PBXSourcesBuildPhase section */ - 9C8CDA0E1D7A288E00E207CA /* Sources */ = { - isa = PBXSourcesBuildPhase; - buildActionMask = 2147483647; - files = ( - F4151F671EF3197200EEA00B /* Test_SimpleExtensionMap.swift in Sources */, - F4CECDDF262A1442008B05BC /* Test_TextFormatDecodingOptions.swift in Sources */, - F47CF9A223E88DD000C7B24C /* unittest_swift_naming_number_prefix.pb.swift in Sources */, - 9C8CDA1D1D7A28F600E207CA /* any_test.pb.swift in Sources */, - 8037FC962507E4F4003B7FAC /* unittest_swift_json.pb.swift in Sources */, - F40D33EB2017ED2200ABAF0F /* unittest_swift_enum_proto3.pb.swift in Sources */, - 9C8CDA1E1D7A28F600E207CA /* conformance.pb.swift in Sources */, - 9C8CDA211D7A28F600E207CA /* map_unittest.pb.swift in Sources */, - AAEA52211DA5BB81003F318F /* Message+UInt8ArrayHelpers.swift in Sources */, - AAE0F4E01E6A3886005240E0 /* Test_EnumWithAliases.swift in Sources */, - F4C3A9721E96A08F006BB610 /* unittest_swift_oneof_all_required.pb.swift in Sources */, - 9C8CDA201D7A28F600E207CA /* TestHelpers.swift in Sources */, - 9C8CDA231D7A28F600E207CA /* Test_AllTypes.swift in Sources */, - 9CCD5F941E008203002D1940 /* Test_TextFormat_WKT_proto3.swift in Sources */, - F482B6941E857BC100A25EF8 /* unittest_swift_naming_no_prefix.pb.swift in Sources */, - 9C8CDA241D7A28F600E207CA /* Test_AllTypes_Proto3.swift in Sources */, - 9C8CDA251D7A28F600E207CA /* Test_Any.swift in Sources */, - 9C8CDA261D7A28F600E207CA /* Test_Api.swift in Sources */, - F44F94361DBF9AEA00BC5B85 /* Test_BasicFields_Access_Proto2.swift in Sources */, - 9CC8CAB31EC512A0008EF45F /* generated_swift_names_fields.pb.swift in Sources */, - F44F943B1DBFBB7500BC5B85 /* Test_BasicFields_Access_Proto3.swift in Sources */, - F4151F781EFAD85B00EEA00B /* Test_BinaryDelimited.swift in Sources */, - 6583D6E5246E04A200353AF4 /* Test_JSON_Extensions.swift in Sources */, - 9C8CDA271D7A28F600E207CA /* Test_Conformance.swift in Sources */, - 9C8CDA291D7A28F600E207CA /* Test_Duration.swift in Sources */, - 9C8CDA2A1D7A28F600E207CA /* Test_Empty.swift in Sources */, - AA6CF6F61DB6D228007DF26B /* Test_Enum_Proto2.swift in Sources */, - 9C8CDA2B1D7A28F600E207CA /* Test_Enum.swift in Sources */, - 9C8CDA2C1D7A28F600E207CA /* Test_Extensions.swift in Sources */, - 9C8CDA2D1D7A28F600E207CA /* Test_ExtremeDefaultValues.swift in Sources */, - 9C8CDA2E1D7A28F600E207CA /* Test_FieldMask.swift in Sources */, - 9C8CDA2F1D7A28F600E207CA /* Test_FieldOrdering.swift in Sources */, - 9C8CDA301D7A28F600E207CA /* Test_JSON.swift in Sources */, - 9C8CDA311D7A28F600E207CA /* Test_JSON_Conformance.swift in Sources */, - 9CC8CAB01EC512A0008EF45F /* generated_swift_names_enums.pb.swift in Sources */, - F4A1A8AE1E65E2F00022E078 /* map_proto2_unittest.pb.swift in Sources */, - 9C8CDA321D7A28F600E207CA /* Test_JSON_Group.swift in Sources */, - 9C8CDA341D7A28F600E207CA /* Test_Map.swift in Sources */, - F44F94491DBFF18000BC5B85 /* Test_MapFields_Access_Proto2.swift in Sources */, - F44F944E1DBFF8DC00BC5B85 /* Test_MapFields_Access_Proto3.swift in Sources */, - 9C8CDA351D7A28F600E207CA /* Test_Map_JSON.swift in Sources */, - F4F4F1191E5633E8006C6CAD /* Test_Naming.swift in Sources */, - F4584DB51EDDCA8800803AB6 /* Test_JSONDecodingOptions.swift in Sources */, - 9CC8CAB61EC512A0008EF45F /* generated_swift_names_messages.pb.swift in Sources */, - F44F943F1DBFC2CF00BC5B85 /* Test_OneofFields_Access_Proto2.swift in Sources */, - F44F94441DBFE0BF00BC5B85 /* Test_OneofFields_Access_Proto3.swift in Sources */, - 9C8CDA361D7A28F600E207CA /* Test_Packed.swift in Sources */, - F451075923A2B9B500488257 /* Data+TestHelpers.swift in Sources */, - F4539D271E688B040076251F /* Test_GroupWithGroups.swift in Sources */, - 9C8CDA371D7A28F600E207CA /* Test_ParsingMerge.swift in Sources */, - 9C60CBED1DF9DEEA00F7B14E /* Test_TextFormat_proto2.swift in Sources */, - 9C8CDA391D7A28F600E207CA /* Test_ReallyLargeTagNumber.swift in Sources */, - F430B120262764D400C9EE2A /* Test_FuzzTests.swift in Sources */, - 9C8CDA3A1D7A28F600E207CA /* Test_RecursiveMap.swift in Sources */, - 9C60CBE91DF8AC3F00F7B14E /* Test_TextFormat_Map_proto3.swift in Sources */, - 9C8CDA3B1D7A28F600E207CA /* Test_Required.swift in Sources */, - 9C8CDA3C1D7A28F600E207CA /* Test_Reserved.swift in Sources */, - 9C8CDA3D1D7A28F600E207CA /* Test_Struct.swift in Sources */, - 9C8CDA3E1D7A28F600E207CA /* Test_Timestamp.swift in Sources */, - 9C8CDA3F1D7A28F600E207CA /* Test_Type.swift in Sources */, - DB2E0AFB1EB24C7600F59319 /* Test_JSON_Array.swift in Sources */, - F48FDD281E4D18060061D5C1 /* Test_TextFormat_proto3.swift in Sources */, - 9C8CDA401D7A28F600E207CA /* Test_Unknown_proto2.swift in Sources */, - 9C8CDA411D7A28F600E207CA /* Test_Unknown_proto3.swift in Sources */, - 9C8CDA421D7A28F600E207CA /* Test_Wrappers.swift in Sources */, - 9C8CDA431D7A28F600E207CA /* unittest.pb.swift in Sources */, - 9C8CDA441D7A28F600E207CA /* unittest_arena.pb.swift in Sources */, - F48FDD271E4D18060061D5C1 /* Test_TextFormat_proto2_extensions.swift in Sources */, - F430B11D262764D400C9EE2A /* fuzz_testing.pb.swift in Sources */, - 9C8CDA451D7A28F600E207CA /* unittest_custom_options.pb.swift in Sources */, - 9C8CDA461D7A28F600E207CA /* unittest_drop_unknown_fields.pb.swift in Sources */, - 9C8CDA471D7A28F600E207CA /* unittest_embed_optimize_for.pb.swift in Sources */, - 9C8CDA481D7A28F600E207CA /* unittest_empty.pb.swift in Sources */, - F411FEAD1EDDDC61001AE6B2 /* Test_BinaryDecodingOptions.swift in Sources */, - 9C8CDA491D7A28F600E207CA /* unittest_import.pb.swift in Sources */, - 9C8CDA4A1D7A28F600E207CA /* unittest_import_lite.pb.swift in Sources */, - AA3640971E60EBB0000C3CF4 /* Test_Merge.swift in Sources */, - F45D73FE1EE9984B00E0A231 /* Test_MessageSet.swift in Sources */, - 9C8CDA4C1D7A28F600E207CA /* unittest_import_public.pb.swift in Sources */, - 9C8CDA4D1D7A28F600E207CA /* unittest_import_public_lite.pb.swift in Sources */, - 9C8CDA4F1D7A28F600E207CA /* unittest_lite.pb.swift in Sources */, - 9C8CDA501D7A28F600E207CA /* unittest_lite_imports_nonlite.pb.swift in Sources */, - 9C8CDA511D7A28F600E207CA /* unittest_mset.pb.swift in Sources */, - F4D3154A1DEC811B005D4A80 /* unittest_swift_extension3.pb.swift in Sources */, - F4584D3C1ECA4FC700803AB6 /* unittest_swift_oneof_merging.pb.swift in Sources */, - 9C8CDA641D7A28F600E207CA /* unittest_swift_naming.pb.swift in Sources */, - F4A07B2D1E4A3E630035678A /* test_messages_proto3.pb.swift in Sources */, - 9C8CDA521D7A28F600E207CA /* unittest_mset_wire_format.pb.swift in Sources */, - F47C42B62437A3C700C08579 /* unittest_proto3_optional.pb.swift in Sources */, - 9C8CDA561D7A28F600E207CA /* unittest_no_field_presence.pb.swift in Sources */, - F47C42C32437A73000C08579 /* Test_AllTypes_Proto3_Optional.swift in Sources */, - 9C8CDA571D7A28F600E207CA /* unittest_no_generic_services.pb.swift in Sources */, - 9C8CDA581D7A28F600E207CA /* unittest_optimize_for.pb.swift in Sources */, - 9C8CDA591D7A28F600E207CA /* unittest_preserve_unknown_enum.pb.swift in Sources */, - 9C8CDA5A1D7A28F600E207CA /* unittest_preserve_unknown_enum2.pb.swift in Sources */, - 9C8CDA5C1D7A28F600E207CA /* unittest_proto3_arena.pb.swift in Sources */, - 9C8CDA5B1D7A28F600E207CA /* unittest_proto3.pb.swift in Sources */, - 9C8CDA5D1D7A28F600E207CA /* unittest_swift_all_required_types.pb.swift in Sources */, - 9C8CDA5E1D7A28F600E207CA /* unittest_swift_cycle.pb.swift in Sources */, - 9C7254671E5F9B1600486C98 /* Test_TextFormat_Unknown.swift in Sources */, - 9C8CDA611D7A28F600E207CA /* unittest_swift_extension.pb.swift in Sources */, - F4D315491DEC811B005D4A80 /* unittest_swift_extension2.pb.swift in Sources */, - F4D315551DECA0EA005D4A80 /* unittest_swift_extension4.pb.swift in Sources */, - 9C8CDA5F1D7A28F600E207CA /* unittest_swift_enum.pb.swift in Sources */, - 9C8CDA601D7A28F600E207CA /* unittest_swift_enum_optional_default.pb.swift in Sources */, - 9C8CDA621D7A28F600E207CA /* unittest_swift_fieldorder.pb.swift in Sources */, - 9C8CDA631D7A28F600E207CA /* unittest_swift_groups.pb.swift in Sources */, - 9C8CDA651D7A28F600E207CA /* unittest_swift_performance.pb.swift in Sources */, - F4618B652154245600E5FABA /* Test_JSONEncodingOptions.swift in Sources */, - 9C8CDA661D7A28F600E207CA /* unittest_swift_reserved.pb.swift in Sources */, - F482B67A1E856D2700A25EF8 /* unittest_swift_reserved_ext.pb.swift in Sources */, - 9C8CDA671D7A28F600E207CA /* unittest_swift_runtime_proto2.pb.swift in Sources */, - 9C8CDA681D7A28F600E207CA /* unittest_swift_runtime_proto3.pb.swift in Sources */, - 9CC8CAAD1EC512A0008EF45F /* generated_swift_names_enum_cases.pb.swift in Sources */, - 9C8CDA691D7A28F600E207CA /* unittest_swift_startup.pb.swift in Sources */, - 9C8CDA6A1D7A28F600E207CA /* unittest_well_known_types.pb.swift in Sources */, - ); - runOnlyForDeploymentPostprocessing = 0; - }; - BD12FD311D767BA0001815C7 /* Sources */ = { - isa = PBXSourcesBuildPhase; - buildActionMask = 2147483647; - files = ( - 0353A1CE1E81623B00067996 /* any.pb.swift in Sources */, - F4CECDD3262A141B008B05BC /* TextFormatDecodingOptions.swift in Sources */, - 9C2F237B1D7780D1008524F2 /* api.pb.swift in Sources */, - 9C2F237C1D7780D1008524F2 /* duration.pb.swift in Sources */, - F4618B572154151700E5FABA /* JSONEncodingOptions.swift in Sources */, - 9C2F237D1D7780D1008524F2 /* empty.pb.swift in Sources */, - 9C75F89F1DDD3FA3005CCFF2 /* JSONDecoder.swift in Sources */, - 9C2F237E1D7780D1008524F2 /* field_mask.pb.swift in Sources */, - AAE0F4E41E6F5CB9005240E0 /* Google_Protobuf_Value+Extensions.swift in Sources */, - 9C2F23801D7780D1008524F2 /* Google_Protobuf_Duration+Extensions.swift in Sources */, - 9C2F23811D7780D1008524F2 /* Google_Protobuf_FieldMask+Extensions.swift in Sources */, - F47138971E4E56AC00C8492C /* Internal.swift in Sources */, - AA28A4AD1DA454DA00C866D9 /* BinaryEncodingSizeVisitor.swift in Sources */, - 9C2F23821D7780D1008524F2 /* Google_Protobuf_Struct+Extensions.swift in Sources */, - 9CA424431E286D4E00C0E5B4 /* StringUtils.swift in Sources */, - DB2E0AFF1EB25D1D00F59319 /* Message+JSONArrayAdditions.swift in Sources */, - AA78AD371E84C5B4001C43F9 /* Message+AnyAdditions.swift in Sources */, - 9C2F23831D7780D1008524F2 /* Google_Protobuf_Timestamp+Extensions.swift in Sources */, - F411FE9C1EDDD706001AE6B2 /* JSONDecodingOptions.swift in Sources */, - 9C2F23851D7780D1008524F2 /* BinaryDecoder.swift in Sources */, - AA3640921E60D592000C3CF4 /* struct.pb.swift in Sources */, - 9C2F23861D7780D1008524F2 /* BinaryEncoder.swift in Sources */, - F4EDCC2C22DF896500A1ECB7 /* DoubleParser.swift in Sources */, - F4E852B71EE9D84800AE837E /* SelectiveVisitor.swift in Sources */, - F41BA4431E7B35C6004F6E95 /* AnyMessageStorage.swift in Sources */, - 9C2F23871D7780D1008524F2 /* Message+BinaryAdditions.swift in Sources */, - 9C2F23891D7780D1008524F2 /* Enum.swift in Sources */, - 9C2F238B1D7780D1008524F2 /* ExtensionFields.swift in Sources */, - F41BA3FD1E76F639004F6E95 /* Google_Protobuf_Any+Registry.swift in Sources */, - 9C75F88B1DDD30A5005CCFF2 /* ExtensionFieldValueSet.swift in Sources */, - F48769F923020B7D00D44224 /* descriptor.pb.swift in Sources */, - F4F4F11E1E5C7562006C6CAD /* MathUtils.swift in Sources */, - 9C84E4941E5E3ABD00513BE0 /* JSONEncodingError.swift in Sources */, - AA86F6FB1E0A0F0B006CC38A /* JSONEncodingVisitor.swift in Sources */, - F41BA4141E79BE54004F6E95 /* Google_Protobuf_Any+Extensions.swift in Sources */, - E7038A25224D7F1000B68775 /* Data+Extensions.swift in Sources */, - 9C2F238C1D7780D1008524F2 /* MessageExtension.swift in Sources */, - 9C667A961E4C203D008B974F /* BinaryDecodingError.swift in Sources */, - 9C2F238D1D7780D1008524F2 /* Decoder.swift in Sources */, - 9C2F238F1D7780D1008524F2 /* HashVisitor.swift in Sources */, - AAABA40C1E4A42CD00365CDF /* ProtobufAPIVersionCheck.swift in Sources */, - AAF2ED401DEF4D94007B510F /* ProtoNameProviding.swift in Sources */, - F4151F721EFAB83900EEA00B /* BinaryDelimited.swift in Sources */, - AAF2ED3B1DEF3FBC007B510F /* NameMap.swift in Sources */, - F411FEA01EDDD83C001AE6B2 /* BinaryDecodingOptions.swift in Sources */, - AA05BF501DAEB7E800619042 /* FieldTag.swift in Sources */, - 9C75F8A41DDD44A1005CCFF2 /* ProtobufMap.swift in Sources */, - AA28A4AA1DA40B0900C866D9 /* Varint.swift in Sources */, - F41BA4191E79C59A004F6E95 /* AnyUnpackError.swift in Sources */, - 9C2F23911D7780D1008524F2 /* JSONEncoder.swift in Sources */, - 9C2F23921D7780D1008524F2 /* Message+JSONAdditions.swift in Sources */, - F4539D2B1E6F5DD40076251F /* CustomJSONCodable.swift in Sources */, - AAEA52771DA832A8003F318F /* wrappers.pb.swift in Sources */, - 9C2F23931D7780D1008524F2 /* Message.swift in Sources */, - F4F4F11B1E5C7556006C6CAD /* TimeUtils.swift in Sources */, - F482B6B61E89941500A25EF8 /* Version.swift in Sources */, - 9C2F23981D7780D1008524F2 /* FieldTypes.swift in Sources */, - 9C2F23991D7780D1008524F2 /* UnknownStorage.swift in Sources */, - 9C5890B41DFF6389001CFC34 /* TextFormatDecoder.swift in Sources */, - 9C5890B51DFF6389001CFC34 /* TextFormatEncoder.swift in Sources */, - 9C5890B61DFF6389001CFC34 /* TextFormatEncodingVisitor.swift in Sources */, - 9C5890B71DFF6389001CFC34 /* TextFormatScanner.swift in Sources */, - 9C5890B91DFF6389001CFC34 /* Message+TextFormatAdditions.swift in Sources */, - F451074B23A288E400488257 /* UnsafeBufferPointer+Shims.swift in Sources */, - 9C4178621E809DA2007830C3 /* ExtensionMap.swift in Sources */, - F48FDD241E4D17ED0061D5C1 /* JSONScanner.swift in Sources */, - 9C75F8861DDD3045005CCFF2 /* SimpleExtensionMap.swift in Sources */, - F451074723A288E400488257 /* UnsafeRawPointer+Shims.swift in Sources */, - 9C84E4901E5E3ABD00513BE0 /* BinaryEncodingError.swift in Sources */, - 9C75F8811DDBE0FC005CCFF2 /* Visitor.swift in Sources */, - 9C0B366C1E5FAB910094E128 /* JSONMapEncodingVisitor.swift in Sources */, - 9C2F239B1D7780D1008524F2 /* source_context.pb.swift in Sources */, - 9C2F239C1D7780D1008524F2 /* timestamp.pb.swift in Sources */, - AA28A4A71DA30E5900C866D9 /* ZigZag.swift in Sources */, - 9C2F239D1D7780D1008524F2 /* type.pb.swift in Sources */, - 9C75F8951DDD3D20005CCFF2 /* BinaryEncodingVisitor.swift in Sources */, - F49B576C2252771700350FFD /* TextFormatEncodingOptions.swift in Sources */, - AAB979F61E7066D8003DC2F4 /* Google_Protobuf_ListValue+Extensions.swift in Sources */, - AA05BF4B1DAEB7E400619042 /* WireFormat.swift in Sources */, - 9C667A921E4C203D008B974F /* JSONDecodingError.swift in Sources */, - F44F93691DAD7FA500BC5B85 /* Google_Protobuf_Wrappers+Extensions.swift in Sources */, - 9C667A9A1E4C203D008B974F /* TextFormatDecodingError.swift in Sources */, - 9CE4C56924EF34F200471257 /* Google_Protobuf_NullValue+Extensions.swift in Sources */, - 9C75F8901DDD3108005CCFF2 /* ExtensibleMessage.swift in Sources */, - ); - runOnlyForDeploymentPostprocessing = 0; - }; - CompilePhase_Protobuf /* Sources */ = { - isa = PBXSourcesBuildPhase; - buildActionMask = 0; - files = ( - F41BA4421E7AE53C004F6E95 /* AnyMessageStorage.swift in Sources */, - F4CECDD2262A141B008B05BC /* TextFormatDecodingOptions.swift in Sources */, - __src_cc_ref_Sources/Protobuf/api.pb.swift /* api.pb.swift in Sources */, - __src_cc_ref_Sources/Protobuf/duration.pb.swift /* duration.pb.swift in Sources */, - F4618B562154151700E5FABA /* JSONEncodingOptions.swift in Sources */, - __src_cc_ref_Sources/Protobuf/empty.pb.swift /* empty.pb.swift in Sources */, - __src_cc_ref_Sources/Protobuf/ProtobufEnum.swift /* Enum.swift in Sources */, - 9C75F88F1DDD3108005CCFF2 /* ExtensibleMessage.swift in Sources */, - AAE0F4E31E6F5CB9005240E0 /* Google_Protobuf_Value+Extensions.swift in Sources */, - 8DC1CA0F1E54B81400CA8A26 /* TimeUtils.swift in Sources */, - __src_cc_ref_Sources/Protobuf/ProtobufExtensionFields.swift /* ExtensionFields.swift in Sources */, - 9C4178611E809DA2007830C3 /* ExtensionMap.swift in Sources */, - 9C75F88A1DDD30A5005CCFF2 /* ExtensionFieldValueSet.swift in Sources */, - F47138961E4E56AC00C8492C /* Internal.swift in Sources */, - 9C75F8851DDD3045005CCFF2 /* SimpleExtensionMap.swift in Sources */, - __src_cc_ref_Sources/Protobuf/ProtobufFieldDecoder.swift /* Decoder.swift in Sources */, - DB2E0AFE1EB25D1D00F59319 /* Message+JSONArrayAdditions.swift in Sources */, - AA78AD361E84C5B4001C43F9 /* Message+AnyAdditions.swift in Sources */, - AAF2ED3A1DEF3FBC007B510F /* NameMap.swift in Sources */, - F4584DB81EDDCAD600803AB6 /* JSONDecodingOptions.swift in Sources */, - 9CA424421E286D4E00C0E5B4 /* StringUtils.swift in Sources */, - AA05BF4F1DAEB7E800619042 /* FieldTag.swift in Sources */, - F4EDCC2B22DF896500A1ECB7 /* DoubleParser.swift in Sources */, - __src_cc_ref_Sources/Protobuf/ProtobufTypes.swift /* FieldTypes.swift in Sources */, - F4E852B61EE9D83C00AE837E /* SelectiveVisitor.swift in Sources */, - AA3640911E60D043000C3CF4 /* struct.pb.swift in Sources */, - __src_cc_ref_Sources/Protobuf/field_mask.pb.swift /* field_mask.pb.swift in Sources */, - __src_cc_ref_Sources/Protobuf/Google_Protobuf_Duration_Extensions.swift /* Google_Protobuf_Duration+Extensions.swift in Sources */, - __src_cc_ref_Sources/Protobuf/Google_Protobuf_FieldMask_Extensions.swift /* Google_Protobuf_FieldMask+Extensions.swift in Sources */, - F41BA3FC1E76F635004F6E95 /* Google_Protobuf_Any+Registry.swift in Sources */, - F48769F823020B7D00D44224 /* descriptor.pb.swift in Sources */, - __src_cc_ref_Sources/Protobuf/Google_Protobuf_Struct.swift /* Google_Protobuf_Struct+Extensions.swift in Sources */, - __src_cc_ref_Sources/Protobuf/Google_Protobuf_Timestamp_Extensions.swift /* Google_Protobuf_Timestamp+Extensions.swift in Sources */, - 9C84E4931E5E3ABD00513BE0 /* JSONEncodingError.swift in Sources */, - 8DC1CA0D1E54B80800CA8A26 /* MathUtils.swift in Sources */, - E7038A24224D7F1000B68775 /* Data+Extensions.swift in Sources */, - F41BA4131E79BDCA004F6E95 /* Google_Protobuf_Any+Extensions.swift in Sources */, - AAEA52721DA80DD4003F318F /* Google_Protobuf_Wrappers+Extensions.swift in Sources */, - AAABA40B1E4A42CD00365CDF /* ProtobufAPIVersionCheck.swift in Sources */, - 9C667A951E4C203D008B974F /* BinaryDecodingError.swift in Sources */, - AA86F6FA1E0A0F0B006CC38A /* JSONEncodingVisitor.swift in Sources */, - __src_cc_ref_Sources/Protobuf/ProtobufHash.swift /* HashVisitor.swift in Sources */, - __src_cc_ref_Sources/Protobuf/ProtobufJSONEncoding.swift /* JSONEncoder.swift in Sources */, - F4151F711EFAB83400EEA00B /* BinaryDelimited.swift in Sources */, - F411FE9F1EDDD83B001AE6B2 /* BinaryDecodingOptions.swift in Sources */, - 9C75F89E1DDD3FA3005CCFF2 /* JSONDecoder.swift in Sources */, - __src_cc_ref_Sources/Protobuf/ProtobufJSONTypes.swift /* Message+JSONAdditions.swift in Sources */, - 9C75F8A31DDD44A1005CCFF2 /* ProtobufMap.swift in Sources */, - F41BA4181E79C568004F6E95 /* AnyUnpackError.swift in Sources */, - __src_cc_ref_Sources/Protobuf/ProtobufMessage.swift /* Message.swift in Sources */, - __src_cc_ref_Sources/Protobuf/ProtobufExtensions.swift /* MessageExtension.swift in Sources */, - F4539D2A1E6F5DC70076251F /* CustomJSONCodable.swift in Sources */, - __src_cc_ref_Sources/Protobuf/ProtobufBinaryDecoding.swift /* BinaryDecoder.swift in Sources */, - __src_cc_ref_Sources/Protobuf/ProtobufBinaryEncoding.swift /* BinaryEncoder.swift in Sources */, - AA28A4AC1DA454DA00C866D9 /* BinaryEncodingSizeVisitor.swift in Sources */, - F482B6B31E89940E00A25EF8 /* Version.swift in Sources */, - F41BA4401E7AE4AC004F6E95 /* any.pb.swift in Sources */, - 9C75F8941DDD3D20005CCFF2 /* BinaryEncodingVisitor.swift in Sources */, - __src_cc_ref_Sources/Protobuf/ProtobufBinaryTypes.swift /* Message+BinaryAdditions.swift in Sources */, - AAF2ED3F1DEF4D94007B510F /* ProtoNameProviding.swift in Sources */, - __src_cc_ref_Sources/Protobuf/source_context.pb.swift /* source_context.pb.swift in Sources */, - BCCA0E691DB1210E00957D74 /* TextFormatDecoder.swift in Sources */, - BCCA0E6A1DB1210E00957D74 /* TextFormatEncoder.swift in Sources */, - F451074A23A288E400488257 /* UnsafeBufferPointer+Shims.swift in Sources */, - 9C667A991E4C203D008B974F /* TextFormatDecodingError.swift in Sources */, - 9CE9CF371E32C9F8004FBED6 /* JSONScanner.swift in Sources */, - 9C84E48F1E5E3ABD00513BE0 /* BinaryEncodingError.swift in Sources */, - F451074623A288E400488257 /* UnsafeRawPointer+Shims.swift in Sources */, - 9C667A911E4C203D008B974F /* JSONDecodingError.swift in Sources */, - 9C0B366B1E5FAB910094E128 /* JSONMapEncodingVisitor.swift in Sources */, - 9CEB0D681DF5E934002D80F0 /* TextFormatEncodingVisitor.swift in Sources */, - 9CEB0D6C1DF5F921002D80F0 /* TextFormatScanner.swift in Sources */, - BCCA0E6B1DB1210E00957D74 /* Message+TextFormatAdditions.swift in Sources */, - __src_cc_ref_Sources/Protobuf/timestamp.pb.swift /* timestamp.pb.swift in Sources */, - __src_cc_ref_Sources/Protobuf/type.pb.swift /* type.pb.swift in Sources */, - __src_cc_ref_Sources/Protobuf/ProtobufUnknown.swift /* UnknownStorage.swift in Sources */, - F49B576B2252771700350FFD /* TextFormatEncodingOptions.swift in Sources */, - AAB979F51E7066D8003DC2F4 /* Google_Protobuf_ListValue+Extensions.swift in Sources */, - AA28A4A91DA40B0900C866D9 /* Varint.swift in Sources */, - 9C75F8801DDBE0DE005CCFF2 /* Visitor.swift in Sources */, - AA05BF4A1DAEB7E400619042 /* WireFormat.swift in Sources */, - AAEA52741DA80DEA003F318F /* wrappers.pb.swift in Sources */, - 9CE4C56824EF34F200471257 /* Google_Protobuf_NullValue+Extensions.swift in Sources */, - AA28A4A61DA30E5900C866D9 /* ZigZag.swift in Sources */, - ); - runOnlyForDeploymentPostprocessing = 0; - }; - CompilePhase_ProtobufTestSuite /* Sources */ = { - isa = PBXSourcesBuildPhase; - buildActionMask = 0; - files = ( - F4151F661EF3197100EEA00B /* Test_SimpleExtensionMap.swift in Sources */, - F4CECDDE262A1442008B05BC /* Test_TextFormatDecodingOptions.swift in Sources */, - F47CF9A123E88DD000C7B24C /* unittest_swift_naming_number_prefix.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/any_test.pb.swift /* any_test.pb.swift in Sources */, - 8037FC952507E4F4003B7FAC /* unittest_swift_json.pb.swift in Sources */, - F40D33EA2017ED2100ABAF0F /* unittest_swift_enum_proto3.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/conformance.pb.swift /* conformance.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/map_unittest.pb.swift /* map_unittest.pb.swift in Sources */, - AAEA52201DA5BB81003F318F /* Message+UInt8ArrayHelpers.swift in Sources */, - AAE0F4DF1E6A3886005240E0 /* Test_EnumWithAliases.swift in Sources */, - F4C3A9711E96A08E006BB610 /* unittest_swift_oneof_all_required.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/TestHelpers.swift /* TestHelpers.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_AllTypes.swift /* Test_AllTypes.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_AllTypes_Proto3.swift /* Test_AllTypes_Proto3.swift in Sources */, - F482B6931E857BC100A25EF8 /* unittest_swift_naming_no_prefix.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_Any.swift /* Test_Any.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_Api.swift /* Test_Api.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_Conformance.swift /* Test_Conformance.swift in Sources */, - 9CC8CAB21EC512A0008EF45F /* generated_swift_names_fields.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_Duration.swift /* Test_Duration.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_Empty.swift /* Test_Empty.swift in Sources */, - F4151F771EFAD85A00EEA00B /* Test_BinaryDelimited.swift in Sources */, - 6583D6E4246E04A200353AF4 /* Test_JSON_Extensions.swift in Sources */, - F44F94431DBFE0BE00BC5B85 /* Test_OneofFields_Access_Proto3.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_Enum.swift /* Test_Enum.swift in Sources */, - AA6CF6F51DB6D227007DF26B /* Test_Enum_Proto2.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_Extensions.swift /* Test_Extensions.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_ExtremeDefaultValues.swift /* Test_ExtremeDefaultValues.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_FieldMask.swift /* Test_FieldMask.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_FieldOrdering.swift /* Test_FieldOrdering.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_JSON.swift /* Test_JSON.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_JSON_Conformance.swift /* Test_JSON_Conformance.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_JSON_Group.swift /* Test_JSON_Group.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_Map.swift /* Test_Map.swift in Sources */, - 9CC8CAAF1EC512A0008EF45F /* generated_swift_names_enums.pb.swift in Sources */, - F4A1A8AD1E65E2EF0022E078 /* map_proto2_unittest.pb.swift in Sources */, - F44F94481DBFF17F00BC5B85 /* Test_MapFields_Access_Proto2.swift in Sources */, - F44F944D1DBFF8DB00BC5B85 /* Test_MapFields_Access_Proto3.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_Map_JSON.swift /* Test_Map_JSON.swift in Sources */, - F44F943E1DBFC2CF00BC5B85 /* Test_OneofFields_Access_Proto2.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_Packed.swift /* Test_Packed.swift in Sources */, - F4F4F1181E5633E7006C6CAD /* Test_Naming.swift in Sources */, - F4584DB41EDDCA8700803AB6 /* Test_JSONDecodingOptions.swift in Sources */, - 9CC8CAB51EC512A0008EF45F /* generated_swift_names_messages.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_ParsingMerge.swift /* Test_ParsingMerge.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_ReallyLargeTagNumber.swift /* Test_ReallyLargeTagNumber.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_RecursiveMap.swift /* Test_RecursiveMap.swift in Sources */, - F451075823A2B9B500488257 /* Data+TestHelpers.swift in Sources */, - F4539D261E688B030076251F /* Test_GroupWithGroups.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_Required.swift /* Test_Required.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_Reserved.swift /* Test_Reserved.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_Struct.swift /* Test_Struct.swift in Sources */, - F430B11F262764D400C9EE2A /* Test_FuzzTests.swift in Sources */, - 9C60CBEC1DF9DEEA00F7B14E /* Test_TextFormat_proto2.swift in Sources */, - 9C5890A71DFF5FFC001CFC34 /* Test_TextFormat_proto2_extensions.swift in Sources */, - BCCA0E7A1DB124B800957D74 /* Test_TextFormat_proto3.swift in Sources */, - 9CCD5F931E008203002D1940 /* Test_TextFormat_WKT_proto3.swift in Sources */, - F44F943A1DBFBB7400BC5B85 /* Test_BasicFields_Access_Proto3.swift in Sources */, - F44F94351DBF9AEA00BC5B85 /* Test_BasicFields_Access_Proto2.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_Timestamp.swift /* Test_Timestamp.swift in Sources */, - DB2E0AFA1EB24C7600F59319 /* Test_JSON_Array.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_Type.swift /* Test_Type.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_Unknown_proto2.swift /* Test_Unknown_proto2.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_Unknown_proto3.swift /* Test_Unknown_proto3.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/Test_Wrappers.swift /* Test_Wrappers.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest.pb.swift /* unittest.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_arena.pb.swift /* unittest_arena.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_custom_options.pb.swift /* unittest_custom_options.pb.swift in Sources */, - F430B11C262764D400C9EE2A /* fuzz_testing.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_drop_unknown_fields.pb.swift /* unittest_drop_unknown_fields.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_embed_optimize_for.pb.swift /* unittest_embed_optimize_for.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_empty.pb.swift /* unittest_empty.pb.swift in Sources */, - F4A07B2C1E4A3E620035678A /* test_messages_proto3.pb.swift in Sources */, - F411FEAC1EDDDC61001AE6B2 /* Test_BinaryDecodingOptions.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_import.pb.swift /* unittest_import.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_import_lite.pb.swift /* unittest_import_lite.pb.swift in Sources */, - AA3640961E60EBB0000C3CF4 /* Test_Merge.swift in Sources */, - F45D73FD1EE9984A00E0A231 /* Test_MessageSet.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_import_public.pb.swift /* unittest_import_public.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_import_public_lite.pb.swift /* unittest_import_public_lite.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_lite.pb.swift /* unittest_lite.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_lite_imports_nonlite.pb.swift /* unittest_lite_imports_nonlite.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_mset.pb.swift /* unittest_mset.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_mset_wire_format.pb.swift /* unittest_mset_wire_format.pb.swift in Sources */, - F4584D3B1ECA4FC600803AB6 /* unittest_swift_oneof_merging.pb.swift in Sources */, - 9C60CBE81DF8AC3F00F7B14E /* Test_TextFormat_Map_proto3.swift in Sources */, - F47C42B52437A3C700C08579 /* unittest_proto3_optional.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_no_field_presence.pb.swift /* unittest_no_field_presence.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_no_generic_services.pb.swift /* unittest_no_generic_services.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_optimize_for.pb.swift /* unittest_optimize_for.pb.swift in Sources */, - F47C42C22437A73000C08579 /* Test_AllTypes_Proto3_Optional.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_preserve_unknown_enum.pb.swift /* unittest_preserve_unknown_enum.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_preserve_unknown_enum2.pb.swift /* unittest_preserve_unknown_enum2.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_proto3.pb.swift /* unittest_proto3.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_proto3_arena.pb.swift /* unittest_proto3_arena.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_swift_all_required_types.pb.swift /* unittest_swift_all_required_types.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_swift_cycle.pb.swift /* unittest_swift_cycle.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_swift_enum.pb.swift /* unittest_swift_enum.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_swift_enum_optional_default.pb.swift /* unittest_swift_enum_optional_default.pb.swift in Sources */, - 9C7254661E5F9B1600486C98 /* Test_TextFormat_Unknown.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_swift_extension.pb.swift /* unittest_swift_extension.pb.swift in Sources */, - F4D315471DEC8117005D4A80 /* unittest_swift_extension2.pb.swift in Sources */, - F4D315481DEC8117005D4A80 /* unittest_swift_extension3.pb.swift in Sources */, - F4D315541DECA0EA005D4A80 /* unittest_swift_extension4.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_swift_fieldorder.pb.swift /* unittest_swift_fieldorder.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_swift_groups.pb.swift /* unittest_swift_groups.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_swift_naming.pb.swift /* unittest_swift_naming.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_swift_performance.pb.swift /* unittest_swift_performance.pb.swift in Sources */, - F4618B642154245600E5FABA /* Test_JSONEncodingOptions.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_swift_reserved.pb.swift /* unittest_swift_reserved.pb.swift in Sources */, - F482B6791E856D2600A25EF8 /* unittest_swift_reserved_ext.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_swift_runtime_proto2.pb.swift /* unittest_swift_runtime_proto2.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_swift_runtime_proto3.pb.swift /* unittest_swift_runtime_proto3.pb.swift in Sources */, - 9CC8CAAC1EC512A0008EF45F /* generated_swift_names_enum_cases.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_swift_startup.pb.swift /* unittest_swift_startup.pb.swift in Sources */, - __src_cc_ref_Tests/ProtobufTests/unittest_well_known_types.pb.swift /* unittest_well_known_types.pb.swift in Sources */, - ); - runOnlyForDeploymentPostprocessing = 0; - }; - F44F936A1DAEA53900BC5B85 /* Sources */ = { - isa = PBXSourcesBuildPhase; - buildActionMask = 2147483647; - files = ( - 0353A1CF1E81624F00067996 /* any.pb.swift in Sources */, - F4CECDD4262A141B008B05BC /* TextFormatDecodingOptions.swift in Sources */, - F44F93821DAEA76700BC5B85 /* BinaryEncoder.swift in Sources */, - F44F93961DAEA76700BC5B85 /* timestamp.pb.swift in Sources */, - F4618B582154151700E5FABA /* JSONEncodingOptions.swift in Sources */, - F44F93951DAEA76700BC5B85 /* source_context.pb.swift in Sources */, - 9C75F8A01DDD3FA3005CCFF2 /* JSONDecoder.swift in Sources */, - F44F939A1DAEA76700BC5B85 /* ZigZag.swift in Sources */, - AAE0F4E51E6F5CB9005240E0 /* Google_Protobuf_Value+Extensions.swift in Sources */, - F44F93971DAEA76700BC5B85 /* type.pb.swift in Sources */, - F44F937F1DAEA76700BC5B85 /* Google_Protobuf_Timestamp+Extensions.swift in Sources */, - F44F938E1DAEA76700BC5B85 /* Message+JSONAdditions.swift in Sources */, - F47138981E4E56AC00C8492C /* Internal.swift in Sources */, - F44F93801DAEA76700BC5B85 /* Google_Protobuf_Wrappers+Extensions.swift in Sources */, - 9CA424441E286D4E00C0E5B4 /* StringUtils.swift in Sources */, - DB2E0B001EB25D1D00F59319 /* Message+JSONArrayAdditions.swift in Sources */, - AA78AD381E84C5B4001C43F9 /* Message+AnyAdditions.swift in Sources */, - F44F938F1DAEA76700BC5B85 /* Message.swift in Sources */, - F411FE9D1EDDD706001AE6B2 /* JSONDecodingOptions.swift in Sources */, - F44F93861DAEA76700BC5B85 /* Enum.swift in Sources */, - F44F938A1DAEA76700BC5B85 /* Decoder.swift in Sources */, - AA3640931E60D593000C3CF4 /* struct.pb.swift in Sources */, - F4EDCC2D22DF896500A1ECB7 /* DoubleParser.swift in Sources */, - F4E852B81EE9D84900AE837E /* SelectiveVisitor.swift in Sources */, - F41BA4441E7B35C7004F6E95 /* AnyMessageStorage.swift in Sources */, - F44F938D1DAEA76700BC5B85 /* JSONEncoder.swift in Sources */, - F44F938B1DAEA76700BC5B85 /* HashVisitor.swift in Sources */, - 9C75F88C1DDD30A5005CCFF2 /* ExtensionFieldValueSet.swift in Sources */, - AA86F6FC1E0A0F0B006CC38A /* JSONEncodingVisitor.swift in Sources */, - F41BA3FE1E76F639004F6E95 /* Google_Protobuf_Any+Registry.swift in Sources */, - F48769FA23020B7D00D44224 /* descriptor.pb.swift in Sources */, - AAF2ED411DEF4D94007B510F /* ProtoNameProviding.swift in Sources */, - AAF2ED3C1DEF3FBC007B510F /* NameMap.swift in Sources */, - 9C84E4951E5E3ABD00513BE0 /* JSONEncodingError.swift in Sources */, - F4F4F11F1E5C7563006C6CAD /* MathUtils.swift in Sources */, - E7038A26224D7F1000B68775 /* Data+Extensions.swift in Sources */, - F41BA4151E79BE55004F6E95 /* Google_Protobuf_Any+Extensions.swift in Sources */, - F44F937E1DAEA76700BC5B85 /* Google_Protobuf_Struct+Extensions.swift in Sources */, - 9C667A971E4C203D008B974F /* BinaryDecodingError.swift in Sources */, - F44F93941DAEA76700BC5B85 /* UnknownStorage.swift in Sources */, - 9C75F8821DDBE10D005CCFF2 /* Visitor.swift in Sources */, - AAABA40D1E4A42CD00365CDF /* ProtobufAPIVersionCheck.swift in Sources */, - F4151F731EFAB83A00EEA00B /* BinaryDelimited.swift in Sources */, - F44F93781DAEA76700BC5B85 /* duration.pb.swift in Sources */, - F411FEA11EDDD83D001AE6B2 /* BinaryDecodingOptions.swift in Sources */, - AA05BF511DAEB7E800619042 /* FieldTag.swift in Sources */, - 9C75F8A51DDD44A1005CCFF2 /* ProtobufMap.swift in Sources */, - F44F937A1DAEA76700BC5B85 /* field_mask.pb.swift in Sources */, - F44F93831DAEA76700BC5B85 /* BinaryEncodingSizeVisitor.swift in Sources */, - F41BA41A1E79C59B004F6E95 /* AnyUnpackError.swift in Sources */, - F44F93841DAEA76700BC5B85 /* Message+BinaryAdditions.swift in Sources */, - F4539D2C1E6F5DD50076251F /* CustomJSONCodable.swift in Sources */, - F44F93991DAEA76700BC5B85 /* wrappers.pb.swift in Sources */, - F44F93811DAEA76700BC5B85 /* BinaryDecoder.swift in Sources */, - F4F4F11C1E5C7556006C6CAD /* TimeUtils.swift in Sources */, - F482B6B71E89941600A25EF8 /* Version.swift in Sources */, - F44F93981DAEA76700BC5B85 /* Varint.swift in Sources */, - F44F937C1DAEA76700BC5B85 /* Google_Protobuf_Duration+Extensions.swift in Sources */, - 9C5890AE1DFF6384001CFC34 /* TextFormatDecoder.swift in Sources */, - 9C5890AF1DFF6384001CFC34 /* TextFormatEncoder.swift in Sources */, - 9C5890B01DFF6384001CFC34 /* TextFormatEncodingVisitor.swift in Sources */, - 9C5890B11DFF6384001CFC34 /* TextFormatScanner.swift in Sources */, - 9C5890B31DFF6384001CFC34 /* Message+TextFormatAdditions.swift in Sources */, - F451074C23A288E400488257 /* UnsafeBufferPointer+Shims.swift in Sources */, - 9C4178631E809DA2007830C3 /* ExtensionMap.swift in Sources */, - F48FDD251E4D17EE0061D5C1 /* JSONScanner.swift in Sources */, - 9C84E4911E5E3ABD00513BE0 /* BinaryEncodingError.swift in Sources */, - F451074823A288E400488257 /* UnsafeRawPointer+Shims.swift in Sources */, - F44F93931DAEA76700BC5B85 /* FieldTypes.swift in Sources */, - 9C0B366D1E5FAB910094E128 /* JSONMapEncodingVisitor.swift in Sources */, - 9C75F8871DDD3045005CCFF2 /* SimpleExtensionMap.swift in Sources */, - F44F937D1DAEA76700BC5B85 /* Google_Protobuf_FieldMask+Extensions.swift in Sources */, - F44F93771DAEA76700BC5B85 /* api.pb.swift in Sources */, - F44F93791DAEA76700BC5B85 /* empty.pb.swift in Sources */, - F44F93891DAEA76700BC5B85 /* MessageExtension.swift in Sources */, - 9C75F8961DDD3D20005CCFF2 /* BinaryEncodingVisitor.swift in Sources */, - F49B576D2252771700350FFD /* TextFormatEncodingOptions.swift in Sources */, - AAB979F71E7066D8003DC2F4 /* Google_Protobuf_ListValue+Extensions.swift in Sources */, - AA05BF4C1DAEB7E400619042 /* WireFormat.swift in Sources */, - 9C667A931E4C203D008B974F /* JSONDecodingError.swift in Sources */, - F44F93881DAEA76700BC5B85 /* ExtensionFields.swift in Sources */, - 9C667A9B1E4C203D008B974F /* TextFormatDecodingError.swift in Sources */, - 9CE4C56A24EF34F200471257 /* Google_Protobuf_NullValue+Extensions.swift in Sources */, - 9C75F8911DDD3108005CCFF2 /* ExtensibleMessage.swift in Sources */, - ); - runOnlyForDeploymentPostprocessing = 0; - }; - F44F939B1DAEA7C500BC5B85 /* Sources */ = { - isa = PBXSourcesBuildPhase; - buildActionMask = 2147483647; - files = ( - F4151F681EF3197300EEA00B /* Test_SimpleExtensionMap.swift in Sources */, - F4CECDE0262A1442008B05BC /* Test_TextFormatDecodingOptions.swift in Sources */, - F47CF9A323E88DD000C7B24C /* unittest_swift_naming_number_prefix.pb.swift in Sources */, - F44F93BD1DAEA8C900BC5B85 /* Test_FieldOrdering.swift in Sources */, - 8037FC972507E4F4003B7FAC /* unittest_swift_json.pb.swift in Sources */, - F40D33EC2017ED2300ABAF0F /* unittest_swift_enum_proto3.pb.swift in Sources */, - F44F93C21DAEA8C900BC5B85 /* Test_Map_JSON.swift in Sources */, - F44F93DD1DAEA8C900BC5B85 /* unittest_lite.pb.swift in Sources */, - F44F93B31DAEA8C900BC5B85 /* Test_Any.swift in Sources */, - F44F93B71DAEA8C900BC5B85 /* Test_Duration.swift in Sources */, - AAE0F4E11E6A3886005240E0 /* Test_EnumWithAliases.swift in Sources */, - F4C3A9731E96A090006BB610 /* unittest_swift_oneof_all_required.pb.swift in Sources */, - F44F93DF1DAEA8C900BC5B85 /* unittest_mset.pb.swift in Sources */, - F44F93D51DAEA8C900BC5B85 /* unittest_empty.pb.swift in Sources */, - F44F93C11DAEA8C900BC5B85 /* Test_JSON.swift in Sources */, - F482B6951E857BC200A25EF8 /* unittest_swift_naming_no_prefix.pb.swift in Sources */, - 9CCD5F951E008203002D1940 /* Test_TextFormat_WKT_proto3.swift in Sources */, - F44F93EB1DAEA8C900BC5B85 /* unittest_swift_cycle.pb.swift in Sources */, - F44F93C81DAEA8C900BC5B85 /* Test_RecursiveMap.swift in Sources */, - 9CC8CAB41EC512A0008EF45F /* generated_swift_names_fields.pb.swift in Sources */, - F44F93D81DAEA8C900BC5B85 /* unittest_import_public_lite.pb.swift in Sources */, - 6583D6E6246E04A200353AF4 /* Test_JSON_Extensions.swift in Sources */, - F4151F791EFAD85C00EEA00B /* Test_BinaryDelimited.swift in Sources */, - F44F93B81DAEA8C900BC5B85 /* Test_Empty.swift in Sources */, - F44F93B11DAEA8C900BC5B85 /* Test_AllTypes_Proto3.swift in Sources */, - F44F94451DBFE0C000BC5B85 /* Test_OneofFields_Access_Proto3.swift in Sources */, - F44F93DC1DAEA8C900BC5B85 /* unittest_lite_imports_nonlite.pb.swift in Sources */, - F44F93F01DAEA8C900BC5B85 /* unittest_swift_groups.pb.swift in Sources */, - F44F93EE1DAEA8C900BC5B85 /* unittest_swift_extension.pb.swift in Sources */, - F44F93D31DAEA8C900BC5B85 /* unittest_drop_unknown_fields.pb.swift in Sources */, - F44F93BA1DAEA8C900BC5B85 /* Test_Extensions.swift in Sources */, - F44F93B51DAEA8C900BC5B85 /* Test_Conformance.swift in Sources */, - F44F93E71DAEA8C900BC5B85 /* unittest_preserve_unknown_enum2.pb.swift in Sources */, - F44F93CD1DAEA8C900BC5B85 /* Test_Type.swift in Sources */, - 9CC8CAB11EC512A0008EF45F /* generated_swift_names_enums.pb.swift in Sources */, - F4A1A8AF1E65E2F10022E078 /* map_proto2_unittest.pb.swift in Sources */, - F44F93AB1DAEA8C900BC5B85 /* conformance.pb.swift in Sources */, - F44F93E31DAEA8C900BC5B85 /* unittest_no_field_presence.pb.swift in Sources */, - F44F93AA1DAEA8C900BC5B85 /* any_test.pb.swift in Sources */, - F44F93AF1DAEA8C900BC5B85 /* map_unittest.pb.swift in Sources */, - F44F93C91DAEA8C900BC5B85 /* Test_Required.swift in Sources */, - F4584DB61EDDCA8900803AB6 /* Test_JSONDecodingOptions.swift in Sources */, - F4F4F11A1E5633EA006C6CAD /* Test_Naming.swift in Sources */, - 9CC8CAB71EC512A0008EF45F /* generated_swift_names_messages.pb.swift in Sources */, - F44F93D11DAEA8C900BC5B85 /* unittest_arena.pb.swift in Sources */, - F451075A23A2B9B500488257 /* Data+TestHelpers.swift in Sources */, - F44F93EC1DAEA8C900BC5B85 /* unittest_swift_enum_optional_default.pb.swift in Sources */, - F4539D281E688B050076251F /* Test_GroupWithGroups.swift in Sources */, - F44F93BB1DAEA8C900BC5B85 /* Test_ExtremeDefaultValues.swift in Sources */, - F44F93EF1DAEA8C900BC5B85 /* unittest_swift_fieldorder.pb.swift in Sources */, - 9C60CBEE1DF9DEEA00F7B14E /* Test_TextFormat_proto2.swift in Sources */, - F44F93F81DAEA8C900BC5B85 /* unittest.pb.swift in Sources */, - F430B121262764D400C9EE2A /* Test_FuzzTests.swift in Sources */, - F44F93E81DAEA8C900BC5B85 /* unittest_proto3_arena.pb.swift in Sources */, - 9C60CBEA1DF8AC3F00F7B14E /* Test_TextFormat_Map_proto3.swift in Sources */, - F44F93F21DAEA8C900BC5B85 /* unittest_swift_performance.pb.swift in Sources */, - F44F93B41DAEA8C900BC5B85 /* Test_Api.swift in Sources */, - F44F93E41DAEA8C900BC5B85 /* unittest_no_generic_services.pb.swift in Sources */, - F44F944A1DBFF18100BC5B85 /* Test_MapFields_Access_Proto2.swift in Sources */, - DB2E0AFC1EB24C7600F59319 /* Test_JSON_Array.swift in Sources */, - F44F93CF1DAEA8C900BC5B85 /* Test_Unknown_proto3.swift in Sources */, - F48FDD2A1E4D18080061D5C1 /* Test_TextFormat_proto3.swift in Sources */, - F44F93D61DAEA8C900BC5B85 /* unittest_import_lite.pb.swift in Sources */, - F44F93BE1DAEA8C900BC5B85 /* Test_JSON_Conformance.swift in Sources */, - F48FDD291E4D18080061D5C1 /* Test_TextFormat_proto2_extensions.swift in Sources */, - F44F93CA1DAEA8C900BC5B85 /* Test_Reserved.swift in Sources */, - F44F93BF1DAEA8C900BC5B85 /* Test_JSON_Group.swift in Sources */, - F44F93E61DAEA8C900BC5B85 /* unittest_preserve_unknown_enum.pb.swift in Sources */, - F430B11E262764D400C9EE2A /* fuzz_testing.pb.swift in Sources */, - F411FEAE1EDDDC62001AE6B2 /* Test_BinaryDecodingOptions.swift in Sources */, - F44F93E51DAEA8C900BC5B85 /* unittest_optimize_for.pb.swift in Sources */, - F44F943C1DBFBB7700BC5B85 /* Test_BasicFields_Access_Proto3.swift in Sources */, - F44F93DB1DAEA8C900BC5B85 /* unittest_import.pb.swift in Sources */, - AA3640981E60EBB0000C3CF4 /* Test_Merge.swift in Sources */, - F45D73FF1EE9984C00E0A231 /* Test_MessageSet.swift in Sources */, - F44F93BC1DAEA8C900BC5B85 /* Test_FieldMask.swift in Sources */, - F4D3154C1DEC811C005D4A80 /* unittest_swift_extension3.pb.swift in Sources */, - F44F93D41DAEA8C900BC5B85 /* unittest_embed_optimize_for.pb.swift in Sources */, - F44F93C31DAEA8C900BC5B85 /* Test_Map.swift in Sources */, - F44F93F71DAEA8C900BC5B85 /* unittest_well_known_types.pb.swift in Sources */, - F44F93D01DAEA8C900BC5B85 /* Test_Wrappers.swift in Sources */, - F4584D3D1ECA4FC800803AB6 /* unittest_swift_oneof_merging.pb.swift in Sources */, - F4D315561DECA0EB005D4A80 /* unittest_swift_extension4.pb.swift in Sources */, - F44F93DA1DAEA8C900BC5B85 /* unittest_import_public.pb.swift in Sources */, - F4A07B2E1E4A3E640035678A /* test_messages_proto3.pb.swift in Sources */, - AA6CF6F71DB6D229007DF26B /* Test_Enum_Proto2.swift in Sources */, - F47C42B72437A3C700C08579 /* unittest_proto3_optional.pb.swift in Sources */, - F44F94371DBF9AEA00BC5B85 /* Test_BasicFields_Access_Proto2.swift in Sources */, - F44F93C71DAEA8C900BC5B85 /* Test_ReallyLargeTagNumber.swift in Sources */, - F44F93C41DAEA8C900BC5B85 /* Test_Packed.swift in Sources */, - F47C42C42437A73000C08579 /* Test_AllTypes_Proto3_Optional.swift in Sources */, - F44F93B21DAEA8C900BC5B85 /* Test_AllTypes.swift in Sources */, - F44F93EA1DAEA8C900BC5B85 /* unittest_swift_all_required_types.pb.swift in Sources */, - F44F93B01DAEA8C900BC5B85 /* Message+UInt8ArrayHelpers.swift in Sources */, - F4D3154B1DEC811C005D4A80 /* unittest_swift_extension2.pb.swift in Sources */, - F44F93F41DAEA8C900BC5B85 /* unittest_swift_runtime_proto2.pb.swift in Sources */, - F44F93CE1DAEA8C900BC5B85 /* Test_Unknown_proto2.swift in Sources */, - F44F93AD1DAEA8C900BC5B85 /* TestHelpers.swift in Sources */, - F44F93F61DAEA8C900BC5B85 /* unittest_swift_startup.pb.swift in Sources */, - F44F93C51DAEA8C900BC5B85 /* Test_ParsingMerge.swift in Sources */, - 9C7254681E5F9B1600486C98 /* Test_TextFormat_Unknown.swift in Sources */, - F44F93E91DAEA8C900BC5B85 /* unittest_proto3.pb.swift in Sources */, - F44F93D21DAEA8C900BC5B85 /* unittest_custom_options.pb.swift in Sources */, - F44F93B91DAEA8C900BC5B85 /* Test_Enum.swift in Sources */, - F44F93DE1DAEA8C900BC5B85 /* unittest_mset_wire_format.pb.swift in Sources */, - F44F93CB1DAEA8C900BC5B85 /* Test_Struct.swift in Sources */, - F44F944F1DBFF8DC00BC5B85 /* Test_MapFields_Access_Proto3.swift in Sources */, - F44F93CC1DAEA8C900BC5B85 /* Test_Timestamp.swift in Sources */, - F4618B662154245600E5FABA /* Test_JSONEncodingOptions.swift in Sources */, - F44F93F31DAEA8C900BC5B85 /* unittest_swift_reserved.pb.swift in Sources */, - F482B67B1E856D2700A25EF8 /* unittest_swift_reserved_ext.pb.swift in Sources */, - F44F94401DBFC2CF00BC5B85 /* Test_OneofFields_Access_Proto2.swift in Sources */, - F44F93F11DAEA8C900BC5B85 /* unittest_swift_naming.pb.swift in Sources */, - 9CC8CAAE1EC512A0008EF45F /* generated_swift_names_enum_cases.pb.swift in Sources */, - F44F93F51DAEA8C900BC5B85 /* unittest_swift_runtime_proto3.pb.swift in Sources */, - F44F93ED1DAEA8C900BC5B85 /* unittest_swift_enum.pb.swift in Sources */, - ); - runOnlyForDeploymentPostprocessing = 0; - }; - F44F93F91DAEB13F00BC5B85 /* Sources */ = { - isa = PBXSourcesBuildPhase; - buildActionMask = 2147483647; - files = ( - 0353A1D01E81625400067996 /* any.pb.swift in Sources */, - F4CECDD5262A141B008B05BC /* TextFormatDecodingOptions.swift in Sources */, - F44F94061DAEB23500BC5B85 /* api.pb.swift in Sources */, - F44F94071DAEB23500BC5B85 /* duration.pb.swift in Sources */, - F4618B592154151700E5FABA /* JSONEncodingOptions.swift in Sources */, - F44F94081DAEB23500BC5B85 /* empty.pb.swift in Sources */, - F44F94151DAEB23500BC5B85 /* Enum.swift in Sources */, - 9C75F8921DDD3108005CCFF2 /* ExtensibleMessage.swift in Sources */, - AAE0F4E61E6F5CB9005240E0 /* Google_Protobuf_Value+Extensions.swift in Sources */, - F44F94171DAEB23500BC5B85 /* ExtensionFields.swift in Sources */, - 9C75F88D1DDD30A5005CCFF2 /* ExtensionFieldValueSet.swift in Sources */, - F47138991E4E56AC00C8492C /* Internal.swift in Sources */, - 9C75F8881DDD3045005CCFF2 /* SimpleExtensionMap.swift in Sources */, - F44F94191DAEB23500BC5B85 /* Decoder.swift in Sources */, - AAF2ED3D1DEF3FBC007B510F /* NameMap.swift in Sources */, - 9CA424451E286D4E00C0E5B4 /* StringUtils.swift in Sources */, - DB2E0B011EB25D1D00F59319 /* Message+JSONArrayAdditions.swift in Sources */, - AA78AD391E84C5B4001C43F9 /* Message+AnyAdditions.swift in Sources */, - AA05BF521DAEB7E800619042 /* FieldTag.swift in Sources */, - F411FE9E1EDDD707001AE6B2 /* JSONDecodingOptions.swift in Sources */, - F44F94221DAEB23500BC5B85 /* FieldTypes.swift in Sources */, - F44F94091DAEB23500BC5B85 /* field_mask.pb.swift in Sources */, - F4EDCC2E22DF896500A1ECB7 /* DoubleParser.swift in Sources */, - AA3640941E60D593000C3CF4 /* struct.pb.swift in Sources */, - F4E852B91EE9D84A00AE837E /* SelectiveVisitor.swift in Sources */, - F41BA4451E7B35C8004F6E95 /* AnyMessageStorage.swift in Sources */, - F44F940B1DAEB23500BC5B85 /* Google_Protobuf_Duration+Extensions.swift in Sources */, - F44F940C1DAEB23500BC5B85 /* Google_Protobuf_FieldMask+Extensions.swift in Sources */, - ECBC5C4A1DF6ABC500F658E8 /* Google_Protobuf_Struct+Extensions.swift in Sources */, - F41BA3FF1E76F63A004F6E95 /* Google_Protobuf_Any+Registry.swift in Sources */, - F48769FB23020B7D00D44224 /* descriptor.pb.swift in Sources */, - ECBC5C4D1DF6ABC500F658E8 /* Google_Protobuf_Timestamp+Extensions.swift in Sources */, - F4F4F1201E5C7565006C6CAD /* MathUtils.swift in Sources */, - 9C84E4961E5E3ABD00513BE0 /* JSONEncodingError.swift in Sources */, - ECBC5C491DF6ABC500F658E8 /* Google_Protobuf_Wrappers+Extensions.swift in Sources */, - E7038A27224D7F1000B68775 /* Data+Extensions.swift in Sources */, - F41BA4161E79BE56004F6E95 /* Google_Protobuf_Any+Extensions.swift in Sources */, - AA86F6FD1E0A0F0B006CC38A /* JSONEncodingVisitor.swift in Sources */, - 9C667A981E4C203D008B974F /* BinaryDecodingError.swift in Sources */, - F44F941A1DAEB23500BC5B85 /* HashVisitor.swift in Sources */, - F44F941C1DAEB23500BC5B85 /* JSONEncoder.swift in Sources */, - AAABA40E1E4A42CD00365CDF /* ProtobufAPIVersionCheck.swift in Sources */, - F4151F741EFAB83A00EEA00B /* BinaryDelimited.swift in Sources */, - 9C75F8A11DDD3FA3005CCFF2 /* JSONDecoder.swift in Sources */, - F411FEA21EDDD83E001AE6B2 /* BinaryDecodingOptions.swift in Sources */, - F44F941D1DAEB23500BC5B85 /* Message+JSONAdditions.swift in Sources */, - 9C75F8A61DDD44A1005CCFF2 /* ProtobufMap.swift in Sources */, - F44F941E1DAEB23500BC5B85 /* Message.swift in Sources */, - F41BA41B1E79C59B004F6E95 /* AnyUnpackError.swift in Sources */, - F44F94181DAEB23500BC5B85 /* MessageExtension.swift in Sources */, - F44F94101DAEB23500BC5B85 /* BinaryDecoder.swift in Sources */, - F4539D2D1E6F5DD60076251F /* CustomJSONCodable.swift in Sources */, - F44F94111DAEB23500BC5B85 /* BinaryEncoder.swift in Sources */, - F44F94121DAEB23500BC5B85 /* BinaryEncodingSizeVisitor.swift in Sources */, - F4F4F11D1E5C7557006C6CAD /* TimeUtils.swift in Sources */, - F482B6B81E89941600A25EF8 /* Version.swift in Sources */, - 9C75F8971DDD3D20005CCFF2 /* BinaryEncodingVisitor.swift in Sources */, - F44F94131DAEB23500BC5B85 /* Message+BinaryAdditions.swift in Sources */, - AAF2ED421DEF4D94007B510F /* ProtoNameProviding.swift in Sources */, - ECBC5C501DF6ABC500F658E8 /* source_context.pb.swift in Sources */, - 9C5890A81DFF6375001CFC34 /* TextFormatDecoder.swift in Sources */, - 9C5890A91DFF6375001CFC34 /* TextFormatEncoder.swift in Sources */, - F48FDD261E4D17EF0061D5C1 /* JSONScanner.swift in Sources */, - F451074D23A288E400488257 /* UnsafeBufferPointer+Shims.swift in Sources */, - 9C4178641E809DA2007830C3 /* ExtensionMap.swift in Sources */, - 9C5890AA1DFF6375001CFC34 /* TextFormatEncodingVisitor.swift in Sources */, - 9C84E4921E5E3ABD00513BE0 /* BinaryEncodingError.swift in Sources */, - F451074923A288E400488257 /* UnsafeRawPointer+Shims.swift in Sources */, - 9C5890AB1DFF6375001CFC34 /* TextFormatScanner.swift in Sources */, - 9C0B366E1E5FAB910094E128 /* JSONMapEncodingVisitor.swift in Sources */, - 9C5890AD1DFF6375001CFC34 /* Message+TextFormatAdditions.swift in Sources */, - ECBC5C4B1DF6ABC500F658E8 /* timestamp.pb.swift in Sources */, - ECBC5C4E1DF6ABC500F658E8 /* type.pb.swift in Sources */, - F44F94231DAEB23500BC5B85 /* UnknownStorage.swift in Sources */, - ECBC5C4C1DF6ABC500F658E8 /* Varint.swift in Sources */, - 9C75F8831DDBE118005CCFF2 /* Visitor.swift in Sources */, - F49B576E2252771700350FFD /* TextFormatEncodingOptions.swift in Sources */, - AAB979F81E7066D8003DC2F4 /* Google_Protobuf_ListValue+Extensions.swift in Sources */, - AA05BF4D1DAEB7E400619042 /* WireFormat.swift in Sources */, - 9C667A941E4C203D008B974F /* JSONDecodingError.swift in Sources */, - ECBC5C511DF6ABC500F658E8 /* wrappers.pb.swift in Sources */, - 9C667A9C1E4C203D008B974F /* TextFormatDecodingError.swift in Sources */, - 9CE4C56B24EF34F200471257 /* Google_Protobuf_NullValue+Extensions.swift in Sources */, - ECBC5C4F1DF6ABC500F658E8 /* ZigZag.swift in Sources */, - ); - runOnlyForDeploymentPostprocessing = 0; - }; -/* End PBXSourcesBuildPhase section */ - -/* Begin PBXTargetDependency section */ - 9C8CDA191D7A288E00E207CA /* PBXTargetDependency */ = { - isa = PBXTargetDependency; - target = BD12FD351D767BA0001815C7 /* SwiftProtobuf_iOS */; - targetProxy = 9C8CDA181D7A288E00E207CA /* PBXContainerItemProxy */; - }; - F44F93A61DAEA7C500BC5B85 /* PBXTargetDependency */ = { - isa = PBXTargetDependency; - target = F44F936E1DAEA53900BC5B85 /* SwiftProtobuf_tvOS */; - targetProxy = F44F93A51DAEA7C500BC5B85 /* PBXContainerItemProxy */; - }; - __Dependency_Protobuf /* PBXTargetDependency */ = { - isa = PBXTargetDependency; - target = "______Target_Protobuf" /* SwiftProtobuf_macOS */; - targetProxy = 9CAEA5251D25B35600EB832A /* PBXContainerItemProxy */; - }; -/* End PBXTargetDependency section */ - -/* Begin XCBuildConfiguration section */ - 9C8CDA1B1D7A288E00E207CA /* Debug */ = { - isa = XCBuildConfiguration; - baseConfigurationReference = 5A82E34B2455D26900EB0A70 /* SwiftProtobufTestSuite_iOS.xcconfig */; - buildSettings = { - }; - name = Debug; - }; - 9C8CDA1C1D7A288E00E207CA /* Release */ = { - isa = XCBuildConfiguration; - baseConfigurationReference = 5A82E34B2455D26900EB0A70 /* SwiftProtobufTestSuite_iOS.xcconfig */; - buildSettings = { - }; - name = Release; - }; - BD12FD3B1D767BA1001815C7 /* Debug */ = { - isa = XCBuildConfiguration; - baseConfigurationReference = 5A82E3462455D26900EB0A70 /* SwiftProtobuf_iOS.xcconfig */; - buildSettings = { - }; - name = Debug; - }; - BD12FD3C1D767BA1001815C7 /* Release */ = { - isa = XCBuildConfiguration; - baseConfigurationReference = 5A82E3462455D26900EB0A70 /* SwiftProtobuf_iOS.xcconfig */; - buildSettings = { - }; - name = Release; - }; - F44F93741DAEA53900BC5B85 /* Debug */ = { - isa = XCBuildConfiguration; - baseConfigurationReference = 5A82E3492455D26900EB0A70 /* SwiftProtobuf_tvOS.xcconfig */; - buildSettings = { - }; - name = Debug; - }; - F44F93751DAEA53900BC5B85 /* Release */ = { - isa = XCBuildConfiguration; - baseConfigurationReference = 5A82E3492455D26900EB0A70 /* SwiftProtobuf_tvOS.xcconfig */; - buildSettings = { - }; - name = Release; - }; - F44F93A81DAEA7C500BC5B85 /* Debug */ = { - isa = XCBuildConfiguration; - baseConfigurationReference = 5A82E34A2455D26900EB0A70 /* SwiftProtobufTestSuite_tvOS.xcconfig */; - buildSettings = { - }; - name = Debug; - }; - F44F93A91DAEA7C500BC5B85 /* Release */ = { - isa = XCBuildConfiguration; - baseConfigurationReference = 5A82E34A2455D26900EB0A70 /* SwiftProtobufTestSuite_tvOS.xcconfig */; - buildSettings = { - }; - name = Release; - }; - F44F94031DAEB13F00BC5B85 /* Debug */ = { - isa = XCBuildConfiguration; - baseConfigurationReference = 5A82E3452455D26900EB0A70 /* SwiftProtobuf_watchOS.xcconfig */; - buildSettings = { - }; - name = Debug; - }; - F44F94041DAEB13F00BC5B85 /* Release */ = { - isa = XCBuildConfiguration; - baseConfigurationReference = 5A82E3452455D26900EB0A70 /* SwiftProtobuf_watchOS.xcconfig */; - buildSettings = { - }; - name = Release; - }; - _ReleaseConf_Protobuf /* Release */ = { - isa = XCBuildConfiguration; - baseConfigurationReference = 5A82E3482455D26900EB0A70 /* SwiftProtobuf_macOS.xcconfig */; - buildSettings = { - }; - name = Release; - }; - _ReleaseConf_ProtobufTestSuite /* Release */ = { - isa = XCBuildConfiguration; - baseConfigurationReference = 5A82E3472455D26900EB0A70 /* SwiftProtobufTestSuite_macOS.xcconfig */; - buildSettings = { - }; - name = Release; - }; - "___DebugConf_Protobuf" /* Debug */ = { - isa = XCBuildConfiguration; - baseConfigurationReference = 5A82E3482455D26900EB0A70 /* SwiftProtobuf_macOS.xcconfig */; - buildSettings = { - }; - name = Debug; - }; - "___DebugConf_ProtobufTestSuite" /* Debug */ = { - isa = XCBuildConfiguration; - baseConfigurationReference = 5A82E3472455D26900EB0A70 /* SwiftProtobufTestSuite_macOS.xcconfig */; - buildSettings = { - }; - name = Debug; - }; - "_____Release_" /* Release */ = { - isa = XCBuildConfiguration; - baseConfigurationReference = 5A82E34D2455D71400EB0A70 /* Base_Release.xcconfig */; - buildSettings = { - }; - name = Release; - }; - "_______Debug_" /* Debug */ = { - isa = XCBuildConfiguration; - baseConfigurationReference = 5A82E34C2455D71400EB0A70 /* Base_Debug.xcconfig */; - buildSettings = { - }; - name = Debug; - }; -/* End XCBuildConfiguration section */ - -/* Begin XCConfigurationList section */ - 9C8CDA1A1D7A288E00E207CA /* Build configuration list for PBXNativeTarget "SwiftProtobufTestSuite_iOS" */ = { - isa = XCConfigurationList; - buildConfigurations = ( - 9C8CDA1B1D7A288E00E207CA /* Debug */, - 9C8CDA1C1D7A288E00E207CA /* Release */, - ); - defaultConfigurationIsVisible = 0; - defaultConfigurationName = Release; - }; - BD12FD3D1D767BA1001815C7 /* Build configuration list for PBXNativeTarget "SwiftProtobuf_iOS" */ = { - isa = XCConfigurationList; - buildConfigurations = ( - BD12FD3B1D767BA1001815C7 /* Debug */, - BD12FD3C1D767BA1001815C7 /* Release */, - ); - defaultConfigurationIsVisible = 0; - defaultConfigurationName = Release; - }; - F44F93761DAEA53900BC5B85 /* Build configuration list for PBXNativeTarget "SwiftProtobuf_tvOS" */ = { - isa = XCConfigurationList; - buildConfigurations = ( - F44F93741DAEA53900BC5B85 /* Debug */, - F44F93751DAEA53900BC5B85 /* Release */, - ); - defaultConfigurationIsVisible = 0; - defaultConfigurationName = Release; - }; - F44F93A71DAEA7C500BC5B85 /* Build configuration list for PBXNativeTarget "SwiftProtobufTestSuite_tvOS" */ = { - isa = XCConfigurationList; - buildConfigurations = ( - F44F93A81DAEA7C500BC5B85 /* Debug */, - F44F93A91DAEA7C500BC5B85 /* Release */, - ); - defaultConfigurationIsVisible = 0; - defaultConfigurationName = Release; - }; - F44F94051DAEB13F00BC5B85 /* Build configuration list for PBXNativeTarget "SwiftProtobuf_watchOS" */ = { - isa = XCConfigurationList; - buildConfigurations = ( - F44F94031DAEB13F00BC5B85 /* Debug */, - F44F94041DAEB13F00BC5B85 /* Release */, - ); - defaultConfigurationIsVisible = 0; - defaultConfigurationName = Release; - }; - "___RootConfs_" /* Build configuration list for PBXProject "SwiftProtobuf" */ = { - isa = XCConfigurationList; - buildConfigurations = ( - "_______Debug_" /* Debug */, - "_____Release_" /* Release */, - ); - defaultConfigurationIsVisible = 0; - defaultConfigurationName = Release; - }; - "_______Confs_Protobuf" /* Build configuration list for PBXNativeTarget "SwiftProtobuf_macOS" */ = { - isa = XCConfigurationList; - buildConfigurations = ( - "___DebugConf_Protobuf" /* Debug */, - _ReleaseConf_Protobuf /* Release */, - ); - defaultConfigurationIsVisible = 0; - defaultConfigurationName = Release; - }; - "_______Confs_ProtobufTestSuite" /* Build configuration list for PBXNativeTarget "SwiftProtobufTestSuite_macOS" */ = { - isa = XCConfigurationList; - buildConfigurations = ( - "___DebugConf_ProtobufTestSuite" /* Debug */, - _ReleaseConf_ProtobufTestSuite /* Release */, - ); - defaultConfigurationIsVisible = 0; - defaultConfigurationName = Release; - }; -/* End XCConfigurationList section */ - }; - rootObject = __RootObject_ /* Project object */; -} diff --git a/SwiftProtobuf.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/SwiftProtobuf.xcodeproj/project.xcworkspace/contents.xcworkspacedata deleted file mode 100644 index 919434a62..000000000 --- a/SwiftProtobuf.xcodeproj/project.xcworkspace/contents.xcworkspacedata +++ /dev/null @@ -1,7 +0,0 @@ - - - - - diff --git a/SwiftProtobuf.xcodeproj/xcconfigs/Base.xcconfig b/SwiftProtobuf.xcodeproj/xcconfigs/Base.xcconfig deleted file mode 100644 index 8192ef4a2..000000000 --- a/SwiftProtobuf.xcodeproj/xcconfigs/Base.xcconfig +++ /dev/null @@ -1,86 +0,0 @@ -// Deployment -SKIP_INSTALL = YES -COMBINE_HIDPI_IMAGES = YES -IPHONEOS_DEPLOYMENT_TARGET = 9.0 -MACOSX_DEPLOYMENT_TARGET = 10.9 -TVOS_DEPLOYMENT_TARGET = 9.0 -WATCHOS_DEPLOYMENT_TARGET = 2.0 - -// Build Options -APPLICATION_EXTENSION_API_ONLY = YES - -// Linking -DYLIB_CURRENT_VERSION = 1 -DYLIB_COMPATIBILITY_VERSION = 1 -DYLIB_INSTALL_NAME_BASE = @rpath -CURRENT_PROJECT_VERSION = 1.18.0 - -// Packaging -PRODUCT_NAME = $(TARGET_NAME) - -// Search Paths -ALWAYS_SEARCH_USER_PATHS = NO -USE_HEADERMAP = NO - -// Apple Clang - Code Generation -GCC_NO_COMMON_BLOCKS = YES - -// Apple Clang - Language - Objective-C -CLANG_ENABLE_OBJC_WEAK = YES - -// Apple Clang - Preprocessing -ENABLE_STRICT_OBJC_MSGSEND = YES - -// Apple Clang - Warning Policies -GCC_TREAT_WARNINGS_AS_ERRORS = YES - -// Apple Clang - Warnings - All languages -CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES -CLANG_WARN_DOCUMENTATION_COMMENTS = YES -CLANG_WARN_EMPTY_BODY = YES -CLANG_WARN_BOOL_CONVERSION = YES -CLANG_WARN_CONSTANT_CONVERSION = YES -GCC_WARN_64_TO_32_BIT_CONVERSION = YES -CLANG_WARN_ENUM_CONVERSION = YES -CLANG_WARN_INT_CONVERSION = YES -CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES -CLANG_WARN_INFINITE_RECURSION = YES -GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR -GCC_WARN_ABOUT_MISSING_NEWLINE = YES -CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES -CLANG_WARN_STRICT_PROTOTYPES = YES -CLANG_WARN_COMMA = YES -GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE -CLANG_WARN_UNREACHABLE_CODE = YES -GCC_WARN_UNUSED_FUNCTION = YES -GCC_WARN_UNUSED_VARIABLE = YES - -// Apple Clang - Warnings - C++ -CLANG_WARN_RANGE_LOOP_ANALYSIS = YES -CLANG_WARN_SUSPICIOUS_MOVE = YES - -// Apple Clang - Warnings - Objective-C -CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR -CLANG_WARN__DUPLICATE_METHOD_MATCH = YES -CLANG_WARN_OBJC_LITERAL_CONVERSION = YES -CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES -GCC_WARN_UNDECLARED_SELECTOR = YES -CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR - -// Apple Clang - Warnings - Objective-C and ARC -CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES - -// Static Analyzer - Generic Issues -CLANG_ANALYZER_NONNULL = YES - -// Static Analyzer - Issues - Apple APIs -CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES - -// Swift Compiler - Custom Flags -OTHER_SWIFT_FLAGS = -DXcode - -// Swift Compiler - Language -SWIFT_VERSION = 5.0 - -// Swift Compiler - Warning Policies -SWIFT_TREAT_WARNINGS_AS_ERRORS = YES diff --git a/SwiftProtobuf.xcodeproj/xcconfigs/Base_Debug.xcconfig b/SwiftProtobuf.xcodeproj/xcconfigs/Base_Debug.xcconfig deleted file mode 100644 index 11eafd3a6..000000000 --- a/SwiftProtobuf.xcodeproj/xcconfigs/Base_Debug.xcconfig +++ /dev/null @@ -1,24 +0,0 @@ -#include "Base.xcconfig" - -// Architectures -ONLY_ACTIVE_ARCH = YES - -// Build Options -DEBUG_INFORMATION_FORMAT = dwarf -ENABLE_TESTABILITY = YES - -// Deployment -COPY_PHASE_STRIP = NO -STRIP_INSTALLED_PRODUCT = NO - -// Apple Clang - Code Generation -GCC_OPTIMIZATION_LEVEL = 0 - -// Apple Clang - Preprocessing -GCC_PREPROCESSOR_DEFINITIONS = DEBUG=1 - -// Swift Compiler - Code Generation -SWIFT_OPTIMIZATION_LEVEL = -Onone - -// Swift Compiler - Custom Flags -SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG diff --git a/SwiftProtobuf.xcodeproj/xcconfigs/Base_Release.xcconfig b/SwiftProtobuf.xcodeproj/xcconfigs/Base_Release.xcconfig deleted file mode 100644 index 3488d5187..000000000 --- a/SwiftProtobuf.xcodeproj/xcconfigs/Base_Release.xcconfig +++ /dev/null @@ -1,13 +0,0 @@ -#include "Base.xcconfig" - -// Build Options -DEBUG_INFORMATION_FORMAT = dwarf-with-dsym -VALIDATE_PRODUCT = YES - -// Apple Clang - Preprocessing -ENABLE_NS_ASSERTIONS = NO - -// Swift Compiler - Code Generation -SWIFT_COMPILATION_MODE = wholemodule -SWIFT_OPTIMIZATION_LEVEL = -O - diff --git a/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobufTestSuite_iOS.xcconfig b/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobufTestSuite_iOS.xcconfig deleted file mode 100644 index b52fdfeaa..000000000 --- a/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobufTestSuite_iOS.xcconfig +++ /dev/null @@ -1,17 +0,0 @@ -// Architectures -SDKROOT = iphoneos - -// Deployment -TARGETED_DEVICE_FAMILY = 1,2 - -// Linking -LD_RUNPATH_SEARCH_PATHS = @loader_path/Frameworks - -// Packaging -INFOPLIST_FILE = SwiftProtobuf.xcodeproj/ProtobufTestSuite_Info.plist -PRODUCT_BUNDLE_IDENTIFIER = org.swift.protobuf.SwiftProtobufTests -PRODUCT_MODULE_NAME = SwiftProtobufTests -PRODUCT_NAME = SwiftProtobufTests - -// Signing -CODE_SIGN_IDENTITY[sdk=iphoneos*] = iPhone Developer diff --git a/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobufTestSuite_macOS.xcconfig b/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobufTestSuite_macOS.xcconfig deleted file mode 100644 index 29f5c909c..000000000 --- a/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobufTestSuite_macOS.xcconfig +++ /dev/null @@ -1,11 +0,0 @@ -// Architectures -SDKROOT = macosx - -// Linking -LD_RUNPATH_SEARCH_PATHS = @loader_path/../Frameworks - -// Packaging -INFOPLIST_FILE = SwiftProtobuf.xcodeproj/ProtobufTestSuite_Info.plist -PRODUCT_BUNDLE_IDENTIFIER = org.swift.protobuf.SwiftProtobufTests -PRODUCT_MODULE_NAME = SwiftProtobufTests -PRODUCT_NAME = SwiftProtobufTests diff --git a/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobufTestSuite_tvOS.xcconfig b/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobufTestSuite_tvOS.xcconfig deleted file mode 100644 index 41d56291e..000000000 --- a/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobufTestSuite_tvOS.xcconfig +++ /dev/null @@ -1,17 +0,0 @@ -// Architectures -SDKROOT = appletvos - -// Deployment -TVOS_DEPLOYMENT_TARGET = 9.0 - -// Linking -LD_RUNPATH_SEARCH_PATHS = $(inherited) @executable_path/Frameworks @loader_path/Frameworks - -// Packaging -INFOPLIST_FILE = SwiftProtobuf.xcodeproj/ProtobufTestSuite_Info.plist -PRODUCT_BUNDLE_IDENTIFIER = org.swift.protobuf.SwiftProtobufTests -PRODUCT_MODULE_NAME = SwiftProtobufTests -PRODUCT_NAME = SwiftProtobufTests - -// Signing -CODE_SIGN_IDENTITY[sdk=appletvos*] = iPhone Developer diff --git a/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobuf_iOS.xcconfig b/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobuf_iOS.xcconfig deleted file mode 100644 index 44364e88c..000000000 --- a/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobuf_iOS.xcconfig +++ /dev/null @@ -1,12 +0,0 @@ -// Architectures -SDKROOT = iphoneos -SUPPORTED_PLATFORMS = iphonesimulator iphoneos - -// Deployment -TARGETED_DEVICE_FAMILY = 1,2 - -// Packaging -INFOPLIST_FILE = SwiftProtobuf.xcodeproj/Protobuf_Info.plist -PRODUCT_BUNDLE_IDENTIFIER = org.swift.protobuf.SwiftProtobuf -PRODUCT_MODULE_NAME = SwiftProtobuf -PRODUCT_NAME = SwiftProtobuf diff --git a/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobuf_macOS.xcconfig b/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobuf_macOS.xcconfig deleted file mode 100644 index 9bdc5d15c..000000000 --- a/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobuf_macOS.xcconfig +++ /dev/null @@ -1,8 +0,0 @@ -// Architectures -SDKROOT = macosx - -// Packaging -INFOPLIST_FILE = SwiftProtobuf.xcodeproj/Protobuf_Info.plist -PRODUCT_BUNDLE_IDENTIFIER = org.swift.protobuf.SwiftProtobuf -PRODUCT_MODULE_NAME = SwiftProtobuf -PRODUCT_NAME = SwiftProtobuf diff --git a/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobuf_tvOS.xcconfig b/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobuf_tvOS.xcconfig deleted file mode 100644 index ae43c0602..000000000 --- a/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobuf_tvOS.xcconfig +++ /dev/null @@ -1,12 +0,0 @@ -// Architectures -SDKROOT = appletvos - -// Deployment -TARGETED_DEVICE_FAMILY = 3 - -// Packaging -INFOPLIST_FILE = SwiftProtobuf.xcodeproj/Protobuf_Info.plist -PRODUCT_BUNDLE_IDENTIFIER = org.swift.protobuf.SwiftProtobuf -PRODUCT_MODULE_NAME = SwiftProtobuf -PRODUCT_NAME = SwiftProtobuf - diff --git a/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobuf_watchOS.xcconfig b/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobuf_watchOS.xcconfig deleted file mode 100644 index 199959f5a..000000000 --- a/SwiftProtobuf.xcodeproj/xcconfigs/SwiftProtobuf_watchOS.xcconfig +++ /dev/null @@ -1,11 +0,0 @@ -// Architectures -SDKROOT = watchos - -// Deployment -TARGETED_DEVICE_FAMILY = 4 - -// Packaging -INFOPLIST_FILE = SwiftProtobuf.xcodeproj/Protobuf_Info.plist -PRODUCT_BUNDLE_IDENTIFIER = org.swift.protobuf.SwiftProtobuf -PRODUCT_MODULE_NAME = SwiftProtobuf -PRODUCT_NAME = SwiftProtobuf diff --git a/SwiftProtobuf.xcodeproj/xcshareddata/xcschemes/SwiftProtobuf_iOS.xcscheme b/SwiftProtobuf.xcodeproj/xcshareddata/xcschemes/SwiftProtobuf_iOS.xcscheme deleted file mode 100644 index 8bde8a24a..000000000 --- a/SwiftProtobuf.xcodeproj/xcshareddata/xcschemes/SwiftProtobuf_iOS.xcscheme +++ /dev/null @@ -1,95 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/SwiftProtobuf.xcodeproj/xcshareddata/xcschemes/SwiftProtobuf_macOS.xcscheme b/SwiftProtobuf.xcodeproj/xcshareddata/xcschemes/SwiftProtobuf_macOS.xcscheme deleted file mode 100644 index 0f11685ab..000000000 --- a/SwiftProtobuf.xcodeproj/xcshareddata/xcschemes/SwiftProtobuf_macOS.xcscheme +++ /dev/null @@ -1,77 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/SwiftProtobuf.xcodeproj/xcshareddata/xcschemes/SwiftProtobuf_tvOS.xcscheme b/SwiftProtobuf.xcodeproj/xcshareddata/xcschemes/SwiftProtobuf_tvOS.xcscheme deleted file mode 100644 index 21e3cd3c9..000000000 --- a/SwiftProtobuf.xcodeproj/xcshareddata/xcschemes/SwiftProtobuf_tvOS.xcscheme +++ /dev/null @@ -1,95 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/SwiftProtobuf.xcodeproj/xcshareddata/xcschemes/SwiftProtobuf_watchOS.xcscheme b/SwiftProtobuf.xcodeproj/xcshareddata/xcschemes/SwiftProtobuf_watchOS.xcscheme deleted file mode 100644 index 10416293a..000000000 --- a/SwiftProtobuf.xcodeproj/xcshareddata/xcschemes/SwiftProtobuf_watchOS.xcscheme +++ /dev/null @@ -1,76 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/SwiftProtobuf.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist b/SwiftProtobuf.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist deleted file mode 100644 index 5772e109b..000000000 --- a/SwiftProtobuf.xcodeproj/xcshareddata/xcschemes/xcschememanagement.plist +++ /dev/null @@ -1,12 +0,0 @@ - - - - SchemeUserState - - SwiftProtobuf.xcscheme - - - SuppressBuildableAutocreation - - - diff --git a/Tests/LinuxMain.swift b/Tests/LinuxMain.swift deleted file mode 100644 index 54489099f..000000000 --- a/Tests/LinuxMain.swift +++ /dev/null @@ -1,1281 +0,0 @@ -// -// GENERATED FILE -// DO NOT EDIT -// swift-format-ignore-file -// - -import XCTest -@testable import SwiftProtobufTests -@testable import SwiftProtobufPluginLibraryTests - - -extension Test_Descriptor { - static var allTests = [ - ("testParsing", testParsing), - ("testLookup", testLookup), - ("testParents", testParents), - ("testFields", testFields), - ("testExtensions", testExtensions), - ("testExtensionRanges", testExtensionRanges) - ] -} - -extension Test_NamingUtils { - static var allTests = [ - ("testTypePrefix", testTypePrefix), - ("testPrefixStripper_strip", testPrefixStripper_strip), - ("testSanitize_messageName", testSanitize_messageName), - ("testSanitize_enumName", testSanitize_enumName), - ("testSanitize_oneofName", testSanitize_oneofName), - ("testSanitize_fieldName", testSanitize_fieldName), - ("testSanitize_enumCaseName", testSanitize_enumCaseName), - ("testSanitize_messageScopedExtensionName", testSanitize_messageScopedExtensionName), - ("testToCamelCase", testToCamelCase) - ] -} - -extension Test_ProtoFileToModuleMappings { - static var allTests = [ - ("test_Initialization", test_Initialization), - ("test_Initialization_InvalidConfigs", test_Initialization_InvalidConfigs), - ("test_moduleName_forFile", test_moduleName_forFile), - ("test_neededModules_forFile", test_neededModules_forFile), - ("test_neededModules_forFile_PublicImports", test_neededModules_forFile_PublicImports) - ] -} - -extension Test_SwiftLanguage { - static var allTests = [ - ("testIsValidSwiftIdentifier", testIsValidSwiftIdentifier), - ("testIsNotValidSwiftIdentifier", testIsNotValidSwiftIdentifier) - ] -} - -extension Test_SwiftProtobufNamer { - static var allTests = [ - ("testEnumValueHandling_AliasNameMatches", testEnumValueHandling_AliasNameMatches), - ("testEnumValueHandling_NameCollisions", testEnumValueHandling_NameCollisions), - ("testEnumValueHandling_NameCollisionsAndAliasMatches", testEnumValueHandling_NameCollisionsAndAliasMatches), - ("testEnumValueHandling_UniqueAliasNameCollisions", testEnumValueHandling_UniqueAliasNameCollisions) - ] -} - -extension Test_AllTypes { - static var allTests = [ - ("testEncoding_unknown", testEncoding_unknown), - ("testEncoding_optionalInt32", testEncoding_optionalInt32), - ("testEncoding_optionalInt64", testEncoding_optionalInt64), - ("testEncoding_optionalUint32", testEncoding_optionalUint32), - ("testEncoding_optionalUint64", testEncoding_optionalUint64), - ("testEncoding_optionalSint32", testEncoding_optionalSint32), - ("testEncoding_optionalSint64", testEncoding_optionalSint64), - ("testEncoding_optionalFixed32", testEncoding_optionalFixed32), - ("testEncoding_optionalFixed64", testEncoding_optionalFixed64), - ("testEncoding_optionalSfixed32", testEncoding_optionalSfixed32), - ("testEncoding_optionalSfixed64", testEncoding_optionalSfixed64), - ("testEncoding_optionalFloat", testEncoding_optionalFloat), - ("testEncoding_optionalDouble", testEncoding_optionalDouble), - ("testEncoding_optionalBool", testEncoding_optionalBool), - ("testEncoding_optionalString", testEncoding_optionalString), - ("testEncoding_optionalGroup", testEncoding_optionalGroup), - ("testEncoding_optionalBytes", testEncoding_optionalBytes), - ("testEncoding_optionalNestedMessage", testEncoding_optionalNestedMessage), - ("testEncoding_optionalNestedMessage_unknown1", testEncoding_optionalNestedMessage_unknown1), - ("testEncoding_optionalNestedMessage_unknown2", testEncoding_optionalNestedMessage_unknown2), - ("testEncoding_optionalNestedMessage_unknown3", testEncoding_optionalNestedMessage_unknown3), - ("testEncoding_optionalNestedMessage_unknown4", testEncoding_optionalNestedMessage_unknown4), - ("testEncoding_optionalForeignMessage", testEncoding_optionalForeignMessage), - ("testEncoding_optionalImportMessage", testEncoding_optionalImportMessage), - ("testEncoding_optionalNestedEnum", testEncoding_optionalNestedEnum), - ("testEncoding_optionalForeignEnum", testEncoding_optionalForeignEnum), - ("testEncoding_optionalImportEnum", testEncoding_optionalImportEnum), - ("testEncoding_optionalStringPiece", testEncoding_optionalStringPiece), - ("testEncoding_optionalCord", testEncoding_optionalCord), - ("testEncoding_optionalPublicImportMessage", testEncoding_optionalPublicImportMessage), - ("testEncoding_optionalLazyMessage", testEncoding_optionalLazyMessage), - ("testEncoding_repeatedInt32", testEncoding_repeatedInt32), - ("testEncoding_repeatedInt64", testEncoding_repeatedInt64), - ("testEncoding_repeatedUint32", testEncoding_repeatedUint32), - ("testEncoding_repeatedUint64", testEncoding_repeatedUint64), - ("testEncoding_repeatedSint32", testEncoding_repeatedSint32), - ("testEncoding_repeatedSint64", testEncoding_repeatedSint64), - ("testEncoding_repeatedFixed32", testEncoding_repeatedFixed32), - ("testEncoding_repeatedFixed64", testEncoding_repeatedFixed64), - ("testEncoding_repeatedSfixed32", testEncoding_repeatedSfixed32), - ("testEncoding_repeatedSfixed64", testEncoding_repeatedSfixed64), - ("testEncoding_repeatedFloat", testEncoding_repeatedFloat), - ("testEncoding_repeatedDouble", testEncoding_repeatedDouble), - ("testEncoding_repeatedBool", testEncoding_repeatedBool), - ("testEncoding_repeatedString", testEncoding_repeatedString), - ("testEncoding_repeatedBytes", testEncoding_repeatedBytes), - ("testEncoding_repeatedGroup", testEncoding_repeatedGroup), - ("testEncoding_repeatedNestedMessage", testEncoding_repeatedNestedMessage), - ("testEncoding_repeatedNestedMessage_unknown", testEncoding_repeatedNestedMessage_unknown), - ("testEncoding_repeatedNestedEnum", testEncoding_repeatedNestedEnum), - ("testEncoding_defaultInt32", testEncoding_defaultInt32), - ("testEncoding_defaultInt64", testEncoding_defaultInt64), - ("testEncoding_defaultUint32", testEncoding_defaultUint32), - ("testEncoding_defaultUint64", testEncoding_defaultUint64), - ("testEncoding_defaultSint32", testEncoding_defaultSint32), - ("testEncoding_defaultSint64", testEncoding_defaultSint64), - ("testEncoding_defaultFixed32", testEncoding_defaultFixed32), - ("testEncoding_defaultFixed64", testEncoding_defaultFixed64), - ("testEncoding_defaultSfixed32", testEncoding_defaultSfixed32), - ("testEncoding_defaultSfixed64", testEncoding_defaultSfixed64), - ("testEncoding_defaultFloat", testEncoding_defaultFloat), - ("testEncoding_defaultDouble", testEncoding_defaultDouble), - ("testEncoding_defaultBool", testEncoding_defaultBool), - ("testEncoding_defaultString", testEncoding_defaultString), - ("testEncoding_defaultBytes", testEncoding_defaultBytes), - ("testEncoding_defaultNestedEnum", testEncoding_defaultNestedEnum), - ("testEncoding_defaultForeignEnum", testEncoding_defaultForeignEnum), - ("testEncoding_defaultImportEnum", testEncoding_defaultImportEnum), - ("testEncoding_defaultStringPiece", testEncoding_defaultStringPiece), - ("testEncoding_defaultCord", testEncoding_defaultCord), - ("testEncoding_oneofUint32", testEncoding_oneofUint32), - ("testEncoding_oneofNestedMessage", testEncoding_oneofNestedMessage), - ("testEncoding_oneofNestedMessage1", testEncoding_oneofNestedMessage1), - ("testEncoding_oneofNestedMessage2", testEncoding_oneofNestedMessage2), - ("testEncoding_oneofNestedMessage9", testEncoding_oneofNestedMessage9), - ("testEncoding_oneofString", testEncoding_oneofString), - ("testEncoding_oneofBytes", testEncoding_oneofBytes), - ("testEncoding_oneofBytes2", testEncoding_oneofBytes2), - ("testEncoding_oneofBytes3", testEncoding_oneofBytes3), - ("testEncoding_oneofBytes4", testEncoding_oneofBytes4), - ("testEncoding_oneofBytes5", testEncoding_oneofBytes5), - ("testEncoding_oneofBytes_failures", testEncoding_oneofBytes_failures), - ("testEncoding_oneofBytes_debugDescription", testEncoding_oneofBytes_debugDescription), - ("testDebugDescription", testDebugDescription), - ("testDebugDescription2", testDebugDescription2), - ("testDebugDescription3", testDebugDescription3), - ("testDebugDescription4", testDebugDescription4), - ("testWithFactoryHelper", testWithFactoryHelper), - ("testWithFactoryHelperRethrows", testWithFactoryHelperRethrows), - ("testUnknownFields_Success", testUnknownFields_Success), - ("testUnknownFields_Failures", testUnknownFields_Failures) - ] -} - -extension Test_AllTypes_Proto3 { - static var allTests = [ - ("testEncoding_optionalInt32", testEncoding_optionalInt32), - ("testEncoding_optionalInt64", testEncoding_optionalInt64), - ("testEncoding_optionalUint32", testEncoding_optionalUint32), - ("testEncoding_optionalUint64", testEncoding_optionalUint64), - ("testEncoding_optionalSint32", testEncoding_optionalSint32), - ("testEncoding_optionalSint64", testEncoding_optionalSint64), - ("testEncoding_optionalFixed32", testEncoding_optionalFixed32), - ("testEncoding_optionalFixed64", testEncoding_optionalFixed64), - ("testEncoding_optionalSfixed32", testEncoding_optionalSfixed32), - ("testEncoding_optionalSfixed64", testEncoding_optionalSfixed64), - ("testEncoding_optionalFloat", testEncoding_optionalFloat), - ("testEncoding_optionalDouble", testEncoding_optionalDouble), - ("testEncoding_optionalBool", testEncoding_optionalBool), - ("testEncoding_optionalString", testEncoding_optionalString), - ("testEncoding_optionalBytes", testEncoding_optionalBytes), - ("testEncoding_optionalNestedMessage", testEncoding_optionalNestedMessage), - ("testEncoding_optionalForeignMessage", testEncoding_optionalForeignMessage), - ("testEncoding_optionalImportMessage", testEncoding_optionalImportMessage), - ("testEncoding_optionalNestedEnum", testEncoding_optionalNestedEnum), - ("testEncoding_optionalForeignEnum", testEncoding_optionalForeignEnum), - ("testEncoding_repeatedInt32", testEncoding_repeatedInt32), - ("testEncoding_repeatedInt64", testEncoding_repeatedInt64), - ("testEncoding_repeatedUint32", testEncoding_repeatedUint32), - ("testEncoding_repeatedUint64", testEncoding_repeatedUint64), - ("testEncoding_repeatedSint32", testEncoding_repeatedSint32), - ("testEncoding_repeatedSint64", testEncoding_repeatedSint64), - ("testEncoding_repeatedFixed32", testEncoding_repeatedFixed32), - ("testEncoding_repeatedFixed64", testEncoding_repeatedFixed64), - ("testEncoding_repeatedSfixed32", testEncoding_repeatedSfixed32), - ("testEncoding_repeatedSfixed64", testEncoding_repeatedSfixed64), - ("testEncoding_repeatedFloat", testEncoding_repeatedFloat), - ("testEncoding_repeatedDouble", testEncoding_repeatedDouble), - ("testEncoding_repeatedBool", testEncoding_repeatedBool), - ("testEncoding_repeatedString", testEncoding_repeatedString), - ("testEncoding_repeatedBytes", testEncoding_repeatedBytes), - ("testEncoding_repeatedNestedMessage", testEncoding_repeatedNestedMessage), - ("testEncoding_repeatedNestedEnum", testEncoding_repeatedNestedEnum), - ("testEncoding_oneofUint32", testEncoding_oneofUint32), - ("testEncoding_oneofNestedMessage", testEncoding_oneofNestedMessage), - ("testEncoding_oneofNestedMessage1", testEncoding_oneofNestedMessage1), - ("testEncoding_oneofNestedMessage2", testEncoding_oneofNestedMessage2), - ("testEncoding_oneofNestedMessage9", testEncoding_oneofNestedMessage9), - ("testEncoding_oneofString", testEncoding_oneofString), - ("testEncoding_oneofBytes", testEncoding_oneofBytes), - ("testEncoding_oneofBytes2", testEncoding_oneofBytes2), - ("testEncoding_oneofBytes3", testEncoding_oneofBytes3), - ("testEncoding_oneofBytes4", testEncoding_oneofBytes4), - ("testEncoding_oneofBytes5", testEncoding_oneofBytes5), - ("testEncoding_oneofBytes_failures", testEncoding_oneofBytes_failures), - ("testEncoding_oneofBytes_debugDescription", testEncoding_oneofBytes_debugDescription), - ("testDebugDescription", testDebugDescription), - ("testDebugDescription2", testDebugDescription2), - ("testDebugDescription3", testDebugDescription3) - ] -} - -extension Test_AllTypes_Proto3_Optional { - static var allTests = [ - ("testEncoding_optionalInt32", testEncoding_optionalInt32), - ("testEncoding_optionalInt64", testEncoding_optionalInt64), - ("testEncoding_optionalUint32", testEncoding_optionalUint32), - ("testEncoding_optionalUint64", testEncoding_optionalUint64), - ("testEncoding_optionalSint32", testEncoding_optionalSint32), - ("testEncoding_optionalSint64", testEncoding_optionalSint64), - ("testEncoding_optionalFixed32", testEncoding_optionalFixed32), - ("testEncoding_optionalFixed64", testEncoding_optionalFixed64), - ("testEncoding_optionalSfixed32", testEncoding_optionalSfixed32), - ("testEncoding_optionalSfixed64", testEncoding_optionalSfixed64), - ("testEncoding_optionalFloat", testEncoding_optionalFloat), - ("testEncoding_optionalDouble", testEncoding_optionalDouble), - ("testEncoding_optionalBool", testEncoding_optionalBool), - ("testEncoding_optionalString", testEncoding_optionalString), - ("testEncoding_optionalBytes", testEncoding_optionalBytes), - ("testEncoding_optionalCord", testEncoding_optionalCord), - ("testEncoding_optionalNestedMessage", testEncoding_optionalNestedMessage), - ("testEncoding_lazyNestedMessage", testEncoding_lazyNestedMessage), - ("testEncoding_optionalNestedEnum", testEncoding_optionalNestedEnum) - ] -} - -extension Test_Any { - static var allTests = [ - ("test_Any", test_Any), - ("test_Any_different_prefix", test_Any_different_prefix), - ("test_Any_noprefix", test_Any_noprefix), - ("test_Any_shortesttype", test_Any_shortesttype), - ("test_Any_UserMessage", test_Any_UserMessage), - ("test_Any_UnknownUserMessage_JSON", test_Any_UnknownUserMessage_JSON), - ("test_Any_UnknownUserMessage_protobuf", test_Any_UnknownUserMessage_protobuf), - ("test_Any_Any", test_Any_Any), - ("test_Any_recursive", test_Any_recursive), - ("test_Any_Duration_JSON_roundtrip", test_Any_Duration_JSON_roundtrip), - ("test_Any_Duration_transcode", test_Any_Duration_transcode), - ("test_Any_FieldMask_JSON_roundtrip", test_Any_FieldMask_JSON_roundtrip), - ("test_Any_FieldMask_transcode", test_Any_FieldMask_transcode), - ("test_Any_Int32Value_JSON_roundtrip", test_Any_Int32Value_JSON_roundtrip), - ("test_Any_Int32Value_transcode", test_Any_Int32Value_transcode), - ("test_Any_Struct_JSON_roundtrip", test_Any_Struct_JSON_roundtrip), - ("test_Any_Struct_transcode", test_Any_Struct_transcode), - ("test_Any_Timestamp_JSON_roundtrip", test_Any_Timestamp_JSON_roundtrip), - ("test_Any_Timestamp_transcode", test_Any_Timestamp_transcode), - ("test_Any_ListValue_JSON_roundtrip", test_Any_ListValue_JSON_roundtrip), - ("test_Any_ListValue_transcode", test_Any_ListValue_transcode), - ("test_Any_Value_struct_JSON_roundtrip", test_Any_Value_struct_JSON_roundtrip), - ("test_Any_Value_struct_transcode", test_Any_Value_struct_transcode), - ("test_Any_Value_int_JSON_roundtrip", test_Any_Value_int_JSON_roundtrip), - ("test_Any_Value_int_transcode", test_Any_Value_int_transcode), - ("test_Any_Value_string_JSON_roundtrip", test_Any_Value_string_JSON_roundtrip), - ("test_Any_Value_string_transcode", test_Any_Value_string_transcode), - ("test_Any_OddTypeURL_FromValue", test_Any_OddTypeURL_FromValue), - ("test_Any_OddTypeURL_FromMessage", test_Any_OddTypeURL_FromMessage), - ("test_Any_JSON_Extensions", test_Any_JSON_Extensions), - ("test_Any_WKT_UnknownFields", test_Any_WKT_UnknownFields), - ("test_Any_empty", test_Any_empty), - ("test_Any_nestedList", test_Any_nestedList), - ("test_IsA", test_IsA), - ("test_Any_Registry", test_Any_Registry) - ] -} - -extension Test_Api { - static var allTests = [ - ("testExists", testExists), - ("testInitializer", testInitializer) - ] -} - -extension Test_BasicFields_Access_Proto2 { - static var allTests = [ - ("testOptionalInt32", testOptionalInt32), - ("testOptionalInt64", testOptionalInt64), - ("testOptionalUint32", testOptionalUint32), - ("testOptionalUint64", testOptionalUint64), - ("testOptionalSint32", testOptionalSint32), - ("testOptionalSint64", testOptionalSint64), - ("testOptionalFixed32", testOptionalFixed32), - ("testOptionalFixed64", testOptionalFixed64), - ("testOptionalSfixed32", testOptionalSfixed32), - ("testOptionalSfixed64", testOptionalSfixed64), - ("testOptionalFloat", testOptionalFloat), - ("testOptionalDouble", testOptionalDouble), - ("testOptionalBool", testOptionalBool), - ("testOptionalString", testOptionalString), - ("testOptionalBytes", testOptionalBytes), - ("testOptionalGroup", testOptionalGroup), - ("testOptionalNestedMessage", testOptionalNestedMessage), - ("testOptionalForeignMessage", testOptionalForeignMessage), - ("testOptionalImportMessage", testOptionalImportMessage), - ("testOptionalNestedEnum", testOptionalNestedEnum), - ("testOptionalForeignEnum", testOptionalForeignEnum), - ("testOptionalImportEnum", testOptionalImportEnum), - ("testOptionalStringPiece", testOptionalStringPiece), - ("testOptionalCord", testOptionalCord), - ("testOptionalPublicImportMessage", testOptionalPublicImportMessage), - ("testOptionalLazyMessage", testOptionalLazyMessage), - ("testDefaultInt32", testDefaultInt32), - ("testDefaultInt64", testDefaultInt64), - ("testDefaultUint32", testDefaultUint32), - ("testDefaultUint64", testDefaultUint64), - ("testDefaultSint32", testDefaultSint32), - ("testDefaultSint64", testDefaultSint64), - ("testDefaultFixed32", testDefaultFixed32), - ("testDefaultFixed64", testDefaultFixed64), - ("testDefaultSfixed32", testDefaultSfixed32), - ("testDefaultSfixed64", testDefaultSfixed64), - ("testDefaultFloat", testDefaultFloat), - ("testDefaultDouble", testDefaultDouble), - ("testDefaultBool", testDefaultBool), - ("testDefaultString", testDefaultString), - ("testDefaultBytes", testDefaultBytes), - ("testDefaultNestedEnum", testDefaultNestedEnum), - ("testDefaultForeignEnum", testDefaultForeignEnum), - ("testDefaultImportEnum", testDefaultImportEnum), - ("testDefaultStringPiece", testDefaultStringPiece), - ("testDefaultCord", testDefaultCord), - ("testRepeatedInt32", testRepeatedInt32), - ("testRepeatedInt64", testRepeatedInt64), - ("testRepeatedUint32", testRepeatedUint32), - ("testRepeatedUint64", testRepeatedUint64), - ("testRepeatedSint32", testRepeatedSint32), - ("testRepeatedSint64", testRepeatedSint64), - ("testRepeatedFixed32", testRepeatedFixed32), - ("testRepeatedFixed64", testRepeatedFixed64), - ("testRepeatedSfixed32", testRepeatedSfixed32), - ("testRepeatedSfixed64", testRepeatedSfixed64), - ("testRepeatedFloat", testRepeatedFloat), - ("testRepeatedDouble", testRepeatedDouble), - ("testRepeatedBool", testRepeatedBool), - ("testRepeatedString", testRepeatedString), - ("testRepeatedBytes", testRepeatedBytes), - ("testRepeatedGroup", testRepeatedGroup), - ("testRepeatedNestedMessage", testRepeatedNestedMessage), - ("testRepeatedForeignMessage", testRepeatedForeignMessage), - ("testRepeatedImportMessage", testRepeatedImportMessage), - ("testRepeatedNestedEnum", testRepeatedNestedEnum), - ("testRepeatedForeignEnum", testRepeatedForeignEnum), - ("testRepeatedImportEnum", testRepeatedImportEnum), - ("testRepeatedStringPiece", testRepeatedStringPiece), - ("testRepeatedCord", testRepeatedCord), - ("testRepeatedLazyMessage", testRepeatedLazyMessage) - ] -} - -extension Test_BasicFields_Access_Proto3 { - static var allTests = [ - ("testOptionalInt32", testOptionalInt32), - ("testOptionalInt64", testOptionalInt64), - ("testOptionalUint32", testOptionalUint32), - ("testOptionalUint64", testOptionalUint64), - ("testOptionalSint32", testOptionalSint32), - ("testOptionalSint64", testOptionalSint64), - ("testOptionalFixed32", testOptionalFixed32), - ("testOptionalFixed64", testOptionalFixed64), - ("testOptionalSfixed32", testOptionalSfixed32), - ("testOptionalSfixed64", testOptionalSfixed64), - ("testOptionalFloat", testOptionalFloat), - ("testOptionalDouble", testOptionalDouble), - ("testOptionalBool", testOptionalBool), - ("testOptionalString", testOptionalString), - ("testOptionalBytes", testOptionalBytes), - ("testOptionalNestedMessage", testOptionalNestedMessage), - ("testOptionalForeignMessage", testOptionalForeignMessage), - ("testOptionalImportMessage", testOptionalImportMessage), - ("testOptionalNestedEnum", testOptionalNestedEnum), - ("testOptionalForeignEnum", testOptionalForeignEnum), - ("testOptionalPublicImportMessage", testOptionalPublicImportMessage), - ("testRepeatedInt32", testRepeatedInt32), - ("testRepeatedInt64", testRepeatedInt64), - ("testRepeatedUint32", testRepeatedUint32), - ("testRepeatedUint64", testRepeatedUint64), - ("testRepeatedSint32", testRepeatedSint32), - ("testRepeatedSint64", testRepeatedSint64), - ("testRepeatedFixed32", testRepeatedFixed32), - ("testRepeatedFixed64", testRepeatedFixed64), - ("testRepeatedSfixed32", testRepeatedSfixed32), - ("testRepeatedSfixed64", testRepeatedSfixed64), - ("testRepeatedFloat", testRepeatedFloat), - ("testRepeatedDouble", testRepeatedDouble), - ("testRepeatedBool", testRepeatedBool), - ("testRepeatedString", testRepeatedString), - ("testRepeatedBytes", testRepeatedBytes), - ("testRepeatedNestedMessage", testRepeatedNestedMessage), - ("testRepeatedForeignMessage", testRepeatedForeignMessage), - ("testRepeatedImportMessage", testRepeatedImportMessage), - ("testRepeatedNestedEnum", testRepeatedNestedEnum), - ("testRepeatedForeignEnum", testRepeatedForeignEnum) - ] -} - -extension Test_BinaryDecodingOptions { - static var allTests = [ - ("testMessageDepthLimit", testMessageDepthLimit), - ("testDiscaringUnknownFields", testDiscaringUnknownFields) - ] -} - -extension Test_BinaryDelimited { - static var allTests = [ - ("testEverything", testEverything) - ] -} - -extension Test_Conformance { - static var allTests = [ - ("testFieldNaming", testFieldNaming), - ("testFieldNaming_protoNames", testFieldNaming_protoNames), - ("testFieldNaming_escapeInName", testFieldNaming_escapeInName), - ("testInt32_min_roundtrip", testInt32_min_roundtrip), - ("testInt32_toosmall", testInt32_toosmall), - ("testRepeatedBoolWrapper", testRepeatedBoolWrapper), - ("testString_unicodeEscape", testString_unicodeEscape), - ("testString_surrogates", testString_surrogates), - ("testBytes_unicodeEscape", testBytes_unicodeEscape), - ("testBytes_surrogates", testBytes_surrogates), - ("test_LiteralIncludeLF", test_LiteralIncludeLF), - ("testMaps_TextFormatKeysSorted", testMaps_TextFormatKeysSorted) - ] -} - -extension Test_Duration { - static var allTests = [ - ("testJSON_encode", testJSON_encode), - ("testJSON_decode", testJSON_decode), - ("testSerializationFailure", testSerializationFailure), - ("testJSON_durationField", testJSON_durationField), - ("testFieldMember", testFieldMember), - ("testTranscode", testTranscode), - ("testConformance", testConformance), - ("testBasicArithmetic", testBasicArithmetic), - ("testArithmeticNormalizes", testArithmeticNormalizes), - ("testFloatLiteralConvertible", testFloatLiteralConvertible), - ("testInitializationByTimeIntervals", testInitializationByTimeIntervals), - ("testGetters", testGetters) - ] -} - -extension Test_Empty { - static var allTests = [ - ("testExists", testExists) - ] -} - -extension Test_Enum { - static var allTests = [ - ("testEqual", testEqual), - ("testJSONsingular", testJSONsingular), - ("testJSONrepeated", testJSONrepeated), - ("testUnknownValues", testUnknownValues), - ("testEnumPrefixStripping", testEnumPrefixStripping), - ("testEnumPrefixStripping_TextFormat", testEnumPrefixStripping_TextFormat), - ("testEnumPrefixStripping_JSON", testEnumPrefixStripping_JSON), - ("testCaseIterable", testCaseIterable) - ] -} - -extension Test_EnumWithAliases { - static var allTests = [ - ("testJSONEncodeUsesOriginalNames", testJSONEncodeUsesOriginalNames), - ("testJSONDecodeAcceptsAllNames", testJSONDecodeAcceptsAllNames), - ("testTextFormatEncodeUsesOriginalNames", testTextFormatEncodeUsesOriginalNames), - ("testTextFormatDecodeAcceptsAllNames", testTextFormatDecodeAcceptsAllNames) - ] -} - -extension Test_Enum_Proto2 { - static var allTests = [ - ("testEqual", testEqual), - ("testUnknownIgnored", testUnknownIgnored), - ("testJSONsingular", testJSONsingular), - ("testJSONrepeated", testJSONrepeated), - ("testUnknownValues", testUnknownValues), - ("testEnumPrefixStripping", testEnumPrefixStripping), - ("testEnumPrefixStripping_TextFormat", testEnumPrefixStripping_TextFormat), - ("testEnumPrefixStripping_JSON", testEnumPrefixStripping_JSON), - ("testCaseIterable", testCaseIterable) - ] -} - -extension Test_Extensions { - static var allTests = [ - ("test_optionalInt32Extension", test_optionalInt32Extension), - ("test_extensionMessageSpecificity", test_extensionMessageSpecificity), - ("test_optionalStringExtension", test_optionalStringExtension), - ("test_repeatedInt32Extension", test_repeatedInt32Extension), - ("test_defaultInt32Extension", test_defaultInt32Extension), - ("test_groupExtension", test_groupExtension), - ("test_repeatedGroupExtension", test_repeatedGroupExtension), - ("test_MessageNoStorageClass", test_MessageNoStorageClass), - ("test_MessageUsingStorageClass", test_MessageUsingStorageClass) - ] -} - -extension Test_ExtremeDefaultValues { - static var allTests = [ - ("test_escapedBytes", test_escapedBytes), - ("test_largeUint32", test_largeUint32), - ("test_largeUint64", test_largeUint64), - ("test_smallInt32", test_smallInt32), - ("test_smallInt64", test_smallInt64), - ("test_reallySmallInt32", test_reallySmallInt32), - ("test_reallySmallInt64", test_reallySmallInt64), - ("test_utf8String", test_utf8String), - ("test_zeroFloat", test_zeroFloat), - ("test_oneFloat", test_oneFloat), - ("test_smallFloat", test_smallFloat), - ("test_negativeOneFloat", test_negativeOneFloat), - ("test_negativeFloat", test_negativeFloat), - ("test_largeFloat", test_largeFloat), - ("test_smallNegativeFloat", test_smallNegativeFloat), - ("test_infDouble", test_infDouble), - ("test_negInfDouble", test_negInfDouble), - ("test_nanDouble", test_nanDouble), - ("test_infFloat", test_infFloat), - ("test_negInfFloat", test_negInfFloat), - ("test_nanFloat", test_nanFloat), - ("test_cppTrigraph", test_cppTrigraph), - ("test_stringWithZero", test_stringWithZero), - ("test_bytesWithZero", test_bytesWithZero), - ("test_stringPieceWithZero", test_stringPieceWithZero), - ("test_cordWithZero", test_cordWithZero), - ("test_replacementString", test_replacementString) - ] -} - -extension Test_FieldMask { - static var allTests = [ - ("testJSON", testJSON), - ("testProtobuf", testProtobuf), - ("testDebugDescription", testDebugDescription), - ("testConvenienceInits", testConvenienceInits), - ("testJSON_field", testJSON_field), - ("testSerializationFailure", testSerializationFailure) - ] -} - -extension Test_FieldOrdering { - static var allTests = [ - ("test_FieldOrdering", test_FieldOrdering) - ] -} - -extension Test_FuzzTests { - static var allTests = [ - ("test_Binary", test_Binary), - ("test_JSON", test_JSON), - ("test_TextFormat", test_TextFormat) - ] -} - -extension Test_GroupWithinGroup { - static var allTests = [ - ("testGroupWithGroup_Single", testGroupWithGroup_Single), - ("testGroupWithGroup_Repeated", testGroupWithGroup_Repeated) - ] -} - -extension Test_JSON { - static var allTests = [ - ("testMultipleFields", testMultipleFields), - ("testTruncation", testTruncation), - ("testOptionalInt32", testOptionalInt32), - ("testOptionalUInt32", testOptionalUInt32), - ("testOptionalInt64", testOptionalInt64), - ("testOptionalUInt64", testOptionalUInt64), - ("testOptionalDouble", testOptionalDouble), - ("testOptionalFloat", testOptionalFloat), - ("testOptionalDouble_NaN", testOptionalDouble_NaN), - ("testOptionalFloat_NaN", testOptionalFloat_NaN), - ("testOptionalDouble_roundtrip", testOptionalDouble_roundtrip), - ("testOptionalFloat_roundtrip", testOptionalFloat_roundtrip), - ("testOptionalBool", testOptionalBool), - ("testOptionalString", testOptionalString), - ("testOptionalString_controlCharacters", testOptionalString_controlCharacters), - ("testOptionalBytes", testOptionalBytes), - ("testOptionalBytes_escapes", testOptionalBytes_escapes), - ("testOptionalBytes_roundtrip", testOptionalBytes_roundtrip), - ("testOptionalNestedMessage", testOptionalNestedMessage), - ("testOptionalNestedEnum", testOptionalNestedEnum), - ("testRepeatedInt32", testRepeatedInt32), - ("testRepeatedString", testRepeatedString), - ("testRepeatedNestedMessage", testRepeatedNestedMessage), - ("testRepeatedEnum", testRepeatedEnum), - ("testOneof", testOneof), - ("testEmptyMessage", testEmptyMessage) - ] -} - -extension Test_JSONPacked { - static var allTests = [ - ("testPackedFloat", testPackedFloat), - ("testPackedDouble", testPackedDouble), - ("testPackedInt32", testPackedInt32), - ("testPackedInt64", testPackedInt64), - ("testPackedUInt32", testPackedUInt32), - ("testPackedUInt64", testPackedUInt64), - ("testPackedSInt32", testPackedSInt32), - ("testPackedSInt64", testPackedSInt64), - ("testPackedFixed32", testPackedFixed32), - ("testPackedFixed64", testPackedFixed64), - ("testPackedSFixed32", testPackedSFixed32), - ("testPackedSFixed64", testPackedSFixed64), - ("testPackedBool", testPackedBool) - ] -} - -extension Test_JSONrepeated { - static var allTests = [ - ("testPackedInt32", testPackedInt32) - ] -} - -extension Test_JSONDecodingOptions { - static var allTests = [ - ("testMessageDepthLimit", testMessageDepthLimit), - ("testIgnoreUnknownFields", testIgnoreUnknownFields) - ] -} - -extension Test_JSONEncodingOptions { - static var allTests = [ - ("testAlwaysPrintEnumsAsInts", testAlwaysPrintEnumsAsInts), - ("testPreserveProtoFieldNames", testPreserveProtoFieldNames) - ] -} - -extension Test_JSON_Array { - static var allTests = [ - ("testTwoObjectsWithMultipleFields", testTwoObjectsWithMultipleFields), - ("testRepeatedNestedMessage", testRepeatedNestedMessage) - ] -} - -extension Test_JSON_Conformance { - static var allTests = [ - ("testNullSupport_regularTypes", testNullSupport_regularTypes), - ("testNullSupport_wellKnownTypes", testNullSupport_wellKnownTypes), - ("testNullSupport_Value", testNullSupport_Value), - ("testNullSupport_optionalNullValue", testNullSupport_optionalNullValue), - ("testNullSupport_oneofNullValue", testNullSupport_oneofNullValue), - ("testNullSupport_oneofNullValue_alternate", testNullSupport_oneofNullValue_alternate), - ("testNullSupport_oneofNullValue_numeric", testNullSupport_oneofNullValue_numeric), - ("testNullSupport_repeatedNullValue", testNullSupport_repeatedNullValue), - ("testNullSupport_Repeated", testNullSupport_Repeated), - ("testNullSupport_RepeatedValue", testNullSupport_RepeatedValue), - ("testNullConformance", testNullConformance), - ("testValueList", testValueList), - ("testNestedAny", testNestedAny) - ] -} - -extension Test_JSON_Extensions { - static var allTests = [ - ("test_optionalInt32Extension", test_optionalInt32Extension), - ("test_optionalMessageExtension", test_optionalMessageExtension), - ("test_repeatedInt32Extension", test_repeatedInt32Extension), - ("test_repeatedMessageExtension", test_repeatedMessageExtension), - ("test_optionalStringExtensionWithDefault", test_optionalStringExtensionWithDefault), - ("test_ArrayWithExtensions", test_ArrayWithExtensions) - ] -} - -extension Test_JSON_RecursiveNested_Extensions { - static var allTests = [ - ("test_nestedMessage", test_nestedMessage) - ] -} - -extension Test_JSON_Group { - static var allTests = [ - ("testOptionalGroup", testOptionalGroup), - ("testRepeatedGroup", testRepeatedGroup) - ] -} - -extension Test_Map { - static var allTests = [ - ("test_mapInt32Int32", test_mapInt32Int32), - ("test_mapInt64Int64", test_mapInt64Int64), - ("test_mapUint32Uint32", test_mapUint32Uint32), - ("test_mapUint64Uint64", test_mapUint64Uint64), - ("test_mapSint32Sint32", test_mapSint32Sint32), - ("test_mapSint64Sint64", test_mapSint64Sint64), - ("test_mapFixed32Fixed32", test_mapFixed32Fixed32), - ("test_mapFixed64Fixed64", test_mapFixed64Fixed64), - ("test_mapSfixed32Sfixed32", test_mapSfixed32Sfixed32), - ("test_mapSfixed64Sfixed64", test_mapSfixed64Sfixed64), - ("test_mapInt32Float", test_mapInt32Float), - ("test_mapInt32Double", test_mapInt32Double), - ("test_mapBoolBool", test_mapBoolBool), - ("test_mapStringString", test_mapStringString), - ("test_mapInt32Bytes", test_mapInt32Bytes), - ("test_mapInt32Enum", test_mapInt32Enum), - ("test_mapInt32ForeignMessage", test_mapInt32ForeignMessage), - ("test_mapStringForeignMessage", test_mapStringForeignMessage), - ("test_mapEnumUnknowns_Proto2", test_mapEnumUnknowns_Proto2), - ("test_mapEnumUnknowns_Proto3", test_mapEnumUnknowns_Proto3) - ] -} - -extension Test_MapFields_Access_Proto2 { - static var allTests = [ - ("testMapInt32Int32", testMapInt32Int32), - ("testMapInt64Int64", testMapInt64Int64), - ("testMapUint32Uint32", testMapUint32Uint32), - ("testMapUint64Uint64", testMapUint64Uint64), - ("testMapSint32Sint32", testMapSint32Sint32), - ("testMapSint64Sint64", testMapSint64Sint64), - ("testMapFixed32Fixed32", testMapFixed32Fixed32), - ("testMapFixed64Fixed64", testMapFixed64Fixed64), - ("testMapSfixed32Sfixed32", testMapSfixed32Sfixed32), - ("testMapSfixed64Sfixed64", testMapSfixed64Sfixed64), - ("testMapInt32Float", testMapInt32Float), - ("testMapInt32Double", testMapInt32Double), - ("testMapBoolBool", testMapBoolBool), - ("testMapStringString", testMapStringString), - ("testMapStringBytes", testMapStringBytes), - ("testMapStringMessage", testMapStringMessage), - ("testMapInt32Bytes", testMapInt32Bytes), - ("testMapInt32Enum", testMapInt32Enum), - ("testMapInt32Message", testMapInt32Message) - ] -} - -extension Test_MapFields_Access_Proto3 { - static var allTests = [ - ("testMapInt32Int32", testMapInt32Int32), - ("testMapInt64Int64", testMapInt64Int64), - ("testMapUint32Uint32", testMapUint32Uint32), - ("testMapUint64Uint64", testMapUint64Uint64), - ("testMapSint32Sint32", testMapSint32Sint32), - ("testMapSint64Sint64", testMapSint64Sint64), - ("testMapFixed32Fixed32", testMapFixed32Fixed32), - ("testMapFixed64Fixed64", testMapFixed64Fixed64), - ("testMapSfixed32Sfixed32", testMapSfixed32Sfixed32), - ("testMapSfixed64Sfixed64", testMapSfixed64Sfixed64), - ("testMapInt32Float", testMapInt32Float), - ("testMapInt32Double", testMapInt32Double), - ("testMapBoolBool", testMapBoolBool), - ("testMapStringString", testMapStringString), - ("testMapStringBytes", testMapStringBytes), - ("testMapStringMessage", testMapStringMessage), - ("testMapInt32Bytes", testMapInt32Bytes), - ("testMapInt32Enum", testMapInt32Enum), - ("testMapInt32Message", testMapInt32Message) - ] -} - -extension Test_Map_JSON { - static var allTests = [ - ("testMapInt32Int32", testMapInt32Int32), - ("testMapInt64Int64", testMapInt64Int64), - ("testMapUInt32UInt32", testMapUInt32UInt32), - ("testMapUInt64UInt64", testMapUInt64UInt64), - ("testMapSInt32SInt32", testMapSInt32SInt32), - ("testMapSInt64SInt64", testMapSInt64SInt64), - ("testFixed32Fixed32", testFixed32Fixed32), - ("testFixed64Fixed64", testFixed64Fixed64), - ("testSFixed32SFixed32", testSFixed32SFixed32), - ("testSFixed64SFixed64", testSFixed64SFixed64), - ("test_mapInt32Float", test_mapInt32Float), - ("test_mapInt32Double", test_mapInt32Double), - ("test_mapBoolBool", test_mapBoolBool), - ("testMapStringString", testMapStringString), - ("testMapInt32Bytes", testMapInt32Bytes), - ("testMapInt32Enum", testMapInt32Enum), - ("testMapInt32Message", testMapInt32Message) - ] -} - -extension Test_Merge { - static var allTests = [ - ("testMergeSimple", testMergeSimple), - ("testMergePreservesValueSemantics", testMergePreservesValueSemantics) - ] -} - -extension Test_MessageSet { - static var allTests = [ - ("testSerialize", testSerialize), - ("testParse", testParse), - ("testTextFormat_Serialize", testTextFormat_Serialize), - ("testTextFormat_Parse", testTextFormat_Parse) - ] -} - -extension Test_PackageMapping { - static var allTests = [ - ("testPackageStartingWithNumber", testPackageStartingWithNumber) - ] -} - -extension Test_FieldNamingInitials { - static var allTests = [ - ("testHidingFunctions", testHidingFunctions), - ("testLowers", testLowers), - ("testUppers", testUppers), - ("testWordCase", testWordCase) - ] -} - -extension Test_ExtensionNamingInitials_MessageScoped { - static var allTests = [ - ("testLowers", testLowers), - ("testUppers", testUppers), - ("testWordCase", testWordCase) - ] -} - -extension Test_ExtensionNamingInitials_GlobalScoped { - static var allTests = [ - ("testLowers", testLowers), - ("testUppers", testUppers), - ("testWordCase", testWordCase) - ] -} - -extension Test_ExtensionNamingInitials_GlobalScoped_NoPrefix { - static var allTests = [ - ("testLowers", testLowers), - ("testUppers", testUppers), - ("testWordCase", testWordCase) - ] -} - -extension Test_ValidIdentifiers { - static var allTests = [ - ("testFieldNames", testFieldNames), - ("testOneofNames", testOneofNames), - ("testEnumCaseNames", testEnumCaseNames) - ] -} - -extension Test_OneofFields_Access_Proto2 { - static var allTests = [ - ("testOneofInt32", testOneofInt32), - ("testOneofInt64", testOneofInt64), - ("testOneofUint32", testOneofUint32), - ("testOneofUint64", testOneofUint64), - ("testOneofSint32", testOneofSint32), - ("testOneofSint64", testOneofSint64), - ("testOneofFixed32", testOneofFixed32), - ("testOneofFixed64", testOneofFixed64), - ("testOneofSfixed32", testOneofSfixed32), - ("testOneofSfixed64", testOneofSfixed64), - ("testOneofFloat", testOneofFloat), - ("testOneofDouble", testOneofDouble), - ("testOneofBool", testOneofBool), - ("testOneofString", testOneofString), - ("testOneofBytes", testOneofBytes), - ("testOneofGroup", testOneofGroup), - ("testOneofMessage", testOneofMessage), - ("testOneofEnum", testOneofEnum), - ("testOneofOnlyOneSet", testOneofOnlyOneSet) - ] -} - -extension Test_OneofFields_Access_Proto3 { - static var allTests = [ - ("testOneofInt32", testOneofInt32), - ("testOneofInt64", testOneofInt64), - ("testOneofUint32", testOneofUint32), - ("testOneofUint64", testOneofUint64), - ("testOneofSint32", testOneofSint32), - ("testOneofSint64", testOneofSint64), - ("testOneofFixed32", testOneofFixed32), - ("testOneofFixed64", testOneofFixed64), - ("testOneofSfixed32", testOneofSfixed32), - ("testOneofSfixed64", testOneofSfixed64), - ("testOneofFloat", testOneofFloat), - ("testOneofDouble", testOneofDouble), - ("testOneofBool", testOneofBool), - ("testOneofString", testOneofString), - ("testOneofBytes", testOneofBytes), - ("testOneofMessage", testOneofMessage), - ("testOneofEnum", testOneofEnum), - ("testOneofOnlyOneSet", testOneofOnlyOneSet) - ] -} - -extension Test_Packed { - static var allTests = [ - ("testEncoding_packedInt32", testEncoding_packedInt32), - ("testEncoding_packedInt64", testEncoding_packedInt64), - ("testEncoding_packedUint32", testEncoding_packedUint32), - ("testEncoding_packedUint64", testEncoding_packedUint64), - ("testEncoding_packedSint32", testEncoding_packedSint32), - ("testEncoding_packedSint64", testEncoding_packedSint64), - ("testEncoding_packedFixed32", testEncoding_packedFixed32), - ("testEncoding_packedFixed64", testEncoding_packedFixed64), - ("testEncoding_packedSfixed32", testEncoding_packedSfixed32), - ("testEncoding_packedSfixed64", testEncoding_packedSfixed64), - ("testEncoding_packedFloat", testEncoding_packedFloat), - ("testEncoding_packedDouble", testEncoding_packedDouble), - ("testEncoding_packedBool", testEncoding_packedBool), - ("testEncoding_packedEnum", testEncoding_packedEnum) - ] -} - -extension Test_ParsingMerge { - static var allTests = [ - ("test_Merge", test_Merge), - ("test_Merge_Oneof", test_Merge_Oneof) - ] -} - -extension Test_ReallyLargeTagNumber { - static var allTests = [ - ("test_ReallyLargeTagNumber", test_ReallyLargeTagNumber) - ] -} - -extension Test_RecursiveMap { - static var allTests = [ - ("test_RecursiveMap", test_RecursiveMap) - ] -} - -extension Test_Required { - static var allTests = [ - ("test_IsInitialized", test_IsInitialized), - ("test_OneOf_IsInitialized", test_OneOf_IsInitialized), - ("test_NestedInProto2_IsInitialized", test_NestedInProto2_IsInitialized), - ("test_NestedInProto3_IsInitialized", test_NestedInProto3_IsInitialized), - ("test_map_isInitialized", test_map_isInitialized), - ("test_Extensions_isInitialized", test_Extensions_isInitialized), - ("test_decodeRequired", test_decodeRequired), - ("test_encodeRequired", test_encodeRequired) - ] -} - -extension Test_SmallRequired { - static var allTests = [ - ("test_decodeRequired", test_decodeRequired), - ("test_encodeRequired", test_encodeRequired) - ] -} - -extension Test_Reserved { - static var allTests = [ - ("testEnumNaming", testEnumNaming), - ("testMessageNames", testMessageNames), - ("testFieldNamesMatchingMetadata", testFieldNamesMatchingMetadata), - ("testExtensionNamesMatching", testExtensionNamesMatching) - ] -} - -extension Test_SimpleExtensionMap { - static var allTests = [ - ("testInsert", testInsert), - ("testInsert_contentsOf", testInsert_contentsOf), - ("testInitialize_list", testInitialize_list), - ("testFormUnion", testFormUnion), - ("testUnion", testUnion), - ("testInitialize_union", testInitialize_union), - ("testSubscript", testSubscript), - ("testFieldNumberForProto", testFieldNumberForProto) - ] -} - -extension Test_Struct { - static var allTests = [ - ("testStruct_pbencode", testStruct_pbencode), - ("testStruct_pbdecode", testStruct_pbdecode), - ("test_JSON", test_JSON), - ("test_JSON_field", test_JSON_field), - ("test_equality", test_equality) - ] -} - -extension Test_JSON_ListValue { - static var allTests = [ - ("testProtobuf", testProtobuf), - ("testJSON", testJSON), - ("test_JSON_nested_list", test_JSON_nested_list), - ("test_equality", test_equality) - ] -} - -extension Test_Value { - static var allTests = [ - ("testValue_empty", testValue_empty) - ] -} - -extension Test_JSON_Value { - static var allTests = [ - ("testValue_emptyShouldThrow", testValue_emptyShouldThrow), - ("testValue_null", testValue_null), - ("testValue_number", testValue_number), - ("testValue_string", testValue_string), - ("testValue_bool", testValue_bool), - ("testValue_struct", testValue_struct), - ("testValue_list", testValue_list), - ("testValue_complex", testValue_complex), - ("testStruct_conformance", testStruct_conformance), - ("testStruct_null", testStruct_null) - ] -} - -extension Test_TextFormatDecodingOptions { - static var allTests = [ - ("testMessageDepthLimit", testMessageDepthLimit) - ] -} - -extension Test_TextFormat_Map_proto3 { - static var allTests = [ - ("test_Int32Int32", test_Int32Int32), - ("test_Int32Int32_numbers", test_Int32Int32_numbers), - ("test_StringMessage", test_StringMessage), - ("test_StringMessage_numbers", test_StringMessage_numbers) - ] -} - -extension Test_TextFormat_Unknown { - static var allTests = [ - ("test_unknown_varint", test_unknown_varint), - ("test_unknown_fixed64", test_unknown_fixed64), - ("test_unknown_lengthDelimited_string", test_unknown_lengthDelimited_string), - ("test_unknown_lengthDelimited_message", test_unknown_lengthDelimited_message), - ("test_unknown_lengthDelimited_notmessage", test_unknown_lengthDelimited_notmessage), - ("test_unknown_lengthDelimited_nested_message", test_unknown_lengthDelimited_nested_message), - ("test_unknown_lengthDelimited_nested_message_recursion_limits", test_unknown_lengthDelimited_nested_message_recursion_limits), - ("test_unknown_group", test_unknown_group), - ("test_unknown_nested_group", test_unknown_nested_group), - ("test_unknown_nested_group_no_recursion_limits", test_unknown_nested_group_no_recursion_limits), - ("test_unknown_fixed32", test_unknown_fixed32) - ] -} - -extension Test_TextFormat_WKT_proto3 { - static var allTests = [ - ("testAny", testAny), - ("testAny_verbose", testAny_verbose), - ("testApi", testApi), - ("testDuration", testDuration), - ("testEmpty", testEmpty), - ("testFieldMask", testFieldMask), - ("testStruct", testStruct), - ("testTimestamp", testTimestamp), - ("testType", testType), - ("testDoubleValue", testDoubleValue), - ("testFloatValue", testFloatValue), - ("testInt64Value", testInt64Value), - ("testUInt64Value", testUInt64Value), - ("testInt32Value", testInt32Value), - ("testUInt32Value", testUInt32Value), - ("testBoolValue", testBoolValue), - ("testStringValue", testStringValue), - ("testBytesValue", testBytesValue), - ("testValue", testValue) - ] -} - -extension Test_TextFormat_proto2 { - static var allTests = [ - ("test_group", test_group), - ("test_group_numbers", test_group_numbers), - ("test_repeatedGroup", test_repeatedGroup), - ("test_repeatedGroup_numbers", test_repeatedGroup_numbers) - ] -} - -extension Test_TextFormat_proto2_extensions { - static var allTests = [ - ("test_file_level_extension", test_file_level_extension), - ("test_nested_extension", test_nested_extension) - ] -} - -extension Test_TextFormat_proto3 { - static var allTests = [ - ("testDecoding_comments", testDecoding_comments), - ("testDecoding_comments_numbers", testDecoding_comments_numbers), - ("testEncoding_optionalInt32", testEncoding_optionalInt32), - ("testEncoding_optionalInt64", testEncoding_optionalInt64), - ("testEncoding_optionalUint32", testEncoding_optionalUint32), - ("testEncoding_optionalUint64", testEncoding_optionalUint64), - ("testEncoding_optionalSint32", testEncoding_optionalSint32), - ("testEncoding_optionalSint64", testEncoding_optionalSint64), - ("testEncoding_optionalFixed32", testEncoding_optionalFixed32), - ("testEncoding_optionalFixed64", testEncoding_optionalFixed64), - ("testEncoding_optionalSfixed32", testEncoding_optionalSfixed32), - ("testEncoding_optionalSfixed64", testEncoding_optionalSfixed64), - ("testEncoding_optionalFloat", testEncoding_optionalFloat), - ("testEncoding_optionalDouble", testEncoding_optionalDouble), - ("testEncoding_optionalBool", testEncoding_optionalBool), - ("testEncoding_optionalString", testEncoding_optionalString), - ("testEncoding_optionalString_controlCharacters", testEncoding_optionalString_controlCharacters), - ("testEncoding_optionalString_UTF8", testEncoding_optionalString_UTF8), - ("testEncoding_optionalBytes", testEncoding_optionalBytes), - ("testEncoding_optionalBytes_roundtrip", testEncoding_optionalBytes_roundtrip), - ("testEncoding_optionalNestedMessage", testEncoding_optionalNestedMessage), - ("testEncoding_optionalForeignMessage", testEncoding_optionalForeignMessage), - ("testEncoding_optionalImportMessage", testEncoding_optionalImportMessage), - ("testEncoding_optionalNestedEnum", testEncoding_optionalNestedEnum), - ("testEncoding_optionalForeignEnum", testEncoding_optionalForeignEnum), - ("testEncoding_optionalPublicImportMessage", testEncoding_optionalPublicImportMessage), - ("testEncoding_repeatedInt32", testEncoding_repeatedInt32), - ("testEncoding_repeatedInt64", testEncoding_repeatedInt64), - ("testEncoding_repeatedUint32", testEncoding_repeatedUint32), - ("testEncoding_repeatedUint64", testEncoding_repeatedUint64), - ("testEncoding_repeatedSint32", testEncoding_repeatedSint32), - ("testEncoding_repeatedSint64", testEncoding_repeatedSint64), - ("testEncoding_repeatedFixed32", testEncoding_repeatedFixed32), - ("testEncoding_repeatedFixed64", testEncoding_repeatedFixed64), - ("testEncoding_repeatedSfixed32", testEncoding_repeatedSfixed32), - ("testEncoding_repeatedSfixed64", testEncoding_repeatedSfixed64), - ("testEncoding_repeatedFloat", testEncoding_repeatedFloat), - ("testEncoding_repeatedDouble", testEncoding_repeatedDouble), - ("testEncoding_repeatedBool", testEncoding_repeatedBool), - ("testEncoding_repeatedString", testEncoding_repeatedString), - ("testEncoding_repeatedBytes", testEncoding_repeatedBytes), - ("testEncoding_repeatedNestedMessage", testEncoding_repeatedNestedMessage), - ("testEncoding_repeatedForeignMessage", testEncoding_repeatedForeignMessage), - ("testEncoding_repeatedImportMessage", testEncoding_repeatedImportMessage), - ("testEncoding_repeatedNestedEnum", testEncoding_repeatedNestedEnum), - ("testEncoding_repeatedForeignEnum", testEncoding_repeatedForeignEnum), - ("testEncoding_oneofUint32", testEncoding_oneofUint32), - ("testInvalidToken", testInvalidToken), - ("testInvalidFieldName", testInvalidFieldName), - ("testInvalidCapitalization", testInvalidCapitalization), - ("testExplicitDelimiters", testExplicitDelimiters), - ("testMultipleFields", testMultipleFields), - ("testMultipleFields_numbers", testMultipleFields_numbers) - ] -} - -extension Test_Timestamp { - static var allTests = [ - ("testJSON", testJSON), - ("testJSON_range", testJSON_range), - ("testJSON_timezones", testJSON_timezones), - ("testJSON_timestampField", testJSON_timestampField), - ("testJSON_conformance", testJSON_conformance), - ("testSerializationFailure", testSerializationFailure), - ("testBasicArithmetic", testBasicArithmetic), - ("testArithmeticNormalizes", testArithmeticNormalizes), - ("testInitializationByTimestamps", testInitializationByTimestamps), - ("testInitializationByReferenceTimestamp", testInitializationByReferenceTimestamp), - ("testInitializationByDates", testInitializationByDates), - ("testTimestampGetters", testTimestampGetters) - ] -} - -extension Test_Type { - static var allTests = [ - ("testExists", testExists) - ] -} - -extension Test_Unknown_proto2 { - static var allTests = [ - ("testBinaryPB", testBinaryPB), - ("testJSON", testJSON), - ("test_MessageNoStorageClass", test_MessageNoStorageClass), - ("test_MessageUsingStorageClass", test_MessageUsingStorageClass) - ] -} - -extension Test_Unknown_proto3 { - static var allTests = [ - ("testBinaryPB", testBinaryPB), - ("testJSON", testJSON), - ("test_MessageNoStorageClass", test_MessageNoStorageClass), - ("test_MessageUsingStorageClass", test_MessageUsingStorageClass) - ] -} - -extension Test_Wrappers { - static var allTests = [ - ("testDoubleValue", testDoubleValue), - ("testFloatValue", testFloatValue), - ("testInt64Value", testInt64Value), - ("testUInt64Value", testUInt64Value), - ("testInt32Value", testInt32Value), - ("testUInt32Value", testUInt32Value), - ("testBoolValue", testBoolValue), - ("testStringValue", testStringValue), - ("testBytesValue", testBytesValue) - ] -} - -XCTMain( - [ - testCase(Test_Descriptor.allTests), - testCase(Test_NamingUtils.allTests), - testCase(Test_ProtoFileToModuleMappings.allTests), - testCase(Test_SwiftLanguage.allTests), - testCase(Test_SwiftProtobufNamer.allTests), - testCase(Test_AllTypes.allTests), - testCase(Test_AllTypes_Proto3.allTests), - testCase(Test_AllTypes_Proto3_Optional.allTests), - testCase(Test_Any.allTests), - testCase(Test_Api.allTests), - testCase(Test_BasicFields_Access_Proto2.allTests), - testCase(Test_BasicFields_Access_Proto3.allTests), - testCase(Test_BinaryDecodingOptions.allTests), - testCase(Test_BinaryDelimited.allTests), - testCase(Test_Conformance.allTests), - testCase(Test_Duration.allTests), - testCase(Test_Empty.allTests), - testCase(Test_Enum.allTests), - testCase(Test_EnumWithAliases.allTests), - testCase(Test_Enum_Proto2.allTests), - testCase(Test_Extensions.allTests), - testCase(Test_ExtremeDefaultValues.allTests), - testCase(Test_FieldMask.allTests), - testCase(Test_FieldOrdering.allTests), - testCase(Test_FuzzTests.allTests), - testCase(Test_GroupWithinGroup.allTests), - testCase(Test_JSON.allTests), - testCase(Test_JSONPacked.allTests), - testCase(Test_JSONrepeated.allTests), - testCase(Test_JSONDecodingOptions.allTests), - testCase(Test_JSONEncodingOptions.allTests), - testCase(Test_JSON_Array.allTests), - testCase(Test_JSON_Conformance.allTests), - testCase(Test_JSON_Extensions.allTests), - testCase(Test_JSON_RecursiveNested_Extensions.allTests), - testCase(Test_JSON_Group.allTests), - testCase(Test_Map.allTests), - testCase(Test_MapFields_Access_Proto2.allTests), - testCase(Test_MapFields_Access_Proto3.allTests), - testCase(Test_Map_JSON.allTests), - testCase(Test_Merge.allTests), - testCase(Test_MessageSet.allTests), - testCase(Test_PackageMapping.allTests), - testCase(Test_FieldNamingInitials.allTests), - testCase(Test_ExtensionNamingInitials_MessageScoped.allTests), - testCase(Test_ExtensionNamingInitials_GlobalScoped.allTests), - testCase(Test_ExtensionNamingInitials_GlobalScoped_NoPrefix.allTests), - testCase(Test_ValidIdentifiers.allTests), - testCase(Test_OneofFields_Access_Proto2.allTests), - testCase(Test_OneofFields_Access_Proto3.allTests), - testCase(Test_Packed.allTests), - testCase(Test_ParsingMerge.allTests), - testCase(Test_ReallyLargeTagNumber.allTests), - testCase(Test_RecursiveMap.allTests), - testCase(Test_Required.allTests), - testCase(Test_SmallRequired.allTests), - testCase(Test_Reserved.allTests), - testCase(Test_SimpleExtensionMap.allTests), - testCase(Test_Struct.allTests), - testCase(Test_JSON_ListValue.allTests), - testCase(Test_Value.allTests), - testCase(Test_JSON_Value.allTests), - testCase(Test_TextFormatDecodingOptions.allTests), - testCase(Test_TextFormat_Map_proto3.allTests), - testCase(Test_TextFormat_Unknown.allTests), - testCase(Test_TextFormat_WKT_proto3.allTests), - testCase(Test_TextFormat_proto2.allTests), - testCase(Test_TextFormat_proto2_extensions.allTests), - testCase(Test_TextFormat_proto3.allTests), - testCase(Test_Timestamp.allTests), - testCase(Test_Type.allTests), - testCase(Test_Unknown_proto2.allTests), - testCase(Test_Unknown_proto3.allTests), - testCase(Test_Wrappers.allTests) - ] -) diff --git a/Tests/SwiftProtobufPluginLibraryTests/Descriptor+TestHelpers.swift b/Tests/SwiftProtobufPluginLibraryTests/Descriptor+TestHelpers.swift deleted file mode 100644 index 24e35cf11..000000000 --- a/Tests/SwiftProtobufPluginLibraryTests/Descriptor+TestHelpers.swift +++ /dev/null @@ -1,45 +0,0 @@ -// Sources/protoc-gen-swift/Descriptor+TestHelpers.swift - Additions to Descriptors -// -// Copyright (c) 2014 - 2017 Apple Inc. and the project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See LICENSE.txt for license information: -// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt -// -// ----------------------------------------------------------------------------- - -import SwiftProtobuf -import SwiftProtobufPluginLibrary - -extension Google_Protobuf_FileDescriptorProto { - init(name: String, dependencies: [String] = [], publicDependencies: [Int32] = []) { - for idx in publicDependencies { precondition(Int(idx) <= dependencies.count) } - self.init() - self.name = name - dependency = dependencies - publicDependency = publicDependencies - } - init(textFormatStrings: [String]) throws { - let s = textFormatStrings.joined(separator: "\n") + "\n" - try self.init(textFormatString: s) - } -} - -extension Google_Protobuf_FileDescriptorSet { - init(files: [Google_Protobuf_FileDescriptorProto]) { - self.init() - file = files - } - init(file: Google_Protobuf_FileDescriptorProto) { - self.init() - self.file = [file] - } -} - -extension Google_Protobuf_EnumValueDescriptorProto { - init(name: String, number: Int32) { - self.init() - self.name = name - self.number = number - } -} diff --git a/Tests/SwiftProtobufPluginLibraryTests/DescriptorTestData.swift b/Tests/SwiftProtobufPluginLibraryTests/DescriptorTestData.swift index edd051127..d8e66c712 100644 --- a/Tests/SwiftProtobufPluginLibraryTests/DescriptorTestData.swift +++ b/Tests/SwiftProtobufPluginLibraryTests/DescriptorTestData.swift @@ -2,1105 +2,1546 @@ // swift-format-ignore-file import Foundation let fileDescriptorSetBytes: [UInt8] = [ - 0x0a, 0xc3, 0x3b, 0x0a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x65, 0x73, - 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x12, 0x0f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x22, 0x4d, 0x0a, 0x11, 0x46, 0x69, - 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, - 0x53, 0x65, 0x74, 0x12, 0x38, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x18, - 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, - 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, - 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x04, 0x66, 0x69, 0x6c, - 0x65, 0x22, 0xe4, 0x04, 0x0a, 0x13, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, - 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, - 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x18, 0x0a, - 0x07, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x07, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x12, - 0x1e, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, - 0x79, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x64, 0x65, 0x70, - 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x70, - 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, - 0x65, 0x6e, 0x63, 0x79, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x05, 0x52, 0x10, - 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x44, 0x65, 0x70, 0x65, 0x6e, 0x64, - 0x65, 0x6e, 0x63, 0x79, 0x12, 0x27, 0x0a, 0x0f, 0x77, 0x65, 0x61, 0x6b, - 0x5f, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x18, - 0x0b, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0e, 0x77, 0x65, 0x61, 0x6b, 0x44, - 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x43, 0x0a, - 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x79, 0x70, - 0x65, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, - 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, - 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, - 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x0b, 0x6d, 0x65, 0x73, 0x73, 0x61, - 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x41, 0x0a, 0x09, 0x65, 0x6e, - 0x75, 0x6d, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, - 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, - 0x6f, 0x74, 0x6f, 0x52, 0x08, 0x65, 0x6e, 0x75, 0x6d, 0x54, 0x79, 0x70, - 0x65, 0x12, 0x41, 0x0a, 0x07, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, - 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x6f, 0x6f, - 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, - 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x44, 0x65, 0x73, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, - 0x07, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x43, 0x0a, 0x09, - 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, - 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, - 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x09, 0x65, 0x78, 0x74, 0x65, - 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x36, 0x0a, 0x07, 0x6f, 0x70, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, - 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x12, 0x49, 0x0a, 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, - 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x09, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x6f, - 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, - 0x52, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, - 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x79, 0x6e, 0x74, - 0x61, 0x78, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x79, - 0x6e, 0x74, 0x61, 0x78, 0x22, 0xb9, 0x06, 0x0a, 0x0f, 0x44, 0x65, 0x73, - 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, - 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3b, 0x0a, 0x05, - 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x25, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, - 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, - 0x74, 0x6f, 0x52, 0x05, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x43, 0x0a, - 0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x06, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, - 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, - 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x09, 0x65, 0x78, 0x74, - 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x41, 0x0a, 0x0b, 0x6e, 0x65, - 0x73, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, - 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, - 0x6f, 0x52, 0x0a, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x54, 0x79, 0x70, - 0x65, 0x12, 0x41, 0x0a, 0x09, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x79, - 0x70, 0x65, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, - 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, - 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x44, 0x65, 0x73, 0x63, 0x72, - 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x08, - 0x65, 0x6e, 0x75, 0x6d, 0x54, 0x79, 0x70, 0x65, 0x12, 0x58, 0x0a, 0x0f, - 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, - 0x6e, 0x67, 0x65, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, - 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x45, 0x78, 0x74, 0x65, - 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x0e, - 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x6e, - 0x67, 0x65, 0x12, 0x44, 0x0a, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, - 0x64, 0x65, 0x63, 0x6c, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, - 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x44, 0x65, - 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, - 0x6f, 0x52, 0x09, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x44, 0x65, 0x63, 0x6c, - 0x12, 0x39, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, - 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, - 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, - 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, - 0x55, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, - 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x2e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, - 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x52, 0x65, - 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, - 0x0d, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, - 0x67, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x0a, 0x20, 0x03, 0x28, - 0x09, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x4e, - 0x61, 0x6d, 0x65, 0x1a, 0x7a, 0x0a, 0x0e, 0x45, 0x78, 0x74, 0x65, 0x6e, - 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, - 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, - 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, - 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x65, 0x6e, - 0x64, 0x12, 0x40, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x67, 0x6f, 0x6f, - 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, - 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, - 0x6e, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, - 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x37, 0x0a, 0x0d, 0x52, - 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, - 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, - 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, - 0x03, 0x65, 0x6e, 0x64, 0x22, 0x7c, 0x0a, 0x15, 0x45, 0x78, 0x74, 0x65, - 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x70, - 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, - 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, - 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, - 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, - 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, - 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, - 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0xc1, - 0x06, 0x0a, 0x14, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, - 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6e, - 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, - 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x41, 0x0a, 0x05, 0x6c, - 0x61, 0x62, 0x65, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, - 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, - 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x52, 0x05, 0x6c, 0x61, 0x62, - 0x65, 0x6c, 0x12, 0x3e, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, - 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, - 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x54, 0x79, 0x70, 0x65, - 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x79, - 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x08, 0x74, 0x79, 0x70, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, - 0x1a, 0x0a, 0x08, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x65, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x78, 0x74, 0x65, 0x6e, - 0x64, 0x65, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, - 0x6c, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0c, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x56, - 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x6f, 0x6e, 0x65, 0x6f, - 0x66, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x09, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x0a, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x49, 0x6e, 0x64, 0x65, - 0x78, 0x12, 0x1b, 0x0a, 0x09, 0x6a, 0x73, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, - 0x6d, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6a, 0x73, - 0x6f, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x07, 0x6f, 0x70, - 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, - 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x33, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x18, 0x11, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, - 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x22, 0xb6, 0x02, 0x0a, - 0x04, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, - 0x45, 0x5f, 0x44, 0x4f, 0x55, 0x42, 0x4c, 0x45, 0x10, 0x01, 0x12, 0x0e, - 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46, 0x4c, 0x4f, 0x41, 0x54, - 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, - 0x4e, 0x54, 0x36, 0x34, 0x10, 0x03, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, - 0x50, 0x45, 0x5f, 0x55, 0x49, 0x4e, 0x54, 0x36, 0x34, 0x10, 0x04, 0x12, - 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4e, 0x54, 0x33, - 0x32, 0x10, 0x05, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45, 0x5f, - 0x46, 0x49, 0x58, 0x45, 0x44, 0x36, 0x34, 0x10, 0x06, 0x12, 0x10, 0x0a, - 0x0c, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46, 0x49, 0x58, 0x45, 0x44, 0x33, - 0x32, 0x10, 0x07, 0x12, 0x0d, 0x0a, 0x09, 0x54, 0x59, 0x50, 0x45, 0x5f, - 0x42, 0x4f, 0x4f, 0x4c, 0x10, 0x08, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, - 0x50, 0x45, 0x5f, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x09, 0x12, - 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x47, 0x52, 0x4f, 0x55, - 0x50, 0x10, 0x0a, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45, 0x5f, - 0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x10, 0x0b, 0x12, 0x0e, 0x0a, - 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x42, 0x59, 0x54, 0x45, 0x53, 0x10, - 0x0c, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x49, - 0x4e, 0x54, 0x33, 0x32, 0x10, 0x0d, 0x12, 0x0d, 0x0a, 0x09, 0x54, 0x59, - 0x50, 0x45, 0x5f, 0x45, 0x4e, 0x55, 0x4d, 0x10, 0x0e, 0x12, 0x11, 0x0a, - 0x0d, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x46, 0x49, 0x58, 0x45, 0x44, - 0x33, 0x32, 0x10, 0x0f, 0x12, 0x11, 0x0a, 0x0d, 0x54, 0x59, 0x50, 0x45, - 0x5f, 0x53, 0x46, 0x49, 0x58, 0x45, 0x44, 0x36, 0x34, 0x10, 0x10, 0x12, - 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x49, 0x4e, 0x54, - 0x33, 0x32, 0x10, 0x11, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, - 0x5f, 0x53, 0x49, 0x4e, 0x54, 0x36, 0x34, 0x10, 0x12, 0x22, 0x43, 0x0a, - 0x05, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x41, - 0x42, 0x45, 0x4c, 0x5f, 0x4f, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x41, 0x4c, - 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, - 0x52, 0x45, 0x51, 0x55, 0x49, 0x52, 0x45, 0x44, 0x10, 0x02, 0x12, 0x12, - 0x0a, 0x0e, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x5f, 0x52, 0x45, 0x50, 0x45, - 0x41, 0x54, 0x45, 0x44, 0x10, 0x03, 0x22, 0x63, 0x0a, 0x14, 0x4f, 0x6e, - 0x65, 0x6f, 0x66, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, - 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, - 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, - 0x6d, 0x65, 0x12, 0x37, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x6f, - 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, - 0x66, 0x2e, 0x4f, 0x6e, 0x65, 0x6f, 0x66, 0x4f, 0x70, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, - 0xe3, 0x02, 0x0a, 0x13, 0x45, 0x6e, 0x75, 0x6d, 0x44, 0x65, 0x73, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, - 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3f, 0x0a, 0x05, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, - 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, - 0x75, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, - 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, - 0x12, 0x36, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, - 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, - 0x45, 0x6e, 0x75, 0x6d, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, - 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x5d, 0x0a, 0x0e, - 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x72, 0x61, 0x6e, - 0x67, 0x65, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x67, - 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, - 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x44, 0x65, 0x73, 0x63, 0x72, - 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x45, - 0x6e, 0x75, 0x6d, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x52, - 0x61, 0x6e, 0x67, 0x65, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x64, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x72, - 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x6e, 0x61, 0x6d, 0x65, - 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x65, 0x73, 0x65, - 0x72, 0x76, 0x65, 0x64, 0x4e, 0x61, 0x6d, 0x65, 0x1a, 0x3b, 0x0a, 0x11, - 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, - 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, - 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x22, 0x83, 0x01, - 0x0a, 0x18, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x44, - 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, - 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, - 0x0a, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x3b, - 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, - 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, - 0xa7, 0x01, 0x0a, 0x16, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x44, - 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, - 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3e, - 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x18, 0x02, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, - 0x68, 0x6f, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, - 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x52, 0x06, 0x6d, 0x65, 0x74, 0x68, - 0x6f, 0x64, 0x12, 0x39, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x6f, - 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, - 0x66, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4f, 0x70, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x22, 0x89, 0x02, 0x0a, 0x15, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, - 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, - 0x6f, 0x74, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, - 0x1d, 0x0a, 0x0a, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x79, 0x70, - 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x69, 0x6e, 0x70, - 0x75, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x6f, 0x75, - 0x74, 0x70, 0x75, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x54, - 0x79, 0x70, 0x65, 0x12, 0x38, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, - 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, - 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x12, 0x30, 0x0a, 0x10, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, - 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67, 0x18, 0x05, 0x20, - 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0f, - 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, - 0x69, 0x6e, 0x67, 0x12, 0x30, 0x0a, 0x10, 0x73, 0x65, 0x72, 0x76, 0x65, - 0x72, 0x5f, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67, 0x18, - 0x06, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, - 0x52, 0x0f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65, - 0x61, 0x6d, 0x69, 0x6e, 0x67, 0x22, 0x91, 0x09, 0x0a, 0x0b, 0x46, 0x69, - 0x6c, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x21, 0x0a, - 0x0c, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, - 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6a, 0x61, 0x76, - 0x61, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x14, - 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x5f, 0x63, - 0x6c, 0x61, 0x73, 0x73, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x12, 0x6a, 0x61, 0x76, 0x61, 0x4f, 0x75, 0x74, 0x65, - 0x72, 0x43, 0x6c, 0x61, 0x73, 0x73, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x35, - 0x0a, 0x13, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x6d, 0x75, 0x6c, 0x74, 0x69, - 0x70, 0x6c, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x0a, 0x20, - 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x11, - 0x6a, 0x61, 0x76, 0x61, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, - 0x46, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x44, 0x0a, 0x1d, 0x6a, 0x61, 0x76, - 0x61, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x5f, 0x65, - 0x71, 0x75, 0x61, 0x6c, 0x73, 0x5f, 0x61, 0x6e, 0x64, 0x5f, 0x68, 0x61, - 0x73, 0x68, 0x18, 0x14, 0x20, 0x01, 0x28, 0x08, 0x42, 0x02, 0x18, 0x01, - 0x52, 0x19, 0x6a, 0x61, 0x76, 0x61, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, - 0x74, 0x65, 0x45, 0x71, 0x75, 0x61, 0x6c, 0x73, 0x41, 0x6e, 0x64, 0x48, - 0x61, 0x73, 0x68, 0x12, 0x3a, 0x0a, 0x16, 0x6a, 0x61, 0x76, 0x61, 0x5f, - 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, - 0x5f, 0x75, 0x74, 0x66, 0x38, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x08, 0x3a, - 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x13, 0x6a, 0x61, 0x76, 0x61, - 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x55, - 0x74, 0x66, 0x38, 0x12, 0x53, 0x0a, 0x0c, 0x6f, 0x70, 0x74, 0x69, 0x6d, - 0x69, 0x7a, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, - 0x0e, 0x32, 0x29, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, - 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4f, 0x70, 0x74, 0x69, - 0x6d, 0x69, 0x7a, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x3a, 0x05, 0x53, 0x50, - 0x45, 0x45, 0x44, 0x52, 0x0b, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, - 0x65, 0x46, 0x6f, 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x67, 0x6f, 0x5f, 0x70, - 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x09, 0x67, 0x6f, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x12, - 0x35, 0x0a, 0x13, 0x63, 0x63, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, - 0x63, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x10, - 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, - 0x11, 0x63, 0x63, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x53, 0x65, - 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x39, 0x0a, 0x15, 0x6a, 0x61, - 0x76, 0x61, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x5f, 0x73, - 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x11, 0x20, 0x01, 0x28, - 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x13, 0x6a, 0x61, - 0x76, 0x61, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x53, 0x65, 0x72, - 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x35, 0x0a, 0x13, 0x70, 0x79, 0x5f, - 0x67, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x5f, 0x73, 0x65, 0x72, 0x76, - 0x69, 0x63, 0x65, 0x73, 0x18, 0x12, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, - 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x11, 0x70, 0x79, 0x47, 0x65, 0x6e, - 0x65, 0x72, 0x69, 0x63, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, - 0x12, 0x37, 0x0a, 0x14, 0x70, 0x68, 0x70, 0x5f, 0x67, 0x65, 0x6e, 0x65, - 0x72, 0x69, 0x63, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, - 0x18, 0x2a, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, - 0x65, 0x52, 0x12, 0x70, 0x68, 0x70, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, - 0x63, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x25, 0x0a, - 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, - 0x17, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, - 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, - 0x12, 0x2e, 0x0a, 0x10, 0x63, 0x63, 0x5f, 0x65, 0x6e, 0x61, 0x62, 0x6c, - 0x65, 0x5f, 0x61, 0x72, 0x65, 0x6e, 0x61, 0x73, 0x18, 0x1f, 0x20, 0x01, - 0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65, 0x52, 0x0e, 0x63, 0x63, - 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x41, 0x72, 0x65, 0x6e, 0x61, 0x73, - 0x12, 0x2a, 0x0a, 0x11, 0x6f, 0x62, 0x6a, 0x63, 0x5f, 0x63, 0x6c, 0x61, - 0x73, 0x73, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x24, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0f, 0x6f, 0x62, 0x6a, 0x63, 0x43, 0x6c, 0x61, - 0x73, 0x73, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x29, 0x0a, 0x10, - 0x63, 0x73, 0x68, 0x61, 0x72, 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, - 0x70, 0x61, 0x63, 0x65, 0x18, 0x25, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, - 0x63, 0x73, 0x68, 0x61, 0x72, 0x70, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x77, 0x69, 0x66, 0x74, - 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x27, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0b, 0x73, 0x77, 0x69, 0x66, 0x74, 0x50, 0x72, 0x65, 0x66, - 0x69, 0x78, 0x12, 0x28, 0x0a, 0x10, 0x70, 0x68, 0x70, 0x5f, 0x63, 0x6c, - 0x61, 0x73, 0x73, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, 0x18, 0x28, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x70, 0x68, 0x70, 0x43, 0x6c, 0x61, - 0x73, 0x73, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x12, 0x23, 0x0a, 0x0d, - 0x70, 0x68, 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, - 0x65, 0x18, 0x29, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x70, 0x68, 0x70, - 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x34, 0x0a, - 0x16, 0x70, 0x68, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, - 0x61, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, - 0x2c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x14, 0x70, 0x68, 0x70, 0x4d, 0x65, - 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, - 0x61, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x72, 0x75, 0x62, 0x79, 0x5f, - 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x2d, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0b, 0x72, 0x75, 0x62, 0x79, 0x50, 0x61, 0x63, 0x6b, 0x61, - 0x67, 0x65, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, - 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, - 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, - 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, - 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, - 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, - 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x3a, 0x0a, 0x0c, - 0x4f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x4d, 0x6f, 0x64, 0x65, - 0x12, 0x09, 0x0a, 0x05, 0x53, 0x50, 0x45, 0x45, 0x44, 0x10, 0x01, 0x12, - 0x0d, 0x0a, 0x09, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x53, 0x49, 0x5a, 0x45, - 0x10, 0x02, 0x12, 0x10, 0x0a, 0x0c, 0x4c, 0x49, 0x54, 0x45, 0x5f, 0x52, - 0x55, 0x4e, 0x54, 0x49, 0x4d, 0x45, 0x10, 0x03, 0x2a, 0x09, 0x08, 0xe8, - 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x4a, 0x04, 0x08, 0x26, 0x10, - 0x27, 0x22, 0xe3, 0x02, 0x0a, 0x0e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, - 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3c, 0x0a, 0x17, - 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x5f, - 0x77, 0x69, 0x72, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, - 0x52, 0x14, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, - 0x57, 0x69, 0x72, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x4c, - 0x0a, 0x1f, 0x6e, 0x6f, 0x5f, 0x73, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, - 0x64, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, - 0x5f, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x1c, - 0x6e, 0x6f, 0x53, 0x74, 0x61, 0x6e, 0x64, 0x61, 0x72, 0x64, 0x44, 0x65, - 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x41, 0x63, 0x63, 0x65, - 0x73, 0x73, 0x6f, 0x72, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, - 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, - 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65, 0x70, - 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x6d, - 0x61, 0x70, 0x5f, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x18, 0x07, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x08, 0x6d, 0x61, 0x70, 0x45, 0x6e, 0x74, 0x72, 0x79, - 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, - 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, - 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, - 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, - 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, - 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, - 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, - 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, - 0x80, 0x80, 0x80, 0x80, 0x02, 0x4a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x4a, - 0x04, 0x08, 0x05, 0x10, 0x06, 0x4a, 0x04, 0x08, 0x06, 0x10, 0x07, 0x4a, - 0x04, 0x08, 0x08, 0x10, 0x09, 0x4a, 0x04, 0x08, 0x09, 0x10, 0x0a, 0x22, - 0xe2, 0x03, 0x0a, 0x0c, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x41, 0x0a, 0x05, 0x63, 0x74, 0x79, 0x70, - 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x67, 0x6f, - 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, - 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x2e, 0x43, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x06, 0x53, 0x54, - 0x52, 0x49, 0x4e, 0x47, 0x52, 0x05, 0x63, 0x74, 0x79, 0x70, 0x65, 0x12, - 0x16, 0x0a, 0x06, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x06, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x64, 0x12, - 0x47, 0x0a, 0x06, 0x6a, 0x73, 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, - 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, - 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4a, - 0x53, 0x54, 0x79, 0x70, 0x65, 0x3a, 0x09, 0x4a, 0x53, 0x5f, 0x4e, 0x4f, - 0x52, 0x4d, 0x41, 0x4c, 0x52, 0x06, 0x6a, 0x73, 0x74, 0x79, 0x70, 0x65, - 0x12, 0x19, 0x0a, 0x04, 0x6c, 0x61, 0x7a, 0x79, 0x18, 0x05, 0x20, 0x01, - 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x04, 0x6c, - 0x61, 0x7a, 0x79, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, - 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x3a, - 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, - 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x19, 0x0a, 0x04, 0x77, 0x65, - 0x61, 0x6b, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, - 0x6c, 0x73, 0x65, 0x52, 0x04, 0x77, 0x65, 0x61, 0x6b, 0x12, 0x58, 0x0a, - 0x14, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, - 0x65, 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, - 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, - 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, - 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, - 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, - 0x69, 0x6f, 0x6e, 0x22, 0x2f, 0x0a, 0x05, 0x43, 0x54, 0x79, 0x70, 0x65, - 0x12, 0x0a, 0x0a, 0x06, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x00, - 0x12, 0x08, 0x0a, 0x04, 0x43, 0x4f, 0x52, 0x44, 0x10, 0x01, 0x12, 0x10, - 0x0a, 0x0c, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x5f, 0x50, 0x49, 0x45, - 0x43, 0x45, 0x10, 0x02, 0x22, 0x35, 0x0a, 0x06, 0x4a, 0x53, 0x54, 0x79, - 0x70, 0x65, 0x12, 0x0d, 0x0a, 0x09, 0x4a, 0x53, 0x5f, 0x4e, 0x4f, 0x52, - 0x4d, 0x41, 0x4c, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x4a, 0x53, 0x5f, - 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, - 0x4a, 0x53, 0x5f, 0x4e, 0x55, 0x4d, 0x42, 0x45, 0x52, 0x10, 0x02, 0x2a, - 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x4a, 0x04, - 0x08, 0x04, 0x10, 0x05, 0x22, 0x73, 0x0a, 0x0c, 0x4f, 0x6e, 0x65, 0x6f, - 0x66, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x58, 0x0a, 0x14, - 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, - 0x64, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, - 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, - 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, - 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, - 0x6f, 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, - 0x02, 0x22, 0xc0, 0x01, 0x0a, 0x0b, 0x45, 0x6e, 0x75, 0x6d, 0x4f, 0x70, - 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x6c, 0x6c, - 0x6f, 0x77, 0x5f, 0x61, 0x6c, 0x69, 0x61, 0x73, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x0a, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x41, 0x6c, 0x69, - 0x61, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, - 0x61, 0x74, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, - 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, - 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, - 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, - 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, - 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, - 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, - 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, - 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x4a, 0x04, - 0x08, 0x05, 0x10, 0x06, 0x22, 0x9e, 0x01, 0x0a, 0x10, 0x45, 0x6e, 0x75, - 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, - 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, - 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, - 0x61, 0x74, 0x65, 0x64, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, - 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, - 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, - 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, - 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, - 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2a, 0x09, - 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0x9c, 0x01, - 0x0a, 0x0e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4f, 0x70, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x72, - 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x21, 0x20, 0x01, 0x28, 0x08, - 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64, 0x65, 0x70, - 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x58, 0x0a, 0x14, 0x75, - 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, - 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, - 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, - 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, - 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, - 0x6e, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, - 0x22, 0xe0, 0x02, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, - 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x25, 0x0a, 0x0a, 0x64, 0x65, - 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x18, 0x21, 0x20, 0x01, - 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x0a, 0x64, - 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x12, 0x71, 0x0a, - 0x11, 0x69, 0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, 0x79, - 0x5f, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x22, 0x20, 0x01, 0x28, 0x0e, - 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, - 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x49, 0x64, 0x65, - 0x6d, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x4c, 0x65, 0x76, 0x65, - 0x6c, 0x3a, 0x13, 0x49, 0x44, 0x45, 0x4d, 0x50, 0x4f, 0x54, 0x45, 0x4e, - 0x43, 0x59, 0x5f, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x52, 0x10, - 0x69, 0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, 0x79, 0x4c, - 0x65, 0x76, 0x65, 0x6c, 0x12, 0x58, 0x0a, 0x14, 0x75, 0x6e, 0x69, 0x6e, - 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x6f, 0x70, - 0x74, 0x69, 0x6f, 0x6e, 0x18, 0xe7, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, - 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, - 0x6e, 0x52, 0x13, 0x75, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, - 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x50, - 0x0a, 0x10, 0x49, 0x64, 0x65, 0x6d, 0x70, 0x6f, 0x74, 0x65, 0x6e, 0x63, - 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x17, 0x0a, 0x13, 0x49, 0x44, - 0x45, 0x4d, 0x50, 0x4f, 0x54, 0x45, 0x4e, 0x43, 0x59, 0x5f, 0x55, 0x4e, - 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x4e, - 0x4f, 0x5f, 0x53, 0x49, 0x44, 0x45, 0x5f, 0x45, 0x46, 0x46, 0x45, 0x43, - 0x54, 0x53, 0x10, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x49, 0x44, 0x45, 0x4d, - 0x50, 0x4f, 0x54, 0x45, 0x4e, 0x54, 0x10, 0x02, 0x2a, 0x09, 0x08, 0xe8, - 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, 0x9a, 0x03, 0x0a, 0x13, - 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x72, 0x65, 0x74, 0x65, - 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x41, 0x0a, 0x04, 0x6e, - 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, - 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x62, 0x75, 0x66, 0x2e, 0x55, 0x6e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, - 0x72, 0x65, 0x74, 0x65, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x2e, - 0x4e, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74, 0x52, 0x04, 0x6e, 0x61, - 0x6d, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, - 0x66, 0x69, 0x65, 0x72, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, - 0x66, 0x69, 0x65, 0x72, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2c, 0x0a, - 0x12, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x69, 0x6e, - 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x04, 0x52, 0x10, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x76, 0x65, 0x49, - 0x6e, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2c, 0x0a, 0x12, 0x6e, - 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x69, 0x6e, 0x74, 0x5f, - 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x10, 0x6e, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x49, 0x6e, 0x74, - 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x64, 0x6f, 0x75, - 0x62, 0x6c, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, - 0x01, 0x28, 0x01, 0x52, 0x0b, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x56, - 0x61, 0x6c, 0x75, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x74, 0x72, 0x69, - 0x6e, 0x67, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, - 0x28, 0x0c, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, - 0x6c, 0x75, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x61, 0x67, 0x67, 0x72, 0x65, - 0x67, 0x61, 0x74, 0x65, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, - 0x61, 0x74, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x1a, 0x4a, 0x0a, 0x08, - 0x4e, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x74, 0x12, 0x1b, 0x0a, 0x09, - 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, - 0x02, 0x28, 0x09, 0x52, 0x08, 0x6e, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x72, - 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x73, 0x5f, 0x65, 0x78, 0x74, 0x65, - 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x02, 0x28, 0x08, 0x52, - 0x0b, 0x69, 0x73, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, - 0x22, 0xa7, 0x02, 0x0a, 0x0e, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x43, - 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x44, 0x0a, 0x08, 0x6c, - 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x28, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x4c, - 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x08, 0x6c, 0x6f, 0x63, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0xce, 0x01, 0x0a, 0x08, 0x4c, 0x6f, - 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x04, 0x70, 0x61, - 0x74, 0x68, 0x18, 0x01, 0x20, 0x03, 0x28, 0x05, 0x42, 0x02, 0x10, 0x01, - 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x16, 0x0a, 0x04, 0x73, 0x70, - 0x61, 0x6e, 0x18, 0x02, 0x20, 0x03, 0x28, 0x05, 0x42, 0x02, 0x10, 0x01, - 0x52, 0x04, 0x73, 0x70, 0x61, 0x6e, 0x12, 0x29, 0x0a, 0x10, 0x6c, 0x65, - 0x61, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, - 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x6c, 0x65, - 0x61, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, - 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x74, 0x72, 0x61, 0x69, 0x6c, 0x69, 0x6e, - 0x67, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x74, 0x72, 0x61, 0x69, 0x6c, 0x69, - 0x6e, 0x67, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x3a, - 0x0a, 0x19, 0x6c, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x64, 0x65, - 0x74, 0x61, 0x63, 0x68, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x65, - 0x6e, 0x74, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x17, 0x6c, - 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x44, 0x65, 0x74, 0x61, 0x63, 0x68, - 0x65, 0x64, 0x43, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0xd1, - 0x01, 0x0a, 0x11, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, - 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x4d, 0x0a, 0x0a, - 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, - 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x47, - 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x64, 0x65, - 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x41, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, - 0x69, 0x6f, 0x6e, 0x1a, 0x6d, 0x0a, 0x0a, 0x41, 0x6e, 0x6e, 0x6f, 0x74, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x04, 0x70, 0x61, 0x74, - 0x68, 0x18, 0x01, 0x20, 0x03, 0x28, 0x05, 0x42, 0x02, 0x10, 0x01, 0x52, - 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0a, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x46, 0x69, - 0x6c, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x62, 0x65, 0x67, 0x69, 0x6e, - 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x42, 0x7e, 0x0a, 0x13, 0x63, 0x6f, - 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x62, 0x75, 0x66, 0x42, 0x10, 0x44, 0x65, 0x73, 0x63, 0x72, - 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x48, - 0x01, 0x5a, 0x2d, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, - 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, - 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x70, 0x62, - 0xf8, 0x01, 0x01, 0xa2, 0x02, 0x03, 0x47, 0x50, 0x42, 0xaa, 0x02, 0x1a, - 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, - 0x62, 0x75, 0x66, 0x2e, 0x52, 0x65, 0x66, 0x6c, 0x65, 0x63, 0x74, 0x69, - 0x6f, 0x6e, 0x0a, 0xac, 0x07, 0x0a, 0x25, 0x67, 0x6f, 0x6f, 0x67, 0x6c, - 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x63, - 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x2f, 0x70, 0x6c, 0x75, 0x67, - 0x69, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x67, 0x6f, - 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, - 0x66, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x1a, 0x20, - 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x62, 0x75, 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x63, 0x0a, 0x07, - 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x6d, - 0x61, 0x6a, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, - 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x69, 0x6e, - 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x6d, 0x69, - 0x6e, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x61, 0x74, 0x63, 0x68, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x70, 0x61, 0x74, 0x63, - 0x68, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x75, 0x66, 0x66, 0x69, - 0x78, 0x22, 0xf1, 0x01, 0x0a, 0x14, 0x43, 0x6f, 0x64, 0x65, 0x47, 0x65, - 0x6e, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x74, - 0x6f, 0x5f, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x18, 0x01, - 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x66, 0x69, 0x6c, 0x65, 0x54, 0x6f, - 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x12, 0x1c, 0x0a, 0x09, - 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x09, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, - 0x65, 0x72, 0x12, 0x43, 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, - 0x66, 0x69, 0x6c, 0x65, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, - 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x44, 0x65, 0x73, - 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, - 0x52, 0x09, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x46, 0x69, 0x6c, 0x65, 0x12, - 0x4c, 0x0a, 0x10, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x5f, - 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x21, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x63, 0x6f, 0x6d, 0x70, - 0x69, 0x6c, 0x65, 0x72, 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, - 0x52, 0x0f, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x56, 0x65, - 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x94, 0x03, 0x0a, 0x15, 0x43, 0x6f, - 0x64, 0x65, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, - 0x72, 0x72, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, - 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x2d, 0x0a, 0x12, 0x73, 0x75, 0x70, - 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x5f, 0x66, 0x65, 0x61, 0x74, 0x75, - 0x72, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x11, 0x73, - 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x46, 0x65, 0x61, 0x74, - 0x75, 0x72, 0x65, 0x73, 0x12, 0x48, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65, - 0x18, 0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x67, 0x6f, 0x6f, - 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, - 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x2e, 0x43, 0x6f, - 0x64, 0x65, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x46, 0x69, 0x6c, 0x65, - 0x52, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x1a, 0xb1, 0x01, 0x0a, 0x04, 0x46, - 0x69, 0x6c, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, - 0x27, 0x0a, 0x0f, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, - 0x5f, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0e, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x50, - 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6e, 0x74, - 0x65, 0x6e, 0x74, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, - 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, 0x52, 0x0a, 0x13, 0x67, 0x65, - 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x63, 0x6f, 0x64, 0x65, - 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x22, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, - 0x74, 0x65, 0x64, 0x43, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, - 0x11, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x43, 0x6f, - 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x38, 0x0a, 0x07, 0x46, 0x65, - 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x10, 0x0a, 0x0c, 0x46, 0x45, 0x41, - 0x54, 0x55, 0x52, 0x45, 0x5f, 0x4e, 0x4f, 0x4e, 0x45, 0x10, 0x00, 0x12, - 0x1b, 0x0a, 0x17, 0x46, 0x45, 0x41, 0x54, 0x55, 0x52, 0x45, 0x5f, 0x50, - 0x52, 0x4f, 0x54, 0x4f, 0x33, 0x5f, 0x4f, 0x50, 0x54, 0x49, 0x4f, 0x4e, - 0x41, 0x4c, 0x10, 0x01, 0x42, 0x57, 0x0a, 0x1c, 0x63, 0x6f, 0x6d, 0x2e, - 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x62, 0x75, 0x66, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, - 0x42, 0x0c, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x50, 0x72, 0x6f, 0x74, - 0x6f, 0x73, 0x5a, 0x29, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, - 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, - 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x70, 0x62, 0x0a, 0xc8, 0x17, + 0x0a, 0x92, 0x0c, 0x0a, 0x26, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x6c, + 0x69, 0x62, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, + 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x6d, 0x70, 0x6f, 0x72, + 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1c, 0x73, 0x77, 0x69, + 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, + 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, + 0x74, 0x22, 0x63, 0x0a, 0x07, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x05, 0x6d, 0x61, 0x6a, 0x6f, 0x72, 0x12, 0x14, + 0x0a, 0x05, 0x6d, 0x69, 0x6e, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x05, 0x6d, 0x69, 0x6e, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, + 0x70, 0x61, 0x74, 0x63, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x05, 0x70, 0x61, 0x74, 0x63, 0x68, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x75, + 0x66, 0x66, 0x69, 0x78, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x73, 0x75, 0x66, 0x66, 0x69, 0x78, 0x22, 0x95, 0x01, 0x0a, 0x0d, 0x45, + 0x78, 0x74, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x4f, 0x6e, 0x65, + 0x12, 0x5d, 0x0a, 0x0d, 0x73, 0x75, 0x62, 0x5f, 0x6d, 0x73, 0x67, 0x5f, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x39, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, + 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, + 0x64, 0x61, 0x62, 0x6c, 0x65, 0x4f, 0x6e, 0x65, 0x2e, 0x45, 0x78, 0x74, + 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x77, 0x6f, 0x52, 0x0b, + 0x73, 0x75, 0x62, 0x4d, 0x73, 0x67, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x1a, + 0x1a, 0x0a, 0x0d, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, + 0x65, 0x54, 0x77, 0x6f, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, + 0x80, 0x80, 0x02, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, + 0x80, 0x02, 0x4a, 0xcc, 0x09, 0x0a, 0x06, 0x12, 0x04, 0x10, 0x00, 0x24, + 0x01, 0x0a, 0xa0, 0x05, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x10, 0x00, 0x12, + 0x32, 0x95, 0x05, 0x20, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x53, + 0x77, 0x69, 0x66, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x4c, 0x69, 0x62, 0x72, 0x61, 0x72, + 0x79, 0x54, 0x65, 0x73, 0x74, 0x73, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x6c, 0x69, 0x62, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x6d, 0x70, + 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x2d, 0x20, + 0x74, 0x65, 0x73, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x0a, 0x0a, + 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x69, 0x73, 0x20, 0x70, 0x61, 0x72, + 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x53, 0x77, 0x69, + 0x66, 0x74, 0x2e, 0x6f, 0x72, 0x67, 0x20, 0x6f, 0x70, 0x65, 0x6e, 0x20, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, + 0x63, 0x74, 0x0a, 0x0a, 0x20, 0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x20, 0x28, 0x63, 0x29, 0x20, 0x32, 0x30, 0x32, 0x34, 0x20, + 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x49, 0x6e, 0x63, 0x2e, 0x20, 0x61, + 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x53, 0x77, 0x69, 0x66, 0x74, + 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x61, 0x75, 0x74, + 0x68, 0x6f, 0x72, 0x73, 0x0a, 0x20, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, + 0x65, 0x64, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x41, 0x70, 0x61, + 0x63, 0x68, 0x65, 0x20, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x20, + 0x76, 0x32, 0x2e, 0x30, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x52, 0x75, + 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x4c, 0x69, 0x62, 0x72, 0x61, 0x72, + 0x79, 0x20, 0x45, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x0a, + 0x0a, 0x20, 0x53, 0x65, 0x65, 0x20, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, + 0x2f, 0x73, 0x77, 0x69, 0x66, 0x74, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x4c, + 0x49, 0x43, 0x45, 0x4e, 0x53, 0x45, 0x2e, 0x74, 0x78, 0x74, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x6c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x20, 0x69, + 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x20, + 0x53, 0x65, 0x65, 0x20, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x73, + 0x77, 0x69, 0x66, 0x74, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x43, 0x4f, 0x4e, + 0x54, 0x52, 0x49, 0x42, 0x55, 0x54, 0x4f, 0x52, 0x53, 0x2e, 0x74, 0x78, + 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, + 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x53, 0x77, 0x69, 0x66, 0x74, 0x20, + 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x61, 0x75, 0x74, 0x68, + 0x6f, 0x72, 0x73, 0x0a, 0x0a, 0x20, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, + 0x2f, 0x0a, 0x2f, 0x20, 0x54, 0x65, 0x73, 0x74, 0x20, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x54, 0x65, 0x73, 0x74, 0x73, + 0x2f, 0x53, 0x77, 0x69, 0x66, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x4c, 0x69, 0x62, 0x72, + 0x61, 0x72, 0x79, 0x54, 0x65, 0x73, 0x74, 0x73, 0x2f, 0x54, 0x65, 0x73, + 0x74, 0x5f, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, + 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x0a, 0x2f, 0x0a, 0x20, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x0a, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x12, + 0x00, 0x25, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x14, 0x00, + 0x19, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x14, + 0x08, 0x0f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, + 0x15, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x04, + 0x12, 0x03, 0x15, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x15, 0x0b, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x15, 0x11, 0x16, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x15, 0x19, 0x1a, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x16, 0x02, 0x1b, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x04, 0x12, 0x03, 0x16, + 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, + 0x03, 0x16, 0x0b, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x16, 0x11, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x16, 0x19, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x17, 0x02, 0x1b, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x02, 0x04, 0x12, 0x03, 0x17, 0x02, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x17, 0x0b, + 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x17, 0x11, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x17, 0x19, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x03, 0x12, 0x03, 0x18, 0x02, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x03, 0x04, 0x12, 0x03, 0x18, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x03, 0x05, 0x12, 0x03, 0x18, 0x0b, 0x11, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x18, 0x12, 0x18, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x18, + 0x1b, 0x1c, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x1b, 0x00, + 0x24, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x1b, + 0x08, 0x15, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x01, 0x03, 0x00, 0x12, 0x04, + 0x1d, 0x02, 0x1f, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x03, 0x00, + 0x01, 0x12, 0x03, 0x1d, 0x0a, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x03, 0x00, 0x05, 0x12, 0x03, 0x1e, 0x04, 0x1b, 0x0a, 0x0d, 0x0a, 0x06, + 0x04, 0x01, 0x03, 0x00, 0x05, 0x00, 0x12, 0x03, 0x1e, 0x0f, 0x1a, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x05, 0x00, 0x01, 0x12, 0x03, + 0x1e, 0x0f, 0x13, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x01, 0x03, 0x00, 0x05, + 0x00, 0x02, 0x12, 0x03, 0x1e, 0x17, 0x1a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x01, 0x02, 0x00, 0x12, 0x03, 0x21, 0x02, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x00, 0x04, 0x12, 0x03, 0x21, 0x02, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, 0x03, 0x21, 0x0b, 0x18, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x21, + 0x19, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, + 0x03, 0x21, 0x29, 0x2a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x05, 0x12, + 0x03, 0x23, 0x02, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x05, 0x00, + 0x12, 0x03, 0x23, 0x0d, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x05, + 0x00, 0x01, 0x12, 0x03, 0x23, 0x0d, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x01, 0x05, 0x00, 0x02, 0x12, 0x03, 0x23, 0x15, 0x18, 0x0a, 0xfa, 0x2f, 0x0a, 0x1f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x6c, 0x69, 0x62, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, - 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x67, 0x6f, - 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, - 0x66, 0x2f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x25, 0x67, 0x6f, 0x6f, 0x67, - 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, - 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x2f, 0x70, 0x6c, 0x75, - 0x67, 0x69, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xa7, 0x04, - 0x0a, 0x0f, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4d, 0x65, - 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, - 0x6c, 0x64, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, - 0x69, 0x65, 0x6c, 0x64, 0x31, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, - 0x6c, 0x64, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x66, - 0x69, 0x65, 0x6c, 0x64, 0x32, 0x12, 0x3d, 0x0a, 0x06, 0x66, 0x69, 0x65, - 0x6c, 0x64, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, - 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, - 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, - 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x45, 0x6e, 0x75, 0x6d, 0x48, 0x00, - 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x12, 0x48, 0x0a, 0x06, - 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, - 0x32, 0x2e, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, + 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x70, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x6c, 0x69, 0x62, 0x5f, 0x64, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x5f, + 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x22, 0xa7, 0x04, 0x0a, 0x0f, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, + 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x16, 0x0a, 0x06, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x12, 0x16, 0x0a, 0x06, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x12, 0x3d, 0x0a, 0x06, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x23, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, - 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4d, 0x65, 0x73, - 0x73, 0x61, 0x67, 0x65, 0x2e, 0x53, 0x75, 0x62, 0x45, 0x6e, 0x75, 0x6d, - 0x48, 0x00, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x12, 0x4b, - 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x18, 0x05, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, - 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, - 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4d, - 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x53, 0x75, 0x62, 0x4d, 0x65, - 0x73, 0x73, 0x61, 0x67, 0x65, 0x48, 0x00, 0x52, 0x06, 0x66, 0x69, 0x65, - 0x6c, 0x64, 0x35, 0x12, 0x41, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, - 0x36, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x73, 0x77, - 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, - 0x65, 0x76, 0x65, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, - 0x48, 0x00, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x1a, 0x87, - 0x01, 0x0a, 0x0a, 0x53, 0x75, 0x62, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, - 0x65, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, - 0x31, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, - 0x32, 0x12, 0x49, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x73, 0x77, 0x69, 0x66, + 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x45, 0x6e, 0x75, + 0x6d, 0x48, 0x00, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x12, + 0x48, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x34, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x2e, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, + 0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, + 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x53, 0x75, 0x62, 0x45, + 0x6e, 0x75, 0x6d, 0x48, 0x00, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x34, 0x12, 0x4b, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x53, 0x75, - 0x62, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x06, 0x66, 0x69, - 0x65, 0x6c, 0x64, 0x33, 0x22, 0x3c, 0x0a, 0x07, 0x53, 0x75, 0x62, 0x45, - 0x6e, 0x75, 0x6d, 0x12, 0x0f, 0x0a, 0x0b, 0x53, 0x55, 0x42, 0x5f, 0x56, - 0x41, 0x4c, 0x55, 0x45, 0x5f, 0x30, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, - 0x53, 0x55, 0x42, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x5f, 0x31, 0x10, - 0x01, 0x12, 0x0f, 0x0a, 0x0b, 0x53, 0x55, 0x42, 0x5f, 0x56, 0x41, 0x4c, - 0x55, 0x45, 0x5f, 0x32, 0x10, 0x02, 0x42, 0x03, 0x0a, 0x01, 0x6f, 0x22, - 0x8d, 0x01, 0x0a, 0x10, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, - 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x12, 0x3a, 0x0a, 0x04, - 0x6c, 0x65, 0x66, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, + 0x62, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x48, 0x00, 0x52, 0x06, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x35, 0x12, 0x41, 0x0a, 0x06, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x36, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, - 0x67, 0x65, 0x52, 0x04, 0x6c, 0x65, 0x66, 0x74, 0x12, 0x3d, 0x0a, 0x05, - 0x72, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x27, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, - 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4d, 0x65, 0x73, 0x73, - 0x61, 0x67, 0x65, 0x32, 0x52, 0x05, 0x72, 0x69, 0x67, 0x68, 0x74, 0x22, - 0x79, 0x0a, 0x0c, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x52, - 0x65, 0x66, 0x73, 0x12, 0x34, 0x0a, 0x04, 0x64, 0x65, 0x73, 0x63, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x6f, 0x67, - 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, - 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, - 0x6f, 0x74, 0x6f, 0x52, 0x04, 0x64, 0x65, 0x73, 0x63, 0x12, 0x33, 0x0a, - 0x03, 0x76, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, - 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, - 0x72, 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x03, 0x76, - 0x65, 0x72, 0x22, 0xd6, 0x01, 0x0a, 0x0c, 0x53, 0x63, 0x6f, 0x70, 0x65, - 0x72, 0x46, 0x6f, 0x72, 0x45, 0x78, 0x74, 0x32, 0x61, 0x0a, 0x08, 0x65, - 0x78, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x1f, 0x2e, 0x67, 0x6f, - 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, - 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xb9, 0x85, 0x06, 0x20, 0x01, 0x28, 0x0e, - 0x32, 0x23, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, - 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, - 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x45, 0x6e, 0x75, - 0x6d, 0x52, 0x07, 0x65, 0x78, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x63, - 0x0a, 0x07, 0x65, 0x78, 0x74, 0x5f, 0x6d, 0x73, 0x67, 0x12, 0x1f, 0x2e, - 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, - 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xba, 0x85, 0x06, 0x20, 0x01, + 0x67, 0x65, 0x32, 0x48, 0x00, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x36, 0x1a, 0x87, 0x01, 0x0a, 0x0a, 0x53, 0x75, 0x62, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x31, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x32, 0x12, 0x49, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x33, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x73, + 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, + 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x2e, 0x53, 0x75, 0x62, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, + 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x33, 0x22, 0x3c, 0x0a, 0x07, 0x53, + 0x75, 0x62, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x0f, 0x0a, 0x0b, 0x53, 0x55, + 0x42, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x5f, 0x30, 0x10, 0x00, 0x12, + 0x0f, 0x0a, 0x0b, 0x53, 0x55, 0x42, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, + 0x5f, 0x31, 0x10, 0x01, 0x12, 0x0f, 0x0a, 0x0b, 0x53, 0x55, 0x42, 0x5f, + 0x56, 0x41, 0x4c, 0x55, 0x45, 0x5f, 0x32, 0x10, 0x02, 0x42, 0x03, 0x0a, + 0x01, 0x6f, 0x22, 0x8d, 0x01, 0x0a, 0x10, 0x54, 0x6f, 0x70, 0x4c, 0x65, + 0x76, 0x65, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x12, + 0x3a, 0x0a, 0x04, 0x6c, 0x65, 0x66, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, + 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x04, 0x6c, 0x65, 0x66, 0x74, 0x12, + 0x3d, 0x0a, 0x05, 0x72, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4d, - 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x52, 0x06, 0x65, 0x78, 0x74, - 0x4d, 0x73, 0x67, 0x22, 0xfb, 0x07, 0x0a, 0x18, 0x50, 0x72, 0x6f, 0x74, - 0x6f, 0x32, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, - 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x22, 0x0a, 0x0d, - 0x72, 0x65, 0x71, 0x5f, 0x73, 0x74, 0x72, 0x5f, 0x66, 0x69, 0x65, 0x6c, - 0x64, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x0b, 0x72, 0x65, 0x71, - 0x53, 0x74, 0x72, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x26, 0x0a, 0x0f, - 0x72, 0x65, 0x71, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x66, 0x69, - 0x65, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x02, 0x28, 0x05, 0x52, 0x0d, 0x72, - 0x65, 0x71, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, 0x6c, 0x64, - 0x12, 0x49, 0x0a, 0x0e, 0x72, 0x65, 0x71, 0x5f, 0x65, 0x6e, 0x75, 0x6d, - 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x03, 0x20, 0x02, 0x28, 0x0e, - 0x32, 0x23, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x52, 0x05, 0x72, 0x69, 0x67, + 0x68, 0x74, 0x22, 0x86, 0x01, 0x0a, 0x0c, 0x45, 0x78, 0x74, 0x65, 0x72, + 0x6e, 0x61, 0x6c, 0x52, 0x65, 0x66, 0x73, 0x12, 0x3d, 0x0a, 0x03, 0x6f, + 0x6e, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x73, + 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x69, 0x6d, 0x70, + 0x6f, 0x72, 0x74, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x61, 0x62, + 0x6c, 0x65, 0x4f, 0x6e, 0x65, 0x52, 0x03, 0x6f, 0x6e, 0x65, 0x12, 0x37, + 0x0a, 0x03, 0x76, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x25, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, + 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x52, 0x03, 0x76, 0x65, 0x72, 0x22, 0x8a, 0x02, 0x0a, 0x0c, + 0x53, 0x63, 0x6f, 0x70, 0x65, 0x72, 0x46, 0x6f, 0x72, 0x45, 0x78, 0x74, + 0x32, 0x7b, 0x0a, 0x08, 0x65, 0x78, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, + 0x12, 0x39, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, - 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x45, 0x6e, 0x75, - 0x6d, 0x52, 0x0c, 0x72, 0x65, 0x71, 0x45, 0x6e, 0x75, 0x6d, 0x46, 0x69, - 0x65, 0x6c, 0x64, 0x12, 0x52, 0x0a, 0x11, 0x72, 0x65, 0x71, 0x5f, 0x6d, - 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, - 0x18, 0x04, 0x20, 0x02, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x77, 0x69, - 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, - 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, - 0x76, 0x65, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0f, - 0x72, 0x65, 0x71, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x69, - 0x65, 0x6c, 0x64, 0x12, 0x22, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x5f, 0x73, - 0x74, 0x72, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x0b, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0b, 0x6f, 0x70, 0x74, 0x53, 0x74, 0x72, 0x46, 0x69, - 0x65, 0x6c, 0x64, 0x12, 0x26, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x5f, 0x69, - 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x0c, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x49, 0x6e, 0x74, - 0x33, 0x32, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x49, 0x0a, 0x0e, 0x6f, - 0x70, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x66, 0x69, 0x65, 0x6c, - 0x64, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x73, 0x77, + 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x45, 0x78, 0x74, 0x65, + 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x4f, 0x6e, 0x65, 0x2e, 0x45, 0x78, + 0x74, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x77, 0x6f, 0x18, + 0xb9, 0x85, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, - 0x65, 0x76, 0x65, 0x6c, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0c, 0x6f, 0x70, - 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x52, - 0x0a, 0x11, 0x6f, 0x70, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, - 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x0e, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, - 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, - 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4d, 0x65, - 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x4d, 0x65, - 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x28, - 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x5f, 0x73, 0x74, 0x72, - 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x15, 0x20, 0x03, 0x28, 0x09, - 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x53, 0x74, 0x72, 0x46, - 0x69, 0x65, 0x6c, 0x64, 0x12, 0x2c, 0x0a, 0x12, 0x72, 0x65, 0x70, 0x65, - 0x61, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x66, 0x69, 0x65, - 0x6c, 0x64, 0x18, 0x16, 0x20, 0x03, 0x28, 0x05, 0x52, 0x10, 0x72, 0x65, - 0x70, 0x65, 0x61, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, - 0x6c, 0x64, 0x12, 0x4f, 0x0a, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, - 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, - 0x17, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x73, 0x77, 0x69, 0x66, - 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, - 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, - 0x65, 0x6c, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, - 0x61, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, - 0x58, 0x0a, 0x14, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x5f, 0x6d, 0x65, - 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, - 0x18, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x77, 0x69, 0x66, - 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, - 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, - 0x65, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x12, 0x72, - 0x65, 0x70, 0x65, 0x61, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, - 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x28, 0x0a, 0x0f, 0x6f, 0x6e, 0x65, - 0x6f, 0x66, 0x5f, 0x73, 0x74, 0x72, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, - 0x18, 0x1f, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0d, 0x6f, 0x6e, - 0x65, 0x6f, 0x66, 0x53, 0x74, 0x72, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, - 0x2c, 0x0a, 0x11, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x69, 0x6e, 0x74, - 0x33, 0x32, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x20, 0x20, 0x01, - 0x28, 0x05, 0x48, 0x00, 0x52, 0x0f, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x49, - 0x6e, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x4f, 0x0a, - 0x10, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x5f, - 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x21, 0x20, 0x01, 0x28, 0x0e, 0x32, - 0x23, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, - 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, - 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x45, 0x6e, 0x75, 0x6d, - 0x48, 0x00, 0x52, 0x0e, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x45, 0x6e, 0x75, - 0x6d, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x58, 0x0a, 0x13, 0x6f, 0x6e, - 0x65, 0x6f, 0x66, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, - 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x22, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x26, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, + 0x65, 0x76, 0x65, 0x6c, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x07, 0x65, 0x78, + 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x7d, 0x0a, 0x07, 0x65, 0x78, 0x74, + 0x5f, 0x6d, 0x73, 0x67, 0x12, 0x39, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, + 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, + 0x74, 0x65, 0x73, 0x74, 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x2e, + 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x4f, 0x6e, + 0x65, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, + 0x54, 0x77, 0x6f, 0x18, 0xba, 0x85, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x27, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4d, 0x65, 0x73, 0x73, - 0x61, 0x67, 0x65, 0x48, 0x00, 0x52, 0x11, 0x6f, 0x6e, 0x65, 0x6f, 0x66, + 0x61, 0x67, 0x65, 0x32, 0x52, 0x06, 0x65, 0x78, 0x74, 0x4d, 0x73, 0x67, + 0x22, 0xfb, 0x07, 0x0a, 0x18, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x50, 0x72, 0x65, + 0x73, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x22, 0x0a, 0x0d, 0x72, 0x65, 0x71, + 0x5f, 0x73, 0x74, 0x72, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x01, + 0x20, 0x02, 0x28, 0x09, 0x52, 0x0b, 0x72, 0x65, 0x71, 0x53, 0x74, 0x72, + 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x26, 0x0a, 0x0f, 0x72, 0x65, 0x71, + 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x18, 0x02, 0x20, 0x02, 0x28, 0x05, 0x52, 0x0d, 0x72, 0x65, 0x71, 0x49, + 0x6e, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x49, 0x0a, + 0x0e, 0x72, 0x65, 0x71, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x18, 0x03, 0x20, 0x02, 0x28, 0x0e, 0x32, 0x23, 0x2e, + 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, + 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0c, + 0x72, 0x65, 0x71, 0x45, 0x6e, 0x75, 0x6d, 0x46, 0x69, 0x65, 0x6c, 0x64, + 0x12, 0x52, 0x0a, 0x11, 0x72, 0x65, 0x71, 0x5f, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x04, 0x20, + 0x02, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, + 0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, + 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0f, 0x72, 0x65, 0x71, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x69, 0x65, 0x6c, 0x64, - 0x42, 0x03, 0x0a, 0x01, 0x6f, 0x22, 0x5e, 0x0a, 0x19, 0x4d, 0x73, 0x67, - 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x6e, - 0x67, 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x2a, 0x04, - 0x08, 0x01, 0x10, 0x02, 0x2a, 0x04, 0x08, 0x03, 0x10, 0x04, 0x2a, 0x04, - 0x08, 0x02, 0x10, 0x03, 0x2a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x2a, 0x04, - 0x08, 0x07, 0x10, 0x08, 0x2a, 0x04, 0x08, 0x09, 0x10, 0x0a, 0x2a, 0x04, - 0x08, 0x64, 0x10, 0x6f, 0x2a, 0x05, 0x08, 0x7e, 0x10, 0x83, 0x01, 0x2a, - 0x04, 0x08, 0x6f, 0x10, 0x79, 0x4a, 0x04, 0x08, 0x08, 0x10, 0x09, 0x4a, - 0x04, 0x08, 0x79, 0x10, 0x7e, 0x22, 0xd5, 0x01, 0x0a, 0x23, 0x4d, 0x73, - 0x67, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, - 0x6e, 0x67, 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x57, - 0x69, 0x74, 0x68, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x12, 0x16, 0x0a, - 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x18, 0x06, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x12, 0x1a, 0x0a, - 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x34, 0x18, 0x7c, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, - 0x34, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, - 0x35, 0x18, 0x7d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, - 0x6c, 0x64, 0x31, 0x32, 0x35, 0x12, 0x1b, 0x0a, 0x08, 0x66, 0x69, 0x65, - 0x6c, 0x64, 0x32, 0x30, 0x30, 0x18, 0xc8, 0x01, 0x20, 0x01, 0x28, 0x05, - 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x30, 0x2a, 0x04, - 0x08, 0x01, 0x10, 0x02, 0x2a, 0x04, 0x08, 0x03, 0x10, 0x04, 0x2a, 0x04, - 0x08, 0x02, 0x10, 0x03, 0x2a, 0x04, 0x08, 0x04, 0x10, 0x05, 0x2a, 0x04, - 0x08, 0x07, 0x10, 0x08, 0x2a, 0x04, 0x08, 0x09, 0x10, 0x0a, 0x2a, 0x04, - 0x08, 0x64, 0x10, 0x6f, 0x2a, 0x05, 0x08, 0x7e, 0x10, 0x83, 0x01, 0x2a, - 0x04, 0x08, 0x6f, 0x10, 0x79, 0x4a, 0x04, 0x08, 0x08, 0x10, 0x09, 0x4a, - 0x04, 0x08, 0x79, 0x10, 0x7c, 0x22, 0xcc, 0x01, 0x0a, 0x22, 0x4d, 0x73, - 0x67, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, - 0x6e, 0x67, 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x4e, - 0x6f, 0x4d, 0x65, 0x72, 0x67, 0x69, 0x6e, 0x67, 0x12, 0x16, 0x0a, 0x06, - 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, - 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x12, 0x16, 0x0a, 0x06, - 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, - 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x12, 0x16, 0x0a, 0x06, - 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, - 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x12, 0x18, 0x0a, 0x07, - 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x18, 0x0d, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x12, 0x18, - 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x35, 0x18, 0x0f, 0x20, - 0x01, 0x28, 0x05, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x35, - 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x31, 0x18, - 0x15, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, - 0x32, 0x31, 0x2a, 0x04, 0x08, 0x03, 0x10, 0x06, 0x2a, 0x04, 0x08, 0x07, - 0x10, 0x0d, 0x2a, 0x04, 0x08, 0x10, 0x10, 0x15, 0x2a, 0x3c, 0x0a, 0x0c, - 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x45, 0x6e, 0x75, 0x6d, - 0x12, 0x0e, 0x0a, 0x0a, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x5f, 0x5a, 0x45, - 0x52, 0x4f, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x56, 0x41, 0x4c, 0x55, - 0x45, 0x5f, 0x4f, 0x4e, 0x45, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x56, - 0x41, 0x4c, 0x55, 0x45, 0x5f, 0x54, 0x57, 0x4f, 0x10, 0x02, 0x32, 0xb1, - 0x01, 0x0a, 0x0b, 0x53, 0x6f, 0x6d, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, - 0x63, 0x65, 0x12, 0x4a, 0x0a, 0x03, 0x46, 0x6f, 0x6f, 0x12, 0x20, 0x2e, - 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x21, 0x2e, 0x67, 0x6f, - 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, - 0x66, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x72, 0x2e, 0x56, - 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x56, 0x0a, 0x03, 0x42, 0x61, - 0x72, 0x12, 0x26, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, - 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, - 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4d, 0x65, - 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x27, 0x2e, 0x73, 0x77, 0x69, 0x66, - 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, - 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, - 0x65, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x3a, 0x38, - 0x0a, 0x07, 0x65, 0x78, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x12, 0x1d, 0x2e, - 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, - 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x90, 0xbf, 0x05, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x06, 0x65, 0x78, 0x74, 0x53, 0x74, 0x72, 0x42, 0x06, 0xba, 0x02, - 0x03, 0x53, 0x44, 0x54, 0x0a, 0xae, 0x0a, 0x0a, 0x20, 0x70, 0x6c, 0x75, - 0x67, 0x69, 0x6e, 0x6c, 0x69, 0x62, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, - 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x32, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x73, 0x77, 0x69, 0x66, 0x74, + 0x12, 0x22, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x5f, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0b, 0x6f, 0x70, 0x74, 0x53, 0x74, 0x72, 0x46, 0x69, 0x65, 0x6c, 0x64, + 0x12, 0x26, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x33, + 0x32, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x0c, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x46, + 0x69, 0x65, 0x6c, 0x64, 0x12, 0x49, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x5f, + 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x0d, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, - 0x74, 0x65, 0x73, 0x74, 0x22, 0xc4, 0x09, 0x0a, 0x18, 0x50, 0x72, 0x6f, - 0x74, 0x6f, 0x33, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x6f, - 0x72, 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x1b, 0x0a, - 0x09, 0x73, 0x74, 0x72, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x74, 0x72, 0x46, 0x69, 0x65, - 0x6c, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, - 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, - 0x0a, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, - 0x56, 0x0a, 0x0a, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x66, 0x69, 0x65, 0x6c, - 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x37, 0x2e, 0x73, 0x77, - 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x50, 0x72, 0x6f, 0x74, - 0x6f, 0x33, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, - 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x75, 0x62, - 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x09, 0x65, 0x6e, 0x75, 0x6d, 0x46, 0x69, - 0x65, 0x6c, 0x64, 0x12, 0x48, 0x0a, 0x0d, 0x6d, 0x65, 0x73, 0x73, 0x61, - 0x67, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, + 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, + 0x6c, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x45, 0x6e, + 0x75, 0x6d, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x52, 0x0a, 0x11, 0x6f, + 0x70, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, + 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, + 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x28, 0x0a, 0x10, 0x72, + 0x65, 0x70, 0x65, 0x61, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x5f, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x18, 0x15, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x72, + 0x65, 0x70, 0x65, 0x61, 0x74, 0x53, 0x74, 0x72, 0x46, 0x69, 0x65, 0x6c, + 0x64, 0x12, 0x2c, 0x0a, 0x12, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x5f, + 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, + 0x16, 0x20, 0x03, 0x28, 0x05, 0x52, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, + 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, + 0x4f, 0x0a, 0x11, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x5f, 0x65, 0x6e, + 0x75, 0x6d, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x17, 0x20, 0x03, + 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, - 0x73, 0x74, 0x2e, 0x4f, 0x74, 0x68, 0x65, 0x72, 0x4d, 0x65, 0x73, 0x73, - 0x61, 0x67, 0x65, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, - 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x27, 0x0a, 0x0d, 0x6f, 0x70, 0x74, - 0x5f, 0x73, 0x74, 0x72, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x0b, - 0x20, 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x0b, 0x6f, 0x70, 0x74, 0x53, - 0x74, 0x72, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x88, 0x01, 0x01, 0x12, 0x2b, - 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, - 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x05, 0x48, - 0x02, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x46, - 0x69, 0x65, 0x6c, 0x64, 0x88, 0x01, 0x01, 0x12, 0x62, 0x0a, 0x0e, 0x6f, - 0x70, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x66, 0x69, 0x65, 0x6c, - 0x64, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x37, 0x2e, 0x73, 0x77, - 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x50, 0x72, 0x6f, 0x74, - 0x6f, 0x33, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, - 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x75, 0x62, - 0x45, 0x6e, 0x75, 0x6d, 0x48, 0x03, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x45, - 0x6e, 0x75, 0x6d, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x88, 0x01, 0x01, 0x12, - 0x54, 0x0a, 0x11, 0x6f, 0x70, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, - 0x67, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x0e, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, + 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x45, + 0x6e, 0x75, 0x6d, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x45, + 0x6e, 0x75, 0x6d, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x58, 0x0a, 0x14, + 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x18, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, - 0x73, 0x74, 0x2e, 0x4f, 0x74, 0x68, 0x65, 0x72, 0x4d, 0x65, 0x73, 0x73, - 0x61, 0x67, 0x65, 0x48, 0x04, 0x52, 0x0f, 0x6f, 0x70, 0x74, 0x4d, 0x65, - 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x88, 0x01, - 0x01, 0x12, 0x28, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x5f, - 0x73, 0x74, 0x72, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x15, 0x20, - 0x03, 0x28, 0x09, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x53, - 0x74, 0x72, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x2c, 0x0a, 0x12, 0x72, - 0x65, 0x70, 0x65, 0x61, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, - 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x16, 0x20, 0x03, 0x28, 0x05, 0x52, - 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, - 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x63, 0x0a, 0x11, 0x72, 0x65, 0x70, - 0x65, 0x61, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x66, 0x69, 0x65, - 0x6c, 0x64, 0x18, 0x17, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x37, 0x2e, 0x73, + 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x12, 0x72, 0x65, 0x70, 0x65, + 0x61, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x69, 0x65, + 0x6c, 0x64, 0x12, 0x28, 0x0a, 0x0f, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, + 0x73, 0x74, 0x72, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x1f, 0x20, + 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0d, 0x6f, 0x6e, 0x65, 0x6f, 0x66, + 0x53, 0x74, 0x72, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x2c, 0x0a, 0x11, + 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x20, 0x20, 0x01, 0x28, 0x05, 0x48, + 0x00, 0x52, 0x0f, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x49, 0x6e, 0x74, 0x33, + 0x32, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x4f, 0x0a, 0x10, 0x6f, 0x6e, + 0x65, 0x6f, 0x66, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x18, 0x21, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x73, + 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, + 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x45, 0x6e, 0x75, 0x6d, 0x48, 0x00, 0x52, + 0x0e, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x45, 0x6e, 0x75, 0x6d, 0x46, 0x69, + 0x65, 0x6c, 0x64, 0x12, 0x58, 0x0a, 0x13, 0x6f, 0x6e, 0x65, 0x6f, 0x66, + 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x18, 0x22, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, - 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x50, 0x72, 0x6f, - 0x74, 0x6f, 0x33, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x6f, - 0x72, 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x75, - 0x62, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x65, 0x61, - 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x55, - 0x0a, 0x14, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x5f, 0x6d, 0x65, 0x73, - 0x73, 0x61, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x18, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, + 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, + 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x48, 0x00, 0x52, 0x11, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x03, 0x0a, + 0x01, 0x6f, 0x2a, 0x3c, 0x0a, 0x0c, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, + 0x65, 0x6c, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x0e, 0x0a, 0x0a, 0x56, 0x41, + 0x4c, 0x55, 0x45, 0x5f, 0x5a, 0x45, 0x52, 0x4f, 0x10, 0x00, 0x12, 0x0d, + 0x0a, 0x09, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x5f, 0x4f, 0x4e, 0x45, 0x10, + 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x5f, 0x54, + 0x57, 0x4f, 0x10, 0x02, 0x32, 0xc0, 0x01, 0x0a, 0x0b, 0x53, 0x6f, 0x6d, + 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x59, 0x0a, 0x03, + 0x46, 0x6f, 0x6f, 0x12, 0x2b, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, + 0x65, 0x73, 0x74, 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x45, + 0x78, 0x74, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x4f, 0x6e, 0x65, + 0x1a, 0x25, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, + 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x12, 0x56, 0x0a, 0x03, 0x42, 0x61, 0x72, 0x12, 0x26, + 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, + 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x1a, 0x27, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, + 0x73, 0x74, 0x2e, 0x54, 0x6f, 0x70, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x3a, 0x46, 0x0a, 0x07, 0x65, + 0x78, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x12, 0x2b, 0x2e, 0x73, 0x77, 0x69, + 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, + 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x69, 0x6d, 0x70, 0x6f, 0x72, + 0x74, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x61, 0x62, 0x6c, 0x65, + 0x4f, 0x6e, 0x65, 0x18, 0x90, 0xbf, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x65, 0x78, 0x74, 0x53, 0x74, 0x72, 0x42, 0x06, 0xba, 0x02, 0x03, + 0x53, 0x44, 0x54, 0x4a, 0xf8, 0x1b, 0x0a, 0x06, 0x12, 0x04, 0x10, 0x00, + 0x6a, 0x01, 0x0a, 0x80, 0x05, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x10, 0x00, + 0x12, 0x32, 0xf5, 0x04, 0x20, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, + 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x6c, 0x69, 0x62, 0x5f, 0x64, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, + 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x2d, 0x20, 0x74, 0x65, + 0x73, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x0a, 0x0a, 0x20, 0x54, + 0x68, 0x69, 0x73, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x66, + 0x69, 0x6c, 0x65, 0x20, 0x69, 0x73, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, + 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x53, 0x77, 0x69, 0x66, 0x74, + 0x2e, 0x6f, 0x72, 0x67, 0x20, 0x6f, 0x70, 0x65, 0x6e, 0x20, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x0a, 0x0a, 0x20, 0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, + 0x20, 0x28, 0x63, 0x29, 0x20, 0x32, 0x30, 0x31, 0x34, 0x20, 0x2d, 0x20, + 0x32, 0x30, 0x31, 0x37, 0x20, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x49, + 0x6e, 0x63, 0x2e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x53, 0x77, 0x69, 0x66, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, + 0x74, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x73, 0x0a, 0x20, 0x4c, + 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x64, 0x20, 0x75, 0x6e, 0x64, 0x65, + 0x72, 0x20, 0x41, 0x70, 0x61, 0x63, 0x68, 0x65, 0x20, 0x4c, 0x69, 0x63, + 0x65, 0x6e, 0x73, 0x65, 0x20, 0x76, 0x32, 0x2e, 0x30, 0x20, 0x77, 0x69, + 0x74, 0x68, 0x20, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x4c, + 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x20, 0x45, 0x78, 0x63, 0x65, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x20, 0x53, 0x65, 0x65, 0x20, 0x68, + 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x73, 0x77, 0x69, 0x66, 0x74, 0x2e, + 0x6f, 0x72, 0x67, 0x2f, 0x4c, 0x49, 0x43, 0x45, 0x4e, 0x53, 0x45, 0x2e, + 0x74, 0x78, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6c, 0x69, 0x63, 0x65, + 0x6e, 0x73, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x53, 0x65, 0x65, 0x20, 0x68, 0x74, 0x74, + 0x70, 0x3a, 0x2f, 0x2f, 0x73, 0x77, 0x69, 0x66, 0x74, 0x2e, 0x6f, 0x72, + 0x67, 0x2f, 0x43, 0x4f, 0x4e, 0x54, 0x52, 0x49, 0x42, 0x55, 0x54, 0x4f, + 0x52, 0x53, 0x2e, 0x74, 0x78, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x53, + 0x77, 0x69, 0x66, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, + 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x73, 0x0a, 0x0a, 0x20, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x2f, 0x0a, 0x2f, 0x20, 0x54, 0x65, 0x73, + 0x74, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x54, 0x65, 0x73, 0x74, 0x73, 0x2f, 0x53, 0x77, 0x69, 0x66, 0x74, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x50, 0x6c, 0x75, 0x67, 0x69, + 0x6e, 0x4c, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x54, 0x65, 0x73, 0x74, + 0x73, 0x2f, 0x54, 0x65, 0x73, 0x74, 0x5f, 0x44, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x0a, + 0x2f, 0x0a, 0x20, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x0a, 0x08, 0x0a, + 0x01, 0x02, 0x12, 0x03, 0x12, 0x00, 0x1e, 0x0a, 0x08, 0x0a, 0x01, 0x08, + 0x12, 0x03, 0x15, 0x00, 0x1c, 0x0a, 0x3a, 0x0a, 0x02, 0x08, 0x27, 0x12, + 0x03, 0x15, 0x00, 0x1c, 0x1a, 0x2f, 0x20, 0x55, 0x73, 0x65, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x6f, + 0x20, 0x74, 0x65, 0x73, 0x74, 0x20, 0x73, 0x77, 0x69, 0x66, 0x74, 0x20, + 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, + 0x03, 0x17, 0x00, 0x30, 0x0a, 0x0a, 0x0a, 0x02, 0x05, 0x00, 0x12, 0x04, + 0x19, 0x00, 0x1d, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x05, 0x00, 0x01, 0x12, + 0x03, 0x19, 0x05, 0x11, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x00, + 0x12, 0x03, 0x1a, 0x02, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, + 0x00, 0x01, 0x12, 0x03, 0x1a, 0x02, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x05, + 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x1a, 0x0f, 0x10, 0x0a, 0x0b, 0x0a, + 0x04, 0x05, 0x00, 0x02, 0x01, 0x12, 0x03, 0x1b, 0x02, 0x10, 0x0a, 0x0c, + 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x1b, 0x02, 0x0b, + 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x1b, + 0x0e, 0x0f, 0x0a, 0x0b, 0x0a, 0x04, 0x05, 0x00, 0x02, 0x02, 0x12, 0x03, + 0x1c, 0x02, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x1c, 0x02, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x05, 0x00, 0x02, + 0x02, 0x02, 0x12, 0x03, 0x1c, 0x0e, 0x0f, 0x0a, 0x0a, 0x0a, 0x02, 0x04, + 0x00, 0x12, 0x04, 0x1f, 0x00, 0x36, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, + 0x00, 0x01, 0x12, 0x03, 0x1f, 0x08, 0x17, 0x0a, 0x0c, 0x0a, 0x04, 0x04, + 0x00, 0x04, 0x00, 0x12, 0x04, 0x21, 0x02, 0x25, 0x03, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x04, 0x00, 0x01, 0x12, 0x03, 0x21, 0x07, 0x0e, 0x0a, + 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x22, + 0x04, 0x14, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x22, 0x04, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, + 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x22, 0x12, 0x13, 0x0a, 0x0d, + 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x23, 0x04, + 0x14, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, 0x01, + 0x12, 0x03, 0x23, 0x04, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, + 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x23, 0x12, 0x13, 0x0a, 0x0d, 0x0a, + 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x24, 0x04, 0x14, + 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, + 0x03, 0x24, 0x04, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, + 0x02, 0x02, 0x02, 0x12, 0x03, 0x24, 0x12, 0x13, 0x0a, 0x0c, 0x0a, 0x04, + 0x04, 0x00, 0x03, 0x00, 0x12, 0x04, 0x27, 0x02, 0x2b, 0x03, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x03, 0x00, 0x01, 0x12, 0x03, 0x27, 0x0a, 0x14, + 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x03, 0x00, 0x02, 0x00, 0x12, 0x03, + 0x28, 0x04, 0x1e, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, + 0x00, 0x04, 0x12, 0x03, 0x28, 0x04, 0x0c, 0x0a, 0x0e, 0x0a, 0x07, 0x04, + 0x00, 0x03, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x28, 0x0d, 0x12, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x28, 0x13, 0x19, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x28, 0x1c, 0x1d, 0x0a, 0x0d, 0x0a, 0x06, 0x04, + 0x00, 0x03, 0x00, 0x02, 0x01, 0x12, 0x03, 0x29, 0x04, 0x1f, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x01, 0x04, 0x12, 0x03, 0x29, + 0x04, 0x0c, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x01, + 0x05, 0x12, 0x03, 0x29, 0x0d, 0x13, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, + 0x03, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x29, 0x14, 0x1a, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x29, + 0x1d, 0x1e, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x03, 0x00, 0x02, 0x02, + 0x12, 0x03, 0x2a, 0x04, 0x23, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, + 0x00, 0x02, 0x02, 0x04, 0x12, 0x03, 0x2a, 0x04, 0x0c, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x2a, 0x0d, + 0x17, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x02, 0x01, + 0x12, 0x03, 0x2a, 0x18, 0x1e, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, + 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x2a, 0x21, 0x22, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x2d, 0x02, 0x1d, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x04, 0x12, 0x03, 0x2d, 0x02, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x2d, + 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, + 0x03, 0x2d, 0x12, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x03, 0x12, 0x03, 0x2d, 0x1b, 0x1c, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x01, 0x12, 0x03, 0x2e, 0x02, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x01, 0x04, 0x12, 0x03, 0x2e, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x2e, 0x0b, 0x10, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x2e, 0x11, + 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, + 0x2e, 0x1a, 0x1b, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x00, 0x08, 0x00, 0x12, + 0x04, 0x30, 0x02, 0x35, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x08, + 0x00, 0x01, 0x12, 0x03, 0x30, 0x08, 0x09, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x02, 0x12, 0x03, 0x31, 0x04, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x31, 0x04, 0x10, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x31, 0x11, 0x17, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x31, + 0x1a, 0x1b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, + 0x32, 0x04, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x06, + 0x12, 0x03, 0x32, 0x04, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x03, 0x01, 0x12, 0x03, 0x32, 0x0c, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x32, 0x15, 0x16, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x00, 0x02, 0x04, 0x12, 0x03, 0x33, 0x04, 0x1a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x06, 0x12, 0x03, 0x33, 0x04, 0x0e, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x33, + 0x0f, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x03, 0x12, + 0x03, 0x33, 0x18, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x05, + 0x12, 0x03, 0x34, 0x04, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x05, 0x06, 0x12, 0x03, 0x34, 0x04, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x05, 0x01, 0x12, 0x03, 0x34, 0x15, 0x1b, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x05, 0x03, 0x12, 0x03, 0x34, 0x1e, 0x1f, 0x0a, + 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x38, 0x00, 0x3b, 0x01, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x38, 0x08, 0x18, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x39, 0x02, 0x24, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x04, 0x12, 0x03, 0x39, + 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x39, 0x0b, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x39, 0x1b, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x39, 0x22, 0x23, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x01, 0x02, 0x01, 0x12, 0x03, 0x3a, 0x02, 0x26, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x01, 0x04, 0x12, 0x03, 0x3a, 0x02, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x06, 0x12, 0x03, 0x3a, 0x0b, + 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x3a, 0x1c, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x3a, 0x24, 0x25, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x02, 0x12, + 0x04, 0x3d, 0x00, 0x40, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x02, 0x01, + 0x12, 0x03, 0x3d, 0x08, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, + 0x00, 0x12, 0x03, 0x3e, 0x02, 0x3e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x00, 0x04, 0x12, 0x03, 0x3e, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x00, 0x06, 0x12, 0x03, 0x3e, 0x0b, 0x35, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, 0x3e, 0x36, 0x39, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, 0x12, 0x03, 0x3e, + 0x3c, 0x3d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x3f, 0x02, 0x38, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x04, + 0x12, 0x03, 0x3f, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, + 0x01, 0x06, 0x12, 0x03, 0x3f, 0x0b, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x3f, 0x30, 0x33, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x3f, 0x36, 0x37, 0x0a, + 0x09, 0x0a, 0x01, 0x07, 0x12, 0x04, 0x42, 0x00, 0x44, 0x01, 0x0a, 0x09, + 0x0a, 0x02, 0x07, 0x00, 0x12, 0x03, 0x43, 0x02, 0x22, 0x0a, 0x0a, 0x0a, + 0x03, 0x07, 0x00, 0x02, 0x12, 0x03, 0x42, 0x07, 0x31, 0x0a, 0x0a, 0x0a, + 0x03, 0x07, 0x00, 0x04, 0x12, 0x03, 0x43, 0x02, 0x0a, 0x0a, 0x0a, 0x0a, + 0x03, 0x07, 0x00, 0x05, 0x12, 0x03, 0x43, 0x0b, 0x11, 0x0a, 0x0a, 0x0a, + 0x03, 0x07, 0x00, 0x01, 0x12, 0x03, 0x43, 0x12, 0x19, 0x0a, 0x0a, 0x0a, + 0x03, 0x07, 0x00, 0x03, 0x12, 0x03, 0x43, 0x1c, 0x21, 0x0a, 0x0a, 0x0a, + 0x02, 0x04, 0x03, 0x12, 0x04, 0x46, 0x00, 0x4b, 0x01, 0x0a, 0x0a, 0x0a, + 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x46, 0x08, 0x14, 0x0a, 0x0b, 0x0a, + 0x03, 0x04, 0x03, 0x06, 0x12, 0x04, 0x47, 0x02, 0x4a, 0x03, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x03, 0x06, 0x00, 0x12, 0x03, 0x48, 0x04, 0x2b, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x06, 0x00, 0x02, 0x12, 0x03, 0x47, 0x09, + 0x41, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x06, 0x00, 0x04, 0x12, 0x03, + 0x48, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x06, 0x00, 0x06, + 0x12, 0x03, 0x48, 0x0d, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x06, + 0x00, 0x01, 0x12, 0x03, 0x48, 0x1a, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x06, 0x00, 0x03, 0x12, 0x03, 0x48, 0x25, 0x2a, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x03, 0x06, 0x01, 0x12, 0x03, 0x49, 0x04, 0x2e, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x03, 0x06, 0x01, 0x02, 0x12, 0x03, 0x47, 0x09, 0x41, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x06, 0x01, 0x04, 0x12, 0x03, 0x49, + 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x06, 0x01, 0x06, 0x12, + 0x03, 0x49, 0x0d, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x06, 0x01, + 0x01, 0x12, 0x03, 0x49, 0x1e, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x06, 0x01, 0x03, 0x12, 0x03, 0x49, 0x28, 0x2d, 0x0a, 0x0a, 0x0a, 0x02, + 0x06, 0x00, 0x12, 0x04, 0x4d, 0x00, 0x50, 0x01, 0x0a, 0x0a, 0x0a, 0x03, + 0x06, 0x00, 0x01, 0x12, 0x03, 0x4d, 0x08, 0x13, 0x0a, 0x0b, 0x0a, 0x04, + 0x06, 0x00, 0x02, 0x00, 0x12, 0x03, 0x4e, 0x02, 0x65, 0x0a, 0x0c, 0x0a, + 0x05, 0x06, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x4e, 0x06, 0x09, 0x0a, + 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x4e, 0x0a, + 0x34, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x4e, 0x3f, 0x63, 0x0a, 0x0b, 0x0a, 0x04, 0x06, 0x00, 0x02, 0x01, 0x12, + 0x03, 0x4f, 0x02, 0x36, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x4f, 0x06, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x06, 0x00, + 0x02, 0x01, 0x02, 0x12, 0x03, 0x4f, 0x0a, 0x19, 0x0a, 0x0c, 0x0a, 0x05, + 0x06, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x4f, 0x24, 0x34, 0x0a, 0x0a, + 0x0a, 0x02, 0x04, 0x04, 0x12, 0x04, 0x52, 0x00, 0x6a, 0x01, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x04, 0x01, 0x12, 0x03, 0x52, 0x08, 0x20, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x04, 0x02, 0x00, 0x12, 0x03, 0x54, 0x02, 0x24, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x04, 0x12, 0x03, 0x54, 0x02, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x54, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x54, 0x12, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x54, 0x22, 0x23, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x04, 0x02, 0x01, 0x12, 0x03, 0x55, 0x02, 0x25, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x01, 0x04, 0x12, 0x03, 0x55, 0x02, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x05, 0x12, 0x03, 0x55, 0x0b, 0x10, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x01, 0x12, 0x03, 0x55, + 0x11, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x01, 0x03, 0x12, + 0x03, 0x55, 0x23, 0x24, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x02, + 0x12, 0x03, 0x56, 0x02, 0x2b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x02, 0x04, 0x12, 0x03, 0x56, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x02, 0x06, 0x12, 0x03, 0x56, 0x0b, 0x17, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x02, 0x01, 0x12, 0x03, 0x56, 0x18, 0x26, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x02, 0x03, 0x12, 0x03, 0x56, 0x29, + 0x2a, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x03, 0x12, 0x03, 0x57, + 0x02, 0x31, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, 0x04, 0x12, + 0x03, 0x57, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x03, + 0x06, 0x12, 0x03, 0x57, 0x0b, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x03, 0x01, 0x12, 0x03, 0x57, 0x1b, 0x2c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x03, 0x03, 0x12, 0x03, 0x57, 0x2f, 0x30, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x04, 0x02, 0x04, 0x12, 0x03, 0x59, 0x02, 0x25, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x04, 0x12, 0x03, 0x59, 0x02, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x05, 0x12, 0x03, + 0x59, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x04, 0x01, + 0x12, 0x03, 0x59, 0x12, 0x1f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x04, 0x03, 0x12, 0x03, 0x59, 0x22, 0x24, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x04, 0x02, 0x05, 0x12, 0x03, 0x5a, 0x02, 0x26, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x05, 0x04, 0x12, 0x03, 0x5a, 0x02, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x05, 0x05, 0x12, 0x03, 0x5a, 0x0b, 0x10, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x05, 0x01, 0x12, 0x03, 0x5a, + 0x11, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x05, 0x03, 0x12, + 0x03, 0x5a, 0x23, 0x25, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x06, + 0x12, 0x03, 0x5b, 0x02, 0x2c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x06, 0x04, 0x12, 0x03, 0x5b, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x06, 0x06, 0x12, 0x03, 0x5b, 0x0b, 0x17, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x06, 0x01, 0x12, 0x03, 0x5b, 0x18, 0x26, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x06, 0x03, 0x12, 0x03, 0x5b, 0x29, + 0x2b, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x07, 0x12, 0x03, 0x5c, + 0x02, 0x32, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x07, 0x04, 0x12, + 0x03, 0x5c, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x07, + 0x06, 0x12, 0x03, 0x5c, 0x0b, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x07, 0x01, 0x12, 0x03, 0x5c, 0x1b, 0x2c, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x07, 0x03, 0x12, 0x03, 0x5c, 0x2f, 0x31, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x04, 0x02, 0x08, 0x12, 0x03, 0x5e, 0x02, 0x28, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x08, 0x04, 0x12, 0x03, 0x5e, 0x02, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x08, 0x05, 0x12, 0x03, + 0x5e, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x08, 0x01, + 0x12, 0x03, 0x5e, 0x12, 0x22, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x08, 0x03, 0x12, 0x03, 0x5e, 0x25, 0x27, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x04, 0x02, 0x09, 0x12, 0x03, 0x5f, 0x02, 0x29, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x09, 0x04, 0x12, 0x03, 0x5f, 0x02, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x09, 0x05, 0x12, 0x03, 0x5f, 0x0b, 0x10, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x09, 0x01, 0x12, 0x03, 0x5f, + 0x11, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x09, 0x03, 0x12, + 0x03, 0x5f, 0x26, 0x28, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x0a, + 0x12, 0x03, 0x60, 0x02, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x0a, 0x04, 0x12, 0x03, 0x60, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x0a, 0x06, 0x12, 0x03, 0x60, 0x0b, 0x17, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x0a, 0x01, 0x12, 0x03, 0x60, 0x18, 0x29, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0a, 0x03, 0x12, 0x03, 0x60, 0x2c, + 0x2e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x0b, 0x12, 0x03, 0x61, + 0x02, 0x35, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0b, 0x04, 0x12, + 0x03, 0x61, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0b, + 0x06, 0x12, 0x03, 0x61, 0x0b, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, + 0x02, 0x0b, 0x01, 0x12, 0x03, 0x61, 0x1b, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x04, 0x02, 0x0b, 0x03, 0x12, 0x03, 0x61, 0x32, 0x34, 0x0a, 0x0c, + 0x0a, 0x04, 0x04, 0x04, 0x08, 0x00, 0x12, 0x04, 0x63, 0x02, 0x68, 0x03, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x08, 0x00, 0x01, 0x12, 0x03, 0x63, + 0x08, 0x09, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x0c, 0x12, 0x03, + 0x64, 0x04, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0c, 0x05, + 0x12, 0x03, 0x64, 0x04, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x0c, 0x01, 0x12, 0x03, 0x64, 0x0b, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x0c, 0x03, 0x12, 0x03, 0x64, 0x1d, 0x1f, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x04, 0x02, 0x0d, 0x12, 0x03, 0x65, 0x04, 0x21, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0d, 0x05, 0x12, 0x03, 0x65, 0x04, 0x09, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0d, 0x01, 0x12, 0x03, 0x65, + 0x0a, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0d, 0x03, 0x12, + 0x03, 0x65, 0x1e, 0x20, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x0e, + 0x12, 0x03, 0x66, 0x04, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, + 0x0e, 0x06, 0x12, 0x03, 0x66, 0x04, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x04, 0x02, 0x0e, 0x01, 0x12, 0x03, 0x66, 0x11, 0x21, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x04, 0x02, 0x0e, 0x03, 0x12, 0x03, 0x66, 0x24, 0x26, 0x0a, + 0x0b, 0x0a, 0x04, 0x04, 0x04, 0x02, 0x0f, 0x12, 0x03, 0x67, 0x04, 0x2d, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0f, 0x06, 0x12, 0x03, 0x67, + 0x04, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0f, 0x01, 0x12, + 0x03, 0x67, 0x14, 0x27, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x04, 0x02, 0x0f, + 0x03, 0x12, 0x03, 0x67, 0x2a, 0x2c, 0x0a, 0xd2, 0x19, 0x0a, 0x20, 0x70, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x6c, 0x69, 0x62, 0x5f, 0x64, 0x65, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, + 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x73, 0x77, 0x69, + 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, + 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x22, 0xc4, 0x09, 0x0a, 0x18, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x46, 0x6f, 0x72, 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x12, + 0x1b, 0x0a, 0x09, 0x73, 0x74, 0x72, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x74, 0x72, 0x46, + 0x69, 0x65, 0x6c, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x6e, 0x74, 0x33, + 0x32, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x0a, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x46, 0x69, 0x65, 0x6c, + 0x64, 0x12, 0x56, 0x0a, 0x0a, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x37, 0x2e, + 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x33, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, + 0x6f, 0x72, 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x53, + 0x75, 0x62, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x09, 0x65, 0x6e, 0x75, 0x6d, + 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x48, 0x0a, 0x0d, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x4f, 0x74, 0x68, 0x65, 0x72, 0x4d, 0x65, - 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x12, 0x72, 0x65, 0x70, 0x65, 0x61, - 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x69, 0x65, 0x6c, - 0x64, 0x12, 0x28, 0x0a, 0x0f, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x73, - 0x74, 0x72, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x1f, 0x20, 0x01, - 0x28, 0x09, 0x48, 0x00, 0x52, 0x0d, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x53, - 0x74, 0x72, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x2c, 0x0a, 0x11, 0x6f, - 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x66, - 0x69, 0x65, 0x6c, 0x64, 0x18, 0x20, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, - 0x52, 0x0f, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x49, 0x6e, 0x74, 0x33, 0x32, - 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x63, 0x0a, 0x10, 0x6f, 0x6e, 0x65, - 0x6f, 0x66, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x66, 0x69, 0x65, 0x6c, - 0x64, 0x18, 0x21, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x37, 0x2e, 0x73, 0x77, - 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, - 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x50, 0x72, 0x6f, 0x74, - 0x6f, 0x33, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, - 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x75, 0x62, - 0x45, 0x6e, 0x75, 0x6d, 0x48, 0x00, 0x52, 0x0e, 0x6f, 0x6e, 0x65, 0x6f, - 0x66, 0x45, 0x6e, 0x75, 0x6d, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x55, - 0x0a, 0x13, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x6d, 0x65, 0x73, 0x73, - 0x61, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x22, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, - 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, - 0x65, 0x73, 0x74, 0x2e, 0x4f, 0x74, 0x68, 0x65, 0x72, 0x4d, 0x65, 0x73, - 0x73, 0x61, 0x67, 0x65, 0x48, 0x00, 0x52, 0x11, 0x6f, 0x6e, 0x65, 0x6f, - 0x66, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x69, 0x65, 0x6c, - 0x64, 0x22, 0x3c, 0x0a, 0x07, 0x53, 0x75, 0x62, 0x45, 0x6e, 0x75, 0x6d, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x27, 0x0a, 0x0d, 0x6f, + 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x18, 0x0b, 0x20, 0x01, 0x28, 0x09, 0x48, 0x01, 0x52, 0x0b, 0x6f, 0x70, + 0x74, 0x53, 0x74, 0x72, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x88, 0x01, 0x01, + 0x12, 0x2b, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x33, + 0x32, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x0c, 0x20, 0x01, 0x28, + 0x05, 0x48, 0x02, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x49, 0x6e, 0x74, 0x33, + 0x32, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x88, 0x01, 0x01, 0x12, 0x62, 0x0a, + 0x0e, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x37, 0x2e, + 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x33, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, + 0x6f, 0x72, 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x53, + 0x75, 0x62, 0x45, 0x6e, 0x75, 0x6d, 0x48, 0x03, 0x52, 0x0c, 0x6f, 0x70, + 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x88, 0x01, + 0x01, 0x12, 0x54, 0x0a, 0x11, 0x6f, 0x70, 0x74, 0x5f, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x0e, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, + 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, + 0x74, 0x65, 0x73, 0x74, 0x2e, 0x4f, 0x74, 0x68, 0x65, 0x72, 0x4d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x48, 0x04, 0x52, 0x0f, 0x6f, 0x70, 0x74, + 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x69, 0x65, 0x6c, 0x64, + 0x88, 0x01, 0x01, 0x12, 0x28, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, + 0x74, 0x5f, 0x73, 0x74, 0x72, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, + 0x15, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x65, 0x61, + 0x74, 0x53, 0x74, 0x72, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x2c, 0x0a, + 0x12, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x33, + 0x32, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x16, 0x20, 0x03, 0x28, + 0x05, 0x52, 0x10, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x49, 0x6e, 0x74, + 0x33, 0x32, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x63, 0x0a, 0x11, 0x72, + 0x65, 0x70, 0x65, 0x61, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x18, 0x17, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x37, + 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x50, + 0x72, 0x6f, 0x74, 0x6f, 0x33, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x46, 0x6f, 0x72, 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x2e, + 0x53, 0x75, 0x62, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0f, 0x72, 0x65, 0x70, + 0x65, 0x61, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x46, 0x69, 0x65, 0x6c, 0x64, + 0x12, 0x55, 0x0a, 0x14, 0x72, 0x65, 0x70, 0x65, 0x61, 0x74, 0x5f, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x18, 0x18, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x77, 0x69, + 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, + 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x4f, 0x74, 0x68, 0x65, 0x72, + 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x12, 0x72, 0x65, 0x70, + 0x65, 0x61, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x69, + 0x65, 0x6c, 0x64, 0x12, 0x28, 0x0a, 0x0f, 0x6f, 0x6e, 0x65, 0x6f, 0x66, + 0x5f, 0x73, 0x74, 0x72, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x1f, + 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0d, 0x6f, 0x6e, 0x65, 0x6f, + 0x66, 0x53, 0x74, 0x72, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x2c, 0x0a, + 0x11, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, + 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x20, 0x20, 0x01, 0x28, 0x05, + 0x48, 0x00, 0x52, 0x0f, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x49, 0x6e, 0x74, + 0x33, 0x32, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x63, 0x0a, 0x10, 0x6f, + 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x18, 0x21, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x37, 0x2e, + 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x50, 0x72, + 0x6f, 0x74, 0x6f, 0x33, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, + 0x6f, 0x72, 0x50, 0x72, 0x65, 0x73, 0x65, 0x6e, 0x63, 0x65, 0x2e, 0x53, + 0x75, 0x62, 0x45, 0x6e, 0x75, 0x6d, 0x48, 0x00, 0x52, 0x0e, 0x6f, 0x6e, + 0x65, 0x6f, 0x66, 0x45, 0x6e, 0x75, 0x6d, 0x46, 0x69, 0x65, 0x6c, 0x64, + 0x12, 0x55, 0x0a, 0x13, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, + 0x22, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x77, 0x69, 0x66, + 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, + 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x4f, 0x74, 0x68, 0x65, 0x72, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x48, 0x00, 0x52, 0x11, 0x6f, 0x6e, + 0x65, 0x6f, 0x66, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x69, + 0x65, 0x6c, 0x64, 0x22, 0x3c, 0x0a, 0x07, 0x53, 0x75, 0x62, 0x45, 0x6e, + 0x75, 0x6d, 0x12, 0x0f, 0x0a, 0x0b, 0x53, 0x55, 0x42, 0x5f, 0x56, 0x41, + 0x4c, 0x55, 0x45, 0x5f, 0x30, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x53, + 0x55, 0x42, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x5f, 0x31, 0x10, 0x01, 0x12, 0x0f, 0x0a, 0x0b, 0x53, 0x55, 0x42, 0x5f, 0x56, 0x41, 0x4c, 0x55, - 0x45, 0x5f, 0x30, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x53, 0x55, 0x42, - 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x5f, 0x31, 0x10, 0x01, 0x12, 0x0f, - 0x0a, 0x0b, 0x53, 0x55, 0x42, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x5f, - 0x32, 0x10, 0x02, 0x42, 0x03, 0x0a, 0x01, 0x6f, 0x42, 0x10, 0x0a, 0x0e, - 0x5f, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x5f, 0x66, 0x69, 0x65, - 0x6c, 0x64, 0x42, 0x12, 0x0a, 0x10, 0x5f, 0x6f, 0x70, 0x74, 0x5f, 0x69, - 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x11, - 0x0a, 0x0f, 0x5f, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x5f, - 0x66, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x14, 0x0a, 0x12, 0x5f, 0x6f, 0x70, - 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x66, 0x69, - 0x65, 0x6c, 0x64, 0x22, 0x24, 0x0a, 0x0c, 0x4f, 0x74, 0x68, 0x65, 0x72, - 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x66, - 0x69, 0x65, 0x6c, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, - 0x66, 0x69, 0x65, 0x6c, 0x64, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x33, 0x0a, 0x92, 0x02, 0x0a, 0x3f, 0x53, 0x77, 0x69, 0x66, 0x74, 0x50, - 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x50, 0x6c, 0x75, 0x67, 0x69, - 0x6e, 0x4c, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x2f, 0x73, 0x77, 0x69, - 0x66, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, - 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x5f, 0x6d, 0x61, 0x70, 0x70, 0x69, - 0x6e, 0x67, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x73, - 0x77, 0x69, 0x66, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, - 0x66, 0x2e, 0x67, 0x65, 0x6e, 0x5f, 0x73, 0x77, 0x69, 0x66, 0x74, 0x22, - 0xac, 0x01, 0x0a, 0x0e, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x4d, 0x61, - 0x70, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x12, 0x48, 0x0a, 0x07, 0x6d, 0x61, - 0x70, 0x70, 0x69, 0x6e, 0x67, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x2e, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x67, 0x65, 0x6e, 0x5f, 0x73, 0x77, 0x69, - 0x66, 0x74, 0x2e, 0x4d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x4d, 0x61, 0x70, - 0x70, 0x69, 0x6e, 0x67, 0x73, 0x2e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, - 0x07, 0x6d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x1a, 0x50, 0x0a, 0x05, - 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x6f, 0x64, - 0x75, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0a, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x4e, 0x61, - 0x6d, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, - 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, - 0x03, 0x28, 0x09, 0x52, 0x0d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x46, 0x69, - 0x6c, 0x65, 0x50, 0x61, 0x74, 0x68, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x33 + 0x45, 0x5f, 0x32, 0x10, 0x02, 0x42, 0x03, 0x0a, 0x01, 0x6f, 0x42, 0x10, + 0x0a, 0x0e, 0x5f, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x5f, 0x66, + 0x69, 0x65, 0x6c, 0x64, 0x42, 0x12, 0x0a, 0x10, 0x5f, 0x6f, 0x70, 0x74, + 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x42, 0x11, 0x0a, 0x0f, 0x5f, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x6e, 0x75, + 0x6d, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x14, 0x0a, 0x12, 0x5f, + 0x6f, 0x70, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x22, 0x24, 0x0a, 0x0c, 0x4f, 0x74, 0x68, + 0x65, 0x72, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x14, 0x0a, + 0x05, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x4a, 0xa1, 0x0f, 0x0a, 0x06, + 0x12, 0x04, 0x10, 0x00, 0x36, 0x01, 0x0a, 0x80, 0x05, 0x0a, 0x01, 0x0c, + 0x12, 0x03, 0x10, 0x00, 0x12, 0x32, 0xf5, 0x04, 0x20, 0x50, 0x72, 0x6f, + 0x74, 0x6f, 0x73, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x6c, 0x69, + 0x62, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, + 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, + 0x2d, 0x20, 0x74, 0x65, 0x73, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x0a, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x69, 0x73, 0x20, 0x70, + 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x53, + 0x77, 0x69, 0x66, 0x74, 0x2e, 0x6f, 0x72, 0x67, 0x20, 0x6f, 0x70, 0x65, + 0x6e, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x0a, 0x0a, 0x20, 0x43, 0x6f, 0x70, 0x79, 0x72, + 0x69, 0x67, 0x68, 0x74, 0x20, 0x28, 0x63, 0x29, 0x20, 0x32, 0x30, 0x31, + 0x34, 0x20, 0x2d, 0x20, 0x32, 0x30, 0x32, 0x30, 0x20, 0x41, 0x70, 0x70, + 0x6c, 0x65, 0x20, 0x49, 0x6e, 0x63, 0x2e, 0x20, 0x61, 0x6e, 0x64, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x53, 0x77, 0x69, 0x66, 0x74, 0x20, 0x70, 0x72, + 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, + 0x73, 0x0a, 0x20, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x64, 0x20, + 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x41, 0x70, 0x61, 0x63, 0x68, 0x65, + 0x20, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x20, 0x76, 0x32, 0x2e, + 0x30, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x52, 0x75, 0x6e, 0x74, 0x69, + 0x6d, 0x65, 0x20, 0x4c, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x20, 0x45, + 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x20, 0x53, + 0x65, 0x65, 0x20, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x73, 0x77, + 0x69, 0x66, 0x74, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x4c, 0x49, 0x43, 0x45, + 0x4e, 0x53, 0x45, 0x2e, 0x74, 0x78, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, + 0x6c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, + 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x53, 0x65, 0x65, + 0x20, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x73, 0x77, 0x69, 0x66, + 0x74, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x43, 0x4f, 0x4e, 0x54, 0x52, 0x49, + 0x42, 0x55, 0x54, 0x4f, 0x52, 0x53, 0x2e, 0x74, 0x78, 0x74, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, + 0x6f, 0x66, 0x20, 0x53, 0x77, 0x69, 0x66, 0x74, 0x20, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x73, + 0x0a, 0x0a, 0x20, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x2f, 0x0a, 0x2f, + 0x20, 0x54, 0x65, 0x73, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, + 0x66, 0x6f, 0x72, 0x20, 0x54, 0x65, 0x73, 0x74, 0x73, 0x2f, 0x53, 0x77, + 0x69, 0x66, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x50, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x4c, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, + 0x54, 0x65, 0x73, 0x74, 0x73, 0x2f, 0x54, 0x65, 0x73, 0x74, 0x5f, 0x44, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x73, 0x77, + 0x69, 0x66, 0x74, 0x0a, 0x2f, 0x0a, 0x20, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x0a, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x12, 0x00, 0x1e, 0x0a, + 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x14, 0x00, 0x32, 0x01, 0x0a, + 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x14, 0x08, 0x20, 0x0a, + 0x0c, 0x0a, 0x04, 0x04, 0x00, 0x04, 0x00, 0x12, 0x04, 0x16, 0x02, 0x1a, + 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x04, 0x00, 0x01, 0x12, 0x03, + 0x16, 0x07, 0x0e, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, + 0x00, 0x12, 0x03, 0x17, 0x04, 0x14, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, + 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x17, 0x04, 0x0f, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x00, 0x02, 0x12, 0x03, 0x17, + 0x12, 0x13, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, + 0x12, 0x03, 0x18, 0x04, 0x14, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, + 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x18, 0x04, 0x0f, 0x0a, 0x0e, 0x0a, + 0x07, 0x04, 0x00, 0x04, 0x00, 0x02, 0x01, 0x02, 0x12, 0x03, 0x18, 0x12, + 0x13, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, 0x12, + 0x03, 0x19, 0x04, 0x14, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x04, 0x00, + 0x02, 0x02, 0x01, 0x12, 0x03, 0x19, 0x04, 0x0f, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x00, 0x04, 0x00, 0x02, 0x02, 0x02, 0x12, 0x03, 0x19, 0x12, 0x13, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x1c, 0x02, + 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x1c, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x1c, 0x09, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x1c, 0x15, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x01, 0x12, 0x03, 0x1d, 0x02, 0x18, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x1d, 0x02, 0x07, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x1d, 0x08, 0x13, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x1d, + 0x16, 0x17, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, + 0x1e, 0x02, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, + 0x12, 0x03, 0x1e, 0x02, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x02, 0x01, 0x12, 0x03, 0x1e, 0x0a, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x1e, 0x17, 0x18, 0x0a, 0x0b, 0x0a, + 0x04, 0x04, 0x00, 0x02, 0x03, 0x12, 0x03, 0x1f, 0x02, 0x21, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x06, 0x12, 0x03, 0x1f, 0x02, 0x0e, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x1f, + 0x0f, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, + 0x03, 0x1f, 0x1f, 0x20, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x04, + 0x12, 0x03, 0x21, 0x02, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x04, 0x04, 0x12, 0x03, 0x21, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x04, 0x05, 0x12, 0x03, 0x21, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x04, 0x01, 0x12, 0x03, 0x21, 0x12, 0x1f, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x03, 0x12, 0x03, 0x21, 0x22, + 0x24, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x05, 0x12, 0x03, 0x22, + 0x02, 0x26, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, 0x04, 0x12, + 0x03, 0x22, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x05, + 0x05, 0x12, 0x03, 0x22, 0x0b, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x05, 0x01, 0x12, 0x03, 0x22, 0x11, 0x20, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x05, 0x03, 0x12, 0x03, 0x22, 0x23, 0x25, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x06, 0x12, 0x03, 0x23, 0x02, 0x27, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x04, 0x12, 0x03, 0x23, 0x02, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x06, 0x12, 0x03, + 0x23, 0x0b, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x06, 0x01, + 0x12, 0x03, 0x23, 0x13, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x06, 0x03, 0x12, 0x03, 0x23, 0x24, 0x26, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x07, 0x12, 0x03, 0x24, 0x02, 0x2f, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x07, 0x04, 0x12, 0x03, 0x24, 0x02, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x07, 0x06, 0x12, 0x03, 0x24, 0x0b, 0x17, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x07, 0x01, 0x12, 0x03, 0x24, + 0x18, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x07, 0x03, 0x12, + 0x03, 0x24, 0x2c, 0x2e, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x08, + 0x12, 0x03, 0x26, 0x02, 0x28, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x08, 0x04, 0x12, 0x03, 0x26, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x08, 0x05, 0x12, 0x03, 0x26, 0x0b, 0x11, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x08, 0x01, 0x12, 0x03, 0x26, 0x12, 0x22, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x08, 0x03, 0x12, 0x03, 0x26, 0x25, + 0x27, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x09, 0x12, 0x03, 0x27, + 0x02, 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x09, 0x04, 0x12, + 0x03, 0x27, 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x09, + 0x05, 0x12, 0x03, 0x27, 0x0b, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x09, 0x01, 0x12, 0x03, 0x27, 0x11, 0x23, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x09, 0x03, 0x12, 0x03, 0x27, 0x26, 0x28, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x0a, 0x12, 0x03, 0x28, 0x02, 0x2a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0a, 0x04, 0x12, 0x03, 0x28, 0x02, + 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0a, 0x06, 0x12, 0x03, + 0x28, 0x0b, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0a, 0x01, + 0x12, 0x03, 0x28, 0x13, 0x24, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, + 0x0a, 0x03, 0x12, 0x03, 0x28, 0x27, 0x29, 0x0a, 0x0b, 0x0a, 0x04, 0x04, + 0x00, 0x02, 0x0b, 0x12, 0x03, 0x29, 0x02, 0x32, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x0b, 0x04, 0x12, 0x03, 0x29, 0x02, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0b, 0x06, 0x12, 0x03, 0x29, 0x0b, 0x17, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0b, 0x01, 0x12, 0x03, 0x29, + 0x18, 0x2c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0b, 0x03, 0x12, + 0x03, 0x29, 0x2f, 0x31, 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x00, 0x08, 0x00, + 0x12, 0x04, 0x2b, 0x02, 0x30, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x08, 0x00, 0x01, 0x12, 0x03, 0x2b, 0x08, 0x09, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x0c, 0x12, 0x03, 0x2c, 0x04, 0x20, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x0c, 0x05, 0x12, 0x03, 0x2c, 0x04, 0x0a, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0c, 0x01, 0x12, 0x03, 0x2c, 0x0b, + 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0c, 0x03, 0x12, 0x03, + 0x2c, 0x1d, 0x1f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x0d, 0x12, + 0x03, 0x2d, 0x04, 0x21, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0d, + 0x05, 0x12, 0x03, 0x2d, 0x04, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x0d, 0x01, 0x12, 0x03, 0x2d, 0x0a, 0x1b, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x0d, 0x03, 0x12, 0x03, 0x2d, 0x1e, 0x20, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x0e, 0x12, 0x03, 0x2e, 0x04, 0x22, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0e, 0x06, 0x12, 0x03, 0x2e, 0x04, + 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0e, 0x01, 0x12, 0x03, + 0x2e, 0x0c, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0e, 0x03, + 0x12, 0x03, 0x2e, 0x1f, 0x21, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x0f, 0x12, 0x03, 0x2f, 0x04, 0x2a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x0f, 0x06, 0x12, 0x03, 0x2f, 0x04, 0x10, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x0f, 0x01, 0x12, 0x03, 0x2f, 0x11, 0x24, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x0f, 0x03, 0x12, 0x03, 0x2f, 0x27, 0x29, + 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x01, 0x12, 0x04, 0x34, 0x00, 0x36, 0x01, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x01, 0x01, 0x12, 0x03, 0x34, 0x08, 0x14, + 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x35, 0x02, + 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, + 0x35, 0x02, 0x08, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, + 0x12, 0x03, 0x35, 0x09, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x35, 0x11, 0x12, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, 0x0a, 0xe2, 0x0d, 0x0a, 0x24, 0x70, 0x6c, 0x75, 0x67, + 0x69, 0x6e, 0x6c, 0x69, 0x62, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, + 0x65, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x73, 0x77, + 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x22, 0x95, 0x05, 0x0a, 0x1b, + 0x45, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x69, + 0x74, 0x65, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x63, 0x61, 0x6c, 0x61, + 0x72, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x0b, 0x73, 0x63, 0x61, 0x6c, 0x61, 0x72, 0x46, 0x69, 0x65, + 0x6c, 0x64, 0x12, 0x5d, 0x0a, 0x09, 0x6d, 0x61, 0x70, 0x5f, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x40, 0x2e, + 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x45, 0x64, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x46, 0x6f, 0x72, 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, + 0x64, 0x2e, 0x4d, 0x61, 0x70, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x52, 0x08, 0x6d, 0x61, 0x70, 0x46, 0x69, 0x65, 0x6c, + 0x64, 0x12, 0x73, 0x0a, 0x11, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x5f, 0x6d, 0x61, 0x70, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x47, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, + 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, + 0x74, 0x65, 0x73, 0x74, 0x2e, 0x45, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x44, + 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x2e, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x4d, 0x61, 0x70, 0x46, 0x69, 0x65, 0x6c, 0x64, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x4d, 0x61, 0x70, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x5b, + 0x0a, 0x0f, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x5f, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x32, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, + 0x45, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x69, + 0x74, 0x65, 0x64, 0x52, 0x0e, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, + 0x65, 0x64, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x12, 0x6d, 0x0a, 0x15, 0x6c, + 0x65, 0x6e, 0x67, 0x74, 0x68, 0x5f, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, + 0x65, 0x64, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, + 0x73, 0x74, 0x2e, 0x45, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x46, 0x6f, 0x72, 0x44, 0x65, 0x6c, + 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x28, + 0x01, 0x52, 0x13, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x50, 0x72, 0x65, + 0x66, 0x69, 0x78, 0x65, 0x64, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x1a, 0x3b, + 0x0a, 0x0d, 0x4d, 0x61, 0x70, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, + 0x76, 0x0a, 0x14, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4d, 0x61, + 0x70, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, + 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x48, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x73, + 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x45, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, + 0x46, 0x6f, 0x72, 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, + 0x05, 0x92, 0x03, 0x02, 0x28, 0x02, 0x4a, 0xf6, 0x07, 0x0a, 0x06, 0x12, + 0x04, 0x10, 0x00, 0x1e, 0x01, 0x0a, 0x80, 0x05, 0x0a, 0x01, 0x0c, 0x12, + 0x03, 0x10, 0x00, 0x11, 0x32, 0xf5, 0x04, 0x20, 0x50, 0x72, 0x6f, 0x74, + 0x6f, 0x73, 0x2f, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x6c, 0x69, 0x62, + 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, + 0x74, 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x2d, + 0x20, 0x74, 0x65, 0x73, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x0a, + 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x69, 0x73, 0x20, 0x70, 0x61, + 0x72, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x53, 0x77, + 0x69, 0x66, 0x74, 0x2e, 0x6f, 0x72, 0x67, 0x20, 0x6f, 0x70, 0x65, 0x6e, + 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x0a, 0x0a, 0x20, 0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, + 0x67, 0x68, 0x74, 0x20, 0x28, 0x63, 0x29, 0x20, 0x32, 0x30, 0x31, 0x34, + 0x20, 0x2d, 0x20, 0x32, 0x30, 0x32, 0x34, 0x20, 0x41, 0x70, 0x70, 0x6c, + 0x65, 0x20, 0x49, 0x6e, 0x63, 0x2e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x53, 0x77, 0x69, 0x66, 0x74, 0x20, 0x70, 0x72, 0x6f, + 0x6a, 0x65, 0x63, 0x74, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x73, + 0x0a, 0x20, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x64, 0x20, 0x75, + 0x6e, 0x64, 0x65, 0x72, 0x20, 0x41, 0x70, 0x61, 0x63, 0x68, 0x65, 0x20, + 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x20, 0x76, 0x32, 0x2e, 0x30, + 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, + 0x65, 0x20, 0x4c, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x20, 0x45, 0x78, + 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x20, 0x53, 0x65, + 0x65, 0x20, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x73, 0x77, 0x69, + 0x66, 0x74, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x4c, 0x49, 0x43, 0x45, 0x4e, + 0x53, 0x45, 0x2e, 0x74, 0x78, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6c, + 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x20, 0x69, 0x6e, 0x66, 0x6f, 0x72, + 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x53, 0x65, 0x65, 0x20, + 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x73, 0x77, 0x69, 0x66, 0x74, + 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x43, 0x4f, 0x4e, 0x54, 0x52, 0x49, 0x42, + 0x55, 0x54, 0x4f, 0x52, 0x53, 0x2e, 0x74, 0x78, 0x74, 0x20, 0x66, 0x6f, + 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x20, 0x6f, + 0x66, 0x20, 0x53, 0x77, 0x69, 0x66, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x6a, + 0x65, 0x63, 0x74, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x73, 0x0a, + 0x0a, 0x20, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x2f, 0x0a, 0x2f, 0x20, + 0x54, 0x65, 0x73, 0x74, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x54, 0x65, 0x73, 0x74, 0x73, 0x2f, 0x53, 0x77, 0x69, + 0x66, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x50, 0x6c, + 0x75, 0x67, 0x69, 0x6e, 0x4c, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x54, + 0x65, 0x73, 0x74, 0x73, 0x2f, 0x54, 0x65, 0x73, 0x74, 0x5f, 0x44, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x73, 0x77, 0x69, + 0x66, 0x74, 0x0a, 0x2f, 0x0a, 0x20, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, + 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, 0x12, 0x00, 0x1e, 0x0a, 0x08, + 0x0a, 0x01, 0x08, 0x12, 0x03, 0x14, 0x00, 0x2d, 0x0a, 0x0a, 0x0a, 0x03, + 0x08, 0x32, 0x05, 0x12, 0x03, 0x14, 0x00, 0x2d, 0x0a, 0x0a, 0x0a, 0x02, + 0x04, 0x00, 0x12, 0x04, 0x16, 0x00, 0x1e, 0x01, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x00, 0x01, 0x12, 0x03, 0x16, 0x08, 0x23, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x17, 0x02, 0x19, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x17, 0x02, 0x07, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x17, 0x08, + 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x17, 0x17, 0x18, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, + 0x03, 0x18, 0x02, 0x23, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, + 0x06, 0x12, 0x03, 0x18, 0x02, 0x14, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x18, 0x15, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x18, 0x21, 0x22, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x19, 0x02, 0x40, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x06, 0x12, 0x03, 0x19, 0x02, + 0x29, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, + 0x19, 0x2a, 0x3b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, + 0x12, 0x03, 0x19, 0x3e, 0x3f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, + 0x03, 0x12, 0x03, 0x1a, 0x02, 0x32, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x03, 0x06, 0x12, 0x03, 0x1a, 0x02, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x03, 0x01, 0x12, 0x03, 0x1a, 0x1e, 0x2d, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x02, 0x03, 0x03, 0x12, 0x03, 0x1a, 0x30, 0x31, + 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x04, 0x12, 0x04, 0x1b, 0x02, + 0x1d, 0x04, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, 0x06, 0x12, + 0x03, 0x1b, 0x02, 0x1d, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x04, + 0x01, 0x12, 0x03, 0x1b, 0x1e, 0x33, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x04, 0x03, 0x12, 0x03, 0x1b, 0x36, 0x37, 0x0a, 0x0d, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x04, 0x08, 0x12, 0x04, 0x1b, 0x38, 0x1d, 0x03, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x02, 0x04, 0x08, 0x15, 0x05, 0x12, 0x03, + 0x1c, 0x04, 0x2f, 0x62, 0x08, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x70, 0xe8, 0x07, 0x0a, 0x93, 0x02, 0x0a, 0x1f, 0x75, 0x6e, 0x69, + 0x74, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x69, + 0x74, 0x65, 0x64, 0x5f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x11, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x22, + 0x2b, 0x0a, 0x0d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x49, 0x6d, + 0x70, 0x6f, 0x72, 0x74, 0x12, 0x0c, 0x0a, 0x01, 0x61, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x01, 0x61, 0x12, 0x0c, 0x0a, 0x01, 0x62, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x62, 0x4a, 0xa2, 0x01, 0x0a, + 0x06, 0x12, 0x04, 0x00, 0x00, 0x07, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, + 0x12, 0x03, 0x00, 0x00, 0x11, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, + 0x02, 0x00, 0x1a, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x04, + 0x00, 0x07, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, + 0x04, 0x08, 0x15, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, + 0x03, 0x05, 0x02, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x05, 0x12, 0x03, 0x05, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x01, 0x12, 0x03, 0x05, 0x08, 0x09, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x05, 0x0c, 0x0d, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x06, 0x02, 0x0e, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x06, 0x02, + 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, + 0x06, 0x08, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, + 0x12, 0x03, 0x06, 0x0c, 0x0d, 0x62, 0x08, 0x65, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x70, 0xe8, 0x07, 0x0a, 0xbe, 0x1e, 0x0a, 0x18, 0x75, + 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x64, 0x65, 0x6c, 0x69, + 0x6d, 0x69, 0x74, 0x65, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, + 0x11, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x75, 0x6e, + 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x75, 0x6e, 0x69, 0x74, + 0x74, 0x65, 0x73, 0x74, 0x5f, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, + 0x65, 0x64, 0x5f, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x22, 0x2c, 0x0a, 0x0e, 0x4c, 0x65, 0x6e, 0x67, 0x74, + 0x68, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x65, 0x64, 0x12, 0x0c, 0x0a, + 0x01, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x61, 0x12, + 0x0c, 0x0a, 0x01, 0x62, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, + 0x62, 0x22, 0x2f, 0x0a, 0x11, 0x4e, 0x6f, 0x74, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x4c, 0x69, 0x6b, 0x65, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x0c, + 0x0a, 0x01, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x61, + 0x12, 0x0c, 0x0a, 0x01, 0x62, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x01, 0x62, 0x22, 0x30, 0x0a, 0x12, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4c, + 0x69, 0x6b, 0x65, 0x46, 0x69, 0x6c, 0x65, 0x53, 0x63, 0x6f, 0x70, 0x65, + 0x12, 0x0c, 0x0a, 0x01, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x01, 0x61, 0x12, 0x0c, 0x0a, 0x01, 0x62, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x01, 0x62, 0x22, 0xdd, 0x04, 0x0a, 0x0d, 0x54, 0x65, 0x73, + 0x74, 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x12, 0x57, + 0x0a, 0x0e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x70, 0x72, 0x65, 0x66, + 0x69, 0x78, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, + 0x2e, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x75, 0x6e, + 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x44, + 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x2e, 0x4c, 0x65, 0x6e, + 0x67, 0x74, 0x68, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x65, 0x64, 0x52, + 0x0e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x70, 0x72, 0x65, 0x66, 0x69, + 0x78, 0x65, 0x64, 0x12, 0x3f, 0x0a, 0x06, 0x6e, 0x65, 0x73, 0x74, 0x65, + 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x65, 0x64, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, + 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x44, 0x65, 0x6c, 0x69, + 0x6d, 0x69, 0x74, 0x65, 0x64, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x28, 0x02, + 0x52, 0x06, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x4f, 0x0a, 0x09, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x6c, 0x69, 0x6b, 0x65, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, + 0x54, 0x65, 0x73, 0x74, 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, + 0x64, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4c, 0x69, 0x6b, 0x65, 0x42, + 0x05, 0xaa, 0x01, 0x02, 0x28, 0x02, 0x52, 0x09, 0x67, 0x72, 0x6f, 0x75, + 0x70, 0x6c, 0x69, 0x6b, 0x65, 0x12, 0x55, 0x0a, 0x0c, 0x6e, 0x6f, 0x74, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x6c, 0x69, 0x6b, 0x65, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, + 0x54, 0x65, 0x73, 0x74, 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, + 0x64, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4c, 0x69, 0x6b, 0x65, 0x42, + 0x05, 0xaa, 0x01, 0x02, 0x28, 0x02, 0x52, 0x0c, 0x6e, 0x6f, 0x74, 0x67, + 0x72, 0x6f, 0x75, 0x70, 0x6c, 0x69, 0x6b, 0x65, 0x12, 0x59, 0x0a, 0x11, + 0x6e, 0x6f, 0x74, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x6c, 0x69, 0x6b, 0x65, + 0x73, 0x63, 0x6f, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x24, 0x2e, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x75, + 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x4e, 0x6f, 0x74, 0x47, + 0x72, 0x6f, 0x75, 0x70, 0x4c, 0x69, 0x6b, 0x65, 0x53, 0x63, 0x6f, 0x70, + 0x65, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x28, 0x02, 0x52, 0x11, 0x6e, 0x6f, + 0x74, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x6c, 0x69, 0x6b, 0x65, 0x73, 0x63, + 0x6f, 0x70, 0x65, 0x12, 0x4d, 0x0a, 0x0d, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, + 0x42, 0x05, 0xaa, 0x01, 0x02, 0x28, 0x02, 0x52, 0x0d, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x1a, 0x2c, + 0x0a, 0x0e, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x50, 0x72, 0x65, 0x66, + 0x69, 0x78, 0x65, 0x64, 0x12, 0x0c, 0x0a, 0x01, 0x61, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x01, 0x61, 0x12, 0x0c, 0x0a, 0x01, 0x62, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x62, 0x1a, 0x27, 0x0a, 0x09, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4c, 0x69, 0x6b, 0x65, 0x12, 0x0c, 0x0a, + 0x01, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, 0x61, 0x12, + 0x0c, 0x0a, 0x01, 0x62, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x01, + 0x62, 0x2a, 0x09, 0x08, 0xe8, 0x07, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, + 0x3a, 0x6c, 0x0a, 0x0e, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x70, 0x72, + 0x65, 0x66, 0x69, 0x78, 0x65, 0x64, 0x12, 0x20, 0x2e, 0x65, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, + 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x44, 0x65, 0x6c, 0x69, 0x6d, + 0x69, 0x74, 0x65, 0x64, 0x18, 0xec, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x21, 0x2e, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x75, + 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x4c, 0x65, 0x6e, 0x67, + 0x74, 0x68, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x65, 0x64, 0x52, 0x0e, + 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x70, 0x72, 0x65, 0x66, 0x69, 0x78, + 0x65, 0x64, 0x3a, 0x7f, 0x0a, 0x12, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x6c, + 0x69, 0x6b, 0x65, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x63, 0x6f, 0x70, 0x65, + 0x12, 0x20, 0x2e, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, + 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, + 0x74, 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x18, 0xe8, + 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x65, 0x64, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, + 0x74, 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4c, 0x69, 0x6b, 0x65, 0x46, + 0x69, 0x6c, 0x65, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x42, 0x05, 0xaa, 0x01, + 0x02, 0x28, 0x02, 0x52, 0x12, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x6c, 0x69, + 0x6b, 0x65, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x3a, + 0x7f, 0x0a, 0x14, 0x6e, 0x6f, 0x74, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x5f, 0x6c, 0x69, 0x6b, 0x65, 0x5f, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x12, + 0x20, 0x2e, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x75, + 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, + 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x18, 0xe9, 0x07, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x65, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, + 0x2e, 0x4e, 0x6f, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4c, 0x69, 0x6b, + 0x65, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x28, + 0x02, 0x52, 0x11, 0x6e, 0x6f, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4c, + 0x69, 0x6b, 0x65, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x3a, 0x72, 0x0a, 0x09, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x6c, 0x69, 0x6b, 0x65, 0x12, 0x20, 0x2e, + 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x75, 0x6e, 0x69, + 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x44, 0x65, + 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x18, 0xea, 0x07, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, + 0x65, 0x73, 0x74, 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, + 0x2e, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4c, 0x69, 0x6b, 0x65, 0x42, 0x05, + 0xaa, 0x01, 0x02, 0x28, 0x02, 0x52, 0x09, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x6c, 0x69, 0x6b, 0x65, 0x3a, 0x70, 0x0a, 0x0d, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x20, 0x2e, + 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x5f, 0x75, 0x6e, 0x69, + 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x54, 0x65, 0x73, 0x74, 0x44, 0x65, + 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x18, 0xeb, 0x07, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x49, 0x6d, 0x70, 0x6f, 0x72, 0x74, + 0x42, 0x05, 0xaa, 0x01, 0x02, 0x28, 0x02, 0x52, 0x0d, 0x6d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x4a, 0x99, + 0x13, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x4a, 0x01, 0x0a, 0x08, 0x0a, + 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x11, 0x0a, 0x08, 0x0a, 0x01, 0x02, + 0x12, 0x03, 0x02, 0x00, 0x1a, 0x0a, 0x09, 0x0a, 0x02, 0x03, 0x00, 0x12, + 0x03, 0x04, 0x00, 0x29, 0x0a, 0x6c, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, + 0x09, 0x00, 0x0c, 0x01, 0x32, 0x60, 0x20, 0x54, 0x65, 0x73, 0x74, 0x20, + 0x76, 0x61, 0x72, 0x69, 0x6f, 0x75, 0x73, 0x20, 0x73, 0x63, 0x65, 0x6e, + 0x61, 0x72, 0x69, 0x6f, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x61, + 0x72, 0x65, 0x20, 0x6e, 0x6f, 0x77, 0x20, 0x70, 0x6f, 0x73, 0x73, 0x69, + 0x62, 0x6c, 0x65, 0x20, 0x69, 0x6e, 0x20, 0x65, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x20, 0x32, 0x30, 0x32, 0x33, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x77, 0x65, 0x72, 0x65, 0x6e, 0x27, 0x74, 0x20, 0x69, 0x6e, 0x0a, + 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, + 0x01, 0x12, 0x03, 0x09, 0x08, 0x16, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x00, 0x12, 0x03, 0x0a, 0x02, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x0a, 0x02, 0x07, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0a, 0x08, 0x09, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x0a, 0x0c, + 0x0d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x0b, + 0x02, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, + 0x03, 0x0b, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x0b, 0x08, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x01, 0x03, 0x12, 0x03, 0x0b, 0x0c, 0x0d, 0x0a, 0x0a, 0x0a, 0x02, + 0x04, 0x01, 0x12, 0x04, 0x0e, 0x00, 0x11, 0x01, 0x0a, 0x0a, 0x0a, 0x03, + 0x04, 0x01, 0x01, 0x12, 0x03, 0x0e, 0x08, 0x19, 0x0a, 0x0b, 0x0a, 0x04, + 0x04, 0x01, 0x02, 0x00, 0x12, 0x03, 0x0f, 0x02, 0x0e, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x0f, 0x02, 0x07, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, 0x0f, 0x08, + 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x0f, 0x0c, 0x0d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x01, 0x02, 0x01, 0x12, + 0x03, 0x10, 0x02, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, 0x02, 0x01, + 0x05, 0x12, 0x03, 0x10, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x01, + 0x02, 0x01, 0x01, 0x12, 0x03, 0x10, 0x08, 0x09, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x10, 0x0c, 0x0d, 0x0a, 0x0a, + 0x0a, 0x02, 0x04, 0x02, 0x12, 0x04, 0x13, 0x00, 0x16, 0x01, 0x0a, 0x0a, + 0x0a, 0x03, 0x04, 0x02, 0x01, 0x12, 0x03, 0x13, 0x08, 0x1a, 0x0a, 0x0b, + 0x0a, 0x04, 0x04, 0x02, 0x02, 0x00, 0x12, 0x03, 0x14, 0x02, 0x0e, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x05, 0x12, 0x03, 0x14, 0x02, + 0x07, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x14, 0x08, 0x09, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, 0x02, 0x00, 0x03, + 0x12, 0x03, 0x14, 0x0c, 0x0d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x02, 0x02, + 0x01, 0x12, 0x03, 0x15, 0x02, 0x0e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x02, + 0x02, 0x01, 0x05, 0x12, 0x03, 0x15, 0x02, 0x07, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x02, 0x02, 0x01, 0x01, 0x12, 0x03, 0x15, 0x08, 0x09, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x02, 0x02, 0x01, 0x03, 0x12, 0x03, 0x15, 0x0c, 0x0d, + 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x03, 0x12, 0x04, 0x18, 0x00, 0x36, 0x01, + 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x01, 0x12, 0x03, 0x18, 0x08, 0x15, + 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x03, 0x03, 0x00, 0x12, 0x04, 0x19, 0x02, + 0x1c, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x03, 0x00, 0x01, 0x12, + 0x03, 0x19, 0x0a, 0x18, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x03, 0x03, 0x00, + 0x02, 0x00, 0x12, 0x03, 0x1a, 0x04, 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, + 0x03, 0x03, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x1a, 0x04, 0x09, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x1a, 0x0a, 0x0b, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x03, 0x00, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x1a, 0x0e, 0x0f, 0x0a, 0x0d, 0x0a, 0x06, 0x04, + 0x03, 0x03, 0x00, 0x02, 0x01, 0x12, 0x03, 0x1b, 0x04, 0x10, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x03, 0x03, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x1b, + 0x04, 0x09, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x03, 0x00, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x1b, 0x0a, 0x0b, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, + 0x03, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x1b, 0x0e, 0x0f, 0x0a, 0x43, + 0x0a, 0x04, 0x04, 0x03, 0x02, 0x00, 0x12, 0x03, 0x1e, 0x02, 0x24, 0x1a, + 0x36, 0x20, 0x4e, 0x6f, 0x6e, 0x2d, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x69, + 0x74, 0x65, 0x64, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, + 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x73, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x2d, 0x6c, 0x69, 0x6b, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x00, 0x06, 0x12, 0x03, 0x1e, 0x02, 0x10, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x00, 0x01, 0x12, 0x03, 0x1e, 0x11, 0x1f, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x00, 0x03, 0x12, 0x03, 0x1e, 0x22, + 0x23, 0x0a, 0x2d, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x01, 0x12, 0x03, 0x21, + 0x02, 0x43, 0x1a, 0x20, 0x20, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x20, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x20, 0x74, 0x65, 0x73, 0x74, 0x73, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x06, 0x12, 0x03, 0x21, + 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x12, + 0x03, 0x21, 0x10, 0x16, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x21, 0x19, 0x1a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x01, 0x08, 0x12, 0x03, 0x21, 0x1b, 0x42, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x03, 0x02, 0x01, 0x08, 0x15, 0x05, 0x12, 0x03, 0x21, 0x1c, 0x41, + 0x0a, 0x0c, 0x0a, 0x04, 0x04, 0x03, 0x03, 0x01, 0x12, 0x04, 0x23, 0x02, + 0x26, 0x03, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x03, 0x01, 0x01, 0x12, + 0x03, 0x23, 0x0a, 0x13, 0x0a, 0x0d, 0x0a, 0x06, 0x04, 0x03, 0x03, 0x01, + 0x02, 0x00, 0x12, 0x03, 0x24, 0x04, 0x10, 0x0a, 0x0e, 0x0a, 0x07, 0x04, + 0x03, 0x03, 0x01, 0x02, 0x00, 0x05, 0x12, 0x03, 0x24, 0x04, 0x09, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x03, 0x01, 0x02, 0x00, 0x01, 0x12, 0x03, + 0x24, 0x0a, 0x0b, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x03, 0x01, 0x02, + 0x00, 0x03, 0x12, 0x03, 0x24, 0x0e, 0x0f, 0x0a, 0x0d, 0x0a, 0x06, 0x04, + 0x03, 0x03, 0x01, 0x02, 0x01, 0x12, 0x03, 0x25, 0x04, 0x10, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x03, 0x03, 0x01, 0x02, 0x01, 0x05, 0x12, 0x03, 0x25, + 0x04, 0x09, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x03, 0x01, 0x02, 0x01, + 0x01, 0x12, 0x03, 0x25, 0x0a, 0x0b, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, + 0x03, 0x01, 0x02, 0x01, 0x03, 0x12, 0x03, 0x25, 0x0e, 0x0f, 0x0a, 0x26, + 0x0a, 0x04, 0x04, 0x03, 0x02, 0x02, 0x12, 0x03, 0x29, 0x02, 0x42, 0x1a, + 0x19, 0x20, 0x54, 0x72, 0x75, 0x6c, 0x79, 0x20, 0x67, 0x72, 0x6f, 0x75, + 0x70, 0x2d, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, 0x06, 0x12, + 0x03, 0x29, 0x02, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x02, + 0x01, 0x12, 0x03, 0x29, 0x0c, 0x15, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x02, 0x03, 0x12, 0x03, 0x29, 0x18, 0x19, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x02, 0x02, 0x08, 0x12, 0x03, 0x29, 0x1a, 0x41, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x03, 0x02, 0x02, 0x08, 0x15, 0x05, 0x12, 0x03, 0x29, + 0x1b, 0x40, 0x0a, 0x50, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x03, 0x12, 0x03, + 0x2c, 0x02, 0x45, 0x1a, 0x43, 0x20, 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x69, + 0x74, 0x65, 0x64, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x74, 0x68, + 0x61, 0x74, 0x20, 0x69, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x2d, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x73, 0x6f, 0x6c, 0x65, + 0x6c, 0x79, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x6f, + 0x66, 0x20, 0x69, 0x74, 0x73, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x06, 0x12, 0x03, 0x2c, + 0x02, 0x0b, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, 0x01, 0x12, + 0x03, 0x2c, 0x0c, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x03, + 0x03, 0x12, 0x03, 0x2c, 0x1b, 0x1c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x02, 0x03, 0x08, 0x12, 0x03, 0x2c, 0x1d, 0x44, 0x0a, 0x0e, 0x0a, 0x07, + 0x04, 0x03, 0x02, 0x03, 0x08, 0x15, 0x05, 0x12, 0x03, 0x2c, 0x1e, 0x43, + 0x0a, 0x57, 0x0a, 0x04, 0x04, 0x03, 0x02, 0x04, 0x12, 0x04, 0x2f, 0x02, + 0x30, 0x2e, 0x1a, 0x49, 0x20, 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, + 0x65, 0x64, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x74, 0x68, 0x61, + 0x74, 0x20, 0x69, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x67, 0x72, 0x6f, 0x75, + 0x70, 0x2d, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, + 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x63, + 0x6f, 0x70, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x74, 0x73, 0x20, 0x74, + 0x79, 0x70, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x04, 0x06, 0x12, 0x03, 0x2f, 0x02, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x04, 0x01, 0x12, 0x03, 0x2f, 0x14, 0x25, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x04, 0x03, 0x12, 0x03, 0x2f, 0x28, 0x29, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x04, 0x08, 0x12, 0x03, 0x30, 0x06, + 0x2d, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x02, 0x04, 0x08, 0x15, 0x05, + 0x12, 0x03, 0x30, 0x07, 0x2c, 0x0a, 0x52, 0x0a, 0x04, 0x04, 0x03, 0x02, + 0x05, 0x12, 0x03, 0x33, 0x02, 0x4a, 0x1a, 0x45, 0x20, 0x44, 0x65, 0x6c, + 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x27, 0x73, 0x20, 0x67, 0x72, 0x6f, 0x75, + 0x70, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x65, 0x78, 0x63, 0x65, 0x70, 0x74, + 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x74, 0x27, 0x73, 0x20, 0x61, + 0x6e, 0x20, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x74, + 0x79, 0x70, 0x65, 0x2e, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, + 0x05, 0x06, 0x12, 0x03, 0x33, 0x02, 0x0f, 0x0a, 0x0c, 0x0a, 0x05, 0x04, + 0x03, 0x02, 0x05, 0x01, 0x12, 0x03, 0x33, 0x10, 0x1d, 0x0a, 0x0c, 0x0a, + 0x05, 0x04, 0x03, 0x02, 0x05, 0x03, 0x12, 0x03, 0x33, 0x20, 0x21, 0x0a, + 0x0c, 0x0a, 0x05, 0x04, 0x03, 0x02, 0x05, 0x08, 0x12, 0x03, 0x33, 0x22, + 0x49, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x03, 0x02, 0x05, 0x08, 0x15, 0x05, + 0x12, 0x03, 0x33, 0x23, 0x48, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x03, 0x05, + 0x12, 0x03, 0x35, 0x02, 0x19, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x03, 0x05, + 0x00, 0x12, 0x03, 0x35, 0x0d, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x03, + 0x05, 0x00, 0x01, 0x12, 0x03, 0x35, 0x0d, 0x11, 0x0a, 0x0c, 0x0a, 0x05, + 0x04, 0x03, 0x05, 0x00, 0x02, 0x12, 0x03, 0x35, 0x15, 0x18, 0x0a, 0x09, + 0x0a, 0x01, 0x07, 0x12, 0x04, 0x38, 0x00, 0x4a, 0x01, 0x0a, 0x41, 0x0a, + 0x02, 0x07, 0x00, 0x12, 0x03, 0x3a, 0x02, 0x27, 0x1a, 0x36, 0x20, 0x4e, + 0x6f, 0x6e, 0x2d, 0x64, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, + 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, + 0x6f, 0x74, 0x68, 0x65, 0x72, 0x77, 0x69, 0x73, 0x65, 0x20, 0x6c, 0x6f, + 0x6f, 0x6b, 0x73, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2d, 0x6c, 0x69, + 0x6b, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x00, 0x02, 0x12, + 0x03, 0x38, 0x07, 0x14, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x00, 0x06, 0x12, + 0x03, 0x3a, 0x02, 0x10, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x00, 0x01, 0x12, + 0x03, 0x3a, 0x11, 0x1f, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x00, 0x03, 0x12, + 0x03, 0x3a, 0x22, 0x26, 0x0a, 0x29, 0x0a, 0x02, 0x07, 0x01, 0x12, 0x04, + 0x3d, 0x02, 0x3e, 0x2e, 0x1a, 0x1d, 0x20, 0x54, 0x72, 0x75, 0x6c, 0x79, + 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x2d, 0x6c, 0x69, 0x6b, 0x65, 0x20, + 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x2e, 0x0a, 0x0a, + 0x0a, 0x0a, 0x03, 0x07, 0x01, 0x02, 0x12, 0x03, 0x38, 0x07, 0x14, 0x0a, + 0x0a, 0x0a, 0x03, 0x07, 0x01, 0x06, 0x12, 0x03, 0x3d, 0x02, 0x14, 0x0a, + 0x0a, 0x0a, 0x03, 0x07, 0x01, 0x01, 0x12, 0x03, 0x3d, 0x15, 0x27, 0x0a, + 0x0a, 0x0a, 0x03, 0x07, 0x01, 0x03, 0x12, 0x03, 0x3d, 0x2a, 0x2e, 0x0a, + 0x0a, 0x0a, 0x03, 0x07, 0x01, 0x08, 0x12, 0x03, 0x3e, 0x06, 0x2d, 0x0a, + 0x0c, 0x0a, 0x05, 0x07, 0x01, 0x08, 0x15, 0x05, 0x12, 0x03, 0x3e, 0x07, + 0x2c, 0x0a, 0x4c, 0x0a, 0x02, 0x07, 0x02, 0x12, 0x04, 0x41, 0x02, 0x42, + 0x2e, 0x1a, 0x40, 0x20, 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, + 0x64, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x20, + 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x67, + 0x72, 0x6f, 0x75, 0x70, 0x2d, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x62, 0x65, + 0x63, 0x61, 0x75, 0x73, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x74, 0x73, + 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x07, + 0x02, 0x02, 0x12, 0x03, 0x38, 0x07, 0x14, 0x0a, 0x0a, 0x0a, 0x03, 0x07, + 0x02, 0x06, 0x12, 0x03, 0x41, 0x02, 0x13, 0x0a, 0x0a, 0x0a, 0x03, 0x07, + 0x02, 0x01, 0x12, 0x03, 0x41, 0x14, 0x28, 0x0a, 0x0a, 0x0a, 0x03, 0x07, + 0x02, 0x03, 0x12, 0x03, 0x41, 0x2b, 0x2f, 0x0a, 0x0a, 0x0a, 0x03, 0x07, + 0x02, 0x08, 0x12, 0x03, 0x42, 0x06, 0x2d, 0x0a, 0x0c, 0x0a, 0x05, 0x07, + 0x02, 0x08, 0x15, 0x05, 0x12, 0x03, 0x42, 0x07, 0x2c, 0x0a, 0x59, 0x0a, + 0x02, 0x07, 0x03, 0x12, 0x04, 0x45, 0x02, 0x46, 0x2e, 0x1a, 0x4d, 0x20, + 0x44, 0x65, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64, 0x20, 0x65, 0x78, + 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, + 0x20, 0x69, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x67, 0x72, 0x6f, 0x75, 0x70, + 0x2d, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x62, 0x65, 0x63, 0x61, 0x75, 0x73, + 0x65, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x63, 0x6f, + 0x70, 0x65, 0x20, 0x6f, 0x66, 0x20, 0x69, 0x74, 0x73, 0x20, 0x74, 0x79, + 0x70, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x03, 0x02, 0x12, + 0x03, 0x38, 0x07, 0x14, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x03, 0x06, 0x12, + 0x03, 0x45, 0x02, 0x19, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x03, 0x01, 0x12, + 0x03, 0x45, 0x1a, 0x23, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x03, 0x03, 0x12, + 0x03, 0x45, 0x26, 0x2a, 0x0a, 0x0a, 0x0a, 0x03, 0x07, 0x03, 0x08, 0x12, + 0x03, 0x46, 0x06, 0x2d, 0x0a, 0x0c, 0x0a, 0x05, 0x07, 0x03, 0x08, 0x15, + 0x05, 0x12, 0x03, 0x46, 0x07, 0x2c, 0x0a, 0x54, 0x0a, 0x02, 0x07, 0x04, + 0x12, 0x03, 0x49, 0x02, 0x4d, 0x1a, 0x49, 0x20, 0x44, 0x65, 0x6c, 0x69, + 0x6d, 0x69, 0x74, 0x65, 0x64, 0x20, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, + 0x69, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x61, 0x74, 0x27, 0x73, 0x20, 0x67, + 0x72, 0x6f, 0x75, 0x70, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x65, 0x78, 0x63, + 0x65, 0x70, 0x74, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x74, 0x27, + 0x73, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, + 0x07, 0x04, 0x02, 0x12, 0x03, 0x38, 0x07, 0x14, 0x0a, 0x0a, 0x0a, 0x03, + 0x07, 0x04, 0x06, 0x12, 0x03, 0x49, 0x02, 0x0f, 0x0a, 0x0a, 0x0a, 0x03, + 0x07, 0x04, 0x01, 0x12, 0x03, 0x49, 0x10, 0x1d, 0x0a, 0x0a, 0x0a, 0x03, + 0x07, 0x04, 0x03, 0x12, 0x03, 0x49, 0x20, 0x24, 0x0a, 0x0a, 0x0a, 0x03, + 0x07, 0x04, 0x08, 0x12, 0x03, 0x49, 0x25, 0x4c, 0x0a, 0x0c, 0x0a, 0x05, + 0x07, 0x04, 0x08, 0x15, 0x05, 0x12, 0x03, 0x49, 0x26, 0x4b, 0x62, 0x08, + 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x70, 0xe8, 0x07, 0x0a, + 0x9a, 0x0c, 0x0a, 0x24, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x5f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, + 0x65, 0x5f, 0x6d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x18, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x67, 0x65, 0x6e, + 0x5f, 0x73, 0x77, 0x69, 0x66, 0x74, 0x22, 0xac, 0x01, 0x0a, 0x0e, 0x4d, + 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x4d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, + 0x73, 0x12, 0x48, 0x0a, 0x07, 0x6d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, + 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x73, 0x77, 0x69, + 0x66, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x67, 0x65, 0x6e, 0x5f, 0x73, 0x77, 0x69, 0x66, 0x74, 0x2e, 0x4d, 0x6f, + 0x64, 0x75, 0x6c, 0x65, 0x4d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x73, + 0x2e, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x07, 0x6d, 0x61, 0x70, 0x70, + 0x69, 0x6e, 0x67, 0x1a, 0x50, 0x0a, 0x05, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x5f, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6d, + 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x26, 0x0a, + 0x0f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x5f, + 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x46, 0x69, 0x6c, 0x65, 0x50, 0x61, 0x74, + 0x68, 0x4a, 0xa0, 0x0a, 0x0a, 0x06, 0x12, 0x04, 0x0b, 0x00, 0x24, 0x01, + 0x0a, 0xca, 0x03, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x0b, 0x00, 0x12, 0x32, + 0xbf, 0x03, 0x20, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x53, 0x77, + 0x69, 0x66, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x50, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x4c, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, + 0x2f, 0x73, 0x77, 0x69, 0x66, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x5f, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x5f, 0x6d, + 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x20, 0x2d, 0x20, 0x53, 0x77, 0x69, 0x66, 0x74, 0x20, 0x4d, 0x6f, + 0x64, 0x75, 0x6c, 0x65, 0x20, 0x6d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, + 0x73, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x0a, 0x0a, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x69, + 0x73, 0x20, 0x70, 0x61, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x53, 0x77, 0x69, 0x66, 0x74, 0x2e, 0x6f, 0x72, 0x67, 0x20, + 0x6f, 0x70, 0x65, 0x6e, 0x20, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20, + 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x0a, 0x0a, 0x20, 0x43, 0x6f, + 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x28, 0x63, 0x29, 0x20, + 0x32, 0x30, 0x31, 0x34, 0x20, 0x2d, 0x20, 0x32, 0x30, 0x31, 0x37, 0x20, + 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x49, 0x6e, 0x63, 0x2e, 0x20, 0x61, + 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20, 0x53, 0x77, 0x69, 0x66, 0x74, + 0x20, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x61, 0x75, 0x74, + 0x68, 0x6f, 0x72, 0x73, 0x0a, 0x20, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, + 0x65, 0x64, 0x20, 0x75, 0x6e, 0x64, 0x65, 0x72, 0x20, 0x41, 0x70, 0x61, + 0x63, 0x68, 0x65, 0x20, 0x4c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x20, + 0x76, 0x32, 0x2e, 0x30, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x52, 0x75, + 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x20, 0x4c, 0x69, 0x62, 0x72, 0x61, 0x72, + 0x79, 0x20, 0x45, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x0a, + 0x0a, 0x20, 0x53, 0x65, 0x65, 0x20, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, + 0x2f, 0x73, 0x77, 0x69, 0x66, 0x74, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x4c, + 0x49, 0x43, 0x45, 0x4e, 0x53, 0x45, 0x2e, 0x74, 0x78, 0x74, 0x20, 0x66, + 0x6f, 0x72, 0x20, 0x6c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x20, 0x69, + 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x20, + 0x53, 0x65, 0x65, 0x20, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x73, + 0x77, 0x69, 0x66, 0x74, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x43, 0x4f, 0x4e, + 0x54, 0x52, 0x49, 0x42, 0x55, 0x54, 0x4f, 0x52, 0x53, 0x2e, 0x74, 0x78, + 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, + 0x73, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x53, 0x77, 0x69, 0x66, 0x74, 0x20, + 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, 0x20, 0x61, 0x75, 0x74, 0x68, + 0x6f, 0x72, 0x73, 0x0a, 0x0a, 0x0a, 0x08, 0x0a, 0x01, 0x02, 0x12, 0x03, + 0x0d, 0x00, 0x21, 0x0a, 0x80, 0x01, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, + 0x11, 0x00, 0x24, 0x01, 0x1a, 0x74, 0x20, 0x43, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x75, 0x73, 0x65, + 0x64, 0x20, 0x74, 0x6f, 0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x20, 0x6d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x73, + 0x20, 0x66, 0x6f, 0x72, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, + 0x65, 0x64, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x66, 0x69, 0x6c, + 0x65, 0x73, 0x0a, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x53, + 0x77, 0x69, 0x66, 0x74, 0x20, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x20, + 0x74, 0x68, 0x65, 0x79, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x62, 0x65, + 0x20, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, + 0x2e, 0x0a, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x11, + 0x08, 0x16, 0x0a, 0x5a, 0x0a, 0x04, 0x04, 0x00, 0x03, 0x00, 0x12, 0x04, + 0x15, 0x02, 0x20, 0x03, 0x1a, 0x4c, 0x20, 0x49, 0x6e, 0x64, 0x69, 0x76, + 0x69, 0x64, 0x75, 0x61, 0x6c, 0x20, 0x6c, 0x69, 0x73, 0x74, 0x69, 0x6e, + 0x67, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x64, + 0x75, 0x6c, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x61, 0x6e, 0x64, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x20, 0x74, + 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20, 0x67, 0x6f, 0x0a, + 0x20, 0x69, 0x6e, 0x74, 0x6f, 0x20, 0x69, 0x74, 0x2e, 0x0a, 0x0a, 0x0c, + 0x0a, 0x05, 0x04, 0x00, 0x03, 0x00, 0x01, 0x12, 0x03, 0x15, 0x0a, 0x0f, + 0x0a, 0x79, 0x0a, 0x06, 0x04, 0x00, 0x03, 0x00, 0x02, 0x00, 0x12, 0x03, + 0x19, 0x04, 0x1b, 0x1a, 0x6a, 0x20, 0x54, 0x68, 0x65, 0x20, 0x53, 0x77, + 0x69, 0x66, 0x74, 0x20, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x20, 0x6e, + 0x61, 0x6d, 0x65, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77, 0x69, 0x6c, + 0x6c, 0x20, 0x62, 0x65, 0x20, 0x69, 0x6d, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x74, + 0x6f, 0x20, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x20, 0x61, 0x6c, 0x6c, 0x0a, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x79, 0x70, 0x65, 0x73, 0x20, 0x66, + 0x72, 0x6f, 0x6d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x69, 0x76, 0x65, + 0x6e, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x66, 0x69, 0x6c, 0x65, + 0x73, 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, + 0x00, 0x05, 0x12, 0x03, 0x19, 0x04, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, + 0x00, 0x03, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x19, 0x0b, 0x16, 0x0a, + 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, + 0x19, 0x19, 0x1a, 0x0a, 0x84, 0x02, 0x0a, 0x06, 0x04, 0x00, 0x03, 0x00, + 0x02, 0x01, 0x12, 0x03, 0x1f, 0x04, 0x28, 0x1a, 0xf4, 0x01, 0x20, 0x54, + 0x68, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x20, 0x66, 0x69, 0x6c, + 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x73, 0x68, 0x6f, 0x75, + 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x69, 0x64, + 0x65, 0x72, 0x65, 0x64, 0x20, 0x69, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, + 0x20, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x2e, 0x20, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x0a, 0x20, 0x73, 0x68, + 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, + 0x68, 0x6f, 0x77, 0x20, 0x74, 0x68, 0x65, 0x79, 0x20, 0x61, 0x72, 0x65, + 0x20, 0x65, 0x78, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x74, + 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, + 0x74, 0x65, 0x64, 0x3b, 0x20, 0x69, 0x2e, 0x65, 0x2e, 0x20, 0x2d, 0x20, + 0x68, 0x6f, 0x77, 0x20, 0x74, 0x68, 0x65, 0x79, 0x0a, 0x20, 0x61, 0x72, + 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x69, 0x6d, + 0x70, 0x6f, 0x72, 0x74, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x20, + 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x75, 0x73, 0x65, 0x64, 0x20, 0x66, + 0x72, 0x6f, 0x6d, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20, 0x66, 0x69, + 0x6c, 0x65, 0x73, 0x2c, 0x20, 0x73, 0x6f, 0x20, 0x60, 0x6d, 0x79, 0x5f, + 0x66, 0x69, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x60, 0x0a, + 0x20, 0x6f, 0x72, 0x20, 0x60, 0x70, 0x61, 0x74, 0x68, 0x2f, 0x74, 0x6f, + 0x2f, 0x66, 0x69, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x60, + 0x2e, 0x0a, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x01, + 0x04, 0x12, 0x03, 0x1f, 0x04, 0x0c, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, + 0x03, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x1f, 0x0d, 0x13, 0x0a, 0x0e, + 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x1f, + 0x14, 0x23, 0x0a, 0x0e, 0x0a, 0x07, 0x04, 0x00, 0x03, 0x00, 0x02, 0x01, + 0x03, 0x12, 0x03, 0x1f, 0x26, 0x27, 0x0a, 0x1c, 0x0a, 0x04, 0x04, 0x00, + 0x02, 0x00, 0x12, 0x03, 0x23, 0x02, 0x1d, 0x1a, 0x0f, 0x20, 0x54, 0x68, + 0x65, 0x20, 0x6d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x73, 0x2e, 0x0a, + 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x04, 0x12, 0x03, 0x23, + 0x02, 0x0a, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x06, 0x12, + 0x03, 0x23, 0x0b, 0x10, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, + 0x01, 0x12, 0x03, 0x23, 0x11, 0x18, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, + 0x02, 0x00, 0x03, 0x12, 0x03, 0x23, 0x1b, 0x1c, 0x62, 0x06, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x33 ] -let fileDescriptorSetData = Data(fileDescriptorSetBytes) diff --git a/Tests/SwiftProtobufPluginLibraryTests/PluginLibTestingEditionDefaults.swift b/Tests/SwiftProtobufPluginLibraryTests/PluginLibTestingEditionDefaults.swift new file mode 100644 index 000000000..012490b93 --- /dev/null +++ b/Tests/SwiftProtobufPluginLibraryTests/PluginLibTestingEditionDefaults.swift @@ -0,0 +1,20 @@ +// See Makefile how this is generated. +// swift-format-ignore-file +import Foundation +let testFeatureSetDefaultBytes: [UInt8] = [ + 0x0a, 0x29, 0x18, 0x84, 0x07, 0x22, 0x04, 0xfa, 0xf0, 0x04, 0x00, 0x2a, + 0x1e, 0x08, 0x01, 0x10, 0x02, 0x18, 0x02, 0x20, 0x03, 0x28, 0x01, 0x30, + 0x02, 0x38, 0x02, 0x40, 0x01, 0xfa, 0xf0, 0x04, 0x0a, 0x08, 0x01, 0x10, + 0x01, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x0a, 0x29, 0x18, 0xe7, 0x07, + 0x22, 0x04, 0xfa, 0xf0, 0x04, 0x00, 0x2a, 0x1e, 0x08, 0x02, 0x10, 0x01, + 0x18, 0x01, 0x20, 0x02, 0x28, 0x01, 0x30, 0x01, 0x38, 0x02, 0x40, 0x01, + 0xfa, 0xf0, 0x04, 0x0a, 0x08, 0x01, 0x10, 0x01, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x01, 0x0a, 0x29, 0x18, 0xe8, 0x07, 0x22, 0x1a, 0x08, 0x01, 0x10, + 0x01, 0x18, 0x01, 0x20, 0x02, 0x28, 0x01, 0x30, 0x01, 0xfa, 0xf0, 0x04, + 0x0a, 0x08, 0x01, 0x10, 0x01, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x2a, + 0x08, 0x38, 0x02, 0x40, 0x01, 0xfa, 0xf0, 0x04, 0x00, 0x0a, 0x29, 0x18, + 0xe9, 0x07, 0x22, 0x1e, 0x08, 0x01, 0x10, 0x01, 0x18, 0x01, 0x20, 0x02, + 0x28, 0x01, 0x30, 0x01, 0x38, 0x01, 0x40, 0x02, 0xfa, 0xf0, 0x04, 0x0a, + 0x08, 0x01, 0x10, 0x01, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x2a, 0x04, + 0xfa, 0xf0, 0x04, 0x00, 0x20, 0xe6, 0x07, 0x28, 0xe9, 0x07 +] diff --git a/Tests/SwiftProtobufPluginLibraryTests/Test_Descriptor.swift b/Tests/SwiftProtobufPluginLibraryTests/Test_Descriptor.swift index 9952f3346..1c339ed30 100644 --- a/Tests/SwiftProtobufPluginLibraryTests/Test_Descriptor.swift +++ b/Tests/SwiftProtobufPluginLibraryTests/Test_Descriptor.swift @@ -8,429 +8,491 @@ // // ----------------------------------------------------------------------------- -import XCTest import SwiftProtobuf import SwiftProtobufPluginLibrary +import XCTest + +extension FileDescriptor { + func extensionField(named: String) -> FieldDescriptor? { + extensions.first { $0.name == named } + } +} +extension Descriptor { + func field(named: String) -> FieldDescriptor? { + fields.first { $0.name == named } + } +} + +final class Test_Descriptor: XCTestCase { + + func testParsing() throws { + let fileSet = try Google_Protobuf_FileDescriptorSet(serializedBytes: fileDescriptorSetBytes) + + let descriptorSet = DescriptorSet(proto: fileSet) + XCTAssertEqual(descriptorSet.files.count, 7) + // descriptor.proto documents the protoc will order the files based on the import + // from plugin on descriptor. + XCTAssertEqual(descriptorSet.files[0].name, "pluginlib_descriptor_test_import.proto") + XCTAssertEqual(descriptorSet.files[1].name, "pluginlib_descriptor_test.proto") + XCTAssertEqual(descriptorSet.files[2].name, "pluginlib_descriptor_test2.proto") + XCTAssertEqual(descriptorSet.files[3].name, "pluginlib_descriptor_delimited.proto") + XCTAssertEqual(descriptorSet.files[4].name, "unittest_delimited_import.proto") + XCTAssertEqual(descriptorSet.files[5].name, "unittest_delimited.proto") + XCTAssertEqual(descriptorSet.files[6].name, "swift_protobuf_module_mappings.proto") + + let importFileDescriptor = descriptorSet.files[0] + + XCTAssertEqual(importFileDescriptor.messages.count, 2) + XCTAssertEqual(importFileDescriptor.messages[0].fullName, "swift_descriptor_test.import.Version") + XCTAssertNil(importFileDescriptor.messages[0].containingType) + XCTAssertEqual(importFileDescriptor.messages[0].messages.count, 0) + XCTAssertEqual(importFileDescriptor.enums.count, 0) + XCTAssertEqual(importFileDescriptor.extensions.count, 0) + + XCTAssertEqual(importFileDescriptor.messages[1].fullName, "swift_descriptor_test.import.ExtendableOne") + XCTAssertNil(importFileDescriptor.messages[1].containingType) + XCTAssertEqual(importFileDescriptor.messages[1].messages.count, 1) + + XCTAssertEqual( + importFileDescriptor.messages[1].messages[0].fullName, + "swift_descriptor_test.import.ExtendableOne.ExtendableTwo" + ) + XCTAssertEqual(importFileDescriptor.messages[1].messages[0].messages.count, 0) + + let testFileDesciptor = descriptorSet.files[1] + + XCTAssertEqual(testFileDesciptor.enums.count, 1) + XCTAssertEqual(testFileDesciptor.enums[0].fullName, "swift_descriptor_test.TopLevelEnum") + XCTAssertNil(testFileDesciptor.enums[0].containingType) + + XCTAssertEqual(testFileDesciptor.messages[0].enums.count, 1) + XCTAssertEqual(testFileDesciptor.messages[0].enums[0].fullName, "swift_descriptor_test.TopLevelMessage.SubEnum") + XCTAssertTrue(testFileDesciptor.messages[0].enums[0].containingType === testFileDesciptor.messages[0]) + + XCTAssertEqual(testFileDesciptor.messages[0].oneofs.count, 1) + XCTAssertEqual(testFileDesciptor.messages[0].oneofs[0].name, "o") + XCTAssertEqual(testFileDesciptor.messages[1].oneofs.count, 0) + + XCTAssertEqual(testFileDesciptor.extensions.count, 1) + XCTAssertEqual(testFileDesciptor.extensions[0].name, "ext_str") + XCTAssertEqual(testFileDesciptor.messages[3].extensions.count, 2) + XCTAssertEqual(testFileDesciptor.messages[3].extensions[0].name, "ext_enum") + XCTAssertEqual(testFileDesciptor.messages[3].extensions[1].name, "ext_msg") + + XCTAssertEqual(testFileDesciptor.services.count, 1) + XCTAssertEqual(testFileDesciptor.services[0].fullName, "swift_descriptor_test.SomeService") + XCTAssertEqual(testFileDesciptor.services[0].methods.count, 2) + XCTAssertEqual(testFileDesciptor.services[0].methods[0].name, "Foo") + XCTAssertEqual(testFileDesciptor.services[0].methods[1].name, "Bar") + } + + func testLookup() throws { + let fileSet = try Google_Protobuf_FileDescriptorSet(serializedBytes: fileDescriptorSetBytes) + + let descriptorSet = DescriptorSet(proto: fileSet) + + XCTAssertTrue( + descriptorSet.fileDescriptor(named: "pluginlib_descriptor_test_import.proto") === descriptorSet.files[0] + ) + + XCTAssertTrue( + descriptorSet.descriptor(named: "swift_descriptor_test.import.Version") + === descriptorSet.files[0].messages[0] + ) + XCTAssertTrue( + descriptorSet.descriptor(named: "swift_descriptor_test.TopLevelMessage") + === descriptorSet.files[1].messages[0] + ) + XCTAssertTrue( + descriptorSet.descriptor(named: "swift_descriptor_test.TopLevelMessage.SubMessage") + === descriptorSet.files[1].messages[0].messages[0] + ) + + XCTAssertTrue( + descriptorSet.enumDescriptor(named: "swift_descriptor_test.TopLevelEnum") + === descriptorSet.files[1].enums[0] + ) + XCTAssertTrue( + descriptorSet.enumDescriptor(named: "swift_descriptor_test.TopLevelMessage.SubEnum") + === descriptorSet.files[1].messages[0].enums[0] + ) + + XCTAssertTrue( + descriptorSet.serviceDescriptor(named: "swift_descriptor_test.SomeService") + === descriptorSet.files[1].services[0] + ) + } + + func testParents() throws { + let fileSet = try Google_Protobuf_FileDescriptorSet(serializedBytes: fileDescriptorSetBytes) + + let descriptorSet = DescriptorSet(proto: fileSet) + + let importVersion = descriptorSet.descriptor(named: "swift_descriptor_test.import.Version")! + XCTAssertTrue(importVersion.containingType == nil) -class Test_Descriptor: XCTestCase { - - func testParsing() throws { - let fileSet = try Google_Protobuf_FileDescriptorSet(serializedData: fileDescriptorSetData) - - let descriptorSet = DescriptorSet(proto: fileSet) - XCTAssertEqual(descriptorSet.files.count, 5) - // descriptor.proto documents the protoc will order the files based on the import - // from plugin on descriptor. - XCTAssertEqual(descriptorSet.files[0].name, "google/protobuf/descriptor.proto") - XCTAssertEqual(descriptorSet.files[1].name, "google/protobuf/compiler/plugin.proto") - XCTAssertEqual(descriptorSet.files[2].name, "pluginlib_descriptor_test.proto") - XCTAssertEqual(descriptorSet.files[3].name, "pluginlib_descriptor_test2.proto") - XCTAssertEqual(descriptorSet.files[4].name, "SwiftProtobufPluginLibrary/swift_protobuf_module_mappings.proto") - - let pluginFileDescriptor = descriptorSet.files[1] - - XCTAssertEqual(pluginFileDescriptor.messages.count, 3) - XCTAssertEqual(pluginFileDescriptor.messages[0].fullName, ".google.protobuf.compiler.Version") - XCTAssertNil(pluginFileDescriptor.messages[0].containingType) - XCTAssertEqual(pluginFileDescriptor.messages[0].messages.count, 0) - XCTAssertEqual(pluginFileDescriptor.messages[1].fullName, ".google.protobuf.compiler.CodeGeneratorRequest") - XCTAssertNil(pluginFileDescriptor.messages[1].containingType) - XCTAssertEqual(pluginFileDescriptor.messages[1].messages.count, 0) - XCTAssertEqual(pluginFileDescriptor.messages[2].fullName, ".google.protobuf.compiler.CodeGeneratorResponse") - XCTAssertNil(pluginFileDescriptor.messages[2].containingType) - XCTAssertEqual(pluginFileDescriptor.messages[2].messages.count, 1) - XCTAssertEqual(pluginFileDescriptor.messages[2].messages[0].fullName, ".google.protobuf.compiler.CodeGeneratorResponse.File") - XCTAssertTrue(pluginFileDescriptor.messages[2].messages[0].containingType === pluginFileDescriptor.messages[2]) - - let descriptorFileDescriptor = descriptorSet.files[0] - - XCTAssertEqual(descriptorFileDescriptor.enums.count, 0) - XCTAssertEqual(descriptorFileDescriptor.messages[4].enums.count, 2) - XCTAssertEqual(descriptorFileDescriptor.messages[4].enums[0].fullName, ".google.protobuf.FieldDescriptorProto.Type") - XCTAssertTrue(descriptorFileDescriptor.messages[4].enums[0].containingType === descriptorFileDescriptor.messages[4]) - XCTAssertEqual(descriptorFileDescriptor.messages[4].enums[1].fullName, ".google.protobuf.FieldDescriptorProto.Label") - XCTAssertTrue(descriptorFileDescriptor.messages[4].enums[1].containingType === descriptorFileDescriptor.messages[4]) - - let testFileDesciptor = descriptorSet.files[2] - - XCTAssertEqual(testFileDesciptor.enums.count, 1) - XCTAssertEqual(testFileDesciptor.enums[0].fullName, ".swift_descriptor_test.TopLevelEnum") - XCTAssertNil(testFileDesciptor.enums[0].containingType) - - XCTAssertEqual(testFileDesciptor.messages[0].oneofs.count, 1) - XCTAssertEqual(testFileDesciptor.messages[0].oneofs[0].name, "o") - XCTAssertEqual(testFileDesciptor.messages[1].oneofs.count, 0) - - XCTAssertEqual(testFileDesciptor.extensions.count, 1) - XCTAssertEqual(testFileDesciptor.extensions[0].name, "ext_str") - XCTAssertEqual(testFileDesciptor.messages[3].extensions.count, 2) - XCTAssertEqual(testFileDesciptor.messages[3].extensions[0].name, "ext_enum") - XCTAssertEqual(testFileDesciptor.messages[3].extensions[1].name, "ext_msg") - - XCTAssertEqual(testFileDesciptor.services.count, 1) - XCTAssertEqual(testFileDesciptor.services[0].fullName, ".swift_descriptor_test.SomeService") - XCTAssertEqual(testFileDesciptor.services[0].methods.count, 2) - XCTAssertEqual(testFileDesciptor.services[0].methods[0].name, "Foo") - XCTAssertEqual(testFileDesciptor.services[0].methods[1].name, "Bar") - } - - func testLookup() throws { - let fileSet = try Google_Protobuf_FileDescriptorSet(serializedData: fileDescriptorSetData) - - let descriptorSet = DescriptorSet(proto: fileSet) - - XCTAssertTrue(descriptorSet.lookupFileDescriptor(protoName: "google/protobuf/descriptor.proto") === descriptorSet.files[0]) - XCTAssertTrue(descriptorSet.lookupFileDescriptor(protoName: "google/protobuf/compiler/plugin.proto") === descriptorSet.files[1]) - - XCTAssertTrue(descriptorSet.lookupDescriptor(protoName: ".google.protobuf.compiler.CodeGeneratorRequest") === descriptorSet.files[1].messages[1]) - XCTAssertTrue(descriptorSet.lookupDescriptor(protoName: ".google.protobuf.DescriptorProto") === descriptorSet.files[0].messages[2]) - XCTAssertTrue(descriptorSet.lookupDescriptor(protoName: ".google.protobuf.DescriptorProto.ExtensionRange") === descriptorSet.files[0].messages[2].messages[0]) - - XCTAssertTrue(descriptorSet.lookupEnumDescriptor(protoName: ".google.protobuf.FieldDescriptorProto.Type") === descriptorSet.files[0].messages[4].enums[0]) - XCTAssertTrue(descriptorSet.lookupEnumDescriptor(protoName: ".google.protobuf.FieldDescriptorProto.Label") === descriptorSet.files[0].messages[4].enums[1]) - - XCTAssertTrue(descriptorSet.lookupServiceDescriptor(protoName: ".swift_descriptor_test.SomeService") === descriptorSet.files[2].services[0]) - } - - func testParents() throws { - let fileSet = try Google_Protobuf_FileDescriptorSet(serializedData: fileDescriptorSetData) - - let descriptorSet = DescriptorSet(proto: fileSet) - - let codeGenResponse = descriptorSet.lookupDescriptor(protoName: ".google.protobuf.compiler.CodeGeneratorResponse") - XCTAssertTrue(codeGenResponse.containingType == nil) - let codeGenResponseFile = descriptorSet.lookupDescriptor(protoName: ".google.protobuf.compiler.CodeGeneratorResponse.File") - XCTAssertTrue(codeGenResponseFile.containingType === codeGenResponse) - - let fieldDescProto = descriptorSet.lookupDescriptor(protoName: ".google.protobuf.FieldDescriptorProto") - let fieldDescType = descriptorSet.lookupEnumDescriptor(protoName: ".google.protobuf.FieldDescriptorProto.Type") - XCTAssertTrue(fieldDescType.containingType === fieldDescProto) - let fieldDescLabel = descriptorSet.lookupEnumDescriptor(protoName: ".google.protobuf.FieldDescriptorProto.Label") - XCTAssertTrue(fieldDescLabel.containingType === fieldDescProto) - - let serviceDescProto = descriptorSet.lookupServiceDescriptor(protoName: ".swift_descriptor_test.SomeService") - let fooMethod = serviceDescProto.methods[0] - XCTAssertTrue(fooMethod.service === serviceDescProto) - let barMethod = serviceDescProto.methods[1] - XCTAssertTrue(barMethod.service === serviceDescProto) - - let descriptorFile = descriptorSet.files[0] - let pluginFile = descriptorSet.files[1] - let descriptorTestFile = descriptorSet.files[2] - - XCTAssertTrue(codeGenResponse.file === pluginFile) - XCTAssertTrue(codeGenResponseFile.file === pluginFile) - - XCTAssertTrue(fieldDescProto.file === descriptorFile) - XCTAssertTrue(fieldDescType.file === descriptorFile) - XCTAssertTrue(fieldDescLabel.file === descriptorFile) - - XCTAssertTrue(serviceDescProto.file === descriptorTestFile) - } - - func testFields() throws { - let fileSet = try Google_Protobuf_FileDescriptorSet(serializedData: fileDescriptorSetData) - - let descriptorSet = DescriptorSet(proto: fileSet) - - let topLevelEnum = descriptorSet.lookupEnumDescriptor(protoName: ".swift_descriptor_test.TopLevelEnum") - let topLevelMessage = descriptorSet.lookupDescriptor(protoName: ".swift_descriptor_test.TopLevelMessage") - let subEnum = topLevelMessage.enums[0] - let subMessage = topLevelMessage.messages[0] - let topLevelMessage2 = descriptorSet.lookupDescriptor(protoName: ".swift_descriptor_test.TopLevelMessage2") - - XCTAssertEqual(topLevelMessage.fields.count, 6) - XCTAssertEqual(topLevelMessage.fields[0].name, "field1") - XCTAssertEqual(topLevelMessage.fields[1].name, "field2") - XCTAssertEqual(topLevelMessage.fields[2].name, "field3") - XCTAssertEqual(topLevelMessage.fields[3].name, "field4") - XCTAssertEqual(topLevelMessage.fields[4].name, "field5") - XCTAssertEqual(topLevelMessage.fields[5].name, "field6") - XCTAssertTrue(topLevelMessage.fields[2].enumType === topLevelEnum) - XCTAssertTrue(topLevelMessage.fields[3].enumType === subEnum) - XCTAssertTrue(topLevelMessage.fields[4].messageType === subMessage) - XCTAssertTrue(topLevelMessage.fields[5].messageType === topLevelMessage2) - - let oneof = topLevelMessage.oneofs[0] - XCTAssertTrue(oneof.containingType === topLevelMessage) - XCTAssertEqual(oneof.fields.count, 4) - XCTAssertTrue(oneof.fields[0] === topLevelMessage.fields[2]) - XCTAssertTrue(oneof.fields[1] === topLevelMessage.fields[3]) - XCTAssertTrue(oneof.fields[2] === topLevelMessage.fields[4]) - XCTAssertTrue(oneof.fields[3] === topLevelMessage.fields[5]) - - XCTAssertEqual(topLevelMessage2.fields.count, 2) - XCTAssertEqual(topLevelMessage2.fields[0].name, "left") - XCTAssertEqual(topLevelMessage2.fields[1].name, "right") - XCTAssertTrue(topLevelMessage2.fields[0].messageType === topLevelMessage) - XCTAssertTrue(topLevelMessage2.fields[1].messageType === topLevelMessage2) - - let externalRefs = descriptorSet.lookupDescriptor(protoName: ".swift_descriptor_test.ExternalRefs") - let googleProtobufDescriptorProto = descriptorSet.lookupDescriptor(protoName: ".google.protobuf.DescriptorProto") - let googleProtobufCompilerVersion = descriptorSet.lookupDescriptor(protoName: ".google.protobuf.compiler.Version") - - XCTAssertEqual(externalRefs.fields.count, 2) - XCTAssertEqual(externalRefs.fields[0].name, "desc") - XCTAssertEqual(externalRefs.fields[1].name, "ver") - XCTAssertTrue(externalRefs.fields[0].messageType === googleProtobufDescriptorProto) - XCTAssertTrue(externalRefs.fields[1].messageType === googleProtobufCompilerVersion) - - // Proto2 Presence - - let proto2ForPresence = descriptorSet.lookupDescriptor(protoName: ".swift_descriptor_test.Proto2MessageForPresence") - - XCTAssertEqual(proto2ForPresence.fields.count, 16) - XCTAssertEqual(proto2ForPresence.fields[0].name, "req_str_field") - XCTAssertEqual(proto2ForPresence.fields[1].name, "req_int32_field") - XCTAssertEqual(proto2ForPresence.fields[2].name, "req_enum_field") - XCTAssertEqual(proto2ForPresence.fields[3].name, "req_message_field") - XCTAssertEqual(proto2ForPresence.fields[4].name, "opt_str_field") - XCTAssertEqual(proto2ForPresence.fields[5].name, "opt_int32_field") - XCTAssertEqual(proto2ForPresence.fields[6].name, "opt_enum_field") - XCTAssertEqual(proto2ForPresence.fields[7].name, "opt_message_field") - XCTAssertEqual(proto2ForPresence.fields[8].name, "repeat_str_field") - XCTAssertEqual(proto2ForPresence.fields[9].name, "repeat_int32_field") - XCTAssertEqual(proto2ForPresence.fields[10].name, "repeat_enum_field") - XCTAssertEqual(proto2ForPresence.fields[11].name, "repeat_message_field") - XCTAssertEqual(proto2ForPresence.fields[12].name, "oneof_str_field") - XCTAssertEqual(proto2ForPresence.fields[13].name, "oneof_int32_field") - XCTAssertEqual(proto2ForPresence.fields[14].name, "oneof_enum_field") - XCTAssertEqual(proto2ForPresence.fields[15].name, "oneof_message_field") - - XCTAssertFalse(proto2ForPresence.fields[0].hasOptionalKeyword) - XCTAssertFalse(proto2ForPresence.fields[1].hasOptionalKeyword) - XCTAssertFalse(proto2ForPresence.fields[2].hasOptionalKeyword) - XCTAssertFalse(proto2ForPresence.fields[3].hasOptionalKeyword) - XCTAssertTrue(proto2ForPresence.fields[4].hasOptionalKeyword) - XCTAssertTrue(proto2ForPresence.fields[5].hasOptionalKeyword) - XCTAssertTrue(proto2ForPresence.fields[6].hasOptionalKeyword) - XCTAssertTrue(proto2ForPresence.fields[7].hasOptionalKeyword) - XCTAssertFalse(proto2ForPresence.fields[8].hasOptionalKeyword) - XCTAssertFalse(proto2ForPresence.fields[9].hasOptionalKeyword) - XCTAssertFalse(proto2ForPresence.fields[10].hasOptionalKeyword) - XCTAssertFalse(proto2ForPresence.fields[11].hasOptionalKeyword) - XCTAssertFalse(proto2ForPresence.fields[12].hasOptionalKeyword) - XCTAssertFalse(proto2ForPresence.fields[13].hasOptionalKeyword) - XCTAssertFalse(proto2ForPresence.fields[14].hasOptionalKeyword) - XCTAssertFalse(proto2ForPresence.fields[15].hasOptionalKeyword) - - XCTAssertTrue(proto2ForPresence.fields[0].hasPresence) - XCTAssertTrue(proto2ForPresence.fields[1].hasPresence) - XCTAssertTrue(proto2ForPresence.fields[2].hasPresence) - XCTAssertTrue(proto2ForPresence.fields[3].hasPresence) - XCTAssertTrue(proto2ForPresence.fields[4].hasPresence) - XCTAssertTrue(proto2ForPresence.fields[5].hasPresence) - XCTAssertTrue(proto2ForPresence.fields[6].hasPresence) - XCTAssertTrue(proto2ForPresence.fields[7].hasPresence) - XCTAssertFalse(proto2ForPresence.fields[8].hasPresence) - XCTAssertFalse(proto2ForPresence.fields[9].hasPresence) - XCTAssertFalse(proto2ForPresence.fields[10].hasPresence) - XCTAssertFalse(proto2ForPresence.fields[11].hasPresence) - XCTAssertTrue(proto2ForPresence.fields[12].hasPresence) - XCTAssertTrue(proto2ForPresence.fields[13].hasPresence) - XCTAssertTrue(proto2ForPresence.fields[14].hasPresence) - XCTAssertTrue(proto2ForPresence.fields[15].hasPresence) - - // No synthetic oneof in proto2 syntax, so the lists should be the same. - XCTAssertEqual(proto2ForPresence.oneofs.count, proto2ForPresence.realOneofs.count) - for (i, o) in proto2ForPresence.realOneofs.enumerated() { - XCTAssert(o === proto2ForPresence.oneofs[i]) + let importExtendOne = descriptorSet.descriptor(named: "swift_descriptor_test.import.ExtendableOne")! + let importExtendTwo = descriptorSet.descriptor( + named: "swift_descriptor_test.import.ExtendableOne.ExtendableTwo" + )! + XCTAssertTrue(importExtendTwo.containingType === importExtendOne) + + let testDescriptor = descriptorSet.descriptor(named: "swift_descriptor_test.TopLevelMessage")! + let testEnum = descriptorSet.enumDescriptor(named: "swift_descriptor_test.TopLevelMessage.SubEnum")! + XCTAssertTrue(testEnum.containingType === testDescriptor) + + let serviceDescProto = descriptorSet.serviceDescriptor(named: "swift_descriptor_test.SomeService")! + let fooMethod = serviceDescProto.methods[0] + XCTAssertTrue(fooMethod.service === serviceDescProto) + let barMethod = serviceDescProto.methods[1] + XCTAssertTrue(barMethod.service === serviceDescProto) + + let importFile = descriptorSet.files[0] + let testFile = descriptorSet.files[1] + + XCTAssertTrue(importVersion.file === importFile) + + XCTAssertTrue(importExtendOne.file === importFile) + XCTAssertTrue(importExtendTwo.file === importFile) + + XCTAssertTrue(testDescriptor.file === testFile) + XCTAssertTrue(testEnum.file === testFile) + XCTAssertTrue(serviceDescProto.file === testFile) } - // Proto3 Presence - - let proto3ForPresence = descriptorSet.lookupDescriptor(protoName: ".swift_descriptor_test.Proto3MessageForPresence") - XCTAssertEqual(proto3ForPresence.fields.count, 16) - XCTAssertEqual(proto3ForPresence.fields[0].name, "str_field") - XCTAssertEqual(proto3ForPresence.fields[1].name, "int32_field") - XCTAssertEqual(proto3ForPresence.fields[2].name, "enum_field") - XCTAssertEqual(proto3ForPresence.fields[3].name, "message_field") - XCTAssertEqual(proto3ForPresence.fields[4].name, "opt_str_field") - XCTAssertEqual(proto3ForPresence.fields[5].name, "opt_int32_field") - XCTAssertEqual(proto3ForPresence.fields[6].name, "opt_enum_field") - XCTAssertEqual(proto3ForPresence.fields[7].name, "opt_message_field") - XCTAssertEqual(proto3ForPresence.fields[8].name, "repeat_str_field") - XCTAssertEqual(proto3ForPresence.fields[9].name, "repeat_int32_field") - XCTAssertEqual(proto3ForPresence.fields[10].name, "repeat_enum_field") - XCTAssertEqual(proto3ForPresence.fields[11].name, "repeat_message_field") - XCTAssertEqual(proto3ForPresence.fields[12].name, "oneof_str_field") - XCTAssertEqual(proto3ForPresence.fields[13].name, "oneof_int32_field") - XCTAssertEqual(proto3ForPresence.fields[14].name, "oneof_enum_field") - XCTAssertEqual(proto3ForPresence.fields[15].name, "oneof_message_field") - - XCTAssertFalse(proto3ForPresence.fields[0].hasOptionalKeyword) - XCTAssertFalse(proto3ForPresence.fields[1].hasOptionalKeyword) - XCTAssertFalse(proto3ForPresence.fields[2].hasOptionalKeyword) - XCTAssertFalse(proto3ForPresence.fields[3].hasOptionalKeyword) - XCTAssertTrue(proto3ForPresence.fields[4].hasOptionalKeyword) - XCTAssertTrue(proto3ForPresence.fields[5].hasOptionalKeyword) - XCTAssertTrue(proto3ForPresence.fields[6].hasOptionalKeyword) - XCTAssertTrue(proto3ForPresence.fields[7].hasOptionalKeyword) - XCTAssertFalse(proto3ForPresence.fields[8].hasOptionalKeyword) - XCTAssertFalse(proto3ForPresence.fields[9].hasOptionalKeyword) - XCTAssertFalse(proto3ForPresence.fields[10].hasOptionalKeyword) - XCTAssertFalse(proto3ForPresence.fields[11].hasOptionalKeyword) - XCTAssertFalse(proto3ForPresence.fields[12].hasOptionalKeyword) - XCTAssertFalse(proto3ForPresence.fields[13].hasOptionalKeyword) - XCTAssertFalse(proto3ForPresence.fields[14].hasOptionalKeyword) - XCTAssertFalse(proto3ForPresence.fields[15].hasOptionalKeyword) - - XCTAssertFalse(proto3ForPresence.fields[0].hasPresence) - XCTAssertFalse(proto3ForPresence.fields[1].hasPresence) - XCTAssertFalse(proto3ForPresence.fields[2].hasPresence) - XCTAssertTrue(proto3ForPresence.fields[3].hasPresence) - XCTAssertTrue(proto3ForPresence.fields[4].hasPresence) - XCTAssertTrue(proto3ForPresence.fields[5].hasPresence) - XCTAssertTrue(proto3ForPresence.fields[6].hasPresence) - XCTAssertTrue(proto3ForPresence.fields[7].hasPresence) - XCTAssertFalse(proto3ForPresence.fields[8].hasPresence) - XCTAssertFalse(proto3ForPresence.fields[9].hasPresence) - XCTAssertFalse(proto3ForPresence.fields[10].hasPresence) - XCTAssertFalse(proto3ForPresence.fields[11].hasPresence) - XCTAssertTrue(proto3ForPresence.fields[12].hasPresence) - XCTAssertTrue(proto3ForPresence.fields[13].hasPresence) - XCTAssertTrue(proto3ForPresence.fields[14].hasPresence) - XCTAssertTrue(proto3ForPresence.fields[15].hasPresence) - - // Synthetic oneof in proto3 syntax for the 'optional' fields, so - // the lists should NOTE be the same, `realOneofs` one should be a - // prefix of `oneofs`. - XCTAssertTrue(proto3ForPresence.oneofs.count > proto3ForPresence.realOneofs.count) - for (i, o) in proto2ForPresence.realOneofs.enumerated() { - XCTAssert(o === proto2ForPresence.oneofs[i]) + func testFields() throws { + let fileSet = try Google_Protobuf_FileDescriptorSet(serializedBytes: fileDescriptorSetBytes) + + let descriptorSet = DescriptorSet(proto: fileSet) + + let topLevelEnum = descriptorSet.enumDescriptor(named: "swift_descriptor_test.TopLevelEnum")! + let topLevelMessage = descriptorSet.descriptor(named: "swift_descriptor_test.TopLevelMessage")! + let subEnum = topLevelMessage.enums[0] + let subMessage = topLevelMessage.messages[0] + let topLevelMessage2 = descriptorSet.descriptor(named: "swift_descriptor_test.TopLevelMessage2")! + + XCTAssertEqual(topLevelMessage.fields.count, 6) + XCTAssertEqual(topLevelMessage.fields[0].name, "field1") + XCTAssertEqual(topLevelMessage.fields[1].name, "field2") + XCTAssertEqual(topLevelMessage.fields[2].name, "field3") + XCTAssertEqual(topLevelMessage.fields[3].name, "field4") + XCTAssertEqual(topLevelMessage.fields[4].name, "field5") + XCTAssertEqual(topLevelMessage.fields[5].name, "field6") + XCTAssertTrue(topLevelMessage.fields[2].enumType === topLevelEnum) + XCTAssertTrue(topLevelMessage.fields[3].enumType === subEnum) + XCTAssertTrue(topLevelMessage.fields[4].messageType === subMessage) + XCTAssertTrue(topLevelMessage.fields[5].messageType === topLevelMessage2) + + let oneof = topLevelMessage.oneofs[0] + XCTAssertTrue(oneof.containingType === topLevelMessage) + XCTAssertEqual(oneof.fields.count, 4) + XCTAssertTrue(oneof.fields[0] === topLevelMessage.fields[2]) + XCTAssertTrue(oneof.fields[1] === topLevelMessage.fields[3]) + XCTAssertTrue(oneof.fields[2] === topLevelMessage.fields[4]) + XCTAssertTrue(oneof.fields[3] === topLevelMessage.fields[5]) + + XCTAssertEqual(topLevelMessage2.fields.count, 2) + XCTAssertEqual(topLevelMessage2.fields[0].name, "left") + XCTAssertEqual(topLevelMessage2.fields[1].name, "right") + XCTAssertTrue(topLevelMessage2.fields[0].messageType === topLevelMessage) + XCTAssertTrue(topLevelMessage2.fields[1].messageType === topLevelMessage2) + + let externalRefs = descriptorSet.descriptor(named: "swift_descriptor_test.ExternalRefs")! + let extendOne = descriptorSet.descriptor(named: "swift_descriptor_test.import.ExtendableOne")! + let testImportVersion = descriptorSet.descriptor(named: "swift_descriptor_test.import.Version")! + + XCTAssertEqual(externalRefs.fields.count, 2) + XCTAssertEqual(externalRefs.fields[0].name, "one") + XCTAssertEqual(externalRefs.fields[1].name, "ver") + XCTAssertTrue(externalRefs.fields[0].messageType === extendOne) + XCTAssertTrue(externalRefs.fields[1].messageType === testImportVersion) + + // Proto2 Presence + + let proto2ForPresence = descriptorSet.descriptor(named: "swift_descriptor_test.Proto2MessageForPresence")! + + XCTAssertEqual(proto2ForPresence.fields.count, 16) + XCTAssertEqual(proto2ForPresence.fields[0].name, "req_str_field") + XCTAssertEqual(proto2ForPresence.fields[1].name, "req_int32_field") + XCTAssertEqual(proto2ForPresence.fields[2].name, "req_enum_field") + XCTAssertEqual(proto2ForPresence.fields[3].name, "req_message_field") + XCTAssertEqual(proto2ForPresence.fields[4].name, "opt_str_field") + XCTAssertEqual(proto2ForPresence.fields[5].name, "opt_int32_field") + XCTAssertEqual(proto2ForPresence.fields[6].name, "opt_enum_field") + XCTAssertEqual(proto2ForPresence.fields[7].name, "opt_message_field") + XCTAssertEqual(proto2ForPresence.fields[8].name, "repeat_str_field") + XCTAssertEqual(proto2ForPresence.fields[9].name, "repeat_int32_field") + XCTAssertEqual(proto2ForPresence.fields[10].name, "repeat_enum_field") + XCTAssertEqual(proto2ForPresence.fields[11].name, "repeat_message_field") + XCTAssertEqual(proto2ForPresence.fields[12].name, "oneof_str_field") + XCTAssertEqual(proto2ForPresence.fields[13].name, "oneof_int32_field") + XCTAssertEqual(proto2ForPresence.fields[14].name, "oneof_enum_field") + XCTAssertEqual(proto2ForPresence.fields[15].name, "oneof_message_field") + + XCTAssertFalse(proto2ForPresence.fields[0]._hasOptionalKeyword) + XCTAssertFalse(proto2ForPresence.fields[1]._hasOptionalKeyword) + XCTAssertFalse(proto2ForPresence.fields[2]._hasOptionalKeyword) + XCTAssertFalse(proto2ForPresence.fields[3]._hasOptionalKeyword) + XCTAssertTrue(proto2ForPresence.fields[4]._hasOptionalKeyword) + XCTAssertTrue(proto2ForPresence.fields[5]._hasOptionalKeyword) + XCTAssertTrue(proto2ForPresence.fields[6]._hasOptionalKeyword) + XCTAssertTrue(proto2ForPresence.fields[7]._hasOptionalKeyword) + XCTAssertFalse(proto2ForPresence.fields[8]._hasOptionalKeyword) + XCTAssertFalse(proto2ForPresence.fields[9]._hasOptionalKeyword) + XCTAssertFalse(proto2ForPresence.fields[10]._hasOptionalKeyword) + XCTAssertFalse(proto2ForPresence.fields[11]._hasOptionalKeyword) + XCTAssertFalse(proto2ForPresence.fields[12]._hasOptionalKeyword) + XCTAssertFalse(proto2ForPresence.fields[13]._hasOptionalKeyword) + XCTAssertFalse(proto2ForPresence.fields[14]._hasOptionalKeyword) + XCTAssertFalse(proto2ForPresence.fields[15]._hasOptionalKeyword) + + XCTAssertTrue(proto2ForPresence.fields[0].hasPresence) + XCTAssertTrue(proto2ForPresence.fields[1].hasPresence) + XCTAssertTrue(proto2ForPresence.fields[2].hasPresence) + XCTAssertTrue(proto2ForPresence.fields[3].hasPresence) + XCTAssertTrue(proto2ForPresence.fields[4].hasPresence) + XCTAssertTrue(proto2ForPresence.fields[5].hasPresence) + XCTAssertTrue(proto2ForPresence.fields[6].hasPresence) + XCTAssertTrue(proto2ForPresence.fields[7].hasPresence) + XCTAssertFalse(proto2ForPresence.fields[8].hasPresence) + XCTAssertFalse(proto2ForPresence.fields[9].hasPresence) + XCTAssertFalse(proto2ForPresence.fields[10].hasPresence) + XCTAssertFalse(proto2ForPresence.fields[11].hasPresence) + XCTAssertTrue(proto2ForPresence.fields[12].hasPresence) + XCTAssertTrue(proto2ForPresence.fields[13].hasPresence) + XCTAssertTrue(proto2ForPresence.fields[14].hasPresence) + XCTAssertTrue(proto2ForPresence.fields[15].hasPresence) + + // No synthetic oneof in proto2 syntax, so the lists should be the same. + XCTAssertEqual(proto2ForPresence.oneofs.count, proto2ForPresence.realOneofs.count) + for (i, o) in proto2ForPresence.realOneofs.enumerated() { + XCTAssert(o === proto2ForPresence.oneofs[i]) + } + + // Proto3 Presence + + let proto3ForPresence = descriptorSet.descriptor(named: "swift_descriptor_test.Proto3MessageForPresence")! + XCTAssertEqual(proto3ForPresence.fields.count, 16) + XCTAssertEqual(proto3ForPresence.fields[0].name, "str_field") + XCTAssertEqual(proto3ForPresence.fields[1].name, "int32_field") + XCTAssertEqual(proto3ForPresence.fields[2].name, "enum_field") + XCTAssertEqual(proto3ForPresence.fields[3].name, "message_field") + XCTAssertEqual(proto3ForPresence.fields[4].name, "opt_str_field") + XCTAssertEqual(proto3ForPresence.fields[5].name, "opt_int32_field") + XCTAssertEqual(proto3ForPresence.fields[6].name, "opt_enum_field") + XCTAssertEqual(proto3ForPresence.fields[7].name, "opt_message_field") + XCTAssertEqual(proto3ForPresence.fields[8].name, "repeat_str_field") + XCTAssertEqual(proto3ForPresence.fields[9].name, "repeat_int32_field") + XCTAssertEqual(proto3ForPresence.fields[10].name, "repeat_enum_field") + XCTAssertEqual(proto3ForPresence.fields[11].name, "repeat_message_field") + XCTAssertEqual(proto3ForPresence.fields[12].name, "oneof_str_field") + XCTAssertEqual(proto3ForPresence.fields[13].name, "oneof_int32_field") + XCTAssertEqual(proto3ForPresence.fields[14].name, "oneof_enum_field") + XCTAssertEqual(proto3ForPresence.fields[15].name, "oneof_message_field") + + XCTAssertFalse(proto3ForPresence.fields[0]._hasOptionalKeyword) + XCTAssertFalse(proto3ForPresence.fields[1]._hasOptionalKeyword) + XCTAssertFalse(proto3ForPresence.fields[2]._hasOptionalKeyword) + XCTAssertFalse(proto3ForPresence.fields[3]._hasOptionalKeyword) + XCTAssertTrue(proto3ForPresence.fields[4]._hasOptionalKeyword) + XCTAssertTrue(proto3ForPresence.fields[5]._hasOptionalKeyword) + XCTAssertTrue(proto3ForPresence.fields[6]._hasOptionalKeyword) + XCTAssertTrue(proto3ForPresence.fields[7]._hasOptionalKeyword) + XCTAssertFalse(proto3ForPresence.fields[8]._hasOptionalKeyword) + XCTAssertFalse(proto3ForPresence.fields[9]._hasOptionalKeyword) + XCTAssertFalse(proto3ForPresence.fields[10]._hasOptionalKeyword) + XCTAssertFalse(proto3ForPresence.fields[11]._hasOptionalKeyword) + XCTAssertFalse(proto3ForPresence.fields[12]._hasOptionalKeyword) + XCTAssertFalse(proto3ForPresence.fields[13]._hasOptionalKeyword) + XCTAssertFalse(proto3ForPresence.fields[14]._hasOptionalKeyword) + XCTAssertFalse(proto3ForPresence.fields[15]._hasOptionalKeyword) + + XCTAssertFalse(proto3ForPresence.fields[0].hasPresence) + XCTAssertFalse(proto3ForPresence.fields[1].hasPresence) + XCTAssertFalse(proto3ForPresence.fields[2].hasPresence) + XCTAssertTrue(proto3ForPresence.fields[3].hasPresence) + XCTAssertTrue(proto3ForPresence.fields[4].hasPresence) + XCTAssertTrue(proto3ForPresence.fields[5].hasPresence) + XCTAssertTrue(proto3ForPresence.fields[6].hasPresence) + XCTAssertTrue(proto3ForPresence.fields[7].hasPresence) + XCTAssertFalse(proto3ForPresence.fields[8].hasPresence) + XCTAssertFalse(proto3ForPresence.fields[9].hasPresence) + XCTAssertFalse(proto3ForPresence.fields[10].hasPresence) + XCTAssertFalse(proto3ForPresence.fields[11].hasPresence) + XCTAssertTrue(proto3ForPresence.fields[12].hasPresence) + XCTAssertTrue(proto3ForPresence.fields[13].hasPresence) + XCTAssertTrue(proto3ForPresence.fields[14].hasPresence) + XCTAssertTrue(proto3ForPresence.fields[15].hasPresence) + + // Synthetic oneof in proto3 syntax for the 'optional' fields, so + // the lists should NOTE be the same, `realOneofs` one should be a + // prefix of `oneofs`. + XCTAssertTrue(proto3ForPresence.oneofs.count > proto3ForPresence.realOneofs.count) + for (i, o) in proto2ForPresence.realOneofs.enumerated() { + XCTAssert(o === proto2ForPresence.oneofs[i]) + } } - } - - func testExtensions() throws { - // Extensions are a little different in how they have extensionScope and - // containingType, so they are split out to be a clear test of their behaviors. - - let fileSet = try Google_Protobuf_FileDescriptorSet(serializedData: fileDescriptorSetData) - - let descriptorSet = DescriptorSet(proto: fileSet) - - let googleProtobufFieldOptions = descriptorSet.lookupDescriptor(protoName: ".google.protobuf.FieldOptions") - let googleProtobufMessageOptions = descriptorSet.lookupDescriptor(protoName: ".google.protobuf.MessageOptions") - - let descriptorTestFile = descriptorSet.files[2] - - let topLevelExt = descriptorTestFile.extensions[0] - XCTAssertNil(topLevelExt.extensionScope) - XCTAssertTrue(topLevelExt.containingType === googleProtobufFieldOptions) - - let extScoper = descriptorSet.lookupDescriptor(protoName: ".swift_descriptor_test.ScoperForExt") - let nestedExt1 = descriptorTestFile.messages[3].extensions[0] - let nestedExt2 = descriptorTestFile.messages[3].extensions[1] - XCTAssertTrue(nestedExt1.extensionScope === extScoper) - XCTAssertTrue(nestedExt1.containingType === googleProtobufMessageOptions) - XCTAssertTrue(nestedExt2.extensionScope === extScoper) - XCTAssertTrue(nestedExt2.containingType === googleProtobufMessageOptions) - - XCTAssertTrue(nestedExt1.enumType === descriptorTestFile.enums[0]) - XCTAssertTrue(nestedExt2.messageType === descriptorTestFile.messages[1]) - - XCTAssertTrue(topLevelExt.file === descriptorTestFile) - XCTAssertTrue(nestedExt1.file === descriptorTestFile) - XCTAssertTrue(nestedExt2.file === descriptorTestFile) - } - - func testExtensionRanges() throws { - let fileSet = try Google_Protobuf_FileDescriptorSet(serializedData: fileDescriptorSetData) - - let descriptorSet = DescriptorSet(proto: fileSet) - - let msgDescriptor = descriptorSet.lookupDescriptor(protoName: ".swift_descriptor_test.MsgExtensionRangeOrdering") - // Quick check of what should be in the proto file - XCTAssertEqual(msgDescriptor.extensionRanges.count, 9) - XCTAssertEqual(msgDescriptor.extensionRanges[0].start, 1) - XCTAssertEqual(msgDescriptor.extensionRanges[1].start, 3) - XCTAssertEqual(msgDescriptor.extensionRanges[2].start, 2) - XCTAssertEqual(msgDescriptor.extensionRanges[3].start, 4) - XCTAssertEqual(msgDescriptor.extensionRanges[4].start, 7) - XCTAssertEqual(msgDescriptor.extensionRanges[5].start, 9) - XCTAssertEqual(msgDescriptor.extensionRanges[6].start, 100) - XCTAssertEqual(msgDescriptor.extensionRanges[7].start, 126) - XCTAssertEqual(msgDescriptor.extensionRanges[8].start, 111) - - // Check sorting/merging - XCTAssertEqual(msgDescriptor.normalizedExtensionRanges.count, 5) - XCTAssertEqual(msgDescriptor.normalizedExtensionRanges[0].start, 1) - XCTAssertEqual(msgDescriptor.normalizedExtensionRanges[0].end, 5) - XCTAssertEqual(msgDescriptor.normalizedExtensionRanges[1].start, 7) - XCTAssertEqual(msgDescriptor.normalizedExtensionRanges[1].end, 8) - XCTAssertEqual(msgDescriptor.normalizedExtensionRanges[2].start, 9) - XCTAssertEqual(msgDescriptor.normalizedExtensionRanges[2].end, 10) - XCTAssertEqual(msgDescriptor.normalizedExtensionRanges[3].start, 100) - XCTAssertEqual(msgDescriptor.normalizedExtensionRanges[3].end, 121) - XCTAssertEqual(msgDescriptor.normalizedExtensionRanges[4].start, 126) - XCTAssertEqual(msgDescriptor.normalizedExtensionRanges[4].end, 131) - - - // Check the "ambitious" merging. - XCTAssertEqual(msgDescriptor.ambitiousExtensionRanges.count, 1) - XCTAssertEqual(msgDescriptor.ambitiousExtensionRanges[0].start, 1) - XCTAssertEqual(msgDescriptor.ambitiousExtensionRanges[0].end, 131) - - let msgDescriptor2 = descriptorSet.lookupDescriptor(protoName: ".swift_descriptor_test.MsgExtensionRangeOrderingWithFields") - // Quick check of what should be in the proto file - XCTAssertEqual(msgDescriptor2.extensionRanges.count, 9) - XCTAssertEqual(msgDescriptor2.extensionRanges[0].start, 1) - XCTAssertEqual(msgDescriptor2.extensionRanges[1].start, 3) - XCTAssertEqual(msgDescriptor2.extensionRanges[2].start, 2) - XCTAssertEqual(msgDescriptor2.extensionRanges[3].start, 4) - XCTAssertEqual(msgDescriptor2.extensionRanges[4].start, 7) - XCTAssertEqual(msgDescriptor2.extensionRanges[5].start, 9) - XCTAssertEqual(msgDescriptor2.extensionRanges[6].start, 100) - XCTAssertEqual(msgDescriptor2.extensionRanges[7].start, 126) - XCTAssertEqual(msgDescriptor2.extensionRanges[8].start, 111) - - // Check sorting/merging - XCTAssertEqual(msgDescriptor2.normalizedExtensionRanges.count, 5) - XCTAssertEqual(msgDescriptor2.normalizedExtensionRanges[0].start, 1) - XCTAssertEqual(msgDescriptor2.normalizedExtensionRanges[0].end, 5) - XCTAssertEqual(msgDescriptor2.normalizedExtensionRanges[1].start, 7) - XCTAssertEqual(msgDescriptor2.normalizedExtensionRanges[1].end, 8) - XCTAssertEqual(msgDescriptor2.normalizedExtensionRanges[2].start, 9) - XCTAssertEqual(msgDescriptor2.normalizedExtensionRanges[2].end, 10) - XCTAssertEqual(msgDescriptor2.normalizedExtensionRanges[3].start, 100) - XCTAssertEqual(msgDescriptor2.normalizedExtensionRanges[3].end, 121) - XCTAssertEqual(msgDescriptor2.normalizedExtensionRanges[4].start, 126) - XCTAssertEqual(msgDescriptor2.normalizedExtensionRanges[4].end, 131) - - - // Check the "ambitious" merging. - XCTAssertEqual(msgDescriptor2.ambitiousExtensionRanges.count, 3) - XCTAssertEqual(msgDescriptor2.ambitiousExtensionRanges[0].start, 1) - XCTAssertEqual(msgDescriptor2.ambitiousExtensionRanges[0].end, 5) - XCTAssertEqual(msgDescriptor2.ambitiousExtensionRanges[1].start, 7) - XCTAssertEqual(msgDescriptor2.ambitiousExtensionRanges[1].end, 121) - XCTAssertEqual(msgDescriptor2.ambitiousExtensionRanges[2].start, 126) - XCTAssertEqual(msgDescriptor2.ambitiousExtensionRanges[2].end, 131) - - let msgDescriptor3 = descriptorSet.lookupDescriptor(protoName: ".swift_descriptor_test.MsgExtensionRangeOrderingNoMerging") - // Quick check of what should be in the proto file - XCTAssertEqual(msgDescriptor3.extensionRanges.count, 3) - XCTAssertEqual(msgDescriptor3.extensionRanges[0].start, 3) - XCTAssertEqual(msgDescriptor3.extensionRanges[1].start, 7) - XCTAssertEqual(msgDescriptor3.extensionRanges[2].start, 16) - - // Check sorting/merging - XCTAssertEqual(msgDescriptor3.normalizedExtensionRanges.count, 3) - XCTAssertEqual(msgDescriptor3.normalizedExtensionRanges[0].start, 3) - XCTAssertEqual(msgDescriptor3.normalizedExtensionRanges[0].end, 6) - XCTAssertEqual(msgDescriptor3.normalizedExtensionRanges[1].start, 7) - XCTAssertEqual(msgDescriptor3.normalizedExtensionRanges[1].end, 13) - XCTAssertEqual(msgDescriptor3.normalizedExtensionRanges[2].start, 16) - XCTAssertEqual(msgDescriptor3.normalizedExtensionRanges[2].end, 21) - - // Check the "ambitious" merging. - XCTAssertEqual(msgDescriptor3.ambitiousExtensionRanges.count, 3) - XCTAssertEqual(msgDescriptor3.ambitiousExtensionRanges[0].start, 3) - XCTAssertEqual(msgDescriptor3.ambitiousExtensionRanges[0].end, 6) - XCTAssertEqual(msgDescriptor3.ambitiousExtensionRanges[1].start, 7) - XCTAssertEqual(msgDescriptor3.ambitiousExtensionRanges[1].end, 13) - XCTAssertEqual(msgDescriptor3.ambitiousExtensionRanges[2].start, 16) - XCTAssertEqual(msgDescriptor3.ambitiousExtensionRanges[2].end, 21) - } + func testExtensions() throws { + // Extensions are a little different in how they have extensionScope and + // containingType, so they are split out to be a clear test of their behaviors. + + let fileSet = try Google_Protobuf_FileDescriptorSet(serializedBytes: fileDescriptorSetBytes) + + let descriptorSet = DescriptorSet(proto: fileSet) + + let extendOne = descriptorSet.descriptor(named: "swift_descriptor_test.import.ExtendableOne")! + let extendTwo = descriptorSet.descriptor(named: "swift_descriptor_test.import.ExtendableOne.ExtendableTwo")! + + let descriptorTestFile = descriptorSet.files[1] + + let topLevelExt = descriptorTestFile.extensions[0] + XCTAssertNil(topLevelExt.extensionScope) + XCTAssertTrue(topLevelExt.containingType === extendOne) + + let extScoper = descriptorSet.descriptor(named: "swift_descriptor_test.ScoperForExt")! + let nestedExt1 = descriptorTestFile.messages[3].extensions[0] + let nestedExt2 = descriptorTestFile.messages[3].extensions[1] + XCTAssertTrue(nestedExt1.extensionScope === extScoper) + XCTAssertTrue(nestedExt1.containingType === extendTwo) + XCTAssertTrue(nestedExt2.extensionScope === extScoper) + XCTAssertTrue(nestedExt2.containingType === extendTwo) + + XCTAssertTrue(nestedExt1.enumType === descriptorTestFile.enums[0]) + XCTAssertTrue(nestedExt2.messageType === descriptorTestFile.messages[1]) + + XCTAssertTrue(topLevelExt.file === descriptorTestFile) + XCTAssertTrue(nestedExt1.file === descriptorTestFile) + XCTAssertTrue(nestedExt2.file === descriptorTestFile) + } + + func testDelimited() throws { + let fileSet = try Google_Protobuf_FileDescriptorSet(serializedBytes: fileDescriptorSetBytes) + let descriptorSet = DescriptorSet(proto: fileSet) + + let msg = try XCTUnwrap( + descriptorSet.descriptor(named: SwiftDescriptorTest_EditionsMessageForDelimited.protoMessageName) + ) + + XCTAssertEqual(try XCTUnwrap(msg.field(named: "scalar_field")).type, .int32) + XCTAssertEqual(try XCTUnwrap(msg.field(named: "map_field")).type, .message) + XCTAssertEqual(try XCTUnwrap(msg.field(named: "message_map_field")).type, .message) + XCTAssertEqual(try XCTUnwrap(msg.field(named: "delimited_field")).type, .group) + XCTAssertEqual(try XCTUnwrap(msg.field(named: "length_prefixed_field")).type, .message) + } + + func testIsGroupLike_GroupLikeDelimited() throws { + let fileSet = try Google_Protobuf_FileDescriptorSet(serializedBytes: fileDescriptorSetBytes) + let descriptorSet = DescriptorSet(proto: fileSet) + + let msg = try XCTUnwrap(descriptorSet.descriptor(named: EditionsUnittest_TestDelimited.protoMessageName)) + let file = try XCTUnwrap(msg.file) + + XCTAssertTrue(try XCTUnwrap(msg.field(named: "grouplike")).isGroupLike) + XCTAssertTrue(try XCTUnwrap(file.extensionField(named: "grouplikefilescope")).isGroupLike) + } + + func testIsGroupLike_GroupLikeNotDelimited() throws { + let fileSet = try Google_Protobuf_FileDescriptorSet(serializedBytes: fileDescriptorSetBytes) + let descriptorSet = DescriptorSet(proto: fileSet) + + let msg = try XCTUnwrap(descriptorSet.descriptor(named: EditionsUnittest_TestDelimited.protoMessageName)) + let file = try XCTUnwrap(msg.file) + + XCTAssertFalse(try XCTUnwrap(msg.field(named: "lengthprefixed")).isGroupLike) + XCTAssertFalse(try XCTUnwrap(file.extensionField(named: "lengthprefixed")).isGroupLike) + } + + func testIsGroupLike_GroupLikeMismatchedName() throws { + let fileSet = try Google_Protobuf_FileDescriptorSet(serializedBytes: fileDescriptorSetBytes) + let descriptorSet = DescriptorSet(proto: fileSet) + + let msg = try XCTUnwrap(descriptorSet.descriptor(named: EditionsUnittest_TestDelimited.protoMessageName)) + let file = try XCTUnwrap(msg.file) + + XCTAssertFalse(try XCTUnwrap(msg.field(named: "notgrouplike")).isGroupLike) + XCTAssertFalse(try XCTUnwrap(file.extensionField(named: "not_group_like_scope")).isGroupLike) + } + + func testIsGroupLike_GroupLikeMismatchedScope() throws { + let fileSet = try Google_Protobuf_FileDescriptorSet(serializedBytes: fileDescriptorSetBytes) + let descriptorSet = DescriptorSet(proto: fileSet) + + let msg = try XCTUnwrap(descriptorSet.descriptor(named: EditionsUnittest_TestDelimited.protoMessageName)) + let file = try XCTUnwrap(msg.file) + + XCTAssertFalse(try XCTUnwrap(msg.field(named: "notgrouplikescope")).isGroupLike) + XCTAssertFalse(try XCTUnwrap(file.extensionField(named: "grouplike")).isGroupLike) + } + + func testIsGroupLike_GroupLikeMismatchedFile() throws { + let fileSet = try Google_Protobuf_FileDescriptorSet(serializedBytes: fileDescriptorSetBytes) + let descriptorSet = DescriptorSet(proto: fileSet) + + let msg = try XCTUnwrap(descriptorSet.descriptor(named: EditionsUnittest_TestDelimited.protoMessageName)) + let file = try XCTUnwrap(msg.file) + + XCTAssertFalse(try XCTUnwrap(msg.field(named: "messageimport")).isGroupLike) + XCTAssertFalse(try XCTUnwrap(file.extensionField(named: "messageimport")).isGroupLike) + } + + func testExtractProto_Options() throws { + let fileSet = try Google_Protobuf_FileDescriptorSet(serializedBytes: fileDescriptorSetBytes) + let descriptorSet = DescriptorSet(proto: fileSet) + + let fileDescriptor = descriptorSet.fileDescriptor(named: "pluginlib_descriptor_test.proto")! + + // NOTE: There should be a full tests for ExtractProto that validates all the sub descriptor + // protos. But for now, given the function's implementation, just test that the options are + // honored correctly. + + // Default: + // - includeSourceCodeInfo = false + // - headerOnly = false + do { + let extract = fileDescriptor.extractProto() + XCTAssertFalse(extract.hasSourceCodeInfo, "Included SourceCodeInfo?") + XCTAssertFalse(extract.messageType.isEmpty, "Missing messages?") + XCTAssertFalse(extract.enumType.isEmpty, "Missing enums?") + XCTAssertFalse(extract.extension.isEmpty, "Missing extensions?") + XCTAssertFalse(extract.service.isEmpty, "Missing services?") + } + + var options = ExtractProtoOptions() + options.includeSourceCodeInfo = true + // - includeSourceCodeInfo = true + // - headerOnly = false + do { + let extract = fileDescriptor.extractProto(options: options) + XCTAssertTrue(extract.hasSourceCodeInfo, "Missing SourceCodeInfo?") + XCTAssertFalse(extract.messageType.isEmpty, "Missing messages?") + XCTAssertFalse(extract.enumType.isEmpty, "Missing enums?") + XCTAssertFalse(extract.extension.isEmpty, "Missing extensions?") + XCTAssertFalse(extract.service.isEmpty, "Missing services?") + } + + options.headerOnly = true + // - includeSourceCodeInfo = true + // - headerOnly = true + do { + let extract = fileDescriptor.extractProto(options: options) + XCTAssertTrue(extract.hasSourceCodeInfo, "Missing SourceCodeInfo?") + XCTAssertTrue(extract.messageType.isEmpty, "Incuded messages?") + XCTAssertTrue(extract.enumType.isEmpty, "Incuded enums?") + XCTAssertTrue(extract.extension.isEmpty, "Missing extensions?") + XCTAssertTrue(extract.service.isEmpty, "Missing services?") + } + + options.includeSourceCodeInfo = false + // - includeSourceCodeInfo = false + // - headerOnly = false + do { + let extract = fileDescriptor.extractProto(options: options) + XCTAssertFalse(extract.hasSourceCodeInfo, "Included SourceCodeInfo?") + XCTAssertTrue(extract.messageType.isEmpty, "Incuded messages?") + XCTAssertTrue(extract.enumType.isEmpty, "Incuded enums?") + XCTAssertTrue(extract.extension.isEmpty, "Missing extensions?") + XCTAssertTrue(extract.service.isEmpty, "Missing services?") + } + } } diff --git a/Tests/SwiftProtobufPluginLibraryTests/Test_Descriptor_FeatureResolution.swift b/Tests/SwiftProtobufPluginLibraryTests/Test_Descriptor_FeatureResolution.swift new file mode 100644 index 000000000..af80f7d4c --- /dev/null +++ b/Tests/SwiftProtobufPluginLibraryTests/Test_Descriptor_FeatureResolution.swift @@ -0,0 +1,735 @@ +// Tests/SwiftProtobufPluginLibraryTests/Test_Descriptor.swift - Test Descriptor.swift +// +// Copyright (c) 2014 - 2024 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +import SwiftProtobuf +import SwiftProtobufPluginLibrary +import XCTest + +private let testFeatureSetDefaults = + try! Google_Protobuf_FeatureSetDefaults( + serializedBytes: testFeatureSetDefaultBytes, + extensions: SwiftFeatureTest_TestFeatures_Extensions + ) + +private struct TestContext { + let descriptorSet: DescriptorSet + var file: FileDescriptor { descriptorSet.files.first! } + + init(_ descriptorTextFormat: String) { + let file = try! Google_Protobuf_FileDescriptorProto( + textFormatString: descriptorTextFormat, + extensions: SwiftFeatureTest_TestFeatures_Extensions + ) + descriptorSet = DescriptorSet( + protos: [file], + featureSetDefaults: testFeatureSetDefaults, + featureExtensions: [SwiftFeatureTest_Extensions_test] + ) + } +} + +final class Test_Descriptor_FeatureResolution: XCTestCase { + + func testFileLevel_Defaults() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + """ + ) + + let features = context.file.features + XCTAssertTrue(features.hasSwiftFeatureTest_test) + XCTAssertEqual(features.SwiftFeatureTest_test.feature1, .value1) + } + + func testFileLevel_Override() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + options { + features { + [swift_feature_test.test] { feature1: ENUM_FEATURE_VALUE2 } + } + } + """ + ) + + let features = context.file.features + XCTAssertTrue(features.hasSwiftFeatureTest_test) + XCTAssertEqual(features.SwiftFeatureTest_test.feature1, .value2) // File override + } + + func testMessageLevel_Defaults() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + message_type { + name: "Top" + nested_type { + name: "Nested" + } + } + """ + ) + + let topFeatures = context.file.messages.first!.features + XCTAssertTrue(topFeatures.hasSwiftFeatureTest_test) + XCTAssertEqual(topFeatures.SwiftFeatureTest_test.feature1, .value1) + XCTAssertEqual(topFeatures.SwiftFeatureTest_test.feature2, .value1) + let nestedFeatures = context.file.messages.first!.messages.first!.features + XCTAssertTrue(nestedFeatures.hasSwiftFeatureTest_test) + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature1, .value1) + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature2, .value1) + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature3, .value1) + } + + func testMessageLevel_Override() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + options { + features { + [swift_feature_test.test] { feature1: ENUM_FEATURE_VALUE2 } + } + } + message_type { + name: "Top" + options { + features { + [swift_feature_test.test] { feature2: ENUM_FEATURE_VALUE3 } + } + } + nested_type { + name: "Nested" + options { + features { + [swift_feature_test.test] { feature3: ENUM_FEATURE_VALUE4 } + } + } + } + } + """ + ) + + let topFeatures = context.file.messages.first!.features + XCTAssertTrue(topFeatures.hasSwiftFeatureTest_test) + XCTAssertEqual(topFeatures.SwiftFeatureTest_test.feature1, .value2) // File override + XCTAssertEqual(topFeatures.SwiftFeatureTest_test.feature2, .value3) // Top override + let nestedFeatures = context.file.messages.first!.messages.first!.features + XCTAssertTrue(nestedFeatures.hasSwiftFeatureTest_test) + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature1, .value2) // File override + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature2, .value3) // Top override + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature3, .value4) // Nested override + } + + func testEnumLevel_Defaults() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + enum_type { + name: "Top" + value { name: "TOP_UNKNOWN", number: 0 } + value { name: "TOP_ONE", number: 1 } + } + message_type { + name: "MyMessage" + enum_type { + name: "Nested" + value { name: "NESTED_UNKNOWN", number: 0 } + value { name: "NESTED_ONE", number: 1 } + } + } + """ + ) + + let topFeatures = context.file.enums.first!.features + XCTAssertTrue(topFeatures.hasSwiftFeatureTest_test) + XCTAssertEqual(topFeatures.SwiftFeatureTest_test.feature1, .value1) + XCTAssertEqual(topFeatures.SwiftFeatureTest_test.feature2, .value1) + let nestedFeatures = context.file.messages.first!.enums.first!.features + XCTAssertTrue(nestedFeatures.hasSwiftFeatureTest_test) + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature1, .value1) + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature2, .value1) + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature3, .value1) + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature4, .value1) + } + + func testEnumLevel_Override() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + options { + features { + [swift_feature_test.test] { feature1: ENUM_FEATURE_VALUE2 } + } + } + enum_type { + name: "Top" + options { + features { + [swift_feature_test.test] { feature2: ENUM_FEATURE_VALUE3 } + } + } + value { name: "TOP_UNKNOWN", number: 0 } + value { name: "TOP_ONE", number: 1 } + } + message_type { + name: "MyMessage" + options { + features { + [swift_feature_test.test] { feature3: ENUM_FEATURE_VALUE4 } + } + } + enum_type { + name: "Nested" + options { + features { + [swift_feature_test.test] { feature4: ENUM_FEATURE_VALUE5 } + } + } + value { name: "NESTED_UNKNOWN", number: 0 } + value { name: "NESTED_ONE", number: 1 } + } + } + """ + ) + + let topFeatures = context.file.enums.first!.features + XCTAssertTrue(topFeatures.hasSwiftFeatureTest_test) + XCTAssertEqual(topFeatures.SwiftFeatureTest_test.feature1, .value2) // File override + XCTAssertEqual(topFeatures.SwiftFeatureTest_test.feature2, .value3) // "Top" Enum override + let nestedFeatures = context.file.messages.first!.enums.first!.features + XCTAssertTrue(nestedFeatures.hasSwiftFeatureTest_test) + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature1, .value2) // File override + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature2, .value1) // default ("Top" Enum override) + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature3, .value4) // Message override + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature4, .value5) // "Nested" Enum override + } + + func testEnumValueLevel_Defaults() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + enum_type { + name: "Top" + value { name: "TOP_UNKNOWN", number: 0 } + value { name: "TOP_ONE", number: 1 } + } + """ + ) + + let features = context.file.enums.first!.values.first!.features + XCTAssertTrue(features.hasSwiftFeatureTest_test) + XCTAssertEqual(features.SwiftFeatureTest_test.feature1, .value1) + XCTAssertEqual(features.SwiftFeatureTest_test.feature2, .value1) + XCTAssertEqual(features.SwiftFeatureTest_test.feature3, .value1) + } + + func testEnumValueLevel_Override() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + options { + features { + [swift_feature_test.test] { feature1: ENUM_FEATURE_VALUE2 } + } + } + enum_type { + name: "MyEnum" + options { + features { + [swift_feature_test.test] { feature2: ENUM_FEATURE_VALUE3 } + } + } + value { + name: "TOP_UNKNOWN" + options { + features { + [swift_feature_test.test] { feature3: ENUM_FEATURE_VALUE4 } + } + } + number: 0 + } + value { name: "TOP_ONE", number: 1 } + } + """ + ) + + let features = context.file.enums.first!.values.first!.features + XCTAssertTrue(features.hasSwiftFeatureTest_test) + XCTAssertEqual(features.SwiftFeatureTest_test.feature1, .value2) // File override + XCTAssertEqual(features.SwiftFeatureTest_test.feature2, .value3) // Enum override + XCTAssertEqual(features.SwiftFeatureTest_test.feature3, .value4) // EnumValue override + } + + func testExtensionRangeLevel_Defaults() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + message_type { + name: "MyMessage" + extension_range { start: 1, end: 100 } + } + """ + ) + + let features = context.file.messages.first!.messageExtensionRanges.first!.features + XCTAssertTrue(features.hasSwiftFeatureTest_test) + XCTAssertEqual(features.SwiftFeatureTest_test.feature1, .value1) + XCTAssertEqual(features.SwiftFeatureTest_test.feature2, .value1) + XCTAssertEqual(features.SwiftFeatureTest_test.feature3, .value1) + } + + func testExtensionRangeLevel_Override() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + options { + features { + [swift_feature_test.test] { feature1: ENUM_FEATURE_VALUE2 } + } + } + message_type { + name: "MyMessage" + options { + features { + [swift_feature_test.test] { feature2: ENUM_FEATURE_VALUE3 } + } + } + extension_range { + start: 1 + end: 100 + options { + features { + [swift_feature_test.test] { feature3: ENUM_FEATURE_VALUE4 } + } + } + } + } + """ + ) + + let features = context.file.messages.first!.messageExtensionRanges.first!.features + XCTAssertTrue(features.hasSwiftFeatureTest_test) + XCTAssertEqual(features.SwiftFeatureTest_test.feature1, .value2) // File override + XCTAssertEqual(features.SwiftFeatureTest_test.feature2, .value3) // Message override + XCTAssertEqual(features.SwiftFeatureTest_test.feature3, .value4) // ExtensionRange override + } + + func testExtensionLevel_Defaults() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + message_type { + name: "MyMessage" + extension_range { start: 1, end: 100 } + extension { + name: "nested" + json_name: "nested" + number: 2 + type: TYPE_STRING + extendee: ".MyMessage" + } + } + extension { + name: "top" + json_name: "top" + number: 1 + type: TYPE_STRING + extendee: ".MyMessage" + } + """ + ) + + let topFeatures = context.file.extensions.first!.features + XCTAssertTrue(topFeatures.hasSwiftFeatureTest_test) + XCTAssertEqual(topFeatures.SwiftFeatureTest_test.feature1, .value1) + XCTAssertEqual(topFeatures.SwiftFeatureTest_test.feature2, .value1) + let nestedFeatures = context.file.messages.first!.extensions.first!.features + XCTAssertTrue(nestedFeatures.hasSwiftFeatureTest_test) + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature1, .value1) + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature2, .value1) + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature3, .value1) + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature4, .value1) + } + + func testExtensionLevel_Override() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + options { + features { + [swift_feature_test.test] { feature1: ENUM_FEATURE_VALUE2 } + } + } + message_type { + name: "MyMessage" + options { + features { + [swift_feature_test.test] { feature3: ENUM_FEATURE_VALUE4 } + } + } + extension_range { start: 1, end: 100 } + extension { + name: "nested" + json_name: "nested" + number: 2 + type: TYPE_STRING + extendee: ".MyMessage" + options { + features { + [swift_feature_test.test] { feature4: ENUM_FEATURE_VALUE5 } + } + } + } + } + extension { + name: "top" + json_name: "top" + number: 1 + type: TYPE_STRING + extendee: ".MyMessage" + options { + features { + [swift_feature_test.test] { feature2: ENUM_FEATURE_VALUE3 } + } + } + } + """ + ) + + let topFeatures = context.file.extensions.first!.features + XCTAssertTrue(topFeatures.hasSwiftFeatureTest_test) + XCTAssertEqual(topFeatures.SwiftFeatureTest_test.feature1, .value2) // File override + XCTAssertEqual(topFeatures.SwiftFeatureTest_test.feature2, .value3) // "top" Extension override + let nestedFeatures = context.file.messages.first!.extensions.first!.features + XCTAssertTrue(nestedFeatures.hasSwiftFeatureTest_test) + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature1, .value2) // File override + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature2, .value1) // default ("top" Extension override) + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature3, .value4) // Message override + XCTAssertEqual(nestedFeatures.SwiftFeatureTest_test.feature4, .value5) // "nested" Extension override + } + + func testMessageFieldLevel_Defaults() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + message_type { + name: "MyMessage" + field { + name: "field" + json_name: "field" + number: 1 + type: TYPE_STRING + } + } + """ + ) + + let features = context.file.messages.first!.fields.first!.features + XCTAssertTrue(features.hasSwiftFeatureTest_test) + XCTAssertEqual(features.SwiftFeatureTest_test.feature1, .value1) + XCTAssertEqual(features.SwiftFeatureTest_test.feature2, .value1) + XCTAssertEqual(features.SwiftFeatureTest_test.feature3, .value1) + } + + func testMessageFieldLevel_Override() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + options { + features { + [swift_feature_test.test] { feature1: ENUM_FEATURE_VALUE2 } + } + } + message_type { + name: "MyMessage" + options { + features { + [swift_feature_test.test] { feature2: ENUM_FEATURE_VALUE3 } + } + } + field { + name: "field" + json_name: "field" + number: 1 + type: TYPE_STRING + options { + features { + [swift_feature_test.test] { feature3: ENUM_FEATURE_VALUE4 } + } + } + } + } + """ + ) + + let features = context.file.messages.first!.fields.first!.features + XCTAssertTrue(features.hasSwiftFeatureTest_test) + XCTAssertEqual(features.SwiftFeatureTest_test.feature1, .value2) // File override + XCTAssertEqual(features.SwiftFeatureTest_test.feature2, .value3) // Message override + XCTAssertEqual(features.SwiftFeatureTest_test.feature3, .value4) // Field override + } + + func testMessageOneofFieldLevel_Defaults() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + message_type { + name: "MyMessage" + oneof_decl { name: "my_oneof" } + field { + name: "oneof_field" + json_name: "oneof_field" + number: 1 + type: TYPE_STRING + oneof_index: 0 + } + field { + name: "not_oneof_field" + json_name: "not_oneof_field" + number: 2 + type: TYPE_STRING + } + } + """ + ) + + let oneof = context.file.messages.first!.realOneofs.first! + XCTAssertEqual(oneof.name, "my_oneof") + let oneofFeatures = oneof.features + XCTAssertTrue(oneofFeatures.hasSwiftFeatureTest_test) + XCTAssertEqual(oneofFeatures.SwiftFeatureTest_test.feature1, .value1) + XCTAssertEqual(oneofFeatures.SwiftFeatureTest_test.feature2, .value1) + XCTAssertEqual(oneofFeatures.SwiftFeatureTest_test.feature3, .value1) + let oneofField = context.file.messages.first!.fields.first! + XCTAssertEqual(oneofField.name, "oneof_field") + let oneofFieldFeatures = oneofField.features + XCTAssertTrue(oneofFieldFeatures.hasSwiftFeatureTest_test) + XCTAssertEqual(oneofFieldFeatures.SwiftFeatureTest_test.feature1, .value1) + XCTAssertEqual(oneofFieldFeatures.SwiftFeatureTest_test.feature2, .value1) + XCTAssertEqual(oneofFieldFeatures.SwiftFeatureTest_test.feature3, .value1) + XCTAssertEqual(oneofFieldFeatures.SwiftFeatureTest_test.feature4, .value1) + XCTAssertEqual(oneofFieldFeatures.SwiftFeatureTest_test.feature5, .value1) + let field = context.file.messages.first!.fields[1] + XCTAssertEqual(field.name, "not_oneof_field") + let fieldFeatures = field.features + XCTAssertTrue(fieldFeatures.hasSwiftFeatureTest_test) + XCTAssertEqual(fieldFeatures.SwiftFeatureTest_test.feature1, .value1) + XCTAssertEqual(fieldFeatures.SwiftFeatureTest_test.feature2, .value1) + XCTAssertEqual(fieldFeatures.SwiftFeatureTest_test.feature3, .value1) + XCTAssertEqual(fieldFeatures.SwiftFeatureTest_test.feature4, .value1) + XCTAssertEqual(fieldFeatures.SwiftFeatureTest_test.feature5, .value1) + } + + func testMessageOneofFieldLevel_Override() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + options { + features { + [swift_feature_test.test] { feature1: ENUM_FEATURE_VALUE2 } + } + } + message_type { + name: "MyMessage" + options { + features { + [swift_feature_test.test] { feature2: ENUM_FEATURE_VALUE3 } + } + } + oneof_decl { + name: "my_oneof" + options { + features { + [swift_feature_test.test] { feature3: ENUM_FEATURE_VALUE4 } + } + } + } + field { + name: "oneof_field" + json_name: "oneof_field" + number: 1 + type: TYPE_STRING + oneof_index: 0 + options { + features { + [swift_feature_test.test] { feature4: ENUM_FEATURE_VALUE5 } + } + } + } + field { + name: "not_oneof_field" + json_name: "not_oneof_field" + number: 2 + type: TYPE_STRING + options { + features { + [swift_feature_test.test] { feature5: ENUM_FEATURE_VALUE6 } + } + } + } + } + """ + ) + + let oneof = context.file.messages.first!.realOneofs.first! + XCTAssertEqual(oneof.name, "my_oneof") + let oneofFeatures = oneof.features + XCTAssertTrue(oneofFeatures.hasSwiftFeatureTest_test) + XCTAssertEqual(oneofFeatures.SwiftFeatureTest_test.feature1, .value2) // File override + XCTAssertEqual(oneofFeatures.SwiftFeatureTest_test.feature2, .value3) // Message override + XCTAssertEqual(oneofFeatures.SwiftFeatureTest_test.feature3, .value4) // Oneof override + let oneofField = context.file.messages.first!.fields.first! + XCTAssertEqual(oneofField.name, "oneof_field") + let oneofFieldFeatures = oneofField.features + XCTAssertTrue(oneofFieldFeatures.hasSwiftFeatureTest_test) + XCTAssertEqual(oneofFieldFeatures.SwiftFeatureTest_test.feature1, .value2) // File override + XCTAssertEqual(oneofFieldFeatures.SwiftFeatureTest_test.feature2, .value3) // Message override + XCTAssertEqual(oneofFieldFeatures.SwiftFeatureTest_test.feature3, .value4) // Oneof override + XCTAssertEqual(oneofFieldFeatures.SwiftFeatureTest_test.feature4, .value5) // "oneof_field" Field override + XCTAssertEqual( + oneofFieldFeatures.SwiftFeatureTest_test.feature5, // default ("not_oneof_field" Field override) + .value1 + ) + let field = context.file.messages.first!.fields[1] + XCTAssertEqual(field.name, "not_oneof_field") + let fieldFeatures = field.features + XCTAssertTrue(fieldFeatures.hasSwiftFeatureTest_test) + XCTAssertEqual(fieldFeatures.SwiftFeatureTest_test.feature1, .value2) // File override + XCTAssertEqual(fieldFeatures.SwiftFeatureTest_test.feature2, .value3) // Message override + XCTAssertEqual(fieldFeatures.SwiftFeatureTest_test.feature3, .value1) // default (Oneof override) + XCTAssertEqual( + fieldFeatures.SwiftFeatureTest_test.feature4, // default ("oneof_field" Field override) + .value1 + ) + XCTAssertEqual(fieldFeatures.SwiftFeatureTest_test.feature5, .value6) // "not_oneof_field" Field override + } + + func testServiceLevel_Defaults() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + service { + name: "MyService" + } + """ + ) + + let features = context.file.services.first!.features + XCTAssertTrue(features.hasSwiftFeatureTest_test) + XCTAssertEqual(features.SwiftFeatureTest_test.feature1, .value1) + XCTAssertEqual(features.SwiftFeatureTest_test.feature2, .value1) + } + + func testServiceLevel_Overrides() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + options { + features { + [swift_feature_test.test] { feature1: ENUM_FEATURE_VALUE3 } + } + } + service { + name: "MyService" + options { + features { + [swift_feature_test.test] { feature2: ENUM_FEATURE_VALUE4 } + } + } + } + """ + ) + + let features = context.file.services.first!.features + XCTAssertTrue(features.hasSwiftFeatureTest_test) + XCTAssertEqual(features.SwiftFeatureTest_test.feature1, .value3) // File override + XCTAssertEqual(features.SwiftFeatureTest_test.feature2, .value4) // Service override + } + + func testMethodLevel_Defaults() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + message_type { name: "empty" } + service { + name: "MyService" + method { name: "doSomething" input_type: ".empty" output_type: ".empty" } + } + """ + ) + + let features = context.file.services.first!.methods.first!.features + XCTAssertTrue(features.hasSwiftFeatureTest_test) + XCTAssertEqual(features.SwiftFeatureTest_test.feature1, .value1) + XCTAssertEqual(features.SwiftFeatureTest_test.feature2, .value1) + XCTAssertEqual(features.SwiftFeatureTest_test.feature3, .value1) + } + + func testMethodLevel_Overrides() throws { + let context = TestContext( + """ + name: "test.proto" + edition: EDITION_2023 + options { + features { + [swift_feature_test.test] { feature1: ENUM_FEATURE_VALUE3 } + } + } + message_type { name: "empty" } + service { + name: "MyService" + options { + features { + [swift_feature_test.test] { feature2: ENUM_FEATURE_VALUE4 } + } + } + method { + name: "doSomething" + input_type: ".empty" + output_type: ".empty" + options { + features { + [swift_feature_test.test] { feature3: ENUM_FEATURE_VALUE5 } + } + } + } + } + """ + ) + + let features = context.file.services.first!.methods.first!.features + XCTAssertTrue(features.hasSwiftFeatureTest_test) + XCTAssertEqual(features.SwiftFeatureTest_test.feature1, .value3) // File override + XCTAssertEqual(features.SwiftFeatureTest_test.feature2, .value4) // Service override + XCTAssertEqual(features.SwiftFeatureTest_test.feature3, .value5) // Method override + } + +} diff --git a/Tests/SwiftProtobufPluginLibraryTests/Test_FeatureResolver.swift b/Tests/SwiftProtobufPluginLibraryTests/Test_FeatureResolver.swift new file mode 100644 index 000000000..76dc00701 --- /dev/null +++ b/Tests/SwiftProtobufPluginLibraryTests/Test_FeatureResolver.swift @@ -0,0 +1,300 @@ +// Tests/SwiftProtobufPluginLibraryTests/Test_Descriptor.swift - Test Descriptor.swift +// +// Copyright (c) 2014 - 2024 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +import SwiftProtobuf +import SwiftProtobufPluginLibrary +import XCTest + +final class Test_FeatureResolver: XCTestCase { + + private func simpleResolver(extensions: [any AnyMessageExtension] = []) -> FeatureResolver { + let defaults = try! Google_Protobuf_FeatureSetDefaults( + textFormatString: """ + minimum_edition: EDITION_PROTO2 + maximum_edition: EDITION_2023 + defaults { edition: EDITION_2023 } + """ + ) + return try! FeatureResolver( + edition: .edition2023, + featureSetDefaults: defaults, + featureExtensions: extensions + ) + } + + func testInit_EditionBelowMin() { + let defaults = Google_Protobuf_FeatureSetDefaults.with { + $0.minimumEdition = .proto3 + $0.maximumEdition = .edition2023 + } + XCTAssertThrowsError(try FeatureResolver(edition: .proto2, featureSetDefaults: defaults)) { e in + XCTAssertEqual( + e as! FeatureResolver.Error, + FeatureResolver.Error.unsupported( + edition: .proto2, + supported: Google_Protobuf_Edition.proto3...Google_Protobuf_Edition.edition2023 + ) + ) + } + } + + func testInit_EditionAboveMax() { + let defaults = Google_Protobuf_FeatureSetDefaults.with { + $0.minimumEdition = .proto2 + $0.maximumEdition = .proto3 + } + XCTAssertThrowsError(try FeatureResolver(edition: .edition2023, featureSetDefaults: defaults)) { e in + XCTAssertEqual( + e as! FeatureResolver.Error, + FeatureResolver.Error.unsupported( + edition: .edition2023, + supported: Google_Protobuf_Edition.proto2...Google_Protobuf_Edition.proto3 + ) + ) + } + } + + func testInit_EditionUnstable() throws { + let defaults = Google_Protobuf_FeatureSetDefaults.with { + $0.minimumEdition = .proto2 + $0.maximumEdition = .proto3 + $0.defaults = [ + .with { $0.edition = .proto2 }, + .with { $0.edition = .proto3 }, + ] + } + + let resolver1: FeatureResolver = try FeatureResolver( + edition: .unstable, + featureSetDefaults: defaults + ) + XCTAssertEqual(resolver1.edition, .unstable) + } + + func testInit_EditionDefaultNotFound() { + let defaults = try! Google_Protobuf_FeatureSetDefaults( + textFormatString: """ + minimum_edition: EDITION_PROTO2 + maximum_edition: EDITION_2023 + defaults { edition: EDITION_2023 } + """ + ) + XCTAssertThrowsError(try FeatureResolver(edition: .proto2, featureSetDefaults: defaults)) { e in + XCTAssertEqual( + e as! FeatureResolver.Error, + FeatureResolver.Error.noDefault(edition: .proto2) + ) + } + } + + func testInit_EditionExactMatches() throws { + let defaults = try! Google_Protobuf_FeatureSetDefaults( + textFormatString: """ + minimum_edition: EDITION_99997_TEST_ONLY + maximum_edition: EDITION_99999_TEST_ONLY + defaults { + edition: EDITION_99997_TEST_ONLY + overridable_features { field_presence: EXPLICIT} + } + defaults { + edition: EDITION_99998_TEST_ONLY + overridable_features { field_presence: IMPLICIT} + } + defaults { + edition: EDITION_99999_TEST_ONLY + overridable_features { field_presence: LEGACY_REQUIRED} + } + """ + ) + + // Ensure the right things were matched and we got the right feature sets. + + // If lookup fails, throw out of the test method. + + // edition99997TestOnly + let resolver1: FeatureResolver = try FeatureResolver( + edition: .edition99997TestOnly, + featureSetDefaults: defaults + ) + XCTAssertEqual(resolver1.edition, .edition99997TestOnly) + XCTAssertEqual(resolver1.defaultFeatureSet.fieldPresence, .explicit) + + // edition99998TestOnly + let resolver2 = try FeatureResolver( + edition: .edition99998TestOnly, + featureSetDefaults: defaults + ) + XCTAssertEqual(resolver2.edition, .edition99998TestOnly) + XCTAssertEqual(resolver2.defaultFeatureSet.fieldPresence, .implicit) + + // edition99999TestOnly + let resolver3 = try FeatureResolver( + edition: .edition99999TestOnly, + featureSetDefaults: defaults + ) + XCTAssertEqual(resolver3.edition, .edition99999TestOnly) + XCTAssertEqual(resolver3.defaultFeatureSet.fieldPresence, .legacyRequired) + } + + func testInit_EditionMatchesLower() throws { + let defaults = try! Google_Protobuf_FeatureSetDefaults( + textFormatString: """ + minimum_edition: EDITION_99997_TEST_ONLY + maximum_edition: EDITION_99999_TEST_ONLY + defaults { + edition: EDITION_99997_TEST_ONLY + overridable_features { field_presence: EXPLICIT} + } + defaults { + edition: EDITION_99999_TEST_ONLY + overridable_features { field_presence: LEGACY_REQUIRED} + } + """ + ) + + // Ensure the right things were matched and we got the right feature sets. + + // If lookup fails, throw out of the test method. + + // edition99997TestOnly + let resolver1: FeatureResolver = try FeatureResolver( + edition: .edition99997TestOnly, + featureSetDefaults: defaults + ) + XCTAssertEqual(resolver1.edition, .edition99997TestOnly) + XCTAssertEqual(resolver1.defaultFeatureSet.fieldPresence, .explicit) + + // edition99998TestOnly + // The edition will says 99998 since that's what we requested, but the + // defaults will have what was in 99997 + let resolver2 = try FeatureResolver( + edition: .edition99998TestOnly, + featureSetDefaults: defaults + ) + XCTAssertEqual(resolver2.edition, .edition99998TestOnly) + XCTAssertEqual(resolver2.defaultFeatureSet.fieldPresence, .explicit) + + // edition99999TestOnly + let resolver3 = try FeatureResolver( + edition: .edition99999TestOnly, + featureSetDefaults: defaults + ) + XCTAssertEqual(resolver3.edition, .edition99999TestOnly) + XCTAssertEqual(resolver3.defaultFeatureSet.fieldPresence, .legacyRequired) + } + + func testInit_BadExtension() throws { + let defaults = try! Google_Protobuf_FeatureSetDefaults( + textFormatString: """ + minimum_edition: EDITION_PROTO2 + maximum_edition: EDITION_2023 + defaults { edition: EDITION_PROTO2 } + """ + ) + + XCTAssertThrowsError( + try FeatureResolver( + edition: .proto2, + featureSetDefaults: defaults, + featureExtensions: [ + SwiftFeatureTest_Extensions_test, + SDTExtensions_ext_str, + ] + ) + ) { e in + XCTAssertEqual( + e as! FeatureResolver.Error, + FeatureResolver.Error.invalidExtension(type: "swift_descriptor_test.import.ExtendableOne") + ) + } + } + + func testInit_mergingFixedOverridable() throws { + let defaults = try! Google_Protobuf_FeatureSetDefaults( + textFormatString: """ + minimum_edition: EDITION_99997_TEST_ONLY + maximum_edition: EDITION_99999_TEST_ONLY + defaults { + edition: EDITION_99997_TEST_ONLY + overridable_features { field_presence: EXPLICIT } + fixed_features { enum_type: CLOSED } + } + """ + ) + + // Test that fixed and overridable merge + + // If lookup fails, throw out of the test method. + + let resolver1: FeatureResolver = try FeatureResolver( + edition: .edition99997TestOnly, + featureSetDefaults: defaults + ) + XCTAssertEqual(resolver1.edition, .edition99997TestOnly) + XCTAssertEqual(resolver1.defaultFeatureSet.fieldPresence, .explicit) + XCTAssertEqual(resolver1.defaultFeatureSet.enumType, .closed) + } + + func testResolve_Basics() { + let resolver = simpleResolver() + + let features1 = Google_Protobuf_FeatureSet.with { + $0.fieldPresence = .explicit + $0.messageEncoding = .lengthPrefixed + } + let features2 = Google_Protobuf_FeatureSet.with { + $0.enumType = .open + } + let features3 = Google_Protobuf_FeatureSet.with { + $0.fieldPresence = .legacyRequired + $0.jsonFormat = .legacyBestEffort + } + + // No overlap + let merged12 = resolver.resolve(features: features1, resolvedParent: features2) + XCTAssertEqual(merged12.fieldPresence, .explicit) + XCTAssertEqual(merged12.enumType, .open) + XCTAssertEqual(merged12.messageEncoding, .lengthPrefixed) + + // Overlap, features overrides parent features + let merged13 = resolver.resolve(features: features1, resolvedParent: features3) + XCTAssertEqual(merged13.fieldPresence, .explicit) + XCTAssertEqual(merged13.jsonFormat, .legacyBestEffort) + XCTAssertEqual(merged13.messageEncoding, .lengthPrefixed) + } + + func testResolve_CustomFeature() { + let resolver = simpleResolver(extensions: [SwiftFeatureTest_Extensions_test]) + + let features1 = Google_Protobuf_FeatureSet.with { + $0.SwiftFeatureTest_test.feature1 = .value2 + $0.SwiftFeatureTest_test.feature2 = .value2 + } + let features2 = Google_Protobuf_FeatureSet.with { + $0.SwiftFeatureTest_test.feature3 = .value3 + } + let features3 = Google_Protobuf_FeatureSet.with { + $0.SwiftFeatureTest_test.feature1 = .value4 + $0.SwiftFeatureTest_test.feature3 = .value4 + } + + // No overlap + let merged12 = resolver.resolve(features: features1, resolvedParent: features2) + XCTAssertEqual(merged12.SwiftFeatureTest_test.feature1, .value2) + XCTAssertEqual(merged12.SwiftFeatureTest_test.feature2, .value2) + XCTAssertEqual(merged12.SwiftFeatureTest_test.feature3, .value3) + + // Overlap, features overrides parent features + let merged13 = resolver.resolve(features: features1, resolvedParent: features3) + XCTAssertEqual(merged13.SwiftFeatureTest_test.feature1, .value2) + XCTAssertEqual(merged13.SwiftFeatureTest_test.feature2, .value2) + XCTAssertEqual(merged13.SwiftFeatureTest_test.feature3, .value4) + } +} diff --git a/Tests/SwiftProtobufPluginLibraryTests/Test_NamingUtils.swift b/Tests/SwiftProtobufPluginLibraryTests/Test_NamingUtils.swift index aa3a29fbc..8045a1b5c 100644 --- a/Tests/SwiftProtobufPluginLibraryTests/Test_NamingUtils.swift +++ b/Tests/SwiftProtobufPluginLibraryTests/Test_NamingUtils.swift @@ -8,357 +8,366 @@ // // ----------------------------------------------------------------------------- -import XCTest import SwiftProtobuf -@testable import SwiftProtobufPluginLibrary - -class Test_NamingUtils: XCTestCase { - - func testTypePrefix() throws { - // package, swiftPrefix, expected - let tests: [(String, String?, String)] = [ - ( "", nil, "" ), - ( "", "", "" ), - - ( "foo", nil, "Foo_" ), - ( "FOO", nil, "FOO_" ), - ( "fooBar", nil, "FooBar_" ), - ( "FooBar", nil, "FooBar_" ), - - ( "foo.bar.baz", nil, "Foo_Bar_Baz_" ), - ( "foo_bar_baz", nil, "FooBarBaz_" ), - ( "foo.bar_baz", nil, "Foo_BarBaz_" ), - ( "foo_bar__baz", nil, "FooBarBaz_" ), - ( "foo.bar_baz_", nil, "Foo_BarBaz_" ), - ( "foo._bar_baz", nil, "Foo_BarBaz_" ), - - ( "foo.BAR_baz", nil, "Foo_BARBaz_" ), - ( "foo.bar_bAZ", nil, "Foo_BarBAZ_" ), - ( "FOO.BAR_BAZ", nil, "FOO_BARBAZ_" ), - - ( "_foo", nil, "Foo_" ), - ( "__foo", nil, "Foo_" ), - ( "_1foo", nil, "_1foo_" ), - ( "__1foo", nil, "_1foo_" ), - ( "_1foo.2bar._3baz", nil, "_1foo_2bar_3baz_" ), - ( "_1foo_2bar_3baz", nil, "_1foo2bar3baz_" ), - - ( "foo.bar.baz", "", "" ), - ( "", "ABC", "ABC" ), - - ( "foo.bar.baz", "ABC", "ABC" ), - ( "foo.bar.baz", "abc", "abc" ), - ( "foo.bar.baz", "aBc", "aBc" ), - ] - for (package, prefix, expected) in tests { - var proto = Google_Protobuf_FileOptions() - if let prefix = prefix { - proto.swiftPrefix = prefix - } - let result = NamingUtils.typePrefix(protoPackage: package, fileOptions: proto) - XCTAssertEqual(result, expected, "Package: \(package), Prefix: \(prefix ?? "nil")") +import SwiftProtobufPluginLibrary +import XCTest + +final class Test_NamingUtils: XCTestCase { + + func testTypePrefix() throws { + // package, swiftPrefix, expected + let tests: [(String, String?, String)] = [ + ("", nil, ""), + ("", "", ""), + + ("foo", nil, "Foo_"), + ("FOO", nil, "FOO_"), + ("fooBar", nil, "FooBar_"), + ("FooBar", nil, "FooBar_"), + + ("foo.bar.baz", nil, "Foo_Bar_Baz_"), + ("foo_bar_baz", nil, "FooBarBaz_"), + ("foo.bar_baz", nil, "Foo_BarBaz_"), + ("foo_bar__baz", nil, "FooBarBaz_"), + ("foo.bar_baz_", nil, "Foo_BarBaz_"), + ("foo._bar_baz", nil, "Foo_BarBaz_"), + + ("foo.BAR_baz", nil, "Foo_BARBaz_"), + ("foo.bar_bAZ", nil, "Foo_BarBAZ_"), + ("FOO.BAR_BAZ", nil, "FOO_BARBAZ_"), + + ("_foo", nil, "Foo_"), + ("__foo", nil, "Foo_"), + ("_1foo", nil, "_1foo_"), + ("__1foo", nil, "_1foo_"), + ("_1foo.2bar._3baz", nil, "_1foo_2bar_3baz_"), + ("_1foo_2bar_3baz", nil, "_1foo2bar3baz_"), + + ("foo.bar.baz", "", ""), + ("", "ABC", "ABC"), + + ("foo.bar.baz", "ABC", "ABC"), + ("foo.bar.baz", "abc", "abc"), + ("foo.bar.baz", "aBc", "aBc"), + ] + for (package, prefix, expected) in tests { + var proto = Google_Protobuf_FileOptions() + if let prefix = prefix { + proto.swiftPrefix = prefix + } + let result = NamingUtils.typePrefix(protoPackage: package, fileOptions: proto) + XCTAssertEqual(result, expected, "Package: \(package), Prefix: \(prefix ?? "nil")") + } } - } - - func testPrefixStripper_strip() { - // prefix, string, expected - let tests: [(String, String, String?)] = [ - ( "", "", nil ), - - ( "FOO", "FOO", nil ), - ( "fOo", "FOO", nil ), - - ( "foo_", "FOO", nil ), - ( "_foo", "FOO", nil ), - ( "_foo_", "FOO", nil ), - - ( "foo", "FOO_", nil ), - ( "foo", "_FOO", nil ), - ( "foo", "_FOO_", nil ), - - ( "foo_", "FOObar", "bar" ), - ( "_foo", "FOObar", "bar" ), - ( "_foo_", "FOObar", "bar" ), - - ( "foo", "FOO_bar", "bar" ), - ( "foo", "_FOObar", "bar" ), - ( "foo", "_FOO_bar", "bar" ), - - ( "FOO_bar", "foo_BAR_baz", "baz" ), - ( "FooBar", "foo_bar_Baz", "Baz" ), - ( "foo_bar", "foobar_bAZ", "bAZ" ), - ( "_foo_bar", "foobar_bAZ", "bAZ" ), - ( "foo__bar_", "_foo_bar__baz", "baz" ), - - ( "FooBar", "foo_bar_1", nil ), - ( "FooBar", "foo_bar_1foo", nil ), - ( "FooBar", "foo_bar_foo1", "foo1" ), - ] - for (prefix, str, expected) in tests { - let stripper = NamingUtils.PrefixStripper(prefix: prefix) - let result = stripper.strip(from: str) - XCTAssertEqual(result, expected, "Prefix: \(prefix), Input: \(str)") + + func testPrefixStripper_strip() { + // prefix, string, expected + let tests: [(String, String, String?)] = [ + ("", "", nil), + + ("FOO", "FOO", nil), + ("fOo", "FOO", nil), + + ("foo_", "FOO", nil), + ("_foo", "FOO", nil), + ("_foo_", "FOO", nil), + + ("foo", "FOO_", nil), + ("foo", "_FOO", nil), + ("foo", "_FOO_", nil), + + ("foo_", "FOObar", "bar"), + ("_foo", "FOObar", "bar"), + ("_foo_", "FOObar", "bar"), + + ("foo", "FOO_bar", "bar"), + ("foo", "_FOObar", "bar"), + ("foo", "_FOO_bar", "bar"), + + ("FOO_bar", "foo_BAR_baz", "baz"), + ("FooBar", "foo_bar_Baz", "Baz"), + ("foo_bar", "foobar_bAZ", "bAZ"), + ("_foo_bar", "foobar_bAZ", "bAZ"), + ("foo__bar_", "_foo_bar__baz", "baz"), + + ("FooBar", "foo_bar_1", nil), + ("FooBar", "foo_bar_1foo", nil), + ("FooBar", "foo_bar_foo1", "foo1"), + ] + for (prefix, str, expected) in tests { + let stripper = NamingUtils.PrefixStripper(prefix: prefix) + let result = stripper.strip(from: str) + XCTAssertEqual(result, expected, "Prefix: \(prefix), Input: \(str)") + } } - } - - func testSanitize_messageName() { - // input, expected - let tests: [(String, String)] = [ - ( "", "" ), - - ( "Foo", "Foo" ), - ( "FooBar", "FooBar" ), - ( "foo_bar", "foo_bar" ), - - // Some of our names get the disambiguator added. - ( "SwiftProtobuf", "SwiftProtobufMessage" ), - ( "RenamedSwiftProtobuf", "RenamedSwiftProtobufMessage" ), - ( "isInitialized", "isInitializedMessage" ), - - // Some Swift keywords. - ( "associatedtype", "associatedtypeMessage" ), - ( "class", "classMessage" ), - ( "break", "breakMessage" ), - ( "do", "doMessage" ), - - // Inputs with the disambiguator. - ( "classMessage", "classMessageMessage" ), - ( "classMessageMessage", "classMessageMessageMessage" ), - - // Underscores - ( "_", "_Message" ), - ( "___", "___Message" ), - ] - for (input, expected) in tests { - XCTAssertEqual(NamingUtils.sanitize(messageName: input, forbiddenTypeNames: ["RenamedSwiftProtobuf"]), expected) + + func testSanitize_messageName() { + // input, expected + let tests: [(String, String)] = [ + ("", ""), + + ("Foo", "Foo"), + ("FooBar", "FooBar"), + ("foo_bar", "foo_bar"), + + // Some of our names get the disambiguator added. + ("SwiftProtobuf", "SwiftProtobufMessage"), + ("RenamedSwiftProtobuf", "RenamedSwiftProtobufMessage"), + ("isInitialized", "isInitializedMessage"), + + // Some Swift keywords. + ("associatedtype", "associatedtypeMessage"), + ("class", "classMessage"), + ("break", "breakMessage"), + ("do", "doMessage"), + + // Inputs with the disambiguator. + ("classMessage", "classMessageMessage"), + ("classMessageMessage", "classMessageMessageMessage"), + + // Underscores + ("_", "_Message"), + ("___", "___Message"), + ] + for (input, expected) in tests { + XCTAssertEqual( + NamingUtils.sanitize(messageName: input, forbiddenTypeNames: ["RenamedSwiftProtobuf"]), + expected + ) + } } - } - - func testSanitize_enumName() { - // input, expected - let tests: [(String, String)] = [ - ( "", "" ), - - ( "Foo", "Foo" ), - ( "FooBar", "FooBar" ), - ( "foo_bar", "foo_bar" ), - - // Some of our names get the disambiguator added. - ( "SwiftProtobuf", "SwiftProtobufEnum" ), - ( "RenamedSwiftProtobuf", "RenamedSwiftProtobufEnum" ), - ( "isInitialized", "isInitializedEnum" ), - - // Some Swift keywords. - ( "associatedtype", "associatedtypeEnum" ), - ( "class", "classEnum" ), - ( "break", "breakEnum" ), - ( "do", "doEnum" ), - - // Inputs with the disambiguator. - ( "classEnum", "classEnumEnum" ), - ( "classEnumEnum", "classEnumEnumEnum" ), - - // Underscores - ( "_", "_Enum" ), - ( "___", "___Enum" ), - ] - for (input, expected) in tests { - XCTAssertEqual(NamingUtils.sanitize(enumName: input, forbiddenTypeNames: ["RenamedSwiftProtobuf"]), expected) + + func testSanitize_enumName() { + // input, expected + let tests: [(String, String)] = [ + ("", ""), + + ("Foo", "Foo"), + ("FooBar", "FooBar"), + ("foo_bar", "foo_bar"), + + // Some of our names get the disambiguator added. + ("SwiftProtobuf", "SwiftProtobufEnum"), + ("RenamedSwiftProtobuf", "RenamedSwiftProtobufEnum"), + ("isInitialized", "isInitializedEnum"), + + // Some Swift keywords. + ("associatedtype", "associatedtypeEnum"), + ("class", "classEnum"), + ("break", "breakEnum"), + ("do", "doEnum"), + + // Inputs with the disambiguator. + ("classEnum", "classEnumEnum"), + ("classEnumEnum", "classEnumEnumEnum"), + + // Underscores + ("_", "_Enum"), + ("___", "___Enum"), + ] + for (input, expected) in tests { + XCTAssertEqual( + NamingUtils.sanitize(enumName: input, forbiddenTypeNames: ["RenamedSwiftProtobuf"]), + expected + ) + } } - } - - func testSanitize_oneofName() { - // input, expected - let tests: [(String, String)] = [ - ( "", "" ), - - ( "Foo", "Foo" ), - ( "FooBar", "FooBar" ), - ( "foo_bar", "foo_bar" ), - - // Some of our names get the disambiguator added. - ( "RenamedSwiftProtobuf", "RenamedSwiftProtobufOneof" ), - ( "isInitialized", "isInitializedOneof" ), - - // Some Swift keywords. - ( "associatedtype", "associatedtypeOneof" ), - ( "class", "classOneof" ), - ( "break", "breakOneof" ), - ( "do", "doOneof" ), - - // Inputs with the disambiguator. - ( "classOneof", "classOneofOneof" ), - ( "classOneofOneof", "classOneofOneofOneof" ), - - // Underscores - ( "_", "_Oneof" ), - ( "___", "___Oneof" ), - ] - for (input, expected) in tests { - XCTAssertEqual(NamingUtils.sanitize(oneofName: input, forbiddenTypeNames: ["RenamedSwiftProtobuf"]), expected) + + func testSanitize_oneofName() { + // input, expected + let tests: [(String, String)] = [ + ("", ""), + + ("Foo", "Foo"), + ("FooBar", "FooBar"), + ("foo_bar", "foo_bar"), + + // Some of our names get the disambiguator added. + ("RenamedSwiftProtobuf", "RenamedSwiftProtobufOneof"), + ("isInitialized", "isInitializedOneof"), + + // Some Swift keywords. + ("associatedtype", "associatedtypeOneof"), + ("class", "classOneof"), + ("break", "breakOneof"), + ("do", "doOneof"), + + // Inputs with the disambiguator. + ("classOneof", "classOneofOneof"), + ("classOneofOneof", "classOneofOneofOneof"), + + // Underscores + ("_", "_Oneof"), + ("___", "___Oneof"), + ] + for (input, expected) in tests { + XCTAssertEqual( + NamingUtils.sanitize(oneofName: input, forbiddenTypeNames: ["RenamedSwiftProtobuf"]), + expected + ) + } } - } - - func testSanitize_fieldName() { - // input, expected - let tests: [(String, String)] = [ - ( "", "" ), - - ( "Foo", "Foo" ), - ( "FooBar", "FooBar" ), - ( "foo_bar", "foo_bar" ), - - // Some of our names get the disambiguator added. - ( "debugDescription", "debugDescription_p" ), - ( "isInitialized", "isInitialized_p" ), - - // Some Swift keywords. - ( "associatedtype", "`associatedtype`" ), - ( "class", "`class`" ), - ( "break", "`break`" ), - ( "do", "`do`" ), - - // "has"/"clear" get added by us, so they get the disambiguator... - ( "hasFoo", "hasFoo_p" ), - ( "clearFoo", "clearFoo_p" ), - // ...but don't catch words... - ( "hashtag", "hashtag" ), - ( "clearable", "clearable" ), - ( "has911", "has911" ), - // ...or by themselves. - ( "has", "has" ), - ( "clear", "clear" ), - - // Underscores get more underscores. - ( "_", "___" ), - ( "___", "_____" ), - ] - - for (input, expected) in tests { - XCTAssertEqual(NamingUtils.sanitize(fieldName: input), expected) - - let inputPrefixed = "XX" + NamingUtils.uppercaseFirstCharacter(input) - let expected2 = "XX" + NamingUtils.uppercaseFirstCharacter(NamingUtils.trimBackticks(expected)) - XCTAssertEqual(NamingUtils.sanitize(fieldName: inputPrefixed, basedOn: input), expected2) + + func testSanitize_fieldName() { + // input, expected + let tests: [(String, String)] = [ + ("", ""), + + ("Foo", "Foo"), + ("FooBar", "FooBar"), + ("foo_bar", "foo_bar"), + + // Some of our names get the disambiguator added. + ("debugDescription", "debugDescription_p"), + ("isInitialized", "isInitialized_p"), + + // Some Swift keywords. + ("associatedtype", "`associatedtype`"), + ("class", "`class`"), + ("break", "`break`"), + ("do", "`do`"), + + // "has"/"clear" get added by us, so they get the disambiguator... + ("hasFoo", "hasFoo_p"), + ("clearFoo", "clearFoo_p"), + // ...but don't catch words... + ("hashtag", "hashtag"), + ("clearable", "clearable"), + ("has911", "has911"), + // ...or by themselves. + ("has", "has"), + ("clear", "clear"), + + // Underscores get more underscores. + ("_", "___"), + ("___", "_____"), + ] + + for (input, expected) in tests { + XCTAssertEqual(NamingUtils.sanitize(fieldName: input), expected) + + let inputPrefixed = "XX" + NamingUtils.uppercaseFirstCharacter(input) + let expected2 = "XX" + NamingUtils.uppercaseFirstCharacter(NamingUtils.trimBackticks(expected)) + XCTAssertEqual(NamingUtils.sanitize(fieldName: inputPrefixed, basedOn: input), expected2) + } } - } - - func testSanitize_enumCaseName() { - // input, expected - let tests: [(String, String)] = [ - ( "", "" ), - - ( "Foo", "Foo" ), - ( "FooBar", "FooBar" ), - ( "foo_bar", "foo_bar" ), - - // Some of our names get the disambiguator added. - ( "debugDescription", "debugDescription_" ), - ( "dynamicType", "dynamicType_" ), - - // Some Swift keywords work with backticks - ( "associatedtype", "`associatedtype`" ), - ( "class", "`class`" ), - ( "break", "`break`" ), - ( "do", "`do`" ), - - // Underscores get more underscores. - ( "_", "___" ), - ( "___", "_____" ), - ] - - for (input, expected) in tests { - XCTAssertEqual(NamingUtils.sanitize(enumCaseName: input), expected) + + func testSanitize_enumCaseName() { + // input, expected + let tests: [(String, String)] = [ + ("", ""), + + ("Foo", "Foo"), + ("FooBar", "FooBar"), + ("foo_bar", "foo_bar"), + + // Some of our names get the disambiguator added. + ("debugDescription", "debugDescription_"), + ("dynamicType", "dynamicType_"), + + // Some Swift keywords work with backticks + ("associatedtype", "`associatedtype`"), + ("class", "`class`"), + ("break", "`break`"), + ("do", "`do`"), + + // Underscores get more underscores. + ("_", "___"), + ("___", "_____"), + ] + + for (input, expected) in tests { + XCTAssertEqual(NamingUtils.sanitize(enumCaseName: input), expected) + } } - } - - func testSanitize_messageScopedExtensionName() { - // input, expected - let tests: [(String, String)] = [ - ( "", "" ), - - ( "Foo", "Foo" ), - ( "FooBar", "FooBar" ), - ( "foo_bar", "foo_bar" ), - - // Some of our names get the disambiguator added. - ( "debugDescription", "debugDescription_" ), - ( "dynamicType", "dynamicType_" ), - - // Some Swift keywords work with backticks - ( "associatedtype", "`associatedtype`" ), - ( "class", "`class`" ), - ( "break", "`break`" ), - ( "do", "`do`" ), - - // Underscores get more underscores. - ( "_", "___" ), - ( "___", "_____" ), - ] - - for (input, expected) in tests { - XCTAssertEqual(NamingUtils.sanitize(messageScopedExtensionName: input), expected) + + func testSanitize_messageScopedExtensionName() { + // input, expected + let tests: [(String, String)] = [ + ("", ""), + + ("Foo", "Foo"), + ("FooBar", "FooBar"), + ("foo_bar", "foo_bar"), + + // Some of our names get the disambiguator added. + ("debugDescription", "debugDescription_"), + ("dynamicType", "dynamicType_"), + + // Some Swift keywords work with backticks + ("associatedtype", "`associatedtype`"), + ("class", "`class`"), + ("break", "`break`"), + ("do", "`do`"), + + // Underscores get more underscores. + ("_", "___"), + ("___", "_____"), + ] + + for (input, expected) in tests { + XCTAssertEqual(NamingUtils.sanitize(messageScopedExtensionName: input), expected) + } } - } - - func testToCamelCase() { - // input, expectedLower, expectedUpper - let tests: [(String, String, String)] = [ - ( "", "", "" ), - - ( "foo", "foo", "Foo" ), - ( "FOO", "foo", "Foo" ), - ( "foO", "foO", "FoO" ), - - ( "foo_bar", "fooBar", "FooBar" ), - ( "foo_bar", "fooBar", "FooBar" ), - ( "foo_bAr_BaZ", "fooBArBaZ", "FooBArBaZ" ), - ( "foo_bAr_BaZ", "fooBArBaZ", "FooBArBaZ" ), - - ( "foo1bar", "foo1Bar", "Foo1Bar" ), - ( "foo2bAr3BaZ", "foo2BAr3BaZ", "Foo2BAr3BaZ" ), - - ( "foo_1bar", "foo1Bar", "Foo1Bar" ), - ( "foo_2bAr_3BaZ", "foo2BAr3BaZ", "Foo2BAr3BaZ" ), - ( "_0foo_1bar", "_0Foo1Bar", "_0Foo1Bar" ), - ( "_0foo_2bAr_3BaZ", "_0Foo2BAr3BaZ", "_0Foo2BAr3BaZ" ), - - ( "url", "url", "URL" ), - ( "http", "http", "HTTP" ), - ( "https", "https", "HTTPS" ), - ( "id", "id", "ID" ), - - ( "the_url", "theURL", "TheURL" ), - ( "use_http", "useHTTP", "UseHTTP" ), - ( "use_https", "useHTTPS", "UseHTTPS" ), - ( "request_id", "requestID", "RequestID" ), - - ( "url_number", "urlNumber", "URLNumber" ), - ( "http_needed", "httpNeeded", "HTTPNeeded" ), - ( "https_needed", "httpsNeeded", "HTTPSNeeded" ), - ( "id_number", "idNumber", "IDNumber" ), - - ( "is_url_number", "isURLNumber", "IsURLNumber" ), - ( "is_http_needed", "isHTTPNeeded", "IsHTTPNeeded" ), - ( "is_https_needed", "isHTTPSNeeded", "IsHTTPSNeeded" ), - ( "the_id_number", "theIDNumber", "TheIDNumber" ), - - ( "url_foo_http_id", "urlFooHTTPID", "URLFooHTTPID"), - - ( "göß", "göß", "Göß"), - ( "göo", "göO", "GöO"), - ( "gö_o", "göO", "GöO"), - ( "g_🎉_o", "g🎉O", "G🎉O"), - ( "g🎉o", "g🎉O", "G🎉O"), - - ( "m\u{AB}n", "m_u171N", "M_u171N"), - ( "m\u{AB}_n", "m_u171N", "M_u171N"), - ( "m_\u{AB}_n", "m_u171N", "M_u171N"), - ] - - for (input, expectedLower, expectedUppper) in tests { - XCTAssertEqual(NamingUtils.toLowerCamelCase(input), expectedLower) - XCTAssertEqual(NamingUtils.toUpperCamelCase(input), expectedUppper) + + func testToCamelCase() { + // input, expectedLower, expectedUpper + let tests: [(String, String, String)] = [ + ("", "", ""), + + ("foo", "foo", "Foo"), + ("FOO", "foo", "Foo"), + ("foO", "foO", "FoO"), + + ("foo_bar", "fooBar", "FooBar"), + ("foo_bar", "fooBar", "FooBar"), + ("foo_bAr_BaZ", "fooBArBaZ", "FooBArBaZ"), + ("foo_bAr_BaZ", "fooBArBaZ", "FooBArBaZ"), + + ("foo1bar", "foo1Bar", "Foo1Bar"), + ("foo2bAr3BaZ", "foo2BAr3BaZ", "Foo2BAr3BaZ"), + + ("foo_1bar", "foo1Bar", "Foo1Bar"), + ("foo_2bAr_3BaZ", "foo2BAr3BaZ", "Foo2BAr3BaZ"), + ("_0foo_1bar", "_0Foo1Bar", "_0Foo1Bar"), + ("_0foo_2bAr_3BaZ", "_0Foo2BAr3BaZ", "_0Foo2BAr3BaZ"), + + ("url", "url", "URL"), + ("http", "http", "HTTP"), + ("https", "https", "HTTPS"), + ("id", "id", "ID"), + + ("the_url", "theURL", "TheURL"), + ("use_http", "useHTTP", "UseHTTP"), + ("use_https", "useHTTPS", "UseHTTPS"), + ("request_id", "requestID", "RequestID"), + + ("url_number", "urlNumber", "URLNumber"), + ("http_needed", "httpNeeded", "HTTPNeeded"), + ("https_needed", "httpsNeeded", "HTTPSNeeded"), + ("id_number", "idNumber", "IDNumber"), + + ("is_url_number", "isURLNumber", "IsURLNumber"), + ("is_http_needed", "isHTTPNeeded", "IsHTTPNeeded"), + ("is_https_needed", "isHTTPSNeeded", "IsHTTPSNeeded"), + ("the_id_number", "theIDNumber", "TheIDNumber"), + + ("url_foo_http_id", "urlFooHTTPID", "URLFooHTTPID"), + + ("göß", "göß", "Göß"), + ("göo", "göO", "GöO"), + ("gö_o", "göO", "GöO"), + ("g_🎉_o", "g🎉O", "G🎉O"), + ("g🎉o", "g🎉O", "G🎉O"), + + ("m\u{AB}n", "m_u171N", "M_u171N"), + ("m\u{AB}_n", "m_u171N", "M_u171N"), + ("m_\u{AB}_n", "m_u171N", "M_u171N"), + ] + + for (input, expectedLower, expectedUppper) in tests { + XCTAssertEqual(NamingUtils.toLowerCamelCase(input), expectedLower) + XCTAssertEqual(NamingUtils.toUpperCamelCase(input), expectedUppper) + } } - } } diff --git a/Tests/SwiftProtobufPluginLibraryTests/Test_ProtoFileToModuleMappings.swift b/Tests/SwiftProtobufPluginLibraryTests/Test_ProtoFileToModuleMappings.swift index e4a4b21ce..409b8a499 100644 --- a/Tests/SwiftProtobufPluginLibraryTests/Test_ProtoFileToModuleMappings.swift +++ b/Tests/SwiftProtobufPluginLibraryTests/Test_ProtoFileToModuleMappings.swift @@ -8,300 +8,313 @@ // // ----------------------------------------------------------------------------- -import XCTest import SwiftProtobuf -@testable import SwiftProtobufPluginLibrary - -// Support equality to simplify testing of getting the correct errors. -extension ProtoFileToModuleMappings.LoadError: Equatable { - public static func ==(lhs: ProtoFileToModuleMappings.LoadError, rhs: ProtoFileToModuleMappings.LoadError) -> Bool { - switch (lhs, rhs) { - case (.entryMissingModuleName(let l), .entryMissingModuleName(let r)): return l == r - case (.entryHasNoProtoPaths(let l), .entryHasNoProtoPaths(let r)): return l == r - case (.duplicateProtoPathMapping(let l1, let l2, let l3), - .duplicateProtoPathMapping(let r1, let r2, let r3)): return l1 == r1 && l2 == r2 && l3 == r3 - default: return false - } - } -} +import SwiftProtobufPluginLibrary +import SwiftProtobufTestHelpers +import XCTest // Helpers to make test cases. -fileprivate typealias FileDescriptorProto = Google_Protobuf_FileDescriptorProto - -class Test_ProtoFileToModuleMappings: XCTestCase { - - func test_Initialization() { - // ProtoFileToModuleMappings always includes mappings for the protos that - // ship with the library, so they will show in the counts below. - let baselineEntries = SwiftProtobufInfo.bundledProtoFiles.count - let baselineModules = 1 // Since those files are in SwiftProtobuf. - - // (config, num_expected_mappings, num_expected_modules) - let tests: [(String, Int, Int)] = [ - ("", 0, 0), - - ("mapping { module_name: \"good\", proto_file_path: \"file.proto\" }", 1, 1), - - ("mapping { module_name: \"good\", proto_file_path: [\"a\",\"b\"] }", 2, 1), - - // Two mapping {}, same module. - ("mapping { module_name: \"good\", proto_file_path: \"a\" }\n" + - "mapping { module_name: \"good\", proto_file_path: \"b\" }", 2, 1), - - // Two mapping {}, different modules. - ("mapping { module_name: \"one\", proto_file_path: \"a\" }\n" + - "mapping { module_name: \"two\", proto_file_path: \"b\" }", 2, 2), - - // Same file listed twice; odd, but ok since no conflict. - ("mapping { module_name: \"foo\", proto_file_path: [\"abc\", \"abc\"] }", 1, 1), - - // Same module/file listing; odd, but ok since no conflict. - ("mapping { module_name: \"foo\", proto_file_path: [\"mno\", \"abc\"] }\n" + - "mapping { module_name: \"foo\", proto_file_path: [\"abc\", \"xyz\"] }", 3, 1), - - ] - - for (idx, (configText, expectMappings, expectedModules)) in tests.enumerated() { - let config: SwiftProtobuf_GenSwift_ModuleMappings - do { - config = try SwiftProtobuf_GenSwift_ModuleMappings(textFormatString: configText) - } catch { - XCTFail("Index: \(idx) - Test case wasn't valid TextFormat") - continue - } - - do { - let mapper = try ProtoFileToModuleMappings(moduleMappingsProto: config) - XCTAssertEqual(mapper.mappings.count, expectMappings + baselineEntries, "Index: \(idx)") - XCTAssertEqual(Set(mapper.mappings.values).count, expectedModules + baselineModules, "Index: \(idx)") - } catch let error { - XCTFail("Index \(idx) - Unexpected error: \(error)") - } +private typealias FileDescriptorProto = Google_Protobuf_FileDescriptorProto + +final class Test_ProtoFileToModuleMappings: XCTestCase { + + func test_Initialization() { + // ProtoFileToModuleMappings always includes mappings for the protos that + // ship with the library, so they will show in the counts below. + let baselineEntries = SwiftProtobufInfo.bundledProtoFiles.count + let baselineModules = 1 // Since those files are in SwiftProtobuf. + + // (config, num_expected_mappings, num_expected_modules) + let tests: [(String, Int, Int)] = [ + ("", 0, 0), + + ("mapping { module_name: \"good\", proto_file_path: \"file.proto\" }", 1, 1), + + ("mapping { module_name: \"good\", proto_file_path: [\"a\",\"b\"] }", 2, 1), + + // Two mapping {}, same module. + ( + "mapping { module_name: \"good\", proto_file_path: \"a\" }\n" + + "mapping { module_name: \"good\", proto_file_path: \"b\" }", 2, 1 + ), + + // Two mapping {}, different modules. + ( + "mapping { module_name: \"one\", proto_file_path: \"a\" }\n" + + "mapping { module_name: \"two\", proto_file_path: \"b\" }", 2, 2 + ), + + // Same file listed twice; odd, but ok since no conflict. + ("mapping { module_name: \"foo\", proto_file_path: [\"abc\", \"abc\"] }", 1, 1), + + // Same module/file listing; odd, but ok since no conflict. + ( + "mapping { module_name: \"foo\", proto_file_path: [\"mno\", \"abc\"] }\n" + + "mapping { module_name: \"foo\", proto_file_path: [\"abc\", \"xyz\"] }", 3, 1 + ), + + ] + + for (idx, (configText, expectMappings, expectedModules)) in tests.enumerated() { + let config: SwiftProtobuf_GenSwift_ModuleMappings + do { + config = try SwiftProtobuf_GenSwift_ModuleMappings(textFormatString: configText) + } catch { + XCTFail("Index: \(idx) - Test case wasn't valid TextFormat") + continue + } + + do { + let mapper = try ProtoFileToModuleMappings(moduleMappingsProto: config) + XCTAssertEqual(mapper.mappings.count, expectMappings + baselineEntries, "Index: \(idx)") + XCTAssertEqual(Set(mapper.mappings.values).count, expectedModules + baselineModules, "Index: \(idx)") + XCTAssert(mapper.hasMappings == (expectMappings != 0), "Index: \(idx)") + } catch let error { + XCTFail("Index \(idx) - Unexpected error: \(error)") + } + } } - } - - func test_Initialization_InvalidConfigs() { - // This are valid text format, but not valid config protos. - // (input, expected_error_type) - let partialConfigs: [(String, ProtoFileToModuleMappings.LoadError)] = [ - // No module or proto files - ("mapping { }", .entryMissingModuleName(mappingIndex: 0)), - - // No proto files - ("mapping { module_name: \"foo\" }", .entryHasNoProtoPaths(mappingIndex: 0)), - - // No module - ("mapping { proto_file_path: [\"foo\"] }", .entryMissingModuleName(mappingIndex: 0)), - ("mapping { proto_file_path: [\"foo\", \"bar\"] }", .entryMissingModuleName(mappingIndex: 0)), - - // Empty module name. - ("mapping { module_name: \"\" }", .entryMissingModuleName(mappingIndex: 0)), - ("mapping { module_name: \"\", proto_file_path: [\"foo\"] }", .entryMissingModuleName(mappingIndex: 0)), - ("mapping { module_name: \"\", proto_file_path: [\"foo\", \"bar\"] }", .entryMissingModuleName(mappingIndex: 0)), - - // Throw some on a second entry just to check that also. - ("mapping { module_name: \"good\", proto_file_path: \"file.proto\" }\n" + - "mapping { }", - .entryMissingModuleName(mappingIndex: 1)), - ("mapping { module_name: \"good\", proto_file_path: \"file.proto\" }\n" + - "mapping { module_name: \"foo\" }", - .entryHasNoProtoPaths(mappingIndex: 1)), - - // Duplicates - - ("mapping { module_name: \"foo\", proto_file_path: \"abc\" }\n" + - "mapping { module_name: \"bar\", proto_file_path: \"abc\" }", - .duplicateProtoPathMapping(path: "abc", firstModule: "foo", secondModule: "bar")), - - ("mapping { module_name: \"foo\", proto_file_path: \"abc\" }\n" + - "mapping { module_name: \"bar\", proto_file_path: \"xyz\" }\n" + - "mapping { module_name: \"baz\", proto_file_path: \"abc\" }", - .duplicateProtoPathMapping(path: "abc", firstModule: "foo", secondModule: "baz")), - ] - - for (idx, (configText, expected)) in partialConfigs.enumerated() { - let config: SwiftProtobuf_GenSwift_ModuleMappings - do { - config = try SwiftProtobuf_GenSwift_ModuleMappings(textFormatString: configText) - } catch { - XCTFail("Index: \(idx) - Test case wasn't valid TextFormat") - continue - } - - do { - let _ = try ProtoFileToModuleMappings(moduleMappingsProto: config) - XCTFail("Shouldn't have gotten here, index \(idx)") - } catch let error as ProtoFileToModuleMappings.LoadError { - XCTAssertEqual(error, expected, "Index \(idx)") - } catch let error { - XCTFail("Index \(idx) - Unexpected error: \(error)") - } + + func test_Initialization_InvalidConfigs() { + // This are valid text format, but not valid config protos. + // (input, expected_error_type) + let partialConfigs: [(String, ProtoFileToModuleMappings.LoadError)] = [ + // No module or proto files + ("mapping { }", .entryMissingModuleName(mappingIndex: 0)), + + // No proto files + ("mapping { module_name: \"foo\" }", .entryHasNoProtoPaths(mappingIndex: 0)), + + // No module + ("mapping { proto_file_path: [\"foo\"] }", .entryMissingModuleName(mappingIndex: 0)), + ("mapping { proto_file_path: [\"foo\", \"bar\"] }", .entryMissingModuleName(mappingIndex: 0)), + + // Empty module name. + ("mapping { module_name: \"\" }", .entryMissingModuleName(mappingIndex: 0)), + ("mapping { module_name: \"\", proto_file_path: [\"foo\"] }", .entryMissingModuleName(mappingIndex: 0)), + ( + "mapping { module_name: \"\", proto_file_path: [\"foo\", \"bar\"] }", + .entryMissingModuleName(mappingIndex: 0) + ), + + // Throw some on a second entry just to check that also. + ( + "mapping { module_name: \"good\", proto_file_path: \"file.proto\" }\n" + "mapping { }", + .entryMissingModuleName(mappingIndex: 1) + ), + ( + "mapping { module_name: \"good\", proto_file_path: \"file.proto\" }\n" + + "mapping { module_name: \"foo\" }", + .entryHasNoProtoPaths(mappingIndex: 1) + ), + + // Duplicates + + ( + "mapping { module_name: \"foo\", proto_file_path: \"abc\" }\n" + + "mapping { module_name: \"bar\", proto_file_path: \"abc\" }", + .duplicateProtoPathMapping(path: "abc", firstModule: "foo", secondModule: "bar") + ), + + ( + "mapping { module_name: \"foo\", proto_file_path: \"abc\" }\n" + + "mapping { module_name: \"bar\", proto_file_path: \"xyz\" }\n" + + "mapping { module_name: \"baz\", proto_file_path: \"abc\" }", + .duplicateProtoPathMapping(path: "abc", firstModule: "foo", secondModule: "baz") + ), + ] + + for (idx, (configText, expected)) in partialConfigs.enumerated() { + let config: SwiftProtobuf_GenSwift_ModuleMappings + do { + config = try SwiftProtobuf_GenSwift_ModuleMappings(textFormatString: configText) + } catch { + XCTFail("Index: \(idx) - Test case wasn't valid TextFormat") + continue + } + + do { + let _ = try ProtoFileToModuleMappings(moduleMappingsProto: config) + XCTFail("Shouldn't have gotten here, index \(idx)") + } catch let error as ProtoFileToModuleMappings.LoadError { + XCTAssertEqual(error, expected, "Index \(idx)") + } catch let error { + XCTFail("Index \(idx) - Unexpected error: \(error)") + } + } } - } - - func test_moduleName_forFile() { - let configText = [ - "mapping { module_name: \"foo\", proto_file_path: \"file\" }", - "mapping { module_name: \"bar\", proto_file_path: \"dir1/file\" }", - "mapping { module_name: \"baz\", proto_file_path: [\"dir2/file\",\"file4\"] }", - "mapping { module_name: \"foo\", proto_file_path: \"file5\" }", - ].joined(separator: "\n") - - let config = try! SwiftProtobuf_GenSwift_ModuleMappings(textFormatString: configText) - let mapper = try! ProtoFileToModuleMappings(moduleMappingsProto: config) - - let tests: [(String, String?)] = [ - ( "file", "foo" ), - ( "dir1/file", "bar" ), - ( "dir2/file", "baz" ), - ( "file4", "baz" ), - ( "file5", "foo" ), - - ( "", nil ), - ( "not found", nil ), - ] - - for (name, expected) in tests { - let descSet = DescriptorSet(protos: [FileDescriptorProto(name: name)]) - XCTAssertEqual(mapper.moduleName(forFile: descSet.files.first!), expected, "Looking for \(name)") + + func test_moduleName_forFile() { + let configText = [ + "mapping { module_name: \"foo\", proto_file_path: \"file\" }", + "mapping { module_name: \"bar\", proto_file_path: \"dir1/file\" }", + "mapping { module_name: \"baz\", proto_file_path: [\"dir2/file\",\"file4\"] }", + "mapping { module_name: \"foo\", proto_file_path: \"file5\" }", + ].joined(separator: "\n") + + let config = try! SwiftProtobuf_GenSwift_ModuleMappings(textFormatString: configText) + let mapper = try! ProtoFileToModuleMappings(moduleMappingsProto: config) + + let tests: [(String, String?)] = [ + ("file", "foo"), + ("dir1/file", "bar"), + ("dir2/file", "baz"), + ("file4", "baz"), + ("file5", "foo"), + + ("", nil), + ("not found", nil), + ] + + for (name, expected) in tests { + let descSet = DescriptorSet(protos: [FileDescriptorProto(name: name)]) + XCTAssertEqual(mapper.moduleName(forFile: descSet.files.first!), expected, "Looking for \(name)") + } } - } - - func test_neededModules_forFile() { - let configText = [ - "mapping { module_name: \"foo\", proto_file_path: \"file\" }", - "mapping { module_name: \"bar\", proto_file_path: \"dir1/file\" }", - "mapping { module_name: \"baz\", proto_file_path: [\"dir2/file\",\"file4\"] }", - "mapping { module_name: \"foo\", proto_file_path: \"file5\" }", - ].joined(separator: "\n") - - let config = try! SwiftProtobuf_GenSwift_ModuleMappings(textFormatString: configText) - let mapper = try! ProtoFileToModuleMappings(moduleMappingsProto: config) - - let fileProtos = [ - FileDescriptorProto(name: "file"), - FileDescriptorProto(name: "google/protobuf/any.proto"), - FileDescriptorProto(name: "dir1/file", dependencies: ["file"]), - FileDescriptorProto(name: "dir2/file", dependencies: ["google/protobuf/any.proto"]), - FileDescriptorProto(name: "file4", dependencies: ["dir2/file", "dir1/file", "file"]), - FileDescriptorProto(name: "file5", dependencies: ["file"]), - ] - let descSet = DescriptorSet(protos: fileProtos) - - // ( filename, [deps] ) - let tests: [(String, [String]?)] = [ - ( "file", nil ), - ( "dir1/file", ["foo"] ), - ( "dir2/file", nil ), - ( "file4", ["bar", "foo"] ), - ( "file5", nil ), - ] - - for (name, expected) in tests { - let fileDesc = descSet.files.filter{ $0.name == name }.first! - let result = mapper.neededModules(forFile: fileDesc) - if let expected = expected { - XCTAssertEqual(result!, expected, "Looking for \(name)") - } else { - XCTAssertNil(result, "Looking for \(name)") - } + + func test_neededModules_forFile() { + let configText = [ + "mapping { module_name: \"foo\", proto_file_path: \"file\" }", + "mapping { module_name: \"bar\", proto_file_path: \"dir1/file\" }", + "mapping { module_name: \"baz\", proto_file_path: [\"dir2/file\",\"file4\"] }", + "mapping { module_name: \"foo\", proto_file_path: \"file5\" }", + ].joined(separator: "\n") + + let config = try! SwiftProtobuf_GenSwift_ModuleMappings(textFormatString: configText) + let mapper = try! ProtoFileToModuleMappings(moduleMappingsProto: config) + + let fileProtos = [ + FileDescriptorProto(name: "file"), + FileDescriptorProto(name: "google/protobuf/any.proto"), + FileDescriptorProto(name: "dir1/file", dependencies: ["file"]), + FileDescriptorProto(name: "dir2/file", dependencies: ["google/protobuf/any.proto"]), + FileDescriptorProto(name: "file4", dependencies: ["dir2/file", "dir1/file", "file"]), + FileDescriptorProto(name: "file5", dependencies: ["file"]), + ] + let descSet = DescriptorSet(protos: fileProtos) + + // ( filename, [deps] ) + let tests: [(String, [String]?)] = [ + ("file", nil), + ("dir1/file", ["foo"]), + ("dir2/file", nil), + ("file4", ["bar", "foo"]), + ("file5", nil), + ] + + for (name, expected) in tests { + let fileDesc = descSet.files.filter { $0.name == name }.first! + let result = mapper.neededModules(forFile: fileDesc) + if let expected = expected { + XCTAssertEqual(result!, expected, "Looking for \(name)") + } else { + XCTAssertNil(result, "Looking for \(name)") + } + } } - } - - func test_neededModules_forFile_PublicImports() { - // See the note in neededModules(forFile:) about how public import complicate things. - - // Given: - // - // + File: a.proto - // message A {} - // - // + File: imports_a_publicly.proto - // import public "a.proto"; - // - // message ImportsAPublicly { - // A a = 1; - // } - // - // + File: imports_imports_a_publicly.proto - // import public "imports_a_publicly.proto"; - // - // message ImportsImportsAPublicly { - // A a = 1; - // } - // - // + File: uses_a_transitively.proto - // import "imports_a_publicly.proto"; - // - // message UsesATransitively { - // A a = 1; - // } - // - // + File: uses_a_transitively2.proto - // import "imports_imports_a_publicly.proto"; - // - // message UsesATransitively2 { - // A a = 1; - // } - // - // With a mapping file of: - // - // mapping { - // module_name: "A" - // proto_file_path: "a.proto" - // } - // mapping { - // module_name: "ImportsAPublicly" - // proto_file_path: "imports_a_publicly.proto" - // } - // mapping { - // module_name: "ImportsImportsAPublicly" - // proto_file_path: "imports_imports_a_publicly.proto" - // } - - let configText = [ - "mapping { module_name: \"A\", proto_file_path: \"a.proto\" }", - "mapping { module_name: \"ImportsAPublicly\", proto_file_path: \"imports_a_publicly.proto\" }", - "mapping { module_name: \"ImportsImportsAPublicly\", proto_file_path: \"imports_imports_a_publicly.proto\" }", - ].joined(separator: "\n") - - let config = try! SwiftProtobuf_GenSwift_ModuleMappings(textFormatString: configText) - let mapper = try! ProtoFileToModuleMappings(moduleMappingsProto: config) - - let fileProtos = [ - FileDescriptorProto(name: "a.proto"), - FileDescriptorProto(name: "imports_a_publicly.proto", - dependencies: ["a.proto"], - publicDependencies: [0]), - FileDescriptorProto(name: "imports_imports_a_publicly.proto", - dependencies: ["imports_a_publicly.proto"], - publicDependencies: [0]), - FileDescriptorProto(name: "uses_a_transitively.proto", - dependencies: ["imports_a_publicly.proto"]), - FileDescriptorProto(name: "uses_a_transitively2.proto", - dependencies: ["imports_imports_a_publicly.proto"]), - ] - let descSet = DescriptorSet(protos: fileProtos) - - // ( filename, [deps] ) - let tests: [(String, [String]?)] = [ - ( "a.proto", nil ), - ( "imports_a_publicly.proto", ["A"] ), - ( "imports_imports_a_publicly.proto", ["A", "ImportsAPublicly"] ), - ( "uses_a_transitively.proto", ["A", "ImportsAPublicly"] ), - ( "uses_a_transitively2.proto", ["A", "ImportsAPublicly", "ImportsImportsAPublicly"] ), - ] - - for (name, expected) in tests { - let fileDesc = descSet.files.filter{ $0.name == name }.first! - let result = mapper.neededModules(forFile: fileDesc) - if let expected = expected { - XCTAssertEqual(result!, expected, "Looking for \(name)") - } else { - XCTAssertNil(result, "Looking for \(name)") - } + + func test_neededModules_forFile_PublicImports() { + // See the note in neededModules(forFile:) about how public import complicate things. + + // Given: + // + // + File: a.proto + // message A {} + // + // + File: imports_a_publicly.proto + // import public "a.proto"; + // + // message ImportsAPublicly { + // A a = 1; + // } + // + // + File: imports_imports_a_publicly.proto + // import public "imports_a_publicly.proto"; + // + // message ImportsImportsAPublicly { + // A a = 1; + // } + // + // + File: uses_a_transitively.proto + // import "imports_a_publicly.proto"; + // + // message UsesATransitively { + // A a = 1; + // } + // + // + File: uses_a_transitively2.proto + // import "imports_imports_a_publicly.proto"; + // + // message UsesATransitively2 { + // A a = 1; + // } + // + // With a mapping file of: + // + // mapping { + // module_name: "A" + // proto_file_path: "a.proto" + // } + // mapping { + // module_name: "ImportsAPublicly" + // proto_file_path: "imports_a_publicly.proto" + // } + // mapping { + // module_name: "ImportsImportsAPublicly" + // proto_file_path: "imports_imports_a_publicly.proto" + // } + + let configText = [ + "mapping { module_name: \"A\", proto_file_path: \"a.proto\" }", + "mapping { module_name: \"ImportsAPublicly\", proto_file_path: \"imports_a_publicly.proto\" }", + "mapping { module_name: \"ImportsImportsAPublicly\", proto_file_path: \"imports_imports_a_publicly.proto\" }", + ].joined(separator: "\n") + + let config = try! SwiftProtobuf_GenSwift_ModuleMappings(textFormatString: configText) + let mapper = try! ProtoFileToModuleMappings(moduleMappingsProto: config) + + let fileProtos = [ + FileDescriptorProto(name: "a.proto"), + FileDescriptorProto( + name: "imports_a_publicly.proto", + dependencies: ["a.proto"], + publicDependencies: [0] + ), + FileDescriptorProto( + name: "imports_imports_a_publicly.proto", + dependencies: ["imports_a_publicly.proto"], + publicDependencies: [0] + ), + FileDescriptorProto( + name: "uses_a_transitively.proto", + dependencies: ["imports_a_publicly.proto"] + ), + FileDescriptorProto( + name: "uses_a_transitively2.proto", + dependencies: ["imports_imports_a_publicly.proto"] + ), + ] + let descSet = DescriptorSet(protos: fileProtos) + + // ( filename, [deps] ) + let tests: [(String, [String]?)] = [ + ("a.proto", nil), + ("imports_a_publicly.proto", ["A"]), + ("imports_imports_a_publicly.proto", ["A", "ImportsAPublicly"]), + ("uses_a_transitively.proto", ["A", "ImportsAPublicly"]), + ("uses_a_transitively2.proto", ["A", "ImportsAPublicly", "ImportsImportsAPublicly"]), + ] + + for (name, expected) in tests { + let fileDesc = descSet.files.filter { $0.name == name }.first! + let result = mapper.neededModules(forFile: fileDesc) + if let expected = expected { + XCTAssertEqual(result!, expected, "Looking for \(name)") + } else { + XCTAssertNil(result, "Looking for \(name)") + } + } } - } } diff --git a/Tests/SwiftProtobufPluginLibraryTests/Test_SwiftLanguage.swift b/Tests/SwiftProtobufPluginLibraryTests/Test_SwiftLanguage.swift index d92abf86c..437a843e5 100644 --- a/Tests/SwiftProtobufPluginLibraryTests/Test_SwiftLanguage.swift +++ b/Tests/SwiftProtobufPluginLibraryTests/Test_SwiftLanguage.swift @@ -12,27 +12,33 @@ /// // ----------------------------------------------------------------------------- -import XCTest import SwiftProtobufPluginLibrary +import XCTest -class Test_SwiftLanguage: XCTestCase { +final class Test_SwiftLanguage: XCTestCase { func testIsValidSwiftIdentifier() { let cases = [ "H9000", "\u{1f436}\u{1f431}", ] for identifier in cases { - XCTAssertTrue(isValidSwiftIdentifier(identifier, allowQuoted: false), - "Should be valid: \(identifier)") + XCTAssertTrue( + isValidSwiftIdentifier(identifier, allowQuoted: false), + "Should be valid: \(identifier)" + ) } - let quotedCases = cases.map {return "`\($0)`"} + let quotedCases = cases.map { "`\($0)`" } for identifier in quotedCases { - XCTAssertFalse(isValidSwiftIdentifier(identifier, allowQuoted: false), - "Should NOT be valid: \(identifier)") + XCTAssertFalse( + isValidSwiftIdentifier(identifier, allowQuoted: false), + "Should NOT be valid: \(identifier)" + ) } for identifier in cases + quotedCases { - XCTAssertTrue(isValidSwiftIdentifier(identifier, allowQuoted: true), - "Should be valid: \(identifier)") + XCTAssertTrue( + isValidSwiftIdentifier(identifier, allowQuoted: true), + "Should be valid: \(identifier)" + ) } } @@ -45,17 +51,23 @@ class Test_SwiftLanguage: XCTestCase { "This is bad", ] for identifier in cases { - XCTAssertFalse(isValidSwiftIdentifier(identifier, allowQuoted: false), - "Should NOT be valid: \(identifier)") + XCTAssertFalse( + isValidSwiftIdentifier(identifier, allowQuoted: false), + "Should NOT be valid: \(identifier)" + ) } - let quotedCases = cases.map {return "`\($0)`"} + let quotedCases = cases.map { "`\($0)`" } for identifier in cases + quotedCases { - XCTAssertFalse(isValidSwiftIdentifier(identifier, allowQuoted: false), - "Should NOT be valid: \(identifier)") + XCTAssertFalse( + isValidSwiftIdentifier(identifier, allowQuoted: false), + "Should NOT be valid: \(identifier)" + ) } for identifier in cases + quotedCases { - XCTAssertFalse(isValidSwiftIdentifier(identifier, allowQuoted: true), - "Should NOT be valid: \(identifier)") + XCTAssertFalse( + isValidSwiftIdentifier(identifier, allowQuoted: true), + "Should NOT be valid: \(identifier)" + ) } let badQuotes = [ @@ -67,8 +79,10 @@ class Test_SwiftLanguage: XCTestCase { "``H9000``", ] for identifier in badQuotes { - XCTAssertFalse(isValidSwiftIdentifier(identifier, allowQuoted: true), - "Should NOT be valid: \(identifier)") + XCTAssertFalse( + isValidSwiftIdentifier(identifier, allowQuoted: true), + "Should NOT be valid: \(identifier)" + ) } } } diff --git a/Tests/SwiftProtobufPluginLibraryTests/Test_SwiftProtobufNamer.swift b/Tests/SwiftProtobufPluginLibraryTests/Test_SwiftProtobufNamer.swift index 7ea0f7427..52872e85b 100644 --- a/Tests/SwiftProtobufPluginLibraryTests/Test_SwiftProtobufNamer.swift +++ b/Tests/SwiftProtobufPluginLibraryTests/Test_SwiftProtobufNamer.swift @@ -8,331 +8,278 @@ // // ----------------------------------------------------------------------------- -import XCTest import SwiftProtobuf import SwiftProtobufPluginLibrary +import SwiftProtobufTestHelpers +import XCTest -class Test_SwiftProtobufNamer: XCTestCase { - - func testEnumValueHandling_AliasNameMatches() throws { - let txt = [ - "name: \"test.proto\"", - "syntax: \"proto2\"", - "enum_type {", - " name: \"TestEnum\"", - " options {", - " allow_alias: true", - " }", - " value {", - " name: \"TEST_ENUM_FOO\"", - " number: 0", // Primary - " }", - " value {", - " name: \"TEST_ENUM_BAR\"", - " number: 1", - " }", - " value {", - " name: \"TESTENUM_FOO\"", - " number: 0", // Alias - " }", - " value {", - " name: \"_FOO\"", - " number: 0", // Alias - " }", - " value {", - " name: \"FOO\"", - " number: 0", // Alias - " }", - " value {", - " name: \"TEST_ENUM_ALIAS\"", - " number: 0", // Alias (unique name) - " }", - "}" - ] - - let fileProto: Google_Protobuf_FileDescriptorProto - do { - fileProto = try Google_Protobuf_FileDescriptorProto(textFormatStrings: txt) - } catch let e { - XCTFail("Error: \(e)") - return +final class Test_SwiftProtobufNamer: XCTestCase { + + func testEnumValueHandling_AliasNameMatches() throws { + let txt = [ + "name: \"test.proto\"", + "syntax: \"proto2\"", + "enum_type {", + " name: \"TestEnum\"", + " options {", + " allow_alias: true", + " }", + " value {", + " name: \"TEST_ENUM_FOO\"", + " number: 0", // Primary + " }", + " value {", + " name: \"TEST_ENUM_BAR\"", + " number: 1", + " }", + " value {", + " name: \"TESTENUM_FOO\"", + " number: 0", // Alias + " }", + " value {", + " name: \"_FOO\"", + " number: 0", // Alias + " }", + " value {", + " name: \"FOO\"", + " number: 0", // Alias + " }", + " value {", + " name: \"TEST_ENUM_ALIAS\"", + " number: 0", // Alias (unique name) + " }", + "}", + ] + + let fileProto: Google_Protobuf_FileDescriptorProto + do { + fileProto = try Google_Protobuf_FileDescriptorProto(textFormatStrings: txt) + } catch let e { + XCTFail("Error: \(e)") + return + } + + let descriptorSet = DescriptorSet(protos: [fileProto]) + let namer = + SwiftProtobufNamer( + currentFile: descriptorSet.fileDescriptor(named: "test.proto")!, + protoFileToModuleMappings: ProtoFileToModuleMappings() + ) + + let e = descriptorSet.enumDescriptor(named: "TestEnum")! + let values = e.values + XCTAssertEqual(values.count, 6) + + // Test relativeName(enumValue:) + + XCTAssertEqual(namer.relativeName(enumValue: values[0]), "foo") + XCTAssertEqual(namer.relativeName(enumValue: values[1]), "bar") + XCTAssertEqual(namer.relativeName(enumValue: values[2]), "foo") + XCTAssertEqual(namer.relativeName(enumValue: values[3]), "foo") + XCTAssertEqual(namer.relativeName(enumValue: values[4]), "foo") + XCTAssertEqual(namer.relativeName(enumValue: values[5]), "alias") } - let descriptorSet = DescriptorSet(protos: [fileProto]) - let namer = - SwiftProtobufNamer(currentFile: descriptorSet.lookupFileDescriptor(protoName: "test.proto"), - protoFileToModuleMappings: ProtoFileToModuleMappings()) - - let e = descriptorSet.lookupEnumDescriptor(protoName: ".TestEnum") - let values = e.values - XCTAssertEqual(values.count, 6) - - // Test relativeName(enumValue:) - - XCTAssertEqual(namer.relativeName(enumValue: values[0]), "foo") - XCTAssertEqual(namer.relativeName(enumValue: values[1]), "bar") - XCTAssertEqual(namer.relativeName(enumValue: values[2]), "foo") - XCTAssertEqual(namer.relativeName(enumValue: values[3]), "foo") - XCTAssertEqual(namer.relativeName(enumValue: values[4]), "foo") - XCTAssertEqual(namer.relativeName(enumValue: values[5]), "alias") - - // Test uniquelyNamedValues(enum:) - - let filtered = namer.uniquelyNamedValues(enum: e) - XCTAssertEqual(filtered.count, 3) - - XCTAssertEqual(filtered[0].name, "TEST_ENUM_FOO") - XCTAssertEqual(filtered[1].name, "TEST_ENUM_BAR") - XCTAssertEqual(filtered[2].name, "TEST_ENUM_ALIAS") - XCTAssertEqual(namer.relativeName(enumValue: filtered[0]), "foo") - XCTAssertEqual(namer.relativeName(enumValue: filtered[1]), "bar") - XCTAssertEqual(namer.relativeName(enumValue: filtered[2]), "alias") - } - - func testEnumValueHandling_NameCollisions() { - let txt = [ - "name: \"test.proto\"", - "syntax: \"proto2\"", - "enum_type {", - " name: \"TestEnum\"", - " value {", - " name: \"TEST_ENUM_FOO\"", - " number: 0", // Collision - " }", - " value {", - " name: \"TEST_ENUM_BAR\"", - " number: 1", - " }", - " value {", - " name: \"TESTENUM_FOO\"", - " number: 2", // Collision - " }", - " value {", - " name: \"_FOO\"", - " number: -1", // Collision - negative value - " }", - "}" - ] - - let fileProto: Google_Protobuf_FileDescriptorProto - do { - fileProto = try Google_Protobuf_FileDescriptorProto(textFormatStrings: txt) - } catch let e { - XCTFail("Error: \(e)") - return + func testEnumValueHandling_NameCollisions() { + let txt = [ + "name: \"test.proto\"", + "syntax: \"proto2\"", + "enum_type {", + " name: \"TestEnum\"", + " value {", + " name: \"TEST_ENUM_FOO\"", + " number: 0", // Collision + " }", + " value {", + " name: \"TEST_ENUM_BAR\"", + " number: 1", + " }", + " value {", + " name: \"TESTENUM_FOO\"", + " number: 2", // Collision + " }", + " value {", + " name: \"_FOO\"", + " number: -1", // Collision - negative value + " }", + "}", + ] + + let fileProto: Google_Protobuf_FileDescriptorProto + do { + fileProto = try Google_Protobuf_FileDescriptorProto(textFormatStrings: txt) + } catch let e { + XCTFail("Error: \(e)") + return + } + + let descriptorSet = DescriptorSet(protos: [fileProto]) + let namer = + SwiftProtobufNamer( + currentFile: descriptorSet.fileDescriptor(named: "test.proto")!, + protoFileToModuleMappings: ProtoFileToModuleMappings() + ) + + let e = descriptorSet.enumDescriptor(named: "TestEnum")! + let values = e.values + XCTAssertEqual(values.count, 4) + + // Test relativeName(enumValue:) + + XCTAssertEqual(namer.relativeName(enumValue: values[0]), "foo_0") + XCTAssertEqual(namer.relativeName(enumValue: values[1]), "bar") + XCTAssertEqual(namer.relativeName(enumValue: values[2]), "foo_2") + XCTAssertEqual(namer.relativeName(enumValue: values[3]), "foo_n1") } - let descriptorSet = DescriptorSet(protos: [fileProto]) - let namer = - SwiftProtobufNamer(currentFile: descriptorSet.lookupFileDescriptor(protoName: "test.proto"), - protoFileToModuleMappings: ProtoFileToModuleMappings()) - - let e = descriptorSet.lookupEnumDescriptor(protoName: ".TestEnum") - let values = e.values - XCTAssertEqual(values.count, 4) - - // Test relativeName(enumValue:) - - XCTAssertEqual(namer.relativeName(enumValue: values[0]), "foo_0") - XCTAssertEqual(namer.relativeName(enumValue: values[1]), "bar") - XCTAssertEqual(namer.relativeName(enumValue: values[2]), "foo_2") - XCTAssertEqual(namer.relativeName(enumValue: values[3]), "foo_n1") - - // Test uniquelyNamedValues(enum:) - - let filtered = namer.uniquelyNamedValues(enum: e) - XCTAssertEqual(filtered.count, 4) - - XCTAssertEqual(filtered[0].name, "TEST_ENUM_FOO") - XCTAssertEqual(filtered[1].name, "TEST_ENUM_BAR") - XCTAssertEqual(filtered[2].name, "TESTENUM_FOO") - XCTAssertEqual(filtered[3].name, "_FOO") - XCTAssertEqual(namer.relativeName(enumValue: filtered[0]), "foo_0") - XCTAssertEqual(namer.relativeName(enumValue: filtered[1]), "bar") - XCTAssertEqual(namer.relativeName(enumValue: filtered[2]), "foo_2") - XCTAssertEqual(namer.relativeName(enumValue: filtered[3]), "foo_n1") - } - - func testEnumValueHandling_NameCollisionsAndAliasMatches() { - let txt = [ - "name: \"test.proto\"", - "syntax: \"proto2\"", - "enum_type {", - " name: \"TestEnum\"", - " options {", - " allow_alias: true", - " }", - " value {", - " name: \"TEST_ENUM_FOO\"", - " number: 0", // Collision/Primary0 - " }", - " value {", - " name: \"TEST_ENUM_BAR\"", - " number: 1", - " }", - " value {", - " name: \"TESTENUM_FOO\"", - " number: 0", // Alias 0 - " }", - " value {", - " name: \"_FOO\"", - " number: 2", // Collision/Primary2 - " }", - " value {", - " name: \"FOO\"", - " number: 2", // Alias 2 - " }", - " value {", - " name: \"TEST_ENUM_ALIAS\"", - " number: 0", // Alias 0 - Unique name - " }", - " value {", - " name: \"mumble\"", - " number: 1", // Alias 1 - Collision with next alias - " }", - " value {", - " name: \"MUMBLE\"", - " number: 0", // Alias 0 - Collision with previous alias - " }", - "}" - ] - - let fileProto: Google_Protobuf_FileDescriptorProto - do { - fileProto = try Google_Protobuf_FileDescriptorProto(textFormatStrings: txt) - } catch let e { - XCTFail("Error: \(e)") - return + func testEnumValueHandling_NameCollisionsAndAliasMatches() { + let txt = [ + "name: \"test.proto\"", + "syntax: \"proto2\"", + "enum_type {", + " name: \"TestEnum\"", + " options {", + " allow_alias: true", + " }", + " value {", + " name: \"TEST_ENUM_FOO\"", + " number: 0", // Collision/Primary0 + " }", + " value {", + " name: \"TEST_ENUM_BAR\"", + " number: 1", + " }", + " value {", + " name: \"TESTENUM_FOO\"", + " number: 0", // Alias 0 + " }", + " value {", + " name: \"_FOO\"", + " number: 2", // Collision/Primary2 + " }", + " value {", + " name: \"FOO\"", + " number: 2", // Alias 2 + " }", + " value {", + " name: \"TEST_ENUM_ALIAS\"", + " number: 0", // Alias 0 - Unique name + " }", + " value {", + " name: \"mumble\"", + " number: 1", // Alias 1 - Collision with next alias + " }", + " value {", + " name: \"MUMBLE\"", + " number: 0", // Alias 0 - Collision with previous alias + " }", + "}", + ] + + let fileProto: Google_Protobuf_FileDescriptorProto + do { + fileProto = try Google_Protobuf_FileDescriptorProto(textFormatStrings: txt) + } catch let e { + XCTFail("Error: \(e)") + return + } + + let descriptorSet = DescriptorSet(protos: [fileProto]) + let namer = + SwiftProtobufNamer( + currentFile: descriptorSet.fileDescriptor(named: "test.proto")!, + protoFileToModuleMappings: ProtoFileToModuleMappings() + ) + + let e = descriptorSet.enumDescriptor(named: "TestEnum")! + let values = e.values + XCTAssertEqual(values.count, 8) + + // Test relativeName(enumValue:) + + XCTAssertEqual(namer.relativeName(enumValue: values[0]), "foo_0") + XCTAssertEqual(namer.relativeName(enumValue: values[1]), "bar") + XCTAssertEqual(namer.relativeName(enumValue: values[2]), "foo_0") + XCTAssertEqual(namer.relativeName(enumValue: values[3]), "foo_2") + XCTAssertEqual(namer.relativeName(enumValue: values[4]), "foo_2") + XCTAssertEqual(namer.relativeName(enumValue: values[5]), "alias") + XCTAssertEqual(namer.relativeName(enumValue: values[6]), "mumble_1") + XCTAssertEqual(namer.relativeName(enumValue: values[7]), "mumble_0") } - let descriptorSet = DescriptorSet(protos: [fileProto]) - let namer = - SwiftProtobufNamer(currentFile: descriptorSet.lookupFileDescriptor(protoName: "test.proto"), - protoFileToModuleMappings: ProtoFileToModuleMappings()) - - let e = descriptorSet.lookupEnumDescriptor(protoName: ".TestEnum") - let values = e.values - XCTAssertEqual(values.count, 8) - - // Test relativeName(enumValue:) - - XCTAssertEqual(namer.relativeName(enumValue: values[0]), "foo_0") - XCTAssertEqual(namer.relativeName(enumValue: values[1]), "bar") - XCTAssertEqual(namer.relativeName(enumValue: values[2]), "foo_0") - XCTAssertEqual(namer.relativeName(enumValue: values[3]), "foo_2") - XCTAssertEqual(namer.relativeName(enumValue: values[4]), "foo_2") - XCTAssertEqual(namer.relativeName(enumValue: values[5]), "alias") - XCTAssertEqual(namer.relativeName(enumValue: values[6]), "mumble_1") - XCTAssertEqual(namer.relativeName(enumValue: values[7]), "mumble_0") - - // Test uniquelyNamedValues(enum:) - - let filtered = namer.uniquelyNamedValues(enum: e) - XCTAssertEqual(filtered.count, 6) - - XCTAssertEqual(filtered[0].name, "TEST_ENUM_FOO") - XCTAssertEqual(filtered[1].name, "TEST_ENUM_BAR") - XCTAssertEqual(filtered[2].name, "_FOO") - XCTAssertEqual(filtered[3].name, "TEST_ENUM_ALIAS") - XCTAssertEqual(filtered[4].name, "mumble") - XCTAssertEqual(filtered[5].name, "MUMBLE") - XCTAssertEqual(namer.relativeName(enumValue: filtered[0]), "foo_0") - XCTAssertEqual(namer.relativeName(enumValue: filtered[1]), "bar") - XCTAssertEqual(namer.relativeName(enumValue: filtered[2]), "foo_2") - XCTAssertEqual(namer.relativeName(enumValue: filtered[3]), "alias") - XCTAssertEqual(namer.relativeName(enumValue: filtered[4]), "mumble_1") - XCTAssertEqual(namer.relativeName(enumValue: filtered[5]), "mumble_0") - } - - func testEnumValueHandling_UniqueAliasNameCollisions() { - // Tests were the aliases collided in naming, but not with - // the original. - - let txt = [ - "name: \"test.proto\"", - "syntax: \"proto2\"", - "enum_type {", - " name: \"AliasedEnum\"", - " options {", - " allow_alias: true", - " }", - " value {", - " name: \"ALIAS_FOO\"", - " number: 0", - " }", - " value {", - " name: \"ALIAS_BAR\"", - " number: 1", - " }", - " value {", - " name: \"ALIAS_BAZ\"", - " number: 2", - " }", - " value {", - " name: \"QUX\"", - " number: 2", // short name merged with the next because they have the same value. - " }", - " value {", - " name: \"qux\"", - " number: 2", - " }", - " value {", - " name: \"bAz\"", - " number: 2", - " }", - "}" - ] - - let fileProto: Google_Protobuf_FileDescriptorProto - do { - fileProto = try Google_Protobuf_FileDescriptorProto(textFormatStrings: txt) - } catch let e { - XCTFail("Error: \(e)") - return + func testEnumValueHandling_UniqueAliasNameCollisions() { + // Tests were the aliases collided in naming, but not with + // the original. + + let txt = [ + "name: \"test.proto\"", + "syntax: \"proto2\"", + "enum_type {", + " name: \"AliasedEnum\"", + " options {", + " allow_alias: true", + " }", + " value {", + " name: \"ALIAS_FOO\"", + " number: 0", + " }", + " value {", + " name: \"ALIAS_BAR\"", + " number: 1", + " }", + " value {", + " name: \"ALIAS_BAZ\"", + " number: 2", + " }", + " value {", + " name: \"QUX\"", + " number: 2", // short name merged with the next because they have the same value. + " }", + " value {", + " name: \"qux\"", + " number: 2", + " }", + " value {", + " name: \"bAz\"", + " number: 2", + " }", + "}", + ] + + let fileProto: Google_Protobuf_FileDescriptorProto + do { + fileProto = try Google_Protobuf_FileDescriptorProto(textFormatStrings: txt) + } catch let e { + XCTFail("Error: \(e)") + return + } + + let descriptorSet = DescriptorSet(protos: [fileProto]) + let namer = + SwiftProtobufNamer( + currentFile: descriptorSet.fileDescriptor(named: "test.proto")!, + protoFileToModuleMappings: ProtoFileToModuleMappings() + ) + + let e = descriptorSet.enumDescriptor(named: "AliasedEnum")! + let values = e.values + XCTAssertEqual(values.count, 6) + + XCTAssertEqual(values[0].name, "ALIAS_FOO") + XCTAssertEqual(values[1].name, "ALIAS_BAR") + XCTAssertEqual(values[2].name, "ALIAS_BAZ") + XCTAssertEqual(values[3].name, "QUX") + XCTAssertEqual(values[4].name, "qux") + XCTAssertEqual(values[5].name, "bAz") + + // Test relativeName(enumValue:) + + XCTAssertEqual(namer.relativeName(enumValue: values[0]), "aliasFoo") + XCTAssertEqual(namer.relativeName(enumValue: values[1]), "aliasBar") + XCTAssertEqual(namer.relativeName(enumValue: values[2]), "aliasBaz") + XCTAssertEqual(namer.relativeName(enumValue: values[3]), "qux") + XCTAssertEqual(namer.relativeName(enumValue: values[4]), "qux") + XCTAssertEqual(namer.relativeName(enumValue: values[5]), "bAz") } - let descriptorSet = DescriptorSet(protos: [fileProto]) - let namer = - SwiftProtobufNamer(currentFile: descriptorSet.lookupFileDescriptor(protoName: "test.proto"), - protoFileToModuleMappings: ProtoFileToModuleMappings()) - - let e = descriptorSet.lookupEnumDescriptor(protoName: ".AliasedEnum") - let values = e.values - XCTAssertEqual(values.count, 6) - - XCTAssertEqual(values[0].name, "ALIAS_FOO") - XCTAssertEqual(values[1].name, "ALIAS_BAR") - XCTAssertEqual(values[2].name, "ALIAS_BAZ") - XCTAssertEqual(values[3].name, "QUX") - XCTAssertEqual(values[4].name, "qux") - XCTAssertEqual(values[5].name, "bAz") - - // Test relativeName(enumValue:) - - XCTAssertEqual(namer.relativeName(enumValue: values[0]), "aliasFoo") - XCTAssertEqual(namer.relativeName(enumValue: values[1]), "aliasBar") - XCTAssertEqual(namer.relativeName(enumValue: values[2]), "aliasBaz") - XCTAssertEqual(namer.relativeName(enumValue: values[3]), "qux") - XCTAssertEqual(namer.relativeName(enumValue: values[4]), "qux") - XCTAssertEqual(namer.relativeName(enumValue: values[5]), "bAz") - - // Test uniquelyNamedValues(enum:) - - // QUX & qux collided, so only one remains. - - let filtered = namer.uniquelyNamedValues(enum: e) - XCTAssertEqual(filtered.count, 5) - - XCTAssertEqual(filtered[0].name, "ALIAS_FOO") - XCTAssertEqual(filtered[1].name, "ALIAS_BAR") - XCTAssertEqual(filtered[2].name, "ALIAS_BAZ") - XCTAssertEqual(filtered[3].name, "QUX") - XCTAssertEqual(filtered[4].name, "bAz") - XCTAssertEqual(namer.relativeName(enumValue: filtered[0]), "aliasFoo") - XCTAssertEqual(namer.relativeName(enumValue: filtered[1]), "aliasBar") - XCTAssertEqual(namer.relativeName(enumValue: filtered[2]), "aliasBaz") - XCTAssertEqual(namer.relativeName(enumValue: filtered[3]), "qux") - XCTAssertEqual(namer.relativeName(enumValue: filtered[4]), "bAz") - } - } diff --git a/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_delimited.pb.swift b/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_delimited.pb.swift new file mode 100644 index 000000000..cc9c8b132 --- /dev/null +++ b/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_delimited.pb.swift @@ -0,0 +1,188 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: pluginlib_descriptor_delimited.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 - 2024 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 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 SwiftDescriptorTest_EditionsMessageForDelimited: @unchecked Sendable { + // 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 scalarField: Int32 { + get {_storage._scalarField ?? 0} + set {_uniqueStorage()._scalarField = newValue} + } + /// Returns true if `scalarField` has been explicitly set. + var hasScalarField: Bool {_storage._scalarField != nil} + /// Clears the value of `scalarField`. Subsequent reads from it will return its default value. + mutating func clearScalarField() {_uniqueStorage()._scalarField = nil} + + var mapField: Dictionary { + get {_storage._mapField} + set {_uniqueStorage()._mapField = newValue} + } + + var messageMapField: Dictionary { + get {_storage._messageMapField} + set {_uniqueStorage()._messageMapField = newValue} + } + + var delimitedField: SwiftDescriptorTest_EditionsMessageForDelimited { + get {_storage._delimitedField ?? SwiftDescriptorTest_EditionsMessageForDelimited()} + set {_uniqueStorage()._delimitedField = newValue} + } + /// Returns true if `delimitedField` has been explicitly set. + var hasDelimitedField: Bool {_storage._delimitedField != nil} + /// Clears the value of `delimitedField`. Subsequent reads from it will return its default value. + mutating func clearDelimitedField() {_uniqueStorage()._delimitedField = nil} + + var lengthPrefixedField: SwiftDescriptorTest_EditionsMessageForDelimited { + get {_storage._lengthPrefixedField ?? SwiftDescriptorTest_EditionsMessageForDelimited()} + set {_uniqueStorage()._lengthPrefixedField = newValue} + } + /// Returns true if `lengthPrefixedField` has been explicitly set. + var hasLengthPrefixedField: Bool {_storage._lengthPrefixedField != nil} + /// Clears the value of `lengthPrefixedField`. Subsequent reads from it will return its default value. + mutating func clearLengthPrefixedField() {_uniqueStorage()._lengthPrefixedField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_descriptor_test" + +extension SwiftDescriptorTest_EditionsMessageForDelimited: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".EditionsMessageForDelimited" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}scalar_field\0\u{3}map_field\0\u{3}message_map_field\0\u{3}delimited_field\0\u{3}length_prefixed_field\0") + + fileprivate class _StorageClass { + var _scalarField: Int32? = nil + var _mapField: Dictionary = [:] + var _messageMapField: Dictionary = [:] + var _delimitedField: SwiftDescriptorTest_EditionsMessageForDelimited? = nil + var _lengthPrefixedField: SwiftDescriptorTest_EditionsMessageForDelimited? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _scalarField = source._scalarField + _mapField = source._mapField + _messageMapField = source._messageMapField + _delimitedField = source._delimitedField + _lengthPrefixedField = source._lengthPrefixedField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._scalarField) }() + case 2: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapField) }() + case 3: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._messageMapField) }() + case 4: try { try decoder.decodeSingularGroupField(value: &_storage._delimitedField) }() + case 5: try { try decoder.decodeSingularMessageField(value: &_storage._lengthPrefixedField) }() + default: break + } + } + } + } + + func traverse(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._scalarField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + if !_storage._mapField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapField, fieldNumber: 2) + } + if !_storage._messageMapField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._messageMapField, fieldNumber: 3) + } + try { if let v = _storage._delimitedField { + try visitor.visitSingularGroupField(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._lengthPrefixedField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 5) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftDescriptorTest_EditionsMessageForDelimited, rhs: SwiftDescriptorTest_EditionsMessageForDelimited) -> 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._scalarField != rhs_storage._scalarField {return false} + if _storage._mapField != rhs_storage._mapField {return false} + if _storage._messageMapField != rhs_storage._messageMapField {return false} + if _storage._delimitedField != rhs_storage._delimitedField {return false} + if _storage._lengthPrefixedField != rhs_storage._lengthPrefixedField {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test.pb.swift b/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test.pb.swift new file mode 100644 index 000000000..0d4e2ee32 --- /dev/null +++ b/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test.pb.swift @@ -0,0 +1,1012 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// 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 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: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case valueZero = 0 + case valueOne = 1 + case valueTwo = 2 + + init() { + self = .valueZero + } + +} + +struct SDTTopLevelMessage: @unchecked Sendable { + // 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 {_storage._field1 ?? String()} + set {_uniqueStorage()._field1 = newValue} + } + /// Returns true if `field1` has been explicitly set. + var hasField1: Bool {_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 {_storage._field2 ?? 0} + set {_uniqueStorage()._field2 = newValue} + } + /// Returns true if `field2` has been explicitly set. + var hasField2: Bool {_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, Sendable { + case field3(SDTTopLevelEnum) + case field4(SDTTopLevelMessage.SubEnum) + case field5(SDTTopLevelMessage.SubMessage) + case field6(SDTTopLevelMessage2) + + } + + enum SubEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case subValue0 = 0 + case subValue1 = 1 + case subValue2 = 2 + + init() { + self = .subValue0 + } + + } + + struct SubMessage: @unchecked Sendable { + // 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 {_storage._field1 ?? 0} + set {_uniqueStorage()._field1 = newValue} + } + /// Returns true if `field1` has been explicitly set. + var hasField1: Bool {_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 {_storage._field2 ?? String()} + set {_uniqueStorage()._field2 = newValue} + } + /// Returns true if `field2` has been explicitly set. + var hasField2: Bool {_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 {_storage._field3 ?? SDTTopLevelMessage.SubMessage()} + set {_uniqueStorage()._field3 = newValue} + } + /// Returns true if `field3` has been explicitly set. + var hasField3: Bool {_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 +} + +struct SDTTopLevelMessage2: @unchecked Sendable { + // 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 {_storage._left ?? SDTTopLevelMessage()} + set {_uniqueStorage()._left = newValue} + } + /// Returns true if `left` has been explicitly set. + var hasLeft: Bool {_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 {_storage._right ?? SDTTopLevelMessage2()} + set {_uniqueStorage()._right = newValue} + } + /// Returns true if `right` has been explicitly set. + var hasRight: Bool {_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: Sendable { + // 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 one: SwiftDescriptorTest_Import_ExtendableOne { + get {_one ?? SwiftDescriptorTest_Import_ExtendableOne()} + set {_one = newValue} + } + /// Returns true if `one` has been explicitly set. + var hasOne: Bool {self._one != nil} + /// Clears the value of `one`. Subsequent reads from it will return its default value. + mutating func clearOne() {self._one = nil} + + var ver: SwiftDescriptorTest_Import_Version { + get {_ver ?? SwiftDescriptorTest_Import_Version()} + set {_ver = newValue} + } + /// Returns true if `ver` has been explicitly set. + var hasVer: Bool {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 _one: SwiftDescriptorTest_Import_ExtendableOne? = nil + fileprivate var _ver: SwiftDescriptorTest_Import_Version? = nil +} + +struct SDTScoperForExt: Sendable { + // 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: Sendable { + // 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 {_reqStrField ?? String()} + set {_reqStrField = newValue} + } + /// Returns true if `reqStrField` has been explicitly set. + var hasReqStrField: Bool {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 {_reqInt32Field ?? 0} + set {_reqInt32Field = newValue} + } + /// Returns true if `reqInt32Field` has been explicitly set. + var hasReqInt32Field: Bool {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 {_reqEnumField ?? .valueZero} + set {_reqEnumField = newValue} + } + /// Returns true if `reqEnumField` has been explicitly set. + var hasReqEnumField: Bool {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 {_reqMessageField ?? SDTTopLevelMessage()} + set {_reqMessageField = newValue} + } + /// Returns true if `reqMessageField` has been explicitly set. + var hasReqMessageField: Bool {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 {_optStrField ?? String()} + set {_optStrField = newValue} + } + /// Returns true if `optStrField` has been explicitly set. + var hasOptStrField: Bool {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 {_optInt32Field ?? 0} + set {_optInt32Field = newValue} + } + /// Returns true if `optInt32Field` has been explicitly set. + var hasOptInt32Field: Bool {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 {_optEnumField ?? .valueZero} + set {_optEnumField = newValue} + } + /// Returns true if `optEnumField` has been explicitly set. + var hasOptEnumField: Bool {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 {_optMessageField ?? SDTTopLevelMessage()} + set {_optMessageField = newValue} + } + /// Returns true if `optMessageField` has been explicitly set. + var hasOptMessageField: Bool {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, Sendable { + case oneofStrField(String) + case oneofInt32Field(Int32) + case oneofEnumField(SDTTopLevelEnum) + case oneofMessageField(SDTTopLevelMessage) + + } + + 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 +} + +// MARK: - Extension support defined in pluginlib_descriptor_test.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 SwiftDescriptorTest_Import_ExtendableOne { + + 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 SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo { + + 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, SwiftDescriptorTest_Import_ExtendableOne>( + _protobuf_fieldNumber: 90000, + fieldName: "swift_descriptor_test.ext_str" +) + +extension SDTScoperForExt { + enum Extensions { + static let ext_enum = SwiftProtobuf.MessageExtension, SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo>( + _protobuf_fieldNumber: 99001, + fieldName: "swift_descriptor_test.ScoperForExt.ext_enum" + ) + + static let ext_msg = SwiftProtobuf.MessageExtension, SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo>( + _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(bytecode: "\0\u{2}\0VALUE_ZERO\0\u{1}VALUE_ONE\0\u{1}VALUE_TWO\0") +} + +extension SDTTopLevelMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TopLevelMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field1\0\u{1}field2\0\u{1}field3\0\u{1}field4\0\u{1}field5\0\u{1}field6\0") + + fileprivate class _StorageClass { + var _field1: String? = nil + var _field2: Int32? = nil + var _o: SDTTopLevelMessage.OneOf_O? + + // 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() + + 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(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(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(bytecode: "\0\u{2}\0SUB_VALUE_0\0\u{1}SUB_VALUE_1\0\u{1}SUB_VALUE_2\0") +} + +extension SDTTopLevelMessage.SubMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SDTTopLevelMessage.protoMessageName + ".SubMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field1\0\u{1}field2\0\u{1}field3\0") + + fileprivate class _StorageClass { + var _field1: Int32? = nil + var _field2: String? = nil + var _field3: SDTTopLevelMessage.SubMessage? = nil + + // 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() + + 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(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(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(bytecode: "\0\u{1}left\0\u{1}right\0") + + fileprivate class _StorageClass { + var _left: SDTTopLevelMessage? = nil + var _right: SDTTopLevelMessage2? = nil + + // 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() + + 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(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(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(bytecode: "\0\u{1}one\0\u{1}ver\0") + + public var isInitialized: Bool { + if let v = self._one, !v.isInitialized {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._one) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._ver) }() + 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 + try { if let v = self._one { + 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._one != rhs._one {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(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(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(bytecode: "\0\u{3}req_str_field\0\u{3}req_int32_field\0\u{3}req_enum_field\0\u{3}req_message_field\0\u{4}\u{7}opt_str_field\0\u{3}opt_int32_field\0\u{3}opt_enum_field\0\u{3}opt_message_field\0\u{4}\u{7}repeat_str_field\0\u{3}repeat_int32_field\0\u{3}repeat_enum_field\0\u{3}repeat_message_field\0\u{4}\u{7}oneof_str_field\0\u{3}oneof_int32_field\0\u{3}oneof_enum_field\0\u{3}oneof_message_field\0") + + 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(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(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 + } +} diff --git a/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test2.pb.swift b/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test2.pb.swift new file mode 100644 index 000000000..13075892e --- /dev/null +++ b/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test2.pb.swift @@ -0,0 +1,388 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: pluginlib_descriptor_test2.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 - 2020 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 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 SwiftDescriptorTest_Proto3MessageForPresence: Sendable { + // 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 strField: String = String() + + var int32Field: Int32 = 0 + + var enumField: SwiftDescriptorTest_Proto3MessageForPresence.SubEnum = .subValue0 + + var messageField: SwiftDescriptorTest_OtherMessage { + get {_messageField ?? SwiftDescriptorTest_OtherMessage()} + set {_messageField = newValue} + } + /// Returns true if `messageField` has been explicitly set. + var hasMessageField: Bool {self._messageField != nil} + /// Clears the value of `messageField`. Subsequent reads from it will return its default value. + mutating func clearMessageField() {self._messageField = nil} + + var optStrField: String { + get {_optStrField ?? String()} + set {_optStrField = newValue} + } + /// Returns true if `optStrField` has been explicitly set. + var hasOptStrField: Bool {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 {_optInt32Field ?? 0} + set {_optInt32Field = newValue} + } + /// Returns true if `optInt32Field` has been explicitly set. + var hasOptInt32Field: Bool {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: SwiftDescriptorTest_Proto3MessageForPresence.SubEnum { + get {_optEnumField ?? .subValue0} + set {_optEnumField = newValue} + } + /// Returns true if `optEnumField` has been explicitly set. + var hasOptEnumField: Bool {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: SwiftDescriptorTest_OtherMessage { + get {_optMessageField ?? SwiftDescriptorTest_OtherMessage()} + set {_optMessageField = newValue} + } + /// Returns true if `optMessageField` has been explicitly set. + var hasOptMessageField: Bool {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: [SwiftDescriptorTest_Proto3MessageForPresence.SubEnum] = [] + + var repeatMessageField: [SwiftDescriptorTest_OtherMessage] = [] + + var o: SwiftDescriptorTest_Proto3MessageForPresence.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: SwiftDescriptorTest_Proto3MessageForPresence.SubEnum { + get { + if case .oneofEnumField(let v)? = o {return v} + return .subValue0 + } + set {o = .oneofEnumField(newValue)} + } + + var oneofMessageField: SwiftDescriptorTest_OtherMessage { + get { + if case .oneofMessageField(let v)? = o {return v} + return SwiftDescriptorTest_OtherMessage() + } + set {o = .oneofMessageField(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_O: Equatable, Sendable { + case oneofStrField(String) + case oneofInt32Field(Int32) + case oneofEnumField(SwiftDescriptorTest_Proto3MessageForPresence.SubEnum) + case oneofMessageField(SwiftDescriptorTest_OtherMessage) + + } + + enum SubEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case subValue0 // = 0 + case subValue1 // = 1 + case subValue2 // = 2 + case UNRECOGNIZED(Int) + + init() { + self = .subValue0 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .subValue0 + case 1: self = .subValue1 + case 2: self = .subValue2 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .subValue0: return 0 + case .subValue1: return 1 + case .subValue2: return 2 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftDescriptorTest_Proto3MessageForPresence.SubEnum] = [ + .subValue0, + .subValue1, + .subValue2, + ] + + } + + init() {} + + fileprivate var _messageField: SwiftDescriptorTest_OtherMessage? = nil + fileprivate var _optStrField: String? = nil + fileprivate var _optInt32Field: Int32? = nil + fileprivate var _optEnumField: SwiftDescriptorTest_Proto3MessageForPresence.SubEnum? = nil + fileprivate var _optMessageField: SwiftDescriptorTest_OtherMessage? = nil +} + +struct SwiftDescriptorTest_OtherMessage: Sendable { + // 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 field: String = String() + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_descriptor_test" + +extension SwiftDescriptorTest_Proto3MessageForPresence: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Proto3MessageForPresence" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}str_field\0\u{3}int32_field\0\u{3}enum_field\0\u{3}message_field\0\u{4}\u{7}opt_str_field\0\u{3}opt_int32_field\0\u{3}opt_enum_field\0\u{3}opt_message_field\0\u{4}\u{7}repeat_str_field\0\u{3}repeat_int32_field\0\u{3}repeat_enum_field\0\u{3}repeat_message_field\0\u{4}\u{7}oneof_str_field\0\u{3}oneof_int32_field\0\u{3}oneof_enum_field\0\u{3}oneof_message_field\0") + + 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.strField) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self.int32Field) }() + case 3: try { try decoder.decodeSingularEnumField(value: &self.enumField) }() + case 4: try { try decoder.decodeSingularMessageField(value: &self._messageField) }() + 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: SwiftDescriptorTest_Proto3MessageForPresence.SubEnum? + 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: SwiftDescriptorTest_OtherMessage? + 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(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 + if !self.strField.isEmpty { + try visitor.visitSingularStringField(value: self.strField, fieldNumber: 1) + } + if self.int32Field != 0 { + try visitor.visitSingularInt32Field(value: self.int32Field, fieldNumber: 2) + } + if self.enumField != .subValue0 { + try visitor.visitSingularEnumField(value: self.enumField, fieldNumber: 3) + } + try { if let v = self._messageField { + 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.visitPackedInt32Field(value: self.repeatInt32Field, fieldNumber: 22) + } + if !self.repeatEnumField.isEmpty { + try visitor.visitPackedEnumField(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: SwiftDescriptorTest_Proto3MessageForPresence, rhs: SwiftDescriptorTest_Proto3MessageForPresence) -> Bool { + if lhs.strField != rhs.strField {return false} + if lhs.int32Field != rhs.int32Field {return false} + if lhs.enumField != rhs.enumField {return false} + if lhs._messageField != rhs._messageField {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 SwiftDescriptorTest_Proto3MessageForPresence.SubEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0SUB_VALUE_0\0\u{1}SUB_VALUE_1\0\u{1}SUB_VALUE_2\0") +} + +extension SwiftDescriptorTest_OtherMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OtherMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field\0") + + 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.field) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.field.isEmpty { + try visitor.visitSingularStringField(value: self.field, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftDescriptorTest_OtherMessage, rhs: SwiftDescriptorTest_OtherMessage) -> Bool { + if lhs.field != rhs.field {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test_import.pb.swift b/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test_import.pb.swift new file mode 100644 index 000000000..87529f161 --- /dev/null +++ b/Tests/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test_import.pb.swift @@ -0,0 +1,248 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: pluginlib_descriptor_test_import.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protos/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test_import.proto - test proto +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2024 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 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 SwiftDescriptorTest_Import_Version: Sendable { + // 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 major: Int32 { + get {_major ?? 0} + set {_major = newValue} + } + /// Returns true if `major` has been explicitly set. + var hasMajor: Bool {self._major != nil} + /// Clears the value of `major`. Subsequent reads from it will return its default value. + mutating func clearMajor() {self._major = nil} + + var minor: Int32 { + get {_minor ?? 0} + set {_minor = newValue} + } + /// Returns true if `minor` has been explicitly set. + var hasMinor: Bool {self._minor != nil} + /// Clears the value of `minor`. Subsequent reads from it will return its default value. + mutating func clearMinor() {self._minor = nil} + + var patch: Int32 { + get {_patch ?? 0} + set {_patch = newValue} + } + /// Returns true if `patch` has been explicitly set. + var hasPatch: Bool {self._patch != nil} + /// Clears the value of `patch`. Subsequent reads from it will return its default value. + mutating func clearPatch() {self._patch = nil} + + var suffix: String { + get {_suffix ?? String()} + set {_suffix = newValue} + } + /// Returns true if `suffix` has been explicitly set. + var hasSuffix: Bool {self._suffix != nil} + /// Clears the value of `suffix`. Subsequent reads from it will return its default value. + mutating func clearSuffix() {self._suffix = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _major: Int32? = nil + fileprivate var _minor: Int32? = nil + fileprivate var _patch: Int32? = nil + fileprivate var _suffix: String? = nil +} + +struct SwiftDescriptorTest_Import_ExtendableOne: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 subMsgField: SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo { + get {_subMsgField ?? SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo()} + set {_subMsgField = newValue} + } + /// Returns true if `subMsgField` has been explicitly set. + var hasSubMsgField: Bool {self._subMsgField != nil} + /// Clears the value of `subMsgField`. Subsequent reads from it will return its default value. + mutating func clearSubMsgField() {self._subMsgField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct ExtendableTwo: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _subMsgField: SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_descriptor_test.import" + +extension SwiftDescriptorTest_Import_Version: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".Version" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}major\0\u{1}minor\0\u{1}patch\0\u{1}suffix\0") + + 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._major) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._minor) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._patch) }() + case 4: try { try decoder.decodeSingularStringField(value: &self._suffix) }() + 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 + try { if let v = self._major { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._minor { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = self._patch { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = self._suffix { + try visitor.visitSingularStringField(value: v, fieldNumber: 4) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftDescriptorTest_Import_Version, rhs: SwiftDescriptorTest_Import_Version) -> Bool { + if lhs._major != rhs._major {return false} + if lhs._minor != rhs._minor {return false} + if lhs._patch != rhs._patch {return false} + if lhs._suffix != rhs._suffix {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftDescriptorTest_Import_ExtendableOne: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ExtendableOne" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}sub_msg_field\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + if let v = self._subMsgField, !v.isInitialized {return false} + return true + } + + 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.decodeSingularMessageField(value: &self._subMsgField) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftDescriptorTest_Import_ExtendableOne.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._subMsgField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftDescriptorTest_Import_ExtendableOne, rhs: SwiftDescriptorTest_Import_ExtendableOne) -> Bool { + if lhs._subMsgField != rhs._subMsgField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftDescriptorTest_Import_ExtendableOne.protoMessageName + ".ExtendableTwo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1000 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo, rhs: SwiftDescriptorTest_Import_ExtendableOne.ExtendableTwo) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} diff --git a/Tests/SwiftProtobufPluginLibraryTests/test_features.pb.swift b/Tests/SwiftProtobufPluginLibraryTests/test_features.pb.swift new file mode 100644 index 000000000..de52d9b5f --- /dev/null +++ b/Tests/SwiftProtobufPluginLibraryTests/test_features.pb.swift @@ -0,0 +1,218 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: test_features.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protos/SwiftProtobufPluginLibraryTests/test_features.proto - test proto for Features +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2024 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 +// +// ----------------------------------------------------------------------------- + +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 SwiftFeatureTest_TestFeatures: Sendable { + // 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 feature1: SwiftFeatureTest_TestFeatures.EnumFeature { + get {_feature1 ?? .unknown} + set {_feature1 = newValue} + } + /// Returns true if `feature1` has been explicitly set. + var hasFeature1: Bool {self._feature1 != nil} + /// Clears the value of `feature1`. Subsequent reads from it will return its default value. + mutating func clearFeature1() {self._feature1 = nil} + + var feature2: SwiftFeatureTest_TestFeatures.EnumFeature { + get {_feature2 ?? .unknown} + set {_feature2 = newValue} + } + /// Returns true if `feature2` has been explicitly set. + var hasFeature2: Bool {self._feature2 != nil} + /// Clears the value of `feature2`. Subsequent reads from it will return its default value. + mutating func clearFeature2() {self._feature2 = nil} + + var feature3: SwiftFeatureTest_TestFeatures.EnumFeature { + get {_feature3 ?? .unknown} + set {_feature3 = newValue} + } + /// Returns true if `feature3` has been explicitly set. + var hasFeature3: Bool {self._feature3 != nil} + /// Clears the value of `feature3`. Subsequent reads from it will return its default value. + mutating func clearFeature3() {self._feature3 = nil} + + var feature4: SwiftFeatureTest_TestFeatures.EnumFeature { + get {_feature4 ?? .unknown} + set {_feature4 = newValue} + } + /// Returns true if `feature4` has been explicitly set. + var hasFeature4: Bool {self._feature4 != nil} + /// Clears the value of `feature4`. Subsequent reads from it will return its default value. + mutating func clearFeature4() {self._feature4 = nil} + + var feature5: SwiftFeatureTest_TestFeatures.EnumFeature { + get {_feature5 ?? .unknown} + set {_feature5 = newValue} + } + /// Returns true if `feature5` has been explicitly set. + var hasFeature5: Bool {self._feature5 != nil} + /// Clears the value of `feature5`. Subsequent reads from it will return its default value. + mutating func clearFeature5() {self._feature5 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum EnumFeature: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case unknown = 0 + case value1 = 1 + case value2 = 2 + case value3 = 3 + case value4 = 4 + case value5 = 5 + case value6 = 6 + + init() { + self = .unknown + } + + } + + init() {} + + fileprivate var _feature1: SwiftFeatureTest_TestFeatures.EnumFeature? = nil + fileprivate var _feature2: SwiftFeatureTest_TestFeatures.EnumFeature? = nil + fileprivate var _feature3: SwiftFeatureTest_TestFeatures.EnumFeature? = nil + fileprivate var _feature4: SwiftFeatureTest_TestFeatures.EnumFeature? = nil + fileprivate var _feature5: SwiftFeatureTest_TestFeatures.EnumFeature? = nil +} + +// MARK: - Extension support defined in test_features.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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_FeatureSet { + + var SwiftFeatureTest_test: SwiftFeatureTest_TestFeatures { + get {return getExtensionValue(ext: SwiftFeatureTest_Extensions_test) ?? SwiftFeatureTest_TestFeatures()} + set {setExtensionValue(ext: SwiftFeatureTest_Extensions_test, value: newValue)} + } + /// Returns true if extension `SwiftFeatureTest_Extensions_test` + /// has been explicitly set. + var hasSwiftFeatureTest_test: Bool { + return hasExtensionValue(ext: SwiftFeatureTest_Extensions_test) + } + /// Clears the value of extension `SwiftFeatureTest_Extensions_test`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftFeatureTest_test() { + clearExtensionValue(ext: SwiftFeatureTest_Extensions_test) + } + +} + +// MARK: - File's ExtensionMap: SwiftFeatureTest_TestFeatures_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 SwiftFeatureTest_TestFeatures_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftFeatureTest_Extensions_test +] + +// 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 SwiftFeatureTest_Extensions_test = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FeatureSet>( + _protobuf_fieldNumber: 9999, + fieldName: "swift_feature_test.test" +) + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_feature_test" + +extension SwiftFeatureTest_TestFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}feature1\0\u{1}feature2\0\u{1}feature3\0\u{1}feature4\0\u{1}feature5\0") + + 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._feature1) }() + case 2: try { try decoder.decodeSingularEnumField(value: &self._feature2) }() + case 3: try { try decoder.decodeSingularEnumField(value: &self._feature3) }() + case 4: try { try decoder.decodeSingularEnumField(value: &self._feature4) }() + case 5: try { try decoder.decodeSingularEnumField(value: &self._feature5) }() + 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 + try { if let v = self._feature1 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 1) + } }() + try { if let v = self._feature2 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 2) + } }() + try { if let v = self._feature3 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 3) + } }() + try { if let v = self._feature4 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 4) + } }() + try { if let v = self._feature5 { + try visitor.visitSingularEnumField(value: v, fieldNumber: 5) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftFeatureTest_TestFeatures, rhs: SwiftFeatureTest_TestFeatures) -> Bool { + if lhs._feature1 != rhs._feature1 {return false} + if lhs._feature2 != rhs._feature2 {return false} + if lhs._feature3 != rhs._feature3 {return false} + if lhs._feature4 != rhs._feature4 {return false} + if lhs._feature5 != rhs._feature5 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftFeatureTest_TestFeatures.EnumFeature: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ENUM_FEATURE_UNKNOWN\0\u{1}ENUM_FEATURE_VALUE1\0\u{1}ENUM_FEATURE_VALUE2\0\u{1}ENUM_FEATURE_VALUE3\0\u{1}ENUM_FEATURE_VALUE4\0\u{1}ENUM_FEATURE_VALUE5\0\u{1}ENUM_FEATURE_VALUE6\0") +} diff --git a/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited.pb.swift b/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited.pb.swift new file mode 100644 index 000000000..bba777128 --- /dev/null +++ b/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited.pb.swift @@ -0,0 +1,706 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: unittest_delimited.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +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 EditionsUnittest_LengthPrefixed: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil +} + +struct EditionsUnittest_NotGroupLikeScope: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil +} + +struct EditionsUnittest_GroupLikeFileScope: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil +} + +struct EditionsUnittest_TestDelimited: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Non-delimited field that otherwise looks group-like. + var lengthprefixed: EditionsUnittest_TestDelimited.LengthPrefixed { + get {_storage._lengthprefixed ?? EditionsUnittest_TestDelimited.LengthPrefixed()} + set {_uniqueStorage()._lengthprefixed = newValue} + } + /// Returns true if `lengthprefixed` has been explicitly set. + var hasLengthprefixed: Bool {_storage._lengthprefixed != nil} + /// Clears the value of `lengthprefixed`. Subsequent reads from it will return its default value. + mutating func clearLengthprefixed() {_uniqueStorage()._lengthprefixed = nil} + + /// Nested field for nested tests. + var nested: EditionsUnittest_TestDelimited { + get {_storage._nested ?? EditionsUnittest_TestDelimited()} + set {_uniqueStorage()._nested = newValue} + } + /// Returns true if `nested` has been explicitly set. + var hasNested: Bool {_storage._nested != nil} + /// Clears the value of `nested`. Subsequent reads from it will return its default value. + mutating func clearNested() {_uniqueStorage()._nested = nil} + + /// Truly group-like field. + var groupLike: EditionsUnittest_TestDelimited.GroupLike { + get {_storage._groupLike ?? EditionsUnittest_TestDelimited.GroupLike()} + set {_uniqueStorage()._groupLike = newValue} + } + /// Returns true if `groupLike` has been explicitly set. + var hasGroupLike: Bool {_storage._groupLike != nil} + /// Clears the value of `groupLike`. Subsequent reads from it will return its default value. + mutating func clearGroupLike() {_uniqueStorage()._groupLike = nil} + + /// Delimited field that isn't group-like solely because of its name. + var notgrouplike: EditionsUnittest_TestDelimited.GroupLike { + get {_storage._notgrouplike ?? EditionsUnittest_TestDelimited.GroupLike()} + set {_uniqueStorage()._notgrouplike = newValue} + } + /// Returns true if `notgrouplike` has been explicitly set. + var hasNotgrouplike: Bool {_storage._notgrouplike != nil} + /// Clears the value of `notgrouplike`. Subsequent reads from it will return its default value. + mutating func clearNotgrouplike() {_uniqueStorage()._notgrouplike = nil} + + /// Delimited field that isn't group-like because of the scope of its type. + var notgrouplikescope: EditionsUnittest_NotGroupLikeScope { + get {_storage._notgrouplikescope ?? EditionsUnittest_NotGroupLikeScope()} + set {_uniqueStorage()._notgrouplikescope = newValue} + } + /// Returns true if `notgrouplikescope` has been explicitly set. + var hasNotgrouplikescope: Bool {_storage._notgrouplikescope != nil} + /// Clears the value of `notgrouplikescope`. Subsequent reads from it will return its default value. + mutating func clearNotgrouplikescope() {_uniqueStorage()._notgrouplikescope = nil} + + /// Delimited field that's grouplike except that it's an imported type. + var messageimport: EditionsUnittest_MessageImport { + get {_storage._messageimport ?? EditionsUnittest_MessageImport()} + set {_uniqueStorage()._messageimport = newValue} + } + /// Returns true if `messageimport` has been explicitly set. + var hasMessageimport: Bool {_storage._messageimport != nil} + /// Clears the value of `messageimport`. Subsequent reads from it will return its default value. + mutating func clearMessageimport() {_uniqueStorage()._messageimport = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct LengthPrefixed: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil + } + + struct GroupLike: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil + } + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Extension support defined in unittest_delimited.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 EditionsUnittest_TestDelimited { + + /// Non-delimited field that otherwise looks group-like. + var EditionsUnittest_lengthprefixed: EditionsUnittest_LengthPrefixed { + get {return getExtensionValue(ext: EditionsUnittest_Extensions_lengthprefixed) ?? EditionsUnittest_LengthPrefixed()} + set {setExtensionValue(ext: EditionsUnittest_Extensions_lengthprefixed, value: newValue)} + } + /// Returns true if extension `EditionsUnittest_Extensions_lengthprefixed` + /// has been explicitly set. + var hasEditionsUnittest_lengthprefixed: Bool { + return hasExtensionValue(ext: EditionsUnittest_Extensions_lengthprefixed) + } + /// Clears the value of extension `EditionsUnittest_Extensions_lengthprefixed`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionsUnittest_lengthprefixed() { + clearExtensionValue(ext: EditionsUnittest_Extensions_lengthprefixed) + } + + /// Truly group-like extension. + var EditionsUnittest_groupLikeFileScope: EditionsUnittest_GroupLikeFileScope { + get {return getExtensionValue(ext: EditionsUnittest_Extensions_GroupLikeFileScope) ?? EditionsUnittest_GroupLikeFileScope()} + set {setExtensionValue(ext: EditionsUnittest_Extensions_GroupLikeFileScope, value: newValue)} + } + /// Returns true if extension `EditionsUnittest_Extensions_GroupLikeFileScope` + /// has been explicitly set. + var hasEditionsUnittest_groupLikeFileScope: Bool { + return hasExtensionValue(ext: EditionsUnittest_Extensions_GroupLikeFileScope) + } + /// Clears the value of extension `EditionsUnittest_Extensions_GroupLikeFileScope`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionsUnittest_groupLikeFileScope() { + clearExtensionValue(ext: EditionsUnittest_Extensions_GroupLikeFileScope) + } + + /// Delimited extension that isn't group-like because of its name. + var EditionsUnittest_notGroupLikeScope: EditionsUnittest_NotGroupLikeScope { + get {return getExtensionValue(ext: EditionsUnittest_Extensions_not_group_like_scope) ?? EditionsUnittest_NotGroupLikeScope()} + set {setExtensionValue(ext: EditionsUnittest_Extensions_not_group_like_scope, value: newValue)} + } + /// Returns true if extension `EditionsUnittest_Extensions_not_group_like_scope` + /// has been explicitly set. + var hasEditionsUnittest_notGroupLikeScope: Bool { + return hasExtensionValue(ext: EditionsUnittest_Extensions_not_group_like_scope) + } + /// Clears the value of extension `EditionsUnittest_Extensions_not_group_like_scope`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionsUnittest_notGroupLikeScope() { + clearExtensionValue(ext: EditionsUnittest_Extensions_not_group_like_scope) + } + + /// Delimited extension that isn't group-like because of the scope of its type. + var EditionsUnittest_grouplike: EditionsUnittest_TestDelimited.GroupLike { + get {return getExtensionValue(ext: EditionsUnittest_Extensions_grouplike) ?? EditionsUnittest_TestDelimited.GroupLike()} + set {setExtensionValue(ext: EditionsUnittest_Extensions_grouplike, value: newValue)} + } + /// Returns true if extension `EditionsUnittest_Extensions_grouplike` + /// has been explicitly set. + var hasEditionsUnittest_grouplike: Bool { + return hasExtensionValue(ext: EditionsUnittest_Extensions_grouplike) + } + /// Clears the value of extension `EditionsUnittest_Extensions_grouplike`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionsUnittest_grouplike() { + clearExtensionValue(ext: EditionsUnittest_Extensions_grouplike) + } + + /// Delimited extension that's grouplike except that it's an imported type. + var EditionsUnittest_messageimport: EditionsUnittest_MessageImport { + get {return getExtensionValue(ext: EditionsUnittest_Extensions_messageimport) ?? EditionsUnittest_MessageImport()} + set {setExtensionValue(ext: EditionsUnittest_Extensions_messageimport, value: newValue)} + } + /// Returns true if extension `EditionsUnittest_Extensions_messageimport` + /// has been explicitly set. + var hasEditionsUnittest_messageimport: Bool { + return hasExtensionValue(ext: EditionsUnittest_Extensions_messageimport) + } + /// Clears the value of extension `EditionsUnittest_Extensions_messageimport`. + /// Subsequent reads from it will return its default value. + mutating func clearEditionsUnittest_messageimport() { + clearExtensionValue(ext: EditionsUnittest_Extensions_messageimport) + } + +} + +// MARK: - File's ExtensionMap: EditionsUnittest_UnittestDelimited_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 EditionsUnittest_UnittestDelimited_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + EditionsUnittest_Extensions_lengthprefixed, + EditionsUnittest_Extensions_GroupLikeFileScope, + EditionsUnittest_Extensions_not_group_like_scope, + EditionsUnittest_Extensions_grouplike, + EditionsUnittest_Extensions_messageimport +] + +// 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. + +/// Non-delimited field that otherwise looks group-like. +let EditionsUnittest_Extensions_lengthprefixed = SwiftProtobuf.MessageExtension, EditionsUnittest_TestDelimited>( + _protobuf_fieldNumber: 1004, + fieldName: "editions_unittest.lengthprefixed" +) + +/// Truly group-like extension. +let EditionsUnittest_Extensions_GroupLikeFileScope = SwiftProtobuf.MessageExtension, EditionsUnittest_TestDelimited>( + _protobuf_fieldNumber: 1000, + fieldName: "editions_unittest.grouplikefilescope" +) + +/// Delimited extension that isn't group-like because of its name. +let EditionsUnittest_Extensions_not_group_like_scope = SwiftProtobuf.MessageExtension, EditionsUnittest_TestDelimited>( + _protobuf_fieldNumber: 1001, + fieldName: "editions_unittest.not_group_like_scope" +) + +/// Delimited extension that isn't group-like because of the scope of its type. +let EditionsUnittest_Extensions_grouplike = SwiftProtobuf.MessageExtension, EditionsUnittest_TestDelimited>( + _protobuf_fieldNumber: 1002, + fieldName: "editions_unittest.grouplike" +) + +/// Delimited extension that's grouplike except that it's an imported type. +let EditionsUnittest_Extensions_messageimport = SwiftProtobuf.MessageExtension, EditionsUnittest_TestDelimited>( + _protobuf_fieldNumber: 1003, + fieldName: "editions_unittest.messageimport" +) + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "editions_unittest" + +extension EditionsUnittest_LengthPrefixed: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".LengthPrefixed" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_LengthPrefixed, rhs: EditionsUnittest_LengthPrefixed) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionsUnittest_NotGroupLikeScope: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NotGroupLikeScope" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_NotGroupLikeScope, rhs: EditionsUnittest_NotGroupLikeScope) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionsUnittest_GroupLikeFileScope: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GroupLikeFileScope" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_GroupLikeFileScope, rhs: EditionsUnittest_GroupLikeFileScope) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionsUnittest_TestDelimited: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestDelimited" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}lengthprefixed\0\u{1}nested\0\u{7}GroupLike\0\u{1}notgrouplike\0\u{1}notgrouplikescope\0\u{1}messageimport\0") + + fileprivate class _StorageClass { + var _lengthprefixed: EditionsUnittest_TestDelimited.LengthPrefixed? = nil + var _nested: EditionsUnittest_TestDelimited? = nil + var _groupLike: EditionsUnittest_TestDelimited.GroupLike? = nil + var _notgrouplike: EditionsUnittest_TestDelimited.GroupLike? = nil + var _notgrouplikescope: EditionsUnittest_NotGroupLikeScope? = nil + var _messageimport: EditionsUnittest_MessageImport? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _lengthprefixed = source._lengthprefixed + _nested = source._nested + _groupLike = source._groupLike + _notgrouplike = source._notgrouplike + _notgrouplikescope = source._notgrouplikescope + _messageimport = source._messageimport + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if let v = _storage._nested, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._lengthprefixed) }() + case 2: try { try decoder.decodeSingularGroupField(value: &_storage._nested) }() + case 3: try { try decoder.decodeSingularGroupField(value: &_storage._groupLike) }() + case 4: try { try decoder.decodeSingularGroupField(value: &_storage._notgrouplike) }() + case 5: try { try decoder.decodeSingularGroupField(value: &_storage._notgrouplikescope) }() + case 6: try { try decoder.decodeSingularGroupField(value: &_storage._messageimport) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: EditionsUnittest_TestDelimited.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._lengthprefixed { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._nested { + try visitor.visitSingularGroupField(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._groupLike { + try visitor.visitSingularGroupField(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._notgrouplike { + try visitor.visitSingularGroupField(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._notgrouplikescope { + try visitor.visitSingularGroupField(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._messageimport { + try visitor.visitSingularGroupField(value: v, fieldNumber: 6) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_TestDelimited, rhs: EditionsUnittest_TestDelimited) -> 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._lengthprefixed != rhs_storage._lengthprefixed {return false} + if _storage._nested != rhs_storage._nested {return false} + if _storage._groupLike != rhs_storage._groupLike {return false} + if _storage._notgrouplike != rhs_storage._notgrouplike {return false} + if _storage._notgrouplikescope != rhs_storage._notgrouplikescope {return false} + if _storage._messageimport != rhs_storage._messageimport {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension EditionsUnittest_TestDelimited.LengthPrefixed: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionsUnittest_TestDelimited.protoMessageName + ".LengthPrefixed" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_TestDelimited.LengthPrefixed, rhs: EditionsUnittest_TestDelimited.LengthPrefixed) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension EditionsUnittest_TestDelimited.GroupLike: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = EditionsUnittest_TestDelimited.protoMessageName + ".GroupLike" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_TestDelimited.GroupLike, rhs: EditionsUnittest_TestDelimited.GroupLike) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited_import.pb.swift b/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited_import.pb.swift new file mode 100644 index 000000000..0e18e0afd --- /dev/null +++ b/Tests/SwiftProtobufPluginLibraryTests/unittest_delimited_import.pb.swift @@ -0,0 +1,95 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: unittest_delimited_import.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +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 EditionsUnittest_MessageImport: Sendable { + // 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 a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} + + var b: Int32 { + get {_b ?? 0} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: Int32? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "editions_unittest" + +extension EditionsUnittest_MessageImport: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MessageImport" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0") + + 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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._b) }() + 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 + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: EditionsUnittest_MessageImport, rhs: EditionsUnittest_MessageImport) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Tests/SwiftProtobufTests/Data+TestHelpers.swift b/Tests/SwiftProtobufTests/Data+TestHelpers.swift index 59820a333..684f91147 100644 --- a/Tests/SwiftProtobufTests/Data+TestHelpers.swift +++ b/Tests/SwiftProtobufTests/Data+TestHelpers.swift @@ -9,7 +9,7 @@ // ----------------------------------------------------------------------------- import Foundation -@testable import SwiftProtobuf +import SwiftProtobuf /// Helpers for building up wire encoding in tests. extension Data { @@ -43,4 +43,3 @@ extension Data { } } - diff --git a/Tests/SwiftProtobufTests/Message+UInt8ArrayHelpers.swift b/Tests/SwiftProtobufTests/Message+UInt8ArrayHelpers.swift deleted file mode 100644 index cf072fd48..000000000 --- a/Tests/SwiftProtobufTests/Message+UInt8ArrayHelpers.swift +++ /dev/null @@ -1,28 +0,0 @@ -// Tests/SwiftProtobufTests/Message+UInt8ArrayHelpers.swift - UInt8 array message helpers -// -// Copyright (c) 2014 - 2016 Apple Inc. and the project authors -// Licensed under Apache License v2.0 with Runtime Library Exception -// -// See LICENSE.txt for license information: -// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt -// -// ----------------------------------------------------------------------------- -/// -/// Helper methods to serialize/parse messages via UInt8 arrays, to ease -/// test migration since the original methods have been removed from the -/// runtime. -/// -// ----------------------------------------------------------------------------- - -import Foundation -import SwiftProtobuf - -extension SwiftProtobuf.Message { - init(serializedBytes: [UInt8], extensions: SwiftProtobuf.SimpleExtensionMap? = nil) throws { - try self.init(serializedData: Data(serializedBytes), extensions: extensions) - } - - func serializedBytes() throws -> [UInt8] { - return try [UInt8](serializedData()) - } -} diff --git a/Tests/SwiftProtobufTests/TestHelpers.swift b/Tests/SwiftProtobufTests/TestHelpers.swift index 5a143fc7c..f7c8bc744 100644 --- a/Tests/SwiftProtobufTests/TestHelpers.swift +++ b/Tests/SwiftProtobufTests/TestHelpers.swift @@ -12,9 +12,9 @@ /// // ----------------------------------------------------------------------------- -import XCTest import Foundation import SwiftProtobuf +import XCTest typealias XCTestFileArgType = StaticString @@ -24,21 +24,36 @@ protocol PBTestHelpers { extension PBTestHelpers where MessageTestType: SwiftProtobuf.Message & Equatable { - private func string(from data: Data) -> String { - return "[" + data.map { String($0) }.joined(separator: ", ") + "]" + private func string(from data: [UInt8]) -> String { + "[" + data.map { String($0) }.joined(separator: ", ") + "]" } - func assertEncode(_ expected: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line, configure: (inout MessageTestType) -> Void) { + func assertEncode( + _ expected: [UInt8], + file: XCTestFileArgType = #file, + line: UInt = #line, + configure: (inout MessageTestType) -> Void + ) { let empty = MessageTestType() var configured = empty configure(&configured) XCTAssert(configured != empty, "Object should not be equal to empty object", file: file, line: line) do { - let encoded = try configured.serializedData() - XCTAssert(Data(expected) == encoded, "Did not encode correctly: got \(string(from: encoded))", file: file, line: line) + let encoded: [UInt8] = try configured.serializedBytes() + XCTAssert( + expected == encoded, + "Did not encode correctly: got \(string(from: encoded))", + file: file, + line: line + ) do { - let decoded = try MessageTestType(serializedData: encoded) - XCTAssert(decoded == configured, "Encode/decode cycle should generate equal object: \(decoded) != \(configured)", file: file, line: line) + let decoded = try MessageTestType(serializedBytes: encoded) + XCTAssert( + decoded == configured, + "Encode/decode cycle should generate equal object: \(decoded) != \(configured)", + file: file, + line: line + ) } catch { XCTFail("Failed to decode protobuf: \(string(from: encoded))", file: file, line: line) } @@ -47,15 +62,20 @@ extension PBTestHelpers where MessageTestType: SwiftProtobuf.Message & Equatable } } - func baseAssertDecodeSucceeds(_ bytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line, check: (MessageTestType) -> Bool) { + func baseAssertDecodeSucceeds( + _ bytes: [UInt8], + file: XCTestFileArgType = #file, + line: UInt = #line, + check: (MessageTestType) -> Bool + ) { do { - let decoded = try MessageTestType(serializedData: Data(bytes)) + let decoded = try MessageTestType(serializedBytes: bytes) XCTAssert(check(decoded), "Condition failed for \(decoded)", file: file, line: line) do { - let encoded = try decoded.serializedData() + let encoded: [UInt8] = try decoded.serializedBytes() do { - let redecoded = try MessageTestType(serializedData: encoded) + let redecoded = try MessageTestType(serializedBytes: encoded) XCTAssert(check(redecoded), "Condition failed for redecoded \(redecoded)", file: file, line: line) XCTAssertEqual(decoded, redecoded, file: file, line: line) } catch let e { @@ -69,13 +89,23 @@ extension PBTestHelpers where MessageTestType: SwiftProtobuf.Message & Equatable } } - func assertDecodeSucceeds(_ bytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line, check: (MessageTestType) -> Bool) { + func assertDecodeSucceeds( + _ bytes: [UInt8], + file: XCTestFileArgType = #file, + line: UInt = #line, + check: (MessageTestType) -> Bool + ) { baseAssertDecodeSucceeds(bytes, file: file, line: line, check: check) } // Helper to check that decode succeeds by the data ended up in unknown fields. // Supports an optional `check` to do additional validation. - func assertDecodesAsUnknownFields(_ bytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line, check: ((MessageTestType) -> Bool)? = nil) { + func assertDecodesAsUnknownFields( + _ bytes: [UInt8], + file: XCTestFileArgType = #file, + line: UInt = #line, + check: ((MessageTestType) -> Bool)? = nil + ) { assertDecodeSucceeds(bytes, file: file, line: line) { if $0.unknownFields.data != Data(bytes) { return false @@ -87,10 +117,16 @@ extension PBTestHelpers where MessageTestType: SwiftProtobuf.Message & Equatable } } - func assertMergesAsUnknownFields(_ bytes: [UInt8], inTo message: MessageTestType, file: XCTestFileArgType = #file, line: UInt = #line, check: ((MessageTestType) -> Bool)? = nil) { + func assertMergesAsUnknownFields( + _ bytes: [UInt8], + inTo message: MessageTestType, + file: XCTestFileArgType = #file, + line: UInt = #line, + check: ((MessageTestType) -> Bool)? = nil + ) { var msgCopy = message do { - try msgCopy.merge(serializedData: Data(bytes)) + try msgCopy.merge(serializedBytes: bytes) } catch let e { XCTFail("Failed to decode: \(e)", file: file, line: line) } @@ -100,16 +136,28 @@ extension PBTestHelpers where MessageTestType: SwiftProtobuf.Message & Equatable } } - func assertDecodeSucceeds(inputBytes bytes: [UInt8], recodedBytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line, check: (MessageTestType) -> Bool) { + func assertDecodeSucceeds( + inputBytes bytes: [UInt8], + recodedBytes: [UInt8], + file: XCTestFileArgType = #file, + line: UInt = #line, + check: (MessageTestType) -> Bool + ) { do { - let decoded = try MessageTestType(serializedData: Data(bytes)) + let decoded = try MessageTestType(serializedBytes: bytes) XCTAssert(check(decoded), "Condition failed for \(decoded)", file: file, line: line) do { - let encoded = try decoded.serializedData() - XCTAssertEqual(Data(recodedBytes), encoded, "Didn't recode as expected: \(string(from: encoded)) expected: \(recodedBytes)", file: file, line: line) + let encoded: [UInt8] = try decoded.serializedBytes() + XCTAssertEqual( + recodedBytes, + encoded, + "Didn't recode as expected: \(string(from: encoded)) expected: \(recodedBytes)", + file: file, + line: line + ) do { - let redecoded = try MessageTestType(serializedData: encoded) + let redecoded = try MessageTestType(serializedBytes: encoded) XCTAssert(check(redecoded), "Condition failed for redecoded \(redecoded)", file: file, line: line) XCTAssertEqual(decoded, redecoded, file: file, line: line) } catch let e { @@ -123,10 +171,9 @@ extension PBTestHelpers where MessageTestType: SwiftProtobuf.Message & Equatable } } - func assertDecodeFails(_ bytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line) { do { - let _ = try MessageTestType(serializedData: Data(bytes)) + let _ = try MessageTestType(serializedBytes: bytes) XCTFail("Swift decode should have failed: \(bytes)", file: file, line: line) } catch { // Yay! It failed! @@ -134,35 +181,70 @@ extension PBTestHelpers where MessageTestType: SwiftProtobuf.Message & Equatable } - func assertJSONEncode(_ expected: String, extensions: ExtensionMap = SimpleExtensionMap(), file: XCTestFileArgType = #file, line: UInt = #line, configure: (inout MessageTestType) -> Void) { + func assertJSONEncode( + _ expected: String, + extensions: any ExtensionMap = SimpleExtensionMap(), + encodingOptions: JSONEncodingOptions = .init(), + file: XCTestFileArgType = #file, + line: UInt = #line, + configure: (inout MessageTestType) -> Void + ) { let empty = MessageTestType() var configured = empty configure(&configured) XCTAssert(configured != empty, "Object should not be equal to empty object", file: file, line: line) do { - let encoded = try configured.jsonString() - XCTAssert(expected == encoded, "Did not encode correctly: got \(encoded)", file: file, line: line) + let encoded = try configured.jsonString(options: encodingOptions) + XCTAssert( + expected == encoded, + "Did not encode correctly: got \(encoded) but expected \(expected)", + file: file, + line: line + ) do { let decoded = try MessageTestType(jsonString: encoded, extensions: extensions) - XCTAssert(decoded == configured, "Encode/decode cycle should generate equal object: \(decoded) != \(configured)", file: file, line: line) + XCTAssert( + decoded == configured, + "Encode/decode cycle should generate equal object: \(decoded) != \(configured)", + file: file, + line: line + ) } catch { - XCTFail("Encode/decode cycle should not throw error decoding: \(encoded), but it threw \(error)", file: file, line: line) + XCTFail( + "Encode/decode cycle should not throw error decoding: \(encoded), but it threw \(error)", + file: file, + line: line + ) } } catch let e { XCTFail("Failed to serialize JSON: \(e)\n \(configured)", file: file, line: line) } do { - let encodedData = try configured.jsonUTF8Data() - let encodedOptString = String(data: encodedData, encoding: String.Encoding.utf8) + let encodedData: [UInt8] = try configured.jsonUTF8Bytes(options: encodingOptions) + let encodedOptString = String(bytes: encodedData, encoding: String.Encoding.utf8) XCTAssertNotNil(encodedOptString) let encodedString = encodedOptString! - XCTAssert(expected == encodedString, "Did not encode correctly: got \(encodedString)", file: file, line: line) + XCTAssert( + expected == encodedString, + "Did not encode correctly: got \(encodedString)", + file: file, + line: line + ) do { - let decoded = try MessageTestType(jsonUTF8Data: encodedData, extensions: extensions) - XCTAssert(decoded == configured, "Encode/decode cycle should generate equal object: \(decoded) != \(configured)", file: file, line: line) + let decoded = try MessageTestType(jsonUTF8Bytes: encodedData, extensions: extensions) + XCTAssert( + decoded == configured, + "Encode/decode cycle should generate equal object: \(decoded) != \(configured)", + file: file, + line: line + ) } catch { - XCTFail("Encode/decode cycle should not throw error decoding: \(encodedString), but it threw \(error)", file: file, line: line) + XCTFail( + "Encode/decode cycle should not throw error decoding: \(encodedString), but it threw \(error)", + file: file, + line: line + ) } } catch let e { XCTFail("Failed to serialize JSON: \(e)\n \(configured)", file: file, line: line) @@ -173,7 +255,13 @@ extension PBTestHelpers where MessageTestType: SwiftProtobuf.Message & Equatable /// This uses the provided block to initialize the object, then: /// * Encodes the object and checks that the result is the expected result /// * Decodes it again and verifies that the round-trip gives an equal object - func assertTextFormatEncode(_ expected: String, extensions: ExtensionMap? = nil, file: XCTestFileArgType = #file, line: UInt = #line, configure: (inout MessageTestType) -> Void) { + func assertTextFormatEncode( + _ expected: String, + extensions: (any ExtensionMap)? = nil, + file: XCTestFileArgType = #file, + line: UInt = #line, + configure: (inout MessageTestType) -> Void + ) { let empty = MessageTestType() var configured = empty configure(&configured) @@ -183,15 +271,24 @@ extension PBTestHelpers where MessageTestType: SwiftProtobuf.Message & Equatable XCTAssertEqual(expected, encoded, "Did not encode correctly", file: file, line: line) do { let decoded = try MessageTestType(textFormatString: encoded, extensions: extensions) - XCTAssert(decoded == configured, "Encode/decode cycle should generate equal object: \(decoded) != \(configured)", file: file, line: line) + XCTAssert( + decoded == configured, + "Encode/decode cycle should generate equal object: \(decoded) != \(configured)", + file: file, + line: line + ) } catch { - XCTFail("Encode/decode cycle should not throw error but got \(error) while decoding \(encoded)", file: file, line: line) + XCTFail( + "Encode/decode cycle should not throw error but got \(error) while decoding \(encoded)", + file: file, + line: line + ) } } func assertJSONArrayEncode( _ expected: String, - extensions: ExtensionMap = SimpleExtensionMap(), + extensions: any ExtensionMap = SimpleExtensionMap(), file: XCTestFileArgType = #file, line: UInt = #line, configure: (inout [MessageTestType]) -> Void @@ -204,11 +301,22 @@ extension PBTestHelpers where MessageTestType: SwiftProtobuf.Message & Equatable let encoded = try MessageTestType.jsonString(from: configured) XCTAssert(expected == encoded, "Did not encode correctly: got \(encoded)", file: file, line: line) do { - let decoded = try MessageTestType.array(fromJSONString: encoded, - extensions: extensions) - XCTAssert(decoded == configured, "Encode/decode cycle should generate equal object: \(decoded) != \(configured)", file: file, line: line) + let decoded = try MessageTestType.array( + fromJSONString: encoded, + extensions: extensions + ) + XCTAssert( + decoded == configured, + "Encode/decode cycle should generate equal object: \(decoded) != \(configured)", + file: file, + line: line + ) } catch { - XCTFail("Encode/decode cycle should not throw error decoding: \(encoded), but it threw \(error)", file: file, line: line) + XCTFail( + "Encode/decode cycle should not throw error decoding: \(encoded), but it threw \(error)", + file: file, + line: line + ) } } catch let e { XCTFail("Failed to serialize JSON: \(e)\n \(configured)", file: file, line: line) @@ -217,20 +325,30 @@ extension PBTestHelpers where MessageTestType: SwiftProtobuf.Message & Equatable func assertJSONDecodeSucceeds( _ json: String, - extensions: ExtensionMap = SimpleExtensionMap(), + options: JSONDecodingOptions = JSONDecodingOptions(), + extensions: any ExtensionMap = SimpleExtensionMap(), file: XCTestFileArgType = #file, line: UInt = #line, check: (MessageTestType) -> Bool ) { do { - let decoded: MessageTestType = try MessageTestType(jsonString: json, extensions: extensions) + let decoded: MessageTestType = try MessageTestType( + jsonString: json, + extensions: extensions, + options: options + ) XCTAssert(check(decoded), "Condition failed for \(decoded)", file: file, line: line) do { let encoded = try decoded.jsonString() do { - let redecoded = try MessageTestType(jsonString: encoded, extensions: extensions) - XCTAssert(check(redecoded), "Condition failed for redecoded \(redecoded) from \(encoded)", file: file, line: line) + let redecoded = try MessageTestType(jsonString: encoded, extensions: extensions, options: options) + XCTAssert( + check(redecoded), + "Condition failed for redecoded \(redecoded) from \(encoded)", + file: file, + line: line + ) XCTAssertEqual(decoded, redecoded, file: file, line: line) } catch { XCTFail("Swift should have recoded/redecoded without error: \(encoded)", file: file, line: line) @@ -245,18 +363,35 @@ extension PBTestHelpers where MessageTestType: SwiftProtobuf.Message & Equatable do { let jsonData = json.data(using: String.Encoding.utf8)! - let decoded: MessageTestType = try MessageTestType(jsonUTF8Data: jsonData, extensions: extensions) + let decoded: MessageTestType = try MessageTestType( + jsonUTF8Bytes: jsonData, + extensions: extensions, + options: options + ) XCTAssert(check(decoded), "Condition failed for \(decoded) from binary \(json)", file: file, line: line) do { - let encoded = try decoded.jsonUTF8Data() - let encodedString = String(data: encoded, encoding: String.Encoding.utf8)! + let encoded: [UInt8] = try decoded.jsonUTF8Bytes() + let encodedString = String(decoding: encoded, as: UTF8.self) do { - let redecoded = try MessageTestType(jsonUTF8Data: encoded, extensions: extensions) - XCTAssert(check(redecoded), "Condition failed for redecoded \(redecoded) from binary \(encodedString)", file: file, line: line) + let redecoded = try MessageTestType( + jsonUTF8Bytes: encoded, + extensions: extensions, + options: options + ) + XCTAssert( + check(redecoded), + "Condition failed for redecoded \(redecoded) from binary \(encodedString)", + file: file, + line: line + ) XCTAssertEqual(decoded, redecoded, file: file, line: line) } catch { - XCTFail("Swift should have recoded/redecoded without error: \(encodedString)", file: file, line: line) + XCTFail( + "Swift should have recoded/redecoded without error: \(encodedString)", + file: file, + line: line + ) } } catch let e { XCTFail("Swift should have recoded without error but got \(e)\n \(decoded)", file: file, line: line) @@ -267,9 +402,15 @@ extension PBTestHelpers where MessageTestType: SwiftProtobuf.Message & Equatable } } - func assertTextFormatDecodeSucceeds(_ text: String, file: XCTestFileArgType = #file, line: UInt = #line, check: (MessageTestType) throws -> Bool) { + func assertTextFormatDecodeSucceeds( + _ text: String, + options: TextFormatDecodingOptions = TextFormatDecodingOptions(), + file: XCTestFileArgType = #file, + line: UInt = #line, + check: (MessageTestType) throws -> Bool + ) { do { - let decoded: MessageTestType = try MessageTestType(textFormatString: text) + let decoded: MessageTestType = try MessageTestType(textFormatString: text, options: options) do { let r = try check(decoded) XCTAssert(r, "Condition failed for \(decoded)", file: file, line: line) @@ -278,7 +419,7 @@ extension PBTestHelpers where MessageTestType: SwiftProtobuf.Message & Equatable } let encoded = decoded.textFormatString() do { - let redecoded = try MessageTestType(textFormatString: text) + let redecoded = try MessageTestType(textFormatString: encoded) do { let r = try check(redecoded) XCTAssert(r, "Condition failed for redecoded \(redecoded)", file: file, line: line) @@ -325,7 +466,7 @@ extension PBTestHelpers where MessageTestType: SwiftProtobuf.Message & Equatable func assertJSONDecodeFails( _ json: String, - extensions: ExtensionMap = SimpleExtensionMap(), + extensions: any ExtensionMap = SimpleExtensionMap(), options: JSONDecodingOptions = JSONDecodingOptions(), file: XCTestFileArgType = #file, line: UInt = #line @@ -339,7 +480,7 @@ extension PBTestHelpers where MessageTestType: SwiftProtobuf.Message & Equatable let jsonData = json.data(using: String.Encoding.utf8)! do { - let _ = try MessageTestType(jsonUTF8Data: jsonData, extensions: extensions, options: options) + let _ = try MessageTestType(jsonUTF8Bytes: jsonData, extensions: extensions, options: options) XCTFail("Swift decode should have failed for binary: \(json)", file: file, line: line) } catch { // Yay! It failed again! @@ -357,7 +498,7 @@ extension PBTestHelpers where MessageTestType: SwiftProtobuf.Message & Equatable func assertJSONArrayDecodeFails( _ json: String, - extensions: ExtensionMap = SimpleExtensionMap(), + extensions: any ExtensionMap = SimpleExtensionMap(), file: XCTestFileArgType = #file, line: UInt = #line ) { @@ -368,73 +509,124 @@ extension PBTestHelpers where MessageTestType: SwiftProtobuf.Message & Equatable // Yay! It failed! } } + + func assertDebugDescription( + _ expected: String, + file: XCTestFileArgType = #file, + line: UInt = #line, + configure: (inout MessageTestType) -> Void + ) { + // `assertDebugDescription` is a no-op in release as `debugDescription` is unavailable. + #if DEBUG + var m = MessageTestType() + configure(&m) + let actual = m.debugDescription + XCTAssertEqual(actual, expected, file: file, line: line) + #endif + } +} + +extension XCTestCase { + func assertDebugDescription( + _ expected: String, + _ m: any SwiftProtobuf.Message, + fmt: String? = nil, + file: XCTestFileArgType = #file, + line: UInt = #line + ) { + // `assertDebugDescription` is a no-op in release as `debugDescription` is unavailable. + #if DEBUG + let actual = m.debugDescription + XCTAssertEqual(actual, expected, fmt ?? "debugDescription did not match", file: file, line: line) + #endif + } + /// Like ``assertDebugDescription``, but only checks the the ``debugDescription`` ends with + /// ``expectedSuffix``, mainly useful where you want to be agnotics to some preable like + /// the module name. + func assertDebugDescriptionSuffix( + _ expectedSuffix: String, + _ m: any SwiftProtobuf.Message, + fmt: String? = nil, + file: XCTestFileArgType = #file, + line: UInt = #line + ) { + // `assertDebugDescriptionSuffix` is a no-op in release as `debugDescription` is unavailable. + #if DEBUG + let actual = m.debugDescription + XCTAssertTrue(actual.hasSuffix(expectedSuffix), fmt ?? "debugDescription did not match", file: file, line: line) + #endif + } + + func isSwiftProtobufErrorEqual(_ actual: SwiftProtobufError, _ expected: SwiftProtobufError) -> Bool { + (actual.code == expected.code) && (actual.message == expected.message) + } } -/// Protocol to help write visitor for testing. It provides default implementaions +/// Protocol to help write visitor for testing. It provides default implementations /// that will cause a failure if anything gets called. This way specific tests can /// just hook the methods they intend to validate. protocol PBTestVisitor: Visitor { - // Adds nothing. + // Adds nothing. } extension PBTestVisitor { - mutating func visitUnknown(bytes: Data) throws { - XCTFail("Unexpected unknowns: \(bytes)") - } - - mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws { - XCTFail("Unexpected bool: \(fieldNumber) = \(value)") - } - - mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws { - XCTFail("Unexpected bytes: \(fieldNumber) = \(value)") - } - - mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws { - XCTFail("Unexpected Int64: \(fieldNumber) = \(value)") - } - - mutating func visitSingularEnumField(value: E, fieldNumber: Int) throws { - XCTFail("Unexpected Enum: \(fieldNumber) = \(value)") - } - - mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws { - XCTFail("Unexpected Int64: \(fieldNumber) = \(value)") - } - - mutating func visitSingularMessageField(value: M, fieldNumber: Int) throws { - XCTFail("Unexpected Message: \(fieldNumber) = \(value)") - } - - mutating func visitSingularStringField(value: String, fieldNumber: Int) throws { - XCTFail("Unexpected String: \(fieldNumber) = \(value)") - } - - mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws { - XCTFail("Unexpected UInt64: \(fieldNumber) = \(value)") - } - - mutating func visitMapField( - fieldType: _ProtobufMap.Type, - value: _ProtobufMap.BaseType, - fieldNumber: Int - ) throws { - XCTFail("Unexpected map<*, *>: \(fieldNumber) = \(value)") - } - - mutating func visitMapField( - fieldType: _ProtobufEnumMap.Type, - value: _ProtobufEnumMap.BaseType, - fieldNumber: Int - ) throws where ValueType.RawValue == Int { - XCTFail("Unexpected map<*, Enum>: \(fieldNumber) = \(value)") - } - - mutating func visitMapField( - fieldType: _ProtobufMessageMap.Type, - value: _ProtobufMessageMap.BaseType, - fieldNumber: Int - ) throws { - XCTFail("Unexpected map<*, Message>: \(fieldNumber) = \(value)") - } + mutating func visitUnknown(bytes: Data) throws { + XCTFail("Unexpected unknowns: \(bytes)") + } + + mutating func visitSingularBoolField(value: Bool, fieldNumber: Int) throws { + XCTFail("Unexpected bool: \(fieldNumber) = \(value)") + } + + mutating func visitSingularBytesField(value: Data, fieldNumber: Int) throws { + XCTFail("Unexpected bytes: \(fieldNumber) = \(value)") + } + + mutating func visitSingularDoubleField(value: Double, fieldNumber: Int) throws { + XCTFail("Unexpected Int64: \(fieldNumber) = \(value)") + } + + mutating func visitSingularEnumField(value: E, fieldNumber: Int) throws { + XCTFail("Unexpected Enum: \(fieldNumber) = \(value)") + } + + mutating func visitSingularInt64Field(value: Int64, fieldNumber: Int) throws { + XCTFail("Unexpected Int64: \(fieldNumber) = \(value)") + } + + mutating func visitSingularMessageField(value: M, fieldNumber: Int) throws { + XCTFail("Unexpected Message: \(fieldNumber) = \(value)") + } + + mutating func visitSingularStringField(value: String, fieldNumber: Int) throws { + XCTFail("Unexpected String: \(fieldNumber) = \(value)") + } + + mutating func visitSingularUInt64Field(value: UInt64, fieldNumber: Int) throws { + XCTFail("Unexpected UInt64: \(fieldNumber) = \(value)") + } + + mutating func visitMapField( + fieldType: _ProtobufMap.Type, + value: _ProtobufMap.BaseType, + fieldNumber: Int + ) throws { + XCTFail("Unexpected map<*, *>: \(fieldNumber) = \(value)") + } + + mutating func visitMapField( + fieldType: _ProtobufEnumMap.Type, + value: _ProtobufEnumMap.BaseType, + fieldNumber: Int + ) throws where ValueType.RawValue == Int { + XCTFail("Unexpected map<*, Enum>: \(fieldNumber) = \(value)") + } + + mutating func visitMapField( + fieldType: _ProtobufMessageMap.Type, + value: _ProtobufMessageMap.BaseType, + fieldNumber: Int + ) throws { + XCTFail("Unexpected map<*, Message>: \(fieldNumber) = \(value)") + } } diff --git a/Tests/SwiftProtobufTests/Test_AllTypes.swift b/Tests/SwiftProtobufTests/Test_AllTypes.swift index 5a2af7f07..071b3759d 100644 --- a/Tests/SwiftProtobufTests/Test_AllTypes.swift +++ b/Tests/SwiftProtobufTests/Test_AllTypes.swift @@ -16,20 +16,26 @@ // ----------------------------------------------------------------------------- import Foundation +import SwiftProtobuf import XCTest -class Test_AllTypes: XCTestCase, PBTestHelpers { - typealias MessageTestType = ProtobufUnittest_TestAllTypes +final class Test_AllTypes: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_TestAllTypes // Custom decodeSucceeds that also does a round-trip through the Empty // message to make sure unknown fields are consistently preserved by proto2. - func assertDecodeSucceeds(_ bytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line, check: (MessageTestType) -> Bool) { + func assertDecodeSucceeds( + _ bytes: [UInt8], + file: XCTestFileArgType = #file, + line: UInt = #line, + check: (MessageTestType) -> Bool + ) { baseAssertDecodeSucceeds(bytes, file: file, line: line, check: check) do { // Make sure unknown fields are preserved by empty message decode/encode - let empty = try ProtobufUnittest_TestEmptyMessage(serializedBytes: bytes) + let empty = try SwiftProtoTesting_TestEmptyMessage(serializedBytes: bytes) do { - let newBytes = try empty.serializedBytes() + let newBytes: [UInt8] = try empty.serializedBytes() XCTAssertEqual(bytes, newBytes, "Empty decode/recode did not match", file: file, line: line) } catch let e { XCTFail("Reserializing empty threw an error: \(e)", file: file, line: line) @@ -39,26 +45,19 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } } - func assertDebugDescription(_ expected: String, file: XCTestFileArgType = #file, line: UInt = #line, configure: (inout MessageTestType) -> ()) { - var m = MessageTestType() - configure(&m) - let actual = m.debugDescription - XCTAssertEqual(actual, expected, file: file, line: line) - } - // // Unknown field // func testEncoding_unknown() { - assertDecodeFails([208, 41]) // Field 666, wiretype 0 - assertDecodeSucceeds([208, 41, 0]) {$0 != MessageTestType()} // Ditto, with varint body + assertDecodeFails([208, 41]) // Field 666, wiretype 0 + assertDecodeSucceeds([208, 41, 0]) { $0 != MessageTestType() } // Ditto, with varint body // This test validation when putting things into unknown fields. In // this case, ensuring the a varint value isn't invalid. assertDecodeFails([ - (7 << 3) + 0, // Field 7 as a varint (it should be a fixed32) - // And overly encoded varint for the value (extracted from some fuzz testing) - 239, 191, 189, 239, 191, 189, 239, 191, 189, 239, 191, 189, 49, + (7 << 3) + 0, // Field 7 as a varint (it should be a fixed32) + // And overly encoded varint for the value (extracted from some fuzz testing) + 239, 191, 189, 239, 191, 189, 239, 191, 189, 239, 191, 189, 49, ]) } @@ -66,16 +65,22 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { // Singular types // func testEncoding_optionalInt32() { - assertEncode([8, 1]) {(o: inout MessageTestType) in o.optionalInt32 = 1} - assertEncode([8, 255, 255, 255, 255, 7]) {(o: inout MessageTestType) in o.optionalInt32 = Int32.max} - assertEncode([8, 128, 128, 128, 128, 248, 255, 255, 255, 255, 1]) {(o: inout MessageTestType) in o.optionalInt32 = Int32.min} - assertDecodeSucceeds([8, 1]) {$0.optionalInt32 == 1} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_int32: 1\n") {(o: inout MessageTestType) in o.optionalInt32 = 1} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_int32: -2147483648\noptional_uint32: 4294967295\n") {(o: inout MessageTestType) in + assertEncode([8, 1]) { (o: inout MessageTestType) in o.optionalInt32 = 1 } + assertEncode([8, 255, 255, 255, 255, 7]) { (o: inout MessageTestType) in o.optionalInt32 = Int32.max } + assertEncode([8, 128, 128, 128, 128, 248, 255, 255, 255, 255, 1]) { (o: inout MessageTestType) in + o.optionalInt32 = Int32.min + } + assertDecodeSucceeds([8, 1]) { $0.optionalInt32 == 1 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_int32: 1\n") { + (o: inout MessageTestType) in o.optionalInt32 = 1 + } + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_int32: -2147483648\noptional_uint32: 4294967295\n" + ) { (o: inout MessageTestType) in o.optionalInt32 = Int32.min o.optionalUint32 = UInt32.max } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\n") {(o: inout MessageTestType) in + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\n") { (o: inout MessageTestType) in o.optionalInt32 = 1 o.clearOptionalInt32() } @@ -91,17 +96,17 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } // We should recognize a valid field after an unknown field: - assertDecodeSucceeds([208, 41, 0, 8, 1]) {$0.optionalInt32 == 1} + assertDecodeSucceeds([208, 41, 0, 8, 1]) { $0.optionalInt32 == 1 } assertDecodeFails([8]) - assertDecodeFails([9, 57]) // Cannot use wire type 1 - assertDecodeFails([10, 58]) // Cannot use wire type 2 - assertDecodeFails([11, 59]) // Cannot use wire type 3 - assertDecodeFails([12, 60]) // Cannot use wire type 4 - assertDecodeFails([13, 61]) // Cannot use wire type 5 - assertDecodeFails([14, 62]) // Cannot use wire type 6 - assertDecodeFails([15, 63]) // Cannot use wire type 7 + assertDecodeFails([9, 57]) // Cannot use wire type 1 + assertDecodeFails([10, 58]) // Cannot use wire type 2 + assertDecodeFails([11, 59]) // Cannot use wire type 3 + assertDecodeFails([12, 60]) // Cannot use wire type 4 + assertDecodeFails([13, 61]) // Cannot use wire type 5 + assertDecodeFails([14, 62]) // Cannot use wire type 6 + assertDecodeFails([15, 63]) // Cannot use wire type 7 assertDecodeFails([8, 188]) assertDecodeFails([8]) @@ -132,11 +137,17 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalInt64() { - assertEncode([16, 1]) {(o: inout MessageTestType) in o.optionalInt64 = 1} - assertEncode([16, 255, 255, 255, 255, 255, 255, 255, 255, 127]) {(o: inout MessageTestType) in o.optionalInt64 = Int64.max} - assertEncode([16, 128, 128, 128, 128, 128, 128, 128, 128, 128, 1]) {(o: inout MessageTestType) in o.optionalInt64 = Int64.min} - assertDecodeSucceeds([16, 184, 156, 195, 145, 203, 1]) {$0.optionalInt64 == 54529150520} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_int64: 1\n") {(o: inout MessageTestType) in o.optionalInt64 = 1} + assertEncode([16, 1]) { (o: inout MessageTestType) in o.optionalInt64 = 1 } + assertEncode([16, 255, 255, 255, 255, 255, 255, 255, 255, 127]) { (o: inout MessageTestType) in + o.optionalInt64 = Int64.max + } + assertEncode([16, 128, 128, 128, 128, 128, 128, 128, 128, 128, 1]) { (o: inout MessageTestType) in + o.optionalInt64 = Int64.min + } + assertDecodeSucceeds([16, 184, 156, 195, 145, 203, 1]) { $0.optionalInt64 == 54_529_150_520 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_int64: 1\n") { + (o: inout MessageTestType) in o.optionalInt64 = 1 + } assertDecodeFails([16]) assertDecodeFails([16, 184, 156, 195, 145, 203]) assertDecodeFails([17, 81]) @@ -174,10 +185,12 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalUint32() { - assertEncode([24, 255, 255, 255, 255, 15]) {(o: inout MessageTestType) in o.optionalUint32 = UInt32.max} - assertEncode([24, 0]) {(o: inout MessageTestType) in o.optionalUint32 = UInt32.min} - assertDecodeSucceeds([24, 149, 88]) {$0.optionalUint32 == 11285} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_uint32: 1\n") {(o: inout MessageTestType) in o.optionalUint32 = 1} + assertEncode([24, 255, 255, 255, 255, 15]) { (o: inout MessageTestType) in o.optionalUint32 = UInt32.max } + assertEncode([24, 0]) { (o: inout MessageTestType) in o.optionalUint32 = UInt32.min } + assertDecodeSucceeds([24, 149, 88]) { $0.optionalUint32 == 11285 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_uint32: 1\n") { + (o: inout MessageTestType) in o.optionalUint32 = 1 + } assertDecodeFails([24]) assertDecodeFails([24, 149]) assertDecodeFails([25, 105]) @@ -215,10 +228,14 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalUint64() { - assertEncode([32, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1]) {(o: inout MessageTestType) in o.optionalUint64 = UInt64.max} - assertEncode([32, 0]) {(o: inout MessageTestType) in o.optionalUint64 = UInt64.min} - assertDecodeSucceeds([32, 149, 7]) {$0.optionalUint64 == 917} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_uint64: 1\n") {(o: inout MessageTestType) in o.optionalUint64 = 1} + assertEncode([32, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1]) { (o: inout MessageTestType) in + o.optionalUint64 = UInt64.max + } + assertEncode([32, 0]) { (o: inout MessageTestType) in o.optionalUint64 = UInt64.min } + assertDecodeSucceeds([32, 149, 7]) { $0.optionalUint64 == 917 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_uint64: 1\n") { + (o: inout MessageTestType) in o.optionalUint64 = 1 + } assertDecodeFails([32]) assertDecodeFails([32, 149]) assertDecodeFails([32, 149, 190, 193, 230, 186, 233, 166, 219]) @@ -226,7 +243,7 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { assertDecodeFails([33, 0]) assertDecodeFails([33, 8, 0]) assertDecodeFails([34]) - assertDecodesAsUnknownFields([34, 0]) // Wrong wire type (length delimited), valid as an unknown field + assertDecodesAsUnknownFields([34, 0]) // Wrong wire type (length delimited), valid as an unknown field assertDecodeFails([34, 8, 0]) assertDecodeFails([35]) assertDecodeFails([35, 0]) @@ -271,18 +288,24 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalSint32() { - assertEncode([40, 254, 255, 255, 255, 15]) {(o: inout MessageTestType) in o.optionalSint32 = Int32.max} - assertEncode([40, 255, 255, 255, 255, 15]) {(o: inout MessageTestType) in o.optionalSint32 = Int32.min} - assertDecodeSucceeds([40, 0x81, 0x82, 0x80, 0x00]) {$0.optionalSint32 == -129} - assertDecodeSucceeds([40, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00]) {$0.optionalSint32 == 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_sint32: 1\n") {(o: inout MessageTestType) in o.optionalSint32 = 1} + assertEncode([40, 254, 255, 255, 255, 15]) { (o: inout MessageTestType) in o.optionalSint32 = Int32.max } + assertEncode([40, 255, 255, 255, 255, 15]) { (o: inout MessageTestType) in o.optionalSint32 = Int32.min } + assertDecodeSucceeds([40, 0x81, 0x82, 0x80, 0x00]) { $0.optionalSint32 == -129 } + assertDecodeSucceeds([40, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00]) { + $0.optionalSint32 == 0 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_sint32: 1\n") { + (o: inout MessageTestType) in o.optionalSint32 = 1 + } // Truncate on overflow - assertDecodeSucceeds([40, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f]) {$0.optionalSint32 == -2147483648} - assertDecodeSucceeds([40, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x7f]) {$0.optionalSint32 == 2147483647} + assertDecodeSucceeds([40, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f]) { $0.optionalSint32 == -2_147_483_648 } + assertDecodeSucceeds([40, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x7f]) { $0.optionalSint32 == 2_147_483_647 } assertDecodeFails([40]) - assertDecodeFails([40, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00]) + assertDecodeFails([ + 40, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + ]) assertDecodeFails([41]) assertDecodeFails([41, 0]) assertDecodeFails([42]) @@ -325,10 +348,16 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalSint64() { - assertEncode([48, 254, 255, 255, 255, 255, 255, 255, 255, 255, 1]) {(o: inout MessageTestType) in o.optionalSint64 = Int64.max} - assertEncode([48, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1]) {(o: inout MessageTestType) in o.optionalSint64 = Int64.min} - assertDecodeSucceeds([48, 139, 94]) {$0.optionalSint64 == -6022} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_sint64: 1\n") {(o: inout MessageTestType) in o.optionalSint64 = 1} + assertEncode([48, 254, 255, 255, 255, 255, 255, 255, 255, 255, 1]) { (o: inout MessageTestType) in + o.optionalSint64 = Int64.max + } + assertEncode([48, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1]) { (o: inout MessageTestType) in + o.optionalSint64 = Int64.min + } + assertDecodeSucceeds([48, 139, 94]) { $0.optionalSint64 == -6022 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_sint64: 1\n") { + (o: inout MessageTestType) in o.optionalSint64 = 1 + } assertDecodeFails([48]) assertDecodeFails([48, 139]) assertDecodeFails([49]) @@ -373,10 +402,12 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalFixed32() { - assertEncode([61, 255, 255, 255, 255]) {(o: inout MessageTestType) in o.optionalFixed32 = UInt32.max} - assertEncode([61, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.optionalFixed32 = UInt32.min} - assertDecodeSucceeds([61, 8, 12, 108, 1]) {$0.optionalFixed32 == 23858184} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_fixed32: 1\n") {(o: inout MessageTestType) in o.optionalFixed32 = 1} + assertEncode([61, 255, 255, 255, 255]) { (o: inout MessageTestType) in o.optionalFixed32 = UInt32.max } + assertEncode([61, 0, 0, 0, 0]) { (o: inout MessageTestType) in o.optionalFixed32 = UInt32.min } + assertDecodeSucceeds([61, 8, 12, 108, 1]) { $0.optionalFixed32 == 23_858_184 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_fixed32: 1\n") { + (o: inout MessageTestType) in o.optionalFixed32 = 1 + } assertDecodeFails([61]) assertDecodeFails([61, 255]) assertDecodeFails([61, 255, 255]) @@ -430,10 +461,16 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalFixed64() { - assertEncode([65, 255, 255, 255, 255, 255, 255, 255, 255]) {(o: inout MessageTestType) in o.optionalFixed64 = UInt64.max} - assertEncode([65, 0, 0, 0, 0, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.optionalFixed64 = UInt64.min} - assertDecodeSucceeds([65, 255, 255, 255, 255, 255, 255, 255, 255]) {$0.optionalFixed64 == 18446744073709551615} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_fixed64: 1\n") {(o: inout MessageTestType) in o.optionalFixed64 = 1} + assertEncode([65, 255, 255, 255, 255, 255, 255, 255, 255]) { (o: inout MessageTestType) in + o.optionalFixed64 = UInt64.max + } + assertEncode([65, 0, 0, 0, 0, 0, 0, 0, 0]) { (o: inout MessageTestType) in o.optionalFixed64 = UInt64.min } + assertDecodeSucceeds([65, 255, 255, 255, 255, 255, 255, 255, 255]) { + $0.optionalFixed64 == 18_446_744_073_709_551_615 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_fixed64: 1\n") { + (o: inout MessageTestType) in o.optionalFixed64 = 1 + } assertDecodeFails([65]) assertDecodeFails([65, 255]) assertDecodeFails([65, 255, 255]) @@ -491,11 +528,13 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalSfixed32() { - assertEncode([77, 255, 255, 255, 127]) {(o: inout MessageTestType) in o.optionalSfixed32 = Int32.max} - assertEncode([77, 0, 0, 0, 128]) {(o: inout MessageTestType) in o.optionalSfixed32 = Int32.min} - assertDecodeSucceeds([77, 0, 0, 0, 0]) {$0.optionalSfixed32 == 0} - assertDecodeSucceeds([77, 255, 255, 255, 255]) {$0.optionalSfixed32 == -1} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_sfixed32: 1\n") {(o: inout MessageTestType) in o.optionalSfixed32 = 1} + assertEncode([77, 255, 255, 255, 127]) { (o: inout MessageTestType) in o.optionalSfixed32 = Int32.max } + assertEncode([77, 0, 0, 0, 128]) { (o: inout MessageTestType) in o.optionalSfixed32 = Int32.min } + assertDecodeSucceeds([77, 0, 0, 0, 0]) { $0.optionalSfixed32 == 0 } + assertDecodeSucceeds([77, 255, 255, 255, 255]) { $0.optionalSfixed32 == -1 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_sfixed32: 1\n") { + (o: inout MessageTestType) in o.optionalSfixed32 = 1 + } assertDecodeFails([77]) assertDecodeFails([77]) assertDecodeFails([77, 0]) @@ -550,10 +589,14 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalSfixed64() { - assertEncode([81, 255, 255, 255, 255, 255, 255, 255, 127]) {(o: inout MessageTestType) in o.optionalSfixed64 = Int64.max} - assertEncode([81, 0, 0, 0, 0, 0, 0, 0, 128]) {(o: inout MessageTestType) in o.optionalSfixed64 = Int64.min} - assertDecodeSucceeds([81, 0, 0, 0, 0, 0, 0, 0, 128]) {$0.optionalSfixed64 == -9223372036854775808} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_sfixed64: 1\n") {(o: inout MessageTestType) in o.optionalSfixed64 = 1} + assertEncode([81, 255, 255, 255, 255, 255, 255, 255, 127]) { (o: inout MessageTestType) in + o.optionalSfixed64 = Int64.max + } + assertEncode([81, 0, 0, 0, 0, 0, 0, 0, 128]) { (o: inout MessageTestType) in o.optionalSfixed64 = Int64.min } + assertDecodeSucceeds([81, 0, 0, 0, 0, 0, 0, 0, 128]) { $0.optionalSfixed64 == -9_223_372_036_854_775_808 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_sfixed64: 1\n") { + (o: inout MessageTestType) in o.optionalSfixed64 = 1 + } assertDecodeFails([81]) assertDecodeFails([81, 0]) assertDecodeFails([81, 0, 0]) @@ -609,9 +652,9 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalFloat() { - assertEncode([93, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.optionalFloat = 0.0} - assertEncode([93, 0, 0, 0, 63]) {(o: inout MessageTestType) in o.optionalFloat = 0.5} - assertEncode([93, 0, 0, 0, 64]) {(o: inout MessageTestType) in o.optionalFloat = 2.0} + assertEncode([93, 0, 0, 0, 0]) { (o: inout MessageTestType) in o.optionalFloat = 0.0 } + assertEncode([93, 0, 0, 0, 63]) { (o: inout MessageTestType) in o.optionalFloat = 0.5 } + assertEncode([93, 0, 0, 0, 64]) { (o: inout MessageTestType) in o.optionalFloat = 2.0 } assertDecodeSucceeds([93, 0, 0, 0, 0]) { if $0.hasOptionalFloat { return $0.optionalFloat == 0 @@ -620,26 +663,27 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { return false } } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_float: 1.0\n") { - (o: inout MessageTestType) in o.optionalFloat = 1.0} + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_float: 1.0\n") { + (o: inout MessageTestType) in o.optionalFloat = 1.0 + } assertDecodeFails([93, 0, 0, 0]) assertDecodeFails([93, 0, 0]) assertDecodeFails([93, 0]) assertDecodeFails([93]) - assertDecodeFails([88]) // Float cannot use wire type 0 + assertDecodeFails([88]) // Float cannot use wire type 0 assertDecodesAsUnknownFields([88, 0]) // Wrong wire type (varint), valid as an unknown field - assertDecodeFails([89]) // Float cannot use wire type 1 - assertDecodeFails([89, 0, 0, 0, 0]) // Float cannot use wire type 1 - assertDecodeFails([90]) // Float cannot use wire type 2 + assertDecodeFails([89]) // Float cannot use wire type 1 + assertDecodeFails([89, 0, 0, 0, 0]) // Float cannot use wire type 1 + assertDecodeFails([90]) // Float cannot use wire type 2 assertDecodesAsUnknownFields([90, 0]) // Wrong wire type (length delimited), valid as an unknown field - assertDecodeFails([91]) // Float cannot use wire type 3 - assertDecodeFails([91, 0, 0, 0, 0]) // Float cannot use wire type 3 - assertDecodeFails([92]) // Float cannot use wire type 4 - assertDecodeFails([92, 0, 0, 0, 0]) // Float cannot use wire type 4 - assertDecodeFails([94]) // Float cannot use wire type 6 - assertDecodeFails([94, 0, 0, 0, 0]) // Float cannot use wire type 6 - assertDecodeFails([95]) // Float cannot use wire type 7 - assertDecodeFails([95, 0, 0, 0, 0]) // Float cannot use wire type 7 + assertDecodeFails([91]) // Float cannot use wire type 3 + assertDecodeFails([91, 0, 0, 0, 0]) // Float cannot use wire type 3 + assertDecodeFails([92]) // Float cannot use wire type 4 + assertDecodeFails([92, 0, 0, 0, 0]) // Float cannot use wire type 4 + assertDecodeFails([94]) // Float cannot use wire type 6 + assertDecodeFails([94, 0, 0, 0, 0]) // Float cannot use wire type 6 + assertDecodeFails([95]) // Float cannot use wire type 7 + assertDecodeFails([95, 0, 0, 0, 0]) // Float cannot use wire type 7 let empty = MessageTestType() var a = empty @@ -668,12 +712,13 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalDouble() { - assertEncode([97, 0, 0, 0, 0, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.optionalDouble = 0.0} - assertEncode([97, 0, 0, 0, 0, 0, 0, 224, 63]) {(o: inout MessageTestType) in o.optionalDouble = 0.5} - assertEncode([97, 0, 0, 0, 0, 0, 0, 0, 64]) {(o: inout MessageTestType) in o.optionalDouble = 2.0} - assertDecodeSucceeds([97, 0, 0, 0, 0, 0, 0, 224, 63]) {$0.optionalDouble == 0.5} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_double: 1.0\n") { - (o: inout MessageTestType) in o.optionalDouble = 1.0} + assertEncode([97, 0, 0, 0, 0, 0, 0, 0, 0]) { (o: inout MessageTestType) in o.optionalDouble = 0.0 } + assertEncode([97, 0, 0, 0, 0, 0, 0, 224, 63]) { (o: inout MessageTestType) in o.optionalDouble = 0.5 } + assertEncode([97, 0, 0, 0, 0, 0, 0, 0, 64]) { (o: inout MessageTestType) in o.optionalDouble = 2.0 } + assertDecodeSucceeds([97, 0, 0, 0, 0, 0, 0, 224, 63]) { $0.optionalDouble == 0.5 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_double: 1.0\n") { + (o: inout MessageTestType) in o.optionalDouble = 1.0 + } assertDecodeFails([97, 0, 0, 0, 0, 0, 0, 224]) assertDecodeFails([97]) assertDecodeFails([96]) @@ -725,8 +770,8 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalBool() { - assertEncode([104, 0]) {(o: inout MessageTestType) in o.optionalBool = false} - assertEncode([104, 1]) {(o: inout MessageTestType) in o.optionalBool = true} + assertEncode([104, 0]) { (o: inout MessageTestType) in o.optionalBool = false } + assertEncode([104, 1]) { (o: inout MessageTestType) in o.optionalBool = true } assertDecodeSucceeds([104, 1]) { if $0.hasOptionalBool { return $0.optionalBool == true @@ -735,8 +780,12 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { return false } } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_bool: true\n") {(o: inout MessageTestType) in o.optionalBool = true} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_bool: false\n") {(o: inout MessageTestType) in o.optionalBool = false} + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_bool: true\n") { + (o: inout MessageTestType) in o.optionalBool = true + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_bool: false\n") { + (o: inout MessageTestType) in o.optionalBool = false + } assertDecodeFails([104]) assertDecodeFails([104, 255]) assertDecodeFails([105]) @@ -781,11 +830,12 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalString() { - assertEncode([114, 0]) {(o: inout MessageTestType) in o.optionalString = ""} - assertEncode([114, 1, 65]) {(o: inout MessageTestType) in o.optionalString = "A"} - assertEncode([114, 4, 0xf0, 0x9f, 0x98, 0x84]) {(o: inout MessageTestType) in o.optionalString = "😄"} - assertEncode([114, 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) {(o: inout MessageTestType) in - o.optionalString = "\u{00}\u{01}\u{02}\u{03}\u{04}\u{05}\u{06}\u{07}\u{08}\u{09}\u{0a}"} + assertEncode([114, 0]) { (o: inout MessageTestType) in o.optionalString = "" } + assertEncode([114, 1, 65]) { (o: inout MessageTestType) in o.optionalString = "A" } + assertEncode([114, 4, 0xf0, 0x9f, 0x98, 0x84]) { (o: inout MessageTestType) in o.optionalString = "😄" } + assertEncode([114, 11, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) { (o: inout MessageTestType) in + o.optionalString = "\u{00}\u{01}\u{02}\u{03}\u{04}\u{05}\u{06}\u{07}\u{08}\u{09}\u{0a}" + } assertDecodeSucceeds([114, 5, 72, 101, 108, 108, 111]) { if $0.hasOptionalString { return $0.optionalString == "Hello" @@ -795,20 +845,26 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } } assertDecodeSucceeds([114, 4, 97, 0, 98, 99]) { - return $0.optionalString == "a\0bc" + $0.optionalString == "a\0bc" } assertDecodeSucceeds([114, 16, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]) { - return $0.optionalString == "\u{00}\u{01}\u{02}\u{03}\u{04}\u{05}\u{06}\u{07}\u{08}\u{09}\u{0a}\u{0b}\u{0c}\u{0d}\u{0e}\u{0f}" + $0.optionalString + == "\u{00}\u{01}\u{02}\u{03}\u{04}\u{05}\u{06}\u{07}\u{08}\u{09}\u{0a}\u{0b}\u{0c}\u{0d}\u{0e}\u{0f}" } assertDecodeSucceeds([114, 16, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]) { - return $0.optionalString == "\u{10}\u{11}\u{12}\u{13}\u{14}\u{15}\u{16}\u{17}\u{18}\u{19}\u{1a}\u{1b}\u{1c}\u{1d}\u{1e}\u{1f}" + $0.optionalString + == "\u{10}\u{11}\u{12}\u{13}\u{14}\u{15}\u{16}\u{17}\u{18}\u{19}\u{1a}\u{1b}\u{1c}\u{1d}\u{1e}\u{1f}" + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_string: \"abc\"\n") { + (o: inout MessageTestType) in o.optionalString = "abc" + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_string: \"\\b\\t\"\n") { + (o: inout MessageTestType) in o.optionalString = "\u{08}\u{09}" } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_string: \"abc\"\n") {(o: inout MessageTestType) in o.optionalString = "abc"} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_string: \"\\b\\t\"\n") {(o: inout MessageTestType) in o.optionalString = "\u{08}\u{09}"} assertDecodeFails([114]) assertDecodeFails([114, 1]) assertDecodeFails([114, 2, 65]) - assertDecodeFails([114, 1, 193]) // Invalid UTF-8 + assertDecodeFails([114, 1, 193]) // Invalid UTF-8 assertDecodeFails([112]) assertDecodesAsUnknownFields([112, 0]) // Wrong wire type (varint), valid as an unknown field assertDecodeFails([113]) @@ -824,6 +880,17 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { assertDecodeFails([119]) assertDecodeFails([119, 0]) + // Ensure strings over 2GB fail to decode according to spec. + XCTAssertThrowsError( + try MessageTestType(serializedBytes: [ + 114, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, + // Don't need all the bytes, want some to let the length issue trigger. + 0x01, 0x02, 0x03, + ]) + ) { + XCTAssertEqual($0 as! BinaryDecodingError, .malformedProtobuf) + } + let empty = MessageTestType() var a = empty a.optionalString = "" @@ -851,7 +918,7 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalGroup() { - assertEncode([131, 1, 136, 1, 159, 141, 6, 132, 1]) {(o: inout MessageTestType) in + assertEncode([131, 1, 136, 1, 159, 141, 6, 132, 1]) { (o: inout MessageTestType) in var g = MessageTestType.OptionalGroup() g.a = 99999 o.optionalGroup = g @@ -862,36 +929,37 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { // Extra field 1 (varint of zero) within group assertDecodeSucceeds([131, 1, 8, 0, 136, 1, 159, 141, 6, 132, 1]) { $0.optionalGroup.a == 99999 - && $0.optionalGroup.unknownFields.data == Data([8, 0]) + && $0.optionalGroup.unknownFields.data == Data([8, 0]) } // Empty group assertDecodeSucceeds([131, 1, 132, 1]) { $0.optionalGroup == MessageTestType.OptionalGroup() } assertDebugDescription( - "SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\nOptionalGroup {\n a: 1\n}\n") {(o: inout MessageTestType) in + "SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\nOptionalGroup {\n a: 1\n}\n" + ) { (o: inout MessageTestType) in var g = MessageTestType.OptionalGroup() g.a = 1 o.optionalGroup = g } - assertDecodeFails([131, 1, 136, 1, 159, 141, 6]) // End group missing. - assertDecodeFails([131, 1, 136, 1, 159, 141, 6, 132, 2]) // Wrong end group. + assertDecodeFails([131, 1, 136, 1, 159, 141, 6]) // End group missing. + assertDecodeFails([131, 1, 136, 1, 159, 141, 6, 132, 2]) // Wrong end group. - assertDecodeFails([128, 1]) // Bad wire type + assertDecodeFails([128, 1]) // Bad wire type assertDecodesAsUnknownFields([128, 1, 0]) // Wrong wire type (varint), valid as an unknown field assertDecodesAsUnknownFields([128, 1, 132, 1]) // Wrong wire type (varint), valid as an unknown field - assertDecodeFails([129, 1]) // Bad wire type - assertDecodeFails([129, 1, 0]) // Bad wire type - assertDecodeFails([130, 1]) // Bad wire type + assertDecodeFails([129, 1]) // Bad wire type + assertDecodeFails([129, 1, 0]) // Bad wire type + assertDecodeFails([130, 1]) // Bad wire type assertDecodesAsUnknownFields([130, 1, 0]) // Wrong wire type (length delimited), valid as an unknown field - assertDecodeFails([131, 1]) // Lone start marker should fail - assertDecodeFails([132, 1]) // Lone stop marker should fail - assertDecodeFails([133, 1]) // Bad wire type - assertDecodeFails([133, 1, 0]) // Bad wire type - assertDecodeFails([134, 1]) // Bad wire type - assertDecodeFails([134, 1, 0]) // Bad wire type - assertDecodeFails([135, 1]) // Bad wire type - assertDecodeFails([135, 1, 0]) // Bad wire type + assertDecodeFails([131, 1]) // Lone start marker should fail + assertDecodeFails([132, 1]) // Lone stop marker should fail + assertDecodeFails([133, 1]) // Bad wire type + assertDecodeFails([133, 1, 0]) // Bad wire type + assertDecodeFails([134, 1]) // Bad wire type + assertDecodeFails([134, 1, 0]) // Bad wire type + assertDecodeFails([135, 1]) // Bad wire type + assertDecodeFails([135, 1, 0]) // Bad wire type // Ensure storage is uniqued for clear. let c = MessageTestType.with { @@ -908,9 +976,9 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalBytes() { - assertEncode([122, 0]) {(o: inout MessageTestType) in o.optionalBytes = Data()} - assertEncode([122, 1, 1]) {(o: inout MessageTestType) in o.optionalBytes = Data([1])} - assertEncode([122, 2, 1, 2]) {(o: inout MessageTestType) in o.optionalBytes = Data([1, 2])} + assertEncode([122, 0]) { (o: inout MessageTestType) in o.optionalBytes = Data() } + assertEncode([122, 1, 1]) { (o: inout MessageTestType) in o.optionalBytes = Data([1]) } + assertEncode([122, 2, 1, 2]) { (o: inout MessageTestType) in o.optionalBytes = Data([1, 2]) } assertDecodeSucceeds([122, 4, 0, 1, 2, 255]) { if $0.hasOptionalBytes { return $0.optionalBytes == Data([0, 1, 2, 255]) @@ -919,7 +987,9 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { return false } } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_bytes: \"\\001\\002\\003\"\n") {(o: inout MessageTestType) in o.optionalBytes = Data([1, 2, 3])} + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_bytes: \"\\001\\002\\003\"\n" + ) { (o: inout MessageTestType) in o.optionalBytes = Data([1, 2, 3]) } assertDecodeFails([122]) assertDecodeFails([122, 1]) assertDecodeFails([122, 2, 0]) @@ -939,6 +1009,17 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { assertDecodeFails([127]) assertDecodeFails([127, 0]) + // Ensure bytes over 2GB fail to decode according to spec. + XCTAssertThrowsError( + try MessageTestType(serializedBytes: [ + 122, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, + // Don't need all the bytes, want some to let the length issue trigger. + 0x01, 0x02, 0x03, + ]) + ) { + XCTAssertEqual($0 as! BinaryDecodingError, .malformedProtobuf) + } + let empty = MessageTestType() var a = empty a.optionalBytes = Data() @@ -966,14 +1047,16 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalNestedMessage() { - assertEncode([146, 1, 2, 8, 1]) {(o: inout MessageTestType) in + assertEncode([146, 1, 2, 8, 1]) { (o: inout MessageTestType) in var nested = MessageTestType.NestedMessage() nested.bb = 1 o.optionalNestedMessage = nested } - assertDecodeSucceeds([146, 1, 4, 8, 1, 8, 3]) {$0.optionalNestedMessage.bb == 3} - assertDecodeSucceeds([146, 1, 2, 8, 1, 146, 1, 2, 8, 4]) {$0.optionalNestedMessage.bb == 4} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_nested_message {\n bb: 1\n}\n") {(o: inout MessageTestType) in + assertDecodeSucceeds([146, 1, 4, 8, 1, 8, 3]) { $0.optionalNestedMessage.bb == 3 } + assertDecodeSucceeds([146, 1, 2, 8, 1, 146, 1, 2, 8, 4]) { $0.optionalNestedMessage.bb == 4 } + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_nested_message {\n bb: 1\n}\n" + ) { (o: inout MessageTestType) in var nested = MessageTestType.NestedMessage() nested.bb = 1 o.optionalNestedMessage = nested @@ -982,6 +1065,17 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { assertDecodeFails([146, 1, 2, 8, 128]) assertDecodeFails([146, 1, 1, 128]) + // Ensure message field over 2GB fail to decode according to spec. + XCTAssertThrowsError( + try MessageTestType(serializedBytes: [ + 146, 1, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, + // Don't need all the bytes, want some to let the length issue trigger. + 0x01, 0x02, 0x03, + ]) + ) { + XCTAssertEqual($0 as! BinaryDecodingError, .malformedProtobuf) + } + // Ensure storage is uniqued for clear. let c = MessageTestType.with { $0.optionalNestedMessage.bb = 1 @@ -998,14 +1092,16 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { // Known message field followed by unknown field func testEncoding_optionalNestedMessage_unknown1() throws { - let bytes: [UInt8] = [146, 1, 2, 8, 1, // nested message with bb=1 - 208, 41, 0] // Unknown field 666 with varint 0 + let bytes: [UInt8] = [ + 146, 1, 2, 8, 1, // nested message with bb=1 + 208, 41, 0, + ] // Unknown field 666 with varint 0 do { - let m = try MessageTestType(serializedData: Data(bytes)) - XCTAssertEqual(m.optionalNestedMessage, MessageTestType.NestedMessage.with{$0.bb = 1}) + let m = try MessageTestType(serializedBytes: bytes) + XCTAssertEqual(m.optionalNestedMessage, MessageTestType.NestedMessage.with { $0.bb = 1 }) do { - let recoded = try m.serializedData() - XCTAssertEqual(recoded, Data(bytes)) + let recoded: [UInt8] = try m.serializedBytes() + XCTAssertEqual(recoded, bytes) } catch let e { XCTFail("Failed to recode: \(e)") } @@ -1016,16 +1112,18 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { // Unknown field followed by known message field func testEncoding_optionalNestedMessage_unknown2() throws { - let bytes: [UInt8] = [208, 41, 0, // Unknown 666 with varint 0 - 146, 1, 2, 8, 1] // Nested msg with bb=1 + let bytes: [UInt8] = [ + 208, 41, 0, // Unknown 666 with varint 0 + 146, 1, 2, 8, 1, + ] // Nested msg with bb=1 do { - let m = try MessageTestType(serializedData: Data(bytes)) - XCTAssertEqual(m.optionalNestedMessage, MessageTestType.NestedMessage.with{$0.bb = 1}) + let m = try MessageTestType(serializedBytes: bytes) + XCTAssertEqual(m.optionalNestedMessage, MessageTestType.NestedMessage.with { $0.bb = 1 }) do { - let recoded = try m.serializedData() + let recoded: [UInt8] = try m.serializedBytes() // Unknown field gets reserialized at end let expectedBytes: [UInt8] = [146, 1, 2, 8, 1, 208, 41, 0] - XCTAssertEqual(recoded, Data(expectedBytes)) + XCTAssertEqual(recoded, expectedBytes) } catch let e { XCTFail("Failed to recode: \(e)") } @@ -1038,15 +1136,17 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { func testEncoding_optionalNestedMessage_unknown3() throws { // Inner field has bb=1 (8, 1) and unknown 666 with varint 99 // Outer message has unknown 666 with varint 0 - let bytes: [UInt8] = [146, 1, 5, 8, 1, 208, 41, 99, - 208, 41, 0] + let bytes: [UInt8] = [ + 146, 1, 5, 8, 1, 208, 41, 99, + 208, 41, 0, + ] do { - let m = try MessageTestType(serializedData: Data(bytes)) - XCTAssertNotEqual(m.optionalNestedMessage, MessageTestType.NestedMessage.with{$0.bb = 1}) + let m = try MessageTestType(serializedBytes: bytes) + XCTAssertNotEqual(m.optionalNestedMessage, MessageTestType.NestedMessage.with { $0.bb = 1 }) XCTAssertEqual(m.optionalNestedMessage.bb, 1) do { - let recoded = try m.serializedData() - XCTAssertEqual(recoded, Data(bytes)) + let recoded: [UInt8] = try m.serializedBytes() + XCTAssertEqual(recoded, bytes) } catch let e { XCTFail("Failed to recode: \(e)") } @@ -1061,14 +1161,14 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { // first in outer and inner message let bytes: [UInt8] = [208, 41, 0, 146, 1, 5, 208, 41, 99, 8, 1] do { - let m = try MessageTestType(serializedData: Data(bytes)) - XCTAssertNotEqual(m.optionalNestedMessage, MessageTestType.NestedMessage.with{$0.bb = 1}) + let m = try MessageTestType(serializedBytes: bytes) + XCTAssertNotEqual(m.optionalNestedMessage, MessageTestType.NestedMessage.with { $0.bb = 1 }) XCTAssertEqual(m.optionalNestedMessage.bb, 1) do { - let recoded = try m.serializedData() + let recoded: [UInt8] = try m.serializedBytes() // Reserializing moves unknown fields to end let expectedBytes: [UInt8] = [146, 1, 5, 8, 1, 208, 41, 99, 208, 41, 0] - XCTAssertEqual(recoded, Data(expectedBytes)) + XCTAssertEqual(recoded, expectedBytes) } catch let e { XCTFail("Failed to recode: \(e)") } @@ -1078,36 +1178,44 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalForeignMessage() { - assertEncode([154, 1, 2, 8, 1]) {(o: inout MessageTestType) in - var foreign = ProtobufUnittest_ForeignMessage() + assertEncode([154, 1, 2, 8, 1]) { (o: inout MessageTestType) in + var foreign = SwiftProtoTesting_ForeignMessage() foreign.c = 1 o.optionalForeignMessage = foreign } - assertDecodeSucceeds([154, 1, 4, 8, 1, 8, 3]) {$0.optionalForeignMessage.c == 3} - assertDecodeSucceeds([154, 1, 2, 8, 1, 154, 1, 2, 8, 4]) {$0.optionalForeignMessage.c == 4} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_foreign_message {\n c: 1\n}\n") {(o: inout MessageTestType) in - var foreign = ProtobufUnittest_ForeignMessage() + assertDecodeSucceeds([154, 1, 4, 8, 1, 8, 3]) { $0.optionalForeignMessage.c == 3 } + assertDecodeSucceeds([154, 1, 2, 8, 1, 154, 1, 2, 8, 4]) { $0.optionalForeignMessage.c == 4 } + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_foreign_message {\n c: 1\n}\n" + ) { (o: inout MessageTestType) in + var foreign = SwiftProtoTesting_ForeignMessage() foreign.c = 1 o.optionalForeignMessage = foreign } assertDecodesAsUnknownFields([152, 1, 0]) // Wrong wire type (varint), valid as an unknown field - assertDecodeFails([153, 1]) // Wire type 1 + assertDecodeFails([153, 1]) // Wire type 1 assertDecodeFails([153, 1, 0]) - assertDecodesAsUnknownFields([153, 1, 0, 0, 0, 0, 0, 0, 0, 0]) // Wrong wire type (fixed64), valid as an unknown field - assertDecodeFails([155, 1]) // Wire type 3 + assertDecodesAsUnknownFields([ + 153, 1, // Wrong wire type (fixed64), valid as an unknown field + 0, 0, 0, 0, 0, 0, 0, 0, + ]) + assertDecodeFails([155, 1]) // Wire type 3 assertDecodeFails([155, 1, 0]) - assertDecodesAsUnknownFields([155, 1, 156, 1]) // Wrong wire type (start group, end group), valid as an unknown field - assertDecodeFails([156, 1]) // Wire type 4 + assertDecodesAsUnknownFields([ + 155, 1, // Wrong wire type (start group, end group), valid as an unknown field + 156, 1, + ]) + assertDecodeFails([156, 1]) // Wire type 4 assertDecodeFails([156, 1, 0]) - assertDecodeFails([157, 1]) // Wire type 5 + assertDecodeFails([157, 1]) // Wire type 5 assertDecodeFails([157, 1, 0]) assertDecodesAsUnknownFields([157, 1, 0, 0, 0, 0]) // Wrong wire type (fixed32), valid as an unknown field - assertDecodeFails([158, 1]) // Wire type 6 + assertDecodeFails([158, 1]) // Wire type 6 assertDecodeFails([158, 1, 0]) - assertDecodeFails([159, 1]) // Wire type 7 + assertDecodeFails([159, 1]) // Wire type 7 assertDecodeFails([159, 1, 0]) - assertDecodeFails([154, 1, 4, 8, 1]) // Truncated + assertDecodeFails([154, 1, 4, 8, 1]) // Truncated // Ensure storage is uniqued for clear. let c = MessageTestType.with { @@ -1124,13 +1232,13 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalImportMessage() { - assertEncode([162, 1, 2, 8, 1]) {(o: inout MessageTestType) in - var imp = ProtobufUnittestImport_ImportMessage() + assertEncode([162, 1, 2, 8, 1]) { (o: inout MessageTestType) in + var imp = SwiftProtoTesting_Import_ImportMessage() imp.d = 1 o.optionalImportMessage = imp } - assertDecodeSucceeds([162, 1, 4, 8, 1, 8, 3]) {$0.optionalImportMessage.d == 3} - assertDecodeSucceeds([162, 1, 2, 8, 1, 162, 1, 2, 8, 4]) {$0.optionalImportMessage.d == 4} + assertDecodeSucceeds([162, 1, 4, 8, 1, 8, 3]) { $0.optionalImportMessage.d == 3 } + assertDecodeSucceeds([162, 1, 2, 8, 1, 162, 1, 2, 8, 4]) { $0.optionalImportMessage.d == 4 } // Ensure storage is uniqued for clear. let c = MessageTestType.with { @@ -1147,7 +1255,7 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalNestedEnum() throws { - assertEncode([168, 1, 2]) {(o: inout MessageTestType) in + assertEncode([168, 1, 2]) { (o: inout MessageTestType) in o.optionalNestedEnum = .bar } assertDecodeSucceeds([168, 1, 2]) { @@ -1160,15 +1268,16 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } assertDecodeFails([168, 1]) assertDecodeSucceeds([168, 1, 128, 1]) { !$0.hasOptionalNestedEnum } - assertDecodeSucceeds([168, 1, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1]) {$0.optionalNestedEnum == .neg} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_nested_enum: BAR\n") {(o: inout MessageTestType) in + assertDecodeSucceeds([168, 1, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1]) { $0.optionalNestedEnum == .neg } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_nested_enum: BAR\n") { + (o: inout MessageTestType) in o.optionalNestedEnum = .bar } // The out-of-range enum value should be preserved as an unknown field - let decoded = try ProtobufUnittest_TestAllTypes(serializedData: Data([168, 1, 128, 1])) + let decoded = try SwiftProtoTesting_TestAllTypes(serializedBytes: [168, 1, 128, 1]) XCTAssertFalse(decoded.hasOptionalNestedEnum) - let recoded = try decoded.serializedBytes() + let recoded: [UInt8] = try decoded.serializedBytes() XCTAssertEqual(recoded, [168, 1, 128, 1]) // Ensure storage is uniqued for clear. @@ -1186,10 +1295,12 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalForeignEnum() { - assertEncode([176, 1, 5]) {(o: inout MessageTestType) in + assertEncode([176, 1, 5]) { (o: inout MessageTestType) in o.optionalForeignEnum = .foreignBar } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_foreign_enum: FOREIGN_BAR\n") {(o: inout MessageTestType) in + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_foreign_enum: FOREIGN_BAR\n" + ) { (o: inout MessageTestType) in o.optionalForeignEnum = .foreignBar } @@ -1208,10 +1319,11 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_optionalImportEnum() { - assertEncode([184, 1, 8]) {(o: inout MessageTestType) in + assertEncode([184, 1, 8]) { (o: inout MessageTestType) in o.optionalImportEnum = .importBar } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_import_enum: IMPORT_BAR\n") {(o: inout MessageTestType) in + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_import_enum: IMPORT_BAR\n") + { (o: inout MessageTestType) in o.optionalImportEnum = .importBar } @@ -1229,99 +1341,65 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { XCTAssertFalse(d.hasOptionalImportEnum) } - func testEncoding_optionalStringPiece() { - assertEncode([194, 1, 6, 97, 98, 99, 100, 101, 102]) {(o: inout MessageTestType) in - o.optionalStringPiece = "abcdef" - } - - // Ensure storage is uniqued for clear. - let c = MessageTestType.with { - $0.optionalStringPiece = "mumble" - } - var d = c - XCTAssertEqual(c, d) - XCTAssertTrue(c.hasOptionalStringPiece) - XCTAssertTrue(d.hasOptionalStringPiece) - d.clearOptionalStringPiece() - XCTAssertNotEqual(c, d) - XCTAssertTrue(c.hasOptionalStringPiece) - XCTAssertFalse(d.hasOptionalStringPiece) - } - - func testEncoding_optionalCord() { - assertEncode([202, 1, 6, 102, 101, 100, 99, 98, 97]) {(o: inout MessageTestType) in - o.optionalCord = "fedcba" - } - - // Ensure storage is uniqued for clear. - let c = MessageTestType.with { - $0.optionalCord = "mumble" - } - var d = c - XCTAssertEqual(c, d) - XCTAssertTrue(c.hasOptionalCord) - XCTAssertTrue(d.hasOptionalCord) - d.clearOptionalCord() - XCTAssertNotEqual(c, d) - XCTAssertTrue(c.hasOptionalCord) - XCTAssertFalse(d.hasOptionalCord) - } - func testEncoding_optionalPublicImportMessage() { - assertEncode([210, 1, 2, 8, 12]) {(o: inout MessageTestType) in - var sub = ProtobufUnittestImport_PublicImportMessage() + assertEncode([210, 1, 2, 8, 12]) { (o: inout MessageTestType) in + var sub = SwiftProtoTesting_Import_PublicImportMessage() sub.e = 12 o.optionalPublicImportMessage = sub } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_public_import_message {\n e: 9999\n}\n") {(o: inout MessageTestType) in - var sub = ProtobufUnittestImport_PublicImportMessage() + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_public_import_message {\n e: 9999\n}\n" + ) { (o: inout MessageTestType) in + var sub = SwiftProtoTesting_Import_PublicImportMessage() sub.e = 9999 o.optionalPublicImportMessage = sub } } - func testEncoding_optionalLazyMessage() { - assertEncode([218, 1, 2, 8, 7]) {(o: inout MessageTestType) in - var m = MessageTestType.NestedMessage() - m.bb = 7 - o.optionalLazyMessage = m - } - } - // // Repeated types // func testEncoding_repeatedInt32() { - assertEncode([248, 1, 255, 255, 255, 255, 7, 248, 1, 128, 128, 128, 128, 248, 255, 255, 255, 255, 1]) {(o: inout MessageTestType) in o.repeatedInt32 = [Int32.max, Int32.min]} - assertDecodeSucceeds([248, 1, 8, 248, 1, 247, 255, 255, 255, 15]) {$0.repeatedInt32 == [8, -9]} + assertEncode([248, 1, 255, 255, 255, 255, 7, 248, 1, 128, 128, 128, 128, 248, 255, 255, 255, 255, 1]) { + (o: inout MessageTestType) in o.repeatedInt32 = [Int32.max, Int32.min] + } + assertDecodeSucceeds([248, 1, 8, 248, 1, 247, 255, 255, 255, 15]) { $0.repeatedInt32 == [8, -9] } assertDecodeFails([248, 1, 8, 248, 1, 247, 255, 255, 255, 255, 255, 255, 255, 255]) assertDecodeFails([248, 1, 8, 248, 1]) assertDecodeFails([248, 1]) assertDecodeFails([249, 1, 73]) // 250, 1 should actually work because that's packed - assertDecodeSucceeds([250, 1, 4, 8, 9, 10, 11]) {$0.repeatedInt32 == [8, 9, 10, 11]} + assertDecodeSucceeds([250, 1, 4, 8, 9, 10, 11]) { $0.repeatedInt32 == [8, 9, 10, 11] } assertDecodeFails([251, 1, 75]) assertDecodeFails([252, 1, 76]) assertDecodeFails([253, 1, 77]) assertDecodeFails([254, 1, 78]) assertDecodeFails([255, 1, 79]) - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\nrepeated_int32: 1\n") {(o: inout MessageTestType) in + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\nrepeated_int32: 1\n") { + (o: inout MessageTestType) in o.repeatedInt32 = [1] } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\n") {(o: inout MessageTestType) in + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\n") { (o: inout MessageTestType) in o.repeatedInt32 = [] } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\nrepeated_int32: 1\nrepeated_int32: 2\n") {(o: inout MessageTestType) in + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\nrepeated_int32: 1\nrepeated_int32: 2\n" + ) { (o: inout MessageTestType) in o.repeatedInt32 = [1, 2] } } - func testEncoding_repeatedInt64() { - assertEncode([128, 2, 255, 255, 255, 255, 255, 255, 255, 255, 127, 128, 2, 128, 128, 128, 128, 128, 128, 128, 128, 128, 1]) {(o: inout MessageTestType) in o.repeatedInt64 = [Int64.max, Int64.min]} - assertDecodeSucceeds([128, 2, 255, 255, 153, 166, 234, 175, 227, 1, 128, 2, 185, 156, 196, 237, 158, 222, 230, 255, 255, 1]) {$0.repeatedInt64 == [999999999999999, -111111111111111]} - assertDecodeSucceeds([130, 2, 1, 1]) {$0.repeatedInt64 == [1]} // Accepts packed coding - assertDecodeFails([128, 2, 255, 255, 153, 166, 234, 175, 227, 1, 128, 2, 185, 156, 196, 237, 158, 222, 230, 255, 255]) + assertEncode([ + 128, 2, 255, 255, 255, 255, 255, 255, 255, 255, 127, 128, 2, 128, 128, 128, 128, 128, 128, 128, 128, 128, 1, + ]) { (o: inout MessageTestType) in o.repeatedInt64 = [Int64.max, Int64.min] } + assertDecodeSucceeds([ + 128, 2, 255, 255, 153, 166, 234, 175, 227, 1, 128, 2, 185, 156, 196, 237, 158, 222, 230, 255, 255, 1, + ]) { $0.repeatedInt64 == [999_999_999_999_999, -111_111_111_111_111] } + assertDecodeSucceeds([130, 2, 1, 1]) { $0.repeatedInt64 == [1] } // Accepts packed coding + assertDecodeFails([ + 128, 2, 255, 255, 153, 166, 234, 175, 227, 1, 128, 2, 185, 156, 196, 237, 158, 222, 230, 255, 255, + ]) assertDecodeFails([128, 2, 1, 128, 2]) assertDecodeFails([128, 2, 128]) assertDecodeFails([128, 2]) @@ -1334,19 +1412,26 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_repeatedUint32() { - assertEncode([136, 2, 255, 255, 255, 255, 15, 136, 2, 0]) {(o: inout MessageTestType) in o.repeatedUint32 = [UInt32.max, UInt32.min]} - assertDecodeSucceeds([136, 2, 210, 9, 136, 2, 213, 27]) {(o:MessageTestType) in - o.repeatedUint32 == [1234, 3541]} - assertDecodeSucceeds([136, 2, 255, 255, 255, 255, 15, 136, 2, 213, 27]) {(o:MessageTestType) in - o.repeatedUint32 == [4294967295, 3541]} - assertDecodeSucceeds([138, 2, 2, 1, 2]) {(o:MessageTestType) in - o.repeatedUint32 == [1, 2]} + assertEncode([136, 2, 255, 255, 255, 255, 15, 136, 2, 0]) { (o: inout MessageTestType) in + o.repeatedUint32 = [UInt32.max, UInt32.min] + } + assertDecodeSucceeds([136, 2, 210, 9, 136, 2, 213, 27]) { (o: MessageTestType) in + o.repeatedUint32 == [1234, 3541] + } + assertDecodeSucceeds([136, 2, 255, 255, 255, 255, 15, 136, 2, 213, 27]) { (o: MessageTestType) in + o.repeatedUint32 == [4_294_967_295, 3541] + } + assertDecodeSucceeds([138, 2, 2, 1, 2]) { (o: MessageTestType) in + o.repeatedUint32 == [1, 2] + } // Truncate on 32-bit overflow - assertDecodeSucceeds([136, 2, 255, 255, 255, 255, 31]) {(o:MessageTestType) in - o.repeatedUint32 == [4294967295]} - assertDecodeSucceeds([136, 2, 255, 255, 255, 255, 255, 255, 255, 1]) {(o:MessageTestType) in - o.repeatedUint32 == [4294967295]} + assertDecodeSucceeds([136, 2, 255, 255, 255, 255, 31]) { (o: MessageTestType) in + o.repeatedUint32 == [4_294_967_295] + } + assertDecodeSucceeds([136, 2, 255, 255, 255, 255, 255, 255, 255, 1]) { (o: MessageTestType) in + o.repeatedUint32 == [4_294_967_295] + } assertDecodeFails([136, 2]) assertDecodeFails([136, 2, 210]) @@ -1360,9 +1445,11 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_repeatedUint64() { - assertEncode([144, 2, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1, 144, 2, 0]) {(o: inout MessageTestType) in o.repeatedUint64 = [UInt64.max, UInt64.min]} - assertDecodeSucceeds([144, 2, 149, 8]) {$0.repeatedUint64 == [1045 ]} - assertDecodeSucceeds([146, 2, 2, 0, 1]) {$0.repeatedUint64 == [0, 1]} + assertEncode([144, 2, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1, 144, 2, 0]) { + (o: inout MessageTestType) in o.repeatedUint64 = [UInt64.max, UInt64.min] + } + assertDecodeSucceeds([144, 2, 149, 8]) { $0.repeatedUint64 == [1045] } + assertDecodeSucceeds([146, 2, 2, 0, 1]) { $0.repeatedUint64 == [0, 1] } assertDecodeFails([144]) assertDecodeFails([144, 2]) assertDecodeFails([144, 2, 149]) @@ -1382,13 +1469,18 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_repeatedSint32() { - assertEncode([152, 2, 254, 255, 255, 255, 15, 152, 2, 255, 255, 255, 255, 15]) {(o: inout MessageTestType) in o.repeatedSint32 = [Int32.max, Int32.min]} - assertDecodeSucceeds([152, 2, 170, 180, 222, 117, 152, 2, 225, 162, 243, 173, 1]) {$0.repeatedSint32 == [123456789, -182347953]} - assertDecodeSucceeds([154, 2, 1, 0]) {$0.repeatedSint32 == [0]} - assertDecodeSucceeds([154, 2, 1, 1, 152, 2, 2]) {$0.repeatedSint32 == [-1, 1]} + assertEncode([152, 2, 254, 255, 255, 255, 15, 152, 2, 255, 255, 255, 255, 15]) { (o: inout MessageTestType) in + o.repeatedSint32 = [Int32.max, Int32.min] + } + assertDecodeSucceeds([152, 2, 170, 180, 222, 117, 152, 2, 225, 162, 243, 173, 1]) { + $0.repeatedSint32 == [123_456_789, -182_347_953] + } + assertDecodeSucceeds([154, 2, 1, 0]) { $0.repeatedSint32 == [0] } + assertDecodeSucceeds([154, 2, 1, 1, 152, 2, 2]) { $0.repeatedSint32 == [-1, 1] } // 32-bit overflow truncates - assertDecodeSucceeds([152, 2, 170, 180, 222, 117, 152, 2, 225, 162, 243, 173, 255, 255, 1]) {$0.repeatedSint32 == [123456789, -2061396145]} - + assertDecodeSucceeds([152, 2, 170, 180, 222, 117, 152, 2, 225, 162, 243, 173, 255, 255, 1]) { + $0.repeatedSint32 == [123_456_789, -2_061_396_145] + } assertDecodeFails([152, 2, 170, 180, 222, 117, 152]) assertDecodeFails([152, 2, 170, 180, 222, 117, 152, 2]) @@ -1409,9 +1501,14 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_repeatedSint64() { - assertEncode([160, 2, 254, 255, 255, 255, 255, 255, 255, 255, 255, 1, 160, 2, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1]) {(o: inout MessageTestType) in o.repeatedSint64 = [Int64.max, Int64.min]} - assertDecodeSucceeds([160, 2, 170, 180, 222, 117, 160, 2, 225, 162, 243, 173, 255, 89]) {$0.repeatedSint64 == [123456789,-1546102139057]} - assertDecodeSucceeds([162, 2, 1, 1]) {$0.repeatedSint64 == [-1]} + assertEncode([ + 160, 2, 254, 255, 255, 255, 255, 255, 255, 255, 255, 1, 160, 2, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 1, + ]) { (o: inout MessageTestType) in o.repeatedSint64 = [Int64.max, Int64.min] } + assertDecodeSucceeds([160, 2, 170, 180, 222, 117, 160, 2, 225, 162, 243, 173, 255, 89]) { + $0.repeatedSint64 == [123_456_789, -1_546_102_139_057] + } + assertDecodeSucceeds([162, 2, 1, 1]) { $0.repeatedSint64 == [-1] } assertDecodeFails([160, 2, 170, 180, 222, 117, 160]) assertDecodeFails([160, 2, 170, 180, 222, 117, 160, 2]) assertDecodeFails([160, 2, 170, 180, 222, 117, 160, 2, 225]) @@ -1431,9 +1528,15 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_repeatedFixed32() { - assertEncode([173, 2, 255, 255, 255, 255, 173, 2, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.repeatedFixed32 = [UInt32.max, UInt32.min]} - assertDecodeSucceeds([173, 2, 255, 255, 255, 127, 173, 2, 127, 127, 127, 127]) {$0.repeatedFixed32 == [2147483647, 2139062143]} - assertDecodeSucceeds([170, 2, 4, 1, 0, 0, 0, 173, 2, 255, 255, 255, 127]) {$0.repeatedFixed32 == [1, 2147483647]} + assertEncode([173, 2, 255, 255, 255, 255, 173, 2, 0, 0, 0, 0]) { (o: inout MessageTestType) in + o.repeatedFixed32 = [UInt32.max, UInt32.min] + } + assertDecodeSucceeds([173, 2, 255, 255, 255, 127, 173, 2, 127, 127, 127, 127]) { + $0.repeatedFixed32 == [2_147_483_647, 2_139_062_143] + } + assertDecodeSucceeds([170, 2, 4, 1, 0, 0, 0, 173, 2, 255, 255, 255, 127]) { + $0.repeatedFixed32 == [1, 2_147_483_647] + } assertDecodeFails([173]) assertDecodeFails([173, 2]) assertDecodeFails([173, 2, 255]) @@ -1465,10 +1568,17 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_repeatedFixed64() { - assertEncode([177, 2, 255, 255, 255, 255, 255, 255, 255, 255, 177, 2, 0, 0, 0, 0, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.repeatedFixed64 = [UInt64.max, UInt64.min]} - assertDecodeSucceeds([177, 2, 255, 255, 255, 127, 0, 0, 0, 0, 177, 2, 255, 255, 255, 255, 0, 0, 0, 0, 177, 2, 255, 255, 255, 255, 255, 255, 255, 255]) {$0.repeatedFixed64 == [2147483647, 4294967295, 18446744073709551615]} - assertDecodeSucceeds([178, 2, 8, 1, 0, 0, 0, 0, 0, 0, 0]) {$0.repeatedFixed64 == [1]} - assertDecodeSucceeds([177, 2, 2, 0, 0, 0, 0, 0, 0, 0, 178, 2, 8, 1, 0, 0, 0, 0, 0, 0, 0]) {$0.repeatedFixed64 == [2, 1]} + assertEncode([177, 2, 255, 255, 255, 255, 255, 255, 255, 255, 177, 2, 0, 0, 0, 0, 0, 0, 0, 0]) { + (o: inout MessageTestType) in o.repeatedFixed64 = [UInt64.max, UInt64.min] + } + assertDecodeSucceeds([ + 177, 2, 255, 255, 255, 127, 0, 0, 0, 0, 177, 2, 255, 255, 255, 255, 0, 0, 0, 0, 177, 2, 255, 255, 255, 255, + 255, 255, 255, 255, + ]) { $0.repeatedFixed64 == [2_147_483_647, 4_294_967_295, 18_446_744_073_709_551_615] } + assertDecodeSucceeds([178, 2, 8, 1, 0, 0, 0, 0, 0, 0, 0]) { $0.repeatedFixed64 == [1] } + assertDecodeSucceeds([177, 2, 2, 0, 0, 0, 0, 0, 0, 0, 178, 2, 8, 1, 0, 0, 0, 0, 0, 0, 0]) { + $0.repeatedFixed64 == [2, 1] + } assertDecodeFails([177]) assertDecodeFails([177, 2]) assertDecodeFails([177, 2, 255]) @@ -1497,9 +1607,11 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_repeatedSfixed32() { - assertEncode([189, 2, 255, 255, 255, 127, 189, 2, 0, 0, 0, 128]) {(o: inout MessageTestType) in o.repeatedSfixed32 = [Int32.max, Int32.min]} - assertDecodeSucceeds([189, 2, 0, 0, 0, 0]) {$0.repeatedSfixed32 == [0]} - assertDecodeSucceeds([186, 2, 4, 1, 0, 0, 0, 189, 2, 3, 0, 0, 0]) {$0.repeatedSfixed32 == [1, 3]} + assertEncode([189, 2, 255, 255, 255, 127, 189, 2, 0, 0, 0, 128]) { (o: inout MessageTestType) in + o.repeatedSfixed32 = [Int32.max, Int32.min] + } + assertDecodeSucceeds([189, 2, 0, 0, 0, 0]) { $0.repeatedSfixed32 == [0] } + assertDecodeSucceeds([186, 2, 4, 1, 0, 0, 0, 189, 2, 3, 0, 0, 0]) { $0.repeatedSfixed32 == [1, 3] } assertDecodeFails([189]) assertDecodeFails([189, 2]) assertDecodeFails([189, 2, 0]) @@ -1526,9 +1638,16 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_repeatedSfixed64() { - assertEncode([193, 2, 255, 255, 255, 255, 255, 255, 255, 127, 193, 2, 0, 0, 0, 0, 0, 0, 0, 128]) {(o: inout MessageTestType) in o.repeatedSfixed64 = [Int64.max, Int64.min]} - assertDecodeSucceeds([193, 2, 0, 0, 0, 0, 0, 0, 0, 128, 193, 2, 255, 255, 255, 255, 255, 255, 255, 255, 193, 2, 1, 0, 0, 0, 0, 0, 0, 0, 193, 2, 255, 255, 255, 255, 255, 255, 255, 127]) {$0.repeatedSfixed64 == [-9223372036854775808, -1, 1, 9223372036854775807]} - assertDecodeSucceeds([194, 2, 8, 0, 0, 0, 0, 0, 0, 0, 0, 193, 2, 1, 0, 0, 0, 0, 0, 0, 0]) {$0.repeatedSfixed64 == [0, 1]} + assertEncode([193, 2, 255, 255, 255, 255, 255, 255, 255, 127, 193, 2, 0, 0, 0, 0, 0, 0, 0, 128]) { + (o: inout MessageTestType) in o.repeatedSfixed64 = [Int64.max, Int64.min] + } + assertDecodeSucceeds([ + 193, 2, 0, 0, 0, 0, 0, 0, 0, 128, 193, 2, 255, 255, 255, 255, 255, 255, 255, 255, 193, 2, 1, 0, 0, 0, 0, 0, + 0, 0, 193, 2, 255, 255, 255, 255, 255, 255, 255, 127, + ]) { $0.repeatedSfixed64 == [-9_223_372_036_854_775_808, -1, 1, 9_223_372_036_854_775_807] } + assertDecodeSucceeds([194, 2, 8, 0, 0, 0, 0, 0, 0, 0, 0, 193, 2, 1, 0, 0, 0, 0, 0, 0, 0]) { + $0.repeatedSfixed64 == [0, 1] + } assertDecodeFails([193]) assertDecodeFails([193, 2]) assertDecodeFails([193, 2, 0]) @@ -1559,29 +1678,37 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_repeatedFloat() { - assertEncode([205, 2, 0, 0, 0, 63, 205, 2, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.repeatedFloat = [0.5, 0.0]} - assertDecodeSucceeds([205, 2, 0, 0, 0, 63, 205, 2, 0, 0, 0, 63]) {$0.repeatedFloat == [0.5, 0.5]} - assertDecodeSucceeds([202, 2, 8, 0, 0, 0, 63, 0, 0, 0, 63]) {$0.repeatedFloat == [0.5, 0.5]} + assertEncode([205, 2, 0, 0, 0, 63, 205, 2, 0, 0, 0, 0]) { (o: inout MessageTestType) in + o.repeatedFloat = [0.5, 0.0] + } + assertDecodeSucceeds([205, 2, 0, 0, 0, 63, 205, 2, 0, 0, 0, 63]) { $0.repeatedFloat == [0.5, 0.5] } + assertDecodeSucceeds([202, 2, 8, 0, 0, 0, 63, 0, 0, 0, 63]) { $0.repeatedFloat == [0.5, 0.5] } assertDecodeFails([205, 2, 0, 0, 0, 63, 205, 2, 0, 0, 128]) assertDecodeFails([205, 2, 0, 0, 0, 63, 205, 2]) - assertDecodeFails([200, 2]) // Bad byte sequence - assertDecodeFails([200, 2, 0, 0, 0, 0]) // Bad byte sequence - assertDecodeFails([201, 2]) // Bad byte sequence - assertDecodeFails([201, 2, 0, 0, 0, 0]) // Bad byte sequence - assertDecodeFails([203, 2]) // Bad byte sequence - assertDecodeFails([203, 2, 0, 0, 0, 0]) // Bad byte sequence - assertDecodeFails([204, 2]) // Bad byte sequence - assertDecodeFails([204, 2, 0, 0, 0, 0]) // Bad byte sequence - assertDecodeFails([206, 2]) // Bad byte sequence - assertDecodeFails([206, 2, 0, 0, 0, 0]) // Bad byte sequence - assertDecodeFails([207, 2]) // Bad byte sequence - assertDecodeFails([207, 2, 0, 0, 0, 0]) // Bad byte sequence + assertDecodeFails([200, 2]) // Bad byte sequence + assertDecodeFails([200, 2, 0, 0, 0, 0]) // Bad byte sequence + assertDecodeFails([201, 2]) // Bad byte sequence + assertDecodeFails([201, 2, 0, 0, 0, 0]) // Bad byte sequence + assertDecodeFails([203, 2]) // Bad byte sequence + assertDecodeFails([203, 2, 0, 0, 0, 0]) // Bad byte sequence + assertDecodeFails([204, 2]) // Bad byte sequence + assertDecodeFails([204, 2, 0, 0, 0, 0]) // Bad byte sequence + assertDecodeFails([206, 2]) // Bad byte sequence + assertDecodeFails([206, 2, 0, 0, 0, 0]) // Bad byte sequence + assertDecodeFails([207, 2]) // Bad byte sequence + assertDecodeFails([207, 2, 0, 0, 0, 0]) // Bad byte sequence } func testEncoding_repeatedDouble() { - assertEncode([209, 2, 0, 0, 0, 0, 0, 0, 224, 63, 209, 2, 0, 0, 0, 0, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.repeatedDouble = [0.5, 0.0]} - assertDecodeSucceeds([209, 2, 0, 0, 0, 0, 0, 0, 224, 63, 209, 2, 0, 0, 0, 0, 0, 0, 208, 63]) {$0.repeatedDouble == [0.5, 0.25]} - assertDecodeSucceeds([210, 2, 16, 0, 0, 0, 0, 0, 0, 224, 63, 0, 0, 0, 0, 0, 0, 208, 63]) {$0.repeatedDouble == [0.5, 0.25]} + assertEncode([209, 2, 0, 0, 0, 0, 0, 0, 224, 63, 209, 2, 0, 0, 0, 0, 0, 0, 0, 0]) { + (o: inout MessageTestType) in o.repeatedDouble = [0.5, 0.0] + } + assertDecodeSucceeds([209, 2, 0, 0, 0, 0, 0, 0, 224, 63, 209, 2, 0, 0, 0, 0, 0, 0, 208, 63]) { + $0.repeatedDouble == [0.5, 0.25] + } + assertDecodeSucceeds([210, 2, 16, 0, 0, 0, 0, 0, 0, 224, 63, 0, 0, 0, 0, 0, 0, 208, 63]) { + $0.repeatedDouble == [0.5, 0.25] + } assertDecodeFails([209, 2]) assertDecodeFails([209, 2, 0]) assertDecodeFails([209, 2, 0, 0]) @@ -1608,9 +1735,13 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_repeatedBool() { - assertEncode([216, 2, 1, 216, 2, 0, 216, 2, 1]) {(o: inout MessageTestType) in o.repeatedBool = [true, false, true]} - assertDecodeSucceeds([216, 2, 1, 216, 2, 0, 216, 2, 0, 216, 2, 1]) {$0.repeatedBool == [true, false, false, true]} - assertDecodeSucceeds([218, 2, 3, 1, 0, 1, 216, 2, 0]) {$0.repeatedBool == [true, false, true, false]} + assertEncode([216, 2, 1, 216, 2, 0, 216, 2, 1]) { (o: inout MessageTestType) in + o.repeatedBool = [true, false, true] + } + assertDecodeSucceeds([216, 2, 1, 216, 2, 0, 216, 2, 0, 216, 2, 1]) { + $0.repeatedBool == [true, false, false, true] + } + assertDecodeSucceeds([218, 2, 3, 1, 0, 1, 216, 2, 0]) { $0.repeatedBool == [true, false, true, false] } assertDecodeFails([216]) assertDecodeFails([216, 2]) assertDecodeFails([216, 2, 255]) @@ -1630,13 +1761,15 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_repeatedString() { - assertEncode([226, 2, 1, 65, 226, 2, 1, 66]) {(o: inout MessageTestType) in o.repeatedString = ["A", "B"]} - assertDecodeSucceeds([226, 2, 5, 72, 101, 108, 108, 111, 226, 2, 5, 119, 111, 114, 108, 100, 226, 2, 0]) {$0.repeatedString == ["Hello", "world", ""]} + assertEncode([226, 2, 1, 65, 226, 2, 1, 66]) { (o: inout MessageTestType) in o.repeatedString = ["A", "B"] } + assertDecodeSucceeds([226, 2, 5, 72, 101, 108, 108, 111, 226, 2, 5, 119, 111, 114, 108, 100, 226, 2, 0]) { + $0.repeatedString == ["Hello", "world", ""] + } assertDecodeFails([226]) assertDecodeFails([226, 2]) assertDecodeFails([226, 2, 1]) assertDecodeFails([226, 2, 2, 65]) - assertDecodeFails([226, 2, 1, 193]) // Invalid UTF-8 + assertDecodeFails([226, 2, 1, 193]) // Invalid UTF-8 assertDecodeFails([224, 2]) assertDecodesAsUnknownFields([224, 2, 0]) // Wrong wire type (varint), valid as an unknown field assertDecodeFails([225, 2]) @@ -1654,10 +1787,12 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_repeatedBytes() { - assertEncode([234, 2, 1, 1, 234, 2, 0, 234, 2, 1, 2]) {(o: inout MessageTestType) in o.repeatedBytes = [Data([1]), Data(), Data([2])]} + assertEncode([234, 2, 1, 1, 234, 2, 0, 234, 2, 1, 2]) { (o: inout MessageTestType) in + o.repeatedBytes = [Data([1]), Data(), Data([2])] + } assertDecodeSucceeds([234, 2, 4, 0, 1, 2, 255, 234, 2, 0]) { let ref = [Data([0, 1, 2, 255]), Data()] - for (a,b) in zip($0.repeatedBytes, ref) { + for (a, b) in zip($0.repeatedBytes, ref) { if a != b { return false } } return true @@ -1681,16 +1816,16 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_repeatedGroup() { - assertEncode([243, 2, 248, 2, 1, 244, 2, 243, 2, 244, 2]) {(o: inout MessageTestType) in + assertEncode([243, 2, 248, 2, 1, 244, 2, 243, 2, 244, 2]) { (o: inout MessageTestType) in var g1 = MessageTestType.RepeatedGroup() g1.a = 1 let g2 = MessageTestType.RepeatedGroup() // g2 has nothing set. o.repeatedGroup = [g1, g2] } - assertDecodeFails([243, 2, 248, 2, 1]) // End group missing. - assertDecodeFails([243, 2, 248, 2, 1, 244, 3]) // Wrong end group. - assertDecodeFails([240, 2]) // Wire type 0 + assertDecodeFails([243, 2, 248, 2, 1]) // End group missing. + assertDecodeFails([243, 2, 248, 2, 1, 244, 3]) // Wrong end group. + assertDecodeFails([240, 2]) // Wire type 0 assertDecodesAsUnknownFields([240, 2, 0]) // Wrong wire type (varint), valid as an unknown field assertDecodesAsUnknownFields([240, 2, 244, 2]) // Wrong wire type (varint), valid as an unknown field // JSON current disable, pending what to do with groups @@ -1701,14 +1836,18 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { // g2.a = 2 // o.repeatedGroup = [g1, g2] // } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\nRepeatedGroup {\n a: 1\n}\nRepeatedGroup {\n a: 2\n}\n") {(o: inout MessageTestType) in + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\nRepeatedGroup {\n a: 1\n}\nRepeatedGroup {\n a: 2\n}\n" + ) { (o: inout MessageTestType) in var g1 = MessageTestType.RepeatedGroup() g1.a = 1 var g2 = MessageTestType.RepeatedGroup() g2.a = 2 o.repeatedGroup = [g1, g2] } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\nrepeated_int32: 1\nrepeated_int32: 2\nrepeated_int32: 3\nRepeatedGroup {\n a: 1\n}\nRepeatedGroup {\n a: 2\n}\n") {(o: inout MessageTestType) in + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\nrepeated_int32: 1\nrepeated_int32: 2\nrepeated_int32: 3\nRepeatedGroup {\n a: 1\n}\nRepeatedGroup {\n a: 2\n}\n" + ) { (o: inout MessageTestType) in o.repeatedInt32 = [1, 2, 3] var g1 = MessageTestType.RepeatedGroup() g1.a = 1 @@ -1719,7 +1858,7 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_repeatedNestedMessage() { - assertEncode([130, 3, 2, 8, 1, 130, 3, 2, 8, 2]) {(o: inout MessageTestType) in + assertEncode([130, 3, 2, 8, 1, 130, 3, 2, 8, 2]) { (o: inout MessageTestType) in var m1 = MessageTestType.NestedMessage() m1.bb = 1 var m2 = MessageTestType.NestedMessage() @@ -1728,7 +1867,21 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } assertDecodeFails([128, 3]) assertDecodesAsUnknownFields([128, 3, 0]) // Wrong wire type (varint), valid as an unknown field - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\nrepeated_nested_message {\n bb: 1\n}\nrepeated_nested_message {\n bb: 2\n}\n") {(o: inout MessageTestType) in + + // Ensure message field over 2GB fail to decode according to spec. + XCTAssertThrowsError( + try MessageTestType(serializedBytes: [ + 130, 3, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, + // Don't need all the bytes, want some to let the length issue trigger. + 0x01, 0x02, 0x03, + ]) + ) { + XCTAssertEqual($0 as! BinaryDecodingError, .malformedProtobuf) + } + + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\nrepeated_nested_message {\n bb: 1\n}\nrepeated_nested_message {\n bb: 2\n}\n" + ) { (o: inout MessageTestType) in var m1 = MessageTestType.NestedMessage() m1.bb = 1 var m2 = MessageTestType.NestedMessage() @@ -1739,25 +1892,25 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { func testEncoding_repeatedNestedMessage_unknown() { let bytes: [UInt8] = [ - 208, 41, 0, // Unknown 666 with varint 0 + 208, 41, 0, // Unknown 666 with varint 0 130, 3, 8, // Inner message with 8 bytes - 208, 41, 8, // Unknown 666 with varint 8 - 8, 1, // bb = 1 - 208, 41, 9, // Unknown 666 with varint 9 - 208, 41, 1, // Unknown 666 with varint 1 - 130, 3, 8, // inner message with 8 bytes - 208, 41, 10, // Unknown 666 with varint 10 - 8, 2, // bb = 2 - 208, 41, 11, // Unknown 666 with varint 11 - 208, 41, 2 // Unknown 666 with varint 2 + 208, 41, 8, // Unknown 666 with varint 8 + 8, 1, // bb = 1 + 208, 41, 9, // Unknown 666 with varint 9 + 208, 41, 1, // Unknown 666 with varint 1 + 130, 3, 8, // inner message with 8 bytes + 208, 41, 10, // Unknown 666 with varint 10 + 8, 2, // bb = 2 + 208, 41, 11, // Unknown 666 with varint 11 + 208, 41, 2, // Unknown 666 with varint 2 ] do { - let m = try MessageTestType(serializedData: Data(bytes)) + let m = try MessageTestType(serializedBytes: bytes) XCTAssertEqual(m.repeatedNestedMessage.count, 2) - XCTAssertNotEqual(m.repeatedNestedMessage[0], MessageTestType.NestedMessage.with{$0.bb = 1}) + XCTAssertNotEqual(m.repeatedNestedMessage[0], MessageTestType.NestedMessage.with { $0.bb = 1 }) XCTAssertEqual(m.repeatedNestedMessage[0].bb, 1) - XCTAssertNotEqual(m.repeatedNestedMessage[1], MessageTestType.NestedMessage.with{$0.bb = 2}) + XCTAssertNotEqual(m.repeatedNestedMessage[1], MessageTestType.NestedMessage.with { $0.bb = 2 }) XCTAssertEqual(m.repeatedNestedMessage[1].bb, 2) do { // Same contents, but reordered @@ -1766,10 +1919,10 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { 130, 3, 8, 8, 2, 208, 41, 10, 208, 41, 11, 208, 41, 0, 208, 41, 1, - 208, 41, 2 + 208, 41, 2, ] - let recoded = try m.serializedData() - XCTAssertEqual(recoded, Data(expectedBytes)) + let recoded: [UInt8] = try m.serializedBytes() + XCTAssertEqual(recoded, expectedBytes) } catch let e { XCTFail("Failed to recode: \(e)") } @@ -1779,10 +1932,12 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_repeatedNestedEnum() throws { - assertEncode([152, 3, 2, 152, 3, 3]) {(o: inout MessageTestType) in + assertEncode([152, 3, 2, 152, 3, 3]) { (o: inout MessageTestType) in o.repeatedNestedEnum = [.bar, .baz] } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\nrepeated_nested_enum: BAR\nrepeated_nested_enum: BAZ\n") {(o: inout MessageTestType) in + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\nrepeated_nested_enum: BAR\nrepeated_nested_enum: BAZ\n" + ) { (o: inout MessageTestType) in o.repeatedNestedEnum = [.bar, .baz] } assertDecodeSucceeds([152, 3, 2, 152, 3, 128, 1]) { @@ -1791,9 +1946,9 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { // The out-of-range enum value should be preserved as an unknown field do { - let decoded1 = try ProtobufUnittest_TestAllTypes(serializedData: Data([152, 3, 1, 152, 3, 128, 1])) + let decoded1 = try SwiftProtoTesting_TestAllTypes(serializedBytes: [152, 3, 1, 152, 3, 128, 1]) XCTAssertEqual(decoded1.repeatedNestedEnum, [.foo]) - let recoded1 = try decoded1.serializedBytes() + let recoded1: [UInt8] = try decoded1.serializedBytes() XCTAssertEqual(recoded1, [152, 3, 1, 152, 3, 128, 1]) } catch let e { XCTFail("Decode failed: \(e)") @@ -1801,9 +1956,9 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { // Unknown fields always get reserialized last, which trashes order here: do { - let decoded2 = try ProtobufUnittest_TestAllTypes(serializedData: Data([152, 3, 128, 1, 152, 3, 2])) + let decoded2 = try SwiftProtoTesting_TestAllTypes(serializedBytes: [152, 3, 128, 1, 152, 3, 2]) XCTAssertEqual(decoded2.repeatedNestedEnum, [.bar]) - let recoded2 = try decoded2.serializedBytes() + let recoded2: [UInt8] = try decoded2.serializedBytes() XCTAssertEqual(recoded2, [152, 3, 2, 152, 3, 128, 1]) } catch let e { XCTFail("Decode failed: \(e)") @@ -1811,9 +1966,9 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { // Unknown enums within packed behave as if it were plain repeated do { - let decoded3 = try ProtobufUnittest_TestAllTypes(serializedData: Data([154, 3, 3, 128, 1, 2])) + let decoded3 = try SwiftProtoTesting_TestAllTypes(serializedBytes: [154, 3, 3, 128, 1, 2]) XCTAssertEqual(decoded3.repeatedNestedEnum, [.bar]) - let recoded3 = try decoded3.serializedBytes() + let recoded3: [UInt8] = try decoded3.serializedBytes() XCTAssertEqual(recoded3, [152, 3, 2, 154, 3, 2, 128, 1]) } catch let e { XCTFail("Decode failed: \(e)") @@ -1827,7 +1982,8 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { let empty = MessageTestType() XCTAssertEqual(empty.defaultInt32, 41) // Setting explicitly does serialize (even if default) - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\ndefault_int32: 41\n") {(o: inout MessageTestType) in + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\ndefault_int32: 41\n") { + (o: inout MessageTestType) in o.defaultInt32 = 41 } @@ -1849,15 +2005,16 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { t.defaultInt32 = 4 t.clearDefaultInt32() XCTAssertEqual(t.defaultInt32, 41) - XCTAssertEqual(t.debugDescription, "SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\n") + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\n", t) // The default is still not serialized - let s = try t.serializedBytes() + let s: [UInt8] = try t.serializedBytes() XCTAssertEqual([], s) - assertDecodeSucceeds([]) {$0.defaultInt32 == 41} - assertDecodeSucceeds([232, 3, 4]) {$0.defaultInt32 == 4} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\ndefault_int32: 4\n") {(o: inout MessageTestType) in + assertDecodeSucceeds([]) { $0.defaultInt32 == 41 } + assertDecodeSucceeds([232, 3, 4]) { $0.defaultInt32 == 4 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\ndefault_int32: 4\n") { + (o: inout MessageTestType) in o.defaultInt32 = 4 } } @@ -1886,15 +2043,15 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { b.optionalInt32 = 1 XCTAssertNotEqual(a, b) - assertDecodeSucceeds([]) {$0.defaultInt64 == 42} - assertDecodeSucceeds([240, 3, 42]) {$0.defaultInt64 == 42} - assertDecodeSucceeds([240, 3, 8]) {$0.defaultInt64 == 8} + assertDecodeSucceeds([]) { $0.defaultInt64 == 42 } + assertDecodeSucceeds([240, 3, 42]) { $0.defaultInt64 == 42 } + assertDecodeSucceeds([240, 3, 8]) { $0.defaultInt64 == 8 } } func testEncoding_defaultUint32() throws { let empty = MessageTestType() XCTAssertEqual(empty.defaultUint32, 43) - XCTAssertEqual(try empty.serializedData(), Data()) + XCTAssertEqual(try empty.serializedBytes(), [UInt8]()) // Writing a value equal to the default compares as not equal to an unset field var a = MessageTestType() @@ -1909,9 +2066,9 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { b.optionalInt32 = 1 XCTAssertNotEqual(a, b) - assertDecodeSucceeds([]) {$0.defaultUint32 == 43} - assertDecodeSucceeds([248, 3, 43]) {$0.defaultUint32 == 43} - assertDecodeSucceeds([248, 3, 9]) {$0.defaultUint32 == 9} + assertDecodeSucceeds([]) { $0.defaultUint32 == 43 } + assertDecodeSucceeds([248, 3, 43]) { $0.defaultUint32 == 43 } + assertDecodeSucceeds([248, 3, 9]) { $0.defaultUint32 == 9 } } func testEncoding_defaultUint64() throws { @@ -1932,9 +2089,9 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { b.optionalInt32 = 1 XCTAssertNotEqual(a, b) - assertDecodeSucceeds([]) {$0.defaultUint64 == 44} - assertDecodeSucceeds([128, 4, 44]) {$0.defaultUint64 == 44} - assertDecodeSucceeds([128, 4, 9]) {$0.defaultUint64 == 9} + assertDecodeSucceeds([]) { $0.defaultUint64 == 44 } + assertDecodeSucceeds([128, 4, 44]) { $0.defaultUint64 == 44 } + assertDecodeSucceeds([128, 4, 9]) { $0.defaultUint64 == 9 } } func testEncoding_defaultSint32() throws { @@ -1955,9 +2112,9 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { b.optionalInt32 = 1 XCTAssertNotEqual(a, b) - assertDecodeSucceeds([]) {$0.defaultSint32 == -45} - assertDecodeSucceeds([136, 4, 89]) {$0.defaultSint32 == -45} - assertDecodeSucceeds([136, 4, 0]) {$0.defaultSint32 == 0} + assertDecodeSucceeds([]) { $0.defaultSint32 == -45 } + assertDecodeSucceeds([136, 4, 89]) { $0.defaultSint32 == -45 } + assertDecodeSucceeds([136, 4, 0]) { $0.defaultSint32 == 0 } assertDecodeFails([136, 4]) } @@ -1979,9 +2136,9 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { b.optionalInt32 = 1 XCTAssertNotEqual(a, b) - assertDecodeSucceeds([]) {$0.defaultSint64 == 46} - assertDecodeSucceeds([144, 4, 92]) {$0.defaultSint64 == 46} - assertDecodeSucceeds([144, 4, 0]) {$0.defaultSint64 == 0} + assertDecodeSucceeds([]) { $0.defaultSint64 == 46 } + assertDecodeSucceeds([144, 4, 92]) { $0.defaultSint64 == 46 } + assertDecodeSucceeds([144, 4, 0]) { $0.defaultSint64 == 0 } } func testEncoding_defaultFixed32() throws { @@ -2002,9 +2159,9 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { b.optionalInt32 = 1 XCTAssertNotEqual(a, b) - assertDecodeSucceeds([]) {$0.defaultFixed32 == 47} - assertDecodeSucceeds([157, 4, 47, 0, 0, 0]) {$0.defaultFixed32 == 47} - assertDecodeSucceeds([157, 4, 0, 0, 0, 0]) {$0.defaultFixed32 == 0} + assertDecodeSucceeds([]) { $0.defaultFixed32 == 47 } + assertDecodeSucceeds([157, 4, 47, 0, 0, 0]) { $0.defaultFixed32 == 47 } + assertDecodeSucceeds([157, 4, 0, 0, 0, 0]) { $0.defaultFixed32 == 0 } } func testEncoding_defaultFixed64() throws { @@ -2025,9 +2182,9 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { b.optionalInt32 = 1 XCTAssertNotEqual(a, b) - assertDecodeSucceeds([]) {$0.defaultFixed64 == 48} - assertDecodeSucceeds([161, 4, 48, 0, 0, 0, 0, 0, 0, 0]) {$0.defaultFixed64 == 48} - assertDecodeSucceeds([161, 4, 0, 0, 0, 0, 0, 0, 0, 0]) {$0.defaultFixed64 == 0} + assertDecodeSucceeds([]) { $0.defaultFixed64 == 48 } + assertDecodeSucceeds([161, 4, 48, 0, 0, 0, 0, 0, 0, 0]) { $0.defaultFixed64 == 48 } + assertDecodeSucceeds([161, 4, 0, 0, 0, 0, 0, 0, 0, 0]) { $0.defaultFixed64 == 0 } } func testEncoding_defaultSfixed32() throws { @@ -2040,7 +2197,7 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { a.defaultSfixed32 = 49 XCTAssertNotEqual(a, empty) - XCTAssertEqual(Data([173, 4, 49, 0, 0, 0]), try a.serializedData()) + XCTAssertEqual([173, 4, 49, 0, 0, 0], try a.serializedBytes()) XCTAssertEqual("{\"defaultSfixed32\":49}", try a.jsonString()) var b = MessageTestType() @@ -2048,9 +2205,9 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { b.optionalInt32 = 1 XCTAssertNotEqual(a, b) - assertDecodeSucceeds([]) {$0.defaultSfixed32 == 49} - assertDecodeSucceeds([173, 4, 49, 0, 0, 0]) {$0.defaultSfixed32 == 49} - assertDecodeSucceeds([173, 4, 0, 0, 0, 0]) {$0.defaultSfixed32 == 0} + assertDecodeSucceeds([]) { $0.defaultSfixed32 == 49 } + assertDecodeSucceeds([173, 4, 49, 0, 0, 0]) { $0.defaultSfixed32 == 49 } + assertDecodeSucceeds([173, 4, 0, 0, 0, 0]) { $0.defaultSfixed32 == 0 } } func testEncoding_defaultSfixed64() throws { @@ -2071,9 +2228,9 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { b.optionalInt32 = 1 XCTAssertNotEqual(a, b) - assertDecodeSucceeds([]) {$0.defaultSfixed64 == -50} - assertDecodeSucceeds([177, 4, 206, 255, 255, 255, 255, 255, 255, 255]) {$0.defaultSfixed64 == -50} - assertDecodeSucceeds([177, 4, 0, 0, 0, 0, 0, 0, 0, 0]) {$0.defaultSfixed64 == 0} + assertDecodeSucceeds([]) { $0.defaultSfixed64 == -50 } + assertDecodeSucceeds([177, 4, 206, 255, 255, 255, 255, 255, 255, 255]) { $0.defaultSfixed64 == -50 } + assertDecodeSucceeds([177, 4, 0, 0, 0, 0, 0, 0, 0, 0]) { $0.defaultSfixed64 == 0 } } func testEncoding_defaultFloat() throws { @@ -2094,9 +2251,9 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { b.optionalInt32 = 1 XCTAssertNotEqual(a, b) - assertDecodeSucceeds([]) {$0.defaultFloat == 51.5} - assertDecodeSucceeds([189, 4, 0, 0, 0, 0]) {$0.defaultFloat == 0} - assertDecodeSucceeds([189, 4, 0, 0, 78, 66]) {$0.defaultFloat == 51.5} + assertDecodeSucceeds([]) { $0.defaultFloat == 51.5 } + assertDecodeSucceeds([189, 4, 0, 0, 0, 0]) { $0.defaultFloat == 0 } + assertDecodeSucceeds([189, 4, 0, 0, 78, 66]) { $0.defaultFloat == 51.5 } } func testEncoding_defaultDouble() throws { @@ -2116,9 +2273,9 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { a.optionalInt32 = 1 XCTAssertNotEqual(a, b) - assertDecodeSucceeds([]) {$0.defaultDouble == 52e3} - assertDecodeSucceeds([193, 4, 0, 0, 0, 0, 0, 0, 0, 0]) {$0.defaultDouble == 0} - assertDecodeSucceeds([193, 4, 0, 0, 0, 0, 0, 100, 233, 64]) {$0.defaultDouble == 52e3} + assertDecodeSucceeds([]) { $0.defaultDouble == 52e3 } + assertDecodeSucceeds([193, 4, 0, 0, 0, 0, 0, 0, 0, 0]) { $0.defaultDouble == 0 } + assertDecodeSucceeds([193, 4, 0, 0, 0, 0, 0, 100, 233, 64]) { $0.defaultDouble == 52e3 } } func testEncoding_defaultBool() throws { @@ -2138,12 +2295,12 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { b.optionalInt32 = 1 XCTAssertNotEqual(a, b) - assertEncode([200, 4, 0]) {(o: inout MessageTestType) in o.defaultBool = false} - assertJSONEncode("{\"defaultBool\":false}") {(o: inout MessageTestType) in o.defaultBool = false} + assertEncode([200, 4, 0]) { (o: inout MessageTestType) in o.defaultBool = false } + assertJSONEncode("{\"defaultBool\":false}") { (o: inout MessageTestType) in o.defaultBool = false } - assertDecodeSucceeds([]) {$0.defaultBool == true} - assertDecodeSucceeds([200, 4, 0]) {$0.defaultBool == false} - assertDecodeSucceeds([200, 4, 1]) {$0.defaultBool == true} + assertDecodeSucceeds([]) { $0.defaultBool == true } + assertDecodeSucceeds([200, 4, 0]) { $0.defaultBool == false } + assertDecodeSucceeds([200, 4, 1]) { $0.defaultBool == true } } @@ -2164,8 +2321,8 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { b.optionalInt32 = 1 XCTAssertNotEqual(a, b) - assertDecodeSucceeds([]) {$0.defaultString == "hello"} - assertDecodeSucceeds([210, 4, 1, 97]) {$0.defaultString == "a"} + assertDecodeSucceeds([]) { $0.defaultString == "hello" } + assertDecodeSucceeds([210, 4, 1, 97]) { $0.defaultString == "a" } } func testEncoding_defaultBytes() throws { @@ -2185,8 +2342,8 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { a.optionalInt32 = 1 XCTAssertNotEqual(a, b) - assertDecodeSucceeds([]) {$0.defaultBytes == Data([119, 111, 114, 108, 100])} - assertDecodeSucceeds([218, 4, 1, 1]) {$0.defaultBytes == Data([1])} + assertDecodeSucceeds([]) { $0.defaultBytes == Data([119, 111, 114, 108, 100]) } + assertDecodeSucceeds([218, 4, 1, 1]) { $0.defaultBytes == Data([1]) } } func testEncoding_defaultNestedEnum() throws { @@ -2206,13 +2363,13 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { a.optionalInt32 = 1 XCTAssertNotEqual(a, b) - assertDecodeSucceeds([]) {$0.defaultNestedEnum == .bar} - assertDecodeSucceeds([136, 5, 3]) {$0.defaultNestedEnum == .baz} + assertDecodeSucceeds([]) { $0.defaultNestedEnum == .bar } + assertDecodeSucceeds([136, 5, 3]) { $0.defaultNestedEnum == .baz } } func testEncoding_defaultForeignEnum() throws { let empty = MessageTestType() - XCTAssertEqual(empty.defaultForeignEnum, ProtobufUnittest_ForeignEnum.foreignBar) + XCTAssertEqual(empty.defaultForeignEnum, SwiftProtoTesting_ForeignEnum.foreignBar) // Writing a value equal to the default compares as not equal to an unset field var a = MessageTestType() @@ -2227,49 +2384,29 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { a.optionalInt32 = 1 XCTAssertNotEqual(a, b) - assertDecodeSucceeds([]) {$0.defaultForeignEnum == .foreignBar} - assertDecodeSucceeds([144, 5, 6]) {$0.defaultForeignEnum == ProtobufUnittest_ForeignEnum.foreignBaz} + assertDecodeSucceeds([]) { $0.defaultForeignEnum == .foreignBar } + assertDecodeSucceeds([144, 5, 6]) { $0.defaultForeignEnum == SwiftProtoTesting_ForeignEnum.foreignBaz } } func testEncoding_defaultImportEnum() throws { let empty = MessageTestType() - XCTAssertEqual(empty.defaultImportEnum, ProtobufUnittestImport_ImportEnum.importBar) - assertEncode([152, 5, 9]) {(o: inout MessageTestType) in o.defaultImportEnum = .importBaz} - assertDecodeSucceeds([]) {$0.defaultImportEnum == .importBar} - assertDecodeSucceeds([152, 5, 9]) {$0.defaultImportEnum == .importBaz} - } - - func testEncoding_defaultStringPiece() throws { - let empty = MessageTestType() - XCTAssertEqual(empty.defaultStringPiece, "abc") - XCTAssertEqual(try empty.serializedBytes(), []) - - var a = empty - a.defaultStringPiece = "abc" - XCTAssertEqual([162, 5, 3, 97, 98, 99], try a.serializedBytes()) - } - - func testEncoding_defaultCord() { - let empty = MessageTestType() - XCTAssertEqual(empty.defaultCord, "123") - XCTAssertEqual(try empty.serializedBytes(), []) - - var a = empty - a.defaultCord = "123" - XCTAssertEqual([170, 5, 3, 49, 50, 51], try a.serializedBytes()) + XCTAssertEqual(empty.defaultImportEnum, SwiftProtoTesting_Import_ImportEnum.importBar) + assertEncode([152, 5, 9]) { (o: inout MessageTestType) in o.defaultImportEnum = .importBaz } + assertDecodeSucceeds([]) { $0.defaultImportEnum == .importBar } + assertDecodeSucceeds([152, 5, 9]) { $0.defaultImportEnum == .importBaz } } func testEncoding_oneofUint32() throws { - assertEncode([248, 6, 0]) {(o: inout MessageTestType) in o.oneofUint32 = 0} - assertDecodeSucceeds([248, 6, 255, 255, 255, 255, 15]) {$0.oneofUint32 == UInt32.max} - assertDecodeSucceeds([138, 7, 1, 97, 248, 6, 1]) {(o: MessageTestType) in + assertEncode([248, 6, 0]) { (o: inout MessageTestType) in o.oneofUint32 = 0 } + assertDecodeSucceeds([248, 6, 255, 255, 255, 255, 15]) { $0.oneofUint32 == UInt32.max } + assertDecodeSucceeds([138, 7, 1, 97, 248, 6, 1]) { (o: MessageTestType) in if case .oneofUint32? = o.oneofField, o.oneofUint32 == UInt32(1) { return true } return false } - assertDecodeFails([248, 6, 128]) // Bad varint + assertDecodeFails([248, 6, 128]) // Bad varint // Bad wire types: assertDecodeFails([249, 6]) assertDecodeFails([249, 6, 0]) @@ -2279,7 +2416,7 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } let initialMsg = MessageTestType.with { $0.oneofString = "initial" } assertMergesAsUnknownFields([250, 6, 0], inTo: initialMsg) { - $0.oneofString == "initial" // Shouldn't have gotten cleared. + $0.oneofString == "initial" // Shouldn't have gotten cleared. } assertDecodeFails([251, 6]) assertDecodeFails([251, 6, 0]) @@ -2294,25 +2431,25 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { var m = MessageTestType() m.oneofUint32 = 77 - XCTAssertEqual(m.debugDescription, "SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noneof_uint32: 77\n") + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noneof_uint32: 77\n", m) var m2 = MessageTestType() m2.oneofUint32 = 78 XCTAssertNotEqual(m.hashValue, m2.hashValue) } func testEncoding_oneofNestedMessage() { - assertEncode([130, 7, 2, 8, 1]) {(o: inout MessageTestType) in + assertEncode([130, 7, 2, 8, 1]) { (o: inout MessageTestType) in var nested = MessageTestType.NestedMessage() nested.bb = 1 o.oneofNestedMessage = nested } - assertDecodeSucceeds([130, 7, 0]) {(o: MessageTestType) in + assertDecodeSucceeds([130, 7, 0]) { (o: MessageTestType) in if case .oneofNestedMessage(let m)? = o.oneofField { return !m.hasBb } return false } - assertDecodeSucceeds([248, 6, 0, 130, 7, 2, 8, 1]) {(o: MessageTestType) in + assertDecodeSucceeds([248, 6, 0, 130, 7, 2, 8, 1]) { (o: MessageTestType) in if case .oneofUint32? = o.oneofField { return false } @@ -2323,14 +2460,14 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } } func testEncoding_oneofNestedMessage1() { - assertDecodeSucceeds([130, 7, 2, 8, 1, 248, 6, 0]) {(o: MessageTestType) in + assertDecodeSucceeds([130, 7, 2, 8, 1, 248, 6, 0]) { (o: MessageTestType) in if case .oneofUint32? = o.oneofField, o.oneofUint32 == 0 { return true } return false } // Unkonwn field within nested message should not break decoding - assertDecodeSucceeds([130, 7, 5, 128, 127, 0, 8, 1, 248, 6, 0]) {(o: MessageTestType) in + assertDecodeSucceeds([130, 7, 5, 128, 127, 0, 8, 1, 248, 6, 0]) { (o: MessageTestType) in if case .oneofUint32? = o.oneofField, o.oneofUint32 == 0 { return true } @@ -2343,7 +2480,10 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { nested1.bb = 1 var m = MessageTestType() m.oneofNestedMessage = nested1 - XCTAssertEqual(m.debugDescription, "SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noneof_nested_message {\n bb: 1\n}\n") + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noneof_nested_message {\n bb: 1\n}\n", + m + ) var nested2 = MessageTestType.NestedMessage() nested2.bb = 2 var m2 = MessageTestType() @@ -2358,7 +2498,7 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } let initialMsg = MessageTestType.with { $0.oneofString = "initial" } assertMergesAsUnknownFields([128, 7, 0], inTo: initialMsg) { - $0.oneofString == "initial" // Shouldn't have gotten cleared. + $0.oneofString == "initial" // Shouldn't have gotten cleared. } assertDecodeFails([129, 7]) assertDecodeFails([129, 7, 0]) @@ -2375,64 +2515,67 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testEncoding_oneofString() { - assertEncode([138, 7, 1, 97]) {(o: inout MessageTestType) in o.oneofString = "a"} - assertDecodeSucceeds([138, 7, 1, 97]) {$0.oneofString == "a"} - assertDecodeSucceeds([138, 7, 0]) {$0.oneofString == ""} - assertDecodeSucceeds([146, 7, 0, 138, 7, 1, 97]) {(o:MessageTestType) in + assertEncode([138, 7, 1, 97]) { (o: inout MessageTestType) in o.oneofString = "a" } + assertDecodeSucceeds([138, 7, 1, 97]) { $0.oneofString == "a" } + assertDecodeSucceeds([138, 7, 0]) { $0.oneofString == "" } + assertDecodeSucceeds([146, 7, 0, 138, 7, 1, 97]) { (o: MessageTestType) in if case .oneofString? = o.oneofField, o.oneofString == "a" { return true } return false } - assertDecodeFails([138, 7, 1]) // Truncated body - assertDecodeFails([138, 7, 1, 192]) // Malformed UTF-8 + assertDecodeFails([138, 7, 1]) // Truncated body + assertDecodeFails([138, 7, 1, 192]) // Malformed UTF-8 // Bad wire types: assertDecodesAsUnknownFields([136, 7, 0]) { // Wrong wire type (varint), valid as an unknown field $0.oneofField == nil // oneof doesn't get set. } let initialMsg = MessageTestType.with { $0.oneofUint32 = 123 } assertMergesAsUnknownFields([136, 7, 0], inTo: initialMsg) { - $0.oneofUint32 == 123 // Shouldn't have gotten cleared. + $0.oneofUint32 == 123 // Shouldn't have gotten cleared. } assertDecodesAsUnknownFields([136, 7, 1]) { // Wrong wire type (varint), valid as an unknown field $0.oneofField == nil // oneof doesn't get set. } assertMergesAsUnknownFields([136, 7, 1], inTo: initialMsg) { - $0.oneofUint32 == 123 // Shouldn't have gotten cleared. + $0.oneofUint32 == 123 // Shouldn't have gotten cleared. } - assertDecodesAsUnknownFields([137, 7, 1, 1, 1, 1, 1, 1, 1, 1]) { // Wrong wire type (fixed64), valid as an unknown field + assertDecodesAsUnknownFields([ + 137, 7, // Wrong wire type (fixed64), valid as an unknown field + 1, 1, 1, 1, 1, 1, 1, 1, + ]) { $0.oneofField == nil // oneof doesn't get set. } assertMergesAsUnknownFields([137, 7, 1, 1, 1, 1, 1, 1, 1, 1], inTo: initialMsg) { - $0.oneofUint32 == 123 // Shouldn't have gotten cleared. + $0.oneofUint32 == 123 // Shouldn't have gotten cleared. } - assertDecodeFails([139, 7]) // Wire type 3 - assertDecodeFails([140, 7]) // Wire type 4 + assertDecodeFails([139, 7]) // Wire type 3 + assertDecodeFails([140, 7]) // Wire type 4 assertDecodeFails([141, 7, 0]) // Wire type 5 assertDecodesAsUnknownFields([141, 7, 0, 0, 0, 0]) { // Wrong wire type (fixed32), valid as an unknown field $0.oneofField == nil // oneof doesn't get set. } assertMergesAsUnknownFields([141, 7, 0, 0, 0, 0], inTo: initialMsg) { - $0.oneofUint32 == 123 // Shouldn't have gotten cleared. + $0.oneofUint32 == 123 // Shouldn't have gotten cleared. } - assertDecodeFails([142, 7]) // Wire type 6 - assertDecodeFails([142, 7, 0]) // Wire type 6 - assertDecodeFails([143, 7]) // Wire type 7 - assertDecodeFails([143, 7, 0]) // Wire type 7 + assertDecodeFails([142, 7]) // Wire type 6 + assertDecodeFails([142, 7, 0]) // Wire type 6 + assertDecodeFails([143, 7]) // Wire type 7 + assertDecodeFails([143, 7, 0]) // Wire type 7 var m = MessageTestType() m.oneofString = "abc" - XCTAssertEqual(m.debugDescription, "SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noneof_string: \"abc\"\n") + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noneof_string: \"abc\"\n", m) var m2 = MessageTestType() m2.oneofString = "def" XCTAssertNotEqual(m.hashValue, m2.hashValue) } func testEncoding_oneofBytes() { - assertEncode([146, 7, 1, 1]) {(o: inout MessageTestType) in o.oneofBytes = Data([1])} + assertEncode([146, 7, 1, 1]) { (o: inout MessageTestType) in o.oneofBytes = Data([1]) } } func testEncoding_oneofBytes2() { - assertDecodeSucceeds([146, 7, 1, 1]) {(o: MessageTestType) in + assertDecodeSucceeds([146, 7, 1, 1]) { (o: MessageTestType) in let expectedB = Data([1]) if case .oneofBytes(let b)? = o.oneofField { let s = o.oneofString @@ -2442,7 +2585,7 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } } func testEncoding_oneofBytes3() { - assertDecodeSucceeds([146, 7, 0]) {(o: MessageTestType) in + assertDecodeSucceeds([146, 7, 0]) { (o: MessageTestType) in let expectedB = Data() if case .oneofBytes(let b)? = o.oneofField { let s = o.oneofString @@ -2452,7 +2595,7 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } } func testEncoding_oneofBytes4() { - assertDecodeSucceeds([138, 7, 1, 97, 146, 7, 0]) {(o: MessageTestType) in + assertDecodeSucceeds([138, 7, 1, 97, 146, 7, 0]) { (o: MessageTestType) in let expectedB = Data() if case .oneofBytes(let b)? = o.oneofField { let s = o.oneofString @@ -2476,7 +2619,7 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } let initialMsg = MessageTestType.with { $0.oneofString = "initial" } assertMergesAsUnknownFields([144, 7, 0], inTo: initialMsg) { - $0.oneofString == "initial" // Shouldn't have gotten cleared. + $0.oneofString == "initial" // Shouldn't have gotten cleared. } assertDecodeFails([145, 7]) assertDecodeFails([145, 7, 0]) @@ -2496,7 +2639,10 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { var m = MessageTestType() m.oneofBytes = Data([1, 2, 3]) - XCTAssertEqual(m.debugDescription, "SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noneof_bytes: \"\\001\\002\\003\"\n") + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noneof_bytes: \"\\001\\002\\003\"\n", + m + ) var m2 = MessageTestType() m2.oneofBytes = Data([4, 5, 6]) XCTAssertNotEqual(m.hashValue, m2.hashValue) @@ -2504,39 +2650,46 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { func testDebugDescription() { var m = MessageTestType() - let d = m.debugDescription - XCTAssertEqual("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\n", d) + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\n", m) m.optionalInt32 = 7 - XCTAssertEqual("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_int32: 7\n", m.debugDescription) + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_int32: 7\n", m) m.repeatedString = ["a", "b"] - XCTAssertEqual("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_int32: 7\nrepeated_string: \"a\"\nrepeated_string: \"b\"\n", m.debugDescription) + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_int32: 7\nrepeated_string: \"a\"\nrepeated_string: \"b\"\n", + m + ) } func testDebugDescription2() { // Message with only one field - var m = ProtobufUnittest_ForeignMessage() - XCTAssertEqual("SwiftProtobufTests.ProtobufUnittest_ForeignMessage:\n", m.debugDescription) + var m = SwiftProtoTesting_ForeignMessage() + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_ForeignMessage:\n", m) m.c = 3 - XCTAssertEqual("SwiftProtobufTests.ProtobufUnittest_ForeignMessage:\nc: 3\n", m.debugDescription) + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_ForeignMessage:\nc: 3\n", m) } func testDebugDescription3() { // Message with only a single oneof - var m = ProtobufUnittest_TestOneof() - XCTAssertEqual("SwiftProtobufTests.ProtobufUnittest_TestOneof:\n", m.debugDescription) + var m = SwiftProtoTesting_TestOneof() + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestOneof:\n", m) m.fooInt = 1 - XCTAssertEqual("SwiftProtobufTests.ProtobufUnittest_TestOneof:\nfoo_int: 1\n", m.debugDescription) + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestOneof:\nfoo_int: 1\n", m) m.fooString = "a" - XCTAssertEqual("SwiftProtobufTests.ProtobufUnittest_TestOneof:\nfoo_string: \"a\"\n", m.debugDescription) - var g = ProtobufUnittest_TestOneof.FooGroup() + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestOneof:\nfoo_string: \"a\"\n", m) + var g = SwiftProtoTesting_TestOneof.FooGroup() g.a = 7 g.b = "b" m.fooGroup = g - XCTAssertEqual("SwiftProtobufTests.ProtobufUnittest_TestOneof:\nFooGroup {\n a: 7\n b: \"b\"\n}\n", m.debugDescription) + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestOneof:\nFooGroup {\n a: 7\n b: \"b\"\n}\n", + m + ) } func testDebugDescription4() { - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestAllTypes:\noptional_int32: 88\nrepeated_int32: 1\nrepeated_int32: 2\nrepeated_int32: 3\nRepeatedGroup {\n a: 1\n}\nRepeatedGroup {\n a: 2\n}\n") {(o: inout MessageTestType) in + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllTypes:\noptional_int32: 88\nrepeated_int32: 1\nrepeated_int32: 2\nrepeated_int32: 3\nRepeatedGroup {\n a: 1\n}\nRepeatedGroup {\n a: 2\n}\n" + ) { (o: inout MessageTestType) in o.optionalInt32 = 88 o.repeatedInt32 = [1, 2, 3] var g1 = MessageTestType.RepeatedGroup() @@ -2548,48 +2701,49 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } func testWithFactoryHelper() { - let m = ProtobufUnittest_ForeignMessage.with { $0.c = 5 } + let m = SwiftProtoTesting_ForeignMessage.with { $0.c = 5 } XCTAssertEqual(5, m.c) } func testWithFactoryHelperRethrows() { - class TestWithFactoryHelperRethrows_Error : Error {} + struct TestWithFactoryHelperRethrows_Error: Error {} - let pNoThrow: (inout ProtobufUnittest_ForeignMessage) -> () = { $0.c = 1 } - let m1 = ProtobufUnittest_ForeignMessage.with(pNoThrow) + let pNoThrow: (inout SwiftProtoTesting_ForeignMessage) -> Void = { $0.c = 1 } + let m1 = SwiftProtoTesting_ForeignMessage.with(pNoThrow) XCTAssertEqual(1, m1.c) var populatorRan = false - let pThrow: (inout ProtobufUnittest_ForeignMessage) throws -> () = { + let pThrow: (inout SwiftProtoTesting_ForeignMessage) throws -> Void = { $0.c = 2 populatorRan = true throw TestWithFactoryHelperRethrows_Error() } - let m2 = try? ProtobufUnittest_ForeignMessage.with(pThrow) + let m2 = try? SwiftProtoTesting_ForeignMessage.with(pThrow) XCTAssertNil(m2) XCTAssert(populatorRan) } func testUnknownFields_Success() throws { let testInputs: [([UInt8], String)] = [ - ([192, 12, 1], "200: 1"), // varint of 1. - ([193, 12, 20, 0, 0, 0, 0, 0, 0, 0], "200: 0x0000000000000014"), // fixed64 of 20 - ([194, 12, 3, 65, 66, 67], "200: \"ABC\""), // length delimited. - ([195, 12, 8, 1, 196, 12], "200 {\n 1: 1\n}"), // StartGroup, Field 1: varint of 1, EndGroup. - ([197, 12, 30, 0, 0, 0], "200: 0x0000001E"), // fixed32. - - ([192, 12, 129, 1], "200: 129"), // varint of 129 (two bytes on wire). - ([195, 12, 11, 8, 1, 12, 196, 12], "200 {\n 1 {\n 1: 1\n }\n}"), // StartGroup, Field 1: StartGroup, Field 1: varint of 1, EndGroup, EndGroup. + ([192, 12, 1], "200: 1"), // varint of 1. + ([193, 12, 20, 0, 0, 0, 0, 0, 0, 0], "200: 0x0000000000000014"), // fixed64 of 20 + ([194, 12, 3, 65, 66, 67], "200: \"ABC\""), // length delimited. + ([195, 12, 8, 1, 196, 12], "200 {\n 1: 1\n}"), // StartGroup, Field 1: varint of 1, EndGroup. + ([197, 12, 30, 0, 0, 0], "200: 0x0000001E"), // fixed32. + + ([192, 12, 129, 1], "200: 129"), // varint of 129 (two bytes on wire). + // StartGroup, Field 1: StartGroup, Field 1: varint of 1, EndGroup, EndGroup. + ([195, 12, 11, 8, 1, 12, 196, 12], "200 {\n 1 {\n 1: 1\n }\n}"), ] // Fields at the top level of the message. for (bytes, expectedTextFormat) in testInputs { do { - let msg = try ProtobufUnittest_TestAllTypes(serializedBytes: bytes) + let msg = try SwiftProtoTesting_TestAllTypes(serializedBytes: bytes) XCTAssertEqual(msg.unknownFields.data, Data(bytes), "Decoding \(bytes)") XCTAssertEqual(msg.textFormatString(), expectedTextFormat + "\n", "Decoding \(bytes)") - XCTAssertEqual(try msg.serializedData(), Data(bytes), "Decoding \(bytes)") + XCTAssertEqual(try msg.serializedBytes(), bytes, "Decoding \(bytes)") } catch let e { XCTFail("Decoding \(bytes) failed with error: \(e)") } @@ -2606,11 +2760,11 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { fullExpectedTextFormat.append("}\n") do { - let msg = try ProtobufUnittest_NestedTestAllTypes(serializedBytes: fullBytes) + let msg = try SwiftProtoTesting_NestedTestAllTypes(serializedBytes: fullBytes) XCTAssertTrue(msg.unknownFields.data.isEmpty) XCTAssertEqual(msg.payload.unknownFields.data, Data(bytes), "Decoding \(bytes)") XCTAssertEqual(msg.textFormatString(), fullExpectedTextFormat, "Decoding \(bytes)") - XCTAssertEqual(try msg.serializedData(), Data(fullBytes), "Decoding \(bytes)") + XCTAssertEqual(try msg.serializedBytes(), fullBytes, "Decoding \(bytes)") } catch let e { XCTFail("Decoding \(bytes) failed with error: \(e)") } @@ -2626,11 +2780,11 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { } fullExpectedTextFormat.append("}\n") do { - let msg = try ProtobufUnittest_TestAllTypes(serializedBytes: fullBytes) + let msg = try SwiftProtoTesting_TestAllTypes(serializedBytes: fullBytes) XCTAssertTrue(msg.unknownFields.data.isEmpty) XCTAssertEqual(msg.optionalGroup.unknownFields.data, Data(bytes), "Decoding \(bytes)") XCTAssertEqual(msg.textFormatString(), fullExpectedTextFormat, "Decoding \(bytes)") - XCTAssertEqual(try msg.serializedData(), Data(fullBytes), "Decoding \(bytes)") + XCTAssertEqual(try msg.serializedBytes(), fullBytes, "Decoding \(bytes)") } catch let e { XCTFail("Decoding \(bytes) failed with error: \(e)") } @@ -2639,26 +2793,27 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { func testUnknownFields_Failures() throws { let testInputs: [[UInt8]] = [ - [192, 12], // varint - [192, 12, 129], // varint (should be two bytes) - [193, 12], // fixed64 - [193, 12, 20, 0, 0, 0, 0, 0, 0], // fixed64 - [194, 12], // length delimited. - [194, 12, 3, 65, 66], // length delimited. - [195, 12], // StartGroup. - [195, 12, 8, 1], // StartGroup, Field 1: varint of 1. - [197, 12], // fixed32. - [197, 12, 30, 0, 0], // fixed32. - - [195, 12, 11], // StartGroup, Field 1: StartGroup. - [195, 12, 11, 8, 1, 12], // StartGroup, Field 1: StartGroup, Field 1: varint of 1, EndGroup. - [195, 12, 11, 8, 1, 196, 12], // StartGroup, Field 1: StartGroup, Field 1: varint of 1, EndGroup (but wrong group). + [192, 12], // varint + [192, 12, 129], // varint (should be two bytes) + [193, 12], // fixed64 + [193, 12, 20, 0, 0, 0, 0, 0, 0], // fixed64 + [194, 12], // length delimited. + [194, 12, 3, 65, 66], // length delimited. + [195, 12], // StartGroup. + [195, 12, 8, 1], // StartGroup, Field 1: varint of 1. + [197, 12], // fixed32. + [197, 12, 30, 0, 0], // fixed32. + + [195, 12, 11], // StartGroup, Field 1: StartGroup. + [195, 12, 11, 8, 1, 12], // StartGroup, Field 1: StartGroup, Field 1: varint of 1, EndGroup. + // StartGroup, Field 1: StartGroup, Field 1: varint of 1, EndGroup (but wrong group). + [195, 12, 11, 8, 1, 196, 12], ] // Fields at the top level of the message. for bytes in testInputs { do { - _ = try ProtobufUnittest_TestAllTypes(serializedBytes: bytes) + _ = try SwiftProtoTesting_TestAllTypes(serializedBytes: bytes) XCTFail("Decode of \(bytes) should have failed.") } catch { // Nothing should error! @@ -2670,7 +2825,7 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { // Hang it in the 'payload' field of NestedTestAllTypes let fullBytes = [18, UInt8(bytes.count)] + bytes do { - _ = try ProtobufUnittest_NestedTestAllTypes(serializedBytes: fullBytes) + _ = try SwiftProtoTesting_NestedTestAllTypes(serializedBytes: fullBytes) XCTFail("Decode of \(bytes) should have failed.") } catch { // Nothing should error! @@ -2682,11 +2837,80 @@ class Test_AllTypes: XCTestCase, PBTestHelpers { // Hang it after the start of the 'OptionalGroup' field of TestAllTypes let fullBytes = [131, 1] + bytes do { - _ = try ProtobufUnittest_TestAllTypes(serializedBytes: fullBytes) + _ = try SwiftProtoTesting_TestAllTypes(serializedBytes: fullBytes) XCTFail("Decode of \(bytes) should have failed.") } catch { // Nothing should error! } - } + } + } + + func testReservedFields() { + let setOptionalInt = "optional_int32: 1" + let expected = try! SwiftProtoTesting_TestAllTypes(textFormatString: setOptionalInt) + XCTAssertEqual(expected.optionalInt32, 1) + + let testFields: [String] = [ + "reserved_field", // by name + "999999", // by number + ] + + let testValues: [String] = [ + "2", + "\"foo\"", + "ENUM_VALUE", + "-1.2", + "true", + "{ something: 1 }", + "< something: 1 >", + ] + + let testValueWrappers: [(String, String)] = [ + ("", ""), // Bare value + ("[", "]"), // Into an array + ] + + let unknownFieldInput = "mumble_nope: 1" + + var options = TextFormatDecodingOptions() + options.ignoreUnknownFields = true + + for testField in testFields { + for testValue in testValues { + for (pre, post) in testValueWrappers { + + // parse with something valid after the input to confirm that works + let validInput = "\(testField): \(pre)\(testValue)\(post)\n\(setOptionalInt)" + do { + let msg = try SwiftProtoTesting_TestAllTypes(textFormatString: validInput) + XCTAssertEqual(msg, expected, "Not equal for \(validInput): \(msg)") + } catch let e { + XCTFail("Parsing \(validInput) failed with error: \(e)") + } + + // Add something unknown and confirm it errors + let withUnknownInput = "\(testField): \(testValue)\n\(unknownFieldInput)\n\(setOptionalInt)" + do { + let _ = try SwiftProtoTesting_TestAllTypes(textFormatString: withUnknownInput) + XCTFail("Shouldn't get here") + } catch TextFormatDecodingError.unknownField { + // This is what should have happened. + } catch let e { + XCTFail("Parsing \(withUnknownInput) failed with error: \(e)") + } + + // With something unknown, but skip unknowns. + do { + let msg = try SwiftProtoTesting_TestAllTypes( + textFormatString: withUnknownInput, + options: options + ) + XCTAssertEqual(msg, expected, "Not equal for \(withUnknownInput): \(msg)") + } catch let e { + XCTFail("Parsing \(withUnknownInput) failed with error: \(e)") + } + } + } + } } } diff --git a/Tests/SwiftProtobufTests/Test_AllTypes_Proto3.swift b/Tests/SwiftProtobufTests/Test_AllTypes_Proto3.swift index a066382ea..ae9351a1a 100644 --- a/Tests/SwiftProtobufTests/Test_AllTypes_Proto3.swift +++ b/Tests/SwiftProtobufTests/Test_AllTypes_Proto3.swift @@ -18,18 +18,23 @@ import Foundation import XCTest -class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { - typealias MessageTestType = Proto3Unittest_TestAllTypes +final class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_Proto3_TestAllTypes // Custom decodeSucceeds that also does a round-trip through the Empty // message to make sure unknown fields are consistently preserved by proto2. - func assertDecodeSucceeds(_ bytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line, check: (MessageTestType) -> Bool) { + func assertDecodeSucceeds( + _ bytes: [UInt8], + file: XCTestFileArgType = #file, + line: UInt = #line, + check: (MessageTestType) -> Bool + ) { baseAssertDecodeSucceeds(bytes, file: file, line: line, check: check) do { // Make sure unknown fields are preserved by empty message decode/encode - let empty = try ProtobufUnittest_TestEmptyMessage(serializedBytes: bytes) + let empty = try SwiftProtoTesting_TestEmptyMessage(serializedBytes: bytes) do { - let newBytes = try empty.serializedBytes() + let newBytes: [UInt8] = try empty.serializedBytes() XCTAssertEqual(bytes, newBytes, "Empty decode/recode did not match", file: file, line: line) } catch let e { XCTFail("Reserializing empty threw an error: \(e)", file: file, line: line) @@ -39,46 +44,46 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } } - func assertDebugDescription(_ expected: String, file: XCTestFileArgType = #file, line: UInt = #line, configure: (inout MessageTestType) -> ()) { - var m = MessageTestType() - configure(&m) - let actual = m.debugDescription - XCTAssertEqual(actual, expected, file: file, line: line) - } - // // Singular types // func testEncoding_optionalInt32() { - assertEncode([8, 1]) {(o: inout MessageTestType) in o.optionalInt32 = 1} - assertEncode([8, 255, 255, 255, 255, 7]) {(o: inout MessageTestType) in o.optionalInt32 = Int32.max} - assertEncode([8, 128, 128, 128, 128, 248, 255, 255, 255, 255, 1]) {(o: inout MessageTestType) in o.optionalInt32 = Int32.min} - assertDecodeSucceeds([8, 1]) {(o: MessageTestType) in + assertEncode([8, 1]) { (o: inout MessageTestType) in o.optionalInt32 = 1 } + assertEncode([8, 255, 255, 255, 255, 7]) { (o: inout MessageTestType) in o.optionalInt32 = Int32.max } + assertEncode([8, 128, 128, 128, 128, 248, 255, 255, 255, 255, 1]) { (o: inout MessageTestType) in + o.optionalInt32 = Int32.min + } + assertDecodeSucceeds([8, 1]) { (o: MessageTestType) in let t: Int32 = o.optionalInt32 return t == 1 } - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_int32: 1\n") {(o: inout MessageTestType) in o.optionalInt32 = 1} - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_int32: -2147483648\noptional_uint32: 4294967295\n") {(o: inout MessageTestType) in + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_int32: 1\n") { + (o: inout MessageTestType) in o.optionalInt32 = 1 + } + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_int32: -2147483648\noptional_uint32: 4294967295\n" + ) { (o: inout MessageTestType) in o.optionalInt32 = Int32.min o.optionalUint32 = UInt32.max } - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\n") {(o: inout MessageTestType) in + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\n") { + (o: inout MessageTestType) in o.optionalInt32 = 1 o.optionalInt32 = 0 } // Technically, this overflows Int32, but we truncate and accept it. - assertDecodeSucceeds([8, 255, 255, 255, 255, 255, 255, 1]) {$0.optionalInt32 == -1} + assertDecodeSucceeds([8, 255, 255, 255, 255, 255, 255, 1]) { $0.optionalInt32 == -1 } assertDecodeFails([8]) - assertDecodeFails([9, 57]) // Cannot use wire type 1 - assertDecodeFails([10, 58]) // Cannot use wire type 2 - assertDecodeFails([11, 59]) // Cannot use wire type 3 - assertDecodeFails([12, 60]) // Cannot use wire type 4 - assertDecodeFails([13, 61]) // Cannot use wire type 5 - assertDecodeFails([14, 62]) // Cannot use wire type 6 - assertDecodeFails([15, 63]) // Cannot use wire type 7 + assertDecodeFails([9, 57]) // Cannot use wire type 1 + assertDecodeFails([10, 58]) // Cannot use wire type 2 + assertDecodeFails([11, 59]) // Cannot use wire type 3 + assertDecodeFails([12, 60]) // Cannot use wire type 4 + assertDecodeFails([13, 61]) // Cannot use wire type 5 + assertDecodeFails([14, 62]) // Cannot use wire type 6 + assertDecodeFails([15, 63]) // Cannot use wire type 7 assertDecodeFails([8, 188]) assertDecodeFails([8]) @@ -94,14 +99,20 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalInt64() { - assertEncode([16, 1]) {(o: inout MessageTestType) in o.optionalInt64 = 1} - assertEncode([16, 255, 255, 255, 255, 255, 255, 255, 255, 127]) {(o: inout MessageTestType) in o.optionalInt64 = Int64.max} - assertEncode([16, 128, 128, 128, 128, 128, 128, 128, 128, 128, 1]) {(o: inout MessageTestType) in o.optionalInt64 = Int64.min} - assertDecodeSucceeds([16, 184, 156, 195, 145, 203, 1]) {(o: MessageTestType) in - let t: Int64 = o.optionalInt64 // Verify in-memory type - return t == 54529150520 - } - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_int64: 1\n") {(o: inout MessageTestType) in o.optionalInt64 = 1} + assertEncode([16, 1]) { (o: inout MessageTestType) in o.optionalInt64 = 1 } + assertEncode([16, 255, 255, 255, 255, 255, 255, 255, 255, 127]) { (o: inout MessageTestType) in + o.optionalInt64 = Int64.max + } + assertEncode([16, 128, 128, 128, 128, 128, 128, 128, 128, 128, 1]) { (o: inout MessageTestType) in + o.optionalInt64 = Int64.min + } + assertDecodeSucceeds([16, 184, 156, 195, 145, 203, 1]) { (o: MessageTestType) in + let t: Int64 = o.optionalInt64 // Verify in-memory type + return t == 54_529_150_520 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_int64: 1\n") { + (o: inout MessageTestType) in o.optionalInt64 = 1 + } assertDecodeFails([16]) assertDecodeFails([16, 184, 156, 195, 145, 203]) assertDecodeFails([17, 81]) @@ -124,12 +135,14 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalUint32() { - assertEncode([24, 255, 255, 255, 255, 15]) {(o: inout MessageTestType) in o.optionalUint32 = UInt32.max} - assertDecodeSucceeds([24, 149, 88]) {(o: MessageTestType) in + assertEncode([24, 255, 255, 255, 255, 15]) { (o: inout MessageTestType) in o.optionalUint32 = UInt32.max } + assertDecodeSucceeds([24, 149, 88]) { (o: MessageTestType) in let t: UInt32 = o.optionalUint32 return t == 11285 } - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_uint32: 1\n") {(o: inout MessageTestType) in o.optionalUint32 = 1} + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_uint32: 1\n") { + (o: inout MessageTestType) in o.optionalUint32 = 1 + } assertDecodeFails([24]) assertDecodeFails([24, 149]) assertDecodeFails([25, 105]) @@ -153,12 +166,16 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalUint64() throws { - assertEncode([32, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1]) {(o: inout MessageTestType) in o.optionalUint64 = UInt64.max} - assertDecodeSucceeds([32, 149, 7]) {(o: MessageTestType) in + assertEncode([32, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1]) { (o: inout MessageTestType) in + o.optionalUint64 = UInt64.max + } + assertDecodeSucceeds([32, 149, 7]) { (o: MessageTestType) in let t: UInt64 = o.optionalUint64 return t == 917 } - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_uint64: 1\n") {(o: inout MessageTestType) in o.optionalUint64 = 1} + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_uint64: 1\n") { + (o: inout MessageTestType) in o.optionalUint64 = 1 + } assertDecodeFails([32]) assertDecodeFails([32, 149]) assertDecodeFails([32, 149, 190, 193, 230, 186, 233, 166, 219]) @@ -166,7 +183,7 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { assertDecodeFails([33, 0]) assertDecodeFails([33, 8, 0]) assertDecodeFails([34]) - assertDecodesAsUnknownFields([34, 0]) // Wrong wire type (length delimited), valid as an unknown field + assertDecodesAsUnknownFields([34, 0]) // Wrong wire type (length delimited), valid as an unknown field assertDecodeFails([34, 8, 0]) assertDecodeFails([35]) assertDecodeFails([35, 0]) @@ -197,21 +214,27 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalSint32() { - assertEncode([40, 254, 255, 255, 255, 15]) {(o: inout MessageTestType) in o.optionalSint32 = Int32.max} - assertEncode([40, 255, 255, 255, 255, 15]) {(o: inout MessageTestType) in o.optionalSint32 = Int32.min} - assertDecodeSucceeds([40, 0x81, 0x82, 0x80, 0x00]) {(o: MessageTestType) in - let t: Int32 = o.optionalSint32 // Verify in-memory type + assertEncode([40, 254, 255, 255, 255, 15]) { (o: inout MessageTestType) in o.optionalSint32 = Int32.max } + assertEncode([40, 255, 255, 255, 255, 15]) { (o: inout MessageTestType) in o.optionalSint32 = Int32.min } + assertDecodeSucceeds([40, 0x81, 0x82, 0x80, 0x00]) { (o: MessageTestType) in + let t: Int32 = o.optionalSint32 // Verify in-memory type return t == -129 } - assertDecodeSucceeds([40, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00]) {$0.optionalSint32 == 0} - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_sint32: 1\n") {(o: inout MessageTestType) in o.optionalSint32 = 1} + assertDecodeSucceeds([40, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00]) { + $0.optionalSint32 == 0 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_sint32: 1\n") { + (o: inout MessageTestType) in o.optionalSint32 = 1 + } // Truncate on overflow - assertDecodeSucceeds([40, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f]) {$0.optionalSint32 == -2147483648} - assertDecodeSucceeds([40, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x7f]) {$0.optionalSint32 == 2147483647} + assertDecodeSucceeds([40, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f]) { $0.optionalSint32 == -2_147_483_648 } + assertDecodeSucceeds([40, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x7f]) { $0.optionalSint32 == 2_147_483_647 } assertDecodeFails([40]) - assertDecodeFails([40, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00]) + assertDecodeFails([ + 40, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + ]) assertDecodeFails([41]) assertDecodeFails([41, 0]) assertDecodeFails([42]) @@ -239,13 +262,19 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalSint64() { - assertEncode([48, 254, 255, 255, 255, 255, 255, 255, 255, 255, 1]) {(o: inout MessageTestType) in o.optionalSint64 = Int64.max} - assertEncode([48, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1]) {(o: inout MessageTestType) in o.optionalSint64 = Int64.min} - assertDecodeSucceeds([48, 139, 94]) {(o: MessageTestType) in + assertEncode([48, 254, 255, 255, 255, 255, 255, 255, 255, 255, 1]) { (o: inout MessageTestType) in + o.optionalSint64 = Int64.max + } + assertEncode([48, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1]) { (o: inout MessageTestType) in + o.optionalSint64 = Int64.min + } + assertDecodeSucceeds([48, 139, 94]) { (o: MessageTestType) in let t: Int64 = o.optionalSint64 return t == -6022 } - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_sint64: 1\n") {(o: inout MessageTestType) in o.optionalSint64 = 1} + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_sint64: 1\n") { + (o: inout MessageTestType) in o.optionalSint64 = 1 + } assertDecodeFails([48]) assertDecodeFails([48, 139]) assertDecodeFails([49]) @@ -275,12 +304,14 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalFixed32() throws { - assertEncode([61, 255, 255, 255, 255]) {(o: inout MessageTestType) in o.optionalFixed32 = UInt32.max} - assertDecodeSucceeds([61, 8, 12, 108, 1]) {(o: MessageTestType) in + assertEncode([61, 255, 255, 255, 255]) { (o: inout MessageTestType) in o.optionalFixed32 = UInt32.max } + assertDecodeSucceeds([61, 8, 12, 108, 1]) { (o: MessageTestType) in let t: UInt32 = o.optionalFixed32 - return t == 23858184 + return t == 23_858_184 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_fixed32: 1\n") { + (o: inout MessageTestType) in o.optionalFixed32 = 1 } - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_fixed32: 1\n") {(o: inout MessageTestType) in o.optionalFixed32 = 1} assertDecodeFails([61]) assertDecodeFails([61, 255]) assertDecodeFails([61, 255, 255]) @@ -320,12 +351,16 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalFixed64() throws { - assertEncode([65, 255, 255, 255, 255, 255, 255, 255, 255]) {(o: inout MessageTestType) in o.optionalFixed64 = UInt64.max} - assertDecodeSucceeds([65, 255, 255, 255, 255, 255, 255, 255, 255]) {(o: MessageTestType) in - let t: UInt64 = o.optionalFixed64 // Verify in-memory type - return t == 18446744073709551615 + assertEncode([65, 255, 255, 255, 255, 255, 255, 255, 255]) { (o: inout MessageTestType) in + o.optionalFixed64 = UInt64.max + } + assertDecodeSucceeds([65, 255, 255, 255, 255, 255, 255, 255, 255]) { (o: MessageTestType) in + let t: UInt64 = o.optionalFixed64 // Verify in-memory type + return t == 18_446_744_073_709_551_615 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_fixed64: 1\n") { + (o: inout MessageTestType) in o.optionalFixed64 = 1 } - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_fixed64: 1\n") {(o: inout MessageTestType) in o.optionalFixed64 = 1} assertDecodeFails([65]) assertDecodeFails([65, 255]) assertDecodeFails([65, 255, 255]) @@ -369,14 +404,16 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalSfixed32() throws { - assertEncode([77, 255, 255, 255, 127]) {(o: inout MessageTestType) in o.optionalSfixed32 = Int32.max} - assertEncode([77, 0, 0, 0, 128]) {(o: inout MessageTestType) in o.optionalSfixed32 = Int32.min} - assertDecodeSucceeds([77, 0, 0, 0, 0]) {(o: MessageTestType) in - let t: Int32 = o.optionalSfixed32 // Verify in-memory type + assertEncode([77, 255, 255, 255, 127]) { (o: inout MessageTestType) in o.optionalSfixed32 = Int32.max } + assertEncode([77, 0, 0, 0, 128]) { (o: inout MessageTestType) in o.optionalSfixed32 = Int32.min } + assertDecodeSucceeds([77, 0, 0, 0, 0]) { (o: MessageTestType) in + let t: Int32 = o.optionalSfixed32 // Verify in-memory type return t == 0 } - assertDecodeSucceeds([77, 255, 255, 255, 255]) {$0.optionalSfixed32 == -1} - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_sfixed32: 1\n") {(o: inout MessageTestType) in o.optionalSfixed32 = 1} + assertDecodeSucceeds([77, 255, 255, 255, 255]) { $0.optionalSfixed32 == -1 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_sfixed32: 1\n") { + (o: inout MessageTestType) in o.optionalSfixed32 = 1 + } assertDecodeFails([77]) assertDecodeFails([77]) assertDecodeFails([77, 0]) @@ -416,13 +453,17 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalSfixed64() throws { - assertEncode([81, 255, 255, 255, 255, 255, 255, 255, 127]) {(o: inout MessageTestType) in o.optionalSfixed64 = Int64.max} - assertEncode([81, 0, 0, 0, 0, 0, 0, 0, 128]) {(o: inout MessageTestType) in o.optionalSfixed64 = Int64.min} - assertDecodeSucceeds([81, 0, 0, 0, 0, 0, 0, 0, 128]) {(o: MessageTestType) in - let t: Int64 = o.optionalSfixed64 // Verify in-memory type - return t == -9223372036854775808 + assertEncode([81, 255, 255, 255, 255, 255, 255, 255, 127]) { (o: inout MessageTestType) in + o.optionalSfixed64 = Int64.max + } + assertEncode([81, 0, 0, 0, 0, 0, 0, 0, 128]) { (o: inout MessageTestType) in o.optionalSfixed64 = Int64.min } + assertDecodeSucceeds([81, 0, 0, 0, 0, 0, 0, 0, 128]) { (o: MessageTestType) in + let t: Int64 = o.optionalSfixed64 // Verify in-memory type + return t == -9_223_372_036_854_775_808 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_sfixed64: 1\n") { + (o: inout MessageTestType) in o.optionalSfixed64 = 1 } - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_sfixed64: 1\n") {(o: inout MessageTestType) in o.optionalSfixed64 = 1} assertDecodeFails([81]) assertDecodeFails([81, 0]) assertDecodeFails([81, 0, 0]) @@ -463,32 +504,33 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalFloat() throws { - assertEncode([93, 0, 0, 0, 63]) {(o: inout MessageTestType) in o.optionalFloat = 0.5} - assertEncode([93, 0, 0, 0, 64]) {(o: inout MessageTestType) in o.optionalFloat = 2.0} - assertDecodeSucceeds([93, 0, 0, 0, 0]) {(o: MessageTestType) in + assertEncode([93, 0, 0, 0, 63]) { (o: inout MessageTestType) in o.optionalFloat = 0.5 } + assertEncode([93, 0, 0, 0, 64]) { (o: inout MessageTestType) in o.optionalFloat = 2.0 } + assertDecodeSucceeds([93, 0, 0, 0, 0]) { (o: MessageTestType) in let t: Float = o.optionalFloat return t == 0 } - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_float: 1.0\n") { - (o: inout MessageTestType) in o.optionalFloat = 1.0} + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_float: 1.0\n") { + (o: inout MessageTestType) in o.optionalFloat = 1.0 + } assertDecodeFails([93, 0, 0, 0]) assertDecodeFails([93, 0, 0]) assertDecodeFails([93, 0]) assertDecodeFails([93]) - assertDecodeFails([88]) // Float cannot use wire type 0 + assertDecodeFails([88]) // Float cannot use wire type 0 assertDecodesAsUnknownFields([88, 0]) // Wrong wire type (varint), valid as an unknown field - assertDecodeFails([89]) // Float cannot use wire type 1 - assertDecodeFails([89, 0, 0, 0, 0]) // Float cannot use wire type 1 - assertDecodeFails([90]) // Float cannot use wire type 2 + assertDecodeFails([89]) // Float cannot use wire type 1 + assertDecodeFails([89, 0, 0, 0, 0]) // Float cannot use wire type 1 + assertDecodeFails([90]) // Float cannot use wire type 2 assertDecodesAsUnknownFields([90, 0]) // Wrong wire type (length delimited), valid as an unknown field - assertDecodeFails([91]) // Float cannot use wire type 3 - assertDecodeFails([91, 0, 0, 0, 0]) // Float cannot use wire type 3 - assertDecodeFails([92]) // Float cannot use wire type 4 - assertDecodeFails([92, 0, 0, 0, 0]) // Float cannot use wire type 4 - assertDecodeFails([94]) // Float cannot use wire type 6 - assertDecodeFails([94, 0, 0, 0, 0]) // Float cannot use wire type 6 - assertDecodeFails([95]) // Float cannot use wire type 7 - assertDecodeFails([95, 0, 0, 0, 0]) // Float cannot use wire type 7 + assertDecodeFails([91]) // Float cannot use wire type 3 + assertDecodeFails([91, 0, 0, 0, 0]) // Float cannot use wire type 3 + assertDecodeFails([92]) // Float cannot use wire type 4 + assertDecodeFails([92, 0, 0, 0, 0]) // Float cannot use wire type 4 + assertDecodeFails([94]) // Float cannot use wire type 6 + assertDecodeFails([94, 0, 0, 0, 0]) // Float cannot use wire type 6 + assertDecodeFails([95]) // Float cannot use wire type 7 + assertDecodeFails([95, 0, 0, 0, 0]) // Float cannot use wire type 7 let empty = MessageTestType() var a = empty @@ -503,14 +545,15 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalDouble() throws { - assertEncode([97, 0, 0, 0, 0, 0, 0, 224, 63]) {(o: inout MessageTestType) in o.optionalDouble = 0.5} - assertEncode([97, 0, 0, 0, 0, 0, 0, 0, 64]) {(o: inout MessageTestType) in o.optionalDouble = 2.0} - assertDecodeSucceeds([97, 0, 0, 0, 0, 0, 0, 224, 63]) {(o: MessageTestType) in + assertEncode([97, 0, 0, 0, 0, 0, 0, 224, 63]) { (o: inout MessageTestType) in o.optionalDouble = 0.5 } + assertEncode([97, 0, 0, 0, 0, 0, 0, 0, 64]) { (o: inout MessageTestType) in o.optionalDouble = 2.0 } + assertDecodeSucceeds([97, 0, 0, 0, 0, 0, 0, 224, 63]) { (o: MessageTestType) in let t: Double = o.optionalDouble return t == 0.5 } - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_double: 1.0\n") { - (o: inout MessageTestType) in o.optionalDouble = 1.0} + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_double: 1.0\n") { + (o: inout MessageTestType) in o.optionalDouble = 1.0 + } assertDecodeFails([97, 0, 0, 0, 0, 0, 0, 224]) assertDecodeFails([97]) assertDecodeFails([96]) @@ -548,13 +591,17 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalBool() throws { - assertEncode([104, 1]) {(o: inout MessageTestType) in o.optionalBool = true} - assertDecodeSucceeds([104, 1]) {(o: MessageTestType) in - let t: Bool = o.optionalBool // Verify non-optional + assertEncode([104, 1]) { (o: inout MessageTestType) in o.optionalBool = true } + assertDecodeSucceeds([104, 1]) { (o: MessageTestType) in + let t: Bool = o.optionalBool // Verify non-optional return t == true } - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_bool: true\n") {(o: inout MessageTestType) in o.optionalBool = true} - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\n") {(o: inout MessageTestType) in o.optionalBool = false} + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_bool: true\n") { + (o: inout MessageTestType) in o.optionalBool = true + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\n") { + (o: inout MessageTestType) in o.optionalBool = false + } assertDecodeFails([104]) assertDecodeFails([104, 255]) assertDecodeFails([105]) @@ -585,18 +632,21 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalString() throws { - assertEncode([114, 1, 65]) {(o: inout MessageTestType) in o.optionalString = "A"} - assertEncode([114, 4, 0xf0, 0x9f, 0x98, 0x84]) {(o: inout MessageTestType) in o.optionalString = "😄"} - assertDecodeSucceeds([114, 5, 72, 101, 108, 108, 111]) {(o: MessageTestType) in - let t: String = o.optionalString // Verify non-optional + assertEncode([114, 1, 65]) { (o: inout MessageTestType) in o.optionalString = "A" } + assertEncode([114, 4, 0xf0, 0x9f, 0x98, 0x84]) { (o: inout MessageTestType) in o.optionalString = "😄" } + assertDecodeSucceeds([114, 5, 72, 101, 108, 108, 111]) { (o: MessageTestType) in + let t: String = o.optionalString // Verify non-optional return t == "Hello" } - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_string: \"abc\"\n") {(o: inout MessageTestType) in o.optionalString = "abc"} - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_string: \"\\b\\t\"\n") {(o: inout MessageTestType) in o.optionalString = "\u{08}\u{09}"} + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_string: \"abc\"\n") + { (o: inout MessageTestType) in o.optionalString = "abc" } + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_string: \"\\b\\t\"\n" + ) { (o: inout MessageTestType) in o.optionalString = "\u{08}\u{09}" } assertDecodeFails([114]) assertDecodeFails([114, 1]) assertDecodeFails([114, 2, 65]) - assertDecodeFails([114, 1, 193]) // Invalid UTF-8 + assertDecodeFails([114, 1, 193]) // Invalid UTF-8 assertDecodeFails([112]) assertDecodesAsUnknownFields([112, 0]) // Wrong wire type (varint), valid as an unknown field assertDecodeFails([113]) @@ -625,13 +675,15 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalBytes() { - assertEncode([122, 1, 1]) {(o: inout MessageTestType) in o.optionalBytes = Data([1])} - assertEncode([122, 2, 1, 2]) {(o: inout MessageTestType) in o.optionalBytes = Data([1, 2])} - assertDecodeSucceeds([122, 4, 0, 1, 2, 255]) {(o: MessageTestType) in - let t = o.optionalBytes // Verify non-optional + assertEncode([122, 1, 1]) { (o: inout MessageTestType) in o.optionalBytes = Data([1]) } + assertEncode([122, 2, 1, 2]) { (o: inout MessageTestType) in o.optionalBytes = Data([1, 2]) } + assertDecodeSucceeds([122, 4, 0, 1, 2, 255]) { (o: MessageTestType) in + let t = o.optionalBytes // Verify non-optional return t == Data([0, 1, 2, 255]) } - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_bytes: \"\\001\\002\\003\"\n") {(o: inout MessageTestType) in o.optionalBytes = Data([1, 2, 3])} + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_bytes: \"\\001\\002\\003\"\n" + ) { (o: inout MessageTestType) in o.optionalBytes = Data([1, 2, 3]) } assertDecodeFails([122]) assertDecodeFails([122, 1]) assertDecodeFails([122, 2, 0]) @@ -664,12 +716,14 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalNestedMessage() { - assertEncode([146, 1, 2, 8, 1]) {(o: inout MessageTestType) in + assertEncode([146, 1, 2, 8, 1]) { (o: inout MessageTestType) in o.optionalNestedMessage.bb = 1 } - assertDecodeSucceeds([146, 1, 4, 8, 1, 8, 3]) {$0.optionalNestedMessage.bb == 3} - assertDecodeSucceeds([146, 1, 2, 8, 1, 146, 1, 2, 8, 4]) {$0.optionalNestedMessage.bb == 4} - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_nested_message {\n bb: 1\n}\n") {(o: inout MessageTestType) in + assertDecodeSucceeds([146, 1, 4, 8, 1, 8, 3]) { $0.optionalNestedMessage.bb == 3 } + assertDecodeSucceeds([146, 1, 2, 8, 1, 146, 1, 2, 8, 4]) { $0.optionalNestedMessage.bb == 4 } + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_nested_message {\n bb: 1\n}\n" + ) { (o: inout MessageTestType) in var nested = MessageTestType.NestedMessage() nested.bb = 1 o.optionalNestedMessage = nested @@ -692,34 +746,42 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalForeignMessage() { - assertEncode([154, 1, 2, 8, 1]) {(o: inout MessageTestType) in + assertEncode([154, 1, 2, 8, 1]) { (o: inout MessageTestType) in o.optionalForeignMessage.c = 1 } - assertDecodeSucceeds([154, 1, 4, 8, 1, 8, 3]) {$0.optionalForeignMessage.c == 3} - assertDecodeSucceeds([154, 1, 2, 8, 1, 154, 1, 2, 8, 4]) {$0.optionalForeignMessage.c == 4} - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_foreign_message {\n c: 1\n}\n") {(o: inout MessageTestType) in - var foreign = Proto3Unittest_ForeignMessage() + assertDecodeSucceeds([154, 1, 4, 8, 1, 8, 3]) { $0.optionalForeignMessage.c == 3 } + assertDecodeSucceeds([154, 1, 2, 8, 1, 154, 1, 2, 8, 4]) { $0.optionalForeignMessage.c == 4 } + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_foreign_message {\n c: 1\n}\n" + ) { (o: inout MessageTestType) in + var foreign = SwiftProtoTesting_Proto3_ForeignMessage() foreign.c = 1 o.optionalForeignMessage = foreign } assertDecodesAsUnknownFields([152, 1, 0]) // Wrong wire type (varint), valid as an unknown field - assertDecodeFails([153, 1]) // Wire type 1 + assertDecodeFails([153, 1]) // Wire type 1 assertDecodeFails([153, 1, 0]) - assertDecodesAsUnknownFields([153, 1, 0, 0, 0, 0, 0, 0, 0, 0]) // Wrong wire type (fixed64), valid as an unknown field - assertDecodeFails([155, 1]) // Wire type 3 + assertDecodesAsUnknownFields([ + 153, 1, // Wrong wire type (fixed64), valid as an unknown field + 0, 0, 0, 0, 0, 0, 0, 0, + ]) + assertDecodeFails([155, 1]) // Wire type 3 assertDecodeFails([155, 1, 0]) - assertDecodesAsUnknownFields([155, 1, 156, 1]) // Wrong wire type (start group, end group), valid as an unknown field - assertDecodeFails([156, 1]) // Wire type 4 + assertDecodesAsUnknownFields([ + 155, 1, // Wrong wire type (start group, end group), valid as an unknown field + 156, 1, + ]) + assertDecodeFails([156, 1]) // Wire type 4 assertDecodeFails([156, 1, 0]) - assertDecodeFails([157, 1]) // Wire type 5 + assertDecodeFails([157, 1]) // Wire type 5 assertDecodeFails([157, 1, 0]) assertDecodesAsUnknownFields([157, 1, 0, 0, 0, 0]) // Wrong wire type (fixed32), valid as an unknown field - assertDecodeFails([158, 1]) // Wire type 6 + assertDecodeFails([158, 1]) // Wire type 6 assertDecodeFails([158, 1, 0]) - assertDecodeFails([159, 1]) // Wire type 7 + assertDecodeFails([159, 1]) // Wire type 7 assertDecodeFails([159, 1, 0]) - assertDecodeFails([154, 1, 4, 8, 1]) // Truncated + assertDecodeFails([154, 1, 4, 8, 1]) // Truncated // Ensure storage is uniqued for clear. let c = MessageTestType.with { @@ -736,11 +798,11 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalImportMessage() { - assertEncode([162, 1, 2, 8, 1]) {(o: inout MessageTestType) in + assertEncode([162, 1, 2, 8, 1]) { (o: inout MessageTestType) in o.optionalImportMessage.d = 1 } - assertDecodeSucceeds([162, 1, 4, 8, 1, 8, 3]) {$0.optionalImportMessage.d == 3} - assertDecodeSucceeds([162, 1, 2, 8, 1, 162, 1, 2, 8, 4]) {$0.optionalImportMessage.d == 4} + assertDecodeSucceeds([162, 1, 4, 8, 1, 8, 3]) { $0.optionalImportMessage.d == 3 } + assertDecodeSucceeds([162, 1, 2, 8, 1, 162, 1, 2, 8, 4]) { $0.optionalImportMessage.d == 4 } // Ensure storage is uniqued for clear. let c = MessageTestType.with { @@ -757,23 +819,28 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalNestedEnum() { - assertEncode([168, 1, 2]) {(o: inout MessageTestType) in + assertEncode([168, 1, 2]) { (o: inout MessageTestType) in o.optionalNestedEnum = .bar } - assertDecodeSucceeds([168, 1, 2]) {$0.optionalNestedEnum == .bar} + assertDecodeSucceeds([168, 1, 2]) { $0.optionalNestedEnum == .bar } assertDecodeFails([168, 1]) - assertDecodeSucceeds([168, 1, 128, 1]) {$0.optionalNestedEnum == .UNRECOGNIZED(128)} - assertDecodeSucceeds([168, 1, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1]) {$0.optionalNestedEnum == .UNRECOGNIZED(-1)} - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_nested_enum: BAR\n") {(o: inout MessageTestType) in + assertDecodeSucceeds([168, 1, 128, 1]) { $0.optionalNestedEnum == .UNRECOGNIZED(128) } + assertDecodeSucceeds([168, 1, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1]) { + $0.optionalNestedEnum == .UNRECOGNIZED(-1) + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_nested_enum: BAR\n") + { (o: inout MessageTestType) in o.optionalNestedEnum = .bar } } func testEncoding_optionalForeignEnum() { - assertEncode([176, 1, 5]) {(o: inout MessageTestType) in + assertEncode([176, 1, 5]) { (o: inout MessageTestType) in o.optionalForeignEnum = .foreignBar } - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_foreign_enum: FOREIGN_BAR\n") {(o: inout MessageTestType) in + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_foreign_enum: FOREIGN_BAR\n" + ) { (o: inout MessageTestType) in o.optionalForeignEnum = .foreignBar } } @@ -782,36 +849,46 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { // Repeated types // func testEncoding_repeatedInt32() { - assertEncode([250, 1, 15, 255, 255, 255, 255, 7, 128, 128, 128, 128, 248, 255, 255, 255, 255, 1]) {(o: inout MessageTestType) in o.repeatedInt32 = [Int32.max, Int32.min]} - assertDecodeSucceeds([248, 1, 8, 248, 1, 247, 255, 255, 255, 15]) {$0.repeatedInt32 == [8, -9]} + assertEncode([250, 1, 15, 255, 255, 255, 255, 7, 128, 128, 128, 128, 248, 255, 255, 255, 255, 1]) { + (o: inout MessageTestType) in o.repeatedInt32 = [Int32.max, Int32.min] + } + assertDecodeSucceeds([248, 1, 8, 248, 1, 247, 255, 255, 255, 15]) { $0.repeatedInt32 == [8, -9] } assertDecodeFails([248, 1, 8, 248, 1, 247, 255, 255, 255, 255, 255, 255, 255, 255]) assertDecodeFails([248, 1, 8, 248, 1]) assertDecodeFails([248, 1]) assertDecodeFails([249, 1, 73]) // 250, 1 should actually work because that's packed - assertDecodeSucceeds([250, 1, 4, 8, 9, 10, 11]) {$0.repeatedInt32 == [8, 9, 10, 11]} + assertDecodeSucceeds([250, 1, 4, 8, 9, 10, 11]) { $0.repeatedInt32 == [8, 9, 10, 11] } assertDecodeFails([251, 1, 75]) assertDecodeFails([252, 1, 76]) assertDecodeFails([253, 1, 77]) assertDecodeFails([254, 1, 78]) assertDecodeFails([255, 1, 79]) - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\nrepeated_int32: [1]\n") {(o: inout MessageTestType) in + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\nrepeated_int32: [1]\n") { + (o: inout MessageTestType) in o.repeatedInt32 = [1] } - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\n") {(o: inout MessageTestType) in + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\n") { + (o: inout MessageTestType) in o.repeatedInt32 = [] } - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\nrepeated_int32: [1, 2]\n") {(o: inout MessageTestType) in + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\nrepeated_int32: [1, 2]\n") { + (o: inout MessageTestType) in o.repeatedInt32 = [1, 2] } } - func testEncoding_repeatedInt64() { - assertEncode([130, 2, 19, 255, 255, 255, 255, 255, 255, 255, 255, 127, 128, 128, 128, 128, 128, 128, 128, 128, 128, 1]) {(o: inout MessageTestType) in o.repeatedInt64 = [Int64.max, Int64.min]} - assertDecodeSucceeds([128, 2, 255, 255, 153, 166, 234, 175, 227, 1, 128, 2, 185, 156, 196, 237, 158, 222, 230, 255, 255, 1]) {$0.repeatedInt64 == [999999999999999, -111111111111111]} - assertDecodeSucceeds([130, 2, 1, 1]) {$0.repeatedInt64 == [1]} // Accepts packed coding - assertDecodeFails([128, 2, 255, 255, 153, 166, 234, 175, 227, 1, 128, 2, 185, 156, 196, 237, 158, 222, 230, 255, 255]) + assertEncode([ + 130, 2, 19, 255, 255, 255, 255, 255, 255, 255, 255, 127, 128, 128, 128, 128, 128, 128, 128, 128, 128, 1, + ]) { (o: inout MessageTestType) in o.repeatedInt64 = [Int64.max, Int64.min] } + assertDecodeSucceeds([ + 128, 2, 255, 255, 153, 166, 234, 175, 227, 1, 128, 2, 185, 156, 196, 237, 158, 222, 230, 255, 255, 1, + ]) { $0.repeatedInt64 == [999_999_999_999_999, -111_111_111_111_111] } + assertDecodeSucceeds([130, 2, 1, 1]) { $0.repeatedInt64 == [1] } // Accepts packed coding + assertDecodeFails([ + 128, 2, 255, 255, 153, 166, 234, 175, 227, 1, 128, 2, 185, 156, 196, 237, 158, 222, 230, 255, 255, + ]) assertDecodeFails([128, 2, 1, 128, 2]) assertDecodeFails([128, 2, 128]) assertDecodeFails([128, 2]) @@ -824,19 +901,26 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedUint32() { - assertEncode([138, 2, 6, 255, 255, 255, 255, 15, 0]) {(o: inout MessageTestType) in o.repeatedUint32 = [UInt32.max, UInt32.min]} - assertDecodeSucceeds([136, 2, 210, 9, 136, 2, 213, 27]) {(o:MessageTestType) in - o.repeatedUint32 == [1234, 3541]} - assertDecodeSucceeds([136, 2, 255, 255, 255, 255, 15, 136, 2, 213, 27]) {(o:MessageTestType) in - o.repeatedUint32 == [4294967295, 3541]} - assertDecodeSucceeds([138, 2, 2, 1, 2]) {(o:MessageTestType) in - o.repeatedUint32 == [1, 2]} + assertEncode([138, 2, 6, 255, 255, 255, 255, 15, 0]) { (o: inout MessageTestType) in + o.repeatedUint32 = [UInt32.max, UInt32.min] + } + assertDecodeSucceeds([136, 2, 210, 9, 136, 2, 213, 27]) { (o: MessageTestType) in + o.repeatedUint32 == [1234, 3541] + } + assertDecodeSucceeds([136, 2, 255, 255, 255, 255, 15, 136, 2, 213, 27]) { (o: MessageTestType) in + o.repeatedUint32 == [4_294_967_295, 3541] + } + assertDecodeSucceeds([138, 2, 2, 1, 2]) { (o: MessageTestType) in + o.repeatedUint32 == [1, 2] + } // Truncate on 32-bit overflow - assertDecodeSucceeds([136, 2, 255, 255, 255, 255, 31]) {(o:MessageTestType) in - o.repeatedUint32 == [4294967295]} - assertDecodeSucceeds([136, 2, 255, 255, 255, 255, 255, 255, 255, 1]) {(o:MessageTestType) in - o.repeatedUint32 == [4294967295]} + assertDecodeSucceeds([136, 2, 255, 255, 255, 255, 31]) { (o: MessageTestType) in + o.repeatedUint32 == [4_294_967_295] + } + assertDecodeSucceeds([136, 2, 255, 255, 255, 255, 255, 255, 255, 1]) { (o: MessageTestType) in + o.repeatedUint32 == [4_294_967_295] + } assertDecodeFails([136, 2]) assertDecodeFails([136, 2, 210]) @@ -850,9 +934,11 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedUint64() { - assertEncode([146, 2, 11, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1, 0]) {(o: inout MessageTestType) in o.repeatedUint64 = [UInt64.max, UInt64.min]} - assertDecodeSucceeds([144, 2, 149, 8]) {$0.repeatedUint64 == [1045 ]} - assertDecodeSucceeds([146, 2, 2, 0, 1]) {$0.repeatedUint64 == [0, 1]} + assertEncode([146, 2, 11, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1, 0]) { (o: inout MessageTestType) in + o.repeatedUint64 = [UInt64.max, UInt64.min] + } + assertDecodeSucceeds([144, 2, 149, 8]) { $0.repeatedUint64 == [1045] } + assertDecodeSucceeds([146, 2, 2, 0, 1]) { $0.repeatedUint64 == [0, 1] } assertDecodeFails([144]) assertDecodeFails([144, 2]) assertDecodeFails([144, 2, 149]) @@ -872,13 +958,18 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedSint32() { - assertEncode([154, 2, 10, 254, 255, 255, 255, 15, 255, 255, 255, 255, 15]) {(o: inout MessageTestType) in o.repeatedSint32 = [Int32.max, Int32.min]} - assertDecodeSucceeds([152, 2, 170, 180, 222, 117, 152, 2, 225, 162, 243, 173, 1]) {$0.repeatedSint32 == [123456789, -182347953]} - assertDecodeSucceeds([154, 2, 1, 0]) {$0.repeatedSint32 == [0]} - assertDecodeSucceeds([154, 2, 1, 1, 152, 2, 2]) {$0.repeatedSint32 == [-1, 1]} + assertEncode([154, 2, 10, 254, 255, 255, 255, 15, 255, 255, 255, 255, 15]) { (o: inout MessageTestType) in + o.repeatedSint32 = [Int32.max, Int32.min] + } + assertDecodeSucceeds([152, 2, 170, 180, 222, 117, 152, 2, 225, 162, 243, 173, 1]) { + $0.repeatedSint32 == [123_456_789, -182_347_953] + } + assertDecodeSucceeds([154, 2, 1, 0]) { $0.repeatedSint32 == [0] } + assertDecodeSucceeds([154, 2, 1, 1, 152, 2, 2]) { $0.repeatedSint32 == [-1, 1] } // 32-bit overflow truncates - assertDecodeSucceeds([152, 2, 170, 180, 222, 117, 152, 2, 225, 162, 243, 173, 255, 255, 1]) {$0.repeatedSint32 == [123456789, -2061396145]} - + assertDecodeSucceeds([152, 2, 170, 180, 222, 117, 152, 2, 225, 162, 243, 173, 255, 255, 1]) { + $0.repeatedSint32 == [123_456_789, -2_061_396_145] + } assertDecodeFails([152, 2, 170, 180, 222, 117, 152]) assertDecodeFails([152, 2, 170, 180, 222, 117, 152, 2]) @@ -899,9 +990,13 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedSint64() { - assertEncode([162, 2, 20, 254, 255, 255, 255, 255, 255, 255, 255, 255, 1, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1]) {(o: inout MessageTestType) in o.repeatedSint64 = [Int64.max, Int64.min]} - assertDecodeSucceeds([160, 2, 170, 180, 222, 117, 160, 2, 225, 162, 243, 173, 255, 89]) {$0.repeatedSint64 == [123456789,-1546102139057]} - assertDecodeSucceeds([162, 2, 1, 1]) {$0.repeatedSint64 == [-1]} + assertEncode([ + 162, 2, 20, 254, 255, 255, 255, 255, 255, 255, 255, 255, 1, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1, + ]) { (o: inout MessageTestType) in o.repeatedSint64 = [Int64.max, Int64.min] } + assertDecodeSucceeds([160, 2, 170, 180, 222, 117, 160, 2, 225, 162, 243, 173, 255, 89]) { + $0.repeatedSint64 == [123_456_789, -1_546_102_139_057] + } + assertDecodeSucceeds([162, 2, 1, 1]) { $0.repeatedSint64 == [-1] } assertDecodeFails([160, 2, 170, 180, 222, 117, 160]) assertDecodeFails([160, 2, 170, 180, 222, 117, 160, 2]) assertDecodeFails([160, 2, 170, 180, 222, 117, 160, 2, 225]) @@ -921,9 +1016,15 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedFixed32() { - assertEncode([170, 2, 8, 255, 255, 255, 255, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.repeatedFixed32 = [UInt32.max, UInt32.min]} - assertDecodeSucceeds([173, 2, 255, 255, 255, 127, 173, 2, 127, 127, 127, 127]) {$0.repeatedFixed32 == [2147483647, 2139062143]} - assertDecodeSucceeds([170, 2, 4, 1, 0, 0, 0, 173, 2, 255, 255, 255, 127]) {$0.repeatedFixed32 == [1, 2147483647]} + assertEncode([170, 2, 8, 255, 255, 255, 255, 0, 0, 0, 0]) { (o: inout MessageTestType) in + o.repeatedFixed32 = [UInt32.max, UInt32.min] + } + assertDecodeSucceeds([173, 2, 255, 255, 255, 127, 173, 2, 127, 127, 127, 127]) { + $0.repeatedFixed32 == [2_147_483_647, 2_139_062_143] + } + assertDecodeSucceeds([170, 2, 4, 1, 0, 0, 0, 173, 2, 255, 255, 255, 127]) { + $0.repeatedFixed32 == [1, 2_147_483_647] + } assertDecodeFails([173]) assertDecodeFails([173, 2]) assertDecodeFails([173, 2, 255]) @@ -955,10 +1056,17 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedFixed64() { - assertEncode([178, 2, 16, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.repeatedFixed64 = [UInt64.max, UInt64.min]} - assertDecodeSucceeds([177, 2, 255, 255, 255, 127, 0, 0, 0, 0, 177, 2, 255, 255, 255, 255, 0, 0, 0, 0, 177, 2, 255, 255, 255, 255, 255, 255, 255, 255]) {$0.repeatedFixed64 == [2147483647, 4294967295, 18446744073709551615]} - assertDecodeSucceeds([178, 2, 8, 1, 0, 0, 0, 0, 0, 0, 0]) {$0.repeatedFixed64 == [1]} - assertDecodeSucceeds([177, 2, 2, 0, 0, 0, 0, 0, 0, 0, 178, 2, 8, 1, 0, 0, 0, 0, 0, 0, 0]) {$0.repeatedFixed64 == [2, 1]} + assertEncode([178, 2, 16, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0]) { + (o: inout MessageTestType) in o.repeatedFixed64 = [UInt64.max, UInt64.min] + } + assertDecodeSucceeds([ + 177, 2, 255, 255, 255, 127, 0, 0, 0, 0, 177, 2, 255, 255, 255, 255, 0, 0, 0, 0, 177, 2, 255, 255, 255, 255, + 255, 255, 255, 255, + ]) { $0.repeatedFixed64 == [2_147_483_647, 4_294_967_295, 18_446_744_073_709_551_615] } + assertDecodeSucceeds([178, 2, 8, 1, 0, 0, 0, 0, 0, 0, 0]) { $0.repeatedFixed64 == [1] } + assertDecodeSucceeds([177, 2, 2, 0, 0, 0, 0, 0, 0, 0, 178, 2, 8, 1, 0, 0, 0, 0, 0, 0, 0]) { + $0.repeatedFixed64 == [2, 1] + } assertDecodeFails([177]) assertDecodeFails([177, 2]) assertDecodeFails([177, 2, 255]) @@ -987,9 +1095,11 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedSfixed32() { - assertEncode([186, 2, 8, 255, 255, 255, 127, 0, 0, 0, 128]) {(o: inout MessageTestType) in o.repeatedSfixed32 = [Int32.max, Int32.min]} - assertDecodeSucceeds([189, 2, 0, 0, 0, 0]) {$0.repeatedSfixed32 == [0]} - assertDecodeSucceeds([186, 2, 4, 1, 0, 0, 0, 189, 2, 3, 0, 0, 0]) {$0.repeatedSfixed32 == [1, 3]} + assertEncode([186, 2, 8, 255, 255, 255, 127, 0, 0, 0, 128]) { (o: inout MessageTestType) in + o.repeatedSfixed32 = [Int32.max, Int32.min] + } + assertDecodeSucceeds([189, 2, 0, 0, 0, 0]) { $0.repeatedSfixed32 == [0] } + assertDecodeSucceeds([186, 2, 4, 1, 0, 0, 0, 189, 2, 3, 0, 0, 0]) { $0.repeatedSfixed32 == [1, 3] } assertDecodeFails([189]) assertDecodeFails([189, 2]) assertDecodeFails([189, 2, 0]) @@ -1016,9 +1126,16 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedSfixed64() { - assertEncode([194, 2, 16, 255, 255, 255, 255, 255, 255, 255, 127, 0, 0, 0, 0, 0, 0, 0, 128]) {(o: inout MessageTestType) in o.repeatedSfixed64 = [Int64.max, Int64.min]} - assertDecodeSucceeds([193, 2, 0, 0, 0, 0, 0, 0, 0, 128, 193, 2, 255, 255, 255, 255, 255, 255, 255, 255, 193, 2, 1, 0, 0, 0, 0, 0, 0, 0, 193, 2, 255, 255, 255, 255, 255, 255, 255, 127]) {$0.repeatedSfixed64 == [-9223372036854775808, -1, 1, 9223372036854775807]} - assertDecodeSucceeds([194, 2, 8, 0, 0, 0, 0, 0, 0, 0, 0, 193, 2, 1, 0, 0, 0, 0, 0, 0, 0]) {$0.repeatedSfixed64 == [0, 1]} + assertEncode([194, 2, 16, 255, 255, 255, 255, 255, 255, 255, 127, 0, 0, 0, 0, 0, 0, 0, 128]) { + (o: inout MessageTestType) in o.repeatedSfixed64 = [Int64.max, Int64.min] + } + assertDecodeSucceeds([ + 193, 2, 0, 0, 0, 0, 0, 0, 0, 128, 193, 2, 255, 255, 255, 255, 255, 255, 255, 255, 193, 2, 1, 0, 0, 0, 0, 0, + 0, 0, 193, 2, 255, 255, 255, 255, 255, 255, 255, 127, + ]) { $0.repeatedSfixed64 == [-9_223_372_036_854_775_808, -1, 1, 9_223_372_036_854_775_807] } + assertDecodeSucceeds([194, 2, 8, 0, 0, 0, 0, 0, 0, 0, 0, 193, 2, 1, 0, 0, 0, 0, 0, 0, 0]) { + $0.repeatedSfixed64 == [0, 1] + } assertDecodeFails([193]) assertDecodeFails([193, 2]) assertDecodeFails([193, 2, 0]) @@ -1049,29 +1166,36 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedFloat() { - assertEncode([202, 2, 8, 0, 0, 0, 63, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.repeatedFloat = [0.5, 0.0]} - assertDecodeSucceeds([205, 2, 0, 0, 0, 63, 205, 2, 0, 0, 0, 63]) {$0.repeatedFloat == [0.5, 0.5]} - assertDecodeSucceeds([202, 2, 8, 0, 0, 0, 63, 0, 0, 0, 63]) {$0.repeatedFloat == [0.5, 0.5]} + assertEncode([202, 2, 8, 0, 0, 0, 63, 0, 0, 0, 0]) { (o: inout MessageTestType) in o.repeatedFloat = [0.5, 0.0] + } + assertDecodeSucceeds([205, 2, 0, 0, 0, 63, 205, 2, 0, 0, 0, 63]) { $0.repeatedFloat == [0.5, 0.5] } + assertDecodeSucceeds([202, 2, 8, 0, 0, 0, 63, 0, 0, 0, 63]) { $0.repeatedFloat == [0.5, 0.5] } assertDecodeFails([205, 2, 0, 0, 0, 63, 205, 2, 0, 0, 128]) assertDecodeFails([205, 2, 0, 0, 0, 63, 205, 2]) - assertDecodeFails([200, 2]) // Bad byte sequence - assertDecodeFails([200, 2, 0, 0, 0, 0]) // Bad byte sequence - assertDecodeFails([201, 2]) // Bad byte sequence - assertDecodeFails([201, 2, 0, 0, 0, 0]) // Bad byte sequence - assertDecodeFails([203, 2]) // Bad byte sequence - assertDecodeFails([203, 2, 0, 0, 0, 0]) // Bad byte sequence - assertDecodeFails([204, 2]) // Bad byte sequence - assertDecodeFails([204, 2, 0, 0, 0, 0]) // Bad byte sequence - assertDecodeFails([206, 2]) // Bad byte sequence - assertDecodeFails([206, 2, 0, 0, 0, 0]) // Bad byte sequence - assertDecodeFails([207, 2]) // Bad byte sequence - assertDecodeFails([207, 2, 0, 0, 0, 0]) // Bad byte sequence + assertDecodeFails([200, 2]) // Bad byte sequence + assertDecodeFails([200, 2, 0, 0, 0, 0]) // Bad byte sequence + assertDecodeFails([201, 2]) // Bad byte sequence + assertDecodeFails([201, 2, 0, 0, 0, 0]) // Bad byte sequence + assertDecodeFails([203, 2]) // Bad byte sequence + assertDecodeFails([203, 2, 0, 0, 0, 0]) // Bad byte sequence + assertDecodeFails([204, 2]) // Bad byte sequence + assertDecodeFails([204, 2, 0, 0, 0, 0]) // Bad byte sequence + assertDecodeFails([206, 2]) // Bad byte sequence + assertDecodeFails([206, 2, 0, 0, 0, 0]) // Bad byte sequence + assertDecodeFails([207, 2]) // Bad byte sequence + assertDecodeFails([207, 2, 0, 0, 0, 0]) // Bad byte sequence } func testEncoding_repeatedDouble() { - assertEncode([210, 2, 16, 0, 0, 0, 0, 0, 0, 224, 63, 0, 0, 0, 0, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.repeatedDouble = [0.5, 0.0]} - assertDecodeSucceeds([209, 2, 0, 0, 0, 0, 0, 0, 224, 63, 209, 2, 0, 0, 0, 0, 0, 0, 208, 63]) {$0.repeatedDouble == [0.5, 0.25]} - assertDecodeSucceeds([210, 2, 16, 0, 0, 0, 0, 0, 0, 224, 63, 0, 0, 0, 0, 0, 0, 208, 63]) {$0.repeatedDouble == [0.5, 0.25]} + assertEncode([210, 2, 16, 0, 0, 0, 0, 0, 0, 224, 63, 0, 0, 0, 0, 0, 0, 0, 0]) { (o: inout MessageTestType) in + o.repeatedDouble = [0.5, 0.0] + } + assertDecodeSucceeds([209, 2, 0, 0, 0, 0, 0, 0, 224, 63, 209, 2, 0, 0, 0, 0, 0, 0, 208, 63]) { + $0.repeatedDouble == [0.5, 0.25] + } + assertDecodeSucceeds([210, 2, 16, 0, 0, 0, 0, 0, 0, 224, 63, 0, 0, 0, 0, 0, 0, 208, 63]) { + $0.repeatedDouble == [0.5, 0.25] + } assertDecodeFails([209, 2]) assertDecodeFails([209, 2, 0]) assertDecodeFails([209, 2, 0, 0]) @@ -1098,9 +1222,11 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedBool() { - assertEncode([218, 2, 3, 1, 0, 1]) {(o: inout MessageTestType) in o.repeatedBool = [true, false, true]} - assertDecodeSucceeds([216, 2, 1, 216, 2, 0, 216, 2, 0, 216, 2, 1]) {$0.repeatedBool == [true, false, false, true]} - assertDecodeSucceeds([218, 2, 3, 1, 0, 1, 216, 2, 0]) {$0.repeatedBool == [true, false, true, false]} + assertEncode([218, 2, 3, 1, 0, 1]) { (o: inout MessageTestType) in o.repeatedBool = [true, false, true] } + assertDecodeSucceeds([216, 2, 1, 216, 2, 0, 216, 2, 0, 216, 2, 1]) { + $0.repeatedBool == [true, false, false, true] + } + assertDecodeSucceeds([218, 2, 3, 1, 0, 1, 216, 2, 0]) { $0.repeatedBool == [true, false, true, false] } assertDecodeFails([216]) assertDecodeFails([216, 2]) assertDecodeFails([216, 2, 255]) @@ -1120,13 +1246,15 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedString() { - assertEncode([226, 2, 1, 65, 226, 2, 1, 66]) {(o: inout MessageTestType) in o.repeatedString = ["A", "B"]} - assertDecodeSucceeds([226, 2, 5, 72, 101, 108, 108, 111, 226, 2, 5, 119, 111, 114, 108, 100, 226, 2, 0]) {$0.repeatedString == ["Hello", "world", ""]} + assertEncode([226, 2, 1, 65, 226, 2, 1, 66]) { (o: inout MessageTestType) in o.repeatedString = ["A", "B"] } + assertDecodeSucceeds([226, 2, 5, 72, 101, 108, 108, 111, 226, 2, 5, 119, 111, 114, 108, 100, 226, 2, 0]) { + $0.repeatedString == ["Hello", "world", ""] + } assertDecodeFails([226]) assertDecodeFails([226, 2]) assertDecodeFails([226, 2, 1]) assertDecodeFails([226, 2, 2, 65]) - assertDecodeFails([226, 2, 1, 193]) // Invalid UTF-8 + assertDecodeFails([226, 2, 1, 193]) // Invalid UTF-8 assertDecodeFails([224, 2]) assertDecodesAsUnknownFields([224, 2, 0]) // Wrong wire type (varint), valid as an unknown field assertDecodeFails([225, 2]) @@ -1144,10 +1272,12 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedBytes() { - assertEncode([234, 2, 1, 1, 234, 2, 0, 234, 2, 1, 2]) {(o: inout MessageTestType) in o.repeatedBytes = [Data([1]), Data(), Data([2])]} + assertEncode([234, 2, 1, 1, 234, 2, 0, 234, 2, 1, 2]) { (o: inout MessageTestType) in + o.repeatedBytes = [Data([1]), Data(), Data([2])] + } assertDecodeSucceeds([234, 2, 4, 0, 1, 2, 255, 234, 2, 0]) { let ref: [[UInt8]] = [[0, 1, 2, 255], []] - for (a,b) in zip($0.repeatedBytes, ref) { + for (a, b) in zip($0.repeatedBytes, ref) { if a != Data(b) { return false } } return true @@ -1171,7 +1301,7 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedNestedMessage() { - assertEncode([130, 3, 2, 8, 1, 130, 3, 2, 8, 2]) {(o: inout MessageTestType) in + assertEncode([130, 3, 2, 8, 1, 130, 3, 2, 8, 2]) { (o: inout MessageTestType) in var m1 = MessageTestType.NestedMessage() m1.bb = 1 var m2 = MessageTestType.NestedMessage() @@ -1180,7 +1310,9 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } assertDecodeFails([128, 3]) assertDecodesAsUnknownFields([128, 3, 0]) // Wrong wire type (varint), valid as an unknown field - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\nrepeated_nested_message {\n bb: 1\n}\nrepeated_nested_message {\n bb: 2\n}\n") {(o: inout MessageTestType) in + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\nrepeated_nested_message {\n bb: 1\n}\nrepeated_nested_message {\n bb: 2\n}\n" + ) { (o: inout MessageTestType) in var m1 = MessageTestType.NestedMessage() m1.bb = 1 var m2 = MessageTestType.NestedMessage() @@ -1190,25 +1322,27 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedNestedEnum() { - assertEncode([154, 3, 2, 2, 3]) {(o: inout MessageTestType) in + assertEncode([154, 3, 2, 2, 3]) { (o: inout MessageTestType) in o.repeatedNestedEnum = [.bar, .baz] } - assertDebugDescription("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\nrepeated_nested_enum: [BAR, BAZ]\n") {(o: inout MessageTestType) in + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\nrepeated_nested_enum: [BAR, BAZ]\n" + ) { (o: inout MessageTestType) in o.repeatedNestedEnum = [.bar, .baz] } } func testEncoding_oneofUint32() { - assertEncode([248, 6, 0]) {(o: inout MessageTestType) in o.oneofUint32 = 0} - assertDecodeSucceeds([248, 6, 255, 255, 255, 255, 15]) {$0.oneofUint32 == UInt32.max} - assertDecodeSucceeds([138, 7, 1, 97, 248, 6, 1]) {(o: MessageTestType) in + assertEncode([248, 6, 0]) { (o: inout MessageTestType) in o.oneofUint32 = 0 } + assertDecodeSucceeds([248, 6, 255, 255, 255, 255, 15]) { $0.oneofUint32 == UInt32.max } + assertDecodeSucceeds([138, 7, 1, 97, 248, 6, 1]) { (o: MessageTestType) in if case .oneofUint32? = o.oneofField, o.oneofUint32 == UInt32(1) { - return true + return true } return false } - assertDecodeFails([248, 6, 128]) // Bad varint + assertDecodeFails([248, 6, 128]) // Bad varint // Bad wire types: assertDecodeFails([249, 6]) assertDecodeFails([249, 6, 0]) @@ -1229,24 +1363,24 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { var m = MessageTestType() m.oneofUint32 = 77 - XCTAssertEqual(m.debugDescription, "SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noneof_uint32: 77\n") + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noneof_uint32: 77\n", m) var m2 = MessageTestType() m2.oneofUint32 = 78 XCTAssertNotEqual(m.hashValue, m2.hashValue) } func testEncoding_oneofNestedMessage() { - assertEncode([130, 7, 2, 8, 1]) {(o: inout MessageTestType) in + assertEncode([130, 7, 2, 8, 1]) { (o: inout MessageTestType) in o.oneofNestedMessage = MessageTestType.NestedMessage() o.oneofNestedMessage.bb = 1 } - assertDecodeSucceeds([130, 7, 0]) {(o: MessageTestType) in + assertDecodeSucceeds([130, 7, 0]) { (o: MessageTestType) in if case .oneofNestedMessage(let m)? = o.oneofField { return m.bb == 0 } return false } - assertDecodeSucceeds([248, 6, 0, 130, 7, 2, 8, 1]) {(o: MessageTestType) in + assertDecodeSucceeds([248, 6, 0, 130, 7, 2, 8, 1]) { (o: MessageTestType) in if case .oneofUint32? = o.oneofField { return false } @@ -1257,14 +1391,14 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } } func testEncoding_oneofNestedMessage1() { - assertDecodeSucceeds([130, 7, 2, 8, 1, 248, 6, 0]) {(o: MessageTestType) in + assertDecodeSucceeds([130, 7, 2, 8, 1, 248, 6, 0]) { (o: MessageTestType) in if case .oneofUint32? = o.oneofField, o.oneofUint32 == UInt32(0) { return true } return false } // Unkonwn field within nested message should not break decoding - assertDecodeSucceeds([130, 7, 5, 128, 127, 0, 8, 1, 248, 6, 0]) {(o: MessageTestType) in + assertDecodeSucceeds([130, 7, 5, 128, 127, 0, 8, 1, 248, 6, 0]) { (o: MessageTestType) in if case .oneofUint32? = o.oneofField, o.oneofUint32 == 0 { return true } @@ -1276,7 +1410,10 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { var m = MessageTestType() m.oneofNestedMessage = MessageTestType.NestedMessage() m.oneofNestedMessage.bb = 1 - XCTAssertEqual(m.debugDescription, "SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noneof_nested_message {\n bb: 1\n}\n") + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noneof_nested_message {\n bb: 1\n}\n", + m + ) var m2 = MessageTestType() m2.oneofNestedMessage = MessageTestType.NestedMessage() m2.oneofNestedMessage.bb = 2 @@ -1285,7 +1422,7 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { func testEncoding_oneofNestedMessage9() { assertDecodeFails([128, 7]) - assertDecodesAsUnknownFields([128, 7, 0]) { // Wrong wire type (varint), valid as an unknown field + assertDecodesAsUnknownFields([128, 7, 0]) { // Wrong wire type (varint), valid as an unknown field $0.oneofField == nil // oneof doesn't get set. } assertDecodeFails([129, 7]) @@ -1303,17 +1440,17 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } func testEncoding_oneofString() { - assertEncode([138, 7, 1, 97]) {(o: inout MessageTestType) in o.oneofString = "a"} - assertDecodeSucceeds([138, 7, 1, 97]) {$0.oneofString == "a"} - assertDecodeSucceeds([138, 7, 0]) {$0.oneofString == ""} - assertDecodeSucceeds([146, 7, 0, 138, 7, 1, 97]) {(o:MessageTestType) in + assertEncode([138, 7, 1, 97]) { (o: inout MessageTestType) in o.oneofString = "a" } + assertDecodeSucceeds([138, 7, 1, 97]) { $0.oneofString == "a" } + assertDecodeSucceeds([138, 7, 0]) { $0.oneofString == "" } + assertDecodeSucceeds([146, 7, 0, 138, 7, 1, 97]) { (o: MessageTestType) in if case .oneofString? = o.oneofField, o.oneofString == "a" { - return true + return true } return false } - assertDecodeFails([138, 7, 1]) // Truncated body - assertDecodeFails([138, 7, 1, 192]) // Malformed UTF-8 + assertDecodeFails([138, 7, 1]) // Truncated body + assertDecodeFails([138, 7, 1, 192]) // Malformed UTF-8 // Bad wire types: assertDecodesAsUnknownFields([136, 7, 0]) { // Wrong wire type (varint), valid as an unknown field $0.oneofField == nil // oneof doesn't get set. @@ -1321,33 +1458,36 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { assertDecodesAsUnknownFields([136, 7, 1]) { // Wrong wire type (varint), valid as an unknown field $0.oneofField == nil // oneof doesn't get set. } - assertDecodesAsUnknownFields([137, 7, 1, 1, 1, 1, 1, 1, 1, 1]) { // Wrong wire type (fixed64), valid as an unknown field + assertDecodesAsUnknownFields([ + 137, 7, // Wrong wire type (fixed64), valid as an unknown field + 1, 1, 1, 1, 1, 1, 1, 1, + ]) { $0.oneofField == nil // oneof doesn't get set. } - assertDecodeFails([139, 7]) // Wire type 3 - assertDecodeFails([140, 7]) // Wire type 4 + assertDecodeFails([139, 7]) // Wire type 3 + assertDecodeFails([140, 7]) // Wire type 4 assertDecodeFails([141, 7, 0]) // Wire type 5 assertDecodesAsUnknownFields([141, 7, 0, 0, 0, 0]) { // Wrong wire type (fixed32), valid as an unknown field $0.oneofField == nil // oneof doesn't get set. } - assertDecodeFails([142, 7]) // Wire type 6 - assertDecodeFails([142, 7, 0]) // Wire type 6 - assertDecodeFails([143, 7]) // Wire type 7 - assertDecodeFails([143, 7, 0]) // Wire type 7 + assertDecodeFails([142, 7]) // Wire type 6 + assertDecodeFails([142, 7, 0]) // Wire type 6 + assertDecodeFails([143, 7]) // Wire type 7 + assertDecodeFails([143, 7, 0]) // Wire type 7 var m = MessageTestType() m.oneofString = "abc" - XCTAssertEqual(m.debugDescription, "SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noneof_string: \"abc\"\n") + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noneof_string: \"abc\"\n", m) var m2 = MessageTestType() m2.oneofString = "def" XCTAssertNotEqual(m.hashValue, m2.hashValue) } func testEncoding_oneofBytes() { - assertEncode([146, 7, 1, 1]) {(o: inout MessageTestType) in o.oneofBytes = Data([1])} + assertEncode([146, 7, 1, 1]) { (o: inout MessageTestType) in o.oneofBytes = Data([1]) } } func testEncoding_oneofBytes2() { - assertDecodeSucceeds([146, 7, 1, 1]) {(o: MessageTestType) in + assertDecodeSucceeds([146, 7, 1, 1]) { (o: MessageTestType) in let expectedB = Data([1]) if case .oneofBytes(let b)? = o.oneofField { let s = o.oneofString @@ -1357,7 +1497,7 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } } func testEncoding_oneofBytes3() { - assertDecodeSucceeds([146, 7, 0]) {(o: MessageTestType) in + assertDecodeSucceeds([146, 7, 0]) { (o: MessageTestType) in let expectedB = Data() if case .oneofBytes(let b)? = o.oneofField { let s = o.oneofString @@ -1367,7 +1507,7 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { } } func testEncoding_oneofBytes4() { - assertDecodeSucceeds([138, 7, 1, 97, 146, 7, 0]) {(o: MessageTestType) in + assertDecodeSucceeds([138, 7, 1, 97, 146, 7, 0]) { (o: MessageTestType) in let expectedB = Data() if case .oneofBytes(let b)? = o.oneofField { let s = o.oneofString @@ -1407,7 +1547,10 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { var m = MessageTestType() m.oneofBytes = Data([1, 2, 3]) - XCTAssertEqual(m.debugDescription, "SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noneof_bytes: \"\\001\\002\\003\"\n") + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noneof_bytes: \"\\001\\002\\003\"\n", + m + ) var m2 = MessageTestType() m2.oneofBytes = Data([4, 5, 6]) XCTAssertNotEqual(m.hashValue, m2.hashValue) @@ -1415,35 +1558,39 @@ class Test_AllTypes_Proto3: XCTestCase, PBTestHelpers { func testDebugDescription() { var m = MessageTestType() - let d = m.debugDescription - XCTAssertEqual("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\n", d) + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\n", m) m.optionalInt32 = 7 - XCTAssertEqual("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_int32: 7\n", m.debugDescription) + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_int32: 7\n", m) m.repeatedString = ["a", "b"] - XCTAssertEqual("SwiftProtobufTests.Proto3Unittest_TestAllTypes:\noptional_int32: 7\nrepeated_string: \"a\"\nrepeated_string: \"b\"\n", m.debugDescription) + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_Proto3_TestAllTypes:\noptional_int32: 7\nrepeated_string: \"a\"\nrepeated_string: \"b\"\n", + m + ) } func testDebugDescription2() { // Message with only one field - var m = ProtobufUnittest_ForeignMessage() - XCTAssertEqual("SwiftProtobufTests.ProtobufUnittest_ForeignMessage:\n", m.debugDescription) + var m = SwiftProtoTesting_ForeignMessage() + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_ForeignMessage:\n", m) m.c = 3 - XCTAssertEqual("SwiftProtobufTests.ProtobufUnittest_ForeignMessage:\nc: 3\n", m.debugDescription) + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_ForeignMessage:\nc: 3\n", m) } func testDebugDescription3() { // Message with only a optional oneof - var m = ProtobufUnittest_TestOneof() - XCTAssertEqual("SwiftProtobufTests.ProtobufUnittest_TestOneof:\n", m.debugDescription) + var m = SwiftProtoTesting_TestOneof() + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestOneof:\n", m) m.fooInt = 1 - XCTAssertEqual("SwiftProtobufTests.ProtobufUnittest_TestOneof:\nfoo_int: 1\n", m.debugDescription) + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestOneof:\nfoo_int: 1\n", m) m.fooString = "a" - XCTAssertEqual("SwiftProtobufTests.ProtobufUnittest_TestOneof:\nfoo_string: \"a\"\n", m.debugDescription) - var g = ProtobufUnittest_TestOneof.FooGroup() + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestOneof:\nfoo_string: \"a\"\n", m) + var g = SwiftProtoTesting_TestOneof.FooGroup() g.a = 7 g.b = "b" m.fooGroup = g - XCTAssertEqual("SwiftProtobufTests.ProtobufUnittest_TestOneof:\nFooGroup {\n a: 7\n b: \"b\"\n}\n", m.debugDescription) + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestOneof:\nFooGroup {\n a: 7\n b: \"b\"\n}\n", + m + ) } } - diff --git a/Tests/SwiftProtobufTests/Test_AllTypes_Proto3_Optional.swift b/Tests/SwiftProtobufTests/Test_AllTypes_Proto3_Optional.swift index 4aeba387b..36ed3eef8 100644 --- a/Tests/SwiftProtobufTests/Test_AllTypes_Proto3_Optional.swift +++ b/Tests/SwiftProtobufTests/Test_AllTypes_Proto3_Optional.swift @@ -18,18 +18,23 @@ import Foundation import XCTest -class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { - typealias MessageTestType = ProtobufUnittest_TestProto3Optional +final class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_TestProto3Optional // Custom decodeSucceeds that also does a round-trip through the Empty // message to make sure unknown fields are consistently preserved by proto2. - func assertDecodeSucceeds(_ bytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line, check: (MessageTestType) -> Bool) { + func assertDecodeSucceeds( + _ bytes: [UInt8], + file: XCTestFileArgType = #file, + line: UInt = #line, + check: (MessageTestType) -> Bool + ) { baseAssertDecodeSucceeds(bytes, file: file, line: line, check: check) do { // Make sure unknown fields are preserved by empty message decode/encode - let empty = try ProtobufUnittest_TestEmptyMessage(serializedBytes: bytes) + let empty = try SwiftProtoTesting_TestEmptyMessage(serializedBytes: bytes) do { - let newBytes = try empty.serializedBytes() + let newBytes: [UInt8] = try empty.serializedBytes() XCTAssertEqual(bytes, newBytes, "Empty decode/recode did not match", file: file, line: line) } catch let e { XCTFail("Reserializing empty threw an error: \(e)", file: file, line: line) @@ -39,23 +44,19 @@ class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { } } - func assertDebugDescription(_ expected: String, file: XCTestFileArgType = #file, line: UInt = #line, configure: (inout MessageTestType) -> ()) { - var m = MessageTestType() - configure(&m) - let actual = m.debugDescription - XCTAssertEqual(actual, expected, file: file, line: line) - } - // // Optional Singular types // // Setting the values to zero values to ensure when encoded the values are captured. func testEncoding_optionalInt32() { - assertEncode([8, 0]) {(o: inout MessageTestType) in o.optionalInt32 = 0} - assertDecodeSucceeds([8, 0]) {$0.hasOptionalInt32 && $0.optionalInt32 == 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\noptional_int32: 0\n") {(o: inout MessageTestType) in o.optionalInt32 = 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") {(o: inout MessageTestType) in + assertEncode([8, 0]) { (o: inout MessageTestType) in o.optionalInt32 = 0 } + assertDecodeSucceeds([8, 0]) { $0.hasOptionalInt32 && $0.optionalInt32 == 0 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\noptional_int32: 0\n") { + (o: inout MessageTestType) in o.optionalInt32 = 0 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\n") { + (o: inout MessageTestType) in o.optionalInt32 = 0 o.clearOptionalInt32() } @@ -74,12 +75,15 @@ class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { } func testEncoding_optionalInt64() { - assertEncode([16, 0]) {(o: inout MessageTestType) in o.optionalInt64 = 0} - assertDecodeSucceeds([16, 0]) {$0.hasOptionalInt64 && $0.optionalInt64 == 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\noptional_int64: 0\n") {(o: inout MessageTestType) in o.optionalInt64 = 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") {(o: inout MessageTestType) in - o.optionalInt64 = 0 - o.clearOptionalInt64() + assertEncode([16, 0]) { (o: inout MessageTestType) in o.optionalInt64 = 0 } + assertDecodeSucceeds([16, 0]) { $0.hasOptionalInt64 && $0.optionalInt64 == 0 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\noptional_int64: 0\n") { + (o: inout MessageTestType) in o.optionalInt64 = 0 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\n") { + (o: inout MessageTestType) in + o.optionalInt64 = 0 + o.clearOptionalInt64() } let empty = MessageTestType() @@ -109,12 +113,15 @@ class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { } func testEncoding_optionalUint32() { - assertEncode([24, 0]) {(o: inout MessageTestType) in o.optionalUint32 = 0} - assertDecodeSucceeds([24, 0]) {$0.hasOptionalUint32 && $0.optionalUint32 == 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\noptional_uint32: 0\n") {(o: inout MessageTestType) in o.optionalUint32 = 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") {(o: inout MessageTestType) in - o.optionalUint32 = 0 - o.clearOptionalUint32() + assertEncode([24, 0]) { (o: inout MessageTestType) in o.optionalUint32 = 0 } + assertDecodeSucceeds([24, 0]) { $0.hasOptionalUint32 && $0.optionalUint32 == 0 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\noptional_uint32: 0\n") { + (o: inout MessageTestType) in o.optionalUint32 = 0 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\n") { + (o: inout MessageTestType) in + o.optionalUint32 = 0 + o.clearOptionalUint32() } let empty = MessageTestType() @@ -144,12 +151,15 @@ class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { } func testEncoding_optionalUint64() { - assertEncode([32, 0]) {(o: inout MessageTestType) in o.optionalUint64 = 0} - assertDecodeSucceeds([32, 0]) {$0.hasOptionalUint64 && $0.optionalUint64 == 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\noptional_uint64: 0\n") {(o: inout MessageTestType) in o.optionalUint64 = 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") {(o: inout MessageTestType) in - o.optionalUint64 = 0 - o.clearOptionalUint64() + assertEncode([32, 0]) { (o: inout MessageTestType) in o.optionalUint64 = 0 } + assertDecodeSucceeds([32, 0]) { $0.hasOptionalUint64 && $0.optionalUint64 == 0 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\noptional_uint64: 0\n") { + (o: inout MessageTestType) in o.optionalUint64 = 0 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\n") { + (o: inout MessageTestType) in + o.optionalUint64 = 0 + o.clearOptionalUint64() } let empty = MessageTestType() @@ -179,12 +189,15 @@ class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { } func testEncoding_optionalSint32() { - assertEncode([40, 0]) {(o: inout MessageTestType) in o.optionalSint32 = 0} - assertDecodeSucceeds([40, 0]) {$0.hasOptionalSint32 && $0.optionalSint32 == 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\noptional_sint32: 0\n") {(o: inout MessageTestType) in o.optionalSint32 = 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") {(o: inout MessageTestType) in - o.optionalSint32 = 0 - o.clearOptionalSint32() + assertEncode([40, 0]) { (o: inout MessageTestType) in o.optionalSint32 = 0 } + assertDecodeSucceeds([40, 0]) { $0.hasOptionalSint32 && $0.optionalSint32 == 0 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\noptional_sint32: 0\n") { + (o: inout MessageTestType) in o.optionalSint32 = 0 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\n") { + (o: inout MessageTestType) in + o.optionalSint32 = 0 + o.clearOptionalSint32() } let empty = MessageTestType() @@ -214,12 +227,15 @@ class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { } func testEncoding_optionalSint64() { - assertEncode([48, 0]) {(o: inout MessageTestType) in o.optionalSint64 = 0} - assertDecodeSucceeds([48, 0]) {$0.hasOptionalSint64 && $0.optionalSint64 == 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\noptional_sint64: 0\n") {(o: inout MessageTestType) in o.optionalSint64 = 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") {(o: inout MessageTestType) in - o.optionalSint64 = 0 - o.clearOptionalSint64() + assertEncode([48, 0]) { (o: inout MessageTestType) in o.optionalSint64 = 0 } + assertDecodeSucceeds([48, 0]) { $0.hasOptionalSint64 && $0.optionalSint64 == 0 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\noptional_sint64: 0\n") { + (o: inout MessageTestType) in o.optionalSint64 = 0 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\n") { + (o: inout MessageTestType) in + o.optionalSint64 = 0 + o.clearOptionalSint64() } let empty = MessageTestType() @@ -249,12 +265,15 @@ class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { } func testEncoding_optionalFixed32() { - assertEncode([61, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.optionalFixed32 = 0} - assertDecodeSucceeds([61, 0, 0, 0, 0]) {$0.hasOptionalFixed32 && $0.optionalFixed32 == 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\noptional_fixed32: 0\n") {(o: inout MessageTestType) in o.optionalFixed32 = 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") {(o: inout MessageTestType) in - o.optionalFixed32 = 0 - o.clearOptionalFixed32() + assertEncode([61, 0, 0, 0, 0]) { (o: inout MessageTestType) in o.optionalFixed32 = 0 } + assertDecodeSucceeds([61, 0, 0, 0, 0]) { $0.hasOptionalFixed32 && $0.optionalFixed32 == 0 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\noptional_fixed32: 0\n") { + (o: inout MessageTestType) in o.optionalFixed32 = 0 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\n") { + (o: inout MessageTestType) in + o.optionalFixed32 = 0 + o.clearOptionalFixed32() } let empty = MessageTestType() @@ -284,12 +303,15 @@ class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { } func testEncoding_optionalFixed64() { - assertEncode([65, 0, 0, 0, 0, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.optionalFixed64 = UInt64.min} - assertDecodeSucceeds([65, 0, 0, 0, 0, 0, 0, 0, 0]) {$0.hasOptionalFixed64 && $0.optionalFixed64 == 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\noptional_fixed64: 0\n") {(o: inout MessageTestType) in o.optionalFixed64 = 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") {(o: inout MessageTestType) in - o.optionalFixed64 = 0 - o.clearOptionalFixed64() + assertEncode([65, 0, 0, 0, 0, 0, 0, 0, 0]) { (o: inout MessageTestType) in o.optionalFixed64 = UInt64.min } + assertDecodeSucceeds([65, 0, 0, 0, 0, 0, 0, 0, 0]) { $0.hasOptionalFixed64 && $0.optionalFixed64 == 0 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\noptional_fixed64: 0\n") { + (o: inout MessageTestType) in o.optionalFixed64 = 0 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\n") { + (o: inout MessageTestType) in + o.optionalFixed64 = 0 + o.clearOptionalFixed64() } let empty = MessageTestType() @@ -319,12 +341,15 @@ class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { } func testEncoding_optionalSfixed32() { - assertEncode([77, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.optionalSfixed32 = 0} - assertDecodeSucceeds([77, 0, 0, 0, 0]) {$0.hasOptionalSfixed32 && $0.optionalSfixed32 == 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\noptional_sfixed32: 0\n") {(o: inout MessageTestType) in o.optionalSfixed32 = 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") {(o: inout MessageTestType) in - o.optionalSfixed32 = 0 - o.clearOptionalSfixed32() + assertEncode([77, 0, 0, 0, 0]) { (o: inout MessageTestType) in o.optionalSfixed32 = 0 } + assertDecodeSucceeds([77, 0, 0, 0, 0]) { $0.hasOptionalSfixed32 && $0.optionalSfixed32 == 0 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\noptional_sfixed32: 0\n") { + (o: inout MessageTestType) in o.optionalSfixed32 = 0 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\n") { + (o: inout MessageTestType) in + o.optionalSfixed32 = 0 + o.clearOptionalSfixed32() } let empty = MessageTestType() @@ -354,12 +379,15 @@ class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { } func testEncoding_optionalSfixed64() { - assertEncode([81, 0, 0, 0, 0, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.optionalSfixed64 = 0} - assertDecodeSucceeds([81, 0, 0, 0, 0, 0, 0, 0, 0]) {$0.hasOptionalSfixed64 && $0.optionalSfixed64 == 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\noptional_sfixed64: 0\n") {(o: inout MessageTestType) in o.optionalSfixed64 = 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") {(o: inout MessageTestType) in - o.optionalSfixed64 = 0 - o.clearOptionalSfixed64() + assertEncode([81, 0, 0, 0, 0, 0, 0, 0, 0]) { (o: inout MessageTestType) in o.optionalSfixed64 = 0 } + assertDecodeSucceeds([81, 0, 0, 0, 0, 0, 0, 0, 0]) { $0.hasOptionalSfixed64 && $0.optionalSfixed64 == 0 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\noptional_sfixed64: 0\n") { + (o: inout MessageTestType) in o.optionalSfixed64 = 0 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\n") { + (o: inout MessageTestType) in + o.optionalSfixed64 = 0 + o.clearOptionalSfixed64() } let empty = MessageTestType() @@ -389,13 +417,15 @@ class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { } func testEncoding_optionalFloat() { - assertEncode([93, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.optionalFloat = 0.0} - assertDecodeSucceeds([93, 0, 0, 0, 0]) {$0.hasOptionalFloat && $0.optionalFloat == 0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\noptional_float: 0.0\n") { - (o: inout MessageTestType) in o.optionalFloat = 0.0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") { (o: inout MessageTestType) in - o.optionalFloat = 1.0 - o.clearOptionalFloat() + assertEncode([93, 0, 0, 0, 0]) { (o: inout MessageTestType) in o.optionalFloat = 0.0 } + assertDecodeSucceeds([93, 0, 0, 0, 0]) { $0.hasOptionalFloat && $0.optionalFloat == 0 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\noptional_float: 0.0\n") { + (o: inout MessageTestType) in o.optionalFloat = 0.0 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\n") { + (o: inout MessageTestType) in + o.optionalFloat = 1.0 + o.clearOptionalFloat() } let empty = MessageTestType() @@ -425,14 +455,15 @@ class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { } func testEncoding_optionalDouble() { - assertEncode([97, 0, 0, 0, 0, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.optionalDouble = 0.0} - assertDecodeSucceeds([97, 0, 0, 0, 0, 0, 0, 0, 0]) {$0.hasOptionalDouble && $0.optionalDouble == 0.0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\noptional_double: 0.0\n") { - (o: inout MessageTestType) in o.optionalDouble = 0.0} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") { + assertEncode([97, 0, 0, 0, 0, 0, 0, 0, 0]) { (o: inout MessageTestType) in o.optionalDouble = 0.0 } + assertDecodeSucceeds([97, 0, 0, 0, 0, 0, 0, 0, 0]) { $0.hasOptionalDouble && $0.optionalDouble == 0.0 } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\noptional_double: 0.0\n") { + (o: inout MessageTestType) in o.optionalDouble = 0.0 + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\n") { (o: inout MessageTestType) in - o.optionalDouble = 0.0 - o.clearOptionalDouble() + o.optionalDouble = 0.0 + o.clearOptionalDouble() } let empty = MessageTestType() @@ -462,12 +493,15 @@ class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { } func testEncoding_optionalBool() { - assertEncode([104, 0]) {(o: inout MessageTestType) in o.optionalBool = false} + assertEncode([104, 0]) { (o: inout MessageTestType) in o.optionalBool = false } assertDecodeSucceeds([104, 0]) { $0.hasOptionalBool && $0.optionalBool == false } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\noptional_bool: false\n") {(o: inout MessageTestType) in o.optionalBool = false} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") {(o: inout MessageTestType) in - o.optionalBool = false - o.clearOptionalBool() + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\noptional_bool: false\n") { + (o: inout MessageTestType) in o.optionalBool = false + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\n") { + (o: inout MessageTestType) in + o.optionalBool = false + o.clearOptionalBool() } let empty = MessageTestType() @@ -497,12 +531,15 @@ class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { } func testEncoding_optionalString() { - assertEncode([114, 0]) {(o: inout MessageTestType) in o.optionalString = ""} + assertEncode([114, 0]) { (o: inout MessageTestType) in o.optionalString = "" } assertDecodeSucceeds([114, 0]) { $0.hasOptionalString && $0.optionalString == "" } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\noptional_string: \"\"\n") {(o: inout MessageTestType) in o.optionalString = ""} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") {(o: inout MessageTestType) in - o.optionalString = "" - o.clearOptionalString() + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\noptional_string: \"\"\n") { + (o: inout MessageTestType) in o.optionalString = "" + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\n") { + (o: inout MessageTestType) in + o.optionalString = "" + o.clearOptionalString() } let empty = MessageTestType() @@ -532,12 +569,15 @@ class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { } func testEncoding_optionalBytes() { - assertEncode([122, 0]) {(o: inout MessageTestType) in o.optionalBytes = Data()} + assertEncode([122, 0]) { (o: inout MessageTestType) in o.optionalBytes = Data() } assertDecodeSucceeds([122, 0]) { $0.hasOptionalBytes && $0.optionalBytes == Data() } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\noptional_bytes: \"\"\n") {(o: inout MessageTestType) in o.optionalBytes = Data()} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") {(o: inout MessageTestType) in - o.optionalBytes = Data() - o.clearOptionalBytes() + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\noptional_bytes: \"\"\n") { + (o: inout MessageTestType) in o.optionalBytes = Data() + } + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\n") { + (o: inout MessageTestType) in + o.optionalBytes = Data() + o.clearOptionalBytes() } let empty = MessageTestType() @@ -566,52 +606,20 @@ class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { XCTAssertFalse(d.hasOptionalBytes) } - func testEncoding_optionalCord() { - // The `ctype = CORD` option has no meaning in SwiftProtobuf, - // but test is for completeness. - assertEncode([130, 1, 0]) {(o: inout MessageTestType) in o.optionalCord = ""} - assertDecodeSucceeds([130, 1, 0]) { $0.hasOptionalCord && $0.optionalCord == "" } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\noptional_cord: \"\"\n") {(o: inout MessageTestType) in o.optionalCord = ""} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") {(o: inout MessageTestType) in - o.optionalCord = "" - o.clearOptionalCord() - } - - let empty = MessageTestType() - var a = empty - a.optionalCord = "" - XCTAssertNotEqual(a, empty) - var b = empty - b.optionalCord = "a" - XCTAssertNotEqual(a, b) - b.clearOptionalCord() - XCTAssertNotEqual(a, b) - b.optionalCord = "" - XCTAssertEqual(a, b) - - // Ensure storage is uniqued for clear. - let c = MessageTestType.with { - $0.optionalCord = "blah" - } - var d = c - XCTAssertEqual(c, d) - XCTAssertTrue(c.hasOptionalCord) - XCTAssertTrue(d.hasOptionalCord) - d.clearOptionalCord() - XCTAssertNotEqual(c, d) - XCTAssertTrue(c.hasOptionalCord) - XCTAssertFalse(d.hasOptionalCord) - } - func testEncoding_optionalNestedMessage() { - assertEncode([146, 1, 0]) {(o: inout MessageTestType) in + assertEncode([146, 1, 0]) { (o: inout MessageTestType) in o.optionalNestedMessage = MessageTestType.NestedMessage() } - assertDecodeSucceeds([146, 1, 0]) {$0.hasOptionalNestedMessage && $0.optionalNestedMessage == MessageTestType.NestedMessage()} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\noptional_nested_message {\n}\n") {(o: inout MessageTestType) in + assertDecodeSucceeds([146, 1, 0]) { + $0.hasOptionalNestedMessage && $0.optionalNestedMessage == MessageTestType.NestedMessage() + } + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\noptional_nested_message {\n}\n" + ) { (o: inout MessageTestType) in o.optionalNestedMessage = MessageTestType.NestedMessage() } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") {(o: inout MessageTestType) in + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\n") { + (o: inout MessageTestType) in o.optionalNestedMessage = MessageTestType.NestedMessage() o.clearOptionalNestedMessage() } @@ -630,46 +638,20 @@ class Test_AllTypes_Proto3_Optional: XCTestCase, PBTestHelpers { XCTAssertFalse(d.hasOptionalNestedMessage) } - func testEncoding_lazyNestedMessage() { - // The `lazy = true` option has no meaning in SwiftProtobuf, - // but test is for completeness. - assertEncode([154, 1, 0]) {(o: inout MessageTestType) in - o.lazyNestedMessage = MessageTestType.NestedMessage() - } - assertDecodeSucceeds([154, 1, 0]) {$0.hasLazyNestedMessage && $0.lazyNestedMessage == MessageTestType.NestedMessage()} - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\nlazy_nested_message {\n}\n") {(o: inout MessageTestType) in - o.lazyNestedMessage = MessageTestType.NestedMessage() - } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") {(o: inout MessageTestType) in - o.lazyNestedMessage = MessageTestType.NestedMessage() - o.clearLazyNestedMessage() - } - - // Ensure storage is uniqued for clear. - let c = MessageTestType.with { - $0.lazyNestedMessage.bb = 1 - } - var d = c - XCTAssertEqual(c, d) - XCTAssertTrue(c.hasLazyNestedMessage) - XCTAssertTrue(d.hasLazyNestedMessage) - d.clearLazyNestedMessage() - XCTAssertNotEqual(c, d) - XCTAssertTrue(c.hasLazyNestedMessage) - XCTAssertFalse(d.hasLazyNestedMessage) - } - func testEncoding_optionalNestedEnum() throws { - assertEncode([168, 1, 0]) {(o: inout MessageTestType) in + assertEncode([168, 1, 0]) { (o: inout MessageTestType) in o.optionalNestedEnum = .unspecified } assertDecodeSucceeds([168, 1, 0]) { $0.hasOptionalNestedEnum && $0.optionalNestedEnum == .unspecified } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\noptional_nested_enum: UNSPECIFIED\n") {(o: inout MessageTestType) in + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\noptional_nested_enum: UNSPECIFIED\n" + ) { (o: inout MessageTestType) in o.optionalNestedEnum = .unspecified } - assertDebugDescription("SwiftProtobufTests.ProtobufUnittest_TestProto3Optional:\n") {(o: inout MessageTestType) in + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestProto3Optional:\n") { + (o: inout MessageTestType) in o.optionalNestedEnum = .unspecified o.clearOptionalNestedEnum() } diff --git a/Tests/SwiftProtobufTests/Test_Any.swift b/Tests/SwiftProtobufTests/Test_Any.swift index 9d0004638..ba5191cac 100644 --- a/Tests/SwiftProtobufTests/Test_Any.swift +++ b/Tests/SwiftProtobufTests/Test_Any.swift @@ -16,39 +16,46 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_Any: XCTestCase { +final class Test_Any: XCTestCase { func test_Any() throws { - var content = ProtobufUnittest_TestAllTypes() + var content = SwiftProtoTesting_TestAllTypes() content.optionalInt32 = 7 - var m = ProtobufUnittest_TestAny() + var m = SwiftProtoTesting_TestAny() m.int32Value = 12 m.anyValue = try Google_Protobuf_Any(message: content) // The Any holding an object can be JSON serialized XCTAssertNotNil(try m.jsonString()) - let encoded = try m.serializedBytes() - XCTAssertEqual(encoded, [8, 12, 18, 56, 10, 50, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109, 47, 112, 114, 111, 116, 111, 98, 117, 102, 95, 117, 110, 105, 116, 116, 101, 115, 116, 46, 84, 101, 115, 116, 65, 108, 108, 84, 121, 112, 101, 115, 18, 2, 8, 7]) - let decoded = try ProtobufUnittest_TestAny(serializedBytes: encoded) - XCTAssertEqual(decoded.anyValue.typeURL, "type.googleapis.com/protobuf_unittest.TestAllTypes") + let encoded: [UInt8] = try m.serializedBytes() + XCTAssertEqual( + encoded, + [ + 8, 12, 18, 58, 10, 52, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, + 111, 109, 47, 115, 119, 105, 102, 116, 95, 112, 114, 111, 116, 111, 95, 116, 101, 115, 116, 105, 110, + 103, 46, 84, 101, 115, 116, 65, 108, 108, 84, 121, 112, 101, 115, 18, 2, 8, 7, + ] + ) + let decoded = try SwiftProtoTesting_TestAny(serializedBytes: encoded) + XCTAssertEqual(decoded.anyValue.typeURL, "type.googleapis.com/swift_proto_testing.TestAllTypes") XCTAssertEqual(decoded.anyValue.value, Data([8, 7])) XCTAssertEqual(decoded.int32Value, 12) XCTAssertNotNil(decoded.anyValue) let any = decoded.anyValue do { - let extracted = try ProtobufUnittest_TestAllTypes(unpackingAny: any) + let extracted = try SwiftProtoTesting_TestAllTypes(unpackingAny: any) XCTAssertEqual(extracted.optionalInt32, 7) } catch { XCTFail("Failed to unpack \(any)") } - XCTAssertThrowsError(try ProtobufUnittest_TestEmptyMessage(unpackingAny: any)) - let recoded = try decoded.serializedBytes() + XCTAssertThrowsError(try SwiftProtoTesting_TestEmptyMessage(unpackingAny: any)) + let recoded: [UInt8] = try decoded.serializedBytes() XCTAssertEqual(encoded, recoded) } @@ -58,28 +65,31 @@ class Test_Any: XCTestCase { /// /// This test verifies that we can decode an Any with a different prefix func test_Any_different_prefix() throws { - let encoded = Data([8, 12, 18, 40, 10, 34, 88, 47, 89, 47, 112, 114, 111, 116, 111, 98, 117, 102, 95, 117, 110, 105, 116, 116, 101, 115, 116, 46, 84, 101, 115, 116, 65, 108, 108, 84, 121, 112, 101, 115, 18, 2, 8, 7]) - let decoded: ProtobufUnittest_TestAny + let encoded: [UInt8] = [ + 8, 12, 18, 42, 10, 36, 88, 47, 89, 47, 115, 119, 105, 102, 116, 95, 112, 114, 111, 116, 111, 95, 116, 101, + 115, 116, 105, 110, 103, 46, 84, 101, 115, 116, 65, 108, 108, 84, 121, 112, 101, 115, 18, 2, 8, 7, + ] + let decoded: SwiftProtoTesting_TestAny do { - decoded = try ProtobufUnittest_TestAny(serializedData: encoded) + decoded = try SwiftProtoTesting_TestAny(serializedBytes: encoded) } catch { XCTFail("Failed to decode \(encoded): \(error)") return } - XCTAssertEqual(decoded.anyValue.typeURL, "X/Y/protobuf_unittest.TestAllTypes") + XCTAssertEqual(decoded.anyValue.typeURL, "X/Y/swift_proto_testing.TestAllTypes") XCTAssertEqual(decoded.anyValue.value, Data([8, 7])) XCTAssertEqual(decoded.int32Value, 12) XCTAssertNotNil(decoded.anyValue) let any = decoded.anyValue do { - let extracted = try ProtobufUnittest_TestAllTypes(unpackingAny: any) + let extracted = try SwiftProtoTesting_TestAllTypes(unpackingAny: any) XCTAssertEqual(extracted.optionalInt32, 7) } catch { XCTFail("Failed to unpack \(any)") } - XCTAssertThrowsError(try ProtobufUnittest_TestEmptyMessage(unpackingAny: any)) - let recoded = try decoded.serializedData() + XCTAssertThrowsError(try SwiftProtoTesting_TestEmptyMessage(unpackingAny: any)) + let recoded: [UInt8] = try decoded.serializedBytes() XCTAssertEqual(encoded, recoded) } @@ -89,96 +99,112 @@ class Test_Any: XCTestCase { /// /// This test verifies that we can decode an Any with an empty prefix func test_Any_noprefix() throws { - let encoded = Data([8, 12, 18, 37, 10, 31, 47, 112, 114, 111, 116, 111, 98, 117, 102, 95, 117, 110, 105, 116, 116, 101, 115, 116, 46, 84, 101, 115, 116, 65, 108, 108, 84, 121, 112, 101, 115, 18, 2, 8, 7]) - let decoded: ProtobufUnittest_TestAny + let encoded: [UInt8] = [ + 8, 12, 18, 39, 10, 33, 47, 115, 119, 105, 102, 116, 95, 112, 114, 111, 116, 111, 95, 116, 101, 115, 116, + 105, 110, 103, 46, 84, 101, 115, 116, 65, 108, 108, 84, 121, 112, 101, 115, 18, 2, 8, 7, + ] + let decoded: SwiftProtoTesting_TestAny do { - decoded = try ProtobufUnittest_TestAny(serializedData: encoded) + decoded = try SwiftProtoTesting_TestAny(serializedBytes: encoded) } catch { XCTFail("Failed to decode \(encoded): \(error)") return } - XCTAssertEqual(decoded.anyValue.typeURL, "/protobuf_unittest.TestAllTypes") + XCTAssertEqual(decoded.anyValue.typeURL, "/swift_proto_testing.TestAllTypes") XCTAssertEqual(decoded.anyValue.value, Data([8, 7])) XCTAssertEqual(decoded.int32Value, 12) XCTAssertNotNil(decoded.anyValue) let any = decoded.anyValue do { - let extracted = try ProtobufUnittest_TestAllTypes(unpackingAny: any) + let extracted = try SwiftProtoTesting_TestAllTypes(unpackingAny: any) XCTAssertEqual(extracted.optionalInt32, 7) } catch { XCTFail("Failed to unpack \(any)") } - XCTAssertThrowsError(try ProtobufUnittest_TestEmptyMessage(unpackingAny: any)) - let recoded = try decoded.serializedData() + XCTAssertThrowsError(try SwiftProtoTesting_TestEmptyMessage(unpackingAny: any)) + let recoded: [UInt8] = try decoded.serializedBytes() XCTAssertEqual(encoded, recoded) } /// Though Google discourages this, we should be able to match and decode an Any /// if the typeURL holds just the type name: func test_Any_shortesttype() throws { - let encoded = Data([8, 12, 18, 36, 10, 30, 112, 114, 111, 116, 111, 98, 117, 102, 95, 117, 110, 105, 116, 116, 101, 115, 116, 46, 84, 101, 115, 116, 65, 108, 108, 84, 121, 112, 101, 115, 18, 2, 8, 7]) - let decoded: ProtobufUnittest_TestAny + let encoded: [UInt8] = [ + 8, 12, 18, 38, 10, 32, 115, 119, 105, 102, 116, 95, 112, 114, 111, 116, 111, 95, 116, 101, 115, 116, 105, + 110, 103, 46, 84, 101, 115, 116, 65, 108, 108, 84, 121, 112, 101, 115, 18, 2, 8, 7, + ] + let decoded: SwiftProtoTesting_TestAny do { - decoded = try ProtobufUnittest_TestAny(serializedData: encoded) + decoded = try SwiftProtoTesting_TestAny(serializedBytes: encoded) } catch { XCTFail("Failed to decode \(encoded): \(error)") return } - XCTAssertEqual(decoded.anyValue.typeURL, "protobuf_unittest.TestAllTypes") + XCTAssertEqual(decoded.anyValue.typeURL, "swift_proto_testing.TestAllTypes") XCTAssertEqual(decoded.anyValue.value, Data([8, 7])) XCTAssertEqual(decoded.int32Value, 12) XCTAssertNotNil(decoded.anyValue) let any = decoded.anyValue do { - let extracted = try ProtobufUnittest_TestAllTypes(unpackingAny: any) + let extracted = try SwiftProtoTesting_TestAllTypes(unpackingAny: any) XCTAssertEqual(extracted.optionalInt32, 7) } catch { XCTFail("Failed to unpack \(any)") } - XCTAssertThrowsError(try ProtobufUnittest_TestEmptyMessage(unpackingAny: any)) - let recoded = try decoded.serializedData() + XCTAssertThrowsError(try SwiftProtoTesting_TestEmptyMessage(unpackingAny: any)) + let recoded: [UInt8] = try decoded.serializedBytes() XCTAssertEqual(encoded, recoded) } func test_Any_UserMessage() throws { - Google_Protobuf_Any.register(messageType: ProtobufUnittest_TestAllTypes.self) - var content = ProtobufUnittest_TestAllTypes() + Google_Protobuf_Any.register(messageType: SwiftProtoTesting_TestAllTypes.self) + var content = SwiftProtoTesting_TestAllTypes() content.optionalInt32 = 7 - var m = ProtobufUnittest_TestAny() + var m = SwiftProtoTesting_TestAny() m.int32Value = 12 m.anyValue = try Google_Protobuf_Any(message: content) let encoded = try m.jsonString() - XCTAssertEqual(encoded, "{\"int32Value\":12,\"anyValue\":{\"@type\":\"type.googleapis.com/protobuf_unittest.TestAllTypes\",\"optionalInt32\":7}}") + XCTAssertEqual( + encoded, + "{\"int32Value\":12,\"anyValue\":{\"@type\":\"type.googleapis.com/swift_proto_testing.TestAllTypes\",\"optionalInt32\":7}}" + ) do { - let decoded = try ProtobufUnittest_TestAny(jsonString: encoded) + let decoded = try SwiftProtoTesting_TestAny(jsonString: encoded) XCTAssertNotNil(decoded.anyValue) XCTAssertEqual(Data([8, 7]), decoded.anyValue.value) XCTAssertEqual(decoded.int32Value, 12) XCTAssertNotNil(decoded.anyValue) let any = decoded.anyValue do { - let extracted = try ProtobufUnittest_TestAllTypes(unpackingAny: any) + let extracted = try SwiftProtoTesting_TestAllTypes(unpackingAny: any) XCTAssertEqual(extracted.optionalInt32, 7) - XCTAssertThrowsError(try ProtobufUnittest_TestEmptyMessage(unpackingAny: any)) + XCTAssertThrowsError(try SwiftProtoTesting_TestEmptyMessage(unpackingAny: any)) } catch { XCTFail("Failed to unpack \(any)") } let recoded = try decoded.jsonString() XCTAssertEqual(encoded, recoded) - XCTAssertEqual([8, 12, 18, 56, 10, 50, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109, 47, 112, 114, 111, 116, 111, 98, 117, 102, 95, 117, 110, 105, 116, 116, 101, 115, 116, 46, 84, 101, 115, 116, 65, 108, 108, 84, 121, 112, 101, 115, 18, 2, 8, 7], try decoded.serializedBytes()) + XCTAssertEqual( + [ + 8, 12, 18, 58, 10, 52, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, + 99, 111, 109, 47, 115, 119, 105, 102, 116, 95, 112, 114, 111, 116, 111, 95, 116, 101, 115, 116, 105, + 110, 103, 46, 84, 101, 115, 116, 65, 108, 108, 84, 121, 112, 101, 115, 18, 2, 8, 7, + ], + try decoded.serializedBytes() + ) } catch { XCTFail("Failed to decode \(encoded)") } } func test_Any_UnknownUserMessage_JSON() throws { - Google_Protobuf_Any.register(messageType: ProtobufUnittest_TestAllTypes.self) + Google_Protobuf_Any.register(messageType: SwiftProtoTesting_TestAllTypes.self) let start = "{\"int32Value\":12,\"anyValue\":{\"@type\":\"type.googleapis.com/UNKNOWN\",\"optionalInt32\":7}}" - let decoded = try ProtobufUnittest_TestAny(jsonString: start) + let decoded = try SwiftProtoTesting_TestAny(jsonString: start) // JSON-to-JSON transcoding succeeds let recoded = try decoded.jsonString() @@ -189,21 +215,27 @@ class Test_Any: XCTestCase { XCTAssertEqual(anyValue.typeURL, "type.googleapis.com/UNKNOWN") XCTAssertEqual(anyValue.value, Data()) - XCTAssertEqual(anyValue.textFormatString(), "type_url: \"type.googleapis.com/UNKNOWN\"\n#json: \"{\\\"optionalInt32\\\":7}\"\n") + XCTAssertEqual( + anyValue.textFormatString(), + "type_url: \"type.googleapis.com/UNKNOWN\"\n#json: \"{\\\"optionalInt32\\\":7}\"\n" + ) // Verify: JSON-to-protobuf transcoding should fail here // since the Any does not have type information - XCTAssertThrowsError(try decoded.serializedBytes()) + XCTAssertThrowsError(try decoded.serializedBytes() as [UInt8]) } func test_Any_UnknownUserMessage_protobuf() throws { - Google_Protobuf_Any.register(messageType: ProtobufUnittest_TestAllTypes.self) - let start = Data([8, 12, 18, 33, 10, 27, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109, 47, 85, 78, 75, 78, 79, 87, 78, 18, 2, 8, 7]) + Google_Protobuf_Any.register(messageType: SwiftProtoTesting_TestAllTypes.self) + let start: [UInt8] = [ + 8, 12, 18, 33, 10, 27, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, + 109, 47, 85, 78, 75, 78, 79, 87, 78, 18, 2, 8, 7, + ] - let decoded = try ProtobufUnittest_TestAny(serializedData: start) + let decoded = try SwiftProtoTesting_TestAny(serializedBytes: start) // Protobuf-to-protobuf transcoding succeeds - let recoded = try decoded.serializedData() + let recoded: [UInt8] = try decoded.serializedBytes() XCTAssertEqual(recoded, start) let anyValue = decoded.anyValue @@ -218,10 +250,11 @@ class Test_Any: XCTestCase { } func test_Any_Any() throws { - let start = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Any\",\"value\":{\"@type\":\"type.googleapis.com/google.protobuf.Int32Value\",\"value\":1}}}" - let decoded: ProtobufTestMessages_Proto3_TestAllTypesProto3 + let start = + "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Any\",\"value\":{\"@type\":\"type.googleapis.com/google.protobuf.Int32Value\",\"value\":1}}}" + let decoded: SwiftProtoTesting_Test3_TestAllTypesProto3 do { - decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) + decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) } catch { XCTFail("Failed to decode \(start)") return @@ -242,18 +275,27 @@ class Test_Any: XCTestCase { return } - let protobuf: Data + let protobuf: [UInt8] do { - protobuf = try decoded.serializedData() + protobuf = try decoded.serializedBytes() } catch { XCTFail("Failed to serialize \(decoded)") return } - XCTAssertEqual(protobuf, Data([138, 19, 95, 10, 39, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 65, 110, 121, 18, 52, 10, 46, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 73, 110, 116, 51, 50, 86, 97, 108, 117, 101, 18, 2, 8, 1])) - - let redecoded: ProtobufTestMessages_Proto3_TestAllTypesProto3 + XCTAssertEqual( + protobuf, + [ + 138, 19, 95, 10, 39, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, + 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 65, 110, 121, + 18, 52, 10, 46, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, + 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 73, 110, 116, 51, + 50, 86, 97, 108, 117, 101, 18, 2, 8, 1, + ] + ) + + let redecoded: SwiftProtoTesting_Test3_TestAllTypesProto3 do { - redecoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(serializedData: protobuf) + redecoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(serializedBytes: protobuf) } catch { XCTFail("Failed to decode \(protobuf)") return @@ -278,25 +320,26 @@ class Test_Any: XCTestCase { func test_Any_recursive() throws { func nestedAny(_ i: Int) throws -> Google_Protobuf_Any { - guard i > 0 else { return Google_Protobuf_Any() } - return try Google_Protobuf_Any(message: nestedAny(i - 1)) + guard i > 0 else { return Google_Protobuf_Any() } + return try Google_Protobuf_Any(message: nestedAny(i - 1)) } let any = try nestedAny(5) - let encoded = try any.serializedBytes() + let encoded: [UInt8] = try any.serializedBytes() XCTAssertEqual(encoded.count, 214) } func test_Any_Duration_JSON_roundtrip() throws { - let start = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Duration\",\"value\":\"99.001s\"}}" + let start = + "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Duration\",\"value\":\"99.001s\"}}" do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) XCTAssertNotNil(decoded.optionalAny) let anyField = decoded.optionalAny do { let unpacked = try Google_Protobuf_Duration(unpackingAny: anyField) XCTAssertEqual(unpacked.seconds, 99) - XCTAssertEqual(unpacked.nanos, 1000000) + XCTAssertEqual(unpacked.nanos, 1_000_000) } catch { XCTFail("Failed to unpack \(anyField)") } @@ -309,13 +352,21 @@ class Test_Any: XCTestCase { } func test_Any_Duration_transcode() throws { - let start = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Duration\",\"value\":\"99.001s\"}}" + let start = + "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Duration\",\"value\":\"99.001s\"}}" do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) - let protobuf = try decoded.serializedData() - XCTAssertEqual(protobuf, Data([138, 19, 54, 10, 44, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 68, 117, 114, 97, 116, 105, 111, 110, 18, 6, 8, 99, 16, 192, 132, 61])) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) + let protobuf: [UInt8] = try decoded.serializedBytes() + XCTAssertEqual( + protobuf, + [ + 138, 19, 54, 10, 44, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, + 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 68, + 117, 114, 97, 116, 105, 111, 110, 18, 6, 8, 99, 16, 192, 132, 61, + ] + ) do { - let redecoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(serializedData: protobuf) + let redecoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(serializedBytes: protobuf) let json = try redecoded.jsonString() XCTAssertEqual(json, start) } catch let e { @@ -327,9 +378,10 @@ class Test_Any: XCTestCase { } func test_Any_FieldMask_JSON_roundtrip() throws { - let start = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.FieldMask\",\"value\":\"foo,bar.bazQuux\"}}" + let start = + "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.FieldMask\",\"value\":\"foo,bar.bazQuux\"}}" do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) XCTAssertNotNil(decoded.optionalAny) let anyField = decoded.optionalAny do { @@ -347,13 +399,22 @@ class Test_Any: XCTestCase { } func test_Any_FieldMask_transcode() throws { - let start = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.FieldMask\",\"value\":\"foo,bar.bazQuux\"}}" + let start = + "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.FieldMask\",\"value\":\"foo,bar.bazQuux\"}}" do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) - let protobuf = try decoded.serializedData() - XCTAssertEqual(protobuf, Data([138, 19, 68, 10, 45, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 70, 105, 101, 108, 100, 77, 97, 115, 107, 18, 19, 10, 3, 102, 111, 111, 10, 12, 98, 97, 114, 46, 98, 97, 122, 95, 113, 117, 117, 120])) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) + let protobuf: [UInt8] = try decoded.serializedBytes() + XCTAssertEqual( + protobuf, + [ + 138, 19, 68, 10, 45, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, + 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 70, + 105, 101, 108, 100, 77, 97, 115, 107, 18, 19, 10, 3, 102, 111, 111, 10, 12, 98, 97, 114, 46, 98, 97, + 122, 95, 113, 117, 117, 120, + ] + ) do { - let redecoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(serializedData: protobuf) + let redecoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(serializedBytes: protobuf) let json = try redecoded.jsonString() XCTAssertEqual(json, start) } catch let e { @@ -367,7 +428,7 @@ class Test_Any: XCTestCase { func test_Any_Int32Value_JSON_roundtrip() throws { let start = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Int32Value\",\"value\":1}}" do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) XCTAssertNotNil(decoded.optionalAny) let anyField = decoded.optionalAny do { @@ -387,11 +448,18 @@ class Test_Any: XCTestCase { func test_Any_Int32Value_transcode() throws { let start = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Int32Value\",\"value\":1}}" do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) - let protobuf = try decoded.serializedData() - XCTAssertEqual(protobuf, Data([138, 19, 52, 10, 46, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 73, 110, 116, 51, 50, 86, 97, 108, 117, 101, 18, 2, 8, 1])) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) + let protobuf: [UInt8] = try decoded.serializedBytes() + XCTAssertEqual( + protobuf, + [ + 138, 19, 52, 10, 46, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, + 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 73, + 110, 116, 51, 50, 86, 97, 108, 117, 101, 18, 2, 8, 1, + ] + ) do { - let redecoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(serializedData: protobuf) + let redecoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(serializedBytes: protobuf) let json = try redecoded.jsonString() XCTAssertEqual(json, start) } catch let e { @@ -407,12 +475,12 @@ class Test_Any: XCTestCase { func test_Any_Struct_JSON_roundtrip() throws { let start = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Struct\",\"value\":{\"foo\":1}}}" do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) XCTAssertNotNil(decoded.optionalAny) let anyField = decoded.optionalAny do { let unpacked = try Google_Protobuf_Struct(unpackingAny: anyField) - XCTAssertEqual(unpacked.fields["foo"], Google_Protobuf_Value(numberValue:1)) + XCTAssertEqual(unpacked.fields["foo"], Google_Protobuf_Value(numberValue: 1)) } catch { XCTFail("Failed to unpack \(anyField)") } @@ -425,13 +493,21 @@ class Test_Any: XCTestCase { } func test_Any_Struct_transcode() throws { - let start = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Struct\",\"value\":{\"foo\":1.0}}}" + let start = + "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Struct\",\"value\":{\"foo\":1.0}}}" do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) - let protobuf = try decoded.serializedData() - XCTAssertEqual(protobuf, Data([138, 19, 64, 10, 42, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 83, 116, 114, 117, 99, 116, 18, 18, 10, 16, 10, 3, 102, 111, 111, 18, 9, 17, 0, 0, 0, 0, 0, 0, 240, 63])) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) + let protobuf: [UInt8] = try decoded.serializedBytes() + XCTAssertEqual( + protobuf, + [ + 138, 19, 64, 10, 42, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, + 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 83, + 116, 114, 117, 99, 116, 18, 18, 10, 16, 10, 3, 102, 111, 111, 18, 9, 17, 0, 0, 0, 0, 0, 0, 240, 63, + ] + ) do { - let redecoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(serializedData: protobuf) + let redecoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(serializedBytes: protobuf) let json = try redecoded.jsonString() XCTAssertEqual(json, start) } catch let e { @@ -443,9 +519,10 @@ class Test_Any: XCTestCase { } func test_Any_Timestamp_JSON_roundtrip() throws { - let start = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Timestamp\",\"value\":\"1970-01-01T00:00:01Z\"}}" + let start = + "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Timestamp\",\"value\":\"1970-01-01T00:00:01Z\"}}" do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) XCTAssertNotNil(decoded.optionalAny) let anyField = decoded.optionalAny do { @@ -464,13 +541,21 @@ class Test_Any: XCTestCase { } func test_Any_Timestamp_transcode() throws { - let start = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Timestamp\",\"value\":\"1970-01-01T00:00:01.000000001Z\"}}" + let start = + "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Timestamp\",\"value\":\"1970-01-01T00:00:01.000000001Z\"}}" do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) - let protobuf = try decoded.serializedData() - XCTAssertEqual(protobuf, Data([138, 19, 53, 10, 45, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 84, 105, 109, 101, 115, 116, 97, 109, 112, 18, 4, 8, 1, 16, 1])) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) + let protobuf: [UInt8] = try decoded.serializedBytes() + XCTAssertEqual( + protobuf, + [ + 138, 19, 53, 10, 45, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, + 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 84, + 105, 109, 101, 115, 116, 97, 109, 112, 18, 4, 8, 1, 16, 1, + ] + ) do { - let redecoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(serializedData: protobuf) + let redecoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(serializedBytes: protobuf) let json = try redecoded.jsonString() XCTAssertEqual(json, start) } catch let e { @@ -482,13 +567,17 @@ class Test_Any: XCTestCase { } func test_Any_ListValue_JSON_roundtrip() throws { - let start = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.ListValue\",\"value\":[\"foo\",1]}}" + let start = + "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.ListValue\",\"value\":[\"foo\",1]}}" do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) let anyField = decoded.optionalAny do { let unpacked = try Google_Protobuf_ListValue(unpackingAny: anyField) - XCTAssertEqual(unpacked.values, [Google_Protobuf_Value(stringValue: "foo"), Google_Protobuf_Value(numberValue: 1)]) + XCTAssertEqual( + unpacked.values, + [Google_Protobuf_Value(stringValue: "foo"), Google_Protobuf_Value(numberValue: 1)] + ) } catch { XCTFail("Failed to unpack \(anyField)") } @@ -501,13 +590,22 @@ class Test_Any: XCTestCase { } func test_Any_ListValue_transcode() throws { - let start = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.ListValue\",\"value\":[1.0,\"abc\"]}}" + let start = + "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.ListValue\",\"value\":[1.0,\"abc\"]}}" do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) - let protobuf = try decoded.serializedData() - XCTAssertEqual(protobuf, Data([138, 19, 67, 10, 45, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 76, 105, 115, 116, 86, 97, 108, 117, 101, 18, 18, 10, 9, 17, 0, 0, 0, 0, 0, 0, 240, 63, 10, 5, 26, 3, 97, 98, 99])) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) + let protobuf: [UInt8] = try decoded.serializedBytes() + XCTAssertEqual( + protobuf, + [ + 138, 19, 67, 10, 45, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, + 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 76, + 105, 115, 116, 86, 97, 108, 117, 101, 18, 18, 10, 9, 17, 0, 0, 0, 0, 0, 0, 240, 63, 10, 5, 26, 3, + 97, 98, 99, + ] + ) do { - let redecoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(serializedData: protobuf) + let redecoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(serializedBytes: protobuf) let json = try redecoded.jsonString() XCTAssertEqual(json, start) } catch let e { @@ -522,13 +620,13 @@ class Test_Any: XCTestCase { // Value holding a JSON Struct let start1 = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Value\",\"value\":{\"foo\":1}}}" do { - let decoded1 = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start1) + let decoded1 = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start1) XCTAssertNotNil(decoded1.optionalAny) let anyField = decoded1.optionalAny XCTAssertThrowsError(try Google_Protobuf_Struct(unpackingAny: anyField)) do { let unpacked = try Google_Protobuf_Value(unpackingAny: anyField) - XCTAssertEqual(unpacked.structValue.fields["foo"], Google_Protobuf_Value(numberValue:1)) + XCTAssertEqual(unpacked.structValue.fields["foo"], Google_Protobuf_Value(numberValue: 1)) } catch { XCTFail("failed to unpack \(anyField)") } @@ -541,13 +639,22 @@ class Test_Any: XCTestCase { } func test_Any_Value_struct_transcode() throws { - let start = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Value\",\"value\":{\"foo\":1.0}}}" + let start = + "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Value\",\"value\":{\"foo\":1.0}}}" do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) - let protobuf = try decoded.serializedData() - XCTAssertEqual(protobuf, Data([138, 19, 65, 10, 41, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 86, 97, 108, 117, 101, 18, 20, 42, 18, 10, 16, 10, 3, 102, 111, 111, 18, 9, 17, 0, 0, 0, 0, 0, 0, 240, 63])) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) + let protobuf: [UInt8] = try decoded.serializedBytes() + XCTAssertEqual( + protobuf, + [ + 138, 19, 65, 10, 41, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, + 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 86, + 97, 108, 117, 101, 18, 20, 42, 18, 10, 16, 10, 3, 102, 111, 111, 18, 9, 17, 0, 0, 0, 0, 0, 0, 240, + 63, + ] + ) do { - let redecoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(serializedData: protobuf) + let redecoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(serializedBytes: protobuf) let json = try redecoded.jsonString() XCTAssertEqual(json, start) } catch let e { @@ -562,7 +669,7 @@ class Test_Any: XCTestCase { // Value holding an Int let start2 = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Value\",\"value\":1}}" do { - let decoded2 = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start2) + let decoded2 = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start2) XCTAssertNotNil(decoded2.optionalAny) let anyField = decoded2.optionalAny XCTAssertThrowsError(try Google_Protobuf_Struct(unpackingAny: anyField)) @@ -583,11 +690,18 @@ class Test_Any: XCTestCase { func test_Any_Value_int_transcode() throws { let start = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Value\",\"value\":1.0}}" do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) - let protobuf = try decoded.serializedData() - XCTAssertEqual(protobuf, Data([138, 19, 54, 10, 41, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 86, 97, 108, 117, 101, 18, 9, 17, 0, 0, 0, 0, 0, 0, 240, 63])) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) + let protobuf: [UInt8] = try decoded.serializedBytes() + XCTAssertEqual( + protobuf, + [ + 138, 19, 54, 10, 41, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, + 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 86, + 97, 108, 117, 101, 18, 9, 17, 0, 0, 0, 0, 0, 0, 240, 63, + ] + ) do { - let redecoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(serializedData: protobuf) + let redecoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(serializedBytes: protobuf) let json = try redecoded.jsonString() XCTAssertEqual(json, start) } catch { @@ -602,7 +716,7 @@ class Test_Any: XCTestCase { // Value holding a String let start3 = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Value\",\"value\":\"abc\"}}" do { - let decoded3 = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start3) + let decoded3 = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start3) let anyField = decoded3.optionalAny XCTAssertThrowsError(try Google_Protobuf_Struct(unpackingAny: anyField)) do { @@ -622,11 +736,18 @@ class Test_Any: XCTestCase { func test_Any_Value_string_transcode() throws { let start = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Value\",\"value\":\"abc\"}}" do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) - let protobuf = try decoded.serializedData() - XCTAssertEqual(protobuf, Data([138, 19, 50, 10, 41, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 86, 97, 108, 117, 101, 18, 5, 26, 3, 97, 98, 99])) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) + let protobuf: [UInt8] = try decoded.serializedBytes() + XCTAssertEqual( + protobuf, + [ + 138, 19, 50, 10, 41, 116, 121, 112, 101, 46, 103, 111, 111, 103, 108, 101, 97, 112, 105, 115, 46, + 99, 111, 109, 47, 103, 111, 111, 103, 108, 101, 46, 112, 114, 111, 116, 111, 98, 117, 102, 46, 86, + 97, 108, 117, 101, 18, 5, 26, 3, 97, 98, 99, + ] + ) do { - let redecoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(serializedData: protobuf) + let redecoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(serializedBytes: protobuf) let json = try redecoded.jsonString() XCTAssertEqual(json, start) } catch { @@ -638,214 +759,519 @@ class Test_Any: XCTestCase { } func test_Any_OddTypeURL_FromValue() throws { - var msg = ProtobufTestMessages_Proto3_TestAllTypesProto3() - msg.optionalAny.value = Data([0x1a, 0x03, 0x61, 0x62, 0x63]) - msg.optionalAny.typeURL = "Odd\nType\" prefix/google.protobuf.Value" - let newJSON = try msg.jsonString() - XCTAssertEqual(newJSON, "{\"optionalAny\":{\"@type\":\"Odd\\nType\\\" prefix/google.protobuf.Value\",\"value\":\"abc\"}}") + var msg = SwiftProtoTesting_Test3_TestAllTypesProto3() + msg.optionalAny.value = Data([0x1a, 0x03, 0x61, 0x62, 0x63]) + msg.optionalAny.typeURL = "Odd\nType\" prefix/google.protobuf.Value" + let newJSON = try msg.jsonString() + XCTAssertEqual( + newJSON, + "{\"optionalAny\":{\"@type\":\"Odd\\nType\\\" prefix/google.protobuf.Value\",\"value\":\"abc\"}}" + ) } func test_Any_OddTypeURL_FromMessage() throws { - let valueMsg = Google_Protobuf_Value.with { - $0.stringValue = "abc" - } - var msg = ProtobufTestMessages_Proto3_TestAllTypesProto3() - msg.optionalAny = try Google_Protobuf_Any(message: valueMsg, typePrefix: "Odd\nPrefix\"") - let newJSON = try msg.jsonString() - XCTAssertEqual(newJSON, "{\"optionalAny\":{\"@type\":\"Odd\\nPrefix\\\"/google.protobuf.Value\",\"value\":\"abc\"}}") + let valueMsg = Google_Protobuf_Value.with { + $0.stringValue = "abc" + } + var msg = SwiftProtoTesting_Test3_TestAllTypesProto3() + msg.optionalAny = try Google_Protobuf_Any(message: valueMsg, typePrefix: "Odd\nPrefix\"") + let newJSON = try msg.jsonString() + XCTAssertEqual( + newJSON, + "{\"optionalAny\":{\"@type\":\"Odd\\nPrefix\\\"/google.protobuf.Value\",\"value\":\"abc\"}}" + ) } func test_Any_JSON_Extensions() throws { - var content = ProtobufUnittest_TestAllExtensions() - content.ProtobufUnittest_optionalInt32Extension = 17 + var content = SwiftProtoTesting_TestAllExtensions() + content.SwiftProtoTesting_optionalInt32Extension = 17 + + var msg = SwiftProtoTesting_TestAny() + msg.anyValue = try Google_Protobuf_Any(message: content) + + let json = try msg.jsonString() + XCTAssertEqual( + json, + "{\"anyValue\":{\"@type\":\"type.googleapis.com/swift_proto_testing.TestAllExtensions\",\"[swift_proto_testing.optional_int32_extension]\":17}}" + ) + + // Decode the outer message without any extension knowledge + let decoded = try SwiftProtoTesting_TestAny(jsonString: json) + // Decoding the inner content fails without extension info + XCTAssertThrowsError(try SwiftProtoTesting_TestAllExtensions(unpackingAny: decoded.anyValue)) + // Succeeds if you do provide extension info + let decodedContent = try SwiftProtoTesting_TestAllExtensions( + unpackingAny: decoded.anyValue, + extensions: SwiftProtoTesting_Unittest_Extensions + ) + XCTAssertEqual(content, decodedContent) + + // Transcoding should fail without extension info + XCTAssertThrowsError(try decoded.serializedBytes() as [UInt8]) + + // Decode the outer message with extension information + let decodedWithExtensions = try SwiftProtoTesting_TestAny( + jsonString: json, + extensions: SwiftProtoTesting_Unittest_Extensions + ) + // Still fails; the Any doesn't record extensions that were in effect when the outer Any was decoded + XCTAssertThrowsError(try SwiftProtoTesting_TestAllExtensions(unpackingAny: decodedWithExtensions.anyValue)) + let decodedWithExtensionsContent = try SwiftProtoTesting_TestAllExtensions( + unpackingAny: decodedWithExtensions.anyValue, + extensions: SwiftProtoTesting_Unittest_Extensions + ) + XCTAssertEqual(content, decodedWithExtensionsContent) + + XCTAssertTrue(Google_Protobuf_Any.register(messageType: SwiftProtoTesting_TestAllExtensions.self)) + // Throws because the extensions can't be implicitly transcoded + XCTAssertThrowsError(try decodedWithExtensions.serializedBytes() as [UInt8]) + } - var msg = ProtobufUnittest_TestAny() - msg.anyValue = try Google_Protobuf_Any(message: content) + func test_Any_WKT_UnknownFields() throws { + let testcases = [ + // unknown field before value + "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Duration\",\"fred\":1,\"value\":\"99.001s\"}}", + // unknown field after value + "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Duration\",\"value\":\"99.001s\",\"fred\":1}}", + ] + for json in testcases { + for ignoreUnknown in [false, true] { + var options = JSONDecodingOptions() + options.ignoreUnknownFields = ignoreUnknown + // This may appear a little odd, since Any lazy parses, this will + // always succeed because the Any isn't decoded until requested. + let decoded = try! SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: json, options: options) + + XCTAssertNotNil(decoded.optionalAny) + let anyField = decoded.optionalAny + do { + let unpacked = try Google_Protobuf_Duration(unpackingAny: anyField) + XCTAssertTrue(ignoreUnknown) // Should have throw if not ignoring unknowns. + XCTAssertEqual(unpacked.seconds, 99) + XCTAssertEqual(unpacked.nanos, 1_000_000) + } catch { + XCTAssertTrue(!ignoreUnknown) + } + + // The extra field should still be there. + let encoded = try decoded.jsonString() + XCTAssertEqual(encoded, json) + } + } + } - let json = try msg.jsonString() - XCTAssertEqual(json, "{\"anyValue\":{\"@type\":\"type.googleapis.com/protobuf_unittest.TestAllExtensions\",\"[protobuf_unittest.optional_int32_extension]\":17}}") + func test_Any_empty() throws { + let start = "{\"optionalAny\":{}}" + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) + let protobuf: [UInt8] = try decoded.serializedBytes() + XCTAssertEqual(protobuf, [138, 19, 0]) + let redecoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(serializedBytes: protobuf) + let retext = redecoded.textFormatString() + XCTAssertEqual(retext, "optional_any {\n}\n") + let reredecoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(textFormatString: retext) + let rejson = try reredecoded.jsonString() + XCTAssertEqual(rejson, start) + } - // Decode the outer message without any extension knowledge - let decoded = try ProtobufUnittest_TestAny(jsonString: json) - // Decoding the inner content fails without extension info - XCTAssertThrowsError(try ProtobufUnittest_TestAllExtensions(unpackingAny: decoded.anyValue)) - // Succeeds if you do provide extension info - let decodedContent = try ProtobufUnittest_TestAllExtensions(unpackingAny: decoded.anyValue, - extensions: ProtobufUnittest_Unittest_Extensions) - XCTAssertEqual(content, decodedContent) + func test_Any_typeURLValidations() throws { + // Upstream most langauges end up validating the type_url during encoding as well + // as during decoding. Basically to do things, they end up looking up the type + // in their global registries to use reflection to do things. SwiftProtobuf doesn't + // have a registry we can rely on being complete. So instead during encoding we + // do the most basic of checks. These tests help ensure those checks are working as + // expected. + // + // The inspiration for the tests and the errors comes from editing upstream's + // json_test.cc and observing a few things: + // + // TEST_P(JsonTest, HackingTypeURLs) { + // google::protobuf::Any any; + // any.set_type_url("not_valid"); + // // INVALID_ARGUMENT: @type must contain at least one / and a nonempty host; got: not_valid + // EXPECT_THAT(ToJson(any), StatusIs(absl::StatusCode::kInvalidArgument)); + // + // // This works because the message counts as empty + // any.set_type_url("type.googleapis.com/proto3.TestMessage"); + // EXPECT_THAT(ToJson(any), + // IsOkAndHolds(R"({"@type":"type.googleapis.com/proto3.TestMessage"})")); + // INVALID_ARGUMENT: @type must contain at least one / and a nonempty host; got: + // + // EXPECT_THAT(ToProto(R"json( + // { + // "@type": "" + // } + // )json"), + // StatusIs(absl::StatusCode::kInvalidArgument)); + // } + // + // TEST_P(JsonTest, HackingValues) { + // google::protobuf::Any any; + // any.set_value("abc"); + // std::string blob = any.SerializeAsString(); + // EXPECT_FALSE(blob.empty()); // It didn't fail to serialize + // // INVALID_ARGUMENT: broken Any: missing type URL + // EXPECT_THAT(ToJson(any), StatusIs(absl::StatusCode::kInvalidArgument)); + // + // // INVALID_ARGUMENT: invalid JSON in google.protobuf.Any, near 2:5 (offset 5): in legacy mode, missing @type in Any is only allowed for an empty object + // EXPECT_THAT(ToProto(R"json( + // { + // "value": "abc" + // } + // )json"), + // StatusIs(absl::StatusCode::kInvalidArgument)); + // } + + // ---- With a binary protobuf data in the backing store: - // Transcoding should fail without extension info - XCTAssertThrowsError(try decoded.serializedData()) + do { + // No payload, no type_url + var any = Google_Protobuf_Any() + any.value = Data() + XCTAssertEqual(try any.jsonString(), "{}") + // No payload, valid type_url + any.typeURL = "type.googleapis.com/SomeMessage" + XCTAssertEqual( + try any.jsonString(), + "{\"@type\":\"type.googleapis.com/SomeMessage\"}" + ) + // No payload, invalid type url. + any.typeURL = "not_valid" + XCTAssertThrowsError( + try any.jsonString() + ) { error in + XCTAssertTrue( + self.isSwiftProtobufErrorEqual( + error as! SwiftProtobufError, + .JSONEncoding.invalidAnyTypeURL(type_url: "not_valid") + ) + ) + } - // Decode the outer message with extension information - let decodedWithExtensions = try ProtobufUnittest_TestAny(jsonString: json, - extensions: ProtobufUnittest_Unittest_Extensions) - // Still fails; the Any doesn't record extensions that were in effect when the outer Any was decoded - XCTAssertThrowsError(try ProtobufUnittest_TestAllExtensions(unpackingAny: decodedWithExtensions.anyValue)) - let decodedWithExtensionsContent = try ProtobufUnittest_TestAllExtensions(unpackingAny: decodedWithExtensions.anyValue, - extensions: ProtobufUnittest_Unittest_Extensions) - XCTAssertEqual(content, decodedWithExtensionsContent) + // Has payload, no type_url + any = Google_Protobuf_Any() + any.value = Data([8, 1]) // SwiftProtoTesting_TestAllTypes.optionalInt32 = 1 + XCTAssertThrowsError( + try any.jsonString() + ) { error in + XCTAssertTrue( + self.isSwiftProtobufErrorEqual( + error as! SwiftProtobufError, + .JSONEncoding.emptyAnyTypeURL() + ) + ) + } + // Has payload, valid type_url (gets lazy decoded) + Google_Protobuf_Any.register(messageType: SwiftProtoTesting_TestAllTypes.self) + any.typeURL = "type.googleapis.com/swift_proto_testing.TestAllTypes" + XCTAssertEqual( + try any.jsonString(), + "{\"@type\":\"type.googleapis.com/swift_proto_testing.TestAllTypes\",\"optionalInt32\":1}" + ) + // Has payload, invalid type url. + any.typeURL = "not_valid" + XCTAssertThrowsError( + try any.jsonString() + ) { error in + XCTAssertTrue( + self.isSwiftProtobufErrorEqual( + error as! SwiftProtobufError, + .JSONEncoding.invalidAnyTypeURL(type_url: "not_valid") + ) + ) + } + } - XCTAssertTrue(Google_Protobuf_Any.register(messageType: ProtobufUnittest_TestAllExtensions.self)) - // Throws because the extensions can't be implicitly transcoded - XCTAssertThrowsError(try decodedWithExtensions.serializedData()) - } + // ---- With a message in the backing store: - func test_Any_WKT_UnknownFields() throws { - let testcases = [ - // unknown field before value - "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Duration\",\"fred\":1,\"value\":\"99.001s\"}}", - // unknown field after value - "{\"optionalAny\":{\"@type\":\"type.googleapis.com/google.protobuf.Duration\",\"value\":\"99.001s\",\"fred\":1}}", - ] - for json in testcases { - for ignoreUnknown in [false, true] { - var options = JSONDecodingOptions() - options.ignoreUnknownFields = ignoreUnknown - // This may appear a little odd, since Any lazy parses, this will - // always succeed because the Any isn't decoded until requested. - let decoded = try! ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: json, options: options) - - XCTAssertNotNil(decoded.optionalAny) - let anyField = decoded.optionalAny - do { - let unpacked = try Google_Protobuf_Duration(unpackingAny: anyField) - XCTAssertTrue(ignoreUnknown) // Should have throw if not ignoring unknowns. - XCTAssertEqual(unpacked.seconds, 99) - XCTAssertEqual(unpacked.nanos, 1000000) - } catch { - XCTAssertTrue(!ignoreUnknown) - } - - // The extra field should still be there. - let encoded = try decoded.jsonString() - XCTAssertEqual(encoded, json) - } - } - } + do { + var content = SwiftProtoTesting_TestAllTypes() + var anyEmpty = try Google_Protobuf_Any(message: content) + content.optionalInt32 = 17 + var anyNonEmpty = try Google_Protobuf_Any(message: content) + + // Valid + XCTAssertEqual( + try anyEmpty.jsonString(), + "{\"@type\":\"type.googleapis.com/swift_proto_testing.TestAllTypes\"}" + ) + XCTAssertEqual( + try anyNonEmpty.jsonString(), + "{\"@type\":\"type.googleapis.com/swift_proto_testing.TestAllTypes\",\"optionalInt32\":17}" + ) + // Blank type url, will get defaulted again. + anyEmpty.typeURL = "" + anyNonEmpty.typeURL = "" + XCTAssertEqual( + try anyEmpty.jsonString(), + "{\"@type\":\"type.googleapis.com/swift_proto_testing.TestAllTypes\"}" + ) + XCTAssertEqual( + try anyNonEmpty.jsonString(), + "{\"@type\":\"type.googleapis.com/swift_proto_testing.TestAllTypes\",\"optionalInt32\":17}" + ) + // Invalid type url, will error + anyEmpty.typeURL = "not_valid" + anyNonEmpty.typeURL = "not_valid" + XCTAssertThrowsError( + try anyEmpty.jsonString() + ) { error in + XCTAssertTrue( + self.isSwiftProtobufErrorEqual( + error as! SwiftProtobufError, + .JSONEncoding.invalidAnyTypeURL(type_url: "not_valid") + ) + ) + } + XCTAssertThrowsError( + try anyNonEmpty.jsonString() + ) { error in + XCTAssertTrue( + self.isSwiftProtobufErrorEqual( + error as! SwiftProtobufError, + .JSONEncoding.invalidAnyTypeURL(type_url: "not_valid") + ) + ) + } + } - func test_Any_empty() throws { - let start = "{\"optionalAny\":{}}" - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) - let protobuf = try decoded.serializedData() - XCTAssertEqual(protobuf, Data([138, 19, 0])) - let redecoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(serializedData: protobuf) - let retext = redecoded.textFormatString() - XCTAssertEqual(retext, "optional_any {\n}\n") - let reredecoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(textFormatString: retext) - let rejson = try reredecoded.jsonString() - XCTAssertEqual(rejson, start) + // ---- With json data in the backing store: + + do { + // Empty, round trips. + var json = "{}" + var any = try Google_Protobuf_Any(jsonString: json) + XCTAssertEqual(json, try any.jsonString()) + // Empty with valid type_url, round trips + json = "{\"@type\":\"type.googleapis.com/SomeMessage\"}" + any = try Google_Protobuf_Any(jsonString: json) + XCTAssertEqual(json, try any.jsonString()) + // Empty with invalid type_url + XCTAssertThrowsError( + try Google_Protobuf_Any(jsonString: "{\"@type\":\"not_valid\"}") + ) { error in + XCTAssertTrue( + self.isSwiftProtobufErrorEqual( + error as! SwiftProtobufError, + .JSONDecoding.invalidAnyTypeURL(type_url: "not_valid") + ) + ) + } + // Empty, override with valid type_url, round trips + json = "{\"@type\":\"type.googleapis.com/SomeMessage\"}" + any = try Google_Protobuf_Any(jsonString: json) + any.typeURL = "type.googleapis.com/AnotherMessage" + XCTAssertEqual("{\"@type\":\"type.googleapis.com/AnotherMessage\"}", try any.jsonString()) + // Empty, override with invalid type_url + any = try Google_Protobuf_Any(jsonString: json) + any.typeURL = "not_valid" + XCTAssertThrowsError( + try any.jsonString() + ) { error in + XCTAssertTrue( + self.isSwiftProtobufErrorEqual( + error as! SwiftProtobufError, + .JSONEncoding.invalidAnyTypeURL(type_url: "not_valid") + ) + ) + } + // Field but no type_url won't even decode. + XCTAssertThrowsError( + try Google_Protobuf_Any(jsonString: "{\"value\":1}") + ) { error in + XCTAssertTrue( + self.isSwiftProtobufErrorEqual( + error as! SwiftProtobufError, + .JSONDecoding.emptyAnyTypeURL() + ) + ) + } + // Non empty and a type_url round trips. + json = "{\"@type\":\"type.googleapis.com/SomeMessage\",\"value\":1}" + any = try Google_Protobuf_Any(jsonString: json) + XCTAssertEqual(json, try any.jsonString()) + // Non empty and override of the type_url still works + any = try Google_Protobuf_Any(jsonString: json) + any.typeURL = "type.googleapis.com/AnotherMessage" + XCTAssertEqual("{\"@type\":\"type.googleapis.com/AnotherMessage\",\"value\":1}", try any.jsonString()) + // Non empty, override with invalid type_url + any = try Google_Protobuf_Any(jsonString: json) + any.typeURL = "not_valid" + XCTAssertThrowsError( + try any.jsonString() + ) { error in + XCTAssertTrue( + self.isSwiftProtobufErrorEqual( + error as! SwiftProtobufError, + .JSONEncoding.invalidAnyTypeURL(type_url: "not_valid") + ) + ) + } + } + + // ---- These come from the upstream conformace tests: + + do { + // AnyWktRepresentationWithEmptyTypeAndValue + let emptyTypeAndValue = "{\"optional_any\":{\"@type\":\"\",\"value\":\"\"}}" + XCTAssertThrowsError( + try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: emptyTypeAndValue) + ) { error in + XCTAssertTrue( + self.isSwiftProtobufErrorEqual( + error as! SwiftProtobufError, + .JSONDecoding.invalidAnyTypeURL(type_url: "") + ) + ) + } + + // AnyWktRepresentationWithBadType + let notAType = "{\"optional_any\":{\"@type\":\"not_a_url\",\"value\":\"\"}}" + XCTAssertThrowsError( + try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: notAType) + ) { error in + XCTAssertTrue( + self.isSwiftProtobufErrorEqual( + error as! SwiftProtobufError, + .JSONDecoding.invalidAnyTypeURL(type_url: "not_a_url") + ) + ) + } + + // ---- Variant of AnyWktRepresentationWithEmptyTypeAndValue above with no value. + let emptyType = "{\"optional_any\":{\"@type\":\"\"}}" + XCTAssertThrowsError( + try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: emptyType) + ) { error in + XCTAssertTrue( + self.isSwiftProtobufErrorEqual( + error as! SwiftProtobufError, + .JSONDecoding.invalidAnyTypeURL(type_url: "") + ) + ) + } + } } func test_Any_nestedList() throws { - var start = "{\"optionalAny\":{\"x\":" - for _ in 0...10000 { - start.append("[") - } - XCTAssertThrowsError( - // This should fail because the deeply-nested array is not closed - // It should not crash from exhausting stack space - try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) - ) - for _ in 0...10000 { - start.append("]") - } - start.append("}}") - // This should succeed because the deeply-nested array is properly closed - // It should not crash from exhausting stack space and should - // not fail due to recursion limits (because when skipping, those are - // only applied to objects). - _ = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) + var start = "{\"optionalAny\":{\"@type\":\"type.googleapis.com/Something\",\"x\":" + for _ in 0...10000 { + start.append("[") + } + XCTAssertThrowsError( + // This should fail because the deeply-nested array is not closed + // It should not crash from exhausting stack space + try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) + ) + for _ in 0...10000 { + start.append("]") + } + start.append("}}") + // This should succeed because the deeply-nested array is properly closed + // It should not crash from exhausting stack space and should + // not fail due to recursion limits (because when skipping, those are + // only applied to objects). + _ = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) } func test_IsA() { - var msg = Google_Protobuf_Any() - - msg.typeURL = "type.googleapis.com/protobuf_unittest.TestAllTypes" - XCTAssertTrue(msg.isA(ProtobufUnittest_TestAllTypes.self)) - XCTAssertFalse(msg.isA(Google_Protobuf_Empty.self)) - msg.typeURL = "random.site.org/protobuf_unittest.TestAllTypes" - XCTAssertTrue(msg.isA(ProtobufUnittest_TestAllTypes.self)) - XCTAssertFalse(msg.isA(Google_Protobuf_Empty.self)) - msg.typeURL = "/protobuf_unittest.TestAllTypes" - XCTAssertTrue(msg.isA(ProtobufUnittest_TestAllTypes.self)) - XCTAssertFalse(msg.isA(Google_Protobuf_Empty.self)) - msg.typeURL = "protobuf_unittest.TestAllTypes" - XCTAssertTrue(msg.isA(ProtobufUnittest_TestAllTypes.self)) - XCTAssertFalse(msg.isA(Google_Protobuf_Empty.self)) - - msg.typeURL = "" - XCTAssertFalse(msg.isA(ProtobufUnittest_TestAllTypes.self)) - XCTAssertFalse(msg.isA(Google_Protobuf_Empty.self)) + var msg = Google_Protobuf_Any() + + msg.typeURL = "type.googleapis.com/swift_proto_testing.TestAllTypes" + XCTAssertTrue(msg.isA(SwiftProtoTesting_TestAllTypes.self)) + XCTAssertFalse(msg.isA(Google_Protobuf_Empty.self)) + msg.typeURL = "random.site.org/swift_proto_testing.TestAllTypes" + XCTAssertTrue(msg.isA(SwiftProtoTesting_TestAllTypes.self)) + XCTAssertFalse(msg.isA(Google_Protobuf_Empty.self)) + msg.typeURL = "/swift_proto_testing.TestAllTypes" + XCTAssertTrue(msg.isA(SwiftProtoTesting_TestAllTypes.self)) + XCTAssertFalse(msg.isA(Google_Protobuf_Empty.self)) + msg.typeURL = "swift_proto_testing.TestAllTypes" + XCTAssertTrue(msg.isA(SwiftProtoTesting_TestAllTypes.self)) + XCTAssertFalse(msg.isA(Google_Protobuf_Empty.self)) + + msg.typeURL = "" + XCTAssertFalse(msg.isA(SwiftProtoTesting_TestAllTypes.self)) + XCTAssertFalse(msg.isA(Google_Protobuf_Empty.self)) } func test_Any_Registry() { - // Registering the same type multiple times is ok. - XCTAssertTrue(Google_Protobuf_Any.register(messageType: ProtobufUnittestImport_ImportMessage.self)) - XCTAssertTrue(Google_Protobuf_Any.register(messageType: ProtobufUnittestImport_ImportMessage.self)) - - // Registering a different type with the same messageName will fail. - XCTAssertFalse(Google_Protobuf_Any.register(messageType: ConflictingImportMessage.self)) - - // Sanity check that the .proto files weren't changed, and they do have the same name. - XCTAssertEqual(ConflictingImportMessage.protoMessageName, ProtobufUnittestImport_ImportMessage.protoMessageName) - - // Lookup - XCTAssertTrue(Google_Protobuf_Any.messageType(forMessageName: ProtobufUnittestImport_ImportMessage.protoMessageName) == ProtobufUnittestImport_ImportMessage.self) - XCTAssertNil(Google_Protobuf_Any.messageType(forMessageName: ProtobufUnittest_TestMap.protoMessageName)) - - // All the WKTs should be registered. - let wkts: [Message.Type] = [ - Google_Protobuf_Any.self, - Google_Protobuf_BoolValue.self, - Google_Protobuf_BytesValue.self, - Google_Protobuf_DoubleValue.self, - Google_Protobuf_Duration.self, - Google_Protobuf_Empty.self, - Google_Protobuf_FieldMask.self, - Google_Protobuf_FloatValue.self, - Google_Protobuf_Int32Value.self, - Google_Protobuf_Int64Value.self, - Google_Protobuf_ListValue.self, - Google_Protobuf_StringValue.self, - Google_Protobuf_Struct.self, - Google_Protobuf_Timestamp.self, - Google_Protobuf_UInt32Value.self, - Google_Protobuf_UInt64Value.self, - Google_Protobuf_Value.self, - ] - for t in wkts { - XCTAssertTrue(Google_Protobuf_Any.messageType(forMessageName: t.protoMessageName) == t, - "Looking up \(t.protoMessageName)") - } + // Registering the same type multiple times is ok. + XCTAssertTrue(Google_Protobuf_Any.register(messageType: SwiftProtoTesting_Import_ImportMessage.self)) + XCTAssertTrue(Google_Protobuf_Any.register(messageType: SwiftProtoTesting_Import_ImportMessage.self)) + + // Registering a different type with the same messageName will fail. + XCTAssertFalse(Google_Protobuf_Any.register(messageType: ConflictingImportMessage.self)) + + // Sanity check that the .proto files weren't changed, and they do have the same name. + XCTAssertEqual( + ConflictingImportMessage.protoMessageName, + SwiftProtoTesting_Import_ImportMessage.protoMessageName + ) + + // Lookup + XCTAssertTrue( + Google_Protobuf_Any.messageType(forMessageName: SwiftProtoTesting_Import_ImportMessage.protoMessageName) + == SwiftProtoTesting_Import_ImportMessage.self + ) + XCTAssertNil(Google_Protobuf_Any.messageType(forMessageName: SwiftProtoTesting_TestMap.protoMessageName)) + + // All the WKTs should be registered. + let wkts: [any Message.Type] = [ + Google_Protobuf_Any.self, + Google_Protobuf_BoolValue.self, + Google_Protobuf_BytesValue.self, + Google_Protobuf_DoubleValue.self, + Google_Protobuf_Duration.self, + Google_Protobuf_Empty.self, + Google_Protobuf_FieldMask.self, + Google_Protobuf_FloatValue.self, + Google_Protobuf_Int32Value.self, + Google_Protobuf_Int64Value.self, + Google_Protobuf_ListValue.self, + Google_Protobuf_StringValue.self, + Google_Protobuf_Struct.self, + Google_Protobuf_Timestamp.self, + Google_Protobuf_UInt32Value.self, + Google_Protobuf_UInt64Value.self, + Google_Protobuf_Value.self, + ] + for t in wkts { + XCTAssertTrue( + Google_Protobuf_Any.messageType(forMessageName: t.protoMessageName) == t, + "Looking up \(t.protoMessageName)" + ) + } } } -// Dump message class to test registration conflicts +// Dummy message class to test registration conflicts, this is basically the +// generated code from SwiftProtoTesting_TestEmptyMessage. struct ConflictingImportMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, - SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = "protobuf_unittest_import.ImportMessage" + SwiftProtobuf._ProtoNameProviding, + Sendable +{ + static let protoMessageName: String = "swift_proto_testing.import.ImportMessage" - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownFields = SwiftProtobuf.UnknownStorage() - init() {} + init() {} - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { + mutating func decodeMessage(decoder: inout D) throws { + while let _ = try decoder.nextFieldNumber() { + } } - } - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [:] + static let _protobuf_nameMap: SwiftProtobuf._NameMap = SwiftProtobuf._NameMap() - func _protobuf_generated_isEqualTo(other: ConflictingImportMessage) -> Bool { - if unknownFields != other.unknownFields {return false} - return true - } + static func == (lhs: ConflictingImportMessage, rhs: ConflictingImportMessage) -> Bool { + if lhs.unknownFields != rhs.unknownFields { return false } + return true + } } diff --git a/Tests/SwiftProtobufTests/Test_Api.swift b/Tests/SwiftProtobufTests/Test_Api.swift index e55bbb8dc..4dd85deb0 100644 --- a/Tests/SwiftProtobufTests/Test_Api.swift +++ b/Tests/SwiftProtobufTests/Test_Api.swift @@ -15,14 +15,14 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_Api: XCTestCase, PBTestHelpers { +final class Test_Api: XCTestCase, PBTestHelpers { typealias MessageTestType = Google_Protobuf_Api func testExists() { - assertEncode([10,7,97,112,105,78,97,109,101,34,1,49]) { (o: inout MessageTestType) in + assertEncode([10, 7, 97, 112, 105, 78, 97, 109, 101, 34, 1, 49]) { (o: inout MessageTestType) in o.name = "apiName" o.version = "1" } @@ -41,7 +41,9 @@ class Test_Api: XCTestCase, PBTestHelpers { m.version = "1.0.0" m.syntax = .proto3 - XCTAssertEqual(try m.jsonString(), "{\"name\":\"apiName\",\"methods\":[{\"name\":\"method1\"}],\"options\":[{\"name\":\"option1\",\"value\":{\"@type\":\"type.googleapis.com/google.protobuf.StringValue\",\"value\":\"value1\"}}],\"version\":\"1.0.0\",\"syntax\":\"SYNTAX_PROTO3\"}") + XCTAssertEqual( + try m.jsonString(), + "{\"name\":\"apiName\",\"methods\":[{\"name\":\"method1\"}],\"options\":[{\"name\":\"option1\",\"value\":{\"@type\":\"type.googleapis.com/google.protobuf.StringValue\",\"value\":\"value1\"}}],\"version\":\"1.0.0\",\"syntax\":\"SYNTAX_PROTO3\"}" + ) } } - diff --git a/Tests/SwiftProtobufTests/Test_AsyncMessageSequence.swift b/Tests/SwiftProtobufTests/Test_AsyncMessageSequence.swift new file mode 100644 index 000000000..5795bfc53 --- /dev/null +++ b/Tests/SwiftProtobufTests/Test_AsyncMessageSequence.swift @@ -0,0 +1,243 @@ +// Tests/SwiftProtobufTests/Test_AsyncMessageSequence.swift - +// +// Copyright (c) 2023 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// Tests the decoding of binary-delimited message streams, ensuring various invalid stream scenarios are +/// handled gracefully. +/// +// ----------------------------------------------------------------------------- + +import Foundation +import SwiftProtobuf +import XCTest + +final class Test_AsyncMessageSequence: XCTestCase { + + // Decode a valid binary delimited stream + func testValidSequence() async throws { + let expected: [Int32] = Array(1...5) + var messages = [SwiftProtoTesting_TestAllTypes]() + for messageNumber in expected { + let message = SwiftProtoTesting_TestAllTypes.with { + $0.optionalInt32 = messageNumber + } + messages.append(message) + } + let serialized = try serializedMessageData(messages: messages) + let asyncBytes = asyncByteStream(bytes: serialized) + + // Recreate the original array + let decoded = asyncBytes.binaryProtobufDelimitedMessages(of: SwiftProtoTesting_TestAllTypes.self) + let observed = try await decoded.reduce(into: [Int32]()) { array, element in + array.append(element.optionalInt32) + } + XCTAssertEqual(observed, expected, "The original and re-created arrays should be equal.") + } + + // Decode a message from a stream, discarding unknown fields + func testBinaryDecodingOptions() async throws { + let unknownFields: [UInt8] = [ + // Field 1, 150 + 0x08, 0x96, 0x01, + // Field 2, string "testing" + 0x12, 0x07, 0x74, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, + ] + let message = try SwiftProtoTesting_TestEmptyMessage(serializedBytes: unknownFields) + let serialized = try serializedMessageData(messages: [message]) + var asyncBytes = asyncByteStream(bytes: serialized) + var decodingOptions = BinaryDecodingOptions() + let decodedWithUnknown = asyncBytes.binaryProtobufDelimitedMessages( + of: SwiftProtoTesting_TestEmptyMessage.self, + options: decodingOptions + ) + + // First ensure unknown fields are decoded + for try await message in decodedWithUnknown { + XCTAssertEqual(Array(message.unknownFields.data), unknownFields) + } + asyncBytes = asyncByteStream(bytes: serialized) + // Then re-run ensuring unknowh fields are discarded + decodingOptions.discardUnknownFields = true + let decodedWithUnknownDiscarded = asyncBytes.binaryProtobufDelimitedMessages( + of: SwiftProtoTesting_TestEmptyMessage.self, + options: decodingOptions + ) + var count = 0 + for try await message in decodedWithUnknownDiscarded { + XCTAssertTrue(message.unknownFields.data.isEmpty) + count += 1 + } + XCTAssertEqual(count, 1, "Expected one message with unknown fields discarded.") + } + + // Decode zero length messages + func testZeroLengthMessages() async throws { + var messages = [SwiftProtoTesting_TestAllTypes]() + for _ in 1...5 { + messages.append(SwiftProtoTesting_TestAllTypes()) + } + let serialized = try serializedMessageData(messages: messages) + let asyncBytes = asyncByteStream(bytes: serialized) + + var count = 0 + let decoded = AsyncMessageSequence, SwiftProtoTesting_TestAllTypes>(base: asyncBytes) + for try await message in decoded { + XCTAssertEqual(message, SwiftProtoTesting_TestAllTypes()) + count += 1 + } + XCTAssertEqual(count, 5, "Expected five messages with default fields.") + } + + // Stream with a single zero varint + func testStreamZeroVarintOnly() async throws { + let seq = asyncByteStream(bytes: [0]) + let decoded = seq.binaryProtobufDelimitedMessages(of: SwiftProtoTesting_TestAllTypes.self) + + var count = 0 + for try await message in decoded { + XCTAssertEqual(message, SwiftProtoTesting_TestAllTypes()) + count += 1 + } + XCTAssertEqual(count, 1) + } + + // Empty stream with zero bytes + func testEmptyStream() async throws { + let asyncBytes = asyncByteStream(bytes: []) + let messages = asyncBytes.binaryProtobufDelimitedMessages(of: SwiftProtoTesting_TestAllTypes.self) + for try await _ in messages { + XCTFail("Shouldn't have returned a value for an empty stream.") + } + } + + // A stream with legal non-zero varint but no message + func testNonZeroVarintNoMessage() async throws { + let asyncBytes = asyncByteStream(bytes: [0x96, 0x01]) + let decoded = asyncBytes.binaryProtobufDelimitedMessages(of: SwiftProtoTesting_TestAllTypes.self) + var truncatedThrown = false + do { + for try await _ in decoded { + XCTFail("Shouldn't have returned a value for an empty stream.") + } + } catch { + if error as! BinaryDelimited.Error == .truncated { + truncatedThrown = true + } + } + XCTAssertTrue(truncatedThrown, "Should throw a SwiftProtobufError.BinaryStreamDecoding.truncated") + } + + // Single varint describing a 2GB message + func testTooLarge() async throws { + let asyncBytes = asyncByteStream(bytes: [128, 128, 128, 128, 8]) + let decoded = asyncBytes.binaryProtobufDelimitedMessages(of: SwiftProtoTesting_TestAllTypes.self) + do { + for try await _ in decoded { + XCTFail("Shouldn't have returned a value for an invalid stream.") + } + } catch { + XCTAssertTrue(self.isSwiftProtobufErrorEqual(error as! SwiftProtobufError, .BinaryDecoding.tooLarge())) + } + } + + // Stream with truncated varint + func testTruncatedVarint() async throws { + let asyncBytes = asyncByteStream(bytes: [192]) + + let decoded = asyncBytes.binaryProtobufDelimitedMessages(of: SwiftProtoTesting_TestAllTypes.self) + var truncatedThrown = false + do { + for try await _ in decoded { + XCTFail("Shouldn't have returned a value for an empty stream.") + } + } catch { + if error as! BinaryDelimited.Error == .truncated { + truncatedThrown = true + } + } + XCTAssertTrue(truncatedThrown, "Should throw a SwiftProtobufError.BinaryStreamDecoding.truncated") + } + + // Stream with a valid varint and message, but the following varint is truncated + func testValidMessageThenTruncatedVarint() async throws { + var truncatedThrown = false + let msg = SwiftProtoTesting_TestAllTypes.with { + $0.optionalInt64 = 123_456_789 + } + let truncatedVarint: [UInt8] = [224, 216] + var serialized = try serializedMessageData(messages: [msg]) + serialized += truncatedVarint + let asyncBytes = asyncByteStream(bytes: serialized) + + do { + var count = 0 + let decoded = asyncBytes.binaryProtobufDelimitedMessages(of: SwiftProtoTesting_TestAllTypes.self) + for try await message in decoded { + XCTAssertEqual( + message, + SwiftProtoTesting_TestAllTypes.with { + $0.optionalInt64 = 123_456_789 + } + ) + count += 1 + if count > 1 { + XCTFail("Expected one message only.") + } + } + XCTAssertEqual(count, 1, "One message should be deserialized") + } catch { + if error as! BinaryDelimited.Error == .truncated { + truncatedThrown = true + } + } + XCTAssertTrue(truncatedThrown, "Should throw a SwiftProtobuf.BinaryStreamDecoding.truncated") + } + + // Slow test case found by oss-fuzz: 1 million zero-sized messages + // A similar test with BinaryDelimited is about 4x faster, showing + // that we have some room for improvement here. + // (Note this currently only tests 100,000 zero-sized messages, + // but the constant below is easy to edit if you want to experiment.) + func testLargeExample() async throws { + let messageCount = 100_000 + let bytes = [UInt8](repeating: 0, count: messageCount) + let byteStream = asyncByteStream(bytes: bytes) + let decodedStream = byteStream.binaryProtobufDelimitedMessages( + of: SwiftProtoTesting_TestAllTypes.self, + extensions: SwiftProtoTesting_Fuzz_FuzzTesting_Extensions + ) + var count = 0 + for try await message in decodedStream { + XCTAssertEqual(message, SwiftProtoTesting_TestAllTypes()) + count += 1 + } + XCTAssertEqual(count, messageCount) + } + + fileprivate func asyncByteStream(bytes: [UInt8]) -> AsyncStream { + AsyncStream(UInt8.self) { continuation in + for byte in bytes { + continuation.yield(byte) + } + continuation.finish() + } + } + + fileprivate func serializedMessageData(messages: [any Message]) throws -> [UInt8] { + let memoryOutputStream = OutputStream.toMemory() + memoryOutputStream.open() + for message in messages { + XCTAssertNoThrow(try BinaryDelimited.serialize(message: message, to: memoryOutputStream)) + } + memoryOutputStream.close() + let nsData = memoryOutputStream.property(forKey: .dataWrittenToMemoryStreamKey) as! NSData + let data = Data(referencing: nsData) + return [UInt8](data) + } +} diff --git a/Tests/SwiftProtobufTests/Test_BasicFields_Access_Proto2.swift b/Tests/SwiftProtobufTests/Test_BasicFields_Access_Proto2.swift index d49b03fb2..15efc954d 100644 --- a/Tests/SwiftProtobufTests/Test_BasicFields_Access_Proto2.swift +++ b/Tests/SwiftProtobufTests/Test_BasicFields_Access_Proto2.swift @@ -12,859 +12,760 @@ /// // ----------------------------------------------------------------------------- -import XCTest import Foundation +import XCTest // NOTE: The generator changes what is generated based on the number/types // of fields (using a nested storage class or not), to be completel, all // these tests should be done once with a message that gets that storage // class and a second time with messages that avoid that. -class Test_BasicFields_Access_Proto2: XCTestCase { - - // Optional - - func testOptionalInt32() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalInt32, 0) - XCTAssertFalse(msg.hasOptionalInt32) - msg.optionalInt32 = 1 - XCTAssertTrue(msg.hasOptionalInt32) - XCTAssertEqual(msg.optionalInt32, 1) - msg.clearOptionalInt32() - XCTAssertEqual(msg.optionalInt32, 0) - XCTAssertFalse(msg.hasOptionalInt32) - } - - func testOptionalInt64() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalInt64, 0) - XCTAssertFalse(msg.hasOptionalInt64) - msg.optionalInt64 = 2 - XCTAssertTrue(msg.hasOptionalInt64) - XCTAssertEqual(msg.optionalInt64, 2) - msg.clearOptionalInt64() - XCTAssertEqual(msg.optionalInt64, 0) - XCTAssertFalse(msg.hasOptionalInt64) - } - - func testOptionalUint32() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalUint32, 0) - XCTAssertFalse(msg.hasOptionalUint32) - msg.optionalUint32 = 3 - XCTAssertTrue(msg.hasOptionalUint32) - XCTAssertEqual(msg.optionalUint32, 3) - msg.clearOptionalUint32() - XCTAssertEqual(msg.optionalUint32, 0) - XCTAssertFalse(msg.hasOptionalUint32) - } - - func testOptionalUint64() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalUint64, 0) - XCTAssertFalse(msg.hasOptionalUint64) - msg.optionalUint64 = 4 - XCTAssertTrue(msg.hasOptionalUint64) - XCTAssertEqual(msg.optionalUint64, 4) - msg.clearOptionalUint64() - XCTAssertEqual(msg.optionalUint64, 0) - XCTAssertFalse(msg.hasOptionalUint64) - } - - func testOptionalSint32() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalSint32, 0) - XCTAssertFalse(msg.hasOptionalSint32) - msg.optionalSint32 = 5 - XCTAssertTrue(msg.hasOptionalSint32) - XCTAssertEqual(msg.optionalSint32, 5) - msg.clearOptionalSint32() - XCTAssertEqual(msg.optionalSint32, 0) - XCTAssertFalse(msg.hasOptionalSint32) - } - - func testOptionalSint64() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalSint64, 0) - XCTAssertFalse(msg.hasOptionalSint64) - msg.optionalSint64 = 6 - XCTAssertTrue(msg.hasOptionalSint64) - XCTAssertEqual(msg.optionalSint64, 6) - msg.clearOptionalSint64() - XCTAssertEqual(msg.optionalSint64, 0) - XCTAssertFalse(msg.hasOptionalSint64) - } - - func testOptionalFixed32() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalFixed32, 0) - XCTAssertFalse(msg.hasOptionalFixed32) - msg.optionalFixed32 = 7 - XCTAssertTrue(msg.hasOptionalFixed32) - XCTAssertEqual(msg.optionalFixed32, 7) - msg.clearOptionalFixed32() - XCTAssertEqual(msg.optionalFixed32, 0) - XCTAssertFalse(msg.hasOptionalFixed32) - } - - func testOptionalFixed64() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalFixed64, 0) - XCTAssertFalse(msg.hasOptionalFixed64) - msg.optionalFixed64 = 8 - XCTAssertTrue(msg.hasOptionalFixed64) - XCTAssertEqual(msg.optionalFixed64, 8) - msg.clearOptionalFixed64() - XCTAssertEqual(msg.optionalFixed64, 0) - XCTAssertFalse(msg.hasOptionalFixed64) - } - - func testOptionalSfixed32() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalSfixed32, 0) - XCTAssertFalse(msg.hasOptionalSfixed32) - msg.optionalSfixed32 = 9 - XCTAssertTrue(msg.hasOptionalSfixed32) - XCTAssertEqual(msg.optionalSfixed32, 9) - msg.clearOptionalSfixed32() - XCTAssertEqual(msg.optionalSfixed32, 0) - XCTAssertFalse(msg.hasOptionalSfixed32) - } - - func testOptionalSfixed64() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalSfixed64, 0) - XCTAssertFalse(msg.hasOptionalSfixed64) - msg.optionalSfixed64 = 10 - XCTAssertTrue(msg.hasOptionalSfixed64) - XCTAssertEqual(msg.optionalSfixed64, 10) - msg.clearOptionalSfixed64() - XCTAssertEqual(msg.optionalSfixed64, 0) - XCTAssertFalse(msg.hasOptionalSfixed64) - } - - func testOptionalFloat() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalFloat, 0.0) - XCTAssertFalse(msg.hasOptionalFloat) - msg.optionalFloat = 11.0 - XCTAssertTrue(msg.hasOptionalFloat) - XCTAssertEqual(msg.optionalFloat, 11.0) - msg.clearOptionalFloat() - XCTAssertEqual(msg.optionalFloat, 0.0) - XCTAssertFalse(msg.hasOptionalFloat) - } - - func testOptionalDouble() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalDouble, 0.0) - XCTAssertFalse(msg.hasOptionalDouble) - msg.optionalDouble = 12.0 - XCTAssertTrue(msg.hasOptionalDouble) - XCTAssertEqual(msg.optionalDouble, 12.0) - msg.clearOptionalDouble() - XCTAssertEqual(msg.optionalDouble, 0.0) - XCTAssertFalse(msg.hasOptionalDouble) - } - - func testOptionalBool() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalBool, false) - XCTAssertFalse(msg.hasOptionalBool) - msg.optionalBool = true - XCTAssertTrue(msg.hasOptionalBool) - XCTAssertEqual(msg.optionalBool, true) - msg.clearOptionalBool() - XCTAssertEqual(msg.optionalBool, false) - XCTAssertFalse(msg.hasOptionalBool) - } - - func testOptionalString() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalString, "") - XCTAssertFalse(msg.hasOptionalString) - msg.optionalString = "14" - XCTAssertTrue(msg.hasOptionalString) - XCTAssertEqual(msg.optionalString, "14") - msg.clearOptionalString() - XCTAssertEqual(msg.optionalString, "") - XCTAssertFalse(msg.hasOptionalString) - } - - func testOptionalBytes() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalBytes, Data()) - XCTAssertFalse(msg.hasOptionalBytes) - msg.optionalBytes = Data([15]) - XCTAssertTrue(msg.hasOptionalBytes) - XCTAssertEqual(msg.optionalBytes, Data([15])) - msg.clearOptionalBytes() - XCTAssertEqual(msg.optionalBytes, Data()) - XCTAssertFalse(msg.hasOptionalBytes) - } - - func testOptionalGroup() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalGroup.a, 0) - XCTAssertFalse(msg.hasOptionalGroup) - var grp = ProtobufUnittest_TestAllTypes.OptionalGroup() - grp.a = 16 - msg.optionalGroup = grp - XCTAssertTrue(msg.hasOptionalGroup) - XCTAssertEqual(msg.optionalGroup.a, 16) - msg.clearOptionalGroup() - XCTAssertEqual(msg.optionalGroup.a, 0) - XCTAssertFalse(msg.hasOptionalGroup) - } - - func testOptionalNestedMessage() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalNestedMessage.bb, 0) - XCTAssertFalse(msg.hasOptionalNestedMessage) - var nestedMsg = ProtobufUnittest_TestAllTypes.NestedMessage() - nestedMsg.bb = 18 - msg.optionalNestedMessage = nestedMsg - XCTAssertTrue(msg.hasOptionalNestedMessage) - XCTAssertEqual(msg.optionalNestedMessage.bb, 18) - XCTAssertEqual(msg.optionalNestedMessage, nestedMsg) - msg.clearOptionalNestedMessage() - XCTAssertEqual(msg.optionalNestedMessage.bb, 0) - XCTAssertFalse(msg.hasOptionalNestedMessage) - } - - func testOptionalForeignMessage() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalForeignMessage.c, 0) - XCTAssertFalse(msg.hasOptionalForeignMessage) - var foreignMsg = ProtobufUnittest_ForeignMessage() - foreignMsg.c = 19 - msg.optionalForeignMessage = foreignMsg - XCTAssertTrue(msg.hasOptionalForeignMessage) - XCTAssertEqual(msg.optionalForeignMessage.c, 19) - XCTAssertEqual(msg.optionalForeignMessage, foreignMsg) - msg.clearOptionalForeignMessage() - XCTAssertEqual(msg.optionalForeignMessage.c, 0) - XCTAssertFalse(msg.hasOptionalForeignMessage) - } - - func testOptionalImportMessage() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalImportMessage.d, 0) - XCTAssertFalse(msg.hasOptionalImportMessage) - var importedMsg = ProtobufUnittestImport_ImportMessage() - importedMsg.d = 20 - msg.optionalImportMessage = importedMsg - XCTAssertTrue(msg.hasOptionalImportMessage) - XCTAssertEqual(msg.optionalImportMessage.d, 20) - XCTAssertEqual(msg.optionalImportMessage, importedMsg) - msg.clearOptionalImportMessage() - XCTAssertEqual(msg.optionalImportMessage.d, 0) - XCTAssertFalse(msg.hasOptionalImportMessage) - } - - func testOptionalNestedEnum() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalNestedEnum, .foo) - XCTAssertFalse(msg.hasOptionalNestedEnum) - msg.optionalNestedEnum = .bar - XCTAssertTrue(msg.hasOptionalNestedEnum) - XCTAssertEqual(msg.optionalNestedEnum, .bar) - msg.clearOptionalNestedEnum() - XCTAssertEqual(msg.optionalNestedEnum, .foo) - XCTAssertFalse(msg.hasOptionalNestedEnum) - } - - func testOptionalForeignEnum() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalForeignEnum, .foreignFoo) - XCTAssertFalse(msg.hasOptionalForeignEnum) - msg.optionalForeignEnum = .foreignBar - XCTAssertTrue(msg.hasOptionalForeignEnum) - XCTAssertEqual(msg.optionalForeignEnum, .foreignBar) - msg.clearOptionalForeignEnum() - XCTAssertEqual(msg.optionalForeignEnum, .foreignFoo) - XCTAssertFalse(msg.hasOptionalForeignEnum) - } - - func testOptionalImportEnum() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalImportEnum, .importFoo) - XCTAssertFalse(msg.hasOptionalImportEnum) - msg.optionalImportEnum = .importBar - XCTAssertTrue(msg.hasOptionalImportEnum) - XCTAssertEqual(msg.optionalImportEnum, .importBar) - msg.clearOptionalImportEnum() - XCTAssertEqual(msg.optionalImportEnum, .importFoo) - XCTAssertFalse(msg.hasOptionalImportEnum) - } - - func testOptionalStringPiece() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalStringPiece, "") - XCTAssertFalse(msg.hasOptionalStringPiece) - msg.optionalStringPiece = "24" - XCTAssertTrue(msg.hasOptionalStringPiece) - XCTAssertEqual(msg.optionalStringPiece, "24") - msg.clearOptionalStringPiece() - XCTAssertEqual(msg.optionalStringPiece, "") - XCTAssertFalse(msg.hasOptionalStringPiece) - } - - func testOptionalCord() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalCord, "") - XCTAssertFalse(msg.hasOptionalCord) - msg.optionalCord = "25" - XCTAssertTrue(msg.hasOptionalCord) - XCTAssertEqual(msg.optionalCord, "25") - msg.clearOptionalCord() - XCTAssertEqual(msg.optionalCord, "") - XCTAssertFalse(msg.hasOptionalCord) - } - - func testOptionalPublicImportMessage() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalPublicImportMessage.e, 0) - XCTAssertFalse(msg.hasOptionalPublicImportMessage) - var pubImportedMsg = ProtobufUnittestImport_PublicImportMessage() - pubImportedMsg.e = 26 - msg.optionalPublicImportMessage = pubImportedMsg - XCTAssertTrue(msg.hasOptionalPublicImportMessage) - XCTAssertEqual(msg.optionalPublicImportMessage.e, 26) - XCTAssertEqual(msg.optionalPublicImportMessage, pubImportedMsg) - msg.clearOptionalPublicImportMessage() - XCTAssertEqual(msg.optionalPublicImportMessage.e, 0) - XCTAssertFalse(msg.hasOptionalPublicImportMessage) - } - - func testOptionalLazyMessage() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.optionalLazyMessage.bb, 0) - XCTAssertFalse(msg.hasOptionalLazyMessage) - var nestedMsg = ProtobufUnittest_TestAllTypes.NestedMessage() - nestedMsg.bb = 27 - msg.optionalLazyMessage = nestedMsg - XCTAssertTrue(msg.hasOptionalLazyMessage) - XCTAssertEqual(msg.optionalLazyMessage.bb, 27) - XCTAssertEqual(msg.optionalLazyMessage, nestedMsg) - msg.clearOptionalLazyMessage() - XCTAssertEqual(msg.optionalLazyMessage.bb, 0) - XCTAssertFalse(msg.hasOptionalLazyMessage) - } - - // Optional with explicit default values (non zero) - - func testDefaultInt32() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultInt32, 41) - XCTAssertFalse(msg.hasDefaultInt32) - msg.defaultInt32 = 61 - XCTAssertTrue(msg.hasDefaultInt32) - XCTAssertEqual(msg.defaultInt32, 61) - msg.clearDefaultInt32() - XCTAssertEqual(msg.defaultInt32, 41) - XCTAssertFalse(msg.hasDefaultInt32) - } - - func testDefaultInt64() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultInt64, 42) - XCTAssertFalse(msg.hasDefaultInt64) - msg.defaultInt64 = 62 - XCTAssertTrue(msg.hasDefaultInt64) - XCTAssertEqual(msg.defaultInt64, 62) - msg.clearDefaultInt64() - XCTAssertEqual(msg.defaultInt64, 42) - XCTAssertFalse(msg.hasDefaultInt64) - } - - func testDefaultUint32() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultUint32, 43) - XCTAssertFalse(msg.hasDefaultUint32) - msg.defaultUint32 = 63 - XCTAssertTrue(msg.hasDefaultUint32) - XCTAssertEqual(msg.defaultUint32, 63) - msg.clearDefaultUint32() - XCTAssertEqual(msg.defaultUint32, 43) - XCTAssertFalse(msg.hasDefaultUint32) - } - - func testDefaultUint64() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultUint64, 44) - XCTAssertFalse(msg.hasDefaultUint64) - msg.defaultUint64 = 64 - XCTAssertTrue(msg.hasDefaultUint64) - XCTAssertEqual(msg.defaultUint64, 64) - msg.clearDefaultUint64() - XCTAssertEqual(msg.defaultUint64, 44) - XCTAssertFalse(msg.hasDefaultUint64) - } - - func testDefaultSint32() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultSint32, -45) - XCTAssertFalse(msg.hasDefaultSint32) - msg.defaultSint32 = 65 - XCTAssertTrue(msg.hasDefaultSint32) - XCTAssertEqual(msg.defaultSint32, 65) - msg.clearDefaultSint32() - XCTAssertEqual(msg.defaultSint32, -45) - XCTAssertFalse(msg.hasDefaultSint32) - } - - func testDefaultSint64() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultSint64, 46) - XCTAssertFalse(msg.hasDefaultSint64) - msg.defaultSint64 = 66 - XCTAssertTrue(msg.hasDefaultSint64) - XCTAssertEqual(msg.defaultSint64, 66) - msg.clearDefaultSint64() - XCTAssertEqual(msg.defaultSint64, 46) - XCTAssertFalse(msg.hasDefaultSint64) - } - - func testDefaultFixed32() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultFixed32, 47) - XCTAssertFalse(msg.hasDefaultFixed32) - msg.defaultFixed32 = 67 - XCTAssertTrue(msg.hasDefaultFixed32) - XCTAssertEqual(msg.defaultFixed32, 67) - msg.clearDefaultFixed32() - XCTAssertEqual(msg.defaultFixed32, 47) - XCTAssertFalse(msg.hasDefaultFixed32) - } - - func testDefaultFixed64() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultFixed64, 48) - XCTAssertFalse(msg.hasDefaultFixed64) - msg.defaultFixed64 = 68 - XCTAssertTrue(msg.hasDefaultFixed64) - XCTAssertEqual(msg.defaultFixed64, 68) - msg.clearDefaultFixed64() - XCTAssertEqual(msg.defaultFixed64, 48) - XCTAssertFalse(msg.hasDefaultFixed64) - } - - func testDefaultSfixed32() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultSfixed32, 49) - XCTAssertFalse(msg.hasDefaultSfixed32) - msg.defaultSfixed32 = 69 - XCTAssertTrue(msg.hasDefaultSfixed32) - XCTAssertEqual(msg.defaultSfixed32, 69) - msg.clearDefaultSfixed32() - XCTAssertEqual(msg.defaultSfixed32, 49) - XCTAssertFalse(msg.hasDefaultSfixed32) - } - - func testDefaultSfixed64() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultSfixed64, -50) - XCTAssertFalse(msg.hasDefaultSfixed64) - msg.defaultSfixed64 = 70 - XCTAssertTrue(msg.hasDefaultSfixed64) - XCTAssertEqual(msg.defaultSfixed64, 70) - msg.clearDefaultSfixed64() - XCTAssertEqual(msg.defaultSfixed64, -50) - XCTAssertFalse(msg.hasDefaultSfixed64) - } - - func testDefaultFloat() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultFloat, 51.5) - XCTAssertFalse(msg.hasDefaultFloat) - msg.defaultFloat = 71 - XCTAssertTrue(msg.hasDefaultFloat) - XCTAssertEqual(msg.defaultFloat, 71) - msg.clearDefaultFloat() - XCTAssertEqual(msg.defaultFloat, 51.5) - XCTAssertFalse(msg.hasDefaultFloat) - } - - func testDefaultDouble() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultDouble, 52e3) - XCTAssertFalse(msg.hasDefaultDouble) - msg.defaultDouble = 72 - XCTAssertTrue(msg.hasDefaultDouble) - XCTAssertEqual(msg.defaultDouble, 72) - msg.clearDefaultDouble() - XCTAssertEqual(msg.defaultDouble, 52e3) - XCTAssertFalse(msg.hasDefaultDouble) - } - - func testDefaultBool() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultBool, true) - XCTAssertFalse(msg.hasDefaultBool) - msg.defaultBool = false - XCTAssertTrue(msg.hasDefaultBool) - XCTAssertEqual(msg.defaultBool, false) - msg.clearDefaultBool() - XCTAssertEqual(msg.defaultBool, true) - XCTAssertFalse(msg.hasDefaultBool) - } - - func testDefaultString() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultString, "hello") - XCTAssertFalse(msg.hasDefaultString) - msg.defaultString = "74" - XCTAssertTrue(msg.hasDefaultString) - XCTAssertEqual(msg.defaultString, "74") - msg.clearDefaultString() - XCTAssertEqual(msg.defaultString, "hello") - XCTAssertFalse(msg.hasDefaultString) - } - - func testDefaultBytes() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultBytes, "world".data(using: .utf8)) - XCTAssertFalse(msg.hasDefaultBytes) - msg.defaultBytes = Data([75]) - XCTAssertTrue(msg.hasDefaultBytes) - XCTAssertEqual(msg.defaultBytes, Data([75])) - msg.clearDefaultBytes() - XCTAssertEqual(msg.defaultBytes, "world".data(using: .utf8)) - XCTAssertFalse(msg.hasDefaultBytes) - } - - func testDefaultNestedEnum() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultNestedEnum, .bar) - XCTAssertFalse(msg.hasDefaultNestedEnum) - msg.defaultNestedEnum = .baz - XCTAssertTrue(msg.hasDefaultNestedEnum) - XCTAssertEqual(msg.defaultNestedEnum, .baz) - msg.clearDefaultNestedEnum() - XCTAssertEqual(msg.defaultNestedEnum, .bar) - XCTAssertFalse(msg.hasDefaultNestedEnum) - } - - func testDefaultForeignEnum() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultForeignEnum, .foreignBar) - XCTAssertFalse(msg.hasDefaultForeignEnum) - msg.defaultForeignEnum = .foreignBaz - XCTAssertTrue(msg.hasDefaultForeignEnum) - XCTAssertEqual(msg.defaultForeignEnum, .foreignBaz) - msg.clearDefaultForeignEnum() - XCTAssertEqual(msg.defaultForeignEnum, .foreignBar) - XCTAssertFalse(msg.hasDefaultForeignEnum) - } - - func testDefaultImportEnum() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultImportEnum, .importBar) - XCTAssertFalse(msg.hasDefaultImportEnum) - msg.defaultImportEnum = .importBaz - XCTAssertTrue(msg.hasDefaultImportEnum) - XCTAssertEqual(msg.defaultImportEnum, .importBaz) - msg.clearDefaultImportEnum() - XCTAssertEqual(msg.defaultImportEnum, .importBar) - XCTAssertFalse(msg.hasDefaultImportEnum) - } - - func testDefaultStringPiece() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultStringPiece, "abc") - XCTAssertFalse(msg.hasDefaultStringPiece) - msg.defaultStringPiece = "84" - XCTAssertTrue(msg.hasDefaultStringPiece) - XCTAssertEqual(msg.defaultStringPiece, "84") - msg.clearDefaultStringPiece() - XCTAssertEqual(msg.defaultStringPiece, "abc") - XCTAssertFalse(msg.hasDefaultStringPiece) - } - - func testDefaultCord() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.defaultCord, "123") - XCTAssertFalse(msg.hasDefaultCord) - msg.defaultCord = "85" - XCTAssertTrue(msg.hasDefaultCord) - XCTAssertEqual(msg.defaultCord, "85") - msg.clearDefaultCord() - XCTAssertEqual(msg.defaultCord, "123") - XCTAssertFalse(msg.hasDefaultCord) - } - - // Repeated - - func testRepeatedInt32() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedInt32, []) - msg.repeatedInt32 = [31] - XCTAssertEqual(msg.repeatedInt32, [31]) - msg.repeatedInt32.append(131) - XCTAssertEqual(msg.repeatedInt32, [31, 131]) - } - - func testRepeatedInt64() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedInt64, []) - msg.repeatedInt64 = [32] - XCTAssertEqual(msg.repeatedInt64, [32]) - msg.repeatedInt64.append(132) - XCTAssertEqual(msg.repeatedInt64, [32, 132]) - } - - func testRepeatedUint32() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedUint32, []) - msg.repeatedUint32 = [33] - XCTAssertEqual(msg.repeatedUint32, [33]) - msg.repeatedUint32.append(133) - XCTAssertEqual(msg.repeatedUint32, [33, 133]) - } - - func testRepeatedUint64() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedUint64, []) - msg.repeatedUint64 = [34] - XCTAssertEqual(msg.repeatedUint64, [34]) - msg.repeatedUint64.append(134) - XCTAssertEqual(msg.repeatedUint64, [34, 134]) - } - - func testRepeatedSint32() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedSint32, []) - msg.repeatedSint32 = [35] - XCTAssertEqual(msg.repeatedSint32, [35]) - msg.repeatedSint32.append(135) - XCTAssertEqual(msg.repeatedSint32, [35, 135]) - } - - func testRepeatedSint64() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedSint64, []) - msg.repeatedSint64 = [36] - XCTAssertEqual(msg.repeatedSint64, [36]) - msg.repeatedSint64.append(136) - XCTAssertEqual(msg.repeatedSint64, [36, 136]) - } - - func testRepeatedFixed32() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedFixed32, []) - msg.repeatedFixed32 = [37] - XCTAssertEqual(msg.repeatedFixed32, [37]) - msg.repeatedFixed32.append(137) - XCTAssertEqual(msg.repeatedFixed32, [37, 137]) - } - - func testRepeatedFixed64() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedFixed64, []) - msg.repeatedFixed64 = [38] - XCTAssertEqual(msg.repeatedFixed64, [38]) - msg.repeatedFixed64.append(138) - XCTAssertEqual(msg.repeatedFixed64, [38, 138]) - } - - func testRepeatedSfixed32() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedSfixed32, []) - msg.repeatedSfixed32 = [39] - XCTAssertEqual(msg.repeatedSfixed32, [39]) - msg.repeatedSfixed32.append(139) - XCTAssertEqual(msg.repeatedSfixed32, [39, 139]) - } - - func testRepeatedSfixed64() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedSfixed64, []) - msg.repeatedSfixed64 = [40] - XCTAssertEqual(msg.repeatedSfixed64, [40]) - msg.repeatedSfixed64.append(140) - XCTAssertEqual(msg.repeatedSfixed64, [40, 140]) - } - - func testRepeatedFloat() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedFloat, []) - msg.repeatedFloat = [41.0] - XCTAssertEqual(msg.repeatedFloat, [41.0]) - msg.repeatedFloat.append(141.0) - XCTAssertEqual(msg.repeatedFloat, [41.0, 141.0]) - } - - func testRepeatedDouble() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedDouble, []) - msg.repeatedDouble = [42.0] - XCTAssertEqual(msg.repeatedDouble, [42.0]) - msg.repeatedDouble.append(142.0) - XCTAssertEqual(msg.repeatedDouble, [42.0, 142.0]) - } - - func testRepeatedBool() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedBool, []) - msg.repeatedBool = [true] - XCTAssertEqual(msg.repeatedBool, [true]) - msg.repeatedBool.append(false) - XCTAssertEqual(msg.repeatedBool, [true, false]) - } - - func testRepeatedString() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedString, []) - msg.repeatedString = ["44"] - XCTAssertEqual(msg.repeatedString, ["44"]) - msg.repeatedString.append("144") - XCTAssertEqual(msg.repeatedString, ["44", "144"]) - } - - func testRepeatedBytes() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedBytes, []) - msg.repeatedBytes = [Data([45])] - XCTAssertEqual(msg.repeatedBytes, [Data([45])]) - msg.repeatedBytes.append(Data([145])) - XCTAssertEqual(msg.repeatedBytes, [Data([45]), Data([145])]) - } - - func testRepeatedGroup() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedGroup, []) - var grp = ProtobufUnittest_TestAllTypes.RepeatedGroup() - grp.a = 46 - msg.repeatedGroup = [grp] - XCTAssertEqual(msg.repeatedGroup.count, 1) - XCTAssertEqual(msg.repeatedGroup[0].a, 46) - XCTAssertEqual(msg.repeatedGroup, [grp]) - var grp2 = ProtobufUnittest_TestAllTypes.RepeatedGroup() - grp2.a = 146 - msg.repeatedGroup.append(grp2) - XCTAssertEqual(msg.repeatedGroup.count, 2) - XCTAssertEqual(msg.repeatedGroup[0].a, 46) - XCTAssertEqual(msg.repeatedGroup[1].a, 146) - XCTAssertEqual(msg.repeatedGroup, [grp, grp2]) - } - - func testRepeatedNestedMessage() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedNestedMessage, []) - var nestedMsg = ProtobufUnittest_TestAllTypes.NestedMessage() - nestedMsg.bb = 48 - msg.repeatedNestedMessage = [nestedMsg] - XCTAssertEqual(msg.repeatedNestedMessage.count, 1) - XCTAssertEqual(msg.repeatedNestedMessage[0].bb, 48) - XCTAssertEqual(msg.repeatedNestedMessage, [nestedMsg]) - var nestedMsg2 = ProtobufUnittest_TestAllTypes.NestedMessage() - nestedMsg2.bb = 148 - msg.repeatedNestedMessage.append(nestedMsg2) - XCTAssertEqual(msg.repeatedNestedMessage.count, 2) - XCTAssertEqual(msg.repeatedNestedMessage[0].bb, 48) - XCTAssertEqual(msg.repeatedNestedMessage[1].bb, 148) - XCTAssertEqual(msg.repeatedNestedMessage, [nestedMsg, nestedMsg2]) - } - - func testRepeatedForeignMessage() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedForeignMessage, []) - var foreignMsg = ProtobufUnittest_ForeignMessage() - foreignMsg.c = 49 - msg.repeatedForeignMessage = [foreignMsg] - XCTAssertEqual(msg.repeatedForeignMessage.count, 1) - XCTAssertEqual(msg.repeatedForeignMessage[0].c, 49) - XCTAssertEqual(msg.repeatedForeignMessage, [foreignMsg]) - var foreignMsg2 = ProtobufUnittest_ForeignMessage() - foreignMsg2.c = 149 - msg.repeatedForeignMessage.append(foreignMsg2) - XCTAssertEqual(msg.repeatedForeignMessage.count, 2) - XCTAssertEqual(msg.repeatedForeignMessage[0].c, 49) - XCTAssertEqual(msg.repeatedForeignMessage[1].c, 149) - XCTAssertEqual(msg.repeatedForeignMessage, [foreignMsg, foreignMsg2]) - } - - func testRepeatedImportMessage() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedImportMessage, []) - var importedMsg = ProtobufUnittestImport_ImportMessage() - importedMsg.d = 50 - msg.repeatedImportMessage = [importedMsg] - XCTAssertEqual(msg.repeatedImportMessage.count, 1) - XCTAssertEqual(msg.repeatedImportMessage[0].d, 50) - XCTAssertEqual(msg.repeatedImportMessage, [importedMsg]) - var importedMsg2 = ProtobufUnittestImport_ImportMessage() - importedMsg2.d = 150 - msg.repeatedImportMessage.append(importedMsg2) - XCTAssertEqual(msg.repeatedImportMessage.count, 2) - XCTAssertEqual(msg.repeatedImportMessage[0].d, 50) - XCTAssertEqual(msg.repeatedImportMessage[1].d, 150) - XCTAssertEqual(msg.repeatedImportMessage, [importedMsg, importedMsg2]) - } - - func testRepeatedNestedEnum() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedNestedEnum, []) - msg.repeatedNestedEnum = [.bar] - XCTAssertEqual(msg.repeatedNestedEnum, [.bar]) - msg.repeatedNestedEnum.append(.baz) - XCTAssertEqual(msg.repeatedNestedEnum, [.bar, .baz]) - } - - func testRepeatedForeignEnum() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedForeignEnum, []) - msg.repeatedForeignEnum = [.foreignBar] - XCTAssertEqual(msg.repeatedForeignEnum, [.foreignBar]) - msg.repeatedForeignEnum.append(.foreignBaz) - XCTAssertEqual(msg.repeatedForeignEnum, [.foreignBar, .foreignBaz]) - } - - func testRepeatedImportEnum() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedImportEnum, []) - msg.repeatedImportEnum = [.importBar] - XCTAssertEqual(msg.repeatedImportEnum, [.importBar]) - msg.repeatedImportEnum.append(.importBaz) - XCTAssertEqual(msg.repeatedImportEnum, [.importBar, .importBaz]) - } - - func testRepeatedStringPiece() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedStringPiece, []) - msg.repeatedStringPiece = ["54"] - XCTAssertEqual(msg.repeatedStringPiece, ["54"]) - msg.repeatedStringPiece.append("154") - XCTAssertEqual(msg.repeatedStringPiece, ["54", "154"]) - } - - func testRepeatedCord() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedCord, []) - msg.repeatedCord = ["55"] - XCTAssertEqual(msg.repeatedCord, ["55"]) - msg.repeatedCord.append("155") - XCTAssertEqual(msg.repeatedCord, ["55", "155"]) - } - - func testRepeatedLazyMessage() { - var msg = ProtobufUnittest_TestAllTypes() - XCTAssertEqual(msg.repeatedLazyMessage, []) - var nestedMsg = ProtobufUnittest_TestAllTypes.NestedMessage() - nestedMsg.bb = 57 - msg.repeatedLazyMessage = [nestedMsg] - XCTAssertEqual(msg.repeatedLazyMessage.count, 1) - XCTAssertEqual(msg.repeatedLazyMessage[0].bb, 57) - XCTAssertEqual(msg.repeatedLazyMessage, [nestedMsg]) - var nestedMsg2 = ProtobufUnittest_TestAllTypes.NestedMessage() - nestedMsg2.bb = 157 - msg.repeatedLazyMessage.append(nestedMsg2) - XCTAssertEqual(msg.repeatedLazyMessage.count, 2) - XCTAssertEqual(msg.repeatedLazyMessage[0].bb, 57) - XCTAssertEqual(msg.repeatedLazyMessage[1].bb, 157) - XCTAssertEqual(msg.repeatedLazyMessage, [nestedMsg, nestedMsg2]) - } +final class Test_BasicFields_Access_Proto2: XCTestCase { + + // Optional + + func testOptionalInt32() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalInt32, 0) + XCTAssertFalse(msg.hasOptionalInt32) + msg.optionalInt32 = 1 + XCTAssertTrue(msg.hasOptionalInt32) + XCTAssertEqual(msg.optionalInt32, 1) + msg.clearOptionalInt32() + XCTAssertEqual(msg.optionalInt32, 0) + XCTAssertFalse(msg.hasOptionalInt32) + } + + func testOptionalInt64() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalInt64, 0) + XCTAssertFalse(msg.hasOptionalInt64) + msg.optionalInt64 = 2 + XCTAssertTrue(msg.hasOptionalInt64) + XCTAssertEqual(msg.optionalInt64, 2) + msg.clearOptionalInt64() + XCTAssertEqual(msg.optionalInt64, 0) + XCTAssertFalse(msg.hasOptionalInt64) + } + + func testOptionalUint32() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalUint32, 0) + XCTAssertFalse(msg.hasOptionalUint32) + msg.optionalUint32 = 3 + XCTAssertTrue(msg.hasOptionalUint32) + XCTAssertEqual(msg.optionalUint32, 3) + msg.clearOptionalUint32() + XCTAssertEqual(msg.optionalUint32, 0) + XCTAssertFalse(msg.hasOptionalUint32) + } + + func testOptionalUint64() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalUint64, 0) + XCTAssertFalse(msg.hasOptionalUint64) + msg.optionalUint64 = 4 + XCTAssertTrue(msg.hasOptionalUint64) + XCTAssertEqual(msg.optionalUint64, 4) + msg.clearOptionalUint64() + XCTAssertEqual(msg.optionalUint64, 0) + XCTAssertFalse(msg.hasOptionalUint64) + } + + func testOptionalSint32() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalSint32, 0) + XCTAssertFalse(msg.hasOptionalSint32) + msg.optionalSint32 = 5 + XCTAssertTrue(msg.hasOptionalSint32) + XCTAssertEqual(msg.optionalSint32, 5) + msg.clearOptionalSint32() + XCTAssertEqual(msg.optionalSint32, 0) + XCTAssertFalse(msg.hasOptionalSint32) + } + + func testOptionalSint64() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalSint64, 0) + XCTAssertFalse(msg.hasOptionalSint64) + msg.optionalSint64 = 6 + XCTAssertTrue(msg.hasOptionalSint64) + XCTAssertEqual(msg.optionalSint64, 6) + msg.clearOptionalSint64() + XCTAssertEqual(msg.optionalSint64, 0) + XCTAssertFalse(msg.hasOptionalSint64) + } + + func testOptionalFixed32() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalFixed32, 0) + XCTAssertFalse(msg.hasOptionalFixed32) + msg.optionalFixed32 = 7 + XCTAssertTrue(msg.hasOptionalFixed32) + XCTAssertEqual(msg.optionalFixed32, 7) + msg.clearOptionalFixed32() + XCTAssertEqual(msg.optionalFixed32, 0) + XCTAssertFalse(msg.hasOptionalFixed32) + } + + func testOptionalFixed64() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalFixed64, 0) + XCTAssertFalse(msg.hasOptionalFixed64) + msg.optionalFixed64 = 8 + XCTAssertTrue(msg.hasOptionalFixed64) + XCTAssertEqual(msg.optionalFixed64, 8) + msg.clearOptionalFixed64() + XCTAssertEqual(msg.optionalFixed64, 0) + XCTAssertFalse(msg.hasOptionalFixed64) + } + + func testOptionalSfixed32() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalSfixed32, 0) + XCTAssertFalse(msg.hasOptionalSfixed32) + msg.optionalSfixed32 = 9 + XCTAssertTrue(msg.hasOptionalSfixed32) + XCTAssertEqual(msg.optionalSfixed32, 9) + msg.clearOptionalSfixed32() + XCTAssertEqual(msg.optionalSfixed32, 0) + XCTAssertFalse(msg.hasOptionalSfixed32) + } + + func testOptionalSfixed64() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalSfixed64, 0) + XCTAssertFalse(msg.hasOptionalSfixed64) + msg.optionalSfixed64 = 10 + XCTAssertTrue(msg.hasOptionalSfixed64) + XCTAssertEqual(msg.optionalSfixed64, 10) + msg.clearOptionalSfixed64() + XCTAssertEqual(msg.optionalSfixed64, 0) + XCTAssertFalse(msg.hasOptionalSfixed64) + } + + func testOptionalFloat() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalFloat, 0.0) + XCTAssertFalse(msg.hasOptionalFloat) + msg.optionalFloat = 11.0 + XCTAssertTrue(msg.hasOptionalFloat) + XCTAssertEqual(msg.optionalFloat, 11.0) + msg.clearOptionalFloat() + XCTAssertEqual(msg.optionalFloat, 0.0) + XCTAssertFalse(msg.hasOptionalFloat) + } + + func testOptionalDouble() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalDouble, 0.0) + XCTAssertFalse(msg.hasOptionalDouble) + msg.optionalDouble = 12.0 + XCTAssertTrue(msg.hasOptionalDouble) + XCTAssertEqual(msg.optionalDouble, 12.0) + msg.clearOptionalDouble() + XCTAssertEqual(msg.optionalDouble, 0.0) + XCTAssertFalse(msg.hasOptionalDouble) + } + + func testOptionalBool() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalBool, false) + XCTAssertFalse(msg.hasOptionalBool) + msg.optionalBool = true + XCTAssertTrue(msg.hasOptionalBool) + XCTAssertEqual(msg.optionalBool, true) + msg.clearOptionalBool() + XCTAssertEqual(msg.optionalBool, false) + XCTAssertFalse(msg.hasOptionalBool) + } + + func testOptionalString() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalString, "") + XCTAssertFalse(msg.hasOptionalString) + msg.optionalString = "14" + XCTAssertTrue(msg.hasOptionalString) + XCTAssertEqual(msg.optionalString, "14") + msg.clearOptionalString() + XCTAssertEqual(msg.optionalString, "") + XCTAssertFalse(msg.hasOptionalString) + } + + func testOptionalBytes() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalBytes, Data()) + XCTAssertFalse(msg.hasOptionalBytes) + msg.optionalBytes = Data([15]) + XCTAssertTrue(msg.hasOptionalBytes) + XCTAssertEqual(msg.optionalBytes, Data([15])) + msg.clearOptionalBytes() + XCTAssertEqual(msg.optionalBytes, Data()) + XCTAssertFalse(msg.hasOptionalBytes) + } + + func testOptionalGroup() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalGroup.a, 0) + XCTAssertFalse(msg.hasOptionalGroup) + var grp = SwiftProtoTesting_TestAllTypes.OptionalGroup() + grp.a = 16 + msg.optionalGroup = grp + XCTAssertTrue(msg.hasOptionalGroup) + XCTAssertEqual(msg.optionalGroup.a, 16) + msg.clearOptionalGroup() + XCTAssertEqual(msg.optionalGroup.a, 0) + XCTAssertFalse(msg.hasOptionalGroup) + } + + func testOptionalNestedMessage() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalNestedMessage.bb, 0) + XCTAssertFalse(msg.hasOptionalNestedMessage) + var nestedMsg = SwiftProtoTesting_TestAllTypes.NestedMessage() + nestedMsg.bb = 18 + msg.optionalNestedMessage = nestedMsg + XCTAssertTrue(msg.hasOptionalNestedMessage) + XCTAssertEqual(msg.optionalNestedMessage.bb, 18) + XCTAssertEqual(msg.optionalNestedMessage, nestedMsg) + msg.clearOptionalNestedMessage() + XCTAssertEqual(msg.optionalNestedMessage.bb, 0) + XCTAssertFalse(msg.hasOptionalNestedMessage) + } + + func testOptionalForeignMessage() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalForeignMessage.c, 0) + XCTAssertFalse(msg.hasOptionalForeignMessage) + var foreignMsg = SwiftProtoTesting_ForeignMessage() + foreignMsg.c = 19 + msg.optionalForeignMessage = foreignMsg + XCTAssertTrue(msg.hasOptionalForeignMessage) + XCTAssertEqual(msg.optionalForeignMessage.c, 19) + XCTAssertEqual(msg.optionalForeignMessage, foreignMsg) + msg.clearOptionalForeignMessage() + XCTAssertEqual(msg.optionalForeignMessage.c, 0) + XCTAssertFalse(msg.hasOptionalForeignMessage) + } + + func testOptionalImportMessage() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalImportMessage.d, 0) + XCTAssertFalse(msg.hasOptionalImportMessage) + var importedMsg = SwiftProtoTesting_Import_ImportMessage() + importedMsg.d = 20 + msg.optionalImportMessage = importedMsg + XCTAssertTrue(msg.hasOptionalImportMessage) + XCTAssertEqual(msg.optionalImportMessage.d, 20) + XCTAssertEqual(msg.optionalImportMessage, importedMsg) + msg.clearOptionalImportMessage() + XCTAssertEqual(msg.optionalImportMessage.d, 0) + XCTAssertFalse(msg.hasOptionalImportMessage) + } + + func testOptionalNestedEnum() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalNestedEnum, .foo) + XCTAssertFalse(msg.hasOptionalNestedEnum) + msg.optionalNestedEnum = .bar + XCTAssertTrue(msg.hasOptionalNestedEnum) + XCTAssertEqual(msg.optionalNestedEnum, .bar) + msg.clearOptionalNestedEnum() + XCTAssertEqual(msg.optionalNestedEnum, .foo) + XCTAssertFalse(msg.hasOptionalNestedEnum) + } + + func testOptionalForeignEnum() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalForeignEnum, .foreignFoo) + XCTAssertFalse(msg.hasOptionalForeignEnum) + msg.optionalForeignEnum = .foreignBar + XCTAssertTrue(msg.hasOptionalForeignEnum) + XCTAssertEqual(msg.optionalForeignEnum, .foreignBar) + msg.clearOptionalForeignEnum() + XCTAssertEqual(msg.optionalForeignEnum, .foreignFoo) + XCTAssertFalse(msg.hasOptionalForeignEnum) + } + + func testOptionalImportEnum() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalImportEnum, .importFoo) + XCTAssertFalse(msg.hasOptionalImportEnum) + msg.optionalImportEnum = .importBar + XCTAssertTrue(msg.hasOptionalImportEnum) + XCTAssertEqual(msg.optionalImportEnum, .importBar) + msg.clearOptionalImportEnum() + XCTAssertEqual(msg.optionalImportEnum, .importFoo) + XCTAssertFalse(msg.hasOptionalImportEnum) + } + + func testOptionalPublicImportMessage() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.optionalPublicImportMessage.e, 0) + XCTAssertFalse(msg.hasOptionalPublicImportMessage) + var pubImportedMsg = SwiftProtoTesting_Import_PublicImportMessage() + pubImportedMsg.e = 26 + msg.optionalPublicImportMessage = pubImportedMsg + XCTAssertTrue(msg.hasOptionalPublicImportMessage) + XCTAssertEqual(msg.optionalPublicImportMessage.e, 26) + XCTAssertEqual(msg.optionalPublicImportMessage, pubImportedMsg) + msg.clearOptionalPublicImportMessage() + XCTAssertEqual(msg.optionalPublicImportMessage.e, 0) + XCTAssertFalse(msg.hasOptionalPublicImportMessage) + } + + // Optional with explicit default values (non zero) + + func testDefaultInt32() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.defaultInt32, 41) + XCTAssertFalse(msg.hasDefaultInt32) + msg.defaultInt32 = 61 + XCTAssertTrue(msg.hasDefaultInt32) + XCTAssertEqual(msg.defaultInt32, 61) + msg.clearDefaultInt32() + XCTAssertEqual(msg.defaultInt32, 41) + XCTAssertFalse(msg.hasDefaultInt32) + } + + func testDefaultInt64() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.defaultInt64, 42) + XCTAssertFalse(msg.hasDefaultInt64) + msg.defaultInt64 = 62 + XCTAssertTrue(msg.hasDefaultInt64) + XCTAssertEqual(msg.defaultInt64, 62) + msg.clearDefaultInt64() + XCTAssertEqual(msg.defaultInt64, 42) + XCTAssertFalse(msg.hasDefaultInt64) + } + + func testDefaultUint32() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.defaultUint32, 43) + XCTAssertFalse(msg.hasDefaultUint32) + msg.defaultUint32 = 63 + XCTAssertTrue(msg.hasDefaultUint32) + XCTAssertEqual(msg.defaultUint32, 63) + msg.clearDefaultUint32() + XCTAssertEqual(msg.defaultUint32, 43) + XCTAssertFalse(msg.hasDefaultUint32) + } + + func testDefaultUint64() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.defaultUint64, 44) + XCTAssertFalse(msg.hasDefaultUint64) + msg.defaultUint64 = 64 + XCTAssertTrue(msg.hasDefaultUint64) + XCTAssertEqual(msg.defaultUint64, 64) + msg.clearDefaultUint64() + XCTAssertEqual(msg.defaultUint64, 44) + XCTAssertFalse(msg.hasDefaultUint64) + } + + func testDefaultSint32() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.defaultSint32, -45) + XCTAssertFalse(msg.hasDefaultSint32) + msg.defaultSint32 = 65 + XCTAssertTrue(msg.hasDefaultSint32) + XCTAssertEqual(msg.defaultSint32, 65) + msg.clearDefaultSint32() + XCTAssertEqual(msg.defaultSint32, -45) + XCTAssertFalse(msg.hasDefaultSint32) + } + + func testDefaultSint64() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.defaultSint64, 46) + XCTAssertFalse(msg.hasDefaultSint64) + msg.defaultSint64 = 66 + XCTAssertTrue(msg.hasDefaultSint64) + XCTAssertEqual(msg.defaultSint64, 66) + msg.clearDefaultSint64() + XCTAssertEqual(msg.defaultSint64, 46) + XCTAssertFalse(msg.hasDefaultSint64) + } + + func testDefaultFixed32() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.defaultFixed32, 47) + XCTAssertFalse(msg.hasDefaultFixed32) + msg.defaultFixed32 = 67 + XCTAssertTrue(msg.hasDefaultFixed32) + XCTAssertEqual(msg.defaultFixed32, 67) + msg.clearDefaultFixed32() + XCTAssertEqual(msg.defaultFixed32, 47) + XCTAssertFalse(msg.hasDefaultFixed32) + } + + func testDefaultFixed64() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.defaultFixed64, 48) + XCTAssertFalse(msg.hasDefaultFixed64) + msg.defaultFixed64 = 68 + XCTAssertTrue(msg.hasDefaultFixed64) + XCTAssertEqual(msg.defaultFixed64, 68) + msg.clearDefaultFixed64() + XCTAssertEqual(msg.defaultFixed64, 48) + XCTAssertFalse(msg.hasDefaultFixed64) + } + + func testDefaultSfixed32() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.defaultSfixed32, 49) + XCTAssertFalse(msg.hasDefaultSfixed32) + msg.defaultSfixed32 = 69 + XCTAssertTrue(msg.hasDefaultSfixed32) + XCTAssertEqual(msg.defaultSfixed32, 69) + msg.clearDefaultSfixed32() + XCTAssertEqual(msg.defaultSfixed32, 49) + XCTAssertFalse(msg.hasDefaultSfixed32) + } + + func testDefaultSfixed64() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.defaultSfixed64, -50) + XCTAssertFalse(msg.hasDefaultSfixed64) + msg.defaultSfixed64 = 70 + XCTAssertTrue(msg.hasDefaultSfixed64) + XCTAssertEqual(msg.defaultSfixed64, 70) + msg.clearDefaultSfixed64() + XCTAssertEqual(msg.defaultSfixed64, -50) + XCTAssertFalse(msg.hasDefaultSfixed64) + } + + func testDefaultFloat() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.defaultFloat, 51.5) + XCTAssertFalse(msg.hasDefaultFloat) + msg.defaultFloat = 71 + XCTAssertTrue(msg.hasDefaultFloat) + XCTAssertEqual(msg.defaultFloat, 71) + msg.clearDefaultFloat() + XCTAssertEqual(msg.defaultFloat, 51.5) + XCTAssertFalse(msg.hasDefaultFloat) + } + + func testDefaultDouble() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.defaultDouble, 52e3) + XCTAssertFalse(msg.hasDefaultDouble) + msg.defaultDouble = 72 + XCTAssertTrue(msg.hasDefaultDouble) + XCTAssertEqual(msg.defaultDouble, 72) + msg.clearDefaultDouble() + XCTAssertEqual(msg.defaultDouble, 52e3) + XCTAssertFalse(msg.hasDefaultDouble) + } + + func testDefaultBool() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.defaultBool, true) + XCTAssertFalse(msg.hasDefaultBool) + msg.defaultBool = false + XCTAssertTrue(msg.hasDefaultBool) + XCTAssertEqual(msg.defaultBool, false) + msg.clearDefaultBool() + XCTAssertEqual(msg.defaultBool, true) + XCTAssertFalse(msg.hasDefaultBool) + } + + func testDefaultString() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.defaultString, "hello") + XCTAssertFalse(msg.hasDefaultString) + msg.defaultString = "74" + XCTAssertTrue(msg.hasDefaultString) + XCTAssertEqual(msg.defaultString, "74") + msg.clearDefaultString() + XCTAssertEqual(msg.defaultString, "hello") + XCTAssertFalse(msg.hasDefaultString) + } + + func testDefaultBytes() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.defaultBytes, "world".data(using: .utf8)) + XCTAssertFalse(msg.hasDefaultBytes) + msg.defaultBytes = Data([75]) + XCTAssertTrue(msg.hasDefaultBytes) + XCTAssertEqual(msg.defaultBytes, Data([75])) + msg.clearDefaultBytes() + XCTAssertEqual(msg.defaultBytes, "world".data(using: .utf8)) + XCTAssertFalse(msg.hasDefaultBytes) + } + + func testDefaultNestedEnum() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.defaultNestedEnum, .bar) + XCTAssertFalse(msg.hasDefaultNestedEnum) + msg.defaultNestedEnum = .baz + XCTAssertTrue(msg.hasDefaultNestedEnum) + XCTAssertEqual(msg.defaultNestedEnum, .baz) + msg.clearDefaultNestedEnum() + XCTAssertEqual(msg.defaultNestedEnum, .bar) + XCTAssertFalse(msg.hasDefaultNestedEnum) + } + + func testDefaultForeignEnum() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.defaultForeignEnum, .foreignBar) + XCTAssertFalse(msg.hasDefaultForeignEnum) + msg.defaultForeignEnum = .foreignBaz + XCTAssertTrue(msg.hasDefaultForeignEnum) + XCTAssertEqual(msg.defaultForeignEnum, .foreignBaz) + msg.clearDefaultForeignEnum() + XCTAssertEqual(msg.defaultForeignEnum, .foreignBar) + XCTAssertFalse(msg.hasDefaultForeignEnum) + } + + func testDefaultImportEnum() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.defaultImportEnum, .importBar) + XCTAssertFalse(msg.hasDefaultImportEnum) + msg.defaultImportEnum = .importBaz + XCTAssertTrue(msg.hasDefaultImportEnum) + XCTAssertEqual(msg.defaultImportEnum, .importBaz) + msg.clearDefaultImportEnum() + XCTAssertEqual(msg.defaultImportEnum, .importBar) + XCTAssertFalse(msg.hasDefaultImportEnum) + } + + // Repeated + + func testRepeatedInt32() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedInt32, []) + msg.repeatedInt32 = [31] + XCTAssertEqual(msg.repeatedInt32, [31]) + msg.repeatedInt32.append(131) + XCTAssertEqual(msg.repeatedInt32, [31, 131]) + } + + func testRepeatedInt64() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedInt64, []) + msg.repeatedInt64 = [32] + XCTAssertEqual(msg.repeatedInt64, [32]) + msg.repeatedInt64.append(132) + XCTAssertEqual(msg.repeatedInt64, [32, 132]) + } + + func testRepeatedUint32() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedUint32, []) + msg.repeatedUint32 = [33] + XCTAssertEqual(msg.repeatedUint32, [33]) + msg.repeatedUint32.append(133) + XCTAssertEqual(msg.repeatedUint32, [33, 133]) + } + + func testRepeatedUint64() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedUint64, []) + msg.repeatedUint64 = [34] + XCTAssertEqual(msg.repeatedUint64, [34]) + msg.repeatedUint64.append(134) + XCTAssertEqual(msg.repeatedUint64, [34, 134]) + } + + func testRepeatedSint32() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedSint32, []) + msg.repeatedSint32 = [35] + XCTAssertEqual(msg.repeatedSint32, [35]) + msg.repeatedSint32.append(135) + XCTAssertEqual(msg.repeatedSint32, [35, 135]) + } + + func testRepeatedSint64() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedSint64, []) + msg.repeatedSint64 = [36] + XCTAssertEqual(msg.repeatedSint64, [36]) + msg.repeatedSint64.append(136) + XCTAssertEqual(msg.repeatedSint64, [36, 136]) + } + + func testRepeatedFixed32() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedFixed32, []) + msg.repeatedFixed32 = [37] + XCTAssertEqual(msg.repeatedFixed32, [37]) + msg.repeatedFixed32.append(137) + XCTAssertEqual(msg.repeatedFixed32, [37, 137]) + } + + func testRepeatedFixed64() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedFixed64, []) + msg.repeatedFixed64 = [38] + XCTAssertEqual(msg.repeatedFixed64, [38]) + msg.repeatedFixed64.append(138) + XCTAssertEqual(msg.repeatedFixed64, [38, 138]) + } + + func testRepeatedSfixed32() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedSfixed32, []) + msg.repeatedSfixed32 = [39] + XCTAssertEqual(msg.repeatedSfixed32, [39]) + msg.repeatedSfixed32.append(139) + XCTAssertEqual(msg.repeatedSfixed32, [39, 139]) + } + + func testRepeatedSfixed64() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedSfixed64, []) + msg.repeatedSfixed64 = [40] + XCTAssertEqual(msg.repeatedSfixed64, [40]) + msg.repeatedSfixed64.append(140) + XCTAssertEqual(msg.repeatedSfixed64, [40, 140]) + } + + func testRepeatedFloat() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedFloat, []) + msg.repeatedFloat = [41.0] + XCTAssertEqual(msg.repeatedFloat, [41.0]) + msg.repeatedFloat.append(141.0) + XCTAssertEqual(msg.repeatedFloat, [41.0, 141.0]) + } + + func testRepeatedDouble() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedDouble, []) + msg.repeatedDouble = [42.0] + XCTAssertEqual(msg.repeatedDouble, [42.0]) + msg.repeatedDouble.append(142.0) + XCTAssertEqual(msg.repeatedDouble, [42.0, 142.0]) + } + + func testRepeatedBool() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedBool, []) + msg.repeatedBool = [true] + XCTAssertEqual(msg.repeatedBool, [true]) + msg.repeatedBool.append(false) + XCTAssertEqual(msg.repeatedBool, [true, false]) + } + + func testRepeatedString() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedString, []) + msg.repeatedString = ["44"] + XCTAssertEqual(msg.repeatedString, ["44"]) + msg.repeatedString.append("144") + XCTAssertEqual(msg.repeatedString, ["44", "144"]) + } + + func testRepeatedBytes() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedBytes, []) + msg.repeatedBytes = [Data([45])] + XCTAssertEqual(msg.repeatedBytes, [Data([45])]) + msg.repeatedBytes.append(Data([145])) + XCTAssertEqual(msg.repeatedBytes, [Data([45]), Data([145])]) + } + + func testRepeatedGroup() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedGroup, []) + var grp = SwiftProtoTesting_TestAllTypes.RepeatedGroup() + grp.a = 46 + msg.repeatedGroup = [grp] + XCTAssertEqual(msg.repeatedGroup.count, 1) + XCTAssertEqual(msg.repeatedGroup[0].a, 46) + XCTAssertEqual(msg.repeatedGroup, [grp]) + var grp2 = SwiftProtoTesting_TestAllTypes.RepeatedGroup() + grp2.a = 146 + msg.repeatedGroup.append(grp2) + XCTAssertEqual(msg.repeatedGroup.count, 2) + XCTAssertEqual(msg.repeatedGroup[0].a, 46) + XCTAssertEqual(msg.repeatedGroup[1].a, 146) + XCTAssertEqual(msg.repeatedGroup, [grp, grp2]) + } + + func testRepeatedNestedMessage() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedNestedMessage, []) + var nestedMsg = SwiftProtoTesting_TestAllTypes.NestedMessage() + nestedMsg.bb = 48 + msg.repeatedNestedMessage = [nestedMsg] + XCTAssertEqual(msg.repeatedNestedMessage.count, 1) + XCTAssertEqual(msg.repeatedNestedMessage[0].bb, 48) + XCTAssertEqual(msg.repeatedNestedMessage, [nestedMsg]) + var nestedMsg2 = SwiftProtoTesting_TestAllTypes.NestedMessage() + nestedMsg2.bb = 148 + msg.repeatedNestedMessage.append(nestedMsg2) + XCTAssertEqual(msg.repeatedNestedMessage.count, 2) + XCTAssertEqual(msg.repeatedNestedMessage[0].bb, 48) + XCTAssertEqual(msg.repeatedNestedMessage[1].bb, 148) + XCTAssertEqual(msg.repeatedNestedMessage, [nestedMsg, nestedMsg2]) + } + + func testRepeatedForeignMessage() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedForeignMessage, []) + var foreignMsg = SwiftProtoTesting_ForeignMessage() + foreignMsg.c = 49 + msg.repeatedForeignMessage = [foreignMsg] + XCTAssertEqual(msg.repeatedForeignMessage.count, 1) + XCTAssertEqual(msg.repeatedForeignMessage[0].c, 49) + XCTAssertEqual(msg.repeatedForeignMessage, [foreignMsg]) + var foreignMsg2 = SwiftProtoTesting_ForeignMessage() + foreignMsg2.c = 149 + msg.repeatedForeignMessage.append(foreignMsg2) + XCTAssertEqual(msg.repeatedForeignMessage.count, 2) + XCTAssertEqual(msg.repeatedForeignMessage[0].c, 49) + XCTAssertEqual(msg.repeatedForeignMessage[1].c, 149) + XCTAssertEqual(msg.repeatedForeignMessage, [foreignMsg, foreignMsg2]) + } + + func testRepeatedImportMessage() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedImportMessage, []) + var importedMsg = SwiftProtoTesting_Import_ImportMessage() + importedMsg.d = 50 + msg.repeatedImportMessage = [importedMsg] + XCTAssertEqual(msg.repeatedImportMessage.count, 1) + XCTAssertEqual(msg.repeatedImportMessage[0].d, 50) + XCTAssertEqual(msg.repeatedImportMessage, [importedMsg]) + var importedMsg2 = SwiftProtoTesting_Import_ImportMessage() + importedMsg2.d = 150 + msg.repeatedImportMessage.append(importedMsg2) + XCTAssertEqual(msg.repeatedImportMessage.count, 2) + XCTAssertEqual(msg.repeatedImportMessage[0].d, 50) + XCTAssertEqual(msg.repeatedImportMessage[1].d, 150) + XCTAssertEqual(msg.repeatedImportMessage, [importedMsg, importedMsg2]) + } + + func testRepeatedNestedEnum() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedNestedEnum, []) + msg.repeatedNestedEnum = [.bar] + XCTAssertEqual(msg.repeatedNestedEnum, [.bar]) + msg.repeatedNestedEnum.append(.baz) + XCTAssertEqual(msg.repeatedNestedEnum, [.bar, .baz]) + } + + func testRepeatedForeignEnum() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedForeignEnum, []) + msg.repeatedForeignEnum = [.foreignBar] + XCTAssertEqual(msg.repeatedForeignEnum, [.foreignBar]) + msg.repeatedForeignEnum.append(.foreignBaz) + XCTAssertEqual(msg.repeatedForeignEnum, [.foreignBar, .foreignBaz]) + } + + func testRepeatedImportEnum() { + var msg = SwiftProtoTesting_TestAllTypes() + XCTAssertEqual(msg.repeatedImportEnum, []) + msg.repeatedImportEnum = [.importBar] + XCTAssertEqual(msg.repeatedImportEnum, [.importBar]) + msg.repeatedImportEnum.append(.importBaz) + XCTAssertEqual(msg.repeatedImportEnum, [.importBar, .importBaz]) + } } diff --git a/Tests/SwiftProtobufTests/Test_BasicFields_Access_Proto3.swift b/Tests/SwiftProtobufTests/Test_BasicFields_Access_Proto3.swift index 3f053446f..7563615cf 100644 --- a/Tests/SwiftProtobufTests/Test_BasicFields_Access_Proto3.swift +++ b/Tests/SwiftProtobufTests/Test_BasicFields_Access_Proto3.swift @@ -12,384 +12,384 @@ /// // ----------------------------------------------------------------------------- -import XCTest import Foundation +import XCTest // NOTE: The generator changes what is generated based on the number/types // of fields (using a nested storage class or not), to be completel, all // these tests should be done once with a message that gets that storage // class and a second time with messages that avoid that. -class Test_BasicFields_Access_Proto3: XCTestCase { - - // Optional - - func testOptionalInt32() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalInt32, 0) - msg.optionalInt32 = 1 - XCTAssertEqual(msg.optionalInt32, 1) - } - - func testOptionalInt64() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalInt64, 0) - msg.optionalInt64 = 2 - XCTAssertEqual(msg.optionalInt64, 2) - } - - func testOptionalUint32() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalUint32, 0) - msg.optionalUint32 = 3 - XCTAssertEqual(msg.optionalUint32, 3) - } - - func testOptionalUint64() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalUint64, 0) - msg.optionalUint64 = 4 - XCTAssertEqual(msg.optionalUint64, 4) - } - - func testOptionalSint32() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalSint32, 0) - msg.optionalSint32 = 5 - XCTAssertEqual(msg.optionalSint32, 5) - } - - func testOptionalSint64() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalSint64, 0) - msg.optionalSint64 = 6 - XCTAssertEqual(msg.optionalSint64, 6) - } - - func testOptionalFixed32() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalFixed32, 0) - msg.optionalFixed32 = 7 - XCTAssertEqual(msg.optionalFixed32, 7) - } - - func testOptionalFixed64() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalFixed64, 0) - msg.optionalFixed64 = 8 - XCTAssertEqual(msg.optionalFixed64, 8) - } - - func testOptionalSfixed32() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalSfixed32, 0) - msg.optionalSfixed32 = 9 - XCTAssertEqual(msg.optionalSfixed32, 9) - } - - func testOptionalSfixed64() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalSfixed64, 0) - msg.optionalSfixed64 = 10 - XCTAssertEqual(msg.optionalSfixed64, 10) - } - - func testOptionalFloat() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalFloat, 0.0) - msg.optionalFloat = 11.0 - XCTAssertEqual(msg.optionalFloat, 11.0) - } - - func testOptionalDouble() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalDouble, 0.0) - msg.optionalDouble = 12.0 - XCTAssertEqual(msg.optionalDouble, 12.0) - } - - func testOptionalBool() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalBool, false) - msg.optionalBool = true - XCTAssertEqual(msg.optionalBool, true) - } - - func testOptionalString() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalString, "") - msg.optionalString = "14" - XCTAssertEqual(msg.optionalString, "14") - } - - func testOptionalBytes() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalBytes, Data()) - msg.optionalBytes = Data([15]) - XCTAssertEqual(msg.optionalBytes, Data([15])) - } - - func testOptionalNestedMessage() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalNestedMessage.bb, 0) - var nestedMsg = Proto3Unittest_TestAllTypes.NestedMessage() - nestedMsg.bb = 18 - msg.optionalNestedMessage = nestedMsg - XCTAssertEqual(msg.optionalNestedMessage.bb, 18) - XCTAssertEqual(msg.optionalNestedMessage, nestedMsg) - } - - func testOptionalForeignMessage() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalForeignMessage.c, 0) - var foreignMsg = Proto3Unittest_ForeignMessage() - foreignMsg.c = 19 - msg.optionalForeignMessage = foreignMsg - XCTAssertEqual(msg.optionalForeignMessage.c, 19) - XCTAssertEqual(msg.optionalForeignMessage, foreignMsg) - } - - func testOptionalImportMessage() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalImportMessage.d, 0) - var importedMsg = ProtobufUnittestImport_ImportMessage() - importedMsg.d = 20 - msg.optionalImportMessage = importedMsg - XCTAssertEqual(msg.optionalImportMessage.d, 20) - XCTAssertEqual(msg.optionalImportMessage, importedMsg) - } - - func testOptionalNestedEnum() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalNestedEnum, .zero) - msg.optionalNestedEnum = .bar - XCTAssertEqual(msg.optionalNestedEnum, .bar) - } - - func testOptionalForeignEnum() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalForeignEnum, .foreignZero) - msg.optionalForeignEnum = .foreignBar - XCTAssertEqual(msg.optionalForeignEnum, .foreignBar) - } - - func testOptionalPublicImportMessage() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.optionalPublicImportMessage.e, 0) - var pubImportedMsg = ProtobufUnittestImport_PublicImportMessage() - pubImportedMsg.e = 26 - msg.optionalPublicImportMessage = pubImportedMsg - XCTAssertEqual(msg.optionalPublicImportMessage.e, 26) - XCTAssertEqual(msg.optionalPublicImportMessage, pubImportedMsg) - } - - // Repeated - - func testRepeatedInt32() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedInt32, []) - msg.repeatedInt32 = [31] - XCTAssertEqual(msg.repeatedInt32, [31]) - msg.repeatedInt32.append(131) - XCTAssertEqual(msg.repeatedInt32, [31, 131]) - } - - func testRepeatedInt64() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedInt64, []) - msg.repeatedInt64 = [32] - XCTAssertEqual(msg.repeatedInt64, [32]) - msg.repeatedInt64.append(132) - XCTAssertEqual(msg.repeatedInt64, [32, 132]) - } - - func testRepeatedUint32() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedUint32, []) - msg.repeatedUint32 = [33] - XCTAssertEqual(msg.repeatedUint32, [33]) - msg.repeatedUint32.append(133) - XCTAssertEqual(msg.repeatedUint32, [33, 133]) - } - - func testRepeatedUint64() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedUint64, []) - msg.repeatedUint64 = [34] - XCTAssertEqual(msg.repeatedUint64, [34]) - msg.repeatedUint64.append(134) - XCTAssertEqual(msg.repeatedUint64, [34, 134]) - } - - func testRepeatedSint32() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedSint32, []) - msg.repeatedSint32 = [35] - XCTAssertEqual(msg.repeatedSint32, [35]) - msg.repeatedSint32.append(135) - XCTAssertEqual(msg.repeatedSint32, [35, 135]) - } - - func testRepeatedSint64() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedSint64, []) - msg.repeatedSint64 = [36] - XCTAssertEqual(msg.repeatedSint64, [36]) - msg.repeatedSint64.append(136) - XCTAssertEqual(msg.repeatedSint64, [36, 136]) - } - - func testRepeatedFixed32() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedFixed32, []) - msg.repeatedFixed32 = [37] - XCTAssertEqual(msg.repeatedFixed32, [37]) - msg.repeatedFixed32.append(137) - XCTAssertEqual(msg.repeatedFixed32, [37, 137]) - } - - func testRepeatedFixed64() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedFixed64, []) - msg.repeatedFixed64 = [38] - XCTAssertEqual(msg.repeatedFixed64, [38]) - msg.repeatedFixed64.append(138) - XCTAssertEqual(msg.repeatedFixed64, [38, 138]) - } - - func testRepeatedSfixed32() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedSfixed32, []) - msg.repeatedSfixed32 = [39] - XCTAssertEqual(msg.repeatedSfixed32, [39]) - msg.repeatedSfixed32.append(139) - XCTAssertEqual(msg.repeatedSfixed32, [39, 139]) - } - - func testRepeatedSfixed64() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedSfixed64, []) - msg.repeatedSfixed64 = [40] - XCTAssertEqual(msg.repeatedSfixed64, [40]) - msg.repeatedSfixed64.append(140) - XCTAssertEqual(msg.repeatedSfixed64, [40, 140]) - } - - func testRepeatedFloat() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedFloat, []) - msg.repeatedFloat = [41.0] - XCTAssertEqual(msg.repeatedFloat, [41.0]) - msg.repeatedFloat.append(141.0) - XCTAssertEqual(msg.repeatedFloat, [41.0, 141.0]) - } - - func testRepeatedDouble() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedDouble, []) - msg.repeatedDouble = [42.0] - XCTAssertEqual(msg.repeatedDouble, [42.0]) - msg.repeatedDouble.append(142.0) - XCTAssertEqual(msg.repeatedDouble, [42.0, 142.0]) - } - - func testRepeatedBool() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedBool, []) - msg.repeatedBool = [true] - XCTAssertEqual(msg.repeatedBool, [true]) - msg.repeatedBool.append(false) - XCTAssertEqual(msg.repeatedBool, [true, false]) - } - - func testRepeatedString() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedString, []) - msg.repeatedString = ["44"] - XCTAssertEqual(msg.repeatedString, ["44"]) - msg.repeatedString.append("144") - XCTAssertEqual(msg.repeatedString, ["44", "144"]) - } - - func testRepeatedBytes() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedBytes, []) - msg.repeatedBytes = [Data([45])] - XCTAssertEqual(msg.repeatedBytes, [Data([45])]) - msg.repeatedBytes.append(Data([145])) - XCTAssertEqual(msg.repeatedBytes, [Data([45]), Data([145])]) - } - - func testRepeatedNestedMessage() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedNestedMessage, []) - var nestedMsg = Proto3Unittest_TestAllTypes.NestedMessage() - nestedMsg.bb = 48 - msg.repeatedNestedMessage = [nestedMsg] - XCTAssertEqual(msg.repeatedNestedMessage.count, 1) - XCTAssertEqual(msg.repeatedNestedMessage[0].bb, 48) - XCTAssertEqual(msg.repeatedNestedMessage, [nestedMsg]) - var nestedMsg2 = Proto3Unittest_TestAllTypes.NestedMessage() - nestedMsg2.bb = 148 - msg.repeatedNestedMessage.append(nestedMsg2) - XCTAssertEqual(msg.repeatedNestedMessage.count, 2) - XCTAssertEqual(msg.repeatedNestedMessage[0].bb, 48) - XCTAssertEqual(msg.repeatedNestedMessage[1].bb, 148) - XCTAssertEqual(msg.repeatedNestedMessage, [nestedMsg, nestedMsg2]) - } - - func testRepeatedForeignMessage() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedForeignMessage, []) - var foreignMsg = Proto3Unittest_ForeignMessage() - foreignMsg.c = 49 - msg.repeatedForeignMessage = [foreignMsg] - XCTAssertEqual(msg.repeatedForeignMessage.count, 1) - XCTAssertEqual(msg.repeatedForeignMessage[0].c, 49) - XCTAssertEqual(msg.repeatedForeignMessage, [foreignMsg]) - var foreignMsg2 = Proto3Unittest_ForeignMessage() - foreignMsg2.c = 149 - msg.repeatedForeignMessage.append(foreignMsg2) - XCTAssertEqual(msg.repeatedForeignMessage.count, 2) - XCTAssertEqual(msg.repeatedForeignMessage[0].c, 49) - XCTAssertEqual(msg.repeatedForeignMessage[1].c, 149) - XCTAssertEqual(msg.repeatedForeignMessage, [foreignMsg, foreignMsg2]) - } - - func testRepeatedImportMessage() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedImportMessage, []) - var importedMsg = ProtobufUnittestImport_ImportMessage() - importedMsg.d = 50 - msg.repeatedImportMessage = [importedMsg] - XCTAssertEqual(msg.repeatedImportMessage.count, 1) - XCTAssertEqual(msg.repeatedImportMessage[0].d, 50) - XCTAssertEqual(msg.repeatedImportMessage, [importedMsg]) - var importedMsg2 = ProtobufUnittestImport_ImportMessage() - importedMsg2.d = 150 - msg.repeatedImportMessage.append(importedMsg2) - XCTAssertEqual(msg.repeatedImportMessage.count, 2) - XCTAssertEqual(msg.repeatedImportMessage[0].d, 50) - XCTAssertEqual(msg.repeatedImportMessage[1].d, 150) - XCTAssertEqual(msg.repeatedImportMessage, [importedMsg, importedMsg2]) - } - - func testRepeatedNestedEnum() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedNestedEnum, []) - msg.repeatedNestedEnum = [.bar] - XCTAssertEqual(msg.repeatedNestedEnum, [.bar]) - msg.repeatedNestedEnum.append(.baz) - XCTAssertEqual(msg.repeatedNestedEnum, [.bar, .baz]) - } - - func testRepeatedForeignEnum() { - var msg = Proto3Unittest_TestAllTypes() - XCTAssertEqual(msg.repeatedForeignEnum, []) - msg.repeatedForeignEnum = [.foreignBar] - XCTAssertEqual(msg.repeatedForeignEnum, [.foreignBar]) - msg.repeatedForeignEnum.append(.foreignBaz) - XCTAssertEqual(msg.repeatedForeignEnum, [.foreignBar, .foreignBaz]) - } +final class Test_BasicFields_Access_Proto3: XCTestCase { + + // Optional + + func testOptionalInt32() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalInt32, 0) + msg.optionalInt32 = 1 + XCTAssertEqual(msg.optionalInt32, 1) + } + + func testOptionalInt64() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalInt64, 0) + msg.optionalInt64 = 2 + XCTAssertEqual(msg.optionalInt64, 2) + } + + func testOptionalUint32() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalUint32, 0) + msg.optionalUint32 = 3 + XCTAssertEqual(msg.optionalUint32, 3) + } + + func testOptionalUint64() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalUint64, 0) + msg.optionalUint64 = 4 + XCTAssertEqual(msg.optionalUint64, 4) + } + + func testOptionalSint32() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalSint32, 0) + msg.optionalSint32 = 5 + XCTAssertEqual(msg.optionalSint32, 5) + } + + func testOptionalSint64() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalSint64, 0) + msg.optionalSint64 = 6 + XCTAssertEqual(msg.optionalSint64, 6) + } + + func testOptionalFixed32() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalFixed32, 0) + msg.optionalFixed32 = 7 + XCTAssertEqual(msg.optionalFixed32, 7) + } + + func testOptionalFixed64() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalFixed64, 0) + msg.optionalFixed64 = 8 + XCTAssertEqual(msg.optionalFixed64, 8) + } + + func testOptionalSfixed32() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalSfixed32, 0) + msg.optionalSfixed32 = 9 + XCTAssertEqual(msg.optionalSfixed32, 9) + } + + func testOptionalSfixed64() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalSfixed64, 0) + msg.optionalSfixed64 = 10 + XCTAssertEqual(msg.optionalSfixed64, 10) + } + + func testOptionalFloat() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalFloat, 0.0) + msg.optionalFloat = 11.0 + XCTAssertEqual(msg.optionalFloat, 11.0) + } + + func testOptionalDouble() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalDouble, 0.0) + msg.optionalDouble = 12.0 + XCTAssertEqual(msg.optionalDouble, 12.0) + } + + func testOptionalBool() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalBool, false) + msg.optionalBool = true + XCTAssertEqual(msg.optionalBool, true) + } + + func testOptionalString() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalString, "") + msg.optionalString = "14" + XCTAssertEqual(msg.optionalString, "14") + } + + func testOptionalBytes() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalBytes, Data()) + msg.optionalBytes = Data([15]) + XCTAssertEqual(msg.optionalBytes, Data([15])) + } + + func testOptionalNestedMessage() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalNestedMessage.bb, 0) + var nestedMsg = SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage() + nestedMsg.bb = 18 + msg.optionalNestedMessage = nestedMsg + XCTAssertEqual(msg.optionalNestedMessage.bb, 18) + XCTAssertEqual(msg.optionalNestedMessage, nestedMsg) + } + + func testOptionalForeignMessage() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalForeignMessage.c, 0) + var foreignMsg = SwiftProtoTesting_Proto3_ForeignMessage() + foreignMsg.c = 19 + msg.optionalForeignMessage = foreignMsg + XCTAssertEqual(msg.optionalForeignMessage.c, 19) + XCTAssertEqual(msg.optionalForeignMessage, foreignMsg) + } + + func testOptionalImportMessage() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalImportMessage.d, 0) + var importedMsg = SwiftProtoTesting_Import_ImportMessage() + importedMsg.d = 20 + msg.optionalImportMessage = importedMsg + XCTAssertEqual(msg.optionalImportMessage.d, 20) + XCTAssertEqual(msg.optionalImportMessage, importedMsg) + } + + func testOptionalNestedEnum() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalNestedEnum, .zero) + msg.optionalNestedEnum = .bar + XCTAssertEqual(msg.optionalNestedEnum, .bar) + } + + func testOptionalForeignEnum() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalForeignEnum, .foreignZero) + msg.optionalForeignEnum = .foreignBar + XCTAssertEqual(msg.optionalForeignEnum, .foreignBar) + } + + func testOptionalPublicImportMessage() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.optionalPublicImportMessage.e, 0) + var pubImportedMsg = SwiftProtoTesting_Import_PublicImportMessage() + pubImportedMsg.e = 26 + msg.optionalPublicImportMessage = pubImportedMsg + XCTAssertEqual(msg.optionalPublicImportMessage.e, 26) + XCTAssertEqual(msg.optionalPublicImportMessage, pubImportedMsg) + } + + // Repeated + + func testRepeatedInt32() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedInt32, []) + msg.repeatedInt32 = [31] + XCTAssertEqual(msg.repeatedInt32, [31]) + msg.repeatedInt32.append(131) + XCTAssertEqual(msg.repeatedInt32, [31, 131]) + } + + func testRepeatedInt64() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedInt64, []) + msg.repeatedInt64 = [32] + XCTAssertEqual(msg.repeatedInt64, [32]) + msg.repeatedInt64.append(132) + XCTAssertEqual(msg.repeatedInt64, [32, 132]) + } + + func testRepeatedUint32() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedUint32, []) + msg.repeatedUint32 = [33] + XCTAssertEqual(msg.repeatedUint32, [33]) + msg.repeatedUint32.append(133) + XCTAssertEqual(msg.repeatedUint32, [33, 133]) + } + + func testRepeatedUint64() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedUint64, []) + msg.repeatedUint64 = [34] + XCTAssertEqual(msg.repeatedUint64, [34]) + msg.repeatedUint64.append(134) + XCTAssertEqual(msg.repeatedUint64, [34, 134]) + } + + func testRepeatedSint32() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedSint32, []) + msg.repeatedSint32 = [35] + XCTAssertEqual(msg.repeatedSint32, [35]) + msg.repeatedSint32.append(135) + XCTAssertEqual(msg.repeatedSint32, [35, 135]) + } + + func testRepeatedSint64() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedSint64, []) + msg.repeatedSint64 = [36] + XCTAssertEqual(msg.repeatedSint64, [36]) + msg.repeatedSint64.append(136) + XCTAssertEqual(msg.repeatedSint64, [36, 136]) + } + + func testRepeatedFixed32() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedFixed32, []) + msg.repeatedFixed32 = [37] + XCTAssertEqual(msg.repeatedFixed32, [37]) + msg.repeatedFixed32.append(137) + XCTAssertEqual(msg.repeatedFixed32, [37, 137]) + } + + func testRepeatedFixed64() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedFixed64, []) + msg.repeatedFixed64 = [38] + XCTAssertEqual(msg.repeatedFixed64, [38]) + msg.repeatedFixed64.append(138) + XCTAssertEqual(msg.repeatedFixed64, [38, 138]) + } + + func testRepeatedSfixed32() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedSfixed32, []) + msg.repeatedSfixed32 = [39] + XCTAssertEqual(msg.repeatedSfixed32, [39]) + msg.repeatedSfixed32.append(139) + XCTAssertEqual(msg.repeatedSfixed32, [39, 139]) + } + + func testRepeatedSfixed64() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedSfixed64, []) + msg.repeatedSfixed64 = [40] + XCTAssertEqual(msg.repeatedSfixed64, [40]) + msg.repeatedSfixed64.append(140) + XCTAssertEqual(msg.repeatedSfixed64, [40, 140]) + } + + func testRepeatedFloat() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedFloat, []) + msg.repeatedFloat = [41.0] + XCTAssertEqual(msg.repeatedFloat, [41.0]) + msg.repeatedFloat.append(141.0) + XCTAssertEqual(msg.repeatedFloat, [41.0, 141.0]) + } + + func testRepeatedDouble() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedDouble, []) + msg.repeatedDouble = [42.0] + XCTAssertEqual(msg.repeatedDouble, [42.0]) + msg.repeatedDouble.append(142.0) + XCTAssertEqual(msg.repeatedDouble, [42.0, 142.0]) + } + + func testRepeatedBool() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedBool, []) + msg.repeatedBool = [true] + XCTAssertEqual(msg.repeatedBool, [true]) + msg.repeatedBool.append(false) + XCTAssertEqual(msg.repeatedBool, [true, false]) + } + + func testRepeatedString() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedString, []) + msg.repeatedString = ["44"] + XCTAssertEqual(msg.repeatedString, ["44"]) + msg.repeatedString.append("144") + XCTAssertEqual(msg.repeatedString, ["44", "144"]) + } + + func testRepeatedBytes() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedBytes, []) + msg.repeatedBytes = [Data([45])] + XCTAssertEqual(msg.repeatedBytes, [Data([45])]) + msg.repeatedBytes.append(Data([145])) + XCTAssertEqual(msg.repeatedBytes, [Data([45]), Data([145])]) + } + + func testRepeatedNestedMessage() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedNestedMessage, []) + var nestedMsg = SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage() + nestedMsg.bb = 48 + msg.repeatedNestedMessage = [nestedMsg] + XCTAssertEqual(msg.repeatedNestedMessage.count, 1) + XCTAssertEqual(msg.repeatedNestedMessage[0].bb, 48) + XCTAssertEqual(msg.repeatedNestedMessage, [nestedMsg]) + var nestedMsg2 = SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage() + nestedMsg2.bb = 148 + msg.repeatedNestedMessage.append(nestedMsg2) + XCTAssertEqual(msg.repeatedNestedMessage.count, 2) + XCTAssertEqual(msg.repeatedNestedMessage[0].bb, 48) + XCTAssertEqual(msg.repeatedNestedMessage[1].bb, 148) + XCTAssertEqual(msg.repeatedNestedMessage, [nestedMsg, nestedMsg2]) + } + + func testRepeatedForeignMessage() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedForeignMessage, []) + var foreignMsg = SwiftProtoTesting_Proto3_ForeignMessage() + foreignMsg.c = 49 + msg.repeatedForeignMessage = [foreignMsg] + XCTAssertEqual(msg.repeatedForeignMessage.count, 1) + XCTAssertEqual(msg.repeatedForeignMessage[0].c, 49) + XCTAssertEqual(msg.repeatedForeignMessage, [foreignMsg]) + var foreignMsg2 = SwiftProtoTesting_Proto3_ForeignMessage() + foreignMsg2.c = 149 + msg.repeatedForeignMessage.append(foreignMsg2) + XCTAssertEqual(msg.repeatedForeignMessage.count, 2) + XCTAssertEqual(msg.repeatedForeignMessage[0].c, 49) + XCTAssertEqual(msg.repeatedForeignMessage[1].c, 149) + XCTAssertEqual(msg.repeatedForeignMessage, [foreignMsg, foreignMsg2]) + } + + func testRepeatedImportMessage() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedImportMessage, []) + var importedMsg = SwiftProtoTesting_Import_ImportMessage() + importedMsg.d = 50 + msg.repeatedImportMessage = [importedMsg] + XCTAssertEqual(msg.repeatedImportMessage.count, 1) + XCTAssertEqual(msg.repeatedImportMessage[0].d, 50) + XCTAssertEqual(msg.repeatedImportMessage, [importedMsg]) + var importedMsg2 = SwiftProtoTesting_Import_ImportMessage() + importedMsg2.d = 150 + msg.repeatedImportMessage.append(importedMsg2) + XCTAssertEqual(msg.repeatedImportMessage.count, 2) + XCTAssertEqual(msg.repeatedImportMessage[0].d, 50) + XCTAssertEqual(msg.repeatedImportMessage[1].d, 150) + XCTAssertEqual(msg.repeatedImportMessage, [importedMsg, importedMsg2]) + } + + func testRepeatedNestedEnum() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedNestedEnum, []) + msg.repeatedNestedEnum = [.bar] + XCTAssertEqual(msg.repeatedNestedEnum, [.bar]) + msg.repeatedNestedEnum.append(.baz) + XCTAssertEqual(msg.repeatedNestedEnum, [.bar, .baz]) + } + + func testRepeatedForeignEnum() { + var msg = SwiftProtoTesting_Proto3_TestAllTypes() + XCTAssertEqual(msg.repeatedForeignEnum, []) + msg.repeatedForeignEnum = [.foreignBar] + XCTAssertEqual(msg.repeatedForeignEnum, [.foreignBar]) + msg.repeatedForeignEnum.append(.foreignBaz) + XCTAssertEqual(msg.repeatedForeignEnum, [.foreignBar, .foreignBaz]) + } } diff --git a/Tests/SwiftProtobufTests/Test_BinaryDecodingOptions.swift b/Tests/SwiftProtobufTests/Test_BinaryDecodingOptions.swift index c55424344..2a799275b 100644 --- a/Tests/SwiftProtobufTests/Test_BinaryDecodingOptions.swift +++ b/Tests/SwiftProtobufTests/Test_BinaryDecodingOptions.swift @@ -13,14 +13,14 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_BinaryDecodingOptions: XCTestCase { +final class Test_BinaryDecodingOptions: XCTestCase { func testMessageDepthLimit() throws { - let tests: [([UInt8], Message.Type, ExtensionMap?, [(Int, Bool)])] = [ + let tests: [([UInt8], any Message.Type, (any ExtensionMap)?, [(Int, Bool)])] = [ // Input, (Limit, success/failure) // Messages within messages: // outer is msg 1 @@ -31,13 +31,17 @@ class Test_BinaryDecodingOptions: XCTestCase { // } // } // } - ([10, 6, 10, 4, 18, 2, 8, 99], - ProtobufUnittest_NestedTestAllTypes.self, - nil, // No Extensions - [( 10, true ), - ( 4, true ), - ( 3, false ), - ( 2, false )]), + ( + [10, 6, 10, 4, 18, 2, 8, 99], + SwiftProtoTesting_NestedTestAllTypes.self, + nil, // No Extensions + [ + (10, true), + (4, true), + (3, false), + (2, false), + ] + ), // Group within messages: // outer is msg 1 // child { // sub msg 2 @@ -49,13 +53,17 @@ class Test_BinaryDecodingOptions: XCTestCase { // } // } // } - ([10, 11, 10, 9, 18, 7, 131, 1, 136, 1, 98, 132, 1], - ProtobufUnittest_NestedTestAllTypes.self, - nil, // No Extensions - [( 10, true ), - ( 5, true ), - ( 4, false ), - ( 3, false )]), + ( + [10, 11, 10, 9, 18, 7, 131, 1, 136, 1, 98, 132, 1], + SwiftProtoTesting_NestedTestAllTypes.self, + nil, // No Extensions + [ + (10, true), + (5, true), + (4, false), + (3, false), + ] + ), // Nesting of unknown groups: // outer is msg 1 // 4 { // sub msg 2 @@ -68,38 +76,50 @@ class Test_BinaryDecodingOptions: XCTestCase { // 35 = 0b100011 -> field 4/start group // 8, 1 -> field 1/varint, value of 1 // 36 = 0b100100 -> field 4/end group - ([35, 35, 35, 8, 1, 36, 36, 36], - ProtobufUnittest_TestEmptyMessage.self, - nil, // No Extensions - [( 10, true ), - ( 4, true ), - ( 3, false ), - ( 2, false )]), + ( + [35, 35, 35, 8, 1, 36, 36, 36], + SwiftProtoTesting_TestEmptyMessage.self, + nil, // No Extensions + [ + (10, true), + (4, true), + (3, false), + (2, false), + ] + ), // Nested message are on the wire as length delimited, so no depth comes into // play when they are unknown message fields. // Limit applies to message extension fields: // outer is msg 1 - // [protobuf_unittest.optional_nested_message_extension] { // sub msg 2 + // [swift_proto_testing.optional_nested_message_extension] { // sub msg 2 // bb: 1 // } - ([146, 1, 2, 8, 1], - ProtobufUnittest_TestAllExtensions.self, - ProtobufUnittest_Unittest_Extensions, - [( 10, true ), - ( 2, true ), - ( 1, false )]), + ( + [146, 1, 2, 8, 1], + SwiftProtoTesting_TestAllExtensions.self, + SwiftProtoTesting_Unittest_Extensions, + [ + (10, true), + (2, true), + (1, false), + ] + ), // Limit applies to group extension fields: // outer is msg 1 - // [protobuf_unittest.optionalgroup_extension] { // sub msg 2 + // [swift_proto_testing.optionalgroup_extension] { // sub msg 2 // a: 1 // } - ([131, 1, 136, 1, 1, 132, 1], - ProtobufUnittest_TestAllExtensions.self, - ProtobufUnittest_Unittest_Extensions, - [( 10, true ), - ( 2, true ), - ( 1, false )]), + ( + [131, 1, 136, 1, 1, 132, 1], + SwiftProtoTesting_TestAllExtensions.self, + SwiftProtoTesting_Unittest_Extensions, + [ + (10, true), + (2, true), + (1, false), + ] + ), ] for (i, (binaryInput, messageType, extensions, testCases)) in tests.enumerated() { @@ -107,10 +127,11 @@ class Test_BinaryDecodingOptions: XCTestCase { do { var options = BinaryDecodingOptions() options.messageDepthLimit = limit - let _ = - try messageType.init(serializedData: Data(binaryInput), - extensions: extensions, - options: options) + let _ = try messageType.init( + serializedBytes: binaryInput, + extensions: extensions, + options: options + ) if !expectSuccess { XCTFail("Should not have succeed, pass: \(i), limit: \(limit)") } @@ -120,14 +141,14 @@ class Test_BinaryDecodingOptions: XCTestCase { } else { // Nothing, this is what was expected. } - } catch let e { + } catch let e { XCTFail("Decode failed (pass: \(i), limit: \(limit) with unexpected error: \(e)") } } } } - func testDiscaringUnknownFields() throws { + func testDiscardingUnknownFields() throws { // All tests decode once confirming things show up in unknowns, then decode // a second time confirming they were dropped. @@ -147,20 +168,21 @@ class Test_BinaryDecodingOptions: XCTestCase { 16, 1, // Field 2, fixed64 of 2 25, 2, 0, 0, 0, 0, 0, 0, 0, - // Field 3, length delimted of 3 + // Field 3, length delimited of 3 34, 1, 3, // Field 4, group (start, field 6 varinit of 4, end) 43, 56, 4, 44, // Field 5, fixed32 of 5 53, 5, 0, 0, 0, ] - let inputCurrentLevelData = Data(inputCurrentLevel) do { - let msg1 = try ProtobufUnittest_TestEmptyMessage(serializedData: inputCurrentLevelData) - XCTAssertEqual(msg1.unknownFields.data, inputCurrentLevelData) + let msg1 = try SwiftProtoTesting_TestEmptyMessage(serializedBytes: inputCurrentLevel) + XCTAssertEqual(Array(msg1.unknownFields.data), inputCurrentLevel) - let msg2 = try ProtobufUnittest_TestEmptyMessage(serializedData: inputCurrentLevelData, - options: discardOptions) + let msg2 = try SwiftProtoTesting_TestEmptyMessage( + serializedBytes: inputCurrentLevel, + options: discardOptions + ) XCTAssertTrue(msg2.unknownFields.data.isEmpty) } @@ -174,24 +196,26 @@ class Test_BinaryDecodingOptions: XCTestCase { // } // 6: 0x00000005 // } - let inputSubMessage: [UInt8] = [ - // Field 18, length of data, pluse the data - 146, 1, UInt8(inputCurrentLevel.count), - ] + inputCurrentLevel - let inputSubMessageData = Data(inputSubMessage) + let inputSubMessage: [UInt8] = + [ + // Field 18, length of data, plus the data + 146, 1, UInt8(inputCurrentLevel.count), + ] + inputCurrentLevel do { - let msg1 = try ProtobufUnittest_TestAllTypes(serializedData: inputSubMessageData) + let msg1 = try SwiftProtoTesting_TestAllTypes(serializedBytes: inputSubMessage) XCTAssertTrue(msg1.unknownFields.data.isEmpty) - XCTAssertEqual(msg1.optionalNestedMessage.unknownFields.data, inputCurrentLevelData) + XCTAssertEqual(Array(msg1.optionalNestedMessage.unknownFields.data), inputCurrentLevel) - let msg2 = try ProtobufUnittest_TestAllTypes(serializedData: inputSubMessageData, - options: discardOptions) + let msg2 = try SwiftProtoTesting_TestAllTypes( + serializedBytes: inputSubMessage, + options: discardOptions + ) XCTAssertTrue(msg2.unknownFields.data.isEmpty) XCTAssertTrue(msg2.optionalNestedMessage.unknownFields.data.isEmpty) } // Unknown fields nested within a message extension field: - // [protobuf_unittest.optional_nested_message_extension] { + // [swift_proto_testing.optional_nested_message_extension] { // 2: 1 // 3: 0x0000000000000002 // 4: "\003" @@ -201,19 +225,23 @@ class Test_BinaryDecodingOptions: XCTestCase { // 6: 0x00000005 // } do { - let msg1 = try ProtobufUnittest_TestAllExtensions( - serializedData: inputSubMessageData, - extensions: ProtobufUnittest_Unittest_Extensions) + let msg1 = try SwiftProtoTesting_TestAllExtensions( + serializedBytes: inputSubMessage, + extensions: SwiftProtoTesting_Unittest_Extensions + ) XCTAssertTrue(msg1.unknownFields.data.isEmpty) - XCTAssertEqual(msg1.ProtobufUnittest_optionalNestedMessageExtension.unknownFields.data, - inputCurrentLevelData) + XCTAssertEqual( + Array(msg1.SwiftProtoTesting_optionalNestedMessageExtension.unknownFields.data), + inputCurrentLevel + ) - let msg2 = try ProtobufUnittest_TestAllExtensions( - serializedData: inputSubMessageData, - extensions: ProtobufUnittest_Unittest_Extensions, - options: discardOptions) + let msg2 = try SwiftProtoTesting_TestAllExtensions( + serializedBytes: inputSubMessage, + extensions: SwiftProtoTesting_Unittest_Extensions, + options: discardOptions + ) XCTAssertTrue(msg2.unknownFields.data.isEmpty) - XCTAssertTrue(msg2.ProtobufUnittest_optionalNestedMessageExtension.unknownFields.data.isEmpty) + XCTAssertTrue(msg2.SwiftProtoTesting_optionalNestedMessageExtension.unknownFields.data.isEmpty) } // Unknown fields nested within a group field: @@ -226,32 +254,36 @@ class Test_BinaryDecodingOptions: XCTestCase { // } // 6: 0x00000005 // } - let inputGroup: [UInt8] = [ - // Field 16, start_group - 131, 1, - ] + inputCurrentLevel + [ - // Field 16, end_group - 132, 1, - ] - let inputGroupData = Data(inputGroup) + let inputGroup: [UInt8] = + [ + // Field 16, start_group + 131, 1, + ] + inputCurrentLevel + [ + // Field 16, end_group + 132, 1, + ] do { - let msg1 = try ProtobufUnittest_TestAllExtensions( - serializedData: inputGroupData, - extensions: ProtobufUnittest_Unittest_Extensions) + let msg1 = try SwiftProtoTesting_TestAllExtensions( + serializedBytes: inputGroup, + extensions: SwiftProtoTesting_Unittest_Extensions + ) XCTAssertTrue(msg1.unknownFields.data.isEmpty) - XCTAssertEqual(msg1.ProtobufUnittest_optionalGroupExtension.unknownFields.data, - inputCurrentLevelData) + XCTAssertEqual( + Array(msg1.SwiftProtoTesting_optionalGroupExtension.unknownFields.data), + inputCurrentLevel + ) - let msg2 = try ProtobufUnittest_TestAllExtensions( - serializedData: inputGroupData, - extensions: ProtobufUnittest_Unittest_Extensions, - options: discardOptions) + let msg2 = try SwiftProtoTesting_TestAllExtensions( + serializedBytes: inputGroup, + extensions: SwiftProtoTesting_Unittest_Extensions, + options: discardOptions + ) XCTAssertTrue(msg2.unknownFields.data.isEmpty) - XCTAssertTrue(msg2.ProtobufUnittest_optionalGroupExtension.unknownFields.data.isEmpty) + XCTAssertTrue(msg2.SwiftProtoTesting_optionalGroupExtension.unknownFields.data.isEmpty) } // Unknown fields nested within a group extension field: - // [protobuf_unittest.optionalgroup_extension] { + // [swift_proto_testing.optionalgroup_extension] { // 2: 1 // 3: 0x0000000000000002 // 4: "\003" @@ -261,31 +293,34 @@ class Test_BinaryDecodingOptions: XCTestCase { // 6: 0x00000005 // } do { - let msg1 = try ProtobufUnittest_TestAllTypes(serializedData: inputGroupData) + let msg1 = try SwiftProtoTesting_TestAllTypes(serializedBytes: inputGroup) XCTAssertTrue(msg1.unknownFields.data.isEmpty) - XCTAssertEqual(msg1.optionalGroup.unknownFields.data, inputCurrentLevelData) + XCTAssertEqual(Array(msg1.optionalGroup.unknownFields.data), inputCurrentLevel) - let msg2 = try ProtobufUnittest_TestAllTypes(serializedData: inputGroupData, - options: discardOptions) + let msg2 = try SwiftProtoTesting_TestAllTypes( + serializedBytes: inputGroup, + options: discardOptions + ) XCTAssertTrue(msg2.unknownFields.data.isEmpty) XCTAssertTrue(msg2.optionalGroup.unknownFields.data.isEmpty) } - // An unknown enum value. proto2 syntax unknown enums uses a different code - // path to end up in unknown fiels, so ensure that is honoring the option. + // An unknown enum value. Closed enums uses a different code path and + // end up in unknown fields, so ensure that is honoring the option. // Test data: // optional_nested_enum: 13 let inputUnknownEnum: [UInt8] = [ // Field 21, varint - 168, 1, 13 + 168, 1, 13, ] - let inputUnknownEnumData = Data(inputUnknownEnum) do { - let msg1 = try ProtobufUnittest_TestAllTypes(serializedData: inputUnknownEnumData) - XCTAssertEqual(msg1.unknownFields.data, inputUnknownEnumData) + let msg1 = try SwiftProtoTesting_TestAllTypes(serializedBytes: inputUnknownEnum) + XCTAssertEqual(Array(msg1.unknownFields.data), inputUnknownEnum) - let msg2 = try ProtobufUnittest_TestAllTypes(serializedData: inputUnknownEnumData, - options: discardOptions) + let msg2 = try SwiftProtoTesting_TestAllTypes( + serializedBytes: inputUnknownEnum, + options: discardOptions + ) XCTAssertTrue(msg2.unknownFields.data.isEmpty) } } diff --git a/Tests/SwiftProtobufTests/Test_BinaryDelimited.swift b/Tests/SwiftProtobufTests/Test_BinaryDelimited.swift index 9faacff5e..753da08e4 100644 --- a/Tests/SwiftProtobufTests/Test_BinaryDelimited.swift +++ b/Tests/SwiftProtobufTests/Test_BinaryDelimited.swift @@ -9,66 +9,182 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_BinaryDelimited: XCTestCase { +private func openInputStream(_ bytes: [UInt8]) -> InputStream { + let istream = InputStream(data: Data(bytes)) + istream.open() + return istream +} - func testEverything() { - // Don't need to test encode/decode since there are plenty of tests specific to that, - // just test the delimited behaviors. +final class Test_BinaryDelimited: XCTestCase { - let stream1 = OutputStream.toMemory() - stream1.open() + /// Helper to assert the next message read matches and expected one. + func assertParse(expected: M, onStream istream: InputStream) { + do { + let msg = try BinaryDelimited.parse( + messageType: M.self, + from: istream + ) + XCTAssertEqual(msg, expected) + } catch let e { + XCTFail("Unexpected failure: \(e)") + } + } - let msg1 = ProtobufUnittest_TestAllTypes.with { - $0.optionalBool = true - $0.optionalInt32 = 123 - $0.optionalInt64 = 123456789 - $0.optionalGroup.a = 456 - $0.optionalNestedEnum = .baz - $0.repeatedString.append("wee") - $0.repeatedFloat.append(1.23) + /// Helper to assert we're at the end of the stream. + /// + /// `hasBytesAvailable` is documented as maybe returning True and a read + /// has to happen to really know if ones at the end. This is especially + /// true with file based streams. + func assertParseFails(atEndOfStream istream: InputStream) { + XCTAssertThrowsError( + try BinaryDelimited.parse( + messageType: SwiftProtoTesting_TestAllTypes.self, + from: istream + ) + ) { error in + XCTAssertTrue( + self.isSwiftProtobufErrorEqual(error as! SwiftProtobufError, .BinaryStreamDecoding.noBytesAvailable()) + ) + } } - XCTAssertNoThrow(try BinaryDelimited.serialize(message: msg1, to: stream1)) + func assertParsing(failsWithTruncatedStream istream: InputStream) { + XCTAssertThrowsError( + try BinaryDelimited.parse( + messageType: SwiftProtoTesting_TestAllTypes.self, + from: istream + ) + ) { error in + XCTAssertEqual(error as? BinaryDelimited.Error, BinaryDelimited.Error.truncated) + } + } - let msg2 = ProtobufUnittest_TestPackedTypes.with { - $0.packedBool.append(true) - $0.packedInt32.append(234) - $0.packedDouble.append(345.67) + func testNoData() { + let istream = openInputStream([]) + + assertParseFails(atEndOfStream: istream) } - XCTAssertNoThrow(try BinaryDelimited.serialize(message: msg2, to: stream1)) - - stream1.close() - // See https://bugs.swift.org/browse/SR-5404 - let nsData = stream1.property(forKey: .dataWrittenToMemoryStreamKey) as! NSData - let data = Data(referencing: nsData) - let stream2 = InputStream(data: data) - stream2.open() - - var msg1a = ProtobufUnittest_TestAllTypes() - XCTAssertNoThrow(try BinaryDelimited.merge(into: &msg1a, from: stream2)) - XCTAssertEqual(msg1, msg1a) - - do { - let msg2a = try BinaryDelimited.parse( - messageType: ProtobufUnittest_TestPackedTypes.self, - from: stream2) - XCTAssertEqual(msg2, msg2a) - } catch let e { - XCTFail("Unexpected failure: \(e)") + func testZeroLengthMessage() { + let istream = openInputStream([0]) + + assertParse(expected: SwiftProtoTesting_TestAllTypes(), onStream: istream) + + assertParseFails(atEndOfStream: istream) } - do { - _ = try BinaryDelimited.parse(messageType: ProtobufUnittest_TestAllTypes.self, from: stream2) - XCTFail("Should not have gotten here") - } catch BinaryDelimited.Error.truncated { - // Nothing, this is what we expect since there is nothing left to read. - } catch let e { - XCTFail("Unexpected failure: \(e)") + func testNoDataForMessage() { + let istream = openInputStream([0x96, 0x01]) + + // Length will be read, then the no data for the message, so .truncated. + assertParsing(failsWithTruncatedStream: istream) } - } + func testNotEnoughDataForMessage() { + let istream = openInputStream([0x96, 0x01, 0x01, 0x02, 0x03]) + + // Length will be read, but not enought data, so .truncated + assertParsing(failsWithTruncatedStream: istream) + } + + func testTruncatedLength() { + let istream = openInputStream([0x96]) // Needs something like `, 0x01` + + assertParsing(failsWithTruncatedStream: istream) + } + + func testTooLarge() { + let istream = openInputStream([0x80, 0x80, 0x80, 0x80, 0x08]) // 2GB + + XCTAssertThrowsError( + try BinaryDelimited.parse( + messageType: SwiftProtoTesting_TestAllTypes.self, + from: istream + ) + ) { error in + XCTAssertEqual(error as! BinaryDecodingError, .malformedProtobuf) + } + } + + func testOverEncodedLength() { + let istream = openInputStream([ + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x08, + ]) + + XCTAssertThrowsError( + try BinaryDelimited.parse( + messageType: SwiftProtoTesting_TestAllTypes.self, + from: istream + ) + ) { error in + XCTAssertEqual(error as! BinaryDecodingError, .malformedProtobuf) + } + } + + func testTwoMessages() { + let stream1 = OutputStream.toMemory() + stream1.open() + + let msg1 = SwiftProtoTesting_TestAllTypes.with { + $0.optionalBool = true + $0.optionalInt32 = 123 + $0.optionalInt64 = 123_456_789 + $0.optionalGroup.a = 456 + $0.optionalNestedEnum = .baz + $0.repeatedString.append("wee") + $0.repeatedFloat.append(1.23) + } + + XCTAssertNoThrow(try BinaryDelimited.serialize(message: msg1, to: stream1)) + + let msg2 = SwiftProtoTesting_TestPackedTypes.with { + $0.packedBool.append(true) + $0.packedInt32.append(234) + $0.packedDouble.append(345.67) + } + + XCTAssertNoThrow(try BinaryDelimited.serialize(message: msg2, to: stream1)) + + stream1.close() + // See https://bugs.swift.org/browse/SR-5404 + let nsData = stream1.property(forKey: .dataWrittenToMemoryStreamKey) as! NSData + let data = Data(referencing: nsData) + let stream2 = InputStream(data: data) + stream2.open() + + // Test using `merge` + var msg1a = SwiftProtoTesting_TestAllTypes() + XCTAssertNoThrow(try BinaryDelimited.merge(into: &msg1a, from: stream2)) + XCTAssertEqual(msg1, msg1a) + + // Test using `parse` + assertParse(expected: msg2, onStream: stream2) + + assertParseFails(atEndOfStream: stream2) + } + + // oss-fuzz found this case that runs slowly for AsyncMessageSequence + // Copied here as well for comparison. + func testLargeExample() throws { + let messageCount = 100_000 + let bytes = [UInt8](repeating: 0, count: messageCount) + let istream = openInputStream(bytes) + + for _ in 0.. Bool in - return (m.fieldname1 == 1) && (m.fieldName2 == 2) && (m.fieldName3 == 3) + (m.fieldname1 == 1) && (m.fieldName2 == 2) && (m.fieldName3 == 3) } do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: json) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: json) let recoded = try decoded.jsonString() XCTAssertEqual(recoded, "{\"fieldname1\":1,\"fieldName2\":2,\"FieldName3\":3}") } catch let e { @@ -38,10 +38,10 @@ class Test_Conformance: XCTestCase, PBTestHelpers { // Also accept the names in the .proto when decoding let json = "{\n \"fieldname1\": 1,\n \"field_name2\": 2,\n \"_field_name3\": 3\n }" assertJSONDecodeSucceeds(json) { (m: MessageTestType) -> Bool in - return (m.fieldname1 == 1) && (m.fieldName2 == 2) && (m.fieldName3 == 3) + (m.fieldname1 == 1) && (m.fieldName2 == 2) && (m.fieldName3 == 3) } do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: json) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: json) let recoded = try decoded.jsonString() XCTAssertEqual(recoded, "{\"fieldname1\":1,\"fieldName2\":2,\"FieldName3\":3}") } catch let e { @@ -51,14 +51,14 @@ class Test_Conformance: XCTestCase, PBTestHelpers { func testFieldNaming_escapeInName() throws { assertJSONDecodeSucceeds("{\"fieldn\\u0061me1\": 1}") { - return $0.fieldname1 == 1 + $0.fieldname1 == 1 } } func testInt32_min_roundtrip() throws { let json = "{\"optionalInt32\": -2147483648}" do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: json) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: json) let recoded = try decoded.jsonString() XCTAssertEqual(recoded, "{\"optionalInt32\":-2147483648}") } catch { @@ -72,17 +72,17 @@ class Test_Conformance: XCTestCase, PBTestHelpers { func testRepeatedBoolWrapper() { assertJSONDecodeSucceeds("{\"repeatedBoolWrapper\": [true, false]}") { - (o: ProtobufTestMessages_Proto3_TestAllTypesProto3) -> Bool in - return o.repeatedBoolWrapper == [Google_Protobuf_BoolValue(true), Google_Protobuf_BoolValue(false)] + (o: SwiftProtoTesting_Test3_TestAllTypesProto3) -> Bool in + o.repeatedBoolWrapper == [Google_Protobuf_BoolValue(true), Google_Protobuf_BoolValue(false)] } } func testString_unicodeEscape() { assertTextFormatDecodeSucceeds("optional_string: \"\\u1234\"") { - return $0.optionalString == "\u{1234}" + $0.optionalString == "\u{1234}" } assertTextFormatDecodeSucceeds("optional_string: \"\\U0001F601\"") { - return $0.optionalString == "\u{1F601}" + $0.optionalString == "\u{1F601}" } assertTextFormatDecodeFails("optional_string: \"\\u") @@ -95,7 +95,7 @@ class Test_Conformance: XCTestCase, PBTestHelpers { assertTextFormatDecodeFails("optional_string: \"\\U1234DCXY\"") assertJSONDecodeSucceeds("{\"optional_string\": \"\\u1234\"}") { - return $0.optionalString == "\u{1234}" + $0.optionalString == "\u{1234}" } assertJSONDecodeFails("{\"optionalString\": \"\\u") @@ -140,16 +140,16 @@ class Test_Conformance: XCTestCase, PBTestHelpers { assertJSONDecodeFails("{\"optionalString\": \"\\uDE01\\uD83D\"}") // Correct surrogate assertJSONDecodeSucceeds("{\"optionalString\": \"\\uD83D\\uDE01\"}") { - return $0.optionalString == "\u{1F601}" + $0.optionalString == "\u{1F601}" } } func testBytes_unicodeEscape() { assertTextFormatDecodeSucceeds("optional_bytes: \"\\u1234\"") { - return $0.optionalBytes == Data("\u{1234}".utf8) + $0.optionalBytes == Data("\u{1234}".utf8) } assertTextFormatDecodeSucceeds("optional_bytes: \"\\U0001F601\"") { - return $0.optionalBytes == Data("\u{1F601}".utf8) + $0.optionalBytes == Data("\u{1F601}".utf8) } assertTextFormatDecodeFails("optional_bytes: \"\\u") @@ -195,13 +195,19 @@ class Test_Conformance: XCTestCase, PBTestHelpers { } func testMaps_TextFormatKeysSorted() { - assertTextFormatEncode("map_string_string {\n key: \"a\"\n value: \"value\"\n}\nmap_string_string {\n key: \"b\"\n value: \"value\"\n}\nmap_string_string {\n key: \"c\"\n value: \"value\"\n}\n") {(o: inout MessageTestType) in - o.mapStringString = ["c":"value", "b":"value", "a":"value"] - } - assertTextFormatEncode("map_int32_int32 {\n key: 1\n value: 0\n}\nmap_int32_int32 {\n key: 2\n value: 0\n}\nmap_int32_int32 {\n key: 3\n value: 0\n}\n") {(o: inout MessageTestType) in - o.mapInt32Int32 = [3:0, 2:0, 1:0] - } - assertTextFormatEncode("map_bool_bool {\n key: false\n value: false\n}\nmap_bool_bool {\n key: true\n value: false\n}\n") {(o: inout MessageTestType) in + assertTextFormatEncode( + "map_string_string {\n key: \"a\"\n value: \"value\"\n}\nmap_string_string {\n key: \"b\"\n value: \"value\"\n}\nmap_string_string {\n key: \"c\"\n value: \"value\"\n}\n" + ) { (o: inout MessageTestType) in + o.mapStringString = ["c": "value", "b": "value", "a": "value"] + } + assertTextFormatEncode( + "map_int32_int32 {\n key: 1\n value: 0\n}\nmap_int32_int32 {\n key: 2\n value: 0\n}\nmap_int32_int32 {\n key: 3\n value: 0\n}\n" + ) { (o: inout MessageTestType) in + o.mapInt32Int32 = [3: 0, 2: 0, 1: 0] + } + assertTextFormatEncode( + "map_bool_bool {\n key: false\n value: false\n}\nmap_bool_bool {\n key: true\n value: false\n}\n" + ) { (o: inout MessageTestType) in o.mapBoolBool = [true: false, false: false] } } diff --git a/Tests/SwiftProtobufTests/Test_Duration.swift b/Tests/SwiftProtobufTests/Test_Duration.swift index b3284b847..6287d0ba9 100644 --- a/Tests/SwiftProtobufTests/Test_Duration.swift +++ b/Tests/SwiftProtobufTests/Test_Duration.swift @@ -13,11 +13,11 @@ /// // ----------------------------------------------------------------------------- -import XCTest -import SwiftProtobuf import Foundation +import SwiftProtobuf +import XCTest -class Test_Duration: XCTestCase, PBTestHelpers { +final class Test_Duration: XCTestCase, PBTestHelpers { typealias MessageTestType = Google_Protobuf_Duration func testJSON_encode() throws { @@ -25,14 +25,22 @@ class Test_Duration: XCTestCase, PBTestHelpers { o.seconds = 100 o.nanos = 0 } + assertJSONEncode("\"-5s\"") { (o: inout MessageTestType) in + o.seconds = -5 + o.nanos = 0 + } + assertJSONEncode("\"-0.500s\"") { (o: inout MessageTestType) in + o.seconds = 0 + o.nanos = -500_000_000 + } // Always prints exactly 3, 6, or 9 digits assertJSONEncode("\"100.100s\"") { (o: inout MessageTestType) in o.seconds = 100 - o.nanos = 100000000 + o.nanos = 100_000_000 } assertJSONEncode("\"100.001s\"") { (o: inout MessageTestType) in o.seconds = 100 - o.nanos = 1000000 + o.nanos = 1_000_000 } assertJSONEncode("\"100.000100s\"") { (o: inout MessageTestType) in o.seconds = 100 @@ -54,21 +62,28 @@ class Test_Duration: XCTestCase, PBTestHelpers { // Negative durations assertJSONEncode("\"-100.100s\"") { (o: inout MessageTestType) in o.seconds = -100 - o.nanos = -100000000 + o.nanos = -100_000_000 } } func testJSON_decode() throws { - assertJSONDecodeSucceeds("\"1.000000000s\"") {(o:MessageTestType) in + assertJSONDecodeSucceeds("\"1.000000000s\"") { (o: MessageTestType) in o.seconds == 1 && o.nanos == 0 } - assertJSONDecodeSucceeds("\"-315576000000.999999999s\"") {(o:MessageTestType) in - o.seconds == -315576000000 && o.nanos == -999999999 + assertJSONDecodeSucceeds("\"-5s\"") { (o: MessageTestType) in + o.seconds == -5 && o.nanos == 0 + } + assertJSONDecodeSucceeds("\"-0.5s\"") { (o: MessageTestType) in + o.seconds == 0 && o.nanos == -500_000_000 + } + + assertJSONDecodeSucceeds("\"-315576000000.999999999s\"") { (o: MessageTestType) in + o.seconds == -315_576_000_000 && o.nanos == -999_999_999 } assertJSONDecodeFails("\"-315576000001s\"") - assertJSONDecodeSucceeds("\"315576000000.999999999s\"") {(o:MessageTestType) in - o.seconds == 315576000000 && o.nanos == 999999999 + assertJSONDecodeSucceeds("\"315576000000.999999999s\"") { (o: MessageTestType) in + o.seconds == 315_576_000_000 && o.nanos == 999_999_999 } assertJSONDecodeFails("\"315576000001s\"") @@ -81,65 +96,101 @@ class Test_Duration: XCTestCase, PBTestHelpers { } func testSerializationFailure() throws { - let maxOutOfRange = Google_Protobuf_Duration(seconds:-315576000001) + let maxOutOfRange = Google_Protobuf_Duration(seconds: -315_576_000_001) XCTAssertThrowsError(try maxOutOfRange.jsonString()) - let minInRange = Google_Protobuf_Duration(seconds:-315576000000, nanos: -999999999) - let _ = try minInRange.jsonString() // Assert does not throw - let maxInRange = Google_Protobuf_Duration(seconds:315576000000, nanos: 999999999) - let _ = try maxInRange.jsonString() // Assert does not throw - let minOutOfRange = Google_Protobuf_Duration(seconds:315576000001) + let minInRange = Google_Protobuf_Duration(seconds: -315_576_000_000, nanos: -999_999_999) + let _ = try minInRange.jsonString() // Assert does not throw + let maxInRange = Google_Protobuf_Duration(seconds: 315_576_000_000, nanos: 999_999_999) + let _ = try maxInRange.jsonString() // Assert does not throw + let minOutOfRange = Google_Protobuf_Duration(seconds: 315_576_000_001) XCTAssertThrowsError(try minOutOfRange.jsonString()) + // Signs don't match (a conformance test). + let posNeg = Google_Protobuf_Duration(seconds: 1, nanos: -1) + XCTAssertThrowsError(try posNeg.jsonString()) + let negPos = Google_Protobuf_Duration(seconds: -1, nanos: 1) + XCTAssertThrowsError(try negPos.jsonString()) + // Nanos only out of range (a conformance test). + let nanosTooSmall = Google_Protobuf_Duration(seconds: 0, nanos: -1_000_000_000) + XCTAssertThrowsError(try nanosTooSmall.jsonString()) + let nanosTooBig = Google_Protobuf_Duration(seconds: 0, nanos: 1_000_000_001) + XCTAssertThrowsError(try nanosTooBig.jsonString()) } // Make sure durations work correctly when stored in a field func testJSON_durationField() throws { do { - let valid = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: "{\"optionalDuration\": \"1.001s\"}") - XCTAssertEqual(valid.optionalDuration, Google_Protobuf_Duration(seconds: 1, nanos: 1000000)) + let valid = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: "{\"optionalDuration\": \"1.001s\"}") + XCTAssertEqual(valid.optionalDuration, Google_Protobuf_Duration(seconds: 1, nanos: 1_000_000)) } catch { XCTFail("Should have decoded correctly") } - XCTAssertThrowsError(try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: "{\"optionalDuration\": \"-315576000001.000000000s\"}")) + XCTAssertThrowsError( + try SwiftProtoTesting_Test3_TestAllTypesProto3( + jsonString: "{\"optionalDuration\": \"-315576000001.000000000s\"}" + ) + ) - XCTAssertThrowsError(try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: "{\"optionalDuration\": \"315576000001.000000000s\"}")) - XCTAssertThrowsError(try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: "{\"optionalDuration\": \"1.001\"}")) + XCTAssertThrowsError( + try SwiftProtoTesting_Test3_TestAllTypesProto3( + jsonString: "{\"optionalDuration\": \"315576000001.000000000s\"}" + ) + ) + XCTAssertThrowsError( + try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: "{\"optionalDuration\": \"1.001\"}") + ) } func testFieldMember() throws { // Verify behavior when a duration appears as a field on a larger object let json1 = "{\"optionalDuration\": \"-315576000000.999999999s\"}" - let m1 = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: json1) - XCTAssertEqual(m1.optionalDuration.seconds, -315576000000) - XCTAssertEqual(m1.optionalDuration.nanos, -999999999) + let m1 = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: json1) + XCTAssertEqual(m1.optionalDuration.seconds, -315_576_000_000) + XCTAssertEqual(m1.optionalDuration.nanos, -999_999_999) let json2 = "{\"repeatedDuration\": [\"1.5s\", \"-1.5s\"]}" - let expected2 = [Google_Protobuf_Duration(seconds:1, nanos:500000000), Google_Protobuf_Duration(seconds:-1, nanos:-500000000)] - let actual2 = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: json2) + let expected2 = [ + Google_Protobuf_Duration(seconds: 1, nanos: 500_000_000), + Google_Protobuf_Duration(seconds: -1, nanos: -500_000_000), + ] + let actual2 = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: json2) XCTAssertEqual(actual2.repeatedDuration, expected2) } func testTranscode() throws { let jsonMax = "{\"optionalDuration\": \"315576000000.999999999s\"}" - let parsedMax = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: jsonMax) - XCTAssertEqual(parsedMax.optionalDuration.seconds, 315576000000) - XCTAssertEqual(parsedMax.optionalDuration.nanos, 999999999) - XCTAssertEqual(try parsedMax.serializedData(), Data([234, 18, 13, 8, 128, 188, 174, 206, 151, 9, 16, 255, 147, 235, 220, 3])) + let parsedMax = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: jsonMax) + XCTAssertEqual(parsedMax.optionalDuration.seconds, 315_576_000_000) + XCTAssertEqual(parsedMax.optionalDuration.nanos, 999_999_999) + XCTAssertEqual( + try parsedMax.serializedBytes(), + [234, 18, 13, 8, 128, 188, 174, 206, 151, 9, 16, 255, 147, 235, 220, 3] + ) let jsonMin = "{\"optionalDuration\": \"-315576000000.999999999s\"}" - let parsedMin = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: jsonMin) - XCTAssertEqual(parsedMin.optionalDuration.seconds, -315576000000) - XCTAssertEqual(parsedMin.optionalDuration.nanos, -999999999) - XCTAssertEqual(try parsedMin.serializedData(), Data([234, 18, 22, 8, 128, 196, 209, 177, 232, 246, 255, 255, 255, 1, 16, 129, 236, 148, 163, 252, 255, 255, 255, 255, 1])) + let parsedMin = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: jsonMin) + XCTAssertEqual(parsedMin.optionalDuration.seconds, -315_576_000_000) + XCTAssertEqual(parsedMin.optionalDuration.nanos, -999_999_999) + XCTAssertEqual( + try parsedMin.serializedBytes(), + [ + 234, 18, 22, 8, 128, 196, 209, 177, 232, 246, 255, 255, 255, 1, 16, 129, 236, 148, 163, 252, 255, 255, + 255, 255, 1, + ] + ) } func testConformance() throws { - let tooSmall = try ProtobufTestMessages_Proto3_TestAllTypesProto3(serializedData: Data([234, 18, 11, 8, 255, 195, 209, 177, 232, 246, 255, 255, 255, 1])) - XCTAssertEqual(tooSmall.optionalDuration.seconds, -315576000001) + let tooSmall = try SwiftProtoTesting_Test3_TestAllTypesProto3(serializedBytes: [ + 234, 18, 11, 8, 255, 195, 209, 177, 232, 246, 255, 255, 255, 1, + ]) + XCTAssertEqual(tooSmall.optionalDuration.seconds, -315_576_000_001) XCTAssertEqual(tooSmall.optionalDuration.nanos, 0) XCTAssertThrowsError(try tooSmall.jsonString()) - let tooBig = try ProtobufTestMessages_Proto3_TestAllTypesProto3(serializedData: Data([234, 18, 7, 8, 129, 188, 174, 206, 151, 9])) - XCTAssertEqual(tooBig.optionalDuration.seconds, 315576000001) + let tooBig = try SwiftProtoTesting_Test3_TestAllTypesProto3(serializedBytes: [ + 234, 18, 7, 8, 129, 188, 174, 206, 151, 9, + ]) + XCTAssertEqual(tooBig.optionalDuration.seconds, 315_576_000_001) XCTAssertEqual(tooBig.optionalDuration.nanos, 0) XCTAssertThrowsError(try tooBig.jsonString()) } @@ -166,93 +217,228 @@ class Test_Duration: XCTestCase, PBTestHelpers { func testArithmeticNormalizes() throws { // Addition normalizes the result - XCTAssertEqual(Google_Protobuf_Duration() + Google_Protobuf_Duration(seconds: 0, nanos: 2000000001), - Google_Protobuf_Duration(seconds: 2, nanos: 1)) + XCTAssertEqual( + Google_Protobuf_Duration(seconds: 1, nanos: 500_000_000) + + Google_Protobuf_Duration(seconds: 1, nanos: 500_000_001), + Google_Protobuf_Duration(seconds: 3, nanos: 1) + ) + XCTAssertEqual( + Google_Protobuf_Duration(seconds: -1, nanos: -500_000_000) + + Google_Protobuf_Duration(seconds: -1, nanos: -500_000_001), + Google_Protobuf_Duration(seconds: -3, nanos: -1) + ) // Subtraction normalizes the result - XCTAssertEqual(Google_Protobuf_Duration() - Google_Protobuf_Duration(seconds: 0, nanos: 2000000001), - Google_Protobuf_Duration(seconds: -2, nanos: -1)) - // Unary minus normalizes the result - XCTAssertEqual(-Google_Protobuf_Duration(seconds: 0, nanos: 2000000001), - Google_Protobuf_Duration(seconds: -2, nanos: -1)) - XCTAssertEqual(-Google_Protobuf_Duration(seconds: 0, nanos: -2000000001), - Google_Protobuf_Duration(seconds: 2, nanos: 1)) - XCTAssertEqual(-Google_Protobuf_Duration(seconds: 1, nanos: -2000000001), - Google_Protobuf_Duration(seconds: 1, nanos: 1)) - XCTAssertEqual(-Google_Protobuf_Duration(seconds: -1, nanos: 2000000001), - Google_Protobuf_Duration(seconds: -1, nanos: -1)) - XCTAssertEqual(-Google_Protobuf_Duration(seconds: -1, nanos: -2000000001), - Google_Protobuf_Duration(seconds: 3, nanos: 1)) - XCTAssertEqual(-Google_Protobuf_Duration(seconds: 1, nanos: 2000000001), - Google_Protobuf_Duration(seconds: -3, nanos: -1)) + XCTAssertEqual( + Google_Protobuf_Duration(seconds: 0, nanos: -700_000_000) + - Google_Protobuf_Duration(seconds: 1, nanos: 500_000_000), + Google_Protobuf_Duration(seconds: -2, nanos: -200_000_000) + ) + XCTAssertEqual( + Google_Protobuf_Duration(seconds: 5, nanos: 0) - Google_Protobuf_Duration(seconds: 2, nanos: 1), + Google_Protobuf_Duration(seconds: 2, nanos: 999_999_999) + ) + XCTAssertEqual( + Google_Protobuf_Duration(seconds: 0, nanos: 0) - Google_Protobuf_Duration(seconds: 2, nanos: 1), + Google_Protobuf_Duration(seconds: -2, nanos: -1) + ) + // Unary minus normalizes the result (because it should match doing `Duration(0,0) - operand`. + XCTAssertEqual( + -Google_Protobuf_Duration(seconds: 0, nanos: 2_000_000_001), + Google_Protobuf_Duration(seconds: -2, nanos: -1) + ) + XCTAssertEqual( + -Google_Protobuf_Duration(seconds: 0, nanos: -2_000_000_001), + Google_Protobuf_Duration(seconds: 2, nanos: 1) + ) + XCTAssertEqual( + -Google_Protobuf_Duration(seconds: 1, nanos: -2_000_000_001), + Google_Protobuf_Duration(seconds: 1, nanos: 1) + ) + XCTAssertEqual( + -Google_Protobuf_Duration(seconds: -1, nanos: 2_000_000_001), + Google_Protobuf_Duration(seconds: -1, nanos: -1) + ) + XCTAssertEqual( + -Google_Protobuf_Duration(seconds: -1, nanos: -2_000_000_001), + Google_Protobuf_Duration(seconds: 3, nanos: 1) + ) + XCTAssertEqual( + -Google_Protobuf_Duration(seconds: 1, nanos: 2_000_000_001), + Google_Protobuf_Duration(seconds: -3, nanos: -1) + ) } func testFloatLiteralConvertible() throws { var a: Google_Protobuf_Duration = 1.5 - XCTAssertEqual(a, Google_Protobuf_Duration(seconds: 1, nanos: 500000000)) + XCTAssertEqual(a, Google_Protobuf_Duration(seconds: 1, nanos: 500_000_000)) a = 100.000000001 XCTAssertEqual(a, Google_Protobuf_Duration(seconds: 100, nanos: 1)) a = 1.9999999991 - XCTAssertEqual(a, Google_Protobuf_Duration(seconds: 1, nanos: 999999999)) + XCTAssertEqual(a, Google_Protobuf_Duration(seconds: 1, nanos: 999_999_999)) a = 1.9999999999 XCTAssertEqual(a, Google_Protobuf_Duration(seconds: 2, nanos: 0)) - var c = ProtobufTestMessages_Proto3_TestAllTypesProto3() + var c = SwiftProtoTesting_Test3_TestAllTypesProto3() c.optionalDuration = 100.000000001 - XCTAssertEqual(Data([234, 18, 4, 8, 100, 16, 1]), try c.serializedData()) + XCTAssertEqual([234, 18, 4, 8, 100, 16, 1], try c.serializedBytes()) XCTAssertEqual("{\"optionalDuration\":\"100.000000001s\"}", try c.jsonString()) } - func testInitializationByTimeIntervals() throws { + func testInitializationRoundingTimeIntervals() throws { // Negative interval - let t1 = Google_Protobuf_Duration(timeInterval: -123.456) + let t1 = Google_Protobuf_Duration(rounding: -123.456) XCTAssertEqual(t1.seconds, -123) - XCTAssertEqual(t1.nanos, -456000000) + XCTAssertEqual(t1.nanos, -456_000_000) // Full precision - let t2 = Google_Protobuf_Duration(timeInterval: -123.999999999) + let t2 = Google_Protobuf_Duration(rounding: -123.999999999) XCTAssertEqual(t2.seconds, -123) - XCTAssertEqual(t2.nanos, -999999999) + XCTAssertEqual(t2.nanos, -999_999_999) - // Round up - let t3 = Google_Protobuf_Duration(timeInterval: -123.9999999994) + // Value past percision, default and some explicit rules + let t3 = Google_Protobuf_Duration(rounding: -123.9999999994) XCTAssertEqual(t3.seconds, -123) - XCTAssertEqual(t3.nanos, -999999999) + XCTAssertEqual(t3.nanos, -999_999_999) + let t3u = Google_Protobuf_Duration(rounding: -123.9999999994, rule: .up) + XCTAssertEqual(t3u.seconds, -123) + XCTAssertEqual(t3u.nanos, -999_999_999) + let t3d = Google_Protobuf_Duration(rounding: -123.9999999994, rule: .down) + XCTAssertEqual(t3d.seconds, -124) + XCTAssertEqual(t3d.nanos, 0) - // Round down - let t4 = Google_Protobuf_Duration(timeInterval: -123.9999999996) + // Value past percision, default and some explicit rules + let t4 = Google_Protobuf_Duration(rounding: -123.9999999996) XCTAssertEqual(t4.seconds, -124) XCTAssertEqual(t4.nanos, 0) + let t4u = Google_Protobuf_Duration(rounding: -123.9999999996, rule: .up) + XCTAssertEqual(t4u.seconds, -123) + XCTAssertEqual(t4u.nanos, -999_999_999) + let t4d = Google_Protobuf_Duration(rounding: -123.9999999996, rule: .down) + XCTAssertEqual(t4d.seconds, -124) + XCTAssertEqual(t4d.nanos, 0) - let t5 = Google_Protobuf_Duration(timeInterval: 0) + let t5 = Google_Protobuf_Duration(rounding: 0) XCTAssertEqual(t5.seconds, 0) XCTAssertEqual(t5.nanos, 0) // Positive interval - let t6 = Google_Protobuf_Duration(timeInterval: 123.456) + let t6 = Google_Protobuf_Duration(rounding: 123.456) XCTAssertEqual(t6.seconds, 123) - XCTAssertEqual(t6.nanos, 456000000) + XCTAssertEqual(t6.nanos, 456_000_000) // Full precision - let t7 = Google_Protobuf_Duration(timeInterval: 123.999999999) + let t7 = Google_Protobuf_Duration(rounding: 123.999999999) XCTAssertEqual(t7.seconds, 123) - XCTAssertEqual(t7.nanos, 999999999) + XCTAssertEqual(t7.nanos, 999_999_999) - // Round down - let t8 = Google_Protobuf_Duration(timeInterval: 123.9999999994) + // Value past percision, default and some explicit rules + let t8 = Google_Protobuf_Duration(rounding: 123.9999999994) XCTAssertEqual(t8.seconds, 123) - XCTAssertEqual(t8.nanos, 999999999) + XCTAssertEqual(t8.nanos, 999_999_999) + let t8u = Google_Protobuf_Duration(rounding: 123.9999999994, rule: .up) + XCTAssertEqual(t8u.seconds, 124) + XCTAssertEqual(t8u.nanos, 0) + let t8d = Google_Protobuf_Duration(rounding: 123.9999999994, rule: .down) + XCTAssertEqual(t8d.seconds, 123) + XCTAssertEqual(t8d.nanos, 999_999_999) - // Round up - let t9 = Google_Protobuf_Duration(timeInterval: 123.9999999996) + // Value past percision, default and some explicit rules + let t9 = Google_Protobuf_Duration(rounding: 123.9999999996) XCTAssertEqual(t9.seconds, 124) XCTAssertEqual(t9.nanos, 0) + let t9u = Google_Protobuf_Duration(rounding: 123.9999999996, rule: .up) + XCTAssertEqual(t9u.seconds, 124) + XCTAssertEqual(t9u.nanos, 0) + let t9d = Google_Protobuf_Duration(rounding: 123.9999999996, rule: .down) + XCTAssertEqual(t9d.seconds, 123) + XCTAssertEqual(t9d.nanos, 999_999_999) } func testGetters() throws { - let t1 = Google_Protobuf_Duration(seconds: -123, nanos: -123456789) + let t1 = Google_Protobuf_Duration(seconds: -123, nanos: -123_456_789) XCTAssertEqual(t1.timeInterval, -123.123456789) - let t2 = Google_Protobuf_Duration(seconds: 123, nanos: 123456789) + let t2 = Google_Protobuf_Duration(seconds: 123, nanos: 123_456_789) XCTAssertEqual(t2.timeInterval, 123.123456789) } + + func testConvertFromStdlibDuration() throws { + guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { + throw XCTSkip("Duration is not supported on this platform") + } + + // Full precision + do { + let sd = Duration.seconds(123) + .nanoseconds(123_456_789) + let pd = Google_Protobuf_Duration(rounding: sd) + XCTAssertEqual(pd.seconds, 123) + XCTAssertEqual(pd.nanos, 123_456_789) + } + + // Default rounding (toNearestAwayFromZero) + do { + let sd = Duration(secondsComponent: 123, attosecondsComponent: 123_456_789_499_999_999) + let pd = Google_Protobuf_Duration(rounding: sd) + XCTAssertEqual(pd.seconds, 123) + XCTAssertEqual(pd.nanos, 123_456_789) + } + do { + let sd = Duration(secondsComponent: 123, attosecondsComponent: 123_456_789_500_000_000) + let pd = Google_Protobuf_Duration(rounding: sd) + XCTAssertEqual(pd.seconds, 123) + XCTAssertEqual(pd.nanos, 123_456_790) + } + + // Other rounding rules + do { + let sd = Duration(secondsComponent: 123, attosecondsComponent: 123_456_789_499_999_999) + let pd = Google_Protobuf_Duration(rounding: sd, rule: .awayFromZero) + XCTAssertEqual(pd.seconds, 123) + XCTAssertEqual(pd.nanos, 123_456_790) + } + do { + let sd = Duration(secondsComponent: 123, attosecondsComponent: 123_456_789_999_999_999) + let pd = Google_Protobuf_Duration(rounding: sd, rule: .towardZero) + XCTAssertEqual(pd.seconds, 123) + XCTAssertEqual(pd.nanos, 123_456_789) + } + + // Negative duration + do { + let sd = Duration.zero - .seconds(123) - .nanoseconds(123_456_789) + let pd = Google_Protobuf_Duration(rounding: sd) + XCTAssertEqual(pd.seconds, -123) + XCTAssertEqual(pd.nanos, -123_456_789) + } + do { + let sd = .zero - Duration(secondsComponent: 123, attosecondsComponent: 123_456_789_000_000_001) + let pd = Google_Protobuf_Duration(rounding: sd, rule: .towardZero) + XCTAssertEqual(pd.seconds, -123) + XCTAssertEqual(pd.nanos, -123_456_789) + } + do { + let sd = .zero - Duration(secondsComponent: 123, attosecondsComponent: 123_456_789_000_000_001) + let pd = Google_Protobuf_Duration(rounding: sd, rule: .awayFromZero) + XCTAssertEqual(pd.seconds, -123) + XCTAssertEqual(pd.nanos, -123_456_790) + } + } + + func testConvertToStdlibDuration() throws { + guard #available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) else { + throw XCTSkip("Duration is not supported on this platform") + } + + do { + let pd = Google_Protobuf_Duration(seconds: 123, nanos: 123_456_789) + let sd = Duration(pd) + XCTAssertEqual(sd, .seconds(123) + .nanoseconds(123_456_789)) + } + // Negative duration + do { + let pd = Google_Protobuf_Duration(seconds: -123, nanos: -123_456_789) + let sd = Duration(pd) + XCTAssertEqual(sd, .zero - (.seconds(123) + .nanoseconds(123_456_789))) + } + } } diff --git a/Tests/SwiftProtobufTests/Test_Empty.swift b/Tests/SwiftProtobufTests/Test_Empty.swift index af467626d..890e0a8f2 100644 --- a/Tests/SwiftProtobufTests/Test_Empty.swift +++ b/Tests/SwiftProtobufTests/Test_Empty.swift @@ -15,14 +15,14 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_Empty: XCTestCase, PBTestHelpers { +final class Test_Empty: XCTestCase, PBTestHelpers { typealias MessageTestType = Google_Protobuf_Empty func testExists() throws { let e = Google_Protobuf_Empty() - XCTAssertEqual(Data(), try e.serializedData()) + XCTAssertEqual([UInt8](), try e.serializedBytes()) } } diff --git a/Tests/SwiftProtobufTests/Test_Enum.swift b/Tests/SwiftProtobufTests/Test_Enum.swift index 8d40a41e7..87f981e1f 100644 --- a/Tests/SwiftProtobufTests/Test_Enum.swift +++ b/Tests/SwiftProtobufTests/Test_Enum.swift @@ -15,18 +15,19 @@ // ----------------------------------------------------------------------------- import Foundation +import SwiftProtobuf import XCTest -class Test_Enum: XCTestCase, PBTestHelpers { - typealias MessageTestType = Proto3Unittest_TestAllTypes +final class Test_Enum: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_Proto3_TestAllTypes func testEqual() { - // The message from unittest.proto doens't exist in unittest_proto3.proto + // The message from unittest.proto doesn't exist in unittest_proto3.proto } func testJSONsingular() { assertJSONEncode("{\"optionalNestedEnum\":\"FOO\"}") { (m: inout MessageTestType) in - m.optionalNestedEnum = Proto3Unittest_TestAllTypes.NestedEnum.foo + m.optionalNestedEnum = SwiftProtoTesting_Proto3_TestAllTypes.NestedEnum.foo } assertJSONEncode("{\"optionalNestedEnum\":777}") { (m: inout MessageTestType) in @@ -40,16 +41,38 @@ class Test_Enum: XCTestCase, PBTestHelpers { } } + func testJSONdecodingOptions() { + var options = JSONDecodingOptions() + + let json_with_unknown_enum_single = "{\"optionalNestedEnum\":\"NEW_VALUE\"}" + let json_with_unknown_enum_repeated = "{\"repeatedNestedEnum\":[\"FOO\",\"NEW_VALUE\", \"BAR\"]}" + + options.ignoreUnknownFields = false + assertJSONDecodeFails(json_with_unknown_enum_single) + assertJSONDecodeFails(json_with_unknown_enum_repeated) + + options.ignoreUnknownFields = true + assertJSONDecodeSucceeds(json_with_unknown_enum_single, options: options) { (m: MessageTestType) -> Bool in + // proto3 syntax, so the field should have the default value. + m.optionalNestedEnum == .zero + } + assertJSONDecodeSucceeds(json_with_unknown_enum_repeated, options: options) { (m: MessageTestType) -> Bool in + m.repeatedNestedEnum == [.foo, .bar] + } + + // SwiftProtoTesting_Proto3_TestAllTypes doesn't have a map<>, Test_Map_JSON covers this case. + } + func testUnknownValues() throws { - let orig = Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra.with { + let orig = SwiftProtoTesting_UnknownEnum_Proto3_MyMessagePlusExtra.with { $0.e = .eExtra $0.repeatedE.append(.eExtra) $0.repeatedPackedE.append(.eExtra) $0.oneofE1 = .eExtra } - let origSerialized = try orig.serializedData() - let msg = try Proto3PreserveUnknownEnumUnittest_MyMessage(serializedData: origSerialized) + let origSerialized: [UInt8] = try orig.serializedBytes() + let msg = try SwiftProtoTesting_UnknownEnum_Proto3_MyMessage(serializedBytes: origSerialized) // Nothing in unknowns, they should just be unrecognized. XCTAssertEqual(msg.e, .UNRECOGNIZED(3)) @@ -58,7 +81,7 @@ class Test_Enum: XCTestCase, PBTestHelpers { XCTAssertEqual(msg.o, .oneofE1(.UNRECOGNIZED(3))) XCTAssertTrue(msg.unknownFields.data.isEmpty) - let msgSerialized = try msg.serializedData() + let msgSerialized: [UInt8] = try msg.serializedBytes() XCTAssertEqual(origSerialized, msgSerialized) } @@ -67,92 +90,91 @@ class Test_Enum: XCTestCase, PBTestHelpers { // generated, and compile failures mean things didn't generate as expected. // Note: "firstValue" and "secondValue" on these, the enum name has been removed. - XCTAssertEqual(Protobuf3Unittest_SwiftEnumTest.EnumTest1.firstValue.rawValue, 0) - XCTAssertEqual(Protobuf3Unittest_SwiftEnumTest.EnumTest1.secondValue.rawValue, 2) - XCTAssertEqual(Protobuf3Unittest_SwiftEnumTest.EnumTest2.firstValue.rawValue, 0) - XCTAssertEqual(Protobuf3Unittest_SwiftEnumTest.EnumTest2.secondValue.rawValue, 2) + XCTAssertEqual(SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTest1.firstValue.rawValue, 0) + XCTAssertEqual(SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTest1.secondValue.rawValue, 2) + XCTAssertEqual(SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTest2.firstValue.rawValue, 0) + XCTAssertEqual(SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTest2.secondValue.rawValue, 2) // And these don't use the enum name in the value names, so nothing is trimmed. - XCTAssertEqual(Protobuf3Unittest_SwiftEnumTest.EnumTestNoStem.enumTestNoStem1.rawValue, 0) - XCTAssertEqual(Protobuf3Unittest_SwiftEnumTest.EnumTestNoStem.enumTestNoStem2.rawValue, 2) + XCTAssertEqual(SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTestNoStem.enumTestNoStem1.rawValue, 0) + XCTAssertEqual(SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTestNoStem.enumTestNoStem2.rawValue, 2) // And this checks handing of reversed words, which means backticks are needed around // some of the generated code. - XCTAssertEqual(Protobuf3Unittest_SwiftEnumTest.EnumTestReservedWord.var.rawValue, 0) - XCTAssertEqual(Protobuf3Unittest_SwiftEnumTest.EnumTestReservedWord.notReserved.rawValue, 2) + XCTAssertEqual(SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTestReservedWord.var.rawValue, 0) + XCTAssertEqual(SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTestReservedWord.notReserved.rawValue, 2) } func testEnumPrefixStripping_TextFormat() throws { var txt = "values1: [ENUM_TEST_1_FIRST_VALUE, ENUM_TEST_1_SECOND_VALUE]\n" - var msg = Protobuf3Unittest_SwiftEnumTest.with { - $0.values1 = [ .firstValue, .secondValue ] + var msg = SwiftProtoTesting_Enum3_SwiftEnumTest.with { + $0.values1 = [.firstValue, .secondValue] } XCTAssertEqual(msg.textFormatString(), txt) - var msg2 = try Protobuf3Unittest_SwiftEnumTest(textFormatString: txt) + var msg2 = try SwiftProtoTesting_Enum3_SwiftEnumTest(textFormatString: txt) XCTAssertEqual(msg2, msg) txt = "values2: [ENUM_TEST_2_FIRST_VALUE, SECOND_VALUE]\n" - msg = Protobuf3Unittest_SwiftEnumTest.with { - $0.values2 = [ .firstValue, .secondValue ] + msg = SwiftProtoTesting_Enum3_SwiftEnumTest.with { + $0.values2 = [.firstValue, .secondValue] } XCTAssertEqual(msg.textFormatString(), txt) - msg2 = try Protobuf3Unittest_SwiftEnumTest(textFormatString: txt) + msg2 = try SwiftProtoTesting_Enum3_SwiftEnumTest(textFormatString: txt) XCTAssertEqual(msg2, msg) txt = "values3: [ENUM_TEST_NO_STEM_1, ENUM_TEST_NO_STEM_2]\n" - msg = Protobuf3Unittest_SwiftEnumTest.with { - $0.values3 = [ .enumTestNoStem1, .enumTestNoStem2 ] + msg = SwiftProtoTesting_Enum3_SwiftEnumTest.with { + $0.values3 = [.enumTestNoStem1, .enumTestNoStem2] } XCTAssertEqual(msg.textFormatString(), txt) - msg2 = try Protobuf3Unittest_SwiftEnumTest(textFormatString: txt) + msg2 = try SwiftProtoTesting_Enum3_SwiftEnumTest(textFormatString: txt) XCTAssertEqual(msg2, msg) txt = "values4: [ENUM_TEST_RESERVED_WORD_VAR, ENUM_TEST_RESERVED_WORD_NOT_RESERVED]\n" - msg = Protobuf3Unittest_SwiftEnumTest.with { - $0.values4 = [ .var, .notReserved ] + msg = SwiftProtoTesting_Enum3_SwiftEnumTest.with { + $0.values4 = [.var, .notReserved] } XCTAssertEqual(msg.textFormatString(), txt) - msg2 = try Protobuf3Unittest_SwiftEnumTest(textFormatString: txt) + msg2 = try SwiftProtoTesting_Enum3_SwiftEnumTest(textFormatString: txt) XCTAssertEqual(msg2, msg) } func testEnumPrefixStripping_JSON() throws { var json = "{\"values1\":[\"ENUM_TEST_1_FIRST_VALUE\",\"ENUM_TEST_1_SECOND_VALUE\"]}" - var msg = Protobuf3Unittest_SwiftEnumTest.with { - $0.values1 = [ .firstValue, .secondValue ] + var msg = SwiftProtoTesting_Enum3_SwiftEnumTest.with { + $0.values1 = [.firstValue, .secondValue] } XCTAssertEqual(try msg.jsonString(), json) - var msg2 = try Protobuf3Unittest_SwiftEnumTest(jsonString: json) + var msg2 = try SwiftProtoTesting_Enum3_SwiftEnumTest(jsonString: json) XCTAssertEqual(msg2, msg) json = "{\"values2\":[\"ENUM_TEST_2_FIRST_VALUE\",\"SECOND_VALUE\"]}" - msg = Protobuf3Unittest_SwiftEnumTest.with { - $0.values2 = [ .firstValue, .secondValue ] + msg = SwiftProtoTesting_Enum3_SwiftEnumTest.with { + $0.values2 = [.firstValue, .secondValue] } XCTAssertEqual(try msg.jsonString(), json) - msg2 = try Protobuf3Unittest_SwiftEnumTest(jsonString: json) + msg2 = try SwiftProtoTesting_Enum3_SwiftEnumTest(jsonString: json) XCTAssertEqual(msg2, msg) json = "{\"values3\":[\"ENUM_TEST_NO_STEM_1\",\"ENUM_TEST_NO_STEM_2\"]}" - msg = Protobuf3Unittest_SwiftEnumTest.with { - $0.values3 = [ .enumTestNoStem1, .enumTestNoStem2 ] + msg = SwiftProtoTesting_Enum3_SwiftEnumTest.with { + $0.values3 = [.enumTestNoStem1, .enumTestNoStem2] } XCTAssertEqual(try msg.jsonString(), json) - msg2 = try Protobuf3Unittest_SwiftEnumTest(jsonString: json) + msg2 = try SwiftProtoTesting_Enum3_SwiftEnumTest(jsonString: json) XCTAssertEqual(msg2, msg) json = "{\"values4\":[\"ENUM_TEST_RESERVED_WORD_VAR\",\"ENUM_TEST_RESERVED_WORD_NOT_RESERVED\"]}" - msg = Protobuf3Unittest_SwiftEnumTest.with { - $0.values4 = [ .var, .notReserved ] + msg = SwiftProtoTesting_Enum3_SwiftEnumTest.with { + $0.values4 = [.var, .notReserved] } XCTAssertEqual(try msg.jsonString(), json) - msg2 = try Protobuf3Unittest_SwiftEnumTest(jsonString: json) + msg2 = try SwiftProtoTesting_Enum3_SwiftEnumTest(jsonString: json) XCTAssertEqual(msg2, msg) } func testCaseIterable() { - #if swift(>=4.2) - // proto3 syntax enums require the generator to create allCases, + // Open enums require the generator to create allCases, // ensure it is works as expected (order of the file, no aliases). - var i = Protobuf3Unittest_SwiftEnumWithAliasTest.EnumWithAlias.allCases.makeIterator() + var i = SwiftProtoTesting_Enum3_SwiftEnumWithAliasTest.EnumWithAlias.allCases.makeIterator() guard let e1 = i.next() else { XCTFail("Couldn't get first value") return @@ -171,6 +193,5 @@ class Test_Enum: XCTestCase, PBTestHelpers { XCTAssertEqual(e1, .foo1) XCTAssertEqual(e2, .baz1) XCTAssertEqual(e3, .bar1) - #endif } } diff --git a/Tests/SwiftProtobufTests/Test_EnumWithAliases.swift b/Tests/SwiftProtobufTests/Test_EnumWithAliases.swift index a5dbf4bbf..ea02ba034 100644 --- a/Tests/SwiftProtobufTests/Test_EnumWithAliases.swift +++ b/Tests/SwiftProtobufTests/Test_EnumWithAliases.swift @@ -17,46 +17,46 @@ import Foundation import XCTest -class Test_EnumWithAliases: XCTestCase, PBTestHelpers { - typealias MessageTestType = ProtobufUnittest_SwiftEnumWithAliasTest +final class Test_EnumWithAliases: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_Enum2_SwiftEnumWithAliasTest - func testJSONEncodeUsesOriginalNames() { - assertJSONEncode("{\"values\":[\"FOO1\",\"BAR1\"]}") { (m: inout MessageTestType) in - m.values = [.foo1, .bar1] - } + func testJSONEncodeUsesOriginalNames() { + assertJSONEncode("{\"values\":[\"FOO1\",\"BAR1\"]}") { (m: inout MessageTestType) in + m.values = [.foo1, .bar1] + } - assertJSONEncode("{\"values\":[\"FOO1\",\"BAR1\"]}") { (m: inout MessageTestType) in - m.values = [.foo2, .bar2] + assertJSONEncode("{\"values\":[\"FOO1\",\"BAR1\"]}") { (m: inout MessageTestType) in + m.values = [.foo2, .bar2] + } } - } - func testJSONDecodeAcceptsAllNames() throws { - assertJSONDecodeSucceeds("{\"values\":[\"FOO1\",\"BAR1\"]}") { (m: MessageTestType) in - return m.values == [.foo1, .bar1] - } + func testJSONDecodeAcceptsAllNames() throws { + assertJSONDecodeSucceeds("{\"values\":[\"FOO1\",\"BAR1\"]}") { (m: MessageTestType) in + m.values == [.foo1, .bar1] + } - assertJSONDecodeSucceeds("{\"values\":[\"FOO2\",\"BAR2\"]}") { (m: MessageTestType) in - return m.values == [.foo1, .bar1] + assertJSONDecodeSucceeds("{\"values\":[\"FOO2\",\"BAR2\"]}") { (m: MessageTestType) in + m.values == [.foo1, .bar1] + } } - } - func testTextFormatEncodeUsesOriginalNames() { - assertTextFormatEncode("values: [FOO1, BAR1]\n") { (m: inout MessageTestType) in - m.values = [.foo1, .bar1] - } + func testTextFormatEncodeUsesOriginalNames() { + assertTextFormatEncode("values: [FOO1, BAR1]\n") { (m: inout MessageTestType) in + m.values = [.foo1, .bar1] + } - assertTextFormatEncode("values: [FOO1, BAR1]\n") { (m: inout MessageTestType) in - m.values = [.foo2, .bar2] + assertTextFormatEncode("values: [FOO1, BAR1]\n") { (m: inout MessageTestType) in + m.values = [.foo2, .bar2] + } } - } - func testTextFormatDecodeAcceptsAllNames() throws { - assertTextFormatDecodeSucceeds("values: [FOO1, BAR1]\n") { (m: MessageTestType) in - return m.values == [.foo1, .bar1] - } + func testTextFormatDecodeAcceptsAllNames() throws { + assertTextFormatDecodeSucceeds("values: [FOO1, BAR1]\n") { (m: MessageTestType) in + m.values == [.foo1, .bar1] + } - assertTextFormatDecodeSucceeds("values: [FOO2, BAR2]\n") { (m: MessageTestType) in - return m.values == [.foo1, .bar1] + assertTextFormatDecodeSucceeds("values: [FOO2, BAR2]\n") { (m: MessageTestType) in + m.values == [.foo1, .bar1] + } } - } } diff --git a/Tests/SwiftProtobufTests/Test_Enum_Proto2.swift b/Tests/SwiftProtobufTests/Test_Enum_Proto2.swift index c538cd86d..0861ac9ed 100644 --- a/Tests/SwiftProtobufTests/Test_Enum_Proto2.swift +++ b/Tests/SwiftProtobufTests/Test_Enum_Proto2.swift @@ -17,12 +17,12 @@ import Foundation import XCTest -class Test_Enum_Proto2: XCTestCase, PBTestHelpers { - typealias MessageTestType = ProtobufUnittest_TestAllTypes +final class Test_Enum_Proto2: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_TestAllTypes func testEqual() { - XCTAssertEqual(ProtobufUnittest_TestEnumWithDupValue.foo1, ProtobufUnittest_TestEnumWithDupValue.foo2) - XCTAssertNotEqual(ProtobufUnittest_TestEnumWithDupValue.foo1, ProtobufUnittest_TestEnumWithDupValue.bar1) + XCTAssertEqual(SwiftProtoTesting_TestEnumWithDupValue.foo1, SwiftProtoTesting_TestEnumWithDupValue.foo2) + XCTAssertNotEqual(SwiftProtoTesting_TestEnumWithDupValue.foo1, SwiftProtoTesting_TestEnumWithDupValue.bar1) } func testUnknownIgnored() { @@ -43,7 +43,7 @@ class Test_Enum_Proto2: XCTestCase, PBTestHelpers { func testJSONsingular() { assertJSONEncode("{\"optionalNestedEnum\":\"FOO\"}") { (m: inout MessageTestType) in - m.optionalNestedEnum = ProtobufUnittest_TestAllTypes.NestedEnum.foo + m.optionalNestedEnum = SwiftProtoTesting_TestAllTypes.NestedEnum.foo } } @@ -54,15 +54,15 @@ class Test_Enum_Proto2: XCTestCase, PBTestHelpers { } func testUnknownValues() throws { - let orig = Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra.with { + let orig = SwiftProtoTesting_UnknownEnum_Proto3_MyMessagePlusExtra.with { $0.e = .eExtra $0.repeatedE.append(.eExtra) $0.repeatedPackedE.append(.eExtra) $0.oneofE1 = .eExtra } - let origSerialized = try orig.serializedData() - let msg = try Proto2PreserveUnknownEnumUnittest_MyMessage(serializedData: origSerialized) + let origSerialized: [UInt8] = try orig.serializedBytes() + let msg = try SwiftProtoTesting_UnknownEnum_Proto2_MyMessage(serializedBytes: origSerialized) // Nothing should be set, should all be in unknowns. XCTAssertFalse(msg.hasE) @@ -71,8 +71,8 @@ class Test_Enum_Proto2: XCTestCase, PBTestHelpers { XCTAssertNil(msg.o) XCTAssertFalse(msg.unknownFields.data.isEmpty) - let msgSerialized = try msg.serializedData() - let msgPrime = try Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra(serializedData: msgSerialized) + let msgSerialized: [UInt8] = try msg.serializedBytes() + let msgPrime = try SwiftProtoTesting_UnknownEnum_Proto3_MyMessagePlusExtra(serializedBytes: msgSerialized) // They should be back in the right fields. XCTAssertEqual(msgPrime.e, .eExtra) @@ -87,104 +87,103 @@ class Test_Enum_Proto2: XCTestCase, PBTestHelpers { // generated, and compile failures mean things didn't generate as expected. // Note: "firstValue" and "secondValue" on these, the enum name has been removed. - XCTAssertEqual(ProtobufUnittest_SwiftEnumTest.EnumTest1.firstValue.rawValue, 1) - XCTAssertEqual(ProtobufUnittest_SwiftEnumTest.EnumTest1.secondValue.rawValue, 2) - XCTAssertEqual(ProtobufUnittest_SwiftEnumTest.EnumTest2.firstValue.rawValue, 1) - XCTAssertEqual(ProtobufUnittest_SwiftEnumTest.EnumTest2.secondValue.rawValue, 2) + XCTAssertEqual(SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTest1.firstValue.rawValue, 1) + XCTAssertEqual(SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTest1.secondValue.rawValue, 2) + XCTAssertEqual(SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTest2.firstValue.rawValue, 1) + XCTAssertEqual(SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTest2.secondValue.rawValue, 2) // And these don't use the enum name in the value names, so nothing is trimmed. - XCTAssertEqual(ProtobufUnittest_SwiftEnumTest.EnumTestNoStem.enumTestNoStem1.rawValue, 1) - XCTAssertEqual(ProtobufUnittest_SwiftEnumTest.EnumTestNoStem.enumTestNoStem2.rawValue, 2) + XCTAssertEqual(SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTestNoStem.enumTestNoStem1.rawValue, 1) + XCTAssertEqual(SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTestNoStem.enumTestNoStem2.rawValue, 2) // And this checks handing of reversed words, which means backticks are needed around // some of the generated code. - XCTAssertEqual(ProtobufUnittest_SwiftEnumTest.EnumTestReservedWord.var.rawValue, 1) - XCTAssertEqual(ProtobufUnittest_SwiftEnumTest.EnumTestReservedWord.notReserved.rawValue, 2) + XCTAssertEqual(SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTestReservedWord.var.rawValue, 1) + XCTAssertEqual(SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTestReservedWord.notReserved.rawValue, 2) } func testEnumPrefixStripping_TextFormat() throws { var txt = "values1: ENUM_TEST_1_FIRST_VALUE\nvalues1: ENUM_TEST_1_SECOND_VALUE\n" - var msg = ProtobufUnittest_SwiftEnumTest.with { - $0.values1 = [ .firstValue, .secondValue ] + var msg = SwiftProtoTesting_Enum2_SwiftEnumTest.with { + $0.values1 = [.firstValue, .secondValue] } XCTAssertEqual(msg.textFormatString(), txt) - var msg2 = try ProtobufUnittest_SwiftEnumTest(textFormatString: txt) + var msg2 = try SwiftProtoTesting_Enum2_SwiftEnumTest(textFormatString: txt) XCTAssertEqual(msg2, msg) txt = "values2: ENUM_TEST_2_FIRST_VALUE\nvalues2: SECOND_VALUE\n" - msg = ProtobufUnittest_SwiftEnumTest.with { - $0.values2 = [ .firstValue, .secondValue ] + msg = SwiftProtoTesting_Enum2_SwiftEnumTest.with { + $0.values2 = [.firstValue, .secondValue] } XCTAssertEqual(msg.textFormatString(), txt) - msg2 = try ProtobufUnittest_SwiftEnumTest(textFormatString: txt) + msg2 = try SwiftProtoTesting_Enum2_SwiftEnumTest(textFormatString: txt) XCTAssertEqual(msg2, msg) txt = "values3: ENUM_TEST_NO_STEM_1\nvalues3: ENUM_TEST_NO_STEM_2\n" - msg = ProtobufUnittest_SwiftEnumTest.with { - $0.values3 = [ .enumTestNoStem1, .enumTestNoStem2 ] + msg = SwiftProtoTesting_Enum2_SwiftEnumTest.with { + $0.values3 = [.enumTestNoStem1, .enumTestNoStem2] } XCTAssertEqual(msg.textFormatString(), txt) - msg2 = try ProtobufUnittest_SwiftEnumTest(textFormatString: txt) + msg2 = try SwiftProtoTesting_Enum2_SwiftEnumTest(textFormatString: txt) XCTAssertEqual(msg2, msg) txt = "values4: ENUM_TEST_RESERVED_WORD_VAR\nvalues4: ENUM_TEST_RESERVED_WORD_NOT_RESERVED\n" - msg = ProtobufUnittest_SwiftEnumTest.with { - $0.values4 = [ .var, .notReserved ] + msg = SwiftProtoTesting_Enum2_SwiftEnumTest.with { + $0.values4 = [.var, .notReserved] } XCTAssertEqual(msg.textFormatString(), txt) - msg2 = try ProtobufUnittest_SwiftEnumTest(textFormatString: txt) + msg2 = try SwiftProtoTesting_Enum2_SwiftEnumTest(textFormatString: txt) XCTAssertEqual(msg2, msg) } func testEnumPrefixStripping_JSON() throws { var json = "{\"values1\":[\"ENUM_TEST_1_FIRST_VALUE\",\"ENUM_TEST_1_SECOND_VALUE\"]}" - var msg = ProtobufUnittest_SwiftEnumTest.with { - $0.values1 = [ .firstValue, .secondValue ] + var msg = SwiftProtoTesting_Enum2_SwiftEnumTest.with { + $0.values1 = [.firstValue, .secondValue] } XCTAssertEqual(try msg.jsonString(), json) - var msg2 = try ProtobufUnittest_SwiftEnumTest(jsonString: json) + var msg2 = try SwiftProtoTesting_Enum2_SwiftEnumTest(jsonString: json) XCTAssertEqual(msg2, msg) json = "{\"values2\":[\"ENUM_TEST_2_FIRST_VALUE\",\"SECOND_VALUE\"]}" - msg = ProtobufUnittest_SwiftEnumTest.with { - $0.values2 = [ .firstValue, .secondValue ] + msg = SwiftProtoTesting_Enum2_SwiftEnumTest.with { + $0.values2 = [.firstValue, .secondValue] } XCTAssertEqual(try msg.jsonString(), json) - msg2 = try ProtobufUnittest_SwiftEnumTest(jsonString: json) + msg2 = try SwiftProtoTesting_Enum2_SwiftEnumTest(jsonString: json) XCTAssertEqual(msg2, msg) json = "{\"values3\":[\"ENUM_TEST_NO_STEM_1\",\"ENUM_TEST_NO_STEM_2\"]}" - msg = ProtobufUnittest_SwiftEnumTest.with { - $0.values3 = [ .enumTestNoStem1, .enumTestNoStem2 ] + msg = SwiftProtoTesting_Enum2_SwiftEnumTest.with { + $0.values3 = [.enumTestNoStem1, .enumTestNoStem2] } XCTAssertEqual(try msg.jsonString(), json) - msg2 = try ProtobufUnittest_SwiftEnumTest(jsonString: json) + msg2 = try SwiftProtoTesting_Enum2_SwiftEnumTest(jsonString: json) XCTAssertEqual(msg2, msg) json = "{\"values4\":[\"ENUM_TEST_RESERVED_WORD_VAR\",\"ENUM_TEST_RESERVED_WORD_NOT_RESERVED\"]}" - msg = ProtobufUnittest_SwiftEnumTest.with { - $0.values4 = [ .var, .notReserved ] + msg = SwiftProtoTesting_Enum2_SwiftEnumTest.with { + $0.values4 = [.var, .notReserved] } XCTAssertEqual(try msg.jsonString(), json) - msg2 = try ProtobufUnittest_SwiftEnumTest(jsonString: json) + msg2 = try SwiftProtoTesting_Enum2_SwiftEnumTest(jsonString: json) XCTAssertEqual(msg2, msg) } func testCaseIterable() { - #if swift(>=4.2) - // proto2 syntax enums have allCases generated by the compiled, this + // Closed enums have allCases generated by the compiled, this // just ensures the generator pereserved the order of the file and // the handing of aliases doesn't confuse things. - var i = ProtobufUnittest_SwiftEnumWithAliasTest.EnumWithAlias.allCases.makeIterator() + var i = SwiftProtoTesting_Enum2_SwiftEnumWithAliasTest.EnumWithAlias.allCases.makeIterator() guard let e1 = i.next() else { - XCTFail("Couldn't get first value") - return + XCTFail("Couldn't get first value") + return } guard let e2 = i.next() else { - XCTFail("Couldn't get second value") - return + XCTFail("Couldn't get second value") + return } guard let e3 = i.next() else { - XCTFail("Couldn't get second value") - return + XCTFail("Couldn't get second value") + return } // Should be the end. XCTAssertNil(i.next()) @@ -192,6 +191,5 @@ class Test_Enum_Proto2: XCTestCase, PBTestHelpers { XCTAssertEqual(e1, .foo1) XCTAssertEqual(e2, .baz1) XCTAssertEqual(e3, .bar1) - #endif } } diff --git a/Tests/SwiftProtobufTests/Test_Extensions.swift b/Tests/SwiftProtobufTests/Test_Extensions.swift index 9c85e84f9..a9ca9b082 100644 --- a/Tests/SwiftProtobufTests/Test_Extensions.swift +++ b/Tests/SwiftProtobufTests/Test_Extensions.swift @@ -13,26 +13,36 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest // Exercise the support for Proto2 extensions. -class Test_Extensions: XCTestCase, PBTestHelpers { - typealias MessageTestType = ProtobufUnittest_TestAllExtensions +final class Test_Extensions: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_TestAllExtensions var extensions = SwiftProtobuf.SimpleExtensionMap() - func assertEncode(_ expected: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line, configure: (inout MessageTestType) -> Void) { + func assertEncode( + _ expected: [UInt8], + file: XCTestFileArgType = #file, + line: UInt = #line, + configure: (inout MessageTestType) -> Void + ) { let empty = MessageTestType() var configured = empty configure(&configured) XCTAssert(configured != empty, "Object should not be equal to empty object", file: file, line: line) do { - let encoded = try configured.serializedData() - XCTAssert(Data(expected) == encoded, "Did not encode correctly: got \(encoded)", file: file, line: line) + let encoded: [UInt8] = try configured.serializedBytes() + XCTAssert(expected == encoded, "Did not encode correctly: got \(encoded)", file: file, line: line) do { - let decoded = try MessageTestType(serializedData: encoded, extensions: extensions) - XCTAssert(decoded == configured, "Encode/decode cycle should generate equal object: \(decoded) != \(configured)", file: file, line: line) + let decoded = try MessageTestType(serializedBytes: encoded, extensions: extensions) + XCTAssert( + decoded == configured, + "Encode/decode cycle should generate equal object: \(decoded) != \(configured)", + file: file, + line: line + ) } catch { XCTFail("Failed to decode protobuf: \(encoded)", file: file, line: line) } @@ -41,14 +51,19 @@ class Test_Extensions: XCTestCase, PBTestHelpers { } } - func assertDecodeSucceeds(_ bytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line, check: (MessageTestType) -> Bool) { + func assertDecodeSucceeds( + _ bytes: [UInt8], + file: XCTestFileArgType = #file, + line: UInt = #line, + check: (MessageTestType) -> Bool + ) { do { - let decoded = try MessageTestType(serializedData: Data(bytes), extensions: extensions) + let decoded = try MessageTestType(serializedBytes: bytes, extensions: extensions) XCTAssert(check(decoded), "Condition failed for \(decoded)", file: file, line: line) - let encoded = try decoded.serializedData() + let encoded: [UInt8] = try decoded.serializedBytes() do { - let redecoded = try MessageTestType(serializedData: encoded, extensions: extensions) + let redecoded = try MessageTestType(serializedBytes: encoded, extensions: extensions) XCTAssert(check(redecoded), "Condition failed for redecoded \(redecoded)", file: file, line: line) XCTAssertEqual(decoded, redecoded, file: file, line: line) } catch { @@ -61,7 +76,7 @@ class Test_Extensions: XCTestCase, PBTestHelpers { func assertDecodeFails(_ bytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line) { do { - let _ = try MessageTestType(serializedData: Data(bytes), extensions: extensions) + let _ = try MessageTestType(serializedBytes: bytes, extensions: extensions) XCTFail("Swift decode should have failed: \(bytes)", file: file, line: line) } catch { // Yay! It failed! @@ -69,29 +84,30 @@ class Test_Extensions: XCTestCase, PBTestHelpers { } - override func setUp() { // Start with all the extensions from the unittest.proto file: - extensions = ProtobufUnittest_Unittest_Extensions + extensions = SwiftProtoTesting_Unittest_Extensions // Append another file's worth: - extensions.formUnion(ProtobufUnittest_UnittestCustomOptions_Extensions) + extensions.formUnion(SwiftProtoTesting_Extend_UnittestSwiftExtension_Extensions) // Append an array of extensions - extensions.insert(contentsOf: - [ - Extensions_RepeatedExtensionGroup, - Extensions_ExtensionGroup - ] + extensions.insert(contentsOf: [ + SwiftProtoTesting_Extensions_RepeatedExtensionGroup, + SwiftProtoTesting_Extensions_ExtensionGroup, + ] ) } func test_optionalInt32Extension() throws { assertEncode([8, 17]) { (o: inout MessageTestType) in - o.ProtobufUnittest_optionalInt32Extension = 17 + o.SwiftProtoTesting_optionalInt32Extension = 17 } - assertDecodeSucceeds([8, 99]) {$0.ProtobufUnittest_optionalInt32Extension == 99} + assertDecodeSucceeds([8, 99]) { $0.SwiftProtoTesting_optionalInt32Extension == 99 } assertDecodeFails([9]) assertDecodeFails([9, 0]) - assertDecodesAsUnknownFields([9, 0, 0, 0, 0, 0, 0, 0, 0]) // Wrong wire type (fixed64), valid as an unknown field + assertDecodesAsUnknownFields([ + 9, // Wrong wire type (fixed64), valid as an unknown field + 0, 0, 0, 0, 0, 0, 0, 0, + ]) assertDecodeFails([10]) assertDecodesAsUnknownFields([10, 0]) // Wrong wire type (length delimited), valid as an unknown field assertDecodeFails([11]) @@ -108,14 +124,17 @@ class Test_Extensions: XCTestCase, PBTestHelpers { assertDecodeFails([15, 0]) // Decoded extension should correctly compare to a manually-set extension - let m1 = try ProtobufUnittest_TestAllExtensions(serializedData: Data([8, 17]), extensions: extensions) - var m2 = ProtobufUnittest_TestAllExtensions() - m2.ProtobufUnittest_optionalInt32Extension = 17 + let m1 = try SwiftProtoTesting_TestAllExtensions(serializedBytes: [8, 17], extensions: extensions) + var m2 = SwiftProtoTesting_TestAllExtensions() + m2.SwiftProtoTesting_optionalInt32Extension = 17 XCTAssertEqual(m1, m2) - m2.ProtobufUnittest_optionalInt32Extension = 18 + m2.SwiftProtoTesting_optionalInt32Extension = 18 XCTAssertNotEqual(m1, m2) - XCTAssertEqual(m2.debugDescription, "SwiftProtobufTests.ProtobufUnittest_TestAllExtensions:\n[protobuf_unittest.optional_int32_extension]: 18\n") + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllExtensions:\n[swift_proto_testing.optional_int32_extension]: 18\n", + m2 + ) XCTAssertNotEqual(m1.hashValue, m2.hashValue) } @@ -123,71 +142,83 @@ class Test_Extensions: XCTestCase, PBTestHelpers { // An extension set with two extensions for field #5, but for // different messages and with different types var extensions = SimpleExtensionMap() - extensions.insert(ProtobufUnittest_Extensions_optional_sint32_extension) - extensions.insert(ProtobufUnittest_Extensions_my_extension_int) + extensions.insert(SwiftProtoTesting_Extensions_optional_sint32_extension) + extensions.insert(SwiftProtoTesting_Extensions_my_extension_int) // This should decode with optionalSint32Extension - let m1 = try ProtobufUnittest_TestAllExtensions(serializedData: Data([40, 1]), extensions: extensions) - XCTAssertEqual(m1.ProtobufUnittest_optionalSint32Extension, -1) + let m1 = try SwiftProtoTesting_TestAllExtensions(serializedBytes: [40, 1], extensions: extensions) + XCTAssertEqual(m1.SwiftProtoTesting_optionalSint32Extension, -1) // This should decode with myExtensionInt - let m2 = try ProtobufUnittest_TestFieldOrderings(serializedData: Data([40, 1]), extensions: extensions) - XCTAssertEqual(m2.ProtobufUnittest_myExtensionInt, 1) + let m2 = try SwiftProtoTesting_TestFieldOrderings(serializedBytes: [40, 1], extensions: extensions) + XCTAssertEqual(m2.SwiftProtoTesting_myExtensionInt, 1) } func test_optionalStringExtension() throws { assertEncode([114, 5, 104, 101, 108, 108, 111]) { (o: inout MessageTestType) in - o.ProtobufUnittest_optionalStringExtension = "hello" + o.SwiftProtoTesting_optionalStringExtension = "hello" } - assertDecodeSucceeds([114, 2, 97, 98]) {$0.ProtobufUnittest_optionalStringExtension == "ab"} + assertDecodeSucceeds([114, 2, 97, 98]) { $0.SwiftProtoTesting_optionalStringExtension == "ab" } - var m1 = ProtobufUnittest_TestAllExtensions() - m1.ProtobufUnittest_optionalStringExtension = "ab" - XCTAssertEqual(m1.debugDescription, "SwiftProtobufTests.ProtobufUnittest_TestAllExtensions:\n[protobuf_unittest.optional_string_extension]: \"ab\"\n") + var m1 = SwiftProtoTesting_TestAllExtensions() + m1.SwiftProtoTesting_optionalStringExtension = "ab" + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllExtensions:\n[swift_proto_testing.optional_string_extension]: \"ab\"\n", + m1 + ) } func test_repeatedInt32Extension() throws { assertEncode([248, 1, 7, 248, 1, 8]) { (o: inout MessageTestType) in - o.ProtobufUnittest_repeatedInt32Extension = [7, 8] + o.SwiftProtoTesting_repeatedInt32Extension = [7, 8] } - assertDecodeSucceeds([248, 1, 7]) {$0.ProtobufUnittest_repeatedInt32Extension == [7]} - assertDecodeSucceeds([248, 1, 7, 248, 1, 8]) {$0.ProtobufUnittest_repeatedInt32Extension == [7, 8]} - assertDecodeSucceeds([250, 1, 2, 7, 8]) {$0.ProtobufUnittest_repeatedInt32Extension == [7, 8]} + assertDecodeSucceeds([248, 1, 7]) { $0.SwiftProtoTesting_repeatedInt32Extension == [7] } + assertDecodeSucceeds([248, 1, 7, 248, 1, 8]) { $0.SwiftProtoTesting_repeatedInt32Extension == [7, 8] } + assertDecodeSucceeds([250, 1, 2, 7, 8]) { $0.SwiftProtoTesting_repeatedInt32Extension == [7, 8] } // Verify that the usual array access/modification operations work correctly - var m = ProtobufUnittest_TestAllExtensions() - m.ProtobufUnittest_repeatedInt32Extension = [7] - m.ProtobufUnittest_repeatedInt32Extension.append(8) - XCTAssertEqual(m.ProtobufUnittest_repeatedInt32Extension, [7, 8]) - XCTAssertEqual(m.ProtobufUnittest_repeatedInt32Extension[0], 7) - m.ProtobufUnittest_repeatedInt32Extension[1] = 9 - XCTAssertNotEqual(m.ProtobufUnittest_repeatedInt32Extension, [7, 8]) - XCTAssertEqual(m.ProtobufUnittest_repeatedInt32Extension, [7, 9]) - - XCTAssertEqual(m.debugDescription, "SwiftProtobufTests.ProtobufUnittest_TestAllExtensions:\n[protobuf_unittest.repeated_int32_extension]: 7\n[protobuf_unittest.repeated_int32_extension]: 9\n") - - XCTAssertTrue(m.hasProtobufUnittest_repeatedInt32Extension) - m.ProtobufUnittest_repeatedInt32Extension = [] - XCTAssertFalse(m.hasProtobufUnittest_repeatedInt32Extension) + var m = SwiftProtoTesting_TestAllExtensions() + m.SwiftProtoTesting_repeatedInt32Extension = [7] + m.SwiftProtoTesting_repeatedInt32Extension.append(8) + XCTAssertEqual(m.SwiftProtoTesting_repeatedInt32Extension, [7, 8]) + XCTAssertEqual(m.SwiftProtoTesting_repeatedInt32Extension[0], 7) + m.SwiftProtoTesting_repeatedInt32Extension[1] = 9 + XCTAssertNotEqual(m.SwiftProtoTesting_repeatedInt32Extension, [7, 8]) + XCTAssertEqual(m.SwiftProtoTesting_repeatedInt32Extension, [7, 9]) + + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllExtensions:\n[swift_proto_testing.repeated_int32_extension]: 7\n[swift_proto_testing.repeated_int32_extension]: 9\n", + m + ) + + XCTAssertFalse(m.SwiftProtoTesting_repeatedInt32Extension.isEmpty) + m.SwiftProtoTesting_repeatedInt32Extension = [] + XCTAssertTrue(m.SwiftProtoTesting_repeatedInt32Extension.isEmpty) } func test_defaultInt32Extension() throws { - var m = ProtobufUnittest_TestAllExtensions() - XCTAssertEqual(m.ProtobufUnittest_defaultInt32Extension, 41) + var m = SwiftProtoTesting_TestAllExtensions() + XCTAssertEqual(m.SwiftProtoTesting_defaultInt32Extension, 41) XCTAssertEqual(try m.serializedBytes(), []) - XCTAssertEqual(m.debugDescription, "SwiftProtobufTests.ProtobufUnittest_TestAllExtensions:\n") - m.ProtobufUnittest_defaultInt32Extension = 100 + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllExtensions:\n", m) + m.SwiftProtoTesting_defaultInt32Extension = 100 XCTAssertEqual(try m.serializedBytes(), [232, 3, 100]) - XCTAssertEqual(m.debugDescription, "SwiftProtobufTests.ProtobufUnittest_TestAllExtensions:\n[protobuf_unittest.default_int32_extension]: 100\n") - m.clearProtobufUnittest_defaultInt32Extension() + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllExtensions:\n[swift_proto_testing.default_int32_extension]: 100\n", + m + ) + m.clearSwiftProtoTesting_defaultInt32Extension() XCTAssertEqual(try m.serializedBytes(), []) - XCTAssertEqual(m.debugDescription, "SwiftProtobufTests.ProtobufUnittest_TestAllExtensions:\n") - m.ProtobufUnittest_defaultInt32Extension = 41 // Default value + assertDebugDescription("SwiftProtobufTests.SwiftProtoTesting_TestAllExtensions:\n", m) + m.SwiftProtoTesting_defaultInt32Extension = 41 // Default value XCTAssertEqual(try m.serializedBytes(), [232, 3, 41]) - XCTAssertEqual(m.debugDescription, "SwiftProtobufTests.ProtobufUnittest_TestAllExtensions:\n[protobuf_unittest.default_int32_extension]: 41\n") + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_TestAllExtensions:\n[swift_proto_testing.default_int32_extension]: 41\n", + m + ) assertEncode([232, 3, 17]) { (o: inout MessageTestType) in - o.ProtobufUnittest_defaultInt32Extension = 17 + o.SwiftProtoTesting_defaultInt32Extension = 17 } } @@ -195,23 +226,23 @@ class Test_Extensions: XCTestCase, PBTestHelpers { /// Verify group extensions and handling of unknown groups /// func test_groupExtension() throws { - var m = SwiftTestGroupExtensions() - var group = ExtensionGroup() + var m = SwiftProtoTesting_GroupExtensions() + var group = SwiftProtoTesting_ExtensionGroup() group.a = 7 - m.extensionGroup = group - let coded = try m.serializedData() + m.SwiftProtoTesting_extensionGroup = group + let coded: [UInt8] = try m.serializedBytes() // Deserialize into a message that lacks the group extension, then reserialize // Group should be preserved as an unknown field do { - let m2 = try SwiftTestGroupUnextended(serializedData: coded) + let m2 = try SwiftProtoTesting_GroupUnextended(serializedBytes: coded) XCTAssert(!m2.hasA) - let recoded = try m2.serializedData() + let recoded: [UInt8] = try m2.serializedBytes() // Deserialize, check the group contents were preserved. do { - let m3 = try SwiftTestGroupExtensions(serializedData: recoded, extensions: extensions) - XCTAssertEqual(m3.extensionGroup.a, 7) + let m3 = try SwiftProtoTesting_GroupExtensions(serializedBytes: recoded, extensions: extensions) + XCTAssertEqual(m3.SwiftProtoTesting_extensionGroup.a, 7) } catch { XCTFail("Bad decode/recode/decode cycle") } @@ -220,28 +251,27 @@ class Test_Extensions: XCTestCase, PBTestHelpers { } } - func test_repeatedGroupExtension() throws { - var m = SwiftTestGroupExtensions() - var group1 = RepeatedExtensionGroup() + var m = SwiftProtoTesting_GroupExtensions() + var group1 = SwiftProtoTesting_RepeatedExtensionGroup() group1.a = 7 - var group2 = RepeatedExtensionGroup() + var group2 = SwiftProtoTesting_RepeatedExtensionGroup() group2.a = 7 - m.repeatedExtensionGroup = [group1, group2] - let coded = try m.serializedData() + m.SwiftProtoTesting_repeatedExtensionGroup = [group1, group2] + let coded: [UInt8] = try m.serializedBytes() // Deserialize into a message that lacks the group extension, then reserialize // Group should be preserved as an unknown field do { - let m2 = try SwiftTestGroupUnextended(serializedData: coded) + let m2 = try SwiftProtoTesting_GroupUnextended(serializedBytes: coded) XCTAssert(!m2.hasA) do { - let recoded = try m2.serializedData() + let recoded: [UInt8] = try m2.serializedBytes() // Deserialize, check the group contents were preserved. do { - let m3 = try SwiftTestGroupExtensions(serializedData: recoded, extensions: extensions) - XCTAssertEqual(m3.repeatedExtensionGroup, [group1, group2]) + let m3 = try SwiftProtoTesting_GroupExtensions(serializedBytes: recoded, extensions: extensions) + XCTAssertEqual(m3.SwiftProtoTesting_repeatedExtensionGroup, [group1, group2]) } catch { XCTFail("Bad decode/recode/decode cycle") } @@ -252,142 +282,142 @@ class Test_Extensions: XCTestCase, PBTestHelpers { XCTFail("Decoding into unextended message failed for \(coded)") } - XCTAssertTrue(m.hasRepeatedExtensionGroup) - m.repeatedExtensionGroup = [] - XCTAssertFalse(m.hasRepeatedExtensionGroup) + XCTAssertFalse(m.SwiftProtoTesting_repeatedExtensionGroup.isEmpty) + m.SwiftProtoTesting_repeatedExtensionGroup = [] + XCTAssertTrue(m.SwiftProtoTesting_repeatedExtensionGroup.isEmpty) } func test_MessageNoStorageClass() { - var msg1 = ProtobufUnittest_Extend_MsgNoStorage() - XCTAssertFalse(msg1.hasProtobufUnittest_Extend_extA) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extA, 0) - XCTAssertFalse(msg1.hasProtobufUnittest_Extend_extB) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extB, 0) - - msg1.ProtobufUnittest_Extend_extA = 1 - msg1.ProtobufUnittest_Extend_extB = 2 - XCTAssertTrue(msg1.hasProtobufUnittest_Extend_extA) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extA, 1) - XCTAssertTrue(msg1.hasProtobufUnittest_Extend_extB) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extB, 2) + var msg1 = SwiftProtoTesting_Extend_MsgNoStorage() + XCTAssertFalse(msg1.hasSwiftProtoTesting_Extend_extA) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extA, 0) + XCTAssertFalse(msg1.hasSwiftProtoTesting_Extend_extB) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extB, 0) + + msg1.SwiftProtoTesting_Extend_extA = 1 + msg1.SwiftProtoTesting_Extend_extB = 2 + XCTAssertTrue(msg1.hasSwiftProtoTesting_Extend_extA) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extA, 1) + XCTAssertTrue(msg1.hasSwiftProtoTesting_Extend_extB) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extB, 2) var msg2 = msg1 - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extA) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extA, 1) - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extB) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extB, 2) - - msg2.ProtobufUnittest_Extend_extA = 10 - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extA) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extA, 10) - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extB) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extB, 2) - XCTAssertTrue(msg1.hasProtobufUnittest_Extend_extA) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extA, 1) - XCTAssertTrue(msg1.hasProtobufUnittest_Extend_extB) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extB, 2) - - msg1.ProtobufUnittest_Extend_extB = 3 - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extA) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extA, 10) - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extB) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extB, 2) - XCTAssertTrue(msg1.hasProtobufUnittest_Extend_extA) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extA, 1) - XCTAssertTrue(msg1.hasProtobufUnittest_Extend_extB) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extB, 3) + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extA) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extA, 1) + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extB) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extB, 2) + + msg2.SwiftProtoTesting_Extend_extA = 10 + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extA) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extA, 10) + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extB) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extB, 2) + XCTAssertTrue(msg1.hasSwiftProtoTesting_Extend_extA) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extA, 1) + XCTAssertTrue(msg1.hasSwiftProtoTesting_Extend_extB) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extB, 2) + + msg1.SwiftProtoTesting_Extend_extB = 3 + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extA) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extA, 10) + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extB) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extB, 2) + XCTAssertTrue(msg1.hasSwiftProtoTesting_Extend_extA) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extA, 1) + XCTAssertTrue(msg1.hasSwiftProtoTesting_Extend_extB) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extB, 3) msg2 = msg1 - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extA) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extA, 1) - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extB) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extB, 3) - - msg2.clearProtobufUnittest_Extend_extA() - XCTAssertFalse(msg2.hasProtobufUnittest_Extend_extA) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extA, 0) - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extB) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extB, 3) - XCTAssertTrue(msg1.hasProtobufUnittest_Extend_extA) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extA, 1) - XCTAssertTrue(msg1.hasProtobufUnittest_Extend_extB) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extB, 3) - - msg1.clearProtobufUnittest_Extend_extB() - XCTAssertFalse(msg2.hasProtobufUnittest_Extend_extA) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extA, 0) - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extB) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extB, 3) - XCTAssertTrue(msg1.hasProtobufUnittest_Extend_extA) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extA, 1) - XCTAssertFalse(msg1.hasProtobufUnittest_Extend_extB) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extB, 0) + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extA) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extA, 1) + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extB) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extB, 3) + + msg2.clearSwiftProtoTesting_Extend_extA() + XCTAssertFalse(msg2.hasSwiftProtoTesting_Extend_extA) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extA, 0) + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extB) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extB, 3) + XCTAssertTrue(msg1.hasSwiftProtoTesting_Extend_extA) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extA, 1) + XCTAssertTrue(msg1.hasSwiftProtoTesting_Extend_extB) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extB, 3) + + msg1.clearSwiftProtoTesting_Extend_extB() + XCTAssertFalse(msg2.hasSwiftProtoTesting_Extend_extA) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extA, 0) + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extB) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extB, 3) + XCTAssertTrue(msg1.hasSwiftProtoTesting_Extend_extA) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extA, 1) + XCTAssertFalse(msg1.hasSwiftProtoTesting_Extend_extB) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extB, 0) } func test_MessageUsingStorageClass() { - var msg1 = ProtobufUnittest_Extend_MsgUsesStorage() - XCTAssertFalse(msg1.hasProtobufUnittest_Extend_extC) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extC, 0) - XCTAssertFalse(msg1.hasProtobufUnittest_Extend_extD) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extD, 0) - - msg1.ProtobufUnittest_Extend_extC = 1 - msg1.ProtobufUnittest_Extend_extD = 2 - XCTAssertTrue(msg1.hasProtobufUnittest_Extend_extC) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extC, 1) - XCTAssertTrue(msg1.hasProtobufUnittest_Extend_extD) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extD, 2) + var msg1 = SwiftProtoTesting_Extend_MsgUsesStorage() + XCTAssertFalse(msg1.hasSwiftProtoTesting_Extend_extC) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extC, 0) + XCTAssertFalse(msg1.hasSwiftProtoTesting_Extend_extD) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extD, 0) + + msg1.SwiftProtoTesting_Extend_extC = 1 + msg1.SwiftProtoTesting_Extend_extD = 2 + XCTAssertTrue(msg1.hasSwiftProtoTesting_Extend_extC) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extC, 1) + XCTAssertTrue(msg1.hasSwiftProtoTesting_Extend_extD) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extD, 2) var msg2 = msg1 - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extC) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extC, 1) - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extD) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extD, 2) - - msg2.ProtobufUnittest_Extend_extC = 10 - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extC) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extC, 10) - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extD) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extD, 2) - XCTAssertTrue(msg1.hasProtobufUnittest_Extend_extC) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extC, 1) - XCTAssertTrue(msg1.hasProtobufUnittest_Extend_extD) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extD, 2) - - msg1.ProtobufUnittest_Extend_extD = 3 - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extC) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extC, 10) - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extD) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extD, 2) - XCTAssertTrue(msg1.hasProtobufUnittest_Extend_extC) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extC, 1) - XCTAssertTrue(msg1.hasProtobufUnittest_Extend_extD) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extD, 3) + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extC) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extC, 1) + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extD) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extD, 2) + + msg2.SwiftProtoTesting_Extend_extC = 10 + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extC) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extC, 10) + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extD) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extD, 2) + XCTAssertTrue(msg1.hasSwiftProtoTesting_Extend_extC) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extC, 1) + XCTAssertTrue(msg1.hasSwiftProtoTesting_Extend_extD) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extD, 2) + + msg1.SwiftProtoTesting_Extend_extD = 3 + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extC) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extC, 10) + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extD) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extD, 2) + XCTAssertTrue(msg1.hasSwiftProtoTesting_Extend_extC) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extC, 1) + XCTAssertTrue(msg1.hasSwiftProtoTesting_Extend_extD) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extD, 3) msg2 = msg1 - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extC) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extC, 1) - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extD) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extD, 3) - - msg2.clearProtobufUnittest_Extend_extC() - XCTAssertFalse(msg2.hasProtobufUnittest_Extend_extC) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extC, 0) - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extD) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extD, 3) - XCTAssertTrue(msg1.hasProtobufUnittest_Extend_extC) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extC, 1) - XCTAssertTrue(msg1.hasProtobufUnittest_Extend_extD) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extD, 3) - - msg1.clearProtobufUnittest_Extend_extD() - XCTAssertFalse(msg2.hasProtobufUnittest_Extend_extC) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extC, 0) - XCTAssertTrue(msg2.hasProtobufUnittest_Extend_extD) - XCTAssertEqual(msg2.ProtobufUnittest_Extend_extD, 3) - XCTAssertTrue(msg1.hasProtobufUnittest_Extend_extC) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extC, 1) - XCTAssertFalse(msg1.hasProtobufUnittest_Extend_extD) - XCTAssertEqual(msg1.ProtobufUnittest_Extend_extD, 0) + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extC) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extC, 1) + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extD) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extD, 3) + + msg2.clearSwiftProtoTesting_Extend_extC() + XCTAssertFalse(msg2.hasSwiftProtoTesting_Extend_extC) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extC, 0) + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extD) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extD, 3) + XCTAssertTrue(msg1.hasSwiftProtoTesting_Extend_extC) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extC, 1) + XCTAssertTrue(msg1.hasSwiftProtoTesting_Extend_extD) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extD, 3) + + msg1.clearSwiftProtoTesting_Extend_extD() + XCTAssertFalse(msg2.hasSwiftProtoTesting_Extend_extC) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extC, 0) + XCTAssertTrue(msg2.hasSwiftProtoTesting_Extend_extD) + XCTAssertEqual(msg2.SwiftProtoTesting_Extend_extD, 3) + XCTAssertTrue(msg1.hasSwiftProtoTesting_Extend_extC) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extC, 1) + XCTAssertFalse(msg1.hasSwiftProtoTesting_Extend_extD) + XCTAssertEqual(msg1.SwiftProtoTesting_Extend_extD, 0) } } diff --git a/Tests/SwiftProtobufTests/Test_ExtremeDefaultValues.swift b/Tests/SwiftProtobufTests/Test_ExtremeDefaultValues.swift index 83dd712da..22a42b459 100644 --- a/Tests/SwiftProtobufTests/Test_ExtremeDefaultValues.swift +++ b/Tests/SwiftProtobufTests/Test_ExtremeDefaultValues.swift @@ -21,145 +21,135 @@ import XCTest // Verify that the Swift backend correctly encodes various // extreme values when generating code that applies defaults. // -class Test_ExtremeDefaultValues: XCTestCase { +final class Test_ExtremeDefaultValues: XCTestCase { func test_escapedBytes() { - let m = ProtobufUnittest_TestExtremeDefaultValues() + let m = SwiftProtoTesting_TestExtremeDefaultValues() XCTAssertEqual(m.escapedBytes, Data([0, 1, 7, 8, 12, 10, 13, 9, 11, 92, 39, 34, 254])) } func test_largeUint32() { - let m = ProtobufUnittest_TestExtremeDefaultValues() - XCTAssertEqual(m.largeUint32, 0xFFFFFFFF) + let m = SwiftProtoTesting_TestExtremeDefaultValues() + XCTAssertEqual(m.largeUint32, 0xFFFF_FFFF) } func test_largeUint64() { - let m = ProtobufUnittest_TestExtremeDefaultValues() - XCTAssertEqual(m.largeUint64, 0xFFFFFFFFFFFFFFFF) + let m = SwiftProtoTesting_TestExtremeDefaultValues() + XCTAssertEqual(m.largeUint64, 0xFFFF_FFFF_FFFF_FFFF) } func test_smallInt32() { - let m = ProtobufUnittest_TestExtremeDefaultValues() - XCTAssertEqual(m.smallInt32, -0x7fffffff) + let m = SwiftProtoTesting_TestExtremeDefaultValues() + XCTAssertEqual(m.smallInt32, -0x7fff_ffff) } func test_smallInt64() { - let m = ProtobufUnittest_TestExtremeDefaultValues() - XCTAssertEqual(m.smallInt64, -0x7fffffffffffffff) + let m = SwiftProtoTesting_TestExtremeDefaultValues() + XCTAssertEqual(m.smallInt64, -0x7fff_ffff_ffff_ffff) } func test_reallySmallInt32() { - let m = ProtobufUnittest_TestExtremeDefaultValues() - XCTAssertEqual(m.reallySmallInt32, -0x80000000) + let m = SwiftProtoTesting_TestExtremeDefaultValues() + XCTAssertEqual(m.reallySmallInt32, -0x8000_0000) } func test_reallySmallInt64() { - let m = ProtobufUnittest_TestExtremeDefaultValues() - XCTAssertEqual(m.reallySmallInt64, -0x8000000000000000) + let m = SwiftProtoTesting_TestExtremeDefaultValues() + XCTAssertEqual(m.reallySmallInt64, -0x8000_0000_0000_0000) } func test_utf8String() { - let m = ProtobufUnittest_TestExtremeDefaultValues() - XCTAssertEqual(m.utf8String, "ሴ") // Unicode u1234 + let m = SwiftProtoTesting_TestExtremeDefaultValues() + XCTAssertEqual(m.utf8String, "ሴ") // Unicode u1234 XCTAssertEqual(m.utf8String, "\u{1234}") } func test_zeroFloat() { - let m = ProtobufUnittest_TestExtremeDefaultValues() + let m = SwiftProtoTesting_TestExtremeDefaultValues() XCTAssertEqual(m.zeroFloat, 0.0) } func test_oneFloat() { - let m = ProtobufUnittest_TestExtremeDefaultValues() + let m = SwiftProtoTesting_TestExtremeDefaultValues() XCTAssertEqual(m.oneFloat, 1.0) } func test_smallFloat() { - let m = ProtobufUnittest_TestExtremeDefaultValues() + let m = SwiftProtoTesting_TestExtremeDefaultValues() XCTAssertEqual(m.smallFloat, 1.5) } func test_negativeOneFloat() { - let m = ProtobufUnittest_TestExtremeDefaultValues() + let m = SwiftProtoTesting_TestExtremeDefaultValues() XCTAssertEqual(m.negativeOneFloat, -1) } func test_negativeFloat() { - let m = ProtobufUnittest_TestExtremeDefaultValues() + let m = SwiftProtoTesting_TestExtremeDefaultValues() XCTAssertEqual(m.negativeFloat, -1.5) } func test_largeFloat() { - let m = ProtobufUnittest_TestExtremeDefaultValues() + let m = SwiftProtoTesting_TestExtremeDefaultValues() XCTAssertEqual(m.largeFloat, 2E8) } func test_smallNegativeFloat() { - let m = ProtobufUnittest_TestExtremeDefaultValues() + let m = SwiftProtoTesting_TestExtremeDefaultValues() XCTAssertEqual(m.smallNegativeFloat, -8e-28) } func test_infDouble() { - let m = ProtobufUnittest_TestExtremeDefaultValues() + let m = SwiftProtoTesting_TestExtremeDefaultValues() XCTAssertEqual(m.infDouble, Double.infinity) } func test_negInfDouble() { - let m = ProtobufUnittest_TestExtremeDefaultValues() + let m = SwiftProtoTesting_TestExtremeDefaultValues() XCTAssertEqual(m.negInfDouble, -Double.infinity) } func test_nanDouble() { - let m = ProtobufUnittest_TestExtremeDefaultValues() + let m = SwiftProtoTesting_TestExtremeDefaultValues() XCTAssert(m.nanDouble.isNaN) } func test_infFloat() { - let m = ProtobufUnittest_TestExtremeDefaultValues() + let m = SwiftProtoTesting_TestExtremeDefaultValues() XCTAssertEqual(m.infFloat, Float.infinity) XCTAssert(m.infFloat.isInfinite) XCTAssertEqual(m.infFloat.sign, FloatingPointSign.plus) } func test_negInfFloat() { - let m = ProtobufUnittest_TestExtremeDefaultValues() + let m = SwiftProtoTesting_TestExtremeDefaultValues() XCTAssertEqual(m.negInfFloat, -Float.infinity) XCTAssert(m.negInfFloat.isInfinite) XCTAssertEqual(m.negInfFloat.sign, FloatingPointSign.minus) } func test_nanFloat() { - let m = ProtobufUnittest_TestExtremeDefaultValues() + let m = SwiftProtoTesting_TestExtremeDefaultValues() XCTAssert(m.nanFloat.isNaN) } func test_cppTrigraph() { - let m = ProtobufUnittest_TestExtremeDefaultValues() + let m = SwiftProtoTesting_TestExtremeDefaultValues() XCTAssertEqual(m.cppTrigraph, "? ? ?? ?? ??? ??/ ??-") } func test_stringWithZero() { - let m = ProtobufUnittest_TestExtremeDefaultValues() + let m = SwiftProtoTesting_TestExtremeDefaultValues() XCTAssertEqual(m.stringWithZero, "hel\0lo") } func test_bytesWithZero() { - let m = ProtobufUnittest_TestExtremeDefaultValues() + let m = SwiftProtoTesting_TestExtremeDefaultValues() XCTAssertEqual(m.bytesWithZero, Data([119, 111, 114, 0, 108, 100])) } - func test_stringPieceWithZero() { - let m = ProtobufUnittest_TestExtremeDefaultValues() - XCTAssertEqual(m.stringPieceWithZero, "ab\0c") - } - - func test_cordWithZero() { - let m = ProtobufUnittest_TestExtremeDefaultValues() - XCTAssertEqual(m.cordWithZero, "12\03") - } - func test_replacementString() { - let m = ProtobufUnittest_TestExtremeDefaultValues() + let m = SwiftProtoTesting_TestExtremeDefaultValues() XCTAssertEqual(m.replacementString, "${unknown}") } } diff --git a/Tests/SwiftProtobufTests/Test_FieldMask.swift b/Tests/SwiftProtobufTests/Test_FieldMask.swift index 044cd7c5c..7ad8c75c9 100644 --- a/Tests/SwiftProtobufTests/Test_FieldMask.swift +++ b/Tests/SwiftProtobufTests/Test_FieldMask.swift @@ -13,14 +13,11 @@ /// // ----------------------------------------------------------------------------- -// TODO: We should have utility functions for applying a mask to an arbitrary -// message, intersecting two masks, etc. - import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_FieldMask: XCTestCase, PBTestHelpers { +final class Test_FieldMask: XCTestCase, PBTestHelpers { typealias MessageTestType = Google_Protobuf_FieldMask func testJSON() { @@ -32,7 +29,7 @@ class Test_FieldMask: XCTestCase, PBTestHelpers { } // assertJSONEncode doesn't want an empty object, hand roll it. let msg = MessageTestType.with { (o: inout MessageTestType) in - o.paths = [] + o.paths = [] } XCTAssertEqual(try msg.jsonString(), "\"\"") assertJSONDecodeSucceeds("\"foo\"") { $0.paths == ["foo"] } @@ -44,8 +41,8 @@ class Test_FieldMask: XCTestCase, PBTestHelpers { assertJSONDecodeFails("\"foo,,bar\"") assertJSONDecodeFails("\"foo,bar") assertJSONDecodeFails("foo,bar\"") - assertJSONDecodeFails("\"H̱ܻ̻ܻ̻ܶܶAܻD\"") // Reject non-ASCII - assertJSONDecodeFails("abc_def") // Reject underscores + assertJSONDecodeFails("\"H̱ܻ̻ܻ̻ܶܶAܻD\"") // Reject non-ASCII + assertJSONDecodeFails("abc_def") // Reject underscores } func testProtobuf() { @@ -57,7 +54,7 @@ class Test_FieldMask: XCTestCase, PBTestHelpers { func testDebugDescription() { var m = Google_Protobuf_FieldMask() m.paths = ["foo", "bar"] - XCTAssertEqual(m.debugDescription, "SwiftProtobuf.Google_Protobuf_FieldMask:\npaths: \"foo\"\npaths: \"bar\"\n") + assertDebugDescriptionSuffix(".Google_Protobuf_FieldMask:\npaths: \"foo\"\npaths: \"bar\"\n", m) } func testConvenienceInits() { @@ -82,7 +79,9 @@ class Test_FieldMask: XCTestCase, PBTestHelpers { // Make sure field mask works correctly when stored in a field func testJSON_field() throws { do { - let valid = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: "{\"optionalFieldMask\": \"foo,barBaz\"}") + let valid = try SwiftProtoTesting_Test3_TestAllTypesProto3( + jsonString: "{\"optionalFieldMask\": \"foo,barBaz\"}" + ) XCTAssertEqual(valid.optionalFieldMask, Google_Protobuf_FieldMask(protoPaths: "foo", "bar_baz")) } catch { XCTFail("Should have decoded correctly") @@ -91,13 +90,15 @@ class Test_FieldMask: XCTestCase, PBTestHelpers { // https://github.com/protocolbuffers/protobuf/issues/4734 resulted in a new conformance // test to confirm an empty string works. do { - let valid = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: "{\"optionalFieldMask\": \"\"}") + let valid = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: "{\"optionalFieldMask\": \"\"}") XCTAssertEqual(valid.optionalFieldMask, Google_Protobuf_FieldMask()) } catch { XCTFail("Should have decoded correctly") } - XCTAssertThrowsError(try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: "{\"optionalFieldMask\": \"foo,bar_bar\"}")) + XCTAssertThrowsError( + try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: "{\"optionalFieldMask\": \"foo,bar_bar\"}") + ) } func testSerializationFailure() { @@ -109,4 +110,714 @@ class Test_FieldMask: XCTestCase, PBTestHelpers { XCTAssertThrowsError(try m.jsonString()) } } + + // Checks merge functionality for field masks. + func testMergeFieldsOfMessage() throws { + var message = SwiftProtoTesting_TestAllTypes.with { model in + model.optionalInt32 = 1 + model.optionalNestedMessage = .with { nested in + nested.bb = 2 + } + } + + let secondMessage = SwiftProtoTesting_TestAllTypes.with { model in + model.optionalInt32 = 2 + model.optionalNestedMessage = .with { nested in + nested.bb = 3 + } + } + + // Checks nested message merge + try message.merge(from: secondMessage, fieldMask: .init(protoPaths: "optional_nested_message.bb")) + XCTAssertEqual(message.optionalInt32, 1) + XCTAssertEqual(message.optionalNestedMessage.bb, 3) + + // Checks primitive type merge + try message.merge(from: secondMessage, fieldMask: .init(protoPaths: "optional_int32")) + XCTAssertEqual(message.optionalInt32, 2) + XCTAssertEqual(message.optionalNestedMessage.bb, 3) + } + + // Checks merge functionality for repeated field masks. + func testMergeRepeatedFieldsOfMessage() throws { + var message = SwiftProtoTesting_TestAllTypes.with { model in + model.repeatedInt32 = [1, 2] + } + + let secondMessage = SwiftProtoTesting_TestAllTypes.with { model in + model.repeatedInt32 = [3, 4] + } + + let fieldMask = Google_Protobuf_FieldMask(protoPaths: ["repeated_int32"]) + + // Checks without replacing repeated fields + try message.merge(from: secondMessage, fieldMask: fieldMask) + XCTAssertEqual(message.repeatedInt32, [1, 2, 3, 4]) + + // Checks with replacing repeated fields + var options = Google_Protobuf_FieldMask.MergeOptions() + options.replaceRepeatedFields = true + try message.merge(from: secondMessage, fieldMask: fieldMask, mergeOption: options) + XCTAssertEqual(message.repeatedInt32, [3, 4]) + } + + // Checks merge functionality for map field masks. + func testMergeMapFieldsOfMessage() throws { + var message = SwiftProtoTesting_Fuzz_Message.with { model in + model.mapInt32String = [1: "a", 2: "c"] + } + + let secondMessage = SwiftProtoTesting_Fuzz_Message.with { model in + model.mapInt32String = [2: "b"] + } + + let fieldMask = Google_Protobuf_FieldMask(protoPaths: ["map_int32_string"]) + + // Checks without replacing repeated fields + try message.merge(from: secondMessage, fieldMask: fieldMask) + XCTAssertEqual(message.mapInt32String, [1: "a", 2: "b"]) + + // Checks with replacing repeated fields + var options = Google_Protobuf_FieldMask.MergeOptions() + options.replaceRepeatedFields = true + try message.merge(from: secondMessage, fieldMask: fieldMask, mergeOption: options) + XCTAssertEqual(message.mapInt32String, [2: "b"]) + } + + // Checks trim functionality for field masks. + func testTrimFieldsOfMessage() throws { + var message = SwiftProtoTesting_TestAllTypes.with { model in + model.optionalInt32 = 1 + model.optionalNestedMessage = .with { nested in + nested.bb = 2 + } + } + + // Checks trim to be successful. + let r1 = message.trim(keeping: .init(protoPaths: "optional_nested_message.bb")) + XCTAssertTrue(r1) + XCTAssertEqual(message.optionalInt32, 0) + XCTAssertEqual(message.optionalNestedMessage.bb, 2) + + // Checks trim should do nothing with an empty fieldMask. + let r2 = message.trim(keeping: .init()) + XCTAssertFalse(r2) + + // Checks trim should return false if nothing has been changed. + let r3 = message.trim(keeping: .init(protoPaths: "optional_nested_message.bb")) + XCTAssertFalse(r3) + + // Checks trim to be unsuccessful with an invalid fieldMask. + let r4 = message.trim(keeping: .init(protoPaths: "invalid_path")) + XCTAssertFalse(r4) + } + + // Checks trim functionality for field masks when applies on a extensible message. + func testTrimFieldsOfMessageWithExtension() throws { + var message = SwiftProtoTesting_Fuzz_Message() + message.singularInt32 = 1 + message.SwiftProtoTesting_Fuzz_singularInt32Ext = 1 + let mask = Google_Protobuf_FieldMask(protoPaths: ["singular_string"]) + + // Checks trim should retain extensions while removes other fields. + let r1 = message.trim(keeping: mask) + XCTAssertTrue(r1) + XCTAssertEqual(message.SwiftProtoTesting_Fuzz_singularInt32Ext, .init(1)) + XCTAssertEqual(message.singularInt32, .init(0)) + + // Checks trim should do nothing (fields are already removed) and still retain extension fields. + let r2 = message.trim(keeping: mask) + XCTAssertFalse(r2) + XCTAssertEqual(message.SwiftProtoTesting_Fuzz_singularInt32Ext, .init(1)) + } + + // Checks `isPathValid` func + // 1. Valid primitive path. + // 2, 3. Valid nested path. (for message and group) + // 4. Invalid primitive path. + // 5, 6. Invalid nested path. + // 7, 8. Invalid path after map and repeated. + // 9. Invalid path after group. + func testIsPathValid() { + XCTAssertTrue(SwiftProtoTesting_TestAllTypes.isPathValid("optional_int32")) + XCTAssertTrue(SwiftProtoTesting_TestAllTypes.isPathValid("optional_nested_message.bb")) + XCTAssertTrue(SwiftProtoTesting_Fuzz_Message.isPathValid("SingularGroup.group_field")) + XCTAssertFalse(SwiftProtoTesting_TestAllTypes.isPathValid("optional_int")) + XCTAssertFalse(SwiftProtoTesting_TestAllTypes.isPathValid("optional_nested_message.bc")) + XCTAssertFalse(SwiftProtoTesting_TestAllTypes.isPathValid("optional_nested_message.bb.a")) + XCTAssertFalse(SwiftProtoTesting_TestAllTypes.isPathValid("repeatedInt32.a")) + XCTAssertFalse(SwiftProtoTesting_Fuzz_Message.isPathValid("map_bool_int32.a")) + XCTAssertFalse(SwiftProtoTesting_Fuzz_Message.isPathValid("SingularGroup.a")) + } + + // Checks `isValid` func of FieldMask. + // 1. Empty field mask is always valid. + // 2, 3. Valid field masks. + // 4, 5. Invalid field masks. + func testIsFieldMaskValid() { + let m1 = Google_Protobuf_FieldMask() + let m2 = Google_Protobuf_FieldMask(protoPaths: [ + "optional_int32", + "optional_nested_message.bb", + ]) + let m3 = Google_Protobuf_FieldMask(protoPaths: [ + "optional_int32", + "optional_nested_message", + ]) + let m4 = Google_Protobuf_FieldMask(protoPaths: [ + "optional_int32", + "optional_nested_message.bc", + ]) + let m5 = Google_Protobuf_FieldMask(protoPaths: [ + "optional_int", + "optional_nested_message.bb", + ]) + XCTAssertTrue(m1.isValid(for: SwiftProtoTesting_TestAllTypes.self)) + XCTAssertTrue(m2.isValid(for: SwiftProtoTesting_TestAllTypes.self)) + XCTAssertTrue(m3.isValid(for: SwiftProtoTesting_TestAllTypes.self)) + XCTAssertFalse(m4.isValid(for: SwiftProtoTesting_TestAllTypes.self)) + XCTAssertFalse(m5.isValid(for: SwiftProtoTesting_TestAllTypes.self)) + } + + // Checks canonincal form of field mask. + // 1. Sub-message with parent in the paths should be excluded. + // 2. Canonincal form should be sorted. + // 3. More nested levels of paths with duplicates. + // 4. Two siblings with their parent should be excluded. + func testCanonicalFieldMask() { + let m1 = Google_Protobuf_FieldMask(protoPaths: ["a.b", "a", "b"]) + XCTAssertEqual(m1.canonical.paths, ["a", "b"]) + let m2 = Google_Protobuf_FieldMask(protoPaths: ["b", "a"]) + XCTAssertEqual(m2.canonical.paths, ["a", "b"]) + let m3 = Google_Protobuf_FieldMask(protoPaths: ["c", "a.b.c", "a.b", "a.b", "a.b.c.d"]) + XCTAssertEqual(m3.canonical.paths, ["a.b", "c"]) + let m4 = Google_Protobuf_FieldMask(protoPaths: ["a.c", "a", "a.b"]) + XCTAssertEqual(m4.canonical.paths, ["a"]) + } + + // Checks `addPath` func of fieldMask with: + // - Valid primitive path should be added. + // - Valid nested path should be added. + // - Invalid path should throw error. + func testAddPathToFieldMask() throws { + var mask = Google_Protobuf_FieldMask() + XCTAssertNoThrow(try mask.addPath("optional_int32", of: SwiftProtoTesting_TestAllTypes.self)) + XCTAssertEqual(mask.paths, ["optional_int32"]) + XCTAssertNoThrow(try mask.addPath("optional_nested_message.bb", of: SwiftProtoTesting_TestAllTypes.self)) + XCTAssertEqual(mask.paths, ["optional_int32", "optional_nested_message.bb"]) + XCTAssertThrowsError(try mask.addPath("optional_int", of: SwiftProtoTesting_TestAllTypes.self)) + } + + // Check `contains` func of fieldMask. + // 1. Parent contains sub-message. + // 2. Path contains itself. + // 3. Sub-message does not contain its parent. + // 4. Two different paths does not contain each other. + // 5. Two different sub-paths does not contain each other. + func testPathContainsInFieldMask() { + let m1 = Google_Protobuf_FieldMask(protoPaths: ["a"]) + XCTAssertTrue(m1.contains("a.b")) + let m2 = Google_Protobuf_FieldMask(protoPaths: ["a"]) + XCTAssertTrue(m2.contains("a")) + let m3 = Google_Protobuf_FieldMask(protoPaths: ["a.b"]) + XCTAssertFalse(m3.contains("a")) + let m4 = Google_Protobuf_FieldMask(protoPaths: ["a"]) + XCTAssertFalse(m4.contains("b")) + let m5 = Google_Protobuf_FieldMask(protoPaths: ["a.b"]) + XCTAssertFalse(m5.contains("a.c")) + } + + // Checks inits of fieldMask with: + // - All fields of a message type. + // - Particular field numbers of a message type. + func testFieldPathMessageInits() throws { + let m1 = Google_Protobuf_FieldMask(allFieldsOf: SwiftProtoTesting_TestAny.self) + XCTAssertEqual(m1.paths.sorted(), ["any_value", "int32_value", "repeated_any_value", "text"]) + let m2 = try Google_Protobuf_FieldMask(fieldNumbers: [1, 2], of: SwiftProtoTesting_TestAny.self) + XCTAssertEqual(m2.paths.sorted(), ["any_value", "int32_value"]) + XCTAssertThrowsError(try Google_Protobuf_FieldMask(fieldNumbers: [10], of: SwiftProtoTesting_TestAny.self)) + } + + // Checks that json names of paths should not be contained in mask field with allFieldsOf init. + func testFieldMaskAllPathsWithUniqueName() { + let mask = Google_Protobuf_FieldMask(allFieldsOf: SwiftProtoTesting_Fuzz_Message.self) + // proto name is included + XCTAssertTrue(mask.paths.contains("SingularGroup")) + // json name is not included + XCTAssertFalse(mask.paths.contains("singulargroup")) + } + + // Checks `union` func of fieldMask. + func testUnionFieldMasks() throws { + let m1 = Google_Protobuf_FieldMask(protoPaths: ["a", "b"]) + let m2 = Google_Protobuf_FieldMask(protoPaths: ["b", "c"]) + XCTAssertEqual(m1.union(m2).paths, ["a", "b", "c"]) + + let m3 = Google_Protobuf_FieldMask(protoPaths: ["a", "b"]) + let m4 = Google_Protobuf_FieldMask(protoPaths: ["c", "d"]) + XCTAssertEqual(m3.union(m4).paths, ["a", "b", "c", "d"]) + + let m5 = Google_Protobuf_FieldMask() + let m6 = Google_Protobuf_FieldMask(protoPaths: ["c", "d"]) + XCTAssertEqual(m5.union(m6).paths, ["c", "d"]) + + let m7 = Google_Protobuf_FieldMask(protoPaths: ["a", "b"]) + let m8 = Google_Protobuf_FieldMask(protoPaths: ["a", "b"]) + XCTAssertEqual(m7.union(m8).paths, ["a", "b"]) + + let m9 = Google_Protobuf_FieldMask(protoPaths: ["a", "a"]) + let m10 = Google_Protobuf_FieldMask(protoPaths: ["a", "b"]) + XCTAssertEqual(m9.union(m10).paths, ["a", "b"]) + } + + // Checks `intersect` func of fieldMask. + func testIntersectFieldMasks() throws { + let m1 = Google_Protobuf_FieldMask(protoPaths: ["a", "b"]) + let m2 = Google_Protobuf_FieldMask(protoPaths: ["b", "c"]) + XCTAssertEqual(m1.intersect(m2).paths, ["b"]) + + let m3 = Google_Protobuf_FieldMask(protoPaths: ["a", "b"]) + let m4 = Google_Protobuf_FieldMask(protoPaths: ["c", "d"]) + XCTAssertEqual(m3.intersect(m4).paths, []) + + let m5 = Google_Protobuf_FieldMask() + let m6 = Google_Protobuf_FieldMask(protoPaths: ["c", "d"]) + XCTAssertEqual(m5.intersect(m6).paths, []) + + let m7 = Google_Protobuf_FieldMask(protoPaths: ["a", "b"]) + let m8 = Google_Protobuf_FieldMask(protoPaths: ["a", "b"]) + XCTAssertEqual(m7.intersect(m8).paths, ["a", "b"]) + + let m9 = Google_Protobuf_FieldMask(protoPaths: ["a", "a"]) + let m10 = Google_Protobuf_FieldMask(protoPaths: ["a", "b"]) + XCTAssertEqual(m9.intersect(m10).paths, ["a"]) + } + + // Checks `substract` func of fieldMask. + func testSubtractFieldMasks() throws { + let m1 = Google_Protobuf_FieldMask(protoPaths: ["a", "b"]) + let m2 = Google_Protobuf_FieldMask(protoPaths: ["b", "c"]) + XCTAssertEqual(m1.subtract(m2).paths, ["a"]) + + let m3 = Google_Protobuf_FieldMask(protoPaths: ["a", "b"]) + let m4 = Google_Protobuf_FieldMask(protoPaths: ["c", "d"]) + XCTAssertEqual(m3.subtract(m4).paths, ["a", "b"]) + + let m5 = Google_Protobuf_FieldMask() + let m6 = Google_Protobuf_FieldMask(protoPaths: ["c", "d"]) + XCTAssertEqual(m5.subtract(m6).paths, []) + + let m7 = Google_Protobuf_FieldMask(protoPaths: ["a", "b"]) + let m8 = Google_Protobuf_FieldMask(protoPaths: ["a", "b"]) + XCTAssertEqual(m7.subtract(m8).paths, []) + + let m9 = Google_Protobuf_FieldMask(protoPaths: ["a", "a"]) + let m10 = Google_Protobuf_FieldMask(protoPaths: ["b"]) + XCTAssertEqual(m9.subtract(m10).paths, ["a"]) + } + + // Checks whether all field types could be merged. + func testMergeAllFields() throws { + var m1 = SwiftProtoTesting_Fuzz_Message() + let m2 = SwiftProtoTesting_Fuzz_Message.with { m in + m.singularInt32 = 1 + m.singularInt64 = 1 + m.singularUint32 = 1 + m.singularUint64 = 1 + m.singularSint32 = 1 + m.singularSint64 = 1 + m.singularFixed32 = 1 + m.singularFixed64 = 1 + m.singularSfixed32 = 1 + m.singularSfixed64 = 1 + m.singularFloat = 1 + m.singularDouble = 1 + m.singularBool = true + m.singularString = "str" + m.singularBytes = "str".data(using: .utf8) ?? .init() + m.singularEnum = .two + m.singularGroup = .with { $0.groupField = 1 } + m.singularMessage = .with { $0.singularInt32 = 1 } + m.repeatedInt32 = [1] + m.repeatedInt64 = [1] + m.repeatedUint32 = [1] + m.repeatedUint64 = [1] + m.repeatedSint32 = [1] + m.repeatedSint64 = [1] + m.repeatedFixed32 = [1] + m.repeatedFixed64 = [1] + m.repeatedSfixed32 = [1] + m.repeatedSfixed64 = [1] + m.repeatedFloat = [1] + m.repeatedDouble = [1] + m.repeatedBool = [true] + m.repeatedString = ["str"] + m.repeatedBytes = ["str".data(using: .utf8) ?? .init()] + m.repeatedEnum = [.two] + m.repeatedGroup = [.with { $0.groupField = 1 }] + m.repeatedMessage = [.with { $0.singularInt32 = 1 }] + m.o = .oneofInt32(1) + m.repeatedPackedInt32 = [1] + m.repeatedPackedInt64 = [1] + m.repeatedPackedUint32 = [1] + m.repeatedPackedUint64 = [1] + m.repeatedPackedSint32 = [1] + m.repeatedPackedSint64 = [1] + m.repeatedPackedFixed32 = [1] + m.repeatedPackedFixed64 = [1] + m.repeatedPackedSfixed32 = [1] + m.repeatedPackedSfixed64 = [1] + m.repeatedPackedFloat = [1] + m.repeatedPackedDouble = [1] + m.repeatedPackedBool = [true] + m.repeatedPackedEnum = [.two] + m.mapInt32Int32 = [1: 1] + m.mapInt32Int64 = [1: 1] + m.mapInt32Uint32 = [1: 1] + m.mapInt32Uint64 = [1: 1] + m.mapInt32Sint32 = [1: 1] + m.mapInt32Sint64 = [1: 1] + m.mapInt32Fixed32 = [1: 1] + m.mapInt32Fixed64 = [1: 1] + m.mapInt32AnEnum = [1: .one] + m.mapInt32Message = [1: .init()] + } + try m1.merge(from: m2, fieldMask: .init(allFieldsOf: SwiftProtoTesting_Fuzz_Message.self)) + XCTAssertEqual(m1.singularInt32, m2.singularInt32) + XCTAssertEqual(m1.singularInt64, m2.singularInt64) + XCTAssertEqual(m1.singularUint32, m2.singularUint32) + XCTAssertEqual(m1.singularUint64, m2.singularUint64) + XCTAssertEqual(m1.singularSint32, m2.singularSint32) + XCTAssertEqual(m1.singularSint64, m2.singularSint64) + XCTAssertEqual(m1.singularFixed32, m2.singularFixed32) + XCTAssertEqual(m1.singularFixed64, m2.singularFixed64) + XCTAssertEqual(m1.singularSfixed32, m2.singularSfixed32) + XCTAssertEqual(m1.singularSfixed64, m2.singularSfixed64) + XCTAssertEqual(m1.singularFloat, m2.singularFloat) + XCTAssertEqual(m1.singularDouble, m2.singularDouble) + XCTAssertEqual(m1.singularBool, m2.singularBool) + XCTAssertEqual(m1.singularString, m2.singularString) + XCTAssertEqual(m1.singularBytes, m2.singularBytes) + XCTAssertEqual(m1.singularEnum, m2.singularEnum) + XCTAssertEqual(m1.singularGroup, m2.singularGroup) + XCTAssertEqual(m1.singularMessage, m2.singularMessage) + XCTAssertEqual(m1.repeatedInt32, m2.repeatedInt32) + XCTAssertEqual(m1.repeatedInt64, m2.repeatedInt64) + XCTAssertEqual(m1.repeatedUint32, m2.repeatedUint32) + XCTAssertEqual(m1.repeatedUint64, m2.repeatedUint64) + XCTAssertEqual(m1.repeatedSint32, m2.repeatedSint32) + XCTAssertEqual(m1.repeatedSint64, m2.repeatedSint64) + XCTAssertEqual(m1.repeatedFixed32, m2.repeatedFixed32) + XCTAssertEqual(m1.repeatedFixed64, m2.repeatedFixed64) + XCTAssertEqual(m1.repeatedSfixed32, m2.repeatedSfixed32) + XCTAssertEqual(m1.repeatedSfixed64, m2.repeatedSfixed64) + XCTAssertEqual(m1.repeatedFloat, m2.repeatedFloat) + XCTAssertEqual(m1.repeatedDouble, m2.repeatedDouble) + XCTAssertEqual(m1.repeatedBool, m2.repeatedBool) + XCTAssertEqual(m1.repeatedString, m2.repeatedString) + XCTAssertEqual(m1.repeatedBytes, m2.repeatedBytes) + XCTAssertEqual(m1.repeatedEnum, m2.repeatedEnum) + XCTAssertEqual(m1.repeatedGroup, m2.repeatedGroup) + XCTAssertEqual(m1.repeatedMessage, m2.repeatedMessage) + XCTAssertEqual(m1.o, m2.o) + XCTAssertEqual(m1.repeatedPackedInt32, m2.repeatedPackedInt32) + XCTAssertEqual(m1.repeatedPackedInt64, m2.repeatedPackedInt64) + XCTAssertEqual(m1.repeatedPackedUint32, m2.repeatedPackedUint32) + XCTAssertEqual(m1.repeatedPackedUint64, m2.repeatedPackedUint64) + XCTAssertEqual(m1.repeatedPackedSint32, m2.repeatedPackedSint32) + XCTAssertEqual(m1.repeatedPackedSint64, m2.repeatedPackedSint64) + XCTAssertEqual(m1.repeatedPackedFixed32, m2.repeatedPackedFixed32) + XCTAssertEqual(m1.repeatedPackedFixed64, m2.repeatedPackedFixed64) + XCTAssertEqual(m1.repeatedPackedSfixed32, m2.repeatedPackedSfixed32) + XCTAssertEqual(m1.repeatedPackedSfixed64, m2.repeatedPackedSfixed64) + XCTAssertEqual(m1.repeatedPackedFloat, m2.repeatedPackedFloat) + XCTAssertEqual(m1.repeatedPackedDouble, m2.repeatedPackedDouble) + XCTAssertEqual(m1.repeatedPackedBool, m2.repeatedPackedBool) + XCTAssertEqual(m1.repeatedPackedEnum, m2.repeatedPackedEnum) + XCTAssertEqual(m1.mapInt32Int32, m2.mapInt32Int32) + XCTAssertEqual(m1.mapInt32Int64, m2.mapInt32Int64) + XCTAssertEqual(m1.mapInt32Uint32, m2.mapInt32Uint32) + XCTAssertEqual(m1.mapInt32Uint64, m2.mapInt32Uint64) + XCTAssertEqual(m1.mapInt32Sint32, m2.mapInt32Sint32) + XCTAssertEqual(m1.mapInt32Sint64, m2.mapInt32Sint64) + XCTAssertEqual(m1.mapInt32Fixed32, m2.mapInt32Fixed32) + XCTAssertEqual(m1.mapInt32Fixed64, m2.mapInt32Fixed64) + XCTAssertEqual(m1.mapInt32AnEnum, m2.mapInt32AnEnum) + XCTAssertEqual(m1.mapInt32Message, m2.mapInt32Message) + } + + // Checks whether a group of fields could be merged without merging the others. + func testMergeFieldsPartially() throws { + var m1 = SwiftProtoTesting_Fuzz_Message() + let m2 = SwiftProtoTesting_Fuzz_Message.with { m in + m.singularInt32 = 1 + m.singularInt64 = 1 + m.singularUint32 = 1 + m.singularUint64 = 1 + m.singularSint32 = 1 + m.singularSint64 = 1 + m.singularFixed32 = 1 + m.singularFixed64 = 1 + m.singularSfixed32 = 1 + m.singularSfixed64 = 1 + m.singularFloat = 1 + m.singularDouble = 1 + m.singularBool = true + m.singularString = "str" + m.singularBytes = "str".data(using: .utf8) ?? .init() + m.singularEnum = .two + m.singularGroup = .with { $0.groupField = 1 } + m.singularMessage = .with { $0.singularInt32 = 1 } + m.repeatedInt32 = [1] + m.repeatedInt64 = [1] + m.repeatedUint32 = [1] + m.repeatedUint64 = [1] + m.repeatedSint32 = [1] + m.repeatedSint64 = [1] + m.repeatedFixed32 = [1] + m.repeatedFixed64 = [1] + m.repeatedSfixed32 = [1] + m.repeatedSfixed64 = [1] + m.repeatedFloat = [1] + m.repeatedDouble = [1] + m.repeatedBool = [true] + m.repeatedString = ["str"] + m.repeatedBytes = ["str".data(using: .utf8) ?? .init()] + m.repeatedEnum = [.two] + m.repeatedGroup = [.with { $0.groupField = 1 }] + m.repeatedMessage = [.with { $0.singularInt32 = 1 }] + m.o = .oneofInt32(1) + m.repeatedPackedInt32 = [1] + m.repeatedPackedInt64 = [1] + m.repeatedPackedUint32 = [1] + m.repeatedPackedUint64 = [1] + m.repeatedPackedSint32 = [1] + m.repeatedPackedSint64 = [1] + m.repeatedPackedFixed32 = [1] + m.repeatedPackedFixed64 = [1] + m.repeatedPackedSfixed32 = [1] + m.repeatedPackedSfixed64 = [1] + m.repeatedPackedFloat = [1] + m.repeatedPackedDouble = [1] + m.repeatedPackedBool = [true] + m.repeatedPackedEnum = [.two] + m.mapInt32Int32 = [1: 1] + m.mapInt32Int64 = [1: 1] + m.mapInt32Uint32 = [1: 1] + m.mapInt32Uint64 = [1: 1] + m.mapInt32Sint32 = [1: 1] + m.mapInt32Sint64 = [1: 1] + m.mapInt32Fixed32 = [1: 1] + m.mapInt32Fixed64 = [1: 1] + m.mapInt32AnEnum = [1: .one] + m.mapInt32Message = [1: .init()] + } + let mask = Google_Protobuf_FieldMask(protoPaths: [ + "singular_int32", + "singular_int64", + "singular_uint32", + "singular_uint64", + "singular_sint32", + "singular_sint64", + "singular_fixed32", + "singular_fixed64", + "singular_sfixed32", + "singular_sfixed64", + ]) + try m1.merge(from: m2, fieldMask: mask) + XCTAssertEqual(m1.singularInt32, m2.singularInt32) + XCTAssertEqual(m1.singularInt64, m2.singularInt64) + XCTAssertEqual(m1.singularUint32, m2.singularUint32) + XCTAssertEqual(m1.singularUint64, m2.singularUint64) + XCTAssertEqual(m1.singularSint32, m2.singularSint32) + XCTAssertEqual(m1.singularSint64, m2.singularSint64) + XCTAssertEqual(m1.singularFixed32, m2.singularFixed32) + XCTAssertEqual(m1.singularFixed64, m2.singularFixed64) + XCTAssertEqual(m1.singularSfixed32, m2.singularSfixed32) + XCTAssertEqual(m1.singularSfixed64, m2.singularSfixed64) + XCTAssertNotEqual(m1.singularFloat, m2.singularFloat) + XCTAssertNotEqual(m1.singularDouble, m2.singularDouble) + XCTAssertNotEqual(m1.singularBool, m2.singularBool) + XCTAssertNotEqual(m1.singularString, m2.singularString) + XCTAssertNotEqual(m1.singularBytes, m2.singularBytes) + XCTAssertNotEqual(m1.singularEnum, m2.singularEnum) + XCTAssertNotEqual(m1.singularGroup, m2.singularGroup) + XCTAssertNotEqual(m1.singularMessage, m2.singularMessage) + XCTAssertNotEqual(m1.repeatedInt32, m2.repeatedInt32) + XCTAssertNotEqual(m1.repeatedInt64, m2.repeatedInt64) + XCTAssertNotEqual(m1.repeatedUint32, m2.repeatedUint32) + XCTAssertNotEqual(m1.repeatedUint64, m2.repeatedUint64) + XCTAssertNotEqual(m1.repeatedSint32, m2.repeatedSint32) + XCTAssertNotEqual(m1.repeatedSint64, m2.repeatedSint64) + XCTAssertNotEqual(m1.repeatedFixed32, m2.repeatedFixed32) + XCTAssertNotEqual(m1.repeatedFixed64, m2.repeatedFixed64) + XCTAssertNotEqual(m1.repeatedSfixed32, m2.repeatedSfixed32) + XCTAssertNotEqual(m1.repeatedSfixed64, m2.repeatedSfixed64) + XCTAssertNotEqual(m1.repeatedFloat, m2.repeatedFloat) + XCTAssertNotEqual(m1.repeatedDouble, m2.repeatedDouble) + XCTAssertNotEqual(m1.repeatedBool, m2.repeatedBool) + XCTAssertNotEqual(m1.repeatedString, m2.repeatedString) + XCTAssertNotEqual(m1.repeatedBytes, m2.repeatedBytes) + XCTAssertNotEqual(m1.repeatedEnum, m2.repeatedEnum) + XCTAssertNotEqual(m1.repeatedGroup, m2.repeatedGroup) + XCTAssertNotEqual(m1.repeatedMessage, m2.repeatedMessage) + XCTAssertNotEqual(m1.o, m2.o) + XCTAssertNotEqual(m1.repeatedPackedInt32, m2.repeatedPackedInt32) + XCTAssertNotEqual(m1.repeatedPackedInt64, m2.repeatedPackedInt64) + XCTAssertNotEqual(m1.repeatedPackedUint32, m2.repeatedPackedUint32) + XCTAssertNotEqual(m1.repeatedPackedUint64, m2.repeatedPackedUint64) + XCTAssertNotEqual(m1.repeatedPackedSint32, m2.repeatedPackedSint32) + XCTAssertNotEqual(m1.repeatedPackedSint64, m2.repeatedPackedSint64) + XCTAssertNotEqual(m1.repeatedPackedFixed32, m2.repeatedPackedFixed32) + XCTAssertNotEqual(m1.repeatedPackedFixed64, m2.repeatedPackedFixed64) + XCTAssertNotEqual(m1.repeatedPackedSfixed32, m2.repeatedPackedSfixed32) + XCTAssertNotEqual(m1.repeatedPackedSfixed64, m2.repeatedPackedSfixed64) + XCTAssertNotEqual(m1.repeatedPackedFloat, m2.repeatedPackedFloat) + XCTAssertNotEqual(m1.repeatedPackedDouble, m2.repeatedPackedDouble) + XCTAssertNotEqual(m1.repeatedPackedBool, m2.repeatedPackedBool) + XCTAssertNotEqual(m1.repeatedPackedEnum, m2.repeatedPackedEnum) + XCTAssertNotEqual(m1.mapInt32Int32, m2.mapInt32Int32) + XCTAssertNotEqual(m1.mapInt32Int64, m2.mapInt32Int64) + XCTAssertNotEqual(m1.mapInt32Uint32, m2.mapInt32Uint32) + XCTAssertNotEqual(m1.mapInt32Uint64, m2.mapInt32Uint64) + XCTAssertNotEqual(m1.mapInt32Sint32, m2.mapInt32Sint32) + XCTAssertNotEqual(m1.mapInt32Sint64, m2.mapInt32Sint64) + XCTAssertNotEqual(m1.mapInt32Fixed32, m2.mapInt32Fixed32) + XCTAssertNotEqual(m1.mapInt32Fixed64, m2.mapInt32Fixed64) + XCTAssertNotEqual(m1.mapInt32AnEnum, m2.mapInt32AnEnum) + XCTAssertNotEqual(m1.mapInt32Message, m2.mapInt32Message) + } + + // Checks merge could be done for an optional path with nil value. + func testMergeOptionalValue() throws { + var m1 = SwiftProtoTesting_Fuzz_Message.with { m in + m.singularInt32 = 1 + } + let m2 = SwiftProtoTesting_Fuzz_Message() + try m1.merge(from: m2, fieldMask: .init(protoPaths: ["singular_int32"])) + XCTAssertEqual(m1.singularInt32, m2.singularInt32) + } + + // Checks merge could be done for an optional path with default value. + func testMergeDefaultValue() throws { + var m1 = SwiftProtoTesting_TestAllTypes.with { m in + m.defaultInt32 = 1 + } + let m2 = SwiftProtoTesting_TestAllTypes() + try m1.merge(from: m2, fieldMask: .init(protoPaths: ["default_int32"])) + XCTAssertEqual(m1.defaultInt32, m2.defaultInt32) + } + + // Checks merge could be done for non-optional paths. + func testMergeNonOptionalValues() throws { + var m1 = try SwiftProtoTesting_Proto3_TestAllTypes.with { m in + m.optionalInt32 = 1 + m.optionalInt64 = 1 + m.optionalDouble = 1 + m.optionalFloat = 1 + m.optionalString = "str" + m.optionalBool = true + m.optionalBytes = try XCTUnwrap("str".data(using: .utf8)) + m.optionalUint32 = 1 + m.optionalUint64 = 1 + m.optionalSint32 = 1 + m.optionalSint64 = 1 + m.optionalFixed32 = 1 + m.optionalFixed64 = 1 + m.optionalSfixed32 = 1 + m.optionalSfixed64 = 1 + m.optionalNestedEnum = .bar + } + let m2 = SwiftProtoTesting_Proto3_TestAllTypes() + try m1.merge( + from: m2, + fieldMask: .init(protoPaths: [ + "optional_int32", + "optional_int64", + "optional_double", + "optional_float", + "optional_string", + "optional_bool", + "optional_bytes", + "optional_uint32", + "optional_uint64", + "optional_sint32", + "optional_sint64", + "optional_fixed32", + "optional_fixed64", + "optional_sfixed32", + "optional_sfixed64", + "optional_nested_enum", + ]) + ) + XCTAssertEqual(m1.optionalInt32, m2.optionalInt32) + XCTAssertEqual(m1.optionalInt64, m2.optionalInt64) + XCTAssertEqual(m1.optionalDouble, m2.optionalDouble) + XCTAssertEqual(m1.optionalFloat, m2.optionalFloat) + XCTAssertEqual(m1.optionalString, m2.optionalString) + XCTAssertEqual(m1.optionalBool, m2.optionalBool) + XCTAssertEqual(m1.optionalBytes, m2.optionalBytes) + XCTAssertEqual(m1.optionalUint32, m2.optionalUint32) + XCTAssertEqual(m1.optionalUint64, m2.optionalUint64) + XCTAssertEqual(m1.optionalSint32, m2.optionalSint32) + XCTAssertEqual(m1.optionalSint64, m2.optionalSint64) + XCTAssertEqual(m1.optionalFixed32, m2.optionalFixed32) + XCTAssertEqual(m1.optionalFixed64, m2.optionalFixed64) + XCTAssertEqual(m1.optionalSfixed32, m2.optionalSfixed32) + XCTAssertEqual(m1.optionalSfixed64, m2.optionalSfixed64) + XCTAssertEqual(m1.optionalNestedEnum, m2.optionalNestedEnum) + XCTAssertEqual(m1.optionalSint32, m2.optionalSint32) + } + + // Checks if merge works with nested proto messages + func testMergeNestedMessages() throws { + var m1 = SwiftProtoTesting_Fuzz_Message() + let m2 = SwiftProtoTesting_Fuzz_Message.with { m in + m.singularMessage = .with { _m in + _m.singularMessage = .with { __m in + __m.singularInt32 = 1 + } + } + } + let m3 = SwiftProtoTesting_Fuzz_Message.with { m in + m.singularMessage = .with { _m in + _m.singularMessage = .with { __m in + __m.singularInt32 = 2 + } + } + } + try m1.merge(from: m2, fieldMask: .init(protoPaths: ["singular_message.singular_message"])) + XCTAssertEqual(m1.singularMessage.singularMessage.singularInt32, Int32(1)) + try m1.merge(from: m3, fieldMask: .init(protoPaths: ["singular_message.singular_message.singular_int32"])) + XCTAssertEqual(m1.singularMessage.singularMessage.singularInt32, Int32(2)) + } + + // Checks merging nested path inside groups + func testMergeNestedGroups() throws { + var m1 = SwiftProtoTesting_Fuzz_Message() + let m2 = SwiftProtoTesting_Fuzz_Message.with { m in + m.singularGroup = .with { _m in + _m.groupField = 1 + } + } + try m1.merge(from: m2, fieldMask: .init(protoPaths: ["SingularGroup.group_field"])) + XCTAssertEqual(m1.singularGroup.groupField, m2.singularGroup.groupField) + } + + // Checks that merging with json path should do nothing. Path should only be merged using proto names. + func testMergeFieldWithJSONName() throws { + var m1 = SwiftProtoTesting_Fuzz_Message() + let m2 = SwiftProtoTesting_Fuzz_Message.with { m in + m.singularGroup = .with { $0.groupField = 1 } + } + // should do nothing with json path (should not merge) + try m1.merge(from: m2, fieldMask: .with({ $0.paths = ["singulargroup"] })) + XCTAssertNotEqual(m1.singularGroup, m2.singularGroup) + // should merge with proto path + try m1.merge(from: m2, fieldMask: .with({ $0.paths = ["SingularGroup"] })) + XCTAssertEqual(m1.singularGroup, m2.singularGroup) + // should do nothing with json path (do not clear field) + try m1.merge(from: m2, fieldMask: .with({ $0.paths = ["singulargroup"] })) + XCTAssertEqual(m1.singularGroup, m2.singularGroup) + } } diff --git a/Tests/SwiftProtobufTests/Test_FieldOrdering.swift b/Tests/SwiftProtobufTests/Test_FieldOrdering.swift index 31c5fa5ec..ccfaf5ff3 100644 --- a/Tests/SwiftProtobufTests/Test_FieldOrdering.swift +++ b/Tests/SwiftProtobufTests/Test_FieldOrdering.swift @@ -20,8 +20,8 @@ import Foundation import XCTest -class Test_FieldOrdering: XCTestCase { - typealias MessageTestType = Swift_Protobuf_TestFieldOrderings +final class Test_FieldOrdering: XCTestCase { + typealias MessageTestType = SwiftProtoTesting_Order_TestFieldOrderings func test_FieldOrdering() throws { var m = MessageTestType() @@ -32,15 +32,27 @@ class Test_FieldOrdering: XCTestCase { nest.oo = 1 nest.bb = 2 m.optionalNestedMessage = nest - m.Swift_Protobuf_myExtensionInt = 12 - m.Swift_Protobuf_myExtensionString = "def" + m.SwiftProtoTesting_Order_myExtensionInt = 12 + m.SwiftProtoTesting_Order_myExtensionString = "def" m.oneofInt32 = 7 - let encoded1 = try m.serializedBytes() - XCTAssertEqual([8, 1, 40, 12, 80, 7, 90, 3, 97, 98, 99, 146, 3, 3, 100, 101, 102, 173, 6, 0, 0, 128, 63, 194, 12, 4, 8, 2, 16, 1], encoded1) + let encoded1: [UInt8] = try m.serializedBytes() + XCTAssertEqual( + [ + 8, 1, 40, 12, 80, 7, 90, 3, 97, 98, 99, 146, 3, 3, 100, 101, 102, 173, 6, 0, 0, 128, 63, 194, 12, 4, 8, + 2, 16, 1, + ], + encoded1 + ) m.oneofInt64 = 8 - let encoded2 = try m.serializedBytes() - XCTAssertEqual([8, 1, 40, 12, 90, 3, 97, 98, 99, 146, 3, 3, 100, 101, 102, 224, 3, 8, 173, 6, 0, 0, 128, 63, 194, 12, 4, 8, 2, 16, 1], encoded2) + let encoded2: [UInt8] = try m.serializedBytes() + XCTAssertEqual( + [ + 8, 1, 40, 12, 90, 3, 97, 98, 99, 146, 3, 3, 100, 101, 102, 224, 3, 8, 173, 6, 0, 0, 128, 63, 194, 12, 4, + 8, 2, 16, 1, + ], + encoded2 + ) } } diff --git a/Tests/SwiftProtobufTests/Test_FuzzTests.swift b/Tests/SwiftProtobufTests/Test_FuzzTests.swift index b8ea0919d..c5f9ec184 100644 --- a/Tests/SwiftProtobufTests/Test_FuzzTests.swift +++ b/Tests/SwiftProtobufTests/Test_FuzzTests.swift @@ -21,136 +21,197 @@ // Easily get the hex dumps via `xxd -i < _test_case_file_` import Foundation +import SwiftProtobuf import XCTest -class Test_FuzzTests: XCTestCase { - - func assertBinaryFails(_ bytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line) { - XCTAssertThrowsError( - try Fuzz_Testing_Message(serializedData: Data(bytes), extensions: Fuzz_Testing_FuzzTesting_Extensions), - file: file, line: line) - } - - func assertJSONFails(_ jsonBytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line) { - XCTAssertThrowsError( - try Fuzz_Testing_Message(jsonUTF8Data: Data(jsonBytes), extensions: Fuzz_Testing_FuzzTesting_Extensions), - file: file, line: line) - } - - func assertJSONFails(_ json: String, file: XCTestFileArgType = #file, line: UInt = #line) { - XCTAssertThrowsError( - try Fuzz_Testing_Message(jsonString: json, extensions: Fuzz_Testing_FuzzTesting_Extensions), - file: file, line: line) - } - - func assertTextFormatFails(_ textFormat: String, file: XCTestFileArgType = #file, line: UInt = #line) { - XCTAssertThrowsError( - try Fuzz_Testing_Message(textFormatString: textFormat, extensions: Fuzz_Testing_FuzzTesting_Extensions), - file: file, line: line) - } - - func assertTextFormatFails(_ asBytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line) { - guard let str = String(data: Data(asBytes), encoding: .utf8) else { - XCTFail("Failed to make a string", file: file, line: line) - return +final class Test_FuzzTests: XCTestCase { + + func assertBinaryFails(_ bytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line) { + XCTAssertThrowsError( + try SwiftProtoTesting_Fuzz_Message( + serializedBytes: bytes, + extensions: SwiftProtoTesting_Fuzz_FuzzTesting_Extensions + ), + file: file, + line: line + ) } - XCTAssertThrowsError( - try Fuzz_Testing_Message(textFormatString: str, extensions: Fuzz_Testing_FuzzTesting_Extensions), - file: file, line: line) - } - - func assertTextFormatSucceeds(_ textFormat: String, file: XCTestFileArgType = #file, line: UInt = #line) { - XCTAssertNoThrow( - try Fuzz_Testing_Message(textFormatString: textFormat, extensions: Fuzz_Testing_FuzzTesting_Extensions), - file: file, line: line) - } - - func assertTextFormatSucceeds(_ asBytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line) { - guard let str = String(data: Data(asBytes), encoding: .utf8) else { - XCTFail("Failed to make a string", file: file, line: line) - return + + func assertJSONFails(_ jsonBytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line) { + XCTAssertThrowsError( + try SwiftProtoTesting_Fuzz_Message( + jsonUTF8Bytes: jsonBytes, + extensions: SwiftProtoTesting_Fuzz_FuzzTesting_Extensions + ), + file: file, + line: line + ) + } + + func assertJSONFails(_ json: String, file: XCTestFileArgType = #file, line: UInt = #line) { + XCTAssertThrowsError( + try SwiftProtoTesting_Fuzz_Message( + jsonString: json, + extensions: SwiftProtoTesting_Fuzz_FuzzTesting_Extensions + ), + file: file, + line: line + ) + } + + func assertTextFormatFails( + _ textFormat: String, + options: TextFormatDecodingOptions = TextFormatDecodingOptions(), + file: XCTestFileArgType = #file, + line: UInt = #line + ) { + XCTAssertThrowsError( + try SwiftProtoTesting_Fuzz_Message( + textFormatString: textFormat, + options: options, + extensions: SwiftProtoTesting_Fuzz_FuzzTesting_Extensions + ), + file: file, + line: line + ) + } + + func assertTextFormatFails( + _ asBytes: [UInt8], + options: TextFormatDecodingOptions = TextFormatDecodingOptions(), + file: XCTestFileArgType = #file, + line: UInt = #line + ) { + guard let str = String(data: Data(asBytes), encoding: .utf8) else { + print( + """ + Failed to make string (at \(file):\(line)): nothing to try and decode. + The fuzzer does not fail in this case and neither should we, skipping test. + """ + ) + return + } + XCTAssertThrowsError( + try SwiftProtoTesting_Fuzz_Message( + textFormatString: str, + options: options, + extensions: SwiftProtoTesting_Fuzz_FuzzTesting_Extensions + ), + file: file, + line: line + ) + } + + func assertTextFormatSucceeds( + _ textFormat: String, + options: TextFormatDecodingOptions = TextFormatDecodingOptions(), + file: XCTestFileArgType = #file, + line: UInt = #line + ) { + XCTAssertNoThrow( + try SwiftProtoTesting_Fuzz_Message( + textFormatString: textFormat, + options: options, + extensions: SwiftProtoTesting_Fuzz_FuzzTesting_Extensions + ), + file: file, + line: line + ) + } + + func assertTextFormatSucceeds( + _ asBytes: [UInt8], + options: TextFormatDecodingOptions = TextFormatDecodingOptions(), + file: XCTestFileArgType = #file, + line: UInt = #line + ) { + guard let str = String(data: Data(asBytes), encoding: .utf8) else { + print( + """ + Failed to make string (at \(file):\(line)): nothing to try and decode. + The fuzzer does not fail in this case and neither should we, skipping test. + """ + ) + return + } + XCTAssertNoThrow( + try SwiftProtoTesting_Fuzz_Message( + textFormatString: str, + options: options, + extensions: SwiftProtoTesting_Fuzz_FuzzTesting_Extensions + ), + file: file, + line: line + ) + } + + func test_Binary() { + // FailCases/Binary-packed-float-double-growth + assertBinaryFails([ + 0x8a, 0x41, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0x8a, 0x41, 0x8d, + 0x8c, + ]) + } + + func test_JSON() { + // FailCases/JSON-malformed-utf8 + assertJSONFails([ + 0x7b, 0x22, 0xf4, 0x7b, 0x22, 0x3a, 0x5c, 0x00, 0x2e, 0x20, 0x22, 0x3a, + 0x5c, 0x00, 0x2e, 0x20, + ]) + + // FailCases/clusterfuzz-testcase-minimized-FuzzJSON_debug-4506617283477504 + // FailCases/clusterfuzz-testcase-minimized-FuzzJSON_release-5689942715006976 + assertJSONFails("{\"[fuzz.testing.singular_sint32_ext]\":null") + + // FailCases/JSON-Any + assertJSONFails(" {\"wktAny\":{\"ny\":{") + + // FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzJSON_release-4929034878844928 + // This actually fails when the fuzzer was trying to write it back out again. + let msg = try! SwiftProtoTesting_Fuzz_Message(jsonString: " {\"wktAny\": {}} ") + XCTAssertEqual(try! msg.jsonString(), "{\"wktAny\":{}}") + + // FailCases/clusterfuzz-testcase-minimized-FuzzJSON_debug-6286338012282880 + assertJSONFails("{\"wktTimestamp\":\"9999-12-31T23:59:60Z\"}") + } + + func test_TextFormat() { + // FailCases/TextFormat-map-loops-forever + // FailCases/TextFormat-map-loops-forever2 + assertTextFormatFails("104<") + assertTextFormatFails("104{") + + // FailCases/TextFormat-octal-out-of-range + assertTextFormatSucceeds([ + 0x34, 0x34, 0x3a, 0x27, 0x32, 0x5c, 0x35, 0x30, 0x31, 0x39, 0x31, 0x3c, + 0x31, 0x0f, 0x3a, 0x27, + ]) + + // FailCases/TextFormat-ending-zero + assertTextFormatSucceeds(" 1:0 1:0 1:0") + // FailCases/TextFormat-ending-minus + assertTextFormatFails(" 1:0 1:0 5:-") + + // FailCases/clusterfuzz-testcase-minimized-FuzzTextFormat_release-5836572361621504 + assertTextFormatFails([ + 0x31, 0x35, 0x3a, 0x27, 0xa9, 0xa9, 0x5c, 0x75, 0x41, 0x62, + ]) + + assertTextFormatSucceeds( + "500<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<>>>>>>>>>>>>>>>>500<1:''\n2:''>" + ) + + assertTextFormatFails( + "500<[fvwzz_exobuf.Aob/google.protobuf.Any]<[oeFgb/google.protobuf.Any]<[xlob/google.protobuf.Any]<[oeee0FFFFgb/google.protobuf.Any]<[oglob/google.protobuf.Any]<[oogoFFFFFFFFRFfuzz.tebool_extFFFFFFFBFFFFegleeeeeeeeeeeeeeeeeeemeeeeeeeeeeeneeeeeeeekeeeeFFFFFFFFFIFFFFFFFgb/google.protobuf.Any]<[oglob/google.protobuf.Any]<[oogoFFFFFFFFRFfuzz.tebool_extFFFFFFFBFFFFegleeeeeeeeeeeeeeeeeeemeeeeeeeeeeeneeeeeeeekeeeeFFFFFFFFFIFFFFFFFgb/google.protobuf.Any]<[oglob/google.protobuf.Any]<[oogoFFFFFFFFRFfuzz.tebool_extFFFFFFFBFFFFegleeeeeeeeeeeeeeeeeeemeeeeeeeeeeeneeeeeeeekeeeeFFFFFFFFFIFFFFFFFgb/google.protobuf.Any]<[oglob/google.protobuf.Any]<[oogoFFFFFFFFRFfuzz.tebool_extFFFFFFFBFFFFegleeeeeeeeeeeeeeeeeeemeeeeeeeeeeeneeeeeeeekeeeeFFFFFFFFFIFFFFFFFgb/google.protobuf.Any]<[oglob/google.protobuf.Any]<[oogoFFFFFFFFRFfuzz.tebool_extFFFFFFFBFFFFegleeeeeeeeeeeeeeeeeeemeeeeeeeeeeeneeeeeeeekeeeeFFFFFFFFFIFFFFFFFgb/google.protobuf.Any]<[oglob/google.protobuf.Any]<[oogoFFFFFFFFRFfuzz.tebool_extFFFFFFFBFFFFegleeeeeeeeeeeeeeeeeeemeeeeeeeeeeeneeeeeeeekeeeeFFFFFFFFFIFFFFFFFgb/google.protobuf.Any]<>>>>>>>>>>>>>>>>>500<1:''\n1:''\n1:''\n2:''\n1:'roto" + ) + + // FailCases/clusterfuzz-testcase-FuzzTextFormat_release-4619956026146816 + // FailCases/clusterfuzz-testcase-minimized-FuzzTextFormat_release-4619956026146816 + var opts = TextFormatDecodingOptions() + opts.ignoreUnknownFields = true + opts.ignoreUnknownExtensionFields = true + assertTextFormatFails("rsingular_sint:-", options: opts) + assertTextFormatFails(" l :-", options: opts) } - XCTAssertNoThrow( - try Fuzz_Testing_Message(textFormatString: str, extensions: Fuzz_Testing_FuzzTesting_Extensions), - file: file, line: line) - } - - func test_Binary() { - // FailCases/Binary-packed-float-double-growth - assertBinaryFails([ - 0x8a, 0x41, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0x8a, 0x41, 0x8d, - 0x8c, - ]) - } - - func test_JSON() { - // FailCases/JSON-malformed-utf8 - assertJSONFails([ - 0x7b, 0x22, 0xf4, 0x7b, 0x22, 0x3a, 0x5c, 0x00, 0x2e, 0x20, 0x22, 0x3a, - 0x5c, 0x00, 0x2e, 0x20 - ]) - - // FailCases/clusterfuzz-testcase-minimized-FuzzJSON_debug-4506617283477504 - // FailCases/clusterfuzz-testcase-minimized-FuzzJSON_release-5689942715006976 - assertJSONFails("{\"[fuzz.testing.singular_sint32_ext]\":null") - - // FailCases/JSON-Any - assertJSONFails(" {\"wktAny\":{\"ny\":{") - - // FuzzTesting/FailCases/clusterfuzz-testcase-minimized-FuzzJSON_release-4929034878844928 - // This actually fails when the fuzzer was trying to write it back out again. - let msg = try! Fuzz_Testing_Message(jsonString: " {\"wktAny\": {}} ") - XCTAssertEqual(try! msg.jsonString(), "{\"wktAny\":{}}") - } - - func test_TextFormat() { - // FailCases/TextFormat-map-loops-forever - // FailCases/TextFormat-map-loops-forever2 - assertTextFormatFails("104<") - assertTextFormatFails("104{") - - // FailCases/TextFormat-octal-out-of-range - assertTextFormatSucceeds([ - 0x34, 0x34, 0x3a, 0x27, 0x32, 0x5c, 0x35, 0x30, 0x31, 0x39, 0x31, 0x3c, - 0x31, 0x0f, 0x3a, 0x27 - ]) - - // FailCases/TextFormat-ending-zero - assertTextFormatSucceeds(" 1:0 1:0 1:0") - // FailCases/TextFormat-ending-minus - assertTextFormatFails(" 1:0 1:0 5:-") - - // FailCases/clusterfuzz-testcase-minimized-FuzzTextFormat_release-5836572361621504 - assertTextFormatFails([ - 0x31, 0x35, 0x3a, 0x27, 0xa9, 0xa9, 0x5c, 0x75, 0x41, 0x62 - ]) - - assertTextFormatSucceeds("500<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<[google.protobuf.Any]<>>>>>>>>>>>>>>>>500<1:''\n2:''>") - - assertTextFormatFails("500<[fvwzz_exobuf.Aob/google.protobuf.Any]<[oeFgb/google.protobuf.Any]<[xlob/google.protobuf.Any]<[oeee0FFFFgb/google.protobuf.Any]<[oglob/google.protobuf.Any]<[oogoFFFFFFFFRFfuzz.tebool_extFFFFFFFBFFFFegleeeeeeeeeeeeeeeeeeemeeeeeeeeeeeneeeeeeeekeeeeFFFFFFFFFIFFFFFFFgb/google.protobuf.Any]<[oglob/google.protobuf.Any]<[oogoFFFFFFFFRFfuzz.tebool_extFFFFFFFBFFFFegleeeeeeeeeeeeeeeeeeemeeeeeeeeeeeneeeeeeeekeeeeFFFFFFFFFIFFFFFFFgb/google.protobuf.Any]<[oglob/google.protobuf.Any]<[oogoFFFFFFFFRFfuzz.tebool_extFFFFFFFBFFFFegleeeeeeeeeeeeeeeeeeemeeeeeeeeeeeneeeeeeeekeeeeFFFFFFFFFIFFFFFFFgb/google.protobuf.Any]<[oglob/google.protobuf.Any]<[oogoFFFFFFFFRFfuzz.tebool_extFFFFFFFBFFFFegleeeeeeeeeeeeeeeeeeemeeeeeeeeeeeneeeeeeeekeeeeFFFFFFFFFIFFFFFFFgb/google.protobuf.Any]<[oglob/google.protobuf.Any]<[oogoFFFFFFFFRFfuzz.tebool_extFFFFFFFBFFFFegleeeeeeeeeeeeeeeeeeemeeeeeeeeeeeneeeeeeeekeeeeFFFFFFFFFIFFFFFFFgb/google.protobuf.Any]<[oglob/google.protobuf.Any]<[oogoFFFFFFFFRFfuzz.tebool_extFFFFFFFBFFFFegleeeeeeeeeeeeeeeeeeemeeeeeeeeeeeneeeeeeeekeeeeFFFFFFFFFIFFFFFFFgb/google.protobuf.Any]<>>>>>>>>>>>>>>>>>500<1:''\n1:''\n1:''\n2:''\n1:'roto") - - // FailCases/clusterfuzz-testcase-minimized-FuzzTextFormat_release-5109315292233728 - // This decodes but fails when trying to generate the TextFormat again. - let bytes: [UInt8] = [ - 0x35, 0x30, 0x30, 0x3c, 0x31, 0x3a, 0x27, 0x67, 0x6f, 0x6f, 0x67, 0x6c, - 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, - 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x27, 0x32, 0x3a, 0x27, - 0x78, 0x74, 0x32, 0x31, 0x3a, 0x34, 0x37, 0x40, 0x6f, 0x67, 0x6c, 0x65, - 0x2e, 0x6d, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, - 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x6d, 0x61, 0x70, 0x5f, 0x73, - 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, - 0x36, 0x34, 0x3a, 0x15, 0x15, 0x15, 0x15, 0x30, 0x15, 0x15, 0x15, 0x15, - 0x1d, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x58, 0x58, - 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, - 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0xa9, 0xa9, 0xa9, 0xa9, - 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, - 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, - 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, - 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, - 0xa9, 0xa9, 0xa9, 0xa9, 0x31, 0x27, 0x3e, - ] - let str = String(data: Data(bytes), encoding: .utf8)! - let msg = try! Fuzz_Testing_Message(textFormatString: str, extensions: Fuzz_Testing_FuzzTesting_Extensions) - let _ = msg.textFormatString() - } } diff --git a/Tests/SwiftProtobufTests/Test_GroupWithGroups.swift b/Tests/SwiftProtobufTests/Test_GroupWithGroups.swift index a84ff5dc3..6b1ae8a1d 100644 --- a/Tests/SwiftProtobufTests/Test_GroupWithGroups.swift +++ b/Tests/SwiftProtobufTests/Test_GroupWithGroups.swift @@ -11,51 +11,47 @@ import Foundation import XCTest -class Test_GroupWithinGroup: XCTestCase, PBTestHelpers { - typealias MessageTestType = SwiftTestNestingGroupsMessage +final class Test_GroupWithinGroup: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_NestingGroupsMessage - func testGroupWithGroup_Single() { - assertEncode([8, 1, 19, 8, 2, 19, 8, 3, 20, 20]) {(o: inout MessageTestType) in - o.outerA = 1 - o.subGroup1.sub1A = 2 - o.subGroup1.subGroup2.sub2A = 3 + func testGroupWithGroup_Single() { + assertEncode([8, 1, 19, 8, 2, 19, 8, 3, 20, 20]) { (o: inout MessageTestType) in + o.outerA = 1 + o.subGroup1.sub1A = 2 + o.subGroup1.subGroup2.sub2A = 3 + } + assertDecodeSucceeds([19, 19, 8, 1, 20, 20]) { + $0.subGroup1.subGroup2.sub2A == 1 + } + // Empty group + assertDecodeSucceeds([19, 19, 20, 20]) { + $0.subGroup1.hasSubGroup2 && $0.subGroup1.subGroup2 == MessageTestType.SubGroup1.SubGroup2() + } + assertDecodeFails([8, 1, 19, 8, 2, 19, 8, 3, 20]) // End group missing. + assertDecodeFails([8, 1, 19, 8, 2, 19, 8, 3, 20, 28]) // Wrong end group. } - assertDecodeSucceeds([19, 19, 8, 1, 20, 20]) { - $0.subGroup1.subGroup2.sub2A == 1 - } - // Empty group - assertDecodeSucceeds([19, 19, 20, 20]) { - $0.subGroup1.hasSubGroup2 && - $0.subGroup1.subGroup2 == MessageTestType.SubGroup1.SubGroup2() - } - assertDecodeFails([8, 1, 19, 8, 2, 19, 8, 3, 20]) // End group missing. - assertDecodeFails([8, 1, 19, 8, 2, 19, 8, 3, 20, 28]) // Wrong end group. - } - func testGroupWithGroup_Repeated() { - assertEncode([8, 4, 27, 8, 5, 19, 8, 6, 20, 28]) {(o: inout MessageTestType) in - var grp2 = MessageTestType.SubGroup3.SubGroup4() - grp2.sub4A = 6 + func testGroupWithGroup_Repeated() { + assertEncode([8, 4, 27, 8, 5, 19, 8, 6, 20, 28]) { (o: inout MessageTestType) in + var grp2 = MessageTestType.SubGroup3.SubGroup4() + grp2.sub4A = 6 - var grp = MessageTestType.SubGroup3() - grp.sub3A = 5 - grp.subGroup4.append(grp2) + var grp = MessageTestType.SubGroup3() + grp.sub3A = 5 + grp.subGroup4.append(grp2) - o.outerA = 4 - o.subGroup3.append(grp) - } - assertDecodeSucceeds([27, 19, 8, 1, 20, 28]) { - $0.subGroup3.count == 1 && - $0.subGroup3[0].subGroup4.count == 1 && - $0.subGroup3[0].subGroup4[0].sub4A == 1 - } - // Empty group - assertDecodeSucceeds([27, 19, 20, 28]) { (o: MessageTestType) -> Bool in - o.subGroup3.count == 1 && - o.subGroup3[0].subGroup4.count == 1 && - o.subGroup3[0].subGroup4[0] == MessageTestType.SubGroup3.SubGroup4() + o.outerA = 4 + o.subGroup3.append(grp) + } + assertDecodeSucceeds([27, 19, 8, 1, 20, 28]) { + $0.subGroup3.count == 1 && $0.subGroup3[0].subGroup4.count == 1 && $0.subGroup3[0].subGroup4[0].sub4A == 1 + } + // Empty group + assertDecodeSucceeds([27, 19, 20, 28]) { (o: MessageTestType) -> Bool in + o.subGroup3.count == 1 && o.subGroup3[0].subGroup4.count == 1 + && o.subGroup3[0].subGroup4[0] == MessageTestType.SubGroup3.SubGroup4() + } + assertDecodeFails([8, 4, 27, 8, 5, 19, 8, 6, 20]) // End group missing. + assertDecodeFails([8, 4, 27, 8, 5, 19, 8, 6, 28, 20]) // Wrong end groups (reversed). } - assertDecodeFails([8, 4, 27, 8, 5, 19, 8, 6, 20]) // End group missing. - assertDecodeFails([8, 4, 27, 8, 5, 19, 8, 6, 28, 20]) // Wrong end groups (reversed). - } } diff --git a/Tests/SwiftProtobufTests/Test_JSON.swift b/Tests/SwiftProtobufTests/Test_JSON.swift index e0b7c013d..3aeb09750 100644 --- a/Tests/SwiftProtobufTests/Test_JSON.swift +++ b/Tests/SwiftProtobufTests/Test_JSON.swift @@ -15,11 +15,11 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_JSON: XCTestCase, PBTestHelpers { - typealias MessageTestType = Proto3Unittest_TestAllTypes +final class Test_JSON: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_Proto3_TestAllTypes private func configureLargeObject(_ o: inout MessageTestType) { o.optionalInt32 = 1 @@ -40,15 +40,15 @@ class Test_JSON: XCTestCase, PBTestHelpers { var nested = MessageTestType.NestedMessage() nested.bb = 7 o.optionalNestedMessage = nested - var foreign = Proto3Unittest_ForeignMessage() + var foreign = SwiftProtoTesting_Proto3_ForeignMessage() foreign.c = 88 o.optionalForeignMessage = foreign - var importMessage = ProtobufUnittestImport_ImportMessage() + var importMessage = SwiftProtoTesting_Import_ImportMessage() importMessage.d = -9 o.optionalImportMessage = importMessage o.optionalNestedEnum = .baz o.optionalForeignEnum = .foreignBaz - var publicImportMessage = ProtobufUnittestImport_PublicImportMessage() + var publicImportMessage = SwiftProtoTesting_Import_PublicImportMessage() publicImportMessage.e = -999999 o.optionalPublicImportMessage = publicImportMessage o.repeatedInt32 = [1, 2] @@ -83,53 +83,105 @@ class Test_JSON: XCTestCase, PBTestHelpers { } func testMultipleFields() { - let expected: String = ("{" - + "\"optionalInt32\":1," - + "\"optionalInt64\":\"2\"," - + "\"optionalUint32\":3," - + "\"optionalUint64\":\"4\"," - + "\"optionalSint32\":5," - + "\"optionalSint64\":\"6\"," - + "\"optionalFixed32\":7," - + "\"optionalFixed64\":\"8\"," - + "\"optionalSfixed32\":9," - + "\"optionalSfixed64\":\"10\"," - + "\"optionalFloat\":11.0," - + "\"optionalDouble\":12.0," - + "\"optionalBool\":true," - + "\"optionalString\":\"abc\"," - + "\"optionalBytes\":\"QUI=\"," - + "\"optionalNestedMessage\":{\"bb\":7}," - + "\"optionalForeignMessage\":{\"c\":88}," - + "\"optionalImportMessage\":{\"d\":-9}," - + "\"optionalNestedEnum\":\"BAZ\"," - + "\"optionalForeignEnum\":\"FOREIGN_BAZ\"," - + "\"optionalPublicImportMessage\":{\"e\":-999999}," - + "\"repeatedInt32\":[1,2]," - + "\"repeatedInt64\":[\"3\",\"4\"]," - + "\"repeatedUint32\":[5,6]," - + "\"repeatedUint64\":[\"7\",\"8\"]," - + "\"repeatedSint32\":[9,10]," - + "\"repeatedSint64\":[\"11\",\"12\"]," - + "\"repeatedFixed32\":[13,14]," - + "\"repeatedFixed64\":[\"15\",\"16\"]," - + "\"repeatedSfixed32\":[17,18]," - + "\"repeatedSfixed64\":[\"19\",\"20\"]," - + "\"repeatedFloat\":[21.0,22.0]," - + "\"repeatedDouble\":[23.0,24.0]," - + "\"repeatedBool\":[true,false]," - + "\"repeatedString\":[\"abc\",\"def\"]," - + "\"repeatedBytes\":[\"\",\"QUI=\"]," - + "\"repeatedNestedMessage\":[{\"bb\":7},{\"bb\":-7}]," - + "\"repeatedForeignMessage\":[{\"c\":88},{\"c\":-88}]," - + "\"repeatedImportMessage\":[{\"d\":-9},{\"d\":999999}]," - + "\"repeatedNestedEnum\":[\"BAR\",\"BAZ\"]," - + "\"repeatedForeignEnum\":[\"FOREIGN_BAR\",\"FOREIGN_BAZ\"]," - + "\"oneofUint32\":99" - + "}") + let expected: String = + ("{" + + "\"optionalInt32\":1," + + "\"optionalInt64\":\"2\"," + + "\"optionalUint32\":3," + + "\"optionalUint64\":\"4\"," + + "\"optionalSint32\":5," + + "\"optionalSint64\":\"6\"," + + "\"optionalFixed32\":7," + + "\"optionalFixed64\":\"8\"," + + "\"optionalSfixed32\":9," + + "\"optionalSfixed64\":\"10\"," + + "\"optionalFloat\":11.0," + + "\"optionalDouble\":12.0," + + "\"optionalBool\":true," + + "\"optionalString\":\"abc\"," + + "\"optionalBytes\":\"QUI=\"," + + "\"optionalNestedMessage\":{\"bb\":7}," + + "\"optionalForeignMessage\":{\"c\":88}," + + "\"optionalImportMessage\":{\"d\":-9}," + + "\"optionalNestedEnum\":\"BAZ\"," + + "\"optionalForeignEnum\":\"FOREIGN_BAZ\"," + + "\"optionalPublicImportMessage\":{\"e\":-999999}," + + "\"repeatedInt32\":[1,2]," + + "\"repeatedInt64\":[\"3\",\"4\"]," + + "\"repeatedUint32\":[5,6]," + + "\"repeatedUint64\":[\"7\",\"8\"]," + + "\"repeatedSint32\":[9,10]," + + "\"repeatedSint64\":[\"11\",\"12\"]," + + "\"repeatedFixed32\":[13,14]," + + "\"repeatedFixed64\":[\"15\",\"16\"]," + + "\"repeatedSfixed32\":[17,18]," + + "\"repeatedSfixed64\":[\"19\",\"20\"]," + + "\"repeatedFloat\":[21.0,22.0]," + + "\"repeatedDouble\":[23.0,24.0]," + + "\"repeatedBool\":[true,false]," + + "\"repeatedString\":[\"abc\",\"def\"]," + + "\"repeatedBytes\":[\"\",\"QUI=\"]," + + "\"repeatedNestedMessage\":[{\"bb\":7},{\"bb\":-7}]," + + "\"repeatedForeignMessage\":[{\"c\":88},{\"c\":-88}]," + + "\"repeatedImportMessage\":[{\"d\":-9},{\"d\":999999}]," + + "\"repeatedNestedEnum\":[\"BAR\",\"BAZ\"]," + + "\"repeatedForeignEnum\":[\"FOREIGN_BAR\",\"FOREIGN_BAZ\"]," + + "\"oneofUint32\":99" + + "}") assertJSONEncode(expected, configure: configureLargeObject) } + func testMultipleFields_whenJSONEncodingInt64AsNumbers() { + let expected: String = + ("{" + + "\"optionalInt32\":1," + + "\"optionalInt64\":2," + + "\"optionalUint32\":3," + + "\"optionalUint64\":4," + + "\"optionalSint32\":5," + + "\"optionalSint64\":6," + + "\"optionalFixed32\":7," + + "\"optionalFixed64\":8," + + "\"optionalSfixed32\":9," + + "\"optionalSfixed64\":10," + + "\"optionalFloat\":11.0," + + "\"optionalDouble\":12.0," + + "\"optionalBool\":true," + + "\"optionalString\":\"abc\"," + + "\"optionalBytes\":\"QUI=\"," + + "\"optionalNestedMessage\":{\"bb\":7}," + + "\"optionalForeignMessage\":{\"c\":88}," + + "\"optionalImportMessage\":{\"d\":-9}," + + "\"optionalNestedEnum\":\"BAZ\"," + + "\"optionalForeignEnum\":\"FOREIGN_BAZ\"," + + "\"optionalPublicImportMessage\":{\"e\":-999999}," + + "\"repeatedInt32\":[1,2]," + + "\"repeatedInt64\":[3,4]," + + "\"repeatedUint32\":[5,6]," + + "\"repeatedUint64\":[7,8]," + + "\"repeatedSint32\":[9,10]," + + "\"repeatedSint64\":[11,12]," + + "\"repeatedFixed32\":[13,14]," + + "\"repeatedFixed64\":[15,16]," + + "\"repeatedSfixed32\":[17,18]," + + "\"repeatedSfixed64\":[19,20]," + + "\"repeatedFloat\":[21.0,22.0]," + + "\"repeatedDouble\":[23.0,24.0]," + + "\"repeatedBool\":[true,false]," + + "\"repeatedString\":[\"abc\",\"def\"]," + + "\"repeatedBytes\":[\"\",\"QUI=\"]," + + "\"repeatedNestedMessage\":[{\"bb\":7},{\"bb\":-7}]," + + "\"repeatedForeignMessage\":[{\"c\":88},{\"c\":-88}]," + + "\"repeatedImportMessage\":[{\"d\":-9},{\"d\":999999}]," + + "\"repeatedNestedEnum\":[\"BAR\",\"BAZ\"]," + + "\"repeatedForeignEnum\":[\"FOREIGN_BAR\",\"FOREIGN_BAZ\"]," + + "\"oneofUint32\":99" + + "}") + + var encodingOptions = JSONEncodingOptions() + encodingOptions.alwaysPrintInt64sAsNumbers = true + assertJSONEncode(expected, encodingOptions: encodingOptions, configure: configureLargeObject) + } // See if we can crash the JSON parser by trying every possible // truncation of the large message above. @@ -149,57 +201,73 @@ class Test_JSON: XCTestCase, PBTestHelpers { } func testOptionalInt32() { - assertJSONEncode("{\"optionalInt32\":1}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalInt32\":1}") { (o: inout MessageTestType) in o.optionalInt32 = 1 } - assertJSONEncode("{\"optionalInt32\":2147483647}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalInt32\":2147483647}") { (o: inout MessageTestType) in o.optionalInt32 = Int32.max } - assertJSONEncode("{\"optionalInt32\":-2147483648}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalInt32\":-2147483648}") { (o: inout MessageTestType) in o.optionalInt32 = Int32.min } // 32-bit overflow assertJSONDecodeFails("{\"optionalInt32\":2147483648}") // Explicit 'null' is permitted, proto3 decodes it to default value - assertJSONDecodeSucceeds("{\"optionalInt32\":null}") {(o:MessageTestType) in - o.optionalInt32 == 0} + assertJSONDecodeSucceeds("{\"optionalInt32\":null}") { (o: MessageTestType) in + o.optionalInt32 == 0 + } // Quoted or unquoted numbers, positive, negative, or zero - assertJSONDecodeSucceeds("{\"optionalInt32\":1}") {(o:MessageTestType) in - o.optionalInt32 == 1} - assertJSONDecodeSucceeds("{\"optionalInt32\":\"1\"}") {(o:MessageTestType) in - o.optionalInt32 == 1} - assertJSONDecodeSucceeds("{\"optionalInt32\":\"\\u0030\"}") {(o:MessageTestType) in - o.optionalInt32 == 0} - assertJSONDecodeSucceeds("{\"optionalInt32\":\"\\u0031\"}") {(o:MessageTestType) in - o.optionalInt32 == 1} - assertJSONDecodeSucceeds("{\"optionalInt32\":\"\\u00310\"}") {(o:MessageTestType) in - o.optionalInt32 == 10} - assertJSONDecodeSucceeds("{\"optionalInt32\":0}") {(o:MessageTestType) in - o.optionalInt32 == 0} - assertJSONDecodeSucceeds("{\"optionalInt32\":\"0\"}") {(o:MessageTestType) in - o.optionalInt32 == 0} - assertJSONDecodeSucceeds("{\"optionalInt32\":-0}") {(o:MessageTestType) in - o.optionalInt32 == 0} - assertJSONDecodeSucceeds("{\"optionalInt32\":\"-0\"}") {(o:MessageTestType) in - o.optionalInt32 == 0} - assertJSONDecodeSucceeds("{\"optionalInt32\":-1}") {(o:MessageTestType) in - o.optionalInt32 == -1} - assertJSONDecodeSucceeds("{\"optionalInt32\":\"-1\"}") {(o:MessageTestType) in - o.optionalInt32 == -1} + assertJSONDecodeSucceeds("{\"optionalInt32\":1}") { (o: MessageTestType) in + o.optionalInt32 == 1 + } + assertJSONDecodeSucceeds("{\"optionalInt32\":\"1\"}") { (o: MessageTestType) in + o.optionalInt32 == 1 + } + assertJSONDecodeSucceeds("{\"optionalInt32\":\"\\u0030\"}") { (o: MessageTestType) in + o.optionalInt32 == 0 + } + assertJSONDecodeSucceeds("{\"optionalInt32\":\"\\u0031\"}") { (o: MessageTestType) in + o.optionalInt32 == 1 + } + assertJSONDecodeSucceeds("{\"optionalInt32\":\"\\u00310\"}") { (o: MessageTestType) in + o.optionalInt32 == 10 + } + assertJSONDecodeSucceeds("{\"optionalInt32\":0}") { (o: MessageTestType) in + o.optionalInt32 == 0 + } + assertJSONDecodeSucceeds("{\"optionalInt32\":\"0\"}") { (o: MessageTestType) in + o.optionalInt32 == 0 + } + assertJSONDecodeSucceeds("{\"optionalInt32\":-0}") { (o: MessageTestType) in + o.optionalInt32 == 0 + } + assertJSONDecodeSucceeds("{\"optionalInt32\":\"-0\"}") { (o: MessageTestType) in + o.optionalInt32 == 0 + } + assertJSONDecodeSucceeds("{\"optionalInt32\":-1}") { (o: MessageTestType) in + o.optionalInt32 == -1 + } + assertJSONDecodeSucceeds("{\"optionalInt32\":\"-1\"}") { (o: MessageTestType) in + o.optionalInt32 == -1 + } // JSON RFC does not accept leading zeros assertJSONDecodeFails("{\"optionalInt32\":00000000000000000000001}") assertJSONDecodeFails("{\"optionalInt32\":\"01\"}") assertJSONDecodeFails("{\"optionalInt32\":-01}") assertJSONDecodeFails("{\"optionalInt32\":\"-00000000000000000000001\"}") // Exponents are okay, as long as result is integer - assertJSONDecodeSucceeds("{\"optionalInt32\":2.147483647e9}") {(o:MessageTestType) in - o.optionalInt32 == Int32.max} - assertJSONDecodeSucceeds("{\"optionalInt32\":-2.147483648e9}") {(o:MessageTestType) in - o.optionalInt32 == Int32.min} - assertJSONDecodeSucceeds("{\"optionalInt32\":1e3}") {(o:MessageTestType) in - o.optionalInt32 == 1000} - assertJSONDecodeSucceeds("{\"optionalInt32\":100e-2}") {(o:MessageTestType) in - o.optionalInt32 == 1} + assertJSONDecodeSucceeds("{\"optionalInt32\":2.147483647e9}") { (o: MessageTestType) in + o.optionalInt32 == Int32.max + } + assertJSONDecodeSucceeds("{\"optionalInt32\":-2.147483648e9}") { (o: MessageTestType) in + o.optionalInt32 == Int32.min + } + assertJSONDecodeSucceeds("{\"optionalInt32\":1e3}") { (o: MessageTestType) in + o.optionalInt32 == 1000 + } + assertJSONDecodeSucceeds("{\"optionalInt32\":100e-2}") { (o: MessageTestType) in + o.optionalInt32 == 1 + } assertJSONDecodeFails("{\"optionalInt32\":1e-1}") // Reject malformed input assertJSONDecodeFails("{\"optionalInt32\":\\u0031}") @@ -230,30 +298,30 @@ class Test_JSON: XCTestCase, PBTestHelpers { } func testOptionalUInt32() { - assertJSONEncode("{\"optionalUint32\":1}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalUint32\":1}") { (o: inout MessageTestType) in o.optionalUint32 = 1 } - assertJSONEncode("{\"optionalUint32\":4294967295}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalUint32\":4294967295}") { (o: inout MessageTestType) in o.optionalUint32 = UInt32.max } assertJSONDecodeFails("{\"optionalUint32\":4294967296}") // Explicit 'null' is permitted, decodes to default - assertJSONDecodeSucceeds("{\"optionalUint32\":null}") {$0.optionalUint32 == 0} + assertJSONDecodeSucceeds("{\"optionalUint32\":null}") { $0.optionalUint32 == 0 } // Quoted or unquoted numbers, positive, negative, or zero - assertJSONDecodeSucceeds("{\"optionalUint32\":1}") {$0.optionalUint32 == 1} - assertJSONDecodeSucceeds("{\"optionalUint32\":\"1\"}") {$0.optionalUint32 == 1} - assertJSONDecodeSucceeds("{\"optionalUint32\":0}") {$0.optionalUint32 == 0} - assertJSONDecodeSucceeds("{\"optionalUint32\":\"0\"}") {$0.optionalUint32 == 0} + assertJSONDecodeSucceeds("{\"optionalUint32\":1}") { $0.optionalUint32 == 1 } + assertJSONDecodeSucceeds("{\"optionalUint32\":\"1\"}") { $0.optionalUint32 == 1 } + assertJSONDecodeSucceeds("{\"optionalUint32\":0}") { $0.optionalUint32 == 0 } + assertJSONDecodeSucceeds("{\"optionalUint32\":\"0\"}") { $0.optionalUint32 == 0 } // Protobuf JSON does not accept leading zeros assertJSONDecodeFails("{\"optionalUint32\":01}") assertJSONDecodeFails("{\"optionalUint32\":\"01\"}") // But it does accept exponential (as long as result is integral) - assertJSONDecodeSucceeds("{\"optionalUint32\":4.294967295e9}") {$0.optionalUint32 == UInt32.max} - assertJSONDecodeSucceeds("{\"optionalUint32\":1e3}") {$0.optionalUint32 == 1000} - assertJSONDecodeSucceeds("{\"optionalUint32\":1.2e3}") {$0.optionalUint32 == 1200} - assertJSONDecodeSucceeds("{\"optionalUint32\":1000e-2}") {$0.optionalUint32 == 10} - assertJSONDecodeSucceeds("{\"optionalUint32\":1.0}") {$0.optionalUint32 == 1} - assertJSONDecodeSucceeds("{\"optionalUint32\":1.000000e2}") {$0.optionalUint32 == 100} + assertJSONDecodeSucceeds("{\"optionalUint32\":4.294967295e9}") { $0.optionalUint32 == UInt32.max } + assertJSONDecodeSucceeds("{\"optionalUint32\":1e3}") { $0.optionalUint32 == 1000 } + assertJSONDecodeSucceeds("{\"optionalUint32\":1.2e3}") { $0.optionalUint32 == 1200 } + assertJSONDecodeSucceeds("{\"optionalUint32\":1000e-2}") { $0.optionalUint32 == 10 } + assertJSONDecodeSucceeds("{\"optionalUint32\":1.0}") { $0.optionalUint32 == 1 } + assertJSONDecodeSucceeds("{\"optionalUint32\":1.000000e2}") { $0.optionalUint32 == 100 } assertJSONDecodeFails("{\"optionalUint32\":1e-3}") assertJSONDecodeFails("{\"optionalUint32\":1") assertJSONDecodeFails("{\"optionalUint32\":\"") @@ -271,28 +339,28 @@ class Test_JSON: XCTestCase, PBTestHelpers { func testOptionalInt64() throws { // Protoc JSON always quotes Int64 values - assertJSONEncode("{\"optionalInt64\":\"9007199254740992\"}") {(o: inout MessageTestType) in - o.optionalInt64 = 0x20000000000000 + assertJSONEncode("{\"optionalInt64\":\"9007199254740992\"}") { (o: inout MessageTestType) in + o.optionalInt64 = 0x20_0000_0000_0000 } - assertJSONEncode("{\"optionalInt64\":\"9007199254740991\"}") {(o: inout MessageTestType) in - o.optionalInt64 = 0x1fffffffffffff + assertJSONEncode("{\"optionalInt64\":\"9007199254740991\"}") { (o: inout MessageTestType) in + o.optionalInt64 = 0x1f_ffff_ffff_ffff } - assertJSONEncode("{\"optionalInt64\":\"-9007199254740992\"}") {(o: inout MessageTestType) in - o.optionalInt64 = -0x20000000000000 + assertJSONEncode("{\"optionalInt64\":\"-9007199254740992\"}") { (o: inout MessageTestType) in + o.optionalInt64 = -0x20_0000_0000_0000 } - assertJSONEncode("{\"optionalInt64\":\"-9007199254740991\"}") {(o: inout MessageTestType) in - o.optionalInt64 = -0x1fffffffffffff + assertJSONEncode("{\"optionalInt64\":\"-9007199254740991\"}") { (o: inout MessageTestType) in + o.optionalInt64 = -0x1f_ffff_ffff_ffff } - assertJSONEncode("{\"optionalInt64\":\"9223372036854775807\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalInt64\":\"9223372036854775807\"}") { (o: inout MessageTestType) in o.optionalInt64 = Int64.max } - assertJSONEncode("{\"optionalInt64\":\"-9223372036854775808\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalInt64\":\"-9223372036854775808\"}") { (o: inout MessageTestType) in o.optionalInt64 = Int64.min } - assertJSONEncode("{\"optionalInt64\":\"1\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalInt64\":\"1\"}") { (o: inout MessageTestType) in o.optionalInt64 = 1 } - assertJSONEncode("{\"optionalInt64\":\"-1\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalInt64\":\"-1\"}") { (o: inout MessageTestType) in o.optionalInt64 = -1 } @@ -302,25 +370,25 @@ class Test_JSON: XCTestCase, PBTestHelpers { XCTAssertEqual(try a.jsonString(), "{}") // Decode should work even with unquoted large numbers - assertJSONDecodeSucceeds("{\"optionalInt64\":9223372036854775807}") {$0.optionalInt64 == Int64.max} + assertJSONDecodeSucceeds("{\"optionalInt64\":9223372036854775807}") { $0.optionalInt64 == Int64.max } assertJSONDecodeFails("{\"optionalInt64\":9223372036854775808}") - assertJSONDecodeSucceeds("{\"optionalInt64\":-9223372036854775808}") {$0.optionalInt64 == Int64.min} + assertJSONDecodeSucceeds("{\"optionalInt64\":-9223372036854775808}") { $0.optionalInt64 == Int64.min } assertJSONDecodeFails("{\"optionalInt64\":-9223372036854775809}") // Protobuf JSON does not accept leading zeros assertJSONDecodeFails("{\"optionalInt64\": \"01\" }") - assertJSONDecodeSucceeds("{\"optionalInt64\": \"1\" }") {$0.optionalInt64 == 1} + assertJSONDecodeSucceeds("{\"optionalInt64\": \"1\" }") { $0.optionalInt64 == 1 } assertJSONDecodeFails("{\"optionalInt64\": \"-01\" }") - assertJSONDecodeSucceeds("{\"optionalInt64\": \"-1\" }") {$0.optionalInt64 == -1} - assertJSONDecodeSucceeds("{\"optionalInt64\": \"0\" }") {$0.optionalInt64 == 0} + assertJSONDecodeSucceeds("{\"optionalInt64\": \"-1\" }") { $0.optionalInt64 == -1 } + assertJSONDecodeSucceeds("{\"optionalInt64\": \"0\" }") { $0.optionalInt64 == 0 } // Protobuf JSON does accept exponential format for integer fields - assertJSONDecodeSucceeds("{\"optionalInt64\":1e3}") {$0.optionalInt64 == 1000} - assertJSONDecodeSucceeds("{\"optionalInt64\":\"9223372036854775807\"}") {$0.optionalInt64 == Int64.max} - assertJSONDecodeSucceeds("{\"optionalInt64\":-9.223372036854775808e18}") {$0.optionalInt64 == Int64.min} - assertJSONDecodeFails("{\"optionalInt64\":9.223372036854775808e18}") // Out of range + assertJSONDecodeSucceeds("{\"optionalInt64\":1e3}") { $0.optionalInt64 == 1000 } + assertJSONDecodeSucceeds("{\"optionalInt64\":\"9223372036854775807\"}") { $0.optionalInt64 == Int64.max } + assertJSONDecodeSucceeds("{\"optionalInt64\":-9.223372036854775808e18}") { $0.optionalInt64 == Int64.min } + assertJSONDecodeFails("{\"optionalInt64\":9.223372036854775808e18}") // Out of range // Explicit 'null' is permitted, decodes to default (in proto3) - assertJSONDecodeSucceeds("{\"optionalInt64\":null}") {$0.optionalInt64 == 0} - assertJSONDecodeSucceeds("{\"optionalInt64\":2147483648}") {$0.optionalInt64 == 2147483648} - assertJSONDecodeSucceeds("{\"optionalInt64\":2147483648}") {$0.optionalInt64 == 2147483648} + assertJSONDecodeSucceeds("{\"optionalInt64\":null}") { $0.optionalInt64 == 0 } + assertJSONDecodeSucceeds("{\"optionalInt64\":2147483648}") { $0.optionalInt64 == 2_147_483_648 } + assertJSONDecodeSucceeds("{\"optionalInt64\":2147483648}") { $0.optionalInt64 == 2_147_483_648 } assertJSONDecodeFails("{\"optionalInt64\":1") assertJSONDecodeFails("{\"optionalInt64\":\"") @@ -329,19 +397,21 @@ class Test_JSON: XCTestCase, PBTestHelpers { } func testOptionalUInt64() { - assertJSONEncode("{\"optionalUint64\":\"1\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalUint64\":\"1\"}") { (o: inout MessageTestType) in o.optionalUint64 = 1 } - assertJSONEncode("{\"optionalUint64\":\"4294967295\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalUint64\":\"4294967295\"}") { (o: inout MessageTestType) in o.optionalUint64 = UInt64(UInt32.max) } - assertJSONEncode("{\"optionalUint64\":\"18446744073709551615\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalUint64\":\"18446744073709551615\"}") { (o: inout MessageTestType) in o.optionalUint64 = UInt64.max } // Parse unquoted 64-bit integers - assertJSONDecodeSucceeds("{\"optionalUint64\":18446744073709551615}") {$0.optionalUint64 == UInt64.max} + assertJSONDecodeSucceeds("{\"optionalUint64\":18446744073709551615}") { $0.optionalUint64 == UInt64.max } // Accept quoted 64-bit integers with backslash escapes in them - assertJSONDecodeSucceeds("{\"optionalUint64\":\"184467\\u00344073709551615\"}") {$0.optionalUint64 == UInt64.max} + assertJSONDecodeSucceeds("{\"optionalUint64\":\"184467\\u00344073709551615\"}") { + $0.optionalUint64 == UInt64.max + } // Reject unquoted 64-bit integers with backslash escapes assertJSONDecodeFails("{\"optionalUint64\":184467\\u00344073709551615}") // Reject out-of-range integers, whether or not quoted @@ -351,22 +421,22 @@ class Test_JSON: XCTestCase, PBTestHelpers { assertJSONDecodeFails("{\"optionalUint64\":184467440737095516109}") // Explicit 'null' is permitted, decodes to default - assertJSONDecodeSucceeds("{\"optionalUint64\":null}") {$0.optionalUint64 == 0} + assertJSONDecodeSucceeds("{\"optionalUint64\":null}") { $0.optionalUint64 == 0 } // Quoted or unquoted numbers, positive or zero - assertJSONDecodeSucceeds("{\"optionalUint64\":1}") {$0.optionalUint64 == 1} - assertJSONDecodeSucceeds("{\"optionalUint64\":\"1\"}") {$0.optionalUint64 == 1} - assertJSONDecodeSucceeds("{\"optionalUint64\":0}") {$0.optionalUint64 == 0} - assertJSONDecodeSucceeds("{\"optionalUint64\":\"0\"}") {$0.optionalUint64 == 0} + assertJSONDecodeSucceeds("{\"optionalUint64\":1}") { $0.optionalUint64 == 1 } + assertJSONDecodeSucceeds("{\"optionalUint64\":\"1\"}") { $0.optionalUint64 == 1 } + assertJSONDecodeSucceeds("{\"optionalUint64\":0}") { $0.optionalUint64 == 0 } + assertJSONDecodeSucceeds("{\"optionalUint64\":\"0\"}") { $0.optionalUint64 == 0 } // Protobuf JSON does not accept leading zeros assertJSONDecodeFails("{\"optionalUint64\":01}") assertJSONDecodeFails("{\"optionalUint64\":\"01\"}") // But it does accept exponential (as long as result is integral) - assertJSONDecodeSucceeds("{\"optionalUint64\":4.294967295e9}") {$0.optionalUint64 == UInt64(UInt32.max)} - assertJSONDecodeSucceeds("{\"optionalUint64\":1e3}") {$0.optionalUint64 == 1000} - assertJSONDecodeSucceeds("{\"optionalUint64\":1.2e3}") {$0.optionalUint64 == 1200} - assertJSONDecodeSucceeds("{\"optionalUint64\":1000e-2}") {$0.optionalUint64 == 10} - assertJSONDecodeSucceeds("{\"optionalUint64\":1.0}") {$0.optionalUint64 == 1} - assertJSONDecodeSucceeds("{\"optionalUint64\":1.000000e2}") {$0.optionalUint64 == 100} + assertJSONDecodeSucceeds("{\"optionalUint64\":4.294967295e9}") { $0.optionalUint64 == UInt64(UInt32.max) } + assertJSONDecodeSucceeds("{\"optionalUint64\":1e3}") { $0.optionalUint64 == 1000 } + assertJSONDecodeSucceeds("{\"optionalUint64\":1.2e3}") { $0.optionalUint64 == 1200 } + assertJSONDecodeSucceeds("{\"optionalUint64\":1000e-2}") { $0.optionalUint64 == 10 } + assertJSONDecodeSucceeds("{\"optionalUint64\":1.0}") { $0.optionalUint64 == 1 } + assertJSONDecodeSucceeds("{\"optionalUint64\":1.000000e2}") { $0.optionalUint64 == 100 } assertJSONDecodeFails("{\"optionalUint64\":1e-3}") assertJSONDecodeFails("{\"optionalUint64\":1.11e1}") // Reject truncated JSON (ending at the beginning, end, or middle of the number @@ -384,7 +454,11 @@ class Test_JSON: XCTestCase, PBTestHelpers { assertJSONDecodeFails("{\"optionalUint64\":[]}") } - private func assertRoundTripJSON(file: XCTestFileArgType = #file, line: UInt = #line, configure: (inout MessageTestType) -> Void) { + private func assertRoundTripJSON( + file: XCTestFileArgType = #file, + line: UInt = #line, + configure: (inout MessageTestType) -> Void + ) { var original = MessageTestType() configure(&original) do { @@ -401,32 +475,32 @@ class Test_JSON: XCTestCase, PBTestHelpers { } func testOptionalDouble() throws { - assertJSONEncode("{\"optionalDouble\":1.0}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalDouble\":1.0}") { (o: inout MessageTestType) in o.optionalDouble = 1.0 } - assertJSONEncode("{\"optionalDouble\":\"Infinity\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalDouble\":\"Infinity\"}") { (o: inout MessageTestType) in o.optionalDouble = Double.infinity } - assertJSONEncode("{\"optionalDouble\":\"-Infinity\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalDouble\":\"-Infinity\"}") { (o: inout MessageTestType) in o.optionalDouble = -Double.infinity } - assertJSONDecodeSucceeds("{\"optionalDouble\":\"Inf\"}") {$0.optionalDouble == Double.infinity} - assertJSONDecodeSucceeds("{\"optionalDouble\":\"-Inf\"}") {$0.optionalDouble == -Double.infinity} - assertJSONDecodeSucceeds("{\"optionalDouble\":\"1\"}") {$0.optionalDouble == 1} - assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.0\"}") {$0.optionalDouble == 1.0} - assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.5\"}") {$0.optionalDouble == 1.5} - assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.5e1\"}") {$0.optionalDouble == 15} - assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.5E1\"}") {$0.optionalDouble == 15} - assertJSONDecodeSucceeds("{\"optionalDouble\":\"1\\u002e5e1\"}") {$0.optionalDouble == 15} - assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.\\u0035e1\"}") {$0.optionalDouble == 15} - assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.5\\u00651\"}") {$0.optionalDouble == 15} - assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.5e\\u002b1\"}") {$0.optionalDouble == 15} - assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.5e+\\u0031\"}") {$0.optionalDouble == 15} - assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.5e+1\"}") {$0.optionalDouble == 15} - assertJSONDecodeSucceeds("{\"optionalDouble\":\"15e-1\"}") {$0.optionalDouble == 1.5} - assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.0e0\"}") {$0.optionalDouble == 1.0} - assertJSONDecodeSucceeds("{\"optionalDouble\":\"0\"}") {$0.optionalDouble == 0.0} - assertJSONDecodeSucceeds("{\"optionalDouble\":0}") {$0.optionalDouble == 0.0} + assertJSONDecodeSucceeds("{\"optionalDouble\":\"Inf\"}") { $0.optionalDouble == Double.infinity } + assertJSONDecodeSucceeds("{\"optionalDouble\":\"-Inf\"}") { $0.optionalDouble == -Double.infinity } + assertJSONDecodeSucceeds("{\"optionalDouble\":\"1\"}") { $0.optionalDouble == 1 } + assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.0\"}") { $0.optionalDouble == 1.0 } + assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.5\"}") { $0.optionalDouble == 1.5 } + assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.5e1\"}") { $0.optionalDouble == 15 } + assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.5E1\"}") { $0.optionalDouble == 15 } + assertJSONDecodeSucceeds("{\"optionalDouble\":\"1\\u002e5e1\"}") { $0.optionalDouble == 15 } + assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.\\u0035e1\"}") { $0.optionalDouble == 15 } + assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.5\\u00651\"}") { $0.optionalDouble == 15 } + assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.5e\\u002b1\"}") { $0.optionalDouble == 15 } + assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.5e+\\u0031\"}") { $0.optionalDouble == 15 } + assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.5e+1\"}") { $0.optionalDouble == 15 } + assertJSONDecodeSucceeds("{\"optionalDouble\":\"15e-1\"}") { $0.optionalDouble == 1.5 } + assertJSONDecodeSucceeds("{\"optionalDouble\":\"1.0e0\"}") { $0.optionalDouble == 1.0 } + assertJSONDecodeSucceeds("{\"optionalDouble\":\"0\"}") { $0.optionalDouble == 0.0 } + assertJSONDecodeSucceeds("{\"optionalDouble\":0}") { $0.optionalDouble == 0.0 } // We preserve signed zero when decoding let d1 = try MessageTestType(jsonString: "{\"optionalDouble\":\"-0\"}") XCTAssertEqual(d1.optionalDouble, 0.0) @@ -435,12 +509,12 @@ class Test_JSON: XCTestCase, PBTestHelpers { XCTAssertEqual(d2.optionalDouble, 0.0) XCTAssertEqual(d2.optionalDouble.sign, .minus) // But re-encoding treats the field as defaulted, so the sign gets lost - assertJSONDecodeSucceeds("{\"optionalDouble\":\"-0\"}") {$0.optionalDouble == 0.0} - assertJSONDecodeSucceeds("{\"optionalDouble\":-0}") {$0.optionalDouble == 0.0} + assertJSONDecodeSucceeds("{\"optionalDouble\":\"-0\"}") { $0.optionalDouble == 0.0 } + assertJSONDecodeSucceeds("{\"optionalDouble\":-0}") { $0.optionalDouble == 0.0 } // Malformed numbers should fail assertJSONDecodeFails("{\"optionalDouble\":Infinity}") - assertJSONDecodeFails("{\"optionalDouble\":-Infinity}") // Must be quoted + assertJSONDecodeFails("{\"optionalDouble\":-Infinity}") // Must be quoted assertJSONDecodeFails("{\"optionalDouble\":\"inf\"}") assertJSONDecodeFails("{\"optionalDouble\":\"-inf\"}") assertJSONDecodeFails("{\"optionalDouble\":NaN}") @@ -461,57 +535,57 @@ class Test_JSON: XCTestCase, PBTestHelpers { assertJSONDecodeFails("{\"optionalDouble\":1.0.0}") // A wide range of numbers should exactly round-trip - assertRoundTripJSON {$0.optionalDouble = 0.1} - assertRoundTripJSON {$0.optionalDouble = 0.01} - assertRoundTripJSON {$0.optionalDouble = 0.001} - assertRoundTripJSON {$0.optionalDouble = 0.0001} - assertRoundTripJSON {$0.optionalDouble = 0.00001} - assertRoundTripJSON {$0.optionalDouble = 0.000001} - assertRoundTripJSON {$0.optionalDouble = 1e-10} - assertRoundTripJSON {$0.optionalDouble = 1e-20} - assertRoundTripJSON {$0.optionalDouble = 1e-30} - assertRoundTripJSON {$0.optionalDouble = 1e-40} - assertRoundTripJSON {$0.optionalDouble = 1e-50} - assertRoundTripJSON {$0.optionalDouble = 1e-60} - assertRoundTripJSON {$0.optionalDouble = 1e-100} - assertRoundTripJSON {$0.optionalDouble = 1e-200} - assertRoundTripJSON {$0.optionalDouble = Double.pi} - assertRoundTripJSON {$0.optionalDouble = 123456.789123456789123} - assertRoundTripJSON {$0.optionalDouble = 1.7976931348623157e+308} - assertRoundTripJSON {$0.optionalDouble = 2.22507385850720138309e-308} + assertRoundTripJSON { $0.optionalDouble = 0.1 } + assertRoundTripJSON { $0.optionalDouble = 0.01 } + assertRoundTripJSON { $0.optionalDouble = 0.001 } + assertRoundTripJSON { $0.optionalDouble = 0.0001 } + assertRoundTripJSON { $0.optionalDouble = 0.00001 } + assertRoundTripJSON { $0.optionalDouble = 0.000001 } + assertRoundTripJSON { $0.optionalDouble = 1e-10 } + assertRoundTripJSON { $0.optionalDouble = 1e-20 } + assertRoundTripJSON { $0.optionalDouble = 1e-30 } + assertRoundTripJSON { $0.optionalDouble = 1e-40 } + assertRoundTripJSON { $0.optionalDouble = 1e-50 } + assertRoundTripJSON { $0.optionalDouble = 1e-60 } + assertRoundTripJSON { $0.optionalDouble = 1e-100 } + assertRoundTripJSON { $0.optionalDouble = 1e-200 } + assertRoundTripJSON { $0.optionalDouble = Double.pi } + assertRoundTripJSON { $0.optionalDouble = 123456.789123456789123 } + assertRoundTripJSON { $0.optionalDouble = 1.7976931348623157e+308 } + assertRoundTripJSON { $0.optionalDouble = 2.22507385850720138309e-308 } } func testOptionalFloat() throws { - assertJSONEncode("{\"optionalFloat\":1.0}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalFloat\":1.0}") { (o: inout MessageTestType) in o.optionalFloat = 1.0 } - assertJSONEncode("{\"optionalFloat\":-1.0}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalFloat\":-1.0}") { (o: inout MessageTestType) in o.optionalFloat = -1.0 } - assertJSONEncode("{\"optionalFloat\":\"Infinity\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalFloat\":\"Infinity\"}") { (o: inout MessageTestType) in o.optionalFloat = Float.infinity } - assertJSONEncode("{\"optionalFloat\":\"-Infinity\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalFloat\":\"-Infinity\"}") { (o: inout MessageTestType) in o.optionalFloat = -Float.infinity } - assertJSONDecodeSucceeds("{\"optionalFloat\":\"Inf\"}") {$0.optionalFloat == Float.infinity} - assertJSONDecodeSucceeds("{\"optionalFloat\":\"-Inf\"}") {$0.optionalFloat == -Float.infinity} - assertJSONDecodeSucceeds("{\"optionalFloat\":\"1\"}") {$0.optionalFloat == 1} - assertJSONDecodeSucceeds("{\"optionalFloat\":\"-1\"}") {$0.optionalFloat == -1} - assertJSONDecodeSucceeds("{\"optionalFloat\":\"1.0\"}") {$0.optionalFloat == 1.0} - assertJSONDecodeSucceeds("{\"optionalFloat\":\"1.5\"}") {$0.optionalFloat == 1.5} - assertJSONDecodeSucceeds("{\"optionalFloat\":\"1.5e1\"}") {$0.optionalFloat == 15} - assertJSONDecodeSucceeds("{\"optionalFloat\":\"1\\u002e5e1\"}") {$0.optionalFloat == 15} - assertJSONDecodeSucceeds("{\"optionalFloat\":\"1.\\u0035e1\"}") {$0.optionalFloat == 15} - assertJSONDecodeSucceeds("{\"optionalFloat\":\"1.5\\u00651\"}") {$0.optionalFloat == 15} - assertJSONDecodeSucceeds("{\"optionalFloat\":\"1.5e\\u002b1\"}") {$0.optionalFloat == 15} - assertJSONDecodeSucceeds("{\"optionalFloat\":\"1.5e+\\u0031\"}") {$0.optionalFloat == 15} - assertJSONDecodeSucceeds("{\"optionalFloat\":\"1.5e+1\"}") {$0.optionalFloat == 15} - assertJSONDecodeSucceeds("{\"optionalFloat\":\"15e-1\"}") {$0.optionalFloat == 1.5} - assertJSONDecodeSucceeds("{\"optionalFloat\":\"1.0e0\"}") {$0.optionalFloat == 1.0} - assertJSONDecodeSucceeds("{\"optionalFloat\":1.0e0}") {$0.optionalFloat == 1.0} - assertJSONDecodeSucceeds("{\"optionalFloat\":\"0\"}") {$0.optionalFloat == 0.0} - assertJSONDecodeSucceeds("{\"optionalFloat\":0}") {$0.optionalFloat == 0.0} + assertJSONDecodeSucceeds("{\"optionalFloat\":\"Inf\"}") { $0.optionalFloat == Float.infinity } + assertJSONDecodeSucceeds("{\"optionalFloat\":\"-Inf\"}") { $0.optionalFloat == -Float.infinity } + assertJSONDecodeSucceeds("{\"optionalFloat\":\"1\"}") { $0.optionalFloat == 1 } + assertJSONDecodeSucceeds("{\"optionalFloat\":\"-1\"}") { $0.optionalFloat == -1 } + assertJSONDecodeSucceeds("{\"optionalFloat\":\"1.0\"}") { $0.optionalFloat == 1.0 } + assertJSONDecodeSucceeds("{\"optionalFloat\":\"1.5\"}") { $0.optionalFloat == 1.5 } + assertJSONDecodeSucceeds("{\"optionalFloat\":\"1.5e1\"}") { $0.optionalFloat == 15 } + assertJSONDecodeSucceeds("{\"optionalFloat\":\"1\\u002e5e1\"}") { $0.optionalFloat == 15 } + assertJSONDecodeSucceeds("{\"optionalFloat\":\"1.\\u0035e1\"}") { $0.optionalFloat == 15 } + assertJSONDecodeSucceeds("{\"optionalFloat\":\"1.5\\u00651\"}") { $0.optionalFloat == 15 } + assertJSONDecodeSucceeds("{\"optionalFloat\":\"1.5e\\u002b1\"}") { $0.optionalFloat == 15 } + assertJSONDecodeSucceeds("{\"optionalFloat\":\"1.5e+\\u0031\"}") { $0.optionalFloat == 15 } + assertJSONDecodeSucceeds("{\"optionalFloat\":\"1.5e+1\"}") { $0.optionalFloat == 15 } + assertJSONDecodeSucceeds("{\"optionalFloat\":\"15e-1\"}") { $0.optionalFloat == 1.5 } + assertJSONDecodeSucceeds("{\"optionalFloat\":\"1.0e0\"}") { $0.optionalFloat == 1.0 } + assertJSONDecodeSucceeds("{\"optionalFloat\":1.0e0}") { $0.optionalFloat == 1.0 } + assertJSONDecodeSucceeds("{\"optionalFloat\":\"0\"}") { $0.optionalFloat == 0.0 } + assertJSONDecodeSucceeds("{\"optionalFloat\":0}") { $0.optionalFloat == 0.0 } // We preserve signed zero when decoding let d1 = try MessageTestType(jsonString: "{\"optionalFloat\":\"-0\"}") XCTAssertEqual(d1.optionalFloat, 0.0) @@ -520,11 +594,11 @@ class Test_JSON: XCTestCase, PBTestHelpers { XCTAssertEqual(d2.optionalFloat, 0.0) XCTAssertEqual(d2.optionalFloat.sign, .minus) // But re-encoding treats the field as defaulted, so the sign gets lost - assertJSONDecodeSucceeds("{\"optionalFloat\":\"-0\"}") {$0.optionalFloat == 0.0} - assertJSONDecodeSucceeds("{\"optionalFloat\":-0}") {$0.optionalFloat == 0.0} + assertJSONDecodeSucceeds("{\"optionalFloat\":\"-0\"}") { $0.optionalFloat == 0.0 } + assertJSONDecodeSucceeds("{\"optionalFloat\":-0}") { $0.optionalFloat == 0.0 } // Malformed numbers should fail assertJSONDecodeFails("{\"optionalFloat\":Infinity}") - assertJSONDecodeFails("{\"optionalFloat\":-Infinity}") // Must be quoted + assertJSONDecodeFails("{\"optionalFloat\":-Infinity}") // Must be quoted assertJSONDecodeFails("{\"optionalFloat\":NaN}") assertJSONDecodeFails("{\"optionalFloat\":\"nan\"}") assertJSONDecodeFails("{\"optionalFloat\":\"1.0.0\"}") @@ -549,49 +623,49 @@ class Test_JSON: XCTestCase, PBTestHelpers { assertJSONDecodeFails("{\"optionalFloat\":1e39}") // A wide range of numbers should exactly round-trip - assertRoundTripJSON {$0.optionalFloat = 0.1} - assertRoundTripJSON {$0.optionalFloat = 0.01} - assertRoundTripJSON {$0.optionalFloat = 0.001} - assertRoundTripJSON {$0.optionalFloat = 0.0001} - assertRoundTripJSON {$0.optionalFloat = 0.00001} - assertRoundTripJSON {$0.optionalFloat = 0.000001} - assertRoundTripJSON {$0.optionalFloat = 1.00000075e-36} - assertRoundTripJSON {$0.optionalFloat = 1e-10} - assertRoundTripJSON {$0.optionalFloat = 1e-20} - assertRoundTripJSON {$0.optionalFloat = 1e-30} - assertRoundTripJSON {$0.optionalFloat = Float(1e-40)} - assertRoundTripJSON {$0.optionalFloat = Float(1e-50)} - assertRoundTripJSON {$0.optionalFloat = Float(1e-60)} - assertRoundTripJSON {$0.optionalFloat = Float(1e-100)} - assertRoundTripJSON {$0.optionalFloat = Float(1e-200)} - assertRoundTripJSON {$0.optionalFloat = Float.pi} - assertRoundTripJSON {$0.optionalFloat = 123456.789123456789123} - assertRoundTripJSON {$0.optionalFloat = 1999.9999999999} - assertRoundTripJSON {$0.optionalFloat = 1999.9} - assertRoundTripJSON {$0.optionalFloat = 1999.99} - assertRoundTripJSON {$0.optionalFloat = 1999.99} - assertRoundTripJSON {$0.optionalFloat = 3.402823567e+38} - assertRoundTripJSON {$0.optionalFloat = 1.1754944e-38} + assertRoundTripJSON { $0.optionalFloat = 0.1 } + assertRoundTripJSON { $0.optionalFloat = 0.01 } + assertRoundTripJSON { $0.optionalFloat = 0.001 } + assertRoundTripJSON { $0.optionalFloat = 0.0001 } + assertRoundTripJSON { $0.optionalFloat = 0.00001 } + assertRoundTripJSON { $0.optionalFloat = 0.000001 } + assertRoundTripJSON { $0.optionalFloat = 1.00000075e-36 } + assertRoundTripJSON { $0.optionalFloat = 1e-10 } + assertRoundTripJSON { $0.optionalFloat = 1e-20 } + assertRoundTripJSON { $0.optionalFloat = 1e-30 } + assertRoundTripJSON { $0.optionalFloat = Float(1e-40) } + assertRoundTripJSON { $0.optionalFloat = Float(1e-50) } + assertRoundTripJSON { $0.optionalFloat = Float(1e-60) } + assertRoundTripJSON { $0.optionalFloat = Float(1e-100) } + assertRoundTripJSON { $0.optionalFloat = Float(1e-200) } + assertRoundTripJSON { $0.optionalFloat = Float.pi } + assertRoundTripJSON { $0.optionalFloat = 123456.789123456789123 } + assertRoundTripJSON { $0.optionalFloat = 1999.9999999999 } + assertRoundTripJSON { $0.optionalFloat = 1999.9 } + assertRoundTripJSON { $0.optionalFloat = 1999.99 } + assertRoundTripJSON { $0.optionalFloat = 1999.99 } + assertRoundTripJSON { $0.optionalFloat = 3.402823567e+38 } + assertRoundTripJSON { $0.optionalFloat = 1.1754944e-38 } } func testOptionalDouble_NaN() throws { // The helper functions don't work with NaN because NaN != NaN - var o = Proto3Unittest_TestAllTypes() + var o = SwiftProtoTesting_Proto3_TestAllTypes() o.optionalDouble = Double.nan let encoded = try o.jsonString() XCTAssertEqual(encoded, "{\"optionalDouble\":\"NaN\"}") - let o2 = try Proto3Unittest_TestAllTypes(jsonString: encoded) + let o2 = try SwiftProtoTesting_Proto3_TestAllTypes(jsonString: encoded) XCTAssert(o2.optionalDouble.isNaN == .some(true)) } func testOptionalFloat_NaN() throws { // The helper functions don't work with NaN because NaN != NaN - var o = Proto3Unittest_TestAllTypes() + var o = SwiftProtoTesting_Proto3_TestAllTypes() o.optionalFloat = Float.nan let encoded = try o.jsonString() XCTAssertEqual(encoded, "{\"optionalFloat\":\"NaN\"}") do { - let o2 = try Proto3Unittest_TestAllTypes(jsonString: encoded) + let o2 = try SwiftProtoTesting_Proto3_TestAllTypes(jsonString: encoded) XCTAssert(o2.optionalFloat.isNaN == .some(true)) } catch let e { XCTFail("Couldn't decode: \(e) -- \(encoded)") @@ -601,19 +675,19 @@ class Test_JSON: XCTestCase, PBTestHelpers { func testOptionalDouble_roundtrip() throws { for _ in 0..<10000 { let d = drand48() - assertRoundTripJSON {$0.optionalDouble = d} + assertRoundTripJSON { $0.optionalDouble = d } } } func testOptionalFloat_roundtrip() throws { for _ in 0..<10000 { let f = Float(drand48()) - assertRoundTripJSON {$0.optionalFloat = f} + assertRoundTripJSON { $0.optionalFloat = f } } } func testOptionalBool() throws { - assertJSONEncode("{\"optionalBool\":true}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalBool\":true}") { (o: inout MessageTestType) in o.optionalBool = true } @@ -624,15 +698,15 @@ class Test_JSON: XCTestCase, PBTestHelpers { } func testOptionalString() { - assertJSONEncode("{\"optionalString\":\"hello\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalString\":\"hello\"}") { (o: inout MessageTestType) in o.optionalString = "hello" } // Start of the C1 range - assertJSONEncode("{\"optionalString\":\"~\\u007F\\u0080\\u0081\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalString\":\"~\\u007F\\u0080\\u0081\"}") { (o: inout MessageTestType) in o.optionalString = "\u{7e}\u{7f}\u{80}\u{81}" } // End of the C1 range - assertJSONEncode("{\"optionalString\":\"\\u009E\\u009F ¡¢£\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalString\":\"\\u009E\\u009F ¡¢£\"}") { (o: inout MessageTestType) in o.optionalString = "\u{9e}\u{9f}\u{a0}\u{a1}\u{a2}\u{a3}" } @@ -642,11 +716,11 @@ class Test_JSON: XCTestCase, PBTestHelpers { XCTAssertEqual(try a.jsonString(), "{}") // Example from RFC 7159: G clef coded as escaped surrogate pair - assertJSONDecodeSucceeds("{\"optionalString\":\"\\uD834\\uDD1E\"}") {$0.optionalString == "𝄞"} + assertJSONDecodeSucceeds("{\"optionalString\":\"\\uD834\\uDD1E\"}") { $0.optionalString == "𝄞" } // Ditto, with lowercase hex - assertJSONDecodeSucceeds("{\"optionalString\":\"\\ud834\\udd1e\"}") {$0.optionalString == "𝄞"} + assertJSONDecodeSucceeds("{\"optionalString\":\"\\ud834\\udd1e\"}") { $0.optionalString == "𝄞" } // Same character represented directly - assertJSONDecodeSucceeds("{\"optionalString\":\"𝄞\"}") {$0.optionalString == "𝄞"} + assertJSONDecodeSucceeds("{\"optionalString\":\"𝄞\"}") { $0.optionalString == "𝄞" } // Various broken surrogate forms assertJSONDecodeFails("{\"optionalString\":\"\\uDD1E\\uD834\"}") assertJSONDecodeFails("{\"optionalString\":\"\\uDD1E\"}") @@ -655,24 +729,23 @@ class Test_JSON: XCTestCase, PBTestHelpers { } func testOptionalString_controlCharacters() { - // This is known to fail on Swift Linux 4.1 and earlier, - // so skip it there. - // See https://bugs.swift.org/browse/SR-4218 for details. -#if !os(Linux) || swift(>=4.2) // Verify that all C0 controls are correctly escaped - assertJSONEncode("{\"optionalString\":\"\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalString\":\"\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\"}") { + (o: inout MessageTestType) in o.optionalString = "\u{00}\u{01}\u{02}\u{03}\u{04}\u{05}\u{06}\u{07}" } - assertJSONEncode("{\"optionalString\":\"\\b\\t\\n\\u000B\\f\\r\\u000E\\u000F\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalString\":\"\\b\\t\\n\\u000B\\f\\r\\u000E\\u000F\"}") { + (o: inout MessageTestType) in o.optionalString = "\u{08}\u{09}\u{0a}\u{0b}\u{0c}\u{0d}\u{0e}\u{0f}" } - assertJSONEncode("{\"optionalString\":\"\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalString\":\"\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\"}") { + (o: inout MessageTestType) in o.optionalString = "\u{10}\u{11}\u{12}\u{13}\u{14}\u{15}\u{16}\u{17}" } - assertJSONEncode("{\"optionalString\":\"\\u0018\\u0019\\u001A\\u001B\\u001C\\u001D\\u001E\\u001F\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalString\":\"\\u0018\\u0019\\u001A\\u001B\\u001C\\u001D\\u001E\\u001F\"}") { + (o: inout MessageTestType) in o.optionalString = "\u{18}\u{19}\u{1a}\u{1b}\u{1c}\u{1d}\u{1e}\u{1f}" } -#endif } func testOptionalBytes() throws { @@ -681,41 +754,41 @@ class Test_JSON: XCTestCase, PBTestHelpers { a.optionalBytes = Data() XCTAssertEqual(try a.jsonString(), "{}") - assertJSONEncode("{\"optionalBytes\":\"AA==\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalBytes\":\"AA==\"}") { (o: inout MessageTestType) in o.optionalBytes = Data([0]) } - assertJSONEncode("{\"optionalBytes\":\"AAA=\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalBytes\":\"AAA=\"}") { (o: inout MessageTestType) in o.optionalBytes = Data([0, 0]) } - assertJSONEncode("{\"optionalBytes\":\"AAAA\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalBytes\":\"AAAA\"}") { (o: inout MessageTestType) in o.optionalBytes = Data([0, 0, 0]) } - assertJSONEncode("{\"optionalBytes\":\"/w==\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalBytes\":\"/w==\"}") { (o: inout MessageTestType) in o.optionalBytes = Data([255]) } - assertJSONEncode("{\"optionalBytes\":\"//8=\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalBytes\":\"//8=\"}") { (o: inout MessageTestType) in o.optionalBytes = Data([255, 255]) } - assertJSONEncode("{\"optionalBytes\":\"////\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalBytes\":\"////\"}") { (o: inout MessageTestType) in o.optionalBytes = Data([255, 255, 255]) } - assertJSONEncode("{\"optionalBytes\":\"QQ==\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalBytes\":\"QQ==\"}") { (o: inout MessageTestType) in o.optionalBytes = Data([65]) } assertJSONDecodeFails("{\"optionalBytes\":\"QQ=\"}") assertJSONDecodeSucceeds("{\"optionalBytes\":\"QQ\"}") { $0.optionalBytes == Data([65]) } - assertJSONEncode("{\"optionalBytes\":\"QUI=\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalBytes\":\"QUI=\"}") { (o: inout MessageTestType) in o.optionalBytes = Data([65, 66]) } assertJSONDecodeSucceeds("{\"optionalBytes\":\"QUI\"}") { $0.optionalBytes == Data([65, 66]) } - assertJSONEncode("{\"optionalBytes\":\"QUJD\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalBytes\":\"QUJD\"}") { (o: inout MessageTestType) in o.optionalBytes = Data([65, 66, 67]) } - assertJSONEncode("{\"optionalBytes\":\"QUJDRA==\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalBytes\":\"QUJDRA==\"}") { (o: inout MessageTestType) in o.optionalBytes = Data([65, 66, 67, 68]) } assertJSONDecodeFails("{\"optionalBytes\":\"QUJDRA===\"}") @@ -723,14 +796,14 @@ class Test_JSON: XCTestCase, PBTestHelpers { assertJSONDecodeSucceeds("{\"optionalBytes\":\"QUJDRA\"}") { $0.optionalBytes == Data([65, 66, 67, 68]) } - assertJSONEncode("{\"optionalBytes\":\"QUJDREU=\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalBytes\":\"QUJDREU=\"}") { (o: inout MessageTestType) in o.optionalBytes = Data([65, 66, 67, 68, 69]) } assertJSONDecodeFails("{\"optionalBytes\":\"QUJDREU==\"}") assertJSONDecodeSucceeds("{\"optionalBytes\":\"QUJDREU\"}") { $0.optionalBytes == Data([65, 66, 67, 68, 69]) } - assertJSONEncode("{\"optionalBytes\":\"QUJDREVG\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalBytes\":\"QUJDREVG\"}") { (o: inout MessageTestType) in o.optionalBytes = Data([65, 66, 67, 68, 69, 70]) } assertJSONDecodeFails("{\"optionalBytes\":\"QUJDREVG=\"}") @@ -796,29 +869,29 @@ class Test_JSON: XCTestCase, PBTestHelpers { func testOptionalBytes_roundtrip() throws { for i in UInt8(0)...UInt8(255) { let d = Data([i]) - let message = Proto3Unittest_TestAllTypes.with { $0.optionalBytes = d } + let message = SwiftProtoTesting_Proto3_TestAllTypes.with { $0.optionalBytes = d } let text = try message.jsonString() - let decoded = try Proto3Unittest_TestAllTypes(jsonString: text) + let decoded = try SwiftProtoTesting_Proto3_TestAllTypes(jsonString: text) XCTAssertEqual(decoded, message) XCTAssertEqual(message.optionalBytes[0], i) } } func testOptionalNestedMessage() { - assertJSONEncode("{\"optionalNestedMessage\":{\"bb\":1}}") {(o: inout MessageTestType) in - var sub = Proto3Unittest_TestAllTypes.NestedMessage() + assertJSONEncode("{\"optionalNestedMessage\":{\"bb\":1}}") { (o: inout MessageTestType) in + var sub = SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage() sub.bb = 1 o.optionalNestedMessage = sub } } func testOptionalNestedEnum() { - assertJSONEncode("{\"optionalNestedEnum\":\"FOO\"}") {(o: inout MessageTestType) in - o.optionalNestedEnum = Proto3Unittest_TestAllTypes.NestedEnum.foo + assertJSONEncode("{\"optionalNestedEnum\":\"FOO\"}") { (o: inout MessageTestType) in + o.optionalNestedEnum = SwiftProtoTesting_Proto3_TestAllTypes.NestedEnum.foo } - assertJSONDecodeSucceeds("{\"optionalNestedEnum\":1}") {$0.optionalNestedEnum == .foo} + assertJSONDecodeSucceeds("{\"optionalNestedEnum\":1}") { $0.optionalNestedEnum == .foo } // Out-of-range values should be serialized to an int - assertJSONEncode("{\"optionalNestedEnum\":123}") {(o: inout MessageTestType) in + assertJSONEncode("{\"optionalNestedEnum\":123}") { (o: inout MessageTestType) in o.optionalNestedEnum = .UNRECOGNIZED(123) } // TODO: Check whether Google's spec agrees that unknown Enum tags @@ -827,47 +900,47 @@ class Test_JSON: XCTestCase, PBTestHelpers { } func testRepeatedInt32() { - assertJSONEncode("{\"repeatedInt32\":[1]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"repeatedInt32\":[1]}") { (o: inout MessageTestType) in o.repeatedInt32 = [1] } - assertJSONEncode("{\"repeatedInt32\":[1,2]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"repeatedInt32\":[1,2]}") { (o: inout MessageTestType) in o.repeatedInt32 = [1, 2] } - assertEncode([250, 1, 2, 1, 2]) {(o: inout MessageTestType) in + assertEncode([250, 1, 2, 1, 2]) { (o: inout MessageTestType) in // Proto3 seems to default to packed for repeated int fields o.repeatedInt32 = [1, 2] } - assertJSONDecodeSucceeds("{\"repeatedInt32\":null}") {$0.repeatedInt32 == []} - assertJSONDecodeSucceeds("{\"repeatedInt32\":[]}") {$0.repeatedInt32 == []} - assertJSONDecodeSucceeds("{\"repeatedInt32\":[1]}") {$0.repeatedInt32 == [1]} - assertJSONDecodeSucceeds("{\"repeatedInt32\":[1,2]}") {$0.repeatedInt32 == [1, 2]} + assertJSONDecodeSucceeds("{\"repeatedInt32\":null}") { $0.repeatedInt32 == [] } + assertJSONDecodeSucceeds("{\"repeatedInt32\":[]}") { $0.repeatedInt32 == [] } + assertJSONDecodeSucceeds("{\"repeatedInt32\":[1]}") { $0.repeatedInt32 == [1] } + assertJSONDecodeSucceeds("{\"repeatedInt32\":[1,2]}") { $0.repeatedInt32 == [1, 2] } } func testRepeatedString() { - assertJSONEncode("{\"repeatedString\":[\"\"]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"repeatedString\":[\"\"]}") { (o: inout MessageTestType) in o.repeatedString = [""] } - assertJSONEncode("{\"repeatedString\":[\"abc\",\"\"]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"repeatedString\":[\"abc\",\"\"]}") { (o: inout MessageTestType) in o.repeatedString = ["abc", ""] } - assertJSONDecodeSucceeds("{\"repeatedString\":null}") {$0.repeatedString == []} - assertJSONDecodeSucceeds("{\"repeatedString\":[]}") {$0.repeatedString == []} + assertJSONDecodeSucceeds("{\"repeatedString\":null}") { $0.repeatedString == [] } + assertJSONDecodeSucceeds("{\"repeatedString\":[]}") { $0.repeatedString == [] } assertJSONDecodeSucceeds(" { \"repeatedString\" : [ \"1\" , \"2\" ] } ") { $0.repeatedString == ["1", "2"] } } func testRepeatedNestedMessage() { - assertJSONEncode("{\"repeatedNestedMessage\":[{\"bb\":1}]}") {(o: inout MessageTestType) in - var sub = Proto3Unittest_TestAllTypes.NestedMessage() + assertJSONEncode("{\"repeatedNestedMessage\":[{\"bb\":1}]}") { (o: inout MessageTestType) in + var sub = SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage() sub.bb = 1 o.repeatedNestedMessage = [sub] } - assertJSONEncode("{\"repeatedNestedMessage\":[{\"bb\":1},{\"bb\":2}]}") {(o: inout MessageTestType) in - var sub1 = Proto3Unittest_TestAllTypes.NestedMessage() + assertJSONEncode("{\"repeatedNestedMessage\":[{\"bb\":1},{\"bb\":2}]}") { (o: inout MessageTestType) in + var sub1 = SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage() sub1.bb = 1 - var sub2 = Proto3Unittest_TestAllTypes.NestedMessage() + var sub2 = SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage() sub2.bb = 2 o.repeatedNestedMessage = [sub1, sub2] } @@ -877,22 +950,22 @@ class Test_JSON: XCTestCase, PBTestHelpers { } func testRepeatedEnum() { - assertJSONEncode("{\"repeatedNestedEnum\":[\"FOO\"]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"repeatedNestedEnum\":[\"FOO\"]}") { (o: inout MessageTestType) in o.repeatedNestedEnum = [.foo] } - assertJSONEncode("{\"repeatedNestedEnum\":[\"FOO\",\"BAR\"]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"repeatedNestedEnum\":[\"FOO\",\"BAR\"]}") { (o: inout MessageTestType) in o.repeatedNestedEnum = [.foo, .bar] } - assertJSONDecodeSucceeds("{\"repeatedNestedEnum\":[\"FOO\",0,1,\"BAR\",-1]}") {(o:MessageTestType) in + assertJSONDecodeSucceeds("{\"repeatedNestedEnum\":[\"FOO\",0,1,\"BAR\",-1]}") { (o: MessageTestType) in o.repeatedNestedEnum == [.foo, .zero, .foo, .bar, .neg] } assertJSONDecodeFails("{\"repeatedNestedEnum\":[null]}") assertJSONDecodeFails("{\"repeatedNestedEnum\":\"FOO\"}") assertJSONDecodeFails("{\"repeatedNestedEnum\":0}") - assertJSONDecodeSucceeds("{\"repeatedNestedEnum\":null}") {(o:MessageTestType) in + assertJSONDecodeSucceeds("{\"repeatedNestedEnum\":null}") { (o: MessageTestType) in o.repeatedNestedEnum == [] } - assertJSONDecodeSucceeds("{\"repeatedNestedEnum\":[]}") {(o:MessageTestType) in + assertJSONDecodeSucceeds("{\"repeatedNestedEnum\":[]}") { (o: MessageTestType) in o.repeatedNestedEnum == [] } } @@ -900,14 +973,14 @@ class Test_JSON: XCTestCase, PBTestHelpers { // TODO: Test other repeated field types func testOneof() { - assertJSONEncode("{\"oneofUint32\":1}") {(o: inout MessageTestType) in + assertJSONEncode("{\"oneofUint32\":1}") { (o: inout MessageTestType) in o.oneofUint32 = 1 } - assertJSONEncode("{\"oneofString\":\"abc\"}") {(o: inout MessageTestType) in + assertJSONEncode("{\"oneofString\":\"abc\"}") { (o: inout MessageTestType) in o.oneofString = "abc" } - assertJSONEncode("{\"oneofNestedMessage\":{\"bb\":1}}") {(o: inout MessageTestType) in - var sub = Proto3Unittest_TestAllTypes.NestedMessage() + assertJSONEncode("{\"oneofNestedMessage\":{\"bb\":1}}") { (o: inout MessageTestType) in + var sub = SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage() sub.bb = 1 o.oneofNestedMessage = sub } @@ -917,219 +990,218 @@ class Test_JSON: XCTestCase, PBTestHelpers { } func testEmptyMessage() { - assertJSONDecodeSucceeds("{}") {MessageTestType -> Bool in true} + assertJSONDecodeSucceeds("{}") { MessageTestType -> Bool in true } assertJSONDecodeFails("") assertJSONDecodeFails("{") assertJSONDecodeFails("}") } } - -class Test_JSONPacked: XCTestCase, PBTestHelpers { - typealias MessageTestType = Proto3Unittest_TestPackedTypes +final class Test_JSONPacked: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_Proto3_TestPackedTypes func testPackedFloat() { - assertJSONEncode("{\"packedFloat\":[1.0]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedFloat\":[1.0]}") { (o: inout MessageTestType) in o.packedFloat = [1] } - assertJSONEncode("{\"packedFloat\":[1.0,0.25,0.125]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedFloat\":[1.0,0.25,0.125]}") { (o: inout MessageTestType) in o.packedFloat = [1, 0.25, 0.125] } assertJSONDecodeSucceeds("{\"packedFloat\":[1,0.25,125e-3]}") { $0.packedFloat == [1, 0.25, 0.125] } - assertJSONDecodeSucceeds("{\"packedFloat\":null}") {$0.packedFloat == []} - assertJSONDecodeSucceeds("{\"packedFloat\":[]}") {$0.packedFloat == []} - assertJSONDecodeSucceeds("{\"packedFloat\":[\"1\"]}") {$0.packedFloat == [1]} - assertJSONDecodeSucceeds("{\"packedFloat\":[\"1\",2]}") {$0.packedFloat == [1, 2]} + assertJSONDecodeSucceeds("{\"packedFloat\":null}") { $0.packedFloat == [] } + assertJSONDecodeSucceeds("{\"packedFloat\":[]}") { $0.packedFloat == [] } + assertJSONDecodeSucceeds("{\"packedFloat\":[\"1\"]}") { $0.packedFloat == [1] } + assertJSONDecodeSucceeds("{\"packedFloat\":[\"1\",2]}") { $0.packedFloat == [1, 2] } } func testPackedDouble() { - assertJSONEncode("{\"packedDouble\":[1.0]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedDouble\":[1.0]}") { (o: inout MessageTestType) in o.packedDouble = [1] } - assertJSONEncode("{\"packedDouble\":[1.0,0.25,0.125]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedDouble\":[1.0,0.25,0.125]}") { (o: inout MessageTestType) in o.packedDouble = [1, 0.25, 0.125] } assertJSONDecodeSucceeds("{\"packedDouble\":[1,0.25,125e-3]}") { $0.packedDouble == [1, 0.25, 0.125] } - assertJSONDecodeSucceeds("{\"packedDouble\":null}") {$0.packedDouble == []} - assertJSONDecodeSucceeds("{\"packedDouble\":[]}") {$0.packedDouble == []} - assertJSONDecodeSucceeds("{\"packedDouble\":[\"1\"]}") {$0.packedDouble == [1]} - assertJSONDecodeSucceeds("{\"packedDouble\":[\"1\",2]}") {$0.packedDouble == [1, 2]} + assertJSONDecodeSucceeds("{\"packedDouble\":null}") { $0.packedDouble == [] } + assertJSONDecodeSucceeds("{\"packedDouble\":[]}") { $0.packedDouble == [] } + assertJSONDecodeSucceeds("{\"packedDouble\":[\"1\"]}") { $0.packedDouble == [1] } + assertJSONDecodeSucceeds("{\"packedDouble\":[\"1\",2]}") { $0.packedDouble == [1, 2] } } func testPackedInt32() { - assertJSONEncode("{\"packedInt32\":[1]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedInt32\":[1]}") { (o: inout MessageTestType) in o.packedInt32 = [1] } - assertJSONEncode("{\"packedInt32\":[1,2]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedInt32\":[1,2]}") { (o: inout MessageTestType) in o.packedInt32 = [1, 2] } - assertJSONEncode("{\"packedInt32\":[-2147483648,2147483647]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedInt32\":[-2147483648,2147483647]}") { (o: inout MessageTestType) in o.packedInt32 = [Int32.min, Int32.max] } - assertJSONDecodeSucceeds("{\"packedInt32\":null}") {$0.packedInt32 == []} - assertJSONDecodeSucceeds("{\"packedInt32\":[]}") {$0.packedInt32 == []} - assertJSONDecodeSucceeds("{\"packedInt32\":[\"1\"]}") {$0.packedInt32 == [1]} - assertJSONDecodeSucceeds("{\"packedInt32\":[\"1\",\"2\"]}") {$0.packedInt32 == [1, 2]} - assertJSONDecodeSucceeds(" { \"packedInt32\" : [ \"1\" , \"2\" ] } ") {$0.packedInt32 == [1, 2]} + assertJSONDecodeSucceeds("{\"packedInt32\":null}") { $0.packedInt32 == [] } + assertJSONDecodeSucceeds("{\"packedInt32\":[]}") { $0.packedInt32 == [] } + assertJSONDecodeSucceeds("{\"packedInt32\":[\"1\"]}") { $0.packedInt32 == [1] } + assertJSONDecodeSucceeds("{\"packedInt32\":[\"1\",\"2\"]}") { $0.packedInt32 == [1, 2] } + assertJSONDecodeSucceeds(" { \"packedInt32\" : [ \"1\" , \"2\" ] } ") { $0.packedInt32 == [1, 2] } } func testPackedInt64() { - assertJSONEncode("{\"packedInt64\":[\"1\"]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedInt64\":[\"1\"]}") { (o: inout MessageTestType) in o.packedInt64 = [1] } assertJSONEncode("{\"packedInt64\":[\"9223372036854775807\",\"-9223372036854775808\"]}") { (o: inout MessageTestType) in o.packedInt64 = [Int64.max, Int64.min] } - assertJSONDecodeSucceeds("{\"packedInt64\":null}") {$0.packedInt64 == []} - assertJSONDecodeSucceeds("{\"packedInt64\":[]}") {$0.packedInt64 == []} - assertJSONDecodeSucceeds("{\"packedInt64\":[1]}") {$0.packedInt64 == [1]} - assertJSONDecodeSucceeds("{\"packedInt64\":[1,2]}") {$0.packedInt64 == [1, 2]} + assertJSONDecodeSucceeds("{\"packedInt64\":null}") { $0.packedInt64 == [] } + assertJSONDecodeSucceeds("{\"packedInt64\":[]}") { $0.packedInt64 == [] } + assertJSONDecodeSucceeds("{\"packedInt64\":[1]}") { $0.packedInt64 == [1] } + assertJSONDecodeSucceeds("{\"packedInt64\":[1,2]}") { $0.packedInt64 == [1, 2] } assertJSONDecodeFails("{\"packedInt64\":[null]}") } func testPackedUInt32() { - assertJSONEncode("{\"packedUint32\":[1]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedUint32\":[1]}") { (o: inout MessageTestType) in o.packedUint32 = [1] } - assertJSONEncode("{\"packedUint32\":[0,4294967295]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedUint32\":[0,4294967295]}") { (o: inout MessageTestType) in o.packedUint32 = [UInt32.min, UInt32.max] } - assertJSONDecodeSucceeds("{\"packedUint32\":null}") {$0.packedUint32 == []} - assertJSONDecodeSucceeds("{\"packedUint32\":[]}") {$0.packedUint32 == []} - assertJSONDecodeSucceeds("{\"packedUint32\":[1]}") {$0.packedUint32 == [1]} - assertJSONDecodeSucceeds("{\"packedUint32\":[1,2]}") {$0.packedUint32 == [1, 2]} + assertJSONDecodeSucceeds("{\"packedUint32\":null}") { $0.packedUint32 == [] } + assertJSONDecodeSucceeds("{\"packedUint32\":[]}") { $0.packedUint32 == [] } + assertJSONDecodeSucceeds("{\"packedUint32\":[1]}") { $0.packedUint32 == [1] } + assertJSONDecodeSucceeds("{\"packedUint32\":[1,2]}") { $0.packedUint32 == [1, 2] } assertJSONDecodeFails("{\"packedUint32\":[null]}") assertJSONDecodeFails("{\"packedUint32\":[-1]}") assertJSONDecodeFails("{\"packedUint32\":[1.2]}") } func testPackedUInt64() { - assertJSONEncode("{\"packedUint64\":[\"1\"]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedUint64\":[\"1\"]}") { (o: inout MessageTestType) in o.packedUint64 = [1] } assertJSONEncode("{\"packedUint64\":[\"0\",\"18446744073709551615\"]}") { (o: inout MessageTestType) in o.packedUint64 = [UInt64.min, UInt64.max] } - assertJSONDecodeSucceeds("{\"packedUint64\":null}") {$0.packedUint64 == []} - assertJSONDecodeSucceeds("{\"packedUint64\":[]}") {$0.packedUint64 == []} - assertJSONDecodeSucceeds("{\"packedUint64\":[1]}") {$0.packedUint64 == [1]} - assertJSONDecodeSucceeds("{\"packedUint64\":[1,2]}") {$0.packedUint64 == [1, 2]} + assertJSONDecodeSucceeds("{\"packedUint64\":null}") { $0.packedUint64 == [] } + assertJSONDecodeSucceeds("{\"packedUint64\":[]}") { $0.packedUint64 == [] } + assertJSONDecodeSucceeds("{\"packedUint64\":[1]}") { $0.packedUint64 == [1] } + assertJSONDecodeSucceeds("{\"packedUint64\":[1,2]}") { $0.packedUint64 == [1, 2] } assertJSONDecodeFails("{\"packedUint64\":[null]}") assertJSONDecodeFails("{\"packedUint64\":[-1]}") assertJSONDecodeFails("{\"packedUint64\":[1.2]}") } func testPackedSInt32() { - assertJSONEncode("{\"packedSint32\":[1]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedSint32\":[1]}") { (o: inout MessageTestType) in o.packedSint32 = [1] } - assertJSONEncode("{\"packedSint32\":[-2147483648,2147483647]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedSint32\":[-2147483648,2147483647]}") { (o: inout MessageTestType) in o.packedSint32 = [Int32.min, Int32.max] } - assertJSONDecodeSucceeds("{\"packedSint32\":null}") {$0.packedSint32 == []} - assertJSONDecodeSucceeds("{\"packedSint32\":[]}") {$0.packedSint32 == []} - assertJSONDecodeSucceeds("{\"packedSint32\":[1]}") {$0.packedSint32 == [1]} - assertJSONDecodeSucceeds("{\"packedSint32\":[1,2]}") {$0.packedSint32 == [1, 2]} + assertJSONDecodeSucceeds("{\"packedSint32\":null}") { $0.packedSint32 == [] } + assertJSONDecodeSucceeds("{\"packedSint32\":[]}") { $0.packedSint32 == [] } + assertJSONDecodeSucceeds("{\"packedSint32\":[1]}") { $0.packedSint32 == [1] } + assertJSONDecodeSucceeds("{\"packedSint32\":[1,2]}") { $0.packedSint32 == [1, 2] } assertJSONDecodeFails("{\"packedSint32\":[null]}") assertJSONDecodeFails("{\"packedSint32\":[1.2]}") } func testPackedSInt64() { - assertJSONEncode("{\"packedSint64\":[\"1\"]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedSint64\":[\"1\"]}") { (o: inout MessageTestType) in o.packedSint64 = [1] } assertJSONEncode("{\"packedSint64\":[\"-9223372036854775808\",\"9223372036854775807\"]}") { (o: inout MessageTestType) in o.packedSint64 = [Int64.min, Int64.max] } - assertJSONDecodeSucceeds("{\"packedSint64\":null}") {$0.packedSint64 == []} - assertJSONDecodeSucceeds("{\"packedSint64\":[]}") {$0.packedSint64 == []} - assertJSONDecodeSucceeds("{\"packedSint64\":[1]}") {$0.packedSint64 == [1]} - assertJSONDecodeSucceeds("{\"packedSint64\":[1,2]}") {$0.packedSint64 == [1, 2]} + assertJSONDecodeSucceeds("{\"packedSint64\":null}") { $0.packedSint64 == [] } + assertJSONDecodeSucceeds("{\"packedSint64\":[]}") { $0.packedSint64 == [] } + assertJSONDecodeSucceeds("{\"packedSint64\":[1]}") { $0.packedSint64 == [1] } + assertJSONDecodeSucceeds("{\"packedSint64\":[1,2]}") { $0.packedSint64 == [1, 2] } assertJSONDecodeFails("{\"packedSint64\":[null]}") assertJSONDecodeFails("{\"packedSint64\":[1.2]}") } func testPackedFixed32() { - assertJSONEncode("{\"packedFixed32\":[1]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedFixed32\":[1]}") { (o: inout MessageTestType) in o.packedFixed32 = [1] } - assertJSONEncode("{\"packedFixed32\":[0,4294967295]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedFixed32\":[0,4294967295]}") { (o: inout MessageTestType) in o.packedFixed32 = [UInt32.min, UInt32.max] } - assertJSONDecodeSucceeds("{\"packedFixed32\":null}") {$0.packedFixed32 == []} - assertJSONDecodeSucceeds("{\"packedFixed32\":[]}") {$0.packedFixed32 == []} - assertJSONDecodeSucceeds("{\"packedFixed32\":[1]}") {$0.packedFixed32 == [1]} - assertJSONDecodeSucceeds("{\"packedFixed32\":[1,2]}") {$0.packedFixed32 == [1, 2]} + assertJSONDecodeSucceeds("{\"packedFixed32\":null}") { $0.packedFixed32 == [] } + assertJSONDecodeSucceeds("{\"packedFixed32\":[]}") { $0.packedFixed32 == [] } + assertJSONDecodeSucceeds("{\"packedFixed32\":[1]}") { $0.packedFixed32 == [1] } + assertJSONDecodeSucceeds("{\"packedFixed32\":[1,2]}") { $0.packedFixed32 == [1, 2] } assertJSONDecodeFails("{\"packedFixed32\":[null]}") assertJSONDecodeFails("{\"packedFixed32\":[-1]}") assertJSONDecodeFails("{\"packedFixed32\":[1.2]}") } func testPackedFixed64() { - assertJSONEncode("{\"packedFixed64\":[\"1\"]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedFixed64\":[\"1\"]}") { (o: inout MessageTestType) in o.packedFixed64 = [1] } assertJSONEncode("{\"packedFixed64\":[\"0\",\"18446744073709551615\"]}") { (o: inout MessageTestType) in o.packedFixed64 = [UInt64.min, UInt64.max] } - assertJSONDecodeSucceeds("{\"packedFixed64\":null}") {$0.packedFixed64 == []} - assertJSONDecodeSucceeds("{\"packedFixed64\":[]}") {$0.packedFixed64 == []} - assertJSONDecodeSucceeds("{\"packedFixed64\":[1]}") {$0.packedFixed64 == [1]} - assertJSONDecodeSucceeds("{\"packedFixed64\":[1,2]}") {$0.packedFixed64 == [1, 2]} + assertJSONDecodeSucceeds("{\"packedFixed64\":null}") { $0.packedFixed64 == [] } + assertJSONDecodeSucceeds("{\"packedFixed64\":[]}") { $0.packedFixed64 == [] } + assertJSONDecodeSucceeds("{\"packedFixed64\":[1]}") { $0.packedFixed64 == [1] } + assertJSONDecodeSucceeds("{\"packedFixed64\":[1,2]}") { $0.packedFixed64 == [1, 2] } assertJSONDecodeFails("{\"packedFixed64\":[null]}") assertJSONDecodeFails("{\"packedFixed64\":[-1]}") assertJSONDecodeFails("{\"packedFixed64\":[1.2]}") } func testPackedSFixed32() { - assertJSONEncode("{\"packedSfixed32\":[1]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedSfixed32\":[1]}") { (o: inout MessageTestType) in o.packedSfixed32 = [1] } - assertJSONEncode("{\"packedSfixed32\":[-2147483648,2147483647]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedSfixed32\":[-2147483648,2147483647]}") { (o: inout MessageTestType) in o.packedSfixed32 = [Int32.min, Int32.max] } - assertJSONDecodeSucceeds("{\"packedSfixed32\":null}") {$0.packedSfixed32 == []} - assertJSONDecodeSucceeds("{\"packedSfixed32\":[]}") {$0.packedSfixed32 == []} - assertJSONDecodeSucceeds("{\"packedSfixed32\":[1]}") {$0.packedSfixed32 == [1]} - assertJSONDecodeSucceeds("{\"packedSfixed32\":[1,2]}") {$0.packedSfixed32 == [1, 2]} + assertJSONDecodeSucceeds("{\"packedSfixed32\":null}") { $0.packedSfixed32 == [] } + assertJSONDecodeSucceeds("{\"packedSfixed32\":[]}") { $0.packedSfixed32 == [] } + assertJSONDecodeSucceeds("{\"packedSfixed32\":[1]}") { $0.packedSfixed32 == [1] } + assertJSONDecodeSucceeds("{\"packedSfixed32\":[1,2]}") { $0.packedSfixed32 == [1, 2] } assertJSONDecodeFails("{\"packedSfixed32\":[null]}") assertJSONDecodeFails("{\"packedSfixed32\":[1.2]}") } func testPackedSFixed64() { - assertJSONEncode("{\"packedSfixed64\":[\"1\"]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedSfixed64\":[\"1\"]}") { (o: inout MessageTestType) in o.packedSfixed64 = [1] } assertJSONEncode("{\"packedSfixed64\":[\"-9223372036854775808\",\"9223372036854775807\"]}") { (o: inout MessageTestType) in o.packedSfixed64 = [Int64.min, Int64.max] } - assertJSONDecodeSucceeds("{\"packedSfixed64\":null}") {$0.packedSfixed64 == []} - assertJSONDecodeSucceeds("{\"packedSfixed64\":[]}") {$0.packedSfixed64 == []} - assertJSONDecodeSucceeds("{\"packedSfixed64\":[1]}") {$0.packedSfixed64 == [1]} - assertJSONDecodeSucceeds("{\"packedSfixed64\":[1,2]}") {$0.packedSfixed64 == [1, 2]} + assertJSONDecodeSucceeds("{\"packedSfixed64\":null}") { $0.packedSfixed64 == [] } + assertJSONDecodeSucceeds("{\"packedSfixed64\":[]}") { $0.packedSfixed64 == [] } + assertJSONDecodeSucceeds("{\"packedSfixed64\":[1]}") { $0.packedSfixed64 == [1] } + assertJSONDecodeSucceeds("{\"packedSfixed64\":[1,2]}") { $0.packedSfixed64 == [1, 2] } assertJSONDecodeFails("{\"packedSfixed64\":[null]}") assertJSONDecodeFails("{\"packedSfixed64\":[1.2]}") } func testPackedBool() { - assertJSONEncode("{\"packedBool\":[true]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"packedBool\":[true]}") { (o: inout MessageTestType) in o.packedBool = [true] } assertJSONEncode("{\"packedBool\":[true,false]}") { (o: inout MessageTestType) in - o.packedBool = [true,false] + o.packedBool = [true, false] } - assertJSONDecodeSucceeds("{\"packedBool\":null}") {$0.packedBool == []} - assertJSONDecodeSucceeds("{\"packedBool\":[]}") {$0.packedBool == []} + assertJSONDecodeSucceeds("{\"packedBool\":null}") { $0.packedBool == [] } + assertJSONDecodeSucceeds("{\"packedBool\":[]}") { $0.packedBool == [] } assertJSONDecodeFails("{\"packedBool\":[null]}") assertJSONDecodeFails("{\"packedBool\":[1,0]}") assertJSONDecodeFails("{\"packedBool\":[\"true\"]}") @@ -1137,23 +1209,23 @@ class Test_JSONPacked: XCTestCase, PBTestHelpers { } } -class Test_JSONrepeated: XCTestCase, PBTestHelpers { - typealias MessageTestType = Proto3Unittest_TestUnpackedTypes +final class Test_JSONrepeated: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_Proto3_TestUnpackedTypes func testPackedInt32() { - assertJSONEncode("{\"repeatedInt32\":[1]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"repeatedInt32\":[1]}") { (o: inout MessageTestType) in o.repeatedInt32 = [1] } - assertJSONEncode("{\"repeatedInt32\":[1,2]}") {(o: inout MessageTestType) in + assertJSONEncode("{\"repeatedInt32\":[1,2]}") { (o: inout MessageTestType) in o.repeatedInt32 = [1, 2] } - assertEncode([8, 1, 8, 2]) {(o: inout MessageTestType) in + assertEncode([8, 1, 8, 2]) { (o: inout MessageTestType) in o.repeatedInt32 = [1, 2] } - assertJSONDecodeSucceeds("{\"repeatedInt32\":null}") {$0.repeatedInt32 == []} - assertJSONDecodeSucceeds("{\"repeatedInt32\":[]}") {$0.repeatedInt32 == []} - assertJSONDecodeSucceeds("{\"repeatedInt32\":[1]}") {$0.repeatedInt32 == [1]} - assertJSONDecodeSucceeds("{\"repeatedInt32\":[1,2]}") {$0.repeatedInt32 == [1, 2]} + assertJSONDecodeSucceeds("{\"repeatedInt32\":null}") { $0.repeatedInt32 == [] } + assertJSONDecodeSucceeds("{\"repeatedInt32\":[]}") { $0.repeatedInt32 == [] } + assertJSONDecodeSucceeds("{\"repeatedInt32\":[1]}") { $0.repeatedInt32 == [1] } + assertJSONDecodeSucceeds("{\"repeatedInt32\":[1,2]}") { $0.repeatedInt32 == [1, 2] } } } diff --git a/Tests/SwiftProtobufTests/Test_JSONDecodingOptions.swift b/Tests/SwiftProtobufTests/Test_JSONDecodingOptions.swift index a7ad4b63c..47a10387f 100644 --- a/Tests/SwiftProtobufTests/Test_JSONDecodingOptions.swift +++ b/Tests/SwiftProtobufTests/Test_JSONDecodingOptions.swift @@ -13,10 +13,10 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_JSONDecodingOptions: XCTestCase { +final class Test_JSONDecodingOptions: XCTestCase { func testMessageDepthLimit() { let jsonInputs: [String] = [ @@ -29,11 +29,11 @@ class Test_JSONDecodingOptions: XCTestCase { let tests: [(Int, Bool)] = [ // Limit, success/failure - ( 10, true ), - ( 4, true ), - ( 3, true ), - ( 2, false ), - ( 1, false ), + (10, true), + (4, true), + (3, true), + (2, false), + (1, false), ] for (i, jsonInput) in jsonInputs.enumerated() { @@ -42,7 +42,7 @@ class Test_JSONDecodingOptions: XCTestCase { var options = JSONDecodingOptions() options.messageDepthLimit = limit options.ignoreUnknownFields = true - let _ = try ProtobufUnittest_TestRecursiveMessage(jsonString: jsonInput, options: options) + let _ = try SwiftProtoTesting_TestRecursiveMessage(jsonString: jsonInput, options: options) if !expectSuccess { XCTFail("Should not have succeed, pass: \(i), limit: \(limit)") } @@ -52,7 +52,7 @@ class Test_JSONDecodingOptions: XCTestCase { } else { // Nothing, this is what was expected. } - } catch let e { + } catch let e { XCTFail("Decode failed (pass: \(i), limit: \(limit) with unexpected error: \(e)") } } @@ -134,7 +134,7 @@ class Test_JSONDecodingOptions: XCTestCase { for (i, (isValidJSON, jsonInput)) in jsonInputs.enumerated() { // Default options (error on unknown fields) do { - let _ = try ProtobufUnittest_TestEmptyMessage(jsonString: jsonInput) + let _ = try SwiftProtoTesting_TestEmptyMessage(jsonString: jsonInput) XCTFail("Input \(i): Should not have gotten here! Input: \(jsonInput)") } catch JSONDecodingError.unknownField(let field) { XCTAssertEqual(field, "unknown", "Input \(i): got field \(field)") @@ -144,15 +144,21 @@ class Test_JSONDecodingOptions: XCTestCase { // Ignoring unknown fields do { - let _ = try ProtobufUnittest_TestEmptyMessage(jsonString: jsonInput, - options:options) - XCTAssertTrue(isValidJSON, - "Input \(i): Should not have been able to parse: \(jsonInput)") + let _ = try SwiftProtoTesting_TestEmptyMessage( + jsonString: jsonInput, + options: options + ) + XCTAssertTrue( + isValidJSON, + "Input \(i): Should not have been able to parse: \(jsonInput)" + ) } catch JSONDecodingError.unknownField(let field) { XCTFail("Input \(i): should not have gotten unknown field \(field), input \(jsonInput)") } catch let e { - XCTAssertFalse(isValidJSON, - "Input \(i): Error \(e): Should have been able to parse: \(jsonInput)") + XCTAssertFalse( + isValidJSON, + "Input \(i): Error \(e): Should have been able to parse: \(jsonInput)" + ) } } } diff --git a/Tests/SwiftProtobufTests/Test_JSONEncodingOptions.swift b/Tests/SwiftProtobufTests/Test_JSONEncodingOptions.swift index d497469ec..a625b4695 100644 --- a/Tests/SwiftProtobufTests/Test_JSONEncodingOptions.swift +++ b/Tests/SwiftProtobufTests/Test_JSONEncodingOptions.swift @@ -13,172 +13,371 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_JSONEncodingOptions: XCTestCase { +final class Test_JSONEncodingOptions: XCTestCase { - func testAlwaysPrintEnumsAsInts() { - // Use explict options (the default is false), just to be pedantic. - var asStrings = JSONEncodingOptions() - asStrings.alwaysPrintEnumsAsInts = false - var asInts = JSONEncodingOptions() - asInts.alwaysPrintEnumsAsInts = true + func testAlwaysPrintInt64sAsNumbers() { + // Use explicit options (the default is false), no reason only others can be pedantic. + var asStrings = JSONEncodingOptions() + asStrings.alwaysPrintInt64sAsNumbers = false + var asNumbers = JSONEncodingOptions() + asNumbers.alwaysPrintInt64sAsNumbers = true - // Toplevel fields + // Toplevel fields. + let msg1 = SwiftProtoTesting_Message2.with { + $0.optionalInt64 = 1_656_338_459_803 + } + XCTAssertEqual(try msg1.jsonString(options: asStrings), "{\"optionalInt64\":\"1656338459803\"}") + XCTAssertEqual(try msg1.jsonString(options: asNumbers), "{\"optionalInt64\":1656338459803}") - let msg1 = ProtobufUnittest_Message3.with { - $0.optionalEnum = .bar - } - XCTAssertEqual(try msg1.jsonString(options: asStrings), "{\"optionalEnum\":\"BAR\"}") - XCTAssertEqual(try msg1.jsonString(options: asInts), "{\"optionalEnum\":1}") + let msg2 = SwiftProtoTesting_Message2.with { + $0.repeatedInt64 = [1_656_338_459_802, 1_656_338_459_803] + } + XCTAssertEqual( + try msg2.jsonString(options: asStrings), + "{\"repeatedInt64\":[\"1656338459802\",\"1656338459803\"]}" + ) + XCTAssertEqual(try msg2.jsonString(options: asNumbers), "{\"repeatedInt64\":[1656338459802,1656338459803]}") - let msg2 = ProtobufUnittest_Message3.with { - $0.repeatedEnum = [.bar, .baz] - } - XCTAssertEqual(try msg2.jsonString(options: asStrings), "{\"repeatedEnum\":[\"BAR\",\"BAZ\"]}") - XCTAssertEqual(try msg2.jsonString(options: asInts), "{\"repeatedEnum\":[1,2]}") + let msg3 = SwiftProtoTesting_Message2.with { + $0.mapInt64Int64[1_656_338_459_803] = 1_656_338_459_802 + } + XCTAssertEqual( + try msg3.jsonString(options: asStrings), + "{\"mapInt64Int64\":{\"1656338459803\":\"1656338459802\"}}" + ) + XCTAssertEqual(try msg3.jsonString(options: asNumbers), "{\"mapInt64Int64\":{\"1656338459803\":1656338459802}}") - let msg3 = ProtobufUnittest_Message3.with { - $0.mapInt32Enum[42] = .baz - } - XCTAssertEqual(try msg3.jsonString(options: asStrings), "{\"mapInt32Enum\":{\"42\":\"BAZ\"}}") - XCTAssertEqual(try msg3.jsonString(options: asInts), "{\"mapInt32Enum\":{\"42\":2}}") + // Nested down a level. + let msg4 = SwiftProtoTesting_Message2.with { + $0.optionalMessage.optionalInt64 = 1_656_338_459_802 + } + XCTAssertEqual( + try msg4.jsonString(options: asStrings), + "{\"optionalMessage\":{\"optionalInt64\":\"1656338459802\"}}" + ) + XCTAssertEqual( + try msg4.jsonString(options: asNumbers), + "{\"optionalMessage\":{\"optionalInt64\":1656338459802}}" + ) - // The enum field nested down a level. + let msg5 = SwiftProtoTesting_Message2.with { + $0.optionalMessage.repeatedInt64 = [1_656_338_459_802, 1_656_338_459_803] + } + XCTAssertEqual( + try msg5.jsonString(options: asStrings), + "{\"optionalMessage\":{\"repeatedInt64\":[\"1656338459802\",\"1656338459803\"]}}" + ) + XCTAssertEqual( + try msg5.jsonString(options: asNumbers), + "{\"optionalMessage\":{\"repeatedInt64\":[1656338459802,1656338459803]}}" + ) - let msg4 = ProtobufUnittest_Message3.with { - $0.optionalMessage.optionalEnum = .bar - } - XCTAssertEqual(try msg4.jsonString(options: asStrings), - "{\"optionalMessage\":{\"optionalEnum\":\"BAR\"}}") - XCTAssertEqual(try msg4.jsonString(options: asInts), - "{\"optionalMessage\":{\"optionalEnum\":1}}") + let msg6 = SwiftProtoTesting_Message2.with { + $0.optionalMessage.mapInt64Int64[1_656_338_459_803] = 1_656_338_459_802 + } + XCTAssertEqual( + try msg6.jsonString(options: asStrings), + "{\"optionalMessage\":{\"mapInt64Int64\":{\"1656338459803\":\"1656338459802\"}}}" + ) + XCTAssertEqual( + try msg6.jsonString(options: asNumbers), + "{\"optionalMessage\":{\"mapInt64Int64\":{\"1656338459803\":1656338459802}}}" + ) - let msg5 = ProtobufUnittest_Message3.with { - $0.optionalMessage.repeatedEnum = [.bar, .baz] - } - XCTAssertEqual(try msg5.jsonString(options: asStrings), - "{\"optionalMessage\":{\"repeatedEnum\":[\"BAR\",\"BAZ\"]}}") - XCTAssertEqual(try msg5.jsonString(options: asInts), - "{\"optionalMessage\":{\"repeatedEnum\":[1,2]}}") + // Array additions. + let msgArray = [msg1, msg2, msg3] + XCTAssertEqual( + try SwiftProtoTesting_Message2.jsonString(from: msgArray, options: asStrings), + "[" + "{\"optionalInt64\":\"1656338459803\"}" + "," + + "{\"repeatedInt64\":[\"1656338459802\",\"1656338459803\"]}" + "," + + "{\"mapInt64Int64\":{\"1656338459803\":\"1656338459802\"}}" + "]" + ) + XCTAssertEqual( + try SwiftProtoTesting_Message2.jsonString(from: msgArray, options: asNumbers), + "[" + "{\"optionalInt64\":1656338459803}" + "," + "{\"repeatedInt64\":[1656338459802,1656338459803]}" + "," + + "{\"mapInt64Int64\":{\"1656338459803\":1656338459802}}" + "]" + ) - let msg6 = ProtobufUnittest_Message3.with { - $0.optionalMessage.mapInt32Enum[42] = .baz - } - XCTAssertEqual(try msg6.jsonString(options: asStrings), - "{\"optionalMessage\":{\"mapInt32Enum\":{\"42\":\"BAZ\"}}}") - XCTAssertEqual(try msg6.jsonString(options: asInts), - "{\"optionalMessage\":{\"mapInt32Enum\":{\"42\":2}}}") - - // The array additions - - let msgArray = [msg1, msg2, msg3] - XCTAssertEqual(try ProtobufUnittest_Message3.jsonString(from: msgArray, options: asStrings), - "[" + - "{\"optionalEnum\":\"BAR\"}" + "," + - "{\"repeatedEnum\":[\"BAR\",\"BAZ\"]}" + "," + - "{\"mapInt32Enum\":{\"42\":\"BAZ\"}}" + - "]") - XCTAssertEqual(try ProtobufUnittest_Message3.jsonString(from: msgArray, options: asInts), - "[" + - "{\"optionalEnum\":1}" + "," + - "{\"repeatedEnum\":[1,2]}" + "," + - "{\"mapInt32Enum\":{\"42\":2}}" + - "]") - - // Any - - Google_Protobuf_Any.register(messageType: ProtobufUnittest_TestAllTypes.self) - let content = ProtobufUnittest_TestAllTypes.with { - $0.optionalNestedEnum = .neg + // Any. + Google_Protobuf_Any.register(messageType: SwiftProtoTesting_TestAllTypes.self) + let content = SwiftProtoTesting_TestAllTypes.with { + $0.optionalInt64 = 1_656_338_459_803 + } + let msg7 = try! Google_Protobuf_Any(message: content) + XCTAssertEqual( + try msg7.jsonString(options: asStrings), + "{\"@type\":\"type.googleapis.com/swift_proto_testing.TestAllTypes\",\"optionalInt64\":\"1656338459803\"}" + ) + XCTAssertEqual( + try msg7.jsonString(options: asNumbers), + "{\"@type\":\"type.googleapis.com/swift_proto_testing.TestAllTypes\",\"optionalInt64\":1656338459803}" + ) + + // UInt64 - Toplevel fields. + let msg8 = SwiftProtoTesting_Message2.with { + $0.optionalUint64 = 1_656_338_459_803 + } + XCTAssertEqual(try msg8.jsonString(options: asStrings), "{\"optionalUint64\":\"1656338459803\"}") + XCTAssertEqual(try msg8.jsonString(options: asNumbers), "{\"optionalUint64\":1656338459803}") + + let msg9 = SwiftProtoTesting_Message2.with { + $0.repeatedUint64 = [1_656_338_459_802, 1_656_338_459_803] + } + XCTAssertEqual( + try msg9.jsonString(options: asStrings), + "{\"repeatedUint64\":[\"1656338459802\",\"1656338459803\"]}" + ) + XCTAssertEqual(try msg9.jsonString(options: asNumbers), "{\"repeatedUint64\":[1656338459802,1656338459803]}") + + let msg10 = SwiftProtoTesting_Message2.with { + $0.mapUint64Uint64[1_656_338_459_803] = 1_656_338_459_802 + } + XCTAssertEqual( + try msg10.jsonString(options: asStrings), + "{\"mapUint64Uint64\":{\"1656338459803\":\"1656338459802\"}}" + ) + XCTAssertEqual( + try msg10.jsonString(options: asNumbers), + "{\"mapUint64Uint64\":{\"1656338459803\":1656338459802}}" + ) } - let msg7 = try! Google_Protobuf_Any(message: content) - XCTAssertEqual(try msg7.jsonString(options: asStrings), - "{\"@type\":\"type.googleapis.com/protobuf_unittest.TestAllTypes\",\"optionalNestedEnum\":\"NEG\"}") - XCTAssertEqual(try msg7.jsonString(options: asInts), - "{\"@type\":\"type.googleapis.com/protobuf_unittest.TestAllTypes\",\"optionalNestedEnum\":-1}") - } + func testAlwaysPrintEnumsAsInts() { + // Use explicit options (the default is false), just to be pedantic. + var asStrings = JSONEncodingOptions() + asStrings.alwaysPrintEnumsAsInts = false + var asInts = JSONEncodingOptions() + asInts.alwaysPrintEnumsAsInts = true - func testPreserveProtoFieldNames() { - var jsonNames = JSONEncodingOptions() - jsonNames.preserveProtoFieldNames = false - var protoNames = JSONEncodingOptions() - protoNames.preserveProtoFieldNames = true + // Toplevel fields - // Toplevel fields + let msg1 = SwiftProtoTesting_Message3.with { + $0.optionalEnum = .bar + } + XCTAssertEqual(try msg1.jsonString(options: asStrings), "{\"optionalEnum\":\"BAR\"}") + XCTAssertEqual(try msg1.jsonString(options: asInts), "{\"optionalEnum\":1}") - let msg1 = ProtobufUnittest_Message3.with { - $0.optionalEnum = .bar - } - XCTAssertEqual(try msg1.jsonString(options: jsonNames), "{\"optionalEnum\":\"BAR\"}") - XCTAssertEqual(try msg1.jsonString(options: protoNames), "{\"optional_enum\":\"BAR\"}") + let msg2 = SwiftProtoTesting_Message3.with { + $0.repeatedEnum = [.bar, .baz] + } + XCTAssertEqual(try msg2.jsonString(options: asStrings), "{\"repeatedEnum\":[\"BAR\",\"BAZ\"]}") + XCTAssertEqual(try msg2.jsonString(options: asInts), "{\"repeatedEnum\":[1,2]}") - let msg2 = ProtobufUnittest_Message3.with { - $0.repeatedEnum = [.bar, .baz] - } - XCTAssertEqual(try msg2.jsonString(options: jsonNames), "{\"repeatedEnum\":[\"BAR\",\"BAZ\"]}") - XCTAssertEqual(try msg2.jsonString(options: protoNames), "{\"repeated_enum\":[\"BAR\",\"BAZ\"]}") + let msg3 = SwiftProtoTesting_Message3.with { + $0.mapInt32Enum[42] = .baz + } + XCTAssertEqual(try msg3.jsonString(options: asStrings), "{\"mapInt32Enum\":{\"42\":\"BAZ\"}}") + XCTAssertEqual(try msg3.jsonString(options: asInts), "{\"mapInt32Enum\":{\"42\":2}}") - let msg3 = ProtobufUnittest_Message3.with { - $0.mapInt32Enum[42] = .baz - } - XCTAssertEqual(try msg3.jsonString(options: jsonNames), "{\"mapInt32Enum\":{\"42\":\"BAZ\"}}") - XCTAssertEqual(try msg3.jsonString(options: protoNames), "{\"map_int32_enum\":{\"42\":\"BAZ\"}}") + // The enum field nested down a level. - // The enum field nested down a level. + let msg4 = SwiftProtoTesting_Message3.with { + $0.optionalMessage.optionalEnum = .bar + } + XCTAssertEqual( + try msg4.jsonString(options: asStrings), + "{\"optionalMessage\":{\"optionalEnum\":\"BAR\"}}" + ) + XCTAssertEqual( + try msg4.jsonString(options: asInts), + "{\"optionalMessage\":{\"optionalEnum\":1}}" + ) - let msg4 = ProtobufUnittest_Message3.with { - $0.optionalMessage.optionalEnum = .bar - } - XCTAssertEqual(try msg4.jsonString(options: jsonNames), - "{\"optionalMessage\":{\"optionalEnum\":\"BAR\"}}") - XCTAssertEqual(try msg4.jsonString(options: protoNames), - "{\"optional_message\":{\"optional_enum\":\"BAR\"}}") + let msg5 = SwiftProtoTesting_Message3.with { + $0.optionalMessage.repeatedEnum = [.bar, .baz] + } + XCTAssertEqual( + try msg5.jsonString(options: asStrings), + "{\"optionalMessage\":{\"repeatedEnum\":[\"BAR\",\"BAZ\"]}}" + ) + XCTAssertEqual( + try msg5.jsonString(options: asInts), + "{\"optionalMessage\":{\"repeatedEnum\":[1,2]}}" + ) + + let msg6 = SwiftProtoTesting_Message3.with { + $0.optionalMessage.mapInt32Enum[42] = .baz + } + XCTAssertEqual( + try msg6.jsonString(options: asStrings), + "{\"optionalMessage\":{\"mapInt32Enum\":{\"42\":\"BAZ\"}}}" + ) + XCTAssertEqual( + try msg6.jsonString(options: asInts), + "{\"optionalMessage\":{\"mapInt32Enum\":{\"42\":2}}}" + ) + + // The array additions + + let msgArray = [msg1, msg2, msg3] + XCTAssertEqual( + try SwiftProtoTesting_Message3.jsonString(from: msgArray, options: asStrings), + "[" + "{\"optionalEnum\":\"BAR\"}" + "," + "{\"repeatedEnum\":[\"BAR\",\"BAZ\"]}" + "," + + "{\"mapInt32Enum\":{\"42\":\"BAZ\"}}" + "]" + ) + XCTAssertEqual( + try SwiftProtoTesting_Message3.jsonString(from: msgArray, options: asInts), + "[" + "{\"optionalEnum\":1}" + "," + "{\"repeatedEnum\":[1,2]}" + "," + "{\"mapInt32Enum\":{\"42\":2}}" + + "]" + ) + + // Any + + Google_Protobuf_Any.register(messageType: SwiftProtoTesting_TestAllTypes.self) + let content = SwiftProtoTesting_TestAllTypes.with { + $0.optionalNestedEnum = .neg + } + let msg7 = try! Google_Protobuf_Any(message: content) + XCTAssertEqual( + try msg7.jsonString(options: asStrings), + "{\"@type\":\"type.googleapis.com/swift_proto_testing.TestAllTypes\",\"optionalNestedEnum\":\"NEG\"}" + ) + XCTAssertEqual( + try msg7.jsonString(options: asInts), + "{\"@type\":\"type.googleapis.com/swift_proto_testing.TestAllTypes\",\"optionalNestedEnum\":-1}" + ) - let msg5 = ProtobufUnittest_Message3.with { - $0.optionalMessage.repeatedEnum = [.bar, .baz] } - XCTAssertEqual(try msg5.jsonString(options: jsonNames), - "{\"optionalMessage\":{\"repeatedEnum\":[\"BAR\",\"BAZ\"]}}") - XCTAssertEqual(try msg5.jsonString(options: protoNames), - "{\"optional_message\":{\"repeated_enum\":[\"BAR\",\"BAZ\"]}}") - let msg6 = ProtobufUnittest_Message3.with { - $0.optionalMessage.mapInt32Enum[42] = .baz + func testPreserveProtoFieldNames() { + var jsonNames = JSONEncodingOptions() + jsonNames.preserveProtoFieldNames = false + var protoNames = JSONEncodingOptions() + protoNames.preserveProtoFieldNames = true + + // Toplevel fields + + let msg1 = SwiftProtoTesting_Message3.with { + $0.optionalEnum = .bar + } + XCTAssertEqual(try msg1.jsonString(options: jsonNames), "{\"optionalEnum\":\"BAR\"}") + XCTAssertEqual(try msg1.jsonString(options: protoNames), "{\"optional_enum\":\"BAR\"}") + + let msg2 = SwiftProtoTesting_Message3.with { + $0.repeatedEnum = [.bar, .baz] + } + XCTAssertEqual(try msg2.jsonString(options: jsonNames), "{\"repeatedEnum\":[\"BAR\",\"BAZ\"]}") + XCTAssertEqual(try msg2.jsonString(options: protoNames), "{\"repeated_enum\":[\"BAR\",\"BAZ\"]}") + + let msg3 = SwiftProtoTesting_Message3.with { + $0.mapInt32Enum[42] = .baz + } + XCTAssertEqual(try msg3.jsonString(options: jsonNames), "{\"mapInt32Enum\":{\"42\":\"BAZ\"}}") + XCTAssertEqual(try msg3.jsonString(options: protoNames), "{\"map_int32_enum\":{\"42\":\"BAZ\"}}") + + // The enum field nested down a level. + + let msg4 = SwiftProtoTesting_Message3.with { + $0.optionalMessage.optionalEnum = .bar + } + XCTAssertEqual( + try msg4.jsonString(options: jsonNames), + "{\"optionalMessage\":{\"optionalEnum\":\"BAR\"}}" + ) + XCTAssertEqual( + try msg4.jsonString(options: protoNames), + "{\"optional_message\":{\"optional_enum\":\"BAR\"}}" + ) + + let msg5 = SwiftProtoTesting_Message3.with { + $0.optionalMessage.repeatedEnum = [.bar, .baz] + } + XCTAssertEqual( + try msg5.jsonString(options: jsonNames), + "{\"optionalMessage\":{\"repeatedEnum\":[\"BAR\",\"BAZ\"]}}" + ) + XCTAssertEqual( + try msg5.jsonString(options: protoNames), + "{\"optional_message\":{\"repeated_enum\":[\"BAR\",\"BAZ\"]}}" + ) + + let msg6 = SwiftProtoTesting_Message3.with { + $0.optionalMessage.mapInt32Enum[42] = .baz + } + XCTAssertEqual( + try msg6.jsonString(options: jsonNames), + "{\"optionalMessage\":{\"mapInt32Enum\":{\"42\":\"BAZ\"}}}" + ) + XCTAssertEqual( + try msg6.jsonString(options: protoNames), + "{\"optional_message\":{\"map_int32_enum\":{\"42\":\"BAZ\"}}}" + ) + + // The array additions + + let msgArray = [msg1, msg2, msg3] + XCTAssertEqual( + try SwiftProtoTesting_Message3.jsonString(from: msgArray, options: jsonNames), + "[" + "{\"optionalEnum\":\"BAR\"}" + "," + "{\"repeatedEnum\":[\"BAR\",\"BAZ\"]}" + "," + + "{\"mapInt32Enum\":{\"42\":\"BAZ\"}}" + "]" + ) + XCTAssertEqual( + try SwiftProtoTesting_Message3.jsonString(from: msgArray, options: protoNames), + "[" + "{\"optional_enum\":\"BAR\"}" + "," + "{\"repeated_enum\":[\"BAR\",\"BAZ\"]}" + "," + + "{\"map_int32_enum\":{\"42\":\"BAZ\"}}" + "]" + ) + + // Any + + Google_Protobuf_Any.register(messageType: SwiftProtoTesting_TestAllTypes.self) + let content = SwiftProtoTesting_TestAllTypes.with { + $0.optionalNestedEnum = .neg + } + let msg7 = try! Google_Protobuf_Any(message: content) + XCTAssertEqual( + try msg7.jsonString(options: jsonNames), + "{\"@type\":\"type.googleapis.com/swift_proto_testing.TestAllTypes\",\"optionalNestedEnum\":\"NEG\"}" + ) + XCTAssertEqual( + try msg7.jsonString(options: protoNames), + "{\"@type\":\"type.googleapis.com/swift_proto_testing.TestAllTypes\",\"optional_nested_enum\":\"NEG\"}" + ) } - XCTAssertEqual(try msg6.jsonString(options: jsonNames), - "{\"optionalMessage\":{\"mapInt32Enum\":{\"42\":\"BAZ\"}}}") - XCTAssertEqual(try msg6.jsonString(options: protoNames), - "{\"optional_message\":{\"map_int32_enum\":{\"42\":\"BAZ\"}}}") - - // The array additions - - let msgArray = [msg1, msg2, msg3] - XCTAssertEqual(try ProtobufUnittest_Message3.jsonString(from: msgArray, options: jsonNames), - "[" + - "{\"optionalEnum\":\"BAR\"}" + "," + - "{\"repeatedEnum\":[\"BAR\",\"BAZ\"]}" + "," + - "{\"mapInt32Enum\":{\"42\":\"BAZ\"}}" + - "]") - XCTAssertEqual(try ProtobufUnittest_Message3.jsonString(from: msgArray, options: protoNames), - "[" + - "{\"optional_enum\":\"BAR\"}" + "," + - "{\"repeated_enum\":[\"BAR\",\"BAZ\"]}" + "," + - "{\"map_int32_enum\":{\"42\":\"BAZ\"}}" + - "]") - - // Any - - Google_Protobuf_Any.register(messageType: ProtobufUnittest_TestAllTypes.self) - let content = ProtobufUnittest_TestAllTypes.with { - $0.optionalNestedEnum = .neg + + func testUseDeterministicOrdering() { + var options = JSONEncodingOptions() + options.useDeterministicOrdering = true + + let stringMap = SwiftProtoTesting_Message3.with { + $0.mapStringString = [ + "b": "B", + "a": "A", + "0": "0", + "UPPER": "v", + "x": "X", + ] + } + XCTAssertEqual( + try stringMap.jsonString(options: options), + "{\"mapStringString\":{\"0\":\"0\",\"UPPER\":\"v\",\"a\":\"A\",\"b\":\"B\",\"x\":\"X\"}}" + ) + + let messageMap = SwiftProtoTesting_Message3.with { + $0.mapInt32Message = [ + 5: .with { $0.optionalSint32 = 5 }, + 1: .with { $0.optionalSint32 = 1 }, + 3: .with { $0.optionalSint32 = 3 }, + ] + } + XCTAssertEqual( + try messageMap.jsonString(options: options), + "{\"mapInt32Message\":{\"1\":{\"optionalSint32\":1},\"3\":{\"optionalSint32\":3},\"5\":{\"optionalSint32\":5}}}" + ) + + let enumMap = SwiftProtoTesting_Message3.with { + $0.mapInt32Enum = [ + 5: .foo, + 3: .bar, + 0: .baz, + 1: .extra3, + ] + } + XCTAssertEqual( + try enumMap.jsonString(options: options), + "{\"mapInt32Enum\":{\"0\":\"BAZ\",\"1\":\"EXTRA_3\",\"3\":\"BAR\",\"5\":\"FOO\"}}" + ) } - let msg7 = try! Google_Protobuf_Any(message: content) - XCTAssertEqual(try msg7.jsonString(options: jsonNames), - "{\"@type\":\"type.googleapis.com/protobuf_unittest.TestAllTypes\",\"optionalNestedEnum\":\"NEG\"}") - XCTAssertEqual(try msg7.jsonString(options: protoNames), - "{\"@type\":\"type.googleapis.com/protobuf_unittest.TestAllTypes\",\"optional_nested_enum\":\"NEG\"}") - } } diff --git a/Tests/SwiftProtobufTests/Test_JSON_Array.swift b/Tests/SwiftProtobufTests/Test_JSON_Array.swift index 1b00b6d0f..4a1f0ff54 100644 --- a/Tests/SwiftProtobufTests/Test_JSON_Array.swift +++ b/Tests/SwiftProtobufTests/Test_JSON_Array.swift @@ -15,11 +15,11 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_JSON_Array: XCTestCase, PBTestHelpers { - typealias MessageTestType = Proto3Unittest_TestAllTypes +final class Test_JSON_Array: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_Proto3_TestAllTypes private func configureTwoObjects(_ o: inout [MessageTestType]) { var o1 = MessageTestType() @@ -41,16 +41,16 @@ class Test_JSON_Array: XCTestCase, PBTestHelpers { var nested = MessageTestType.NestedMessage() nested.bb = 7 o1.optionalNestedMessage = nested - var foreign = Proto3Unittest_ForeignMessage() + var foreign = SwiftProtoTesting_Proto3_ForeignMessage() foreign.c = 88 o1.optionalForeignMessage = foreign - var importMessage = ProtobufUnittestImport_ImportMessage() + var importMessage = SwiftProtoTesting_Import_ImportMessage() importMessage.d = -9 o1.optionalImportMessage = importMessage o1.optionalNestedEnum = .baz o1.optionalForeignEnum = .foreignBaz -// o1.optionalImportEnum = .importBaz - var publicImportMessage = ProtobufUnittestImport_PublicImportMessage() + // o1.optionalImportEnum = .importBaz + var publicImportMessage = SwiftProtoTesting_Import_PublicImportMessage() publicImportMessage.e = -999999 o1.optionalPublicImportMessage = publicImportMessage o1.repeatedInt32 = [1, 2] @@ -88,65 +88,68 @@ class Test_JSON_Array: XCTestCase, PBTestHelpers { } func testTwoObjectsWithMultipleFields() { - let expected: String = ("[{" - + "\"optionalInt32\":1," - + "\"optionalInt64\":\"2\"," - + "\"optionalUint32\":3," - + "\"optionalUint64\":\"4\"," - + "\"optionalSint32\":5," - + "\"optionalSint64\":\"6\"," - + "\"optionalFixed32\":7," - + "\"optionalFixed64\":\"8\"," - + "\"optionalSfixed32\":9," - + "\"optionalSfixed64\":\"10\"," - + "\"optionalFloat\":11.0," - + "\"optionalDouble\":12.0," - + "\"optionalBool\":true," - + "\"optionalString\":\"abc\"," - + "\"optionalBytes\":\"QUI=\"," - + "\"optionalNestedMessage\":{\"bb\":7}," - + "\"optionalForeignMessage\":{\"c\":88}," - + "\"optionalImportMessage\":{\"d\":-9}," - + "\"optionalNestedEnum\":\"BAZ\"," - + "\"optionalForeignEnum\":\"FOREIGN_BAZ\"," -// + "\"optionalImportEnum\":\"IMPORT_BAZ\"," - + "\"optionalPublicImportMessage\":{\"e\":-999999}," - + "\"repeatedInt32\":[1,2]," - + "\"repeatedInt64\":[\"3\",\"4\"]," - + "\"repeatedUint32\":[5,6]," - + "\"repeatedUint64\":[\"7\",\"8\"]," - + "\"repeatedSint32\":[9,10]," - + "\"repeatedSint64\":[\"11\",\"12\"]," - + "\"repeatedFixed32\":[13,14]," - + "\"repeatedFixed64\":[\"15\",\"16\"]," - + "\"repeatedSfixed32\":[17,18]," - + "\"repeatedSfixed64\":[\"19\",\"20\"]," - + "\"repeatedFloat\":[21.0,22.0]," - + "\"repeatedDouble\":[23.0,24.0]," - + "\"repeatedBool\":[true,false]," - + "\"repeatedString\":[\"abc\",\"def\"]," - + "\"repeatedBytes\":[\"\",\"QUI=\"]," - + "\"repeatedNestedMessage\":[{\"bb\":7},{\"bb\":-7}]," - + "\"repeatedForeignMessage\":[{\"c\":88},{\"c\":-88}]," - + "\"repeatedNestedEnum\":[\"BAR\",\"BAZ\"]," - + "\"repeatedForeignEnum\":[\"FOREIGN_BAR\",\"FOREIGN_BAZ\"]," - + "\"oneofUint32\":99" - + "},{}]") + let expected: String = + ("[{" + + "\"optionalInt32\":1," + + "\"optionalInt64\":\"2\"," + + "\"optionalUint32\":3," + + "\"optionalUint64\":\"4\"," + + "\"optionalSint32\":5," + + "\"optionalSint64\":\"6\"," + + "\"optionalFixed32\":7," + + "\"optionalFixed64\":\"8\"," + + "\"optionalSfixed32\":9," + + "\"optionalSfixed64\":\"10\"," + + "\"optionalFloat\":11.0," + + "\"optionalDouble\":12.0," + + "\"optionalBool\":true," + + "\"optionalString\":\"abc\"," + + "\"optionalBytes\":\"QUI=\"," + + "\"optionalNestedMessage\":{\"bb\":7}," + + "\"optionalForeignMessage\":{\"c\":88}," + + "\"optionalImportMessage\":{\"d\":-9}," + + "\"optionalNestedEnum\":\"BAZ\"," + + "\"optionalForeignEnum\":\"FOREIGN_BAZ\"," + // + "\"optionalImportEnum\":\"IMPORT_BAZ\"," + + "\"optionalPublicImportMessage\":{\"e\":-999999}," + + "\"repeatedInt32\":[1,2]," + + "\"repeatedInt64\":[\"3\",\"4\"]," + + "\"repeatedUint32\":[5,6]," + + "\"repeatedUint64\":[\"7\",\"8\"]," + + "\"repeatedSint32\":[9,10]," + + "\"repeatedSint64\":[\"11\",\"12\"]," + + "\"repeatedFixed32\":[13,14]," + + "\"repeatedFixed64\":[\"15\",\"16\"]," + + "\"repeatedSfixed32\":[17,18]," + + "\"repeatedSfixed64\":[\"19\",\"20\"]," + + "\"repeatedFloat\":[21.0,22.0]," + + "\"repeatedDouble\":[23.0,24.0]," + + "\"repeatedBool\":[true,false]," + + "\"repeatedString\":[\"abc\",\"def\"]," + + "\"repeatedBytes\":[\"\",\"QUI=\"]," + + "\"repeatedNestedMessage\":[{\"bb\":7},{\"bb\":-7}]," + + "\"repeatedForeignMessage\":[{\"c\":88},{\"c\":-88}]," + + "\"repeatedNestedEnum\":[\"BAR\",\"BAZ\"]," + + "\"repeatedForeignEnum\":[\"FOREIGN_BAR\",\"FOREIGN_BAZ\"]," + + "\"oneofUint32\":99" + + "},{}]") assertJSONArrayEncode(expected, configure: configureTwoObjects) } func testRepeatedNestedMessage() { - assertJSONArrayEncode("[{\"repeatedNestedMessage\":[{\"bb\":1}]},{\"repeatedNestedMessage\":[{\"bb\":1},{\"bb\":2}]}]") {(o: inout [MessageTestType]) in + assertJSONArrayEncode( + "[{\"repeatedNestedMessage\":[{\"bb\":1}]},{\"repeatedNestedMessage\":[{\"bb\":1},{\"bb\":2}]}]" + ) { (o: inout [MessageTestType]) in var o1 = MessageTestType() - var sub1 = Proto3Unittest_TestAllTypes.NestedMessage() + var sub1 = SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage() sub1.bb = 1 o1.repeatedNestedMessage = [sub1] o.append(o1) var o2 = MessageTestType() - var sub2 = Proto3Unittest_TestAllTypes.NestedMessage() + var sub2 = SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage() sub2.bb = 1 - var sub3 = Proto3Unittest_TestAllTypes.NestedMessage() + var sub3 = SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage() sub3.bb = 2 o2.repeatedNestedMessage = [sub2, sub3] o.append(o2) diff --git a/Tests/SwiftProtobufTests/Test_JSON_Conformance.swift b/Tests/SwiftProtobufTests/Test_JSON_Conformance.swift index de9505392..a35e03e0d 100644 --- a/Tests/SwiftProtobufTests/Test_JSON_Conformance.swift +++ b/Tests/SwiftProtobufTests/Test_JSON_Conformance.swift @@ -14,17 +14,23 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_JSON_Conformance: XCTestCase { - func assertEmptyDecode(_ json: String, file: XCTestFileArgType = #file, line: UInt = #line) -> () { +final class Test_JSON_Conformance: XCTestCase { + func assertEmptyDecode(_ json: String, file: XCTestFileArgType = #file, line: UInt = #line) { do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: json) - XCTAssertEqual(decoded, ProtobufTestMessages_Proto3_TestAllTypesProto3(), "Decoded object should be equal to empty object: \(decoded)", file: file, line: line) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: json) + XCTAssertEqual( + decoded, + SwiftProtoTesting_Test3_TestAllTypesProto3(), + "Decoded object should be equal to empty object: \(decoded)", + file: file, + line: line + ) let recoded = try decoded.jsonString() XCTAssertEqual(recoded, "{}", file: file, line: line) - let protobuf = try decoded.serializedBytes() + let protobuf: [UInt8] = try decoded.serializedBytes() XCTAssertEqual(protobuf, [], file: file, line: line) } catch let e { XCTFail("Decode failed with error \(e)", file: file, line: line) @@ -87,10 +93,10 @@ class Test_JSON_Conformance: XCTestCase { func testNullSupport_Value() throws { // BUT: Value fields treat null as a regular value let valueNull = "{\"optionalValue\": null}" - let decoded: ProtobufTestMessages_Proto3_TestAllTypesProto3 + let decoded: SwiftProtoTesting_Test3_TestAllTypesProto3 do { - decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: valueNull) - XCTAssertNotEqual(decoded, ProtobufTestMessages_Proto3_TestAllTypesProto3()) + decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: valueNull) + XCTAssertNotEqual(decoded, SwiftProtoTesting_Test3_TestAllTypesProto3()) } catch let e { XCTFail("Decode failed with error \(e): \(valueNull)") return @@ -104,7 +110,7 @@ class Test_JSON_Conformance: XCTestCase { } do { - let protobuf = try decoded.serializedBytes() + let protobuf: [UInt8] = try decoded.serializedBytes() XCTAssertEqual(protobuf, [146, 19, 2, 8, 0]) } catch let e { XCTFail("Protobuf encode failed with error: \(e)") @@ -114,12 +120,12 @@ class Test_JSON_Conformance: XCTestCase { func testNullSupport_optionalNullValue() throws { // BUT: NullValue fields treat null as a regular value let valueNull = "{\"optionalNullValue\": null}" - let decoded: ProtobufTestMessages_Proto3_TestAllTypesProto3 + let decoded: SwiftProtoTesting_Test3_TestAllTypesProto3 do { - decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: valueNull) + decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: valueNull) // Since NullValue is a single-value enum, the decoded // value is already the default... - XCTAssertEqual(decoded, ProtobufTestMessages_Proto3_TestAllTypesProto3()) + XCTAssertEqual(decoded, SwiftProtoTesting_Test3_TestAllTypesProto3()) } catch let e { XCTFail("Decode failed with error \(e): \(valueNull)") return @@ -134,7 +140,7 @@ class Test_JSON_Conformance: XCTestCase { } do { - let protobuf = try decoded.serializedBytes() + let protobuf: [UInt8] = try decoded.serializedBytes() XCTAssertEqual(protobuf, []) } catch let e { XCTFail("Protobuf encode failed with error: \(e)") @@ -145,10 +151,10 @@ class Test_JSON_Conformance: XCTestCase { // In a oneof, parsing a null value changes the oneof, // so there are observable effects... let valueNull = "{\"oneofNullValue\": null}" - let decoded: ProtobufTestMessages_Proto3_TestAllTypesProto3 + let decoded: SwiftProtoTesting_Test3_TestAllTypesProto3 do { - decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: valueNull) - XCTAssertNotEqual(decoded, ProtobufTestMessages_Proto3_TestAllTypesProto3()) + decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: valueNull) + XCTAssertNotEqual(decoded, SwiftProtoTesting_Test3_TestAllTypesProto3()) XCTAssertNotNil(decoded.oneofNullValue) } catch let e { XCTFail("Decode failed with error \(e): \(valueNull)") @@ -163,7 +169,7 @@ class Test_JSON_Conformance: XCTestCase { } do { - let protobuf = try decoded.serializedBytes() + let protobuf: [UInt8] = try decoded.serializedBytes() XCTAssertEqual(protobuf, [192, 7, 0]) } catch let e { XCTFail("Protobuf encode failed with error: \(e)") @@ -174,10 +180,10 @@ class Test_JSON_Conformance: XCTestCase { // As above, except verify that we decode the enum // value name like any other enum. let valueNull = "{\"oneofNullValue\": \"NULL_VALUE\"}" - let decoded: ProtobufTestMessages_Proto3_TestAllTypesProto3 + let decoded: SwiftProtoTesting_Test3_TestAllTypesProto3 do { - decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: valueNull) - XCTAssertNotEqual(decoded, ProtobufTestMessages_Proto3_TestAllTypesProto3()) + decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: valueNull) + XCTAssertNotEqual(decoded, SwiftProtoTesting_Test3_TestAllTypesProto3()) XCTAssertNotNil(decoded.oneofNullValue) } catch let e { XCTFail("Decode failed with error \(e): \(valueNull)") @@ -189,10 +195,10 @@ class Test_JSON_Conformance: XCTestCase { // As above, except verify that we decode the enum // numeric value like any other enum. let valueNull = "{\"oneofNullValue\": 0}" - let decoded: ProtobufTestMessages_Proto3_TestAllTypesProto3 + let decoded: SwiftProtoTesting_Test3_TestAllTypesProto3 do { - decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: valueNull) - XCTAssertNotEqual(decoded, ProtobufTestMessages_Proto3_TestAllTypesProto3()) + decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: valueNull) + XCTAssertNotEqual(decoded, SwiftProtoTesting_Test3_TestAllTypesProto3()) XCTAssertNotNil(decoded.oneofNullValue) } catch let e { XCTFail("Decode failed with error \(e): \(valueNull)") @@ -202,10 +208,10 @@ class Test_JSON_Conformance: XCTestCase { func testNullSupport_repeatedNullValue() throws { let valueNull = "{\"repeatedNullValue\": [0, \"NULL_VALUE\", null]}" - let decoded: ProtobufUnittest_SwiftJSONTest + let decoded: SwiftProtoTesting_SwiftJSONTest do { - decoded = try ProtobufUnittest_SwiftJSONTest(jsonString: valueNull) - XCTAssertNotEqual(decoded, ProtobufUnittest_SwiftJSONTest()) + decoded = try SwiftProtoTesting_SwiftJSONTest(jsonString: valueNull) + XCTAssertNotEqual(decoded, SwiftProtoTesting_SwiftJSONTest()) XCTAssertEqual(3, decoded.repeatedNullValue.count) } catch let e { XCTFail("Decode failed with error \(e): \(valueNull)") @@ -223,24 +229,27 @@ class Test_JSON_Conformance: XCTestCase { func testNullSupport_Repeated() throws { // Nulls within repeated lists are errors let json1 = "{\"repeatedBoolWrapper\":[true, null, false]}" - XCTAssertThrowsError(try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: json1)) + XCTAssertThrowsError(try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: json1)) let json2 = "{\"repeatedNestedMessage\":[{}, null]}" - XCTAssertThrowsError(try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: json2)) + XCTAssertThrowsError(try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: json2)) // Make sure the above is failing for the right reason: let json3 = "{\"repeatedNestedMessage\":[{}]}" - let _ = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: json3) + let _ = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: json3) let json4 = "{\"repeatedNestedMessage\":[null]}" - XCTAssertThrowsError(try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: json4)) + XCTAssertThrowsError(try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: json4)) } func testNullSupport_RepeatedValue() throws { // BUT: null is valid within repeated Value fields let repeatedValueWithNull = "{\"repeatedValue\": [1, null]}" - let decoded: ProtobufTestMessages_Proto3_TestAllTypesProto3 + let decoded: SwiftProtoTesting_Test3_TestAllTypesProto3 do { - decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: repeatedValueWithNull) - XCTAssertNotEqual(decoded, ProtobufTestMessages_Proto3_TestAllTypesProto3()) - XCTAssertEqual(decoded.repeatedValue, [Google_Protobuf_Value(numberValue:1), nil as Google_Protobuf_Value]) + decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: repeatedValueWithNull) + XCTAssertNotEqual(decoded, SwiftProtoTesting_Test3_TestAllTypesProto3()) + XCTAssertEqual( + decoded.repeatedValue, + [Google_Protobuf_Value(numberValue: 1), nil as Google_Protobuf_Value] + ) } catch { XCTFail("Decode failed with error \(error): \(repeatedValueWithNull)") return @@ -252,7 +261,7 @@ class Test_JSON_Conformance: XCTestCase { XCTFail("Re-encode failed with error: \(repeatedValueWithNull)") } do { - let protobuf = try decoded.serializedBytes() + let protobuf: [UInt8] = try decoded.serializedBytes() XCTAssertEqual(protobuf, [226, 19, 9, 17, 0, 0, 0, 0, 0, 0, 240, 63, 226, 19, 2, 8, 0]) } catch { XCTFail("Protobuf encoding failed with error: \(repeatedValueWithNull)") @@ -260,9 +269,10 @@ class Test_JSON_Conformance: XCTestCase { } func testNullConformance() { - let start = "{\n \"optionalBoolWrapper\": null,\n \"optionalInt32Wrapper\": null,\n \"optionalUint32Wrapper\": null,\n \"optionalInt64Wrapper\": null,\n \"optionalUint64Wrapper\": null,\n \"optionalFloatWrapper\": null,\n \"optionalDoubleWrapper\": null,\n \"optionalStringWrapper\": null,\n \"optionalBytesWrapper\": null,\n \"repeatedBoolWrapper\": null,\n \"repeatedInt32Wrapper\": null,\n \"repeatedUint32Wrapper\": null,\n \"repeatedInt64Wrapper\": null,\n \"repeatedUint64Wrapper\": null,\n \"repeatedFloatWrapper\": null,\n \"repeatedDoubleWrapper\": null,\n \"repeatedStringWrapper\": null,\n \"repeatedBytesWrapper\": null\n }" + let start = + "{\n \"optionalBoolWrapper\": null,\n \"optionalInt32Wrapper\": null,\n \"optionalUint32Wrapper\": null,\n \"optionalInt64Wrapper\": null,\n \"optionalUint64Wrapper\": null,\n \"optionalFloatWrapper\": null,\n \"optionalDoubleWrapper\": null,\n \"optionalStringWrapper\": null,\n \"optionalBytesWrapper\": null,\n \"repeatedBoolWrapper\": null,\n \"repeatedInt32Wrapper\": null,\n \"repeatedUint32Wrapper\": null,\n \"repeatedInt64Wrapper\": null,\n \"repeatedUint64Wrapper\": null,\n \"repeatedFloatWrapper\": null,\n \"repeatedDoubleWrapper\": null,\n \"repeatedStringWrapper\": null,\n \"repeatedBytesWrapper\": null\n }" do { - let t = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) + let t = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) XCTAssertEqual(try t.jsonString(), "{}") } catch { XCTFail() @@ -271,9 +281,9 @@ class Test_JSON_Conformance: XCTestCase { func testValueList() { let start = "{\"optionalValue\":[0.0,\"hello\"]}" - let t: ProtobufTestMessages_Proto3_TestAllTypesProto3 + let t: SwiftProtoTesting_Test3_TestAllTypesProto3 do { - t = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) + t = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) } catch { XCTFail("Failed to decode: \(start)") return @@ -281,19 +291,45 @@ class Test_JSON_Conformance: XCTestCase { XCTAssertEqual(try t.jsonString(), start) } + func testValue_DoubleNonFinite() { + XCTAssertThrowsError(try Google_Protobuf_Value(numberValue: .nan).jsonString()) { + XCTAssertEqual( + $0 as? JSONEncodingError, + JSONEncodingError.valueNumberNotFinite, + "Wrong error? - \($0)" + ) + } + + XCTAssertThrowsError(try Google_Protobuf_Value(numberValue: .infinity).jsonString()) { + XCTAssertEqual( + $0 as? JSONEncodingError, + JSONEncodingError.valueNumberNotFinite, + "Wrong error? - \($0)" + ) + } + + XCTAssertThrowsError(try Google_Protobuf_Value(numberValue: -.infinity).jsonString()) { + XCTAssertEqual( + $0 as? JSONEncodingError, + JSONEncodingError.valueNumberNotFinite, + "Wrong error? - \($0)" + ) + } + } func testNestedAny() { - let start = ("{\n" - + " \"optionalAny\": {\n" - + " \"@type\": \"type.googleapis.com/google.protobuf.Any\",\n" - + " \"value\": {\n" - + " \"@type\": \"type.googleapis.com/protobuf_test_messages.proto3.TestAllTypes\",\n" - + " \"optionalInt32\": 12345\n" - + " }\n" - + " }\n" - + " }") + let start = + ("{\n" + + " \"optionalAny\": {\n" + + " \"@type\": \"type.googleapis.com/google.protobuf.Any\",\n" + + " \"value\": {\n" + + " \"@type\": \"type.googleapis.com/swift_proto_testing.test3.TestAllTypes\",\n" + + " \"optionalInt32\": 12345\n" + + " }\n" + + " }\n" + + " }") do { - _ = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: start) + _ = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: start) } catch { XCTFail("Failed to decode: \(start)") return diff --git a/Tests/SwiftProtobufTests/Test_JSON_Extensions.swift b/Tests/SwiftProtobufTests/Test_JSON_Extensions.swift index 6e217155c..989e1029a 100644 --- a/Tests/SwiftProtobufTests/Test_JSON_Extensions.swift +++ b/Tests/SwiftProtobufTests/Test_JSON_Extensions.swift @@ -13,138 +13,161 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_JSON_Extensions: XCTestCase, PBTestHelpers { - typealias MessageTestType = ProtobufUnittest_TestAllExtensions +final class Test_JSON_Extensions: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_TestAllExtensions var extensions = SwiftProtobuf.SimpleExtensionMap() override func setUp() { // Start with all the extensions from the unittest.proto file: - extensions = ProtobufUnittest_Unittest_Extensions + extensions = SwiftProtoTesting_Unittest_Extensions // Append another file's worth: - extensions.formUnion(ProtobufUnittest_UnittestCustomOptions_Extensions) + extensions.formUnion(SwiftProtoTesting_Extend_UnittestSwiftExtension_Extensions) // Append an array of extensions - extensions.insert(contentsOf: - [ - Extensions_RepeatedExtensionGroup, - Extensions_ExtensionGroup - ] + extensions.insert(contentsOf: [ + SwiftProtoTesting_Extensions_RepeatedExtensionGroup, + SwiftProtoTesting_Extensions_ExtensionGroup, + ] ) } func test_optionalInt32Extension() throws { - assertJSONEncode("{\"[protobuf_unittest.optional_int32_extension]\":17}", - extensions: extensions) { + assertJSONEncode( + "{\"[swift_proto_testing.optional_int32_extension]\":17}", + extensions: extensions + ) { (o: inout MessageTestType) in - o.ProtobufUnittest_optionalInt32Extension = 17 + o.SwiftProtoTesting_optionalInt32Extension = 17 } - assertJSONDecodeFails("{\"[protobuf_unittest.UNKNOWN_EXTENSION]\":17}", - extensions: extensions) - assertJSONDecodeFails("{\"[UNKNOWN_PACKAGE.optional_int32_extension]\":17}", - extensions: extensions) - assertJSONDecodeFails("{\"[protobuf_unittest.optional_int32_extension\":17}", - extensions: extensions) - assertJSONDecodeFails("{\"protobuf_unittest.optional_int32_extension]\":17}", - extensions: extensions) - assertJSONDecodeFails("{\"[optional_int32_extension\":17}", - extensions: extensions) - assertJSONDecodeFails("{\"protobuf_unittest.optional_int32_extension\":17}", - extensions: extensions) - - assertJSONArrayEncode("[{\"[protobuf_unittest.optional_int32_extension]\":17}]", - extensions: extensions) { + assertJSONDecodeFails( + "{\"[swift_proto_testing.UNKNOWN_EXTENSION]\":17}", + extensions: extensions + ) + assertJSONDecodeFails( + "{\"[UNKNOWN_PACKAGE.optional_int32_extension]\":17}", + extensions: extensions + ) + assertJSONDecodeFails( + "{\"[swift_proto_testing.optional_int32_extension\":17}", + extensions: extensions + ) + assertJSONDecodeFails( + "{\"swift_proto_testing.optional_int32_extension]\":17}", + extensions: extensions + ) + assertJSONDecodeFails( + "{\"[optional_int32_extension\":17}", + extensions: extensions + ) + assertJSONDecodeFails( + "{\"swift_proto_testing.optional_int32_extension\":17}", + extensions: extensions + ) + + assertJSONArrayEncode( + "[{\"[swift_proto_testing.optional_int32_extension]\":17}]", + extensions: extensions + ) { (o: inout [MessageTestType]) in var o1 = MessageTestType() - o1.ProtobufUnittest_optionalInt32Extension = 17 + o1.SwiftProtoTesting_optionalInt32Extension = 17 o.append(o1) } } func test_optionalMessageExtension() throws { - assertJSONEncode("{\"[protobuf_unittest.optional_nested_message_extension]\":{\"bb\":12}}", - extensions: extensions) - { + assertJSONEncode( + "{\"[swift_proto_testing.optional_nested_message_extension]\":{\"bb\":12}}", + extensions: extensions + ) { (o: inout MessageTestType) in - o.ProtobufUnittest_optionalNestedMessageExtension = - ProtobufUnittest_TestAllTypes.NestedMessage.with { + o.SwiftProtoTesting_optionalNestedMessageExtension = + SwiftProtoTesting_TestAllTypes.NestedMessage.with { $0.bb = 12 } } } func test_repeatedInt32Extension() throws { - assertJSONEncode("{\"[protobuf_unittest.repeated_int32_extension]\":[1,2,3,17]}", - extensions: extensions) { + assertJSONEncode( + "{\"[swift_proto_testing.repeated_int32_extension]\":[1,2,3,17]}", + extensions: extensions + ) { (o: inout MessageTestType) in - o.ProtobufUnittest_repeatedInt32Extension = [1,2,3,17] + o.SwiftProtoTesting_repeatedInt32Extension = [1, 2, 3, 17] } } func test_repeatedMessageExtension() throws { - assertJSONEncode("{\"[protobuf_unittest.repeated_nested_message_extension]\":[{\"bb\":12},{}]}", - extensions: extensions) - { + assertJSONEncode( + "{\"[swift_proto_testing.repeated_nested_message_extension]\":[{\"bb\":12},{}]}", + extensions: extensions + ) { (o: inout MessageTestType) in - o.ProtobufUnittest_repeatedNestedMessageExtension = + o.SwiftProtoTesting_repeatedNestedMessageExtension = [ - ProtobufUnittest_TestAllTypes.NestedMessage.with { $0.bb = 12 }, - ProtobufUnittest_TestAllTypes.NestedMessage() + SwiftProtoTesting_TestAllTypes.NestedMessage.with { $0.bb = 12 }, + SwiftProtoTesting_TestAllTypes.NestedMessage(), ] } } func test_optionalStringExtensionWithDefault() throws { - assertJSONEncode("{\"[protobuf_unittest.default_string_extension]\":\"hi\"}", extensions: extensions) - { + assertJSONEncode("{\"[swift_proto_testing.default_string_extension]\":\"hi\"}", extensions: extensions) { (o: inout MessageTestType) in - o.ProtobufUnittest_defaultStringExtension = "hi" + o.SwiftProtoTesting_defaultStringExtension = "hi" } assertJSONDecodeSucceeds("{}", extensions: extensions) { - $0.ProtobufUnittest_defaultStringExtension == "hello" + $0.SwiftProtoTesting_defaultStringExtension == "hello" } } func test_ArrayWithExtensions() throws { assertJSONArrayEncode( "[" - + "{\"[protobuf_unittest.optional_int32_extension]\":17}," - + "{}," - + "{\"[protobuf_unittest.optional_double_extension]\":1.23}" - + "]", - extensions: extensions) - { + + "{\"[swift_proto_testing.optional_int32_extension]\":17}," + + "{}," + + "{\"[swift_proto_testing.optional_double_extension]\":1.23}" + + "]", + extensions: extensions + ) { (o: inout [MessageTestType]) in let o1 = MessageTestType.with { - $0.ProtobufUnittest_optionalInt32Extension = 17 + $0.SwiftProtoTesting_optionalInt32Extension = 17 } o.append(o1) o.append(MessageTestType()) let o3 = MessageTestType.with { - $0.ProtobufUnittest_optionalDoubleExtension = 1.23 + $0.SwiftProtoTesting_optionalDoubleExtension = 1.23 } o.append(o3) } } } -class Test_JSON_RecursiveNested_Extensions: XCTestCase, PBTestHelpers { - typealias MessageTestType = ProtobufUnittest_Extend_Msg1 - let extensions = ProtobufUnittest_Extend_UnittestSwiftExtension_Extensions - +final class Test_JSON_RecursiveNested_Extensions: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_Extend_Msg1 + let extensions = SwiftProtoTesting_Extend_UnittestSwiftExtension_Extensions + func test_nestedMessage() throws { - assertJSONEncode("{\"[protobuf_unittest.extend.a_b]\":12}", - extensions: extensions) { - (o: inout MessageTestType) in - o.ProtobufUnittest_Extend_aB = 12 + assertJSONEncode( + "{\"[swift_proto_testing.extend.a_b]\":12}", + extensions: extensions + ) { + (o: inout MessageTestType) in + o.SwiftProtoTesting_Extend_aB = 12 } - - assertJSONDecodeSucceeds("{\"[protobuf_unittest.extend.m2]\":{\"[protobuf_unittest.extend.aB]\":23}}", extensions: extensions) { - $0.ProtobufUnittest_Extend_m2.ProtobufUnittest_Extend_aB == 23 + + assertJSONDecodeSucceeds( + "{\"[swift_proto_testing.extend.m2]\":{\"[swift_proto_testing.extend.aB]\":23}}", + extensions: extensions + ) { + $0.SwiftProtoTesting_Extend_m2.SwiftProtoTesting_Extend_aB == 23 } } - + } diff --git a/Tests/SwiftProtobufTests/Test_JSON_Group.swift b/Tests/SwiftProtobufTests/Test_JSON_Group.swift index a1b4db78d..eeb981e74 100644 --- a/Tests/SwiftProtobufTests/Test_JSON_Group.swift +++ b/Tests/SwiftProtobufTests/Test_JSON_Group.swift @@ -17,14 +17,24 @@ import Foundation import XCTest -class Test_JSON_Group: XCTestCase, PBTestHelpers { - typealias MessageTestType = ProtobufUnittest_TestAllTypes +final class Test_JSON_Group: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_TestAllTypes func testOptionalGroup() { - assertJSONDecodeFails("{\"optionalgroup\":{\"a\":3}}") + assertJSONEncode("{\"optionalgroup\":{\"a\":3}}") { (o: inout MessageTestType) in + o.optionalGroup.a = 3 + } } func testRepeatedGroup() { - assertJSONDecodeFails("{\"repeatedgroup\":[{\"a\":1},{\"a\":2}]}") + assertJSONEncode("{\"repeatedgroup\":[{\"a\":1},{\"a\":2}]}") { (o: inout MessageTestType) in + let one = SwiftProtoTesting_TestAllTypes.RepeatedGroup.with { + $0.a = 1 + } + let two = SwiftProtoTesting_TestAllTypes.RepeatedGroup.with { + $0.a = 2 + } + o.repeatedGroup = [one, two] + } } } diff --git a/Tests/SwiftProtobufTests/Test_JSON_Performance.swift b/Tests/SwiftProtobufTests/Test_JSON_Performance.swift new file mode 100644 index 000000000..6f02826e8 --- /dev/null +++ b/Tests/SwiftProtobufTests/Test_JSON_Performance.swift @@ -0,0 +1,133 @@ +// Tests/SwiftProtobufTests/Test_JSON_Performance.swift - JSON performance checks +// +// Copyright (c) 2022 - 2022 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// This is a set of tests for JSON format protobuf files. +/// +// ----------------------------------------------------------------------------- + +import SwiftProtobuf +import XCTest + +final class Test_JSON_Performance: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_Fuzz_Message + + // Each of the following should be under 1s on a reasonably + // fast machine (originally developed on an M1 MacBook Pro). + // If they are significantly slower than that, then something + // may be amiss. + + func testEncoding_manyIntMapsEncoding_shouldBeUnder1s() { + let rawPadding = [Int32](repeating: 1_000_000_000, count: 150000) + let mapRepeats = 60000 + + let pad = rawPadding.map({ $0.description }).joined(separator: ",") + let child = "{\"mapFixed64Sint64\":{\"30\":\"4\"}}" + let children = [String](repeating: child, count: mapRepeats).joined(separator: ",") + let expected = + ("{" + + "\"repeatedInt32\":[" + + pad + + "]," + + "\"repeatedMessage\":[" + + children + + "]}") + + let msg = MessageTestType.with { + $0.repeatedInt32 = rawPadding + let child = MessageTestType.with { + $0.mapFixed64Sint64[30] = 4 + } + let array = [MessageTestType](repeating: child, count: mapRepeats) + $0.repeatedMessage = array + } + + // Map fields used to trigger quadratic behavior, which meant + // this encoding could take over 30s, but now it should + // consistently take a fraction of a second. I've skipped + // decoding here because decoding is much slower -- due to the + // need to create a lot of objects -- which makes it much less + // obvious when the encoding goes awry. + let encoded = try! msg.jsonString() + XCTAssertEqual(expected, encoded) + } + + func testEncoding_manyEnumMapsEncoding_shouldBeUnder1s() { + let rawPadding = [Int32](repeating: 1_000_000_000, count: 150000) + let mapRepeats = 60000 + + let pad = rawPadding.map({ $0.description }).joined(separator: ",") + let child = "{\"mapInt32AnEnum\":{\"30\":\"TWO\"}}" + let children = [String](repeating: child, count: mapRepeats).joined(separator: ",") + let expected = + ("{" + + "\"repeatedInt32\":[" + + pad + + "]," + + "\"repeatedMessage\":[" + + children + + "]}") + + let msg = MessageTestType.with { + $0.repeatedInt32 = rawPadding + let child = MessageTestType.with { + $0.mapInt32AnEnum[30] = SwiftProtoTesting_Fuzz_AnEnum.two + } + let array = [MessageTestType](repeating: child, count: mapRepeats) + $0.repeatedMessage = array + } + + // Map fields used to trigger quadratic behavior, which meant + // this encoding could take over 30s, but now it should + // consistently take a fraction of a second. I've skipped + // decoding here because decoding is much slower -- due to the + // need to create a lot of objects -- which makes it much less + // obvious when the encoding goes awry. + let encoded = try! msg.jsonString() + XCTAssertEqual(expected, encoded) + } + + func testEncoding_manyMessageMapsEncoding_shouldBeUnder1s() { + let rawPadding = [Int32](repeating: 1_000_000_000, count: 150000) + let mapRepeats = 50000 + + let pad = rawPadding.map({ $0.description }).joined(separator: ",") + let child = "{\"mapInt32Message\":{\"30\":{\"singularInt32\":8}}}" + let children = [String](repeating: child, count: mapRepeats).joined(separator: ",") + let expected = + ("{" + + "\"repeatedInt32\":[" + + pad + + "]," + + "\"repeatedMessage\":[" + + children + + "]}") + + let msg = MessageTestType.with { + $0.repeatedInt32 = rawPadding + let child = MessageTestType.with { + let grandchild = MessageTestType.with { + $0.singularInt32 = 8 + } + $0.mapInt32Message[30] = grandchild + } + let array = [MessageTestType](repeating: child, count: mapRepeats) + $0.repeatedMessage = array + } + + // Map fields used to trigger quadratic behavior, which meant + // this encoding could take over 30s, but now it should + // consistently take a fraction of a second. I've skipped + // decoding here because decoding is much slower -- due to the + // need to create a lot of objects -- which makes it much less + // obvious when the encoding goes awry. + let encoded = try! msg.jsonString() + XCTAssertEqual(expected, encoded) + } +} diff --git a/Tests/SwiftProtobufTests/Test_Map.swift b/Tests/SwiftProtobufTests/Test_Map.swift index a1fd8b371..6c7d8b41a 100644 --- a/Tests/SwiftProtobufTests/Test_Map.swift +++ b/Tests/SwiftProtobufTests/Test_Map.swift @@ -15,41 +15,56 @@ import Foundation import XCTest -class Test_Map: XCTestCase, PBTestHelpers { - typealias MessageTestType = ProtobufUnittest_TestMap +final class Test_Map: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_TestMap - func assertMapEncode(_ expectedBlocks: [[UInt8]], file: XCTestFileArgType = #file, line: UInt = #line, configure: (inout MessageTestType) -> Void) { + func assertMapEncode( + _ expectedBlocks: [[UInt8]], + file: XCTestFileArgType = #file, + line: UInt = #line, + configure: (inout MessageTestType) -> Void + ) { let empty = MessageTestType() var configured = empty configure(&configured) XCTAssert(configured != empty, "Object should not be equal to empty object", file: file, line: line) do { - let encoded = try configured.serializedBytes() + let encoded: [UInt8] = try configured.serializedBytes() // Reorder the provided blocks to match what we were given var t = encoded[0.. Bool in + m.mapInt32Enum == [1: .foo, 3: .baz] + } + } + func testMapInt32Message() { - assertJSONEncode("{\"mapInt32ForeignMessage\":{\"7\":{\"c\":999}}}") {(o: inout MessageTestType) in - var m = ProtobufUnittest_ForeignMessage() + assertJSONEncode("{\"mapInt32ForeignMessage\":{\"7\":{\"c\":999}}}") { (o: inout MessageTestType) in + var m = SwiftProtoTesting_ForeignMessage() m.c = 999 o.mapInt32ForeignMessage[7] = m } assertJSONDecodeSucceeds("{\"mapInt32ForeignMessage\":{\"7\":{\"c\":7},\"8\":{\"c\":8}}}") { - var sub7 = ProtobufUnittest_ForeignMessage() + var sub7 = SwiftProtoTesting_ForeignMessage() sub7.c = 7 - var sub8 = ProtobufUnittest_ForeignMessage() + var sub8 = SwiftProtoTesting_ForeignMessage() sub8.c = 8 - return $0.mapInt32ForeignMessage == [7:sub7, 8:sub8] + return $0.mapInt32ForeignMessage == [7: sub7, 8: sub8] } } } diff --git a/Tests/SwiftProtobufTests/Test_Merge.swift b/Tests/SwiftProtobufTests/Test_Merge.swift index bca87e52d..cf3f262df 100644 --- a/Tests/SwiftProtobufTests/Test_Merge.swift +++ b/Tests/SwiftProtobufTests/Test_Merge.swift @@ -9,47 +9,47 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_Merge: XCTestCase, PBTestHelpers { - typealias MessageTestType = Proto3Unittest_TestAllTypes +final class Test_Merge: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_Proto3_TestAllTypes - func testMergeSimple() throws { - var m1 = Proto3Unittest_TestAllTypes() - m1.optionalInt32 = 100 + func testMergeSimple() throws { + var m1 = SwiftProtoTesting_Proto3_TestAllTypes() + m1.optionalInt32 = 100 - var m2 = Proto3Unittest_TestAllTypes() - m2.optionalInt64 = 1000 + var m2 = SwiftProtoTesting_Proto3_TestAllTypes() + m2.optionalInt64 = 1000 - do { - try m1.merge(serializedData: m2.serializedData()) - XCTAssertEqual(m1.optionalInt32, 100) - XCTAssertEqual(m1.optionalInt64, 1000) - } catch let e { - XCTFail("Merge should not have thrown, but it did: \(e)") + do { + try m1.merge(serializedBytes: m2.serializedBytes() as [UInt8]) + XCTAssertEqual(m1.optionalInt32, 100) + XCTAssertEqual(m1.optionalInt64, 1000) + } catch let e { + XCTFail("Merge should not have thrown, but it did: \(e)") + } } - } - - func testMergePreservesValueSemantics() throws { - var original = Proto3Unittest_TestAllTypes() - original.optionalInt32 = 100 - let copied = original - - var toMerge = Proto3Unittest_TestAllTypes() - toMerge.optionalInt64 = 1000 - - do { - try original.merge(serializedData: toMerge.serializedData()) - - // The original should have the value from the merged message... - XCTAssertEqual(original.optionalInt32, 100) - XCTAssertEqual(original.optionalInt64, 1000) - // ...but the older copy should not be affected. - XCTAssertEqual(copied.optionalInt32, 100) - XCTAssertEqual(copied.optionalInt64, 0) - } catch let e { - XCTFail("Merge should not have thrown, but it did: \(e)") + + func testMergePreservesValueSemantics() throws { + var original = SwiftProtoTesting_Proto3_TestAllTypes() + original.optionalInt32 = 100 + let copied = original + + var toMerge = SwiftProtoTesting_Proto3_TestAllTypes() + toMerge.optionalInt64 = 1000 + + do { + try original.merge(serializedBytes: toMerge.serializedBytes() as [UInt8]) + + // The original should have the value from the merged message... + XCTAssertEqual(original.optionalInt32, 100) + XCTAssertEqual(original.optionalInt64, 1000) + // ...but the older copy should not be affected. + XCTAssertEqual(copied.optionalInt32, 100) + XCTAssertEqual(copied.optionalInt64, 0) + } catch let e { + XCTFail("Merge should not have thrown, but it did: \(e)") + } } - } } diff --git a/Tests/SwiftProtobufTests/Test_MessageSet.swift b/Tests/SwiftProtobufTests/Test_MessageSet.swift index 44c1bafb9..9667381c0 100644 --- a/Tests/SwiftProtobufTests/Test_MessageSet.swift +++ b/Tests/SwiftProtobufTests/Test_MessageSet.swift @@ -13,213 +13,434 @@ // ----------------------------------------------------------------------------- import Foundation +import SwiftProtobuf import XCTest -@testable import SwiftProtobuf - -extension ProtobufUnittest_RawMessageSet.Item { - fileprivate init(typeID: Int, message: Data) { - self.init() - self.typeID = Int32(typeID) - self.message = message - } + +extension SwiftProtoTesting_RawMessageSet.Item { + fileprivate init(typeID: Int, message: Data) { + self.init() + self.typeID = Int32(typeID) + self.message = message + } } -class Test_MessageSet: XCTestCase { +final class Test_MessageSet: XCTestCase { + + // wireformat_unittest.cc: TEST(WireFormatTest, SerializeMessageSet) + func testSerialize() throws { + let msg = SwiftProtoTesting_WireFormat_TestMessageSet.with { + $0.SwiftProtoTesting_TestMessageSetExtension1_messageSetExtension.i = 123 + $0.SwiftProtoTesting_TestMessageSetExtension2_messageSetExtension.str = "foo" + } + + let serialized: [UInt8] + do { + serialized = try msg.serializedBytes() + } catch let e { + XCTFail("Failed to serialize: \(e)") + return + } + + // Read it back in with the RawMessageSet to validate it. + + let raw: SwiftProtoTesting_RawMessageSet + do { + raw = try SwiftProtoTesting_RawMessageSet(serializedBytes: serialized) + } catch let e { + XCTFail("Failed to parse: \(e)") + return + } - // wireformat_unittest.cc: TEST(WireFormatTest, SerializeMessageSet) - func testSerialize() throws { - let msg = Proto2WireformatUnittest_TestMessageSet.with { - $0.ProtobufUnittest_TestMessageSetExtension1_messageSetExtension.i = 123 - $0.ProtobufUnittest_TestMessageSetExtension2_messageSetExtension.str = "foo" + XCTAssertTrue(raw.unknownFields.data.isEmpty) + + XCTAssertEqual(raw.item.count, 2) + + XCTAssertEqual( + Int(raw.item[0].typeID), + SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension.fieldNumber + ) + XCTAssertEqual( + Int(raw.item[1].typeID), + SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension.fieldNumber + ) + + let extMsg1 = try SwiftProtoTesting_TestMessageSetExtension1(serializedBytes: raw.item[0].message) + XCTAssertEqual(extMsg1.i, 123) + XCTAssertTrue(extMsg1.unknownFields.data.isEmpty) + let extMsg2 = try SwiftProtoTesting_TestMessageSetExtension2(serializedBytes: raw.item[1].message) + XCTAssertEqual(extMsg2.str, "foo") + XCTAssertTrue(extMsg2.unknownFields.data.isEmpty) } - let serialized: Data - do { - serialized = try msg.serializedData() - } catch let e { - XCTFail("Failed to serialize: \(e)") - return + // wireformat_unittest.cc: TEST(WireFormatTest, ParseMessageSet) + func testParse() throws { + let msg1 = SwiftProtoTesting_TestMessageSetExtension1.with { $0.i = 123 } + let msg2 = SwiftProtoTesting_TestMessageSetExtension2.with { $0.str = "foo" } + var raw = SwiftProtoTesting_RawMessageSet() + raw.item = [ + // Two known extensions. + SwiftProtoTesting_RawMessageSet.Item( + typeID: SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension.fieldNumber, + message: try msg1.serializedBytes() + ), + SwiftProtoTesting_RawMessageSet.Item( + typeID: SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension.fieldNumber, + message: try msg2.serializedBytes() + ), + // One unknown extension. + SwiftProtoTesting_RawMessageSet.Item(typeID: 7, message: Data([1, 2, 3])), + ] + // Add some unknown data into one of the groups to ensure it gets stripped when parsing. + raw.item[1].unknownFields.append(protobufData: Data([40, 2])) // Field 5, varint of 2 + + let serialized: Data + do { + serialized = try raw.serializedBytes() + } catch let e { + XCTFail("Failed to serialize: \(e)") + return + } + + let msg: SwiftProtoTesting_WireFormat_TestMessageSet + do { + msg = try SwiftProtoTesting_WireFormat_TestMessageSet( + serializedBytes: serialized, + extensions: SwiftProtoTesting_UnittestMset_Extensions + ) + } catch let e { + XCTFail("Failed to parse: \(e)") + return + } + + // Ensure the extensions showed up, but with nothing extra. + XCTAssertEqual( + msg.SwiftProtoTesting_TestMessageSetExtension1_messageSetExtension.i, + 123 + ) + XCTAssertTrue( + msg.SwiftProtoTesting_TestMessageSetExtension1_messageSetExtension.unknownFields.data.isEmpty + ) + XCTAssertEqual( + msg.SwiftProtoTesting_TestMessageSetExtension2_messageSetExtension.str, + "foo" + ) + XCTAssertTrue( + msg.SwiftProtoTesting_TestMessageSetExtension2_messageSetExtension.unknownFields.data.isEmpty + ) + + // Ensure the unknown shows up as a group. + let expectedUnknowns = Data([ + 11, // Start group + 16, 7, // typeID = 7 + 26, 3, 1, 2, 3, // message data = 3 bytes: 1, 2, 3 + 12, // End Group + ]) + XCTAssertEqual(msg.unknownFields.data, expectedUnknowns) + + var validator = ExtensionValidator() + validator.expectedMessages = [ + (SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension.fieldNumber, false), + (SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension.fieldNumber, false), + ] + validator.expectedUnknowns = [expectedUnknowns] + validator.validate(message: msg) } - // Read it back in with the RawMessageSet to validate it. + static let canonicalTextFormat: String = + ("message_set {\n" + " [swift_proto_testing.TestMessageSetExtension1] {\n" + " i: 23\n" + " }\n" + + " [swift_proto_testing.TestMessageSetExtension2] {\n" + " str: \"foo\"\n" + " }\n" + "}\n") - let raw: ProtobufUnittest_RawMessageSet - do { - raw = try ProtobufUnittest_RawMessageSet(serializedData: serialized) - } catch let e { - XCTFail("Failed to parse: \(e)") - return + func testParseOrder1() throws { + let serialized = Data([ + 11, + 16, 176, 166, 94, // Extension ID + 26, 2, 120, 123, // Payload message + 12, + ]) + + let msg: SwiftProtoTesting_WireFormat_TestMessageSet + do { + msg = try SwiftProtoTesting_WireFormat_TestMessageSet( + serializedBytes: serialized, + extensions: SwiftProtoTesting_UnittestMset_Extensions + ) + } catch let e { + XCTFail("Failed to parse: \(e)") + return + } + XCTAssertEqual( + msg.SwiftProtoTesting_TestMessageSetExtension1_messageSetExtension.i, + 123 + ) } - XCTAssertTrue(raw.unknownFields.data.isEmpty) - - XCTAssertEqual(raw.item.count, 2) - - XCTAssertEqual(Int(raw.item[0].typeID), - ProtobufUnittest_TestMessageSetExtension1.Extensions.message_set_extension.fieldNumber) - XCTAssertEqual(Int(raw.item[1].typeID), - ProtobufUnittest_TestMessageSetExtension2.Extensions.message_set_extension.fieldNumber) - - let extMsg1 = try ProtobufUnittest_TestMessageSetExtension1(serializedData: raw.item[0].message) - XCTAssertEqual(extMsg1.i, 123) - XCTAssertTrue(extMsg1.unknownFields.data.isEmpty) - let extMsg2 = try ProtobufUnittest_TestMessageSetExtension2(serializedData: raw.item[1].message) - XCTAssertEqual(extMsg2.str, "foo") - XCTAssertTrue(extMsg2.unknownFields.data.isEmpty) - } - - // wireformat_unittest.cc: TEST(WireFormatTest, ParseMessageSet) - func testParse() throws { - let msg1 = ProtobufUnittest_TestMessageSetExtension1.with { $0.i = 123 } - let msg2 = ProtobufUnittest_TestMessageSetExtension2.with { $0.str = "foo" } - var raw = ProtobufUnittest_RawMessageSet() - raw.item = [ - // Two known extensions. - ProtobufUnittest_RawMessageSet.Item( - typeID: ProtobufUnittest_TestMessageSetExtension1.Extensions.message_set_extension.fieldNumber, - message: try msg1.serializedData()), - ProtobufUnittest_RawMessageSet.Item( - typeID: ProtobufUnittest_TestMessageSetExtension2.Extensions.message_set_extension.fieldNumber, - message: try msg2.serializedData()), - // One unknown extension. - ProtobufUnittest_RawMessageSet.Item(typeID: 7, message: Data([1, 2, 3])) - ] - // Add some unknown data into one of the groups to ensure it gets stripped when parsing. - raw.item[1].unknownFields.append(protobufData: Data([40, 2])) // Field 5, varint of 2 - - let serialized: Data - do { - serialized = try raw.serializedData() - } catch let e { - XCTFail("Failed to serialize: \(e)") - return + func testParseOrder2() throws { + let serialized = Data([ + 11, + 26, 2, 120, 123, // Payload message + 16, 176, 166, 94, // Extension ID + 12, + ]) + + let msg: SwiftProtoTesting_WireFormat_TestMessageSet + do { + msg = try SwiftProtoTesting_WireFormat_TestMessageSet( + serializedBytes: serialized, + extensions: SwiftProtoTesting_UnittestMset_Extensions + ) + } catch let e { + XCTFail("Failed to parse: \(e)") + return + } + XCTAssertEqual( + msg.SwiftProtoTesting_TestMessageSetExtension1_messageSetExtension.i, + 123 + ) } - let msg: Proto2WireformatUnittest_TestMessageSet - do { - msg = try Proto2WireformatUnittest_TestMessageSet( - serializedData: serialized, - extensions: ProtobufUnittest_UnittestMset_Extensions) - } catch let e { - XCTFail("Failed to parse: \(e)") - return + // text_format_unittest.cc: TEST_F(TextFormatMessageSetTest, Serialize) + func testTextFormat_Serialize() { + let msg = SwiftProtoTesting_TestMessageSetContainer.with { + $0.messageSet.SwiftProtoTesting_TestMessageSetExtension1_messageSetExtension.i = 23 + $0.messageSet.SwiftProtoTesting_TestMessageSetExtension2_messageSetExtension.str = "foo" + } + + XCTAssertEqual(msg.textFormatString(), Test_MessageSet.canonicalTextFormat) } - // Ensure the extensions showed up, but with nothing extra. - XCTAssertEqual( - msg.ProtobufUnittest_TestMessageSetExtension1_messageSetExtension.i, 123) - XCTAssertTrue( - msg.ProtobufUnittest_TestMessageSetExtension1_messageSetExtension.unknownFields.data.isEmpty) - XCTAssertEqual( - msg.ProtobufUnittest_TestMessageSetExtension2_messageSetExtension.str, "foo") - XCTAssertTrue( - msg.ProtobufUnittest_TestMessageSetExtension2_messageSetExtension.unknownFields.data.isEmpty) - - // Ensure the unknown shows up as a group. - let expectedUnknowns = Data([ - 11, // Start group - 16, 7, // typeID = 7 - 26, 3, 1, 2, 3, // message data = 3 bytes: 1, 2, 3 - 12 // End Group - ]) - XCTAssertEqual(msg.unknownFields.data, expectedUnknowns) - - var validator = ExtensionValidator() - validator.expectedMessages = [ - (ProtobufUnittest_TestMessageSetExtension1.Extensions.message_set_extension.fieldNumber, false), - (ProtobufUnittest_TestMessageSetExtension2.Extensions.message_set_extension.fieldNumber, false), - ] - validator.expectedUnknowns = [ expectedUnknowns ] - validator.validate(message: msg) - } - - static let canonicalTextFormat: String = ( - "message_set {\n" + - " [protobuf_unittest.TestMessageSetExtension1] {\n" + - " i: 23\n" + - " }\n" + - " [protobuf_unittest.TestMessageSetExtension2] {\n" + - " str: \"foo\"\n" + - " }\n" + - "}\n" - ) - - // text_format_unittest.cc: TEST_F(TextFormatMessageSetTest, Serialize) - func testTextFormat_Serialize() { - let msg = ProtobufUnittest_TestMessageSetContainer.with { - $0.messageSet.ProtobufUnittest_TestMessageSetExtension1_messageSetExtension.i = 23 - $0.messageSet.ProtobufUnittest_TestMessageSetExtension2_messageSetExtension.str = "foo" + // text_format_unittest.cc: TEST_F(TextFormatMessageSetTest, Deserialize) + func testTextFormat_Parse() { + let msg: SwiftProtoTesting_TestMessageSetContainer + do { + msg = try SwiftProtoTesting_TestMessageSetContainer( + textFormatString: Test_MessageSet.canonicalTextFormat, + extensions: SwiftProtoTesting_UnittestMset_Extensions + ) + } catch let e { + XCTFail("Shouldn't have failed: \(e)") + return + } + + XCTAssertEqual( + msg.messageSet.SwiftProtoTesting_TestMessageSetExtension1_messageSetExtension.i, + 23 + ) + XCTAssertEqual( + msg.messageSet.SwiftProtoTesting_TestMessageSetExtension2_messageSetExtension.str, + "foo" + ) + + // Ensure nothing else showed up. + XCTAssertTrue(msg.unknownFields.data.isEmpty) + XCTAssertTrue(msg.messageSet.unknownFields.data.isEmpty) + + var validator = ExtensionValidator() + validator.expectedMessages = [ + (1, true), // swift_proto_testing.TestMessageSetContainer.message_set (where the extensions are) + (SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension.fieldNumber, false), + (SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension.fieldNumber, false), + ] + validator.validate(message: msg) } - XCTAssertEqual(msg.textFormatString(), Test_MessageSet.canonicalTextFormat) - } - - // text_format_unittest.cc: TEST_F(TextFormatMessageSetTest, Deserialize) - func testTextFormat_Parse() { - let msg: ProtobufUnittest_TestMessageSetContainer - do { - msg = try ProtobufUnittest_TestMessageSetContainer( - textFormatString: Test_MessageSet.canonicalTextFormat, - extensions: ProtobufUnittest_UnittestMset_Extensions) - } catch let e { - XCTFail("Shouldn't have failed: \(e)") - return + func testParse_FirstValueSticks() throws { + let extMsg1 = SwiftProtoTesting_TestMessageSetExtension1.with { $0.i = 123 } + let extMsg2 = SwiftProtoTesting_TestMessageSetExtension2.with { $0.str = "foo" } + + var rawItem = SwiftProtoTesting_RawBreakableMessageSet.Item() + rawItem.typeID = [ + Int32(SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension.fieldNumber), + Int32(SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension.fieldNumber), + ] + rawItem.message = [ + try extMsg1.serializedBytes(), + try extMsg2.serializedBytes(), + ] + let raw = SwiftProtoTesting_RawBreakableMessageSet.with { $0.item = [rawItem] } + + let serialized: Data + do { + serialized = try raw.serializedBytes() + } catch let e { + XCTFail("Failed to serialize: \(e)") + return + } + + let msg: SwiftProtoTesting_WireFormat_TestMessageSet + do { + msg = try SwiftProtoTesting_WireFormat_TestMessageSet( + serializedBytes: serialized, + extensions: SwiftProtoTesting_UnittestMset_Extensions + ) + } catch let e { + XCTFail("Failed to parse: \(e)") + return + } + + // Only the first extension shows up and with only the expected data. + XCTAssertTrue(msg.hasSwiftProtoTesting_TestMessageSetExtension1_messageSetExtension) + XCTAssertFalse(msg.hasSwiftProtoTesting_TestMessageSetExtension2_messageSetExtension) + XCTAssertEqual( + msg.SwiftProtoTesting_TestMessageSetExtension1_messageSetExtension.i, + 123 + ) + XCTAssertTrue( + msg.SwiftProtoTesting_TestMessageSetExtension1_messageSetExtension.unknownFields.data.isEmpty + ) + + XCTAssertTrue(msg.unknownFields.data.isEmpty) + + var validator = ExtensionValidator() + validator.expectedMessages = [ + (SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension.fieldNumber, false) + ] + validator.validate(message: msg) } - XCTAssertEqual( - msg.messageSet.ProtobufUnittest_TestMessageSetExtension1_messageSetExtension.i, 23) - XCTAssertEqual( - msg.messageSet.ProtobufUnittest_TestMessageSetExtension2_messageSetExtension.str, "foo") - - // Ensure nothing else showed up. - XCTAssertTrue(msg.unknownFields.data.isEmpty) - XCTAssertTrue(msg.messageSet.unknownFields.data.isEmpty) - - var validator = ExtensionValidator() - validator.expectedMessages = [ - (1, true), // protobuf_unittest.TestMessageSetContainer.message_set (where the extensions are) - (ProtobufUnittest_TestMessageSetExtension1.Extensions.message_set_extension.fieldNumber, false), - (ProtobufUnittest_TestMessageSetExtension2.Extensions.message_set_extension.fieldNumber, false), - ] - validator.validate(message: msg) - } - - fileprivate struct ExtensionValidator: PBTestVisitor { - // Values are field number and if we should recurse. - var expectedMessages = [(Int, Bool)]() - var expectedUnknowns = [Data]() - - mutating func validate(message: M) { - do { - try message.traverse(visitor: &self) - } catch let e { - XCTFail("Error while traversing: \(e)") - } - XCTAssertTrue(expectedMessages.isEmpty, - "Expected more messages: \(expectedMessages)") - XCTAssertTrue(expectedUnknowns.isEmpty, - "Expected more unknowns: \(expectedUnknowns)") + func testParse_PartialValuesDropped() { + var raw = SwiftProtoTesting_RawBreakableMessageSet() + + do { + // No payload + let rawItem = SwiftProtoTesting_RawBreakableMessageSet.Item.with { + $0.typeID = [ + Int32(SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension.fieldNumber) + ] + } + raw.item.append(rawItem) + } + + do { + // No typeID + let rawItem = SwiftProtoTesting_RawBreakableMessageSet.Item.with { + $0.message = [Data()] // Empty message is zero length data. + } + raw.item.append(rawItem) + } + + do { + // Neither field. + let rawItem = SwiftProtoTesting_RawBreakableMessageSet.Item() + raw.item.append(rawItem) + } + + let serialized: Data + do { + serialized = try raw.serializedBytes() + } catch let e { + XCTFail("Failed to serialize: \(e)") + return + } + + let msg: SwiftProtoTesting_WireFormat_TestMessageSet + do { + msg = try SwiftProtoTesting_WireFormat_TestMessageSet( + serializedBytes: serialized, + extensions: SwiftProtoTesting_UnittestMset_Extensions + ) + } catch let e { + XCTFail("Failed to parse: \(e)") + return + } + + // All are partials, so nothing show show up. + XCTAssertFalse(msg.hasSwiftProtoTesting_TestMessageSetExtension1_messageSetExtension) + XCTAssertFalse(msg.hasSwiftProtoTesting_TestMessageSetExtension2_messageSetExtension) + XCTAssertTrue(msg.unknownFields.data.isEmpty) + + var validator = ExtensionValidator() + validator.validate(message: msg) } - mutating func visitSingularMessageField(value: M, fieldNumber: Int) throws { - guard !expectedMessages.isEmpty else { - XCTFail("Unexpected Message: \(fieldNumber) = \(value)") - return - } - let (expected, shouldRecurse) = expectedMessages.removeFirst() - XCTAssertEqual(fieldNumber, expected) - if shouldRecurse && expected == fieldNumber { - try value.traverse(visitor: &self) - } + func testParse_FieldEncoding() { + let extMsg1 = SwiftProtoTesting_TestMessageSetExtension1.with { $0.i = 123 } + let extMsg3 = SwiftProtoTesting_TestMessageSetExtension3.with { $0.x = 10 } + + let msgEx = SwiftProtoTesting_MessageEx.with { + $0.SwiftProtoTesting_TestMessageSetExtension1_doppelgangerMessageSetExtension = extMsg1 + $0.SwiftProtoTesting_TestMessageSetExtension3_doppelgangerMessageSetExtension = extMsg3 + } + + let serialized: Data + do { + serialized = try msgEx.serializedBytes() + } catch let e { + XCTFail("Failed to serialize: \(e)") + return + } + + let msg: SwiftProtoTesting_WireFormat_TestMessageSet + do { + msg = try SwiftProtoTesting_WireFormat_TestMessageSet( + serializedBytes: serialized, + extensions: SwiftProtoTesting_UnittestMset_Extensions + ) + } catch let e { + XCTFail("Failed to parse: \(e)") + return + } + + // One comes in as a known field, other comes in as unknown field (not promoted to the + // group form). + XCTAssertTrue(msg.hasSwiftProtoTesting_TestMessageSetExtension1_messageSetExtension) + XCTAssertFalse(msg.hasSwiftProtoTesting_TestMessageSetExtension2_messageSetExtension) + + let expectedUnknowns = Data([ + 210, 223, 243, 5, // Length delimted field 1547770 + 3, // Length (varint) + 208, 1, // Varint field 26 ("x") in message + 10, // Value of X + ]) + XCTAssertEqual(msg.unknownFields.data, expectedUnknowns) + + var validator = ExtensionValidator() + validator.expectedMessages = [ + (SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension.fieldNumber, false) + ] + validator.expectedUnknowns = [expectedUnknowns] + validator.validate(message: msg) } - mutating func visitUnknown(bytes: Data) throws { - guard !expectedUnknowns.isEmpty else { - XCTFail("Unexpected Unknown: \(bytes)") - return - } - let expected = expectedUnknowns.removeFirst() - XCTAssertEqual(bytes, expected) + fileprivate struct ExtensionValidator: PBTestVisitor { + // Values are field number and if we should recurse. + var expectedMessages = [(Int, Bool)]() + var expectedUnknowns = [Data]() + + mutating func validate(message: M) { + do { + try message.traverse(visitor: &self) + } catch let e { + XCTFail("Error while traversing: \(e)") + } + XCTAssertTrue( + expectedMessages.isEmpty, + "Expected more messages: \(expectedMessages)" + ) + XCTAssertTrue( + expectedUnknowns.isEmpty, + "Expected more unknowns: \(expectedUnknowns)" + ) + } + + mutating func visitSingularMessageField(value: M, fieldNumber: Int) throws { + guard !expectedMessages.isEmpty else { + XCTFail("Unexpected Message: \(fieldNumber) = \(value)") + return + } + let (expected, shouldRecurse) = expectedMessages.removeFirst() + XCTAssertEqual(fieldNumber, expected) + if shouldRecurse && expected == fieldNumber { + try value.traverse(visitor: &self) + } + } + + mutating func visitUnknown(bytes: Data) throws { + guard !expectedUnknowns.isEmpty else { + XCTFail("Unexpected Unknown: \(bytes)") + return + } + let expected = expectedUnknowns.removeFirst() + XCTAssertEqual(bytes, expected) + } } - } } diff --git a/Tests/SwiftProtobufTests/Test_Naming.swift b/Tests/SwiftProtobufTests/Test_Naming.swift index 812a87987..9a4974be2 100644 --- a/Tests/SwiftProtobufTests/Test_Naming.swift +++ b/Tests/SwiftProtobufTests/Test_Naming.swift @@ -9,8 +9,8 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest // In transforming some of the names in protos to Swift names, we do different // transforms, this test is mainly a compile test in that the code below calls @@ -23,891 +23,891 @@ import SwiftProtobuf // NOTE: If this code fails to compile, make sure the name changes make sense. -class Test_PackageMapping: XCTestCase { - func testPackageStartingWithNumber() { - let _ = _4fun_Mumble_MyMessage() - } +final class Test_PackageMapping: XCTestCase { + func testPackageStartingWithNumber() { + let _ = _4fun_SwiftProtoTesting_Mumble_MyMessage() + } } -class Test_FieldNamingInitials: XCTestCase { - func testHidingFunctions() throws { - // Check that we can access the standard `serializeData`, etc - // methods even on messages that define fields or submessages with - // such names: - let msg = SwiftUnittest_Names_FieldNames() - _ = try msg.serializedData() - _ = try msg.jsonUTF8Data() - _ = try msg.jsonString() - - let msg2 = SwiftUnittest_Names_MessageNames() - // The submessage is a static type name: - _ = SwiftUnittest_Names_MessageNames.serializedData() - // The method is an instance property: - _ = try msg2.serializedData() - _ = try msg2.jsonUTF8Data() - _ = try msg2.jsonString() - } - - func testLowers() { - var msg = SwiftUnittest_Names_FieldNamingInitials.Lowers() - - msg.http = 1 - XCTAssertTrue(msg.hasHTTP) - msg.clearHTTP() - - msg.httpRequest = 1 - XCTAssertTrue(msg.hasHTTPRequest) - msg.clearHTTPRequest() - - msg.theHTTPRequest = 1 - XCTAssertTrue(msg.hasTheHTTPRequest) - msg.clearTheHTTPRequest() - - msg.theHTTP = 1 - XCTAssertTrue(msg.hasTheHTTP) - msg.clearTheHTTP() - - msg.https = 1 - XCTAssertTrue(msg.hasHTTPS) - msg.clearHTTPS() - - msg.httpsRequest = 1 - XCTAssertTrue(msg.hasHTTPSRequest) - msg.clearHTTPSRequest() - - msg.theHTTPSRequest = 1 - XCTAssertTrue(msg.hasTheHTTPSRequest) - msg.clearTheHTTPSRequest() - - msg.theHTTPS = 1 - XCTAssertTrue(msg.hasTheHTTPS) - msg.clearTheHTTPS() - - msg.url = 1 - XCTAssertTrue(msg.hasURL) - msg.clearURL() - - msg.urlValue = 1 - XCTAssertTrue(msg.hasURLValue) - msg.clearURLValue() - - msg.theURLValue = 1 - XCTAssertTrue(msg.hasTheURLValue) - msg.clearTheURLValue() - - msg.theURL = 1 - XCTAssertTrue(msg.hasTheURL) - msg.clearTheURL() - - msg.aBC = 1 - XCTAssertTrue(msg.hasABC) - msg.clearABC() - - msg.id = 1 - XCTAssertTrue(msg.hasID) - msg.clearID() - - msg.idNumber = 1 - XCTAssertTrue(msg.hasIDNumber) - msg.clearIDNumber() - - msg.theIDNumber = 1 - XCTAssertTrue(msg.hasTheIDNumber) - msg.clearTheIDNumber() - - msg.requestID = 1 - XCTAssertTrue(msg.hasRequestID) - msg.clearRequestID() - } - - func testUppers() { - var msg = SwiftUnittest_Names_FieldNamingInitials.Uppers() - - msg.http = 1 - XCTAssertTrue(msg.hasHTTP) - msg.clearHTTP() - - msg.httpRequest = 1 - XCTAssertTrue(msg.hasHTTPRequest) - msg.clearHTTPRequest() - - msg.theHTTPRequest = 1 - XCTAssertTrue(msg.hasTheHTTPRequest) - msg.clearTheHTTPRequest() - - msg.theHTTP = 1 - XCTAssertTrue(msg.hasTheHTTP) - msg.clearTheHTTP() +final class Test_FieldNamingInitials: XCTestCase { + func testHidingFunctions() throws { + // Check that we can access the standard `serializeData`, etc + // methods even on messages that define fields or submessages with + // such names: + let msg = SwiftProtoTesting_Names_FieldNames() + _ = try msg.serializedBytes() as [UInt8] + _ = try msg.jsonUTF8Bytes() as [UInt8] + _ = try msg.jsonString() + + let msg2 = SwiftProtoTesting_Names_MessageNames() + // The submessage is a static type name: + _ = SwiftProtoTesting_Names_MessageNames.serializedData() + // The method is an instance property: + _ = try msg2.serializedBytes() as [UInt8] + _ = try msg2.jsonUTF8Bytes() as [UInt8] + _ = try msg2.jsonString() + } + + func testLowers() { + var msg = SwiftProtoTesting_Names_FieldNamingInitials.Lowers() + + msg.http = 1 + XCTAssertTrue(msg.hasHTTP) + msg.clearHTTP() + + msg.httpRequest = 1 + XCTAssertTrue(msg.hasHTTPRequest) + msg.clearHTTPRequest() + + msg.theHTTPRequest = 1 + XCTAssertTrue(msg.hasTheHTTPRequest) + msg.clearTheHTTPRequest() + + msg.theHTTP = 1 + XCTAssertTrue(msg.hasTheHTTP) + msg.clearTheHTTP() + + msg.https = 1 + XCTAssertTrue(msg.hasHTTPS) + msg.clearHTTPS() + + msg.httpsRequest = 1 + XCTAssertTrue(msg.hasHTTPSRequest) + msg.clearHTTPSRequest() + + msg.theHTTPSRequest = 1 + XCTAssertTrue(msg.hasTheHTTPSRequest) + msg.clearTheHTTPSRequest() + + msg.theHTTPS = 1 + XCTAssertTrue(msg.hasTheHTTPS) + msg.clearTheHTTPS() + + msg.url = 1 + XCTAssertTrue(msg.hasURL) + msg.clearURL() + + msg.urlValue = 1 + XCTAssertTrue(msg.hasURLValue) + msg.clearURLValue() + + msg.theURLValue = 1 + XCTAssertTrue(msg.hasTheURLValue) + msg.clearTheURLValue() + + msg.theURL = 1 + XCTAssertTrue(msg.hasTheURL) + msg.clearTheURL() + + msg.aBC = 1 + XCTAssertTrue(msg.hasABC) + msg.clearABC() + + msg.id = 1 + XCTAssertTrue(msg.hasID) + msg.clearID() + + msg.idNumber = 1 + XCTAssertTrue(msg.hasIDNumber) + msg.clearIDNumber() + + msg.theIDNumber = 1 + XCTAssertTrue(msg.hasTheIDNumber) + msg.clearTheIDNumber() + + msg.requestID = 1 + XCTAssertTrue(msg.hasRequestID) + msg.clearRequestID() + } + + func testUppers() { + var msg = SwiftProtoTesting_Names_FieldNamingInitials.Uppers() + + msg.http = 1 + XCTAssertTrue(msg.hasHTTP) + msg.clearHTTP() + + msg.httpRequest = 1 + XCTAssertTrue(msg.hasHTTPRequest) + msg.clearHTTPRequest() + + msg.theHTTPRequest = 1 + XCTAssertTrue(msg.hasTheHTTPRequest) + msg.clearTheHTTPRequest() + + msg.theHTTP = 1 + XCTAssertTrue(msg.hasTheHTTP) + msg.clearTheHTTP() - msg.https = 1 - XCTAssertTrue(msg.hasHTTPS) - msg.clearHTTPS() + msg.https = 1 + XCTAssertTrue(msg.hasHTTPS) + msg.clearHTTPS() - msg.httpsRequest = 1 - XCTAssertTrue(msg.hasHTTPSRequest) - msg.clearHTTPSRequest() + msg.httpsRequest = 1 + XCTAssertTrue(msg.hasHTTPSRequest) + msg.clearHTTPSRequest() - msg.theHTTPSRequest = 1 - XCTAssertTrue(msg.hasTheHTTPSRequest) - msg.clearTheHTTPSRequest() + msg.theHTTPSRequest = 1 + XCTAssertTrue(msg.hasTheHTTPSRequest) + msg.clearTheHTTPSRequest() - msg.theHTTPS = 1 - XCTAssertTrue(msg.hasTheHTTPS) - msg.clearTheHTTPS() + msg.theHTTPS = 1 + XCTAssertTrue(msg.hasTheHTTPS) + msg.clearTheHTTPS() - msg.url = 1 - XCTAssertTrue(msg.hasURL) - msg.clearURL() + msg.url = 1 + XCTAssertTrue(msg.hasURL) + msg.clearURL() - msg.urlValue = 1 - XCTAssertTrue(msg.hasURLValue) - msg.clearURLValue() + msg.urlValue = 1 + XCTAssertTrue(msg.hasURLValue) + msg.clearURLValue() - msg.theURLValue = 1 - XCTAssertTrue(msg.hasTheURLValue) - msg.clearTheURLValue() + msg.theURLValue = 1 + XCTAssertTrue(msg.hasTheURLValue) + msg.clearTheURLValue() - msg.theURL = 1 - XCTAssertTrue(msg.hasTheURL) - msg.clearTheURL() + msg.theURL = 1 + XCTAssertTrue(msg.hasTheURL) + msg.clearTheURL() - msg.id = 1 - XCTAssertTrue(msg.hasID) - msg.clearID() + msg.id = 1 + XCTAssertTrue(msg.hasID) + msg.clearID() - msg.idNumber = 1 - XCTAssertTrue(msg.hasIDNumber) - msg.clearIDNumber() + msg.idNumber = 1 + XCTAssertTrue(msg.hasIDNumber) + msg.clearIDNumber() - msg.theIDNumber = 1 - XCTAssertTrue(msg.hasTheIDNumber) - msg.clearTheIDNumber() + msg.theIDNumber = 1 + XCTAssertTrue(msg.hasTheIDNumber) + msg.clearTheIDNumber() - msg.requestID = 1 - XCTAssertTrue(msg.hasRequestID) - msg.clearRequestID() - } - - func testWordCase() { - var msg = SwiftUnittest_Names_FieldNamingInitials.WordCase() + msg.requestID = 1 + XCTAssertTrue(msg.hasRequestID) + msg.clearRequestID() + } + + func testWordCase() { + var msg = SwiftProtoTesting_Names_FieldNamingInitials.WordCase() - msg.http = 1 - XCTAssertTrue(msg.hasHTTP) - msg.clearHTTP() + msg.http = 1 + XCTAssertTrue(msg.hasHTTP) + msg.clearHTTP() - msg.httpRequest = 1 - XCTAssertTrue(msg.hasHTTPRequest) - msg.clearHTTPRequest() + msg.httpRequest = 1 + XCTAssertTrue(msg.hasHTTPRequest) + msg.clearHTTPRequest() - msg.theHTTPRequest = 1 - XCTAssertTrue(msg.hasTheHTTPRequest) - msg.clearTheHTTPRequest() + msg.theHTTPRequest = 1 + XCTAssertTrue(msg.hasTheHTTPRequest) + msg.clearTheHTTPRequest() - msg.theHTTP = 1 - XCTAssertTrue(msg.hasTheHTTP) - msg.clearTheHTTP() + msg.theHTTP = 1 + XCTAssertTrue(msg.hasTheHTTP) + msg.clearTheHTTP() - msg.https = 1 - XCTAssertTrue(msg.hasHTTPS) - msg.clearHTTPS() + msg.https = 1 + XCTAssertTrue(msg.hasHTTPS) + msg.clearHTTPS() - msg.httpsRequest = 1 - XCTAssertTrue(msg.hasHTTPSRequest) - msg.clearHTTPSRequest() + msg.httpsRequest = 1 + XCTAssertTrue(msg.hasHTTPSRequest) + msg.clearHTTPSRequest() - msg.theHTTPSRequest = 1 - XCTAssertTrue(msg.hasTheHTTPSRequest) - msg.clearTheHTTPSRequest() + msg.theHTTPSRequest = 1 + XCTAssertTrue(msg.hasTheHTTPSRequest) + msg.clearTheHTTPSRequest() - msg.theHTTPS = 1 - XCTAssertTrue(msg.hasTheHTTPS) - msg.clearTheHTTPS() + msg.theHTTPS = 1 + XCTAssertTrue(msg.hasTheHTTPS) + msg.clearTheHTTPS() - msg.url = 1 - XCTAssertTrue(msg.hasURL) - msg.clearURL() + msg.url = 1 + XCTAssertTrue(msg.hasURL) + msg.clearURL() - msg.urlValue = 1 - XCTAssertTrue(msg.hasURLValue) - msg.clearURLValue() + msg.urlValue = 1 + XCTAssertTrue(msg.hasURLValue) + msg.clearURLValue() - msg.theURLValue = 1 - XCTAssertTrue(msg.hasTheURLValue) - msg.clearTheURLValue() + msg.theURLValue = 1 + XCTAssertTrue(msg.hasTheURLValue) + msg.clearTheURLValue() - msg.theURL = 1 - XCTAssertTrue(msg.hasTheURL) - msg.clearTheURL() + msg.theURL = 1 + XCTAssertTrue(msg.hasTheURL) + msg.clearTheURL() - msg.id = 1 - XCTAssertTrue(msg.hasID) - msg.clearID() + msg.id = 1 + XCTAssertTrue(msg.hasID) + msg.clearID() - msg.idNumber = 1 - XCTAssertTrue(msg.hasIDNumber) - msg.clearIDNumber() + msg.idNumber = 1 + XCTAssertTrue(msg.hasIDNumber) + msg.clearIDNumber() - msg.theIDNumber = 1 - XCTAssertTrue(msg.hasTheIDNumber) - msg.clearTheIDNumber() + msg.theIDNumber = 1 + XCTAssertTrue(msg.hasTheIDNumber) + msg.clearTheIDNumber() - msg.requestID = 1 - XCTAssertTrue(msg.hasRequestID) - msg.clearRequestID() - } + msg.requestID = 1 + XCTAssertTrue(msg.hasRequestID) + msg.clearRequestID() + } } -class Test_ExtensionNamingInitials_MessageScoped: XCTestCase { - func testLowers() { - var msg = SwiftUnittest_Names_ExtensionNamingInitials() +final class Test_ExtensionNamingInitials_MessageScoped: XCTestCase { + func testLowers() { + var msg = SwiftProtoTesting_Names_ExtensionNamingInitials() - msg.SwiftUnittest_Names_Lowers_http = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Lowers_http) - msg.clearSwiftUnittest_Names_Lowers_http() + msg.SwiftProtoTesting_Names_Lowers_http = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Lowers_http) + msg.clearSwiftProtoTesting_Names_Lowers_http() - msg.SwiftUnittest_Names_Lowers_httpRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Lowers_httpRequest) - msg.clearSwiftUnittest_Names_Lowers_httpRequest() + msg.SwiftProtoTesting_Names_Lowers_httpRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Lowers_httpRequest) + msg.clearSwiftProtoTesting_Names_Lowers_httpRequest() - msg.SwiftUnittest_Names_Lowers_theHTTPRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Lowers_theHTTPRequest) - msg.clearSwiftUnittest_Names_Lowers_theHTTPRequest() + msg.SwiftProtoTesting_Names_Lowers_theHTTPRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Lowers_theHTTPRequest) + msg.clearSwiftProtoTesting_Names_Lowers_theHTTPRequest() - msg.SwiftUnittest_Names_Lowers_theHTTP = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Lowers_theHTTP) - msg.clearSwiftUnittest_Names_Lowers_theHTTP() + msg.SwiftProtoTesting_Names_Lowers_theHTTP = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Lowers_theHTTP) + msg.clearSwiftProtoTesting_Names_Lowers_theHTTP() - msg.SwiftUnittest_Names_Lowers_https = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Lowers_https) - msg.clearSwiftUnittest_Names_Lowers_https() + msg.SwiftProtoTesting_Names_Lowers_https = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Lowers_https) + msg.clearSwiftProtoTesting_Names_Lowers_https() - msg.SwiftUnittest_Names_Lowers_httpsRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Lowers_httpsRequest) - msg.clearSwiftUnittest_Names_Lowers_httpsRequest() + msg.SwiftProtoTesting_Names_Lowers_httpsRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Lowers_httpsRequest) + msg.clearSwiftProtoTesting_Names_Lowers_httpsRequest() - msg.SwiftUnittest_Names_Lowers_theHTTPSRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Lowers_theHTTPSRequest) - msg.clearSwiftUnittest_Names_Lowers_theHTTPSRequest() + msg.SwiftProtoTesting_Names_Lowers_theHTTPSRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Lowers_theHTTPSRequest) + msg.clearSwiftProtoTesting_Names_Lowers_theHTTPSRequest() - msg.SwiftUnittest_Names_Lowers_theHTTPS = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Lowers_theHTTPS) - msg.clearSwiftUnittest_Names_Lowers_theHTTPS() + msg.SwiftProtoTesting_Names_Lowers_theHTTPS = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Lowers_theHTTPS) + msg.clearSwiftProtoTesting_Names_Lowers_theHTTPS() - msg.SwiftUnittest_Names_Lowers_url = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Lowers_url) - msg.clearSwiftUnittest_Names_Lowers_url() + msg.SwiftProtoTesting_Names_Lowers_url = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Lowers_url) + msg.clearSwiftProtoTesting_Names_Lowers_url() - msg.SwiftUnittest_Names_Lowers_urlValue = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Lowers_urlValue) - msg.clearSwiftUnittest_Names_Lowers_urlValue() + msg.SwiftProtoTesting_Names_Lowers_urlValue = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Lowers_urlValue) + msg.clearSwiftProtoTesting_Names_Lowers_urlValue() - msg.SwiftUnittest_Names_Lowers_theURLValue = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Lowers_theURLValue) - msg.clearSwiftUnittest_Names_Lowers_theURLValue() + msg.SwiftProtoTesting_Names_Lowers_theURLValue = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Lowers_theURLValue) + msg.clearSwiftProtoTesting_Names_Lowers_theURLValue() - msg.SwiftUnittest_Names_Lowers_theURL = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Lowers_theURL) - msg.clearSwiftUnittest_Names_Lowers_theURL() + msg.SwiftProtoTesting_Names_Lowers_theURL = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Lowers_theURL) + msg.clearSwiftProtoTesting_Names_Lowers_theURL() - msg.SwiftUnittest_Names_Lowers_aBC = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Lowers_aBC) - msg.clearSwiftUnittest_Names_Lowers_aBC() + msg.SwiftProtoTesting_Names_Lowers_aBC = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Lowers_aBC) + msg.clearSwiftProtoTesting_Names_Lowers_aBC() - msg.SwiftUnittest_Names_Lowers_id = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Lowers_id) - msg.clearSwiftUnittest_Names_Lowers_id() + msg.SwiftProtoTesting_Names_Lowers_id = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Lowers_id) + msg.clearSwiftProtoTesting_Names_Lowers_id() - msg.SwiftUnittest_Names_Lowers_idNumber = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Lowers_idNumber) - msg.clearSwiftUnittest_Names_Lowers_idNumber() + msg.SwiftProtoTesting_Names_Lowers_idNumber = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Lowers_idNumber) + msg.clearSwiftProtoTesting_Names_Lowers_idNumber() - msg.SwiftUnittest_Names_Lowers_theIDNumber = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Lowers_theIDNumber) - msg.clearSwiftUnittest_Names_Lowers_theIDNumber() + msg.SwiftProtoTesting_Names_Lowers_theIDNumber = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Lowers_theIDNumber) + msg.clearSwiftProtoTesting_Names_Lowers_theIDNumber() - msg.SwiftUnittest_Names_Lowers_requestID = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Lowers_requestID) - msg.clearSwiftUnittest_Names_Lowers_requestID() - } + msg.SwiftProtoTesting_Names_Lowers_requestID = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Lowers_requestID) + msg.clearSwiftProtoTesting_Names_Lowers_requestID() + } - func testUppers() { - var msg = SwiftUnittest_Names_ExtensionNamingInitials() + func testUppers() { + var msg = SwiftProtoTesting_Names_ExtensionNamingInitials() - msg.SwiftUnittest_Names_Uppers_http = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Uppers_http) - msg.clearSwiftUnittest_Names_Uppers_http() + msg.SwiftProtoTesting_Names_Uppers_http = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Uppers_http) + msg.clearSwiftProtoTesting_Names_Uppers_http() - msg.SwiftUnittest_Names_Uppers_httpRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Uppers_httpRequest) - msg.clearSwiftUnittest_Names_Uppers_httpRequest() + msg.SwiftProtoTesting_Names_Uppers_httpRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Uppers_httpRequest) + msg.clearSwiftProtoTesting_Names_Uppers_httpRequest() - msg.SwiftUnittest_Names_Uppers_theHTTPRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Uppers_theHTTPRequest) - msg.clearSwiftUnittest_Names_Uppers_theHTTPRequest() + msg.SwiftProtoTesting_Names_Uppers_theHTTPRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Uppers_theHTTPRequest) + msg.clearSwiftProtoTesting_Names_Uppers_theHTTPRequest() - msg.SwiftUnittest_Names_Uppers_theHTTP = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Uppers_theHTTP) - msg.clearSwiftUnittest_Names_Uppers_theHTTP() + msg.SwiftProtoTesting_Names_Uppers_theHTTP = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Uppers_theHTTP) + msg.clearSwiftProtoTesting_Names_Uppers_theHTTP() - msg.SwiftUnittest_Names_Uppers_https = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Uppers_https) - msg.clearSwiftUnittest_Names_Uppers_https() + msg.SwiftProtoTesting_Names_Uppers_https = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Uppers_https) + msg.clearSwiftProtoTesting_Names_Uppers_https() - msg.SwiftUnittest_Names_Uppers_httpsRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Uppers_httpsRequest) - msg.clearSwiftUnittest_Names_Uppers_httpsRequest() + msg.SwiftProtoTesting_Names_Uppers_httpsRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Uppers_httpsRequest) + msg.clearSwiftProtoTesting_Names_Uppers_httpsRequest() - msg.SwiftUnittest_Names_Uppers_theHTTPSRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Uppers_theHTTPSRequest) - msg.clearSwiftUnittest_Names_Uppers_theHTTPSRequest() + msg.SwiftProtoTesting_Names_Uppers_theHTTPSRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Uppers_theHTTPSRequest) + msg.clearSwiftProtoTesting_Names_Uppers_theHTTPSRequest() - msg.SwiftUnittest_Names_Uppers_theHTTPS = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Uppers_theHTTPS) - msg.clearSwiftUnittest_Names_Uppers_theHTTPS() + msg.SwiftProtoTesting_Names_Uppers_theHTTPS = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Uppers_theHTTPS) + msg.clearSwiftProtoTesting_Names_Uppers_theHTTPS() - msg.SwiftUnittest_Names_Uppers_url = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Uppers_url) - msg.clearSwiftUnittest_Names_Uppers_url() + msg.SwiftProtoTesting_Names_Uppers_url = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Uppers_url) + msg.clearSwiftProtoTesting_Names_Uppers_url() - msg.SwiftUnittest_Names_Uppers_urlValue = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Uppers_urlValue) - msg.clearSwiftUnittest_Names_Uppers_urlValue() + msg.SwiftProtoTesting_Names_Uppers_urlValue = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Uppers_urlValue) + msg.clearSwiftProtoTesting_Names_Uppers_urlValue() - msg.SwiftUnittest_Names_Uppers_theURLValue = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Uppers_theURLValue) - msg.clearSwiftUnittest_Names_Uppers_theURLValue() + msg.SwiftProtoTesting_Names_Uppers_theURLValue = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Uppers_theURLValue) + msg.clearSwiftProtoTesting_Names_Uppers_theURLValue() - msg.SwiftUnittest_Names_Uppers_theURL = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Uppers_theURL) - msg.clearSwiftUnittest_Names_Uppers_theURL() + msg.SwiftProtoTesting_Names_Uppers_theURL = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Uppers_theURL) + msg.clearSwiftProtoTesting_Names_Uppers_theURL() - msg.SwiftUnittest_Names_Uppers_id = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Uppers_id) - msg.clearSwiftUnittest_Names_Uppers_id() + msg.SwiftProtoTesting_Names_Uppers_id = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Uppers_id) + msg.clearSwiftProtoTesting_Names_Uppers_id() - msg.SwiftUnittest_Names_Uppers_idNumber = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Uppers_idNumber) - msg.clearSwiftUnittest_Names_Uppers_idNumber() + msg.SwiftProtoTesting_Names_Uppers_idNumber = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Uppers_idNumber) + msg.clearSwiftProtoTesting_Names_Uppers_idNumber() - msg.SwiftUnittest_Names_Uppers_theIDNumber = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Uppers_theIDNumber) - msg.clearSwiftUnittest_Names_Uppers_theIDNumber() + msg.SwiftProtoTesting_Names_Uppers_theIDNumber = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Uppers_theIDNumber) + msg.clearSwiftProtoTesting_Names_Uppers_theIDNumber() - msg.SwiftUnittest_Names_Uppers_requestID = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_Uppers_requestID) - msg.clearSwiftUnittest_Names_Uppers_requestID() - } - - func testWordCase() { - var msg = SwiftUnittest_Names_ExtensionNamingInitials() + msg.SwiftProtoTesting_Names_Uppers_requestID = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_Uppers_requestID) + msg.clearSwiftProtoTesting_Names_Uppers_requestID() + } + + func testWordCase() { + var msg = SwiftProtoTesting_Names_ExtensionNamingInitials() - msg.SwiftUnittest_Names_WordCase_http = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_WordCase_http) - msg.clearSwiftUnittest_Names_WordCase_http() + msg.SwiftProtoTesting_Names_WordCase_http = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_WordCase_http) + msg.clearSwiftProtoTesting_Names_WordCase_http() - msg.SwiftUnittest_Names_WordCase_httpRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_WordCase_httpRequest) - msg.clearSwiftUnittest_Names_WordCase_httpRequest() + msg.SwiftProtoTesting_Names_WordCase_httpRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_WordCase_httpRequest) + msg.clearSwiftProtoTesting_Names_WordCase_httpRequest() - msg.SwiftUnittest_Names_WordCase_theHTTPRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_WordCase_theHTTPRequest) - msg.clearSwiftUnittest_Names_WordCase_theHTTPRequest() + msg.SwiftProtoTesting_Names_WordCase_theHTTPRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_WordCase_theHTTPRequest) + msg.clearSwiftProtoTesting_Names_WordCase_theHTTPRequest() - msg.SwiftUnittest_Names_WordCase_theHTTP = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_WordCase_theHTTP) - msg.clearSwiftUnittest_Names_WordCase_theHTTP() + msg.SwiftProtoTesting_Names_WordCase_theHTTP = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_WordCase_theHTTP) + msg.clearSwiftProtoTesting_Names_WordCase_theHTTP() - msg.SwiftUnittest_Names_WordCase_https = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_WordCase_https) - msg.clearSwiftUnittest_Names_WordCase_https() + msg.SwiftProtoTesting_Names_WordCase_https = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_WordCase_https) + msg.clearSwiftProtoTesting_Names_WordCase_https() - msg.SwiftUnittest_Names_WordCase_httpsRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_WordCase_httpsRequest) - msg.clearSwiftUnittest_Names_WordCase_httpsRequest() + msg.SwiftProtoTesting_Names_WordCase_httpsRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_WordCase_httpsRequest) + msg.clearSwiftProtoTesting_Names_WordCase_httpsRequest() - msg.SwiftUnittest_Names_WordCase_theHTTPSRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_WordCase_theHTTPSRequest) - msg.clearSwiftUnittest_Names_WordCase_theHTTPSRequest() + msg.SwiftProtoTesting_Names_WordCase_theHTTPSRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_WordCase_theHTTPSRequest) + msg.clearSwiftProtoTesting_Names_WordCase_theHTTPSRequest() - msg.SwiftUnittest_Names_WordCase_theHTTPS = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_WordCase_theHTTPS) - msg.clearSwiftUnittest_Names_WordCase_theHTTPS() + msg.SwiftProtoTesting_Names_WordCase_theHTTPS = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_WordCase_theHTTPS) + msg.clearSwiftProtoTesting_Names_WordCase_theHTTPS() - msg.SwiftUnittest_Names_WordCase_url = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_WordCase_url) - msg.clearSwiftUnittest_Names_WordCase_url() + msg.SwiftProtoTesting_Names_WordCase_url = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_WordCase_url) + msg.clearSwiftProtoTesting_Names_WordCase_url() - msg.SwiftUnittest_Names_WordCase_urlValue = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_WordCase_urlValue) - msg.clearSwiftUnittest_Names_WordCase_urlValue() + msg.SwiftProtoTesting_Names_WordCase_urlValue = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_WordCase_urlValue) + msg.clearSwiftProtoTesting_Names_WordCase_urlValue() - msg.SwiftUnittest_Names_WordCase_theURLValue = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_WordCase_theURLValue) - msg.clearSwiftUnittest_Names_WordCase_theURLValue() + msg.SwiftProtoTesting_Names_WordCase_theURLValue = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_WordCase_theURLValue) + msg.clearSwiftProtoTesting_Names_WordCase_theURLValue() - msg.SwiftUnittest_Names_WordCase_theURL = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_WordCase_theURL) - msg.clearSwiftUnittest_Names_WordCase_theURL() + msg.SwiftProtoTesting_Names_WordCase_theURL = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_WordCase_theURL) + msg.clearSwiftProtoTesting_Names_WordCase_theURL() - msg.SwiftUnittest_Names_WordCase_id = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_WordCase_id) - msg.clearSwiftUnittest_Names_WordCase_id() + msg.SwiftProtoTesting_Names_WordCase_id = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_WordCase_id) + msg.clearSwiftProtoTesting_Names_WordCase_id() - msg.SwiftUnittest_Names_WordCase_idNumber = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_WordCase_idNumber) - msg.clearSwiftUnittest_Names_WordCase_idNumber() + msg.SwiftProtoTesting_Names_WordCase_idNumber = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_WordCase_idNumber) + msg.clearSwiftProtoTesting_Names_WordCase_idNumber() - msg.SwiftUnittest_Names_WordCase_theIDNumber = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_WordCase_theIDNumber) - msg.clearSwiftUnittest_Names_WordCase_theIDNumber() + msg.SwiftProtoTesting_Names_WordCase_theIDNumber = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_WordCase_theIDNumber) + msg.clearSwiftProtoTesting_Names_WordCase_theIDNumber() - msg.SwiftUnittest_Names_WordCase_requestID = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_WordCase_requestID) - msg.clearSwiftUnittest_Names_WordCase_requestID() - } + msg.SwiftProtoTesting_Names_WordCase_requestID = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_WordCase_requestID) + msg.clearSwiftProtoTesting_Names_WordCase_requestID() + } } -class Test_ExtensionNamingInitials_GlobalScoped: XCTestCase { - func testLowers() { - var msg = SwiftUnittest_Names_ExtensionNamingInitialsLowers() +final class Test_ExtensionNamingInitials_GlobalScoped: XCTestCase { + func testLowers() { + var msg = SwiftProtoTesting_Names_ExtensionNamingInitialsLowers() - msg.SwiftUnittest_Names_http = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_http) - msg.clearSwiftUnittest_Names_http() + msg.SwiftProtoTesting_Names_http = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_http) + msg.clearSwiftProtoTesting_Names_http() - msg.SwiftUnittest_Names_httpRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_httpRequest) - msg.clearSwiftUnittest_Names_httpRequest() + msg.SwiftProtoTesting_Names_httpRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_httpRequest) + msg.clearSwiftProtoTesting_Names_httpRequest() - msg.SwiftUnittest_Names_theHTTPRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theHTTPRequest) - msg.clearSwiftUnittest_Names_theHTTPRequest() + msg.SwiftProtoTesting_Names_theHTTPRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theHTTPRequest) + msg.clearSwiftProtoTesting_Names_theHTTPRequest() - msg.SwiftUnittest_Names_theHTTP = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theHTTP) - msg.clearSwiftUnittest_Names_theHTTP() + msg.SwiftProtoTesting_Names_theHTTP = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theHTTP) + msg.clearSwiftProtoTesting_Names_theHTTP() - msg.SwiftUnittest_Names_https = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_https) - msg.clearSwiftUnittest_Names_https() + msg.SwiftProtoTesting_Names_https = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_https) + msg.clearSwiftProtoTesting_Names_https() - msg.SwiftUnittest_Names_httpsRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_httpsRequest) - msg.clearSwiftUnittest_Names_httpsRequest() + msg.SwiftProtoTesting_Names_httpsRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_httpsRequest) + msg.clearSwiftProtoTesting_Names_httpsRequest() - msg.SwiftUnittest_Names_theHTTPSRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theHTTPSRequest) - msg.clearSwiftUnittest_Names_theHTTPSRequest() + msg.SwiftProtoTesting_Names_theHTTPSRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theHTTPSRequest) + msg.clearSwiftProtoTesting_Names_theHTTPSRequest() - msg.SwiftUnittest_Names_theHTTPS = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theHTTPS) - msg.clearSwiftUnittest_Names_theHTTPS() + msg.SwiftProtoTesting_Names_theHTTPS = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theHTTPS) + msg.clearSwiftProtoTesting_Names_theHTTPS() - msg.SwiftUnittest_Names_url = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_url) - msg.clearSwiftUnittest_Names_url() + msg.SwiftProtoTesting_Names_url = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_url) + msg.clearSwiftProtoTesting_Names_url() - msg.SwiftUnittest_Names_urlValue = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_urlValue) - msg.clearSwiftUnittest_Names_urlValue() + msg.SwiftProtoTesting_Names_urlValue = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_urlValue) + msg.clearSwiftProtoTesting_Names_urlValue() - msg.SwiftUnittest_Names_theURLValue = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theURLValue) - msg.clearSwiftUnittest_Names_theURLValue() + msg.SwiftProtoTesting_Names_theURLValue = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theURLValue) + msg.clearSwiftProtoTesting_Names_theURLValue() - msg.SwiftUnittest_Names_theURL = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theURL) - msg.clearSwiftUnittest_Names_theURL() + msg.SwiftProtoTesting_Names_theURL = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theURL) + msg.clearSwiftProtoTesting_Names_theURL() - msg.SwiftUnittest_Names_aBC = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_aBC) - msg.clearSwiftUnittest_Names_aBC() + msg.SwiftProtoTesting_Names_aBC = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_aBC) + msg.clearSwiftProtoTesting_Names_aBC() - msg.SwiftUnittest_Names_id = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_id) - msg.clearSwiftUnittest_Names_id() + msg.SwiftProtoTesting_Names_id = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_id) + msg.clearSwiftProtoTesting_Names_id() - msg.SwiftUnittest_Names_idNumber = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_idNumber) - msg.clearSwiftUnittest_Names_idNumber() + msg.SwiftProtoTesting_Names_idNumber = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_idNumber) + msg.clearSwiftProtoTesting_Names_idNumber() - msg.SwiftUnittest_Names_theIDNumber = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theIDNumber) - msg.clearSwiftUnittest_Names_theIDNumber() + msg.SwiftProtoTesting_Names_theIDNumber = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theIDNumber) + msg.clearSwiftProtoTesting_Names_theIDNumber() - msg.SwiftUnittest_Names_requestID = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_requestID) - msg.clearSwiftUnittest_Names_requestID() - } + msg.SwiftProtoTesting_Names_requestID = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_requestID) + msg.clearSwiftProtoTesting_Names_requestID() + } - func testUppers() { - var msg = SwiftUnittest_Names_ExtensionNamingInitialsUppers() + func testUppers() { + var msg = SwiftProtoTesting_Names_ExtensionNamingInitialsUppers() - msg.SwiftUnittest_Names_http = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_http) - msg.clearSwiftUnittest_Names_http() + msg.SwiftProtoTesting_Names_http = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_http) + msg.clearSwiftProtoTesting_Names_http() - msg.SwiftUnittest_Names_httpRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_httpRequest) - msg.clearSwiftUnittest_Names_httpRequest() + msg.SwiftProtoTesting_Names_httpRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_httpRequest) + msg.clearSwiftProtoTesting_Names_httpRequest() - msg.SwiftUnittest_Names_theHTTPRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theHTTPRequest) - msg.clearSwiftUnittest_Names_theHTTPRequest() + msg.SwiftProtoTesting_Names_theHTTPRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theHTTPRequest) + msg.clearSwiftProtoTesting_Names_theHTTPRequest() - msg.SwiftUnittest_Names_theHTTP = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theHTTP) - msg.clearSwiftUnittest_Names_theHTTP() + msg.SwiftProtoTesting_Names_theHTTP = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theHTTP) + msg.clearSwiftProtoTesting_Names_theHTTP() - msg.SwiftUnittest_Names_https = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_https) - msg.clearSwiftUnittest_Names_https() + msg.SwiftProtoTesting_Names_https = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_https) + msg.clearSwiftProtoTesting_Names_https() - msg.SwiftUnittest_Names_httpsRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_httpsRequest) - msg.clearSwiftUnittest_Names_httpsRequest() + msg.SwiftProtoTesting_Names_httpsRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_httpsRequest) + msg.clearSwiftProtoTesting_Names_httpsRequest() - msg.SwiftUnittest_Names_theHTTPSRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theHTTPSRequest) - msg.clearSwiftUnittest_Names_theHTTPSRequest() + msg.SwiftProtoTesting_Names_theHTTPSRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theHTTPSRequest) + msg.clearSwiftProtoTesting_Names_theHTTPSRequest() - msg.SwiftUnittest_Names_theHTTPS = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theHTTPS) - msg.clearSwiftUnittest_Names_theHTTPS() + msg.SwiftProtoTesting_Names_theHTTPS = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theHTTPS) + msg.clearSwiftProtoTesting_Names_theHTTPS() - msg.SwiftUnittest_Names_url = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_url) - msg.clearSwiftUnittest_Names_url() + msg.SwiftProtoTesting_Names_url = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_url) + msg.clearSwiftProtoTesting_Names_url() - msg.SwiftUnittest_Names_urlValue = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_urlValue) - msg.clearSwiftUnittest_Names_urlValue() + msg.SwiftProtoTesting_Names_urlValue = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_urlValue) + msg.clearSwiftProtoTesting_Names_urlValue() - msg.SwiftUnittest_Names_theURLValue = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theURLValue) - msg.clearSwiftUnittest_Names_theURLValue() + msg.SwiftProtoTesting_Names_theURLValue = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theURLValue) + msg.clearSwiftProtoTesting_Names_theURLValue() - msg.SwiftUnittest_Names_theURL = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theURL) - msg.clearSwiftUnittest_Names_theURL() + msg.SwiftProtoTesting_Names_theURL = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theURL) + msg.clearSwiftProtoTesting_Names_theURL() - msg.SwiftUnittest_Names_idNumber = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_idNumber) - msg.clearSwiftUnittest_Names_idNumber() + msg.SwiftProtoTesting_Names_idNumber = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_idNumber) + msg.clearSwiftProtoTesting_Names_idNumber() - msg.SwiftUnittest_Names_theIDNumber = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theIDNumber) - msg.clearSwiftUnittest_Names_theIDNumber() + msg.SwiftProtoTesting_Names_theIDNumber = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theIDNumber) + msg.clearSwiftProtoTesting_Names_theIDNumber() - msg.SwiftUnittest_Names_requestID = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_requestID) - msg.clearSwiftUnittest_Names_requestID() - } - - func testWordCase() { - var msg = SwiftUnittest_Names_ExtensionNamingInitialsWordCase() + msg.SwiftProtoTesting_Names_requestID = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_requestID) + msg.clearSwiftProtoTesting_Names_requestID() + } + + func testWordCase() { + var msg = SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase() - msg.SwiftUnittest_Names_http = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_http) - msg.clearSwiftUnittest_Names_http() + msg.SwiftProtoTesting_Names_http = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_http) + msg.clearSwiftProtoTesting_Names_http() - msg.SwiftUnittest_Names_httpRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_httpRequest) - msg.clearSwiftUnittest_Names_httpRequest() + msg.SwiftProtoTesting_Names_httpRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_httpRequest) + msg.clearSwiftProtoTesting_Names_httpRequest() - msg.SwiftUnittest_Names_theHTTPRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theHTTPRequest) - msg.clearSwiftUnittest_Names_theHTTPRequest() + msg.SwiftProtoTesting_Names_theHTTPRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theHTTPRequest) + msg.clearSwiftProtoTesting_Names_theHTTPRequest() - msg.SwiftUnittest_Names_theHTTP = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theHTTP) - msg.clearSwiftUnittest_Names_theHTTP() + msg.SwiftProtoTesting_Names_theHTTP = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theHTTP) + msg.clearSwiftProtoTesting_Names_theHTTP() - msg.SwiftUnittest_Names_https = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_https) - msg.clearSwiftUnittest_Names_https() + msg.SwiftProtoTesting_Names_https = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_https) + msg.clearSwiftProtoTesting_Names_https() - msg.SwiftUnittest_Names_httpsRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_httpsRequest) - msg.clearSwiftUnittest_Names_httpsRequest() + msg.SwiftProtoTesting_Names_httpsRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_httpsRequest) + msg.clearSwiftProtoTesting_Names_httpsRequest() - msg.SwiftUnittest_Names_theHTTPSRequest = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theHTTPSRequest) - msg.clearSwiftUnittest_Names_theHTTPSRequest() + msg.SwiftProtoTesting_Names_theHTTPSRequest = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theHTTPSRequest) + msg.clearSwiftProtoTesting_Names_theHTTPSRequest() - msg.SwiftUnittest_Names_theHTTPS = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theHTTPS) - msg.clearSwiftUnittest_Names_theHTTPS() + msg.SwiftProtoTesting_Names_theHTTPS = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theHTTPS) + msg.clearSwiftProtoTesting_Names_theHTTPS() - msg.SwiftUnittest_Names_url = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_url) - msg.clearSwiftUnittest_Names_url() + msg.SwiftProtoTesting_Names_url = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_url) + msg.clearSwiftProtoTesting_Names_url() - msg.SwiftUnittest_Names_urlValue = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_urlValue) - msg.clearSwiftUnittest_Names_urlValue() + msg.SwiftProtoTesting_Names_urlValue = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_urlValue) + msg.clearSwiftProtoTesting_Names_urlValue() - msg.SwiftUnittest_Names_theURLValue = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theURLValue) - msg.clearSwiftUnittest_Names_theURLValue() + msg.SwiftProtoTesting_Names_theURLValue = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theURLValue) + msg.clearSwiftProtoTesting_Names_theURLValue() - msg.SwiftUnittest_Names_theURL = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theURL) - msg.clearSwiftUnittest_Names_theURL() + msg.SwiftProtoTesting_Names_theURL = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theURL) + msg.clearSwiftProtoTesting_Names_theURL() - msg.SwiftUnittest_Names_idNumber = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_idNumber) - msg.clearSwiftUnittest_Names_idNumber() + msg.SwiftProtoTesting_Names_idNumber = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_idNumber) + msg.clearSwiftProtoTesting_Names_idNumber() - msg.SwiftUnittest_Names_theIDNumber = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_theIDNumber) - msg.clearSwiftUnittest_Names_theIDNumber() + msg.SwiftProtoTesting_Names_theIDNumber = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_theIDNumber) + msg.clearSwiftProtoTesting_Names_theIDNumber() - msg.SwiftUnittest_Names_requestID = 1 - XCTAssertTrue(msg.hasSwiftUnittest_Names_requestID) - msg.clearSwiftUnittest_Names_requestID() - } + msg.SwiftProtoTesting_Names_requestID = 1 + XCTAssertTrue(msg.hasSwiftProtoTesting_Names_requestID) + msg.clearSwiftProtoTesting_Names_requestID() + } } -class Test_ExtensionNamingInitials_GlobalScoped_NoPrefix: XCTestCase { - func testLowers() { - var msg = SwiftUnittest_Names_ExtensionNamingInitialsLowers() +final class Test_ExtensionNamingInitials_GlobalScoped_NoPrefix: XCTestCase { + func testLowers() { + var msg = SwiftProtoTesting_Names_ExtensionNamingInitialsLowers() - msg.http = 1 - XCTAssertTrue(msg.hasHTTP) - msg.clearHTTP() + msg.http = 1 + XCTAssertTrue(msg.hasHTTP) + msg.clearHTTP() - msg.httpRequest = 1 - XCTAssertTrue(msg.hasHTTPRequest) - msg.clearHTTPRequest() + msg.httpRequest = 1 + XCTAssertTrue(msg.hasHTTPRequest) + msg.clearHTTPRequest() - msg.theHTTPRequest = 1 - XCTAssertTrue(msg.hasTheHTTPRequest) - msg.clearTheHTTPRequest() + msg.theHTTPRequest = 1 + XCTAssertTrue(msg.hasTheHTTPRequest) + msg.clearTheHTTPRequest() - msg.theHTTP = 1 - XCTAssertTrue(msg.hasTheHTTP) - msg.clearTheHTTP() + msg.theHTTP = 1 + XCTAssertTrue(msg.hasTheHTTP) + msg.clearTheHTTP() - msg.https = 1 - XCTAssertTrue(msg.hasHTTPS) - msg.clearHTTPS() + msg.https = 1 + XCTAssertTrue(msg.hasHTTPS) + msg.clearHTTPS() - msg.httpsRequest = 1 - XCTAssertTrue(msg.hasHTTPSRequest) - msg.clearHTTPSRequest() + msg.httpsRequest = 1 + XCTAssertTrue(msg.hasHTTPSRequest) + msg.clearHTTPSRequest() - msg.theHTTPSRequest = 1 - XCTAssertTrue(msg.hasTheHTTPSRequest) - msg.clearTheHTTPSRequest() + msg.theHTTPSRequest = 1 + XCTAssertTrue(msg.hasTheHTTPSRequest) + msg.clearTheHTTPSRequest() - msg.theHTTPS = 1 - XCTAssertTrue(msg.hasTheHTTPS) - msg.clearTheHTTPS() + msg.theHTTPS = 1 + XCTAssertTrue(msg.hasTheHTTPS) + msg.clearTheHTTPS() - msg.url = 1 - XCTAssertTrue(msg.hasURL) - msg.clearURL() + msg.url = 1 + XCTAssertTrue(msg.hasURL) + msg.clearURL() - msg.urlValue = 1 - XCTAssertTrue(msg.hasURLValue) - msg.clearURLValue() + msg.urlValue = 1 + XCTAssertTrue(msg.hasURLValue) + msg.clearURLValue() - msg.theURLValue = 1 - XCTAssertTrue(msg.hasTheURLValue) - msg.clearTheURLValue() + msg.theURLValue = 1 + XCTAssertTrue(msg.hasTheURLValue) + msg.clearTheURLValue() - msg.theURL = 1 - XCTAssertTrue(msg.hasTheURL) - msg.clearTheURL() + msg.theURL = 1 + XCTAssertTrue(msg.hasTheURL) + msg.clearTheURL() - msg.aBC = 1 - XCTAssertTrue(msg.hasABC) - msg.clearABC() + msg.aBC = 1 + XCTAssertTrue(msg.hasABC) + msg.clearABC() - msg.id = 1 - XCTAssertTrue(msg.hasID) - msg.clearID() + msg.id = 1 + XCTAssertTrue(msg.hasID) + msg.clearID() - msg.idNumber = 1 - XCTAssertTrue(msg.hasIDNumber) - msg.clearIDNumber() + msg.idNumber = 1 + XCTAssertTrue(msg.hasIDNumber) + msg.clearIDNumber() - msg.theIDNumber = 1 - XCTAssertTrue(msg.hasTheIDNumber) - msg.clearTheIDNumber() + msg.theIDNumber = 1 + XCTAssertTrue(msg.hasTheIDNumber) + msg.clearTheIDNumber() - msg.requestID = 1 - XCTAssertTrue(msg.hasRequestID) - msg.clearRequestID() - } + msg.requestID = 1 + XCTAssertTrue(msg.hasRequestID) + msg.clearRequestID() + } - func testUppers() { - var msg = SwiftUnittest_Names_ExtensionNamingInitialsUppers() + func testUppers() { + var msg = SwiftProtoTesting_Names_ExtensionNamingInitialsUppers() - msg.http = 1 - XCTAssertTrue(msg.hasHTTP) - msg.clearHTTP() + msg.http = 1 + XCTAssertTrue(msg.hasHTTP) + msg.clearHTTP() - msg.httpRequest = 1 - XCTAssertTrue(msg.hasHTTPRequest) - msg.clearHTTPRequest() + msg.httpRequest = 1 + XCTAssertTrue(msg.hasHTTPRequest) + msg.clearHTTPRequest() - msg.theHTTPRequest = 1 - XCTAssertTrue(msg.hasTheHTTPRequest) - msg.clearTheHTTPRequest() + msg.theHTTPRequest = 1 + XCTAssertTrue(msg.hasTheHTTPRequest) + msg.clearTheHTTPRequest() - msg.theHTTP = 1 - XCTAssertTrue(msg.hasTheHTTP) - msg.clearTheHTTP() + msg.theHTTP = 1 + XCTAssertTrue(msg.hasTheHTTP) + msg.clearTheHTTP() - msg.https = 1 - XCTAssertTrue(msg.hasHTTPS) - msg.clearHTTPS() + msg.https = 1 + XCTAssertTrue(msg.hasHTTPS) + msg.clearHTTPS() - msg.httpsRequest = 1 - XCTAssertTrue(msg.hasHTTPSRequest) - msg.clearHTTPSRequest() + msg.httpsRequest = 1 + XCTAssertTrue(msg.hasHTTPSRequest) + msg.clearHTTPSRequest() - msg.theHTTPSRequest = 1 - XCTAssertTrue(msg.hasTheHTTPSRequest) - msg.clearTheHTTPSRequest() + msg.theHTTPSRequest = 1 + XCTAssertTrue(msg.hasTheHTTPSRequest) + msg.clearTheHTTPSRequest() - msg.theHTTPS = 1 - XCTAssertTrue(msg.hasTheHTTPS) - msg.clearTheHTTPS() + msg.theHTTPS = 1 + XCTAssertTrue(msg.hasTheHTTPS) + msg.clearTheHTTPS() - msg.url = 1 - XCTAssertTrue(msg.hasURL) - msg.clearURL() + msg.url = 1 + XCTAssertTrue(msg.hasURL) + msg.clearURL() - msg.urlValue = 1 - XCTAssertTrue(msg.hasURLValue) - msg.clearURLValue() + msg.urlValue = 1 + XCTAssertTrue(msg.hasURLValue) + msg.clearURLValue() - msg.theURLValue = 1 - XCTAssertTrue(msg.hasTheURLValue) - msg.clearTheURLValue() + msg.theURLValue = 1 + XCTAssertTrue(msg.hasTheURLValue) + msg.clearTheURLValue() - msg.theURL = 1 - XCTAssertTrue(msg.hasTheURL) - msg.clearTheURL() + msg.theURL = 1 + XCTAssertTrue(msg.hasTheURL) + msg.clearTheURL() - msg.id = 1 - XCTAssertTrue(msg.hasID) - msg.clearID() + msg.id = 1 + XCTAssertTrue(msg.hasID) + msg.clearID() - msg.idNumber = 1 - XCTAssertTrue(msg.hasIDNumber) - msg.clearIDNumber() + msg.idNumber = 1 + XCTAssertTrue(msg.hasIDNumber) + msg.clearIDNumber() - msg.theIDNumber = 1 - XCTAssertTrue(msg.hasTheIDNumber) - msg.clearTheIDNumber() + msg.theIDNumber = 1 + XCTAssertTrue(msg.hasTheIDNumber) + msg.clearTheIDNumber() - msg.requestID = 1 - XCTAssertTrue(msg.hasRequestID) - msg.clearRequestID() - } - - func testWordCase() { - var msg = SwiftUnittest_Names_ExtensionNamingInitialsWordCase() + msg.requestID = 1 + XCTAssertTrue(msg.hasRequestID) + msg.clearRequestID() + } + + func testWordCase() { + var msg = SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase() - msg.http = 1 - XCTAssertTrue(msg.hasHTTP) - msg.clearHTTP() + msg.http = 1 + XCTAssertTrue(msg.hasHTTP) + msg.clearHTTP() - msg.httpRequest = 1 - XCTAssertTrue(msg.hasHTTPRequest) - msg.clearHTTPRequest() + msg.httpRequest = 1 + XCTAssertTrue(msg.hasHTTPRequest) + msg.clearHTTPRequest() - msg.theHTTPRequest = 1 - XCTAssertTrue(msg.hasTheHTTPRequest) - msg.clearTheHTTPRequest() + msg.theHTTPRequest = 1 + XCTAssertTrue(msg.hasTheHTTPRequest) + msg.clearTheHTTPRequest() - msg.theHTTP = 1 - XCTAssertTrue(msg.hasTheHTTP) - msg.clearTheHTTP() + msg.theHTTP = 1 + XCTAssertTrue(msg.hasTheHTTP) + msg.clearTheHTTP() - msg.https = 1 - XCTAssertTrue(msg.hasHTTPS) - msg.clearHTTPS() + msg.https = 1 + XCTAssertTrue(msg.hasHTTPS) + msg.clearHTTPS() - msg.httpsRequest = 1 - XCTAssertTrue(msg.hasHTTPSRequest) - msg.clearHTTPSRequest() + msg.httpsRequest = 1 + XCTAssertTrue(msg.hasHTTPSRequest) + msg.clearHTTPSRequest() - msg.theHTTPSRequest = 1 - XCTAssertTrue(msg.hasTheHTTPSRequest) - msg.clearTheHTTPSRequest() + msg.theHTTPSRequest = 1 + XCTAssertTrue(msg.hasTheHTTPSRequest) + msg.clearTheHTTPSRequest() - msg.theHTTPS = 1 - XCTAssertTrue(msg.hasTheHTTPS) - msg.clearTheHTTPS() + msg.theHTTPS = 1 + XCTAssertTrue(msg.hasTheHTTPS) + msg.clearTheHTTPS() - msg.url = 1 - XCTAssertTrue(msg.hasURL) - msg.clearURL() + msg.url = 1 + XCTAssertTrue(msg.hasURL) + msg.clearURL() - msg.urlValue = 1 - XCTAssertTrue(msg.hasURLValue) - msg.clearURLValue() + msg.urlValue = 1 + XCTAssertTrue(msg.hasURLValue) + msg.clearURLValue() - msg.theURLValue = 1 - XCTAssertTrue(msg.hasTheURLValue) - msg.clearTheURLValue() + msg.theURLValue = 1 + XCTAssertTrue(msg.hasTheURLValue) + msg.clearTheURLValue() - msg.theURL = 1 - XCTAssertTrue(msg.hasTheURL) - msg.clearTheURL() + msg.theURL = 1 + XCTAssertTrue(msg.hasTheURL) + msg.clearTheURL() - msg.id = 1 - XCTAssertTrue(msg.hasID) - msg.clearID() + msg.id = 1 + XCTAssertTrue(msg.hasID) + msg.clearID() - msg.idNumber = 1 - XCTAssertTrue(msg.hasIDNumber) - msg.clearIDNumber() + msg.idNumber = 1 + XCTAssertTrue(msg.hasIDNumber) + msg.clearIDNumber() - msg.theIDNumber = 1 - XCTAssertTrue(msg.hasTheIDNumber) - msg.clearTheIDNumber() + msg.theIDNumber = 1 + XCTAssertTrue(msg.hasTheIDNumber) + msg.clearTheIDNumber() - msg.requestID = 1 - XCTAssertTrue(msg.hasRequestID) - msg.clearRequestID() - } + msg.requestID = 1 + XCTAssertTrue(msg.hasRequestID) + msg.clearRequestID() + } } -class Test_ValidIdentifiers: XCTestCase { - func testFieldNames() { - let msg = SwiftUnittest_Names_ValidIdentifiers() - XCTAssertEqual(msg._1Field, 0) - XCTAssertFalse(msg.has_1Field) - XCTAssertEqual(msg.field, 0) - XCTAssertFalse(msg.hasField) - XCTAssertEqual(msg._3Field3, 0) - XCTAssertFalse(msg.has_3Field3) - } - - func testOneofNames() { - var msg = SwiftUnittest_Names_ValidIdentifiers() - XCTAssertEqual(msg._2Of, nil) - - XCTAssertEqual(msg._4, 0) - XCTAssertEqual(msg._5Field, 0) - - msg._2Of = ._4(20) - - XCTAssertEqual(msg._2Of, SwiftUnittest_Names_ValidIdentifiers.OneOf__2Of._4(20)) - XCTAssertEqual(msg._4, 20) - } - - func testEnumCaseNames() { - var msg = SwiftUnittest_Names_ValidIdentifiers() - msg.enumField = .testEnum0 - msg.enumField = .first - msg.enumField = ._2 - msg.enumField = ._3Value - } +final class Test_ValidIdentifiers: XCTestCase { + func testFieldNames() { + let msg = SwiftProtoTesting_Names_ValidIdentifiers() + XCTAssertEqual(msg._1Field, 0) + XCTAssertFalse(msg.has_1Field) + XCTAssertEqual(msg.field, 0) + XCTAssertFalse(msg.hasField) + XCTAssertEqual(msg._3Field3, 0) + XCTAssertFalse(msg.has_3Field3) + } + + func testOneofNames() { + var msg = SwiftProtoTesting_Names_ValidIdentifiers() + XCTAssertEqual(msg._2Of, nil) + + XCTAssertEqual(msg._4, 0) + XCTAssertEqual(msg._5Field, 0) + + msg._2Of = ._4(20) + + XCTAssertEqual(msg._2Of, SwiftProtoTesting_Names_ValidIdentifiers.OneOf__2Of._4(20)) + XCTAssertEqual(msg._4, 20) + } + + func testEnumCaseNames() { + var msg = SwiftProtoTesting_Names_ValidIdentifiers() + msg.enumField = .testEnum0 + msg.enumField = .first + msg.enumField = ._2 + msg.enumField = ._3Value + } } diff --git a/Tests/SwiftProtobufTests/Test_OneofFields_Access_Proto2.swift b/Tests/SwiftProtobufTests/Test_OneofFields_Access_Proto2.swift index d34688d03..316c5ed0d 100644 --- a/Tests/SwiftProtobufTests/Test_OneofFields_Access_Proto2.swift +++ b/Tests/SwiftProtobufTests/Test_OneofFields_Access_Proto2.swift @@ -12,564 +12,564 @@ /// // ----------------------------------------------------------------------------- -import XCTest import Foundation +import XCTest // NOTE: The generator changes what is generated based on the number/types // of fields (using a nested storage class or not), to be completel, all // these tests should be done once with a message that gets that storage // class and a second time with messages that avoid that. -class Test_OneofFields_Access_Proto2: XCTestCase { - - // Accessing one field. - // - Returns default - // - Accepts/Captures value - // - Resets - // - Accepts/Captures default value - - func testOneofInt32() { - var msg = ProtobufUnittest_Message2() - XCTAssertEqual(msg.oneofInt32, 100) - XCTAssertNil(msg.o) - msg.oneofInt32 = 51 - XCTAssertEqual(msg.oneofInt32, 51) - XCTAssertEqual(msg.o, .oneofInt32(51)) - msg.o = nil - XCTAssertEqual(msg.oneofInt32, 100) - XCTAssertNil(msg.o) - msg.oneofInt32 = 100 - XCTAssertEqual(msg.oneofInt32, 100) - XCTAssertEqual(msg.o, .oneofInt32(100)) - } +final class Test_OneofFields_Access_Proto2: XCTestCase { - func testOneofInt64() { - var msg = ProtobufUnittest_Message2() - XCTAssertEqual(msg.oneofInt64, 101) - XCTAssertNil(msg.o) - msg.oneofInt64 = 52 - XCTAssertEqual(msg.oneofInt64, 52) - XCTAssertEqual(msg.o, .oneofInt64(52)) - msg.o = nil - XCTAssertEqual(msg.oneofInt64, 101) - XCTAssertNil(msg.o) - msg.oneofInt64 = 101 - XCTAssertEqual(msg.oneofInt64, 101) - XCTAssertEqual(msg.o, .oneofInt64(101)) - } + // Accessing one field. + // - Returns default + // - Accepts/Captures value + // - Resets + // - Accepts/Captures default value - func testOneofUint32() { - var msg = ProtobufUnittest_Message2() - XCTAssertEqual(msg.oneofUint32, 102) - XCTAssertNil(msg.o) - msg.oneofUint32 = 53 - XCTAssertEqual(msg.oneofUint32, 53) - XCTAssertEqual(msg.o, .oneofUint32(53)) - msg.o = nil - XCTAssertEqual(msg.oneofUint32, 102) - XCTAssertNil(msg.o) - msg.oneofUint32 = 102 - XCTAssertEqual(msg.oneofUint32, 102) - XCTAssertEqual(msg.o, .oneofUint32(102)) - } - - func testOneofUint64() { - var msg = ProtobufUnittest_Message2() - XCTAssertEqual(msg.oneofUint64, 103) - XCTAssertNil(msg.o) - msg.oneofUint64 = 54 - XCTAssertEqual(msg.oneofUint64, 54) - XCTAssertEqual(msg.o, .oneofUint64(54)) - msg.o = nil - XCTAssertEqual(msg.oneofUint64, 103) - XCTAssertNil(msg.o) - msg.oneofUint64 = 103 - XCTAssertEqual(msg.oneofUint64, 103) - XCTAssertEqual(msg.o, .oneofUint64(103)) - } + func testOneofInt32() { + var msg = SwiftProtoTesting_Message2() + XCTAssertEqual(msg.oneofInt32, 100) + XCTAssertNil(msg.o) + msg.oneofInt32 = 51 + XCTAssertEqual(msg.oneofInt32, 51) + XCTAssertEqual(msg.o, .oneofInt32(51)) + msg.o = nil + XCTAssertEqual(msg.oneofInt32, 100) + XCTAssertNil(msg.o) + msg.oneofInt32 = 100 + XCTAssertEqual(msg.oneofInt32, 100) + XCTAssertEqual(msg.o, .oneofInt32(100)) + } - func testOneofSint32() { - var msg = ProtobufUnittest_Message2() - XCTAssertEqual(msg.oneofSint32, 104) - XCTAssertNil(msg.o) - msg.oneofSint32 = 55 - XCTAssertEqual(msg.oneofSint32, 55) - XCTAssertEqual(msg.o, .oneofSint32(55)) - msg.o = nil - XCTAssertEqual(msg.oneofSint32, 104) - XCTAssertNil(msg.o) - msg.oneofSint32 = 104 - XCTAssertEqual(msg.oneofSint32, 104) - XCTAssertEqual(msg.o, .oneofSint32(104)) - } + func testOneofInt64() { + var msg = SwiftProtoTesting_Message2() + XCTAssertEqual(msg.oneofInt64, 101) + XCTAssertNil(msg.o) + msg.oneofInt64 = 52 + XCTAssertEqual(msg.oneofInt64, 52) + XCTAssertEqual(msg.o, .oneofInt64(52)) + msg.o = nil + XCTAssertEqual(msg.oneofInt64, 101) + XCTAssertNil(msg.o) + msg.oneofInt64 = 101 + XCTAssertEqual(msg.oneofInt64, 101) + XCTAssertEqual(msg.o, .oneofInt64(101)) + } - func testOneofSint64() { - var msg = ProtobufUnittest_Message2() - XCTAssertEqual(msg.oneofSint64, 105) - XCTAssertNil(msg.o) - msg.oneofSint64 = 56 - XCTAssertEqual(msg.oneofSint64, 56) - XCTAssertEqual(msg.o, .oneofSint64(56)) - msg.o = nil - XCTAssertEqual(msg.oneofSint64, 105) - XCTAssertNil(msg.o) - msg.oneofSint64 = 105 - XCTAssertEqual(msg.oneofSint64, 105) - XCTAssertEqual(msg.o, .oneofSint64(105)) - } + func testOneofUint32() { + var msg = SwiftProtoTesting_Message2() + XCTAssertEqual(msg.oneofUint32, 102) + XCTAssertNil(msg.o) + msg.oneofUint32 = 53 + XCTAssertEqual(msg.oneofUint32, 53) + XCTAssertEqual(msg.o, .oneofUint32(53)) + msg.o = nil + XCTAssertEqual(msg.oneofUint32, 102) + XCTAssertNil(msg.o) + msg.oneofUint32 = 102 + XCTAssertEqual(msg.oneofUint32, 102) + XCTAssertEqual(msg.o, .oneofUint32(102)) + } - func testOneofFixed32() { - var msg = ProtobufUnittest_Message2() - XCTAssertEqual(msg.oneofFixed32, 106) - XCTAssertNil(msg.o) - msg.oneofFixed32 = 57 - XCTAssertEqual(msg.oneofFixed32, 57) - XCTAssertEqual(msg.o, .oneofFixed32(57)) - msg.o = nil - XCTAssertEqual(msg.oneofFixed32, 106) - XCTAssertNil(msg.o) - msg.oneofFixed32 = 106 - XCTAssertEqual(msg.oneofFixed32, 106) - XCTAssertEqual(msg.o, .oneofFixed32(106)) - } + func testOneofUint64() { + var msg = SwiftProtoTesting_Message2() + XCTAssertEqual(msg.oneofUint64, 103) + XCTAssertNil(msg.o) + msg.oneofUint64 = 54 + XCTAssertEqual(msg.oneofUint64, 54) + XCTAssertEqual(msg.o, .oneofUint64(54)) + msg.o = nil + XCTAssertEqual(msg.oneofUint64, 103) + XCTAssertNil(msg.o) + msg.oneofUint64 = 103 + XCTAssertEqual(msg.oneofUint64, 103) + XCTAssertEqual(msg.o, .oneofUint64(103)) + } - func testOneofFixed64() { - var msg = ProtobufUnittest_Message2() - XCTAssertEqual(msg.oneofFixed64, 107) - XCTAssertNil(msg.o) - msg.oneofFixed64 = 58 - XCTAssertEqual(msg.oneofFixed64, 58) - XCTAssertEqual(msg.o, .oneofFixed64(58)) - msg.o = nil - XCTAssertEqual(msg.oneofFixed64, 107) - XCTAssertNil(msg.o) - msg.oneofFixed64 = 107 - XCTAssertEqual(msg.oneofFixed64, 107) - XCTAssertEqual(msg.o, .oneofFixed64(107)) - } + func testOneofSint32() { + var msg = SwiftProtoTesting_Message2() + XCTAssertEqual(msg.oneofSint32, 104) + XCTAssertNil(msg.o) + msg.oneofSint32 = 55 + XCTAssertEqual(msg.oneofSint32, 55) + XCTAssertEqual(msg.o, .oneofSint32(55)) + msg.o = nil + XCTAssertEqual(msg.oneofSint32, 104) + XCTAssertNil(msg.o) + msg.oneofSint32 = 104 + XCTAssertEqual(msg.oneofSint32, 104) + XCTAssertEqual(msg.o, .oneofSint32(104)) + } - func testOneofSfixed32() { - var msg = ProtobufUnittest_Message2() - XCTAssertEqual(msg.oneofSfixed32, 108) - XCTAssertNil(msg.o) - msg.oneofSfixed32 = 59 - XCTAssertEqual(msg.oneofSfixed32, 59) - XCTAssertEqual(msg.o, .oneofSfixed32(59)) - msg.o = nil - XCTAssertEqual(msg.oneofSfixed32, 108) - XCTAssertNil(msg.o) - msg.oneofSfixed32 = 108 - XCTAssertEqual(msg.oneofSfixed32, 108) - XCTAssertEqual(msg.o, .oneofSfixed32(108)) - } + func testOneofSint64() { + var msg = SwiftProtoTesting_Message2() + XCTAssertEqual(msg.oneofSint64, 105) + XCTAssertNil(msg.o) + msg.oneofSint64 = 56 + XCTAssertEqual(msg.oneofSint64, 56) + XCTAssertEqual(msg.o, .oneofSint64(56)) + msg.o = nil + XCTAssertEqual(msg.oneofSint64, 105) + XCTAssertNil(msg.o) + msg.oneofSint64 = 105 + XCTAssertEqual(msg.oneofSint64, 105) + XCTAssertEqual(msg.o, .oneofSint64(105)) + } - func testOneofSfixed64() { - var msg = ProtobufUnittest_Message2() - XCTAssertEqual(msg.oneofSfixed64, 109) - XCTAssertNil(msg.o) - msg.oneofSfixed64 = 60 - XCTAssertEqual(msg.oneofSfixed64, 60) - XCTAssertEqual(msg.o, .oneofSfixed64(60)) - msg.o = nil - XCTAssertEqual(msg.oneofSfixed64, 109) - XCTAssertNil(msg.o) - msg.oneofSfixed64 = 109 - XCTAssertEqual(msg.oneofSfixed64, 109) - XCTAssertEqual(msg.o, .oneofSfixed64(109)) - } + func testOneofFixed32() { + var msg = SwiftProtoTesting_Message2() + XCTAssertEqual(msg.oneofFixed32, 106) + XCTAssertNil(msg.o) + msg.oneofFixed32 = 57 + XCTAssertEqual(msg.oneofFixed32, 57) + XCTAssertEqual(msg.o, .oneofFixed32(57)) + msg.o = nil + XCTAssertEqual(msg.oneofFixed32, 106) + XCTAssertNil(msg.o) + msg.oneofFixed32 = 106 + XCTAssertEqual(msg.oneofFixed32, 106) + XCTAssertEqual(msg.o, .oneofFixed32(106)) + } - func testOneofFloat() { - var msg = ProtobufUnittest_Message2() - XCTAssertEqual(msg.oneofFloat, 110.0) - XCTAssertNil(msg.o) - msg.oneofFloat = 61.0 - XCTAssertEqual(msg.oneofFloat, 61.0) - XCTAssertEqual(msg.o, .oneofFloat(61.0)) - msg.o = nil - XCTAssertEqual(msg.oneofFloat, 110.0) - XCTAssertNil(msg.o) - msg.oneofFloat = 110.0 - XCTAssertEqual(msg.oneofFloat, 110.0) - XCTAssertEqual(msg.o, .oneofFloat(110.0)) - } + func testOneofFixed64() { + var msg = SwiftProtoTesting_Message2() + XCTAssertEqual(msg.oneofFixed64, 107) + XCTAssertNil(msg.o) + msg.oneofFixed64 = 58 + XCTAssertEqual(msg.oneofFixed64, 58) + XCTAssertEqual(msg.o, .oneofFixed64(58)) + msg.o = nil + XCTAssertEqual(msg.oneofFixed64, 107) + XCTAssertNil(msg.o) + msg.oneofFixed64 = 107 + XCTAssertEqual(msg.oneofFixed64, 107) + XCTAssertEqual(msg.o, .oneofFixed64(107)) + } - func testOneofDouble() { - var msg = ProtobufUnittest_Message2() - XCTAssertEqual(msg.oneofDouble, 111.0) - XCTAssertNil(msg.o) - msg.oneofDouble = 62.0 - XCTAssertEqual(msg.oneofDouble, 62.0) - XCTAssertEqual(msg.o, .oneofDouble(62.0)) - msg.o = nil - XCTAssertEqual(msg.oneofDouble, 111.0) - XCTAssertNil(msg.o) - msg.oneofDouble = 111.0 - XCTAssertEqual(msg.oneofDouble, 111.0) - XCTAssertEqual(msg.o, .oneofDouble(111.0)) - } + func testOneofSfixed32() { + var msg = SwiftProtoTesting_Message2() + XCTAssertEqual(msg.oneofSfixed32, 108) + XCTAssertNil(msg.o) + msg.oneofSfixed32 = 59 + XCTAssertEqual(msg.oneofSfixed32, 59) + XCTAssertEqual(msg.o, .oneofSfixed32(59)) + msg.o = nil + XCTAssertEqual(msg.oneofSfixed32, 108) + XCTAssertNil(msg.o) + msg.oneofSfixed32 = 108 + XCTAssertEqual(msg.oneofSfixed32, 108) + XCTAssertEqual(msg.o, .oneofSfixed32(108)) + } - func testOneofBool() { - var msg = ProtobufUnittest_Message2() - XCTAssertEqual(msg.oneofBool, true) - XCTAssertNil(msg.o) - msg.oneofBool = false - XCTAssertEqual(msg.oneofBool, false) - XCTAssertEqual(msg.o, .oneofBool(false)) - msg.o = nil - XCTAssertEqual(msg.oneofBool, true) - XCTAssertNil(msg.o) - msg.oneofBool = true - XCTAssertEqual(msg.oneofBool, true) - XCTAssertEqual(msg.o, .oneofBool(true)) - } + func testOneofSfixed64() { + var msg = SwiftProtoTesting_Message2() + XCTAssertEqual(msg.oneofSfixed64, 109) + XCTAssertNil(msg.o) + msg.oneofSfixed64 = 60 + XCTAssertEqual(msg.oneofSfixed64, 60) + XCTAssertEqual(msg.o, .oneofSfixed64(60)) + msg.o = nil + XCTAssertEqual(msg.oneofSfixed64, 109) + XCTAssertNil(msg.o) + msg.oneofSfixed64 = 109 + XCTAssertEqual(msg.oneofSfixed64, 109) + XCTAssertEqual(msg.o, .oneofSfixed64(109)) + } - func testOneofString() { - var msg = ProtobufUnittest_Message2() - XCTAssertEqual(msg.oneofString, "string") - XCTAssertNil(msg.o) - msg.oneofString = "64" - XCTAssertEqual(msg.oneofString, "64") - XCTAssertEqual(msg.o, .oneofString("64")) - msg.o = nil - XCTAssertEqual(msg.oneofString, "string") - XCTAssertNil(msg.o) - msg.oneofString = "string" - XCTAssertEqual(msg.oneofString, "string") - XCTAssertEqual(msg.o, .oneofString("string")) - } + func testOneofFloat() { + var msg = SwiftProtoTesting_Message2() + XCTAssertEqual(msg.oneofFloat, 110.0) + XCTAssertNil(msg.o) + msg.oneofFloat = 61.0 + XCTAssertEqual(msg.oneofFloat, 61.0) + XCTAssertEqual(msg.o, .oneofFloat(61.0)) + msg.o = nil + XCTAssertEqual(msg.oneofFloat, 110.0) + XCTAssertNil(msg.o) + msg.oneofFloat = 110.0 + XCTAssertEqual(msg.oneofFloat, 110.0) + XCTAssertEqual(msg.o, .oneofFloat(110.0)) + } - func testOneofBytes() { - var msg = ProtobufUnittest_Message2() - XCTAssertEqual(msg.oneofBytes, "data".data(using: .utf8)) - XCTAssertNil(msg.o) - msg.oneofBytes = Data([65]) - XCTAssertEqual(msg.oneofBytes, Data([65])) - XCTAssertEqual(msg.o, .oneofBytes(Data([65]))) - msg.o = nil - XCTAssertEqual(msg.oneofBytes, "data".data(using: .utf8)) - XCTAssertNil(msg.o) - msg.oneofBytes = "data".data(using: .utf8)! - XCTAssertEqual(msg.oneofBytes, "data".data(using: .utf8)) - XCTAssertEqual(msg.o, .oneofBytes("data".data(using: .utf8)!)) - } + func testOneofDouble() { + var msg = SwiftProtoTesting_Message2() + XCTAssertEqual(msg.oneofDouble, 111.0) + XCTAssertNil(msg.o) + msg.oneofDouble = 62.0 + XCTAssertEqual(msg.oneofDouble, 62.0) + XCTAssertEqual(msg.o, .oneofDouble(62.0)) + msg.o = nil + XCTAssertEqual(msg.oneofDouble, 111.0) + XCTAssertNil(msg.o) + msg.oneofDouble = 111.0 + XCTAssertEqual(msg.oneofDouble, 111.0) + XCTAssertEqual(msg.o, .oneofDouble(111.0)) + } - func testOneofGroup() { - var msg = ProtobufUnittest_Message2() - XCTAssertEqual(msg.oneofGroup.a, 116) - XCTAssertFalse(msg.oneofGroup.hasA) - XCTAssertNil(msg.o) - var grp = ProtobufUnittest_Message2.OneofGroup() - grp.a = 66 - msg.oneofGroup = grp - XCTAssertEqual(msg.oneofGroup.a, 66) - XCTAssertTrue(msg.oneofGroup.hasA) - XCTAssertEqual(msg.oneofGroup, grp) - if case .oneofGroup(let v)? = msg.o { - XCTAssertTrue(v.hasA) - XCTAssertEqual(v.a, 66) - XCTAssertEqual(v, grp) - } else { - XCTFail("Wasn't the right case") + func testOneofBool() { + var msg = SwiftProtoTesting_Message2() + XCTAssertEqual(msg.oneofBool, true) + XCTAssertNil(msg.o) + msg.oneofBool = false + XCTAssertEqual(msg.oneofBool, false) + XCTAssertEqual(msg.o, .oneofBool(false)) + msg.o = nil + XCTAssertEqual(msg.oneofBool, true) + XCTAssertNil(msg.o) + msg.oneofBool = true + XCTAssertEqual(msg.oneofBool, true) + XCTAssertEqual(msg.o, .oneofBool(true)) } - msg.o = nil - XCTAssertEqual(msg.oneofGroup.a, 116) - XCTAssertFalse(msg.oneofGroup.hasA) - XCTAssertNil(msg.o) - // Default within the group - var grp2 = ProtobufUnittest_Message2.OneofGroup() - grp2.a = 116 - msg.oneofGroup = grp2 - XCTAssertEqual(msg.oneofGroup.a, 116) - XCTAssertTrue(msg.oneofGroup.hasA) - XCTAssertEqual(msg.oneofGroup, grp2) - if case .oneofGroup(let v)? = msg.o { - XCTAssertTrue(v.hasA) - XCTAssertEqual(v.a, 116) - XCTAssertEqual(v, grp2) - } else { - XCTFail("Wasn't the right case") + + func testOneofString() { + var msg = SwiftProtoTesting_Message2() + XCTAssertEqual(msg.oneofString, "string") + XCTAssertNil(msg.o) + msg.oneofString = "64" + XCTAssertEqual(msg.oneofString, "64") + XCTAssertEqual(msg.o, .oneofString("64")) + msg.o = nil + XCTAssertEqual(msg.oneofString, "string") + XCTAssertNil(msg.o) + msg.oneofString = "string" + XCTAssertEqual(msg.oneofString, "string") + XCTAssertEqual(msg.o, .oneofString("string")) } - msg.o = nil - // Group with nothing set. - let grp3 = ProtobufUnittest_Message2.OneofGroup() - msg.oneofGroup = grp3 - XCTAssertEqual(msg.oneofGroup.a, 116) - XCTAssertFalse(msg.oneofGroup.hasA) - XCTAssertEqual(msg.oneofGroup, grp3) - if case .oneofGroup(let v)? = msg.o { - XCTAssertFalse(v.hasA) - XCTAssertEqual(v.a, 116) - XCTAssertEqual(v, grp3) - } else { - XCTFail("Wasn't the right case") + + func testOneofBytes() { + var msg = SwiftProtoTesting_Message2() + XCTAssertEqual(msg.oneofBytes, "data".data(using: .utf8)) + XCTAssertNil(msg.o) + msg.oneofBytes = Data([65]) + XCTAssertEqual(msg.oneofBytes, Data([65])) + XCTAssertEqual(msg.o, .oneofBytes(Data([65]))) + msg.o = nil + XCTAssertEqual(msg.oneofBytes, "data".data(using: .utf8)) + XCTAssertNil(msg.o) + msg.oneofBytes = "data".data(using: .utf8)! + XCTAssertEqual(msg.oneofBytes, "data".data(using: .utf8)) + XCTAssertEqual(msg.o, .oneofBytes("data".data(using: .utf8)!)) } - } - func testOneofMessage() { - var msg = ProtobufUnittest_Message2() - XCTAssertEqual(msg.oneofMessage.optionalInt32, 0) - XCTAssertNil(msg.o) - var subMsg = ProtobufUnittest_Message2() - subMsg.optionalInt32 = 66 - msg.oneofMessage = subMsg - XCTAssertEqual(msg.oneofMessage.optionalInt32, 66) - XCTAssertEqual(msg.oneofMessage, subMsg) - if case .oneofMessage(let v)? = msg.o { - XCTAssertEqual(v.optionalInt32, 66) - XCTAssertEqual(v, subMsg) - } else { - XCTFail("Wasn't the right case") + func testOneofGroup() { + var msg = SwiftProtoTesting_Message2() + XCTAssertEqual(msg.oneofGroup.a, 116) + XCTAssertFalse(msg.oneofGroup.hasA) + XCTAssertNil(msg.o) + var grp = SwiftProtoTesting_Message2.OneofGroup() + grp.a = 66 + msg.oneofGroup = grp + XCTAssertEqual(msg.oneofGroup.a, 66) + XCTAssertTrue(msg.oneofGroup.hasA) + XCTAssertEqual(msg.oneofGroup, grp) + if case .oneofGroup(let v)? = msg.o { + XCTAssertTrue(v.hasA) + XCTAssertEqual(v.a, 66) + XCTAssertEqual(v, grp) + } else { + XCTFail("Wasn't the right case") + } + msg.o = nil + XCTAssertEqual(msg.oneofGroup.a, 116) + XCTAssertFalse(msg.oneofGroup.hasA) + XCTAssertNil(msg.o) + // Default within the group + var grp2 = SwiftProtoTesting_Message2.OneofGroup() + grp2.a = 116 + msg.oneofGroup = grp2 + XCTAssertEqual(msg.oneofGroup.a, 116) + XCTAssertTrue(msg.oneofGroup.hasA) + XCTAssertEqual(msg.oneofGroup, grp2) + if case .oneofGroup(let v)? = msg.o { + XCTAssertTrue(v.hasA) + XCTAssertEqual(v.a, 116) + XCTAssertEqual(v, grp2) + } else { + XCTFail("Wasn't the right case") + } + msg.o = nil + // Group with nothing set. + let grp3 = SwiftProtoTesting_Message2.OneofGroup() + msg.oneofGroup = grp3 + XCTAssertEqual(msg.oneofGroup.a, 116) + XCTAssertFalse(msg.oneofGroup.hasA) + XCTAssertEqual(msg.oneofGroup, grp3) + if case .oneofGroup(let v)? = msg.o { + XCTAssertFalse(v.hasA) + XCTAssertEqual(v.a, 116) + XCTAssertEqual(v, grp3) + } else { + XCTFail("Wasn't the right case") + } } - msg.o = nil - XCTAssertEqual(msg.oneofMessage.optionalInt32, 0) - XCTAssertNil(msg.o) - // Default within the message - var subMsg2 = ProtobufUnittest_Message2() - subMsg2.optionalInt32 = 0 - msg.oneofMessage = subMsg2 - XCTAssertEqual(msg.oneofMessage.optionalInt32, 0) - XCTAssertTrue(msg.oneofMessage.hasOptionalInt32) - XCTAssertEqual(msg.oneofMessage, subMsg2) - if case .oneofMessage(let v)? = msg.o { - XCTAssertTrue(v.hasOptionalInt32) - XCTAssertEqual(v.optionalInt32, 0) - XCTAssertEqual(v, subMsg2) - } else { - XCTFail("Wasn't the right case") + + func testOneofMessage() { + var msg = SwiftProtoTesting_Message2() + XCTAssertEqual(msg.oneofMessage.optionalInt32, 0) + XCTAssertNil(msg.o) + var subMsg = SwiftProtoTesting_Message2() + subMsg.optionalInt32 = 66 + msg.oneofMessage = subMsg + XCTAssertEqual(msg.oneofMessage.optionalInt32, 66) + XCTAssertEqual(msg.oneofMessage, subMsg) + if case .oneofMessage(let v)? = msg.o { + XCTAssertEqual(v.optionalInt32, 66) + XCTAssertEqual(v, subMsg) + } else { + XCTFail("Wasn't the right case") + } + msg.o = nil + XCTAssertEqual(msg.oneofMessage.optionalInt32, 0) + XCTAssertNil(msg.o) + // Default within the message + var subMsg2 = SwiftProtoTesting_Message2() + subMsg2.optionalInt32 = 0 + msg.oneofMessage = subMsg2 + XCTAssertEqual(msg.oneofMessage.optionalInt32, 0) + XCTAssertTrue(msg.oneofMessage.hasOptionalInt32) + XCTAssertEqual(msg.oneofMessage, subMsg2) + if case .oneofMessage(let v)? = msg.o { + XCTAssertTrue(v.hasOptionalInt32) + XCTAssertEqual(v.optionalInt32, 0) + XCTAssertEqual(v, subMsg2) + } else { + XCTFail("Wasn't the right case") + } + msg.o = nil + // Message with nothing set. + let subMsg3 = SwiftProtoTesting_Message2() + msg.oneofMessage = subMsg3 + XCTAssertEqual(msg.oneofMessage.optionalInt32, 0) + XCTAssertFalse(msg.oneofMessage.hasOptionalInt32) + XCTAssertEqual(msg.oneofMessage, subMsg3) + if case .oneofMessage(let v)? = msg.o { + XCTAssertFalse(v.hasOptionalInt32) + XCTAssertEqual(v.optionalInt32, 0) + XCTAssertEqual(v, subMsg3) + } else { + XCTFail("Wasn't the right case") + } } - msg.o = nil - // Message with nothing set. - let subMsg3 = ProtobufUnittest_Message2() - msg.oneofMessage = subMsg3 - XCTAssertEqual(msg.oneofMessage.optionalInt32, 0) - XCTAssertFalse(msg.oneofMessage.hasOptionalInt32) - XCTAssertEqual(msg.oneofMessage, subMsg3) - if case .oneofMessage(let v)? = msg.o { - XCTAssertFalse(v.hasOptionalInt32) - XCTAssertEqual(v.optionalInt32, 0) - XCTAssertEqual(v, subMsg3) - } else { - XCTFail("Wasn't the right case") + + func testOneofEnum() { + var msg = SwiftProtoTesting_Message2() + XCTAssertEqual(msg.oneofEnum, .baz) + XCTAssertNil(msg.o) + msg.oneofEnum = .bar + XCTAssertEqual(msg.oneofEnum, .bar) + XCTAssertEqual(msg.o, .oneofEnum(.bar)) + msg.o = nil + XCTAssertEqual(msg.oneofEnum, .baz) + XCTAssertNil(msg.o) + msg.oneofEnum = .baz + XCTAssertEqual(msg.oneofEnum, .baz) + XCTAssertEqual(msg.o, .oneofEnum(.baz)) } - } - func testOneofEnum() { - var msg = ProtobufUnittest_Message2() - XCTAssertEqual(msg.oneofEnum, .baz) - XCTAssertNil(msg.o) - msg.oneofEnum = .bar - XCTAssertEqual(msg.oneofEnum, .bar) - XCTAssertEqual(msg.o, .oneofEnum(.bar)) - msg.o = nil - XCTAssertEqual(msg.oneofEnum, .baz) - XCTAssertNil(msg.o) - msg.oneofEnum = .baz - XCTAssertEqual(msg.oneofEnum, .baz) - XCTAssertEqual(msg.o, .oneofEnum(.baz)) - } + // Chaining. Set each item in the oneof clear the previous one. - // Chaining. Set each item in the oneof clear the previous one. + func testOneofOnlyOneSet() { + var msg = SwiftProtoTesting_Message2() - func testOneofOnlyOneSet() { - var msg = ProtobufUnittest_Message2() + func assertRightFiledSet(_ i: Int) { + // Make sure the case is correct for the enum based access. + switch msg.o { + case nil: + XCTAssertEqual(i, 0) + case .oneofInt32(let v)?: + XCTAssertEqual(i, 1) + XCTAssertEqual(v, 51) + case .oneofInt64(let v)?: + XCTAssertEqual(i, 2) + XCTAssertEqual(v, 52) + case .oneofUint32(let v)?: + XCTAssertEqual(i, 3) + XCTAssertEqual(v, 53) + case .oneofUint64(let v)?: + XCTAssertEqual(i, 4) + XCTAssertEqual(v, 54) + case .oneofSint32(let v)?: + XCTAssertEqual(i, 5) + XCTAssertEqual(v, 55) + case .oneofSint64(let v)?: + XCTAssertEqual(i, 6) + XCTAssertEqual(v, 56) + case .oneofFixed32(let v)?: + XCTAssertEqual(i, 7) + XCTAssertEqual(v, 57) + case .oneofFixed64(let v)?: + XCTAssertEqual(i, 8) + XCTAssertEqual(v, 58) + case .oneofSfixed32(let v)?: + XCTAssertEqual(i, 9) + XCTAssertEqual(v, 59) + case .oneofSfixed64(let v)?: + XCTAssertEqual(i, 10) + XCTAssertEqual(v, 60) + case .oneofFloat(let v)?: + XCTAssertEqual(i, 11) + XCTAssertEqual(v, 61.0) + case .oneofDouble(let v)?: + XCTAssertEqual(i, 12) + XCTAssertEqual(v, 62.0) + case .oneofBool(let v)?: + XCTAssertEqual(i, 13) + XCTAssertEqual(v, false) + case .oneofString(let v)?: + XCTAssertEqual(i, 14) + XCTAssertEqual(v, "64") + case .oneofBytes(let v)?: + XCTAssertEqual(i, 15) + XCTAssertEqual(v, Data([65])) + case .oneofGroup(let v)?: + XCTAssertEqual(i, 16) + XCTAssertTrue(v.hasA) + XCTAssertEqual(v.a, 66) + case .oneofMessage(let v)?: + XCTAssertEqual(i, 17) + XCTAssertTrue(v.hasOptionalInt32) + XCTAssertEqual(v.optionalInt32, 68) + case .oneofEnum(let v)?: + XCTAssertEqual(i, 18) + XCTAssertEqual(v, .bar) + } - func assertRightFiledSet(_ i: Int) { - // Make sure the case is correct for the enum based access. - switch msg.o { - case nil: - XCTAssertEqual(i, 0) - case .oneofInt32(let v)?: - XCTAssertEqual(i, 1) - XCTAssertEqual(v, 51) - case .oneofInt64(let v)?: - XCTAssertEqual(i, 2) - XCTAssertEqual(v, 52) - case .oneofUint32(let v)?: - XCTAssertEqual(i, 3) - XCTAssertEqual(v, 53) - case .oneofUint64(let v)?: - XCTAssertEqual(i, 4) - XCTAssertEqual(v, 54) - case .oneofSint32(let v)?: - XCTAssertEqual(i, 5) - XCTAssertEqual(v, 55) - case .oneofSint64(let v)?: - XCTAssertEqual(i, 6) - XCTAssertEqual(v, 56) - case .oneofFixed32(let v)?: - XCTAssertEqual(i, 7) - XCTAssertEqual(v, 57) - case .oneofFixed64(let v)?: - XCTAssertEqual(i, 8) - XCTAssertEqual(v, 58) - case .oneofSfixed32(let v)?: - XCTAssertEqual(i, 9) - XCTAssertEqual(v, 59) - case .oneofSfixed64(let v)?: - XCTAssertEqual(i, 10) - XCTAssertEqual(v, 60) - case .oneofFloat(let v)?: - XCTAssertEqual(i, 11) - XCTAssertEqual(v, 61.0) - case .oneofDouble(let v)?: - XCTAssertEqual(i, 12) - XCTAssertEqual(v, 62.0) - case .oneofBool(let v)?: - XCTAssertEqual(i, 13) - XCTAssertEqual(v, false) - case .oneofString(let v)?: - XCTAssertEqual(i, 14) - XCTAssertEqual(v, "64") - case .oneofBytes(let v)?: - XCTAssertEqual(i, 15) - XCTAssertEqual(v, Data([65])) - case .oneofGroup(let v)?: - XCTAssertEqual(i, 16) - XCTAssertTrue(v.hasA) - XCTAssertEqual(v.a, 66) - case .oneofMessage(let v)?: - XCTAssertEqual(i, 17) - XCTAssertTrue(v.hasOptionalInt32) - XCTAssertEqual(v.optionalInt32, 68) - case .oneofEnum(let v)?: - XCTAssertEqual(i, 18) - XCTAssertEqual(v, .bar) - } + // Check direct field access (gets the right value or the default) + if i == 1 { + XCTAssertEqual(msg.oneofInt32, 51) + } else { + XCTAssertEqual(msg.oneofInt32, 100, "i = \(i)") + } + if i == 2 { + XCTAssertEqual(msg.oneofInt64, 52) + } else { + XCTAssertEqual(msg.oneofInt64, 101, "i = \(i)") + } + if i == 3 { + XCTAssertEqual(msg.oneofUint32, 53) + } else { + XCTAssertEqual(msg.oneofUint32, 102, "i = \(i)") + } + if i == 4 { + XCTAssertEqual(msg.oneofUint64, 54) + } else { + XCTAssertEqual(msg.oneofUint64, 103, "i = \(i)") + } + if i == 5 { + XCTAssertEqual(msg.oneofSint32, 55) + } else { + XCTAssertEqual(msg.oneofSint32, 104, "i = \(i)") + } + if i == 6 { + XCTAssertEqual(msg.oneofSint64, 56) + } else { + XCTAssertEqual(msg.oneofSint64, 105, "i = \(i)") + } + if i == 7 { + XCTAssertEqual(msg.oneofFixed32, 57) + } else { + XCTAssertEqual(msg.oneofFixed32, 106, "i = \(i)") + } + if i == 8 { + XCTAssertEqual(msg.oneofFixed64, 58) + } else { + XCTAssertEqual(msg.oneofFixed64, 107, "i = \(i)") + } + if i == 9 { + XCTAssertEqual(msg.oneofSfixed32, 59) + } else { + XCTAssertEqual(msg.oneofSfixed32, 108, "i = \(i)") + } + if i == 10 { + XCTAssertEqual(msg.oneofSfixed64, 60) + } else { + XCTAssertEqual(msg.oneofSfixed64, 109, "i = \(i)") + } + if i == 11 { + XCTAssertEqual(msg.oneofFloat, 61.0) + } else { + XCTAssertEqual(msg.oneofFloat, 110.0, "i = \(i)") + } + if i == 12 { + XCTAssertEqual(msg.oneofDouble, 62.0) + } else { + XCTAssertEqual(msg.oneofDouble, 111.0, "i = \(i)") + } + if i == 13 { + XCTAssertEqual(msg.oneofBool, false) + } else { + XCTAssertEqual(msg.oneofBool, true, "i = \(i)") + } + if i == 14 { + XCTAssertEqual(msg.oneofString, "64") + } else { + XCTAssertEqual(msg.oneofString, "string", "i = \(i)") + } + if i == 15 { + XCTAssertEqual(msg.oneofBytes, Data([65])) + } else { + XCTAssertEqual(msg.oneofBytes, "data".data(using: .utf8), "i = \(i)") + } + if i == 16 { + XCTAssertTrue(msg.oneofGroup.hasA) + XCTAssertEqual(msg.oneofGroup.a, 66) + } else { + XCTAssertFalse(msg.oneofGroup.hasA, "i = \(i)") + XCTAssertEqual(msg.oneofGroup.a, 116, "i = \(i)") + } + if i == 17 { + XCTAssertTrue(msg.oneofMessage.hasOptionalInt32) + XCTAssertEqual(msg.oneofMessage.optionalInt32, 68) + } else { + XCTAssertFalse(msg.oneofMessage.hasOptionalInt32, "i = \(i)") + XCTAssertEqual(msg.oneofMessage.optionalInt32, 0, "i = \(i)") + } + if i == 18 { + XCTAssertEqual(msg.oneofEnum, .bar) + } else { + XCTAssertEqual(msg.oneofEnum, .baz, "i = \(i)") + } + } - // Check direct field access (gets the right value or the default) - if i == 1 { - XCTAssertEqual(msg.oneofInt32, 51) - } else { - XCTAssertEqual(msg.oneofInt32, 100, "i = \(i)") - } - if i == 2 { - XCTAssertEqual(msg.oneofInt64, 52) - } else { - XCTAssertEqual(msg.oneofInt64, 101, "i = \(i)") - } - if i == 3 { - XCTAssertEqual(msg.oneofUint32, 53) - } else { - XCTAssertEqual(msg.oneofUint32, 102, "i = \(i)") - } - if i == 4 { - XCTAssertEqual(msg.oneofUint64, 54) - } else { - XCTAssertEqual(msg.oneofUint64, 103, "i = \(i)") - } - if i == 5 { - XCTAssertEqual(msg.oneofSint32, 55) - } else { - XCTAssertEqual(msg.oneofSint32, 104, "i = \(i)") - } - if i == 6 { - XCTAssertEqual(msg.oneofSint64, 56) - } else { - XCTAssertEqual(msg.oneofSint64, 105, "i = \(i)") - } - if i == 7 { - XCTAssertEqual(msg.oneofFixed32, 57) - } else { - XCTAssertEqual(msg.oneofFixed32, 106, "i = \(i)") - } - if i == 8 { - XCTAssertEqual(msg.oneofFixed64, 58) - } else { - XCTAssertEqual(msg.oneofFixed64, 107, "i = \(i)") - } - if i == 9 { - XCTAssertEqual(msg.oneofSfixed32, 59) - } else { - XCTAssertEqual(msg.oneofSfixed32, 108, "i = \(i)") - } - if i == 10 { - XCTAssertEqual(msg.oneofSfixed64, 60) - } else { - XCTAssertEqual(msg.oneofSfixed64, 109, "i = \(i)") - } - if i == 11 { - XCTAssertEqual(msg.oneofFloat, 61.0) - } else { - XCTAssertEqual(msg.oneofFloat, 110.0, "i = \(i)") - } - if i == 12 { - XCTAssertEqual(msg.oneofDouble, 62.0) - } else { - XCTAssertEqual(msg.oneofDouble, 111.0, "i = \(i)") - } - if i == 13 { - XCTAssertEqual(msg.oneofBool, false) - } else { - XCTAssertEqual(msg.oneofBool, true, "i = \(i)") - } - if i == 14 { - XCTAssertEqual(msg.oneofString, "64") - } else { - XCTAssertEqual(msg.oneofString, "string", "i = \(i)") - } - if i == 15 { - XCTAssertEqual(msg.oneofBytes, Data([65])) - } else { - XCTAssertEqual(msg.oneofBytes, "data".data(using: .utf8), "i = \(i)") - } - if i == 16 { - XCTAssertTrue(msg.oneofGroup.hasA) - XCTAssertEqual(msg.oneofGroup.a, 66) - } else { - XCTAssertFalse(msg.oneofGroup.hasA, "i = \(i)") - XCTAssertEqual(msg.oneofGroup.a, 116, "i = \(i)") - } - if i == 17 { - XCTAssertTrue(msg.oneofMessage.hasOptionalInt32) - XCTAssertEqual(msg.oneofMessage.optionalInt32, 68) - } else { - XCTAssertFalse(msg.oneofMessage.hasOptionalInt32, "i = \(i)") - XCTAssertEqual(msg.oneofMessage.optionalInt32, 0, "i = \(i)") - } - if i == 18 { - XCTAssertEqual(msg.oneofEnum, .bar) - } else { - XCTAssertEqual(msg.oneofEnum, .baz, "i = \(i)") - } + // Now cycle through the cases. + assertRightFiledSet(0) + msg.oneofInt32 = 51 + assertRightFiledSet(1) + msg.oneofInt64 = 52 + assertRightFiledSet(2) + msg.oneofUint32 = 53 + assertRightFiledSet(3) + msg.oneofUint64 = 54 + assertRightFiledSet(4) + msg.oneofSint32 = 55 + assertRightFiledSet(5) + msg.oneofSint64 = 56 + assertRightFiledSet(6) + msg.oneofFixed32 = 57 + assertRightFiledSet(7) + msg.oneofFixed64 = 58 + assertRightFiledSet(8) + msg.oneofSfixed32 = 59 + assertRightFiledSet(9) + msg.oneofSfixed64 = 60 + assertRightFiledSet(10) + msg.oneofFloat = 61.0 + assertRightFiledSet(11) + msg.oneofDouble = 62.0 + assertRightFiledSet(12) + msg.oneofBool = false + assertRightFiledSet(13) + msg.oneofString = "64" + assertRightFiledSet(14) + msg.oneofBytes = Data([65]) + assertRightFiledSet(15) + msg.oneofGroup.a = 66 + assertRightFiledSet(16) + msg.oneofMessage.optionalInt32 = 68 + assertRightFiledSet(17) + msg.oneofEnum = .bar + assertRightFiledSet(18) } - - // Now cycle through the cases. - assertRightFiledSet(0) - msg.oneofInt32 = 51 - assertRightFiledSet(1) - msg.oneofInt64 = 52 - assertRightFiledSet(2) - msg.oneofUint32 = 53 - assertRightFiledSet(3) - msg.oneofUint64 = 54 - assertRightFiledSet(4) - msg.oneofSint32 = 55 - assertRightFiledSet(5) - msg.oneofSint64 = 56 - assertRightFiledSet(6) - msg.oneofFixed32 = 57 - assertRightFiledSet(7) - msg.oneofFixed64 = 58 - assertRightFiledSet(8) - msg.oneofSfixed32 = 59 - assertRightFiledSet(9) - msg.oneofSfixed64 = 60 - assertRightFiledSet(10) - msg.oneofFloat = 61.0 - assertRightFiledSet(11) - msg.oneofDouble = 62.0 - assertRightFiledSet(12) - msg.oneofBool = false - assertRightFiledSet(13) - msg.oneofString = "64" - assertRightFiledSet(14) - msg.oneofBytes = Data([65]) - assertRightFiledSet(15) - msg.oneofGroup.a = 66 - assertRightFiledSet(16) - msg.oneofMessage.optionalInt32 = 68 - assertRightFiledSet(17) - msg.oneofEnum = .bar - assertRightFiledSet(18) - } } diff --git a/Tests/SwiftProtobufTests/Test_OneofFields_Access_Proto3.swift b/Tests/SwiftProtobufTests/Test_OneofFields_Access_Proto3.swift index 58b665b16..99f983b33 100644 --- a/Tests/SwiftProtobufTests/Test_OneofFields_Access_Proto3.swift +++ b/Tests/SwiftProtobufTests/Test_OneofFields_Access_Proto3.swift @@ -12,497 +12,497 @@ /// // ----------------------------------------------------------------------------- -import XCTest import Foundation +import XCTest // NOTE: The generator changes what is generated based on the number/types // of fields (using a nested storage class or not), to be completel, all // these tests should be done once with a message that gets that storage // class and a second time with messages that avoid that. -class Test_OneofFields_Access_Proto3: XCTestCase { +final class Test_OneofFields_Access_Proto3: XCTestCase { - // Accessing one field. - // - Returns default - // - Accepts/Captures value - // - Resets - // - Accepts/Captures default value + // Accessing one field. + // - Returns default + // - Accepts/Captures value + // - Resets + // - Accepts/Captures default value - func testOneofInt32() { - var msg = ProtobufUnittest_Message3() - XCTAssertEqual(msg.oneofInt32, 0) - XCTAssertNil(msg.o) - msg.oneofInt32 = 51 - XCTAssertEqual(msg.oneofInt32, 51) - XCTAssertEqual(msg.o, .oneofInt32(51)) - msg.o = nil - XCTAssertEqual(msg.oneofInt32, 0) - XCTAssertNil(msg.o) - msg.oneofInt32 = 0 - XCTAssertEqual(msg.oneofInt32, 0) - XCTAssertEqual(msg.o, .oneofInt32(0)) - } + func testOneofInt32() { + var msg = SwiftProtoTesting_Message3() + XCTAssertEqual(msg.oneofInt32, 0) + XCTAssertNil(msg.o) + msg.oneofInt32 = 51 + XCTAssertEqual(msg.oneofInt32, 51) + XCTAssertEqual(msg.o, .oneofInt32(51)) + msg.o = nil + XCTAssertEqual(msg.oneofInt32, 0) + XCTAssertNil(msg.o) + msg.oneofInt32 = 0 + XCTAssertEqual(msg.oneofInt32, 0) + XCTAssertEqual(msg.o, .oneofInt32(0)) + } - func testOneofInt64() { - var msg = ProtobufUnittest_Message3() - XCTAssertEqual(msg.oneofInt64, 0) - XCTAssertNil(msg.o) - msg.oneofInt64 = 52 - XCTAssertEqual(msg.oneofInt64, 52) - XCTAssertEqual(msg.o, .oneofInt64(52)) - msg.o = nil - XCTAssertEqual(msg.oneofInt64, 0) - XCTAssertNil(msg.o) - msg.oneofInt64 = 0 - XCTAssertEqual(msg.oneofInt64, 0) - XCTAssertEqual(msg.o, .oneofInt64(0)) - } + func testOneofInt64() { + var msg = SwiftProtoTesting_Message3() + XCTAssertEqual(msg.oneofInt64, 0) + XCTAssertNil(msg.o) + msg.oneofInt64 = 52 + XCTAssertEqual(msg.oneofInt64, 52) + XCTAssertEqual(msg.o, .oneofInt64(52)) + msg.o = nil + XCTAssertEqual(msg.oneofInt64, 0) + XCTAssertNil(msg.o) + msg.oneofInt64 = 0 + XCTAssertEqual(msg.oneofInt64, 0) + XCTAssertEqual(msg.o, .oneofInt64(0)) + } - func testOneofUint32() { - var msg = ProtobufUnittest_Message3() - XCTAssertEqual(msg.oneofUint32, 0) - XCTAssertNil(msg.o) - msg.oneofUint32 = 53 - XCTAssertEqual(msg.oneofUint32, 53) - XCTAssertEqual(msg.o, .oneofUint32(53)) - msg.o = nil - XCTAssertEqual(msg.oneofUint32, 0) - XCTAssertNil(msg.o) - msg.oneofUint32 = 0 - XCTAssertEqual(msg.oneofUint32, 0) - XCTAssertEqual(msg.o, .oneofUint32(0)) - } + func testOneofUint32() { + var msg = SwiftProtoTesting_Message3() + XCTAssertEqual(msg.oneofUint32, 0) + XCTAssertNil(msg.o) + msg.oneofUint32 = 53 + XCTAssertEqual(msg.oneofUint32, 53) + XCTAssertEqual(msg.o, .oneofUint32(53)) + msg.o = nil + XCTAssertEqual(msg.oneofUint32, 0) + XCTAssertNil(msg.o) + msg.oneofUint32 = 0 + XCTAssertEqual(msg.oneofUint32, 0) + XCTAssertEqual(msg.o, .oneofUint32(0)) + } - func testOneofUint64() { - var msg = ProtobufUnittest_Message3() - XCTAssertEqual(msg.oneofUint64, 0) - XCTAssertNil(msg.o) - msg.oneofUint64 = 54 - XCTAssertEqual(msg.oneofUint64, 54) - XCTAssertEqual(msg.o, .oneofUint64(54)) - msg.o = nil - XCTAssertEqual(msg.oneofUint64, 0) - XCTAssertNil(msg.o) - msg.oneofUint64 = 0 - XCTAssertEqual(msg.oneofUint64, 0) - XCTAssertEqual(msg.o, .oneofUint64(0)) - } + func testOneofUint64() { + var msg = SwiftProtoTesting_Message3() + XCTAssertEqual(msg.oneofUint64, 0) + XCTAssertNil(msg.o) + msg.oneofUint64 = 54 + XCTAssertEqual(msg.oneofUint64, 54) + XCTAssertEqual(msg.o, .oneofUint64(54)) + msg.o = nil + XCTAssertEqual(msg.oneofUint64, 0) + XCTAssertNil(msg.o) + msg.oneofUint64 = 0 + XCTAssertEqual(msg.oneofUint64, 0) + XCTAssertEqual(msg.o, .oneofUint64(0)) + } - func testOneofSint32() { - var msg = ProtobufUnittest_Message3() - XCTAssertEqual(msg.oneofSint32, 0) - XCTAssertNil(msg.o) - msg.oneofSint32 = 55 - XCTAssertEqual(msg.oneofSint32, 55) - XCTAssertEqual(msg.o, .oneofSint32(55)) - msg.o = nil - XCTAssertEqual(msg.oneofSint32, 0) - XCTAssertNil(msg.o) - msg.oneofSint32 = 0 - XCTAssertEqual(msg.oneofSint32, 0) - XCTAssertEqual(msg.o, .oneofSint32(0)) - } + func testOneofSint32() { + var msg = SwiftProtoTesting_Message3() + XCTAssertEqual(msg.oneofSint32, 0) + XCTAssertNil(msg.o) + msg.oneofSint32 = 55 + XCTAssertEqual(msg.oneofSint32, 55) + XCTAssertEqual(msg.o, .oneofSint32(55)) + msg.o = nil + XCTAssertEqual(msg.oneofSint32, 0) + XCTAssertNil(msg.o) + msg.oneofSint32 = 0 + XCTAssertEqual(msg.oneofSint32, 0) + XCTAssertEqual(msg.o, .oneofSint32(0)) + } - func testOneofSint64() { - var msg = ProtobufUnittest_Message3() - XCTAssertEqual(msg.oneofSint64, 0) - XCTAssertNil(msg.o) - msg.oneofSint64 = 56 - XCTAssertEqual(msg.oneofSint64, 56) - XCTAssertEqual(msg.o, .oneofSint64(56)) - msg.o = nil - XCTAssertEqual(msg.oneofSint64, 0) - XCTAssertNil(msg.o) - msg.oneofSint64 = 0 - XCTAssertEqual(msg.oneofSint64, 0) - XCTAssertEqual(msg.o, .oneofSint64(0)) - } + func testOneofSint64() { + var msg = SwiftProtoTesting_Message3() + XCTAssertEqual(msg.oneofSint64, 0) + XCTAssertNil(msg.o) + msg.oneofSint64 = 56 + XCTAssertEqual(msg.oneofSint64, 56) + XCTAssertEqual(msg.o, .oneofSint64(56)) + msg.o = nil + XCTAssertEqual(msg.oneofSint64, 0) + XCTAssertNil(msg.o) + msg.oneofSint64 = 0 + XCTAssertEqual(msg.oneofSint64, 0) + XCTAssertEqual(msg.o, .oneofSint64(0)) + } - func testOneofFixed32() { - var msg = ProtobufUnittest_Message3() - XCTAssertEqual(msg.oneofFixed32, 0) - XCTAssertNil(msg.o) - msg.oneofFixed32 = 57 - XCTAssertEqual(msg.oneofFixed32, 57) - XCTAssertEqual(msg.o, .oneofFixed32(57)) - msg.o = nil - XCTAssertEqual(msg.oneofFixed32, 0) - XCTAssertNil(msg.o) - msg.oneofFixed32 = 0 - XCTAssertEqual(msg.oneofFixed32, 0) - XCTAssertEqual(msg.o, .oneofFixed32(0)) - } + func testOneofFixed32() { + var msg = SwiftProtoTesting_Message3() + XCTAssertEqual(msg.oneofFixed32, 0) + XCTAssertNil(msg.o) + msg.oneofFixed32 = 57 + XCTAssertEqual(msg.oneofFixed32, 57) + XCTAssertEqual(msg.o, .oneofFixed32(57)) + msg.o = nil + XCTAssertEqual(msg.oneofFixed32, 0) + XCTAssertNil(msg.o) + msg.oneofFixed32 = 0 + XCTAssertEqual(msg.oneofFixed32, 0) + XCTAssertEqual(msg.o, .oneofFixed32(0)) + } - func testOneofFixed64() { - var msg = ProtobufUnittest_Message3() - XCTAssertEqual(msg.oneofFixed64, 0) - XCTAssertNil(msg.o) - msg.oneofFixed64 = 58 - XCTAssertEqual(msg.oneofFixed64, 58) - XCTAssertEqual(msg.o, .oneofFixed64(58)) - msg.o = nil - XCTAssertEqual(msg.oneofFixed64, 0) - XCTAssertNil(msg.o) - msg.oneofFixed64 = 0 - XCTAssertEqual(msg.oneofFixed64, 0) - XCTAssertEqual(msg.o, .oneofFixed64(0)) - } + func testOneofFixed64() { + var msg = SwiftProtoTesting_Message3() + XCTAssertEqual(msg.oneofFixed64, 0) + XCTAssertNil(msg.o) + msg.oneofFixed64 = 58 + XCTAssertEqual(msg.oneofFixed64, 58) + XCTAssertEqual(msg.o, .oneofFixed64(58)) + msg.o = nil + XCTAssertEqual(msg.oneofFixed64, 0) + XCTAssertNil(msg.o) + msg.oneofFixed64 = 0 + XCTAssertEqual(msg.oneofFixed64, 0) + XCTAssertEqual(msg.o, .oneofFixed64(0)) + } - func testOneofSfixed32() { - var msg = ProtobufUnittest_Message3() - XCTAssertEqual(msg.oneofSfixed32, 0) - XCTAssertNil(msg.o) - msg.oneofSfixed32 = 59 - XCTAssertEqual(msg.oneofSfixed32, 59) - XCTAssertEqual(msg.o, .oneofSfixed32(59)) - msg.o = nil - XCTAssertEqual(msg.oneofSfixed32, 0) - XCTAssertNil(msg.o) - msg.oneofSfixed32 = 0 - XCTAssertEqual(msg.oneofSfixed32, 0) - XCTAssertEqual(msg.o, .oneofSfixed32(0)) - } + func testOneofSfixed32() { + var msg = SwiftProtoTesting_Message3() + XCTAssertEqual(msg.oneofSfixed32, 0) + XCTAssertNil(msg.o) + msg.oneofSfixed32 = 59 + XCTAssertEqual(msg.oneofSfixed32, 59) + XCTAssertEqual(msg.o, .oneofSfixed32(59)) + msg.o = nil + XCTAssertEqual(msg.oneofSfixed32, 0) + XCTAssertNil(msg.o) + msg.oneofSfixed32 = 0 + XCTAssertEqual(msg.oneofSfixed32, 0) + XCTAssertEqual(msg.o, .oneofSfixed32(0)) + } - func testOneofSfixed64() { - var msg = ProtobufUnittest_Message3() - XCTAssertEqual(msg.oneofSfixed64, 0) - XCTAssertNil(msg.o) - msg.oneofSfixed64 = 60 - XCTAssertEqual(msg.oneofSfixed64, 60) - XCTAssertEqual(msg.o, .oneofSfixed64(60)) - msg.o = nil - XCTAssertEqual(msg.oneofSfixed64, 0) - XCTAssertNil(msg.o) - msg.oneofSfixed64 = 0 - XCTAssertEqual(msg.oneofSfixed64, 0) - XCTAssertEqual(msg.o, .oneofSfixed64(0)) - } + func testOneofSfixed64() { + var msg = SwiftProtoTesting_Message3() + XCTAssertEqual(msg.oneofSfixed64, 0) + XCTAssertNil(msg.o) + msg.oneofSfixed64 = 60 + XCTAssertEqual(msg.oneofSfixed64, 60) + XCTAssertEqual(msg.o, .oneofSfixed64(60)) + msg.o = nil + XCTAssertEqual(msg.oneofSfixed64, 0) + XCTAssertNil(msg.o) + msg.oneofSfixed64 = 0 + XCTAssertEqual(msg.oneofSfixed64, 0) + XCTAssertEqual(msg.o, .oneofSfixed64(0)) + } - func testOneofFloat() { - var msg = ProtobufUnittest_Message3() - XCTAssertEqual(msg.oneofFloat, 0.0) - XCTAssertNil(msg.o) - msg.oneofFloat = 61.0 - XCTAssertEqual(msg.oneofFloat, 61.0) - XCTAssertEqual(msg.o, .oneofFloat(61.0)) - msg.o = nil - XCTAssertEqual(msg.oneofFloat, 0.0) - XCTAssertNil(msg.o) - msg.oneofFloat = 0.0 - XCTAssertEqual(msg.oneofFloat, 0.0) - XCTAssertEqual(msg.o, .oneofFloat(0.0)) - } + func testOneofFloat() { + var msg = SwiftProtoTesting_Message3() + XCTAssertEqual(msg.oneofFloat, 0.0) + XCTAssertNil(msg.o) + msg.oneofFloat = 61.0 + XCTAssertEqual(msg.oneofFloat, 61.0) + XCTAssertEqual(msg.o, .oneofFloat(61.0)) + msg.o = nil + XCTAssertEqual(msg.oneofFloat, 0.0) + XCTAssertNil(msg.o) + msg.oneofFloat = 0.0 + XCTAssertEqual(msg.oneofFloat, 0.0) + XCTAssertEqual(msg.o, .oneofFloat(0.0)) + } - func testOneofDouble() { - var msg = ProtobufUnittest_Message3() - XCTAssertEqual(msg.oneofDouble, 0.0) - XCTAssertNil(msg.o) - msg.oneofDouble = 62.0 - XCTAssertEqual(msg.oneofDouble, 62.0) - XCTAssertEqual(msg.o, .oneofDouble(62.0)) - msg.o = nil - XCTAssertEqual(msg.oneofDouble, 0.0) - XCTAssertNil(msg.o) - msg.oneofDouble = 0.0 - XCTAssertEqual(msg.oneofDouble, 0.0) - XCTAssertEqual(msg.o, .oneofDouble(0.0)) - } + func testOneofDouble() { + var msg = SwiftProtoTesting_Message3() + XCTAssertEqual(msg.oneofDouble, 0.0) + XCTAssertNil(msg.o) + msg.oneofDouble = 62.0 + XCTAssertEqual(msg.oneofDouble, 62.0) + XCTAssertEqual(msg.o, .oneofDouble(62.0)) + msg.o = nil + XCTAssertEqual(msg.oneofDouble, 0.0) + XCTAssertNil(msg.o) + msg.oneofDouble = 0.0 + XCTAssertEqual(msg.oneofDouble, 0.0) + XCTAssertEqual(msg.o, .oneofDouble(0.0)) + } - func testOneofBool() { - var msg = ProtobufUnittest_Message3() - XCTAssertEqual(msg.oneofBool, false) - XCTAssertNil(msg.o) - msg.oneofBool = true - XCTAssertEqual(msg.oneofBool, true) - XCTAssertEqual(msg.o, .oneofBool(true)) - msg.o = nil - XCTAssertEqual(msg.oneofBool, false) - XCTAssertNil(msg.o) - msg.oneofBool = false - XCTAssertEqual(msg.oneofBool, false) - XCTAssertEqual(msg.o, .oneofBool(false)) - } + func testOneofBool() { + var msg = SwiftProtoTesting_Message3() + XCTAssertEqual(msg.oneofBool, false) + XCTAssertNil(msg.o) + msg.oneofBool = true + XCTAssertEqual(msg.oneofBool, true) + XCTAssertEqual(msg.o, .oneofBool(true)) + msg.o = nil + XCTAssertEqual(msg.oneofBool, false) + XCTAssertNil(msg.o) + msg.oneofBool = false + XCTAssertEqual(msg.oneofBool, false) + XCTAssertEqual(msg.o, .oneofBool(false)) + } - func testOneofString() { - var msg = ProtobufUnittest_Message3() - XCTAssertEqual(msg.oneofString, "") - XCTAssertNil(msg.o) - msg.oneofString = "64" - XCTAssertEqual(msg.oneofString, "64") - XCTAssertEqual(msg.o, .oneofString("64")) - msg.o = nil - XCTAssertEqual(msg.oneofString, "") - XCTAssertNil(msg.o) - msg.oneofString = "" - XCTAssertEqual(msg.oneofString, "") - XCTAssertEqual(msg.o, .oneofString("")) - } + func testOneofString() { + var msg = SwiftProtoTesting_Message3() + XCTAssertEqual(msg.oneofString, "") + XCTAssertNil(msg.o) + msg.oneofString = "64" + XCTAssertEqual(msg.oneofString, "64") + XCTAssertEqual(msg.o, .oneofString("64")) + msg.o = nil + XCTAssertEqual(msg.oneofString, "") + XCTAssertNil(msg.o) + msg.oneofString = "" + XCTAssertEqual(msg.oneofString, "") + XCTAssertEqual(msg.o, .oneofString("")) + } - func testOneofBytes() { - var msg = ProtobufUnittest_Message3() - XCTAssertEqual(msg.oneofBytes, Data()) - XCTAssertNil(msg.o) - msg.oneofBytes = Data([65]) - XCTAssertEqual(msg.oneofBytes, Data([65])) - XCTAssertEqual(msg.o, .oneofBytes(Data([65]))) - msg.o = nil - XCTAssertEqual(msg.oneofBytes, Data()) - XCTAssertNil(msg.o) - msg.oneofBytes = Data() - XCTAssertEqual(msg.oneofBytes, Data()) - XCTAssertEqual(msg.o, .oneofBytes(Data())) - } + func testOneofBytes() { + var msg = SwiftProtoTesting_Message3() + XCTAssertEqual(msg.oneofBytes, Data()) + XCTAssertNil(msg.o) + msg.oneofBytes = Data([65]) + XCTAssertEqual(msg.oneofBytes, Data([65])) + XCTAssertEqual(msg.o, .oneofBytes(Data([65]))) + msg.o = nil + XCTAssertEqual(msg.oneofBytes, Data()) + XCTAssertNil(msg.o) + msg.oneofBytes = Data() + XCTAssertEqual(msg.oneofBytes, Data()) + XCTAssertEqual(msg.o, .oneofBytes(Data())) + } - // No group. + // No group. - func testOneofMessage() { - var msg = ProtobufUnittest_Message3() - XCTAssertEqual(msg.oneofMessage.optionalInt32, 0) - XCTAssertNil(msg.o) - var subMsg = ProtobufUnittest_Message3() - subMsg.optionalInt32 = 66 - msg.oneofMessage = subMsg - XCTAssertEqual(msg.oneofMessage.optionalInt32, 66) - XCTAssertEqual(msg.oneofMessage, subMsg) - if case .oneofMessage(let v)? = msg.o { - XCTAssertEqual(v.optionalInt32, 66) - XCTAssertEqual(v, subMsg) - } else { - XCTFail("Wasn't the right case") - } - msg.o = nil - XCTAssertEqual(msg.oneofMessage.optionalInt32, 0) - XCTAssertNil(msg.o) - // Default within the message - var subMsg2 = ProtobufUnittest_Message3() - subMsg2.optionalInt32 = 0 - msg.oneofMessage = subMsg2 - XCTAssertEqual(msg.oneofMessage.optionalInt32, 0) - XCTAssertEqual(msg.oneofMessage, subMsg2) - if case .oneofMessage(let v)? = msg.o { - XCTAssertEqual(v.optionalInt32, 0) - XCTAssertEqual(v, subMsg2) - } else { - XCTFail("Wasn't the right case") + func testOneofMessage() { + var msg = SwiftProtoTesting_Message3() + XCTAssertEqual(msg.oneofMessage.optionalInt32, 0) + XCTAssertNil(msg.o) + var subMsg = SwiftProtoTesting_Message3() + subMsg.optionalInt32 = 66 + msg.oneofMessage = subMsg + XCTAssertEqual(msg.oneofMessage.optionalInt32, 66) + XCTAssertEqual(msg.oneofMessage, subMsg) + if case .oneofMessage(let v)? = msg.o { + XCTAssertEqual(v.optionalInt32, 66) + XCTAssertEqual(v, subMsg) + } else { + XCTFail("Wasn't the right case") + } + msg.o = nil + XCTAssertEqual(msg.oneofMessage.optionalInt32, 0) + XCTAssertNil(msg.o) + // Default within the message + var subMsg2 = SwiftProtoTesting_Message3() + subMsg2.optionalInt32 = 0 + msg.oneofMessage = subMsg2 + XCTAssertEqual(msg.oneofMessage.optionalInt32, 0) + XCTAssertEqual(msg.oneofMessage, subMsg2) + if case .oneofMessage(let v)? = msg.o { + XCTAssertEqual(v.optionalInt32, 0) + XCTAssertEqual(v, subMsg2) + } else { + XCTFail("Wasn't the right case") + } + msg.o = nil + // Message with nothing set. + let subMsg3 = SwiftProtoTesting_Message3() + msg.oneofMessage = subMsg3 + XCTAssertEqual(msg.oneofMessage.optionalInt32, 0) + XCTAssertEqual(msg.oneofMessage, subMsg3) + if case .oneofMessage(let v)? = msg.o { + XCTAssertEqual(v.optionalInt32, 0) + XCTAssertEqual(v, subMsg3) + } else { + XCTFail("Wasn't the right case") + } } - msg.o = nil - // Message with nothing set. - let subMsg3 = ProtobufUnittest_Message3() - msg.oneofMessage = subMsg3 - XCTAssertEqual(msg.oneofMessage.optionalInt32, 0) - XCTAssertEqual(msg.oneofMessage, subMsg3) - if case .oneofMessage(let v)? = msg.o { - XCTAssertEqual(v.optionalInt32, 0) - XCTAssertEqual(v, subMsg3) - } else { - XCTFail("Wasn't the right case") + + func testOneofEnum() { + var msg = SwiftProtoTesting_Message3() + XCTAssertEqual(msg.oneofEnum, .foo) + XCTAssertNil(msg.o) + msg.oneofEnum = .bar + XCTAssertEqual(msg.oneofEnum, .bar) + XCTAssertEqual(msg.o, .oneofEnum(.bar)) + msg.o = nil + XCTAssertEqual(msg.oneofEnum, .foo) + XCTAssertNil(msg.o) + msg.oneofEnum = .foo + XCTAssertEqual(msg.oneofEnum, .foo) + XCTAssertEqual(msg.o, .oneofEnum(.foo)) } - } - func testOneofEnum() { - var msg = ProtobufUnittest_Message3() - XCTAssertEqual(msg.oneofEnum, .foo) - XCTAssertNil(msg.o) - msg.oneofEnum = .bar - XCTAssertEqual(msg.oneofEnum, .bar) - XCTAssertEqual(msg.o, .oneofEnum(.bar)) - msg.o = nil - XCTAssertEqual(msg.oneofEnum, .foo) - XCTAssertNil(msg.o) - msg.oneofEnum = .foo - XCTAssertEqual(msg.oneofEnum, .foo) - XCTAssertEqual(msg.o, .oneofEnum(.foo)) - } + // Chaining. Set each item in the oneof clear the previous one. - // Chaining. Set each item in the oneof clear the previous one. + func testOneofOnlyOneSet() { + var msg = SwiftProtoTesting_Message3() - func testOneofOnlyOneSet() { - var msg = ProtobufUnittest_Message3() + func assertRightFiledSet(_ i: Int) { + // Make sure the case is correct for the enum based access. + switch msg.o { + case nil: + XCTAssertEqual(i, 0) + case .oneofInt32(let v)?: + XCTAssertEqual(i, 1) + XCTAssertEqual(v, 51) + case .oneofInt64(let v)?: + XCTAssertEqual(i, 2) + XCTAssertEqual(v, 52) + case .oneofUint32(let v)?: + XCTAssertEqual(i, 3) + XCTAssertEqual(v, 53) + case .oneofUint64(let v)?: + XCTAssertEqual(i, 4) + XCTAssertEqual(v, 54) + case .oneofSint32(let v)?: + XCTAssertEqual(i, 5) + XCTAssertEqual(v, 55) + case .oneofSint64(let v)?: + XCTAssertEqual(i, 6) + XCTAssertEqual(v, 56) + case .oneofFixed32(let v)?: + XCTAssertEqual(i, 7) + XCTAssertEqual(v, 57) + case .oneofFixed64(let v)?: + XCTAssertEqual(i, 8) + XCTAssertEqual(v, 58) + case .oneofSfixed32(let v)?: + XCTAssertEqual(i, 9) + XCTAssertEqual(v, 59) + case .oneofSfixed64(let v)?: + XCTAssertEqual(i, 10) + XCTAssertEqual(v, 60) + case .oneofFloat(let v)?: + XCTAssertEqual(i, 11) + XCTAssertEqual(v, 61.0) + case .oneofDouble(let v)?: + XCTAssertEqual(i, 12) + XCTAssertEqual(v, 62.0) + case .oneofBool(let v)?: + XCTAssertEqual(i, 13) + XCTAssertEqual(v, true) + case .oneofString(let v)?: + XCTAssertEqual(i, 14) + XCTAssertEqual(v, "64") + case .oneofBytes(let v)?: + XCTAssertEqual(i, 15) + XCTAssertEqual(v, Data([65])) + // No group. + case .oneofMessage(let v)?: + XCTAssertEqual(i, 17) + XCTAssertEqual(v.optionalInt32, 68) + case .oneofEnum(let v)?: + XCTAssertEqual(i, 18) + XCTAssertEqual(v, .bar) + } - func assertRightFiledSet(_ i: Int) { - // Make sure the case is correct for the enum based access. - switch msg.o { - case nil: - XCTAssertEqual(i, 0) - case .oneofInt32(let v)?: - XCTAssertEqual(i, 1) - XCTAssertEqual(v, 51) - case .oneofInt64(let v)?: - XCTAssertEqual(i, 2) - XCTAssertEqual(v, 52) - case .oneofUint32(let v)?: - XCTAssertEqual(i, 3) - XCTAssertEqual(v, 53) - case .oneofUint64(let v)?: - XCTAssertEqual(i, 4) - XCTAssertEqual(v, 54) - case .oneofSint32(let v)?: - XCTAssertEqual(i, 5) - XCTAssertEqual(v, 55) - case .oneofSint64(let v)?: - XCTAssertEqual(i, 6) - XCTAssertEqual(v, 56) - case .oneofFixed32(let v)?: - XCTAssertEqual(i, 7) - XCTAssertEqual(v, 57) - case .oneofFixed64(let v)?: - XCTAssertEqual(i, 8) - XCTAssertEqual(v, 58) - case .oneofSfixed32(let v)?: - XCTAssertEqual(i, 9) - XCTAssertEqual(v, 59) - case .oneofSfixed64(let v)?: - XCTAssertEqual(i, 10) - XCTAssertEqual(v, 60) - case .oneofFloat(let v)?: - XCTAssertEqual(i, 11) - XCTAssertEqual(v, 61.0) - case .oneofDouble(let v)?: - XCTAssertEqual(i, 12) - XCTAssertEqual(v, 62.0) - case .oneofBool(let v)?: - XCTAssertEqual(i, 13) - XCTAssertEqual(v, true) - case .oneofString(let v)?: - XCTAssertEqual(i, 14) - XCTAssertEqual(v, "64") - case .oneofBytes(let v)?: - XCTAssertEqual(i, 15) - XCTAssertEqual(v, Data([65])) - // No group. - case .oneofMessage(let v)?: - XCTAssertEqual(i, 17) - XCTAssertEqual(v.optionalInt32, 68) - case .oneofEnum(let v)?: - XCTAssertEqual(i, 18) - XCTAssertEqual(v, .bar) - } + // Check direct field access (gets the right value or the default) + if i == 1 { + XCTAssertEqual(msg.oneofInt32, 51) + } else { + XCTAssertEqual(msg.oneofInt32, 0, "i = \(i)") + } + if i == 2 { + XCTAssertEqual(msg.oneofInt64, 52) + } else { + XCTAssertEqual(msg.oneofInt64, 0, "i = \(i)") + } + if i == 3 { + XCTAssertEqual(msg.oneofUint32, 53) + } else { + XCTAssertEqual(msg.oneofUint32, 0, "i = \(i)") + } + if i == 4 { + XCTAssertEqual(msg.oneofUint64, 54) + } else { + XCTAssertEqual(msg.oneofUint64, 0, "i = \(i)") + } + if i == 5 { + XCTAssertEqual(msg.oneofSint32, 55) + } else { + XCTAssertEqual(msg.oneofSint32, 0, "i = \(i)") + } + if i == 6 { + XCTAssertEqual(msg.oneofSint64, 56) + } else { + XCTAssertEqual(msg.oneofSint64, 0, "i = \(i)") + } + if i == 7 { + XCTAssertEqual(msg.oneofFixed32, 57) + } else { + XCTAssertEqual(msg.oneofFixed32, 0, "i = \(i)") + } + if i == 8 { + XCTAssertEqual(msg.oneofFixed64, 58) + } else { + XCTAssertEqual(msg.oneofFixed64, 0, "i = \(i)") + } + if i == 9 { + XCTAssertEqual(msg.oneofSfixed32, 59) + } else { + XCTAssertEqual(msg.oneofSfixed32, 0, "i = \(i)") + } + if i == 10 { + XCTAssertEqual(msg.oneofSfixed64, 60) + } else { + XCTAssertEqual(msg.oneofSfixed64, 0, "i = \(i)") + } + if i == 11 { + XCTAssertEqual(msg.oneofFloat, 61.0) + } else { + XCTAssertEqual(msg.oneofFloat, 0.0, "i = \(i)") + } + if i == 12 { + XCTAssertEqual(msg.oneofDouble, 62.0) + } else { + XCTAssertEqual(msg.oneofDouble, 0.0, "i = \(i)") + } + if i == 13 { + XCTAssertEqual(msg.oneofBool, true) + } else { + XCTAssertEqual(msg.oneofBool, false, "i = \(i)") + } + if i == 14 { + XCTAssertEqual(msg.oneofString, "64") + } else { + XCTAssertEqual(msg.oneofString, "", "i = \(i)") + } + if i == 15 { + XCTAssertEqual(msg.oneofBytes, Data([65])) + } else { + XCTAssertEqual(msg.oneofBytes, Data(), "i = \(i)") + } + // No group + if i == 17 { + XCTAssertEqual(msg.oneofMessage.optionalInt32, 68) + } else { + XCTAssertEqual(msg.oneofMessage.optionalInt32, 0, "i = \(i)") + } + if i == 18 { + XCTAssertEqual(msg.oneofEnum, .bar) + } else { + XCTAssertEqual(msg.oneofEnum, .foo, "i = \(i)") + } + } - // Check direct field access (gets the right value or the default) - if i == 1 { - XCTAssertEqual(msg.oneofInt32, 51) - } else { - XCTAssertEqual(msg.oneofInt32, 0, "i = \(i)") - } - if i == 2 { - XCTAssertEqual(msg.oneofInt64, 52) - } else { - XCTAssertEqual(msg.oneofInt64, 0, "i = \(i)") - } - if i == 3 { - XCTAssertEqual(msg.oneofUint32, 53) - } else { - XCTAssertEqual(msg.oneofUint32, 0, "i = \(i)") - } - if i == 4 { - XCTAssertEqual(msg.oneofUint64, 54) - } else { - XCTAssertEqual(msg.oneofUint64, 0, "i = \(i)") - } - if i == 5 { - XCTAssertEqual(msg.oneofSint32, 55) - } else { - XCTAssertEqual(msg.oneofSint32, 0, "i = \(i)") - } - if i == 6 { - XCTAssertEqual(msg.oneofSint64, 56) - } else { - XCTAssertEqual(msg.oneofSint64, 0, "i = \(i)") - } - if i == 7 { - XCTAssertEqual(msg.oneofFixed32, 57) - } else { - XCTAssertEqual(msg.oneofFixed32, 0, "i = \(i)") - } - if i == 8 { - XCTAssertEqual(msg.oneofFixed64, 58) - } else { - XCTAssertEqual(msg.oneofFixed64, 0, "i = \(i)") - } - if i == 9 { - XCTAssertEqual(msg.oneofSfixed32, 59) - } else { - XCTAssertEqual(msg.oneofSfixed32, 0, "i = \(i)") - } - if i == 10 { - XCTAssertEqual(msg.oneofSfixed64, 60) - } else { - XCTAssertEqual(msg.oneofSfixed64, 0, "i = \(i)") - } - if i == 11 { - XCTAssertEqual(msg.oneofFloat, 61.0) - } else { - XCTAssertEqual(msg.oneofFloat, 0.0, "i = \(i)") - } - if i == 12 { - XCTAssertEqual(msg.oneofDouble, 62.0) - } else { - XCTAssertEqual(msg.oneofDouble, 0.0, "i = \(i)") - } - if i == 13 { - XCTAssertEqual(msg.oneofBool, true) - } else { - XCTAssertEqual(msg.oneofBool, false, "i = \(i)") - } - if i == 14 { - XCTAssertEqual(msg.oneofString, "64") - } else { - XCTAssertEqual(msg.oneofString, "", "i = \(i)") - } - if i == 15 { - XCTAssertEqual(msg.oneofBytes, Data([65])) - } else { - XCTAssertEqual(msg.oneofBytes, Data(), "i = \(i)") - } - // No group - if i == 17 { - XCTAssertEqual(msg.oneofMessage.optionalInt32, 68) - } else { - XCTAssertEqual(msg.oneofMessage.optionalInt32, 0, "i = \(i)") - } - if i == 18 { - XCTAssertEqual(msg.oneofEnum, .bar) - } else { - XCTAssertEqual(msg.oneofEnum, .foo, "i = \(i)") - } + // Now cycle through the cases. + assertRightFiledSet(0) + msg.oneofInt32 = 51 + assertRightFiledSet(1) + msg.oneofInt64 = 52 + assertRightFiledSet(2) + msg.oneofUint32 = 53 + assertRightFiledSet(3) + msg.oneofUint64 = 54 + assertRightFiledSet(4) + msg.oneofSint32 = 55 + assertRightFiledSet(5) + msg.oneofSint64 = 56 + assertRightFiledSet(6) + msg.oneofFixed32 = 57 + assertRightFiledSet(7) + msg.oneofFixed64 = 58 + assertRightFiledSet(8) + msg.oneofSfixed32 = 59 + assertRightFiledSet(9) + msg.oneofSfixed64 = 60 + assertRightFiledSet(10) + msg.oneofFloat = 61 + assertRightFiledSet(11) + msg.oneofDouble = 62 + assertRightFiledSet(12) + msg.oneofBool = true + assertRightFiledSet(13) + msg.oneofString = "64" + assertRightFiledSet(14) + msg.oneofBytes = Data([65]) + assertRightFiledSet(15) + // No group + msg.oneofMessage.optionalInt32 = 68 + assertRightFiledSet(17) + msg.oneofEnum = .bar + assertRightFiledSet(18) } - - // Now cycle through the cases. - assertRightFiledSet(0) - msg.oneofInt32 = 51 - assertRightFiledSet(1) - msg.oneofInt64 = 52 - assertRightFiledSet(2) - msg.oneofUint32 = 53 - assertRightFiledSet(3) - msg.oneofUint64 = 54 - assertRightFiledSet(4) - msg.oneofSint32 = 55 - assertRightFiledSet(5) - msg.oneofSint64 = 56 - assertRightFiledSet(6) - msg.oneofFixed32 = 57 - assertRightFiledSet(7) - msg.oneofFixed64 = 58 - assertRightFiledSet(8) - msg.oneofSfixed32 = 59 - assertRightFiledSet(9) - msg.oneofSfixed64 = 60 - assertRightFiledSet(10) - msg.oneofFloat = 61 - assertRightFiledSet(11) - msg.oneofDouble = 62 - assertRightFiledSet(12) - msg.oneofBool = true - assertRightFiledSet(13) - msg.oneofString = "64" - assertRightFiledSet(14) - msg.oneofBytes = Data([65]) - assertRightFiledSet(15) - // No group - msg.oneofMessage.optionalInt32 = 68 - assertRightFiledSet(17) - msg.oneofEnum = .bar - assertRightFiledSet(18) - } } diff --git a/Tests/SwiftProtobufTests/Test_OneofSwitchSplit.swift b/Tests/SwiftProtobufTests/Test_OneofSwitchSplit.swift new file mode 100644 index 000000000..ea63c5273 --- /dev/null +++ b/Tests/SwiftProtobufTests/Test_OneofSwitchSplit.swift @@ -0,0 +1,75 @@ +// Tests/SwiftProtobufTests/Test_OneofSwitchSplit.swift +// +// Copyright (c) 2014 - 2025 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// Test that large oneof fields with split switch statements work correctly. +/// This proto has 508 oneof fields with 2 interleaved regular fields that +/// create chunks. With maxCasesInSwitch=500, this tests both: +/// - Chunking: regular fields at 251 and 502 split the oneof into 3 groups +/// - Each chunk is under 500 fields, so no further splitting within chunks +/// +/// The primary testing is through reference file inspection (see Reference/). +/// These runtime tests are minimal smoke tests to verify basic functionality. +/// +// ----------------------------------------------------------------------------- + +import Foundation +import SwiftProtobuf +import XCTest + +final class Test_OneofSwitchSplit: XCTestCase { + + func testChunkBoundaries() throws { + var msg = SwiftProtoTesting_SwitchSplit_SwitchSplitMessage() + + // Test chunk 1: fields 1-250 (before regular_field_251) + msg.field001 = 1 + XCTAssertEqual(msg.field001, 1) + msg.field250 = 250 + XCTAssertEqual(msg.field250, 250) + + // Test chunk 2: fields 252-501 (between regular fields) + msg.field252 = 252 + XCTAssertEqual(msg.field252, 252) + msg.field501 = 501 + XCTAssertEqual(msg.field501, 501) + + // Test chunk 3: fields 503-510 (after regular_field_502) + msg.field503 = 503 + XCTAssertEqual(msg.field503, 503) + msg.field510 = 510 + XCTAssertEqual(msg.field510, 510) + + // Test regular fields don't interfere with oneof + msg.regularField251 = 999 + XCTAssertEqual(msg.regularField251, 999) + XCTAssertEqual(msg.field510, 510) + } + + func testSerializationAcrossChunks() throws { + // Test serialization from each chunk + var msg1 = SwiftProtoTesting_SwitchSplit_SwitchSplitMessage() + msg1.field100 = 100 + let data1 = try msg1.serializedData() + let decoded1 = try SwiftProtoTesting_SwitchSplit_SwitchSplitMessage(serializedBytes: data1) + XCTAssertEqual(decoded1.field100, 100) + + var msg2 = SwiftProtoTesting_SwitchSplit_SwitchSplitMessage() + msg2.field400 = 400 + let data2 = try msg2.serializedData() + let decoded2 = try SwiftProtoTesting_SwitchSplit_SwitchSplitMessage(serializedBytes: data2) + XCTAssertEqual(decoded2.field400, 400) + + var msg3 = SwiftProtoTesting_SwitchSplit_SwitchSplitMessage() + msg3.field505 = 505 + let data3 = try msg3.serializedData() + let decoded3 = try SwiftProtoTesting_SwitchSplit_SwitchSplitMessage(serializedBytes: data3) + XCTAssertEqual(decoded3.field505, 505) + } +} diff --git a/Tests/SwiftProtobufTests/Test_OpcodeCompatibility.swift b/Tests/SwiftProtobufTests/Test_OpcodeCompatibility.swift new file mode 100644 index 000000000..16b6adb9e --- /dev/null +++ b/Tests/SwiftProtobufTests/Test_OpcodeCompatibility.swift @@ -0,0 +1,57 @@ +// Tests/SwiftProtobufTests/Test_OpcodeCompatibility.swift +// +// Copyright (c) 2014 - 2025 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- +/// +/// Ensures that numeric values of instructions used in runtime bytecode do not +/// change accidentally. +/// +// ----------------------------------------------------------------------------- + +import SwiftProtobuf +import XCTest + +/// WARNING: If these tests fail, you have BROKEN COMPATIBILITY with the current +/// version of the runtime! +final class Test_OpcodeCompatibility: XCTestCase { + func testProtoNameInstruction() { + assertOpcodes([ + (ProtoNameInstruction.sameNext, 1), + (ProtoNameInstruction.sameDelta, 2), + (ProtoNameInstruction.standardNext, 3), + (ProtoNameInstruction.standardDelta, 4), + (ProtoNameInstruction.uniqueNext, 5), + (ProtoNameInstruction.uniqueDelta, 6), + (ProtoNameInstruction.groupNext, 7), + (ProtoNameInstruction.groupDelta, 8), + (ProtoNameInstruction.aliasNext, 9), + (ProtoNameInstruction.aliasDelta, 10), + (ProtoNameInstruction.reservedName, 11), + (ProtoNameInstruction.reservedNumbers, 12), + ]) + } + + private func assertOpcodes( + _ pairs: [(Instruction, Int)], + file: StaticString = #file, + line: UInt = #line + ) where Instruction.RawValue == UInt64 { + for pair in pairs { + XCTAssertEqual( + pair.0.rawValue, + UInt64(pair.1), + "COMPATIBILITY BREAK: Instruction \(pair.0) expected to have opcode \(pair.1), but got \(pair.0.rawValue)" + ) + } + XCTAssertEqual( + pairs.count, + Instruction.allCases.count, + "Not all instructions are covered by this test; please update it" + ) + } +} diff --git a/Tests/SwiftProtobufTests/Test_Packed.swift b/Tests/SwiftProtobufTests/Test_Packed.swift index fa4622af4..3024157ce 100644 --- a/Tests/SwiftProtobufTests/Test_Packed.swift +++ b/Tests/SwiftProtobufTests/Test_Packed.swift @@ -16,17 +16,21 @@ import Foundation import XCTest -class Test_Packed: XCTestCase, PBTestHelpers { - typealias MessageTestType = ProtobufUnittest_TestPackedTypes +final class Test_Packed: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_TestPackedTypes func testEncoding_packedInt32() { - assertEncode([210, 5, 16, 255, 255, 255, 255, 7, 0, 128, 128, 128, 128, 248, 255, 255, 255, 255, 1]) {(o: inout MessageTestType) in o.packedInt32 = [Int32.max, 0, Int32.min]} - assertDecodeSucceeds([210, 5, 6, 8, 247, 255, 255, 255, 15]) {$0.packedInt32 == [8, -9]} - assertDecodeSucceeds([210, 5, 0]) {$0.packedInt32 == []} - assertDecodeSucceeds([208, 5, 0, 208, 5, 1]) {$0.packedInt32 == [0, 1]} // Also accept non-packed + assertEncode([210, 5, 16, 255, 255, 255, 255, 7, 0, 128, 128, 128, 128, 248, 255, 255, 255, 255, 1]) { + (o: inout MessageTestType) in o.packedInt32 = [Int32.max, 0, Int32.min] + } + assertDecodeSucceeds([210, 5, 6, 8, 247, 255, 255, 255, 15]) { $0.packedInt32 == [8, -9] } + assertDecodeSucceeds([210, 5, 0]) { $0.packedInt32 == [] } + assertDecodeSucceeds([208, 5, 0, 208, 5, 1]) { $0.packedInt32 == [0, 1] } // Also accept non-packed // Truncate 32-bit values that overflow - assertDecodeSucceeds([210, 5, 11, 8, 247, 255, 255, 255, 255, 255, 255, 255, 255, 1]) {$0.packedInt32 == [8, -9]} + assertDecodeSucceeds([210, 5, 11, 8, 247, 255, 255, 255, 255, 255, 255, 255, 255, 1]) { + $0.packedInt32 == [8, -9] + } assertDecodeFails([210, 5, 12, 8, 247, 255, 255, 255, 255, 255, 255, 255, 255, 1]) assertDecodeFails([210, 5, 10, 8, 247, 255, 255, 255, 255, 255, 255, 255, 255]) @@ -39,13 +43,24 @@ class Test_Packed: XCTestCase, PBTestHelpers { } func testEncoding_packedInt64() { - assertEncode([218, 5, 20, 255, 255, 255, 255, 255, 255, 255, 255, 127, 0, 128, 128, 128, 128, 128, 128, 128, 128, 128, 1]) {(o: inout MessageTestType) in o.packedInt64 = [Int64.max, 0, Int64.min]} - assertDecodeSucceeds([218, 5, 18, 255, 255, 153, 166, 234, 175, 227, 1, 185, 156, 196, 237, 158, 222, 230, 255, 255, 1]) {$0.packedInt64 == [999999999999999, -111111111111111]} - assertDecodeSucceeds([218, 5, 18, 255, 255, 153, 166, 234, 175, 227, 1, 185, 156, 196, 237, 158, 222, 230, 255, 255, 1, 218, 5, 18, 255, 255, 153, 166, 234, 175, 227, 1, 185, 156, 196, 237, 158, 222, 230, 255, 255, 1]) {$0.packedInt64 == [999999999999999, -111111111111111, 999999999999999, -111111111111111]} - assertDecodeSucceeds([218, 5, 0]) {$0.packedInt64 == []} - assertDecodeFails([218, 5, 19, 255, 255, 153, 166, 234, 175, 227, 1, 185, 156, 196, 237, 158, 222, 230, 255, 255, 1]) - assertDecodeFails([218, 5, 17, 255, 255, 153, 166, 234, 175, 227, 1, 185, 156, 196, 237, 158, 222, 230, 255, 255]) - assertDecodeSucceeds([216, 5, 0]) {$0.packedInt64 == [0]} // Accept non-packed encoding + assertEncode([ + 218, 5, 20, 255, 255, 255, 255, 255, 255, 255, 255, 127, 0, 128, 128, 128, 128, 128, 128, 128, 128, 128, 1, + ]) { (o: inout MessageTestType) in o.packedInt64 = [Int64.max, 0, Int64.min] } + assertDecodeSucceeds([ + 218, 5, 18, 255, 255, 153, 166, 234, 175, 227, 1, 185, 156, 196, 237, 158, 222, 230, 255, 255, 1, + ]) { $0.packedInt64 == [999_999_999_999_999, -111_111_111_111_111] } + assertDecodeSucceeds([ + 218, 5, 18, 255, 255, 153, 166, 234, 175, 227, 1, 185, 156, 196, 237, 158, 222, 230, 255, 255, 1, 218, 5, + 18, 255, 255, 153, 166, 234, 175, 227, 1, 185, 156, 196, 237, 158, 222, 230, 255, 255, 1, + ]) { $0.packedInt64 == [999_999_999_999_999, -111_111_111_111_111, 999_999_999_999_999, -111_111_111_111_111] } + assertDecodeSucceeds([218, 5, 0]) { $0.packedInt64 == [] } + assertDecodeFails([ + 218, 5, 19, 255, 255, 153, 166, 234, 175, 227, 1, 185, 156, 196, 237, 158, 222, 230, 255, 255, 1, + ]) + assertDecodeFails([ + 218, 5, 17, 255, 255, 153, 166, 234, 175, 227, 1, 185, 156, 196, 237, 158, 222, 230, 255, 255, + ]) + assertDecodeSucceeds([216, 5, 0]) { $0.packedInt64 == [0] } // Accept non-packed encoding assertDecodeFails([217, 5]) assertDecodeFails([217, 5, 0]) assertDecodeFails([217, 5, 217, 5]) @@ -67,12 +82,18 @@ class Test_Packed: XCTestCase, PBTestHelpers { } func testEncoding_packedUint32() { - assertEncode([226, 5, 6, 255, 255, 255, 255, 15, 0]) {(o: inout MessageTestType) in o.packedUint32 = [UInt32.max, UInt32.min]} - assertDecodeSucceeds([226, 5, 5, 210, 9, 213, 187, 3]) {$0.packedUint32 == [1234, 56789]} - assertDecodeSucceeds([226, 5, 12, 255, 255, 255, 255, 15, 255, 255, 255, 255, 7, 1, 0]) {$0.packedUint32 == [4294967295, 2147483647, 1, 0]} - assertDecodeSucceeds([224, 5, 1, 224, 5, 2]) {$0.packedUint32 == [1, 2]} + assertEncode([226, 5, 6, 255, 255, 255, 255, 15, 0]) { (o: inout MessageTestType) in + o.packedUint32 = [UInt32.max, UInt32.min] + } + assertDecodeSucceeds([226, 5, 5, 210, 9, 213, 187, 3]) { $0.packedUint32 == [1234, 56789] } + assertDecodeSucceeds([226, 5, 12, 255, 255, 255, 255, 15, 255, 255, 255, 255, 7, 1, 0]) { + $0.packedUint32 == [4_294_967_295, 2_147_483_647, 1, 0] + } + assertDecodeSucceeds([224, 5, 1, 224, 5, 2]) { $0.packedUint32 == [1, 2] } // Truncate on 32-bit overflow - assertDecodeSucceeds([226, 5, 12, 255, 255, 255, 255, 31, 255, 255, 255, 255, 7, 1, 0]) {$0.packedUint32 == [4294967295, 2147483647, 1, 0]} + assertDecodeSucceeds([226, 5, 12, 255, 255, 255, 255, 31, 255, 255, 255, 255, 7, 1, 0]) { + $0.packedUint32 == [4_294_967_295, 2_147_483_647, 1, 0] + } assertDecodeFails([226, 5, 4, 255, 255, 255, 255]) assertDecodeFails([225, 5, 0]) @@ -90,12 +111,16 @@ class Test_Packed: XCTestCase, PBTestHelpers { } func testEncoding_packedUint64() { - assertEncode([234, 5, 11, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1, 0]) {(o: inout MessageTestType) in o.packedUint64 = [UInt64.max, UInt64.min]} - assertDecodeSucceeds([234, 5, 9, 149, 154, 239, 58, 177, 209, 249, 214, 3]) {$0.packedUint64 == [123456789, 987654321]} - assertDecodeSucceeds([234, 5, 0]) {$0.packedUint64 == []} - assertDecodeSucceeds([234, 5, 1, 1, 232, 5, 2]) {$0.packedUint64 == [1, 2]} - assertDecodeFails([234, 5, 9, 149, 154, 239, 58, 177, 209, 249, 4]) // Truncated body - assertDecodeFails([234, 5, 8, 149, 154, 239, 58, 177, 209, 249, 214]) // Malformed varint + assertEncode([234, 5, 11, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1, 0]) { (o: inout MessageTestType) in + o.packedUint64 = [UInt64.max, UInt64.min] + } + assertDecodeSucceeds([234, 5, 9, 149, 154, 239, 58, 177, 209, 249, 214, 3]) { + $0.packedUint64 == [123_456_789, 987_654_321] + } + assertDecodeSucceeds([234, 5, 0]) { $0.packedUint64 == [] } + assertDecodeSucceeds([234, 5, 1, 1, 232, 5, 2]) { $0.packedUint64 == [1, 2] } + assertDecodeFails([234, 5, 9, 149, 154, 239, 58, 177, 209, 249, 4]) // Truncated body + assertDecodeFails([234, 5, 8, 149, 154, 239, 58, 177, 209, 249, 214]) // Malformed varint assertDecodeFails([233, 5]) assertDecodeFails([233, 5, 0]) assertDecodeFails([235, 5]) @@ -111,17 +136,23 @@ class Test_Packed: XCTestCase, PBTestHelpers { } func testEncoding_packedSint32() { - assertEncode([242, 5, 10, 254, 255, 255, 255, 15, 255, 255, 255, 255, 15]) {(o: inout MessageTestType) in o.packedSint32 = [Int32.max, Int32.min]} - assertDecodeSucceeds([242, 5, 13, 255, 255, 255, 255, 15, 1, 0, 2, 254, 255, 255, 255, 15]) {$0.packedSint32 == [-2147483648, -1, 0, 1, 2147483647]} - assertDecodeSucceeds([242, 5, 5, 255, 255, 255, 255, 15, 242, 5, 3, 1, 0, 2, 242, 5, 0, 242, 5, 5, 254, 255, 255, 255, 15]) {$0.packedSint32 == [-2147483648, -1, 0, 1, 2147483647]} - assertDecodeSucceeds([242, 5, 0]) {$0.packedSint32 == []} - assertDecodeSucceeds([240, 5, 0]) {$0.packedSint32 == [0]} - assertDecodeSucceeds([242, 5, 0, 240, 5, 0]) {$0.packedSint32 == [0]} + assertEncode([242, 5, 10, 254, 255, 255, 255, 15, 255, 255, 255, 255, 15]) { (o: inout MessageTestType) in + o.packedSint32 = [Int32.max, Int32.min] + } + assertDecodeSucceeds([242, 5, 13, 255, 255, 255, 255, 15, 1, 0, 2, 254, 255, 255, 255, 15]) { + $0.packedSint32 == [-2_147_483_648, -1, 0, 1, 2_147_483_647] + } + assertDecodeSucceeds([ + 242, 5, 5, 255, 255, 255, 255, 15, 242, 5, 3, 1, 0, 2, 242, 5, 0, 242, 5, 5, 254, 255, 255, 255, 15, + ]) { $0.packedSint32 == [-2_147_483_648, -1, 0, 1, 2_147_483_647] } + assertDecodeSucceeds([242, 5, 0]) { $0.packedSint32 == [] } + assertDecodeSucceeds([240, 5, 0]) { $0.packedSint32 == [0] } + assertDecodeSucceeds([242, 5, 0, 240, 5, 0]) { $0.packedSint32 == [0] } // 32-bit overflow truncates - assertDecodeSucceeds([242, 5, 5, 255, 255, 255, 255, 127]) {$0.packedSint32 == [-2147483648]} + assertDecodeSucceeds([242, 5, 5, 255, 255, 255, 255, 127]) { $0.packedSint32 == [-2_147_483_648] } - assertDecodeFails([242, 5, 5, 255, 255, 255, 255]) // truncated body - assertDecodeFails([242, 5, 4, 255, 255, 255, 255]) // malformed varint + assertDecodeFails([242, 5, 5, 255, 255, 255, 255]) // truncated body + assertDecodeFails([242, 5, 4, 255, 255, 255, 255]) // malformed varint assertDecodeFails([241, 5]) assertDecodeFails([241, 5, 0]) assertDecodeFails([243, 5]) @@ -137,11 +168,17 @@ class Test_Packed: XCTestCase, PBTestHelpers { } func testEncoding_packedSint64() { - assertEncode([250, 5, 20, 254, 255, 255, 255, 255, 255, 255, 255, 255, 1, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1]) {(o: inout MessageTestType) in o.packedSint64 = [Int64.max, Int64.min]} - assertDecodeSucceeds([250, 5, 9, 170, 180, 222, 117, 225, 162, 243, 173, 7]) {$0.packedSint64 == [123456789, -987654321]} - assertDecodeSucceeds([250, 5, 4, 170, 180, 222, 117, 250, 5, 5, 225, 162, 243, 173, 7]) {$0.packedSint64 == [123456789, -987654321]} - assertDecodeSucceeds([248, 5, 0, 250, 5, 2, 1, 2]) {$0.packedSint64 == [0, -1, 1]} - assertDecodeSucceeds([250, 5, 0]) {$0.packedSint64 == []} + assertEncode([ + 250, 5, 20, 254, 255, 255, 255, 255, 255, 255, 255, 255, 1, 255, 255, 255, 255, 255, 255, 255, 255, 255, 1, + ]) { (o: inout MessageTestType) in o.packedSint64 = [Int64.max, Int64.min] } + assertDecodeSucceeds([250, 5, 9, 170, 180, 222, 117, 225, 162, 243, 173, 7]) { + $0.packedSint64 == [123_456_789, -987_654_321] + } + assertDecodeSucceeds([250, 5, 4, 170, 180, 222, 117, 250, 5, 5, 225, 162, 243, 173, 7]) { + $0.packedSint64 == [123_456_789, -987_654_321] + } + assertDecodeSucceeds([248, 5, 0, 250, 5, 2, 1, 2]) { $0.packedSint64 == [0, -1, 1] } + assertDecodeSucceeds([250, 5, 0]) { $0.packedSint64 == [] } assertDecodeFails([250, 5, 9, 170, 180, 222, 117, 225, 162, 243, 7]) assertDecodeFails([250, 5, 8, 170, 180, 222, 117, 225, 162, 243, 173]) assertDecodeFails([249, 5]) @@ -159,11 +196,17 @@ class Test_Packed: XCTestCase, PBTestHelpers { } func testEncoding_packedFixed32() { - assertEncode([130, 6, 8, 255, 255, 255, 255, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.packedFixed32 = [UInt32.max, UInt32.min]} - assertDecodeSucceeds([130, 6, 8, 255, 255, 255, 127, 255, 255, 255, 255]) {$0.packedFixed32 == [2147483647, 4294967295]} - assertDecodeSucceeds([130, 6, 4, 255, 255, 255, 127, 130, 6, 4, 255, 255, 255, 255]) {$0.packedFixed32 == [2147483647, 4294967295]} - assertDecodeSucceeds([130, 6, 0]) {$0.packedFixed32 == []} - assertDecodeSucceeds([133, 6, 0, 0, 0, 0]) {$0.packedFixed32 == [0]} + assertEncode([130, 6, 8, 255, 255, 255, 255, 0, 0, 0, 0]) { (o: inout MessageTestType) in + o.packedFixed32 = [UInt32.max, UInt32.min] + } + assertDecodeSucceeds([130, 6, 8, 255, 255, 255, 127, 255, 255, 255, 255]) { + $0.packedFixed32 == [2_147_483_647, 4_294_967_295] + } + assertDecodeSucceeds([130, 6, 4, 255, 255, 255, 127, 130, 6, 4, 255, 255, 255, 255]) { + $0.packedFixed32 == [2_147_483_647, 4_294_967_295] + } + assertDecodeSucceeds([130, 6, 0]) { $0.packedFixed32 == [] } + assertDecodeSucceeds([133, 6, 0, 0, 0, 0]) { $0.packedFixed32 == [0] } assertDecodeFails([130, 6, 4, 8, 255, 255, 255, 127, 255, 255, 255]) assertDecodeFails([130, 6, 7, 255, 255, 255, 127, 255, 255, 255]) assertDecodeFails([128, 6]) @@ -187,13 +230,27 @@ class Test_Packed: XCTestCase, PBTestHelpers { } func testEncoding_packedFixed64() { - assertEncode([138, 6, 16, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0]) {(o: inout MessageTestType) in o.packedFixed64 = [UInt64.max, UInt64.min]} - assertDecodeSucceeds([138, 6, 24, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255]) {$0.packedFixed64 == [2147483647, 4294967295, 18446744073709551615]} - assertDecodeSucceeds([138, 6, 8, 255, 255, 255, 127, 0, 0, 0, 0, 138, 6, 16, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255]) {$0.packedFixed64 == [2147483647, 4294967295, 18446744073709551615]} - assertDecodeSucceeds([138, 6, 0]) {$0.packedFixed64 == []} - assertDecodeSucceeds([137, 6, 0, 0, 0, 0, 0, 0, 0, 0]) {$0.packedFixed64 == [0]} - assertDecodeFails([138, 6, 24, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255]) - assertDecodeFails([138, 6, 23, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255]) + assertEncode([138, 6, 16, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0]) { + (o: inout MessageTestType) in o.packedFixed64 = [UInt64.max, UInt64.min] + } + assertDecodeSucceeds([ + 138, 6, 24, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, + 255, 255, + ]) { $0.packedFixed64 == [2_147_483_647, 4_294_967_295, 18_446_744_073_709_551_615] } + assertDecodeSucceeds([ + 138, 6, 8, 255, 255, 255, 127, 0, 0, 0, 0, 138, 6, 16, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, + 255, 255, 255, 255, + ]) { $0.packedFixed64 == [2_147_483_647, 4_294_967_295, 18_446_744_073_709_551_615] } + assertDecodeSucceeds([138, 6, 0]) { $0.packedFixed64 == [] } + assertDecodeSucceeds([137, 6, 0, 0, 0, 0, 0, 0, 0, 0]) { $0.packedFixed64 == [0] } + assertDecodeFails([ + 138, 6, 24, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, + 255, + ]) + assertDecodeFails([ + 138, 6, 23, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, + 255, + ]) assertDecodeFails([136, 6]) assertDecodesAsUnknownFields([136, 6, 0]) // Wrong wire type (varint), valid as an unknown field assertDecodeFails([136, 6, 0, 0, 0, 0, 0, 0, 0, 0]) @@ -215,12 +272,20 @@ class Test_Packed: XCTestCase, PBTestHelpers { } func testEncoding_packedSfixed32() { - assertEncode([146, 6, 8, 255, 255, 255, 127, 0, 0, 0, 128]) {(o: inout MessageTestType) in o.packedSfixed32 = [Int32.max, Int32.min]} - assertDecodeSucceeds([146, 6, 12, 0, 0, 0, 128, 1, 0, 0, 0, 255, 255, 255, 127]) {$0.packedSfixed32 == [-2147483648, 1, 2147483647]} - assertDecodeSucceeds([146, 6, 4, 0, 0, 0, 128, 146, 6, 8, 1, 0, 0, 0, 255, 255, 255, 127]) {$0.packedSfixed32 == [-2147483648, 1, 2147483647]} - assertDecodeSucceeds([146, 6, 4, 0, 0, 0, 128, 146, 6, 0, 146, 6, 8, 1, 0, 0, 0, 255, 255, 255, 127]) {$0.packedSfixed32 == [-2147483648, 1, 2147483647]} - assertDecodeSucceeds([149, 6, 1, 0, 0, 0, 146, 6, 4, 7, 0, 0, 0]) {$0.packedSfixed32 == [1, 7]} - assertDecodeSucceeds([146, 6, 0]) {$0.packedSfixed32 == []} + assertEncode([146, 6, 8, 255, 255, 255, 127, 0, 0, 0, 128]) { (o: inout MessageTestType) in + o.packedSfixed32 = [Int32.max, Int32.min] + } + assertDecodeSucceeds([146, 6, 12, 0, 0, 0, 128, 1, 0, 0, 0, 255, 255, 255, 127]) { + $0.packedSfixed32 == [-2_147_483_648, 1, 2_147_483_647] + } + assertDecodeSucceeds([146, 6, 4, 0, 0, 0, 128, 146, 6, 8, 1, 0, 0, 0, 255, 255, 255, 127]) { + $0.packedSfixed32 == [-2_147_483_648, 1, 2_147_483_647] + } + assertDecodeSucceeds([146, 6, 4, 0, 0, 0, 128, 146, 6, 0, 146, 6, 8, 1, 0, 0, 0, 255, 255, 255, 127]) { + $0.packedSfixed32 == [-2_147_483_648, 1, 2_147_483_647] + } + assertDecodeSucceeds([149, 6, 1, 0, 0, 0, 146, 6, 4, 7, 0, 0, 0]) { $0.packedSfixed32 == [1, 7] } + assertDecodeSucceeds([146, 6, 0]) { $0.packedSfixed32 == [] } assertDecodeFails([146, 6, 12, 0, 0, 0, 128, 1, 0, 0, 0, 255, 255, 255]) assertDecodeFails([146, 6, 11, 0, 0, 0, 128, 1, 0, 0, 0, 255, 255, 255]) assertDecodesAsUnknownFields([144, 6, 5]) // Wrong wire type (varint), valid as an unknown field @@ -244,14 +309,35 @@ class Test_Packed: XCTestCase, PBTestHelpers { } func testEncoding_packedSfixed64() { - assertEncode([154, 6, 16, 255, 255, 255, 255, 255, 255, 255, 127, 0, 0, 0, 0, 0, 0, 0, 128]) {(o: inout MessageTestType) in o.packedSfixed64 = [Int64.max, Int64.min]} - assertDecodeSucceeds([154, 6, 32, 0, 0, 0, 0, 0, 0, 0, 128, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 127]) {$0.packedSfixed64 == [-9223372036854775808, 2147483647, 4294967295, 9223372036854775807]} - assertDecodeSucceeds([154, 6, 8, 0, 0, 0, 0, 0, 0, 0, 128, 154, 6, 0, 154, 6, 16, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 154, 6, 8, 255, 255, 255, 255, 255, 255, 255, 127]) {$0.packedSfixed64 == [-9223372036854775808, 2147483647, 4294967295, 9223372036854775807]} - assertDecodeSucceeds([154, 6, 0]) {$0.packedSfixed64 == []} - assertDecodeSucceeds([153, 6, 3, 0, 0, 0, 0, 0, 0, 0]) {$0.packedSfixed64 == [3]} - assertDecodeFails([154, 6, 33, 0, 0, 0, 0, 0, 0, 0, 128, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 127]) - assertDecodeFails([154, 6, 32, 0, 0, 0, 0, 0, 0, 0, 128, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255]) - assertDecodeFails([154, 6, 31, 0, 0, 0, 0, 0, 0, 0, 128, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255]) + assertEncode([154, 6, 16, 255, 255, 255, 255, 255, 255, 255, 127, 0, 0, 0, 0, 0, 0, 0, 128]) { + (o: inout MessageTestType) in o.packedSfixed64 = [Int64.max, Int64.min] + } + assertDecodeSucceeds([ + 154, 6, 32, 0, 0, 0, 0, 0, 0, 0, 128, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, + 255, 255, 255, 255, 255, 255, 127, + ]) { + $0.packedSfixed64 == [-9_223_372_036_854_775_808, 2_147_483_647, 4_294_967_295, 9_223_372_036_854_775_807] + } + assertDecodeSucceeds([ + 154, 6, 8, 0, 0, 0, 0, 0, 0, 0, 128, 154, 6, 0, 154, 6, 16, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, + 255, 0, 0, 0, 0, 154, 6, 8, 255, 255, 255, 255, 255, 255, 255, 127, + ]) { + $0.packedSfixed64 == [-9_223_372_036_854_775_808, 2_147_483_647, 4_294_967_295, 9_223_372_036_854_775_807] + } + assertDecodeSucceeds([154, 6, 0]) { $0.packedSfixed64 == [] } + assertDecodeSucceeds([153, 6, 3, 0, 0, 0, 0, 0, 0, 0]) { $0.packedSfixed64 == [3] } + assertDecodeFails([ + 154, 6, 33, 0, 0, 0, 0, 0, 0, 0, 128, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, + 255, 255, 255, 255, 255, 255, 127, + ]) + assertDecodeFails([ + 154, 6, 32, 0, 0, 0, 0, 0, 0, 0, 128, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, + 255, 255, 255, 255, 255, 255, + ]) + assertDecodeFails([ + 154, 6, 31, 0, 0, 0, 0, 0, 0, 0, 128, 255, 255, 255, 127, 0, 0, 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 255, + 255, 255, 255, 255, 255, 255, + ]) assertDecodeFails([152, 6]) assertDecodesAsUnknownFields([152, 6, 0]) // Wrong wire type (varint), valid as an unknown field assertDecodeFails([152, 6, 0, 0, 0, 0, 0, 0, 0, 0]) @@ -273,34 +359,48 @@ class Test_Packed: XCTestCase, PBTestHelpers { } func testEncoding_packedFloat() { - assertEncode([162, 6, 8, 0, 0, 0, 63, 0, 0, 128, 62]) {(o: inout MessageTestType) in o.packedFloat = [0.5, 0.25]} - assertDecodeSucceeds([162, 6, 8, 0, 0, 0, 63, 0, 0, 128, 62]) {$0.packedFloat == [0.5, 0.25]} - assertDecodeSucceeds([162, 6, 4, 0, 0, 0, 63, 162, 6, 4, 0, 0, 128, 62]) {$0.packedFloat == [0.5, 0.25]} - assertDecodeSucceeds([165, 6, 0, 0, 0, 63, 162, 6, 4, 0, 0, 128, 62]) {$0.packedFloat == [0.5, 0.25]} - assertDecodeSucceeds([162, 6, 4, 0, 0, 0, 63, 165, 6, 0, 0, 128, 62]) {$0.packedFloat == [0.5, 0.25]} - assertDecodeSucceeds([165, 6, 0, 0, 0, 63, 165, 6, 0, 0, 128, 62]) {$0.packedFloat == [0.5, 0.25]} - assertDecodeSucceeds([162, 6, 0]) {$0.packedFloat == []} + assertEncode([162, 6, 8, 0, 0, 0, 63, 0, 0, 128, 62]) { (o: inout MessageTestType) in + o.packedFloat = [0.5, 0.25] + } + assertDecodeSucceeds([162, 6, 8, 0, 0, 0, 63, 0, 0, 128, 62]) { $0.packedFloat == [0.5, 0.25] } + assertDecodeSucceeds([162, 6, 4, 0, 0, 0, 63, 162, 6, 4, 0, 0, 128, 62]) { $0.packedFloat == [0.5, 0.25] } + assertDecodeSucceeds([165, 6, 0, 0, 0, 63, 162, 6, 4, 0, 0, 128, 62]) { $0.packedFloat == [0.5, 0.25] } + assertDecodeSucceeds([162, 6, 4, 0, 0, 0, 63, 165, 6, 0, 0, 128, 62]) { $0.packedFloat == [0.5, 0.25] } + assertDecodeSucceeds([165, 6, 0, 0, 0, 63, 165, 6, 0, 0, 128, 62]) { $0.packedFloat == [0.5, 0.25] } + assertDecodeSucceeds([162, 6, 0]) { $0.packedFloat == [] } assertDecodeFails([162, 6, 8, 0, 0, 0, 63, 0, 0, 128]) assertDecodeFails([162, 6, 7, 0, 0, 0, 63, 0, 0, 128]) - assertDecodeFails([160, 6]) // Cannot use wire type 0 - assertDecodeFails([161, 6]) // Cannot use wire type 1 - assertDecodeFails([163, 6]) // Cannot use wire type 3 - assertDecodeFails([164, 6]) // Cannot use wire type 4 - assertDecodeFails([166, 6]) // Cannot use wire type 6 - assertDecodeFails([167, 6]) // Cannot use wire type 7 + assertDecodeFails([160, 6]) // Cannot use wire type 0 + assertDecodeFails([161, 6]) // Cannot use wire type 1 + assertDecodeFails([163, 6]) // Cannot use wire type 3 + assertDecodeFails([164, 6]) // Cannot use wire type 4 + assertDecodeFails([166, 6]) // Cannot use wire type 6 + assertDecodeFails([167, 6]) // Cannot use wire type 7 } func testEncoding_packedDouble() { - assertEncode([170, 6, 16, 0, 0, 0, 0, 0, 0, 224, 63, 0, 0, 0, 0, 0, 0, 208, 63]) {(o: inout MessageTestType) in o.packedDouble = [0.5, 0.25]} - assertDecodeSucceeds([170, 6, 16, 0, 0, 0, 0, 0, 0, 224, 63, 0, 0, 0, 0, 0, 0, 208, 63]) {$0.packedDouble == [0.5, 0.25]} - assertDecodeSucceeds([170, 6, 0]) {$0.packedDouble == []} + assertEncode([170, 6, 16, 0, 0, 0, 0, 0, 0, 224, 63, 0, 0, 0, 0, 0, 0, 208, 63]) { (o: inout MessageTestType) in + o.packedDouble = [0.5, 0.25] + } + assertDecodeSucceeds([170, 6, 16, 0, 0, 0, 0, 0, 0, 224, 63, 0, 0, 0, 0, 0, 0, 208, 63]) { + $0.packedDouble == [0.5, 0.25] + } + assertDecodeSucceeds([170, 6, 0]) { $0.packedDouble == [] } assertDecodeFails([170, 6, 16, 0, 0, 0, 0, 0, 0, 224, 63, 0, 0, 0, 0, 0, 0, 208]) assertDecodeFails([170, 6, 15, 0, 0, 0, 0, 0, 0, 224, 63, 0, 0, 0, 0, 0, 0, 208]) assertDecodeFails([170, 6, 16, 0, 0, 0, 0, 0, 0, 224, 63]) - assertDecodeSucceeds([169, 6, 0, 0, 0, 0, 0, 0, 224, 63, 169, 6, 0, 0, 0, 0, 0, 0, 208, 63]) {$0.packedDouble == [0.5, 0.25]} - assertDecodeSucceeds([169, 6, 0, 0, 0, 0, 0, 0, 224, 63, 170, 6, 8, 0, 0, 0, 0, 0, 0, 208, 63]) {$0.packedDouble == [0.5, 0.25]} - assertDecodeSucceeds([170, 6, 8, 0, 0, 0, 0, 0, 0, 224, 63, 169, 6, 0, 0, 0, 0, 0, 0, 208, 63]) {$0.packedDouble == [0.5, 0.25]} - assertDecodeSucceeds([170, 6, 8, 0, 0, 0, 0, 0, 0, 224, 63, 170, 6, 8, 0, 0, 0, 0, 0, 0, 208, 63]) {$0.packedDouble == [0.5, 0.25]} + assertDecodeSucceeds([169, 6, 0, 0, 0, 0, 0, 0, 224, 63, 169, 6, 0, 0, 0, 0, 0, 0, 208, 63]) { + $0.packedDouble == [0.5, 0.25] + } + assertDecodeSucceeds([169, 6, 0, 0, 0, 0, 0, 0, 224, 63, 170, 6, 8, 0, 0, 0, 0, 0, 0, 208, 63]) { + $0.packedDouble == [0.5, 0.25] + } + assertDecodeSucceeds([170, 6, 8, 0, 0, 0, 0, 0, 0, 224, 63, 169, 6, 0, 0, 0, 0, 0, 0, 208, 63]) { + $0.packedDouble == [0.5, 0.25] + } + assertDecodeSucceeds([170, 6, 8, 0, 0, 0, 0, 0, 0, 224, 63, 170, 6, 8, 0, 0, 0, 0, 0, 0, 208, 63]) { + $0.packedDouble == [0.5, 0.25] + } assertDecodeFails([168, 6]) assertDecodesAsUnknownFields([168, 6, 0]) // Wrong wire type (varint), valid as an unknown field assertDecodeFails([168, 6, 0, 0, 0, 0, 0, 0, 0, 0]) @@ -322,15 +422,20 @@ class Test_Packed: XCTestCase, PBTestHelpers { } func testEncoding_packedBool() { - assertEncode([178, 6, 4, 1, 0, 0, 1]) {(o: inout MessageTestType) in o.packedBool = [true, false, false, true]} - assertDecodeSucceeds([178, 6, 4, 1, 0, 0, 1]) {$0.packedBool == [true, false, false, true]} - assertDecodeSucceeds([178, 6, 5, 255, 1, 0, 0, 1]) {$0.packedBool == [true, false, false, true]} - assertDecodeSucceeds([178, 6, 5, 1, 128, 0, 0, 1]) {$0.packedBool == [true, false, false, true]} - assertDecodeSucceeds([178, 6, 14, 1, 128, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127]) {$0.packedBool == [true, false, false, true]} - assertDecodeSucceeds([178, 6, 1, 1, 178, 6, 0, 178, 6, 3, 0, 0, 1]) {$0.packedBool == [true, false, false, true]} - assertDecodeSucceeds([178, 6, 0]) {$0.packedBool == []} - assertDecodeSucceeds([176, 6, 0]) {$0.packedBool == [false]} - assertDecodeSucceeds([178, 6, 2, 0, 1, 176, 6, 0]) {$0.packedBool == [false, true, false]} + assertEncode([178, 6, 4, 1, 0, 0, 1]) { (o: inout MessageTestType) in o.packedBool = [true, false, false, true] + } + assertDecodeSucceeds([178, 6, 4, 1, 0, 0, 1]) { $0.packedBool == [true, false, false, true] } + assertDecodeSucceeds([178, 6, 5, 255, 1, 0, 0, 1]) { $0.packedBool == [true, false, false, true] } + assertDecodeSucceeds([178, 6, 5, 1, 128, 0, 0, 1]) { $0.packedBool == [true, false, false, true] } + assertDecodeSucceeds([178, 6, 14, 1, 128, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 127]) { + $0.packedBool == [true, false, false, true] + } + assertDecodeSucceeds([178, 6, 1, 1, 178, 6, 0, 178, 6, 3, 0, 0, 1]) { + $0.packedBool == [true, false, false, true] + } + assertDecodeSucceeds([178, 6, 0]) { $0.packedBool == [] } + assertDecodeSucceeds([176, 6, 0]) { $0.packedBool == [false] } + assertDecodeSucceeds([178, 6, 2, 0, 1, 176, 6, 0]) { $0.packedBool == [false, true, false] } assertDecodeFails([178, 6, 4, 1, 0, 0]) assertDecodeFails([178, 6, 3, 1, 0, 128]) @@ -350,20 +455,22 @@ class Test_Packed: XCTestCase, PBTestHelpers { } func testEncoding_packedEnum() throws { - assertEncode([186, 6, 2, 5, 4]) {(o: inout MessageTestType) in o.packedEnum = [.foreignBar, .foreignFoo]} - assertDecodeSucceeds([186, 6, 2, 4, 5]) {$0.packedEnum == [.foreignFoo, .foreignBar]} - assertDecodeSucceeds([186, 6, 0]) {$0.packedEnum == []} - assertDecodeSucceeds([186, 6, 1, 5, 186, 6, 0, 186, 6, 2, 132, 0]) {$0.packedEnum == [.foreignBar, .foreignFoo]} + assertEncode([186, 6, 2, 5, 4]) { (o: inout MessageTestType) in o.packedEnum = [.foreignBar, .foreignFoo] } + assertDecodeSucceeds([186, 6, 2, 4, 5]) { $0.packedEnum == [.foreignFoo, .foreignBar] } + assertDecodeSucceeds([186, 6, 0]) { $0.packedEnum == [] } + assertDecodeSucceeds([186, 6, 1, 5, 186, 6, 0, 186, 6, 2, 132, 0]) { + $0.packedEnum == [.foreignBar, .foreignFoo] + } // Packed enums can be stored as plain repeated - assertDecodeSucceeds([186, 6, 2, 4, 6, 184, 6, 5]) {$0.packedEnum == [.foreignFoo, .foreignBaz, .foreignBar]} + assertDecodeSucceeds([186, 6, 2, 4, 6, 184, 6, 5]) { $0.packedEnum == [.foreignFoo, .foreignBaz, .foreignBar] } // Proto2 converts unrecognized enum values into unknowns - assertDecodeSucceeds([186, 6, 2, 6, 99]) {$0.packedEnum == [.foreignBaz]} - + assertDecodeSucceeds([186, 6, 2, 6, 99]) { $0.packedEnum == [.foreignBaz] } + // Unknown enums within packed become separate unknown entries do { - let decoded1 = try ProtobufUnittest_TestPackedTypes(serializedData: Data([186, 6, 3, 4, 99, 6])) + let decoded1 = try SwiftProtoTesting_TestPackedTypes(serializedBytes: [186, 6, 3, 4, 99, 6]) XCTAssertEqual(decoded1.packedEnum, [.foreignFoo, .foreignBaz]) - let recoded1 = try decoded1.serializedBytes() + let recoded1: [UInt8] = try decoded1.serializedBytes() XCTAssertEqual(recoded1, [186, 6, 2, 4, 6, 186, 6, 1, 99]) } catch let e { XCTFail("Decode failed: \(e)") @@ -385,5 +492,3 @@ class Test_Packed: XCTestCase, PBTestHelpers { assertDecodeFails([191, 6, 0]) } } - - diff --git a/Tests/SwiftProtobufTests/Test_ParsingMerge.swift b/Tests/SwiftProtobufTests/Test_ParsingMerge.swift index a670231da..2aed5dd37 100644 --- a/Tests/SwiftProtobufTests/Test_ParsingMerge.swift +++ b/Tests/SwiftProtobufTests/Test_ParsingMerge.swift @@ -18,18 +18,18 @@ import Foundation import XCTest -class Test_ParsingMerge: XCTestCase { +final class Test_ParsingMerge: XCTestCase { func test_Merge() { // Repeated fields generator has field1 - var m = ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator() + var m = SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator() // Populate 'field1' - var t1 = ProtobufUnittest_TestAllTypes() + var t1 = SwiftProtoTesting_TestAllTypes() t1.optionalInt32 = 1 t1.optionalString = "abc" - var t2 = ProtobufUnittest_TestAllTypes() - t2.optionalInt32 = 2 // Should override t1.optionalInt32 + var t2 = SwiftProtoTesting_TestAllTypes() + t2.optionalInt32 = 2 // Should override t1.optionalInt32 t2.optionalInt64 = 3 m.field1 = [t1, t2] @@ -40,14 +40,14 @@ class Test_ParsingMerge: XCTestCase { m.field3 = [t1, t2] // Populate group1 - var g1a = ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group1() + var g1a = SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group1() var g1b = g1a g1a.field1 = t1 g1b.field1 = t2 m.group1 = [g1a, g1b] // Populate group2 - var g2a = ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group2() + var g2a = SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group2() var g2b = g2a g2a.field1 = t1 g2b.field1 = t2 @@ -55,9 +55,9 @@ class Test_ParsingMerge: XCTestCase { // Encode/decode should merge repeated fields into non-repeated do { - let encoded = try m.serializedData() + let encoded: [UInt8] = try m.serializedBytes() do { - let decoded = try ProtobufUnittest_TestParsingMerge(serializedData: encoded) + let decoded = try SwiftProtoTesting_TestParsingMerge(serializedBytes: encoded) // requiredAllTypes <== merge of field1 let field1 = decoded.requiredAllTypes @@ -73,7 +73,7 @@ class Test_ParsingMerge: XCTestCase { // repeatedAllTypes <== field3 without merging XCTAssertEqual(decoded.repeatedAllTypes, [t1, t2]) - + // optionalGroup <== merge of repeated group1 let group1 = decoded.optionalGroup XCTAssertEqual(group1.optionalGroupAllTypes.optionalInt32, 2) @@ -99,20 +99,20 @@ class Test_ParsingMerge: XCTestCase { // Each time the oneof is changed to a different subfield, the previous state // is cleared. - var m = SwiftUnittest_TestParsingMerge.RepeatedFieldsGenerator() + var m = SwiftProtoTesting_Merging_TestParsingMerge.RepeatedFieldsGenerator() - var t1 = SwiftUnittest_TestMessage() + var t1 = SwiftProtoTesting_Merging_TestMessage() t1.oneofNestedMessage.a = 1 t1.oneofNestedMessage.b = 1 - var t2 = SwiftUnittest_TestMessage() + var t2 = SwiftProtoTesting_Merging_TestMessage() t2.oneofString = "string" m.field1 = [t1, t2] m.field2 = [t1, t2] do { - let encoded = try m.serializedData() + let encoded: [UInt8] = try m.serializedBytes() do { - let decoded = try SwiftUnittest_TestParsingMerge(serializedData: encoded) + let decoded = try SwiftProtoTesting_Merging_TestParsingMerge(serializedBytes: encoded) // optional_message <== merge of field1 let field1 = decoded.optionalMessage @@ -122,7 +122,7 @@ class Test_ParsingMerge: XCTestCase { // repeated_message <== field2 without merging XCTAssertEqual(decoded.repeatedMessage, [t1, t2]) - } catch { + } catch { XCTFail("Decoding failed \(encoded)") } } catch let e { @@ -132,18 +132,18 @@ class Test_ParsingMerge: XCTestCase { // Second, including if it is changed back to a message, anything from the first // one is lost. - m = SwiftUnittest_TestParsingMerge.RepeatedFieldsGenerator() + m = SwiftProtoTesting_Merging_TestParsingMerge.RepeatedFieldsGenerator() - var t3 = SwiftUnittest_TestMessage() + var t3 = SwiftProtoTesting_Merging_TestMessage() t3.oneofNestedMessage.b = 3 t3.oneofNestedMessage.c = 3 m.field1 = [t1, t2, t3] m.field2 = [t1, t2, t3] do { - let encoded = try m.serializedData() + let encoded: [UInt8] = try m.serializedBytes() do { - let decoded = try SwiftUnittest_TestParsingMerge(serializedData: encoded) + let decoded = try SwiftProtoTesting_Merging_TestParsingMerge(serializedBytes: encoded) // optional_message <== merge of field1 let field1 = decoded.optionalMessage @@ -154,27 +154,26 @@ class Test_ParsingMerge: XCTestCase { // repeated_message <== field2 without merging XCTAssertEqual(decoded.repeatedMessage, [t1, t2, t3]) - } catch { + } catch { XCTFail("Decoding failed \(encoded)") } } catch let e { XCTFail("Encoding failed for \(m) with error \(e)") } - // But, if the oneofs are set to the message field without chaning between, just like // a normal opitional/required message field, the data should be merged. - m = SwiftUnittest_TestParsingMerge.RepeatedFieldsGenerator() + m = SwiftProtoTesting_Merging_TestParsingMerge.RepeatedFieldsGenerator() m.field1 = [t1, t3] m.field2 = [t1, t3] // Encode/decode should merge repeated fields into non-repeated do { - let encoded = try m.serializedData() + let encoded: [UInt8] = try m.serializedBytes() do { - let decoded = try SwiftUnittest_TestParsingMerge(serializedData: encoded) + let decoded = try SwiftProtoTesting_Merging_TestParsingMerge(serializedBytes: encoded) // optional_message <== merge of field1 let field1 = decoded.optionalMessage @@ -184,7 +183,7 @@ class Test_ParsingMerge: XCTestCase { // repeated_message <== field2 without merging XCTAssertEqual(decoded.repeatedMessage, [t1, t3]) - } catch { + } catch { XCTFail("Decoding failed \(encoded)") } } catch let e { diff --git a/Tests/SwiftProtobufTests/Test_RawSpan.swift b/Tests/SwiftProtobufTests/Test_RawSpan.swift new file mode 100644 index 000000000..8ea0b7a82 --- /dev/null +++ b/Tests/SwiftProtobufTests/Test_RawSpan.swift @@ -0,0 +1,84 @@ +import Foundation +import SwiftProtobuf +import XCTest + +#if compiler(>=6.2) + +final class Test_RawSpan: XCTestCase { + func testEmptyRawSpan() throws { + guard #available(macOS 10.14.4, iOS 12.2, watchOS 5.2, tvOS 12.2, visionOS 1.0, *) else { + throw XCTSkip("Span structs not available on selected platform") + } + + let emptyRawSpan = RawSpan() + + let decoded = try SwiftProtoTesting_TestAllTypes(serializedBytes: emptyRawSpan) + let expected = SwiftProtoTesting_TestAllTypes() + + XCTAssertEqual(decoded, expected, "Empty span should decode to equal empty message") + } + + func testRawSpanReencodedEmptyByteArray() throws { + guard #available(macOS 26, iOS 26, watchOS 26, tvOS 26, visionOS 26, *) else { + throw XCTSkip("span.bytes not available on selected platform") + } + + let expected: [UInt8] = [] + let expectedRawSpan = expected.span.bytes + + let decoded = try SwiftProtoTesting_TestAllTypes(serializedBytes: expectedRawSpan) + let reencoded: [UInt8] = try decoded.serializedBytes() + + XCTAssertEqual( + reencoded, + expected, + "Raw span of empty array of bytes should decode and encode as empty message" + ) + } + + func testRawSpanDataEncodeDecode() throws { + guard #available(macOS 10.14.4, iOS 12.2, watchOS 5.2, tvOS 12.2, visionOS 1.0, *) else { + throw XCTSkip("Span structs not available on selected platform") + } + + let expected = SwiftProtoTesting_TestAllTypes.with { + $0.optionalInt32 = 1 + $0.optionalInt64 = Int64.max + $0.optionalString = "RawSpan test" + $0.repeatedBool = [true, false] + } + + let encoded: Data = try expected.serializedBytes() + let encodedRawSpan: RawSpan = encoded.bytes + + let decoded = try SwiftProtoTesting_TestAllTypes(serializedBytes: encodedRawSpan) + + XCTAssertEqual(decoded, expected, "") + } + + func testRawSpanTruncated() throws { + guard #available(macOS 10.14.4, iOS 12.2, watchOS 5.2, tvOS 12.2, visionOS 1.0, *) else { + throw XCTSkip("Span structs not available on selected platform") + } + + let expected = SwiftProtoTesting_TestAllTypes.with { + $0.optionalInt32 = 1 + $0.optionalInt64 = Int64.max + $0.optionalString = "RawSpan test" + $0.repeatedBool = [true, false] + } + + let encoded: Data = try expected.serializedBytes() + let truncatedRawSpan: RawSpan = encoded.bytes.extracting(droppingLast: 1) + + var decoded = SwiftProtoTesting_TestAllTypes() + + XCTAssertThrowsError( + try decoded.merge(serializedBytes: truncatedRawSpan) + ) { error in + XCTAssertEqual(error as? BinaryDecodingError, BinaryDecodingError.truncated) + } + } +} + +#endif diff --git a/Tests/SwiftProtobufTests/Test_ReallyLargeTagNumber.swift b/Tests/SwiftProtobufTests/Test_ReallyLargeTagNumber.swift index a39019bce..2078a523d 100644 --- a/Tests/SwiftProtobufTests/Test_ReallyLargeTagNumber.swift +++ b/Tests/SwiftProtobufTests/Test_ReallyLargeTagNumber.swift @@ -15,19 +15,19 @@ import Foundation import XCTest -class Test_ReallyLargeTagNumber: XCTestCase { +final class Test_ReallyLargeTagNumber: XCTestCase { func test_ReallyLargeTagNumber() { - var m = ProtobufUnittest_TestReallyLargeTagNumber() + var m = SwiftProtoTesting_TestReallyLargeTagNumber() m.a = 1 m.bb = 2 do { - let encoded = try m.serializedData() - XCTAssertEqual(encoded, Data([8, 1, 248, 255, 255, 255, 7, 2])) + let encoded: [UInt8] = try m.serializedBytes() + XCTAssertEqual(encoded, [8, 1, 248, 255, 255, 255, 7, 2]) do { - let decoded = try ProtobufUnittest_TestReallyLargeTagNumber(serializedData: encoded) + let decoded = try SwiftProtoTesting_TestReallyLargeTagNumber(serializedBytes: encoded) XCTAssertEqual(2, decoded.bb) XCTAssertEqual(1, decoded.a) XCTAssertEqual(m, decoded) diff --git a/Tests/SwiftProtobufTests/Test_RecursiveMap.swift b/Tests/SwiftProtobufTests/Test_RecursiveMap.swift index 7d7cd9d4d..4b3ffc8e5 100644 --- a/Tests/SwiftProtobufTests/Test_RecursiveMap.swift +++ b/Tests/SwiftProtobufTests/Test_RecursiveMap.swift @@ -15,19 +15,19 @@ import Foundation import XCTest -class Test_RecursiveMap: XCTestCase { +final class Test_RecursiveMap: XCTestCase { func test_RecursiveMap() throws { - let inner = ProtobufUnittest_TestRecursiveMapMessage() - var mid = ProtobufUnittest_TestRecursiveMapMessage() + let inner = SwiftProtoTesting_TestRecursiveMapMessage() + var mid = SwiftProtoTesting_TestRecursiveMapMessage() mid.a = ["1": inner] - var outer = ProtobufUnittest_TestRecursiveMapMessage() + var outer = SwiftProtoTesting_TestRecursiveMapMessage() outer.a = ["2": mid] do { - let encoded = try outer.serializedData() - XCTAssertEqual(encoded, Data([10, 12, 10, 1, 50, 18, 7, 10, 5, 10, 1, 49, 18, 0])) + let encoded: [UInt8] = try outer.serializedBytes() + XCTAssertEqual(encoded, [10, 12, 10, 1, 50, 18, 7, 10, 5, 10, 1, 49, 18, 0]) - let decodedOuter = try ProtobufUnittest_TestRecursiveMapMessage(serializedData: encoded) + let decodedOuter = try SwiftProtoTesting_TestRecursiveMapMessage(serializedBytes: encoded) if let decodedMid = decodedOuter.a["2"] { if let decodedInner = decodedMid.a["1"] { XCTAssertEqual(decodedOuter.a.count, 1) diff --git a/Tests/SwiftProtobufTests/Test_Required.swift b/Tests/SwiftProtobufTests/Test_Required.swift index 6746b80e3..71bb3854a 100644 --- a/Tests/SwiftProtobufTests/Test_Required.swift +++ b/Tests/SwiftProtobufTests/Test_Required.swift @@ -28,16 +28,15 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest - import SwiftProtobuf +import XCTest -class Test_Required: XCTestCase, PBTestHelpers { - typealias MessageTestType = ProtobufUnittest_TestAllRequiredTypes +final class Test_Required: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_TestAllRequiredTypes func test_IsInitialized() { // message declared in proto2 syntax file with required fields. - var msg = ProtobufUnittest_TestRequired() + var msg = SwiftProtoTesting_TestRequired() XCTAssertFalse(msg.isInitialized) msg.a = 1 XCTAssertFalse(msg.isInitialized) @@ -50,39 +49,38 @@ class Test_Required: XCTestCase, PBTestHelpers { func test_OneOf_IsInitialized() { // message declared in proto2 syntax file with a message in a oneof where that message // has a required field. - var msg = ProtobufUnittest_TestRequiredOneof() + var msg = SwiftProtoTesting_TestRequiredOneof() XCTAssertTrue(msg.isInitialized) - msg.fooMessage = ProtobufUnittest_TestRequiredOneof.NestedMessage() + msg.fooMessage = SwiftProtoTesting_TestRequiredOneof.NestedMessage() XCTAssertFalse(msg.isInitialized) msg.fooInt = 1 XCTAssertTrue(msg.isInitialized) - msg.fooMessage = ProtobufUnittest_TestRequiredOneof.NestedMessage() + msg.fooMessage = SwiftProtoTesting_TestRequiredOneof.NestedMessage() XCTAssertFalse(msg.isInitialized) msg.fooMessage.requiredDouble = 1.1 XCTAssertTrue(msg.isInitialized) // group within the oneof that has a required field. - var msg2 = ProtobufUnittest_OneOfContainer() + var msg2 = SwiftProtoTesting_OneOfContainer() XCTAssertTrue(msg2.isInitialized) - msg2.option3 = ProtobufUnittest_OneOfContainer.Option3() + msg2.option3 = SwiftProtoTesting_OneOfContainer.Option3() XCTAssertFalse(msg2.isInitialized) msg2.option4 = 1 XCTAssertTrue(msg2.isInitialized) - msg2.option3 = ProtobufUnittest_OneOfContainer.Option3() + msg2.option3 = SwiftProtoTesting_OneOfContainer.Option3() XCTAssertFalse(msg2.isInitialized) msg2.option3.a = 1 XCTAssertTrue(msg2.isInitialized) } - func test_NestedInProto2_IsInitialized() { // message declared in proto2 syntax file, with fields that are another message that has // required fields. - var msg = ProtobufUnittest_TestRequiredForeign() + var msg = SwiftProtoTesting_TestRequiredForeign() XCTAssertTrue(msg.isInitialized) - msg.optionalMessage = ProtobufUnittest_TestRequired() + msg.optionalMessage = SwiftProtoTesting_TestRequired() XCTAssertFalse(msg.isInitialized) msg.optionalMessage.a = 1 msg.optionalMessage.b = 2 @@ -90,7 +88,7 @@ class Test_Required: XCTestCase, PBTestHelpers { msg.optionalMessage.c = 3 XCTAssertTrue(msg.isInitialized) - msg.repeatedMessage.append(ProtobufUnittest_TestRequired()) + msg.repeatedMessage.append(SwiftProtoTesting_TestRequired()) XCTAssertFalse(msg.isInitialized) msg.repeatedMessage[0].a = 1 msg.repeatedMessage[0].b = 2 @@ -102,11 +100,11 @@ class Test_Required: XCTestCase, PBTestHelpers { func test_NestedInProto3_IsInitialized() { // message declared in proto3 syntax file, with fields that are another message that has // required fields. - var msg = Proto2NofieldpresenceUnittest_TestProto2Required() + var msg = SwiftProtoTesting_Proto3_TestProto2Required() XCTAssertTrue(msg.isInitialized) - msg.proto2 = ProtobufUnittest_TestRequired() + msg.proto2 = SwiftProtoTesting_TestRequired() XCTAssertFalse(msg.isInitialized) msg.proto2.a = 1 msg.proto2.b = 2 @@ -116,11 +114,11 @@ class Test_Required: XCTestCase, PBTestHelpers { } func test_map_isInitialized() { - var msg = ProtobufUnittest_TestRequiredMessageMap() + var msg = SwiftProtoTesting_TestRequiredMessageMap() XCTAssertTrue(msg.isInitialized) - msg.mapField[0] = ProtobufUnittest_TestRequired() + msg.mapField[0] = SwiftProtoTesting_TestRequired() XCTAssertFalse(msg.isInitialized) msg.mapField[0]!.a = 1 @@ -131,31 +129,35 @@ class Test_Required: XCTestCase, PBTestHelpers { } func test_Extensions_isInitialized() { - var msg = ProtobufUnittest_TestAllExtensions() + var msg = SwiftProtoTesting_TestAllExtensions() XCTAssertTrue(msg.isInitialized) - msg.ProtobufUnittest_TestRequired_single = ProtobufUnittest_TestRequired() + msg.SwiftProtoTesting_TestRequired_single = SwiftProtoTesting_TestRequired() XCTAssertFalse(msg.isInitialized) - msg.ProtobufUnittest_TestRequired_single.a = 1 - msg.ProtobufUnittest_TestRequired_single.b = 2 + msg.SwiftProtoTesting_TestRequired_single.a = 1 + msg.SwiftProtoTesting_TestRequired_single.b = 2 XCTAssertFalse(msg.isInitialized) - msg.ProtobufUnittest_TestRequired_single.c = 3 + msg.SwiftProtoTesting_TestRequired_single.c = 3 XCTAssertTrue(msg.isInitialized) - msg.ProtobufUnittest_TestRequired_multi.append(ProtobufUnittest_TestRequired()) + msg.SwiftProtoTesting_TestRequired_multi.append(SwiftProtoTesting_TestRequired()) XCTAssertFalse(msg.isInitialized) - msg.ProtobufUnittest_TestRequired_multi[0].a = 1 - msg.ProtobufUnittest_TestRequired_multi[0].b = 2 + msg.SwiftProtoTesting_TestRequired_multi[0].a = 1 + msg.SwiftProtoTesting_TestRequired_multi[0].b = 2 XCTAssertFalse(msg.isInitialized) - msg.ProtobufUnittest_TestRequired_multi[0].c = 3 + msg.SwiftProtoTesting_TestRequired_multi[0].c = 3 XCTAssertTrue(msg.isInitialized) } // Helper to assert decoding fails with a not initialized error. - fileprivate func assertDecodeFailsNotInitialized(_ bytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line) { + fileprivate func assertDecodeFailsNotInitialized( + _ bytes: [UInt8], + file: XCTestFileArgType = #file, + line: UInt = #line + ) { do { - let _ = try MessageTestType(serializedData: Data(bytes)) + let _ = try MessageTestType(serializedBytes: bytes) XCTFail("Swift decode should have failed: \(bytes)", file: file, line: line) } catch BinaryDecodingError.missingRequiredFields { // Correct error! @@ -165,14 +167,19 @@ class Test_Required: XCTestCase, PBTestHelpers { } // Helper to assert decoding partial succeeds. - fileprivate func assertPartialDecodeSucceeds(_ bytes: [UInt8], _ expectedTextFormat: String, file: XCTestFileArgType = #file, line: UInt = #line) { + fileprivate func assertPartialDecodeSucceeds( + _ bytes: [UInt8], + _ expectedTextFormat: String, + file: XCTestFileArgType = #file, + line: UInt = #line + ) { do { - let msg = try MessageTestType(serializedData: Data(bytes), partial: true) - var expected = "SwiftProtobufTests.ProtobufUnittest_TestAllRequiredTypes:\n" + let msg = try MessageTestType(serializedBytes: bytes, partial: true) + var expected = "SwiftProtobufTests.SwiftProtoTesting_TestAllRequiredTypes:\n" if !expectedTextFormat.isEmpty { expected += expectedTextFormat + "\n" } - XCTAssertEqual(msg.debugDescription, expected, "While decoding \(bytes)", file: file, line: line) + assertDebugDescription(expected, msg, fmt: "While decoding \(bytes)", file: file, line: line) } catch let e { XCTFail("Decoding \(bytes) failed with error: \(e)", file: file, line: line) } @@ -207,10 +214,7 @@ class Test_Required: XCTestCase, PBTestHelpers { ([168, 1, 3], "required_nested_enum: BAZ"), ([176, 1, 5], "required_foreign_enum: FOREIGN_BAR"), ([184, 1, 9], "required_import_enum: IMPORT_BAZ"), - ([194, 1, 2, 50, 52], "required_string_piece: \"24\""), - ([202, 1, 2, 50, 53], "required_cord: \"25\""), ([210, 1, 2, 8, 26], "required_public_import_message {\n e: 26\n}"), - ([218, 1, 2, 8, 27], "required_lazy_message {\n bb: 27\n}"), ([232, 3, 61], "default_int32: 61"), ([240, 3, 62], "default_int64: 62"), ([248, 3, 63], "default_uint32: 63"), @@ -229,8 +233,6 @@ class Test_Required: XCTestCase, PBTestHelpers { ([136, 5, 3], "default_nested_enum: BAZ"), ([144, 5, 6], "default_foreign_enum: FOREIGN_BAZ"), ([152, 5, 9], "default_import_enum: IMPORT_BAZ"), - ([162, 5, 2, 56, 52], "default_string_piece: \"84\""), - ([170, 5, 2, 56, 53], "default_cord: \"85\""), ] for (bytes, textFormattedField) in testInputs { assertDecodeFailsNotInitialized(bytes) @@ -238,21 +240,25 @@ class Test_Required: XCTestCase, PBTestHelpers { } // Glue it all together and it should decode ok as it will be complete. - var allBytesData = Data() - var allTextFormattedField = "SwiftProtobufTests.ProtobufUnittest_TestAllRequiredTypes:\n" + var allBytes: [UInt8] = [] + var allTextFormattedField = "SwiftProtobufTests.SwiftProtoTesting_TestAllRequiredTypes:\n" for (bytes, textFormattedField) in testInputs { - allBytesData.append(Data(bytes)) - allTextFormattedField.append(textFormattedField) - allTextFormattedField.append("\n") + allBytes.append(contentsOf: bytes) + allTextFormattedField.append(textFormattedField) + allTextFormattedField.append("\n") } - let fullMsg = try ProtobufUnittest_TestAllRequiredTypes(serializedData: allBytesData) - XCTAssertEqual(fullMsg.debugDescription, allTextFormattedField) + let fullMsg = try SwiftProtoTesting_TestAllRequiredTypes(serializedBytes: allBytes) + assertDebugDescription(allTextFormattedField, fullMsg) } // Helper to assert encoding fails with a not initialized error. - fileprivate func assertEncodeFailsNotInitialized(_ message: MessageTestType, file: XCTestFileArgType = #file, line: UInt = #line) { + fileprivate func assertEncodeFailsNotInitialized( + _ message: MessageTestType, + file: XCTestFileArgType = #file, + line: UInt = #line + ) { do { - let _ = try message.serializedData() + let _: [UInt8] = try message.serializedBytes() XCTFail("Swift encode should have failed: \(message)", file: file, line: line) } catch BinaryEncodingError.missingRequiredFields { // Correct error! @@ -262,10 +268,15 @@ class Test_Required: XCTestCase, PBTestHelpers { } // Helper to assert encoding partial succeeds. - fileprivate func assertPartialEncodeSucceeds(_ message: MessageTestType, _ expectedBytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line) { + fileprivate func assertPartialEncodeSucceeds( + _ message: MessageTestType, + _ expectedBytes: [UInt8], + file: XCTestFileArgType = #file, + line: UInt = #line + ) { do { - let data = try message.serializedData(partial: true) - XCTAssertEqual(data, Data(expectedBytes), "While encoding \(message)", file: file, line: line) + let data: [UInt8] = try message.serializedBytes(partial: true) + XCTAssertEqual(data, expectedBytes, "While encoding \(message)", file: file, line: line) } catch let e { XCTFail("Encoding failed with error: \(e) for \(message)", file: file, line: line) } @@ -304,10 +315,7 @@ class Test_Required: XCTestCase, PBTestHelpers { ([168, 1, 3], { (m) in m.requiredNestedEnum = .baz }), ([176, 1, 5], { (m) in m.requiredForeignEnum = .foreignBar }), ([184, 1, 9], { (m) in m.requiredImportEnum = .importBaz }), - ([194, 1, 2, 50, 52], { (m) in m.requiredStringPiece = "24" }), - ([202, 1, 2, 50, 53], { (m) in m.requiredCord = "25" }), ([210, 1, 2, 8, 26], { (m) in m.requiredPublicImportMessage.e = 26 }), - ([218, 1, 2, 8, 27], { (m) in m.requiredLazyMessage.bb = 27 }), ([232, 3, 61], { (m) in m.defaultInt32 = 61 }), ([240, 3, 62], { (m) in m.defaultInt64 = 62 }), ([248, 3, 63], { (m) in m.defaultUint32 = 63 }), @@ -326,8 +334,6 @@ class Test_Required: XCTestCase, PBTestHelpers { ([136, 5, 3], { (m) in m.defaultNestedEnum = .baz }), ([144, 5, 6], { (m) in m.defaultForeignEnum = .foreignBaz }), ([152, 5, 9], { (m) in m.defaultImportEnum = .importBaz }), - ([162, 5, 2, 56, 52], { (m) in m.defaultStringPiece = "84" }), - ([170, 5, 2, 56, 53], { (m) in m.defaultCord = "85" }), ] for (expected, configure) in testInputs { var message = MessageTestType() @@ -337,25 +343,29 @@ class Test_Required: XCTestCase, PBTestHelpers { } // Glue it all together and it should encode ok as it will be complete. - var allExpectedData = Data() + var allExpectedData = [UInt8]() msg = MessageTestType() for (expected, configure) in testInputs { - allExpectedData.append(Data(expected)) + allExpectedData.append(contentsOf: expected) configure(&msg) } - let serialized = try msg.serializedData() + let serialized: [UInt8] = try msg.serializedBytes() XCTAssertEqual(serialized, allExpectedData) } } -class Test_SmallRequired: XCTestCase, PBTestHelpers { - typealias MessageTestType = ProtobufUnittest_TestSomeRequiredTypes +final class Test_SmallRequired: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_TestSomeRequiredTypes // Check behavior of a small message (non-heap-stored) with required fields // Helper to assert decoding fails with a not initialized error. - fileprivate func assertDecodeFailsNotInitialized(_ bytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line) { + fileprivate func assertDecodeFailsNotInitialized( + _ bytes: [UInt8], + file: XCTestFileArgType = #file, + line: UInt = #line + ) { do { - let _ = try MessageTestType(serializedData: Data(bytes)) + let _ = try MessageTestType(serializedBytes: bytes) XCTFail("Swift decode should have failed: \(bytes)", file: file, line: line) } catch BinaryDecodingError.missingRequiredFields { // Correct error! @@ -365,14 +375,19 @@ class Test_SmallRequired: XCTestCase, PBTestHelpers { } // Helper to assert decoding partial succeeds. - fileprivate func assertPartialDecodeSucceeds(_ bytes: [UInt8], _ expectedTextFormat: String, file: XCTestFileArgType = #file, line: UInt = #line) { + fileprivate func assertPartialDecodeSucceeds( + _ bytes: [UInt8], + _ expectedTextFormat: String, + file: XCTestFileArgType = #file, + line: UInt = #line + ) { do { - let msg = try MessageTestType(serializedData: Data(bytes), partial: true) - var expected = "SwiftProtobufTests.ProtobufUnittest_TestSomeRequiredTypes:\n" + let msg = try MessageTestType(serializedBytes: bytes, partial: true) + var expected = "SwiftProtobufTests.SwiftProtoTesting_TestSomeRequiredTypes:\n" if !expectedTextFormat.isEmpty { expected += expectedTextFormat + "\n" } - XCTAssertEqual(msg.debugDescription, expected, "While decoding \(bytes)", file: file, line: line) + assertDebugDescription(expected, msg, fmt: "While decoding \(bytes)", file: file, line: line) } catch let e { XCTFail("Decoding \(bytes) failed with error: \(e)", file: file, line: line) } @@ -398,21 +413,25 @@ class Test_SmallRequired: XCTestCase, PBTestHelpers { } // Glue it all together and it should decode ok as it will be complete. - var allBytesData = Data() - var allTextFormattedField = "SwiftProtobufTests.ProtobufUnittest_TestSomeRequiredTypes:\n" + var allBytes: [UInt8] = [] + var allTextFormattedField = "SwiftProtobufTests.SwiftProtoTesting_TestSomeRequiredTypes:\n" for (bytes, textFormattedField) in testInputs { - allBytesData.append(Data(bytes)) - allTextFormattedField.append(textFormattedField) - allTextFormattedField.append("\n") + allBytes.append(contentsOf: bytes) + allTextFormattedField.append(textFormattedField) + allTextFormattedField.append("\n") } - let fullMsg = try ProtobufUnittest_TestSomeRequiredTypes(serializedData: allBytesData) - XCTAssertEqual(fullMsg.debugDescription, allTextFormattedField) + let fullMsg = try SwiftProtoTesting_TestSomeRequiredTypes(serializedBytes: allBytes) + assertDebugDescription(allTextFormattedField, fullMsg) } // Helper to assert encoding fails with a not initialized error. - fileprivate func assertEncodeFailsNotInitialized(_ message: MessageTestType, file: XCTestFileArgType = #file, line: UInt = #line) { + fileprivate func assertEncodeFailsNotInitialized( + _ message: MessageTestType, + file: XCTestFileArgType = #file, + line: UInt = #line + ) { do { - let _ = try message.serializedData() + let _: [UInt8] = try message.serializedBytes() XCTFail("Swift encode should have failed: \(message)", file: file, line: line) } catch BinaryEncodingError.missingRequiredFields { // Correct error! @@ -422,10 +441,15 @@ class Test_SmallRequired: XCTestCase, PBTestHelpers { } // Helper to assert encoding partial succeeds. - fileprivate func assertPartialEncodeSucceeds(_ message: MessageTestType, _ expectedBytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line) { + fileprivate func assertPartialEncodeSucceeds( + _ message: MessageTestType, + _ expectedBytes: [UInt8], + file: XCTestFileArgType = #file, + line: UInt = #line + ) { do { - let data = try message.serializedData(partial: true) - XCTAssertEqual(data, Data(expectedBytes), "While encoding \(message)", file: file, line: line) + let data: [UInt8] = try message.serializedBytes(partial: true) + XCTAssertEqual(data, expectedBytes, "While encoding \(message)", file: file, line: line) } catch let e { XCTFail("Encoding failed with error: \(e) for \(message)", file: file, line: line) } @@ -457,13 +481,13 @@ class Test_SmallRequired: XCTestCase, PBTestHelpers { } // Glue it all together and it should encode ok as it will be complete. - var allExpectedData = Data() + var allExpectedData = [UInt8]() msg = MessageTestType() for (expected, configure) in testInputs { - allExpectedData.append(Data(expected)) + allExpectedData.append(contentsOf: expected) configure(&msg) } - let serialized = try msg.serializedData() + let serialized: [UInt8] = try msg.serializedBytes() XCTAssertEqual(serialized, allExpectedData) } } diff --git a/Tests/SwiftProtobufTests/Test_Reserved.swift b/Tests/SwiftProtobufTests/Test_Reserved.swift index 7af17236a..5569a1f11 100644 --- a/Tests/SwiftProtobufTests/Test_Reserved.swift +++ b/Tests/SwiftProtobufTests/Test_Reserved.swift @@ -16,36 +16,45 @@ // ----------------------------------------------------------------------------- import Foundation +import SwiftProtobuf import XCTest -@testable import SwiftProtobuf -class Test_Reserved: XCTestCase { +final class Test_Reserved: XCTestCase { func testEnumNaming() { - XCTAssertEqual(ProtobufUnittest_SwiftReservedTest.Enum.double.rawValue, 1) - XCTAssertEqual(String(describing: ProtobufUnittest_SwiftReservedTest.Enum.double.name!), "DOUBLE") - XCTAssertEqual(ProtobufUnittest_SwiftReservedTest.Enum.json.rawValue, 2) - XCTAssertEqual(String(describing: ProtobufUnittest_SwiftReservedTest.Enum.json.name!), "JSON") - XCTAssertEqual(ProtobufUnittest_SwiftReservedTest.Enum.`class`.rawValue, 3) - XCTAssertEqual(String(describing: ProtobufUnittest_SwiftReservedTest.Enum.`class`.name!), "CLASS") - XCTAssertEqual(ProtobufUnittest_SwiftReservedTest.Enum.___.rawValue, 4) - XCTAssertEqual(String(describing: ProtobufUnittest_SwiftReservedTest.Enum.___.name!), "_") - XCTAssertEqual(ProtobufUnittest_SwiftReservedTest.Enum.self_.rawValue, 5) - XCTAssertEqual(String(describing: ProtobufUnittest_SwiftReservedTest.Enum.self_.name!), "SELF") - XCTAssertEqual(ProtobufUnittest_SwiftReservedTest.Enum.type.rawValue, 6) - XCTAssertEqual(String(describing: ProtobufUnittest_SwiftReservedTest.Enum.type.name!), "TYPE") + XCTAssertEqual(SwiftProtoTesting_SwiftReservedTest.Enum.double.rawValue, 1) + XCTAssertEqual(String(describing: SwiftProtoTesting_SwiftReservedTest.Enum.double.name!), "DOUBLE") + XCTAssertEqual(SwiftProtoTesting_SwiftReservedTest.Enum.json.rawValue, 2) + XCTAssertEqual(String(describing: SwiftProtoTesting_SwiftReservedTest.Enum.json.name!), "JSON") + XCTAssertEqual(SwiftProtoTesting_SwiftReservedTest.Enum.`class`.rawValue, 3) + XCTAssertEqual(String(describing: SwiftProtoTesting_SwiftReservedTest.Enum.`class`.name!), "CLASS") + XCTAssertEqual(SwiftProtoTesting_SwiftReservedTest.Enum.___.rawValue, 4) + XCTAssertEqual(String(describing: SwiftProtoTesting_SwiftReservedTest.Enum.___.name!), "_") + XCTAssertEqual(SwiftProtoTesting_SwiftReservedTest.Enum.self_.rawValue, 5) + XCTAssertEqual(String(describing: SwiftProtoTesting_SwiftReservedTest.Enum.self_.name!), "SELF") + XCTAssertEqual(SwiftProtoTesting_SwiftReservedTest.Enum.type.rawValue, 6) + XCTAssertEqual(String(describing: SwiftProtoTesting_SwiftReservedTest.Enum.type.name!), "TYPE") } func testMessageNames() { - XCTAssertEqual(ProtobufUnittest_SwiftReservedTest.classMessage.protoMessageName, "protobuf_unittest.SwiftReservedTest.class") - XCTAssertEqual(ProtobufUnittest_SwiftReservedTest.isEqual.protoMessageName, "protobuf_unittest.SwiftReservedTest.isEqual") - XCTAssertEqual(ProtobufUnittest_SwiftReservedTest.TypeMessage.protoMessageName, "protobuf_unittest.SwiftReservedTest.Type") + XCTAssertEqual( + SwiftProtoTesting_SwiftReservedTest.classMessage.protoMessageName, + "swift_proto_testing.SwiftReservedTest.class" + ) + XCTAssertEqual( + SwiftProtoTesting_SwiftReservedTest.isEqual.protoMessageName, + "swift_proto_testing.SwiftReservedTest.isEqual" + ) + XCTAssertEqual( + SwiftProtoTesting_SwiftReservedTest.TypeMessage.protoMessageName, + "swift_proto_testing.SwiftReservedTest.Type" + ) } func testFieldNamesMatchingMetadata() { // A chunk of this test is just that things compile because it is calling the names // we expect to have generated. - var msg = ProtobufUnittest_SwiftReservedTest() + var msg = SwiftProtoTesting_SwiftReservedTest() msg.protoMessageName = 1 msg.protoPackageName = 2 @@ -56,7 +65,10 @@ class Test_Reserved: XCTestCase { msg.hashValue_p = "bar" msg.debugDescription_p = 5 - XCTAssertEqual(msg.debugDescription, "SwiftProtobufTests.ProtobufUnittest_SwiftReservedTest:\nproto_message_name: 1\nproto_package_name: 2\nany_type_prefix: 3\nany_type_url: 4\nis_initialized: \"foo\"\nhash_value: \"bar\"\ndebug_description: 5\n") + assertDebugDescription( + "SwiftProtobufTests.SwiftProtoTesting_SwiftReservedTest:\nproto_message_name: 1\nproto_package_name: 2\nany_type_prefix: 3\nany_type_url: 4\nis_initialized: \"foo\"\nhash_value: \"bar\"\ndebug_description: 5\n", + msg + ) msg.clearIsInitialized_p() msg.clearHashValue_p() @@ -70,7 +82,7 @@ class Test_Reserved: XCTestCase { // This is really just a compile test, if things don't compile, check that the // new names really make sense. - var msg = ProtobufUnittest_SwiftReservedTest.TypeMessage() + var msg = SwiftProtoTesting_SwiftReservedTest.TypeMessage() msg.debugDescription_p = true XCTAssertTrue(msg.hasDebugDescription_p) diff --git a/Tests/SwiftProtobufTests/Test_SimpleExtensionMap.swift b/Tests/SwiftProtobufTests/Test_SimpleExtensionMap.swift index df3da4dc9..a552c5561 100644 --- a/Tests/SwiftProtobufTests/Test_SimpleExtensionMap.swift +++ b/Tests/SwiftProtobufTests/Test_SimpleExtensionMap.swift @@ -13,212 +13,223 @@ // ----------------------------------------------------------------------------- import Foundation +import SwiftProtobuf import XCTest -@testable import SwiftProtobuf extension AnyMessageExtension { - // Support equality to simplify testing of getting the correct errors. - func isEqual(_ other: AnyMessageExtension) -> Bool { - return (fieldNumber == other.fieldNumber && - fieldName == other.fieldName && - messageType == other.messageType) - } + // Support equality to simplify testing of getting the correct errors. + func isEqual(_ other: any AnyMessageExtension) -> Bool { + (fieldNumber == other.fieldNumber && fieldName == other.fieldName && messageType == other.messageType) + } } // Define some extension to use for testing behaviors. -let ext1 = MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 1, - fieldName: "my_ext1" +let ext1 = MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 1, + fieldName: "my_ext1" ) -let ext2 = MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 2, - fieldName: "my_ext2" +let ext2 = MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 2, + fieldName: "my_ext2" ) // Same field number as ext1, but different class being extended. -let ext3 = MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 1, - fieldName: "my_ext1b" +let ext3 = MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 1, + fieldName: "my_ext1b" ) // Same field number and message type as ext2, so it will replace it in the mapping. -let ext4 = MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 2, - fieldName: "my_ext4" +let ext4 = MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 2, + fieldName: "my_ext4" ) +final class Test_SimpleExtensionMap: XCTestCase { + func assert(map: SimpleExtensionMap, contains: [any AnyMessageExtension], line: UInt = #line) { + // Extact what it constaings. + var includes = [any AnyMessageExtension]() + for (_, l) in map.fields { + for e in l { + includes.append(e) + } + } -class Test_SimpleExtensionMap: XCTestCase { - func assert(map: SimpleExtensionMap, contains: [AnyMessageExtension], line: UInt = #line) { - // Extact what it constaings. - var includes = [AnyMessageExtension]() - for (_, l) in map.fields { - for e in l { - includes.append(e) - } - } - - // Check that everything the lists match no matter the orders. - for c in contains { - var found = false - for i in includes { - if (c.isEqual(i)) { - found = true - break + // Check that everything the lists match no matter the orders. + for c in contains { + var found = false + for i in includes { + if c.isEqual(i) { + found = true + break + } + } + XCTAssertTrue(found, "Map didn't include \(c)", line: line) } - } - XCTAssertTrue(found, "Map didn't include \(c)", line: line) - } - for i in includes { - var found = false - for c in contains { - if (i.isEqual(c)) { - found = true - break + for i in includes { + var found = false + for c in contains { + if i.isEqual(c) { + found = true + break + } + } + XCTAssertTrue(found, "Map wasn't supposed to include \(i)", line: line) } - } - XCTAssertTrue(found, "Map wasn't supposed to include \(i)", line: line) } - } - - func testInsert() { - var map = SimpleExtensionMap() - XCTAssertEqual(map.fields.count, 0) - map.insert(ext1) - assert(map: map, contains: [ext1]) + func testInsert() { + var map = SimpleExtensionMap() + XCTAssertEqual(map.fields.count, 0) - map.insert(ext2) - assert(map: map, contains: [ext2, ext1]) + map.insert(ext1) + assert(map: map, contains: [ext1]) - map.insert(ext3) - assert(map: map, contains: [ext3, ext2, ext1]) + map.insert(ext2) + assert(map: map, contains: [ext2, ext1]) - // ext4 has the same message and number as ext2, so should replace it. - map.insert(ext4) - assert(map: map, contains: [ext4, ext1, ext3]) - } + map.insert(ext3) + assert(map: map, contains: [ext3, ext2, ext1]) - func testInsert_contentsOf() { - var map = SimpleExtensionMap() - XCTAssertEqual(map.fields.count, 0) - - map.insert(contentsOf: [ext1, ext2]) - assert(map: map, contains: [ext1, ext2]) - - // ext4 has the same message and number as ext2, so should replace it. - map.insert(contentsOf: [ext3, ext4]) - assert(map: map, contains: [ext1, ext4, ext3]) - } - - func testInitialize_list() { - let map1: SimpleExtensionMap = [ext1, ext2] - assert(map: map1, contains: [ext1, ext2]) - - let map2: SimpleExtensionMap = [ext1, ext2, ext3, ext4] - assert(map: map2, contains: [ext1, ext3, ext4]) -} - - func testFormUnion() { - var map1: SimpleExtensionMap = [ext1] - let map2: SimpleExtensionMap = [ext2] - let map3: SimpleExtensionMap = [ext3, ext4] - - map1.formUnion(map2) - assert(map: map1, contains: [ext1, ext2]) + // ext4 has the same message and number as ext2, so should replace it. + map.insert(ext4) + assert(map: map, contains: [ext4, ext1, ext3]) + } - // ext4 has the same message and number as ext2, so should replace it. - map1.formUnion(map3) - assert(map: map1, contains: [ext1, ext3, ext4]) - } + func testInsert_contentsOf() { + var map = SimpleExtensionMap() + XCTAssertEqual(map.fields.count, 0) - func testUnion() { - let map1: SimpleExtensionMap = [ext1] - let map2: SimpleExtensionMap = [ext2] - let map3: SimpleExtensionMap = [ext3, ext4] + map.insert(contentsOf: [ext1, ext2]) + assert(map: map, contains: [ext1, ext2]) - let map4 = map1.union(map2) - assert(map: map4, contains: [ext1, ext2]) + // ext4 has the same message and number as ext2, so should replace it. + map.insert(contentsOf: [ext3, ext4]) + assert(map: map, contains: [ext1, ext4, ext3]) + } - // ext4 has the same message and number as ext2, so should replace it. - let map5 = map4.union(map3) - assert(map: map5, contains: [ext1, ext3, ext4]) - } - - func testInitialize_union() { - let map1: SimpleExtensionMap = [ext1] - let map2: SimpleExtensionMap = [ext2] - let map3: SimpleExtensionMap = [ext3, ext4] + func testInitialize_list() { + let map1: SimpleExtensionMap = [ext1, ext2] + assert(map: map1, contains: [ext1, ext2]) - let map4 = SimpleExtensionMap(map1, map2) - assert(map: map4, contains: [ext1, ext2]) + let map2: SimpleExtensionMap = [ext1, ext2, ext3, ext4] + assert(map: map2, contains: [ext1, ext3, ext4]) + } - // ext4 has the same message and number as ext2, so should replace it. - let map5 = SimpleExtensionMap(map1, map2, map3) - assert(map: map5, contains: [ext1, ext3, ext4]) - } + func testFormUnion() { + var map1: SimpleExtensionMap = [ext1] + let map2: SimpleExtensionMap = [ext2] + let map3: SimpleExtensionMap = [ext3, ext4] - func testSubscript() { - let map1: SimpleExtensionMap = [ext1, ext2] + map1.formUnion(map2) + assert(map: map1, contains: [ext1, ext2]) - let lookup1 = map1[ext1.messageType, ext1.fieldNumber] - XCTAssertTrue(lookup1!.isEqual(ext1)) + // ext4 has the same message and number as ext2, so should replace it. + map1.formUnion(map3) + assert(map: map1, contains: [ext1, ext3, ext4]) + } - let lookup2 = map1[ext2.messageType, ext2.fieldNumber] - XCTAssertTrue(lookup2!.isEqual(ext2)) + func testUnion() { + let map1: SimpleExtensionMap = [ext1] + let map2: SimpleExtensionMap = [ext2] + let map3: SimpleExtensionMap = [ext3, ext4] - let lookup3 = map1[ProtobufUnittest_TestAllTypes.self, ext1.fieldNumber] - XCTAssertNil(lookup3) + let map4 = map1.union(map2) + assert(map: map4, contains: [ext1, ext2]) - let lookup4 = map1[ext1.messageType, 999] - XCTAssertNil(lookup4) + // ext4 has the same message and number as ext2, so should replace it. + let map5 = map4.union(map3) + assert(map: map5, contains: [ext1, ext3, ext4]) + } - // ext4 will replace ext2 - let map2: SimpleExtensionMap = [ext1, ext2, ext4] + func testInitialize_union() { + let map1: SimpleExtensionMap = [ext1] + let map2: SimpleExtensionMap = [ext2] + let map3: SimpleExtensionMap = [ext3, ext4] - let lookup1b = map2[ext1.messageType, ext1.fieldNumber] - XCTAssertTrue(lookup1b!.isEqual(ext1)) + let map4 = SimpleExtensionMap(map1, map2) + assert(map: map4, contains: [ext1, ext2]) - let lookup2b = map2[ext2.messageType, ext2.fieldNumber] - XCTAssertTrue(lookup2b!.isEqual(ext4)) - XCTAssertTrue(!lookup2b!.isEqual(ext2)) - } + // ext4 has the same message and number as ext2, so should replace it. + let map5 = SimpleExtensionMap(map1, map2, map3) + assert(map: map5, contains: [ext1, ext3, ext4]) + } - func testFieldNumberForProto() { - let map1: SimpleExtensionMap = [ext1, ext2] + func testSubscript() { + let map1: SimpleExtensionMap = [ext1, ext2] - let lookup1 = map1.fieldNumberForProto(messageType: ext1.messageType, - protoFieldName: ext1.fieldName) - XCTAssertEqual(lookup1, ext1.fieldNumber) + let lookup1 = map1[ext1.messageType, ext1.fieldNumber] + XCTAssertTrue(lookup1!.isEqual(ext1)) - let lookup2 = map1.fieldNumberForProto(messageType: ext2.messageType, - protoFieldName: ext2.fieldName) - XCTAssertEqual(lookup2, ext2.fieldNumber) + let lookup2 = map1[ext2.messageType, ext2.fieldNumber] + XCTAssertTrue(lookup2!.isEqual(ext2)) - let lookup3 = map1.fieldNumberForProto(messageType: ext1.messageType, - protoFieldName: "foo_bar_baz") - XCTAssertNil(lookup3) + let lookup3 = map1[SwiftProtoTesting_TestAllTypes.self, ext1.fieldNumber] + XCTAssertNil(lookup3) - let lookup4 = map1.fieldNumberForProto(messageType: ProtobufUnittest_TestAllTypes.self, - protoFieldName: ext1.fieldName) - XCTAssertNil(lookup4) + let lookup4 = map1[ext1.messageType, 999] + XCTAssertNil(lookup4) - // ext4 will replace ext2 - let map2: SimpleExtensionMap = [ext1, ext2, ext4] + // ext4 will replace ext2 + let map2: SimpleExtensionMap = [ext1, ext2, ext4] - let lookup1b = map2.fieldNumberForProto(messageType: ext1.messageType, - protoFieldName: ext1.fieldName) - XCTAssertEqual(lookup1b, ext1.fieldNumber) + let lookup1b = map2[ext1.messageType, ext1.fieldNumber] + XCTAssertTrue(lookup1b!.isEqual(ext1)) - let lookup2b = map2.fieldNumberForProto(messageType: ext2.messageType, - protoFieldName: ext2.fieldName) - XCTAssertNil(lookup2b) + let lookup2b = map2[ext2.messageType, ext2.fieldNumber] + XCTAssertTrue(lookup2b!.isEqual(ext4)) + XCTAssertTrue(!lookup2b!.isEqual(ext2)) + } - let lookup3b = map2.fieldNumberForProto(messageType: ext4.messageType, - protoFieldName: ext4.fieldName) - XCTAssertEqual(lookup3b, ext4.fieldNumber) - } + func testFieldNumberForProto() { + let map1: SimpleExtensionMap = [ext1, ext2] + + let lookup1 = map1.fieldNumberForProto( + messageType: ext1.messageType, + protoFieldName: ext1.fieldName + ) + XCTAssertEqual(lookup1, ext1.fieldNumber) + + let lookup2 = map1.fieldNumberForProto( + messageType: ext2.messageType, + protoFieldName: ext2.fieldName + ) + XCTAssertEqual(lookup2, ext2.fieldNumber) + + let lookup3 = map1.fieldNumberForProto( + messageType: ext1.messageType, + protoFieldName: "foo_bar_baz" + ) + XCTAssertNil(lookup3) + + let lookup4 = map1.fieldNumberForProto( + messageType: SwiftProtoTesting_TestAllTypes.self, + protoFieldName: ext1.fieldName + ) + XCTAssertNil(lookup4) + + // ext4 will replace ext2 + let map2: SimpleExtensionMap = [ext1, ext2, ext4] + + let lookup1b = map2.fieldNumberForProto( + messageType: ext1.messageType, + protoFieldName: ext1.fieldName + ) + XCTAssertEqual(lookup1b, ext1.fieldNumber) + + let lookup2b = map2.fieldNumberForProto( + messageType: ext2.messageType, + protoFieldName: ext2.fieldName + ) + XCTAssertNil(lookup2b) + + let lookup3b = map2.fieldNumberForProto( + messageType: ext4.messageType, + protoFieldName: ext4.fieldName + ) + XCTAssertEqual(lookup3b, ext4.fieldNumber) + } } diff --git a/Tests/SwiftProtobufTests/Test_Struct.swift b/Tests/SwiftProtobufTests/Test_Struct.swift index bd074b656..ccc7eddfe 100644 --- a/Tests/SwiftProtobufTests/Test_Struct.swift +++ b/Tests/SwiftProtobufTests/Test_Struct.swift @@ -14,14 +14,14 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_Struct: XCTestCase, PBTestHelpers { +final class Test_Struct: XCTestCase, PBTestHelpers { typealias MessageTestType = Google_Protobuf_Struct func testStruct_pbencode() { - assertEncode([10, 12, 10, 3, 102, 111, 111, 18, 5, 26, 3, 98, 97, 114]) {(o: inout MessageTestType) in + assertEncode([10, 12, 10, 3, 102, 111, 111, 18, 5, 26, 3, 98, 97, 114]) { (o: inout MessageTestType) in var v = Google_Protobuf_Value() v.stringValue = "bar" o.fields["foo"] = v @@ -37,7 +37,8 @@ class Test_Struct: XCTestCase, PBTestHelpers { var different = Google_Protobuf_Struct() different.fields = ["a": vTrue, "b": vNull, "c": vNull] - return (m.fields.count == 2 + return + (m.fields.count == 2 && m.fields["a"] == vTrue && m.fields["a"] != vNull && m.fields["b"] == vNull @@ -48,7 +49,7 @@ class Test_Struct: XCTestCase, PBTestHelpers { } func test_JSON() { - assertJSONDecodeSucceeds("{}") {$0.fields == [:]} + assertJSONDecodeSucceeds("{}") { $0.fields == [:] } assertJSONDecodeFails("null") assertJSONDecodeFails("false") assertJSONDecodeFails("true") @@ -65,7 +66,7 @@ class Test_Struct: XCTestCase, PBTestHelpers { // "null" as a field value indicates the field is missing // (Except for Value, where "null" indicates NullValue) do { - let c1 = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString:"{\"optionalStruct\":null}") + let c1 = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: "{\"optionalStruct\":null}") // null here decodes to an empty field. // See github.com/protocolbuffers/protobuf Issue #1327 XCTAssertEqual(try c1.jsonString(), "{}") @@ -74,7 +75,7 @@ class Test_Struct: XCTestCase, PBTestHelpers { } do { - let c2 = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString:"{\"optionalStruct\":{}}") + let c2 = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: "{\"optionalStruct\":{}}") XCTAssertNotNil(c2.optionalStruct) XCTAssertEqual(c2.optionalStruct.fields, [:]) } catch let e { @@ -103,14 +104,15 @@ class Test_Struct: XCTestCase, PBTestHelpers { } } -class Test_JSON_ListValue: XCTestCase, PBTestHelpers { +final class Test_JSON_ListValue: XCTestCase, PBTestHelpers { typealias MessageTestType = Google_Protobuf_ListValue // Since ProtobufJSONList is handbuilt rather than generated, // we need to verify all the basic functionality, including // serialization, equality, hash, etc. func testProtobuf() { - assertEncode([10, 9, 17, 0, 0, 0, 0, 0, 0, 240, 63, 10, 5, 26, 3, 97, 98, 99, 10, 2, 32, 1]) { (o: inout MessageTestType) in + assertEncode([10, 9, 17, 0, 0, 0, 0, 0, 0, 240, 63, 10, 5, 26, 3, 97, 98, 99, 10, 2, 32, 1]) { + (o: inout MessageTestType) in o.values.append(Google_Protobuf_Value(numberValue: 1)) o.values.append(Google_Protobuf_Value(stringValue: "abc")) o.values.append(Google_Protobuf_Value(boolValue: true)) @@ -130,7 +132,7 @@ class Test_JSON_ListValue: XCTestCase, PBTestHelpers { o.values.append(Google_Protobuf_Value(listValue: [1, nil])) o.values.append(Google_Protobuf_Value(listValue: [])) } - assertJSONDecodeSucceeds("[]") {$0.values == []} + assertJSONDecodeSucceeds("[]") { $0.values == [] } assertJSONDecodeFails("") assertJSONDecodeFails("true") assertJSONDecodeFails("false") @@ -140,20 +142,20 @@ class Test_JSON_ListValue: XCTestCase, PBTestHelpers { assertJSONDecodeFails("[}") assertJSONDecodeFails("[,]") assertJSONDecodeFails("[true,]") - assertJSONDecodeSucceeds("[true]") {$0.values == [Google_Protobuf_Value(boolValue: true)]} + assertJSONDecodeSucceeds("[true]") { $0.values == [Google_Protobuf_Value(boolValue: true)] } } func test_JSON_nested_list() throws { let limit = JSONDecodingOptions().messageDepthLimit let depths = [ // Small lists - 1,2,3,4,5, + 1, 2, 3, 4, 5, // Little less than default messageDepthLimit, should succeed limit - 3, limit - 2, limit - 1, limit, // Little bigger than default messageDepthLimit, should fail limit + 1, limit + 2, limit + 3, limit + 4, // Really big, should fail cleanly (not crash) - 1000,10000,100000,1000000 + 1000, 10000, 100000, 1_000_000, ] for depth in depths { var s = "" @@ -172,7 +174,7 @@ class Test_JSON_ListValue: XCTestCase, PBTestHelpers { // Recursion limits should cause this to // fail cleanly without crashing if depth <= limit { - assertJSONDecodeSucceeds(s) {_ in true} + assertJSONDecodeSucceeds(s) { _ in true } } else { assertJSONDecodeFails(s) } @@ -193,8 +195,7 @@ class Test_JSON_ListValue: XCTestCase, PBTestHelpers { } } - -class Test_Value: XCTestCase, PBTestHelpers { +final class Test_Value: XCTestCase, PBTestHelpers { typealias MessageTestType = Google_Protobuf_Value func testValue_empty() throws { @@ -211,9 +212,8 @@ class Test_Value: XCTestCase, PBTestHelpers { } } - // TODO: Should have convenience initializers on Google_Protobuf_Value -class Test_JSON_Value: XCTestCase, PBTestHelpers { +final class Test_JSON_Value: XCTestCase, PBTestHelpers { typealias MessageTestType = Google_Protobuf_Value func testValue_emptyShouldThrow() throws { @@ -235,19 +235,19 @@ class Test_JSON_Value: XCTestCase, PBTestHelpers { XCTAssertEqual([8, 0], try null.serializedBytes()) XCTAssertEqual(nullFromLiteral, null) XCTAssertNotEqual(nullFromLiteral, Google_Protobuf_Value(numberValue: 1)) - assertJSONDecodeSucceeds("null") {$0.nullValue == .nullValue} - assertJSONDecodeSucceeds(" null ") {$0.nullValue == .nullValue} + assertJSONDecodeSucceeds("null") { $0.nullValue == .nullValue } + assertJSONDecodeSucceeds(" null ") { $0.nullValue == .nullValue } assertJSONDecodeFails("numb") do { - let m1 = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: "{\"optionalValue\": null}") + let m1 = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: "{\"optionalValue\": null}") XCTAssertEqual(try m1.jsonString(), "{\"optionalValue\":null}") XCTAssertEqual(try m1.serializedBytes(), [146, 19, 2, 8, 0]) } catch { XCTFail() } - XCTAssertEqual(null.debugDescription, "SwiftProtobuf.Google_Protobuf_Value:\nnull_value: NULL_VALUE\n") + assertDebugDescriptionSuffix(".Google_Protobuf_Value:\nnull_value: NULL_VALUE\n", null) } func testValue_number() throws { @@ -258,14 +258,14 @@ class Test_JSON_Value: XCTestCase, PBTestHelpers { XCTAssertNotEqual(oneFromIntegerLiteral, twoFromFloatLiteral) XCTAssertEqual("1.0", try oneFromIntegerLiteral.jsonString()) XCTAssertEqual([17, 0, 0, 0, 0, 0, 0, 240, 63], try oneFromIntegerLiteral.serializedBytes()) - assertJSONEncode("3.25") {(o: inout MessageTestType) in + assertJSONEncode("3.25") { (o: inout MessageTestType) in o.numberValue = 3.25 } - assertJSONDecodeSucceeds("3.25") {$0.numberValue == 3.25} - assertJSONDecodeSucceeds(" 3.25 ") {$0.numberValue == 3.25} + assertJSONDecodeSucceeds("3.25") { $0.numberValue == 3.25 } + assertJSONDecodeSucceeds(" 3.25 ") { $0.numberValue == 3.25 } assertJSONDecodeFails("3.2.5") - XCTAssertEqual(oneFromIntegerLiteral.debugDescription, "SwiftProtobuf.Google_Protobuf_Value:\nnumber_value: 1.0\n") + assertDebugDescriptionSuffix(".Google_Protobuf_Value:\nnumber_value: 1.0\n", oneFromIntegerLiteral) } func testValue_string() throws { @@ -276,14 +276,14 @@ class Test_JSON_Value: XCTestCase, PBTestHelpers { XCTAssertNotEqual(fromStringLiteral, Google_Protobuf_Value()) // JSON serialization - assertJSONEncode("\"abcd\"") {(o: inout MessageTestType) in + assertJSONEncode("\"abcd\"") { (o: inout MessageTestType) in o.stringValue = "abcd" } - assertJSONEncode("\"\"") {(o: inout MessageTestType) in + assertJSONEncode("\"\"") { (o: inout MessageTestType) in o.stringValue = "" } - assertJSONDecodeSucceeds("\"abcd\"") {$0.stringValue == "abcd"} - assertJSONDecodeSucceeds(" \"abcd\" ") {$0.stringValue == "abcd"} + assertJSONDecodeSucceeds("\"abcd\"") { $0.stringValue == "abcd" } + assertJSONDecodeSucceeds(" \"abcd\" ") { $0.stringValue == "abcd" } assertJSONDecodeFails("\"abcd\" XXX") assertJSONDecodeFails("\"abcd") @@ -302,7 +302,7 @@ class Test_JSON_Value: XCTestCase, PBTestHelpers { // PB serialization XCTAssertEqual([26, 3, 97, 34, 98], try Google_Protobuf_Value(stringValue: "a\"b").serializedBytes()) - XCTAssertEqual(fromStringLiteral.debugDescription, "SwiftProtobuf.Google_Protobuf_Value:\nstring_value: \"abcd\"\n") + assertDebugDescriptionSuffix(".Google_Protobuf_Value:\nstring_value: \"abcd\"\n", fromStringLiteral) } func testValue_bool() { @@ -311,35 +311,38 @@ class Test_JSON_Value: XCTestCase, PBTestHelpers { XCTAssertEqual(trueFromLiteral, Google_Protobuf_Value(boolValue: true)) XCTAssertEqual(falseFromLiteral, Google_Protobuf_Value(boolValue: false)) XCTAssertNotEqual(falseFromLiteral, trueFromLiteral) - assertJSONEncode("true") {(o: inout MessageTestType) in + assertJSONEncode("true") { (o: inout MessageTestType) in o.boolValue = true } - assertJSONEncode("false") {(o: inout MessageTestType) in + assertJSONEncode("false") { (o: inout MessageTestType) in o.boolValue = false } - assertJSONDecodeSucceeds("true") {$0.boolValue == true} - assertJSONDecodeSucceeds(" false ") {$0.boolValue == false} + assertJSONDecodeSucceeds("true") { $0.boolValue == true } + assertJSONDecodeSucceeds(" false ") { $0.boolValue == false } assertJSONDecodeFails("yes") assertJSONDecodeFails(" true false ") - XCTAssertEqual(trueFromLiteral.debugDescription, "SwiftProtobuf.Google_Protobuf_Value:\nbool_value: true\n") + assertDebugDescriptionSuffix(".Google_Protobuf_Value:\nbool_value: true\n", trueFromLiteral) } func testValue_struct() throws { - assertJSONEncode("{\"a\":1.0}") {(o: inout MessageTestType) in - o.structValue = Google_Protobuf_Struct(fields:["a": Google_Protobuf_Value(numberValue: 1)]) + assertJSONEncode("{\"a\":1.0}") { (o: inout MessageTestType) in + o.structValue = Google_Protobuf_Struct(fields: ["a": Google_Protobuf_Value(numberValue: 1)]) } let structValue = try Google_Protobuf_Value(jsonString: "{\"a\":1.0}") - let d = structValue.debugDescription - XCTAssertEqual(d, "SwiftProtobuf.Google_Protobuf_Value:\nstruct_value {\n fields {\n key: \"a\"\n value {\n number_value: 1.0\n }\n }\n}\n") + assertDebugDescriptionSuffix( + ".Google_Protobuf_Value:\nstruct_value {\n fields {\n key: \"a\"\n value {\n number_value: 1.0\n }\n }\n}\n", + structValue + ) } func testValue_list() throws { let listValue = try Google_Protobuf_Value(jsonString: "[1, true, \"abc\"]") - let d = listValue.debugDescription - XCTAssertEqual(d, "SwiftProtobuf.Google_Protobuf_Value:\nlist_value {\n values {\n number_value: 1.0\n }\n values {\n bool_value: true\n }\n values {\n string_value: \"abc\"\n }\n}\n") - + assertDebugDescriptionSuffix( + ".Google_Protobuf_Value:\nlist_value {\n values {\n number_value: 1.0\n }\n values {\n bool_value: true\n }\n values {\n string_value: \"abc\"\n }\n}\n", + listValue + ) } func testValue_complex() { @@ -347,7 +350,8 @@ class Test_JSON_Value: XCTestCase, PBTestHelpers { let outer = $0.structValue.fields let a = outer["a"]?.structValue.fields let c = outer["c"]?.listValue.values - return (a?["b"]?.numberValue == 1.0 + return + (a?["b"]?.numberValue == 1.0 && c?.count == 4 && c?[0].numberValue == 7 && c?[1].boolValue == true @@ -357,22 +361,23 @@ class Test_JSON_Value: XCTestCase, PBTestHelpers { } func testStruct_conformance() throws { - let json = ("{\n" - + " \"optionalStruct\": {\n" - + " \"nullValue\": null,\n" - + " \"intValue\": 1234,\n" - + " \"boolValue\": true,\n" - + " \"doubleValue\": 1234.5678,\n" - + " \"stringValue\": \"Hello world!\",\n" - + " \"listValue\": [1234, \"5678\"],\n" - + " \"objectValue\": {\n" - + " \"value\": 0\n" - + " }\n" - + " }\n" - + "}\n") - let m: ProtobufTestMessages_Proto3_TestAllTypesProto3 + let json = + ("{\n" + + " \"optionalStruct\": {\n" + + " \"nullValue\": null,\n" + + " \"intValue\": 1234,\n" + + " \"boolValue\": true,\n" + + " \"doubleValue\": 1234.5678,\n" + + " \"stringValue\": \"Hello world!\",\n" + + " \"listValue\": [1234, \"5678\"],\n" + + " \"objectValue\": {\n" + + " \"value\": 0\n" + + " }\n" + + " }\n" + + "}\n") + let m: SwiftProtoTesting_Test3_TestAllTypesProto3 do { - m = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: json) + m = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: json) } catch { XCTFail("Decoding failed: \(json)") return @@ -405,9 +410,13 @@ class Test_JSON_Value: XCTestCase, PBTestHelpers { } XCTAssertNotNil(s.fields["listValue"]) if let lv = s.fields["listValue"] { - XCTAssertEqual(lv.listValue, - [Google_Protobuf_Value(numberValue: 1234), - Google_Protobuf_Value(stringValue: "5678")]) + XCTAssertEqual( + lv.listValue, + [ + Google_Protobuf_Value(numberValue: 1234), + Google_Protobuf_Value(stringValue: "5678"), + ] + ) } XCTAssertNotNil(s.fields["objectValue"]) if let ov = s.fields["objectValue"] { @@ -420,11 +429,12 @@ class Test_JSON_Value: XCTestCase, PBTestHelpers { } func testStruct_null() throws { - let json = ("{\n" - + " \"optionalStruct\": null\n" - + "}\n") + let json = + ("{\n" + + " \"optionalStruct\": null\n" + + "}\n") do { - let decoded = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: json) + let decoded = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: json) let recoded = try decoded.jsonString() XCTAssertEqual(recoded, "{}") } catch { diff --git a/Tests/SwiftProtobufTests/Test_TextFormatDecodingOptions.swift b/Tests/SwiftProtobufTests/Test_TextFormatDecodingOptions.swift index c0212dd28..cd84a40c4 100644 --- a/Tests/SwiftProtobufTests/Test_TextFormatDecodingOptions.swift +++ b/Tests/SwiftProtobufTests/Test_TextFormatDecodingOptions.swift @@ -13,28 +13,741 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_TextFormatDecodingOptions: XCTestCase { +final class Test_TextFormatDecodingOptions: XCTestCase { func testMessageDepthLimit() { let textInput = "a: { a: { i: 1 } }" let tests: [(Int, Bool)] = [ // Limit, success/failure - ( 10, true ), - ( 4, true ), - ( 3, true ), - ( 2, false ), - ( 1, false ), + (10, true), + (4, true), + (3, true), + (2, false), + (1, false), + ] + + for (limit, expectSuccess) in tests { + do { + var options = TextFormatDecodingOptions() + options.messageDepthLimit = limit + let _ = try SwiftProtoTesting_TestRecursiveMessage(textFormatString: textInput, options: options) + if !expectSuccess { + XCTFail("Should not have succeed, limit: \(limit)") + } + } catch TextFormatDecodingError.messageDepthLimit { + if expectSuccess { + XCTFail("Decode failed because of limit, but should *NOT* have, limit: \(limit)") + } else { + // Nothing, this is what was expected. + } + } catch let e { + XCTFail("Decode failed (limit: \(limit) with unexpected error: \(e)") + } + } + } + + // MARK: Ignoring unknown fields + + func testIgnoreUnknown_Fields() throws { + let textInputField = "a:1\noptional_int32: 2\nfoo_bar_baz: 3" + let textInputExtField = "[ext.field]: 1\noptional_int32: 2\n[other_ext]: 3" + + var options = TextFormatDecodingOptions() + options.ignoreUnknownFields = true + + let msg = try SwiftProtoTesting_TestAllTypes(textFormatString: textInputField, options: options) + XCTAssertEqual(msg.textFormatString(), "optional_int32: 2\n") + + do { + let _ = try SwiftProtoTesting_TestAllTypes(textFormatString: textInputExtField, options: options) + XCTFail("Shouldn't get here") + } catch TextFormatDecodingError.unknownField { + // This is what should have happened. + } + } + + func testIgnoreUnknown_ExtensionFields() throws { + let textInputField = "a:1\noptional_int32: 2\nfoo_bar_baz: 3" + let textInputExtField = "[ext.field]: 1\noptional_int32: 2\n[other_ext]: 3" + + var options = TextFormatDecodingOptions() + options.ignoreUnknownExtensionFields = true + + do { + let _ = try SwiftProtoTesting_TestAllTypes(textFormatString: textInputField, options: options) + XCTFail("Shouldn't get here") + } catch TextFormatDecodingError.unknownField { + // This is what should have happened. + } + + let msg = try SwiftProtoTesting_TestAllTypes(textFormatString: textInputExtField, options: options) + XCTAssertEqual(msg.textFormatString(), "optional_int32: 2\n") + } + + func testIgnoreUnknown_Both() throws { + let textInput = "a:1\noptional_int32: 2\n[ext.field]: 3" + + var options = TextFormatDecodingOptions() + options.ignoreUnknownFields = true + options.ignoreUnknownExtensionFields = true + + let msg = try SwiftProtoTesting_TestAllTypes(textFormatString: textInput, options: options) + XCTAssertEqual(msg.textFormatString(), "optional_int32: 2\n") + } + + private struct FieldModes: OptionSet { + let rawValue: Int + + static let single = FieldModes(rawValue: 1 << 0) + static let repeated = FieldModes(rawValue: 1 << 1) + + static let all: FieldModes = [.single, .repeated] + } + + // Custom assert that confirms something parsed as a know field on a message passes and also + // parses when skipped for an unknown field (when the option is enabled). + private func assertDecodeIgnoringUnknownsSucceeds( + _ field: String, + _ value: String, + includeColon: Bool = true, + fieldModes: FieldModes = .all, + file: XCTestFileArgType = #file, + line: UInt = #line + ) { + assert(!fieldModes.isEmpty) + let maybeColon = includeColon ? ":" : "" + let singleText = "optional_\(field)\(maybeColon) \(value)" + let repeatedText = "repeated_\(field): [ \(value) ]" + // First, make sure it decodes into a message correctly. + if fieldModes.contains(.single) { + do { + let msg = try SwiftProtoTesting_TestAllTypes(textFormatString: singleText) + XCTAssertFalse(msg.textFormatString().isEmpty, file: file, line: line) // Should have set some field + } catch { + XCTFail("Shoudn't have failed to decode: \(singleText) - \(error)", file: file, line: line) + } + } + if fieldModes.contains(.repeated) { + do { + let msg = try SwiftProtoTesting_TestAllTypes(textFormatString: repeatedText) + // If there was a value, this something should be set (backdoor to testing + // repeated empty arrays) + XCTAssertEqual(value.isEmpty, msg.textFormatString().isEmpty, file: file, line: line) + } catch { + XCTFail("Shoudn't have failed to decode: \(repeatedText) - \(error)", file: file, line: line) + } + } + + var options = TextFormatDecodingOptions() + options.ignoreUnknownFields = true + options.ignoreUnknownExtensionFields = true + + func assertEmptyDecodeSucceeds(_ text: String) { + do { + let msg = try SwiftProtoTesting_TestEmptyMessage(textFormatString: text, options: options) + XCTAssertTrue(msg.textFormatString().isEmpty, file: file, line: line) + } catch { + XCTFail("Ignoring unknowns shouldn't failed: \(text) - \(error)", file: file, line: line) + } + } + + let singleExtText = "[ext.\(field)]\(maybeColon) \(value)" + let repeatedExtText = "[ext.\(field)]: [ \(value) ]" + + if fieldModes.contains(.single) { + assertEmptyDecodeSucceeds(singleText) + assertEmptyDecodeSucceeds(singleExtText) + assertEmptyDecodeSucceeds("\(singleText) # comment") + assertEmptyDecodeSucceeds("\(singleExtText) # comment") + assertEmptyDecodeSucceeds("unknown_message { \(singleText) }") + assertEmptyDecodeSucceeds("unknown_message { \(singleExtText) }") + assertEmptyDecodeSucceeds("unknown_message {\n # comment before\n \(singleText)\n}") + assertEmptyDecodeSucceeds("unknown_message {\n # comment before\n \(singleExtText)\n}") + assertEmptyDecodeSucceeds("unknown_message {\n \(singleText)\n # comment after\n}") + assertEmptyDecodeSucceeds("unknown_message {\n \(singleExtText)\n # comment after\n}") + assertEmptyDecodeSucceeds("unknown_repeating_message: [ { \(singleText) } ]") + assertEmptyDecodeSucceeds("unknown_repeating_message: [ { \(singleExtText) } ]") + assertEmptyDecodeSucceeds("unknown_repeating_message: [\n # comment before\n { \(singleText) }\n]") + assertEmptyDecodeSucceeds("unknown_repeating_message: [\n # comment before\n { \(singleExtText) }\n]") + assertEmptyDecodeSucceeds("unknown_repeating_message: [\n { \(singleText) }\n # comment after\n]") + assertEmptyDecodeSucceeds("unknown_repeating_message: [\n { \(singleExtText) }\n # comment after\n]") + } + if fieldModes.contains(.repeated) { + assertEmptyDecodeSucceeds(repeatedText) + assertEmptyDecodeSucceeds(repeatedExtText) + assertEmptyDecodeSucceeds("\(repeatedText) # comment after") + assertEmptyDecodeSucceeds("\(repeatedExtText) # comment after") + assertEmptyDecodeSucceeds("unknown_message { \(repeatedText) }") + assertEmptyDecodeSucceeds("unknown_message { \(repeatedExtText) }") + assertEmptyDecodeSucceeds("unknown_message {\n # comment before\n \(repeatedText)\n}") + assertEmptyDecodeSucceeds("unknown_message {\n # comment before\n \(repeatedExtText)\n}") + assertEmptyDecodeSucceeds("unknown_message {\n \(repeatedText)\n # comment after\n}") + assertEmptyDecodeSucceeds("unknown_message {\n \(repeatedExtText)\n # comment after\n}") + assertEmptyDecodeSucceeds("unknown_repeating_message: [ { \(repeatedText) } ]") + assertEmptyDecodeSucceeds("unknown_repeating_message: [ { \(repeatedExtText) } ]") + assertEmptyDecodeSucceeds("unknown_repeating_message: [\n # comment before\n { \(repeatedText) }\n]") + assertEmptyDecodeSucceeds("unknown_repeating_message: [\n # comment before\n { \(repeatedExtText) }\n]") + assertEmptyDecodeSucceeds("unknown_repeating_message: [\n { \(repeatedText) }\n # comment after\n]") + assertEmptyDecodeSucceeds("unknown_repeating_message: [\n { \(repeatedExtText) }\n # comment after\n]") + } + } + + // Custom assert that confirms something parsed as a know field on a message fails and also + // fails when skipped for an unknown field (when the option is enabled). + private func assertDecodeIgnoringUnknownsFails( + _ field: String, + _ value: String, + includeColon: Bool = true, + fieldModes: FieldModes = .all, + file: XCTestFileArgType = #file, + line: UInt = #line + ) { + assert(!fieldModes.isEmpty) + let maybeColon = includeColon ? ":" : "" + let singleText = "optional_\(field)\(maybeColon) \(value)" + let repeatedText = "repeated_\(field)\(maybeColon) [ \(value) ]" + // First, make sure it fails decodes. + if fieldModes.contains(.single) { + do { + let _ = try SwiftProtoTesting_TestAllTypes(textFormatString: singleText) + XCTFail("Should have failed to decode: \(singleText)", file: file, line: line) + } catch { + // Nothing + // TODO: Does it make sense to compare this failure to the ones below? + } + } + if fieldModes.contains(.repeated) { + do { + let _ = try SwiftProtoTesting_TestAllTypes(textFormatString: repeatedText) + XCTFail("Should have failed to decode: \(repeatedText)", file: file, line: line) + } catch { + // Nothing + // TODO: Does it make sense to compare this failure to the ones below? + } + } + + var options = TextFormatDecodingOptions() + options.ignoreUnknownFields = true + options.ignoreUnknownExtensionFields = true + + func assertEmptyDecodeFails(_ text: String) { + do { + let _ = try SwiftProtoTesting_TestEmptyMessage(textFormatString: text, options: options) + XCTFail("Ignoring unknowns should have still failed: \(text)", file: file, line: line) + } catch { + // Nothing + } + } + + let singleExtText = "[ext.\(field)]\(maybeColon) \(value)" + let repeatedExtText = "[ext.\(field)]\(maybeColon) [ \(value) ]" + + // Don't bother with the comment variation as we wouldn't be able to tell if it was + // a failure for the comment or for the field itself. + if fieldModes.contains(.single) { + assertEmptyDecodeFails(singleText) + assertEmptyDecodeFails(singleExtText) + assertEmptyDecodeFails("unknown_message { \(singleText) }") + assertEmptyDecodeFails("unknown_message { \(singleExtText) }") + assertEmptyDecodeFails("unknown_repeating_message: [ { \(singleText) } ]") + assertEmptyDecodeFails("unknown_repeating_message: [ { \(singleExtText) } ]") + } + if fieldModes.contains(.repeated) { + assertEmptyDecodeFails(repeatedText) + assertEmptyDecodeFails(repeatedExtText) + assertEmptyDecodeFails("unknown_message { \(repeatedText) }") + assertEmptyDecodeFails("unknown_message { \(repeatedExtText) }") + assertEmptyDecodeFails("unknown_repeating_message: [ { \(repeatedText) } ]") + assertEmptyDecodeFails("unknown_repeating_message: [ { \(repeatedExtText) } ]") + } + } + + func testIgnoreUnknown_String() { + assertDecodeIgnoringUnknownsSucceeds("string", "'abc'") + assertDecodeIgnoringUnknownsSucceeds("string", "\"abc\"") + assertDecodeIgnoringUnknownsSucceeds("string", "'abc'\n'def'") + assertDecodeIgnoringUnknownsSucceeds("string", "\"abc\"\n\"def\"") + assertDecodeIgnoringUnknownsSucceeds("string", "\" !\\\"#$%&'\"\n") + assertDecodeIgnoringUnknownsSucceeds("string", "\"øùúûüýþÿ\"\n") + assertDecodeIgnoringUnknownsSucceeds("string", "\"\\a\\b\\f\\n\\r\\t\\v\\\"\\'\\\\\\?\"") + assertDecodeIgnoringUnknownsSucceeds("string", "\"\\001\\002\\003\\004\\005\\006\\007\"\n") + assertDecodeIgnoringUnknownsSucceeds("string", "\"\\b\\t\\n\\v\\f\\r\\016\\017\"\n") + assertDecodeIgnoringUnknownsSucceeds("string", "\"\\020\\021\\022\\023\\024\\025\\026\\027\"\n") + assertDecodeIgnoringUnknownsSucceeds("string", "\"\\030\\031\\032\\033\\034\\035\\036\\037\"\n") + assertDecodeIgnoringUnknownsSucceeds("string", "\"☞\"\n") + assertDecodeIgnoringUnknownsSucceeds("string", "\"\\xE2\\x98\\x9E\"") + assertDecodeIgnoringUnknownsSucceeds("string", "\"\\342\\230\\236\"") + + assertDecodeIgnoringUnknownsFails("string", "\"\\z\"") + assertDecodeIgnoringUnknownsFails("string", "\"hello\'") + assertDecodeIgnoringUnknownsFails("string", "\'hello\"") + assertDecodeIgnoringUnknownsFails("string", "\"hello") + // Can't test invalid UTF-8 because as an unknown parse just as bytes. + } + + func testIgnoreUnknown_Bytes() { + assertDecodeIgnoringUnknownsSucceeds("bytes", "'abc'") + assertDecodeIgnoringUnknownsSucceeds("bytes", "\"abc\"") + assertDecodeIgnoringUnknownsSucceeds("bytes", "'abc'\n'def'") + assertDecodeIgnoringUnknownsSucceeds("bytes", "\"abc\"\n\"def\"") + assertDecodeIgnoringUnknownsSucceeds("bytes", "\" !\\\"#$%&'\"\n") + assertDecodeIgnoringUnknownsSucceeds("bytes", "\"øùúûüýþÿ\"\n") + assertDecodeIgnoringUnknownsSucceeds("bytes", "\"\\a\\b\\f\\n\\r\\t\\v\\\"\\'\\\\\\?\"") + assertDecodeIgnoringUnknownsSucceeds("bytes", "\"\\001\\002\\003\\004\\005\\006\\007\"\n") + assertDecodeIgnoringUnknownsSucceeds("bytes", "\"\\b\\t\\n\\v\\f\\r\\016\\017\"\n") + assertDecodeIgnoringUnknownsSucceeds("bytes", "\"\\020\\021\\022\\023\\024\\025\\026\\027\"\n") + assertDecodeIgnoringUnknownsSucceeds("bytes", "\"\\030\\031\\032\\033\\034\\035\\036\\037\"\n") + assertDecodeIgnoringUnknownsSucceeds("bytes", "\"☞\"\n") + assertDecodeIgnoringUnknownsSucceeds("bytes", "\"\\xE2\\x98\\x9E\"") + assertDecodeIgnoringUnknownsSucceeds("bytes", "\"\\342\\230\\236\"") + + assertDecodeIgnoringUnknownsFails("bytes", "\"\\z\"") + assertDecodeIgnoringUnknownsFails("bytes", "\"hello\'") + assertDecodeIgnoringUnknownsFails("bytes", "\'hello\"") + assertDecodeIgnoringUnknownsFails("bytes", "\"hello") + assertDecodeIgnoringUnknownsFails("bytes", "\"\\\"\n") + assertDecodeIgnoringUnknownsFails("bytes", "\"\\x\"\n") + assertDecodeIgnoringUnknownsFails("bytes", "\"\\x&\"\n") + assertDecodeIgnoringUnknownsFails("bytes", "\"\\xg\"\n") + assertDecodeIgnoringUnknownsFails("bytes", "\"\\q\"\n") + assertDecodeIgnoringUnknownsFails("bytes", "\"\\777\"\n") // Out-of-range octal + assertDecodeIgnoringUnknownsFails("bytes", "\"") + assertDecodeIgnoringUnknownsFails("bytes", "\"abcde") + assertDecodeIgnoringUnknownsFails("bytes", "\"\\") + assertDecodeIgnoringUnknownsFails("bytes", "\"\\3") + assertDecodeIgnoringUnknownsFails("bytes", "\"\\32") + assertDecodeIgnoringUnknownsFails("bytes", "\"\\232") + assertDecodeIgnoringUnknownsFails("bytes", "\"\\x") + assertDecodeIgnoringUnknownsFails("bytes", "\"\\x1") + assertDecodeIgnoringUnknownsFails("bytes", "\"\\x12") + assertDecodeIgnoringUnknownsFails("bytes", "\"\\x12q") + } + + func testIgnoreUnknown_Enum() { + assertDecodeIgnoringUnknownsSucceeds("nested_enum", "BAZ") + // Made up values will pass when ignoring unknown fields + } + + func testIgnoreUnknown_Bool() { + assertDecodeIgnoringUnknownsSucceeds("bool", "true") + assertDecodeIgnoringUnknownsSucceeds("bool", "True") + assertDecodeIgnoringUnknownsSucceeds("bool", "t") + assertDecodeIgnoringUnknownsSucceeds("bool", "T") + assertDecodeIgnoringUnknownsSucceeds("bool", "1") + assertDecodeIgnoringUnknownsSucceeds("bool", "false") + assertDecodeIgnoringUnknownsSucceeds("bool", "False") + assertDecodeIgnoringUnknownsSucceeds("bool", "f") + assertDecodeIgnoringUnknownsSucceeds("bool", "F") + assertDecodeIgnoringUnknownsSucceeds("bool", "0") + // Made up values will pass when ignoring unknown fields (as enums) + } + + func testIgnoreUnknown_Integer() { + assertDecodeIgnoringUnknownsSucceeds("int32", "0") + assertDecodeIgnoringUnknownsSucceeds("int32", "-12") + assertDecodeIgnoringUnknownsSucceeds("int32", "0x20") + assertDecodeIgnoringUnknownsSucceeds("int32", "-0x12") + assertDecodeIgnoringUnknownsSucceeds("int32", "01") + assertDecodeIgnoringUnknownsSucceeds("int32", "0123") + assertDecodeIgnoringUnknownsSucceeds("int32", "-01") + assertDecodeIgnoringUnknownsSucceeds("int32", "-0123") + + // Can't test range values for any ints because they would work as floats + + assertDecodeIgnoringUnknownsFails("int32", "0x1g") + assertDecodeIgnoringUnknownsFails("int32", "0x1a2g") + assertDecodeIgnoringUnknownsFails("int32", "-0x1g") + assertDecodeIgnoringUnknownsFails("int32", "-0x1a2g") + assertDecodeIgnoringUnknownsFails("int32", "09") + assertDecodeIgnoringUnknownsFails("int32", "-09") + assertDecodeIgnoringUnknownsFails("int32", "01a") + assertDecodeIgnoringUnknownsFails("int32", "-01a") + assertDecodeIgnoringUnknownsFails("int32", "0128") + assertDecodeIgnoringUnknownsFails("int32", "-0128") + } + + func testIgnoreUnknown_FloatingPoint() { + assertDecodeIgnoringUnknownsSucceeds("float", "0") + + assertDecodeIgnoringUnknownsSucceeds("float", "11.0") + assertDecodeIgnoringUnknownsSucceeds("float", "1.0f") + assertDecodeIgnoringUnknownsSucceeds("float", "12f") + assertDecodeIgnoringUnknownsSucceeds("float", "1.0F") + assertDecodeIgnoringUnknownsSucceeds("float", "12F") + assertDecodeIgnoringUnknownsSucceeds("float", "0.1234") + assertDecodeIgnoringUnknownsSucceeds("float", ".123") + assertDecodeIgnoringUnknownsSucceeds("float", "1.5e3") + assertDecodeIgnoringUnknownsSucceeds("float", "2.5e+3") + assertDecodeIgnoringUnknownsSucceeds("float", "3.5e-3") + + assertDecodeIgnoringUnknownsSucceeds("float", "-11.0") + assertDecodeIgnoringUnknownsSucceeds("float", "-1.0f") + assertDecodeIgnoringUnknownsSucceeds("float", "-12f") + assertDecodeIgnoringUnknownsSucceeds("float", "-1.0F") + assertDecodeIgnoringUnknownsSucceeds("float", "-12F") + assertDecodeIgnoringUnknownsSucceeds("float", "-0.1234") + assertDecodeIgnoringUnknownsSucceeds("float", "-.123") + assertDecodeIgnoringUnknownsSucceeds("float", "-1.5e3") + assertDecodeIgnoringUnknownsSucceeds("float", "-2.5e+3") + assertDecodeIgnoringUnknownsSucceeds("float", "-3.5e-3") + + // This would overload a int, but as a floating point value it will map to "inf". + assertDecodeIgnoringUnknownsSucceeds("float", "999999999999999999999999999999999999") + + // Things that round to infinity or zero, but should parse ok. + assertDecodeIgnoringUnknownsSucceeds("float", "1e50") + assertDecodeIgnoringUnknownsSucceeds("float", "-1e50") + assertDecodeIgnoringUnknownsSucceeds("float", "1e-50") + assertDecodeIgnoringUnknownsSucceeds("float", "-1e-50") + assertDecodeIgnoringUnknownsSucceeds("double", "1e9999") + assertDecodeIgnoringUnknownsSucceeds("double", "-1e9999") + assertDecodeIgnoringUnknownsSucceeds("double", "1e-9999") + assertDecodeIgnoringUnknownsSucceeds("double", "-1e-9999") + + assertDecodeIgnoringUnknownsSucceeds("float", "nan") + assertDecodeIgnoringUnknownsSucceeds("float", "-nan") + assertDecodeIgnoringUnknownsSucceeds("float", "inf") + assertDecodeIgnoringUnknownsSucceeds("float", "-inf") + assertDecodeIgnoringUnknownsSucceeds("double", "nan") + assertDecodeIgnoringUnknownsSucceeds("double", "-nan") + assertDecodeIgnoringUnknownsSucceeds("double", "inf") + assertDecodeIgnoringUnknownsSucceeds("double", "-inf") + } + + func testIgnoreUnknown_Messages() { + // Both bracing types + assertDecodeIgnoringUnknownsSucceeds("nested_message", "{ bb: 7 }") + assertDecodeIgnoringUnknownsSucceeds("nested_message", "{}") + assertDecodeIgnoringUnknownsSucceeds("nested_message", "< bb: 7 >") + assertDecodeIgnoringUnknownsSucceeds("nested_message", "<>") + // Without the colon after the field name + assertDecodeIgnoringUnknownsSucceeds("nested_message", "{ bb: 7 }", includeColon: false) + assertDecodeIgnoringUnknownsSucceeds("nested_message", "{}", includeColon: false) + assertDecodeIgnoringUnknownsSucceeds("nested_message", "< bb: 7 >", includeColon: false) + assertDecodeIgnoringUnknownsSucceeds("nested_message", "<>", includeColon: false) + + assertDecodeIgnoringUnknownsFails("nested_message", "{ >") + assertDecodeIgnoringUnknownsFails("nested_message", "< }") + assertDecodeIgnoringUnknownsFails("nested_message", "{ bb: 7 >") + assertDecodeIgnoringUnknownsFails("nested_message", "< bb: 7 }") + assertDecodeIgnoringUnknownsFails("nested_message", "{ >", includeColon: false) + assertDecodeIgnoringUnknownsFails("nested_message", "< }", includeColon: false) + assertDecodeIgnoringUnknownsFails("nested_message", "{ bb: 7 >", includeColon: false) + assertDecodeIgnoringUnknownsFails("nested_message", "< bb: 7 }", includeColon: false) + } + + func testIgnoreUnknown_FieldSeparators() { + assertDecodeIgnoringUnknownsSucceeds("foreign_message", "{ c: 1, d: 2 }") + assertDecodeIgnoringUnknownsSucceeds("foreign_message", "{ c: 1; d: 2 }") + assertDecodeIgnoringUnknownsSucceeds("foreign_message", "{ c: 1 d: 2 }") + + // Valid parsing accepts separators after a single field, validate that for unknowns also. + + assertDecodeIgnoringUnknownsSucceeds("string", "'abc',", fieldModes: .single) + assertDecodeIgnoringUnknownsSucceeds("nested_enum", "BAZ,", fieldModes: .single) + assertDecodeIgnoringUnknownsSucceeds("bool", "true,", fieldModes: .single) + assertDecodeIgnoringUnknownsSucceeds("int32", "0,", fieldModes: .single) + assertDecodeIgnoringUnknownsSucceeds("float", "nan,", fieldModes: .single) + assertDecodeIgnoringUnknownsSucceeds("foreign_message", "{ },", fieldModes: .single) + + assertDecodeIgnoringUnknownsSucceeds("string", "'abc';", fieldModes: .single) + assertDecodeIgnoringUnknownsSucceeds("nested_enum", "BAZ;", fieldModes: .single) + assertDecodeIgnoringUnknownsSucceeds("bool", "true;", fieldModes: .single) + assertDecodeIgnoringUnknownsSucceeds("int32", "0;", fieldModes: .single) + assertDecodeIgnoringUnknownsSucceeds("float", "nan;", fieldModes: .single) + assertDecodeIgnoringUnknownsSucceeds("foreign_message", "{ };", fieldModes: .single) + // And now within an a sub message. + assertDecodeIgnoringUnknownsSucceeds("foreign_message", "{ c: 1, }", fieldModes: .single) + assertDecodeIgnoringUnknownsSucceeds("foreign_message", "{ c: 1; }", fieldModes: .single) + + // Extra separators fails. + assertDecodeIgnoringUnknownsFails("string", "'abc',,", fieldModes: .single) + assertDecodeIgnoringUnknownsFails("nested_enum", "BAZ,,", fieldModes: .single) + assertDecodeIgnoringUnknownsFails("bool", "true,,", fieldModes: .single) + assertDecodeIgnoringUnknownsFails("int32", "0,,", fieldModes: .single) + assertDecodeIgnoringUnknownsFails("float", "nan,,", fieldModes: .single) + assertDecodeIgnoringUnknownsFails("foreign_message", "{ },,", fieldModes: .single) + + assertDecodeIgnoringUnknownsFails("string", "'abc';;", fieldModes: .single) + assertDecodeIgnoringUnknownsFails("nested_enum", "BAZ;;", fieldModes: .single) + assertDecodeIgnoringUnknownsFails("bool", "true;;", fieldModes: .single) + assertDecodeIgnoringUnknownsFails("int32", "0;;", fieldModes: .single) + assertDecodeIgnoringUnknownsFails("float", "nan;;", fieldModes: .single) + assertDecodeIgnoringUnknownsFails("foreign_message", "{ };;", fieldModes: .single) + // And now within an a sub message. + assertDecodeIgnoringUnknownsFails("foreign_message", "{ c: 1,, }", fieldModes: .single) + assertDecodeIgnoringUnknownsFails("foreign_message", "{ c: 1;; }", fieldModes: .single) + + // Test a few depths of nesting and separators along the way and unknown fields at the + // start and end of each scope along the way. + + let text = """ + unknown_first_outer: "first", + child { + repeated_child { + unknown_first_inner: [0], + payload { + unknown_first_inner_inner: "test", + optional_int32: 1, + unknown_inner_inner: 2f, + }, + unknown_inner: 3.0, + }, + repeated_child { + unknown_first_inner: 0; + payload { + unknown_first_inner_inner: "test"; + optional_int32: 1; + unknown_inner_inner: 2f; + }, + unknown_inner: [3.0]; + }; + unknown: "nope", + unknown: 12; + }, + unknown_outer: [END]; + unknown_outer_final: "last"; + """ + + var options = TextFormatDecodingOptions() + options.ignoreUnknownFields = true + options.ignoreUnknownExtensionFields = true + + do { + let msg = try SwiftProtoTesting_NestedTestAllTypes(textFormatString: text, options: options) + XCTAssertFalse(msg.textFormatString().isEmpty) + } catch { + XCTFail("Shoudn't have failed to decode: \(error)") + } + + } + + func testIgnoreUnknown_ListSeparators() { + // "repeated_int32: []" - good + assertDecodeIgnoringUnknownsSucceeds("int32", "", fieldModes: .repeated) + + // "repeated_int32: [1 2]" - bad, no commas + assertDecodeIgnoringUnknownsFails("int32", "1 2", fieldModes: .repeated) + // "repeated_int32: [1, 2,]" - bad extra trailing comma with no value + assertDecodeIgnoringUnknownsFails("int32", "1, 2,", fieldModes: .repeated) + } + + func testIgnoreUnknown_Comments() throws { + // Stress test to unknown field parsing deals with comments correctly. + let text = """ + does_not_exist: true # comment + something_else { # comment + # comment + optional_string: "still unknown" + } # comment + + optional_int32: 1 # !!! real field + + does_not_exist: true # comment + something_else { # comment + # comment + optional_string: "still unknown" # comment + optional_string: "still unknown" # comment + # comment + "continued" # comment + # comment + some_int : 0x12 # comment + a_float: #comment + 0.2 # comment + repeat: [ + # comment + -123 # comment + # comment + , # comment + # comment + 0222 # comment + # comment + , # comment + # comment + 012 # comment + # comment + ] # comment + } # comment + + optional_uint32: 2 # !!! real field + + does_not_exist: true # comment + something_else { # comment + # comment + optional_string: "still unknown" + } # comment + + """ + + let expected = SwiftProtoTesting_TestAllTypes.with { + $0.optionalInt32 = 1 + $0.optionalUint32 = 2 + } + + var options = TextFormatDecodingOptions() + options.ignoreUnknownFields = true + + let msg = try SwiftProtoTesting_TestAllTypes(textFormatString: text, options: options) + XCTAssertEqual(expected, msg) + } + + func testIgnoreUnknown_Whitespace() throws { + // Blanket test to unknown field parsing deals with comments correctly. + let text = """ + optional_int32: 1 # !!! real field + + does_not_exist + : + 1 + + something_else { + + optional_string: "still unknown" + + " continued value" + + repeated: [ + 1 , + 0x1 + , + 3, 012 + ] + + } + + repeated_strs: [ + "ab" "cd" , + "de" + , + "xyz" + ] + + an_int:1some_bytes:"abc"msg_field:{a:true}repeated:[1]another_int:3 + + optional_uint32: 2 # !!! real field + """ + + let expected = SwiftProtoTesting_TestAllTypes.with { + $0.optionalInt32 = 1 + $0.optionalUint32 = 2 + } + + var options = TextFormatDecodingOptions() + options.ignoreUnknownFields = true + + let msg = try SwiftProtoTesting_TestAllTypes(textFormatString: text, options: options) + XCTAssertEqual(expected, msg) + } + + func testIgnoreUnknown_fieldnumTooBig() { + let expected = SwiftProtoTesting_TestAllTypes.with { + $0.optionalInt32 = 1 + $0.optionalUint32 = 2 + } + var options = TextFormatDecodingOptions() + options.ignoreUnknownFields = true + + // The max field number is 536,870,911, so anything that takes more digits, should + // fail as malformed. + + let testCases: [(field: String, parses: Bool)] = [ + ("536870911", true), + ("1536870911", false), + ] + + for testCase in testCases { + let text = """ + optional_int32: 1 # !!! real field + + # Unknown field that's a message to test parsing of field numbers + # nested within a unknown message. + does_not_exist { + \(testCase.field): 1 + } + + optional_uint32: 2 # !!! real field + """ + + do { + let msg = try SwiftProtoTesting_TestAllTypes( + textFormatString: text, + options: options + ) + // If we get here, it should be the expected message. + XCTAssertTrue(testCase.parses) + XCTAssertEqual(msg, expected) + } catch TextFormatDecodingError.malformedText { + if testCase.parses { + XCTFail("Unexpected malformedText - input: \(testCase.field)") + } else { + // Nothing, was the expected error + } + } catch { + XCTFail("Unexpected error: \(error) - input: \(testCase.field)") + } + } + } + + func testIgnoreUnknown_FailListWithinList() { + // The C++ TextFormat parse doesn't directly block this, but it calculates + // recusion depth differently (it counts each field as a +1/-1 while parsing + // it, that makes an array count as depth); so this got flagged by the fuzz + // testing as a way would could end up with stack overflow. + + var options = TextFormatDecodingOptions() + options.ignoreUnknownFields = true + options.ignoreUnknownExtensionFields = true + + let testCases: [String] = [ + // fields + "f:[[]]", + "f:[1, [], 2]", + "f ", + "f ", + "[e] (_ message: M, expected: String, file: XCTestFileArgType = #file, line: UInt = #line) { + func assertAnyTest( + _ message: M, + expected: String, + file: XCTestFileArgType = #file, + line: UInt = #line + ) { let empty = MessageTestType() var configured = empty do { @@ -34,7 +39,12 @@ class Test_TextFormat_WKT_proto3: XCTestCase, PBTestHelpers { let decoded = try MessageTestType(textFormatString: encoded) let decodedMessage = try M(unpackingAny: decoded.anyField) let r = (message == decodedMessage) - XCTAssert(r, "Encode/decode cycle should generate equal object: \(decoded) != \(configured)", file: file, line: line) + XCTAssert( + r, + "Encode/decode cycle should generate equal object: \(decoded) != \(configured)", + file: file, + line: line + ) } catch { XCTFail("Encode/decode cycle should not throw error, decoding: \(error)", file: file, line: line) } @@ -43,32 +53,45 @@ class Test_TextFormat_WKT_proto3: XCTestCase, PBTestHelpers { // Any equality is a little tricky, so this directly tests the inner // contained object after unpacking the Any. func testAny() throws { - assertAnyTest(Google_Protobuf_Duration(seconds: 123, nanos: 123456789), - expected: "any_field {\n [type.googleapis.com/google.protobuf.Duration] {\n seconds: 123\n nanos: 123456789\n }\n}\n") - assertAnyTest(Google_Protobuf_Empty(), - expected: "any_field {\n [type.googleapis.com/google.protobuf.Empty] {\n }\n}\n") + assertAnyTest( + Google_Protobuf_Duration(seconds: 123, nanos: 123_456_789), + expected: + "any_field {\n [type.googleapis.com/google.protobuf.Duration] {\n seconds: 123\n nanos: 123456789\n }\n}\n" + ) + assertAnyTest( + Google_Protobuf_Empty(), + expected: "any_field {\n [type.googleapis.com/google.protobuf.Empty] {\n }\n}\n" + ) // Nested any - let a = try ProtobufUnittest_TestWellKnownTypes.with { - $0.anyField = try Google_Protobuf_Any(message: Google_Protobuf_Any(message: Google_Protobuf_Duration(seconds: 123, nanos: 234567890))) + let a = try SwiftProtoTesting_TestWellKnownTypes.with { + $0.anyField = try Google_Protobuf_Any( + message: Google_Protobuf_Any(message: Google_Protobuf_Duration(seconds: 123, nanos: 234_567_890)) + ) } let a_encoded = a.textFormatString() - XCTAssertEqual(a_encoded, "any_field {\n [type.googleapis.com/google.protobuf.Any] {\n [type.googleapis.com/google.protobuf.Duration] {\n seconds: 123\n nanos: 234567890\n }\n }\n}\n") + XCTAssertEqual( + a_encoded, + "any_field {\n [type.googleapis.com/google.protobuf.Any] {\n [type.googleapis.com/google.protobuf.Duration] {\n seconds: 123\n nanos: 234567890\n }\n }\n}\n" + ) - let a_decoded = try ProtobufUnittest_TestWellKnownTypes(textFormatString: a_encoded) + let a_decoded = try SwiftProtoTesting_TestWellKnownTypes(textFormatString: a_encoded) let a_decoded_any = a_decoded.anyField let a_decoded_any_any = try Google_Protobuf_Any(unpackingAny: a_decoded_any) let a_decoded_any_any_duration = try Google_Protobuf_Duration(unpackingAny: a_decoded_any_any) XCTAssertEqual(a_decoded_any_any_duration.seconds, 123) - XCTAssertEqual(a_decoded_any_any_duration.nanos, 234567890) + XCTAssertEqual(a_decoded_any_any_duration.nanos, 234_567_890) } // Any supports a "verbose" text encoding that uses the URL as the key // and then encloses the serialization of the object. func testAny_verbose() { - let a: ProtobufUnittest_TestWellKnownTypes + let a: SwiftProtoTesting_TestWellKnownTypes do { - a = try ProtobufUnittest_TestWellKnownTypes(textFormatString: "any_field {[type.googleapis.com/google.protobuf.Duration] {seconds:77,nanos:123456789}}") + a = try SwiftProtoTesting_TestWellKnownTypes( + textFormatString: + "any_field {[type.googleapis.com/google.protobuf.Duration] {seconds:77,nanos:123456789}}" + ) } catch let e { XCTFail("Decoding failed: \(e)") return @@ -77,15 +100,18 @@ class Test_TextFormat_WKT_proto3: XCTestCase, PBTestHelpers { let a_any = a.anyField let a_duration = try Google_Protobuf_Duration(unpackingAny: a_any) XCTAssertEqual(a_duration.seconds, 77) - XCTAssertEqual(a_duration.nanos, 123456789) + XCTAssertEqual(a_duration.nanos, 123_456_789) } catch let e { XCTFail("Any field doesn't hold a duration?: \(e)") } // Nested Any is a particularly tricky decode problem - let b: ProtobufUnittest_TestWellKnownTypes + let b: SwiftProtoTesting_TestWellKnownTypes do { - b = try ProtobufUnittest_TestWellKnownTypes(textFormatString: "any_field {[type.googleapis.com/google.protobuf.Any]{[type.googleapis.com/google.protobuf.Duration] {seconds:88,nanos:987654321}}}") + b = try SwiftProtoTesting_TestWellKnownTypes( + textFormatString: + "any_field {[type.googleapis.com/google.protobuf.Any]{[type.googleapis.com/google.protobuf.Duration] {seconds:88,nanos:987654321}}}" + ) } catch let e { XCTFail("Decoding failed: \(e)") return @@ -100,7 +126,7 @@ class Test_TextFormat_WKT_proto3: XCTestCase, PBTestHelpers { do { let b_duration = try Google_Protobuf_Duration(unpackingAny: b_any) XCTAssertEqual(b_duration.seconds, 88) - XCTAssertEqual(b_duration.nanos, 987654321) + XCTAssertEqual(b_duration.nanos, 987_654_321) } catch let e { XCTFail("Inner Any field doesn't hold a Duration: \(e)") } @@ -114,7 +140,7 @@ class Test_TextFormat_WKT_proto3: XCTestCase, PBTestHelpers { "duration_field {\n seconds: 123\n nanos: 123456789\n}\n" ) { (o: inout MessageTestType) in - o.durationField = Google_Protobuf_Duration(seconds: 123, nanos: 123456789) + o.durationField = Google_Protobuf_Duration(seconds: 123, nanos: 123_456_789) } } @@ -147,7 +173,7 @@ class Test_TextFormat_WKT_proto3: XCTestCase, PBTestHelpers { "timestamp_field {\n seconds: 123\n nanos: 123456789\n}\n" ) { (o: inout MessageTestType) in - o.timestampField = Google_Protobuf_Timestamp(seconds: 123, nanos: 123456789) + o.timestampField = Google_Protobuf_Timestamp(seconds: 123, nanos: 123_456_789) } } diff --git a/Tests/SwiftProtobufTests/Test_TextFormat_proto2.swift b/Tests/SwiftProtobufTests/Test_TextFormat_proto2.swift index 0d5097d5c..5b351ea0d 100644 --- a/Tests/SwiftProtobufTests/Test_TextFormat_proto2.swift +++ b/Tests/SwiftProtobufTests/Test_TextFormat_proto2.swift @@ -13,36 +13,51 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_TextFormat_proto2: XCTestCase, PBTestHelpers { - typealias MessageTestType = ProtobufUnittest_TestAllTypes +final class Test_TextFormat_proto2: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_TestAllTypes func test_group() { - assertTextFormatEncode("OptionalGroup {\n a: 17\n}\n") {(o: inout MessageTestType) in - o.optionalGroup = ProtobufUnittest_TestAllTypes.OptionalGroup.with {$0.a = 17} + assertTextFormatEncode("OptionalGroup {\n a: 17\n}\n") { (o: inout MessageTestType) in + o.optionalGroup = SwiftProtoTesting_TestAllTypes.OptionalGroup.with { $0.a = 17 } } } + func test_group_altName() throws { + let msg = try MessageTestType(textFormatString: "optionalgroup {a: 17}") + XCTAssertEqual(msg.optionalGroup.a, 17) + XCTAssertEqual(msg.textFormatString(), "OptionalGroup {\n a: 17\n}\n") + } + func test_group_numbers() { - assertTextFormatDecodeSucceeds("16 {\n 17: 17\n}\n") {(o: MessageTestType) in - o.optionalGroup == ProtobufUnittest_TestAllTypes.OptionalGroup.with {$0.a = 17} + assertTextFormatDecodeSucceeds("16 {\n 17: 17\n}\n") { (o: MessageTestType) in + o.optionalGroup == SwiftProtoTesting_TestAllTypes.OptionalGroup.with { $0.a = 17 } } } func test_repeatedGroup() { - assertTextFormatEncode("RepeatedGroup {\n a: 17\n}\nRepeatedGroup {\n a: 18\n}\n") {(o: inout MessageTestType) in - let group17 = ProtobufUnittest_TestAllTypes.RepeatedGroup.with {$0.a = 17} - let group18 = ProtobufUnittest_TestAllTypes.RepeatedGroup.with {$0.a = 18} + assertTextFormatEncode("RepeatedGroup {\n a: 17\n}\nRepeatedGroup {\n a: 18\n}\n") { + (o: inout MessageTestType) in + let group17 = SwiftProtoTesting_TestAllTypes.RepeatedGroup.with { $0.a = 17 } + let group18 = SwiftProtoTesting_TestAllTypes.RepeatedGroup.with { $0.a = 18 } o.repeatedGroup = [group17, group18] } } + func test_repeatedGroup_altName() throws { + let msg = try MessageTestType(textFormatString: "repeatedgroup {a: 17}\nrepeatedgroup {a: 18}") + let group17 = SwiftProtoTesting_TestAllTypes.RepeatedGroup.with { $0.a = 17 } + let group18 = SwiftProtoTesting_TestAllTypes.RepeatedGroup.with { $0.a = 18 } + XCTAssertEqual(msg.repeatedGroup, [group17, group18]) + XCTAssertEqual(msg.textFormatString(), "RepeatedGroup {\n a: 17\n}\nRepeatedGroup {\n a: 18\n}\n") + } + func test_repeatedGroup_numbers() { - assertTextFormatDecodeSucceeds("46 {\n 47: 17\n}\n46 {\n 47: 18\n}\n") {(o: MessageTestType) in - let group17 = ProtobufUnittest_TestAllTypes.RepeatedGroup.with {$0.a = 17} - let group18 = ProtobufUnittest_TestAllTypes.RepeatedGroup.with {$0.a = 18} + assertTextFormatDecodeSucceeds("46 {\n 47: 17\n}\n46 {\n 47: 18\n}\n") { (o: MessageTestType) in + let group17 = SwiftProtoTesting_TestAllTypes.RepeatedGroup.with { $0.a = 17 } + let group18 = SwiftProtoTesting_TestAllTypes.RepeatedGroup.with { $0.a = 18 } return o.repeatedGroup == [group17, group18] } } diff --git a/Tests/SwiftProtobufTests/Test_TextFormat_proto2_extensions.swift b/Tests/SwiftProtobufTests/Test_TextFormat_proto2_extensions.swift index 3a999b08b..9536e20a7 100644 --- a/Tests/SwiftProtobufTests/Test_TextFormat_proto2_extensions.swift +++ b/Tests/SwiftProtobufTests/Test_TextFormat_proto2_extensions.swift @@ -13,37 +13,43 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_TextFormat_proto2_extensions: XCTestCase, PBTestHelpers { - typealias MessageTestType = ProtobufUnittest_TestAllExtensions +final class Test_TextFormat_proto2_extensions: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_TestAllExtensions func test_file_level_extension() { - assertTextFormatEncode("[protobuf_unittest.optional_int32_extension]: 789\n", - extensions: ProtobufUnittest_Unittest_Extensions) { + assertTextFormatEncode( + "[swift_proto_testing.optional_int32_extension]: 789\n", + extensions: SwiftProtoTesting_Unittest_Extensions + ) { (o: inout MessageTestType) in - o.ProtobufUnittest_optionalInt32Extension = 789 + o.SwiftProtoTesting_optionalInt32Extension = 789 } // Fails if we don't provide the extensions to the decoder: - assertTextFormatDecodeFails("[protobuf_unittest.optional_int32_extension]: 789\n") + assertTextFormatDecodeFails("[swift_proto_testing.optional_int32_extension]: 789\n") - assertTextFormatEncode("[protobuf_unittest.optionalgroup_extension] {\n a: 789\n}\n", - extensions: ProtobufUnittest_Unittest_Extensions) { + assertTextFormatEncode( + "[swift_proto_testing.optionalgroup_extension] {\n a: 789\n}\n", + extensions: SwiftProtoTesting_Unittest_Extensions + ) { (o: inout MessageTestType) in - o.ProtobufUnittest_optionalGroupExtension.a = 789 + o.SwiftProtoTesting_optionalGroupExtension.a = 789 } // Fails if we don't provide the extensions to the decoder: - assertTextFormatDecodeFails("[protobuf_unittest.optionalgroup_extension] {\n a: 789\n}\n") + assertTextFormatDecodeFails("[swift_proto_testing.optionalgroup_extension] {\n a: 789\n}\n") } func test_nested_extension() { - assertTextFormatEncode("[protobuf_unittest.TestNestedExtension.test]: \"foo\"\n", - extensions: ProtobufUnittest_Unittest_Extensions) { + assertTextFormatEncode( + "[swift_proto_testing.TestNestedExtension.test]: \"foo\"\n", + extensions: SwiftProtoTesting_Unittest_Extensions + ) { (o: inout MessageTestType) in - o.ProtobufUnittest_TestNestedExtension_test = "foo" + o.SwiftProtoTesting_TestNestedExtension_test = "foo" } // Fails if we don't provide the extensions to the decoder: - assertTextFormatDecodeFails("[protobuf_unittest.TestNestedExtension.test]: \"foo\"\n") + assertTextFormatDecodeFails("[swift_proto_testing.TestNestedExtension.test]: \"foo\"\n") } } diff --git a/Tests/SwiftProtobufTests/Test_TextFormat_proto3.swift b/Tests/SwiftProtobufTests/Test_TextFormat_proto3.swift index 149965cff..e8135e028 100644 --- a/Tests/SwiftProtobufTests/Test_TextFormat_proto3.swift +++ b/Tests/SwiftProtobufTests/Test_TextFormat_proto3.swift @@ -13,23 +13,23 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { - typealias MessageTestType = Proto3Unittest_TestAllTypes +final class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_Proto3_TestAllTypes func testDecoding_comments() { assertTextFormatDecodeSucceeds("optional_int32: 41#optional_int32: 42\noptional_int64: 8") { (o: MessageTestType) in - return o.optionalInt32 == 41 && o.optionalInt64 == 8 + o.optionalInt32 == 41 && o.optionalInt64 == 8 } } func testDecoding_comments_numbers() { assertTextFormatDecodeSucceeds("1: 41#optional_int32: 42\n2: 8") { (o: MessageTestType) in - return o.optionalInt32 == 41 && o.optionalInt64 == 8 + o.optionalInt32 == 41 && o.optionalInt64 == 8 } } @@ -43,50 +43,64 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { XCTAssertEqual("optional_int32: 41\n", a.textFormatString()) - assertTextFormatEncode("optional_int32: 1\n") {(o: inout MessageTestType) in o.optionalInt32 = 1 } - assertTextFormatEncode("optional_int32: 12\n") {(o: inout MessageTestType) in o.optionalInt32 = 12 } - assertTextFormatEncode("optional_int32: 123\n") {(o: inout MessageTestType) in o.optionalInt32 = 123 } - assertTextFormatEncode("optional_int32: 1234\n") {(o: inout MessageTestType) in o.optionalInt32 = 1234 } - assertTextFormatEncode("optional_int32: 12345\n") {(o: inout MessageTestType) in o.optionalInt32 = 12345 } - assertTextFormatEncode("optional_int32: 123456\n") {(o: inout MessageTestType) in o.optionalInt32 = 123456 } - assertTextFormatEncode("optional_int32: 1234567\n") {(o: inout MessageTestType) in o.optionalInt32 = 1234567 } - assertTextFormatEncode("optional_int32: 12345678\n") {(o: inout MessageTestType) in o.optionalInt32 = 12345678 } - assertTextFormatEncode("optional_int32: 123456789\n") {(o: inout MessageTestType) in o.optionalInt32 = 123456789 } - assertTextFormatEncode("optional_int32: 1234567890\n") {(o: inout MessageTestType) in o.optionalInt32 = 1234567890 } - - assertTextFormatEncode("optional_int32: 1\n") {(o: inout MessageTestType) in o.optionalInt32 = 1 } - assertTextFormatEncode("optional_int32: 10\n") {(o: inout MessageTestType) in o.optionalInt32 = 10 } - assertTextFormatEncode("optional_int32: 100\n") {(o: inout MessageTestType) in o.optionalInt32 = 100 } - assertTextFormatEncode("optional_int32: 1000\n") {(o: inout MessageTestType) in o.optionalInt32 = 1000 } - assertTextFormatEncode("optional_int32: 10000\n") {(o: inout MessageTestType) in o.optionalInt32 = 10000 } - assertTextFormatEncode("optional_int32: 100000\n") {(o: inout MessageTestType) in o.optionalInt32 = 100000 } - assertTextFormatEncode("optional_int32: 1000000\n") {(o: inout MessageTestType) in o.optionalInt32 = 1000000 } - assertTextFormatEncode("optional_int32: 10000000\n") {(o: inout MessageTestType) in o.optionalInt32 = 10000000 } - assertTextFormatEncode("optional_int32: 100000000\n") {(o: inout MessageTestType) in o.optionalInt32 = 100000000 } - assertTextFormatEncode("optional_int32: 1000000000\n") {(o: inout MessageTestType) in o.optionalInt32 = 1000000000 } - - - assertTextFormatEncode("optional_int32: 41\n") {(o: inout MessageTestType) in - o.optionalInt32 = 41 } - assertTextFormatEncode("optional_int32: 1\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_int32: 1\n") { (o: inout MessageTestType) in o.optionalInt32 = 1 } + assertTextFormatEncode("optional_int32: 12\n") { (o: inout MessageTestType) in o.optionalInt32 = 12 } + assertTextFormatEncode("optional_int32: 123\n") { (o: inout MessageTestType) in o.optionalInt32 = 123 } + assertTextFormatEncode("optional_int32: 1234\n") { (o: inout MessageTestType) in o.optionalInt32 = 1234 } + assertTextFormatEncode("optional_int32: 12345\n") { (o: inout MessageTestType) in o.optionalInt32 = 12345 } + assertTextFormatEncode("optional_int32: 123456\n") { (o: inout MessageTestType) in o.optionalInt32 = 123456 } + assertTextFormatEncode("optional_int32: 1234567\n") { (o: inout MessageTestType) in o.optionalInt32 = 1_234_567 + } + assertTextFormatEncode("optional_int32: 12345678\n") { (o: inout MessageTestType) in + o.optionalInt32 = 12_345_678 + } + assertTextFormatEncode("optional_int32: 123456789\n") { (o: inout MessageTestType) in + o.optionalInt32 = 123_456_789 + } + assertTextFormatEncode("optional_int32: 1234567890\n") { (o: inout MessageTestType) in + o.optionalInt32 = 1_234_567_890 + } + + assertTextFormatEncode("optional_int32: 1\n") { (o: inout MessageTestType) in o.optionalInt32 = 1 } + assertTextFormatEncode("optional_int32: 10\n") { (o: inout MessageTestType) in o.optionalInt32 = 10 } + assertTextFormatEncode("optional_int32: 100\n") { (o: inout MessageTestType) in o.optionalInt32 = 100 } + assertTextFormatEncode("optional_int32: 1000\n") { (o: inout MessageTestType) in o.optionalInt32 = 1000 } + assertTextFormatEncode("optional_int32: 10000\n") { (o: inout MessageTestType) in o.optionalInt32 = 10000 } + assertTextFormatEncode("optional_int32: 100000\n") { (o: inout MessageTestType) in o.optionalInt32 = 100000 } + assertTextFormatEncode("optional_int32: 1000000\n") { (o: inout MessageTestType) in o.optionalInt32 = 1_000_000 + } + assertTextFormatEncode("optional_int32: 10000000\n") { (o: inout MessageTestType) in + o.optionalInt32 = 10_000_000 + } + assertTextFormatEncode("optional_int32: 100000000\n") { (o: inout MessageTestType) in + o.optionalInt32 = 100_000_000 + } + assertTextFormatEncode("optional_int32: 1000000000\n") { (o: inout MessageTestType) in + o.optionalInt32 = 1_000_000_000 + } + + assertTextFormatEncode("optional_int32: 41\n") { (o: inout MessageTestType) in + o.optionalInt32 = 41 + } + assertTextFormatEncode("optional_int32: 1\n") { (o: inout MessageTestType) in o.optionalInt32 = 1 } - assertTextFormatEncode("optional_int32: -1\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_int32: -1\n") { (o: inout MessageTestType) in o.optionalInt32 = -1 } - assertTextFormatDecodeSucceeds("optional_int32:0x1234") {(o: MessageTestType) in - return o.optionalInt32 == 0x1234 + assertTextFormatDecodeSucceeds("optional_int32:0x1234") { (o: MessageTestType) in + o.optionalInt32 == 0x1234 } - assertTextFormatDecodeSucceeds("optional_int32:41") {(o: MessageTestType) in - return o.optionalInt32 == 41 + assertTextFormatDecodeSucceeds("optional_int32:41") { (o: MessageTestType) in + o.optionalInt32 == 41 } assertTextFormatDecodeSucceeds("optional_int32: 41#optional_int32: 42") { (o: MessageTestType) in - return o.optionalInt32 == 41 + o.optionalInt32 == 41 } assertTextFormatDecodeSucceeds("optional_int32: 41 optional_int32: 42") { (o: MessageTestType) in - return o.optionalInt32 == 42 + o.optionalInt32 == 42 } assertTextFormatDecodeFails("optional_int32: a\n") assertTextFormatDecodeFails("optional_int32: 999999999999999999999999999999999999\n") @@ -96,8 +110,8 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { assertTextFormatDecodeFails("optional_int32: \"hello\"\n") assertTextFormatDecodeFails("optional_int32: true\n") assertTextFormatDecodeFails("optional_int32: 0x80000000\n") - assertTextFormatDecodeSucceeds("optional_int32: -0x80000000\n") {(o: MessageTestType) in - return o.optionalInt32 == -0x80000000 + assertTextFormatDecodeSucceeds("optional_int32: -0x80000000\n") { (o: MessageTestType) in + o.optionalInt32 == -0x8000_0000 } assertTextFormatDecodeFails("optional_int32: -0x80000001\n") } @@ -108,31 +122,45 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { XCTAssertEqual("optional_int64: 2\n", a.textFormatString()) - assertTextFormatEncode("optional_int64: 1\n") {(o: inout MessageTestType) in o.optionalInt64 = 1 } - assertTextFormatEncode("optional_int64: 12\n") {(o: inout MessageTestType) in o.optionalInt64 = 12 } - assertTextFormatEncode("optional_int64: 123\n") {(o: inout MessageTestType) in o.optionalInt64 = 123 } - assertTextFormatEncode("optional_int64: 1234\n") {(o: inout MessageTestType) in o.optionalInt64 = 1234 } - assertTextFormatEncode("optional_int64: 12345\n") {(o: inout MessageTestType) in o.optionalInt64 = 12345 } - assertTextFormatEncode("optional_int64: 123456\n") {(o: inout MessageTestType) in o.optionalInt64 = 123456 } - assertTextFormatEncode("optional_int64: 1234567\n") {(o: inout MessageTestType) in o.optionalInt64 = 1234567 } - assertTextFormatEncode("optional_int64: 12345678\n") {(o: inout MessageTestType) in o.optionalInt64 = 12345678 } - assertTextFormatEncode("optional_int64: 123456789\n") {(o: inout MessageTestType) in o.optionalInt64 = 123456789 } - assertTextFormatEncode("optional_int64: 1234567890\n") {(o: inout MessageTestType) in o.optionalInt64 = 1234567890 } - - assertTextFormatEncode("optional_int64: 1\n") {(o: inout MessageTestType) in o.optionalInt64 = 1 } - assertTextFormatEncode("optional_int64: 10\n") {(o: inout MessageTestType) in o.optionalInt64 = 10 } - assertTextFormatEncode("optional_int64: 100\n") {(o: inout MessageTestType) in o.optionalInt64 = 100 } - assertTextFormatEncode("optional_int64: 1000\n") {(o: inout MessageTestType) in o.optionalInt64 = 1000 } - assertTextFormatEncode("optional_int64: 10000\n") {(o: inout MessageTestType) in o.optionalInt64 = 10000 } - assertTextFormatEncode("optional_int64: 100000\n") {(o: inout MessageTestType) in o.optionalInt64 = 100000 } - assertTextFormatEncode("optional_int64: 1000000\n") {(o: inout MessageTestType) in o.optionalInt64 = 1000000 } - assertTextFormatEncode("optional_int64: 10000000\n") {(o: inout MessageTestType) in o.optionalInt64 = 10000000 } - assertTextFormatEncode("optional_int64: 100000000\n") {(o: inout MessageTestType) in o.optionalInt64 = 100000000 } - assertTextFormatEncode("optional_int64: 1000000000\n") {(o: inout MessageTestType) in o.optionalInt64 = 1000000000 } - - assertTextFormatEncode("optional_int64: -2\n") {(o: inout MessageTestType) in o.optionalInt64 = -2 } - assertTextFormatDecodeSucceeds("optional_int64: 0x1234567812345678\n") {(o: MessageTestType) in - return o.optionalInt64 == 0x1234567812345678 + assertTextFormatEncode("optional_int64: 1\n") { (o: inout MessageTestType) in o.optionalInt64 = 1 } + assertTextFormatEncode("optional_int64: 12\n") { (o: inout MessageTestType) in o.optionalInt64 = 12 } + assertTextFormatEncode("optional_int64: 123\n") { (o: inout MessageTestType) in o.optionalInt64 = 123 } + assertTextFormatEncode("optional_int64: 1234\n") { (o: inout MessageTestType) in o.optionalInt64 = 1234 } + assertTextFormatEncode("optional_int64: 12345\n") { (o: inout MessageTestType) in o.optionalInt64 = 12345 } + assertTextFormatEncode("optional_int64: 123456\n") { (o: inout MessageTestType) in o.optionalInt64 = 123456 } + assertTextFormatEncode("optional_int64: 1234567\n") { (o: inout MessageTestType) in o.optionalInt64 = 1_234_567 + } + assertTextFormatEncode("optional_int64: 12345678\n") { (o: inout MessageTestType) in + o.optionalInt64 = 12_345_678 + } + assertTextFormatEncode("optional_int64: 123456789\n") { (o: inout MessageTestType) in + o.optionalInt64 = 123_456_789 + } + assertTextFormatEncode("optional_int64: 1234567890\n") { (o: inout MessageTestType) in + o.optionalInt64 = 1_234_567_890 + } + + assertTextFormatEncode("optional_int64: 1\n") { (o: inout MessageTestType) in o.optionalInt64 = 1 } + assertTextFormatEncode("optional_int64: 10\n") { (o: inout MessageTestType) in o.optionalInt64 = 10 } + assertTextFormatEncode("optional_int64: 100\n") { (o: inout MessageTestType) in o.optionalInt64 = 100 } + assertTextFormatEncode("optional_int64: 1000\n") { (o: inout MessageTestType) in o.optionalInt64 = 1000 } + assertTextFormatEncode("optional_int64: 10000\n") { (o: inout MessageTestType) in o.optionalInt64 = 10000 } + assertTextFormatEncode("optional_int64: 100000\n") { (o: inout MessageTestType) in o.optionalInt64 = 100000 } + assertTextFormatEncode("optional_int64: 1000000\n") { (o: inout MessageTestType) in o.optionalInt64 = 1_000_000 + } + assertTextFormatEncode("optional_int64: 10000000\n") { (o: inout MessageTestType) in + o.optionalInt64 = 10_000_000 + } + assertTextFormatEncode("optional_int64: 100000000\n") { (o: inout MessageTestType) in + o.optionalInt64 = 100_000_000 + } + assertTextFormatEncode("optional_int64: 1000000000\n") { (o: inout MessageTestType) in + o.optionalInt64 = 1_000_000_000 + } + + assertTextFormatEncode("optional_int64: -2\n") { (o: inout MessageTestType) in o.optionalInt64 = -2 } + assertTextFormatDecodeSucceeds("optional_int64: 0x1234567812345678\n") { (o: MessageTestType) in + o.optionalInt64 == 0x1234_5678_1234_5678 } assertTextFormatDecodeFails("optional_int64: a\n") @@ -146,16 +174,16 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { XCTAssertEqual("optional_uint32: 3\n", a.textFormatString()) - assertTextFormatEncode("optional_uint32: 3\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_uint32: 3\n") { (o: inout MessageTestType) in o.optionalUint32 = 3 } - assertTextFormatDecodeSucceeds("optional_uint32: 3u") { + assertTextFormatDecodeSucceeds("optional_uint32: 0x3") { (o: MessageTestType) in - return o.optionalUint32 == 3 + o.optionalUint32 == 3 } - assertTextFormatDecodeSucceeds("optional_uint32: 3u optional_int32: 1") { + assertTextFormatDecodeSucceeds("optional_uint32: 03 optional_int32: 1") { (o: MessageTestType) in - return o.optionalUint32 == 3 && o.optionalInt32 == 1 + o.optionalUint32 == 3 && o.optionalInt32 == 1 } assertTextFormatDecodeFails("optional_uint32: -3\n") assertTextFormatDecodeFails("optional_uint32: 3x\n") @@ -173,12 +201,12 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { XCTAssertEqual("optional_uint64: 4\n", a.textFormatString()) - assertTextFormatEncode("optional_uint64: 4\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_uint64: 4\n") { (o: inout MessageTestType) in o.optionalUint64 = 4 } - assertTextFormatDecodeSucceeds("optional_uint64: 0xf234567812345678\n") {(o: MessageTestType) in - return o.optionalUint64 == 0xf234567812345678 + assertTextFormatDecodeSucceeds("optional_uint64: 0xf234567812345678\n") { (o: MessageTestType) in + o.optionalUint64 == 0xf234_5678_1234_5678 } assertTextFormatDecodeFails("optional_uint64: a\n") assertTextFormatDecodeFails("optional_uint64: 999999999999999999999999999999999999\n") @@ -192,15 +220,15 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { XCTAssertEqual("optional_sint32: 5\n", a.textFormatString()) - assertTextFormatEncode("optional_sint32: 5\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_sint32: 5\n") { (o: inout MessageTestType) in o.optionalSint32 = 5 } - assertTextFormatEncode("optional_sint32: -5\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_sint32: -5\n") { (o: inout MessageTestType) in o.optionalSint32 = -5 } assertTextFormatDecodeSucceeds(" optional_sint32:-5 ") { (o: MessageTestType) in - return o.optionalSint32 == -5 + o.optionalSint32 == -5 } assertTextFormatDecodeFails("optional_sint32: a\n") @@ -212,7 +240,7 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { XCTAssertEqual("optional_sint64: 6\n", a.textFormatString()) - assertTextFormatEncode("optional_sint64: 6\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_sint64: 6\n") { (o: inout MessageTestType) in o.optionalSint64 = 6 } assertTextFormatDecodeFails("optional_sint64: a\n") @@ -224,7 +252,7 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { XCTAssertEqual("optional_fixed32: 7\n", a.textFormatString()) - assertTextFormatEncode("optional_fixed32: 7\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_fixed32: 7\n") { (o: inout MessageTestType) in o.optionalFixed32 = 7 } @@ -237,7 +265,7 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { XCTAssertEqual("optional_fixed64: 8\n", a.textFormatString()) - assertTextFormatEncode("optional_fixed64: 8\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_fixed64: 8\n") { (o: inout MessageTestType) in o.optionalFixed64 = 8 } @@ -250,7 +278,7 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { XCTAssertEqual("optional_sfixed32: 9\n", a.textFormatString()) - assertTextFormatEncode("optional_sfixed32: 9\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_sfixed32: 9\n") { (o: inout MessageTestType) in o.optionalSfixed32 = 9 } @@ -263,14 +291,18 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { XCTAssertEqual("optional_sfixed64: 10\n", a.textFormatString()) - assertTextFormatEncode("optional_sfixed64: 10\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_sfixed64: 10\n") { (o: inout MessageTestType) in o.optionalSfixed64 = 10 } assertTextFormatDecodeFails("optional_sfixed64: a\n") } - private func assertRoundTripText(file: XCTestFileArgType = #file, line: UInt = #line, configure: (inout MessageTestType) -> Void) { + private func assertRoundTripText( + file: XCTestFileArgType = #file, + line: UInt = #line, + configure: (inout MessageTestType) -> Void + ) { var original = MessageTestType() configure(&original) let text = original.textFormatString() @@ -288,101 +320,123 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { XCTAssertEqual("optional_float: 11.0\n", a.textFormatString()) - assertTextFormatEncode("optional_float: 11.0\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_float: 11.0\n") { (o: inout MessageTestType) in o.optionalFloat = 11 } assertTextFormatDecodeSucceeds("optional_float: 1.0f") { (o: MessageTestType) in - return o.optionalFloat == 1.0 + o.optionalFloat == 1.0 } assertTextFormatDecodeSucceeds("optional_float: 1.5e3") { (o: MessageTestType) in - return o.optionalFloat == 1.5e3 + o.optionalFloat == 1.5e3 } assertTextFormatDecodeSucceeds("optional_float: -4.75") { (o: MessageTestType) in - return o.optionalFloat == -4.75 + o.optionalFloat == -4.75 } assertTextFormatDecodeSucceeds("optional_float: 1.0f optional_int32: 1") { (o: MessageTestType) in - return o.optionalFloat == 1.0 && o.optionalInt32 == 1 + o.optionalFloat == 1.0 && o.optionalInt32 == 1 } assertTextFormatDecodeSucceeds("optional_float: 1.0 optional_int32: 1") { (o: MessageTestType) in - return o.optionalFloat == 1.0 && o.optionalInt32 == 1 + o.optionalFloat == 1.0 && o.optionalInt32 == 1 } assertTextFormatDecodeSucceeds("optional_float: 1.0f\n") { (o: MessageTestType) in - return o.optionalFloat == 1.0 + o.optionalFloat == 1.0 + } + assertTextFormatDecodeSucceeds("optional_float: 1.0F\n") { + (o: MessageTestType) in + o.optionalFloat == 1.0 } assertTextFormatDecodeSucceeds("optional_float: 11\n") { (o: MessageTestType) in - return o.optionalFloat == 11.0 + o.optionalFloat == 11.0 } assertTextFormatDecodeSucceeds("optional_float: 11f\n") { (o: MessageTestType) in - return o.optionalFloat == 11.0 + o.optionalFloat == 11.0 + } + assertTextFormatDecodeSucceeds("optional_float: 11F\n") { + (o: MessageTestType) in + o.optionalFloat == 11.0 } assertTextFormatDecodeSucceeds("optional_float: 0\n") { (o: MessageTestType) in - return o.optionalFloat == 0.0 + o.optionalFloat == 0.0 } assertTextFormatDecodeSucceeds("optional_float: 0f\n") { (o: MessageTestType) in - return o.optionalFloat == 0.0 + o.optionalFloat == 0.0 + } + assertTextFormatDecodeSucceeds("optional_float: 0F\n") { + (o: MessageTestType) in + o.optionalFloat == 0.0 + } + assertTextFormatEncode("optional_float: inf\n") { (o: inout MessageTestType) in o.optionalFloat = Float.infinity + } + assertTextFormatEncode("optional_float: -inf\n") { (o: inout MessageTestType) in + o.optionalFloat = -Float.infinity } - assertTextFormatEncode("optional_float: inf\n") {(o: inout MessageTestType) in o.optionalFloat = Float.infinity} - assertTextFormatEncode("optional_float: -inf\n") {(o: inout MessageTestType) in o.optionalFloat = -Float.infinity} // protobuf conformance requires too-large floats to round to Infinity assertTextFormatDecodeSucceeds("optional_float: 3.4028235e+39\n") { (o: MessageTestType) in - return o.optionalFloat == Float.infinity + o.optionalFloat == Float.infinity } assertTextFormatDecodeSucceeds("optional_float: -3.4028235e+39\n") { (o: MessageTestType) in - return o.optionalFloat == -Float.infinity + o.optionalFloat == -Float.infinity + } + // Too-large of values round to infinity + assertTextFormatDecodeSucceeds("optional_float: 1e50\n") { (o: MessageTestType) in + o.optionalFloat == Float.infinity + } + assertTextFormatDecodeSucceeds("optional_float: -1e50\n") { (o: MessageTestType) in + o.optionalFloat == -Float.infinity } // Too-small values round to zero (not currently checked by conformance) assertTextFormatDecodeSucceeds("optional_float: 1e-50\n") { (o: MessageTestType) in - return o.optionalFloat == 0.0 && o.optionalFloat.sign == .plus + o.optionalFloat == 0.0 && o.optionalFloat.sign == .plus } assertTextFormatDecodeSucceeds("optional_float: -1e-50\n") { (o: MessageTestType) in - return o.optionalFloat == 0.0 && o.optionalFloat.sign == .minus + o.optionalFloat == 0.0 && o.optionalFloat.sign == .minus } // protobuf conformance requires subnormals to be handled assertTextFormatDecodeSucceeds("optional_float: 1.17549e-39\n") { (o: MessageTestType) in - return o.optionalFloat == Float(1.17549e-39) + o.optionalFloat == Float(1.17549e-39) } assertTextFormatDecodeSucceeds("optional_float: -1.17549e-39\n") { (o: MessageTestType) in - return o.optionalFloat == Float(-1.17549e-39) + o.optionalFloat == Float(-1.17549e-39) } // protobuf conformance requires integer forms larger than Int64 to be accepted assertTextFormatDecodeSucceeds("optional_float: 18446744073709551616\n") { (o: MessageTestType) in - return o.optionalFloat == 1.84467441e+19 + o.optionalFloat == 1.84467441e+19 } assertTextFormatDecodeSucceeds("optional_float: -18446744073709551616\n") { (o: MessageTestType) in - return o.optionalFloat == -1.84467441e+19 + o.optionalFloat == -1.84467441e+19 } - let b = Proto3Unittest_TestAllTypes.with {$0.optionalFloat = Float.nan} + let b = SwiftProtoTesting_Proto3_TestAllTypes.with { $0.optionalFloat = Float.nan } XCTAssertEqual("optional_float: nan\n", b.textFormatString()) do { - let nan1 = try Proto3Unittest_TestAllTypes(textFormatString: "optional_float: nan\n") + let nan1 = try SwiftProtoTesting_Proto3_TestAllTypes(textFormatString: "optional_float: nan\n") XCTAssert(nan1.optionalFloat.isNaN) } catch let e { XCTFail("Decoding nan failed: \(e)") } do { - let nan2 = try Proto3Unittest_TestAllTypes(textFormatString: "optional_float: NaN\n") + let nan2 = try SwiftProtoTesting_Proto3_TestAllTypes(textFormatString: "optional_float: NaN\n") XCTAssert(nan2.optionalFloat.isNaN) } catch let e { XCTFail("Decoding nan failed: \(e)") @@ -390,17 +444,17 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { assertTextFormatDecodeFails("optional_float: nanoptional_int32: 1\n") - assertTextFormatDecodeSucceeds("optional_float: INFINITY\n") {(o: MessageTestType) in - return o.optionalFloat == Float.infinity + assertTextFormatDecodeSucceeds("optional_float: INFINITY\n") { (o: MessageTestType) in + o.optionalFloat == Float.infinity } - assertTextFormatDecodeSucceeds("optional_float: Infinity\n") {(o: MessageTestType) in - return o.optionalFloat == Float.infinity + assertTextFormatDecodeSucceeds("optional_float: Infinity\n") { (o: MessageTestType) in + o.optionalFloat == Float.infinity } - assertTextFormatDecodeSucceeds("optional_float: -INFINITY\n") {(o: MessageTestType) in - return o.optionalFloat == -Float.infinity + assertTextFormatDecodeSucceeds("optional_float: -INFINITY\n") { (o: MessageTestType) in + o.optionalFloat == -Float.infinity } - assertTextFormatDecodeSucceeds("optional_float: -Infinity\n") {(o: MessageTestType) in - return o.optionalFloat == -Float.infinity + assertTextFormatDecodeSucceeds("optional_float: -Infinity\n") { (o: MessageTestType) in + o.optionalFloat == -Float.infinity } assertTextFormatDecodeFails("optional_float: INFINITY_AND_BEYOND\n") assertTextFormatDecodeFails("optional_float: infinityoptional_int32: 1\n") @@ -411,28 +465,28 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { assertTextFormatDecodeFails("optional_float: 012\n") // A wide range of numbers should exactly round-trip - assertRoundTripText {$0.optionalFloat = 0.1} - assertRoundTripText {$0.optionalFloat = 0.01} - assertRoundTripText {$0.optionalFloat = 0.001} - assertRoundTripText {$0.optionalFloat = 0.0001} - assertRoundTripText {$0.optionalFloat = 0.00001} - assertRoundTripText {$0.optionalFloat = 0.000001} - assertRoundTripText {$0.optionalFloat = 1e-10} - assertRoundTripText {$0.optionalFloat = 1e-20} - assertRoundTripText {$0.optionalFloat = 1e-30} - assertRoundTripText {$0.optionalFloat = Float(1e-40)} - assertRoundTripText {$0.optionalFloat = Float(1e-50)} - assertRoundTripText {$0.optionalFloat = Float(1e-60)} - assertRoundTripText {$0.optionalFloat = Float(1e-100)} - assertRoundTripText {$0.optionalFloat = Float(1e-200)} - assertRoundTripText {$0.optionalFloat = Float.pi} - assertRoundTripText {$0.optionalFloat = 123456.789123456789123} - assertRoundTripText {$0.optionalFloat = 1999.9999999999} - assertRoundTripText {$0.optionalFloat = 1999.9} - assertRoundTripText {$0.optionalFloat = 1999.99} - assertRoundTripText {$0.optionalFloat = 1999.999} - assertRoundTripText {$0.optionalFloat = 3.402823567e+38} - assertRoundTripText {$0.optionalFloat = 1.1754944e-38} + assertRoundTripText { $0.optionalFloat = 0.1 } + assertRoundTripText { $0.optionalFloat = 0.01 } + assertRoundTripText { $0.optionalFloat = 0.001 } + assertRoundTripText { $0.optionalFloat = 0.0001 } + assertRoundTripText { $0.optionalFloat = 0.00001 } + assertRoundTripText { $0.optionalFloat = 0.000001 } + assertRoundTripText { $0.optionalFloat = 1e-10 } + assertRoundTripText { $0.optionalFloat = 1e-20 } + assertRoundTripText { $0.optionalFloat = 1e-30 } + assertRoundTripText { $0.optionalFloat = Float(1e-40) } + assertRoundTripText { $0.optionalFloat = Float(1e-50) } + assertRoundTripText { $0.optionalFloat = Float(1e-60) } + assertRoundTripText { $0.optionalFloat = Float(1e-100) } + assertRoundTripText { $0.optionalFloat = Float(1e-200) } + assertRoundTripText { $0.optionalFloat = Float.pi } + assertRoundTripText { $0.optionalFloat = 123456.789123456789123 } + assertRoundTripText { $0.optionalFloat = 1999.9999999999 } + assertRoundTripText { $0.optionalFloat = 1999.9 } + assertRoundTripText { $0.optionalFloat = 1999.99 } + assertRoundTripText { $0.optionalFloat = 1999.999 } + assertRoundTripText { $0.optionalFloat = 3.402823567e+38 } + assertRoundTripText { $0.optionalFloat = 1.1754944e-38 } } func testEncoding_optionalDouble() { @@ -441,35 +495,73 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { XCTAssertEqual("optional_double: 12.0\n", a.textFormatString()) - assertTextFormatEncode("optional_double: 12.0\n") {(o: inout MessageTestType) in o.optionalDouble = 12 } - assertTextFormatEncode("optional_double: inf\n") {(o: inout MessageTestType) in o.optionalDouble = Double.infinity} - assertTextFormatEncode("optional_double: -inf\n") {(o: inout MessageTestType) in o.optionalDouble = -Double.infinity} - let b = Proto3Unittest_TestAllTypes.with {$0.optionalDouble = Double.nan} + assertTextFormatEncode("optional_double: 12.0\n") { (o: inout MessageTestType) in o.optionalDouble = 12 } + assertTextFormatEncode("optional_double: inf\n") { (o: inout MessageTestType) in + o.optionalDouble = Double.infinity + } + assertTextFormatEncode("optional_double: -inf\n") { (o: inout MessageTestType) in + o.optionalDouble = -Double.infinity + } + let b = SwiftProtoTesting_Proto3_TestAllTypes.with { $0.optionalDouble = Double.nan } XCTAssertEqual("optional_double: nan\n", b.textFormatString()) - assertTextFormatDecodeSucceeds("optional_double: 1.0\n") {(o: MessageTestType) in - return o.optionalDouble == 1.0 + assertTextFormatDecodeSucceeds("optional_double: 1.0\n") { (o: MessageTestType) in + o.optionalDouble == 1.0 + } + assertTextFormatDecodeSucceeds("optional_double: 1.0f\n") { (o: MessageTestType) in + o.optionalDouble == 1.0 + } + assertTextFormatDecodeSucceeds("optional_double: 1.0F\n") { (o: MessageTestType) in + o.optionalDouble == 1.0 + } + assertTextFormatDecodeSucceeds("optional_double: 1\n") { (o: MessageTestType) in + o.optionalDouble == 1.0 + } + assertTextFormatDecodeSucceeds("optional_double: 1f\n") { (o: MessageTestType) in + o.optionalDouble == 1.0 + } + assertTextFormatDecodeSucceeds("optional_double: 1F\n") { (o: MessageTestType) in + o.optionalDouble == 1.0 + } + assertTextFormatDecodeSucceeds("optional_double: 0\n") { (o: MessageTestType) in + o.optionalDouble == 0.0 } - assertTextFormatDecodeSucceeds("optional_double: 1\n") {(o: MessageTestType) in - return o.optionalDouble == 1.0 + assertTextFormatDecodeSucceeds("optional_double: 0f\n") { (o: MessageTestType) in + o.optionalDouble == 0.0 } - assertTextFormatDecodeSucceeds("optional_double: 0\n") {(o: MessageTestType) in - return o.optionalDouble == 0.0 + assertTextFormatDecodeSucceeds("optional_double: 0F\n") { (o: MessageTestType) in + o.optionalDouble == 0.0 } - assertTextFormatDecodeSucceeds("12: 1.0\n") {(o: MessageTestType) in - return o.optionalDouble == 1.0 + assertTextFormatDecodeSucceeds("12: 1.0\n") { (o: MessageTestType) in + o.optionalDouble == 1.0 } - assertTextFormatDecodeSucceeds("optional_double: INFINITY\n") {(o: MessageTestType) in - return o.optionalDouble == Double.infinity + // Too-large of values round to infinity + assertTextFormatDecodeSucceeds("optional_double: 1e9999\n") { (o: MessageTestType) in + o.optionalDouble == Double.infinity } - assertTextFormatDecodeSucceeds("optional_double: Infinity\n") {(o: MessageTestType) in - return o.optionalDouble == Double.infinity + assertTextFormatDecodeSucceeds("optional_double: -1e9999\n") { (o: MessageTestType) in + o.optionalDouble == -Double.infinity } - assertTextFormatDecodeSucceeds("optional_double: -INFINITY\n") {(o: MessageTestType) in - return o.optionalDouble == -Double.infinity + // Too-small values round to zero (not currently checked by conformance) + assertTextFormatDecodeSucceeds("optional_double: 1e-9999\n") { + (o: MessageTestType) in + o.optionalDouble == 0.0 && o.optionalDouble.sign == .plus + } + assertTextFormatDecodeSucceeds("optional_double: -1e-9999\n") { + (o: MessageTestType) in + o.optionalDouble == 0.0 && o.optionalDouble.sign == .minus } - assertTextFormatDecodeSucceeds("optional_double: -Infinity\n") {(o: MessageTestType) in - return o.optionalDouble == -Double.infinity + assertTextFormatDecodeSucceeds("optional_double: INFINITY\n") { (o: MessageTestType) in + o.optionalDouble == Double.infinity + } + assertTextFormatDecodeSucceeds("optional_double: Infinity\n") { (o: MessageTestType) in + o.optionalDouble == Double.infinity + } + assertTextFormatDecodeSucceeds("optional_double: -INFINITY\n") { (o: MessageTestType) in + o.optionalDouble == -Double.infinity + } + assertTextFormatDecodeSucceeds("optional_double: -Infinity\n") { (o: MessageTestType) in + o.optionalDouble == -Double.infinity } assertTextFormatDecodeFails("optional_double: INFINITY_AND_BEYOND\n") assertTextFormatDecodeFails("optional_double: INFIN\n") @@ -479,24 +571,24 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { assertTextFormatDecodeFails("optional_double: 0123\n") // A wide range of numbers should exactly round-trip - assertRoundTripText {$0.optionalDouble = 0.1} - assertRoundTripText {$0.optionalDouble = 0.01} - assertRoundTripText {$0.optionalDouble = 0.001} - assertRoundTripText {$0.optionalDouble = 0.0001} - assertRoundTripText {$0.optionalDouble = 0.00001} - assertRoundTripText {$0.optionalDouble = 0.000001} - assertRoundTripText {$0.optionalDouble = 1e-10} - assertRoundTripText {$0.optionalDouble = 1e-20} - assertRoundTripText {$0.optionalDouble = 1e-30} - assertRoundTripText {$0.optionalDouble = 1e-40} - assertRoundTripText {$0.optionalDouble = 1e-50} - assertRoundTripText {$0.optionalDouble = 1e-60} - assertRoundTripText {$0.optionalDouble = 1e-100} - assertRoundTripText {$0.optionalDouble = 1e-200} - assertRoundTripText {$0.optionalDouble = Double.pi} - assertRoundTripText {$0.optionalDouble = 123456.789123456789123} - assertRoundTripText {$0.optionalDouble = 1.7976931348623157e+308} - assertRoundTripText {$0.optionalDouble = 2.22507385850720138309e-308} + assertRoundTripText { $0.optionalDouble = 0.1 } + assertRoundTripText { $0.optionalDouble = 0.01 } + assertRoundTripText { $0.optionalDouble = 0.001 } + assertRoundTripText { $0.optionalDouble = 0.0001 } + assertRoundTripText { $0.optionalDouble = 0.00001 } + assertRoundTripText { $0.optionalDouble = 0.000001 } + assertRoundTripText { $0.optionalDouble = 1e-10 } + assertRoundTripText { $0.optionalDouble = 1e-20 } + assertRoundTripText { $0.optionalDouble = 1e-30 } + assertRoundTripText { $0.optionalDouble = 1e-40 } + assertRoundTripText { $0.optionalDouble = 1e-50 } + assertRoundTripText { $0.optionalDouble = 1e-60 } + assertRoundTripText { $0.optionalDouble = 1e-100 } + assertRoundTripText { $0.optionalDouble = 1e-200 } + assertRoundTripText { $0.optionalDouble = Double.pi } + assertRoundTripText { $0.optionalDouble = 123456.789123456789123 } + assertRoundTripText { $0.optionalDouble = 1.7976931348623157e+308 } + assertRoundTripText { $0.optionalDouble = 2.22507385850720138309e-308 } } func testEncoding_optionalBool() { @@ -507,44 +599,44 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { a.optionalBool = false XCTAssertEqual("", a.textFormatString()) - assertTextFormatEncode("optional_bool: true\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_bool: true\n") { (o: inout MessageTestType) in o.optionalBool = true } - assertTextFormatDecodeSucceeds("optional_bool:true") {(o: MessageTestType) in - return o.optionalBool == true + assertTextFormatDecodeSucceeds("optional_bool:true") { (o: MessageTestType) in + o.optionalBool == true } - assertTextFormatDecodeSucceeds("optional_bool:true ") {(o: MessageTestType) in - return o.optionalBool == true + assertTextFormatDecodeSucceeds("optional_bool:true ") { (o: MessageTestType) in + o.optionalBool == true } - assertTextFormatDecodeSucceeds("optional_bool:true\n ") {(o: MessageTestType) in - return o.optionalBool == true + assertTextFormatDecodeSucceeds("optional_bool:true\n ") { (o: MessageTestType) in + o.optionalBool == true } - assertTextFormatDecodeSucceeds("optional_bool:True\n ") {(o: MessageTestType) in - return o.optionalBool == true + assertTextFormatDecodeSucceeds("optional_bool:True\n ") { (o: MessageTestType) in + o.optionalBool == true } - assertTextFormatDecodeSucceeds("optional_bool:t\n ") {(o: MessageTestType) in - return o.optionalBool == true + assertTextFormatDecodeSucceeds("optional_bool:t\n ") { (o: MessageTestType) in + o.optionalBool == true } - assertTextFormatDecodeSucceeds("optional_bool:1\n ") {(o: MessageTestType) in - return o.optionalBool == true + assertTextFormatDecodeSucceeds("optional_bool:1\n ") { (o: MessageTestType) in + o.optionalBool == true } - assertTextFormatDecodeSucceeds("optional_bool:false\n ") {(o: MessageTestType) in - return o.optionalBool == false + assertTextFormatDecodeSucceeds("optional_bool:false\n ") { (o: MessageTestType) in + o.optionalBool == false } - assertTextFormatDecodeSucceeds("optional_bool:False\n ") {(o: MessageTestType) in - return o.optionalBool == false + assertTextFormatDecodeSucceeds("optional_bool:False\n ") { (o: MessageTestType) in + o.optionalBool == false } - assertTextFormatDecodeSucceeds("optional_bool:f\n ") {(o: MessageTestType) in - return o.optionalBool == false + assertTextFormatDecodeSucceeds("optional_bool:f\n ") { (o: MessageTestType) in + o.optionalBool == false } - assertTextFormatDecodeSucceeds("optional_bool:0\n ") {(o: MessageTestType) in - return o.optionalBool == false + assertTextFormatDecodeSucceeds("optional_bool:0\n ") { (o: MessageTestType) in + o.optionalBool == false } - assertTextFormatDecodeSucceeds("13:0\n ") {(o: MessageTestType) in - return o.optionalBool == false + assertTextFormatDecodeSucceeds("13:0\n ") { (o: MessageTestType) in + o.optionalBool == false } - assertTextFormatDecodeSucceeds("13:1\n ") {(o: MessageTestType) in - return o.optionalBool == true + assertTextFormatDecodeSucceeds("13:1\n ") { (o: MessageTestType) in + o.optionalBool == true } assertTextFormatDecodeFails("optional_bool: 10\n") @@ -594,58 +686,57 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { o.optionalString = "\u{f8}\u{f9}\u{fa}\u{fb}\u{fc}\u{fd}\u{fe}\u{ff}" } - // Adjacent quoted strings concatenate, see // google/protobuf/text_format_unittest.cc#L597 assertTextFormatDecodeSucceeds("optional_string: \"abc\"\"def\"") { (o: MessageTestType) in - return o.optionalString == "abcdef" + o.optionalString == "abcdef" } assertTextFormatDecodeSucceeds("optional_string: \"abc\" \"def\"") { (o: MessageTestType) in - return o.optionalString == "abcdef" + o.optionalString == "abcdef" } assertTextFormatDecodeSucceeds("optional_string: \"abc\" \"def\"") { (o: MessageTestType) in - return o.optionalString == "abcdef" + o.optionalString == "abcdef" } // Adjacent quoted strings concatenate across multiple lines assertTextFormatDecodeSucceeds("optional_string: \"abc\"\n\"def\"") { (o: MessageTestType) in - return o.optionalString == "abcdef" + o.optionalString == "abcdef" } assertTextFormatDecodeSucceeds("optional_string: \"abc\"\n \t \"def\"\n\"ghi\"\n") { (o: MessageTestType) in - return o.optionalString == "abcdefghi" + o.optionalString == "abcdefghi" } assertTextFormatDecodeSucceeds("optional_string: \"abc\"\n\'def\'\n\"ghi\"\n") { (o: MessageTestType) in - return o.optionalString == "abcdefghi" + o.optionalString == "abcdefghi" } assertTextFormatDecodeSucceeds("optional_string: \"abcdefghi\"") { (o: MessageTestType) in - return o.optionalString == "abcdefghi" + o.optionalString == "abcdefghi" } // Note: Values 0-127 are same whether viewed as Unicode code // points or UTF-8 bytes. assertTextFormatDecodeSucceeds("optional_string: \"\\a\\b\\f\\n\\r\\t\\v\\\"\\'\\\\\\?\"") { (o: MessageTestType) in - return o.optionalString == "\u{07}\u{08}\u{0C}\u{0A}\u{0D}\u{09}\u{0B}\"'\\?" + o.optionalString == "\u{07}\u{08}\u{0C}\u{0A}\u{0D}\u{09}\u{0B}\"'\\?" } assertTextFormatDecodeFails("optional_string: \"\\z\"") assertTextFormatDecodeSucceeds("optional_string: \"\\001\\01\\1\\0011\\010\\289\"") { (o: MessageTestType) in - return o.optionalString == "\u{01}\u{01}\u{01}\u{01}\u{31}\u{08}\u{02}89" + o.optionalString == "\u{01}\u{01}\u{01}\u{01}\u{31}\u{08}\u{02}89" } assertTextFormatDecodeSucceeds("optional_string: \"\\x1\\x12\\x123\\x1234\"") { (o: MessageTestType) in - return o.optionalString == "\u{01}\u{12}\u{12}3\u{12}34" + o.optionalString == "\u{01}\u{12}\u{12}3\u{12}34" } assertTextFormatDecodeSucceeds("optional_string: \"\\x0f\\x3g\"") { (o: MessageTestType) in - return o.optionalString == "\u{0f}\u{03}g" + o.optionalString == "\u{0f}\u{03}g" } - assertTextFormatEncode("optional_string: \"abc\"\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_string: \"abc\"\n") { (o: inout MessageTestType) in o.optionalString = "abc" } assertTextFormatDecodeFails("optional_string:hello") @@ -655,10 +746,6 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalString_controlCharacters() throws { - // This is known to fail on Swift Linux 4.1 and earlier, - // so skip it there. - // See https://bugs.swift.org/browse/SR-4218 for details. -#if !os(Linux) || swift(>=4.2) assertTextFormatEncode("optional_string: \"\\001\\002\\003\\004\\005\\006\\007\"\n") { (o: inout MessageTestType) in o.optionalString = "\u{01}\u{02}\u{03}\u{04}\u{05}\u{06}\u{07}" @@ -675,59 +762,59 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { (o: inout MessageTestType) in o.optionalString = "\u{18}\u{19}\u{1a}\u{1b}\u{1c}\u{1d}\u{1e}\u{1f}" } -#endif } func testEncoding_optionalString_UTF8() throws { // We encode to/from a string, not a sequence of bytes, so valid // Unicode characters just get preserved on both encode and decode: - assertTextFormatEncode("optional_string: \"☞\"\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_string: \"☞\"\n") { (o: inout MessageTestType) in o.optionalString = "☞" } // Other encoders write each byte of a UTF-8 sequence, maybe in hex: - assertTextFormatDecodeSucceeds("optional_string: \"\\xE2\\x98\\x9E\"") {(o: MessageTestType) in - return o.optionalString == "☞" + assertTextFormatDecodeSucceeds("optional_string: \"\\xE2\\x98\\x9E\"") { (o: MessageTestType) in + o.optionalString == "☞" } // Or maybe in octal: - assertTextFormatDecodeSucceeds("optional_string: \"\\342\\230\\236\"") {(o: MessageTestType) in - return o.optionalString == "☞" + assertTextFormatDecodeSucceeds("optional_string: \"\\342\\230\\236\"") { (o: MessageTestType) in + o.optionalString == "☞" } // Each string piece is decoded separately, broken UTF-8 is an error assertTextFormatDecodeFails("optional_string: \"\\342\\230\" \"\\236\"") } func testEncoding_optionalBytes() throws { - let o = Proto3Unittest_TestAllTypes.with { $0.optionalBytes = Data() } + let o = SwiftProtoTesting_Proto3_TestAllTypes.with { $0.optionalBytes = Data() } XCTAssertEqual("", o.textFormatString()) - assertTextFormatEncode("optional_bytes: \"AB\"\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_bytes: \"AB\"\n") { (o: inout MessageTestType) in o.optionalBytes = Data([65, 66]) } - assertTextFormatEncode("optional_bytes: \"\\000\\001AB\\177\\200\\377\"\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_bytes: \"\\000\\001AB\\177\\200\\377\"\n") { (o: inout MessageTestType) in o.optionalBytes = Data([0, 1, 65, 66, 127, 128, 255]) } - assertTextFormatEncode("optional_bytes: \"\\b\\t\\n\\v\\f\\r\\\"'?\\\\\"\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_bytes: \"\\b\\t\\n\\v\\f\\r\\\"'?\\\\\"\n") { (o: inout MessageTestType) in o.optionalBytes = Data([8, 9, 10, 11, 12, 13, 34, 39, 63, 92]) } - assertTextFormatDecodeSucceeds("optional_bytes: \"A\" \"B\"\n") {(o: MessageTestType) in - return o.optionalBytes == Data([65, 66]) + assertTextFormatDecodeSucceeds("optional_bytes: \"A\" \"B\"\n") { (o: MessageTestType) in + o.optionalBytes == Data([65, 66]) } - assertTextFormatDecodeSucceeds("optional_bytes: \"\\0\\1AB\\178\\189\\x61\\xdq\\x123456789\"\n") {(o: MessageTestType) in - return o.optionalBytes == Data([0, 1, 65, 66, 15, 56, 1, 56, 57, 97, 13, 113, 18, 51, 52, 53, 54, 55, 56, 57]) + assertTextFormatDecodeSucceeds("optional_bytes: \"\\0\\1AB\\178\\189\\x61\\xdq\\x123456789\"\n") { + (o: MessageTestType) in + o.optionalBytes == Data([0, 1, 65, 66, 15, 56, 1, 56, 57, 97, 13, 113, 18, 51, 52, 53, 54, 55, 56, 57]) } // "\1" followed by "2", not "\12" - assertTextFormatDecodeSucceeds("optional_bytes: \"\\1\" \"2\"") {(o: MessageTestType) in - return o.optionalBytes == Data([1, 50]) // Not [10] + assertTextFormatDecodeSucceeds("optional_bytes: \"\\1\" \"2\"") { (o: MessageTestType) in + o.optionalBytes == Data([1, 50]) // Not [10]// Not [10] } // "\x6" followed by "2", not "\x62" - assertTextFormatDecodeSucceeds("optional_bytes: \"\\x6\" \"2\"") {(o: MessageTestType) in - return o.optionalBytes == Data([6, 50]) // Not [98] + assertTextFormatDecodeSucceeds("optional_bytes: \"\\x6\" \"2\"") { (o: MessageTestType) in + o.optionalBytes == Data([6, 50]) // Not [98]// Not [98] } - assertTextFormatDecodeSucceeds("optional_bytes: \"\"\n") {(o: MessageTestType) in - return o.optionalBytes == Data() + assertTextFormatDecodeSucceeds("optional_bytes: \"\"\n") { (o: MessageTestType) in + o.optionalBytes == Data() } - assertTextFormatDecodeSucceeds("optional_bytes: \"\\b\\t\\n\\v\\f\\r\\\"\\'\\?'\"\n") {(o: MessageTestType) in - return o.optionalBytes == Data([8, 9, 10, 11, 12, 13, 34, 39, 63, 39]) + assertTextFormatDecodeSucceeds("optional_bytes: \"\\b\\t\\n\\v\\f\\r\\\"\\'\\?'\"\n") { (o: MessageTestType) in + o.optionalBytes == Data([8, 9, 10, 11, 12, 13, 34, 39, 63, 39]) } assertTextFormatDecodeFails("optional_bytes: 10\n") @@ -736,7 +823,7 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { assertTextFormatDecodeFails("optional_bytes: \"\\x&\"\n") assertTextFormatDecodeFails("optional_bytes: \"\\xg\"\n") assertTextFormatDecodeFails("optional_bytes: \"\\q\"\n") - assertTextFormatDecodeFails("optional_bytes: \"\\777\"\n") // Out-of-range octal + assertTextFormatDecodeFails("optional_bytes: \"\\777\"\n") // Out-of-range octal assertTextFormatDecodeFails("optional_bytes: \"") assertTextFormatDecodeFails("optional_bytes: \"abcde") assertTextFormatDecodeFails("optional_bytes: \"\\") @@ -752,9 +839,9 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { func testEncoding_optionalBytes_roundtrip() throws { for i in UInt8(0)...UInt8(255) { let d = Data([i]) - let message = Proto3Unittest_TestAllTypes.with { $0.optionalBytes = d } + let message = SwiftProtoTesting_Proto3_TestAllTypes.with { $0.optionalBytes = d } let text = message.textFormatString() - let decoded = try Proto3Unittest_TestAllTypes(textFormatString: text) + let decoded = try SwiftProtoTesting_Proto3_TestAllTypes(textFormatString: text) XCTAssertEqual(decoded, message) XCTAssertEqual(message.optionalBytes[0], i) } @@ -769,27 +856,27 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { XCTAssertEqual("optional_nested_message {\n bb: 7\n}\n", a.textFormatString()) - assertTextFormatEncode("optional_nested_message {\n bb: 7\n}\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_nested_message {\n bb: 7\n}\n") { (o: inout MessageTestType) in o.optionalNestedMessage = nested } // Google permits reading a message field with or without the separating ':' - assertTextFormatDecodeSucceeds("optional_nested_message: {bb:7}") {(o: MessageTestType) in - return o.optionalNestedMessage.bb == 7 + assertTextFormatDecodeSucceeds("optional_nested_message: {bb:7}") { (o: MessageTestType) in + o.optionalNestedMessage.bb == 7 } // Messages can be wrapped in {...} or <...> - assertTextFormatDecodeSucceeds("optional_nested_message ") {(o: MessageTestType) in - return o.optionalNestedMessage.bb == 7 + assertTextFormatDecodeSucceeds("optional_nested_message ") { (o: MessageTestType) in + o.optionalNestedMessage.bb == 7 } // Google permits reading a message field with or without the separating ':' - assertTextFormatDecodeSucceeds("optional_nested_message: ") {(o: MessageTestType) in - return o.optionalNestedMessage.bb == 7 + assertTextFormatDecodeSucceeds("optional_nested_message: ") { (o: MessageTestType) in + o.optionalNestedMessage.bb == 7 } assertTextFormatDecodeFails("optional_nested_message: a\n") } func testEncoding_optionalForeignMessage() { - var foreign = Proto3Unittest_ForeignMessage() + var foreign = SwiftProtoTesting_Proto3_ForeignMessage() foreign.c = 88 var a = MessageTestType() @@ -797,10 +884,12 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { XCTAssertEqual("optional_foreign_message {\n c: 88\n}\n", a.textFormatString()) - assertTextFormatEncode("optional_foreign_message {\n c: 88\n}\n") {(o: inout MessageTestType) in o.optionalForeignMessage = foreign } + assertTextFormatEncode("optional_foreign_message {\n c: 88\n}\n") { (o: inout MessageTestType) in + o.optionalForeignMessage = foreign + } do { - let message = try MessageTestType(textFormatString:"optional_foreign_message: {\n c: 88\n}\n") + let message = try MessageTestType(textFormatString: "optional_foreign_message: {\n c: 88\n}\n") XCTAssertEqual(message.optionalForeignMessage.c, 88) } catch { XCTFail("Presented error: \(error)") @@ -810,7 +899,7 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { } func testEncoding_optionalImportMessage() { - var importMessage = ProtobufUnittestImport_ImportMessage() + var importMessage = SwiftProtoTesting_Import_ImportMessage() importMessage.d = -9 var a = MessageTestType() @@ -818,10 +907,12 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { XCTAssertEqual("optional_import_message {\n d: -9\n}\n", a.textFormatString()) - assertTextFormatEncode("optional_import_message {\n d: -9\n}\n") {(o: inout MessageTestType) in o.optionalImportMessage = importMessage } + assertTextFormatEncode("optional_import_message {\n d: -9\n}\n") { (o: inout MessageTestType) in + o.optionalImportMessage = importMessage + } do { - let message = try MessageTestType(textFormatString:"optional_import_message: {\n d: -9\n}\n") + let message = try MessageTestType(textFormatString: "optional_import_message: {\n d: -9\n}\n") XCTAssertEqual(message.optionalImportMessage.d, -9) } catch { XCTFail("Presented error: \(error)") @@ -836,17 +927,17 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { XCTAssertEqual("optional_nested_enum: BAZ\n", a.textFormatString()) - assertTextFormatEncode("optional_nested_enum: BAZ\n") {(o: inout MessageTestType) in + assertTextFormatEncode("optional_nested_enum: BAZ\n") { (o: inout MessageTestType) in o.optionalNestedEnum = .baz } - assertTextFormatDecodeSucceeds("optional_nested_enum:BAZ"){(o: MessageTestType) in - return o.optionalNestedEnum == .baz + assertTextFormatDecodeSucceeds("optional_nested_enum:BAZ") { (o: MessageTestType) in + o.optionalNestedEnum == .baz } - assertTextFormatDecodeSucceeds("optional_nested_enum:1"){(o: MessageTestType) in - return o.optionalNestedEnum == .foo + assertTextFormatDecodeSucceeds("optional_nested_enum:1") { (o: MessageTestType) in + o.optionalNestedEnum == .foo } - assertTextFormatDecodeSucceeds("optional_nested_enum:2"){(o: MessageTestType) in - return o.optionalNestedEnum == .bar + assertTextFormatDecodeSucceeds("optional_nested_enum:2") { (o: MessageTestType) in + o.optionalNestedEnum == .bar } assertTextFormatDecodeFails("optional_nested_enum: a\n") assertTextFormatDecodeFails("optional_nested_enum: FOOBAR") @@ -855,7 +946,7 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { // Note: This implementation currently preserves numeric unknown // enum values, unlike Google's C++ implementation, which considers // it a parse error. - let b = try Proto3Unittest_TestAllTypes(textFormatString: "optional_nested_enum: 999\n") + let b = try SwiftProtoTesting_Proto3_TestAllTypes(textFormatString: "optional_nested_enum: 999\n") XCTAssertEqual("optional_nested_enum: 999\n", b.textFormatString()) } @@ -865,16 +956,22 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { XCTAssertEqual("optional_foreign_enum: FOREIGN_BAZ\n", a.textFormatString()) - assertTextFormatEncode("optional_foreign_enum: FOREIGN_BAZ\n") {(o: inout MessageTestType) in o.optionalForeignEnum = .foreignBaz } - assertTextFormatDecodeSucceeds("optional_foreign_enum: 6\n") {(o: MessageTestType) in o.optionalForeignEnum == .foreignBaz } + assertTextFormatEncode("optional_foreign_enum: FOREIGN_BAZ\n") { (o: inout MessageTestType) in + o.optionalForeignEnum = .foreignBaz + } + assertTextFormatDecodeSucceeds("optional_foreign_enum: 6\n") { (o: MessageTestType) in + o.optionalForeignEnum == .foreignBaz + } - assertTextFormatEncode("optional_foreign_enum: 99\n") {(o: inout MessageTestType) in o.optionalForeignEnum = .UNRECOGNIZED(99) } + assertTextFormatEncode("optional_foreign_enum: 99\n") { (o: inout MessageTestType) in + o.optionalForeignEnum = .UNRECOGNIZED(99) + } assertTextFormatDecodeFails("optional_foreign_enum: a\n") } func testEncoding_optionalPublicImportMessage() { - var publicImportMessage = ProtobufUnittestImport_PublicImportMessage() + var publicImportMessage = SwiftProtoTesting_Import_PublicImportMessage() publicImportMessage.e = -999999 var a = MessageTestType() @@ -882,10 +979,12 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { XCTAssertEqual("optional_public_import_message {\n e: -999999\n}\n", a.textFormatString()) - assertTextFormatEncode("optional_public_import_message {\n e: -999999\n}\n") {(o: inout MessageTestType) in o.optionalPublicImportMessage = publicImportMessage } + assertTextFormatEncode("optional_public_import_message {\n e: -999999\n}\n") { (o: inout MessageTestType) in + o.optionalPublicImportMessage = publicImportMessage + } do { - let message = try MessageTestType(textFormatString:"optional_public_import_message: {\n e: -999999\n}\n") + let message = try MessageTestType(textFormatString: "optional_public_import_message: {\n e: -999999\n}\n") XCTAssertEqual(message.optionalPublicImportMessage.e, -999999) } catch { XCTFail("Presented error: \(error)") @@ -903,33 +1002,33 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { a.repeatedInt32 = [1, 2] XCTAssertEqual("repeated_int32: [1, 2]\n", a.textFormatString()) - assertTextFormatEncode("repeated_int32: [1, 2]\n") {(o: inout MessageTestType) in + assertTextFormatEncode("repeated_int32: [1, 2]\n") { (o: inout MessageTestType) in o.repeatedInt32 = [1, 2] } assertTextFormatDecodeSucceeds("repeated_int32: 1\n repeated_int32: 2\n") { (o: MessageTestType) in - return o.repeatedInt32 == [1, 2] + o.repeatedInt32 == [1, 2] } assertTextFormatDecodeSucceeds("repeated_int32:[1, 2]") { (o: MessageTestType) in - return o.repeatedInt32 == [1, 2] + o.repeatedInt32 == [1, 2] } assertTextFormatDecodeSucceeds("repeated_int32: [1] repeated_int32: 2\n") { (o: MessageTestType) in - return o.repeatedInt32 == [1, 2] + o.repeatedInt32 == [1, 2] } assertTextFormatDecodeSucceeds("repeated_int32: 1 repeated_int32: [2]\n") { (o: MessageTestType) in - return o.repeatedInt32 == [1, 2] + o.repeatedInt32 == [1, 2] } assertTextFormatDecodeSucceeds("repeated_int32:[]\nrepeated_int32: [1, 2]\nrepeated_int32:[]\n") { (o: MessageTestType) in - return o.repeatedInt32 == [1, 2] + o.repeatedInt32 == [1, 2] } assertTextFormatDecodeSucceeds("repeated_int32:1\nrepeated_int32:2\n") { (o: MessageTestType) in - return o.repeatedInt32 == [1, 2] + o.repeatedInt32 == [1, 2] } assertTextFormatDecodeFails("repeated_int32: 1\nrepeated_int32: a\n") @@ -944,18 +1043,18 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedInt64() { - assertTextFormatEncode("repeated_int64: [3, 4]\n") {(o: inout MessageTestType) in + assertTextFormatEncode("repeated_int64: [3, 4]\n") { (o: inout MessageTestType) in o.repeatedInt64 = [3, 4] } - assertTextFormatDecodeSucceeds("repeated_int64: 3\nrepeated_int64: 4\n") {(o: MessageTestType) in - return o.repeatedInt64 == [3, 4] + assertTextFormatDecodeSucceeds("repeated_int64: 3\nrepeated_int64: 4\n") { (o: MessageTestType) in + o.repeatedInt64 == [3, 4] } assertTextFormatDecodeFails("repeated_int64: 3\nrepeated_int64: a\n") } func testEncoding_repeatedUint32() { - assertTextFormatEncode("repeated_uint32: [5, 6]\n") {(o: inout MessageTestType) in + assertTextFormatEncode("repeated_uint32: [5, 6]\n") { (o: inout MessageTestType) in o.repeatedUint32 = [5, 6] } @@ -963,7 +1062,7 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedUint64() { - assertTextFormatEncode("repeated_uint64: [7, 8]\n") {(o: inout MessageTestType) in + assertTextFormatEncode("repeated_uint64: [7, 8]\n") { (o: inout MessageTestType) in o.repeatedUint64 = [7, 8] } @@ -975,7 +1074,7 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedSint32() { - assertTextFormatEncode("repeated_sint32: [9, 10]\n") {(o: inout MessageTestType) in + assertTextFormatEncode("repeated_sint32: [9, 10]\n") { (o: inout MessageTestType) in o.repeatedSint32 = [9, 10] } @@ -983,7 +1082,7 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedSint64() { - assertTextFormatEncode("repeated_sint64: [11, 12]\n") {(o: inout MessageTestType) in + assertTextFormatEncode("repeated_sint64: [11, 12]\n") { (o: inout MessageTestType) in o.repeatedSint64 = [11, 12] } @@ -991,7 +1090,7 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedFixed32() { - assertTextFormatEncode("repeated_fixed32: [13, 14]\n") {(o: inout MessageTestType) in + assertTextFormatEncode("repeated_fixed32: [13, 14]\n") { (o: inout MessageTestType) in o.repeatedFixed32 = [13, 14] } @@ -999,7 +1098,7 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedFixed64() { - assertTextFormatEncode("repeated_fixed64: [15, 16]\n") {(o: inout MessageTestType) in + assertTextFormatEncode("repeated_fixed64: [15, 16]\n") { (o: inout MessageTestType) in o.repeatedFixed64 = [15, 16] } @@ -1007,7 +1106,7 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedSfixed32() { - assertTextFormatEncode("repeated_sfixed32: [17, 18]\n") {(o: inout MessageTestType) in + assertTextFormatEncode("repeated_sfixed32: [17, 18]\n") { (o: inout MessageTestType) in o.repeatedSfixed32 = [17, 18] } @@ -1015,7 +1114,7 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedSfixed64() { - assertTextFormatEncode("repeated_sfixed64: [19, 20]\n") {(o: inout MessageTestType) in + assertTextFormatEncode("repeated_sfixed64: [19, 20]\n") { (o: inout MessageTestType) in o.repeatedSfixed64 = [19, 20] } @@ -1023,7 +1122,7 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedFloat() { - assertTextFormatEncode("repeated_float: [21.0, 22.0]\n") {(o: inout MessageTestType) in + assertTextFormatEncode("repeated_float: [21.0, 22.0]\n") { (o: inout MessageTestType) in o.repeatedFloat = [21, 22] } @@ -1031,10 +1130,10 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedDouble() { - assertTextFormatEncode("repeated_double: [23.0, 24.0]\n") {(o: inout MessageTestType) in + assertTextFormatEncode("repeated_double: [23.0, 24.0]\n") { (o: inout MessageTestType) in o.repeatedDouble = [23, 24] } - assertTextFormatEncode("repeated_double: [2.25, 2.5]\n") {(o: inout MessageTestType) in + assertTextFormatEncode("repeated_double: [2.25, 2.5]\n") { (o: inout MessageTestType) in o.repeatedDouble = [2.25, 2.5] } @@ -1042,12 +1141,12 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedBool() { - assertTextFormatEncode("repeated_bool: [true, false]\n") {(o: inout MessageTestType) in + assertTextFormatEncode("repeated_bool: [true, false]\n") { (o: inout MessageTestType) in o.repeatedBool = [true, false] } assertTextFormatDecodeSucceeds("repeated_bool: [true, false, True, False, t, f, 1, 0]") { (o: MessageTestType) in - return o.repeatedBool == [true, false, true, false, true, false, true, false] + o.repeatedBool == [true, false, true, false, true, false, true, false] } assertTextFormatDecodeFails("repeated_bool: true\nrepeated_bool: a\n") @@ -1056,27 +1155,27 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { func testEncoding_repeatedString() { assertTextFormatDecodeSucceeds("repeated_string: \"abc\"\nrepeated_string: \"def\"\n") { (o: MessageTestType) in - return o.repeatedString == ["abc", "def"] + o.repeatedString == ["abc", "def"] } assertTextFormatDecodeSucceeds("repeated_string: \"a\" \"bc\"\nrepeated_string: 'd' \"e\" \"f\"\n") { (o: MessageTestType) in - return o.repeatedString == ["abc", "def"] + o.repeatedString == ["abc", "def"] } assertTextFormatDecodeSucceeds("repeated_string:[\"abc\", \"def\"]") { (o: MessageTestType) in - return o.repeatedString == ["abc", "def"] + o.repeatedString == ["abc", "def"] } assertTextFormatDecodeSucceeds("repeated_string:[\"a\"\"bc\", \"d\" 'e' \"f\"]") { (o: MessageTestType) in - return o.repeatedString == ["abc", "def"] + o.repeatedString == ["abc", "def"] } assertTextFormatDecodeSucceeds("repeated_string:[\"abc\", 'def']") { (o: MessageTestType) in - return o.repeatedString == ["abc", "def"] + o.repeatedString == ["abc", "def"] } assertTextFormatDecodeSucceeds("repeated_string:[\"abc\"] repeated_string: \"def\"") { (o: MessageTestType) in - return o.repeatedString == ["abc", "def"] + o.repeatedString == ["abc", "def"] } assertTextFormatDecodeFails("repeated_string:[\"abc\", \"def\",]") assertTextFormatDecodeFails("repeated_string:[\"abc\"") @@ -1085,7 +1184,9 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { assertTextFormatDecodeFails("repeated_string: \"abc\"]") assertTextFormatDecodeFails("repeated_string: abc") - assertTextFormatEncode("repeated_string: \"abc\"\nrepeated_string: \"def\"\n") {(o: inout MessageTestType) in o.repeatedString = ["abc", "def"] } + assertTextFormatEncode("repeated_string: \"abc\"\nrepeated_string: \"def\"\n") { (o: inout MessageTestType) in + o.repeatedString = ["abc", "def"] + } } func testEncoding_repeatedBytes() { @@ -1093,17 +1194,17 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { a.repeatedBytes = [Data(), Data([65, 66])] XCTAssertEqual("repeated_bytes: \"\"\nrepeated_bytes: \"AB\"\n", a.textFormatString()) - assertTextFormatEncode("repeated_bytes: \"\"\nrepeated_bytes: \"AB\"\n") {(o: inout MessageTestType) in + assertTextFormatEncode("repeated_bytes: \"\"\nrepeated_bytes: \"AB\"\n") { (o: inout MessageTestType) in o.repeatedBytes = [Data(), Data([65, 66])] } - assertTextFormatDecodeSucceeds("repeated_bytes: \"\"\nrepeated_bytes: \"A\" \"B\"\n") {(o: MessageTestType) in - return o.repeatedBytes == [Data(), Data([65, 66])] + assertTextFormatDecodeSucceeds("repeated_bytes: \"\"\nrepeated_bytes: \"A\" \"B\"\n") { (o: MessageTestType) in + o.repeatedBytes == [Data(), Data([65, 66])] } - assertTextFormatDecodeSucceeds("repeated_bytes: [\"\", \"AB\"]\n") {(o: MessageTestType) in - return o.repeatedBytes == [Data(), Data([65, 66])] + assertTextFormatDecodeSucceeds("repeated_bytes: [\"\", \"AB\"]\n") { (o: MessageTestType) in + o.repeatedBytes == [Data(), Data([65, 66])] } - assertTextFormatDecodeSucceeds("repeated_bytes: [\"\", \"A\" \"B\"]\n") {(o: MessageTestType) in - return o.repeatedBytes == [Data(), Data([65, 66])] + assertTextFormatDecodeSucceeds("repeated_bytes: [\"\", \"A\" \"B\"]\n") { (o: MessageTestType) in + o.repeatedBytes == [Data(), Data([65, 66])] } } @@ -1117,22 +1218,29 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { var a = MessageTestType() a.repeatedNestedMessage = [nested, nested2] - XCTAssertEqual("repeated_nested_message {\n bb: 7\n}\nrepeated_nested_message {\n bb: -7\n}\n", a.textFormatString()) + XCTAssertEqual( + "repeated_nested_message {\n bb: 7\n}\nrepeated_nested_message {\n bb: -7\n}\n", + a.textFormatString() + ) - assertTextFormatEncode("repeated_nested_message {\n bb: 7\n}\nrepeated_nested_message {\n bb: -7\n}\n") {(o: inout MessageTestType) in o.repeatedNestedMessage = [nested, nested2] } + assertTextFormatEncode("repeated_nested_message {\n bb: 7\n}\nrepeated_nested_message {\n bb: -7\n}\n") { + (o: inout MessageTestType) in o.repeatedNestedMessage = [nested, nested2] + } - assertTextFormatDecodeSucceeds("repeated_nested_message: {\n bb: 7\n}\nrepeated_nested_message: {\n bb: -7\n}\n") { + assertTextFormatDecodeSucceeds( + "repeated_nested_message: {\n bb: 7\n}\nrepeated_nested_message: {\n bb: -7\n}\n" + ) { (o: MessageTestType) in - return o.repeatedNestedMessage == [ - MessageTestType.NestedMessage.with {$0.bb = 7}, - MessageTestType.NestedMessage.with {$0.bb = -7} + o.repeatedNestedMessage == [ + MessageTestType.NestedMessage.with { $0.bb = 7 }, + MessageTestType.NestedMessage.with { $0.bb = -7 }, ] } assertTextFormatDecodeSucceeds("repeated_nested_message:[{bb: 7}, {bb: -7}]") { (o: MessageTestType) in - return o.repeatedNestedMessage == [ - MessageTestType.NestedMessage.with {$0.bb = 7}, - MessageTestType.NestedMessage.with {$0.bb = -7} + o.repeatedNestedMessage == [ + MessageTestType.NestedMessage.with { $0.bb = 7 }, + MessageTestType.NestedMessage.with { $0.bb = -7 }, ] } @@ -1140,7 +1248,7 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedForeignMessage() { - var foreign = Proto3Unittest_ForeignMessage() + var foreign = SwiftProtoTesting_Proto3_ForeignMessage() foreign.c = 88 var foreign2 = foreign @@ -1149,12 +1257,19 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { var a = MessageTestType() a.repeatedForeignMessage = [foreign, foreign2] - XCTAssertEqual("repeated_foreign_message {\n c: 88\n}\nrepeated_foreign_message {\n c: -88\n}\n", a.textFormatString()) + XCTAssertEqual( + "repeated_foreign_message {\n c: 88\n}\nrepeated_foreign_message {\n c: -88\n}\n", + a.textFormatString() + ) - assertTextFormatEncode("repeated_foreign_message {\n c: 88\n}\nrepeated_foreign_message {\n c: -88\n}\n") {(o: inout MessageTestType) in o.repeatedForeignMessage = [foreign, foreign2] } + assertTextFormatEncode("repeated_foreign_message {\n c: 88\n}\nrepeated_foreign_message {\n c: -88\n}\n") { + (o: inout MessageTestType) in o.repeatedForeignMessage = [foreign, foreign2] + } do { - let message = try MessageTestType(textFormatString:"repeated_foreign_message: {\n c: 88\n}\nrepeated_foreign_message: {\n c: -88\n}\n") + let message = try MessageTestType( + textFormatString: "repeated_foreign_message: {\n c: 88\n}\nrepeated_foreign_message: {\n c: -88\n}\n" + ) XCTAssertEqual(message.repeatedForeignMessage[0].c, 88) XCTAssertEqual(message.repeatedForeignMessage[1].c, -88) } catch { @@ -1164,9 +1279,8 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { assertTextFormatDecodeFails("repeated_foreign_message {\n c: 88\n}\nrepeated_foreign_message {\n c: a\n}\n") } - func testEncoding_repeatedImportMessage() { - var importMessage = ProtobufUnittestImport_ImportMessage() + var importMessage = SwiftProtoTesting_Import_ImportMessage() importMessage.d = -9 var importMessage2 = importMessage @@ -1175,12 +1289,19 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { var a = MessageTestType() a.repeatedImportMessage = [importMessage, importMessage2] - XCTAssertEqual("repeated_import_message {\n d: -9\n}\nrepeated_import_message {\n d: 999999\n}\n", a.textFormatString()) + XCTAssertEqual( + "repeated_import_message {\n d: -9\n}\nrepeated_import_message {\n d: 999999\n}\n", + a.textFormatString() + ) - assertTextFormatEncode("repeated_import_message {\n d: -9\n}\nrepeated_import_message {\n d: 999999\n}\n") {(o: inout MessageTestType) in o.repeatedImportMessage = [importMessage, importMessage2] } + assertTextFormatEncode("repeated_import_message {\n d: -9\n}\nrepeated_import_message {\n d: 999999\n}\n") { + (o: inout MessageTestType) in o.repeatedImportMessage = [importMessage, importMessage2] + } do { - let message = try MessageTestType(textFormatString:"repeated_import_message: {\n d: -9\n}\nrepeated_import_message: {\n d: 999999\n}\n") + let message = try MessageTestType( + textFormatString: "repeated_import_message: {\n d: -9\n}\nrepeated_import_message: {\n d: 999999\n}\n" + ) XCTAssertEqual(message.repeatedImportMessage[0].d, -9) XCTAssertEqual(message.repeatedImportMessage[1].d, 999999) } catch { @@ -1191,51 +1312,52 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { } func testEncoding_repeatedNestedEnum() { - assertTextFormatEncode("repeated_nested_enum: [BAR, BAZ]\n") {(o: inout MessageTestType) in + assertTextFormatEncode("repeated_nested_enum: [BAR, BAZ]\n") { (o: inout MessageTestType) in o.repeatedNestedEnum = [.bar, .baz] } assertTextFormatDecodeSucceeds("repeated_nested_enum: BAR repeated_nested_enum: BAZ") { (o: MessageTestType) in - return o.repeatedNestedEnum == [.bar, .baz] + o.repeatedNestedEnum == [.bar, .baz] } assertTextFormatDecodeSucceeds("repeated_nested_enum: [2, BAZ]") { (o: MessageTestType) in - return o.repeatedNestedEnum == [.bar, .baz] + o.repeatedNestedEnum == [.bar, .baz] } - assertTextFormatDecodeSucceeds("repeated_nested_enum: [] repeated_nested_enum: [2] repeated_nested_enum: [BAZ] repeated_nested_enum: []") { + assertTextFormatDecodeSucceeds( + "repeated_nested_enum: [] repeated_nested_enum: [2] repeated_nested_enum: [BAZ] repeated_nested_enum: []" + ) { (o: MessageTestType) in - return o.repeatedNestedEnum == [.bar, .baz] + o.repeatedNestedEnum == [.bar, .baz] } assertTextFormatDecodeFails("repeated_nested_enum: BAR\nrepeated_nested_enum: a\n") } func testEncoding_repeatedForeignEnum() { - assertTextFormatEncode("repeated_foreign_enum: [FOREIGN_BAR, FOREIGN_BAZ]\n") {(o: inout MessageTestType) in + assertTextFormatEncode("repeated_foreign_enum: [FOREIGN_BAR, FOREIGN_BAZ]\n") { (o: inout MessageTestType) in o.repeatedForeignEnum = [.foreignBar, .foreignBaz] } - assertTextFormatDecodeSucceeds("repeated_foreign_enum: [5, 6]\n") {(o: MessageTestType) in + assertTextFormatDecodeSucceeds("repeated_foreign_enum: [5, 6]\n") { (o: MessageTestType) in o.repeatedForeignEnum == [.foreignBar, .foreignBaz] } - assertTextFormatEncode("repeated_foreign_enum: [123, 321]\n") {(o: inout MessageTestType) in + assertTextFormatEncode("repeated_foreign_enum: [123, 321]\n") { (o: inout MessageTestType) in o.repeatedForeignEnum = [.UNRECOGNIZED(123), .UNRECOGNIZED(321)] } assertTextFormatDecodeFails("repeated_foreign_enum: FOREIGN_BAR\nrepeated_foreign_enum: a\n") } - func testEncoding_oneofUint32() { var a = MessageTestType() a.oneofUint32 = 99 XCTAssertEqual("oneof_uint32: 99\n", a.textFormatString()) - assertTextFormatEncode("oneof_uint32: 99\n") {(o: inout MessageTestType) in o.oneofUint32 = 99 } + assertTextFormatEncode("oneof_uint32: 99\n") { (o: inout MessageTestType) in o.oneofUint32 = 99 } assertTextFormatDecodeFails("oneof_uint32: a\n") } @@ -1260,15 +1382,30 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { } func testExplicitDelimiters() { - assertTextFormatDecodeSucceeds("optional_int32:1,optional_int64:3;optional_uint32:4") {(o: MessageTestType) in - return o.optionalInt32 == 1 && o.optionalInt64 == 3 && o.optionalUint32 == 4 - } - assertTextFormatDecodeSucceeds("optional_int32:1,\n") {(o: MessageTestType) in - return o.optionalInt32 == 1 - } - assertTextFormatDecodeSucceeds("optional_int32:1;\n") {(o: MessageTestType) in - return o.optionalInt32 == 1 - } + assertTextFormatDecodeSucceeds("optional_int32:1,optional_int64:3;optional_uint32:4") { (o: MessageTestType) in + o.optionalInt32 == 1 && o.optionalInt64 == 3 && o.optionalUint32 == 4 + } + assertTextFormatDecodeSucceeds("optional_int32:1,\n") { (o: MessageTestType) in + o.optionalInt32 == 1 + } + assertTextFormatDecodeSucceeds("optional_int32:1;\n") { (o: MessageTestType) in + o.optionalInt32 == 1 + } + assertTextFormatDecodeSucceeds("optional_nested_message {bb:3,},") { (o: MessageTestType) in + o.optionalNestedMessage.bb == 3 + } + assertTextFormatDecodeSucceeds("optional_nested_message {bb:7;};") { (o: MessageTestType) in + o.optionalNestedMessage.bb == 7 + } + // Make sure duplicate separators fail. + assertTextFormatDecodeFails("optional_int32:1,,") + assertTextFormatDecodeFails("optional_int32:1;;") + assertTextFormatDecodeFails("optional_int32:1,;") + assertTextFormatDecodeFails("optional_int32:1;,") + assertTextFormatDecodeFails("optional_nested_message {bb:7,,}") + assertTextFormatDecodeFails("optional_nested_message {bb:7;;}") + assertTextFormatDecodeFails("optional_nested_message {bb:7,;}") + assertTextFormatDecodeFails("optional_nested_message {bb:7;,}") } // @@ -1294,15 +1431,15 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { var nested = MessageTestType.NestedMessage() nested.bb = 7 o.optionalNestedMessage = nested - var foreign = Proto3Unittest_ForeignMessage() + var foreign = SwiftProtoTesting_Proto3_ForeignMessage() foreign.c = 88 o.optionalForeignMessage = foreign - var importMessage = ProtobufUnittestImport_ImportMessage() + var importMessage = SwiftProtoTesting_Import_ImportMessage() importMessage.d = -9 o.optionalImportMessage = importMessage o.optionalNestedEnum = .baz o.optionalForeignEnum = .foreignBaz - var publicImportMessage = ProtobufUnittestImport_PublicImportMessage() + var publicImportMessage = SwiftProtoTesting_Import_PublicImportMessage() publicImportMessage.e = -999999 o.optionalPublicImportMessage = publicImportMessage o.repeatedInt32 = [1, 2] @@ -1335,148 +1472,150 @@ class Test_TextFormat_proto3: XCTestCase, PBTestHelpers { } func testMultipleFields() { - let expected: String = ("optional_int32: 1\n" - + "optional_int64: 2\n" - + "optional_uint32: 3\n" - + "optional_uint64: 4\n" - + "optional_sint32: 5\n" - + "optional_sint64: 6\n" - + "optional_fixed32: 7\n" - + "optional_fixed64: 8\n" - + "optional_sfixed32: 9\n" - + "optional_sfixed64: 10\n" - + "optional_float: 11.0\n" - + "optional_double: 12.0\n" - + "optional_bool: true\n" - + "optional_string: \"abc\"\n" - + "optional_bytes: \"AB\"\n" - + "optional_nested_message {\n" - + " bb: 7\n" - + "}\n" - + "optional_foreign_message {\n" - + " c: 88\n" - + "}\n" - + "optional_import_message {\n" - + " d: -9\n" - + "}\n" - + "optional_nested_enum: BAZ\n" - + "optional_foreign_enum: FOREIGN_BAZ\n" - + "optional_public_import_message {\n" - + " e: -999999\n" - + "}\n" - + "repeated_int32: [1, 2]\n" - + "repeated_int64: [3, 4]\n" - + "repeated_uint32: [5, 6]\n" - + "repeated_uint64: [7, 8]\n" - + "repeated_sint32: [9, 10]\n" - + "repeated_sint64: [11, 12]\n" - + "repeated_fixed32: [13, 14]\n" - + "repeated_fixed64: [15, 16]\n" - + "repeated_sfixed32: [17, 18]\n" - + "repeated_sfixed64: [19, 20]\n" - + "repeated_float: [21.0, 22.0]\n" - + "repeated_double: [23.0, 24.0]\n" - + "repeated_bool: [true, false]\n" - + "repeated_string: \"abc\"\n" - + "repeated_string: \"def\"\n" - + "repeated_bytes: \"\"\n" - + "repeated_bytes: \"AB\"\n" - + "repeated_nested_message {\n" - + " bb: 7\n" - + "}\n" - + "repeated_nested_message {\n" - + " bb: -7\n" - + "}\n" - + "repeated_foreign_message {\n" - + " c: 88\n" - + "}\n" - + "repeated_foreign_message {\n" - + " c: -88\n" - + "}\n" - + "repeated_import_message {\n" - + " d: -9\n" - + "}\n" - + "repeated_import_message {\n" - + " d: 999999\n" - + "}\n" - + "repeated_nested_enum: [BAR, BAZ]\n" - + "repeated_foreign_enum: [FOREIGN_BAR, FOREIGN_BAZ]\n" - + "oneof_uint32: 99\n") + let expected: String = + ("optional_int32: 1\n" + + "optional_int64: 2\n" + + "optional_uint32: 3\n" + + "optional_uint64: 4\n" + + "optional_sint32: 5\n" + + "optional_sint64: 6\n" + + "optional_fixed32: 7\n" + + "optional_fixed64: 8\n" + + "optional_sfixed32: 9\n" + + "optional_sfixed64: 10\n" + + "optional_float: 11.0\n" + + "optional_double: 12.0\n" + + "optional_bool: true\n" + + "optional_string: \"abc\"\n" + + "optional_bytes: \"AB\"\n" + + "optional_nested_message {\n" + + " bb: 7\n" + + "}\n" + + "optional_foreign_message {\n" + + " c: 88\n" + + "}\n" + + "optional_import_message {\n" + + " d: -9\n" + + "}\n" + + "optional_nested_enum: BAZ\n" + + "optional_foreign_enum: FOREIGN_BAZ\n" + + "optional_public_import_message {\n" + + " e: -999999\n" + + "}\n" + + "repeated_int32: [1, 2]\n" + + "repeated_int64: [3, 4]\n" + + "repeated_uint32: [5, 6]\n" + + "repeated_uint64: [7, 8]\n" + + "repeated_sint32: [9, 10]\n" + + "repeated_sint64: [11, 12]\n" + + "repeated_fixed32: [13, 14]\n" + + "repeated_fixed64: [15, 16]\n" + + "repeated_sfixed32: [17, 18]\n" + + "repeated_sfixed64: [19, 20]\n" + + "repeated_float: [21.0, 22.0]\n" + + "repeated_double: [23.0, 24.0]\n" + + "repeated_bool: [true, false]\n" + + "repeated_string: \"abc\"\n" + + "repeated_string: \"def\"\n" + + "repeated_bytes: \"\"\n" + + "repeated_bytes: \"AB\"\n" + + "repeated_nested_message {\n" + + " bb: 7\n" + + "}\n" + + "repeated_nested_message {\n" + + " bb: -7\n" + + "}\n" + + "repeated_foreign_message {\n" + + " c: 88\n" + + "}\n" + + "repeated_foreign_message {\n" + + " c: -88\n" + + "}\n" + + "repeated_import_message {\n" + + " d: -9\n" + + "}\n" + + "repeated_import_message {\n" + + " d: 999999\n" + + "}\n" + + "repeated_nested_enum: [BAR, BAZ]\n" + + "repeated_foreign_enum: [FOREIGN_BAR, FOREIGN_BAZ]\n" + + "oneof_uint32: 99\n") assertTextFormatEncode(expected, configure: configureLargeObject) } func testMultipleFields_numbers() { - let text: String = ("1: 1\n" - + "2: 2\n" - + "3: 3\n" - + "4: 4\n" - + "5: 5\n" - + "6: 6\n" - + "7: 7\n" - + "8: 8\n" - + "9: 9\n" - + "10: 10\n" - + "11: 11\n" - + "12: 12\n" - + "13: true\n" - + "14: \"abc\"\n" - + "15: \"AB\"\n" - + "18 {\n" - + " bb: 7\n" - + "}\n" - + "19 {\n" - + " c: 88\n" - + "}\n" - + "20 {\n" - + " d: -9\n" - + "}\n" - + "21: BAZ\n" - + "22: FOREIGN_BAZ\n" - + "26 {\n" - + " e: -999999\n" - + "}\n" - + "31: [1, 2]\n" - + "32: [3, 4]\n" - + "33: [5, 6]\n" - + "34: [7, 8]\n" - + "35: [9, 10]\n" - + "36: [11, 12]\n" - + "37: [13, 14]\n" - + "38: [15, 16]\n" - + "39: [17, 18]\n" - + "40: [19, 20]\n" - + "41: [21, 22]\n" - + "42: [23, 24]\n" - + "43: [true, false]\n" - + "44: \"abc\"\n" - + "44: \"def\"\n" - + "45: \"\"\n" - + "45: \"AB\"\n" - + "48 {\n" - + " bb: 7\n" - + "}\n" - + "48 {\n" - + " bb: -7\n" - + "}\n" - + "49 {\n" - + " c: 88\n" - + "}\n" - + "49 {\n" - + " c: -88\n" - + "}\n" - + "50 {\n" - + " d: -9\n" - + "}\n" - + "50 {\n" - + " d: 999999\n" - + "}\n" - + "51: [BAR, BAZ]\n" - + "52: [FOREIGN_BAR, FOREIGN_BAZ]\n" - + "111: 99\n") + let text: String = + ("1: 1\n" + + "2: 2\n" + + "3: 3\n" + + "4: 4\n" + + "5: 5\n" + + "6: 6\n" + + "7: 7\n" + + "8: 8\n" + + "9: 9\n" + + "10: 10\n" + + "11: 11\n" + + "12: 12\n" + + "13: true\n" + + "14: \"abc\"\n" + + "15: \"AB\"\n" + + "18 {\n" + + " bb: 7\n" + + "}\n" + + "19 {\n" + + " c: 88\n" + + "}\n" + + "20 {\n" + + " d: -9\n" + + "}\n" + + "21: BAZ\n" + + "22: FOREIGN_BAZ\n" + + "26 {\n" + + " e: -999999\n" + + "}\n" + + "31: [1, 2]\n" + + "32: [3, 4]\n" + + "33: [5, 6]\n" + + "34: [7, 8]\n" + + "35: [9, 10]\n" + + "36: [11, 12]\n" + + "37: [13, 14]\n" + + "38: [15, 16]\n" + + "39: [17, 18]\n" + + "40: [19, 20]\n" + + "41: [21, 22]\n" + + "42: [23, 24]\n" + + "43: [true, false]\n" + + "44: \"abc\"\n" + + "44: \"def\"\n" + + "45: \"\"\n" + + "45: \"AB\"\n" + + "48 {\n" + + " bb: 7\n" + + "}\n" + + "48 {\n" + + " bb: -7\n" + + "}\n" + + "49 {\n" + + " c: 88\n" + + "}\n" + + "49 {\n" + + " c: -88\n" + + "}\n" + + "50 {\n" + + " d: -9\n" + + "}\n" + + "50 {\n" + + " d: 999999\n" + + "}\n" + + "51: [BAR, BAZ]\n" + + "52: [FOREIGN_BAR, FOREIGN_BAZ]\n" + + "111: 99\n") let expected = MessageTestType.with { configureLargeObject(&$0) } - assertTextFormatDecodeSucceeds(text) {(o: MessageTestType) in + assertTextFormatDecodeSucceeds(text) { (o: MessageTestType) in o == expected } } diff --git a/Tests/SwiftProtobufTests/Test_Timestamp.swift b/Tests/SwiftProtobufTests/Test_Timestamp.swift index d3a247cad..a96550908 100644 --- a/Tests/SwiftProtobufTests/Test_Timestamp.swift +++ b/Tests/SwiftProtobufTests/Test_Timestamp.swift @@ -19,70 +19,71 @@ /// // ----------------------------------------------------------------------------- - import Foundation -import XCTest import SwiftProtobuf +import XCTest -class Test_Timestamp: XCTestCase, PBTestHelpers { +final class Test_Timestamp: XCTestCase, PBTestHelpers { typealias MessageTestType = Google_Protobuf_Timestamp func testJSON() throws { - XCTAssertEqual("\"1970-01-01T00:00:00Z\"", - try Google_Protobuf_Timestamp().jsonString()) + XCTAssertEqual( + "\"1970-01-01T00:00:00Z\"", + try Google_Protobuf_Timestamp().jsonString() + ) assertJSONEncode("\"1970-01-01T00:00:01.000000001Z\"") { (o: inout MessageTestType) in - o.seconds = 1 // 1 second + o.seconds = 1 // 1 second o.nanos = 1 } assertJSONEncode("\"1970-01-01T00:01:00.000000010Z\"") { (o: inout MessageTestType) in - o.seconds = 60 // 1 minute + o.seconds = 60 // 1 minute o.nanos = 10 } assertJSONEncode("\"1970-01-01T01:00:00.000000100Z\"") { (o: inout MessageTestType) in - o.seconds = 3600 // 1 hour + o.seconds = 3600 // 1 hour o.nanos = 100 } assertJSONEncode("\"1970-01-02T00:00:00.000001Z\"") { (o: inout MessageTestType) in - o.seconds = 86400 // 1 day + o.seconds = 86400 // 1 day o.nanos = 1000 } assertJSONEncode("\"1970-02-01T00:00:00.000010Z\"") { (o: inout MessageTestType) in - o.seconds = 2678400 // 1 month + o.seconds = 2_678_400 // 1 month o.nanos = 10000 } assertJSONEncode("\"1971-01-01T00:00:00.000100Z\"") { (o: inout MessageTestType) in - o.seconds = 31536000 // 1 year + o.seconds = 31_536_000 // 1 year o.nanos = 100000 } assertJSONEncode("\"1970-01-01T00:00:01.001Z\"") { (o: inout MessageTestType) in o.seconds = 1 - o.nanos = 1000000 + o.nanos = 1_000_000 } assertJSONEncode("\"1970-01-01T00:00:01.010Z\"") { (o: inout MessageTestType) in o.seconds = 1 - o.nanos = 10000000 + o.nanos = 10_000_000 } assertJSONEncode("\"1970-01-01T00:00:01.100Z\"") { (o: inout MessageTestType) in o.seconds = 1 - o.nanos = 100000000 + o.nanos = 100_000_000 } assertJSONEncode("\"1970-01-01T00:00:01Z\"") { @@ -94,28 +95,28 @@ class Test_Timestamp: XCTestCase, PBTestHelpers { // Largest representable date assertJSONEncode("\"9999-12-31T23:59:59.999999999Z\"") { (o: inout MessageTestType) in - o.seconds = 253402300799 - o.nanos = 999999999 + o.seconds = 253_402_300_799 + o.nanos = 999_999_999 } // 10 billion seconds after Epoch assertJSONEncode("\"2286-11-20T17:46:40Z\"") { (o: inout MessageTestType) in - o.seconds = 10000000000 + o.seconds = 10_000_000_000 o.nanos = 0 } // 1 billion seconds after Epoch assertJSONEncode("\"2001-09-09T01:46:40Z\"") { (o: inout MessageTestType) in - o.seconds = 1000000000 + o.seconds = 1_000_000_000 o.nanos = 0 } // 1 million seconds after Epoch assertJSONEncode("\"1970-01-12T13:46:40Z\"") { (o: inout MessageTestType) in - o.seconds = 1000000 + o.seconds = 1_000_000 o.nanos = 0 } @@ -136,35 +137,35 @@ class Test_Timestamp: XCTestCase, PBTestHelpers { // 1 million seconds before Epoch assertJSONEncode("\"1969-12-20T10:13:20Z\"") { (o: inout MessageTestType) in - o.seconds = -1000000 + o.seconds = -1_000_000 o.nanos = 0 } // 1 billion seconds before Epoch assertJSONEncode("\"1938-04-24T22:13:20Z\"") { (o: inout MessageTestType) in - o.seconds = -1000000000 + o.seconds = -1_000_000_000 o.nanos = 0 } // 10 billion seconds before Epoch assertJSONEncode("\"1653-02-10T06:13:20Z\"") { (o: inout MessageTestType) in - o.seconds = -10000000000 + o.seconds = -10_000_000_000 o.nanos = 0 } // Earliest leap year assertJSONEncode("\"0004-02-19T02:50:24Z\"") { (o: inout MessageTestType) in - o.seconds = -62036744976 + o.seconds = -62_036_744_976 o.nanos = 0 } // Earliest representable date assertJSONEncode("\"0001-01-01T00:00:00Z\"") { (o: inout MessageTestType) in - o.seconds = -62135596800 + o.seconds = -62_135_596_800 o.nanos = 0 } @@ -181,21 +182,20 @@ class Test_Timestamp: XCTestCase, PBTestHelpers { assertJSONDecodeFails("\"9999-12-31T00:00:00\"") } - func testJSON_range() throws { // Check that JSON timestamps round-trip correctly over a wide range. // This checks about 15,000 dates scattered over a 10,000 year period // to verify that our JSON encoder and decoder agree with each other. // Combined with the above checks of specific known dates, this gives a // pretty high confidence that our date calculations are correct. - let earliest: Int64 = -62135596800 - let latest: Int64 = 253402300799 + let earliest: Int64 = -62_135_596_800 + let latest: Int64 = 253_402_300_799 // Use a smaller increment to get more exhaustive testing. An // increment of 12345 will test every single day in the entire // 10,000 year range and require about 15 minutes to run. // An increment of 12345678 will pick about one day out of // every 5 months and require only a few seconds to run. - let increment: Int64 = 12345678 + let increment: Int64 = 12_345_678 var t: Int64 = earliest // If things are broken, this test can easily generate >10,000 failures. // That many failures can break a lot of tools (Xcode, for example), so @@ -213,7 +213,11 @@ class Test_Timestamp: XCTestCase, PBTestHelpers { if decoded.seconds != t { if roundTripFailures == 0 { // Only the first round-trip failure will be reported here - XCTAssertEqual(decoded.seconds, t, "Round-trip failed for \(encoded): \(t) != \(decoded.seconds)") + XCTAssertEqual( + decoded.seconds, + t, + "Round-trip failed for \(encoded): \(t) != \(decoded.seconds)" + ) } roundTripFailures += 1 } @@ -240,32 +244,53 @@ class Test_Timestamp: XCTestCase, PBTestHelpers { } func testJSON_timezones() { - assertJSONDecodeSucceeds("\"1970-01-01T08:00:00+08:00\"") {$0.seconds == 0} - assertJSONDecodeSucceeds("\"1969-12-31T16:00:00-08:00\"") {$0.seconds == 0} + assertJSONDecodeSucceeds("\"1970-01-01T08:00:00+08:00\"") { $0.seconds == 0 } + assertJSONDecodeSucceeds("\"1969-12-31T16:00:00-08:00\"") { $0.seconds == 0 } assertJSONDecodeFails("\"0001-01-01T00:00:00+23:59\"") assertJSONDecodeFails("\"9999-12-31T23:59:59-23:59\"") } func testJSON_timestampField() throws { do { - let valid = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: "{\"optionalTimestamp\": \"0001-01-01T00:00:00Z\"}") - XCTAssertEqual(valid.optionalTimestamp, Google_Protobuf_Timestamp(seconds: -62135596800)) + let valid = try SwiftProtoTesting_Test3_TestAllTypesProto3( + jsonString: "{\"optionalTimestamp\": \"0001-01-01T00:00:00Z\"}" + ) + XCTAssertEqual(valid.optionalTimestamp, Google_Protobuf_Timestamp(seconds: -62_135_596_800)) } catch { XCTFail("Should have decoded correctly") } - - XCTAssertThrowsError(try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: "{\"optionalTimestamp\": \"10000-01-01T00:00:00Z\"}")) - XCTAssertThrowsError(try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: "{\"optionalTimestamp\": \"0001-01-01T00:00:00\"}")) - XCTAssertThrowsError(try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: "{\"optionalTimestamp\": \"0001-01-01 00:00:00Z\"}")) - XCTAssertThrowsError(try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: "{\"optionalTimestamp\": \"0001-01-01T00:00:00z\"}")) - XCTAssertThrowsError(try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: "{\"optionalTimestamp\": \"0001-01-01t00:00:00Z\"}")) + XCTAssertThrowsError( + try SwiftProtoTesting_Test3_TestAllTypesProto3( + jsonString: "{\"optionalTimestamp\": \"10000-01-01T00:00:00Z\"}" + ) + ) + XCTAssertThrowsError( + try SwiftProtoTesting_Test3_TestAllTypesProto3( + jsonString: "{\"optionalTimestamp\": \"0001-01-01T00:00:00\"}" + ) + ) + XCTAssertThrowsError( + try SwiftProtoTesting_Test3_TestAllTypesProto3( + jsonString: "{\"optionalTimestamp\": \"0001-01-01 00:00:00Z\"}" + ) + ) + XCTAssertThrowsError( + try SwiftProtoTesting_Test3_TestAllTypesProto3( + jsonString: "{\"optionalTimestamp\": \"0001-01-01T00:00:00z\"}" + ) + ) + XCTAssertThrowsError( + try SwiftProtoTesting_Test3_TestAllTypesProto3( + jsonString: "{\"optionalTimestamp\": \"0001-01-01t00:00:00Z\"}" + ) + ) } // A couple more test cases transcribed from conformance test func testJSON_conformance() throws { - let t1 = Google_Protobuf_Timestamp(seconds: 0, nanos: 10000000) - var m1 = ProtobufTestMessages_Proto3_TestAllTypesProto3() + let t1 = Google_Protobuf_Timestamp(seconds: 0, nanos: 10_000_000) + var m1 = SwiftProtoTesting_Test3_TestAllTypesProto3() m1.optionalTimestamp = t1 let expected1 = "{\"optionalTimestamp\":\"1970-01-01T00:00:00.010Z\"}" XCTAssertEqual(try m1.jsonString(), expected1) @@ -273,7 +298,7 @@ class Test_Timestamp: XCTestCase, PBTestHelpers { let json2 = "{\"optionalTimestamp\": \"1970-01-01T00:00:00.010000000Z\"}" let expected2 = "{\"optionalTimestamp\":\"1970-01-01T00:00:00.010Z\"}" do { - let m2 = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: json2) + let m2 = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: json2) do { let recoded2 = try m2.jsonString() XCTAssertEqual(recoded2, expected2) @@ -286,26 +311,37 @@ class Test_Timestamp: XCTestCase, PBTestHelpers { // Extra spaces around all the tokens. let json3 = " { \"repeatedTimestamp\" : [ \"0001-01-01T00:00:00Z\" , \"9999-12-31T23:59:59.999999999Z\" ] } " - let m3 = try ProtobufTestMessages_Proto3_TestAllTypesProto3(jsonString: json3) - let expected3 = [Google_Protobuf_Timestamp(seconds: -62135596800), - Google_Protobuf_Timestamp(seconds: 253402300799, nanos: 999999999)] + let m3 = try SwiftProtoTesting_Test3_TestAllTypesProto3(jsonString: json3) + let expected3 = [ + Google_Protobuf_Timestamp(seconds: -62_135_596_800), + Google_Protobuf_Timestamp(seconds: 253_402_300_799, nanos: 999_999_999), + ] XCTAssertEqual(m3.repeatedTimestamp, expected3) } func testSerializationFailure() throws { - let maxOutOfRange = Google_Protobuf_Timestamp(seconds:-62135596800, nanos: -1) + let maxOutOfRange = Google_Protobuf_Timestamp(seconds: -62_135_596_801, nanos: 999_999_999) XCTAssertThrowsError(try maxOutOfRange.jsonString()) - let minInRange = Google_Protobuf_Timestamp(seconds:-62135596800) + let minInRange = Google_Protobuf_Timestamp(seconds: -62_135_596_800) XCTAssertNotNil(try minInRange.jsonString()) - let maxInRange = Google_Protobuf_Timestamp(seconds:253402300799, nanos: 999999999) + let maxInRange = Google_Protobuf_Timestamp(seconds: 253_402_300_799, nanos: 999_999_999) XCTAssertNotNil(try maxInRange.jsonString()) - let minOutOfRange = Google_Protobuf_Timestamp(seconds:253402300800) + let minOutOfRange = Google_Protobuf_Timestamp(seconds: 253_402_300_800) XCTAssertThrowsError(try minOutOfRange.jsonString()) + let negNanos = Google_Protobuf_Timestamp(seconds: 5_000, nanos: -1) + XCTAssertThrowsError(try negNanos.jsonString()) + let nansTooLarge = Google_Protobuf_Timestamp(seconds: 5_000, nanos: 1_000_000_000) + XCTAssertThrowsError(try nansTooLarge.jsonString()) } func testBasicArithmetic() throws { - let tn1_n1 = Google_Protobuf_Timestamp(seconds: -2, nanos: 999999999) - let t0 = Google_Protobuf_Timestamp() + // One second and one nano second before epoch + let tn1_n1 = Google_Protobuf_Timestamp(seconds: -2, nanos: 999_999_999) + // Half a second before the epoc + let tn1_n500000000 = Google_Protobuf_Timestamp(seconds: -1, nanos: 500_000_000) + let t0 = Google_Protobuf_Timestamp() // epoc + // Times after the epoch + let t0_500000000 = Google_Protobuf_Timestamp(seconds: 0, nanos: 500_000_000) let t1_1 = Google_Protobuf_Timestamp(seconds: 1, nanos: 1) let t2_2 = Google_Protobuf_Timestamp(seconds: 2, nanos: 2) let t3_3 = Google_Protobuf_Timestamp(seconds: 3, nanos: 3) @@ -330,106 +366,266 @@ class Test_Timestamp: XCTestCase, PBTestHelpers { // Difference of two timestamps is a duration XCTAssertEqual(d1_1, t4_4 - t3_3) XCTAssertEqual(dn1_n1, t3_3 - t4_4) + XCTAssertEqual(d2_2, t1_1 - tn1_n1) + XCTAssertEqual(dn1_n1, t0 - t1_1) + + // Test within nanos space rolling past zero + XCTAssertEqual(tn1_n500000000, t0_500000000 - Google_Protobuf_Duration(seconds: 1)) + XCTAssertEqual(t0_500000000, tn1_n500000000 + Google_Protobuf_Duration(seconds: 1)) } func testArithmeticNormalizes() throws { // Addition normalizes the result - let r1: Google_Protobuf_Timestamp = Google_Protobuf_Timestamp() + Google_Protobuf_Duration(seconds: 0, nanos: 2000000001) - XCTAssertEqual(r1.seconds, 2) + let r1: Google_Protobuf_Timestamp = + Google_Protobuf_Timestamp(seconds: 1, nanos: 500_000_000) + + Google_Protobuf_Duration(seconds: 1, nanos: 500_000_001) + XCTAssertEqual(r1.seconds, 3) XCTAssertEqual(r1.nanos, 1) + let r1n: Google_Protobuf_Timestamp = + Google_Protobuf_Timestamp(seconds: -1, nanos: 500_000_000) + + Google_Protobuf_Duration(seconds: -1, nanos: -500_000_001) + XCTAssertEqual(r1n.seconds, -3) + XCTAssertEqual(r1n.nanos, 999_999_999) // Subtraction normalizes the result - let r2: Google_Protobuf_Timestamp = Google_Protobuf_Timestamp() - Google_Protobuf_Duration(seconds: 0, nanos: 2000000001) - XCTAssertEqual(r2.seconds, -3) - XCTAssertEqual(r2.nanos, 999999999) - - // Subtraction normalizes the result - let r3: Google_Protobuf_Duration = Google_Protobuf_Timestamp() - Google_Protobuf_Timestamp(seconds: 0, nanos: 2000000001) + let r2: Google_Protobuf_Timestamp = + Google_Protobuf_Timestamp(seconds: 1, nanos: 500_000_000) + - Google_Protobuf_Duration(seconds: 1, nanos: 500_000_001) + XCTAssertEqual(r2.seconds, -1) + XCTAssertEqual(r2.nanos, 999_999_999) + let r2n: Google_Protobuf_Timestamp = + Google_Protobuf_Timestamp(seconds: -1, nanos: 500_000_000) + - Google_Protobuf_Duration(seconds: -1, nanos: -500_000_001) + XCTAssertEqual(r2n.seconds, 1) + XCTAssertEqual(r2n.nanos, 1) + + // Subtraction for delta normalizes the result + let r3: Google_Protobuf_Duration = + Google_Protobuf_Timestamp() - Google_Protobuf_Timestamp(seconds: 2, nanos: 1) XCTAssertEqual(r3.seconds, -2) XCTAssertEqual(r3.nanos, -1) - let r4: Google_Protobuf_Duration = Google_Protobuf_Timestamp(seconds: 1) - Google_Protobuf_Timestamp(nanos: 2000000001) + let r4: Google_Protobuf_Duration = + Google_Protobuf_Timestamp(seconds: 1) - Google_Protobuf_Timestamp(seconds: 2, nanos: 1) XCTAssertEqual(r4.seconds, -1) XCTAssertEqual(r4.nanos, -1) - let r5: Google_Protobuf_Duration = Google_Protobuf_Timestamp(seconds: -1) - Google_Protobuf_Timestamp(nanos: -2000000001) + let r5: Google_Protobuf_Duration = + Google_Protobuf_Timestamp(seconds: -1) - Google_Protobuf_Timestamp(seconds: -3, nanos: 999_999_999) XCTAssertEqual(r5.seconds, 1) XCTAssertEqual(r5.nanos, 1) - let r6: Google_Protobuf_Duration = Google_Protobuf_Timestamp(seconds: -10) - Google_Protobuf_Timestamp(nanos: -2000000001) - XCTAssertEqual(r6.seconds, -7) - XCTAssertEqual(r6.nanos, -999999999) - - let r7: Google_Protobuf_Duration = Google_Protobuf_Timestamp(seconds: 10) - Google_Protobuf_Timestamp(nanos: 2000000001) + let r6: Google_Protobuf_Duration = + Google_Protobuf_Timestamp(seconds: 10) - Google_Protobuf_Timestamp(seconds: -3, nanos: 999_999_999) + XCTAssertEqual(r6.seconds, 12) + XCTAssertEqual(r6.nanos, 1) + let r6n: Google_Protobuf_Duration = + Google_Protobuf_Timestamp(seconds: -10) - Google_Protobuf_Timestamp(seconds: -3, nanos: 999_999_999) + XCTAssertEqual(r6n.seconds, -7) + XCTAssertEqual(r6n.nanos, -999_999_999) + + let r7: Google_Protobuf_Duration = + Google_Protobuf_Timestamp(seconds: 10) - Google_Protobuf_Timestamp(seconds: 2, nanos: 1) XCTAssertEqual(r7.seconds, 7) - XCTAssertEqual(r7.nanos, 999999999) + XCTAssertEqual(r7.nanos, 999_999_999) } - // TODO: Should setter correct for out-of-range - // nanos and other minor inconsistencies? - - func testInitializationByTimestamps() throws { + func testInitializationRoundingTimestamps() throws { // Negative timestamp - let t1 = Google_Protobuf_Timestamp(timeIntervalSince1970: -123.456) + let t1 = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: -123.456) XCTAssertEqual(t1.seconds, -124) - XCTAssertEqual(t1.nanos, 544000000) + XCTAssertEqual(t1.nanos, 544_000_000) + XCTAssertEqual(t1.timeIntervalSince1970, -123.456) // Full precision - let t2 = Google_Protobuf_Timestamp(timeIntervalSince1970: -123.999999999) + let t2 = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: -123.999999999) XCTAssertEqual(t2.seconds, -124) XCTAssertEqual(t2.nanos, 1) + XCTAssertEqual(t2.timeIntervalSince1970, -123.999999999) - // Round up - let t3 = Google_Protobuf_Timestamp(timeIntervalSince1970: -123.9999999994) + // Value past percision, default and some explicit rules + let t3 = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: -123.9999999994) XCTAssertEqual(t3.seconds, -124) XCTAssertEqual(t3.nanos, 1) - - // Round down - let t4 = Google_Protobuf_Timestamp(timeIntervalSince1970: -123.9999999996) + XCTAssertEqual(t3.timeIntervalSince1970, -123.999999999) + let t3u = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: -123.9999999994, rule: .up) + XCTAssertEqual(t3u.seconds, -124) + XCTAssertEqual(t3u.nanos, 1) + let t3d = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: -123.9999999994, rule: .down) + XCTAssertEqual(t3d.seconds, -124) + XCTAssertEqual(t3d.nanos, 0) + + // Value past percision, default and some explicit rules + let t4 = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: -123.9999999996) XCTAssertEqual(t4.seconds, -124) XCTAssertEqual(t4.nanos, 0) - - let t5 = Google_Protobuf_Timestamp(timeIntervalSince1970: 0) + let t4u = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: -123.9999999996, rule: .up) + XCTAssertEqual(t4u.seconds, -124) + XCTAssertEqual(t4u.nanos, 1) + let t4d = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: -123.9999999996, rule: .down) + XCTAssertEqual(t4d.seconds, -124) + XCTAssertEqual(t4d.nanos, 0) + + let t5 = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: 0) XCTAssertEqual(t5.seconds, 0) XCTAssertEqual(t5.nanos, 0) + XCTAssertEqual(t5.timeIntervalSince1970, 0) // Positive timestamp - let t6 = Google_Protobuf_Timestamp(timeIntervalSince1970: 123.456) + let t6 = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: 123.456) XCTAssertEqual(t6.seconds, 123) - XCTAssertEqual(t6.nanos, 456000000) + XCTAssertEqual(t6.nanos, 456_000_000) // Full precision - let t7 = Google_Protobuf_Timestamp(timeIntervalSince1970: 123.999999999) + let t7 = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: 123.999999999) XCTAssertEqual(t7.seconds, 123) - XCTAssertEqual(t7.nanos, 999999999) + XCTAssertEqual(t7.nanos, 999_999_999) + XCTAssertEqual(t7.timeIntervalSince1970, 123.999999999) - // Round down - let t8 = Google_Protobuf_Timestamp(timeIntervalSince1970: 123.9999999994) + // Value past percision, default and some explicit rules + let t8 = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: 123.9999999994) XCTAssertEqual(t8.seconds, 123) - XCTAssertEqual(t8.nanos, 999999999) - - // Round up - let t9 = Google_Protobuf_Timestamp(timeIntervalSince1970: 123.9999999996) + XCTAssertEqual(t8.nanos, 999_999_999) + let t8u = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: 123.9999999994, rule: .up) + XCTAssertEqual(t8u.seconds, 124) + XCTAssertEqual(t8u.nanos, 0) + let t8d = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: 123.9999999994, rule: .down) + XCTAssertEqual(t8d.seconds, 123) + XCTAssertEqual(t8d.nanos, 999_999_999) + + // Value past percision, default and some explicit rules + let t9 = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: 123.9999999996) XCTAssertEqual(t9.seconds, 124) XCTAssertEqual(t9.nanos, 0) + let t9u = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: 123.9999999996) + XCTAssertEqual(t9u.seconds, 124) + XCTAssertEqual(t9u.nanos, 0) + let t9d = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: 123.9999999996) + XCTAssertEqual(t9d.seconds, 124) + XCTAssertEqual(t9d.nanos, 0) + + // Small Positive Value + let t10 = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: 0.999999999) + XCTAssertEqual(t10.seconds, 0) + XCTAssertEqual(t10.nanos, 999_999_999) + XCTAssertEqual(t10.timeIntervalSince1970, 0.999999999) + + // Small Negative Value + let t11 = Google_Protobuf_Timestamp(roundingTimeIntervalSince1970: -0.000000001) + XCTAssertEqual(t11.seconds, -1) + XCTAssertEqual(t11.nanos, 999_999_999) + // No fetch of the value as it can fall into percision issues for a double. } func testInitializationByReferenceTimestamp() throws { - let t1 = Google_Protobuf_Timestamp(timeIntervalSinceReferenceDate: 123.456) - XCTAssertEqual(t1.seconds, 978307323) - XCTAssertEqual(t1.nanos, 456000000) + let t1 = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: 123.456) + XCTAssertEqual(t1.seconds, 978_307_323) + XCTAssertEqual(t1.nanos, 456_000_000) + XCTAssertEqual(t1.timeIntervalSinceReferenceDate, 123.456) + + let t2 = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: 0.0) + XCTAssertEqual(t2.seconds, 978_307_200) + XCTAssertEqual(t2.nanos, 0) + XCTAssertEqual(t2.timeIntervalSinceReferenceDate, 0) + + let t3 = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: -0.1) + XCTAssertEqual(t3.seconds, 978_307_199) + XCTAssertEqual(t3.nanos, 900_000_000) + // No fetch of the value as it can fall into percision issues for a double. + + let t4 = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: -1.0) + XCTAssertEqual(t4.seconds, 978_307_199) + XCTAssertEqual(t4.nanos, 0) + XCTAssertEqual(t4.timeIntervalSinceReferenceDate, -1.0) + + let t5 = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: -978307200.0) + XCTAssertEqual(t5.seconds, 0) + XCTAssertEqual(t5.nanos, 0) + XCTAssertEqual(t5.timeIntervalSinceReferenceDate, -978307200.0) + + let t6 = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: -978307201.0) + XCTAssertEqual(t6.seconds, -1) + XCTAssertEqual(t6.nanos, 0) + XCTAssertEqual(t6.timeIntervalSinceReferenceDate, -978307201.0) + + // Just before epoch. + // At this point we're in double percision issues, so this doesn't come out as + // one might expect. + let t7 = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: -978307200.1) + XCTAssertEqual(t7.seconds, -1) + XCTAssertEqual(t7.nanos, 899_999_976) + XCTAssertEqual(t7.timeIntervalSinceReferenceDate, -978307200.1) + + // Due to the percission issue mentioned on t7, we can't easily do cases that result + // in negative final values where the rounding is clearly testable. + + // Full precision + let t8 = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: 123.999999999) + XCTAssertEqual(t8.seconds, 978_307_323) + XCTAssertEqual(t8.nanos, 999_999_999) + XCTAssertEqual(t8.timeIntervalSinceReferenceDate, 123.999999999) + + // Full precision + let t9 = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: -123.999999999) + XCTAssertEqual(t9.seconds, 978_307_076) + XCTAssertEqual(t9.nanos, 1) + XCTAssertEqual(t9.timeIntervalSinceReferenceDate, -123.999999999) + + // Value past percision, default and some explicit rules + let t10 = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: 123.9999999994) + XCTAssertEqual(t10.seconds, 978_307_323) + XCTAssertEqual(t10.nanos, 999_999_999) + let t10u = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: 123.9999999994, rule: .up) + XCTAssertEqual(t10u.seconds, 978_307_324) + XCTAssertEqual(t10u.nanos, 0) + let t10d = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: 123.9999999994, rule: .down) + XCTAssertEqual(t10d.seconds, 978_307_323) + XCTAssertEqual(t10d.nanos, 999_999_999) + + // Value past percision, default and some explicit rules + let t11 = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: 123.9999999996) + XCTAssertEqual(t11.seconds, 978_307_324) + XCTAssertEqual(t11.nanos, 0) + let t11u = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: 123.9999999996, rule: .up) + XCTAssertEqual(t11u.seconds, 978_307_324) + XCTAssertEqual(t11u.nanos, 0) + let t11d = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: 123.9999999996, rule: .down) + XCTAssertEqual(t11d.seconds, 978_307_323) + XCTAssertEqual(t11d.nanos, 999_999_999) + + // Value past percision, default and some explicit rules + let t12 = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: -123.9999999994) + XCTAssertEqual(t12.seconds, 978_307_076) + XCTAssertEqual(t12.nanos, 1) + let t12u = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: -123.9999999994, rule: .up) + XCTAssertEqual(t12u.seconds, 978_307_076) + XCTAssertEqual(t12u.nanos, 1) + let t12d = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: -123.9999999994, rule: .down) + XCTAssertEqual(t12d.seconds, 978_307_076) + XCTAssertEqual(t12d.nanos, 0) + + // Value past percision, default and some explicit rules + let t13 = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: -123.9999999996) + XCTAssertEqual(t13.seconds, 978_307_076) + XCTAssertEqual(t13.nanos, 0) + let t13u = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: -123.9999999996, rule: .up) + XCTAssertEqual(t13u.seconds, 978_307_076) + XCTAssertEqual(t13u.nanos, 1) + let t13d = Google_Protobuf_Timestamp(roundingTimeIntervalSinceReferenceDate: -123.9999999996, rule: .down) + XCTAssertEqual(t13d.seconds, 978_307_076) + XCTAssertEqual(t13d.nanos, 0) } func testInitializationByDates() throws { let t1 = Google_Protobuf_Timestamp(date: Date(timeIntervalSinceReferenceDate: 123.456)) - XCTAssertEqual(t1.seconds, 978307323) - XCTAssertEqual(t1.nanos, 456000000) + XCTAssertEqual(t1.seconds, 978_307_323) + XCTAssertEqual(t1.nanos, 456_000_000) } func testTimestampGetters() throws { - let t1 = Google_Protobuf_Timestamp(seconds: 12345678, nanos: 12345678) - XCTAssertEqual(t1.seconds, 12345678) - XCTAssertEqual(t1.nanos, 12345678) + let t1 = Google_Protobuf_Timestamp(seconds: 12_345_678, nanos: 12_345_678) + XCTAssertEqual(t1.seconds, 12_345_678) + XCTAssertEqual(t1.nanos, 12_345_678) XCTAssertEqual(t1.timeIntervalSince1970, 12345678.012345678) XCTAssertEqual(t1.timeIntervalSinceReferenceDate, -965961521.987654322) let d = t1.date diff --git a/Tests/SwiftProtobufTests/Test_Type.swift b/Tests/SwiftProtobufTests/Test_Type.swift index 17de45c1b..fd35832a9 100644 --- a/Tests/SwiftProtobufTests/Test_Type.swift +++ b/Tests/SwiftProtobufTests/Test_Type.swift @@ -13,19 +13,21 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest // Since Type is purely compiled (there is no hand-coding // in it) this is a fairly thin test just to ensure that the proto // does get into the runtime: -class Test_Type: XCTestCase, PBTestHelpers { +final class Test_Type: XCTestCase, PBTestHelpers { typealias MessageTestType = Google_Protobuf_Type func testExists() { - assertEncode([18,13,8,1,16,3,24,1,34,3,102,111,111,64,1, - 18,9,8,8,24,2,34,3,98,97,114]) { (o: inout MessageTestType) in + assertEncode([ + 18, 13, 8, 1, 16, 3, 24, 1, 34, 3, 102, 111, 111, 64, 1, + 18, 9, 8, 8, 24, 2, 34, 3, 98, 97, 114, + ]) { (o: inout MessageTestType) in var field1 = Google_Protobuf_Field() field1.kind = .typeDouble field1.cardinality = .repeated diff --git a/Tests/SwiftProtobufTests/Test_Unknown_proto2.swift b/Tests/SwiftProtobufTests/Test_Unknown_proto2.swift index 1100f44bc..3eb7732f2 100644 --- a/Tests/SwiftProtobufTests/Test_Unknown_proto2.swift +++ b/Tests/SwiftProtobufTests/Test_Unknown_proto2.swift @@ -14,21 +14,21 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest // Verify that unknown fields are correctly preserved by // proto2 messages. -class Test_Unknown_proto2: XCTestCase, PBTestHelpers { - typealias MessageTestType = ProtobufUnittest_TestEmptyMessage +final class Test_Unknown_proto2: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_TestEmptyMessage /// Verify that json decode ignores the provided fields but otherwise succeeds func assertJSONIgnores(_ json: String, file: XCTestFileArgType = #file, line: UInt = #line) { do { var options = JSONDecodingOptions() options.ignoreUnknownFields = true - let empty = try ProtobufUnittest_TestEmptyMessage(jsonString: json, options: options) + let empty = try SwiftProtoTesting_TestEmptyMessage(jsonString: json, options: options) do { let json = try empty.jsonString() XCTAssertEqual("{}", json, file: file, line: line) @@ -44,10 +44,10 @@ class Test_Unknown_proto2: XCTestCase, PBTestHelpers { func testBinaryPB() { func assertRecodes(_ protobufBytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line) { do { - let empty = try ProtobufUnittest_TestEmptyMessage(serializedData: Data(protobufBytes)) + let empty = try SwiftProtoTesting_TestEmptyMessage(serializedBytes: protobufBytes) do { - let pb = try empty.serializedData() - XCTAssertEqual(Data(protobufBytes), pb, file: file, line: line) + let pb: [UInt8] = try empty.serializedBytes() + XCTAssertEqual(protobufBytes, pb, file: file, line: line) } catch { XCTFail("Recoding empty failed", file: file, line: line) } @@ -56,23 +56,27 @@ class Test_Unknown_proto2: XCTestCase, PBTestHelpers { } } func assertFails(_ protobufBytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line) { - XCTAssertThrowsError(try ProtobufUnittest_TestEmptyMessage(serializedData: Data(protobufBytes)), file: file, line: line) + XCTAssertThrowsError( + try SwiftProtoTesting_TestEmptyMessage(serializedBytes: protobufBytes), + file: file, + line: line + ) } // Well-formed input should decode/recode as-is; malformed input should fail to decode - assertFails([0]) // Invalid field number + assertFails([0]) // Invalid field number assertFails([0, 0]) - assertFails([1]) // Invalid field number - assertFails([2]) // Invalid field number - assertFails([3]) // Invalid field number - assertFails([4]) // Invalid field number - assertFails([5]) // Invalid field number - assertFails([6]) // Invalid field number - assertFails([7]) // Invalid field number - assertFails([8]) // Varint field #1 but no varint body + assertFails([1]) // Invalid field number + assertFails([2]) // Invalid field number + assertFails([3]) // Invalid field number + assertFails([4]) // Invalid field number + assertFails([5]) // Invalid field number + assertFails([6]) // Invalid field number + assertFails([7]) // Invalid field number + assertFails([8]) // Varint field #1 but no varint body assertRecodes([8, 0]) - assertFails([8, 128]) // Truncated varint + assertFails([8, 128]) // Truncated varint assertRecodes([9, 0, 0, 0, 0, 0, 0, 0, 0]) - assertFails([9, 0, 0, 0, 0, 0, 0, 0]) // Truncated 64-bit field + assertFails([9, 0, 0, 0, 0, 0, 0, 0]) // Truncated 64-bit field assertFails([9, 0, 0, 0, 0, 0, 0]) assertFails([9, 0, 0, 0, 0, 0]) assertFails([9, 0, 0, 0, 0]) @@ -80,14 +84,14 @@ class Test_Unknown_proto2: XCTestCase, PBTestHelpers { assertFails([9, 0, 0]) assertFails([9, 0]) assertFails([9]) - assertFails([10]) // Length-delimited field but no length - assertRecodes([10, 0]) // Valid 0-length field - assertFails([10, 1]) // Length 1 but truncated - assertRecodes([10, 1, 2]) // Length 1 with 1 byte - assertFails([10, 2, 1]) // Length 2 truncated - assertFails([11]) // Start group #1 but no end group - assertRecodes([11, 12]) // Start/end group #1 - assertFails([12]) // Bare end group + assertFails([10]) // Length-delimited field but no length + assertRecodes([10, 0]) // Valid 0-length field + assertFails([10, 1]) // Length 1 but truncated + assertRecodes([10, 1, 2]) // Length 1 with 1 byte + assertFails([10, 2, 1]) // Length 2 truncated + assertFails([11]) // Start group #1 but no end group + assertRecodes([11, 12]) // Start/end group #1 + assertFails([12]) // Bare end group assertRecodes([13, 0, 0, 0, 0]) assertFails([13, 0, 0, 0]) assertFails([13, 0, 0]) @@ -95,9 +99,9 @@ class Test_Unknown_proto2: XCTestCase, PBTestHelpers { assertFails([13]) assertFails([14]) assertFails([15]) - assertRecodes([248, 255, 255, 255, 15, 0]) // Maximum field number - assertFails([128, 128, 128, 128, 16, 0]) // Out-of-range field number - assertFails([248, 255, 255, 255, 127, 0]) // Out-of-range field number + assertRecodes([248, 255, 255, 255, 15, 0]) // Maximum field number + assertFails([128, 128, 128, 128, 16, 0]) // Out-of-range field number + assertFails([248, 255, 255, 255, 127, 0]) // Out-of-range field number } // JSON coding drops unknown fields for both proto2 and proto3 @@ -119,7 +123,7 @@ class Test_Unknown_proto2: XCTestCase, PBTestHelpers { assertJSONIgnores("{\"unknown\": {}}") assertJSONIgnores("{\"unknown\": {\"foo\": 1}}") assertJSONIgnores("{\"unknown\": 7, \"also_unknown\": 8}") - assertJSONIgnores("{\"unknown\": 7, \"unknown\": 8}") // ??? + assertJSONIgnores("{\"unknown\": 7, \"unknown\": 8}") // ??? // Badly formed JSON should fail to decode, even in unknown sections var options = JSONDecodingOptions() @@ -158,47 +162,46 @@ class Test_Unknown_proto2: XCTestCase, PBTestHelpers { assertJSONDecodeFails("{\"unknown\", \"a\": 1}", options: options) } - - func assertUnknownFields(_ message: Message, _ bytes: [UInt8], line: UInt = #line) { + func assertUnknownFields(_ message: any Message, _ bytes: [UInt8], line: UInt = #line) { XCTAssertEqual(message.unknownFields.data, Data(bytes), line: line) } func test_MessageNoStorageClass() throws { - var msg1 = ProtobufUnittest_Msg2NoStorage() + var msg1 = SwiftProtoTesting_Msg2NoStorage() assertUnknownFields(msg1, []) - try msg1.merge(serializedData: Data([24, 1])) // Field 3, varint + try msg1.merge(serializedBytes: [24, 1]) // Field 3, varint assertUnknownFields(msg1, [24, 1]) var msg2 = msg1 assertUnknownFields(msg2, [24, 1]) assertUnknownFields(msg1, [24, 1]) - try msg2.merge(serializedData: Data([34, 1, 52])) // Field 4, length delimted + try msg2.merge(serializedBytes: [34, 1, 52]) // Field 4, length delimited assertUnknownFields(msg2, [24, 1, 34, 1, 52]) assertUnknownFields(msg1, [24, 1]) - try msg1.merge(serializedData: Data([61, 7, 0, 0, 0])) // Field 7, 32-bit value + try msg1.merge(serializedBytes: [61, 7, 0, 0, 0]) // Field 7, 32-bit value assertUnknownFields(msg2, [24, 1, 34, 1, 52]) assertUnknownFields(msg1, [24, 1, 61, 7, 0, 0, 0]) } func test_MessageUsingStorageClass() throws { - var msg1 = ProtobufUnittest_Msg2UsesStorage() + var msg1 = SwiftProtoTesting_Msg2UsesStorage() assertUnknownFields(msg1, []) - try msg1.merge(serializedData: Data([24, 1])) // Field 3, varint + try msg1.merge(serializedBytes: [24, 1]) // Field 3, varint assertUnknownFields(msg1, [24, 1]) var msg2 = msg1 assertUnknownFields(msg2, [24, 1]) assertUnknownFields(msg1, [24, 1]) - try msg2.merge(serializedData: Data([34, 1, 52])) // Field 4, length delimted + try msg2.merge(serializedBytes: [34, 1, 52]) // Field 4, length delimited assertUnknownFields(msg2, [24, 1, 34, 1, 52]) assertUnknownFields(msg1, [24, 1]) - try msg1.merge(serializedData: Data([61, 7, 0, 0, 0])) // Field 7, 32-bit value + try msg1.merge(serializedBytes: [61, 7, 0, 0, 0]) // Field 7, 32-bit value assertUnknownFields(msg2, [24, 1, 34, 1, 52]) assertUnknownFields(msg1, [24, 1, 61, 7, 0, 0, 0]) } diff --git a/Tests/SwiftProtobufTests/Test_Unknown_proto3.swift b/Tests/SwiftProtobufTests/Test_Unknown_proto3.swift index 3bbdacead..2b8f0aac2 100644 --- a/Tests/SwiftProtobufTests/Test_Unknown_proto3.swift +++ b/Tests/SwiftProtobufTests/Test_Unknown_proto3.swift @@ -14,23 +14,23 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest // Note: This uses the 'Proto3Arena' version of the empty message. // 'Arena' just indicates that this empty proto3 message // happens to be defined in a .proto that is also used for testing // C++ arena support. -class Test_Unknown_proto3: XCTestCase, PBTestHelpers { - typealias MessageTestType = Proto3ArenaUnittest_TestEmptyMessage +final class Test_Unknown_proto3: XCTestCase, PBTestHelpers { + typealias MessageTestType = SwiftProtoTesting_Proto3_TestEmptyMessage /// Verify that json decode ignores the provided fields but otherwise succeeds func assertJSONIgnores(_ json: String, file: XCTestFileArgType = #file, line: UInt = #line) { do { var options = JSONDecodingOptions() options.ignoreUnknownFields = true - let empty = try Proto3ArenaUnittest_TestEmptyMessage(jsonString: json, options: options) + let empty = try MessageTestType(jsonString: json, options: options) do { let json = try empty.jsonString() XCTAssertEqual("{}", json, file: file, line: line) @@ -46,10 +46,10 @@ class Test_Unknown_proto3: XCTestCase, PBTestHelpers { func testBinaryPB() { func assertRecodes(_ protobufBytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line) { do { - let empty = try Proto3ArenaUnittest_TestEmptyMessage(serializedData: Data(protobufBytes)) + let empty = try MessageTestType(serializedBytes: protobufBytes) do { - let pb = try empty.serializedData() - XCTAssertEqual(Data(protobufBytes), pb, file: file, line: line) + let pb: [UInt8] = try empty.serializedBytes() + XCTAssertEqual(protobufBytes, pb, file: file, line: line) } catch { XCTFail("Recoding empty failed", file: file, line: line) } @@ -58,23 +58,23 @@ class Test_Unknown_proto3: XCTestCase, PBTestHelpers { } } func assertFails(_ protobufBytes: [UInt8], file: XCTestFileArgType = #file, line: UInt = #line) { - XCTAssertThrowsError(try Proto3ArenaUnittest_TestEmptyMessage(serializedData: Data(protobufBytes)), file: file, line: line) + XCTAssertThrowsError(try MessageTestType(serializedBytes: protobufBytes), file: file, line: line) } // Well-formed input should decode/recode as-is; malformed input should fail to decode - assertFails([0]) // Invalid field number + assertFails([0]) // Invalid field number assertFails([0, 0]) - assertFails([1]) // Invalid field number - assertFails([2]) // Invalid field number - assertFails([3]) // Invalid field number - assertFails([4]) // Invalid field number - assertFails([5]) // Invalid field number - assertFails([6]) // Invalid field number - assertFails([7]) // Invalid field number - assertFails([8]) // Varint field #1 but no varint body + assertFails([1]) // Invalid field number + assertFails([2]) // Invalid field number + assertFails([3]) // Invalid field number + assertFails([4]) // Invalid field number + assertFails([5]) // Invalid field number + assertFails([6]) // Invalid field number + assertFails([7]) // Invalid field number + assertFails([8]) // Varint field #1 but no varint body assertRecodes([8, 0]) - assertFails([8, 128]) // Truncated varint + assertFails([8, 128]) // Truncated varint assertRecodes([9, 0, 0, 0, 0, 0, 0, 0, 0]) - assertFails([9, 0, 0, 0, 0, 0, 0, 0]) // Truncated 64-bit field + assertFails([9, 0, 0, 0, 0, 0, 0, 0]) // Truncated 64-bit field assertFails([9, 0, 0, 0, 0, 0, 0]) assertFails([9, 0, 0, 0, 0, 0]) assertFails([9, 0, 0, 0, 0]) @@ -82,14 +82,14 @@ class Test_Unknown_proto3: XCTestCase, PBTestHelpers { assertFails([9, 0, 0]) assertFails([9, 0]) assertFails([9]) - assertFails([10]) // Length-delimited field but no length - assertRecodes([10, 0]) // Valid 0-length field - assertFails([10, 1]) // Length 1 but truncated - assertRecodes([10, 1, 2]) // Length 1 with 1 byte - assertFails([10, 2, 1]) // Length 2 truncated - assertFails([11]) // Start group #1 but no end group - assertRecodes([11, 12]) // Start/end group #1 - assertFails([12]) // Bare end group + assertFails([10]) // Length-delimited field but no length + assertRecodes([10, 0]) // Valid 0-length field + assertFails([10, 1]) // Length 1 but truncated + assertRecodes([10, 1, 2]) // Length 1 with 1 byte + assertFails([10, 2, 1]) // Length 2 truncated + assertFails([11]) // Start group #1 but no end group + assertRecodes([11, 12]) // Start/end group #1 + assertFails([12]) // Bare end group assertRecodes([13, 0, 0, 0, 0]) assertFails([13, 0, 0, 0]) assertFails([13, 0, 0]) @@ -97,9 +97,9 @@ class Test_Unknown_proto3: XCTestCase, PBTestHelpers { assertFails([13]) assertFails([14]) assertFails([15]) - assertRecodes([248, 255, 255, 255, 15, 0]) // Maximum field number - assertFails([128, 128, 128, 128, 16, 0]) // Out-of-range field number - assertFails([248, 255, 255, 255, 127, 0]) // Out-of-range field number + assertRecodes([248, 255, 255, 255, 15, 0]) // Maximum field number + assertFails([128, 128, 128, 128, 16, 0]) // Out-of-range field number + assertFails([248, 255, 255, 255, 127, 0]) // Out-of-range field number } // JSON coding drops unknown fields for both proto2 and proto3 @@ -121,7 +121,7 @@ class Test_Unknown_proto3: XCTestCase, PBTestHelpers { assertJSONIgnores("{\"unknown\": {}}") assertJSONIgnores("{\"unknown\": {\"foo\": 1}}") assertJSONIgnores("{\"unknown\": 7, \"also_unknown\": 8}") - assertJSONIgnores("{\"unknown\": 7, \"unknown\": 8}") // ??? + assertJSONIgnores("{\"unknown\": 7, \"unknown\": 8}") // ??? // Badly formed JSON should fail to decode, even in unknown sections var options = JSONDecodingOptions() @@ -160,47 +160,46 @@ class Test_Unknown_proto3: XCTestCase, PBTestHelpers { assertJSONDecodeFails("{\"unknown\", \"a\": 1}", options: options) } - - func assertUnknownFields(_ message: Message, _ bytes: [UInt8], line: UInt = #line) { + func assertUnknownFields(_ message: any Message, _ bytes: [UInt8], line: UInt = #line) { XCTAssertEqual(message.unknownFields.data, Data(bytes), line: line) } func test_MessageNoStorageClass() throws { - var msg1 = ProtobufUnittest_Msg3NoStorage() + var msg1 = SwiftProtoTesting_Msg3NoStorage() assertUnknownFields(msg1, []) - try msg1.merge(serializedData: Data([24, 1])) // Field 3, varint + try msg1.merge(serializedBytes: [24, 1]) // Field 3, varint assertUnknownFields(msg1, [24, 1]) var msg2 = msg1 assertUnknownFields(msg2, [24, 1]) assertUnknownFields(msg1, [24, 1]) - try msg2.merge(serializedData: Data([34, 1, 52])) // Field 4, length delimted + try msg2.merge(serializedBytes: [34, 1, 52]) // Field 4, length delimited assertUnknownFields(msg2, [24, 1, 34, 1, 52]) assertUnknownFields(msg1, [24, 1]) - try msg1.merge(serializedData: Data([61, 7, 0, 0, 0])) // Field 7, 32-bit value + try msg1.merge(serializedBytes: [61, 7, 0, 0, 0]) // Field 7, 32-bit value assertUnknownFields(msg2, [24, 1, 34, 1, 52]) assertUnknownFields(msg1, [24, 1, 61, 7, 0, 0, 0]) } func test_MessageUsingStorageClass() throws { - var msg1 = ProtobufUnittest_Msg3UsesStorage() + var msg1 = SwiftProtoTesting_Msg3UsesStorage() assertUnknownFields(msg1, []) - try msg1.merge(serializedData: Data([24, 1])) // Field 3, varint + try msg1.merge(serializedBytes: [24, 1]) // Field 3, varint assertUnknownFields(msg1, [24, 1]) var msg2 = msg1 assertUnknownFields(msg2, [24, 1]) assertUnknownFields(msg1, [24, 1]) - try msg2.merge(serializedData: Data([34, 1, 52])) // Field 4, length delimted + try msg2.merge(serializedBytes: [34, 1, 52]) // Field 4, length delimited assertUnknownFields(msg2, [24, 1, 34, 1, 52]) assertUnknownFields(msg1, [24, 1]) - try msg1.merge(serializedData: Data([61, 7, 0, 0, 0])) // Field 7, 32-bit value + try msg1.merge(serializedBytes: [61, 7, 0, 0, 0]) // Field 7, 32-bit value assertUnknownFields(msg2, [24, 1, 34, 1, 52]) assertUnknownFields(msg1, [24, 1, 61, 7, 0, 0, 0]) } diff --git a/Tests/SwiftProtobufTests/Test_Wrappers.swift b/Tests/SwiftProtobufTests/Test_Wrappers.swift index eda02d94d..0ce02293f 100644 --- a/Tests/SwiftProtobufTests/Test_Wrappers.swift +++ b/Tests/SwiftProtobufTests/Test_Wrappers.swift @@ -14,12 +14,10 @@ // ----------------------------------------------------------------------------- import Foundation -import XCTest import SwiftProtobuf +import XCTest -//TODO: Test Mirror functionality - -class Test_Wrappers: XCTestCase { +final class Test_Wrappers: XCTestCase { /// Asserts that decoding the JSON "null" literal for the given message type /// throws `illegalNull`. @@ -39,10 +37,11 @@ class Test_Wrappers: XCTestCase { XCTAssertEqual("0.0", try m.jsonString()) m.value = 1.0 XCTAssertEqual("1.0", try m.jsonString()) - XCTAssertEqual([9,0,0,0,0,0,0,240,63], try m.serializedBytes()) + XCTAssertEqual([9, 0, 0, 0, 0, 0, 0, 240, 63], try m.serializedBytes()) - let mw = try ProtobufTestMessages_Proto3_TestAllTypesProto3( - jsonString: "{\"optionalDoubleWrapper\":null}") + let mw = try SwiftProtoTesting_Test3_TestAllTypesProto3( + jsonString: "{\"optionalDoubleWrapper\":null}" + ) XCTAssertFalse(mw.hasOptionalDoubleWrapper) assertJSONDecodeNullFails(for: Google_Protobuf_DoubleValue.self) @@ -59,13 +58,13 @@ class Test_Wrappers: XCTestCase { XCTAssertEqual(m3.value, 1.0) // Use object equality to verify decode - XCTAssertEqual(m, try Google_Protobuf_DoubleValue(jsonString:"1.0")) - XCTAssertEqual(m2, try Google_Protobuf_DoubleValue(jsonString:"2")) - XCTAssertEqual(m, try Google_Protobuf_DoubleValue(serializedData: Data([9,0,0,0,0,0,0,240,63]))) + XCTAssertEqual(m, try Google_Protobuf_DoubleValue(jsonString: "1.0")) + XCTAssertEqual(m2, try Google_Protobuf_DoubleValue(jsonString: "2")) + XCTAssertEqual(m, try Google_Protobuf_DoubleValue(serializedBytes: [9, 0, 0, 0, 0, 0, 0, 240, 63])) // hash - XCTAssertEqual(m.hashValue, try Google_Protobuf_DoubleValue(jsonString:"1.0").hashValue) - XCTAssertNotEqual(m.hashValue, try Google_Protobuf_DoubleValue(jsonString:"1.1").hashValue) + XCTAssertEqual(m.hashValue, try Google_Protobuf_DoubleValue(jsonString: "1.0").hashValue) + XCTAssertNotEqual(m.hashValue, try Google_Protobuf_DoubleValue(jsonString: "1.1").hashValue) // TODO: Google documents that nulls are preserved; what does this mean? // TODO: Is Google_Protobuf_DoubleValue allowed to quote large numbers when serializing? @@ -77,10 +76,11 @@ class Test_Wrappers: XCTestCase { XCTAssertEqual("0.0", try m.jsonString()) m.value = 1.0 XCTAssertEqual("1.0", try m.jsonString()) - XCTAssertEqual([13,0,0,128,63], try m.serializedBytes()) + XCTAssertEqual([13, 0, 0, 128, 63], try m.serializedBytes()) - let mw = try ProtobufTestMessages_Proto3_TestAllTypesProto3( - jsonString: "{\"optionalFloatWrapper\":null}") + let mw = try SwiftProtoTesting_Test3_TestAllTypesProto3( + jsonString: "{\"optionalFloatWrapper\":null}" + ) XCTAssertFalse(mw.hasOptionalFloatWrapper) assertJSONDecodeNullFails(for: Google_Protobuf_FloatValue.self) @@ -95,19 +95,19 @@ class Test_Wrappers: XCTestCase { XCTAssertEqual(m3.value, 3.0) // Use object equality to verify decode - XCTAssertEqual(m, try Google_Protobuf_FloatValue(jsonString:"1.0")) - XCTAssertEqual(m2, try Google_Protobuf_FloatValue(jsonString:"2")) - XCTAssertEqual(m, try Google_Protobuf_FloatValue(serializedData: Data([13,0,0,128,63]))) + XCTAssertEqual(m, try Google_Protobuf_FloatValue(jsonString: "1.0")) + XCTAssertEqual(m2, try Google_Protobuf_FloatValue(jsonString: "2")) + XCTAssertEqual(m, try Google_Protobuf_FloatValue(serializedBytes: [13, 0, 0, 128, 63])) - XCTAssertThrowsError(try Google_Protobuf_FloatValue(jsonString:"-3.502823e+38")) - XCTAssertThrowsError(try Google_Protobuf_FloatValue(jsonString:"3.502823e+38")) + XCTAssertThrowsError(try Google_Protobuf_FloatValue(jsonString: "-3.502823e+38")) + XCTAssertThrowsError(try Google_Protobuf_FloatValue(jsonString: "3.502823e+38")) - XCTAssertEqual(try Google_Protobuf_FloatValue(jsonString:"-3.402823e+38"), -3.402823e+38) - XCTAssertEqual(try Google_Protobuf_FloatValue(jsonString:"3.402823e+38"), 3.402823e+38) + XCTAssertEqual(try Google_Protobuf_FloatValue(jsonString: "-3.402823e+38"), -3.402823e+38) + XCTAssertEqual(try Google_Protobuf_FloatValue(jsonString: "3.402823e+38"), 3.402823e+38) // hash - XCTAssertEqual(m.hashValue, try Google_Protobuf_FloatValue(jsonString:"1.0").hashValue) - XCTAssertNotEqual(m.hashValue, try Google_Protobuf_FloatValue(jsonString:"1.1").hashValue) + XCTAssertEqual(m.hashValue, try Google_Protobuf_FloatValue(jsonString: "1.0").hashValue) + XCTAssertNotEqual(m.hashValue, try Google_Protobuf_FloatValue(jsonString: "1.1").hashValue) // TODO: Google documents that nulls are preserved; what does this mean? // TODO: Is Google_Protobuf_FloatValue allowed to quote large numbers when serializing? @@ -120,18 +120,19 @@ class Test_Wrappers: XCTestCase { m.value = 777 let j2 = try m.jsonString() XCTAssertEqual("\"777\"", j2) - XCTAssertEqual([8,137,6], try m.serializedBytes()) + XCTAssertEqual([8, 137, 6], try m.serializedBytes()) // TODO: More - let mw = try ProtobufTestMessages_Proto3_TestAllTypesProto3( - jsonString: "{\"optionalInt64Wrapper\":null}") + let mw = try SwiftProtoTesting_Test3_TestAllTypesProto3( + jsonString: "{\"optionalInt64Wrapper\":null}" + ) XCTAssertFalse(mw.hasOptionalInt64Wrapper) assertJSONDecodeNullFails(for: Google_Protobuf_Int64Value.self) // hash - XCTAssertEqual(m.hashValue, try Google_Protobuf_Int64Value(jsonString:"777").hashValue) - XCTAssertNotEqual(m.hashValue, try Google_Protobuf_Int64Value(jsonString:"778").hashValue) + XCTAssertEqual(m.hashValue, try Google_Protobuf_Int64Value(jsonString: "777").hashValue) + XCTAssertNotEqual(m.hashValue, try Google_Protobuf_Int64Value(jsonString: "778").hashValue) } func testUInt64Value() throws { @@ -139,18 +140,19 @@ class Test_Wrappers: XCTestCase { XCTAssertEqual("\"0\"", try m.jsonString()) m.value = 777 XCTAssertEqual("\"777\"", try m.jsonString()) - XCTAssertEqual([8,137,6], try m.serializedBytes()) + XCTAssertEqual([8, 137, 6], try m.serializedBytes()) // TODO: More - let mw = try ProtobufTestMessages_Proto3_TestAllTypesProto3( - jsonString: "{\"optionalUint64Wrapper\":null}") + let mw = try SwiftProtoTesting_Test3_TestAllTypesProto3( + jsonString: "{\"optionalUint64Wrapper\":null}" + ) XCTAssertFalse(mw.hasOptionalUint64Wrapper) assertJSONDecodeNullFails(for: Google_Protobuf_UInt64Value.self) // hash - XCTAssertEqual(m.hashValue, try Google_Protobuf_UInt64Value(jsonString:"777").hashValue) - XCTAssertNotEqual(m.hashValue, try Google_Protobuf_UInt64Value(jsonString:"778").hashValue) + XCTAssertEqual(m.hashValue, try Google_Protobuf_UInt64Value(jsonString: "777").hashValue) + XCTAssertNotEqual(m.hashValue, try Google_Protobuf_UInt64Value(jsonString: "778").hashValue) } func testInt32Value() throws { @@ -158,18 +160,19 @@ class Test_Wrappers: XCTestCase { XCTAssertEqual("0", try m.jsonString()) m.value = 777 XCTAssertEqual("777", try m.jsonString()) - XCTAssertEqual([8,137,6], try m.serializedBytes()) + XCTAssertEqual([8, 137, 6], try m.serializedBytes()) // TODO: More - let mw = try ProtobufTestMessages_Proto3_TestAllTypesProto3( - jsonString: "{\"optionalInt32Wrapper\":null}") + let mw = try SwiftProtoTesting_Test3_TestAllTypesProto3( + jsonString: "{\"optionalInt32Wrapper\":null}" + ) XCTAssertFalse(mw.hasOptionalInt32Wrapper) assertJSONDecodeNullFails(for: Google_Protobuf_Int32Value.self) // hash - XCTAssertEqual(m.hashValue, try Google_Protobuf_Int32Value(jsonString:"777").hashValue) - XCTAssertNotEqual(m.hashValue, try Google_Protobuf_Int32Value(jsonString:"778").hashValue) + XCTAssertEqual(m.hashValue, try Google_Protobuf_Int32Value(jsonString: "777").hashValue) + XCTAssertNotEqual(m.hashValue, try Google_Protobuf_Int32Value(jsonString: "778").hashValue) } func testUInt32Value() throws { @@ -177,18 +180,19 @@ class Test_Wrappers: XCTestCase { XCTAssertEqual("0", try m.jsonString()) m.value = 777 XCTAssertEqual("777", try m.jsonString()) - XCTAssertEqual([8,137,6], try m.serializedBytes()) + XCTAssertEqual([8, 137, 6], try m.serializedBytes()) // TODO: More - let mw = try ProtobufTestMessages_Proto3_TestAllTypesProto3( - jsonString: "{\"optionalUint32Wrapper\":null}") + let mw = try SwiftProtoTesting_Test3_TestAllTypesProto3( + jsonString: "{\"optionalUint32Wrapper\":null}" + ) XCTAssertFalse(mw.hasOptionalUint32Wrapper) assertJSONDecodeNullFails(for: Google_Protobuf_UInt32Value.self) // hash - XCTAssertEqual(m.hashValue, try Google_Protobuf_UInt32Value(jsonString:"777").hashValue) - XCTAssertNotEqual(m.hashValue, try Google_Protobuf_UInt32Value(jsonString:"778").hashValue) + XCTAssertEqual(m.hashValue, try Google_Protobuf_UInt32Value(jsonString: "777").hashValue) + XCTAssertNotEqual(m.hashValue, try Google_Protobuf_UInt32Value(jsonString: "778").hashValue) } func testBoolValue() throws { @@ -196,18 +200,19 @@ class Test_Wrappers: XCTestCase { XCTAssertEqual("false", try m.jsonString()) m.value = true XCTAssertEqual("true", try m.jsonString()) - XCTAssertEqual([8,1], try m.serializedBytes()) + XCTAssertEqual([8, 1], try m.serializedBytes()) // TODO: More - let mw = try ProtobufTestMessages_Proto3_TestAllTypesProto3( - jsonString: "{\"optionalBoolWrapper\":null}") + let mw = try SwiftProtoTesting_Test3_TestAllTypesProto3( + jsonString: "{\"optionalBoolWrapper\":null}" + ) XCTAssertFalse(mw.hasOptionalBoolWrapper) assertJSONDecodeNullFails(for: Google_Protobuf_BoolValue.self) // hash - XCTAssertEqual(m.hashValue, try Google_Protobuf_BoolValue(jsonString:"true").hashValue) - XCTAssertNotEqual(m.hashValue, try Google_Protobuf_BoolValue(jsonString:"false").hashValue) + XCTAssertEqual(m.hashValue, try Google_Protobuf_BoolValue(jsonString: "true").hashValue) + XCTAssertNotEqual(m.hashValue, try Google_Protobuf_BoolValue(jsonString: "false").hashValue) } func testStringValue() throws { @@ -215,22 +220,29 @@ class Test_Wrappers: XCTestCase { XCTAssertEqual("\"\"", try m.jsonString()) m.value = "abc" XCTAssertEqual("\"abc\"", try m.jsonString()) - XCTAssertEqual([10,3,97,98,99], try m.serializedBytes()) + XCTAssertEqual([10, 3, 97, 98, 99], try m.serializedBytes()) // TODO: More - let mw = try ProtobufTestMessages_Proto3_TestAllTypesProto3( - jsonString: "{\"optionalStringWrapper\":null}") + let mw = try SwiftProtoTesting_Test3_TestAllTypesProto3( + jsonString: "{\"optionalStringWrapper\":null}" + ) XCTAssertFalse(mw.hasOptionalStringWrapper) assertJSONDecodeNullFails(for: Google_Protobuf_StringValue.self) XCTAssertThrowsError(try Google_Protobuf_StringValue(jsonString: "\"\\UABCD\"")) - XCTAssertEqual(try Google_Protobuf_StringValue(jsonString: "\"\\uABCD\""), Google_Protobuf_StringValue("\u{ABCD}")) - XCTAssertEqual(try Google_Protobuf_StringValue(jsonString: "\"\\\"\\\\\\/\\b\\f\\n\\r\\t\""), Google_Protobuf_StringValue("\"\\/\u{08}\u{0c}\n\r\t")) + XCTAssertEqual( + try Google_Protobuf_StringValue(jsonString: "\"\\uABCD\""), + Google_Protobuf_StringValue("\u{ABCD}") + ) + XCTAssertEqual( + try Google_Protobuf_StringValue(jsonString: "\"\\\"\\\\\\/\\b\\f\\n\\r\\t\""), + Google_Protobuf_StringValue("\"\\/\u{08}\u{0c}\n\r\t") + ) // hash - XCTAssertEqual(m.hashValue, try Google_Protobuf_StringValue(jsonString:"\"abc\"").hashValue) - XCTAssertNotEqual(m.hashValue, try Google_Protobuf_StringValue(jsonString:"\"def\"").hashValue) + XCTAssertEqual(m.hashValue, try Google_Protobuf_StringValue(jsonString: "\"abc\"").hashValue) + XCTAssertNotEqual(m.hashValue, try Google_Protobuf_StringValue(jsonString: "\"def\"").hashValue) } func testBytesValue() throws { @@ -238,17 +250,18 @@ class Test_Wrappers: XCTestCase { XCTAssertEqual("\"\"", try m.jsonString()) m.value = Data([0, 1, 2]) XCTAssertEqual("\"AAEC\"", try m.jsonString()) - XCTAssertEqual([10,3,0,1,2], try m.serializedBytes()) + XCTAssertEqual([10, 3, 0, 1, 2], try m.serializedBytes()) // TODO: More - let mw = try ProtobufTestMessages_Proto3_TestAllTypesProto3( - jsonString: "{\"optionalBytesWrapper\":null}") + let mw = try SwiftProtoTesting_Test3_TestAllTypesProto3( + jsonString: "{\"optionalBytesWrapper\":null}" + ) XCTAssertFalse(mw.hasOptionalBytesWrapper) assertJSONDecodeNullFails(for: Google_Protobuf_BytesValue.self) // hash - XCTAssertEqual(m.hashValue, try Google_Protobuf_BytesValue(jsonString:"\"AAEC\"").hashValue) - XCTAssertNotEqual(m.hashValue, try Google_Protobuf_BytesValue(jsonString:"\"AAED\"").hashValue) + XCTAssertEqual(m.hashValue, try Google_Protobuf_BytesValue(jsonString: "\"AAEC\"").hashValue) + XCTAssertNotEqual(m.hashValue, try Google_Protobuf_BytesValue(jsonString: "\"AAED\"").hashValue) } } diff --git a/Tests/SwiftProtobufTests/any_test.pb.swift b/Tests/SwiftProtobufTests/any_test.pb.swift index dc142da9b..fd4633d3f 100644 --- a/Tests/SwiftProtobufTests/any_test.pb.swift +++ b/Tests/SwiftProtobufTests/any_test.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/any_test.proto +// Source: any_test.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -37,7 +38,6 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -50,7 +50,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_TestAny { +struct SwiftProtoTesting_TestAny: Sendable { // 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. @@ -58,11 +58,11 @@ struct ProtobufUnittest_TestAny { var int32Value: Int32 = 0 var anyValue: SwiftProtobuf.Google_Protobuf_Any { - get {return _anyValue ?? SwiftProtobuf.Google_Protobuf_Any()} + get {_anyValue ?? SwiftProtobuf.Google_Protobuf_Any()} set {_anyValue = newValue} } /// Returns true if `anyValue` has been explicitly set. - var hasAnyValue: Bool {return self._anyValue != nil} + var hasAnyValue: Bool {self._anyValue != nil} /// Clears the value of `anyValue`. Subsequent reads from it will return its default value. mutating func clearAnyValue() {self._anyValue = nil} @@ -77,22 +77,13 @@ struct ProtobufUnittest_TestAny { fileprivate var _anyValue: SwiftProtobuf.Google_Protobuf_Any? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_TestAny: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_TestAny: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_TestAny: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestAny" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "int32_value"), - 2: .standard(proto: "any_value"), - 3: .standard(proto: "repeated_any_value"), - 4: .same(proto: "text"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}int32_value\0\u{3}any_value\0\u{3}repeated_any_value\0\u{1}text\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -129,7 +120,7 @@ extension ProtobufUnittest_TestAny: SwiftProtobuf.Message, SwiftProtobuf._Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestAny, rhs: ProtobufUnittest_TestAny) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestAny, rhs: SwiftProtoTesting_TestAny) -> Bool { if lhs.int32Value != rhs.int32Value {return false} if lhs._anyValue != rhs._anyValue {return false} if lhs.repeatedAnyValue != rhs.repeatedAnyValue {return false} diff --git a/Tests/SwiftProtobufTests/fuzz_testing.pb.swift b/Tests/SwiftProtobufTests/fuzz_testing.pb.swift index 992e746d6..9184d28e4 100644 --- a/Tests/SwiftProtobufTests/fuzz_testing.pb.swift +++ b/Tests/SwiftProtobufTests/fuzz_testing.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: fuzz_testing.proto @@ -34,302 +35,274 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum Fuzz_Testing_AnEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case zero // = 0 - case one // = 1 - case two // = 2 - case three // = 3 +enum SwiftProtoTesting_Fuzz_AnEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case zero = 0 + case one = 1 + case two = 2 + case three = 3 init() { self = .zero } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .zero - case 1: self = .one - case 2: self = .two - case 3: self = .three - default: return nil - } - } - - var rawValue: Int { - switch self { - case .zero: return 0 - case .one: return 1 - case .two: return 2 - case .three: return 3 - } - } - -} - -#if swift(>=4.2) - -extension Fuzz_Testing_AnEnum: CaseIterable { - // Support synthesized by the compiler. } -#endif // swift(>=4.2) - -struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Fuzz_Message: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { // 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. /// Singular var singularInt32: Int32 { - get {return _storage._singularInt32 ?? 0} + get {_storage._singularInt32 ?? 0} set {_uniqueStorage()._singularInt32 = newValue} } /// Returns true if `singularInt32` has been explicitly set. - var hasSingularInt32: Bool {return _storage._singularInt32 != nil} + var hasSingularInt32: Bool {_storage._singularInt32 != nil} /// Clears the value of `singularInt32`. Subsequent reads from it will return its default value. mutating func clearSingularInt32() {_uniqueStorage()._singularInt32 = nil} var singularInt64: Int64 { - get {return _storage._singularInt64 ?? 0} + get {_storage._singularInt64 ?? 0} set {_uniqueStorage()._singularInt64 = newValue} } /// Returns true if `singularInt64` has been explicitly set. - var hasSingularInt64: Bool {return _storage._singularInt64 != nil} + var hasSingularInt64: Bool {_storage._singularInt64 != nil} /// Clears the value of `singularInt64`. Subsequent reads from it will return its default value. mutating func clearSingularInt64() {_uniqueStorage()._singularInt64 = nil} var singularUint32: UInt32 { - get {return _storage._singularUint32 ?? 0} + get {_storage._singularUint32 ?? 0} set {_uniqueStorage()._singularUint32 = newValue} } /// Returns true if `singularUint32` has been explicitly set. - var hasSingularUint32: Bool {return _storage._singularUint32 != nil} + var hasSingularUint32: Bool {_storage._singularUint32 != nil} /// Clears the value of `singularUint32`. Subsequent reads from it will return its default value. mutating func clearSingularUint32() {_uniqueStorage()._singularUint32 = nil} var singularUint64: UInt64 { - get {return _storage._singularUint64 ?? 0} + get {_storage._singularUint64 ?? 0} set {_uniqueStorage()._singularUint64 = newValue} } /// Returns true if `singularUint64` has been explicitly set. - var hasSingularUint64: Bool {return _storage._singularUint64 != nil} + var hasSingularUint64: Bool {_storage._singularUint64 != nil} /// Clears the value of `singularUint64`. Subsequent reads from it will return its default value. mutating func clearSingularUint64() {_uniqueStorage()._singularUint64 = nil} var singularSint32: Int32 { - get {return _storage._singularSint32 ?? 0} + get {_storage._singularSint32 ?? 0} set {_uniqueStorage()._singularSint32 = newValue} } /// Returns true if `singularSint32` has been explicitly set. - var hasSingularSint32: Bool {return _storage._singularSint32 != nil} + var hasSingularSint32: Bool {_storage._singularSint32 != nil} /// Clears the value of `singularSint32`. Subsequent reads from it will return its default value. mutating func clearSingularSint32() {_uniqueStorage()._singularSint32 = nil} var singularSint64: Int64 { - get {return _storage._singularSint64 ?? 0} + get {_storage._singularSint64 ?? 0} set {_uniqueStorage()._singularSint64 = newValue} } /// Returns true if `singularSint64` has been explicitly set. - var hasSingularSint64: Bool {return _storage._singularSint64 != nil} + var hasSingularSint64: Bool {_storage._singularSint64 != nil} /// Clears the value of `singularSint64`. Subsequent reads from it will return its default value. mutating func clearSingularSint64() {_uniqueStorage()._singularSint64 = nil} var singularFixed32: UInt32 { - get {return _storage._singularFixed32 ?? 0} + get {_storage._singularFixed32 ?? 0} set {_uniqueStorage()._singularFixed32 = newValue} } /// Returns true if `singularFixed32` has been explicitly set. - var hasSingularFixed32: Bool {return _storage._singularFixed32 != nil} + var hasSingularFixed32: Bool {_storage._singularFixed32 != nil} /// Clears the value of `singularFixed32`. Subsequent reads from it will return its default value. mutating func clearSingularFixed32() {_uniqueStorage()._singularFixed32 = nil} var singularFixed64: UInt64 { - get {return _storage._singularFixed64 ?? 0} + get {_storage._singularFixed64 ?? 0} set {_uniqueStorage()._singularFixed64 = newValue} } /// Returns true if `singularFixed64` has been explicitly set. - var hasSingularFixed64: Bool {return _storage._singularFixed64 != nil} + var hasSingularFixed64: Bool {_storage._singularFixed64 != nil} /// Clears the value of `singularFixed64`. Subsequent reads from it will return its default value. mutating func clearSingularFixed64() {_uniqueStorage()._singularFixed64 = nil} var singularSfixed32: Int32 { - get {return _storage._singularSfixed32 ?? 0} + get {_storage._singularSfixed32 ?? 0} set {_uniqueStorage()._singularSfixed32 = newValue} } /// Returns true if `singularSfixed32` has been explicitly set. - var hasSingularSfixed32: Bool {return _storage._singularSfixed32 != nil} + var hasSingularSfixed32: Bool {_storage._singularSfixed32 != nil} /// Clears the value of `singularSfixed32`. Subsequent reads from it will return its default value. mutating func clearSingularSfixed32() {_uniqueStorage()._singularSfixed32 = nil} var singularSfixed64: Int64 { - get {return _storage._singularSfixed64 ?? 0} + get {_storage._singularSfixed64 ?? 0} set {_uniqueStorage()._singularSfixed64 = newValue} } /// Returns true if `singularSfixed64` has been explicitly set. - var hasSingularSfixed64: Bool {return _storage._singularSfixed64 != nil} + var hasSingularSfixed64: Bool {_storage._singularSfixed64 != nil} /// Clears the value of `singularSfixed64`. Subsequent reads from it will return its default value. mutating func clearSingularSfixed64() {_uniqueStorage()._singularSfixed64 = nil} var singularFloat: Float { - get {return _storage._singularFloat ?? 0} + get {_storage._singularFloat ?? 0} set {_uniqueStorage()._singularFloat = newValue} } /// Returns true if `singularFloat` has been explicitly set. - var hasSingularFloat: Bool {return _storage._singularFloat != nil} + var hasSingularFloat: Bool {_storage._singularFloat != nil} /// Clears the value of `singularFloat`. Subsequent reads from it will return its default value. mutating func clearSingularFloat() {_uniqueStorage()._singularFloat = nil} var singularDouble: Double { - get {return _storage._singularDouble ?? 0} + get {_storage._singularDouble ?? 0} set {_uniqueStorage()._singularDouble = newValue} } /// Returns true if `singularDouble` has been explicitly set. - var hasSingularDouble: Bool {return _storage._singularDouble != nil} + var hasSingularDouble: Bool {_storage._singularDouble != nil} /// Clears the value of `singularDouble`. Subsequent reads from it will return its default value. mutating func clearSingularDouble() {_uniqueStorage()._singularDouble = nil} var singularBool: Bool { - get {return _storage._singularBool ?? false} + get {_storage._singularBool ?? false} set {_uniqueStorage()._singularBool = newValue} } /// Returns true if `singularBool` has been explicitly set. - var hasSingularBool: Bool {return _storage._singularBool != nil} + var hasSingularBool: Bool {_storage._singularBool != nil} /// Clears the value of `singularBool`. Subsequent reads from it will return its default value. mutating func clearSingularBool() {_uniqueStorage()._singularBool = nil} var singularString: String { - get {return _storage._singularString ?? String()} + get {_storage._singularString ?? String()} set {_uniqueStorage()._singularString = newValue} } /// Returns true if `singularString` has been explicitly set. - var hasSingularString: Bool {return _storage._singularString != nil} + var hasSingularString: Bool {_storage._singularString != nil} /// Clears the value of `singularString`. Subsequent reads from it will return its default value. mutating func clearSingularString() {_uniqueStorage()._singularString = nil} var singularBytes: Data { - get {return _storage._singularBytes ?? Data()} + get {_storage._singularBytes ?? Data()} set {_uniqueStorage()._singularBytes = newValue} } /// Returns true if `singularBytes` has been explicitly set. - var hasSingularBytes: Bool {return _storage._singularBytes != nil} + var hasSingularBytes: Bool {_storage._singularBytes != nil} /// Clears the value of `singularBytes`. Subsequent reads from it will return its default value. mutating func clearSingularBytes() {_uniqueStorage()._singularBytes = nil} - var singularEnum: Fuzz_Testing_AnEnum { - get {return _storage._singularEnum ?? .zero} + var singularEnum: SwiftProtoTesting_Fuzz_AnEnum { + get {_storage._singularEnum ?? .zero} set {_uniqueStorage()._singularEnum = newValue} } /// Returns true if `singularEnum` has been explicitly set. - var hasSingularEnum: Bool {return _storage._singularEnum != nil} + var hasSingularEnum: Bool {_storage._singularEnum != nil} /// Clears the value of `singularEnum`. Subsequent reads from it will return its default value. mutating func clearSingularEnum() {_uniqueStorage()._singularEnum = nil} - var singularGroup: Fuzz_Testing_Message.SingularGroup { - get {return _storage._singularGroup ?? Fuzz_Testing_Message.SingularGroup()} + var singularGroup: SwiftProtoTesting_Fuzz_Message.SingularGroup { + get {_storage._singularGroup ?? SwiftProtoTesting_Fuzz_Message.SingularGroup()} set {_uniqueStorage()._singularGroup = newValue} } /// Returns true if `singularGroup` has been explicitly set. - var hasSingularGroup: Bool {return _storage._singularGroup != nil} + var hasSingularGroup: Bool {_storage._singularGroup != nil} /// Clears the value of `singularGroup`. Subsequent reads from it will return its default value. mutating func clearSingularGroup() {_uniqueStorage()._singularGroup = nil} - var singularMessage: Fuzz_Testing_Message { - get {return _storage._singularMessage ?? Fuzz_Testing_Message()} + var singularMessage: SwiftProtoTesting_Fuzz_Message { + get {_storage._singularMessage ?? SwiftProtoTesting_Fuzz_Message()} set {_uniqueStorage()._singularMessage = newValue} } /// Returns true if `singularMessage` has been explicitly set. - var hasSingularMessage: Bool {return _storage._singularMessage != nil} + var hasSingularMessage: Bool {_storage._singularMessage != nil} /// Clears the value of `singularMessage`. Subsequent reads from it will return its default value. mutating func clearSingularMessage() {_uniqueStorage()._singularMessage = nil} /// Repeated var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } - var repeatedEnum: [Fuzz_Testing_AnEnum] { - get {return _storage._repeatedEnum} + var repeatedEnum: [SwiftProtoTesting_Fuzz_AnEnum] { + get {_storage._repeatedEnum} set {_uniqueStorage()._repeatedEnum = newValue} } - var repeatedGroup: [Fuzz_Testing_Message.RepeatedGroup] { - get {return _storage._repeatedGroup} + var repeatedGroup: [SwiftProtoTesting_Fuzz_Message.RepeatedGroup] { + get {_storage._repeatedGroup} set {_uniqueStorage()._repeatedGroup = newValue} } - var repeatedMessage: [Fuzz_Testing_Message] { - get {return _storage._repeatedMessage} + var repeatedMessage: [SwiftProtoTesting_Fuzz_Message] { + get {_storage._repeatedMessage} set {_uniqueStorage()._repeatedMessage = newValue} } @@ -459,7 +432,7 @@ struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { set {_uniqueStorage()._o = .oneofBytes(newValue)} } - var oneofEnum: Fuzz_Testing_AnEnum { + var oneofEnum: SwiftProtoTesting_Fuzz_AnEnum { get { if case .oneofEnum(let v)? = _storage._o {return v} return .zero @@ -467,1211 +440,1211 @@ struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { set {_uniqueStorage()._o = .oneofEnum(newValue)} } - var oneofGroup: Fuzz_Testing_Message.OneofGroup { + var oneofGroup: SwiftProtoTesting_Fuzz_Message.OneofGroup { get { if case .oneofGroup(let v)? = _storage._o {return v} - return Fuzz_Testing_Message.OneofGroup() + return SwiftProtoTesting_Fuzz_Message.OneofGroup() } set {_uniqueStorage()._o = .oneofGroup(newValue)} } - var oneofMessage: Fuzz_Testing_Message { + var oneofMessage: SwiftProtoTesting_Fuzz_Message { get { if case .oneofMessage(let v)? = _storage._o {return v} - return Fuzz_Testing_Message() + return SwiftProtoTesting_Fuzz_Message() } set {_uniqueStorage()._o = .oneofMessage(newValue)} } /// Repeated Packed var repeatedPackedInt32: [Int32] { - get {return _storage._repeatedPackedInt32} + get {_storage._repeatedPackedInt32} set {_uniqueStorage()._repeatedPackedInt32 = newValue} } var repeatedPackedInt64: [Int64] { - get {return _storage._repeatedPackedInt64} + get {_storage._repeatedPackedInt64} set {_uniqueStorage()._repeatedPackedInt64 = newValue} } var repeatedPackedUint32: [UInt32] { - get {return _storage._repeatedPackedUint32} + get {_storage._repeatedPackedUint32} set {_uniqueStorage()._repeatedPackedUint32 = newValue} } var repeatedPackedUint64: [UInt64] { - get {return _storage._repeatedPackedUint64} + get {_storage._repeatedPackedUint64} set {_uniqueStorage()._repeatedPackedUint64 = newValue} } var repeatedPackedSint32: [Int32] { - get {return _storage._repeatedPackedSint32} + get {_storage._repeatedPackedSint32} set {_uniqueStorage()._repeatedPackedSint32 = newValue} } var repeatedPackedSint64: [Int64] { - get {return _storage._repeatedPackedSint64} + get {_storage._repeatedPackedSint64} set {_uniqueStorage()._repeatedPackedSint64 = newValue} } var repeatedPackedFixed32: [UInt32] { - get {return _storage._repeatedPackedFixed32} + get {_storage._repeatedPackedFixed32} set {_uniqueStorage()._repeatedPackedFixed32 = newValue} } var repeatedPackedFixed64: [UInt64] { - get {return _storage._repeatedPackedFixed64} + get {_storage._repeatedPackedFixed64} set {_uniqueStorage()._repeatedPackedFixed64 = newValue} } var repeatedPackedSfixed32: [Int32] { - get {return _storage._repeatedPackedSfixed32} + get {_storage._repeatedPackedSfixed32} set {_uniqueStorage()._repeatedPackedSfixed32 = newValue} } var repeatedPackedSfixed64: [Int64] { - get {return _storage._repeatedPackedSfixed64} + get {_storage._repeatedPackedSfixed64} set {_uniqueStorage()._repeatedPackedSfixed64 = newValue} } var repeatedPackedFloat: [Float] { - get {return _storage._repeatedPackedFloat} + get {_storage._repeatedPackedFloat} set {_uniqueStorage()._repeatedPackedFloat = newValue} } var repeatedPackedDouble: [Double] { - get {return _storage._repeatedPackedDouble} + get {_storage._repeatedPackedDouble} set {_uniqueStorage()._repeatedPackedDouble = newValue} } var repeatedPackedBool: [Bool] { - get {return _storage._repeatedPackedBool} + get {_storage._repeatedPackedBool} set {_uniqueStorage()._repeatedPackedBool = newValue} } - var repeatedPackedEnum: [Fuzz_Testing_AnEnum] { - get {return _storage._repeatedPackedEnum} + var repeatedPackedEnum: [SwiftProtoTesting_Fuzz_AnEnum] { + get {_storage._repeatedPackedEnum} set {_uniqueStorage()._repeatedPackedEnum = newValue} } /// map<> var mapInt32Int32: Dictionary { - get {return _storage._mapInt32Int32} + get {_storage._mapInt32Int32} set {_uniqueStorage()._mapInt32Int32 = newValue} } var mapInt32Int64: Dictionary { - get {return _storage._mapInt32Int64} + get {_storage._mapInt32Int64} set {_uniqueStorage()._mapInt32Int64 = newValue} } var mapInt32Uint32: Dictionary { - get {return _storage._mapInt32Uint32} + get {_storage._mapInt32Uint32} set {_uniqueStorage()._mapInt32Uint32 = newValue} } var mapInt32Uint64: Dictionary { - get {return _storage._mapInt32Uint64} + get {_storage._mapInt32Uint64} set {_uniqueStorage()._mapInt32Uint64 = newValue} } var mapInt32Sint32: Dictionary { - get {return _storage._mapInt32Sint32} + get {_storage._mapInt32Sint32} set {_uniqueStorage()._mapInt32Sint32 = newValue} } var mapInt32Sint64: Dictionary { - get {return _storage._mapInt32Sint64} + get {_storage._mapInt32Sint64} set {_uniqueStorage()._mapInt32Sint64 = newValue} } var mapInt32Fixed32: Dictionary { - get {return _storage._mapInt32Fixed32} + get {_storage._mapInt32Fixed32} set {_uniqueStorage()._mapInt32Fixed32 = newValue} } var mapInt32Fixed64: Dictionary { - get {return _storage._mapInt32Fixed64} + get {_storage._mapInt32Fixed64} set {_uniqueStorage()._mapInt32Fixed64 = newValue} } var mapInt32Sfixed32: Dictionary { - get {return _storage._mapInt32Sfixed32} + get {_storage._mapInt32Sfixed32} set {_uniqueStorage()._mapInt32Sfixed32 = newValue} } var mapInt32Sfixed64: Dictionary { - get {return _storage._mapInt32Sfixed64} + get {_storage._mapInt32Sfixed64} set {_uniqueStorage()._mapInt32Sfixed64 = newValue} } var mapInt32Float: Dictionary { - get {return _storage._mapInt32Float} + get {_storage._mapInt32Float} set {_uniqueStorage()._mapInt32Float = newValue} } var mapInt32Double: Dictionary { - get {return _storage._mapInt32Double} + get {_storage._mapInt32Double} set {_uniqueStorage()._mapInt32Double = newValue} } var mapInt32Bool: Dictionary { - get {return _storage._mapInt32Bool} + get {_storage._mapInt32Bool} set {_uniqueStorage()._mapInt32Bool = newValue} } var mapInt32String: Dictionary { - get {return _storage._mapInt32String} + get {_storage._mapInt32String} set {_uniqueStorage()._mapInt32String = newValue} } var mapInt32Bytes: Dictionary { - get {return _storage._mapInt32Bytes} + get {_storage._mapInt32Bytes} set {_uniqueStorage()._mapInt32Bytes = newValue} } - var mapInt32AnEnum: Dictionary { - get {return _storage._mapInt32AnEnum} + var mapInt32AnEnum: Dictionary { + get {_storage._mapInt32AnEnum} set {_uniqueStorage()._mapInt32AnEnum = newValue} } - var mapInt32Message: Dictionary { - get {return _storage._mapInt32Message} + var mapInt32Message: Dictionary { + get {_storage._mapInt32Message} set {_uniqueStorage()._mapInt32Message = newValue} } var mapInt64Int32: Dictionary { - get {return _storage._mapInt64Int32} + get {_storage._mapInt64Int32} set {_uniqueStorage()._mapInt64Int32 = newValue} } var mapInt64Int64: Dictionary { - get {return _storage._mapInt64Int64} + get {_storage._mapInt64Int64} set {_uniqueStorage()._mapInt64Int64 = newValue} } var mapInt64Uint32: Dictionary { - get {return _storage._mapInt64Uint32} + get {_storage._mapInt64Uint32} set {_uniqueStorage()._mapInt64Uint32 = newValue} } var mapInt64Uint64: Dictionary { - get {return _storage._mapInt64Uint64} + get {_storage._mapInt64Uint64} set {_uniqueStorage()._mapInt64Uint64 = newValue} } var mapInt64Sint32: Dictionary { - get {return _storage._mapInt64Sint32} + get {_storage._mapInt64Sint32} set {_uniqueStorage()._mapInt64Sint32 = newValue} } var mapInt64Sint64: Dictionary { - get {return _storage._mapInt64Sint64} + get {_storage._mapInt64Sint64} set {_uniqueStorage()._mapInt64Sint64 = newValue} } var mapInt64Fixed32: Dictionary { - get {return _storage._mapInt64Fixed32} + get {_storage._mapInt64Fixed32} set {_uniqueStorage()._mapInt64Fixed32 = newValue} } var mapInt64Fixed64: Dictionary { - get {return _storage._mapInt64Fixed64} + get {_storage._mapInt64Fixed64} set {_uniqueStorage()._mapInt64Fixed64 = newValue} } var mapInt64Sfixed32: Dictionary { - get {return _storage._mapInt64Sfixed32} + get {_storage._mapInt64Sfixed32} set {_uniqueStorage()._mapInt64Sfixed32 = newValue} } var mapInt64Sfixed64: Dictionary { - get {return _storage._mapInt64Sfixed64} + get {_storage._mapInt64Sfixed64} set {_uniqueStorage()._mapInt64Sfixed64 = newValue} } var mapInt64Float: Dictionary { - get {return _storage._mapInt64Float} + get {_storage._mapInt64Float} set {_uniqueStorage()._mapInt64Float = newValue} } var mapInt64Double: Dictionary { - get {return _storage._mapInt64Double} + get {_storage._mapInt64Double} set {_uniqueStorage()._mapInt64Double = newValue} } var mapInt64Bool: Dictionary { - get {return _storage._mapInt64Bool} + get {_storage._mapInt64Bool} set {_uniqueStorage()._mapInt64Bool = newValue} } var mapInt64String: Dictionary { - get {return _storage._mapInt64String} + get {_storage._mapInt64String} set {_uniqueStorage()._mapInt64String = newValue} } var mapInt64Bytes: Dictionary { - get {return _storage._mapInt64Bytes} + get {_storage._mapInt64Bytes} set {_uniqueStorage()._mapInt64Bytes = newValue} } - var mapInt64AnEnum: Dictionary { - get {return _storage._mapInt64AnEnum} + var mapInt64AnEnum: Dictionary { + get {_storage._mapInt64AnEnum} set {_uniqueStorage()._mapInt64AnEnum = newValue} } - var mapInt64Message: Dictionary { - get {return _storage._mapInt64Message} + var mapInt64Message: Dictionary { + get {_storage._mapInt64Message} set {_uniqueStorage()._mapInt64Message = newValue} } var mapUint32Int32: Dictionary { - get {return _storage._mapUint32Int32} + get {_storage._mapUint32Int32} set {_uniqueStorage()._mapUint32Int32 = newValue} } var mapUint32Int64: Dictionary { - get {return _storage._mapUint32Int64} + get {_storage._mapUint32Int64} set {_uniqueStorage()._mapUint32Int64 = newValue} } var mapUint32Uint32: Dictionary { - get {return _storage._mapUint32Uint32} + get {_storage._mapUint32Uint32} set {_uniqueStorage()._mapUint32Uint32 = newValue} } var mapUint32Uint64: Dictionary { - get {return _storage._mapUint32Uint64} + get {_storage._mapUint32Uint64} set {_uniqueStorage()._mapUint32Uint64 = newValue} } var mapUint32Sint32: Dictionary { - get {return _storage._mapUint32Sint32} + get {_storage._mapUint32Sint32} set {_uniqueStorage()._mapUint32Sint32 = newValue} } var mapUint32Sint64: Dictionary { - get {return _storage._mapUint32Sint64} + get {_storage._mapUint32Sint64} set {_uniqueStorage()._mapUint32Sint64 = newValue} } var mapUint32Fixed32: Dictionary { - get {return _storage._mapUint32Fixed32} + get {_storage._mapUint32Fixed32} set {_uniqueStorage()._mapUint32Fixed32 = newValue} } var mapUint32Fixed64: Dictionary { - get {return _storage._mapUint32Fixed64} + get {_storage._mapUint32Fixed64} set {_uniqueStorage()._mapUint32Fixed64 = newValue} } var mapUint32Sfixed32: Dictionary { - get {return _storage._mapUint32Sfixed32} + get {_storage._mapUint32Sfixed32} set {_uniqueStorage()._mapUint32Sfixed32 = newValue} } var mapUint32Sfixed64: Dictionary { - get {return _storage._mapUint32Sfixed64} + get {_storage._mapUint32Sfixed64} set {_uniqueStorage()._mapUint32Sfixed64 = newValue} } var mapUint32Float: Dictionary { - get {return _storage._mapUint32Float} + get {_storage._mapUint32Float} set {_uniqueStorage()._mapUint32Float = newValue} } var mapUint32Double: Dictionary { - get {return _storage._mapUint32Double} + get {_storage._mapUint32Double} set {_uniqueStorage()._mapUint32Double = newValue} } var mapUint32Bool: Dictionary { - get {return _storage._mapUint32Bool} + get {_storage._mapUint32Bool} set {_uniqueStorage()._mapUint32Bool = newValue} } var mapUint32String: Dictionary { - get {return _storage._mapUint32String} + get {_storage._mapUint32String} set {_uniqueStorage()._mapUint32String = newValue} } var mapUint32Bytes: Dictionary { - get {return _storage._mapUint32Bytes} + get {_storage._mapUint32Bytes} set {_uniqueStorage()._mapUint32Bytes = newValue} } - var mapUint32AnEnum: Dictionary { - get {return _storage._mapUint32AnEnum} + var mapUint32AnEnum: Dictionary { + get {_storage._mapUint32AnEnum} set {_uniqueStorage()._mapUint32AnEnum = newValue} } - var mapUint32Message: Dictionary { - get {return _storage._mapUint32Message} + var mapUint32Message: Dictionary { + get {_storage._mapUint32Message} set {_uniqueStorage()._mapUint32Message = newValue} } var mapUint64Int32: Dictionary { - get {return _storage._mapUint64Int32} + get {_storage._mapUint64Int32} set {_uniqueStorage()._mapUint64Int32 = newValue} } var mapUint64Int64: Dictionary { - get {return _storage._mapUint64Int64} + get {_storage._mapUint64Int64} set {_uniqueStorage()._mapUint64Int64 = newValue} } var mapUint64Uint32: Dictionary { - get {return _storage._mapUint64Uint32} + get {_storage._mapUint64Uint32} set {_uniqueStorage()._mapUint64Uint32 = newValue} } var mapUint64Uint64: Dictionary { - get {return _storage._mapUint64Uint64} + get {_storage._mapUint64Uint64} set {_uniqueStorage()._mapUint64Uint64 = newValue} } var mapUint64Sint32: Dictionary { - get {return _storage._mapUint64Sint32} + get {_storage._mapUint64Sint32} set {_uniqueStorage()._mapUint64Sint32 = newValue} } var mapUint64Sint64: Dictionary { - get {return _storage._mapUint64Sint64} + get {_storage._mapUint64Sint64} set {_uniqueStorage()._mapUint64Sint64 = newValue} } var mapUint64Fixed32: Dictionary { - get {return _storage._mapUint64Fixed32} + get {_storage._mapUint64Fixed32} set {_uniqueStorage()._mapUint64Fixed32 = newValue} } var mapUint64Fixed64: Dictionary { - get {return _storage._mapUint64Fixed64} + get {_storage._mapUint64Fixed64} set {_uniqueStorage()._mapUint64Fixed64 = newValue} } var mapUint64Sfixed32: Dictionary { - get {return _storage._mapUint64Sfixed32} + get {_storage._mapUint64Sfixed32} set {_uniqueStorage()._mapUint64Sfixed32 = newValue} } var mapUint64Sfixed64: Dictionary { - get {return _storage._mapUint64Sfixed64} + get {_storage._mapUint64Sfixed64} set {_uniqueStorage()._mapUint64Sfixed64 = newValue} } var mapUint64Float: Dictionary { - get {return _storage._mapUint64Float} + get {_storage._mapUint64Float} set {_uniqueStorage()._mapUint64Float = newValue} } var mapUint64Double: Dictionary { - get {return _storage._mapUint64Double} + get {_storage._mapUint64Double} set {_uniqueStorage()._mapUint64Double = newValue} } var mapUint64Bool: Dictionary { - get {return _storage._mapUint64Bool} + get {_storage._mapUint64Bool} set {_uniqueStorage()._mapUint64Bool = newValue} } var mapUint64String: Dictionary { - get {return _storage._mapUint64String} + get {_storage._mapUint64String} set {_uniqueStorage()._mapUint64String = newValue} } var mapUint64Bytes: Dictionary { - get {return _storage._mapUint64Bytes} + get {_storage._mapUint64Bytes} set {_uniqueStorage()._mapUint64Bytes = newValue} } - var mapUint64AnEnum: Dictionary { - get {return _storage._mapUint64AnEnum} + var mapUint64AnEnum: Dictionary { + get {_storage._mapUint64AnEnum} set {_uniqueStorage()._mapUint64AnEnum = newValue} } - var mapUint64Message: Dictionary { - get {return _storage._mapUint64Message} + var mapUint64Message: Dictionary { + get {_storage._mapUint64Message} set {_uniqueStorage()._mapUint64Message = newValue} } var mapSint32Int32: Dictionary { - get {return _storage._mapSint32Int32} + get {_storage._mapSint32Int32} set {_uniqueStorage()._mapSint32Int32 = newValue} } var mapSint32Int64: Dictionary { - get {return _storage._mapSint32Int64} + get {_storage._mapSint32Int64} set {_uniqueStorage()._mapSint32Int64 = newValue} } var mapSint32Uint32: Dictionary { - get {return _storage._mapSint32Uint32} + get {_storage._mapSint32Uint32} set {_uniqueStorage()._mapSint32Uint32 = newValue} } var mapSint32Uint64: Dictionary { - get {return _storage._mapSint32Uint64} + get {_storage._mapSint32Uint64} set {_uniqueStorage()._mapSint32Uint64 = newValue} } var mapSint32Sint32: Dictionary { - get {return _storage._mapSint32Sint32} + get {_storage._mapSint32Sint32} set {_uniqueStorage()._mapSint32Sint32 = newValue} } var mapSint32Sint64: Dictionary { - get {return _storage._mapSint32Sint64} + get {_storage._mapSint32Sint64} set {_uniqueStorage()._mapSint32Sint64 = newValue} } var mapSint32Fixed32: Dictionary { - get {return _storage._mapSint32Fixed32} + get {_storage._mapSint32Fixed32} set {_uniqueStorage()._mapSint32Fixed32 = newValue} } var mapSint32Fixed64: Dictionary { - get {return _storage._mapSint32Fixed64} + get {_storage._mapSint32Fixed64} set {_uniqueStorage()._mapSint32Fixed64 = newValue} } var mapSint32Sfixed32: Dictionary { - get {return _storage._mapSint32Sfixed32} + get {_storage._mapSint32Sfixed32} set {_uniqueStorage()._mapSint32Sfixed32 = newValue} } var mapSint32Sfixed64: Dictionary { - get {return _storage._mapSint32Sfixed64} + get {_storage._mapSint32Sfixed64} set {_uniqueStorage()._mapSint32Sfixed64 = newValue} } var mapSint32Float: Dictionary { - get {return _storage._mapSint32Float} + get {_storage._mapSint32Float} set {_uniqueStorage()._mapSint32Float = newValue} } var mapSint32Double: Dictionary { - get {return _storage._mapSint32Double} + get {_storage._mapSint32Double} set {_uniqueStorage()._mapSint32Double = newValue} } var mapSint32Bool: Dictionary { - get {return _storage._mapSint32Bool} + get {_storage._mapSint32Bool} set {_uniqueStorage()._mapSint32Bool = newValue} } var mapSint32String: Dictionary { - get {return _storage._mapSint32String} + get {_storage._mapSint32String} set {_uniqueStorage()._mapSint32String = newValue} } var mapSint32Bytes: Dictionary { - get {return _storage._mapSint32Bytes} + get {_storage._mapSint32Bytes} set {_uniqueStorage()._mapSint32Bytes = newValue} } - var mapSint32AnEnum: Dictionary { - get {return _storage._mapSint32AnEnum} + var mapSint32AnEnum: Dictionary { + get {_storage._mapSint32AnEnum} set {_uniqueStorage()._mapSint32AnEnum = newValue} } - var mapSint32Message: Dictionary { - get {return _storage._mapSint32Message} + var mapSint32Message: Dictionary { + get {_storage._mapSint32Message} set {_uniqueStorage()._mapSint32Message = newValue} } var mapSint64Int32: Dictionary { - get {return _storage._mapSint64Int32} + get {_storage._mapSint64Int32} set {_uniqueStorage()._mapSint64Int32 = newValue} } var mapSint64Int64: Dictionary { - get {return _storage._mapSint64Int64} + get {_storage._mapSint64Int64} set {_uniqueStorage()._mapSint64Int64 = newValue} } var mapSint64Uint32: Dictionary { - get {return _storage._mapSint64Uint32} + get {_storage._mapSint64Uint32} set {_uniqueStorage()._mapSint64Uint32 = newValue} } var mapSint64Uint64: Dictionary { - get {return _storage._mapSint64Uint64} + get {_storage._mapSint64Uint64} set {_uniqueStorage()._mapSint64Uint64 = newValue} } var mapSint64Sint32: Dictionary { - get {return _storage._mapSint64Sint32} + get {_storage._mapSint64Sint32} set {_uniqueStorage()._mapSint64Sint32 = newValue} } var mapSint64Sint64: Dictionary { - get {return _storage._mapSint64Sint64} + get {_storage._mapSint64Sint64} set {_uniqueStorage()._mapSint64Sint64 = newValue} } var mapSint64Fixed32: Dictionary { - get {return _storage._mapSint64Fixed32} + get {_storage._mapSint64Fixed32} set {_uniqueStorage()._mapSint64Fixed32 = newValue} } var mapSint64Fixed64: Dictionary { - get {return _storage._mapSint64Fixed64} + get {_storage._mapSint64Fixed64} set {_uniqueStorage()._mapSint64Fixed64 = newValue} } var mapSint64Sfixed32: Dictionary { - get {return _storage._mapSint64Sfixed32} + get {_storage._mapSint64Sfixed32} set {_uniqueStorage()._mapSint64Sfixed32 = newValue} } var mapSint64Sfixed64: Dictionary { - get {return _storage._mapSint64Sfixed64} + get {_storage._mapSint64Sfixed64} set {_uniqueStorage()._mapSint64Sfixed64 = newValue} } var mapSint64Float: Dictionary { - get {return _storage._mapSint64Float} + get {_storage._mapSint64Float} set {_uniqueStorage()._mapSint64Float = newValue} } var mapSint64Double: Dictionary { - get {return _storage._mapSint64Double} + get {_storage._mapSint64Double} set {_uniqueStorage()._mapSint64Double = newValue} } var mapSint64Bool: Dictionary { - get {return _storage._mapSint64Bool} + get {_storage._mapSint64Bool} set {_uniqueStorage()._mapSint64Bool = newValue} } var mapSint64String: Dictionary { - get {return _storage._mapSint64String} + get {_storage._mapSint64String} set {_uniqueStorage()._mapSint64String = newValue} } var mapSint64Bytes: Dictionary { - get {return _storage._mapSint64Bytes} + get {_storage._mapSint64Bytes} set {_uniqueStorage()._mapSint64Bytes = newValue} } - var mapSint64AnEnum: Dictionary { - get {return _storage._mapSint64AnEnum} + var mapSint64AnEnum: Dictionary { + get {_storage._mapSint64AnEnum} set {_uniqueStorage()._mapSint64AnEnum = newValue} } - var mapSint64Message: Dictionary { - get {return _storage._mapSint64Message} + var mapSint64Message: Dictionary { + get {_storage._mapSint64Message} set {_uniqueStorage()._mapSint64Message = newValue} } var mapFixed32Int32: Dictionary { - get {return _storage._mapFixed32Int32} + get {_storage._mapFixed32Int32} set {_uniqueStorage()._mapFixed32Int32 = newValue} } var mapFixed32Int64: Dictionary { - get {return _storage._mapFixed32Int64} + get {_storage._mapFixed32Int64} set {_uniqueStorage()._mapFixed32Int64 = newValue} } var mapFixed32Uint32: Dictionary { - get {return _storage._mapFixed32Uint32} + get {_storage._mapFixed32Uint32} set {_uniqueStorage()._mapFixed32Uint32 = newValue} } var mapFixed32Uint64: Dictionary { - get {return _storage._mapFixed32Uint64} + get {_storage._mapFixed32Uint64} set {_uniqueStorage()._mapFixed32Uint64 = newValue} } var mapFixed32Sint32: Dictionary { - get {return _storage._mapFixed32Sint32} + get {_storage._mapFixed32Sint32} set {_uniqueStorage()._mapFixed32Sint32 = newValue} } var mapFixed32Sint64: Dictionary { - get {return _storage._mapFixed32Sint64} + get {_storage._mapFixed32Sint64} set {_uniqueStorage()._mapFixed32Sint64 = newValue} } var mapFixed32Fixed32: Dictionary { - get {return _storage._mapFixed32Fixed32} + get {_storage._mapFixed32Fixed32} set {_uniqueStorage()._mapFixed32Fixed32 = newValue} } var mapFixed32Fixed64: Dictionary { - get {return _storage._mapFixed32Fixed64} + get {_storage._mapFixed32Fixed64} set {_uniqueStorage()._mapFixed32Fixed64 = newValue} } var mapFixed32Sfixed32: Dictionary { - get {return _storage._mapFixed32Sfixed32} + get {_storage._mapFixed32Sfixed32} set {_uniqueStorage()._mapFixed32Sfixed32 = newValue} } var mapFixed32Sfixed64: Dictionary { - get {return _storage._mapFixed32Sfixed64} + get {_storage._mapFixed32Sfixed64} set {_uniqueStorage()._mapFixed32Sfixed64 = newValue} } var mapFixed32Float: Dictionary { - get {return _storage._mapFixed32Float} + get {_storage._mapFixed32Float} set {_uniqueStorage()._mapFixed32Float = newValue} } var mapFixed32Double: Dictionary { - get {return _storage._mapFixed32Double} + get {_storage._mapFixed32Double} set {_uniqueStorage()._mapFixed32Double = newValue} } var mapFixed32Bool: Dictionary { - get {return _storage._mapFixed32Bool} + get {_storage._mapFixed32Bool} set {_uniqueStorage()._mapFixed32Bool = newValue} } var mapFixed32String: Dictionary { - get {return _storage._mapFixed32String} + get {_storage._mapFixed32String} set {_uniqueStorage()._mapFixed32String = newValue} } var mapFixed32Bytes: Dictionary { - get {return _storage._mapFixed32Bytes} + get {_storage._mapFixed32Bytes} set {_uniqueStorage()._mapFixed32Bytes = newValue} } - var mapFixed32AnEnum: Dictionary { - get {return _storage._mapFixed32AnEnum} + var mapFixed32AnEnum: Dictionary { + get {_storage._mapFixed32AnEnum} set {_uniqueStorage()._mapFixed32AnEnum = newValue} } - var mapFixed32Message: Dictionary { - get {return _storage._mapFixed32Message} + var mapFixed32Message: Dictionary { + get {_storage._mapFixed32Message} set {_uniqueStorage()._mapFixed32Message = newValue} } var mapFixed64Int32: Dictionary { - get {return _storage._mapFixed64Int32} + get {_storage._mapFixed64Int32} set {_uniqueStorage()._mapFixed64Int32 = newValue} } var mapFixed64Int64: Dictionary { - get {return _storage._mapFixed64Int64} + get {_storage._mapFixed64Int64} set {_uniqueStorage()._mapFixed64Int64 = newValue} } var mapFixed64Uint32: Dictionary { - get {return _storage._mapFixed64Uint32} + get {_storage._mapFixed64Uint32} set {_uniqueStorage()._mapFixed64Uint32 = newValue} } var mapFixed64Uint64: Dictionary { - get {return _storage._mapFixed64Uint64} + get {_storage._mapFixed64Uint64} set {_uniqueStorage()._mapFixed64Uint64 = newValue} } var mapFixed64Sint32: Dictionary { - get {return _storage._mapFixed64Sint32} + get {_storage._mapFixed64Sint32} set {_uniqueStorage()._mapFixed64Sint32 = newValue} } var mapFixed64Sint64: Dictionary { - get {return _storage._mapFixed64Sint64} + get {_storage._mapFixed64Sint64} set {_uniqueStorage()._mapFixed64Sint64 = newValue} } var mapFixed64Fixed32: Dictionary { - get {return _storage._mapFixed64Fixed32} + get {_storage._mapFixed64Fixed32} set {_uniqueStorage()._mapFixed64Fixed32 = newValue} } var mapFixed64Fixed64: Dictionary { - get {return _storage._mapFixed64Fixed64} + get {_storage._mapFixed64Fixed64} set {_uniqueStorage()._mapFixed64Fixed64 = newValue} } var mapFixed64Sfixed32: Dictionary { - get {return _storage._mapFixed64Sfixed32} + get {_storage._mapFixed64Sfixed32} set {_uniqueStorage()._mapFixed64Sfixed32 = newValue} } var mapFixed64Sfixed64: Dictionary { - get {return _storage._mapFixed64Sfixed64} + get {_storage._mapFixed64Sfixed64} set {_uniqueStorage()._mapFixed64Sfixed64 = newValue} } var mapFixed64Float: Dictionary { - get {return _storage._mapFixed64Float} + get {_storage._mapFixed64Float} set {_uniqueStorage()._mapFixed64Float = newValue} } var mapFixed64Double: Dictionary { - get {return _storage._mapFixed64Double} + get {_storage._mapFixed64Double} set {_uniqueStorage()._mapFixed64Double = newValue} } var mapFixed64Bool: Dictionary { - get {return _storage._mapFixed64Bool} + get {_storage._mapFixed64Bool} set {_uniqueStorage()._mapFixed64Bool = newValue} } var mapFixed64String: Dictionary { - get {return _storage._mapFixed64String} + get {_storage._mapFixed64String} set {_uniqueStorage()._mapFixed64String = newValue} } var mapFixed64Bytes: Dictionary { - get {return _storage._mapFixed64Bytes} + get {_storage._mapFixed64Bytes} set {_uniqueStorage()._mapFixed64Bytes = newValue} } - var mapFixed64AnEnum: Dictionary { - get {return _storage._mapFixed64AnEnum} + var mapFixed64AnEnum: Dictionary { + get {_storage._mapFixed64AnEnum} set {_uniqueStorage()._mapFixed64AnEnum = newValue} } - var mapFixed64Message: Dictionary { - get {return _storage._mapFixed64Message} + var mapFixed64Message: Dictionary { + get {_storage._mapFixed64Message} set {_uniqueStorage()._mapFixed64Message = newValue} } var mapSfixed32Int32: Dictionary { - get {return _storage._mapSfixed32Int32} + get {_storage._mapSfixed32Int32} set {_uniqueStorage()._mapSfixed32Int32 = newValue} } var mapSfixed32Int64: Dictionary { - get {return _storage._mapSfixed32Int64} + get {_storage._mapSfixed32Int64} set {_uniqueStorage()._mapSfixed32Int64 = newValue} } var mapSfixed32Uint32: Dictionary { - get {return _storage._mapSfixed32Uint32} + get {_storage._mapSfixed32Uint32} set {_uniqueStorage()._mapSfixed32Uint32 = newValue} } var mapSfixed32Uint64: Dictionary { - get {return _storage._mapSfixed32Uint64} + get {_storage._mapSfixed32Uint64} set {_uniqueStorage()._mapSfixed32Uint64 = newValue} } var mapSfixed32Sint32: Dictionary { - get {return _storage._mapSfixed32Sint32} + get {_storage._mapSfixed32Sint32} set {_uniqueStorage()._mapSfixed32Sint32 = newValue} } var mapSfixed32Sint64: Dictionary { - get {return _storage._mapSfixed32Sint64} + get {_storage._mapSfixed32Sint64} set {_uniqueStorage()._mapSfixed32Sint64 = newValue} } var mapSfixed32Fixed32: Dictionary { - get {return _storage._mapSfixed32Fixed32} + get {_storage._mapSfixed32Fixed32} set {_uniqueStorage()._mapSfixed32Fixed32 = newValue} } var mapSfixed32Fixed64: Dictionary { - get {return _storage._mapSfixed32Fixed64} + get {_storage._mapSfixed32Fixed64} set {_uniqueStorage()._mapSfixed32Fixed64 = newValue} } var mapSfixed32Sfixed32: Dictionary { - get {return _storage._mapSfixed32Sfixed32} + get {_storage._mapSfixed32Sfixed32} set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} } var mapSfixed32Sfixed64: Dictionary { - get {return _storage._mapSfixed32Sfixed64} + get {_storage._mapSfixed32Sfixed64} set {_uniqueStorage()._mapSfixed32Sfixed64 = newValue} } var mapSfixed32Float: Dictionary { - get {return _storage._mapSfixed32Float} + get {_storage._mapSfixed32Float} set {_uniqueStorage()._mapSfixed32Float = newValue} } var mapSfixed32Double: Dictionary { - get {return _storage._mapSfixed32Double} + get {_storage._mapSfixed32Double} set {_uniqueStorage()._mapSfixed32Double = newValue} } var mapSfixed32Bool: Dictionary { - get {return _storage._mapSfixed32Bool} + get {_storage._mapSfixed32Bool} set {_uniqueStorage()._mapSfixed32Bool = newValue} } var mapSfixed32String: Dictionary { - get {return _storage._mapSfixed32String} + get {_storage._mapSfixed32String} set {_uniqueStorage()._mapSfixed32String = newValue} } var mapSfixed32Bytes: Dictionary { - get {return _storage._mapSfixed32Bytes} + get {_storage._mapSfixed32Bytes} set {_uniqueStorage()._mapSfixed32Bytes = newValue} } - var mapSfixed32AnEnum: Dictionary { - get {return _storage._mapSfixed32AnEnum} + var mapSfixed32AnEnum: Dictionary { + get {_storage._mapSfixed32AnEnum} set {_uniqueStorage()._mapSfixed32AnEnum = newValue} } - var mapSfixed32Message: Dictionary { - get {return _storage._mapSfixed32Message} + var mapSfixed32Message: Dictionary { + get {_storage._mapSfixed32Message} set {_uniqueStorage()._mapSfixed32Message = newValue} } var mapSfixed64Int32: Dictionary { - get {return _storage._mapSfixed64Int32} + get {_storage._mapSfixed64Int32} set {_uniqueStorage()._mapSfixed64Int32 = newValue} } var mapSfixed64Int64: Dictionary { - get {return _storage._mapSfixed64Int64} + get {_storage._mapSfixed64Int64} set {_uniqueStorage()._mapSfixed64Int64 = newValue} } var mapSfixed64Uint32: Dictionary { - get {return _storage._mapSfixed64Uint32} + get {_storage._mapSfixed64Uint32} set {_uniqueStorage()._mapSfixed64Uint32 = newValue} } var mapSfixed64Uint64: Dictionary { - get {return _storage._mapSfixed64Uint64} + get {_storage._mapSfixed64Uint64} set {_uniqueStorage()._mapSfixed64Uint64 = newValue} } var mapSfixed64Sint32: Dictionary { - get {return _storage._mapSfixed64Sint32} + get {_storage._mapSfixed64Sint32} set {_uniqueStorage()._mapSfixed64Sint32 = newValue} } var mapSfixed64Sint64: Dictionary { - get {return _storage._mapSfixed64Sint64} + get {_storage._mapSfixed64Sint64} set {_uniqueStorage()._mapSfixed64Sint64 = newValue} } var mapSfixed64Fixed32: Dictionary { - get {return _storage._mapSfixed64Fixed32} + get {_storage._mapSfixed64Fixed32} set {_uniqueStorage()._mapSfixed64Fixed32 = newValue} } var mapSfixed64Fixed64: Dictionary { - get {return _storage._mapSfixed64Fixed64} + get {_storage._mapSfixed64Fixed64} set {_uniqueStorage()._mapSfixed64Fixed64 = newValue} } var mapSfixed64Sfixed32: Dictionary { - get {return _storage._mapSfixed64Sfixed32} + get {_storage._mapSfixed64Sfixed32} set {_uniqueStorage()._mapSfixed64Sfixed32 = newValue} } var mapSfixed64Sfixed64: Dictionary { - get {return _storage._mapSfixed64Sfixed64} + get {_storage._mapSfixed64Sfixed64} set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} } var mapSfixed64Float: Dictionary { - get {return _storage._mapSfixed64Float} + get {_storage._mapSfixed64Float} set {_uniqueStorage()._mapSfixed64Float = newValue} } var mapSfixed64Double: Dictionary { - get {return _storage._mapSfixed64Double} + get {_storage._mapSfixed64Double} set {_uniqueStorage()._mapSfixed64Double = newValue} } var mapSfixed64Bool: Dictionary { - get {return _storage._mapSfixed64Bool} + get {_storage._mapSfixed64Bool} set {_uniqueStorage()._mapSfixed64Bool = newValue} } var mapSfixed64String: Dictionary { - get {return _storage._mapSfixed64String} + get {_storage._mapSfixed64String} set {_uniqueStorage()._mapSfixed64String = newValue} } var mapSfixed64Bytes: Dictionary { - get {return _storage._mapSfixed64Bytes} + get {_storage._mapSfixed64Bytes} set {_uniqueStorage()._mapSfixed64Bytes = newValue} } - var mapSfixed64AnEnum: Dictionary { - get {return _storage._mapSfixed64AnEnum} + var mapSfixed64AnEnum: Dictionary { + get {_storage._mapSfixed64AnEnum} set {_uniqueStorage()._mapSfixed64AnEnum = newValue} } - var mapSfixed64Message: Dictionary { - get {return _storage._mapSfixed64Message} + var mapSfixed64Message: Dictionary { + get {_storage._mapSfixed64Message} set {_uniqueStorage()._mapSfixed64Message = newValue} } var mapBoolInt32: Dictionary { - get {return _storage._mapBoolInt32} + get {_storage._mapBoolInt32} set {_uniqueStorage()._mapBoolInt32 = newValue} } var mapBoolInt64: Dictionary { - get {return _storage._mapBoolInt64} + get {_storage._mapBoolInt64} set {_uniqueStorage()._mapBoolInt64 = newValue} } var mapBoolUint32: Dictionary { - get {return _storage._mapBoolUint32} + get {_storage._mapBoolUint32} set {_uniqueStorage()._mapBoolUint32 = newValue} } var mapBoolUint64: Dictionary { - get {return _storage._mapBoolUint64} + get {_storage._mapBoolUint64} set {_uniqueStorage()._mapBoolUint64 = newValue} } var mapBoolSint32: Dictionary { - get {return _storage._mapBoolSint32} + get {_storage._mapBoolSint32} set {_uniqueStorage()._mapBoolSint32 = newValue} } var mapBoolSint64: Dictionary { - get {return _storage._mapBoolSint64} + get {_storage._mapBoolSint64} set {_uniqueStorage()._mapBoolSint64 = newValue} } var mapBoolFixed32: Dictionary { - get {return _storage._mapBoolFixed32} + get {_storage._mapBoolFixed32} set {_uniqueStorage()._mapBoolFixed32 = newValue} } var mapBoolFixed64: Dictionary { - get {return _storage._mapBoolFixed64} + get {_storage._mapBoolFixed64} set {_uniqueStorage()._mapBoolFixed64 = newValue} } var mapBoolSfixed32: Dictionary { - get {return _storage._mapBoolSfixed32} + get {_storage._mapBoolSfixed32} set {_uniqueStorage()._mapBoolSfixed32 = newValue} } var mapBoolSfixed64: Dictionary { - get {return _storage._mapBoolSfixed64} + get {_storage._mapBoolSfixed64} set {_uniqueStorage()._mapBoolSfixed64 = newValue} } var mapBoolFloat: Dictionary { - get {return _storage._mapBoolFloat} + get {_storage._mapBoolFloat} set {_uniqueStorage()._mapBoolFloat = newValue} } var mapBoolDouble: Dictionary { - get {return _storage._mapBoolDouble} + get {_storage._mapBoolDouble} set {_uniqueStorage()._mapBoolDouble = newValue} } var mapBoolBool: Dictionary { - get {return _storage._mapBoolBool} + get {_storage._mapBoolBool} set {_uniqueStorage()._mapBoolBool = newValue} } var mapBoolString: Dictionary { - get {return _storage._mapBoolString} + get {_storage._mapBoolString} set {_uniqueStorage()._mapBoolString = newValue} } var mapBoolBytes: Dictionary { - get {return _storage._mapBoolBytes} + get {_storage._mapBoolBytes} set {_uniqueStorage()._mapBoolBytes = newValue} } - var mapBoolAnEnum: Dictionary { - get {return _storage._mapBoolAnEnum} + var mapBoolAnEnum: Dictionary { + get {_storage._mapBoolAnEnum} set {_uniqueStorage()._mapBoolAnEnum = newValue} } - var mapBoolMessage: Dictionary { - get {return _storage._mapBoolMessage} + var mapBoolMessage: Dictionary { + get {_storage._mapBoolMessage} set {_uniqueStorage()._mapBoolMessage = newValue} } /// WKTs since some get special handing in JSON. var wktAny: SwiftProtobuf.Google_Protobuf_Any { - get {return _storage._wktAny ?? SwiftProtobuf.Google_Protobuf_Any()} + get {_storage._wktAny ?? SwiftProtobuf.Google_Protobuf_Any()} set {_uniqueStorage()._wktAny = newValue} } /// Returns true if `wktAny` has been explicitly set. - var hasWktAny: Bool {return _storage._wktAny != nil} + var hasWktAny: Bool {_storage._wktAny != nil} /// Clears the value of `wktAny`. Subsequent reads from it will return its default value. mutating func clearWktAny() {_uniqueStorage()._wktAny = nil} var wktApi: SwiftProtobuf.Google_Protobuf_Api { - get {return _storage._wktApi ?? SwiftProtobuf.Google_Protobuf_Api()} + get {_storage._wktApi ?? SwiftProtobuf.Google_Protobuf_Api()} set {_uniqueStorage()._wktApi = newValue} } /// Returns true if `wktApi` has been explicitly set. - var hasWktApi: Bool {return _storage._wktApi != nil} + var hasWktApi: Bool {_storage._wktApi != nil} /// Clears the value of `wktApi`. Subsequent reads from it will return its default value. mutating func clearWktApi() {_uniqueStorage()._wktApi = nil} var wktDuration: SwiftProtobuf.Google_Protobuf_Duration { - get {return _storage._wktDuration ?? SwiftProtobuf.Google_Protobuf_Duration()} + get {_storage._wktDuration ?? SwiftProtobuf.Google_Protobuf_Duration()} set {_uniqueStorage()._wktDuration = newValue} } /// Returns true if `wktDuration` has been explicitly set. - var hasWktDuration: Bool {return _storage._wktDuration != nil} + var hasWktDuration: Bool {_storage._wktDuration != nil} /// Clears the value of `wktDuration`. Subsequent reads from it will return its default value. mutating func clearWktDuration() {_uniqueStorage()._wktDuration = nil} var wktEmpty: SwiftProtobuf.Google_Protobuf_Empty { - get {return _storage._wktEmpty ?? SwiftProtobuf.Google_Protobuf_Empty()} + get {_storage._wktEmpty ?? SwiftProtobuf.Google_Protobuf_Empty()} set {_uniqueStorage()._wktEmpty = newValue} } /// Returns true if `wktEmpty` has been explicitly set. - var hasWktEmpty: Bool {return _storage._wktEmpty != nil} + var hasWktEmpty: Bool {_storage._wktEmpty != nil} /// Clears the value of `wktEmpty`. Subsequent reads from it will return its default value. mutating func clearWktEmpty() {_uniqueStorage()._wktEmpty = nil} var wktFieldMask: SwiftProtobuf.Google_Protobuf_FieldMask { - get {return _storage._wktFieldMask ?? SwiftProtobuf.Google_Protobuf_FieldMask()} + get {_storage._wktFieldMask ?? SwiftProtobuf.Google_Protobuf_FieldMask()} set {_uniqueStorage()._wktFieldMask = newValue} } /// Returns true if `wktFieldMask` has been explicitly set. - var hasWktFieldMask: Bool {return _storage._wktFieldMask != nil} + var hasWktFieldMask: Bool {_storage._wktFieldMask != nil} /// Clears the value of `wktFieldMask`. Subsequent reads from it will return its default value. mutating func clearWktFieldMask() {_uniqueStorage()._wktFieldMask = nil} var wktSourceContext: SwiftProtobuf.Google_Protobuf_SourceContext { - get {return _storage._wktSourceContext ?? SwiftProtobuf.Google_Protobuf_SourceContext()} + get {_storage._wktSourceContext ?? SwiftProtobuf.Google_Protobuf_SourceContext()} set {_uniqueStorage()._wktSourceContext = newValue} } /// Returns true if `wktSourceContext` has been explicitly set. - var hasWktSourceContext: Bool {return _storage._wktSourceContext != nil} + var hasWktSourceContext: Bool {_storage._wktSourceContext != nil} /// Clears the value of `wktSourceContext`. Subsequent reads from it will return its default value. mutating func clearWktSourceContext() {_uniqueStorage()._wktSourceContext = nil} var wktStruct: SwiftProtobuf.Google_Protobuf_Struct { - get {return _storage._wktStruct ?? SwiftProtobuf.Google_Protobuf_Struct()} + get {_storage._wktStruct ?? SwiftProtobuf.Google_Protobuf_Struct()} set {_uniqueStorage()._wktStruct = newValue} } /// Returns true if `wktStruct` has been explicitly set. - var hasWktStruct: Bool {return _storage._wktStruct != nil} + var hasWktStruct: Bool {_storage._wktStruct != nil} /// Clears the value of `wktStruct`. Subsequent reads from it will return its default value. mutating func clearWktStruct() {_uniqueStorage()._wktStruct = nil} var wktTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp { - get {return _storage._wktTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()} + get {_storage._wktTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()} set {_uniqueStorage()._wktTimestamp = newValue} } /// Returns true if `wktTimestamp` has been explicitly set. - var hasWktTimestamp: Bool {return _storage._wktTimestamp != nil} + var hasWktTimestamp: Bool {_storage._wktTimestamp != nil} /// Clears the value of `wktTimestamp`. Subsequent reads from it will return its default value. mutating func clearWktTimestamp() {_uniqueStorage()._wktTimestamp = nil} var wktType: SwiftProtobuf.Google_Protobuf_Type { - get {return _storage._wktType ?? SwiftProtobuf.Google_Protobuf_Type()} + get {_storage._wktType ?? SwiftProtobuf.Google_Protobuf_Type()} set {_uniqueStorage()._wktType = newValue} } /// Returns true if `wktType` has been explicitly set. - var hasWktType: Bool {return _storage._wktType != nil} + var hasWktType: Bool {_storage._wktType != nil} /// Clears the value of `wktType`. Subsequent reads from it will return its default value. mutating func clearWktType() {_uniqueStorage()._wktType = nil} var wktDoubleValue: SwiftProtobuf.Google_Protobuf_DoubleValue { - get {return _storage._wktDoubleValue ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} + get {_storage._wktDoubleValue ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} set {_uniqueStorage()._wktDoubleValue = newValue} } /// Returns true if `wktDoubleValue` has been explicitly set. - var hasWktDoubleValue: Bool {return _storage._wktDoubleValue != nil} + var hasWktDoubleValue: Bool {_storage._wktDoubleValue != nil} /// Clears the value of `wktDoubleValue`. Subsequent reads from it will return its default value. mutating func clearWktDoubleValue() {_uniqueStorage()._wktDoubleValue = nil} var wktFloatValue: SwiftProtobuf.Google_Protobuf_FloatValue { - get {return _storage._wktFloatValue ?? SwiftProtobuf.Google_Protobuf_FloatValue()} + get {_storage._wktFloatValue ?? SwiftProtobuf.Google_Protobuf_FloatValue()} set {_uniqueStorage()._wktFloatValue = newValue} } /// Returns true if `wktFloatValue` has been explicitly set. - var hasWktFloatValue: Bool {return _storage._wktFloatValue != nil} + var hasWktFloatValue: Bool {_storage._wktFloatValue != nil} /// Clears the value of `wktFloatValue`. Subsequent reads from it will return its default value. mutating func clearWktFloatValue() {_uniqueStorage()._wktFloatValue = nil} var wktInt64Value: SwiftProtobuf.Google_Protobuf_Int64Value { - get {return _storage._wktInt64Value ?? SwiftProtobuf.Google_Protobuf_Int64Value()} + get {_storage._wktInt64Value ?? SwiftProtobuf.Google_Protobuf_Int64Value()} set {_uniqueStorage()._wktInt64Value = newValue} } /// Returns true if `wktInt64Value` has been explicitly set. - var hasWktInt64Value: Bool {return _storage._wktInt64Value != nil} + var hasWktInt64Value: Bool {_storage._wktInt64Value != nil} /// Clears the value of `wktInt64Value`. Subsequent reads from it will return its default value. mutating func clearWktInt64Value() {_uniqueStorage()._wktInt64Value = nil} var wktUint64Value: SwiftProtobuf.Google_Protobuf_UInt64Value { - get {return _storage._wktUint64Value ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} + get {_storage._wktUint64Value ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} set {_uniqueStorage()._wktUint64Value = newValue} } /// Returns true if `wktUint64Value` has been explicitly set. - var hasWktUint64Value: Bool {return _storage._wktUint64Value != nil} + var hasWktUint64Value: Bool {_storage._wktUint64Value != nil} /// Clears the value of `wktUint64Value`. Subsequent reads from it will return its default value. mutating func clearWktUint64Value() {_uniqueStorage()._wktUint64Value = nil} var wktInt32Value: SwiftProtobuf.Google_Protobuf_Int32Value { - get {return _storage._wktInt32Value ?? SwiftProtobuf.Google_Protobuf_Int32Value()} + get {_storage._wktInt32Value ?? SwiftProtobuf.Google_Protobuf_Int32Value()} set {_uniqueStorage()._wktInt32Value = newValue} } /// Returns true if `wktInt32Value` has been explicitly set. - var hasWktInt32Value: Bool {return _storage._wktInt32Value != nil} + var hasWktInt32Value: Bool {_storage._wktInt32Value != nil} /// Clears the value of `wktInt32Value`. Subsequent reads from it will return its default value. mutating func clearWktInt32Value() {_uniqueStorage()._wktInt32Value = nil} var wktUint32Value: SwiftProtobuf.Google_Protobuf_UInt32Value { - get {return _storage._wktUint32Value ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} + get {_storage._wktUint32Value ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} set {_uniqueStorage()._wktUint32Value = newValue} } /// Returns true if `wktUint32Value` has been explicitly set. - var hasWktUint32Value: Bool {return _storage._wktUint32Value != nil} + var hasWktUint32Value: Bool {_storage._wktUint32Value != nil} /// Clears the value of `wktUint32Value`. Subsequent reads from it will return its default value. mutating func clearWktUint32Value() {_uniqueStorage()._wktUint32Value = nil} var wktBoolValue: SwiftProtobuf.Google_Protobuf_BoolValue { - get {return _storage._wktBoolValue ?? SwiftProtobuf.Google_Protobuf_BoolValue()} + get {_storage._wktBoolValue ?? SwiftProtobuf.Google_Protobuf_BoolValue()} set {_uniqueStorage()._wktBoolValue = newValue} } /// Returns true if `wktBoolValue` has been explicitly set. - var hasWktBoolValue: Bool {return _storage._wktBoolValue != nil} + var hasWktBoolValue: Bool {_storage._wktBoolValue != nil} /// Clears the value of `wktBoolValue`. Subsequent reads from it will return its default value. mutating func clearWktBoolValue() {_uniqueStorage()._wktBoolValue = nil} var wktStringValue: SwiftProtobuf.Google_Protobuf_StringValue { - get {return _storage._wktStringValue ?? SwiftProtobuf.Google_Protobuf_StringValue()} + get {_storage._wktStringValue ?? SwiftProtobuf.Google_Protobuf_StringValue()} set {_uniqueStorage()._wktStringValue = newValue} } /// Returns true if `wktStringValue` has been explicitly set. - var hasWktStringValue: Bool {return _storage._wktStringValue != nil} + var hasWktStringValue: Bool {_storage._wktStringValue != nil} /// Clears the value of `wktStringValue`. Subsequent reads from it will return its default value. mutating func clearWktStringValue() {_uniqueStorage()._wktStringValue = nil} var wktBytesValue: SwiftProtobuf.Google_Protobuf_BytesValue { - get {return _storage._wktBytesValue ?? SwiftProtobuf.Google_Protobuf_BytesValue()} + get {_storage._wktBytesValue ?? SwiftProtobuf.Google_Protobuf_BytesValue()} set {_uniqueStorage()._wktBytesValue = newValue} } /// Returns true if `wktBytesValue` has been explicitly set. - var hasWktBytesValue: Bool {return _storage._wktBytesValue != nil} + var hasWktBytesValue: Bool {_storage._wktBytesValue != nil} /// Clears the value of `wktBytesValue`. Subsequent reads from it will return its default value. mutating func clearWktBytesValue() {_uniqueStorage()._wktBytesValue = nil} /// Get some coverage for the special message_set_wire_format. - var singularMessageSet: Fuzz_Testing_AMessageSetMessage { - get {return _storage._singularMessageSet ?? Fuzz_Testing_AMessageSetMessage()} + var singularMessageSet: SwiftProtoTesting_Fuzz_AMessageSetMessage { + get {_storage._singularMessageSet ?? SwiftProtoTesting_Fuzz_AMessageSetMessage()} set {_uniqueStorage()._singularMessageSet = newValue} } /// Returns true if `singularMessageSet` has been explicitly set. - var hasSingularMessageSet: Bool {return _storage._singularMessageSet != nil} + var hasSingularMessageSet: Bool {_storage._singularMessageSet != nil} /// Clears the value of `singularMessageSet`. Subsequent reads from it will return its default value. mutating func clearSingularMessageSet() {_uniqueStorage()._singularMessageSet = nil} - var repeatedMessageSet: [Fuzz_Testing_AMessageSetMessage] { - get {return _storage._repeatedMessageSet} + var repeatedMessageSet: [SwiftProtoTesting_Fuzz_AMessageSetMessage] { + get {_storage._repeatedMessageSet} set {_uniqueStorage()._repeatedMessageSet = newValue} } var unknownFields = SwiftProtobuf.UnknownStorage() /// oneof - enum OneOf_O: Equatable { + enum OneOf_O: Equatable, Sendable { case oneofInt32(Int32) case oneofInt64(Int64) case oneofUint32(UInt32) @@ -1687,110 +1660,28 @@ struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { case oneofBool(Bool) case oneofString(String) case oneofBytes(Data) - case oneofEnum(Fuzz_Testing_AnEnum) - case oneofGroup(Fuzz_Testing_Message.OneofGroup) - case oneofMessage(Fuzz_Testing_Message) + case oneofEnum(SwiftProtoTesting_Fuzz_AnEnum) + case oneofGroup(SwiftProtoTesting_Fuzz_Message.OneofGroup) + case oneofMessage(SwiftProtoTesting_Fuzz_Message) fileprivate var isInitialized: Bool { guard case .oneofMessage(let v) = self else {return true} return v.isInitialized } - #if !swift(>=4.1) - static func ==(lhs: Fuzz_Testing_Message.OneOf_O, rhs: Fuzz_Testing_Message.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 (.oneofInt32, .oneofInt32): return { - guard case .oneofInt32(let l) = lhs, case .oneofInt32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofInt64, .oneofInt64): return { - guard case .oneofInt64(let l) = lhs, case .oneofInt64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint64, .oneofUint64): return { - guard case .oneofUint64(let l) = lhs, case .oneofUint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSint32, .oneofSint32): return { - guard case .oneofSint32(let l) = lhs, case .oneofSint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSint64, .oneofSint64): return { - guard case .oneofSint64(let l) = lhs, case .oneofSint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFixed32, .oneofFixed32): return { - guard case .oneofFixed32(let l) = lhs, case .oneofFixed32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFixed64, .oneofFixed64): return { - guard case .oneofFixed64(let l) = lhs, case .oneofFixed64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSfixed32, .oneofSfixed32): return { - guard case .oneofSfixed32(let l) = lhs, case .oneofSfixed32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSfixed64, .oneofSfixed64): return { - guard case .oneofSfixed64(let l) = lhs, case .oneofSfixed64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFloat, .oneofFloat): return { - guard case .oneofFloat(let l) = lhs, case .oneofFloat(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofDouble, .oneofDouble): return { - guard case .oneofDouble(let l) = lhs, case .oneofDouble(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBool, .oneofBool): return { - guard case .oneofBool(let l) = lhs, case .oneofBool(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofEnum, .oneofEnum): return { - guard case .oneofEnum(let l) = lhs, case .oneofEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofGroup, .oneofGroup): return { - guard case .oneofGroup(let l) = lhs, case .oneofGroup(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofMessage, .oneofMessage): return { - guard case .oneofMessage(let l) = lhs, case .oneofMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - struct SingularGroup { + struct SingularGroup: Sendable { // 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 groupField: Int32 { - get {return _groupField ?? 0} + get {_groupField ?? 0} set {_groupField = newValue} } /// Returns true if `groupField` has been explicitly set. - var hasGroupField: Bool {return self._groupField != nil} + var hasGroupField: Bool {self._groupField != nil} /// Clears the value of `groupField`. Subsequent reads from it will return its default value. mutating func clearGroupField() {self._groupField = nil} @@ -1801,17 +1692,17 @@ struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { fileprivate var _groupField: Int32? = nil } - struct RepeatedGroup { + struct RepeatedGroup: Sendable { // 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 groupField: Int32 { - get {return _groupField ?? 0} + get {_groupField ?? 0} set {_groupField = newValue} } /// Returns true if `groupField` has been explicitly set. - var hasGroupField: Bool {return self._groupField != nil} + var hasGroupField: Bool {self._groupField != nil} /// Clears the value of `groupField`. Subsequent reads from it will return its default value. mutating func clearGroupField() {self._groupField = nil} @@ -1822,17 +1713,17 @@ struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { fileprivate var _groupField: Int32? = nil } - struct OneofGroup { + struct OneofGroup: Sendable { // 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 groupField: Int32 { - get {return _groupField ?? 0} + get {_groupField ?? 0} set {_groupField = newValue} } /// Returns true if `groupField` has been explicitly set. - var hasGroupField: Bool {return self._groupField != nil} + var hasGroupField: Bool {self._groupField != nil} /// Clears the value of `groupField`. Subsequent reads from it will return its default value. mutating func clearGroupField() {self._groupField = nil} @@ -1850,7 +1741,7 @@ struct Fuzz_Testing_Message: SwiftProtobuf.ExtensibleMessage { } /// A message with message_set_wire_format. -struct Fuzz_Testing_AMessageSetMessage: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Fuzz_AMessageSetMessage: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -1862,17 +1753,60 @@ struct Fuzz_Testing_AMessageSetMessage: SwiftProtobuf.ExtensibleMessage { var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct Fuzz_Testing_SingularGroup_ext { +/// Two extensions to go with the message_set_wire_format testing. +struct SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1: Sendable { + // 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 aString: String { + get {_aString ?? String()} + set {_aString = newValue} + } + /// Returns true if `aString` has been explicitly set. + var hasAString: Bool {self._aString != nil} + /// Clears the value of `aString`. Subsequent reads from it will return its default value. + mutating func clearAString() {self._aString = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _aString: String? = nil +} + +struct SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2: Sendable { + // 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 anInt32: Int32 { + get {_anInt32 ?? 0} + set {_anInt32 = newValue} + } + /// Returns true if `anInt32` has been explicitly set. + var hasAnInt32: Bool {self._anInt32 != nil} + /// Clears the value of `anInt32`. Subsequent reads from it will return its default value. + mutating func clearAnInt32() {self._anInt32 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _anInt32: Int32? = nil +} + +struct SwiftProtoTesting_Fuzz_SingularGroup_ext: Sendable { // 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 groupField: Int32 { - get {return _groupField ?? 0} + get {_groupField ?? 0} set {_groupField = newValue} } /// Returns true if `groupField` has been explicitly set. - var hasGroupField: Bool {return self._groupField != nil} + var hasGroupField: Bool {self._groupField != nil} /// Clears the value of `groupField`. Subsequent reads from it will return its default value. mutating func clearGroupField() {self._groupField = nil} @@ -1883,17 +1817,17 @@ struct Fuzz_Testing_SingularGroup_ext { fileprivate var _groupField: Int32? = nil } -struct Fuzz_Testing_RepeatedGroup_ext { +struct SwiftProtoTesting_Fuzz_RepeatedGroup_ext: Sendable { // 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 groupField: Int32 { - get {return _groupField ?? 0} + get {_groupField ?? 0} set {_groupField = newValue} } /// Returns true if `groupField` has been explicitly set. - var hasGroupField: Bool {return self._groupField != nil} + var hasGroupField: Bool {self._groupField != nil} /// Clears the value of `groupField`. Subsequent reads from it will return its default value. mutating func clearGroupField() {self._groupField = nil} @@ -1904,841 +1838,544 @@ struct Fuzz_Testing_RepeatedGroup_ext { fileprivate var _groupField: Int32? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension Fuzz_Testing_AnEnum: @unchecked Sendable {} -extension Fuzz_Testing_Message: @unchecked Sendable {} -extension Fuzz_Testing_Message.OneOf_O: @unchecked Sendable {} -extension Fuzz_Testing_Message.SingularGroup: @unchecked Sendable {} -extension Fuzz_Testing_Message.RepeatedGroup: @unchecked Sendable {} -extension Fuzz_Testing_Message.OneofGroup: @unchecked Sendable {} -extension Fuzz_Testing_AMessageSetMessage: @unchecked Sendable {} -extension Fuzz_Testing_SingularGroup_ext: @unchecked Sendable {} -extension Fuzz_Testing_RepeatedGroup_ext: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in fuzz_testing.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 Fuzz_Testing_Message { +extension SwiftProtoTesting_Fuzz_AMessageSetMessage { - /// Singular - var Fuzz_Testing_singularInt32Ext: Int32 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_int32_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_int32_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1_messageSetExtension: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension) ?? SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1()} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_int32_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension` /// has been explicitly set. - var hasFuzz_Testing_singularInt32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_int32_ext) + var hasSwiftProtoTesting_Fuzz_AMessageSetMessageExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_int32_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularInt32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_int32_ext) + mutating func clearSwiftProtoTesting_Fuzz_AMessageSetMessageExtension1_messageSetExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension) } - var Fuzz_Testing_singularInt64Ext: Int64 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_int64_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_int64_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2_messageSetExtension: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension) ?? SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2()} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_int64_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension` /// has been explicitly set. - var hasFuzz_Testing_singularInt64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_int64_ext) + var hasSwiftProtoTesting_Fuzz_AMessageSetMessageExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_int64_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularInt64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_int64_ext) + mutating func clearSwiftProtoTesting_Fuzz_AMessageSetMessageExtension2_messageSetExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension) } +} - var Fuzz_Testing_singularUint32Ext: UInt32 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint32_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_uint32_ext` - /// has been explicitly set. - var hasFuzz_Testing_singularUint32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_uint32_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularUint32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint32_ext) - } +extension SwiftProtoTesting_Fuzz_Message { - var Fuzz_Testing_singularUint64Ext: UInt64 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint64_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint64_ext, value: newValue)} + /// Singular + var SwiftProtoTesting_Fuzz_singularInt32Ext: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_uint64_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext` /// has been explicitly set. - var hasFuzz_Testing_singularUint64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint64_ext) + var hasSwiftProtoTesting_Fuzz_singularInt32Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_uint64_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularUint64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_uint64_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularInt32Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext) } - var Fuzz_Testing_singularSint32Ext: Int32 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint32_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint32_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularInt64Ext: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_sint32_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext` /// has been explicitly set. - var hasFuzz_Testing_singularSint32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint32_ext) + var hasSwiftProtoTesting_Fuzz_singularInt64Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_sint32_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularSint32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint32_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularInt64Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext) } - var Fuzz_Testing_singularSint64Ext: Int64 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint64_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint64_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularUint32Ext: UInt32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_sint64_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext` /// has been explicitly set. - var hasFuzz_Testing_singularSint64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint64_ext) + var hasSwiftProtoTesting_Fuzz_singularUint32Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_sint64_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularSint64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_sint64_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularUint32Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext) } - var Fuzz_Testing_singularFixed32Ext: UInt32 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed32_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed32_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularUint64Ext: UInt64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_fixed32_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext` /// has been explicitly set. - var hasFuzz_Testing_singularFixed32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed32_ext) + var hasSwiftProtoTesting_Fuzz_singularUint64Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_fixed32_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularFixed32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed32_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularUint64Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext) } - var Fuzz_Testing_singularFixed64Ext: UInt64 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed64_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed64_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularSint32Ext: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_fixed64_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext` /// has been explicitly set. - var hasFuzz_Testing_singularFixed64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed64_ext) + var hasSwiftProtoTesting_Fuzz_singularSint32Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_fixed64_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularFixed64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_fixed64_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularSint32Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext) } - var Fuzz_Testing_singularSfixed32Ext: Int32 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed32_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed32_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularSint64Ext: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_sfixed32_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext` /// has been explicitly set. - var hasFuzz_Testing_singularSfixed32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed32_ext) + var hasSwiftProtoTesting_Fuzz_singularSint64Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_sfixed32_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularSfixed32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed32_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularSint64Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext) } - var Fuzz_Testing_singularSfixed64Ext: Int64 { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed64_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed64_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularFixed32Ext: UInt32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_sfixed64_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext` /// has been explicitly set. - var hasFuzz_Testing_singularSfixed64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed64_ext) + var hasSwiftProtoTesting_Fuzz_singularFixed32Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_sfixed64_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularSfixed64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_sfixed64_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularFixed32Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext) } - var Fuzz_Testing_singularFloatExt: Float { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_float_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_float_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularFixed64Ext: UInt64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_float_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext` /// has been explicitly set. - var hasFuzz_Testing_singularFloatExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_float_ext) + var hasSwiftProtoTesting_Fuzz_singularFixed64Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_float_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularFloatExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_float_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularFixed64Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext) } - var Fuzz_Testing_singularDoubleExt: Double { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_double_ext) ?? 0} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_double_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularSfixed32Ext: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_double_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext` /// has been explicitly set. - var hasFuzz_Testing_singularDoubleExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_double_ext) + var hasSwiftProtoTesting_Fuzz_singularSfixed32Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_double_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularDoubleExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_double_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularSfixed32Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext) } - var Fuzz_Testing_singularBoolExt: Bool { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_bool_ext) ?? false} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_bool_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularSfixed64Ext: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_bool_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext` /// has been explicitly set. - var hasFuzz_Testing_singularBoolExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_bool_ext) + var hasSwiftProtoTesting_Fuzz_singularSfixed64Ext: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_bool_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularBoolExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_bool_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularSfixed64Ext() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext) } - var Fuzz_Testing_singularStringExt: String { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_string_ext) ?? String()} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_string_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularFloatExt: Float { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_float_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_float_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_string_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_float_ext` /// has been explicitly set. - var hasFuzz_Testing_singularStringExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_string_ext) + var hasSwiftProtoTesting_Fuzz_singularFloatExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_float_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_string_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_float_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularStringExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_string_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularFloatExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_float_ext) } - var Fuzz_Testing_singularBytesExt: Data { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_bytes_ext) ?? Data()} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_bytes_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularDoubleExt: Double { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_double_ext) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_double_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_bytes_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_double_ext` /// has been explicitly set. - var hasFuzz_Testing_singularBytesExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_bytes_ext) + var hasSwiftProtoTesting_Fuzz_singularDoubleExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_double_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_bytes_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_double_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularBytesExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_bytes_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularDoubleExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_double_ext) } - var Fuzz_Testing_singularEnumExt: Fuzz_Testing_AnEnum { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_enum_ext) ?? .zero} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_enum_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularBoolExt: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_enum_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext` /// has been explicitly set. - var hasFuzz_Testing_singularEnumExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_enum_ext) + var hasSwiftProtoTesting_Fuzz_singularBoolExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_enum_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularEnumExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_enum_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularBoolExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext) } - var Fuzz_Testing_singularGroupExt: Fuzz_Testing_SingularGroup_ext { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_SingularGroup_ext) ?? Fuzz_Testing_SingularGroup_ext()} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_SingularGroup_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularStringExt: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_string_ext) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_string_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_SingularGroup_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_string_ext` /// has been explicitly set. - var hasFuzz_Testing_singularGroupExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_SingularGroup_ext) + var hasSwiftProtoTesting_Fuzz_singularStringExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_string_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_SingularGroup_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_string_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularGroupExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_SingularGroup_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularStringExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_string_ext) } - var Fuzz_Testing_singularMessageExt: Fuzz_Testing_Message { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_singular_message_ext) ?? Fuzz_Testing_Message()} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_singular_message_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularBytesExt: Data { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext) ?? Data()} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_singular_message_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext` /// has been explicitly set. - var hasFuzz_Testing_singularMessageExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_singular_message_ext) + var hasSwiftProtoTesting_Fuzz_singularBytesExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_singular_message_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_singularMessageExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_singular_message_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularBytesExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext) } - /// Repeated - var Fuzz_Testing_repeatedInt32Ext: [Int32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int32_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularEnumExt: SwiftProtoTesting_Fuzz_AnEnum { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext) ?? .zero} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_int32_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext` /// has been explicitly set. - var hasFuzz_Testing_repeatedInt32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int32_ext) + var hasSwiftProtoTesting_Fuzz_singularEnumExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_int32_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedInt32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int32_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularEnumExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext) } - var Fuzz_Testing_repeatedInt64Ext: [Int64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int64_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularGroupExt: SwiftProtoTesting_Fuzz_SingularGroup_ext { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext) ?? SwiftProtoTesting_Fuzz_SingularGroup_ext()} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_int64_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext` /// has been explicitly set. - var hasFuzz_Testing_repeatedInt64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int64_ext) + var hasSwiftProtoTesting_Fuzz_singularGroupExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_int64_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedInt64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_int64_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularGroupExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext) } - var Fuzz_Testing_repeatedUint32Ext: [UInt32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint32_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_singularMessageExt: SwiftProtoTesting_Fuzz_Message { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_message_ext) ?? SwiftProtoTesting_Fuzz_Message()} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_message_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_uint32_ext` + /// Returns true if extension `SwiftProtoTesting_Fuzz_Extensions_singular_message_ext` /// has been explicitly set. - var hasFuzz_Testing_repeatedUint32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint32_ext) + var hasSwiftProtoTesting_Fuzz_singularMessageExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_message_ext) } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_uint32_ext`. + /// Clears the value of extension `SwiftProtoTesting_Fuzz_Extensions_singular_message_ext`. /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedUint32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint32_ext) + mutating func clearSwiftProtoTesting_Fuzz_singularMessageExt() { + clearExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_singular_message_ext) } - var Fuzz_Testing_repeatedUint64Ext: [UInt64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_uint64_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedUint64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_uint64_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedUint64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_uint64_ext) + /// Repeated + var SwiftProtoTesting_Fuzz_repeatedInt32Ext: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_int32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_int32_ext, value: newValue)} } - var Fuzz_Testing_repeatedSint32Ext: [Int32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_sint32_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedSint32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_sint32_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedSint32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint32_ext) + var SwiftProtoTesting_Fuzz_repeatedInt64Ext: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_int64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_int64_ext, value: newValue)} } - var Fuzz_Testing_repeatedSint64Ext: [Int64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_sint64_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedSint64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_sint64_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedSint64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sint64_ext) + var SwiftProtoTesting_Fuzz_repeatedUint32Ext: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_uint32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_uint32_ext, value: newValue)} } - var Fuzz_Testing_repeatedFixed32Ext: [UInt32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_fixed32_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedFixed32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_fixed32_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedFixed32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed32_ext) + var SwiftProtoTesting_Fuzz_repeatedUint64Ext: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_uint64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_uint64_ext, value: newValue)} } - var Fuzz_Testing_repeatedFixed64Ext: [UInt64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_fixed64_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedFixed64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_fixed64_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedFixed64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_fixed64_ext) + var SwiftProtoTesting_Fuzz_repeatedSint32Ext: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sint32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sint32_ext, value: newValue)} } - var Fuzz_Testing_repeatedSfixed32Ext: [Int32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_sfixed32_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedSfixed32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_sfixed32_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedSfixed32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed32_ext) + var SwiftProtoTesting_Fuzz_repeatedSint64Ext: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sint64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sint64_ext, value: newValue)} } - var Fuzz_Testing_repeatedSfixed64Ext: [Int64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_sfixed64_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedSfixed64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_sfixed64_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedSfixed64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_sfixed64_ext) + var SwiftProtoTesting_Fuzz_repeatedFixed32Ext: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_fixed32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_fixed32_ext, value: newValue)} } - var Fuzz_Testing_repeatedFloatExt: [Float] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_float_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_float_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_float_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedFloatExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_float_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_float_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedFloatExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_float_ext) + var SwiftProtoTesting_Fuzz_repeatedFixed64Ext: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_fixed64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_fixed64_ext, value: newValue)} } - var Fuzz_Testing_repeatedDoubleExt: [Double] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_double_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_double_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_double_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedDoubleExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_double_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_double_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedDoubleExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_double_ext) + var SwiftProtoTesting_Fuzz_repeatedSfixed32Ext: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed32_ext, value: newValue)} } - var Fuzz_Testing_repeatedBoolExt: [Bool] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bool_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bool_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_bool_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedBoolExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bool_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_bool_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedBoolExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bool_ext) + var SwiftProtoTesting_Fuzz_repeatedSfixed64Ext: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed64_ext, value: newValue)} } - var Fuzz_Testing_repeatedStringExt: [String] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_string_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_string_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_string_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedStringExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_string_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_string_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedStringExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_string_ext) + var SwiftProtoTesting_Fuzz_repeatedFloatExt: [Float] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_float_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_float_ext, value: newValue)} } - var Fuzz_Testing_repeatedBytesExt: [Data] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bytes_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bytes_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_bytes_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedBytesExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bytes_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_bytes_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedBytesExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_bytes_ext) + var SwiftProtoTesting_Fuzz_repeatedDoubleExt: [Double] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_double_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_double_ext, value: newValue)} } - var Fuzz_Testing_repeatedEnumExt: [Fuzz_Testing_AnEnum] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_enum_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_enum_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_enum_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedEnumExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_enum_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_enum_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedEnumExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_enum_ext) + var SwiftProtoTesting_Fuzz_repeatedBoolExt: [Bool] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_bool_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_bool_ext, value: newValue)} } - var Fuzz_Testing_repeatedGroupExt: [Fuzz_Testing_RepeatedGroup_ext] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_RepeatedGroup_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_RepeatedGroup_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_RepeatedGroup_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedGroupExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_RepeatedGroup_ext) + var SwiftProtoTesting_Fuzz_repeatedStringExt: [String] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_string_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_string_ext, value: newValue)} } - /// Clears the value of extension `Fuzz_Testing_Extensions_RepeatedGroup_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedGroupExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_RepeatedGroup_ext) + + var SwiftProtoTesting_Fuzz_repeatedBytesExt: [Data] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_bytes_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_bytes_ext, value: newValue)} } - var Fuzz_Testing_repeatedMessageExt: [Fuzz_Testing_Message] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_message_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_message_ext, value: newValue)} + var SwiftProtoTesting_Fuzz_repeatedEnumExt: [SwiftProtoTesting_Fuzz_AnEnum] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_enum_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_enum_ext, value: newValue)} } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_message_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedMessageExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_message_ext) + + var SwiftProtoTesting_Fuzz_repeatedGroupExt: [SwiftProtoTesting_Fuzz_RepeatedGroup_ext] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_RepeatedGroup_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_RepeatedGroup_ext, value: newValue)} } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_message_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedMessageExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_message_ext) + + var SwiftProtoTesting_Fuzz_repeatedMessageExt: [SwiftProtoTesting_Fuzz_Message] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_message_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_message_ext, value: newValue)} } /// Repeated Packed - var Fuzz_Testing_repeatedPackedInt32Ext: [Int32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_int32_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedInt32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_int32_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedInt32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int32_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedInt32Ext: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int32_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedInt64Ext: [Int64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_int64_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedInt64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_int64_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedInt64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_int64_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedInt64Ext: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int64_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedUint32Ext: [UInt32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_uint32_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedUint32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_uint32_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedUint32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint32_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedUint32Ext: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint32_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedUint64Ext: [UInt64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_uint64_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedUint64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_uint64_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedUint64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_uint64_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedUint64Ext: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint64_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedSint32Ext: [Int32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_sint32_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedSint32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_sint32_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedSint32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint32_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedSint32Ext: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint32_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedSint64Ext: [Int64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_sint64_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedSint64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_sint64_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedSint64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sint64_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedSint64Ext: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint64_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedFixed32Ext: [UInt32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_fixed32_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedFixed32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_fixed32_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedFixed32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed32_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedFixed32Ext: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed32_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedFixed64Ext: [UInt64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_fixed64_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedFixed64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_fixed64_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedFixed64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_fixed64_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedFixed64Ext: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed64_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedSfixed32Ext: [Int32] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedSfixed32Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedSfixed32Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedSfixed32Ext: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed32_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed32_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedSfixed64Ext: [Int64] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedSfixed64Ext: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedSfixed64Ext() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedSfixed64Ext: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed64_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed64_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedFloatExt: [Float] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_float_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_float_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_float_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedFloatExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_float_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_float_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedFloatExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_float_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedFloatExt: [Float] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_float_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_float_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedDoubleExt: [Double] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_double_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_double_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_double_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedDoubleExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_double_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_double_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedDoubleExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_double_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedDoubleExt: [Double] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_double_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_double_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedBoolExt: [Bool] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_bool_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_bool_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_bool_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedBoolExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_bool_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_bool_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedBoolExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_bool_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedBoolExt: [Bool] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_bool_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_bool_ext, value: newValue)} } - var Fuzz_Testing_repeatedPackedEnumExt: [Fuzz_Testing_AnEnum] { - get {return getExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_enum_ext) ?? []} - set {setExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_enum_ext, value: newValue)} - } - /// Returns true if extension `Fuzz_Testing_Extensions_repeated_packed_enum_ext` - /// has been explicitly set. - var hasFuzz_Testing_repeatedPackedEnumExt: Bool { - return hasExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_enum_ext) - } - /// Clears the value of extension `Fuzz_Testing_Extensions_repeated_packed_enum_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearFuzz_Testing_repeatedPackedEnumExt() { - clearExtensionValue(ext: Fuzz_Testing_Extensions_repeated_packed_enum_ext) + var SwiftProtoTesting_Fuzz_repeatedPackedEnumExt: [SwiftProtoTesting_Fuzz_AnEnum] { + get {return getExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_enum_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Fuzz_Extensions_repeated_packed_enum_ext, value: newValue)} } } -// MARK: - File's ExtensionMap: Fuzz_Testing_FuzzTesting_Extensions +// MARK: - File's ExtensionMap: SwiftProtoTesting_Fuzz_FuzzTesting_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 Fuzz_Testing_FuzzTesting_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - Fuzz_Testing_Extensions_singular_int32_ext, - Fuzz_Testing_Extensions_singular_int64_ext, - Fuzz_Testing_Extensions_singular_uint32_ext, - Fuzz_Testing_Extensions_singular_uint64_ext, - Fuzz_Testing_Extensions_singular_sint32_ext, - Fuzz_Testing_Extensions_singular_sint64_ext, - Fuzz_Testing_Extensions_singular_fixed32_ext, - Fuzz_Testing_Extensions_singular_fixed64_ext, - Fuzz_Testing_Extensions_singular_sfixed32_ext, - Fuzz_Testing_Extensions_singular_sfixed64_ext, - Fuzz_Testing_Extensions_singular_float_ext, - Fuzz_Testing_Extensions_singular_double_ext, - Fuzz_Testing_Extensions_singular_bool_ext, - Fuzz_Testing_Extensions_singular_string_ext, - Fuzz_Testing_Extensions_singular_bytes_ext, - Fuzz_Testing_Extensions_singular_enum_ext, - Fuzz_Testing_Extensions_SingularGroup_ext, - Fuzz_Testing_Extensions_singular_message_ext, - Fuzz_Testing_Extensions_repeated_int32_ext, - Fuzz_Testing_Extensions_repeated_int64_ext, - Fuzz_Testing_Extensions_repeated_uint32_ext, - Fuzz_Testing_Extensions_repeated_uint64_ext, - Fuzz_Testing_Extensions_repeated_sint32_ext, - Fuzz_Testing_Extensions_repeated_sint64_ext, - Fuzz_Testing_Extensions_repeated_fixed32_ext, - Fuzz_Testing_Extensions_repeated_fixed64_ext, - Fuzz_Testing_Extensions_repeated_sfixed32_ext, - Fuzz_Testing_Extensions_repeated_sfixed64_ext, - Fuzz_Testing_Extensions_repeated_float_ext, - Fuzz_Testing_Extensions_repeated_double_ext, - Fuzz_Testing_Extensions_repeated_bool_ext, - Fuzz_Testing_Extensions_repeated_string_ext, - Fuzz_Testing_Extensions_repeated_bytes_ext, - Fuzz_Testing_Extensions_repeated_enum_ext, - Fuzz_Testing_Extensions_RepeatedGroup_ext, - Fuzz_Testing_Extensions_repeated_message_ext, - Fuzz_Testing_Extensions_repeated_packed_int32_ext, - Fuzz_Testing_Extensions_repeated_packed_int64_ext, - Fuzz_Testing_Extensions_repeated_packed_uint32_ext, - Fuzz_Testing_Extensions_repeated_packed_uint64_ext, - Fuzz_Testing_Extensions_repeated_packed_sint32_ext, - Fuzz_Testing_Extensions_repeated_packed_sint64_ext, - Fuzz_Testing_Extensions_repeated_packed_fixed32_ext, - Fuzz_Testing_Extensions_repeated_packed_fixed64_ext, - Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext, - Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext, - Fuzz_Testing_Extensions_repeated_packed_float_ext, - Fuzz_Testing_Extensions_repeated_packed_double_ext, - Fuzz_Testing_Extensions_repeated_packed_bool_ext, - Fuzz_Testing_Extensions_repeated_packed_enum_ext +let SwiftProtoTesting_Fuzz_FuzzTesting_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_float_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_double_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_string_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext, + SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext, + SwiftProtoTesting_Fuzz_Extensions_singular_message_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_int32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_int64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_uint32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_uint64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_sint32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_sint64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_fixed32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_fixed64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_float_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_double_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_bool_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_string_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_bytes_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_enum_ext, + SwiftProtoTesting_Fuzz_Extensions_RepeatedGroup_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_message_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed32_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed64_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_float_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_double_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_bool_ext, + SwiftProtoTesting_Fuzz_Extensions_repeated_packed_enum_ext, + SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1.Extensions.message_set_extension, + SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2.Extensions.message_set_extension ] // Extension Objects - The only reason these might be needed is when manually @@ -2746,550 +2383,287 @@ let Fuzz_Testing_FuzzTesting_Extensions: SwiftProtobuf.SimpleExtensionMap = [ // accessors for the extension fields on the messages directly. /// Singular -let Fuzz_Testing_Extensions_singular_int32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_int32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1001, - fieldName: "fuzz.testing.singular_int32_ext" + fieldName: "swift_proto_testing.fuzz.singular_int32_ext" ) -let Fuzz_Testing_Extensions_singular_int64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_int64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1002, - fieldName: "fuzz.testing.singular_int64_ext" + fieldName: "swift_proto_testing.fuzz.singular_int64_ext" ) -let Fuzz_Testing_Extensions_singular_uint32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_uint32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1003, - fieldName: "fuzz.testing.singular_uint32_ext" + fieldName: "swift_proto_testing.fuzz.singular_uint32_ext" ) -let Fuzz_Testing_Extensions_singular_uint64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_uint64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1004, - fieldName: "fuzz.testing.singular_uint64_ext" + fieldName: "swift_proto_testing.fuzz.singular_uint64_ext" ) -let Fuzz_Testing_Extensions_singular_sint32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_sint32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1005, - fieldName: "fuzz.testing.singular_sint32_ext" + fieldName: "swift_proto_testing.fuzz.singular_sint32_ext" ) -let Fuzz_Testing_Extensions_singular_sint64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_sint64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1006, - fieldName: "fuzz.testing.singular_sint64_ext" + fieldName: "swift_proto_testing.fuzz.singular_sint64_ext" ) -let Fuzz_Testing_Extensions_singular_fixed32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_fixed32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1007, - fieldName: "fuzz.testing.singular_fixed32_ext" + fieldName: "swift_proto_testing.fuzz.singular_fixed32_ext" ) -let Fuzz_Testing_Extensions_singular_fixed64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_fixed64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1008, - fieldName: "fuzz.testing.singular_fixed64_ext" + fieldName: "swift_proto_testing.fuzz.singular_fixed64_ext" ) -let Fuzz_Testing_Extensions_singular_sfixed32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_sfixed32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1009, - fieldName: "fuzz.testing.singular_sfixed32_ext" + fieldName: "swift_proto_testing.fuzz.singular_sfixed32_ext" ) -let Fuzz_Testing_Extensions_singular_sfixed64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_sfixed64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1010, - fieldName: "fuzz.testing.singular_sfixed64_ext" + fieldName: "swift_proto_testing.fuzz.singular_sfixed64_ext" ) -let Fuzz_Testing_Extensions_singular_float_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_float_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1011, - fieldName: "fuzz.testing.singular_float_ext" + fieldName: "swift_proto_testing.fuzz.singular_float_ext" ) -let Fuzz_Testing_Extensions_singular_double_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_double_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1012, - fieldName: "fuzz.testing.singular_double_ext" + fieldName: "swift_proto_testing.fuzz.singular_double_ext" ) -let Fuzz_Testing_Extensions_singular_bool_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_bool_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1013, - fieldName: "fuzz.testing.singular_bool_ext" + fieldName: "swift_proto_testing.fuzz.singular_bool_ext" ) -let Fuzz_Testing_Extensions_singular_string_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_string_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1014, - fieldName: "fuzz.testing.singular_string_ext" + fieldName: "swift_proto_testing.fuzz.singular_string_ext" ) -let Fuzz_Testing_Extensions_singular_bytes_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_bytes_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1015, - fieldName: "fuzz.testing.singular_bytes_ext" + fieldName: "swift_proto_testing.fuzz.singular_bytes_ext" ) -let Fuzz_Testing_Extensions_singular_enum_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_enum_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1016, - fieldName: "fuzz.testing.singular_enum_ext" + fieldName: "swift_proto_testing.fuzz.singular_enum_ext" ) -let Fuzz_Testing_Extensions_SingularGroup_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_SingularGroup_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1017, - fieldName: "fuzz.testing.singulargroup_ext" + fieldName: "swift_proto_testing.fuzz.singulargroup_ext" ) -let Fuzz_Testing_Extensions_singular_message_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_singular_message_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1019, - fieldName: "fuzz.testing.singular_message_ext" + fieldName: "swift_proto_testing.fuzz.singular_message_ext" ) /// Repeated -let Fuzz_Testing_Extensions_repeated_int32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_int32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1031, - fieldName: "fuzz.testing.repeated_int32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_int32_ext" ) -let Fuzz_Testing_Extensions_repeated_int64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_int64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1032, - fieldName: "fuzz.testing.repeated_int64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_int64_ext" ) -let Fuzz_Testing_Extensions_repeated_uint32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_uint32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1033, - fieldName: "fuzz.testing.repeated_uint32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_uint32_ext" ) -let Fuzz_Testing_Extensions_repeated_uint64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_uint64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1034, - fieldName: "fuzz.testing.repeated_uint64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_uint64_ext" ) -let Fuzz_Testing_Extensions_repeated_sint32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_sint32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1035, - fieldName: "fuzz.testing.repeated_sint32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_sint32_ext" ) -let Fuzz_Testing_Extensions_repeated_sint64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_sint64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1036, - fieldName: "fuzz.testing.repeated_sint64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_sint64_ext" ) -let Fuzz_Testing_Extensions_repeated_fixed32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_fixed32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1037, - fieldName: "fuzz.testing.repeated_fixed32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_fixed32_ext" ) -let Fuzz_Testing_Extensions_repeated_fixed64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_fixed64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1038, - fieldName: "fuzz.testing.repeated_fixed64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_fixed64_ext" ) -let Fuzz_Testing_Extensions_repeated_sfixed32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1039, - fieldName: "fuzz.testing.repeated_sfixed32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_sfixed32_ext" ) -let Fuzz_Testing_Extensions_repeated_sfixed64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_sfixed64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1040, - fieldName: "fuzz.testing.repeated_sfixed64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_sfixed64_ext" ) -let Fuzz_Testing_Extensions_repeated_float_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_float_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1041, - fieldName: "fuzz.testing.repeated_float_ext" + fieldName: "swift_proto_testing.fuzz.repeated_float_ext" ) -let Fuzz_Testing_Extensions_repeated_double_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_double_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1042, - fieldName: "fuzz.testing.repeated_double_ext" + fieldName: "swift_proto_testing.fuzz.repeated_double_ext" ) -let Fuzz_Testing_Extensions_repeated_bool_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_bool_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1043, - fieldName: "fuzz.testing.repeated_bool_ext" + fieldName: "swift_proto_testing.fuzz.repeated_bool_ext" ) -let Fuzz_Testing_Extensions_repeated_string_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_string_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1044, - fieldName: "fuzz.testing.repeated_string_ext" + fieldName: "swift_proto_testing.fuzz.repeated_string_ext" ) -let Fuzz_Testing_Extensions_repeated_bytes_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_bytes_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1045, - fieldName: "fuzz.testing.repeated_bytes_ext" + fieldName: "swift_proto_testing.fuzz.repeated_bytes_ext" ) -let Fuzz_Testing_Extensions_repeated_enum_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_enum_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1046, - fieldName: "fuzz.testing.repeated_enum_ext" + fieldName: "swift_proto_testing.fuzz.repeated_enum_ext" ) -let Fuzz_Testing_Extensions_RepeatedGroup_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_RepeatedGroup_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1047, - fieldName: "fuzz.testing.repeatedgroup_ext" + fieldName: "swift_proto_testing.fuzz.repeatedgroup_ext" ) -let Fuzz_Testing_Extensions_repeated_message_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_message_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1049, - fieldName: "fuzz.testing.repeated_message_ext" + fieldName: "swift_proto_testing.fuzz.repeated_message_ext" ) /// Repeated Packed -let Fuzz_Testing_Extensions_repeated_packed_int32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1061, - fieldName: "fuzz.testing.repeated_packed_int32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_int32_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_int64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_int64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1062, - fieldName: "fuzz.testing.repeated_packed_int64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_int64_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_uint32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1063, - fieldName: "fuzz.testing.repeated_packed_uint32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_uint32_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_uint64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_uint64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1064, - fieldName: "fuzz.testing.repeated_packed_uint64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_uint64_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_sint32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1065, - fieldName: "fuzz.testing.repeated_packed_sint32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_sint32_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_sint64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sint64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1066, - fieldName: "fuzz.testing.repeated_packed_sint64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_sint64_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_fixed32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1067, - fieldName: "fuzz.testing.repeated_packed_fixed32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_fixed32_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_fixed64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_fixed64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1068, - fieldName: "fuzz.testing.repeated_packed_fixed64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_fixed64_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_sfixed32_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed32_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1069, - fieldName: "fuzz.testing.repeated_packed_sfixed32_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_sfixed32_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_sfixed64_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_sfixed64_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1070, - fieldName: "fuzz.testing.repeated_packed_sfixed64_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_sfixed64_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_float_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_float_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1071, - fieldName: "fuzz.testing.repeated_packed_float_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_float_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_double_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_double_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1072, - fieldName: "fuzz.testing.repeated_packed_double_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_double_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_bool_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_bool_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1073, - fieldName: "fuzz.testing.repeated_packed_bool_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_bool_ext" ) -let Fuzz_Testing_Extensions_repeated_packed_enum_ext = SwiftProtobuf.MessageExtension, Fuzz_Testing_Message>( +let SwiftProtoTesting_Fuzz_Extensions_repeated_packed_enum_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_Message>( _protobuf_fieldNumber: 1074, - fieldName: "fuzz.testing.repeated_packed_enum_ext" + fieldName: "swift_proto_testing.fuzz.repeated_packed_enum_ext" ) +extension SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_AMessageSetMessage>( + _protobuf_fieldNumber: 1547769, + fieldName: "swift_proto_testing.fuzz.AMessageSetMessageExtension1" + ) + } +} + +extension SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2 { + enum Extensions { + static let message_set_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Fuzz_AMessageSetMessage>( + _protobuf_fieldNumber: 4135312, + fieldName: "swift_proto_testing.fuzz.AMessageSetMessageExtension2" + ) + } +} + // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "fuzz.testing" +fileprivate let _protobuf_package = "swift_proto_testing.fuzz" -extension Fuzz_Testing_AnEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ZERO"), - 1: .same(proto: "ONE"), - 2: .same(proto: "TWO"), - 3: .same(proto: "THREE"), - ] +extension SwiftProtoTesting_Fuzz_AnEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ZERO\0\u{1}ONE\0\u{1}TWO\0\u{1}THREE\0") } -extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Fuzz_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Message" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "singular_int32"), - 2: .standard(proto: "singular_int64"), - 3: .standard(proto: "singular_uint32"), - 4: .standard(proto: "singular_uint64"), - 5: .standard(proto: "singular_sint32"), - 6: .standard(proto: "singular_sint64"), - 7: .standard(proto: "singular_fixed32"), - 8: .standard(proto: "singular_fixed64"), - 9: .standard(proto: "singular_sfixed32"), - 10: .standard(proto: "singular_sfixed64"), - 11: .standard(proto: "singular_float"), - 12: .standard(proto: "singular_double"), - 13: .standard(proto: "singular_bool"), - 14: .standard(proto: "singular_string"), - 15: .standard(proto: "singular_bytes"), - 16: .standard(proto: "singular_enum"), - 17: .unique(proto: "SingularGroup", json: "singulargroup"), - 19: .standard(proto: "singular_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 46: .standard(proto: "repeated_enum"), - 47: .unique(proto: "RepeatedGroup", json: "repeatedgroup"), - 49: .standard(proto: "repeated_message"), - 61: .standard(proto: "oneof_int32"), - 62: .standard(proto: "oneof_int64"), - 63: .standard(proto: "oneof_uint32"), - 64: .standard(proto: "oneof_uint64"), - 65: .standard(proto: "oneof_sint32"), - 66: .standard(proto: "oneof_sint64"), - 67: .standard(proto: "oneof_fixed32"), - 68: .standard(proto: "oneof_fixed64"), - 69: .standard(proto: "oneof_sfixed32"), - 70: .standard(proto: "oneof_sfixed64"), - 71: .standard(proto: "oneof_float"), - 72: .standard(proto: "oneof_double"), - 73: .standard(proto: "oneof_bool"), - 74: .standard(proto: "oneof_string"), - 75: .standard(proto: "oneof_bytes"), - 76: .standard(proto: "oneof_enum"), - 77: .unique(proto: "OneofGroup", json: "oneofgroup"), - 79: .standard(proto: "oneof_message"), - 81: .standard(proto: "repeated_packed_int32"), - 82: .standard(proto: "repeated_packed_int64"), - 83: .standard(proto: "repeated_packed_uint32"), - 84: .standard(proto: "repeated_packed_uint64"), - 85: .standard(proto: "repeated_packed_sint32"), - 86: .standard(proto: "repeated_packed_sint64"), - 87: .standard(proto: "repeated_packed_fixed32"), - 88: .standard(proto: "repeated_packed_fixed64"), - 89: .standard(proto: "repeated_packed_sfixed32"), - 90: .standard(proto: "repeated_packed_sfixed64"), - 91: .standard(proto: "repeated_packed_float"), - 92: .standard(proto: "repeated_packed_double"), - 93: .standard(proto: "repeated_packed_bool"), - 94: .standard(proto: "repeated_packed_enum"), - 100: .standard(proto: "map_int32_int32"), - 101: .standard(proto: "map_int32_int64"), - 102: .standard(proto: "map_int32_uint32"), - 103: .standard(proto: "map_int32_uint64"), - 104: .standard(proto: "map_int32_sint32"), - 105: .standard(proto: "map_int32_sint64"), - 106: .standard(proto: "map_int32_fixed32"), - 107: .standard(proto: "map_int32_fixed64"), - 108: .standard(proto: "map_int32_sfixed32"), - 109: .standard(proto: "map_int32_sfixed64"), - 110: .standard(proto: "map_int32_float"), - 111: .standard(proto: "map_int32_double"), - 112: .standard(proto: "map_int32_bool"), - 113: .standard(proto: "map_int32_string"), - 114: .standard(proto: "map_int32_bytes"), - 115: .standard(proto: "map_int32_AnEnum"), - 116: .standard(proto: "map_int32_Message"), - 117: .standard(proto: "map_int64_int32"), - 118: .standard(proto: "map_int64_int64"), - 119: .standard(proto: "map_int64_uint32"), - 120: .standard(proto: "map_int64_uint64"), - 121: .standard(proto: "map_int64_sint32"), - 122: .standard(proto: "map_int64_sint64"), - 123: .standard(proto: "map_int64_fixed32"), - 124: .standard(proto: "map_int64_fixed64"), - 125: .standard(proto: "map_int64_sfixed32"), - 126: .standard(proto: "map_int64_sfixed64"), - 127: .standard(proto: "map_int64_float"), - 128: .standard(proto: "map_int64_double"), - 129: .standard(proto: "map_int64_bool"), - 130: .standard(proto: "map_int64_string"), - 131: .standard(proto: "map_int64_bytes"), - 132: .standard(proto: "map_int64_AnEnum"), - 133: .standard(proto: "map_int64_Message"), - 134: .standard(proto: "map_uint32_int32"), - 135: .standard(proto: "map_uint32_int64"), - 136: .standard(proto: "map_uint32_uint32"), - 137: .standard(proto: "map_uint32_uint64"), - 138: .standard(proto: "map_uint32_sint32"), - 139: .standard(proto: "map_uint32_sint64"), - 140: .standard(proto: "map_uint32_fixed32"), - 141: .standard(proto: "map_uint32_fixed64"), - 142: .standard(proto: "map_uint32_sfixed32"), - 143: .standard(proto: "map_uint32_sfixed64"), - 144: .standard(proto: "map_uint32_float"), - 145: .standard(proto: "map_uint32_double"), - 146: .standard(proto: "map_uint32_bool"), - 147: .standard(proto: "map_uint32_string"), - 148: .standard(proto: "map_uint32_bytes"), - 149: .standard(proto: "map_uint32_AnEnum"), - 150: .standard(proto: "map_uint32_Message"), - 151: .standard(proto: "map_uint64_int32"), - 152: .standard(proto: "map_uint64_int64"), - 153: .standard(proto: "map_uint64_uint32"), - 154: .standard(proto: "map_uint64_uint64"), - 155: .standard(proto: "map_uint64_sint32"), - 156: .standard(proto: "map_uint64_sint64"), - 157: .standard(proto: "map_uint64_fixed32"), - 158: .standard(proto: "map_uint64_fixed64"), - 159: .standard(proto: "map_uint64_sfixed32"), - 160: .standard(proto: "map_uint64_sfixed64"), - 161: .standard(proto: "map_uint64_float"), - 162: .standard(proto: "map_uint64_double"), - 163: .standard(proto: "map_uint64_bool"), - 164: .standard(proto: "map_uint64_string"), - 165: .standard(proto: "map_uint64_bytes"), - 166: .standard(proto: "map_uint64_AnEnum"), - 167: .standard(proto: "map_uint64_Message"), - 168: .standard(proto: "map_sint32_int32"), - 169: .standard(proto: "map_sint32_int64"), - 170: .standard(proto: "map_sint32_uint32"), - 171: .standard(proto: "map_sint32_uint64"), - 172: .standard(proto: "map_sint32_sint32"), - 173: .standard(proto: "map_sint32_sint64"), - 174: .standard(proto: "map_sint32_fixed32"), - 175: .standard(proto: "map_sint32_fixed64"), - 176: .standard(proto: "map_sint32_sfixed32"), - 177: .standard(proto: "map_sint32_sfixed64"), - 178: .standard(proto: "map_sint32_float"), - 179: .standard(proto: "map_sint32_double"), - 180: .standard(proto: "map_sint32_bool"), - 181: .standard(proto: "map_sint32_string"), - 182: .standard(proto: "map_sint32_bytes"), - 183: .standard(proto: "map_sint32_AnEnum"), - 184: .standard(proto: "map_sint32_Message"), - 185: .standard(proto: "map_sint64_int32"), - 186: .standard(proto: "map_sint64_int64"), - 187: .standard(proto: "map_sint64_uint32"), - 188: .standard(proto: "map_sint64_uint64"), - 189: .standard(proto: "map_sint64_sint32"), - 190: .standard(proto: "map_sint64_sint64"), - 191: .standard(proto: "map_sint64_fixed32"), - 192: .standard(proto: "map_sint64_fixed64"), - 193: .standard(proto: "map_sint64_sfixed32"), - 194: .standard(proto: "map_sint64_sfixed64"), - 195: .standard(proto: "map_sint64_float"), - 196: .standard(proto: "map_sint64_double"), - 197: .standard(proto: "map_sint64_bool"), - 198: .standard(proto: "map_sint64_string"), - 199: .standard(proto: "map_sint64_bytes"), - 200: .standard(proto: "map_sint64_AnEnum"), - 201: .standard(proto: "map_sint64_Message"), - 202: .standard(proto: "map_fixed32_int32"), - 203: .standard(proto: "map_fixed32_int64"), - 204: .standard(proto: "map_fixed32_uint32"), - 205: .standard(proto: "map_fixed32_uint64"), - 206: .standard(proto: "map_fixed32_sint32"), - 207: .standard(proto: "map_fixed32_sint64"), - 208: .standard(proto: "map_fixed32_fixed32"), - 209: .standard(proto: "map_fixed32_fixed64"), - 210: .standard(proto: "map_fixed32_sfixed32"), - 211: .standard(proto: "map_fixed32_sfixed64"), - 212: .standard(proto: "map_fixed32_float"), - 213: .standard(proto: "map_fixed32_double"), - 214: .standard(proto: "map_fixed32_bool"), - 215: .standard(proto: "map_fixed32_string"), - 216: .standard(proto: "map_fixed32_bytes"), - 217: .standard(proto: "map_fixed32_AnEnum"), - 218: .standard(proto: "map_fixed32_Message"), - 219: .standard(proto: "map_fixed64_int32"), - 220: .standard(proto: "map_fixed64_int64"), - 221: .standard(proto: "map_fixed64_uint32"), - 222: .standard(proto: "map_fixed64_uint64"), - 223: .standard(proto: "map_fixed64_sint32"), - 224: .standard(proto: "map_fixed64_sint64"), - 225: .standard(proto: "map_fixed64_fixed32"), - 226: .standard(proto: "map_fixed64_fixed64"), - 227: .standard(proto: "map_fixed64_sfixed32"), - 228: .standard(proto: "map_fixed64_sfixed64"), - 229: .standard(proto: "map_fixed64_float"), - 230: .standard(proto: "map_fixed64_double"), - 231: .standard(proto: "map_fixed64_bool"), - 232: .standard(proto: "map_fixed64_string"), - 233: .standard(proto: "map_fixed64_bytes"), - 234: .standard(proto: "map_fixed64_AnEnum"), - 235: .standard(proto: "map_fixed64_Message"), - 236: .standard(proto: "map_sfixed32_int32"), - 237: .standard(proto: "map_sfixed32_int64"), - 238: .standard(proto: "map_sfixed32_uint32"), - 239: .standard(proto: "map_sfixed32_uint64"), - 240: .standard(proto: "map_sfixed32_sint32"), - 241: .standard(proto: "map_sfixed32_sint64"), - 242: .standard(proto: "map_sfixed32_fixed32"), - 243: .standard(proto: "map_sfixed32_fixed64"), - 244: .standard(proto: "map_sfixed32_sfixed32"), - 245: .standard(proto: "map_sfixed32_sfixed64"), - 246: .standard(proto: "map_sfixed32_float"), - 247: .standard(proto: "map_sfixed32_double"), - 248: .standard(proto: "map_sfixed32_bool"), - 249: .standard(proto: "map_sfixed32_string"), - 250: .standard(proto: "map_sfixed32_bytes"), - 251: .standard(proto: "map_sfixed32_AnEnum"), - 252: .standard(proto: "map_sfixed32_Message"), - 253: .standard(proto: "map_sfixed64_int32"), - 254: .standard(proto: "map_sfixed64_int64"), - 255: .standard(proto: "map_sfixed64_uint32"), - 256: .standard(proto: "map_sfixed64_uint64"), - 257: .standard(proto: "map_sfixed64_sint32"), - 258: .standard(proto: "map_sfixed64_sint64"), - 259: .standard(proto: "map_sfixed64_fixed32"), - 260: .standard(proto: "map_sfixed64_fixed64"), - 261: .standard(proto: "map_sfixed64_sfixed32"), - 262: .standard(proto: "map_sfixed64_sfixed64"), - 263: .standard(proto: "map_sfixed64_float"), - 264: .standard(proto: "map_sfixed64_double"), - 265: .standard(proto: "map_sfixed64_bool"), - 266: .standard(proto: "map_sfixed64_string"), - 267: .standard(proto: "map_sfixed64_bytes"), - 268: .standard(proto: "map_sfixed64_AnEnum"), - 269: .standard(proto: "map_sfixed64_Message"), - 270: .standard(proto: "map_bool_int32"), - 271: .standard(proto: "map_bool_int64"), - 272: .standard(proto: "map_bool_uint32"), - 273: .standard(proto: "map_bool_uint64"), - 274: .standard(proto: "map_bool_sint32"), - 275: .standard(proto: "map_bool_sint64"), - 276: .standard(proto: "map_bool_fixed32"), - 277: .standard(proto: "map_bool_fixed64"), - 278: .standard(proto: "map_bool_sfixed32"), - 279: .standard(proto: "map_bool_sfixed64"), - 280: .standard(proto: "map_bool_float"), - 281: .standard(proto: "map_bool_double"), - 282: .standard(proto: "map_bool_bool"), - 283: .standard(proto: "map_bool_string"), - 284: .standard(proto: "map_bool_bytes"), - 285: .standard(proto: "map_bool_AnEnum"), - 286: .standard(proto: "map_bool_Message"), - 500: .standard(proto: "wkt_any"), - 501: .standard(proto: "wkt_api"), - 502: .standard(proto: "wkt_duration"), - 503: .standard(proto: "wkt_empty"), - 504: .standard(proto: "wkt_field_mask"), - 505: .standard(proto: "wkt_source_context"), - 506: .standard(proto: "wkt_struct"), - 507: .standard(proto: "wkt_timestamp"), - 508: .standard(proto: "wkt_type"), - 509: .standard(proto: "wkt_double_value"), - 510: .standard(proto: "wkt_float_value"), - 511: .standard(proto: "wkt_int64_value"), - 512: .standard(proto: "wkt_uint64_value"), - 513: .standard(proto: "wkt_int32_value"), - 514: .standard(proto: "wkt_uint32_value"), - 515: .standard(proto: "wkt_bool_value"), - 516: .standard(proto: "wkt_string_value"), - 517: .standard(proto: "wkt_bytes_value"), - 600: .standard(proto: "singular_message_set"), - 601: .standard(proto: "repeated_message_set"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}singular_int32\0\u{3}singular_int64\0\u{3}singular_uint32\0\u{3}singular_uint64\0\u{3}singular_sint32\0\u{3}singular_sint64\0\u{3}singular_fixed32\0\u{3}singular_fixed64\0\u{3}singular_sfixed32\0\u{3}singular_sfixed64\0\u{3}singular_float\0\u{3}singular_double\0\u{3}singular_bool\0\u{3}singular_string\0\u{3}singular_bytes\0\u{3}singular_enum\0\u{7}SingularGroup\0\u{4}\u{2}singular_message\0\u{4}\u{c}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{3}repeated_enum\0\u{7}RepeatedGroup\0\u{4}\u{2}repeated_message\0\u{4}\u{c}oneof_int32\0\u{3}oneof_int64\0\u{3}oneof_uint32\0\u{3}oneof_uint64\0\u{3}oneof_sint32\0\u{3}oneof_sint64\0\u{3}oneof_fixed32\0\u{3}oneof_fixed64\0\u{3}oneof_sfixed32\0\u{3}oneof_sfixed64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_bool\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_enum\0\u{7}OneofGroup\0\u{4}\u{2}oneof_message\0\u{4}\u{2}repeated_packed_int32\0\u{3}repeated_packed_int64\0\u{3}repeated_packed_uint32\0\u{3}repeated_packed_uint64\0\u{3}repeated_packed_sint32\0\u{3}repeated_packed_sint64\0\u{3}repeated_packed_fixed32\0\u{3}repeated_packed_fixed64\0\u{3}repeated_packed_sfixed32\0\u{3}repeated_packed_sfixed64\0\u{3}repeated_packed_float\0\u{3}repeated_packed_double\0\u{3}repeated_packed_bool\0\u{3}repeated_packed_enum\0\u{4}\u{6}map_int32_int32\0\u{3}map_int32_int64\0\u{3}map_int32_uint32\0\u{3}map_int32_uint64\0\u{3}map_int32_sint32\0\u{3}map_int32_sint64\0\u{3}map_int32_fixed32\0\u{3}map_int32_fixed64\0\u{3}map_int32_sfixed32\0\u{3}map_int32_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_int32_bool\0\u{3}map_int32_string\0\u{3}map_int32_bytes\0\u{3}map_int32_AnEnum\0\u{3}map_int32_Message\0\u{3}map_int64_int32\0\u{3}map_int64_int64\0\u{3}map_int64_uint32\0\u{3}map_int64_uint64\0\u{3}map_int64_sint32\0\u{3}map_int64_sint64\0\u{3}map_int64_fixed32\0\u{3}map_int64_fixed64\0\u{3}map_int64_sfixed32\0\u{3}map_int64_sfixed64\0\u{3}map_int64_float\0\u{3}map_int64_double\0\u{3}map_int64_bool\0\u{3}map_int64_string\0\u{3}map_int64_bytes\0\u{3}map_int64_AnEnum\0\u{3}map_int64_Message\0\u{3}map_uint32_int32\0\u{3}map_uint32_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint32_uint64\0\u{3}map_uint32_sint32\0\u{3}map_uint32_sint64\0\u{3}map_uint32_fixed32\0\u{3}map_uint32_fixed64\0\u{3}map_uint32_sfixed32\0\u{3}map_uint32_sfixed64\0\u{3}map_uint32_float\0\u{3}map_uint32_double\0\u{3}map_uint32_bool\0\u{3}map_uint32_string\0\u{3}map_uint32_bytes\0\u{3}map_uint32_AnEnum\0\u{3}map_uint32_Message\0\u{3}map_uint64_int32\0\u{3}map_uint64_int64\0\u{3}map_uint64_uint32\0\u{3}map_uint64_uint64\0\u{3}map_uint64_sint32\0\u{3}map_uint64_sint64\0\u{3}map_uint64_fixed32\0\u{3}map_uint64_fixed64\0\u{3}map_uint64_sfixed32\0\u{3}map_uint64_sfixed64\0\u{3}map_uint64_float\0\u{3}map_uint64_double\0\u{3}map_uint64_bool\0\u{3}map_uint64_string\0\u{3}map_uint64_bytes\0\u{3}map_uint64_AnEnum\0\u{3}map_uint64_Message\0\u{3}map_sint32_int32\0\u{3}map_sint32_int64\0\u{3}map_sint32_uint32\0\u{3}map_sint32_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint32_sint64\0\u{3}map_sint32_fixed32\0\u{3}map_sint32_fixed64\0\u{3}map_sint32_sfixed32\0\u{3}map_sint32_sfixed64\0\u{3}map_sint32_float\0\u{3}map_sint32_double\0\u{3}map_sint32_bool\0\u{3}map_sint32_string\0\u{3}map_sint32_bytes\0\u{3}map_sint32_AnEnum\0\u{3}map_sint32_Message\0\u{3}map_sint64_int32\0\u{3}map_sint64_int64\0\u{3}map_sint64_uint32\0\u{3}map_sint64_uint64\0\u{3}map_sint64_sint32\0\u{3}map_sint64_sint64\0\u{3}map_sint64_fixed32\0\u{3}map_sint64_fixed64\0\u{3}map_sint64_sfixed32\0\u{3}map_sint64_sfixed64\0\u{3}map_sint64_float\0\u{3}map_sint64_double\0\u{3}map_sint64_bool\0\u{3}map_sint64_string\0\u{3}map_sint64_bytes\0\u{3}map_sint64_AnEnum\0\u{3}map_sint64_Message\0\u{3}map_fixed32_int32\0\u{3}map_fixed32_int64\0\u{3}map_fixed32_uint32\0\u{3}map_fixed32_uint64\0\u{3}map_fixed32_sint32\0\u{3}map_fixed32_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed32_fixed64\0\u{3}map_fixed32_sfixed32\0\u{3}map_fixed32_sfixed64\0\u{3}map_fixed32_float\0\u{3}map_fixed32_double\0\u{3}map_fixed32_bool\0\u{3}map_fixed32_string\0\u{3}map_fixed32_bytes\0\u{3}map_fixed32_AnEnum\0\u{3}map_fixed32_Message\0\u{3}map_fixed64_int32\0\u{3}map_fixed64_int64\0\u{3}map_fixed64_uint32\0\u{3}map_fixed64_uint64\0\u{3}map_fixed64_sint32\0\u{3}map_fixed64_sint64\0\u{3}map_fixed64_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_fixed64_sfixed32\0\u{3}map_fixed64_sfixed64\0\u{3}map_fixed64_float\0\u{3}map_fixed64_double\0\u{3}map_fixed64_bool\0\u{3}map_fixed64_string\0\u{3}map_fixed64_bytes\0\u{3}map_fixed64_AnEnum\0\u{3}map_fixed64_Message\0\u{3}map_sfixed32_int32\0\u{3}map_sfixed32_int64\0\u{3}map_sfixed32_uint32\0\u{3}map_sfixed32_uint64\0\u{3}map_sfixed32_sint32\0\u{3}map_sfixed32_sint64\0\u{3}map_sfixed32_fixed32\0\u{3}map_sfixed32_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed32_sfixed64\0\u{3}map_sfixed32_float\0\u{3}map_sfixed32_double\0\u{3}map_sfixed32_bool\0\u{3}map_sfixed32_string\0\u{3}map_sfixed32_bytes\0\u{3}map_sfixed32_AnEnum\0\u{3}map_sfixed32_Message\0\u{3}map_sfixed64_int32\0\u{3}map_sfixed64_int64\0\u{3}map_sfixed64_uint32\0\u{3}map_sfixed64_uint64\0\u{3}map_sfixed64_sint32\0\u{3}map_sfixed64_sint64\0\u{3}map_sfixed64_fixed32\0\u{3}map_sfixed64_fixed64\0\u{3}map_sfixed64_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_sfixed64_float\0\u{3}map_sfixed64_double\0\u{3}map_sfixed64_bool\0\u{3}map_sfixed64_string\0\u{3}map_sfixed64_bytes\0\u{3}map_sfixed64_AnEnum\0\u{3}map_sfixed64_Message\0\u{3}map_bool_int32\0\u{3}map_bool_int64\0\u{3}map_bool_uint32\0\u{3}map_bool_uint64\0\u{3}map_bool_sint32\0\u{3}map_bool_sint64\0\u{3}map_bool_fixed32\0\u{3}map_bool_fixed64\0\u{3}map_bool_sfixed32\0\u{3}map_bool_sfixed64\0\u{3}map_bool_float\0\u{3}map_bool_double\0\u{3}map_bool_bool\0\u{3}map_bool_string\0\u{3}map_bool_bytes\0\u{3}map_bool_AnEnum\0\u{3}map_bool_Message\0\u{4}V\u{3}wkt_any\0\u{3}wkt_api\0\u{3}wkt_duration\0\u{3}wkt_empty\0\u{3}wkt_field_mask\0\u{3}wkt_source_context\0\u{3}wkt_struct\0\u{3}wkt_timestamp\0\u{3}wkt_type\0\u{3}wkt_double_value\0\u{3}wkt_float_value\0\u{3}wkt_int64_value\0\u{3}wkt_uint64_value\0\u{3}wkt_int32_value\0\u{3}wkt_uint32_value\0\u{3}wkt_bool_value\0\u{3}wkt_string_value\0\u{3}wkt_bytes_value\0\u{4}S\u{1}singular_message_set\0\u{3}repeated_message_set\0") fileprivate class _StorageClass { var _singularInt32: Int32? = nil @@ -3307,9 +2681,9 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _singularBool: Bool? = nil var _singularString: String? = nil var _singularBytes: Data? = nil - var _singularEnum: Fuzz_Testing_AnEnum? = nil - var _singularGroup: Fuzz_Testing_Message.SingularGroup? = nil - var _singularMessage: Fuzz_Testing_Message? = nil + var _singularEnum: SwiftProtoTesting_Fuzz_AnEnum? = nil + var _singularGroup: SwiftProtoTesting_Fuzz_Message.SingularGroup? = nil + var _singularMessage: SwiftProtoTesting_Fuzz_Message? = nil var _repeatedInt32: [Int32] = [] var _repeatedInt64: [Int64] = [] var _repeatedUint32: [UInt32] = [] @@ -3325,10 +2699,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _repeatedBool: [Bool] = [] var _repeatedString: [String] = [] var _repeatedBytes: [Data] = [] - var _repeatedEnum: [Fuzz_Testing_AnEnum] = [] - var _repeatedGroup: [Fuzz_Testing_Message.RepeatedGroup] = [] - var _repeatedMessage: [Fuzz_Testing_Message] = [] - var _o: Fuzz_Testing_Message.OneOf_O? + var _repeatedEnum: [SwiftProtoTesting_Fuzz_AnEnum] = [] + var _repeatedGroup: [SwiftProtoTesting_Fuzz_Message.RepeatedGroup] = [] + var _repeatedMessage: [SwiftProtoTesting_Fuzz_Message] = [] + var _o: SwiftProtoTesting_Fuzz_Message.OneOf_O? var _repeatedPackedInt32: [Int32] = [] var _repeatedPackedInt64: [Int64] = [] var _repeatedPackedUint32: [UInt32] = [] @@ -3342,7 +2716,7 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _repeatedPackedFloat: [Float] = [] var _repeatedPackedDouble: [Double] = [] var _repeatedPackedBool: [Bool] = [] - var _repeatedPackedEnum: [Fuzz_Testing_AnEnum] = [] + var _repeatedPackedEnum: [SwiftProtoTesting_Fuzz_AnEnum] = [] var _mapInt32Int32: Dictionary = [:] var _mapInt32Int64: Dictionary = [:] var _mapInt32Uint32: Dictionary = [:] @@ -3358,8 +2732,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapInt32Bool: Dictionary = [:] var _mapInt32String: Dictionary = [:] var _mapInt32Bytes: Dictionary = [:] - var _mapInt32AnEnum: Dictionary = [:] - var _mapInt32Message: Dictionary = [:] + var _mapInt32AnEnum: Dictionary = [:] + var _mapInt32Message: Dictionary = [:] var _mapInt64Int32: Dictionary = [:] var _mapInt64Int64: Dictionary = [:] var _mapInt64Uint32: Dictionary = [:] @@ -3375,8 +2749,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapInt64Bool: Dictionary = [:] var _mapInt64String: Dictionary = [:] var _mapInt64Bytes: Dictionary = [:] - var _mapInt64AnEnum: Dictionary = [:] - var _mapInt64Message: Dictionary = [:] + var _mapInt64AnEnum: Dictionary = [:] + var _mapInt64Message: Dictionary = [:] var _mapUint32Int32: Dictionary = [:] var _mapUint32Int64: Dictionary = [:] var _mapUint32Uint32: Dictionary = [:] @@ -3392,8 +2766,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapUint32Bool: Dictionary = [:] var _mapUint32String: Dictionary = [:] var _mapUint32Bytes: Dictionary = [:] - var _mapUint32AnEnum: Dictionary = [:] - var _mapUint32Message: Dictionary = [:] + var _mapUint32AnEnum: Dictionary = [:] + var _mapUint32Message: Dictionary = [:] var _mapUint64Int32: Dictionary = [:] var _mapUint64Int64: Dictionary = [:] var _mapUint64Uint32: Dictionary = [:] @@ -3409,8 +2783,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapUint64Bool: Dictionary = [:] var _mapUint64String: Dictionary = [:] var _mapUint64Bytes: Dictionary = [:] - var _mapUint64AnEnum: Dictionary = [:] - var _mapUint64Message: Dictionary = [:] + var _mapUint64AnEnum: Dictionary = [:] + var _mapUint64Message: Dictionary = [:] var _mapSint32Int32: Dictionary = [:] var _mapSint32Int64: Dictionary = [:] var _mapSint32Uint32: Dictionary = [:] @@ -3426,8 +2800,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapSint32Bool: Dictionary = [:] var _mapSint32String: Dictionary = [:] var _mapSint32Bytes: Dictionary = [:] - var _mapSint32AnEnum: Dictionary = [:] - var _mapSint32Message: Dictionary = [:] + var _mapSint32AnEnum: Dictionary = [:] + var _mapSint32Message: Dictionary = [:] var _mapSint64Int32: Dictionary = [:] var _mapSint64Int64: Dictionary = [:] var _mapSint64Uint32: Dictionary = [:] @@ -3443,8 +2817,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapSint64Bool: Dictionary = [:] var _mapSint64String: Dictionary = [:] var _mapSint64Bytes: Dictionary = [:] - var _mapSint64AnEnum: Dictionary = [:] - var _mapSint64Message: Dictionary = [:] + var _mapSint64AnEnum: Dictionary = [:] + var _mapSint64Message: Dictionary = [:] var _mapFixed32Int32: Dictionary = [:] var _mapFixed32Int64: Dictionary = [:] var _mapFixed32Uint32: Dictionary = [:] @@ -3460,8 +2834,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapFixed32Bool: Dictionary = [:] var _mapFixed32String: Dictionary = [:] var _mapFixed32Bytes: Dictionary = [:] - var _mapFixed32AnEnum: Dictionary = [:] - var _mapFixed32Message: Dictionary = [:] + var _mapFixed32AnEnum: Dictionary = [:] + var _mapFixed32Message: Dictionary = [:] var _mapFixed64Int32: Dictionary = [:] var _mapFixed64Int64: Dictionary = [:] var _mapFixed64Uint32: Dictionary = [:] @@ -3477,8 +2851,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapFixed64Bool: Dictionary = [:] var _mapFixed64String: Dictionary = [:] var _mapFixed64Bytes: Dictionary = [:] - var _mapFixed64AnEnum: Dictionary = [:] - var _mapFixed64Message: Dictionary = [:] + var _mapFixed64AnEnum: Dictionary = [:] + var _mapFixed64Message: Dictionary = [:] var _mapSfixed32Int32: Dictionary = [:] var _mapSfixed32Int64: Dictionary = [:] var _mapSfixed32Uint32: Dictionary = [:] @@ -3494,8 +2868,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapSfixed32Bool: Dictionary = [:] var _mapSfixed32String: Dictionary = [:] var _mapSfixed32Bytes: Dictionary = [:] - var _mapSfixed32AnEnum: Dictionary = [:] - var _mapSfixed32Message: Dictionary = [:] + var _mapSfixed32AnEnum: Dictionary = [:] + var _mapSfixed32Message: Dictionary = [:] var _mapSfixed64Int32: Dictionary = [:] var _mapSfixed64Int64: Dictionary = [:] var _mapSfixed64Uint32: Dictionary = [:] @@ -3511,8 +2885,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapSfixed64Bool: Dictionary = [:] var _mapSfixed64String: Dictionary = [:] var _mapSfixed64Bytes: Dictionary = [:] - var _mapSfixed64AnEnum: Dictionary = [:] - var _mapSfixed64Message: Dictionary = [:] + var _mapSfixed64AnEnum: Dictionary = [:] + var _mapSfixed64Message: Dictionary = [:] var _mapBoolInt32: Dictionary = [:] var _mapBoolInt64: Dictionary = [:] var _mapBoolUint32: Dictionary = [:] @@ -3528,8 +2902,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _mapBoolBool: Dictionary = [:] var _mapBoolString: Dictionary = [:] var _mapBoolBytes: Dictionary = [:] - var _mapBoolAnEnum: Dictionary = [:] - var _mapBoolMessage: Dictionary = [:] + var _mapBoolAnEnum: Dictionary = [:] + var _mapBoolMessage: Dictionary = [:] var _wktAny: SwiftProtobuf.Google_Protobuf_Any? = nil var _wktApi: SwiftProtobuf.Google_Protobuf_Api? = nil var _wktDuration: SwiftProtobuf.Google_Protobuf_Duration? = nil @@ -3548,10 +2922,14 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp var _wktBoolValue: SwiftProtobuf.Google_Protobuf_BoolValue? = nil var _wktStringValue: SwiftProtobuf.Google_Protobuf_StringValue? = nil var _wktBytesValue: SwiftProtobuf.Google_Protobuf_BytesValue? = nil - var _singularMessageSet: Fuzz_Testing_AMessageSetMessage? = nil - var _repeatedMessageSet: [Fuzz_Testing_AMessageSetMessage] = [] + var _singularMessageSet: SwiftProtoTesting_Fuzz_AMessageSetMessage? = nil + var _repeatedMessageSet: [SwiftProtoTesting_Fuzz_AMessageSetMessage] = [] - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -4012,7 +3390,7 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp } }() case 76: try { - var v: Fuzz_Testing_AnEnum? + var v: SwiftProtoTesting_Fuzz_AnEnum? try decoder.decodeSingularEnumField(value: &v) if let v = v { if _storage._o != nil {try decoder.handleConflictingOneOf()} @@ -4020,7 +3398,7 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp } }() case 77: try { - var v: Fuzz_Testing_Message.OneofGroup? + var v: SwiftProtoTesting_Fuzz_Message.OneofGroup? var hadOneofValue = false if let current = _storage._o { hadOneofValue = true @@ -4033,7 +3411,7 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp } }() case 79: try { - var v: Fuzz_Testing_Message? + var v: SwiftProtoTesting_Fuzz_Message? var hadOneofValue = false if let current = _storage._o { hadOneofValue = true @@ -4074,8 +3452,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 112: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bool) }() case 113: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32String) }() case 114: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bytes) }() - case 115: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32AnEnum) }() - case 116: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32Message) }() + case 115: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32AnEnum) }() + case 116: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32Message) }() case 117: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int32) }() case 118: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() case 119: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Uint32) }() @@ -4091,8 +3469,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 129: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Bool) }() case 130: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64String) }() case 131: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Bytes) }() - case 132: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt64AnEnum) }() - case 133: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt64Message) }() + case 132: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt64AnEnum) }() + case 133: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt64Message) }() case 134: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Int32) }() case 135: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Int64) }() case 136: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() @@ -4108,8 +3486,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 146: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Bool) }() case 147: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32String) }() case 148: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Bytes) }() - case 149: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapUint32AnEnum) }() - case 150: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapUint32Message) }() + case 149: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapUint32AnEnum) }() + case 150: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapUint32Message) }() case 151: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Int32) }() case 152: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Int64) }() case 153: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Uint32) }() @@ -4125,8 +3503,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 163: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Bool) }() case 164: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64String) }() case 165: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Bytes) }() - case 166: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapUint64AnEnum) }() - case 167: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapUint64Message) }() + case 166: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapUint64AnEnum) }() + case 167: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapUint64Message) }() case 168: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Int32) }() case 169: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Int64) }() case 170: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Uint32) }() @@ -4142,8 +3520,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 180: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Bool) }() case 181: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32String) }() case 182: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Bytes) }() - case 183: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSint32AnEnum) }() - case 184: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSint32Message) }() + case 183: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSint32AnEnum) }() + case 184: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSint32Message) }() case 185: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Int32) }() case 186: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Int64) }() case 187: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Uint32) }() @@ -4159,8 +3537,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 197: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Bool) }() case 198: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64String) }() case 199: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Bytes) }() - case 200: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSint64AnEnum) }() - case 201: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSint64Message) }() + case 200: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSint64AnEnum) }() + case 201: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSint64Message) }() case 202: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Int32) }() case 203: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Int64) }() case 204: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Uint32) }() @@ -4176,8 +3554,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 214: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Bool) }() case 215: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32String) }() case 216: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Bytes) }() - case 217: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapFixed32AnEnum) }() - case 218: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapFixed32Message) }() + case 217: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapFixed32AnEnum) }() + case 218: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapFixed32Message) }() case 219: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Int32) }() case 220: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Int64) }() case 221: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Uint32) }() @@ -4193,8 +3571,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 231: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Bool) }() case 232: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64String) }() case 233: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Bytes) }() - case 234: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapFixed64AnEnum) }() - case 235: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapFixed64Message) }() + case 234: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapFixed64AnEnum) }() + case 235: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapFixed64Message) }() case 236: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Int32) }() case 237: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Int64) }() case 238: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Uint32) }() @@ -4210,8 +3588,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 248: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Bool) }() case 249: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32String) }() case 250: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Bytes) }() - case 251: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSfixed32AnEnum) }() - case 252: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSfixed32Message) }() + case 251: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSfixed32AnEnum) }() + case 252: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSfixed32Message) }() case 253: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Int32) }() case 254: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Int64) }() case 255: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Uint32) }() @@ -4227,8 +3605,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 265: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Bool) }() case 266: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64String) }() case 267: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Bytes) }() - case 268: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSfixed64AnEnum) }() - case 269: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSfixed64Message) }() + case 268: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapSfixed64AnEnum) }() + case 269: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapSfixed64Message) }() case 270: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolInt32) }() case 271: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolInt64) }() case 272: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolUint32) }() @@ -4244,8 +3622,8 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 282: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() case 283: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolString) }() case 284: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBytes) }() - case 285: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapBoolAnEnum) }() - case 286: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapBoolMessage) }() + case 285: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapBoolAnEnum) }() + case 286: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapBoolMessage) }() case 500: try { try decoder.decodeSingularMessageField(value: &_storage._wktAny) }() case 501: try { try decoder.decodeSingularMessageField(value: &_storage._wktApi) }() case 502: try { try decoder.decodeSingularMessageField(value: &_storage._wktDuration) }() @@ -4267,7 +3645,7 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp case 600: try { try decoder.decodeSingularMessageField(value: &_storage._singularMessageSet) }() case 601: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedMessageSet) }() case 1000..<2001: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Fuzz_Testing_Message.self, fieldNumber: fieldNumber) }() + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Fuzz_Message.self, fieldNumber: fieldNumber) }() default: break } } @@ -4551,10 +3929,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bytes, fieldNumber: 114) } if !_storage._mapInt32AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32AnEnum, fieldNumber: 115) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32AnEnum, fieldNumber: 115) } if !_storage._mapInt32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32Message, fieldNumber: 116) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32Message, fieldNumber: 116) } if !_storage._mapInt64Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Int32, fieldNumber: 117) @@ -4602,10 +3980,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Bytes, fieldNumber: 131) } if !_storage._mapInt64AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt64AnEnum, fieldNumber: 132) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt64AnEnum, fieldNumber: 132) } if !_storage._mapInt64Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt64Message, fieldNumber: 133) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt64Message, fieldNumber: 133) } if !_storage._mapUint32Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Int32, fieldNumber: 134) @@ -4653,10 +4031,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Bytes, fieldNumber: 148) } if !_storage._mapUint32AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapUint32AnEnum, fieldNumber: 149) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapUint32AnEnum, fieldNumber: 149) } if !_storage._mapUint32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapUint32Message, fieldNumber: 150) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapUint32Message, fieldNumber: 150) } if !_storage._mapUint64Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Int32, fieldNumber: 151) @@ -4704,10 +4082,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Bytes, fieldNumber: 165) } if !_storage._mapUint64AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapUint64AnEnum, fieldNumber: 166) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapUint64AnEnum, fieldNumber: 166) } if !_storage._mapUint64Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapUint64Message, fieldNumber: 167) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapUint64Message, fieldNumber: 167) } if !_storage._mapSint32Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Int32, fieldNumber: 168) @@ -4755,10 +4133,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Bytes, fieldNumber: 182) } if !_storage._mapSint32AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSint32AnEnum, fieldNumber: 183) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSint32AnEnum, fieldNumber: 183) } if !_storage._mapSint32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSint32Message, fieldNumber: 184) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSint32Message, fieldNumber: 184) } if !_storage._mapSint64Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Int32, fieldNumber: 185) @@ -4806,10 +4184,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Bytes, fieldNumber: 199) } if !_storage._mapSint64AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSint64AnEnum, fieldNumber: 200) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSint64AnEnum, fieldNumber: 200) } if !_storage._mapSint64Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSint64Message, fieldNumber: 201) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSint64Message, fieldNumber: 201) } if !_storage._mapFixed32Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Int32, fieldNumber: 202) @@ -4857,10 +4235,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Bytes, fieldNumber: 216) } if !_storage._mapFixed32AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapFixed32AnEnum, fieldNumber: 217) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapFixed32AnEnum, fieldNumber: 217) } if !_storage._mapFixed32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapFixed32Message, fieldNumber: 218) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapFixed32Message, fieldNumber: 218) } if !_storage._mapFixed64Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Int32, fieldNumber: 219) @@ -4908,10 +4286,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Bytes, fieldNumber: 233) } if !_storage._mapFixed64AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapFixed64AnEnum, fieldNumber: 234) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapFixed64AnEnum, fieldNumber: 234) } if !_storage._mapFixed64Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapFixed64Message, fieldNumber: 235) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapFixed64Message, fieldNumber: 235) } if !_storage._mapSfixed32Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Int32, fieldNumber: 236) @@ -4959,10 +4337,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Bytes, fieldNumber: 250) } if !_storage._mapSfixed32AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSfixed32AnEnum, fieldNumber: 251) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSfixed32AnEnum, fieldNumber: 251) } if !_storage._mapSfixed32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSfixed32Message, fieldNumber: 252) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSfixed32Message, fieldNumber: 252) } if !_storage._mapSfixed64Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Int32, fieldNumber: 253) @@ -5010,10 +4388,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Bytes, fieldNumber: 267) } if !_storage._mapSfixed64AnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSfixed64AnEnum, fieldNumber: 268) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapSfixed64AnEnum, fieldNumber: 268) } if !_storage._mapSfixed64Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSfixed64Message, fieldNumber: 269) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapSfixed64Message, fieldNumber: 269) } if !_storage._mapBoolInt32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolInt32, fieldNumber: 270) @@ -5061,10 +4439,10 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolBytes, fieldNumber: 284) } if !_storage._mapBoolAnEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapBoolAnEnum, fieldNumber: 285) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapBoolAnEnum, fieldNumber: 285) } if !_storage._mapBoolMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapBoolMessage, fieldNumber: 286) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapBoolMessage, fieldNumber: 286) } try { if let v = _storage._wktAny { try visitor.visitSingularMessageField(value: v, fieldNumber: 500) @@ -5131,7 +4509,7 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Fuzz_Testing_Message, rhs: Fuzz_Testing_Message) -> Bool { + static func ==(lhs: SwiftProtoTesting_Fuzz_Message, rhs: SwiftProtoTesting_Fuzz_Message) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -5404,11 +4782,9 @@ extension Fuzz_Testing_Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImp } } -extension Fuzz_Testing_Message.SingularGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = Fuzz_Testing_Message.protoMessageName + ".SingularGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 18: .standard(proto: "group_field"), - ] +extension SwiftProtoTesting_Fuzz_Message.SingularGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Fuzz_Message.protoMessageName + ".SingularGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{12}group_field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -5433,18 +4809,16 @@ extension Fuzz_Testing_Message.SingularGroup: SwiftProtobuf.Message, SwiftProtob try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Fuzz_Testing_Message.SingularGroup, rhs: Fuzz_Testing_Message.SingularGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_Fuzz_Message.SingularGroup, rhs: SwiftProtoTesting_Fuzz_Message.SingularGroup) -> Bool { if lhs._groupField != rhs._groupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Fuzz_Testing_Message.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = Fuzz_Testing_Message.protoMessageName + ".RepeatedGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 48: .standard(proto: "group_field"), - ] +extension SwiftProtoTesting_Fuzz_Message.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Fuzz_Message.protoMessageName + ".RepeatedGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}0group_field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -5469,18 +4843,16 @@ extension Fuzz_Testing_Message.RepeatedGroup: SwiftProtobuf.Message, SwiftProtob try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Fuzz_Testing_Message.RepeatedGroup, rhs: Fuzz_Testing_Message.RepeatedGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_Fuzz_Message.RepeatedGroup, rhs: SwiftProtoTesting_Fuzz_Message.RepeatedGroup) -> Bool { if lhs._groupField != rhs._groupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Fuzz_Testing_Message.OneofGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = Fuzz_Testing_Message.protoMessageName + ".OneofGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 78: .standard(proto: "group_field"), - ] +extension SwiftProtoTesting_Fuzz_Message.OneofGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Fuzz_Message.protoMessageName + ".OneofGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}N\u{1}group_field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -5505,14 +4877,14 @@ extension Fuzz_Testing_Message.OneofGroup: SwiftProtobuf.Message, SwiftProtobuf. try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Fuzz_Testing_Message.OneofGroup, rhs: Fuzz_Testing_Message.OneofGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_Fuzz_Message.OneofGroup, rhs: SwiftProtoTesting_Fuzz_Message.OneofGroup) -> Bool { if lhs._groupField != rhs._groupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Fuzz_Testing_AMessageSetMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Fuzz_AMessageSetMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".AMessageSetMessage" static let _protobuf_nameMap = SwiftProtobuf._NameMap() @@ -5522,7 +4894,7 @@ extension Fuzz_Testing_AMessageSetMessage: SwiftProtobuf.Message, SwiftProtobuf. } mutating func decodeMessage(decoder: inout D) throws { - try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: Fuzz_Testing_AMessageSetMessage.self) + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Fuzz_AMessageSetMessage.self) } func traverse(visitor: inout V) throws { @@ -5530,18 +4902,84 @@ extension Fuzz_Testing_AMessageSetMessage: SwiftProtobuf.Message, SwiftProtobuf. try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Fuzz_Testing_AMessageSetMessage, rhs: Fuzz_Testing_AMessageSetMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Fuzz_AMessageSetMessage, rhs: SwiftProtoTesting_Fuzz_AMessageSetMessage) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension Fuzz_Testing_SingularGroup_ext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".AMessageSetMessageExtension1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{a}a_string\0") + + 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 10: try { try decoder.decodeSingularStringField(value: &self._aString) }() + 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 + try { if let v = self._aString { + try visitor.visitSingularStringField(value: v, fieldNumber: 10) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1, rhs: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension1) -> Bool { + if lhs._aString != rhs._aString {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".AMessageSetMessageExtension2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{14}an_int32\0") + + 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 20: try { try decoder.decodeSingularInt32Field(value: &self._anInt32) }() + 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 + try { if let v = self._anInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 20) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2, rhs: SwiftProtoTesting_Fuzz_AMessageSetMessageExtension2) -> Bool { + if lhs._anInt32 != rhs._anInt32 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Fuzz_SingularGroup_ext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SingularGroup_ext" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1018: .standard(proto: "group_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}z\u{f}group_field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -5566,18 +5004,16 @@ extension Fuzz_Testing_SingularGroup_ext: SwiftProtobuf.Message, SwiftProtobuf._ try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Fuzz_Testing_SingularGroup_ext, rhs: Fuzz_Testing_SingularGroup_ext) -> Bool { + static func ==(lhs: SwiftProtoTesting_Fuzz_SingularGroup_ext, rhs: SwiftProtoTesting_Fuzz_SingularGroup_ext) -> Bool { if lhs._groupField != rhs._groupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Fuzz_Testing_RepeatedGroup_ext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Fuzz_RepeatedGroup_ext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".RepeatedGroup_ext" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1048: .standard(proto: "group_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}X\u{10}group_field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -5602,7 +5038,7 @@ extension Fuzz_Testing_RepeatedGroup_ext: SwiftProtobuf.Message, SwiftProtobuf._ try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Fuzz_Testing_RepeatedGroup_ext, rhs: Fuzz_Testing_RepeatedGroup_ext) -> Bool { + static func ==(lhs: SwiftProtoTesting_Fuzz_RepeatedGroup_ext, rhs: SwiftProtoTesting_Fuzz_RepeatedGroup_ext) -> Bool { if lhs._groupField != rhs._groupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Tests/SwiftProtobufTests/generated_swift_names_enum_cases.pb.swift b/Tests/SwiftProtobufTests/generated_swift_names_enum_cases.pb.swift index d1057efb5..6698d859d 100644 --- a/Tests/SwiftProtobufTests/generated_swift_names_enum_cases.pb.swift +++ b/Tests/SwiftProtobufTests/generated_swift_names_enum_cases.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: generated_swift_names_enum_cases.proto @@ -11,7 +12,6 @@ /// Protoc errors imply this file is being generated incorrectly /// Swift compile errors are probably bugs in protoc-gen-swift -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -24,878 +24,1036 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum { +enum SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case none // = 0 - case adjusted // = 1 - case aggregateValue // = 2 - case allCases_ // = 3 - case allowAlias // = 4 - case alwaysPrintEnumsAsInts // = 5 - case annotation // = 6 - case any // = 7 - case anyExtensionField // = 8 - case anyMessageExtension // = 9 - case anyMessageStorage // = 10 - case anyUnpackError // = 11 - case api // = 12 - case appended // = 13 - case appendUintHex // = 14 - case appendUnknown // = 15 - case areAllInitialized // = 16 - case array // = 17 - case arrayDepth // = 18 - case arrayLiteral // = 19 - case arraySeparator // = 20 - case `as` // = 21 - case asciiOpenCurlyBracket // = 22 - case asciiZero // = 23 - case available // = 24 - case b // = 25 - case base64Values // = 26 - case baseAddress // = 27 - case baseType // = 28 - case begin // = 29 - case binary // = 30 - case binaryDecoder // = 31 - case binaryDecodingError // = 32 - case binaryDecodingOptions // = 33 - case binaryDelimited // = 34 - case binaryEncoder // = 35 - case binaryEncodingError // = 36 - case binaryEncodingMessageSetSizeVisitor // = 37 - case binaryEncodingMessageSetVisitor // = 38 - case binaryEncodingSizeVisitor // = 39 - case binaryEncodingVisitor // = 40 - case binaryOptions // = 41 - case body // = 42 - case bool // = 43 - case booleanLiteral // = 44 - case booleanLiteralType // = 45 - case boolValue // = 46 - case bytes // = 47 - case bytesInGroup // = 48 - case bytesRead // = 49 - case bytesValue // = 50 - case c // = 51 - case capitalizeNext // = 52 - case cardinality // = 53 - case ccEnableArenas // = 54 - case ccGenericServices // = 55 - case character // = 56 - case chars // = 57 - case `class` // = 58 - case clearAggregateValue // = 59 - case clearAllowAlias // = 60 - case clearBegin // = 61 - case clearCcEnableArenas // = 62 - case clearCcGenericServices // = 63 - case clearClientStreaming // = 64 - case clearCsharpNamespace // = 65 - case clearCtype // = 66 - case clearDefaultValue // = 67 - case clearDeprecated // = 68 - case clearDoubleValue // = 69 - case clearEnd // = 70 - case clearExtendee // = 71 - case clearExtensionValue // = 72 - case clearGoPackage // = 73 - case clearIdempotencyLevel // = 74 - case clearIdentifierValue // = 75 - case clearInputType // = 76 - case clearIsExtension // = 77 - case clearJavaGenerateEqualsAndHash // = 78 - case clearJavaGenericServices // = 79 - case clearJavaMultipleFiles // = 80 - case clearJavaOuterClassname // = 81 - case clearJavaPackage // = 82 - case clearJavaStringCheckUtf8 // = 83 - case clearJsonName // = 84 - case clearJstype // = 85 - case clearLabel // = 86 - case clearLazy // = 87 - case clearLeadingComments // = 88 - case clearMapEntry // = 89 - case clearMessageSetWireFormat // = 90 - case clearName // = 91 - case clearNamePart // = 92 - case clearNegativeIntValue // = 93 - case clearNoStandardDescriptorAccessor // = 94 - case clearNumber // = 95 - case clearObjcClassPrefix // = 96 - case clearOneofIndex // = 97 - case clearOptimizeFor // = 98 - case clearOptions // = 99 - case clearOutputType // = 100 - case clearPackage // = 101 - case clearPacked // = 102 - case clearPhpClassPrefix // = 103 - case clearPhpGenericServices // = 104 - case clearPhpMetadataNamespace // = 105 - case clearPhpNamespace // = 106 - case clearPositiveIntValue // = 107 - case clearProto3Optional // = 108 - case clearPyGenericServices // = 109 - case clearRubyPackage // = 110 - case clearServerStreaming // = 111 - case clearSourceCodeInfo // = 112 - case clearSourceContext // = 113 - case clearSourceFile // = 114 - case clearStart // = 115 - case clearStringValue // = 116 - case clearSwiftPrefix // = 117 - case clearSyntax // = 118 - case clearTrailingComments // = 119 - case clearType // = 120 - case clearTypeName // = 121 - case clearValue // = 122 - case clearWeak // = 123 - case clientStreaming // = 124 - case codePoint // = 125 - case codeUnits // = 126 - case collection // = 127 - case com // = 128 - case comma // = 129 - case contentsOf // = 130 - case contiguousBytes // = 131 - case count // = 132 - case countVarintsInBuffer // = 133 - case csharpNamespace // = 134 - case ctype // = 135 - case customCodable // = 136 - case customDebugStringConvertible // = 137 - case d // = 138 - case data // = 139 - case dataResult // = 140 - case date // = 141 - case daySec // = 142 - case daysSinceEpoch // = 143 - case debugDescription_ // = 144 - case decoded // = 145 - case decodedFromJsonnull // = 146 - case decodeExtensionField // = 147 - case decodeExtensionFieldsAsMessageSet // = 148 - case decodeJson // = 149 - case decodeMapField // = 150 - case decodeMessage // = 151 - case decoder // = 152 - case decodeRepeated // = 153 - case decodeRepeatedBoolField // = 154 - case decodeRepeatedBytesField // = 155 - case decodeRepeatedDoubleField // = 156 - case decodeRepeatedEnumField // = 157 - case decodeRepeatedFixed32Field // = 158 - case decodeRepeatedFixed64Field // = 159 - case decodeRepeatedFloatField // = 160 - case decodeRepeatedGroupField // = 161 - case decodeRepeatedInt32Field // = 162 - case decodeRepeatedInt64Field // = 163 - case decodeRepeatedMessageField // = 164 - case decodeRepeatedSfixed32Field // = 165 - case decodeRepeatedSfixed64Field // = 166 - case decodeRepeatedSint32Field // = 167 - case decodeRepeatedSint64Field // = 168 - case decodeRepeatedStringField // = 169 - case decodeRepeatedUint32Field // = 170 - case decodeRepeatedUint64Field // = 171 - case decodeSingular // = 172 - case decodeSingularBoolField // = 173 - case decodeSingularBytesField // = 174 - case decodeSingularDoubleField // = 175 - case decodeSingularEnumField // = 176 - case decodeSingularFixed32Field // = 177 - case decodeSingularFixed64Field // = 178 - case decodeSingularFloatField // = 179 - case decodeSingularGroupField // = 180 - case decodeSingularInt32Field // = 181 - case decodeSingularInt64Field // = 182 - case decodeSingularMessageField // = 183 - case decodeSingularSfixed32Field // = 184 - case decodeSingularSfixed64Field // = 185 - case decodeSingularSint32Field // = 186 - case decodeSingularSint64Field // = 187 - case decodeSingularStringField // = 188 - case decodeSingularUint32Field // = 189 - case decodeSingularUint64Field // = 190 - case decodeTextFormat // = 191 - case defaultAnyTypeUrlprefix // = 192 - case defaultValue // = 193 - case dependency // = 194 - case deprecated // = 195 - case description_ // = 196 - case descriptorProto // = 197 - case dictionary // = 198 - case dictionaryLiteral // = 199 - case digit // = 200 - case digit0 // = 201 - case digit1 // = 202 - case digitCount // = 203 - case digits // = 204 - case digitValue // = 205 - case discardableResult // = 206 - case discardUnknownFields // = 207 - case distance // = 208 - case double // = 209 - case doubleValue // = 210 - case duration // = 211 - case e // = 212 - case element // = 213 - case elements // = 214 - case emitExtensionFieldName // = 215 - case emitFieldName // = 216 - case emitFieldNumber // = 217 - case empty // = 218 - case emptyData // = 219 - case encodeAsBytes // = 220 - case encoded // = 221 - case encodedJsonstring // = 222 - case encodedSize // = 223 - case encodeField // = 224 - case encoder // = 225 - case end // = 226 - case endArray // = 227 - case endMessageField // = 228 - case endObject // = 229 - case endRegularField // = 230 - case `enum` // = 231 - case enumDescriptorProto // = 232 - case enumOptions // = 233 - case enumReservedRange // = 234 - case enumType // = 235 - case enumvalue // = 236 - case enumValueDescriptorProto // = 237 - case enumValueOptions // = 238 - case equatable // = 239 - case error // = 240 - case expressibleByArrayLiteral // = 241 - case expressibleByDictionaryLiteral // = 242 - case ext // = 243 - case extDecoder // = 244 - case extendedGraphemeClusterLiteral // = 245 - case extendedGraphemeClusterLiteralType // = 246 - case extendee // = 247 - case extensibleMessage // = 248 - case `extension` // = 249 - case extensionField // = 250 - case extensionFieldNumber // = 251 - case extensionFieldValueSet // = 252 - case extensionMap // = 253 - case extensionRange // = 254 - case extensionRangeOptions // = 255 - case extensions // = 256 - case extras // = 257 - case f // = 258 - case `false` // = 259 - case field // = 260 - case fieldData // = 261 - case fieldDescriptorProto // = 262 - case fieldMask // = 263 - case fieldName // = 264 - case fieldNameCount // = 265 - case fieldNum // = 266 - case fieldNumber // = 267 - case fieldNumberForProto // = 268 - case fieldOptions // = 269 - case fields // = 270 - case fieldSize // = 271 - case fieldTag // = 272 - case fieldType // = 273 - case file // = 274 - case fileDescriptorProto // = 275 - case fileDescriptorSet // = 276 - case fileName // = 277 - case fileOptions // = 278 - case filter // = 279 - case first // = 280 - case firstItem // = 281 - case float // = 282 - case floatLiteral // = 283 - case floatLiteralType // = 284 - case floatValue // = 285 - case forMessageName // = 286 - case formUnion // = 287 - case forReadingFrom // = 288 - case forTypeURL // = 289 - case forwardParser // = 290 - case forWritingInto // = 291 - case from // = 292 - case fromAscii2 // = 293 - case fromAscii4 // = 294 - case fromByteOffset // = 295 - case fromHexDigit // = 296 - case `func` // = 297 - case g // = 298 - case generatedCodeInfo // = 299 - case get // = 300 - case getExtensionValue // = 301 - case googleapis // = 302 - case googleProtobufAny // = 303 - case googleProtobufApi // = 304 - case googleProtobufBoolValue // = 305 - case googleProtobufBytesValue // = 306 - case googleProtobufDescriptorProto // = 307 - case googleProtobufDoubleValue // = 308 - case googleProtobufDuration // = 309 - case googleProtobufEmpty // = 310 - case googleProtobufEnum // = 311 - case googleProtobufEnumDescriptorProto // = 312 - case googleProtobufEnumOptions // = 313 - case googleProtobufEnumValue // = 314 - case googleProtobufEnumValueDescriptorProto // = 315 - case googleProtobufEnumValueOptions // = 316 - case googleProtobufExtensionRangeOptions // = 317 - case googleProtobufField // = 318 - case googleProtobufFieldDescriptorProto // = 319 - case googleProtobufFieldMask // = 320 - case googleProtobufFieldOptions // = 321 - case googleProtobufFileDescriptorProto // = 322 - case googleProtobufFileDescriptorSet // = 323 - case googleProtobufFileOptions // = 324 - case googleProtobufFloatValue // = 325 - case googleProtobufGeneratedCodeInfo // = 326 - case googleProtobufInt32Value // = 327 - case googleProtobufInt64Value // = 328 - case googleProtobufListValue // = 329 - case googleProtobufMessageOptions // = 330 - case googleProtobufMethod // = 331 - case googleProtobufMethodDescriptorProto // = 332 - case googleProtobufMethodOptions // = 333 - case googleProtobufMixin // = 334 - case googleProtobufNullValue // = 335 - case googleProtobufOneofDescriptorProto // = 336 - case googleProtobufOneofOptions // = 337 - case googleProtobufOption // = 338 - case googleProtobufServiceDescriptorProto // = 339 - case googleProtobufServiceOptions // = 340 - case googleProtobufSourceCodeInfo // = 341 - case googleProtobufSourceContext // = 342 - case googleProtobufStringValue // = 343 - case googleProtobufStruct // = 344 - case googleProtobufSyntax // = 345 - case googleProtobufTimestamp // = 346 - case googleProtobufType // = 347 - case googleProtobufUint32Value // = 348 - case googleProtobufUint64Value // = 349 - case googleProtobufUninterpretedOption // = 350 - case googleProtobufValue // = 351 - case goPackage // = 352 - case group // = 353 - case groupFieldNumberStack // = 354 - case groupSize // = 355 - case h // = 356 - case hadOneofValue // = 357 - case handleConflictingOneOf // = 358 - case hasAggregateValue // = 359 - case hasAllowAlias // = 360 - case hasBegin // = 361 - case hasCcEnableArenas // = 362 - case hasCcGenericServices // = 363 - case hasClientStreaming // = 364 - case hasCsharpNamespace // = 365 - case hasCtype // = 366 - case hasDefaultValue // = 367 - case hasDeprecated // = 368 - case hasDoubleValue // = 369 - case hasEnd // = 370 - case hasExtendee // = 371 - case hasExtensionValue // = 372 - case hasGoPackage // = 373 - case hash // = 374 - case hashable // = 375 - case hasher // = 376 - case hashValue_ // = 377 - case hashVisitor // = 378 - case hasIdempotencyLevel // = 379 - case hasIdentifierValue // = 380 - case hasInputType // = 381 - case hasIsExtension // = 382 - case hasJavaGenerateEqualsAndHash // = 383 - case hasJavaGenericServices // = 384 - case hasJavaMultipleFiles // = 385 - case hasJavaOuterClassname // = 386 - case hasJavaPackage // = 387 - case hasJavaStringCheckUtf8 // = 388 - case hasJsonName // = 389 - case hasJstype // = 390 - case hasLabel // = 391 - case hasLazy // = 392 - case hasLeadingComments // = 393 - case hasMapEntry // = 394 - case hasMessageSetWireFormat // = 395 - case hasName // = 396 - case hasNamePart // = 397 - case hasNegativeIntValue // = 398 - case hasNoStandardDescriptorAccessor // = 399 - case hasNumber // = 400 - case hasObjcClassPrefix // = 401 - case hasOneofIndex // = 402 - case hasOptimizeFor // = 403 - case hasOptions // = 404 - case hasOutputType // = 405 - case hasPackage // = 406 - case hasPacked // = 407 - case hasPhpClassPrefix // = 408 - case hasPhpGenericServices // = 409 - case hasPhpMetadataNamespace // = 410 - case hasPhpNamespace // = 411 - case hasPositiveIntValue // = 412 - case hasProto3Optional // = 413 - case hasPyGenericServices // = 414 - case hasRubyPackage // = 415 - case hasServerStreaming // = 416 - case hasSourceCodeInfo // = 417 - case hasSourceContext // = 418 - case hasSourceFile // = 419 - case hasStart // = 420 - case hasStringValue // = 421 - case hasSwiftPrefix // = 422 - case hasSyntax // = 423 - case hasTrailingComments // = 424 - case hasType // = 425 - case hasTypeName // = 426 - case hasValue // = 427 - case hasWeak // = 428 - case hour // = 429 - case i // = 430 - case idempotencyLevel // = 431 - case identifierValue // = 432 - case `if` // = 433 - case ignoreUnknownFields // = 434 - case index // = 435 - case init_ // = 436 - case `inout` // = 437 - case inputType // = 438 - case insert // = 439 - case int // = 440 - case int32 // = 441 - case int32Value // = 442 - case int64 // = 443 - case int64Value // = 444 - case int8 // = 445 - case integerLiteral // = 446 - case integerLiteralType // = 447 - case intern // = 448 - case `internal` // = 449 - case internalState // = 450 - case into // = 451 - case ints // = 452 - case isA // = 453 - case isEqual // = 454 - case isEqualTo // = 455 - case isExtension // = 456 - case isInitialized // = 457 - case itemTagsEncodedSize // = 458 - case iterator // = 459 - case i2166136261 // = 460 - case javaGenerateEqualsAndHash // = 461 - case javaGenericServices // = 462 - case javaMultipleFiles // = 463 - case javaOuterClassname // = 464 - case javaPackage // = 465 - case javaStringCheckUtf8 // = 466 - case jsondecoder // = 467 - case jsondecodingError // = 468 - case jsondecodingOptions // = 469 - case jsonEncoder // = 470 - case jsonencodingError // = 471 - case jsonencodingOptions // = 472 - case jsonencodingVisitor // = 473 - case jsonmapEncodingVisitor // = 474 - case jsonName // = 475 - case jsonPath // = 476 - case jsonPaths // = 477 - case jsonscanner // = 478 - case jsonString // = 479 - case jsonText // = 480 - case jsonUtf8Data // = 481 - case jstype // = 482 - case k // = 483 - case key // = 484 - case keyField // = 485 - case keyType // = 486 - case kind // = 487 - case l // = 488 - case label // = 489 - case lazy // = 490 - case leadingComments // = 491 - case leadingDetachedComments // = 492 - case length // = 493 - case lessThan // = 494 - case `let` // = 495 - case lhs // = 496 - case list // = 497 - case listOfMessages // = 498 - case listValue // = 499 - case littleEndian // = 500 - case littleEndianBytes // = 501 - case load // = 502 - case localHasher // = 503 - case location // = 504 - case m // = 505 - case major // = 506 - case makeIterator // = 507 - case mapEntry // = 508 - case mapHash // = 509 - case mapKeyType // = 510 - case mapNameResolver // = 511 - case mapToMessages // = 512 - case mapValueType // = 513 - case mapVisitor // = 514 - case mdayStart // = 515 - case merge // = 516 - case message // = 517 - case messageDepthLimit // = 518 - case messageExtension // = 519 - case messageImplementationBase // = 520 - case messageOptions // = 521 - case messageSet // = 522 - case messageSetWireFormat // = 523 - case messageType // = 524 - case method // = 525 - case methodDescriptorProto // = 526 - case methodOptions // = 527 - case methods // = 528 - case minor // = 529 - case mixin // = 530 - case mixins // = 531 - case modifier // = 532 - case modify // = 533 - case month // = 534 - case msgExtension // = 535 - case mutating // = 536 - case n // = 537 - case name // = 538 - case nameDescription // = 539 - case nameMap // = 540 - case namePart // = 541 - case nameResolver // = 542 - case names // = 543 - case nanos // = 544 - case nativeBytes // = 545 - case nativeEndianBytes // = 546 - case negativeIntValue // = 547 - case nestedType // = 548 - case newL // = 549 - case newList // = 550 - case newValue // = 551 - case nextByte // = 552 - case nextFieldNumber // = 553 - case `nil` // = 554 - case nilLiteral // = 555 - case noStandardDescriptorAccessor // = 556 - case nullValue // = 557 - case number // = 558 - case numberValue // = 559 - case objcClassPrefix // = 560 - case of // = 561 - case oneofDecl // = 562 - case oneofDescriptorProto // = 563 - case oneofIndex // = 564 - case oneofOptions // = 565 - case oneofs // = 566 - case oneOfKind // = 567 - case optimizeFor // = 568 - case optimizeMode // = 569 - case option // = 570 - case optionalEnumExtensionField // = 571 - case optionalExtensionField // = 572 - case optionalGroupExtensionField // = 573 - case optionalMessageExtensionField // = 574 - case options // = 575 - case other // = 576 - case others // = 577 - case out // = 578 - case outputType // = 579 - case p // = 580 - case package // = 581 - case packed // = 582 - case packedEnumExtensionField // = 583 - case packedExtensionField // = 584 - case padding // = 585 - case parent // = 586 - case parse // = 587 - case partial // = 588 - case path // = 589 - case paths // = 590 - case payload // = 591 - case payloadSize // = 592 - case phpClassPrefix // = 593 - case phpGenericServices // = 594 - case phpMetadataNamespace // = 595 - case phpNamespace // = 596 - case pointer // = 597 - case pos // = 598 - case positiveIntValue // = 599 - case prefix // = 600 - case preserveProtoFieldNames // = 601 - case preTraverse // = 602 - case printUnknownFields // = 603 - case proto2 // = 604 - case proto3DefaultValue // = 605 - case proto3Optional // = 606 - case protobufApiversionCheck // = 607 - case protobufApiversion2 // = 608 - case protobufBool // = 609 - case protobufBytes // = 610 - case protobufDouble // = 611 - case protobufEnumMap // = 612 - case protobufExtension // = 613 - case protobufFixed32 // = 614 - case protobufFixed64 // = 615 - case protobufFloat // = 616 - case protobufInt32 // = 617 - case protobufInt64 // = 618 - case protobufMap // = 619 - case protobufMessageMap // = 620 - case protobufSfixed32 // = 621 - case protobufSfixed64 // = 622 - case protobufSint32 // = 623 - case protobufSint64 // = 624 - case protobufString // = 625 - case protobufUint32 // = 626 - case protobufUint64 // = 627 - case protobufExtensionFieldValues // = 628 - case protobufFieldNumber // = 629 - case protobufGeneratedIsEqualTo // = 630 - case protobufNameMap // = 631 - case protobufNewField // = 632 - case protobufPackage // = 633 - case `protocol` // = 634 - case protoFieldName // = 635 - case protoMessageName // = 636 - case protoNameProviding // = 637 - case protoPaths // = 638 - case `public` // = 639 - case publicDependency // = 640 - case putBoolValue // = 641 - case putBytesValue // = 642 - case putDoubleValue // = 643 - case putEnumValue // = 644 - case putFixedUint32 // = 645 - case putFixedUint64 // = 646 - case putFloatValue // = 647 - case putInt64 // = 648 - case putStringValue // = 649 - case putUint64 // = 650 - case putUint64Hex // = 651 - case putVarInt // = 652 - case putZigZagVarInt // = 653 - case pyGenericServices // = 654 - case rawChars // = 655 - case rawRepresentable // = 656 - case rawValue_ // = 657 - case read4HexDigits // = 658 - case register // = 659 - case repeatedEnumExtensionField // = 660 - case repeatedExtensionField // = 661 - case repeatedGroupExtensionField // = 662 - case repeatedMessageExtensionField // = 663 - case requestStreaming // = 664 - case requestTypeURL // = 665 - case requiredSize // = 666 - case reservedName // = 667 - case reservedRange // = 668 - case responseStreaming // = 669 - case responseTypeURL // = 670 - case result // = 671 - case `rethrows` // = 672 - case `return` // = 673 - case returnType // = 674 - case revision // = 675 - case rhs // = 676 - case root // = 677 - case rubyPackage // = 678 - case s // = 679 - case sawBackslash // = 680 - case sawSection4Characters // = 681 - case sawSection5Characters // = 682 - case scanner // = 683 - case seconds // = 684 - case self_ // = 685 - case separator // = 686 - case serialize // = 687 - case serializedData // = 688 - case serializedSize // = 689 - case serverStreaming // = 690 - case service // = 691 - case serviceDescriptorProto // = 692 - case serviceOptions // = 693 - case set // = 694 - case setExtensionValue // = 695 - case shift // = 696 - case simpleExtensionMap // = 697 - case sizer // = 698 - case source // = 699 - case sourceCodeInfo // = 700 - case sourceContext // = 701 - case sourceEncoding // = 702 - case sourceFile // = 703 - case span // = 704 - case split // = 705 - case start // = 706 - case startArray // = 707 - case startArrayObject // = 708 - case startField // = 709 - case startIndex // = 710 - case startMessageField // = 711 - case startObject // = 712 - case startRegularField // = 713 - case state // = 714 - case `static` // = 715 - case staticString // = 716 - case storage // = 717 - case string // = 718 - case stringLiteral // = 719 - case stringLiteralType // = 720 - case stringResult // = 721 - case stringValue // = 722 - case `struct` // = 723 - case structValue // = 724 - case subDecoder // = 725 - case `subscript` // = 726 - case subVisitor // = 727 - case swift // = 728 - case swiftPrefix // = 729 - case swiftProtobuf // = 730 - case syntax // = 731 - case t // = 732 - case tag // = 733 - case terminator // = 734 - case testDecoder // = 735 - case text // = 736 - case textDecoder // = 737 - case textFormatDecoder // = 738 - case textFormatDecodingError // = 739 - case textFormatDecodingOptions // = 740 - case textFormatEncodingOptions // = 741 - case textFormatEncodingVisitor // = 742 - case textFormatString // = 743 - case `throws` // = 744 - case timeInterval // = 745 - case timeIntervalSince1970 // = 746 - case timeIntervalSinceReferenceDate // = 747 - case timestamp // = 748 - case total // = 749 - case totalArrayDepth // = 750 - case totalSize // = 751 - case trailingComments // = 752 - case traverse // = 753 - case `true` // = 754 - case `try` // = 755 - case type // = 756 - case `typealias` // = 757 - case typeEnum // = 758 - case typeName // = 759 - case typePrefix // = 760 - case typeStart // = 761 - case typeUnknown // = 762 - case typeURL // = 763 - case uint32 // = 764 - case uint32Value // = 765 - case uint64 // = 766 - case uint64Value // = 767 - case uint8 // = 768 - case unicodeScalarLiteral // = 769 - case unicodeScalarLiteralType // = 770 - case unicodeScalars // = 771 - case unicodeScalarView // = 772 - case uninterpretedOption // = 773 - case union // = 774 - case uniqueStorage // = 775 - case unknown // = 776 - case unknownFields // = 777 - case unknownStorage // = 778 - case unpackTo // = 779 - case unsafeBufferPointer // = 780 - case unsafeMutablePointer // = 781 - case unsafeMutableRawBufferPointer // = 782 - case unsafeMutableRawPointer // = 783 - case unsafeRawBufferPointer // = 784 - case unsafeRawPointer // = 785 - case updatedOptions // = 786 - case url // = 787 - case utf8 // = 788 - case utf8Ptr // = 789 - case utf8ToDouble // = 790 - case utf8View // = 791 - case v // = 792 - case value // = 793 - case valueField // = 794 - case values // = 795 - case valueType // = 796 - case `var` // = 797 - case version // = 798 - case versionString // = 799 - case visitExtensionFields // = 800 - case visitExtensionFieldsAsMessageSet // = 801 - case visitMapField // = 802 - case visitor // = 803 - case visitPacked // = 804 - case visitPackedBoolField // = 805 - case visitPackedDoubleField // = 806 - case visitPackedEnumField // = 807 - case visitPackedFixed32Field // = 808 - case visitPackedFixed64Field // = 809 - case visitPackedFloatField // = 810 - case visitPackedInt32Field // = 811 - case visitPackedInt64Field // = 812 - case visitPackedSfixed32Field // = 813 - case visitPackedSfixed64Field // = 814 - case visitPackedSint32Field // = 815 - case visitPackedSint64Field // = 816 - case visitPackedUint32Field // = 817 - case visitPackedUint64Field // = 818 - case visitRepeated // = 819 - case visitRepeatedBoolField // = 820 - case visitRepeatedBytesField // = 821 - case visitRepeatedDoubleField // = 822 - case visitRepeatedEnumField // = 823 - case visitRepeatedFixed32Field // = 824 - case visitRepeatedFixed64Field // = 825 - case visitRepeatedFloatField // = 826 - case visitRepeatedGroupField // = 827 - case visitRepeatedInt32Field // = 828 - case visitRepeatedInt64Field // = 829 - case visitRepeatedMessageField // = 830 - case visitRepeatedSfixed32Field // = 831 - case visitRepeatedSfixed64Field // = 832 - case visitRepeatedSint32Field // = 833 - case visitRepeatedSint64Field // = 834 - case visitRepeatedStringField // = 835 - case visitRepeatedUint32Field // = 836 - case visitRepeatedUint64Field // = 837 - case visitSingular // = 838 - case visitSingularBoolField // = 839 - case visitSingularBytesField // = 840 - case visitSingularDoubleField // = 841 - case visitSingularEnumField // = 842 - case visitSingularFixed32Field // = 843 - case visitSingularFixed64Field // = 844 - case visitSingularFloatField // = 845 - case visitSingularGroupField // = 846 - case visitSingularInt32Field // = 847 - case visitSingularInt64Field // = 848 - case visitSingularMessageField // = 849 - case visitSingularSfixed32Field // = 850 - case visitSingularSfixed64Field // = 851 - case visitSingularSint32Field // = 852 - case visitSingularSint64Field // = 853 - case visitSingularStringField // = 854 - case visitSingularUint32Field // = 855 - case visitSingularUint64Field // = 856 - case visitUnknown // = 857 - case wasDecoded // = 858 - case weak // = 859 - case weakDependency // = 860 - case `where` // = 861 - case wireFormat // = 862 - case with // = 863 - case withUnsafeBytes // = 864 - case withUnsafeMutableBytes // = 865 - case work // = 866 - case wrappedType // = 867 - case written // = 868 - case yday // = 869 + case addPath // = 1 + case adjusted // = 2 + case aggregateValue // = 3 + case allCases_ // = 4 + case allowAlias // = 5 + case alwaysPrintEnumsAsInts // = 6 + case alwaysPrintInt64SAsNumbers // = 7 + case annotation // = 8 + case any // = 9 + case anyExtensionField // = 10 + case anyMessageExtension // = 11 + case anyMessageStorage // = 12 + case anyUnpackError // = 13 + case append // = 14 + case appended // = 15 + case appendUintHex // = 16 + case appendUnknown // = 17 + case areAllInitialized // = 18 + case array // = 19 + case arrayDepth // = 20 + case arrayLiteral // = 21 + case arraySeparator // = 22 + case `as` // = 23 + case asciiOpenCurlyBracket // = 24 + case asciiZero // = 25 + case async // = 26 + case asyncIterator // = 27 + case asyncIteratorProtocol // = 28 + case asyncMessageSequence // = 29 + case available // = 30 + case b // = 31 + case base // = 32 + case base64Values // = 33 + case baseAddress // = 34 + case baseType // = 35 + case begin // = 36 + case binary // = 37 + case binaryDecoder // = 38 + case binaryDecoding // = 39 + case binaryDecodingError // = 40 + case binaryDecodingOptions // = 41 + case binaryDelimited // = 42 + case binaryEncoder // = 43 + case binaryEncodingError // = 44 + case binaryEncodingMessageSetSizeVisitor // = 45 + case binaryEncodingMessageSetVisitor // = 46 + case binaryEncodingOptions // = 47 + case binaryEncodingSizeVisitor // = 48 + case binaryEncodingVisitor // = 49 + case binaryOptions // = 50 + case binaryProtobufDelimitedMessages // = 51 + case binaryStreamDecoding // = 52 + case binaryStreamDecodingError // = 53 + case bitPattern // = 54 + case body // = 55 + case bool // = 56 + case booleanLiteral // = 57 + case booleanLiteralType // = 58 + case boolValue // = 59 + case buffer // = 60 + case byte // = 61 + case bytecode // = 62 + case bytecodeReader // = 63 + case bytes // = 64 + case bytesInGroup // = 65 + case bytesNeeded // = 66 + case bytesRead // = 67 + case c // = 68 + case canonical // = 69 + case capitalizeNext // = 70 + case cardinality // = 71 + case caseIterable // = 72 + case castedValue // = 73 + case ccEnableArenas // = 74 + case ccGenericServices // = 75 + case character // = 76 + case chars // = 77 + case checkProgramFormat // = 78 + case chunk // = 79 + case `class` // = 80 + case clearAggregateValue // = 81 + case clearAllowAlias // = 82 + case clearBegin // = 83 + case clearCcEnableArenas // = 84 + case clearCcGenericServices // = 85 + case clearClientStreaming // = 86 + case clearCsharpNamespace // = 87 + case clearCtype // = 88 + case clearDebugRedact // = 89 + case clearDefaultSymbolVisibility // = 90 + case clearDefaultValue // = 91 + case clearDeprecated // = 92 + case clearDeprecatedLegacyJsonFieldConflicts // = 93 + case clearDeprecationWarning // = 94 + case clearDoubleValue // = 95 + case clearEdition // = 96 + case clearEditionDeprecated // = 97 + case clearEditionIntroduced // = 98 + case clearEditionRemoved // = 99 + case clearEnd // = 100 + case clearEnforceNamingStyle // = 101 + case clearEnumType // = 102 + case clearExtendee // = 103 + case clearExtensionValue // = 104 + case clearFeatures // = 105 + case clearFeatureSupport // = 106 + case clearFieldPresence // = 107 + case clearFixedFeatures // = 108 + case clearFullName // = 109 + case clearGoPackage // = 110 + case clearIdempotencyLevel // = 111 + case clearIdentifierValue // = 112 + case clearInputType // = 113 + case clearIsExtension // = 114 + case clearJavaGenerateEqualsAndHash // = 115 + case clearJavaGenericServices // = 116 + case clearJavaMultipleFiles // = 117 + case clearJavaOuterClassname // = 118 + case clearJavaPackage // = 119 + case clearJavaStringCheckUtf8 // = 120 + case clearJsonFormat // = 121 + case clearJsonName // = 122 + case clearJstype // = 123 + case clearLabel // = 124 + case clearLazy // = 125 + case clearLeadingComments // = 126 + case clearMapEntry // = 127 + case clearMaximumEdition // = 128 + case clearMessageEncoding // = 129 + case clearMessageSetWireFormat // = 130 + case clearMinimumEdition // = 131 + case clearName // = 132 + case clearNamePart // = 133 + case clearNegativeIntValue // = 134 + case clearNoStandardDescriptorAccessor // = 135 + case clearNumber // = 136 + case clearObjcClassPrefix // = 137 + case clearOneofIndex // = 138 + case clearOptimizeFor // = 139 + case clearOptions // = 140 + case clearOutputType // = 141 + case clearOverridableFeatures // = 142 + case clearPackage // = 143 + case clearPacked // = 144 + case clearPhpClassPrefix // = 145 + case clearPhpMetadataNamespace // = 146 + case clearPhpNamespace // = 147 + case clearPositiveIntValue // = 148 + case clearProto3Optional // = 149 + case clearPyGenericServices // = 150 + case clearRemovalError // = 151 + case clearRepeated // = 152 + case clearRepeatedFieldEncoding // = 153 + case clearReserved // = 154 + case clearRetention // = 155 + case clearRubyPackage // = 156 + case clearSemantic // = 157 + case clearServerStreaming // = 158 + case clearSourceCodeInfo // = 159 + case clearSourceContext // = 160 + case clearSourceFile // = 161 + case clearStart // = 162 + case clearStringValue // = 163 + case clearSwiftPrefix // = 164 + case clearSyntax // = 165 + case clearTrailingComments // = 166 + case clearType // = 167 + case clearTypeName // = 168 + case clearUnverifiedLazy // = 169 + case clearUtf8Validation // = 170 + case clearValue // = 171 + case clearVerification // = 172 + case clearVisibility // = 173 + case clearWeak // = 174 + case clientStreaming // = 175 + case code // = 176 + case codePoint // = 177 + case codeUnits // = 178 + case collection // = 179 + case comma // = 180 + case consumedBytes // = 181 + case contains // = 182 + case contentsOf // = 183 + case contiguousBytes // = 184 + case copy // = 185 + case count // = 186 + case countVarintsInBuffer // = 187 + case csharpNamespace // = 188 + case ctype // = 189 + case customCodable // = 190 + case customDebugStringConvertible // = 191 + case customStringConvertible // = 192 + case d // = 193 + case data // = 194 + case dataResult // = 195 + case date // = 196 + case daySec // = 197 + case daysSinceEpoch // = 198 + case debugDescription_ // = 199 + case debugRedact // = 200 + case declaration // = 201 + case decoded // = 202 + case decodedFromJsonnull // = 203 + case decodeExtensionField // = 204 + case decodeExtensionFieldsAsMessageSet // = 205 + case decodeJson // = 206 + case decodeMapField // = 207 + case decodeMessage // = 208 + case decoder // = 209 + case decodeRepeated // = 210 + case decodeRepeatedBoolField // = 211 + case decodeRepeatedBytesField // = 212 + case decodeRepeatedDoubleField // = 213 + case decodeRepeatedEnumField // = 214 + case decodeRepeatedFixed32Field // = 215 + case decodeRepeatedFixed64Field // = 216 + case decodeRepeatedFloatField // = 217 + case decodeRepeatedGroupField // = 218 + case decodeRepeatedInt32Field // = 219 + case decodeRepeatedInt64Field // = 220 + case decodeRepeatedMessageField // = 221 + case decodeRepeatedSfixed32Field // = 222 + case decodeRepeatedSfixed64Field // = 223 + case decodeRepeatedSint32Field // = 224 + case decodeRepeatedSint64Field // = 225 + case decodeRepeatedStringField // = 226 + case decodeRepeatedUint32Field // = 227 + case decodeRepeatedUint64Field // = 228 + case decodeSingular // = 229 + case decodeSingularBoolField // = 230 + case decodeSingularBytesField // = 231 + case decodeSingularDoubleField // = 232 + case decodeSingularEnumField // = 233 + case decodeSingularFixed32Field // = 234 + case decodeSingularFixed64Field // = 235 + case decodeSingularFloatField // = 236 + case decodeSingularGroupField // = 237 + case decodeSingularInt32Field // = 238 + case decodeSingularInt64Field // = 239 + case decodeSingularMessageField // = 240 + case decodeSingularSfixed32Field // = 241 + case decodeSingularSfixed64Field // = 242 + case decodeSingularSint32Field // = 243 + case decodeSingularSint64Field // = 244 + case decodeSingularStringField // = 245 + case decodeSingularUint32Field // = 246 + case decodeSingularUint64Field // = 247 + case decodeTextFormat // = 248 + case defaultAnyTypeUrlprefix // = 249 + case defaults // = 250 + case defaultSymbolVisibility // = 251 + case defaultValue // = 252 + case dependency // = 253 + case deprecated // = 254 + case deprecatedLegacyJsonFieldConflicts // = 255 + case deprecationWarning // = 256 + case description_ // = 257 + case dictionary // = 258 + case dictionaryLiteral // = 259 + case digit // = 260 + case digit0 // = 261 + case digit1 // = 262 + case digitCount // = 263 + case digits // = 264 + case digitValue // = 265 + case discardableResult // = 266 + case discardUnknownFields // = 267 + case double // = 268 + case doubleValue // = 269 + case duration // = 270 + case e // = 271 + case edition // = 272 + case editionDefault // = 273 + case editionDefaults // = 274 + case editionDeprecated // = 275 + case editionIntroduced // = 276 + case editionRemoved // = 277 + case element // = 278 + case elements // = 279 + case `else` // = 280 + case emitExtensionFieldName // = 281 + case emitFieldName // = 282 + case emitFieldNumber // = 283 + case emptyAnyTypeURL // = 284 + case emptyData // = 285 + case encodeAsBytes // = 286 + case encoded // = 287 + case encodedJsonstring // = 288 + case encodedSize // = 289 + case encodeField // = 290 + case encoder // = 291 + case end // = 292 + case endArray // = 293 + case endMessageField // = 294 + case endObject // = 295 + case endRegularField // = 296 + case enforceNamingStyle // = 297 + case `enum` // = 298 + case enumReservedRange // = 299 + case enumType // = 300 + case enumvalue // = 301 + case equatable // = 302 + case error // = 303 + case execute // = 304 + case expressibleByArrayLiteral // = 305 + case expressibleByDictionaryLiteral // = 306 + case ext // = 307 + case extDecoder // = 308 + case extendedGraphemeClusterLiteral // = 309 + case extendedGraphemeClusterLiteralType // = 310 + case extendee // = 311 + case extensibleMessage // = 312 + case `extension` // = 313 + case extensionField // = 314 + case extensionFieldNumber // = 315 + case extensionFieldValueSet // = 316 + case extensionMap // = 317 + case extensionRange // = 318 + case extensions // = 319 + case extras // = 320 + case f // = 321 + case `false` // = 322 + case features // = 323 + case featureSetEditionDefault // = 324 + case featureSupport // = 325 + case field // = 326 + case fieldData // = 327 + case fieldMaskError // = 328 + case fieldName // = 329 + case fieldNameCount // = 330 + case fieldNum // = 331 + case fieldNumber // = 332 + case fieldNumberForProto // = 333 + case fieldPresence // = 334 + case fields // = 335 + case fieldSize // = 336 + case fieldTag // = 337 + case fieldType // = 338 + case file // = 339 + case fileName // = 340 + case filter // = 341 + case final // = 342 + case finiteOnly // = 343 + case first // = 344 + case firstItem // = 345 + case fixedFeatures // = 346 + case float // = 347 + case floatLiteral // = 348 + case floatLiteralType // = 349 + case `for` // = 350 + case forMessageName // = 351 + case formUnion // = 352 + case forReadingFrom // = 353 + case forTypeURL // = 354 + case forwardParser // = 355 + case forWritingInto // = 356 + case from // = 357 + case fromAscii2 // = 358 + case fromAscii4 // = 359 + case fromByteOffset // = 360 + case fromHexDigit // = 361 + case fullName // = 362 + case `func` // = 363 + case function // = 364 + case g // = 365 + case get // = 366 + case getExtensionValue // = 367 + case googleProtobufAny // = 368 + case googleProtobufApi // = 369 + case googleProtobufBoolValue // = 370 + case googleProtobufBytesValue // = 371 + case googleProtobufDescriptorProto // = 372 + case googleProtobufDoubleValue // = 373 + case googleProtobufDuration // = 374 + case googleProtobufEdition // = 375 + case googleProtobufEmpty // = 376 + case googleProtobufEnum // = 377 + case googleProtobufEnumDescriptorProto // = 378 + case googleProtobufEnumOptions // = 379 + case googleProtobufEnumValue // = 380 + case googleProtobufEnumValueDescriptorProto // = 381 + case googleProtobufEnumValueOptions // = 382 + case googleProtobufExtensionRangeOptions // = 383 + case googleProtobufFeatureSet // = 384 + case googleProtobufFeatureSetDefaults // = 385 + case googleProtobufField // = 386 + case googleProtobufFieldDescriptorProto // = 387 + case googleProtobufFieldMask // = 388 + case googleProtobufFieldOptions // = 389 + case googleProtobufFileDescriptorProto // = 390 + case googleProtobufFileDescriptorSet // = 391 + case googleProtobufFileOptions // = 392 + case googleProtobufFloatValue // = 393 + case googleProtobufGeneratedCodeInfo // = 394 + case googleProtobufInt32Value // = 395 + case googleProtobufInt64Value // = 396 + case googleProtobufListValue // = 397 + case googleProtobufMessageOptions // = 398 + case googleProtobufMethod // = 399 + case googleProtobufMethodDescriptorProto // = 400 + case googleProtobufMethodOptions // = 401 + case googleProtobufMixin // = 402 + case googleProtobufNullValue // = 403 + case googleProtobufOneofDescriptorProto // = 404 + case googleProtobufOneofOptions // = 405 + case googleProtobufOption // = 406 + case googleProtobufServiceDescriptorProto // = 407 + case googleProtobufServiceOptions // = 408 + case googleProtobufSourceCodeInfo // = 409 + case googleProtobufSourceContext // = 410 + case googleProtobufStringValue // = 411 + case googleProtobufStruct // = 412 + case googleProtobufSymbolVisibility // = 413 + case googleProtobufSyntax // = 414 + case googleProtobufTimestamp // = 415 + case googleProtobufType // = 416 + case googleProtobufUint32Value // = 417 + case googleProtobufUint64Value // = 418 + case googleProtobufUninterpretedOption // = 419 + case googleProtobufValue // = 420 + case goPackage // = 421 + case gotData // = 422 + case group // = 423 + case groupFieldNumberStack // = 424 + case groupSize // = 425 + case `guard` // = 426 + case hadOneofValue // = 427 + case handleConflictingOneOf // = 428 + case handleInstruction // = 429 + case hasAggregateValue // = 430 + case hasAllowAlias // = 431 + case hasBegin // = 432 + case hasCcEnableArenas // = 433 + case hasCcGenericServices // = 434 + case hasClientStreaming // = 435 + case hasCsharpNamespace // = 436 + case hasCtype // = 437 + case hasData // = 438 + case hasDebugRedact // = 439 + case hasDefaultSymbolVisibility // = 440 + case hasDefaultValue // = 441 + case hasDeprecated // = 442 + case hasDeprecatedLegacyJsonFieldConflicts // = 443 + case hasDeprecationWarning // = 444 + case hasDoubleValue // = 445 + case hasEdition // = 446 + case hasEditionDeprecated // = 447 + case hasEditionIntroduced // = 448 + case hasEditionRemoved // = 449 + case hasEnd // = 450 + case hasEnforceNamingStyle // = 451 + case hasEnumType // = 452 + case hasExplicitDelta // = 453 + case hasExtendee // = 454 + case hasExtensionValue // = 455 + case hasFeatures // = 456 + case hasFeatureSupport // = 457 + case hasFieldPresence // = 458 + case hasFixedFeatures // = 459 + case hasFullName // = 460 + case hasGoPackage // = 461 + case hash // = 462 + case hashable // = 463 + case hasher // = 464 + case hashVisitor // = 465 + case hasIdempotencyLevel // = 466 + case hasIdentifierValue // = 467 + case hasInputType // = 468 + case hasIsExtension // = 469 + case hasJavaGenerateEqualsAndHash // = 470 + case hasJavaGenericServices // = 471 + case hasJavaMultipleFiles // = 472 + case hasJavaOuterClassname // = 473 + case hasJavaPackage // = 474 + case hasJavaStringCheckUtf8 // = 475 + case hasJsonFormat // = 476 + case hasJsonName // = 477 + case hasJstype // = 478 + case hasLabel // = 479 + case hasLazy // = 480 + case hasLeadingComments // = 481 + case hasMapEntry // = 482 + case hasMaximumEdition // = 483 + case hasMessageEncoding // = 484 + case hasMessageSetWireFormat // = 485 + case hasMinimumEdition // = 486 + case hasName // = 487 + case hasNamePart // = 488 + case hasNegativeIntValue // = 489 + case hasNoStandardDescriptorAccessor // = 490 + case hasNumber // = 491 + case hasObjcClassPrefix // = 492 + case hasOneofIndex // = 493 + case hasOptimizeFor // = 494 + case hasOptions // = 495 + case hasOutputType // = 496 + case hasOverridableFeatures // = 497 + case hasPackage // = 498 + case hasPacked // = 499 + case hasPhpClassPrefix // = 500 + case hasPhpMetadataNamespace // = 501 + case hasPhpNamespace // = 502 + case hasPositiveIntValue // = 503 + case hasProto3Optional // = 504 + case hasPyGenericServices // = 505 + case hasRemovalError // = 506 + case hasRepeated // = 507 + case hasRepeatedFieldEncoding // = 508 + case hasReserved // = 509 + case hasRetention // = 510 + case hasRubyPackage // = 511 + case hasSemantic // = 512 + case hasServerStreaming // = 513 + case hasSourceCodeInfo // = 514 + case hasSourceContext // = 515 + case hasSourceFile // = 516 + case hasStart // = 517 + case hasStringValue // = 518 + case hasSwiftPrefix // = 519 + case hasSyntax // = 520 + case hasTrailingComments // = 521 + case hasType // = 522 + case hasTypeName // = 523 + case hasUnverifiedLazy // = 524 + case hasUtf8Validation // = 525 + case hasValue // = 526 + case hasVerification // = 527 + case hasVisibility // = 528 + case hasWeak // = 529 + case hour // = 530 + case i // = 531 + case idempotencyLevel // = 532 + case identifierValue // = 533 + case `if` // = 534 + case ignoreUnknownExtensionFields // = 535 + case ignoreUnknownFields // = 536 + case index // = 537 + case init_ // = 538 + case `inout` // = 539 + case inputType // = 540 + case insert // = 541 + case instruction // = 542 + case int // = 543 + case int32 // = 544 + case int64 // = 545 + case int8 // = 546 + case integerLiteral // = 547 + case integerLiteralType // = 548 + case intern // = 549 + case `internal` // = 550 + case internalState // = 551 + case intersect // = 552 + case into // = 553 + case ints // = 554 + case invalidAnyTypeURL // = 555 + case isA // = 556 + case isEqual // = 557 + case isEqualTo // = 558 + case isExtension // = 559 + case isInitialized // = 560 + case isNegative // = 561 + case isPathValid // = 562 + case isReserved // = 563 + case isValid // = 564 + case itemTagsEncodedSize // = 565 + case iterator // = 566 + case javaGenerateEqualsAndHash // = 567 + case javaGenericServices // = 568 + case javaMultipleFiles // = 569 + case javaOuterClassname // = 570 + case javaPackage // = 571 + case javaStringCheckUtf8 // = 572 + case jsondecoder // = 573 + case jsondecoding // = 574 + case jsondecodingError // = 575 + case jsondecodingOptions // = 576 + case jsonEncoder // = 577 + case jsonencoding // = 578 + case jsonencodingError // = 579 + case jsonencodingOptions // = 580 + case jsonencodingVisitor // = 581 + case jsonFormat // = 582 + case jsonmapEncodingVisitor // = 583 + case jsonName // = 584 + case jsonPath // = 585 + case jsonPaths // = 586 + case jsonscanner // = 587 + case jsonString // = 588 + case jsonText // = 589 + case jsonUtf8Bytes // = 590 + case jsonUtf8Data // = 591 + case jstype // = 592 + case k // = 593 + case kChunkSize // = 594 + case key // = 595 + case keyField // = 596 + case keyFieldOpt // = 597 + case keyType // = 598 + case kind // = 599 + case l // = 600 + case label // = 601 + case lazy // = 602 + case leadingComments // = 603 + case leadingDetachedComments // = 604 + case length // = 605 + case lessThan // = 606 + case `let` // = 607 + case lhs // = 608 + case line // = 609 + case list // = 610 + case listOfMessages // = 611 + case listValue // = 612 + case littleEndian // = 613 + case load // = 614 + case localHasher // = 615 + case location // = 616 + case m // = 617 + case major // = 618 + case makeAsyncIterator // = 619 + case makeIterator // = 620 + case malformedLength // = 621 + case mapEntry // = 622 + case mapKeyType // = 623 + case mapToMessages // = 624 + case mapValueType // = 625 + case mapVisitor // = 626 + case mask // = 627 + case maximumEdition // = 628 + case mdayStart // = 629 + case merge // = 630 + case mergeOptions // = 631 + case message // = 632 + case messageDepthLimit // = 633 + case messageEncoding // = 634 + case messageExtension // = 635 + case messageImplementationBase // = 636 + case messageSet // = 637 + case messageSetWireFormat // = 638 + case messageSize // = 639 + case messageType // = 640 + case method // = 641 + case methods // = 642 + case min // = 643 + case minimumEdition // = 644 + case minor // = 645 + case mixins // = 646 + case modify // = 647 + case month // = 648 + case msgExtension // = 649 + case mutating // = 650 + case n // = 651 + case name // = 652 + case nameDescription // = 653 + case nameMap // = 654 + case namePart // = 655 + case names // = 656 + case nanos // = 657 + case negativeIntValue // = 658 + case nestedType // = 659 + case newExtensible // = 660 + case newL // = 661 + case newList // = 662 + case newMessage // = 663 + case newValue // = 664 + case next // = 665 + case nextByte // = 666 + case nextFieldNumber // = 667 + case nextInstruction // = 668 + case nextInt32 // = 669 + case nextNullTerminatedString // = 670 + case nextNullTerminatedStringArray // = 671 + case nextNumber // = 672 + case nextUint64 // = 673 + case nextVarInt // = 674 + case `nil` // = 675 + case nilLiteral // = 676 + case noBytesAvailable // = 677 + case noStandardDescriptorAccessor // = 678 + case nullValue // = 679 + case number // = 680 + case numberValue // = 681 + case objcClassPrefix // = 682 + case of // = 683 + case oneOfKind // = 684 + case oneofDecl // = 685 + case oneofIndex // = 686 + case oneofs // = 687 + case optimizeFor // = 688 + case optimizeMode // = 689 + case optionalEnumExtensionField // = 690 + case optionalExtensionField // = 691 + case optionalGroupExtensionField // = 692 + case optionalMessageExtensionField // = 693 + case optionDependency // = 694 + case optionRetention // = 695 + case options // = 696 + case optionTargetType // = 697 + case other // = 698 + case others // = 699 + case out // = 700 + case outputType // = 701 + case overridableFeatures // = 702 + case p // = 703 + case package // = 704 + case packed // = 705 + case packedEnumExtensionField // = 706 + case packedExtensionField // = 707 + case padding // = 708 + case parent // = 709 + case parse // = 710 + case partial // = 711 + case path // = 712 + case pathDecoder // = 713 + case pathDecodingError // = 714 + case paths // = 715 + case pathVisitor // = 716 + case payload // = 717 + case payloadSize // = 718 + case phpClassPrefix // = 719 + case phpMetadataNamespace // = 720 + case phpNamespace // = 721 + case pos // = 722 + case positiveIntValue // = 723 + case prefix // = 724 + case preserveProtoFieldNames // = 725 + case preTraverse // = 726 + case previousNumber // = 727 + case prevPath // = 728 + case printUnknownFields // = 729 + case programBuffer // = 730 + case programFormat // = 731 + case proto2 // = 732 + case proto3DefaultValue // = 733 + case proto3Optional // = 734 + case protobufExtensionFieldValues // = 735 + case protobufFieldNumber // = 736 + case protobufGeneratedIsEqualTo // = 737 + case protobufNameMap // = 738 + case protobufNewField // = 739 + case protobufPackage // = 740 + case protobufApiversion2 // = 741 + case protobufApiversionCheck // = 742 + case protobufBool // = 743 + case protobufBytes // = 744 + case protobufData // = 745 + case protobufDouble // = 746 + case protobufEnumMap // = 747 + case protobufExtension // = 748 + case protobufFixed32 // = 749 + case protobufFixed64 // = 750 + case protobufFloat // = 751 + case protobufInt32 // = 752 + case protobufInt64 // = 753 + case protobufMap // = 754 + case protobufMessageMap // = 755 + case protobufSfixed32 // = 756 + case protobufSfixed64 // = 757 + case protobufSint32 // = 758 + case protobufSint64 // = 759 + case protobufString // = 760 + case protobufUint32 // = 761 + case protobufUint64 // = 762 + case `protocol` // = 763 + case protoFieldName // = 764 + case protoMessageName // = 765 + case protoNameProviding // = 766 + case protoPaths // = 767 + case `public` // = 768 + case publicDependency // = 769 + case putBoolValue // = 770 + case putBytesValue // = 771 + case putDoubleValue // = 772 + case putEnumValue // = 773 + case putFixedUint32 // = 774 + case putFixedUint64 // = 775 + case putFloatValue // = 776 + case putInt64 // = 777 + case putStringValue // = 778 + case putUint64 // = 779 + case putUint64Hex // = 780 + case putVarInt // = 781 + case putZigZagVarInt // = 782 + case pyGenericServices // = 783 + case r // = 784 + case rawChars // = 785 + case rawRepresentable // = 786 + case rawValue_ // = 787 + case read4HexDigits // = 788 + case readBytes // = 789 + case reader // = 790 + case register // = 791 + case remainingProgram // = 792 + case removalError // = 793 + case removingAllFieldsOf // = 794 + case repeated // = 795 + case repeatedEnumExtensionField // = 796 + case repeatedExtensionField // = 797 + case repeatedFieldEncoding // = 798 + case repeatedGroupExtensionField // = 799 + case repeatedMessageExtensionField // = 800 + case repeating // = 801 + case replaceRepeatedFields // = 802 + case requestStreaming // = 803 + case requestTypeURL // = 804 + case requiredSize // = 805 + case responseStreaming // = 806 + case responseTypeURL // = 807 + case result // = 808 + case retention // = 809 + case `rethrows` // = 810 + case returnType // = 811 + case revision // = 812 + case rhs // = 813 + case root // = 814 + case rubyPackage // = 815 + case s // = 816 + case sawBackslash // = 817 + case sawSection4Characters // = 818 + case sawSection5Characters // = 819 + case scalar // = 820 + case scan // = 821 + case scanner // = 822 + case seconds // = 823 + case self_ // = 824 + case semantic // = 825 + case sendable // = 826 + case separator // = 827 + case serialize // = 828 + case serializedBytes // = 829 + case serializedData // = 830 + case serializedSize // = 831 + case serverStreaming // = 832 + case service // = 833 + case set // = 834 + case setExtensionValue // = 835 + case shift // = 836 + case simpleExtensionMap // = 837 + case size // = 838 + case sizer // = 839 + case source // = 840 + case sourceCodeInfo // = 841 + case sourceContext // = 842 + case sourceEncoding // = 843 + case sourceFile // = 844 + case sourceLocation // = 845 + case span // = 846 + case split // = 847 + case start // = 848 + case startArray // = 849 + case startArrayObject // = 850 + case startField // = 851 + case startIndex // = 852 + case startMessageField // = 853 + case startObject // = 854 + case startRegularField // = 855 + case state // = 856 + case `static` // = 857 + case staticString // = 858 + case storage // = 859 + case string // = 860 + case stringLiteral // = 861 + case stringLiteralType // = 862 + case stringResult // = 863 + case stringValue // = 864 + case `struct` // = 865 + case structValue // = 866 + case subDecoder // = 867 + case `subscript` // = 868 + case subtract // = 869 + case subVisitor // = 870 + case swift // = 871 + case swiftPrefix // = 872 + case swiftProtobufContiguousBytes // = 873 + case swiftProtobufError // = 874 + case syntax // = 875 + case t // = 876 + case tag // = 877 + case targets // = 878 + case terminator // = 879 + case testDecoder // = 880 + case text // = 881 + case textDecoder // = 882 + case textFormatDecoder // = 883 + case textFormatDecodingError // = 884 + case textFormatDecodingOptions // = 885 + case textFormatEncodingOptions // = 886 + case textFormatEncodingVisitor // = 887 + case textFormatString // = 888 + case throwOrIgnore // = 889 + case `throws` // = 890 + case timeInterval // = 891 + case timeIntervalSince1970 // = 892 + case timeIntervalSinceReferenceDate // = 893 + case tmp // = 894 + case tooLarge // = 895 + case total // = 896 + case totalArrayDepth // = 897 + case totalSize // = 898 + case trailingComments // = 899 + case traverse // = 900 + case trim // = 901 + case `true` // = 902 + case `try` // = 903 + case type // = 904 + case `typealias` // = 905 + case typeEnum // = 906 + case typeName // = 907 + case typePrefix // = 908 + case typeStart // = 909 + case typeUnknown // = 910 + case typeURL // = 911 + case uint32 // = 912 + case uint64 // = 913 + case uint8 // = 914 + case unchecked // = 915 + case unicode // = 916 + case unicodeScalarLiteral // = 917 + case unicodeScalarLiteralType // = 918 + case unicodeScalars // = 919 + case unicodeScalarView // = 920 + case uninterpretedOption // = 921 + case union // = 922 + case uniqueStorage // = 923 + case unknown // = 924 + case unknownFields // = 925 + case unknownStorage // = 926 + case unpackTo // = 927 + case unsafeBufferPointer // = 928 + case unsafeMutablePointer // = 929 + case unsafeMutableRawBufferPointer // = 930 + case unsafeRawBufferPointer // = 931 + case unsafeRawPointer // = 932 + case unverifiedLazy // = 933 + case updatedOptions // = 934 + case uppercasedAssumingAscii // = 935 + case url // = 936 + case useDeterministicOrdering // = 937 + case utf8 // = 938 + case utf8Ptr // = 939 + case utf8ToDouble // = 940 + case utf8Validation // = 941 + case utf8View // = 942 + case v // = 943 + case value // = 944 + case valueField // = 945 + case values // = 946 + case valueType // = 947 + case `var` // = 948 + case verification // = 949 + case verificationState // = 950 + case version // = 951 + case versionString // = 952 + case visibility // = 953 + case visibilityFeature // = 954 + case visitExtensionFields // = 955 + case visitExtensionFieldsAsMessageSet // = 956 + case visitMapField // = 957 + case visitor // = 958 + case visitPacked // = 959 + case visitPackedBoolField // = 960 + case visitPackedDoubleField // = 961 + case visitPackedEnumField // = 962 + case visitPackedFixed32Field // = 963 + case visitPackedFixed64Field // = 964 + case visitPackedFloatField // = 965 + case visitPackedInt32Field // = 966 + case visitPackedInt64Field // = 967 + case visitPackedSfixed32Field // = 968 + case visitPackedSfixed64Field // = 969 + case visitPackedSint32Field // = 970 + case visitPackedSint64Field // = 971 + case visitPackedUint32Field // = 972 + case visitPackedUint64Field // = 973 + case visitRepeated // = 974 + case visitRepeatedBoolField // = 975 + case visitRepeatedBytesField // = 976 + case visitRepeatedDoubleField // = 977 + case visitRepeatedEnumField // = 978 + case visitRepeatedFixed32Field // = 979 + case visitRepeatedFixed64Field // = 980 + case visitRepeatedFloatField // = 981 + case visitRepeatedGroupField // = 982 + case visitRepeatedInt32Field // = 983 + case visitRepeatedInt64Field // = 984 + case visitRepeatedMessageField // = 985 + case visitRepeatedSfixed32Field // = 986 + case visitRepeatedSfixed64Field // = 987 + case visitRepeatedSint32Field // = 988 + case visitRepeatedSint64Field // = 989 + case visitRepeatedStringField // = 990 + case visitRepeatedUint32Field // = 991 + case visitRepeatedUint64Field // = 992 + case visitSingular // = 993 + case visitSingularBoolField // = 994 + case visitSingularBytesField // = 995 + case visitSingularDoubleField // = 996 + case visitSingularEnumField // = 997 + case visitSingularFixed32Field // = 998 + case visitSingularFixed64Field // = 999 + case visitSingularFloatField // = 1000 + case visitSingularGroupField // = 1001 + case visitSingularInt32Field // = 1002 + case visitSingularInt64Field // = 1003 + case visitSingularMessageField // = 1004 + case visitSingularSfixed32Field // = 1005 + case visitSingularSfixed64Field // = 1006 + case visitSingularSint32Field // = 1007 + case visitSingularSint64Field // = 1008 + case visitSingularStringField // = 1009 + case visitSingularUint32Field // = 1010 + case visitSingularUint64Field // = 1011 + case visitUnknown // = 1012 + case void // = 1013 + case wasDecoded // = 1014 + case weak // = 1015 + case weakDependency // = 1016 + case `where` // = 1017 + case wireFormat // = 1018 + case with // = 1019 + case withUnsafeBytes // = 1020 + case withUnsafeMutableBytes // = 1021 + case work // = 1022 + case wrapped // = 1023 + case wrappedType // = 1024 + case wrappedValue // = 1025 + case written // = 1026 + case yday // = 1027 case UNRECOGNIZED(Int) init() { @@ -905,875 +1063,1033 @@ enum ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum { init?(rawValue: Int) { switch rawValue { case 0: self = .none - case 1: self = .adjusted - case 2: self = .aggregateValue - case 3: self = .allCases_ - case 4: self = .allowAlias - case 5: self = .alwaysPrintEnumsAsInts - case 6: self = .annotation - case 7: self = .any - case 8: self = .anyExtensionField - case 9: self = .anyMessageExtension - case 10: self = .anyMessageStorage - case 11: self = .anyUnpackError - case 12: self = .api - case 13: self = .appended - case 14: self = .appendUintHex - case 15: self = .appendUnknown - case 16: self = .areAllInitialized - case 17: self = .array - case 18: self = .arrayDepth - case 19: self = .arrayLiteral - case 20: self = .arraySeparator - case 21: self = .as - case 22: self = .asciiOpenCurlyBracket - case 23: self = .asciiZero - case 24: self = .available - case 25: self = .b - case 26: self = .base64Values - case 27: self = .baseAddress - case 28: self = .baseType - case 29: self = .begin - case 30: self = .binary - case 31: self = .binaryDecoder - case 32: self = .binaryDecodingError - case 33: self = .binaryDecodingOptions - case 34: self = .binaryDelimited - case 35: self = .binaryEncoder - case 36: self = .binaryEncodingError - case 37: self = .binaryEncodingMessageSetSizeVisitor - case 38: self = .binaryEncodingMessageSetVisitor - case 39: self = .binaryEncodingSizeVisitor - case 40: self = .binaryEncodingVisitor - case 41: self = .binaryOptions - case 42: self = .body - case 43: self = .bool - case 44: self = .booleanLiteral - case 45: self = .booleanLiteralType - case 46: self = .boolValue - case 47: self = .bytes - case 48: self = .bytesInGroup - case 49: self = .bytesRead - case 50: self = .bytesValue - case 51: self = .c - case 52: self = .capitalizeNext - case 53: self = .cardinality - case 54: self = .ccEnableArenas - case 55: self = .ccGenericServices - case 56: self = .character - case 57: self = .chars - case 58: self = .class - case 59: self = .clearAggregateValue - case 60: self = .clearAllowAlias - case 61: self = .clearBegin - case 62: self = .clearCcEnableArenas - case 63: self = .clearCcGenericServices - case 64: self = .clearClientStreaming - case 65: self = .clearCsharpNamespace - case 66: self = .clearCtype - case 67: self = .clearDefaultValue - case 68: self = .clearDeprecated - case 69: self = .clearDoubleValue - case 70: self = .clearEnd - case 71: self = .clearExtendee - case 72: self = .clearExtensionValue - case 73: self = .clearGoPackage - case 74: self = .clearIdempotencyLevel - case 75: self = .clearIdentifierValue - case 76: self = .clearInputType - case 77: self = .clearIsExtension - case 78: self = .clearJavaGenerateEqualsAndHash - case 79: self = .clearJavaGenericServices - case 80: self = .clearJavaMultipleFiles - case 81: self = .clearJavaOuterClassname - case 82: self = .clearJavaPackage - case 83: self = .clearJavaStringCheckUtf8 - case 84: self = .clearJsonName - case 85: self = .clearJstype - case 86: self = .clearLabel - case 87: self = .clearLazy - case 88: self = .clearLeadingComments - case 89: self = .clearMapEntry - case 90: self = .clearMessageSetWireFormat - case 91: self = .clearName - case 92: self = .clearNamePart - case 93: self = .clearNegativeIntValue - case 94: self = .clearNoStandardDescriptorAccessor - case 95: self = .clearNumber - case 96: self = .clearObjcClassPrefix - case 97: self = .clearOneofIndex - case 98: self = .clearOptimizeFor - case 99: self = .clearOptions - case 100: self = .clearOutputType - case 101: self = .clearPackage - case 102: self = .clearPacked - case 103: self = .clearPhpClassPrefix - case 104: self = .clearPhpGenericServices - case 105: self = .clearPhpMetadataNamespace - case 106: self = .clearPhpNamespace - case 107: self = .clearPositiveIntValue - case 108: self = .clearProto3Optional - case 109: self = .clearPyGenericServices - case 110: self = .clearRubyPackage - case 111: self = .clearServerStreaming - case 112: self = .clearSourceCodeInfo - case 113: self = .clearSourceContext - case 114: self = .clearSourceFile - case 115: self = .clearStart - case 116: self = .clearStringValue - case 117: self = .clearSwiftPrefix - case 118: self = .clearSyntax - case 119: self = .clearTrailingComments - case 120: self = .clearType - case 121: self = .clearTypeName - case 122: self = .clearValue - case 123: self = .clearWeak - case 124: self = .clientStreaming - case 125: self = .codePoint - case 126: self = .codeUnits - case 127: self = .collection - case 128: self = .com - case 129: self = .comma - case 130: self = .contentsOf - case 131: self = .contiguousBytes - case 132: self = .count - case 133: self = .countVarintsInBuffer - case 134: self = .csharpNamespace - case 135: self = .ctype - case 136: self = .customCodable - case 137: self = .customDebugStringConvertible - case 138: self = .d - case 139: self = .data - case 140: self = .dataResult - case 141: self = .date - case 142: self = .daySec - case 143: self = .daysSinceEpoch - case 144: self = .debugDescription_ - case 145: self = .decoded - case 146: self = .decodedFromJsonnull - case 147: self = .decodeExtensionField - case 148: self = .decodeExtensionFieldsAsMessageSet - case 149: self = .decodeJson - case 150: self = .decodeMapField - case 151: self = .decodeMessage - case 152: self = .decoder - case 153: self = .decodeRepeated - case 154: self = .decodeRepeatedBoolField - case 155: self = .decodeRepeatedBytesField - case 156: self = .decodeRepeatedDoubleField - case 157: self = .decodeRepeatedEnumField - case 158: self = .decodeRepeatedFixed32Field - case 159: self = .decodeRepeatedFixed64Field - case 160: self = .decodeRepeatedFloatField - case 161: self = .decodeRepeatedGroupField - case 162: self = .decodeRepeatedInt32Field - case 163: self = .decodeRepeatedInt64Field - case 164: self = .decodeRepeatedMessageField - case 165: self = .decodeRepeatedSfixed32Field - case 166: self = .decodeRepeatedSfixed64Field - case 167: self = .decodeRepeatedSint32Field - case 168: self = .decodeRepeatedSint64Field - case 169: self = .decodeRepeatedStringField - case 170: self = .decodeRepeatedUint32Field - case 171: self = .decodeRepeatedUint64Field - case 172: self = .decodeSingular - case 173: self = .decodeSingularBoolField - case 174: self = .decodeSingularBytesField - case 175: self = .decodeSingularDoubleField - case 176: self = .decodeSingularEnumField - case 177: self = .decodeSingularFixed32Field - case 178: self = .decodeSingularFixed64Field - case 179: self = .decodeSingularFloatField - case 180: self = .decodeSingularGroupField - case 181: self = .decodeSingularInt32Field - case 182: self = .decodeSingularInt64Field - case 183: self = .decodeSingularMessageField - case 184: self = .decodeSingularSfixed32Field - case 185: self = .decodeSingularSfixed64Field - case 186: self = .decodeSingularSint32Field - case 187: self = .decodeSingularSint64Field - case 188: self = .decodeSingularStringField - case 189: self = .decodeSingularUint32Field - case 190: self = .decodeSingularUint64Field - case 191: self = .decodeTextFormat - case 192: self = .defaultAnyTypeUrlprefix - case 193: self = .defaultValue - case 194: self = .dependency - case 195: self = .deprecated - case 196: self = .description_ - case 197: self = .descriptorProto - case 198: self = .dictionary - case 199: self = .dictionaryLiteral - case 200: self = .digit - case 201: self = .digit0 - case 202: self = .digit1 - case 203: self = .digitCount - case 204: self = .digits - case 205: self = .digitValue - case 206: self = .discardableResult - case 207: self = .discardUnknownFields - case 208: self = .distance - case 209: self = .double - case 210: self = .doubleValue - case 211: self = .duration - case 212: self = .e - case 213: self = .element - case 214: self = .elements - case 215: self = .emitExtensionFieldName - case 216: self = .emitFieldName - case 217: self = .emitFieldNumber - case 218: self = .empty - case 219: self = .emptyData - case 220: self = .encodeAsBytes - case 221: self = .encoded - case 222: self = .encodedJsonstring - case 223: self = .encodedSize - case 224: self = .encodeField - case 225: self = .encoder - case 226: self = .end - case 227: self = .endArray - case 228: self = .endMessageField - case 229: self = .endObject - case 230: self = .endRegularField - case 231: self = .enum - case 232: self = .enumDescriptorProto - case 233: self = .enumOptions - case 234: self = .enumReservedRange - case 235: self = .enumType - case 236: self = .enumvalue - case 237: self = .enumValueDescriptorProto - case 238: self = .enumValueOptions - case 239: self = .equatable - case 240: self = .error - case 241: self = .expressibleByArrayLiteral - case 242: self = .expressibleByDictionaryLiteral - case 243: self = .ext - case 244: self = .extDecoder - case 245: self = .extendedGraphemeClusterLiteral - case 246: self = .extendedGraphemeClusterLiteralType - case 247: self = .extendee - case 248: self = .extensibleMessage - case 249: self = .extension - case 250: self = .extensionField - case 251: self = .extensionFieldNumber - case 252: self = .extensionFieldValueSet - case 253: self = .extensionMap - case 254: self = .extensionRange - case 255: self = .extensionRangeOptions - case 256: self = .extensions - case 257: self = .extras - case 258: self = .f - case 259: self = .false - case 260: self = .field - case 261: self = .fieldData - case 262: self = .fieldDescriptorProto - case 263: self = .fieldMask - case 264: self = .fieldName - case 265: self = .fieldNameCount - case 266: self = .fieldNum - case 267: self = .fieldNumber - case 268: self = .fieldNumberForProto - case 269: self = .fieldOptions - case 270: self = .fields - case 271: self = .fieldSize - case 272: self = .fieldTag - case 273: self = .fieldType - case 274: self = .file - case 275: self = .fileDescriptorProto - case 276: self = .fileDescriptorSet - case 277: self = .fileName - case 278: self = .fileOptions - case 279: self = .filter - case 280: self = .first - case 281: self = .firstItem - case 282: self = .float - case 283: self = .floatLiteral - case 284: self = .floatLiteralType - case 285: self = .floatValue - case 286: self = .forMessageName - case 287: self = .formUnion - case 288: self = .forReadingFrom - case 289: self = .forTypeURL - case 290: self = .forwardParser - case 291: self = .forWritingInto - case 292: self = .from - case 293: self = .fromAscii2 - case 294: self = .fromAscii4 - case 295: self = .fromByteOffset - case 296: self = .fromHexDigit - case 297: self = .func - case 298: self = .g - case 299: self = .generatedCodeInfo - case 300: self = .get - case 301: self = .getExtensionValue - case 302: self = .googleapis - case 303: self = .googleProtobufAny - case 304: self = .googleProtobufApi - case 305: self = .googleProtobufBoolValue - case 306: self = .googleProtobufBytesValue - case 307: self = .googleProtobufDescriptorProto - case 308: self = .googleProtobufDoubleValue - case 309: self = .googleProtobufDuration - case 310: self = .googleProtobufEmpty - case 311: self = .googleProtobufEnum - case 312: self = .googleProtobufEnumDescriptorProto - case 313: self = .googleProtobufEnumOptions - case 314: self = .googleProtobufEnumValue - case 315: self = .googleProtobufEnumValueDescriptorProto - case 316: self = .googleProtobufEnumValueOptions - case 317: self = .googleProtobufExtensionRangeOptions - case 318: self = .googleProtobufField - case 319: self = .googleProtobufFieldDescriptorProto - case 320: self = .googleProtobufFieldMask - case 321: self = .googleProtobufFieldOptions - case 322: self = .googleProtobufFileDescriptorProto - case 323: self = .googleProtobufFileDescriptorSet - case 324: self = .googleProtobufFileOptions - case 325: self = .googleProtobufFloatValue - case 326: self = .googleProtobufGeneratedCodeInfo - case 327: self = .googleProtobufInt32Value - case 328: self = .googleProtobufInt64Value - case 329: self = .googleProtobufListValue - case 330: self = .googleProtobufMessageOptions - case 331: self = .googleProtobufMethod - case 332: self = .googleProtobufMethodDescriptorProto - case 333: self = .googleProtobufMethodOptions - case 334: self = .googleProtobufMixin - case 335: self = .googleProtobufNullValue - case 336: self = .googleProtobufOneofDescriptorProto - case 337: self = .googleProtobufOneofOptions - case 338: self = .googleProtobufOption - case 339: self = .googleProtobufServiceDescriptorProto - case 340: self = .googleProtobufServiceOptions - case 341: self = .googleProtobufSourceCodeInfo - case 342: self = .googleProtobufSourceContext - case 343: self = .googleProtobufStringValue - case 344: self = .googleProtobufStruct - case 345: self = .googleProtobufSyntax - case 346: self = .googleProtobufTimestamp - case 347: self = .googleProtobufType - case 348: self = .googleProtobufUint32Value - case 349: self = .googleProtobufUint64Value - case 350: self = .googleProtobufUninterpretedOption - case 351: self = .googleProtobufValue - case 352: self = .goPackage - case 353: self = .group - case 354: self = .groupFieldNumberStack - case 355: self = .groupSize - case 356: self = .h - case 357: self = .hadOneofValue - case 358: self = .handleConflictingOneOf - case 359: self = .hasAggregateValue - case 360: self = .hasAllowAlias - case 361: self = .hasBegin - case 362: self = .hasCcEnableArenas - case 363: self = .hasCcGenericServices - case 364: self = .hasClientStreaming - case 365: self = .hasCsharpNamespace - case 366: self = .hasCtype - case 367: self = .hasDefaultValue - case 368: self = .hasDeprecated - case 369: self = .hasDoubleValue - case 370: self = .hasEnd - case 371: self = .hasExtendee - case 372: self = .hasExtensionValue - case 373: self = .hasGoPackage - case 374: self = .hash - case 375: self = .hashable - case 376: self = .hasher - case 377: self = .hashValue_ - case 378: self = .hashVisitor - case 379: self = .hasIdempotencyLevel - case 380: self = .hasIdentifierValue - case 381: self = .hasInputType - case 382: self = .hasIsExtension - case 383: self = .hasJavaGenerateEqualsAndHash - case 384: self = .hasJavaGenericServices - case 385: self = .hasJavaMultipleFiles - case 386: self = .hasJavaOuterClassname - case 387: self = .hasJavaPackage - case 388: self = .hasJavaStringCheckUtf8 - case 389: self = .hasJsonName - case 390: self = .hasJstype - case 391: self = .hasLabel - case 392: self = .hasLazy - case 393: self = .hasLeadingComments - case 394: self = .hasMapEntry - case 395: self = .hasMessageSetWireFormat - case 396: self = .hasName - case 397: self = .hasNamePart - case 398: self = .hasNegativeIntValue - case 399: self = .hasNoStandardDescriptorAccessor - case 400: self = .hasNumber - case 401: self = .hasObjcClassPrefix - case 402: self = .hasOneofIndex - case 403: self = .hasOptimizeFor - case 404: self = .hasOptions - case 405: self = .hasOutputType - case 406: self = .hasPackage - case 407: self = .hasPacked - case 408: self = .hasPhpClassPrefix - case 409: self = .hasPhpGenericServices - case 410: self = .hasPhpMetadataNamespace - case 411: self = .hasPhpNamespace - case 412: self = .hasPositiveIntValue - case 413: self = .hasProto3Optional - case 414: self = .hasPyGenericServices - case 415: self = .hasRubyPackage - case 416: self = .hasServerStreaming - case 417: self = .hasSourceCodeInfo - case 418: self = .hasSourceContext - case 419: self = .hasSourceFile - case 420: self = .hasStart - case 421: self = .hasStringValue - case 422: self = .hasSwiftPrefix - case 423: self = .hasSyntax - case 424: self = .hasTrailingComments - case 425: self = .hasType - case 426: self = .hasTypeName - case 427: self = .hasValue - case 428: self = .hasWeak - case 429: self = .hour - case 430: self = .i - case 431: self = .idempotencyLevel - case 432: self = .identifierValue - case 433: self = .if - case 434: self = .ignoreUnknownFields - case 435: self = .index - case 436: self = .init_ - case 437: self = .inout - case 438: self = .inputType - case 439: self = .insert - case 440: self = .int - case 441: self = .int32 - case 442: self = .int32Value - case 443: self = .int64 - case 444: self = .int64Value - case 445: self = .int8 - case 446: self = .integerLiteral - case 447: self = .integerLiteralType - case 448: self = .intern - case 449: self = .internal - case 450: self = .internalState - case 451: self = .into - case 452: self = .ints - case 453: self = .isA - case 454: self = .isEqual - case 455: self = .isEqualTo - case 456: self = .isExtension - case 457: self = .isInitialized - case 458: self = .itemTagsEncodedSize - case 459: self = .iterator - case 460: self = .i2166136261 - case 461: self = .javaGenerateEqualsAndHash - case 462: self = .javaGenericServices - case 463: self = .javaMultipleFiles - case 464: self = .javaOuterClassname - case 465: self = .javaPackage - case 466: self = .javaStringCheckUtf8 - case 467: self = .jsondecoder - case 468: self = .jsondecodingError - case 469: self = .jsondecodingOptions - case 470: self = .jsonEncoder - case 471: self = .jsonencodingError - case 472: self = .jsonencodingOptions - case 473: self = .jsonencodingVisitor - case 474: self = .jsonmapEncodingVisitor - case 475: self = .jsonName - case 476: self = .jsonPath - case 477: self = .jsonPaths - case 478: self = .jsonscanner - case 479: self = .jsonString - case 480: self = .jsonText - case 481: self = .jsonUtf8Data - case 482: self = .jstype - case 483: self = .k - case 484: self = .key - case 485: self = .keyField - case 486: self = .keyType - case 487: self = .kind - case 488: self = .l - case 489: self = .label - case 490: self = .lazy - case 491: self = .leadingComments - case 492: self = .leadingDetachedComments - case 493: self = .length - case 494: self = .lessThan - case 495: self = .let - case 496: self = .lhs - case 497: self = .list - case 498: self = .listOfMessages - case 499: self = .listValue - case 500: self = .littleEndian - case 501: self = .littleEndianBytes - case 502: self = .load - case 503: self = .localHasher - case 504: self = .location - case 505: self = .m - case 506: self = .major - case 507: self = .makeIterator - case 508: self = .mapEntry - case 509: self = .mapHash - case 510: self = .mapKeyType - case 511: self = .mapNameResolver - case 512: self = .mapToMessages - case 513: self = .mapValueType - case 514: self = .mapVisitor - case 515: self = .mdayStart - case 516: self = .merge - case 517: self = .message - case 518: self = .messageDepthLimit - case 519: self = .messageExtension - case 520: self = .messageImplementationBase - case 521: self = .messageOptions - case 522: self = .messageSet - case 523: self = .messageSetWireFormat - case 524: self = .messageType - case 525: self = .method - case 526: self = .methodDescriptorProto - case 527: self = .methodOptions - case 528: self = .methods - case 529: self = .minor - case 530: self = .mixin - case 531: self = .mixins - case 532: self = .modifier - case 533: self = .modify - case 534: self = .month - case 535: self = .msgExtension - case 536: self = .mutating - case 537: self = .n - case 538: self = .name - case 539: self = .nameDescription - case 540: self = .nameMap - case 541: self = .namePart - case 542: self = .nameResolver - case 543: self = .names - case 544: self = .nanos - case 545: self = .nativeBytes - case 546: self = .nativeEndianBytes - case 547: self = .negativeIntValue - case 548: self = .nestedType - case 549: self = .newL - case 550: self = .newList - case 551: self = .newValue - case 552: self = .nextByte - case 553: self = .nextFieldNumber - case 554: self = .nil - case 555: self = .nilLiteral - case 556: self = .noStandardDescriptorAccessor - case 557: self = .nullValue - case 558: self = .number - case 559: self = .numberValue - case 560: self = .objcClassPrefix - case 561: self = .of - case 562: self = .oneofDecl - case 563: self = .oneofDescriptorProto - case 564: self = .oneofIndex - case 565: self = .oneofOptions - case 566: self = .oneofs - case 567: self = .oneOfKind - case 568: self = .optimizeFor - case 569: self = .optimizeMode - case 570: self = .option - case 571: self = .optionalEnumExtensionField - case 572: self = .optionalExtensionField - case 573: self = .optionalGroupExtensionField - case 574: self = .optionalMessageExtensionField - case 575: self = .options - case 576: self = .other - case 577: self = .others - case 578: self = .out - case 579: self = .outputType - case 580: self = .p - case 581: self = .package - case 582: self = .packed - case 583: self = .packedEnumExtensionField - case 584: self = .packedExtensionField - case 585: self = .padding - case 586: self = .parent - case 587: self = .parse - case 588: self = .partial - case 589: self = .path - case 590: self = .paths - case 591: self = .payload - case 592: self = .payloadSize - case 593: self = .phpClassPrefix - case 594: self = .phpGenericServices - case 595: self = .phpMetadataNamespace - case 596: self = .phpNamespace - case 597: self = .pointer - case 598: self = .pos - case 599: self = .positiveIntValue - case 600: self = .prefix - case 601: self = .preserveProtoFieldNames - case 602: self = .preTraverse - case 603: self = .printUnknownFields - case 604: self = .proto2 - case 605: self = .proto3DefaultValue - case 606: self = .proto3Optional - case 607: self = .protobufApiversionCheck - case 608: self = .protobufApiversion2 - case 609: self = .protobufBool - case 610: self = .protobufBytes - case 611: self = .protobufDouble - case 612: self = .protobufEnumMap - case 613: self = .protobufExtension - case 614: self = .protobufFixed32 - case 615: self = .protobufFixed64 - case 616: self = .protobufFloat - case 617: self = .protobufInt32 - case 618: self = .protobufInt64 - case 619: self = .protobufMap - case 620: self = .protobufMessageMap - case 621: self = .protobufSfixed32 - case 622: self = .protobufSfixed64 - case 623: self = .protobufSint32 - case 624: self = .protobufSint64 - case 625: self = .protobufString - case 626: self = .protobufUint32 - case 627: self = .protobufUint64 - case 628: self = .protobufExtensionFieldValues - case 629: self = .protobufFieldNumber - case 630: self = .protobufGeneratedIsEqualTo - case 631: self = .protobufNameMap - case 632: self = .protobufNewField - case 633: self = .protobufPackage - case 634: self = .protocol - case 635: self = .protoFieldName - case 636: self = .protoMessageName - case 637: self = .protoNameProviding - case 638: self = .protoPaths - case 639: self = .public - case 640: self = .publicDependency - case 641: self = .putBoolValue - case 642: self = .putBytesValue - case 643: self = .putDoubleValue - case 644: self = .putEnumValue - case 645: self = .putFixedUint32 - case 646: self = .putFixedUint64 - case 647: self = .putFloatValue - case 648: self = .putInt64 - case 649: self = .putStringValue - case 650: self = .putUint64 - case 651: self = .putUint64Hex - case 652: self = .putVarInt - case 653: self = .putZigZagVarInt - case 654: self = .pyGenericServices - case 655: self = .rawChars - case 656: self = .rawRepresentable - case 657: self = .rawValue_ - case 658: self = .read4HexDigits - case 659: self = .register - case 660: self = .repeatedEnumExtensionField - case 661: self = .repeatedExtensionField - case 662: self = .repeatedGroupExtensionField - case 663: self = .repeatedMessageExtensionField - case 664: self = .requestStreaming - case 665: self = .requestTypeURL - case 666: self = .requiredSize - case 667: self = .reservedName - case 668: self = .reservedRange - case 669: self = .responseStreaming - case 670: self = .responseTypeURL - case 671: self = .result - case 672: self = .rethrows - case 673: self = .return - case 674: self = .returnType - case 675: self = .revision - case 676: self = .rhs - case 677: self = .root - case 678: self = .rubyPackage - case 679: self = .s - case 680: self = .sawBackslash - case 681: self = .sawSection4Characters - case 682: self = .sawSection5Characters - case 683: self = .scanner - case 684: self = .seconds - case 685: self = .self_ - case 686: self = .separator - case 687: self = .serialize - case 688: self = .serializedData - case 689: self = .serializedSize - case 690: self = .serverStreaming - case 691: self = .service - case 692: self = .serviceDescriptorProto - case 693: self = .serviceOptions - case 694: self = .set - case 695: self = .setExtensionValue - case 696: self = .shift - case 697: self = .simpleExtensionMap - case 698: self = .sizer - case 699: self = .source - case 700: self = .sourceCodeInfo - case 701: self = .sourceContext - case 702: self = .sourceEncoding - case 703: self = .sourceFile - case 704: self = .span - case 705: self = .split - case 706: self = .start - case 707: self = .startArray - case 708: self = .startArrayObject - case 709: self = .startField - case 710: self = .startIndex - case 711: self = .startMessageField - case 712: self = .startObject - case 713: self = .startRegularField - case 714: self = .state - case 715: self = .static - case 716: self = .staticString - case 717: self = .storage - case 718: self = .string - case 719: self = .stringLiteral - case 720: self = .stringLiteralType - case 721: self = .stringResult - case 722: self = .stringValue - case 723: self = .struct - case 724: self = .structValue - case 725: self = .subDecoder - case 726: self = .subscript - case 727: self = .subVisitor - case 728: self = .swift - case 729: self = .swiftPrefix - case 730: self = .swiftProtobuf - case 731: self = .syntax - case 732: self = .t - case 733: self = .tag - case 734: self = .terminator - case 735: self = .testDecoder - case 736: self = .text - case 737: self = .textDecoder - case 738: self = .textFormatDecoder - case 739: self = .textFormatDecodingError - case 740: self = .textFormatDecodingOptions - case 741: self = .textFormatEncodingOptions - case 742: self = .textFormatEncodingVisitor - case 743: self = .textFormatString - case 744: self = .throws - case 745: self = .timeInterval - case 746: self = .timeIntervalSince1970 - case 747: self = .timeIntervalSinceReferenceDate - case 748: self = .timestamp - case 749: self = .total - case 750: self = .totalArrayDepth - case 751: self = .totalSize - case 752: self = .trailingComments - case 753: self = .traverse - case 754: self = .true - case 755: self = .try - case 756: self = .type - case 757: self = .typealias - case 758: self = .typeEnum - case 759: self = .typeName - case 760: self = .typePrefix - case 761: self = .typeStart - case 762: self = .typeUnknown - case 763: self = .typeURL - case 764: self = .uint32 - case 765: self = .uint32Value - case 766: self = .uint64 - case 767: self = .uint64Value - case 768: self = .uint8 - case 769: self = .unicodeScalarLiteral - case 770: self = .unicodeScalarLiteralType - case 771: self = .unicodeScalars - case 772: self = .unicodeScalarView - case 773: self = .uninterpretedOption - case 774: self = .union - case 775: self = .uniqueStorage - case 776: self = .unknown - case 777: self = .unknownFields - case 778: self = .unknownStorage - case 779: self = .unpackTo - case 780: self = .unsafeBufferPointer - case 781: self = .unsafeMutablePointer - case 782: self = .unsafeMutableRawBufferPointer - case 783: self = .unsafeMutableRawPointer - case 784: self = .unsafeRawBufferPointer - case 785: self = .unsafeRawPointer - case 786: self = .updatedOptions - case 787: self = .url - case 788: self = .utf8 - case 789: self = .utf8Ptr - case 790: self = .utf8ToDouble - case 791: self = .utf8View - case 792: self = .v - case 793: self = .value - case 794: self = .valueField - case 795: self = .values - case 796: self = .valueType - case 797: self = .var - case 798: self = .version - case 799: self = .versionString - case 800: self = .visitExtensionFields - case 801: self = .visitExtensionFieldsAsMessageSet - case 802: self = .visitMapField - case 803: self = .visitor - case 804: self = .visitPacked - case 805: self = .visitPackedBoolField - case 806: self = .visitPackedDoubleField - case 807: self = .visitPackedEnumField - case 808: self = .visitPackedFixed32Field - case 809: self = .visitPackedFixed64Field - case 810: self = .visitPackedFloatField - case 811: self = .visitPackedInt32Field - case 812: self = .visitPackedInt64Field - case 813: self = .visitPackedSfixed32Field - case 814: self = .visitPackedSfixed64Field - case 815: self = .visitPackedSint32Field - case 816: self = .visitPackedSint64Field - case 817: self = .visitPackedUint32Field - case 818: self = .visitPackedUint64Field - case 819: self = .visitRepeated - case 820: self = .visitRepeatedBoolField - case 821: self = .visitRepeatedBytesField - case 822: self = .visitRepeatedDoubleField - case 823: self = .visitRepeatedEnumField - case 824: self = .visitRepeatedFixed32Field - case 825: self = .visitRepeatedFixed64Field - case 826: self = .visitRepeatedFloatField - case 827: self = .visitRepeatedGroupField - case 828: self = .visitRepeatedInt32Field - case 829: self = .visitRepeatedInt64Field - case 830: self = .visitRepeatedMessageField - case 831: self = .visitRepeatedSfixed32Field - case 832: self = .visitRepeatedSfixed64Field - case 833: self = .visitRepeatedSint32Field - case 834: self = .visitRepeatedSint64Field - case 835: self = .visitRepeatedStringField - case 836: self = .visitRepeatedUint32Field - case 837: self = .visitRepeatedUint64Field - case 838: self = .visitSingular - case 839: self = .visitSingularBoolField - case 840: self = .visitSingularBytesField - case 841: self = .visitSingularDoubleField - case 842: self = .visitSingularEnumField - case 843: self = .visitSingularFixed32Field - case 844: self = .visitSingularFixed64Field - case 845: self = .visitSingularFloatField - case 846: self = .visitSingularGroupField - case 847: self = .visitSingularInt32Field - case 848: self = .visitSingularInt64Field - case 849: self = .visitSingularMessageField - case 850: self = .visitSingularSfixed32Field - case 851: self = .visitSingularSfixed64Field - case 852: self = .visitSingularSint32Field - case 853: self = .visitSingularSint64Field - case 854: self = .visitSingularStringField - case 855: self = .visitSingularUint32Field - case 856: self = .visitSingularUint64Field - case 857: self = .visitUnknown - case 858: self = .wasDecoded - case 859: self = .weak - case 860: self = .weakDependency - case 861: self = .where - case 862: self = .wireFormat - case 863: self = .with - case 864: self = .withUnsafeBytes - case 865: self = .withUnsafeMutableBytes - case 866: self = .work - case 867: self = .wrappedType - case 868: self = .written - case 869: self = .yday + case 1: self = .addPath + case 2: self = .adjusted + case 3: self = .aggregateValue + case 4: self = .allCases_ + case 5: self = .allowAlias + case 6: self = .alwaysPrintEnumsAsInts + case 7: self = .alwaysPrintInt64SAsNumbers + case 8: self = .annotation + case 9: self = .any + case 10: self = .anyExtensionField + case 11: self = .anyMessageExtension + case 12: self = .anyMessageStorage + case 13: self = .anyUnpackError + case 14: self = .append + case 15: self = .appended + case 16: self = .appendUintHex + case 17: self = .appendUnknown + case 18: self = .areAllInitialized + case 19: self = .array + case 20: self = .arrayDepth + case 21: self = .arrayLiteral + case 22: self = .arraySeparator + case 23: self = .as + case 24: self = .asciiOpenCurlyBracket + case 25: self = .asciiZero + case 26: self = .async + case 27: self = .asyncIterator + case 28: self = .asyncIteratorProtocol + case 29: self = .asyncMessageSequence + case 30: self = .available + case 31: self = .b + case 32: self = .base + case 33: self = .base64Values + case 34: self = .baseAddress + case 35: self = .baseType + case 36: self = .begin + case 37: self = .binary + case 38: self = .binaryDecoder + case 39: self = .binaryDecoding + case 40: self = .binaryDecodingError + case 41: self = .binaryDecodingOptions + case 42: self = .binaryDelimited + case 43: self = .binaryEncoder + case 44: self = .binaryEncodingError + case 45: self = .binaryEncodingMessageSetSizeVisitor + case 46: self = .binaryEncodingMessageSetVisitor + case 47: self = .binaryEncodingOptions + case 48: self = .binaryEncodingSizeVisitor + case 49: self = .binaryEncodingVisitor + case 50: self = .binaryOptions + case 51: self = .binaryProtobufDelimitedMessages + case 52: self = .binaryStreamDecoding + case 53: self = .binaryStreamDecodingError + case 54: self = .bitPattern + case 55: self = .body + case 56: self = .bool + case 57: self = .booleanLiteral + case 58: self = .booleanLiteralType + case 59: self = .boolValue + case 60: self = .buffer + case 61: self = .byte + case 62: self = .bytecode + case 63: self = .bytecodeReader + case 64: self = .bytes + case 65: self = .bytesInGroup + case 66: self = .bytesNeeded + case 67: self = .bytesRead + case 68: self = .c + case 69: self = .canonical + case 70: self = .capitalizeNext + case 71: self = .cardinality + case 72: self = .caseIterable + case 73: self = .castedValue + case 74: self = .ccEnableArenas + case 75: self = .ccGenericServices + case 76: self = .character + case 77: self = .chars + case 78: self = .checkProgramFormat + case 79: self = .chunk + case 80: self = .class + case 81: self = .clearAggregateValue + case 82: self = .clearAllowAlias + case 83: self = .clearBegin + case 84: self = .clearCcEnableArenas + case 85: self = .clearCcGenericServices + case 86: self = .clearClientStreaming + case 87: self = .clearCsharpNamespace + case 88: self = .clearCtype + case 89: self = .clearDebugRedact + case 90: self = .clearDefaultSymbolVisibility + case 91: self = .clearDefaultValue + case 92: self = .clearDeprecated + case 93: self = .clearDeprecatedLegacyJsonFieldConflicts + case 94: self = .clearDeprecationWarning + case 95: self = .clearDoubleValue + case 96: self = .clearEdition + case 97: self = .clearEditionDeprecated + case 98: self = .clearEditionIntroduced + case 99: self = .clearEditionRemoved + case 100: self = .clearEnd + case 101: self = .clearEnforceNamingStyle + case 102: self = .clearEnumType + case 103: self = .clearExtendee + case 104: self = .clearExtensionValue + case 105: self = .clearFeatures + case 106: self = .clearFeatureSupport + case 107: self = .clearFieldPresence + case 108: self = .clearFixedFeatures + case 109: self = .clearFullName + case 110: self = .clearGoPackage + case 111: self = .clearIdempotencyLevel + case 112: self = .clearIdentifierValue + case 113: self = .clearInputType + case 114: self = .clearIsExtension + case 115: self = .clearJavaGenerateEqualsAndHash + case 116: self = .clearJavaGenericServices + case 117: self = .clearJavaMultipleFiles + case 118: self = .clearJavaOuterClassname + case 119: self = .clearJavaPackage + case 120: self = .clearJavaStringCheckUtf8 + case 121: self = .clearJsonFormat + case 122: self = .clearJsonName + case 123: self = .clearJstype + case 124: self = .clearLabel + case 125: self = .clearLazy + case 126: self = .clearLeadingComments + case 127: self = .clearMapEntry + case 128: self = .clearMaximumEdition + case 129: self = .clearMessageEncoding + case 130: self = .clearMessageSetWireFormat + case 131: self = .clearMinimumEdition + case 132: self = .clearName + case 133: self = .clearNamePart + case 134: self = .clearNegativeIntValue + case 135: self = .clearNoStandardDescriptorAccessor + case 136: self = .clearNumber + case 137: self = .clearObjcClassPrefix + case 138: self = .clearOneofIndex + case 139: self = .clearOptimizeFor + case 140: self = .clearOptions + case 141: self = .clearOutputType + case 142: self = .clearOverridableFeatures + case 143: self = .clearPackage + case 144: self = .clearPacked + case 145: self = .clearPhpClassPrefix + case 146: self = .clearPhpMetadataNamespace + case 147: self = .clearPhpNamespace + case 148: self = .clearPositiveIntValue + case 149: self = .clearProto3Optional + case 150: self = .clearPyGenericServices + case 151: self = .clearRemovalError + case 152: self = .clearRepeated + case 153: self = .clearRepeatedFieldEncoding + case 154: self = .clearReserved + case 155: self = .clearRetention + case 156: self = .clearRubyPackage + case 157: self = .clearSemantic + case 158: self = .clearServerStreaming + case 159: self = .clearSourceCodeInfo + case 160: self = .clearSourceContext + case 161: self = .clearSourceFile + case 162: self = .clearStart + case 163: self = .clearStringValue + case 164: self = .clearSwiftPrefix + case 165: self = .clearSyntax + case 166: self = .clearTrailingComments + case 167: self = .clearType + case 168: self = .clearTypeName + case 169: self = .clearUnverifiedLazy + case 170: self = .clearUtf8Validation + case 171: self = .clearValue + case 172: self = .clearVerification + case 173: self = .clearVisibility + case 174: self = .clearWeak + case 175: self = .clientStreaming + case 176: self = .code + case 177: self = .codePoint + case 178: self = .codeUnits + case 179: self = .collection + case 180: self = .comma + case 181: self = .consumedBytes + case 182: self = .contains + case 183: self = .contentsOf + case 184: self = .contiguousBytes + case 185: self = .copy + case 186: self = .count + case 187: self = .countVarintsInBuffer + case 188: self = .csharpNamespace + case 189: self = .ctype + case 190: self = .customCodable + case 191: self = .customDebugStringConvertible + case 192: self = .customStringConvertible + case 193: self = .d + case 194: self = .data + case 195: self = .dataResult + case 196: self = .date + case 197: self = .daySec + case 198: self = .daysSinceEpoch + case 199: self = .debugDescription_ + case 200: self = .debugRedact + case 201: self = .declaration + case 202: self = .decoded + case 203: self = .decodedFromJsonnull + case 204: self = .decodeExtensionField + case 205: self = .decodeExtensionFieldsAsMessageSet + case 206: self = .decodeJson + case 207: self = .decodeMapField + case 208: self = .decodeMessage + case 209: self = .decoder + case 210: self = .decodeRepeated + case 211: self = .decodeRepeatedBoolField + case 212: self = .decodeRepeatedBytesField + case 213: self = .decodeRepeatedDoubleField + case 214: self = .decodeRepeatedEnumField + case 215: self = .decodeRepeatedFixed32Field + case 216: self = .decodeRepeatedFixed64Field + case 217: self = .decodeRepeatedFloatField + case 218: self = .decodeRepeatedGroupField + case 219: self = .decodeRepeatedInt32Field + case 220: self = .decodeRepeatedInt64Field + case 221: self = .decodeRepeatedMessageField + case 222: self = .decodeRepeatedSfixed32Field + case 223: self = .decodeRepeatedSfixed64Field + case 224: self = .decodeRepeatedSint32Field + case 225: self = .decodeRepeatedSint64Field + case 226: self = .decodeRepeatedStringField + case 227: self = .decodeRepeatedUint32Field + case 228: self = .decodeRepeatedUint64Field + case 229: self = .decodeSingular + case 230: self = .decodeSingularBoolField + case 231: self = .decodeSingularBytesField + case 232: self = .decodeSingularDoubleField + case 233: self = .decodeSingularEnumField + case 234: self = .decodeSingularFixed32Field + case 235: self = .decodeSingularFixed64Field + case 236: self = .decodeSingularFloatField + case 237: self = .decodeSingularGroupField + case 238: self = .decodeSingularInt32Field + case 239: self = .decodeSingularInt64Field + case 240: self = .decodeSingularMessageField + case 241: self = .decodeSingularSfixed32Field + case 242: self = .decodeSingularSfixed64Field + case 243: self = .decodeSingularSint32Field + case 244: self = .decodeSingularSint64Field + case 245: self = .decodeSingularStringField + case 246: self = .decodeSingularUint32Field + case 247: self = .decodeSingularUint64Field + case 248: self = .decodeTextFormat + case 249: self = .defaultAnyTypeUrlprefix + case 250: self = .defaults + case 251: self = .defaultSymbolVisibility + case 252: self = .defaultValue + case 253: self = .dependency + case 254: self = .deprecated + case 255: self = .deprecatedLegacyJsonFieldConflicts + case 256: self = .deprecationWarning + case 257: self = .description_ + case 258: self = .dictionary + case 259: self = .dictionaryLiteral + case 260: self = .digit + case 261: self = .digit0 + case 262: self = .digit1 + case 263: self = .digitCount + case 264: self = .digits + case 265: self = .digitValue + case 266: self = .discardableResult + case 267: self = .discardUnknownFields + case 268: self = .double + case 269: self = .doubleValue + case 270: self = .duration + case 271: self = .e + case 272: self = .edition + case 273: self = .editionDefault + case 274: self = .editionDefaults + case 275: self = .editionDeprecated + case 276: self = .editionIntroduced + case 277: self = .editionRemoved + case 278: self = .element + case 279: self = .elements + case 280: self = .else + case 281: self = .emitExtensionFieldName + case 282: self = .emitFieldName + case 283: self = .emitFieldNumber + case 284: self = .emptyAnyTypeURL + case 285: self = .emptyData + case 286: self = .encodeAsBytes + case 287: self = .encoded + case 288: self = .encodedJsonstring + case 289: self = .encodedSize + case 290: self = .encodeField + case 291: self = .encoder + case 292: self = .end + case 293: self = .endArray + case 294: self = .endMessageField + case 295: self = .endObject + case 296: self = .endRegularField + case 297: self = .enforceNamingStyle + case 298: self = .enum + case 299: self = .enumReservedRange + case 300: self = .enumType + case 301: self = .enumvalue + case 302: self = .equatable + case 303: self = .error + case 304: self = .execute + case 305: self = .expressibleByArrayLiteral + case 306: self = .expressibleByDictionaryLiteral + case 307: self = .ext + case 308: self = .extDecoder + case 309: self = .extendedGraphemeClusterLiteral + case 310: self = .extendedGraphemeClusterLiteralType + case 311: self = .extendee + case 312: self = .extensibleMessage + case 313: self = .extension + case 314: self = .extensionField + case 315: self = .extensionFieldNumber + case 316: self = .extensionFieldValueSet + case 317: self = .extensionMap + case 318: self = .extensionRange + case 319: self = .extensions + case 320: self = .extras + case 321: self = .f + case 322: self = .false + case 323: self = .features + case 324: self = .featureSetEditionDefault + case 325: self = .featureSupport + case 326: self = .field + case 327: self = .fieldData + case 328: self = .fieldMaskError + case 329: self = .fieldName + case 330: self = .fieldNameCount + case 331: self = .fieldNum + case 332: self = .fieldNumber + case 333: self = .fieldNumberForProto + case 334: self = .fieldPresence + case 335: self = .fields + case 336: self = .fieldSize + case 337: self = .fieldTag + case 338: self = .fieldType + case 339: self = .file + case 340: self = .fileName + case 341: self = .filter + case 342: self = .final + case 343: self = .finiteOnly + case 344: self = .first + case 345: self = .firstItem + case 346: self = .fixedFeatures + case 347: self = .float + case 348: self = .floatLiteral + case 349: self = .floatLiteralType + case 350: self = .for + case 351: self = .forMessageName + case 352: self = .formUnion + case 353: self = .forReadingFrom + case 354: self = .forTypeURL + case 355: self = .forwardParser + case 356: self = .forWritingInto + case 357: self = .from + case 358: self = .fromAscii2 + case 359: self = .fromAscii4 + case 360: self = .fromByteOffset + case 361: self = .fromHexDigit + case 362: self = .fullName + case 363: self = .func + case 364: self = .function + case 365: self = .g + case 366: self = .get + case 367: self = .getExtensionValue + case 368: self = .googleProtobufAny + case 369: self = .googleProtobufApi + case 370: self = .googleProtobufBoolValue + case 371: self = .googleProtobufBytesValue + case 372: self = .googleProtobufDescriptorProto + case 373: self = .googleProtobufDoubleValue + case 374: self = .googleProtobufDuration + case 375: self = .googleProtobufEdition + case 376: self = .googleProtobufEmpty + case 377: self = .googleProtobufEnum + case 378: self = .googleProtobufEnumDescriptorProto + case 379: self = .googleProtobufEnumOptions + case 380: self = .googleProtobufEnumValue + case 381: self = .googleProtobufEnumValueDescriptorProto + case 382: self = .googleProtobufEnumValueOptions + case 383: self = .googleProtobufExtensionRangeOptions + case 384: self = .googleProtobufFeatureSet + case 385: self = .googleProtobufFeatureSetDefaults + case 386: self = .googleProtobufField + case 387: self = .googleProtobufFieldDescriptorProto + case 388: self = .googleProtobufFieldMask + case 389: self = .googleProtobufFieldOptions + case 390: self = .googleProtobufFileDescriptorProto + case 391: self = .googleProtobufFileDescriptorSet + case 392: self = .googleProtobufFileOptions + case 393: self = .googleProtobufFloatValue + case 394: self = .googleProtobufGeneratedCodeInfo + case 395: self = .googleProtobufInt32Value + case 396: self = .googleProtobufInt64Value + case 397: self = .googleProtobufListValue + case 398: self = .googleProtobufMessageOptions + case 399: self = .googleProtobufMethod + case 400: self = .googleProtobufMethodDescriptorProto + case 401: self = .googleProtobufMethodOptions + case 402: self = .googleProtobufMixin + case 403: self = .googleProtobufNullValue + case 404: self = .googleProtobufOneofDescriptorProto + case 405: self = .googleProtobufOneofOptions + case 406: self = .googleProtobufOption + case 407: self = .googleProtobufServiceDescriptorProto + case 408: self = .googleProtobufServiceOptions + case 409: self = .googleProtobufSourceCodeInfo + case 410: self = .googleProtobufSourceContext + case 411: self = .googleProtobufStringValue + case 412: self = .googleProtobufStruct + case 413: self = .googleProtobufSymbolVisibility + case 414: self = .googleProtobufSyntax + case 415: self = .googleProtobufTimestamp + case 416: self = .googleProtobufType + case 417: self = .googleProtobufUint32Value + case 418: self = .googleProtobufUint64Value + case 419: self = .googleProtobufUninterpretedOption + case 420: self = .googleProtobufValue + case 421: self = .goPackage + case 422: self = .gotData + case 423: self = .group + case 424: self = .groupFieldNumberStack + case 425: self = .groupSize + case 426: self = .guard + case 427: self = .hadOneofValue + case 428: self = .handleConflictingOneOf + case 429: self = .handleInstruction + case 430: self = .hasAggregateValue + case 431: self = .hasAllowAlias + case 432: self = .hasBegin + case 433: self = .hasCcEnableArenas + case 434: self = .hasCcGenericServices + case 435: self = .hasClientStreaming + case 436: self = .hasCsharpNamespace + case 437: self = .hasCtype + case 438: self = .hasData + case 439: self = .hasDebugRedact + case 440: self = .hasDefaultSymbolVisibility + case 441: self = .hasDefaultValue + case 442: self = .hasDeprecated + case 443: self = .hasDeprecatedLegacyJsonFieldConflicts + case 444: self = .hasDeprecationWarning + case 445: self = .hasDoubleValue + case 446: self = .hasEdition + case 447: self = .hasEditionDeprecated + case 448: self = .hasEditionIntroduced + case 449: self = .hasEditionRemoved + case 450: self = .hasEnd + case 451: self = .hasEnforceNamingStyle + case 452: self = .hasEnumType + case 453: self = .hasExplicitDelta + case 454: self = .hasExtendee + case 455: self = .hasExtensionValue + case 456: self = .hasFeatures + case 457: self = .hasFeatureSupport + case 458: self = .hasFieldPresence + case 459: self = .hasFixedFeatures + case 460: self = .hasFullName + case 461: self = .hasGoPackage + case 462: self = .hash + case 463: self = .hashable + case 464: self = .hasher + case 465: self = .hashVisitor + case 466: self = .hasIdempotencyLevel + case 467: self = .hasIdentifierValue + case 468: self = .hasInputType + case 469: self = .hasIsExtension + case 470: self = .hasJavaGenerateEqualsAndHash + case 471: self = .hasJavaGenericServices + case 472: self = .hasJavaMultipleFiles + case 473: self = .hasJavaOuterClassname + case 474: self = .hasJavaPackage + case 475: self = .hasJavaStringCheckUtf8 + case 476: self = .hasJsonFormat + case 477: self = .hasJsonName + case 478: self = .hasJstype + case 479: self = .hasLabel + case 480: self = .hasLazy + case 481: self = .hasLeadingComments + case 482: self = .hasMapEntry + case 483: self = .hasMaximumEdition + case 484: self = .hasMessageEncoding + case 485: self = .hasMessageSetWireFormat + case 486: self = .hasMinimumEdition + case 487: self = .hasName + case 488: self = .hasNamePart + case 489: self = .hasNegativeIntValue + case 490: self = .hasNoStandardDescriptorAccessor + case 491: self = .hasNumber + case 492: self = .hasObjcClassPrefix + case 493: self = .hasOneofIndex + case 494: self = .hasOptimizeFor + case 495: self = .hasOptions + case 496: self = .hasOutputType + case 497: self = .hasOverridableFeatures + case 498: self = .hasPackage + case 499: self = .hasPacked + case 500: self = .hasPhpClassPrefix + case 501: self = .hasPhpMetadataNamespace + case 502: self = .hasPhpNamespace + case 503: self = .hasPositiveIntValue + case 504: self = .hasProto3Optional + case 505: self = .hasPyGenericServices + case 506: self = .hasRemovalError + case 507: self = .hasRepeated + case 508: self = .hasRepeatedFieldEncoding + case 509: self = .hasReserved + case 510: self = .hasRetention + case 511: self = .hasRubyPackage + case 512: self = .hasSemantic + case 513: self = .hasServerStreaming + case 514: self = .hasSourceCodeInfo + case 515: self = .hasSourceContext + case 516: self = .hasSourceFile + case 517: self = .hasStart + case 518: self = .hasStringValue + case 519: self = .hasSwiftPrefix + case 520: self = .hasSyntax + case 521: self = .hasTrailingComments + case 522: self = .hasType + case 523: self = .hasTypeName + case 524: self = .hasUnverifiedLazy + case 525: self = .hasUtf8Validation + case 526: self = .hasValue + case 527: self = .hasVerification + case 528: self = .hasVisibility + case 529: self = .hasWeak + case 530: self = .hour + case 531: self = .i + case 532: self = .idempotencyLevel + case 533: self = .identifierValue + case 534: self = .if + case 535: self = .ignoreUnknownExtensionFields + case 536: self = .ignoreUnknownFields + case 537: self = .index + case 538: self = .init_ + case 539: self = .inout + case 540: self = .inputType + case 541: self = .insert + case 542: self = .instruction + case 543: self = .int + case 544: self = .int32 + case 545: self = .int64 + case 546: self = .int8 + case 547: self = .integerLiteral + case 548: self = .integerLiteralType + case 549: self = .intern + case 550: self = .internal + case 551: self = .internalState + case 552: self = .intersect + case 553: self = .into + case 554: self = .ints + case 555: self = .invalidAnyTypeURL + case 556: self = .isA + case 557: self = .isEqual + case 558: self = .isEqualTo + case 559: self = .isExtension + case 560: self = .isInitialized + case 561: self = .isNegative + case 562: self = .isPathValid + case 563: self = .isReserved + case 564: self = .isValid + case 565: self = .itemTagsEncodedSize + case 566: self = .iterator + case 567: self = .javaGenerateEqualsAndHash + case 568: self = .javaGenericServices + case 569: self = .javaMultipleFiles + case 570: self = .javaOuterClassname + case 571: self = .javaPackage + case 572: self = .javaStringCheckUtf8 + case 573: self = .jsondecoder + case 574: self = .jsondecoding + case 575: self = .jsondecodingError + case 576: self = .jsondecodingOptions + case 577: self = .jsonEncoder + case 578: self = .jsonencoding + case 579: self = .jsonencodingError + case 580: self = .jsonencodingOptions + case 581: self = .jsonencodingVisitor + case 582: self = .jsonFormat + case 583: self = .jsonmapEncodingVisitor + case 584: self = .jsonName + case 585: self = .jsonPath + case 586: self = .jsonPaths + case 587: self = .jsonscanner + case 588: self = .jsonString + case 589: self = .jsonText + case 590: self = .jsonUtf8Bytes + case 591: self = .jsonUtf8Data + case 592: self = .jstype + case 593: self = .k + case 594: self = .kChunkSize + case 595: self = .key + case 596: self = .keyField + case 597: self = .keyFieldOpt + case 598: self = .keyType + case 599: self = .kind + case 600: self = .l + case 601: self = .label + case 602: self = .lazy + case 603: self = .leadingComments + case 604: self = .leadingDetachedComments + case 605: self = .length + case 606: self = .lessThan + case 607: self = .let + case 608: self = .lhs + case 609: self = .line + case 610: self = .list + case 611: self = .listOfMessages + case 612: self = .listValue + case 613: self = .littleEndian + case 614: self = .load + case 615: self = .localHasher + case 616: self = .location + case 617: self = .m + case 618: self = .major + case 619: self = .makeAsyncIterator + case 620: self = .makeIterator + case 621: self = .malformedLength + case 622: self = .mapEntry + case 623: self = .mapKeyType + case 624: self = .mapToMessages + case 625: self = .mapValueType + case 626: self = .mapVisitor + case 627: self = .mask + case 628: self = .maximumEdition + case 629: self = .mdayStart + case 630: self = .merge + case 631: self = .mergeOptions + case 632: self = .message + case 633: self = .messageDepthLimit + case 634: self = .messageEncoding + case 635: self = .messageExtension + case 636: self = .messageImplementationBase + case 637: self = .messageSet + case 638: self = .messageSetWireFormat + case 639: self = .messageSize + case 640: self = .messageType + case 641: self = .method + case 642: self = .methods + case 643: self = .min + case 644: self = .minimumEdition + case 645: self = .minor + case 646: self = .mixins + case 647: self = .modify + case 648: self = .month + case 649: self = .msgExtension + case 650: self = .mutating + case 651: self = .n + case 652: self = .name + case 653: self = .nameDescription + case 654: self = .nameMap + case 655: self = .namePart + case 656: self = .names + case 657: self = .nanos + case 658: self = .negativeIntValue + case 659: self = .nestedType + case 660: self = .newExtensible + case 661: self = .newL + case 662: self = .newList + case 663: self = .newMessage + case 664: self = .newValue + case 665: self = .next + case 666: self = .nextByte + case 667: self = .nextFieldNumber + case 668: self = .nextInstruction + case 669: self = .nextInt32 + case 670: self = .nextNullTerminatedString + case 671: self = .nextNullTerminatedStringArray + case 672: self = .nextNumber + case 673: self = .nextUint64 + case 674: self = .nextVarInt + case 675: self = .nil + case 676: self = .nilLiteral + case 677: self = .noBytesAvailable + case 678: self = .noStandardDescriptorAccessor + case 679: self = .nullValue + case 680: self = .number + case 681: self = .numberValue + case 682: self = .objcClassPrefix + case 683: self = .of + case 684: self = .oneOfKind + case 685: self = .oneofDecl + case 686: self = .oneofIndex + case 687: self = .oneofs + case 688: self = .optimizeFor + case 689: self = .optimizeMode + case 690: self = .optionalEnumExtensionField + case 691: self = .optionalExtensionField + case 692: self = .optionalGroupExtensionField + case 693: self = .optionalMessageExtensionField + case 694: self = .optionDependency + case 695: self = .optionRetention + case 696: self = .options + case 697: self = .optionTargetType + case 698: self = .other + case 699: self = .others + case 700: self = .out + case 701: self = .outputType + case 702: self = .overridableFeatures + case 703: self = .p + case 704: self = .package + case 705: self = .packed + case 706: self = .packedEnumExtensionField + case 707: self = .packedExtensionField + case 708: self = .padding + case 709: self = .parent + case 710: self = .parse + case 711: self = .partial + case 712: self = .path + case 713: self = .pathDecoder + case 714: self = .pathDecodingError + case 715: self = .paths + case 716: self = .pathVisitor + case 717: self = .payload + case 718: self = .payloadSize + case 719: self = .phpClassPrefix + case 720: self = .phpMetadataNamespace + case 721: self = .phpNamespace + case 722: self = .pos + case 723: self = .positiveIntValue + case 724: self = .prefix + case 725: self = .preserveProtoFieldNames + case 726: self = .preTraverse + case 727: self = .previousNumber + case 728: self = .prevPath + case 729: self = .printUnknownFields + case 730: self = .programBuffer + case 731: self = .programFormat + case 732: self = .proto2 + case 733: self = .proto3DefaultValue + case 734: self = .proto3Optional + case 735: self = .protobufExtensionFieldValues + case 736: self = .protobufFieldNumber + case 737: self = .protobufGeneratedIsEqualTo + case 738: self = .protobufNameMap + case 739: self = .protobufNewField + case 740: self = .protobufPackage + case 741: self = .protobufApiversion2 + case 742: self = .protobufApiversionCheck + case 743: self = .protobufBool + case 744: self = .protobufBytes + case 745: self = .protobufData + case 746: self = .protobufDouble + case 747: self = .protobufEnumMap + case 748: self = .protobufExtension + case 749: self = .protobufFixed32 + case 750: self = .protobufFixed64 + case 751: self = .protobufFloat + case 752: self = .protobufInt32 + case 753: self = .protobufInt64 + case 754: self = .protobufMap + case 755: self = .protobufMessageMap + case 756: self = .protobufSfixed32 + case 757: self = .protobufSfixed64 + case 758: self = .protobufSint32 + case 759: self = .protobufSint64 + case 760: self = .protobufString + case 761: self = .protobufUint32 + case 762: self = .protobufUint64 + case 763: self = .protocol + case 764: self = .protoFieldName + case 765: self = .protoMessageName + case 766: self = .protoNameProviding + case 767: self = .protoPaths + case 768: self = .public + case 769: self = .publicDependency + case 770: self = .putBoolValue + case 771: self = .putBytesValue + case 772: self = .putDoubleValue + case 773: self = .putEnumValue + case 774: self = .putFixedUint32 + case 775: self = .putFixedUint64 + case 776: self = .putFloatValue + case 777: self = .putInt64 + case 778: self = .putStringValue + case 779: self = .putUint64 + case 780: self = .putUint64Hex + case 781: self = .putVarInt + case 782: self = .putZigZagVarInt + case 783: self = .pyGenericServices + case 784: self = .r + case 785: self = .rawChars + case 786: self = .rawRepresentable + case 787: self = .rawValue_ + case 788: self = .read4HexDigits + case 789: self = .readBytes + case 790: self = .reader + case 791: self = .register + case 792: self = .remainingProgram + case 793: self = .removalError + case 794: self = .removingAllFieldsOf + case 795: self = .repeated + case 796: self = .repeatedEnumExtensionField + case 797: self = .repeatedExtensionField + case 798: self = .repeatedFieldEncoding + case 799: self = .repeatedGroupExtensionField + case 800: self = .repeatedMessageExtensionField + case 801: self = .repeating + case 802: self = .replaceRepeatedFields + case 803: self = .requestStreaming + case 804: self = .requestTypeURL + case 805: self = .requiredSize + case 806: self = .responseStreaming + case 807: self = .responseTypeURL + case 808: self = .result + case 809: self = .retention + case 810: self = .rethrows + case 811: self = .returnType + case 812: self = .revision + case 813: self = .rhs + case 814: self = .root + case 815: self = .rubyPackage + case 816: self = .s + case 817: self = .sawBackslash + case 818: self = .sawSection4Characters + case 819: self = .sawSection5Characters + case 820: self = .scalar + case 821: self = .scan + case 822: self = .scanner + case 823: self = .seconds + case 824: self = .self_ + case 825: self = .semantic + case 826: self = .sendable + case 827: self = .separator + case 828: self = .serialize + case 829: self = .serializedBytes + case 830: self = .serializedData + case 831: self = .serializedSize + case 832: self = .serverStreaming + case 833: self = .service + case 834: self = .set + case 835: self = .setExtensionValue + case 836: self = .shift + case 837: self = .simpleExtensionMap + case 838: self = .size + case 839: self = .sizer + case 840: self = .source + case 841: self = .sourceCodeInfo + case 842: self = .sourceContext + case 843: self = .sourceEncoding + case 844: self = .sourceFile + case 845: self = .sourceLocation + case 846: self = .span + case 847: self = .split + case 848: self = .start + case 849: self = .startArray + case 850: self = .startArrayObject + case 851: self = .startField + case 852: self = .startIndex + case 853: self = .startMessageField + case 854: self = .startObject + case 855: self = .startRegularField + case 856: self = .state + case 857: self = .static + case 858: self = .staticString + case 859: self = .storage + case 860: self = .string + case 861: self = .stringLiteral + case 862: self = .stringLiteralType + case 863: self = .stringResult + case 864: self = .stringValue + case 865: self = .struct + case 866: self = .structValue + case 867: self = .subDecoder + case 868: self = .subscript + case 869: self = .subtract + case 870: self = .subVisitor + case 871: self = .swift + case 872: self = .swiftPrefix + case 873: self = .swiftProtobufContiguousBytes + case 874: self = .swiftProtobufError + case 875: self = .syntax + case 876: self = .t + case 877: self = .tag + case 878: self = .targets + case 879: self = .terminator + case 880: self = .testDecoder + case 881: self = .text + case 882: self = .textDecoder + case 883: self = .textFormatDecoder + case 884: self = .textFormatDecodingError + case 885: self = .textFormatDecodingOptions + case 886: self = .textFormatEncodingOptions + case 887: self = .textFormatEncodingVisitor + case 888: self = .textFormatString + case 889: self = .throwOrIgnore + case 890: self = .throws + case 891: self = .timeInterval + case 892: self = .timeIntervalSince1970 + case 893: self = .timeIntervalSinceReferenceDate + case 894: self = .tmp + case 895: self = .tooLarge + case 896: self = .total + case 897: self = .totalArrayDepth + case 898: self = .totalSize + case 899: self = .trailingComments + case 900: self = .traverse + case 901: self = .trim + case 902: self = .true + case 903: self = .try + case 904: self = .type + case 905: self = .typealias + case 906: self = .typeEnum + case 907: self = .typeName + case 908: self = .typePrefix + case 909: self = .typeStart + case 910: self = .typeUnknown + case 911: self = .typeURL + case 912: self = .uint32 + case 913: self = .uint64 + case 914: self = .uint8 + case 915: self = .unchecked + case 916: self = .unicode + case 917: self = .unicodeScalarLiteral + case 918: self = .unicodeScalarLiteralType + case 919: self = .unicodeScalars + case 920: self = .unicodeScalarView + case 921: self = .uninterpretedOption + case 922: self = .union + case 923: self = .uniqueStorage + case 924: self = .unknown + case 925: self = .unknownFields + case 926: self = .unknownStorage + case 927: self = .unpackTo + case 928: self = .unsafeBufferPointer + case 929: self = .unsafeMutablePointer + case 930: self = .unsafeMutableRawBufferPointer + case 931: self = .unsafeRawBufferPointer + case 932: self = .unsafeRawPointer + case 933: self = .unverifiedLazy + case 934: self = .updatedOptions + case 935: self = .uppercasedAssumingAscii + case 936: self = .url + case 937: self = .useDeterministicOrdering + case 938: self = .utf8 + case 939: self = .utf8Ptr + case 940: self = .utf8ToDouble + case 941: self = .utf8Validation + case 942: self = .utf8View + case 943: self = .v + case 944: self = .value + case 945: self = .valueField + case 946: self = .values + case 947: self = .valueType + case 948: self = .var + case 949: self = .verification + case 950: self = .verificationState + case 951: self = .version + case 952: self = .versionString + case 953: self = .visibility + case 954: self = .visibilityFeature + case 955: self = .visitExtensionFields + case 956: self = .visitExtensionFieldsAsMessageSet + case 957: self = .visitMapField + case 958: self = .visitor + case 959: self = .visitPacked + case 960: self = .visitPackedBoolField + case 961: self = .visitPackedDoubleField + case 962: self = .visitPackedEnumField + case 963: self = .visitPackedFixed32Field + case 964: self = .visitPackedFixed64Field + case 965: self = .visitPackedFloatField + case 966: self = .visitPackedInt32Field + case 967: self = .visitPackedInt64Field + case 968: self = .visitPackedSfixed32Field + case 969: self = .visitPackedSfixed64Field + case 970: self = .visitPackedSint32Field + case 971: self = .visitPackedSint64Field + case 972: self = .visitPackedUint32Field + case 973: self = .visitPackedUint64Field + case 974: self = .visitRepeated + case 975: self = .visitRepeatedBoolField + case 976: self = .visitRepeatedBytesField + case 977: self = .visitRepeatedDoubleField + case 978: self = .visitRepeatedEnumField + case 979: self = .visitRepeatedFixed32Field + case 980: self = .visitRepeatedFixed64Field + case 981: self = .visitRepeatedFloatField + case 982: self = .visitRepeatedGroupField + case 983: self = .visitRepeatedInt32Field + case 984: self = .visitRepeatedInt64Field + case 985: self = .visitRepeatedMessageField + case 986: self = .visitRepeatedSfixed32Field + case 987: self = .visitRepeatedSfixed64Field + case 988: self = .visitRepeatedSint32Field + case 989: self = .visitRepeatedSint64Field + case 990: self = .visitRepeatedStringField + case 991: self = .visitRepeatedUint32Field + case 992: self = .visitRepeatedUint64Field + case 993: self = .visitSingular + case 994: self = .visitSingularBoolField + case 995: self = .visitSingularBytesField + case 996: self = .visitSingularDoubleField + case 997: self = .visitSingularEnumField + case 998: self = .visitSingularFixed32Field + case 999: self = .visitSingularFixed64Field + case 1000: self = .visitSingularFloatField + case 1001: self = .visitSingularGroupField + case 1002: self = .visitSingularInt32Field + case 1003: self = .visitSingularInt64Field + case 1004: self = .visitSingularMessageField + case 1005: self = .visitSingularSfixed32Field + case 1006: self = .visitSingularSfixed64Field + case 1007: self = .visitSingularSint32Field + case 1008: self = .visitSingularSint64Field + case 1009: self = .visitSingularStringField + case 1010: self = .visitSingularUint32Field + case 1011: self = .visitSingularUint64Field + case 1012: self = .visitUnknown + case 1013: self = .void + case 1014: self = .wasDecoded + case 1015: self = .weak + case 1016: self = .weakDependency + case 1017: self = .where + case 1018: self = .wireFormat + case 1019: self = .with + case 1020: self = .withUnsafeBytes + case 1021: self = .withUnsafeMutableBytes + case 1022: self = .work + case 1023: self = .wrapped + case 1024: self = .wrappedType + case 1025: self = .wrappedValue + case 1026: self = .written + case 1027: self = .yday default: self = .UNRECOGNIZED(rawValue) } } @@ -1781,878 +2097,1039 @@ enum ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum { var rawValue: Int { switch self { case .none: return 0 - case .adjusted: return 1 - case .aggregateValue: return 2 - case .allCases_: return 3 - case .allowAlias: return 4 - case .alwaysPrintEnumsAsInts: return 5 - case .annotation: return 6 - case .any: return 7 - case .anyExtensionField: return 8 - case .anyMessageExtension: return 9 - case .anyMessageStorage: return 10 - case .anyUnpackError: return 11 - case .api: return 12 - case .appended: return 13 - case .appendUintHex: return 14 - case .appendUnknown: return 15 - case .areAllInitialized: return 16 - case .array: return 17 - case .arrayDepth: return 18 - case .arrayLiteral: return 19 - case .arraySeparator: return 20 - case .as: return 21 - case .asciiOpenCurlyBracket: return 22 - case .asciiZero: return 23 - case .available: return 24 - case .b: return 25 - case .base64Values: return 26 - case .baseAddress: return 27 - case .baseType: return 28 - case .begin: return 29 - case .binary: return 30 - case .binaryDecoder: return 31 - case .binaryDecodingError: return 32 - case .binaryDecodingOptions: return 33 - case .binaryDelimited: return 34 - case .binaryEncoder: return 35 - case .binaryEncodingError: return 36 - case .binaryEncodingMessageSetSizeVisitor: return 37 - case .binaryEncodingMessageSetVisitor: return 38 - case .binaryEncodingSizeVisitor: return 39 - case .binaryEncodingVisitor: return 40 - case .binaryOptions: return 41 - case .body: return 42 - case .bool: return 43 - case .booleanLiteral: return 44 - case .booleanLiteralType: return 45 - case .boolValue: return 46 - case .bytes: return 47 - case .bytesInGroup: return 48 - case .bytesRead: return 49 - case .bytesValue: return 50 - case .c: return 51 - case .capitalizeNext: return 52 - case .cardinality: return 53 - case .ccEnableArenas: return 54 - case .ccGenericServices: return 55 - case .character: return 56 - case .chars: return 57 - case .class: return 58 - case .clearAggregateValue: return 59 - case .clearAllowAlias: return 60 - case .clearBegin: return 61 - case .clearCcEnableArenas: return 62 - case .clearCcGenericServices: return 63 - case .clearClientStreaming: return 64 - case .clearCsharpNamespace: return 65 - case .clearCtype: return 66 - case .clearDefaultValue: return 67 - case .clearDeprecated: return 68 - case .clearDoubleValue: return 69 - case .clearEnd: return 70 - case .clearExtendee: return 71 - case .clearExtensionValue: return 72 - case .clearGoPackage: return 73 - case .clearIdempotencyLevel: return 74 - case .clearIdentifierValue: return 75 - case .clearInputType: return 76 - case .clearIsExtension: return 77 - case .clearJavaGenerateEqualsAndHash: return 78 - case .clearJavaGenericServices: return 79 - case .clearJavaMultipleFiles: return 80 - case .clearJavaOuterClassname: return 81 - case .clearJavaPackage: return 82 - case .clearJavaStringCheckUtf8: return 83 - case .clearJsonName: return 84 - case .clearJstype: return 85 - case .clearLabel: return 86 - case .clearLazy: return 87 - case .clearLeadingComments: return 88 - case .clearMapEntry: return 89 - case .clearMessageSetWireFormat: return 90 - case .clearName: return 91 - case .clearNamePart: return 92 - case .clearNegativeIntValue: return 93 - case .clearNoStandardDescriptorAccessor: return 94 - case .clearNumber: return 95 - case .clearObjcClassPrefix: return 96 - case .clearOneofIndex: return 97 - case .clearOptimizeFor: return 98 - case .clearOptions: return 99 - case .clearOutputType: return 100 - case .clearPackage: return 101 - case .clearPacked: return 102 - case .clearPhpClassPrefix: return 103 - case .clearPhpGenericServices: return 104 - case .clearPhpMetadataNamespace: return 105 - case .clearPhpNamespace: return 106 - case .clearPositiveIntValue: return 107 - case .clearProto3Optional: return 108 - case .clearPyGenericServices: return 109 - case .clearRubyPackage: return 110 - case .clearServerStreaming: return 111 - case .clearSourceCodeInfo: return 112 - case .clearSourceContext: return 113 - case .clearSourceFile: return 114 - case .clearStart: return 115 - case .clearStringValue: return 116 - case .clearSwiftPrefix: return 117 - case .clearSyntax: return 118 - case .clearTrailingComments: return 119 - case .clearType: return 120 - case .clearTypeName: return 121 - case .clearValue: return 122 - case .clearWeak: return 123 - case .clientStreaming: return 124 - case .codePoint: return 125 - case .codeUnits: return 126 - case .collection: return 127 - case .com: return 128 - case .comma: return 129 - case .contentsOf: return 130 - case .contiguousBytes: return 131 - case .count: return 132 - case .countVarintsInBuffer: return 133 - case .csharpNamespace: return 134 - case .ctype: return 135 - case .customCodable: return 136 - case .customDebugStringConvertible: return 137 - case .d: return 138 - case .data: return 139 - case .dataResult: return 140 - case .date: return 141 - case .daySec: return 142 - case .daysSinceEpoch: return 143 - case .debugDescription_: return 144 - case .decoded: return 145 - case .decodedFromJsonnull: return 146 - case .decodeExtensionField: return 147 - case .decodeExtensionFieldsAsMessageSet: return 148 - case .decodeJson: return 149 - case .decodeMapField: return 150 - case .decodeMessage: return 151 - case .decoder: return 152 - case .decodeRepeated: return 153 - case .decodeRepeatedBoolField: return 154 - case .decodeRepeatedBytesField: return 155 - case .decodeRepeatedDoubleField: return 156 - case .decodeRepeatedEnumField: return 157 - case .decodeRepeatedFixed32Field: return 158 - case .decodeRepeatedFixed64Field: return 159 - case .decodeRepeatedFloatField: return 160 - case .decodeRepeatedGroupField: return 161 - case .decodeRepeatedInt32Field: return 162 - case .decodeRepeatedInt64Field: return 163 - case .decodeRepeatedMessageField: return 164 - case .decodeRepeatedSfixed32Field: return 165 - case .decodeRepeatedSfixed64Field: return 166 - case .decodeRepeatedSint32Field: return 167 - case .decodeRepeatedSint64Field: return 168 - case .decodeRepeatedStringField: return 169 - case .decodeRepeatedUint32Field: return 170 - case .decodeRepeatedUint64Field: return 171 - case .decodeSingular: return 172 - case .decodeSingularBoolField: return 173 - case .decodeSingularBytesField: return 174 - case .decodeSingularDoubleField: return 175 - case .decodeSingularEnumField: return 176 - case .decodeSingularFixed32Field: return 177 - case .decodeSingularFixed64Field: return 178 - case .decodeSingularFloatField: return 179 - case .decodeSingularGroupField: return 180 - case .decodeSingularInt32Field: return 181 - case .decodeSingularInt64Field: return 182 - case .decodeSingularMessageField: return 183 - case .decodeSingularSfixed32Field: return 184 - case .decodeSingularSfixed64Field: return 185 - case .decodeSingularSint32Field: return 186 - case .decodeSingularSint64Field: return 187 - case .decodeSingularStringField: return 188 - case .decodeSingularUint32Field: return 189 - case .decodeSingularUint64Field: return 190 - case .decodeTextFormat: return 191 - case .defaultAnyTypeUrlprefix: return 192 - case .defaultValue: return 193 - case .dependency: return 194 - case .deprecated: return 195 - case .description_: return 196 - case .descriptorProto: return 197 - case .dictionary: return 198 - case .dictionaryLiteral: return 199 - case .digit: return 200 - case .digit0: return 201 - case .digit1: return 202 - case .digitCount: return 203 - case .digits: return 204 - case .digitValue: return 205 - case .discardableResult: return 206 - case .discardUnknownFields: return 207 - case .distance: return 208 - case .double: return 209 - case .doubleValue: return 210 - case .duration: return 211 - case .e: return 212 - case .element: return 213 - case .elements: return 214 - case .emitExtensionFieldName: return 215 - case .emitFieldName: return 216 - case .emitFieldNumber: return 217 - case .empty: return 218 - case .emptyData: return 219 - case .encodeAsBytes: return 220 - case .encoded: return 221 - case .encodedJsonstring: return 222 - case .encodedSize: return 223 - case .encodeField: return 224 - case .encoder: return 225 - case .end: return 226 - case .endArray: return 227 - case .endMessageField: return 228 - case .endObject: return 229 - case .endRegularField: return 230 - case .enum: return 231 - case .enumDescriptorProto: return 232 - case .enumOptions: return 233 - case .enumReservedRange: return 234 - case .enumType: return 235 - case .enumvalue: return 236 - case .enumValueDescriptorProto: return 237 - case .enumValueOptions: return 238 - case .equatable: return 239 - case .error: return 240 - case .expressibleByArrayLiteral: return 241 - case .expressibleByDictionaryLiteral: return 242 - case .ext: return 243 - case .extDecoder: return 244 - case .extendedGraphemeClusterLiteral: return 245 - case .extendedGraphemeClusterLiteralType: return 246 - case .extendee: return 247 - case .extensibleMessage: return 248 - case .extension: return 249 - case .extensionField: return 250 - case .extensionFieldNumber: return 251 - case .extensionFieldValueSet: return 252 - case .extensionMap: return 253 - case .extensionRange: return 254 - case .extensionRangeOptions: return 255 - case .extensions: return 256 - case .extras: return 257 - case .f: return 258 - case .false: return 259 - case .field: return 260 - case .fieldData: return 261 - case .fieldDescriptorProto: return 262 - case .fieldMask: return 263 - case .fieldName: return 264 - case .fieldNameCount: return 265 - case .fieldNum: return 266 - case .fieldNumber: return 267 - case .fieldNumberForProto: return 268 - case .fieldOptions: return 269 - case .fields: return 270 - case .fieldSize: return 271 - case .fieldTag: return 272 - case .fieldType: return 273 - case .file: return 274 - case .fileDescriptorProto: return 275 - case .fileDescriptorSet: return 276 - case .fileName: return 277 - case .fileOptions: return 278 - case .filter: return 279 - case .first: return 280 - case .firstItem: return 281 - case .float: return 282 - case .floatLiteral: return 283 - case .floatLiteralType: return 284 - case .floatValue: return 285 - case .forMessageName: return 286 - case .formUnion: return 287 - case .forReadingFrom: return 288 - case .forTypeURL: return 289 - case .forwardParser: return 290 - case .forWritingInto: return 291 - case .from: return 292 - case .fromAscii2: return 293 - case .fromAscii4: return 294 - case .fromByteOffset: return 295 - case .fromHexDigit: return 296 - case .func: return 297 - case .g: return 298 - case .generatedCodeInfo: return 299 - case .get: return 300 - case .getExtensionValue: return 301 - case .googleapis: return 302 - case .googleProtobufAny: return 303 - case .googleProtobufApi: return 304 - case .googleProtobufBoolValue: return 305 - case .googleProtobufBytesValue: return 306 - case .googleProtobufDescriptorProto: return 307 - case .googleProtobufDoubleValue: return 308 - case .googleProtobufDuration: return 309 - case .googleProtobufEmpty: return 310 - case .googleProtobufEnum: return 311 - case .googleProtobufEnumDescriptorProto: return 312 - case .googleProtobufEnumOptions: return 313 - case .googleProtobufEnumValue: return 314 - case .googleProtobufEnumValueDescriptorProto: return 315 - case .googleProtobufEnumValueOptions: return 316 - case .googleProtobufExtensionRangeOptions: return 317 - case .googleProtobufField: return 318 - case .googleProtobufFieldDescriptorProto: return 319 - case .googleProtobufFieldMask: return 320 - case .googleProtobufFieldOptions: return 321 - case .googleProtobufFileDescriptorProto: return 322 - case .googleProtobufFileDescriptorSet: return 323 - case .googleProtobufFileOptions: return 324 - case .googleProtobufFloatValue: return 325 - case .googleProtobufGeneratedCodeInfo: return 326 - case .googleProtobufInt32Value: return 327 - case .googleProtobufInt64Value: return 328 - case .googleProtobufListValue: return 329 - case .googleProtobufMessageOptions: return 330 - case .googleProtobufMethod: return 331 - case .googleProtobufMethodDescriptorProto: return 332 - case .googleProtobufMethodOptions: return 333 - case .googleProtobufMixin: return 334 - case .googleProtobufNullValue: return 335 - case .googleProtobufOneofDescriptorProto: return 336 - case .googleProtobufOneofOptions: return 337 - case .googleProtobufOption: return 338 - case .googleProtobufServiceDescriptorProto: return 339 - case .googleProtobufServiceOptions: return 340 - case .googleProtobufSourceCodeInfo: return 341 - case .googleProtobufSourceContext: return 342 - case .googleProtobufStringValue: return 343 - case .googleProtobufStruct: return 344 - case .googleProtobufSyntax: return 345 - case .googleProtobufTimestamp: return 346 - case .googleProtobufType: return 347 - case .googleProtobufUint32Value: return 348 - case .googleProtobufUint64Value: return 349 - case .googleProtobufUninterpretedOption: return 350 - case .googleProtobufValue: return 351 - case .goPackage: return 352 - case .group: return 353 - case .groupFieldNumberStack: return 354 - case .groupSize: return 355 - case .h: return 356 - case .hadOneofValue: return 357 - case .handleConflictingOneOf: return 358 - case .hasAggregateValue: return 359 - case .hasAllowAlias: return 360 - case .hasBegin: return 361 - case .hasCcEnableArenas: return 362 - case .hasCcGenericServices: return 363 - case .hasClientStreaming: return 364 - case .hasCsharpNamespace: return 365 - case .hasCtype: return 366 - case .hasDefaultValue: return 367 - case .hasDeprecated: return 368 - case .hasDoubleValue: return 369 - case .hasEnd: return 370 - case .hasExtendee: return 371 - case .hasExtensionValue: return 372 - case .hasGoPackage: return 373 - case .hash: return 374 - case .hashable: return 375 - case .hasher: return 376 - case .hashValue_: return 377 - case .hashVisitor: return 378 - case .hasIdempotencyLevel: return 379 - case .hasIdentifierValue: return 380 - case .hasInputType: return 381 - case .hasIsExtension: return 382 - case .hasJavaGenerateEqualsAndHash: return 383 - case .hasJavaGenericServices: return 384 - case .hasJavaMultipleFiles: return 385 - case .hasJavaOuterClassname: return 386 - case .hasJavaPackage: return 387 - case .hasJavaStringCheckUtf8: return 388 - case .hasJsonName: return 389 - case .hasJstype: return 390 - case .hasLabel: return 391 - case .hasLazy: return 392 - case .hasLeadingComments: return 393 - case .hasMapEntry: return 394 - case .hasMessageSetWireFormat: return 395 - case .hasName: return 396 - case .hasNamePart: return 397 - case .hasNegativeIntValue: return 398 - case .hasNoStandardDescriptorAccessor: return 399 - case .hasNumber: return 400 - case .hasObjcClassPrefix: return 401 - case .hasOneofIndex: return 402 - case .hasOptimizeFor: return 403 - case .hasOptions: return 404 - case .hasOutputType: return 405 - case .hasPackage: return 406 - case .hasPacked: return 407 - case .hasPhpClassPrefix: return 408 - case .hasPhpGenericServices: return 409 - case .hasPhpMetadataNamespace: return 410 - case .hasPhpNamespace: return 411 - case .hasPositiveIntValue: return 412 - case .hasProto3Optional: return 413 - case .hasPyGenericServices: return 414 - case .hasRubyPackage: return 415 - case .hasServerStreaming: return 416 - case .hasSourceCodeInfo: return 417 - case .hasSourceContext: return 418 - case .hasSourceFile: return 419 - case .hasStart: return 420 - case .hasStringValue: return 421 - case .hasSwiftPrefix: return 422 - case .hasSyntax: return 423 - case .hasTrailingComments: return 424 - case .hasType: return 425 - case .hasTypeName: return 426 - case .hasValue: return 427 - case .hasWeak: return 428 - case .hour: return 429 - case .i: return 430 - case .idempotencyLevel: return 431 - case .identifierValue: return 432 - case .if: return 433 - case .ignoreUnknownFields: return 434 - case .index: return 435 - case .init_: return 436 - case .inout: return 437 - case .inputType: return 438 - case .insert: return 439 - case .int: return 440 - case .int32: return 441 - case .int32Value: return 442 - case .int64: return 443 - case .int64Value: return 444 - case .int8: return 445 - case .integerLiteral: return 446 - case .integerLiteralType: return 447 - case .intern: return 448 - case .internal: return 449 - case .internalState: return 450 - case .into: return 451 - case .ints: return 452 - case .isA: return 453 - case .isEqual: return 454 - case .isEqualTo: return 455 - case .isExtension: return 456 - case .isInitialized: return 457 - case .itemTagsEncodedSize: return 458 - case .iterator: return 459 - case .i2166136261: return 460 - case .javaGenerateEqualsAndHash: return 461 - case .javaGenericServices: return 462 - case .javaMultipleFiles: return 463 - case .javaOuterClassname: return 464 - case .javaPackage: return 465 - case .javaStringCheckUtf8: return 466 - case .jsondecoder: return 467 - case .jsondecodingError: return 468 - case .jsondecodingOptions: return 469 - case .jsonEncoder: return 470 - case .jsonencodingError: return 471 - case .jsonencodingOptions: return 472 - case .jsonencodingVisitor: return 473 - case .jsonmapEncodingVisitor: return 474 - case .jsonName: return 475 - case .jsonPath: return 476 - case .jsonPaths: return 477 - case .jsonscanner: return 478 - case .jsonString: return 479 - case .jsonText: return 480 - case .jsonUtf8Data: return 481 - case .jstype: return 482 - case .k: return 483 - case .key: return 484 - case .keyField: return 485 - case .keyType: return 486 - case .kind: return 487 - case .l: return 488 - case .label: return 489 - case .lazy: return 490 - case .leadingComments: return 491 - case .leadingDetachedComments: return 492 - case .length: return 493 - case .lessThan: return 494 - case .let: return 495 - case .lhs: return 496 - case .list: return 497 - case .listOfMessages: return 498 - case .listValue: return 499 + case .addPath: return 1 + case .adjusted: return 2 + case .aggregateValue: return 3 + case .allCases_: return 4 + case .allowAlias: return 5 + case .alwaysPrintEnumsAsInts: return 6 + case .alwaysPrintInt64SAsNumbers: return 7 + case .annotation: return 8 + case .any: return 9 + case .anyExtensionField: return 10 + case .anyMessageExtension: return 11 + case .anyMessageStorage: return 12 + case .anyUnpackError: return 13 + case .append: return 14 + case .appended: return 15 + case .appendUintHex: return 16 + case .appendUnknown: return 17 + case .areAllInitialized: return 18 + case .array: return 19 + case .arrayDepth: return 20 + case .arrayLiteral: return 21 + case .arraySeparator: return 22 + case .as: return 23 + case .asciiOpenCurlyBracket: return 24 + case .asciiZero: return 25 + case .async: return 26 + case .asyncIterator: return 27 + case .asyncIteratorProtocol: return 28 + case .asyncMessageSequence: return 29 + case .available: return 30 + case .b: return 31 + case .base: return 32 + case .base64Values: return 33 + case .baseAddress: return 34 + case .baseType: return 35 + case .begin: return 36 + case .binary: return 37 + case .binaryDecoder: return 38 + case .binaryDecoding: return 39 + case .binaryDecodingError: return 40 + case .binaryDecodingOptions: return 41 + case .binaryDelimited: return 42 + case .binaryEncoder: return 43 + case .binaryEncodingError: return 44 + case .binaryEncodingMessageSetSizeVisitor: return 45 + case .binaryEncodingMessageSetVisitor: return 46 + case .binaryEncodingOptions: return 47 + case .binaryEncodingSizeVisitor: return 48 + case .binaryEncodingVisitor: return 49 + case .binaryOptions: return 50 + case .binaryProtobufDelimitedMessages: return 51 + case .binaryStreamDecoding: return 52 + case .binaryStreamDecodingError: return 53 + case .bitPattern: return 54 + case .body: return 55 + case .bool: return 56 + case .booleanLiteral: return 57 + case .booleanLiteralType: return 58 + case .boolValue: return 59 + case .buffer: return 60 + case .byte: return 61 + case .bytecode: return 62 + case .bytecodeReader: return 63 + case .bytes: return 64 + case .bytesInGroup: return 65 + case .bytesNeeded: return 66 + case .bytesRead: return 67 + case .c: return 68 + case .canonical: return 69 + case .capitalizeNext: return 70 + case .cardinality: return 71 + case .caseIterable: return 72 + case .castedValue: return 73 + case .ccEnableArenas: return 74 + case .ccGenericServices: return 75 + case .character: return 76 + case .chars: return 77 + case .checkProgramFormat: return 78 + case .chunk: return 79 + case .class: return 80 + case .clearAggregateValue: return 81 + case .clearAllowAlias: return 82 + case .clearBegin: return 83 + case .clearCcEnableArenas: return 84 + case .clearCcGenericServices: return 85 + case .clearClientStreaming: return 86 + case .clearCsharpNamespace: return 87 + case .clearCtype: return 88 + case .clearDebugRedact: return 89 + case .clearDefaultSymbolVisibility: return 90 + case .clearDefaultValue: return 91 + case .clearDeprecated: return 92 + case .clearDeprecatedLegacyJsonFieldConflicts: return 93 + case .clearDeprecationWarning: return 94 + case .clearDoubleValue: return 95 + case .clearEdition: return 96 + case .clearEditionDeprecated: return 97 + case .clearEditionIntroduced: return 98 + case .clearEditionRemoved: return 99 + case .clearEnd: return 100 + case .clearEnforceNamingStyle: return 101 + case .clearEnumType: return 102 + case .clearExtendee: return 103 + case .clearExtensionValue: return 104 + case .clearFeatures: return 105 + case .clearFeatureSupport: return 106 + case .clearFieldPresence: return 107 + case .clearFixedFeatures: return 108 + case .clearFullName: return 109 + case .clearGoPackage: return 110 + case .clearIdempotencyLevel: return 111 + case .clearIdentifierValue: return 112 + case .clearInputType: return 113 + case .clearIsExtension: return 114 + case .clearJavaGenerateEqualsAndHash: return 115 + case .clearJavaGenericServices: return 116 + case .clearJavaMultipleFiles: return 117 + case .clearJavaOuterClassname: return 118 + case .clearJavaPackage: return 119 + case .clearJavaStringCheckUtf8: return 120 + case .clearJsonFormat: return 121 + case .clearJsonName: return 122 + case .clearJstype: return 123 + case .clearLabel: return 124 + case .clearLazy: return 125 + case .clearLeadingComments: return 126 + case .clearMapEntry: return 127 + case .clearMaximumEdition: return 128 + case .clearMessageEncoding: return 129 + case .clearMessageSetWireFormat: return 130 + case .clearMinimumEdition: return 131 + case .clearName: return 132 + case .clearNamePart: return 133 + case .clearNegativeIntValue: return 134 + case .clearNoStandardDescriptorAccessor: return 135 + case .clearNumber: return 136 + case .clearObjcClassPrefix: return 137 + case .clearOneofIndex: return 138 + case .clearOptimizeFor: return 139 + case .clearOptions: return 140 + case .clearOutputType: return 141 + case .clearOverridableFeatures: return 142 + case .clearPackage: return 143 + case .clearPacked: return 144 + case .clearPhpClassPrefix: return 145 + case .clearPhpMetadataNamespace: return 146 + case .clearPhpNamespace: return 147 + case .clearPositiveIntValue: return 148 + case .clearProto3Optional: return 149 + case .clearPyGenericServices: return 150 + case .clearRemovalError: return 151 + case .clearRepeated: return 152 + case .clearRepeatedFieldEncoding: return 153 + case .clearReserved: return 154 + case .clearRetention: return 155 + case .clearRubyPackage: return 156 + case .clearSemantic: return 157 + case .clearServerStreaming: return 158 + case .clearSourceCodeInfo: return 159 + case .clearSourceContext: return 160 + case .clearSourceFile: return 161 + case .clearStart: return 162 + case .clearStringValue: return 163 + case .clearSwiftPrefix: return 164 + case .clearSyntax: return 165 + case .clearTrailingComments: return 166 + case .clearType: return 167 + case .clearTypeName: return 168 + case .clearUnverifiedLazy: return 169 + case .clearUtf8Validation: return 170 + case .clearValue: return 171 + case .clearVerification: return 172 + case .clearVisibility: return 173 + case .clearWeak: return 174 + case .clientStreaming: return 175 + case .code: return 176 + case .codePoint: return 177 + case .codeUnits: return 178 + case .collection: return 179 + case .comma: return 180 + case .consumedBytes: return 181 + case .contains: return 182 + case .contentsOf: return 183 + case .contiguousBytes: return 184 + case .copy: return 185 + case .count: return 186 + case .countVarintsInBuffer: return 187 + case .csharpNamespace: return 188 + case .ctype: return 189 + case .customCodable: return 190 + case .customDebugStringConvertible: return 191 + case .customStringConvertible: return 192 + case .d: return 193 + case .data: return 194 + case .dataResult: return 195 + case .date: return 196 + case .daySec: return 197 + case .daysSinceEpoch: return 198 + case .debugDescription_: return 199 + case .debugRedact: return 200 + case .declaration: return 201 + case .decoded: return 202 + case .decodedFromJsonnull: return 203 + case .decodeExtensionField: return 204 + case .decodeExtensionFieldsAsMessageSet: return 205 + case .decodeJson: return 206 + case .decodeMapField: return 207 + case .decodeMessage: return 208 + case .decoder: return 209 + case .decodeRepeated: return 210 + case .decodeRepeatedBoolField: return 211 + case .decodeRepeatedBytesField: return 212 + case .decodeRepeatedDoubleField: return 213 + case .decodeRepeatedEnumField: return 214 + case .decodeRepeatedFixed32Field: return 215 + case .decodeRepeatedFixed64Field: return 216 + case .decodeRepeatedFloatField: return 217 + case .decodeRepeatedGroupField: return 218 + case .decodeRepeatedInt32Field: return 219 + case .decodeRepeatedInt64Field: return 220 + case .decodeRepeatedMessageField: return 221 + case .decodeRepeatedSfixed32Field: return 222 + case .decodeRepeatedSfixed64Field: return 223 + case .decodeRepeatedSint32Field: return 224 + case .decodeRepeatedSint64Field: return 225 + case .decodeRepeatedStringField: return 226 + case .decodeRepeatedUint32Field: return 227 + case .decodeRepeatedUint64Field: return 228 + case .decodeSingular: return 229 + case .decodeSingularBoolField: return 230 + case .decodeSingularBytesField: return 231 + case .decodeSingularDoubleField: return 232 + case .decodeSingularEnumField: return 233 + case .decodeSingularFixed32Field: return 234 + case .decodeSingularFixed64Field: return 235 + case .decodeSingularFloatField: return 236 + case .decodeSingularGroupField: return 237 + case .decodeSingularInt32Field: return 238 + case .decodeSingularInt64Field: return 239 + case .decodeSingularMessageField: return 240 + case .decodeSingularSfixed32Field: return 241 + case .decodeSingularSfixed64Field: return 242 + case .decodeSingularSint32Field: return 243 + case .decodeSingularSint64Field: return 244 + case .decodeSingularStringField: return 245 + case .decodeSingularUint32Field: return 246 + case .decodeSingularUint64Field: return 247 + case .decodeTextFormat: return 248 + case .defaultAnyTypeUrlprefix: return 249 + case .defaults: return 250 + case .defaultSymbolVisibility: return 251 + case .defaultValue: return 252 + case .dependency: return 253 + case .deprecated: return 254 + case .deprecatedLegacyJsonFieldConflicts: return 255 + case .deprecationWarning: return 256 + case .description_: return 257 + case .dictionary: return 258 + case .dictionaryLiteral: return 259 + case .digit: return 260 + case .digit0: return 261 + case .digit1: return 262 + case .digitCount: return 263 + case .digits: return 264 + case .digitValue: return 265 + case .discardableResult: return 266 + case .discardUnknownFields: return 267 + case .double: return 268 + case .doubleValue: return 269 + case .duration: return 270 + case .e: return 271 + case .edition: return 272 + case .editionDefault: return 273 + case .editionDefaults: return 274 + case .editionDeprecated: return 275 + case .editionIntroduced: return 276 + case .editionRemoved: return 277 + case .element: return 278 + case .elements: return 279 + case .else: return 280 + case .emitExtensionFieldName: return 281 + case .emitFieldName: return 282 + case .emitFieldNumber: return 283 + case .emptyAnyTypeURL: return 284 + case .emptyData: return 285 + case .encodeAsBytes: return 286 + case .encoded: return 287 + case .encodedJsonstring: return 288 + case .encodedSize: return 289 + case .encodeField: return 290 + case .encoder: return 291 + case .end: return 292 + case .endArray: return 293 + case .endMessageField: return 294 + case .endObject: return 295 + case .endRegularField: return 296 + case .enforceNamingStyle: return 297 + case .enum: return 298 + case .enumReservedRange: return 299 + case .enumType: return 300 + case .enumvalue: return 301 + case .equatable: return 302 + case .error: return 303 + case .execute: return 304 + case .expressibleByArrayLiteral: return 305 + case .expressibleByDictionaryLiteral: return 306 + case .ext: return 307 + case .extDecoder: return 308 + case .extendedGraphemeClusterLiteral: return 309 + case .extendedGraphemeClusterLiteralType: return 310 + case .extendee: return 311 + case .extensibleMessage: return 312 + case .extension: return 313 + case .extensionField: return 314 + case .extensionFieldNumber: return 315 + case .extensionFieldValueSet: return 316 + case .extensionMap: return 317 + case .extensionRange: return 318 + case .extensions: return 319 + case .extras: return 320 + case .f: return 321 + case .false: return 322 + case .features: return 323 + case .featureSetEditionDefault: return 324 + case .featureSupport: return 325 + case .field: return 326 + case .fieldData: return 327 + case .fieldMaskError: return 328 + case .fieldName: return 329 + case .fieldNameCount: return 330 + case .fieldNum: return 331 + case .fieldNumber: return 332 + case .fieldNumberForProto: return 333 + case .fieldPresence: return 334 + case .fields: return 335 + case .fieldSize: return 336 + case .fieldTag: return 337 + case .fieldType: return 338 + case .file: return 339 + case .fileName: return 340 + case .filter: return 341 + case .final: return 342 + case .finiteOnly: return 343 + case .first: return 344 + case .firstItem: return 345 + case .fixedFeatures: return 346 + case .float: return 347 + case .floatLiteral: return 348 + case .floatLiteralType: return 349 + case .for: return 350 + case .forMessageName: return 351 + case .formUnion: return 352 + case .forReadingFrom: return 353 + case .forTypeURL: return 354 + case .forwardParser: return 355 + case .forWritingInto: return 356 + case .from: return 357 + case .fromAscii2: return 358 + case .fromAscii4: return 359 + case .fromByteOffset: return 360 + case .fromHexDigit: return 361 + case .fullName: return 362 + case .func: return 363 + case .function: return 364 + case .g: return 365 + case .get: return 366 + case .getExtensionValue: return 367 + case .googleProtobufAny: return 368 + case .googleProtobufApi: return 369 + case .googleProtobufBoolValue: return 370 + case .googleProtobufBytesValue: return 371 + case .googleProtobufDescriptorProto: return 372 + case .googleProtobufDoubleValue: return 373 + case .googleProtobufDuration: return 374 + case .googleProtobufEdition: return 375 + case .googleProtobufEmpty: return 376 + case .googleProtobufEnum: return 377 + case .googleProtobufEnumDescriptorProto: return 378 + case .googleProtobufEnumOptions: return 379 + case .googleProtobufEnumValue: return 380 + case .googleProtobufEnumValueDescriptorProto: return 381 + case .googleProtobufEnumValueOptions: return 382 + case .googleProtobufExtensionRangeOptions: return 383 + case .googleProtobufFeatureSet: return 384 + case .googleProtobufFeatureSetDefaults: return 385 + case .googleProtobufField: return 386 + case .googleProtobufFieldDescriptorProto: return 387 + case .googleProtobufFieldMask: return 388 + case .googleProtobufFieldOptions: return 389 + case .googleProtobufFileDescriptorProto: return 390 + case .googleProtobufFileDescriptorSet: return 391 + case .googleProtobufFileOptions: return 392 + case .googleProtobufFloatValue: return 393 + case .googleProtobufGeneratedCodeInfo: return 394 + case .googleProtobufInt32Value: return 395 + case .googleProtobufInt64Value: return 396 + case .googleProtobufListValue: return 397 + case .googleProtobufMessageOptions: return 398 + case .googleProtobufMethod: return 399 + case .googleProtobufMethodDescriptorProto: return 400 + case .googleProtobufMethodOptions: return 401 + case .googleProtobufMixin: return 402 + case .googleProtobufNullValue: return 403 + case .googleProtobufOneofDescriptorProto: return 404 + case .googleProtobufOneofOptions: return 405 + case .googleProtobufOption: return 406 + case .googleProtobufServiceDescriptorProto: return 407 + case .googleProtobufServiceOptions: return 408 + case .googleProtobufSourceCodeInfo: return 409 + case .googleProtobufSourceContext: return 410 + case .googleProtobufStringValue: return 411 + case .googleProtobufStruct: return 412 + case .googleProtobufSymbolVisibility: return 413 + case .googleProtobufSyntax: return 414 + case .googleProtobufTimestamp: return 415 + case .googleProtobufType: return 416 + case .googleProtobufUint32Value: return 417 + case .googleProtobufUint64Value: return 418 + case .googleProtobufUninterpretedOption: return 419 + case .googleProtobufValue: return 420 + case .goPackage: return 421 + case .gotData: return 422 + case .group: return 423 + case .groupFieldNumberStack: return 424 + case .groupSize: return 425 + case .guard: return 426 + case .hadOneofValue: return 427 + case .handleConflictingOneOf: return 428 + case .handleInstruction: return 429 + case .hasAggregateValue: return 430 + case .hasAllowAlias: return 431 + case .hasBegin: return 432 + case .hasCcEnableArenas: return 433 + case .hasCcGenericServices: return 434 + case .hasClientStreaming: return 435 + case .hasCsharpNamespace: return 436 + case .hasCtype: return 437 + case .hasData: return 438 + case .hasDebugRedact: return 439 + case .hasDefaultSymbolVisibility: return 440 + case .hasDefaultValue: return 441 + case .hasDeprecated: return 442 + case .hasDeprecatedLegacyJsonFieldConflicts: return 443 + case .hasDeprecationWarning: return 444 + case .hasDoubleValue: return 445 + case .hasEdition: return 446 + case .hasEditionDeprecated: return 447 + case .hasEditionIntroduced: return 448 + case .hasEditionRemoved: return 449 + case .hasEnd: return 450 + case .hasEnforceNamingStyle: return 451 + case .hasEnumType: return 452 + case .hasExplicitDelta: return 453 + case .hasExtendee: return 454 + case .hasExtensionValue: return 455 + case .hasFeatures: return 456 + case .hasFeatureSupport: return 457 + case .hasFieldPresence: return 458 + case .hasFixedFeatures: return 459 + case .hasFullName: return 460 + case .hasGoPackage: return 461 + case .hash: return 462 + case .hashable: return 463 + case .hasher: return 464 + case .hashVisitor: return 465 + case .hasIdempotencyLevel: return 466 + case .hasIdentifierValue: return 467 + case .hasInputType: return 468 + case .hasIsExtension: return 469 + case .hasJavaGenerateEqualsAndHash: return 470 + case .hasJavaGenericServices: return 471 + case .hasJavaMultipleFiles: return 472 + case .hasJavaOuterClassname: return 473 + case .hasJavaPackage: return 474 + case .hasJavaStringCheckUtf8: return 475 + case .hasJsonFormat: return 476 + case .hasJsonName: return 477 + case .hasJstype: return 478 + case .hasLabel: return 479 + case .hasLazy: return 480 + case .hasLeadingComments: return 481 + case .hasMapEntry: return 482 + case .hasMaximumEdition: return 483 + case .hasMessageEncoding: return 484 + case .hasMessageSetWireFormat: return 485 + case .hasMinimumEdition: return 486 + case .hasName: return 487 + case .hasNamePart: return 488 + case .hasNegativeIntValue: return 489 + case .hasNoStandardDescriptorAccessor: return 490 + case .hasNumber: return 491 + case .hasObjcClassPrefix: return 492 + case .hasOneofIndex: return 493 + case .hasOptimizeFor: return 494 + case .hasOptions: return 495 + case .hasOutputType: return 496 + case .hasOverridableFeatures: return 497 + case .hasPackage: return 498 + case .hasPacked: return 499 default: break } switch self { - case .littleEndian: return 500 - case .littleEndianBytes: return 501 - case .load: return 502 - case .localHasher: return 503 - case .location: return 504 - case .m: return 505 - case .major: return 506 - case .makeIterator: return 507 - case .mapEntry: return 508 - case .mapHash: return 509 - case .mapKeyType: return 510 - case .mapNameResolver: return 511 - case .mapToMessages: return 512 - case .mapValueType: return 513 - case .mapVisitor: return 514 - case .mdayStart: return 515 - case .merge: return 516 - case .message: return 517 - case .messageDepthLimit: return 518 - case .messageExtension: return 519 - case .messageImplementationBase: return 520 - case .messageOptions: return 521 - case .messageSet: return 522 - case .messageSetWireFormat: return 523 - case .messageType: return 524 - case .method: return 525 - case .methodDescriptorProto: return 526 - case .methodOptions: return 527 - case .methods: return 528 - case .minor: return 529 - case .mixin: return 530 - case .mixins: return 531 - case .modifier: return 532 - case .modify: return 533 - case .month: return 534 - case .msgExtension: return 535 - case .mutating: return 536 - case .n: return 537 - case .name: return 538 - case .nameDescription: return 539 - case .nameMap: return 540 - case .namePart: return 541 - case .nameResolver: return 542 - case .names: return 543 - case .nanos: return 544 - case .nativeBytes: return 545 - case .nativeEndianBytes: return 546 - case .negativeIntValue: return 547 - case .nestedType: return 548 - case .newL: return 549 - case .newList: return 550 - case .newValue: return 551 - case .nextByte: return 552 - case .nextFieldNumber: return 553 - case .nil: return 554 - case .nilLiteral: return 555 - case .noStandardDescriptorAccessor: return 556 - case .nullValue: return 557 - case .number: return 558 - case .numberValue: return 559 - case .objcClassPrefix: return 560 - case .of: return 561 - case .oneofDecl: return 562 - case .oneofDescriptorProto: return 563 - case .oneofIndex: return 564 - case .oneofOptions: return 565 - case .oneofs: return 566 - case .oneOfKind: return 567 - case .optimizeFor: return 568 - case .optimizeMode: return 569 - case .option: return 570 - case .optionalEnumExtensionField: return 571 - case .optionalExtensionField: return 572 - case .optionalGroupExtensionField: return 573 - case .optionalMessageExtensionField: return 574 - case .options: return 575 - case .other: return 576 - case .others: return 577 - case .out: return 578 - case .outputType: return 579 - case .p: return 580 - case .package: return 581 - case .packed: return 582 - case .packedEnumExtensionField: return 583 - case .packedExtensionField: return 584 - case .padding: return 585 - case .parent: return 586 - case .parse: return 587 - case .partial: return 588 - case .path: return 589 - case .paths: return 590 - case .payload: return 591 - case .payloadSize: return 592 - case .phpClassPrefix: return 593 - case .phpGenericServices: return 594 - case .phpMetadataNamespace: return 595 - case .phpNamespace: return 596 - case .pointer: return 597 - case .pos: return 598 - case .positiveIntValue: return 599 - case .prefix: return 600 - case .preserveProtoFieldNames: return 601 - case .preTraverse: return 602 - case .printUnknownFields: return 603 - case .proto2: return 604 - case .proto3DefaultValue: return 605 - case .proto3Optional: return 606 - case .protobufApiversionCheck: return 607 - case .protobufApiversion2: return 608 - case .protobufBool: return 609 - case .protobufBytes: return 610 - case .protobufDouble: return 611 - case .protobufEnumMap: return 612 - case .protobufExtension: return 613 - case .protobufFixed32: return 614 - case .protobufFixed64: return 615 - case .protobufFloat: return 616 - case .protobufInt32: return 617 - case .protobufInt64: return 618 - case .protobufMap: return 619 - case .protobufMessageMap: return 620 - case .protobufSfixed32: return 621 - case .protobufSfixed64: return 622 - case .protobufSint32: return 623 - case .protobufSint64: return 624 - case .protobufString: return 625 - case .protobufUint32: return 626 - case .protobufUint64: return 627 - case .protobufExtensionFieldValues: return 628 - case .protobufFieldNumber: return 629 - case .protobufGeneratedIsEqualTo: return 630 - case .protobufNameMap: return 631 - case .protobufNewField: return 632 - case .protobufPackage: return 633 - case .protocol: return 634 - case .protoFieldName: return 635 - case .protoMessageName: return 636 - case .protoNameProviding: return 637 - case .protoPaths: return 638 - case .public: return 639 - case .publicDependency: return 640 - case .putBoolValue: return 641 - case .putBytesValue: return 642 - case .putDoubleValue: return 643 - case .putEnumValue: return 644 - case .putFixedUint32: return 645 - case .putFixedUint64: return 646 - case .putFloatValue: return 647 - case .putInt64: return 648 - case .putStringValue: return 649 - case .putUint64: return 650 - case .putUint64Hex: return 651 - case .putVarInt: return 652 - case .putZigZagVarInt: return 653 - case .pyGenericServices: return 654 - case .rawChars: return 655 - case .rawRepresentable: return 656 - case .rawValue_: return 657 - case .read4HexDigits: return 658 - case .register: return 659 - case .repeatedEnumExtensionField: return 660 - case .repeatedExtensionField: return 661 - case .repeatedGroupExtensionField: return 662 - case .repeatedMessageExtensionField: return 663 - case .requestStreaming: return 664 - case .requestTypeURL: return 665 - case .requiredSize: return 666 - case .reservedName: return 667 - case .reservedRange: return 668 - case .responseStreaming: return 669 - case .responseTypeURL: return 670 - case .result: return 671 - case .rethrows: return 672 - case .return: return 673 - case .returnType: return 674 - case .revision: return 675 - case .rhs: return 676 - case .root: return 677 - case .rubyPackage: return 678 - case .s: return 679 - case .sawBackslash: return 680 - case .sawSection4Characters: return 681 - case .sawSection5Characters: return 682 - case .scanner: return 683 - case .seconds: return 684 - case .self_: return 685 - case .separator: return 686 - case .serialize: return 687 - case .serializedData: return 688 - case .serializedSize: return 689 - case .serverStreaming: return 690 - case .service: return 691 - case .serviceDescriptorProto: return 692 - case .serviceOptions: return 693 - case .set: return 694 - case .setExtensionValue: return 695 - case .shift: return 696 - case .simpleExtensionMap: return 697 - case .sizer: return 698 - case .source: return 699 - case .sourceCodeInfo: return 700 - case .sourceContext: return 701 - case .sourceEncoding: return 702 - case .sourceFile: return 703 - case .span: return 704 - case .split: return 705 - case .start: return 706 - case .startArray: return 707 - case .startArrayObject: return 708 - case .startField: return 709 - case .startIndex: return 710 - case .startMessageField: return 711 - case .startObject: return 712 - case .startRegularField: return 713 - case .state: return 714 - case .static: return 715 - case .staticString: return 716 - case .storage: return 717 - case .string: return 718 - case .stringLiteral: return 719 - case .stringLiteralType: return 720 - case .stringResult: return 721 - case .stringValue: return 722 - case .struct: return 723 - case .structValue: return 724 - case .subDecoder: return 725 - case .subscript: return 726 - case .subVisitor: return 727 - case .swift: return 728 - case .swiftPrefix: return 729 - case .swiftProtobuf: return 730 - case .syntax: return 731 - case .t: return 732 - case .tag: return 733 - case .terminator: return 734 - case .testDecoder: return 735 - case .text: return 736 - case .textDecoder: return 737 - case .textFormatDecoder: return 738 - case .textFormatDecodingError: return 739 - case .textFormatDecodingOptions: return 740 - case .textFormatEncodingOptions: return 741 - case .textFormatEncodingVisitor: return 742 - case .textFormatString: return 743 - case .throws: return 744 - case .timeInterval: return 745 - case .timeIntervalSince1970: return 746 - case .timeIntervalSinceReferenceDate: return 747 - case .timestamp: return 748 - case .total: return 749 - case .totalArrayDepth: return 750 - case .totalSize: return 751 - case .trailingComments: return 752 - case .traverse: return 753 - case .true: return 754 - case .try: return 755 - case .type: return 756 - case .typealias: return 757 - case .typeEnum: return 758 - case .typeName: return 759 - case .typePrefix: return 760 - case .typeStart: return 761 - case .typeUnknown: return 762 - case .typeURL: return 763 - case .uint32: return 764 - case .uint32Value: return 765 - case .uint64: return 766 - case .uint64Value: return 767 - case .uint8: return 768 - case .unicodeScalarLiteral: return 769 - case .unicodeScalarLiteralType: return 770 - case .unicodeScalars: return 771 - case .unicodeScalarView: return 772 - case .uninterpretedOption: return 773 - case .union: return 774 - case .uniqueStorage: return 775 - case .unknown: return 776 - case .unknownFields: return 777 - case .unknownStorage: return 778 - case .unpackTo: return 779 - case .unsafeBufferPointer: return 780 - case .unsafeMutablePointer: return 781 - case .unsafeMutableRawBufferPointer: return 782 - case .unsafeMutableRawPointer: return 783 - case .unsafeRawBufferPointer: return 784 - case .unsafeRawPointer: return 785 - case .updatedOptions: return 786 - case .url: return 787 - case .utf8: return 788 - case .utf8Ptr: return 789 - case .utf8ToDouble: return 790 - case .utf8View: return 791 - case .v: return 792 - case .value: return 793 - case .valueField: return 794 - case .values: return 795 - case .valueType: return 796 - case .var: return 797 - case .version: return 798 - case .versionString: return 799 - case .visitExtensionFields: return 800 - case .visitExtensionFieldsAsMessageSet: return 801 - case .visitMapField: return 802 - case .visitor: return 803 - case .visitPacked: return 804 - case .visitPackedBoolField: return 805 - case .visitPackedDoubleField: return 806 - case .visitPackedEnumField: return 807 - case .visitPackedFixed32Field: return 808 - case .visitPackedFixed64Field: return 809 - case .visitPackedFloatField: return 810 - case .visitPackedInt32Field: return 811 - case .visitPackedInt64Field: return 812 - case .visitPackedSfixed32Field: return 813 - case .visitPackedSfixed64Field: return 814 - case .visitPackedSint32Field: return 815 - case .visitPackedSint64Field: return 816 - case .visitPackedUint32Field: return 817 - case .visitPackedUint64Field: return 818 - case .visitRepeated: return 819 - case .visitRepeatedBoolField: return 820 - case .visitRepeatedBytesField: return 821 - case .visitRepeatedDoubleField: return 822 - case .visitRepeatedEnumField: return 823 - case .visitRepeatedFixed32Field: return 824 - case .visitRepeatedFixed64Field: return 825 - case .visitRepeatedFloatField: return 826 - case .visitRepeatedGroupField: return 827 - case .visitRepeatedInt32Field: return 828 - case .visitRepeatedInt64Field: return 829 - case .visitRepeatedMessageField: return 830 - case .visitRepeatedSfixed32Field: return 831 - case .visitRepeatedSfixed64Field: return 832 - case .visitRepeatedSint32Field: return 833 - case .visitRepeatedSint64Field: return 834 - case .visitRepeatedStringField: return 835 - case .visitRepeatedUint32Field: return 836 - case .visitRepeatedUint64Field: return 837 - case .visitSingular: return 838 - case .visitSingularBoolField: return 839 - case .visitSingularBytesField: return 840 - case .visitSingularDoubleField: return 841 - case .visitSingularEnumField: return 842 - case .visitSingularFixed32Field: return 843 - case .visitSingularFixed64Field: return 844 - case .visitSingularFloatField: return 845 - case .visitSingularGroupField: return 846 - case .visitSingularInt32Field: return 847 - case .visitSingularInt64Field: return 848 - case .visitSingularMessageField: return 849 - case .visitSingularSfixed32Field: return 850 - case .visitSingularSfixed64Field: return 851 - case .visitSingularSint32Field: return 852 - case .visitSingularSint64Field: return 853 - case .visitSingularStringField: return 854 - case .visitSingularUint32Field: return 855 - case .visitSingularUint64Field: return 856 - case .visitUnknown: return 857 - case .wasDecoded: return 858 - case .weak: return 859 - case .weakDependency: return 860 - case .where: return 861 - case .wireFormat: return 862 - case .with: return 863 - case .withUnsafeBytes: return 864 - case .withUnsafeMutableBytes: return 865 - case .work: return 866 - case .wrappedType: return 867 - case .written: return 868 - case .yday: return 869 + case .hasPhpClassPrefix: return 500 + case .hasPhpMetadataNamespace: return 501 + case .hasPhpNamespace: return 502 + case .hasPositiveIntValue: return 503 + case .hasProto3Optional: return 504 + case .hasPyGenericServices: return 505 + case .hasRemovalError: return 506 + case .hasRepeated: return 507 + case .hasRepeatedFieldEncoding: return 508 + case .hasReserved: return 509 + case .hasRetention: return 510 + case .hasRubyPackage: return 511 + case .hasSemantic: return 512 + case .hasServerStreaming: return 513 + case .hasSourceCodeInfo: return 514 + case .hasSourceContext: return 515 + case .hasSourceFile: return 516 + case .hasStart: return 517 + case .hasStringValue: return 518 + case .hasSwiftPrefix: return 519 + case .hasSyntax: return 520 + case .hasTrailingComments: return 521 + case .hasType: return 522 + case .hasTypeName: return 523 + case .hasUnverifiedLazy: return 524 + case .hasUtf8Validation: return 525 + case .hasValue: return 526 + case .hasVerification: return 527 + case .hasVisibility: return 528 + case .hasWeak: return 529 + case .hour: return 530 + case .i: return 531 + case .idempotencyLevel: return 532 + case .identifierValue: return 533 + case .if: return 534 + case .ignoreUnknownExtensionFields: return 535 + case .ignoreUnknownFields: return 536 + case .index: return 537 + case .init_: return 538 + case .inout: return 539 + case .inputType: return 540 + case .insert: return 541 + case .instruction: return 542 + case .int: return 543 + case .int32: return 544 + case .int64: return 545 + case .int8: return 546 + case .integerLiteral: return 547 + case .integerLiteralType: return 548 + case .intern: return 549 + case .internal: return 550 + case .internalState: return 551 + case .intersect: return 552 + case .into: return 553 + case .ints: return 554 + case .invalidAnyTypeURL: return 555 + case .isA: return 556 + case .isEqual: return 557 + case .isEqualTo: return 558 + case .isExtension: return 559 + case .isInitialized: return 560 + case .isNegative: return 561 + case .isPathValid: return 562 + case .isReserved: return 563 + case .isValid: return 564 + case .itemTagsEncodedSize: return 565 + case .iterator: return 566 + case .javaGenerateEqualsAndHash: return 567 + case .javaGenericServices: return 568 + case .javaMultipleFiles: return 569 + case .javaOuterClassname: return 570 + case .javaPackage: return 571 + case .javaStringCheckUtf8: return 572 + case .jsondecoder: return 573 + case .jsondecoding: return 574 + case .jsondecodingError: return 575 + case .jsondecodingOptions: return 576 + case .jsonEncoder: return 577 + case .jsonencoding: return 578 + case .jsonencodingError: return 579 + case .jsonencodingOptions: return 580 + case .jsonencodingVisitor: return 581 + case .jsonFormat: return 582 + case .jsonmapEncodingVisitor: return 583 + case .jsonName: return 584 + case .jsonPath: return 585 + case .jsonPaths: return 586 + case .jsonscanner: return 587 + case .jsonString: return 588 + case .jsonText: return 589 + case .jsonUtf8Bytes: return 590 + case .jsonUtf8Data: return 591 + case .jstype: return 592 + case .k: return 593 + case .kChunkSize: return 594 + case .key: return 595 + case .keyField: return 596 + case .keyFieldOpt: return 597 + case .keyType: return 598 + case .kind: return 599 + case .l: return 600 + case .label: return 601 + case .lazy: return 602 + case .leadingComments: return 603 + case .leadingDetachedComments: return 604 + case .length: return 605 + case .lessThan: return 606 + case .let: return 607 + case .lhs: return 608 + case .line: return 609 + case .list: return 610 + case .listOfMessages: return 611 + case .listValue: return 612 + case .littleEndian: return 613 + case .load: return 614 + case .localHasher: return 615 + case .location: return 616 + case .m: return 617 + case .major: return 618 + case .makeAsyncIterator: return 619 + case .makeIterator: return 620 + case .malformedLength: return 621 + case .mapEntry: return 622 + case .mapKeyType: return 623 + case .mapToMessages: return 624 + case .mapValueType: return 625 + case .mapVisitor: return 626 + case .mask: return 627 + case .maximumEdition: return 628 + case .mdayStart: return 629 + case .merge: return 630 + case .mergeOptions: return 631 + case .message: return 632 + case .messageDepthLimit: return 633 + case .messageEncoding: return 634 + case .messageExtension: return 635 + case .messageImplementationBase: return 636 + case .messageSet: return 637 + case .messageSetWireFormat: return 638 + case .messageSize: return 639 + case .messageType: return 640 + case .method: return 641 + case .methods: return 642 + case .min: return 643 + case .minimumEdition: return 644 + case .minor: return 645 + case .mixins: return 646 + case .modify: return 647 + case .month: return 648 + case .msgExtension: return 649 + case .mutating: return 650 + case .n: return 651 + case .name: return 652 + case .nameDescription: return 653 + case .nameMap: return 654 + case .namePart: return 655 + case .names: return 656 + case .nanos: return 657 + case .negativeIntValue: return 658 + case .nestedType: return 659 + case .newExtensible: return 660 + case .newL: return 661 + case .newList: return 662 + case .newMessage: return 663 + case .newValue: return 664 + case .next: return 665 + case .nextByte: return 666 + case .nextFieldNumber: return 667 + case .nextInstruction: return 668 + case .nextInt32: return 669 + case .nextNullTerminatedString: return 670 + case .nextNullTerminatedStringArray: return 671 + case .nextNumber: return 672 + case .nextUint64: return 673 + case .nextVarInt: return 674 + case .nil: return 675 + case .nilLiteral: return 676 + case .noBytesAvailable: return 677 + case .noStandardDescriptorAccessor: return 678 + case .nullValue: return 679 + case .number: return 680 + case .numberValue: return 681 + case .objcClassPrefix: return 682 + case .of: return 683 + case .oneOfKind: return 684 + case .oneofDecl: return 685 + case .oneofIndex: return 686 + case .oneofs: return 687 + case .optimizeFor: return 688 + case .optimizeMode: return 689 + case .optionalEnumExtensionField: return 690 + case .optionalExtensionField: return 691 + case .optionalGroupExtensionField: return 692 + case .optionalMessageExtensionField: return 693 + case .optionDependency: return 694 + case .optionRetention: return 695 + case .options: return 696 + case .optionTargetType: return 697 + case .other: return 698 + case .others: return 699 + case .out: return 700 + case .outputType: return 701 + case .overridableFeatures: return 702 + case .p: return 703 + case .package: return 704 + case .packed: return 705 + case .packedEnumExtensionField: return 706 + case .packedExtensionField: return 707 + case .padding: return 708 + case .parent: return 709 + case .parse: return 710 + case .partial: return 711 + case .path: return 712 + case .pathDecoder: return 713 + case .pathDecodingError: return 714 + case .paths: return 715 + case .pathVisitor: return 716 + case .payload: return 717 + case .payloadSize: return 718 + case .phpClassPrefix: return 719 + case .phpMetadataNamespace: return 720 + case .phpNamespace: return 721 + case .pos: return 722 + case .positiveIntValue: return 723 + case .prefix: return 724 + case .preserveProtoFieldNames: return 725 + case .preTraverse: return 726 + case .previousNumber: return 727 + case .prevPath: return 728 + case .printUnknownFields: return 729 + case .programBuffer: return 730 + case .programFormat: return 731 + case .proto2: return 732 + case .proto3DefaultValue: return 733 + case .proto3Optional: return 734 + case .protobufExtensionFieldValues: return 735 + case .protobufFieldNumber: return 736 + case .protobufGeneratedIsEqualTo: return 737 + case .protobufNameMap: return 738 + case .protobufNewField: return 739 + case .protobufPackage: return 740 + case .protobufApiversion2: return 741 + case .protobufApiversionCheck: return 742 + case .protobufBool: return 743 + case .protobufBytes: return 744 + case .protobufData: return 745 + case .protobufDouble: return 746 + case .protobufEnumMap: return 747 + case .protobufExtension: return 748 + case .protobufFixed32: return 749 + case .protobufFixed64: return 750 + case .protobufFloat: return 751 + case .protobufInt32: return 752 + case .protobufInt64: return 753 + case .protobufMap: return 754 + case .protobufMessageMap: return 755 + case .protobufSfixed32: return 756 + case .protobufSfixed64: return 757 + case .protobufSint32: return 758 + case .protobufSint64: return 759 + case .protobufString: return 760 + case .protobufUint32: return 761 + case .protobufUint64: return 762 + case .protocol: return 763 + case .protoFieldName: return 764 + case .protoMessageName: return 765 + case .protoNameProviding: return 766 + case .protoPaths: return 767 + case .public: return 768 + case .publicDependency: return 769 + case .putBoolValue: return 770 + case .putBytesValue: return 771 + case .putDoubleValue: return 772 + case .putEnumValue: return 773 + case .putFixedUint32: return 774 + case .putFixedUint64: return 775 + case .putFloatValue: return 776 + case .putInt64: return 777 + case .putStringValue: return 778 + case .putUint64: return 779 + case .putUint64Hex: return 780 + case .putVarInt: return 781 + case .putZigZagVarInt: return 782 + case .pyGenericServices: return 783 + case .r: return 784 + case .rawChars: return 785 + case .rawRepresentable: return 786 + case .rawValue_: return 787 + case .read4HexDigits: return 788 + case .readBytes: return 789 + case .reader: return 790 + case .register: return 791 + case .remainingProgram: return 792 + case .removalError: return 793 + case .removingAllFieldsOf: return 794 + case .repeated: return 795 + case .repeatedEnumExtensionField: return 796 + case .repeatedExtensionField: return 797 + case .repeatedFieldEncoding: return 798 + case .repeatedGroupExtensionField: return 799 + case .repeatedMessageExtensionField: return 800 + case .repeating: return 801 + case .replaceRepeatedFields: return 802 + case .requestStreaming: return 803 + case .requestTypeURL: return 804 + case .requiredSize: return 805 + case .responseStreaming: return 806 + case .responseTypeURL: return 807 + case .result: return 808 + case .retention: return 809 + case .rethrows: return 810 + case .returnType: return 811 + case .revision: return 812 + case .rhs: return 813 + case .root: return 814 + case .rubyPackage: return 815 + case .s: return 816 + case .sawBackslash: return 817 + case .sawSection4Characters: return 818 + case .sawSection5Characters: return 819 + case .scalar: return 820 + case .scan: return 821 + case .scanner: return 822 + case .seconds: return 823 + case .self_: return 824 + case .semantic: return 825 + case .sendable: return 826 + case .separator: return 827 + case .serialize: return 828 + case .serializedBytes: return 829 + case .serializedData: return 830 + case .serializedSize: return 831 + case .serverStreaming: return 832 + case .service: return 833 + case .set: return 834 + case .setExtensionValue: return 835 + case .shift: return 836 + case .simpleExtensionMap: return 837 + case .size: return 838 + case .sizer: return 839 + case .source: return 840 + case .sourceCodeInfo: return 841 + case .sourceContext: return 842 + case .sourceEncoding: return 843 + case .sourceFile: return 844 + case .sourceLocation: return 845 + case .span: return 846 + case .split: return 847 + case .start: return 848 + case .startArray: return 849 + case .startArrayObject: return 850 + case .startField: return 851 + case .startIndex: return 852 + case .startMessageField: return 853 + case .startObject: return 854 + case .startRegularField: return 855 + case .state: return 856 + case .static: return 857 + case .staticString: return 858 + case .storage: return 859 + case .string: return 860 + case .stringLiteral: return 861 + case .stringLiteralType: return 862 + case .stringResult: return 863 + case .stringValue: return 864 + case .struct: return 865 + case .structValue: return 866 + case .subDecoder: return 867 + case .subscript: return 868 + case .subtract: return 869 + case .subVisitor: return 870 + case .swift: return 871 + case .swiftPrefix: return 872 + case .swiftProtobufContiguousBytes: return 873 + case .swiftProtobufError: return 874 + case .syntax: return 875 + case .t: return 876 + case .tag: return 877 + case .targets: return 878 + case .terminator: return 879 + case .testDecoder: return 880 + case .text: return 881 + case .textDecoder: return 882 + case .textFormatDecoder: return 883 + case .textFormatDecodingError: return 884 + case .textFormatDecodingOptions: return 885 + case .textFormatEncodingOptions: return 886 + case .textFormatEncodingVisitor: return 887 + case .textFormatString: return 888 + case .throwOrIgnore: return 889 + case .throws: return 890 + case .timeInterval: return 891 + case .timeIntervalSince1970: return 892 + case .timeIntervalSinceReferenceDate: return 893 + case .tmp: return 894 + case .tooLarge: return 895 + case .total: return 896 + case .totalArrayDepth: return 897 + case .totalSize: return 898 + case .trailingComments: return 899 + case .traverse: return 900 + case .trim: return 901 + case .true: return 902 + case .try: return 903 + case .type: return 904 + case .typealias: return 905 + case .typeEnum: return 906 + case .typeName: return 907 + case .typePrefix: return 908 + case .typeStart: return 909 + case .typeUnknown: return 910 + case .typeURL: return 911 + case .uint32: return 912 + case .uint64: return 913 + case .uint8: return 914 + case .unchecked: return 915 + case .unicode: return 916 + case .unicodeScalarLiteral: return 917 + case .unicodeScalarLiteralType: return 918 + case .unicodeScalars: return 919 + case .unicodeScalarView: return 920 + case .uninterpretedOption: return 921 + case .union: return 922 + case .uniqueStorage: return 923 + case .unknown: return 924 + case .unknownFields: return 925 + case .unknownStorage: return 926 + case .unpackTo: return 927 + case .unsafeBufferPointer: return 928 + case .unsafeMutablePointer: return 929 + case .unsafeMutableRawBufferPointer: return 930 + case .unsafeRawBufferPointer: return 931 + case .unsafeRawPointer: return 932 + case .unverifiedLazy: return 933 + case .updatedOptions: return 934 + case .uppercasedAssumingAscii: return 935 + case .url: return 936 + case .useDeterministicOrdering: return 937 + case .utf8: return 938 + case .utf8Ptr: return 939 + case .utf8ToDouble: return 940 + case .utf8Validation: return 941 + case .utf8View: return 942 + case .v: return 943 + case .value: return 944 + case .valueField: return 945 + case .values: return 946 + case .valueType: return 947 + case .var: return 948 + case .verification: return 949 + case .verificationState: return 950 + case .version: return 951 + case .versionString: return 952 + case .visibility: return 953 + case .visibilityFeature: return 954 + case .visitExtensionFields: return 955 + case .visitExtensionFieldsAsMessageSet: return 956 + case .visitMapField: return 957 + case .visitor: return 958 + case .visitPacked: return 959 + case .visitPackedBoolField: return 960 + case .visitPackedDoubleField: return 961 + case .visitPackedEnumField: return 962 + case .visitPackedFixed32Field: return 963 + case .visitPackedFixed64Field: return 964 + case .visitPackedFloatField: return 965 + case .visitPackedInt32Field: return 966 + case .visitPackedInt64Field: return 967 + case .visitPackedSfixed32Field: return 968 + case .visitPackedSfixed64Field: return 969 + case .visitPackedSint32Field: return 970 + case .visitPackedSint64Field: return 971 + case .visitPackedUint32Field: return 972 + case .visitPackedUint64Field: return 973 + case .visitRepeated: return 974 + case .visitRepeatedBoolField: return 975 + case .visitRepeatedBytesField: return 976 + case .visitRepeatedDoubleField: return 977 + case .visitRepeatedEnumField: return 978 + case .visitRepeatedFixed32Field: return 979 + case .visitRepeatedFixed64Field: return 980 + case .visitRepeatedFloatField: return 981 + case .visitRepeatedGroupField: return 982 + case .visitRepeatedInt32Field: return 983 + case .visitRepeatedInt64Field: return 984 + case .visitRepeatedMessageField: return 985 + case .visitRepeatedSfixed32Field: return 986 + case .visitRepeatedSfixed64Field: return 987 + case .visitRepeatedSint32Field: return 988 + case .visitRepeatedSint64Field: return 989 + case .visitRepeatedStringField: return 990 + case .visitRepeatedUint32Field: return 991 + case .visitRepeatedUint64Field: return 992 + case .visitSingular: return 993 + case .visitSingularBoolField: return 994 + case .visitSingularBytesField: return 995 + case .visitSingularDoubleField: return 996 + case .visitSingularEnumField: return 997 + case .visitSingularFixed32Field: return 998 + case .visitSingularFixed64Field: return 999 + default: break + } + switch self { + case .visitSingularFloatField: return 1000 + case .visitSingularGroupField: return 1001 + case .visitSingularInt32Field: return 1002 + case .visitSingularInt64Field: return 1003 + case .visitSingularMessageField: return 1004 + case .visitSingularSfixed32Field: return 1005 + case .visitSingularSfixed64Field: return 1006 + case .visitSingularSint32Field: return 1007 + case .visitSingularSint64Field: return 1008 + case .visitSingularStringField: return 1009 + case .visitSingularUint32Field: return 1010 + case .visitSingularUint64Field: return 1011 + case .visitUnknown: return 1012 + case .void: return 1013 + case .wasDecoded: return 1014 + case .weak: return 1015 + case .weakDependency: return 1016 + case .where: return 1017 + case .wireFormat: return 1018 + case .with: return 1019 + case .withUnsafeBytes: return 1020 + case .withUnsafeMutableBytes: return 1021 + case .work: return 1022 + case .wrapped: return 1023 + case .wrappedType: return 1024 + case .wrappedValue: return 1025 + case .written: return 1026 + case .yday: return 1027 case .UNRECOGNIZED(let i): return i default: break } @@ -2662,26 +3139,23 @@ enum ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: SwiftProtobuf.Enum { fatalError() } -} - -#if swift(>=4.2) - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnum] = [ + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum] = [ .none, + .addPath, .adjusted, .aggregateValue, .allCases_, .allowAlias, .alwaysPrintEnumsAsInts, + .alwaysPrintInt64SAsNumbers, .annotation, .any, .anyExtensionField, .anyMessageExtension, .anyMessageStorage, .anyUnpackError, - .api, + .append, .appended, .appendUintHex, .appendUnknown, @@ -2693,14 +3167,20 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .as, .asciiOpenCurlyBracket, .asciiZero, + .async, + .asyncIterator, + .asyncIteratorProtocol, + .asyncMessageSequence, .available, .b, + .base, .base64Values, .baseAddress, .baseType, .begin, .binary, .binaryDecoder, + .binaryDecoding, .binaryDecodingError, .binaryDecodingOptions, .binaryDelimited, @@ -2708,25 +3188,39 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .binaryEncodingError, .binaryEncodingMessageSetSizeVisitor, .binaryEncodingMessageSetVisitor, + .binaryEncodingOptions, .binaryEncodingSizeVisitor, .binaryEncodingVisitor, .binaryOptions, + .binaryProtobufDelimitedMessages, + .binaryStreamDecoding, + .binaryStreamDecodingError, + .bitPattern, .body, .bool, .booleanLiteral, .booleanLiteralType, .boolValue, + .buffer, + .byte, + .bytecode, + .bytecodeReader, .bytes, .bytesInGroup, + .bytesNeeded, .bytesRead, - .bytesValue, .c, + .canonical, .capitalizeNext, .cardinality, + .caseIterable, + .castedValue, .ccEnableArenas, .ccGenericServices, .character, .chars, + .checkProgramFormat, + .chunk, .class, .clearAggregateValue, .clearAllowAlias, @@ -2736,12 +3230,27 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .clearClientStreaming, .clearCsharpNamespace, .clearCtype, + .clearDebugRedact, + .clearDefaultSymbolVisibility, .clearDefaultValue, .clearDeprecated, + .clearDeprecatedLegacyJsonFieldConflicts, + .clearDeprecationWarning, .clearDoubleValue, + .clearEdition, + .clearEditionDeprecated, + .clearEditionIntroduced, + .clearEditionRemoved, .clearEnd, + .clearEnforceNamingStyle, + .clearEnumType, .clearExtendee, .clearExtensionValue, + .clearFeatures, + .clearFeatureSupport, + .clearFieldPresence, + .clearFixedFeatures, + .clearFullName, .clearGoPackage, .clearIdempotencyLevel, .clearIdentifierValue, @@ -2753,13 +3262,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .clearJavaOuterClassname, .clearJavaPackage, .clearJavaStringCheckUtf8, + .clearJsonFormat, .clearJsonName, .clearJstype, .clearLabel, .clearLazy, .clearLeadingComments, .clearMapEntry, + .clearMaximumEdition, + .clearMessageEncoding, .clearMessageSetWireFormat, + .clearMinimumEdition, .clearName, .clearNamePart, .clearNegativeIntValue, @@ -2770,16 +3283,22 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .clearOptimizeFor, .clearOptions, .clearOutputType, + .clearOverridableFeatures, .clearPackage, .clearPacked, .clearPhpClassPrefix, - .clearPhpGenericServices, .clearPhpMetadataNamespace, .clearPhpNamespace, .clearPositiveIntValue, .clearProto3Optional, .clearPyGenericServices, + .clearRemovalError, + .clearRepeated, + .clearRepeatedFieldEncoding, + .clearReserved, + .clearRetention, .clearRubyPackage, + .clearSemantic, .clearServerStreaming, .clearSourceCodeInfo, .clearSourceContext, @@ -2791,22 +3310,30 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .clearTrailingComments, .clearType, .clearTypeName, + .clearUnverifiedLazy, + .clearUtf8Validation, .clearValue, + .clearVerification, + .clearVisibility, .clearWeak, .clientStreaming, + .code, .codePoint, .codeUnits, .collection, - .com, .comma, + .consumedBytes, + .contains, .contentsOf, .contiguousBytes, + .copy, .count, .countVarintsInBuffer, .csharpNamespace, .ctype, .customCodable, .customDebugStringConvertible, + .customStringConvertible, .d, .data, .dataResult, @@ -2814,6 +3341,8 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .daySec, .daysSinceEpoch, .debugDescription_, + .debugRedact, + .declaration, .decoded, .decodedFromJsonnull, .decodeExtensionField, @@ -2862,11 +3391,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .decodeSingularUint64Field, .decodeTextFormat, .defaultAnyTypeUrlprefix, + .defaults, + .defaultSymbolVisibility, .defaultValue, .dependency, .deprecated, + .deprecatedLegacyJsonFieldConflicts, + .deprecationWarning, .description_, - .descriptorProto, .dictionary, .dictionaryLiteral, .digit, @@ -2877,17 +3409,23 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .digitValue, .discardableResult, .discardUnknownFields, - .distance, .double, .doubleValue, .duration, .e, + .edition, + .editionDefault, + .editionDefaults, + .editionDeprecated, + .editionIntroduced, + .editionRemoved, .element, .elements, + .else, .emitExtensionFieldName, .emitFieldName, .emitFieldNumber, - .empty, + .emptyAnyTypeURL, .emptyData, .encodeAsBytes, .encoded, @@ -2900,16 +3438,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .endMessageField, .endObject, .endRegularField, + .enforceNamingStyle, .enum, - .enumDescriptorProto, - .enumOptions, .enumReservedRange, .enumType, .enumvalue, - .enumValueDescriptorProto, - .enumValueOptions, .equatable, .error, + .execute, .expressibleByArrayLiteral, .expressibleByDictionaryLiteral, .ext, @@ -2924,37 +3460,38 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .extensionFieldValueSet, .extensionMap, .extensionRange, - .extensionRangeOptions, .extensions, .extras, .f, .false, + .features, + .featureSetEditionDefault, + .featureSupport, .field, .fieldData, - .fieldDescriptorProto, - .fieldMask, + .fieldMaskError, .fieldName, .fieldNameCount, .fieldNum, .fieldNumber, .fieldNumberForProto, - .fieldOptions, + .fieldPresence, .fields, .fieldSize, .fieldTag, .fieldType, .file, - .fileDescriptorProto, - .fileDescriptorSet, .fileName, - .fileOptions, .filter, + .final, + .finiteOnly, .first, .firstItem, + .fixedFeatures, .float, .floatLiteral, .floatLiteralType, - .floatValue, + .for, .forMessageName, .formUnion, .forReadingFrom, @@ -2966,12 +3503,12 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .fromAscii4, .fromByteOffset, .fromHexDigit, + .fullName, .func, + .function, .g, - .generatedCodeInfo, .get, .getExtensionValue, - .googleapis, .googleProtobufAny, .googleProtobufApi, .googleProtobufBoolValue, @@ -2979,6 +3516,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .googleProtobufDescriptorProto, .googleProtobufDoubleValue, .googleProtobufDuration, + .googleProtobufEdition, .googleProtobufEmpty, .googleProtobufEnum, .googleProtobufEnumDescriptorProto, @@ -2987,6 +3525,8 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .googleProtobufEnumValueDescriptorProto, .googleProtobufEnumValueOptions, .googleProtobufExtensionRangeOptions, + .googleProtobufFeatureSet, + .googleProtobufFeatureSetDefaults, .googleProtobufField, .googleProtobufFieldDescriptorProto, .googleProtobufFieldMask, @@ -3014,6 +3554,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .googleProtobufSourceContext, .googleProtobufStringValue, .googleProtobufStruct, + .googleProtobufSymbolVisibility, .googleProtobufSyntax, .googleProtobufTimestamp, .googleProtobufType, @@ -3022,12 +3563,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .googleProtobufUninterpretedOption, .googleProtobufValue, .goPackage, + .gotData, .group, .groupFieldNumberStack, .groupSize, - .h, + .guard, .hadOneofValue, .handleConflictingOneOf, + .handleInstruction, .hasAggregateValue, .hasAllowAlias, .hasBegin, @@ -3036,17 +3579,33 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .hasClientStreaming, .hasCsharpNamespace, .hasCtype, + .hasData, + .hasDebugRedact, + .hasDefaultSymbolVisibility, .hasDefaultValue, .hasDeprecated, + .hasDeprecatedLegacyJsonFieldConflicts, + .hasDeprecationWarning, .hasDoubleValue, + .hasEdition, + .hasEditionDeprecated, + .hasEditionIntroduced, + .hasEditionRemoved, .hasEnd, + .hasEnforceNamingStyle, + .hasEnumType, + .hasExplicitDelta, .hasExtendee, .hasExtensionValue, + .hasFeatures, + .hasFeatureSupport, + .hasFieldPresence, + .hasFixedFeatures, + .hasFullName, .hasGoPackage, .hash, .hashable, .hasher, - .hashValue_, .hashVisitor, .hasIdempotencyLevel, .hasIdentifierValue, @@ -3058,13 +3617,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .hasJavaOuterClassname, .hasJavaPackage, .hasJavaStringCheckUtf8, + .hasJsonFormat, .hasJsonName, .hasJstype, .hasLabel, .hasLazy, .hasLeadingComments, .hasMapEntry, + .hasMaximumEdition, + .hasMessageEncoding, .hasMessageSetWireFormat, + .hasMinimumEdition, .hasName, .hasNamePart, .hasNegativeIntValue, @@ -3075,16 +3638,22 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .hasOptimizeFor, .hasOptions, .hasOutputType, + .hasOverridableFeatures, .hasPackage, .hasPacked, .hasPhpClassPrefix, - .hasPhpGenericServices, .hasPhpMetadataNamespace, .hasPhpNamespace, .hasPositiveIntValue, .hasProto3Optional, .hasPyGenericServices, + .hasRemovalError, + .hasRepeated, + .hasRepeatedFieldEncoding, + .hasReserved, + .hasRetention, .hasRubyPackage, + .hasSemantic, .hasServerStreaming, .hasSourceCodeInfo, .hasSourceContext, @@ -3096,40 +3665,49 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .hasTrailingComments, .hasType, .hasTypeName, + .hasUnverifiedLazy, + .hasUtf8Validation, .hasValue, + .hasVerification, + .hasVisibility, .hasWeak, .hour, .i, .idempotencyLevel, .identifierValue, .if, + .ignoreUnknownExtensionFields, .ignoreUnknownFields, .index, .init_, .inout, .inputType, .insert, + .instruction, .int, .int32, - .int32Value, .int64, - .int64Value, .int8, .integerLiteral, .integerLiteralType, .intern, .internal, .internalState, + .intersect, .into, .ints, + .invalidAnyTypeURL, .isA, .isEqual, .isEqualTo, .isExtension, .isInitialized, + .isNegative, + .isPathValid, + .isReserved, + .isValid, .itemTagsEncodedSize, .iterator, - .i2166136261, .javaGenerateEqualsAndHash, .javaGenericServices, .javaMultipleFiles, @@ -3137,12 +3715,15 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .javaPackage, .javaStringCheckUtf8, .jsondecoder, + .jsondecoding, .jsondecodingError, .jsondecodingOptions, .jsonEncoder, + .jsonencoding, .jsonencodingError, .jsonencodingOptions, .jsonencodingVisitor, + .jsonFormat, .jsonmapEncodingVisitor, .jsonName, .jsonPath, @@ -3150,11 +3731,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .jsonscanner, .jsonString, .jsonText, + .jsonUtf8Bytes, .jsonUtf8Data, .jstype, .k, + .kChunkSize, .key, .keyField, + .keyFieldOpt, .keyType, .kind, .l, @@ -3166,42 +3750,44 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .lessThan, .let, .lhs, + .line, .list, .listOfMessages, .listValue, .littleEndian, - .littleEndianBytes, .load, .localHasher, .location, .m, .major, + .makeAsyncIterator, .makeIterator, + .malformedLength, .mapEntry, - .mapHash, .mapKeyType, - .mapNameResolver, .mapToMessages, .mapValueType, .mapVisitor, + .mask, + .maximumEdition, .mdayStart, .merge, + .mergeOptions, .message, .messageDepthLimit, + .messageEncoding, .messageExtension, .messageImplementationBase, - .messageOptions, .messageSet, .messageSetWireFormat, + .messageSize, .messageType, .method, - .methodDescriptorProto, - .methodOptions, .methods, + .min, + .minimumEdition, .minor, - .mixin, .mixins, - .modifier, .modify, .month, .msgExtension, @@ -3211,44 +3797,53 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .nameDescription, .nameMap, .namePart, - .nameResolver, .names, .nanos, - .nativeBytes, - .nativeEndianBytes, .negativeIntValue, .nestedType, + .newExtensible, .newL, .newList, + .newMessage, .newValue, + .next, .nextByte, .nextFieldNumber, + .nextInstruction, + .nextInt32, + .nextNullTerminatedString, + .nextNullTerminatedStringArray, + .nextNumber, + .nextUint64, + .nextVarInt, .nil, .nilLiteral, + .noBytesAvailable, .noStandardDescriptorAccessor, .nullValue, .number, .numberValue, .objcClassPrefix, .of, + .oneOfKind, .oneofDecl, - .oneofDescriptorProto, .oneofIndex, - .oneofOptions, .oneofs, - .oneOfKind, .optimizeFor, .optimizeMode, - .option, .optionalEnumExtensionField, .optionalExtensionField, .optionalGroupExtensionField, .optionalMessageExtensionField, + .optionDependency, + .optionRetention, .options, + .optionTargetType, .other, .others, .out, .outputType, + .overridableFeatures, .p, .package, .packed, @@ -3259,27 +3854,39 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .parse, .partial, .path, + .pathDecoder, + .pathDecodingError, .paths, + .pathVisitor, .payload, .payloadSize, .phpClassPrefix, - .phpGenericServices, .phpMetadataNamespace, .phpNamespace, - .pointer, .pos, .positiveIntValue, .prefix, .preserveProtoFieldNames, .preTraverse, + .previousNumber, + .prevPath, .printUnknownFields, + .programBuffer, + .programFormat, .proto2, .proto3DefaultValue, .proto3Optional, - .protobufApiversionCheck, + .protobufExtensionFieldValues, + .protobufFieldNumber, + .protobufGeneratedIsEqualTo, + .protobufNameMap, + .protobufNewField, + .protobufPackage, .protobufApiversion2, + .protobufApiversionCheck, .protobufBool, .protobufBytes, + .protobufData, .protobufDouble, .protobufEnumMap, .protobufExtension, @@ -3297,12 +3904,6 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .protobufString, .protobufUint32, .protobufUint64, - .protobufExtensionFieldValues, - .protobufFieldNumber, - .protobufGeneratedIsEqualTo, - .protobufNameMap, - .protobufNewField, - .protobufPackage, .protocol, .protoFieldName, .protoMessageName, @@ -3324,25 +3925,33 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .putVarInt, .putZigZagVarInt, .pyGenericServices, + .r, .rawChars, .rawRepresentable, .rawValue_, .read4HexDigits, + .readBytes, + .reader, .register, + .remainingProgram, + .removalError, + .removingAllFieldsOf, + .repeated, .repeatedEnumExtensionField, .repeatedExtensionField, + .repeatedFieldEncoding, .repeatedGroupExtensionField, .repeatedMessageExtensionField, + .repeating, + .replaceRepeatedFields, .requestStreaming, .requestTypeURL, .requiredSize, - .reservedName, - .reservedRange, .responseStreaming, .responseTypeURL, .result, + .retention, .rethrows, - .return, .returnType, .revision, .rhs, @@ -3352,27 +3961,32 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .sawBackslash, .sawSection4Characters, .sawSection5Characters, + .scalar, + .scan, .scanner, .seconds, .self_, + .semantic, + .sendable, .separator, .serialize, + .serializedBytes, .serializedData, .serializedSize, .serverStreaming, .service, - .serviceDescriptorProto, - .serviceOptions, .set, .setExtensionValue, .shift, .simpleExtensionMap, + .size, .sizer, .source, .sourceCodeInfo, .sourceContext, .sourceEncoding, .sourceFile, + .sourceLocation, .span, .split, .start, @@ -3396,13 +4010,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .structValue, .subDecoder, .subscript, + .subtract, .subVisitor, .swift, .swiftPrefix, - .swiftProtobuf, + .swiftProtobufContiguousBytes, + .swiftProtobufError, .syntax, .t, .tag, + .targets, .terminator, .testDecoder, .text, @@ -3413,16 +4030,19 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .textFormatEncodingOptions, .textFormatEncodingVisitor, .textFormatString, + .throwOrIgnore, .throws, .timeInterval, .timeIntervalSince1970, .timeIntervalSinceReferenceDate, - .timestamp, + .tmp, + .tooLarge, .total, .totalArrayDepth, .totalSize, .trailingComments, .traverse, + .trim, .true, .try, .type, @@ -3434,10 +4054,10 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .typeUnknown, .typeURL, .uint32, - .uint32Value, .uint64, - .uint64Value, .uint8, + .unchecked, + .unicode, .unicodeScalarLiteral, .unicodeScalarLiteralType, .unicodeScalars, @@ -3452,14 +4072,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .unsafeBufferPointer, .unsafeMutablePointer, .unsafeMutableRawBufferPointer, - .unsafeMutableRawPointer, .unsafeRawBufferPointer, .unsafeRawPointer, + .unverifiedLazy, .updatedOptions, + .uppercasedAssumingAscii, .url, + .useDeterministicOrdering, .utf8, .utf8Ptr, .utf8ToDouble, + .utf8Validation, .utf8View, .v, .value, @@ -3467,8 +4090,12 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .values, .valueType, .var, + .verification, + .verificationState, .version, .versionString, + .visibility, + .visibilityFeature, .visitExtensionFields, .visitExtensionFieldsAsMessageSet, .visitMapField, @@ -3527,6 +4154,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .visitSingularUint32Field, .visitSingularUint64Field, .visitUnknown, + .void, .wasDecoded, .weak, .weakDependency, @@ -3536,891 +4164,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: CaseIterable { .withUnsafeBytes, .withUnsafeMutableBytes, .work, + .wrapped, .wrappedType, + .wrappedValue, .written, .yday, ] -} -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) +} // MARK: - Code below here is support for the SwiftProtobuf runtime. -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE"), - 1: .same(proto: "adjusted"), - 2: .same(proto: "aggregateValue"), - 3: .same(proto: "allCases"), - 4: .same(proto: "allowAlias"), - 5: .same(proto: "alwaysPrintEnumsAsInts"), - 6: .same(proto: "annotation"), - 7: .same(proto: "any"), - 8: .same(proto: "AnyExtensionField"), - 9: .same(proto: "AnyMessageExtension"), - 10: .same(proto: "AnyMessageStorage"), - 11: .same(proto: "AnyUnpackError"), - 12: .same(proto: "Api"), - 13: .same(proto: "appended"), - 14: .same(proto: "appendUIntHex"), - 15: .same(proto: "appendUnknown"), - 16: .same(proto: "areAllInitialized"), - 17: .same(proto: "array"), - 18: .same(proto: "arrayDepth"), - 19: .same(proto: "arrayLiteral"), - 20: .same(proto: "arraySeparator"), - 21: .same(proto: "as"), - 22: .same(proto: "asciiOpenCurlyBracket"), - 23: .same(proto: "asciiZero"), - 24: .same(proto: "available"), - 25: .same(proto: "b"), - 26: .same(proto: "base64Values"), - 27: .same(proto: "baseAddress"), - 28: .same(proto: "BaseType"), - 29: .same(proto: "begin"), - 30: .same(proto: "binary"), - 31: .same(proto: "BinaryDecoder"), - 32: .same(proto: "BinaryDecodingError"), - 33: .same(proto: "BinaryDecodingOptions"), - 34: .same(proto: "BinaryDelimited"), - 35: .same(proto: "BinaryEncoder"), - 36: .same(proto: "BinaryEncodingError"), - 37: .same(proto: "BinaryEncodingMessageSetSizeVisitor"), - 38: .same(proto: "BinaryEncodingMessageSetVisitor"), - 39: .same(proto: "BinaryEncodingSizeVisitor"), - 40: .same(proto: "BinaryEncodingVisitor"), - 41: .same(proto: "binaryOptions"), - 42: .same(proto: "body"), - 43: .same(proto: "Bool"), - 44: .same(proto: "booleanLiteral"), - 45: .same(proto: "BooleanLiteralType"), - 46: .same(proto: "boolValue"), - 47: .same(proto: "bytes"), - 48: .same(proto: "bytesInGroup"), - 49: .same(proto: "bytesRead"), - 50: .same(proto: "BytesValue"), - 51: .same(proto: "c"), - 52: .same(proto: "capitalizeNext"), - 53: .same(proto: "cardinality"), - 54: .same(proto: "ccEnableArenas"), - 55: .same(proto: "ccGenericServices"), - 56: .same(proto: "Character"), - 57: .same(proto: "chars"), - 58: .same(proto: "class"), - 59: .same(proto: "clearAggregateValue"), - 60: .same(proto: "clearAllowAlias"), - 61: .same(proto: "clearBegin"), - 62: .same(proto: "clearCcEnableArenas"), - 63: .same(proto: "clearCcGenericServices"), - 64: .same(proto: "clearClientStreaming"), - 65: .same(proto: "clearCsharpNamespace"), - 66: .same(proto: "clearCtype"), - 67: .same(proto: "clearDefaultValue"), - 68: .same(proto: "clearDeprecated"), - 69: .same(proto: "clearDoubleValue"), - 70: .same(proto: "clearEnd"), - 71: .same(proto: "clearExtendee"), - 72: .same(proto: "clearExtensionValue"), - 73: .same(proto: "clearGoPackage"), - 74: .same(proto: "clearIdempotencyLevel"), - 75: .same(proto: "clearIdentifierValue"), - 76: .same(proto: "clearInputType"), - 77: .same(proto: "clearIsExtension"), - 78: .same(proto: "clearJavaGenerateEqualsAndHash"), - 79: .same(proto: "clearJavaGenericServices"), - 80: .same(proto: "clearJavaMultipleFiles"), - 81: .same(proto: "clearJavaOuterClassname"), - 82: .same(proto: "clearJavaPackage"), - 83: .same(proto: "clearJavaStringCheckUtf8"), - 84: .same(proto: "clearJsonName"), - 85: .same(proto: "clearJstype"), - 86: .same(proto: "clearLabel"), - 87: .same(proto: "clearLazy"), - 88: .same(proto: "clearLeadingComments"), - 89: .same(proto: "clearMapEntry"), - 90: .same(proto: "clearMessageSetWireFormat"), - 91: .same(proto: "clearName"), - 92: .same(proto: "clearNamePart"), - 93: .same(proto: "clearNegativeIntValue"), - 94: .same(proto: "clearNoStandardDescriptorAccessor"), - 95: .same(proto: "clearNumber"), - 96: .same(proto: "clearObjcClassPrefix"), - 97: .same(proto: "clearOneofIndex"), - 98: .same(proto: "clearOptimizeFor"), - 99: .same(proto: "clearOptions"), - 100: .same(proto: "clearOutputType"), - 101: .same(proto: "clearPackage"), - 102: .same(proto: "clearPacked"), - 103: .same(proto: "clearPhpClassPrefix"), - 104: .same(proto: "clearPhpGenericServices"), - 105: .same(proto: "clearPhpMetadataNamespace"), - 106: .same(proto: "clearPhpNamespace"), - 107: .same(proto: "clearPositiveIntValue"), - 108: .same(proto: "clearProto3Optional"), - 109: .same(proto: "clearPyGenericServices"), - 110: .same(proto: "clearRubyPackage"), - 111: .same(proto: "clearServerStreaming"), - 112: .same(proto: "clearSourceCodeInfo"), - 113: .same(proto: "clearSourceContext"), - 114: .same(proto: "clearSourceFile"), - 115: .same(proto: "clearStart"), - 116: .same(proto: "clearStringValue"), - 117: .same(proto: "clearSwiftPrefix"), - 118: .same(proto: "clearSyntax"), - 119: .same(proto: "clearTrailingComments"), - 120: .same(proto: "clearType"), - 121: .same(proto: "clearTypeName"), - 122: .same(proto: "clearValue"), - 123: .same(proto: "clearWeak"), - 124: .same(proto: "clientStreaming"), - 125: .same(proto: "codePoint"), - 126: .same(proto: "codeUnits"), - 127: .same(proto: "Collection"), - 128: .same(proto: "com"), - 129: .same(proto: "comma"), - 130: .same(proto: "contentsOf"), - 131: .same(proto: "ContiguousBytes"), - 132: .same(proto: "count"), - 133: .same(proto: "countVarintsInBuffer"), - 134: .same(proto: "csharpNamespace"), - 135: .same(proto: "ctype"), - 136: .same(proto: "customCodable"), - 137: .same(proto: "CustomDebugStringConvertible"), - 138: .same(proto: "d"), - 139: .same(proto: "Data"), - 140: .same(proto: "dataResult"), - 141: .same(proto: "date"), - 142: .same(proto: "daySec"), - 143: .same(proto: "daysSinceEpoch"), - 144: .same(proto: "debugDescription"), - 145: .same(proto: "decoded"), - 146: .same(proto: "decodedFromJSONNull"), - 147: .same(proto: "decodeExtensionField"), - 148: .same(proto: "decodeExtensionFieldsAsMessageSet"), - 149: .same(proto: "decodeJSON"), - 150: .same(proto: "decodeMapField"), - 151: .same(proto: "decodeMessage"), - 152: .same(proto: "decoder"), - 153: .same(proto: "decodeRepeated"), - 154: .same(proto: "decodeRepeatedBoolField"), - 155: .same(proto: "decodeRepeatedBytesField"), - 156: .same(proto: "decodeRepeatedDoubleField"), - 157: .same(proto: "decodeRepeatedEnumField"), - 158: .same(proto: "decodeRepeatedFixed32Field"), - 159: .same(proto: "decodeRepeatedFixed64Field"), - 160: .same(proto: "decodeRepeatedFloatField"), - 161: .same(proto: "decodeRepeatedGroupField"), - 162: .same(proto: "decodeRepeatedInt32Field"), - 163: .same(proto: "decodeRepeatedInt64Field"), - 164: .same(proto: "decodeRepeatedMessageField"), - 165: .same(proto: "decodeRepeatedSFixed32Field"), - 166: .same(proto: "decodeRepeatedSFixed64Field"), - 167: .same(proto: "decodeRepeatedSInt32Field"), - 168: .same(proto: "decodeRepeatedSInt64Field"), - 169: .same(proto: "decodeRepeatedStringField"), - 170: .same(proto: "decodeRepeatedUInt32Field"), - 171: .same(proto: "decodeRepeatedUInt64Field"), - 172: .same(proto: "decodeSingular"), - 173: .same(proto: "decodeSingularBoolField"), - 174: .same(proto: "decodeSingularBytesField"), - 175: .same(proto: "decodeSingularDoubleField"), - 176: .same(proto: "decodeSingularEnumField"), - 177: .same(proto: "decodeSingularFixed32Field"), - 178: .same(proto: "decodeSingularFixed64Field"), - 179: .same(proto: "decodeSingularFloatField"), - 180: .same(proto: "decodeSingularGroupField"), - 181: .same(proto: "decodeSingularInt32Field"), - 182: .same(proto: "decodeSingularInt64Field"), - 183: .same(proto: "decodeSingularMessageField"), - 184: .same(proto: "decodeSingularSFixed32Field"), - 185: .same(proto: "decodeSingularSFixed64Field"), - 186: .same(proto: "decodeSingularSInt32Field"), - 187: .same(proto: "decodeSingularSInt64Field"), - 188: .same(proto: "decodeSingularStringField"), - 189: .same(proto: "decodeSingularUInt32Field"), - 190: .same(proto: "decodeSingularUInt64Field"), - 191: .same(proto: "decodeTextFormat"), - 192: .same(proto: "defaultAnyTypeURLPrefix"), - 193: .same(proto: "defaultValue"), - 194: .same(proto: "dependency"), - 195: .same(proto: "deprecated"), - 196: .same(proto: "description"), - 197: .same(proto: "DescriptorProto"), - 198: .same(proto: "Dictionary"), - 199: .same(proto: "dictionaryLiteral"), - 200: .same(proto: "digit"), - 201: .same(proto: "digit0"), - 202: .same(proto: "digit1"), - 203: .same(proto: "digitCount"), - 204: .same(proto: "digits"), - 205: .same(proto: "digitValue"), - 206: .same(proto: "discardableResult"), - 207: .same(proto: "discardUnknownFields"), - 208: .same(proto: "distance"), - 209: .same(proto: "double"), - 210: .same(proto: "doubleValue"), - 211: .same(proto: "Duration"), - 212: .same(proto: "E"), - 213: .same(proto: "Element"), - 214: .same(proto: "elements"), - 215: .same(proto: "emitExtensionFieldName"), - 216: .same(proto: "emitFieldName"), - 217: .same(proto: "emitFieldNumber"), - 218: .same(proto: "Empty"), - 219: .same(proto: "emptyData"), - 220: .same(proto: "encodeAsBytes"), - 221: .same(proto: "encoded"), - 222: .same(proto: "encodedJSONString"), - 223: .same(proto: "encodedSize"), - 224: .same(proto: "encodeField"), - 225: .same(proto: "encoder"), - 226: .same(proto: "end"), - 227: .same(proto: "endArray"), - 228: .same(proto: "endMessageField"), - 229: .same(proto: "endObject"), - 230: .same(proto: "endRegularField"), - 231: .same(proto: "enum"), - 232: .same(proto: "EnumDescriptorProto"), - 233: .same(proto: "EnumOptions"), - 234: .same(proto: "EnumReservedRange"), - 235: .same(proto: "enumType"), - 236: .same(proto: "enumvalue"), - 237: .same(proto: "EnumValueDescriptorProto"), - 238: .same(proto: "EnumValueOptions"), - 239: .same(proto: "Equatable"), - 240: .same(proto: "Error"), - 241: .same(proto: "ExpressibleByArrayLiteral"), - 242: .same(proto: "ExpressibleByDictionaryLiteral"), - 243: .same(proto: "ext"), - 244: .same(proto: "extDecoder"), - 245: .same(proto: "extendedGraphemeClusterLiteral"), - 246: .same(proto: "ExtendedGraphemeClusterLiteralType"), - 247: .same(proto: "extendee"), - 248: .same(proto: "ExtensibleMessage"), - 249: .same(proto: "extension"), - 250: .same(proto: "ExtensionField"), - 251: .same(proto: "extensionFieldNumber"), - 252: .same(proto: "ExtensionFieldValueSet"), - 253: .same(proto: "ExtensionMap"), - 254: .same(proto: "extensionRange"), - 255: .same(proto: "ExtensionRangeOptions"), - 256: .same(proto: "extensions"), - 257: .same(proto: "extras"), - 258: .same(proto: "F"), - 259: .same(proto: "false"), - 260: .same(proto: "field"), - 261: .same(proto: "fieldData"), - 262: .same(proto: "FieldDescriptorProto"), - 263: .same(proto: "FieldMask"), - 264: .same(proto: "fieldName"), - 265: .same(proto: "fieldNameCount"), - 266: .same(proto: "fieldNum"), - 267: .same(proto: "fieldNumber"), - 268: .same(proto: "fieldNumberForProto"), - 269: .same(proto: "FieldOptions"), - 270: .same(proto: "fields"), - 271: .same(proto: "fieldSize"), - 272: .same(proto: "FieldTag"), - 273: .same(proto: "fieldType"), - 274: .same(proto: "file"), - 275: .same(proto: "FileDescriptorProto"), - 276: .same(proto: "FileDescriptorSet"), - 277: .same(proto: "fileName"), - 278: .same(proto: "FileOptions"), - 279: .same(proto: "filter"), - 280: .same(proto: "first"), - 281: .same(proto: "firstItem"), - 282: .same(proto: "float"), - 283: .same(proto: "floatLiteral"), - 284: .same(proto: "FloatLiteralType"), - 285: .same(proto: "FloatValue"), - 286: .same(proto: "forMessageName"), - 287: .same(proto: "formUnion"), - 288: .same(proto: "forReadingFrom"), - 289: .same(proto: "forTypeURL"), - 290: .same(proto: "ForwardParser"), - 291: .same(proto: "forWritingInto"), - 292: .same(proto: "from"), - 293: .same(proto: "fromAscii2"), - 294: .same(proto: "fromAscii4"), - 295: .same(proto: "fromByteOffset"), - 296: .same(proto: "fromHexDigit"), - 297: .same(proto: "func"), - 298: .same(proto: "G"), - 299: .same(proto: "GeneratedCodeInfo"), - 300: .same(proto: "get"), - 301: .same(proto: "getExtensionValue"), - 302: .same(proto: "googleapis"), - 303: .same(proto: "Google_Protobuf_Any"), - 304: .same(proto: "Google_Protobuf_Api"), - 305: .same(proto: "Google_Protobuf_BoolValue"), - 306: .same(proto: "Google_Protobuf_BytesValue"), - 307: .same(proto: "Google_Protobuf_DescriptorProto"), - 308: .same(proto: "Google_Protobuf_DoubleValue"), - 309: .same(proto: "Google_Protobuf_Duration"), - 310: .same(proto: "Google_Protobuf_Empty"), - 311: .same(proto: "Google_Protobuf_Enum"), - 312: .same(proto: "Google_Protobuf_EnumDescriptorProto"), - 313: .same(proto: "Google_Protobuf_EnumOptions"), - 314: .same(proto: "Google_Protobuf_EnumValue"), - 315: .same(proto: "Google_Protobuf_EnumValueDescriptorProto"), - 316: .same(proto: "Google_Protobuf_EnumValueOptions"), - 317: .same(proto: "Google_Protobuf_ExtensionRangeOptions"), - 318: .same(proto: "Google_Protobuf_Field"), - 319: .same(proto: "Google_Protobuf_FieldDescriptorProto"), - 320: .same(proto: "Google_Protobuf_FieldMask"), - 321: .same(proto: "Google_Protobuf_FieldOptions"), - 322: .same(proto: "Google_Protobuf_FileDescriptorProto"), - 323: .same(proto: "Google_Protobuf_FileDescriptorSet"), - 324: .same(proto: "Google_Protobuf_FileOptions"), - 325: .same(proto: "Google_Protobuf_FloatValue"), - 326: .same(proto: "Google_Protobuf_GeneratedCodeInfo"), - 327: .same(proto: "Google_Protobuf_Int32Value"), - 328: .same(proto: "Google_Protobuf_Int64Value"), - 329: .same(proto: "Google_Protobuf_ListValue"), - 330: .same(proto: "Google_Protobuf_MessageOptions"), - 331: .same(proto: "Google_Protobuf_Method"), - 332: .same(proto: "Google_Protobuf_MethodDescriptorProto"), - 333: .same(proto: "Google_Protobuf_MethodOptions"), - 334: .same(proto: "Google_Protobuf_Mixin"), - 335: .same(proto: "Google_Protobuf_NullValue"), - 336: .same(proto: "Google_Protobuf_OneofDescriptorProto"), - 337: .same(proto: "Google_Protobuf_OneofOptions"), - 338: .same(proto: "Google_Protobuf_Option"), - 339: .same(proto: "Google_Protobuf_ServiceDescriptorProto"), - 340: .same(proto: "Google_Protobuf_ServiceOptions"), - 341: .same(proto: "Google_Protobuf_SourceCodeInfo"), - 342: .same(proto: "Google_Protobuf_SourceContext"), - 343: .same(proto: "Google_Protobuf_StringValue"), - 344: .same(proto: "Google_Protobuf_Struct"), - 345: .same(proto: "Google_Protobuf_Syntax"), - 346: .same(proto: "Google_Protobuf_Timestamp"), - 347: .same(proto: "Google_Protobuf_Type"), - 348: .same(proto: "Google_Protobuf_UInt32Value"), - 349: .same(proto: "Google_Protobuf_UInt64Value"), - 350: .same(proto: "Google_Protobuf_UninterpretedOption"), - 351: .same(proto: "Google_Protobuf_Value"), - 352: .same(proto: "goPackage"), - 353: .same(proto: "group"), - 354: .same(proto: "groupFieldNumberStack"), - 355: .same(proto: "groupSize"), - 356: .same(proto: "h"), - 357: .same(proto: "hadOneofValue"), - 358: .same(proto: "handleConflictingOneOf"), - 359: .same(proto: "hasAggregateValue"), - 360: .same(proto: "hasAllowAlias"), - 361: .same(proto: "hasBegin"), - 362: .same(proto: "hasCcEnableArenas"), - 363: .same(proto: "hasCcGenericServices"), - 364: .same(proto: "hasClientStreaming"), - 365: .same(proto: "hasCsharpNamespace"), - 366: .same(proto: "hasCtype"), - 367: .same(proto: "hasDefaultValue"), - 368: .same(proto: "hasDeprecated"), - 369: .same(proto: "hasDoubleValue"), - 370: .same(proto: "hasEnd"), - 371: .same(proto: "hasExtendee"), - 372: .same(proto: "hasExtensionValue"), - 373: .same(proto: "hasGoPackage"), - 374: .same(proto: "hash"), - 375: .same(proto: "Hashable"), - 376: .same(proto: "hasher"), - 377: .same(proto: "hashValue"), - 378: .same(proto: "HashVisitor"), - 379: .same(proto: "hasIdempotencyLevel"), - 380: .same(proto: "hasIdentifierValue"), - 381: .same(proto: "hasInputType"), - 382: .same(proto: "hasIsExtension"), - 383: .same(proto: "hasJavaGenerateEqualsAndHash"), - 384: .same(proto: "hasJavaGenericServices"), - 385: .same(proto: "hasJavaMultipleFiles"), - 386: .same(proto: "hasJavaOuterClassname"), - 387: .same(proto: "hasJavaPackage"), - 388: .same(proto: "hasJavaStringCheckUtf8"), - 389: .same(proto: "hasJsonName"), - 390: .same(proto: "hasJstype"), - 391: .same(proto: "hasLabel"), - 392: .same(proto: "hasLazy"), - 393: .same(proto: "hasLeadingComments"), - 394: .same(proto: "hasMapEntry"), - 395: .same(proto: "hasMessageSetWireFormat"), - 396: .same(proto: "hasName"), - 397: .same(proto: "hasNamePart"), - 398: .same(proto: "hasNegativeIntValue"), - 399: .same(proto: "hasNoStandardDescriptorAccessor"), - 400: .same(proto: "hasNumber"), - 401: .same(proto: "hasObjcClassPrefix"), - 402: .same(proto: "hasOneofIndex"), - 403: .same(proto: "hasOptimizeFor"), - 404: .same(proto: "hasOptions"), - 405: .same(proto: "hasOutputType"), - 406: .same(proto: "hasPackage"), - 407: .same(proto: "hasPacked"), - 408: .same(proto: "hasPhpClassPrefix"), - 409: .same(proto: "hasPhpGenericServices"), - 410: .same(proto: "hasPhpMetadataNamespace"), - 411: .same(proto: "hasPhpNamespace"), - 412: .same(proto: "hasPositiveIntValue"), - 413: .same(proto: "hasProto3Optional"), - 414: .same(proto: "hasPyGenericServices"), - 415: .same(proto: "hasRubyPackage"), - 416: .same(proto: "hasServerStreaming"), - 417: .same(proto: "hasSourceCodeInfo"), - 418: .same(proto: "hasSourceContext"), - 419: .same(proto: "hasSourceFile"), - 420: .same(proto: "hasStart"), - 421: .same(proto: "hasStringValue"), - 422: .same(proto: "hasSwiftPrefix"), - 423: .same(proto: "hasSyntax"), - 424: .same(proto: "hasTrailingComments"), - 425: .same(proto: "hasType"), - 426: .same(proto: "hasTypeName"), - 427: .same(proto: "hasValue"), - 428: .same(proto: "hasWeak"), - 429: .same(proto: "hour"), - 430: .same(proto: "i"), - 431: .same(proto: "idempotencyLevel"), - 432: .same(proto: "identifierValue"), - 433: .same(proto: "if"), - 434: .same(proto: "ignoreUnknownFields"), - 435: .same(proto: "index"), - 436: .same(proto: "init"), - 437: .same(proto: "inout"), - 438: .same(proto: "inputType"), - 439: .same(proto: "insert"), - 440: .same(proto: "Int"), - 441: .same(proto: "Int32"), - 442: .same(proto: "Int32Value"), - 443: .same(proto: "Int64"), - 444: .same(proto: "Int64Value"), - 445: .same(proto: "Int8"), - 446: .same(proto: "integerLiteral"), - 447: .same(proto: "IntegerLiteralType"), - 448: .same(proto: "intern"), - 449: .same(proto: "Internal"), - 450: .same(proto: "InternalState"), - 451: .same(proto: "into"), - 452: .same(proto: "ints"), - 453: .same(proto: "isA"), - 454: .same(proto: "isEqual"), - 455: .same(proto: "isEqualTo"), - 456: .same(proto: "isExtension"), - 457: .same(proto: "isInitialized"), - 458: .same(proto: "itemTagsEncodedSize"), - 459: .same(proto: "Iterator"), - 460: .same(proto: "i_2166136261"), - 461: .same(proto: "javaGenerateEqualsAndHash"), - 462: .same(proto: "javaGenericServices"), - 463: .same(proto: "javaMultipleFiles"), - 464: .same(proto: "javaOuterClassname"), - 465: .same(proto: "javaPackage"), - 466: .same(proto: "javaStringCheckUtf8"), - 467: .same(proto: "JSONDecoder"), - 468: .same(proto: "JSONDecodingError"), - 469: .same(proto: "JSONDecodingOptions"), - 470: .same(proto: "jsonEncoder"), - 471: .same(proto: "JSONEncodingError"), - 472: .same(proto: "JSONEncodingOptions"), - 473: .same(proto: "JSONEncodingVisitor"), - 474: .same(proto: "JSONMapEncodingVisitor"), - 475: .same(proto: "jsonName"), - 476: .same(proto: "jsonPath"), - 477: .same(proto: "jsonPaths"), - 478: .same(proto: "JSONScanner"), - 479: .same(proto: "jsonString"), - 480: .same(proto: "jsonText"), - 481: .same(proto: "jsonUTF8Data"), - 482: .same(proto: "jstype"), - 483: .same(proto: "k"), - 484: .same(proto: "Key"), - 485: .same(proto: "keyField"), - 486: .same(proto: "KeyType"), - 487: .same(proto: "kind"), - 488: .same(proto: "l"), - 489: .same(proto: "label"), - 490: .same(proto: "lazy"), - 491: .same(proto: "leadingComments"), - 492: .same(proto: "leadingDetachedComments"), - 493: .same(proto: "length"), - 494: .same(proto: "lessThan"), - 495: .same(proto: "let"), - 496: .same(proto: "lhs"), - 497: .same(proto: "list"), - 498: .same(proto: "listOfMessages"), - 499: .same(proto: "listValue"), - 500: .same(proto: "littleEndian"), - 501: .same(proto: "littleEndianBytes"), - 502: .same(proto: "load"), - 503: .same(proto: "localHasher"), - 504: .same(proto: "location"), - 505: .same(proto: "M"), - 506: .same(proto: "major"), - 507: .same(proto: "makeIterator"), - 508: .same(proto: "mapEntry"), - 509: .same(proto: "mapHash"), - 510: .same(proto: "MapKeyType"), - 511: .same(proto: "mapNameResolver"), - 512: .same(proto: "mapToMessages"), - 513: .same(proto: "MapValueType"), - 514: .same(proto: "mapVisitor"), - 515: .same(proto: "mdayStart"), - 516: .same(proto: "merge"), - 517: .same(proto: "message"), - 518: .same(proto: "messageDepthLimit"), - 519: .same(proto: "MessageExtension"), - 520: .same(proto: "MessageImplementationBase"), - 521: .same(proto: "MessageOptions"), - 522: .same(proto: "MessageSet"), - 523: .same(proto: "messageSetWireFormat"), - 524: .same(proto: "messageType"), - 525: .same(proto: "Method"), - 526: .same(proto: "MethodDescriptorProto"), - 527: .same(proto: "MethodOptions"), - 528: .same(proto: "methods"), - 529: .same(proto: "minor"), - 530: .same(proto: "Mixin"), - 531: .same(proto: "mixins"), - 532: .same(proto: "modifier"), - 533: .same(proto: "modify"), - 534: .same(proto: "month"), - 535: .same(proto: "msgExtension"), - 536: .same(proto: "mutating"), - 537: .same(proto: "n"), - 538: .same(proto: "name"), - 539: .same(proto: "NameDescription"), - 540: .same(proto: "NameMap"), - 541: .same(proto: "NamePart"), - 542: .same(proto: "nameResolver"), - 543: .same(proto: "names"), - 544: .same(proto: "nanos"), - 545: .same(proto: "nativeBytes"), - 546: .same(proto: "nativeEndianBytes"), - 547: .same(proto: "negativeIntValue"), - 548: .same(proto: "nestedType"), - 549: .same(proto: "newL"), - 550: .same(proto: "newList"), - 551: .same(proto: "newValue"), - 552: .same(proto: "nextByte"), - 553: .same(proto: "nextFieldNumber"), - 554: .same(proto: "nil"), - 555: .same(proto: "nilLiteral"), - 556: .same(proto: "noStandardDescriptorAccessor"), - 557: .same(proto: "nullValue"), - 558: .same(proto: "number"), - 559: .same(proto: "numberValue"), - 560: .same(proto: "objcClassPrefix"), - 561: .same(proto: "of"), - 562: .same(proto: "oneofDecl"), - 563: .same(proto: "OneofDescriptorProto"), - 564: .same(proto: "oneofIndex"), - 565: .same(proto: "OneofOptions"), - 566: .same(proto: "oneofs"), - 567: .same(proto: "OneOf_Kind"), - 568: .same(proto: "optimizeFor"), - 569: .same(proto: "OptimizeMode"), - 570: .same(proto: "Option"), - 571: .same(proto: "OptionalEnumExtensionField"), - 572: .same(proto: "OptionalExtensionField"), - 573: .same(proto: "OptionalGroupExtensionField"), - 574: .same(proto: "OptionalMessageExtensionField"), - 575: .same(proto: "options"), - 576: .same(proto: "other"), - 577: .same(proto: "others"), - 578: .same(proto: "out"), - 579: .same(proto: "outputType"), - 580: .same(proto: "p"), - 581: .same(proto: "package"), - 582: .same(proto: "packed"), - 583: .same(proto: "PackedEnumExtensionField"), - 584: .same(proto: "PackedExtensionField"), - 585: .same(proto: "padding"), - 586: .same(proto: "parent"), - 587: .same(proto: "parse"), - 588: .same(proto: "partial"), - 589: .same(proto: "path"), - 590: .same(proto: "paths"), - 591: .same(proto: "payload"), - 592: .same(proto: "payloadSize"), - 593: .same(proto: "phpClassPrefix"), - 594: .same(proto: "phpGenericServices"), - 595: .same(proto: "phpMetadataNamespace"), - 596: .same(proto: "phpNamespace"), - 597: .same(proto: "pointer"), - 598: .same(proto: "pos"), - 599: .same(proto: "positiveIntValue"), - 600: .same(proto: "prefix"), - 601: .same(proto: "preserveProtoFieldNames"), - 602: .same(proto: "preTraverse"), - 603: .same(proto: "printUnknownFields"), - 604: .same(proto: "proto2"), - 605: .same(proto: "proto3DefaultValue"), - 606: .same(proto: "proto3Optional"), - 607: .same(proto: "ProtobufAPIVersionCheck"), - 608: .same(proto: "ProtobufAPIVersion_2"), - 609: .same(proto: "ProtobufBool"), - 610: .same(proto: "ProtobufBytes"), - 611: .same(proto: "ProtobufDouble"), - 612: .same(proto: "ProtobufEnumMap"), - 613: .same(proto: "protobufExtension"), - 614: .same(proto: "ProtobufFixed32"), - 615: .same(proto: "ProtobufFixed64"), - 616: .same(proto: "ProtobufFloat"), - 617: .same(proto: "ProtobufInt32"), - 618: .same(proto: "ProtobufInt64"), - 619: .same(proto: "ProtobufMap"), - 620: .same(proto: "ProtobufMessageMap"), - 621: .same(proto: "ProtobufSFixed32"), - 622: .same(proto: "ProtobufSFixed64"), - 623: .same(proto: "ProtobufSInt32"), - 624: .same(proto: "ProtobufSInt64"), - 625: .same(proto: "ProtobufString"), - 626: .same(proto: "ProtobufUInt32"), - 627: .same(proto: "ProtobufUInt64"), - 628: .same(proto: "protobuf_extensionFieldValues"), - 629: .same(proto: "protobuf_fieldNumber"), - 630: .same(proto: "protobuf_generated_isEqualTo"), - 631: .same(proto: "protobuf_nameMap"), - 632: .same(proto: "protobuf_newField"), - 633: .same(proto: "protobuf_package"), - 634: .same(proto: "protocol"), - 635: .same(proto: "protoFieldName"), - 636: .same(proto: "protoMessageName"), - 637: .same(proto: "ProtoNameProviding"), - 638: .same(proto: "protoPaths"), - 639: .same(proto: "public"), - 640: .same(proto: "publicDependency"), - 641: .same(proto: "putBoolValue"), - 642: .same(proto: "putBytesValue"), - 643: .same(proto: "putDoubleValue"), - 644: .same(proto: "putEnumValue"), - 645: .same(proto: "putFixedUInt32"), - 646: .same(proto: "putFixedUInt64"), - 647: .same(proto: "putFloatValue"), - 648: .same(proto: "putInt64"), - 649: .same(proto: "putStringValue"), - 650: .same(proto: "putUInt64"), - 651: .same(proto: "putUInt64Hex"), - 652: .same(proto: "putVarInt"), - 653: .same(proto: "putZigZagVarInt"), - 654: .same(proto: "pyGenericServices"), - 655: .same(proto: "rawChars"), - 656: .same(proto: "RawRepresentable"), - 657: .same(proto: "RawValue"), - 658: .same(proto: "read4HexDigits"), - 659: .same(proto: "register"), - 660: .same(proto: "RepeatedEnumExtensionField"), - 661: .same(proto: "RepeatedExtensionField"), - 662: .same(proto: "RepeatedGroupExtensionField"), - 663: .same(proto: "RepeatedMessageExtensionField"), - 664: .same(proto: "requestStreaming"), - 665: .same(proto: "requestTypeURL"), - 666: .same(proto: "requiredSize"), - 667: .same(proto: "reservedName"), - 668: .same(proto: "reservedRange"), - 669: .same(proto: "responseStreaming"), - 670: .same(proto: "responseTypeURL"), - 671: .same(proto: "result"), - 672: .same(proto: "rethrows"), - 673: .same(proto: "return"), - 674: .same(proto: "ReturnType"), - 675: .same(proto: "revision"), - 676: .same(proto: "rhs"), - 677: .same(proto: "root"), - 678: .same(proto: "rubyPackage"), - 679: .same(proto: "s"), - 680: .same(proto: "sawBackslash"), - 681: .same(proto: "sawSection4Characters"), - 682: .same(proto: "sawSection5Characters"), - 683: .same(proto: "scanner"), - 684: .same(proto: "seconds"), - 685: .same(proto: "self"), - 686: .same(proto: "separator"), - 687: .same(proto: "serialize"), - 688: .same(proto: "serializedData"), - 689: .same(proto: "serializedSize"), - 690: .same(proto: "serverStreaming"), - 691: .same(proto: "service"), - 692: .same(proto: "ServiceDescriptorProto"), - 693: .same(proto: "ServiceOptions"), - 694: .same(proto: "set"), - 695: .same(proto: "setExtensionValue"), - 696: .same(proto: "shift"), - 697: .same(proto: "SimpleExtensionMap"), - 698: .same(proto: "sizer"), - 699: .same(proto: "source"), - 700: .same(proto: "sourceCodeInfo"), - 701: .same(proto: "sourceContext"), - 702: .same(proto: "sourceEncoding"), - 703: .same(proto: "sourceFile"), - 704: .same(proto: "span"), - 705: .same(proto: "split"), - 706: .same(proto: "start"), - 707: .same(proto: "startArray"), - 708: .same(proto: "startArrayObject"), - 709: .same(proto: "startField"), - 710: .same(proto: "startIndex"), - 711: .same(proto: "startMessageField"), - 712: .same(proto: "startObject"), - 713: .same(proto: "startRegularField"), - 714: .same(proto: "state"), - 715: .same(proto: "static"), - 716: .same(proto: "StaticString"), - 717: .same(proto: "storage"), - 718: .same(proto: "String"), - 719: .same(proto: "stringLiteral"), - 720: .same(proto: "StringLiteralType"), - 721: .same(proto: "stringResult"), - 722: .same(proto: "stringValue"), - 723: .same(proto: "struct"), - 724: .same(proto: "structValue"), - 725: .same(proto: "subDecoder"), - 726: .same(proto: "subscript"), - 727: .same(proto: "subVisitor"), - 728: .same(proto: "Swift"), - 729: .same(proto: "swiftPrefix"), - 730: .same(proto: "SwiftProtobuf"), - 731: .same(proto: "syntax"), - 732: .same(proto: "T"), - 733: .same(proto: "tag"), - 734: .same(proto: "terminator"), - 735: .same(proto: "testDecoder"), - 736: .same(proto: "text"), - 737: .same(proto: "textDecoder"), - 738: .same(proto: "TextFormatDecoder"), - 739: .same(proto: "TextFormatDecodingError"), - 740: .same(proto: "TextFormatDecodingOptions"), - 741: .same(proto: "TextFormatEncodingOptions"), - 742: .same(proto: "TextFormatEncodingVisitor"), - 743: .same(proto: "textFormatString"), - 744: .same(proto: "throws"), - 745: .same(proto: "timeInterval"), - 746: .same(proto: "timeIntervalSince1970"), - 747: .same(proto: "timeIntervalSinceReferenceDate"), - 748: .same(proto: "Timestamp"), - 749: .same(proto: "total"), - 750: .same(proto: "totalArrayDepth"), - 751: .same(proto: "totalSize"), - 752: .same(proto: "trailingComments"), - 753: .same(proto: "traverse"), - 754: .same(proto: "true"), - 755: .same(proto: "try"), - 756: .same(proto: "type"), - 757: .same(proto: "typealias"), - 758: .same(proto: "TypeEnum"), - 759: .same(proto: "typeName"), - 760: .same(proto: "typePrefix"), - 761: .same(proto: "typeStart"), - 762: .same(proto: "typeUnknown"), - 763: .same(proto: "typeURL"), - 764: .same(proto: "UInt32"), - 765: .same(proto: "UInt32Value"), - 766: .same(proto: "UInt64"), - 767: .same(proto: "UInt64Value"), - 768: .same(proto: "UInt8"), - 769: .same(proto: "unicodeScalarLiteral"), - 770: .same(proto: "UnicodeScalarLiteralType"), - 771: .same(proto: "unicodeScalars"), - 772: .same(proto: "UnicodeScalarView"), - 773: .same(proto: "uninterpretedOption"), - 774: .same(proto: "union"), - 775: .same(proto: "uniqueStorage"), - 776: .same(proto: "unknown"), - 777: .same(proto: "unknownFields"), - 778: .same(proto: "UnknownStorage"), - 779: .same(proto: "unpackTo"), - 780: .same(proto: "UnsafeBufferPointer"), - 781: .same(proto: "UnsafeMutablePointer"), - 782: .same(proto: "UnsafeMutableRawBufferPointer"), - 783: .same(proto: "UnsafeMutableRawPointer"), - 784: .same(proto: "UnsafeRawBufferPointer"), - 785: .same(proto: "UnsafeRawPointer"), - 786: .same(proto: "updatedOptions"), - 787: .same(proto: "url"), - 788: .same(proto: "utf8"), - 789: .same(proto: "utf8Ptr"), - 790: .same(proto: "utf8ToDouble"), - 791: .same(proto: "UTF8View"), - 792: .same(proto: "v"), - 793: .same(proto: "value"), - 794: .same(proto: "valueField"), - 795: .same(proto: "values"), - 796: .same(proto: "ValueType"), - 797: .same(proto: "var"), - 798: .same(proto: "Version"), - 799: .same(proto: "versionString"), - 800: .same(proto: "visitExtensionFields"), - 801: .same(proto: "visitExtensionFieldsAsMessageSet"), - 802: .same(proto: "visitMapField"), - 803: .same(proto: "visitor"), - 804: .same(proto: "visitPacked"), - 805: .same(proto: "visitPackedBoolField"), - 806: .same(proto: "visitPackedDoubleField"), - 807: .same(proto: "visitPackedEnumField"), - 808: .same(proto: "visitPackedFixed32Field"), - 809: .same(proto: "visitPackedFixed64Field"), - 810: .same(proto: "visitPackedFloatField"), - 811: .same(proto: "visitPackedInt32Field"), - 812: .same(proto: "visitPackedInt64Field"), - 813: .same(proto: "visitPackedSFixed32Field"), - 814: .same(proto: "visitPackedSFixed64Field"), - 815: .same(proto: "visitPackedSInt32Field"), - 816: .same(proto: "visitPackedSInt64Field"), - 817: .same(proto: "visitPackedUInt32Field"), - 818: .same(proto: "visitPackedUInt64Field"), - 819: .same(proto: "visitRepeated"), - 820: .same(proto: "visitRepeatedBoolField"), - 821: .same(proto: "visitRepeatedBytesField"), - 822: .same(proto: "visitRepeatedDoubleField"), - 823: .same(proto: "visitRepeatedEnumField"), - 824: .same(proto: "visitRepeatedFixed32Field"), - 825: .same(proto: "visitRepeatedFixed64Field"), - 826: .same(proto: "visitRepeatedFloatField"), - 827: .same(proto: "visitRepeatedGroupField"), - 828: .same(proto: "visitRepeatedInt32Field"), - 829: .same(proto: "visitRepeatedInt64Field"), - 830: .same(proto: "visitRepeatedMessageField"), - 831: .same(proto: "visitRepeatedSFixed32Field"), - 832: .same(proto: "visitRepeatedSFixed64Field"), - 833: .same(proto: "visitRepeatedSInt32Field"), - 834: .same(proto: "visitRepeatedSInt64Field"), - 835: .same(proto: "visitRepeatedStringField"), - 836: .same(proto: "visitRepeatedUInt32Field"), - 837: .same(proto: "visitRepeatedUInt64Field"), - 838: .same(proto: "visitSingular"), - 839: .same(proto: "visitSingularBoolField"), - 840: .same(proto: "visitSingularBytesField"), - 841: .same(proto: "visitSingularDoubleField"), - 842: .same(proto: "visitSingularEnumField"), - 843: .same(proto: "visitSingularFixed32Field"), - 844: .same(proto: "visitSingularFixed64Field"), - 845: .same(proto: "visitSingularFloatField"), - 846: .same(proto: "visitSingularGroupField"), - 847: .same(proto: "visitSingularInt32Field"), - 848: .same(proto: "visitSingularInt64Field"), - 849: .same(proto: "visitSingularMessageField"), - 850: .same(proto: "visitSingularSFixed32Field"), - 851: .same(proto: "visitSingularSFixed64Field"), - 852: .same(proto: "visitSingularSInt32Field"), - 853: .same(proto: "visitSingularSInt64Field"), - 854: .same(proto: "visitSingularStringField"), - 855: .same(proto: "visitSingularUInt32Field"), - 856: .same(proto: "visitSingularUInt64Field"), - 857: .same(proto: "visitUnknown"), - 858: .same(proto: "wasDecoded"), - 859: .same(proto: "weak"), - 860: .same(proto: "weakDependency"), - 861: .same(proto: "where"), - 862: .same(proto: "wireFormat"), - 863: .same(proto: "with"), - 864: .same(proto: "withUnsafeBytes"), - 865: .same(proto: "withUnsafeMutableBytes"), - 866: .same(proto: "work"), - 867: .same(proto: "WrappedType"), - 868: .same(proto: "written"), - 869: .same(proto: "yday"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE\0\u{1}addPath\0\u{1}adjusted\0\u{1}aggregateValue\0\u{1}allCases\0\u{1}allowAlias\0\u{1}alwaysPrintEnumsAsInts\0\u{1}alwaysPrintInt64sAsNumbers\0\u{1}annotation\0\u{1}any\0\u{1}AnyExtensionField\0\u{1}AnyMessageExtension\0\u{1}AnyMessageStorage\0\u{1}AnyUnpackError\0\u{1}append\0\u{1}appended\0\u{1}appendUIntHex\0\u{1}appendUnknown\0\u{1}areAllInitialized\0\u{1}Array\0\u{1}arrayDepth\0\u{1}arrayLiteral\0\u{1}arraySeparator\0\u{1}as\0\u{1}asciiOpenCurlyBracket\0\u{1}asciiZero\0\u{1}async\0\u{1}AsyncIterator\0\u{1}AsyncIteratorProtocol\0\u{1}AsyncMessageSequence\0\u{1}available\0\u{1}b\0\u{1}Base\0\u{1}base64Values\0\u{1}baseAddress\0\u{1}BaseType\0\u{1}begin\0\u{1}binary\0\u{1}BinaryDecoder\0\u{1}BinaryDecoding\0\u{1}BinaryDecodingError\0\u{1}BinaryDecodingOptions\0\u{1}BinaryDelimited\0\u{1}BinaryEncoder\0\u{1}BinaryEncodingError\0\u{1}BinaryEncodingMessageSetSizeVisitor\0\u{1}BinaryEncodingMessageSetVisitor\0\u{1}BinaryEncodingOptions\0\u{1}BinaryEncodingSizeVisitor\0\u{1}BinaryEncodingVisitor\0\u{1}binaryOptions\0\u{1}binaryProtobufDelimitedMessages\0\u{1}BinaryStreamDecoding\0\u{1}binaryStreamDecodingError\0\u{1}bitPattern\0\u{1}body\0\u{1}Bool\0\u{1}booleanLiteral\0\u{1}BooleanLiteralType\0\u{1}boolValue\0\u{1}buffer\0\u{1}byte\0\u{1}bytecode\0\u{1}BytecodeReader\0\u{1}bytes\0\u{1}bytesInGroup\0\u{1}bytesNeeded\0\u{1}bytesRead\0\u{1}c\0\u{1}canonical\0\u{1}capitalizeNext\0\u{1}cardinality\0\u{1}CaseIterable\0\u{1}castedValue\0\u{1}ccEnableArenas\0\u{1}ccGenericServices\0\u{1}Character\0\u{1}chars\0\u{1}checkProgramFormat\0\u{1}chunk\0\u{1}class\0\u{1}clearAggregateValue\0\u{1}clearAllowAlias\0\u{1}clearBegin\0\u{1}clearCcEnableArenas\0\u{1}clearCcGenericServices\0\u{1}clearClientStreaming\0\u{1}clearCsharpNamespace\0\u{1}clearCtype\0\u{1}clearDebugRedact\0\u{1}clearDefaultSymbolVisibility\0\u{1}clearDefaultValue\0\u{1}clearDeprecated\0\u{1}clearDeprecatedLegacyJsonFieldConflicts\0\u{1}clearDeprecationWarning\0\u{1}clearDoubleValue\0\u{1}clearEdition\0\u{1}clearEditionDeprecated\0\u{1}clearEditionIntroduced\0\u{1}clearEditionRemoved\0\u{1}clearEnd\0\u{1}clearEnforceNamingStyle\0\u{1}clearEnumType\0\u{1}clearExtendee\0\u{1}clearExtensionValue\0\u{1}clearFeatures\0\u{1}clearFeatureSupport\0\u{1}clearFieldPresence\0\u{1}clearFixedFeatures\0\u{1}clearFullName\0\u{1}clearGoPackage\0\u{1}clearIdempotencyLevel\0\u{1}clearIdentifierValue\0\u{1}clearInputType\0\u{1}clearIsExtension\0\u{1}clearJavaGenerateEqualsAndHash\0\u{1}clearJavaGenericServices\0\u{1}clearJavaMultipleFiles\0\u{1}clearJavaOuterClassname\0\u{1}clearJavaPackage\0\u{1}clearJavaStringCheckUtf8\0\u{1}clearJsonFormat\0\u{1}clearJsonName\0\u{1}clearJstype\0\u{1}clearLabel\0\u{1}clearLazy\0\u{1}clearLeadingComments\0\u{1}clearMapEntry\0\u{1}clearMaximumEdition\0\u{1}clearMessageEncoding\0\u{1}clearMessageSetWireFormat\0\u{1}clearMinimumEdition\0\u{1}clearName\0\u{1}clearNamePart\0\u{1}clearNegativeIntValue\0\u{1}clearNoStandardDescriptorAccessor\0\u{1}clearNumber\0\u{1}clearObjcClassPrefix\0\u{1}clearOneofIndex\0\u{1}clearOptimizeFor\0\u{1}clearOptions\0\u{1}clearOutputType\0\u{1}clearOverridableFeatures\0\u{1}clearPackage\0\u{1}clearPacked\0\u{1}clearPhpClassPrefix\0\u{1}clearPhpMetadataNamespace\0\u{1}clearPhpNamespace\0\u{1}clearPositiveIntValue\0\u{1}clearProto3Optional\0\u{1}clearPyGenericServices\0\u{1}clearRemovalError\0\u{1}clearRepeated\0\u{1}clearRepeatedFieldEncoding\0\u{1}clearReserved\0\u{1}clearRetention\0\u{1}clearRubyPackage\0\u{1}clearSemantic\0\u{1}clearServerStreaming\0\u{1}clearSourceCodeInfo\0\u{1}clearSourceContext\0\u{1}clearSourceFile\0\u{1}clearStart\0\u{1}clearStringValue\0\u{1}clearSwiftPrefix\0\u{1}clearSyntax\0\u{1}clearTrailingComments\0\u{1}clearType\0\u{1}clearTypeName\0\u{1}clearUnverifiedLazy\0\u{1}clearUtf8Validation\0\u{1}clearValue\0\u{1}clearVerification\0\u{1}clearVisibility\0\u{1}clearWeak\0\u{1}clientStreaming\0\u{1}code\0\u{1}codePoint\0\u{1}codeUnits\0\u{1}Collection\0\u{1}comma\0\u{1}consumedBytes\0\u{1}contains\0\u{1}contentsOf\0\u{1}ContiguousBytes\0\u{1}copy\0\u{1}count\0\u{1}countVarintsInBuffer\0\u{1}csharpNamespace\0\u{1}ctype\0\u{1}customCodable\0\u{1}CustomDebugStringConvertible\0\u{1}CustomStringConvertible\0\u{1}D\0\u{1}Data\0\u{1}dataResult\0\u{1}date\0\u{1}daySec\0\u{1}daysSinceEpoch\0\u{1}debugDescription\0\u{1}debugRedact\0\u{1}declaration\0\u{1}decoded\0\u{1}decodedFromJSONNull\0\u{1}decodeExtensionField\0\u{1}decodeExtensionFieldsAsMessageSet\0\u{1}decodeJSON\0\u{1}decodeMapField\0\u{1}decodeMessage\0\u{1}Decoder\0\u{1}decodeRepeated\0\u{1}decodeRepeatedBoolField\0\u{1}decodeRepeatedBytesField\0\u{1}decodeRepeatedDoubleField\0\u{1}decodeRepeatedEnumField\0\u{1}decodeRepeatedFixed32Field\0\u{1}decodeRepeatedFixed64Field\0\u{1}decodeRepeatedFloatField\0\u{1}decodeRepeatedGroupField\0\u{1}decodeRepeatedInt32Field\0\u{1}decodeRepeatedInt64Field\0\u{1}decodeRepeatedMessageField\0\u{1}decodeRepeatedSFixed32Field\0\u{1}decodeRepeatedSFixed64Field\0\u{1}decodeRepeatedSInt32Field\0\u{1}decodeRepeatedSInt64Field\0\u{1}decodeRepeatedStringField\0\u{1}decodeRepeatedUInt32Field\0\u{1}decodeRepeatedUInt64Field\0\u{1}decodeSingular\0\u{1}decodeSingularBoolField\0\u{1}decodeSingularBytesField\0\u{1}decodeSingularDoubleField\0\u{1}decodeSingularEnumField\0\u{1}decodeSingularFixed32Field\0\u{1}decodeSingularFixed64Field\0\u{1}decodeSingularFloatField\0\u{1}decodeSingularGroupField\0\u{1}decodeSingularInt32Field\0\u{1}decodeSingularInt64Field\0\u{1}decodeSingularMessageField\0\u{1}decodeSingularSFixed32Field\0\u{1}decodeSingularSFixed64Field\0\u{1}decodeSingularSInt32Field\0\u{1}decodeSingularSInt64Field\0\u{1}decodeSingularStringField\0\u{1}decodeSingularUInt32Field\0\u{1}decodeSingularUInt64Field\0\u{1}decodeTextFormat\0\u{1}defaultAnyTypeURLPrefix\0\u{1}defaults\0\u{1}defaultSymbolVisibility\0\u{1}defaultValue\0\u{1}dependency\0\u{1}deprecated\0\u{1}deprecatedLegacyJsonFieldConflicts\0\u{1}deprecationWarning\0\u{1}description\0\u{1}Dictionary\0\u{1}dictionaryLiteral\0\u{1}digit\0\u{1}digit0\0\u{1}digit1\0\u{1}digitCount\0\u{1}digits\0\u{1}digitValue\0\u{1}discardableResult\0\u{1}discardUnknownFields\0\u{1}Double\0\u{1}doubleValue\0\u{1}duration\0\u{1}E\0\u{1}edition\0\u{1}EditionDefault\0\u{1}editionDefaults\0\u{1}editionDeprecated\0\u{1}editionIntroduced\0\u{1}editionRemoved\0\u{1}Element\0\u{1}elements\0\u{1}else\0\u{1}emitExtensionFieldName\0\u{1}emitFieldName\0\u{1}emitFieldNumber\0\u{1}emptyAnyTypeURL\0\u{1}emptyData\0\u{1}encodeAsBytes\0\u{1}encoded\0\u{1}encodedJSONString\0\u{1}encodedSize\0\u{1}encodeField\0\u{1}encoder\0\u{1}end\0\u{1}endArray\0\u{1}endMessageField\0\u{1}endObject\0\u{1}endRegularField\0\u{1}enforceNamingStyle\0\u{1}enum\0\u{1}EnumReservedRange\0\u{1}enumType\0\u{1}enumvalue\0\u{1}Equatable\0\u{1}Error\0\u{1}execute\0\u{1}ExpressibleByArrayLiteral\0\u{1}ExpressibleByDictionaryLiteral\0\u{1}ext\0\u{1}extDecoder\0\u{1}extendedGraphemeClusterLiteral\0\u{1}ExtendedGraphemeClusterLiteralType\0\u{1}extendee\0\u{1}ExtensibleMessage\0\u{1}extension\0\u{1}ExtensionField\0\u{1}extensionFieldNumber\0\u{1}ExtensionFieldValueSet\0\u{1}ExtensionMap\0\u{1}extensionRange\0\u{1}extensions\0\u{1}extras\0\u{1}F\0\u{1}false\0\u{1}features\0\u{1}FeatureSetEditionDefault\0\u{1}featureSupport\0\u{1}field\0\u{1}fieldData\0\u{1}FieldMaskError\0\u{1}fieldName\0\u{1}fieldNameCount\0\u{1}fieldNum\0\u{1}fieldNumber\0\u{1}fieldNumberForProto\0\u{1}fieldPresence\0\u{1}fields\0\u{1}fieldSize\0\u{1}FieldTag\0\u{1}FieldType\0\u{1}file\0\u{1}fileName\0\u{1}filter\0\u{1}final\0\u{1}finiteOnly\0\u{1}first\0\u{1}firstItem\0\u{1}fixedFeatures\0\u{1}Float\0\u{1}floatLiteral\0\u{1}FloatLiteralType\0\u{1}for\0\u{1}forMessageName\0\u{1}formUnion\0\u{1}forReadingFrom\0\u{1}forTypeURL\0\u{1}ForwardParser\0\u{1}forWritingInto\0\u{1}from\0\u{1}fromAscii2\0\u{1}fromAscii4\0\u{1}fromByteOffset\0\u{1}fromHexDigit\0\u{1}fullName\0\u{1}func\0\u{1}function\0\u{1}G\0\u{1}get\0\u{1}getExtensionValue\0\u{1}Google_Protobuf_Any\0\u{1}Google_Protobuf_Api\0\u{1}Google_Protobuf_BoolValue\0\u{1}Google_Protobuf_BytesValue\0\u{1}Google_Protobuf_DescriptorProto\0\u{1}Google_Protobuf_DoubleValue\0\u{1}Google_Protobuf_Duration\0\u{1}Google_Protobuf_Edition\0\u{1}Google_Protobuf_Empty\0\u{1}Google_Protobuf_Enum\0\u{1}Google_Protobuf_EnumDescriptorProto\0\u{1}Google_Protobuf_EnumOptions\0\u{1}Google_Protobuf_EnumValue\0\u{1}Google_Protobuf_EnumValueDescriptorProto\0\u{1}Google_Protobuf_EnumValueOptions\0\u{1}Google_Protobuf_ExtensionRangeOptions\0\u{1}Google_Protobuf_FeatureSet\0\u{1}Google_Protobuf_FeatureSetDefaults\0\u{1}Google_Protobuf_Field\0\u{1}Google_Protobuf_FieldDescriptorProto\0\u{1}Google_Protobuf_FieldMask\0\u{1}Google_Protobuf_FieldOptions\0\u{1}Google_Protobuf_FileDescriptorProto\0\u{1}Google_Protobuf_FileDescriptorSet\0\u{1}Google_Protobuf_FileOptions\0\u{1}Google_Protobuf_FloatValue\0\u{1}Google_Protobuf_GeneratedCodeInfo\0\u{1}Google_Protobuf_Int32Value\0\u{1}Google_Protobuf_Int64Value\0\u{1}Google_Protobuf_ListValue\0\u{1}Google_Protobuf_MessageOptions\0\u{1}Google_Protobuf_Method\0\u{1}Google_Protobuf_MethodDescriptorProto\0\u{1}Google_Protobuf_MethodOptions\0\u{1}Google_Protobuf_Mixin\0\u{1}Google_Protobuf_NullValue\0\u{1}Google_Protobuf_OneofDescriptorProto\0\u{1}Google_Protobuf_OneofOptions\0\u{1}Google_Protobuf_Option\0\u{1}Google_Protobuf_ServiceDescriptorProto\0\u{1}Google_Protobuf_ServiceOptions\0\u{1}Google_Protobuf_SourceCodeInfo\0\u{1}Google_Protobuf_SourceContext\0\u{1}Google_Protobuf_StringValue\0\u{1}Google_Protobuf_Struct\0\u{1}Google_Protobuf_SymbolVisibility\0\u{1}Google_Protobuf_Syntax\0\u{1}Google_Protobuf_Timestamp\0\u{1}Google_Protobuf_Type\0\u{1}Google_Protobuf_UInt32Value\0\u{1}Google_Protobuf_UInt64Value\0\u{1}Google_Protobuf_UninterpretedOption\0\u{1}Google_Protobuf_Value\0\u{1}goPackage\0\u{1}gotData\0\u{1}group\0\u{1}groupFieldNumberStack\0\u{1}groupSize\0\u{1}guard\0\u{1}hadOneofValue\0\u{1}handleConflictingOneOf\0\u{1}handleInstruction\0\u{1}hasAggregateValue\0\u{1}hasAllowAlias\0\u{1}hasBegin\0\u{1}hasCcEnableArenas\0\u{1}hasCcGenericServices\0\u{1}hasClientStreaming\0\u{1}hasCsharpNamespace\0\u{1}hasCtype\0\u{1}hasData\0\u{1}hasDebugRedact\0\u{1}hasDefaultSymbolVisibility\0\u{1}hasDefaultValue\0\u{1}hasDeprecated\0\u{1}hasDeprecatedLegacyJsonFieldConflicts\0\u{1}hasDeprecationWarning\0\u{1}hasDoubleValue\0\u{1}hasEdition\0\u{1}hasEditionDeprecated\0\u{1}hasEditionIntroduced\0\u{1}hasEditionRemoved\0\u{1}hasEnd\0\u{1}hasEnforceNamingStyle\0\u{1}hasEnumType\0\u{1}hasExplicitDelta\0\u{1}hasExtendee\0\u{1}hasExtensionValue\0\u{1}hasFeatures\0\u{1}hasFeatureSupport\0\u{1}hasFieldPresence\0\u{1}hasFixedFeatures\0\u{1}hasFullName\0\u{1}hasGoPackage\0\u{1}hash\0\u{1}Hashable\0\u{1}hasher\0\u{1}HashVisitor\0\u{1}hasIdempotencyLevel\0\u{1}hasIdentifierValue\0\u{1}hasInputType\0\u{1}hasIsExtension\0\u{1}hasJavaGenerateEqualsAndHash\0\u{1}hasJavaGenericServices\0\u{1}hasJavaMultipleFiles\0\u{1}hasJavaOuterClassname\0\u{1}hasJavaPackage\0\u{1}hasJavaStringCheckUtf8\0\u{1}hasJsonFormat\0\u{1}hasJsonName\0\u{1}hasJstype\0\u{1}hasLabel\0\u{1}hasLazy\0\u{1}hasLeadingComments\0\u{1}hasMapEntry\0\u{1}hasMaximumEdition\0\u{1}hasMessageEncoding\0\u{1}hasMessageSetWireFormat\0\u{1}hasMinimumEdition\0\u{1}hasName\0\u{1}hasNamePart\0\u{1}hasNegativeIntValue\0\u{1}hasNoStandardDescriptorAccessor\0\u{1}hasNumber\0\u{1}hasObjcClassPrefix\0\u{1}hasOneofIndex\0\u{1}hasOptimizeFor\0\u{1}hasOptions\0\u{1}hasOutputType\0\u{1}hasOverridableFeatures\0\u{1}hasPackage\0\u{1}hasPacked\0\u{1}hasPhpClassPrefix\0\u{1}hasPhpMetadataNamespace\0\u{1}hasPhpNamespace\0\u{1}hasPositiveIntValue\0\u{1}hasProto3Optional\0\u{1}hasPyGenericServices\0\u{1}hasRemovalError\0\u{1}hasRepeated\0\u{1}hasRepeatedFieldEncoding\0\u{1}hasReserved\0\u{1}hasRetention\0\u{1}hasRubyPackage\0\u{1}hasSemantic\0\u{1}hasServerStreaming\0\u{1}hasSourceCodeInfo\0\u{1}hasSourceContext\0\u{1}hasSourceFile\0\u{1}hasStart\0\u{1}hasStringValue\0\u{1}hasSwiftPrefix\0\u{1}hasSyntax\0\u{1}hasTrailingComments\0\u{1}hasType\0\u{1}hasTypeName\0\u{1}hasUnverifiedLazy\0\u{1}hasUtf8Validation\0\u{1}hasValue\0\u{1}hasVerification\0\u{1}hasVisibility\0\u{1}hasWeak\0\u{1}hour\0\u{1}i\0\u{1}idempotencyLevel\0\u{1}identifierValue\0\u{1}if\0\u{1}ignoreUnknownExtensionFields\0\u{1}ignoreUnknownFields\0\u{1}index\0\u{1}init\0\u{1}inout\0\u{1}inputType\0\u{1}insert\0\u{1}Instruction\0\u{1}Int\0\u{1}Int32\0\u{1}Int64\0\u{1}Int8\0\u{1}integerLiteral\0\u{1}IntegerLiteralType\0\u{1}intern\0\u{1}Internal\0\u{1}InternalState\0\u{1}intersect\0\u{1}into\0\u{1}ints\0\u{1}invalidAnyTypeURL\0\u{1}isA\0\u{1}isEqual\0\u{1}isEqualTo\0\u{1}isExtension\0\u{1}isInitialized\0\u{1}isNegative\0\u{1}isPathValid\0\u{1}isReserved\0\u{1}isValid\0\u{1}itemTagsEncodedSize\0\u{1}iterator\0\u{1}javaGenerateEqualsAndHash\0\u{1}javaGenericServices\0\u{1}javaMultipleFiles\0\u{1}javaOuterClassname\0\u{1}javaPackage\0\u{1}javaStringCheckUtf8\0\u{1}JSONDecoder\0\u{1}JSONDecoding\0\u{1}JSONDecodingError\0\u{1}JSONDecodingOptions\0\u{1}jsonEncoder\0\u{1}JSONEncoding\0\u{1}JSONEncodingError\0\u{1}JSONEncodingOptions\0\u{1}JSONEncodingVisitor\0\u{1}jsonFormat\0\u{1}JSONMapEncodingVisitor\0\u{1}jsonName\0\u{1}jsonPath\0\u{1}jsonPaths\0\u{1}JSONScanner\0\u{1}jsonString\0\u{1}jsonText\0\u{1}jsonUTF8Bytes\0\u{1}jsonUTF8Data\0\u{1}jstype\0\u{1}k\0\u{1}kChunkSize\0\u{1}Key\0\u{1}keyField\0\u{1}keyFieldOpt\0\u{1}KeyType\0\u{1}kind\0\u{1}l\0\u{1}label\0\u{1}lazy\0\u{1}leadingComments\0\u{1}leadingDetachedComments\0\u{1}length\0\u{1}lessThan\0\u{1}let\0\u{1}lhs\0\u{1}line\0\u{1}list\0\u{1}listOfMessages\0\u{1}listValue\0\u{1}littleEndian\0\u{1}load\0\u{1}localHasher\0\u{1}location\0\u{1}M\0\u{1}major\0\u{1}makeAsyncIterator\0\u{1}makeIterator\0\u{1}malformedLength\0\u{1}mapEntry\0\u{1}MapKeyType\0\u{1}mapToMessages\0\u{1}MapValueType\0\u{1}mapVisitor\0\u{1}mask\0\u{1}maximumEdition\0\u{1}mdayStart\0\u{1}merge\0\u{1}MergeOptions\0\u{1}message\0\u{1}messageDepthLimit\0\u{1}messageEncoding\0\u{1}MessageExtension\0\u{1}MessageImplementationBase\0\u{1}MessageSet\0\u{1}messageSetWireFormat\0\u{1}messageSize\0\u{1}messageType\0\u{1}method\0\u{1}methods\0\u{1}min\0\u{1}minimumEdition\0\u{1}minor\0\u{1}mixins\0\u{1}modify\0\u{1}month\0\u{1}msgExtension\0\u{1}mutating\0\u{1}n\0\u{1}name\0\u{1}NameDescription\0\u{1}NameMap\0\u{1}NamePart\0\u{1}names\0\u{1}nanos\0\u{1}negativeIntValue\0\u{1}nestedType\0\u{1}newExtensible\0\u{1}newL\0\u{1}newList\0\u{1}newMessage\0\u{1}newValue\0\u{1}next\0\u{1}nextByte\0\u{1}nextFieldNumber\0\u{1}nextInstruction\0\u{1}nextInt32\0\u{1}nextNullTerminatedString\0\u{1}nextNullTerminatedStringArray\0\u{1}nextNumber\0\u{1}nextUInt64\0\u{1}nextVarInt\0\u{1}nil\0\u{1}nilLiteral\0\u{1}noBytesAvailable\0\u{1}noStandardDescriptorAccessor\0\u{1}nullValue\0\u{1}number\0\u{1}numberValue\0\u{1}objcClassPrefix\0\u{1}of\0\u{1}OneOf_Kind\0\u{1}oneofDecl\0\u{1}oneofIndex\0\u{1}oneofs\0\u{1}optimizeFor\0\u{1}OptimizeMode\0\u{1}OptionalEnumExtensionField\0\u{1}OptionalExtensionField\0\u{1}OptionalGroupExtensionField\0\u{1}OptionalMessageExtensionField\0\u{1}optionDependency\0\u{1}OptionRetention\0\u{1}options\0\u{1}OptionTargetType\0\u{1}other\0\u{1}others\0\u{1}out\0\u{1}outputType\0\u{1}overridableFeatures\0\u{1}p\0\u{1}package\0\u{1}packed\0\u{1}PackedEnumExtensionField\0\u{1}PackedExtensionField\0\u{1}padding\0\u{1}parent\0\u{1}parse\0\u{1}partial\0\u{1}path\0\u{1}PathDecoder\0\u{1}PathDecodingError\0\u{1}paths\0\u{1}PathVisitor\0\u{1}payload\0\u{1}payloadSize\0\u{1}phpClassPrefix\0\u{1}phpMetadataNamespace\0\u{1}phpNamespace\0\u{1}pos\0\u{1}positiveIntValue\0\u{1}prefix\0\u{1}preserveProtoFieldNames\0\u{1}preTraverse\0\u{1}previousNumber\0\u{1}prevPath\0\u{1}printUnknownFields\0\u{1}programBuffer\0\u{1}programFormat\0\u{1}proto2\0\u{1}proto3DefaultValue\0\u{1}proto3Optional\0\u{1}protobuf_extensionFieldValues\0\u{1}protobuf_fieldNumber\0\u{1}protobuf_generated_isEqualTo\0\u{1}protobuf_nameMap\0\u{1}protobuf_newField\0\u{1}protobuf_package\0\u{1}ProtobufAPIVersion_2\0\u{1}ProtobufAPIVersionCheck\0\u{1}ProtobufBool\0\u{1}ProtobufBytes\0\u{1}protobufData\0\u{1}ProtobufDouble\0\u{1}ProtobufEnumMap\0\u{1}protobufExtension\0\u{1}ProtobufFixed32\0\u{1}ProtobufFixed64\0\u{1}ProtobufFloat\0\u{1}ProtobufInt32\0\u{1}ProtobufInt64\0\u{1}ProtobufMap\0\u{1}ProtobufMessageMap\0\u{1}ProtobufSFixed32\0\u{1}ProtobufSFixed64\0\u{1}ProtobufSInt32\0\u{1}ProtobufSInt64\0\u{1}ProtobufString\0\u{1}ProtobufUInt32\0\u{1}ProtobufUInt64\0\u{1}protocol\0\u{1}protoFieldName\0\u{1}protoMessageName\0\u{1}ProtoNameProviding\0\u{1}protoPaths\0\u{1}public\0\u{1}publicDependency\0\u{1}putBoolValue\0\u{1}putBytesValue\0\u{1}putDoubleValue\0\u{1}putEnumValue\0\u{1}putFixedUInt32\0\u{1}putFixedUInt64\0\u{1}putFloatValue\0\u{1}putInt64\0\u{1}putStringValue\0\u{1}putUInt64\0\u{1}putUInt64Hex\0\u{1}putVarInt\0\u{1}putZigZagVarInt\0\u{1}pyGenericServices\0\u{1}R\0\u{1}rawChars\0\u{1}RawRepresentable\0\u{1}RawValue\0\u{1}read4HexDigits\0\u{1}readBytes\0\u{1}reader\0\u{1}register\0\u{1}remainingProgram\0\u{1}removalError\0\u{1}removingAllFieldsOf\0\u{1}repeated\0\u{1}RepeatedEnumExtensionField\0\u{1}RepeatedExtensionField\0\u{1}repeatedFieldEncoding\0\u{1}RepeatedGroupExtensionField\0\u{1}RepeatedMessageExtensionField\0\u{1}repeating\0\u{1}replaceRepeatedFields\0\u{1}requestStreaming\0\u{1}requestTypeURL\0\u{1}requiredSize\0\u{1}responseStreaming\0\u{1}responseTypeURL\0\u{1}result\0\u{1}retention\0\u{1}rethrows\0\u{1}ReturnType\0\u{1}revision\0\u{1}rhs\0\u{1}root\0\u{1}rubyPackage\0\u{1}s\0\u{1}sawBackslash\0\u{1}sawSection4Characters\0\u{1}sawSection5Characters\0\u{1}Scalar\0\u{1}scan\0\u{1}scanner\0\u{1}seconds\0\u{1}self\0\u{1}semantic\0\u{1}Sendable\0\u{1}separator\0\u{1}serialize\0\u{1}serializedBytes\0\u{1}serializedData\0\u{1}serializedSize\0\u{1}serverStreaming\0\u{1}service\0\u{1}set\0\u{1}setExtensionValue\0\u{1}shift\0\u{1}SimpleExtensionMap\0\u{1}size\0\u{1}sizer\0\u{1}source\0\u{1}sourceCodeInfo\0\u{1}sourceContext\0\u{1}sourceEncoding\0\u{1}sourceFile\0\u{1}SourceLocation\0\u{1}span\0\u{1}split\0\u{1}start\0\u{1}startArray\0\u{1}startArrayObject\0\u{1}startField\0\u{1}startIndex\0\u{1}startMessageField\0\u{1}startObject\0\u{1}startRegularField\0\u{1}state\0\u{1}static\0\u{1}StaticString\0\u{1}storage\0\u{1}String\0\u{1}stringLiteral\0\u{1}StringLiteralType\0\u{1}stringResult\0\u{1}stringValue\0\u{1}struct\0\u{1}structValue\0\u{1}subDecoder\0\u{1}subscript\0\u{1}subtract\0\u{1}subVisitor\0\u{1}Swift\0\u{1}swiftPrefix\0\u{1}SwiftProtobufContiguousBytes\0\u{1}SwiftProtobufError\0\u{1}syntax\0\u{1}T\0\u{1}tag\0\u{1}targets\0\u{1}terminator\0\u{1}testDecoder\0\u{1}text\0\u{1}textDecoder\0\u{1}TextFormatDecoder\0\u{1}TextFormatDecodingError\0\u{1}TextFormatDecodingOptions\0\u{1}TextFormatEncodingOptions\0\u{1}TextFormatEncodingVisitor\0\u{1}textFormatString\0\u{1}throwOrIgnore\0\u{1}throws\0\u{1}timeInterval\0\u{1}timeIntervalSince1970\0\u{1}timeIntervalSinceReferenceDate\0\u{1}tmp\0\u{1}tooLarge\0\u{1}total\0\u{1}totalArrayDepth\0\u{1}totalSize\0\u{1}trailingComments\0\u{1}traverse\0\u{1}trim\0\u{1}true\0\u{1}try\0\u{1}type\0\u{1}typealias\0\u{1}TypeEnum\0\u{1}typeName\0\u{1}typePrefix\0\u{1}typeStart\0\u{1}typeUnknown\0\u{1}typeURL\0\u{1}UInt32\0\u{1}UInt64\0\u{1}UInt8\0\u{1}unchecked\0\u{1}Unicode\0\u{1}unicodeScalarLiteral\0\u{1}UnicodeScalarLiteralType\0\u{1}unicodeScalars\0\u{1}UnicodeScalarView\0\u{1}uninterpretedOption\0\u{1}union\0\u{1}uniqueStorage\0\u{1}unknown\0\u{1}unknownFields\0\u{1}UnknownStorage\0\u{1}unpackTo\0\u{1}UnsafeBufferPointer\0\u{1}UnsafeMutablePointer\0\u{1}UnsafeMutableRawBufferPointer\0\u{1}UnsafeRawBufferPointer\0\u{1}UnsafeRawPointer\0\u{1}unverifiedLazy\0\u{1}updatedOptions\0\u{1}uppercasedAssumingASCII\0\u{1}url\0\u{1}useDeterministicOrdering\0\u{1}utf8\0\u{1}utf8Ptr\0\u{1}utf8ToDouble\0\u{1}utf8Validation\0\u{1}UTF8View\0\u{1}V\0\u{1}value\0\u{1}valueField\0\u{1}values\0\u{1}ValueType\0\u{1}var\0\u{1}verification\0\u{1}VerificationState\0\u{1}version\0\u{1}versionString\0\u{1}visibility\0\u{1}VisibilityFeature\0\u{1}visitExtensionFields\0\u{1}visitExtensionFieldsAsMessageSet\0\u{1}visitMapField\0\u{1}Visitor\0\u{1}visitPacked\0\u{1}visitPackedBoolField\0\u{1}visitPackedDoubleField\0\u{1}visitPackedEnumField\0\u{1}visitPackedFixed32Field\0\u{1}visitPackedFixed64Field\0\u{1}visitPackedFloatField\0\u{1}visitPackedInt32Field\0\u{1}visitPackedInt64Field\0\u{1}visitPackedSFixed32Field\0\u{1}visitPackedSFixed64Field\0\u{1}visitPackedSInt32Field\0\u{1}visitPackedSInt64Field\0\u{1}visitPackedUInt32Field\0\u{1}visitPackedUInt64Field\0\u{1}visitRepeated\0\u{1}visitRepeatedBoolField\0\u{1}visitRepeatedBytesField\0\u{1}visitRepeatedDoubleField\0\u{1}visitRepeatedEnumField\0\u{1}visitRepeatedFixed32Field\0\u{1}visitRepeatedFixed64Field\0\u{1}visitRepeatedFloatField\0\u{1}visitRepeatedGroupField\0\u{1}visitRepeatedInt32Field\0\u{1}visitRepeatedInt64Field\0\u{1}visitRepeatedMessageField\0\u{1}visitRepeatedSFixed32Field\0\u{1}visitRepeatedSFixed64Field\0\u{1}visitRepeatedSInt32Field\0\u{1}visitRepeatedSInt64Field\0\u{1}visitRepeatedStringField\0\u{1}visitRepeatedUInt32Field\0\u{1}visitRepeatedUInt64Field\0\u{1}visitSingular\0\u{1}visitSingularBoolField\0\u{1}visitSingularBytesField\0\u{1}visitSingularDoubleField\0\u{1}visitSingularEnumField\0\u{1}visitSingularFixed32Field\0\u{1}visitSingularFixed64Field\0\u{1}visitSingularFloatField\0\u{1}visitSingularGroupField\0\u{1}visitSingularInt32Field\0\u{1}visitSingularInt64Field\0\u{1}visitSingularMessageField\0\u{1}visitSingularSFixed32Field\0\u{1}visitSingularSFixed64Field\0\u{1}visitSingularSInt32Field\0\u{1}visitSingularSInt64Field\0\u{1}visitSingularStringField\0\u{1}visitSingularUInt32Field\0\u{1}visitSingularUInt64Field\0\u{1}visitUnknown\0\u{1}Void\0\u{1}wasDecoded\0\u{1}weak\0\u{1}weakDependency\0\u{1}where\0\u{1}wireFormat\0\u{1}with\0\u{1}withUnsafeBytes\0\u{1}withUnsafeMutableBytes\0\u{1}work\0\u{1}Wrapped\0\u{1}WrappedType\0\u{1}wrappedValue\0\u{1}written\0\u{1}yday\0") } diff --git a/Tests/SwiftProtobufTests/generated_swift_names_enums.pb.swift b/Tests/SwiftProtobufTests/generated_swift_names_enums.pb.swift index 2b63bc96e..bd944f898 100644 --- a/Tests/SwiftProtobufTests/generated_swift_names_enums.pb.swift +++ b/Tests/SwiftProtobufTests/generated_swift_names_enums.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: generated_swift_names_enums.proto @@ -11,7 +12,6 @@ /// Protoc errors imply this file is being generated incorrectly /// Swift compile errors are probably bugs in protoc-gen-swift -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -24,14 +24,44 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { +struct SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums: Sendable { // 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() - enum adjusted: SwiftProtobuf.Enum { + enum addPath: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAddPath // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAddPath + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAddPath + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAddPath: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.addPath] = [ + .noneAddPath, + ] + + } + + enum adjusted: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAdjusted // = 0 case UNRECOGNIZED(Int) @@ -54,9 +84,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.adjusted] = [ + .noneAdjusted, + ] + } - enum aggregateValue: SwiftProtobuf.Enum { + enum aggregateValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAggregateValue // = 0 case UNRECOGNIZED(Int) @@ -79,9 +114,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.aggregateValue] = [ + .noneAggregateValue, + ] + } - enum allCases: SwiftProtobuf.Enum { + enum allCases: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAllCases // = 0 case UNRECOGNIZED(Int) @@ -104,9 +144,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.allCases] = [ + .noneAllCases, + ] + } - enum allowAlias: SwiftProtobuf.Enum { + enum allowAlias: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAllowAlias // = 0 case UNRECOGNIZED(Int) @@ -129,9 +174,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.allowAlias] = [ + .noneAllowAlias, + ] + } - enum alwaysPrintEnumsAsInts: SwiftProtobuf.Enum { + enum alwaysPrintEnumsAsInts: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAlwaysPrintEnumsAsInts // = 0 case UNRECOGNIZED(Int) @@ -154,9 +204,44 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.alwaysPrintEnumsAsInts] = [ + .noneAlwaysPrintEnumsAsInts, + ] + + } + + enum alwaysPrintInt64sAsNumbers: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAlwaysPrintInt64SAsNumbers // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAlwaysPrintInt64SAsNumbers + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAlwaysPrintInt64SAsNumbers + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAlwaysPrintInt64SAsNumbers: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.alwaysPrintInt64sAsNumbers] = [ + .noneAlwaysPrintInt64SAsNumbers, + ] + } - enum annotation: SwiftProtobuf.Enum { + enum annotation: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAnnotation // = 0 case UNRECOGNIZED(Int) @@ -179,9 +264,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.annotation] = [ + .noneAnnotation, + ] + } - enum any: SwiftProtobuf.Enum { + enum any: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAny // = 0 case UNRECOGNIZED(Int) @@ -204,9 +294,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.any] = [ + .noneAny, + ] + } - enum AnyExtensionField: SwiftProtobuf.Enum { + enum AnyExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAnyExtensionField // = 0 case UNRECOGNIZED(Int) @@ -229,9 +324,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyExtensionField] = [ + .noneAnyExtensionField, + ] + } - enum AnyMessageExtension: SwiftProtobuf.Enum { + enum AnyMessageExtension: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAnyMessageExtension // = 0 case UNRECOGNIZED(Int) @@ -254,9 +354,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyMessageExtension] = [ + .noneAnyMessageExtension, + ] + } - enum AnyMessageStorage: SwiftProtobuf.Enum { + enum AnyMessageStorage: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAnyMessageStorage // = 0 case UNRECOGNIZED(Int) @@ -279,9 +384,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyMessageStorage] = [ + .noneAnyMessageStorage, + ] + } - enum AnyUnpackError: SwiftProtobuf.Enum { + enum AnyUnpackError: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAnyUnpackError // = 0 case UNRECOGNIZED(Int) @@ -304,34 +414,44 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyUnpackError] = [ + .noneAnyUnpackError, + ] + } - enum Api: SwiftProtobuf.Enum { + enum append: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneApi // = 0 + case noneAppend // = 0 case UNRECOGNIZED(Int) init() { - self = .noneApi + self = .noneAppend } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneApi + case 0: self = .noneAppend default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneApi: return 0 + case .noneAppend: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.append] = [ + .noneAppend, + ] + } - enum appended: SwiftProtobuf.Enum { + enum appended: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAppended // = 0 case UNRECOGNIZED(Int) @@ -354,9 +474,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.appended] = [ + .noneAppended, + ] + } - enum appendUIntHex: SwiftProtobuf.Enum { + enum appendUIntHex: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAppendUintHex // = 0 case UNRECOGNIZED(Int) @@ -379,9 +504,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.appendUIntHex] = [ + .noneAppendUintHex, + ] + } - enum appendUnknown: SwiftProtobuf.Enum { + enum appendUnknown: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAppendUnknown // = 0 case UNRECOGNIZED(Int) @@ -404,9 +534,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.appendUnknown] = [ + .noneAppendUnknown, + ] + } - enum areAllInitialized: SwiftProtobuf.Enum { + enum areAllInitialized: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAreAllInitialized // = 0 case UNRECOGNIZED(Int) @@ -429,9 +564,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.areAllInitialized] = [ + .noneAreAllInitialized, + ] + } - enum array: SwiftProtobuf.Enum { + enum Array: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneArray // = 0 case UNRECOGNIZED(Int) @@ -454,9 +594,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Array] = [ + .noneArray, + ] + } - enum arrayDepth: SwiftProtobuf.Enum { + enum arrayDepth: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneArrayDepth // = 0 case UNRECOGNIZED(Int) @@ -479,9 +624,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.arrayDepth] = [ + .noneArrayDepth, + ] + } - enum arrayLiteral: SwiftProtobuf.Enum { + enum arrayLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneArrayLiteral // = 0 case UNRECOGNIZED(Int) @@ -504,9 +654,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.arrayLiteral] = [ + .noneArrayLiteral, + ] + } - enum arraySeparator: SwiftProtobuf.Enum { + enum arraySeparator: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneArraySeparator // = 0 case UNRECOGNIZED(Int) @@ -529,9 +684,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.arraySeparator] = [ + .noneArraySeparator, + ] + } - enum asEnum: SwiftProtobuf.Enum { + enum asEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAs // = 0 case UNRECOGNIZED(Int) @@ -554,9 +714,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.asEnum] = [ + .noneAs, + ] + } - enum asciiOpenCurlyBracket: SwiftProtobuf.Enum { + enum asciiOpenCurlyBracket: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAsciiOpenCurlyBracket // = 0 case UNRECOGNIZED(Int) @@ -579,9 +744,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.asciiOpenCurlyBracket] = [ + .noneAsciiOpenCurlyBracket, + ] + } - enum asciiZero: SwiftProtobuf.Enum { + enum asciiZero: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAsciiZero // = 0 case UNRECOGNIZED(Int) @@ -604,9 +774,134 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.asciiZero] = [ + .noneAsciiZero, + ] + + } + + enum async: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAsync // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAsync + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAsync + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAsync: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.async] = [ + .noneAsync, + ] + + } + + enum AsyncIterator: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAsyncIterator // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAsyncIterator + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAsyncIterator + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAsyncIterator: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AsyncIterator] = [ + .noneAsyncIterator, + ] + + } + + enum AsyncIteratorProtocol: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAsyncIteratorProtocol // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAsyncIteratorProtocol + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAsyncIteratorProtocol + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAsyncIteratorProtocol: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AsyncIteratorProtocol] = [ + .noneAsyncIteratorProtocol, + ] + + } + + enum AsyncMessageSequence: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneAsyncMessageSequence // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneAsyncMessageSequence + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneAsyncMessageSequence + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneAsyncMessageSequence: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AsyncMessageSequence] = [ + .noneAsyncMessageSequence, + ] + } - enum available: SwiftProtobuf.Enum { + enum available: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneAvailable // = 0 case UNRECOGNIZED(Int) @@ -629,9 +924,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.available] = [ + .noneAvailable, + ] + } - enum b: SwiftProtobuf.Enum { + enum b: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneB // = 0 case UNRECOGNIZED(Int) @@ -654,9 +954,44 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.b] = [ + .noneB, + ] + + } + + enum Base: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBase // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBase + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBase + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBase: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Base] = [ + .noneBase, + ] + } - enum base64Values: SwiftProtobuf.Enum { + enum base64Values: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneBase64Values // = 0 case UNRECOGNIZED(Int) @@ -679,9 +1014,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.base64Values] = [ + .noneBase64Values, + ] + } - enum baseAddress: SwiftProtobuf.Enum { + enum baseAddress: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneBaseAddress // = 0 case UNRECOGNIZED(Int) @@ -704,9 +1044,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.baseAddress] = [ + .noneBaseAddress, + ] + } - enum BaseType: SwiftProtobuf.Enum { + enum BaseType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneBaseType // = 0 case UNRECOGNIZED(Int) @@ -729,9 +1074,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BaseType] = [ + .noneBaseType, + ] + } - enum begin: SwiftProtobuf.Enum { + enum begin: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneBegin // = 0 case UNRECOGNIZED(Int) @@ -754,9 +1104,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.begin] = [ + .noneBegin, + ] + } - enum binary: SwiftProtobuf.Enum { + enum binary: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneBinary // = 0 case UNRECOGNIZED(Int) @@ -779,9 +1134,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binary] = [ + .noneBinary, + ] + } - enum BinaryDecoder: SwiftProtobuf.Enum { + enum BinaryDecoder: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneBinaryDecoder // = 0 case UNRECOGNIZED(Int) @@ -804,9 +1164,44 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecoder] = [ + .noneBinaryDecoder, + ] + + } + + enum BinaryDecoding: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinaryDecoding // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinaryDecoding + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinaryDecoding + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinaryDecoding: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecoding] = [ + .noneBinaryDecoding, + ] + } - enum BinaryDecodingError: SwiftProtobuf.Enum { + enum BinaryDecodingError: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneBinaryDecodingError // = 0 case UNRECOGNIZED(Int) @@ -829,9 +1224,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecodingError] = [ + .noneBinaryDecodingError, + ] + } - enum BinaryDecodingOptions: SwiftProtobuf.Enum { + enum BinaryDecodingOptions: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneBinaryDecodingOptions // = 0 case UNRECOGNIZED(Int) @@ -854,9 +1254,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecodingOptions] = [ + .noneBinaryDecodingOptions, + ] + } - enum BinaryDelimited: SwiftProtobuf.Enum { + enum BinaryDelimited: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneBinaryDelimited // = 0 case UNRECOGNIZED(Int) @@ -879,9 +1284,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDelimited] = [ + .noneBinaryDelimited, + ] + } - enum BinaryEncoder: SwiftProtobuf.Enum { + enum BinaryEncoder: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneBinaryEncoder // = 0 case UNRECOGNIZED(Int) @@ -904,9 +1314,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncoder] = [ + .noneBinaryEncoder, + ] + } - enum BinaryEncodingError: SwiftProtobuf.Enum { + enum BinaryEncodingError: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneBinaryEncodingError // = 0 case UNRECOGNIZED(Int) @@ -929,9 +1344,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingError] = [ + .noneBinaryEncodingError, + ] + } - enum BinaryEncodingMessageSetSizeVisitor: SwiftProtobuf.Enum { + enum BinaryEncodingMessageSetSizeVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneBinaryEncodingMessageSetSizeVisitor // = 0 case UNRECOGNIZED(Int) @@ -954,9 +1374,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetSizeVisitor] = [ + .noneBinaryEncodingMessageSetSizeVisitor, + ] + } - enum BinaryEncodingMessageSetVisitor: SwiftProtobuf.Enum { + enum BinaryEncodingMessageSetVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneBinaryEncodingMessageSetVisitor // = 0 case UNRECOGNIZED(Int) @@ -979,9 +1404,44 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetVisitor] = [ + .noneBinaryEncodingMessageSetVisitor, + ] + + } + + enum BinaryEncodingOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneBinaryEncodingOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneBinaryEncodingOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneBinaryEncodingOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneBinaryEncodingOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingOptions] = [ + .noneBinaryEncodingOptions, + ] + } - enum BinaryEncodingSizeVisitor: SwiftProtobuf.Enum { + enum BinaryEncodingSizeVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneBinaryEncodingSizeVisitor // = 0 case UNRECOGNIZED(Int) @@ -1004,9 +1464,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingSizeVisitor] = [ + .noneBinaryEncodingSizeVisitor, + ] + } - enum BinaryEncodingVisitor: SwiftProtobuf.Enum { + enum BinaryEncodingVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneBinaryEncodingVisitor // = 0 case UNRECOGNIZED(Int) @@ -1029,9 +1494,14 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingVisitor] = [ + .noneBinaryEncodingVisitor, + ] + } - enum binaryOptions: SwiftProtobuf.Enum { + enum binaryOptions: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case noneBinaryOptions // = 0 case UNRECOGNIZED(Int) @@ -1054,32904 +1524,33453 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedEnums { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binaryOptions] = [ + .noneBinaryOptions, + ] + } - enum body: SwiftProtobuf.Enum { + enum binaryProtobufDelimitedMessages: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneBody // = 0 + case noneBinaryProtobufDelimitedMessages // = 0 case UNRECOGNIZED(Int) init() { - self = .noneBody + self = .noneBinaryProtobufDelimitedMessages } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneBody + case 0: self = .noneBinaryProtobufDelimitedMessages default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneBody: return 0 + case .noneBinaryProtobufDelimitedMessages: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binaryProtobufDelimitedMessages] = [ + .noneBinaryProtobufDelimitedMessages, + ] + } - enum BoolEnum: SwiftProtobuf.Enum { + enum BinaryStreamDecoding: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneBool // = 0 + case noneBinaryStreamDecoding // = 0 case UNRECOGNIZED(Int) init() { - self = .noneBool + self = .noneBinaryStreamDecoding } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneBool + case 0: self = .noneBinaryStreamDecoding default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneBool: return 0 + case .noneBinaryStreamDecoding: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryStreamDecoding] = [ + .noneBinaryStreamDecoding, + ] + } - enum booleanLiteral: SwiftProtobuf.Enum { + enum binaryStreamDecodingError: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneBooleanLiteral // = 0 + case noneBinaryStreamDecodingError // = 0 case UNRECOGNIZED(Int) init() { - self = .noneBooleanLiteral + self = .noneBinaryStreamDecodingError } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneBooleanLiteral + case 0: self = .noneBinaryStreamDecodingError default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneBooleanLiteral: return 0 + case .noneBinaryStreamDecodingError: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binaryStreamDecodingError] = [ + .noneBinaryStreamDecodingError, + ] + } - enum BooleanLiteralType: SwiftProtobuf.Enum { + enum bitPattern: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneBooleanLiteralType // = 0 + case noneBitPattern // = 0 case UNRECOGNIZED(Int) init() { - self = .noneBooleanLiteralType + self = .noneBitPattern } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneBooleanLiteralType + case 0: self = .noneBitPattern default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneBooleanLiteralType: return 0 + case .noneBitPattern: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bitPattern] = [ + .noneBitPattern, + ] + } - enum boolValue: SwiftProtobuf.Enum { + enum body: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneBoolValue // = 0 + case noneBody // = 0 case UNRECOGNIZED(Int) init() { - self = .noneBoolValue + self = .noneBody } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneBoolValue + case 0: self = .noneBody default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneBoolValue: return 0 + case .noneBody: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.body] = [ + .noneBody, + ] + } - enum bytes: SwiftProtobuf.Enum { + enum BoolEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneBytes // = 0 + case noneBool // = 0 case UNRECOGNIZED(Int) init() { - self = .noneBytes + self = .noneBool } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneBytes + case 0: self = .noneBool default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneBytes: return 0 + case .noneBool: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BoolEnum] = [ + .noneBool, + ] + } - enum bytesInGroup: SwiftProtobuf.Enum { + enum booleanLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneBytesInGroup // = 0 + case noneBooleanLiteral // = 0 case UNRECOGNIZED(Int) init() { - self = .noneBytesInGroup + self = .noneBooleanLiteral } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneBytesInGroup + case 0: self = .noneBooleanLiteral default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneBytesInGroup: return 0 + case .noneBooleanLiteral: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.booleanLiteral] = [ + .noneBooleanLiteral, + ] + } - enum bytesRead: SwiftProtobuf.Enum { + enum BooleanLiteralType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneBytesRead // = 0 + case noneBooleanLiteralType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneBytesRead + self = .noneBooleanLiteralType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneBytesRead + case 0: self = .noneBooleanLiteralType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneBytesRead: return 0 + case .noneBooleanLiteralType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BooleanLiteralType] = [ + .noneBooleanLiteralType, + ] + } - enum BytesValue: SwiftProtobuf.Enum { + enum boolValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneBytesValue // = 0 + case noneBoolValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneBytesValue + self = .noneBoolValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneBytesValue + case 0: self = .noneBoolValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneBytesValue: return 0 + case .noneBoolValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.boolValue] = [ + .noneBoolValue, + ] + } - enum c: SwiftProtobuf.Enum { + enum buffer: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneC // = 0 + case noneBuffer // = 0 case UNRECOGNIZED(Int) init() { - self = .noneC + self = .noneBuffer } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneC + case 0: self = .noneBuffer default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneC: return 0 + case .noneBuffer: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.buffer] = [ + .noneBuffer, + ] + } - enum capitalizeNext: SwiftProtobuf.Enum { + enum byte: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneCapitalizeNext // = 0 + case noneByte // = 0 case UNRECOGNIZED(Int) init() { - self = .noneCapitalizeNext + self = .noneByte } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneCapitalizeNext + case 0: self = .noneByte default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneCapitalizeNext: return 0 + case .noneByte: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.byte] = [ + .noneByte, + ] + } - enum cardinality: SwiftProtobuf.Enum { + enum bytecode: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneCardinality // = 0 + case noneBytecode // = 0 case UNRECOGNIZED(Int) init() { - self = .noneCardinality + self = .noneBytecode } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneCardinality + case 0: self = .noneBytecode default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneCardinality: return 0 + case .noneBytecode: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytecode] = [ + .noneBytecode, + ] + } - enum ccEnableArenas: SwiftProtobuf.Enum { + enum BytecodeReader: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneCcEnableArenas // = 0 + case noneBytecodeReader // = 0 case UNRECOGNIZED(Int) init() { - self = .noneCcEnableArenas + self = .noneBytecodeReader } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneCcEnableArenas + case 0: self = .noneBytecodeReader default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneCcEnableArenas: return 0 + case .noneBytecodeReader: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BytecodeReader] = [ + .noneBytecodeReader, + ] + } - enum ccGenericServices: SwiftProtobuf.Enum { + enum bytes: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneCcGenericServices // = 0 + case noneBytes // = 0 case UNRECOGNIZED(Int) init() { - self = .noneCcGenericServices + self = .noneBytes } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneCcGenericServices + case 0: self = .noneBytes default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneCcGenericServices: return 0 + case .noneBytes: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytes] = [ + .noneBytes, + ] + } - enum Character: SwiftProtobuf.Enum { + enum bytesInGroup: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneCharacter // = 0 + case noneBytesInGroup // = 0 case UNRECOGNIZED(Int) init() { - self = .noneCharacter + self = .noneBytesInGroup } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneCharacter + case 0: self = .noneBytesInGroup default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneCharacter: return 0 + case .noneBytesInGroup: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytesInGroup] = [ + .noneBytesInGroup, + ] + } - enum chars: SwiftProtobuf.Enum { + enum bytesNeeded: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneChars // = 0 + case noneBytesNeeded // = 0 case UNRECOGNIZED(Int) init() { - self = .noneChars + self = .noneBytesNeeded } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneChars + case 0: self = .noneBytesNeeded default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneChars: return 0 + case .noneBytesNeeded: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytesNeeded] = [ + .noneBytesNeeded, + ] + } - enum classEnum: SwiftProtobuf.Enum { + enum bytesRead: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClass // = 0 + case noneBytesRead // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClass + self = .noneBytesRead } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClass + case 0: self = .noneBytesRead default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClass: return 0 + case .noneBytesRead: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytesRead] = [ + .noneBytesRead, + ] + } - enum clearAggregateValue: SwiftProtobuf.Enum { + enum c: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearAggregateValue // = 0 + case noneC // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearAggregateValue + self = .noneC } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearAggregateValue + case 0: self = .noneC default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearAggregateValue: return 0 + case .noneC: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.c] = [ + .noneC, + ] + } - enum clearAllowAlias: SwiftProtobuf.Enum { + enum canonical: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearAllowAlias // = 0 + case noneCanonical // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearAllowAlias + self = .noneCanonical } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearAllowAlias + case 0: self = .noneCanonical default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearAllowAlias: return 0 + case .noneCanonical: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.canonical] = [ + .noneCanonical, + ] + } - enum clearBegin: SwiftProtobuf.Enum { + enum capitalizeNext: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearBegin // = 0 + case noneCapitalizeNext // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearBegin + self = .noneCapitalizeNext } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearBegin + case 0: self = .noneCapitalizeNext default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearBegin: return 0 + case .noneCapitalizeNext: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.capitalizeNext] = [ + .noneCapitalizeNext, + ] + } - enum clearCcEnableArenas: SwiftProtobuf.Enum { + enum cardinality: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearCcEnableArenas // = 0 + case noneCardinality // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearCcEnableArenas + self = .noneCardinality } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearCcEnableArenas + case 0: self = .noneCardinality default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearCcEnableArenas: return 0 + case .noneCardinality: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.cardinality] = [ + .noneCardinality, + ] + } - enum clearCcGenericServices: SwiftProtobuf.Enum { + enum CaseIterable: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearCcGenericServices // = 0 + case noneCaseIterable // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearCcGenericServices + self = .noneCaseIterable } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearCcGenericServices + case 0: self = .noneCaseIterable default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearCcGenericServices: return 0 + case .noneCaseIterable: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.CaseIterable] = [ + .noneCaseIterable, + ] + } - enum clearClientStreaming: SwiftProtobuf.Enum { + enum castedValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearClientStreaming // = 0 + case noneCastedValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearClientStreaming + self = .noneCastedValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearClientStreaming + case 0: self = .noneCastedValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearClientStreaming: return 0 + case .noneCastedValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.castedValue] = [ + .noneCastedValue, + ] + } - enum clearCsharpNamespace: SwiftProtobuf.Enum { + enum ccEnableArenas: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearCsharpNamespace // = 0 + case noneCcEnableArenas // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearCsharpNamespace + self = .noneCcEnableArenas } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearCsharpNamespace + case 0: self = .noneCcEnableArenas default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearCsharpNamespace: return 0 + case .noneCcEnableArenas: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ccEnableArenas] = [ + .noneCcEnableArenas, + ] + } - enum clearCtype: SwiftProtobuf.Enum { + enum ccGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearCtype // = 0 + case noneCcGenericServices // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearCtype + self = .noneCcGenericServices } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearCtype + case 0: self = .noneCcGenericServices default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearCtype: return 0 + case .noneCcGenericServices: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ccGenericServices] = [ + .noneCcGenericServices, + ] + } - enum clearDefaultValue: SwiftProtobuf.Enum { + enum Character: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearDefaultValue // = 0 + case noneCharacter // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearDefaultValue + self = .noneCharacter } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearDefaultValue + case 0: self = .noneCharacter default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearDefaultValue: return 0 + case .noneCharacter: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Character] = [ + .noneCharacter, + ] + } - enum clearDeprecated: SwiftProtobuf.Enum { + enum chars: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearDeprecated // = 0 + case noneChars // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearDeprecated + self = .noneChars } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearDeprecated + case 0: self = .noneChars default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearDeprecated: return 0 + case .noneChars: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.chars] = [ + .noneChars, + ] + } - enum clearDoubleValue: SwiftProtobuf.Enum { + enum checkProgramFormat: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearDoubleValue // = 0 + case noneCheckProgramFormat // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearDoubleValue + self = .noneCheckProgramFormat } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearDoubleValue + case 0: self = .noneCheckProgramFormat default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearDoubleValue: return 0 + case .noneCheckProgramFormat: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.checkProgramFormat] = [ + .noneCheckProgramFormat, + ] + } - enum clearEnd: SwiftProtobuf.Enum { + enum chunk: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearEnd // = 0 + case noneChunk // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearEnd + self = .noneChunk } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearEnd + case 0: self = .noneChunk default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearEnd: return 0 + case .noneChunk: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.chunk] = [ + .noneChunk, + ] + } - enum clearExtendee: SwiftProtobuf.Enum { + enum classEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearExtendee // = 0 + case noneClass // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearExtendee + self = .noneClass } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearExtendee + case 0: self = .noneClass default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearExtendee: return 0 + case .noneClass: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.classEnum] = [ + .noneClass, + ] + } - enum clearExtensionValue: SwiftProtobuf.Enum { + enum clearAggregateValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearExtensionValue // = 0 + case noneClearAggregateValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearExtensionValue + self = .noneClearAggregateValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearExtensionValue + case 0: self = .noneClearAggregateValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearExtensionValue: return 0 + case .noneClearAggregateValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearAggregateValue] = [ + .noneClearAggregateValue, + ] + } - enum clearGoPackage: SwiftProtobuf.Enum { + enum clearAllowAlias: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearGoPackage // = 0 + case noneClearAllowAlias // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearGoPackage + self = .noneClearAllowAlias } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearGoPackage + case 0: self = .noneClearAllowAlias default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearGoPackage: return 0 + case .noneClearAllowAlias: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearAllowAlias] = [ + .noneClearAllowAlias, + ] + } - enum clearIdempotencyLevel: SwiftProtobuf.Enum { + enum clearBegin: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearIdempotencyLevel // = 0 + case noneClearBegin // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearIdempotencyLevel + self = .noneClearBegin } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearIdempotencyLevel + case 0: self = .noneClearBegin default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearIdempotencyLevel: return 0 + case .noneClearBegin: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearBegin] = [ + .noneClearBegin, + ] + } - enum clearIdentifierValue: SwiftProtobuf.Enum { + enum clearCcEnableArenas: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearIdentifierValue // = 0 + case noneClearCcEnableArenas // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearIdentifierValue + self = .noneClearCcEnableArenas } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearIdentifierValue + case 0: self = .noneClearCcEnableArenas default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearIdentifierValue: return 0 + case .noneClearCcEnableArenas: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCcEnableArenas] = [ + .noneClearCcEnableArenas, + ] + } - enum clearInputType: SwiftProtobuf.Enum { + enum clearCcGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearInputType // = 0 + case noneClearCcGenericServices // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearInputType + self = .noneClearCcGenericServices } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearInputType + case 0: self = .noneClearCcGenericServices default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearInputType: return 0 + case .noneClearCcGenericServices: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCcGenericServices] = [ + .noneClearCcGenericServices, + ] + } - enum clearIsExtension: SwiftProtobuf.Enum { + enum clearClientStreaming: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearIsExtension // = 0 + case noneClearClientStreaming // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearIsExtension + self = .noneClearClientStreaming } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearIsExtension + case 0: self = .noneClearClientStreaming default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearIsExtension: return 0 + case .noneClearClientStreaming: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearClientStreaming] = [ + .noneClearClientStreaming, + ] + } - enum clearJavaGenerateEqualsAndHash: SwiftProtobuf.Enum { + enum clearCsharpNamespace: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearJavaGenerateEqualsAndHash // = 0 + case noneClearCsharpNamespace // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearJavaGenerateEqualsAndHash + self = .noneClearCsharpNamespace } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearJavaGenerateEqualsAndHash + case 0: self = .noneClearCsharpNamespace default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearJavaGenerateEqualsAndHash: return 0 + case .noneClearCsharpNamespace: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCsharpNamespace] = [ + .noneClearCsharpNamespace, + ] + } - enum clearJavaGenericServices: SwiftProtobuf.Enum { + enum clearCtype: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearJavaGenericServices // = 0 + case noneClearCtype // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearJavaGenericServices + self = .noneClearCtype } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearJavaGenericServices + case 0: self = .noneClearCtype default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearJavaGenericServices: return 0 + case .noneClearCtype: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCtype] = [ + .noneClearCtype, + ] + } - enum clearJavaMultipleFiles: SwiftProtobuf.Enum { + enum clearDebugRedact: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearJavaMultipleFiles // = 0 + case noneClearDebugRedact // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearJavaMultipleFiles + self = .noneClearDebugRedact } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearJavaMultipleFiles + case 0: self = .noneClearDebugRedact default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearJavaMultipleFiles: return 0 + case .noneClearDebugRedact: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDebugRedact] = [ + .noneClearDebugRedact, + ] + } - enum clearJavaOuterClassname: SwiftProtobuf.Enum { + enum clearDefaultSymbolVisibility: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearJavaOuterClassname // = 0 + case noneClearDefaultSymbolVisibility // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearJavaOuterClassname + self = .noneClearDefaultSymbolVisibility } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearJavaOuterClassname + case 0: self = .noneClearDefaultSymbolVisibility default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearJavaOuterClassname: return 0 + case .noneClearDefaultSymbolVisibility: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDefaultSymbolVisibility] = [ + .noneClearDefaultSymbolVisibility, + ] + } - enum clearJavaPackage: SwiftProtobuf.Enum { + enum clearDefaultValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearJavaPackage // = 0 + case noneClearDefaultValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearJavaPackage + self = .noneClearDefaultValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearJavaPackage + case 0: self = .noneClearDefaultValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearJavaPackage: return 0 + case .noneClearDefaultValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDefaultValue] = [ + .noneClearDefaultValue, + ] + } - enum clearJavaStringCheckUtf8: SwiftProtobuf.Enum { + enum clearDeprecated: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearJavaStringCheckUtf8 // = 0 + case noneClearDeprecated // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearJavaStringCheckUtf8 + self = .noneClearDeprecated } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearJavaStringCheckUtf8 + case 0: self = .noneClearDeprecated default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearJavaStringCheckUtf8: return 0 + case .noneClearDeprecated: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDeprecated] = [ + .noneClearDeprecated, + ] + } - enum clearJsonName: SwiftProtobuf.Enum { + enum clearDeprecatedLegacyJsonFieldConflicts: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearJsonName // = 0 + case noneClearDeprecatedLegacyJsonFieldConflicts // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearJsonName + self = .noneClearDeprecatedLegacyJsonFieldConflicts } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearJsonName + case 0: self = .noneClearDeprecatedLegacyJsonFieldConflicts default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearJsonName: return 0 + case .noneClearDeprecatedLegacyJsonFieldConflicts: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDeprecatedLegacyJsonFieldConflicts] = [ + .noneClearDeprecatedLegacyJsonFieldConflicts, + ] + } - enum clearJstype: SwiftProtobuf.Enum { + enum clearDeprecationWarning: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearJstype // = 0 + case noneClearDeprecationWarning // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearJstype + self = .noneClearDeprecationWarning } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearJstype + case 0: self = .noneClearDeprecationWarning default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearJstype: return 0 + case .noneClearDeprecationWarning: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDeprecationWarning] = [ + .noneClearDeprecationWarning, + ] + } - enum clearLabel: SwiftProtobuf.Enum { + enum clearDoubleValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearLabel // = 0 + case noneClearDoubleValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearLabel + self = .noneClearDoubleValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearLabel + case 0: self = .noneClearDoubleValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearLabel: return 0 + case .noneClearDoubleValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDoubleValue] = [ + .noneClearDoubleValue, + ] + } - enum clearLazy: SwiftProtobuf.Enum { + enum clearEdition: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearLazy // = 0 + case noneClearEdition // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearLazy + self = .noneClearEdition } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearLazy + case 0: self = .noneClearEdition default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearLazy: return 0 + case .noneClearEdition: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEdition] = [ + .noneClearEdition, + ] + } - enum clearLeadingComments: SwiftProtobuf.Enum { + enum clearEditionDeprecated: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearLeadingComments // = 0 + case noneClearEditionDeprecated // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearLeadingComments + self = .noneClearEditionDeprecated } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearLeadingComments + case 0: self = .noneClearEditionDeprecated default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearLeadingComments: return 0 + case .noneClearEditionDeprecated: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEditionDeprecated] = [ + .noneClearEditionDeprecated, + ] + } - enum clearMapEntry: SwiftProtobuf.Enum { + enum clearEditionIntroduced: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearMapEntry // = 0 + case noneClearEditionIntroduced // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearMapEntry + self = .noneClearEditionIntroduced } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearMapEntry + case 0: self = .noneClearEditionIntroduced default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearMapEntry: return 0 + case .noneClearEditionIntroduced: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEditionIntroduced] = [ + .noneClearEditionIntroduced, + ] + } - enum clearMessageSetWireFormat: SwiftProtobuf.Enum { + enum clearEditionRemoved: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearMessageSetWireFormat // = 0 + case noneClearEditionRemoved // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearMessageSetWireFormat + self = .noneClearEditionRemoved } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearMessageSetWireFormat + case 0: self = .noneClearEditionRemoved default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearMessageSetWireFormat: return 0 + case .noneClearEditionRemoved: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEditionRemoved] = [ + .noneClearEditionRemoved, + ] + } - enum clearName: SwiftProtobuf.Enum { + enum clearEnd: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearName // = 0 + case noneClearEnd // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearName + self = .noneClearEnd } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearName + case 0: self = .noneClearEnd default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearName: return 0 + case .noneClearEnd: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEnd] = [ + .noneClearEnd, + ] + } - enum clearNamePart: SwiftProtobuf.Enum { + enum clearEnforceNamingStyle: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearNamePart // = 0 + case noneClearEnforceNamingStyle // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearNamePart + self = .noneClearEnforceNamingStyle } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearNamePart + case 0: self = .noneClearEnforceNamingStyle default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearNamePart: return 0 + case .noneClearEnforceNamingStyle: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEnforceNamingStyle] = [ + .noneClearEnforceNamingStyle, + ] + } - enum clearNegativeIntValue: SwiftProtobuf.Enum { + enum clearEnumType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearNegativeIntValue // = 0 + case noneClearEnumType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearNegativeIntValue + self = .noneClearEnumType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearNegativeIntValue + case 0: self = .noneClearEnumType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearNegativeIntValue: return 0 + case .noneClearEnumType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEnumType] = [ + .noneClearEnumType, + ] + } - enum clearNoStandardDescriptorAccessor: SwiftProtobuf.Enum { + enum clearExtendee: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearNoStandardDescriptorAccessor // = 0 + case noneClearExtendee // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearNoStandardDescriptorAccessor + self = .noneClearExtendee } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearNoStandardDescriptorAccessor + case 0: self = .noneClearExtendee default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearNoStandardDescriptorAccessor: return 0 + case .noneClearExtendee: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearExtendee] = [ + .noneClearExtendee, + ] + } - enum clearNumber: SwiftProtobuf.Enum { + enum clearExtensionValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearNumber // = 0 + case noneClearExtensionValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearNumber + self = .noneClearExtensionValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearNumber + case 0: self = .noneClearExtensionValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearNumber: return 0 + case .noneClearExtensionValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearExtensionValue] = [ + .noneClearExtensionValue, + ] + } - enum clearObjcClassPrefix: SwiftProtobuf.Enum { + enum clearFeatures: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearObjcClassPrefix // = 0 + case noneClearFeatures // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearObjcClassPrefix + self = .noneClearFeatures } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearObjcClassPrefix + case 0: self = .noneClearFeatures default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearObjcClassPrefix: return 0 + case .noneClearFeatures: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFeatures] = [ + .noneClearFeatures, + ] + } - enum clearOneofIndex: SwiftProtobuf.Enum { + enum clearFeatureSupport: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearOneofIndex // = 0 + case noneClearFeatureSupport // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearOneofIndex + self = .noneClearFeatureSupport } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearOneofIndex + case 0: self = .noneClearFeatureSupport default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearOneofIndex: return 0 + case .noneClearFeatureSupport: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFeatureSupport] = [ + .noneClearFeatureSupport, + ] + } - enum clearOptimizeFor: SwiftProtobuf.Enum { + enum clearFieldPresence: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearOptimizeFor // = 0 + case noneClearFieldPresence // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearOptimizeFor + self = .noneClearFieldPresence } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearOptimizeFor + case 0: self = .noneClearFieldPresence default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearOptimizeFor: return 0 + case .noneClearFieldPresence: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFieldPresence] = [ + .noneClearFieldPresence, + ] + } - enum clearOptions: SwiftProtobuf.Enum { + enum clearFixedFeatures: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearOptions // = 0 + case noneClearFixedFeatures // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearOptions + self = .noneClearFixedFeatures } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearOptions + case 0: self = .noneClearFixedFeatures default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearOptions: return 0 + case .noneClearFixedFeatures: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFixedFeatures] = [ + .noneClearFixedFeatures, + ] + } - enum clearOutputType: SwiftProtobuf.Enum { + enum clearFullName: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearOutputType // = 0 + case noneClearFullName // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearOutputType + self = .noneClearFullName } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearOutputType + case 0: self = .noneClearFullName default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearOutputType: return 0 + case .noneClearFullName: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFullName] = [ + .noneClearFullName, + ] + } - enum clearPackage: SwiftProtobuf.Enum { + enum clearGoPackage: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearPackage // = 0 + case noneClearGoPackage // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearPackage + self = .noneClearGoPackage } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearPackage + case 0: self = .noneClearGoPackage default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearPackage: return 0 + case .noneClearGoPackage: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearGoPackage] = [ + .noneClearGoPackage, + ] + } - enum clearPacked: SwiftProtobuf.Enum { + enum clearIdempotencyLevel: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearPacked // = 0 + case noneClearIdempotencyLevel // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearPacked + self = .noneClearIdempotencyLevel } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearPacked + case 0: self = .noneClearIdempotencyLevel default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearPacked: return 0 + case .noneClearIdempotencyLevel: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearIdempotencyLevel] = [ + .noneClearIdempotencyLevel, + ] + } - enum clearPhpClassPrefix: SwiftProtobuf.Enum { + enum clearIdentifierValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearPhpClassPrefix // = 0 + case noneClearIdentifierValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearPhpClassPrefix + self = .noneClearIdentifierValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearPhpClassPrefix + case 0: self = .noneClearIdentifierValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearPhpClassPrefix: return 0 + case .noneClearIdentifierValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearIdentifierValue] = [ + .noneClearIdentifierValue, + ] + } - enum clearPhpGenericServices: SwiftProtobuf.Enum { + enum clearInputType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearPhpGenericServices // = 0 + case noneClearInputType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearPhpGenericServices + self = .noneClearInputType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearPhpGenericServices + case 0: self = .noneClearInputType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearPhpGenericServices: return 0 + case .noneClearInputType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearInputType] = [ + .noneClearInputType, + ] + } - enum clearPhpMetadataNamespace: SwiftProtobuf.Enum { + enum clearIsExtension: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearPhpMetadataNamespace // = 0 + case noneClearIsExtension // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearPhpMetadataNamespace + self = .noneClearIsExtension } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearPhpMetadataNamespace + case 0: self = .noneClearIsExtension default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearPhpMetadataNamespace: return 0 + case .noneClearIsExtension: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearIsExtension] = [ + .noneClearIsExtension, + ] + } - enum clearPhpNamespace: SwiftProtobuf.Enum { + enum clearJavaGenerateEqualsAndHash: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearPhpNamespace // = 0 + case noneClearJavaGenerateEqualsAndHash // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearPhpNamespace + self = .noneClearJavaGenerateEqualsAndHash } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearPhpNamespace + case 0: self = .noneClearJavaGenerateEqualsAndHash default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearPhpNamespace: return 0 + case .noneClearJavaGenerateEqualsAndHash: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaGenerateEqualsAndHash] = [ + .noneClearJavaGenerateEqualsAndHash, + ] + } - enum clearPositiveIntValue: SwiftProtobuf.Enum { + enum clearJavaGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearPositiveIntValue // = 0 + case noneClearJavaGenericServices // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearPositiveIntValue + self = .noneClearJavaGenericServices } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearPositiveIntValue + case 0: self = .noneClearJavaGenericServices default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearPositiveIntValue: return 0 + case .noneClearJavaGenericServices: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaGenericServices] = [ + .noneClearJavaGenericServices, + ] + } - enum clearProto3Optional: SwiftProtobuf.Enum { + enum clearJavaMultipleFiles: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearProto3Optional // = 0 + case noneClearJavaMultipleFiles // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearProto3Optional + self = .noneClearJavaMultipleFiles } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearProto3Optional + case 0: self = .noneClearJavaMultipleFiles default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearProto3Optional: return 0 + case .noneClearJavaMultipleFiles: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaMultipleFiles] = [ + .noneClearJavaMultipleFiles, + ] + } - enum clearPyGenericServices: SwiftProtobuf.Enum { + enum clearJavaOuterClassname: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearPyGenericServices // = 0 + case noneClearJavaOuterClassname // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearPyGenericServices + self = .noneClearJavaOuterClassname } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearPyGenericServices + case 0: self = .noneClearJavaOuterClassname default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearPyGenericServices: return 0 + case .noneClearJavaOuterClassname: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaOuterClassname] = [ + .noneClearJavaOuterClassname, + ] + } - enum clearRubyPackage: SwiftProtobuf.Enum { + enum clearJavaPackage: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearRubyPackage // = 0 + case noneClearJavaPackage // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearRubyPackage + self = .noneClearJavaPackage } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearRubyPackage + case 0: self = .noneClearJavaPackage default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearRubyPackage: return 0 + case .noneClearJavaPackage: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaPackage] = [ + .noneClearJavaPackage, + ] + } - enum clearServerStreaming: SwiftProtobuf.Enum { + enum clearJavaStringCheckUtf8: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearServerStreaming // = 0 + case noneClearJavaStringCheckUtf8 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearServerStreaming + self = .noneClearJavaStringCheckUtf8 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearServerStreaming + case 0: self = .noneClearJavaStringCheckUtf8 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearServerStreaming: return 0 + case .noneClearJavaStringCheckUtf8: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaStringCheckUtf8] = [ + .noneClearJavaStringCheckUtf8, + ] + } - enum clearSourceCodeInfo: SwiftProtobuf.Enum { + enum clearJsonFormat: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearSourceCodeInfo // = 0 + case noneClearJsonFormat // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearSourceCodeInfo + self = .noneClearJsonFormat } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearSourceCodeInfo + case 0: self = .noneClearJsonFormat default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearSourceCodeInfo: return 0 + case .noneClearJsonFormat: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJsonFormat] = [ + .noneClearJsonFormat, + ] + } - enum clearSourceContext: SwiftProtobuf.Enum { + enum clearJsonName: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearSourceContext // = 0 + case noneClearJsonName // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearSourceContext + self = .noneClearJsonName } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearSourceContext + case 0: self = .noneClearJsonName default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearSourceContext: return 0 + case .noneClearJsonName: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJsonName] = [ + .noneClearJsonName, + ] + } - enum clearSourceFile: SwiftProtobuf.Enum { + enum clearJstype: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearSourceFile // = 0 + case noneClearJstype // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearSourceFile + self = .noneClearJstype } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearSourceFile + case 0: self = .noneClearJstype default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearSourceFile: return 0 + case .noneClearJstype: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJstype] = [ + .noneClearJstype, + ] + } - enum clearStart: SwiftProtobuf.Enum { + enum clearLabel: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearStart // = 0 + case noneClearLabel // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearStart + self = .noneClearLabel } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearStart + case 0: self = .noneClearLabel default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearStart: return 0 + case .noneClearLabel: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearLabel] = [ + .noneClearLabel, + ] + } - enum clearStringValue: SwiftProtobuf.Enum { + enum clearLazy: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearStringValue // = 0 + case noneClearLazy // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearStringValue + self = .noneClearLazy } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearStringValue + case 0: self = .noneClearLazy default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearStringValue: return 0 + case .noneClearLazy: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearLazy] = [ + .noneClearLazy, + ] + } - enum clearSwiftPrefix: SwiftProtobuf.Enum { + enum clearLeadingComments: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearSwiftPrefix // = 0 + case noneClearLeadingComments // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearSwiftPrefix + self = .noneClearLeadingComments } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearSwiftPrefix + case 0: self = .noneClearLeadingComments default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearSwiftPrefix: return 0 + case .noneClearLeadingComments: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearLeadingComments] = [ + .noneClearLeadingComments, + ] + } - enum clearSyntax: SwiftProtobuf.Enum { + enum clearMapEntry: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearSyntax // = 0 + case noneClearMapEntry // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearSyntax + self = .noneClearMapEntry } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearSyntax + case 0: self = .noneClearMapEntry default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearSyntax: return 0 + case .noneClearMapEntry: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMapEntry] = [ + .noneClearMapEntry, + ] + } - enum clearTrailingComments: SwiftProtobuf.Enum { + enum clearMaximumEdition: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearTrailingComments // = 0 + case noneClearMaximumEdition // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearTrailingComments + self = .noneClearMaximumEdition } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearTrailingComments + case 0: self = .noneClearMaximumEdition default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearTrailingComments: return 0 + case .noneClearMaximumEdition: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMaximumEdition] = [ + .noneClearMaximumEdition, + ] + } - enum clearType: SwiftProtobuf.Enum { + enum clearMessageEncoding: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearType // = 0 + case noneClearMessageEncoding // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearType + self = .noneClearMessageEncoding } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearType + case 0: self = .noneClearMessageEncoding default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearType: return 0 + case .noneClearMessageEncoding: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMessageEncoding] = [ + .noneClearMessageEncoding, + ] + } - enum clearTypeName: SwiftProtobuf.Enum { + enum clearMessageSetWireFormat: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearTypeName // = 0 + case noneClearMessageSetWireFormat // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearTypeName + self = .noneClearMessageSetWireFormat } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearTypeName + case 0: self = .noneClearMessageSetWireFormat default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearTypeName: return 0 + case .noneClearMessageSetWireFormat: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMessageSetWireFormat] = [ + .noneClearMessageSetWireFormat, + ] + } - enum clearValue: SwiftProtobuf.Enum { + enum clearMinimumEdition: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearValue // = 0 + case noneClearMinimumEdition // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearValue + self = .noneClearMinimumEdition } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearValue + case 0: self = .noneClearMinimumEdition default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearValue: return 0 + case .noneClearMinimumEdition: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMinimumEdition] = [ + .noneClearMinimumEdition, + ] + } - enum clearWeak: SwiftProtobuf.Enum { + enum clearName: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClearWeak // = 0 + case noneClearName // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClearWeak + self = .noneClearName } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClearWeak + case 0: self = .noneClearName default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClearWeak: return 0 + case .noneClearName: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearName] = [ + .noneClearName, + ] + } - enum clientStreaming: SwiftProtobuf.Enum { + enum clearNamePart: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneClientStreaming // = 0 + case noneClearNamePart // = 0 case UNRECOGNIZED(Int) init() { - self = .noneClientStreaming + self = .noneClearNamePart } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneClientStreaming + case 0: self = .noneClearNamePart default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneClientStreaming: return 0 + case .noneClearNamePart: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNamePart] = [ + .noneClearNamePart, + ] + } - enum codePoint: SwiftProtobuf.Enum { + enum clearNegativeIntValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneCodePoint // = 0 + case noneClearNegativeIntValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneCodePoint + self = .noneClearNegativeIntValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneCodePoint + case 0: self = .noneClearNegativeIntValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneCodePoint: return 0 + case .noneClearNegativeIntValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNegativeIntValue] = [ + .noneClearNegativeIntValue, + ] + } - enum codeUnits: SwiftProtobuf.Enum { + enum clearNoStandardDescriptorAccessor: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneCodeUnits // = 0 + case noneClearNoStandardDescriptorAccessor // = 0 case UNRECOGNIZED(Int) init() { - self = .noneCodeUnits + self = .noneClearNoStandardDescriptorAccessor } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneCodeUnits + case 0: self = .noneClearNoStandardDescriptorAccessor default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneCodeUnits: return 0 + case .noneClearNoStandardDescriptorAccessor: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNoStandardDescriptorAccessor] = [ + .noneClearNoStandardDescriptorAccessor, + ] + } - enum Collection: SwiftProtobuf.Enum { + enum clearNumber: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneCollection // = 0 + case noneClearNumber // = 0 case UNRECOGNIZED(Int) init() { - self = .noneCollection + self = .noneClearNumber } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneCollection + case 0: self = .noneClearNumber default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneCollection: return 0 + case .noneClearNumber: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNumber] = [ + .noneClearNumber, + ] + } - enum com: SwiftProtobuf.Enum { + enum clearObjcClassPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneCom // = 0 + case noneClearObjcClassPrefix // = 0 case UNRECOGNIZED(Int) init() { - self = .noneCom + self = .noneClearObjcClassPrefix } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneCom + case 0: self = .noneClearObjcClassPrefix default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneCom: return 0 + case .noneClearObjcClassPrefix: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearObjcClassPrefix] = [ + .noneClearObjcClassPrefix, + ] + } - enum comma: SwiftProtobuf.Enum { + enum clearOneofIndex: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneComma // = 0 + case noneClearOneofIndex // = 0 case UNRECOGNIZED(Int) init() { - self = .noneComma + self = .noneClearOneofIndex } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneComma + case 0: self = .noneClearOneofIndex default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneComma: return 0 + case .noneClearOneofIndex: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOneofIndex] = [ + .noneClearOneofIndex, + ] + } - enum contentsOf: SwiftProtobuf.Enum { + enum clearOptimizeFor: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneContentsOf // = 0 + case noneClearOptimizeFor // = 0 case UNRECOGNIZED(Int) init() { - self = .noneContentsOf + self = .noneClearOptimizeFor } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneContentsOf + case 0: self = .noneClearOptimizeFor default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneContentsOf: return 0 + case .noneClearOptimizeFor: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOptimizeFor] = [ + .noneClearOptimizeFor, + ] + } - enum ContiguousBytes: SwiftProtobuf.Enum { + enum clearOptions: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneContiguousBytes // = 0 + case noneClearOptions // = 0 case UNRECOGNIZED(Int) init() { - self = .noneContiguousBytes + self = .noneClearOptions } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneContiguousBytes + case 0: self = .noneClearOptions default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneContiguousBytes: return 0 + case .noneClearOptions: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOptions] = [ + .noneClearOptions, + ] + } - enum count: SwiftProtobuf.Enum { + enum clearOutputType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneCount // = 0 + case noneClearOutputType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneCount + self = .noneClearOutputType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneCount + case 0: self = .noneClearOutputType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneCount: return 0 + case .noneClearOutputType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOutputType] = [ + .noneClearOutputType, + ] + } - enum countVarintsInBuffer: SwiftProtobuf.Enum { + enum clearOverridableFeatures: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneCountVarintsInBuffer // = 0 + case noneClearOverridableFeatures // = 0 case UNRECOGNIZED(Int) init() { - self = .noneCountVarintsInBuffer + self = .noneClearOverridableFeatures } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneCountVarintsInBuffer + case 0: self = .noneClearOverridableFeatures default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneCountVarintsInBuffer: return 0 + case .noneClearOverridableFeatures: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOverridableFeatures] = [ + .noneClearOverridableFeatures, + ] + } - enum csharpNamespace: SwiftProtobuf.Enum { + enum clearPackage: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneCsharpNamespace // = 0 + case noneClearPackage // = 0 case UNRECOGNIZED(Int) init() { - self = .noneCsharpNamespace + self = .noneClearPackage } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneCsharpNamespace + case 0: self = .noneClearPackage default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneCsharpNamespace: return 0 + case .noneClearPackage: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPackage] = [ + .noneClearPackage, + ] + } - enum ctype: SwiftProtobuf.Enum { + enum clearPacked: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneCtype // = 0 + case noneClearPacked // = 0 case UNRECOGNIZED(Int) init() { - self = .noneCtype + self = .noneClearPacked } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneCtype + case 0: self = .noneClearPacked default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneCtype: return 0 + case .noneClearPacked: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPacked] = [ + .noneClearPacked, + ] + } - enum customCodable: SwiftProtobuf.Enum { + enum clearPhpClassPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneCustomCodable // = 0 + case noneClearPhpClassPrefix // = 0 case UNRECOGNIZED(Int) init() { - self = .noneCustomCodable + self = .noneClearPhpClassPrefix } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneCustomCodable + case 0: self = .noneClearPhpClassPrefix default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneCustomCodable: return 0 + case .noneClearPhpClassPrefix: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPhpClassPrefix] = [ + .noneClearPhpClassPrefix, + ] + } - enum CustomDebugStringConvertible: SwiftProtobuf.Enum { + enum clearPhpMetadataNamespace: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneCustomDebugStringConvertible // = 0 + case noneClearPhpMetadataNamespace // = 0 case UNRECOGNIZED(Int) init() { - self = .noneCustomDebugStringConvertible + self = .noneClearPhpMetadataNamespace } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneCustomDebugStringConvertible + case 0: self = .noneClearPhpMetadataNamespace default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneCustomDebugStringConvertible: return 0 + case .noneClearPhpMetadataNamespace: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPhpMetadataNamespace] = [ + .noneClearPhpMetadataNamespace, + ] + } - enum d: SwiftProtobuf.Enum { + enum clearPhpNamespace: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneD // = 0 + case noneClearPhpNamespace // = 0 case UNRECOGNIZED(Int) init() { - self = .noneD + self = .noneClearPhpNamespace } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneD + case 0: self = .noneClearPhpNamespace default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneD: return 0 + case .noneClearPhpNamespace: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPhpNamespace] = [ + .noneClearPhpNamespace, + ] + } - enum DataEnum: SwiftProtobuf.Enum { + enum clearPositiveIntValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneData // = 0 + case noneClearPositiveIntValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneData + self = .noneClearPositiveIntValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneData + case 0: self = .noneClearPositiveIntValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneData: return 0 + case .noneClearPositiveIntValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPositiveIntValue] = [ + .noneClearPositiveIntValue, + ] + } - enum dataResult: SwiftProtobuf.Enum { + enum clearProto3Optional: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDataResult // = 0 + case noneClearProto3Optional // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDataResult + self = .noneClearProto3Optional } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDataResult + case 0: self = .noneClearProto3Optional default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDataResult: return 0 + case .noneClearProto3Optional: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearProto3Optional] = [ + .noneClearProto3Optional, + ] + } - enum date: SwiftProtobuf.Enum { + enum clearPyGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDate // = 0 + case noneClearPyGenericServices // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDate + self = .noneClearPyGenericServices } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDate + case 0: self = .noneClearPyGenericServices default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDate: return 0 + case .noneClearPyGenericServices: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPyGenericServices] = [ + .noneClearPyGenericServices, + ] + } - enum daySec: SwiftProtobuf.Enum { + enum clearRemovalError: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDaySec // = 0 + case noneClearRemovalError // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDaySec + self = .noneClearRemovalError } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDaySec + case 0: self = .noneClearRemovalError default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDaySec: return 0 + case .noneClearRemovalError: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRemovalError] = [ + .noneClearRemovalError, + ] + } - enum daysSinceEpoch: SwiftProtobuf.Enum { + enum clearRepeated: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDaysSinceEpoch // = 0 + case noneClearRepeated // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDaysSinceEpoch + self = .noneClearRepeated } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDaysSinceEpoch + case 0: self = .noneClearRepeated default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDaysSinceEpoch: return 0 + case .noneClearRepeated: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRepeated] = [ + .noneClearRepeated, + ] + } - enum debugDescriptionEnum: SwiftProtobuf.Enum { + enum clearRepeatedFieldEncoding: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDebugDescription // = 0 + case noneClearRepeatedFieldEncoding // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDebugDescription + self = .noneClearRepeatedFieldEncoding } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDebugDescription + case 0: self = .noneClearRepeatedFieldEncoding default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDebugDescription: return 0 + case .noneClearRepeatedFieldEncoding: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRepeatedFieldEncoding] = [ + .noneClearRepeatedFieldEncoding, + ] + } - enum decoded: SwiftProtobuf.Enum { + enum clearReserved: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecoded // = 0 + case noneClearReserved // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecoded + self = .noneClearReserved } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecoded + case 0: self = .noneClearReserved default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecoded: return 0 + case .noneClearReserved: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearReserved] = [ + .noneClearReserved, + ] + } - enum decodedFromJSONNull: SwiftProtobuf.Enum { + enum clearRetention: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodedFromJsonnull // = 0 + case noneClearRetention // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodedFromJsonnull + self = .noneClearRetention } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodedFromJsonnull + case 0: self = .noneClearRetention default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodedFromJsonnull: return 0 + case .noneClearRetention: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRetention] = [ + .noneClearRetention, + ] + } - enum decodeExtensionField: SwiftProtobuf.Enum { + enum clearRubyPackage: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeExtensionField // = 0 + case noneClearRubyPackage // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeExtensionField + self = .noneClearRubyPackage } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeExtensionField + case 0: self = .noneClearRubyPackage default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeExtensionField: return 0 + case .noneClearRubyPackage: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRubyPackage] = [ + .noneClearRubyPackage, + ] + } - enum decodeExtensionFieldsAsMessageSet: SwiftProtobuf.Enum { + enum clearSemantic: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeExtensionFieldsAsMessageSet // = 0 + case noneClearSemantic // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeExtensionFieldsAsMessageSet + self = .noneClearSemantic } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeExtensionFieldsAsMessageSet + case 0: self = .noneClearSemantic default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeExtensionFieldsAsMessageSet: return 0 + case .noneClearSemantic: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSemantic] = [ + .noneClearSemantic, + ] + } - enum decodeJSON: SwiftProtobuf.Enum { + enum clearServerStreaming: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeJson // = 0 + case noneClearServerStreaming // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeJson + self = .noneClearServerStreaming } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeJson + case 0: self = .noneClearServerStreaming default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeJson: return 0 + case .noneClearServerStreaming: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearServerStreaming] = [ + .noneClearServerStreaming, + ] + } - enum decodeMapField: SwiftProtobuf.Enum { + enum clearSourceCodeInfo: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeMapField // = 0 + case noneClearSourceCodeInfo // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeMapField + self = .noneClearSourceCodeInfo } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeMapField + case 0: self = .noneClearSourceCodeInfo default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeMapField: return 0 + case .noneClearSourceCodeInfo: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSourceCodeInfo] = [ + .noneClearSourceCodeInfo, + ] + } - enum decodeMessageEnum: SwiftProtobuf.Enum { + enum clearSourceContext: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeMessage // = 0 + case noneClearSourceContext // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeMessage + self = .noneClearSourceContext } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeMessage + case 0: self = .noneClearSourceContext default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeMessage: return 0 + case .noneClearSourceContext: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSourceContext] = [ + .noneClearSourceContext, + ] + } - enum decoder: SwiftProtobuf.Enum { + enum clearSourceFile: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecoder // = 0 + case noneClearSourceFile // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecoder + self = .noneClearSourceFile } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecoder + case 0: self = .noneClearSourceFile default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecoder: return 0 + case .noneClearSourceFile: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSourceFile] = [ + .noneClearSourceFile, + ] + } - enum decodeRepeated: SwiftProtobuf.Enum { + enum clearStart: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeated // = 0 + case noneClearStart // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeated + self = .noneClearStart } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeated + case 0: self = .noneClearStart default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeated: return 0 + case .noneClearStart: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearStart] = [ + .noneClearStart, + ] + } - enum decodeRepeatedBoolField: SwiftProtobuf.Enum { + enum clearStringValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeatedBoolField // = 0 + case noneClearStringValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeatedBoolField + self = .noneClearStringValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeatedBoolField + case 0: self = .noneClearStringValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeatedBoolField: return 0 + case .noneClearStringValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearStringValue] = [ + .noneClearStringValue, + ] + } - enum decodeRepeatedBytesField: SwiftProtobuf.Enum { + enum clearSwiftPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeatedBytesField // = 0 + case noneClearSwiftPrefix // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeatedBytesField + self = .noneClearSwiftPrefix } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeatedBytesField + case 0: self = .noneClearSwiftPrefix default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeatedBytesField: return 0 + case .noneClearSwiftPrefix: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSwiftPrefix] = [ + .noneClearSwiftPrefix, + ] + } - enum decodeRepeatedDoubleField: SwiftProtobuf.Enum { + enum clearSyntax: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeatedDoubleField // = 0 + case noneClearSyntax // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeatedDoubleField + self = .noneClearSyntax } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeatedDoubleField + case 0: self = .noneClearSyntax default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeatedDoubleField: return 0 + case .noneClearSyntax: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSyntax] = [ + .noneClearSyntax, + ] + } - enum decodeRepeatedEnumField: SwiftProtobuf.Enum { + enum clearTrailingComments: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeatedEnumField // = 0 + case noneClearTrailingComments // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeatedEnumField + self = .noneClearTrailingComments } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeatedEnumField + case 0: self = .noneClearTrailingComments default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeatedEnumField: return 0 + case .noneClearTrailingComments: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearTrailingComments] = [ + .noneClearTrailingComments, + ] + } - enum decodeRepeatedFixed32Field: SwiftProtobuf.Enum { + enum clearType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeatedFixed32Field // = 0 + case noneClearType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeatedFixed32Field + self = .noneClearType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeatedFixed32Field + case 0: self = .noneClearType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeatedFixed32Field: return 0 + case .noneClearType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearType] = [ + .noneClearType, + ] + } - enum decodeRepeatedFixed64Field: SwiftProtobuf.Enum { + enum clearTypeName: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeatedFixed64Field // = 0 + case noneClearTypeName // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeatedFixed64Field + self = .noneClearTypeName } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeatedFixed64Field + case 0: self = .noneClearTypeName default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeatedFixed64Field: return 0 + case .noneClearTypeName: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearTypeName] = [ + .noneClearTypeName, + ] + } - enum decodeRepeatedFloatField: SwiftProtobuf.Enum { + enum clearUnverifiedLazy: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeatedFloatField // = 0 + case noneClearUnverifiedLazy // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeatedFloatField + self = .noneClearUnverifiedLazy } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeatedFloatField + case 0: self = .noneClearUnverifiedLazy default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeatedFloatField: return 0 + case .noneClearUnverifiedLazy: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearUnverifiedLazy] = [ + .noneClearUnverifiedLazy, + ] + } - enum decodeRepeatedGroupField: SwiftProtobuf.Enum { + enum clearUtf8Validation: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeatedGroupField // = 0 + case noneClearUtf8Validation // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeatedGroupField + self = .noneClearUtf8Validation } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeatedGroupField + case 0: self = .noneClearUtf8Validation default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeatedGroupField: return 0 + case .noneClearUtf8Validation: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearUtf8Validation] = [ + .noneClearUtf8Validation, + ] + } - enum decodeRepeatedInt32Field: SwiftProtobuf.Enum { + enum clearValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeatedInt32Field // = 0 + case noneClearValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeatedInt32Field + self = .noneClearValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeatedInt32Field + case 0: self = .noneClearValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeatedInt32Field: return 0 + case .noneClearValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearValue] = [ + .noneClearValue, + ] + } - enum decodeRepeatedInt64Field: SwiftProtobuf.Enum { + enum clearVerification: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeatedInt64Field // = 0 + case noneClearVerification // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeatedInt64Field + self = .noneClearVerification } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeatedInt64Field + case 0: self = .noneClearVerification default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeatedInt64Field: return 0 + case .noneClearVerification: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearVerification] = [ + .noneClearVerification, + ] + } - enum decodeRepeatedMessageField: SwiftProtobuf.Enum { + enum clearVisibility: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeatedMessageField // = 0 + case noneClearVisibility // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeatedMessageField + self = .noneClearVisibility } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeatedMessageField + case 0: self = .noneClearVisibility default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeatedMessageField: return 0 + case .noneClearVisibility: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearVisibility] = [ + .noneClearVisibility, + ] + } - enum decodeRepeatedSFixed32Field: SwiftProtobuf.Enum { + enum clearWeak: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeatedSfixed32Field // = 0 + case noneClearWeak // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeatedSfixed32Field + self = .noneClearWeak } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeatedSfixed32Field + case 0: self = .noneClearWeak default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeatedSfixed32Field: return 0 + case .noneClearWeak: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearWeak] = [ + .noneClearWeak, + ] + } - enum decodeRepeatedSFixed64Field: SwiftProtobuf.Enum { + enum clientStreaming: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeatedSfixed64Field // = 0 + case noneClientStreaming // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeatedSfixed64Field + self = .noneClientStreaming } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeatedSfixed64Field + case 0: self = .noneClientStreaming default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeatedSfixed64Field: return 0 + case .noneClientStreaming: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clientStreaming] = [ + .noneClientStreaming, + ] + } - enum decodeRepeatedSInt32Field: SwiftProtobuf.Enum { + enum code: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeatedSint32Field // = 0 + case noneCode // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeatedSint32Field + self = .noneCode } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeatedSint32Field + case 0: self = .noneCode default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeatedSint32Field: return 0 + case .noneCode: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.code] = [ + .noneCode, + ] + } - enum decodeRepeatedSInt64Field: SwiftProtobuf.Enum { + enum codePoint: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeatedSint64Field // = 0 + case noneCodePoint // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeatedSint64Field + self = .noneCodePoint } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeatedSint64Field + case 0: self = .noneCodePoint default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeatedSint64Field: return 0 + case .noneCodePoint: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.codePoint] = [ + .noneCodePoint, + ] + } - enum decodeRepeatedStringField: SwiftProtobuf.Enum { + enum codeUnits: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeatedStringField // = 0 + case noneCodeUnits // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeatedStringField + self = .noneCodeUnits } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeatedStringField + case 0: self = .noneCodeUnits default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeatedStringField: return 0 + case .noneCodeUnits: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.codeUnits] = [ + .noneCodeUnits, + ] + } - enum decodeRepeatedUInt32Field: SwiftProtobuf.Enum { + enum Collection: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeatedUint32Field // = 0 + case noneCollection // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeatedUint32Field + self = .noneCollection } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeatedUint32Field + case 0: self = .noneCollection default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeatedUint32Field: return 0 + case .noneCollection: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Collection] = [ + .noneCollection, + ] + } - enum decodeRepeatedUInt64Field: SwiftProtobuf.Enum { + enum comma: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeRepeatedUint64Field // = 0 + case noneComma // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeRepeatedUint64Field + self = .noneComma } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeRepeatedUint64Field + case 0: self = .noneComma default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeRepeatedUint64Field: return 0 + case .noneComma: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.comma] = [ + .noneComma, + ] + } - enum decodeSingular: SwiftProtobuf.Enum { + enum consumedBytes: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingular // = 0 + case noneConsumedBytes // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingular + self = .noneConsumedBytes } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingular + case 0: self = .noneConsumedBytes default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingular: return 0 + case .noneConsumedBytes: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.consumedBytes] = [ + .noneConsumedBytes, + ] + } - enum decodeSingularBoolField: SwiftProtobuf.Enum { + enum contains: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingularBoolField // = 0 + case noneContains // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingularBoolField + self = .noneContains } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingularBoolField + case 0: self = .noneContains default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingularBoolField: return 0 + case .noneContains: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.contains] = [ + .noneContains, + ] + } - enum decodeSingularBytesField: SwiftProtobuf.Enum { + enum contentsOf: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingularBytesField // = 0 + case noneContentsOf // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingularBytesField + self = .noneContentsOf } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingularBytesField + case 0: self = .noneContentsOf default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingularBytesField: return 0 + case .noneContentsOf: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.contentsOf] = [ + .noneContentsOf, + ] + } - enum decodeSingularDoubleField: SwiftProtobuf.Enum { + enum ContiguousBytes: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingularDoubleField // = 0 + case noneContiguousBytes // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingularDoubleField + self = .noneContiguousBytes } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingularDoubleField + case 0: self = .noneContiguousBytes default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingularDoubleField: return 0 + case .noneContiguousBytes: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ContiguousBytes] = [ + .noneContiguousBytes, + ] + } - enum decodeSingularEnumField: SwiftProtobuf.Enum { + enum copy: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingularEnumField // = 0 + case noneCopy // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingularEnumField + self = .noneCopy } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingularEnumField + case 0: self = .noneCopy default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingularEnumField: return 0 + case .noneCopy: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.copy] = [ + .noneCopy, + ] + } - enum decodeSingularFixed32Field: SwiftProtobuf.Enum { + enum count: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingularFixed32Field // = 0 + case noneCount // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingularFixed32Field + self = .noneCount } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingularFixed32Field + case 0: self = .noneCount default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingularFixed32Field: return 0 + case .noneCount: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.count] = [ + .noneCount, + ] + } - enum decodeSingularFixed64Field: SwiftProtobuf.Enum { + enum countVarintsInBuffer: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingularFixed64Field // = 0 + case noneCountVarintsInBuffer // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingularFixed64Field + self = .noneCountVarintsInBuffer } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingularFixed64Field + case 0: self = .noneCountVarintsInBuffer default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingularFixed64Field: return 0 + case .noneCountVarintsInBuffer: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.countVarintsInBuffer] = [ + .noneCountVarintsInBuffer, + ] + } - enum decodeSingularFloatField: SwiftProtobuf.Enum { + enum csharpNamespace: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingularFloatField // = 0 + case noneCsharpNamespace // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingularFloatField + self = .noneCsharpNamespace } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingularFloatField + case 0: self = .noneCsharpNamespace default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingularFloatField: return 0 + case .noneCsharpNamespace: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.csharpNamespace] = [ + .noneCsharpNamespace, + ] + } - enum decodeSingularGroupField: SwiftProtobuf.Enum { + enum ctype: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingularGroupField // = 0 + case noneCtype // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingularGroupField + self = .noneCtype } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingularGroupField + case 0: self = .noneCtype default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingularGroupField: return 0 + case .noneCtype: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ctype] = [ + .noneCtype, + ] + } - enum decodeSingularInt32Field: SwiftProtobuf.Enum { + enum customCodable: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingularInt32Field // = 0 + case noneCustomCodable // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingularInt32Field + self = .noneCustomCodable } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingularInt32Field + case 0: self = .noneCustomCodable default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingularInt32Field: return 0 + case .noneCustomCodable: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.customCodable] = [ + .noneCustomCodable, + ] + } - enum decodeSingularInt64Field: SwiftProtobuf.Enum { + enum CustomDebugStringConvertible: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingularInt64Field // = 0 + case noneCustomDebugStringConvertible // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingularInt64Field + self = .noneCustomDebugStringConvertible } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingularInt64Field + case 0: self = .noneCustomDebugStringConvertible default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingularInt64Field: return 0 + case .noneCustomDebugStringConvertible: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.CustomDebugStringConvertible] = [ + .noneCustomDebugStringConvertible, + ] + } - enum decodeSingularMessageField: SwiftProtobuf.Enum { + enum CustomStringConvertible: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingularMessageField // = 0 + case noneCustomStringConvertible // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingularMessageField + self = .noneCustomStringConvertible } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingularMessageField + case 0: self = .noneCustomStringConvertible default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingularMessageField: return 0 + case .noneCustomStringConvertible: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.CustomStringConvertible] = [ + .noneCustomStringConvertible, + ] + } - enum decodeSingularSFixed32Field: SwiftProtobuf.Enum { + enum D: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingularSfixed32Field // = 0 + case noneD // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingularSfixed32Field + self = .noneD } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingularSfixed32Field + case 0: self = .noneD default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingularSfixed32Field: return 0 + case .noneD: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.D] = [ + .noneD, + ] + } - enum decodeSingularSFixed64Field: SwiftProtobuf.Enum { + enum DataEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingularSfixed64Field // = 0 + case noneData // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingularSfixed64Field + self = .noneData } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingularSfixed64Field + case 0: self = .noneData default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingularSfixed64Field: return 0 + case .noneData: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.DataEnum] = [ + .noneData, + ] + } - enum decodeSingularSInt32Field: SwiftProtobuf.Enum { + enum dataResult: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingularSint32Field // = 0 + case noneDataResult // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingularSint32Field + self = .noneDataResult } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingularSint32Field + case 0: self = .noneDataResult default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingularSint32Field: return 0 + case .noneDataResult: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.dataResult] = [ + .noneDataResult, + ] + } - enum decodeSingularSInt64Field: SwiftProtobuf.Enum { + enum date: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingularSint64Field // = 0 + case noneDate // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingularSint64Field + self = .noneDate } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingularSint64Field + case 0: self = .noneDate default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingularSint64Field: return 0 + case .noneDate: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.date] = [ + .noneDate, + ] + } - enum decodeSingularStringField: SwiftProtobuf.Enum { + enum daySec: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingularStringField // = 0 + case noneDaySec // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingularStringField + self = .noneDaySec } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingularStringField + case 0: self = .noneDaySec default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingularStringField: return 0 + case .noneDaySec: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.daySec] = [ + .noneDaySec, + ] + } - enum decodeSingularUInt32Field: SwiftProtobuf.Enum { + enum daysSinceEpoch: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingularUint32Field // = 0 + case noneDaysSinceEpoch // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingularUint32Field + self = .noneDaysSinceEpoch } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingularUint32Field + case 0: self = .noneDaysSinceEpoch default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingularUint32Field: return 0 + case .noneDaysSinceEpoch: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.daysSinceEpoch] = [ + .noneDaysSinceEpoch, + ] + } - enum decodeSingularUInt64Field: SwiftProtobuf.Enum { + enum debugDescriptionEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeSingularUint64Field // = 0 + case noneDebugDescription // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeSingularUint64Field + self = .noneDebugDescription } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeSingularUint64Field + case 0: self = .noneDebugDescription default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeSingularUint64Field: return 0 + case .noneDebugDescription: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.debugDescriptionEnum] = [ + .noneDebugDescription, + ] + } - enum decodeTextFormat: SwiftProtobuf.Enum { + enum debugRedact: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDecodeTextFormat // = 0 + case noneDebugRedact // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDecodeTextFormat + self = .noneDebugRedact } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDecodeTextFormat + case 0: self = .noneDebugRedact default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDecodeTextFormat: return 0 + case .noneDebugRedact: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.debugRedact] = [ + .noneDebugRedact, + ] + } - enum defaultAnyTypeURLPrefix: SwiftProtobuf.Enum { + enum declaration: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDefaultAnyTypeUrlprefix // = 0 + case noneDeclaration // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDefaultAnyTypeUrlprefix + self = .noneDeclaration } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDefaultAnyTypeUrlprefix + case 0: self = .noneDeclaration default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDefaultAnyTypeUrlprefix: return 0 + case .noneDeclaration: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.declaration] = [ + .noneDeclaration, + ] + } - enum defaultValue: SwiftProtobuf.Enum { + enum decoded: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDefaultValue // = 0 + case noneDecoded // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDefaultValue + self = .noneDecoded } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDefaultValue + case 0: self = .noneDecoded default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDefaultValue: return 0 + case .noneDecoded: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decoded] = [ + .noneDecoded, + ] + } - enum dependency: SwiftProtobuf.Enum { + enum decodedFromJSONNull: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDependency // = 0 + case noneDecodedFromJsonnull // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDependency + self = .noneDecodedFromJsonnull } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDependency + case 0: self = .noneDecodedFromJsonnull default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDependency: return 0 + case .noneDecodedFromJsonnull: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodedFromJSONNull] = [ + .noneDecodedFromJsonnull, + ] + } - enum deprecated: SwiftProtobuf.Enum { + enum decodeExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDeprecated // = 0 + case noneDecodeExtensionField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDeprecated + self = .noneDecodeExtensionField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDeprecated + case 0: self = .noneDecodeExtensionField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDeprecated: return 0 + case .noneDecodeExtensionField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeExtensionField] = [ + .noneDecodeExtensionField, + ] + } - enum descriptionEnum: SwiftProtobuf.Enum { + enum decodeExtensionFieldsAsMessageSet: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDescription // = 0 + case noneDecodeExtensionFieldsAsMessageSet // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDescription + self = .noneDecodeExtensionFieldsAsMessageSet } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDescription + case 0: self = .noneDecodeExtensionFieldsAsMessageSet default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDescription: return 0 + case .noneDecodeExtensionFieldsAsMessageSet: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeExtensionFieldsAsMessageSet] = [ + .noneDecodeExtensionFieldsAsMessageSet, + ] + } - enum DescriptorProto: SwiftProtobuf.Enum { + enum decodeJSON: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDescriptorProto // = 0 + case noneDecodeJson // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDescriptorProto + self = .noneDecodeJson } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDescriptorProto + case 0: self = .noneDecodeJson default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDescriptorProto: return 0 + case .noneDecodeJson: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeJSON] = [ + .noneDecodeJson, + ] + } - enum Dictionary: SwiftProtobuf.Enum { + enum decodeMapField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDictionary // = 0 + case noneDecodeMapField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDictionary + self = .noneDecodeMapField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDictionary + case 0: self = .noneDecodeMapField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDictionary: return 0 + case .noneDecodeMapField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeMapField] = [ + .noneDecodeMapField, + ] + } - enum dictionaryLiteral: SwiftProtobuf.Enum { + enum decodeMessageEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDictionaryLiteral // = 0 + case noneDecodeMessage // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDictionaryLiteral + self = .noneDecodeMessage } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDictionaryLiteral + case 0: self = .noneDecodeMessage default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDictionaryLiteral: return 0 + case .noneDecodeMessage: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeMessageEnum] = [ + .noneDecodeMessage, + ] + } - enum digit: SwiftProtobuf.Enum { + enum Decoder: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDigit // = 0 + case noneDecoder // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDigit + self = .noneDecoder } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDigit + case 0: self = .noneDecoder default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDigit: return 0 + case .noneDecoder: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Decoder] = [ + .noneDecoder, + ] + } - enum digit0: SwiftProtobuf.Enum { + enum decodeRepeated: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDigit0 // = 0 + case noneDecodeRepeated // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDigit0 + self = .noneDecodeRepeated } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDigit0 + case 0: self = .noneDecodeRepeated default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDigit0: return 0 + case .noneDecodeRepeated: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeated] = [ + .noneDecodeRepeated, + ] + } - enum digit1: SwiftProtobuf.Enum { + enum decodeRepeatedBoolField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDigit1 // = 0 + case noneDecodeRepeatedBoolField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDigit1 + self = .noneDecodeRepeatedBoolField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDigit1 + case 0: self = .noneDecodeRepeatedBoolField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDigit1: return 0 + case .noneDecodeRepeatedBoolField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedBoolField] = [ + .noneDecodeRepeatedBoolField, + ] + } - enum digitCount: SwiftProtobuf.Enum { + enum decodeRepeatedBytesField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDigitCount // = 0 + case noneDecodeRepeatedBytesField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDigitCount + self = .noneDecodeRepeatedBytesField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDigitCount + case 0: self = .noneDecodeRepeatedBytesField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDigitCount: return 0 + case .noneDecodeRepeatedBytesField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedBytesField] = [ + .noneDecodeRepeatedBytesField, + ] + } - enum digits: SwiftProtobuf.Enum { + enum decodeRepeatedDoubleField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDigits // = 0 + case noneDecodeRepeatedDoubleField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDigits + self = .noneDecodeRepeatedDoubleField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDigits + case 0: self = .noneDecodeRepeatedDoubleField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDigits: return 0 + case .noneDecodeRepeatedDoubleField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedDoubleField] = [ + .noneDecodeRepeatedDoubleField, + ] + } - enum digitValue: SwiftProtobuf.Enum { + enum decodeRepeatedEnumField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDigitValue // = 0 + case noneDecodeRepeatedEnumField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDigitValue + self = .noneDecodeRepeatedEnumField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDigitValue + case 0: self = .noneDecodeRepeatedEnumField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDigitValue: return 0 + case .noneDecodeRepeatedEnumField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedEnumField] = [ + .noneDecodeRepeatedEnumField, + ] + } - enum discardableResult: SwiftProtobuf.Enum { + enum decodeRepeatedFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDiscardableResult // = 0 + case noneDecodeRepeatedFixed32Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDiscardableResult + self = .noneDecodeRepeatedFixed32Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDiscardableResult + case 0: self = .noneDecodeRepeatedFixed32Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDiscardableResult: return 0 + case .noneDecodeRepeatedFixed32Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedFixed32Field] = [ + .noneDecodeRepeatedFixed32Field, + ] + } - enum discardUnknownFields: SwiftProtobuf.Enum { + enum decodeRepeatedFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDiscardUnknownFields // = 0 + case noneDecodeRepeatedFixed64Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDiscardUnknownFields + self = .noneDecodeRepeatedFixed64Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDiscardUnknownFields + case 0: self = .noneDecodeRepeatedFixed64Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDiscardUnknownFields: return 0 + case .noneDecodeRepeatedFixed64Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedFixed64Field] = [ + .noneDecodeRepeatedFixed64Field, + ] + } - enum distance: SwiftProtobuf.Enum { + enum decodeRepeatedFloatField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDistance // = 0 + case noneDecodeRepeatedFloatField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDistance + self = .noneDecodeRepeatedFloatField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDistance + case 0: self = .noneDecodeRepeatedFloatField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDistance: return 0 + case .noneDecodeRepeatedFloatField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedFloatField] = [ + .noneDecodeRepeatedFloatField, + ] + } - enum double: SwiftProtobuf.Enum { + enum decodeRepeatedGroupField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDouble // = 0 + case noneDecodeRepeatedGroupField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDouble + self = .noneDecodeRepeatedGroupField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDouble + case 0: self = .noneDecodeRepeatedGroupField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDouble: return 0 + case .noneDecodeRepeatedGroupField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedGroupField] = [ + .noneDecodeRepeatedGroupField, + ] + } - enum doubleValue: SwiftProtobuf.Enum { + enum decodeRepeatedInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDoubleValue // = 0 + case noneDecodeRepeatedInt32Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDoubleValue + self = .noneDecodeRepeatedInt32Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDoubleValue + case 0: self = .noneDecodeRepeatedInt32Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDoubleValue: return 0 + case .noneDecodeRepeatedInt32Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedInt32Field] = [ + .noneDecodeRepeatedInt32Field, + ] + } - enum Duration: SwiftProtobuf.Enum { + enum decodeRepeatedInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneDuration // = 0 + case noneDecodeRepeatedInt64Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneDuration + self = .noneDecodeRepeatedInt64Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneDuration + case 0: self = .noneDecodeRepeatedInt64Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneDuration: return 0 + case .noneDecodeRepeatedInt64Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedInt64Field] = [ + .noneDecodeRepeatedInt64Field, + ] + } - enum E: SwiftProtobuf.Enum { + enum decodeRepeatedMessageField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneE // = 0 + case noneDecodeRepeatedMessageField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneE + self = .noneDecodeRepeatedMessageField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneE + case 0: self = .noneDecodeRepeatedMessageField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneE: return 0 + case .noneDecodeRepeatedMessageField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedMessageField] = [ + .noneDecodeRepeatedMessageField, + ] + } - enum Element: SwiftProtobuf.Enum { + enum decodeRepeatedSFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneElement // = 0 + case noneDecodeRepeatedSfixed32Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneElement + self = .noneDecodeRepeatedSfixed32Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneElement + case 0: self = .noneDecodeRepeatedSfixed32Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneElement: return 0 + case .noneDecodeRepeatedSfixed32Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed32Field] = [ + .noneDecodeRepeatedSfixed32Field, + ] + } - enum elements: SwiftProtobuf.Enum { + enum decodeRepeatedSFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneElements // = 0 + case noneDecodeRepeatedSfixed64Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneElements + self = .noneDecodeRepeatedSfixed64Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneElements + case 0: self = .noneDecodeRepeatedSfixed64Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneElements: return 0 + case .noneDecodeRepeatedSfixed64Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed64Field] = [ + .noneDecodeRepeatedSfixed64Field, + ] + } - enum emitExtensionFieldName: SwiftProtobuf.Enum { + enum decodeRepeatedSInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEmitExtensionFieldName // = 0 + case noneDecodeRepeatedSint32Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEmitExtensionFieldName + self = .noneDecodeRepeatedSint32Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEmitExtensionFieldName + case 0: self = .noneDecodeRepeatedSint32Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEmitExtensionFieldName: return 0 + case .noneDecodeRepeatedSint32Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSInt32Field] = [ + .noneDecodeRepeatedSint32Field, + ] + } - enum emitFieldName: SwiftProtobuf.Enum { + enum decodeRepeatedSInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEmitFieldName // = 0 + case noneDecodeRepeatedSint64Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEmitFieldName + self = .noneDecodeRepeatedSint64Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEmitFieldName + case 0: self = .noneDecodeRepeatedSint64Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEmitFieldName: return 0 + case .noneDecodeRepeatedSint64Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSInt64Field] = [ + .noneDecodeRepeatedSint64Field, + ] + } - enum emitFieldNumber: SwiftProtobuf.Enum { + enum decodeRepeatedStringField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEmitFieldNumber // = 0 + case noneDecodeRepeatedStringField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEmitFieldNumber + self = .noneDecodeRepeatedStringField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEmitFieldNumber + case 0: self = .noneDecodeRepeatedStringField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEmitFieldNumber: return 0 + case .noneDecodeRepeatedStringField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedStringField] = [ + .noneDecodeRepeatedStringField, + ] + } - enum Empty: SwiftProtobuf.Enum { + enum decodeRepeatedUInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEmpty // = 0 + case noneDecodeRepeatedUint32Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEmpty + self = .noneDecodeRepeatedUint32Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEmpty + case 0: self = .noneDecodeRepeatedUint32Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEmpty: return 0 + case .noneDecodeRepeatedUint32Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedUInt32Field] = [ + .noneDecodeRepeatedUint32Field, + ] + } - enum emptyData: SwiftProtobuf.Enum { + enum decodeRepeatedUInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEmptyData // = 0 + case noneDecodeRepeatedUint64Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEmptyData + self = .noneDecodeRepeatedUint64Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEmptyData + case 0: self = .noneDecodeRepeatedUint64Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEmptyData: return 0 + case .noneDecodeRepeatedUint64Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedUInt64Field] = [ + .noneDecodeRepeatedUint64Field, + ] + } - enum encodeAsBytes: SwiftProtobuf.Enum { + enum decodeSingular: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEncodeAsBytes // = 0 + case noneDecodeSingular // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEncodeAsBytes + self = .noneDecodeSingular } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEncodeAsBytes + case 0: self = .noneDecodeSingular default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEncodeAsBytes: return 0 + case .noneDecodeSingular: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingular] = [ + .noneDecodeSingular, + ] + } - enum encoded: SwiftProtobuf.Enum { + enum decodeSingularBoolField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEncoded // = 0 + case noneDecodeSingularBoolField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEncoded + self = .noneDecodeSingularBoolField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEncoded + case 0: self = .noneDecodeSingularBoolField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEncoded: return 0 + case .noneDecodeSingularBoolField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularBoolField] = [ + .noneDecodeSingularBoolField, + ] + } - enum encodedJSONString: SwiftProtobuf.Enum { + enum decodeSingularBytesField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEncodedJsonstring // = 0 + case noneDecodeSingularBytesField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEncodedJsonstring + self = .noneDecodeSingularBytesField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEncodedJsonstring + case 0: self = .noneDecodeSingularBytesField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEncodedJsonstring: return 0 + case .noneDecodeSingularBytesField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularBytesField] = [ + .noneDecodeSingularBytesField, + ] + } - enum encodedSize: SwiftProtobuf.Enum { + enum decodeSingularDoubleField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEncodedSize // = 0 + case noneDecodeSingularDoubleField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEncodedSize + self = .noneDecodeSingularDoubleField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEncodedSize + case 0: self = .noneDecodeSingularDoubleField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEncodedSize: return 0 + case .noneDecodeSingularDoubleField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularDoubleField] = [ + .noneDecodeSingularDoubleField, + ] + } - enum encodeField: SwiftProtobuf.Enum { + enum decodeSingularEnumField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEncodeField // = 0 + case noneDecodeSingularEnumField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEncodeField + self = .noneDecodeSingularEnumField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEncodeField + case 0: self = .noneDecodeSingularEnumField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEncodeField: return 0 + case .noneDecodeSingularEnumField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularEnumField] = [ + .noneDecodeSingularEnumField, + ] + } - enum encoder: SwiftProtobuf.Enum { + enum decodeSingularFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEncoder // = 0 + case noneDecodeSingularFixed32Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEncoder + self = .noneDecodeSingularFixed32Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEncoder + case 0: self = .noneDecodeSingularFixed32Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEncoder: return 0 + case .noneDecodeSingularFixed32Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularFixed32Field] = [ + .noneDecodeSingularFixed32Field, + ] + } - enum end: SwiftProtobuf.Enum { + enum decodeSingularFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEnd // = 0 + case noneDecodeSingularFixed64Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEnd + self = .noneDecodeSingularFixed64Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEnd + case 0: self = .noneDecodeSingularFixed64Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEnd: return 0 + case .noneDecodeSingularFixed64Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularFixed64Field] = [ + .noneDecodeSingularFixed64Field, + ] + } - enum endArray: SwiftProtobuf.Enum { + enum decodeSingularFloatField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEndArray // = 0 + case noneDecodeSingularFloatField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEndArray + self = .noneDecodeSingularFloatField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEndArray + case 0: self = .noneDecodeSingularFloatField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEndArray: return 0 + case .noneDecodeSingularFloatField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularFloatField] = [ + .noneDecodeSingularFloatField, + ] + } - enum endMessageField: SwiftProtobuf.Enum { + enum decodeSingularGroupField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEndMessageField // = 0 + case noneDecodeSingularGroupField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEndMessageField + self = .noneDecodeSingularGroupField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEndMessageField + case 0: self = .noneDecodeSingularGroupField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEndMessageField: return 0 + case .noneDecodeSingularGroupField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularGroupField] = [ + .noneDecodeSingularGroupField, + ] + } - enum endObject: SwiftProtobuf.Enum { + enum decodeSingularInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEndObject // = 0 + case noneDecodeSingularInt32Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEndObject + self = .noneDecodeSingularInt32Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEndObject + case 0: self = .noneDecodeSingularInt32Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEndObject: return 0 + case .noneDecodeSingularInt32Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularInt32Field] = [ + .noneDecodeSingularInt32Field, + ] + } - enum endRegularField: SwiftProtobuf.Enum { + enum decodeSingularInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEndRegularField // = 0 + case noneDecodeSingularInt64Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEndRegularField + self = .noneDecodeSingularInt64Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEndRegularField + case 0: self = .noneDecodeSingularInt64Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEndRegularField: return 0 + case .noneDecodeSingularInt64Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularInt64Field] = [ + .noneDecodeSingularInt64Field, + ] + } - enum enumEnum: SwiftProtobuf.Enum { + enum decodeSingularMessageField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEnum // = 0 + case noneDecodeSingularMessageField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEnum + self = .noneDecodeSingularMessageField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEnum + case 0: self = .noneDecodeSingularMessageField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEnum: return 0 + case .noneDecodeSingularMessageField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularMessageField] = [ + .noneDecodeSingularMessageField, + ] + } - enum EnumDescriptorProto: SwiftProtobuf.Enum { + enum decodeSingularSFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEnumDescriptorProto // = 0 + case noneDecodeSingularSfixed32Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEnumDescriptorProto + self = .noneDecodeSingularSfixed32Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEnumDescriptorProto + case 0: self = .noneDecodeSingularSfixed32Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEnumDescriptorProto: return 0 + case .noneDecodeSingularSfixed32Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSFixed32Field] = [ + .noneDecodeSingularSfixed32Field, + ] + } - enum EnumOptions: SwiftProtobuf.Enum { + enum decodeSingularSFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEnumOptions // = 0 + case noneDecodeSingularSfixed64Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEnumOptions + self = .noneDecodeSingularSfixed64Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEnumOptions + case 0: self = .noneDecodeSingularSfixed64Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEnumOptions: return 0 + case .noneDecodeSingularSfixed64Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSFixed64Field] = [ + .noneDecodeSingularSfixed64Field, + ] + } - enum EnumReservedRange: SwiftProtobuf.Enum { + enum decodeSingularSInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEnumReservedRange // = 0 + case noneDecodeSingularSint32Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEnumReservedRange + self = .noneDecodeSingularSint32Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEnumReservedRange + case 0: self = .noneDecodeSingularSint32Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEnumReservedRange: return 0 + case .noneDecodeSingularSint32Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSInt32Field] = [ + .noneDecodeSingularSint32Field, + ] + } - enum enumType: SwiftProtobuf.Enum { + enum decodeSingularSInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEnumType // = 0 + case noneDecodeSingularSint64Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEnumType + self = .noneDecodeSingularSint64Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEnumType + case 0: self = .noneDecodeSingularSint64Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEnumType: return 0 + case .noneDecodeSingularSint64Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSInt64Field] = [ + .noneDecodeSingularSint64Field, + ] + } - enum enumvalue: SwiftProtobuf.Enum { + enum decodeSingularStringField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEnumvalue // = 0 + case noneDecodeSingularStringField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEnumvalue + self = .noneDecodeSingularStringField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEnumvalue + case 0: self = .noneDecodeSingularStringField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEnumvalue: return 0 + case .noneDecodeSingularStringField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularStringField] = [ + .noneDecodeSingularStringField, + ] + } - enum EnumValueDescriptorProto: SwiftProtobuf.Enum { + enum decodeSingularUInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEnumValueDescriptorProto // = 0 + case noneDecodeSingularUint32Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEnumValueDescriptorProto + self = .noneDecodeSingularUint32Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEnumValueDescriptorProto + case 0: self = .noneDecodeSingularUint32Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEnumValueDescriptorProto: return 0 + case .noneDecodeSingularUint32Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularUInt32Field] = [ + .noneDecodeSingularUint32Field, + ] + } - enum EnumValueOptions: SwiftProtobuf.Enum { + enum decodeSingularUInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEnumValueOptions // = 0 + case noneDecodeSingularUint64Field // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEnumValueOptions + self = .noneDecodeSingularUint64Field } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEnumValueOptions + case 0: self = .noneDecodeSingularUint64Field default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEnumValueOptions: return 0 + case .noneDecodeSingularUint64Field: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularUInt64Field] = [ + .noneDecodeSingularUint64Field, + ] + } - enum Equatable: SwiftProtobuf.Enum { + enum decodeTextFormat: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneEquatable // = 0 + case noneDecodeTextFormat // = 0 case UNRECOGNIZED(Int) init() { - self = .noneEquatable + self = .noneDecodeTextFormat } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneEquatable + case 0: self = .noneDecodeTextFormat default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneEquatable: return 0 + case .noneDecodeTextFormat: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeTextFormat] = [ + .noneDecodeTextFormat, + ] + } - enum Error: SwiftProtobuf.Enum { + enum defaultAnyTypeURLPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneError // = 0 + case noneDefaultAnyTypeUrlprefix // = 0 case UNRECOGNIZED(Int) init() { - self = .noneError + self = .noneDefaultAnyTypeUrlprefix } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneError + case 0: self = .noneDefaultAnyTypeUrlprefix default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneError: return 0 + case .noneDefaultAnyTypeUrlprefix: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaultAnyTypeURLPrefix] = [ + .noneDefaultAnyTypeUrlprefix, + ] + } - enum ExpressibleByArrayLiteral: SwiftProtobuf.Enum { + enum defaults: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneExpressibleByArrayLiteral // = 0 + case noneDefaults // = 0 case UNRECOGNIZED(Int) init() { - self = .noneExpressibleByArrayLiteral + self = .noneDefaults } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneExpressibleByArrayLiteral + case 0: self = .noneDefaults default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneExpressibleByArrayLiteral: return 0 + case .noneDefaults: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaults] = [ + .noneDefaults, + ] + } - enum ExpressibleByDictionaryLiteral: SwiftProtobuf.Enum { + enum defaultSymbolVisibility: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneExpressibleByDictionaryLiteral // = 0 + case noneDefaultSymbolVisibility // = 0 case UNRECOGNIZED(Int) init() { - self = .noneExpressibleByDictionaryLiteral + self = .noneDefaultSymbolVisibility } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneExpressibleByDictionaryLiteral + case 0: self = .noneDefaultSymbolVisibility default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneExpressibleByDictionaryLiteral: return 0 + case .noneDefaultSymbolVisibility: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaultSymbolVisibility] = [ + .noneDefaultSymbolVisibility, + ] + } - enum ext: SwiftProtobuf.Enum { + enum defaultValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneExt // = 0 + case noneDefaultValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneExt + self = .noneDefaultValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneExt + case 0: self = .noneDefaultValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneExt: return 0 + case .noneDefaultValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaultValue] = [ + .noneDefaultValue, + ] + } - enum extDecoder: SwiftProtobuf.Enum { + enum dependency: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneExtDecoder // = 0 + case noneDependency // = 0 case UNRECOGNIZED(Int) init() { - self = .noneExtDecoder + self = .noneDependency } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneExtDecoder + case 0: self = .noneDependency default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneExtDecoder: return 0 + case .noneDependency: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.dependency] = [ + .noneDependency, + ] + } - enum extendedGraphemeClusterLiteral: SwiftProtobuf.Enum { + enum deprecated: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneExtendedGraphemeClusterLiteral // = 0 + case noneDeprecated // = 0 case UNRECOGNIZED(Int) init() { - self = .noneExtendedGraphemeClusterLiteral + self = .noneDeprecated } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneExtendedGraphemeClusterLiteral + case 0: self = .noneDeprecated default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneExtendedGraphemeClusterLiteral: return 0 + case .noneDeprecated: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.deprecated] = [ + .noneDeprecated, + ] + } - enum ExtendedGraphemeClusterLiteralType: SwiftProtobuf.Enum { + enum deprecatedLegacyJsonFieldConflicts: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneExtendedGraphemeClusterLiteralType // = 0 + case noneDeprecatedLegacyJsonFieldConflicts // = 0 case UNRECOGNIZED(Int) init() { - self = .noneExtendedGraphemeClusterLiteralType + self = .noneDeprecatedLegacyJsonFieldConflicts } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneExtendedGraphemeClusterLiteralType + case 0: self = .noneDeprecatedLegacyJsonFieldConflicts default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneExtendedGraphemeClusterLiteralType: return 0 + case .noneDeprecatedLegacyJsonFieldConflicts: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.deprecatedLegacyJsonFieldConflicts] = [ + .noneDeprecatedLegacyJsonFieldConflicts, + ] + } - enum extendee: SwiftProtobuf.Enum { + enum deprecationWarning: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneExtendee // = 0 + case noneDeprecationWarning // = 0 case UNRECOGNIZED(Int) init() { - self = .noneExtendee + self = .noneDeprecationWarning } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneExtendee + case 0: self = .noneDeprecationWarning default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneExtendee: return 0 + case .noneDeprecationWarning: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.deprecationWarning] = [ + .noneDeprecationWarning, + ] + } - enum ExtensibleMessage: SwiftProtobuf.Enum { + enum descriptionEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneExtensibleMessage // = 0 + case noneDescription // = 0 case UNRECOGNIZED(Int) init() { - self = .noneExtensibleMessage + self = .noneDescription } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneExtensibleMessage + case 0: self = .noneDescription default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneExtensibleMessage: return 0 + case .noneDescription: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.descriptionEnum] = [ + .noneDescription, + ] + } - enum extensionEnum: SwiftProtobuf.Enum { + enum Dictionary: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneExtension // = 0 + case noneDictionary // = 0 case UNRECOGNIZED(Int) init() { - self = .noneExtension + self = .noneDictionary } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneExtension + case 0: self = .noneDictionary default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneExtension: return 0 + case .noneDictionary: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Dictionary] = [ + .noneDictionary, + ] + } - enum ExtensionField: SwiftProtobuf.Enum { + enum dictionaryLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneExtensionField // = 0 + case noneDictionaryLiteral // = 0 case UNRECOGNIZED(Int) init() { - self = .noneExtensionField + self = .noneDictionaryLiteral } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneExtensionField + case 0: self = .noneDictionaryLiteral default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneExtensionField: return 0 + case .noneDictionaryLiteral: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.dictionaryLiteral] = [ + .noneDictionaryLiteral, + ] + } - enum extensionFieldNumber: SwiftProtobuf.Enum { + enum digit: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneExtensionFieldNumber // = 0 + case noneDigit // = 0 case UNRECOGNIZED(Int) init() { - self = .noneExtensionFieldNumber + self = .noneDigit } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneExtensionFieldNumber + case 0: self = .noneDigit default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneExtensionFieldNumber: return 0 + case .noneDigit: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digit] = [ + .noneDigit, + ] + } - enum ExtensionFieldValueSet: SwiftProtobuf.Enum { + enum digit0: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneExtensionFieldValueSet // = 0 + case noneDigit0 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneExtensionFieldValueSet + self = .noneDigit0 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneExtensionFieldValueSet + case 0: self = .noneDigit0 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneExtensionFieldValueSet: return 0 + case .noneDigit0: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digit0] = [ + .noneDigit0, + ] + } - enum ExtensionMap: SwiftProtobuf.Enum { + enum digit1: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneExtensionMap // = 0 + case noneDigit1 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneExtensionMap + self = .noneDigit1 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneExtensionMap + case 0: self = .noneDigit1 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneExtensionMap: return 0 + case .noneDigit1: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digit1] = [ + .noneDigit1, + ] + } - enum extensionRange: SwiftProtobuf.Enum { + enum digitCount: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneExtensionRange // = 0 + case noneDigitCount // = 0 case UNRECOGNIZED(Int) init() { - self = .noneExtensionRange + self = .noneDigitCount } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneExtensionRange + case 0: self = .noneDigitCount default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneExtensionRange: return 0 + case .noneDigitCount: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digitCount] = [ + .noneDigitCount, + ] + } - enum ExtensionRangeOptions: SwiftProtobuf.Enum { + enum digits: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneExtensionRangeOptions // = 0 + case noneDigits // = 0 case UNRECOGNIZED(Int) init() { - self = .noneExtensionRangeOptions + self = .noneDigits } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneExtensionRangeOptions + case 0: self = .noneDigits default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneExtensionRangeOptions: return 0 + case .noneDigits: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digits] = [ + .noneDigits, + ] + } - enum extensions: SwiftProtobuf.Enum { + enum digitValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneExtensions // = 0 + case noneDigitValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneExtensions + self = .noneDigitValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneExtensions + case 0: self = .noneDigitValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneExtensions: return 0 + case .noneDigitValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digitValue] = [ + .noneDigitValue, + ] + } - enum extras: SwiftProtobuf.Enum { + enum discardableResult: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneExtras // = 0 + case noneDiscardableResult // = 0 case UNRECOGNIZED(Int) init() { - self = .noneExtras + self = .noneDiscardableResult } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneExtras + case 0: self = .noneDiscardableResult default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneExtras: return 0 + case .noneDiscardableResult: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.discardableResult] = [ + .noneDiscardableResult, + ] + } - enum F: SwiftProtobuf.Enum { + enum discardUnknownFields: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneF // = 0 + case noneDiscardUnknownFields // = 0 case UNRECOGNIZED(Int) init() { - self = .noneF + self = .noneDiscardUnknownFields } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneF + case 0: self = .noneDiscardUnknownFields default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneF: return 0 + case .noneDiscardUnknownFields: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.discardUnknownFields] = [ + .noneDiscardUnknownFields, + ] + } - enum falseEnum: SwiftProtobuf.Enum { + enum DoubleEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFalse // = 0 + case noneDouble // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFalse + self = .noneDouble } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFalse + case 0: self = .noneDouble default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFalse: return 0 + case .noneDouble: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.DoubleEnum] = [ + .noneDouble, + ] + } - enum field: SwiftProtobuf.Enum { + enum doubleValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneField // = 0 + case noneDoubleValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneField + self = .noneDoubleValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneField + case 0: self = .noneDoubleValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneField: return 0 + case .noneDoubleValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.doubleValue] = [ + .noneDoubleValue, + ] + } - enum fieldData: SwiftProtobuf.Enum { + enum duration: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFieldData // = 0 + case noneDuration // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFieldData + self = .noneDuration } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFieldData + case 0: self = .noneDuration default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFieldData: return 0 + case .noneDuration: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.duration] = [ + .noneDuration, + ] + } - enum FieldDescriptorProto: SwiftProtobuf.Enum { + enum E: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFieldDescriptorProto // = 0 + case noneE // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFieldDescriptorProto + self = .noneE } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFieldDescriptorProto + case 0: self = .noneE default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFieldDescriptorProto: return 0 + case .noneE: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.E] = [ + .noneE, + ] + } - enum FieldMask: SwiftProtobuf.Enum { + enum edition: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFieldMask // = 0 + case noneEdition // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFieldMask + self = .noneEdition } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFieldMask + case 0: self = .noneEdition default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFieldMask: return 0 + case .noneEdition: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.edition] = [ + .noneEdition, + ] + } - enum fieldName: SwiftProtobuf.Enum { + enum EditionDefault: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFieldName // = 0 + case noneEditionDefault // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFieldName + self = .noneEditionDefault } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFieldName + case 0: self = .noneEditionDefault default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFieldName: return 0 + case .noneEditionDefault: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.EditionDefault] = [ + .noneEditionDefault, + ] + } - enum fieldNameCount: SwiftProtobuf.Enum { + enum editionDefaults: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFieldNameCount // = 0 + case noneEditionDefaults // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFieldNameCount + self = .noneEditionDefaults } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFieldNameCount + case 0: self = .noneEditionDefaults default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFieldNameCount: return 0 + case .noneEditionDefaults: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionDefaults] = [ + .noneEditionDefaults, + ] + } - enum fieldNum: SwiftProtobuf.Enum { + enum editionDeprecated: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFieldNum // = 0 + case noneEditionDeprecated // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFieldNum + self = .noneEditionDeprecated } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFieldNum + case 0: self = .noneEditionDeprecated default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFieldNum: return 0 + case .noneEditionDeprecated: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionDeprecated] = [ + .noneEditionDeprecated, + ] + } - enum fieldNumber: SwiftProtobuf.Enum { + enum editionIntroduced: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFieldNumber // = 0 + case noneEditionIntroduced // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFieldNumber + self = .noneEditionIntroduced } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFieldNumber + case 0: self = .noneEditionIntroduced default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFieldNumber: return 0 + case .noneEditionIntroduced: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionIntroduced] = [ + .noneEditionIntroduced, + ] + } - enum fieldNumberForProto: SwiftProtobuf.Enum { + enum editionRemoved: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFieldNumberForProto // = 0 + case noneEditionRemoved // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFieldNumberForProto + self = .noneEditionRemoved } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFieldNumberForProto + case 0: self = .noneEditionRemoved default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFieldNumberForProto: return 0 + case .noneEditionRemoved: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionRemoved] = [ + .noneEditionRemoved, + ] + } - enum FieldOptions: SwiftProtobuf.Enum { + enum Element: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFieldOptions // = 0 + case noneElement // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFieldOptions + self = .noneElement } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFieldOptions + case 0: self = .noneElement default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFieldOptions: return 0 + case .noneElement: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Element] = [ + .noneElement, + ] + } - enum fields: SwiftProtobuf.Enum { + enum elements: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFields // = 0 + case noneElements // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFields + self = .noneElements } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFields + case 0: self = .noneElements default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFields: return 0 + case .noneElements: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.elements] = [ + .noneElements, + ] + } - enum fieldSize: SwiftProtobuf.Enum { + enum elseEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFieldSize // = 0 + case noneElse // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFieldSize + self = .noneElse } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFieldSize + case 0: self = .noneElse default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFieldSize: return 0 + case .noneElse: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.elseEnum] = [ + .noneElse, + ] + } - enum FieldTag: SwiftProtobuf.Enum { + enum emitExtensionFieldName: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFieldTag // = 0 + case noneEmitExtensionFieldName // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFieldTag + self = .noneEmitExtensionFieldName } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFieldTag + case 0: self = .noneEmitExtensionFieldName default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFieldTag: return 0 + case .noneEmitExtensionFieldName: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emitExtensionFieldName] = [ + .noneEmitExtensionFieldName, + ] + } - enum fieldType: SwiftProtobuf.Enum { + enum emitFieldName: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFieldType // = 0 + case noneEmitFieldName // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFieldType + self = .noneEmitFieldName } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFieldType + case 0: self = .noneEmitFieldName default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFieldType: return 0 + case .noneEmitFieldName: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emitFieldName] = [ + .noneEmitFieldName, + ] + } - enum file: SwiftProtobuf.Enum { + enum emitFieldNumber: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFile // = 0 + case noneEmitFieldNumber // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFile + self = .noneEmitFieldNumber } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFile + case 0: self = .noneEmitFieldNumber default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFile: return 0 + case .noneEmitFieldNumber: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emitFieldNumber] = [ + .noneEmitFieldNumber, + ] + } - enum FileDescriptorProto: SwiftProtobuf.Enum { + enum emptyAnyTypeURL: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFileDescriptorProto // = 0 + case noneEmptyAnyTypeURL // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFileDescriptorProto + self = .noneEmptyAnyTypeURL } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFileDescriptorProto + case 0: self = .noneEmptyAnyTypeURL default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFileDescriptorProto: return 0 + case .noneEmptyAnyTypeURL: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emptyAnyTypeURL] = [ + .noneEmptyAnyTypeURL, + ] + } - enum FileDescriptorSet: SwiftProtobuf.Enum { + enum emptyData: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFileDescriptorSet // = 0 + case noneEmptyData // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFileDescriptorSet + self = .noneEmptyData } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFileDescriptorSet + case 0: self = .noneEmptyData default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFileDescriptorSet: return 0 + case .noneEmptyData: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emptyData] = [ + .noneEmptyData, + ] + } - enum fileName: SwiftProtobuf.Enum { + enum encodeAsBytes: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFileName // = 0 + case noneEncodeAsBytes // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFileName + self = .noneEncodeAsBytes } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFileName + case 0: self = .noneEncodeAsBytes default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFileName: return 0 + case .noneEncodeAsBytes: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodeAsBytes] = [ + .noneEncodeAsBytes, + ] + } - enum FileOptions: SwiftProtobuf.Enum { + enum encoded: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFileOptions // = 0 + case noneEncoded // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFileOptions + self = .noneEncoded } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFileOptions + case 0: self = .noneEncoded default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFileOptions: return 0 + case .noneEncoded: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encoded] = [ + .noneEncoded, + ] + } - enum filter: SwiftProtobuf.Enum { + enum encodedJSONString: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFilter // = 0 + case noneEncodedJsonstring // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFilter + self = .noneEncodedJsonstring } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFilter + case 0: self = .noneEncodedJsonstring default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFilter: return 0 + case .noneEncodedJsonstring: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodedJSONString] = [ + .noneEncodedJsonstring, + ] + } - enum first: SwiftProtobuf.Enum { + enum encodedSize: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFirst // = 0 + case noneEncodedSize // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFirst + self = .noneEncodedSize } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFirst + case 0: self = .noneEncodedSize default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFirst: return 0 + case .noneEncodedSize: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodedSize] = [ + .noneEncodedSize, + ] + } - enum firstItem: SwiftProtobuf.Enum { + enum encodeField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFirstItem // = 0 + case noneEncodeField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFirstItem + self = .noneEncodeField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFirstItem + case 0: self = .noneEncodeField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFirstItem: return 0 + case .noneEncodeField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodeField] = [ + .noneEncodeField, + ] + } - enum float: SwiftProtobuf.Enum { + enum encoder: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFloat // = 0 + case noneEncoder // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFloat + self = .noneEncoder } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFloat + case 0: self = .noneEncoder default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFloat: return 0 + case .noneEncoder: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encoder] = [ + .noneEncoder, + ] + } - enum floatLiteral: SwiftProtobuf.Enum { + enum end: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFloatLiteral // = 0 + case noneEnd // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFloatLiteral + self = .noneEnd } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFloatLiteral + case 0: self = .noneEnd default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFloatLiteral: return 0 + case .noneEnd: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.end] = [ + .noneEnd, + ] + } - enum FloatLiteralType: SwiftProtobuf.Enum { + enum endArray: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFloatLiteralType // = 0 + case noneEndArray // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFloatLiteralType + self = .noneEndArray } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFloatLiteralType + case 0: self = .noneEndArray default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFloatLiteralType: return 0 + case .noneEndArray: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endArray] = [ + .noneEndArray, + ] + } - enum FloatValue: SwiftProtobuf.Enum { + enum endMessageField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFloatValue // = 0 + case noneEndMessageField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFloatValue + self = .noneEndMessageField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFloatValue + case 0: self = .noneEndMessageField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFloatValue: return 0 + case .noneEndMessageField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endMessageField] = [ + .noneEndMessageField, + ] + } - enum forMessageName: SwiftProtobuf.Enum { + enum endObject: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneForMessageName // = 0 + case noneEndObject // = 0 case UNRECOGNIZED(Int) init() { - self = .noneForMessageName + self = .noneEndObject } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneForMessageName + case 0: self = .noneEndObject default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneForMessageName: return 0 + case .noneEndObject: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endObject] = [ + .noneEndObject, + ] + } - enum formUnion: SwiftProtobuf.Enum { + enum endRegularField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFormUnion // = 0 + case noneEndRegularField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFormUnion + self = .noneEndRegularField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFormUnion + case 0: self = .noneEndRegularField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFormUnion: return 0 + case .noneEndRegularField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endRegularField] = [ + .noneEndRegularField, + ] + } - enum forReadingFrom: SwiftProtobuf.Enum { + enum enforceNamingStyle: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneForReadingFrom // = 0 + case noneEnforceNamingStyle // = 0 case UNRECOGNIZED(Int) init() { - self = .noneForReadingFrom + self = .noneEnforceNamingStyle } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneForReadingFrom + case 0: self = .noneEnforceNamingStyle default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneForReadingFrom: return 0 + case .noneEnforceNamingStyle: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enforceNamingStyle] = [ + .noneEnforceNamingStyle, + ] + } - enum forTypeURL: SwiftProtobuf.Enum { + enum enumEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneForTypeURL // = 0 + case noneEnum // = 0 case UNRECOGNIZED(Int) init() { - self = .noneForTypeURL + self = .noneEnum } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneForTypeURL + case 0: self = .noneEnum default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneForTypeURL: return 0 + case .noneEnum: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enumEnum] = [ + .noneEnum, + ] + } - enum ForwardParser: SwiftProtobuf.Enum { + enum EnumReservedRange: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneForwardParser // = 0 + case noneEnumReservedRange // = 0 case UNRECOGNIZED(Int) init() { - self = .noneForwardParser + self = .noneEnumReservedRange } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneForwardParser + case 0: self = .noneEnumReservedRange default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneForwardParser: return 0 + case .noneEnumReservedRange: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.EnumReservedRange] = [ + .noneEnumReservedRange, + ] + } - enum forWritingInto: SwiftProtobuf.Enum { + enum enumType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneForWritingInto // = 0 + case noneEnumType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneForWritingInto + self = .noneEnumType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneForWritingInto + case 0: self = .noneEnumType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneForWritingInto: return 0 + case .noneEnumType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enumType] = [ + .noneEnumType, + ] + } - enum from: SwiftProtobuf.Enum { + enum enumvalue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFrom // = 0 + case noneEnumvalue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFrom + self = .noneEnumvalue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFrom + case 0: self = .noneEnumvalue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFrom: return 0 + case .noneEnumvalue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enumvalue] = [ + .noneEnumvalue, + ] + } - enum fromAscii2: SwiftProtobuf.Enum { + enum EquatableEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFromAscii2 // = 0 + case noneEquatable // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFromAscii2 + self = .noneEquatable } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFromAscii2 + case 0: self = .noneEquatable default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFromAscii2: return 0 + case .noneEquatable: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.EquatableEnum] = [ + .noneEquatable, + ] + } - enum fromAscii4: SwiftProtobuf.Enum { + enum Error: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFromAscii4 // = 0 + case noneError // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFromAscii4 + self = .noneError } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFromAscii4 + case 0: self = .noneError default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFromAscii4: return 0 + case .noneError: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Error] = [ + .noneError, + ] + } - enum fromByteOffset: SwiftProtobuf.Enum { + enum execute: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFromByteOffset // = 0 + case noneExecute // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFromByteOffset + self = .noneExecute } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFromByteOffset + case 0: self = .noneExecute default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFromByteOffset: return 0 + case .noneExecute: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.execute] = [ + .noneExecute, + ] + } - enum fromHexDigit: SwiftProtobuf.Enum { + enum ExpressibleByArrayLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFromHexDigit // = 0 + case noneExpressibleByArrayLiteral // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFromHexDigit + self = .noneExpressibleByArrayLiteral } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFromHexDigit + case 0: self = .noneExpressibleByArrayLiteral default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFromHexDigit: return 0 + case .noneExpressibleByArrayLiteral: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExpressibleByArrayLiteral] = [ + .noneExpressibleByArrayLiteral, + ] + } - enum funcEnum: SwiftProtobuf.Enum { + enum ExpressibleByDictionaryLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneFunc // = 0 + case noneExpressibleByDictionaryLiteral // = 0 case UNRECOGNIZED(Int) init() { - self = .noneFunc + self = .noneExpressibleByDictionaryLiteral } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneFunc + case 0: self = .noneExpressibleByDictionaryLiteral default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneFunc: return 0 + case .noneExpressibleByDictionaryLiteral: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExpressibleByDictionaryLiteral] = [ + .noneExpressibleByDictionaryLiteral, + ] + } - enum G: SwiftProtobuf.Enum { + enum ext: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneG // = 0 + case noneExt // = 0 case UNRECOGNIZED(Int) init() { - self = .noneG + self = .noneExt } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneG + case 0: self = .noneExt default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneG: return 0 + case .noneExt: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ext] = [ + .noneExt, + ] + } - enum GeneratedCodeInfo: SwiftProtobuf.Enum { + enum extDecoder: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGeneratedCodeInfo // = 0 + case noneExtDecoder // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGeneratedCodeInfo + self = .noneExtDecoder } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGeneratedCodeInfo + case 0: self = .noneExtDecoder default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGeneratedCodeInfo: return 0 + case .noneExtDecoder: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extDecoder] = [ + .noneExtDecoder, + ] + } - enum get: SwiftProtobuf.Enum { + enum extendedGraphemeClusterLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGet // = 0 + case noneExtendedGraphemeClusterLiteral // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGet + self = .noneExtendedGraphemeClusterLiteral } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGet + case 0: self = .noneExtendedGraphemeClusterLiteral default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGet: return 0 + case .noneExtendedGraphemeClusterLiteral: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extendedGraphemeClusterLiteral] = [ + .noneExtendedGraphemeClusterLiteral, + ] + } - enum getExtensionValue: SwiftProtobuf.Enum { + enum ExtendedGraphemeClusterLiteralType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGetExtensionValue // = 0 + case noneExtendedGraphemeClusterLiteralType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGetExtensionValue + self = .noneExtendedGraphemeClusterLiteralType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGetExtensionValue + case 0: self = .noneExtendedGraphemeClusterLiteralType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGetExtensionValue: return 0 + case .noneExtendedGraphemeClusterLiteralType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtendedGraphemeClusterLiteralType] = [ + .noneExtendedGraphemeClusterLiteralType, + ] + } - enum googleapis: SwiftProtobuf.Enum { + enum extendee: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleapis // = 0 + case noneExtendee // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleapis + self = .noneExtendee } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleapis + case 0: self = .noneExtendee default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleapis: return 0 + case .noneExtendee: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extendee] = [ + .noneExtendee, + ] + } - enum Google_Protobuf_Any: SwiftProtobuf.Enum { + enum ExtensibleMessage: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufAny // = 0 + case noneExtensibleMessage // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufAny + self = .noneExtensibleMessage } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufAny + case 0: self = .noneExtensibleMessage default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufAny: return 0 + case .noneExtensibleMessage: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensibleMessage] = [ + .noneExtensibleMessage, + ] + } - enum Google_Protobuf_Api: SwiftProtobuf.Enum { + enum extensionEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufApi // = 0 + case noneExtension // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufApi + self = .noneExtension } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufApi + case 0: self = .noneExtension default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufApi: return 0 + case .noneExtension: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionEnum] = [ + .noneExtension, + ] + } - enum Google_Protobuf_BoolValue: SwiftProtobuf.Enum { + enum ExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufBoolValue // = 0 + case noneExtensionField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufBoolValue + self = .noneExtensionField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufBoolValue + case 0: self = .noneExtensionField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufBoolValue: return 0 + case .noneExtensionField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionField] = [ + .noneExtensionField, + ] + } - enum Google_Protobuf_BytesValue: SwiftProtobuf.Enum { + enum extensionFieldNumber: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufBytesValue // = 0 + case noneExtensionFieldNumber // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufBytesValue + self = .noneExtensionFieldNumber } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufBytesValue + case 0: self = .noneExtensionFieldNumber default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufBytesValue: return 0 + case .noneExtensionFieldNumber: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionFieldNumber] = [ + .noneExtensionFieldNumber, + ] + } - enum Google_Protobuf_DescriptorProto: SwiftProtobuf.Enum { + enum ExtensionFieldValueSet: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufDescriptorProto // = 0 + case noneExtensionFieldValueSet // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufDescriptorProto + self = .noneExtensionFieldValueSet } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufDescriptorProto + case 0: self = .noneExtensionFieldValueSet default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufDescriptorProto: return 0 + case .noneExtensionFieldValueSet: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionFieldValueSet] = [ + .noneExtensionFieldValueSet, + ] + } - enum Google_Protobuf_DoubleValue: SwiftProtobuf.Enum { + enum ExtensionMap: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufDoubleValue // = 0 + case noneExtensionMap // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufDoubleValue + self = .noneExtensionMap } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufDoubleValue + case 0: self = .noneExtensionMap default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufDoubleValue: return 0 + case .noneExtensionMap: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionMap] = [ + .noneExtensionMap, + ] + } - enum Google_Protobuf_Duration: SwiftProtobuf.Enum { + enum extensionRange: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufDuration // = 0 + case noneExtensionRange // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufDuration + self = .noneExtensionRange } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufDuration + case 0: self = .noneExtensionRange default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufDuration: return 0 + case .noneExtensionRange: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionRange] = [ + .noneExtensionRange, + ] + } - enum Google_Protobuf_Empty: SwiftProtobuf.Enum { + enum extensions: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufEmpty // = 0 + case noneExtensions // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufEmpty + self = .noneExtensions } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufEmpty + case 0: self = .noneExtensions default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufEmpty: return 0 + case .noneExtensions: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensions] = [ + .noneExtensions, + ] + } - enum Google_Protobuf_Enum: SwiftProtobuf.Enum { + enum extras: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufEnum // = 0 + case noneExtras // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufEnum + self = .noneExtras } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufEnum + case 0: self = .noneExtras default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufEnum: return 0 + case .noneExtras: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extras] = [ + .noneExtras, + ] + } - enum Google_Protobuf_EnumDescriptorProto: SwiftProtobuf.Enum { + enum F: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufEnumDescriptorProto // = 0 + case noneF // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufEnumDescriptorProto + self = .noneF } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufEnumDescriptorProto + case 0: self = .noneF default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufEnumDescriptorProto: return 0 + case .noneF: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.F] = [ + .noneF, + ] + } - enum Google_Protobuf_EnumOptions: SwiftProtobuf.Enum { + enum falseEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufEnumOptions // = 0 + case noneFalse // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufEnumOptions + self = .noneFalse } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufEnumOptions + case 0: self = .noneFalse default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufEnumOptions: return 0 + case .noneFalse: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.falseEnum] = [ + .noneFalse, + ] + } - enum Google_Protobuf_EnumValue: SwiftProtobuf.Enum { + enum features: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufEnumValue // = 0 + case noneFeatures // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufEnumValue + self = .noneFeatures } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufEnumValue + case 0: self = .noneFeatures default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufEnumValue: return 0 + case .noneFeatures: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.features] = [ + .noneFeatures, + ] + } - enum Google_Protobuf_EnumValueDescriptorProto: SwiftProtobuf.Enum { + enum FeatureSetEditionDefault: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufEnumValueDescriptorProto // = 0 + case noneFeatureSetEditionDefault // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufEnumValueDescriptorProto + self = .noneFeatureSetEditionDefault } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufEnumValueDescriptorProto + case 0: self = .noneFeatureSetEditionDefault default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufEnumValueDescriptorProto: return 0 + case .noneFeatureSetEditionDefault: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FeatureSetEditionDefault] = [ + .noneFeatureSetEditionDefault, + ] + } - enum Google_Protobuf_EnumValueOptions: SwiftProtobuf.Enum { + enum featureSupport: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufEnumValueOptions // = 0 + case noneFeatureSupport // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufEnumValueOptions + self = .noneFeatureSupport } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufEnumValueOptions + case 0: self = .noneFeatureSupport default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufEnumValueOptions: return 0 + case .noneFeatureSupport: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.featureSupport] = [ + .noneFeatureSupport, + ] + } - enum Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.Enum { + enum field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufExtensionRangeOptions // = 0 + case noneField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufExtensionRangeOptions + self = .noneField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufExtensionRangeOptions + case 0: self = .noneField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufExtensionRangeOptions: return 0 + case .noneField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.field] = [ + .noneField, + ] + } - enum Google_Protobuf_Field: SwiftProtobuf.Enum { + enum fieldData: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufField // = 0 + case noneFieldData // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufField + self = .noneFieldData } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufField + case 0: self = .noneFieldData default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufField: return 0 + case .noneFieldData: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldData] = [ + .noneFieldData, + ] + } - enum Google_Protobuf_FieldDescriptorProto: SwiftProtobuf.Enum { + enum FieldMaskError: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufFieldDescriptorProto // = 0 + case noneFieldMaskError // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufFieldDescriptorProto + self = .noneFieldMaskError } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufFieldDescriptorProto + case 0: self = .noneFieldMaskError default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufFieldDescriptorProto: return 0 + case .noneFieldMaskError: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FieldMaskError] = [ + .noneFieldMaskError, + ] + } - enum Google_Protobuf_FieldMask: SwiftProtobuf.Enum { + enum fieldName: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufFieldMask // = 0 + case noneFieldName // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufFieldMask + self = .noneFieldName } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufFieldMask + case 0: self = .noneFieldName default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufFieldMask: return 0 + case .noneFieldName: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldName] = [ + .noneFieldName, + ] + } - enum Google_Protobuf_FieldOptions: SwiftProtobuf.Enum { + enum fieldNameCount: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufFieldOptions // = 0 + case noneFieldNameCount // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufFieldOptions + self = .noneFieldNameCount } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufFieldOptions + case 0: self = .noneFieldNameCount default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufFieldOptions: return 0 + case .noneFieldNameCount: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNameCount] = [ + .noneFieldNameCount, + ] + } - enum Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Enum { + enum fieldNum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufFileDescriptorProto // = 0 + case noneFieldNum // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufFileDescriptorProto + self = .noneFieldNum } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufFileDescriptorProto + case 0: self = .noneFieldNum default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufFileDescriptorProto: return 0 + case .noneFieldNum: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNum] = [ + .noneFieldNum, + ] + } - enum Google_Protobuf_FileDescriptorSet: SwiftProtobuf.Enum { + enum fieldNumber: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufFileDescriptorSet // = 0 + case noneFieldNumber // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufFileDescriptorSet + self = .noneFieldNumber } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufFileDescriptorSet + case 0: self = .noneFieldNumber default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufFileDescriptorSet: return 0 + case .noneFieldNumber: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNumber] = [ + .noneFieldNumber, + ] + } - enum Google_Protobuf_FileOptions: SwiftProtobuf.Enum { + enum fieldNumberForProto: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufFileOptions // = 0 + case noneFieldNumberForProto // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufFileOptions + self = .noneFieldNumberForProto } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufFileOptions + case 0: self = .noneFieldNumberForProto default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufFileOptions: return 0 + case .noneFieldNumberForProto: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNumberForProto] = [ + .noneFieldNumberForProto, + ] + } - enum Google_Protobuf_FloatValue: SwiftProtobuf.Enum { + enum fieldPresence: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufFloatValue // = 0 + case noneFieldPresence // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufFloatValue + self = .noneFieldPresence } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufFloatValue + case 0: self = .noneFieldPresence default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufFloatValue: return 0 + case .noneFieldPresence: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldPresence] = [ + .noneFieldPresence, + ] + } - enum Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf.Enum { + enum fields: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufGeneratedCodeInfo // = 0 + case noneFields // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufGeneratedCodeInfo + self = .noneFields } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufGeneratedCodeInfo + case 0: self = .noneFields default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufGeneratedCodeInfo: return 0 + case .noneFields: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fields] = [ + .noneFields, + ] + } - enum Google_Protobuf_Int32Value: SwiftProtobuf.Enum { + enum fieldSize: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufInt32Value // = 0 + case noneFieldSize // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufInt32Value + self = .noneFieldSize } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufInt32Value + case 0: self = .noneFieldSize default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufInt32Value: return 0 + case .noneFieldSize: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldSize] = [ + .noneFieldSize, + ] + } - enum Google_Protobuf_Int64Value: SwiftProtobuf.Enum { + enum FieldTag: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufInt64Value // = 0 + case noneFieldTag // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufInt64Value + self = .noneFieldTag } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufInt64Value + case 0: self = .noneFieldTag default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufInt64Value: return 0 + case .noneFieldTag: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FieldTag] = [ + .noneFieldTag, + ] + } - enum Google_Protobuf_ListValue: SwiftProtobuf.Enum { + enum FieldType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufListValue // = 0 + case noneFieldType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufListValue + self = .noneFieldType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufListValue + case 0: self = .noneFieldType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufListValue: return 0 + case .noneFieldType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FieldType] = [ + .noneFieldType, + ] + } - enum Google_Protobuf_MessageOptions: SwiftProtobuf.Enum { + enum file: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufMessageOptions // = 0 + case noneFile // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufMessageOptions + self = .noneFile } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufMessageOptions + case 0: self = .noneFile default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufMessageOptions: return 0 + case .noneFile: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.file] = [ + .noneFile, + ] + } - enum Google_Protobuf_Method: SwiftProtobuf.Enum { + enum fileName: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufMethod // = 0 + case noneFileName // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufMethod + self = .noneFileName } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufMethod + case 0: self = .noneFileName default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufMethod: return 0 + case .noneFileName: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fileName] = [ + .noneFileName, + ] + } - enum Google_Protobuf_MethodDescriptorProto: SwiftProtobuf.Enum { + enum filter: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufMethodDescriptorProto // = 0 + case noneFilter // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufMethodDescriptorProto + self = .noneFilter } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufMethodDescriptorProto + case 0: self = .noneFilter default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufMethodDescriptorProto: return 0 + case .noneFilter: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.filter] = [ + .noneFilter, + ] + } - enum Google_Protobuf_MethodOptions: SwiftProtobuf.Enum { + enum final: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufMethodOptions // = 0 + case noneFinal // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufMethodOptions + self = .noneFinal } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufMethodOptions + case 0: self = .noneFinal default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufMethodOptions: return 0 + case .noneFinal: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.final] = [ + .noneFinal, + ] + } - enum Google_Protobuf_Mixin: SwiftProtobuf.Enum { + enum finiteOnly: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufMixin // = 0 + case noneFiniteOnly // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufMixin + self = .noneFiniteOnly } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufMixin + case 0: self = .noneFiniteOnly default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufMixin: return 0 + case .noneFiniteOnly: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.finiteOnly] = [ + .noneFiniteOnly, + ] + } - enum Google_Protobuf_NullValue: SwiftProtobuf.Enum { + enum first: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufNullValue // = 0 + case noneFirst // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufNullValue + self = .noneFirst } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufNullValue + case 0: self = .noneFirst default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufNullValue: return 0 + case .noneFirst: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.first] = [ + .noneFirst, + ] + } - enum Google_Protobuf_OneofDescriptorProto: SwiftProtobuf.Enum { + enum firstItem: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufOneofDescriptorProto // = 0 + case noneFirstItem // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufOneofDescriptorProto + self = .noneFirstItem } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufOneofDescriptorProto + case 0: self = .noneFirstItem default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufOneofDescriptorProto: return 0 + case .noneFirstItem: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.firstItem] = [ + .noneFirstItem, + ] + } - enum Google_Protobuf_OneofOptions: SwiftProtobuf.Enum { + enum fixedFeatures: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufOneofOptions // = 0 + case noneFixedFeatures // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufOneofOptions + self = .noneFixedFeatures } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufOneofOptions + case 0: self = .noneFixedFeatures default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufOneofOptions: return 0 + case .noneFixedFeatures: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fixedFeatures] = [ + .noneFixedFeatures, + ] + } - enum Google_Protobuf_Option: SwiftProtobuf.Enum { + enum FloatEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufOption // = 0 + case noneFloat // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufOption + self = .noneFloat } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufOption + case 0: self = .noneFloat default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufOption: return 0 + case .noneFloat: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FloatEnum] = [ + .noneFloat, + ] + } - enum Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf.Enum { + enum floatLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufServiceDescriptorProto // = 0 + case noneFloatLiteral // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufServiceDescriptorProto + self = .noneFloatLiteral } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufServiceDescriptorProto + case 0: self = .noneFloatLiteral default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufServiceDescriptorProto: return 0 + case .noneFloatLiteral: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.floatLiteral] = [ + .noneFloatLiteral, + ] + } - enum Google_Protobuf_ServiceOptions: SwiftProtobuf.Enum { + enum FloatLiteralType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufServiceOptions // = 0 + case noneFloatLiteralType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufServiceOptions + self = .noneFloatLiteralType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufServiceOptions + case 0: self = .noneFloatLiteralType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufServiceOptions: return 0 + case .noneFloatLiteralType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FloatLiteralType] = [ + .noneFloatLiteralType, + ] + } - enum Google_Protobuf_SourceCodeInfo: SwiftProtobuf.Enum { + enum forEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufSourceCodeInfo // = 0 + case noneFor // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufSourceCodeInfo + self = .noneFor } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufSourceCodeInfo + case 0: self = .noneFor default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufSourceCodeInfo: return 0 + case .noneFor: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forEnum] = [ + .noneFor, + ] + } - enum Google_Protobuf_SourceContext: SwiftProtobuf.Enum { + enum forMessageName: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufSourceContext // = 0 + case noneForMessageName // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufSourceContext + self = .noneForMessageName } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufSourceContext + case 0: self = .noneForMessageName default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufSourceContext: return 0 + case .noneForMessageName: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forMessageName] = [ + .noneForMessageName, + ] + } - enum Google_Protobuf_StringValue: SwiftProtobuf.Enum { + enum formUnion: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufStringValue // = 0 + case noneFormUnion // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufStringValue + self = .noneFormUnion } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufStringValue + case 0: self = .noneFormUnion default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufStringValue: return 0 + case .noneFormUnion: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.formUnion] = [ + .noneFormUnion, + ] + } - enum Google_Protobuf_Struct: SwiftProtobuf.Enum { + enum forReadingFrom: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufStruct // = 0 + case noneForReadingFrom // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufStruct + self = .noneForReadingFrom } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufStruct + case 0: self = .noneForReadingFrom default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufStruct: return 0 + case .noneForReadingFrom: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forReadingFrom] = [ + .noneForReadingFrom, + ] + } - enum Google_Protobuf_Syntax: SwiftProtobuf.Enum { + enum forTypeURL: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufSyntax // = 0 + case noneForTypeURL // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufSyntax + self = .noneForTypeURL } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufSyntax + case 0: self = .noneForTypeURL default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufSyntax: return 0 + case .noneForTypeURL: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forTypeURL] = [ + .noneForTypeURL, + ] + } - enum Google_Protobuf_Timestamp: SwiftProtobuf.Enum { + enum ForwardParser: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufTimestamp // = 0 + case noneForwardParser // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufTimestamp + self = .noneForwardParser } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufTimestamp + case 0: self = .noneForwardParser default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufTimestamp: return 0 + case .noneForwardParser: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ForwardParser] = [ + .noneForwardParser, + ] + } - enum Google_Protobuf_Type: SwiftProtobuf.Enum { + enum forWritingInto: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufType // = 0 + case noneForWritingInto // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufType + self = .noneForWritingInto } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufType + case 0: self = .noneForWritingInto default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufType: return 0 + case .noneForWritingInto: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forWritingInto] = [ + .noneForWritingInto, + ] + } - enum Google_Protobuf_UInt32Value: SwiftProtobuf.Enum { + enum from: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufUint32Value // = 0 + case noneFrom // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufUint32Value + self = .noneFrom } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufUint32Value + case 0: self = .noneFrom default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufUint32Value: return 0 + case .noneFrom: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.from] = [ + .noneFrom, + ] + } - enum Google_Protobuf_UInt64Value: SwiftProtobuf.Enum { + enum fromAscii2: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufUint64Value // = 0 + case noneFromAscii2 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufUint64Value + self = .noneFromAscii2 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufUint64Value + case 0: self = .noneFromAscii2 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufUint64Value: return 0 + case .noneFromAscii2: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromAscii2] = [ + .noneFromAscii2, + ] + } - enum Google_Protobuf_UninterpretedOption: SwiftProtobuf.Enum { + enum fromAscii4: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufUninterpretedOption // = 0 + case noneFromAscii4 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufUninterpretedOption + self = .noneFromAscii4 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufUninterpretedOption + case 0: self = .noneFromAscii4 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufUninterpretedOption: return 0 + case .noneFromAscii4: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromAscii4] = [ + .noneFromAscii4, + ] + } - enum Google_Protobuf_Value: SwiftProtobuf.Enum { + enum fromByteOffset: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoogleProtobufValue // = 0 + case noneFromByteOffset // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoogleProtobufValue + self = .noneFromByteOffset } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoogleProtobufValue + case 0: self = .noneFromByteOffset default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoogleProtobufValue: return 0 + case .noneFromByteOffset: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromByteOffset] = [ + .noneFromByteOffset, + ] + } - enum goPackage: SwiftProtobuf.Enum { + enum fromHexDigit: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGoPackage // = 0 + case noneFromHexDigit // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGoPackage + self = .noneFromHexDigit } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGoPackage + case 0: self = .noneFromHexDigit default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGoPackage: return 0 + case .noneFromHexDigit: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromHexDigit] = [ + .noneFromHexDigit, + ] + } - enum group: SwiftProtobuf.Enum { + enum fullName: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGroup // = 0 + case noneFullName // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGroup + self = .noneFullName } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGroup + case 0: self = .noneFullName default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGroup: return 0 + case .noneFullName: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fullName] = [ + .noneFullName, + ] + } - enum groupFieldNumberStack: SwiftProtobuf.Enum { + enum funcEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGroupFieldNumberStack // = 0 + case noneFunc // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGroupFieldNumberStack + self = .noneFunc } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGroupFieldNumberStack + case 0: self = .noneFunc default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGroupFieldNumberStack: return 0 + case .noneFunc: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.funcEnum] = [ + .noneFunc, + ] + } - enum groupSize: SwiftProtobuf.Enum { + enum function: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneGroupSize // = 0 + case noneFunction // = 0 case UNRECOGNIZED(Int) init() { - self = .noneGroupSize + self = .noneFunction } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneGroupSize + case 0: self = .noneFunction default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneGroupSize: return 0 + case .noneFunction: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.function] = [ + .noneFunction, + ] + } - enum h: SwiftProtobuf.Enum { + enum G: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneH // = 0 + case noneG // = 0 case UNRECOGNIZED(Int) init() { - self = .noneH + self = .noneG } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneH + case 0: self = .noneG default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneH: return 0 + case .noneG: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.G] = [ + .noneG, + ] + } - enum hadOneofValue: SwiftProtobuf.Enum { + enum get: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHadOneofValue // = 0 + case noneGet // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHadOneofValue + self = .noneGet } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHadOneofValue + case 0: self = .noneGet default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHadOneofValue: return 0 + case .noneGet: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.get] = [ + .noneGet, + ] + } - enum handleConflictingOneOf: SwiftProtobuf.Enum { + enum getExtensionValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHandleConflictingOneOf // = 0 + case noneGetExtensionValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHandleConflictingOneOf + self = .noneGetExtensionValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHandleConflictingOneOf + case 0: self = .noneGetExtensionValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHandleConflictingOneOf: return 0 + case .noneGetExtensionValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.getExtensionValue] = [ + .noneGetExtensionValue, + ] + } - enum hasAggregateValue: SwiftProtobuf.Enum { + enum Google_Protobuf_Any: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasAggregateValue // = 0 + case noneGoogleProtobufAny // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasAggregateValue + self = .noneGoogleProtobufAny } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasAggregateValue + case 0: self = .noneGoogleProtobufAny default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasAggregateValue: return 0 + case .noneGoogleProtobufAny: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Any] = [ + .noneGoogleProtobufAny, + ] + } - enum hasAllowAlias: SwiftProtobuf.Enum { + enum Google_Protobuf_Api: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasAllowAlias // = 0 + case noneGoogleProtobufApi // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasAllowAlias + self = .noneGoogleProtobufApi } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasAllowAlias + case 0: self = .noneGoogleProtobufApi default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasAllowAlias: return 0 + case .noneGoogleProtobufApi: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Api] = [ + .noneGoogleProtobufApi, + ] + } - enum hasBegin: SwiftProtobuf.Enum { + enum Google_Protobuf_BoolValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasBegin // = 0 + case noneGoogleProtobufBoolValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasBegin + self = .noneGoogleProtobufBoolValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasBegin + case 0: self = .noneGoogleProtobufBoolValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasBegin: return 0 + case .noneGoogleProtobufBoolValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_BoolValue] = [ + .noneGoogleProtobufBoolValue, + ] + } - enum hasCcEnableArenas: SwiftProtobuf.Enum { + enum Google_Protobuf_BytesValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasCcEnableArenas // = 0 + case noneGoogleProtobufBytesValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasCcEnableArenas + self = .noneGoogleProtobufBytesValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasCcEnableArenas + case 0: self = .noneGoogleProtobufBytesValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasCcEnableArenas: return 0 + case .noneGoogleProtobufBytesValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_BytesValue] = [ + .noneGoogleProtobufBytesValue, + ] + } - enum hasCcGenericServices: SwiftProtobuf.Enum { + enum Google_Protobuf_DescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasCcGenericServices // = 0 + case noneGoogleProtobufDescriptorProto // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasCcGenericServices + self = .noneGoogleProtobufDescriptorProto } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasCcGenericServices + case 0: self = .noneGoogleProtobufDescriptorProto default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasCcGenericServices: return 0 + case .noneGoogleProtobufDescriptorProto: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_DescriptorProto] = [ + .noneGoogleProtobufDescriptorProto, + ] + } - enum hasClientStreaming: SwiftProtobuf.Enum { + enum Google_Protobuf_DoubleValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasClientStreaming // = 0 + case noneGoogleProtobufDoubleValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasClientStreaming + self = .noneGoogleProtobufDoubleValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasClientStreaming + case 0: self = .noneGoogleProtobufDoubleValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasClientStreaming: return 0 + case .noneGoogleProtobufDoubleValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_DoubleValue] = [ + .noneGoogleProtobufDoubleValue, + ] + } - enum hasCsharpNamespace: SwiftProtobuf.Enum { + enum Google_Protobuf_Duration: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasCsharpNamespace // = 0 + case noneGoogleProtobufDuration // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasCsharpNamespace + self = .noneGoogleProtobufDuration } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasCsharpNamespace + case 0: self = .noneGoogleProtobufDuration default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasCsharpNamespace: return 0 + case .noneGoogleProtobufDuration: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Duration] = [ + .noneGoogleProtobufDuration, + ] + } - enum hasCtype: SwiftProtobuf.Enum { + enum Google_Protobuf_Edition: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasCtype // = 0 + case noneGoogleProtobufEdition // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasCtype + self = .noneGoogleProtobufEdition } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasCtype + case 0: self = .noneGoogleProtobufEdition default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasCtype: return 0 + case .noneGoogleProtobufEdition: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Edition] = [ + .noneGoogleProtobufEdition, + ] + } - enum hasDefaultValue: SwiftProtobuf.Enum { + enum Google_Protobuf_Empty: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasDefaultValue // = 0 + case noneGoogleProtobufEmpty // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasDefaultValue + self = .noneGoogleProtobufEmpty } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasDefaultValue + case 0: self = .noneGoogleProtobufEmpty default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasDefaultValue: return 0 + case .noneGoogleProtobufEmpty: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Empty] = [ + .noneGoogleProtobufEmpty, + ] + } - enum hasDeprecated: SwiftProtobuf.Enum { + enum Google_Protobuf_Enum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasDeprecated // = 0 + case noneGoogleProtobufEnum // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasDeprecated + self = .noneGoogleProtobufEnum } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasDeprecated + case 0: self = .noneGoogleProtobufEnum default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasDeprecated: return 0 + case .noneGoogleProtobufEnum: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Enum] = [ + .noneGoogleProtobufEnum, + ] + } - enum hasDoubleValue: SwiftProtobuf.Enum { + enum Google_Protobuf_EnumDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasDoubleValue // = 0 + case noneGoogleProtobufEnumDescriptorProto // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasDoubleValue + self = .noneGoogleProtobufEnumDescriptorProto } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasDoubleValue + case 0: self = .noneGoogleProtobufEnumDescriptorProto default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasDoubleValue: return 0 + case .noneGoogleProtobufEnumDescriptorProto: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumDescriptorProto] = [ + .noneGoogleProtobufEnumDescriptorProto, + ] + } - enum hasEnd: SwiftProtobuf.Enum { + enum Google_Protobuf_EnumOptions: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasEnd // = 0 + case noneGoogleProtobufEnumOptions // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasEnd + self = .noneGoogleProtobufEnumOptions } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasEnd + case 0: self = .noneGoogleProtobufEnumOptions default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasEnd: return 0 + case .noneGoogleProtobufEnumOptions: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumOptions] = [ + .noneGoogleProtobufEnumOptions, + ] + } - enum hasExtendee: SwiftProtobuf.Enum { + enum Google_Protobuf_EnumValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasExtendee // = 0 + case noneGoogleProtobufEnumValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasExtendee + self = .noneGoogleProtobufEnumValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasExtendee + case 0: self = .noneGoogleProtobufEnumValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasExtendee: return 0 + case .noneGoogleProtobufEnumValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValue] = [ + .noneGoogleProtobufEnumValue, + ] + } - enum hasExtensionValue: SwiftProtobuf.Enum { + enum Google_Protobuf_EnumValueDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasExtensionValue // = 0 + case noneGoogleProtobufEnumValueDescriptorProto // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasExtensionValue + self = .noneGoogleProtobufEnumValueDescriptorProto } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasExtensionValue + case 0: self = .noneGoogleProtobufEnumValueDescriptorProto default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasExtensionValue: return 0 + case .noneGoogleProtobufEnumValueDescriptorProto: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueDescriptorProto] = [ + .noneGoogleProtobufEnumValueDescriptorProto, + ] + } - enum hasGoPackage: SwiftProtobuf.Enum { + enum Google_Protobuf_EnumValueOptions: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasGoPackage // = 0 + case noneGoogleProtobufEnumValueOptions // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasGoPackage + self = .noneGoogleProtobufEnumValueOptions } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasGoPackage + case 0: self = .noneGoogleProtobufEnumValueOptions default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasGoPackage: return 0 + case .noneGoogleProtobufEnumValueOptions: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueOptions] = [ + .noneGoogleProtobufEnumValueOptions, + ] + } - enum hash: SwiftProtobuf.Enum { + enum Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHash // = 0 + case noneGoogleProtobufExtensionRangeOptions // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHash + self = .noneGoogleProtobufExtensionRangeOptions } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHash + case 0: self = .noneGoogleProtobufExtensionRangeOptions default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHash: return 0 + case .noneGoogleProtobufExtensionRangeOptions: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ExtensionRangeOptions] = [ + .noneGoogleProtobufExtensionRangeOptions, + ] + } - enum Hashable: SwiftProtobuf.Enum { + enum Google_Protobuf_FeatureSet: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHashable // = 0 + case noneGoogleProtobufFeatureSet // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHashable + self = .noneGoogleProtobufFeatureSet } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHashable + case 0: self = .noneGoogleProtobufFeatureSet default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHashable: return 0 + case .noneGoogleProtobufFeatureSet: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FeatureSet] = [ + .noneGoogleProtobufFeatureSet, + ] + } - enum hasher: SwiftProtobuf.Enum { + enum Google_Protobuf_FeatureSetDefaults: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasher // = 0 + case noneGoogleProtobufFeatureSetDefaults // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasher + self = .noneGoogleProtobufFeatureSetDefaults } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasher + case 0: self = .noneGoogleProtobufFeatureSetDefaults default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasher: return 0 + case .noneGoogleProtobufFeatureSetDefaults: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FeatureSetDefaults] = [ + .noneGoogleProtobufFeatureSetDefaults, + ] + } - enum hashValueEnum: SwiftProtobuf.Enum { + enum Google_Protobuf_Field: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHashValue // = 0 + case noneGoogleProtobufField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHashValue + self = .noneGoogleProtobufField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHashValue + case 0: self = .noneGoogleProtobufField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHashValue: return 0 + case .noneGoogleProtobufField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Field] = [ + .noneGoogleProtobufField, + ] + } - enum HashVisitor: SwiftProtobuf.Enum { + enum Google_Protobuf_FieldDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHashVisitor // = 0 + case noneGoogleProtobufFieldDescriptorProto // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHashVisitor + self = .noneGoogleProtobufFieldDescriptorProto } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHashVisitor + case 0: self = .noneGoogleProtobufFieldDescriptorProto default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHashVisitor: return 0 + case .noneGoogleProtobufFieldDescriptorProto: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldDescriptorProto] = [ + .noneGoogleProtobufFieldDescriptorProto, + ] + } - enum hasIdempotencyLevel: SwiftProtobuf.Enum { + enum Google_Protobuf_FieldMask: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasIdempotencyLevel // = 0 + case noneGoogleProtobufFieldMask // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasIdempotencyLevel + self = .noneGoogleProtobufFieldMask } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasIdempotencyLevel + case 0: self = .noneGoogleProtobufFieldMask default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasIdempotencyLevel: return 0 + case .noneGoogleProtobufFieldMask: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldMask] = [ + .noneGoogleProtobufFieldMask, + ] + } - enum hasIdentifierValue: SwiftProtobuf.Enum { + enum Google_Protobuf_FieldOptions: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasIdentifierValue // = 0 + case noneGoogleProtobufFieldOptions // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasIdentifierValue + self = .noneGoogleProtobufFieldOptions } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasIdentifierValue + case 0: self = .noneGoogleProtobufFieldOptions default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasIdentifierValue: return 0 + case .noneGoogleProtobufFieldOptions: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldOptions] = [ + .noneGoogleProtobufFieldOptions, + ] + } - enum hasInputType: SwiftProtobuf.Enum { + enum Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasInputType // = 0 + case noneGoogleProtobufFileDescriptorProto // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasInputType + self = .noneGoogleProtobufFileDescriptorProto } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasInputType + case 0: self = .noneGoogleProtobufFileDescriptorProto default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasInputType: return 0 + case .noneGoogleProtobufFileDescriptorProto: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorProto] = [ + .noneGoogleProtobufFileDescriptorProto, + ] + } - enum hasIsExtension: SwiftProtobuf.Enum { + enum Google_Protobuf_FileDescriptorSet: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasIsExtension // = 0 + case noneGoogleProtobufFileDescriptorSet // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasIsExtension + self = .noneGoogleProtobufFileDescriptorSet } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasIsExtension + case 0: self = .noneGoogleProtobufFileDescriptorSet default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasIsExtension: return 0 + case .noneGoogleProtobufFileDescriptorSet: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorSet] = [ + .noneGoogleProtobufFileDescriptorSet, + ] + } - enum hasJavaGenerateEqualsAndHash: SwiftProtobuf.Enum { + enum Google_Protobuf_FileOptions: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasJavaGenerateEqualsAndHash // = 0 + case noneGoogleProtobufFileOptions // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasJavaGenerateEqualsAndHash + self = .noneGoogleProtobufFileOptions } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasJavaGenerateEqualsAndHash + case 0: self = .noneGoogleProtobufFileOptions default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasJavaGenerateEqualsAndHash: return 0 + case .noneGoogleProtobufFileOptions: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FileOptions] = [ + .noneGoogleProtobufFileOptions, + ] + } - enum hasJavaGenericServices: SwiftProtobuf.Enum { + enum Google_Protobuf_FloatValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasJavaGenericServices // = 0 + case noneGoogleProtobufFloatValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasJavaGenericServices + self = .noneGoogleProtobufFloatValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasJavaGenericServices + case 0: self = .noneGoogleProtobufFloatValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasJavaGenericServices: return 0 + case .noneGoogleProtobufFloatValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FloatValue] = [ + .noneGoogleProtobufFloatValue, + ] + } - enum hasJavaMultipleFiles: SwiftProtobuf.Enum { + enum Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasJavaMultipleFiles // = 0 + case noneGoogleProtobufGeneratedCodeInfo // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasJavaMultipleFiles + self = .noneGoogleProtobufGeneratedCodeInfo } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasJavaMultipleFiles + case 0: self = .noneGoogleProtobufGeneratedCodeInfo default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasJavaMultipleFiles: return 0 + case .noneGoogleProtobufGeneratedCodeInfo: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_GeneratedCodeInfo] = [ + .noneGoogleProtobufGeneratedCodeInfo, + ] + } - enum hasJavaOuterClassname: SwiftProtobuf.Enum { + enum Google_Protobuf_Int32Value: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasJavaOuterClassname // = 0 + case noneGoogleProtobufInt32Value // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasJavaOuterClassname + self = .noneGoogleProtobufInt32Value } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasJavaOuterClassname + case 0: self = .noneGoogleProtobufInt32Value default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasJavaOuterClassname: return 0 + case .noneGoogleProtobufInt32Value: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Int32Value] = [ + .noneGoogleProtobufInt32Value, + ] + } - enum hasJavaPackage: SwiftProtobuf.Enum { + enum Google_Protobuf_Int64Value: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasJavaPackage // = 0 + case noneGoogleProtobufInt64Value // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasJavaPackage + self = .noneGoogleProtobufInt64Value } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasJavaPackage + case 0: self = .noneGoogleProtobufInt64Value default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasJavaPackage: return 0 + case .noneGoogleProtobufInt64Value: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Int64Value] = [ + .noneGoogleProtobufInt64Value, + ] + } - enum hasJavaStringCheckUtf8: SwiftProtobuf.Enum { + enum Google_Protobuf_ListValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasJavaStringCheckUtf8 // = 0 + case noneGoogleProtobufListValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasJavaStringCheckUtf8 + self = .noneGoogleProtobufListValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasJavaStringCheckUtf8 + case 0: self = .noneGoogleProtobufListValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasJavaStringCheckUtf8: return 0 + case .noneGoogleProtobufListValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ListValue] = [ + .noneGoogleProtobufListValue, + ] + } - enum hasJsonName: SwiftProtobuf.Enum { + enum Google_Protobuf_MessageOptions: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasJsonName // = 0 + case noneGoogleProtobufMessageOptions // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasJsonName + self = .noneGoogleProtobufMessageOptions } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasJsonName + case 0: self = .noneGoogleProtobufMessageOptions default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasJsonName: return 0 + case .noneGoogleProtobufMessageOptions: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_MessageOptions] = [ + .noneGoogleProtobufMessageOptions, + ] + } - enum hasJstype: SwiftProtobuf.Enum { + enum Google_Protobuf_Method: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasJstype // = 0 + case noneGoogleProtobufMethod // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasJstype + self = .noneGoogleProtobufMethod } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasJstype + case 0: self = .noneGoogleProtobufMethod default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasJstype: return 0 + case .noneGoogleProtobufMethod: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Method] = [ + .noneGoogleProtobufMethod, + ] + } - enum hasLabel: SwiftProtobuf.Enum { + enum Google_Protobuf_MethodDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasLabel // = 0 + case noneGoogleProtobufMethodDescriptorProto // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasLabel + self = .noneGoogleProtobufMethodDescriptorProto } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasLabel + case 0: self = .noneGoogleProtobufMethodDescriptorProto default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasLabel: return 0 + case .noneGoogleProtobufMethodDescriptorProto: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodDescriptorProto] = [ + .noneGoogleProtobufMethodDescriptorProto, + ] + } - enum hasLazy: SwiftProtobuf.Enum { + enum Google_Protobuf_MethodOptions: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasLazy // = 0 + case noneGoogleProtobufMethodOptions // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasLazy + self = .noneGoogleProtobufMethodOptions } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasLazy + case 0: self = .noneGoogleProtobufMethodOptions default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasLazy: return 0 + case .noneGoogleProtobufMethodOptions: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodOptions] = [ + .noneGoogleProtobufMethodOptions, + ] + } - enum hasLeadingComments: SwiftProtobuf.Enum { + enum Google_Protobuf_Mixin: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasLeadingComments // = 0 + case noneGoogleProtobufMixin // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasLeadingComments + self = .noneGoogleProtobufMixin } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasLeadingComments + case 0: self = .noneGoogleProtobufMixin default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasLeadingComments: return 0 + case .noneGoogleProtobufMixin: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Mixin] = [ + .noneGoogleProtobufMixin, + ] + } - enum hasMapEntry: SwiftProtobuf.Enum { + enum Google_Protobuf_NullValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasMapEntry // = 0 + case noneGoogleProtobufNullValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasMapEntry + self = .noneGoogleProtobufNullValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasMapEntry + case 0: self = .noneGoogleProtobufNullValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasMapEntry: return 0 + case .noneGoogleProtobufNullValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_NullValue] = [ + .noneGoogleProtobufNullValue, + ] + } - enum hasMessageSetWireFormat: SwiftProtobuf.Enum { + enum Google_Protobuf_OneofDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasMessageSetWireFormat // = 0 + case noneGoogleProtobufOneofDescriptorProto // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasMessageSetWireFormat + self = .noneGoogleProtobufOneofDescriptorProto } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasMessageSetWireFormat + case 0: self = .noneGoogleProtobufOneofDescriptorProto default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasMessageSetWireFormat: return 0 + case .noneGoogleProtobufOneofDescriptorProto: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofDescriptorProto] = [ + .noneGoogleProtobufOneofDescriptorProto, + ] + } - enum hasName: SwiftProtobuf.Enum { + enum Google_Protobuf_OneofOptions: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasName // = 0 + case noneGoogleProtobufOneofOptions // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasName + self = .noneGoogleProtobufOneofOptions } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasName + case 0: self = .noneGoogleProtobufOneofOptions default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasName: return 0 + case .noneGoogleProtobufOneofOptions: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofOptions] = [ + .noneGoogleProtobufOneofOptions, + ] + } - enum hasNamePart: SwiftProtobuf.Enum { + enum Google_Protobuf_Option: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasNamePart // = 0 + case noneGoogleProtobufOption // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasNamePart + self = .noneGoogleProtobufOption } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasNamePart + case 0: self = .noneGoogleProtobufOption default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasNamePart: return 0 + case .noneGoogleProtobufOption: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Option] = [ + .noneGoogleProtobufOption, + ] + } - enum hasNegativeIntValue: SwiftProtobuf.Enum { + enum Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasNegativeIntValue // = 0 + case noneGoogleProtobufServiceDescriptorProto // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasNegativeIntValue + self = .noneGoogleProtobufServiceDescriptorProto } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasNegativeIntValue + case 0: self = .noneGoogleProtobufServiceDescriptorProto default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasNegativeIntValue: return 0 + case .noneGoogleProtobufServiceDescriptorProto: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceDescriptorProto] = [ + .noneGoogleProtobufServiceDescriptorProto, + ] + } - enum hasNoStandardDescriptorAccessor: SwiftProtobuf.Enum { + enum Google_Protobuf_ServiceOptions: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasNoStandardDescriptorAccessor // = 0 + case noneGoogleProtobufServiceOptions // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasNoStandardDescriptorAccessor + self = .noneGoogleProtobufServiceOptions } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasNoStandardDescriptorAccessor + case 0: self = .noneGoogleProtobufServiceOptions default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasNoStandardDescriptorAccessor: return 0 + case .noneGoogleProtobufServiceOptions: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceOptions] = [ + .noneGoogleProtobufServiceOptions, + ] + } - enum hasNumber: SwiftProtobuf.Enum { + enum Google_Protobuf_SourceCodeInfo: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasNumber // = 0 + case noneGoogleProtobufSourceCodeInfo // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasNumber + self = .noneGoogleProtobufSourceCodeInfo } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasNumber + case 0: self = .noneGoogleProtobufSourceCodeInfo default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasNumber: return 0 + case .noneGoogleProtobufSourceCodeInfo: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceCodeInfo] = [ + .noneGoogleProtobufSourceCodeInfo, + ] + } - enum hasObjcClassPrefix: SwiftProtobuf.Enum { + enum Google_Protobuf_SourceContext: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasObjcClassPrefix // = 0 + case noneGoogleProtobufSourceContext // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasObjcClassPrefix + self = .noneGoogleProtobufSourceContext } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasObjcClassPrefix + case 0: self = .noneGoogleProtobufSourceContext default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasObjcClassPrefix: return 0 + case .noneGoogleProtobufSourceContext: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceContext] = [ + .noneGoogleProtobufSourceContext, + ] + } - enum hasOneofIndex: SwiftProtobuf.Enum { + enum Google_Protobuf_StringValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasOneofIndex // = 0 + case noneGoogleProtobufStringValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasOneofIndex + self = .noneGoogleProtobufStringValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasOneofIndex + case 0: self = .noneGoogleProtobufStringValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasOneofIndex: return 0 + case .noneGoogleProtobufStringValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_StringValue] = [ + .noneGoogleProtobufStringValue, + ] + } - enum hasOptimizeFor: SwiftProtobuf.Enum { + enum Google_Protobuf_Struct: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasOptimizeFor // = 0 + case noneGoogleProtobufStruct // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasOptimizeFor + self = .noneGoogleProtobufStruct } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasOptimizeFor + case 0: self = .noneGoogleProtobufStruct default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasOptimizeFor: return 0 + case .noneGoogleProtobufStruct: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Struct] = [ + .noneGoogleProtobufStruct, + ] + } - enum hasOptions: SwiftProtobuf.Enum { + enum Google_Protobuf_SymbolVisibility: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasOptions // = 0 + case noneGoogleProtobufSymbolVisibility // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasOptions + self = .noneGoogleProtobufSymbolVisibility } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasOptions + case 0: self = .noneGoogleProtobufSymbolVisibility default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasOptions: return 0 + case .noneGoogleProtobufSymbolVisibility: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_SymbolVisibility] = [ + .noneGoogleProtobufSymbolVisibility, + ] + } - enum hasOutputType: SwiftProtobuf.Enum { + enum Google_Protobuf_Syntax: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasOutputType // = 0 + case noneGoogleProtobufSyntax // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasOutputType + self = .noneGoogleProtobufSyntax } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasOutputType + case 0: self = .noneGoogleProtobufSyntax default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasOutputType: return 0 + case .noneGoogleProtobufSyntax: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Syntax] = [ + .noneGoogleProtobufSyntax, + ] + } - enum hasPackage: SwiftProtobuf.Enum { + enum Google_Protobuf_Timestamp: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasPackage // = 0 + case noneGoogleProtobufTimestamp // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasPackage + self = .noneGoogleProtobufTimestamp } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasPackage + case 0: self = .noneGoogleProtobufTimestamp default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasPackage: return 0 + case .noneGoogleProtobufTimestamp: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Timestamp] = [ + .noneGoogleProtobufTimestamp, + ] + } - enum hasPacked: SwiftProtobuf.Enum { + enum Google_Protobuf_Type: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasPacked // = 0 + case noneGoogleProtobufType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasPacked + self = .noneGoogleProtobufType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasPacked + case 0: self = .noneGoogleProtobufType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasPacked: return 0 + case .noneGoogleProtobufType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Type] = [ + .noneGoogleProtobufType, + ] + } - enum hasPhpClassPrefix: SwiftProtobuf.Enum { + enum Google_Protobuf_UInt32Value: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasPhpClassPrefix // = 0 + case noneGoogleProtobufUint32Value // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasPhpClassPrefix + self = .noneGoogleProtobufUint32Value } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasPhpClassPrefix + case 0: self = .noneGoogleProtobufUint32Value default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasPhpClassPrefix: return 0 + case .noneGoogleProtobufUint32Value: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt32Value] = [ + .noneGoogleProtobufUint32Value, + ] + } - enum hasPhpGenericServices: SwiftProtobuf.Enum { + enum Google_Protobuf_UInt64Value: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasPhpGenericServices // = 0 + case noneGoogleProtobufUint64Value // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasPhpGenericServices + self = .noneGoogleProtobufUint64Value } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasPhpGenericServices + case 0: self = .noneGoogleProtobufUint64Value default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasPhpGenericServices: return 0 + case .noneGoogleProtobufUint64Value: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt64Value] = [ + .noneGoogleProtobufUint64Value, + ] + } - enum hasPhpMetadataNamespace: SwiftProtobuf.Enum { + enum Google_Protobuf_UninterpretedOption: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasPhpMetadataNamespace // = 0 + case noneGoogleProtobufUninterpretedOption // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasPhpMetadataNamespace + self = .noneGoogleProtobufUninterpretedOption } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasPhpMetadataNamespace + case 0: self = .noneGoogleProtobufUninterpretedOption default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasPhpMetadataNamespace: return 0 + case .noneGoogleProtobufUninterpretedOption: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_UninterpretedOption] = [ + .noneGoogleProtobufUninterpretedOption, + ] + } - enum hasPhpNamespace: SwiftProtobuf.Enum { + enum Google_Protobuf_Value: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasPhpNamespace // = 0 + case noneGoogleProtobufValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasPhpNamespace + self = .noneGoogleProtobufValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasPhpNamespace + case 0: self = .noneGoogleProtobufValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasPhpNamespace: return 0 + case .noneGoogleProtobufValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Value] = [ + .noneGoogleProtobufValue, + ] + } - enum hasPositiveIntValue: SwiftProtobuf.Enum { + enum goPackage: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasPositiveIntValue // = 0 + case noneGoPackage // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasPositiveIntValue + self = .noneGoPackage } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasPositiveIntValue + case 0: self = .noneGoPackage default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasPositiveIntValue: return 0 + case .noneGoPackage: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.goPackage] = [ + .noneGoPackage, + ] + } - enum hasProto3Optional: SwiftProtobuf.Enum { + enum gotData: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasProto3Optional // = 0 + case noneGotData // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasProto3Optional + self = .noneGotData } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasProto3Optional + case 0: self = .noneGotData default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasProto3Optional: return 0 + case .noneGotData: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.gotData] = [ + .noneGotData, + ] + } - enum hasPyGenericServices: SwiftProtobuf.Enum { + enum group: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasPyGenericServices // = 0 + case noneGroup // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasPyGenericServices + self = .noneGroup } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasPyGenericServices + case 0: self = .noneGroup default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasPyGenericServices: return 0 + case .noneGroup: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.group] = [ + .noneGroup, + ] + } - enum hasRubyPackage: SwiftProtobuf.Enum { + enum groupFieldNumberStack: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasRubyPackage // = 0 + case noneGroupFieldNumberStack // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasRubyPackage + self = .noneGroupFieldNumberStack } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasRubyPackage + case 0: self = .noneGroupFieldNumberStack default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasRubyPackage: return 0 + case .noneGroupFieldNumberStack: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.groupFieldNumberStack] = [ + .noneGroupFieldNumberStack, + ] + } - enum hasServerStreaming: SwiftProtobuf.Enum { + enum groupSize: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasServerStreaming // = 0 + case noneGroupSize // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasServerStreaming + self = .noneGroupSize } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasServerStreaming + case 0: self = .noneGroupSize default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasServerStreaming: return 0 + case .noneGroupSize: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.groupSize] = [ + .noneGroupSize, + ] + } - enum hasSourceCodeInfo: SwiftProtobuf.Enum { + enum guardEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasSourceCodeInfo // = 0 + case noneGuard // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasSourceCodeInfo + self = .noneGuard } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasSourceCodeInfo + case 0: self = .noneGuard default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasSourceCodeInfo: return 0 + case .noneGuard: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.guardEnum] = [ + .noneGuard, + ] + } - enum hasSourceContext: SwiftProtobuf.Enum { + enum hadOneofValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasSourceContext // = 0 + case noneHadOneofValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasSourceContext + self = .noneHadOneofValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasSourceContext + case 0: self = .noneHadOneofValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasSourceContext: return 0 + case .noneHadOneofValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hadOneofValue] = [ + .noneHadOneofValue, + ] + } - enum hasSourceFile: SwiftProtobuf.Enum { + enum handleConflictingOneOf: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasSourceFile // = 0 + case noneHandleConflictingOneOf // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasSourceFile + self = .noneHandleConflictingOneOf } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasSourceFile + case 0: self = .noneHandleConflictingOneOf default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasSourceFile: return 0 + case .noneHandleConflictingOneOf: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.handleConflictingOneOf] = [ + .noneHandleConflictingOneOf, + ] + } - enum hasStart: SwiftProtobuf.Enum { + enum handleInstruction: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasStart // = 0 + case noneHandleInstruction // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasStart + self = .noneHandleInstruction } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasStart + case 0: self = .noneHandleInstruction default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasStart: return 0 + case .noneHandleInstruction: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.handleInstruction] = [ + .noneHandleInstruction, + ] + } - enum hasStringValue: SwiftProtobuf.Enum { + enum hasAggregateValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasStringValue // = 0 + case noneHasAggregateValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasStringValue + self = .noneHasAggregateValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasStringValue + case 0: self = .noneHasAggregateValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasStringValue: return 0 + case .noneHasAggregateValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasAggregateValue] = [ + .noneHasAggregateValue, + ] + } - enum hasSwiftPrefix: SwiftProtobuf.Enum { + enum hasAllowAlias: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasSwiftPrefix // = 0 + case noneHasAllowAlias // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasSwiftPrefix + self = .noneHasAllowAlias } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasSwiftPrefix + case 0: self = .noneHasAllowAlias default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasSwiftPrefix: return 0 + case .noneHasAllowAlias: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasAllowAlias] = [ + .noneHasAllowAlias, + ] + } - enum hasSyntax: SwiftProtobuf.Enum { + enum hasBegin: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasSyntax // = 0 + case noneHasBegin // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasSyntax + self = .noneHasBegin } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasSyntax + case 0: self = .noneHasBegin default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasSyntax: return 0 + case .noneHasBegin: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasBegin] = [ + .noneHasBegin, + ] + } - enum hasTrailingComments: SwiftProtobuf.Enum { + enum hasCcEnableArenas: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasTrailingComments // = 0 + case noneHasCcEnableArenas // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasTrailingComments + self = .noneHasCcEnableArenas } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasTrailingComments + case 0: self = .noneHasCcEnableArenas default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasTrailingComments: return 0 + case .noneHasCcEnableArenas: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCcEnableArenas] = [ + .noneHasCcEnableArenas, + ] + } - enum hasType: SwiftProtobuf.Enum { + enum hasCcGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasType // = 0 + case noneHasCcGenericServices // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasType + self = .noneHasCcGenericServices } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasType + case 0: self = .noneHasCcGenericServices default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasType: return 0 + case .noneHasCcGenericServices: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCcGenericServices] = [ + .noneHasCcGenericServices, + ] + } - enum hasTypeName: SwiftProtobuf.Enum { + enum hasClientStreaming: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasTypeName // = 0 + case noneHasClientStreaming // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasTypeName + self = .noneHasClientStreaming } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasTypeName + case 0: self = .noneHasClientStreaming default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasTypeName: return 0 + case .noneHasClientStreaming: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasClientStreaming] = [ + .noneHasClientStreaming, + ] + } - enum hasValue: SwiftProtobuf.Enum { + enum hasCsharpNamespace: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasValue // = 0 + case noneHasCsharpNamespace // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasValue + self = .noneHasCsharpNamespace } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasValue + case 0: self = .noneHasCsharpNamespace default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasValue: return 0 + case .noneHasCsharpNamespace: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCsharpNamespace] = [ + .noneHasCsharpNamespace, + ] + } - enum hasWeak: SwiftProtobuf.Enum { + enum hasCtype: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHasWeak // = 0 + case noneHasCtype // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHasWeak + self = .noneHasCtype } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHasWeak + case 0: self = .noneHasCtype default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHasWeak: return 0 + case .noneHasCtype: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCtype] = [ + .noneHasCtype, + ] + } - enum hour: SwiftProtobuf.Enum { + enum hasData: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneHour // = 0 + case noneHasData // = 0 case UNRECOGNIZED(Int) init() { - self = .noneHour + self = .noneHasData } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneHour + case 0: self = .noneHasData default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneHour: return 0 + case .noneHasData: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasData] = [ + .noneHasData, + ] + } - enum i: SwiftProtobuf.Enum { + enum hasDebugRedact: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneI // = 0 + case noneHasDebugRedact // = 0 case UNRECOGNIZED(Int) init() { - self = .noneI + self = .noneHasDebugRedact } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneI + case 0: self = .noneHasDebugRedact default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneI: return 0 + case .noneHasDebugRedact: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDebugRedact] = [ + .noneHasDebugRedact, + ] + } - enum idempotencyLevel: SwiftProtobuf.Enum { + enum hasDefaultSymbolVisibility: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneIdempotencyLevel // = 0 + case noneHasDefaultSymbolVisibility // = 0 case UNRECOGNIZED(Int) init() { - self = .noneIdempotencyLevel + self = .noneHasDefaultSymbolVisibility } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneIdempotencyLevel + case 0: self = .noneHasDefaultSymbolVisibility default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneIdempotencyLevel: return 0 + case .noneHasDefaultSymbolVisibility: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDefaultSymbolVisibility] = [ + .noneHasDefaultSymbolVisibility, + ] + } - enum identifierValue: SwiftProtobuf.Enum { + enum hasDefaultValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneIdentifierValue // = 0 + case noneHasDefaultValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneIdentifierValue + self = .noneHasDefaultValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneIdentifierValue + case 0: self = .noneHasDefaultValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneIdentifierValue: return 0 + case .noneHasDefaultValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDefaultValue] = [ + .noneHasDefaultValue, + ] + } - enum ifEnum: SwiftProtobuf.Enum { + enum hasDeprecated: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneIf // = 0 + case noneHasDeprecated // = 0 case UNRECOGNIZED(Int) init() { - self = .noneIf + self = .noneHasDeprecated } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneIf + case 0: self = .noneHasDeprecated default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneIf: return 0 + case .noneHasDeprecated: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDeprecated] = [ + .noneHasDeprecated, + ] + } - enum ignoreUnknownFields: SwiftProtobuf.Enum { + enum hasDeprecatedLegacyJsonFieldConflicts: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneIgnoreUnknownFields // = 0 + case noneHasDeprecatedLegacyJsonFieldConflicts // = 0 case UNRECOGNIZED(Int) init() { - self = .noneIgnoreUnknownFields + self = .noneHasDeprecatedLegacyJsonFieldConflicts } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneIgnoreUnknownFields + case 0: self = .noneHasDeprecatedLegacyJsonFieldConflicts default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneIgnoreUnknownFields: return 0 + case .noneHasDeprecatedLegacyJsonFieldConflicts: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDeprecatedLegacyJsonFieldConflicts] = [ + .noneHasDeprecatedLegacyJsonFieldConflicts, + ] + } - enum index: SwiftProtobuf.Enum { + enum hasDeprecationWarning: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneIndex // = 0 + case noneHasDeprecationWarning // = 0 case UNRECOGNIZED(Int) init() { - self = .noneIndex + self = .noneHasDeprecationWarning } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneIndex + case 0: self = .noneHasDeprecationWarning default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneIndex: return 0 + case .noneHasDeprecationWarning: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDeprecationWarning] = [ + .noneHasDeprecationWarning, + ] + } - enum initEnum: SwiftProtobuf.Enum { + enum hasDoubleValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneInit // = 0 + case noneHasDoubleValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneInit + self = .noneHasDoubleValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneInit + case 0: self = .noneHasDoubleValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneInit: return 0 + case .noneHasDoubleValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDoubleValue] = [ + .noneHasDoubleValue, + ] + } - enum inoutEnum: SwiftProtobuf.Enum { + enum hasEdition: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneInout // = 0 + case noneHasEdition // = 0 case UNRECOGNIZED(Int) init() { - self = .noneInout + self = .noneHasEdition } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneInout + case 0: self = .noneHasEdition default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneInout: return 0 + case .noneHasEdition: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEdition] = [ + .noneHasEdition, + ] + } - enum inputType: SwiftProtobuf.Enum { + enum hasEditionDeprecated: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneInputType // = 0 + case noneHasEditionDeprecated // = 0 case UNRECOGNIZED(Int) init() { - self = .noneInputType + self = .noneHasEditionDeprecated } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneInputType + case 0: self = .noneHasEditionDeprecated default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneInputType: return 0 + case .noneHasEditionDeprecated: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEditionDeprecated] = [ + .noneHasEditionDeprecated, + ] + } - enum insert: SwiftProtobuf.Enum { + enum hasEditionIntroduced: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneInsert // = 0 + case noneHasEditionIntroduced // = 0 case UNRECOGNIZED(Int) init() { - self = .noneInsert + self = .noneHasEditionIntroduced } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneInsert + case 0: self = .noneHasEditionIntroduced default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneInsert: return 0 + case .noneHasEditionIntroduced: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEditionIntroduced] = [ + .noneHasEditionIntroduced, + ] + } - enum IntEnum: SwiftProtobuf.Enum { + enum hasEditionRemoved: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneInt // = 0 + case noneHasEditionRemoved // = 0 case UNRECOGNIZED(Int) init() { - self = .noneInt + self = .noneHasEditionRemoved } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneInt + case 0: self = .noneHasEditionRemoved default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneInt: return 0 + case .noneHasEditionRemoved: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEditionRemoved] = [ + .noneHasEditionRemoved, + ] + } - enum Int32Enum: SwiftProtobuf.Enum { + enum hasEnd: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneInt32 // = 0 + case noneHasEnd // = 0 case UNRECOGNIZED(Int) init() { - self = .noneInt32 + self = .noneHasEnd } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneInt32 + case 0: self = .noneHasEnd default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneInt32: return 0 + case .noneHasEnd: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEnd] = [ + .noneHasEnd, + ] + } - enum Int32Value: SwiftProtobuf.Enum { + enum hasEnforceNamingStyle: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneInt32Value // = 0 + case noneHasEnforceNamingStyle // = 0 case UNRECOGNIZED(Int) init() { - self = .noneInt32Value + self = .noneHasEnforceNamingStyle } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneInt32Value + case 0: self = .noneHasEnforceNamingStyle default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneInt32Value: return 0 + case .noneHasEnforceNamingStyle: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEnforceNamingStyle] = [ + .noneHasEnforceNamingStyle, + ] + } - enum Int64Enum: SwiftProtobuf.Enum { + enum hasEnumType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneInt64 // = 0 + case noneHasEnumType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneInt64 + self = .noneHasEnumType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneInt64 + case 0: self = .noneHasEnumType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneInt64: return 0 + case .noneHasEnumType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEnumType] = [ + .noneHasEnumType, + ] + } - enum Int64Value: SwiftProtobuf.Enum { + enum hasExplicitDelta: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneInt64Value // = 0 + case noneHasExplicitDelta // = 0 case UNRECOGNIZED(Int) init() { - self = .noneInt64Value + self = .noneHasExplicitDelta } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneInt64Value + case 0: self = .noneHasExplicitDelta default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneInt64Value: return 0 + case .noneHasExplicitDelta: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasExplicitDelta] = [ + .noneHasExplicitDelta, + ] + } - enum Int8: SwiftProtobuf.Enum { + enum hasExtendee: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneInt8 // = 0 + case noneHasExtendee // = 0 case UNRECOGNIZED(Int) init() { - self = .noneInt8 + self = .noneHasExtendee } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneInt8 + case 0: self = .noneHasExtendee default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneInt8: return 0 + case .noneHasExtendee: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasExtendee] = [ + .noneHasExtendee, + ] + } - enum integerLiteral: SwiftProtobuf.Enum { + enum hasExtensionValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneIntegerLiteral // = 0 + case noneHasExtensionValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneIntegerLiteral + self = .noneHasExtensionValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneIntegerLiteral + case 0: self = .noneHasExtensionValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneIntegerLiteral: return 0 + case .noneHasExtensionValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasExtensionValue] = [ + .noneHasExtensionValue, + ] + } - enum IntegerLiteralType: SwiftProtobuf.Enum { + enum hasFeatures: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneIntegerLiteralType // = 0 + case noneHasFeatures // = 0 case UNRECOGNIZED(Int) init() { - self = .noneIntegerLiteralType + self = .noneHasFeatures } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneIntegerLiteralType + case 0: self = .noneHasFeatures default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneIntegerLiteralType: return 0 + case .noneHasFeatures: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFeatures] = [ + .noneHasFeatures, + ] + } - enum intern: SwiftProtobuf.Enum { + enum hasFeatureSupport: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneIntern // = 0 + case noneHasFeatureSupport // = 0 case UNRECOGNIZED(Int) init() { - self = .noneIntern + self = .noneHasFeatureSupport } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneIntern + case 0: self = .noneHasFeatureSupport default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneIntern: return 0 + case .noneHasFeatureSupport: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFeatureSupport] = [ + .noneHasFeatureSupport, + ] + } - enum Internal: SwiftProtobuf.Enum { + enum hasFieldPresence: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneInternal // = 0 + case noneHasFieldPresence // = 0 case UNRECOGNIZED(Int) init() { - self = .noneInternal + self = .noneHasFieldPresence } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneInternal + case 0: self = .noneHasFieldPresence default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneInternal: return 0 + case .noneHasFieldPresence: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFieldPresence] = [ + .noneHasFieldPresence, + ] + } - enum InternalState: SwiftProtobuf.Enum { + enum hasFixedFeatures: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneInternalState // = 0 + case noneHasFixedFeatures // = 0 case UNRECOGNIZED(Int) init() { - self = .noneInternalState + self = .noneHasFixedFeatures } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneInternalState + case 0: self = .noneHasFixedFeatures default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneInternalState: return 0 + case .noneHasFixedFeatures: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFixedFeatures] = [ + .noneHasFixedFeatures, + ] + } - enum into: SwiftProtobuf.Enum { + enum hasFullName: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneInto // = 0 + case noneHasFullName // = 0 case UNRECOGNIZED(Int) init() { - self = .noneInto + self = .noneHasFullName } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneInto + case 0: self = .noneHasFullName default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneInto: return 0 + case .noneHasFullName: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFullName] = [ + .noneHasFullName, + ] + } - enum ints: SwiftProtobuf.Enum { + enum hasGoPackage: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneInts // = 0 + case noneHasGoPackage // = 0 case UNRECOGNIZED(Int) init() { - self = .noneInts + self = .noneHasGoPackage } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneInts + case 0: self = .noneHasGoPackage default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneInts: return 0 + case .noneHasGoPackage: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasGoPackage] = [ + .noneHasGoPackage, + ] + } - enum isA: SwiftProtobuf.Enum { + enum hash: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneIsA // = 0 + case noneHash // = 0 case UNRECOGNIZED(Int) init() { - self = .noneIsA + self = .noneHash } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneIsA + case 0: self = .noneHash default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneIsA: return 0 + case .noneHash: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hash] = [ + .noneHash, + ] + } - enum isEqual: SwiftProtobuf.Enum { + enum HashableEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneIsEqual // = 0 + case noneHashable // = 0 case UNRECOGNIZED(Int) init() { - self = .noneIsEqual + self = .noneHashable } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneIsEqual + case 0: self = .noneHashable default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneIsEqual: return 0 + case .noneHashable: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.HashableEnum] = [ + .noneHashable, + ] + } - enum isEqualTo: SwiftProtobuf.Enum { + enum hasher: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneIsEqualTo // = 0 + case noneHasher // = 0 case UNRECOGNIZED(Int) init() { - self = .noneIsEqualTo + self = .noneHasher } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneIsEqualTo + case 0: self = .noneHasher default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneIsEqualTo: return 0 + case .noneHasher: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasher] = [ + .noneHasher, + ] + } - enum isExtension: SwiftProtobuf.Enum { + enum HashVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneIsExtension // = 0 + case noneHashVisitor // = 0 case UNRECOGNIZED(Int) init() { - self = .noneIsExtension + self = .noneHashVisitor } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneIsExtension + case 0: self = .noneHashVisitor default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneIsExtension: return 0 + case .noneHashVisitor: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.HashVisitor] = [ + .noneHashVisitor, + ] + } - enum isInitializedEnum: SwiftProtobuf.Enum { + enum hasIdempotencyLevel: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneIsInitialized // = 0 + case noneHasIdempotencyLevel // = 0 case UNRECOGNIZED(Int) init() { - self = .noneIsInitialized + self = .noneHasIdempotencyLevel } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneIsInitialized + case 0: self = .noneHasIdempotencyLevel default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneIsInitialized: return 0 + case .noneHasIdempotencyLevel: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasIdempotencyLevel] = [ + .noneHasIdempotencyLevel, + ] + } - enum itemTagsEncodedSize: SwiftProtobuf.Enum { + enum hasIdentifierValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneItemTagsEncodedSize // = 0 + case noneHasIdentifierValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneItemTagsEncodedSize + self = .noneHasIdentifierValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneItemTagsEncodedSize + case 0: self = .noneHasIdentifierValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneItemTagsEncodedSize: return 0 + case .noneHasIdentifierValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasIdentifierValue] = [ + .noneHasIdentifierValue, + ] + } - enum Iterator: SwiftProtobuf.Enum { + enum hasInputType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneIterator // = 0 + case noneHasInputType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneIterator + self = .noneHasInputType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneIterator + case 0: self = .noneHasInputType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneIterator: return 0 + case .noneHasInputType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasInputType] = [ + .noneHasInputType, + ] + } - enum i_2166136261: SwiftProtobuf.Enum { + enum hasIsExtension: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneI2166136261 // = 0 + case noneHasIsExtension // = 0 case UNRECOGNIZED(Int) init() { - self = .noneI2166136261 + self = .noneHasIsExtension } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneI2166136261 + case 0: self = .noneHasIsExtension default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneI2166136261: return 0 + case .noneHasIsExtension: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasIsExtension] = [ + .noneHasIsExtension, + ] + } - enum javaGenerateEqualsAndHash: SwiftProtobuf.Enum { + enum hasJavaGenerateEqualsAndHash: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJavaGenerateEqualsAndHash // = 0 + case noneHasJavaGenerateEqualsAndHash // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJavaGenerateEqualsAndHash + self = .noneHasJavaGenerateEqualsAndHash } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJavaGenerateEqualsAndHash + case 0: self = .noneHasJavaGenerateEqualsAndHash default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJavaGenerateEqualsAndHash: return 0 + case .noneHasJavaGenerateEqualsAndHash: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaGenerateEqualsAndHash] = [ + .noneHasJavaGenerateEqualsAndHash, + ] + } - enum javaGenericServices: SwiftProtobuf.Enum { + enum hasJavaGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJavaGenericServices // = 0 + case noneHasJavaGenericServices // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJavaGenericServices + self = .noneHasJavaGenericServices } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJavaGenericServices + case 0: self = .noneHasJavaGenericServices default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJavaGenericServices: return 0 + case .noneHasJavaGenericServices: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaGenericServices] = [ + .noneHasJavaGenericServices, + ] + } - enum javaMultipleFiles: SwiftProtobuf.Enum { + enum hasJavaMultipleFiles: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJavaMultipleFiles // = 0 + case noneHasJavaMultipleFiles // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJavaMultipleFiles + self = .noneHasJavaMultipleFiles } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJavaMultipleFiles + case 0: self = .noneHasJavaMultipleFiles default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJavaMultipleFiles: return 0 + case .noneHasJavaMultipleFiles: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaMultipleFiles] = [ + .noneHasJavaMultipleFiles, + ] + } - enum javaOuterClassname: SwiftProtobuf.Enum { + enum hasJavaOuterClassname: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJavaOuterClassname // = 0 + case noneHasJavaOuterClassname // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJavaOuterClassname + self = .noneHasJavaOuterClassname } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJavaOuterClassname + case 0: self = .noneHasJavaOuterClassname default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJavaOuterClassname: return 0 + case .noneHasJavaOuterClassname: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaOuterClassname] = [ + .noneHasJavaOuterClassname, + ] + } - enum javaPackage: SwiftProtobuf.Enum { + enum hasJavaPackage: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJavaPackage // = 0 + case noneHasJavaPackage // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJavaPackage + self = .noneHasJavaPackage } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJavaPackage + case 0: self = .noneHasJavaPackage default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJavaPackage: return 0 + case .noneHasJavaPackage: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaPackage] = [ + .noneHasJavaPackage, + ] + } - enum javaStringCheckUtf8: SwiftProtobuf.Enum { + enum hasJavaStringCheckUtf8: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJavaStringCheckUtf8 // = 0 + case noneHasJavaStringCheckUtf8 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJavaStringCheckUtf8 + self = .noneHasJavaStringCheckUtf8 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJavaStringCheckUtf8 + case 0: self = .noneHasJavaStringCheckUtf8 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJavaStringCheckUtf8: return 0 + case .noneHasJavaStringCheckUtf8: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaStringCheckUtf8] = [ + .noneHasJavaStringCheckUtf8, + ] + } - enum JSONDecoder: SwiftProtobuf.Enum { + enum hasJsonFormat: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJsondecoder // = 0 + case noneHasJsonFormat // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJsondecoder + self = .noneHasJsonFormat } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJsondecoder + case 0: self = .noneHasJsonFormat default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJsondecoder: return 0 + case .noneHasJsonFormat: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJsonFormat] = [ + .noneHasJsonFormat, + ] + } - enum JSONDecodingError: SwiftProtobuf.Enum { + enum hasJsonName: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJsondecodingError // = 0 + case noneHasJsonName // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJsondecodingError + self = .noneHasJsonName } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJsondecodingError + case 0: self = .noneHasJsonName default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJsondecodingError: return 0 + case .noneHasJsonName: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJsonName] = [ + .noneHasJsonName, + ] + } - enum JSONDecodingOptions: SwiftProtobuf.Enum { + enum hasJstype: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJsondecodingOptions // = 0 + case noneHasJstype // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJsondecodingOptions + self = .noneHasJstype } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJsondecodingOptions + case 0: self = .noneHasJstype default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJsondecodingOptions: return 0 + case .noneHasJstype: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJstype] = [ + .noneHasJstype, + ] + } - enum jsonEncoder: SwiftProtobuf.Enum { + enum hasLabel: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJsonEncoder // = 0 + case noneHasLabel // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJsonEncoder + self = .noneHasLabel } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJsonEncoder + case 0: self = .noneHasLabel default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJsonEncoder: return 0 + case .noneHasLabel: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasLabel] = [ + .noneHasLabel, + ] + } - enum JSONEncodingError: SwiftProtobuf.Enum { + enum hasLazy: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJsonencodingError // = 0 + case noneHasLazy // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJsonencodingError + self = .noneHasLazy } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJsonencodingError + case 0: self = .noneHasLazy default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJsonencodingError: return 0 + case .noneHasLazy: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasLazy] = [ + .noneHasLazy, + ] + } - enum JSONEncodingOptions: SwiftProtobuf.Enum { + enum hasLeadingComments: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJsonencodingOptions // = 0 + case noneHasLeadingComments // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJsonencodingOptions + self = .noneHasLeadingComments } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJsonencodingOptions + case 0: self = .noneHasLeadingComments default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJsonencodingOptions: return 0 + case .noneHasLeadingComments: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasLeadingComments] = [ + .noneHasLeadingComments, + ] + } - enum JSONEncodingVisitor: SwiftProtobuf.Enum { + enum hasMapEntry: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJsonencodingVisitor // = 0 + case noneHasMapEntry // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJsonencodingVisitor + self = .noneHasMapEntry } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJsonencodingVisitor + case 0: self = .noneHasMapEntry default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJsonencodingVisitor: return 0 + case .noneHasMapEntry: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMapEntry] = [ + .noneHasMapEntry, + ] + } - enum JSONMapEncodingVisitor: SwiftProtobuf.Enum { + enum hasMaximumEdition: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJsonmapEncodingVisitor // = 0 + case noneHasMaximumEdition // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJsonmapEncodingVisitor + self = .noneHasMaximumEdition } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJsonmapEncodingVisitor + case 0: self = .noneHasMaximumEdition default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJsonmapEncodingVisitor: return 0 + case .noneHasMaximumEdition: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMaximumEdition] = [ + .noneHasMaximumEdition, + ] + } - enum jsonName: SwiftProtobuf.Enum { + enum hasMessageEncoding: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJsonName // = 0 + case noneHasMessageEncoding // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJsonName + self = .noneHasMessageEncoding } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJsonName + case 0: self = .noneHasMessageEncoding default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJsonName: return 0 + case .noneHasMessageEncoding: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMessageEncoding] = [ + .noneHasMessageEncoding, + ] + } - enum jsonPath: SwiftProtobuf.Enum { + enum hasMessageSetWireFormat: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJsonPath // = 0 + case noneHasMessageSetWireFormat // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJsonPath + self = .noneHasMessageSetWireFormat } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJsonPath + case 0: self = .noneHasMessageSetWireFormat default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJsonPath: return 0 + case .noneHasMessageSetWireFormat: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMessageSetWireFormat] = [ + .noneHasMessageSetWireFormat, + ] + } - enum jsonPaths: SwiftProtobuf.Enum { + enum hasMinimumEdition: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJsonPaths // = 0 + case noneHasMinimumEdition // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJsonPaths + self = .noneHasMinimumEdition } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJsonPaths + case 0: self = .noneHasMinimumEdition default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJsonPaths: return 0 + case .noneHasMinimumEdition: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMinimumEdition] = [ + .noneHasMinimumEdition, + ] + } - enum JSONScanner: SwiftProtobuf.Enum { + enum hasName: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJsonscanner // = 0 + case noneHasName // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJsonscanner + self = .noneHasName } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJsonscanner + case 0: self = .noneHasName default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJsonscanner: return 0 + case .noneHasName: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasName] = [ + .noneHasName, + ] + } - enum jsonString: SwiftProtobuf.Enum { + enum hasNamePart: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJsonString // = 0 + case noneHasNamePart // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJsonString + self = .noneHasNamePart } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJsonString + case 0: self = .noneHasNamePart default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJsonString: return 0 + case .noneHasNamePart: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNamePart] = [ + .noneHasNamePart, + ] + } - enum jsonText: SwiftProtobuf.Enum { + enum hasNegativeIntValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJsonText // = 0 + case noneHasNegativeIntValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJsonText + self = .noneHasNegativeIntValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJsonText + case 0: self = .noneHasNegativeIntValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJsonText: return 0 + case .noneHasNegativeIntValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNegativeIntValue] = [ + .noneHasNegativeIntValue, + ] + } - enum jsonUTF8Data: SwiftProtobuf.Enum { + enum hasNoStandardDescriptorAccessor: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJsonUtf8Data // = 0 + case noneHasNoStandardDescriptorAccessor // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJsonUtf8Data + self = .noneHasNoStandardDescriptorAccessor } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJsonUtf8Data + case 0: self = .noneHasNoStandardDescriptorAccessor default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJsonUtf8Data: return 0 + case .noneHasNoStandardDescriptorAccessor: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNoStandardDescriptorAccessor] = [ + .noneHasNoStandardDescriptorAccessor, + ] + } - enum jstype: SwiftProtobuf.Enum { + enum hasNumber: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneJstype // = 0 + case noneHasNumber // = 0 case UNRECOGNIZED(Int) init() { - self = .noneJstype + self = .noneHasNumber } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneJstype + case 0: self = .noneHasNumber default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneJstype: return 0 + case .noneHasNumber: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNumber] = [ + .noneHasNumber, + ] + } - enum k: SwiftProtobuf.Enum { + enum hasObjcClassPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneK // = 0 + case noneHasObjcClassPrefix // = 0 case UNRECOGNIZED(Int) init() { - self = .noneK + self = .noneHasObjcClassPrefix } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneK + case 0: self = .noneHasObjcClassPrefix default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneK: return 0 + case .noneHasObjcClassPrefix: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasObjcClassPrefix] = [ + .noneHasObjcClassPrefix, + ] + } - enum Key: SwiftProtobuf.Enum { + enum hasOneofIndex: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneKey // = 0 + case noneHasOneofIndex // = 0 case UNRECOGNIZED(Int) init() { - self = .noneKey + self = .noneHasOneofIndex } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneKey + case 0: self = .noneHasOneofIndex default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneKey: return 0 + case .noneHasOneofIndex: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOneofIndex] = [ + .noneHasOneofIndex, + ] + } - enum keyField: SwiftProtobuf.Enum { + enum hasOptimizeFor: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneKeyField // = 0 + case noneHasOptimizeFor // = 0 case UNRECOGNIZED(Int) init() { - self = .noneKeyField + self = .noneHasOptimizeFor } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneKeyField + case 0: self = .noneHasOptimizeFor default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneKeyField: return 0 + case .noneHasOptimizeFor: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOptimizeFor] = [ + .noneHasOptimizeFor, + ] + } - enum KeyType: SwiftProtobuf.Enum { + enum hasOptions: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneKeyType // = 0 + case noneHasOptions // = 0 case UNRECOGNIZED(Int) init() { - self = .noneKeyType + self = .noneHasOptions } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneKeyType + case 0: self = .noneHasOptions default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneKeyType: return 0 + case .noneHasOptions: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOptions] = [ + .noneHasOptions, + ] + } - enum kind: SwiftProtobuf.Enum { + enum hasOutputType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneKind // = 0 + case noneHasOutputType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneKind + self = .noneHasOutputType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneKind + case 0: self = .noneHasOutputType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneKind: return 0 + case .noneHasOutputType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOutputType] = [ + .noneHasOutputType, + ] + } - enum l: SwiftProtobuf.Enum { + enum hasOverridableFeatures: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneL // = 0 + case noneHasOverridableFeatures // = 0 case UNRECOGNIZED(Int) init() { - self = .noneL + self = .noneHasOverridableFeatures } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneL + case 0: self = .noneHasOverridableFeatures default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneL: return 0 + case .noneHasOverridableFeatures: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOverridableFeatures] = [ + .noneHasOverridableFeatures, + ] + } - enum label: SwiftProtobuf.Enum { + enum hasPackage: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneLabel // = 0 + case noneHasPackage // = 0 case UNRECOGNIZED(Int) init() { - self = .noneLabel + self = .noneHasPackage } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneLabel + case 0: self = .noneHasPackage default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneLabel: return 0 + case .noneHasPackage: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPackage] = [ + .noneHasPackage, + ] + } - enum lazy: SwiftProtobuf.Enum { + enum hasPacked: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneLazy // = 0 + case noneHasPacked // = 0 case UNRECOGNIZED(Int) init() { - self = .noneLazy + self = .noneHasPacked } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneLazy + case 0: self = .noneHasPacked default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneLazy: return 0 + case .noneHasPacked: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPacked] = [ + .noneHasPacked, + ] + } - enum leadingComments: SwiftProtobuf.Enum { + enum hasPhpClassPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneLeadingComments // = 0 + case noneHasPhpClassPrefix // = 0 case UNRECOGNIZED(Int) init() { - self = .noneLeadingComments + self = .noneHasPhpClassPrefix } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneLeadingComments + case 0: self = .noneHasPhpClassPrefix default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneLeadingComments: return 0 + case .noneHasPhpClassPrefix: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPhpClassPrefix] = [ + .noneHasPhpClassPrefix, + ] + } - enum leadingDetachedComments: SwiftProtobuf.Enum { + enum hasPhpMetadataNamespace: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneLeadingDetachedComments // = 0 + case noneHasPhpMetadataNamespace // = 0 case UNRECOGNIZED(Int) init() { - self = .noneLeadingDetachedComments + self = .noneHasPhpMetadataNamespace } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneLeadingDetachedComments + case 0: self = .noneHasPhpMetadataNamespace default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneLeadingDetachedComments: return 0 + case .noneHasPhpMetadataNamespace: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPhpMetadataNamespace] = [ + .noneHasPhpMetadataNamespace, + ] + } - enum length: SwiftProtobuf.Enum { + enum hasPhpNamespace: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneLength // = 0 + case noneHasPhpNamespace // = 0 case UNRECOGNIZED(Int) init() { - self = .noneLength + self = .noneHasPhpNamespace } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneLength + case 0: self = .noneHasPhpNamespace default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneLength: return 0 + case .noneHasPhpNamespace: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPhpNamespace] = [ + .noneHasPhpNamespace, + ] + } - enum lessThan: SwiftProtobuf.Enum { + enum hasPositiveIntValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneLessThan // = 0 + case noneHasPositiveIntValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneLessThan + self = .noneHasPositiveIntValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneLessThan + case 0: self = .noneHasPositiveIntValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneLessThan: return 0 + case .noneHasPositiveIntValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPositiveIntValue] = [ + .noneHasPositiveIntValue, + ] + } - enum letEnum: SwiftProtobuf.Enum { + enum hasProto3Optional: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneLet // = 0 + case noneHasProto3Optional // = 0 case UNRECOGNIZED(Int) init() { - self = .noneLet + self = .noneHasProto3Optional } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneLet + case 0: self = .noneHasProto3Optional default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneLet: return 0 + case .noneHasProto3Optional: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasProto3Optional] = [ + .noneHasProto3Optional, + ] + } - enum lhs: SwiftProtobuf.Enum { + enum hasPyGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneLhs // = 0 + case noneHasPyGenericServices // = 0 case UNRECOGNIZED(Int) init() { - self = .noneLhs + self = .noneHasPyGenericServices } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneLhs + case 0: self = .noneHasPyGenericServices default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneLhs: return 0 + case .noneHasPyGenericServices: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPyGenericServices] = [ + .noneHasPyGenericServices, + ] + } - enum list: SwiftProtobuf.Enum { + enum hasRemovalError: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneList // = 0 + case noneHasRemovalError // = 0 case UNRECOGNIZED(Int) init() { - self = .noneList + self = .noneHasRemovalError } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneList + case 0: self = .noneHasRemovalError default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneList: return 0 + case .noneHasRemovalError: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRemovalError] = [ + .noneHasRemovalError, + ] + } - enum listOfMessages: SwiftProtobuf.Enum { + enum hasRepeated: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneListOfMessages // = 0 + case noneHasRepeated // = 0 case UNRECOGNIZED(Int) init() { - self = .noneListOfMessages + self = .noneHasRepeated } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneListOfMessages + case 0: self = .noneHasRepeated default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneListOfMessages: return 0 + case .noneHasRepeated: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRepeated] = [ + .noneHasRepeated, + ] + } - enum listValue: SwiftProtobuf.Enum { + enum hasRepeatedFieldEncoding: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneListValue // = 0 + case noneHasRepeatedFieldEncoding // = 0 case UNRECOGNIZED(Int) init() { - self = .noneListValue + self = .noneHasRepeatedFieldEncoding } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneListValue + case 0: self = .noneHasRepeatedFieldEncoding default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneListValue: return 0 + case .noneHasRepeatedFieldEncoding: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRepeatedFieldEncoding] = [ + .noneHasRepeatedFieldEncoding, + ] + } - enum littleEndian: SwiftProtobuf.Enum { + enum hasReserved: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneLittleEndian // = 0 + case noneHasReserved // = 0 case UNRECOGNIZED(Int) init() { - self = .noneLittleEndian + self = .noneHasReserved } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneLittleEndian + case 0: self = .noneHasReserved default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneLittleEndian: return 0 + case .noneHasReserved: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasReserved] = [ + .noneHasReserved, + ] + } - enum littleEndianBytes: SwiftProtobuf.Enum { + enum hasRetention: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneLittleEndianBytes // = 0 + case noneHasRetention // = 0 case UNRECOGNIZED(Int) init() { - self = .noneLittleEndianBytes + self = .noneHasRetention } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneLittleEndianBytes + case 0: self = .noneHasRetention default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneLittleEndianBytes: return 0 + case .noneHasRetention: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRetention] = [ + .noneHasRetention, + ] + } - enum load: SwiftProtobuf.Enum { + enum hasRubyPackage: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneLoad // = 0 + case noneHasRubyPackage // = 0 case UNRECOGNIZED(Int) init() { - self = .noneLoad + self = .noneHasRubyPackage } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneLoad + case 0: self = .noneHasRubyPackage default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneLoad: return 0 + case .noneHasRubyPackage: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRubyPackage] = [ + .noneHasRubyPackage, + ] + } - enum localHasher: SwiftProtobuf.Enum { + enum hasSemantic: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneLocalHasher // = 0 + case noneHasSemantic // = 0 case UNRECOGNIZED(Int) init() { - self = .noneLocalHasher + self = .noneHasSemantic } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneLocalHasher + case 0: self = .noneHasSemantic default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneLocalHasher: return 0 + case .noneHasSemantic: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSemantic] = [ + .noneHasSemantic, + ] + } - enum location: SwiftProtobuf.Enum { + enum hasServerStreaming: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneLocation // = 0 + case noneHasServerStreaming // = 0 case UNRECOGNIZED(Int) init() { - self = .noneLocation + self = .noneHasServerStreaming } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneLocation + case 0: self = .noneHasServerStreaming default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneLocation: return 0 + case .noneHasServerStreaming: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasServerStreaming] = [ + .noneHasServerStreaming, + ] + } - enum M: SwiftProtobuf.Enum { + enum hasSourceCodeInfo: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneM // = 0 + case noneHasSourceCodeInfo // = 0 case UNRECOGNIZED(Int) init() { - self = .noneM + self = .noneHasSourceCodeInfo } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneM + case 0: self = .noneHasSourceCodeInfo default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneM: return 0 + case .noneHasSourceCodeInfo: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSourceCodeInfo] = [ + .noneHasSourceCodeInfo, + ] + } - enum major: SwiftProtobuf.Enum { + enum hasSourceContext: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMajor // = 0 + case noneHasSourceContext // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMajor + self = .noneHasSourceContext } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMajor + case 0: self = .noneHasSourceContext default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMajor: return 0 + case .noneHasSourceContext: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSourceContext] = [ + .noneHasSourceContext, + ] + } - enum makeIterator: SwiftProtobuf.Enum { + enum hasSourceFile: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMakeIterator // = 0 + case noneHasSourceFile // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMakeIterator + self = .noneHasSourceFile } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMakeIterator + case 0: self = .noneHasSourceFile default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMakeIterator: return 0 + case .noneHasSourceFile: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSourceFile] = [ + .noneHasSourceFile, + ] + } - enum mapEntry: SwiftProtobuf.Enum { + enum hasStart: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMapEntry // = 0 + case noneHasStart // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMapEntry + self = .noneHasStart } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMapEntry + case 0: self = .noneHasStart default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMapEntry: return 0 + case .noneHasStart: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasStart] = [ + .noneHasStart, + ] + } - enum mapHash: SwiftProtobuf.Enum { + enum hasStringValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMapHash // = 0 + case noneHasStringValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMapHash + self = .noneHasStringValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMapHash + case 0: self = .noneHasStringValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMapHash: return 0 + case .noneHasStringValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasStringValue] = [ + .noneHasStringValue, + ] + } - enum MapKeyType: SwiftProtobuf.Enum { + enum hasSwiftPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMapKeyType // = 0 + case noneHasSwiftPrefix // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMapKeyType + self = .noneHasSwiftPrefix } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMapKeyType + case 0: self = .noneHasSwiftPrefix default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMapKeyType: return 0 + case .noneHasSwiftPrefix: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSwiftPrefix] = [ + .noneHasSwiftPrefix, + ] + } - enum mapNameResolver: SwiftProtobuf.Enum { + enum hasSyntax: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMapNameResolver // = 0 + case noneHasSyntax // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMapNameResolver + self = .noneHasSyntax } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMapNameResolver + case 0: self = .noneHasSyntax default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMapNameResolver: return 0 + case .noneHasSyntax: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSyntax] = [ + .noneHasSyntax, + ] + } - enum mapToMessages: SwiftProtobuf.Enum { + enum hasTrailingComments: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMapToMessages // = 0 + case noneHasTrailingComments // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMapToMessages + self = .noneHasTrailingComments } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMapToMessages + case 0: self = .noneHasTrailingComments default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMapToMessages: return 0 + case .noneHasTrailingComments: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasTrailingComments] = [ + .noneHasTrailingComments, + ] + } - enum MapValueType: SwiftProtobuf.Enum { + enum hasType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMapValueType // = 0 + case noneHasType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMapValueType + self = .noneHasType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMapValueType + case 0: self = .noneHasType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMapValueType: return 0 + case .noneHasType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasType] = [ + .noneHasType, + ] + } - enum mapVisitor: SwiftProtobuf.Enum { + enum hasTypeName: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMapVisitor // = 0 + case noneHasTypeName // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMapVisitor + self = .noneHasTypeName } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMapVisitor + case 0: self = .noneHasTypeName default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMapVisitor: return 0 + case .noneHasTypeName: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasTypeName] = [ + .noneHasTypeName, + ] + } - enum mdayStart: SwiftProtobuf.Enum { + enum hasUnverifiedLazy: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMdayStart // = 0 + case noneHasUnverifiedLazy // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMdayStart + self = .noneHasUnverifiedLazy } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMdayStart + case 0: self = .noneHasUnverifiedLazy default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMdayStart: return 0 + case .noneHasUnverifiedLazy: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasUnverifiedLazy] = [ + .noneHasUnverifiedLazy, + ] + } - enum merge: SwiftProtobuf.Enum { + enum hasUtf8Validation: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMerge // = 0 + case noneHasUtf8Validation // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMerge + self = .noneHasUtf8Validation } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMerge + case 0: self = .noneHasUtf8Validation default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMerge: return 0 + case .noneHasUtf8Validation: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasUtf8Validation] = [ + .noneHasUtf8Validation, + ] + } - enum message: SwiftProtobuf.Enum { + enum hasValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMessage // = 0 + case noneHasValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMessage + self = .noneHasValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMessage + case 0: self = .noneHasValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMessage: return 0 + case .noneHasValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasValue] = [ + .noneHasValue, + ] + } - enum messageDepthLimit: SwiftProtobuf.Enum { + enum hasVerification: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMessageDepthLimit // = 0 + case noneHasVerification // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMessageDepthLimit + self = .noneHasVerification } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMessageDepthLimit + case 0: self = .noneHasVerification default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMessageDepthLimit: return 0 + case .noneHasVerification: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasVerification] = [ + .noneHasVerification, + ] + } - enum MessageExtension: SwiftProtobuf.Enum { + enum hasVisibility: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMessageExtension // = 0 + case noneHasVisibility // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMessageExtension + self = .noneHasVisibility } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMessageExtension + case 0: self = .noneHasVisibility default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMessageExtension: return 0 + case .noneHasVisibility: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasVisibility] = [ + .noneHasVisibility, + ] + } - enum MessageImplementationBase: SwiftProtobuf.Enum { + enum hasWeak: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMessageImplementationBase // = 0 + case noneHasWeak // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMessageImplementationBase + self = .noneHasWeak } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMessageImplementationBase + case 0: self = .noneHasWeak default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMessageImplementationBase: return 0 + case .noneHasWeak: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasWeak] = [ + .noneHasWeak, + ] + } - enum MessageOptions: SwiftProtobuf.Enum { + enum hour: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMessageOptions // = 0 + case noneHour // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMessageOptions + self = .noneHour } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMessageOptions + case 0: self = .noneHour default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMessageOptions: return 0 + case .noneHour: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hour] = [ + .noneHour, + ] + } - enum MessageSet: SwiftProtobuf.Enum { + enum i: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMessageSet // = 0 + case noneI // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMessageSet + self = .noneI } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMessageSet + case 0: self = .noneI default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMessageSet: return 0 + case .noneI: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.i] = [ + .noneI, + ] + } - enum messageSetWireFormat: SwiftProtobuf.Enum { + enum idempotencyLevel: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMessageSetWireFormat // = 0 + case noneIdempotencyLevel // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMessageSetWireFormat + self = .noneIdempotencyLevel } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMessageSetWireFormat + case 0: self = .noneIdempotencyLevel default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMessageSetWireFormat: return 0 + case .noneIdempotencyLevel: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.idempotencyLevel] = [ + .noneIdempotencyLevel, + ] + } - enum messageType: SwiftProtobuf.Enum { + enum identifierValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMessageType // = 0 + case noneIdentifierValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMessageType + self = .noneIdentifierValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMessageType + case 0: self = .noneIdentifierValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMessageType: return 0 + case .noneIdentifierValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.identifierValue] = [ + .noneIdentifierValue, + ] + } - enum Method: SwiftProtobuf.Enum { + enum ifEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMethod // = 0 + case noneIf // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMethod + self = .noneIf } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMethod + case 0: self = .noneIf default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMethod: return 0 + case .noneIf: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ifEnum] = [ + .noneIf, + ] + } - enum MethodDescriptorProto: SwiftProtobuf.Enum { + enum ignoreUnknownExtensionFields: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMethodDescriptorProto // = 0 + case noneIgnoreUnknownExtensionFields // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMethodDescriptorProto + self = .noneIgnoreUnknownExtensionFields } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMethodDescriptorProto + case 0: self = .noneIgnoreUnknownExtensionFields default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMethodDescriptorProto: return 0 + case .noneIgnoreUnknownExtensionFields: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ignoreUnknownExtensionFields] = [ + .noneIgnoreUnknownExtensionFields, + ] + } - enum MethodOptions: SwiftProtobuf.Enum { + enum ignoreUnknownFields: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMethodOptions // = 0 + case noneIgnoreUnknownFields // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMethodOptions + self = .noneIgnoreUnknownFields } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMethodOptions + case 0: self = .noneIgnoreUnknownFields default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMethodOptions: return 0 + case .noneIgnoreUnknownFields: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ignoreUnknownFields] = [ + .noneIgnoreUnknownFields, + ] + } - enum methods: SwiftProtobuf.Enum { + enum index: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMethods // = 0 + case noneIndex // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMethods + self = .noneIndex } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMethods + case 0: self = .noneIndex default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMethods: return 0 + case .noneIndex: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.index] = [ + .noneIndex, + ] + } - enum minor: SwiftProtobuf.Enum { + enum initEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMinor // = 0 + case noneInit // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMinor + self = .noneInit } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMinor + case 0: self = .noneInit default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMinor: return 0 + case .noneInit: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.initEnum] = [ + .noneInit, + ] + } - enum Mixin: SwiftProtobuf.Enum { + enum inoutEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMixin // = 0 + case noneInout // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMixin + self = .noneInout } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMixin + case 0: self = .noneInout default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMixin: return 0 + case .noneInout: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.inoutEnum] = [ + .noneInout, + ] + } - enum mixins: SwiftProtobuf.Enum { + enum inputType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMixins // = 0 + case noneInputType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMixins + self = .noneInputType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMixins + case 0: self = .noneInputType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMixins: return 0 + case .noneInputType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.inputType] = [ + .noneInputType, + ] + } - enum modifier: SwiftProtobuf.Enum { + enum insert: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneModifier // = 0 + case noneInsert // = 0 case UNRECOGNIZED(Int) init() { - self = .noneModifier + self = .noneInsert } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneModifier + case 0: self = .noneInsert default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneModifier: return 0 + case .noneInsert: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.insert] = [ + .noneInsert, + ] + } - enum modify: SwiftProtobuf.Enum { + enum Instruction: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneModify // = 0 + case noneInstruction // = 0 case UNRECOGNIZED(Int) init() { - self = .noneModify + self = .noneInstruction } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneModify + case 0: self = .noneInstruction default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneModify: return 0 + case .noneInstruction: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Instruction] = [ + .noneInstruction, + ] + } - enum month: SwiftProtobuf.Enum { + enum IntEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMonth // = 0 + case noneInt // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMonth + self = .noneInt } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMonth + case 0: self = .noneInt default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMonth: return 0 + case .noneInt: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.IntEnum] = [ + .noneInt, + ] + } - enum msgExtension: SwiftProtobuf.Enum { + enum Int32Enum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMsgExtension // = 0 + case noneInt32 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMsgExtension + self = .noneInt32 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMsgExtension + case 0: self = .noneInt32 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMsgExtension: return 0 + case .noneInt32: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Int32Enum] = [ + .noneInt32, + ] + } - enum mutating: SwiftProtobuf.Enum { + enum Int64Enum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneMutating // = 0 + case noneInt64 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneMutating + self = .noneInt64 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneMutating + case 0: self = .noneInt64 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneMutating: return 0 + case .noneInt64: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Int64Enum] = [ + .noneInt64, + ] + } - enum n: SwiftProtobuf.Enum { + enum Int8: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case oneN // = 0 + case noneInt8 // = 0 case UNRECOGNIZED(Int) init() { - self = .oneN + self = .noneInt8 } init?(rawValue: Int) { switch rawValue { - case 0: self = .oneN + case 0: self = .noneInt8 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .oneN: return 0 + case .noneInt8: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Int8] = [ + .noneInt8, + ] + } - enum name: SwiftProtobuf.Enum { + enum integerLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneName // = 0 + case noneIntegerLiteral // = 0 case UNRECOGNIZED(Int) init() { - self = .noneName + self = .noneIntegerLiteral } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneName + case 0: self = .noneIntegerLiteral default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneName: return 0 + case .noneIntegerLiteral: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.integerLiteral] = [ + .noneIntegerLiteral, + ] + } - enum NameDescription: SwiftProtobuf.Enum { + enum IntegerLiteralType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNameDescription // = 0 + case noneIntegerLiteralType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNameDescription + self = .noneIntegerLiteralType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNameDescription + case 0: self = .noneIntegerLiteralType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNameDescription: return 0 + case .noneIntegerLiteralType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.IntegerLiteralType] = [ + .noneIntegerLiteralType, + ] + } - enum NameMap: SwiftProtobuf.Enum { + enum intern: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNameMap // = 0 + case noneIntern // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNameMap + self = .noneIntern } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNameMap + case 0: self = .noneIntern default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNameMap: return 0 + case .noneIntern: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.intern] = [ + .noneIntern, + ] + } - enum NamePart: SwiftProtobuf.Enum { + enum Internal: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNamePart // = 0 + case noneInternal // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNamePart + self = .noneInternal } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNamePart + case 0: self = .noneInternal default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNamePart: return 0 + case .noneInternal: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Internal] = [ + .noneInternal, + ] + } - enum nameResolver: SwiftProtobuf.Enum { + enum InternalState: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNameResolver // = 0 + case noneInternalState // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNameResolver + self = .noneInternalState } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNameResolver + case 0: self = .noneInternalState default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNameResolver: return 0 + case .noneInternalState: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.InternalState] = [ + .noneInternalState, + ] + } - enum names: SwiftProtobuf.Enum { + enum intersect: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNames // = 0 + case noneIntersect // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNames + self = .noneIntersect } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNames + case 0: self = .noneIntersect default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNames: return 0 + case .noneIntersect: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.intersect] = [ + .noneIntersect, + ] + } - enum nanos: SwiftProtobuf.Enum { + enum into: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNanos // = 0 + case noneInto // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNanos + self = .noneInto } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNanos + case 0: self = .noneInto default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNanos: return 0 + case .noneInto: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.into] = [ + .noneInto, + ] + } - enum nativeBytes: SwiftProtobuf.Enum { + enum ints: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNativeBytes // = 0 + case noneInts // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNativeBytes + self = .noneInts } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNativeBytes + case 0: self = .noneInts default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNativeBytes: return 0 + case .noneInts: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ints] = [ + .noneInts, + ] + } - enum nativeEndianBytes: SwiftProtobuf.Enum { + enum invalidAnyTypeURL: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNativeEndianBytes // = 0 + case noneInvalidAnyTypeURL // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNativeEndianBytes + self = .noneInvalidAnyTypeURL } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNativeEndianBytes + case 0: self = .noneInvalidAnyTypeURL default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNativeEndianBytes: return 0 + case .noneInvalidAnyTypeURL: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.invalidAnyTypeURL] = [ + .noneInvalidAnyTypeURL, + ] + } - enum negativeIntValue: SwiftProtobuf.Enum { + enum isA: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNegativeIntValue // = 0 + case noneIsA // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNegativeIntValue + self = .noneIsA } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNegativeIntValue + case 0: self = .noneIsA default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNegativeIntValue: return 0 + case .noneIsA: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isA] = [ + .noneIsA, + ] + } - enum nestedType: SwiftProtobuf.Enum { + enum isEqual: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNestedType // = 0 + case noneIsEqual // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNestedType + self = .noneIsEqual } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNestedType + case 0: self = .noneIsEqual default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNestedType: return 0 + case .noneIsEqual: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isEqual] = [ + .noneIsEqual, + ] + } - enum newL: SwiftProtobuf.Enum { + enum isEqualTo: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNewL // = 0 + case noneIsEqualTo // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNewL + self = .noneIsEqualTo } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNewL + case 0: self = .noneIsEqualTo default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNewL: return 0 + case .noneIsEqualTo: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isEqualTo] = [ + .noneIsEqualTo, + ] + } - enum newList: SwiftProtobuf.Enum { + enum isExtension: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNewList // = 0 + case noneIsExtension // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNewList + self = .noneIsExtension } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNewList + case 0: self = .noneIsExtension default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNewList: return 0 + case .noneIsExtension: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isExtension] = [ + .noneIsExtension, + ] + } - enum newValue: SwiftProtobuf.Enum { + enum isInitializedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNewValue // = 0 + case noneIsInitialized // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNewValue + self = .noneIsInitialized } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNewValue + case 0: self = .noneIsInitialized default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNewValue: return 0 + case .noneIsInitialized: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isInitializedEnum] = [ + .noneIsInitialized, + ] + } - enum nextByte: SwiftProtobuf.Enum { + enum isNegative: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNextByte // = 0 + case noneIsNegative // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNextByte + self = .noneIsNegative } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNextByte + case 0: self = .noneIsNegative default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNextByte: return 0 + case .noneIsNegative: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isNegative] = [ + .noneIsNegative, + ] + } - enum nextFieldNumber: SwiftProtobuf.Enum { + enum isPathValid: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNextFieldNumber // = 0 + case noneIsPathValid // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNextFieldNumber + self = .noneIsPathValid } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNextFieldNumber + case 0: self = .noneIsPathValid default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNextFieldNumber: return 0 + case .noneIsPathValid: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isPathValid] = [ + .noneIsPathValid, + ] + } - enum nilEnum: SwiftProtobuf.Enum { + enum isReserved: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNil // = 0 + case noneIsReserved // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNil + self = .noneIsReserved } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNil + case 0: self = .noneIsReserved default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNil: return 0 + case .noneIsReserved: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isReserved] = [ + .noneIsReserved, + ] + } - enum nilLiteral: SwiftProtobuf.Enum { + enum isValid: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNilLiteral // = 0 + case noneIsValid // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNilLiteral + self = .noneIsValid } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNilLiteral + case 0: self = .noneIsValid default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNilLiteral: return 0 + case .noneIsValid: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isValid] = [ + .noneIsValid, + ] + } - enum noStandardDescriptorAccessor: SwiftProtobuf.Enum { + enum itemTagsEncodedSize: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNoStandardDescriptorAccessor // = 0 + case noneItemTagsEncodedSize // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNoStandardDescriptorAccessor + self = .noneItemTagsEncodedSize } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNoStandardDescriptorAccessor + case 0: self = .noneItemTagsEncodedSize default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNoStandardDescriptorAccessor: return 0 + case .noneItemTagsEncodedSize: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.itemTagsEncodedSize] = [ + .noneItemTagsEncodedSize, + ] + } - enum nullValue: SwiftProtobuf.Enum { + enum iterator: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNullValue // = 0 + case noneIterator // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNullValue + self = .noneIterator } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNullValue + case 0: self = .noneIterator default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNullValue: return 0 + case .noneIterator: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.iterator] = [ + .noneIterator, + ] + } - enum number: SwiftProtobuf.Enum { + enum javaGenerateEqualsAndHash: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNumber // = 0 + case noneJavaGenerateEqualsAndHash // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNumber + self = .noneJavaGenerateEqualsAndHash } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNumber + case 0: self = .noneJavaGenerateEqualsAndHash default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNumber: return 0 + case .noneJavaGenerateEqualsAndHash: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaGenerateEqualsAndHash] = [ + .noneJavaGenerateEqualsAndHash, + ] + } - enum numberValue: SwiftProtobuf.Enum { + enum javaGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneNumberValue // = 0 + case noneJavaGenericServices // = 0 case UNRECOGNIZED(Int) init() { - self = .noneNumberValue + self = .noneJavaGenericServices } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneNumberValue + case 0: self = .noneJavaGenericServices default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneNumberValue: return 0 + case .noneJavaGenericServices: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaGenericServices] = [ + .noneJavaGenericServices, + ] + } - enum objcClassPrefix: SwiftProtobuf.Enum { + enum javaMultipleFiles: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneObjcClassPrefix // = 0 + case noneJavaMultipleFiles // = 0 case UNRECOGNIZED(Int) init() { - self = .noneObjcClassPrefix + self = .noneJavaMultipleFiles } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneObjcClassPrefix + case 0: self = .noneJavaMultipleFiles default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneObjcClassPrefix: return 0 + case .noneJavaMultipleFiles: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaMultipleFiles] = [ + .noneJavaMultipleFiles, + ] + } - enum of: SwiftProtobuf.Enum { + enum javaOuterClassname: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOf // = 0 + case noneJavaOuterClassname // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOf + self = .noneJavaOuterClassname } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOf + case 0: self = .noneJavaOuterClassname default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOf: return 0 + case .noneJavaOuterClassname: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaOuterClassname] = [ + .noneJavaOuterClassname, + ] + } - enum oneofDecl: SwiftProtobuf.Enum { + enum javaPackage: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOneofDecl // = 0 + case noneJavaPackage // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOneofDecl + self = .noneJavaPackage } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOneofDecl + case 0: self = .noneJavaPackage default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOneofDecl: return 0 + case .noneJavaPackage: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaPackage] = [ + .noneJavaPackage, + ] + } - enum OneofDescriptorProto: SwiftProtobuf.Enum { + enum javaStringCheckUtf8: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOneofDescriptorProto // = 0 + case noneJavaStringCheckUtf8 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOneofDescriptorProto + self = .noneJavaStringCheckUtf8 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOneofDescriptorProto + case 0: self = .noneJavaStringCheckUtf8 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOneofDescriptorProto: return 0 + case .noneJavaStringCheckUtf8: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaStringCheckUtf8] = [ + .noneJavaStringCheckUtf8, + ] + } - enum oneofIndex: SwiftProtobuf.Enum { + enum JSONDecoder: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOneofIndex // = 0 + case noneJsondecoder // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOneofIndex + self = .noneJsondecoder } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOneofIndex + case 0: self = .noneJsondecoder default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOneofIndex: return 0 + case .noneJsondecoder: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecoder] = [ + .noneJsondecoder, + ] + } - enum OneofOptions: SwiftProtobuf.Enum { + enum JSONDecoding: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOneofOptions // = 0 + case noneJsondecoding // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOneofOptions + self = .noneJsondecoding } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOneofOptions + case 0: self = .noneJsondecoding default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOneofOptions: return 0 + case .noneJsondecoding: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecoding] = [ + .noneJsondecoding, + ] + } - enum oneofs: SwiftProtobuf.Enum { + enum JSONDecodingError: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOneofs // = 0 + case noneJsondecodingError // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOneofs + self = .noneJsondecodingError } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOneofs + case 0: self = .noneJsondecodingError default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOneofs: return 0 + case .noneJsondecodingError: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecodingError] = [ + .noneJsondecodingError, + ] + } - enum OneOf_Kind: SwiftProtobuf.Enum { + enum JSONDecodingOptions: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOneOfKind // = 0 + case noneJsondecodingOptions // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOneOfKind + self = .noneJsondecodingOptions } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOneOfKind + case 0: self = .noneJsondecodingOptions default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOneOfKind: return 0 + case .noneJsondecodingOptions: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecodingOptions] = [ + .noneJsondecodingOptions, + ] + } - enum optimizeFor: SwiftProtobuf.Enum { + enum jsonEncoder: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOptimizeFor // = 0 + case noneJsonEncoder // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOptimizeFor + self = .noneJsonEncoder } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOptimizeFor + case 0: self = .noneJsonEncoder default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOptimizeFor: return 0 + case .noneJsonEncoder: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonEncoder] = [ + .noneJsonEncoder, + ] + } - enum OptimizeMode: SwiftProtobuf.Enum { + enum JSONEncoding: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOptimizeMode // = 0 + case noneJsonencoding // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOptimizeMode + self = .noneJsonencoding } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOptimizeMode + case 0: self = .noneJsonencoding default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOptimizeMode: return 0 + case .noneJsonencoding: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncoding] = [ + .noneJsonencoding, + ] + } - enum Option: SwiftProtobuf.Enum { + enum JSONEncodingError: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOption // = 0 + case noneJsonencodingError // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOption + self = .noneJsonencodingError } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOption + case 0: self = .noneJsonencodingError default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOption: return 0 + case .noneJsonencodingError: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncodingError] = [ + .noneJsonencodingError, + ] + } - enum OptionalEnumExtensionField: SwiftProtobuf.Enum { + enum JSONEncodingOptions: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOptionalEnumExtensionField // = 0 + case noneJsonencodingOptions // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOptionalEnumExtensionField + self = .noneJsonencodingOptions } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOptionalEnumExtensionField + case 0: self = .noneJsonencodingOptions default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOptionalEnumExtensionField: return 0 + case .noneJsonencodingOptions: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncodingOptions] = [ + .noneJsonencodingOptions, + ] + } - enum OptionalExtensionField: SwiftProtobuf.Enum { + enum JSONEncodingVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOptionalExtensionField // = 0 + case noneJsonencodingVisitor // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOptionalExtensionField + self = .noneJsonencodingVisitor } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOptionalExtensionField + case 0: self = .noneJsonencodingVisitor default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOptionalExtensionField: return 0 + case .noneJsonencodingVisitor: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncodingVisitor] = [ + .noneJsonencodingVisitor, + ] + } - enum OptionalGroupExtensionField: SwiftProtobuf.Enum { + enum jsonFormat: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOptionalGroupExtensionField // = 0 + case noneJsonFormat // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOptionalGroupExtensionField + self = .noneJsonFormat } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOptionalGroupExtensionField + case 0: self = .noneJsonFormat default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOptionalGroupExtensionField: return 0 + case .noneJsonFormat: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonFormat] = [ + .noneJsonFormat, + ] + } - enum OptionalMessageExtensionField: SwiftProtobuf.Enum { + enum JSONMapEncodingVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOptionalMessageExtensionField // = 0 + case noneJsonmapEncodingVisitor // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOptionalMessageExtensionField + self = .noneJsonmapEncodingVisitor } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOptionalMessageExtensionField + case 0: self = .noneJsonmapEncodingVisitor default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOptionalMessageExtensionField: return 0 + case .noneJsonmapEncodingVisitor: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONMapEncodingVisitor] = [ + .noneJsonmapEncodingVisitor, + ] + } - enum options: SwiftProtobuf.Enum { + enum jsonName: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOptions // = 0 + case noneJsonName // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOptions + self = .noneJsonName } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOptions + case 0: self = .noneJsonName default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOptions: return 0 + case .noneJsonName: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonName] = [ + .noneJsonName, + ] + } - enum other: SwiftProtobuf.Enum { + enum jsonPath: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOther // = 0 + case noneJsonPath // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOther + self = .noneJsonPath } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOther + case 0: self = .noneJsonPath default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOther: return 0 + case .noneJsonPath: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonPath] = [ + .noneJsonPath, + ] + } - enum others: SwiftProtobuf.Enum { + enum jsonPaths: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOthers // = 0 + case noneJsonPaths // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOthers + self = .noneJsonPaths } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOthers + case 0: self = .noneJsonPaths default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOthers: return 0 + case .noneJsonPaths: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonPaths] = [ + .noneJsonPaths, + ] + } - enum out: SwiftProtobuf.Enum { + enum JSONScanner: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOut // = 0 + case noneJsonscanner // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOut + self = .noneJsonscanner } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOut + case 0: self = .noneJsonscanner default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOut: return 0 + case .noneJsonscanner: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONScanner] = [ + .noneJsonscanner, + ] + } - enum outputType: SwiftProtobuf.Enum { + enum jsonString: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneOutputType // = 0 + case noneJsonString // = 0 case UNRECOGNIZED(Int) init() { - self = .noneOutputType + self = .noneJsonString } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneOutputType + case 0: self = .noneJsonString default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneOutputType: return 0 + case .noneJsonString: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonString] = [ + .noneJsonString, + ] + } - enum p: SwiftProtobuf.Enum { + enum jsonText: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneP // = 0 + case noneJsonText // = 0 case UNRECOGNIZED(Int) init() { - self = .noneP + self = .noneJsonText } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneP + case 0: self = .noneJsonText default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneP: return 0 + case .noneJsonText: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonText] = [ + .noneJsonText, + ] + } - enum package: SwiftProtobuf.Enum { + enum jsonUTF8Bytes: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePackage // = 0 + case noneJsonUtf8Bytes // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePackage + self = .noneJsonUtf8Bytes } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePackage + case 0: self = .noneJsonUtf8Bytes default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePackage: return 0 + case .noneJsonUtf8Bytes: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonUTF8Bytes] = [ + .noneJsonUtf8Bytes, + ] + } - enum packed: SwiftProtobuf.Enum { + enum jsonUTF8Data: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePacked // = 0 + case noneJsonUtf8Data // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePacked + self = .noneJsonUtf8Data } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePacked + case 0: self = .noneJsonUtf8Data default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePacked: return 0 + case .noneJsonUtf8Data: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonUTF8Data] = [ + .noneJsonUtf8Data, + ] + } - enum PackedEnumExtensionField: SwiftProtobuf.Enum { + enum jstype: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePackedEnumExtensionField // = 0 + case noneJstype // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePackedEnumExtensionField + self = .noneJstype } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePackedEnumExtensionField + case 0: self = .noneJstype default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePackedEnumExtensionField: return 0 + case .noneJstype: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jstype] = [ + .noneJstype, + ] + } - enum PackedExtensionField: SwiftProtobuf.Enum { + enum k: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePackedExtensionField // = 0 + case noneK // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePackedExtensionField + self = .noneK } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePackedExtensionField + case 0: self = .noneK default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePackedExtensionField: return 0 + case .noneK: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.k] = [ + .noneK, + ] + } - enum padding: SwiftProtobuf.Enum { + enum kChunkSize: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePadding // = 0 + case noneKChunkSize // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePadding + self = .noneKChunkSize } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePadding + case 0: self = .noneKChunkSize default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePadding: return 0 + case .noneKChunkSize: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.kChunkSize] = [ + .noneKChunkSize, + ] + } - enum parent: SwiftProtobuf.Enum { + enum Key: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneParent // = 0 + case noneKey // = 0 case UNRECOGNIZED(Int) init() { - self = .noneParent + self = .noneKey } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneParent + case 0: self = .noneKey default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneParent: return 0 + case .noneKey: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Key] = [ + .noneKey, + ] + } - enum parse: SwiftProtobuf.Enum { + enum keyField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneParse // = 0 + case noneKeyField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneParse + self = .noneKeyField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneParse + case 0: self = .noneKeyField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneParse: return 0 + case .noneKeyField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.keyField] = [ + .noneKeyField, + ] + } - enum partial: SwiftProtobuf.Enum { + enum keyFieldOpt: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePartial // = 0 + case noneKeyFieldOpt // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePartial + self = .noneKeyFieldOpt } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePartial + case 0: self = .noneKeyFieldOpt default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePartial: return 0 + case .noneKeyFieldOpt: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.keyFieldOpt] = [ + .noneKeyFieldOpt, + ] + } - enum path: SwiftProtobuf.Enum { + enum KeyType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePath // = 0 + case noneKeyType // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePath + self = .noneKeyType } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePath + case 0: self = .noneKeyType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePath: return 0 + case .noneKeyType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.KeyType] = [ + .noneKeyType, + ] + } - enum paths: SwiftProtobuf.Enum { + enum kind: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePaths // = 0 + case noneKind // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePaths + self = .noneKind } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePaths + case 0: self = .noneKind default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePaths: return 0 + case .noneKind: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.kind] = [ + .noneKind, + ] + } - enum payload: SwiftProtobuf.Enum { + enum l: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePayload // = 0 + case noneL // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePayload + self = .noneL } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePayload + case 0: self = .noneL default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePayload: return 0 + case .noneL: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.l] = [ + .noneL, + ] + } - enum payloadSize: SwiftProtobuf.Enum { + enum label: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePayloadSize // = 0 + case noneLabel // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePayloadSize + self = .noneLabel } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePayloadSize + case 0: self = .noneLabel default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePayloadSize: return 0 + case .noneLabel: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.label] = [ + .noneLabel, + ] + } - enum phpClassPrefix: SwiftProtobuf.Enum { + enum lazy: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePhpClassPrefix // = 0 + case noneLazy // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePhpClassPrefix + self = .noneLazy } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePhpClassPrefix + case 0: self = .noneLazy default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePhpClassPrefix: return 0 + case .noneLazy: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.lazy] = [ + .noneLazy, + ] + } - enum phpGenericServices: SwiftProtobuf.Enum { + enum leadingComments: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePhpGenericServices // = 0 + case noneLeadingComments // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePhpGenericServices + self = .noneLeadingComments } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePhpGenericServices + case 0: self = .noneLeadingComments default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePhpGenericServices: return 0 + case .noneLeadingComments: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.leadingComments] = [ + .noneLeadingComments, + ] + } - enum phpMetadataNamespace: SwiftProtobuf.Enum { + enum leadingDetachedComments: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePhpMetadataNamespace // = 0 + case noneLeadingDetachedComments // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePhpMetadataNamespace + self = .noneLeadingDetachedComments } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePhpMetadataNamespace + case 0: self = .noneLeadingDetachedComments default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePhpMetadataNamespace: return 0 + case .noneLeadingDetachedComments: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.leadingDetachedComments] = [ + .noneLeadingDetachedComments, + ] + } - enum phpNamespace: SwiftProtobuf.Enum { + enum length: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePhpNamespace // = 0 + case noneLength // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePhpNamespace + self = .noneLength } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePhpNamespace + case 0: self = .noneLength default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePhpNamespace: return 0 + case .noneLength: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.length] = [ + .noneLength, + ] + } - enum pointer: SwiftProtobuf.Enum { + enum lessThan: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePointer // = 0 + case noneLessThan // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePointer + self = .noneLessThan } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePointer + case 0: self = .noneLessThan default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePointer: return 0 + case .noneLessThan: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.lessThan] = [ + .noneLessThan, + ] + } - enum pos: SwiftProtobuf.Enum { + enum letEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePos // = 0 + case noneLet // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePos + self = .noneLet } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePos + case 0: self = .noneLet default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePos: return 0 + case .noneLet: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.letEnum] = [ + .noneLet, + ] + } - enum positiveIntValue: SwiftProtobuf.Enum { + enum lhs: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePositiveIntValue // = 0 + case noneLhs // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePositiveIntValue + self = .noneLhs } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePositiveIntValue + case 0: self = .noneLhs default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePositiveIntValue: return 0 + case .noneLhs: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.lhs] = [ + .noneLhs, + ] + } - enum prefix: SwiftProtobuf.Enum { + enum line: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePrefix // = 0 + case noneLine // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePrefix + self = .noneLine } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePrefix + case 0: self = .noneLine default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePrefix: return 0 + case .noneLine: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.line] = [ + .noneLine, + ] + } - enum preserveProtoFieldNames: SwiftProtobuf.Enum { + enum list: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePreserveProtoFieldNames // = 0 + case noneList // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePreserveProtoFieldNames + self = .noneList } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePreserveProtoFieldNames + case 0: self = .noneList default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePreserveProtoFieldNames: return 0 + case .noneList: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.list] = [ + .noneList, + ] + } - enum preTraverse: SwiftProtobuf.Enum { + enum listOfMessages: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePreTraverse // = 0 + case noneListOfMessages // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePreTraverse + self = .noneListOfMessages } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePreTraverse + case 0: self = .noneListOfMessages default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePreTraverse: return 0 + case .noneListOfMessages: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.listOfMessages] = [ + .noneListOfMessages, + ] + } - enum printUnknownFields: SwiftProtobuf.Enum { + enum listValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePrintUnknownFields // = 0 + case noneListValue // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePrintUnknownFields + self = .noneListValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePrintUnknownFields + case 0: self = .noneListValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePrintUnknownFields: return 0 + case .noneListValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.listValue] = [ + .noneListValue, + ] + } - enum proto2: SwiftProtobuf.Enum { + enum littleEndian: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProto2 // = 0 + case noneLittleEndian // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProto2 + self = .noneLittleEndian } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProto2 + case 0: self = .noneLittleEndian default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProto2: return 0 + case .noneLittleEndian: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.littleEndian] = [ + .noneLittleEndian, + ] + } - enum proto3DefaultValue: SwiftProtobuf.Enum { + enum load: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProto3DefaultValue // = 0 + case noneLoad // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProto3DefaultValue + self = .noneLoad } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProto3DefaultValue + case 0: self = .noneLoad default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProto3DefaultValue: return 0 + case .noneLoad: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.load] = [ + .noneLoad, + ] + } - enum proto3Optional: SwiftProtobuf.Enum { + enum localHasher: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProto3Optional // = 0 + case noneLocalHasher // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProto3Optional + self = .noneLocalHasher } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProto3Optional + case 0: self = .noneLocalHasher default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProto3Optional: return 0 + case .noneLocalHasher: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.localHasher] = [ + .noneLocalHasher, + ] + } - enum ProtobufAPIVersionCheck: SwiftProtobuf.Enum { + enum location: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufApiversionCheck // = 0 + case noneLocation // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufApiversionCheck + self = .noneLocation } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufApiversionCheck + case 0: self = .noneLocation default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufApiversionCheck: return 0 + case .noneLocation: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.location] = [ + .noneLocation, + ] + } - enum ProtobufAPIVersion_2: SwiftProtobuf.Enum { + enum M: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufApiversion2 // = 0 + case noneM // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufApiversion2 + self = .noneM } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufApiversion2 + case 0: self = .noneM default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufApiversion2: return 0 + case .noneM: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.M] = [ + .noneM, + ] + } - enum ProtobufBool: SwiftProtobuf.Enum { + enum major: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufBool // = 0 + case noneMajor // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufBool + self = .noneMajor } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufBool + case 0: self = .noneMajor default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufBool: return 0 + case .noneMajor: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.major] = [ + .noneMajor, + ] + } - enum ProtobufBytes: SwiftProtobuf.Enum { + enum makeAsyncIterator: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufBytes // = 0 + case noneMakeAsyncIterator // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufBytes + self = .noneMakeAsyncIterator } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufBytes + case 0: self = .noneMakeAsyncIterator default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufBytes: return 0 + case .noneMakeAsyncIterator: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.makeAsyncIterator] = [ + .noneMakeAsyncIterator, + ] + } - enum ProtobufDouble: SwiftProtobuf.Enum { + enum makeIterator: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufDouble // = 0 + case noneMakeIterator // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufDouble + self = .noneMakeIterator } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufDouble + case 0: self = .noneMakeIterator default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufDouble: return 0 + case .noneMakeIterator: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.makeIterator] = [ + .noneMakeIterator, + ] + } - enum ProtobufEnumMap: SwiftProtobuf.Enum { + enum malformedLength: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufEnumMap // = 0 + case noneMalformedLength // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufEnumMap + self = .noneMalformedLength } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufEnumMap + case 0: self = .noneMalformedLength default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufEnumMap: return 0 + case .noneMalformedLength: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.malformedLength] = [ + .noneMalformedLength, + ] + } - enum protobufExtension: SwiftProtobuf.Enum { + enum mapEntry: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufExtension // = 0 + case noneMapEntry // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufExtension + self = .noneMapEntry } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufExtension + case 0: self = .noneMapEntry default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufExtension: return 0 + case .noneMapEntry: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapEntry] = [ + .noneMapEntry, + ] + } - enum ProtobufFixed32: SwiftProtobuf.Enum { + enum MapKeyType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufFixed32 // = 0 + case noneMapKeyType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufFixed32 + self = .noneMapKeyType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufFixed32 + case 0: self = .noneMapKeyType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufFixed32: return 0 + case .noneMapKeyType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MapKeyType] = [ + .noneMapKeyType, + ] + } - enum ProtobufFixed64: SwiftProtobuf.Enum { + enum mapToMessages: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufFixed64 // = 0 + case noneMapToMessages // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufFixed64 + self = .noneMapToMessages } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufFixed64 + case 0: self = .noneMapToMessages default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufFixed64: return 0 + case .noneMapToMessages: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapToMessages] = [ + .noneMapToMessages, + ] + } - enum ProtobufFloat: SwiftProtobuf.Enum { + enum MapValueType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufFloat // = 0 + case noneMapValueType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufFloat + self = .noneMapValueType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufFloat + case 0: self = .noneMapValueType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufFloat: return 0 + case .noneMapValueType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MapValueType] = [ + .noneMapValueType, + ] + } - enum ProtobufInt32: SwiftProtobuf.Enum { + enum mapVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufInt32 // = 0 + case noneMapVisitor // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufInt32 + self = .noneMapVisitor } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufInt32 + case 0: self = .noneMapVisitor default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufInt32: return 0 + case .noneMapVisitor: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapVisitor] = [ + .noneMapVisitor, + ] + } - enum ProtobufInt64: SwiftProtobuf.Enum { + enum mask: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufInt64 // = 0 + case noneMask // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufInt64 + self = .noneMask } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufInt64 + case 0: self = .noneMask default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufInt64: return 0 + case .noneMask: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mask] = [ + .noneMask, + ] + } - enum ProtobufMap: SwiftProtobuf.Enum { + enum maximumEdition: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufMap // = 0 + case noneMaximumEdition // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufMap + self = .noneMaximumEdition } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufMap + case 0: self = .noneMaximumEdition default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufMap: return 0 + case .noneMaximumEdition: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.maximumEdition] = [ + .noneMaximumEdition, + ] + } - enum ProtobufMessageMap: SwiftProtobuf.Enum { + enum mdayStart: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufMessageMap // = 0 + case noneMdayStart // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufMessageMap + self = .noneMdayStart } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufMessageMap + case 0: self = .noneMdayStart default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufMessageMap: return 0 + case .noneMdayStart: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mdayStart] = [ + .noneMdayStart, + ] + } - enum ProtobufSFixed32: SwiftProtobuf.Enum { + enum merge: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufSfixed32 // = 0 + case noneMerge // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufSfixed32 + self = .noneMerge } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufSfixed32 + case 0: self = .noneMerge default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufSfixed32: return 0 + case .noneMerge: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.merge] = [ + .noneMerge, + ] + } - enum ProtobufSFixed64: SwiftProtobuf.Enum { + enum MergeOptions: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufSfixed64 // = 0 + case noneMergeOptions // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufSfixed64 + self = .noneMergeOptions } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufSfixed64 + case 0: self = .noneMergeOptions default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufSfixed64: return 0 + case .noneMergeOptions: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MergeOptions] = [ + .noneMergeOptions, + ] + } - enum ProtobufSInt32: SwiftProtobuf.Enum { + enum message: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufSint32 // = 0 + case noneMessage // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufSint32 + self = .noneMessage } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufSint32 + case 0: self = .noneMessage default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufSint32: return 0 + case .noneMessage: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.message] = [ + .noneMessage, + ] + } - enum ProtobufSInt64: SwiftProtobuf.Enum { + enum messageDepthLimit: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufSint64 // = 0 + case noneMessageDepthLimit // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufSint64 + self = .noneMessageDepthLimit } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufSint64 + case 0: self = .noneMessageDepthLimit default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufSint64: return 0 + case .noneMessageDepthLimit: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageDepthLimit] = [ + .noneMessageDepthLimit, + ] + } - enum ProtobufString: SwiftProtobuf.Enum { + enum messageEncoding: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufString // = 0 + case noneMessageEncoding // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufString + self = .noneMessageEncoding } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufString + case 0: self = .noneMessageEncoding default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufString: return 0 + case .noneMessageEncoding: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageEncoding] = [ + .noneMessageEncoding, + ] + } - enum ProtobufUInt32: SwiftProtobuf.Enum { + enum MessageExtension: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufUint32 // = 0 + case noneMessageExtension // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufUint32 + self = .noneMessageExtension } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufUint32 + case 0: self = .noneMessageExtension default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufUint32: return 0 + case .noneMessageExtension: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MessageExtension] = [ + .noneMessageExtension, + ] + } - enum ProtobufUInt64: SwiftProtobuf.Enum { + enum MessageImplementationBase: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufUint64 // = 0 + case noneMessageImplementationBase // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufUint64 + self = .noneMessageImplementationBase } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufUint64 + case 0: self = .noneMessageImplementationBase default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufUint64: return 0 + case .noneMessageImplementationBase: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MessageImplementationBase] = [ + .noneMessageImplementationBase, + ] + } - enum protobuf_extensionFieldValues: SwiftProtobuf.Enum { + enum MessageSet: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufExtensionFieldValues // = 0 + case noneMessageSet // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufExtensionFieldValues + self = .noneMessageSet } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufExtensionFieldValues + case 0: self = .noneMessageSet default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufExtensionFieldValues: return 0 + case .noneMessageSet: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MessageSet] = [ + .noneMessageSet, + ] + } - enum protobuf_fieldNumber: SwiftProtobuf.Enum { + enum messageSetWireFormat: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufFieldNumber // = 0 + case noneMessageSetWireFormat // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufFieldNumber + self = .noneMessageSetWireFormat } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufFieldNumber + case 0: self = .noneMessageSetWireFormat default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufFieldNumber: return 0 + case .noneMessageSetWireFormat: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageSetWireFormat] = [ + .noneMessageSetWireFormat, + ] + } - enum protobuf_generated_isEqualTo: SwiftProtobuf.Enum { + enum messageSize: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufGeneratedIsEqualTo // = 0 + case noneMessageSize // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufGeneratedIsEqualTo + self = .noneMessageSize } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufGeneratedIsEqualTo + case 0: self = .noneMessageSize default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufGeneratedIsEqualTo: return 0 + case .noneMessageSize: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageSize] = [ + .noneMessageSize, + ] + } - enum protobuf_nameMap: SwiftProtobuf.Enum { + enum messageType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufNameMap // = 0 + case noneMessageType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufNameMap + self = .noneMessageType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufNameMap + case 0: self = .noneMessageType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufNameMap: return 0 + case .noneMessageType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageType] = [ + .noneMessageType, + ] + } - enum protobuf_newField: SwiftProtobuf.Enum { + enum method: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufNewField // = 0 + case noneMethod // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufNewField + self = .noneMethod } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufNewField + case 0: self = .noneMethod default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufNewField: return 0 + case .noneMethod: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.method] = [ + .noneMethod, + ] + } - enum protobuf_package: SwiftProtobuf.Enum { + enum methods: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtobufPackage // = 0 + case noneMethods // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtobufPackage + self = .noneMethods } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtobufPackage + case 0: self = .noneMethods default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtobufPackage: return 0 + case .noneMethods: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.methods] = [ + .noneMethods, + ] + } - enum protocolEnum: SwiftProtobuf.Enum { + enum min: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtocol // = 0 + case noneMin // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtocol + self = .noneMin } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtocol + case 0: self = .noneMin default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtocol: return 0 + case .noneMin: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.min] = [ + .noneMin, + ] + } - enum protoFieldName: SwiftProtobuf.Enum { + enum minimumEdition: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtoFieldName // = 0 + case noneMinimumEdition // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtoFieldName + self = .noneMinimumEdition } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtoFieldName + case 0: self = .noneMinimumEdition default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtoFieldName: return 0 + case .noneMinimumEdition: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.minimumEdition] = [ + .noneMinimumEdition, + ] + } - enum protoMessageNameEnum: SwiftProtobuf.Enum { + enum minor: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtoMessageName // = 0 + case noneMinor // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtoMessageName + self = .noneMinor } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtoMessageName + case 0: self = .noneMinor default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtoMessageName: return 0 + case .noneMinor: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.minor] = [ + .noneMinor, + ] + } - enum ProtoNameProviding: SwiftProtobuf.Enum { + enum mixins: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtoNameProviding // = 0 + case noneMixins // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtoNameProviding + self = .noneMixins } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtoNameProviding + case 0: self = .noneMixins default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtoNameProviding: return 0 + case .noneMixins: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mixins] = [ + .noneMixins, + ] + } - enum protoPaths: SwiftProtobuf.Enum { + enum modify: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneProtoPaths // = 0 + case noneModify // = 0 case UNRECOGNIZED(Int) init() { - self = .noneProtoPaths + self = .noneModify } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneProtoPaths + case 0: self = .noneModify default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneProtoPaths: return 0 + case .noneModify: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.modify] = [ + .noneModify, + ] + } - enum publicEnum: SwiftProtobuf.Enum { + enum month: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePublic // = 0 + case noneMonth // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePublic + self = .noneMonth } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePublic + case 0: self = .noneMonth default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePublic: return 0 + case .noneMonth: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.month] = [ + .noneMonth, + ] + } - enum publicDependency: SwiftProtobuf.Enum { + enum msgExtension: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePublicDependency // = 0 + case noneMsgExtension // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePublicDependency + self = .noneMsgExtension } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePublicDependency + case 0: self = .noneMsgExtension default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePublicDependency: return 0 + case .noneMsgExtension: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.msgExtension] = [ + .noneMsgExtension, + ] + } - enum putBoolValue: SwiftProtobuf.Enum { + enum mutating: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePutBoolValue // = 0 + case noneMutating // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePutBoolValue + self = .noneMutating } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePutBoolValue + case 0: self = .noneMutating default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePutBoolValue: return 0 + case .noneMutating: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mutating] = [ + .noneMutating, + ] + } - enum putBytesValue: SwiftProtobuf.Enum { + enum n: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePutBytesValue // = 0 + case oneN // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePutBytesValue + self = .oneN } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePutBytesValue + case 0: self = .oneN default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePutBytesValue: return 0 + case .oneN: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.n] = [ + .oneN, + ] + } - enum putDoubleValue: SwiftProtobuf.Enum { + enum name: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePutDoubleValue // = 0 + case noneName // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePutDoubleValue + self = .noneName } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePutDoubleValue + case 0: self = .noneName default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePutDoubleValue: return 0 + case .noneName: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.name] = [ + .noneName, + ] + } - enum putEnumValue: SwiftProtobuf.Enum { + enum NameDescription: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePutEnumValue // = 0 + case noneNameDescription // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePutEnumValue + self = .noneNameDescription } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePutEnumValue + case 0: self = .noneNameDescription default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePutEnumValue: return 0 + case .noneNameDescription: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.NameDescription] = [ + .noneNameDescription, + ] + } - enum putFixedUInt32: SwiftProtobuf.Enum { + enum NameMap: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePutFixedUint32 // = 0 + case noneNameMap // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePutFixedUint32 + self = .noneNameMap } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePutFixedUint32 + case 0: self = .noneNameMap default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePutFixedUint32: return 0 + case .noneNameMap: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.NameMap] = [ + .noneNameMap, + ] + } - enum putFixedUInt64: SwiftProtobuf.Enum { + enum NamePart: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePutFixedUint64 // = 0 + case noneNamePart // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePutFixedUint64 + self = .noneNamePart } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePutFixedUint64 + case 0: self = .noneNamePart default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePutFixedUint64: return 0 + case .noneNamePart: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.NamePart] = [ + .noneNamePart, + ] + } - enum putFloatValue: SwiftProtobuf.Enum { + enum names: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePutFloatValue // = 0 + case noneNames // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePutFloatValue + self = .noneNames } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePutFloatValue + case 0: self = .noneNames default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePutFloatValue: return 0 + case .noneNames: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.names] = [ + .noneNames, + ] + } - enum putInt64: SwiftProtobuf.Enum { + enum nanos: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePutInt64 // = 0 + case noneNanos // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePutInt64 + self = .noneNanos } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePutInt64 + case 0: self = .noneNanos default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePutInt64: return 0 + case .noneNanos: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nanos] = [ + .noneNanos, + ] + } - enum putStringValue: SwiftProtobuf.Enum { + enum negativeIntValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePutStringValue // = 0 + case noneNegativeIntValue // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePutStringValue + self = .noneNegativeIntValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePutStringValue + case 0: self = .noneNegativeIntValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePutStringValue: return 0 + case .noneNegativeIntValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.negativeIntValue] = [ + .noneNegativeIntValue, + ] + } - enum putUInt64: SwiftProtobuf.Enum { + enum nestedType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePutUint64 // = 0 + case noneNestedType // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePutUint64 + self = .noneNestedType } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePutUint64 + case 0: self = .noneNestedType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePutUint64: return 0 + case .noneNestedType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nestedType] = [ + .noneNestedType, + ] + } - enum putUInt64Hex: SwiftProtobuf.Enum { + enum newExtensible: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePutUint64Hex // = 0 + case noneNewExtensible // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePutUint64Hex + self = .noneNewExtensible } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePutUint64Hex + case 0: self = .noneNewExtensible default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePutUint64Hex: return 0 + case .noneNewExtensible: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newExtensible] = [ + .noneNewExtensible, + ] + } - enum putVarInt: SwiftProtobuf.Enum { + enum newL: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePutVarInt // = 0 + case noneNewL // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePutVarInt + self = .noneNewL } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePutVarInt + case 0: self = .noneNewL default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePutVarInt: return 0 + case .noneNewL: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newL] = [ + .noneNewL, + ] + } - enum putZigZagVarInt: SwiftProtobuf.Enum { + enum newList: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePutZigZagVarInt // = 0 + case noneNewList // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePutZigZagVarInt + self = .noneNewList } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePutZigZagVarInt + case 0: self = .noneNewList default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePutZigZagVarInt: return 0 + case .noneNewList: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newList] = [ + .noneNewList, + ] + } - enum pyGenericServices: SwiftProtobuf.Enum { + enum newMessage: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case nonePyGenericServices // = 0 + case noneNewMessage // = 0 case UNRECOGNIZED(Int) init() { - self = .nonePyGenericServices + self = .noneNewMessage } init?(rawValue: Int) { switch rawValue { - case 0: self = .nonePyGenericServices + case 0: self = .noneNewMessage default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .nonePyGenericServices: return 0 + case .noneNewMessage: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newMessage] = [ + .noneNewMessage, + ] + } - enum rawChars: SwiftProtobuf.Enum { + enum newValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneRawChars // = 0 + case noneNewValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneRawChars + self = .noneNewValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneRawChars + case 0: self = .noneNewValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneRawChars: return 0 + case .noneNewValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newValue] = [ + .noneNewValue, + ] + } - enum RawRepresentable: SwiftProtobuf.Enum { + enum next: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneRawRepresentable // = 0 + case noneNext // = 0 case UNRECOGNIZED(Int) init() { - self = .noneRawRepresentable + self = .noneNext } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneRawRepresentable + case 0: self = .noneNext default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneRawRepresentable: return 0 + case .noneNext: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.next] = [ + .noneNext, + ] + } - enum RawValue: SwiftProtobuf.Enum { + enum nextByte: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneRawValue // = 0 + case noneNextByte // = 0 case UNRECOGNIZED(Int) init() { - self = .noneRawValue + self = .noneNextByte } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneRawValue + case 0: self = .noneNextByte default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneRawValue: return 0 + case .noneNextByte: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextByte] = [ + .noneNextByte, + ] + } - enum read4HexDigits: SwiftProtobuf.Enum { + enum nextFieldNumber: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneRead4HexDigits // = 0 + case noneNextFieldNumber // = 0 case UNRECOGNIZED(Int) init() { - self = .noneRead4HexDigits + self = .noneNextFieldNumber } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneRead4HexDigits + case 0: self = .noneNextFieldNumber default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneRead4HexDigits: return 0 + case .noneNextFieldNumber: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextFieldNumber] = [ + .noneNextFieldNumber, + ] + } - enum register: SwiftProtobuf.Enum { + enum nextInstruction: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneRegister // = 0 + case noneNextInstruction // = 0 case UNRECOGNIZED(Int) init() { - self = .noneRegister + self = .noneNextInstruction } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneRegister + case 0: self = .noneNextInstruction default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneRegister: return 0 + case .noneNextInstruction: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextInstruction] = [ + .noneNextInstruction, + ] + } - enum RepeatedEnumExtensionField: SwiftProtobuf.Enum { + enum nextInt32: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneRepeatedEnumExtensionField // = 0 + case noneNextInt32 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneRepeatedEnumExtensionField + self = .noneNextInt32 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneRepeatedEnumExtensionField + case 0: self = .noneNextInt32 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneRepeatedEnumExtensionField: return 0 + case .noneNextInt32: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextInt32] = [ + .noneNextInt32, + ] + } - enum RepeatedExtensionField: SwiftProtobuf.Enum { + enum nextNullTerminatedString: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneRepeatedExtensionField // = 0 + case noneNextNullTerminatedString // = 0 case UNRECOGNIZED(Int) init() { - self = .noneRepeatedExtensionField + self = .noneNextNullTerminatedString } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneRepeatedExtensionField + case 0: self = .noneNextNullTerminatedString default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneRepeatedExtensionField: return 0 + case .noneNextNullTerminatedString: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextNullTerminatedString] = [ + .noneNextNullTerminatedString, + ] + } - enum RepeatedGroupExtensionField: SwiftProtobuf.Enum { + enum nextNullTerminatedStringArray: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneRepeatedGroupExtensionField // = 0 + case noneNextNullTerminatedStringArray // = 0 case UNRECOGNIZED(Int) init() { - self = .noneRepeatedGroupExtensionField + self = .noneNextNullTerminatedStringArray } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneRepeatedGroupExtensionField + case 0: self = .noneNextNullTerminatedStringArray default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneRepeatedGroupExtensionField: return 0 + case .noneNextNullTerminatedStringArray: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextNullTerminatedStringArray] = [ + .noneNextNullTerminatedStringArray, + ] + } - enum RepeatedMessageExtensionField: SwiftProtobuf.Enum { + enum nextNumber: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneRepeatedMessageExtensionField // = 0 + case noneNextNumber // = 0 case UNRECOGNIZED(Int) init() { - self = .noneRepeatedMessageExtensionField + self = .noneNextNumber } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneRepeatedMessageExtensionField + case 0: self = .noneNextNumber default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneRepeatedMessageExtensionField: return 0 + case .noneNextNumber: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextNumber] = [ + .noneNextNumber, + ] + } - enum requestStreaming: SwiftProtobuf.Enum { + enum nextUInt64: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneRequestStreaming // = 0 + case noneNextUint64 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneRequestStreaming + self = .noneNextUint64 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneRequestStreaming + case 0: self = .noneNextUint64 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneRequestStreaming: return 0 + case .noneNextUint64: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextUInt64] = [ + .noneNextUint64, + ] + } - enum requestTypeURL: SwiftProtobuf.Enum { + enum nextVarInt: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneRequestTypeURL // = 0 + case noneNextVarInt // = 0 case UNRECOGNIZED(Int) init() { - self = .noneRequestTypeURL + self = .noneNextVarInt } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneRequestTypeURL + case 0: self = .noneNextVarInt default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneRequestTypeURL: return 0 + case .noneNextVarInt: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextVarInt] = [ + .noneNextVarInt, + ] + } - enum requiredSize: SwiftProtobuf.Enum { + enum nilEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneRequiredSize // = 0 + case noneNil // = 0 case UNRECOGNIZED(Int) init() { - self = .noneRequiredSize + self = .noneNil } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneRequiredSize + case 0: self = .noneNil default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneRequiredSize: return 0 + case .noneNil: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nilEnum] = [ + .noneNil, + ] + } - enum reservedName: SwiftProtobuf.Enum { + enum nilLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneReservedName // = 0 + case noneNilLiteral // = 0 case UNRECOGNIZED(Int) init() { - self = .noneReservedName + self = .noneNilLiteral } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneReservedName + case 0: self = .noneNilLiteral default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneReservedName: return 0 + case .noneNilLiteral: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nilLiteral] = [ + .noneNilLiteral, + ] + } - enum reservedRange: SwiftProtobuf.Enum { + enum noBytesAvailable: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneReservedRange // = 0 + case noneNoBytesAvailable // = 0 case UNRECOGNIZED(Int) init() { - self = .noneReservedRange + self = .noneNoBytesAvailable } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneReservedRange + case 0: self = .noneNoBytesAvailable default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneReservedRange: return 0 + case .noneNoBytesAvailable: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.noBytesAvailable] = [ + .noneNoBytesAvailable, + ] + } - enum responseStreaming: SwiftProtobuf.Enum { + enum noStandardDescriptorAccessor: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneResponseStreaming // = 0 + case noneNoStandardDescriptorAccessor // = 0 case UNRECOGNIZED(Int) init() { - self = .noneResponseStreaming + self = .noneNoStandardDescriptorAccessor } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneResponseStreaming + case 0: self = .noneNoStandardDescriptorAccessor default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneResponseStreaming: return 0 + case .noneNoStandardDescriptorAccessor: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.noStandardDescriptorAccessor] = [ + .noneNoStandardDescriptorAccessor, + ] + } - enum responseTypeURL: SwiftProtobuf.Enum { + enum nullValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneResponseTypeURL // = 0 + case noneNullValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneResponseTypeURL + self = .noneNullValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneResponseTypeURL + case 0: self = .noneNullValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneResponseTypeURL: return 0 + case .noneNullValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nullValue] = [ + .noneNullValue, + ] + } - enum result: SwiftProtobuf.Enum { + enum number: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneResult // = 0 + case noneNumber // = 0 case UNRECOGNIZED(Int) init() { - self = .noneResult + self = .noneNumber } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneResult + case 0: self = .noneNumber default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneResult: return 0 + case .noneNumber: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.number] = [ + .noneNumber, + ] + } - enum rethrowsEnum: SwiftProtobuf.Enum { + enum numberValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneRethrows // = 0 + case noneNumberValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneRethrows + self = .noneNumberValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneRethrows + case 0: self = .noneNumberValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneRethrows: return 0 + case .noneNumberValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.numberValue] = [ + .noneNumberValue, + ] + } - enum returnEnum: SwiftProtobuf.Enum { + enum objcClassPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneReturn // = 0 + case noneObjcClassPrefix // = 0 case UNRECOGNIZED(Int) init() { - self = .noneReturn + self = .noneObjcClassPrefix } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneReturn + case 0: self = .noneObjcClassPrefix default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneReturn: return 0 + case .noneObjcClassPrefix: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.objcClassPrefix] = [ + .noneObjcClassPrefix, + ] + } - enum ReturnType: SwiftProtobuf.Enum { + enum of: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneReturnType // = 0 + case noneOf // = 0 case UNRECOGNIZED(Int) init() { - self = .noneReturnType + self = .noneOf } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneReturnType + case 0: self = .noneOf default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneReturnType: return 0 + case .noneOf: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.of] = [ + .noneOf, + ] + } - enum revision: SwiftProtobuf.Enum { + enum OneOf_Kind: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneRevision // = 0 + case noneOneOfKind // = 0 case UNRECOGNIZED(Int) init() { - self = .noneRevision + self = .noneOneOfKind } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneRevision + case 0: self = .noneOneOfKind default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneRevision: return 0 + case .noneOneOfKind: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OneOf_Kind] = [ + .noneOneOfKind, + ] + } - enum rhs: SwiftProtobuf.Enum { + enum oneofDecl: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneRhs // = 0 + case noneOneofDecl // = 0 case UNRECOGNIZED(Int) init() { - self = .noneRhs + self = .noneOneofDecl } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneRhs + case 0: self = .noneOneofDecl default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneRhs: return 0 + case .noneOneofDecl: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofDecl] = [ + .noneOneofDecl, + ] + } - enum root: SwiftProtobuf.Enum { + enum oneofIndex: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneRoot // = 0 + case noneOneofIndex // = 0 case UNRECOGNIZED(Int) init() { - self = .noneRoot + self = .noneOneofIndex } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneRoot + case 0: self = .noneOneofIndex default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneRoot: return 0 + case .noneOneofIndex: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofIndex] = [ + .noneOneofIndex, + ] + } - enum rubyPackage: SwiftProtobuf.Enum { + enum oneofs: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneRubyPackage // = 0 + case noneOneofs // = 0 case UNRECOGNIZED(Int) init() { - self = .noneRubyPackage + self = .noneOneofs } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneRubyPackage + case 0: self = .noneOneofs default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneRubyPackage: return 0 + case .noneOneofs: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofs] = [ + .noneOneofs, + ] + } - enum s: SwiftProtobuf.Enum { + enum optimizeFor: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneS // = 0 + case noneOptimizeFor // = 0 case UNRECOGNIZED(Int) init() { - self = .noneS + self = .noneOptimizeFor } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneS + case 0: self = .noneOptimizeFor default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneS: return 0 + case .noneOptimizeFor: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.optimizeFor] = [ + .noneOptimizeFor, + ] + } - enum sawBackslash: SwiftProtobuf.Enum { + enum OptimizeMode: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSawBackslash // = 0 + case noneOptimizeMode // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSawBackslash + self = .noneOptimizeMode } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSawBackslash + case 0: self = .noneOptimizeMode default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSawBackslash: return 0 + case .noneOptimizeMode: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptimizeMode] = [ + .noneOptimizeMode, + ] + } - enum sawSection4Characters: SwiftProtobuf.Enum { + enum OptionalEnumExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSawSection4Characters // = 0 + case noneOptionalEnumExtensionField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSawSection4Characters + self = .noneOptionalEnumExtensionField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSawSection4Characters + case 0: self = .noneOptionalEnumExtensionField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSawSection4Characters: return 0 + case .noneOptionalEnumExtensionField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalEnumExtensionField] = [ + .noneOptionalEnumExtensionField, + ] + } - enum sawSection5Characters: SwiftProtobuf.Enum { + enum OptionalExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSawSection5Characters // = 0 + case noneOptionalExtensionField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSawSection5Characters + self = .noneOptionalExtensionField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSawSection5Characters + case 0: self = .noneOptionalExtensionField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSawSection5Characters: return 0 + case .noneOptionalExtensionField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalExtensionField] = [ + .noneOptionalExtensionField, + ] + } - enum scanner: SwiftProtobuf.Enum { + enum OptionalGroupExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneScanner // = 0 + case noneOptionalGroupExtensionField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneScanner + self = .noneOptionalGroupExtensionField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneScanner + case 0: self = .noneOptionalGroupExtensionField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneScanner: return 0 + case .noneOptionalGroupExtensionField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalGroupExtensionField] = [ + .noneOptionalGroupExtensionField, + ] + } - enum seconds: SwiftProtobuf.Enum { + enum OptionalMessageExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSeconds // = 0 + case noneOptionalMessageExtensionField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSeconds + self = .noneOptionalMessageExtensionField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSeconds + case 0: self = .noneOptionalMessageExtensionField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSeconds: return 0 + case .noneOptionalMessageExtensionField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalMessageExtensionField] = [ + .noneOptionalMessageExtensionField, + ] + } - enum selfEnum: SwiftProtobuf.Enum { + enum optionDependency: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSelf // = 0 + case noneOptionDependency // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSelf + self = .noneOptionDependency } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSelf + case 0: self = .noneOptionDependency default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSelf: return 0 + case .noneOptionDependency: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.optionDependency] = [ + .noneOptionDependency, + ] + } - enum separator: SwiftProtobuf.Enum { + enum OptionRetention: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSeparator // = 0 + case noneOptionRetention // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSeparator + self = .noneOptionRetention } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSeparator + case 0: self = .noneOptionRetention default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSeparator: return 0 + case .noneOptionRetention: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionRetention] = [ + .noneOptionRetention, + ] + } - enum serialize: SwiftProtobuf.Enum { + enum options: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSerialize // = 0 + case noneOptions // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSerialize + self = .noneOptions } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSerialize + case 0: self = .noneOptions default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSerialize: return 0 + case .noneOptions: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.options] = [ + .noneOptions, + ] + } - enum serializedData: SwiftProtobuf.Enum { + enum OptionTargetType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSerializedData // = 0 + case noneOptionTargetType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSerializedData + self = .noneOptionTargetType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSerializedData + case 0: self = .noneOptionTargetType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSerializedData: return 0 + case .noneOptionTargetType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionTargetType] = [ + .noneOptionTargetType, + ] + } - enum serializedSize: SwiftProtobuf.Enum { + enum other: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSerializedSize // = 0 + case noneOther // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSerializedSize + self = .noneOther } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSerializedSize + case 0: self = .noneOther default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSerializedSize: return 0 + case .noneOther: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.other] = [ + .noneOther, + ] + } - enum serverStreaming: SwiftProtobuf.Enum { + enum others: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneServerStreaming // = 0 + case noneOthers // = 0 case UNRECOGNIZED(Int) init() { - self = .noneServerStreaming + self = .noneOthers } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneServerStreaming + case 0: self = .noneOthers default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneServerStreaming: return 0 + case .noneOthers: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.others] = [ + .noneOthers, + ] + } - enum service: SwiftProtobuf.Enum { + enum out: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneService // = 0 + case noneOut // = 0 case UNRECOGNIZED(Int) init() { - self = .noneService + self = .noneOut } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneService + case 0: self = .noneOut default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneService: return 0 + case .noneOut: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.out] = [ + .noneOut, + ] + } - enum ServiceDescriptorProto: SwiftProtobuf.Enum { + enum outputType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneServiceDescriptorProto // = 0 + case noneOutputType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneServiceDescriptorProto + self = .noneOutputType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneServiceDescriptorProto + case 0: self = .noneOutputType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneServiceDescriptorProto: return 0 + case .noneOutputType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.outputType] = [ + .noneOutputType, + ] + } - enum ServiceOptions: SwiftProtobuf.Enum { + enum overridableFeatures: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneServiceOptions // = 0 + case noneOverridableFeatures // = 0 case UNRECOGNIZED(Int) init() { - self = .noneServiceOptions + self = .noneOverridableFeatures } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneServiceOptions + case 0: self = .noneOverridableFeatures default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneServiceOptions: return 0 + case .noneOverridableFeatures: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.overridableFeatures] = [ + .noneOverridableFeatures, + ] + } - enum set: SwiftProtobuf.Enum { + enum p: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSet // = 0 + case noneP // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSet + self = .noneP } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSet + case 0: self = .noneP default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSet: return 0 + case .noneP: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.p] = [ + .noneP, + ] + } - enum setExtensionValue: SwiftProtobuf.Enum { + enum package: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSetExtensionValue // = 0 + case nonePackage // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSetExtensionValue + self = .nonePackage } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSetExtensionValue + case 0: self = .nonePackage default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSetExtensionValue: return 0 + case .nonePackage: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.package] = [ + .nonePackage, + ] + } - enum shift: SwiftProtobuf.Enum { + enum packed: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneShift // = 0 + case nonePacked // = 0 case UNRECOGNIZED(Int) init() { - self = .noneShift + self = .nonePacked } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneShift + case 0: self = .nonePacked default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneShift: return 0 + case .nonePacked: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packed] = [ + .nonePacked, + ] + } - enum SimpleExtensionMap: SwiftProtobuf.Enum { + enum PackedEnumExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSimpleExtensionMap // = 0 + case nonePackedEnumExtensionField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSimpleExtensionMap + self = .nonePackedEnumExtensionField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSimpleExtensionMap + case 0: self = .nonePackedEnumExtensionField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSimpleExtensionMap: return 0 + case .nonePackedEnumExtensionField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PackedEnumExtensionField] = [ + .nonePackedEnumExtensionField, + ] + } - enum sizer: SwiftProtobuf.Enum { + enum PackedExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSizer // = 0 + case nonePackedExtensionField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSizer + self = .nonePackedExtensionField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSizer + case 0: self = .nonePackedExtensionField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSizer: return 0 + case .nonePackedExtensionField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PackedExtensionField] = [ + .nonePackedExtensionField, + ] + } - enum source: SwiftProtobuf.Enum { + enum padding: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSource // = 0 + case nonePadding // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSource + self = .nonePadding } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSource + case 0: self = .nonePadding default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSource: return 0 + case .nonePadding: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.padding] = [ + .nonePadding, + ] + } - enum sourceCodeInfo: SwiftProtobuf.Enum { + enum parent: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSourceCodeInfo // = 0 + case noneParent // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSourceCodeInfo + self = .noneParent } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSourceCodeInfo + case 0: self = .noneParent default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSourceCodeInfo: return 0 + case .noneParent: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.parent] = [ + .noneParent, + ] + } - enum sourceContext: SwiftProtobuf.Enum { + enum parse: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSourceContext // = 0 + case noneParse // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSourceContext + self = .noneParse } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSourceContext + case 0: self = .noneParse default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSourceContext: return 0 + case .noneParse: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.parse] = [ + .noneParse, + ] + } - enum sourceEncoding: SwiftProtobuf.Enum { + enum partial: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSourceEncoding // = 0 + case nonePartial // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSourceEncoding + self = .nonePartial } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSourceEncoding + case 0: self = .nonePartial default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSourceEncoding: return 0 + case .nonePartial: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.partial] = [ + .nonePartial, + ] + } - enum sourceFile: SwiftProtobuf.Enum { + enum path: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSourceFile // = 0 + case nonePath // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSourceFile + self = .nonePath } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSourceFile + case 0: self = .nonePath default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSourceFile: return 0 + case .nonePath: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.path] = [ + .nonePath, + ] + } - enum span: SwiftProtobuf.Enum { + enum PathDecoder: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSpan // = 0 + case nonePathDecoder // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSpan + self = .nonePathDecoder } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSpan + case 0: self = .nonePathDecoder default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSpan: return 0 + case .nonePathDecoder: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PathDecoder] = [ + .nonePathDecoder, + ] + } - enum split: SwiftProtobuf.Enum { + enum PathDecodingError: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSplit // = 0 + case nonePathDecodingError // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSplit + self = .nonePathDecodingError } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSplit + case 0: self = .nonePathDecodingError default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSplit: return 0 + case .nonePathDecodingError: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PathDecodingError] = [ + .nonePathDecodingError, + ] + } - enum start: SwiftProtobuf.Enum { + enum paths: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneStart // = 0 + case nonePaths // = 0 case UNRECOGNIZED(Int) init() { - self = .noneStart + self = .nonePaths } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneStart + case 0: self = .nonePaths default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneStart: return 0 + case .nonePaths: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.paths] = [ + .nonePaths, + ] + } - enum startArray: SwiftProtobuf.Enum { + enum PathVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneStartArray // = 0 + case nonePathVisitor // = 0 case UNRECOGNIZED(Int) init() { - self = .noneStartArray + self = .nonePathVisitor } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneStartArray + case 0: self = .nonePathVisitor default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneStartArray: return 0 + case .nonePathVisitor: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PathVisitor] = [ + .nonePathVisitor, + ] + } - enum startArrayObject: SwiftProtobuf.Enum { + enum payload: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneStartArrayObject // = 0 + case nonePayload // = 0 case UNRECOGNIZED(Int) init() { - self = .noneStartArrayObject + self = .nonePayload } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneStartArrayObject + case 0: self = .nonePayload default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneStartArrayObject: return 0 + case .nonePayload: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.payload] = [ + .nonePayload, + ] + } - enum startField: SwiftProtobuf.Enum { + enum payloadSize: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneStartField // = 0 + case nonePayloadSize // = 0 case UNRECOGNIZED(Int) init() { - self = .noneStartField + self = .nonePayloadSize } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneStartField + case 0: self = .nonePayloadSize default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneStartField: return 0 + case .nonePayloadSize: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.payloadSize] = [ + .nonePayloadSize, + ] + } - enum startIndex: SwiftProtobuf.Enum { + enum phpClassPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneStartIndex // = 0 + case nonePhpClassPrefix // = 0 case UNRECOGNIZED(Int) init() { - self = .noneStartIndex + self = .nonePhpClassPrefix } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneStartIndex + case 0: self = .nonePhpClassPrefix default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneStartIndex: return 0 + case .nonePhpClassPrefix: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpClassPrefix] = [ + .nonePhpClassPrefix, + ] + } - enum startMessageField: SwiftProtobuf.Enum { + enum phpMetadataNamespace: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneStartMessageField // = 0 + case nonePhpMetadataNamespace // = 0 case UNRECOGNIZED(Int) init() { - self = .noneStartMessageField + self = .nonePhpMetadataNamespace } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneStartMessageField + case 0: self = .nonePhpMetadataNamespace default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneStartMessageField: return 0 + case .nonePhpMetadataNamespace: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpMetadataNamespace] = [ + .nonePhpMetadataNamespace, + ] + } - enum startObject: SwiftProtobuf.Enum { + enum phpNamespace: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneStartObject // = 0 + case nonePhpNamespace // = 0 case UNRECOGNIZED(Int) init() { - self = .noneStartObject + self = .nonePhpNamespace } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneStartObject + case 0: self = .nonePhpNamespace default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneStartObject: return 0 + case .nonePhpNamespace: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpNamespace] = [ + .nonePhpNamespace, + ] + } - enum startRegularField: SwiftProtobuf.Enum { + enum pos: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneStartRegularField // = 0 + case nonePos // = 0 case UNRECOGNIZED(Int) init() { - self = .noneStartRegularField + self = .nonePos } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneStartRegularField + case 0: self = .nonePos default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneStartRegularField: return 0 + case .nonePos: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.pos] = [ + .nonePos, + ] + } - enum state: SwiftProtobuf.Enum { + enum positiveIntValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneState // = 0 + case nonePositiveIntValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneState + self = .nonePositiveIntValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneState + case 0: self = .nonePositiveIntValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneState: return 0 + case .nonePositiveIntValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.positiveIntValue] = [ + .nonePositiveIntValue, + ] + } - enum staticEnum: SwiftProtobuf.Enum { + enum prefix: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneStatic // = 0 + case nonePrefix // = 0 case UNRECOGNIZED(Int) init() { - self = .noneStatic + self = .nonePrefix } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneStatic + case 0: self = .nonePrefix default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneStatic: return 0 + case .nonePrefix: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.prefix] = [ + .nonePrefix, + ] + } - enum StaticString: SwiftProtobuf.Enum { + enum preserveProtoFieldNames: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneStaticString // = 0 + case nonePreserveProtoFieldNames // = 0 case UNRECOGNIZED(Int) init() { - self = .noneStaticString + self = .nonePreserveProtoFieldNames } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneStaticString + case 0: self = .nonePreserveProtoFieldNames default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneStaticString: return 0 + case .nonePreserveProtoFieldNames: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.preserveProtoFieldNames] = [ + .nonePreserveProtoFieldNames, + ] + } - enum storage: SwiftProtobuf.Enum { + enum preTraverse: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneStorage // = 0 + case nonePreTraverse // = 0 case UNRECOGNIZED(Int) init() { - self = .noneStorage + self = .nonePreTraverse } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneStorage + case 0: self = .nonePreTraverse default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneStorage: return 0 + case .nonePreTraverse: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.preTraverse] = [ + .nonePreTraverse, + ] + } - enum StringEnum: SwiftProtobuf.Enum { + enum previousNumber: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneString // = 0 + case nonePreviousNumber // = 0 case UNRECOGNIZED(Int) init() { - self = .noneString + self = .nonePreviousNumber } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneString + case 0: self = .nonePreviousNumber default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneString: return 0 + case .nonePreviousNumber: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.previousNumber] = [ + .nonePreviousNumber, + ] + } - enum stringLiteral: SwiftProtobuf.Enum { + enum prevPath: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneStringLiteral // = 0 + case nonePrevPath // = 0 case UNRECOGNIZED(Int) init() { - self = .noneStringLiteral + self = .nonePrevPath } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneStringLiteral + case 0: self = .nonePrevPath default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneStringLiteral: return 0 + case .nonePrevPath: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.prevPath] = [ + .nonePrevPath, + ] + } - enum StringLiteralType: SwiftProtobuf.Enum { + enum printUnknownFields: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneStringLiteralType // = 0 + case nonePrintUnknownFields // = 0 case UNRECOGNIZED(Int) init() { - self = .noneStringLiteralType + self = .nonePrintUnknownFields } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneStringLiteralType + case 0: self = .nonePrintUnknownFields default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneStringLiteralType: return 0 + case .nonePrintUnknownFields: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.printUnknownFields] = [ + .nonePrintUnknownFields, + ] + } - enum stringResult: SwiftProtobuf.Enum { + enum programBuffer: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneStringResult // = 0 + case noneProgramBuffer // = 0 case UNRECOGNIZED(Int) init() { - self = .noneStringResult + self = .noneProgramBuffer } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneStringResult + case 0: self = .noneProgramBuffer default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneStringResult: return 0 + case .noneProgramBuffer: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.programBuffer] = [ + .noneProgramBuffer, + ] + } - enum stringValue: SwiftProtobuf.Enum { + enum programFormat: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneStringValue // = 0 + case noneProgramFormat // = 0 case UNRECOGNIZED(Int) init() { - self = .noneStringValue + self = .noneProgramFormat } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneStringValue + case 0: self = .noneProgramFormat default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneStringValue: return 0 + case .noneProgramFormat: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.programFormat] = [ + .noneProgramFormat, + ] + } - enum structEnum: SwiftProtobuf.Enum { + enum proto2: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneStruct // = 0 + case noneProto2 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneStruct + self = .noneProto2 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneStruct + case 0: self = .noneProto2 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneStruct: return 0 + case .noneProto2: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto2] = [ + .noneProto2, + ] + } - enum structValue: SwiftProtobuf.Enum { + enum proto3DefaultValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneStructValue // = 0 + case noneProto3DefaultValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneStructValue + self = .noneProto3DefaultValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneStructValue + case 0: self = .noneProto3DefaultValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneStructValue: return 0 + case .noneProto3DefaultValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto3DefaultValue] = [ + .noneProto3DefaultValue, + ] + } - enum subDecoder: SwiftProtobuf.Enum { + enum proto3Optional: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSubDecoder // = 0 + case noneProto3Optional // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSubDecoder + self = .noneProto3Optional } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSubDecoder + case 0: self = .noneProto3Optional default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSubDecoder: return 0 + case .noneProto3Optional: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto3Optional] = [ + .noneProto3Optional, + ] + } - enum subscriptEnum: SwiftProtobuf.Enum { + enum protobuf_extensionFieldValues: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSubscript // = 0 + case noneProtobufExtensionFieldValues // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSubscript + self = .noneProtobufExtensionFieldValues } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSubscript + case 0: self = .noneProtobufExtensionFieldValues default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSubscript: return 0 + case .noneProtobufExtensionFieldValues: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues] = [ + .noneProtobufExtensionFieldValues, + ] + } - enum subVisitor: SwiftProtobuf.Enum { + enum protobuf_fieldNumber: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSubVisitor // = 0 + case noneProtobufFieldNumber // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSubVisitor + self = .noneProtobufFieldNumber } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSubVisitor + case 0: self = .noneProtobufFieldNumber default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSubVisitor: return 0 + case .noneProtobufFieldNumber: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_fieldNumber] = [ + .noneProtobufFieldNumber, + ] + } - enum Swift: SwiftProtobuf.Enum { + enum protobuf_generated_isEqualTo: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSwift // = 0 + case noneProtobufGeneratedIsEqualTo // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSwift + self = .noneProtobufGeneratedIsEqualTo } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSwift + case 0: self = .noneProtobufGeneratedIsEqualTo default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSwift: return 0 + case .noneProtobufGeneratedIsEqualTo: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo] = [ + .noneProtobufGeneratedIsEqualTo, + ] + } - enum swiftPrefix: SwiftProtobuf.Enum { + enum protobuf_nameMap: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSwiftPrefix // = 0 + case noneProtobufNameMap // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSwiftPrefix + self = .noneProtobufNameMap } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSwiftPrefix + case 0: self = .noneProtobufNameMap default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSwiftPrefix: return 0 + case .noneProtobufNameMap: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_nameMap] = [ + .noneProtobufNameMap, + ] + } - enum SwiftProtobufEnum: SwiftProtobuf.Enum { + enum protobuf_newField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSwiftProtobuf // = 0 + case noneProtobufNewField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSwiftProtobuf + self = .noneProtobufNewField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSwiftProtobuf + case 0: self = .noneProtobufNewField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSwiftProtobuf: return 0 + case .noneProtobufNewField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_newField] = [ + .noneProtobufNewField, + ] + } - enum syntax: SwiftProtobuf.Enum { + enum protobuf_package: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneSyntax // = 0 + case noneProtobufPackage // = 0 case UNRECOGNIZED(Int) init() { - self = .noneSyntax + self = .noneProtobufPackage } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneSyntax + case 0: self = .noneProtobufPackage default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneSyntax: return 0 + case .noneProtobufPackage: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_package] = [ + .noneProtobufPackage, + ] + } - enum T: SwiftProtobuf.Enum { + enum ProtobufAPIVersion_2: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneT // = 0 + case noneProtobufApiversion2 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneT + self = .noneProtobufApiversion2 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneT + case 0: self = .noneProtobufApiversion2 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneT: return 0 + case .noneProtobufApiversion2: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_2] = [ + .noneProtobufApiversion2, + ] + } - enum tag: SwiftProtobuf.Enum { + enum ProtobufAPIVersionCheck: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTag // = 0 + case noneProtobufApiversionCheck // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTag + self = .noneProtobufApiversionCheck } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTag + case 0: self = .noneProtobufApiversionCheck default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTag: return 0 + case .noneProtobufApiversionCheck: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck] = [ + .noneProtobufApiversionCheck, + ] + } - enum terminator: SwiftProtobuf.Enum { + enum ProtobufBool: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTerminator // = 0 + case noneProtobufBool // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTerminator + self = .noneProtobufBool } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTerminator + case 0: self = .noneProtobufBool default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTerminator: return 0 + case .noneProtobufBool: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufBool] = [ + .noneProtobufBool, + ] + } - enum testDecoder: SwiftProtobuf.Enum { + enum ProtobufBytes: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTestDecoder // = 0 + case noneProtobufBytes // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTestDecoder + self = .noneProtobufBytes } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTestDecoder + case 0: self = .noneProtobufBytes default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTestDecoder: return 0 + case .noneProtobufBytes: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufBytes] = [ + .noneProtobufBytes, + ] + } - enum text: SwiftProtobuf.Enum { + enum protobufData: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneText // = 0 + case noneProtobufData // = 0 case UNRECOGNIZED(Int) init() { - self = .noneText + self = .noneProtobufData } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneText + case 0: self = .noneProtobufData default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneText: return 0 + case .noneProtobufData: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobufData] = [ + .noneProtobufData, + ] + } - enum textDecoder: SwiftProtobuf.Enum { + enum ProtobufDouble: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTextDecoder // = 0 + case noneProtobufDouble // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTextDecoder + self = .noneProtobufDouble } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTextDecoder + case 0: self = .noneProtobufDouble default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTextDecoder: return 0 + case .noneProtobufDouble: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufDouble] = [ + .noneProtobufDouble, + ] + } - enum TextFormatDecoder: SwiftProtobuf.Enum { + enum ProtobufEnumMap: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTextFormatDecoder // = 0 + case noneProtobufEnumMap // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTextFormatDecoder + self = .noneProtobufEnumMap } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTextFormatDecoder + case 0: self = .noneProtobufEnumMap default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTextFormatDecoder: return 0 + case .noneProtobufEnumMap: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufEnumMap] = [ + .noneProtobufEnumMap, + ] + } - enum TextFormatDecodingError: SwiftProtobuf.Enum { + enum protobufExtension: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTextFormatDecodingError // = 0 + case noneProtobufExtension // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTextFormatDecodingError + self = .noneProtobufExtension } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTextFormatDecodingError + case 0: self = .noneProtobufExtension default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTextFormatDecodingError: return 0 + case .noneProtobufExtension: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobufExtension] = [ + .noneProtobufExtension, + ] + } - enum TextFormatDecodingOptions: SwiftProtobuf.Enum { + enum ProtobufFixed32: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTextFormatDecodingOptions // = 0 + case noneProtobufFixed32 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTextFormatDecodingOptions + self = .noneProtobufFixed32 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTextFormatDecodingOptions + case 0: self = .noneProtobufFixed32 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTextFormatDecodingOptions: return 0 + case .noneProtobufFixed32: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFixed32] = [ + .noneProtobufFixed32, + ] + } - enum TextFormatEncodingOptions: SwiftProtobuf.Enum { + enum ProtobufFixed64: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTextFormatEncodingOptions // = 0 + case noneProtobufFixed64 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTextFormatEncodingOptions + self = .noneProtobufFixed64 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTextFormatEncodingOptions + case 0: self = .noneProtobufFixed64 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTextFormatEncodingOptions: return 0 + case .noneProtobufFixed64: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFixed64] = [ + .noneProtobufFixed64, + ] + } - enum TextFormatEncodingVisitor: SwiftProtobuf.Enum { + enum ProtobufFloat: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTextFormatEncodingVisitor // = 0 + case noneProtobufFloat // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTextFormatEncodingVisitor + self = .noneProtobufFloat } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTextFormatEncodingVisitor + case 0: self = .noneProtobufFloat default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTextFormatEncodingVisitor: return 0 + case .noneProtobufFloat: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFloat] = [ + .noneProtobufFloat, + ] + } - enum textFormatString: SwiftProtobuf.Enum { + enum ProtobufInt32: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTextFormatString // = 0 + case noneProtobufInt32 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTextFormatString + self = .noneProtobufInt32 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTextFormatString + case 0: self = .noneProtobufInt32 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTextFormatString: return 0 + case .noneProtobufInt32: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufInt32] = [ + .noneProtobufInt32, + ] + } - enum throwsEnum: SwiftProtobuf.Enum { + enum ProtobufInt64: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneThrows // = 0 + case noneProtobufInt64 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneThrows + self = .noneProtobufInt64 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneThrows + case 0: self = .noneProtobufInt64 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneThrows: return 0 + case .noneProtobufInt64: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufInt64] = [ + .noneProtobufInt64, + ] + } - enum timeInterval: SwiftProtobuf.Enum { + enum ProtobufMap: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTimeInterval // = 0 + case noneProtobufMap // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTimeInterval + self = .noneProtobufMap } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTimeInterval + case 0: self = .noneProtobufMap default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTimeInterval: return 0 + case .noneProtobufMap: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufMap] = [ + .noneProtobufMap, + ] + } - enum timeIntervalSince1970: SwiftProtobuf.Enum { + enum ProtobufMessageMap: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTimeIntervalSince1970 // = 0 + case noneProtobufMessageMap // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTimeIntervalSince1970 + self = .noneProtobufMessageMap } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTimeIntervalSince1970 + case 0: self = .noneProtobufMessageMap default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTimeIntervalSince1970: return 0 + case .noneProtobufMessageMap: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufMessageMap] = [ + .noneProtobufMessageMap, + ] + } - enum timeIntervalSinceReferenceDate: SwiftProtobuf.Enum { + enum ProtobufSFixed32: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTimeIntervalSinceReferenceDate // = 0 + case noneProtobufSfixed32 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTimeIntervalSinceReferenceDate + self = .noneProtobufSfixed32 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTimeIntervalSinceReferenceDate + case 0: self = .noneProtobufSfixed32 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTimeIntervalSinceReferenceDate: return 0 + case .noneProtobufSfixed32: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSFixed32] = [ + .noneProtobufSfixed32, + ] + } - enum Timestamp: SwiftProtobuf.Enum { + enum ProtobufSFixed64: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTimestamp // = 0 + case noneProtobufSfixed64 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTimestamp + self = .noneProtobufSfixed64 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTimestamp + case 0: self = .noneProtobufSfixed64 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTimestamp: return 0 + case .noneProtobufSfixed64: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSFixed64] = [ + .noneProtobufSfixed64, + ] + } - enum total: SwiftProtobuf.Enum { + enum ProtobufSInt32: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTotal // = 0 + case noneProtobufSint32 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTotal + self = .noneProtobufSint32 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTotal + case 0: self = .noneProtobufSint32 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTotal: return 0 + case .noneProtobufSint32: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSInt32] = [ + .noneProtobufSint32, + ] + } - enum totalArrayDepth: SwiftProtobuf.Enum { + enum ProtobufSInt64: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTotalArrayDepth // = 0 + case noneProtobufSint64 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTotalArrayDepth + self = .noneProtobufSint64 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTotalArrayDepth + case 0: self = .noneProtobufSint64 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTotalArrayDepth: return 0 + case .noneProtobufSint64: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSInt64] = [ + .noneProtobufSint64, + ] + } - enum totalSize: SwiftProtobuf.Enum { + enum ProtobufString: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTotalSize // = 0 + case noneProtobufString // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTotalSize + self = .noneProtobufString } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTotalSize + case 0: self = .noneProtobufString default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTotalSize: return 0 + case .noneProtobufString: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufString] = [ + .noneProtobufString, + ] + } - enum trailingComments: SwiftProtobuf.Enum { + enum ProtobufUInt32: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTrailingComments // = 0 + case noneProtobufUint32 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTrailingComments + self = .noneProtobufUint32 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTrailingComments + case 0: self = .noneProtobufUint32 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTrailingComments: return 0 + case .noneProtobufUint32: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufUInt32] = [ + .noneProtobufUint32, + ] + } - enum traverseEnum: SwiftProtobuf.Enum { + enum ProtobufUInt64: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTraverse // = 0 + case noneProtobufUint64 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTraverse + self = .noneProtobufUint64 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTraverse + case 0: self = .noneProtobufUint64 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTraverse: return 0 + case .noneProtobufUint64: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufUInt64] = [ + .noneProtobufUint64, + ] + } - enum trueEnum: SwiftProtobuf.Enum { + enum protocolEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTrue // = 0 + case noneProtocol // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTrue + self = .noneProtocol } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTrue + case 0: self = .noneProtocol default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTrue: return 0 + case .noneProtocol: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protocolEnum] = [ + .noneProtocol, + ] + } - enum tryEnum: SwiftProtobuf.Enum { + enum protoFieldName: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTry // = 0 + case noneProtoFieldName // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTry + self = .noneProtoFieldName } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTry + case 0: self = .noneProtoFieldName default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTry: return 0 + case .noneProtoFieldName: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoFieldName] = [ + .noneProtoFieldName, + ] + } - enum type: SwiftProtobuf.Enum { + enum protoMessageNameEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneType // = 0 + case noneProtoMessageName // = 0 case UNRECOGNIZED(Int) init() { - self = .noneType + self = .noneProtoMessageName } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneType + case 0: self = .noneProtoMessageName default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneType: return 0 + case .noneProtoMessageName: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoMessageNameEnum] = [ + .noneProtoMessageName, + ] + } - enum typealiasEnum: SwiftProtobuf.Enum { + enum ProtoNameProviding: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTypealias // = 0 + case noneProtoNameProviding // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTypealias + self = .noneProtoNameProviding } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTypealias + case 0: self = .noneProtoNameProviding default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTypealias: return 0 + case .noneProtoNameProviding: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtoNameProviding] = [ + .noneProtoNameProviding, + ] + } - enum TypeEnumEnum: SwiftProtobuf.Enum { + enum protoPaths: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTypeEnum // = 0 + case noneProtoPaths // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTypeEnum + self = .noneProtoPaths } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTypeEnum + case 0: self = .noneProtoPaths default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTypeEnum: return 0 + case .noneProtoPaths: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoPaths] = [ + .noneProtoPaths, + ] + } - enum typeName: SwiftProtobuf.Enum { + enum publicEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTypeName // = 0 + case nonePublic // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTypeName + self = .nonePublic } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTypeName + case 0: self = .nonePublic default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTypeName: return 0 + case .nonePublic: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.publicEnum] = [ + .nonePublic, + ] + } - enum typePrefix: SwiftProtobuf.Enum { + enum publicDependency: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTypePrefix // = 0 + case nonePublicDependency // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTypePrefix + self = .nonePublicDependency } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTypePrefix + case 0: self = .nonePublicDependency default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTypePrefix: return 0 + case .nonePublicDependency: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.publicDependency] = [ + .nonePublicDependency, + ] + } - enum typeStart: SwiftProtobuf.Enum { + enum putBoolValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTypeStart // = 0 + case nonePutBoolValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTypeStart + self = .nonePutBoolValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTypeStart + case 0: self = .nonePutBoolValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTypeStart: return 0 + case .nonePutBoolValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putBoolValue] = [ + .nonePutBoolValue, + ] + } - enum typeUnknown: SwiftProtobuf.Enum { + enum putBytesValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTypeUnknown // = 0 + case nonePutBytesValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTypeUnknown + self = .nonePutBytesValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTypeUnknown + case 0: self = .nonePutBytesValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTypeUnknown: return 0 + case .nonePutBytesValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putBytesValue] = [ + .nonePutBytesValue, + ] + } - enum typeURL: SwiftProtobuf.Enum { + enum putDoubleValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneTypeURL // = 0 + case nonePutDoubleValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneTypeURL + self = .nonePutDoubleValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneTypeURL + case 0: self = .nonePutDoubleValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneTypeURL: return 0 + case .nonePutDoubleValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putDoubleValue] = [ + .nonePutDoubleValue, + ] + } - enum UInt32Enum: SwiftProtobuf.Enum { + enum putEnumValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUint32 // = 0 + case nonePutEnumValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUint32 + self = .nonePutEnumValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUint32 + case 0: self = .nonePutEnumValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUint32: return 0 + case .nonePutEnumValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putEnumValue] = [ + .nonePutEnumValue, + ] + } - enum UInt32Value: SwiftProtobuf.Enum { + enum putFixedUInt32: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUint32Value // = 0 + case nonePutFixedUint32 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUint32Value + self = .nonePutFixedUint32 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUint32Value + case 0: self = .nonePutFixedUint32 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUint32Value: return 0 + case .nonePutFixedUint32: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFixedUInt32] = [ + .nonePutFixedUint32, + ] + } - enum UInt64Enum: SwiftProtobuf.Enum { + enum putFixedUInt64: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUint64 // = 0 + case nonePutFixedUint64 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUint64 + self = .nonePutFixedUint64 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUint64 + case 0: self = .nonePutFixedUint64 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUint64: return 0 + case .nonePutFixedUint64: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFixedUInt64] = [ + .nonePutFixedUint64, + ] + } - enum UInt64Value: SwiftProtobuf.Enum { + enum putFloatValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUint64Value // = 0 + case nonePutFloatValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUint64Value + self = .nonePutFloatValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUint64Value + case 0: self = .nonePutFloatValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUint64Value: return 0 + case .nonePutFloatValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFloatValue] = [ + .nonePutFloatValue, + ] + } - enum UInt8: SwiftProtobuf.Enum { + enum putInt64: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUint8 // = 0 + case nonePutInt64 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUint8 + self = .nonePutInt64 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUint8 + case 0: self = .nonePutInt64 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUint8: return 0 + case .nonePutInt64: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putInt64] = [ + .nonePutInt64, + ] + } - enum unicodeScalarLiteral: SwiftProtobuf.Enum { + enum putStringValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUnicodeScalarLiteral // = 0 + case nonePutStringValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUnicodeScalarLiteral + self = .nonePutStringValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUnicodeScalarLiteral + case 0: self = .nonePutStringValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUnicodeScalarLiteral: return 0 + case .nonePutStringValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putStringValue] = [ + .nonePutStringValue, + ] + } - enum UnicodeScalarLiteralType: SwiftProtobuf.Enum { + enum putUInt64: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUnicodeScalarLiteralType // = 0 + case nonePutUint64 // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUnicodeScalarLiteralType + self = .nonePutUint64 } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUnicodeScalarLiteralType + case 0: self = .nonePutUint64 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUnicodeScalarLiteralType: return 0 + case .nonePutUint64: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putUInt64] = [ + .nonePutUint64, + ] + } - enum unicodeScalars: SwiftProtobuf.Enum { + enum putUInt64Hex: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUnicodeScalars // = 0 + case nonePutUint64Hex // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUnicodeScalars + self = .nonePutUint64Hex } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUnicodeScalars + case 0: self = .nonePutUint64Hex default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUnicodeScalars: return 0 + case .nonePutUint64Hex: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putUInt64Hex] = [ + .nonePutUint64Hex, + ] + } - enum UnicodeScalarView: SwiftProtobuf.Enum { + enum putVarInt: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUnicodeScalarView // = 0 + case nonePutVarInt // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUnicodeScalarView + self = .nonePutVarInt } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUnicodeScalarView + case 0: self = .nonePutVarInt default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUnicodeScalarView: return 0 + case .nonePutVarInt: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putVarInt] = [ + .nonePutVarInt, + ] + } - enum uninterpretedOption: SwiftProtobuf.Enum { + enum putZigZagVarInt: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUninterpretedOption // = 0 + case nonePutZigZagVarInt // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUninterpretedOption + self = .nonePutZigZagVarInt } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUninterpretedOption + case 0: self = .nonePutZigZagVarInt default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUninterpretedOption: return 0 + case .nonePutZigZagVarInt: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putZigZagVarInt] = [ + .nonePutZigZagVarInt, + ] + } - enum union: SwiftProtobuf.Enum { + enum pyGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUnion // = 0 + case nonePyGenericServices // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUnion + self = .nonePyGenericServices } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUnion + case 0: self = .nonePyGenericServices default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUnion: return 0 + case .nonePyGenericServices: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.pyGenericServices] = [ + .nonePyGenericServices, + ] + } - enum uniqueStorage: SwiftProtobuf.Enum { + enum R: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUniqueStorage // = 0 + case noneR // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUniqueStorage + self = .noneR } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUniqueStorage + case 0: self = .noneR default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUniqueStorage: return 0 + case .noneR: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.R] = [ + .noneR, + ] + } - enum unknown: SwiftProtobuf.Enum { + enum rawChars: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUnknown // = 0 + case noneRawChars // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUnknown + self = .noneRawChars } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUnknown + case 0: self = .noneRawChars default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUnknown: return 0 + case .noneRawChars: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rawChars] = [ + .noneRawChars, + ] + } - enum unknownFieldsEnum: SwiftProtobuf.Enum { + enum RawRepresentable: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUnknownFields // = 0 + case noneRawRepresentable // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUnknownFields + self = .noneRawRepresentable } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUnknownFields + case 0: self = .noneRawRepresentable default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUnknownFields: return 0 + case .noneRawRepresentable: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RawRepresentable] = [ + .noneRawRepresentable, + ] + } - enum UnknownStorage: SwiftProtobuf.Enum { + enum RawValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUnknownStorage // = 0 + case noneRawValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUnknownStorage + self = .noneRawValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUnknownStorage + case 0: self = .noneRawValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUnknownStorage: return 0 + case .noneRawValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RawValue] = [ + .noneRawValue, + ] + } - enum unpackTo: SwiftProtobuf.Enum { + enum read4HexDigits: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUnpackTo // = 0 + case noneRead4HexDigits // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUnpackTo + self = .noneRead4HexDigits } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUnpackTo + case 0: self = .noneRead4HexDigits default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUnpackTo: return 0 + case .noneRead4HexDigits: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.read4HexDigits] = [ + .noneRead4HexDigits, + ] + } - enum UnsafeBufferPointer: SwiftProtobuf.Enum { + enum readBytes: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUnsafeBufferPointer // = 0 + case noneReadBytes // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUnsafeBufferPointer + self = .noneReadBytes } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUnsafeBufferPointer + case 0: self = .noneReadBytes default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUnsafeBufferPointer: return 0 + case .noneReadBytes: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.readBytes] = [ + .noneReadBytes, + ] + } - enum UnsafeMutablePointer: SwiftProtobuf.Enum { + enum reader: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUnsafeMutablePointer // = 0 + case noneReader // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUnsafeMutablePointer + self = .noneReader } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUnsafeMutablePointer + case 0: self = .noneReader default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUnsafeMutablePointer: return 0 + case .noneReader: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.reader] = [ + .noneReader, + ] + } - enum UnsafeMutableRawBufferPointer: SwiftProtobuf.Enum { + enum register: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUnsafeMutableRawBufferPointer // = 0 + case noneRegister // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUnsafeMutableRawBufferPointer + self = .noneRegister } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUnsafeMutableRawBufferPointer + case 0: self = .noneRegister default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUnsafeMutableRawBufferPointer: return 0 + case .noneRegister: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.register] = [ + .noneRegister, + ] + } - enum UnsafeMutableRawPointer: SwiftProtobuf.Enum { + enum remainingProgram: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUnsafeMutableRawPointer // = 0 + case noneRemainingProgram // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUnsafeMutableRawPointer + self = .noneRemainingProgram } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUnsafeMutableRawPointer + case 0: self = .noneRemainingProgram default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUnsafeMutableRawPointer: return 0 + case .noneRemainingProgram: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.remainingProgram] = [ + .noneRemainingProgram, + ] + } - enum UnsafeRawBufferPointer: SwiftProtobuf.Enum { + enum removalError: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUnsafeRawBufferPointer // = 0 + case noneRemovalError // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUnsafeRawBufferPointer + self = .noneRemovalError } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUnsafeRawBufferPointer + case 0: self = .noneRemovalError default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUnsafeRawBufferPointer: return 0 + case .noneRemovalError: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.removalError] = [ + .noneRemovalError, + ] + } - enum UnsafeRawPointer: SwiftProtobuf.Enum { + enum removingAllFieldsOf: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUnsafeRawPointer // = 0 + case noneRemovingAllFieldsOf // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUnsafeRawPointer + self = .noneRemovingAllFieldsOf } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUnsafeRawPointer + case 0: self = .noneRemovingAllFieldsOf default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUnsafeRawPointer: return 0 + case .noneRemovingAllFieldsOf: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.removingAllFieldsOf] = [ + .noneRemovingAllFieldsOf, + ] + } - enum updatedOptions: SwiftProtobuf.Enum { + enum repeated: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUpdatedOptions // = 0 + case noneRepeated // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUpdatedOptions + self = .noneRepeated } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUpdatedOptions + case 0: self = .noneRepeated default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUpdatedOptions: return 0 + case .noneRepeated: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeated] = [ + .noneRepeated, + ] + } - enum url: SwiftProtobuf.Enum { + enum RepeatedEnumExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneURL // = 0 + case noneRepeatedEnumExtensionField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneURL + self = .noneRepeatedEnumExtensionField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneURL + case 0: self = .noneRepeatedEnumExtensionField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneURL: return 0 + case .noneRepeatedEnumExtensionField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField] = [ + .noneRepeatedEnumExtensionField, + ] + } - enum utf8: SwiftProtobuf.Enum { + enum RepeatedExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUtf8 // = 0 + case noneRepeatedExtensionField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUtf8 + self = .noneRepeatedExtensionField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUtf8 + case 0: self = .noneRepeatedExtensionField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUtf8: return 0 + case .noneRepeatedExtensionField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedExtensionField] = [ + .noneRepeatedExtensionField, + ] + } - enum utf8Ptr: SwiftProtobuf.Enum { + enum repeatedFieldEncoding: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUtf8Ptr // = 0 + case noneRepeatedFieldEncoding // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUtf8Ptr + self = .noneRepeatedFieldEncoding } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUtf8Ptr + case 0: self = .noneRepeatedFieldEncoding default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUtf8Ptr: return 0 + case .noneRepeatedFieldEncoding: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedFieldEncoding] = [ + .noneRepeatedFieldEncoding, + ] + } - enum utf8ToDouble: SwiftProtobuf.Enum { + enum RepeatedGroupExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUtf8ToDouble // = 0 + case noneRepeatedGroupExtensionField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUtf8ToDouble + self = .noneRepeatedGroupExtensionField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUtf8ToDouble + case 0: self = .noneRepeatedGroupExtensionField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUtf8ToDouble: return 0 + case .noneRepeatedGroupExtensionField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField] = [ + .noneRepeatedGroupExtensionField, + ] + } - enum UTF8View: SwiftProtobuf.Enum { + enum RepeatedMessageExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneUtf8View // = 0 + case noneRepeatedMessageExtensionField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneUtf8View + self = .noneRepeatedMessageExtensionField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneUtf8View + case 0: self = .noneRepeatedMessageExtensionField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneUtf8View: return 0 + case .noneRepeatedMessageExtensionField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField] = [ + .noneRepeatedMessageExtensionField, + ] + } - enum v: SwiftProtobuf.Enum { + enum repeating: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneV // = 0 + case noneRepeating // = 0 case UNRECOGNIZED(Int) init() { - self = .noneV + self = .noneRepeating } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneV + case 0: self = .noneRepeating default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneV: return 0 + case .noneRepeating: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeating] = [ + .noneRepeating, + ] + } - enum value: SwiftProtobuf.Enum { + enum replaceRepeatedFields: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneValue // = 0 + case noneReplaceRepeatedFields // = 0 case UNRECOGNIZED(Int) init() { - self = .noneValue + self = .noneReplaceRepeatedFields } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneValue + case 0: self = .noneReplaceRepeatedFields default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneValue: return 0 + case .noneReplaceRepeatedFields: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.replaceRepeatedFields] = [ + .noneReplaceRepeatedFields, + ] + } - enum valueField: SwiftProtobuf.Enum { + enum requestStreaming: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneValueField // = 0 + case noneRequestStreaming // = 0 case UNRECOGNIZED(Int) init() { - self = .noneValueField + self = .noneRequestStreaming } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneValueField + case 0: self = .noneRequestStreaming default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneValueField: return 0 + case .noneRequestStreaming: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requestStreaming] = [ + .noneRequestStreaming, + ] + } - enum values: SwiftProtobuf.Enum { + enum requestTypeURL: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneValues // = 0 + case noneRequestTypeURL // = 0 case UNRECOGNIZED(Int) init() { - self = .noneValues + self = .noneRequestTypeURL } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneValues + case 0: self = .noneRequestTypeURL default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneValues: return 0 + case .noneRequestTypeURL: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requestTypeURL] = [ + .noneRequestTypeURL, + ] + } - enum ValueType: SwiftProtobuf.Enum { + enum requiredSize: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneValueType // = 0 + case noneRequiredSize // = 0 case UNRECOGNIZED(Int) init() { - self = .noneValueType + self = .noneRequiredSize } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneValueType + case 0: self = .noneRequiredSize default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneValueType: return 0 + case .noneRequiredSize: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requiredSize] = [ + .noneRequiredSize, + ] + } - enum varEnum: SwiftProtobuf.Enum { + enum responseStreaming: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVar // = 0 + case noneResponseStreaming // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVar + self = .noneResponseStreaming } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVar + case 0: self = .noneResponseStreaming default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVar: return 0 + case .noneResponseStreaming: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.responseStreaming] = [ + .noneResponseStreaming, + ] + } - enum Version: SwiftProtobuf.Enum { + enum responseTypeURL: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVersion // = 0 + case noneResponseTypeURL // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVersion + self = .noneResponseTypeURL } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVersion + case 0: self = .noneResponseTypeURL default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVersion: return 0 + case .noneResponseTypeURL: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.responseTypeURL] = [ + .noneResponseTypeURL, + ] + } - enum versionString: SwiftProtobuf.Enum { + enum result: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVersionString // = 0 + case noneResult // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVersionString + self = .noneResult } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVersionString + case 0: self = .noneResult default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVersionString: return 0 + case .noneResult: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.result] = [ + .noneResult, + ] + } - enum visitExtensionFields: SwiftProtobuf.Enum { + enum retention: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitExtensionFields // = 0 + case noneRetention // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitExtensionFields + self = .noneRetention } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitExtensionFields + case 0: self = .noneRetention default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitExtensionFields: return 0 + case .noneRetention: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.retention] = [ + .noneRetention, + ] + } - enum visitExtensionFieldsAsMessageSet: SwiftProtobuf.Enum { + enum rethrowsEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitExtensionFieldsAsMessageSet // = 0 + case noneRethrows // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitExtensionFieldsAsMessageSet + self = .noneRethrows } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitExtensionFieldsAsMessageSet + case 0: self = .noneRethrows default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitExtensionFieldsAsMessageSet: return 0 + case .noneRethrows: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rethrowsEnum] = [ + .noneRethrows, + ] + } - enum visitMapField: SwiftProtobuf.Enum { + enum ReturnType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitMapField // = 0 + case noneReturnType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitMapField + self = .noneReturnType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitMapField + case 0: self = .noneReturnType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitMapField: return 0 + case .noneReturnType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ReturnType] = [ + .noneReturnType, + ] + } - enum visitor: SwiftProtobuf.Enum { + enum revision: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitor // = 0 + case noneRevision // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitor + self = .noneRevision } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitor + case 0: self = .noneRevision default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitor: return 0 + case .noneRevision: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.revision] = [ + .noneRevision, + ] + } - enum visitPacked: SwiftProtobuf.Enum { + enum rhs: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitPacked // = 0 + case noneRhs // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitPacked + self = .noneRhs } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitPacked + case 0: self = .noneRhs default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitPacked: return 0 + case .noneRhs: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rhs] = [ + .noneRhs, + ] + } - enum visitPackedBoolField: SwiftProtobuf.Enum { + enum root: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitPackedBoolField // = 0 + case noneRoot // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitPackedBoolField + self = .noneRoot } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitPackedBoolField + case 0: self = .noneRoot default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitPackedBoolField: return 0 + case .noneRoot: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.root] = [ + .noneRoot, + ] + } - enum visitPackedDoubleField: SwiftProtobuf.Enum { + enum rubyPackage: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitPackedDoubleField // = 0 + case noneRubyPackage // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitPackedDoubleField + self = .noneRubyPackage } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitPackedDoubleField + case 0: self = .noneRubyPackage default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitPackedDoubleField: return 0 + case .noneRubyPackage: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rubyPackage] = [ + .noneRubyPackage, + ] + } - enum visitPackedEnumField: SwiftProtobuf.Enum { + enum s: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitPackedEnumField // = 0 + case noneS // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitPackedEnumField + self = .noneS } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitPackedEnumField + case 0: self = .noneS default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitPackedEnumField: return 0 + case .noneS: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.s] = [ + .noneS, + ] + } - enum visitPackedFixed32Field: SwiftProtobuf.Enum { + enum sawBackslash: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitPackedFixed32Field // = 0 + case noneSawBackslash // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitPackedFixed32Field + self = .noneSawBackslash } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitPackedFixed32Field + case 0: self = .noneSawBackslash default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitPackedFixed32Field: return 0 + case .noneSawBackslash: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawBackslash] = [ + .noneSawBackslash, + ] + } - enum visitPackedFixed64Field: SwiftProtobuf.Enum { + enum sawSection4Characters: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitPackedFixed64Field // = 0 + case noneSawSection4Characters // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitPackedFixed64Field + self = .noneSawSection4Characters } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitPackedFixed64Field + case 0: self = .noneSawSection4Characters default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitPackedFixed64Field: return 0 + case .noneSawSection4Characters: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawSection4Characters] = [ + .noneSawSection4Characters, + ] + } - enum visitPackedFloatField: SwiftProtobuf.Enum { + enum sawSection5Characters: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitPackedFloatField // = 0 + case noneSawSection5Characters // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitPackedFloatField + self = .noneSawSection5Characters } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitPackedFloatField + case 0: self = .noneSawSection5Characters default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitPackedFloatField: return 0 + case .noneSawSection5Characters: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawSection5Characters] = [ + .noneSawSection5Characters, + ] + } - enum visitPackedInt32Field: SwiftProtobuf.Enum { + enum Scalar: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitPackedInt32Field // = 0 + case noneScalar // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitPackedInt32Field + self = .noneScalar } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitPackedInt32Field + case 0: self = .noneScalar default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitPackedInt32Field: return 0 + case .noneScalar: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Scalar] = [ + .noneScalar, + ] + } - enum visitPackedInt64Field: SwiftProtobuf.Enum { + enum scan: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitPackedInt64Field // = 0 + case noneScan // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitPackedInt64Field + self = .noneScan } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitPackedInt64Field + case 0: self = .noneScan default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitPackedInt64Field: return 0 + case .noneScan: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.scan] = [ + .noneScan, + ] + } - enum visitPackedSFixed32Field: SwiftProtobuf.Enum { + enum scanner: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitPackedSfixed32Field // = 0 + case noneScanner // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitPackedSfixed32Field + self = .noneScanner } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitPackedSfixed32Field + case 0: self = .noneScanner default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitPackedSfixed32Field: return 0 + case .noneScanner: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.scanner] = [ + .noneScanner, + ] + } - enum visitPackedSFixed64Field: SwiftProtobuf.Enum { + enum seconds: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitPackedSfixed64Field // = 0 + case noneSeconds // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitPackedSfixed64Field + self = .noneSeconds } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitPackedSfixed64Field + case 0: self = .noneSeconds default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitPackedSfixed64Field: return 0 + case .noneSeconds: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.seconds] = [ + .noneSeconds, + ] + } - enum visitPackedSInt32Field: SwiftProtobuf.Enum { + enum selfEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitPackedSint32Field // = 0 + case noneSelf // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitPackedSint32Field + self = .noneSelf } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitPackedSint32Field + case 0: self = .noneSelf default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitPackedSint32Field: return 0 + case .noneSelf: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.selfEnum] = [ + .noneSelf, + ] + } - enum visitPackedSInt64Field: SwiftProtobuf.Enum { + enum semantic: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitPackedSint64Field // = 0 + case noneSemantic // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitPackedSint64Field + self = .noneSemantic } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitPackedSint64Field + case 0: self = .noneSemantic default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitPackedSint64Field: return 0 + case .noneSemantic: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.semantic] = [ + .noneSemantic, + ] + } - enum visitPackedUInt32Field: SwiftProtobuf.Enum { + enum SendableEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitPackedUint32Field // = 0 + case noneSendable // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitPackedUint32Field + self = .noneSendable } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitPackedUint32Field + case 0: self = .noneSendable default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitPackedUint32Field: return 0 + case .noneSendable: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SendableEnum] = [ + .noneSendable, + ] + } - enum visitPackedUInt64Field: SwiftProtobuf.Enum { + enum separator: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitPackedUint64Field // = 0 + case noneSeparator // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitPackedUint64Field + self = .noneSeparator } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitPackedUint64Field + case 0: self = .noneSeparator default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitPackedUint64Field: return 0 + case .noneSeparator: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.separator] = [ + .noneSeparator, + ] + } - enum visitRepeated: SwiftProtobuf.Enum { + enum serialize: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeated // = 0 + case noneSerialize // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeated + self = .noneSerialize } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeated + case 0: self = .noneSerialize default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeated: return 0 + case .noneSerialize: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serialize] = [ + .noneSerialize, + ] + } - enum visitRepeatedBoolField: SwiftProtobuf.Enum { + enum serializedBytes: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeatedBoolField // = 0 + case noneSerializedBytes // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeatedBoolField + self = .noneSerializedBytes } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeatedBoolField + case 0: self = .noneSerializedBytes default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeatedBoolField: return 0 + case .noneSerializedBytes: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedBytes] = [ + .noneSerializedBytes, + ] + } - enum visitRepeatedBytesField: SwiftProtobuf.Enum { + enum serializedData: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeatedBytesField // = 0 + case noneSerializedData // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeatedBytesField + self = .noneSerializedData } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeatedBytesField + case 0: self = .noneSerializedData default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeatedBytesField: return 0 + case .noneSerializedData: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedData] = [ + .noneSerializedData, + ] + } - enum visitRepeatedDoubleField: SwiftProtobuf.Enum { + enum serializedSize: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeatedDoubleField // = 0 + case noneSerializedSize // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeatedDoubleField + self = .noneSerializedSize } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeatedDoubleField + case 0: self = .noneSerializedSize default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeatedDoubleField: return 0 + case .noneSerializedSize: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedSize] = [ + .noneSerializedSize, + ] + } - enum visitRepeatedEnumField: SwiftProtobuf.Enum { + enum serverStreaming: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeatedEnumField // = 0 + case noneServerStreaming // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeatedEnumField + self = .noneServerStreaming } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeatedEnumField + case 0: self = .noneServerStreaming default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeatedEnumField: return 0 + case .noneServerStreaming: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serverStreaming] = [ + .noneServerStreaming, + ] + } - enum visitRepeatedFixed32Field: SwiftProtobuf.Enum { + enum service: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeatedFixed32Field // = 0 + case noneService // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeatedFixed32Field + self = .noneService } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeatedFixed32Field + case 0: self = .noneService default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeatedFixed32Field: return 0 + case .noneService: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.service] = [ + .noneService, + ] + } - enum visitRepeatedFixed64Field: SwiftProtobuf.Enum { + enum set: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeatedFixed64Field // = 0 + case noneSet // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeatedFixed64Field + self = .noneSet } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeatedFixed64Field + case 0: self = .noneSet default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeatedFixed64Field: return 0 + case .noneSet: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.set] = [ + .noneSet, + ] + } - enum visitRepeatedFloatField: SwiftProtobuf.Enum { + enum setExtensionValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeatedFloatField // = 0 + case noneSetExtensionValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeatedFloatField + self = .noneSetExtensionValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeatedFloatField + case 0: self = .noneSetExtensionValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeatedFloatField: return 0 + case .noneSetExtensionValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.setExtensionValue] = [ + .noneSetExtensionValue, + ] + } - enum visitRepeatedGroupField: SwiftProtobuf.Enum { + enum shift: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeatedGroupField // = 0 + case noneShift // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeatedGroupField + self = .noneShift } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeatedGroupField + case 0: self = .noneShift default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeatedGroupField: return 0 + case .noneShift: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.shift] = [ + .noneShift, + ] + } - enum visitRepeatedInt32Field: SwiftProtobuf.Enum { + enum SimpleExtensionMap: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeatedInt32Field // = 0 + case noneSimpleExtensionMap // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeatedInt32Field + self = .noneSimpleExtensionMap } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeatedInt32Field + case 0: self = .noneSimpleExtensionMap default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeatedInt32Field: return 0 + case .noneSimpleExtensionMap: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SimpleExtensionMap] = [ + .noneSimpleExtensionMap, + ] + } - enum visitRepeatedInt64Field: SwiftProtobuf.Enum { + enum size: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeatedInt64Field // = 0 + case noneSize // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeatedInt64Field + self = .noneSize } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeatedInt64Field + case 0: self = .noneSize default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeatedInt64Field: return 0 + case .noneSize: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.size] = [ + .noneSize, + ] + } - enum visitRepeatedMessageField: SwiftProtobuf.Enum { + enum sizer: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeatedMessageField // = 0 + case noneSizer // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeatedMessageField + self = .noneSizer } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeatedMessageField + case 0: self = .noneSizer default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeatedMessageField: return 0 + case .noneSizer: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sizer] = [ + .noneSizer, + ] + } - enum visitRepeatedSFixed32Field: SwiftProtobuf.Enum { + enum source: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeatedSfixed32Field // = 0 + case noneSource // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeatedSfixed32Field + self = .noneSource } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeatedSfixed32Field + case 0: self = .noneSource default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeatedSfixed32Field: return 0 + case .noneSource: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.source] = [ + .noneSource, + ] + } - enum visitRepeatedSFixed64Field: SwiftProtobuf.Enum { + enum sourceCodeInfo: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeatedSfixed64Field // = 0 + case noneSourceCodeInfo // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeatedSfixed64Field + self = .noneSourceCodeInfo } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeatedSfixed64Field + case 0: self = .noneSourceCodeInfo default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeatedSfixed64Field: return 0 + case .noneSourceCodeInfo: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceCodeInfo] = [ + .noneSourceCodeInfo, + ] + } - enum visitRepeatedSInt32Field: SwiftProtobuf.Enum { + enum sourceContext: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeatedSint32Field // = 0 + case noneSourceContext // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeatedSint32Field + self = .noneSourceContext } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeatedSint32Field + case 0: self = .noneSourceContext default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeatedSint32Field: return 0 + case .noneSourceContext: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceContext] = [ + .noneSourceContext, + ] + } - enum visitRepeatedSInt64Field: SwiftProtobuf.Enum { + enum sourceEncoding: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeatedSint64Field // = 0 + case noneSourceEncoding // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeatedSint64Field + self = .noneSourceEncoding } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeatedSint64Field + case 0: self = .noneSourceEncoding default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeatedSint64Field: return 0 + case .noneSourceEncoding: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceEncoding] = [ + .noneSourceEncoding, + ] + } - enum visitRepeatedStringField: SwiftProtobuf.Enum { + enum sourceFile: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeatedStringField // = 0 + case noneSourceFile // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeatedStringField + self = .noneSourceFile } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeatedStringField + case 0: self = .noneSourceFile default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeatedStringField: return 0 + case .noneSourceFile: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceFile] = [ + .noneSourceFile, + ] + } - enum visitRepeatedUInt32Field: SwiftProtobuf.Enum { + enum SourceLocation: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeatedUint32Field // = 0 + case noneSourceLocation // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeatedUint32Field + self = .noneSourceLocation } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeatedUint32Field + case 0: self = .noneSourceLocation default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeatedUint32Field: return 0 + case .noneSourceLocation: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SourceLocation] = [ + .noneSourceLocation, + ] + } - enum visitRepeatedUInt64Field: SwiftProtobuf.Enum { + enum span: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitRepeatedUint64Field // = 0 + case noneSpan // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitRepeatedUint64Field + self = .noneSpan } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitRepeatedUint64Field + case 0: self = .noneSpan default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitRepeatedUint64Field: return 0 + case .noneSpan: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.span] = [ + .noneSpan, + ] + } - enum visitSingular: SwiftProtobuf.Enum { + enum split: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingular // = 0 + case noneSplit // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingular + self = .noneSplit } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingular + case 0: self = .noneSplit default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingular: return 0 + case .noneSplit: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.split] = [ + .noneSplit, + ] + } - enum visitSingularBoolField: SwiftProtobuf.Enum { + enum start: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingularBoolField // = 0 + case noneStart // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingularBoolField + self = .noneStart } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingularBoolField + case 0: self = .noneStart default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingularBoolField: return 0 + case .noneStart: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.start] = [ + .noneStart, + ] + } - enum visitSingularBytesField: SwiftProtobuf.Enum { + enum startArray: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingularBytesField // = 0 + case noneStartArray // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingularBytesField + self = .noneStartArray } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingularBytesField + case 0: self = .noneStartArray default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingularBytesField: return 0 + case .noneStartArray: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startArray] = [ + .noneStartArray, + ] + } - enum visitSingularDoubleField: SwiftProtobuf.Enum { + enum startArrayObject: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingularDoubleField // = 0 + case noneStartArrayObject // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingularDoubleField + self = .noneStartArrayObject } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingularDoubleField + case 0: self = .noneStartArrayObject default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingularDoubleField: return 0 + case .noneStartArrayObject: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startArrayObject] = [ + .noneStartArrayObject, + ] + } - enum visitSingularEnumField: SwiftProtobuf.Enum { + enum startField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingularEnumField // = 0 + case noneStartField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingularEnumField + self = .noneStartField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingularEnumField + case 0: self = .noneStartField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingularEnumField: return 0 + case .noneStartField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startField] = [ + .noneStartField, + ] + } - enum visitSingularFixed32Field: SwiftProtobuf.Enum { + enum startIndex: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingularFixed32Field // = 0 + case noneStartIndex // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingularFixed32Field + self = .noneStartIndex } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingularFixed32Field + case 0: self = .noneStartIndex default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingularFixed32Field: return 0 + case .noneStartIndex: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startIndex] = [ + .noneStartIndex, + ] + } - enum visitSingularFixed64Field: SwiftProtobuf.Enum { + enum startMessageField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingularFixed64Field // = 0 + case noneStartMessageField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingularFixed64Field + self = .noneStartMessageField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingularFixed64Field + case 0: self = .noneStartMessageField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingularFixed64Field: return 0 + case .noneStartMessageField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startMessageField] = [ + .noneStartMessageField, + ] + } - enum visitSingularFloatField: SwiftProtobuf.Enum { + enum startObject: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingularFloatField // = 0 + case noneStartObject // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingularFloatField + self = .noneStartObject } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingularFloatField + case 0: self = .noneStartObject default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingularFloatField: return 0 + case .noneStartObject: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startObject] = [ + .noneStartObject, + ] + } - enum visitSingularGroupField: SwiftProtobuf.Enum { + enum startRegularField: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingularGroupField // = 0 + case noneStartRegularField // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingularGroupField + self = .noneStartRegularField } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingularGroupField + case 0: self = .noneStartRegularField default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingularGroupField: return 0 + case .noneStartRegularField: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startRegularField] = [ + .noneStartRegularField, + ] + } - enum visitSingularInt32Field: SwiftProtobuf.Enum { + enum state: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingularInt32Field // = 0 + case noneState // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingularInt32Field + self = .noneState } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingularInt32Field + case 0: self = .noneState default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingularInt32Field: return 0 + case .noneState: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.state] = [ + .noneState, + ] + } - enum visitSingularInt64Field: SwiftProtobuf.Enum { + enum staticEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingularInt64Field // = 0 + case noneStatic // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingularInt64Field + self = .noneStatic } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingularInt64Field + case 0: self = .noneStatic default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingularInt64Field: return 0 + case .noneStatic: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.staticEnum] = [ + .noneStatic, + ] + } - enum visitSingularMessageField: SwiftProtobuf.Enum { + enum StaticString: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingularMessageField // = 0 + case noneStaticString // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingularMessageField + self = .noneStaticString } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingularMessageField + case 0: self = .noneStaticString default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingularMessageField: return 0 + case .noneStaticString: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.StaticString] = [ + .noneStaticString, + ] + } - enum visitSingularSFixed32Field: SwiftProtobuf.Enum { + enum storage: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingularSfixed32Field // = 0 + case noneStorage // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingularSfixed32Field + self = .noneStorage } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingularSfixed32Field + case 0: self = .noneStorage default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingularSfixed32Field: return 0 + case .noneStorage: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.storage] = [ + .noneStorage, + ] + } - enum visitSingularSFixed64Field: SwiftProtobuf.Enum { + enum StringEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingularSfixed64Field // = 0 + case noneString // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingularSfixed64Field + self = .noneString } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingularSfixed64Field + case 0: self = .noneString default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingularSfixed64Field: return 0 + case .noneString: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.StringEnum] = [ + .noneString, + ] + } - enum visitSingularSInt32Field: SwiftProtobuf.Enum { + enum stringLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingularSint32Field // = 0 + case noneStringLiteral // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingularSint32Field + self = .noneStringLiteral } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingularSint32Field + case 0: self = .noneStringLiteral default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingularSint32Field: return 0 + case .noneStringLiteral: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.stringLiteral] = [ + .noneStringLiteral, + ] + } - enum visitSingularSInt64Field: SwiftProtobuf.Enum { + enum StringLiteralType: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingularSint64Field // = 0 + case noneStringLiteralType // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingularSint64Field + self = .noneStringLiteralType } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingularSint64Field + case 0: self = .noneStringLiteralType default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingularSint64Field: return 0 + case .noneStringLiteralType: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.StringLiteralType] = [ + .noneStringLiteralType, + ] + } - enum visitSingularStringField: SwiftProtobuf.Enum { + enum stringResult: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingularStringField // = 0 + case noneStringResult // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingularStringField + self = .noneStringResult } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingularStringField + case 0: self = .noneStringResult default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingularStringField: return 0 + case .noneStringResult: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.stringResult] = [ + .noneStringResult, + ] + } - enum visitSingularUInt32Field: SwiftProtobuf.Enum { + enum stringValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingularUint32Field // = 0 + case noneStringValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingularUint32Field + self = .noneStringValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingularUint32Field + case 0: self = .noneStringValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingularUint32Field: return 0 + case .noneStringValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.stringValue] = [ + .noneStringValue, + ] + } - enum visitSingularUInt64Field: SwiftProtobuf.Enum { + enum structEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitSingularUint64Field // = 0 + case noneStruct // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitSingularUint64Field + self = .noneStruct } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitSingularUint64Field + case 0: self = .noneStruct default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitSingularUint64Field: return 0 + case .noneStruct: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.structEnum] = [ + .noneStruct, + ] + } - enum visitUnknown: SwiftProtobuf.Enum { + enum structValue: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneVisitUnknown // = 0 + case noneStructValue // = 0 case UNRECOGNIZED(Int) init() { - self = .noneVisitUnknown + self = .noneStructValue } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneVisitUnknown + case 0: self = .noneStructValue default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneVisitUnknown: return 0 + case .noneStructValue: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.structValue] = [ + .noneStructValue, + ] + } - enum wasDecoded: SwiftProtobuf.Enum { + enum subDecoder: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneWasDecoded // = 0 + case noneSubDecoder // = 0 case UNRECOGNIZED(Int) init() { - self = .noneWasDecoded + self = .noneSubDecoder } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneWasDecoded + case 0: self = .noneSubDecoder default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneWasDecoded: return 0 + case .noneSubDecoder: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subDecoder] = [ + .noneSubDecoder, + ] + } - enum weak: SwiftProtobuf.Enum { + enum subscriptEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneWeak // = 0 + case noneSubscript // = 0 case UNRECOGNIZED(Int) init() { - self = .noneWeak + self = .noneSubscript } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneWeak + case 0: self = .noneSubscript default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneWeak: return 0 + case .noneSubscript: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subscriptEnum] = [ + .noneSubscript, + ] + } - enum weakDependency: SwiftProtobuf.Enum { + enum subtract: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneWeakDependency // = 0 + case noneSubtract // = 0 case UNRECOGNIZED(Int) init() { - self = .noneWeakDependency + self = .noneSubtract } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneWeakDependency + case 0: self = .noneSubtract default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneWeakDependency: return 0 + case .noneSubtract: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subtract] = [ + .noneSubtract, + ] + } - enum whereEnum: SwiftProtobuf.Enum { + enum subVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneWhere // = 0 + case noneSubVisitor // = 0 case UNRECOGNIZED(Int) init() { - self = .noneWhere + self = .noneSubVisitor } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneWhere + case 0: self = .noneSubVisitor default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneWhere: return 0 + case .noneSubVisitor: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subVisitor] = [ + .noneSubVisitor, + ] + } - enum wireFormat: SwiftProtobuf.Enum { + enum SwiftEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneWireFormat // = 0 + case noneSwift // = 0 case UNRECOGNIZED(Int) init() { - self = .noneWireFormat + self = .noneSwift } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneWireFormat + case 0: self = .noneSwift default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneWireFormat: return 0 + case .noneSwift: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SwiftEnum] = [ + .noneSwift, + ] + } - enum with: SwiftProtobuf.Enum { + enum swiftPrefix: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneWith // = 0 + case noneSwiftPrefix // = 0 case UNRECOGNIZED(Int) init() { - self = .noneWith + self = .noneSwiftPrefix } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneWith + case 0: self = .noneSwiftPrefix default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneWith: return 0 + case .noneSwiftPrefix: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.swiftPrefix] = [ + .noneSwiftPrefix, + ] + } - enum withUnsafeBytes: SwiftProtobuf.Enum { + enum SwiftProtobufContiguousBytes: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneWithUnsafeBytes // = 0 + case noneSwiftProtobufContiguousBytes // = 0 case UNRECOGNIZED(Int) init() { - self = .noneWithUnsafeBytes + self = .noneSwiftProtobufContiguousBytes } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneWithUnsafeBytes + case 0: self = .noneSwiftProtobufContiguousBytes default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneWithUnsafeBytes: return 0 + case .noneSwiftProtobufContiguousBytes: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SwiftProtobufContiguousBytes] = [ + .noneSwiftProtobufContiguousBytes, + ] + } - enum withUnsafeMutableBytes: SwiftProtobuf.Enum { + enum SwiftProtobufError: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneWithUnsafeMutableBytes // = 0 + case noneSwiftProtobufError // = 0 case UNRECOGNIZED(Int) init() { - self = .noneWithUnsafeMutableBytes + self = .noneSwiftProtobufError } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneWithUnsafeMutableBytes + case 0: self = .noneSwiftProtobufError default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneWithUnsafeMutableBytes: return 0 + case .noneSwiftProtobufError: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SwiftProtobufError] = [ + .noneSwiftProtobufError, + ] + } - enum work: SwiftProtobuf.Enum { + enum syntax: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneWork // = 0 + case noneSyntax // = 0 case UNRECOGNIZED(Int) init() { - self = .noneWork + self = .noneSyntax } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneWork + case 0: self = .noneSyntax default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneWork: return 0 + case .noneSyntax: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.syntax] = [ + .noneSyntax, + ] + } - enum WrappedType: SwiftProtobuf.Enum { + enum T: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneWrappedType // = 0 + case noneT // = 0 case UNRECOGNIZED(Int) init() { - self = .noneWrappedType + self = .noneT } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneWrappedType + case 0: self = .noneT default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneWrappedType: return 0 + case .noneT: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.T] = [ + .noneT, + ] + } - enum written: SwiftProtobuf.Enum { + enum tag: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneWritten // = 0 + case noneTag // = 0 case UNRECOGNIZED(Int) init() { - self = .noneWritten + self = .noneTag } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneWritten + case 0: self = .noneTag default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneWritten: return 0 + case .noneTag: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tag] = [ + .noneTag, + ] + } - enum yday: SwiftProtobuf.Enum { + enum targets: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int - case noneYday // = 0 + case noneTargets // = 0 case UNRECOGNIZED(Int) init() { - self = .noneYday + self = .noneTargets } init?(rawValue: Int) { switch rawValue { - case 0: self = .noneYday + case 0: self = .noneTargets default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { - case .noneYday: return 0 + case .noneTargets: return 0 case .UNRECOGNIZED(let i): return i } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.targets] = [ + .noneTargets, + ] + } - init() {} -} + enum terminator: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTerminator // = 0 + case UNRECOGNIZED(Int) -#if swift(>=4.2) + init() { + self = .noneTerminator + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.adjusted: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.adjusted] = [ - .noneAdjusted, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTerminator + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.aggregateValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.aggregateValue] = [ - .noneAggregateValue, - ] -} + var rawValue: Int { + switch self { + case .noneTerminator: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allCases: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allCases] = [ - .noneAllCases, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.terminator] = [ + .noneTerminator, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allowAlias: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allowAlias] = [ - .noneAllowAlias, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.alwaysPrintEnumsAsInts: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.alwaysPrintEnumsAsInts] = [ - .noneAlwaysPrintEnumsAsInts, - ] -} + enum testDecoder: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTestDecoder // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.annotation: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.annotation] = [ - .noneAnnotation, - ] -} + init() { + self = .noneTestDecoder + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.any: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.any] = [ - .noneAny, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTestDecoder + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyExtensionField] = [ - .noneAnyExtensionField, - ] -} + var rawValue: Int { + switch self { + case .noneTestDecoder: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageExtension: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageExtension] = [ - .noneAnyMessageExtension, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.testDecoder] = [ + .noneTestDecoder, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageStorage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageStorage] = [ - .noneAnyMessageStorage, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyUnpackError: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyUnpackError] = [ - .noneAnyUnpackError, - ] -} + enum text: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneText // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Api: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Api] = [ - .noneApi, - ] -} + init() { + self = .noneText + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appended: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appended] = [ - .noneAppended, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneText + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUIntHex: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUIntHex] = [ - .noneAppendUintHex, - ] -} + var rawValue: Int { + switch self { + case .noneText: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUnknown: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUnknown] = [ - .noneAppendUnknown, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.text] = [ + .noneText, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.areAllInitialized: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.areAllInitialized] = [ - .noneAreAllInitialized, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.array: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.array] = [ - .noneArray, - ] -} + enum textDecoder: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTextDecoder // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayDepth: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayDepth] = [ - .noneArrayDepth, - ] -} + init() { + self = .noneTextDecoder + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayLiteral] = [ - .noneArrayLiteral, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTextDecoder + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arraySeparator: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arraySeparator] = [ - .noneArraySeparator, - ] -} + var rawValue: Int { + switch self { + case .noneTextDecoder: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asEnum] = [ - .noneAs, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.textDecoder] = [ + .noneTextDecoder, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiOpenCurlyBracket: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiOpenCurlyBracket] = [ - .noneAsciiOpenCurlyBracket, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiZero: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiZero] = [ - .noneAsciiZero, - ] -} + enum TextFormatDecoder: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTextFormatDecoder // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.available: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.available] = [ - .noneAvailable, - ] -} + init() { + self = .noneTextFormatDecoder + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.b: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.b] = [ - .noneB, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTextFormatDecoder + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.base64Values: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.base64Values] = [ - .noneBase64Values, - ] -} + var rawValue: Int { + switch self { + case .noneTextFormatDecoder: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.baseAddress: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.baseAddress] = [ - .noneBaseAddress, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatDecoder] = [ + .noneTextFormatDecoder, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BaseType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BaseType] = [ - .noneBaseType, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.begin: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.begin] = [ - .noneBegin, - ] -} + enum TextFormatDecodingError: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTextFormatDecodingError // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binary: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binary] = [ - .noneBinary, - ] -} + init() { + self = .noneTextFormatDecodingError + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecoder] = [ - .noneBinaryDecoder, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTextFormatDecodingError + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingError: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingError] = [ - .noneBinaryDecodingError, - ] -} + var rawValue: Int { + switch self { + case .noneTextFormatDecodingError: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingOptions] = [ - .noneBinaryDecodingOptions, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatDecodingError] = [ + .noneTextFormatDecodingError, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDelimited: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDelimited] = [ - .noneBinaryDelimited, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncoder] = [ - .noneBinaryEncoder, - ] -} + enum TextFormatDecodingOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTextFormatDecodingOptions // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingError: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingError] = [ - .noneBinaryEncodingError, - ] -} + init() { + self = .noneTextFormatDecodingOptions + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetSizeVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetSizeVisitor] = [ - .noneBinaryEncodingMessageSetSizeVisitor, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTextFormatDecodingOptions + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetVisitor] = [ - .noneBinaryEncodingMessageSetVisitor, - ] -} + var rawValue: Int { + switch self { + case .noneTextFormatDecodingOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingSizeVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingSizeVisitor] = [ - .noneBinaryEncodingSizeVisitor, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatDecodingOptions] = [ + .noneTextFormatDecodingOptions, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingVisitor] = [ - .noneBinaryEncodingVisitor, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binaryOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binaryOptions] = [ - .noneBinaryOptions, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.body: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.body] = [ - .noneBody, - ] -} + enum TextFormatEncodingOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTextFormatEncodingOptions // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BoolEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BoolEnum] = [ - .noneBool, - ] -} + init() { + self = .noneTextFormatEncodingOptions + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.booleanLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.booleanLiteral] = [ - .noneBooleanLiteral, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTextFormatEncodingOptions + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BooleanLiteralType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BooleanLiteralType] = [ - .noneBooleanLiteralType, - ] -} + var rawValue: Int { + switch self { + case .noneTextFormatEncodingOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.boolValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.boolValue] = [ - .noneBoolValue, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatEncodingOptions] = [ + .noneTextFormatEncodingOptions, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytes: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytes] = [ - .noneBytes, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesInGroup: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesInGroup] = [ - .noneBytesInGroup, - ] -} + enum TextFormatEncodingVisitor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTextFormatEncodingVisitor // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesRead: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesRead] = [ - .noneBytesRead, - ] -} + init() { + self = .noneTextFormatEncodingVisitor + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BytesValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BytesValue] = [ - .noneBytesValue, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTextFormatEncodingVisitor + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.c: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.c] = [ - .noneC, - ] -} + var rawValue: Int { + switch self { + case .noneTextFormatEncodingVisitor: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.capitalizeNext: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.capitalizeNext] = [ - .noneCapitalizeNext, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatEncodingVisitor] = [ + .noneTextFormatEncodingVisitor, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.cardinality: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.cardinality] = [ - .noneCardinality, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ccEnableArenas: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ccEnableArenas] = [ - .noneCcEnableArenas, - ] -} + enum textFormatString: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTextFormatString // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ccGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ccGenericServices] = [ - .noneCcGenericServices, - ] -} + init() { + self = .noneTextFormatString + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Character: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Character] = [ - .noneCharacter, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTextFormatString + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.chars: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.chars] = [ - .noneChars, - ] -} + var rawValue: Int { + switch self { + case .noneTextFormatString: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.classEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.classEnum] = [ - .noneClass, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.textFormatString] = [ + .noneTextFormatString, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearAggregateValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearAggregateValue] = [ - .noneClearAggregateValue, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearAllowAlias: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearAllowAlias] = [ - .noneClearAllowAlias, - ] -} + enum throwOrIgnore: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneThrowOrIgnore // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearBegin: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearBegin] = [ - .noneClearBegin, - ] -} + init() { + self = .noneThrowOrIgnore + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCcEnableArenas: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCcEnableArenas] = [ - .noneClearCcEnableArenas, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneThrowOrIgnore + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCcGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCcGenericServices] = [ - .noneClearCcGenericServices, - ] -} + var rawValue: Int { + switch self { + case .noneThrowOrIgnore: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearClientStreaming: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearClientStreaming] = [ - .noneClearClientStreaming, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.throwOrIgnore] = [ + .noneThrowOrIgnore, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCsharpNamespace: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCsharpNamespace] = [ - .noneClearCsharpNamespace, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCtype: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCtype] = [ - .noneClearCtype, - ] -} + enum throwsEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneThrows // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDefaultValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDefaultValue] = [ - .noneClearDefaultValue, - ] -} + init() { + self = .noneThrows + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDeprecated: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDeprecated] = [ - .noneClearDeprecated, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneThrows + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDoubleValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDoubleValue] = [ - .noneClearDoubleValue, - ] -} + var rawValue: Int { + switch self { + case .noneThrows: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearEnd: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearEnd] = [ - .noneClearEnd, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.throwsEnum] = [ + .noneThrows, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtendee: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtendee] = [ - .noneClearExtendee, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtensionValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtensionValue] = [ - .noneClearExtensionValue, - ] -} + enum timeInterval: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTimeInterval // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearGoPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearGoPackage] = [ - .noneClearGoPackage, - ] -} + init() { + self = .noneTimeInterval + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIdempotencyLevel: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIdempotencyLevel] = [ - .noneClearIdempotencyLevel, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTimeInterval + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIdentifierValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIdentifierValue] = [ - .noneClearIdentifierValue, - ] -} + var rawValue: Int { + switch self { + case .noneTimeInterval: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearInputType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearInputType] = [ - .noneClearInputType, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeInterval] = [ + .noneTimeInterval, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIsExtension: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIsExtension] = [ - .noneClearIsExtension, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaGenerateEqualsAndHash: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaGenerateEqualsAndHash] = [ - .noneClearJavaGenerateEqualsAndHash, - ] -} + enum timeIntervalSince1970: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTimeIntervalSince1970 // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaGenericServices] = [ - .noneClearJavaGenericServices, - ] -} + init() { + self = .noneTimeIntervalSince1970 + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaMultipleFiles: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaMultipleFiles] = [ - .noneClearJavaMultipleFiles, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTimeIntervalSince1970 + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaOuterClassname: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaOuterClassname] = [ - .noneClearJavaOuterClassname, - ] -} + var rawValue: Int { + switch self { + case .noneTimeIntervalSince1970: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaPackage] = [ - .noneClearJavaPackage, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeIntervalSince1970] = [ + .noneTimeIntervalSince1970, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaStringCheckUtf8: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaStringCheckUtf8] = [ - .noneClearJavaStringCheckUtf8, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJsonName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJsonName] = [ - .noneClearJsonName, - ] -} + enum timeIntervalSinceReferenceDate: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTimeIntervalSinceReferenceDate // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJstype: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJstype] = [ - .noneClearJstype, - ] -} + init() { + self = .noneTimeIntervalSinceReferenceDate + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLabel: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLabel] = [ - .noneClearLabel, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTimeIntervalSinceReferenceDate + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLazy: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLazy] = [ - .noneClearLazy, - ] -} + var rawValue: Int { + switch self { + case .noneTimeIntervalSinceReferenceDate: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLeadingComments: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLeadingComments] = [ - .noneClearLeadingComments, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate] = [ + .noneTimeIntervalSinceReferenceDate, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearMapEntry: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearMapEntry] = [ - .noneClearMapEntry, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearMessageSetWireFormat: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearMessageSetWireFormat] = [ - .noneClearMessageSetWireFormat, - ] -} + enum tmp: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTmp // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearName] = [ - .noneClearName, - ] -} + init() { + self = .noneTmp + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNamePart: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNamePart] = [ - .noneClearNamePart, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTmp + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNegativeIntValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNegativeIntValue] = [ - .noneClearNegativeIntValue, - ] -} + var rawValue: Int { + switch self { + case .noneTmp: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNoStandardDescriptorAccessor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNoStandardDescriptorAccessor] = [ - .noneClearNoStandardDescriptorAccessor, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tmp] = [ + .noneTmp, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNumber: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNumber] = [ - .noneClearNumber, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearObjcClassPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearObjcClassPrefix] = [ - .noneClearObjcClassPrefix, - ] -} + enum tooLarge: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTooLarge // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOneofIndex: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOneofIndex] = [ - .noneClearOneofIndex, - ] -} + init() { + self = .noneTooLarge + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOptimizeFor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOptimizeFor] = [ - .noneClearOptimizeFor, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTooLarge + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOptions] = [ - .noneClearOptions, - ] -} + var rawValue: Int { + switch self { + case .noneTooLarge: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOutputType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOutputType] = [ - .noneClearOutputType, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tooLarge] = [ + .noneTooLarge, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPackage] = [ - .noneClearPackage, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPacked: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPacked] = [ - .noneClearPacked, - ] -} + enum total: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTotal // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpClassPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpClassPrefix] = [ - .noneClearPhpClassPrefix, - ] -} + init() { + self = .noneTotal + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpGenericServices] = [ - .noneClearPhpGenericServices, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTotal + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpMetadataNamespace: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpMetadataNamespace] = [ - .noneClearPhpMetadataNamespace, - ] -} + var rawValue: Int { + switch self { + case .noneTotal: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpNamespace: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpNamespace] = [ - .noneClearPhpNamespace, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.total] = [ + .noneTotal, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPositiveIntValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPositiveIntValue] = [ - .noneClearPositiveIntValue, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearProto3Optional: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearProto3Optional] = [ - .noneClearProto3Optional, - ] -} + enum totalArrayDepth: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTotalArrayDepth // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPyGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPyGenericServices] = [ - .noneClearPyGenericServices, - ] -} + init() { + self = .noneTotalArrayDepth + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearRubyPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearRubyPackage] = [ - .noneClearRubyPackage, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTotalArrayDepth + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearServerStreaming: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearServerStreaming] = [ - .noneClearServerStreaming, - ] -} + var rawValue: Int { + switch self { + case .noneTotalArrayDepth: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceCodeInfo: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceCodeInfo] = [ - .noneClearSourceCodeInfo, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.totalArrayDepth] = [ + .noneTotalArrayDepth, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceContext: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceContext] = [ - .noneClearSourceContext, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceFile: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceFile] = [ - .noneClearSourceFile, - ] -} + enum totalSize: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTotalSize // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearStart: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearStart] = [ - .noneClearStart, - ] -} + init() { + self = .noneTotalSize + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearStringValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearStringValue] = [ - .noneClearStringValue, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTotalSize + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSwiftPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSwiftPrefix] = [ - .noneClearSwiftPrefix, - ] -} + var rawValue: Int { + switch self { + case .noneTotalSize: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSyntax: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSyntax] = [ - .noneClearSyntax, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.totalSize] = [ + .noneTotalSize, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearTrailingComments: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearTrailingComments] = [ - .noneClearTrailingComments, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearType] = [ - .noneClearType, - ] -} + enum trailingComments: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTrailingComments // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearTypeName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearTypeName] = [ - .noneClearTypeName, - ] -} + init() { + self = .noneTrailingComments + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearValue] = [ - .noneClearValue, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTrailingComments + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearWeak: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearWeak] = [ - .noneClearWeak, - ] -} + var rawValue: Int { + switch self { + case .noneTrailingComments: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clientStreaming: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clientStreaming] = [ - .noneClientStreaming, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.trailingComments] = [ + .noneTrailingComments, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codePoint: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codePoint] = [ - .noneCodePoint, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codeUnits: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codeUnits] = [ - .noneCodeUnits, - ] -} + enum traverseEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTraverse // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Collection: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Collection] = [ - .noneCollection, - ] -} + init() { + self = .noneTraverse + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.com: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.com] = [ - .noneCom, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTraverse + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.comma: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.comma] = [ - .noneComma, - ] -} + var rawValue: Int { + switch self { + case .noneTraverse: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.contentsOf: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.contentsOf] = [ - .noneContentsOf, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.traverseEnum] = [ + .noneTraverse, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ContiguousBytes: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ContiguousBytes] = [ - .noneContiguousBytes, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.count: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.count] = [ - .noneCount, - ] -} + enum trim: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTrim // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.countVarintsInBuffer: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.countVarintsInBuffer] = [ - .noneCountVarintsInBuffer, - ] -} + init() { + self = .noneTrim + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.csharpNamespace: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.csharpNamespace] = [ - .noneCsharpNamespace, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTrim + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ctype: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ctype] = [ - .noneCtype, - ] -} + var rawValue: Int { + switch self { + case .noneTrim: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.customCodable: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.customCodable] = [ - .noneCustomCodable, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.trim] = [ + .noneTrim, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.CustomDebugStringConvertible: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.CustomDebugStringConvertible] = [ - .noneCustomDebugStringConvertible, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.d: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.d] = [ - .noneD, - ] -} + enum trueEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTrue // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DataEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DataEnum] = [ - .noneData, - ] -} + init() { + self = .noneTrue + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dataResult: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dataResult] = [ - .noneDataResult, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTrue + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.date: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.date] = [ - .noneDate, - ] -} + var rawValue: Int { + switch self { + case .noneTrue: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daySec: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daySec] = [ - .noneDaySec, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.trueEnum] = [ + .noneTrue, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daysSinceEpoch: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daysSinceEpoch] = [ - .noneDaysSinceEpoch, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.debugDescriptionEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.debugDescriptionEnum] = [ - .noneDebugDescription, - ] -} + enum tryEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTry // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoded: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoded] = [ - .noneDecoded, - ] -} + init() { + self = .noneTry + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodedFromJSONNull: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodedFromJSONNull] = [ - .noneDecodedFromJsonnull, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTry + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionField] = [ - .noneDecodeExtensionField, - ] -} + var rawValue: Int { + switch self { + case .noneTry: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionFieldsAsMessageSet: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionFieldsAsMessageSet] = [ - .noneDecodeExtensionFieldsAsMessageSet, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tryEnum] = [ + .noneTry, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeJSON: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeJSON] = [ - .noneDecodeJson, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMapField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMapField] = [ - .noneDecodeMapField, - ] -} + enum type: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneType // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMessageEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMessageEnum] = [ - .noneDecodeMessage, - ] -} + init() { + self = .noneType + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoder] = [ - .noneDecoder, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneType + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeated: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeated] = [ - .noneDecodeRepeated, - ] -} + var rawValue: Int { + switch self { + case .noneType: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBoolField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBoolField] = [ - .noneDecodeRepeatedBoolField, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.type] = [ + .noneType, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBytesField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBytesField] = [ - .noneDecodeRepeatedBytesField, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedDoubleField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedDoubleField] = [ - .noneDecodeRepeatedDoubleField, - ] -} + enum typealiasEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTypealias // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedEnumField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedEnumField] = [ - .noneDecodeRepeatedEnumField, - ] -} + init() { + self = .noneTypealias + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed32Field] = [ - .noneDecodeRepeatedFixed32Field, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTypealias + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed64Field] = [ - .noneDecodeRepeatedFixed64Field, - ] -} + var rawValue: Int { + switch self { + case .noneTypealias: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFloatField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFloatField] = [ - .noneDecodeRepeatedFloatField, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typealiasEnum] = [ + .noneTypealias, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedGroupField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedGroupField] = [ - .noneDecodeRepeatedGroupField, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt32Field] = [ - .noneDecodeRepeatedInt32Field, - ] -} + enum TypeEnumEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTypeEnum // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt64Field] = [ - .noneDecodeRepeatedInt64Field, - ] -} + init() { + self = .noneTypeEnum + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedMessageField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedMessageField] = [ - .noneDecodeRepeatedMessageField, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTypeEnum + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed32Field] = [ - .noneDecodeRepeatedSfixed32Field, - ] -} + var rawValue: Int { + switch self { + case .noneTypeEnum: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed64Field] = [ - .noneDecodeRepeatedSfixed64Field, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TypeEnumEnum] = [ + .noneTypeEnum, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt32Field] = [ - .noneDecodeRepeatedSint32Field, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt64Field] = [ - .noneDecodeRepeatedSint64Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedStringField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedStringField] = [ - .noneDecodeRepeatedStringField, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt32Field] = [ - .noneDecodeRepeatedUint32Field, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt64Field] = [ - .noneDecodeRepeatedUint64Field, - ] -} + enum typeName: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTypeName // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingular: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingular] = [ - .noneDecodeSingular, - ] -} + init() { + self = .noneTypeName + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBoolField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBoolField] = [ - .noneDecodeSingularBoolField, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTypeName + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBytesField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBytesField] = [ - .noneDecodeSingularBytesField, - ] -} + var rawValue: Int { + switch self { + case .noneTypeName: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularDoubleField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularDoubleField] = [ - .noneDecodeSingularDoubleField, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeName] = [ + .noneTypeName, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularEnumField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularEnumField] = [ - .noneDecodeSingularEnumField, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed32Field] = [ - .noneDecodeSingularFixed32Field, - ] -} + enum typePrefix: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTypePrefix // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed64Field] = [ - .noneDecodeSingularFixed64Field, - ] -} + init() { + self = .noneTypePrefix + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFloatField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFloatField] = [ - .noneDecodeSingularFloatField, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTypePrefix + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularGroupField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularGroupField] = [ - .noneDecodeSingularGroupField, - ] -} + var rawValue: Int { + switch self { + case .noneTypePrefix: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt32Field] = [ - .noneDecodeSingularInt32Field, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typePrefix] = [ + .noneTypePrefix, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt64Field] = [ - .noneDecodeSingularInt64Field, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularMessageField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularMessageField] = [ - .noneDecodeSingularMessageField, - ] -} + enum typeStart: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTypeStart // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed32Field] = [ - .noneDecodeSingularSfixed32Field, - ] -} + init() { + self = .noneTypeStart + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed64Field] = [ - .noneDecodeSingularSfixed64Field, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTypeStart + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt32Field] = [ - .noneDecodeSingularSint32Field, - ] -} + var rawValue: Int { + switch self { + case .noneTypeStart: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt64Field] = [ - .noneDecodeSingularSint64Field, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeStart] = [ + .noneTypeStart, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularStringField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularStringField] = [ - .noneDecodeSingularStringField, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt32Field] = [ - .noneDecodeSingularUint32Field, - ] -} + enum typeUnknown: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTypeUnknown // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt64Field] = [ - .noneDecodeSingularUint64Field, - ] -} + init() { + self = .noneTypeUnknown + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeTextFormat: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeTextFormat] = [ - .noneDecodeTextFormat, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTypeUnknown + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultAnyTypeURLPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultAnyTypeURLPrefix] = [ - .noneDefaultAnyTypeUrlprefix, - ] -} + var rawValue: Int { + switch self { + case .noneTypeUnknown: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultValue] = [ - .noneDefaultValue, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeUnknown] = [ + .noneTypeUnknown, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dependency: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dependency] = [ - .noneDependency, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.deprecated: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.deprecated] = [ - .noneDeprecated, - ] -} + enum typeURL: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneTypeURL // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.descriptionEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.descriptionEnum] = [ - .noneDescription, - ] -} + init() { + self = .noneTypeURL + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DescriptorProto] = [ - .noneDescriptorProto, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneTypeURL + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Dictionary: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Dictionary] = [ - .noneDictionary, - ] -} + var rawValue: Int { + switch self { + case .noneTypeURL: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dictionaryLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dictionaryLiteral] = [ - .noneDictionaryLiteral, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeURL] = [ + .noneTypeURL, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit] = [ - .noneDigit, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit0: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit0] = [ - .noneDigit0, - ] -} + enum UInt32Enum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUint32 // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit1: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit1] = [ - .noneDigit1, - ] -} + init() { + self = .noneUint32 + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitCount: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitCount] = [ - .noneDigitCount, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUint32 + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digits: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digits] = [ - .noneDigits, - ] -} + var rawValue: Int { + switch self { + case .noneUint32: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitValue] = [ - .noneDigitValue, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UInt32Enum] = [ + .noneUint32, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardableResult: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardableResult] = [ - .noneDiscardableResult, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardUnknownFields: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardUnknownFields] = [ - .noneDiscardUnknownFields, - ] -} + enum UInt64Enum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUint64 // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.distance: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.distance] = [ - .noneDistance, - ] -} + init() { + self = .noneUint64 + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.double: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.double] = [ - .noneDouble, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUint64 + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.doubleValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.doubleValue] = [ - .noneDoubleValue, - ] -} + var rawValue: Int { + switch self { + case .noneUint64: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Duration: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Duration] = [ - .noneDuration, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UInt64Enum] = [ + .noneUint64, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.E: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.E] = [ - .noneE, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Element: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Element] = [ - .noneElement, - ] -} + enum UInt8: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUint8 // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.elements: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.elements] = [ - .noneElements, - ] -} + init() { + self = .noneUint8 + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitExtensionFieldName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitExtensionFieldName] = [ - .noneEmitExtensionFieldName, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUint8 + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldName] = [ - .noneEmitFieldName, - ] -} + var rawValue: Int { + switch self { + case .noneUint8: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldNumber: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldNumber] = [ - .noneEmitFieldNumber, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UInt8] = [ + .noneUint8, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Empty: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Empty] = [ - .noneEmpty, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emptyData: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emptyData] = [ - .noneEmptyData, - ] -} + enum unchecked: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnchecked // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeAsBytes: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeAsBytes] = [ - .noneEncodeAsBytes, - ] -} + init() { + self = .noneUnchecked + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoded: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoded] = [ - .noneEncoded, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnchecked + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedJSONString: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedJSONString] = [ - .noneEncodedJsonstring, - ] -} + var rawValue: Int { + switch self { + case .noneUnchecked: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedSize: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedSize] = [ - .noneEncodedSize, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unchecked] = [ + .noneUnchecked, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeField] = [ - .noneEncodeField, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoder] = [ - .noneEncoder, - ] -} + enum Unicode: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnicode // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.end: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.end] = [ - .noneEnd, - ] -} + init() { + self = .noneUnicode + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endArray: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endArray] = [ - .noneEndArray, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnicode + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endMessageField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endMessageField] = [ - .noneEndMessageField, - ] -} + var rawValue: Int { + switch self { + case .noneUnicode: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endObject: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endObject] = [ - .noneEndObject, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Unicode] = [ + .noneUnicode, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endRegularField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endRegularField] = [ - .noneEndRegularField, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumEnum] = [ - .noneEnum, - ] -} + enum unicodeScalarLiteral: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnicodeScalarLiteral // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumDescriptorProto] = [ - .noneEnumDescriptorProto, - ] -} + init() { + self = .noneUnicodeScalarLiteral + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumOptions] = [ - .noneEnumOptions, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnicodeScalarLiteral + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnicodeScalarLiteral: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unicodeScalarLiteral] = [ + .noneUnicodeScalarLiteral, + ] + + } + + enum UnicodeScalarLiteralType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnicodeScalarLiteralType // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnicodeScalarLiteralType + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnicodeScalarLiteralType + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnicodeScalarLiteralType: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnicodeScalarLiteralType] = [ + .noneUnicodeScalarLiteralType, + ] + + } + + enum unicodeScalars: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnicodeScalars // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnicodeScalars + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnicodeScalars + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnicodeScalars: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unicodeScalars] = [ + .noneUnicodeScalars, + ] + + } + + enum UnicodeScalarView: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnicodeScalarView // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnicodeScalarView + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnicodeScalarView + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnicodeScalarView: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnicodeScalarView] = [ + .noneUnicodeScalarView, + ] + + } + + enum uninterpretedOption: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUninterpretedOption // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUninterpretedOption + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUninterpretedOption + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUninterpretedOption: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.uninterpretedOption] = [ + .noneUninterpretedOption, + ] + + } + + enum union: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnion // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnion + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnion + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnion: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.union] = [ + .noneUnion, + ] + + } + + enum uniqueStorage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUniqueStorage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUniqueStorage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUniqueStorage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUniqueStorage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.uniqueStorage] = [ + .noneUniqueStorage, + ] + + } + + enum unknown: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnknown // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnknown + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnknown + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnknown: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unknown] = [ + .noneUnknown, + ] + + } + + enum unknownFieldsEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnknownFields // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnknownFields + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnknownFields + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnknownFields: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unknownFieldsEnum] = [ + .noneUnknownFields, + ] + + } + + enum UnknownStorage: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnknownStorage // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnknownStorage + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnknownStorage + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnknownStorage: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnknownStorage] = [ + .noneUnknownStorage, + ] + + } + + enum unpackTo: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnpackTo // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnpackTo + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnpackTo + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnpackTo: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unpackTo] = [ + .noneUnpackTo, + ] + + } + + enum UnsafeBufferPointer: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnsafeBufferPointer // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnsafeBufferPointer + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnsafeBufferPointer + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnsafeBufferPointer: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeBufferPointer] = [ + .noneUnsafeBufferPointer, + ] + + } + + enum UnsafeMutablePointer: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnsafeMutablePointer // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnsafeMutablePointer + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnsafeMutablePointer + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnsafeMutablePointer: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeMutablePointer] = [ + .noneUnsafeMutablePointer, + ] + + } + + enum UnsafeMutableRawBufferPointer: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnsafeMutableRawBufferPointer // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnsafeMutableRawBufferPointer + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnsafeMutableRawBufferPointer + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnsafeMutableRawBufferPointer: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeMutableRawBufferPointer] = [ + .noneUnsafeMutableRawBufferPointer, + ] + + } + + enum UnsafeRawBufferPointer: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnsafeRawBufferPointer // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnsafeRawBufferPointer + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnsafeRawBufferPointer + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnsafeRawBufferPointer: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeRawBufferPointer] = [ + .noneUnsafeRawBufferPointer, + ] + + } + + enum UnsafeRawPointer: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnsafeRawPointer // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnsafeRawPointer + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnsafeRawPointer + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnsafeRawPointer: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeRawPointer] = [ + .noneUnsafeRawPointer, + ] + + } + + enum unverifiedLazy: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUnverifiedLazy // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUnverifiedLazy + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUnverifiedLazy + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUnverifiedLazy: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unverifiedLazy] = [ + .noneUnverifiedLazy, + ] + + } + + enum updatedOptions: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUpdatedOptions // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUpdatedOptions + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUpdatedOptions + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUpdatedOptions: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.updatedOptions] = [ + .noneUpdatedOptions, + ] + + } + + enum uppercasedAssumingASCII: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUppercasedAssumingAscii // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUppercasedAssumingAscii + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUppercasedAssumingAscii + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUppercasedAssumingAscii: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.uppercasedAssumingASCII] = [ + .noneUppercasedAssumingAscii, + ] + + } + + enum url: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneURL // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneURL + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneURL + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneURL: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.url] = [ + .noneURL, + ] + + } + + enum useDeterministicOrdering: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUseDeterministicOrdering // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUseDeterministicOrdering + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUseDeterministicOrdering + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUseDeterministicOrdering: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.useDeterministicOrdering] = [ + .noneUseDeterministicOrdering, + ] + + } + + enum utf8: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUtf8 // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUtf8 + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUtf8 + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUtf8: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8] = [ + .noneUtf8, + ] + + } + + enum utf8Ptr: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUtf8Ptr // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUtf8Ptr + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUtf8Ptr + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUtf8Ptr: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8Ptr] = [ + .noneUtf8Ptr, + ] + + } + + enum utf8ToDouble: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUtf8ToDouble // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUtf8ToDouble + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUtf8ToDouble + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUtf8ToDouble: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8ToDouble] = [ + .noneUtf8ToDouble, + ] + + } + + enum utf8Validation: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUtf8Validation // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUtf8Validation + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUtf8Validation + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUtf8Validation: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8Validation] = [ + .noneUtf8Validation, + ] + + } + + enum UTF8View: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneUtf8View // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneUtf8View + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneUtf8View + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneUtf8View: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UTF8View] = [ + .noneUtf8View, + ] + + } + + enum V: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneV // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneV + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneV + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneV: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.V] = [ + .noneV, + ] + + } + + enum value: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneValue // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneValue + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneValue + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.value] = [ + .noneValue, + ] + + } + + enum valueField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneValueField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneValueField + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneValueField + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneValueField: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.valueField] = [ + .noneValueField, + ] + + } + + enum values: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneValues // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneValues + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneValues + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumReservedRange: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumReservedRange] = [ - .noneEnumReservedRange, - ] -} + var rawValue: Int { + switch self { + case .noneValues: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumType] = [ - .noneEnumType, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.values] = [ + .noneValues, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumvalue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumvalue] = [ - .noneEnumvalue, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumValueDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumValueDescriptorProto] = [ - .noneEnumValueDescriptorProto, - ] -} + enum ValueType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneValueType // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumValueOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumValueOptions] = [ - .noneEnumValueOptions, - ] -} + init() { + self = .noneValueType + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Equatable: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Equatable] = [ - .noneEquatable, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneValueType + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Error: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Error] = [ - .noneError, - ] -} + var rawValue: Int { + switch self { + case .noneValueType: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByArrayLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByArrayLiteral] = [ - .noneExpressibleByArrayLiteral, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ValueType] = [ + .noneValueType, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByDictionaryLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByDictionaryLiteral] = [ - .noneExpressibleByDictionaryLiteral, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ext: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ext] = [ - .noneExt, - ] -} + enum varEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVar // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extDecoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extDecoder] = [ - .noneExtDecoder, - ] -} + init() { + self = .noneVar + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendedGraphemeClusterLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendedGraphemeClusterLiteral] = [ - .noneExtendedGraphemeClusterLiteral, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVar + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtendedGraphemeClusterLiteralType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtendedGraphemeClusterLiteralType] = [ - .noneExtendedGraphemeClusterLiteralType, - ] -} + var rawValue: Int { + switch self { + case .noneVar: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendee: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendee] = [ - .noneExtendee, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.varEnum] = [ + .noneVar, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensibleMessage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensibleMessage] = [ - .noneExtensibleMessage, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionEnum] = [ - .noneExtension, - ] -} + enum verification: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVerification // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionField] = [ - .noneExtensionField, - ] -} + init() { + self = .noneVerification + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionFieldNumber: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionFieldNumber] = [ - .noneExtensionFieldNumber, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVerification + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionFieldValueSet: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionFieldValueSet] = [ - .noneExtensionFieldValueSet, - ] -} + var rawValue: Int { + switch self { + case .noneVerification: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionMap: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionMap] = [ - .noneExtensionMap, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.verification] = [ + .noneVerification, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionRange: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionRange] = [ - .noneExtensionRange, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionRangeOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionRangeOptions] = [ - .noneExtensionRangeOptions, - ] -} + enum VerificationState: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVerificationState // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensions] = [ - .noneExtensions, - ] -} + init() { + self = .noneVerificationState + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extras: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extras] = [ - .noneExtras, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVerificationState + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.F: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.F] = [ - .noneF, - ] -} + var rawValue: Int { + switch self { + case .noneVerificationState: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.falseEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.falseEnum] = [ - .noneFalse, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.VerificationState] = [ + .noneVerificationState, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.field] = [ - .noneField, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldData: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldData] = [ - .noneFieldData, - ] -} + enum version: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVersion // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldDescriptorProto] = [ - .noneFieldDescriptorProto, - ] -} + init() { + self = .noneVersion + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldMask: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldMask] = [ - .noneFieldMask, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVersion + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldName] = [ - .noneFieldName, - ] -} + var rawValue: Int { + switch self { + case .noneVersion: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNameCount: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNameCount] = [ - .noneFieldNameCount, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.version] = [ + .noneVersion, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNum] = [ - .noneFieldNum, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumber: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumber] = [ - .noneFieldNumber, - ] -} + enum versionString: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVersionString // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumberForProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumberForProto] = [ - .noneFieldNumberForProto, - ] -} + init() { + self = .noneVersionString + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldOptions] = [ - .noneFieldOptions, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVersionString + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fields: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fields] = [ - .noneFields, - ] -} + var rawValue: Int { + switch self { + case .noneVersionString: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldSize: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldSize] = [ - .noneFieldSize, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.versionString] = [ + .noneVersionString, + ] + + } + + enum visibility: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisibility // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisibility + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisibility + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisibility: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visibility] = [ + .noneVisibility, + ] + + } + + enum VisibilityFeature: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisibilityFeature // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisibilityFeature + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisibilityFeature + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisibilityFeature: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.VisibilityFeature] = [ + .noneVisibilityFeature, + ] + + } + + enum visitExtensionFields: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitExtensionFields // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitExtensionFields + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitExtensionFields + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitExtensionFields: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitExtensionFields] = [ + .noneVisitExtensionFields, + ] + + } + + enum visitExtensionFieldsAsMessageSet: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitExtensionFieldsAsMessageSet // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitExtensionFieldsAsMessageSet + } + + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitExtensionFieldsAsMessageSet + default: self = .UNRECOGNIZED(rawValue) + } + } + + var rawValue: Int { + switch self { + case .noneVisitExtensionFieldsAsMessageSet: return 0 + case .UNRECOGNIZED(let i): return i + } + } + + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitExtensionFieldsAsMessageSet] = [ + .noneVisitExtensionFieldsAsMessageSet, + ] + + } + + enum visitMapField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitMapField // = 0 + case UNRECOGNIZED(Int) + + init() { + self = .noneVisitMapField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldTag: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldTag] = [ - .noneFieldTag, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitMapField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldType] = [ - .noneFieldType, - ] -} + var rawValue: Int { + switch self { + case .noneVisitMapField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.file: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.file] = [ - .noneFile, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitMapField] = [ + .noneVisitMapField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileDescriptorProto] = [ - .noneFileDescriptorProto, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileDescriptorSet: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileDescriptorSet] = [ - .noneFileDescriptorSet, - ] -} + enum Visitor: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitor // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fileName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fileName] = [ - .noneFileName, - ] -} + init() { + self = .noneVisitor + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileOptions] = [ - .noneFileOptions, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitor + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.filter: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.filter] = [ - .noneFilter, - ] -} + var rawValue: Int { + switch self { + case .noneVisitor: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.first: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.first] = [ - .noneFirst, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Visitor] = [ + .noneVisitor, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.firstItem: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.firstItem] = [ - .noneFirstItem, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.float: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.float] = [ - .noneFloat, - ] -} + enum visitPacked: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPacked // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.floatLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.floatLiteral] = [ - .noneFloatLiteral, - ] -} + init() { + self = .noneVisitPacked + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatLiteralType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatLiteralType] = [ - .noneFloatLiteralType, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPacked + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatValue] = [ - .noneFloatValue, - ] -} + var rawValue: Int { + switch self { + case .noneVisitPacked: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forMessageName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forMessageName] = [ - .noneForMessageName, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPacked] = [ + .noneVisitPacked, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.formUnion: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.formUnion] = [ - .noneFormUnion, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forReadingFrom: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forReadingFrom] = [ - .noneForReadingFrom, - ] -} + enum visitPackedBoolField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedBoolField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forTypeURL: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forTypeURL] = [ - .noneForTypeURL, - ] -} + init() { + self = .noneVisitPackedBoolField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ForwardParser: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ForwardParser] = [ - .noneForwardParser, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedBoolField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forWritingInto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forWritingInto] = [ - .noneForWritingInto, - ] -} + var rawValue: Int { + switch self { + case .noneVisitPackedBoolField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.from: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.from] = [ - .noneFrom, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedBoolField] = [ + .noneVisitPackedBoolField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii2: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii2] = [ - .noneFromAscii2, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii4: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii4] = [ - .noneFromAscii4, - ] -} + enum visitPackedDoubleField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedDoubleField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromByteOffset: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromByteOffset] = [ - .noneFromByteOffset, - ] -} + init() { + self = .noneVisitPackedDoubleField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromHexDigit: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromHexDigit] = [ - .noneFromHexDigit, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedDoubleField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.funcEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.funcEnum] = [ - .noneFunc, - ] -} + var rawValue: Int { + switch self { + case .noneVisitPackedDoubleField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.G: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.G] = [ - .noneG, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedDoubleField] = [ + .noneVisitPackedDoubleField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.GeneratedCodeInfo: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.GeneratedCodeInfo] = [ - .noneGeneratedCodeInfo, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.get: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.get] = [ - .noneGet, - ] -} + enum visitPackedEnumField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedEnumField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.getExtensionValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.getExtensionValue] = [ - .noneGetExtensionValue, - ] -} + init() { + self = .noneVisitPackedEnumField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.googleapis: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.googleapis] = [ - .noneGoogleapis, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedEnumField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Any: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Any] = [ - .noneGoogleProtobufAny, - ] -} + var rawValue: Int { + switch self { + case .noneVisitPackedEnumField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Api: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Api] = [ - .noneGoogleProtobufApi, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedEnumField] = [ + .noneVisitPackedEnumField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BoolValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BoolValue] = [ - .noneGoogleProtobufBoolValue, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BytesValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BytesValue] = [ - .noneGoogleProtobufBytesValue, - ] -} + enum visitPackedFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedFixed32Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DescriptorProto] = [ - .noneGoogleProtobufDescriptorProto, - ] -} + init() { + self = .noneVisitPackedFixed32Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DoubleValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DoubleValue] = [ - .noneGoogleProtobufDoubleValue, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedFixed32Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Duration: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Duration] = [ - .noneGoogleProtobufDuration, - ] -} + var rawValue: Int { + switch self { + case .noneVisitPackedFixed32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Empty: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Empty] = [ - .noneGoogleProtobufEmpty, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedFixed32Field] = [ + .noneVisitPackedFixed32Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Enum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Enum] = [ - .noneGoogleProtobufEnum, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumDescriptorProto] = [ - .noneGoogleProtobufEnumDescriptorProto, - ] -} + enum visitPackedFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedFixed64Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumOptions] = [ - .noneGoogleProtobufEnumOptions, - ] -} + init() { + self = .noneVisitPackedFixed64Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValue] = [ - .noneGoogleProtobufEnumValue, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedFixed64Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueDescriptorProto] = [ - .noneGoogleProtobufEnumValueDescriptorProto, - ] -} + var rawValue: Int { + switch self { + case .noneVisitPackedFixed64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueOptions] = [ - .noneGoogleProtobufEnumValueOptions, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedFixed64Field] = [ + .noneVisitPackedFixed64Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ExtensionRangeOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ExtensionRangeOptions] = [ - .noneGoogleProtobufExtensionRangeOptions, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Field] = [ - .noneGoogleProtobufField, - ] -} + enum visitPackedFloatField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedFloatField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldDescriptorProto] = [ - .noneGoogleProtobufFieldDescriptorProto, - ] -} + init() { + self = .noneVisitPackedFloatField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldMask: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldMask] = [ - .noneGoogleProtobufFieldMask, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedFloatField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldOptions] = [ - .noneGoogleProtobufFieldOptions, - ] -} + var rawValue: Int { + switch self { + case .noneVisitPackedFloatField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorProto] = [ - .noneGoogleProtobufFileDescriptorProto, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedFloatField] = [ + .noneVisitPackedFloatField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorSet: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorSet] = [ - .noneGoogleProtobufFileDescriptorSet, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileOptions] = [ - .noneGoogleProtobufFileOptions, - ] -} + enum visitPackedInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedInt32Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FloatValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FloatValue] = [ - .noneGoogleProtobufFloatValue, - ] -} + init() { + self = .noneVisitPackedInt32Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_GeneratedCodeInfo: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_GeneratedCodeInfo] = [ - .noneGoogleProtobufGeneratedCodeInfo, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedInt32Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int32Value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int32Value] = [ - .noneGoogleProtobufInt32Value, - ] -} + var rawValue: Int { + switch self { + case .noneVisitPackedInt32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int64Value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int64Value] = [ - .noneGoogleProtobufInt64Value, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedInt32Field] = [ + .noneVisitPackedInt32Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ListValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ListValue] = [ - .noneGoogleProtobufListValue, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MessageOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MessageOptions] = [ - .noneGoogleProtobufMessageOptions, - ] -} + enum visitPackedInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedInt64Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Method: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Method] = [ - .noneGoogleProtobufMethod, - ] -} + init() { + self = .noneVisitPackedInt64Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodDescriptorProto] = [ - .noneGoogleProtobufMethodDescriptorProto, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedInt64Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodOptions] = [ - .noneGoogleProtobufMethodOptions, - ] -} + var rawValue: Int { + switch self { + case .noneVisitPackedInt64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Mixin: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Mixin] = [ - .noneGoogleProtobufMixin, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedInt64Field] = [ + .noneVisitPackedInt64Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_NullValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_NullValue] = [ - .noneGoogleProtobufNullValue, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofDescriptorProto] = [ - .noneGoogleProtobufOneofDescriptorProto, - ] -} + enum visitPackedSFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedSfixed32Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofOptions] = [ - .noneGoogleProtobufOneofOptions, - ] -} + init() { + self = .noneVisitPackedSfixed32Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Option: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Option] = [ - .noneGoogleProtobufOption, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedSfixed32Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceDescriptorProto] = [ - .noneGoogleProtobufServiceDescriptorProto, - ] -} + var rawValue: Int { + switch self { + case .noneVisitPackedSfixed32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceOptions] = [ - .noneGoogleProtobufServiceOptions, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSFixed32Field] = [ + .noneVisitPackedSfixed32Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceCodeInfo: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceCodeInfo] = [ - .noneGoogleProtobufSourceCodeInfo, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceContext: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceContext] = [ - .noneGoogleProtobufSourceContext, - ] -} + enum visitPackedSFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedSfixed64Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_StringValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_StringValue] = [ - .noneGoogleProtobufStringValue, - ] -} + init() { + self = .noneVisitPackedSfixed64Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Struct: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Struct] = [ - .noneGoogleProtobufStruct, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedSfixed64Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Syntax: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Syntax] = [ - .noneGoogleProtobufSyntax, - ] -} + var rawValue: Int { + switch self { + case .noneVisitPackedSfixed64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Timestamp: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Timestamp] = [ - .noneGoogleProtobufTimestamp, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSFixed64Field] = [ + .noneVisitPackedSfixed64Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Type: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Type] = [ - .noneGoogleProtobufType, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt32Value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt32Value] = [ - .noneGoogleProtobufUint32Value, - ] -} + enum visitPackedSInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedSint32Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt64Value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt64Value] = [ - .noneGoogleProtobufUint64Value, - ] -} + init() { + self = .noneVisitPackedSint32Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UninterpretedOption: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UninterpretedOption] = [ - .noneGoogleProtobufUninterpretedOption, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedSint32Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Value] = [ - .noneGoogleProtobufValue, - ] -} + var rawValue: Int { + switch self { + case .noneVisitPackedSint32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.goPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.goPackage] = [ - .noneGoPackage, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSInt32Field] = [ + .noneVisitPackedSint32Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.group: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.group] = [ - .noneGroup, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupFieldNumberStack: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupFieldNumberStack] = [ - .noneGroupFieldNumberStack, - ] -} + enum visitPackedSInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedSint64Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupSize: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupSize] = [ - .noneGroupSize, - ] -} + init() { + self = .noneVisitPackedSint64Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.h: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.h] = [ - .noneH, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedSint64Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hadOneofValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hadOneofValue] = [ - .noneHadOneofValue, - ] -} + var rawValue: Int { + switch self { + case .noneVisitPackedSint64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.handleConflictingOneOf: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.handleConflictingOneOf] = [ - .noneHandleConflictingOneOf, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSInt64Field] = [ + .noneVisitPackedSint64Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasAggregateValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasAggregateValue] = [ - .noneHasAggregateValue, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasAllowAlias: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasAllowAlias] = [ - .noneHasAllowAlias, - ] -} + enum visitPackedUInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedUint32Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasBegin: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasBegin] = [ - .noneHasBegin, - ] -} + init() { + self = .noneVisitPackedUint32Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCcEnableArenas: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCcEnableArenas] = [ - .noneHasCcEnableArenas, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedUint32Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCcGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCcGenericServices] = [ - .noneHasCcGenericServices, - ] -} + var rawValue: Int { + switch self { + case .noneVisitPackedUint32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasClientStreaming: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasClientStreaming] = [ - .noneHasClientStreaming, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedUInt32Field] = [ + .noneVisitPackedUint32Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCsharpNamespace: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCsharpNamespace] = [ - .noneHasCsharpNamespace, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCtype: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCtype] = [ - .noneHasCtype, - ] -} + enum visitPackedUInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitPackedUint64Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDefaultValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDefaultValue] = [ - .noneHasDefaultValue, - ] -} + init() { + self = .noneVisitPackedUint64Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDeprecated: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDeprecated] = [ - .noneHasDeprecated, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitPackedUint64Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDoubleValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDoubleValue] = [ - .noneHasDoubleValue, - ] -} + var rawValue: Int { + switch self { + case .noneVisitPackedUint64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasEnd: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasEnd] = [ - .noneHasEnd, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedUInt64Field] = [ + .noneVisitPackedUint64Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtendee: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtendee] = [ - .noneHasExtendee, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtensionValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtensionValue] = [ - .noneHasExtensionValue, - ] -} + enum visitRepeated: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeated // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasGoPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasGoPackage] = [ - .noneHasGoPackage, - ] -} + init() { + self = .noneVisitRepeated + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hash: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hash] = [ - .noneHash, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeated + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Hashable: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Hashable] = [ - .noneHashable, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeated: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasher: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasher] = [ - .noneHasher, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeated] = [ + .noneVisitRepeated, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hashValueEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hashValueEnum] = [ - .noneHashValue, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.HashVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.HashVisitor] = [ - .noneHashVisitor, - ] -} + enum visitRepeatedBoolField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedBoolField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIdempotencyLevel: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIdempotencyLevel] = [ - .noneHasIdempotencyLevel, - ] -} + init() { + self = .noneVisitRepeatedBoolField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIdentifierValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIdentifierValue] = [ - .noneHasIdentifierValue, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedBoolField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasInputType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasInputType] = [ - .noneHasInputType, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeatedBoolField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIsExtension: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIsExtension] = [ - .noneHasIsExtension, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedBoolField] = [ + .noneVisitRepeatedBoolField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaGenerateEqualsAndHash: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaGenerateEqualsAndHash] = [ - .noneHasJavaGenerateEqualsAndHash, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaGenericServices] = [ - .noneHasJavaGenericServices, - ] -} + enum visitRepeatedBytesField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedBytesField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaMultipleFiles: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaMultipleFiles] = [ - .noneHasJavaMultipleFiles, - ] -} + init() { + self = .noneVisitRepeatedBytesField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaOuterClassname: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaOuterClassname] = [ - .noneHasJavaOuterClassname, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedBytesField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaPackage] = [ - .noneHasJavaPackage, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeatedBytesField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaStringCheckUtf8: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaStringCheckUtf8] = [ - .noneHasJavaStringCheckUtf8, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedBytesField] = [ + .noneVisitRepeatedBytesField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJsonName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJsonName] = [ - .noneHasJsonName, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJstype: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJstype] = [ - .noneHasJstype, - ] -} + enum visitRepeatedDoubleField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedDoubleField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLabel: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLabel] = [ - .noneHasLabel, - ] -} + init() { + self = .noneVisitRepeatedDoubleField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLazy: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLazy] = [ - .noneHasLazy, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedDoubleField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLeadingComments: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLeadingComments] = [ - .noneHasLeadingComments, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeatedDoubleField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasMapEntry: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasMapEntry] = [ - .noneHasMapEntry, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedDoubleField] = [ + .noneVisitRepeatedDoubleField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasMessageSetWireFormat: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasMessageSetWireFormat] = [ - .noneHasMessageSetWireFormat, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasName] = [ - .noneHasName, - ] -} + enum visitRepeatedEnumField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedEnumField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNamePart: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNamePart] = [ - .noneHasNamePart, - ] -} + init() { + self = .noneVisitRepeatedEnumField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNegativeIntValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNegativeIntValue] = [ - .noneHasNegativeIntValue, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedEnumField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNoStandardDescriptorAccessor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNoStandardDescriptorAccessor] = [ - .noneHasNoStandardDescriptorAccessor, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeatedEnumField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNumber: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNumber] = [ - .noneHasNumber, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedEnumField] = [ + .noneVisitRepeatedEnumField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasObjcClassPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasObjcClassPrefix] = [ - .noneHasObjcClassPrefix, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOneofIndex: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOneofIndex] = [ - .noneHasOneofIndex, - ] -} + enum visitRepeatedFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedFixed32Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOptimizeFor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOptimizeFor] = [ - .noneHasOptimizeFor, - ] -} + init() { + self = .noneVisitRepeatedFixed32Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOptions] = [ - .noneHasOptions, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedFixed32Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOutputType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOutputType] = [ - .noneHasOutputType, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeatedFixed32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPackage] = [ - .noneHasPackage, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedFixed32Field] = [ + .noneVisitRepeatedFixed32Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPacked: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPacked] = [ - .noneHasPacked, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpClassPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpClassPrefix] = [ - .noneHasPhpClassPrefix, - ] -} + enum visitRepeatedFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedFixed64Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpGenericServices] = [ - .noneHasPhpGenericServices, - ] -} + init() { + self = .noneVisitRepeatedFixed64Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpMetadataNamespace: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpMetadataNamespace] = [ - .noneHasPhpMetadataNamespace, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedFixed64Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpNamespace: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpNamespace] = [ - .noneHasPhpNamespace, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeatedFixed64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPositiveIntValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPositiveIntValue] = [ - .noneHasPositiveIntValue, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedFixed64Field] = [ + .noneVisitRepeatedFixed64Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasProto3Optional: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasProto3Optional] = [ - .noneHasProto3Optional, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPyGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPyGenericServices] = [ - .noneHasPyGenericServices, - ] -} + enum visitRepeatedFloatField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedFloatField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasRubyPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasRubyPackage] = [ - .noneHasRubyPackage, - ] -} + init() { + self = .noneVisitRepeatedFloatField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasServerStreaming: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasServerStreaming] = [ - .noneHasServerStreaming, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedFloatField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceCodeInfo: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceCodeInfo] = [ - .noneHasSourceCodeInfo, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeatedFloatField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceContext: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceContext] = [ - .noneHasSourceContext, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedFloatField] = [ + .noneVisitRepeatedFloatField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceFile: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceFile] = [ - .noneHasSourceFile, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasStart: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasStart] = [ - .noneHasStart, - ] -} + enum visitRepeatedGroupField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedGroupField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasStringValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasStringValue] = [ - .noneHasStringValue, - ] -} + init() { + self = .noneVisitRepeatedGroupField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSwiftPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSwiftPrefix] = [ - .noneHasSwiftPrefix, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedGroupField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSyntax: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSyntax] = [ - .noneHasSyntax, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeatedGroupField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasTrailingComments: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasTrailingComments] = [ - .noneHasTrailingComments, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedGroupField] = [ + .noneVisitRepeatedGroupField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasType] = [ - .noneHasType, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasTypeName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasTypeName] = [ - .noneHasTypeName, - ] -} + enum visitRepeatedInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedInt32Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasValue] = [ - .noneHasValue, - ] -} + init() { + self = .noneVisitRepeatedInt32Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasWeak: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasWeak] = [ - .noneHasWeak, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedInt32Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hour: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hour] = [ - .noneHour, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeatedInt32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i] = [ - .noneI, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedInt32Field] = [ + .noneVisitRepeatedInt32Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.idempotencyLevel: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.idempotencyLevel] = [ - .noneIdempotencyLevel, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.identifierValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.identifierValue] = [ - .noneIdentifierValue, - ] -} + enum visitRepeatedInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedInt64Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ifEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ifEnum] = [ - .noneIf, - ] -} + init() { + self = .noneVisitRepeatedInt64Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ignoreUnknownFields: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ignoreUnknownFields] = [ - .noneIgnoreUnknownFields, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedInt64Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.index: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.index] = [ - .noneIndex, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeatedInt64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.initEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.initEnum] = [ - .noneInit, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedInt64Field] = [ + .noneVisitRepeatedInt64Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inoutEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inoutEnum] = [ - .noneInout, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inputType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inputType] = [ - .noneInputType, - ] -} + enum visitRepeatedMessageField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedMessageField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.insert: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.insert] = [ - .noneInsert, - ] -} + init() { + self = .noneVisitRepeatedMessageField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntEnum] = [ - .noneInt, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedMessageField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Enum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Enum] = [ - .noneInt32, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeatedMessageField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Value] = [ - .noneInt32Value, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedMessageField] = [ + .noneVisitRepeatedMessageField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Enum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Enum] = [ - .noneInt64, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Value] = [ - .noneInt64Value, - ] -} + enum visitRepeatedSFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedSfixed32Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int8: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int8] = [ - .noneInt8, - ] -} + init() { + self = .noneVisitRepeatedSfixed32Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.integerLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.integerLiteral] = [ - .noneIntegerLiteral, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedSfixed32Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntegerLiteralType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntegerLiteralType] = [ - .noneIntegerLiteralType, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeatedSfixed32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.intern: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.intern] = [ - .noneIntern, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSFixed32Field] = [ + .noneVisitRepeatedSfixed32Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Internal: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Internal] = [ - .noneInternal, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.InternalState: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.InternalState] = [ - .noneInternalState, - ] -} + enum visitRepeatedSFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedSfixed64Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.into: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.into] = [ - .noneInto, - ] -} + init() { + self = .noneVisitRepeatedSfixed64Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ints: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ints] = [ - .noneInts, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedSfixed64Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isA: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isA] = [ - .noneIsA, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeatedSfixed64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqual: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqual] = [ - .noneIsEqual, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSFixed64Field] = [ + .noneVisitRepeatedSfixed64Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqualTo: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqualTo] = [ - .noneIsEqualTo, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isExtension: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isExtension] = [ - .noneIsExtension, - ] -} + enum visitRepeatedSInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedSint32Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isInitializedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isInitializedEnum] = [ - .noneIsInitialized, - ] -} + init() { + self = .noneVisitRepeatedSint32Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.itemTagsEncodedSize: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.itemTagsEncodedSize] = [ - .noneItemTagsEncodedSize, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedSint32Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Iterator: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Iterator] = [ - .noneIterator, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeatedSint32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i_2166136261: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i_2166136261] = [ - .noneI2166136261, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSInt32Field] = [ + .noneVisitRepeatedSint32Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaGenerateEqualsAndHash: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaGenerateEqualsAndHash] = [ - .noneJavaGenerateEqualsAndHash, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaGenericServices] = [ - .noneJavaGenericServices, - ] -} + enum visitRepeatedSInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedSint64Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaMultipleFiles: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaMultipleFiles] = [ - .noneJavaMultipleFiles, - ] -} + init() { + self = .noneVisitRepeatedSint64Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaOuterClassname: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaOuterClassname] = [ - .noneJavaOuterClassname, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedSint64Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaPackage] = [ - .noneJavaPackage, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeatedSint64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaStringCheckUtf8: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaStringCheckUtf8] = [ - .noneJavaStringCheckUtf8, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSInt64Field] = [ + .noneVisitRepeatedSint64Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecoder] = [ - .noneJsondecoder, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingError: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingError] = [ - .noneJsondecodingError, - ] -} + enum visitRepeatedStringField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedStringField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingOptions] = [ - .noneJsondecodingOptions, - ] -} + init() { + self = .noneVisitRepeatedStringField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonEncoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonEncoder] = [ - .noneJsonEncoder, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedStringField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingError: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingError] = [ - .noneJsonencodingError, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeatedStringField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingOptions] = [ - .noneJsonencodingOptions, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedStringField] = [ + .noneVisitRepeatedStringField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingVisitor] = [ - .noneJsonencodingVisitor, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONMapEncodingVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONMapEncodingVisitor] = [ - .noneJsonmapEncodingVisitor, - ] -} + enum visitRepeatedUInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedUint32Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonName] = [ - .noneJsonName, - ] -} + init() { + self = .noneVisitRepeatedUint32Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPath: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPath] = [ - .noneJsonPath, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedUint32Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPaths: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPaths] = [ - .noneJsonPaths, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeatedUint32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONScanner: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONScanner] = [ - .noneJsonscanner, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedUInt32Field] = [ + .noneVisitRepeatedUint32Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonString: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonString] = [ - .noneJsonString, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonText: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonText] = [ - .noneJsonText, - ] -} + enum visitRepeatedUInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitRepeatedUint64Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonUTF8Data: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonUTF8Data] = [ - .noneJsonUtf8Data, - ] -} + init() { + self = .noneVisitRepeatedUint64Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jstype: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jstype] = [ - .noneJstype, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitRepeatedUint64Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.k: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.k] = [ - .noneK, - ] -} + var rawValue: Int { + switch self { + case .noneVisitRepeatedUint64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Key: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Key] = [ - .noneKey, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedUInt64Field] = [ + .noneVisitRepeatedUint64Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.keyField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.keyField] = [ - .noneKeyField, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.KeyType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.KeyType] = [ - .noneKeyType, - ] -} + enum visitSingular: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingular // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.kind: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.kind] = [ - .noneKind, - ] -} + init() { + self = .noneVisitSingular + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.l: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.l] = [ - .noneL, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingular + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.label: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.label] = [ - .noneLabel, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingular: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lazy: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lazy] = [ - .noneLazy, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingular] = [ + .noneVisitSingular, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.leadingComments: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.leadingComments] = [ - .noneLeadingComments, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.leadingDetachedComments: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.leadingDetachedComments] = [ - .noneLeadingDetachedComments, - ] -} + enum visitSingularBoolField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularBoolField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.length: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.length] = [ - .noneLength, - ] -} + init() { + self = .noneVisitSingularBoolField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lessThan: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lessThan] = [ - .noneLessThan, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularBoolField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.letEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.letEnum] = [ - .noneLet, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingularBoolField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lhs: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lhs] = [ - .noneLhs, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularBoolField] = [ + .noneVisitSingularBoolField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.list: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.list] = [ - .noneList, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listOfMessages: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listOfMessages] = [ - .noneListOfMessages, - ] -} + enum visitSingularBytesField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularBytesField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listValue] = [ - .noneListValue, - ] -} + init() { + self = .noneVisitSingularBytesField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndian: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndian] = [ - .noneLittleEndian, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularBytesField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndianBytes: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndianBytes] = [ - .noneLittleEndianBytes, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingularBytesField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.load: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.load] = [ - .noneLoad, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularBytesField] = [ + .noneVisitSingularBytesField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.localHasher: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.localHasher] = [ - .noneLocalHasher, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.location: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.location] = [ - .noneLocation, - ] -} + enum visitSingularDoubleField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularDoubleField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.M: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.M] = [ - .noneM, - ] -} + init() { + self = .noneVisitSingularDoubleField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.major: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.major] = [ - .noneMajor, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularDoubleField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.makeIterator: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.makeIterator] = [ - .noneMakeIterator, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingularDoubleField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapEntry: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapEntry] = [ - .noneMapEntry, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularDoubleField] = [ + .noneVisitSingularDoubleField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapHash: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapHash] = [ - .noneMapHash, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapKeyType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapKeyType] = [ - .noneMapKeyType, - ] -} + enum visitSingularEnumField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularEnumField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapNameResolver: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapNameResolver] = [ - .noneMapNameResolver, - ] -} + init() { + self = .noneVisitSingularEnumField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapToMessages: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapToMessages] = [ - .noneMapToMessages, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularEnumField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapValueType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapValueType] = [ - .noneMapValueType, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingularEnumField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapVisitor] = [ - .noneMapVisitor, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularEnumField] = [ + .noneVisitSingularEnumField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mdayStart: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mdayStart] = [ - .noneMdayStart, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.merge: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.merge] = [ - .noneMerge, - ] -} + enum visitSingularFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularFixed32Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.message: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.message] = [ - .noneMessage, - ] -} + init() { + self = .noneVisitSingularFixed32Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageDepthLimit: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageDepthLimit] = [ - .noneMessageDepthLimit, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularFixed32Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageExtension: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageExtension] = [ - .noneMessageExtension, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingularFixed32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageImplementationBase: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageImplementationBase] = [ - .noneMessageImplementationBase, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularFixed32Field] = [ + .noneVisitSingularFixed32Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageOptions] = [ - .noneMessageOptions, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageSet: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageSet] = [ - .noneMessageSet, - ] -} + enum visitSingularFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularFixed64Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageSetWireFormat: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageSetWireFormat] = [ - .noneMessageSetWireFormat, - ] -} + init() { + self = .noneVisitSingularFixed64Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageType] = [ - .noneMessageType, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularFixed64Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Method: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Method] = [ - .noneMethod, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingularFixed64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MethodDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MethodDescriptorProto] = [ - .noneMethodDescriptorProto, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularFixed64Field] = [ + .noneVisitSingularFixed64Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MethodOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MethodOptions] = [ - .noneMethodOptions, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.methods: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.methods] = [ - .noneMethods, - ] -} + enum visitSingularFloatField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularFloatField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.minor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.minor] = [ - .noneMinor, - ] -} + init() { + self = .noneVisitSingularFloatField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Mixin: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Mixin] = [ - .noneMixin, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularFloatField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mixins: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mixins] = [ - .noneMixins, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingularFloatField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.modifier: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.modifier] = [ - .noneModifier, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularFloatField] = [ + .noneVisitSingularFloatField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.modify: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.modify] = [ - .noneModify, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.month: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.month] = [ - .noneMonth, - ] -} + enum visitSingularGroupField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularGroupField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.msgExtension: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.msgExtension] = [ - .noneMsgExtension, - ] -} + init() { + self = .noneVisitSingularGroupField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mutating: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mutating] = [ - .noneMutating, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularGroupField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.n: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.n] = [ - .oneN, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingularGroupField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.name: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.name] = [ - .noneName, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularGroupField] = [ + .noneVisitSingularGroupField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameDescription: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameDescription] = [ - .noneNameDescription, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameMap: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameMap] = [ - .noneNameMap, - ] -} + enum visitSingularInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularInt32Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NamePart: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NamePart] = [ - .noneNamePart, - ] -} + init() { + self = .noneVisitSingularInt32Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nameResolver: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nameResolver] = [ - .noneNameResolver, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularInt32Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.names: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.names] = [ - .noneNames, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingularInt32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nanos: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nanos] = [ - .noneNanos, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularInt32Field] = [ + .noneVisitSingularInt32Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeBytes: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeBytes] = [ - .noneNativeBytes, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeEndianBytes: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeEndianBytes] = [ - .noneNativeEndianBytes, - ] -} + enum visitSingularInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularInt64Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.negativeIntValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.negativeIntValue] = [ - .noneNegativeIntValue, - ] -} + init() { + self = .noneVisitSingularInt64Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nestedType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nestedType] = [ - .noneNestedType, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularInt64Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newL: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newL] = [ - .noneNewL, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingularInt64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newList: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newList] = [ - .noneNewList, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularInt64Field] = [ + .noneVisitSingularInt64Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newValue] = [ - .noneNewValue, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextByte: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextByte] = [ - .noneNextByte, - ] -} + enum visitSingularMessageField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularMessageField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextFieldNumber: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextFieldNumber] = [ - .noneNextFieldNumber, - ] -} + init() { + self = .noneVisitSingularMessageField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilEnum] = [ - .noneNil, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularMessageField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilLiteral] = [ - .noneNilLiteral, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingularMessageField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.noStandardDescriptorAccessor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.noStandardDescriptorAccessor] = [ - .noneNoStandardDescriptorAccessor, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularMessageField] = [ + .noneVisitSingularMessageField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nullValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nullValue] = [ - .noneNullValue, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.number: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.number] = [ - .noneNumber, - ] -} + enum visitSingularSFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularSfixed32Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.numberValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.numberValue] = [ - .noneNumberValue, - ] -} + init() { + self = .noneVisitSingularSfixed32Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.objcClassPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.objcClassPrefix] = [ - .noneObjcClassPrefix, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularSfixed32Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.of: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.of] = [ - .noneOf, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingularSfixed32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofDecl: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofDecl] = [ - .noneOneofDecl, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSFixed32Field] = [ + .noneVisitSingularSfixed32Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneofDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneofDescriptorProto] = [ - .noneOneofDescriptorProto, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofIndex: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofIndex] = [ - .noneOneofIndex, - ] -} + enum visitSingularSFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularSfixed64Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneofOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneofOptions] = [ - .noneOneofOptions, - ] -} + init() { + self = .noneVisitSingularSfixed64Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofs: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofs] = [ - .noneOneofs, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularSfixed64Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneOf_Kind: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneOf_Kind] = [ - .noneOneOfKind, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingularSfixed64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.optimizeFor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.optimizeFor] = [ - .noneOptimizeFor, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSFixed64Field] = [ + .noneVisitSingularSfixed64Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptimizeMode: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptimizeMode] = [ - .noneOptimizeMode, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Option: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Option] = [ - .noneOption, - ] -} + enum visitSingularSInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularSint32Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalEnumExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalEnumExtensionField] = [ - .noneOptionalEnumExtensionField, - ] -} + init() { + self = .noneVisitSingularSint32Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalExtensionField] = [ - .noneOptionalExtensionField, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularSint32Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalGroupExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalGroupExtensionField] = [ - .noneOptionalGroupExtensionField, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingularSint32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalMessageExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalMessageExtensionField] = [ - .noneOptionalMessageExtensionField, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSInt32Field] = [ + .noneVisitSingularSint32Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.options: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.options] = [ - .noneOptions, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.other: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.other] = [ - .noneOther, - ] -} + enum visitSingularSInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularSint64Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.others: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.others] = [ - .noneOthers, - ] -} + init() { + self = .noneVisitSingularSint64Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.out: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.out] = [ - .noneOut, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularSint64Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.outputType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.outputType] = [ - .noneOutputType, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingularSint64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.p: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.p] = [ - .noneP, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSInt64Field] = [ + .noneVisitSingularSint64Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.package: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.package] = [ - .nonePackage, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.packed: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.packed] = [ - .nonePacked, - ] -} + enum visitSingularStringField: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularStringField // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedEnumExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedEnumExtensionField] = [ - .nonePackedEnumExtensionField, - ] -} + init() { + self = .noneVisitSingularStringField + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedExtensionField] = [ - .nonePackedExtensionField, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularStringField + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.padding: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.padding] = [ - .nonePadding, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingularStringField: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parent: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parent] = [ - .noneParent, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularStringField] = [ + .noneVisitSingularStringField, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parse: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parse] = [ - .noneParse, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.partial: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.partial] = [ - .nonePartial, - ] -} + enum visitSingularUInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularUint32Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.path: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.path] = [ - .nonePath, - ] -} + init() { + self = .noneVisitSingularUint32Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.paths: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.paths] = [ - .nonePaths, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularUint32Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payload: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payload] = [ - .nonePayload, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingularUint32Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payloadSize: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payloadSize] = [ - .nonePayloadSize, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularUInt32Field] = [ + .noneVisitSingularUint32Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpClassPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpClassPrefix] = [ - .nonePhpClassPrefix, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpGenericServices] = [ - .nonePhpGenericServices, - ] -} + enum visitSingularUInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitSingularUint64Field // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpMetadataNamespace: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpMetadataNamespace] = [ - .nonePhpMetadataNamespace, - ] -} + init() { + self = .noneVisitSingularUint64Field + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpNamespace: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpNamespace] = [ - .nonePhpNamespace, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitSingularUint64Field + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pointer: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pointer] = [ - .nonePointer, - ] -} + var rawValue: Int { + switch self { + case .noneVisitSingularUint64Field: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pos: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pos] = [ - .nonePos, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularUInt64Field] = [ + .noneVisitSingularUint64Field, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.positiveIntValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.positiveIntValue] = [ - .nonePositiveIntValue, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.prefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.prefix] = [ - .nonePrefix, - ] -} + enum visitUnknown: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVisitUnknown // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preserveProtoFieldNames: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preserveProtoFieldNames] = [ - .nonePreserveProtoFieldNames, - ] -} + init() { + self = .noneVisitUnknown + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preTraverse: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preTraverse] = [ - .nonePreTraverse, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVisitUnknown + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.printUnknownFields: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.printUnknownFields] = [ - .nonePrintUnknownFields, - ] -} + var rawValue: Int { + switch self { + case .noneVisitUnknown: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto2: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto2] = [ - .noneProto2, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitUnknown] = [ + .noneVisitUnknown, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3DefaultValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3DefaultValue] = [ - .noneProto3DefaultValue, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3Optional: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3Optional] = [ - .noneProto3Optional, - ] -} + enum Void: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneVoid // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck] = [ - .noneProtobufApiversionCheck, - ] -} + init() { + self = .noneVoid + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_2: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_2] = [ - .noneProtobufApiversion2, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneVoid + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBool: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBool] = [ - .noneProtobufBool, - ] -} + var rawValue: Int { + switch self { + case .noneVoid: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBytes: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBytes] = [ - .noneProtobufBytes, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Void] = [ + .noneVoid, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufDouble: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufDouble] = [ - .noneProtobufDouble, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufEnumMap: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufEnumMap] = [ - .noneProtobufEnumMap, - ] -} + enum wasDecoded: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWasDecoded // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobufExtension: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobufExtension] = [ - .noneProtobufExtension, - ] -} + init() { + self = .noneWasDecoded + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed32: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed32] = [ - .noneProtobufFixed32, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWasDecoded + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed64: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed64] = [ - .noneProtobufFixed64, - ] -} + var rawValue: Int { + switch self { + case .noneWasDecoded: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFloat: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFloat] = [ - .noneProtobufFloat, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.wasDecoded] = [ + .noneWasDecoded, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt32: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt32] = [ - .noneProtobufInt32, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt64: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt64] = [ - .noneProtobufInt64, - ] -} + enum weak: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWeak // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMap: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMap] = [ - .noneProtobufMap, - ] -} + init() { + self = .noneWeak + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMessageMap: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMessageMap] = [ - .noneProtobufMessageMap, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWeak + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed32: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed32] = [ - .noneProtobufSfixed32, - ] -} + var rawValue: Int { + switch self { + case .noneWeak: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed64: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed64] = [ - .noneProtobufSfixed64, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.weak] = [ + .noneWeak, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt32: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt32] = [ - .noneProtobufSint32, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt64: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt64] = [ - .noneProtobufSint64, - ] -} + enum weakDependency: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWeakDependency // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufString: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufString] = [ - .noneProtobufString, - ] -} + init() { + self = .noneWeakDependency + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt32: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt32] = [ - .noneProtobufUint32, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWeakDependency + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt64: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt64] = [ - .noneProtobufUint64, - ] -} + var rawValue: Int { + switch self { + case .noneWeakDependency: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues] = [ - .noneProtobufExtensionFieldValues, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.weakDependency] = [ + .noneWeakDependency, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_fieldNumber: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_fieldNumber] = [ - .noneProtobufFieldNumber, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo] = [ - .noneProtobufGeneratedIsEqualTo, - ] -} + enum whereEnum: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWhere // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_nameMap: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_nameMap] = [ - .noneProtobufNameMap, - ] -} + init() { + self = .noneWhere + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_newField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_newField] = [ - .noneProtobufNewField, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWhere + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_package: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_package] = [ - .noneProtobufPackage, - ] -} + var rawValue: Int { + switch self { + case .noneWhere: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protocolEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protocolEnum] = [ - .noneProtocol, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.whereEnum] = [ + .noneWhere, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoFieldName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoFieldName] = [ - .noneProtoFieldName, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoMessageNameEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoMessageNameEnum] = [ - .noneProtoMessageName, - ] -} + enum wireFormat: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWireFormat // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtoNameProviding: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtoNameProviding] = [ - .noneProtoNameProviding, - ] -} + init() { + self = .noneWireFormat + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoPaths: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoPaths] = [ - .noneProtoPaths, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWireFormat + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicEnum] = [ - .nonePublic, - ] -} + var rawValue: Int { + switch self { + case .noneWireFormat: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicDependency: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicDependency] = [ - .nonePublicDependency, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.wireFormat] = [ + .noneWireFormat, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBoolValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBoolValue] = [ - .nonePutBoolValue, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBytesValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBytesValue] = [ - .nonePutBytesValue, - ] -} + enum with: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWith // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putDoubleValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putDoubleValue] = [ - .nonePutDoubleValue, - ] -} + init() { + self = .noneWith + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putEnumValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putEnumValue] = [ - .nonePutEnumValue, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWith + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt32: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt32] = [ - .nonePutFixedUint32, - ] -} + var rawValue: Int { + switch self { + case .noneWith: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt64: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt64] = [ - .nonePutFixedUint64, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.with] = [ + .noneWith, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFloatValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFloatValue] = [ - .nonePutFloatValue, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putInt64: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putInt64] = [ - .nonePutInt64, - ] -} + enum withUnsafeBytes: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWithUnsafeBytes // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putStringValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putStringValue] = [ - .nonePutStringValue, - ] -} + init() { + self = .noneWithUnsafeBytes + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64] = [ - .nonePutUint64, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWithUnsafeBytes + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64Hex: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64Hex] = [ - .nonePutUint64Hex, - ] -} + var rawValue: Int { + switch self { + case .noneWithUnsafeBytes: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putVarInt: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putVarInt] = [ - .nonePutVarInt, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.withUnsafeBytes] = [ + .noneWithUnsafeBytes, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putZigZagVarInt: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putZigZagVarInt] = [ - .nonePutZigZagVarInt, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pyGenericServices: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pyGenericServices] = [ - .nonePyGenericServices, - ] -} + enum withUnsafeMutableBytes: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWithUnsafeMutableBytes // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rawChars: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rawChars] = [ - .noneRawChars, - ] -} + init() { + self = .noneWithUnsafeMutableBytes + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawRepresentable: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawRepresentable] = [ - .noneRawRepresentable, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWithUnsafeMutableBytes + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawValue] = [ - .noneRawValue, - ] -} + var rawValue: Int { + switch self { + case .noneWithUnsafeMutableBytes: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.read4HexDigits: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.read4HexDigits] = [ - .noneRead4HexDigits, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.withUnsafeMutableBytes] = [ + .noneWithUnsafeMutableBytes, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.register: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.register] = [ - .noneRegister, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField] = [ - .noneRepeatedEnumExtensionField, - ] -} + enum work: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWork // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedExtensionField] = [ - .noneRepeatedExtensionField, - ] -} + init() { + self = .noneWork + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField] = [ - .noneRepeatedGroupExtensionField, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWork + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField] = [ - .noneRepeatedMessageExtensionField, - ] -} + var rawValue: Int { + switch self { + case .noneWork: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestStreaming: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestStreaming] = [ - .noneRequestStreaming, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.work] = [ + .noneWork, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestTypeURL: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestTypeURL] = [ - .noneRequestTypeURL, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requiredSize: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requiredSize] = [ - .noneRequiredSize, - ] -} + enum Wrapped: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWrapped // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.reservedName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.reservedName] = [ - .noneReservedName, - ] -} + init() { + self = .noneWrapped + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.reservedRange: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.reservedRange] = [ - .noneReservedRange, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWrapped + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseStreaming: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseStreaming] = [ - .noneResponseStreaming, - ] -} + var rawValue: Int { + switch self { + case .noneWrapped: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseTypeURL: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseTypeURL] = [ - .noneResponseTypeURL, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Wrapped] = [ + .noneWrapped, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.result: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.result] = [ - .noneResult, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rethrowsEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rethrowsEnum] = [ - .noneRethrows, - ] -} + enum WrappedType: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWrappedType // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.returnEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.returnEnum] = [ - .noneReturn, - ] -} + init() { + self = .noneWrappedType + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ReturnType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ReturnType] = [ - .noneReturnType, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWrappedType + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.revision: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.revision] = [ - .noneRevision, - ] -} + var rawValue: Int { + switch self { + case .noneWrappedType: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rhs: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rhs] = [ - .noneRhs, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.WrappedType] = [ + .noneWrappedType, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.root: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.root] = [ - .noneRoot, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rubyPackage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rubyPackage] = [ - .noneRubyPackage, - ] -} + enum wrappedValue: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWrappedValue // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.s: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.s] = [ - .noneS, - ] -} + init() { + self = .noneWrappedValue + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawBackslash: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawBackslash] = [ - .noneSawBackslash, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWrappedValue + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection4Characters: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection4Characters] = [ - .noneSawSection4Characters, - ] -} + var rawValue: Int { + switch self { + case .noneWrappedValue: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection5Characters: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection5Characters] = [ - .noneSawSection5Characters, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.wrappedValue] = [ + .noneWrappedValue, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.scanner: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.scanner] = [ - .noneScanner, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.seconds: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.seconds] = [ - .noneSeconds, - ] -} + enum written: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneWritten // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.selfEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.selfEnum] = [ - .noneSelf, - ] -} + init() { + self = .noneWritten + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.separator: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.separator] = [ - .noneSeparator, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneWritten + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serialize: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serialize] = [ - .noneSerialize, - ] -} + var rawValue: Int { + switch self { + case .noneWritten: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedData: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedData] = [ - .noneSerializedData, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.written] = [ + .noneWritten, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedSize: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedSize] = [ - .noneSerializedSize, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serverStreaming: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serverStreaming] = [ - .noneServerStreaming, - ] -} + enum yday: SwiftProtobuf.Enum, Swift.CaseIterable { + typealias RawValue = Int + case noneYday // = 0 + case UNRECOGNIZED(Int) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.service: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.service] = [ - .noneService, - ] -} + init() { + self = .noneYday + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ServiceDescriptorProto: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ServiceDescriptorProto] = [ - .noneServiceDescriptorProto, - ] -} + init?(rawValue: Int) { + switch rawValue { + case 0: self = .noneYday + default: self = .UNRECOGNIZED(rawValue) + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ServiceOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ServiceOptions] = [ - .noneServiceOptions, - ] -} + var rawValue: Int { + switch self { + case .noneYday: return 0 + case .UNRECOGNIZED(let i): return i + } + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.set: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.set] = [ - .noneSet, - ] -} + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.yday] = [ + .noneYday, + ] -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.setExtensionValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.setExtensionValue] = [ - .noneSetExtensionValue, - ] -} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.shift: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.shift] = [ - .noneShift, - ] + init() {} } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SimpleExtensionMap: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SimpleExtensionMap] = [ - .noneSimpleExtensionMap, - ] -} +// MARK: - Code below here is support for the SwiftProtobuf runtime. -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sizer: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sizer] = [ - .noneSizer, - ] -} +fileprivate let _protobuf_package = "swift_proto_testing.generated" -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.source: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.source] = [ - .noneSource, - ] -} +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GeneratedSwiftReservedEnums" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceCodeInfo: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceCodeInfo] = [ - .noneSourceCodeInfo, - ] -} + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceContext: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceContext] = [ - .noneSourceContext, - ] -} + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceEncoding: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceEncoding] = [ - .noneSourceEncoding, - ] + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceFile: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceFile] = [ - .noneSourceFile, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.addPath: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_addPath\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.span: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.span] = [ - .noneSpan, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.adjusted: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_adjusted\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.split: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.split] = [ - .noneSplit, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.aggregateValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_aggregateValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.start: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.start] = [ - .noneStart, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.allCases: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_allCases\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArray: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArray] = [ - .noneStartArray, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.allowAlias: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_allowAlias\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArrayObject: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArrayObject] = [ - .noneStartArrayObject, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.alwaysPrintEnumsAsInts: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_alwaysPrintEnumsAsInts\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startField] = [ - .noneStartField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.alwaysPrintInt64sAsNumbers: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_alwaysPrintInt64sAsNumbers\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startIndex: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startIndex] = [ - .noneStartIndex, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.annotation: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_annotation\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startMessageField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startMessageField] = [ - .noneStartMessageField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.any: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_any\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startObject: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startObject] = [ - .noneStartObject, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AnyExtensionField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startRegularField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startRegularField] = [ - .noneStartRegularField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyMessageExtension: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AnyMessageExtension\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.state: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.state] = [ - .noneState, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyMessageStorage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AnyMessageStorage\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.staticEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.staticEnum] = [ - .noneStatic, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyUnpackError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AnyUnpackError\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StaticString: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StaticString] = [ - .noneStaticString, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.append: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_append\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.storage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.storage] = [ - .noneStorage, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.appended: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_appended\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringEnum] = [ - .noneString, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.appendUIntHex: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_appendUIntHex\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringLiteral] = [ - .noneStringLiteral, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.appendUnknown: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_appendUnknown\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringLiteralType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringLiteralType] = [ - .noneStringLiteralType, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.areAllInitialized: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_areAllInitialized\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringResult: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringResult] = [ - .noneStringResult, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Array: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Array\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringValue] = [ - .noneStringValue, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.arrayDepth: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_arrayDepth\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structEnum] = [ - .noneStruct, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.arrayLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_arrayLiteral\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structValue: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structValue] = [ - .noneStructValue, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.arraySeparator: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_arraySeparator\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subDecoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subDecoder] = [ - .noneSubDecoder, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.asEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_as\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subscriptEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subscriptEnum] = [ - .noneSubscript, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.asciiOpenCurlyBracket: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_asciiOpenCurlyBracket\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subVisitor] = [ - .noneSubVisitor, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.asciiZero: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_asciiZero\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Swift: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Swift] = [ - .noneSwift, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.async: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_async\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.swiftPrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.swiftPrefix] = [ - .noneSwiftPrefix, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AsyncIterator: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AsyncIterator\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SwiftProtobufEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SwiftProtobufEnum] = [ - .noneSwiftProtobuf, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AsyncIteratorProtocol: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AsyncIteratorProtocol\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.syntax: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.syntax] = [ - .noneSyntax, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AsyncMessageSequence: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AsyncMessageSequence\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.T: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.T] = [ - .noneT, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.available: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_available\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tag: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tag] = [ - .noneTag, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.b: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_b\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.terminator: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.terminator] = [ - .noneTerminator, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Base: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Base\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.testDecoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.testDecoder] = [ - .noneTestDecoder, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.base64Values: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_base64Values\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.text: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.text] = [ - .noneText, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.baseAddress: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_baseAddress\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textDecoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textDecoder] = [ - .noneTextDecoder, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BaseType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BaseType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecoder: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecoder] = [ - .noneTextFormatDecoder, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.begin: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_begin\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingError: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingError] = [ - .noneTextFormatDecodingError, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binary: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_binary\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingOptions] = [ - .noneTextFormatDecodingOptions, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryDecoder\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingOptions] = [ - .noneTextFormatEncodingOptions, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryDecoding\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingVisitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingVisitor] = [ - .noneTextFormatEncodingVisitor, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecodingError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryDecodingError\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textFormatString: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textFormatString] = [ - .noneTextFormatString, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecodingOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryDecodingOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.throwsEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.throwsEnum] = [ - .noneThrows, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDelimited: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryDelimited\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeInterval: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeInterval] = [ - .noneTimeInterval, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncoder\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSince1970: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSince1970] = [ - .noneTimeIntervalSince1970, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncodingError\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate] = [ - .noneTimeIntervalSinceReferenceDate, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetSizeVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncodingMessageSetSizeVisitor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Timestamp: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Timestamp] = [ - .noneTimestamp, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncodingMessageSetVisitor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.total: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.total] = [ - .noneTotal, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncodingOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalArrayDepth: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalArrayDepth] = [ - .noneTotalArrayDepth, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingSizeVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncodingSizeVisitor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalSize: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalSize] = [ - .noneTotalSize, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncodingVisitor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trailingComments: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trailingComments] = [ - .noneTrailingComments, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binaryOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_binaryOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.traverseEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.traverseEnum] = [ - .noneTraverse, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binaryProtobufDelimitedMessages: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_binaryProtobufDelimitedMessages\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trueEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trueEnum] = [ - .noneTrue, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryStreamDecoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryStreamDecoding\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tryEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tryEnum] = [ - .noneTry, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binaryStreamDecodingError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_binaryStreamDecodingError\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.type: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.type] = [ - .noneType, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bitPattern: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_bitPattern\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typealiasEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typealiasEnum] = [ - .noneTypealias, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.body: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_body\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TypeEnumEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TypeEnumEnum] = [ - .noneTypeEnum, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BoolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Bool\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeName: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeName] = [ - .noneTypeName, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.booleanLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_booleanLiteral\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typePrefix: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typePrefix] = [ - .noneTypePrefix, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BooleanLiteralType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BooleanLiteralType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeStart: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeStart] = [ - .noneTypeStart, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.boolValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_boolValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeUnknown: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeUnknown] = [ - .noneTypeUnknown, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.buffer: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_buffer\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeURL: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeURL] = [ - .noneTypeURL, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.byte: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_byte\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Enum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Enum] = [ - .noneUint32, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytecode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_bytecode\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Value] = [ - .noneUint32Value, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BytecodeReader: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BytecodeReader\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Enum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Enum] = [ - .noneUint64, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_bytes\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Value] = [ - .noneUint64Value, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytesInGroup: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_bytesInGroup\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt8: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt8] = [ - .noneUint8, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytesNeeded: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_bytesNeeded\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalarLiteral: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalarLiteral] = [ - .noneUnicodeScalarLiteral, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytesRead: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_bytesRead\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarLiteralType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarLiteralType] = [ - .noneUnicodeScalarLiteralType, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.c: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_c\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalars: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalars] = [ - .noneUnicodeScalars, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.canonical: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_canonical\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarView: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarView] = [ - .noneUnicodeScalarView, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.capitalizeNext: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_capitalizeNext\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uninterpretedOption: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uninterpretedOption] = [ - .noneUninterpretedOption, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.cardinality: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_cardinality\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.union: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.union] = [ - .noneUnion, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.CaseIterable: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_CaseIterable\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uniqueStorage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uniqueStorage] = [ - .noneUniqueStorage, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.castedValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_castedValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknown: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknown] = [ - .noneUnknown, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ccEnableArenas: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ccEnableArenas\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknownFieldsEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknownFieldsEnum] = [ - .noneUnknownFields, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ccGenericServices: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ccGenericServices\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnknownStorage: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnknownStorage] = [ - .noneUnknownStorage, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Character: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Character\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unpackTo: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unpackTo] = [ - .noneUnpackTo, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.chars: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_chars\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeBufferPointer: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeBufferPointer] = [ - .noneUnsafeBufferPointer, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.checkProgramFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_checkProgramFormat\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutablePointer: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutablePointer] = [ - .noneUnsafeMutablePointer, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.chunk: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_chunk\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawBufferPointer: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawBufferPointer] = [ - .noneUnsafeMutableRawBufferPointer, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.classEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_class\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawPointer: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawPointer] = [ - .noneUnsafeMutableRawPointer, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearAggregateValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearAggregateValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawBufferPointer: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawBufferPointer] = [ - .noneUnsafeRawBufferPointer, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearAllowAlias: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearAllowAlias\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawPointer: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawPointer] = [ - .noneUnsafeRawPointer, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearBegin: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearBegin\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.updatedOptions: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.updatedOptions] = [ - .noneUpdatedOptions, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCcEnableArenas: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearCcEnableArenas\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.url: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.url] = [ - .noneURL, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCcGenericServices: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearCcGenericServices\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8] = [ - .noneUtf8, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearClientStreaming: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearClientStreaming\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8Ptr: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8Ptr] = [ - .noneUtf8Ptr, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCsharpNamespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearCsharpNamespace\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8ToDouble: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8ToDouble] = [ - .noneUtf8ToDouble, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCtype: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearCtype\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UTF8View: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UTF8View] = [ - .noneUtf8View, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDebugRedact: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDebugRedact\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.v: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.v] = [ - .noneV, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDefaultSymbolVisibility: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDefaultSymbolVisibility\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.value: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.value] = [ - .noneValue, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDefaultValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDefaultValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.valueField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.valueField] = [ - .noneValueField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDeprecated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDeprecated\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.values: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.values] = [ - .noneValues, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDeprecatedLegacyJsonFieldConflicts: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDeprecatedLegacyJsonFieldConflicts\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ValueType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ValueType] = [ - .noneValueType, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDeprecationWarning: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDeprecationWarning\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.varEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.varEnum] = [ - .noneVar, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDoubleValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDoubleValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Version: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Version] = [ - .noneVersion, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEdition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEdition\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.versionString: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.versionString] = [ - .noneVersionString, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEditionDeprecated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEditionDeprecated\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFields: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFields] = [ - .noneVisitExtensionFields, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEditionIntroduced: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEditionIntroduced\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFieldsAsMessageSet: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFieldsAsMessageSet] = [ - .noneVisitExtensionFieldsAsMessageSet, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEditionRemoved: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEditionRemoved\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitMapField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitMapField] = [ - .noneVisitMapField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEnd: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEnd\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitor: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitor] = [ - .noneVisitor, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEnforceNamingStyle: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEnforceNamingStyle\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPacked: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPacked] = [ - .noneVisitPacked, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEnumType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEnumType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedBoolField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedBoolField] = [ - .noneVisitPackedBoolField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearExtendee: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearExtendee\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedDoubleField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedDoubleField] = [ - .noneVisitPackedDoubleField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearExtensionValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearExtensionValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedEnumField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedEnumField] = [ - .noneVisitPackedEnumField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFeatures: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearFeatures\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed32Field] = [ - .noneVisitPackedFixed32Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFeatureSupport: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearFeatureSupport\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed64Field] = [ - .noneVisitPackedFixed64Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFieldPresence: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearFieldPresence\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFloatField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFloatField] = [ - .noneVisitPackedFloatField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFixedFeatures: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearFixedFeatures\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt32Field] = [ - .noneVisitPackedInt32Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFullName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearFullName\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt64Field] = [ - .noneVisitPackedInt64Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearGoPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearGoPackage\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed32Field] = [ - .noneVisitPackedSfixed32Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearIdempotencyLevel: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearIdempotencyLevel\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed64Field] = [ - .noneVisitPackedSfixed64Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearIdentifierValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearIdentifierValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt32Field] = [ - .noneVisitPackedSint32Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearInputType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearInputType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt64Field] = [ - .noneVisitPackedSint64Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearIsExtension: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearIsExtension\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt32Field] = [ - .noneVisitPackedUint32Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaGenerateEqualsAndHash: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJavaGenerateEqualsAndHash\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt64Field] = [ - .noneVisitPackedUint64Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaGenericServices: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJavaGenericServices\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeated: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeated] = [ - .noneVisitRepeated, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaMultipleFiles: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJavaMultipleFiles\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBoolField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBoolField] = [ - .noneVisitRepeatedBoolField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaOuterClassname: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJavaOuterClassname\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBytesField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBytesField] = [ - .noneVisitRepeatedBytesField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJavaPackage\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedDoubleField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedDoubleField] = [ - .noneVisitRepeatedDoubleField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaStringCheckUtf8: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJavaStringCheckUtf8\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedEnumField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedEnumField] = [ - .noneVisitRepeatedEnumField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJsonFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJsonFormat\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed32Field] = [ - .noneVisitRepeatedFixed32Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJsonName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJsonName\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed64Field] = [ - .noneVisitRepeatedFixed64Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJstype: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJstype\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFloatField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFloatField] = [ - .noneVisitRepeatedFloatField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearLabel: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearLabel\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedGroupField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedGroupField] = [ - .noneVisitRepeatedGroupField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearLazy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearLazy\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt32Field] = [ - .noneVisitRepeatedInt32Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearLeadingComments: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearLeadingComments\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt64Field] = [ - .noneVisitRepeatedInt64Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMapEntry: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearMapEntry\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedMessageField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedMessageField] = [ - .noneVisitRepeatedMessageField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMaximumEdition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearMaximumEdition\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed32Field] = [ - .noneVisitRepeatedSfixed32Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMessageEncoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearMessageEncoding\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed64Field] = [ - .noneVisitRepeatedSfixed64Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMessageSetWireFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearMessageSetWireFormat\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt32Field] = [ - .noneVisitRepeatedSint32Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMinimumEdition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearMinimumEdition\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt64Field] = [ - .noneVisitRepeatedSint64Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearName\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedStringField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedStringField] = [ - .noneVisitRepeatedStringField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNamePart: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearNamePart\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt32Field] = [ - .noneVisitRepeatedUint32Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNegativeIntValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearNegativeIntValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt64Field] = [ - .noneVisitRepeatedUint64Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNoStandardDescriptorAccessor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearNoStandardDescriptorAccessor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingular: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingular] = [ - .noneVisitSingular, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearNumber\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBoolField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBoolField] = [ - .noneVisitSingularBoolField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearObjcClassPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearObjcClassPrefix\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBytesField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBytesField] = [ - .noneVisitSingularBytesField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOneofIndex: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearOneofIndex\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularDoubleField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularDoubleField] = [ - .noneVisitSingularDoubleField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOptimizeFor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearOptimizeFor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularEnumField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularEnumField] = [ - .noneVisitSingularEnumField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed32Field] = [ - .noneVisitSingularFixed32Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOutputType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearOutputType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed64Field] = [ - .noneVisitSingularFixed64Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOverridableFeatures: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearOverridableFeatures\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFloatField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFloatField] = [ - .noneVisitSingularFloatField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPackage\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularGroupField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularGroupField] = [ - .noneVisitSingularGroupField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPacked: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPacked\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt32Field] = [ - .noneVisitSingularInt32Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPhpClassPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPhpClassPrefix\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt64Field] = [ - .noneVisitSingularInt64Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPhpMetadataNamespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPhpMetadataNamespace\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularMessageField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularMessageField] = [ - .noneVisitSingularMessageField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPhpNamespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPhpNamespace\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed32Field] = [ - .noneVisitSingularSfixed32Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPositiveIntValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPositiveIntValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed64Field] = [ - .noneVisitSingularSfixed64Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearProto3Optional: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearProto3Optional\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt32Field] = [ - .noneVisitSingularSint32Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPyGenericServices: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPyGenericServices\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt64Field] = [ - .noneVisitSingularSint64Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRemovalError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearRemovalError\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularStringField: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularStringField] = [ - .noneVisitSingularStringField, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRepeated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearRepeated\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt32Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt32Field] = [ - .noneVisitSingularUint32Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRepeatedFieldEncoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearRepeatedFieldEncoding\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt64Field: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt64Field] = [ - .noneVisitSingularUint64Field, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearReserved: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearReserved\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitUnknown: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitUnknown] = [ - .noneVisitUnknown, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRetention: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearRetention\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wasDecoded: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wasDecoded] = [ - .noneWasDecoded, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRubyPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearRubyPackage\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.weak: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.weak] = [ - .noneWeak, - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSemantic: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearSemantic\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.weakDependency: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.weakDependency] = [ - .noneWeakDependency, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.whereEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.whereEnum] = [ - .noneWhere, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wireFormat: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wireFormat] = [ - .noneWireFormat, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.with: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.with] = [ - .noneWith, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeBytes: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeBytes] = [ - .noneWithUnsafeBytes, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeMutableBytes: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeMutableBytes] = [ - .noneWithUnsafeMutableBytes, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.work: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.work] = [ - .noneWork, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.WrappedType: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.WrappedType] = [ - .noneWrappedType, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.written: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.written] = [ - .noneWritten, - ] -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.yday: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.yday] = [ - .noneYday, - ] -} - -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.adjusted: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.aggregateValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allCases: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allowAlias: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.alwaysPrintEnumsAsInts: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.annotation: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.any: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageStorage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyUnpackError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Api: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appended: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUIntHex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUnknown: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.areAllInitialized: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.array: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayDepth: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arraySeparator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiOpenCurlyBracket: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiZero: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.available: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.b: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.base64Values: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.baseAddress: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BaseType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.begin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binary: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDelimited: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetSizeVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingSizeVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binaryOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.body: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BoolEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.booleanLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BooleanLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.boolValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesInGroup: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesRead: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BytesValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.c: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.capitalizeNext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.cardinality: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ccEnableArenas: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ccGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Character: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.chars: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.classEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearAggregateValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearAllowAlias: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearBegin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCcEnableArenas: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCcGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearClientStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCsharpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCtype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDefaultValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDeprecated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDoubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearEnd: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtendee: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtensionValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearGoPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIdempotencyLevel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIdentifierValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearInputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIsExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaGenerateEqualsAndHash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaMultipleFiles: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaOuterClassname: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaStringCheckUtf8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJsonName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJstype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLabel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLazy: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLeadingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearMapEntry: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearMessageSetWireFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNamePart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNegativeIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNoStandardDescriptorAccessor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearObjcClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOneofIndex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOptimizeFor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOutputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPacked: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpMetadataNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPositiveIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearProto3Optional: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPyGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearRubyPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearServerStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceContext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceFile: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearStart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearStringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSwiftPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSyntax: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearTrailingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearTypeName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearWeak: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clientStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codePoint: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codeUnits: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Collection: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.com: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.comma: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.contentsOf: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ContiguousBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.count: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.countVarintsInBuffer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.csharpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ctype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.customCodable: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.CustomDebugStringConvertible: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.d: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DataEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dataResult: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.date: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daySec: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daysSinceEpoch: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.debugDescriptionEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoded: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodedFromJSONNull: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionFieldsAsMessageSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeJSON: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMapField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMessageEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBytesField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedGroupField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedStringField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingular: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBytesField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularGroupField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularStringField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeTextFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultAnyTypeURLPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dependency: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.deprecated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.descriptionEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Dictionary: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dictionaryLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit0: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit1: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitCount: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digits: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardableResult: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardUnknownFields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.distance: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.double: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.doubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Duration: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.E: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Element: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.elements: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitExtensionFieldName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Empty: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emptyData: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeAsBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoded: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedJSONString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.end: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endArray: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endObject: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endRegularField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumReservedRange: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumvalue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumValueDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumValueOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Equatable: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Error: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByArrayLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByDictionaryLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendedGraphemeClusterLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtendedGraphemeClusterLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendee: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensibleMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionFieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionFieldValueSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionRange: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionRangeOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extras: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.F: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.falseEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldData: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldMask: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNameCount: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumberForProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldTag: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.file: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileDescriptorSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fileName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.filter: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.first: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.firstItem: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.float: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.floatLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forMessageName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.formUnion: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forReadingFrom: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forTypeURL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ForwardParser: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forWritingInto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.from: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii2: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii4: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromByteOffset: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromHexDigit: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.funcEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.G: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.GeneratedCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.get: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.getExtensionValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.googleapis: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Any: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Api: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BoolValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BytesValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DoubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Duration: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Empty: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Enum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ExtensionRangeOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldMask: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FloatValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_GeneratedCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int32Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int64Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ListValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MessageOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Method: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Mixin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_NullValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Option: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceContext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_StringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Struct: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Syntax: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Timestamp: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Type: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt32Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt64Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UninterpretedOption: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.goPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.group: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupFieldNumberStack: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.h: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hadOneofValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.handleConflictingOneOf: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasAggregateValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasAllowAlias: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasBegin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCcEnableArenas: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCcGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasClientStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCsharpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCtype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDefaultValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDeprecated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDoubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasEnd: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtendee: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtensionValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasGoPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Hashable: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasher: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hashValueEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.HashVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIdempotencyLevel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIdentifierValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasInputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIsExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaGenerateEqualsAndHash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaMultipleFiles: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaOuterClassname: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaStringCheckUtf8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJsonName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJstype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLabel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLazy: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLeadingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasMapEntry: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasMessageSetWireFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNamePart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNegativeIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNoStandardDescriptorAccessor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasObjcClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOneofIndex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOptimizeFor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOutputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPacked: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpMetadataNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPositiveIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasProto3Optional: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPyGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasRubyPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasServerStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceContext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceFile: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasStart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasStringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSwiftPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSyntax: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasTrailingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasTypeName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasWeak: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hour: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.idempotencyLevel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.identifierValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ifEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ignoreUnknownFields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.index: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.initEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inoutEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.insert: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Enum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Enum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.integerLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntegerLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.intern: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Internal: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.InternalState: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.into: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ints: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isA: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqual: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqualTo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isInitializedEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.itemTagsEncodedSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Iterator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i_2166136261: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaGenerateEqualsAndHash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaMultipleFiles: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaOuterClassname: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaStringCheckUtf8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonEncoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONMapEncodingVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPath: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPaths: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONScanner: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonText: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonUTF8Data: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jstype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.k: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Key: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.keyField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.KeyType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.kind: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.l: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.label: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lazy: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.leadingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.leadingDetachedComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.length: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lessThan: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.letEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lhs: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.list: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listOfMessages: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndian: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndianBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.load: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.localHasher: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.location: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.M: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.major: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.makeIterator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapEntry: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapHash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapKeyType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapNameResolver: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapToMessages: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapValueType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mdayStart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.merge: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.message: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageDepthLimit: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageImplementationBase: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageSetWireFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Method: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MethodDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MethodOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.methods: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.minor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Mixin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mixins: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.modifier: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.modify: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.month: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.msgExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mutating: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.n: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.name: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameDescription: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NamePart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nameResolver: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.names: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nanos: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeEndianBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.negativeIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nestedType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newList: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextByte: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextFieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.noStandardDescriptorAccessor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nullValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.number: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.numberValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.objcClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.of: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofDecl: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneofDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofIndex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneofOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofs: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneOf_Kind: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.optimizeFor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptimizeMode: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Option: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalEnumExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalGroupExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalMessageExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.options: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.other: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.others: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.out: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.outputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.p: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.package: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.packed: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedEnumExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.padding: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parent: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parse: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.partial: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.path: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.paths: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payload: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payloadSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpMetadataNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pos: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.positiveIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.prefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preserveProtoFieldNames: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preTraverse: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.printUnknownFields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto2: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3DefaultValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3Optional: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_2: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBool: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufDouble: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufEnumMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobufExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFloat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMessageMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_fieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_nameMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_newField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_package: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protocolEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoFieldName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoMessageNameEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtoNameProviding: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoPaths: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicDependency: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBoolValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBytesValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putDoubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putEnumValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFloatValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putStringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64Hex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putVarInt: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putZigZagVarInt: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pyGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rawChars: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawRepresentable: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.read4HexDigits: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.register: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestTypeURL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requiredSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.reservedName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.reservedRange: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseTypeURL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.result: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rethrowsEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.returnEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ReturnType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.revision: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rhs: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.root: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rubyPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.s: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawBackslash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection4Characters: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection5Characters: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.scanner: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.seconds: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.selfEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.separator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serialize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedData: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serverStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.service: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ServiceDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ServiceOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.set: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.setExtensionValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.shift: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SimpleExtensionMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sizer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.source: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceContext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceEncoding: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceFile: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.span: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.split: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.start: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArray: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArrayObject: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startIndex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startObject: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startRegularField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.state: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.staticEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StaticString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.storage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringResult: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subscriptEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Swift: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.swiftPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SwiftProtobufEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.syntax: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.T: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tag: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.terminator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.testDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.text: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textFormatString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.throwsEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeInterval: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSince1970: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Timestamp: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.total: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalArrayDepth: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trailingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.traverseEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trueEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tryEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.type: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typealiasEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TypeEnumEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typePrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeStart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeUnknown: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeURL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Enum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Enum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalarLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalars: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarView: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uninterpretedOption: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.union: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uniqueStorage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknown: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknownFieldsEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnknownStorage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unpackTo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeBufferPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutablePointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawBufferPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawBufferPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.updatedOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.url: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8Ptr: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8ToDouble: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UTF8View: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.v: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.valueField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.values: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ValueType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.varEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Version: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.versionString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFieldsAsMessageSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitMapField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPacked: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBytesField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedGroupField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedStringField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingular: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBytesField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularGroupField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularStringField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitUnknown: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wasDecoded: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.weak: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.weakDependency: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.whereEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wireFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.with: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeMutableBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.work: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.WrappedType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.written: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.yday: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest_generated" - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".GeneratedSwiftReservedEnums" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedEnums, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedEnums) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearServerStreaming: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearServerStreaming\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.adjusted: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_adjusted"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSourceCodeInfo: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearSourceCodeInfo\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.aggregateValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_aggregateValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSourceContext: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearSourceContext\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allCases: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_allCases"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSourceFile: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearSourceFile\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.allowAlias: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_allowAlias"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearStart: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearStart\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.alwaysPrintEnumsAsInts: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_alwaysPrintEnumsAsInts"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearStringValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearStringValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.annotation: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_annotation"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSwiftPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearSwiftPrefix\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.any: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_any"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSyntax: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearSyntax\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_AnyExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearTrailingComments: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearTrailingComments\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageExtension: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_AnyMessageExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyMessageStorage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_AnyMessageStorage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearTypeName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearTypeName\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.AnyUnpackError: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_AnyUnpackError"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearUnverifiedLazy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearUnverifiedLazy\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Api: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Api"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearUtf8Validation: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearUtf8Validation\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appended: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_appended"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUIntHex: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_appendUIntHex"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearVerification: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearVerification\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.appendUnknown: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_appendUnknown"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearVisibility: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearVisibility\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.areAllInitialized: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_areAllInitialized"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearWeak: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearWeak\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.array: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_array"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clientStreaming: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clientStreaming\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayDepth: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_arrayDepth"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.code: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_code\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arrayLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_arrayLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.codePoint: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_codePoint\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.arraySeparator: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_arraySeparator"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.codeUnits: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_codeUnits\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_as"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Collection: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Collection\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiOpenCurlyBracket: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_asciiOpenCurlyBracket"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.comma: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_comma\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.asciiZero: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_asciiZero"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.consumedBytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_consumedBytes\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.available: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_available"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.contains: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_contains\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.b: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_b"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.contentsOf: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_contentsOf\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.base64Values: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_base64Values"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ContiguousBytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ContiguousBytes\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.baseAddress: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_baseAddress"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.copy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_copy\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BaseType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BaseType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.count: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_count\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.begin: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_begin"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.countVarintsInBuffer: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_countVarintsInBuffer\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binary: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_binary"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.csharpNamespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_csharpNamespace\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ctype: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ctype\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingError: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryDecodingError"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.customCodable: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_customCodable\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDecodingOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryDecodingOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.CustomDebugStringConvertible: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_CustomDebugStringConvertible\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryDelimited: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryDelimited"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.CustomStringConvertible: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_CustomStringConvertible\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryEncoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.D: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_D\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingError: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryEncodingError"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.DataEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Data\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetSizeVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryEncodingMessageSetSizeVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.dataResult: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_dataResult\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryEncodingMessageSetVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.date: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_date\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingSizeVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryEncodingSizeVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.daySec: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_daySec\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BinaryEncodingVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BinaryEncodingVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.daysSinceEpoch: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_daysSinceEpoch\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.binaryOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_binaryOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.debugDescriptionEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_debugDescription\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.body: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_body"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.debugRedact: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_debugRedact\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BoolEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Bool"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.declaration: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_declaration\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.booleanLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_booleanLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decoded: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decoded\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BooleanLiteralType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BooleanLiteralType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodedFromJSONNull: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodedFromJSONNull\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.boolValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_boolValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeExtensionField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytes: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_bytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeExtensionFieldsAsMessageSet: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeExtensionFieldsAsMessageSet\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesInGroup: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_bytesInGroup"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeJSON: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeJSON\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.bytesRead: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_bytesRead"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeMapField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeMapField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.BytesValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_BytesValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeMessageEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeMessage\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.c: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_c"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Decoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Decoder\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.capitalizeNext: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_capitalizeNext"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeated\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.cardinality: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_cardinality"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedBoolField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedBoolField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ccEnableArenas: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ccEnableArenas"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedBytesField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedBytesField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ccGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ccGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedDoubleField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedDoubleField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Character: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Character"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedEnumField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedEnumField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.chars: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_chars"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedFixed32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.classEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_class"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedFixed64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearAggregateValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearAggregateValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedFloatField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedFloatField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearAllowAlias: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearAllowAlias"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedGroupField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedGroupField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearBegin: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearBegin"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedInt32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCcEnableArenas: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearCcEnableArenas"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedInt64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCcGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearCcGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedMessageField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedMessageField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearClientStreaming: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearClientStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedSFixed32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCsharpNamespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearCsharpNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedSFixed64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearCtype: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearCtype"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedSInt32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDefaultValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearDefaultValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedSInt64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDeprecated: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearDeprecated"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedStringField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedStringField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearDoubleValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearDoubleValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedUInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedUInt32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearEnd: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearEnd"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedUInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedUInt64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtendee: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearExtendee"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingular: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingular\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearExtensionValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearExtensionValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularBoolField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularBoolField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearGoPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearGoPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularBytesField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularBytesField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIdempotencyLevel: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearIdempotencyLevel"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularDoubleField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularDoubleField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIdentifierValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearIdentifierValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularEnumField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularEnumField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearInputType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearInputType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularFixed32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearIsExtension: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearIsExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularFixed64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaGenerateEqualsAndHash: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearJavaGenerateEqualsAndHash"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularFloatField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularFloatField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearJavaGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularGroupField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularGroupField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaMultipleFiles: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearJavaMultipleFiles"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularInt32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaOuterClassname: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearJavaOuterClassname"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularInt64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearJavaPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularMessageField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularMessageField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJavaStringCheckUtf8: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearJavaStringCheckUtf8"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularSFixed32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJsonName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearJsonName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularSFixed64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearJstype: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearJstype"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularSInt32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLabel: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearLabel"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularSInt64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLazy: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearLazy"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularStringField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularStringField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearLeadingComments: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearLeadingComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularUInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularUInt32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearMapEntry: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearMapEntry"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularUInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularUInt64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearMessageSetWireFormat: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearMessageSetWireFormat"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeTextFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeTextFormat\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaultAnyTypeURLPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_defaultAnyTypeURLPrefix\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNamePart: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearNamePart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaults: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_defaults\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNegativeIntValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearNegativeIntValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaultSymbolVisibility: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_defaultSymbolVisibility\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNoStandardDescriptorAccessor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearNoStandardDescriptorAccessor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaultValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_defaultValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearNumber: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.dependency: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_dependency\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearObjcClassPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearObjcClassPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.deprecated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_deprecated\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOneofIndex: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearOneofIndex"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.deprecatedLegacyJsonFieldConflicts: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_deprecatedLegacyJsonFieldConflicts\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOptimizeFor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearOptimizeFor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.deprecationWarning: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_deprecationWarning\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.descriptionEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_description\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearOutputType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearOutputType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Dictionary: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Dictionary\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.dictionaryLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_dictionaryLiteral\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPacked: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearPacked"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digit: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_digit\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpClassPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearPhpClassPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digit0: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_digit0\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearPhpGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digit1: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_digit1\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpMetadataNamespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearPhpMetadataNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digitCount: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_digitCount\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPhpNamespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearPhpNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digits: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_digits\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPositiveIntValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearPositiveIntValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digitValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_digitValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearProto3Optional: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearProto3Optional"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.discardableResult: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_discardableResult\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearPyGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearPyGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.discardUnknownFields: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_discardUnknownFields\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearRubyPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearRubyPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.DoubleEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Double\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearServerStreaming: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearServerStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.doubleValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_doubleValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceCodeInfo: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearSourceCodeInfo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.duration: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_duration\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceContext: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearSourceContext"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.E: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_E\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSourceFile: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearSourceFile"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.edition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_edition\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearStart: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearStart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.EditionDefault: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_EditionDefault\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearStringValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearStringValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionDefaults: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_editionDefaults\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSwiftPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearSwiftPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionDeprecated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_editionDeprecated\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearSyntax: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearSyntax"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionIntroduced: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_editionIntroduced\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearTrailingComments: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearTrailingComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionRemoved: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_editionRemoved\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Element: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Element\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearTypeName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearTypeName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.elements: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_elements\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.elseEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_else\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clearWeak: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clearWeak"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emitExtensionFieldName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_emitExtensionFieldName\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.clientStreaming: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_clientStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emitFieldName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_emitFieldName\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codePoint: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_codePoint"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emitFieldNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_emitFieldNumber\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.codeUnits: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_codeUnits"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emptyAnyTypeURL: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_emptyAnyTypeURL\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Collection: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Collection"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emptyData: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_emptyData\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.com: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_com"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodeAsBytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_encodeAsBytes\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.comma: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_comma"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encoded: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_encoded\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.contentsOf: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_contentsOf"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodedJSONString: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_encodedJSONString\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ContiguousBytes: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ContiguousBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodedSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_encodedSize\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.count: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_count"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodeField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_encodeField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.countVarintsInBuffer: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_countVarintsInBuffer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_encoder\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.csharpNamespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_csharpNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.end: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_end\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ctype: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ctype"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endArray: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_endArray\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.customCodable: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_customCodable"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endMessageField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_endMessageField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.CustomDebugStringConvertible: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_CustomDebugStringConvertible"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endObject: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_endObject\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.d: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_d"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endRegularField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_endRegularField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DataEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Data"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enforceNamingStyle: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_enforceNamingStyle\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dataResult: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_dataResult"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enumEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_enum\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.date: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_date"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.EnumReservedRange: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_EnumReservedRange\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daySec: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_daySec"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enumType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_enumType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.daysSinceEpoch: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_daysSinceEpoch"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enumvalue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_enumvalue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.debugDescriptionEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_debugDescription"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.EquatableEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Equatable\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoded: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decoded"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Error: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Error\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodedFromJSONNull: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodedFromJSONNull"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.execute: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_execute\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExpressibleByArrayLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExpressibleByArrayLiteral\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeExtensionFieldsAsMessageSet: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeExtensionFieldsAsMessageSet"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExpressibleByDictionaryLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExpressibleByDictionaryLiteral\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeJSON: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeJSON"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ext: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ext\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMapField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeMapField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extDecoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extDecoder\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeMessageEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeMessage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extendedGraphemeClusterLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extendedGraphemeClusterLiteral\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtendedGraphemeClusterLiteralType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExtendedGraphemeClusterLiteralType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeated: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeated"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extendee: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extendee\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBoolField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedBoolField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensibleMessage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExtensibleMessage\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedBytesField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedBytesField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extension\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedDoubleField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedDoubleField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExtensionField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedEnumField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedEnumField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionFieldNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extensionFieldNumber\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionFieldValueSet: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExtensionFieldValueSet\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionMap: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExtensionMap\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedFloatField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedFloatField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionRange: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extensionRange\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedGroupField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedGroupField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extensions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extras: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extras\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.F: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_F\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedMessageField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedMessageField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.falseEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_false\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedSFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.features: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_features\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedSFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FeatureSetEditionDefault: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_FeatureSetEditionDefault\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedSInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.featureSupport: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_featureSupport\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedSInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedSInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedStringField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedStringField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldData: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldData\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedUInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FieldMaskError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_FieldMaskError\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeRepeatedUInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeRepeatedUInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldName\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingular: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingular"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNameCount: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldNameCount\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBoolField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularBoolField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldNum\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularBytesField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularBytesField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldNumber\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularDoubleField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularDoubleField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNumberForProto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldNumberForProto\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularEnumField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularEnumField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldPresence: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldPresence\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fields: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fields\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldSize\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularFloatField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularFloatField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FieldTag: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_FieldTag\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularGroupField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularGroupField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FieldType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_FieldType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.file: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_file\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fileName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fileName\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularMessageField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularMessageField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.filter: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_filter\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularSFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.final: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_final\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularSFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.finiteOnly: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_finiteOnly\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularSInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.first: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_first\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularSInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularSInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.firstItem: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_firstItem\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularStringField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularStringField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fixedFeatures: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fixedFeatures\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularUInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FloatEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Float\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeSingularUInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeSingularUInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.floatLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_floatLiteral\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.decodeTextFormat: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_decodeTextFormat"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FloatLiteralType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_FloatLiteralType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultAnyTypeURLPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_defaultAnyTypeURLPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_for\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.defaultValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_defaultValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forMessageName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_forMessageName\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dependency: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_dependency"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.formUnion: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_formUnion\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.deprecated: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_deprecated"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forReadingFrom: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_forReadingFrom\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.descriptionEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_description"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forTypeURL: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_forTypeURL\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.DescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_DescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ForwardParser: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ForwardParser\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Dictionary: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Dictionary"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forWritingInto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_forWritingInto\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.dictionaryLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_dictionaryLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.from: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_from\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_digit"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromAscii2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fromAscii2\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit0: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_digit0"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromAscii4: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fromAscii4\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digit1: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_digit1"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromByteOffset: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fromByteOffset\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitCount: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_digitCount"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromHexDigit: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fromHexDigit\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digits: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_digits"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fullName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fullName\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.digitValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_digitValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.funcEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_func\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardableResult: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_discardableResult"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.function: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_function\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.discardUnknownFields: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_discardUnknownFields"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.G: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_G\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.distance: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_distance"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.get: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_get\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.double: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_double"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.getExtensionValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_getExtensionValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.doubleValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_doubleValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Any: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Any\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Duration: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Duration"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Api: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Api\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.E: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_E"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_BoolValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_BoolValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Element: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Element"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_BytesValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_BytesValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.elements: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_elements"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_DescriptorProto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_DescriptorProto\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitExtensionFieldName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_emitExtensionFieldName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_DoubleValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_DoubleValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_emitFieldName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Duration: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Duration\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emitFieldNumber: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_emitFieldNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Edition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Edition\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Empty: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Empty"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Empty: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Empty\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.emptyData: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_emptyData"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Enum\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeAsBytes: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_encodeAsBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumDescriptorProto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_EnumDescriptorProto\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoded: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_encoded"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_EnumOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedJSONString: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_encodedJSONString"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_EnumValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodedSize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_encodedSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueDescriptorProto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_EnumValueDescriptorProto\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encodeField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_encodeField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_EnumValueOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.encoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_encoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_ExtensionRangeOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.end: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_end"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FeatureSet: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FeatureSet\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endArray: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_endArray"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FeatureSetDefaults: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FeatureSetDefaults\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endMessageField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_endMessageField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endObject: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_endObject"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldDescriptorProto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FieldDescriptorProto\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.endRegularField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_endRegularField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldMask: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FieldMask\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_enum"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FieldOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_EnumDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorProto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FileDescriptorProto\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_EnumOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorSet: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FileDescriptorSet\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumReservedRange: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_EnumReservedRange"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FileOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FileOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_enumType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FloatValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FloatValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.enumvalue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_enumvalue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_GeneratedCodeInfo\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumValueDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_EnumValueDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Int32Value: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Int32Value\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.EnumValueOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_EnumValueOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Int64Value: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Int64Value\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Equatable: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Equatable"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ListValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_ListValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Error: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Error"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_MessageOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_MessageOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByArrayLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ExpressibleByArrayLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Method: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Method\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExpressibleByDictionaryLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ExpressibleByDictionaryLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodDescriptorProto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_MethodDescriptorProto\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ext: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ext"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_MethodOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extDecoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_extDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Mixin: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Mixin\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendedGraphemeClusterLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_extendedGraphemeClusterLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_NullValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_NullValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtendedGraphemeClusterLiteralType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ExtendedGraphemeClusterLiteralType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofDescriptorProto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_OneofDescriptorProto\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extendee: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_extendee"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_OneofOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensibleMessage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ExtensibleMessage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Option: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Option\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_extension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_ServiceDescriptorProto\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_ServiceOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionFieldNumber: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_extensionFieldNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceCodeInfo: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_SourceCodeInfo\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionFieldValueSet: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ExtensionFieldValueSet"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceContext: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_SourceContext\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionMap: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ExtensionMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_StringValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_StringValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensionRange: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_extensionRange"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Struct: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Struct\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ExtensionRangeOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ExtensionRangeOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_SymbolVisibility: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_SymbolVisibility\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extensions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_extensions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Syntax: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Syntax\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.extras: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_extras"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Timestamp: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Timestamp\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.F: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_F"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Type: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Type\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.falseEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_false"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt32Value: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_UInt32Value\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt64Value: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_UInt64Value\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldData: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fieldData"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_UninterpretedOption: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_UninterpretedOption\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_FieldDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Value: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Value\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldMask: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_FieldMask"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.goPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_goPackage\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fieldName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.gotData: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_gotData\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNameCount: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fieldNameCount"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.group: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_group\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fieldNum"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.groupFieldNumberStack: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_groupFieldNumberStack\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumber: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fieldNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.groupSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_groupSize\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldNumberForProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fieldNumberForProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.guardEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_guard\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_FieldOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hadOneofValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hadOneofValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fields: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fields"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.handleConflictingOneOf: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_handleConflictingOneOf\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldSize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fieldSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.handleInstruction: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_handleInstruction\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FieldTag: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_FieldTag"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasAggregateValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasAggregateValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fieldType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fieldType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasAllowAlias: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasAllowAlias\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.file: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_file"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasBegin: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasBegin\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_FileDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCcEnableArenas: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasCcEnableArenas\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileDescriptorSet: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_FileDescriptorSet"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCcGenericServices: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasCcGenericServices\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fileName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fileName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasClientStreaming: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasClientStreaming\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FileOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_FileOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCsharpNamespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasCsharpNamespace\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.filter: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_filter"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCtype: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasCtype\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.first: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_first"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasData: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasData\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.firstItem: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_firstItem"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDebugRedact: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDebugRedact\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.float: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_float"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDefaultSymbolVisibility: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDefaultSymbolVisibility\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.floatLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_floatLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDefaultValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDefaultValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatLiteralType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_FloatLiteralType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDeprecated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDeprecated\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.FloatValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_FloatValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDeprecatedLegacyJsonFieldConflicts: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDeprecatedLegacyJsonFieldConflicts\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forMessageName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_forMessageName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDeprecationWarning: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDeprecationWarning\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.formUnion: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_formUnion"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDoubleValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDoubleValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forReadingFrom: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_forReadingFrom"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEdition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEdition\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forTypeURL: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_forTypeURL"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEditionDeprecated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEditionDeprecated\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ForwardParser: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ForwardParser"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEditionIntroduced: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEditionIntroduced\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.forWritingInto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_forWritingInto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEditionRemoved: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEditionRemoved\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.from: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_from"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEnd: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEnd\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii2: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fromAscii2"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEnforceNamingStyle: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEnforceNamingStyle\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromAscii4: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fromAscii4"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEnumType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEnumType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromByteOffset: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fromByteOffset"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasExplicitDelta: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasExplicitDelta\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.fromHexDigit: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_fromHexDigit"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasExtendee: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasExtendee\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.funcEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_func"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasExtensionValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasExtensionValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.G: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_G"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFeatures: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasFeatures\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.GeneratedCodeInfo: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_GeneratedCodeInfo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFeatureSupport: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasFeatureSupport\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.get: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_get"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFieldPresence: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasFieldPresence\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.getExtensionValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_getExtensionValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFixedFeatures: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasFixedFeatures\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.googleapis: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_googleapis"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFullName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasFullName\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Any: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Any"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasGoPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasGoPackage\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Api: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Api"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hash: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hash\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BoolValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_BoolValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.HashableEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Hashable\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_BytesValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_BytesValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasher: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasher\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_DescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.HashVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_HashVisitor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_DoubleValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_DoubleValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasIdempotencyLevel: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasIdempotencyLevel\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Duration: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Duration"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasIdentifierValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasIdentifierValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Empty: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Empty"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasInputType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasInputType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Enum"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasIsExtension: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasIsExtension\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_EnumDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaGenerateEqualsAndHash: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJavaGenerateEqualsAndHash\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_EnumOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaGenericServices: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJavaGenericServices\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_EnumValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaMultipleFiles: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJavaMultipleFiles\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_EnumValueDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaOuterClassname: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJavaOuterClassname\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_EnumValueOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJavaPackage\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_ExtensionRangeOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaStringCheckUtf8: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJavaStringCheckUtf8\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJsonFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJsonFormat\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_FieldDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJsonName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJsonName\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldMask: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_FieldMask"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJstype: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJstype\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_FieldOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasLabel: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasLabel\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_FileDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasLazy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasLazy\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorSet: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_FileDescriptorSet"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasLeadingComments: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasLeadingComments\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FileOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_FileOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMapEntry: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasMapEntry\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_FloatValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_FloatValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMaximumEdition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasMaximumEdition\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_GeneratedCodeInfo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMessageEncoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasMessageEncoding\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int32Value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Int32Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMessageSetWireFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasMessageSetWireFormat\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Int64Value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Int64Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMinimumEdition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasMinimumEdition\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ListValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_ListValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasName\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MessageOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_MessageOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNamePart: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasNamePart\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Method: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Method"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNegativeIntValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasNegativeIntValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_MethodDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNoStandardDescriptorAccessor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasNoStandardDescriptorAccessor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_MethodOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasNumber\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Mixin: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Mixin"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasObjcClassPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasObjcClassPrefix\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_NullValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_NullValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOneofIndex: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasOneofIndex\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_OneofDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOptimizeFor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasOptimizeFor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_OneofOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Option: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Option"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOutputType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasOutputType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_ServiceDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOverridableFeatures: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasOverridableFeatures\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_ServiceOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPackage\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceCodeInfo: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_SourceCodeInfo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPacked: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPacked\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceContext: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_SourceContext"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPhpClassPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPhpClassPrefix\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_StringValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_StringValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPhpMetadataNamespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPhpMetadataNamespace\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Struct: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Struct"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPhpNamespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPhpNamespace\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Syntax: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Syntax"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPositiveIntValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPositiveIntValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Timestamp: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Timestamp"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasProto3Optional: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasProto3Optional\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Type: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Type"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPyGenericServices: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPyGenericServices\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt32Value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_UInt32Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRemovalError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasRemovalError\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt64Value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_UInt64Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRepeated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasRepeated\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_UninterpretedOption: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_UninterpretedOption"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRepeatedFieldEncoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasRepeatedFieldEncoding\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Google_Protobuf_Value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Google_Protobuf_Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasReserved: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasReserved\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.goPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_goPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRetention: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasRetention\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.group: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_group"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRubyPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasRubyPackage\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupFieldNumberStack: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_groupFieldNumberStack"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSemantic: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasSemantic\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.groupSize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_groupSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasServerStreaming: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasServerStreaming\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.h: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_h"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSourceCodeInfo: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasSourceCodeInfo\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hadOneofValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hadOneofValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSourceContext: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasSourceContext\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.handleConflictingOneOf: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_handleConflictingOneOf"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSourceFile: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasSourceFile\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasAggregateValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasAggregateValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasStart: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasStart\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasAllowAlias: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasAllowAlias"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasStringValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasStringValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasBegin: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasBegin"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSwiftPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasSwiftPrefix\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCcEnableArenas: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasCcEnableArenas"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSyntax: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasSyntax\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCcGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasCcGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasTrailingComments: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasTrailingComments\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasClientStreaming: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasClientStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCsharpNamespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasCsharpNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasTypeName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasTypeName\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasCtype: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasCtype"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasUnverifiedLazy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasUnverifiedLazy\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDefaultValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasDefaultValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasUtf8Validation: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasUtf8Validation\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDeprecated: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasDeprecated"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasDoubleValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasDoubleValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasVerification: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasVerification\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasEnd: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasEnd"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasVisibility: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasVisibility\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtendee: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasExtendee"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasWeak: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasWeak\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasExtensionValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasExtensionValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hour: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hour\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasGoPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasGoPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.i: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_i\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hash: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hash"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.idempotencyLevel: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_idempotencyLevel\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Hashable: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Hashable"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.identifierValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_identifierValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasher: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasher"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ifEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_if\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hashValueEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hashValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ignoreUnknownExtensionFields: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ignoreUnknownExtensionFields\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.HashVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_HashVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ignoreUnknownFields: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ignoreUnknownFields\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIdempotencyLevel: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasIdempotencyLevel"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.index: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_index\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIdentifierValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasIdentifierValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.initEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_init\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasInputType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasInputType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.inoutEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_inout\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasIsExtension: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasIsExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.inputType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_inputType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaGenerateEqualsAndHash: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasJavaGenerateEqualsAndHash"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.insert: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_insert\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasJavaGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Instruction: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Instruction\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaMultipleFiles: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasJavaMultipleFiles"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.IntEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Int\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaOuterClassname: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasJavaOuterClassname"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Int32Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Int32\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasJavaPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Int64Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Int64\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJavaStringCheckUtf8: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasJavaStringCheckUtf8"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Int8: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Int8\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJsonName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasJsonName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.integerLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_integerLiteral\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasJstype: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasJstype"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.IntegerLiteralType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_IntegerLiteralType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLabel: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasLabel"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.intern: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_intern\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLazy: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasLazy"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Internal: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Internal\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasLeadingComments: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasLeadingComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.InternalState: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_InternalState\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasMapEntry: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasMapEntry"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.intersect: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_intersect\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasMessageSetWireFormat: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasMessageSetWireFormat"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.into: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_into\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ints: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ints\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNamePart: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasNamePart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.invalidAnyTypeURL: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_invalidAnyTypeURL\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNegativeIntValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasNegativeIntValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isA: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isA\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNoStandardDescriptorAccessor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasNoStandardDescriptorAccessor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isEqual: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isEqual\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasNumber: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isEqualTo: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isEqualTo\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasObjcClassPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasObjcClassPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isExtension: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isExtension\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOneofIndex: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasOneofIndex"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isInitializedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isInitialized\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOptimizeFor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasOptimizeFor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isNegative: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isNegative\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isPathValid: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isPathValid\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasOutputType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasOutputType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isReserved: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isReserved\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isValid: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isValid\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPacked: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasPacked"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.itemTagsEncodedSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_itemTagsEncodedSize\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpClassPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasPhpClassPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.iterator: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_iterator\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasPhpGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaGenerateEqualsAndHash: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_javaGenerateEqualsAndHash\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpMetadataNamespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasPhpMetadataNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaGenericServices: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_javaGenericServices\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPhpNamespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasPhpNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaMultipleFiles: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_javaMultipleFiles\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPositiveIntValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasPositiveIntValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaOuterClassname: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_javaOuterClassname\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasProto3Optional: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasProto3Optional"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_javaPackage\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasPyGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasPyGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaStringCheckUtf8: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_javaStringCheckUtf8\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasRubyPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasRubyPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONDecoder\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasServerStreaming: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasServerStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONDecoding\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceCodeInfo: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasSourceCodeInfo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecodingError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONDecodingError\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceContext: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasSourceContext"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecodingOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONDecodingOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSourceFile: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasSourceFile"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonEncoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonEncoder\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasStart: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasStart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONEncoding\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasStringValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasStringValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncodingError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONEncodingError\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSwiftPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasSwiftPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncodingOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONEncodingOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasSyntax: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasSyntax"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncodingVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONEncodingVisitor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasTrailingComments: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasTrailingComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonFormat\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONMapEncodingVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONMapEncodingVisitor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasTypeName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasTypeName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonName\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonPath: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonPath\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hasWeak: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hasWeak"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonPaths: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonPaths\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.hour: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_hour"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONScanner: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONScanner\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_i"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonString: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonString\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.idempotencyLevel: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_idempotencyLevel"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonText: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonText\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.identifierValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_identifierValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonUTF8Bytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonUTF8Bytes\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ifEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_if"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonUTF8Data: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonUTF8Data\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ignoreUnknownFields: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ignoreUnknownFields"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jstype: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jstype\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.index: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_index"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.k: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_k\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.initEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_init"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.kChunkSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_kChunkSize\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inoutEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_inout"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Key: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Key\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.inputType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_inputType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.keyField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_keyField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.insert: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_insert"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.keyFieldOpt: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_keyFieldOpt\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Int"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.KeyType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_KeyType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Int32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.kind: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_kind\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int32Value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Int32Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.l: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_l\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Int64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.label: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_label\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int64Value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Int64Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.lazy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_lazy\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Int8: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Int8"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.leadingComments: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_leadingComments\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.integerLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_integerLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.leadingDetachedComments: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_leadingDetachedComments\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.IntegerLiteralType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_IntegerLiteralType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.length: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_length\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.intern: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_intern"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.lessThan: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_lessThan\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Internal: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Internal"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.letEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_let\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.InternalState: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_InternalState"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.lhs: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_lhs\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.into: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_into"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.line: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_line\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ints: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ints"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.list: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_list\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isA: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_isA"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.listOfMessages: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_listOfMessages\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqual: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_isEqual"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.listValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_listValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isEqualTo: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_isEqualTo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.littleEndian: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_littleEndian\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isExtension: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_isExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.load: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_load\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.isInitializedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_isInitialized"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.localHasher: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_localHasher\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.itemTagsEncodedSize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_itemTagsEncodedSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.location: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_location\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Iterator: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Iterator"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.M: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_M\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.i_2166136261: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_i_2166136261"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.major: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_major\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaGenerateEqualsAndHash: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_javaGenerateEqualsAndHash"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.makeAsyncIterator: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_makeAsyncIterator\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_javaGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.makeIterator: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_makeIterator\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaMultipleFiles: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_javaMultipleFiles"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.malformedLength: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_malformedLength\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaOuterClassname: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_javaOuterClassname"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapEntry: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mapEntry\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_javaPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MapKeyType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_MapKeyType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.javaStringCheckUtf8: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_javaStringCheckUtf8"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapToMessages: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mapToMessages\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_JSONDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MapValueType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_MapValueType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingError: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_JSONDecodingError"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mapVisitor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONDecodingOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_JSONDecodingOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mask: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mask\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonEncoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_jsonEncoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.maximumEdition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_maximumEdition\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingError: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_JSONEncodingError"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mdayStart: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mdayStart\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_JSONEncodingOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.merge: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_merge\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONEncodingVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_JSONEncodingVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MergeOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_MergeOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONMapEncodingVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_JSONMapEncodingVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.message: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_message\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_jsonName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageDepthLimit: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_messageDepthLimit\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPath: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_jsonPath"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageEncoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_messageEncoding\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonPaths: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_jsonPaths"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MessageExtension: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_MessageExtension\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.JSONScanner: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_JSONScanner"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MessageImplementationBase: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_MessageImplementationBase\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonString: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_jsonString"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MessageSet: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_MessageSet\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonText: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_jsonText"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageSetWireFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_messageSetWireFormat\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jsonUTF8Data: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_jsonUTF8Data"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_messageSize\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.jstype: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_jstype"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_messageType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.k: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_k"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.method: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_method\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Key: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Key"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.methods: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_methods\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.keyField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_keyField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.min: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_min\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.KeyType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_KeyType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.minimumEdition: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_minimumEdition\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.kind: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_kind"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.minor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_minor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.l: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_l"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mixins: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mixins\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.label: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_label"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.modify: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_modify\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lazy: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_lazy"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.month: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_month\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.leadingComments: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_leadingComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.msgExtension: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_msgExtension\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.leadingDetachedComments: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_leadingDetachedComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mutating: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mutating\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.length: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_length"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.n: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_n\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lessThan: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_lessThan"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.name: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_name\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.letEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_let"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.NameDescription: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_NameDescription\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.lhs: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_lhs"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.NameMap: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_NameMap\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.list: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_list"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.NamePart: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_NamePart\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listOfMessages: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_listOfMessages"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.names: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_names\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.listValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_listValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nanos: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nanos\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndian: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_littleEndian"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.negativeIntValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_negativeIntValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.littleEndianBytes: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_littleEndianBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nestedType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nestedType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.load: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_load"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newExtensible: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_newExtensible\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.localHasher: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_localHasher"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newL: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_newL\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.location: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_location"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newList: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_newList\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.M: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_M"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newMessage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_newMessage\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.major: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_major"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_newValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.makeIterator: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_makeIterator"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.next: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_next\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapEntry: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_mapEntry"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextByte: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextByte\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapHash: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_mapHash"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextFieldNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextFieldNumber\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapKeyType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_MapKeyType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextInstruction: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextInstruction\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapNameResolver: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_mapNameResolver"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextInt32: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextInt32\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapToMessages: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_mapToMessages"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextNullTerminatedString: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextNullTerminatedString\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MapValueType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_MapValueType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextNullTerminatedStringArray: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextNullTerminatedStringArray\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mapVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_mapVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextNumber\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mdayStart: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_mdayStart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextUInt64: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextUInt64\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.merge: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_merge"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextVarInt: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextVarInt\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.message: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_message"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nilEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nil\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageDepthLimit: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_messageDepthLimit"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nilLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nilLiteral\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageExtension: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_MessageExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.noBytesAvailable: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_noBytesAvailable\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageImplementationBase: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_MessageImplementationBase"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.noStandardDescriptorAccessor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_noStandardDescriptorAccessor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_MessageOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nullValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nullValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MessageSet: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_MessageSet"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.number: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_number\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageSetWireFormat: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_messageSetWireFormat"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.numberValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_numberValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.messageType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_messageType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.objcClassPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_objcClassPrefix\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Method: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Method"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.of: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_of\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MethodDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_MethodDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OneOf_Kind: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OneOf_Kind\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.MethodOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_MethodOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofDecl: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_oneofDecl\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.methods: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_methods"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofIndex: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_oneofIndex\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.minor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_minor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofs: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_oneofs\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Mixin: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Mixin"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.optimizeFor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_optimizeFor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mixins: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_mixins"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptimizeMode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptimizeMode\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.modifier: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_modifier"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalEnumExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptionalEnumExtensionField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.modify: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_modify"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptionalExtensionField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.month: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_month"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalGroupExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptionalGroupExtensionField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.msgExtension: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_msgExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalMessageExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptionalMessageExtensionField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.mutating: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_mutating"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.optionDependency: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_optionDependency\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.n: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_n"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionRetention: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptionRetention\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.name: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_name"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.options: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_options\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameDescription: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_NameDescription"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionTargetType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptionTargetType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NameMap: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_NameMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.other: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_other\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.NamePart: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_NamePart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.others: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_others\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nameResolver: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nameResolver"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.out: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_out\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.names: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_names"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.outputType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_outputType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nanos: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nanos"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.overridableFeatures: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_overridableFeatures\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeBytes: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nativeBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.p: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_p\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nativeEndianBytes: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nativeEndianBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.package: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_package\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.negativeIntValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_negativeIntValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packed: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_packed\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nestedType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nestedType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PackedEnumExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_PackedEnumExtensionField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newL: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_newL"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PackedExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_PackedExtensionField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newList: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_newList"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.padding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_padding\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.newValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_newValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.parent: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_parent\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextByte: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nextByte"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.parse: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_parse\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nextFieldNumber: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nextFieldNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.partial: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_partial\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nil"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.path: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_path\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nilLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nilLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PathDecoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_PathDecoder\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.noStandardDescriptorAccessor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_noStandardDescriptorAccessor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PathDecodingError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_PathDecodingError\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.nullValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_nullValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.paths: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_paths\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.number: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_number"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PathVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_PathVisitor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.numberValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_numberValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.payload: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_payload\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.objcClassPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_objcClassPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.payloadSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_payloadSize\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.of: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_of"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpClassPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_phpClassPrefix\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofDecl: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_oneofDecl"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpMetadataNamespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_phpMetadataNamespace\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneofDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_OneofDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpNamespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_phpNamespace\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofIndex: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_oneofIndex"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.pos: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_pos\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneofOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_OneofOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.positiveIntValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_positiveIntValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.oneofs: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_oneofs"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.prefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_prefix\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OneOf_Kind: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_OneOf_Kind"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.preserveProtoFieldNames: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_preserveProtoFieldNames\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.optimizeFor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_optimizeFor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.preTraverse: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_preTraverse\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptimizeMode: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_OptimizeMode"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.previousNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_previousNumber\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Option: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Option"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.prevPath: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_prevPath\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalEnumExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_OptionalEnumExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.printUnknownFields: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_printUnknownFields\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_OptionalExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.programBuffer: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_programBuffer\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalGroupExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_OptionalGroupExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.programFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_programFormat\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.OptionalMessageExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_OptionalMessageExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_proto2\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.options: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_options"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto3DefaultValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_proto3DefaultValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.other: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_other"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto3Optional: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_proto3Optional\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.others: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_others"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobuf_extensionFieldValues\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.out: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_out"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_fieldNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobuf_fieldNumber\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.outputType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_outputType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobuf_generated_isEqualTo\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.p: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_p"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_nameMap: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobuf_nameMap\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.package: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_package"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_newField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobuf_newField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.packed: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_packed"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_package: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobuf_package\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedEnumExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_PackedEnumExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufAPIVersion_2\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.PackedExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_PackedExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufAPIVersionCheck\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.padding: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_padding"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufBool: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufBool\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parent: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_parent"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufBytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufBytes\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.parse: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_parse"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobufData: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobufData\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.partial: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_partial"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufDouble: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufDouble\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.path: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_path"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufEnumMap: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufEnumMap\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.paths: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_paths"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobufExtension: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobufExtension\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payload: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_payload"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFixed32: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufFixed32\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.payloadSize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_payloadSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFixed64: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufFixed64\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpClassPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_phpClassPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFloat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufFloat\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_phpGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufInt32: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufInt32\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpMetadataNamespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_phpMetadataNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufInt64: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufInt64\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.phpNamespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_phpNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufMap: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufMap\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pointer: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_pointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufMessageMap: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufMessageMap\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pos: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_pos"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSFixed32: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufSFixed32\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.positiveIntValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_positiveIntValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSFixed64: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufSFixed64\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.prefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_prefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSInt32: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufSInt32\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preserveProtoFieldNames: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_preserveProtoFieldNames"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSInt64: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufSInt64\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.preTraverse: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_preTraverse"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufString: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufString\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.printUnknownFields: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_printUnknownFields"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufUInt32: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufUInt32\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto2: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_proto2"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufUInt64: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufUInt64\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3DefaultValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_proto3DefaultValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protocolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protocol\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.proto3Optional: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_proto3Optional"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoFieldName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protoFieldName\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufAPIVersionCheck"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoMessageNameEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protoMessageName\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_2: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufAPIVersion_2"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtoNameProviding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtoNameProviding\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBool: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufBool"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoPaths: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protoPaths\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufBytes: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.publicEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_public\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufDouble: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufDouble"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.publicDependency: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_publicDependency\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufEnumMap: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufEnumMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putBoolValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putBoolValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobufExtension: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protobufExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putBytesValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putBytesValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed32: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufFixed32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putDoubleValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putDoubleValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFixed64: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufFixed64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putEnumValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putEnumValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufFloat: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufFloat"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFixedUInt32: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putFixedUInt32\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt32: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufInt32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFixedUInt64: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putFixedUInt64\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufInt64: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFloatValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putFloatValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMap: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putInt64: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putInt64\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufMessageMap: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufMessageMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putStringValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putStringValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed32: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufSFixed32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putUInt64: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putUInt64\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSFixed64: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufSFixed64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putUInt64Hex: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putUInt64Hex\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt32: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufSInt32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putVarInt: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putVarInt\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufSInt64: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufSInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putZigZagVarInt: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putZigZagVarInt\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufString: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufString"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.pyGenericServices: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_pyGenericServices\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt32: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufUInt32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.R: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_R\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtobufUInt64: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtobufUInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rawChars: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_rawChars\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protobuf_extensionFieldValues"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RawRepresentable: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_RawRepresentable\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_fieldNumber: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protobuf_fieldNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RawValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_RawValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protobuf_generated_isEqualTo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.read4HexDigits: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_read4HexDigits\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_nameMap: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protobuf_nameMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.readBytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_readBytes\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_newField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protobuf_newField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.reader: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_reader\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protobuf_package: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protobuf_package"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.register: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_register\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protocolEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protocol"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.remainingProgram: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_remainingProgram\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoFieldName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protoFieldName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.removalError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_removalError\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoMessageNameEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protoMessageName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.removingAllFieldsOf: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_removingAllFieldsOf\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ProtoNameProviding: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ProtoNameProviding"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_repeated\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.protoPaths: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_protoPaths"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_RepeatedEnumExtensionField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_public"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_RepeatedExtensionField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.publicDependency: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_publicDependency"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedFieldEncoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_repeatedFieldEncoding\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBoolValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putBoolValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_RepeatedGroupExtensionField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putBytesValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putBytesValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_RepeatedMessageExtensionField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putDoubleValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putDoubleValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeating: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_repeating\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putEnumValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putEnumValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.replaceRepeatedFields: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_replaceRepeatedFields\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt32: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putFixedUInt32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requestStreaming: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_requestStreaming\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFixedUInt64: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putFixedUInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requestTypeURL: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_requestTypeURL\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putFloatValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putFloatValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requiredSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_requiredSize\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putInt64: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.responseStreaming: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_responseStreaming\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putStringValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putStringValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.responseTypeURL: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_responseTypeURL\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putUInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.result: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_result\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putUInt64Hex: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putUInt64Hex"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.retention: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_retention\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putVarInt: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putVarInt"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rethrowsEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_rethrows\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.putZigZagVarInt: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_putZigZagVarInt"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ReturnType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ReturnType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.pyGenericServices: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_pyGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.revision: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_revision\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rawChars: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_rawChars"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rhs: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_rhs\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawRepresentable: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_RawRepresentable"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.root: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_root\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RawValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_RawValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rubyPackage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_rubyPackage\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.read4HexDigits: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_read4HexDigits"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.s: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_s\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.register: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_register"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawBackslash: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sawBackslash\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_RepeatedEnumExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawSection4Characters: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sawSection4Characters\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_RepeatedExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawSection5Characters: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sawSection5Characters\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_RepeatedGroupExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Scalar: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Scalar\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_RepeatedMessageExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.scan: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_scan\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestStreaming: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_requestStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.scanner: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_scanner\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requestTypeURL: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_requestTypeURL"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.seconds: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_seconds\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.requiredSize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_requiredSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.selfEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_self\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.reservedName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_reservedName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.semantic: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_semantic\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.reservedRange: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_reservedRange"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SendableEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Sendable\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseStreaming: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_responseStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.separator: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_separator\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.responseTypeURL: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_responseTypeURL"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serialize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_serialize\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.result: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_result"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedBytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_serializedBytes\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rethrowsEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_rethrows"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedData: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_serializedData\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.returnEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_return"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_serializedSize\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ReturnType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ReturnType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serverStreaming: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_serverStreaming\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.revision: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_revision"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.service: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_service\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rhs: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_rhs"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.set: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_set\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.root: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_root"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.setExtensionValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_setExtensionValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.rubyPackage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_rubyPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.shift: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_shift\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.s: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_s"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SimpleExtensionMap: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_SimpleExtensionMap\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawBackslash: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_sawBackslash"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.size: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_size\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection4Characters: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_sawSection4Characters"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sizer: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sizer\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sawSection5Characters: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_sawSection5Characters"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.source: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_source\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.scanner: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_scanner"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceCodeInfo: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sourceCodeInfo\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.seconds: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_seconds"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceContext: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sourceContext\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.selfEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_self"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceEncoding: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sourceEncoding\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.separator: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_separator"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceFile: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sourceFile\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serialize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_serialize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SourceLocation: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_SourceLocation\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedData: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_serializedData"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.span: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_span\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serializedSize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_serializedSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.split: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_split\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.serverStreaming: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_serverStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.start: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_start\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.service: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_service"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startArray: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startArray\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ServiceDescriptorProto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ServiceDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startArrayObject: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startArrayObject\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ServiceOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ServiceOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.set: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_set"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startIndex: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startIndex\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.setExtensionValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_setExtensionValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startMessageField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startMessageField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.shift: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_shift"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startObject: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startObject\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SimpleExtensionMap: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_SimpleExtensionMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startRegularField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startRegularField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sizer: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_sizer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.state: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_state\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.source: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_source"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.staticEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_static\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceCodeInfo: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_sourceCodeInfo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.StaticString: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_StaticString\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceContext: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_sourceContext"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.storage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_storage\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceEncoding: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_sourceEncoding"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.StringEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_String\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.sourceFile: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_sourceFile"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.stringLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_stringLiteral\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.span: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_span"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.StringLiteralType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_StringLiteralType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.split: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_split"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.stringResult: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_stringResult\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.start: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_start"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.stringValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_stringValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArray: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_startArray"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.structEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_struct\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startArrayObject: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_startArrayObject"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.structValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_structValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_startField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subDecoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_subDecoder\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startIndex: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_startIndex"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subscriptEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_subscript\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startMessageField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_startMessageField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subtract: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_subtract\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startObject: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_startObject"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_subVisitor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.startRegularField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_startRegularField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SwiftEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Swift\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.state: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_state"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.swiftPrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_swiftPrefix\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.staticEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_static"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SwiftProtobufContiguousBytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_SwiftProtobufContiguousBytes\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StaticString: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_StaticString"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SwiftProtobufError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_SwiftProtobufError\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.storage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_storage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.syntax: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_syntax\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_String"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.T: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_T\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_stringLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tag: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_tag\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.StringLiteralType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_StringLiteralType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.targets: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_targets\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringResult: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_stringResult"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.terminator: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_terminator\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.stringValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_stringValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.testDecoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_testDecoder\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_struct"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.text: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_text\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.structValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_structValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.textDecoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_textDecoder\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subDecoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_subDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatDecoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_TextFormatDecoder\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subscriptEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_subscript"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatDecodingError: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_TextFormatDecodingError\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.subVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_subVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatDecodingOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_TextFormatDecodingOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Swift: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Swift"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatEncodingOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_TextFormatEncodingOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.swiftPrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_swiftPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatEncodingVisitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_TextFormatEncodingVisitor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.SwiftProtobufEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_SwiftProtobuf"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.textFormatString: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_textFormatString\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.syntax: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_syntax"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.throwOrIgnore: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_throwOrIgnore\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.T: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_T"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.throwsEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_throws\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tag: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_tag"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeInterval: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_timeInterval\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.terminator: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_terminator"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeIntervalSince1970: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_timeIntervalSince1970\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.testDecoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_testDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_timeIntervalSinceReferenceDate\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.text: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_text"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tmp: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_tmp\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textDecoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_textDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tooLarge: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_tooLarge\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_TextFormatDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.total: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_total\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingError: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_TextFormatDecodingError"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.totalArrayDepth: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_totalArrayDepth\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatDecodingOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_TextFormatDecodingOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.totalSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_totalSize\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_TextFormatEncodingOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.trailingComments: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_trailingComments\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TextFormatEncodingVisitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_TextFormatEncodingVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.traverseEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_traverse\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.textFormatString: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_textFormatString"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.trim: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_trim\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.throwsEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_throws"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.trueEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_true\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeInterval: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_timeInterval"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tryEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_try\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSince1970: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_timeIntervalSince1970"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.type: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_type\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_timeIntervalSinceReferenceDate"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typealiasEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_typealias\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Timestamp: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Timestamp"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TypeEnumEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_TypeEnum\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.total: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_total"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeName: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_typeName\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalArrayDepth: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_totalArrayDepth"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typePrefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_typePrefix\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.totalSize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_totalSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeStart: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_typeStart\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trailingComments: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_trailingComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeUnknown: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_typeUnknown\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.traverseEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_traverse"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeURL: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_typeURL\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.trueEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_true"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UInt32Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UInt32\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.tryEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_try"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UInt64Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UInt64\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.type: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_type"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UInt8: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UInt8\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typealiasEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_typealias"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unchecked: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unchecked\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.TypeEnumEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_TypeEnum"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Unicode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Unicode\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeName: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_typeName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unicodeScalarLiteral: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unicodeScalarLiteral\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typePrefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_typePrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnicodeScalarLiteralType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnicodeScalarLiteralType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeStart: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_typeStart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unicodeScalars: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unicodeScalars\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeUnknown: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_typeUnknown"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnicodeScalarView: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnicodeScalarView\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.typeURL: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_typeURL"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.uninterpretedOption: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_uninterpretedOption\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UInt32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.union: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_union\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt32Value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UInt32Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.uniqueStorage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_uniqueStorage\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unknown: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unknown\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt64Value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UInt64Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unknownFieldsEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unknownFields\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UInt8: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UInt8"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnknownStorage: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnknownStorage\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalarLiteral: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_unicodeScalarLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unpackTo: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unpackTo\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarLiteralType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UnicodeScalarLiteralType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeBufferPointer: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnsafeBufferPointer\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unicodeScalars: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_unicodeScalars"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeMutablePointer: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnsafeMutablePointer\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnicodeScalarView: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UnicodeScalarView"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeMutableRawBufferPointer: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnsafeMutableRawBufferPointer\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uninterpretedOption: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_uninterpretedOption"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeRawBufferPointer: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnsafeRawBufferPointer\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.union: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_union"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeRawPointer: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnsafeRawPointer\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.uniqueStorage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_uniqueStorage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unverifiedLazy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unverifiedLazy\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknown: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_unknown"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.updatedOptions: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_updatedOptions\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unknownFieldsEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_unknownFields"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.uppercasedAssumingASCII: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_uppercasedAssumingASCII\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnknownStorage: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UnknownStorage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.url: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_url\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.unpackTo: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_unpackTo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.useDeterministicOrdering: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_useDeterministicOrdering\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeBufferPointer: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UnsafeBufferPointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_utf8\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutablePointer: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UnsafeMutablePointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8Ptr: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_utf8Ptr\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawBufferPointer: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UnsafeMutableRawBufferPointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8ToDouble: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_utf8ToDouble\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeMutableRawPointer: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UnsafeMutableRawPointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8Validation: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_utf8Validation\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawBufferPointer: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UnsafeRawBufferPointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UTF8View: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UTF8View\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UnsafeRawPointer: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UnsafeRawPointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.V: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_V\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.updatedOptions: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_updatedOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.value: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_value\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.url: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_url"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.valueField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_valueField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_utf8"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.values: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_values\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8Ptr: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_utf8Ptr"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ValueType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ValueType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.utf8ToDouble: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_utf8ToDouble"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.varEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_var\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.UTF8View: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_UTF8View"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.verification: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_verification\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.v: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_v"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.VerificationState: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_VerificationState\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.value: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.version: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_version\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.valueField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_valueField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.versionString: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_versionString\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.values: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_values"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visibility: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visibility\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.ValueType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_ValueType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.VisibilityFeature: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_VisibilityFeature\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.varEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_var"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitExtensionFields: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitExtensionFields\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.Version: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_Version"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitExtensionFieldsAsMessageSet: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitExtensionFieldsAsMessageSet\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.versionString: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_versionString"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitMapField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitMapField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFields: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitExtensionFields"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Visitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Visitor\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitExtensionFieldsAsMessageSet: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitExtensionFieldsAsMessageSet"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPacked: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPacked\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitMapField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitMapField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedBoolField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedBoolField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedDoubleField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedDoubleField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPacked: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPacked"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedEnumField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedEnumField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedBoolField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedBoolField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedFixed32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedDoubleField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedDoubleField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedFixed64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedEnumField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedEnumField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedFloatField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedFloatField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedInt32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedInt64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedFloatField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedFloatField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedSFixed32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedSFixed64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedSInt32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedSFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedSInt64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedSFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedUInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedUInt32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedSInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedUInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedUInt64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedSInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedSInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeated: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeated\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedUInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedBoolField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedBoolField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitPackedUInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitPackedUInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedBytesField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedBytesField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeated: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeated"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedDoubleField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedDoubleField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBoolField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedBoolField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedEnumField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedEnumField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedBytesField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedBytesField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedFixed32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedDoubleField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedDoubleField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedFixed64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedEnumField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedEnumField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedFloatField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedFloatField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedGroupField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedGroupField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedInt32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedFloatField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedFloatField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedInt64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedGroupField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedGroupField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedMessageField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedMessageField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedSFixed32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedSFixed64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedMessageField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedMessageField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedSInt32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedSFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedSInt64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedSFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedStringField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedStringField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedSInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedUInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedUInt32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedSInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedSInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedUInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedUInt64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedStringField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedStringField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingular: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingular\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedUInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularBoolField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularBoolField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitRepeatedUInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitRepeatedUInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularBytesField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularBytesField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingular: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingular"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularDoubleField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularDoubleField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBoolField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularBoolField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularEnumField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularEnumField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularBytesField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularBytesField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularFixed32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularDoubleField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularDoubleField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularFixed64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularEnumField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularEnumField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularFloatField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularFloatField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularGroupField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularGroupField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularInt32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularFloatField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularFloatField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularInt64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularGroupField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularGroupField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularMessageField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularMessageField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSFixed32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularSFixed32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSFixed64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularSFixed64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularMessageField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularMessageField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularSInt32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularSFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularSInt64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSFixed64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularSFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularStringField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularStringField\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularSInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularUInt32Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularUInt32Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularSInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularSInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularUInt64Field: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularUInt64Field\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularStringField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularStringField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitUnknown: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitUnknown\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt32Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularUInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Void: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Void\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitSingularUInt64Field: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitSingularUInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.wasDecoded: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_wasDecoded\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.visitUnknown: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_visitUnknown"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.weak: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_weak\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wasDecoded: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_wasDecoded"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.weakDependency: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_weakDependency\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.weak: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_weak"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.whereEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_where\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.weakDependency: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_weakDependency"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.wireFormat: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_wireFormat\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.whereEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_where"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.with: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_with\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.wireFormat: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_wireFormat"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.withUnsafeBytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_withUnsafeBytes\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.with: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_with"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.withUnsafeMutableBytes: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_withUnsafeMutableBytes\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeBytes: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_withUnsafeBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.work: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_work\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.withUnsafeMutableBytes: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_withUnsafeMutableBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Wrapped: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Wrapped\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.work: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_work"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.WrappedType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_WrappedType\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.WrappedType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_WrappedType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.wrappedValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_wrappedValue\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.written: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_written"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.written: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_written\0") } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedEnums.yday: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "NONE_yday"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.yday: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_yday\0") } diff --git a/Tests/SwiftProtobufTests/generated_swift_names_fields.pb.swift b/Tests/SwiftProtobufTests/generated_swift_names_fields.pb.swift index b2769c8e1..815e18951 100644 --- a/Tests/SwiftProtobufTests/generated_swift_names_fields.pb.swift +++ b/Tests/SwiftProtobufTests/generated_swift_names_fields.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: generated_swift_names_fields.proto @@ -11,7 +12,6 @@ /// Protoc errors imply this file is being generated incorrectly /// Swift compile errors are probably bugs in protoc-gen-swift -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -24,4353 +24,5143 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittestGenerated_GeneratedSwiftReservedFields { +struct SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: @unchecked Sendable { // 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 addPath: Int32 { + get {_storage._addPath} + set {_uniqueStorage()._addPath = newValue} + } + var adjusted: Int32 { - get {return _storage._adjusted} + get {_storage._adjusted} set {_uniqueStorage()._adjusted = newValue} } var aggregateValue: Int32 { - get {return _storage._aggregateValue} + get {_storage._aggregateValue} set {_uniqueStorage()._aggregateValue = newValue} } var allCases: Int32 { - get {return _storage._allCases} + get {_storage._allCases} set {_uniqueStorage()._allCases = newValue} } var allowAlias: Int32 { - get {return _storage._allowAlias} + get {_storage._allowAlias} set {_uniqueStorage()._allowAlias = newValue} } var alwaysPrintEnumsAsInts: Int32 { - get {return _storage._alwaysPrintEnumsAsInts} + get {_storage._alwaysPrintEnumsAsInts} set {_uniqueStorage()._alwaysPrintEnumsAsInts = newValue} } + var alwaysPrintInt64SAsNumbers: Int32 { + get {_storage._alwaysPrintInt64SAsNumbers} + set {_uniqueStorage()._alwaysPrintInt64SAsNumbers = newValue} + } + var annotation: Int32 { - get {return _storage._annotation} + get {_storage._annotation} set {_uniqueStorage()._annotation = newValue} } var any: Int32 { - get {return _storage._any} + get {_storage._any} set {_uniqueStorage()._any = newValue} } var anyExtensionField: Int32 { - get {return _storage._anyExtensionField} + get {_storage._anyExtensionField} set {_uniqueStorage()._anyExtensionField = newValue} } var anyMessageExtension: Int32 { - get {return _storage._anyMessageExtension} + get {_storage._anyMessageExtension} set {_uniqueStorage()._anyMessageExtension = newValue} } var anyMessageStorage: Int32 { - get {return _storage._anyMessageStorage} + get {_storage._anyMessageStorage} set {_uniqueStorage()._anyMessageStorage = newValue} } var anyUnpackError: Int32 { - get {return _storage._anyUnpackError} + get {_storage._anyUnpackError} set {_uniqueStorage()._anyUnpackError = newValue} } - var api: Int32 { - get {return _storage._api} - set {_uniqueStorage()._api = newValue} + var append: Int32 { + get {_storage._append} + set {_uniqueStorage()._append = newValue} } var appended: Int32 { - get {return _storage._appended} + get {_storage._appended} set {_uniqueStorage()._appended = newValue} } var appendUintHex: Int32 { - get {return _storage._appendUintHex} + get {_storage._appendUintHex} set {_uniqueStorage()._appendUintHex = newValue} } var appendUnknown: Int32 { - get {return _storage._appendUnknown} + get {_storage._appendUnknown} set {_uniqueStorage()._appendUnknown = newValue} } var areAllInitialized: Int32 { - get {return _storage._areAllInitialized} + get {_storage._areAllInitialized} set {_uniqueStorage()._areAllInitialized = newValue} } var array: Int32 { - get {return _storage._array} + get {_storage._array} set {_uniqueStorage()._array = newValue} } var arrayDepth: Int32 { - get {return _storage._arrayDepth} + get {_storage._arrayDepth} set {_uniqueStorage()._arrayDepth = newValue} } var arrayLiteral: Int32 { - get {return _storage._arrayLiteral} + get {_storage._arrayLiteral} set {_uniqueStorage()._arrayLiteral = newValue} } var arraySeparator: Int32 { - get {return _storage._arraySeparator} + get {_storage._arraySeparator} set {_uniqueStorage()._arraySeparator = newValue} } var `as`: Int32 { - get {return _storage._as} + get {_storage._as} set {_uniqueStorage()._as = newValue} } var asciiOpenCurlyBracket: Int32 { - get {return _storage._asciiOpenCurlyBracket} + get {_storage._asciiOpenCurlyBracket} set {_uniqueStorage()._asciiOpenCurlyBracket = newValue} } var asciiZero: Int32 { - get {return _storage._asciiZero} + get {_storage._asciiZero} set {_uniqueStorage()._asciiZero = newValue} } + var async: Int32 { + get {_storage._async} + set {_uniqueStorage()._async = newValue} + } + + var asyncIterator: Int32 { + get {_storage._asyncIterator} + set {_uniqueStorage()._asyncIterator = newValue} + } + + var asyncIteratorProtocol: Int32 { + get {_storage._asyncIteratorProtocol} + set {_uniqueStorage()._asyncIteratorProtocol = newValue} + } + + var asyncMessageSequence: Int32 { + get {_storage._asyncMessageSequence} + set {_uniqueStorage()._asyncMessageSequence = newValue} + } + var available: Int32 { - get {return _storage._available} + get {_storage._available} set {_uniqueStorage()._available = newValue} } var b: Int32 { - get {return _storage._b} + get {_storage._b} set {_uniqueStorage()._b = newValue} } + var base: Int32 { + get {_storage._base} + set {_uniqueStorage()._base = newValue} + } + var base64Values: Int32 { - get {return _storage._base64Values} + get {_storage._base64Values} set {_uniqueStorage()._base64Values = newValue} } var baseAddress: Int32 { - get {return _storage._baseAddress} + get {_storage._baseAddress} set {_uniqueStorage()._baseAddress = newValue} } var baseType: Int32 { - get {return _storage._baseType} + get {_storage._baseType} set {_uniqueStorage()._baseType = newValue} } var begin: Int32 { - get {return _storage._begin} + get {_storage._begin} set {_uniqueStorage()._begin = newValue} } var binary: Int32 { - get {return _storage._binary} + get {_storage._binary} set {_uniqueStorage()._binary = newValue} } var binaryDecoder: Int32 { - get {return _storage._binaryDecoder} + get {_storage._binaryDecoder} set {_uniqueStorage()._binaryDecoder = newValue} } + var binaryDecoding: Int32 { + get {_storage._binaryDecoding} + set {_uniqueStorage()._binaryDecoding = newValue} + } + var binaryDecodingError: Int32 { - get {return _storage._binaryDecodingError} + get {_storage._binaryDecodingError} set {_uniqueStorage()._binaryDecodingError = newValue} } var binaryDecodingOptions: Int32 { - get {return _storage._binaryDecodingOptions} + get {_storage._binaryDecodingOptions} set {_uniqueStorage()._binaryDecodingOptions = newValue} } var binaryDelimited: Int32 { - get {return _storage._binaryDelimited} + get {_storage._binaryDelimited} set {_uniqueStorage()._binaryDelimited = newValue} } var binaryEncoder: Int32 { - get {return _storage._binaryEncoder} + get {_storage._binaryEncoder} set {_uniqueStorage()._binaryEncoder = newValue} } var binaryEncodingError: Int32 { - get {return _storage._binaryEncodingError} + get {_storage._binaryEncodingError} set {_uniqueStorage()._binaryEncodingError = newValue} } var binaryEncodingMessageSetSizeVisitor: Int32 { - get {return _storage._binaryEncodingMessageSetSizeVisitor} + get {_storage._binaryEncodingMessageSetSizeVisitor} set {_uniqueStorage()._binaryEncodingMessageSetSizeVisitor = newValue} } var binaryEncodingMessageSetVisitor: Int32 { - get {return _storage._binaryEncodingMessageSetVisitor} + get {_storage._binaryEncodingMessageSetVisitor} set {_uniqueStorage()._binaryEncodingMessageSetVisitor = newValue} } + var binaryEncodingOptions: Int32 { + get {_storage._binaryEncodingOptions} + set {_uniqueStorage()._binaryEncodingOptions = newValue} + } + var binaryEncodingSizeVisitor: Int32 { - get {return _storage._binaryEncodingSizeVisitor} + get {_storage._binaryEncodingSizeVisitor} set {_uniqueStorage()._binaryEncodingSizeVisitor = newValue} } var binaryEncodingVisitor: Int32 { - get {return _storage._binaryEncodingVisitor} + get {_storage._binaryEncodingVisitor} set {_uniqueStorage()._binaryEncodingVisitor = newValue} } var binaryOptions: Int32 { - get {return _storage._binaryOptions} + get {_storage._binaryOptions} set {_uniqueStorage()._binaryOptions = newValue} } + var binaryProtobufDelimitedMessages: Int32 { + get {_storage._binaryProtobufDelimitedMessages} + set {_uniqueStorage()._binaryProtobufDelimitedMessages = newValue} + } + + var binaryStreamDecoding: Int32 { + get {_storage._binaryStreamDecoding} + set {_uniqueStorage()._binaryStreamDecoding = newValue} + } + + var binaryStreamDecodingError: Int32 { + get {_storage._binaryStreamDecodingError} + set {_uniqueStorage()._binaryStreamDecodingError = newValue} + } + + var bitPattern: Int32 { + get {_storage._bitPattern} + set {_uniqueStorage()._bitPattern = newValue} + } + var body: Int32 { - get {return _storage._body} + get {_storage._body} set {_uniqueStorage()._body = newValue} } var bool: Int32 { - get {return _storage._bool} + get {_storage._bool} set {_uniqueStorage()._bool = newValue} } var booleanLiteral: Int32 { - get {return _storage._booleanLiteral} + get {_storage._booleanLiteral} set {_uniqueStorage()._booleanLiteral = newValue} } var booleanLiteralType: Int32 { - get {return _storage._booleanLiteralType} + get {_storage._booleanLiteralType} set {_uniqueStorage()._booleanLiteralType = newValue} } var boolValue: Int32 { - get {return _storage._boolValue} + get {_storage._boolValue} set {_uniqueStorage()._boolValue = newValue} } + var buffer: Int32 { + get {_storage._buffer} + set {_uniqueStorage()._buffer = newValue} + } + + var byte: Int32 { + get {_storage._byte} + set {_uniqueStorage()._byte = newValue} + } + + var bytecode: Int32 { + get {_storage._bytecode} + set {_uniqueStorage()._bytecode = newValue} + } + + var bytecodeReader: Int32 { + get {_storage._bytecodeReader} + set {_uniqueStorage()._bytecodeReader = newValue} + } + var bytes: Int32 { - get {return _storage._bytes} + get {_storage._bytes} set {_uniqueStorage()._bytes = newValue} } var bytesInGroup: Int32 { - get {return _storage._bytesInGroup} + get {_storage._bytesInGroup} set {_uniqueStorage()._bytesInGroup = newValue} } - var bytesRead: Int32 { - get {return _storage._bytesRead} - set {_uniqueStorage()._bytesRead = newValue} + var bytesNeeded: Int32 { + get {_storage._bytesNeeded} + set {_uniqueStorage()._bytesNeeded = newValue} } - var bytesValue: Int32 { - get {return _storage._bytesValue} - set {_uniqueStorage()._bytesValue = newValue} + var bytesRead: Int32 { + get {_storage._bytesRead} + set {_uniqueStorage()._bytesRead = newValue} } var c: Int32 { - get {return _storage._c} + get {_storage._c} set {_uniqueStorage()._c = newValue} } + var canonical: Int32 { + get {_storage._canonical} + set {_uniqueStorage()._canonical = newValue} + } + var capitalizeNext: Int32 { - get {return _storage._capitalizeNext} + get {_storage._capitalizeNext} set {_uniqueStorage()._capitalizeNext = newValue} } var cardinality: Int32 { - get {return _storage._cardinality} + get {_storage._cardinality} set {_uniqueStorage()._cardinality = newValue} } + var caseIterable: Int32 { + get {_storage._caseIterable} + set {_uniqueStorage()._caseIterable = newValue} + } + + var castedValue: Int32 { + get {_storage._castedValue} + set {_uniqueStorage()._castedValue = newValue} + } + var ccEnableArenas: Int32 { - get {return _storage._ccEnableArenas} + get {_storage._ccEnableArenas} set {_uniqueStorage()._ccEnableArenas = newValue} } var ccGenericServices: Int32 { - get {return _storage._ccGenericServices} + get {_storage._ccGenericServices} set {_uniqueStorage()._ccGenericServices = newValue} } var character: Int32 { - get {return _storage._character} + get {_storage._character} set {_uniqueStorage()._character = newValue} } var chars: Int32 { - get {return _storage._chars} + get {_storage._chars} set {_uniqueStorage()._chars = newValue} } + var checkProgramFormat: Int32 { + get {_storage._checkProgramFormat} + set {_uniqueStorage()._checkProgramFormat = newValue} + } + + var chunk: Int32 { + get {_storage._chunk} + set {_uniqueStorage()._chunk = newValue} + } + var `class`: Int32 { - get {return _storage._class} + get {_storage._class} set {_uniqueStorage()._class = newValue} } var clearAggregateValue_p: Int32 { - get {return _storage._clearAggregateValue_p} + get {_storage._clearAggregateValue_p} set {_uniqueStorage()._clearAggregateValue_p = newValue} } var clearAllowAlias_p: Int32 { - get {return _storage._clearAllowAlias_p} + get {_storage._clearAllowAlias_p} set {_uniqueStorage()._clearAllowAlias_p = newValue} } var clearBegin_p: Int32 { - get {return _storage._clearBegin_p} + get {_storage._clearBegin_p} set {_uniqueStorage()._clearBegin_p = newValue} } var clearCcEnableArenas_p: Int32 { - get {return _storage._clearCcEnableArenas_p} + get {_storage._clearCcEnableArenas_p} set {_uniqueStorage()._clearCcEnableArenas_p = newValue} } var clearCcGenericServices_p: Int32 { - get {return _storage._clearCcGenericServices_p} + get {_storage._clearCcGenericServices_p} set {_uniqueStorage()._clearCcGenericServices_p = newValue} } var clearClientStreaming_p: Int32 { - get {return _storage._clearClientStreaming_p} + get {_storage._clearClientStreaming_p} set {_uniqueStorage()._clearClientStreaming_p = newValue} } var clearCsharpNamespace_p: Int32 { - get {return _storage._clearCsharpNamespace_p} + get {_storage._clearCsharpNamespace_p} set {_uniqueStorage()._clearCsharpNamespace_p = newValue} } var clearCtype_p: Int32 { - get {return _storage._clearCtype_p} + get {_storage._clearCtype_p} set {_uniqueStorage()._clearCtype_p = newValue} } + var clearDebugRedact_p: Int32 { + get {_storage._clearDebugRedact_p} + set {_uniqueStorage()._clearDebugRedact_p = newValue} + } + + var clearDefaultSymbolVisibility_p: Int32 { + get {_storage._clearDefaultSymbolVisibility_p} + set {_uniqueStorage()._clearDefaultSymbolVisibility_p = newValue} + } + var clearDefaultValue_p: Int32 { - get {return _storage._clearDefaultValue_p} + get {_storage._clearDefaultValue_p} set {_uniqueStorage()._clearDefaultValue_p = newValue} } var clearDeprecated_p: Int32 { - get {return _storage._clearDeprecated_p} + get {_storage._clearDeprecated_p} set {_uniqueStorage()._clearDeprecated_p = newValue} } + var clearDeprecatedLegacyJsonFieldConflicts_p: Int32 { + get {_storage._clearDeprecatedLegacyJsonFieldConflicts_p} + set {_uniqueStorage()._clearDeprecatedLegacyJsonFieldConflicts_p = newValue} + } + + var clearDeprecationWarning_p: Int32 { + get {_storage._clearDeprecationWarning_p} + set {_uniqueStorage()._clearDeprecationWarning_p = newValue} + } + var clearDoubleValue_p: Int32 { - get {return _storage._clearDoubleValue_p} + get {_storage._clearDoubleValue_p} set {_uniqueStorage()._clearDoubleValue_p = newValue} } + var clearEdition_p: Int32 { + get {_storage._clearEdition_p} + set {_uniqueStorage()._clearEdition_p = newValue} + } + + var clearEditionDeprecated_p: Int32 { + get {_storage._clearEditionDeprecated_p} + set {_uniqueStorage()._clearEditionDeprecated_p = newValue} + } + + var clearEditionIntroduced_p: Int32 { + get {_storage._clearEditionIntroduced_p} + set {_uniqueStorage()._clearEditionIntroduced_p = newValue} + } + + var clearEditionRemoved_p: Int32 { + get {_storage._clearEditionRemoved_p} + set {_uniqueStorage()._clearEditionRemoved_p = newValue} + } + var clearEnd_p: Int32 { - get {return _storage._clearEnd_p} + get {_storage._clearEnd_p} set {_uniqueStorage()._clearEnd_p = newValue} } + var clearEnforceNamingStyle_p: Int32 { + get {_storage._clearEnforceNamingStyle_p} + set {_uniqueStorage()._clearEnforceNamingStyle_p = newValue} + } + + var clearEnumType_p: Int32 { + get {_storage._clearEnumType_p} + set {_uniqueStorage()._clearEnumType_p = newValue} + } + var clearExtendee_p: Int32 { - get {return _storage._clearExtendee_p} + get {_storage._clearExtendee_p} set {_uniqueStorage()._clearExtendee_p = newValue} } var clearExtensionValue_p: Int32 { - get {return _storage._clearExtensionValue_p} + get {_storage._clearExtensionValue_p} set {_uniqueStorage()._clearExtensionValue_p = newValue} } + var clearFeatures_p: Int32 { + get {_storage._clearFeatures_p} + set {_uniqueStorage()._clearFeatures_p = newValue} + } + + var clearFeatureSupport_p: Int32 { + get {_storage._clearFeatureSupport_p} + set {_uniqueStorage()._clearFeatureSupport_p = newValue} + } + + var clearFieldPresence_p: Int32 { + get {_storage._clearFieldPresence_p} + set {_uniqueStorage()._clearFieldPresence_p = newValue} + } + + var clearFixedFeatures_p: Int32 { + get {_storage._clearFixedFeatures_p} + set {_uniqueStorage()._clearFixedFeatures_p = newValue} + } + + var clearFullName_p: Int32 { + get {_storage._clearFullName_p} + set {_uniqueStorage()._clearFullName_p = newValue} + } + var clearGoPackage_p: Int32 { - get {return _storage._clearGoPackage_p} + get {_storage._clearGoPackage_p} set {_uniqueStorage()._clearGoPackage_p = newValue} } var clearIdempotencyLevel_p: Int32 { - get {return _storage._clearIdempotencyLevel_p} + get {_storage._clearIdempotencyLevel_p} set {_uniqueStorage()._clearIdempotencyLevel_p = newValue} } var clearIdentifierValue_p: Int32 { - get {return _storage._clearIdentifierValue_p} + get {_storage._clearIdentifierValue_p} set {_uniqueStorage()._clearIdentifierValue_p = newValue} } var clearInputType_p: Int32 { - get {return _storage._clearInputType_p} + get {_storage._clearInputType_p} set {_uniqueStorage()._clearInputType_p = newValue} } var clearIsExtension_p: Int32 { - get {return _storage._clearIsExtension_p} + get {_storage._clearIsExtension_p} set {_uniqueStorage()._clearIsExtension_p = newValue} } var clearJavaGenerateEqualsAndHash_p: Int32 { - get {return _storage._clearJavaGenerateEqualsAndHash_p} + get {_storage._clearJavaGenerateEqualsAndHash_p} set {_uniqueStorage()._clearJavaGenerateEqualsAndHash_p = newValue} } var clearJavaGenericServices_p: Int32 { - get {return _storage._clearJavaGenericServices_p} + get {_storage._clearJavaGenericServices_p} set {_uniqueStorage()._clearJavaGenericServices_p = newValue} } var clearJavaMultipleFiles_p: Int32 { - get {return _storage._clearJavaMultipleFiles_p} + get {_storage._clearJavaMultipleFiles_p} set {_uniqueStorage()._clearJavaMultipleFiles_p = newValue} } var clearJavaOuterClassname_p: Int32 { - get {return _storage._clearJavaOuterClassname_p} + get {_storage._clearJavaOuterClassname_p} set {_uniqueStorage()._clearJavaOuterClassname_p = newValue} } var clearJavaPackage_p: Int32 { - get {return _storage._clearJavaPackage_p} + get {_storage._clearJavaPackage_p} set {_uniqueStorage()._clearJavaPackage_p = newValue} } var clearJavaStringCheckUtf8_p: Int32 { - get {return _storage._clearJavaStringCheckUtf8_p} + get {_storage._clearJavaStringCheckUtf8_p} set {_uniqueStorage()._clearJavaStringCheckUtf8_p = newValue} } + var clearJsonFormat_p: Int32 { + get {_storage._clearJsonFormat_p} + set {_uniqueStorage()._clearJsonFormat_p = newValue} + } + var clearJsonName_p: Int32 { - get {return _storage._clearJsonName_p} + get {_storage._clearJsonName_p} set {_uniqueStorage()._clearJsonName_p = newValue} } var clearJstype_p: Int32 { - get {return _storage._clearJstype_p} + get {_storage._clearJstype_p} set {_uniqueStorage()._clearJstype_p = newValue} } var clearLabel_p: Int32 { - get {return _storage._clearLabel_p} + get {_storage._clearLabel_p} set {_uniqueStorage()._clearLabel_p = newValue} } var clearLazy_p: Int32 { - get {return _storage._clearLazy_p} + get {_storage._clearLazy_p} set {_uniqueStorage()._clearLazy_p = newValue} } var clearLeadingComments_p: Int32 { - get {return _storage._clearLeadingComments_p} + get {_storage._clearLeadingComments_p} set {_uniqueStorage()._clearLeadingComments_p = newValue} } var clearMapEntry_p: Int32 { - get {return _storage._clearMapEntry_p} + get {_storage._clearMapEntry_p} set {_uniqueStorage()._clearMapEntry_p = newValue} } + var clearMaximumEdition_p: Int32 { + get {_storage._clearMaximumEdition_p} + set {_uniqueStorage()._clearMaximumEdition_p = newValue} + } + + var clearMessageEncoding_p: Int32 { + get {_storage._clearMessageEncoding_p} + set {_uniqueStorage()._clearMessageEncoding_p = newValue} + } + var clearMessageSetWireFormat_p: Int32 { - get {return _storage._clearMessageSetWireFormat_p} + get {_storage._clearMessageSetWireFormat_p} set {_uniqueStorage()._clearMessageSetWireFormat_p = newValue} } + var clearMinimumEdition_p: Int32 { + get {_storage._clearMinimumEdition_p} + set {_uniqueStorage()._clearMinimumEdition_p = newValue} + } + var clearName_p: Int32 { - get {return _storage._clearName_p} + get {_storage._clearName_p} set {_uniqueStorage()._clearName_p = newValue} } var clearNamePart_p: Int32 { - get {return _storage._clearNamePart_p} + get {_storage._clearNamePart_p} set {_uniqueStorage()._clearNamePart_p = newValue} } var clearNegativeIntValue_p: Int32 { - get {return _storage._clearNegativeIntValue_p} + get {_storage._clearNegativeIntValue_p} set {_uniqueStorage()._clearNegativeIntValue_p = newValue} } var clearNoStandardDescriptorAccessor_p: Int32 { - get {return _storage._clearNoStandardDescriptorAccessor_p} + get {_storage._clearNoStandardDescriptorAccessor_p} set {_uniqueStorage()._clearNoStandardDescriptorAccessor_p = newValue} } var clearNumber_p: Int32 { - get {return _storage._clearNumber_p} + get {_storage._clearNumber_p} set {_uniqueStorage()._clearNumber_p = newValue} } var clearObjcClassPrefix_p: Int32 { - get {return _storage._clearObjcClassPrefix_p} + get {_storage._clearObjcClassPrefix_p} set {_uniqueStorage()._clearObjcClassPrefix_p = newValue} } var clearOneofIndex_p: Int32 { - get {return _storage._clearOneofIndex_p} + get {_storage._clearOneofIndex_p} set {_uniqueStorage()._clearOneofIndex_p = newValue} } var clearOptimizeFor_p: Int32 { - get {return _storage._clearOptimizeFor_p} + get {_storage._clearOptimizeFor_p} set {_uniqueStorage()._clearOptimizeFor_p = newValue} } var clearOptions_p: Int32 { - get {return _storage._clearOptions_p} + get {_storage._clearOptions_p} set {_uniqueStorage()._clearOptions_p = newValue} } var clearOutputType_p: Int32 { - get {return _storage._clearOutputType_p} + get {_storage._clearOutputType_p} set {_uniqueStorage()._clearOutputType_p = newValue} } + var clearOverridableFeatures_p: Int32 { + get {_storage._clearOverridableFeatures_p} + set {_uniqueStorage()._clearOverridableFeatures_p = newValue} + } + var clearPackage_p: Int32 { - get {return _storage._clearPackage_p} + get {_storage._clearPackage_p} set {_uniqueStorage()._clearPackage_p = newValue} } var clearPacked_p: Int32 { - get {return _storage._clearPacked_p} + get {_storage._clearPacked_p} set {_uniqueStorage()._clearPacked_p = newValue} } var clearPhpClassPrefix_p: Int32 { - get {return _storage._clearPhpClassPrefix_p} + get {_storage._clearPhpClassPrefix_p} set {_uniqueStorage()._clearPhpClassPrefix_p = newValue} } - var clearPhpGenericServices_p: Int32 { - get {return _storage._clearPhpGenericServices_p} - set {_uniqueStorage()._clearPhpGenericServices_p = newValue} - } - var clearPhpMetadataNamespace_p: Int32 { - get {return _storage._clearPhpMetadataNamespace_p} + get {_storage._clearPhpMetadataNamespace_p} set {_uniqueStorage()._clearPhpMetadataNamespace_p = newValue} } var clearPhpNamespace_p: Int32 { - get {return _storage._clearPhpNamespace_p} + get {_storage._clearPhpNamespace_p} set {_uniqueStorage()._clearPhpNamespace_p = newValue} } var clearPositiveIntValue_p: Int32 { - get {return _storage._clearPositiveIntValue_p} + get {_storage._clearPositiveIntValue_p} set {_uniqueStorage()._clearPositiveIntValue_p = newValue} } var clearProto3Optional_p: Int32 { - get {return _storage._clearProto3Optional_p} + get {_storage._clearProto3Optional_p} set {_uniqueStorage()._clearProto3Optional_p = newValue} } var clearPyGenericServices_p: Int32 { - get {return _storage._clearPyGenericServices_p} + get {_storage._clearPyGenericServices_p} set {_uniqueStorage()._clearPyGenericServices_p = newValue} } + var clearRemovalError_p: Int32 { + get {_storage._clearRemovalError_p} + set {_uniqueStorage()._clearRemovalError_p = newValue} + } + + var clearRepeated_p: Int32 { + get {_storage._clearRepeated_p} + set {_uniqueStorage()._clearRepeated_p = newValue} + } + + var clearRepeatedFieldEncoding_p: Int32 { + get {_storage._clearRepeatedFieldEncoding_p} + set {_uniqueStorage()._clearRepeatedFieldEncoding_p = newValue} + } + + var clearReserved_p: Int32 { + get {_storage._clearReserved_p} + set {_uniqueStorage()._clearReserved_p = newValue} + } + + var clearRetention_p: Int32 { + get {_storage._clearRetention_p} + set {_uniqueStorage()._clearRetention_p = newValue} + } + var clearRubyPackage_p: Int32 { - get {return _storage._clearRubyPackage_p} + get {_storage._clearRubyPackage_p} set {_uniqueStorage()._clearRubyPackage_p = newValue} } + var clearSemantic_p: Int32 { + get {_storage._clearSemantic_p} + set {_uniqueStorage()._clearSemantic_p = newValue} + } + var clearServerStreaming_p: Int32 { - get {return _storage._clearServerStreaming_p} + get {_storage._clearServerStreaming_p} set {_uniqueStorage()._clearServerStreaming_p = newValue} } var clearSourceCodeInfo_p: Int32 { - get {return _storage._clearSourceCodeInfo_p} + get {_storage._clearSourceCodeInfo_p} set {_uniqueStorage()._clearSourceCodeInfo_p = newValue} } var clearSourceContext_p: Int32 { - get {return _storage._clearSourceContext_p} + get {_storage._clearSourceContext_p} set {_uniqueStorage()._clearSourceContext_p = newValue} } var clearSourceFile_p: Int32 { - get {return _storage._clearSourceFile_p} + get {_storage._clearSourceFile_p} set {_uniqueStorage()._clearSourceFile_p = newValue} } var clearStart_p: Int32 { - get {return _storage._clearStart_p} + get {_storage._clearStart_p} set {_uniqueStorage()._clearStart_p = newValue} } var clearStringValue_p: Int32 { - get {return _storage._clearStringValue_p} + get {_storage._clearStringValue_p} set {_uniqueStorage()._clearStringValue_p = newValue} } var clearSwiftPrefix_p: Int32 { - get {return _storage._clearSwiftPrefix_p} + get {_storage._clearSwiftPrefix_p} set {_uniqueStorage()._clearSwiftPrefix_p = newValue} } var clearSyntax_p: Int32 { - get {return _storage._clearSyntax_p} + get {_storage._clearSyntax_p} set {_uniqueStorage()._clearSyntax_p = newValue} } var clearTrailingComments_p: Int32 { - get {return _storage._clearTrailingComments_p} + get {_storage._clearTrailingComments_p} set {_uniqueStorage()._clearTrailingComments_p = newValue} } var clearType_p: Int32 { - get {return _storage._clearType_p} + get {_storage._clearType_p} set {_uniqueStorage()._clearType_p = newValue} } var clearTypeName_p: Int32 { - get {return _storage._clearTypeName_p} + get {_storage._clearTypeName_p} set {_uniqueStorage()._clearTypeName_p = newValue} } + var clearUnverifiedLazy_p: Int32 { + get {_storage._clearUnverifiedLazy_p} + set {_uniqueStorage()._clearUnverifiedLazy_p = newValue} + } + + var clearUtf8Validation_p: Int32 { + get {_storage._clearUtf8Validation_p} + set {_uniqueStorage()._clearUtf8Validation_p = newValue} + } + var clearValue_p: Int32 { - get {return _storage._clearValue_p} + get {_storage._clearValue_p} set {_uniqueStorage()._clearValue_p = newValue} } + var clearVerification_p: Int32 { + get {_storage._clearVerification_p} + set {_uniqueStorage()._clearVerification_p = newValue} + } + + var clearVisibility_p: Int32 { + get {_storage._clearVisibility_p} + set {_uniqueStorage()._clearVisibility_p = newValue} + } + var clearWeak_p: Int32 { - get {return _storage._clearWeak_p} + get {_storage._clearWeak_p} set {_uniqueStorage()._clearWeak_p = newValue} } var clientStreaming: Int32 { - get {return _storage._clientStreaming} + get {_storage._clientStreaming} set {_uniqueStorage()._clientStreaming = newValue} } + var code: Int32 { + get {_storage._code} + set {_uniqueStorage()._code = newValue} + } + var codePoint: Int32 { - get {return _storage._codePoint} + get {_storage._codePoint} set {_uniqueStorage()._codePoint = newValue} } var codeUnits: Int32 { - get {return _storage._codeUnits} + get {_storage._codeUnits} set {_uniqueStorage()._codeUnits = newValue} } var collection: Int32 { - get {return _storage._collection} + get {_storage._collection} set {_uniqueStorage()._collection = newValue} } - var com: Int32 { - get {return _storage._com} - set {_uniqueStorage()._com = newValue} - } - var comma: Int32 { - get {return _storage._comma} + get {_storage._comma} set {_uniqueStorage()._comma = newValue} } + var consumedBytes: Int32 { + get {_storage._consumedBytes} + set {_uniqueStorage()._consumedBytes = newValue} + } + + var contains: Int32 { + get {_storage._contains} + set {_uniqueStorage()._contains = newValue} + } + var contentsOf: Int32 { - get {return _storage._contentsOf} + get {_storage._contentsOf} set {_uniqueStorage()._contentsOf = newValue} } var contiguousBytes: Int32 { - get {return _storage._contiguousBytes} + get {_storage._contiguousBytes} set {_uniqueStorage()._contiguousBytes = newValue} } + var copy: Int32 { + get {_storage._copy} + set {_uniqueStorage()._copy = newValue} + } + var count: Int32 { - get {return _storage._count} + get {_storage._count} set {_uniqueStorage()._count = newValue} } var countVarintsInBuffer: Int32 { - get {return _storage._countVarintsInBuffer} + get {_storage._countVarintsInBuffer} set {_uniqueStorage()._countVarintsInBuffer = newValue} } var csharpNamespace: Int32 { - get {return _storage._csharpNamespace} + get {_storage._csharpNamespace} set {_uniqueStorage()._csharpNamespace = newValue} } var ctype: Int32 { - get {return _storage._ctype} + get {_storage._ctype} set {_uniqueStorage()._ctype = newValue} } var customCodable: Int32 { - get {return _storage._customCodable} + get {_storage._customCodable} set {_uniqueStorage()._customCodable = newValue} } var customDebugStringConvertible: Int32 { - get {return _storage._customDebugStringConvertible} + get {_storage._customDebugStringConvertible} set {_uniqueStorage()._customDebugStringConvertible = newValue} } + var customStringConvertible: Int32 { + get {_storage._customStringConvertible} + set {_uniqueStorage()._customStringConvertible = newValue} + } + var d: Int32 { - get {return _storage._d} + get {_storage._d} set {_uniqueStorage()._d = newValue} } var data: Int32 { - get {return _storage._data} + get {_storage._data} set {_uniqueStorage()._data = newValue} } var dataResult: Int32 { - get {return _storage._dataResult} + get {_storage._dataResult} set {_uniqueStorage()._dataResult = newValue} } var date: Int32 { - get {return _storage._date} + get {_storage._date} set {_uniqueStorage()._date = newValue} } var daySec: Int32 { - get {return _storage._daySec} + get {_storage._daySec} set {_uniqueStorage()._daySec = newValue} } var daysSinceEpoch: Int32 { - get {return _storage._daysSinceEpoch} + get {_storage._daysSinceEpoch} set {_uniqueStorage()._daysSinceEpoch = newValue} } var debugDescription_p: Int32 { - get {return _storage._debugDescription_p} + get {_storage._debugDescription_p} set {_uniqueStorage()._debugDescription_p = newValue} } + var debugRedact: Int32 { + get {_storage._debugRedact} + set {_uniqueStorage()._debugRedact = newValue} + } + + var declaration: Int32 { + get {_storage._declaration} + set {_uniqueStorage()._declaration = newValue} + } + var decoded: Int32 { - get {return _storage._decoded} + get {_storage._decoded} set {_uniqueStorage()._decoded = newValue} } var decodedFromJsonnull: Int32 { - get {return _storage._decodedFromJsonnull} + get {_storage._decodedFromJsonnull} set {_uniqueStorage()._decodedFromJsonnull = newValue} } var decodeExtensionField: Int32 { - get {return _storage._decodeExtensionField} + get {_storage._decodeExtensionField} set {_uniqueStorage()._decodeExtensionField = newValue} } var decodeExtensionFieldsAsMessageSet: Int32 { - get {return _storage._decodeExtensionFieldsAsMessageSet} + get {_storage._decodeExtensionFieldsAsMessageSet} set {_uniqueStorage()._decodeExtensionFieldsAsMessageSet = newValue} } var decodeJson: Int32 { - get {return _storage._decodeJson} + get {_storage._decodeJson} set {_uniqueStorage()._decodeJson = newValue} } var decodeMapField: Int32 { - get {return _storage._decodeMapField} + get {_storage._decodeMapField} set {_uniqueStorage()._decodeMapField = newValue} } var decodeMessage: Int32 { - get {return _storage._decodeMessage} + get {_storage._decodeMessage} set {_uniqueStorage()._decodeMessage = newValue} } var decoder: Int32 { - get {return _storage._decoder} + get {_storage._decoder} set {_uniqueStorage()._decoder = newValue} } var decodeRepeated: Int32 { - get {return _storage._decodeRepeated} + get {_storage._decodeRepeated} set {_uniqueStorage()._decodeRepeated = newValue} } var decodeRepeatedBoolField: Int32 { - get {return _storage._decodeRepeatedBoolField} + get {_storage._decodeRepeatedBoolField} set {_uniqueStorage()._decodeRepeatedBoolField = newValue} } var decodeRepeatedBytesField: Int32 { - get {return _storage._decodeRepeatedBytesField} + get {_storage._decodeRepeatedBytesField} set {_uniqueStorage()._decodeRepeatedBytesField = newValue} } var decodeRepeatedDoubleField: Int32 { - get {return _storage._decodeRepeatedDoubleField} + get {_storage._decodeRepeatedDoubleField} set {_uniqueStorage()._decodeRepeatedDoubleField = newValue} } var decodeRepeatedEnumField: Int32 { - get {return _storage._decodeRepeatedEnumField} + get {_storage._decodeRepeatedEnumField} set {_uniqueStorage()._decodeRepeatedEnumField = newValue} } var decodeRepeatedFixed32Field: Int32 { - get {return _storage._decodeRepeatedFixed32Field} + get {_storage._decodeRepeatedFixed32Field} set {_uniqueStorage()._decodeRepeatedFixed32Field = newValue} } var decodeRepeatedFixed64Field: Int32 { - get {return _storage._decodeRepeatedFixed64Field} + get {_storage._decodeRepeatedFixed64Field} set {_uniqueStorage()._decodeRepeatedFixed64Field = newValue} } var decodeRepeatedFloatField: Int32 { - get {return _storage._decodeRepeatedFloatField} + get {_storage._decodeRepeatedFloatField} set {_uniqueStorage()._decodeRepeatedFloatField = newValue} } var decodeRepeatedGroupField: Int32 { - get {return _storage._decodeRepeatedGroupField} + get {_storage._decodeRepeatedGroupField} set {_uniqueStorage()._decodeRepeatedGroupField = newValue} } var decodeRepeatedInt32Field: Int32 { - get {return _storage._decodeRepeatedInt32Field} + get {_storage._decodeRepeatedInt32Field} set {_uniqueStorage()._decodeRepeatedInt32Field = newValue} } var decodeRepeatedInt64Field: Int32 { - get {return _storage._decodeRepeatedInt64Field} + get {_storage._decodeRepeatedInt64Field} set {_uniqueStorage()._decodeRepeatedInt64Field = newValue} } var decodeRepeatedMessageField: Int32 { - get {return _storage._decodeRepeatedMessageField} + get {_storage._decodeRepeatedMessageField} set {_uniqueStorage()._decodeRepeatedMessageField = newValue} } var decodeRepeatedSfixed32Field: Int32 { - get {return _storage._decodeRepeatedSfixed32Field} + get {_storage._decodeRepeatedSfixed32Field} set {_uniqueStorage()._decodeRepeatedSfixed32Field = newValue} } var decodeRepeatedSfixed64Field: Int32 { - get {return _storage._decodeRepeatedSfixed64Field} + get {_storage._decodeRepeatedSfixed64Field} set {_uniqueStorage()._decodeRepeatedSfixed64Field = newValue} } var decodeRepeatedSint32Field: Int32 { - get {return _storage._decodeRepeatedSint32Field} + get {_storage._decodeRepeatedSint32Field} set {_uniqueStorage()._decodeRepeatedSint32Field = newValue} } var decodeRepeatedSint64Field: Int32 { - get {return _storage._decodeRepeatedSint64Field} + get {_storage._decodeRepeatedSint64Field} set {_uniqueStorage()._decodeRepeatedSint64Field = newValue} } var decodeRepeatedStringField: Int32 { - get {return _storage._decodeRepeatedStringField} + get {_storage._decodeRepeatedStringField} set {_uniqueStorage()._decodeRepeatedStringField = newValue} } var decodeRepeatedUint32Field: Int32 { - get {return _storage._decodeRepeatedUint32Field} + get {_storage._decodeRepeatedUint32Field} set {_uniqueStorage()._decodeRepeatedUint32Field = newValue} } var decodeRepeatedUint64Field: Int32 { - get {return _storage._decodeRepeatedUint64Field} + get {_storage._decodeRepeatedUint64Field} set {_uniqueStorage()._decodeRepeatedUint64Field = newValue} } var decodeSingular: Int32 { - get {return _storage._decodeSingular} + get {_storage._decodeSingular} set {_uniqueStorage()._decodeSingular = newValue} } var decodeSingularBoolField: Int32 { - get {return _storage._decodeSingularBoolField} + get {_storage._decodeSingularBoolField} set {_uniqueStorage()._decodeSingularBoolField = newValue} } var decodeSingularBytesField: Int32 { - get {return _storage._decodeSingularBytesField} + get {_storage._decodeSingularBytesField} set {_uniqueStorage()._decodeSingularBytesField = newValue} } var decodeSingularDoubleField: Int32 { - get {return _storage._decodeSingularDoubleField} + get {_storage._decodeSingularDoubleField} set {_uniqueStorage()._decodeSingularDoubleField = newValue} } var decodeSingularEnumField: Int32 { - get {return _storage._decodeSingularEnumField} + get {_storage._decodeSingularEnumField} set {_uniqueStorage()._decodeSingularEnumField = newValue} } var decodeSingularFixed32Field: Int32 { - get {return _storage._decodeSingularFixed32Field} + get {_storage._decodeSingularFixed32Field} set {_uniqueStorage()._decodeSingularFixed32Field = newValue} } var decodeSingularFixed64Field: Int32 { - get {return _storage._decodeSingularFixed64Field} + get {_storage._decodeSingularFixed64Field} set {_uniqueStorage()._decodeSingularFixed64Field = newValue} } var decodeSingularFloatField: Int32 { - get {return _storage._decodeSingularFloatField} + get {_storage._decodeSingularFloatField} set {_uniqueStorage()._decodeSingularFloatField = newValue} } var decodeSingularGroupField: Int32 { - get {return _storage._decodeSingularGroupField} + get {_storage._decodeSingularGroupField} set {_uniqueStorage()._decodeSingularGroupField = newValue} } var decodeSingularInt32Field: Int32 { - get {return _storage._decodeSingularInt32Field} + get {_storage._decodeSingularInt32Field} set {_uniqueStorage()._decodeSingularInt32Field = newValue} } var decodeSingularInt64Field: Int32 { - get {return _storage._decodeSingularInt64Field} + get {_storage._decodeSingularInt64Field} set {_uniqueStorage()._decodeSingularInt64Field = newValue} } var decodeSingularMessageField: Int32 { - get {return _storage._decodeSingularMessageField} + get {_storage._decodeSingularMessageField} set {_uniqueStorage()._decodeSingularMessageField = newValue} } var decodeSingularSfixed32Field: Int32 { - get {return _storage._decodeSingularSfixed32Field} + get {_storage._decodeSingularSfixed32Field} set {_uniqueStorage()._decodeSingularSfixed32Field = newValue} } var decodeSingularSfixed64Field: Int32 { - get {return _storage._decodeSingularSfixed64Field} + get {_storage._decodeSingularSfixed64Field} set {_uniqueStorage()._decodeSingularSfixed64Field = newValue} } var decodeSingularSint32Field: Int32 { - get {return _storage._decodeSingularSint32Field} + get {_storage._decodeSingularSint32Field} set {_uniqueStorage()._decodeSingularSint32Field = newValue} } var decodeSingularSint64Field: Int32 { - get {return _storage._decodeSingularSint64Field} + get {_storage._decodeSingularSint64Field} set {_uniqueStorage()._decodeSingularSint64Field = newValue} } var decodeSingularStringField: Int32 { - get {return _storage._decodeSingularStringField} + get {_storage._decodeSingularStringField} set {_uniqueStorage()._decodeSingularStringField = newValue} } var decodeSingularUint32Field: Int32 { - get {return _storage._decodeSingularUint32Field} + get {_storage._decodeSingularUint32Field} set {_uniqueStorage()._decodeSingularUint32Field = newValue} } var decodeSingularUint64Field: Int32 { - get {return _storage._decodeSingularUint64Field} + get {_storage._decodeSingularUint64Field} set {_uniqueStorage()._decodeSingularUint64Field = newValue} } var decodeTextFormat: Int32 { - get {return _storage._decodeTextFormat} + get {_storage._decodeTextFormat} set {_uniqueStorage()._decodeTextFormat = newValue} } var defaultAnyTypeUrlprefix: Int32 { - get {return _storage._defaultAnyTypeUrlprefix} + get {_storage._defaultAnyTypeUrlprefix} set {_uniqueStorage()._defaultAnyTypeUrlprefix = newValue} } + var defaults: Int32 { + get {_storage._defaults} + set {_uniqueStorage()._defaults = newValue} + } + + var defaultSymbolVisibility: Int32 { + get {_storage._defaultSymbolVisibility} + set {_uniqueStorage()._defaultSymbolVisibility = newValue} + } + var defaultValue: Int32 { - get {return _storage._defaultValue} + get {_storage._defaultValue} set {_uniqueStorage()._defaultValue = newValue} } var dependency: Int32 { - get {return _storage._dependency} + get {_storage._dependency} set {_uniqueStorage()._dependency = newValue} } var deprecated: Int32 { - get {return _storage._deprecated} + get {_storage._deprecated} set {_uniqueStorage()._deprecated = newValue} } - var description_p: Int32 { - get {return _storage._description_p} - set {_uniqueStorage()._description_p = newValue} + var deprecatedLegacyJsonFieldConflicts: Int32 { + get {_storage._deprecatedLegacyJsonFieldConflicts} + set {_uniqueStorage()._deprecatedLegacyJsonFieldConflicts = newValue} } - var descriptorProto: Int32 { - get {return _storage._descriptorProto} - set {_uniqueStorage()._descriptorProto = newValue} + var deprecationWarning: Int32 { + get {_storage._deprecationWarning} + set {_uniqueStorage()._deprecationWarning = newValue} + } + + var description_p: Int32 { + get {_storage._description_p} + set {_uniqueStorage()._description_p = newValue} } var dictionary: Int32 { - get {return _storage._dictionary} + get {_storage._dictionary} set {_uniqueStorage()._dictionary = newValue} } var dictionaryLiteral: Int32 { - get {return _storage._dictionaryLiteral} + get {_storage._dictionaryLiteral} set {_uniqueStorage()._dictionaryLiteral = newValue} } var digit: Int32 { - get {return _storage._digit} + get {_storage._digit} set {_uniqueStorage()._digit = newValue} } var digit0: Int32 { - get {return _storage._digit0} + get {_storage._digit0} set {_uniqueStorage()._digit0 = newValue} } var digit1: Int32 { - get {return _storage._digit1} + get {_storage._digit1} set {_uniqueStorage()._digit1 = newValue} } var digitCount: Int32 { - get {return _storage._digitCount} + get {_storage._digitCount} set {_uniqueStorage()._digitCount = newValue} } var digits: Int32 { - get {return _storage._digits} + get {_storage._digits} set {_uniqueStorage()._digits = newValue} } var digitValue: Int32 { - get {return _storage._digitValue} + get {_storage._digitValue} set {_uniqueStorage()._digitValue = newValue} } var discardableResult: Int32 { - get {return _storage._discardableResult} + get {_storage._discardableResult} set {_uniqueStorage()._discardableResult = newValue} } var discardUnknownFields: Int32 { - get {return _storage._discardUnknownFields} + get {_storage._discardUnknownFields} set {_uniqueStorage()._discardUnknownFields = newValue} } - var distance: Int32 { - get {return _storage._distance} - set {_uniqueStorage()._distance = newValue} - } - var double: Int32 { - get {return _storage._double} + get {_storage._double} set {_uniqueStorage()._double = newValue} } var doubleValue: Int32 { - get {return _storage._doubleValue} + get {_storage._doubleValue} set {_uniqueStorage()._doubleValue = newValue} } var duration: Int32 { - get {return _storage._duration} + get {_storage._duration} set {_uniqueStorage()._duration = newValue} } var e: Int32 { - get {return _storage._e} + get {_storage._e} set {_uniqueStorage()._e = newValue} } + var edition: Int32 { + get {_storage._edition} + set {_uniqueStorage()._edition = newValue} + } + + var editionDefault: Int32 { + get {_storage._editionDefault} + set {_uniqueStorage()._editionDefault = newValue} + } + + var editionDefaults: Int32 { + get {_storage._editionDefaults} + set {_uniqueStorage()._editionDefaults = newValue} + } + + var editionDeprecated: Int32 { + get {_storage._editionDeprecated} + set {_uniqueStorage()._editionDeprecated = newValue} + } + + var editionIntroduced: Int32 { + get {_storage._editionIntroduced} + set {_uniqueStorage()._editionIntroduced = newValue} + } + + var editionRemoved: Int32 { + get {_storage._editionRemoved} + set {_uniqueStorage()._editionRemoved = newValue} + } + var element: Int32 { - get {return _storage._element} + get {_storage._element} set {_uniqueStorage()._element = newValue} } var elements: Int32 { - get {return _storage._elements} + get {_storage._elements} set {_uniqueStorage()._elements = newValue} } + var `else`: Int32 { + get {_storage._else} + set {_uniqueStorage()._else = newValue} + } + var emitExtensionFieldName: Int32 { - get {return _storage._emitExtensionFieldName} + get {_storage._emitExtensionFieldName} set {_uniqueStorage()._emitExtensionFieldName = newValue} } var emitFieldName: Int32 { - get {return _storage._emitFieldName} + get {_storage._emitFieldName} set {_uniqueStorage()._emitFieldName = newValue} } var emitFieldNumber: Int32 { - get {return _storage._emitFieldNumber} + get {_storage._emitFieldNumber} set {_uniqueStorage()._emitFieldNumber = newValue} } - var empty: Int32 { - get {return _storage._empty} - set {_uniqueStorage()._empty = newValue} + var emptyAnyTypeURL: Int32 { + get {_storage._emptyAnyTypeURL} + set {_uniqueStorage()._emptyAnyTypeURL = newValue} } var emptyData: Int32 { - get {return _storage._emptyData} + get {_storage._emptyData} set {_uniqueStorage()._emptyData = newValue} } var encodeAsBytes: Int32 { - get {return _storage._encodeAsBytes} + get {_storage._encodeAsBytes} set {_uniqueStorage()._encodeAsBytes = newValue} } var encoded: Int32 { - get {return _storage._encoded} + get {_storage._encoded} set {_uniqueStorage()._encoded = newValue} } var encodedJsonstring: Int32 { - get {return _storage._encodedJsonstring} + get {_storage._encodedJsonstring} set {_uniqueStorage()._encodedJsonstring = newValue} } var encodedSize: Int32 { - get {return _storage._encodedSize} + get {_storage._encodedSize} set {_uniqueStorage()._encodedSize = newValue} } var encodeField: Int32 { - get {return _storage._encodeField} + get {_storage._encodeField} set {_uniqueStorage()._encodeField = newValue} } var encoder: Int32 { - get {return _storage._encoder} + get {_storage._encoder} set {_uniqueStorage()._encoder = newValue} } var end: Int32 { - get {return _storage._end} + get {_storage._end} set {_uniqueStorage()._end = newValue} } var endArray: Int32 { - get {return _storage._endArray} + get {_storage._endArray} set {_uniqueStorage()._endArray = newValue} } var endMessageField: Int32 { - get {return _storage._endMessageField} + get {_storage._endMessageField} set {_uniqueStorage()._endMessageField = newValue} } var endObject: Int32 { - get {return _storage._endObject} + get {_storage._endObject} set {_uniqueStorage()._endObject = newValue} } var endRegularField: Int32 { - get {return _storage._endRegularField} + get {_storage._endRegularField} set {_uniqueStorage()._endRegularField = newValue} } - var `enum`: Int32 { - get {return _storage._enum} - set {_uniqueStorage()._enum = newValue} - } - - var enumDescriptorProto: Int32 { - get {return _storage._enumDescriptorProto} - set {_uniqueStorage()._enumDescriptorProto = newValue} + var enforceNamingStyle: Int32 { + get {_storage._enforceNamingStyle} + set {_uniqueStorage()._enforceNamingStyle = newValue} } - var enumOptions: Int32 { - get {return _storage._enumOptions} - set {_uniqueStorage()._enumOptions = newValue} + var `enum`: Int32 { + get {_storage._enum} + set {_uniqueStorage()._enum = newValue} } var enumReservedRange: Int32 { - get {return _storage._enumReservedRange} + get {_storage._enumReservedRange} set {_uniqueStorage()._enumReservedRange = newValue} } var enumType: Int32 { - get {return _storage._enumType} + get {_storage._enumType} set {_uniqueStorage()._enumType = newValue} } var enumvalue: Int32 { - get {return _storage._enumvalue} + get {_storage._enumvalue} set {_uniqueStorage()._enumvalue = newValue} } - var enumValueDescriptorProto: Int32 { - get {return _storage._enumValueDescriptorProto} - set {_uniqueStorage()._enumValueDescriptorProto = newValue} - } - - var enumValueOptions: Int32 { - get {return _storage._enumValueOptions} - set {_uniqueStorage()._enumValueOptions = newValue} - } - var equatable: Int32 { - get {return _storage._equatable} + get {_storage._equatable} set {_uniqueStorage()._equatable = newValue} } var error: Int32 { - get {return _storage._error} + get {_storage._error} set {_uniqueStorage()._error = newValue} } + var execute: Int32 { + get {_storage._execute} + set {_uniqueStorage()._execute = newValue} + } + var expressibleByArrayLiteral: Int32 { - get {return _storage._expressibleByArrayLiteral} + get {_storage._expressibleByArrayLiteral} set {_uniqueStorage()._expressibleByArrayLiteral = newValue} } var expressibleByDictionaryLiteral: Int32 { - get {return _storage._expressibleByDictionaryLiteral} + get {_storage._expressibleByDictionaryLiteral} set {_uniqueStorage()._expressibleByDictionaryLiteral = newValue} } var ext: Int32 { - get {return _storage._ext} + get {_storage._ext} set {_uniqueStorage()._ext = newValue} } var extDecoder: Int32 { - get {return _storage._extDecoder} + get {_storage._extDecoder} set {_uniqueStorage()._extDecoder = newValue} } var extendedGraphemeClusterLiteral: Int32 { - get {return _storage._extendedGraphemeClusterLiteral} + get {_storage._extendedGraphemeClusterLiteral} set {_uniqueStorage()._extendedGraphemeClusterLiteral = newValue} } var extendedGraphemeClusterLiteralType: Int32 { - get {return _storage._extendedGraphemeClusterLiteralType} + get {_storage._extendedGraphemeClusterLiteralType} set {_uniqueStorage()._extendedGraphemeClusterLiteralType = newValue} } var extendee: Int32 { - get {return _storage._extendee} + get {_storage._extendee} set {_uniqueStorage()._extendee = newValue} } var extensibleMessage: Int32 { - get {return _storage._extensibleMessage} + get {_storage._extensibleMessage} set {_uniqueStorage()._extensibleMessage = newValue} } var `extension`: Int32 { - get {return _storage._extension} + get {_storage._extension} set {_uniqueStorage()._extension = newValue} } var extensionField: Int32 { - get {return _storage._extensionField} + get {_storage._extensionField} set {_uniqueStorage()._extensionField = newValue} } var extensionFieldNumber: Int32 { - get {return _storage._extensionFieldNumber} + get {_storage._extensionFieldNumber} set {_uniqueStorage()._extensionFieldNumber = newValue} } var extensionFieldValueSet: Int32 { - get {return _storage._extensionFieldValueSet} + get {_storage._extensionFieldValueSet} set {_uniqueStorage()._extensionFieldValueSet = newValue} } var extensionMap: Int32 { - get {return _storage._extensionMap} + get {_storage._extensionMap} set {_uniqueStorage()._extensionMap = newValue} } var extensionRange: Int32 { - get {return _storage._extensionRange} + get {_storage._extensionRange} set {_uniqueStorage()._extensionRange = newValue} } - var extensionRangeOptions: Int32 { - get {return _storage._extensionRangeOptions} - set {_uniqueStorage()._extensionRangeOptions = newValue} - } - var extensions: Int32 { - get {return _storage._extensions} + get {_storage._extensions} set {_uniqueStorage()._extensions = newValue} } var extras: Int32 { - get {return _storage._extras} + get {_storage._extras} set {_uniqueStorage()._extras = newValue} } var f: Int32 { - get {return _storage._f} + get {_storage._f} set {_uniqueStorage()._f = newValue} } var `false`: Int32 { - get {return _storage._false} + get {_storage._false} set {_uniqueStorage()._false = newValue} } + var features: Int32 { + get {_storage._features} + set {_uniqueStorage()._features = newValue} + } + + var featureSetEditionDefault: Int32 { + get {_storage._featureSetEditionDefault} + set {_uniqueStorage()._featureSetEditionDefault = newValue} + } + + var featureSupport: Int32 { + get {_storage._featureSupport} + set {_uniqueStorage()._featureSupport = newValue} + } + var field: Int32 { - get {return _storage._field} + get {_storage._field} set {_uniqueStorage()._field = newValue} } var fieldData: Int32 { - get {return _storage._fieldData} + get {_storage._fieldData} set {_uniqueStorage()._fieldData = newValue} } - var fieldDescriptorProto: Int32 { - get {return _storage._fieldDescriptorProto} - set {_uniqueStorage()._fieldDescriptorProto = newValue} - } - - var fieldMask: Int32 { - get {return _storage._fieldMask} - set {_uniqueStorage()._fieldMask = newValue} + var fieldMaskError: Int32 { + get {_storage._fieldMaskError} + set {_uniqueStorage()._fieldMaskError = newValue} } var fieldName: Int32 { - get {return _storage._fieldName} + get {_storage._fieldName} set {_uniqueStorage()._fieldName = newValue} } var fieldNameCount: Int32 { - get {return _storage._fieldNameCount} + get {_storage._fieldNameCount} set {_uniqueStorage()._fieldNameCount = newValue} } var fieldNum: Int32 { - get {return _storage._fieldNum} + get {_storage._fieldNum} set {_uniqueStorage()._fieldNum = newValue} } var fieldNumber: Int32 { - get {return _storage._fieldNumber} + get {_storage._fieldNumber} set {_uniqueStorage()._fieldNumber = newValue} } var fieldNumberForProto: Int32 { - get {return _storage._fieldNumberForProto} + get {_storage._fieldNumberForProto} set {_uniqueStorage()._fieldNumberForProto = newValue} } - var fieldOptions: Int32 { - get {return _storage._fieldOptions} - set {_uniqueStorage()._fieldOptions = newValue} + var fieldPresence: Int32 { + get {_storage._fieldPresence} + set {_uniqueStorage()._fieldPresence = newValue} } var fields: Int32 { - get {return _storage._fields} + get {_storage._fields} set {_uniqueStorage()._fields = newValue} } var fieldSize: Int32 { - get {return _storage._fieldSize} + get {_storage._fieldSize} set {_uniqueStorage()._fieldSize = newValue} } var fieldTag: Int32 { - get {return _storage._fieldTag} + get {_storage._fieldTag} set {_uniqueStorage()._fieldTag = newValue} } var fieldType: Int32 { - get {return _storage._fieldType} + get {_storage._fieldType} set {_uniqueStorage()._fieldType = newValue} } var file: Int32 { - get {return _storage._file} + get {_storage._file} set {_uniqueStorage()._file = newValue} } - var fileDescriptorProto: Int32 { - get {return _storage._fileDescriptorProto} - set {_uniqueStorage()._fileDescriptorProto = newValue} - } - - var fileDescriptorSet: Int32 { - get {return _storage._fileDescriptorSet} - set {_uniqueStorage()._fileDescriptorSet = newValue} - } - var fileName: Int32 { - get {return _storage._fileName} + get {_storage._fileName} set {_uniqueStorage()._fileName = newValue} } - var fileOptions: Int32 { - get {return _storage._fileOptions} - set {_uniqueStorage()._fileOptions = newValue} - } - var filter: Int32 { - get {return _storage._filter} + get {_storage._filter} set {_uniqueStorage()._filter = newValue} } + var final: Int32 { + get {_storage._final} + set {_uniqueStorage()._final = newValue} + } + + var finiteOnly: Int32 { + get {_storage._finiteOnly} + set {_uniqueStorage()._finiteOnly = newValue} + } + var first: Int32 { - get {return _storage._first} + get {_storage._first} set {_uniqueStorage()._first = newValue} } var firstItem: Int32 { - get {return _storage._firstItem} + get {_storage._firstItem} set {_uniqueStorage()._firstItem = newValue} } + var fixedFeatures: Int32 { + get {_storage._fixedFeatures} + set {_uniqueStorage()._fixedFeatures = newValue} + } + var float: Int32 { - get {return _storage._float} + get {_storage._float} set {_uniqueStorage()._float = newValue} } var floatLiteral: Int32 { - get {return _storage._floatLiteral} + get {_storage._floatLiteral} set {_uniqueStorage()._floatLiteral = newValue} } var floatLiteralType: Int32 { - get {return _storage._floatLiteralType} + get {_storage._floatLiteralType} set {_uniqueStorage()._floatLiteralType = newValue} } - var floatValue: Int32 { - get {return _storage._floatValue} - set {_uniqueStorage()._floatValue = newValue} + var `for`: Int32 { + get {_storage._for} + set {_uniqueStorage()._for = newValue} } var forMessageName: Int32 { - get {return _storage._forMessageName} + get {_storage._forMessageName} set {_uniqueStorage()._forMessageName = newValue} } var formUnion: Int32 { - get {return _storage._formUnion} + get {_storage._formUnion} set {_uniqueStorage()._formUnion = newValue} } var forReadingFrom: Int32 { - get {return _storage._forReadingFrom} + get {_storage._forReadingFrom} set {_uniqueStorage()._forReadingFrom = newValue} } var forTypeURL: Int32 { - get {return _storage._forTypeURL} + get {_storage._forTypeURL} set {_uniqueStorage()._forTypeURL = newValue} } var forwardParser: Int32 { - get {return _storage._forwardParser} + get {_storage._forwardParser} set {_uniqueStorage()._forwardParser = newValue} } var forWritingInto: Int32 { - get {return _storage._forWritingInto} + get {_storage._forWritingInto} set {_uniqueStorage()._forWritingInto = newValue} } var from: Int32 { - get {return _storage._from} + get {_storage._from} set {_uniqueStorage()._from = newValue} } var fromAscii2: Int32 { - get {return _storage._fromAscii2} + get {_storage._fromAscii2} set {_uniqueStorage()._fromAscii2 = newValue} } var fromAscii4: Int32 { - get {return _storage._fromAscii4} + get {_storage._fromAscii4} set {_uniqueStorage()._fromAscii4 = newValue} } var fromByteOffset: Int32 { - get {return _storage._fromByteOffset} + get {_storage._fromByteOffset} set {_uniqueStorage()._fromByteOffset = newValue} } var fromHexDigit: Int32 { - get {return _storage._fromHexDigit} + get {_storage._fromHexDigit} set {_uniqueStorage()._fromHexDigit = newValue} } + var fullName: Int32 { + get {_storage._fullName} + set {_uniqueStorage()._fullName = newValue} + } + var `func`: Int32 { - get {return _storage._func} + get {_storage._func} set {_uniqueStorage()._func = newValue} } - var g: Int32 { - get {return _storage._g} - set {_uniqueStorage()._g = newValue} + var function: Int32 { + get {_storage._function} + set {_uniqueStorage()._function = newValue} } - var generatedCodeInfo: Int32 { - get {return _storage._generatedCodeInfo} - set {_uniqueStorage()._generatedCodeInfo = newValue} + var g: Int32 { + get {_storage._g} + set {_uniqueStorage()._g = newValue} } var get: Int32 { - get {return _storage._get} + get {_storage._get} set {_uniqueStorage()._get = newValue} } var getExtensionValue: Int32 { - get {return _storage._getExtensionValue} + get {_storage._getExtensionValue} set {_uniqueStorage()._getExtensionValue = newValue} } - var googleapis: Int32 { - get {return _storage._googleapis} - set {_uniqueStorage()._googleapis = newValue} - } - var googleProtobufAny: Int32 { - get {return _storage._googleProtobufAny} + get {_storage._googleProtobufAny} set {_uniqueStorage()._googleProtobufAny = newValue} } var googleProtobufApi: Int32 { - get {return _storage._googleProtobufApi} + get {_storage._googleProtobufApi} set {_uniqueStorage()._googleProtobufApi = newValue} } var googleProtobufBoolValue: Int32 { - get {return _storage._googleProtobufBoolValue} + get {_storage._googleProtobufBoolValue} set {_uniqueStorage()._googleProtobufBoolValue = newValue} } var googleProtobufBytesValue: Int32 { - get {return _storage._googleProtobufBytesValue} + get {_storage._googleProtobufBytesValue} set {_uniqueStorage()._googleProtobufBytesValue = newValue} } var googleProtobufDescriptorProto: Int32 { - get {return _storage._googleProtobufDescriptorProto} + get {_storage._googleProtobufDescriptorProto} set {_uniqueStorage()._googleProtobufDescriptorProto = newValue} } var googleProtobufDoubleValue: Int32 { - get {return _storage._googleProtobufDoubleValue} + get {_storage._googleProtobufDoubleValue} set {_uniqueStorage()._googleProtobufDoubleValue = newValue} } var googleProtobufDuration: Int32 { - get {return _storage._googleProtobufDuration} + get {_storage._googleProtobufDuration} set {_uniqueStorage()._googleProtobufDuration = newValue} } + var googleProtobufEdition: Int32 { + get {_storage._googleProtobufEdition} + set {_uniqueStorage()._googleProtobufEdition = newValue} + } + var googleProtobufEmpty: Int32 { - get {return _storage._googleProtobufEmpty} + get {_storage._googleProtobufEmpty} set {_uniqueStorage()._googleProtobufEmpty = newValue} } var googleProtobufEnum: Int32 { - get {return _storage._googleProtobufEnum} + get {_storage._googleProtobufEnum} set {_uniqueStorage()._googleProtobufEnum = newValue} } var googleProtobufEnumDescriptorProto: Int32 { - get {return _storage._googleProtobufEnumDescriptorProto} + get {_storage._googleProtobufEnumDescriptorProto} set {_uniqueStorage()._googleProtobufEnumDescriptorProto = newValue} } var googleProtobufEnumOptions: Int32 { - get {return _storage._googleProtobufEnumOptions} + get {_storage._googleProtobufEnumOptions} set {_uniqueStorage()._googleProtobufEnumOptions = newValue} } var googleProtobufEnumValue: Int32 { - get {return _storage._googleProtobufEnumValue} + get {_storage._googleProtobufEnumValue} set {_uniqueStorage()._googleProtobufEnumValue = newValue} } var googleProtobufEnumValueDescriptorProto: Int32 { - get {return _storage._googleProtobufEnumValueDescriptorProto} + get {_storage._googleProtobufEnumValueDescriptorProto} set {_uniqueStorage()._googleProtobufEnumValueDescriptorProto = newValue} } var googleProtobufEnumValueOptions: Int32 { - get {return _storage._googleProtobufEnumValueOptions} + get {_storage._googleProtobufEnumValueOptions} set {_uniqueStorage()._googleProtobufEnumValueOptions = newValue} } var googleProtobufExtensionRangeOptions: Int32 { - get {return _storage._googleProtobufExtensionRangeOptions} + get {_storage._googleProtobufExtensionRangeOptions} set {_uniqueStorage()._googleProtobufExtensionRangeOptions = newValue} } + var googleProtobufFeatureSet: Int32 { + get {_storage._googleProtobufFeatureSet} + set {_uniqueStorage()._googleProtobufFeatureSet = newValue} + } + + var googleProtobufFeatureSetDefaults: Int32 { + get {_storage._googleProtobufFeatureSetDefaults} + set {_uniqueStorage()._googleProtobufFeatureSetDefaults = newValue} + } + var googleProtobufField: Int32 { - get {return _storage._googleProtobufField} + get {_storage._googleProtobufField} set {_uniqueStorage()._googleProtobufField = newValue} } var googleProtobufFieldDescriptorProto: Int32 { - get {return _storage._googleProtobufFieldDescriptorProto} + get {_storage._googleProtobufFieldDescriptorProto} set {_uniqueStorage()._googleProtobufFieldDescriptorProto = newValue} } var googleProtobufFieldMask: Int32 { - get {return _storage._googleProtobufFieldMask} + get {_storage._googleProtobufFieldMask} set {_uniqueStorage()._googleProtobufFieldMask = newValue} } var googleProtobufFieldOptions: Int32 { - get {return _storage._googleProtobufFieldOptions} + get {_storage._googleProtobufFieldOptions} set {_uniqueStorage()._googleProtobufFieldOptions = newValue} } var googleProtobufFileDescriptorProto: Int32 { - get {return _storage._googleProtobufFileDescriptorProto} + get {_storage._googleProtobufFileDescriptorProto} set {_uniqueStorage()._googleProtobufFileDescriptorProto = newValue} } var googleProtobufFileDescriptorSet: Int32 { - get {return _storage._googleProtobufFileDescriptorSet} + get {_storage._googleProtobufFileDescriptorSet} set {_uniqueStorage()._googleProtobufFileDescriptorSet = newValue} } var googleProtobufFileOptions: Int32 { - get {return _storage._googleProtobufFileOptions} + get {_storage._googleProtobufFileOptions} set {_uniqueStorage()._googleProtobufFileOptions = newValue} } var googleProtobufFloatValue: Int32 { - get {return _storage._googleProtobufFloatValue} + get {_storage._googleProtobufFloatValue} set {_uniqueStorage()._googleProtobufFloatValue = newValue} } var googleProtobufGeneratedCodeInfo: Int32 { - get {return _storage._googleProtobufGeneratedCodeInfo} + get {_storage._googleProtobufGeneratedCodeInfo} set {_uniqueStorage()._googleProtobufGeneratedCodeInfo = newValue} } var googleProtobufInt32Value: Int32 { - get {return _storage._googleProtobufInt32Value} + get {_storage._googleProtobufInt32Value} set {_uniqueStorage()._googleProtobufInt32Value = newValue} } var googleProtobufInt64Value: Int32 { - get {return _storage._googleProtobufInt64Value} + get {_storage._googleProtobufInt64Value} set {_uniqueStorage()._googleProtobufInt64Value = newValue} } var googleProtobufListValue: Int32 { - get {return _storage._googleProtobufListValue} + get {_storage._googleProtobufListValue} set {_uniqueStorage()._googleProtobufListValue = newValue} } var googleProtobufMessageOptions: Int32 { - get {return _storage._googleProtobufMessageOptions} + get {_storage._googleProtobufMessageOptions} set {_uniqueStorage()._googleProtobufMessageOptions = newValue} } var googleProtobufMethod: Int32 { - get {return _storage._googleProtobufMethod} + get {_storage._googleProtobufMethod} set {_uniqueStorage()._googleProtobufMethod = newValue} } var googleProtobufMethodDescriptorProto: Int32 { - get {return _storage._googleProtobufMethodDescriptorProto} + get {_storage._googleProtobufMethodDescriptorProto} set {_uniqueStorage()._googleProtobufMethodDescriptorProto = newValue} } var googleProtobufMethodOptions: Int32 { - get {return _storage._googleProtobufMethodOptions} + get {_storage._googleProtobufMethodOptions} set {_uniqueStorage()._googleProtobufMethodOptions = newValue} } var googleProtobufMixin: Int32 { - get {return _storage._googleProtobufMixin} + get {_storage._googleProtobufMixin} set {_uniqueStorage()._googleProtobufMixin = newValue} } var googleProtobufNullValue: Int32 { - get {return _storage._googleProtobufNullValue} + get {_storage._googleProtobufNullValue} set {_uniqueStorage()._googleProtobufNullValue = newValue} } var googleProtobufOneofDescriptorProto: Int32 { - get {return _storage._googleProtobufOneofDescriptorProto} + get {_storage._googleProtobufOneofDescriptorProto} set {_uniqueStorage()._googleProtobufOneofDescriptorProto = newValue} } var googleProtobufOneofOptions: Int32 { - get {return _storage._googleProtobufOneofOptions} + get {_storage._googleProtobufOneofOptions} set {_uniqueStorage()._googleProtobufOneofOptions = newValue} } var googleProtobufOption: Int32 { - get {return _storage._googleProtobufOption} + get {_storage._googleProtobufOption} set {_uniqueStorage()._googleProtobufOption = newValue} } var googleProtobufServiceDescriptorProto: Int32 { - get {return _storage._googleProtobufServiceDescriptorProto} + get {_storage._googleProtobufServiceDescriptorProto} set {_uniqueStorage()._googleProtobufServiceDescriptorProto = newValue} } var googleProtobufServiceOptions: Int32 { - get {return _storage._googleProtobufServiceOptions} + get {_storage._googleProtobufServiceOptions} set {_uniqueStorage()._googleProtobufServiceOptions = newValue} } var googleProtobufSourceCodeInfo: Int32 { - get {return _storage._googleProtobufSourceCodeInfo} + get {_storage._googleProtobufSourceCodeInfo} set {_uniqueStorage()._googleProtobufSourceCodeInfo = newValue} } var googleProtobufSourceContext: Int32 { - get {return _storage._googleProtobufSourceContext} + get {_storage._googleProtobufSourceContext} set {_uniqueStorage()._googleProtobufSourceContext = newValue} } var googleProtobufStringValue: Int32 { - get {return _storage._googleProtobufStringValue} + get {_storage._googleProtobufStringValue} set {_uniqueStorage()._googleProtobufStringValue = newValue} } var googleProtobufStruct: Int32 { - get {return _storage._googleProtobufStruct} + get {_storage._googleProtobufStruct} set {_uniqueStorage()._googleProtobufStruct = newValue} } + var googleProtobufSymbolVisibility: Int32 { + get {_storage._googleProtobufSymbolVisibility} + set {_uniqueStorage()._googleProtobufSymbolVisibility = newValue} + } + var googleProtobufSyntax: Int32 { - get {return _storage._googleProtobufSyntax} + get {_storage._googleProtobufSyntax} set {_uniqueStorage()._googleProtobufSyntax = newValue} } var googleProtobufTimestamp: Int32 { - get {return _storage._googleProtobufTimestamp} + get {_storage._googleProtobufTimestamp} set {_uniqueStorage()._googleProtobufTimestamp = newValue} } var googleProtobufType: Int32 { - get {return _storage._googleProtobufType} + get {_storage._googleProtobufType} set {_uniqueStorage()._googleProtobufType = newValue} } var googleProtobufUint32Value: Int32 { - get {return _storage._googleProtobufUint32Value} + get {_storage._googleProtobufUint32Value} set {_uniqueStorage()._googleProtobufUint32Value = newValue} } var googleProtobufUint64Value: Int32 { - get {return _storage._googleProtobufUint64Value} + get {_storage._googleProtobufUint64Value} set {_uniqueStorage()._googleProtobufUint64Value = newValue} } var googleProtobufUninterpretedOption: Int32 { - get {return _storage._googleProtobufUninterpretedOption} + get {_storage._googleProtobufUninterpretedOption} set {_uniqueStorage()._googleProtobufUninterpretedOption = newValue} } var googleProtobufValue: Int32 { - get {return _storage._googleProtobufValue} + get {_storage._googleProtobufValue} set {_uniqueStorage()._googleProtobufValue = newValue} } var goPackage: Int32 { - get {return _storage._goPackage} + get {_storage._goPackage} set {_uniqueStorage()._goPackage = newValue} } + var gotData: Int32 { + get {_storage._gotData} + set {_uniqueStorage()._gotData = newValue} + } + var group: Int32 { - get {return _storage._group} + get {_storage._group} set {_uniqueStorage()._group = newValue} } var groupFieldNumberStack: Int32 { - get {return _storage._groupFieldNumberStack} + get {_storage._groupFieldNumberStack} set {_uniqueStorage()._groupFieldNumberStack = newValue} } var groupSize: Int32 { - get {return _storage._groupSize} + get {_storage._groupSize} set {_uniqueStorage()._groupSize = newValue} } - var h: Int32 { - get {return _storage._h} - set {_uniqueStorage()._h = newValue} + var `guard`: Int32 { + get {_storage._guard} + set {_uniqueStorage()._guard = newValue} } var hadOneofValue: Int32 { - get {return _storage._hadOneofValue} + get {_storage._hadOneofValue} set {_uniqueStorage()._hadOneofValue = newValue} } var handleConflictingOneOf: Int32 { - get {return _storage._handleConflictingOneOf} + get {_storage._handleConflictingOneOf} set {_uniqueStorage()._handleConflictingOneOf = newValue} } + var handleInstruction: Int32 { + get {_storage._handleInstruction} + set {_uniqueStorage()._handleInstruction = newValue} + } + var hasAggregateValue_p: Int32 { - get {return _storage._hasAggregateValue_p} + get {_storage._hasAggregateValue_p} set {_uniqueStorage()._hasAggregateValue_p = newValue} } var hasAllowAlias_p: Int32 { - get {return _storage._hasAllowAlias_p} + get {_storage._hasAllowAlias_p} set {_uniqueStorage()._hasAllowAlias_p = newValue} } var hasBegin_p: Int32 { - get {return _storage._hasBegin_p} + get {_storage._hasBegin_p} set {_uniqueStorage()._hasBegin_p = newValue} } var hasCcEnableArenas_p: Int32 { - get {return _storage._hasCcEnableArenas_p} + get {_storage._hasCcEnableArenas_p} set {_uniqueStorage()._hasCcEnableArenas_p = newValue} } var hasCcGenericServices_p: Int32 { - get {return _storage._hasCcGenericServices_p} + get {_storage._hasCcGenericServices_p} set {_uniqueStorage()._hasCcGenericServices_p = newValue} } var hasClientStreaming_p: Int32 { - get {return _storage._hasClientStreaming_p} + get {_storage._hasClientStreaming_p} set {_uniqueStorage()._hasClientStreaming_p = newValue} } var hasCsharpNamespace_p: Int32 { - get {return _storage._hasCsharpNamespace_p} + get {_storage._hasCsharpNamespace_p} set {_uniqueStorage()._hasCsharpNamespace_p = newValue} } var hasCtype_p: Int32 { - get {return _storage._hasCtype_p} + get {_storage._hasCtype_p} set {_uniqueStorage()._hasCtype_p = newValue} } + var hasData_p: Int32 { + get {_storage._hasData_p} + set {_uniqueStorage()._hasData_p = newValue} + } + + var hasDebugRedact_p: Int32 { + get {_storage._hasDebugRedact_p} + set {_uniqueStorage()._hasDebugRedact_p = newValue} + } + + var hasDefaultSymbolVisibility_p: Int32 { + get {_storage._hasDefaultSymbolVisibility_p} + set {_uniqueStorage()._hasDefaultSymbolVisibility_p = newValue} + } + var hasDefaultValue_p: Int32 { - get {return _storage._hasDefaultValue_p} + get {_storage._hasDefaultValue_p} set {_uniqueStorage()._hasDefaultValue_p = newValue} } var hasDeprecated_p: Int32 { - get {return _storage._hasDeprecated_p} + get {_storage._hasDeprecated_p} set {_uniqueStorage()._hasDeprecated_p = newValue} } + var hasDeprecatedLegacyJsonFieldConflicts_p: Int32 { + get {_storage._hasDeprecatedLegacyJsonFieldConflicts_p} + set {_uniqueStorage()._hasDeprecatedLegacyJsonFieldConflicts_p = newValue} + } + + var hasDeprecationWarning_p: Int32 { + get {_storage._hasDeprecationWarning_p} + set {_uniqueStorage()._hasDeprecationWarning_p = newValue} + } + var hasDoubleValue_p: Int32 { - get {return _storage._hasDoubleValue_p} + get {_storage._hasDoubleValue_p} set {_uniqueStorage()._hasDoubleValue_p = newValue} } + var hasEdition_p: Int32 { + get {_storage._hasEdition_p} + set {_uniqueStorage()._hasEdition_p = newValue} + } + + var hasEditionDeprecated_p: Int32 { + get {_storage._hasEditionDeprecated_p} + set {_uniqueStorage()._hasEditionDeprecated_p = newValue} + } + + var hasEditionIntroduced_p: Int32 { + get {_storage._hasEditionIntroduced_p} + set {_uniqueStorage()._hasEditionIntroduced_p = newValue} + } + + var hasEditionRemoved_p: Int32 { + get {_storage._hasEditionRemoved_p} + set {_uniqueStorage()._hasEditionRemoved_p = newValue} + } + var hasEnd_p: Int32 { - get {return _storage._hasEnd_p} + get {_storage._hasEnd_p} set {_uniqueStorage()._hasEnd_p = newValue} } + var hasEnforceNamingStyle_p: Int32 { + get {_storage._hasEnforceNamingStyle_p} + set {_uniqueStorage()._hasEnforceNamingStyle_p = newValue} + } + + var hasEnumType_p: Int32 { + get {_storage._hasEnumType_p} + set {_uniqueStorage()._hasEnumType_p = newValue} + } + + var hasExplicitDelta_p: Int32 { + get {_storage._hasExplicitDelta_p} + set {_uniqueStorage()._hasExplicitDelta_p = newValue} + } + var hasExtendee_p: Int32 { - get {return _storage._hasExtendee_p} + get {_storage._hasExtendee_p} set {_uniqueStorage()._hasExtendee_p = newValue} } var hasExtensionValue_p: Int32 { - get {return _storage._hasExtensionValue_p} + get {_storage._hasExtensionValue_p} set {_uniqueStorage()._hasExtensionValue_p = newValue} } + var hasFeatures_p: Int32 { + get {_storage._hasFeatures_p} + set {_uniqueStorage()._hasFeatures_p = newValue} + } + + var hasFeatureSupport_p: Int32 { + get {_storage._hasFeatureSupport_p} + set {_uniqueStorage()._hasFeatureSupport_p = newValue} + } + + var hasFieldPresence_p: Int32 { + get {_storage._hasFieldPresence_p} + set {_uniqueStorage()._hasFieldPresence_p = newValue} + } + + var hasFixedFeatures_p: Int32 { + get {_storage._hasFixedFeatures_p} + set {_uniqueStorage()._hasFixedFeatures_p = newValue} + } + + var hasFullName_p: Int32 { + get {_storage._hasFullName_p} + set {_uniqueStorage()._hasFullName_p = newValue} + } + var hasGoPackage_p: Int32 { - get {return _storage._hasGoPackage_p} + get {_storage._hasGoPackage_p} set {_uniqueStorage()._hasGoPackage_p = newValue} } var hash: Int32 { - get {return _storage._hash} + get {_storage._hash} set {_uniqueStorage()._hash = newValue} } var hashable: Int32 { - get {return _storage._hashable} + get {_storage._hashable} set {_uniqueStorage()._hashable = newValue} } var hasher: Int32 { - get {return _storage._hasher} + get {_storage._hasher} set {_uniqueStorage()._hasher = newValue} } - var hashValue_p: Int32 { - get {return _storage._hashValue_p} - set {_uniqueStorage()._hashValue_p = newValue} - } - var hashVisitor: Int32 { - get {return _storage._hashVisitor} + get {_storage._hashVisitor} set {_uniqueStorage()._hashVisitor = newValue} } var hasIdempotencyLevel_p: Int32 { - get {return _storage._hasIdempotencyLevel_p} + get {_storage._hasIdempotencyLevel_p} set {_uniqueStorage()._hasIdempotencyLevel_p = newValue} } var hasIdentifierValue_p: Int32 { - get {return _storage._hasIdentifierValue_p} + get {_storage._hasIdentifierValue_p} set {_uniqueStorage()._hasIdentifierValue_p = newValue} } var hasInputType_p: Int32 { - get {return _storage._hasInputType_p} + get {_storage._hasInputType_p} set {_uniqueStorage()._hasInputType_p = newValue} } var hasIsExtension_p: Int32 { - get {return _storage._hasIsExtension_p} + get {_storage._hasIsExtension_p} set {_uniqueStorage()._hasIsExtension_p = newValue} } var hasJavaGenerateEqualsAndHash_p: Int32 { - get {return _storage._hasJavaGenerateEqualsAndHash_p} + get {_storage._hasJavaGenerateEqualsAndHash_p} set {_uniqueStorage()._hasJavaGenerateEqualsAndHash_p = newValue} } var hasJavaGenericServices_p: Int32 { - get {return _storage._hasJavaGenericServices_p} + get {_storage._hasJavaGenericServices_p} set {_uniqueStorage()._hasJavaGenericServices_p = newValue} } var hasJavaMultipleFiles_p: Int32 { - get {return _storage._hasJavaMultipleFiles_p} + get {_storage._hasJavaMultipleFiles_p} set {_uniqueStorage()._hasJavaMultipleFiles_p = newValue} } var hasJavaOuterClassname_p: Int32 { - get {return _storage._hasJavaOuterClassname_p} + get {_storage._hasJavaOuterClassname_p} set {_uniqueStorage()._hasJavaOuterClassname_p = newValue} } var hasJavaPackage_p: Int32 { - get {return _storage._hasJavaPackage_p} + get {_storage._hasJavaPackage_p} set {_uniqueStorage()._hasJavaPackage_p = newValue} } var hasJavaStringCheckUtf8_p: Int32 { - get {return _storage._hasJavaStringCheckUtf8_p} + get {_storage._hasJavaStringCheckUtf8_p} set {_uniqueStorage()._hasJavaStringCheckUtf8_p = newValue} } + var hasJsonFormat_p: Int32 { + get {_storage._hasJsonFormat_p} + set {_uniqueStorage()._hasJsonFormat_p = newValue} + } + var hasJsonName_p: Int32 { - get {return _storage._hasJsonName_p} + get {_storage._hasJsonName_p} set {_uniqueStorage()._hasJsonName_p = newValue} } var hasJstype_p: Int32 { - get {return _storage._hasJstype_p} + get {_storage._hasJstype_p} set {_uniqueStorage()._hasJstype_p = newValue} } var hasLabel_p: Int32 { - get {return _storage._hasLabel_p} + get {_storage._hasLabel_p} set {_uniqueStorage()._hasLabel_p = newValue} } var hasLazy_p: Int32 { - get {return _storage._hasLazy_p} + get {_storage._hasLazy_p} set {_uniqueStorage()._hasLazy_p = newValue} } var hasLeadingComments_p: Int32 { - get {return _storage._hasLeadingComments_p} + get {_storage._hasLeadingComments_p} set {_uniqueStorage()._hasLeadingComments_p = newValue} } var hasMapEntry_p: Int32 { - get {return _storage._hasMapEntry_p} + get {_storage._hasMapEntry_p} set {_uniqueStorage()._hasMapEntry_p = newValue} } + var hasMaximumEdition_p: Int32 { + get {_storage._hasMaximumEdition_p} + set {_uniqueStorage()._hasMaximumEdition_p = newValue} + } + + var hasMessageEncoding_p: Int32 { + get {_storage._hasMessageEncoding_p} + set {_uniqueStorage()._hasMessageEncoding_p = newValue} + } + var hasMessageSetWireFormat_p: Int32 { - get {return _storage._hasMessageSetWireFormat_p} + get {_storage._hasMessageSetWireFormat_p} set {_uniqueStorage()._hasMessageSetWireFormat_p = newValue} } + var hasMinimumEdition_p: Int32 { + get {_storage._hasMinimumEdition_p} + set {_uniqueStorage()._hasMinimumEdition_p = newValue} + } + var hasName_p: Int32 { - get {return _storage._hasName_p} + get {_storage._hasName_p} set {_uniqueStorage()._hasName_p = newValue} } var hasNamePart_p: Int32 { - get {return _storage._hasNamePart_p} + get {_storage._hasNamePart_p} set {_uniqueStorage()._hasNamePart_p = newValue} } var hasNegativeIntValue_p: Int32 { - get {return _storage._hasNegativeIntValue_p} + get {_storage._hasNegativeIntValue_p} set {_uniqueStorage()._hasNegativeIntValue_p = newValue} } var hasNoStandardDescriptorAccessor_p: Int32 { - get {return _storage._hasNoStandardDescriptorAccessor_p} + get {_storage._hasNoStandardDescriptorAccessor_p} set {_uniqueStorage()._hasNoStandardDescriptorAccessor_p = newValue} } var hasNumber_p: Int32 { - get {return _storage._hasNumber_p} + get {_storage._hasNumber_p} set {_uniqueStorage()._hasNumber_p = newValue} } var hasObjcClassPrefix_p: Int32 { - get {return _storage._hasObjcClassPrefix_p} + get {_storage._hasObjcClassPrefix_p} set {_uniqueStorage()._hasObjcClassPrefix_p = newValue} } var hasOneofIndex_p: Int32 { - get {return _storage._hasOneofIndex_p} + get {_storage._hasOneofIndex_p} set {_uniqueStorage()._hasOneofIndex_p = newValue} } var hasOptimizeFor_p: Int32 { - get {return _storage._hasOptimizeFor_p} + get {_storage._hasOptimizeFor_p} set {_uniqueStorage()._hasOptimizeFor_p = newValue} } var hasOptions_p: Int32 { - get {return _storage._hasOptions_p} + get {_storage._hasOptions_p} set {_uniqueStorage()._hasOptions_p = newValue} } var hasOutputType_p: Int32 { - get {return _storage._hasOutputType_p} + get {_storage._hasOutputType_p} set {_uniqueStorage()._hasOutputType_p = newValue} } + var hasOverridableFeatures_p: Int32 { + get {_storage._hasOverridableFeatures_p} + set {_uniqueStorage()._hasOverridableFeatures_p = newValue} + } + var hasPackage_p: Int32 { - get {return _storage._hasPackage_p} + get {_storage._hasPackage_p} set {_uniqueStorage()._hasPackage_p = newValue} } var hasPacked_p: Int32 { - get {return _storage._hasPacked_p} + get {_storage._hasPacked_p} set {_uniqueStorage()._hasPacked_p = newValue} } var hasPhpClassPrefix_p: Int32 { - get {return _storage._hasPhpClassPrefix_p} + get {_storage._hasPhpClassPrefix_p} set {_uniqueStorage()._hasPhpClassPrefix_p = newValue} } - var hasPhpGenericServices_p: Int32 { - get {return _storage._hasPhpGenericServices_p} - set {_uniqueStorage()._hasPhpGenericServices_p = newValue} - } - var hasPhpMetadataNamespace_p: Int32 { - get {return _storage._hasPhpMetadataNamespace_p} + get {_storage._hasPhpMetadataNamespace_p} set {_uniqueStorage()._hasPhpMetadataNamespace_p = newValue} } var hasPhpNamespace_p: Int32 { - get {return _storage._hasPhpNamespace_p} + get {_storage._hasPhpNamespace_p} set {_uniqueStorage()._hasPhpNamespace_p = newValue} } var hasPositiveIntValue_p: Int32 { - get {return _storage._hasPositiveIntValue_p} + get {_storage._hasPositiveIntValue_p} set {_uniqueStorage()._hasPositiveIntValue_p = newValue} } var hasProto3Optional_p: Int32 { - get {return _storage._hasProto3Optional_p} + get {_storage._hasProto3Optional_p} set {_uniqueStorage()._hasProto3Optional_p = newValue} } var hasPyGenericServices_p: Int32 { - get {return _storage._hasPyGenericServices_p} + get {_storage._hasPyGenericServices_p} set {_uniqueStorage()._hasPyGenericServices_p = newValue} } + var hasRemovalError_p: Int32 { + get {_storage._hasRemovalError_p} + set {_uniqueStorage()._hasRemovalError_p = newValue} + } + + var hasRepeated_p: Int32 { + get {_storage._hasRepeated_p} + set {_uniqueStorage()._hasRepeated_p = newValue} + } + + var hasRepeatedFieldEncoding_p: Int32 { + get {_storage._hasRepeatedFieldEncoding_p} + set {_uniqueStorage()._hasRepeatedFieldEncoding_p = newValue} + } + + var hasReserved_p: Int32 { + get {_storage._hasReserved_p} + set {_uniqueStorage()._hasReserved_p = newValue} + } + + var hasRetention_p: Int32 { + get {_storage._hasRetention_p} + set {_uniqueStorage()._hasRetention_p = newValue} + } + var hasRubyPackage_p: Int32 { - get {return _storage._hasRubyPackage_p} + get {_storage._hasRubyPackage_p} set {_uniqueStorage()._hasRubyPackage_p = newValue} } + var hasSemantic_p: Int32 { + get {_storage._hasSemantic_p} + set {_uniqueStorage()._hasSemantic_p = newValue} + } + var hasServerStreaming_p: Int32 { - get {return _storage._hasServerStreaming_p} + get {_storage._hasServerStreaming_p} set {_uniqueStorage()._hasServerStreaming_p = newValue} } var hasSourceCodeInfo_p: Int32 { - get {return _storage._hasSourceCodeInfo_p} + get {_storage._hasSourceCodeInfo_p} set {_uniqueStorage()._hasSourceCodeInfo_p = newValue} } var hasSourceContext_p: Int32 { - get {return _storage._hasSourceContext_p} + get {_storage._hasSourceContext_p} set {_uniqueStorage()._hasSourceContext_p = newValue} } var hasSourceFile_p: Int32 { - get {return _storage._hasSourceFile_p} + get {_storage._hasSourceFile_p} set {_uniqueStorage()._hasSourceFile_p = newValue} } var hasStart_p: Int32 { - get {return _storage._hasStart_p} + get {_storage._hasStart_p} set {_uniqueStorage()._hasStart_p = newValue} } var hasStringValue_p: Int32 { - get {return _storage._hasStringValue_p} + get {_storage._hasStringValue_p} set {_uniqueStorage()._hasStringValue_p = newValue} } var hasSwiftPrefix_p: Int32 { - get {return _storage._hasSwiftPrefix_p} + get {_storage._hasSwiftPrefix_p} set {_uniqueStorage()._hasSwiftPrefix_p = newValue} } var hasSyntax_p: Int32 { - get {return _storage._hasSyntax_p} + get {_storage._hasSyntax_p} set {_uniqueStorage()._hasSyntax_p = newValue} } var hasTrailingComments_p: Int32 { - get {return _storage._hasTrailingComments_p} + get {_storage._hasTrailingComments_p} set {_uniqueStorage()._hasTrailingComments_p = newValue} } var hasType_p: Int32 { - get {return _storage._hasType_p} + get {_storage._hasType_p} set {_uniqueStorage()._hasType_p = newValue} } var hasTypeName_p: Int32 { - get {return _storage._hasTypeName_p} + get {_storage._hasTypeName_p} set {_uniqueStorage()._hasTypeName_p = newValue} } + var hasUnverifiedLazy_p: Int32 { + get {_storage._hasUnverifiedLazy_p} + set {_uniqueStorage()._hasUnverifiedLazy_p = newValue} + } + + var hasUtf8Validation_p: Int32 { + get {_storage._hasUtf8Validation_p} + set {_uniqueStorage()._hasUtf8Validation_p = newValue} + } + var hasValue_p: Int32 { - get {return _storage._hasValue_p} + get {_storage._hasValue_p} set {_uniqueStorage()._hasValue_p = newValue} } + var hasVerification_p: Int32 { + get {_storage._hasVerification_p} + set {_uniqueStorage()._hasVerification_p = newValue} + } + + var hasVisibility_p: Int32 { + get {_storage._hasVisibility_p} + set {_uniqueStorage()._hasVisibility_p = newValue} + } + var hasWeak_p: Int32 { - get {return _storage._hasWeak_p} + get {_storage._hasWeak_p} set {_uniqueStorage()._hasWeak_p = newValue} } var hour: Int32 { - get {return _storage._hour} + get {_storage._hour} set {_uniqueStorage()._hour = newValue} } var i: Int32 { - get {return _storage._i} + get {_storage._i} set {_uniqueStorage()._i = newValue} } var idempotencyLevel: Int32 { - get {return _storage._idempotencyLevel} + get {_storage._idempotencyLevel} set {_uniqueStorage()._idempotencyLevel = newValue} } var identifierValue: Int32 { - get {return _storage._identifierValue} + get {_storage._identifierValue} set {_uniqueStorage()._identifierValue = newValue} } var `if`: Int32 { - get {return _storage._if} + get {_storage._if} set {_uniqueStorage()._if = newValue} } + var ignoreUnknownExtensionFields: Int32 { + get {_storage._ignoreUnknownExtensionFields} + set {_uniqueStorage()._ignoreUnknownExtensionFields = newValue} + } + var ignoreUnknownFields: Int32 { - get {return _storage._ignoreUnknownFields} + get {_storage._ignoreUnknownFields} set {_uniqueStorage()._ignoreUnknownFields = newValue} } var index: Int32 { - get {return _storage._index} + get {_storage._index} set {_uniqueStorage()._index = newValue} } var init_p: Int32 { - get {return _storage._init_p} + get {_storage._init_p} set {_uniqueStorage()._init_p = newValue} } var `inout`: Int32 { - get {return _storage._inout} + get {_storage._inout} set {_uniqueStorage()._inout = newValue} } var inputType: Int32 { - get {return _storage._inputType} + get {_storage._inputType} set {_uniqueStorage()._inputType = newValue} } var insert: Int32 { - get {return _storage._insert} + get {_storage._insert} set {_uniqueStorage()._insert = newValue} } + var instruction: Int32 { + get {_storage._instruction} + set {_uniqueStorage()._instruction = newValue} + } + var int: Int32 { - get {return _storage._int} + get {_storage._int} set {_uniqueStorage()._int = newValue} } var int32: Int32 { - get {return _storage._int32} + get {_storage._int32} set {_uniqueStorage()._int32 = newValue} } - var int32Value: Int32 { - get {return _storage._int32Value} - set {_uniqueStorage()._int32Value = newValue} - } - var int64: Int32 { - get {return _storage._int64} + get {_storage._int64} set {_uniqueStorage()._int64 = newValue} } - var int64Value: Int32 { - get {return _storage._int64Value} - set {_uniqueStorage()._int64Value = newValue} - } - var int8: Int32 { - get {return _storage._int8} + get {_storage._int8} set {_uniqueStorage()._int8 = newValue} } var integerLiteral: Int32 { - get {return _storage._integerLiteral} + get {_storage._integerLiteral} set {_uniqueStorage()._integerLiteral = newValue} } var integerLiteralType: Int32 { - get {return _storage._integerLiteralType} + get {_storage._integerLiteralType} set {_uniqueStorage()._integerLiteralType = newValue} } var intern: Int32 { - get {return _storage._intern} + get {_storage._intern} set {_uniqueStorage()._intern = newValue} } var `internal`: Int32 { - get {return _storage._internal} + get {_storage._internal} set {_uniqueStorage()._internal = newValue} } var internalState: Int32 { - get {return _storage._internalState} + get {_storage._internalState} set {_uniqueStorage()._internalState = newValue} } + var intersect: Int32 { + get {_storage._intersect} + set {_uniqueStorage()._intersect = newValue} + } + var into: Int32 { - get {return _storage._into} + get {_storage._into} set {_uniqueStorage()._into = newValue} } var ints: Int32 { - get {return _storage._ints} + get {_storage._ints} set {_uniqueStorage()._ints = newValue} } + var invalidAnyTypeURL: Int32 { + get {_storage._invalidAnyTypeURL} + set {_uniqueStorage()._invalidAnyTypeURL = newValue} + } + var isA: Int32 { - get {return _storage._isA} + get {_storage._isA} set {_uniqueStorage()._isA = newValue} } var isEqual: Int32 { - get {return _storage._isEqual} + get {_storage._isEqual} set {_uniqueStorage()._isEqual = newValue} } var isEqualTo: Int32 { - get {return _storage._isEqualTo} + get {_storage._isEqualTo} set {_uniqueStorage()._isEqualTo = newValue} } var isExtension: Int32 { - get {return _storage._isExtension} + get {_storage._isExtension} set {_uniqueStorage()._isExtension = newValue} } var isInitialized_p: Int32 { - get {return _storage._isInitialized_p} + get {_storage._isInitialized_p} set {_uniqueStorage()._isInitialized_p = newValue} } + var isNegative: Int32 { + get {_storage._isNegative} + set {_uniqueStorage()._isNegative = newValue} + } + + var isPathValid: Int32 { + get {_storage._isPathValid} + set {_uniqueStorage()._isPathValid = newValue} + } + + var isReserved: Int32 { + get {_storage._isReserved} + set {_uniqueStorage()._isReserved = newValue} + } + + var isValid: Int32 { + get {_storage._isValid} + set {_uniqueStorage()._isValid = newValue} + } + var itemTagsEncodedSize: Int32 { - get {return _storage._itemTagsEncodedSize} + get {_storage._itemTagsEncodedSize} set {_uniqueStorage()._itemTagsEncodedSize = newValue} } var iterator: Int32 { - get {return _storage._iterator} + get {_storage._iterator} set {_uniqueStorage()._iterator = newValue} } - var i2166136261: Int32 { - get {return _storage._i2166136261} - set {_uniqueStorage()._i2166136261 = newValue} - } - var javaGenerateEqualsAndHash: Int32 { - get {return _storage._javaGenerateEqualsAndHash} + get {_storage._javaGenerateEqualsAndHash} set {_uniqueStorage()._javaGenerateEqualsAndHash = newValue} } var javaGenericServices: Int32 { - get {return _storage._javaGenericServices} + get {_storage._javaGenericServices} set {_uniqueStorage()._javaGenericServices = newValue} } var javaMultipleFiles: Int32 { - get {return _storage._javaMultipleFiles} + get {_storage._javaMultipleFiles} set {_uniqueStorage()._javaMultipleFiles = newValue} } var javaOuterClassname: Int32 { - get {return _storage._javaOuterClassname} + get {_storage._javaOuterClassname} set {_uniqueStorage()._javaOuterClassname = newValue} } var javaPackage: Int32 { - get {return _storage._javaPackage} + get {_storage._javaPackage} set {_uniqueStorage()._javaPackage = newValue} } var javaStringCheckUtf8: Int32 { - get {return _storage._javaStringCheckUtf8} + get {_storage._javaStringCheckUtf8} set {_uniqueStorage()._javaStringCheckUtf8 = newValue} } var jsondecoder: Int32 { - get {return _storage._jsondecoder} + get {_storage._jsondecoder} set {_uniqueStorage()._jsondecoder = newValue} } + var jsondecoding: Int32 { + get {_storage._jsondecoding} + set {_uniqueStorage()._jsondecoding = newValue} + } + var jsondecodingError: Int32 { - get {return _storage._jsondecodingError} + get {_storage._jsondecodingError} set {_uniqueStorage()._jsondecodingError = newValue} } var jsondecodingOptions: Int32 { - get {return _storage._jsondecodingOptions} + get {_storage._jsondecodingOptions} set {_uniqueStorage()._jsondecodingOptions = newValue} } var jsonEncoder: Int32 { - get {return _storage._jsonEncoder} + get {_storage._jsonEncoder} set {_uniqueStorage()._jsonEncoder = newValue} } + var jsonencoding: Int32 { + get {_storage._jsonencoding} + set {_uniqueStorage()._jsonencoding = newValue} + } + var jsonencodingError: Int32 { - get {return _storage._jsonencodingError} + get {_storage._jsonencodingError} set {_uniqueStorage()._jsonencodingError = newValue} } var jsonencodingOptions: Int32 { - get {return _storage._jsonencodingOptions} + get {_storage._jsonencodingOptions} set {_uniqueStorage()._jsonencodingOptions = newValue} } var jsonencodingVisitor: Int32 { - get {return _storage._jsonencodingVisitor} + get {_storage._jsonencodingVisitor} set {_uniqueStorage()._jsonencodingVisitor = newValue} } + var jsonFormat: Int32 { + get {_storage._jsonFormat} + set {_uniqueStorage()._jsonFormat = newValue} + } + var jsonmapEncodingVisitor: Int32 { - get {return _storage._jsonmapEncodingVisitor} + get {_storage._jsonmapEncodingVisitor} set {_uniqueStorage()._jsonmapEncodingVisitor = newValue} } var jsonName: Int32 { - get {return _storage._jsonName} + get {_storage._jsonName} set {_uniqueStorage()._jsonName = newValue} } var jsonPath: Int32 { - get {return _storage._jsonPath} + get {_storage._jsonPath} set {_uniqueStorage()._jsonPath = newValue} } var jsonPaths: Int32 { - get {return _storage._jsonPaths} + get {_storage._jsonPaths} set {_uniqueStorage()._jsonPaths = newValue} } var jsonscanner: Int32 { - get {return _storage._jsonscanner} + get {_storage._jsonscanner} set {_uniqueStorage()._jsonscanner = newValue} } var jsonString: Int32 { - get {return _storage._jsonString} + get {_storage._jsonString} set {_uniqueStorage()._jsonString = newValue} } var jsonText: Int32 { - get {return _storage._jsonText} + get {_storage._jsonText} set {_uniqueStorage()._jsonText = newValue} } + var jsonUtf8Bytes: Int32 { + get {_storage._jsonUtf8Bytes} + set {_uniqueStorage()._jsonUtf8Bytes = newValue} + } + var jsonUtf8Data: Int32 { - get {return _storage._jsonUtf8Data} + get {_storage._jsonUtf8Data} set {_uniqueStorage()._jsonUtf8Data = newValue} } var jstype: Int32 { - get {return _storage._jstype} + get {_storage._jstype} set {_uniqueStorage()._jstype = newValue} } var k: Int32 { - get {return _storage._k} + get {_storage._k} set {_uniqueStorage()._k = newValue} } + var kChunkSize: Int32 { + get {_storage._kChunkSize} + set {_uniqueStorage()._kChunkSize = newValue} + } + var key: Int32 { - get {return _storage._key} + get {_storage._key} set {_uniqueStorage()._key = newValue} } var keyField: Int32 { - get {return _storage._keyField} + get {_storage._keyField} set {_uniqueStorage()._keyField = newValue} } + var keyFieldOpt: Int32 { + get {_storage._keyFieldOpt} + set {_uniqueStorage()._keyFieldOpt = newValue} + } + var keyType: Int32 { - get {return _storage._keyType} + get {_storage._keyType} set {_uniqueStorage()._keyType = newValue} } var kind: Int32 { - get {return _storage._kind} + get {_storage._kind} set {_uniqueStorage()._kind = newValue} } var l: Int32 { - get {return _storage._l} + get {_storage._l} set {_uniqueStorage()._l = newValue} } var label: Int32 { - get {return _storage._label} + get {_storage._label} set {_uniqueStorage()._label = newValue} } var lazy: Int32 { - get {return _storage._lazy} + get {_storage._lazy} set {_uniqueStorage()._lazy = newValue} } var leadingComments: Int32 { - get {return _storage._leadingComments} + get {_storage._leadingComments} set {_uniqueStorage()._leadingComments = newValue} } var leadingDetachedComments: Int32 { - get {return _storage._leadingDetachedComments} + get {_storage._leadingDetachedComments} set {_uniqueStorage()._leadingDetachedComments = newValue} } var length: Int32 { - get {return _storage._length} + get {_storage._length} set {_uniqueStorage()._length = newValue} } var lessThan: Int32 { - get {return _storage._lessThan} + get {_storage._lessThan} set {_uniqueStorage()._lessThan = newValue} } var `let`: Int32 { - get {return _storage._let} + get {_storage._let} set {_uniqueStorage()._let = newValue} } var lhs: Int32 { - get {return _storage._lhs} + get {_storage._lhs} set {_uniqueStorage()._lhs = newValue} } + var line: Int32 { + get {_storage._line} + set {_uniqueStorage()._line = newValue} + } + var list: Int32 { - get {return _storage._list} + get {_storage._list} set {_uniqueStorage()._list = newValue} } var listOfMessages: Int32 { - get {return _storage._listOfMessages} + get {_storage._listOfMessages} set {_uniqueStorage()._listOfMessages = newValue} } var listValue: Int32 { - get {return _storage._listValue} + get {_storage._listValue} set {_uniqueStorage()._listValue = newValue} } var littleEndian: Int32 { - get {return _storage._littleEndian} + get {_storage._littleEndian} set {_uniqueStorage()._littleEndian = newValue} } - var littleEndianBytes: Int32 { - get {return _storage._littleEndianBytes} - set {_uniqueStorage()._littleEndianBytes = newValue} - } - var load: Int32 { - get {return _storage._load} + get {_storage._load} set {_uniqueStorage()._load = newValue} } var localHasher: Int32 { - get {return _storage._localHasher} + get {_storage._localHasher} set {_uniqueStorage()._localHasher = newValue} } var location: Int32 { - get {return _storage._location} + get {_storage._location} set {_uniqueStorage()._location = newValue} } var m: Int32 { - get {return _storage._m} + get {_storage._m} set {_uniqueStorage()._m = newValue} } var major: Int32 { - get {return _storage._major} + get {_storage._major} set {_uniqueStorage()._major = newValue} } + var makeAsyncIterator: Int32 { + get {_storage._makeAsyncIterator} + set {_uniqueStorage()._makeAsyncIterator = newValue} + } + var makeIterator: Int32 { - get {return _storage._makeIterator} + get {_storage._makeIterator} set {_uniqueStorage()._makeIterator = newValue} } - var mapEntry: Int32 { - get {return _storage._mapEntry} - set {_uniqueStorage()._mapEntry = newValue} + var malformedLength: Int32 { + get {_storage._malformedLength} + set {_uniqueStorage()._malformedLength = newValue} } - var mapHash: Int32 { - get {return _storage._mapHash} - set {_uniqueStorage()._mapHash = newValue} + var mapEntry: Int32 { + get {_storage._mapEntry} + set {_uniqueStorage()._mapEntry = newValue} } var mapKeyType: Int32 { - get {return _storage._mapKeyType} + get {_storage._mapKeyType} set {_uniqueStorage()._mapKeyType = newValue} } - var mapNameResolver: Int32 { - get {return _storage._mapNameResolver} - set {_uniqueStorage()._mapNameResolver = newValue} - } - var mapToMessages: Int32 { - get {return _storage._mapToMessages} + get {_storage._mapToMessages} set {_uniqueStorage()._mapToMessages = newValue} } var mapValueType: Int32 { - get {return _storage._mapValueType} + get {_storage._mapValueType} set {_uniqueStorage()._mapValueType = newValue} } var mapVisitor: Int32 { - get {return _storage._mapVisitor} + get {_storage._mapVisitor} set {_uniqueStorage()._mapVisitor = newValue} } + var mask: Int32 { + get {_storage._mask} + set {_uniqueStorage()._mask = newValue} + } + + var maximumEdition: Int32 { + get {_storage._maximumEdition} + set {_uniqueStorage()._maximumEdition = newValue} + } + var mdayStart: Int32 { - get {return _storage._mdayStart} + get {_storage._mdayStart} set {_uniqueStorage()._mdayStart = newValue} } var merge: Int32 { - get {return _storage._merge} + get {_storage._merge} set {_uniqueStorage()._merge = newValue} } + var mergeOptions: Int32 { + get {_storage._mergeOptions} + set {_uniqueStorage()._mergeOptions = newValue} + } + var message: Int32 { - get {return _storage._message} + get {_storage._message} set {_uniqueStorage()._message = newValue} } var messageDepthLimit: Int32 { - get {return _storage._messageDepthLimit} + get {_storage._messageDepthLimit} set {_uniqueStorage()._messageDepthLimit = newValue} } + var messageEncoding: Int32 { + get {_storage._messageEncoding} + set {_uniqueStorage()._messageEncoding = newValue} + } + var messageExtension: Int32 { - get {return _storage._messageExtension} + get {_storage._messageExtension} set {_uniqueStorage()._messageExtension = newValue} } var messageImplementationBase: Int32 { - get {return _storage._messageImplementationBase} + get {_storage._messageImplementationBase} set {_uniqueStorage()._messageImplementationBase = newValue} } - var messageOptions: Int32 { - get {return _storage._messageOptions} - set {_uniqueStorage()._messageOptions = newValue} - } - var messageSet: Int32 { - get {return _storage._messageSet} + get {_storage._messageSet} set {_uniqueStorage()._messageSet = newValue} } var messageSetWireFormat: Int32 { - get {return _storage._messageSetWireFormat} + get {_storage._messageSetWireFormat} set {_uniqueStorage()._messageSetWireFormat = newValue} } + var messageSize: Int32 { + get {_storage._messageSize} + set {_uniqueStorage()._messageSize = newValue} + } + var messageType: Int32 { - get {return _storage._messageType} + get {_storage._messageType} set {_uniqueStorage()._messageType = newValue} } var method: Int32 { - get {return _storage._method} + get {_storage._method} set {_uniqueStorage()._method = newValue} } - var methodDescriptorProto: Int32 { - get {return _storage._methodDescriptorProto} - set {_uniqueStorage()._methodDescriptorProto = newValue} + var methods: Int32 { + get {_storage._methods} + set {_uniqueStorage()._methods = newValue} } - var methodOptions: Int32 { - get {return _storage._methodOptions} - set {_uniqueStorage()._methodOptions = newValue} + var min: Int32 { + get {_storage._min} + set {_uniqueStorage()._min = newValue} } - var methods: Int32 { - get {return _storage._methods} - set {_uniqueStorage()._methods = newValue} + var minimumEdition: Int32 { + get {_storage._minimumEdition} + set {_uniqueStorage()._minimumEdition = newValue} } var minor: Int32 { - get {return _storage._minor} + get {_storage._minor} set {_uniqueStorage()._minor = newValue} } - var mixin: Int32 { - get {return _storage._mixin} - set {_uniqueStorage()._mixin = newValue} - } - var mixins: Int32 { - get {return _storage._mixins} + get {_storage._mixins} set {_uniqueStorage()._mixins = newValue} } - var modifier: Int32 { - get {return _storage._modifier} - set {_uniqueStorage()._modifier = newValue} - } - var modify: Int32 { - get {return _storage._modify} + get {_storage._modify} set {_uniqueStorage()._modify = newValue} } var month: Int32 { - get {return _storage._month} + get {_storage._month} set {_uniqueStorage()._month = newValue} } var msgExtension: Int32 { - get {return _storage._msgExtension} + get {_storage._msgExtension} set {_uniqueStorage()._msgExtension = newValue} } var mutating: Int32 { - get {return _storage._mutating} + get {_storage._mutating} set {_uniqueStorage()._mutating = newValue} } var n: Int32 { - get {return _storage._n} + get {_storage._n} set {_uniqueStorage()._n = newValue} } var name: Int32 { - get {return _storage._name} + get {_storage._name} set {_uniqueStorage()._name = newValue} } var nameDescription: Int32 { - get {return _storage._nameDescription} + get {_storage._nameDescription} set {_uniqueStorage()._nameDescription = newValue} } var nameMap: Int32 { - get {return _storage._nameMap} + get {_storage._nameMap} set {_uniqueStorage()._nameMap = newValue} } var namePart: Int32 { - get {return _storage._namePart} + get {_storage._namePart} set {_uniqueStorage()._namePart = newValue} } - var nameResolver: Int32 { - get {return _storage._nameResolver} - set {_uniqueStorage()._nameResolver = newValue} - } - var names: Int32 { - get {return _storage._names} + get {_storage._names} set {_uniqueStorage()._names = newValue} } var nanos: Int32 { - get {return _storage._nanos} + get {_storage._nanos} set {_uniqueStorage()._nanos = newValue} } - var nativeBytes: Int32 { - get {return _storage._nativeBytes} - set {_uniqueStorage()._nativeBytes = newValue} - } - - var nativeEndianBytes: Int32 { - get {return _storage._nativeEndianBytes} - set {_uniqueStorage()._nativeEndianBytes = newValue} - } - var negativeIntValue: Int32 { - get {return _storage._negativeIntValue} + get {_storage._negativeIntValue} set {_uniqueStorage()._negativeIntValue = newValue} } var nestedType: Int32 { - get {return _storage._nestedType} + get {_storage._nestedType} set {_uniqueStorage()._nestedType = newValue} } + var newExtensible: Int32 { + get {_storage._newExtensible} + set {_uniqueStorage()._newExtensible = newValue} + } + var newL: Int32 { - get {return _storage._newL} + get {_storage._newL} set {_uniqueStorage()._newL = newValue} } var newList: Int32 { - get {return _storage._newList} + get {_storage._newList} set {_uniqueStorage()._newList = newValue} } + var newMessage: Int32 { + get {_storage._newMessage} + set {_uniqueStorage()._newMessage = newValue} + } + var newValue: Int32 { - get {return _storage._newValue} + get {_storage._newValue} set {_uniqueStorage()._newValue = newValue} } + var next: Int32 { + get {_storage._next} + set {_uniqueStorage()._next = newValue} + } + var nextByte: Int32 { - get {return _storage._nextByte} + get {_storage._nextByte} set {_uniqueStorage()._nextByte = newValue} } var nextFieldNumber: Int32 { - get {return _storage._nextFieldNumber} + get {_storage._nextFieldNumber} set {_uniqueStorage()._nextFieldNumber = newValue} } + var nextInstruction: Int32 { + get {_storage._nextInstruction} + set {_uniqueStorage()._nextInstruction = newValue} + } + + var nextInt32: Int32 { + get {_storage._nextInt32} + set {_uniqueStorage()._nextInt32 = newValue} + } + + var nextNullTerminatedString: Int32 { + get {_storage._nextNullTerminatedString} + set {_uniqueStorage()._nextNullTerminatedString = newValue} + } + + var nextNullTerminatedStringArray: Int32 { + get {_storage._nextNullTerminatedStringArray} + set {_uniqueStorage()._nextNullTerminatedStringArray = newValue} + } + + var nextNumber: Int32 { + get {_storage._nextNumber} + set {_uniqueStorage()._nextNumber = newValue} + } + + var nextUint64: Int32 { + get {_storage._nextUint64} + set {_uniqueStorage()._nextUint64 = newValue} + } + + var nextVarInt: Int32 { + get {_storage._nextVarInt} + set {_uniqueStorage()._nextVarInt = newValue} + } + var `nil`: Int32 { - get {return _storage._nil} + get {_storage._nil} set {_uniqueStorage()._nil = newValue} } var nilLiteral: Int32 { - get {return _storage._nilLiteral} + get {_storage._nilLiteral} set {_uniqueStorage()._nilLiteral = newValue} } + var noBytesAvailable: Int32 { + get {_storage._noBytesAvailable} + set {_uniqueStorage()._noBytesAvailable = newValue} + } + var noStandardDescriptorAccessor: Int32 { - get {return _storage._noStandardDescriptorAccessor} + get {_storage._noStandardDescriptorAccessor} set {_uniqueStorage()._noStandardDescriptorAccessor = newValue} } var nullValue: Int32 { - get {return _storage._nullValue} + get {_storage._nullValue} set {_uniqueStorage()._nullValue = newValue} } var number: Int32 { - get {return _storage._number} + get {_storage._number} set {_uniqueStorage()._number = newValue} } var numberValue: Int32 { - get {return _storage._numberValue} + get {_storage._numberValue} set {_uniqueStorage()._numberValue = newValue} } var objcClassPrefix: Int32 { - get {return _storage._objcClassPrefix} + get {_storage._objcClassPrefix} set {_uniqueStorage()._objcClassPrefix = newValue} } var of: Int32 { - get {return _storage._of} + get {_storage._of} set {_uniqueStorage()._of = newValue} } + var oneOfKind: Int32 { + get {_storage._oneOfKind} + set {_uniqueStorage()._oneOfKind = newValue} + } + var oneofDecl: Int32 { - get {return _storage._oneofDecl} + get {_storage._oneofDecl} set {_uniqueStorage()._oneofDecl = newValue} } - var oneofDescriptorProto: Int32 { - get {return _storage._oneofDescriptorProto} - set {_uniqueStorage()._oneofDescriptorProto = newValue} - } - var oneofIndex: Int32 { - get {return _storage._oneofIndex} + get {_storage._oneofIndex} set {_uniqueStorage()._oneofIndex = newValue} } - var oneofOptions: Int32 { - get {return _storage._oneofOptions} - set {_uniqueStorage()._oneofOptions = newValue} - } - var oneofs: Int32 { - get {return _storage._oneofs} + get {_storage._oneofs} set {_uniqueStorage()._oneofs = newValue} } - var oneOfKind: Int32 { - get {return _storage._oneOfKind} - set {_uniqueStorage()._oneOfKind = newValue} - } - var optimizeFor: Int32 { - get {return _storage._optimizeFor} + get {_storage._optimizeFor} set {_uniqueStorage()._optimizeFor = newValue} } var optimizeMode: Int32 { - get {return _storage._optimizeMode} + get {_storage._optimizeMode} set {_uniqueStorage()._optimizeMode = newValue} } - var option: Int32 { - get {return _storage._option} - set {_uniqueStorage()._option = newValue} - } - var optionalEnumExtensionField: Int32 { - get {return _storage._optionalEnumExtensionField} + get {_storage._optionalEnumExtensionField} set {_uniqueStorage()._optionalEnumExtensionField = newValue} } var optionalExtensionField: Int32 { - get {return _storage._optionalExtensionField} + get {_storage._optionalExtensionField} set {_uniqueStorage()._optionalExtensionField = newValue} } var optionalGroupExtensionField: Int32 { - get {return _storage._optionalGroupExtensionField} + get {_storage._optionalGroupExtensionField} set {_uniqueStorage()._optionalGroupExtensionField = newValue} } var optionalMessageExtensionField: Int32 { - get {return _storage._optionalMessageExtensionField} + get {_storage._optionalMessageExtensionField} set {_uniqueStorage()._optionalMessageExtensionField = newValue} } + var optionDependency: Int32 { + get {_storage._optionDependency} + set {_uniqueStorage()._optionDependency = newValue} + } + + var optionRetention: Int32 { + get {_storage._optionRetention} + set {_uniqueStorage()._optionRetention = newValue} + } + var options: Int32 { - get {return _storage._options} + get {_storage._options} set {_uniqueStorage()._options = newValue} } + var optionTargetType: Int32 { + get {_storage._optionTargetType} + set {_uniqueStorage()._optionTargetType = newValue} + } + var other: Int32 { - get {return _storage._other} + get {_storage._other} set {_uniqueStorage()._other = newValue} } var others: Int32 { - get {return _storage._others} + get {_storage._others} set {_uniqueStorage()._others = newValue} } var out: Int32 { - get {return _storage._out} + get {_storage._out} set {_uniqueStorage()._out = newValue} } var outputType: Int32 { - get {return _storage._outputType} + get {_storage._outputType} set {_uniqueStorage()._outputType = newValue} } + var overridableFeatures: Int32 { + get {_storage._overridableFeatures} + set {_uniqueStorage()._overridableFeatures = newValue} + } + var p: Int32 { - get {return _storage._p} + get {_storage._p} set {_uniqueStorage()._p = newValue} } var package: Int32 { - get {return _storage._package} + get {_storage._package} set {_uniqueStorage()._package = newValue} } var packed: Int32 { - get {return _storage._packed} + get {_storage._packed} set {_uniqueStorage()._packed = newValue} } var packedEnumExtensionField: Int32 { - get {return _storage._packedEnumExtensionField} + get {_storage._packedEnumExtensionField} set {_uniqueStorage()._packedEnumExtensionField = newValue} } var packedExtensionField: Int32 { - get {return _storage._packedExtensionField} + get {_storage._packedExtensionField} set {_uniqueStorage()._packedExtensionField = newValue} } var padding: Int32 { - get {return _storage._padding} + get {_storage._padding} set {_uniqueStorage()._padding = newValue} } var parent: Int32 { - get {return _storage._parent} + get {_storage._parent} set {_uniqueStorage()._parent = newValue} } var parse: Int32 { - get {return _storage._parse} + get {_storage._parse} set {_uniqueStorage()._parse = newValue} } var partial: Int32 { - get {return _storage._partial} + get {_storage._partial} set {_uniqueStorage()._partial = newValue} } var path: Int32 { - get {return _storage._path} + get {_storage._path} set {_uniqueStorage()._path = newValue} } + var pathDecoder: Int32 { + get {_storage._pathDecoder} + set {_uniqueStorage()._pathDecoder = newValue} + } + + var pathDecodingError: Int32 { + get {_storage._pathDecodingError} + set {_uniqueStorage()._pathDecodingError = newValue} + } + var paths: Int32 { - get {return _storage._paths} + get {_storage._paths} set {_uniqueStorage()._paths = newValue} } + var pathVisitor: Int32 { + get {_storage._pathVisitor} + set {_uniqueStorage()._pathVisitor = newValue} + } + var payload: Int32 { - get {return _storage._payload} + get {_storage._payload} set {_uniqueStorage()._payload = newValue} } var payloadSize: Int32 { - get {return _storage._payloadSize} + get {_storage._payloadSize} set {_uniqueStorage()._payloadSize = newValue} } var phpClassPrefix: Int32 { - get {return _storage._phpClassPrefix} + get {_storage._phpClassPrefix} set {_uniqueStorage()._phpClassPrefix = newValue} } - var phpGenericServices: Int32 { - get {return _storage._phpGenericServices} - set {_uniqueStorage()._phpGenericServices = newValue} - } - var phpMetadataNamespace: Int32 { - get {return _storage._phpMetadataNamespace} + get {_storage._phpMetadataNamespace} set {_uniqueStorage()._phpMetadataNamespace = newValue} } var phpNamespace: Int32 { - get {return _storage._phpNamespace} + get {_storage._phpNamespace} set {_uniqueStorage()._phpNamespace = newValue} } - var pointer: Int32 { - get {return _storage._pointer} - set {_uniqueStorage()._pointer = newValue} - } - var pos: Int32 { - get {return _storage._pos} + get {_storage._pos} set {_uniqueStorage()._pos = newValue} } var positiveIntValue: Int32 { - get {return _storage._positiveIntValue} + get {_storage._positiveIntValue} set {_uniqueStorage()._positiveIntValue = newValue} } var prefix: Int32 { - get {return _storage._prefix} + get {_storage._prefix} set {_uniqueStorage()._prefix = newValue} } var preserveProtoFieldNames: Int32 { - get {return _storage._preserveProtoFieldNames} + get {_storage._preserveProtoFieldNames} set {_uniqueStorage()._preserveProtoFieldNames = newValue} } var preTraverse: Int32 { - get {return _storage._preTraverse} + get {_storage._preTraverse} set {_uniqueStorage()._preTraverse = newValue} } + var previousNumber: Int32 { + get {_storage._previousNumber} + set {_uniqueStorage()._previousNumber = newValue} + } + + var prevPath: Int32 { + get {_storage._prevPath} + set {_uniqueStorage()._prevPath = newValue} + } + var printUnknownFields: Int32 { - get {return _storage._printUnknownFields} + get {_storage._printUnknownFields} set {_uniqueStorage()._printUnknownFields = newValue} } + var programBuffer: Int32 { + get {_storage._programBuffer} + set {_uniqueStorage()._programBuffer = newValue} + } + + var programFormat: Int32 { + get {_storage._programFormat} + set {_uniqueStorage()._programFormat = newValue} + } + var proto2: Int32 { - get {return _storage._proto2} + get {_storage._proto2} set {_uniqueStorage()._proto2 = newValue} } var proto3DefaultValue: Int32 { - get {return _storage._proto3DefaultValue} + get {_storage._proto3DefaultValue} set {_uniqueStorage()._proto3DefaultValue = newValue} } var proto3Optional: Int32 { - get {return _storage._proto3Optional} + get {_storage._proto3Optional} set {_uniqueStorage()._proto3Optional = newValue} } - var protobufApiversionCheck: Int32 { - get {return _storage._protobufApiversionCheck} - set {_uniqueStorage()._protobufApiversionCheck = newValue} + var protobufExtensionFieldValues: Int32 { + get {_storage._protobufExtensionFieldValues} + set {_uniqueStorage()._protobufExtensionFieldValues = newValue} + } + + var protobufFieldNumber: Int32 { + get {_storage._protobufFieldNumber} + set {_uniqueStorage()._protobufFieldNumber = newValue} + } + + var protobufGeneratedIsEqualTo: Int32 { + get {_storage._protobufGeneratedIsEqualTo} + set {_uniqueStorage()._protobufGeneratedIsEqualTo = newValue} + } + + var protobufNameMap: Int32 { + get {_storage._protobufNameMap} + set {_uniqueStorage()._protobufNameMap = newValue} + } + + var protobufNewField: Int32 { + get {_storage._protobufNewField} + set {_uniqueStorage()._protobufNewField = newValue} + } + + var protobufPackage: Int32 { + get {_storage._protobufPackage} + set {_uniqueStorage()._protobufPackage = newValue} } var protobufApiversion2: Int32 { - get {return _storage._protobufApiversion2} + get {_storage._protobufApiversion2} set {_uniqueStorage()._protobufApiversion2 = newValue} } + var protobufApiversionCheck: Int32 { + get {_storage._protobufApiversionCheck} + set {_uniqueStorage()._protobufApiversionCheck = newValue} + } + var protobufBool: Int32 { - get {return _storage._protobufBool} + get {_storage._protobufBool} set {_uniqueStorage()._protobufBool = newValue} } var protobufBytes: Int32 { - get {return _storage._protobufBytes} + get {_storage._protobufBytes} set {_uniqueStorage()._protobufBytes = newValue} } + var protobufData: Int32 { + get {_storage._protobufData} + set {_uniqueStorage()._protobufData = newValue} + } + var protobufDouble: Int32 { - get {return _storage._protobufDouble} + get {_storage._protobufDouble} set {_uniqueStorage()._protobufDouble = newValue} } var protobufEnumMap: Int32 { - get {return _storage._protobufEnumMap} + get {_storage._protobufEnumMap} set {_uniqueStorage()._protobufEnumMap = newValue} } var protobufExtension: Int32 { - get {return _storage._protobufExtension} + get {_storage._protobufExtension} set {_uniqueStorage()._protobufExtension = newValue} } var protobufFixed32: Int32 { - get {return _storage._protobufFixed32} + get {_storage._protobufFixed32} set {_uniqueStorage()._protobufFixed32 = newValue} } var protobufFixed64: Int32 { - get {return _storage._protobufFixed64} + get {_storage._protobufFixed64} set {_uniqueStorage()._protobufFixed64 = newValue} } var protobufFloat: Int32 { - get {return _storage._protobufFloat} + get {_storage._protobufFloat} set {_uniqueStorage()._protobufFloat = newValue} } var protobufInt32: Int32 { - get {return _storage._protobufInt32} + get {_storage._protobufInt32} set {_uniqueStorage()._protobufInt32 = newValue} } var protobufInt64: Int32 { - get {return _storage._protobufInt64} + get {_storage._protobufInt64} set {_uniqueStorage()._protobufInt64 = newValue} } var protobufMap: Int32 { - get {return _storage._protobufMap} + get {_storage._protobufMap} set {_uniqueStorage()._protobufMap = newValue} } var protobufMessageMap: Int32 { - get {return _storage._protobufMessageMap} + get {_storage._protobufMessageMap} set {_uniqueStorage()._protobufMessageMap = newValue} } var protobufSfixed32: Int32 { - get {return _storage._protobufSfixed32} + get {_storage._protobufSfixed32} set {_uniqueStorage()._protobufSfixed32 = newValue} } var protobufSfixed64: Int32 { - get {return _storage._protobufSfixed64} + get {_storage._protobufSfixed64} set {_uniqueStorage()._protobufSfixed64 = newValue} } var protobufSint32: Int32 { - get {return _storage._protobufSint32} + get {_storage._protobufSint32} set {_uniqueStorage()._protobufSint32 = newValue} } var protobufSint64: Int32 { - get {return _storage._protobufSint64} + get {_storage._protobufSint64} set {_uniqueStorage()._protobufSint64 = newValue} } var protobufString: Int32 { - get {return _storage._protobufString} + get {_storage._protobufString} set {_uniqueStorage()._protobufString = newValue} } var protobufUint32: Int32 { - get {return _storage._protobufUint32} + get {_storage._protobufUint32} set {_uniqueStorage()._protobufUint32 = newValue} } var protobufUint64: Int32 { - get {return _storage._protobufUint64} + get {_storage._protobufUint64} set {_uniqueStorage()._protobufUint64 = newValue} } - var protobufExtensionFieldValues: Int32 { - get {return _storage._protobufExtensionFieldValues} - set {_uniqueStorage()._protobufExtensionFieldValues = newValue} - } - - var protobufFieldNumber: Int32 { - get {return _storage._protobufFieldNumber} - set {_uniqueStorage()._protobufFieldNumber = newValue} - } - - var protobufGeneratedIsEqualTo: Int32 { - get {return _storage._protobufGeneratedIsEqualTo} - set {_uniqueStorage()._protobufGeneratedIsEqualTo = newValue} - } - - var protobufNameMap: Int32 { - get {return _storage._protobufNameMap} - set {_uniqueStorage()._protobufNameMap = newValue} - } - - var protobufNewField: Int32 { - get {return _storage._protobufNewField} - set {_uniqueStorage()._protobufNewField = newValue} - } - - var protobufPackage: Int32 { - get {return _storage._protobufPackage} - set {_uniqueStorage()._protobufPackage = newValue} - } - var `protocol`: Int32 { - get {return _storage._protocol} + get {_storage._protocol} set {_uniqueStorage()._protocol = newValue} } var protoFieldName: Int32 { - get {return _storage._protoFieldName} + get {_storage._protoFieldName} set {_uniqueStorage()._protoFieldName = newValue} } var protoMessageName: Int32 { - get {return _storage._protoMessageName} + get {_storage._protoMessageName} set {_uniqueStorage()._protoMessageName = newValue} } var protoNameProviding: Int32 { - get {return _storage._protoNameProviding} + get {_storage._protoNameProviding} set {_uniqueStorage()._protoNameProviding = newValue} } var protoPaths: Int32 { - get {return _storage._protoPaths} + get {_storage._protoPaths} set {_uniqueStorage()._protoPaths = newValue} } var `public`: Int32 { - get {return _storage._public} + get {_storage._public} set {_uniqueStorage()._public = newValue} } var publicDependency: Int32 { - get {return _storage._publicDependency} + get {_storage._publicDependency} set {_uniqueStorage()._publicDependency = newValue} } var putBoolValue: Int32 { - get {return _storage._putBoolValue} + get {_storage._putBoolValue} set {_uniqueStorage()._putBoolValue = newValue} } var putBytesValue: Int32 { - get {return _storage._putBytesValue} + get {_storage._putBytesValue} set {_uniqueStorage()._putBytesValue = newValue} } var putDoubleValue: Int32 { - get {return _storage._putDoubleValue} + get {_storage._putDoubleValue} set {_uniqueStorage()._putDoubleValue = newValue} } var putEnumValue: Int32 { - get {return _storage._putEnumValue} + get {_storage._putEnumValue} set {_uniqueStorage()._putEnumValue = newValue} } var putFixedUint32: Int32 { - get {return _storage._putFixedUint32} + get {_storage._putFixedUint32} set {_uniqueStorage()._putFixedUint32 = newValue} } var putFixedUint64: Int32 { - get {return _storage._putFixedUint64} + get {_storage._putFixedUint64} set {_uniqueStorage()._putFixedUint64 = newValue} } var putFloatValue: Int32 { - get {return _storage._putFloatValue} + get {_storage._putFloatValue} set {_uniqueStorage()._putFloatValue = newValue} } var putInt64: Int32 { - get {return _storage._putInt64} + get {_storage._putInt64} set {_uniqueStorage()._putInt64 = newValue} } var putStringValue: Int32 { - get {return _storage._putStringValue} + get {_storage._putStringValue} set {_uniqueStorage()._putStringValue = newValue} } var putUint64: Int32 { - get {return _storage._putUint64} + get {_storage._putUint64} set {_uniqueStorage()._putUint64 = newValue} } var putUint64Hex: Int32 { - get {return _storage._putUint64Hex} + get {_storage._putUint64Hex} set {_uniqueStorage()._putUint64Hex = newValue} } var putVarInt: Int32 { - get {return _storage._putVarInt} + get {_storage._putVarInt} set {_uniqueStorage()._putVarInt = newValue} } var putZigZagVarInt: Int32 { - get {return _storage._putZigZagVarInt} + get {_storage._putZigZagVarInt} set {_uniqueStorage()._putZigZagVarInt = newValue} } var pyGenericServices: Int32 { - get {return _storage._pyGenericServices} + get {_storage._pyGenericServices} set {_uniqueStorage()._pyGenericServices = newValue} } + var r: Int32 { + get {_storage._r} + set {_uniqueStorage()._r = newValue} + } + var rawChars: Int32 { - get {return _storage._rawChars} + get {_storage._rawChars} set {_uniqueStorage()._rawChars = newValue} } var rawRepresentable: Int32 { - get {return _storage._rawRepresentable} + get {_storage._rawRepresentable} set {_uniqueStorage()._rawRepresentable = newValue} } var rawValue: Int32 { - get {return _storage._rawValue} + get {_storage._rawValue} set {_uniqueStorage()._rawValue = newValue} } var read4HexDigits: Int32 { - get {return _storage._read4HexDigits} + get {_storage._read4HexDigits} set {_uniqueStorage()._read4HexDigits = newValue} } + var readBytes: Int32 { + get {_storage._readBytes} + set {_uniqueStorage()._readBytes = newValue} + } + + var reader: Int32 { + get {_storage._reader} + set {_uniqueStorage()._reader = newValue} + } + var register: Int32 { - get {return _storage._register} + get {_storage._register} set {_uniqueStorage()._register = newValue} } + var remainingProgram: Int32 { + get {_storage._remainingProgram} + set {_uniqueStorage()._remainingProgram = newValue} + } + + var removalError: Int32 { + get {_storage._removalError} + set {_uniqueStorage()._removalError = newValue} + } + + var removingAllFieldsOf: Int32 { + get {_storage._removingAllFieldsOf} + set {_uniqueStorage()._removingAllFieldsOf = newValue} + } + + var repeated: Int32 { + get {_storage._repeated} + set {_uniqueStorage()._repeated = newValue} + } + var repeatedEnumExtensionField: Int32 { - get {return _storage._repeatedEnumExtensionField} + get {_storage._repeatedEnumExtensionField} set {_uniqueStorage()._repeatedEnumExtensionField = newValue} } var repeatedExtensionField: Int32 { - get {return _storage._repeatedExtensionField} + get {_storage._repeatedExtensionField} set {_uniqueStorage()._repeatedExtensionField = newValue} } + var repeatedFieldEncoding: Int32 { + get {_storage._repeatedFieldEncoding} + set {_uniqueStorage()._repeatedFieldEncoding = newValue} + } + var repeatedGroupExtensionField: Int32 { - get {return _storage._repeatedGroupExtensionField} + get {_storage._repeatedGroupExtensionField} set {_uniqueStorage()._repeatedGroupExtensionField = newValue} } var repeatedMessageExtensionField: Int32 { - get {return _storage._repeatedMessageExtensionField} + get {_storage._repeatedMessageExtensionField} set {_uniqueStorage()._repeatedMessageExtensionField = newValue} } + var repeating: Int32 { + get {_storage._repeating} + set {_uniqueStorage()._repeating = newValue} + } + + var replaceRepeatedFields: Int32 { + get {_storage._replaceRepeatedFields} + set {_uniqueStorage()._replaceRepeatedFields = newValue} + } + var requestStreaming: Int32 { - get {return _storage._requestStreaming} + get {_storage._requestStreaming} set {_uniqueStorage()._requestStreaming = newValue} } var requestTypeURL: Int32 { - get {return _storage._requestTypeURL} + get {_storage._requestTypeURL} set {_uniqueStorage()._requestTypeURL = newValue} } var requiredSize: Int32 { - get {return _storage._requiredSize} + get {_storage._requiredSize} set {_uniqueStorage()._requiredSize = newValue} } - var reservedName: Int32 { - get {return _storage._reservedName} - set {_uniqueStorage()._reservedName = newValue} - } - - var reservedRange: Int32 { - get {return _storage._reservedRange} - set {_uniqueStorage()._reservedRange = newValue} - } - var responseStreaming: Int32 { - get {return _storage._responseStreaming} + get {_storage._responseStreaming} set {_uniqueStorage()._responseStreaming = newValue} } var responseTypeURL: Int32 { - get {return _storage._responseTypeURL} + get {_storage._responseTypeURL} set {_uniqueStorage()._responseTypeURL = newValue} } var result: Int32 { - get {return _storage._result} + get {_storage._result} set {_uniqueStorage()._result = newValue} } - var `rethrows`: Int32 { - get {return _storage._rethrows} - set {_uniqueStorage()._rethrows = newValue} + var retention: Int32 { + get {_storage._retention} + set {_uniqueStorage()._retention = newValue} } - var `return`: Int32 { - get {return _storage._return} - set {_uniqueStorage()._return = newValue} + var `rethrows`: Int32 { + get {_storage._rethrows} + set {_uniqueStorage()._rethrows = newValue} } var returnType: Int32 { - get {return _storage._returnType} + get {_storage._returnType} set {_uniqueStorage()._returnType = newValue} } var revision: Int32 { - get {return _storage._revision} + get {_storage._revision} set {_uniqueStorage()._revision = newValue} } var rhs: Int32 { - get {return _storage._rhs} + get {_storage._rhs} set {_uniqueStorage()._rhs = newValue} } var root: Int32 { - get {return _storage._root} + get {_storage._root} set {_uniqueStorage()._root = newValue} } var rubyPackage: Int32 { - get {return _storage._rubyPackage} + get {_storage._rubyPackage} set {_uniqueStorage()._rubyPackage = newValue} } var s: Int32 { - get {return _storage._s} + get {_storage._s} set {_uniqueStorage()._s = newValue} } var sawBackslash: Int32 { - get {return _storage._sawBackslash} + get {_storage._sawBackslash} set {_uniqueStorage()._sawBackslash = newValue} } var sawSection4Characters: Int32 { - get {return _storage._sawSection4Characters} + get {_storage._sawSection4Characters} set {_uniqueStorage()._sawSection4Characters = newValue} } var sawSection5Characters: Int32 { - get {return _storage._sawSection5Characters} + get {_storage._sawSection5Characters} set {_uniqueStorage()._sawSection5Characters = newValue} } + var scalar: Int32 { + get {_storage._scalar} + set {_uniqueStorage()._scalar = newValue} + } + + var scan: Int32 { + get {_storage._scan} + set {_uniqueStorage()._scan = newValue} + } + var scanner: Int32 { - get {return _storage._scanner} + get {_storage._scanner} set {_uniqueStorage()._scanner = newValue} } var seconds: Int32 { - get {return _storage._seconds} + get {_storage._seconds} set {_uniqueStorage()._seconds = newValue} } var self_p: Int32 { - get {return _storage._self_p} + get {_storage._self_p} set {_uniqueStorage()._self_p = newValue} } + var semantic: Int32 { + get {_storage._semantic} + set {_uniqueStorage()._semantic = newValue} + } + + var sendable: Int32 { + get {_storage._sendable} + set {_uniqueStorage()._sendable = newValue} + } + var separator: Int32 { - get {return _storage._separator} + get {_storage._separator} set {_uniqueStorage()._separator = newValue} } var serialize: Int32 { - get {return _storage._serialize} + get {_storage._serialize} set {_uniqueStorage()._serialize = newValue} } + var serializedBytes: Int32 { + get {_storage._serializedBytes} + set {_uniqueStorage()._serializedBytes = newValue} + } + var serializedData: Int32 { - get {return _storage._serializedData} + get {_storage._serializedData} set {_uniqueStorage()._serializedData = newValue} } var serializedSize: Int32 { - get {return _storage._serializedSize} + get {_storage._serializedSize} set {_uniqueStorage()._serializedSize = newValue} } var serverStreaming: Int32 { - get {return _storage._serverStreaming} + get {_storage._serverStreaming} set {_uniqueStorage()._serverStreaming = newValue} } var service: Int32 { - get {return _storage._service} + get {_storage._service} set {_uniqueStorage()._service = newValue} } - var serviceDescriptorProto: Int32 { - get {return _storage._serviceDescriptorProto} - set {_uniqueStorage()._serviceDescriptorProto = newValue} - } - - var serviceOptions: Int32 { - get {return _storage._serviceOptions} - set {_uniqueStorage()._serviceOptions = newValue} - } - var set: Int32 { - get {return _storage._set} + get {_storage._set} set {_uniqueStorage()._set = newValue} } var setExtensionValue: Int32 { - get {return _storage._setExtensionValue} + get {_storage._setExtensionValue} set {_uniqueStorage()._setExtensionValue = newValue} } var shift: Int32 { - get {return _storage._shift} + get {_storage._shift} set {_uniqueStorage()._shift = newValue} } var simpleExtensionMap: Int32 { - get {return _storage._simpleExtensionMap} + get {_storage._simpleExtensionMap} set {_uniqueStorage()._simpleExtensionMap = newValue} } + var size: Int32 { + get {_storage._size} + set {_uniqueStorage()._size = newValue} + } + var sizer: Int32 { - get {return _storage._sizer} + get {_storage._sizer} set {_uniqueStorage()._sizer = newValue} } var source: Int32 { - get {return _storage._source} + get {_storage._source} set {_uniqueStorage()._source = newValue} } var sourceCodeInfo: Int32 { - get {return _storage._sourceCodeInfo} + get {_storage._sourceCodeInfo} set {_uniqueStorage()._sourceCodeInfo = newValue} } var sourceContext: Int32 { - get {return _storage._sourceContext} + get {_storage._sourceContext} set {_uniqueStorage()._sourceContext = newValue} } var sourceEncoding: Int32 { - get {return _storage._sourceEncoding} + get {_storage._sourceEncoding} set {_uniqueStorage()._sourceEncoding = newValue} } var sourceFile: Int32 { - get {return _storage._sourceFile} + get {_storage._sourceFile} set {_uniqueStorage()._sourceFile = newValue} } + var sourceLocation: Int32 { + get {_storage._sourceLocation} + set {_uniqueStorage()._sourceLocation = newValue} + } + var span: Int32 { - get {return _storage._span} + get {_storage._span} set {_uniqueStorage()._span = newValue} } var split: Int32 { - get {return _storage._split} + get {_storage._split} set {_uniqueStorage()._split = newValue} } var start: Int32 { - get {return _storage._start} + get {_storage._start} set {_uniqueStorage()._start = newValue} } var startArray: Int32 { - get {return _storage._startArray} + get {_storage._startArray} set {_uniqueStorage()._startArray = newValue} } var startArrayObject: Int32 { - get {return _storage._startArrayObject} + get {_storage._startArrayObject} set {_uniqueStorage()._startArrayObject = newValue} } var startField: Int32 { - get {return _storage._startField} + get {_storage._startField} set {_uniqueStorage()._startField = newValue} } var startIndex: Int32 { - get {return _storage._startIndex} + get {_storage._startIndex} set {_uniqueStorage()._startIndex = newValue} } var startMessageField: Int32 { - get {return _storage._startMessageField} + get {_storage._startMessageField} set {_uniqueStorage()._startMessageField = newValue} } var startObject: Int32 { - get {return _storage._startObject} + get {_storage._startObject} set {_uniqueStorage()._startObject = newValue} } var startRegularField: Int32 { - get {return _storage._startRegularField} + get {_storage._startRegularField} set {_uniqueStorage()._startRegularField = newValue} } var state: Int32 { - get {return _storage._state} + get {_storage._state} set {_uniqueStorage()._state = newValue} } var `static`: Int32 { - get {return _storage._static} + get {_storage._static} set {_uniqueStorage()._static = newValue} } var staticString: Int32 { - get {return _storage._staticString} + get {_storage._staticString} set {_uniqueStorage()._staticString = newValue} } var storage: Int32 { - get {return _storage._storage} + get {_storage._storage} set {_uniqueStorage()._storage = newValue} } var string: Int32 { - get {return _storage._string} + get {_storage._string} set {_uniqueStorage()._string = newValue} } var stringLiteral: Int32 { - get {return _storage._stringLiteral} + get {_storage._stringLiteral} set {_uniqueStorage()._stringLiteral = newValue} } var stringLiteralType: Int32 { - get {return _storage._stringLiteralType} + get {_storage._stringLiteralType} set {_uniqueStorage()._stringLiteralType = newValue} } var stringResult: Int32 { - get {return _storage._stringResult} + get {_storage._stringResult} set {_uniqueStorage()._stringResult = newValue} } var stringValue: Int32 { - get {return _storage._stringValue} + get {_storage._stringValue} set {_uniqueStorage()._stringValue = newValue} } var `struct`: Int32 { - get {return _storage._struct} + get {_storage._struct} set {_uniqueStorage()._struct = newValue} } var structValue: Int32 { - get {return _storage._structValue} + get {_storage._structValue} set {_uniqueStorage()._structValue = newValue} } var subDecoder: Int32 { - get {return _storage._subDecoder} + get {_storage._subDecoder} set {_uniqueStorage()._subDecoder = newValue} } var `subscript`: Int32 { - get {return _storage._subscript} + get {_storage._subscript} set {_uniqueStorage()._subscript = newValue} } + var subtract: Int32 { + get {_storage._subtract} + set {_uniqueStorage()._subtract = newValue} + } + var subVisitor: Int32 { - get {return _storage._subVisitor} + get {_storage._subVisitor} set {_uniqueStorage()._subVisitor = newValue} } var swift: Int32 { - get {return _storage._swift} + get {_storage._swift} set {_uniqueStorage()._swift = newValue} } var swiftPrefix: Int32 { - get {return _storage._swiftPrefix} + get {_storage._swiftPrefix} set {_uniqueStorage()._swiftPrefix = newValue} } - var swiftProtobuf: Int32 { - get {return _storage._swiftProtobuf} - set {_uniqueStorage()._swiftProtobuf = newValue} + var swiftProtobufContiguousBytes: Int32 { + get {_storage._swiftProtobufContiguousBytes} + set {_uniqueStorage()._swiftProtobufContiguousBytes = newValue} + } + + var swiftProtobufError: Int32 { + get {_storage._swiftProtobufError} + set {_uniqueStorage()._swiftProtobufError = newValue} } var syntax: Int32 { - get {return _storage._syntax} + get {_storage._syntax} set {_uniqueStorage()._syntax = newValue} } var t: Int32 { - get {return _storage._t} + get {_storage._t} set {_uniqueStorage()._t = newValue} } var tag: Int32 { - get {return _storage._tag} + get {_storage._tag} set {_uniqueStorage()._tag = newValue} } + var targets: Int32 { + get {_storage._targets} + set {_uniqueStorage()._targets = newValue} + } + var terminator: Int32 { - get {return _storage._terminator} + get {_storage._terminator} set {_uniqueStorage()._terminator = newValue} } var testDecoder: Int32 { - get {return _storage._testDecoder} + get {_storage._testDecoder} set {_uniqueStorage()._testDecoder = newValue} } var text: Int32 { - get {return _storage._text} + get {_storage._text} set {_uniqueStorage()._text = newValue} } var textDecoder: Int32 { - get {return _storage._textDecoder} + get {_storage._textDecoder} set {_uniqueStorage()._textDecoder = newValue} } var textFormatDecoder: Int32 { - get {return _storage._textFormatDecoder} + get {_storage._textFormatDecoder} set {_uniqueStorage()._textFormatDecoder = newValue} } var textFormatDecodingError: Int32 { - get {return _storage._textFormatDecodingError} + get {_storage._textFormatDecodingError} set {_uniqueStorage()._textFormatDecodingError = newValue} } var textFormatDecodingOptions: Int32 { - get {return _storage._textFormatDecodingOptions} + get {_storage._textFormatDecodingOptions} set {_uniqueStorage()._textFormatDecodingOptions = newValue} } var textFormatEncodingOptions: Int32 { - get {return _storage._textFormatEncodingOptions} + get {_storage._textFormatEncodingOptions} set {_uniqueStorage()._textFormatEncodingOptions = newValue} } var textFormatEncodingVisitor: Int32 { - get {return _storage._textFormatEncodingVisitor} + get {_storage._textFormatEncodingVisitor} set {_uniqueStorage()._textFormatEncodingVisitor = newValue} } var textFormatString: Int32 { - get {return _storage._textFormatString} + get {_storage._textFormatString} set {_uniqueStorage()._textFormatString = newValue} } + var throwOrIgnore: Int32 { + get {_storage._throwOrIgnore} + set {_uniqueStorage()._throwOrIgnore = newValue} + } + var `throws`: Int32 { - get {return _storage._throws} + get {_storage._throws} set {_uniqueStorage()._throws = newValue} } var timeInterval: Int32 { - get {return _storage._timeInterval} + get {_storage._timeInterval} set {_uniqueStorage()._timeInterval = newValue} } var timeIntervalSince1970: Int32 { - get {return _storage._timeIntervalSince1970} + get {_storage._timeIntervalSince1970} set {_uniqueStorage()._timeIntervalSince1970 = newValue} } var timeIntervalSinceReferenceDate: Int32 { - get {return _storage._timeIntervalSinceReferenceDate} + get {_storage._timeIntervalSinceReferenceDate} set {_uniqueStorage()._timeIntervalSinceReferenceDate = newValue} } - var timestamp: Int32 { - get {return _storage._timestamp} - set {_uniqueStorage()._timestamp = newValue} + var tmp: Int32 { + get {_storage._tmp} + set {_uniqueStorage()._tmp = newValue} + } + + var tooLarge: Int32 { + get {_storage._tooLarge} + set {_uniqueStorage()._tooLarge = newValue} } var total: Int32 { - get {return _storage._total} + get {_storage._total} set {_uniqueStorage()._total = newValue} } var totalArrayDepth: Int32 { - get {return _storage._totalArrayDepth} + get {_storage._totalArrayDepth} set {_uniqueStorage()._totalArrayDepth = newValue} } var totalSize: Int32 { - get {return _storage._totalSize} + get {_storage._totalSize} set {_uniqueStorage()._totalSize = newValue} } var trailingComments: Int32 { - get {return _storage._trailingComments} + get {_storage._trailingComments} set {_uniqueStorage()._trailingComments = newValue} } var traverse: Int32 { - get {return _storage._traverse} + get {_storage._traverse} set {_uniqueStorage()._traverse = newValue} } + var trim: Int32 { + get {_storage._trim} + set {_uniqueStorage()._trim = newValue} + } + var `true`: Int32 { - get {return _storage._true} + get {_storage._true} set {_uniqueStorage()._true = newValue} } var `try`: Int32 { - get {return _storage._try} + get {_storage._try} set {_uniqueStorage()._try = newValue} } var type: Int32 { - get {return _storage._type} + get {_storage._type} set {_uniqueStorage()._type = newValue} } var `typealias`: Int32 { - get {return _storage._typealias} + get {_storage._typealias} set {_uniqueStorage()._typealias = newValue} } var typeEnum: Int32 { - get {return _storage._typeEnum} + get {_storage._typeEnum} set {_uniqueStorage()._typeEnum = newValue} } var typeName: Int32 { - get {return _storage._typeName} + get {_storage._typeName} set {_uniqueStorage()._typeName = newValue} } var typePrefix: Int32 { - get {return _storage._typePrefix} + get {_storage._typePrefix} set {_uniqueStorage()._typePrefix = newValue} } var typeStart: Int32 { - get {return _storage._typeStart} + get {_storage._typeStart} set {_uniqueStorage()._typeStart = newValue} } var typeUnknown: Int32 { - get {return _storage._typeUnknown} + get {_storage._typeUnknown} set {_uniqueStorage()._typeUnknown = newValue} } var typeURL: Int32 { - get {return _storage._typeURL} + get {_storage._typeURL} set {_uniqueStorage()._typeURL = newValue} } var uint32: Int32 { - get {return _storage._uint32} + get {_storage._uint32} set {_uniqueStorage()._uint32 = newValue} } - var uint32Value: Int32 { - get {return _storage._uint32Value} - set {_uniqueStorage()._uint32Value = newValue} - } - var uint64: Int32 { - get {return _storage._uint64} + get {_storage._uint64} set {_uniqueStorage()._uint64 = newValue} } - var uint64Value: Int32 { - get {return _storage._uint64Value} - set {_uniqueStorage()._uint64Value = newValue} - } - var uint8: Int32 { - get {return _storage._uint8} + get {_storage._uint8} set {_uniqueStorage()._uint8 = newValue} } + var unchecked: Int32 { + get {_storage._unchecked} + set {_uniqueStorage()._unchecked = newValue} + } + + var unicode: Int32 { + get {_storage._unicode} + set {_uniqueStorage()._unicode = newValue} + } + var unicodeScalarLiteral: Int32 { - get {return _storage._unicodeScalarLiteral} + get {_storage._unicodeScalarLiteral} set {_uniqueStorage()._unicodeScalarLiteral = newValue} } var unicodeScalarLiteralType: Int32 { - get {return _storage._unicodeScalarLiteralType} + get {_storage._unicodeScalarLiteralType} set {_uniqueStorage()._unicodeScalarLiteralType = newValue} } var unicodeScalars: Int32 { - get {return _storage._unicodeScalars} + get {_storage._unicodeScalars} set {_uniqueStorage()._unicodeScalars = newValue} } var unicodeScalarView: Int32 { - get {return _storage._unicodeScalarView} + get {_storage._unicodeScalarView} set {_uniqueStorage()._unicodeScalarView = newValue} } var uninterpretedOption: Int32 { - get {return _storage._uninterpretedOption} + get {_storage._uninterpretedOption} set {_uniqueStorage()._uninterpretedOption = newValue} } var union: Int32 { - get {return _storage._union} + get {_storage._union} set {_uniqueStorage()._union = newValue} } var uniqueStorage: Int32 { - get {return _storage._uniqueStorage} + get {_storage._uniqueStorage} set {_uniqueStorage()._uniqueStorage = newValue} } var unknown: Int32 { - get {return _storage._unknown} + get {_storage._unknown} set {_uniqueStorage()._unknown = newValue} } var unknownFields_p: Int32 { - get {return _storage._unknownFields_p} + get {_storage._unknownFields_p} set {_uniqueStorage()._unknownFields_p = newValue} } var unknownStorage: Int32 { - get {return _storage._unknownStorage} + get {_storage._unknownStorage} set {_uniqueStorage()._unknownStorage = newValue} } var unpackTo: Int32 { - get {return _storage._unpackTo} + get {_storage._unpackTo} set {_uniqueStorage()._unpackTo = newValue} } var unsafeBufferPointer: Int32 { - get {return _storage._unsafeBufferPointer} + get {_storage._unsafeBufferPointer} set {_uniqueStorage()._unsafeBufferPointer = newValue} } var unsafeMutablePointer: Int32 { - get {return _storage._unsafeMutablePointer} + get {_storage._unsafeMutablePointer} set {_uniqueStorage()._unsafeMutablePointer = newValue} } var unsafeMutableRawBufferPointer: Int32 { - get {return _storage._unsafeMutableRawBufferPointer} + get {_storage._unsafeMutableRawBufferPointer} set {_uniqueStorage()._unsafeMutableRawBufferPointer = newValue} } - var unsafeMutableRawPointer: Int32 { - get {return _storage._unsafeMutableRawPointer} - set {_uniqueStorage()._unsafeMutableRawPointer = newValue} - } - var unsafeRawBufferPointer: Int32 { - get {return _storage._unsafeRawBufferPointer} + get {_storage._unsafeRawBufferPointer} set {_uniqueStorage()._unsafeRawBufferPointer = newValue} } var unsafeRawPointer: Int32 { - get {return _storage._unsafeRawPointer} + get {_storage._unsafeRawPointer} set {_uniqueStorage()._unsafeRawPointer = newValue} } + var unverifiedLazy: Int32 { + get {_storage._unverifiedLazy} + set {_uniqueStorage()._unverifiedLazy = newValue} + } + var updatedOptions: Int32 { - get {return _storage._updatedOptions} + get {_storage._updatedOptions} set {_uniqueStorage()._updatedOptions = newValue} } + var uppercasedAssumingAscii: Int32 { + get {_storage._uppercasedAssumingAscii} + set {_uniqueStorage()._uppercasedAssumingAscii = newValue} + } + var url: Int32 { - get {return _storage._url} + get {_storage._url} set {_uniqueStorage()._url = newValue} } + var useDeterministicOrdering: Int32 { + get {_storage._useDeterministicOrdering} + set {_uniqueStorage()._useDeterministicOrdering = newValue} + } + var utf8: Int32 { - get {return _storage._utf8} + get {_storage._utf8} set {_uniqueStorage()._utf8 = newValue} } var utf8Ptr: Int32 { - get {return _storage._utf8Ptr} + get {_storage._utf8Ptr} set {_uniqueStorage()._utf8Ptr = newValue} } var utf8ToDouble: Int32 { - get {return _storage._utf8ToDouble} + get {_storage._utf8ToDouble} set {_uniqueStorage()._utf8ToDouble = newValue} } + var utf8Validation: Int32 { + get {_storage._utf8Validation} + set {_uniqueStorage()._utf8Validation = newValue} + } + var utf8View: Int32 { - get {return _storage._utf8View} + get {_storage._utf8View} set {_uniqueStorage()._utf8View = newValue} } var v: Int32 { - get {return _storage._v} + get {_storage._v} set {_uniqueStorage()._v = newValue} } var value: Int32 { - get {return _storage._value} + get {_storage._value} set {_uniqueStorage()._value = newValue} } var valueField: Int32 { - get {return _storage._valueField} + get {_storage._valueField} set {_uniqueStorage()._valueField = newValue} } var values: Int32 { - get {return _storage._values} + get {_storage._values} set {_uniqueStorage()._values = newValue} } var valueType: Int32 { - get {return _storage._valueType} + get {_storage._valueType} set {_uniqueStorage()._valueType = newValue} } var `var`: Int32 { - get {return _storage._var} + get {_storage._var} set {_uniqueStorage()._var = newValue} } + var verification: Int32 { + get {_storage._verification} + set {_uniqueStorage()._verification = newValue} + } + + var verificationState: Int32 { + get {_storage._verificationState} + set {_uniqueStorage()._verificationState = newValue} + } + var version: Int32 { - get {return _storage._version} + get {_storage._version} set {_uniqueStorage()._version = newValue} } var versionString: Int32 { - get {return _storage._versionString} + get {_storage._versionString} set {_uniqueStorage()._versionString = newValue} } + var visibility: Int32 { + get {_storage._visibility} + set {_uniqueStorage()._visibility = newValue} + } + + var visibilityFeature: Int32 { + get {_storage._visibilityFeature} + set {_uniqueStorage()._visibilityFeature = newValue} + } + var visitExtensionFields: Int32 { - get {return _storage._visitExtensionFields} + get {_storage._visitExtensionFields} set {_uniqueStorage()._visitExtensionFields = newValue} } var visitExtensionFieldsAsMessageSet: Int32 { - get {return _storage._visitExtensionFieldsAsMessageSet} + get {_storage._visitExtensionFieldsAsMessageSet} set {_uniqueStorage()._visitExtensionFieldsAsMessageSet = newValue} } var visitMapField: Int32 { - get {return _storage._visitMapField} + get {_storage._visitMapField} set {_uniqueStorage()._visitMapField = newValue} } var visitor: Int32 { - get {return _storage._visitor} + get {_storage._visitor} set {_uniqueStorage()._visitor = newValue} } var visitPacked: Int32 { - get {return _storage._visitPacked} + get {_storage._visitPacked} set {_uniqueStorage()._visitPacked = newValue} } var visitPackedBoolField: Int32 { - get {return _storage._visitPackedBoolField} + get {_storage._visitPackedBoolField} set {_uniqueStorage()._visitPackedBoolField = newValue} } var visitPackedDoubleField: Int32 { - get {return _storage._visitPackedDoubleField} + get {_storage._visitPackedDoubleField} set {_uniqueStorage()._visitPackedDoubleField = newValue} } var visitPackedEnumField: Int32 { - get {return _storage._visitPackedEnumField} + get {_storage._visitPackedEnumField} set {_uniqueStorage()._visitPackedEnumField = newValue} } var visitPackedFixed32Field: Int32 { - get {return _storage._visitPackedFixed32Field} + get {_storage._visitPackedFixed32Field} set {_uniqueStorage()._visitPackedFixed32Field = newValue} } var visitPackedFixed64Field: Int32 { - get {return _storage._visitPackedFixed64Field} + get {_storage._visitPackedFixed64Field} set {_uniqueStorage()._visitPackedFixed64Field = newValue} } var visitPackedFloatField: Int32 { - get {return _storage._visitPackedFloatField} + get {_storage._visitPackedFloatField} set {_uniqueStorage()._visitPackedFloatField = newValue} } var visitPackedInt32Field: Int32 { - get {return _storage._visitPackedInt32Field} + get {_storage._visitPackedInt32Field} set {_uniqueStorage()._visitPackedInt32Field = newValue} } var visitPackedInt64Field: Int32 { - get {return _storage._visitPackedInt64Field} + get {_storage._visitPackedInt64Field} set {_uniqueStorage()._visitPackedInt64Field = newValue} } var visitPackedSfixed32Field: Int32 { - get {return _storage._visitPackedSfixed32Field} + get {_storage._visitPackedSfixed32Field} set {_uniqueStorage()._visitPackedSfixed32Field = newValue} } var visitPackedSfixed64Field: Int32 { - get {return _storage._visitPackedSfixed64Field} + get {_storage._visitPackedSfixed64Field} set {_uniqueStorage()._visitPackedSfixed64Field = newValue} } var visitPackedSint32Field: Int32 { - get {return _storage._visitPackedSint32Field} + get {_storage._visitPackedSint32Field} set {_uniqueStorage()._visitPackedSint32Field = newValue} } var visitPackedSint64Field: Int32 { - get {return _storage._visitPackedSint64Field} + get {_storage._visitPackedSint64Field} set {_uniqueStorage()._visitPackedSint64Field = newValue} } var visitPackedUint32Field: Int32 { - get {return _storage._visitPackedUint32Field} + get {_storage._visitPackedUint32Field} set {_uniqueStorage()._visitPackedUint32Field = newValue} } var visitPackedUint64Field: Int32 { - get {return _storage._visitPackedUint64Field} + get {_storage._visitPackedUint64Field} set {_uniqueStorage()._visitPackedUint64Field = newValue} } var visitRepeated: Int32 { - get {return _storage._visitRepeated} + get {_storage._visitRepeated} set {_uniqueStorage()._visitRepeated = newValue} } var visitRepeatedBoolField: Int32 { - get {return _storage._visitRepeatedBoolField} + get {_storage._visitRepeatedBoolField} set {_uniqueStorage()._visitRepeatedBoolField = newValue} } var visitRepeatedBytesField: Int32 { - get {return _storage._visitRepeatedBytesField} + get {_storage._visitRepeatedBytesField} set {_uniqueStorage()._visitRepeatedBytesField = newValue} } var visitRepeatedDoubleField: Int32 { - get {return _storage._visitRepeatedDoubleField} + get {_storage._visitRepeatedDoubleField} set {_uniqueStorage()._visitRepeatedDoubleField = newValue} } var visitRepeatedEnumField: Int32 { - get {return _storage._visitRepeatedEnumField} + get {_storage._visitRepeatedEnumField} set {_uniqueStorage()._visitRepeatedEnumField = newValue} } var visitRepeatedFixed32Field: Int32 { - get {return _storage._visitRepeatedFixed32Field} + get {_storage._visitRepeatedFixed32Field} set {_uniqueStorage()._visitRepeatedFixed32Field = newValue} } var visitRepeatedFixed64Field: Int32 { - get {return _storage._visitRepeatedFixed64Field} + get {_storage._visitRepeatedFixed64Field} set {_uniqueStorage()._visitRepeatedFixed64Field = newValue} } var visitRepeatedFloatField: Int32 { - get {return _storage._visitRepeatedFloatField} + get {_storage._visitRepeatedFloatField} set {_uniqueStorage()._visitRepeatedFloatField = newValue} } var visitRepeatedGroupField: Int32 { - get {return _storage._visitRepeatedGroupField} + get {_storage._visitRepeatedGroupField} set {_uniqueStorage()._visitRepeatedGroupField = newValue} } var visitRepeatedInt32Field: Int32 { - get {return _storage._visitRepeatedInt32Field} + get {_storage._visitRepeatedInt32Field} set {_uniqueStorage()._visitRepeatedInt32Field = newValue} } var visitRepeatedInt64Field: Int32 { - get {return _storage._visitRepeatedInt64Field} + get {_storage._visitRepeatedInt64Field} set {_uniqueStorage()._visitRepeatedInt64Field = newValue} } var visitRepeatedMessageField: Int32 { - get {return _storage._visitRepeatedMessageField} + get {_storage._visitRepeatedMessageField} set {_uniqueStorage()._visitRepeatedMessageField = newValue} } var visitRepeatedSfixed32Field: Int32 { - get {return _storage._visitRepeatedSfixed32Field} + get {_storage._visitRepeatedSfixed32Field} set {_uniqueStorage()._visitRepeatedSfixed32Field = newValue} } var visitRepeatedSfixed64Field: Int32 { - get {return _storage._visitRepeatedSfixed64Field} + get {_storage._visitRepeatedSfixed64Field} set {_uniqueStorage()._visitRepeatedSfixed64Field = newValue} } var visitRepeatedSint32Field: Int32 { - get {return _storage._visitRepeatedSint32Field} + get {_storage._visitRepeatedSint32Field} set {_uniqueStorage()._visitRepeatedSint32Field = newValue} } var visitRepeatedSint64Field: Int32 { - get {return _storage._visitRepeatedSint64Field} + get {_storage._visitRepeatedSint64Field} set {_uniqueStorage()._visitRepeatedSint64Field = newValue} } var visitRepeatedStringField: Int32 { - get {return _storage._visitRepeatedStringField} + get {_storage._visitRepeatedStringField} set {_uniqueStorage()._visitRepeatedStringField = newValue} } var visitRepeatedUint32Field: Int32 { - get {return _storage._visitRepeatedUint32Field} + get {_storage._visitRepeatedUint32Field} set {_uniqueStorage()._visitRepeatedUint32Field = newValue} } var visitRepeatedUint64Field: Int32 { - get {return _storage._visitRepeatedUint64Field} + get {_storage._visitRepeatedUint64Field} set {_uniqueStorage()._visitRepeatedUint64Field = newValue} } var visitSingular: Int32 { - get {return _storage._visitSingular} + get {_storage._visitSingular} set {_uniqueStorage()._visitSingular = newValue} } var visitSingularBoolField: Int32 { - get {return _storage._visitSingularBoolField} + get {_storage._visitSingularBoolField} set {_uniqueStorage()._visitSingularBoolField = newValue} } var visitSingularBytesField: Int32 { - get {return _storage._visitSingularBytesField} + get {_storage._visitSingularBytesField} set {_uniqueStorage()._visitSingularBytesField = newValue} } var visitSingularDoubleField: Int32 { - get {return _storage._visitSingularDoubleField} + get {_storage._visitSingularDoubleField} set {_uniqueStorage()._visitSingularDoubleField = newValue} } var visitSingularEnumField: Int32 { - get {return _storage._visitSingularEnumField} + get {_storage._visitSingularEnumField} set {_uniqueStorage()._visitSingularEnumField = newValue} } var visitSingularFixed32Field: Int32 { - get {return _storage._visitSingularFixed32Field} + get {_storage._visitSingularFixed32Field} set {_uniqueStorage()._visitSingularFixed32Field = newValue} } var visitSingularFixed64Field: Int32 { - get {return _storage._visitSingularFixed64Field} + get {_storage._visitSingularFixed64Field} set {_uniqueStorage()._visitSingularFixed64Field = newValue} } var visitSingularFloatField: Int32 { - get {return _storage._visitSingularFloatField} + get {_storage._visitSingularFloatField} set {_uniqueStorage()._visitSingularFloatField = newValue} } var visitSingularGroupField: Int32 { - get {return _storage._visitSingularGroupField} + get {_storage._visitSingularGroupField} set {_uniqueStorage()._visitSingularGroupField = newValue} } var visitSingularInt32Field: Int32 { - get {return _storage._visitSingularInt32Field} + get {_storage._visitSingularInt32Field} set {_uniqueStorage()._visitSingularInt32Field = newValue} } var visitSingularInt64Field: Int32 { - get {return _storage._visitSingularInt64Field} + get {_storage._visitSingularInt64Field} set {_uniqueStorage()._visitSingularInt64Field = newValue} } var visitSingularMessageField: Int32 { - get {return _storage._visitSingularMessageField} + get {_storage._visitSingularMessageField} set {_uniqueStorage()._visitSingularMessageField = newValue} } var visitSingularSfixed32Field: Int32 { - get {return _storage._visitSingularSfixed32Field} + get {_storage._visitSingularSfixed32Field} set {_uniqueStorage()._visitSingularSfixed32Field = newValue} } var visitSingularSfixed64Field: Int32 { - get {return _storage._visitSingularSfixed64Field} + get {_storage._visitSingularSfixed64Field} set {_uniqueStorage()._visitSingularSfixed64Field = newValue} } var visitSingularSint32Field: Int32 { - get {return _storage._visitSingularSint32Field} + get {_storage._visitSingularSint32Field} set {_uniqueStorage()._visitSingularSint32Field = newValue} } var visitSingularSint64Field: Int32 { - get {return _storage._visitSingularSint64Field} + get {_storage._visitSingularSint64Field} set {_uniqueStorage()._visitSingularSint64Field = newValue} } var visitSingularStringField: Int32 { - get {return _storage._visitSingularStringField} + get {_storage._visitSingularStringField} set {_uniqueStorage()._visitSingularStringField = newValue} } var visitSingularUint32Field: Int32 { - get {return _storage._visitSingularUint32Field} + get {_storage._visitSingularUint32Field} set {_uniqueStorage()._visitSingularUint32Field = newValue} } var visitSingularUint64Field: Int32 { - get {return _storage._visitSingularUint64Field} + get {_storage._visitSingularUint64Field} set {_uniqueStorage()._visitSingularUint64Field = newValue} } var visitUnknown: Int32 { - get {return _storage._visitUnknown} + get {_storage._visitUnknown} set {_uniqueStorage()._visitUnknown = newValue} } + var void: Int32 { + get {_storage._void} + set {_uniqueStorage()._void = newValue} + } + var wasDecoded: Int32 { - get {return _storage._wasDecoded} + get {_storage._wasDecoded} set {_uniqueStorage()._wasDecoded = newValue} } var weak: Int32 { - get {return _storage._weak} + get {_storage._weak} set {_uniqueStorage()._weak = newValue} } var weakDependency: Int32 { - get {return _storage._weakDependency} + get {_storage._weakDependency} set {_uniqueStorage()._weakDependency = newValue} } var `where`: Int32 { - get {return _storage._where} + get {_storage._where} set {_uniqueStorage()._where = newValue} } var wireFormat: Int32 { - get {return _storage._wireFormat} + get {_storage._wireFormat} set {_uniqueStorage()._wireFormat = newValue} } var with: Int32 { - get {return _storage._with} + get {_storage._with} set {_uniqueStorage()._with = newValue} } var withUnsafeBytes: Int32 { - get {return _storage._withUnsafeBytes} + get {_storage._withUnsafeBytes} set {_uniqueStorage()._withUnsafeBytes = newValue} } var withUnsafeMutableBytes: Int32 { - get {return _storage._withUnsafeMutableBytes} + get {_storage._withUnsafeMutableBytes} set {_uniqueStorage()._withUnsafeMutableBytes = newValue} } var work: Int32 { - get {return _storage._work} + get {_storage._work} set {_uniqueStorage()._work = newValue} } + var wrapped: Int32 { + get {_storage._wrapped} + set {_uniqueStorage()._wrapped = newValue} + } + var wrappedType: Int32 { - get {return _storage._wrappedType} + get {_storage._wrappedType} set {_uniqueStorage()._wrappedType = newValue} } + var wrappedValue: Int32 { + get {_storage._wrappedValue} + set {_uniqueStorage()._wrappedValue = newValue} + } + var written: Int32 { - get {return _storage._written} + get {_storage._written} set {_uniqueStorage()._written = newValue} } var yday: Int32 { - get {return _storage._yday} + get {_storage._yday} set {_uniqueStorage()._yday = newValue} } @@ -4381,901 +5171,29 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedFields { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest_generated" +fileprivate let _protobuf_package = "swift_proto_testing.generated" -extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".GeneratedSwiftReservedFields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "adjusted"), - 2: .same(proto: "aggregateValue"), - 3: .same(proto: "allCases"), - 4: .same(proto: "allowAlias"), - 5: .same(proto: "alwaysPrintEnumsAsInts"), - 6: .same(proto: "annotation"), - 7: .same(proto: "any"), - 8: .same(proto: "AnyExtensionField"), - 9: .same(proto: "AnyMessageExtension"), - 10: .same(proto: "AnyMessageStorage"), - 11: .same(proto: "AnyUnpackError"), - 12: .same(proto: "Api"), - 13: .same(proto: "appended"), - 14: .same(proto: "appendUIntHex"), - 15: .same(proto: "appendUnknown"), - 16: .same(proto: "areAllInitialized"), - 17: .same(proto: "array"), - 18: .same(proto: "arrayDepth"), - 19: .same(proto: "arrayLiteral"), - 20: .same(proto: "arraySeparator"), - 21: .same(proto: "as"), - 22: .same(proto: "asciiOpenCurlyBracket"), - 23: .same(proto: "asciiZero"), - 24: .same(proto: "available"), - 25: .same(proto: "b"), - 26: .same(proto: "base64Values"), - 27: .same(proto: "baseAddress"), - 28: .same(proto: "BaseType"), - 29: .same(proto: "begin"), - 30: .same(proto: "binary"), - 31: .same(proto: "BinaryDecoder"), - 32: .same(proto: "BinaryDecodingError"), - 33: .same(proto: "BinaryDecodingOptions"), - 34: .same(proto: "BinaryDelimited"), - 35: .same(proto: "BinaryEncoder"), - 36: .same(proto: "BinaryEncodingError"), - 37: .same(proto: "BinaryEncodingMessageSetSizeVisitor"), - 38: .same(proto: "BinaryEncodingMessageSetVisitor"), - 39: .same(proto: "BinaryEncodingSizeVisitor"), - 40: .same(proto: "BinaryEncodingVisitor"), - 41: .same(proto: "binaryOptions"), - 42: .same(proto: "body"), - 43: .same(proto: "Bool"), - 44: .same(proto: "booleanLiteral"), - 45: .same(proto: "BooleanLiteralType"), - 46: .same(proto: "boolValue"), - 47: .same(proto: "bytes"), - 48: .same(proto: "bytesInGroup"), - 49: .same(proto: "bytesRead"), - 50: .same(proto: "BytesValue"), - 51: .same(proto: "c"), - 52: .same(proto: "capitalizeNext"), - 53: .same(proto: "cardinality"), - 54: .same(proto: "ccEnableArenas"), - 55: .same(proto: "ccGenericServices"), - 56: .same(proto: "Character"), - 57: .same(proto: "chars"), - 58: .same(proto: "class"), - 59: .same(proto: "clearAggregateValue"), - 60: .same(proto: "clearAllowAlias"), - 61: .same(proto: "clearBegin"), - 62: .same(proto: "clearCcEnableArenas"), - 63: .same(proto: "clearCcGenericServices"), - 64: .same(proto: "clearClientStreaming"), - 65: .same(proto: "clearCsharpNamespace"), - 66: .same(proto: "clearCtype"), - 67: .same(proto: "clearDefaultValue"), - 68: .same(proto: "clearDeprecated"), - 69: .same(proto: "clearDoubleValue"), - 70: .same(proto: "clearEnd"), - 71: .same(proto: "clearExtendee"), - 72: .same(proto: "clearExtensionValue"), - 73: .same(proto: "clearGoPackage"), - 74: .same(proto: "clearIdempotencyLevel"), - 75: .same(proto: "clearIdentifierValue"), - 76: .same(proto: "clearInputType"), - 77: .same(proto: "clearIsExtension"), - 78: .same(proto: "clearJavaGenerateEqualsAndHash"), - 79: .same(proto: "clearJavaGenericServices"), - 80: .same(proto: "clearJavaMultipleFiles"), - 81: .same(proto: "clearJavaOuterClassname"), - 82: .same(proto: "clearJavaPackage"), - 83: .same(proto: "clearJavaStringCheckUtf8"), - 84: .same(proto: "clearJsonName"), - 85: .same(proto: "clearJstype"), - 86: .same(proto: "clearLabel"), - 87: .same(proto: "clearLazy"), - 88: .same(proto: "clearLeadingComments"), - 89: .same(proto: "clearMapEntry"), - 90: .same(proto: "clearMessageSetWireFormat"), - 91: .same(proto: "clearName"), - 92: .same(proto: "clearNamePart"), - 93: .same(proto: "clearNegativeIntValue"), - 94: .same(proto: "clearNoStandardDescriptorAccessor"), - 95: .same(proto: "clearNumber"), - 96: .same(proto: "clearObjcClassPrefix"), - 97: .same(proto: "clearOneofIndex"), - 98: .same(proto: "clearOptimizeFor"), - 99: .same(proto: "clearOptions"), - 100: .same(proto: "clearOutputType"), - 101: .same(proto: "clearPackage"), - 102: .same(proto: "clearPacked"), - 103: .same(proto: "clearPhpClassPrefix"), - 104: .same(proto: "clearPhpGenericServices"), - 105: .same(proto: "clearPhpMetadataNamespace"), - 106: .same(proto: "clearPhpNamespace"), - 107: .same(proto: "clearPositiveIntValue"), - 108: .same(proto: "clearProto3Optional"), - 109: .same(proto: "clearPyGenericServices"), - 110: .same(proto: "clearRubyPackage"), - 111: .same(proto: "clearServerStreaming"), - 112: .same(proto: "clearSourceCodeInfo"), - 113: .same(proto: "clearSourceContext"), - 114: .same(proto: "clearSourceFile"), - 115: .same(proto: "clearStart"), - 116: .same(proto: "clearStringValue"), - 117: .same(proto: "clearSwiftPrefix"), - 118: .same(proto: "clearSyntax"), - 119: .same(proto: "clearTrailingComments"), - 120: .same(proto: "clearType"), - 121: .same(proto: "clearTypeName"), - 122: .same(proto: "clearValue"), - 123: .same(proto: "clearWeak"), - 124: .same(proto: "clientStreaming"), - 125: .same(proto: "codePoint"), - 126: .same(proto: "codeUnits"), - 127: .same(proto: "Collection"), - 128: .same(proto: "com"), - 129: .same(proto: "comma"), - 130: .same(proto: "contentsOf"), - 131: .same(proto: "ContiguousBytes"), - 132: .same(proto: "count"), - 133: .same(proto: "countVarintsInBuffer"), - 134: .same(proto: "csharpNamespace"), - 135: .same(proto: "ctype"), - 136: .same(proto: "customCodable"), - 137: .same(proto: "CustomDebugStringConvertible"), - 138: .same(proto: "d"), - 139: .same(proto: "Data"), - 140: .same(proto: "dataResult"), - 141: .same(proto: "date"), - 142: .same(proto: "daySec"), - 143: .same(proto: "daysSinceEpoch"), - 144: .same(proto: "debugDescription"), - 145: .same(proto: "decoded"), - 146: .same(proto: "decodedFromJSONNull"), - 147: .same(proto: "decodeExtensionField"), - 148: .same(proto: "decodeExtensionFieldsAsMessageSet"), - 149: .same(proto: "decodeJSON"), - 150: .same(proto: "decodeMapField"), - 151: .same(proto: "decodeMessage"), - 152: .same(proto: "decoder"), - 153: .same(proto: "decodeRepeated"), - 154: .same(proto: "decodeRepeatedBoolField"), - 155: .same(proto: "decodeRepeatedBytesField"), - 156: .same(proto: "decodeRepeatedDoubleField"), - 157: .same(proto: "decodeRepeatedEnumField"), - 158: .same(proto: "decodeRepeatedFixed32Field"), - 159: .same(proto: "decodeRepeatedFixed64Field"), - 160: .same(proto: "decodeRepeatedFloatField"), - 161: .same(proto: "decodeRepeatedGroupField"), - 162: .same(proto: "decodeRepeatedInt32Field"), - 163: .same(proto: "decodeRepeatedInt64Field"), - 164: .same(proto: "decodeRepeatedMessageField"), - 165: .same(proto: "decodeRepeatedSFixed32Field"), - 166: .same(proto: "decodeRepeatedSFixed64Field"), - 167: .same(proto: "decodeRepeatedSInt32Field"), - 168: .same(proto: "decodeRepeatedSInt64Field"), - 169: .same(proto: "decodeRepeatedStringField"), - 170: .same(proto: "decodeRepeatedUInt32Field"), - 171: .same(proto: "decodeRepeatedUInt64Field"), - 172: .same(proto: "decodeSingular"), - 173: .same(proto: "decodeSingularBoolField"), - 174: .same(proto: "decodeSingularBytesField"), - 175: .same(proto: "decodeSingularDoubleField"), - 176: .same(proto: "decodeSingularEnumField"), - 177: .same(proto: "decodeSingularFixed32Field"), - 178: .same(proto: "decodeSingularFixed64Field"), - 179: .same(proto: "decodeSingularFloatField"), - 180: .same(proto: "decodeSingularGroupField"), - 181: .same(proto: "decodeSingularInt32Field"), - 182: .same(proto: "decodeSingularInt64Field"), - 183: .same(proto: "decodeSingularMessageField"), - 184: .same(proto: "decodeSingularSFixed32Field"), - 185: .same(proto: "decodeSingularSFixed64Field"), - 186: .same(proto: "decodeSingularSInt32Field"), - 187: .same(proto: "decodeSingularSInt64Field"), - 188: .same(proto: "decodeSingularStringField"), - 189: .same(proto: "decodeSingularUInt32Field"), - 190: .same(proto: "decodeSingularUInt64Field"), - 191: .same(proto: "decodeTextFormat"), - 192: .same(proto: "defaultAnyTypeURLPrefix"), - 193: .same(proto: "defaultValue"), - 194: .same(proto: "dependency"), - 195: .same(proto: "deprecated"), - 196: .same(proto: "description"), - 197: .same(proto: "DescriptorProto"), - 198: .same(proto: "Dictionary"), - 199: .same(proto: "dictionaryLiteral"), - 200: .same(proto: "digit"), - 201: .same(proto: "digit0"), - 202: .same(proto: "digit1"), - 203: .same(proto: "digitCount"), - 204: .same(proto: "digits"), - 205: .same(proto: "digitValue"), - 206: .same(proto: "discardableResult"), - 207: .same(proto: "discardUnknownFields"), - 208: .same(proto: "distance"), - 209: .same(proto: "double"), - 210: .same(proto: "doubleValue"), - 211: .same(proto: "Duration"), - 212: .same(proto: "E"), - 213: .same(proto: "Element"), - 214: .same(proto: "elements"), - 215: .same(proto: "emitExtensionFieldName"), - 216: .same(proto: "emitFieldName"), - 217: .same(proto: "emitFieldNumber"), - 218: .same(proto: "Empty"), - 219: .same(proto: "emptyData"), - 220: .same(proto: "encodeAsBytes"), - 221: .same(proto: "encoded"), - 222: .same(proto: "encodedJSONString"), - 223: .same(proto: "encodedSize"), - 224: .same(proto: "encodeField"), - 225: .same(proto: "encoder"), - 226: .same(proto: "end"), - 227: .same(proto: "endArray"), - 228: .same(proto: "endMessageField"), - 229: .same(proto: "endObject"), - 230: .same(proto: "endRegularField"), - 231: .same(proto: "enum"), - 232: .same(proto: "EnumDescriptorProto"), - 233: .same(proto: "EnumOptions"), - 234: .same(proto: "EnumReservedRange"), - 235: .same(proto: "enumType"), - 236: .same(proto: "enumvalue"), - 237: .same(proto: "EnumValueDescriptorProto"), - 238: .same(proto: "EnumValueOptions"), - 239: .same(proto: "Equatable"), - 240: .same(proto: "Error"), - 241: .same(proto: "ExpressibleByArrayLiteral"), - 242: .same(proto: "ExpressibleByDictionaryLiteral"), - 243: .same(proto: "ext"), - 244: .same(proto: "extDecoder"), - 245: .same(proto: "extendedGraphemeClusterLiteral"), - 246: .same(proto: "ExtendedGraphemeClusterLiteralType"), - 247: .same(proto: "extendee"), - 248: .same(proto: "ExtensibleMessage"), - 249: .same(proto: "extension"), - 250: .same(proto: "ExtensionField"), - 251: .same(proto: "extensionFieldNumber"), - 252: .same(proto: "ExtensionFieldValueSet"), - 253: .same(proto: "ExtensionMap"), - 254: .same(proto: "extensionRange"), - 255: .same(proto: "ExtensionRangeOptions"), - 256: .same(proto: "extensions"), - 257: .same(proto: "extras"), - 258: .same(proto: "F"), - 259: .same(proto: "false"), - 260: .same(proto: "field"), - 261: .same(proto: "fieldData"), - 262: .same(proto: "FieldDescriptorProto"), - 263: .same(proto: "FieldMask"), - 264: .same(proto: "fieldName"), - 265: .same(proto: "fieldNameCount"), - 266: .same(proto: "fieldNum"), - 267: .same(proto: "fieldNumber"), - 268: .same(proto: "fieldNumberForProto"), - 269: .same(proto: "FieldOptions"), - 270: .same(proto: "fields"), - 271: .same(proto: "fieldSize"), - 272: .same(proto: "FieldTag"), - 273: .same(proto: "fieldType"), - 274: .same(proto: "file"), - 275: .same(proto: "FileDescriptorProto"), - 276: .same(proto: "FileDescriptorSet"), - 277: .same(proto: "fileName"), - 278: .same(proto: "FileOptions"), - 279: .same(proto: "filter"), - 280: .same(proto: "first"), - 281: .same(proto: "firstItem"), - 282: .same(proto: "float"), - 283: .same(proto: "floatLiteral"), - 284: .same(proto: "FloatLiteralType"), - 285: .same(proto: "FloatValue"), - 286: .same(proto: "forMessageName"), - 287: .same(proto: "formUnion"), - 288: .same(proto: "forReadingFrom"), - 289: .same(proto: "forTypeURL"), - 290: .same(proto: "ForwardParser"), - 291: .same(proto: "forWritingInto"), - 292: .same(proto: "from"), - 293: .same(proto: "fromAscii2"), - 294: .same(proto: "fromAscii4"), - 295: .same(proto: "fromByteOffset"), - 296: .same(proto: "fromHexDigit"), - 297: .same(proto: "func"), - 298: .same(proto: "G"), - 299: .same(proto: "GeneratedCodeInfo"), - 300: .same(proto: "get"), - 301: .same(proto: "getExtensionValue"), - 302: .same(proto: "googleapis"), - 303: .standard(proto: "Google_Protobuf_Any"), - 304: .standard(proto: "Google_Protobuf_Api"), - 305: .standard(proto: "Google_Protobuf_BoolValue"), - 306: .standard(proto: "Google_Protobuf_BytesValue"), - 307: .standard(proto: "Google_Protobuf_DescriptorProto"), - 308: .standard(proto: "Google_Protobuf_DoubleValue"), - 309: .standard(proto: "Google_Protobuf_Duration"), - 310: .standard(proto: "Google_Protobuf_Empty"), - 311: .standard(proto: "Google_Protobuf_Enum"), - 312: .standard(proto: "Google_Protobuf_EnumDescriptorProto"), - 313: .standard(proto: "Google_Protobuf_EnumOptions"), - 314: .standard(proto: "Google_Protobuf_EnumValue"), - 315: .standard(proto: "Google_Protobuf_EnumValueDescriptorProto"), - 316: .standard(proto: "Google_Protobuf_EnumValueOptions"), - 317: .standard(proto: "Google_Protobuf_ExtensionRangeOptions"), - 318: .standard(proto: "Google_Protobuf_Field"), - 319: .standard(proto: "Google_Protobuf_FieldDescriptorProto"), - 320: .standard(proto: "Google_Protobuf_FieldMask"), - 321: .standard(proto: "Google_Protobuf_FieldOptions"), - 322: .standard(proto: "Google_Protobuf_FileDescriptorProto"), - 323: .standard(proto: "Google_Protobuf_FileDescriptorSet"), - 324: .standard(proto: "Google_Protobuf_FileOptions"), - 325: .standard(proto: "Google_Protobuf_FloatValue"), - 326: .standard(proto: "Google_Protobuf_GeneratedCodeInfo"), - 327: .standard(proto: "Google_Protobuf_Int32Value"), - 328: .standard(proto: "Google_Protobuf_Int64Value"), - 329: .standard(proto: "Google_Protobuf_ListValue"), - 330: .standard(proto: "Google_Protobuf_MessageOptions"), - 331: .standard(proto: "Google_Protobuf_Method"), - 332: .standard(proto: "Google_Protobuf_MethodDescriptorProto"), - 333: .standard(proto: "Google_Protobuf_MethodOptions"), - 334: .standard(proto: "Google_Protobuf_Mixin"), - 335: .standard(proto: "Google_Protobuf_NullValue"), - 336: .standard(proto: "Google_Protobuf_OneofDescriptorProto"), - 337: .standard(proto: "Google_Protobuf_OneofOptions"), - 338: .standard(proto: "Google_Protobuf_Option"), - 339: .standard(proto: "Google_Protobuf_ServiceDescriptorProto"), - 340: .standard(proto: "Google_Protobuf_ServiceOptions"), - 341: .standard(proto: "Google_Protobuf_SourceCodeInfo"), - 342: .standard(proto: "Google_Protobuf_SourceContext"), - 343: .standard(proto: "Google_Protobuf_StringValue"), - 344: .standard(proto: "Google_Protobuf_Struct"), - 345: .standard(proto: "Google_Protobuf_Syntax"), - 346: .standard(proto: "Google_Protobuf_Timestamp"), - 347: .standard(proto: "Google_Protobuf_Type"), - 348: .standard(proto: "Google_Protobuf_UInt32Value"), - 349: .standard(proto: "Google_Protobuf_UInt64Value"), - 350: .standard(proto: "Google_Protobuf_UninterpretedOption"), - 351: .standard(proto: "Google_Protobuf_Value"), - 352: .same(proto: "goPackage"), - 353: .same(proto: "group"), - 354: .same(proto: "groupFieldNumberStack"), - 355: .same(proto: "groupSize"), - 356: .same(proto: "h"), - 357: .same(proto: "hadOneofValue"), - 358: .same(proto: "handleConflictingOneOf"), - 359: .same(proto: "hasAggregateValue"), - 360: .same(proto: "hasAllowAlias"), - 361: .same(proto: "hasBegin"), - 362: .same(proto: "hasCcEnableArenas"), - 363: .same(proto: "hasCcGenericServices"), - 364: .same(proto: "hasClientStreaming"), - 365: .same(proto: "hasCsharpNamespace"), - 366: .same(proto: "hasCtype"), - 367: .same(proto: "hasDefaultValue"), - 368: .same(proto: "hasDeprecated"), - 369: .same(proto: "hasDoubleValue"), - 370: .same(proto: "hasEnd"), - 371: .same(proto: "hasExtendee"), - 372: .same(proto: "hasExtensionValue"), - 373: .same(proto: "hasGoPackage"), - 374: .same(proto: "hash"), - 375: .same(proto: "Hashable"), - 376: .same(proto: "hasher"), - 377: .same(proto: "hashValue"), - 378: .same(proto: "HashVisitor"), - 379: .same(proto: "hasIdempotencyLevel"), - 380: .same(proto: "hasIdentifierValue"), - 381: .same(proto: "hasInputType"), - 382: .same(proto: "hasIsExtension"), - 383: .same(proto: "hasJavaGenerateEqualsAndHash"), - 384: .same(proto: "hasJavaGenericServices"), - 385: .same(proto: "hasJavaMultipleFiles"), - 386: .same(proto: "hasJavaOuterClassname"), - 387: .same(proto: "hasJavaPackage"), - 388: .same(proto: "hasJavaStringCheckUtf8"), - 389: .same(proto: "hasJsonName"), - 390: .same(proto: "hasJstype"), - 391: .same(proto: "hasLabel"), - 392: .same(proto: "hasLazy"), - 393: .same(proto: "hasLeadingComments"), - 394: .same(proto: "hasMapEntry"), - 395: .same(proto: "hasMessageSetWireFormat"), - 396: .same(proto: "hasName"), - 397: .same(proto: "hasNamePart"), - 398: .same(proto: "hasNegativeIntValue"), - 399: .same(proto: "hasNoStandardDescriptorAccessor"), - 400: .same(proto: "hasNumber"), - 401: .same(proto: "hasObjcClassPrefix"), - 402: .same(proto: "hasOneofIndex"), - 403: .same(proto: "hasOptimizeFor"), - 404: .same(proto: "hasOptions"), - 405: .same(proto: "hasOutputType"), - 406: .same(proto: "hasPackage"), - 407: .same(proto: "hasPacked"), - 408: .same(proto: "hasPhpClassPrefix"), - 409: .same(proto: "hasPhpGenericServices"), - 410: .same(proto: "hasPhpMetadataNamespace"), - 411: .same(proto: "hasPhpNamespace"), - 412: .same(proto: "hasPositiveIntValue"), - 413: .same(proto: "hasProto3Optional"), - 414: .same(proto: "hasPyGenericServices"), - 415: .same(proto: "hasRubyPackage"), - 416: .same(proto: "hasServerStreaming"), - 417: .same(proto: "hasSourceCodeInfo"), - 418: .same(proto: "hasSourceContext"), - 419: .same(proto: "hasSourceFile"), - 420: .same(proto: "hasStart"), - 421: .same(proto: "hasStringValue"), - 422: .same(proto: "hasSwiftPrefix"), - 423: .same(proto: "hasSyntax"), - 424: .same(proto: "hasTrailingComments"), - 425: .same(proto: "hasType"), - 426: .same(proto: "hasTypeName"), - 427: .same(proto: "hasValue"), - 428: .same(proto: "hasWeak"), - 429: .same(proto: "hour"), - 430: .same(proto: "i"), - 431: .same(proto: "idempotencyLevel"), - 432: .same(proto: "identifierValue"), - 433: .same(proto: "if"), - 434: .same(proto: "ignoreUnknownFields"), - 435: .same(proto: "index"), - 436: .same(proto: "init"), - 437: .same(proto: "inout"), - 438: .same(proto: "inputType"), - 439: .same(proto: "insert"), - 440: .same(proto: "Int"), - 441: .same(proto: "Int32"), - 442: .same(proto: "Int32Value"), - 443: .same(proto: "Int64"), - 444: .same(proto: "Int64Value"), - 445: .same(proto: "Int8"), - 446: .same(proto: "integerLiteral"), - 447: .same(proto: "IntegerLiteralType"), - 448: .same(proto: "intern"), - 449: .same(proto: "Internal"), - 450: .same(proto: "InternalState"), - 451: .same(proto: "into"), - 452: .same(proto: "ints"), - 453: .same(proto: "isA"), - 454: .same(proto: "isEqual"), - 455: .same(proto: "isEqualTo"), - 456: .same(proto: "isExtension"), - 457: .same(proto: "isInitialized"), - 458: .same(proto: "itemTagsEncodedSize"), - 459: .same(proto: "Iterator"), - 460: .standard(proto: "i_2166136261"), - 461: .same(proto: "javaGenerateEqualsAndHash"), - 462: .same(proto: "javaGenericServices"), - 463: .same(proto: "javaMultipleFiles"), - 464: .same(proto: "javaOuterClassname"), - 465: .same(proto: "javaPackage"), - 466: .same(proto: "javaStringCheckUtf8"), - 467: .same(proto: "JSONDecoder"), - 468: .same(proto: "JSONDecodingError"), - 469: .same(proto: "JSONDecodingOptions"), - 470: .same(proto: "jsonEncoder"), - 471: .same(proto: "JSONEncodingError"), - 472: .same(proto: "JSONEncodingOptions"), - 473: .same(proto: "JSONEncodingVisitor"), - 474: .same(proto: "JSONMapEncodingVisitor"), - 475: .same(proto: "jsonName"), - 476: .same(proto: "jsonPath"), - 477: .same(proto: "jsonPaths"), - 478: .same(proto: "JSONScanner"), - 479: .same(proto: "jsonString"), - 480: .same(proto: "jsonText"), - 481: .same(proto: "jsonUTF8Data"), - 482: .same(proto: "jstype"), - 483: .same(proto: "k"), - 484: .same(proto: "Key"), - 485: .same(proto: "keyField"), - 486: .same(proto: "KeyType"), - 487: .same(proto: "kind"), - 488: .same(proto: "l"), - 489: .same(proto: "label"), - 490: .same(proto: "lazy"), - 491: .same(proto: "leadingComments"), - 492: .same(proto: "leadingDetachedComments"), - 493: .same(proto: "length"), - 494: .same(proto: "lessThan"), - 495: .same(proto: "let"), - 496: .same(proto: "lhs"), - 497: .same(proto: "list"), - 498: .same(proto: "listOfMessages"), - 499: .same(proto: "listValue"), - 500: .same(proto: "littleEndian"), - 501: .same(proto: "littleEndianBytes"), - 502: .same(proto: "load"), - 503: .same(proto: "localHasher"), - 504: .same(proto: "location"), - 505: .same(proto: "M"), - 506: .same(proto: "major"), - 507: .same(proto: "makeIterator"), - 508: .same(proto: "mapEntry"), - 509: .same(proto: "mapHash"), - 510: .same(proto: "MapKeyType"), - 511: .same(proto: "mapNameResolver"), - 512: .same(proto: "mapToMessages"), - 513: .same(proto: "MapValueType"), - 514: .same(proto: "mapVisitor"), - 515: .same(proto: "mdayStart"), - 516: .same(proto: "merge"), - 517: .same(proto: "message"), - 518: .same(proto: "messageDepthLimit"), - 519: .same(proto: "MessageExtension"), - 520: .same(proto: "MessageImplementationBase"), - 521: .same(proto: "MessageOptions"), - 522: .same(proto: "MessageSet"), - 523: .same(proto: "messageSetWireFormat"), - 524: .same(proto: "messageType"), - 525: .same(proto: "Method"), - 526: .same(proto: "MethodDescriptorProto"), - 527: .same(proto: "MethodOptions"), - 528: .same(proto: "methods"), - 529: .same(proto: "minor"), - 530: .same(proto: "Mixin"), - 531: .same(proto: "mixins"), - 532: .same(proto: "modifier"), - 533: .same(proto: "modify"), - 534: .same(proto: "month"), - 535: .same(proto: "msgExtension"), - 536: .same(proto: "mutating"), - 537: .same(proto: "n"), - 538: .same(proto: "name"), - 539: .same(proto: "NameDescription"), - 540: .same(proto: "NameMap"), - 541: .same(proto: "NamePart"), - 542: .same(proto: "nameResolver"), - 543: .same(proto: "names"), - 544: .same(proto: "nanos"), - 545: .same(proto: "nativeBytes"), - 546: .same(proto: "nativeEndianBytes"), - 547: .same(proto: "negativeIntValue"), - 548: .same(proto: "nestedType"), - 549: .same(proto: "newL"), - 550: .same(proto: "newList"), - 551: .same(proto: "newValue"), - 552: .same(proto: "nextByte"), - 553: .same(proto: "nextFieldNumber"), - 554: .same(proto: "nil"), - 555: .same(proto: "nilLiteral"), - 556: .same(proto: "noStandardDescriptorAccessor"), - 557: .same(proto: "nullValue"), - 558: .same(proto: "number"), - 559: .same(proto: "numberValue"), - 560: .same(proto: "objcClassPrefix"), - 561: .same(proto: "of"), - 562: .same(proto: "oneofDecl"), - 563: .same(proto: "OneofDescriptorProto"), - 564: .same(proto: "oneofIndex"), - 565: .same(proto: "OneofOptions"), - 566: .same(proto: "oneofs"), - 567: .standard(proto: "OneOf_Kind"), - 568: .same(proto: "optimizeFor"), - 569: .same(proto: "OptimizeMode"), - 570: .same(proto: "Option"), - 571: .same(proto: "OptionalEnumExtensionField"), - 572: .same(proto: "OptionalExtensionField"), - 573: .same(proto: "OptionalGroupExtensionField"), - 574: .same(proto: "OptionalMessageExtensionField"), - 575: .same(proto: "options"), - 576: .same(proto: "other"), - 577: .same(proto: "others"), - 578: .same(proto: "out"), - 579: .same(proto: "outputType"), - 580: .same(proto: "p"), - 581: .same(proto: "package"), - 582: .same(proto: "packed"), - 583: .same(proto: "PackedEnumExtensionField"), - 584: .same(proto: "PackedExtensionField"), - 585: .same(proto: "padding"), - 586: .same(proto: "parent"), - 587: .same(proto: "parse"), - 588: .same(proto: "partial"), - 589: .same(proto: "path"), - 590: .same(proto: "paths"), - 591: .same(proto: "payload"), - 592: .same(proto: "payloadSize"), - 593: .same(proto: "phpClassPrefix"), - 594: .same(proto: "phpGenericServices"), - 595: .same(proto: "phpMetadataNamespace"), - 596: .same(proto: "phpNamespace"), - 597: .same(proto: "pointer"), - 598: .same(proto: "pos"), - 599: .same(proto: "positiveIntValue"), - 600: .same(proto: "prefix"), - 601: .same(proto: "preserveProtoFieldNames"), - 602: .same(proto: "preTraverse"), - 603: .same(proto: "printUnknownFields"), - 604: .same(proto: "proto2"), - 605: .same(proto: "proto3DefaultValue"), - 606: .same(proto: "proto3Optional"), - 607: .same(proto: "ProtobufAPIVersionCheck"), - 608: .standard(proto: "ProtobufAPIVersion_2"), - 609: .same(proto: "ProtobufBool"), - 610: .same(proto: "ProtobufBytes"), - 611: .same(proto: "ProtobufDouble"), - 612: .same(proto: "ProtobufEnumMap"), - 613: .same(proto: "protobufExtension"), - 614: .same(proto: "ProtobufFixed32"), - 615: .same(proto: "ProtobufFixed64"), - 616: .same(proto: "ProtobufFloat"), - 617: .same(proto: "ProtobufInt32"), - 618: .same(proto: "ProtobufInt64"), - 619: .same(proto: "ProtobufMap"), - 620: .same(proto: "ProtobufMessageMap"), - 621: .same(proto: "ProtobufSFixed32"), - 622: .same(proto: "ProtobufSFixed64"), - 623: .same(proto: "ProtobufSInt32"), - 624: .same(proto: "ProtobufSInt64"), - 625: .same(proto: "ProtobufString"), - 626: .same(proto: "ProtobufUInt32"), - 627: .same(proto: "ProtobufUInt64"), - 628: .standard(proto: "protobuf_extensionFieldValues"), - 629: .standard(proto: "protobuf_fieldNumber"), - 630: .standard(proto: "protobuf_generated_isEqualTo"), - 631: .standard(proto: "protobuf_nameMap"), - 632: .standard(proto: "protobuf_newField"), - 633: .standard(proto: "protobuf_package"), - 634: .same(proto: "protocol"), - 635: .same(proto: "protoFieldName"), - 636: .same(proto: "protoMessageName"), - 637: .same(proto: "ProtoNameProviding"), - 638: .same(proto: "protoPaths"), - 639: .same(proto: "public"), - 640: .same(proto: "publicDependency"), - 641: .same(proto: "putBoolValue"), - 642: .same(proto: "putBytesValue"), - 643: .same(proto: "putDoubleValue"), - 644: .same(proto: "putEnumValue"), - 645: .same(proto: "putFixedUInt32"), - 646: .same(proto: "putFixedUInt64"), - 647: .same(proto: "putFloatValue"), - 648: .same(proto: "putInt64"), - 649: .same(proto: "putStringValue"), - 650: .same(proto: "putUInt64"), - 651: .same(proto: "putUInt64Hex"), - 652: .same(proto: "putVarInt"), - 653: .same(proto: "putZigZagVarInt"), - 654: .same(proto: "pyGenericServices"), - 655: .same(proto: "rawChars"), - 656: .same(proto: "RawRepresentable"), - 657: .same(proto: "RawValue"), - 658: .same(proto: "read4HexDigits"), - 659: .same(proto: "register"), - 660: .same(proto: "RepeatedEnumExtensionField"), - 661: .same(proto: "RepeatedExtensionField"), - 662: .same(proto: "RepeatedGroupExtensionField"), - 663: .same(proto: "RepeatedMessageExtensionField"), - 664: .same(proto: "requestStreaming"), - 665: .same(proto: "requestTypeURL"), - 666: .same(proto: "requiredSize"), - 667: .same(proto: "reservedName"), - 668: .same(proto: "reservedRange"), - 669: .same(proto: "responseStreaming"), - 670: .same(proto: "responseTypeURL"), - 671: .same(proto: "result"), - 672: .same(proto: "rethrows"), - 673: .same(proto: "return"), - 674: .same(proto: "ReturnType"), - 675: .same(proto: "revision"), - 676: .same(proto: "rhs"), - 677: .same(proto: "root"), - 678: .same(proto: "rubyPackage"), - 679: .same(proto: "s"), - 680: .same(proto: "sawBackslash"), - 681: .same(proto: "sawSection4Characters"), - 682: .same(proto: "sawSection5Characters"), - 683: .same(proto: "scanner"), - 684: .same(proto: "seconds"), - 685: .same(proto: "self"), - 686: .same(proto: "separator"), - 687: .same(proto: "serialize"), - 688: .same(proto: "serializedData"), - 689: .same(proto: "serializedSize"), - 690: .same(proto: "serverStreaming"), - 691: .same(proto: "service"), - 692: .same(proto: "ServiceDescriptorProto"), - 693: .same(proto: "ServiceOptions"), - 694: .same(proto: "set"), - 695: .same(proto: "setExtensionValue"), - 696: .same(proto: "shift"), - 697: .same(proto: "SimpleExtensionMap"), - 698: .same(proto: "sizer"), - 699: .same(proto: "source"), - 700: .same(proto: "sourceCodeInfo"), - 701: .same(proto: "sourceContext"), - 702: .same(proto: "sourceEncoding"), - 703: .same(proto: "sourceFile"), - 704: .same(proto: "span"), - 705: .same(proto: "split"), - 706: .same(proto: "start"), - 707: .same(proto: "startArray"), - 708: .same(proto: "startArrayObject"), - 709: .same(proto: "startField"), - 710: .same(proto: "startIndex"), - 711: .same(proto: "startMessageField"), - 712: .same(proto: "startObject"), - 713: .same(proto: "startRegularField"), - 714: .same(proto: "state"), - 715: .same(proto: "static"), - 716: .same(proto: "StaticString"), - 717: .same(proto: "storage"), - 718: .same(proto: "String"), - 719: .same(proto: "stringLiteral"), - 720: .same(proto: "StringLiteralType"), - 721: .same(proto: "stringResult"), - 722: .same(proto: "stringValue"), - 723: .same(proto: "struct"), - 724: .same(proto: "structValue"), - 725: .same(proto: "subDecoder"), - 726: .same(proto: "subscript"), - 727: .same(proto: "subVisitor"), - 728: .same(proto: "Swift"), - 729: .same(proto: "swiftPrefix"), - 730: .same(proto: "SwiftProtobuf"), - 731: .same(proto: "syntax"), - 732: .same(proto: "T"), - 733: .same(proto: "tag"), - 734: .same(proto: "terminator"), - 735: .same(proto: "testDecoder"), - 736: .same(proto: "text"), - 737: .same(proto: "textDecoder"), - 738: .same(proto: "TextFormatDecoder"), - 739: .same(proto: "TextFormatDecodingError"), - 740: .same(proto: "TextFormatDecodingOptions"), - 741: .same(proto: "TextFormatEncodingOptions"), - 742: .same(proto: "TextFormatEncodingVisitor"), - 743: .same(proto: "textFormatString"), - 744: .same(proto: "throws"), - 745: .same(proto: "timeInterval"), - 746: .same(proto: "timeIntervalSince1970"), - 747: .same(proto: "timeIntervalSinceReferenceDate"), - 748: .same(proto: "Timestamp"), - 749: .same(proto: "total"), - 750: .same(proto: "totalArrayDepth"), - 751: .same(proto: "totalSize"), - 752: .same(proto: "trailingComments"), - 753: .same(proto: "traverse"), - 754: .same(proto: "true"), - 755: .same(proto: "try"), - 756: .same(proto: "type"), - 757: .same(proto: "typealias"), - 758: .same(proto: "TypeEnum"), - 759: .same(proto: "typeName"), - 760: .same(proto: "typePrefix"), - 761: .same(proto: "typeStart"), - 762: .same(proto: "typeUnknown"), - 763: .same(proto: "typeURL"), - 764: .same(proto: "UInt32"), - 765: .same(proto: "UInt32Value"), - 766: .same(proto: "UInt64"), - 767: .same(proto: "UInt64Value"), - 768: .same(proto: "UInt8"), - 769: .same(proto: "unicodeScalarLiteral"), - 770: .same(proto: "UnicodeScalarLiteralType"), - 771: .same(proto: "unicodeScalars"), - 772: .same(proto: "UnicodeScalarView"), - 773: .same(proto: "uninterpretedOption"), - 774: .same(proto: "union"), - 775: .same(proto: "uniqueStorage"), - 776: .same(proto: "unknown"), - 777: .same(proto: "unknownFields"), - 778: .same(proto: "UnknownStorage"), - 779: .same(proto: "unpackTo"), - 780: .same(proto: "UnsafeBufferPointer"), - 781: .same(proto: "UnsafeMutablePointer"), - 782: .same(proto: "UnsafeMutableRawBufferPointer"), - 783: .same(proto: "UnsafeMutableRawPointer"), - 784: .same(proto: "UnsafeRawBufferPointer"), - 785: .same(proto: "UnsafeRawPointer"), - 786: .same(proto: "updatedOptions"), - 787: .same(proto: "url"), - 788: .same(proto: "utf8"), - 789: .same(proto: "utf8Ptr"), - 790: .same(proto: "utf8ToDouble"), - 791: .same(proto: "UTF8View"), - 792: .same(proto: "v"), - 793: .same(proto: "value"), - 794: .same(proto: "valueField"), - 795: .same(proto: "values"), - 796: .same(proto: "ValueType"), - 797: .same(proto: "var"), - 798: .same(proto: "Version"), - 799: .same(proto: "versionString"), - 800: .same(proto: "visitExtensionFields"), - 801: .same(proto: "visitExtensionFieldsAsMessageSet"), - 802: .same(proto: "visitMapField"), - 803: .same(proto: "visitor"), - 804: .same(proto: "visitPacked"), - 805: .same(proto: "visitPackedBoolField"), - 806: .same(proto: "visitPackedDoubleField"), - 807: .same(proto: "visitPackedEnumField"), - 808: .same(proto: "visitPackedFixed32Field"), - 809: .same(proto: "visitPackedFixed64Field"), - 810: .same(proto: "visitPackedFloatField"), - 811: .same(proto: "visitPackedInt32Field"), - 812: .same(proto: "visitPackedInt64Field"), - 813: .same(proto: "visitPackedSFixed32Field"), - 814: .same(proto: "visitPackedSFixed64Field"), - 815: .same(proto: "visitPackedSInt32Field"), - 816: .same(proto: "visitPackedSInt64Field"), - 817: .same(proto: "visitPackedUInt32Field"), - 818: .same(proto: "visitPackedUInt64Field"), - 819: .same(proto: "visitRepeated"), - 820: .same(proto: "visitRepeatedBoolField"), - 821: .same(proto: "visitRepeatedBytesField"), - 822: .same(proto: "visitRepeatedDoubleField"), - 823: .same(proto: "visitRepeatedEnumField"), - 824: .same(proto: "visitRepeatedFixed32Field"), - 825: .same(proto: "visitRepeatedFixed64Field"), - 826: .same(proto: "visitRepeatedFloatField"), - 827: .same(proto: "visitRepeatedGroupField"), - 828: .same(proto: "visitRepeatedInt32Field"), - 829: .same(proto: "visitRepeatedInt64Field"), - 830: .same(proto: "visitRepeatedMessageField"), - 831: .same(proto: "visitRepeatedSFixed32Field"), - 832: .same(proto: "visitRepeatedSFixed64Field"), - 833: .same(proto: "visitRepeatedSInt32Field"), - 834: .same(proto: "visitRepeatedSInt64Field"), - 835: .same(proto: "visitRepeatedStringField"), - 836: .same(proto: "visitRepeatedUInt32Field"), - 837: .same(proto: "visitRepeatedUInt64Field"), - 838: .same(proto: "visitSingular"), - 839: .same(proto: "visitSingularBoolField"), - 840: .same(proto: "visitSingularBytesField"), - 841: .same(proto: "visitSingularDoubleField"), - 842: .same(proto: "visitSingularEnumField"), - 843: .same(proto: "visitSingularFixed32Field"), - 844: .same(proto: "visitSingularFixed64Field"), - 845: .same(proto: "visitSingularFloatField"), - 846: .same(proto: "visitSingularGroupField"), - 847: .same(proto: "visitSingularInt32Field"), - 848: .same(proto: "visitSingularInt64Field"), - 849: .same(proto: "visitSingularMessageField"), - 850: .same(proto: "visitSingularSFixed32Field"), - 851: .same(proto: "visitSingularSFixed64Field"), - 852: .same(proto: "visitSingularSInt32Field"), - 853: .same(proto: "visitSingularSInt64Field"), - 854: .same(proto: "visitSingularStringField"), - 855: .same(proto: "visitSingularUInt32Field"), - 856: .same(proto: "visitSingularUInt64Field"), - 857: .same(proto: "visitUnknown"), - 858: .same(proto: "wasDecoded"), - 859: .same(proto: "weak"), - 860: .same(proto: "weakDependency"), - 861: .same(proto: "where"), - 862: .same(proto: "wireFormat"), - 863: .same(proto: "with"), - 864: .same(proto: "withUnsafeBytes"), - 865: .same(proto: "withUnsafeMutableBytes"), - 866: .same(proto: "work"), - 867: .same(proto: "WrappedType"), - 868: .same(proto: "written"), - 869: .same(proto: "yday"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}addPath\0\u{1}adjusted\0\u{1}aggregateValue\0\u{1}allCases\0\u{1}allowAlias\0\u{1}alwaysPrintEnumsAsInts\0\u{1}alwaysPrintInt64sAsNumbers\0\u{1}annotation\0\u{1}any\0\u{1}AnyExtensionField\0\u{1}AnyMessageExtension\0\u{1}AnyMessageStorage\0\u{1}AnyUnpackError\0\u{1}append\0\u{1}appended\0\u{1}appendUIntHex\0\u{1}appendUnknown\0\u{1}areAllInitialized\0\u{1}Array\0\u{1}arrayDepth\0\u{1}arrayLiteral\0\u{1}arraySeparator\0\u{1}as\0\u{1}asciiOpenCurlyBracket\0\u{1}asciiZero\0\u{1}async\0\u{1}AsyncIterator\0\u{1}AsyncIteratorProtocol\0\u{1}AsyncMessageSequence\0\u{1}available\0\u{1}b\0\u{1}Base\0\u{1}base64Values\0\u{1}baseAddress\0\u{1}BaseType\0\u{1}begin\0\u{1}binary\0\u{1}BinaryDecoder\0\u{1}BinaryDecoding\0\u{1}BinaryDecodingError\0\u{1}BinaryDecodingOptions\0\u{1}BinaryDelimited\0\u{1}BinaryEncoder\0\u{1}BinaryEncodingError\0\u{1}BinaryEncodingMessageSetSizeVisitor\0\u{1}BinaryEncodingMessageSetVisitor\0\u{1}BinaryEncodingOptions\0\u{1}BinaryEncodingSizeVisitor\0\u{1}BinaryEncodingVisitor\0\u{1}binaryOptions\0\u{1}binaryProtobufDelimitedMessages\0\u{1}BinaryStreamDecoding\0\u{1}binaryStreamDecodingError\0\u{1}bitPattern\0\u{1}body\0\u{1}Bool\0\u{1}booleanLiteral\0\u{1}BooleanLiteralType\0\u{1}boolValue\0\u{1}buffer\0\u{1}byte\0\u{1}bytecode\0\u{1}BytecodeReader\0\u{1}bytes\0\u{1}bytesInGroup\0\u{1}bytesNeeded\0\u{1}bytesRead\0\u{1}c\0\u{1}canonical\0\u{1}capitalizeNext\0\u{1}cardinality\0\u{1}CaseIterable\0\u{1}castedValue\0\u{1}ccEnableArenas\0\u{1}ccGenericServices\0\u{1}Character\0\u{1}chars\0\u{1}checkProgramFormat\0\u{1}chunk\0\u{1}class\0\u{1}clearAggregateValue\0\u{1}clearAllowAlias\0\u{1}clearBegin\0\u{1}clearCcEnableArenas\0\u{1}clearCcGenericServices\0\u{1}clearClientStreaming\0\u{1}clearCsharpNamespace\0\u{1}clearCtype\0\u{1}clearDebugRedact\0\u{1}clearDefaultSymbolVisibility\0\u{1}clearDefaultValue\0\u{1}clearDeprecated\0\u{1}clearDeprecatedLegacyJsonFieldConflicts\0\u{1}clearDeprecationWarning\0\u{1}clearDoubleValue\0\u{1}clearEdition\0\u{1}clearEditionDeprecated\0\u{1}clearEditionIntroduced\0\u{1}clearEditionRemoved\0\u{1}clearEnd\0\u{1}clearEnforceNamingStyle\0\u{1}clearEnumType\0\u{1}clearExtendee\0\u{1}clearExtensionValue\0\u{1}clearFeatures\0\u{1}clearFeatureSupport\0\u{1}clearFieldPresence\0\u{1}clearFixedFeatures\0\u{1}clearFullName\0\u{1}clearGoPackage\0\u{1}clearIdempotencyLevel\0\u{1}clearIdentifierValue\0\u{1}clearInputType\0\u{1}clearIsExtension\0\u{1}clearJavaGenerateEqualsAndHash\0\u{1}clearJavaGenericServices\0\u{1}clearJavaMultipleFiles\0\u{1}clearJavaOuterClassname\0\u{1}clearJavaPackage\0\u{1}clearJavaStringCheckUtf8\0\u{1}clearJsonFormat\0\u{1}clearJsonName\0\u{1}clearJstype\0\u{1}clearLabel\0\u{1}clearLazy\0\u{1}clearLeadingComments\0\u{1}clearMapEntry\0\u{1}clearMaximumEdition\0\u{1}clearMessageEncoding\0\u{1}clearMessageSetWireFormat\0\u{1}clearMinimumEdition\0\u{1}clearName\0\u{1}clearNamePart\0\u{1}clearNegativeIntValue\0\u{1}clearNoStandardDescriptorAccessor\0\u{1}clearNumber\0\u{1}clearObjcClassPrefix\0\u{1}clearOneofIndex\0\u{1}clearOptimizeFor\0\u{1}clearOptions\0\u{1}clearOutputType\0\u{1}clearOverridableFeatures\0\u{1}clearPackage\0\u{1}clearPacked\0\u{1}clearPhpClassPrefix\0\u{1}clearPhpMetadataNamespace\0\u{1}clearPhpNamespace\0\u{1}clearPositiveIntValue\0\u{1}clearProto3Optional\0\u{1}clearPyGenericServices\0\u{1}clearRemovalError\0\u{1}clearRepeated\0\u{1}clearRepeatedFieldEncoding\0\u{1}clearReserved\0\u{1}clearRetention\0\u{1}clearRubyPackage\0\u{1}clearSemantic\0\u{1}clearServerStreaming\0\u{1}clearSourceCodeInfo\0\u{1}clearSourceContext\0\u{1}clearSourceFile\0\u{1}clearStart\0\u{1}clearStringValue\0\u{1}clearSwiftPrefix\0\u{1}clearSyntax\0\u{1}clearTrailingComments\0\u{1}clearType\0\u{1}clearTypeName\0\u{1}clearUnverifiedLazy\0\u{1}clearUtf8Validation\0\u{1}clearValue\0\u{1}clearVerification\0\u{1}clearVisibility\0\u{1}clearWeak\0\u{1}clientStreaming\0\u{1}code\0\u{1}codePoint\0\u{1}codeUnits\0\u{1}Collection\0\u{1}comma\0\u{1}consumedBytes\0\u{1}contains\0\u{1}contentsOf\0\u{1}ContiguousBytes\0\u{1}copy\0\u{1}count\0\u{1}countVarintsInBuffer\0\u{1}csharpNamespace\0\u{1}ctype\0\u{1}customCodable\0\u{1}CustomDebugStringConvertible\0\u{1}CustomStringConvertible\0\u{1}D\0\u{1}Data\0\u{1}dataResult\0\u{1}date\0\u{1}daySec\0\u{1}daysSinceEpoch\0\u{1}debugDescription\0\u{1}debugRedact\0\u{1}declaration\0\u{1}decoded\0\u{1}decodedFromJSONNull\0\u{1}decodeExtensionField\0\u{1}decodeExtensionFieldsAsMessageSet\0\u{1}decodeJSON\0\u{1}decodeMapField\0\u{1}decodeMessage\0\u{1}Decoder\0\u{1}decodeRepeated\0\u{1}decodeRepeatedBoolField\0\u{1}decodeRepeatedBytesField\0\u{1}decodeRepeatedDoubleField\0\u{1}decodeRepeatedEnumField\0\u{1}decodeRepeatedFixed32Field\0\u{1}decodeRepeatedFixed64Field\0\u{1}decodeRepeatedFloatField\0\u{1}decodeRepeatedGroupField\0\u{1}decodeRepeatedInt32Field\0\u{1}decodeRepeatedInt64Field\0\u{1}decodeRepeatedMessageField\0\u{1}decodeRepeatedSFixed32Field\0\u{1}decodeRepeatedSFixed64Field\0\u{1}decodeRepeatedSInt32Field\0\u{1}decodeRepeatedSInt64Field\0\u{1}decodeRepeatedStringField\0\u{1}decodeRepeatedUInt32Field\0\u{1}decodeRepeatedUInt64Field\0\u{1}decodeSingular\0\u{1}decodeSingularBoolField\0\u{1}decodeSingularBytesField\0\u{1}decodeSingularDoubleField\0\u{1}decodeSingularEnumField\0\u{1}decodeSingularFixed32Field\0\u{1}decodeSingularFixed64Field\0\u{1}decodeSingularFloatField\0\u{1}decodeSingularGroupField\0\u{1}decodeSingularInt32Field\0\u{1}decodeSingularInt64Field\0\u{1}decodeSingularMessageField\0\u{1}decodeSingularSFixed32Field\0\u{1}decodeSingularSFixed64Field\0\u{1}decodeSingularSInt32Field\0\u{1}decodeSingularSInt64Field\0\u{1}decodeSingularStringField\0\u{1}decodeSingularUInt32Field\0\u{1}decodeSingularUInt64Field\0\u{1}decodeTextFormat\0\u{1}defaultAnyTypeURLPrefix\0\u{1}defaults\0\u{1}defaultSymbolVisibility\0\u{1}defaultValue\0\u{1}dependency\0\u{1}deprecated\0\u{1}deprecatedLegacyJsonFieldConflicts\0\u{1}deprecationWarning\0\u{1}description\0\u{1}Dictionary\0\u{1}dictionaryLiteral\0\u{1}digit\0\u{1}digit0\0\u{1}digit1\0\u{1}digitCount\0\u{1}digits\0\u{1}digitValue\0\u{1}discardableResult\0\u{1}discardUnknownFields\0\u{1}Double\0\u{1}doubleValue\0\u{1}duration\0\u{1}E\0\u{1}edition\0\u{1}EditionDefault\0\u{1}editionDefaults\0\u{1}editionDeprecated\0\u{1}editionIntroduced\0\u{1}editionRemoved\0\u{1}Element\0\u{1}elements\0\u{1}else\0\u{1}emitExtensionFieldName\0\u{1}emitFieldName\0\u{1}emitFieldNumber\0\u{1}emptyAnyTypeURL\0\u{1}emptyData\0\u{1}encodeAsBytes\0\u{1}encoded\0\u{1}encodedJSONString\0\u{1}encodedSize\0\u{1}encodeField\0\u{1}encoder\0\u{1}end\0\u{1}endArray\0\u{1}endMessageField\0\u{1}endObject\0\u{1}endRegularField\0\u{1}enforceNamingStyle\0\u{1}enum\0\u{1}EnumReservedRange\0\u{1}enumType\0\u{1}enumvalue\0\u{1}Equatable\0\u{1}Error\0\u{1}execute\0\u{1}ExpressibleByArrayLiteral\0\u{1}ExpressibleByDictionaryLiteral\0\u{1}ext\0\u{1}extDecoder\0\u{1}extendedGraphemeClusterLiteral\0\u{1}ExtendedGraphemeClusterLiteralType\0\u{1}extendee\0\u{1}ExtensibleMessage\0\u{1}extension\0\u{1}ExtensionField\0\u{1}extensionFieldNumber\0\u{1}ExtensionFieldValueSet\0\u{1}ExtensionMap\0\u{1}extensionRange\0\u{1}extensions\0\u{1}extras\0\u{1}F\0\u{1}false\0\u{1}features\0\u{1}FeatureSetEditionDefault\0\u{1}featureSupport\0\u{1}field\0\u{1}fieldData\0\u{1}FieldMaskError\0\u{1}fieldName\0\u{1}fieldNameCount\0\u{1}fieldNum\0\u{1}fieldNumber\0\u{1}fieldNumberForProto\0\u{1}fieldPresence\0\u{1}fields\0\u{1}fieldSize\0\u{1}FieldTag\0\u{1}FieldType\0\u{1}file\0\u{1}fileName\0\u{1}filter\0\u{1}final\0\u{1}finiteOnly\0\u{1}first\0\u{1}firstItem\0\u{1}fixedFeatures\0\u{1}Float\0\u{1}floatLiteral\0\u{1}FloatLiteralType\0\u{1}for\0\u{1}forMessageName\0\u{1}formUnion\0\u{1}forReadingFrom\0\u{1}forTypeURL\0\u{1}ForwardParser\0\u{1}forWritingInto\0\u{1}from\0\u{1}fromAscii2\0\u{1}fromAscii4\0\u{1}fromByteOffset\0\u{1}fromHexDigit\0\u{1}fullName\0\u{1}func\0\u{1}function\0\u{1}G\0\u{1}get\0\u{1}getExtensionValue\0\u{3}Google_Protobuf_Any\0\u{3}Google_Protobuf_Api\0\u{3}Google_Protobuf_BoolValue\0\u{3}Google_Protobuf_BytesValue\0\u{3}Google_Protobuf_DescriptorProto\0\u{3}Google_Protobuf_DoubleValue\0\u{3}Google_Protobuf_Duration\0\u{3}Google_Protobuf_Edition\0\u{3}Google_Protobuf_Empty\0\u{3}Google_Protobuf_Enum\0\u{3}Google_Protobuf_EnumDescriptorProto\0\u{3}Google_Protobuf_EnumOptions\0\u{3}Google_Protobuf_EnumValue\0\u{3}Google_Protobuf_EnumValueDescriptorProto\0\u{3}Google_Protobuf_EnumValueOptions\0\u{3}Google_Protobuf_ExtensionRangeOptions\0\u{3}Google_Protobuf_FeatureSet\0\u{3}Google_Protobuf_FeatureSetDefaults\0\u{3}Google_Protobuf_Field\0\u{3}Google_Protobuf_FieldDescriptorProto\0\u{3}Google_Protobuf_FieldMask\0\u{3}Google_Protobuf_FieldOptions\0\u{3}Google_Protobuf_FileDescriptorProto\0\u{3}Google_Protobuf_FileDescriptorSet\0\u{3}Google_Protobuf_FileOptions\0\u{3}Google_Protobuf_FloatValue\0\u{3}Google_Protobuf_GeneratedCodeInfo\0\u{3}Google_Protobuf_Int32Value\0\u{3}Google_Protobuf_Int64Value\0\u{3}Google_Protobuf_ListValue\0\u{3}Google_Protobuf_MessageOptions\0\u{3}Google_Protobuf_Method\0\u{3}Google_Protobuf_MethodDescriptorProto\0\u{3}Google_Protobuf_MethodOptions\0\u{3}Google_Protobuf_Mixin\0\u{3}Google_Protobuf_NullValue\0\u{3}Google_Protobuf_OneofDescriptorProto\0\u{3}Google_Protobuf_OneofOptions\0\u{3}Google_Protobuf_Option\0\u{3}Google_Protobuf_ServiceDescriptorProto\0\u{3}Google_Protobuf_ServiceOptions\0\u{3}Google_Protobuf_SourceCodeInfo\0\u{3}Google_Protobuf_SourceContext\0\u{3}Google_Protobuf_StringValue\0\u{3}Google_Protobuf_Struct\0\u{3}Google_Protobuf_SymbolVisibility\0\u{3}Google_Protobuf_Syntax\0\u{3}Google_Protobuf_Timestamp\0\u{3}Google_Protobuf_Type\0\u{3}Google_Protobuf_UInt32Value\0\u{3}Google_Protobuf_UInt64Value\0\u{3}Google_Protobuf_UninterpretedOption\0\u{3}Google_Protobuf_Value\0\u{1}goPackage\0\u{1}gotData\0\u{1}group\0\u{1}groupFieldNumberStack\0\u{1}groupSize\0\u{1}guard\0\u{1}hadOneofValue\0\u{1}handleConflictingOneOf\0\u{1}handleInstruction\0\u{1}hasAggregateValue\0\u{1}hasAllowAlias\0\u{1}hasBegin\0\u{1}hasCcEnableArenas\0\u{1}hasCcGenericServices\0\u{1}hasClientStreaming\0\u{1}hasCsharpNamespace\0\u{1}hasCtype\0\u{1}hasData\0\u{1}hasDebugRedact\0\u{1}hasDefaultSymbolVisibility\0\u{1}hasDefaultValue\0\u{1}hasDeprecated\0\u{1}hasDeprecatedLegacyJsonFieldConflicts\0\u{1}hasDeprecationWarning\0\u{1}hasDoubleValue\0\u{1}hasEdition\0\u{1}hasEditionDeprecated\0\u{1}hasEditionIntroduced\0\u{1}hasEditionRemoved\0\u{1}hasEnd\0\u{1}hasEnforceNamingStyle\0\u{1}hasEnumType\0\u{1}hasExplicitDelta\0\u{1}hasExtendee\0\u{1}hasExtensionValue\0\u{1}hasFeatures\0\u{1}hasFeatureSupport\0\u{1}hasFieldPresence\0\u{1}hasFixedFeatures\0\u{1}hasFullName\0\u{1}hasGoPackage\0\u{1}hash\0\u{1}Hashable\0\u{1}hasher\0\u{1}HashVisitor\0\u{1}hasIdempotencyLevel\0\u{1}hasIdentifierValue\0\u{1}hasInputType\0\u{1}hasIsExtension\0\u{1}hasJavaGenerateEqualsAndHash\0\u{1}hasJavaGenericServices\0\u{1}hasJavaMultipleFiles\0\u{1}hasJavaOuterClassname\0\u{1}hasJavaPackage\0\u{1}hasJavaStringCheckUtf8\0\u{1}hasJsonFormat\0\u{1}hasJsonName\0\u{1}hasJstype\0\u{1}hasLabel\0\u{1}hasLazy\0\u{1}hasLeadingComments\0\u{1}hasMapEntry\0\u{1}hasMaximumEdition\0\u{1}hasMessageEncoding\0\u{1}hasMessageSetWireFormat\0\u{1}hasMinimumEdition\0\u{1}hasName\0\u{1}hasNamePart\0\u{1}hasNegativeIntValue\0\u{1}hasNoStandardDescriptorAccessor\0\u{1}hasNumber\0\u{1}hasObjcClassPrefix\0\u{1}hasOneofIndex\0\u{1}hasOptimizeFor\0\u{1}hasOptions\0\u{1}hasOutputType\0\u{1}hasOverridableFeatures\0\u{1}hasPackage\0\u{1}hasPacked\0\u{1}hasPhpClassPrefix\0\u{1}hasPhpMetadataNamespace\0\u{1}hasPhpNamespace\0\u{1}hasPositiveIntValue\0\u{1}hasProto3Optional\0\u{1}hasPyGenericServices\0\u{1}hasRemovalError\0\u{1}hasRepeated\0\u{1}hasRepeatedFieldEncoding\0\u{1}hasReserved\0\u{1}hasRetention\0\u{1}hasRubyPackage\0\u{1}hasSemantic\0\u{1}hasServerStreaming\0\u{1}hasSourceCodeInfo\0\u{1}hasSourceContext\0\u{1}hasSourceFile\0\u{1}hasStart\0\u{1}hasStringValue\0\u{1}hasSwiftPrefix\0\u{1}hasSyntax\0\u{1}hasTrailingComments\0\u{1}hasType\0\u{1}hasTypeName\0\u{1}hasUnverifiedLazy\0\u{1}hasUtf8Validation\0\u{1}hasValue\0\u{1}hasVerification\0\u{1}hasVisibility\0\u{1}hasWeak\0\u{1}hour\0\u{1}i\0\u{1}idempotencyLevel\0\u{1}identifierValue\0\u{1}if\0\u{1}ignoreUnknownExtensionFields\0\u{1}ignoreUnknownFields\0\u{1}index\0\u{1}init\0\u{1}inout\0\u{1}inputType\0\u{1}insert\0\u{1}Instruction\0\u{1}Int\0\u{1}Int32\0\u{1}Int64\0\u{1}Int8\0\u{1}integerLiteral\0\u{1}IntegerLiteralType\0\u{1}intern\0\u{1}Internal\0\u{1}InternalState\0\u{1}intersect\0\u{1}into\0\u{1}ints\0\u{1}invalidAnyTypeURL\0\u{1}isA\0\u{1}isEqual\0\u{1}isEqualTo\0\u{1}isExtension\0\u{1}isInitialized\0\u{1}isNegative\0\u{1}isPathValid\0\u{1}isReserved\0\u{1}isValid\0\u{1}itemTagsEncodedSize\0\u{1}iterator\0\u{1}javaGenerateEqualsAndHash\0\u{1}javaGenericServices\0\u{1}javaMultipleFiles\0\u{1}javaOuterClassname\0\u{1}javaPackage\0\u{1}javaStringCheckUtf8\0\u{1}JSONDecoder\0\u{1}JSONDecoding\0\u{1}JSONDecodingError\0\u{1}JSONDecodingOptions\0\u{1}jsonEncoder\0\u{1}JSONEncoding\0\u{1}JSONEncodingError\0\u{1}JSONEncodingOptions\0\u{1}JSONEncodingVisitor\0\u{1}jsonFormat\0\u{1}JSONMapEncodingVisitor\0\u{1}jsonName\0\u{1}jsonPath\0\u{1}jsonPaths\0\u{1}JSONScanner\0\u{1}jsonString\0\u{1}jsonText\0\u{1}jsonUTF8Bytes\0\u{1}jsonUTF8Data\0\u{1}jstype\0\u{1}k\0\u{1}kChunkSize\0\u{1}Key\0\u{1}keyField\0\u{1}keyFieldOpt\0\u{1}KeyType\0\u{1}kind\0\u{1}l\0\u{1}label\0\u{1}lazy\0\u{1}leadingComments\0\u{1}leadingDetachedComments\0\u{1}length\0\u{1}lessThan\0\u{1}let\0\u{1}lhs\0\u{1}line\0\u{1}list\0\u{1}listOfMessages\0\u{1}listValue\0\u{1}littleEndian\0\u{1}load\0\u{1}localHasher\0\u{1}location\0\u{1}M\0\u{1}major\0\u{1}makeAsyncIterator\0\u{1}makeIterator\0\u{1}malformedLength\0\u{1}mapEntry\0\u{1}MapKeyType\0\u{1}mapToMessages\0\u{1}MapValueType\0\u{1}mapVisitor\0\u{1}mask\0\u{1}maximumEdition\0\u{1}mdayStart\0\u{1}merge\0\u{1}MergeOptions\0\u{1}message\0\u{1}messageDepthLimit\0\u{1}messageEncoding\0\u{1}MessageExtension\0\u{1}MessageImplementationBase\0\u{1}MessageSet\0\u{1}messageSetWireFormat\0\u{1}messageSize\0\u{1}messageType\0\u{1}method\0\u{1}methods\0\u{1}min\0\u{1}minimumEdition\0\u{1}minor\0\u{1}mixins\0\u{1}modify\0\u{1}month\0\u{1}msgExtension\0\u{1}mutating\0\u{1}n\0\u{1}name\0\u{1}NameDescription\0\u{1}NameMap\0\u{1}NamePart\0\u{1}names\0\u{1}nanos\0\u{1}negativeIntValue\0\u{1}nestedType\0\u{1}newExtensible\0\u{1}newL\0\u{1}newList\0\u{1}newMessage\0\u{1}newValue\0\u{1}next\0\u{1}nextByte\0\u{1}nextFieldNumber\0\u{1}nextInstruction\0\u{1}nextInt32\0\u{1}nextNullTerminatedString\0\u{1}nextNullTerminatedStringArray\0\u{1}nextNumber\0\u{1}nextUInt64\0\u{1}nextVarInt\0\u{1}nil\0\u{1}nilLiteral\0\u{1}noBytesAvailable\0\u{1}noStandardDescriptorAccessor\0\u{1}nullValue\0\u{1}number\0\u{1}numberValue\0\u{1}objcClassPrefix\0\u{1}of\0\u{3}OneOf_Kind\0\u{1}oneofDecl\0\u{1}oneofIndex\0\u{1}oneofs\0\u{1}optimizeFor\0\u{1}OptimizeMode\0\u{1}OptionalEnumExtensionField\0\u{1}OptionalExtensionField\0\u{1}OptionalGroupExtensionField\0\u{1}OptionalMessageExtensionField\0\u{1}optionDependency\0\u{1}OptionRetention\0\u{1}options\0\u{1}OptionTargetType\0\u{1}other\0\u{1}others\0\u{1}out\0\u{1}outputType\0\u{1}overridableFeatures\0\u{1}p\0\u{1}package\0\u{1}packed\0\u{1}PackedEnumExtensionField\0\u{1}PackedExtensionField\0\u{1}padding\0\u{1}parent\0\u{1}parse\0\u{1}partial\0\u{1}path\0\u{1}PathDecoder\0\u{1}PathDecodingError\0\u{1}paths\0\u{1}PathVisitor\0\u{1}payload\0\u{1}payloadSize\0\u{1}phpClassPrefix\0\u{1}phpMetadataNamespace\0\u{1}phpNamespace\0\u{1}pos\0\u{1}positiveIntValue\0\u{1}prefix\0\u{1}preserveProtoFieldNames\0\u{1}preTraverse\0\u{1}previousNumber\0\u{1}prevPath\0\u{1}printUnknownFields\0\u{1}programBuffer\0\u{1}programFormat\0\u{1}proto2\0\u{1}proto3DefaultValue\0\u{1}proto3Optional\0\u{3}protobuf_extensionFieldValues\0\u{3}protobuf_fieldNumber\0\u{3}protobuf_generated_isEqualTo\0\u{3}protobuf_nameMap\0\u{3}protobuf_newField\0\u{3}protobuf_package\0\u{3}ProtobufAPIVersion_2\0\u{1}ProtobufAPIVersionCheck\0\u{1}ProtobufBool\0\u{1}ProtobufBytes\0\u{1}protobufData\0\u{1}ProtobufDouble\0\u{1}ProtobufEnumMap\0\u{1}protobufExtension\0\u{1}ProtobufFixed32\0\u{1}ProtobufFixed64\0\u{1}ProtobufFloat\0\u{1}ProtobufInt32\0\u{1}ProtobufInt64\0\u{1}ProtobufMap\0\u{1}ProtobufMessageMap\0\u{1}ProtobufSFixed32\0\u{1}ProtobufSFixed64\0\u{1}ProtobufSInt32\0\u{1}ProtobufSInt64\0\u{1}ProtobufString\0\u{1}ProtobufUInt32\0\u{1}ProtobufUInt64\0\u{1}protocol\0\u{1}protoFieldName\0\u{1}protoMessageName\0\u{1}ProtoNameProviding\0\u{1}protoPaths\0\u{1}public\0\u{1}publicDependency\0\u{1}putBoolValue\0\u{1}putBytesValue\0\u{1}putDoubleValue\0\u{1}putEnumValue\0\u{1}putFixedUInt32\0\u{1}putFixedUInt64\0\u{1}putFloatValue\0\u{1}putInt64\0\u{1}putStringValue\0\u{1}putUInt64\0\u{1}putUInt64Hex\0\u{1}putVarInt\0\u{1}putZigZagVarInt\0\u{1}pyGenericServices\0\u{1}R\0\u{1}rawChars\0\u{1}RawRepresentable\0\u{1}RawValue\0\u{1}read4HexDigits\0\u{1}readBytes\0\u{1}reader\0\u{1}register\0\u{1}remainingProgram\0\u{1}removalError\0\u{1}removingAllFieldsOf\0\u{1}repeated\0\u{1}RepeatedEnumExtensionField\0\u{1}RepeatedExtensionField\0\u{1}repeatedFieldEncoding\0\u{1}RepeatedGroupExtensionField\0\u{1}RepeatedMessageExtensionField\0\u{1}repeating\0\u{1}replaceRepeatedFields\0\u{1}requestStreaming\0\u{1}requestTypeURL\0\u{1}requiredSize\0\u{1}responseStreaming\0\u{1}responseTypeURL\0\u{1}result\0\u{1}retention\0\u{1}rethrows\0\u{1}ReturnType\0\u{1}revision\0\u{1}rhs\0\u{1}root\0\u{1}rubyPackage\0\u{1}s\0\u{1}sawBackslash\0\u{1}sawSection4Characters\0\u{1}sawSection5Characters\0\u{1}Scalar\0\u{1}scan\0\u{1}scanner\0\u{1}seconds\0\u{1}self\0\u{1}semantic\0\u{1}Sendable\0\u{1}separator\0\u{1}serialize\0\u{1}serializedBytes\0\u{1}serializedData\0\u{1}serializedSize\0\u{1}serverStreaming\0\u{1}service\0\u{1}set\0\u{1}setExtensionValue\0\u{1}shift\0\u{1}SimpleExtensionMap\0\u{1}size\0\u{1}sizer\0\u{1}source\0\u{1}sourceCodeInfo\0\u{1}sourceContext\0\u{1}sourceEncoding\0\u{1}sourceFile\0\u{1}SourceLocation\0\u{1}span\0\u{1}split\0\u{1}start\0\u{1}startArray\0\u{1}startArrayObject\0\u{1}startField\0\u{1}startIndex\0\u{1}startMessageField\0\u{1}startObject\0\u{1}startRegularField\0\u{1}state\0\u{1}static\0\u{1}StaticString\0\u{1}storage\0\u{1}String\0\u{1}stringLiteral\0\u{1}StringLiteralType\0\u{1}stringResult\0\u{1}stringValue\0\u{1}struct\0\u{1}structValue\0\u{1}subDecoder\0\u{1}subscript\0\u{1}subtract\0\u{1}subVisitor\0\u{1}Swift\0\u{1}swiftPrefix\0\u{1}SwiftProtobufContiguousBytes\0\u{1}SwiftProtobufError\0\u{1}syntax\0\u{1}T\0\u{1}tag\0\u{1}targets\0\u{1}terminator\0\u{1}testDecoder\0\u{1}text\0\u{1}textDecoder\0\u{1}TextFormatDecoder\0\u{1}TextFormatDecodingError\0\u{1}TextFormatDecodingOptions\0\u{1}TextFormatEncodingOptions\0\u{1}TextFormatEncodingVisitor\0\u{1}textFormatString\0\u{1}throwOrIgnore\0\u{1}throws\0\u{1}timeInterval\0\u{1}timeIntervalSince1970\0\u{1}timeIntervalSinceReferenceDate\0\u{1}tmp\0\u{1}tooLarge\0\u{1}total\0\u{1}totalArrayDepth\0\u{1}totalSize\0\u{1}trailingComments\0\u{1}traverse\0\u{1}trim\0\u{1}true\0\u{1}try\0\u{1}type\0\u{1}typealias\0\u{1}TypeEnum\0\u{1}typeName\0\u{1}typePrefix\0\u{1}typeStart\0\u{1}typeUnknown\0\u{1}typeURL\0\u{1}UInt32\0\u{1}UInt64\0\u{1}UInt8\0\u{1}unchecked\0\u{1}Unicode\0\u{1}unicodeScalarLiteral\0\u{1}UnicodeScalarLiteralType\0\u{1}unicodeScalars\0\u{1}UnicodeScalarView\0\u{1}uninterpretedOption\0\u{1}union\0\u{1}uniqueStorage\0\u{1}unknown\0\u{1}unknownFields\0\u{1}UnknownStorage\0\u{1}unpackTo\0\u{1}UnsafeBufferPointer\0\u{1}UnsafeMutablePointer\0\u{1}UnsafeMutableRawBufferPointer\0\u{1}UnsafeRawBufferPointer\0\u{1}UnsafeRawPointer\0\u{1}unverifiedLazy\0\u{1}updatedOptions\0\u{1}uppercasedAssumingASCII\0\u{1}url\0\u{1}useDeterministicOrdering\0\u{1}utf8\0\u{1}utf8Ptr\0\u{1}utf8ToDouble\0\u{1}utf8Validation\0\u{1}UTF8View\0\u{1}V\0\u{1}value\0\u{1}valueField\0\u{1}values\0\u{1}ValueType\0\u{1}var\0\u{1}verification\0\u{1}VerificationState\0\u{1}version\0\u{1}versionString\0\u{1}visibility\0\u{1}VisibilityFeature\0\u{1}visitExtensionFields\0\u{1}visitExtensionFieldsAsMessageSet\0\u{1}visitMapField\0\u{1}Visitor\0\u{1}visitPacked\0\u{1}visitPackedBoolField\0\u{1}visitPackedDoubleField\0\u{1}visitPackedEnumField\0\u{1}visitPackedFixed32Field\0\u{1}visitPackedFixed64Field\0\u{1}visitPackedFloatField\0\u{1}visitPackedInt32Field\0\u{1}visitPackedInt64Field\0\u{1}visitPackedSFixed32Field\0\u{1}visitPackedSFixed64Field\0\u{1}visitPackedSInt32Field\0\u{1}visitPackedSInt64Field\0\u{1}visitPackedUInt32Field\0\u{1}visitPackedUInt64Field\0\u{1}visitRepeated\0\u{1}visitRepeatedBoolField\0\u{1}visitRepeatedBytesField\0\u{1}visitRepeatedDoubleField\0\u{1}visitRepeatedEnumField\0\u{1}visitRepeatedFixed32Field\0\u{1}visitRepeatedFixed64Field\0\u{1}visitRepeatedFloatField\0\u{1}visitRepeatedGroupField\0\u{1}visitRepeatedInt32Field\0\u{1}visitRepeatedInt64Field\0\u{1}visitRepeatedMessageField\0\u{1}visitRepeatedSFixed32Field\0\u{1}visitRepeatedSFixed64Field\0\u{1}visitRepeatedSInt32Field\0\u{1}visitRepeatedSInt64Field\0\u{1}visitRepeatedStringField\0\u{1}visitRepeatedUInt32Field\0\u{1}visitRepeatedUInt64Field\0\u{1}visitSingular\0\u{1}visitSingularBoolField\0\u{1}visitSingularBytesField\0\u{1}visitSingularDoubleField\0\u{1}visitSingularEnumField\0\u{1}visitSingularFixed32Field\0\u{1}visitSingularFixed64Field\0\u{1}visitSingularFloatField\0\u{1}visitSingularGroupField\0\u{1}visitSingularInt32Field\0\u{1}visitSingularInt64Field\0\u{1}visitSingularMessageField\0\u{1}visitSingularSFixed32Field\0\u{1}visitSingularSFixed64Field\0\u{1}visitSingularSInt32Field\0\u{1}visitSingularSInt64Field\0\u{1}visitSingularStringField\0\u{1}visitSingularUInt32Field\0\u{1}visitSingularUInt64Field\0\u{1}visitUnknown\0\u{1}Void\0\u{1}wasDecoded\0\u{1}weak\0\u{1}weakDependency\0\u{1}where\0\u{1}wireFormat\0\u{1}with\0\u{1}withUnsafeBytes\0\u{1}withUnsafeMutableBytes\0\u{1}work\0\u{1}Wrapped\0\u{1}WrappedType\0\u{1}wrappedValue\0\u{1}written\0\u{1}yday\0") fileprivate class _StorageClass { + var _addPath: Int32 = 0 var _adjusted: Int32 = 0 var _aggregateValue: Int32 = 0 var _allCases: Int32 = 0 var _allowAlias: Int32 = 0 var _alwaysPrintEnumsAsInts: Int32 = 0 + var _alwaysPrintInt64SAsNumbers: Int32 = 0 var _annotation: Int32 = 0 var _any: Int32 = 0 var _anyExtensionField: Int32 = 0 var _anyMessageExtension: Int32 = 0 var _anyMessageStorage: Int32 = 0 var _anyUnpackError: Int32 = 0 - var _api: Int32 = 0 + var _append: Int32 = 0 var _appended: Int32 = 0 var _appendUintHex: Int32 = 0 var _appendUnknown: Int32 = 0 @@ -5287,14 +5205,20 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _as: Int32 = 0 var _asciiOpenCurlyBracket: Int32 = 0 var _asciiZero: Int32 = 0 + var _async: Int32 = 0 + var _asyncIterator: Int32 = 0 + var _asyncIteratorProtocol: Int32 = 0 + var _asyncMessageSequence: Int32 = 0 var _available: Int32 = 0 var _b: Int32 = 0 + var _base: Int32 = 0 var _base64Values: Int32 = 0 var _baseAddress: Int32 = 0 var _baseType: Int32 = 0 var _begin: Int32 = 0 var _binary: Int32 = 0 var _binaryDecoder: Int32 = 0 + var _binaryDecoding: Int32 = 0 var _binaryDecodingError: Int32 = 0 var _binaryDecodingOptions: Int32 = 0 var _binaryDelimited: Int32 = 0 @@ -5302,25 +5226,39 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _binaryEncodingError: Int32 = 0 var _binaryEncodingMessageSetSizeVisitor: Int32 = 0 var _binaryEncodingMessageSetVisitor: Int32 = 0 + var _binaryEncodingOptions: Int32 = 0 var _binaryEncodingSizeVisitor: Int32 = 0 var _binaryEncodingVisitor: Int32 = 0 var _binaryOptions: Int32 = 0 + var _binaryProtobufDelimitedMessages: Int32 = 0 + var _binaryStreamDecoding: Int32 = 0 + var _binaryStreamDecodingError: Int32 = 0 + var _bitPattern: Int32 = 0 var _body: Int32 = 0 var _bool: Int32 = 0 var _booleanLiteral: Int32 = 0 var _booleanLiteralType: Int32 = 0 var _boolValue: Int32 = 0 + var _buffer: Int32 = 0 + var _byte: Int32 = 0 + var _bytecode: Int32 = 0 + var _bytecodeReader: Int32 = 0 var _bytes: Int32 = 0 var _bytesInGroup: Int32 = 0 + var _bytesNeeded: Int32 = 0 var _bytesRead: Int32 = 0 - var _bytesValue: Int32 = 0 var _c: Int32 = 0 + var _canonical: Int32 = 0 var _capitalizeNext: Int32 = 0 var _cardinality: Int32 = 0 + var _caseIterable: Int32 = 0 + var _castedValue: Int32 = 0 var _ccEnableArenas: Int32 = 0 var _ccGenericServices: Int32 = 0 var _character: Int32 = 0 var _chars: Int32 = 0 + var _checkProgramFormat: Int32 = 0 + var _chunk: Int32 = 0 var _class: Int32 = 0 var _clearAggregateValue_p: Int32 = 0 var _clearAllowAlias_p: Int32 = 0 @@ -5330,12 +5268,27 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _clearClientStreaming_p: Int32 = 0 var _clearCsharpNamespace_p: Int32 = 0 var _clearCtype_p: Int32 = 0 + var _clearDebugRedact_p: Int32 = 0 + var _clearDefaultSymbolVisibility_p: Int32 = 0 var _clearDefaultValue_p: Int32 = 0 var _clearDeprecated_p: Int32 = 0 + var _clearDeprecatedLegacyJsonFieldConflicts_p: Int32 = 0 + var _clearDeprecationWarning_p: Int32 = 0 var _clearDoubleValue_p: Int32 = 0 + var _clearEdition_p: Int32 = 0 + var _clearEditionDeprecated_p: Int32 = 0 + var _clearEditionIntroduced_p: Int32 = 0 + var _clearEditionRemoved_p: Int32 = 0 var _clearEnd_p: Int32 = 0 + var _clearEnforceNamingStyle_p: Int32 = 0 + var _clearEnumType_p: Int32 = 0 var _clearExtendee_p: Int32 = 0 var _clearExtensionValue_p: Int32 = 0 + var _clearFeatures_p: Int32 = 0 + var _clearFeatureSupport_p: Int32 = 0 + var _clearFieldPresence_p: Int32 = 0 + var _clearFixedFeatures_p: Int32 = 0 + var _clearFullName_p: Int32 = 0 var _clearGoPackage_p: Int32 = 0 var _clearIdempotencyLevel_p: Int32 = 0 var _clearIdentifierValue_p: Int32 = 0 @@ -5347,13 +5300,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _clearJavaOuterClassname_p: Int32 = 0 var _clearJavaPackage_p: Int32 = 0 var _clearJavaStringCheckUtf8_p: Int32 = 0 + var _clearJsonFormat_p: Int32 = 0 var _clearJsonName_p: Int32 = 0 var _clearJstype_p: Int32 = 0 var _clearLabel_p: Int32 = 0 var _clearLazy_p: Int32 = 0 var _clearLeadingComments_p: Int32 = 0 var _clearMapEntry_p: Int32 = 0 + var _clearMaximumEdition_p: Int32 = 0 + var _clearMessageEncoding_p: Int32 = 0 var _clearMessageSetWireFormat_p: Int32 = 0 + var _clearMinimumEdition_p: Int32 = 0 var _clearName_p: Int32 = 0 var _clearNamePart_p: Int32 = 0 var _clearNegativeIntValue_p: Int32 = 0 @@ -5364,16 +5321,22 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _clearOptimizeFor_p: Int32 = 0 var _clearOptions_p: Int32 = 0 var _clearOutputType_p: Int32 = 0 + var _clearOverridableFeatures_p: Int32 = 0 var _clearPackage_p: Int32 = 0 var _clearPacked_p: Int32 = 0 var _clearPhpClassPrefix_p: Int32 = 0 - var _clearPhpGenericServices_p: Int32 = 0 var _clearPhpMetadataNamespace_p: Int32 = 0 var _clearPhpNamespace_p: Int32 = 0 var _clearPositiveIntValue_p: Int32 = 0 var _clearProto3Optional_p: Int32 = 0 var _clearPyGenericServices_p: Int32 = 0 + var _clearRemovalError_p: Int32 = 0 + var _clearRepeated_p: Int32 = 0 + var _clearRepeatedFieldEncoding_p: Int32 = 0 + var _clearReserved_p: Int32 = 0 + var _clearRetention_p: Int32 = 0 var _clearRubyPackage_p: Int32 = 0 + var _clearSemantic_p: Int32 = 0 var _clearServerStreaming_p: Int32 = 0 var _clearSourceCodeInfo_p: Int32 = 0 var _clearSourceContext_p: Int32 = 0 @@ -5385,22 +5348,30 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _clearTrailingComments_p: Int32 = 0 var _clearType_p: Int32 = 0 var _clearTypeName_p: Int32 = 0 + var _clearUnverifiedLazy_p: Int32 = 0 + var _clearUtf8Validation_p: Int32 = 0 var _clearValue_p: Int32 = 0 + var _clearVerification_p: Int32 = 0 + var _clearVisibility_p: Int32 = 0 var _clearWeak_p: Int32 = 0 var _clientStreaming: Int32 = 0 + var _code: Int32 = 0 var _codePoint: Int32 = 0 var _codeUnits: Int32 = 0 var _collection: Int32 = 0 - var _com: Int32 = 0 var _comma: Int32 = 0 + var _consumedBytes: Int32 = 0 + var _contains: Int32 = 0 var _contentsOf: Int32 = 0 var _contiguousBytes: Int32 = 0 + var _copy: Int32 = 0 var _count: Int32 = 0 var _countVarintsInBuffer: Int32 = 0 var _csharpNamespace: Int32 = 0 var _ctype: Int32 = 0 var _customCodable: Int32 = 0 var _customDebugStringConvertible: Int32 = 0 + var _customStringConvertible: Int32 = 0 var _d: Int32 = 0 var _data: Int32 = 0 var _dataResult: Int32 = 0 @@ -5408,6 +5379,8 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _daySec: Int32 = 0 var _daysSinceEpoch: Int32 = 0 var _debugDescription_p: Int32 = 0 + var _debugRedact: Int32 = 0 + var _declaration: Int32 = 0 var _decoded: Int32 = 0 var _decodedFromJsonnull: Int32 = 0 var _decodeExtensionField: Int32 = 0 @@ -5456,11 +5429,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _decodeSingularUint64Field: Int32 = 0 var _decodeTextFormat: Int32 = 0 var _defaultAnyTypeUrlprefix: Int32 = 0 + var _defaults: Int32 = 0 + var _defaultSymbolVisibility: Int32 = 0 var _defaultValue: Int32 = 0 var _dependency: Int32 = 0 var _deprecated: Int32 = 0 + var _deprecatedLegacyJsonFieldConflicts: Int32 = 0 + var _deprecationWarning: Int32 = 0 var _description_p: Int32 = 0 - var _descriptorProto: Int32 = 0 var _dictionary: Int32 = 0 var _dictionaryLiteral: Int32 = 0 var _digit: Int32 = 0 @@ -5471,17 +5447,23 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _digitValue: Int32 = 0 var _discardableResult: Int32 = 0 var _discardUnknownFields: Int32 = 0 - var _distance: Int32 = 0 var _double: Int32 = 0 var _doubleValue: Int32 = 0 var _duration: Int32 = 0 var _e: Int32 = 0 + var _edition: Int32 = 0 + var _editionDefault: Int32 = 0 + var _editionDefaults: Int32 = 0 + var _editionDeprecated: Int32 = 0 + var _editionIntroduced: Int32 = 0 + var _editionRemoved: Int32 = 0 var _element: Int32 = 0 var _elements: Int32 = 0 + var _else: Int32 = 0 var _emitExtensionFieldName: Int32 = 0 var _emitFieldName: Int32 = 0 var _emitFieldNumber: Int32 = 0 - var _empty: Int32 = 0 + var _emptyAnyTypeURL: Int32 = 0 var _emptyData: Int32 = 0 var _encodeAsBytes: Int32 = 0 var _encoded: Int32 = 0 @@ -5494,16 +5476,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _endMessageField: Int32 = 0 var _endObject: Int32 = 0 var _endRegularField: Int32 = 0 + var _enforceNamingStyle: Int32 = 0 var _enum: Int32 = 0 - var _enumDescriptorProto: Int32 = 0 - var _enumOptions: Int32 = 0 var _enumReservedRange: Int32 = 0 var _enumType: Int32 = 0 var _enumvalue: Int32 = 0 - var _enumValueDescriptorProto: Int32 = 0 - var _enumValueOptions: Int32 = 0 var _equatable: Int32 = 0 var _error: Int32 = 0 + var _execute: Int32 = 0 var _expressibleByArrayLiteral: Int32 = 0 var _expressibleByDictionaryLiteral: Int32 = 0 var _ext: Int32 = 0 @@ -5518,37 +5498,38 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _extensionFieldValueSet: Int32 = 0 var _extensionMap: Int32 = 0 var _extensionRange: Int32 = 0 - var _extensionRangeOptions: Int32 = 0 var _extensions: Int32 = 0 var _extras: Int32 = 0 var _f: Int32 = 0 var _false: Int32 = 0 + var _features: Int32 = 0 + var _featureSetEditionDefault: Int32 = 0 + var _featureSupport: Int32 = 0 var _field: Int32 = 0 var _fieldData: Int32 = 0 - var _fieldDescriptorProto: Int32 = 0 - var _fieldMask: Int32 = 0 + var _fieldMaskError: Int32 = 0 var _fieldName: Int32 = 0 var _fieldNameCount: Int32 = 0 var _fieldNum: Int32 = 0 var _fieldNumber: Int32 = 0 var _fieldNumberForProto: Int32 = 0 - var _fieldOptions: Int32 = 0 + var _fieldPresence: Int32 = 0 var _fields: Int32 = 0 var _fieldSize: Int32 = 0 var _fieldTag: Int32 = 0 var _fieldType: Int32 = 0 var _file: Int32 = 0 - var _fileDescriptorProto: Int32 = 0 - var _fileDescriptorSet: Int32 = 0 var _fileName: Int32 = 0 - var _fileOptions: Int32 = 0 var _filter: Int32 = 0 + var _final: Int32 = 0 + var _finiteOnly: Int32 = 0 var _first: Int32 = 0 var _firstItem: Int32 = 0 + var _fixedFeatures: Int32 = 0 var _float: Int32 = 0 var _floatLiteral: Int32 = 0 var _floatLiteralType: Int32 = 0 - var _floatValue: Int32 = 0 + var _for: Int32 = 0 var _forMessageName: Int32 = 0 var _formUnion: Int32 = 0 var _forReadingFrom: Int32 = 0 @@ -5560,12 +5541,12 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _fromAscii4: Int32 = 0 var _fromByteOffset: Int32 = 0 var _fromHexDigit: Int32 = 0 + var _fullName: Int32 = 0 var _func: Int32 = 0 + var _function: Int32 = 0 var _g: Int32 = 0 - var _generatedCodeInfo: Int32 = 0 var _get: Int32 = 0 var _getExtensionValue: Int32 = 0 - var _googleapis: Int32 = 0 var _googleProtobufAny: Int32 = 0 var _googleProtobufApi: Int32 = 0 var _googleProtobufBoolValue: Int32 = 0 @@ -5573,6 +5554,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _googleProtobufDescriptorProto: Int32 = 0 var _googleProtobufDoubleValue: Int32 = 0 var _googleProtobufDuration: Int32 = 0 + var _googleProtobufEdition: Int32 = 0 var _googleProtobufEmpty: Int32 = 0 var _googleProtobufEnum: Int32 = 0 var _googleProtobufEnumDescriptorProto: Int32 = 0 @@ -5581,6 +5563,8 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _googleProtobufEnumValueDescriptorProto: Int32 = 0 var _googleProtobufEnumValueOptions: Int32 = 0 var _googleProtobufExtensionRangeOptions: Int32 = 0 + var _googleProtobufFeatureSet: Int32 = 0 + var _googleProtobufFeatureSetDefaults: Int32 = 0 var _googleProtobufField: Int32 = 0 var _googleProtobufFieldDescriptorProto: Int32 = 0 var _googleProtobufFieldMask: Int32 = 0 @@ -5608,6 +5592,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _googleProtobufSourceContext: Int32 = 0 var _googleProtobufStringValue: Int32 = 0 var _googleProtobufStruct: Int32 = 0 + var _googleProtobufSymbolVisibility: Int32 = 0 var _googleProtobufSyntax: Int32 = 0 var _googleProtobufTimestamp: Int32 = 0 var _googleProtobufType: Int32 = 0 @@ -5616,12 +5601,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _googleProtobufUninterpretedOption: Int32 = 0 var _googleProtobufValue: Int32 = 0 var _goPackage: Int32 = 0 + var _gotData: Int32 = 0 var _group: Int32 = 0 var _groupFieldNumberStack: Int32 = 0 var _groupSize: Int32 = 0 - var _h: Int32 = 0 + var _guard: Int32 = 0 var _hadOneofValue: Int32 = 0 var _handleConflictingOneOf: Int32 = 0 + var _handleInstruction: Int32 = 0 var _hasAggregateValue_p: Int32 = 0 var _hasAllowAlias_p: Int32 = 0 var _hasBegin_p: Int32 = 0 @@ -5630,17 +5617,33 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _hasClientStreaming_p: Int32 = 0 var _hasCsharpNamespace_p: Int32 = 0 var _hasCtype_p: Int32 = 0 + var _hasData_p: Int32 = 0 + var _hasDebugRedact_p: Int32 = 0 + var _hasDefaultSymbolVisibility_p: Int32 = 0 var _hasDefaultValue_p: Int32 = 0 var _hasDeprecated_p: Int32 = 0 + var _hasDeprecatedLegacyJsonFieldConflicts_p: Int32 = 0 + var _hasDeprecationWarning_p: Int32 = 0 var _hasDoubleValue_p: Int32 = 0 + var _hasEdition_p: Int32 = 0 + var _hasEditionDeprecated_p: Int32 = 0 + var _hasEditionIntroduced_p: Int32 = 0 + var _hasEditionRemoved_p: Int32 = 0 var _hasEnd_p: Int32 = 0 + var _hasEnforceNamingStyle_p: Int32 = 0 + var _hasEnumType_p: Int32 = 0 + var _hasExplicitDelta_p: Int32 = 0 var _hasExtendee_p: Int32 = 0 var _hasExtensionValue_p: Int32 = 0 + var _hasFeatures_p: Int32 = 0 + var _hasFeatureSupport_p: Int32 = 0 + var _hasFieldPresence_p: Int32 = 0 + var _hasFixedFeatures_p: Int32 = 0 + var _hasFullName_p: Int32 = 0 var _hasGoPackage_p: Int32 = 0 var _hash: Int32 = 0 var _hashable: Int32 = 0 var _hasher: Int32 = 0 - var _hashValue_p: Int32 = 0 var _hashVisitor: Int32 = 0 var _hasIdempotencyLevel_p: Int32 = 0 var _hasIdentifierValue_p: Int32 = 0 @@ -5652,13 +5655,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _hasJavaOuterClassname_p: Int32 = 0 var _hasJavaPackage_p: Int32 = 0 var _hasJavaStringCheckUtf8_p: Int32 = 0 + var _hasJsonFormat_p: Int32 = 0 var _hasJsonName_p: Int32 = 0 var _hasJstype_p: Int32 = 0 var _hasLabel_p: Int32 = 0 var _hasLazy_p: Int32 = 0 var _hasLeadingComments_p: Int32 = 0 var _hasMapEntry_p: Int32 = 0 + var _hasMaximumEdition_p: Int32 = 0 + var _hasMessageEncoding_p: Int32 = 0 var _hasMessageSetWireFormat_p: Int32 = 0 + var _hasMinimumEdition_p: Int32 = 0 var _hasName_p: Int32 = 0 var _hasNamePart_p: Int32 = 0 var _hasNegativeIntValue_p: Int32 = 0 @@ -5669,16 +5676,22 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _hasOptimizeFor_p: Int32 = 0 var _hasOptions_p: Int32 = 0 var _hasOutputType_p: Int32 = 0 + var _hasOverridableFeatures_p: Int32 = 0 var _hasPackage_p: Int32 = 0 var _hasPacked_p: Int32 = 0 var _hasPhpClassPrefix_p: Int32 = 0 - var _hasPhpGenericServices_p: Int32 = 0 var _hasPhpMetadataNamespace_p: Int32 = 0 var _hasPhpNamespace_p: Int32 = 0 var _hasPositiveIntValue_p: Int32 = 0 var _hasProto3Optional_p: Int32 = 0 var _hasPyGenericServices_p: Int32 = 0 + var _hasRemovalError_p: Int32 = 0 + var _hasRepeated_p: Int32 = 0 + var _hasRepeatedFieldEncoding_p: Int32 = 0 + var _hasReserved_p: Int32 = 0 + var _hasRetention_p: Int32 = 0 var _hasRubyPackage_p: Int32 = 0 + var _hasSemantic_p: Int32 = 0 var _hasServerStreaming_p: Int32 = 0 var _hasSourceCodeInfo_p: Int32 = 0 var _hasSourceContext_p: Int32 = 0 @@ -5690,40 +5703,49 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _hasTrailingComments_p: Int32 = 0 var _hasType_p: Int32 = 0 var _hasTypeName_p: Int32 = 0 + var _hasUnverifiedLazy_p: Int32 = 0 + var _hasUtf8Validation_p: Int32 = 0 var _hasValue_p: Int32 = 0 + var _hasVerification_p: Int32 = 0 + var _hasVisibility_p: Int32 = 0 var _hasWeak_p: Int32 = 0 var _hour: Int32 = 0 var _i: Int32 = 0 var _idempotencyLevel: Int32 = 0 var _identifierValue: Int32 = 0 var _if: Int32 = 0 + var _ignoreUnknownExtensionFields: Int32 = 0 var _ignoreUnknownFields: Int32 = 0 var _index: Int32 = 0 var _init_p: Int32 = 0 var _inout: Int32 = 0 var _inputType: Int32 = 0 var _insert: Int32 = 0 + var _instruction: Int32 = 0 var _int: Int32 = 0 var _int32: Int32 = 0 - var _int32Value: Int32 = 0 var _int64: Int32 = 0 - var _int64Value: Int32 = 0 var _int8: Int32 = 0 var _integerLiteral: Int32 = 0 var _integerLiteralType: Int32 = 0 var _intern: Int32 = 0 var _internal: Int32 = 0 var _internalState: Int32 = 0 + var _intersect: Int32 = 0 var _into: Int32 = 0 var _ints: Int32 = 0 + var _invalidAnyTypeURL: Int32 = 0 var _isA: Int32 = 0 var _isEqual: Int32 = 0 var _isEqualTo: Int32 = 0 var _isExtension: Int32 = 0 var _isInitialized_p: Int32 = 0 + var _isNegative: Int32 = 0 + var _isPathValid: Int32 = 0 + var _isReserved: Int32 = 0 + var _isValid: Int32 = 0 var _itemTagsEncodedSize: Int32 = 0 var _iterator: Int32 = 0 - var _i2166136261: Int32 = 0 var _javaGenerateEqualsAndHash: Int32 = 0 var _javaGenericServices: Int32 = 0 var _javaMultipleFiles: Int32 = 0 @@ -5731,12 +5753,15 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _javaPackage: Int32 = 0 var _javaStringCheckUtf8: Int32 = 0 var _jsondecoder: Int32 = 0 + var _jsondecoding: Int32 = 0 var _jsondecodingError: Int32 = 0 var _jsondecodingOptions: Int32 = 0 var _jsonEncoder: Int32 = 0 + var _jsonencoding: Int32 = 0 var _jsonencodingError: Int32 = 0 var _jsonencodingOptions: Int32 = 0 var _jsonencodingVisitor: Int32 = 0 + var _jsonFormat: Int32 = 0 var _jsonmapEncodingVisitor: Int32 = 0 var _jsonName: Int32 = 0 var _jsonPath: Int32 = 0 @@ -5744,11 +5769,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _jsonscanner: Int32 = 0 var _jsonString: Int32 = 0 var _jsonText: Int32 = 0 + var _jsonUtf8Bytes: Int32 = 0 var _jsonUtf8Data: Int32 = 0 var _jstype: Int32 = 0 var _k: Int32 = 0 + var _kChunkSize: Int32 = 0 var _key: Int32 = 0 var _keyField: Int32 = 0 + var _keyFieldOpt: Int32 = 0 var _keyType: Int32 = 0 var _kind: Int32 = 0 var _l: Int32 = 0 @@ -5760,42 +5788,44 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _lessThan: Int32 = 0 var _let: Int32 = 0 var _lhs: Int32 = 0 + var _line: Int32 = 0 var _list: Int32 = 0 var _listOfMessages: Int32 = 0 var _listValue: Int32 = 0 var _littleEndian: Int32 = 0 - var _littleEndianBytes: Int32 = 0 var _load: Int32 = 0 var _localHasher: Int32 = 0 var _location: Int32 = 0 var _m: Int32 = 0 var _major: Int32 = 0 + var _makeAsyncIterator: Int32 = 0 var _makeIterator: Int32 = 0 + var _malformedLength: Int32 = 0 var _mapEntry: Int32 = 0 - var _mapHash: Int32 = 0 var _mapKeyType: Int32 = 0 - var _mapNameResolver: Int32 = 0 var _mapToMessages: Int32 = 0 var _mapValueType: Int32 = 0 var _mapVisitor: Int32 = 0 + var _mask: Int32 = 0 + var _maximumEdition: Int32 = 0 var _mdayStart: Int32 = 0 var _merge: Int32 = 0 + var _mergeOptions: Int32 = 0 var _message: Int32 = 0 var _messageDepthLimit: Int32 = 0 + var _messageEncoding: Int32 = 0 var _messageExtension: Int32 = 0 var _messageImplementationBase: Int32 = 0 - var _messageOptions: Int32 = 0 var _messageSet: Int32 = 0 var _messageSetWireFormat: Int32 = 0 + var _messageSize: Int32 = 0 var _messageType: Int32 = 0 var _method: Int32 = 0 - var _methodDescriptorProto: Int32 = 0 - var _methodOptions: Int32 = 0 var _methods: Int32 = 0 + var _min: Int32 = 0 + var _minimumEdition: Int32 = 0 var _minor: Int32 = 0 - var _mixin: Int32 = 0 var _mixins: Int32 = 0 - var _modifier: Int32 = 0 var _modify: Int32 = 0 var _month: Int32 = 0 var _msgExtension: Int32 = 0 @@ -5805,44 +5835,53 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _nameDescription: Int32 = 0 var _nameMap: Int32 = 0 var _namePart: Int32 = 0 - var _nameResolver: Int32 = 0 var _names: Int32 = 0 var _nanos: Int32 = 0 - var _nativeBytes: Int32 = 0 - var _nativeEndianBytes: Int32 = 0 var _negativeIntValue: Int32 = 0 var _nestedType: Int32 = 0 + var _newExtensible: Int32 = 0 var _newL: Int32 = 0 var _newList: Int32 = 0 + var _newMessage: Int32 = 0 var _newValue: Int32 = 0 + var _next: Int32 = 0 var _nextByte: Int32 = 0 var _nextFieldNumber: Int32 = 0 + var _nextInstruction: Int32 = 0 + var _nextInt32: Int32 = 0 + var _nextNullTerminatedString: Int32 = 0 + var _nextNullTerminatedStringArray: Int32 = 0 + var _nextNumber: Int32 = 0 + var _nextUint64: Int32 = 0 + var _nextVarInt: Int32 = 0 var _nil: Int32 = 0 var _nilLiteral: Int32 = 0 + var _noBytesAvailable: Int32 = 0 var _noStandardDescriptorAccessor: Int32 = 0 var _nullValue: Int32 = 0 var _number: Int32 = 0 var _numberValue: Int32 = 0 var _objcClassPrefix: Int32 = 0 var _of: Int32 = 0 + var _oneOfKind: Int32 = 0 var _oneofDecl: Int32 = 0 - var _oneofDescriptorProto: Int32 = 0 var _oneofIndex: Int32 = 0 - var _oneofOptions: Int32 = 0 var _oneofs: Int32 = 0 - var _oneOfKind: Int32 = 0 var _optimizeFor: Int32 = 0 var _optimizeMode: Int32 = 0 - var _option: Int32 = 0 var _optionalEnumExtensionField: Int32 = 0 var _optionalExtensionField: Int32 = 0 var _optionalGroupExtensionField: Int32 = 0 var _optionalMessageExtensionField: Int32 = 0 + var _optionDependency: Int32 = 0 + var _optionRetention: Int32 = 0 var _options: Int32 = 0 + var _optionTargetType: Int32 = 0 var _other: Int32 = 0 var _others: Int32 = 0 var _out: Int32 = 0 var _outputType: Int32 = 0 + var _overridableFeatures: Int32 = 0 var _p: Int32 = 0 var _package: Int32 = 0 var _packed: Int32 = 0 @@ -5853,27 +5892,39 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _parse: Int32 = 0 var _partial: Int32 = 0 var _path: Int32 = 0 + var _pathDecoder: Int32 = 0 + var _pathDecodingError: Int32 = 0 var _paths: Int32 = 0 + var _pathVisitor: Int32 = 0 var _payload: Int32 = 0 var _payloadSize: Int32 = 0 var _phpClassPrefix: Int32 = 0 - var _phpGenericServices: Int32 = 0 var _phpMetadataNamespace: Int32 = 0 var _phpNamespace: Int32 = 0 - var _pointer: Int32 = 0 var _pos: Int32 = 0 var _positiveIntValue: Int32 = 0 var _prefix: Int32 = 0 var _preserveProtoFieldNames: Int32 = 0 var _preTraverse: Int32 = 0 + var _previousNumber: Int32 = 0 + var _prevPath: Int32 = 0 var _printUnknownFields: Int32 = 0 + var _programBuffer: Int32 = 0 + var _programFormat: Int32 = 0 var _proto2: Int32 = 0 var _proto3DefaultValue: Int32 = 0 var _proto3Optional: Int32 = 0 - var _protobufApiversionCheck: Int32 = 0 + var _protobufExtensionFieldValues: Int32 = 0 + var _protobufFieldNumber: Int32 = 0 + var _protobufGeneratedIsEqualTo: Int32 = 0 + var _protobufNameMap: Int32 = 0 + var _protobufNewField: Int32 = 0 + var _protobufPackage: Int32 = 0 var _protobufApiversion2: Int32 = 0 + var _protobufApiversionCheck: Int32 = 0 var _protobufBool: Int32 = 0 var _protobufBytes: Int32 = 0 + var _protobufData: Int32 = 0 var _protobufDouble: Int32 = 0 var _protobufEnumMap: Int32 = 0 var _protobufExtension: Int32 = 0 @@ -5891,12 +5942,6 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _protobufString: Int32 = 0 var _protobufUint32: Int32 = 0 var _protobufUint64: Int32 = 0 - var _protobufExtensionFieldValues: Int32 = 0 - var _protobufFieldNumber: Int32 = 0 - var _protobufGeneratedIsEqualTo: Int32 = 0 - var _protobufNameMap: Int32 = 0 - var _protobufNewField: Int32 = 0 - var _protobufPackage: Int32 = 0 var _protocol: Int32 = 0 var _protoFieldName: Int32 = 0 var _protoMessageName: Int32 = 0 @@ -5918,25 +5963,33 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _putVarInt: Int32 = 0 var _putZigZagVarInt: Int32 = 0 var _pyGenericServices: Int32 = 0 + var _r: Int32 = 0 var _rawChars: Int32 = 0 var _rawRepresentable: Int32 = 0 var _rawValue: Int32 = 0 var _read4HexDigits: Int32 = 0 + var _readBytes: Int32 = 0 + var _reader: Int32 = 0 var _register: Int32 = 0 + var _remainingProgram: Int32 = 0 + var _removalError: Int32 = 0 + var _removingAllFieldsOf: Int32 = 0 + var _repeated: Int32 = 0 var _repeatedEnumExtensionField: Int32 = 0 var _repeatedExtensionField: Int32 = 0 + var _repeatedFieldEncoding: Int32 = 0 var _repeatedGroupExtensionField: Int32 = 0 var _repeatedMessageExtensionField: Int32 = 0 + var _repeating: Int32 = 0 + var _replaceRepeatedFields: Int32 = 0 var _requestStreaming: Int32 = 0 var _requestTypeURL: Int32 = 0 var _requiredSize: Int32 = 0 - var _reservedName: Int32 = 0 - var _reservedRange: Int32 = 0 var _responseStreaming: Int32 = 0 var _responseTypeURL: Int32 = 0 var _result: Int32 = 0 + var _retention: Int32 = 0 var _rethrows: Int32 = 0 - var _return: Int32 = 0 var _returnType: Int32 = 0 var _revision: Int32 = 0 var _rhs: Int32 = 0 @@ -5946,27 +5999,32 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _sawBackslash: Int32 = 0 var _sawSection4Characters: Int32 = 0 var _sawSection5Characters: Int32 = 0 + var _scalar: Int32 = 0 + var _scan: Int32 = 0 var _scanner: Int32 = 0 var _seconds: Int32 = 0 var _self_p: Int32 = 0 + var _semantic: Int32 = 0 + var _sendable: Int32 = 0 var _separator: Int32 = 0 var _serialize: Int32 = 0 + var _serializedBytes: Int32 = 0 var _serializedData: Int32 = 0 var _serializedSize: Int32 = 0 var _serverStreaming: Int32 = 0 var _service: Int32 = 0 - var _serviceDescriptorProto: Int32 = 0 - var _serviceOptions: Int32 = 0 var _set: Int32 = 0 var _setExtensionValue: Int32 = 0 var _shift: Int32 = 0 var _simpleExtensionMap: Int32 = 0 + var _size: Int32 = 0 var _sizer: Int32 = 0 var _source: Int32 = 0 var _sourceCodeInfo: Int32 = 0 var _sourceContext: Int32 = 0 var _sourceEncoding: Int32 = 0 var _sourceFile: Int32 = 0 + var _sourceLocation: Int32 = 0 var _span: Int32 = 0 var _split: Int32 = 0 var _start: Int32 = 0 @@ -5990,13 +6048,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _structValue: Int32 = 0 var _subDecoder: Int32 = 0 var _subscript: Int32 = 0 + var _subtract: Int32 = 0 var _subVisitor: Int32 = 0 var _swift: Int32 = 0 var _swiftPrefix: Int32 = 0 - var _swiftProtobuf: Int32 = 0 + var _swiftProtobufContiguousBytes: Int32 = 0 + var _swiftProtobufError: Int32 = 0 var _syntax: Int32 = 0 var _t: Int32 = 0 var _tag: Int32 = 0 + var _targets: Int32 = 0 var _terminator: Int32 = 0 var _testDecoder: Int32 = 0 var _text: Int32 = 0 @@ -6007,16 +6068,19 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _textFormatEncodingOptions: Int32 = 0 var _textFormatEncodingVisitor: Int32 = 0 var _textFormatString: Int32 = 0 + var _throwOrIgnore: Int32 = 0 var _throws: Int32 = 0 var _timeInterval: Int32 = 0 var _timeIntervalSince1970: Int32 = 0 var _timeIntervalSinceReferenceDate: Int32 = 0 - var _timestamp: Int32 = 0 + var _tmp: Int32 = 0 + var _tooLarge: Int32 = 0 var _total: Int32 = 0 var _totalArrayDepth: Int32 = 0 var _totalSize: Int32 = 0 var _trailingComments: Int32 = 0 var _traverse: Int32 = 0 + var _trim: Int32 = 0 var _true: Int32 = 0 var _try: Int32 = 0 var _type: Int32 = 0 @@ -6028,10 +6092,10 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _typeUnknown: Int32 = 0 var _typeURL: Int32 = 0 var _uint32: Int32 = 0 - var _uint32Value: Int32 = 0 var _uint64: Int32 = 0 - var _uint64Value: Int32 = 0 var _uint8: Int32 = 0 + var _unchecked: Int32 = 0 + var _unicode: Int32 = 0 var _unicodeScalarLiteral: Int32 = 0 var _unicodeScalarLiteralType: Int32 = 0 var _unicodeScalars: Int32 = 0 @@ -6046,14 +6110,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _unsafeBufferPointer: Int32 = 0 var _unsafeMutablePointer: Int32 = 0 var _unsafeMutableRawBufferPointer: Int32 = 0 - var _unsafeMutableRawPointer: Int32 = 0 var _unsafeRawBufferPointer: Int32 = 0 var _unsafeRawPointer: Int32 = 0 + var _unverifiedLazy: Int32 = 0 var _updatedOptions: Int32 = 0 + var _uppercasedAssumingAscii: Int32 = 0 var _url: Int32 = 0 + var _useDeterministicOrdering: Int32 = 0 var _utf8: Int32 = 0 var _utf8Ptr: Int32 = 0 var _utf8ToDouble: Int32 = 0 + var _utf8Validation: Int32 = 0 var _utf8View: Int32 = 0 var _v: Int32 = 0 var _value: Int32 = 0 @@ -6061,8 +6128,12 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _values: Int32 = 0 var _valueType: Int32 = 0 var _var: Int32 = 0 + var _verification: Int32 = 0 + var _verificationState: Int32 = 0 var _version: Int32 = 0 var _versionString: Int32 = 0 + var _visibility: Int32 = 0 + var _visibilityFeature: Int32 = 0 var _visitExtensionFields: Int32 = 0 var _visitExtensionFieldsAsMessageSet: Int32 = 0 var _visitMapField: Int32 = 0 @@ -6121,6 +6192,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _visitSingularUint32Field: Int32 = 0 var _visitSingularUint64Field: Int32 = 0 var _visitUnknown: Int32 = 0 + var _void: Int32 = 0 var _wasDecoded: Int32 = 0 var _weak: Int32 = 0 var _weakDependency: Int32 = 0 @@ -6130,27 +6202,35 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. var _withUnsafeBytes: Int32 = 0 var _withUnsafeMutableBytes: Int32 = 0 var _work: Int32 = 0 + var _wrapped: Int32 = 0 var _wrappedType: Int32 = 0 + var _wrappedValue: Int32 = 0 var _written: Int32 = 0 var _yday: Int32 = 0 - static let defaultInstance = _StorageClass() + // 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() private init() {} init(copying source: _StorageClass) { + _addPath = source._addPath _adjusted = source._adjusted _aggregateValue = source._aggregateValue _allCases = source._allCases _allowAlias = source._allowAlias _alwaysPrintEnumsAsInts = source._alwaysPrintEnumsAsInts + _alwaysPrintInt64SAsNumbers = source._alwaysPrintInt64SAsNumbers _annotation = source._annotation _any = source._any _anyExtensionField = source._anyExtensionField _anyMessageExtension = source._anyMessageExtension _anyMessageStorage = source._anyMessageStorage _anyUnpackError = source._anyUnpackError - _api = source._api + _append = source._append _appended = source._appended _appendUintHex = source._appendUintHex _appendUnknown = source._appendUnknown @@ -6162,14 +6242,20 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _as = source._as _asciiOpenCurlyBracket = source._asciiOpenCurlyBracket _asciiZero = source._asciiZero + _async = source._async + _asyncIterator = source._asyncIterator + _asyncIteratorProtocol = source._asyncIteratorProtocol + _asyncMessageSequence = source._asyncMessageSequence _available = source._available _b = source._b + _base = source._base _base64Values = source._base64Values _baseAddress = source._baseAddress _baseType = source._baseType _begin = source._begin _binary = source._binary _binaryDecoder = source._binaryDecoder + _binaryDecoding = source._binaryDecoding _binaryDecodingError = source._binaryDecodingError _binaryDecodingOptions = source._binaryDecodingOptions _binaryDelimited = source._binaryDelimited @@ -6177,25 +6263,39 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _binaryEncodingError = source._binaryEncodingError _binaryEncodingMessageSetSizeVisitor = source._binaryEncodingMessageSetSizeVisitor _binaryEncodingMessageSetVisitor = source._binaryEncodingMessageSetVisitor + _binaryEncodingOptions = source._binaryEncodingOptions _binaryEncodingSizeVisitor = source._binaryEncodingSizeVisitor _binaryEncodingVisitor = source._binaryEncodingVisitor _binaryOptions = source._binaryOptions + _binaryProtobufDelimitedMessages = source._binaryProtobufDelimitedMessages + _binaryStreamDecoding = source._binaryStreamDecoding + _binaryStreamDecodingError = source._binaryStreamDecodingError + _bitPattern = source._bitPattern _body = source._body _bool = source._bool _booleanLiteral = source._booleanLiteral _booleanLiteralType = source._booleanLiteralType _boolValue = source._boolValue + _buffer = source._buffer + _byte = source._byte + _bytecode = source._bytecode + _bytecodeReader = source._bytecodeReader _bytes = source._bytes _bytesInGroup = source._bytesInGroup + _bytesNeeded = source._bytesNeeded _bytesRead = source._bytesRead - _bytesValue = source._bytesValue _c = source._c + _canonical = source._canonical _capitalizeNext = source._capitalizeNext _cardinality = source._cardinality + _caseIterable = source._caseIterable + _castedValue = source._castedValue _ccEnableArenas = source._ccEnableArenas _ccGenericServices = source._ccGenericServices _character = source._character _chars = source._chars + _checkProgramFormat = source._checkProgramFormat + _chunk = source._chunk _class = source._class _clearAggregateValue_p = source._clearAggregateValue_p _clearAllowAlias_p = source._clearAllowAlias_p @@ -6205,12 +6305,27 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _clearClientStreaming_p = source._clearClientStreaming_p _clearCsharpNamespace_p = source._clearCsharpNamespace_p _clearCtype_p = source._clearCtype_p + _clearDebugRedact_p = source._clearDebugRedact_p + _clearDefaultSymbolVisibility_p = source._clearDefaultSymbolVisibility_p _clearDefaultValue_p = source._clearDefaultValue_p _clearDeprecated_p = source._clearDeprecated_p + _clearDeprecatedLegacyJsonFieldConflicts_p = source._clearDeprecatedLegacyJsonFieldConflicts_p + _clearDeprecationWarning_p = source._clearDeprecationWarning_p _clearDoubleValue_p = source._clearDoubleValue_p + _clearEdition_p = source._clearEdition_p + _clearEditionDeprecated_p = source._clearEditionDeprecated_p + _clearEditionIntroduced_p = source._clearEditionIntroduced_p + _clearEditionRemoved_p = source._clearEditionRemoved_p _clearEnd_p = source._clearEnd_p + _clearEnforceNamingStyle_p = source._clearEnforceNamingStyle_p + _clearEnumType_p = source._clearEnumType_p _clearExtendee_p = source._clearExtendee_p _clearExtensionValue_p = source._clearExtensionValue_p + _clearFeatures_p = source._clearFeatures_p + _clearFeatureSupport_p = source._clearFeatureSupport_p + _clearFieldPresence_p = source._clearFieldPresence_p + _clearFixedFeatures_p = source._clearFixedFeatures_p + _clearFullName_p = source._clearFullName_p _clearGoPackage_p = source._clearGoPackage_p _clearIdempotencyLevel_p = source._clearIdempotencyLevel_p _clearIdentifierValue_p = source._clearIdentifierValue_p @@ -6222,13 +6337,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _clearJavaOuterClassname_p = source._clearJavaOuterClassname_p _clearJavaPackage_p = source._clearJavaPackage_p _clearJavaStringCheckUtf8_p = source._clearJavaStringCheckUtf8_p + _clearJsonFormat_p = source._clearJsonFormat_p _clearJsonName_p = source._clearJsonName_p _clearJstype_p = source._clearJstype_p _clearLabel_p = source._clearLabel_p _clearLazy_p = source._clearLazy_p _clearLeadingComments_p = source._clearLeadingComments_p _clearMapEntry_p = source._clearMapEntry_p + _clearMaximumEdition_p = source._clearMaximumEdition_p + _clearMessageEncoding_p = source._clearMessageEncoding_p _clearMessageSetWireFormat_p = source._clearMessageSetWireFormat_p + _clearMinimumEdition_p = source._clearMinimumEdition_p _clearName_p = source._clearName_p _clearNamePart_p = source._clearNamePart_p _clearNegativeIntValue_p = source._clearNegativeIntValue_p @@ -6239,16 +6358,22 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _clearOptimizeFor_p = source._clearOptimizeFor_p _clearOptions_p = source._clearOptions_p _clearOutputType_p = source._clearOutputType_p + _clearOverridableFeatures_p = source._clearOverridableFeatures_p _clearPackage_p = source._clearPackage_p _clearPacked_p = source._clearPacked_p _clearPhpClassPrefix_p = source._clearPhpClassPrefix_p - _clearPhpGenericServices_p = source._clearPhpGenericServices_p _clearPhpMetadataNamespace_p = source._clearPhpMetadataNamespace_p _clearPhpNamespace_p = source._clearPhpNamespace_p _clearPositiveIntValue_p = source._clearPositiveIntValue_p _clearProto3Optional_p = source._clearProto3Optional_p _clearPyGenericServices_p = source._clearPyGenericServices_p + _clearRemovalError_p = source._clearRemovalError_p + _clearRepeated_p = source._clearRepeated_p + _clearRepeatedFieldEncoding_p = source._clearRepeatedFieldEncoding_p + _clearReserved_p = source._clearReserved_p + _clearRetention_p = source._clearRetention_p _clearRubyPackage_p = source._clearRubyPackage_p + _clearSemantic_p = source._clearSemantic_p _clearServerStreaming_p = source._clearServerStreaming_p _clearSourceCodeInfo_p = source._clearSourceCodeInfo_p _clearSourceContext_p = source._clearSourceContext_p @@ -6260,22 +6385,30 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _clearTrailingComments_p = source._clearTrailingComments_p _clearType_p = source._clearType_p _clearTypeName_p = source._clearTypeName_p + _clearUnverifiedLazy_p = source._clearUnverifiedLazy_p + _clearUtf8Validation_p = source._clearUtf8Validation_p _clearValue_p = source._clearValue_p + _clearVerification_p = source._clearVerification_p + _clearVisibility_p = source._clearVisibility_p _clearWeak_p = source._clearWeak_p _clientStreaming = source._clientStreaming + _code = source._code _codePoint = source._codePoint _codeUnits = source._codeUnits _collection = source._collection - _com = source._com _comma = source._comma + _consumedBytes = source._consumedBytes + _contains = source._contains _contentsOf = source._contentsOf _contiguousBytes = source._contiguousBytes + _copy = source._copy _count = source._count _countVarintsInBuffer = source._countVarintsInBuffer _csharpNamespace = source._csharpNamespace _ctype = source._ctype _customCodable = source._customCodable _customDebugStringConvertible = source._customDebugStringConvertible + _customStringConvertible = source._customStringConvertible _d = source._d _data = source._data _dataResult = source._dataResult @@ -6283,6 +6416,8 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _daySec = source._daySec _daysSinceEpoch = source._daysSinceEpoch _debugDescription_p = source._debugDescription_p + _debugRedact = source._debugRedact + _declaration = source._declaration _decoded = source._decoded _decodedFromJsonnull = source._decodedFromJsonnull _decodeExtensionField = source._decodeExtensionField @@ -6331,11 +6466,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _decodeSingularUint64Field = source._decodeSingularUint64Field _decodeTextFormat = source._decodeTextFormat _defaultAnyTypeUrlprefix = source._defaultAnyTypeUrlprefix + _defaults = source._defaults + _defaultSymbolVisibility = source._defaultSymbolVisibility _defaultValue = source._defaultValue _dependency = source._dependency _deprecated = source._deprecated + _deprecatedLegacyJsonFieldConflicts = source._deprecatedLegacyJsonFieldConflicts + _deprecationWarning = source._deprecationWarning _description_p = source._description_p - _descriptorProto = source._descriptorProto _dictionary = source._dictionary _dictionaryLiteral = source._dictionaryLiteral _digit = source._digit @@ -6346,17 +6484,23 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _digitValue = source._digitValue _discardableResult = source._discardableResult _discardUnknownFields = source._discardUnknownFields - _distance = source._distance _double = source._double _doubleValue = source._doubleValue _duration = source._duration _e = source._e + _edition = source._edition + _editionDefault = source._editionDefault + _editionDefaults = source._editionDefaults + _editionDeprecated = source._editionDeprecated + _editionIntroduced = source._editionIntroduced + _editionRemoved = source._editionRemoved _element = source._element _elements = source._elements + _else = source._else _emitExtensionFieldName = source._emitExtensionFieldName _emitFieldName = source._emitFieldName _emitFieldNumber = source._emitFieldNumber - _empty = source._empty + _emptyAnyTypeURL = source._emptyAnyTypeURL _emptyData = source._emptyData _encodeAsBytes = source._encodeAsBytes _encoded = source._encoded @@ -6369,16 +6513,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _endMessageField = source._endMessageField _endObject = source._endObject _endRegularField = source._endRegularField + _enforceNamingStyle = source._enforceNamingStyle _enum = source._enum - _enumDescriptorProto = source._enumDescriptorProto - _enumOptions = source._enumOptions _enumReservedRange = source._enumReservedRange _enumType = source._enumType _enumvalue = source._enumvalue - _enumValueDescriptorProto = source._enumValueDescriptorProto - _enumValueOptions = source._enumValueOptions _equatable = source._equatable _error = source._error + _execute = source._execute _expressibleByArrayLiteral = source._expressibleByArrayLiteral _expressibleByDictionaryLiteral = source._expressibleByDictionaryLiteral _ext = source._ext @@ -6393,37 +6535,38 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _extensionFieldValueSet = source._extensionFieldValueSet _extensionMap = source._extensionMap _extensionRange = source._extensionRange - _extensionRangeOptions = source._extensionRangeOptions _extensions = source._extensions _extras = source._extras _f = source._f _false = source._false + _features = source._features + _featureSetEditionDefault = source._featureSetEditionDefault + _featureSupport = source._featureSupport _field = source._field _fieldData = source._fieldData - _fieldDescriptorProto = source._fieldDescriptorProto - _fieldMask = source._fieldMask + _fieldMaskError = source._fieldMaskError _fieldName = source._fieldName _fieldNameCount = source._fieldNameCount _fieldNum = source._fieldNum _fieldNumber = source._fieldNumber _fieldNumberForProto = source._fieldNumberForProto - _fieldOptions = source._fieldOptions + _fieldPresence = source._fieldPresence _fields = source._fields _fieldSize = source._fieldSize _fieldTag = source._fieldTag _fieldType = source._fieldType _file = source._file - _fileDescriptorProto = source._fileDescriptorProto - _fileDescriptorSet = source._fileDescriptorSet _fileName = source._fileName - _fileOptions = source._fileOptions _filter = source._filter + _final = source._final + _finiteOnly = source._finiteOnly _first = source._first _firstItem = source._firstItem + _fixedFeatures = source._fixedFeatures _float = source._float _floatLiteral = source._floatLiteral _floatLiteralType = source._floatLiteralType - _floatValue = source._floatValue + _for = source._for _forMessageName = source._forMessageName _formUnion = source._formUnion _forReadingFrom = source._forReadingFrom @@ -6435,12 +6578,12 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _fromAscii4 = source._fromAscii4 _fromByteOffset = source._fromByteOffset _fromHexDigit = source._fromHexDigit + _fullName = source._fullName _func = source._func + _function = source._function _g = source._g - _generatedCodeInfo = source._generatedCodeInfo _get = source._get _getExtensionValue = source._getExtensionValue - _googleapis = source._googleapis _googleProtobufAny = source._googleProtobufAny _googleProtobufApi = source._googleProtobufApi _googleProtobufBoolValue = source._googleProtobufBoolValue @@ -6448,6 +6591,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _googleProtobufDescriptorProto = source._googleProtobufDescriptorProto _googleProtobufDoubleValue = source._googleProtobufDoubleValue _googleProtobufDuration = source._googleProtobufDuration + _googleProtobufEdition = source._googleProtobufEdition _googleProtobufEmpty = source._googleProtobufEmpty _googleProtobufEnum = source._googleProtobufEnum _googleProtobufEnumDescriptorProto = source._googleProtobufEnumDescriptorProto @@ -6456,6 +6600,8 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _googleProtobufEnumValueDescriptorProto = source._googleProtobufEnumValueDescriptorProto _googleProtobufEnumValueOptions = source._googleProtobufEnumValueOptions _googleProtobufExtensionRangeOptions = source._googleProtobufExtensionRangeOptions + _googleProtobufFeatureSet = source._googleProtobufFeatureSet + _googleProtobufFeatureSetDefaults = source._googleProtobufFeatureSetDefaults _googleProtobufField = source._googleProtobufField _googleProtobufFieldDescriptorProto = source._googleProtobufFieldDescriptorProto _googleProtobufFieldMask = source._googleProtobufFieldMask @@ -6483,6 +6629,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _googleProtobufSourceContext = source._googleProtobufSourceContext _googleProtobufStringValue = source._googleProtobufStringValue _googleProtobufStruct = source._googleProtobufStruct + _googleProtobufSymbolVisibility = source._googleProtobufSymbolVisibility _googleProtobufSyntax = source._googleProtobufSyntax _googleProtobufTimestamp = source._googleProtobufTimestamp _googleProtobufType = source._googleProtobufType @@ -6491,12 +6638,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _googleProtobufUninterpretedOption = source._googleProtobufUninterpretedOption _googleProtobufValue = source._googleProtobufValue _goPackage = source._goPackage + _gotData = source._gotData _group = source._group _groupFieldNumberStack = source._groupFieldNumberStack _groupSize = source._groupSize - _h = source._h + _guard = source._guard _hadOneofValue = source._hadOneofValue _handleConflictingOneOf = source._handleConflictingOneOf + _handleInstruction = source._handleInstruction _hasAggregateValue_p = source._hasAggregateValue_p _hasAllowAlias_p = source._hasAllowAlias_p _hasBegin_p = source._hasBegin_p @@ -6505,17 +6654,33 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _hasClientStreaming_p = source._hasClientStreaming_p _hasCsharpNamespace_p = source._hasCsharpNamespace_p _hasCtype_p = source._hasCtype_p + _hasData_p = source._hasData_p + _hasDebugRedact_p = source._hasDebugRedact_p + _hasDefaultSymbolVisibility_p = source._hasDefaultSymbolVisibility_p _hasDefaultValue_p = source._hasDefaultValue_p _hasDeprecated_p = source._hasDeprecated_p + _hasDeprecatedLegacyJsonFieldConflicts_p = source._hasDeprecatedLegacyJsonFieldConflicts_p + _hasDeprecationWarning_p = source._hasDeprecationWarning_p _hasDoubleValue_p = source._hasDoubleValue_p + _hasEdition_p = source._hasEdition_p + _hasEditionDeprecated_p = source._hasEditionDeprecated_p + _hasEditionIntroduced_p = source._hasEditionIntroduced_p + _hasEditionRemoved_p = source._hasEditionRemoved_p _hasEnd_p = source._hasEnd_p + _hasEnforceNamingStyle_p = source._hasEnforceNamingStyle_p + _hasEnumType_p = source._hasEnumType_p + _hasExplicitDelta_p = source._hasExplicitDelta_p _hasExtendee_p = source._hasExtendee_p _hasExtensionValue_p = source._hasExtensionValue_p + _hasFeatures_p = source._hasFeatures_p + _hasFeatureSupport_p = source._hasFeatureSupport_p + _hasFieldPresence_p = source._hasFieldPresence_p + _hasFixedFeatures_p = source._hasFixedFeatures_p + _hasFullName_p = source._hasFullName_p _hasGoPackage_p = source._hasGoPackage_p _hash = source._hash _hashable = source._hashable _hasher = source._hasher - _hashValue_p = source._hashValue_p _hashVisitor = source._hashVisitor _hasIdempotencyLevel_p = source._hasIdempotencyLevel_p _hasIdentifierValue_p = source._hasIdentifierValue_p @@ -6527,13 +6692,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _hasJavaOuterClassname_p = source._hasJavaOuterClassname_p _hasJavaPackage_p = source._hasJavaPackage_p _hasJavaStringCheckUtf8_p = source._hasJavaStringCheckUtf8_p + _hasJsonFormat_p = source._hasJsonFormat_p _hasJsonName_p = source._hasJsonName_p _hasJstype_p = source._hasJstype_p _hasLabel_p = source._hasLabel_p _hasLazy_p = source._hasLazy_p _hasLeadingComments_p = source._hasLeadingComments_p _hasMapEntry_p = source._hasMapEntry_p + _hasMaximumEdition_p = source._hasMaximumEdition_p + _hasMessageEncoding_p = source._hasMessageEncoding_p _hasMessageSetWireFormat_p = source._hasMessageSetWireFormat_p + _hasMinimumEdition_p = source._hasMinimumEdition_p _hasName_p = source._hasName_p _hasNamePart_p = source._hasNamePart_p _hasNegativeIntValue_p = source._hasNegativeIntValue_p @@ -6544,16 +6713,22 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _hasOptimizeFor_p = source._hasOptimizeFor_p _hasOptions_p = source._hasOptions_p _hasOutputType_p = source._hasOutputType_p + _hasOverridableFeatures_p = source._hasOverridableFeatures_p _hasPackage_p = source._hasPackage_p _hasPacked_p = source._hasPacked_p _hasPhpClassPrefix_p = source._hasPhpClassPrefix_p - _hasPhpGenericServices_p = source._hasPhpGenericServices_p _hasPhpMetadataNamespace_p = source._hasPhpMetadataNamespace_p _hasPhpNamespace_p = source._hasPhpNamespace_p _hasPositiveIntValue_p = source._hasPositiveIntValue_p _hasProto3Optional_p = source._hasProto3Optional_p _hasPyGenericServices_p = source._hasPyGenericServices_p + _hasRemovalError_p = source._hasRemovalError_p + _hasRepeated_p = source._hasRepeated_p + _hasRepeatedFieldEncoding_p = source._hasRepeatedFieldEncoding_p + _hasReserved_p = source._hasReserved_p + _hasRetention_p = source._hasRetention_p _hasRubyPackage_p = source._hasRubyPackage_p + _hasSemantic_p = source._hasSemantic_p _hasServerStreaming_p = source._hasServerStreaming_p _hasSourceCodeInfo_p = source._hasSourceCodeInfo_p _hasSourceContext_p = source._hasSourceContext_p @@ -6565,40 +6740,49 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _hasTrailingComments_p = source._hasTrailingComments_p _hasType_p = source._hasType_p _hasTypeName_p = source._hasTypeName_p + _hasUnverifiedLazy_p = source._hasUnverifiedLazy_p + _hasUtf8Validation_p = source._hasUtf8Validation_p _hasValue_p = source._hasValue_p + _hasVerification_p = source._hasVerification_p + _hasVisibility_p = source._hasVisibility_p _hasWeak_p = source._hasWeak_p _hour = source._hour _i = source._i _idempotencyLevel = source._idempotencyLevel _identifierValue = source._identifierValue _if = source._if + _ignoreUnknownExtensionFields = source._ignoreUnknownExtensionFields _ignoreUnknownFields = source._ignoreUnknownFields _index = source._index _init_p = source._init_p _inout = source._inout _inputType = source._inputType _insert = source._insert + _instruction = source._instruction _int = source._int _int32 = source._int32 - _int32Value = source._int32Value _int64 = source._int64 - _int64Value = source._int64Value _int8 = source._int8 _integerLiteral = source._integerLiteral _integerLiteralType = source._integerLiteralType _intern = source._intern _internal = source._internal _internalState = source._internalState + _intersect = source._intersect _into = source._into _ints = source._ints + _invalidAnyTypeURL = source._invalidAnyTypeURL _isA = source._isA _isEqual = source._isEqual _isEqualTo = source._isEqualTo _isExtension = source._isExtension _isInitialized_p = source._isInitialized_p + _isNegative = source._isNegative + _isPathValid = source._isPathValid + _isReserved = source._isReserved + _isValid = source._isValid _itemTagsEncodedSize = source._itemTagsEncodedSize _iterator = source._iterator - _i2166136261 = source._i2166136261 _javaGenerateEqualsAndHash = source._javaGenerateEqualsAndHash _javaGenericServices = source._javaGenericServices _javaMultipleFiles = source._javaMultipleFiles @@ -6606,12 +6790,15 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _javaPackage = source._javaPackage _javaStringCheckUtf8 = source._javaStringCheckUtf8 _jsondecoder = source._jsondecoder + _jsondecoding = source._jsondecoding _jsondecodingError = source._jsondecodingError _jsondecodingOptions = source._jsondecodingOptions _jsonEncoder = source._jsonEncoder + _jsonencoding = source._jsonencoding _jsonencodingError = source._jsonencodingError _jsonencodingOptions = source._jsonencodingOptions _jsonencodingVisitor = source._jsonencodingVisitor + _jsonFormat = source._jsonFormat _jsonmapEncodingVisitor = source._jsonmapEncodingVisitor _jsonName = source._jsonName _jsonPath = source._jsonPath @@ -6619,11 +6806,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _jsonscanner = source._jsonscanner _jsonString = source._jsonString _jsonText = source._jsonText + _jsonUtf8Bytes = source._jsonUtf8Bytes _jsonUtf8Data = source._jsonUtf8Data _jstype = source._jstype _k = source._k + _kChunkSize = source._kChunkSize _key = source._key _keyField = source._keyField + _keyFieldOpt = source._keyFieldOpt _keyType = source._keyType _kind = source._kind _l = source._l @@ -6635,42 +6825,44 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _lessThan = source._lessThan _let = source._let _lhs = source._lhs + _line = source._line _list = source._list _listOfMessages = source._listOfMessages _listValue = source._listValue _littleEndian = source._littleEndian - _littleEndianBytes = source._littleEndianBytes _load = source._load _localHasher = source._localHasher _location = source._location _m = source._m _major = source._major + _makeAsyncIterator = source._makeAsyncIterator _makeIterator = source._makeIterator + _malformedLength = source._malformedLength _mapEntry = source._mapEntry - _mapHash = source._mapHash _mapKeyType = source._mapKeyType - _mapNameResolver = source._mapNameResolver _mapToMessages = source._mapToMessages _mapValueType = source._mapValueType _mapVisitor = source._mapVisitor + _mask = source._mask + _maximumEdition = source._maximumEdition _mdayStart = source._mdayStart _merge = source._merge + _mergeOptions = source._mergeOptions _message = source._message _messageDepthLimit = source._messageDepthLimit + _messageEncoding = source._messageEncoding _messageExtension = source._messageExtension _messageImplementationBase = source._messageImplementationBase - _messageOptions = source._messageOptions _messageSet = source._messageSet _messageSetWireFormat = source._messageSetWireFormat + _messageSize = source._messageSize _messageType = source._messageType _method = source._method - _methodDescriptorProto = source._methodDescriptorProto - _methodOptions = source._methodOptions _methods = source._methods + _min = source._min + _minimumEdition = source._minimumEdition _minor = source._minor - _mixin = source._mixin _mixins = source._mixins - _modifier = source._modifier _modify = source._modify _month = source._month _msgExtension = source._msgExtension @@ -6680,44 +6872,53 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _nameDescription = source._nameDescription _nameMap = source._nameMap _namePart = source._namePart - _nameResolver = source._nameResolver _names = source._names _nanos = source._nanos - _nativeBytes = source._nativeBytes - _nativeEndianBytes = source._nativeEndianBytes _negativeIntValue = source._negativeIntValue _nestedType = source._nestedType + _newExtensible = source._newExtensible _newL = source._newL _newList = source._newList + _newMessage = source._newMessage _newValue = source._newValue + _next = source._next _nextByte = source._nextByte _nextFieldNumber = source._nextFieldNumber + _nextInstruction = source._nextInstruction + _nextInt32 = source._nextInt32 + _nextNullTerminatedString = source._nextNullTerminatedString + _nextNullTerminatedStringArray = source._nextNullTerminatedStringArray + _nextNumber = source._nextNumber + _nextUint64 = source._nextUint64 + _nextVarInt = source._nextVarInt _nil = source._nil _nilLiteral = source._nilLiteral + _noBytesAvailable = source._noBytesAvailable _noStandardDescriptorAccessor = source._noStandardDescriptorAccessor _nullValue = source._nullValue _number = source._number _numberValue = source._numberValue _objcClassPrefix = source._objcClassPrefix _of = source._of + _oneOfKind = source._oneOfKind _oneofDecl = source._oneofDecl - _oneofDescriptorProto = source._oneofDescriptorProto _oneofIndex = source._oneofIndex - _oneofOptions = source._oneofOptions _oneofs = source._oneofs - _oneOfKind = source._oneOfKind _optimizeFor = source._optimizeFor _optimizeMode = source._optimizeMode - _option = source._option _optionalEnumExtensionField = source._optionalEnumExtensionField _optionalExtensionField = source._optionalExtensionField _optionalGroupExtensionField = source._optionalGroupExtensionField _optionalMessageExtensionField = source._optionalMessageExtensionField + _optionDependency = source._optionDependency + _optionRetention = source._optionRetention _options = source._options + _optionTargetType = source._optionTargetType _other = source._other _others = source._others _out = source._out _outputType = source._outputType + _overridableFeatures = source._overridableFeatures _p = source._p _package = source._package _packed = source._packed @@ -6728,27 +6929,39 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _parse = source._parse _partial = source._partial _path = source._path + _pathDecoder = source._pathDecoder + _pathDecodingError = source._pathDecodingError _paths = source._paths + _pathVisitor = source._pathVisitor _payload = source._payload _payloadSize = source._payloadSize _phpClassPrefix = source._phpClassPrefix - _phpGenericServices = source._phpGenericServices _phpMetadataNamespace = source._phpMetadataNamespace _phpNamespace = source._phpNamespace - _pointer = source._pointer _pos = source._pos _positiveIntValue = source._positiveIntValue _prefix = source._prefix _preserveProtoFieldNames = source._preserveProtoFieldNames _preTraverse = source._preTraverse + _previousNumber = source._previousNumber + _prevPath = source._prevPath _printUnknownFields = source._printUnknownFields + _programBuffer = source._programBuffer + _programFormat = source._programFormat _proto2 = source._proto2 _proto3DefaultValue = source._proto3DefaultValue _proto3Optional = source._proto3Optional - _protobufApiversionCheck = source._protobufApiversionCheck + _protobufExtensionFieldValues = source._protobufExtensionFieldValues + _protobufFieldNumber = source._protobufFieldNumber + _protobufGeneratedIsEqualTo = source._protobufGeneratedIsEqualTo + _protobufNameMap = source._protobufNameMap + _protobufNewField = source._protobufNewField + _protobufPackage = source._protobufPackage _protobufApiversion2 = source._protobufApiversion2 + _protobufApiversionCheck = source._protobufApiversionCheck _protobufBool = source._protobufBool _protobufBytes = source._protobufBytes + _protobufData = source._protobufData _protobufDouble = source._protobufDouble _protobufEnumMap = source._protobufEnumMap _protobufExtension = source._protobufExtension @@ -6766,12 +6979,6 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _protobufString = source._protobufString _protobufUint32 = source._protobufUint32 _protobufUint64 = source._protobufUint64 - _protobufExtensionFieldValues = source._protobufExtensionFieldValues - _protobufFieldNumber = source._protobufFieldNumber - _protobufGeneratedIsEqualTo = source._protobufGeneratedIsEqualTo - _protobufNameMap = source._protobufNameMap - _protobufNewField = source._protobufNewField - _protobufPackage = source._protobufPackage _protocol = source._protocol _protoFieldName = source._protoFieldName _protoMessageName = source._protoMessageName @@ -6793,25 +7000,33 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _putVarInt = source._putVarInt _putZigZagVarInt = source._putZigZagVarInt _pyGenericServices = source._pyGenericServices + _r = source._r _rawChars = source._rawChars _rawRepresentable = source._rawRepresentable _rawValue = source._rawValue _read4HexDigits = source._read4HexDigits + _readBytes = source._readBytes + _reader = source._reader _register = source._register + _remainingProgram = source._remainingProgram + _removalError = source._removalError + _removingAllFieldsOf = source._removingAllFieldsOf + _repeated = source._repeated _repeatedEnumExtensionField = source._repeatedEnumExtensionField _repeatedExtensionField = source._repeatedExtensionField + _repeatedFieldEncoding = source._repeatedFieldEncoding _repeatedGroupExtensionField = source._repeatedGroupExtensionField _repeatedMessageExtensionField = source._repeatedMessageExtensionField + _repeating = source._repeating + _replaceRepeatedFields = source._replaceRepeatedFields _requestStreaming = source._requestStreaming _requestTypeURL = source._requestTypeURL _requiredSize = source._requiredSize - _reservedName = source._reservedName - _reservedRange = source._reservedRange _responseStreaming = source._responseStreaming _responseTypeURL = source._responseTypeURL _result = source._result + _retention = source._retention _rethrows = source._rethrows - _return = source._return _returnType = source._returnType _revision = source._revision _rhs = source._rhs @@ -6821,27 +7036,32 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _sawBackslash = source._sawBackslash _sawSection4Characters = source._sawSection4Characters _sawSection5Characters = source._sawSection5Characters + _scalar = source._scalar + _scan = source._scan _scanner = source._scanner _seconds = source._seconds _self_p = source._self_p + _semantic = source._semantic + _sendable = source._sendable _separator = source._separator _serialize = source._serialize + _serializedBytes = source._serializedBytes _serializedData = source._serializedData _serializedSize = source._serializedSize _serverStreaming = source._serverStreaming _service = source._service - _serviceDescriptorProto = source._serviceDescriptorProto - _serviceOptions = source._serviceOptions _set = source._set _setExtensionValue = source._setExtensionValue _shift = source._shift _simpleExtensionMap = source._simpleExtensionMap + _size = source._size _sizer = source._sizer _source = source._source _sourceCodeInfo = source._sourceCodeInfo _sourceContext = source._sourceContext _sourceEncoding = source._sourceEncoding _sourceFile = source._sourceFile + _sourceLocation = source._sourceLocation _span = source._span _split = source._split _start = source._start @@ -6865,13 +7085,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _structValue = source._structValue _subDecoder = source._subDecoder _subscript = source._subscript + _subtract = source._subtract _subVisitor = source._subVisitor _swift = source._swift _swiftPrefix = source._swiftPrefix - _swiftProtobuf = source._swiftProtobuf + _swiftProtobufContiguousBytes = source._swiftProtobufContiguousBytes + _swiftProtobufError = source._swiftProtobufError _syntax = source._syntax _t = source._t _tag = source._tag + _targets = source._targets _terminator = source._terminator _testDecoder = source._testDecoder _text = source._text @@ -6882,16 +7105,19 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _textFormatEncodingOptions = source._textFormatEncodingOptions _textFormatEncodingVisitor = source._textFormatEncodingVisitor _textFormatString = source._textFormatString + _throwOrIgnore = source._throwOrIgnore _throws = source._throws _timeInterval = source._timeInterval _timeIntervalSince1970 = source._timeIntervalSince1970 _timeIntervalSinceReferenceDate = source._timeIntervalSinceReferenceDate - _timestamp = source._timestamp + _tmp = source._tmp + _tooLarge = source._tooLarge _total = source._total _totalArrayDepth = source._totalArrayDepth _totalSize = source._totalSize _trailingComments = source._trailingComments _traverse = source._traverse + _trim = source._trim _true = source._true _try = source._try _type = source._type @@ -6903,10 +7129,10 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _typeUnknown = source._typeUnknown _typeURL = source._typeURL _uint32 = source._uint32 - _uint32Value = source._uint32Value _uint64 = source._uint64 - _uint64Value = source._uint64Value _uint8 = source._uint8 + _unchecked = source._unchecked + _unicode = source._unicode _unicodeScalarLiteral = source._unicodeScalarLiteral _unicodeScalarLiteralType = source._unicodeScalarLiteralType _unicodeScalars = source._unicodeScalars @@ -6921,14 +7147,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _unsafeBufferPointer = source._unsafeBufferPointer _unsafeMutablePointer = source._unsafeMutablePointer _unsafeMutableRawBufferPointer = source._unsafeMutableRawBufferPointer - _unsafeMutableRawPointer = source._unsafeMutableRawPointer _unsafeRawBufferPointer = source._unsafeRawBufferPointer _unsafeRawPointer = source._unsafeRawPointer + _unverifiedLazy = source._unverifiedLazy _updatedOptions = source._updatedOptions + _uppercasedAssumingAscii = source._uppercasedAssumingAscii _url = source._url + _useDeterministicOrdering = source._useDeterministicOrdering _utf8 = source._utf8 _utf8Ptr = source._utf8Ptr _utf8ToDouble = source._utf8ToDouble + _utf8Validation = source._utf8Validation _utf8View = source._utf8View _v = source._v _value = source._value @@ -6936,8 +7165,12 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _values = source._values _valueType = source._valueType _var = source._var + _verification = source._verification + _verificationState = source._verificationState _version = source._version _versionString = source._versionString + _visibility = source._visibility + _visibilityFeature = source._visibilityFeature _visitExtensionFields = source._visitExtensionFields _visitExtensionFieldsAsMessageSet = source._visitExtensionFieldsAsMessageSet _visitMapField = source._visitMapField @@ -6996,6 +7229,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _visitSingularUint32Field = source._visitSingularUint32Field _visitSingularUint64Field = source._visitSingularUint64Field _visitUnknown = source._visitUnknown + _void = source._void _wasDecoded = source._wasDecoded _weak = source._weak _weakDependency = source._weakDependency @@ -7005,7 +7239,9 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. _withUnsafeBytes = source._withUnsafeBytes _withUnsafeMutableBytes = source._withUnsafeMutableBytes _work = source._work + _wrapped = source._wrapped _wrappedType = source._wrappedType + _wrappedValue = source._wrappedValue _written = source._written _yday = source._yday } @@ -7026,875 +7262,1033 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. // 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._adjusted) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._aggregateValue) }() - case 3: try { try decoder.decodeSingularInt32Field(value: &_storage._allCases) }() - case 4: try { try decoder.decodeSingularInt32Field(value: &_storage._allowAlias) }() - case 5: try { try decoder.decodeSingularInt32Field(value: &_storage._alwaysPrintEnumsAsInts) }() - case 6: try { try decoder.decodeSingularInt32Field(value: &_storage._annotation) }() - case 7: try { try decoder.decodeSingularInt32Field(value: &_storage._any) }() - case 8: try { try decoder.decodeSingularInt32Field(value: &_storage._anyExtensionField) }() - case 9: try { try decoder.decodeSingularInt32Field(value: &_storage._anyMessageExtension) }() - case 10: try { try decoder.decodeSingularInt32Field(value: &_storage._anyMessageStorage) }() - case 11: try { try decoder.decodeSingularInt32Field(value: &_storage._anyUnpackError) }() - case 12: try { try decoder.decodeSingularInt32Field(value: &_storage._api) }() - case 13: try { try decoder.decodeSingularInt32Field(value: &_storage._appended) }() - case 14: try { try decoder.decodeSingularInt32Field(value: &_storage._appendUintHex) }() - case 15: try { try decoder.decodeSingularInt32Field(value: &_storage._appendUnknown) }() - case 16: try { try decoder.decodeSingularInt32Field(value: &_storage._areAllInitialized) }() - case 17: try { try decoder.decodeSingularInt32Field(value: &_storage._array) }() - case 18: try { try decoder.decodeSingularInt32Field(value: &_storage._arrayDepth) }() - case 19: try { try decoder.decodeSingularInt32Field(value: &_storage._arrayLiteral) }() - case 20: try { try decoder.decodeSingularInt32Field(value: &_storage._arraySeparator) }() - case 21: try { try decoder.decodeSingularInt32Field(value: &_storage._as) }() - case 22: try { try decoder.decodeSingularInt32Field(value: &_storage._asciiOpenCurlyBracket) }() - case 23: try { try decoder.decodeSingularInt32Field(value: &_storage._asciiZero) }() - case 24: try { try decoder.decodeSingularInt32Field(value: &_storage._available) }() - case 25: try { try decoder.decodeSingularInt32Field(value: &_storage._b) }() - case 26: try { try decoder.decodeSingularInt32Field(value: &_storage._base64Values) }() - case 27: try { try decoder.decodeSingularInt32Field(value: &_storage._baseAddress) }() - case 28: try { try decoder.decodeSingularInt32Field(value: &_storage._baseType) }() - case 29: try { try decoder.decodeSingularInt32Field(value: &_storage._begin) }() - case 30: try { try decoder.decodeSingularInt32Field(value: &_storage._binary) }() - case 31: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryDecoder) }() - case 32: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryDecodingError) }() - case 33: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryDecodingOptions) }() - case 34: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryDelimited) }() - case 35: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncoder) }() - case 36: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingError) }() - case 37: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingMessageSetSizeVisitor) }() - case 38: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingMessageSetVisitor) }() - case 39: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingSizeVisitor) }() - case 40: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingVisitor) }() - case 41: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryOptions) }() - case 42: try { try decoder.decodeSingularInt32Field(value: &_storage._body) }() - case 43: try { try decoder.decodeSingularInt32Field(value: &_storage._bool) }() - case 44: try { try decoder.decodeSingularInt32Field(value: &_storage._booleanLiteral) }() - case 45: try { try decoder.decodeSingularInt32Field(value: &_storage._booleanLiteralType) }() - case 46: try { try decoder.decodeSingularInt32Field(value: &_storage._boolValue) }() - case 47: try { try decoder.decodeSingularInt32Field(value: &_storage._bytes) }() - case 48: try { try decoder.decodeSingularInt32Field(value: &_storage._bytesInGroup) }() - case 49: try { try decoder.decodeSingularInt32Field(value: &_storage._bytesRead) }() - case 50: try { try decoder.decodeSingularInt32Field(value: &_storage._bytesValue) }() - case 51: try { try decoder.decodeSingularInt32Field(value: &_storage._c) }() - case 52: try { try decoder.decodeSingularInt32Field(value: &_storage._capitalizeNext) }() - case 53: try { try decoder.decodeSingularInt32Field(value: &_storage._cardinality) }() - case 54: try { try decoder.decodeSingularInt32Field(value: &_storage._ccEnableArenas) }() - case 55: try { try decoder.decodeSingularInt32Field(value: &_storage._ccGenericServices) }() - case 56: try { try decoder.decodeSingularInt32Field(value: &_storage._character) }() - case 57: try { try decoder.decodeSingularInt32Field(value: &_storage._chars) }() - case 58: try { try decoder.decodeSingularInt32Field(value: &_storage._class) }() - case 59: try { try decoder.decodeSingularInt32Field(value: &_storage._clearAggregateValue_p) }() - case 60: try { try decoder.decodeSingularInt32Field(value: &_storage._clearAllowAlias_p) }() - case 61: try { try decoder.decodeSingularInt32Field(value: &_storage._clearBegin_p) }() - case 62: try { try decoder.decodeSingularInt32Field(value: &_storage._clearCcEnableArenas_p) }() - case 63: try { try decoder.decodeSingularInt32Field(value: &_storage._clearCcGenericServices_p) }() - case 64: try { try decoder.decodeSingularInt32Field(value: &_storage._clearClientStreaming_p) }() - case 65: try { try decoder.decodeSingularInt32Field(value: &_storage._clearCsharpNamespace_p) }() - case 66: try { try decoder.decodeSingularInt32Field(value: &_storage._clearCtype_p) }() - case 67: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDefaultValue_p) }() - case 68: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDeprecated_p) }() - case 69: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDoubleValue_p) }() - case 70: try { try decoder.decodeSingularInt32Field(value: &_storage._clearEnd_p) }() - case 71: try { try decoder.decodeSingularInt32Field(value: &_storage._clearExtendee_p) }() - case 72: try { try decoder.decodeSingularInt32Field(value: &_storage._clearExtensionValue_p) }() - case 73: try { try decoder.decodeSingularInt32Field(value: &_storage._clearGoPackage_p) }() - case 74: try { try decoder.decodeSingularInt32Field(value: &_storage._clearIdempotencyLevel_p) }() - case 75: try { try decoder.decodeSingularInt32Field(value: &_storage._clearIdentifierValue_p) }() - case 76: try { try decoder.decodeSingularInt32Field(value: &_storage._clearInputType_p) }() - case 77: try { try decoder.decodeSingularInt32Field(value: &_storage._clearIsExtension_p) }() - case 78: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaGenerateEqualsAndHash_p) }() - case 79: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaGenericServices_p) }() - case 80: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaMultipleFiles_p) }() - case 81: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaOuterClassname_p) }() - case 82: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaPackage_p) }() - case 83: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaStringCheckUtf8_p) }() - case 84: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJsonName_p) }() - case 85: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJstype_p) }() - case 86: try { try decoder.decodeSingularInt32Field(value: &_storage._clearLabel_p) }() - case 87: try { try decoder.decodeSingularInt32Field(value: &_storage._clearLazy_p) }() - case 88: try { try decoder.decodeSingularInt32Field(value: &_storage._clearLeadingComments_p) }() - case 89: try { try decoder.decodeSingularInt32Field(value: &_storage._clearMapEntry_p) }() - case 90: try { try decoder.decodeSingularInt32Field(value: &_storage._clearMessageSetWireFormat_p) }() - case 91: try { try decoder.decodeSingularInt32Field(value: &_storage._clearName_p) }() - case 92: try { try decoder.decodeSingularInt32Field(value: &_storage._clearNamePart_p) }() - case 93: try { try decoder.decodeSingularInt32Field(value: &_storage._clearNegativeIntValue_p) }() - case 94: try { try decoder.decodeSingularInt32Field(value: &_storage._clearNoStandardDescriptorAccessor_p) }() - case 95: try { try decoder.decodeSingularInt32Field(value: &_storage._clearNumber_p) }() - case 96: try { try decoder.decodeSingularInt32Field(value: &_storage._clearObjcClassPrefix_p) }() - case 97: try { try decoder.decodeSingularInt32Field(value: &_storage._clearOneofIndex_p) }() - case 98: try { try decoder.decodeSingularInt32Field(value: &_storage._clearOptimizeFor_p) }() - case 99: try { try decoder.decodeSingularInt32Field(value: &_storage._clearOptions_p) }() - case 100: try { try decoder.decodeSingularInt32Field(value: &_storage._clearOutputType_p) }() - case 101: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPackage_p) }() - case 102: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPacked_p) }() - case 103: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPhpClassPrefix_p) }() - case 104: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPhpGenericServices_p) }() - case 105: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPhpMetadataNamespace_p) }() - case 106: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPhpNamespace_p) }() - case 107: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPositiveIntValue_p) }() - case 108: try { try decoder.decodeSingularInt32Field(value: &_storage._clearProto3Optional_p) }() - case 109: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPyGenericServices_p) }() - case 110: try { try decoder.decodeSingularInt32Field(value: &_storage._clearRubyPackage_p) }() - case 111: try { try decoder.decodeSingularInt32Field(value: &_storage._clearServerStreaming_p) }() - case 112: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSourceCodeInfo_p) }() - case 113: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSourceContext_p) }() - case 114: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSourceFile_p) }() - case 115: try { try decoder.decodeSingularInt32Field(value: &_storage._clearStart_p) }() - case 116: try { try decoder.decodeSingularInt32Field(value: &_storage._clearStringValue_p) }() - case 117: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSwiftPrefix_p) }() - case 118: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSyntax_p) }() - case 119: try { try decoder.decodeSingularInt32Field(value: &_storage._clearTrailingComments_p) }() - case 120: try { try decoder.decodeSingularInt32Field(value: &_storage._clearType_p) }() - case 121: try { try decoder.decodeSingularInt32Field(value: &_storage._clearTypeName_p) }() - case 122: try { try decoder.decodeSingularInt32Field(value: &_storage._clearValue_p) }() - case 123: try { try decoder.decodeSingularInt32Field(value: &_storage._clearWeak_p) }() - case 124: try { try decoder.decodeSingularInt32Field(value: &_storage._clientStreaming) }() - case 125: try { try decoder.decodeSingularInt32Field(value: &_storage._codePoint) }() - case 126: try { try decoder.decodeSingularInt32Field(value: &_storage._codeUnits) }() - case 127: try { try decoder.decodeSingularInt32Field(value: &_storage._collection) }() - case 128: try { try decoder.decodeSingularInt32Field(value: &_storage._com) }() - case 129: try { try decoder.decodeSingularInt32Field(value: &_storage._comma) }() - case 130: try { try decoder.decodeSingularInt32Field(value: &_storage._contentsOf) }() - case 131: try { try decoder.decodeSingularInt32Field(value: &_storage._contiguousBytes) }() - case 132: try { try decoder.decodeSingularInt32Field(value: &_storage._count) }() - case 133: try { try decoder.decodeSingularInt32Field(value: &_storage._countVarintsInBuffer) }() - case 134: try { try decoder.decodeSingularInt32Field(value: &_storage._csharpNamespace) }() - case 135: try { try decoder.decodeSingularInt32Field(value: &_storage._ctype) }() - case 136: try { try decoder.decodeSingularInt32Field(value: &_storage._customCodable) }() - case 137: try { try decoder.decodeSingularInt32Field(value: &_storage._customDebugStringConvertible) }() - case 138: try { try decoder.decodeSingularInt32Field(value: &_storage._d) }() - case 139: try { try decoder.decodeSingularInt32Field(value: &_storage._data) }() - case 140: try { try decoder.decodeSingularInt32Field(value: &_storage._dataResult) }() - case 141: try { try decoder.decodeSingularInt32Field(value: &_storage._date) }() - case 142: try { try decoder.decodeSingularInt32Field(value: &_storage._daySec) }() - case 143: try { try decoder.decodeSingularInt32Field(value: &_storage._daysSinceEpoch) }() - case 144: try { try decoder.decodeSingularInt32Field(value: &_storage._debugDescription_p) }() - case 145: try { try decoder.decodeSingularInt32Field(value: &_storage._decoded) }() - case 146: try { try decoder.decodeSingularInt32Field(value: &_storage._decodedFromJsonnull) }() - case 147: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeExtensionField) }() - case 148: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeExtensionFieldsAsMessageSet) }() - case 149: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeJson) }() - case 150: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeMapField) }() - case 151: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeMessage) }() - case 152: try { try decoder.decodeSingularInt32Field(value: &_storage._decoder) }() - case 153: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeated) }() - case 154: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedBoolField) }() - case 155: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedBytesField) }() - case 156: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedDoubleField) }() - case 157: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedEnumField) }() - case 158: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedFixed32Field) }() - case 159: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedFixed64Field) }() - case 160: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedFloatField) }() - case 161: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedGroupField) }() - case 162: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedInt32Field) }() - case 163: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedInt64Field) }() - case 164: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedMessageField) }() - case 165: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedSfixed32Field) }() - case 166: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedSfixed64Field) }() - case 167: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedSint32Field) }() - case 168: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedSint64Field) }() - case 169: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedStringField) }() - case 170: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedUint32Field) }() - case 171: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedUint64Field) }() - case 172: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingular) }() - case 173: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularBoolField) }() - case 174: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularBytesField) }() - case 175: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularDoubleField) }() - case 176: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularEnumField) }() - case 177: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularFixed32Field) }() - case 178: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularFixed64Field) }() - case 179: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularFloatField) }() - case 180: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularGroupField) }() - case 181: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularInt32Field) }() - case 182: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularInt64Field) }() - case 183: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularMessageField) }() - case 184: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularSfixed32Field) }() - case 185: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularSfixed64Field) }() - case 186: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularSint32Field) }() - case 187: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularSint64Field) }() - case 188: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularStringField) }() - case 189: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularUint32Field) }() - case 190: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularUint64Field) }() - case 191: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeTextFormat) }() - case 192: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultAnyTypeUrlprefix) }() - case 193: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultValue) }() - case 194: try { try decoder.decodeSingularInt32Field(value: &_storage._dependency) }() - case 195: try { try decoder.decodeSingularInt32Field(value: &_storage._deprecated) }() - case 196: try { try decoder.decodeSingularInt32Field(value: &_storage._description_p) }() - case 197: try { try decoder.decodeSingularInt32Field(value: &_storage._descriptorProto) }() - case 198: try { try decoder.decodeSingularInt32Field(value: &_storage._dictionary) }() - case 199: try { try decoder.decodeSingularInt32Field(value: &_storage._dictionaryLiteral) }() - case 200: try { try decoder.decodeSingularInt32Field(value: &_storage._digit) }() - case 201: try { try decoder.decodeSingularInt32Field(value: &_storage._digit0) }() - case 202: try { try decoder.decodeSingularInt32Field(value: &_storage._digit1) }() - case 203: try { try decoder.decodeSingularInt32Field(value: &_storage._digitCount) }() - case 204: try { try decoder.decodeSingularInt32Field(value: &_storage._digits) }() - case 205: try { try decoder.decodeSingularInt32Field(value: &_storage._digitValue) }() - case 206: try { try decoder.decodeSingularInt32Field(value: &_storage._discardableResult) }() - case 207: try { try decoder.decodeSingularInt32Field(value: &_storage._discardUnknownFields) }() - case 208: try { try decoder.decodeSingularInt32Field(value: &_storage._distance) }() - case 209: try { try decoder.decodeSingularInt32Field(value: &_storage._double) }() - case 210: try { try decoder.decodeSingularInt32Field(value: &_storage._doubleValue) }() - case 211: try { try decoder.decodeSingularInt32Field(value: &_storage._duration) }() - case 212: try { try decoder.decodeSingularInt32Field(value: &_storage._e) }() - case 213: try { try decoder.decodeSingularInt32Field(value: &_storage._element) }() - case 214: try { try decoder.decodeSingularInt32Field(value: &_storage._elements) }() - case 215: try { try decoder.decodeSingularInt32Field(value: &_storage._emitExtensionFieldName) }() - case 216: try { try decoder.decodeSingularInt32Field(value: &_storage._emitFieldName) }() - case 217: try { try decoder.decodeSingularInt32Field(value: &_storage._emitFieldNumber) }() - case 218: try { try decoder.decodeSingularInt32Field(value: &_storage._empty) }() - case 219: try { try decoder.decodeSingularInt32Field(value: &_storage._emptyData) }() - case 220: try { try decoder.decodeSingularInt32Field(value: &_storage._encodeAsBytes) }() - case 221: try { try decoder.decodeSingularInt32Field(value: &_storage._encoded) }() - case 222: try { try decoder.decodeSingularInt32Field(value: &_storage._encodedJsonstring) }() - case 223: try { try decoder.decodeSingularInt32Field(value: &_storage._encodedSize) }() - case 224: try { try decoder.decodeSingularInt32Field(value: &_storage._encodeField) }() - case 225: try { try decoder.decodeSingularInt32Field(value: &_storage._encoder) }() - case 226: try { try decoder.decodeSingularInt32Field(value: &_storage._end) }() - case 227: try { try decoder.decodeSingularInt32Field(value: &_storage._endArray) }() - case 228: try { try decoder.decodeSingularInt32Field(value: &_storage._endMessageField) }() - case 229: try { try decoder.decodeSingularInt32Field(value: &_storage._endObject) }() - case 230: try { try decoder.decodeSingularInt32Field(value: &_storage._endRegularField) }() - case 231: try { try decoder.decodeSingularInt32Field(value: &_storage._enum) }() - case 232: try { try decoder.decodeSingularInt32Field(value: &_storage._enumDescriptorProto) }() - case 233: try { try decoder.decodeSingularInt32Field(value: &_storage._enumOptions) }() - case 234: try { try decoder.decodeSingularInt32Field(value: &_storage._enumReservedRange) }() - case 235: try { try decoder.decodeSingularInt32Field(value: &_storage._enumType) }() - case 236: try { try decoder.decodeSingularInt32Field(value: &_storage._enumvalue) }() - case 237: try { try decoder.decodeSingularInt32Field(value: &_storage._enumValueDescriptorProto) }() - case 238: try { try decoder.decodeSingularInt32Field(value: &_storage._enumValueOptions) }() - case 239: try { try decoder.decodeSingularInt32Field(value: &_storage._equatable) }() - case 240: try { try decoder.decodeSingularInt32Field(value: &_storage._error) }() - case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._expressibleByArrayLiteral) }() - case 242: try { try decoder.decodeSingularInt32Field(value: &_storage._expressibleByDictionaryLiteral) }() - case 243: try { try decoder.decodeSingularInt32Field(value: &_storage._ext) }() - case 244: try { try decoder.decodeSingularInt32Field(value: &_storage._extDecoder) }() - case 245: try { try decoder.decodeSingularInt32Field(value: &_storage._extendedGraphemeClusterLiteral) }() - case 246: try { try decoder.decodeSingularInt32Field(value: &_storage._extendedGraphemeClusterLiteralType) }() - case 247: try { try decoder.decodeSingularInt32Field(value: &_storage._extendee) }() - case 248: try { try decoder.decodeSingularInt32Field(value: &_storage._extensibleMessage) }() - case 249: try { try decoder.decodeSingularInt32Field(value: &_storage._extension) }() - case 250: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionField) }() - case 251: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionFieldNumber) }() - case 252: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionFieldValueSet) }() - case 253: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionMap) }() - case 254: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionRange) }() - case 255: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionRangeOptions) }() - case 256: try { try decoder.decodeSingularInt32Field(value: &_storage._extensions) }() - case 257: try { try decoder.decodeSingularInt32Field(value: &_storage._extras) }() - case 258: try { try decoder.decodeSingularInt32Field(value: &_storage._f) }() - case 259: try { try decoder.decodeSingularInt32Field(value: &_storage._false) }() - case 260: try { try decoder.decodeSingularInt32Field(value: &_storage._field) }() - case 261: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldData) }() - case 262: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldDescriptorProto) }() - case 263: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldMask) }() - case 264: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName) }() - case 265: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNameCount) }() - case 266: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNum) }() - case 267: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNumber) }() - case 268: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNumberForProto) }() - case 269: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldOptions) }() - case 270: try { try decoder.decodeSingularInt32Field(value: &_storage._fields) }() - case 271: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldSize) }() - case 272: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldTag) }() - case 273: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldType) }() - case 274: try { try decoder.decodeSingularInt32Field(value: &_storage._file) }() - case 275: try { try decoder.decodeSingularInt32Field(value: &_storage._fileDescriptorProto) }() - case 276: try { try decoder.decodeSingularInt32Field(value: &_storage._fileDescriptorSet) }() - case 277: try { try decoder.decodeSingularInt32Field(value: &_storage._fileName) }() - case 278: try { try decoder.decodeSingularInt32Field(value: &_storage._fileOptions) }() - case 279: try { try decoder.decodeSingularInt32Field(value: &_storage._filter) }() - case 280: try { try decoder.decodeSingularInt32Field(value: &_storage._first) }() - case 281: try { try decoder.decodeSingularInt32Field(value: &_storage._firstItem) }() - case 282: try { try decoder.decodeSingularInt32Field(value: &_storage._float) }() - case 283: try { try decoder.decodeSingularInt32Field(value: &_storage._floatLiteral) }() - case 284: try { try decoder.decodeSingularInt32Field(value: &_storage._floatLiteralType) }() - case 285: try { try decoder.decodeSingularInt32Field(value: &_storage._floatValue) }() - case 286: try { try decoder.decodeSingularInt32Field(value: &_storage._forMessageName) }() - case 287: try { try decoder.decodeSingularInt32Field(value: &_storage._formUnion) }() - case 288: try { try decoder.decodeSingularInt32Field(value: &_storage._forReadingFrom) }() - case 289: try { try decoder.decodeSingularInt32Field(value: &_storage._forTypeURL) }() - case 290: try { try decoder.decodeSingularInt32Field(value: &_storage._forwardParser) }() - case 291: try { try decoder.decodeSingularInt32Field(value: &_storage._forWritingInto) }() - case 292: try { try decoder.decodeSingularInt32Field(value: &_storage._from) }() - case 293: try { try decoder.decodeSingularInt32Field(value: &_storage._fromAscii2) }() - case 294: try { try decoder.decodeSingularInt32Field(value: &_storage._fromAscii4) }() - case 295: try { try decoder.decodeSingularInt32Field(value: &_storage._fromByteOffset) }() - case 296: try { try decoder.decodeSingularInt32Field(value: &_storage._fromHexDigit) }() - case 297: try { try decoder.decodeSingularInt32Field(value: &_storage._func) }() - case 298: try { try decoder.decodeSingularInt32Field(value: &_storage._g) }() - case 299: try { try decoder.decodeSingularInt32Field(value: &_storage._generatedCodeInfo) }() - case 300: try { try decoder.decodeSingularInt32Field(value: &_storage._get) }() - case 301: try { try decoder.decodeSingularInt32Field(value: &_storage._getExtensionValue) }() - case 302: try { try decoder.decodeSingularInt32Field(value: &_storage._googleapis) }() - case 303: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufAny) }() - case 304: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufApi) }() - case 305: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufBoolValue) }() - case 306: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufBytesValue) }() - case 307: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufDescriptorProto) }() - case 308: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufDoubleValue) }() - case 309: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufDuration) }() - case 310: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEmpty) }() - case 311: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnum) }() - case 312: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumDescriptorProto) }() - case 313: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumOptions) }() - case 314: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumValue) }() - case 315: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumValueDescriptorProto) }() - case 316: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumValueOptions) }() - case 317: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufExtensionRangeOptions) }() - case 318: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufField) }() - case 319: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFieldDescriptorProto) }() - case 320: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFieldMask) }() - case 321: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFieldOptions) }() - case 322: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFileDescriptorProto) }() - case 323: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFileDescriptorSet) }() - case 324: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFileOptions) }() - case 325: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFloatValue) }() - case 326: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufGeneratedCodeInfo) }() - case 327: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufInt32Value) }() - case 328: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufInt64Value) }() - case 329: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufListValue) }() - case 330: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMessageOptions) }() - case 331: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMethod) }() - case 332: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMethodDescriptorProto) }() - case 333: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMethodOptions) }() - case 334: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMixin) }() - case 335: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufNullValue) }() - case 336: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufOneofDescriptorProto) }() - case 337: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufOneofOptions) }() - case 338: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufOption) }() - case 339: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufServiceDescriptorProto) }() - case 340: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufServiceOptions) }() - case 341: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSourceCodeInfo) }() - case 342: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSourceContext) }() - case 343: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufStringValue) }() - case 344: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufStruct) }() - case 345: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSyntax) }() - case 346: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufTimestamp) }() - case 347: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufType) }() - case 348: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufUint32Value) }() - case 349: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufUint64Value) }() - case 350: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufUninterpretedOption) }() - case 351: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufValue) }() - case 352: try { try decoder.decodeSingularInt32Field(value: &_storage._goPackage) }() - case 353: try { try decoder.decodeSingularInt32Field(value: &_storage._group) }() - case 354: try { try decoder.decodeSingularInt32Field(value: &_storage._groupFieldNumberStack) }() - case 355: try { try decoder.decodeSingularInt32Field(value: &_storage._groupSize) }() - case 356: try { try decoder.decodeSingularInt32Field(value: &_storage._h) }() - case 357: try { try decoder.decodeSingularInt32Field(value: &_storage._hadOneofValue) }() - case 358: try { try decoder.decodeSingularInt32Field(value: &_storage._handleConflictingOneOf) }() - case 359: try { try decoder.decodeSingularInt32Field(value: &_storage._hasAggregateValue_p) }() - case 360: try { try decoder.decodeSingularInt32Field(value: &_storage._hasAllowAlias_p) }() - case 361: try { try decoder.decodeSingularInt32Field(value: &_storage._hasBegin_p) }() - case 362: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCcEnableArenas_p) }() - case 363: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCcGenericServices_p) }() - case 364: try { try decoder.decodeSingularInt32Field(value: &_storage._hasClientStreaming_p) }() - case 365: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCsharpNamespace_p) }() - case 366: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCtype_p) }() - case 367: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDefaultValue_p) }() - case 368: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDeprecated_p) }() - case 369: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDoubleValue_p) }() - case 370: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEnd_p) }() - case 371: try { try decoder.decodeSingularInt32Field(value: &_storage._hasExtendee_p) }() - case 372: try { try decoder.decodeSingularInt32Field(value: &_storage._hasExtensionValue_p) }() - case 373: try { try decoder.decodeSingularInt32Field(value: &_storage._hasGoPackage_p) }() - case 374: try { try decoder.decodeSingularInt32Field(value: &_storage._hash) }() - case 375: try { try decoder.decodeSingularInt32Field(value: &_storage._hashable) }() - case 376: try { try decoder.decodeSingularInt32Field(value: &_storage._hasher) }() - case 377: try { try decoder.decodeSingularInt32Field(value: &_storage._hashValue_p) }() - case 378: try { try decoder.decodeSingularInt32Field(value: &_storage._hashVisitor) }() - case 379: try { try decoder.decodeSingularInt32Field(value: &_storage._hasIdempotencyLevel_p) }() - case 380: try { try decoder.decodeSingularInt32Field(value: &_storage._hasIdentifierValue_p) }() - case 381: try { try decoder.decodeSingularInt32Field(value: &_storage._hasInputType_p) }() - case 382: try { try decoder.decodeSingularInt32Field(value: &_storage._hasIsExtension_p) }() - case 383: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaGenerateEqualsAndHash_p) }() - case 384: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaGenericServices_p) }() - case 385: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaMultipleFiles_p) }() - case 386: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaOuterClassname_p) }() - case 387: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaPackage_p) }() - case 388: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaStringCheckUtf8_p) }() - case 389: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJsonName_p) }() - case 390: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJstype_p) }() - case 391: try { try decoder.decodeSingularInt32Field(value: &_storage._hasLabel_p) }() - case 392: try { try decoder.decodeSingularInt32Field(value: &_storage._hasLazy_p) }() - case 393: try { try decoder.decodeSingularInt32Field(value: &_storage._hasLeadingComments_p) }() - case 394: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMapEntry_p) }() - case 395: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMessageSetWireFormat_p) }() - case 396: try { try decoder.decodeSingularInt32Field(value: &_storage._hasName_p) }() - case 397: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNamePart_p) }() - case 398: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNegativeIntValue_p) }() - case 399: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNoStandardDescriptorAccessor_p) }() - case 400: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNumber_p) }() - case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._hasObjcClassPrefix_p) }() - case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOneofIndex_p) }() - case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOptimizeFor_p) }() - case 404: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOptions_p) }() - case 405: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOutputType_p) }() - case 406: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPackage_p) }() - case 407: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPacked_p) }() - case 408: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpClassPrefix_p) }() - case 409: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpGenericServices_p) }() - case 410: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpMetadataNamespace_p) }() - case 411: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpNamespace_p) }() - case 412: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPositiveIntValue_p) }() - case 413: try { try decoder.decodeSingularInt32Field(value: &_storage._hasProto3Optional_p) }() - case 414: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPyGenericServices_p) }() - case 415: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRubyPackage_p) }() - case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._hasServerStreaming_p) }() - case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSourceCodeInfo_p) }() - case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSourceContext_p) }() - case 419: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSourceFile_p) }() - case 420: try { try decoder.decodeSingularInt32Field(value: &_storage._hasStart_p) }() - case 421: try { try decoder.decodeSingularInt32Field(value: &_storage._hasStringValue_p) }() - case 422: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSwiftPrefix_p) }() - case 423: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSyntax_p) }() - case 424: try { try decoder.decodeSingularInt32Field(value: &_storage._hasTrailingComments_p) }() - case 425: try { try decoder.decodeSingularInt32Field(value: &_storage._hasType_p) }() - case 426: try { try decoder.decodeSingularInt32Field(value: &_storage._hasTypeName_p) }() - case 427: try { try decoder.decodeSingularInt32Field(value: &_storage._hasValue_p) }() - case 428: try { try decoder.decodeSingularInt32Field(value: &_storage._hasWeak_p) }() - case 429: try { try decoder.decodeSingularInt32Field(value: &_storage._hour) }() - case 430: try { try decoder.decodeSingularInt32Field(value: &_storage._i) }() - case 431: try { try decoder.decodeSingularInt32Field(value: &_storage._idempotencyLevel) }() - case 432: try { try decoder.decodeSingularInt32Field(value: &_storage._identifierValue) }() - case 433: try { try decoder.decodeSingularInt32Field(value: &_storage._if) }() - case 434: try { try decoder.decodeSingularInt32Field(value: &_storage._ignoreUnknownFields) }() - case 435: try { try decoder.decodeSingularInt32Field(value: &_storage._index) }() - case 436: try { try decoder.decodeSingularInt32Field(value: &_storage._init_p) }() - case 437: try { try decoder.decodeSingularInt32Field(value: &_storage._inout) }() - case 438: try { try decoder.decodeSingularInt32Field(value: &_storage._inputType) }() - case 439: try { try decoder.decodeSingularInt32Field(value: &_storage._insert) }() - case 440: try { try decoder.decodeSingularInt32Field(value: &_storage._int) }() - case 441: try { try decoder.decodeSingularInt32Field(value: &_storage._int32) }() - case 442: try { try decoder.decodeSingularInt32Field(value: &_storage._int32Value) }() - case 443: try { try decoder.decodeSingularInt32Field(value: &_storage._int64) }() - case 444: try { try decoder.decodeSingularInt32Field(value: &_storage._int64Value) }() - case 445: try { try decoder.decodeSingularInt32Field(value: &_storage._int8) }() - case 446: try { try decoder.decodeSingularInt32Field(value: &_storage._integerLiteral) }() - case 447: try { try decoder.decodeSingularInt32Field(value: &_storage._integerLiteralType) }() - case 448: try { try decoder.decodeSingularInt32Field(value: &_storage._intern) }() - case 449: try { try decoder.decodeSingularInt32Field(value: &_storage._internal) }() - case 450: try { try decoder.decodeSingularInt32Field(value: &_storage._internalState) }() - case 451: try { try decoder.decodeSingularInt32Field(value: &_storage._into) }() - case 452: try { try decoder.decodeSingularInt32Field(value: &_storage._ints) }() - case 453: try { try decoder.decodeSingularInt32Field(value: &_storage._isA) }() - case 454: try { try decoder.decodeSingularInt32Field(value: &_storage._isEqual) }() - case 455: try { try decoder.decodeSingularInt32Field(value: &_storage._isEqualTo) }() - case 456: try { try decoder.decodeSingularInt32Field(value: &_storage._isExtension) }() - case 457: try { try decoder.decodeSingularInt32Field(value: &_storage._isInitialized_p) }() - case 458: try { try decoder.decodeSingularInt32Field(value: &_storage._itemTagsEncodedSize) }() - case 459: try { try decoder.decodeSingularInt32Field(value: &_storage._iterator) }() - case 460: try { try decoder.decodeSingularInt32Field(value: &_storage._i2166136261) }() - case 461: try { try decoder.decodeSingularInt32Field(value: &_storage._javaGenerateEqualsAndHash) }() - case 462: try { try decoder.decodeSingularInt32Field(value: &_storage._javaGenericServices) }() - case 463: try { try decoder.decodeSingularInt32Field(value: &_storage._javaMultipleFiles) }() - case 464: try { try decoder.decodeSingularInt32Field(value: &_storage._javaOuterClassname) }() - case 465: try { try decoder.decodeSingularInt32Field(value: &_storage._javaPackage) }() - case 466: try { try decoder.decodeSingularInt32Field(value: &_storage._javaStringCheckUtf8) }() - case 467: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecoder) }() - case 468: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecodingError) }() - case 469: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecodingOptions) }() - case 470: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonEncoder) }() - case 471: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencodingError) }() - case 472: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencodingOptions) }() - case 473: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencodingVisitor) }() - case 474: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonmapEncodingVisitor) }() - case 475: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonName) }() - case 476: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonPath) }() - case 477: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonPaths) }() - case 478: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonscanner) }() - case 479: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonString) }() - case 480: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonText) }() - case 481: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonUtf8Data) }() - case 482: try { try decoder.decodeSingularInt32Field(value: &_storage._jstype) }() - case 483: try { try decoder.decodeSingularInt32Field(value: &_storage._k) }() - case 484: try { try decoder.decodeSingularInt32Field(value: &_storage._key) }() - case 485: try { try decoder.decodeSingularInt32Field(value: &_storage._keyField) }() - case 486: try { try decoder.decodeSingularInt32Field(value: &_storage._keyType) }() - case 487: try { try decoder.decodeSingularInt32Field(value: &_storage._kind) }() - case 488: try { try decoder.decodeSingularInt32Field(value: &_storage._l) }() - case 489: try { try decoder.decodeSingularInt32Field(value: &_storage._label) }() - case 490: try { try decoder.decodeSingularInt32Field(value: &_storage._lazy) }() - case 491: try { try decoder.decodeSingularInt32Field(value: &_storage._leadingComments) }() - case 492: try { try decoder.decodeSingularInt32Field(value: &_storage._leadingDetachedComments) }() - case 493: try { try decoder.decodeSingularInt32Field(value: &_storage._length) }() - case 494: try { try decoder.decodeSingularInt32Field(value: &_storage._lessThan) }() - case 495: try { try decoder.decodeSingularInt32Field(value: &_storage._let) }() - case 496: try { try decoder.decodeSingularInt32Field(value: &_storage._lhs) }() - case 497: try { try decoder.decodeSingularInt32Field(value: &_storage._list) }() - case 498: try { try decoder.decodeSingularInt32Field(value: &_storage._listOfMessages) }() - case 499: try { try decoder.decodeSingularInt32Field(value: &_storage._listValue) }() - case 500: try { try decoder.decodeSingularInt32Field(value: &_storage._littleEndian) }() - case 501: try { try decoder.decodeSingularInt32Field(value: &_storage._littleEndianBytes) }() - case 502: try { try decoder.decodeSingularInt32Field(value: &_storage._load) }() - case 503: try { try decoder.decodeSingularInt32Field(value: &_storage._localHasher) }() - case 504: try { try decoder.decodeSingularInt32Field(value: &_storage._location) }() - case 505: try { try decoder.decodeSingularInt32Field(value: &_storage._m) }() - case 506: try { try decoder.decodeSingularInt32Field(value: &_storage._major) }() - case 507: try { try decoder.decodeSingularInt32Field(value: &_storage._makeIterator) }() - case 508: try { try decoder.decodeSingularInt32Field(value: &_storage._mapEntry) }() - case 509: try { try decoder.decodeSingularInt32Field(value: &_storage._mapHash) }() - case 510: try { try decoder.decodeSingularInt32Field(value: &_storage._mapKeyType) }() - case 511: try { try decoder.decodeSingularInt32Field(value: &_storage._mapNameResolver) }() - case 512: try { try decoder.decodeSingularInt32Field(value: &_storage._mapToMessages) }() - case 513: try { try decoder.decodeSingularInt32Field(value: &_storage._mapValueType) }() - case 514: try { try decoder.decodeSingularInt32Field(value: &_storage._mapVisitor) }() - case 515: try { try decoder.decodeSingularInt32Field(value: &_storage._mdayStart) }() - case 516: try { try decoder.decodeSingularInt32Field(value: &_storage._merge) }() - case 517: try { try decoder.decodeSingularInt32Field(value: &_storage._message) }() - case 518: try { try decoder.decodeSingularInt32Field(value: &_storage._messageDepthLimit) }() - case 519: try { try decoder.decodeSingularInt32Field(value: &_storage._messageExtension) }() - case 520: try { try decoder.decodeSingularInt32Field(value: &_storage._messageImplementationBase) }() - case 521: try { try decoder.decodeSingularInt32Field(value: &_storage._messageOptions) }() - case 522: try { try decoder.decodeSingularInt32Field(value: &_storage._messageSet) }() - case 523: try { try decoder.decodeSingularInt32Field(value: &_storage._messageSetWireFormat) }() - case 524: try { try decoder.decodeSingularInt32Field(value: &_storage._messageType) }() - case 525: try { try decoder.decodeSingularInt32Field(value: &_storage._method) }() - case 526: try { try decoder.decodeSingularInt32Field(value: &_storage._methodDescriptorProto) }() - case 527: try { try decoder.decodeSingularInt32Field(value: &_storage._methodOptions) }() - case 528: try { try decoder.decodeSingularInt32Field(value: &_storage._methods) }() - case 529: try { try decoder.decodeSingularInt32Field(value: &_storage._minor) }() - case 530: try { try decoder.decodeSingularInt32Field(value: &_storage._mixin) }() - case 531: try { try decoder.decodeSingularInt32Field(value: &_storage._mixins) }() - case 532: try { try decoder.decodeSingularInt32Field(value: &_storage._modifier) }() - case 533: try { try decoder.decodeSingularInt32Field(value: &_storage._modify) }() - case 534: try { try decoder.decodeSingularInt32Field(value: &_storage._month) }() - case 535: try { try decoder.decodeSingularInt32Field(value: &_storage._msgExtension) }() - case 536: try { try decoder.decodeSingularInt32Field(value: &_storage._mutating) }() - case 537: try { try decoder.decodeSingularInt32Field(value: &_storage._n) }() - case 538: try { try decoder.decodeSingularInt32Field(value: &_storage._name) }() - case 539: try { try decoder.decodeSingularInt32Field(value: &_storage._nameDescription) }() - case 540: try { try decoder.decodeSingularInt32Field(value: &_storage._nameMap) }() - case 541: try { try decoder.decodeSingularInt32Field(value: &_storage._namePart) }() - case 542: try { try decoder.decodeSingularInt32Field(value: &_storage._nameResolver) }() - case 543: try { try decoder.decodeSingularInt32Field(value: &_storage._names) }() - case 544: try { try decoder.decodeSingularInt32Field(value: &_storage._nanos) }() - case 545: try { try decoder.decodeSingularInt32Field(value: &_storage._nativeBytes) }() - case 546: try { try decoder.decodeSingularInt32Field(value: &_storage._nativeEndianBytes) }() - case 547: try { try decoder.decodeSingularInt32Field(value: &_storage._negativeIntValue) }() - case 548: try { try decoder.decodeSingularInt32Field(value: &_storage._nestedType) }() - case 549: try { try decoder.decodeSingularInt32Field(value: &_storage._newL) }() - case 550: try { try decoder.decodeSingularInt32Field(value: &_storage._newList) }() - case 551: try { try decoder.decodeSingularInt32Field(value: &_storage._newValue) }() - case 552: try { try decoder.decodeSingularInt32Field(value: &_storage._nextByte) }() - case 553: try { try decoder.decodeSingularInt32Field(value: &_storage._nextFieldNumber) }() - case 554: try { try decoder.decodeSingularInt32Field(value: &_storage._nil) }() - case 555: try { try decoder.decodeSingularInt32Field(value: &_storage._nilLiteral) }() - case 556: try { try decoder.decodeSingularInt32Field(value: &_storage._noStandardDescriptorAccessor) }() - case 557: try { try decoder.decodeSingularInt32Field(value: &_storage._nullValue) }() - case 558: try { try decoder.decodeSingularInt32Field(value: &_storage._number) }() - case 559: try { try decoder.decodeSingularInt32Field(value: &_storage._numberValue) }() - case 560: try { try decoder.decodeSingularInt32Field(value: &_storage._objcClassPrefix) }() - case 561: try { try decoder.decodeSingularInt32Field(value: &_storage._of) }() - case 562: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofDecl) }() - case 563: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofDescriptorProto) }() - case 564: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofIndex) }() - case 565: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofOptions) }() - case 566: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofs) }() - case 567: try { try decoder.decodeSingularInt32Field(value: &_storage._oneOfKind) }() - case 568: try { try decoder.decodeSingularInt32Field(value: &_storage._optimizeFor) }() - case 569: try { try decoder.decodeSingularInt32Field(value: &_storage._optimizeMode) }() - case 570: try { try decoder.decodeSingularInt32Field(value: &_storage._option) }() - case 571: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalEnumExtensionField) }() - case 572: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalExtensionField) }() - case 573: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalGroupExtensionField) }() - case 574: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalMessageExtensionField) }() - case 575: try { try decoder.decodeSingularInt32Field(value: &_storage._options) }() - case 576: try { try decoder.decodeSingularInt32Field(value: &_storage._other) }() - case 577: try { try decoder.decodeSingularInt32Field(value: &_storage._others) }() - case 578: try { try decoder.decodeSingularInt32Field(value: &_storage._out) }() - case 579: try { try decoder.decodeSingularInt32Field(value: &_storage._outputType) }() - case 580: try { try decoder.decodeSingularInt32Field(value: &_storage._p) }() - case 581: try { try decoder.decodeSingularInt32Field(value: &_storage._package) }() - case 582: try { try decoder.decodeSingularInt32Field(value: &_storage._packed) }() - case 583: try { try decoder.decodeSingularInt32Field(value: &_storage._packedEnumExtensionField) }() - case 584: try { try decoder.decodeSingularInt32Field(value: &_storage._packedExtensionField) }() - case 585: try { try decoder.decodeSingularInt32Field(value: &_storage._padding) }() - case 586: try { try decoder.decodeSingularInt32Field(value: &_storage._parent) }() - case 587: try { try decoder.decodeSingularInt32Field(value: &_storage._parse) }() - case 588: try { try decoder.decodeSingularInt32Field(value: &_storage._partial) }() - case 589: try { try decoder.decodeSingularInt32Field(value: &_storage._path) }() - case 590: try { try decoder.decodeSingularInt32Field(value: &_storage._paths) }() - case 591: try { try decoder.decodeSingularInt32Field(value: &_storage._payload) }() - case 592: try { try decoder.decodeSingularInt32Field(value: &_storage._payloadSize) }() - case 593: try { try decoder.decodeSingularInt32Field(value: &_storage._phpClassPrefix) }() - case 594: try { try decoder.decodeSingularInt32Field(value: &_storage._phpGenericServices) }() - case 595: try { try decoder.decodeSingularInt32Field(value: &_storage._phpMetadataNamespace) }() - case 596: try { try decoder.decodeSingularInt32Field(value: &_storage._phpNamespace) }() - case 597: try { try decoder.decodeSingularInt32Field(value: &_storage._pointer) }() - case 598: try { try decoder.decodeSingularInt32Field(value: &_storage._pos) }() - case 599: try { try decoder.decodeSingularInt32Field(value: &_storage._positiveIntValue) }() - case 600: try { try decoder.decodeSingularInt32Field(value: &_storage._prefix) }() - case 601: try { try decoder.decodeSingularInt32Field(value: &_storage._preserveProtoFieldNames) }() - case 602: try { try decoder.decodeSingularInt32Field(value: &_storage._preTraverse) }() - case 603: try { try decoder.decodeSingularInt32Field(value: &_storage._printUnknownFields) }() - case 604: try { try decoder.decodeSingularInt32Field(value: &_storage._proto2) }() - case 605: try { try decoder.decodeSingularInt32Field(value: &_storage._proto3DefaultValue) }() - case 606: try { try decoder.decodeSingularInt32Field(value: &_storage._proto3Optional) }() - case 607: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufApiversionCheck) }() - case 608: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufApiversion2) }() - case 609: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufBool) }() - case 610: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufBytes) }() - case 611: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufDouble) }() - case 612: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufEnumMap) }() - case 613: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufExtension) }() - case 614: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFixed32) }() - case 615: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFixed64) }() - case 616: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFloat) }() - case 617: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufInt32) }() - case 618: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufInt64) }() - case 619: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufMap) }() - case 620: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufMessageMap) }() - case 621: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSfixed32) }() - case 622: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSfixed64) }() - case 623: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSint32) }() - case 624: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSint64) }() - case 625: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufString) }() - case 626: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufUint32) }() - case 627: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufUint64) }() - case 628: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufExtensionFieldValues) }() - case 629: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFieldNumber) }() - case 630: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufGeneratedIsEqualTo) }() - case 631: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufNameMap) }() - case 632: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufNewField) }() - case 633: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufPackage) }() - case 634: try { try decoder.decodeSingularInt32Field(value: &_storage._protocol) }() - case 635: try { try decoder.decodeSingularInt32Field(value: &_storage._protoFieldName) }() - case 636: try { try decoder.decodeSingularInt32Field(value: &_storage._protoMessageName) }() - case 637: try { try decoder.decodeSingularInt32Field(value: &_storage._protoNameProviding) }() - case 638: try { try decoder.decodeSingularInt32Field(value: &_storage._protoPaths) }() - case 639: try { try decoder.decodeSingularInt32Field(value: &_storage._public) }() - case 640: try { try decoder.decodeSingularInt32Field(value: &_storage._publicDependency) }() - case 641: try { try decoder.decodeSingularInt32Field(value: &_storage._putBoolValue) }() - case 642: try { try decoder.decodeSingularInt32Field(value: &_storage._putBytesValue) }() - case 643: try { try decoder.decodeSingularInt32Field(value: &_storage._putDoubleValue) }() - case 644: try { try decoder.decodeSingularInt32Field(value: &_storage._putEnumValue) }() - case 645: try { try decoder.decodeSingularInt32Field(value: &_storage._putFixedUint32) }() - case 646: try { try decoder.decodeSingularInt32Field(value: &_storage._putFixedUint64) }() - case 647: try { try decoder.decodeSingularInt32Field(value: &_storage._putFloatValue) }() - case 648: try { try decoder.decodeSingularInt32Field(value: &_storage._putInt64) }() - case 649: try { try decoder.decodeSingularInt32Field(value: &_storage._putStringValue) }() - case 650: try { try decoder.decodeSingularInt32Field(value: &_storage._putUint64) }() - case 651: try { try decoder.decodeSingularInt32Field(value: &_storage._putUint64Hex) }() - case 652: try { try decoder.decodeSingularInt32Field(value: &_storage._putVarInt) }() - case 653: try { try decoder.decodeSingularInt32Field(value: &_storage._putZigZagVarInt) }() - case 654: try { try decoder.decodeSingularInt32Field(value: &_storage._pyGenericServices) }() - case 655: try { try decoder.decodeSingularInt32Field(value: &_storage._rawChars) }() - case 656: try { try decoder.decodeSingularInt32Field(value: &_storage._rawRepresentable) }() - case 657: try { try decoder.decodeSingularInt32Field(value: &_storage._rawValue) }() - case 658: try { try decoder.decodeSingularInt32Field(value: &_storage._read4HexDigits) }() - case 659: try { try decoder.decodeSingularInt32Field(value: &_storage._register) }() - case 660: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedEnumExtensionField) }() - case 661: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedExtensionField) }() - case 662: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedGroupExtensionField) }() - case 663: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedMessageExtensionField) }() - case 664: try { try decoder.decodeSingularInt32Field(value: &_storage._requestStreaming) }() - case 665: try { try decoder.decodeSingularInt32Field(value: &_storage._requestTypeURL) }() - case 666: try { try decoder.decodeSingularInt32Field(value: &_storage._requiredSize) }() - case 667: try { try decoder.decodeSingularInt32Field(value: &_storage._reservedName) }() - case 668: try { try decoder.decodeSingularInt32Field(value: &_storage._reservedRange) }() - case 669: try { try decoder.decodeSingularInt32Field(value: &_storage._responseStreaming) }() - case 670: try { try decoder.decodeSingularInt32Field(value: &_storage._responseTypeURL) }() - case 671: try { try decoder.decodeSingularInt32Field(value: &_storage._result) }() - case 672: try { try decoder.decodeSingularInt32Field(value: &_storage._rethrows) }() - case 673: try { try decoder.decodeSingularInt32Field(value: &_storage._return) }() - case 674: try { try decoder.decodeSingularInt32Field(value: &_storage._returnType) }() - case 675: try { try decoder.decodeSingularInt32Field(value: &_storage._revision) }() - case 676: try { try decoder.decodeSingularInt32Field(value: &_storage._rhs) }() - case 677: try { try decoder.decodeSingularInt32Field(value: &_storage._root) }() - case 678: try { try decoder.decodeSingularInt32Field(value: &_storage._rubyPackage) }() - case 679: try { try decoder.decodeSingularInt32Field(value: &_storage._s) }() - case 680: try { try decoder.decodeSingularInt32Field(value: &_storage._sawBackslash) }() - case 681: try { try decoder.decodeSingularInt32Field(value: &_storage._sawSection4Characters) }() - case 682: try { try decoder.decodeSingularInt32Field(value: &_storage._sawSection5Characters) }() - case 683: try { try decoder.decodeSingularInt32Field(value: &_storage._scanner) }() - case 684: try { try decoder.decodeSingularInt32Field(value: &_storage._seconds) }() - case 685: try { try decoder.decodeSingularInt32Field(value: &_storage._self_p) }() - case 686: try { try decoder.decodeSingularInt32Field(value: &_storage._separator) }() - case 687: try { try decoder.decodeSingularInt32Field(value: &_storage._serialize) }() - case 688: try { try decoder.decodeSingularInt32Field(value: &_storage._serializedData) }() - case 689: try { try decoder.decodeSingularInt32Field(value: &_storage._serializedSize) }() - case 690: try { try decoder.decodeSingularInt32Field(value: &_storage._serverStreaming) }() - case 691: try { try decoder.decodeSingularInt32Field(value: &_storage._service) }() - case 692: try { try decoder.decodeSingularInt32Field(value: &_storage._serviceDescriptorProto) }() - case 693: try { try decoder.decodeSingularInt32Field(value: &_storage._serviceOptions) }() - case 694: try { try decoder.decodeSingularInt32Field(value: &_storage._set) }() - case 695: try { try decoder.decodeSingularInt32Field(value: &_storage._setExtensionValue) }() - case 696: try { try decoder.decodeSingularInt32Field(value: &_storage._shift) }() - case 697: try { try decoder.decodeSingularInt32Field(value: &_storage._simpleExtensionMap) }() - case 698: try { try decoder.decodeSingularInt32Field(value: &_storage._sizer) }() - case 699: try { try decoder.decodeSingularInt32Field(value: &_storage._source) }() - case 700: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceCodeInfo) }() - case 701: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceContext) }() - case 702: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceEncoding) }() - case 703: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceFile) }() - case 704: try { try decoder.decodeSingularInt32Field(value: &_storage._span) }() - case 705: try { try decoder.decodeSingularInt32Field(value: &_storage._split) }() - case 706: try { try decoder.decodeSingularInt32Field(value: &_storage._start) }() - case 707: try { try decoder.decodeSingularInt32Field(value: &_storage._startArray) }() - case 708: try { try decoder.decodeSingularInt32Field(value: &_storage._startArrayObject) }() - case 709: try { try decoder.decodeSingularInt32Field(value: &_storage._startField) }() - case 710: try { try decoder.decodeSingularInt32Field(value: &_storage._startIndex) }() - case 711: try { try decoder.decodeSingularInt32Field(value: &_storage._startMessageField) }() - case 712: try { try decoder.decodeSingularInt32Field(value: &_storage._startObject) }() - case 713: try { try decoder.decodeSingularInt32Field(value: &_storage._startRegularField) }() - case 714: try { try decoder.decodeSingularInt32Field(value: &_storage._state) }() - case 715: try { try decoder.decodeSingularInt32Field(value: &_storage._static) }() - case 716: try { try decoder.decodeSingularInt32Field(value: &_storage._staticString) }() - case 717: try { try decoder.decodeSingularInt32Field(value: &_storage._storage) }() - case 718: try { try decoder.decodeSingularInt32Field(value: &_storage._string) }() - case 719: try { try decoder.decodeSingularInt32Field(value: &_storage._stringLiteral) }() - case 720: try { try decoder.decodeSingularInt32Field(value: &_storage._stringLiteralType) }() - case 721: try { try decoder.decodeSingularInt32Field(value: &_storage._stringResult) }() - case 722: try { try decoder.decodeSingularInt32Field(value: &_storage._stringValue) }() - case 723: try { try decoder.decodeSingularInt32Field(value: &_storage._struct) }() - case 724: try { try decoder.decodeSingularInt32Field(value: &_storage._structValue) }() - case 725: try { try decoder.decodeSingularInt32Field(value: &_storage._subDecoder) }() - case 726: try { try decoder.decodeSingularInt32Field(value: &_storage._subscript) }() - case 727: try { try decoder.decodeSingularInt32Field(value: &_storage._subVisitor) }() - case 728: try { try decoder.decodeSingularInt32Field(value: &_storage._swift) }() - case 729: try { try decoder.decodeSingularInt32Field(value: &_storage._swiftPrefix) }() - case 730: try { try decoder.decodeSingularInt32Field(value: &_storage._swiftProtobuf) }() - case 731: try { try decoder.decodeSingularInt32Field(value: &_storage._syntax) }() - case 732: try { try decoder.decodeSingularInt32Field(value: &_storage._t) }() - case 733: try { try decoder.decodeSingularInt32Field(value: &_storage._tag) }() - case 734: try { try decoder.decodeSingularInt32Field(value: &_storage._terminator) }() - case 735: try { try decoder.decodeSingularInt32Field(value: &_storage._testDecoder) }() - case 736: try { try decoder.decodeSingularInt32Field(value: &_storage._text) }() - case 737: try { try decoder.decodeSingularInt32Field(value: &_storage._textDecoder) }() - case 738: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatDecoder) }() - case 739: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatDecodingError) }() - case 740: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatDecodingOptions) }() - case 741: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatEncodingOptions) }() - case 742: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatEncodingVisitor) }() - case 743: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatString) }() - case 744: try { try decoder.decodeSingularInt32Field(value: &_storage._throws) }() - case 745: try { try decoder.decodeSingularInt32Field(value: &_storage._timeInterval) }() - case 746: try { try decoder.decodeSingularInt32Field(value: &_storage._timeIntervalSince1970) }() - case 747: try { try decoder.decodeSingularInt32Field(value: &_storage._timeIntervalSinceReferenceDate) }() - case 748: try { try decoder.decodeSingularInt32Field(value: &_storage._timestamp) }() - case 749: try { try decoder.decodeSingularInt32Field(value: &_storage._total) }() - case 750: try { try decoder.decodeSingularInt32Field(value: &_storage._totalArrayDepth) }() - case 751: try { try decoder.decodeSingularInt32Field(value: &_storage._totalSize) }() - case 752: try { try decoder.decodeSingularInt32Field(value: &_storage._trailingComments) }() - case 753: try { try decoder.decodeSingularInt32Field(value: &_storage._traverse) }() - case 754: try { try decoder.decodeSingularInt32Field(value: &_storage._true) }() - case 755: try { try decoder.decodeSingularInt32Field(value: &_storage._try) }() - case 756: try { try decoder.decodeSingularInt32Field(value: &_storage._type) }() - case 757: try { try decoder.decodeSingularInt32Field(value: &_storage._typealias) }() - case 758: try { try decoder.decodeSingularInt32Field(value: &_storage._typeEnum) }() - case 759: try { try decoder.decodeSingularInt32Field(value: &_storage._typeName) }() - case 760: try { try decoder.decodeSingularInt32Field(value: &_storage._typePrefix) }() - case 761: try { try decoder.decodeSingularInt32Field(value: &_storage._typeStart) }() - case 762: try { try decoder.decodeSingularInt32Field(value: &_storage._typeUnknown) }() - case 763: try { try decoder.decodeSingularInt32Field(value: &_storage._typeURL) }() - case 764: try { try decoder.decodeSingularInt32Field(value: &_storage._uint32) }() - case 765: try { try decoder.decodeSingularInt32Field(value: &_storage._uint32Value) }() - case 766: try { try decoder.decodeSingularInt32Field(value: &_storage._uint64) }() - case 767: try { try decoder.decodeSingularInt32Field(value: &_storage._uint64Value) }() - case 768: try { try decoder.decodeSingularInt32Field(value: &_storage._uint8) }() - case 769: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalarLiteral) }() - case 770: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalarLiteralType) }() - case 771: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalars) }() - case 772: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalarView) }() - case 773: try { try decoder.decodeSingularInt32Field(value: &_storage._uninterpretedOption) }() - case 774: try { try decoder.decodeSingularInt32Field(value: &_storage._union) }() - case 775: try { try decoder.decodeSingularInt32Field(value: &_storage._uniqueStorage) }() - case 776: try { try decoder.decodeSingularInt32Field(value: &_storage._unknown) }() - case 777: try { try decoder.decodeSingularInt32Field(value: &_storage._unknownFields_p) }() - case 778: try { try decoder.decodeSingularInt32Field(value: &_storage._unknownStorage) }() - case 779: try { try decoder.decodeSingularInt32Field(value: &_storage._unpackTo) }() - case 780: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeBufferPointer) }() - case 781: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeMutablePointer) }() - case 782: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeMutableRawBufferPointer) }() - case 783: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeMutableRawPointer) }() - case 784: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeRawBufferPointer) }() - case 785: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeRawPointer) }() - case 786: try { try decoder.decodeSingularInt32Field(value: &_storage._updatedOptions) }() - case 787: try { try decoder.decodeSingularInt32Field(value: &_storage._url) }() - case 788: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8) }() - case 789: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8Ptr) }() - case 790: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8ToDouble) }() - case 791: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8View) }() - case 792: try { try decoder.decodeSingularInt32Field(value: &_storage._v) }() - case 793: try { try decoder.decodeSingularInt32Field(value: &_storage._value) }() - case 794: try { try decoder.decodeSingularInt32Field(value: &_storage._valueField) }() - case 795: try { try decoder.decodeSingularInt32Field(value: &_storage._values) }() - case 796: try { try decoder.decodeSingularInt32Field(value: &_storage._valueType) }() - case 797: try { try decoder.decodeSingularInt32Field(value: &_storage._var) }() - case 798: try { try decoder.decodeSingularInt32Field(value: &_storage._version) }() - case 799: try { try decoder.decodeSingularInt32Field(value: &_storage._versionString) }() - case 800: try { try decoder.decodeSingularInt32Field(value: &_storage._visitExtensionFields) }() - case 801: try { try decoder.decodeSingularInt32Field(value: &_storage._visitExtensionFieldsAsMessageSet) }() - case 802: try { try decoder.decodeSingularInt32Field(value: &_storage._visitMapField) }() - case 803: try { try decoder.decodeSingularInt32Field(value: &_storage._visitor) }() - case 804: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPacked) }() - case 805: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedBoolField) }() - case 806: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedDoubleField) }() - case 807: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedEnumField) }() - case 808: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedFixed32Field) }() - case 809: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedFixed64Field) }() - case 810: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedFloatField) }() - case 811: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedInt32Field) }() - case 812: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedInt64Field) }() - case 813: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSfixed32Field) }() - case 814: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSfixed64Field) }() - case 815: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSint32Field) }() - case 816: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSint64Field) }() - case 817: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedUint32Field) }() - case 818: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedUint64Field) }() - case 819: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeated) }() - case 820: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedBoolField) }() - case 821: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedBytesField) }() - case 822: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedDoubleField) }() - case 823: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedEnumField) }() - case 824: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedFixed32Field) }() - case 825: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedFixed64Field) }() - case 826: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedFloatField) }() - case 827: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedGroupField) }() - case 828: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedInt32Field) }() - case 829: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedInt64Field) }() - case 830: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedMessageField) }() - case 831: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSfixed32Field) }() - case 832: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSfixed64Field) }() - case 833: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSint32Field) }() - case 834: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSint64Field) }() - case 835: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedStringField) }() - case 836: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedUint32Field) }() - case 837: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedUint64Field) }() - case 838: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingular) }() - case 839: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularBoolField) }() - case 840: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularBytesField) }() - case 841: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularDoubleField) }() - case 842: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularEnumField) }() - case 843: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularFixed32Field) }() - case 844: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularFixed64Field) }() - case 845: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularFloatField) }() - case 846: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularGroupField) }() - case 847: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularInt32Field) }() - case 848: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularInt64Field) }() - case 849: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularMessageField) }() - case 850: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSfixed32Field) }() - case 851: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSfixed64Field) }() - case 852: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSint32Field) }() - case 853: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSint64Field) }() - case 854: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularStringField) }() - case 855: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularUint32Field) }() - case 856: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularUint64Field) }() - case 857: try { try decoder.decodeSingularInt32Field(value: &_storage._visitUnknown) }() - case 858: try { try decoder.decodeSingularInt32Field(value: &_storage._wasDecoded) }() - case 859: try { try decoder.decodeSingularInt32Field(value: &_storage._weak) }() - case 860: try { try decoder.decodeSingularInt32Field(value: &_storage._weakDependency) }() - case 861: try { try decoder.decodeSingularInt32Field(value: &_storage._where) }() - case 862: try { try decoder.decodeSingularInt32Field(value: &_storage._wireFormat) }() - case 863: try { try decoder.decodeSingularInt32Field(value: &_storage._with) }() - case 864: try { try decoder.decodeSingularInt32Field(value: &_storage._withUnsafeBytes) }() - case 865: try { try decoder.decodeSingularInt32Field(value: &_storage._withUnsafeMutableBytes) }() - case 866: try { try decoder.decodeSingularInt32Field(value: &_storage._work) }() - case 867: try { try decoder.decodeSingularInt32Field(value: &_storage._wrappedType) }() - case 868: try { try decoder.decodeSingularInt32Field(value: &_storage._written) }() - case 869: try { try decoder.decodeSingularInt32Field(value: &_storage._yday) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &_storage._addPath) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._adjusted) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &_storage._aggregateValue) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &_storage._allCases) }() + case 5: try { try decoder.decodeSingularInt32Field(value: &_storage._allowAlias) }() + case 6: try { try decoder.decodeSingularInt32Field(value: &_storage._alwaysPrintEnumsAsInts) }() + case 7: try { try decoder.decodeSingularInt32Field(value: &_storage._alwaysPrintInt64SAsNumbers) }() + case 8: try { try decoder.decodeSingularInt32Field(value: &_storage._annotation) }() + case 9: try { try decoder.decodeSingularInt32Field(value: &_storage._any) }() + case 10: try { try decoder.decodeSingularInt32Field(value: &_storage._anyExtensionField) }() + case 11: try { try decoder.decodeSingularInt32Field(value: &_storage._anyMessageExtension) }() + case 12: try { try decoder.decodeSingularInt32Field(value: &_storage._anyMessageStorage) }() + case 13: try { try decoder.decodeSingularInt32Field(value: &_storage._anyUnpackError) }() + case 14: try { try decoder.decodeSingularInt32Field(value: &_storage._append) }() + case 15: try { try decoder.decodeSingularInt32Field(value: &_storage._appended) }() + case 16: try { try decoder.decodeSingularInt32Field(value: &_storage._appendUintHex) }() + case 17: try { try decoder.decodeSingularInt32Field(value: &_storage._appendUnknown) }() + case 18: try { try decoder.decodeSingularInt32Field(value: &_storage._areAllInitialized) }() + case 19: try { try decoder.decodeSingularInt32Field(value: &_storage._array) }() + case 20: try { try decoder.decodeSingularInt32Field(value: &_storage._arrayDepth) }() + case 21: try { try decoder.decodeSingularInt32Field(value: &_storage._arrayLiteral) }() + case 22: try { try decoder.decodeSingularInt32Field(value: &_storage._arraySeparator) }() + case 23: try { try decoder.decodeSingularInt32Field(value: &_storage._as) }() + case 24: try { try decoder.decodeSingularInt32Field(value: &_storage._asciiOpenCurlyBracket) }() + case 25: try { try decoder.decodeSingularInt32Field(value: &_storage._asciiZero) }() + case 26: try { try decoder.decodeSingularInt32Field(value: &_storage._async) }() + case 27: try { try decoder.decodeSingularInt32Field(value: &_storage._asyncIterator) }() + case 28: try { try decoder.decodeSingularInt32Field(value: &_storage._asyncIteratorProtocol) }() + case 29: try { try decoder.decodeSingularInt32Field(value: &_storage._asyncMessageSequence) }() + case 30: try { try decoder.decodeSingularInt32Field(value: &_storage._available) }() + case 31: try { try decoder.decodeSingularInt32Field(value: &_storage._b) }() + case 32: try { try decoder.decodeSingularInt32Field(value: &_storage._base) }() + case 33: try { try decoder.decodeSingularInt32Field(value: &_storage._base64Values) }() + case 34: try { try decoder.decodeSingularInt32Field(value: &_storage._baseAddress) }() + case 35: try { try decoder.decodeSingularInt32Field(value: &_storage._baseType) }() + case 36: try { try decoder.decodeSingularInt32Field(value: &_storage._begin) }() + case 37: try { try decoder.decodeSingularInt32Field(value: &_storage._binary) }() + case 38: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryDecoder) }() + case 39: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryDecoding) }() + case 40: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryDecodingError) }() + case 41: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryDecodingOptions) }() + case 42: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryDelimited) }() + case 43: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncoder) }() + case 44: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingError) }() + case 45: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingMessageSetSizeVisitor) }() + case 46: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingMessageSetVisitor) }() + case 47: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingOptions) }() + case 48: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingSizeVisitor) }() + case 49: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryEncodingVisitor) }() + case 50: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryOptions) }() + case 51: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryProtobufDelimitedMessages) }() + case 52: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryStreamDecoding) }() + case 53: try { try decoder.decodeSingularInt32Field(value: &_storage._binaryStreamDecodingError) }() + case 54: try { try decoder.decodeSingularInt32Field(value: &_storage._bitPattern) }() + case 55: try { try decoder.decodeSingularInt32Field(value: &_storage._body) }() + case 56: try { try decoder.decodeSingularInt32Field(value: &_storage._bool) }() + case 57: try { try decoder.decodeSingularInt32Field(value: &_storage._booleanLiteral) }() + case 58: try { try decoder.decodeSingularInt32Field(value: &_storage._booleanLiteralType) }() + case 59: try { try decoder.decodeSingularInt32Field(value: &_storage._boolValue) }() + case 60: try { try decoder.decodeSingularInt32Field(value: &_storage._buffer) }() + case 61: try { try decoder.decodeSingularInt32Field(value: &_storage._byte) }() + case 62: try { try decoder.decodeSingularInt32Field(value: &_storage._bytecode) }() + case 63: try { try decoder.decodeSingularInt32Field(value: &_storage._bytecodeReader) }() + case 64: try { try decoder.decodeSingularInt32Field(value: &_storage._bytes) }() + case 65: try { try decoder.decodeSingularInt32Field(value: &_storage._bytesInGroup) }() + case 66: try { try decoder.decodeSingularInt32Field(value: &_storage._bytesNeeded) }() + case 67: try { try decoder.decodeSingularInt32Field(value: &_storage._bytesRead) }() + case 68: try { try decoder.decodeSingularInt32Field(value: &_storage._c) }() + case 69: try { try decoder.decodeSingularInt32Field(value: &_storage._canonical) }() + case 70: try { try decoder.decodeSingularInt32Field(value: &_storage._capitalizeNext) }() + case 71: try { try decoder.decodeSingularInt32Field(value: &_storage._cardinality) }() + case 72: try { try decoder.decodeSingularInt32Field(value: &_storage._caseIterable) }() + case 73: try { try decoder.decodeSingularInt32Field(value: &_storage._castedValue) }() + case 74: try { try decoder.decodeSingularInt32Field(value: &_storage._ccEnableArenas) }() + case 75: try { try decoder.decodeSingularInt32Field(value: &_storage._ccGenericServices) }() + case 76: try { try decoder.decodeSingularInt32Field(value: &_storage._character) }() + case 77: try { try decoder.decodeSingularInt32Field(value: &_storage._chars) }() + case 78: try { try decoder.decodeSingularInt32Field(value: &_storage._checkProgramFormat) }() + case 79: try { try decoder.decodeSingularInt32Field(value: &_storage._chunk) }() + case 80: try { try decoder.decodeSingularInt32Field(value: &_storage._class) }() + case 81: try { try decoder.decodeSingularInt32Field(value: &_storage._clearAggregateValue_p) }() + case 82: try { try decoder.decodeSingularInt32Field(value: &_storage._clearAllowAlias_p) }() + case 83: try { try decoder.decodeSingularInt32Field(value: &_storage._clearBegin_p) }() + case 84: try { try decoder.decodeSingularInt32Field(value: &_storage._clearCcEnableArenas_p) }() + case 85: try { try decoder.decodeSingularInt32Field(value: &_storage._clearCcGenericServices_p) }() + case 86: try { try decoder.decodeSingularInt32Field(value: &_storage._clearClientStreaming_p) }() + case 87: try { try decoder.decodeSingularInt32Field(value: &_storage._clearCsharpNamespace_p) }() + case 88: try { try decoder.decodeSingularInt32Field(value: &_storage._clearCtype_p) }() + case 89: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDebugRedact_p) }() + case 90: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDefaultSymbolVisibility_p) }() + case 91: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDefaultValue_p) }() + case 92: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDeprecated_p) }() + case 93: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDeprecatedLegacyJsonFieldConflicts_p) }() + case 94: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDeprecationWarning_p) }() + case 95: try { try decoder.decodeSingularInt32Field(value: &_storage._clearDoubleValue_p) }() + case 96: try { try decoder.decodeSingularInt32Field(value: &_storage._clearEdition_p) }() + case 97: try { try decoder.decodeSingularInt32Field(value: &_storage._clearEditionDeprecated_p) }() + case 98: try { try decoder.decodeSingularInt32Field(value: &_storage._clearEditionIntroduced_p) }() + case 99: try { try decoder.decodeSingularInt32Field(value: &_storage._clearEditionRemoved_p) }() + case 100: try { try decoder.decodeSingularInt32Field(value: &_storage._clearEnd_p) }() + case 101: try { try decoder.decodeSingularInt32Field(value: &_storage._clearEnforceNamingStyle_p) }() + case 102: try { try decoder.decodeSingularInt32Field(value: &_storage._clearEnumType_p) }() + case 103: try { try decoder.decodeSingularInt32Field(value: &_storage._clearExtendee_p) }() + case 104: try { try decoder.decodeSingularInt32Field(value: &_storage._clearExtensionValue_p) }() + case 105: try { try decoder.decodeSingularInt32Field(value: &_storage._clearFeatures_p) }() + case 106: try { try decoder.decodeSingularInt32Field(value: &_storage._clearFeatureSupport_p) }() + case 107: try { try decoder.decodeSingularInt32Field(value: &_storage._clearFieldPresence_p) }() + case 108: try { try decoder.decodeSingularInt32Field(value: &_storage._clearFixedFeatures_p) }() + case 109: try { try decoder.decodeSingularInt32Field(value: &_storage._clearFullName_p) }() + case 110: try { try decoder.decodeSingularInt32Field(value: &_storage._clearGoPackage_p) }() + case 111: try { try decoder.decodeSingularInt32Field(value: &_storage._clearIdempotencyLevel_p) }() + case 112: try { try decoder.decodeSingularInt32Field(value: &_storage._clearIdentifierValue_p) }() + case 113: try { try decoder.decodeSingularInt32Field(value: &_storage._clearInputType_p) }() + case 114: try { try decoder.decodeSingularInt32Field(value: &_storage._clearIsExtension_p) }() + case 115: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaGenerateEqualsAndHash_p) }() + case 116: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaGenericServices_p) }() + case 117: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaMultipleFiles_p) }() + case 118: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaOuterClassname_p) }() + case 119: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaPackage_p) }() + case 120: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJavaStringCheckUtf8_p) }() + case 121: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJsonFormat_p) }() + case 122: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJsonName_p) }() + case 123: try { try decoder.decodeSingularInt32Field(value: &_storage._clearJstype_p) }() + case 124: try { try decoder.decodeSingularInt32Field(value: &_storage._clearLabel_p) }() + case 125: try { try decoder.decodeSingularInt32Field(value: &_storage._clearLazy_p) }() + case 126: try { try decoder.decodeSingularInt32Field(value: &_storage._clearLeadingComments_p) }() + case 127: try { try decoder.decodeSingularInt32Field(value: &_storage._clearMapEntry_p) }() + case 128: try { try decoder.decodeSingularInt32Field(value: &_storage._clearMaximumEdition_p) }() + case 129: try { try decoder.decodeSingularInt32Field(value: &_storage._clearMessageEncoding_p) }() + case 130: try { try decoder.decodeSingularInt32Field(value: &_storage._clearMessageSetWireFormat_p) }() + case 131: try { try decoder.decodeSingularInt32Field(value: &_storage._clearMinimumEdition_p) }() + case 132: try { try decoder.decodeSingularInt32Field(value: &_storage._clearName_p) }() + case 133: try { try decoder.decodeSingularInt32Field(value: &_storage._clearNamePart_p) }() + case 134: try { try decoder.decodeSingularInt32Field(value: &_storage._clearNegativeIntValue_p) }() + case 135: try { try decoder.decodeSingularInt32Field(value: &_storage._clearNoStandardDescriptorAccessor_p) }() + case 136: try { try decoder.decodeSingularInt32Field(value: &_storage._clearNumber_p) }() + case 137: try { try decoder.decodeSingularInt32Field(value: &_storage._clearObjcClassPrefix_p) }() + case 138: try { try decoder.decodeSingularInt32Field(value: &_storage._clearOneofIndex_p) }() + case 139: try { try decoder.decodeSingularInt32Field(value: &_storage._clearOptimizeFor_p) }() + case 140: try { try decoder.decodeSingularInt32Field(value: &_storage._clearOptions_p) }() + case 141: try { try decoder.decodeSingularInt32Field(value: &_storage._clearOutputType_p) }() + case 142: try { try decoder.decodeSingularInt32Field(value: &_storage._clearOverridableFeatures_p) }() + case 143: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPackage_p) }() + case 144: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPacked_p) }() + case 145: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPhpClassPrefix_p) }() + case 146: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPhpMetadataNamespace_p) }() + case 147: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPhpNamespace_p) }() + case 148: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPositiveIntValue_p) }() + case 149: try { try decoder.decodeSingularInt32Field(value: &_storage._clearProto3Optional_p) }() + case 150: try { try decoder.decodeSingularInt32Field(value: &_storage._clearPyGenericServices_p) }() + case 151: try { try decoder.decodeSingularInt32Field(value: &_storage._clearRemovalError_p) }() + case 152: try { try decoder.decodeSingularInt32Field(value: &_storage._clearRepeated_p) }() + case 153: try { try decoder.decodeSingularInt32Field(value: &_storage._clearRepeatedFieldEncoding_p) }() + case 154: try { try decoder.decodeSingularInt32Field(value: &_storage._clearReserved_p) }() + case 155: try { try decoder.decodeSingularInt32Field(value: &_storage._clearRetention_p) }() + case 156: try { try decoder.decodeSingularInt32Field(value: &_storage._clearRubyPackage_p) }() + case 157: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSemantic_p) }() + case 158: try { try decoder.decodeSingularInt32Field(value: &_storage._clearServerStreaming_p) }() + case 159: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSourceCodeInfo_p) }() + case 160: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSourceContext_p) }() + case 161: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSourceFile_p) }() + case 162: try { try decoder.decodeSingularInt32Field(value: &_storage._clearStart_p) }() + case 163: try { try decoder.decodeSingularInt32Field(value: &_storage._clearStringValue_p) }() + case 164: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSwiftPrefix_p) }() + case 165: try { try decoder.decodeSingularInt32Field(value: &_storage._clearSyntax_p) }() + case 166: try { try decoder.decodeSingularInt32Field(value: &_storage._clearTrailingComments_p) }() + case 167: try { try decoder.decodeSingularInt32Field(value: &_storage._clearType_p) }() + case 168: try { try decoder.decodeSingularInt32Field(value: &_storage._clearTypeName_p) }() + case 169: try { try decoder.decodeSingularInt32Field(value: &_storage._clearUnverifiedLazy_p) }() + case 170: try { try decoder.decodeSingularInt32Field(value: &_storage._clearUtf8Validation_p) }() + case 171: try { try decoder.decodeSingularInt32Field(value: &_storage._clearValue_p) }() + case 172: try { try decoder.decodeSingularInt32Field(value: &_storage._clearVerification_p) }() + case 173: try { try decoder.decodeSingularInt32Field(value: &_storage._clearVisibility_p) }() + case 174: try { try decoder.decodeSingularInt32Field(value: &_storage._clearWeak_p) }() + case 175: try { try decoder.decodeSingularInt32Field(value: &_storage._clientStreaming) }() + case 176: try { try decoder.decodeSingularInt32Field(value: &_storage._code) }() + case 177: try { try decoder.decodeSingularInt32Field(value: &_storage._codePoint) }() + case 178: try { try decoder.decodeSingularInt32Field(value: &_storage._codeUnits) }() + case 179: try { try decoder.decodeSingularInt32Field(value: &_storage._collection) }() + case 180: try { try decoder.decodeSingularInt32Field(value: &_storage._comma) }() + case 181: try { try decoder.decodeSingularInt32Field(value: &_storage._consumedBytes) }() + case 182: try { try decoder.decodeSingularInt32Field(value: &_storage._contains) }() + case 183: try { try decoder.decodeSingularInt32Field(value: &_storage._contentsOf) }() + case 184: try { try decoder.decodeSingularInt32Field(value: &_storage._contiguousBytes) }() + case 185: try { try decoder.decodeSingularInt32Field(value: &_storage._copy) }() + case 186: try { try decoder.decodeSingularInt32Field(value: &_storage._count) }() + case 187: try { try decoder.decodeSingularInt32Field(value: &_storage._countVarintsInBuffer) }() + case 188: try { try decoder.decodeSingularInt32Field(value: &_storage._csharpNamespace) }() + case 189: try { try decoder.decodeSingularInt32Field(value: &_storage._ctype) }() + case 190: try { try decoder.decodeSingularInt32Field(value: &_storage._customCodable) }() + case 191: try { try decoder.decodeSingularInt32Field(value: &_storage._customDebugStringConvertible) }() + case 192: try { try decoder.decodeSingularInt32Field(value: &_storage._customStringConvertible) }() + case 193: try { try decoder.decodeSingularInt32Field(value: &_storage._d) }() + case 194: try { try decoder.decodeSingularInt32Field(value: &_storage._data) }() + case 195: try { try decoder.decodeSingularInt32Field(value: &_storage._dataResult) }() + case 196: try { try decoder.decodeSingularInt32Field(value: &_storage._date) }() + case 197: try { try decoder.decodeSingularInt32Field(value: &_storage._daySec) }() + case 198: try { try decoder.decodeSingularInt32Field(value: &_storage._daysSinceEpoch) }() + case 199: try { try decoder.decodeSingularInt32Field(value: &_storage._debugDescription_p) }() + case 200: try { try decoder.decodeSingularInt32Field(value: &_storage._debugRedact) }() + case 201: try { try decoder.decodeSingularInt32Field(value: &_storage._declaration) }() + case 202: try { try decoder.decodeSingularInt32Field(value: &_storage._decoded) }() + case 203: try { try decoder.decodeSingularInt32Field(value: &_storage._decodedFromJsonnull) }() + case 204: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeExtensionField) }() + case 205: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeExtensionFieldsAsMessageSet) }() + case 206: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeJson) }() + case 207: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeMapField) }() + case 208: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeMessage) }() + case 209: try { try decoder.decodeSingularInt32Field(value: &_storage._decoder) }() + case 210: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeated) }() + case 211: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedBoolField) }() + case 212: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedBytesField) }() + case 213: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedDoubleField) }() + case 214: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedEnumField) }() + case 215: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedFixed32Field) }() + case 216: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedFixed64Field) }() + case 217: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedFloatField) }() + case 218: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedGroupField) }() + case 219: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedInt32Field) }() + case 220: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedInt64Field) }() + case 221: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedMessageField) }() + case 222: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedSfixed32Field) }() + case 223: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedSfixed64Field) }() + case 224: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedSint32Field) }() + case 225: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedSint64Field) }() + case 226: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedStringField) }() + case 227: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedUint32Field) }() + case 228: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeRepeatedUint64Field) }() + case 229: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingular) }() + case 230: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularBoolField) }() + case 231: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularBytesField) }() + case 232: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularDoubleField) }() + case 233: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularEnumField) }() + case 234: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularFixed32Field) }() + case 235: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularFixed64Field) }() + case 236: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularFloatField) }() + case 237: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularGroupField) }() + case 238: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularInt32Field) }() + case 239: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularInt64Field) }() + case 240: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularMessageField) }() + case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularSfixed32Field) }() + case 242: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularSfixed64Field) }() + case 243: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularSint32Field) }() + case 244: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularSint64Field) }() + case 245: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularStringField) }() + case 246: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularUint32Field) }() + case 247: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeSingularUint64Field) }() + case 248: try { try decoder.decodeSingularInt32Field(value: &_storage._decodeTextFormat) }() + case 249: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultAnyTypeUrlprefix) }() + case 250: try { try decoder.decodeSingularInt32Field(value: &_storage._defaults) }() + case 251: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultSymbolVisibility) }() + case 252: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultValue) }() + case 253: try { try decoder.decodeSingularInt32Field(value: &_storage._dependency) }() + case 254: try { try decoder.decodeSingularInt32Field(value: &_storage._deprecated) }() + case 255: try { try decoder.decodeSingularInt32Field(value: &_storage._deprecatedLegacyJsonFieldConflicts) }() + case 256: try { try decoder.decodeSingularInt32Field(value: &_storage._deprecationWarning) }() + case 257: try { try decoder.decodeSingularInt32Field(value: &_storage._description_p) }() + case 258: try { try decoder.decodeSingularInt32Field(value: &_storage._dictionary) }() + case 259: try { try decoder.decodeSingularInt32Field(value: &_storage._dictionaryLiteral) }() + case 260: try { try decoder.decodeSingularInt32Field(value: &_storage._digit) }() + case 261: try { try decoder.decodeSingularInt32Field(value: &_storage._digit0) }() + case 262: try { try decoder.decodeSingularInt32Field(value: &_storage._digit1) }() + case 263: try { try decoder.decodeSingularInt32Field(value: &_storage._digitCount) }() + case 264: try { try decoder.decodeSingularInt32Field(value: &_storage._digits) }() + case 265: try { try decoder.decodeSingularInt32Field(value: &_storage._digitValue) }() + case 266: try { try decoder.decodeSingularInt32Field(value: &_storage._discardableResult) }() + case 267: try { try decoder.decodeSingularInt32Field(value: &_storage._discardUnknownFields) }() + case 268: try { try decoder.decodeSingularInt32Field(value: &_storage._double) }() + case 269: try { try decoder.decodeSingularInt32Field(value: &_storage._doubleValue) }() + case 270: try { try decoder.decodeSingularInt32Field(value: &_storage._duration) }() + case 271: try { try decoder.decodeSingularInt32Field(value: &_storage._e) }() + case 272: try { try decoder.decodeSingularInt32Field(value: &_storage._edition) }() + case 273: try { try decoder.decodeSingularInt32Field(value: &_storage._editionDefault) }() + case 274: try { try decoder.decodeSingularInt32Field(value: &_storage._editionDefaults) }() + case 275: try { try decoder.decodeSingularInt32Field(value: &_storage._editionDeprecated) }() + case 276: try { try decoder.decodeSingularInt32Field(value: &_storage._editionIntroduced) }() + case 277: try { try decoder.decodeSingularInt32Field(value: &_storage._editionRemoved) }() + case 278: try { try decoder.decodeSingularInt32Field(value: &_storage._element) }() + case 279: try { try decoder.decodeSingularInt32Field(value: &_storage._elements) }() + case 280: try { try decoder.decodeSingularInt32Field(value: &_storage._else) }() + case 281: try { try decoder.decodeSingularInt32Field(value: &_storage._emitExtensionFieldName) }() + case 282: try { try decoder.decodeSingularInt32Field(value: &_storage._emitFieldName) }() + case 283: try { try decoder.decodeSingularInt32Field(value: &_storage._emitFieldNumber) }() + case 284: try { try decoder.decodeSingularInt32Field(value: &_storage._emptyAnyTypeURL) }() + case 285: try { try decoder.decodeSingularInt32Field(value: &_storage._emptyData) }() + case 286: try { try decoder.decodeSingularInt32Field(value: &_storage._encodeAsBytes) }() + case 287: try { try decoder.decodeSingularInt32Field(value: &_storage._encoded) }() + case 288: try { try decoder.decodeSingularInt32Field(value: &_storage._encodedJsonstring) }() + case 289: try { try decoder.decodeSingularInt32Field(value: &_storage._encodedSize) }() + case 290: try { try decoder.decodeSingularInt32Field(value: &_storage._encodeField) }() + case 291: try { try decoder.decodeSingularInt32Field(value: &_storage._encoder) }() + case 292: try { try decoder.decodeSingularInt32Field(value: &_storage._end) }() + case 293: try { try decoder.decodeSingularInt32Field(value: &_storage._endArray) }() + case 294: try { try decoder.decodeSingularInt32Field(value: &_storage._endMessageField) }() + case 295: try { try decoder.decodeSingularInt32Field(value: &_storage._endObject) }() + case 296: try { try decoder.decodeSingularInt32Field(value: &_storage._endRegularField) }() + case 297: try { try decoder.decodeSingularInt32Field(value: &_storage._enforceNamingStyle) }() + case 298: try { try decoder.decodeSingularInt32Field(value: &_storage._enum) }() + case 299: try { try decoder.decodeSingularInt32Field(value: &_storage._enumReservedRange) }() + case 300: try { try decoder.decodeSingularInt32Field(value: &_storage._enumType) }() + case 301: try { try decoder.decodeSingularInt32Field(value: &_storage._enumvalue) }() + case 302: try { try decoder.decodeSingularInt32Field(value: &_storage._equatable) }() + case 303: try { try decoder.decodeSingularInt32Field(value: &_storage._error) }() + case 304: try { try decoder.decodeSingularInt32Field(value: &_storage._execute) }() + case 305: try { try decoder.decodeSingularInt32Field(value: &_storage._expressibleByArrayLiteral) }() + case 306: try { try decoder.decodeSingularInt32Field(value: &_storage._expressibleByDictionaryLiteral) }() + case 307: try { try decoder.decodeSingularInt32Field(value: &_storage._ext) }() + case 308: try { try decoder.decodeSingularInt32Field(value: &_storage._extDecoder) }() + case 309: try { try decoder.decodeSingularInt32Field(value: &_storage._extendedGraphemeClusterLiteral) }() + case 310: try { try decoder.decodeSingularInt32Field(value: &_storage._extendedGraphemeClusterLiteralType) }() + case 311: try { try decoder.decodeSingularInt32Field(value: &_storage._extendee) }() + case 312: try { try decoder.decodeSingularInt32Field(value: &_storage._extensibleMessage) }() + case 313: try { try decoder.decodeSingularInt32Field(value: &_storage._extension) }() + case 314: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionField) }() + case 315: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionFieldNumber) }() + case 316: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionFieldValueSet) }() + case 317: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionMap) }() + case 318: try { try decoder.decodeSingularInt32Field(value: &_storage._extensionRange) }() + case 319: try { try decoder.decodeSingularInt32Field(value: &_storage._extensions) }() + case 320: try { try decoder.decodeSingularInt32Field(value: &_storage._extras) }() + case 321: try { try decoder.decodeSingularInt32Field(value: &_storage._f) }() + case 322: try { try decoder.decodeSingularInt32Field(value: &_storage._false) }() + case 323: try { try decoder.decodeSingularInt32Field(value: &_storage._features) }() + case 324: try { try decoder.decodeSingularInt32Field(value: &_storage._featureSetEditionDefault) }() + case 325: try { try decoder.decodeSingularInt32Field(value: &_storage._featureSupport) }() + case 326: try { try decoder.decodeSingularInt32Field(value: &_storage._field) }() + case 327: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldData) }() + case 328: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldMaskError) }() + case 329: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldName) }() + case 330: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNameCount) }() + case 331: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNum) }() + case 332: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNumber) }() + case 333: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldNumberForProto) }() + case 334: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldPresence) }() + case 335: try { try decoder.decodeSingularInt32Field(value: &_storage._fields) }() + case 336: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldSize) }() + case 337: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldTag) }() + case 338: try { try decoder.decodeSingularInt32Field(value: &_storage._fieldType) }() + case 339: try { try decoder.decodeSingularInt32Field(value: &_storage._file) }() + case 340: try { try decoder.decodeSingularInt32Field(value: &_storage._fileName) }() + case 341: try { try decoder.decodeSingularInt32Field(value: &_storage._filter) }() + case 342: try { try decoder.decodeSingularInt32Field(value: &_storage._final) }() + case 343: try { try decoder.decodeSingularInt32Field(value: &_storage._finiteOnly) }() + case 344: try { try decoder.decodeSingularInt32Field(value: &_storage._first) }() + case 345: try { try decoder.decodeSingularInt32Field(value: &_storage._firstItem) }() + case 346: try { try decoder.decodeSingularInt32Field(value: &_storage._fixedFeatures) }() + case 347: try { try decoder.decodeSingularInt32Field(value: &_storage._float) }() + case 348: try { try decoder.decodeSingularInt32Field(value: &_storage._floatLiteral) }() + case 349: try { try decoder.decodeSingularInt32Field(value: &_storage._floatLiteralType) }() + case 350: try { try decoder.decodeSingularInt32Field(value: &_storage._for) }() + case 351: try { try decoder.decodeSingularInt32Field(value: &_storage._forMessageName) }() + case 352: try { try decoder.decodeSingularInt32Field(value: &_storage._formUnion) }() + case 353: try { try decoder.decodeSingularInt32Field(value: &_storage._forReadingFrom) }() + case 354: try { try decoder.decodeSingularInt32Field(value: &_storage._forTypeURL) }() + case 355: try { try decoder.decodeSingularInt32Field(value: &_storage._forwardParser) }() + case 356: try { try decoder.decodeSingularInt32Field(value: &_storage._forWritingInto) }() + case 357: try { try decoder.decodeSingularInt32Field(value: &_storage._from) }() + case 358: try { try decoder.decodeSingularInt32Field(value: &_storage._fromAscii2) }() + case 359: try { try decoder.decodeSingularInt32Field(value: &_storage._fromAscii4) }() + case 360: try { try decoder.decodeSingularInt32Field(value: &_storage._fromByteOffset) }() + case 361: try { try decoder.decodeSingularInt32Field(value: &_storage._fromHexDigit) }() + case 362: try { try decoder.decodeSingularInt32Field(value: &_storage._fullName) }() + case 363: try { try decoder.decodeSingularInt32Field(value: &_storage._func) }() + case 364: try { try decoder.decodeSingularInt32Field(value: &_storage._function) }() + case 365: try { try decoder.decodeSingularInt32Field(value: &_storage._g) }() + case 366: try { try decoder.decodeSingularInt32Field(value: &_storage._get) }() + case 367: try { try decoder.decodeSingularInt32Field(value: &_storage._getExtensionValue) }() + case 368: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufAny) }() + case 369: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufApi) }() + case 370: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufBoolValue) }() + case 371: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufBytesValue) }() + case 372: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufDescriptorProto) }() + case 373: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufDoubleValue) }() + case 374: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufDuration) }() + case 375: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEdition) }() + case 376: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEmpty) }() + case 377: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnum) }() + case 378: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumDescriptorProto) }() + case 379: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumOptions) }() + case 380: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumValue) }() + case 381: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumValueDescriptorProto) }() + case 382: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufEnumValueOptions) }() + case 383: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufExtensionRangeOptions) }() + case 384: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFeatureSet) }() + case 385: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFeatureSetDefaults) }() + case 386: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufField) }() + case 387: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFieldDescriptorProto) }() + case 388: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFieldMask) }() + case 389: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFieldOptions) }() + case 390: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFileDescriptorProto) }() + case 391: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFileDescriptorSet) }() + case 392: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFileOptions) }() + case 393: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufFloatValue) }() + case 394: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufGeneratedCodeInfo) }() + case 395: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufInt32Value) }() + case 396: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufInt64Value) }() + case 397: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufListValue) }() + case 398: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMessageOptions) }() + case 399: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMethod) }() + case 400: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMethodDescriptorProto) }() + case 401: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMethodOptions) }() + case 402: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufMixin) }() + case 403: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufNullValue) }() + case 404: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufOneofDescriptorProto) }() + case 405: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufOneofOptions) }() + case 406: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufOption) }() + case 407: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufServiceDescriptorProto) }() + case 408: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufServiceOptions) }() + case 409: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSourceCodeInfo) }() + case 410: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSourceContext) }() + case 411: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufStringValue) }() + case 412: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufStruct) }() + case 413: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSymbolVisibility) }() + case 414: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufSyntax) }() + case 415: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufTimestamp) }() + case 416: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufType) }() + case 417: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufUint32Value) }() + case 418: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufUint64Value) }() + case 419: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufUninterpretedOption) }() + case 420: try { try decoder.decodeSingularInt32Field(value: &_storage._googleProtobufValue) }() + case 421: try { try decoder.decodeSingularInt32Field(value: &_storage._goPackage) }() + case 422: try { try decoder.decodeSingularInt32Field(value: &_storage._gotData) }() + case 423: try { try decoder.decodeSingularInt32Field(value: &_storage._group) }() + case 424: try { try decoder.decodeSingularInt32Field(value: &_storage._groupFieldNumberStack) }() + case 425: try { try decoder.decodeSingularInt32Field(value: &_storage._groupSize) }() + case 426: try { try decoder.decodeSingularInt32Field(value: &_storage._guard) }() + case 427: try { try decoder.decodeSingularInt32Field(value: &_storage._hadOneofValue) }() + case 428: try { try decoder.decodeSingularInt32Field(value: &_storage._handleConflictingOneOf) }() + case 429: try { try decoder.decodeSingularInt32Field(value: &_storage._handleInstruction) }() + case 430: try { try decoder.decodeSingularInt32Field(value: &_storage._hasAggregateValue_p) }() + case 431: try { try decoder.decodeSingularInt32Field(value: &_storage._hasAllowAlias_p) }() + case 432: try { try decoder.decodeSingularInt32Field(value: &_storage._hasBegin_p) }() + case 433: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCcEnableArenas_p) }() + case 434: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCcGenericServices_p) }() + case 435: try { try decoder.decodeSingularInt32Field(value: &_storage._hasClientStreaming_p) }() + case 436: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCsharpNamespace_p) }() + case 437: try { try decoder.decodeSingularInt32Field(value: &_storage._hasCtype_p) }() + case 438: try { try decoder.decodeSingularInt32Field(value: &_storage._hasData_p) }() + case 439: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDebugRedact_p) }() + case 440: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDefaultSymbolVisibility_p) }() + case 441: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDefaultValue_p) }() + case 442: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDeprecated_p) }() + case 443: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDeprecatedLegacyJsonFieldConflicts_p) }() + case 444: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDeprecationWarning_p) }() + case 445: try { try decoder.decodeSingularInt32Field(value: &_storage._hasDoubleValue_p) }() + case 446: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEdition_p) }() + case 447: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEditionDeprecated_p) }() + case 448: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEditionIntroduced_p) }() + case 449: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEditionRemoved_p) }() + case 450: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEnd_p) }() + case 451: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEnforceNamingStyle_p) }() + case 452: try { try decoder.decodeSingularInt32Field(value: &_storage._hasEnumType_p) }() + case 453: try { try decoder.decodeSingularInt32Field(value: &_storage._hasExplicitDelta_p) }() + case 454: try { try decoder.decodeSingularInt32Field(value: &_storage._hasExtendee_p) }() + case 455: try { try decoder.decodeSingularInt32Field(value: &_storage._hasExtensionValue_p) }() + case 456: try { try decoder.decodeSingularInt32Field(value: &_storage._hasFeatures_p) }() + case 457: try { try decoder.decodeSingularInt32Field(value: &_storage._hasFeatureSupport_p) }() + case 458: try { try decoder.decodeSingularInt32Field(value: &_storage._hasFieldPresence_p) }() + case 459: try { try decoder.decodeSingularInt32Field(value: &_storage._hasFixedFeatures_p) }() + case 460: try { try decoder.decodeSingularInt32Field(value: &_storage._hasFullName_p) }() + case 461: try { try decoder.decodeSingularInt32Field(value: &_storage._hasGoPackage_p) }() + case 462: try { try decoder.decodeSingularInt32Field(value: &_storage._hash) }() + case 463: try { try decoder.decodeSingularInt32Field(value: &_storage._hashable) }() + case 464: try { try decoder.decodeSingularInt32Field(value: &_storage._hasher) }() + case 465: try { try decoder.decodeSingularInt32Field(value: &_storage._hashVisitor) }() + case 466: try { try decoder.decodeSingularInt32Field(value: &_storage._hasIdempotencyLevel_p) }() + case 467: try { try decoder.decodeSingularInt32Field(value: &_storage._hasIdentifierValue_p) }() + case 468: try { try decoder.decodeSingularInt32Field(value: &_storage._hasInputType_p) }() + case 469: try { try decoder.decodeSingularInt32Field(value: &_storage._hasIsExtension_p) }() + case 470: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaGenerateEqualsAndHash_p) }() + case 471: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaGenericServices_p) }() + case 472: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaMultipleFiles_p) }() + case 473: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaOuterClassname_p) }() + case 474: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaPackage_p) }() + case 475: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJavaStringCheckUtf8_p) }() + case 476: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJsonFormat_p) }() + case 477: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJsonName_p) }() + case 478: try { try decoder.decodeSingularInt32Field(value: &_storage._hasJstype_p) }() + case 479: try { try decoder.decodeSingularInt32Field(value: &_storage._hasLabel_p) }() + case 480: try { try decoder.decodeSingularInt32Field(value: &_storage._hasLazy_p) }() + case 481: try { try decoder.decodeSingularInt32Field(value: &_storage._hasLeadingComments_p) }() + case 482: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMapEntry_p) }() + case 483: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMaximumEdition_p) }() + case 484: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMessageEncoding_p) }() + case 485: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMessageSetWireFormat_p) }() + case 486: try { try decoder.decodeSingularInt32Field(value: &_storage._hasMinimumEdition_p) }() + case 487: try { try decoder.decodeSingularInt32Field(value: &_storage._hasName_p) }() + case 488: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNamePart_p) }() + case 489: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNegativeIntValue_p) }() + case 490: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNoStandardDescriptorAccessor_p) }() + case 491: try { try decoder.decodeSingularInt32Field(value: &_storage._hasNumber_p) }() + case 492: try { try decoder.decodeSingularInt32Field(value: &_storage._hasObjcClassPrefix_p) }() + case 493: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOneofIndex_p) }() + case 494: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOptimizeFor_p) }() + case 495: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOptions_p) }() + case 496: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOutputType_p) }() + case 497: try { try decoder.decodeSingularInt32Field(value: &_storage._hasOverridableFeatures_p) }() + case 498: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPackage_p) }() + case 499: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPacked_p) }() + case 500: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpClassPrefix_p) }() + case 501: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpMetadataNamespace_p) }() + case 502: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPhpNamespace_p) }() + case 503: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPositiveIntValue_p) }() + case 504: try { try decoder.decodeSingularInt32Field(value: &_storage._hasProto3Optional_p) }() + case 505: try { try decoder.decodeSingularInt32Field(value: &_storage._hasPyGenericServices_p) }() + case 506: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRemovalError_p) }() + case 507: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRepeated_p) }() + case 508: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRepeatedFieldEncoding_p) }() + case 509: try { try decoder.decodeSingularInt32Field(value: &_storage._hasReserved_p) }() + case 510: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRetention_p) }() + case 511: try { try decoder.decodeSingularInt32Field(value: &_storage._hasRubyPackage_p) }() + case 512: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSemantic_p) }() + case 513: try { try decoder.decodeSingularInt32Field(value: &_storage._hasServerStreaming_p) }() + case 514: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSourceCodeInfo_p) }() + case 515: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSourceContext_p) }() + case 516: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSourceFile_p) }() + case 517: try { try decoder.decodeSingularInt32Field(value: &_storage._hasStart_p) }() + case 518: try { try decoder.decodeSingularInt32Field(value: &_storage._hasStringValue_p) }() + case 519: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSwiftPrefix_p) }() + case 520: try { try decoder.decodeSingularInt32Field(value: &_storage._hasSyntax_p) }() + case 521: try { try decoder.decodeSingularInt32Field(value: &_storage._hasTrailingComments_p) }() + case 522: try { try decoder.decodeSingularInt32Field(value: &_storage._hasType_p) }() + case 523: try { try decoder.decodeSingularInt32Field(value: &_storage._hasTypeName_p) }() + case 524: try { try decoder.decodeSingularInt32Field(value: &_storage._hasUnverifiedLazy_p) }() + case 525: try { try decoder.decodeSingularInt32Field(value: &_storage._hasUtf8Validation_p) }() + case 526: try { try decoder.decodeSingularInt32Field(value: &_storage._hasValue_p) }() + case 527: try { try decoder.decodeSingularInt32Field(value: &_storage._hasVerification_p) }() + case 528: try { try decoder.decodeSingularInt32Field(value: &_storage._hasVisibility_p) }() + case 529: try { try decoder.decodeSingularInt32Field(value: &_storage._hasWeak_p) }() + case 530: try { try decoder.decodeSingularInt32Field(value: &_storage._hour) }() + case 531: try { try decoder.decodeSingularInt32Field(value: &_storage._i) }() + case 532: try { try decoder.decodeSingularInt32Field(value: &_storage._idempotencyLevel) }() + case 533: try { try decoder.decodeSingularInt32Field(value: &_storage._identifierValue) }() + case 534: try { try decoder.decodeSingularInt32Field(value: &_storage._if) }() + case 535: try { try decoder.decodeSingularInt32Field(value: &_storage._ignoreUnknownExtensionFields) }() + case 536: try { try decoder.decodeSingularInt32Field(value: &_storage._ignoreUnknownFields) }() + case 537: try { try decoder.decodeSingularInt32Field(value: &_storage._index) }() + case 538: try { try decoder.decodeSingularInt32Field(value: &_storage._init_p) }() + case 539: try { try decoder.decodeSingularInt32Field(value: &_storage._inout) }() + case 540: try { try decoder.decodeSingularInt32Field(value: &_storage._inputType) }() + case 541: try { try decoder.decodeSingularInt32Field(value: &_storage._insert) }() + case 542: try { try decoder.decodeSingularInt32Field(value: &_storage._instruction) }() + case 543: try { try decoder.decodeSingularInt32Field(value: &_storage._int) }() + case 544: try { try decoder.decodeSingularInt32Field(value: &_storage._int32) }() + case 545: try { try decoder.decodeSingularInt32Field(value: &_storage._int64) }() + case 546: try { try decoder.decodeSingularInt32Field(value: &_storage._int8) }() + case 547: try { try decoder.decodeSingularInt32Field(value: &_storage._integerLiteral) }() + case 548: try { try decoder.decodeSingularInt32Field(value: &_storage._integerLiteralType) }() + case 549: try { try decoder.decodeSingularInt32Field(value: &_storage._intern) }() + case 550: try { try decoder.decodeSingularInt32Field(value: &_storage._internal) }() + case 551: try { try decoder.decodeSingularInt32Field(value: &_storage._internalState) }() + case 552: try { try decoder.decodeSingularInt32Field(value: &_storage._intersect) }() + case 553: try { try decoder.decodeSingularInt32Field(value: &_storage._into) }() + case 554: try { try decoder.decodeSingularInt32Field(value: &_storage._ints) }() + case 555: try { try decoder.decodeSingularInt32Field(value: &_storage._invalidAnyTypeURL) }() + case 556: try { try decoder.decodeSingularInt32Field(value: &_storage._isA) }() + case 557: try { try decoder.decodeSingularInt32Field(value: &_storage._isEqual) }() + case 558: try { try decoder.decodeSingularInt32Field(value: &_storage._isEqualTo) }() + case 559: try { try decoder.decodeSingularInt32Field(value: &_storage._isExtension) }() + case 560: try { try decoder.decodeSingularInt32Field(value: &_storage._isInitialized_p) }() + case 561: try { try decoder.decodeSingularInt32Field(value: &_storage._isNegative) }() + case 562: try { try decoder.decodeSingularInt32Field(value: &_storage._isPathValid) }() + case 563: try { try decoder.decodeSingularInt32Field(value: &_storage._isReserved) }() + case 564: try { try decoder.decodeSingularInt32Field(value: &_storage._isValid) }() + case 565: try { try decoder.decodeSingularInt32Field(value: &_storage._itemTagsEncodedSize) }() + case 566: try { try decoder.decodeSingularInt32Field(value: &_storage._iterator) }() + case 567: try { try decoder.decodeSingularInt32Field(value: &_storage._javaGenerateEqualsAndHash) }() + case 568: try { try decoder.decodeSingularInt32Field(value: &_storage._javaGenericServices) }() + case 569: try { try decoder.decodeSingularInt32Field(value: &_storage._javaMultipleFiles) }() + case 570: try { try decoder.decodeSingularInt32Field(value: &_storage._javaOuterClassname) }() + case 571: try { try decoder.decodeSingularInt32Field(value: &_storage._javaPackage) }() + case 572: try { try decoder.decodeSingularInt32Field(value: &_storage._javaStringCheckUtf8) }() + case 573: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecoder) }() + case 574: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecoding) }() + case 575: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecodingError) }() + case 576: try { try decoder.decodeSingularInt32Field(value: &_storage._jsondecodingOptions) }() + case 577: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonEncoder) }() + case 578: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencoding) }() + case 579: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencodingError) }() + case 580: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencodingOptions) }() + case 581: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonencodingVisitor) }() + case 582: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonFormat) }() + case 583: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonmapEncodingVisitor) }() + case 584: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonName) }() + case 585: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonPath) }() + case 586: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonPaths) }() + case 587: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonscanner) }() + case 588: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonString) }() + case 589: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonText) }() + case 590: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonUtf8Bytes) }() + case 591: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonUtf8Data) }() + case 592: try { try decoder.decodeSingularInt32Field(value: &_storage._jstype) }() + case 593: try { try decoder.decodeSingularInt32Field(value: &_storage._k) }() + case 594: try { try decoder.decodeSingularInt32Field(value: &_storage._kChunkSize) }() + case 595: try { try decoder.decodeSingularInt32Field(value: &_storage._key) }() + case 596: try { try decoder.decodeSingularInt32Field(value: &_storage._keyField) }() + case 597: try { try decoder.decodeSingularInt32Field(value: &_storage._keyFieldOpt) }() + case 598: try { try decoder.decodeSingularInt32Field(value: &_storage._keyType) }() + case 599: try { try decoder.decodeSingularInt32Field(value: &_storage._kind) }() + case 600: try { try decoder.decodeSingularInt32Field(value: &_storage._l) }() + case 601: try { try decoder.decodeSingularInt32Field(value: &_storage._label) }() + case 602: try { try decoder.decodeSingularInt32Field(value: &_storage._lazy) }() + case 603: try { try decoder.decodeSingularInt32Field(value: &_storage._leadingComments) }() + case 604: try { try decoder.decodeSingularInt32Field(value: &_storage._leadingDetachedComments) }() + case 605: try { try decoder.decodeSingularInt32Field(value: &_storage._length) }() + case 606: try { try decoder.decodeSingularInt32Field(value: &_storage._lessThan) }() + case 607: try { try decoder.decodeSingularInt32Field(value: &_storage._let) }() + case 608: try { try decoder.decodeSingularInt32Field(value: &_storage._lhs) }() + case 609: try { try decoder.decodeSingularInt32Field(value: &_storage._line) }() + case 610: try { try decoder.decodeSingularInt32Field(value: &_storage._list) }() + case 611: try { try decoder.decodeSingularInt32Field(value: &_storage._listOfMessages) }() + case 612: try { try decoder.decodeSingularInt32Field(value: &_storage._listValue) }() + case 613: try { try decoder.decodeSingularInt32Field(value: &_storage._littleEndian) }() + case 614: try { try decoder.decodeSingularInt32Field(value: &_storage._load) }() + case 615: try { try decoder.decodeSingularInt32Field(value: &_storage._localHasher) }() + case 616: try { try decoder.decodeSingularInt32Field(value: &_storage._location) }() + case 617: try { try decoder.decodeSingularInt32Field(value: &_storage._m) }() + case 618: try { try decoder.decodeSingularInt32Field(value: &_storage._major) }() + case 619: try { try decoder.decodeSingularInt32Field(value: &_storage._makeAsyncIterator) }() + case 620: try { try decoder.decodeSingularInt32Field(value: &_storage._makeIterator) }() + case 621: try { try decoder.decodeSingularInt32Field(value: &_storage._malformedLength) }() + case 622: try { try decoder.decodeSingularInt32Field(value: &_storage._mapEntry) }() + case 623: try { try decoder.decodeSingularInt32Field(value: &_storage._mapKeyType) }() + case 624: try { try decoder.decodeSingularInt32Field(value: &_storage._mapToMessages) }() + case 625: try { try decoder.decodeSingularInt32Field(value: &_storage._mapValueType) }() + case 626: try { try decoder.decodeSingularInt32Field(value: &_storage._mapVisitor) }() + case 627: try { try decoder.decodeSingularInt32Field(value: &_storage._mask) }() + case 628: try { try decoder.decodeSingularInt32Field(value: &_storage._maximumEdition) }() + case 629: try { try decoder.decodeSingularInt32Field(value: &_storage._mdayStart) }() + case 630: try { try decoder.decodeSingularInt32Field(value: &_storage._merge) }() + case 631: try { try decoder.decodeSingularInt32Field(value: &_storage._mergeOptions) }() + case 632: try { try decoder.decodeSingularInt32Field(value: &_storage._message) }() + case 633: try { try decoder.decodeSingularInt32Field(value: &_storage._messageDepthLimit) }() + case 634: try { try decoder.decodeSingularInt32Field(value: &_storage._messageEncoding) }() + case 635: try { try decoder.decodeSingularInt32Field(value: &_storage._messageExtension) }() + case 636: try { try decoder.decodeSingularInt32Field(value: &_storage._messageImplementationBase) }() + case 637: try { try decoder.decodeSingularInt32Field(value: &_storage._messageSet) }() + case 638: try { try decoder.decodeSingularInt32Field(value: &_storage._messageSetWireFormat) }() + case 639: try { try decoder.decodeSingularInt32Field(value: &_storage._messageSize) }() + case 640: try { try decoder.decodeSingularInt32Field(value: &_storage._messageType) }() + case 641: try { try decoder.decodeSingularInt32Field(value: &_storage._method) }() + case 642: try { try decoder.decodeSingularInt32Field(value: &_storage._methods) }() + case 643: try { try decoder.decodeSingularInt32Field(value: &_storage._min) }() + case 644: try { try decoder.decodeSingularInt32Field(value: &_storage._minimumEdition) }() + case 645: try { try decoder.decodeSingularInt32Field(value: &_storage._minor) }() + case 646: try { try decoder.decodeSingularInt32Field(value: &_storage._mixins) }() + case 647: try { try decoder.decodeSingularInt32Field(value: &_storage._modify) }() + case 648: try { try decoder.decodeSingularInt32Field(value: &_storage._month) }() + case 649: try { try decoder.decodeSingularInt32Field(value: &_storage._msgExtension) }() + case 650: try { try decoder.decodeSingularInt32Field(value: &_storage._mutating) }() + case 651: try { try decoder.decodeSingularInt32Field(value: &_storage._n) }() + case 652: try { try decoder.decodeSingularInt32Field(value: &_storage._name) }() + case 653: try { try decoder.decodeSingularInt32Field(value: &_storage._nameDescription) }() + case 654: try { try decoder.decodeSingularInt32Field(value: &_storage._nameMap) }() + case 655: try { try decoder.decodeSingularInt32Field(value: &_storage._namePart) }() + case 656: try { try decoder.decodeSingularInt32Field(value: &_storage._names) }() + case 657: try { try decoder.decodeSingularInt32Field(value: &_storage._nanos) }() + case 658: try { try decoder.decodeSingularInt32Field(value: &_storage._negativeIntValue) }() + case 659: try { try decoder.decodeSingularInt32Field(value: &_storage._nestedType) }() + case 660: try { try decoder.decodeSingularInt32Field(value: &_storage._newExtensible) }() + case 661: try { try decoder.decodeSingularInt32Field(value: &_storage._newL) }() + case 662: try { try decoder.decodeSingularInt32Field(value: &_storage._newList) }() + case 663: try { try decoder.decodeSingularInt32Field(value: &_storage._newMessage) }() + case 664: try { try decoder.decodeSingularInt32Field(value: &_storage._newValue) }() + case 665: try { try decoder.decodeSingularInt32Field(value: &_storage._next) }() + case 666: try { try decoder.decodeSingularInt32Field(value: &_storage._nextByte) }() + case 667: try { try decoder.decodeSingularInt32Field(value: &_storage._nextFieldNumber) }() + case 668: try { try decoder.decodeSingularInt32Field(value: &_storage._nextInstruction) }() + case 669: try { try decoder.decodeSingularInt32Field(value: &_storage._nextInt32) }() + case 670: try { try decoder.decodeSingularInt32Field(value: &_storage._nextNullTerminatedString) }() + case 671: try { try decoder.decodeSingularInt32Field(value: &_storage._nextNullTerminatedStringArray) }() + case 672: try { try decoder.decodeSingularInt32Field(value: &_storage._nextNumber) }() + case 673: try { try decoder.decodeSingularInt32Field(value: &_storage._nextUint64) }() + case 674: try { try decoder.decodeSingularInt32Field(value: &_storage._nextVarInt) }() + case 675: try { try decoder.decodeSingularInt32Field(value: &_storage._nil) }() + case 676: try { try decoder.decodeSingularInt32Field(value: &_storage._nilLiteral) }() + case 677: try { try decoder.decodeSingularInt32Field(value: &_storage._noBytesAvailable) }() + case 678: try { try decoder.decodeSingularInt32Field(value: &_storage._noStandardDescriptorAccessor) }() + case 679: try { try decoder.decodeSingularInt32Field(value: &_storage._nullValue) }() + case 680: try { try decoder.decodeSingularInt32Field(value: &_storage._number) }() + case 681: try { try decoder.decodeSingularInt32Field(value: &_storage._numberValue) }() + case 682: try { try decoder.decodeSingularInt32Field(value: &_storage._objcClassPrefix) }() + case 683: try { try decoder.decodeSingularInt32Field(value: &_storage._of) }() + case 684: try { try decoder.decodeSingularInt32Field(value: &_storage._oneOfKind) }() + case 685: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofDecl) }() + case 686: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofIndex) }() + case 687: try { try decoder.decodeSingularInt32Field(value: &_storage._oneofs) }() + case 688: try { try decoder.decodeSingularInt32Field(value: &_storage._optimizeFor) }() + case 689: try { try decoder.decodeSingularInt32Field(value: &_storage._optimizeMode) }() + case 690: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalEnumExtensionField) }() + case 691: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalExtensionField) }() + case 692: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalGroupExtensionField) }() + case 693: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalMessageExtensionField) }() + case 694: try { try decoder.decodeSingularInt32Field(value: &_storage._optionDependency) }() + case 695: try { try decoder.decodeSingularInt32Field(value: &_storage._optionRetention) }() + case 696: try { try decoder.decodeSingularInt32Field(value: &_storage._options) }() + case 697: try { try decoder.decodeSingularInt32Field(value: &_storage._optionTargetType) }() + case 698: try { try decoder.decodeSingularInt32Field(value: &_storage._other) }() + case 699: try { try decoder.decodeSingularInt32Field(value: &_storage._others) }() + case 700: try { try decoder.decodeSingularInt32Field(value: &_storage._out) }() + case 701: try { try decoder.decodeSingularInt32Field(value: &_storage._outputType) }() + case 702: try { try decoder.decodeSingularInt32Field(value: &_storage._overridableFeatures) }() + case 703: try { try decoder.decodeSingularInt32Field(value: &_storage._p) }() + case 704: try { try decoder.decodeSingularInt32Field(value: &_storage._package) }() + case 705: try { try decoder.decodeSingularInt32Field(value: &_storage._packed) }() + case 706: try { try decoder.decodeSingularInt32Field(value: &_storage._packedEnumExtensionField) }() + case 707: try { try decoder.decodeSingularInt32Field(value: &_storage._packedExtensionField) }() + case 708: try { try decoder.decodeSingularInt32Field(value: &_storage._padding) }() + case 709: try { try decoder.decodeSingularInt32Field(value: &_storage._parent) }() + case 710: try { try decoder.decodeSingularInt32Field(value: &_storage._parse) }() + case 711: try { try decoder.decodeSingularInt32Field(value: &_storage._partial) }() + case 712: try { try decoder.decodeSingularInt32Field(value: &_storage._path) }() + case 713: try { try decoder.decodeSingularInt32Field(value: &_storage._pathDecoder) }() + case 714: try { try decoder.decodeSingularInt32Field(value: &_storage._pathDecodingError) }() + case 715: try { try decoder.decodeSingularInt32Field(value: &_storage._paths) }() + case 716: try { try decoder.decodeSingularInt32Field(value: &_storage._pathVisitor) }() + case 717: try { try decoder.decodeSingularInt32Field(value: &_storage._payload) }() + case 718: try { try decoder.decodeSingularInt32Field(value: &_storage._payloadSize) }() + case 719: try { try decoder.decodeSingularInt32Field(value: &_storage._phpClassPrefix) }() + case 720: try { try decoder.decodeSingularInt32Field(value: &_storage._phpMetadataNamespace) }() + case 721: try { try decoder.decodeSingularInt32Field(value: &_storage._phpNamespace) }() + case 722: try { try decoder.decodeSingularInt32Field(value: &_storage._pos) }() + case 723: try { try decoder.decodeSingularInt32Field(value: &_storage._positiveIntValue) }() + case 724: try { try decoder.decodeSingularInt32Field(value: &_storage._prefix) }() + case 725: try { try decoder.decodeSingularInt32Field(value: &_storage._preserveProtoFieldNames) }() + case 726: try { try decoder.decodeSingularInt32Field(value: &_storage._preTraverse) }() + case 727: try { try decoder.decodeSingularInt32Field(value: &_storage._previousNumber) }() + case 728: try { try decoder.decodeSingularInt32Field(value: &_storage._prevPath) }() + case 729: try { try decoder.decodeSingularInt32Field(value: &_storage._printUnknownFields) }() + case 730: try { try decoder.decodeSingularInt32Field(value: &_storage._programBuffer) }() + case 731: try { try decoder.decodeSingularInt32Field(value: &_storage._programFormat) }() + case 732: try { try decoder.decodeSingularInt32Field(value: &_storage._proto2) }() + case 733: try { try decoder.decodeSingularInt32Field(value: &_storage._proto3DefaultValue) }() + case 734: try { try decoder.decodeSingularInt32Field(value: &_storage._proto3Optional) }() + case 735: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufExtensionFieldValues) }() + case 736: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFieldNumber) }() + case 737: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufGeneratedIsEqualTo) }() + case 738: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufNameMap) }() + case 739: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufNewField) }() + case 740: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufPackage) }() + case 741: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufApiversion2) }() + case 742: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufApiversionCheck) }() + case 743: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufBool) }() + case 744: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufBytes) }() + case 745: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufData) }() + case 746: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufDouble) }() + case 747: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufEnumMap) }() + case 748: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufExtension) }() + case 749: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFixed32) }() + case 750: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFixed64) }() + case 751: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufFloat) }() + case 752: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufInt32) }() + case 753: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufInt64) }() + case 754: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufMap) }() + case 755: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufMessageMap) }() + case 756: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSfixed32) }() + case 757: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSfixed64) }() + case 758: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSint32) }() + case 759: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufSint64) }() + case 760: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufString) }() + case 761: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufUint32) }() + case 762: try { try decoder.decodeSingularInt32Field(value: &_storage._protobufUint64) }() + case 763: try { try decoder.decodeSingularInt32Field(value: &_storage._protocol) }() + case 764: try { try decoder.decodeSingularInt32Field(value: &_storage._protoFieldName) }() + case 765: try { try decoder.decodeSingularInt32Field(value: &_storage._protoMessageName) }() + case 766: try { try decoder.decodeSingularInt32Field(value: &_storage._protoNameProviding) }() + case 767: try { try decoder.decodeSingularInt32Field(value: &_storage._protoPaths) }() + case 768: try { try decoder.decodeSingularInt32Field(value: &_storage._public) }() + case 769: try { try decoder.decodeSingularInt32Field(value: &_storage._publicDependency) }() + case 770: try { try decoder.decodeSingularInt32Field(value: &_storage._putBoolValue) }() + case 771: try { try decoder.decodeSingularInt32Field(value: &_storage._putBytesValue) }() + case 772: try { try decoder.decodeSingularInt32Field(value: &_storage._putDoubleValue) }() + case 773: try { try decoder.decodeSingularInt32Field(value: &_storage._putEnumValue) }() + case 774: try { try decoder.decodeSingularInt32Field(value: &_storage._putFixedUint32) }() + case 775: try { try decoder.decodeSingularInt32Field(value: &_storage._putFixedUint64) }() + case 776: try { try decoder.decodeSingularInt32Field(value: &_storage._putFloatValue) }() + case 777: try { try decoder.decodeSingularInt32Field(value: &_storage._putInt64) }() + case 778: try { try decoder.decodeSingularInt32Field(value: &_storage._putStringValue) }() + case 779: try { try decoder.decodeSingularInt32Field(value: &_storage._putUint64) }() + case 780: try { try decoder.decodeSingularInt32Field(value: &_storage._putUint64Hex) }() + case 781: try { try decoder.decodeSingularInt32Field(value: &_storage._putVarInt) }() + case 782: try { try decoder.decodeSingularInt32Field(value: &_storage._putZigZagVarInt) }() + case 783: try { try decoder.decodeSingularInt32Field(value: &_storage._pyGenericServices) }() + case 784: try { try decoder.decodeSingularInt32Field(value: &_storage._r) }() + case 785: try { try decoder.decodeSingularInt32Field(value: &_storage._rawChars) }() + case 786: try { try decoder.decodeSingularInt32Field(value: &_storage._rawRepresentable) }() + case 787: try { try decoder.decodeSingularInt32Field(value: &_storage._rawValue) }() + case 788: try { try decoder.decodeSingularInt32Field(value: &_storage._read4HexDigits) }() + case 789: try { try decoder.decodeSingularInt32Field(value: &_storage._readBytes) }() + case 790: try { try decoder.decodeSingularInt32Field(value: &_storage._reader) }() + case 791: try { try decoder.decodeSingularInt32Field(value: &_storage._register) }() + case 792: try { try decoder.decodeSingularInt32Field(value: &_storage._remainingProgram) }() + case 793: try { try decoder.decodeSingularInt32Field(value: &_storage._removalError) }() + case 794: try { try decoder.decodeSingularInt32Field(value: &_storage._removingAllFieldsOf) }() + case 795: try { try decoder.decodeSingularInt32Field(value: &_storage._repeated) }() + case 796: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedEnumExtensionField) }() + case 797: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedExtensionField) }() + case 798: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedFieldEncoding) }() + case 799: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedGroupExtensionField) }() + case 800: try { try decoder.decodeSingularInt32Field(value: &_storage._repeatedMessageExtensionField) }() + case 801: try { try decoder.decodeSingularInt32Field(value: &_storage._repeating) }() + case 802: try { try decoder.decodeSingularInt32Field(value: &_storage._replaceRepeatedFields) }() + case 803: try { try decoder.decodeSingularInt32Field(value: &_storage._requestStreaming) }() + case 804: try { try decoder.decodeSingularInt32Field(value: &_storage._requestTypeURL) }() + case 805: try { try decoder.decodeSingularInt32Field(value: &_storage._requiredSize) }() + case 806: try { try decoder.decodeSingularInt32Field(value: &_storage._responseStreaming) }() + case 807: try { try decoder.decodeSingularInt32Field(value: &_storage._responseTypeURL) }() + case 808: try { try decoder.decodeSingularInt32Field(value: &_storage._result) }() + case 809: try { try decoder.decodeSingularInt32Field(value: &_storage._retention) }() + case 810: try { try decoder.decodeSingularInt32Field(value: &_storage._rethrows) }() + case 811: try { try decoder.decodeSingularInt32Field(value: &_storage._returnType) }() + case 812: try { try decoder.decodeSingularInt32Field(value: &_storage._revision) }() + case 813: try { try decoder.decodeSingularInt32Field(value: &_storage._rhs) }() + case 814: try { try decoder.decodeSingularInt32Field(value: &_storage._root) }() + case 815: try { try decoder.decodeSingularInt32Field(value: &_storage._rubyPackage) }() + case 816: try { try decoder.decodeSingularInt32Field(value: &_storage._s) }() + case 817: try { try decoder.decodeSingularInt32Field(value: &_storage._sawBackslash) }() + case 818: try { try decoder.decodeSingularInt32Field(value: &_storage._sawSection4Characters) }() + case 819: try { try decoder.decodeSingularInt32Field(value: &_storage._sawSection5Characters) }() + case 820: try { try decoder.decodeSingularInt32Field(value: &_storage._scalar) }() + case 821: try { try decoder.decodeSingularInt32Field(value: &_storage._scan) }() + case 822: try { try decoder.decodeSingularInt32Field(value: &_storage._scanner) }() + case 823: try { try decoder.decodeSingularInt32Field(value: &_storage._seconds) }() + case 824: try { try decoder.decodeSingularInt32Field(value: &_storage._self_p) }() + case 825: try { try decoder.decodeSingularInt32Field(value: &_storage._semantic) }() + case 826: try { try decoder.decodeSingularInt32Field(value: &_storage._sendable) }() + case 827: try { try decoder.decodeSingularInt32Field(value: &_storage._separator) }() + case 828: try { try decoder.decodeSingularInt32Field(value: &_storage._serialize) }() + case 829: try { try decoder.decodeSingularInt32Field(value: &_storage._serializedBytes) }() + case 830: try { try decoder.decodeSingularInt32Field(value: &_storage._serializedData) }() + case 831: try { try decoder.decodeSingularInt32Field(value: &_storage._serializedSize) }() + case 832: try { try decoder.decodeSingularInt32Field(value: &_storage._serverStreaming) }() + case 833: try { try decoder.decodeSingularInt32Field(value: &_storage._service) }() + case 834: try { try decoder.decodeSingularInt32Field(value: &_storage._set) }() + case 835: try { try decoder.decodeSingularInt32Field(value: &_storage._setExtensionValue) }() + case 836: try { try decoder.decodeSingularInt32Field(value: &_storage._shift) }() + case 837: try { try decoder.decodeSingularInt32Field(value: &_storage._simpleExtensionMap) }() + case 838: try { try decoder.decodeSingularInt32Field(value: &_storage._size) }() + case 839: try { try decoder.decodeSingularInt32Field(value: &_storage._sizer) }() + case 840: try { try decoder.decodeSingularInt32Field(value: &_storage._source) }() + case 841: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceCodeInfo) }() + case 842: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceContext) }() + case 843: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceEncoding) }() + case 844: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceFile) }() + case 845: try { try decoder.decodeSingularInt32Field(value: &_storage._sourceLocation) }() + case 846: try { try decoder.decodeSingularInt32Field(value: &_storage._span) }() + case 847: try { try decoder.decodeSingularInt32Field(value: &_storage._split) }() + case 848: try { try decoder.decodeSingularInt32Field(value: &_storage._start) }() + case 849: try { try decoder.decodeSingularInt32Field(value: &_storage._startArray) }() + case 850: try { try decoder.decodeSingularInt32Field(value: &_storage._startArrayObject) }() + case 851: try { try decoder.decodeSingularInt32Field(value: &_storage._startField) }() + case 852: try { try decoder.decodeSingularInt32Field(value: &_storage._startIndex) }() + case 853: try { try decoder.decodeSingularInt32Field(value: &_storage._startMessageField) }() + case 854: try { try decoder.decodeSingularInt32Field(value: &_storage._startObject) }() + case 855: try { try decoder.decodeSingularInt32Field(value: &_storage._startRegularField) }() + case 856: try { try decoder.decodeSingularInt32Field(value: &_storage._state) }() + case 857: try { try decoder.decodeSingularInt32Field(value: &_storage._static) }() + case 858: try { try decoder.decodeSingularInt32Field(value: &_storage._staticString) }() + case 859: try { try decoder.decodeSingularInt32Field(value: &_storage._storage) }() + case 860: try { try decoder.decodeSingularInt32Field(value: &_storage._string) }() + case 861: try { try decoder.decodeSingularInt32Field(value: &_storage._stringLiteral) }() + case 862: try { try decoder.decodeSingularInt32Field(value: &_storage._stringLiteralType) }() + case 863: try { try decoder.decodeSingularInt32Field(value: &_storage._stringResult) }() + case 864: try { try decoder.decodeSingularInt32Field(value: &_storage._stringValue) }() + case 865: try { try decoder.decodeSingularInt32Field(value: &_storage._struct) }() + case 866: try { try decoder.decodeSingularInt32Field(value: &_storage._structValue) }() + case 867: try { try decoder.decodeSingularInt32Field(value: &_storage._subDecoder) }() + case 868: try { try decoder.decodeSingularInt32Field(value: &_storage._subscript) }() + case 869: try { try decoder.decodeSingularInt32Field(value: &_storage._subtract) }() + case 870: try { try decoder.decodeSingularInt32Field(value: &_storage._subVisitor) }() + case 871: try { try decoder.decodeSingularInt32Field(value: &_storage._swift) }() + case 872: try { try decoder.decodeSingularInt32Field(value: &_storage._swiftPrefix) }() + case 873: try { try decoder.decodeSingularInt32Field(value: &_storage._swiftProtobufContiguousBytes) }() + case 874: try { try decoder.decodeSingularInt32Field(value: &_storage._swiftProtobufError) }() + case 875: try { try decoder.decodeSingularInt32Field(value: &_storage._syntax) }() + case 876: try { try decoder.decodeSingularInt32Field(value: &_storage._t) }() + case 877: try { try decoder.decodeSingularInt32Field(value: &_storage._tag) }() + case 878: try { try decoder.decodeSingularInt32Field(value: &_storage._targets) }() + case 879: try { try decoder.decodeSingularInt32Field(value: &_storage._terminator) }() + case 880: try { try decoder.decodeSingularInt32Field(value: &_storage._testDecoder) }() + case 881: try { try decoder.decodeSingularInt32Field(value: &_storage._text) }() + case 882: try { try decoder.decodeSingularInt32Field(value: &_storage._textDecoder) }() + case 883: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatDecoder) }() + case 884: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatDecodingError) }() + case 885: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatDecodingOptions) }() + case 886: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatEncodingOptions) }() + case 887: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatEncodingVisitor) }() + case 888: try { try decoder.decodeSingularInt32Field(value: &_storage._textFormatString) }() + case 889: try { try decoder.decodeSingularInt32Field(value: &_storage._throwOrIgnore) }() + case 890: try { try decoder.decodeSingularInt32Field(value: &_storage._throws) }() + case 891: try { try decoder.decodeSingularInt32Field(value: &_storage._timeInterval) }() + case 892: try { try decoder.decodeSingularInt32Field(value: &_storage._timeIntervalSince1970) }() + case 893: try { try decoder.decodeSingularInt32Field(value: &_storage._timeIntervalSinceReferenceDate) }() + case 894: try { try decoder.decodeSingularInt32Field(value: &_storage._tmp) }() + case 895: try { try decoder.decodeSingularInt32Field(value: &_storage._tooLarge) }() + case 896: try { try decoder.decodeSingularInt32Field(value: &_storage._total) }() + case 897: try { try decoder.decodeSingularInt32Field(value: &_storage._totalArrayDepth) }() + case 898: try { try decoder.decodeSingularInt32Field(value: &_storage._totalSize) }() + case 899: try { try decoder.decodeSingularInt32Field(value: &_storage._trailingComments) }() + case 900: try { try decoder.decodeSingularInt32Field(value: &_storage._traverse) }() + case 901: try { try decoder.decodeSingularInt32Field(value: &_storage._trim) }() + case 902: try { try decoder.decodeSingularInt32Field(value: &_storage._true) }() + case 903: try { try decoder.decodeSingularInt32Field(value: &_storage._try) }() + case 904: try { try decoder.decodeSingularInt32Field(value: &_storage._type) }() + case 905: try { try decoder.decodeSingularInt32Field(value: &_storage._typealias) }() + case 906: try { try decoder.decodeSingularInt32Field(value: &_storage._typeEnum) }() + case 907: try { try decoder.decodeSingularInt32Field(value: &_storage._typeName) }() + case 908: try { try decoder.decodeSingularInt32Field(value: &_storage._typePrefix) }() + case 909: try { try decoder.decodeSingularInt32Field(value: &_storage._typeStart) }() + case 910: try { try decoder.decodeSingularInt32Field(value: &_storage._typeUnknown) }() + case 911: try { try decoder.decodeSingularInt32Field(value: &_storage._typeURL) }() + case 912: try { try decoder.decodeSingularInt32Field(value: &_storage._uint32) }() + case 913: try { try decoder.decodeSingularInt32Field(value: &_storage._uint64) }() + case 914: try { try decoder.decodeSingularInt32Field(value: &_storage._uint8) }() + case 915: try { try decoder.decodeSingularInt32Field(value: &_storage._unchecked) }() + case 916: try { try decoder.decodeSingularInt32Field(value: &_storage._unicode) }() + case 917: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalarLiteral) }() + case 918: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalarLiteralType) }() + case 919: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalars) }() + case 920: try { try decoder.decodeSingularInt32Field(value: &_storage._unicodeScalarView) }() + case 921: try { try decoder.decodeSingularInt32Field(value: &_storage._uninterpretedOption) }() + case 922: try { try decoder.decodeSingularInt32Field(value: &_storage._union) }() + case 923: try { try decoder.decodeSingularInt32Field(value: &_storage._uniqueStorage) }() + case 924: try { try decoder.decodeSingularInt32Field(value: &_storage._unknown) }() + case 925: try { try decoder.decodeSingularInt32Field(value: &_storage._unknownFields_p) }() + case 926: try { try decoder.decodeSingularInt32Field(value: &_storage._unknownStorage) }() + case 927: try { try decoder.decodeSingularInt32Field(value: &_storage._unpackTo) }() + case 928: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeBufferPointer) }() + case 929: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeMutablePointer) }() + case 930: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeMutableRawBufferPointer) }() + case 931: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeRawBufferPointer) }() + case 932: try { try decoder.decodeSingularInt32Field(value: &_storage._unsafeRawPointer) }() + case 933: try { try decoder.decodeSingularInt32Field(value: &_storage._unverifiedLazy) }() + case 934: try { try decoder.decodeSingularInt32Field(value: &_storage._updatedOptions) }() + case 935: try { try decoder.decodeSingularInt32Field(value: &_storage._uppercasedAssumingAscii) }() + case 936: try { try decoder.decodeSingularInt32Field(value: &_storage._url) }() + case 937: try { try decoder.decodeSingularInt32Field(value: &_storage._useDeterministicOrdering) }() + case 938: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8) }() + case 939: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8Ptr) }() + case 940: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8ToDouble) }() + case 941: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8Validation) }() + case 942: try { try decoder.decodeSingularInt32Field(value: &_storage._utf8View) }() + case 943: try { try decoder.decodeSingularInt32Field(value: &_storage._v) }() + case 944: try { try decoder.decodeSingularInt32Field(value: &_storage._value) }() + case 945: try { try decoder.decodeSingularInt32Field(value: &_storage._valueField) }() + case 946: try { try decoder.decodeSingularInt32Field(value: &_storage._values) }() + case 947: try { try decoder.decodeSingularInt32Field(value: &_storage._valueType) }() + case 948: try { try decoder.decodeSingularInt32Field(value: &_storage._var) }() + case 949: try { try decoder.decodeSingularInt32Field(value: &_storage._verification) }() + case 950: try { try decoder.decodeSingularInt32Field(value: &_storage._verificationState) }() + case 951: try { try decoder.decodeSingularInt32Field(value: &_storage._version) }() + case 952: try { try decoder.decodeSingularInt32Field(value: &_storage._versionString) }() + case 953: try { try decoder.decodeSingularInt32Field(value: &_storage._visibility) }() + case 954: try { try decoder.decodeSingularInt32Field(value: &_storage._visibilityFeature) }() + case 955: try { try decoder.decodeSingularInt32Field(value: &_storage._visitExtensionFields) }() + case 956: try { try decoder.decodeSingularInt32Field(value: &_storage._visitExtensionFieldsAsMessageSet) }() + case 957: try { try decoder.decodeSingularInt32Field(value: &_storage._visitMapField) }() + case 958: try { try decoder.decodeSingularInt32Field(value: &_storage._visitor) }() + case 959: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPacked) }() + case 960: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedBoolField) }() + case 961: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedDoubleField) }() + case 962: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedEnumField) }() + case 963: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedFixed32Field) }() + case 964: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedFixed64Field) }() + case 965: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedFloatField) }() + case 966: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedInt32Field) }() + case 967: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedInt64Field) }() + case 968: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSfixed32Field) }() + case 969: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSfixed64Field) }() + case 970: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSint32Field) }() + case 971: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedSint64Field) }() + case 972: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedUint32Field) }() + case 973: try { try decoder.decodeSingularInt32Field(value: &_storage._visitPackedUint64Field) }() + case 974: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeated) }() + case 975: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedBoolField) }() + case 976: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedBytesField) }() + case 977: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedDoubleField) }() + case 978: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedEnumField) }() + case 979: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedFixed32Field) }() + case 980: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedFixed64Field) }() + case 981: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedFloatField) }() + case 982: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedGroupField) }() + case 983: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedInt32Field) }() + case 984: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedInt64Field) }() + case 985: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedMessageField) }() + case 986: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSfixed32Field) }() + case 987: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSfixed64Field) }() + case 988: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSint32Field) }() + case 989: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedSint64Field) }() + case 990: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedStringField) }() + case 991: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedUint32Field) }() + case 992: try { try decoder.decodeSingularInt32Field(value: &_storage._visitRepeatedUint64Field) }() + case 993: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingular) }() + case 994: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularBoolField) }() + case 995: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularBytesField) }() + case 996: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularDoubleField) }() + case 997: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularEnumField) }() + case 998: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularFixed32Field) }() + case 999: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularFixed64Field) }() + case 1000: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularFloatField) }() + case 1001: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularGroupField) }() + case 1002: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularInt32Field) }() + case 1003: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularInt64Field) }() + case 1004: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularMessageField) }() + case 1005: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSfixed32Field) }() + case 1006: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSfixed64Field) }() + case 1007: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSint32Field) }() + case 1008: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularSint64Field) }() + case 1009: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularStringField) }() + case 1010: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularUint32Field) }() + case 1011: try { try decoder.decodeSingularInt32Field(value: &_storage._visitSingularUint64Field) }() + case 1012: try { try decoder.decodeSingularInt32Field(value: &_storage._visitUnknown) }() + case 1013: try { try decoder.decodeSingularInt32Field(value: &_storage._void) }() + case 1014: try { try decoder.decodeSingularInt32Field(value: &_storage._wasDecoded) }() + case 1015: try { try decoder.decodeSingularInt32Field(value: &_storage._weak) }() + case 1016: try { try decoder.decodeSingularInt32Field(value: &_storage._weakDependency) }() + case 1017: try { try decoder.decodeSingularInt32Field(value: &_storage._where) }() + case 1018: try { try decoder.decodeSingularInt32Field(value: &_storage._wireFormat) }() + case 1019: try { try decoder.decodeSingularInt32Field(value: &_storage._with) }() + case 1020: try { try decoder.decodeSingularInt32Field(value: &_storage._withUnsafeBytes) }() + case 1021: try { try decoder.decodeSingularInt32Field(value: &_storage._withUnsafeMutableBytes) }() + case 1022: try { try decoder.decodeSingularInt32Field(value: &_storage._work) }() + case 1023: try { try decoder.decodeSingularInt32Field(value: &_storage._wrapped) }() + case 1024: try { try decoder.decodeSingularInt32Field(value: &_storage._wrappedType) }() + case 1025: try { try decoder.decodeSingularInt32Field(value: &_storage._wrappedValue) }() + case 1026: try { try decoder.decodeSingularInt32Field(value: &_storage._written) }() + case 1027: try { try decoder.decodeSingularInt32Field(value: &_storage._yday) }() default: break } } @@ -7903,2634 +8297,3110 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. func traverse(visitor: inout V) throws { try withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._addPath != 0 { + try visitor.visitSingularInt32Field(value: _storage._addPath, fieldNumber: 1) + } if _storage._adjusted != 0 { - try visitor.visitSingularInt32Field(value: _storage._adjusted, fieldNumber: 1) + try visitor.visitSingularInt32Field(value: _storage._adjusted, fieldNumber: 2) } if _storage._aggregateValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._aggregateValue, fieldNumber: 2) + try visitor.visitSingularInt32Field(value: _storage._aggregateValue, fieldNumber: 3) } if _storage._allCases != 0 { - try visitor.visitSingularInt32Field(value: _storage._allCases, fieldNumber: 3) + try visitor.visitSingularInt32Field(value: _storage._allCases, fieldNumber: 4) } if _storage._allowAlias != 0 { - try visitor.visitSingularInt32Field(value: _storage._allowAlias, fieldNumber: 4) + try visitor.visitSingularInt32Field(value: _storage._allowAlias, fieldNumber: 5) } if _storage._alwaysPrintEnumsAsInts != 0 { - try visitor.visitSingularInt32Field(value: _storage._alwaysPrintEnumsAsInts, fieldNumber: 5) + try visitor.visitSingularInt32Field(value: _storage._alwaysPrintEnumsAsInts, fieldNumber: 6) + } + if _storage._alwaysPrintInt64SAsNumbers != 0 { + try visitor.visitSingularInt32Field(value: _storage._alwaysPrintInt64SAsNumbers, fieldNumber: 7) } if _storage._annotation != 0 { - try visitor.visitSingularInt32Field(value: _storage._annotation, fieldNumber: 6) + try visitor.visitSingularInt32Field(value: _storage._annotation, fieldNumber: 8) } if _storage._any != 0 { - try visitor.visitSingularInt32Field(value: _storage._any, fieldNumber: 7) + try visitor.visitSingularInt32Field(value: _storage._any, fieldNumber: 9) } if _storage._anyExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._anyExtensionField, fieldNumber: 8) + try visitor.visitSingularInt32Field(value: _storage._anyExtensionField, fieldNumber: 10) } if _storage._anyMessageExtension != 0 { - try visitor.visitSingularInt32Field(value: _storage._anyMessageExtension, fieldNumber: 9) + try visitor.visitSingularInt32Field(value: _storage._anyMessageExtension, fieldNumber: 11) } if _storage._anyMessageStorage != 0 { - try visitor.visitSingularInt32Field(value: _storage._anyMessageStorage, fieldNumber: 10) + try visitor.visitSingularInt32Field(value: _storage._anyMessageStorage, fieldNumber: 12) } if _storage._anyUnpackError != 0 { - try visitor.visitSingularInt32Field(value: _storage._anyUnpackError, fieldNumber: 11) + try visitor.visitSingularInt32Field(value: _storage._anyUnpackError, fieldNumber: 13) } - if _storage._api != 0 { - try visitor.visitSingularInt32Field(value: _storage._api, fieldNumber: 12) + if _storage._append != 0 { + try visitor.visitSingularInt32Field(value: _storage._append, fieldNumber: 14) } if _storage._appended != 0 { - try visitor.visitSingularInt32Field(value: _storage._appended, fieldNumber: 13) + try visitor.visitSingularInt32Field(value: _storage._appended, fieldNumber: 15) } if _storage._appendUintHex != 0 { - try visitor.visitSingularInt32Field(value: _storage._appendUintHex, fieldNumber: 14) + try visitor.visitSingularInt32Field(value: _storage._appendUintHex, fieldNumber: 16) } if _storage._appendUnknown != 0 { - try visitor.visitSingularInt32Field(value: _storage._appendUnknown, fieldNumber: 15) + try visitor.visitSingularInt32Field(value: _storage._appendUnknown, fieldNumber: 17) } if _storage._areAllInitialized != 0 { - try visitor.visitSingularInt32Field(value: _storage._areAllInitialized, fieldNumber: 16) + try visitor.visitSingularInt32Field(value: _storage._areAllInitialized, fieldNumber: 18) } if _storage._array != 0 { - try visitor.visitSingularInt32Field(value: _storage._array, fieldNumber: 17) + try visitor.visitSingularInt32Field(value: _storage._array, fieldNumber: 19) } if _storage._arrayDepth != 0 { - try visitor.visitSingularInt32Field(value: _storage._arrayDepth, fieldNumber: 18) + try visitor.visitSingularInt32Field(value: _storage._arrayDepth, fieldNumber: 20) } if _storage._arrayLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._arrayLiteral, fieldNumber: 19) + try visitor.visitSingularInt32Field(value: _storage._arrayLiteral, fieldNumber: 21) } if _storage._arraySeparator != 0 { - try visitor.visitSingularInt32Field(value: _storage._arraySeparator, fieldNumber: 20) + try visitor.visitSingularInt32Field(value: _storage._arraySeparator, fieldNumber: 22) } if _storage._as != 0 { - try visitor.visitSingularInt32Field(value: _storage._as, fieldNumber: 21) + try visitor.visitSingularInt32Field(value: _storage._as, fieldNumber: 23) } if _storage._asciiOpenCurlyBracket != 0 { - try visitor.visitSingularInt32Field(value: _storage._asciiOpenCurlyBracket, fieldNumber: 22) + try visitor.visitSingularInt32Field(value: _storage._asciiOpenCurlyBracket, fieldNumber: 24) } if _storage._asciiZero != 0 { - try visitor.visitSingularInt32Field(value: _storage._asciiZero, fieldNumber: 23) + try visitor.visitSingularInt32Field(value: _storage._asciiZero, fieldNumber: 25) + } + if _storage._async != 0 { + try visitor.visitSingularInt32Field(value: _storage._async, fieldNumber: 26) + } + if _storage._asyncIterator != 0 { + try visitor.visitSingularInt32Field(value: _storage._asyncIterator, fieldNumber: 27) + } + if _storage._asyncIteratorProtocol != 0 { + try visitor.visitSingularInt32Field(value: _storage._asyncIteratorProtocol, fieldNumber: 28) + } + if _storage._asyncMessageSequence != 0 { + try visitor.visitSingularInt32Field(value: _storage._asyncMessageSequence, fieldNumber: 29) } if _storage._available != 0 { - try visitor.visitSingularInt32Field(value: _storage._available, fieldNumber: 24) + try visitor.visitSingularInt32Field(value: _storage._available, fieldNumber: 30) } if _storage._b != 0 { - try visitor.visitSingularInt32Field(value: _storage._b, fieldNumber: 25) + try visitor.visitSingularInt32Field(value: _storage._b, fieldNumber: 31) + } + if _storage._base != 0 { + try visitor.visitSingularInt32Field(value: _storage._base, fieldNumber: 32) } if _storage._base64Values != 0 { - try visitor.visitSingularInt32Field(value: _storage._base64Values, fieldNumber: 26) + try visitor.visitSingularInt32Field(value: _storage._base64Values, fieldNumber: 33) } if _storage._baseAddress != 0 { - try visitor.visitSingularInt32Field(value: _storage._baseAddress, fieldNumber: 27) + try visitor.visitSingularInt32Field(value: _storage._baseAddress, fieldNumber: 34) } if _storage._baseType != 0 { - try visitor.visitSingularInt32Field(value: _storage._baseType, fieldNumber: 28) + try visitor.visitSingularInt32Field(value: _storage._baseType, fieldNumber: 35) } if _storage._begin != 0 { - try visitor.visitSingularInt32Field(value: _storage._begin, fieldNumber: 29) + try visitor.visitSingularInt32Field(value: _storage._begin, fieldNumber: 36) } if _storage._binary != 0 { - try visitor.visitSingularInt32Field(value: _storage._binary, fieldNumber: 30) + try visitor.visitSingularInt32Field(value: _storage._binary, fieldNumber: 37) } if _storage._binaryDecoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryDecoder, fieldNumber: 31) + try visitor.visitSingularInt32Field(value: _storage._binaryDecoder, fieldNumber: 38) + } + if _storage._binaryDecoding != 0 { + try visitor.visitSingularInt32Field(value: _storage._binaryDecoding, fieldNumber: 39) } if _storage._binaryDecodingError != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryDecodingError, fieldNumber: 32) + try visitor.visitSingularInt32Field(value: _storage._binaryDecodingError, fieldNumber: 40) } if _storage._binaryDecodingOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryDecodingOptions, fieldNumber: 33) + try visitor.visitSingularInt32Field(value: _storage._binaryDecodingOptions, fieldNumber: 41) } if _storage._binaryDelimited != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryDelimited, fieldNumber: 34) + try visitor.visitSingularInt32Field(value: _storage._binaryDelimited, fieldNumber: 42) } if _storage._binaryEncoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryEncoder, fieldNumber: 35) + try visitor.visitSingularInt32Field(value: _storage._binaryEncoder, fieldNumber: 43) } if _storage._binaryEncodingError != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryEncodingError, fieldNumber: 36) + try visitor.visitSingularInt32Field(value: _storage._binaryEncodingError, fieldNumber: 44) } if _storage._binaryEncodingMessageSetSizeVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryEncodingMessageSetSizeVisitor, fieldNumber: 37) + try visitor.visitSingularInt32Field(value: _storage._binaryEncodingMessageSetSizeVisitor, fieldNumber: 45) } if _storage._binaryEncodingMessageSetVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryEncodingMessageSetVisitor, fieldNumber: 38) + try visitor.visitSingularInt32Field(value: _storage._binaryEncodingMessageSetVisitor, fieldNumber: 46) + } + if _storage._binaryEncodingOptions != 0 { + try visitor.visitSingularInt32Field(value: _storage._binaryEncodingOptions, fieldNumber: 47) } if _storage._binaryEncodingSizeVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryEncodingSizeVisitor, fieldNumber: 39) + try visitor.visitSingularInt32Field(value: _storage._binaryEncodingSizeVisitor, fieldNumber: 48) } if _storage._binaryEncodingVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryEncodingVisitor, fieldNumber: 40) + try visitor.visitSingularInt32Field(value: _storage._binaryEncodingVisitor, fieldNumber: 49) } if _storage._binaryOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._binaryOptions, fieldNumber: 41) + try visitor.visitSingularInt32Field(value: _storage._binaryOptions, fieldNumber: 50) + } + if _storage._binaryProtobufDelimitedMessages != 0 { + try visitor.visitSingularInt32Field(value: _storage._binaryProtobufDelimitedMessages, fieldNumber: 51) + } + if _storage._binaryStreamDecoding != 0 { + try visitor.visitSingularInt32Field(value: _storage._binaryStreamDecoding, fieldNumber: 52) + } + if _storage._binaryStreamDecodingError != 0 { + try visitor.visitSingularInt32Field(value: _storage._binaryStreamDecodingError, fieldNumber: 53) + } + if _storage._bitPattern != 0 { + try visitor.visitSingularInt32Field(value: _storage._bitPattern, fieldNumber: 54) } if _storage._body != 0 { - try visitor.visitSingularInt32Field(value: _storage._body, fieldNumber: 42) + try visitor.visitSingularInt32Field(value: _storage._body, fieldNumber: 55) } if _storage._bool != 0 { - try visitor.visitSingularInt32Field(value: _storage._bool, fieldNumber: 43) + try visitor.visitSingularInt32Field(value: _storage._bool, fieldNumber: 56) } if _storage._booleanLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._booleanLiteral, fieldNumber: 44) + try visitor.visitSingularInt32Field(value: _storage._booleanLiteral, fieldNumber: 57) } if _storage._booleanLiteralType != 0 { - try visitor.visitSingularInt32Field(value: _storage._booleanLiteralType, fieldNumber: 45) + try visitor.visitSingularInt32Field(value: _storage._booleanLiteralType, fieldNumber: 58) } if _storage._boolValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._boolValue, fieldNumber: 46) + try visitor.visitSingularInt32Field(value: _storage._boolValue, fieldNumber: 59) + } + if _storage._buffer != 0 { + try visitor.visitSingularInt32Field(value: _storage._buffer, fieldNumber: 60) + } + if _storage._byte != 0 { + try visitor.visitSingularInt32Field(value: _storage._byte, fieldNumber: 61) + } + if _storage._bytecode != 0 { + try visitor.visitSingularInt32Field(value: _storage._bytecode, fieldNumber: 62) + } + if _storage._bytecodeReader != 0 { + try visitor.visitSingularInt32Field(value: _storage._bytecodeReader, fieldNumber: 63) } if _storage._bytes != 0 { - try visitor.visitSingularInt32Field(value: _storage._bytes, fieldNumber: 47) + try visitor.visitSingularInt32Field(value: _storage._bytes, fieldNumber: 64) } if _storage._bytesInGroup != 0 { - try visitor.visitSingularInt32Field(value: _storage._bytesInGroup, fieldNumber: 48) + try visitor.visitSingularInt32Field(value: _storage._bytesInGroup, fieldNumber: 65) } - if _storage._bytesRead != 0 { - try visitor.visitSingularInt32Field(value: _storage._bytesRead, fieldNumber: 49) + if _storage._bytesNeeded != 0 { + try visitor.visitSingularInt32Field(value: _storage._bytesNeeded, fieldNumber: 66) } - if _storage._bytesValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._bytesValue, fieldNumber: 50) + if _storage._bytesRead != 0 { + try visitor.visitSingularInt32Field(value: _storage._bytesRead, fieldNumber: 67) } if _storage._c != 0 { - try visitor.visitSingularInt32Field(value: _storage._c, fieldNumber: 51) + try visitor.visitSingularInt32Field(value: _storage._c, fieldNumber: 68) + } + if _storage._canonical != 0 { + try visitor.visitSingularInt32Field(value: _storage._canonical, fieldNumber: 69) } if _storage._capitalizeNext != 0 { - try visitor.visitSingularInt32Field(value: _storage._capitalizeNext, fieldNumber: 52) + try visitor.visitSingularInt32Field(value: _storage._capitalizeNext, fieldNumber: 70) } if _storage._cardinality != 0 { - try visitor.visitSingularInt32Field(value: _storage._cardinality, fieldNumber: 53) + try visitor.visitSingularInt32Field(value: _storage._cardinality, fieldNumber: 71) + } + if _storage._caseIterable != 0 { + try visitor.visitSingularInt32Field(value: _storage._caseIterable, fieldNumber: 72) + } + if _storage._castedValue != 0 { + try visitor.visitSingularInt32Field(value: _storage._castedValue, fieldNumber: 73) } if _storage._ccEnableArenas != 0 { - try visitor.visitSingularInt32Field(value: _storage._ccEnableArenas, fieldNumber: 54) + try visitor.visitSingularInt32Field(value: _storage._ccEnableArenas, fieldNumber: 74) } if _storage._ccGenericServices != 0 { - try visitor.visitSingularInt32Field(value: _storage._ccGenericServices, fieldNumber: 55) + try visitor.visitSingularInt32Field(value: _storage._ccGenericServices, fieldNumber: 75) } if _storage._character != 0 { - try visitor.visitSingularInt32Field(value: _storage._character, fieldNumber: 56) + try visitor.visitSingularInt32Field(value: _storage._character, fieldNumber: 76) } if _storage._chars != 0 { - try visitor.visitSingularInt32Field(value: _storage._chars, fieldNumber: 57) + try visitor.visitSingularInt32Field(value: _storage._chars, fieldNumber: 77) + } + if _storage._checkProgramFormat != 0 { + try visitor.visitSingularInt32Field(value: _storage._checkProgramFormat, fieldNumber: 78) + } + if _storage._chunk != 0 { + try visitor.visitSingularInt32Field(value: _storage._chunk, fieldNumber: 79) } if _storage._class != 0 { - try visitor.visitSingularInt32Field(value: _storage._class, fieldNumber: 58) + try visitor.visitSingularInt32Field(value: _storage._class, fieldNumber: 80) } if _storage._clearAggregateValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearAggregateValue_p, fieldNumber: 59) + try visitor.visitSingularInt32Field(value: _storage._clearAggregateValue_p, fieldNumber: 81) } if _storage._clearAllowAlias_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearAllowAlias_p, fieldNumber: 60) + try visitor.visitSingularInt32Field(value: _storage._clearAllowAlias_p, fieldNumber: 82) } if _storage._clearBegin_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearBegin_p, fieldNumber: 61) + try visitor.visitSingularInt32Field(value: _storage._clearBegin_p, fieldNumber: 83) } if _storage._clearCcEnableArenas_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearCcEnableArenas_p, fieldNumber: 62) + try visitor.visitSingularInt32Field(value: _storage._clearCcEnableArenas_p, fieldNumber: 84) } if _storage._clearCcGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearCcGenericServices_p, fieldNumber: 63) + try visitor.visitSingularInt32Field(value: _storage._clearCcGenericServices_p, fieldNumber: 85) } if _storage._clearClientStreaming_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearClientStreaming_p, fieldNumber: 64) + try visitor.visitSingularInt32Field(value: _storage._clearClientStreaming_p, fieldNumber: 86) } if _storage._clearCsharpNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearCsharpNamespace_p, fieldNumber: 65) + try visitor.visitSingularInt32Field(value: _storage._clearCsharpNamespace_p, fieldNumber: 87) } if _storage._clearCtype_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearCtype_p, fieldNumber: 66) + try visitor.visitSingularInt32Field(value: _storage._clearCtype_p, fieldNumber: 88) + } + if _storage._clearDebugRedact_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearDebugRedact_p, fieldNumber: 89) + } + if _storage._clearDefaultSymbolVisibility_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearDefaultSymbolVisibility_p, fieldNumber: 90) } if _storage._clearDefaultValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearDefaultValue_p, fieldNumber: 67) + try visitor.visitSingularInt32Field(value: _storage._clearDefaultValue_p, fieldNumber: 91) } if _storage._clearDeprecated_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearDeprecated_p, fieldNumber: 68) + try visitor.visitSingularInt32Field(value: _storage._clearDeprecated_p, fieldNumber: 92) + } + if _storage._clearDeprecatedLegacyJsonFieldConflicts_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearDeprecatedLegacyJsonFieldConflicts_p, fieldNumber: 93) + } + if _storage._clearDeprecationWarning_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearDeprecationWarning_p, fieldNumber: 94) } if _storage._clearDoubleValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearDoubleValue_p, fieldNumber: 69) + try visitor.visitSingularInt32Field(value: _storage._clearDoubleValue_p, fieldNumber: 95) + } + if _storage._clearEdition_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearEdition_p, fieldNumber: 96) + } + if _storage._clearEditionDeprecated_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearEditionDeprecated_p, fieldNumber: 97) + } + if _storage._clearEditionIntroduced_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearEditionIntroduced_p, fieldNumber: 98) + } + if _storage._clearEditionRemoved_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearEditionRemoved_p, fieldNumber: 99) + } + if _storage._clearEnd_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearEnd_p, fieldNumber: 100) + } + if _storage._clearEnforceNamingStyle_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearEnforceNamingStyle_p, fieldNumber: 101) + } + if _storage._clearEnumType_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearEnumType_p, fieldNumber: 102) + } + if _storage._clearExtendee_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearExtendee_p, fieldNumber: 103) + } + if _storage._clearExtensionValue_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearExtensionValue_p, fieldNumber: 104) + } + if _storage._clearFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearFeatures_p, fieldNumber: 105) + } + if _storage._clearFeatureSupport_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearFeatureSupport_p, fieldNumber: 106) } - if _storage._clearEnd_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearEnd_p, fieldNumber: 70) + if _storage._clearFieldPresence_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearFieldPresence_p, fieldNumber: 107) } - if _storage._clearExtendee_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearExtendee_p, fieldNumber: 71) + if _storage._clearFixedFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearFixedFeatures_p, fieldNumber: 108) } - if _storage._clearExtensionValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearExtensionValue_p, fieldNumber: 72) + if _storage._clearFullName_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearFullName_p, fieldNumber: 109) } if _storage._clearGoPackage_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearGoPackage_p, fieldNumber: 73) + try visitor.visitSingularInt32Field(value: _storage._clearGoPackage_p, fieldNumber: 110) } if _storage._clearIdempotencyLevel_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearIdempotencyLevel_p, fieldNumber: 74) + try visitor.visitSingularInt32Field(value: _storage._clearIdempotencyLevel_p, fieldNumber: 111) } if _storage._clearIdentifierValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearIdentifierValue_p, fieldNumber: 75) + try visitor.visitSingularInt32Field(value: _storage._clearIdentifierValue_p, fieldNumber: 112) } if _storage._clearInputType_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearInputType_p, fieldNumber: 76) + try visitor.visitSingularInt32Field(value: _storage._clearInputType_p, fieldNumber: 113) } if _storage._clearIsExtension_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearIsExtension_p, fieldNumber: 77) + try visitor.visitSingularInt32Field(value: _storage._clearIsExtension_p, fieldNumber: 114) } if _storage._clearJavaGenerateEqualsAndHash_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearJavaGenerateEqualsAndHash_p, fieldNumber: 78) + try visitor.visitSingularInt32Field(value: _storage._clearJavaGenerateEqualsAndHash_p, fieldNumber: 115) } if _storage._clearJavaGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearJavaGenericServices_p, fieldNumber: 79) + try visitor.visitSingularInt32Field(value: _storage._clearJavaGenericServices_p, fieldNumber: 116) } if _storage._clearJavaMultipleFiles_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearJavaMultipleFiles_p, fieldNumber: 80) + try visitor.visitSingularInt32Field(value: _storage._clearJavaMultipleFiles_p, fieldNumber: 117) } if _storage._clearJavaOuterClassname_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearJavaOuterClassname_p, fieldNumber: 81) + try visitor.visitSingularInt32Field(value: _storage._clearJavaOuterClassname_p, fieldNumber: 118) } if _storage._clearJavaPackage_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearJavaPackage_p, fieldNumber: 82) + try visitor.visitSingularInt32Field(value: _storage._clearJavaPackage_p, fieldNumber: 119) } if _storage._clearJavaStringCheckUtf8_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearJavaStringCheckUtf8_p, fieldNumber: 83) + try visitor.visitSingularInt32Field(value: _storage._clearJavaStringCheckUtf8_p, fieldNumber: 120) + } + if _storage._clearJsonFormat_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearJsonFormat_p, fieldNumber: 121) } if _storage._clearJsonName_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearJsonName_p, fieldNumber: 84) + try visitor.visitSingularInt32Field(value: _storage._clearJsonName_p, fieldNumber: 122) } if _storage._clearJstype_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearJstype_p, fieldNumber: 85) + try visitor.visitSingularInt32Field(value: _storage._clearJstype_p, fieldNumber: 123) } if _storage._clearLabel_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearLabel_p, fieldNumber: 86) + try visitor.visitSingularInt32Field(value: _storage._clearLabel_p, fieldNumber: 124) } if _storage._clearLazy_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearLazy_p, fieldNumber: 87) + try visitor.visitSingularInt32Field(value: _storage._clearLazy_p, fieldNumber: 125) } if _storage._clearLeadingComments_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearLeadingComments_p, fieldNumber: 88) + try visitor.visitSingularInt32Field(value: _storage._clearLeadingComments_p, fieldNumber: 126) } if _storage._clearMapEntry_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearMapEntry_p, fieldNumber: 89) + try visitor.visitSingularInt32Field(value: _storage._clearMapEntry_p, fieldNumber: 127) + } + if _storage._clearMaximumEdition_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearMaximumEdition_p, fieldNumber: 128) + } + if _storage._clearMessageEncoding_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearMessageEncoding_p, fieldNumber: 129) } if _storage._clearMessageSetWireFormat_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearMessageSetWireFormat_p, fieldNumber: 90) + try visitor.visitSingularInt32Field(value: _storage._clearMessageSetWireFormat_p, fieldNumber: 130) + } + if _storage._clearMinimumEdition_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearMinimumEdition_p, fieldNumber: 131) } if _storage._clearName_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearName_p, fieldNumber: 91) + try visitor.visitSingularInt32Field(value: _storage._clearName_p, fieldNumber: 132) } if _storage._clearNamePart_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearNamePart_p, fieldNumber: 92) + try visitor.visitSingularInt32Field(value: _storage._clearNamePart_p, fieldNumber: 133) } if _storage._clearNegativeIntValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearNegativeIntValue_p, fieldNumber: 93) + try visitor.visitSingularInt32Field(value: _storage._clearNegativeIntValue_p, fieldNumber: 134) } if _storage._clearNoStandardDescriptorAccessor_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearNoStandardDescriptorAccessor_p, fieldNumber: 94) + try visitor.visitSingularInt32Field(value: _storage._clearNoStandardDescriptorAccessor_p, fieldNumber: 135) } if _storage._clearNumber_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearNumber_p, fieldNumber: 95) + try visitor.visitSingularInt32Field(value: _storage._clearNumber_p, fieldNumber: 136) } if _storage._clearObjcClassPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearObjcClassPrefix_p, fieldNumber: 96) + try visitor.visitSingularInt32Field(value: _storage._clearObjcClassPrefix_p, fieldNumber: 137) } if _storage._clearOneofIndex_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearOneofIndex_p, fieldNumber: 97) + try visitor.visitSingularInt32Field(value: _storage._clearOneofIndex_p, fieldNumber: 138) } if _storage._clearOptimizeFor_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearOptimizeFor_p, fieldNumber: 98) + try visitor.visitSingularInt32Field(value: _storage._clearOptimizeFor_p, fieldNumber: 139) } if _storage._clearOptions_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearOptions_p, fieldNumber: 99) + try visitor.visitSingularInt32Field(value: _storage._clearOptions_p, fieldNumber: 140) } if _storage._clearOutputType_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearOutputType_p, fieldNumber: 100) + try visitor.visitSingularInt32Field(value: _storage._clearOutputType_p, fieldNumber: 141) + } + if _storage._clearOverridableFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearOverridableFeatures_p, fieldNumber: 142) } if _storage._clearPackage_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearPackage_p, fieldNumber: 101) + try visitor.visitSingularInt32Field(value: _storage._clearPackage_p, fieldNumber: 143) } if _storage._clearPacked_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearPacked_p, fieldNumber: 102) + try visitor.visitSingularInt32Field(value: _storage._clearPacked_p, fieldNumber: 144) } if _storage._clearPhpClassPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearPhpClassPrefix_p, fieldNumber: 103) - } - if _storage._clearPhpGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearPhpGenericServices_p, fieldNumber: 104) + try visitor.visitSingularInt32Field(value: _storage._clearPhpClassPrefix_p, fieldNumber: 145) } if _storage._clearPhpMetadataNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearPhpMetadataNamespace_p, fieldNumber: 105) + try visitor.visitSingularInt32Field(value: _storage._clearPhpMetadataNamespace_p, fieldNumber: 146) } if _storage._clearPhpNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearPhpNamespace_p, fieldNumber: 106) + try visitor.visitSingularInt32Field(value: _storage._clearPhpNamespace_p, fieldNumber: 147) } if _storage._clearPositiveIntValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearPositiveIntValue_p, fieldNumber: 107) + try visitor.visitSingularInt32Field(value: _storage._clearPositiveIntValue_p, fieldNumber: 148) } if _storage._clearProto3Optional_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearProto3Optional_p, fieldNumber: 108) + try visitor.visitSingularInt32Field(value: _storage._clearProto3Optional_p, fieldNumber: 149) } if _storage._clearPyGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearPyGenericServices_p, fieldNumber: 109) + try visitor.visitSingularInt32Field(value: _storage._clearPyGenericServices_p, fieldNumber: 150) + } + if _storage._clearRemovalError_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearRemovalError_p, fieldNumber: 151) + } + if _storage._clearRepeated_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearRepeated_p, fieldNumber: 152) + } + if _storage._clearRepeatedFieldEncoding_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearRepeatedFieldEncoding_p, fieldNumber: 153) + } + if _storage._clearReserved_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearReserved_p, fieldNumber: 154) + } + if _storage._clearRetention_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearRetention_p, fieldNumber: 155) } if _storage._clearRubyPackage_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearRubyPackage_p, fieldNumber: 110) + try visitor.visitSingularInt32Field(value: _storage._clearRubyPackage_p, fieldNumber: 156) + } + if _storage._clearSemantic_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearSemantic_p, fieldNumber: 157) } if _storage._clearServerStreaming_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearServerStreaming_p, fieldNumber: 111) + try visitor.visitSingularInt32Field(value: _storage._clearServerStreaming_p, fieldNumber: 158) } if _storage._clearSourceCodeInfo_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearSourceCodeInfo_p, fieldNumber: 112) + try visitor.visitSingularInt32Field(value: _storage._clearSourceCodeInfo_p, fieldNumber: 159) } if _storage._clearSourceContext_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearSourceContext_p, fieldNumber: 113) + try visitor.visitSingularInt32Field(value: _storage._clearSourceContext_p, fieldNumber: 160) } if _storage._clearSourceFile_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearSourceFile_p, fieldNumber: 114) + try visitor.visitSingularInt32Field(value: _storage._clearSourceFile_p, fieldNumber: 161) } if _storage._clearStart_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearStart_p, fieldNumber: 115) + try visitor.visitSingularInt32Field(value: _storage._clearStart_p, fieldNumber: 162) } if _storage._clearStringValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearStringValue_p, fieldNumber: 116) + try visitor.visitSingularInt32Field(value: _storage._clearStringValue_p, fieldNumber: 163) } if _storage._clearSwiftPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearSwiftPrefix_p, fieldNumber: 117) + try visitor.visitSingularInt32Field(value: _storage._clearSwiftPrefix_p, fieldNumber: 164) } if _storage._clearSyntax_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearSyntax_p, fieldNumber: 118) + try visitor.visitSingularInt32Field(value: _storage._clearSyntax_p, fieldNumber: 165) } if _storage._clearTrailingComments_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearTrailingComments_p, fieldNumber: 119) + try visitor.visitSingularInt32Field(value: _storage._clearTrailingComments_p, fieldNumber: 166) } if _storage._clearType_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearType_p, fieldNumber: 120) + try visitor.visitSingularInt32Field(value: _storage._clearType_p, fieldNumber: 167) } if _storage._clearTypeName_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearTypeName_p, fieldNumber: 121) + try visitor.visitSingularInt32Field(value: _storage._clearTypeName_p, fieldNumber: 168) + } + if _storage._clearUnverifiedLazy_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearUnverifiedLazy_p, fieldNumber: 169) + } + if _storage._clearUtf8Validation_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearUtf8Validation_p, fieldNumber: 170) } if _storage._clearValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearValue_p, fieldNumber: 122) + try visitor.visitSingularInt32Field(value: _storage._clearValue_p, fieldNumber: 171) + } + if _storage._clearVerification_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearVerification_p, fieldNumber: 172) + } + if _storage._clearVisibility_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._clearVisibility_p, fieldNumber: 173) } if _storage._clearWeak_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._clearWeak_p, fieldNumber: 123) + try visitor.visitSingularInt32Field(value: _storage._clearWeak_p, fieldNumber: 174) } if _storage._clientStreaming != 0 { - try visitor.visitSingularInt32Field(value: _storage._clientStreaming, fieldNumber: 124) + try visitor.visitSingularInt32Field(value: _storage._clientStreaming, fieldNumber: 175) + } + if _storage._code != 0 { + try visitor.visitSingularInt32Field(value: _storage._code, fieldNumber: 176) } if _storage._codePoint != 0 { - try visitor.visitSingularInt32Field(value: _storage._codePoint, fieldNumber: 125) + try visitor.visitSingularInt32Field(value: _storage._codePoint, fieldNumber: 177) } if _storage._codeUnits != 0 { - try visitor.visitSingularInt32Field(value: _storage._codeUnits, fieldNumber: 126) + try visitor.visitSingularInt32Field(value: _storage._codeUnits, fieldNumber: 178) } if _storage._collection != 0 { - try visitor.visitSingularInt32Field(value: _storage._collection, fieldNumber: 127) - } - if _storage._com != 0 { - try visitor.visitSingularInt32Field(value: _storage._com, fieldNumber: 128) + try visitor.visitSingularInt32Field(value: _storage._collection, fieldNumber: 179) } if _storage._comma != 0 { - try visitor.visitSingularInt32Field(value: _storage._comma, fieldNumber: 129) + try visitor.visitSingularInt32Field(value: _storage._comma, fieldNumber: 180) + } + if _storage._consumedBytes != 0 { + try visitor.visitSingularInt32Field(value: _storage._consumedBytes, fieldNumber: 181) + } + if _storage._contains != 0 { + try visitor.visitSingularInt32Field(value: _storage._contains, fieldNumber: 182) } if _storage._contentsOf != 0 { - try visitor.visitSingularInt32Field(value: _storage._contentsOf, fieldNumber: 130) + try visitor.visitSingularInt32Field(value: _storage._contentsOf, fieldNumber: 183) } if _storage._contiguousBytes != 0 { - try visitor.visitSingularInt32Field(value: _storage._contiguousBytes, fieldNumber: 131) + try visitor.visitSingularInt32Field(value: _storage._contiguousBytes, fieldNumber: 184) + } + if _storage._copy != 0 { + try visitor.visitSingularInt32Field(value: _storage._copy, fieldNumber: 185) } if _storage._count != 0 { - try visitor.visitSingularInt32Field(value: _storage._count, fieldNumber: 132) + try visitor.visitSingularInt32Field(value: _storage._count, fieldNumber: 186) } if _storage._countVarintsInBuffer != 0 { - try visitor.visitSingularInt32Field(value: _storage._countVarintsInBuffer, fieldNumber: 133) + try visitor.visitSingularInt32Field(value: _storage._countVarintsInBuffer, fieldNumber: 187) } if _storage._csharpNamespace != 0 { - try visitor.visitSingularInt32Field(value: _storage._csharpNamespace, fieldNumber: 134) + try visitor.visitSingularInt32Field(value: _storage._csharpNamespace, fieldNumber: 188) } if _storage._ctype != 0 { - try visitor.visitSingularInt32Field(value: _storage._ctype, fieldNumber: 135) + try visitor.visitSingularInt32Field(value: _storage._ctype, fieldNumber: 189) } if _storage._customCodable != 0 { - try visitor.visitSingularInt32Field(value: _storage._customCodable, fieldNumber: 136) + try visitor.visitSingularInt32Field(value: _storage._customCodable, fieldNumber: 190) } if _storage._customDebugStringConvertible != 0 { - try visitor.visitSingularInt32Field(value: _storage._customDebugStringConvertible, fieldNumber: 137) + try visitor.visitSingularInt32Field(value: _storage._customDebugStringConvertible, fieldNumber: 191) + } + if _storage._customStringConvertible != 0 { + try visitor.visitSingularInt32Field(value: _storage._customStringConvertible, fieldNumber: 192) } if _storage._d != 0 { - try visitor.visitSingularInt32Field(value: _storage._d, fieldNumber: 138) + try visitor.visitSingularInt32Field(value: _storage._d, fieldNumber: 193) } if _storage._data != 0 { - try visitor.visitSingularInt32Field(value: _storage._data, fieldNumber: 139) + try visitor.visitSingularInt32Field(value: _storage._data, fieldNumber: 194) } if _storage._dataResult != 0 { - try visitor.visitSingularInt32Field(value: _storage._dataResult, fieldNumber: 140) + try visitor.visitSingularInt32Field(value: _storage._dataResult, fieldNumber: 195) } if _storage._date != 0 { - try visitor.visitSingularInt32Field(value: _storage._date, fieldNumber: 141) + try visitor.visitSingularInt32Field(value: _storage._date, fieldNumber: 196) } if _storage._daySec != 0 { - try visitor.visitSingularInt32Field(value: _storage._daySec, fieldNumber: 142) + try visitor.visitSingularInt32Field(value: _storage._daySec, fieldNumber: 197) } if _storage._daysSinceEpoch != 0 { - try visitor.visitSingularInt32Field(value: _storage._daysSinceEpoch, fieldNumber: 143) + try visitor.visitSingularInt32Field(value: _storage._daysSinceEpoch, fieldNumber: 198) } if _storage._debugDescription_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._debugDescription_p, fieldNumber: 144) + try visitor.visitSingularInt32Field(value: _storage._debugDescription_p, fieldNumber: 199) + } + if _storage._debugRedact != 0 { + try visitor.visitSingularInt32Field(value: _storage._debugRedact, fieldNumber: 200) + } + if _storage._declaration != 0 { + try visitor.visitSingularInt32Field(value: _storage._declaration, fieldNumber: 201) } if _storage._decoded != 0 { - try visitor.visitSingularInt32Field(value: _storage._decoded, fieldNumber: 145) + try visitor.visitSingularInt32Field(value: _storage._decoded, fieldNumber: 202) } if _storage._decodedFromJsonnull != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodedFromJsonnull, fieldNumber: 146) + try visitor.visitSingularInt32Field(value: _storage._decodedFromJsonnull, fieldNumber: 203) } if _storage._decodeExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeExtensionField, fieldNumber: 147) + try visitor.visitSingularInt32Field(value: _storage._decodeExtensionField, fieldNumber: 204) } if _storage._decodeExtensionFieldsAsMessageSet != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeExtensionFieldsAsMessageSet, fieldNumber: 148) + try visitor.visitSingularInt32Field(value: _storage._decodeExtensionFieldsAsMessageSet, fieldNumber: 205) } if _storage._decodeJson != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeJson, fieldNumber: 149) + try visitor.visitSingularInt32Field(value: _storage._decodeJson, fieldNumber: 206) } if _storage._decodeMapField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeMapField, fieldNumber: 150) + try visitor.visitSingularInt32Field(value: _storage._decodeMapField, fieldNumber: 207) } if _storage._decodeMessage != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeMessage, fieldNumber: 151) + try visitor.visitSingularInt32Field(value: _storage._decodeMessage, fieldNumber: 208) } if _storage._decoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._decoder, fieldNumber: 152) + try visitor.visitSingularInt32Field(value: _storage._decoder, fieldNumber: 209) } if _storage._decodeRepeated != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeated, fieldNumber: 153) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeated, fieldNumber: 210) } if _storage._decodeRepeatedBoolField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedBoolField, fieldNumber: 154) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedBoolField, fieldNumber: 211) } if _storage._decodeRepeatedBytesField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedBytesField, fieldNumber: 155) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedBytesField, fieldNumber: 212) } if _storage._decodeRepeatedDoubleField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedDoubleField, fieldNumber: 156) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedDoubleField, fieldNumber: 213) } if _storage._decodeRepeatedEnumField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedEnumField, fieldNumber: 157) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedEnumField, fieldNumber: 214) } if _storage._decodeRepeatedFixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedFixed32Field, fieldNumber: 158) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedFixed32Field, fieldNumber: 215) } if _storage._decodeRepeatedFixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedFixed64Field, fieldNumber: 159) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedFixed64Field, fieldNumber: 216) } if _storage._decodeRepeatedFloatField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedFloatField, fieldNumber: 160) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedFloatField, fieldNumber: 217) } if _storage._decodeRepeatedGroupField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedGroupField, fieldNumber: 161) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedGroupField, fieldNumber: 218) } if _storage._decodeRepeatedInt32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedInt32Field, fieldNumber: 162) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedInt32Field, fieldNumber: 219) } if _storage._decodeRepeatedInt64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedInt64Field, fieldNumber: 163) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedInt64Field, fieldNumber: 220) } if _storage._decodeRepeatedMessageField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedMessageField, fieldNumber: 164) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedMessageField, fieldNumber: 221) } if _storage._decodeRepeatedSfixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSfixed32Field, fieldNumber: 165) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSfixed32Field, fieldNumber: 222) } if _storage._decodeRepeatedSfixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSfixed64Field, fieldNumber: 166) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSfixed64Field, fieldNumber: 223) } if _storage._decodeRepeatedSint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSint32Field, fieldNumber: 167) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSint32Field, fieldNumber: 224) } if _storage._decodeRepeatedSint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSint64Field, fieldNumber: 168) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedSint64Field, fieldNumber: 225) } if _storage._decodeRepeatedStringField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedStringField, fieldNumber: 169) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedStringField, fieldNumber: 226) } if _storage._decodeRepeatedUint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedUint32Field, fieldNumber: 170) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedUint32Field, fieldNumber: 227) } if _storage._decodeRepeatedUint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedUint64Field, fieldNumber: 171) + try visitor.visitSingularInt32Field(value: _storage._decodeRepeatedUint64Field, fieldNumber: 228) } if _storage._decodeSingular != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingular, fieldNumber: 172) + try visitor.visitSingularInt32Field(value: _storage._decodeSingular, fieldNumber: 229) } if _storage._decodeSingularBoolField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularBoolField, fieldNumber: 173) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularBoolField, fieldNumber: 230) } if _storage._decodeSingularBytesField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularBytesField, fieldNumber: 174) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularBytesField, fieldNumber: 231) } if _storage._decodeSingularDoubleField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularDoubleField, fieldNumber: 175) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularDoubleField, fieldNumber: 232) } if _storage._decodeSingularEnumField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularEnumField, fieldNumber: 176) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularEnumField, fieldNumber: 233) } if _storage._decodeSingularFixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularFixed32Field, fieldNumber: 177) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularFixed32Field, fieldNumber: 234) } if _storage._decodeSingularFixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularFixed64Field, fieldNumber: 178) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularFixed64Field, fieldNumber: 235) } if _storage._decodeSingularFloatField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularFloatField, fieldNumber: 179) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularFloatField, fieldNumber: 236) } if _storage._decodeSingularGroupField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularGroupField, fieldNumber: 180) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularGroupField, fieldNumber: 237) } if _storage._decodeSingularInt32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularInt32Field, fieldNumber: 181) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularInt32Field, fieldNumber: 238) } if _storage._decodeSingularInt64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularInt64Field, fieldNumber: 182) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularInt64Field, fieldNumber: 239) } if _storage._decodeSingularMessageField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularMessageField, fieldNumber: 183) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularMessageField, fieldNumber: 240) } if _storage._decodeSingularSfixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularSfixed32Field, fieldNumber: 184) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularSfixed32Field, fieldNumber: 241) } if _storage._decodeSingularSfixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularSfixed64Field, fieldNumber: 185) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularSfixed64Field, fieldNumber: 242) } if _storage._decodeSingularSint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularSint32Field, fieldNumber: 186) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularSint32Field, fieldNumber: 243) } if _storage._decodeSingularSint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularSint64Field, fieldNumber: 187) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularSint64Field, fieldNumber: 244) } if _storage._decodeSingularStringField != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularStringField, fieldNumber: 188) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularStringField, fieldNumber: 245) } if _storage._decodeSingularUint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularUint32Field, fieldNumber: 189) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularUint32Field, fieldNumber: 246) } if _storage._decodeSingularUint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeSingularUint64Field, fieldNumber: 190) + try visitor.visitSingularInt32Field(value: _storage._decodeSingularUint64Field, fieldNumber: 247) } if _storage._decodeTextFormat != 0 { - try visitor.visitSingularInt32Field(value: _storage._decodeTextFormat, fieldNumber: 191) + try visitor.visitSingularInt32Field(value: _storage._decodeTextFormat, fieldNumber: 248) } if _storage._defaultAnyTypeUrlprefix != 0 { - try visitor.visitSingularInt32Field(value: _storage._defaultAnyTypeUrlprefix, fieldNumber: 192) + try visitor.visitSingularInt32Field(value: _storage._defaultAnyTypeUrlprefix, fieldNumber: 249) + } + if _storage._defaults != 0 { + try visitor.visitSingularInt32Field(value: _storage._defaults, fieldNumber: 250) + } + if _storage._defaultSymbolVisibility != 0 { + try visitor.visitSingularInt32Field(value: _storage._defaultSymbolVisibility, fieldNumber: 251) } if _storage._defaultValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._defaultValue, fieldNumber: 193) + try visitor.visitSingularInt32Field(value: _storage._defaultValue, fieldNumber: 252) } if _storage._dependency != 0 { - try visitor.visitSingularInt32Field(value: _storage._dependency, fieldNumber: 194) + try visitor.visitSingularInt32Field(value: _storage._dependency, fieldNumber: 253) } if _storage._deprecated != 0 { - try visitor.visitSingularInt32Field(value: _storage._deprecated, fieldNumber: 195) + try visitor.visitSingularInt32Field(value: _storage._deprecated, fieldNumber: 254) } - if _storage._description_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._description_p, fieldNumber: 196) + if _storage._deprecatedLegacyJsonFieldConflicts != 0 { + try visitor.visitSingularInt32Field(value: _storage._deprecatedLegacyJsonFieldConflicts, fieldNumber: 255) } - if _storage._descriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._descriptorProto, fieldNumber: 197) + if _storage._deprecationWarning != 0 { + try visitor.visitSingularInt32Field(value: _storage._deprecationWarning, fieldNumber: 256) + } + if _storage._description_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._description_p, fieldNumber: 257) } if _storage._dictionary != 0 { - try visitor.visitSingularInt32Field(value: _storage._dictionary, fieldNumber: 198) + try visitor.visitSingularInt32Field(value: _storage._dictionary, fieldNumber: 258) } if _storage._dictionaryLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._dictionaryLiteral, fieldNumber: 199) + try visitor.visitSingularInt32Field(value: _storage._dictionaryLiteral, fieldNumber: 259) } if _storage._digit != 0 { - try visitor.visitSingularInt32Field(value: _storage._digit, fieldNumber: 200) + try visitor.visitSingularInt32Field(value: _storage._digit, fieldNumber: 260) } if _storage._digit0 != 0 { - try visitor.visitSingularInt32Field(value: _storage._digit0, fieldNumber: 201) + try visitor.visitSingularInt32Field(value: _storage._digit0, fieldNumber: 261) } if _storage._digit1 != 0 { - try visitor.visitSingularInt32Field(value: _storage._digit1, fieldNumber: 202) + try visitor.visitSingularInt32Field(value: _storage._digit1, fieldNumber: 262) } if _storage._digitCount != 0 { - try visitor.visitSingularInt32Field(value: _storage._digitCount, fieldNumber: 203) + try visitor.visitSingularInt32Field(value: _storage._digitCount, fieldNumber: 263) } if _storage._digits != 0 { - try visitor.visitSingularInt32Field(value: _storage._digits, fieldNumber: 204) + try visitor.visitSingularInt32Field(value: _storage._digits, fieldNumber: 264) } if _storage._digitValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._digitValue, fieldNumber: 205) + try visitor.visitSingularInt32Field(value: _storage._digitValue, fieldNumber: 265) } if _storage._discardableResult != 0 { - try visitor.visitSingularInt32Field(value: _storage._discardableResult, fieldNumber: 206) + try visitor.visitSingularInt32Field(value: _storage._discardableResult, fieldNumber: 266) } if _storage._discardUnknownFields != 0 { - try visitor.visitSingularInt32Field(value: _storage._discardUnknownFields, fieldNumber: 207) - } - if _storage._distance != 0 { - try visitor.visitSingularInt32Field(value: _storage._distance, fieldNumber: 208) + try visitor.visitSingularInt32Field(value: _storage._discardUnknownFields, fieldNumber: 267) } if _storage._double != 0 { - try visitor.visitSingularInt32Field(value: _storage._double, fieldNumber: 209) + try visitor.visitSingularInt32Field(value: _storage._double, fieldNumber: 268) } if _storage._doubleValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._doubleValue, fieldNumber: 210) + try visitor.visitSingularInt32Field(value: _storage._doubleValue, fieldNumber: 269) } if _storage._duration != 0 { - try visitor.visitSingularInt32Field(value: _storage._duration, fieldNumber: 211) + try visitor.visitSingularInt32Field(value: _storage._duration, fieldNumber: 270) } if _storage._e != 0 { - try visitor.visitSingularInt32Field(value: _storage._e, fieldNumber: 212) + try visitor.visitSingularInt32Field(value: _storage._e, fieldNumber: 271) + } + if _storage._edition != 0 { + try visitor.visitSingularInt32Field(value: _storage._edition, fieldNumber: 272) + } + if _storage._editionDefault != 0 { + try visitor.visitSingularInt32Field(value: _storage._editionDefault, fieldNumber: 273) + } + if _storage._editionDefaults != 0 { + try visitor.visitSingularInt32Field(value: _storage._editionDefaults, fieldNumber: 274) + } + if _storage._editionDeprecated != 0 { + try visitor.visitSingularInt32Field(value: _storage._editionDeprecated, fieldNumber: 275) + } + if _storage._editionIntroduced != 0 { + try visitor.visitSingularInt32Field(value: _storage._editionIntroduced, fieldNumber: 276) + } + if _storage._editionRemoved != 0 { + try visitor.visitSingularInt32Field(value: _storage._editionRemoved, fieldNumber: 277) } if _storage._element != 0 { - try visitor.visitSingularInt32Field(value: _storage._element, fieldNumber: 213) + try visitor.visitSingularInt32Field(value: _storage._element, fieldNumber: 278) } if _storage._elements != 0 { - try visitor.visitSingularInt32Field(value: _storage._elements, fieldNumber: 214) + try visitor.visitSingularInt32Field(value: _storage._elements, fieldNumber: 279) + } + if _storage._else != 0 { + try visitor.visitSingularInt32Field(value: _storage._else, fieldNumber: 280) } if _storage._emitExtensionFieldName != 0 { - try visitor.visitSingularInt32Field(value: _storage._emitExtensionFieldName, fieldNumber: 215) + try visitor.visitSingularInt32Field(value: _storage._emitExtensionFieldName, fieldNumber: 281) } if _storage._emitFieldName != 0 { - try visitor.visitSingularInt32Field(value: _storage._emitFieldName, fieldNumber: 216) + try visitor.visitSingularInt32Field(value: _storage._emitFieldName, fieldNumber: 282) } if _storage._emitFieldNumber != 0 { - try visitor.visitSingularInt32Field(value: _storage._emitFieldNumber, fieldNumber: 217) + try visitor.visitSingularInt32Field(value: _storage._emitFieldNumber, fieldNumber: 283) } - if _storage._empty != 0 { - try visitor.visitSingularInt32Field(value: _storage._empty, fieldNumber: 218) + if _storage._emptyAnyTypeURL != 0 { + try visitor.visitSingularInt32Field(value: _storage._emptyAnyTypeURL, fieldNumber: 284) } if _storage._emptyData != 0 { - try visitor.visitSingularInt32Field(value: _storage._emptyData, fieldNumber: 219) + try visitor.visitSingularInt32Field(value: _storage._emptyData, fieldNumber: 285) } if _storage._encodeAsBytes != 0 { - try visitor.visitSingularInt32Field(value: _storage._encodeAsBytes, fieldNumber: 220) + try visitor.visitSingularInt32Field(value: _storage._encodeAsBytes, fieldNumber: 286) } if _storage._encoded != 0 { - try visitor.visitSingularInt32Field(value: _storage._encoded, fieldNumber: 221) + try visitor.visitSingularInt32Field(value: _storage._encoded, fieldNumber: 287) } if _storage._encodedJsonstring != 0 { - try visitor.visitSingularInt32Field(value: _storage._encodedJsonstring, fieldNumber: 222) + try visitor.visitSingularInt32Field(value: _storage._encodedJsonstring, fieldNumber: 288) } if _storage._encodedSize != 0 { - try visitor.visitSingularInt32Field(value: _storage._encodedSize, fieldNumber: 223) + try visitor.visitSingularInt32Field(value: _storage._encodedSize, fieldNumber: 289) } if _storage._encodeField != 0 { - try visitor.visitSingularInt32Field(value: _storage._encodeField, fieldNumber: 224) + try visitor.visitSingularInt32Field(value: _storage._encodeField, fieldNumber: 290) } if _storage._encoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._encoder, fieldNumber: 225) + try visitor.visitSingularInt32Field(value: _storage._encoder, fieldNumber: 291) } if _storage._end != 0 { - try visitor.visitSingularInt32Field(value: _storage._end, fieldNumber: 226) + try visitor.visitSingularInt32Field(value: _storage._end, fieldNumber: 292) } if _storage._endArray != 0 { - try visitor.visitSingularInt32Field(value: _storage._endArray, fieldNumber: 227) + try visitor.visitSingularInt32Field(value: _storage._endArray, fieldNumber: 293) } if _storage._endMessageField != 0 { - try visitor.visitSingularInt32Field(value: _storage._endMessageField, fieldNumber: 228) + try visitor.visitSingularInt32Field(value: _storage._endMessageField, fieldNumber: 294) } if _storage._endObject != 0 { - try visitor.visitSingularInt32Field(value: _storage._endObject, fieldNumber: 229) + try visitor.visitSingularInt32Field(value: _storage._endObject, fieldNumber: 295) } if _storage._endRegularField != 0 { - try visitor.visitSingularInt32Field(value: _storage._endRegularField, fieldNumber: 230) + try visitor.visitSingularInt32Field(value: _storage._endRegularField, fieldNumber: 296) } - if _storage._enum != 0 { - try visitor.visitSingularInt32Field(value: _storage._enum, fieldNumber: 231) - } - if _storage._enumDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._enumDescriptorProto, fieldNumber: 232) + if _storage._enforceNamingStyle != 0 { + try visitor.visitSingularInt32Field(value: _storage._enforceNamingStyle, fieldNumber: 297) } - if _storage._enumOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._enumOptions, fieldNumber: 233) + if _storage._enum != 0 { + try visitor.visitSingularInt32Field(value: _storage._enum, fieldNumber: 298) } if _storage._enumReservedRange != 0 { - try visitor.visitSingularInt32Field(value: _storage._enumReservedRange, fieldNumber: 234) + try visitor.visitSingularInt32Field(value: _storage._enumReservedRange, fieldNumber: 299) } if _storage._enumType != 0 { - try visitor.visitSingularInt32Field(value: _storage._enumType, fieldNumber: 235) + try visitor.visitSingularInt32Field(value: _storage._enumType, fieldNumber: 300) } if _storage._enumvalue != 0 { - try visitor.visitSingularInt32Field(value: _storage._enumvalue, fieldNumber: 236) - } - if _storage._enumValueDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._enumValueDescriptorProto, fieldNumber: 237) - } - if _storage._enumValueOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._enumValueOptions, fieldNumber: 238) + try visitor.visitSingularInt32Field(value: _storage._enumvalue, fieldNumber: 301) } if _storage._equatable != 0 { - try visitor.visitSingularInt32Field(value: _storage._equatable, fieldNumber: 239) + try visitor.visitSingularInt32Field(value: _storage._equatable, fieldNumber: 302) } if _storage._error != 0 { - try visitor.visitSingularInt32Field(value: _storage._error, fieldNumber: 240) + try visitor.visitSingularInt32Field(value: _storage._error, fieldNumber: 303) + } + if _storage._execute != 0 { + try visitor.visitSingularInt32Field(value: _storage._execute, fieldNumber: 304) } if _storage._expressibleByArrayLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._expressibleByArrayLiteral, fieldNumber: 241) + try visitor.visitSingularInt32Field(value: _storage._expressibleByArrayLiteral, fieldNumber: 305) } if _storage._expressibleByDictionaryLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._expressibleByDictionaryLiteral, fieldNumber: 242) + try visitor.visitSingularInt32Field(value: _storage._expressibleByDictionaryLiteral, fieldNumber: 306) } if _storage._ext != 0 { - try visitor.visitSingularInt32Field(value: _storage._ext, fieldNumber: 243) + try visitor.visitSingularInt32Field(value: _storage._ext, fieldNumber: 307) } if _storage._extDecoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._extDecoder, fieldNumber: 244) + try visitor.visitSingularInt32Field(value: _storage._extDecoder, fieldNumber: 308) } if _storage._extendedGraphemeClusterLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._extendedGraphemeClusterLiteral, fieldNumber: 245) + try visitor.visitSingularInt32Field(value: _storage._extendedGraphemeClusterLiteral, fieldNumber: 309) } if _storage._extendedGraphemeClusterLiteralType != 0 { - try visitor.visitSingularInt32Field(value: _storage._extendedGraphemeClusterLiteralType, fieldNumber: 246) + try visitor.visitSingularInt32Field(value: _storage._extendedGraphemeClusterLiteralType, fieldNumber: 310) } if _storage._extendee != 0 { - try visitor.visitSingularInt32Field(value: _storage._extendee, fieldNumber: 247) + try visitor.visitSingularInt32Field(value: _storage._extendee, fieldNumber: 311) } if _storage._extensibleMessage != 0 { - try visitor.visitSingularInt32Field(value: _storage._extensibleMessage, fieldNumber: 248) + try visitor.visitSingularInt32Field(value: _storage._extensibleMessage, fieldNumber: 312) } if _storage._extension != 0 { - try visitor.visitSingularInt32Field(value: _storage._extension, fieldNumber: 249) + try visitor.visitSingularInt32Field(value: _storage._extension, fieldNumber: 313) } if _storage._extensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._extensionField, fieldNumber: 250) + try visitor.visitSingularInt32Field(value: _storage._extensionField, fieldNumber: 314) } if _storage._extensionFieldNumber != 0 { - try visitor.visitSingularInt32Field(value: _storage._extensionFieldNumber, fieldNumber: 251) + try visitor.visitSingularInt32Field(value: _storage._extensionFieldNumber, fieldNumber: 315) } if _storage._extensionFieldValueSet != 0 { - try visitor.visitSingularInt32Field(value: _storage._extensionFieldValueSet, fieldNumber: 252) + try visitor.visitSingularInt32Field(value: _storage._extensionFieldValueSet, fieldNumber: 316) } if _storage._extensionMap != 0 { - try visitor.visitSingularInt32Field(value: _storage._extensionMap, fieldNumber: 253) + try visitor.visitSingularInt32Field(value: _storage._extensionMap, fieldNumber: 317) } if _storage._extensionRange != 0 { - try visitor.visitSingularInt32Field(value: _storage._extensionRange, fieldNumber: 254) - } - if _storage._extensionRangeOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._extensionRangeOptions, fieldNumber: 255) + try visitor.visitSingularInt32Field(value: _storage._extensionRange, fieldNumber: 318) } if _storage._extensions != 0 { - try visitor.visitSingularInt32Field(value: _storage._extensions, fieldNumber: 256) + try visitor.visitSingularInt32Field(value: _storage._extensions, fieldNumber: 319) } if _storage._extras != 0 { - try visitor.visitSingularInt32Field(value: _storage._extras, fieldNumber: 257) + try visitor.visitSingularInt32Field(value: _storage._extras, fieldNumber: 320) } if _storage._f != 0 { - try visitor.visitSingularInt32Field(value: _storage._f, fieldNumber: 258) + try visitor.visitSingularInt32Field(value: _storage._f, fieldNumber: 321) } if _storage._false != 0 { - try visitor.visitSingularInt32Field(value: _storage._false, fieldNumber: 259) + try visitor.visitSingularInt32Field(value: _storage._false, fieldNumber: 322) + } + if _storage._features != 0 { + try visitor.visitSingularInt32Field(value: _storage._features, fieldNumber: 323) + } + if _storage._featureSetEditionDefault != 0 { + try visitor.visitSingularInt32Field(value: _storage._featureSetEditionDefault, fieldNumber: 324) + } + if _storage._featureSupport != 0 { + try visitor.visitSingularInt32Field(value: _storage._featureSupport, fieldNumber: 325) } if _storage._field != 0 { - try visitor.visitSingularInt32Field(value: _storage._field, fieldNumber: 260) + try visitor.visitSingularInt32Field(value: _storage._field, fieldNumber: 326) } if _storage._fieldData != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldData, fieldNumber: 261) + try visitor.visitSingularInt32Field(value: _storage._fieldData, fieldNumber: 327) } - if _storage._fieldDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldDescriptorProto, fieldNumber: 262) - } - if _storage._fieldMask != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldMask, fieldNumber: 263) + if _storage._fieldMaskError != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldMaskError, fieldNumber: 328) } if _storage._fieldName != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldName, fieldNumber: 264) + try visitor.visitSingularInt32Field(value: _storage._fieldName, fieldNumber: 329) } if _storage._fieldNameCount != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldNameCount, fieldNumber: 265) + try visitor.visitSingularInt32Field(value: _storage._fieldNameCount, fieldNumber: 330) } if _storage._fieldNum != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldNum, fieldNumber: 266) + try visitor.visitSingularInt32Field(value: _storage._fieldNum, fieldNumber: 331) } if _storage._fieldNumber != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldNumber, fieldNumber: 267) + try visitor.visitSingularInt32Field(value: _storage._fieldNumber, fieldNumber: 332) } if _storage._fieldNumberForProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldNumberForProto, fieldNumber: 268) + try visitor.visitSingularInt32Field(value: _storage._fieldNumberForProto, fieldNumber: 333) } - if _storage._fieldOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldOptions, fieldNumber: 269) + if _storage._fieldPresence != 0 { + try visitor.visitSingularInt32Field(value: _storage._fieldPresence, fieldNumber: 334) } if _storage._fields != 0 { - try visitor.visitSingularInt32Field(value: _storage._fields, fieldNumber: 270) + try visitor.visitSingularInt32Field(value: _storage._fields, fieldNumber: 335) } if _storage._fieldSize != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldSize, fieldNumber: 271) + try visitor.visitSingularInt32Field(value: _storage._fieldSize, fieldNumber: 336) } if _storage._fieldTag != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldTag, fieldNumber: 272) + try visitor.visitSingularInt32Field(value: _storage._fieldTag, fieldNumber: 337) } if _storage._fieldType != 0 { - try visitor.visitSingularInt32Field(value: _storage._fieldType, fieldNumber: 273) + try visitor.visitSingularInt32Field(value: _storage._fieldType, fieldNumber: 338) } if _storage._file != 0 { - try visitor.visitSingularInt32Field(value: _storage._file, fieldNumber: 274) - } - if _storage._fileDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._fileDescriptorProto, fieldNumber: 275) - } - if _storage._fileDescriptorSet != 0 { - try visitor.visitSingularInt32Field(value: _storage._fileDescriptorSet, fieldNumber: 276) + try visitor.visitSingularInt32Field(value: _storage._file, fieldNumber: 339) } if _storage._fileName != 0 { - try visitor.visitSingularInt32Field(value: _storage._fileName, fieldNumber: 277) - } - if _storage._fileOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._fileOptions, fieldNumber: 278) + try visitor.visitSingularInt32Field(value: _storage._fileName, fieldNumber: 340) } if _storage._filter != 0 { - try visitor.visitSingularInt32Field(value: _storage._filter, fieldNumber: 279) + try visitor.visitSingularInt32Field(value: _storage._filter, fieldNumber: 341) + } + if _storage._final != 0 { + try visitor.visitSingularInt32Field(value: _storage._final, fieldNumber: 342) + } + if _storage._finiteOnly != 0 { + try visitor.visitSingularInt32Field(value: _storage._finiteOnly, fieldNumber: 343) } if _storage._first != 0 { - try visitor.visitSingularInt32Field(value: _storage._first, fieldNumber: 280) + try visitor.visitSingularInt32Field(value: _storage._first, fieldNumber: 344) } if _storage._firstItem != 0 { - try visitor.visitSingularInt32Field(value: _storage._firstItem, fieldNumber: 281) + try visitor.visitSingularInt32Field(value: _storage._firstItem, fieldNumber: 345) + } + if _storage._fixedFeatures != 0 { + try visitor.visitSingularInt32Field(value: _storage._fixedFeatures, fieldNumber: 346) } if _storage._float != 0 { - try visitor.visitSingularInt32Field(value: _storage._float, fieldNumber: 282) + try visitor.visitSingularInt32Field(value: _storage._float, fieldNumber: 347) } if _storage._floatLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._floatLiteral, fieldNumber: 283) + try visitor.visitSingularInt32Field(value: _storage._floatLiteral, fieldNumber: 348) } if _storage._floatLiteralType != 0 { - try visitor.visitSingularInt32Field(value: _storage._floatLiteralType, fieldNumber: 284) + try visitor.visitSingularInt32Field(value: _storage._floatLiteralType, fieldNumber: 349) } - if _storage._floatValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._floatValue, fieldNumber: 285) + if _storage._for != 0 { + try visitor.visitSingularInt32Field(value: _storage._for, fieldNumber: 350) } if _storage._forMessageName != 0 { - try visitor.visitSingularInt32Field(value: _storage._forMessageName, fieldNumber: 286) + try visitor.visitSingularInt32Field(value: _storage._forMessageName, fieldNumber: 351) } if _storage._formUnion != 0 { - try visitor.visitSingularInt32Field(value: _storage._formUnion, fieldNumber: 287) + try visitor.visitSingularInt32Field(value: _storage._formUnion, fieldNumber: 352) } if _storage._forReadingFrom != 0 { - try visitor.visitSingularInt32Field(value: _storage._forReadingFrom, fieldNumber: 288) + try visitor.visitSingularInt32Field(value: _storage._forReadingFrom, fieldNumber: 353) } if _storage._forTypeURL != 0 { - try visitor.visitSingularInt32Field(value: _storage._forTypeURL, fieldNumber: 289) + try visitor.visitSingularInt32Field(value: _storage._forTypeURL, fieldNumber: 354) } if _storage._forwardParser != 0 { - try visitor.visitSingularInt32Field(value: _storage._forwardParser, fieldNumber: 290) + try visitor.visitSingularInt32Field(value: _storage._forwardParser, fieldNumber: 355) } if _storage._forWritingInto != 0 { - try visitor.visitSingularInt32Field(value: _storage._forWritingInto, fieldNumber: 291) + try visitor.visitSingularInt32Field(value: _storage._forWritingInto, fieldNumber: 356) } if _storage._from != 0 { - try visitor.visitSingularInt32Field(value: _storage._from, fieldNumber: 292) + try visitor.visitSingularInt32Field(value: _storage._from, fieldNumber: 357) } if _storage._fromAscii2 != 0 { - try visitor.visitSingularInt32Field(value: _storage._fromAscii2, fieldNumber: 293) + try visitor.visitSingularInt32Field(value: _storage._fromAscii2, fieldNumber: 358) } if _storage._fromAscii4 != 0 { - try visitor.visitSingularInt32Field(value: _storage._fromAscii4, fieldNumber: 294) + try visitor.visitSingularInt32Field(value: _storage._fromAscii4, fieldNumber: 359) } if _storage._fromByteOffset != 0 { - try visitor.visitSingularInt32Field(value: _storage._fromByteOffset, fieldNumber: 295) + try visitor.visitSingularInt32Field(value: _storage._fromByteOffset, fieldNumber: 360) } if _storage._fromHexDigit != 0 { - try visitor.visitSingularInt32Field(value: _storage._fromHexDigit, fieldNumber: 296) + try visitor.visitSingularInt32Field(value: _storage._fromHexDigit, fieldNumber: 361) + } + if _storage._fullName != 0 { + try visitor.visitSingularInt32Field(value: _storage._fullName, fieldNumber: 362) } if _storage._func != 0 { - try visitor.visitSingularInt32Field(value: _storage._func, fieldNumber: 297) + try visitor.visitSingularInt32Field(value: _storage._func, fieldNumber: 363) } - if _storage._g != 0 { - try visitor.visitSingularInt32Field(value: _storage._g, fieldNumber: 298) + if _storage._function != 0 { + try visitor.visitSingularInt32Field(value: _storage._function, fieldNumber: 364) } - if _storage._generatedCodeInfo != 0 { - try visitor.visitSingularInt32Field(value: _storage._generatedCodeInfo, fieldNumber: 299) + if _storage._g != 0 { + try visitor.visitSingularInt32Field(value: _storage._g, fieldNumber: 365) } if _storage._get != 0 { - try visitor.visitSingularInt32Field(value: _storage._get, fieldNumber: 300) + try visitor.visitSingularInt32Field(value: _storage._get, fieldNumber: 366) } if _storage._getExtensionValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._getExtensionValue, fieldNumber: 301) - } - if _storage._googleapis != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleapis, fieldNumber: 302) + try visitor.visitSingularInt32Field(value: _storage._getExtensionValue, fieldNumber: 367) } if _storage._googleProtobufAny != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufAny, fieldNumber: 303) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufAny, fieldNumber: 368) } if _storage._googleProtobufApi != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufApi, fieldNumber: 304) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufApi, fieldNumber: 369) } if _storage._googleProtobufBoolValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufBoolValue, fieldNumber: 305) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufBoolValue, fieldNumber: 370) } if _storage._googleProtobufBytesValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufBytesValue, fieldNumber: 306) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufBytesValue, fieldNumber: 371) } if _storage._googleProtobufDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufDescriptorProto, fieldNumber: 307) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufDescriptorProto, fieldNumber: 372) } if _storage._googleProtobufDoubleValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufDoubleValue, fieldNumber: 308) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufDoubleValue, fieldNumber: 373) } if _storage._googleProtobufDuration != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufDuration, fieldNumber: 309) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufDuration, fieldNumber: 374) + } + if _storage._googleProtobufEdition != 0 { + try visitor.visitSingularInt32Field(value: _storage._googleProtobufEdition, fieldNumber: 375) } if _storage._googleProtobufEmpty != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufEmpty, fieldNumber: 310) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufEmpty, fieldNumber: 376) } if _storage._googleProtobufEnum != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnum, fieldNumber: 311) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnum, fieldNumber: 377) } if _storage._googleProtobufEnumDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumDescriptorProto, fieldNumber: 312) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumDescriptorProto, fieldNumber: 378) } if _storage._googleProtobufEnumOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumOptions, fieldNumber: 313) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumOptions, fieldNumber: 379) } if _storage._googleProtobufEnumValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumValue, fieldNumber: 314) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumValue, fieldNumber: 380) } if _storage._googleProtobufEnumValueDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumValueDescriptorProto, fieldNumber: 315) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumValueDescriptorProto, fieldNumber: 381) } if _storage._googleProtobufEnumValueOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumValueOptions, fieldNumber: 316) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufEnumValueOptions, fieldNumber: 382) } if _storage._googleProtobufExtensionRangeOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufExtensionRangeOptions, fieldNumber: 317) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufExtensionRangeOptions, fieldNumber: 383) + } + if _storage._googleProtobufFeatureSet != 0 { + try visitor.visitSingularInt32Field(value: _storage._googleProtobufFeatureSet, fieldNumber: 384) + } + if _storage._googleProtobufFeatureSetDefaults != 0 { + try visitor.visitSingularInt32Field(value: _storage._googleProtobufFeatureSetDefaults, fieldNumber: 385) } if _storage._googleProtobufField != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufField, fieldNumber: 318) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufField, fieldNumber: 386) } if _storage._googleProtobufFieldDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufFieldDescriptorProto, fieldNumber: 319) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufFieldDescriptorProto, fieldNumber: 387) } if _storage._googleProtobufFieldMask != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufFieldMask, fieldNumber: 320) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufFieldMask, fieldNumber: 388) } if _storage._googleProtobufFieldOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufFieldOptions, fieldNumber: 321) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufFieldOptions, fieldNumber: 389) } if _storage._googleProtobufFileDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufFileDescriptorProto, fieldNumber: 322) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufFileDescriptorProto, fieldNumber: 390) } if _storage._googleProtobufFileDescriptorSet != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufFileDescriptorSet, fieldNumber: 323) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufFileDescriptorSet, fieldNumber: 391) } if _storage._googleProtobufFileOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufFileOptions, fieldNumber: 324) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufFileOptions, fieldNumber: 392) } if _storage._googleProtobufFloatValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufFloatValue, fieldNumber: 325) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufFloatValue, fieldNumber: 393) } if _storage._googleProtobufGeneratedCodeInfo != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufGeneratedCodeInfo, fieldNumber: 326) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufGeneratedCodeInfo, fieldNumber: 394) } if _storage._googleProtobufInt32Value != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufInt32Value, fieldNumber: 327) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufInt32Value, fieldNumber: 395) } if _storage._googleProtobufInt64Value != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufInt64Value, fieldNumber: 328) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufInt64Value, fieldNumber: 396) } if _storage._googleProtobufListValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufListValue, fieldNumber: 329) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufListValue, fieldNumber: 397) } if _storage._googleProtobufMessageOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufMessageOptions, fieldNumber: 330) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufMessageOptions, fieldNumber: 398) } if _storage._googleProtobufMethod != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufMethod, fieldNumber: 331) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufMethod, fieldNumber: 399) } if _storage._googleProtobufMethodDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufMethodDescriptorProto, fieldNumber: 332) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufMethodDescriptorProto, fieldNumber: 400) } if _storage._googleProtobufMethodOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufMethodOptions, fieldNumber: 333) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufMethodOptions, fieldNumber: 401) } if _storage._googleProtobufMixin != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufMixin, fieldNumber: 334) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufMixin, fieldNumber: 402) } if _storage._googleProtobufNullValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufNullValue, fieldNumber: 335) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufNullValue, fieldNumber: 403) } if _storage._googleProtobufOneofDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufOneofDescriptorProto, fieldNumber: 336) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufOneofDescriptorProto, fieldNumber: 404) } if _storage._googleProtobufOneofOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufOneofOptions, fieldNumber: 337) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufOneofOptions, fieldNumber: 405) } if _storage._googleProtobufOption != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufOption, fieldNumber: 338) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufOption, fieldNumber: 406) } if _storage._googleProtobufServiceDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufServiceDescriptorProto, fieldNumber: 339) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufServiceDescriptorProto, fieldNumber: 407) } if _storage._googleProtobufServiceOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufServiceOptions, fieldNumber: 340) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufServiceOptions, fieldNumber: 408) } if _storage._googleProtobufSourceCodeInfo != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufSourceCodeInfo, fieldNumber: 341) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufSourceCodeInfo, fieldNumber: 409) } if _storage._googleProtobufSourceContext != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufSourceContext, fieldNumber: 342) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufSourceContext, fieldNumber: 410) } if _storage._googleProtobufStringValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufStringValue, fieldNumber: 343) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufStringValue, fieldNumber: 411) } if _storage._googleProtobufStruct != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufStruct, fieldNumber: 344) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufStruct, fieldNumber: 412) + } + if _storage._googleProtobufSymbolVisibility != 0 { + try visitor.visitSingularInt32Field(value: _storage._googleProtobufSymbolVisibility, fieldNumber: 413) } if _storage._googleProtobufSyntax != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufSyntax, fieldNumber: 345) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufSyntax, fieldNumber: 414) } if _storage._googleProtobufTimestamp != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufTimestamp, fieldNumber: 346) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufTimestamp, fieldNumber: 415) } if _storage._googleProtobufType != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufType, fieldNumber: 347) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufType, fieldNumber: 416) } if _storage._googleProtobufUint32Value != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufUint32Value, fieldNumber: 348) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufUint32Value, fieldNumber: 417) } if _storage._googleProtobufUint64Value != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufUint64Value, fieldNumber: 349) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufUint64Value, fieldNumber: 418) } if _storage._googleProtobufUninterpretedOption != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufUninterpretedOption, fieldNumber: 350) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufUninterpretedOption, fieldNumber: 419) } if _storage._googleProtobufValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._googleProtobufValue, fieldNumber: 351) + try visitor.visitSingularInt32Field(value: _storage._googleProtobufValue, fieldNumber: 420) } if _storage._goPackage != 0 { - try visitor.visitSingularInt32Field(value: _storage._goPackage, fieldNumber: 352) + try visitor.visitSingularInt32Field(value: _storage._goPackage, fieldNumber: 421) + } + if _storage._gotData != 0 { + try visitor.visitSingularInt32Field(value: _storage._gotData, fieldNumber: 422) } if _storage._group != 0 { - try visitor.visitSingularInt32Field(value: _storage._group, fieldNumber: 353) + try visitor.visitSingularInt32Field(value: _storage._group, fieldNumber: 423) } if _storage._groupFieldNumberStack != 0 { - try visitor.visitSingularInt32Field(value: _storage._groupFieldNumberStack, fieldNumber: 354) + try visitor.visitSingularInt32Field(value: _storage._groupFieldNumberStack, fieldNumber: 424) } if _storage._groupSize != 0 { - try visitor.visitSingularInt32Field(value: _storage._groupSize, fieldNumber: 355) + try visitor.visitSingularInt32Field(value: _storage._groupSize, fieldNumber: 425) } - if _storage._h != 0 { - try visitor.visitSingularInt32Field(value: _storage._h, fieldNumber: 356) + if _storage._guard != 0 { + try visitor.visitSingularInt32Field(value: _storage._guard, fieldNumber: 426) } if _storage._hadOneofValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._hadOneofValue, fieldNumber: 357) + try visitor.visitSingularInt32Field(value: _storage._hadOneofValue, fieldNumber: 427) } if _storage._handleConflictingOneOf != 0 { - try visitor.visitSingularInt32Field(value: _storage._handleConflictingOneOf, fieldNumber: 358) + try visitor.visitSingularInt32Field(value: _storage._handleConflictingOneOf, fieldNumber: 428) + } + if _storage._handleInstruction != 0 { + try visitor.visitSingularInt32Field(value: _storage._handleInstruction, fieldNumber: 429) } if _storage._hasAggregateValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasAggregateValue_p, fieldNumber: 359) + try visitor.visitSingularInt32Field(value: _storage._hasAggregateValue_p, fieldNumber: 430) } if _storage._hasAllowAlias_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasAllowAlias_p, fieldNumber: 360) + try visitor.visitSingularInt32Field(value: _storage._hasAllowAlias_p, fieldNumber: 431) } if _storage._hasBegin_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasBegin_p, fieldNumber: 361) + try visitor.visitSingularInt32Field(value: _storage._hasBegin_p, fieldNumber: 432) } if _storage._hasCcEnableArenas_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasCcEnableArenas_p, fieldNumber: 362) + try visitor.visitSingularInt32Field(value: _storage._hasCcEnableArenas_p, fieldNumber: 433) } if _storage._hasCcGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasCcGenericServices_p, fieldNumber: 363) + try visitor.visitSingularInt32Field(value: _storage._hasCcGenericServices_p, fieldNumber: 434) } if _storage._hasClientStreaming_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasClientStreaming_p, fieldNumber: 364) + try visitor.visitSingularInt32Field(value: _storage._hasClientStreaming_p, fieldNumber: 435) } if _storage._hasCsharpNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasCsharpNamespace_p, fieldNumber: 365) + try visitor.visitSingularInt32Field(value: _storage._hasCsharpNamespace_p, fieldNumber: 436) } if _storage._hasCtype_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasCtype_p, fieldNumber: 366) + try visitor.visitSingularInt32Field(value: _storage._hasCtype_p, fieldNumber: 437) + } + if _storage._hasData_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasData_p, fieldNumber: 438) + } + if _storage._hasDebugRedact_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasDebugRedact_p, fieldNumber: 439) + } + if _storage._hasDefaultSymbolVisibility_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasDefaultSymbolVisibility_p, fieldNumber: 440) } if _storage._hasDefaultValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasDefaultValue_p, fieldNumber: 367) + try visitor.visitSingularInt32Field(value: _storage._hasDefaultValue_p, fieldNumber: 441) } if _storage._hasDeprecated_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasDeprecated_p, fieldNumber: 368) + try visitor.visitSingularInt32Field(value: _storage._hasDeprecated_p, fieldNumber: 442) + } + if _storage._hasDeprecatedLegacyJsonFieldConflicts_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasDeprecatedLegacyJsonFieldConflicts_p, fieldNumber: 443) + } + if _storage._hasDeprecationWarning_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasDeprecationWarning_p, fieldNumber: 444) } if _storage._hasDoubleValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasDoubleValue_p, fieldNumber: 369) + try visitor.visitSingularInt32Field(value: _storage._hasDoubleValue_p, fieldNumber: 445) + } + if _storage._hasEdition_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasEdition_p, fieldNumber: 446) + } + if _storage._hasEditionDeprecated_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasEditionDeprecated_p, fieldNumber: 447) + } + if _storage._hasEditionIntroduced_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasEditionIntroduced_p, fieldNumber: 448) + } + if _storage._hasEditionRemoved_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasEditionRemoved_p, fieldNumber: 449) } if _storage._hasEnd_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasEnd_p, fieldNumber: 370) + try visitor.visitSingularInt32Field(value: _storage._hasEnd_p, fieldNumber: 450) + } + if _storage._hasEnforceNamingStyle_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasEnforceNamingStyle_p, fieldNumber: 451) + } + if _storage._hasEnumType_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasEnumType_p, fieldNumber: 452) + } + if _storage._hasExplicitDelta_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasExplicitDelta_p, fieldNumber: 453) } if _storage._hasExtendee_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasExtendee_p, fieldNumber: 371) + try visitor.visitSingularInt32Field(value: _storage._hasExtendee_p, fieldNumber: 454) } if _storage._hasExtensionValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasExtensionValue_p, fieldNumber: 372) + try visitor.visitSingularInt32Field(value: _storage._hasExtensionValue_p, fieldNumber: 455) + } + if _storage._hasFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasFeatures_p, fieldNumber: 456) + } + if _storage._hasFeatureSupport_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasFeatureSupport_p, fieldNumber: 457) + } + if _storage._hasFieldPresence_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasFieldPresence_p, fieldNumber: 458) + } + if _storage._hasFixedFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasFixedFeatures_p, fieldNumber: 459) + } + if _storage._hasFullName_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasFullName_p, fieldNumber: 460) } if _storage._hasGoPackage_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasGoPackage_p, fieldNumber: 373) + try visitor.visitSingularInt32Field(value: _storage._hasGoPackage_p, fieldNumber: 461) } if _storage._hash != 0 { - try visitor.visitSingularInt32Field(value: _storage._hash, fieldNumber: 374) + try visitor.visitSingularInt32Field(value: _storage._hash, fieldNumber: 462) } if _storage._hashable != 0 { - try visitor.visitSingularInt32Field(value: _storage._hashable, fieldNumber: 375) + try visitor.visitSingularInt32Field(value: _storage._hashable, fieldNumber: 463) } if _storage._hasher != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasher, fieldNumber: 376) - } - if _storage._hashValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hashValue_p, fieldNumber: 377) + try visitor.visitSingularInt32Field(value: _storage._hasher, fieldNumber: 464) } if _storage._hashVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._hashVisitor, fieldNumber: 378) + try visitor.visitSingularInt32Field(value: _storage._hashVisitor, fieldNumber: 465) } if _storage._hasIdempotencyLevel_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasIdempotencyLevel_p, fieldNumber: 379) + try visitor.visitSingularInt32Field(value: _storage._hasIdempotencyLevel_p, fieldNumber: 466) } if _storage._hasIdentifierValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasIdentifierValue_p, fieldNumber: 380) + try visitor.visitSingularInt32Field(value: _storage._hasIdentifierValue_p, fieldNumber: 467) } if _storage._hasInputType_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasInputType_p, fieldNumber: 381) + try visitor.visitSingularInt32Field(value: _storage._hasInputType_p, fieldNumber: 468) } if _storage._hasIsExtension_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasIsExtension_p, fieldNumber: 382) + try visitor.visitSingularInt32Field(value: _storage._hasIsExtension_p, fieldNumber: 469) } if _storage._hasJavaGenerateEqualsAndHash_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasJavaGenerateEqualsAndHash_p, fieldNumber: 383) + try visitor.visitSingularInt32Field(value: _storage._hasJavaGenerateEqualsAndHash_p, fieldNumber: 470) } if _storage._hasJavaGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasJavaGenericServices_p, fieldNumber: 384) + try visitor.visitSingularInt32Field(value: _storage._hasJavaGenericServices_p, fieldNumber: 471) } if _storage._hasJavaMultipleFiles_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasJavaMultipleFiles_p, fieldNumber: 385) + try visitor.visitSingularInt32Field(value: _storage._hasJavaMultipleFiles_p, fieldNumber: 472) } if _storage._hasJavaOuterClassname_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasJavaOuterClassname_p, fieldNumber: 386) + try visitor.visitSingularInt32Field(value: _storage._hasJavaOuterClassname_p, fieldNumber: 473) } if _storage._hasJavaPackage_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasJavaPackage_p, fieldNumber: 387) + try visitor.visitSingularInt32Field(value: _storage._hasJavaPackage_p, fieldNumber: 474) } if _storage._hasJavaStringCheckUtf8_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasJavaStringCheckUtf8_p, fieldNumber: 388) + try visitor.visitSingularInt32Field(value: _storage._hasJavaStringCheckUtf8_p, fieldNumber: 475) + } + if _storage._hasJsonFormat_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasJsonFormat_p, fieldNumber: 476) } if _storage._hasJsonName_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasJsonName_p, fieldNumber: 389) + try visitor.visitSingularInt32Field(value: _storage._hasJsonName_p, fieldNumber: 477) } if _storage._hasJstype_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasJstype_p, fieldNumber: 390) + try visitor.visitSingularInt32Field(value: _storage._hasJstype_p, fieldNumber: 478) } if _storage._hasLabel_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasLabel_p, fieldNumber: 391) + try visitor.visitSingularInt32Field(value: _storage._hasLabel_p, fieldNumber: 479) } if _storage._hasLazy_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasLazy_p, fieldNumber: 392) + try visitor.visitSingularInt32Field(value: _storage._hasLazy_p, fieldNumber: 480) } if _storage._hasLeadingComments_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasLeadingComments_p, fieldNumber: 393) + try visitor.visitSingularInt32Field(value: _storage._hasLeadingComments_p, fieldNumber: 481) } if _storage._hasMapEntry_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasMapEntry_p, fieldNumber: 394) + try visitor.visitSingularInt32Field(value: _storage._hasMapEntry_p, fieldNumber: 482) + } + if _storage._hasMaximumEdition_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasMaximumEdition_p, fieldNumber: 483) + } + if _storage._hasMessageEncoding_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasMessageEncoding_p, fieldNumber: 484) } if _storage._hasMessageSetWireFormat_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasMessageSetWireFormat_p, fieldNumber: 395) + try visitor.visitSingularInt32Field(value: _storage._hasMessageSetWireFormat_p, fieldNumber: 485) + } + if _storage._hasMinimumEdition_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasMinimumEdition_p, fieldNumber: 486) } if _storage._hasName_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasName_p, fieldNumber: 396) + try visitor.visitSingularInt32Field(value: _storage._hasName_p, fieldNumber: 487) } if _storage._hasNamePart_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasNamePart_p, fieldNumber: 397) + try visitor.visitSingularInt32Field(value: _storage._hasNamePart_p, fieldNumber: 488) } if _storage._hasNegativeIntValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasNegativeIntValue_p, fieldNumber: 398) + try visitor.visitSingularInt32Field(value: _storage._hasNegativeIntValue_p, fieldNumber: 489) } if _storage._hasNoStandardDescriptorAccessor_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasNoStandardDescriptorAccessor_p, fieldNumber: 399) + try visitor.visitSingularInt32Field(value: _storage._hasNoStandardDescriptorAccessor_p, fieldNumber: 490) } if _storage._hasNumber_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasNumber_p, fieldNumber: 400) + try visitor.visitSingularInt32Field(value: _storage._hasNumber_p, fieldNumber: 491) } if _storage._hasObjcClassPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasObjcClassPrefix_p, fieldNumber: 401) + try visitor.visitSingularInt32Field(value: _storage._hasObjcClassPrefix_p, fieldNumber: 492) } if _storage._hasOneofIndex_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasOneofIndex_p, fieldNumber: 402) + try visitor.visitSingularInt32Field(value: _storage._hasOneofIndex_p, fieldNumber: 493) } if _storage._hasOptimizeFor_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasOptimizeFor_p, fieldNumber: 403) + try visitor.visitSingularInt32Field(value: _storage._hasOptimizeFor_p, fieldNumber: 494) } if _storage._hasOptions_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasOptions_p, fieldNumber: 404) + try visitor.visitSingularInt32Field(value: _storage._hasOptions_p, fieldNumber: 495) } if _storage._hasOutputType_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasOutputType_p, fieldNumber: 405) + try visitor.visitSingularInt32Field(value: _storage._hasOutputType_p, fieldNumber: 496) + } + if _storage._hasOverridableFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasOverridableFeatures_p, fieldNumber: 497) } if _storage._hasPackage_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasPackage_p, fieldNumber: 406) + try visitor.visitSingularInt32Field(value: _storage._hasPackage_p, fieldNumber: 498) } if _storage._hasPacked_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasPacked_p, fieldNumber: 407) + try visitor.visitSingularInt32Field(value: _storage._hasPacked_p, fieldNumber: 499) } if _storage._hasPhpClassPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasPhpClassPrefix_p, fieldNumber: 408) - } - if _storage._hasPhpGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasPhpGenericServices_p, fieldNumber: 409) + try visitor.visitSingularInt32Field(value: _storage._hasPhpClassPrefix_p, fieldNumber: 500) } if _storage._hasPhpMetadataNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasPhpMetadataNamespace_p, fieldNumber: 410) + try visitor.visitSingularInt32Field(value: _storage._hasPhpMetadataNamespace_p, fieldNumber: 501) } if _storage._hasPhpNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasPhpNamespace_p, fieldNumber: 411) + try visitor.visitSingularInt32Field(value: _storage._hasPhpNamespace_p, fieldNumber: 502) } if _storage._hasPositiveIntValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasPositiveIntValue_p, fieldNumber: 412) + try visitor.visitSingularInt32Field(value: _storage._hasPositiveIntValue_p, fieldNumber: 503) } if _storage._hasProto3Optional_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasProto3Optional_p, fieldNumber: 413) + try visitor.visitSingularInt32Field(value: _storage._hasProto3Optional_p, fieldNumber: 504) } if _storage._hasPyGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasPyGenericServices_p, fieldNumber: 414) + try visitor.visitSingularInt32Field(value: _storage._hasPyGenericServices_p, fieldNumber: 505) + } + if _storage._hasRemovalError_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasRemovalError_p, fieldNumber: 506) + } + if _storage._hasRepeated_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasRepeated_p, fieldNumber: 507) + } + if _storage._hasRepeatedFieldEncoding_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasRepeatedFieldEncoding_p, fieldNumber: 508) + } + if _storage._hasReserved_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasReserved_p, fieldNumber: 509) + } + if _storage._hasRetention_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasRetention_p, fieldNumber: 510) } if _storage._hasRubyPackage_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasRubyPackage_p, fieldNumber: 415) + try visitor.visitSingularInt32Field(value: _storage._hasRubyPackage_p, fieldNumber: 511) + } + if _storage._hasSemantic_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasSemantic_p, fieldNumber: 512) } if _storage._hasServerStreaming_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasServerStreaming_p, fieldNumber: 416) + try visitor.visitSingularInt32Field(value: _storage._hasServerStreaming_p, fieldNumber: 513) } if _storage._hasSourceCodeInfo_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasSourceCodeInfo_p, fieldNumber: 417) + try visitor.visitSingularInt32Field(value: _storage._hasSourceCodeInfo_p, fieldNumber: 514) } if _storage._hasSourceContext_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasSourceContext_p, fieldNumber: 418) + try visitor.visitSingularInt32Field(value: _storage._hasSourceContext_p, fieldNumber: 515) } if _storage._hasSourceFile_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasSourceFile_p, fieldNumber: 419) + try visitor.visitSingularInt32Field(value: _storage._hasSourceFile_p, fieldNumber: 516) } if _storage._hasStart_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasStart_p, fieldNumber: 420) + try visitor.visitSingularInt32Field(value: _storage._hasStart_p, fieldNumber: 517) } if _storage._hasStringValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasStringValue_p, fieldNumber: 421) + try visitor.visitSingularInt32Field(value: _storage._hasStringValue_p, fieldNumber: 518) } if _storage._hasSwiftPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasSwiftPrefix_p, fieldNumber: 422) + try visitor.visitSingularInt32Field(value: _storage._hasSwiftPrefix_p, fieldNumber: 519) } if _storage._hasSyntax_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasSyntax_p, fieldNumber: 423) + try visitor.visitSingularInt32Field(value: _storage._hasSyntax_p, fieldNumber: 520) } if _storage._hasTrailingComments_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasTrailingComments_p, fieldNumber: 424) + try visitor.visitSingularInt32Field(value: _storage._hasTrailingComments_p, fieldNumber: 521) } if _storage._hasType_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasType_p, fieldNumber: 425) + try visitor.visitSingularInt32Field(value: _storage._hasType_p, fieldNumber: 522) } if _storage._hasTypeName_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasTypeName_p, fieldNumber: 426) + try visitor.visitSingularInt32Field(value: _storage._hasTypeName_p, fieldNumber: 523) + } + if _storage._hasUnverifiedLazy_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasUnverifiedLazy_p, fieldNumber: 524) + } + if _storage._hasUtf8Validation_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasUtf8Validation_p, fieldNumber: 525) } if _storage._hasValue_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasValue_p, fieldNumber: 427) + try visitor.visitSingularInt32Field(value: _storage._hasValue_p, fieldNumber: 526) + } + if _storage._hasVerification_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasVerification_p, fieldNumber: 527) + } + if _storage._hasVisibility_p != 0 { + try visitor.visitSingularInt32Field(value: _storage._hasVisibility_p, fieldNumber: 528) } if _storage._hasWeak_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._hasWeak_p, fieldNumber: 428) + try visitor.visitSingularInt32Field(value: _storage._hasWeak_p, fieldNumber: 529) } if _storage._hour != 0 { - try visitor.visitSingularInt32Field(value: _storage._hour, fieldNumber: 429) + try visitor.visitSingularInt32Field(value: _storage._hour, fieldNumber: 530) } if _storage._i != 0 { - try visitor.visitSingularInt32Field(value: _storage._i, fieldNumber: 430) + try visitor.visitSingularInt32Field(value: _storage._i, fieldNumber: 531) } if _storage._idempotencyLevel != 0 { - try visitor.visitSingularInt32Field(value: _storage._idempotencyLevel, fieldNumber: 431) + try visitor.visitSingularInt32Field(value: _storage._idempotencyLevel, fieldNumber: 532) } if _storage._identifierValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._identifierValue, fieldNumber: 432) + try visitor.visitSingularInt32Field(value: _storage._identifierValue, fieldNumber: 533) } if _storage._if != 0 { - try visitor.visitSingularInt32Field(value: _storage._if, fieldNumber: 433) + try visitor.visitSingularInt32Field(value: _storage._if, fieldNumber: 534) + } + if _storage._ignoreUnknownExtensionFields != 0 { + try visitor.visitSingularInt32Field(value: _storage._ignoreUnknownExtensionFields, fieldNumber: 535) } if _storage._ignoreUnknownFields != 0 { - try visitor.visitSingularInt32Field(value: _storage._ignoreUnknownFields, fieldNumber: 434) + try visitor.visitSingularInt32Field(value: _storage._ignoreUnknownFields, fieldNumber: 536) } if _storage._index != 0 { - try visitor.visitSingularInt32Field(value: _storage._index, fieldNumber: 435) + try visitor.visitSingularInt32Field(value: _storage._index, fieldNumber: 537) } if _storage._init_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._init_p, fieldNumber: 436) + try visitor.visitSingularInt32Field(value: _storage._init_p, fieldNumber: 538) } if _storage._inout != 0 { - try visitor.visitSingularInt32Field(value: _storage._inout, fieldNumber: 437) + try visitor.visitSingularInt32Field(value: _storage._inout, fieldNumber: 539) } if _storage._inputType != 0 { - try visitor.visitSingularInt32Field(value: _storage._inputType, fieldNumber: 438) + try visitor.visitSingularInt32Field(value: _storage._inputType, fieldNumber: 540) } if _storage._insert != 0 { - try visitor.visitSingularInt32Field(value: _storage._insert, fieldNumber: 439) + try visitor.visitSingularInt32Field(value: _storage._insert, fieldNumber: 541) + } + if _storage._instruction != 0 { + try visitor.visitSingularInt32Field(value: _storage._instruction, fieldNumber: 542) } if _storage._int != 0 { - try visitor.visitSingularInt32Field(value: _storage._int, fieldNumber: 440) + try visitor.visitSingularInt32Field(value: _storage._int, fieldNumber: 543) } if _storage._int32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._int32, fieldNumber: 441) - } - if _storage._int32Value != 0 { - try visitor.visitSingularInt32Field(value: _storage._int32Value, fieldNumber: 442) + try visitor.visitSingularInt32Field(value: _storage._int32, fieldNumber: 544) } if _storage._int64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._int64, fieldNumber: 443) - } - if _storage._int64Value != 0 { - try visitor.visitSingularInt32Field(value: _storage._int64Value, fieldNumber: 444) + try visitor.visitSingularInt32Field(value: _storage._int64, fieldNumber: 545) } if _storage._int8 != 0 { - try visitor.visitSingularInt32Field(value: _storage._int8, fieldNumber: 445) + try visitor.visitSingularInt32Field(value: _storage._int8, fieldNumber: 546) } if _storage._integerLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._integerLiteral, fieldNumber: 446) + try visitor.visitSingularInt32Field(value: _storage._integerLiteral, fieldNumber: 547) } if _storage._integerLiteralType != 0 { - try visitor.visitSingularInt32Field(value: _storage._integerLiteralType, fieldNumber: 447) + try visitor.visitSingularInt32Field(value: _storage._integerLiteralType, fieldNumber: 548) } if _storage._intern != 0 { - try visitor.visitSingularInt32Field(value: _storage._intern, fieldNumber: 448) + try visitor.visitSingularInt32Field(value: _storage._intern, fieldNumber: 549) } if _storage._internal != 0 { - try visitor.visitSingularInt32Field(value: _storage._internal, fieldNumber: 449) + try visitor.visitSingularInt32Field(value: _storage._internal, fieldNumber: 550) } if _storage._internalState != 0 { - try visitor.visitSingularInt32Field(value: _storage._internalState, fieldNumber: 450) + try visitor.visitSingularInt32Field(value: _storage._internalState, fieldNumber: 551) + } + if _storage._intersect != 0 { + try visitor.visitSingularInt32Field(value: _storage._intersect, fieldNumber: 552) } if _storage._into != 0 { - try visitor.visitSingularInt32Field(value: _storage._into, fieldNumber: 451) + try visitor.visitSingularInt32Field(value: _storage._into, fieldNumber: 553) } if _storage._ints != 0 { - try visitor.visitSingularInt32Field(value: _storage._ints, fieldNumber: 452) + try visitor.visitSingularInt32Field(value: _storage._ints, fieldNumber: 554) + } + if _storage._invalidAnyTypeURL != 0 { + try visitor.visitSingularInt32Field(value: _storage._invalidAnyTypeURL, fieldNumber: 555) } if _storage._isA != 0 { - try visitor.visitSingularInt32Field(value: _storage._isA, fieldNumber: 453) + try visitor.visitSingularInt32Field(value: _storage._isA, fieldNumber: 556) } if _storage._isEqual != 0 { - try visitor.visitSingularInt32Field(value: _storage._isEqual, fieldNumber: 454) + try visitor.visitSingularInt32Field(value: _storage._isEqual, fieldNumber: 557) } if _storage._isEqualTo != 0 { - try visitor.visitSingularInt32Field(value: _storage._isEqualTo, fieldNumber: 455) + try visitor.visitSingularInt32Field(value: _storage._isEqualTo, fieldNumber: 558) } if _storage._isExtension != 0 { - try visitor.visitSingularInt32Field(value: _storage._isExtension, fieldNumber: 456) + try visitor.visitSingularInt32Field(value: _storage._isExtension, fieldNumber: 559) } if _storage._isInitialized_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._isInitialized_p, fieldNumber: 457) + try visitor.visitSingularInt32Field(value: _storage._isInitialized_p, fieldNumber: 560) + } + if _storage._isNegative != 0 { + try visitor.visitSingularInt32Field(value: _storage._isNegative, fieldNumber: 561) + } + if _storage._isPathValid != 0 { + try visitor.visitSingularInt32Field(value: _storage._isPathValid, fieldNumber: 562) + } + if _storage._isReserved != 0 { + try visitor.visitSingularInt32Field(value: _storage._isReserved, fieldNumber: 563) + } + if _storage._isValid != 0 { + try visitor.visitSingularInt32Field(value: _storage._isValid, fieldNumber: 564) } if _storage._itemTagsEncodedSize != 0 { - try visitor.visitSingularInt32Field(value: _storage._itemTagsEncodedSize, fieldNumber: 458) + try visitor.visitSingularInt32Field(value: _storage._itemTagsEncodedSize, fieldNumber: 565) } if _storage._iterator != 0 { - try visitor.visitSingularInt32Field(value: _storage._iterator, fieldNumber: 459) - } - if _storage._i2166136261 != 0 { - try visitor.visitSingularInt32Field(value: _storage._i2166136261, fieldNumber: 460) + try visitor.visitSingularInt32Field(value: _storage._iterator, fieldNumber: 566) } if _storage._javaGenerateEqualsAndHash != 0 { - try visitor.visitSingularInt32Field(value: _storage._javaGenerateEqualsAndHash, fieldNumber: 461) + try visitor.visitSingularInt32Field(value: _storage._javaGenerateEqualsAndHash, fieldNumber: 567) } if _storage._javaGenericServices != 0 { - try visitor.visitSingularInt32Field(value: _storage._javaGenericServices, fieldNumber: 462) + try visitor.visitSingularInt32Field(value: _storage._javaGenericServices, fieldNumber: 568) } if _storage._javaMultipleFiles != 0 { - try visitor.visitSingularInt32Field(value: _storage._javaMultipleFiles, fieldNumber: 463) + try visitor.visitSingularInt32Field(value: _storage._javaMultipleFiles, fieldNumber: 569) } if _storage._javaOuterClassname != 0 { - try visitor.visitSingularInt32Field(value: _storage._javaOuterClassname, fieldNumber: 464) + try visitor.visitSingularInt32Field(value: _storage._javaOuterClassname, fieldNumber: 570) } if _storage._javaPackage != 0 { - try visitor.visitSingularInt32Field(value: _storage._javaPackage, fieldNumber: 465) + try visitor.visitSingularInt32Field(value: _storage._javaPackage, fieldNumber: 571) } if _storage._javaStringCheckUtf8 != 0 { - try visitor.visitSingularInt32Field(value: _storage._javaStringCheckUtf8, fieldNumber: 466) + try visitor.visitSingularInt32Field(value: _storage._javaStringCheckUtf8, fieldNumber: 572) } if _storage._jsondecoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsondecoder, fieldNumber: 467) + try visitor.visitSingularInt32Field(value: _storage._jsondecoder, fieldNumber: 573) + } + if _storage._jsondecoding != 0 { + try visitor.visitSingularInt32Field(value: _storage._jsondecoding, fieldNumber: 574) } if _storage._jsondecodingError != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsondecodingError, fieldNumber: 468) + try visitor.visitSingularInt32Field(value: _storage._jsondecodingError, fieldNumber: 575) } if _storage._jsondecodingOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsondecodingOptions, fieldNumber: 469) + try visitor.visitSingularInt32Field(value: _storage._jsondecodingOptions, fieldNumber: 576) } if _storage._jsonEncoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonEncoder, fieldNumber: 470) + try visitor.visitSingularInt32Field(value: _storage._jsonEncoder, fieldNumber: 577) + } + if _storage._jsonencoding != 0 { + try visitor.visitSingularInt32Field(value: _storage._jsonencoding, fieldNumber: 578) } if _storage._jsonencodingError != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonencodingError, fieldNumber: 471) + try visitor.visitSingularInt32Field(value: _storage._jsonencodingError, fieldNumber: 579) } if _storage._jsonencodingOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonencodingOptions, fieldNumber: 472) + try visitor.visitSingularInt32Field(value: _storage._jsonencodingOptions, fieldNumber: 580) } if _storage._jsonencodingVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonencodingVisitor, fieldNumber: 473) + try visitor.visitSingularInt32Field(value: _storage._jsonencodingVisitor, fieldNumber: 581) + } + if _storage._jsonFormat != 0 { + try visitor.visitSingularInt32Field(value: _storage._jsonFormat, fieldNumber: 582) } if _storage._jsonmapEncodingVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonmapEncodingVisitor, fieldNumber: 474) + try visitor.visitSingularInt32Field(value: _storage._jsonmapEncodingVisitor, fieldNumber: 583) } if _storage._jsonName != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonName, fieldNumber: 475) + try visitor.visitSingularInt32Field(value: _storage._jsonName, fieldNumber: 584) } if _storage._jsonPath != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonPath, fieldNumber: 476) + try visitor.visitSingularInt32Field(value: _storage._jsonPath, fieldNumber: 585) } if _storage._jsonPaths != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonPaths, fieldNumber: 477) + try visitor.visitSingularInt32Field(value: _storage._jsonPaths, fieldNumber: 586) } if _storage._jsonscanner != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonscanner, fieldNumber: 478) + try visitor.visitSingularInt32Field(value: _storage._jsonscanner, fieldNumber: 587) } if _storage._jsonString != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonString, fieldNumber: 479) + try visitor.visitSingularInt32Field(value: _storage._jsonString, fieldNumber: 588) } if _storage._jsonText != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonText, fieldNumber: 480) + try visitor.visitSingularInt32Field(value: _storage._jsonText, fieldNumber: 589) + } + if _storage._jsonUtf8Bytes != 0 { + try visitor.visitSingularInt32Field(value: _storage._jsonUtf8Bytes, fieldNumber: 590) } if _storage._jsonUtf8Data != 0 { - try visitor.visitSingularInt32Field(value: _storage._jsonUtf8Data, fieldNumber: 481) + try visitor.visitSingularInt32Field(value: _storage._jsonUtf8Data, fieldNumber: 591) } if _storage._jstype != 0 { - try visitor.visitSingularInt32Field(value: _storage._jstype, fieldNumber: 482) + try visitor.visitSingularInt32Field(value: _storage._jstype, fieldNumber: 592) } if _storage._k != 0 { - try visitor.visitSingularInt32Field(value: _storage._k, fieldNumber: 483) + try visitor.visitSingularInt32Field(value: _storage._k, fieldNumber: 593) + } + if _storage._kChunkSize != 0 { + try visitor.visitSingularInt32Field(value: _storage._kChunkSize, fieldNumber: 594) } if _storage._key != 0 { - try visitor.visitSingularInt32Field(value: _storage._key, fieldNumber: 484) + try visitor.visitSingularInt32Field(value: _storage._key, fieldNumber: 595) } if _storage._keyField != 0 { - try visitor.visitSingularInt32Field(value: _storage._keyField, fieldNumber: 485) + try visitor.visitSingularInt32Field(value: _storage._keyField, fieldNumber: 596) + } + if _storage._keyFieldOpt != 0 { + try visitor.visitSingularInt32Field(value: _storage._keyFieldOpt, fieldNumber: 597) } if _storage._keyType != 0 { - try visitor.visitSingularInt32Field(value: _storage._keyType, fieldNumber: 486) + try visitor.visitSingularInt32Field(value: _storage._keyType, fieldNumber: 598) } if _storage._kind != 0 { - try visitor.visitSingularInt32Field(value: _storage._kind, fieldNumber: 487) + try visitor.visitSingularInt32Field(value: _storage._kind, fieldNumber: 599) } if _storage._l != 0 { - try visitor.visitSingularInt32Field(value: _storage._l, fieldNumber: 488) + try visitor.visitSingularInt32Field(value: _storage._l, fieldNumber: 600) } if _storage._label != 0 { - try visitor.visitSingularInt32Field(value: _storage._label, fieldNumber: 489) + try visitor.visitSingularInt32Field(value: _storage._label, fieldNumber: 601) } if _storage._lazy != 0 { - try visitor.visitSingularInt32Field(value: _storage._lazy, fieldNumber: 490) + try visitor.visitSingularInt32Field(value: _storage._lazy, fieldNumber: 602) } if _storage._leadingComments != 0 { - try visitor.visitSingularInt32Field(value: _storage._leadingComments, fieldNumber: 491) + try visitor.visitSingularInt32Field(value: _storage._leadingComments, fieldNumber: 603) } if _storage._leadingDetachedComments != 0 { - try visitor.visitSingularInt32Field(value: _storage._leadingDetachedComments, fieldNumber: 492) + try visitor.visitSingularInt32Field(value: _storage._leadingDetachedComments, fieldNumber: 604) } if _storage._length != 0 { - try visitor.visitSingularInt32Field(value: _storage._length, fieldNumber: 493) + try visitor.visitSingularInt32Field(value: _storage._length, fieldNumber: 605) } if _storage._lessThan != 0 { - try visitor.visitSingularInt32Field(value: _storage._lessThan, fieldNumber: 494) + try visitor.visitSingularInt32Field(value: _storage._lessThan, fieldNumber: 606) } if _storage._let != 0 { - try visitor.visitSingularInt32Field(value: _storage._let, fieldNumber: 495) + try visitor.visitSingularInt32Field(value: _storage._let, fieldNumber: 607) } if _storage._lhs != 0 { - try visitor.visitSingularInt32Field(value: _storage._lhs, fieldNumber: 496) + try visitor.visitSingularInt32Field(value: _storage._lhs, fieldNumber: 608) + } + if _storage._line != 0 { + try visitor.visitSingularInt32Field(value: _storage._line, fieldNumber: 609) } if _storage._list != 0 { - try visitor.visitSingularInt32Field(value: _storage._list, fieldNumber: 497) + try visitor.visitSingularInt32Field(value: _storage._list, fieldNumber: 610) } if _storage._listOfMessages != 0 { - try visitor.visitSingularInt32Field(value: _storage._listOfMessages, fieldNumber: 498) + try visitor.visitSingularInt32Field(value: _storage._listOfMessages, fieldNumber: 611) } if _storage._listValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._listValue, fieldNumber: 499) + try visitor.visitSingularInt32Field(value: _storage._listValue, fieldNumber: 612) } if _storage._littleEndian != 0 { - try visitor.visitSingularInt32Field(value: _storage._littleEndian, fieldNumber: 500) - } - if _storage._littleEndianBytes != 0 { - try visitor.visitSingularInt32Field(value: _storage._littleEndianBytes, fieldNumber: 501) + try visitor.visitSingularInt32Field(value: _storage._littleEndian, fieldNumber: 613) } if _storage._load != 0 { - try visitor.visitSingularInt32Field(value: _storage._load, fieldNumber: 502) + try visitor.visitSingularInt32Field(value: _storage._load, fieldNumber: 614) } if _storage._localHasher != 0 { - try visitor.visitSingularInt32Field(value: _storage._localHasher, fieldNumber: 503) + try visitor.visitSingularInt32Field(value: _storage._localHasher, fieldNumber: 615) } if _storage._location != 0 { - try visitor.visitSingularInt32Field(value: _storage._location, fieldNumber: 504) + try visitor.visitSingularInt32Field(value: _storage._location, fieldNumber: 616) } if _storage._m != 0 { - try visitor.visitSingularInt32Field(value: _storage._m, fieldNumber: 505) + try visitor.visitSingularInt32Field(value: _storage._m, fieldNumber: 617) } if _storage._major != 0 { - try visitor.visitSingularInt32Field(value: _storage._major, fieldNumber: 506) + try visitor.visitSingularInt32Field(value: _storage._major, fieldNumber: 618) + } + if _storage._makeAsyncIterator != 0 { + try visitor.visitSingularInt32Field(value: _storage._makeAsyncIterator, fieldNumber: 619) } if _storage._makeIterator != 0 { - try visitor.visitSingularInt32Field(value: _storage._makeIterator, fieldNumber: 507) + try visitor.visitSingularInt32Field(value: _storage._makeIterator, fieldNumber: 620) } - if _storage._mapEntry != 0 { - try visitor.visitSingularInt32Field(value: _storage._mapEntry, fieldNumber: 508) + if _storage._malformedLength != 0 { + try visitor.visitSingularInt32Field(value: _storage._malformedLength, fieldNumber: 621) } - if _storage._mapHash != 0 { - try visitor.visitSingularInt32Field(value: _storage._mapHash, fieldNumber: 509) + if _storage._mapEntry != 0 { + try visitor.visitSingularInt32Field(value: _storage._mapEntry, fieldNumber: 622) } if _storage._mapKeyType != 0 { - try visitor.visitSingularInt32Field(value: _storage._mapKeyType, fieldNumber: 510) - } - if _storage._mapNameResolver != 0 { - try visitor.visitSingularInt32Field(value: _storage._mapNameResolver, fieldNumber: 511) + try visitor.visitSingularInt32Field(value: _storage._mapKeyType, fieldNumber: 623) } if _storage._mapToMessages != 0 { - try visitor.visitSingularInt32Field(value: _storage._mapToMessages, fieldNumber: 512) + try visitor.visitSingularInt32Field(value: _storage._mapToMessages, fieldNumber: 624) } if _storage._mapValueType != 0 { - try visitor.visitSingularInt32Field(value: _storage._mapValueType, fieldNumber: 513) + try visitor.visitSingularInt32Field(value: _storage._mapValueType, fieldNumber: 625) } if _storage._mapVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._mapVisitor, fieldNumber: 514) + try visitor.visitSingularInt32Field(value: _storage._mapVisitor, fieldNumber: 626) + } + if _storage._mask != 0 { + try visitor.visitSingularInt32Field(value: _storage._mask, fieldNumber: 627) + } + if _storage._maximumEdition != 0 { + try visitor.visitSingularInt32Field(value: _storage._maximumEdition, fieldNumber: 628) } if _storage._mdayStart != 0 { - try visitor.visitSingularInt32Field(value: _storage._mdayStart, fieldNumber: 515) + try visitor.visitSingularInt32Field(value: _storage._mdayStart, fieldNumber: 629) } if _storage._merge != 0 { - try visitor.visitSingularInt32Field(value: _storage._merge, fieldNumber: 516) + try visitor.visitSingularInt32Field(value: _storage._merge, fieldNumber: 630) + } + if _storage._mergeOptions != 0 { + try visitor.visitSingularInt32Field(value: _storage._mergeOptions, fieldNumber: 631) } if _storage._message != 0 { - try visitor.visitSingularInt32Field(value: _storage._message, fieldNumber: 517) + try visitor.visitSingularInt32Field(value: _storage._message, fieldNumber: 632) } if _storage._messageDepthLimit != 0 { - try visitor.visitSingularInt32Field(value: _storage._messageDepthLimit, fieldNumber: 518) + try visitor.visitSingularInt32Field(value: _storage._messageDepthLimit, fieldNumber: 633) + } + if _storage._messageEncoding != 0 { + try visitor.visitSingularInt32Field(value: _storage._messageEncoding, fieldNumber: 634) } if _storage._messageExtension != 0 { - try visitor.visitSingularInt32Field(value: _storage._messageExtension, fieldNumber: 519) + try visitor.visitSingularInt32Field(value: _storage._messageExtension, fieldNumber: 635) } if _storage._messageImplementationBase != 0 { - try visitor.visitSingularInt32Field(value: _storage._messageImplementationBase, fieldNumber: 520) - } - if _storage._messageOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._messageOptions, fieldNumber: 521) + try visitor.visitSingularInt32Field(value: _storage._messageImplementationBase, fieldNumber: 636) } if _storage._messageSet != 0 { - try visitor.visitSingularInt32Field(value: _storage._messageSet, fieldNumber: 522) + try visitor.visitSingularInt32Field(value: _storage._messageSet, fieldNumber: 637) } if _storage._messageSetWireFormat != 0 { - try visitor.visitSingularInt32Field(value: _storage._messageSetWireFormat, fieldNumber: 523) + try visitor.visitSingularInt32Field(value: _storage._messageSetWireFormat, fieldNumber: 638) + } + if _storage._messageSize != 0 { + try visitor.visitSingularInt32Field(value: _storage._messageSize, fieldNumber: 639) } if _storage._messageType != 0 { - try visitor.visitSingularInt32Field(value: _storage._messageType, fieldNumber: 524) + try visitor.visitSingularInt32Field(value: _storage._messageType, fieldNumber: 640) } if _storage._method != 0 { - try visitor.visitSingularInt32Field(value: _storage._method, fieldNumber: 525) + try visitor.visitSingularInt32Field(value: _storage._method, fieldNumber: 641) } - if _storage._methodDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._methodDescriptorProto, fieldNumber: 526) + if _storage._methods != 0 { + try visitor.visitSingularInt32Field(value: _storage._methods, fieldNumber: 642) } - if _storage._methodOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._methodOptions, fieldNumber: 527) + if _storage._min != 0 { + try visitor.visitSingularInt32Field(value: _storage._min, fieldNumber: 643) } - if _storage._methods != 0 { - try visitor.visitSingularInt32Field(value: _storage._methods, fieldNumber: 528) + if _storage._minimumEdition != 0 { + try visitor.visitSingularInt32Field(value: _storage._minimumEdition, fieldNumber: 644) } if _storage._minor != 0 { - try visitor.visitSingularInt32Field(value: _storage._minor, fieldNumber: 529) - } - if _storage._mixin != 0 { - try visitor.visitSingularInt32Field(value: _storage._mixin, fieldNumber: 530) + try visitor.visitSingularInt32Field(value: _storage._minor, fieldNumber: 645) } if _storage._mixins != 0 { - try visitor.visitSingularInt32Field(value: _storage._mixins, fieldNumber: 531) - } - if _storage._modifier != 0 { - try visitor.visitSingularInt32Field(value: _storage._modifier, fieldNumber: 532) + try visitor.visitSingularInt32Field(value: _storage._mixins, fieldNumber: 646) } if _storage._modify != 0 { - try visitor.visitSingularInt32Field(value: _storage._modify, fieldNumber: 533) + try visitor.visitSingularInt32Field(value: _storage._modify, fieldNumber: 647) } if _storage._month != 0 { - try visitor.visitSingularInt32Field(value: _storage._month, fieldNumber: 534) + try visitor.visitSingularInt32Field(value: _storage._month, fieldNumber: 648) } if _storage._msgExtension != 0 { - try visitor.visitSingularInt32Field(value: _storage._msgExtension, fieldNumber: 535) + try visitor.visitSingularInt32Field(value: _storage._msgExtension, fieldNumber: 649) } if _storage._mutating != 0 { - try visitor.visitSingularInt32Field(value: _storage._mutating, fieldNumber: 536) + try visitor.visitSingularInt32Field(value: _storage._mutating, fieldNumber: 650) } if _storage._n != 0 { - try visitor.visitSingularInt32Field(value: _storage._n, fieldNumber: 537) + try visitor.visitSingularInt32Field(value: _storage._n, fieldNumber: 651) } if _storage._name != 0 { - try visitor.visitSingularInt32Field(value: _storage._name, fieldNumber: 538) + try visitor.visitSingularInt32Field(value: _storage._name, fieldNumber: 652) } if _storage._nameDescription != 0 { - try visitor.visitSingularInt32Field(value: _storage._nameDescription, fieldNumber: 539) + try visitor.visitSingularInt32Field(value: _storage._nameDescription, fieldNumber: 653) } if _storage._nameMap != 0 { - try visitor.visitSingularInt32Field(value: _storage._nameMap, fieldNumber: 540) + try visitor.visitSingularInt32Field(value: _storage._nameMap, fieldNumber: 654) } if _storage._namePart != 0 { - try visitor.visitSingularInt32Field(value: _storage._namePart, fieldNumber: 541) - } - if _storage._nameResolver != 0 { - try visitor.visitSingularInt32Field(value: _storage._nameResolver, fieldNumber: 542) + try visitor.visitSingularInt32Field(value: _storage._namePart, fieldNumber: 655) } if _storage._names != 0 { - try visitor.visitSingularInt32Field(value: _storage._names, fieldNumber: 543) + try visitor.visitSingularInt32Field(value: _storage._names, fieldNumber: 656) } if _storage._nanos != 0 { - try visitor.visitSingularInt32Field(value: _storage._nanos, fieldNumber: 544) - } - if _storage._nativeBytes != 0 { - try visitor.visitSingularInt32Field(value: _storage._nativeBytes, fieldNumber: 545) - } - if _storage._nativeEndianBytes != 0 { - try visitor.visitSingularInt32Field(value: _storage._nativeEndianBytes, fieldNumber: 546) + try visitor.visitSingularInt32Field(value: _storage._nanos, fieldNumber: 657) } if _storage._negativeIntValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._negativeIntValue, fieldNumber: 547) + try visitor.visitSingularInt32Field(value: _storage._negativeIntValue, fieldNumber: 658) } if _storage._nestedType != 0 { - try visitor.visitSingularInt32Field(value: _storage._nestedType, fieldNumber: 548) + try visitor.visitSingularInt32Field(value: _storage._nestedType, fieldNumber: 659) + } + if _storage._newExtensible != 0 { + try visitor.visitSingularInt32Field(value: _storage._newExtensible, fieldNumber: 660) } if _storage._newL != 0 { - try visitor.visitSingularInt32Field(value: _storage._newL, fieldNumber: 549) + try visitor.visitSingularInt32Field(value: _storage._newL, fieldNumber: 661) } if _storage._newList != 0 { - try visitor.visitSingularInt32Field(value: _storage._newList, fieldNumber: 550) + try visitor.visitSingularInt32Field(value: _storage._newList, fieldNumber: 662) + } + if _storage._newMessage != 0 { + try visitor.visitSingularInt32Field(value: _storage._newMessage, fieldNumber: 663) } if _storage._newValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._newValue, fieldNumber: 551) + try visitor.visitSingularInt32Field(value: _storage._newValue, fieldNumber: 664) + } + if _storage._next != 0 { + try visitor.visitSingularInt32Field(value: _storage._next, fieldNumber: 665) } if _storage._nextByte != 0 { - try visitor.visitSingularInt32Field(value: _storage._nextByte, fieldNumber: 552) + try visitor.visitSingularInt32Field(value: _storage._nextByte, fieldNumber: 666) } if _storage._nextFieldNumber != 0 { - try visitor.visitSingularInt32Field(value: _storage._nextFieldNumber, fieldNumber: 553) + try visitor.visitSingularInt32Field(value: _storage._nextFieldNumber, fieldNumber: 667) + } + if _storage._nextInstruction != 0 { + try visitor.visitSingularInt32Field(value: _storage._nextInstruction, fieldNumber: 668) + } + if _storage._nextInt32 != 0 { + try visitor.visitSingularInt32Field(value: _storage._nextInt32, fieldNumber: 669) + } + if _storage._nextNullTerminatedString != 0 { + try visitor.visitSingularInt32Field(value: _storage._nextNullTerminatedString, fieldNumber: 670) + } + if _storage._nextNullTerminatedStringArray != 0 { + try visitor.visitSingularInt32Field(value: _storage._nextNullTerminatedStringArray, fieldNumber: 671) + } + if _storage._nextNumber != 0 { + try visitor.visitSingularInt32Field(value: _storage._nextNumber, fieldNumber: 672) + } + if _storage._nextUint64 != 0 { + try visitor.visitSingularInt32Field(value: _storage._nextUint64, fieldNumber: 673) + } + if _storage._nextVarInt != 0 { + try visitor.visitSingularInt32Field(value: _storage._nextVarInt, fieldNumber: 674) } if _storage._nil != 0 { - try visitor.visitSingularInt32Field(value: _storage._nil, fieldNumber: 554) + try visitor.visitSingularInt32Field(value: _storage._nil, fieldNumber: 675) } if _storage._nilLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._nilLiteral, fieldNumber: 555) + try visitor.visitSingularInt32Field(value: _storage._nilLiteral, fieldNumber: 676) + } + if _storage._noBytesAvailable != 0 { + try visitor.visitSingularInt32Field(value: _storage._noBytesAvailable, fieldNumber: 677) } if _storage._noStandardDescriptorAccessor != 0 { - try visitor.visitSingularInt32Field(value: _storage._noStandardDescriptorAccessor, fieldNumber: 556) + try visitor.visitSingularInt32Field(value: _storage._noStandardDescriptorAccessor, fieldNumber: 678) } if _storage._nullValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._nullValue, fieldNumber: 557) + try visitor.visitSingularInt32Field(value: _storage._nullValue, fieldNumber: 679) } if _storage._number != 0 { - try visitor.visitSingularInt32Field(value: _storage._number, fieldNumber: 558) + try visitor.visitSingularInt32Field(value: _storage._number, fieldNumber: 680) } if _storage._numberValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._numberValue, fieldNumber: 559) + try visitor.visitSingularInt32Field(value: _storage._numberValue, fieldNumber: 681) } if _storage._objcClassPrefix != 0 { - try visitor.visitSingularInt32Field(value: _storage._objcClassPrefix, fieldNumber: 560) + try visitor.visitSingularInt32Field(value: _storage._objcClassPrefix, fieldNumber: 682) } if _storage._of != 0 { - try visitor.visitSingularInt32Field(value: _storage._of, fieldNumber: 561) + try visitor.visitSingularInt32Field(value: _storage._of, fieldNumber: 683) } - if _storage._oneofDecl != 0 { - try visitor.visitSingularInt32Field(value: _storage._oneofDecl, fieldNumber: 562) + if _storage._oneOfKind != 0 { + try visitor.visitSingularInt32Field(value: _storage._oneOfKind, fieldNumber: 684) } - if _storage._oneofDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._oneofDescriptorProto, fieldNumber: 563) + if _storage._oneofDecl != 0 { + try visitor.visitSingularInt32Field(value: _storage._oneofDecl, fieldNumber: 685) } if _storage._oneofIndex != 0 { - try visitor.visitSingularInt32Field(value: _storage._oneofIndex, fieldNumber: 564) - } - if _storage._oneofOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._oneofOptions, fieldNumber: 565) + try visitor.visitSingularInt32Field(value: _storage._oneofIndex, fieldNumber: 686) } if _storage._oneofs != 0 { - try visitor.visitSingularInt32Field(value: _storage._oneofs, fieldNumber: 566) - } - if _storage._oneOfKind != 0 { - try visitor.visitSingularInt32Field(value: _storage._oneOfKind, fieldNumber: 567) + try visitor.visitSingularInt32Field(value: _storage._oneofs, fieldNumber: 687) } if _storage._optimizeFor != 0 { - try visitor.visitSingularInt32Field(value: _storage._optimizeFor, fieldNumber: 568) + try visitor.visitSingularInt32Field(value: _storage._optimizeFor, fieldNumber: 688) } if _storage._optimizeMode != 0 { - try visitor.visitSingularInt32Field(value: _storage._optimizeMode, fieldNumber: 569) - } - if _storage._option != 0 { - try visitor.visitSingularInt32Field(value: _storage._option, fieldNumber: 570) + try visitor.visitSingularInt32Field(value: _storage._optimizeMode, fieldNumber: 689) } if _storage._optionalEnumExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._optionalEnumExtensionField, fieldNumber: 571) + try visitor.visitSingularInt32Field(value: _storage._optionalEnumExtensionField, fieldNumber: 690) } if _storage._optionalExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._optionalExtensionField, fieldNumber: 572) + try visitor.visitSingularInt32Field(value: _storage._optionalExtensionField, fieldNumber: 691) } if _storage._optionalGroupExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._optionalGroupExtensionField, fieldNumber: 573) + try visitor.visitSingularInt32Field(value: _storage._optionalGroupExtensionField, fieldNumber: 692) } if _storage._optionalMessageExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._optionalMessageExtensionField, fieldNumber: 574) + try visitor.visitSingularInt32Field(value: _storage._optionalMessageExtensionField, fieldNumber: 693) + } + if _storage._optionDependency != 0 { + try visitor.visitSingularInt32Field(value: _storage._optionDependency, fieldNumber: 694) + } + if _storage._optionRetention != 0 { + try visitor.visitSingularInt32Field(value: _storage._optionRetention, fieldNumber: 695) } if _storage._options != 0 { - try visitor.visitSingularInt32Field(value: _storage._options, fieldNumber: 575) + try visitor.visitSingularInt32Field(value: _storage._options, fieldNumber: 696) + } + if _storage._optionTargetType != 0 { + try visitor.visitSingularInt32Field(value: _storage._optionTargetType, fieldNumber: 697) } if _storage._other != 0 { - try visitor.visitSingularInt32Field(value: _storage._other, fieldNumber: 576) + try visitor.visitSingularInt32Field(value: _storage._other, fieldNumber: 698) } if _storage._others != 0 { - try visitor.visitSingularInt32Field(value: _storage._others, fieldNumber: 577) + try visitor.visitSingularInt32Field(value: _storage._others, fieldNumber: 699) } if _storage._out != 0 { - try visitor.visitSingularInt32Field(value: _storage._out, fieldNumber: 578) + try visitor.visitSingularInt32Field(value: _storage._out, fieldNumber: 700) } if _storage._outputType != 0 { - try visitor.visitSingularInt32Field(value: _storage._outputType, fieldNumber: 579) + try visitor.visitSingularInt32Field(value: _storage._outputType, fieldNumber: 701) + } + if _storage._overridableFeatures != 0 { + try visitor.visitSingularInt32Field(value: _storage._overridableFeatures, fieldNumber: 702) } if _storage._p != 0 { - try visitor.visitSingularInt32Field(value: _storage._p, fieldNumber: 580) + try visitor.visitSingularInt32Field(value: _storage._p, fieldNumber: 703) } if _storage._package != 0 { - try visitor.visitSingularInt32Field(value: _storage._package, fieldNumber: 581) + try visitor.visitSingularInt32Field(value: _storage._package, fieldNumber: 704) } if _storage._packed != 0 { - try visitor.visitSingularInt32Field(value: _storage._packed, fieldNumber: 582) + try visitor.visitSingularInt32Field(value: _storage._packed, fieldNumber: 705) } if _storage._packedEnumExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._packedEnumExtensionField, fieldNumber: 583) + try visitor.visitSingularInt32Field(value: _storage._packedEnumExtensionField, fieldNumber: 706) } if _storage._packedExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._packedExtensionField, fieldNumber: 584) + try visitor.visitSingularInt32Field(value: _storage._packedExtensionField, fieldNumber: 707) } if _storage._padding != 0 { - try visitor.visitSingularInt32Field(value: _storage._padding, fieldNumber: 585) + try visitor.visitSingularInt32Field(value: _storage._padding, fieldNumber: 708) } if _storage._parent != 0 { - try visitor.visitSingularInt32Field(value: _storage._parent, fieldNumber: 586) + try visitor.visitSingularInt32Field(value: _storage._parent, fieldNumber: 709) } if _storage._parse != 0 { - try visitor.visitSingularInt32Field(value: _storage._parse, fieldNumber: 587) + try visitor.visitSingularInt32Field(value: _storage._parse, fieldNumber: 710) } if _storage._partial != 0 { - try visitor.visitSingularInt32Field(value: _storage._partial, fieldNumber: 588) + try visitor.visitSingularInt32Field(value: _storage._partial, fieldNumber: 711) } if _storage._path != 0 { - try visitor.visitSingularInt32Field(value: _storage._path, fieldNumber: 589) + try visitor.visitSingularInt32Field(value: _storage._path, fieldNumber: 712) + } + if _storage._pathDecoder != 0 { + try visitor.visitSingularInt32Field(value: _storage._pathDecoder, fieldNumber: 713) + } + if _storage._pathDecodingError != 0 { + try visitor.visitSingularInt32Field(value: _storage._pathDecodingError, fieldNumber: 714) } if _storage._paths != 0 { - try visitor.visitSingularInt32Field(value: _storage._paths, fieldNumber: 590) + try visitor.visitSingularInt32Field(value: _storage._paths, fieldNumber: 715) + } + if _storage._pathVisitor != 0 { + try visitor.visitSingularInt32Field(value: _storage._pathVisitor, fieldNumber: 716) } if _storage._payload != 0 { - try visitor.visitSingularInt32Field(value: _storage._payload, fieldNumber: 591) + try visitor.visitSingularInt32Field(value: _storage._payload, fieldNumber: 717) } if _storage._payloadSize != 0 { - try visitor.visitSingularInt32Field(value: _storage._payloadSize, fieldNumber: 592) + try visitor.visitSingularInt32Field(value: _storage._payloadSize, fieldNumber: 718) } if _storage._phpClassPrefix != 0 { - try visitor.visitSingularInt32Field(value: _storage._phpClassPrefix, fieldNumber: 593) - } - if _storage._phpGenericServices != 0 { - try visitor.visitSingularInt32Field(value: _storage._phpGenericServices, fieldNumber: 594) + try visitor.visitSingularInt32Field(value: _storage._phpClassPrefix, fieldNumber: 719) } if _storage._phpMetadataNamespace != 0 { - try visitor.visitSingularInt32Field(value: _storage._phpMetadataNamespace, fieldNumber: 595) + try visitor.visitSingularInt32Field(value: _storage._phpMetadataNamespace, fieldNumber: 720) } if _storage._phpNamespace != 0 { - try visitor.visitSingularInt32Field(value: _storage._phpNamespace, fieldNumber: 596) - } - if _storage._pointer != 0 { - try visitor.visitSingularInt32Field(value: _storage._pointer, fieldNumber: 597) + try visitor.visitSingularInt32Field(value: _storage._phpNamespace, fieldNumber: 721) } if _storage._pos != 0 { - try visitor.visitSingularInt32Field(value: _storage._pos, fieldNumber: 598) + try visitor.visitSingularInt32Field(value: _storage._pos, fieldNumber: 722) } if _storage._positiveIntValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._positiveIntValue, fieldNumber: 599) + try visitor.visitSingularInt32Field(value: _storage._positiveIntValue, fieldNumber: 723) } if _storage._prefix != 0 { - try visitor.visitSingularInt32Field(value: _storage._prefix, fieldNumber: 600) + try visitor.visitSingularInt32Field(value: _storage._prefix, fieldNumber: 724) } if _storage._preserveProtoFieldNames != 0 { - try visitor.visitSingularInt32Field(value: _storage._preserveProtoFieldNames, fieldNumber: 601) + try visitor.visitSingularInt32Field(value: _storage._preserveProtoFieldNames, fieldNumber: 725) } if _storage._preTraverse != 0 { - try visitor.visitSingularInt32Field(value: _storage._preTraverse, fieldNumber: 602) + try visitor.visitSingularInt32Field(value: _storage._preTraverse, fieldNumber: 726) + } + if _storage._previousNumber != 0 { + try visitor.visitSingularInt32Field(value: _storage._previousNumber, fieldNumber: 727) + } + if _storage._prevPath != 0 { + try visitor.visitSingularInt32Field(value: _storage._prevPath, fieldNumber: 728) } if _storage._printUnknownFields != 0 { - try visitor.visitSingularInt32Field(value: _storage._printUnknownFields, fieldNumber: 603) + try visitor.visitSingularInt32Field(value: _storage._printUnknownFields, fieldNumber: 729) + } + if _storage._programBuffer != 0 { + try visitor.visitSingularInt32Field(value: _storage._programBuffer, fieldNumber: 730) + } + if _storage._programFormat != 0 { + try visitor.visitSingularInt32Field(value: _storage._programFormat, fieldNumber: 731) } if _storage._proto2 != 0 { - try visitor.visitSingularInt32Field(value: _storage._proto2, fieldNumber: 604) + try visitor.visitSingularInt32Field(value: _storage._proto2, fieldNumber: 732) } if _storage._proto3DefaultValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._proto3DefaultValue, fieldNumber: 605) + try visitor.visitSingularInt32Field(value: _storage._proto3DefaultValue, fieldNumber: 733) } if _storage._proto3Optional != 0 { - try visitor.visitSingularInt32Field(value: _storage._proto3Optional, fieldNumber: 606) + try visitor.visitSingularInt32Field(value: _storage._proto3Optional, fieldNumber: 734) } - if _storage._protobufApiversionCheck != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufApiversionCheck, fieldNumber: 607) + if _storage._protobufExtensionFieldValues != 0 { + try visitor.visitSingularInt32Field(value: _storage._protobufExtensionFieldValues, fieldNumber: 735) + } + if _storage._protobufFieldNumber != 0 { + try visitor.visitSingularInt32Field(value: _storage._protobufFieldNumber, fieldNumber: 736) + } + if _storage._protobufGeneratedIsEqualTo != 0 { + try visitor.visitSingularInt32Field(value: _storage._protobufGeneratedIsEqualTo, fieldNumber: 737) + } + if _storage._protobufNameMap != 0 { + try visitor.visitSingularInt32Field(value: _storage._protobufNameMap, fieldNumber: 738) + } + if _storage._protobufNewField != 0 { + try visitor.visitSingularInt32Field(value: _storage._protobufNewField, fieldNumber: 739) + } + if _storage._protobufPackage != 0 { + try visitor.visitSingularInt32Field(value: _storage._protobufPackage, fieldNumber: 740) } if _storage._protobufApiversion2 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufApiversion2, fieldNumber: 608) + try visitor.visitSingularInt32Field(value: _storage._protobufApiversion2, fieldNumber: 741) + } + if _storage._protobufApiversionCheck != 0 { + try visitor.visitSingularInt32Field(value: _storage._protobufApiversionCheck, fieldNumber: 742) } if _storage._protobufBool != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufBool, fieldNumber: 609) + try visitor.visitSingularInt32Field(value: _storage._protobufBool, fieldNumber: 743) } if _storage._protobufBytes != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufBytes, fieldNumber: 610) + try visitor.visitSingularInt32Field(value: _storage._protobufBytes, fieldNumber: 744) + } + if _storage._protobufData != 0 { + try visitor.visitSingularInt32Field(value: _storage._protobufData, fieldNumber: 745) } if _storage._protobufDouble != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufDouble, fieldNumber: 611) + try visitor.visitSingularInt32Field(value: _storage._protobufDouble, fieldNumber: 746) } if _storage._protobufEnumMap != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufEnumMap, fieldNumber: 612) + try visitor.visitSingularInt32Field(value: _storage._protobufEnumMap, fieldNumber: 747) } if _storage._protobufExtension != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufExtension, fieldNumber: 613) + try visitor.visitSingularInt32Field(value: _storage._protobufExtension, fieldNumber: 748) } if _storage._protobufFixed32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufFixed32, fieldNumber: 614) + try visitor.visitSingularInt32Field(value: _storage._protobufFixed32, fieldNumber: 749) } if _storage._protobufFixed64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufFixed64, fieldNumber: 615) + try visitor.visitSingularInt32Field(value: _storage._protobufFixed64, fieldNumber: 750) } if _storage._protobufFloat != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufFloat, fieldNumber: 616) + try visitor.visitSingularInt32Field(value: _storage._protobufFloat, fieldNumber: 751) } if _storage._protobufInt32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufInt32, fieldNumber: 617) + try visitor.visitSingularInt32Field(value: _storage._protobufInt32, fieldNumber: 752) } if _storage._protobufInt64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufInt64, fieldNumber: 618) + try visitor.visitSingularInt32Field(value: _storage._protobufInt64, fieldNumber: 753) } if _storage._protobufMap != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufMap, fieldNumber: 619) + try visitor.visitSingularInt32Field(value: _storage._protobufMap, fieldNumber: 754) } if _storage._protobufMessageMap != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufMessageMap, fieldNumber: 620) + try visitor.visitSingularInt32Field(value: _storage._protobufMessageMap, fieldNumber: 755) } if _storage._protobufSfixed32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufSfixed32, fieldNumber: 621) + try visitor.visitSingularInt32Field(value: _storage._protobufSfixed32, fieldNumber: 756) } if _storage._protobufSfixed64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufSfixed64, fieldNumber: 622) + try visitor.visitSingularInt32Field(value: _storage._protobufSfixed64, fieldNumber: 757) } if _storage._protobufSint32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufSint32, fieldNumber: 623) + try visitor.visitSingularInt32Field(value: _storage._protobufSint32, fieldNumber: 758) } if _storage._protobufSint64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufSint64, fieldNumber: 624) + try visitor.visitSingularInt32Field(value: _storage._protobufSint64, fieldNumber: 759) } if _storage._protobufString != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufString, fieldNumber: 625) + try visitor.visitSingularInt32Field(value: _storage._protobufString, fieldNumber: 760) } if _storage._protobufUint32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufUint32, fieldNumber: 626) + try visitor.visitSingularInt32Field(value: _storage._protobufUint32, fieldNumber: 761) } if _storage._protobufUint64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufUint64, fieldNumber: 627) - } - if _storage._protobufExtensionFieldValues != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufExtensionFieldValues, fieldNumber: 628) - } - if _storage._protobufFieldNumber != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufFieldNumber, fieldNumber: 629) - } - if _storage._protobufGeneratedIsEqualTo != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufGeneratedIsEqualTo, fieldNumber: 630) - } - if _storage._protobufNameMap != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufNameMap, fieldNumber: 631) - } - if _storage._protobufNewField != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufNewField, fieldNumber: 632) - } - if _storage._protobufPackage != 0 { - try visitor.visitSingularInt32Field(value: _storage._protobufPackage, fieldNumber: 633) + try visitor.visitSingularInt32Field(value: _storage._protobufUint64, fieldNumber: 762) } if _storage._protocol != 0 { - try visitor.visitSingularInt32Field(value: _storage._protocol, fieldNumber: 634) + try visitor.visitSingularInt32Field(value: _storage._protocol, fieldNumber: 763) } if _storage._protoFieldName != 0 { - try visitor.visitSingularInt32Field(value: _storage._protoFieldName, fieldNumber: 635) + try visitor.visitSingularInt32Field(value: _storage._protoFieldName, fieldNumber: 764) } if _storage._protoMessageName != 0 { - try visitor.visitSingularInt32Field(value: _storage._protoMessageName, fieldNumber: 636) + try visitor.visitSingularInt32Field(value: _storage._protoMessageName, fieldNumber: 765) } if _storage._protoNameProviding != 0 { - try visitor.visitSingularInt32Field(value: _storage._protoNameProviding, fieldNumber: 637) + try visitor.visitSingularInt32Field(value: _storage._protoNameProviding, fieldNumber: 766) } if _storage._protoPaths != 0 { - try visitor.visitSingularInt32Field(value: _storage._protoPaths, fieldNumber: 638) + try visitor.visitSingularInt32Field(value: _storage._protoPaths, fieldNumber: 767) } if _storage._public != 0 { - try visitor.visitSingularInt32Field(value: _storage._public, fieldNumber: 639) + try visitor.visitSingularInt32Field(value: _storage._public, fieldNumber: 768) } if _storage._publicDependency != 0 { - try visitor.visitSingularInt32Field(value: _storage._publicDependency, fieldNumber: 640) + try visitor.visitSingularInt32Field(value: _storage._publicDependency, fieldNumber: 769) } if _storage._putBoolValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._putBoolValue, fieldNumber: 641) + try visitor.visitSingularInt32Field(value: _storage._putBoolValue, fieldNumber: 770) } if _storage._putBytesValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._putBytesValue, fieldNumber: 642) + try visitor.visitSingularInt32Field(value: _storage._putBytesValue, fieldNumber: 771) } if _storage._putDoubleValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._putDoubleValue, fieldNumber: 643) + try visitor.visitSingularInt32Field(value: _storage._putDoubleValue, fieldNumber: 772) } if _storage._putEnumValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._putEnumValue, fieldNumber: 644) + try visitor.visitSingularInt32Field(value: _storage._putEnumValue, fieldNumber: 773) } if _storage._putFixedUint32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._putFixedUint32, fieldNumber: 645) + try visitor.visitSingularInt32Field(value: _storage._putFixedUint32, fieldNumber: 774) } if _storage._putFixedUint64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._putFixedUint64, fieldNumber: 646) + try visitor.visitSingularInt32Field(value: _storage._putFixedUint64, fieldNumber: 775) } if _storage._putFloatValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._putFloatValue, fieldNumber: 647) + try visitor.visitSingularInt32Field(value: _storage._putFloatValue, fieldNumber: 776) } if _storage._putInt64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._putInt64, fieldNumber: 648) + try visitor.visitSingularInt32Field(value: _storage._putInt64, fieldNumber: 777) } if _storage._putStringValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._putStringValue, fieldNumber: 649) + try visitor.visitSingularInt32Field(value: _storage._putStringValue, fieldNumber: 778) } if _storage._putUint64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._putUint64, fieldNumber: 650) + try visitor.visitSingularInt32Field(value: _storage._putUint64, fieldNumber: 779) } if _storage._putUint64Hex != 0 { - try visitor.visitSingularInt32Field(value: _storage._putUint64Hex, fieldNumber: 651) + try visitor.visitSingularInt32Field(value: _storage._putUint64Hex, fieldNumber: 780) } if _storage._putVarInt != 0 { - try visitor.visitSingularInt32Field(value: _storage._putVarInt, fieldNumber: 652) + try visitor.visitSingularInt32Field(value: _storage._putVarInt, fieldNumber: 781) } if _storage._putZigZagVarInt != 0 { - try visitor.visitSingularInt32Field(value: _storage._putZigZagVarInt, fieldNumber: 653) + try visitor.visitSingularInt32Field(value: _storage._putZigZagVarInt, fieldNumber: 782) } if _storage._pyGenericServices != 0 { - try visitor.visitSingularInt32Field(value: _storage._pyGenericServices, fieldNumber: 654) + try visitor.visitSingularInt32Field(value: _storage._pyGenericServices, fieldNumber: 783) + } + if _storage._r != 0 { + try visitor.visitSingularInt32Field(value: _storage._r, fieldNumber: 784) } if _storage._rawChars != 0 { - try visitor.visitSingularInt32Field(value: _storage._rawChars, fieldNumber: 655) + try visitor.visitSingularInt32Field(value: _storage._rawChars, fieldNumber: 785) } if _storage._rawRepresentable != 0 { - try visitor.visitSingularInt32Field(value: _storage._rawRepresentable, fieldNumber: 656) + try visitor.visitSingularInt32Field(value: _storage._rawRepresentable, fieldNumber: 786) } if _storage._rawValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._rawValue, fieldNumber: 657) + try visitor.visitSingularInt32Field(value: _storage._rawValue, fieldNumber: 787) } if _storage._read4HexDigits != 0 { - try visitor.visitSingularInt32Field(value: _storage._read4HexDigits, fieldNumber: 658) + try visitor.visitSingularInt32Field(value: _storage._read4HexDigits, fieldNumber: 788) + } + if _storage._readBytes != 0 { + try visitor.visitSingularInt32Field(value: _storage._readBytes, fieldNumber: 789) + } + if _storage._reader != 0 { + try visitor.visitSingularInt32Field(value: _storage._reader, fieldNumber: 790) } if _storage._register != 0 { - try visitor.visitSingularInt32Field(value: _storage._register, fieldNumber: 659) + try visitor.visitSingularInt32Field(value: _storage._register, fieldNumber: 791) + } + if _storage._remainingProgram != 0 { + try visitor.visitSingularInt32Field(value: _storage._remainingProgram, fieldNumber: 792) + } + if _storage._removalError != 0 { + try visitor.visitSingularInt32Field(value: _storage._removalError, fieldNumber: 793) + } + if _storage._removingAllFieldsOf != 0 { + try visitor.visitSingularInt32Field(value: _storage._removingAllFieldsOf, fieldNumber: 794) + } + if _storage._repeated != 0 { + try visitor.visitSingularInt32Field(value: _storage._repeated, fieldNumber: 795) } if _storage._repeatedEnumExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._repeatedEnumExtensionField, fieldNumber: 660) + try visitor.visitSingularInt32Field(value: _storage._repeatedEnumExtensionField, fieldNumber: 796) } if _storage._repeatedExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._repeatedExtensionField, fieldNumber: 661) + try visitor.visitSingularInt32Field(value: _storage._repeatedExtensionField, fieldNumber: 797) + } + if _storage._repeatedFieldEncoding != 0 { + try visitor.visitSingularInt32Field(value: _storage._repeatedFieldEncoding, fieldNumber: 798) } if _storage._repeatedGroupExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._repeatedGroupExtensionField, fieldNumber: 662) + try visitor.visitSingularInt32Field(value: _storage._repeatedGroupExtensionField, fieldNumber: 799) } if _storage._repeatedMessageExtensionField != 0 { - try visitor.visitSingularInt32Field(value: _storage._repeatedMessageExtensionField, fieldNumber: 663) + try visitor.visitSingularInt32Field(value: _storage._repeatedMessageExtensionField, fieldNumber: 800) + } + if _storage._repeating != 0 { + try visitor.visitSingularInt32Field(value: _storage._repeating, fieldNumber: 801) + } + if _storage._replaceRepeatedFields != 0 { + try visitor.visitSingularInt32Field(value: _storage._replaceRepeatedFields, fieldNumber: 802) } if _storage._requestStreaming != 0 { - try visitor.visitSingularInt32Field(value: _storage._requestStreaming, fieldNumber: 664) + try visitor.visitSingularInt32Field(value: _storage._requestStreaming, fieldNumber: 803) } if _storage._requestTypeURL != 0 { - try visitor.visitSingularInt32Field(value: _storage._requestTypeURL, fieldNumber: 665) + try visitor.visitSingularInt32Field(value: _storage._requestTypeURL, fieldNumber: 804) } if _storage._requiredSize != 0 { - try visitor.visitSingularInt32Field(value: _storage._requiredSize, fieldNumber: 666) - } - if _storage._reservedName != 0 { - try visitor.visitSingularInt32Field(value: _storage._reservedName, fieldNumber: 667) - } - if _storage._reservedRange != 0 { - try visitor.visitSingularInt32Field(value: _storage._reservedRange, fieldNumber: 668) + try visitor.visitSingularInt32Field(value: _storage._requiredSize, fieldNumber: 805) } if _storage._responseStreaming != 0 { - try visitor.visitSingularInt32Field(value: _storage._responseStreaming, fieldNumber: 669) + try visitor.visitSingularInt32Field(value: _storage._responseStreaming, fieldNumber: 806) } if _storage._responseTypeURL != 0 { - try visitor.visitSingularInt32Field(value: _storage._responseTypeURL, fieldNumber: 670) + try visitor.visitSingularInt32Field(value: _storage._responseTypeURL, fieldNumber: 807) } if _storage._result != 0 { - try visitor.visitSingularInt32Field(value: _storage._result, fieldNumber: 671) + try visitor.visitSingularInt32Field(value: _storage._result, fieldNumber: 808) } - if _storage._rethrows != 0 { - try visitor.visitSingularInt32Field(value: _storage._rethrows, fieldNumber: 672) + if _storage._retention != 0 { + try visitor.visitSingularInt32Field(value: _storage._retention, fieldNumber: 809) } - if _storage._return != 0 { - try visitor.visitSingularInt32Field(value: _storage._return, fieldNumber: 673) + if _storage._rethrows != 0 { + try visitor.visitSingularInt32Field(value: _storage._rethrows, fieldNumber: 810) } if _storage._returnType != 0 { - try visitor.visitSingularInt32Field(value: _storage._returnType, fieldNumber: 674) + try visitor.visitSingularInt32Field(value: _storage._returnType, fieldNumber: 811) } if _storage._revision != 0 { - try visitor.visitSingularInt32Field(value: _storage._revision, fieldNumber: 675) + try visitor.visitSingularInt32Field(value: _storage._revision, fieldNumber: 812) } if _storage._rhs != 0 { - try visitor.visitSingularInt32Field(value: _storage._rhs, fieldNumber: 676) + try visitor.visitSingularInt32Field(value: _storage._rhs, fieldNumber: 813) } if _storage._root != 0 { - try visitor.visitSingularInt32Field(value: _storage._root, fieldNumber: 677) + try visitor.visitSingularInt32Field(value: _storage._root, fieldNumber: 814) } if _storage._rubyPackage != 0 { - try visitor.visitSingularInt32Field(value: _storage._rubyPackage, fieldNumber: 678) + try visitor.visitSingularInt32Field(value: _storage._rubyPackage, fieldNumber: 815) } if _storage._s != 0 { - try visitor.visitSingularInt32Field(value: _storage._s, fieldNumber: 679) + try visitor.visitSingularInt32Field(value: _storage._s, fieldNumber: 816) } if _storage._sawBackslash != 0 { - try visitor.visitSingularInt32Field(value: _storage._sawBackslash, fieldNumber: 680) + try visitor.visitSingularInt32Field(value: _storage._sawBackslash, fieldNumber: 817) } if _storage._sawSection4Characters != 0 { - try visitor.visitSingularInt32Field(value: _storage._sawSection4Characters, fieldNumber: 681) + try visitor.visitSingularInt32Field(value: _storage._sawSection4Characters, fieldNumber: 818) } if _storage._sawSection5Characters != 0 { - try visitor.visitSingularInt32Field(value: _storage._sawSection5Characters, fieldNumber: 682) + try visitor.visitSingularInt32Field(value: _storage._sawSection5Characters, fieldNumber: 819) + } + if _storage._scalar != 0 { + try visitor.visitSingularInt32Field(value: _storage._scalar, fieldNumber: 820) + } + if _storage._scan != 0 { + try visitor.visitSingularInt32Field(value: _storage._scan, fieldNumber: 821) } if _storage._scanner != 0 { - try visitor.visitSingularInt32Field(value: _storage._scanner, fieldNumber: 683) + try visitor.visitSingularInt32Field(value: _storage._scanner, fieldNumber: 822) } if _storage._seconds != 0 { - try visitor.visitSingularInt32Field(value: _storage._seconds, fieldNumber: 684) + try visitor.visitSingularInt32Field(value: _storage._seconds, fieldNumber: 823) } if _storage._self_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._self_p, fieldNumber: 685) + try visitor.visitSingularInt32Field(value: _storage._self_p, fieldNumber: 824) + } + if _storage._semantic != 0 { + try visitor.visitSingularInt32Field(value: _storage._semantic, fieldNumber: 825) + } + if _storage._sendable != 0 { + try visitor.visitSingularInt32Field(value: _storage._sendable, fieldNumber: 826) } if _storage._separator != 0 { - try visitor.visitSingularInt32Field(value: _storage._separator, fieldNumber: 686) + try visitor.visitSingularInt32Field(value: _storage._separator, fieldNumber: 827) } if _storage._serialize != 0 { - try visitor.visitSingularInt32Field(value: _storage._serialize, fieldNumber: 687) + try visitor.visitSingularInt32Field(value: _storage._serialize, fieldNumber: 828) + } + if _storage._serializedBytes != 0 { + try visitor.visitSingularInt32Field(value: _storage._serializedBytes, fieldNumber: 829) } if _storage._serializedData != 0 { - try visitor.visitSingularInt32Field(value: _storage._serializedData, fieldNumber: 688) + try visitor.visitSingularInt32Field(value: _storage._serializedData, fieldNumber: 830) } if _storage._serializedSize != 0 { - try visitor.visitSingularInt32Field(value: _storage._serializedSize, fieldNumber: 689) + try visitor.visitSingularInt32Field(value: _storage._serializedSize, fieldNumber: 831) } if _storage._serverStreaming != 0 { - try visitor.visitSingularInt32Field(value: _storage._serverStreaming, fieldNumber: 690) + try visitor.visitSingularInt32Field(value: _storage._serverStreaming, fieldNumber: 832) } if _storage._service != 0 { - try visitor.visitSingularInt32Field(value: _storage._service, fieldNumber: 691) - } - if _storage._serviceDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: _storage._serviceDescriptorProto, fieldNumber: 692) - } - if _storage._serviceOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._serviceOptions, fieldNumber: 693) + try visitor.visitSingularInt32Field(value: _storage._service, fieldNumber: 833) } if _storage._set != 0 { - try visitor.visitSingularInt32Field(value: _storage._set, fieldNumber: 694) + try visitor.visitSingularInt32Field(value: _storage._set, fieldNumber: 834) } if _storage._setExtensionValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._setExtensionValue, fieldNumber: 695) + try visitor.visitSingularInt32Field(value: _storage._setExtensionValue, fieldNumber: 835) } if _storage._shift != 0 { - try visitor.visitSingularInt32Field(value: _storage._shift, fieldNumber: 696) + try visitor.visitSingularInt32Field(value: _storage._shift, fieldNumber: 836) } if _storage._simpleExtensionMap != 0 { - try visitor.visitSingularInt32Field(value: _storage._simpleExtensionMap, fieldNumber: 697) + try visitor.visitSingularInt32Field(value: _storage._simpleExtensionMap, fieldNumber: 837) + } + if _storage._size != 0 { + try visitor.visitSingularInt32Field(value: _storage._size, fieldNumber: 838) } if _storage._sizer != 0 { - try visitor.visitSingularInt32Field(value: _storage._sizer, fieldNumber: 698) + try visitor.visitSingularInt32Field(value: _storage._sizer, fieldNumber: 839) } if _storage._source != 0 { - try visitor.visitSingularInt32Field(value: _storage._source, fieldNumber: 699) + try visitor.visitSingularInt32Field(value: _storage._source, fieldNumber: 840) } if _storage._sourceCodeInfo != 0 { - try visitor.visitSingularInt32Field(value: _storage._sourceCodeInfo, fieldNumber: 700) + try visitor.visitSingularInt32Field(value: _storage._sourceCodeInfo, fieldNumber: 841) } if _storage._sourceContext != 0 { - try visitor.visitSingularInt32Field(value: _storage._sourceContext, fieldNumber: 701) + try visitor.visitSingularInt32Field(value: _storage._sourceContext, fieldNumber: 842) } if _storage._sourceEncoding != 0 { - try visitor.visitSingularInt32Field(value: _storage._sourceEncoding, fieldNumber: 702) + try visitor.visitSingularInt32Field(value: _storage._sourceEncoding, fieldNumber: 843) } if _storage._sourceFile != 0 { - try visitor.visitSingularInt32Field(value: _storage._sourceFile, fieldNumber: 703) + try visitor.visitSingularInt32Field(value: _storage._sourceFile, fieldNumber: 844) + } + if _storage._sourceLocation != 0 { + try visitor.visitSingularInt32Field(value: _storage._sourceLocation, fieldNumber: 845) } if _storage._span != 0 { - try visitor.visitSingularInt32Field(value: _storage._span, fieldNumber: 704) + try visitor.visitSingularInt32Field(value: _storage._span, fieldNumber: 846) } if _storage._split != 0 { - try visitor.visitSingularInt32Field(value: _storage._split, fieldNumber: 705) + try visitor.visitSingularInt32Field(value: _storage._split, fieldNumber: 847) } if _storage._start != 0 { - try visitor.visitSingularInt32Field(value: _storage._start, fieldNumber: 706) + try visitor.visitSingularInt32Field(value: _storage._start, fieldNumber: 848) } if _storage._startArray != 0 { - try visitor.visitSingularInt32Field(value: _storage._startArray, fieldNumber: 707) + try visitor.visitSingularInt32Field(value: _storage._startArray, fieldNumber: 849) } if _storage._startArrayObject != 0 { - try visitor.visitSingularInt32Field(value: _storage._startArrayObject, fieldNumber: 708) + try visitor.visitSingularInt32Field(value: _storage._startArrayObject, fieldNumber: 850) } if _storage._startField != 0 { - try visitor.visitSingularInt32Field(value: _storage._startField, fieldNumber: 709) + try visitor.visitSingularInt32Field(value: _storage._startField, fieldNumber: 851) } if _storage._startIndex != 0 { - try visitor.visitSingularInt32Field(value: _storage._startIndex, fieldNumber: 710) + try visitor.visitSingularInt32Field(value: _storage._startIndex, fieldNumber: 852) } if _storage._startMessageField != 0 { - try visitor.visitSingularInt32Field(value: _storage._startMessageField, fieldNumber: 711) + try visitor.visitSingularInt32Field(value: _storage._startMessageField, fieldNumber: 853) } if _storage._startObject != 0 { - try visitor.visitSingularInt32Field(value: _storage._startObject, fieldNumber: 712) + try visitor.visitSingularInt32Field(value: _storage._startObject, fieldNumber: 854) } if _storage._startRegularField != 0 { - try visitor.visitSingularInt32Field(value: _storage._startRegularField, fieldNumber: 713) + try visitor.visitSingularInt32Field(value: _storage._startRegularField, fieldNumber: 855) } if _storage._state != 0 { - try visitor.visitSingularInt32Field(value: _storage._state, fieldNumber: 714) + try visitor.visitSingularInt32Field(value: _storage._state, fieldNumber: 856) } if _storage._static != 0 { - try visitor.visitSingularInt32Field(value: _storage._static, fieldNumber: 715) + try visitor.visitSingularInt32Field(value: _storage._static, fieldNumber: 857) } if _storage._staticString != 0 { - try visitor.visitSingularInt32Field(value: _storage._staticString, fieldNumber: 716) + try visitor.visitSingularInt32Field(value: _storage._staticString, fieldNumber: 858) } if _storage._storage != 0 { - try visitor.visitSingularInt32Field(value: _storage._storage, fieldNumber: 717) + try visitor.visitSingularInt32Field(value: _storage._storage, fieldNumber: 859) } if _storage._string != 0 { - try visitor.visitSingularInt32Field(value: _storage._string, fieldNumber: 718) + try visitor.visitSingularInt32Field(value: _storage._string, fieldNumber: 860) } if _storage._stringLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._stringLiteral, fieldNumber: 719) + try visitor.visitSingularInt32Field(value: _storage._stringLiteral, fieldNumber: 861) } if _storage._stringLiteralType != 0 { - try visitor.visitSingularInt32Field(value: _storage._stringLiteralType, fieldNumber: 720) + try visitor.visitSingularInt32Field(value: _storage._stringLiteralType, fieldNumber: 862) } if _storage._stringResult != 0 { - try visitor.visitSingularInt32Field(value: _storage._stringResult, fieldNumber: 721) + try visitor.visitSingularInt32Field(value: _storage._stringResult, fieldNumber: 863) } if _storage._stringValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._stringValue, fieldNumber: 722) + try visitor.visitSingularInt32Field(value: _storage._stringValue, fieldNumber: 864) } if _storage._struct != 0 { - try visitor.visitSingularInt32Field(value: _storage._struct, fieldNumber: 723) + try visitor.visitSingularInt32Field(value: _storage._struct, fieldNumber: 865) } if _storage._structValue != 0 { - try visitor.visitSingularInt32Field(value: _storage._structValue, fieldNumber: 724) + try visitor.visitSingularInt32Field(value: _storage._structValue, fieldNumber: 866) } if _storage._subDecoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._subDecoder, fieldNumber: 725) + try visitor.visitSingularInt32Field(value: _storage._subDecoder, fieldNumber: 867) } if _storage._subscript != 0 { - try visitor.visitSingularInt32Field(value: _storage._subscript, fieldNumber: 726) + try visitor.visitSingularInt32Field(value: _storage._subscript, fieldNumber: 868) + } + if _storage._subtract != 0 { + try visitor.visitSingularInt32Field(value: _storage._subtract, fieldNumber: 869) } if _storage._subVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._subVisitor, fieldNumber: 727) + try visitor.visitSingularInt32Field(value: _storage._subVisitor, fieldNumber: 870) } if _storage._swift != 0 { - try visitor.visitSingularInt32Field(value: _storage._swift, fieldNumber: 728) + try visitor.visitSingularInt32Field(value: _storage._swift, fieldNumber: 871) } if _storage._swiftPrefix != 0 { - try visitor.visitSingularInt32Field(value: _storage._swiftPrefix, fieldNumber: 729) + try visitor.visitSingularInt32Field(value: _storage._swiftPrefix, fieldNumber: 872) + } + if _storage._swiftProtobufContiguousBytes != 0 { + try visitor.visitSingularInt32Field(value: _storage._swiftProtobufContiguousBytes, fieldNumber: 873) } - if _storage._swiftProtobuf != 0 { - try visitor.visitSingularInt32Field(value: _storage._swiftProtobuf, fieldNumber: 730) + if _storage._swiftProtobufError != 0 { + try visitor.visitSingularInt32Field(value: _storage._swiftProtobufError, fieldNumber: 874) } if _storage._syntax != 0 { - try visitor.visitSingularInt32Field(value: _storage._syntax, fieldNumber: 731) + try visitor.visitSingularInt32Field(value: _storage._syntax, fieldNumber: 875) } if _storage._t != 0 { - try visitor.visitSingularInt32Field(value: _storage._t, fieldNumber: 732) + try visitor.visitSingularInt32Field(value: _storage._t, fieldNumber: 876) } if _storage._tag != 0 { - try visitor.visitSingularInt32Field(value: _storage._tag, fieldNumber: 733) + try visitor.visitSingularInt32Field(value: _storage._tag, fieldNumber: 877) + } + if _storage._targets != 0 { + try visitor.visitSingularInt32Field(value: _storage._targets, fieldNumber: 878) } if _storage._terminator != 0 { - try visitor.visitSingularInt32Field(value: _storage._terminator, fieldNumber: 734) + try visitor.visitSingularInt32Field(value: _storage._terminator, fieldNumber: 879) } if _storage._testDecoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._testDecoder, fieldNumber: 735) + try visitor.visitSingularInt32Field(value: _storage._testDecoder, fieldNumber: 880) } if _storage._text != 0 { - try visitor.visitSingularInt32Field(value: _storage._text, fieldNumber: 736) + try visitor.visitSingularInt32Field(value: _storage._text, fieldNumber: 881) } if _storage._textDecoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._textDecoder, fieldNumber: 737) + try visitor.visitSingularInt32Field(value: _storage._textDecoder, fieldNumber: 882) } if _storage._textFormatDecoder != 0 { - try visitor.visitSingularInt32Field(value: _storage._textFormatDecoder, fieldNumber: 738) + try visitor.visitSingularInt32Field(value: _storage._textFormatDecoder, fieldNumber: 883) } if _storage._textFormatDecodingError != 0 { - try visitor.visitSingularInt32Field(value: _storage._textFormatDecodingError, fieldNumber: 739) + try visitor.visitSingularInt32Field(value: _storage._textFormatDecodingError, fieldNumber: 884) } if _storage._textFormatDecodingOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._textFormatDecodingOptions, fieldNumber: 740) + try visitor.visitSingularInt32Field(value: _storage._textFormatDecodingOptions, fieldNumber: 885) } if _storage._textFormatEncodingOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._textFormatEncodingOptions, fieldNumber: 741) + try visitor.visitSingularInt32Field(value: _storage._textFormatEncodingOptions, fieldNumber: 886) } if _storage._textFormatEncodingVisitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._textFormatEncodingVisitor, fieldNumber: 742) + try visitor.visitSingularInt32Field(value: _storage._textFormatEncodingVisitor, fieldNumber: 887) } if _storage._textFormatString != 0 { - try visitor.visitSingularInt32Field(value: _storage._textFormatString, fieldNumber: 743) + try visitor.visitSingularInt32Field(value: _storage._textFormatString, fieldNumber: 888) + } + if _storage._throwOrIgnore != 0 { + try visitor.visitSingularInt32Field(value: _storage._throwOrIgnore, fieldNumber: 889) } if _storage._throws != 0 { - try visitor.visitSingularInt32Field(value: _storage._throws, fieldNumber: 744) + try visitor.visitSingularInt32Field(value: _storage._throws, fieldNumber: 890) } if _storage._timeInterval != 0 { - try visitor.visitSingularInt32Field(value: _storage._timeInterval, fieldNumber: 745) + try visitor.visitSingularInt32Field(value: _storage._timeInterval, fieldNumber: 891) } if _storage._timeIntervalSince1970 != 0 { - try visitor.visitSingularInt32Field(value: _storage._timeIntervalSince1970, fieldNumber: 746) + try visitor.visitSingularInt32Field(value: _storage._timeIntervalSince1970, fieldNumber: 892) } if _storage._timeIntervalSinceReferenceDate != 0 { - try visitor.visitSingularInt32Field(value: _storage._timeIntervalSinceReferenceDate, fieldNumber: 747) + try visitor.visitSingularInt32Field(value: _storage._timeIntervalSinceReferenceDate, fieldNumber: 893) } - if _storage._timestamp != 0 { - try visitor.visitSingularInt32Field(value: _storage._timestamp, fieldNumber: 748) + if _storage._tmp != 0 { + try visitor.visitSingularInt32Field(value: _storage._tmp, fieldNumber: 894) + } + if _storage._tooLarge != 0 { + try visitor.visitSingularInt32Field(value: _storage._tooLarge, fieldNumber: 895) } if _storage._total != 0 { - try visitor.visitSingularInt32Field(value: _storage._total, fieldNumber: 749) + try visitor.visitSingularInt32Field(value: _storage._total, fieldNumber: 896) } if _storage._totalArrayDepth != 0 { - try visitor.visitSingularInt32Field(value: _storage._totalArrayDepth, fieldNumber: 750) + try visitor.visitSingularInt32Field(value: _storage._totalArrayDepth, fieldNumber: 897) } if _storage._totalSize != 0 { - try visitor.visitSingularInt32Field(value: _storage._totalSize, fieldNumber: 751) + try visitor.visitSingularInt32Field(value: _storage._totalSize, fieldNumber: 898) } if _storage._trailingComments != 0 { - try visitor.visitSingularInt32Field(value: _storage._trailingComments, fieldNumber: 752) + try visitor.visitSingularInt32Field(value: _storage._trailingComments, fieldNumber: 899) } if _storage._traverse != 0 { - try visitor.visitSingularInt32Field(value: _storage._traverse, fieldNumber: 753) + try visitor.visitSingularInt32Field(value: _storage._traverse, fieldNumber: 900) + } + if _storage._trim != 0 { + try visitor.visitSingularInt32Field(value: _storage._trim, fieldNumber: 901) } if _storage._true != 0 { - try visitor.visitSingularInt32Field(value: _storage._true, fieldNumber: 754) + try visitor.visitSingularInt32Field(value: _storage._true, fieldNumber: 902) } if _storage._try != 0 { - try visitor.visitSingularInt32Field(value: _storage._try, fieldNumber: 755) + try visitor.visitSingularInt32Field(value: _storage._try, fieldNumber: 903) } if _storage._type != 0 { - try visitor.visitSingularInt32Field(value: _storage._type, fieldNumber: 756) + try visitor.visitSingularInt32Field(value: _storage._type, fieldNumber: 904) } if _storage._typealias != 0 { - try visitor.visitSingularInt32Field(value: _storage._typealias, fieldNumber: 757) + try visitor.visitSingularInt32Field(value: _storage._typealias, fieldNumber: 905) } if _storage._typeEnum != 0 { - try visitor.visitSingularInt32Field(value: _storage._typeEnum, fieldNumber: 758) + try visitor.visitSingularInt32Field(value: _storage._typeEnum, fieldNumber: 906) } if _storage._typeName != 0 { - try visitor.visitSingularInt32Field(value: _storage._typeName, fieldNumber: 759) + try visitor.visitSingularInt32Field(value: _storage._typeName, fieldNumber: 907) } if _storage._typePrefix != 0 { - try visitor.visitSingularInt32Field(value: _storage._typePrefix, fieldNumber: 760) + try visitor.visitSingularInt32Field(value: _storage._typePrefix, fieldNumber: 908) } if _storage._typeStart != 0 { - try visitor.visitSingularInt32Field(value: _storage._typeStart, fieldNumber: 761) + try visitor.visitSingularInt32Field(value: _storage._typeStart, fieldNumber: 909) } if _storage._typeUnknown != 0 { - try visitor.visitSingularInt32Field(value: _storage._typeUnknown, fieldNumber: 762) + try visitor.visitSingularInt32Field(value: _storage._typeUnknown, fieldNumber: 910) } if _storage._typeURL != 0 { - try visitor.visitSingularInt32Field(value: _storage._typeURL, fieldNumber: 763) + try visitor.visitSingularInt32Field(value: _storage._typeURL, fieldNumber: 911) } if _storage._uint32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._uint32, fieldNumber: 764) - } - if _storage._uint32Value != 0 { - try visitor.visitSingularInt32Field(value: _storage._uint32Value, fieldNumber: 765) + try visitor.visitSingularInt32Field(value: _storage._uint32, fieldNumber: 912) } if _storage._uint64 != 0 { - try visitor.visitSingularInt32Field(value: _storage._uint64, fieldNumber: 766) - } - if _storage._uint64Value != 0 { - try visitor.visitSingularInt32Field(value: _storage._uint64Value, fieldNumber: 767) + try visitor.visitSingularInt32Field(value: _storage._uint64, fieldNumber: 913) } if _storage._uint8 != 0 { - try visitor.visitSingularInt32Field(value: _storage._uint8, fieldNumber: 768) + try visitor.visitSingularInt32Field(value: _storage._uint8, fieldNumber: 914) + } + if _storage._unchecked != 0 { + try visitor.visitSingularInt32Field(value: _storage._unchecked, fieldNumber: 915) + } + if _storage._unicode != 0 { + try visitor.visitSingularInt32Field(value: _storage._unicode, fieldNumber: 916) } if _storage._unicodeScalarLiteral != 0 { - try visitor.visitSingularInt32Field(value: _storage._unicodeScalarLiteral, fieldNumber: 769) + try visitor.visitSingularInt32Field(value: _storage._unicodeScalarLiteral, fieldNumber: 917) } if _storage._unicodeScalarLiteralType != 0 { - try visitor.visitSingularInt32Field(value: _storage._unicodeScalarLiteralType, fieldNumber: 770) + try visitor.visitSingularInt32Field(value: _storage._unicodeScalarLiteralType, fieldNumber: 918) } if _storage._unicodeScalars != 0 { - try visitor.visitSingularInt32Field(value: _storage._unicodeScalars, fieldNumber: 771) + try visitor.visitSingularInt32Field(value: _storage._unicodeScalars, fieldNumber: 919) } if _storage._unicodeScalarView != 0 { - try visitor.visitSingularInt32Field(value: _storage._unicodeScalarView, fieldNumber: 772) + try visitor.visitSingularInt32Field(value: _storage._unicodeScalarView, fieldNumber: 920) } if _storage._uninterpretedOption != 0 { - try visitor.visitSingularInt32Field(value: _storage._uninterpretedOption, fieldNumber: 773) + try visitor.visitSingularInt32Field(value: _storage._uninterpretedOption, fieldNumber: 921) } if _storage._union != 0 { - try visitor.visitSingularInt32Field(value: _storage._union, fieldNumber: 774) + try visitor.visitSingularInt32Field(value: _storage._union, fieldNumber: 922) } if _storage._uniqueStorage != 0 { - try visitor.visitSingularInt32Field(value: _storage._uniqueStorage, fieldNumber: 775) + try visitor.visitSingularInt32Field(value: _storage._uniqueStorage, fieldNumber: 923) } if _storage._unknown != 0 { - try visitor.visitSingularInt32Field(value: _storage._unknown, fieldNumber: 776) + try visitor.visitSingularInt32Field(value: _storage._unknown, fieldNumber: 924) } if _storage._unknownFields_p != 0 { - try visitor.visitSingularInt32Field(value: _storage._unknownFields_p, fieldNumber: 777) + try visitor.visitSingularInt32Field(value: _storage._unknownFields_p, fieldNumber: 925) } if _storage._unknownStorage != 0 { - try visitor.visitSingularInt32Field(value: _storage._unknownStorage, fieldNumber: 778) + try visitor.visitSingularInt32Field(value: _storage._unknownStorage, fieldNumber: 926) } if _storage._unpackTo != 0 { - try visitor.visitSingularInt32Field(value: _storage._unpackTo, fieldNumber: 779) + try visitor.visitSingularInt32Field(value: _storage._unpackTo, fieldNumber: 927) } if _storage._unsafeBufferPointer != 0 { - try visitor.visitSingularInt32Field(value: _storage._unsafeBufferPointer, fieldNumber: 780) + try visitor.visitSingularInt32Field(value: _storage._unsafeBufferPointer, fieldNumber: 928) } if _storage._unsafeMutablePointer != 0 { - try visitor.visitSingularInt32Field(value: _storage._unsafeMutablePointer, fieldNumber: 781) + try visitor.visitSingularInt32Field(value: _storage._unsafeMutablePointer, fieldNumber: 929) } if _storage._unsafeMutableRawBufferPointer != 0 { - try visitor.visitSingularInt32Field(value: _storage._unsafeMutableRawBufferPointer, fieldNumber: 782) - } - if _storage._unsafeMutableRawPointer != 0 { - try visitor.visitSingularInt32Field(value: _storage._unsafeMutableRawPointer, fieldNumber: 783) + try visitor.visitSingularInt32Field(value: _storage._unsafeMutableRawBufferPointer, fieldNumber: 930) } if _storage._unsafeRawBufferPointer != 0 { - try visitor.visitSingularInt32Field(value: _storage._unsafeRawBufferPointer, fieldNumber: 784) + try visitor.visitSingularInt32Field(value: _storage._unsafeRawBufferPointer, fieldNumber: 931) } if _storage._unsafeRawPointer != 0 { - try visitor.visitSingularInt32Field(value: _storage._unsafeRawPointer, fieldNumber: 785) + try visitor.visitSingularInt32Field(value: _storage._unsafeRawPointer, fieldNumber: 932) + } + if _storage._unverifiedLazy != 0 { + try visitor.visitSingularInt32Field(value: _storage._unverifiedLazy, fieldNumber: 933) } if _storage._updatedOptions != 0 { - try visitor.visitSingularInt32Field(value: _storage._updatedOptions, fieldNumber: 786) + try visitor.visitSingularInt32Field(value: _storage._updatedOptions, fieldNumber: 934) + } + if _storage._uppercasedAssumingAscii != 0 { + try visitor.visitSingularInt32Field(value: _storage._uppercasedAssumingAscii, fieldNumber: 935) } if _storage._url != 0 { - try visitor.visitSingularInt32Field(value: _storage._url, fieldNumber: 787) + try visitor.visitSingularInt32Field(value: _storage._url, fieldNumber: 936) + } + if _storage._useDeterministicOrdering != 0 { + try visitor.visitSingularInt32Field(value: _storage._useDeterministicOrdering, fieldNumber: 937) } if _storage._utf8 != 0 { - try visitor.visitSingularInt32Field(value: _storage._utf8, fieldNumber: 788) + try visitor.visitSingularInt32Field(value: _storage._utf8, fieldNumber: 938) } if _storage._utf8Ptr != 0 { - try visitor.visitSingularInt32Field(value: _storage._utf8Ptr, fieldNumber: 789) + try visitor.visitSingularInt32Field(value: _storage._utf8Ptr, fieldNumber: 939) } if _storage._utf8ToDouble != 0 { - try visitor.visitSingularInt32Field(value: _storage._utf8ToDouble, fieldNumber: 790) + try visitor.visitSingularInt32Field(value: _storage._utf8ToDouble, fieldNumber: 940) + } + if _storage._utf8Validation != 0 { + try visitor.visitSingularInt32Field(value: _storage._utf8Validation, fieldNumber: 941) } if _storage._utf8View != 0 { - try visitor.visitSingularInt32Field(value: _storage._utf8View, fieldNumber: 791) + try visitor.visitSingularInt32Field(value: _storage._utf8View, fieldNumber: 942) } if _storage._v != 0 { - try visitor.visitSingularInt32Field(value: _storage._v, fieldNumber: 792) + try visitor.visitSingularInt32Field(value: _storage._v, fieldNumber: 943) } if _storage._value != 0 { - try visitor.visitSingularInt32Field(value: _storage._value, fieldNumber: 793) + try visitor.visitSingularInt32Field(value: _storage._value, fieldNumber: 944) } if _storage._valueField != 0 { - try visitor.visitSingularInt32Field(value: _storage._valueField, fieldNumber: 794) + try visitor.visitSingularInt32Field(value: _storage._valueField, fieldNumber: 945) } if _storage._values != 0 { - try visitor.visitSingularInt32Field(value: _storage._values, fieldNumber: 795) + try visitor.visitSingularInt32Field(value: _storage._values, fieldNumber: 946) } if _storage._valueType != 0 { - try visitor.visitSingularInt32Field(value: _storage._valueType, fieldNumber: 796) + try visitor.visitSingularInt32Field(value: _storage._valueType, fieldNumber: 947) } if _storage._var != 0 { - try visitor.visitSingularInt32Field(value: _storage._var, fieldNumber: 797) + try visitor.visitSingularInt32Field(value: _storage._var, fieldNumber: 948) + } + if _storage._verification != 0 { + try visitor.visitSingularInt32Field(value: _storage._verification, fieldNumber: 949) + } + if _storage._verificationState != 0 { + try visitor.visitSingularInt32Field(value: _storage._verificationState, fieldNumber: 950) } if _storage._version != 0 { - try visitor.visitSingularInt32Field(value: _storage._version, fieldNumber: 798) + try visitor.visitSingularInt32Field(value: _storage._version, fieldNumber: 951) } if _storage._versionString != 0 { - try visitor.visitSingularInt32Field(value: _storage._versionString, fieldNumber: 799) + try visitor.visitSingularInt32Field(value: _storage._versionString, fieldNumber: 952) + } + if _storage._visibility != 0 { + try visitor.visitSingularInt32Field(value: _storage._visibility, fieldNumber: 953) + } + if _storage._visibilityFeature != 0 { + try visitor.visitSingularInt32Field(value: _storage._visibilityFeature, fieldNumber: 954) } if _storage._visitExtensionFields != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitExtensionFields, fieldNumber: 800) + try visitor.visitSingularInt32Field(value: _storage._visitExtensionFields, fieldNumber: 955) } if _storage._visitExtensionFieldsAsMessageSet != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitExtensionFieldsAsMessageSet, fieldNumber: 801) + try visitor.visitSingularInt32Field(value: _storage._visitExtensionFieldsAsMessageSet, fieldNumber: 956) } if _storage._visitMapField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitMapField, fieldNumber: 802) + try visitor.visitSingularInt32Field(value: _storage._visitMapField, fieldNumber: 957) } if _storage._visitor != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitor, fieldNumber: 803) + try visitor.visitSingularInt32Field(value: _storage._visitor, fieldNumber: 958) } if _storage._visitPacked != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPacked, fieldNumber: 804) + try visitor.visitSingularInt32Field(value: _storage._visitPacked, fieldNumber: 959) } if _storage._visitPackedBoolField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedBoolField, fieldNumber: 805) + try visitor.visitSingularInt32Field(value: _storage._visitPackedBoolField, fieldNumber: 960) } if _storage._visitPackedDoubleField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedDoubleField, fieldNumber: 806) + try visitor.visitSingularInt32Field(value: _storage._visitPackedDoubleField, fieldNumber: 961) } if _storage._visitPackedEnumField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedEnumField, fieldNumber: 807) + try visitor.visitSingularInt32Field(value: _storage._visitPackedEnumField, fieldNumber: 962) } if _storage._visitPackedFixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedFixed32Field, fieldNumber: 808) + try visitor.visitSingularInt32Field(value: _storage._visitPackedFixed32Field, fieldNumber: 963) } if _storage._visitPackedFixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedFixed64Field, fieldNumber: 809) + try visitor.visitSingularInt32Field(value: _storage._visitPackedFixed64Field, fieldNumber: 964) } if _storage._visitPackedFloatField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedFloatField, fieldNumber: 810) + try visitor.visitSingularInt32Field(value: _storage._visitPackedFloatField, fieldNumber: 965) } if _storage._visitPackedInt32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedInt32Field, fieldNumber: 811) + try visitor.visitSingularInt32Field(value: _storage._visitPackedInt32Field, fieldNumber: 966) } if _storage._visitPackedInt64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedInt64Field, fieldNumber: 812) + try visitor.visitSingularInt32Field(value: _storage._visitPackedInt64Field, fieldNumber: 967) } if _storage._visitPackedSfixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedSfixed32Field, fieldNumber: 813) + try visitor.visitSingularInt32Field(value: _storage._visitPackedSfixed32Field, fieldNumber: 968) } if _storage._visitPackedSfixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedSfixed64Field, fieldNumber: 814) + try visitor.visitSingularInt32Field(value: _storage._visitPackedSfixed64Field, fieldNumber: 969) } if _storage._visitPackedSint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedSint32Field, fieldNumber: 815) + try visitor.visitSingularInt32Field(value: _storage._visitPackedSint32Field, fieldNumber: 970) } if _storage._visitPackedSint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedSint64Field, fieldNumber: 816) + try visitor.visitSingularInt32Field(value: _storage._visitPackedSint64Field, fieldNumber: 971) } if _storage._visitPackedUint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedUint32Field, fieldNumber: 817) + try visitor.visitSingularInt32Field(value: _storage._visitPackedUint32Field, fieldNumber: 972) } if _storage._visitPackedUint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitPackedUint64Field, fieldNumber: 818) + try visitor.visitSingularInt32Field(value: _storage._visitPackedUint64Field, fieldNumber: 973) } if _storage._visitRepeated != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeated, fieldNumber: 819) + try visitor.visitSingularInt32Field(value: _storage._visitRepeated, fieldNumber: 974) } if _storage._visitRepeatedBoolField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedBoolField, fieldNumber: 820) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedBoolField, fieldNumber: 975) } if _storage._visitRepeatedBytesField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedBytesField, fieldNumber: 821) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedBytesField, fieldNumber: 976) } if _storage._visitRepeatedDoubleField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedDoubleField, fieldNumber: 822) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedDoubleField, fieldNumber: 977) } if _storage._visitRepeatedEnumField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedEnumField, fieldNumber: 823) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedEnumField, fieldNumber: 978) } if _storage._visitRepeatedFixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedFixed32Field, fieldNumber: 824) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedFixed32Field, fieldNumber: 979) } if _storage._visitRepeatedFixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedFixed64Field, fieldNumber: 825) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedFixed64Field, fieldNumber: 980) } if _storage._visitRepeatedFloatField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedFloatField, fieldNumber: 826) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedFloatField, fieldNumber: 981) } if _storage._visitRepeatedGroupField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedGroupField, fieldNumber: 827) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedGroupField, fieldNumber: 982) } if _storage._visitRepeatedInt32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedInt32Field, fieldNumber: 828) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedInt32Field, fieldNumber: 983) } if _storage._visitRepeatedInt64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedInt64Field, fieldNumber: 829) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedInt64Field, fieldNumber: 984) } if _storage._visitRepeatedMessageField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedMessageField, fieldNumber: 830) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedMessageField, fieldNumber: 985) } if _storage._visitRepeatedSfixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSfixed32Field, fieldNumber: 831) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSfixed32Field, fieldNumber: 986) } if _storage._visitRepeatedSfixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSfixed64Field, fieldNumber: 832) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSfixed64Field, fieldNumber: 987) } if _storage._visitRepeatedSint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSint32Field, fieldNumber: 833) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSint32Field, fieldNumber: 988) } if _storage._visitRepeatedSint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSint64Field, fieldNumber: 834) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedSint64Field, fieldNumber: 989) } if _storage._visitRepeatedStringField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedStringField, fieldNumber: 835) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedStringField, fieldNumber: 990) } if _storage._visitRepeatedUint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedUint32Field, fieldNumber: 836) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedUint32Field, fieldNumber: 991) } if _storage._visitRepeatedUint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitRepeatedUint64Field, fieldNumber: 837) + try visitor.visitSingularInt32Field(value: _storage._visitRepeatedUint64Field, fieldNumber: 992) } if _storage._visitSingular != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingular, fieldNumber: 838) + try visitor.visitSingularInt32Field(value: _storage._visitSingular, fieldNumber: 993) } if _storage._visitSingularBoolField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularBoolField, fieldNumber: 839) + try visitor.visitSingularInt32Field(value: _storage._visitSingularBoolField, fieldNumber: 994) } if _storage._visitSingularBytesField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularBytesField, fieldNumber: 840) + try visitor.visitSingularInt32Field(value: _storage._visitSingularBytesField, fieldNumber: 995) } if _storage._visitSingularDoubleField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularDoubleField, fieldNumber: 841) + try visitor.visitSingularInt32Field(value: _storage._visitSingularDoubleField, fieldNumber: 996) } if _storage._visitSingularEnumField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularEnumField, fieldNumber: 842) + try visitor.visitSingularInt32Field(value: _storage._visitSingularEnumField, fieldNumber: 997) } if _storage._visitSingularFixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularFixed32Field, fieldNumber: 843) + try visitor.visitSingularInt32Field(value: _storage._visitSingularFixed32Field, fieldNumber: 998) } if _storage._visitSingularFixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularFixed64Field, fieldNumber: 844) + try visitor.visitSingularInt32Field(value: _storage._visitSingularFixed64Field, fieldNumber: 999) } if _storage._visitSingularFloatField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularFloatField, fieldNumber: 845) + try visitor.visitSingularInt32Field(value: _storage._visitSingularFloatField, fieldNumber: 1000) } if _storage._visitSingularGroupField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularGroupField, fieldNumber: 846) + try visitor.visitSingularInt32Field(value: _storage._visitSingularGroupField, fieldNumber: 1001) } if _storage._visitSingularInt32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularInt32Field, fieldNumber: 847) + try visitor.visitSingularInt32Field(value: _storage._visitSingularInt32Field, fieldNumber: 1002) } if _storage._visitSingularInt64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularInt64Field, fieldNumber: 848) + try visitor.visitSingularInt32Field(value: _storage._visitSingularInt64Field, fieldNumber: 1003) } if _storage._visitSingularMessageField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularMessageField, fieldNumber: 849) + try visitor.visitSingularInt32Field(value: _storage._visitSingularMessageField, fieldNumber: 1004) } if _storage._visitSingularSfixed32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularSfixed32Field, fieldNumber: 850) + try visitor.visitSingularInt32Field(value: _storage._visitSingularSfixed32Field, fieldNumber: 1005) } if _storage._visitSingularSfixed64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularSfixed64Field, fieldNumber: 851) + try visitor.visitSingularInt32Field(value: _storage._visitSingularSfixed64Field, fieldNumber: 1006) } if _storage._visitSingularSint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularSint32Field, fieldNumber: 852) + try visitor.visitSingularInt32Field(value: _storage._visitSingularSint32Field, fieldNumber: 1007) } if _storage._visitSingularSint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularSint64Field, fieldNumber: 853) + try visitor.visitSingularInt32Field(value: _storage._visitSingularSint64Field, fieldNumber: 1008) } if _storage._visitSingularStringField != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularStringField, fieldNumber: 854) + try visitor.visitSingularInt32Field(value: _storage._visitSingularStringField, fieldNumber: 1009) } if _storage._visitSingularUint32Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularUint32Field, fieldNumber: 855) + try visitor.visitSingularInt32Field(value: _storage._visitSingularUint32Field, fieldNumber: 1010) } if _storage._visitSingularUint64Field != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitSingularUint64Field, fieldNumber: 856) + try visitor.visitSingularInt32Field(value: _storage._visitSingularUint64Field, fieldNumber: 1011) } if _storage._visitUnknown != 0 { - try visitor.visitSingularInt32Field(value: _storage._visitUnknown, fieldNumber: 857) + try visitor.visitSingularInt32Field(value: _storage._visitUnknown, fieldNumber: 1012) + } + if _storage._void != 0 { + try visitor.visitSingularInt32Field(value: _storage._void, fieldNumber: 1013) } if _storage._wasDecoded != 0 { - try visitor.visitSingularInt32Field(value: _storage._wasDecoded, fieldNumber: 858) + try visitor.visitSingularInt32Field(value: _storage._wasDecoded, fieldNumber: 1014) } if _storage._weak != 0 { - try visitor.visitSingularInt32Field(value: _storage._weak, fieldNumber: 859) + try visitor.visitSingularInt32Field(value: _storage._weak, fieldNumber: 1015) } if _storage._weakDependency != 0 { - try visitor.visitSingularInt32Field(value: _storage._weakDependency, fieldNumber: 860) + try visitor.visitSingularInt32Field(value: _storage._weakDependency, fieldNumber: 1016) } if _storage._where != 0 { - try visitor.visitSingularInt32Field(value: _storage._where, fieldNumber: 861) + try visitor.visitSingularInt32Field(value: _storage._where, fieldNumber: 1017) } if _storage._wireFormat != 0 { - try visitor.visitSingularInt32Field(value: _storage._wireFormat, fieldNumber: 862) + try visitor.visitSingularInt32Field(value: _storage._wireFormat, fieldNumber: 1018) } if _storage._with != 0 { - try visitor.visitSingularInt32Field(value: _storage._with, fieldNumber: 863) + try visitor.visitSingularInt32Field(value: _storage._with, fieldNumber: 1019) } if _storage._withUnsafeBytes != 0 { - try visitor.visitSingularInt32Field(value: _storage._withUnsafeBytes, fieldNumber: 864) + try visitor.visitSingularInt32Field(value: _storage._withUnsafeBytes, fieldNumber: 1020) } if _storage._withUnsafeMutableBytes != 0 { - try visitor.visitSingularInt32Field(value: _storage._withUnsafeMutableBytes, fieldNumber: 865) + try visitor.visitSingularInt32Field(value: _storage._withUnsafeMutableBytes, fieldNumber: 1021) } if _storage._work != 0 { - try visitor.visitSingularInt32Field(value: _storage._work, fieldNumber: 866) + try visitor.visitSingularInt32Field(value: _storage._work, fieldNumber: 1022) + } + if _storage._wrapped != 0 { + try visitor.visitSingularInt32Field(value: _storage._wrapped, fieldNumber: 1023) } if _storage._wrappedType != 0 { - try visitor.visitSingularInt32Field(value: _storage._wrappedType, fieldNumber: 867) + try visitor.visitSingularInt32Field(value: _storage._wrappedType, fieldNumber: 1024) + } + if _storage._wrappedValue != 0 { + try visitor.visitSingularInt32Field(value: _storage._wrappedValue, fieldNumber: 1025) } if _storage._written != 0 { - try visitor.visitSingularInt32Field(value: _storage._written, fieldNumber: 868) + try visitor.visitSingularInt32Field(value: _storage._written, fieldNumber: 1026) } if _storage._yday != 0 { - try visitor.visitSingularInt32Field(value: _storage._yday, fieldNumber: 869) + try visitor.visitSingularInt32Field(value: _storage._yday, fieldNumber: 1027) } } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedFields, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedFields) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedFields) -> 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._addPath != rhs_storage._addPath {return false} if _storage._adjusted != rhs_storage._adjusted {return false} if _storage._aggregateValue != rhs_storage._aggregateValue {return false} if _storage._allCases != rhs_storage._allCases {return false} if _storage._allowAlias != rhs_storage._allowAlias {return false} if _storage._alwaysPrintEnumsAsInts != rhs_storage._alwaysPrintEnumsAsInts {return false} + if _storage._alwaysPrintInt64SAsNumbers != rhs_storage._alwaysPrintInt64SAsNumbers {return false} if _storage._annotation != rhs_storage._annotation {return false} if _storage._any != rhs_storage._any {return false} if _storage._anyExtensionField != rhs_storage._anyExtensionField {return false} if _storage._anyMessageExtension != rhs_storage._anyMessageExtension {return false} if _storage._anyMessageStorage != rhs_storage._anyMessageStorage {return false} if _storage._anyUnpackError != rhs_storage._anyUnpackError {return false} - if _storage._api != rhs_storage._api {return false} + if _storage._append != rhs_storage._append {return false} if _storage._appended != rhs_storage._appended {return false} if _storage._appendUintHex != rhs_storage._appendUintHex {return false} if _storage._appendUnknown != rhs_storage._appendUnknown {return false} @@ -10542,14 +11412,20 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._as != rhs_storage._as {return false} if _storage._asciiOpenCurlyBracket != rhs_storage._asciiOpenCurlyBracket {return false} if _storage._asciiZero != rhs_storage._asciiZero {return false} + if _storage._async != rhs_storage._async {return false} + if _storage._asyncIterator != rhs_storage._asyncIterator {return false} + if _storage._asyncIteratorProtocol != rhs_storage._asyncIteratorProtocol {return false} + if _storage._asyncMessageSequence != rhs_storage._asyncMessageSequence {return false} if _storage._available != rhs_storage._available {return false} if _storage._b != rhs_storage._b {return false} + if _storage._base != rhs_storage._base {return false} if _storage._base64Values != rhs_storage._base64Values {return false} if _storage._baseAddress != rhs_storage._baseAddress {return false} if _storage._baseType != rhs_storage._baseType {return false} if _storage._begin != rhs_storage._begin {return false} if _storage._binary != rhs_storage._binary {return false} if _storage._binaryDecoder != rhs_storage._binaryDecoder {return false} + if _storage._binaryDecoding != rhs_storage._binaryDecoding {return false} if _storage._binaryDecodingError != rhs_storage._binaryDecodingError {return false} if _storage._binaryDecodingOptions != rhs_storage._binaryDecodingOptions {return false} if _storage._binaryDelimited != rhs_storage._binaryDelimited {return false} @@ -10557,25 +11433,39 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._binaryEncodingError != rhs_storage._binaryEncodingError {return false} if _storage._binaryEncodingMessageSetSizeVisitor != rhs_storage._binaryEncodingMessageSetSizeVisitor {return false} if _storage._binaryEncodingMessageSetVisitor != rhs_storage._binaryEncodingMessageSetVisitor {return false} + if _storage._binaryEncodingOptions != rhs_storage._binaryEncodingOptions {return false} if _storage._binaryEncodingSizeVisitor != rhs_storage._binaryEncodingSizeVisitor {return false} if _storage._binaryEncodingVisitor != rhs_storage._binaryEncodingVisitor {return false} if _storage._binaryOptions != rhs_storage._binaryOptions {return false} + if _storage._binaryProtobufDelimitedMessages != rhs_storage._binaryProtobufDelimitedMessages {return false} + if _storage._binaryStreamDecoding != rhs_storage._binaryStreamDecoding {return false} + if _storage._binaryStreamDecodingError != rhs_storage._binaryStreamDecodingError {return false} + if _storage._bitPattern != rhs_storage._bitPattern {return false} if _storage._body != rhs_storage._body {return false} if _storage._bool != rhs_storage._bool {return false} if _storage._booleanLiteral != rhs_storage._booleanLiteral {return false} if _storage._booleanLiteralType != rhs_storage._booleanLiteralType {return false} if _storage._boolValue != rhs_storage._boolValue {return false} + if _storage._buffer != rhs_storage._buffer {return false} + if _storage._byte != rhs_storage._byte {return false} + if _storage._bytecode != rhs_storage._bytecode {return false} + if _storage._bytecodeReader != rhs_storage._bytecodeReader {return false} if _storage._bytes != rhs_storage._bytes {return false} if _storage._bytesInGroup != rhs_storage._bytesInGroup {return false} + if _storage._bytesNeeded != rhs_storage._bytesNeeded {return false} if _storage._bytesRead != rhs_storage._bytesRead {return false} - if _storage._bytesValue != rhs_storage._bytesValue {return false} if _storage._c != rhs_storage._c {return false} + if _storage._canonical != rhs_storage._canonical {return false} if _storage._capitalizeNext != rhs_storage._capitalizeNext {return false} if _storage._cardinality != rhs_storage._cardinality {return false} + if _storage._caseIterable != rhs_storage._caseIterable {return false} + if _storage._castedValue != rhs_storage._castedValue {return false} if _storage._ccEnableArenas != rhs_storage._ccEnableArenas {return false} if _storage._ccGenericServices != rhs_storage._ccGenericServices {return false} if _storage._character != rhs_storage._character {return false} if _storage._chars != rhs_storage._chars {return false} + if _storage._checkProgramFormat != rhs_storage._checkProgramFormat {return false} + if _storage._chunk != rhs_storage._chunk {return false} if _storage._class != rhs_storage._class {return false} if _storage._clearAggregateValue_p != rhs_storage._clearAggregateValue_p {return false} if _storage._clearAllowAlias_p != rhs_storage._clearAllowAlias_p {return false} @@ -10585,12 +11475,27 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._clearClientStreaming_p != rhs_storage._clearClientStreaming_p {return false} if _storage._clearCsharpNamespace_p != rhs_storage._clearCsharpNamespace_p {return false} if _storage._clearCtype_p != rhs_storage._clearCtype_p {return false} + if _storage._clearDebugRedact_p != rhs_storage._clearDebugRedact_p {return false} + if _storage._clearDefaultSymbolVisibility_p != rhs_storage._clearDefaultSymbolVisibility_p {return false} if _storage._clearDefaultValue_p != rhs_storage._clearDefaultValue_p {return false} if _storage._clearDeprecated_p != rhs_storage._clearDeprecated_p {return false} + if _storage._clearDeprecatedLegacyJsonFieldConflicts_p != rhs_storage._clearDeprecatedLegacyJsonFieldConflicts_p {return false} + if _storage._clearDeprecationWarning_p != rhs_storage._clearDeprecationWarning_p {return false} if _storage._clearDoubleValue_p != rhs_storage._clearDoubleValue_p {return false} + if _storage._clearEdition_p != rhs_storage._clearEdition_p {return false} + if _storage._clearEditionDeprecated_p != rhs_storage._clearEditionDeprecated_p {return false} + if _storage._clearEditionIntroduced_p != rhs_storage._clearEditionIntroduced_p {return false} + if _storage._clearEditionRemoved_p != rhs_storage._clearEditionRemoved_p {return false} if _storage._clearEnd_p != rhs_storage._clearEnd_p {return false} + if _storage._clearEnforceNamingStyle_p != rhs_storage._clearEnforceNamingStyle_p {return false} + if _storage._clearEnumType_p != rhs_storage._clearEnumType_p {return false} if _storage._clearExtendee_p != rhs_storage._clearExtendee_p {return false} if _storage._clearExtensionValue_p != rhs_storage._clearExtensionValue_p {return false} + if _storage._clearFeatures_p != rhs_storage._clearFeatures_p {return false} + if _storage._clearFeatureSupport_p != rhs_storage._clearFeatureSupport_p {return false} + if _storage._clearFieldPresence_p != rhs_storage._clearFieldPresence_p {return false} + if _storage._clearFixedFeatures_p != rhs_storage._clearFixedFeatures_p {return false} + if _storage._clearFullName_p != rhs_storage._clearFullName_p {return false} if _storage._clearGoPackage_p != rhs_storage._clearGoPackage_p {return false} if _storage._clearIdempotencyLevel_p != rhs_storage._clearIdempotencyLevel_p {return false} if _storage._clearIdentifierValue_p != rhs_storage._clearIdentifierValue_p {return false} @@ -10602,13 +11507,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._clearJavaOuterClassname_p != rhs_storage._clearJavaOuterClassname_p {return false} if _storage._clearJavaPackage_p != rhs_storage._clearJavaPackage_p {return false} if _storage._clearJavaStringCheckUtf8_p != rhs_storage._clearJavaStringCheckUtf8_p {return false} + if _storage._clearJsonFormat_p != rhs_storage._clearJsonFormat_p {return false} if _storage._clearJsonName_p != rhs_storage._clearJsonName_p {return false} if _storage._clearJstype_p != rhs_storage._clearJstype_p {return false} if _storage._clearLabel_p != rhs_storage._clearLabel_p {return false} if _storage._clearLazy_p != rhs_storage._clearLazy_p {return false} if _storage._clearLeadingComments_p != rhs_storage._clearLeadingComments_p {return false} if _storage._clearMapEntry_p != rhs_storage._clearMapEntry_p {return false} + if _storage._clearMaximumEdition_p != rhs_storage._clearMaximumEdition_p {return false} + if _storage._clearMessageEncoding_p != rhs_storage._clearMessageEncoding_p {return false} if _storage._clearMessageSetWireFormat_p != rhs_storage._clearMessageSetWireFormat_p {return false} + if _storage._clearMinimumEdition_p != rhs_storage._clearMinimumEdition_p {return false} if _storage._clearName_p != rhs_storage._clearName_p {return false} if _storage._clearNamePart_p != rhs_storage._clearNamePart_p {return false} if _storage._clearNegativeIntValue_p != rhs_storage._clearNegativeIntValue_p {return false} @@ -10619,16 +11528,22 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._clearOptimizeFor_p != rhs_storage._clearOptimizeFor_p {return false} if _storage._clearOptions_p != rhs_storage._clearOptions_p {return false} if _storage._clearOutputType_p != rhs_storage._clearOutputType_p {return false} + if _storage._clearOverridableFeatures_p != rhs_storage._clearOverridableFeatures_p {return false} if _storage._clearPackage_p != rhs_storage._clearPackage_p {return false} if _storage._clearPacked_p != rhs_storage._clearPacked_p {return false} if _storage._clearPhpClassPrefix_p != rhs_storage._clearPhpClassPrefix_p {return false} - if _storage._clearPhpGenericServices_p != rhs_storage._clearPhpGenericServices_p {return false} if _storage._clearPhpMetadataNamespace_p != rhs_storage._clearPhpMetadataNamespace_p {return false} if _storage._clearPhpNamespace_p != rhs_storage._clearPhpNamespace_p {return false} if _storage._clearPositiveIntValue_p != rhs_storage._clearPositiveIntValue_p {return false} if _storage._clearProto3Optional_p != rhs_storage._clearProto3Optional_p {return false} if _storage._clearPyGenericServices_p != rhs_storage._clearPyGenericServices_p {return false} + if _storage._clearRemovalError_p != rhs_storage._clearRemovalError_p {return false} + if _storage._clearRepeated_p != rhs_storage._clearRepeated_p {return false} + if _storage._clearRepeatedFieldEncoding_p != rhs_storage._clearRepeatedFieldEncoding_p {return false} + if _storage._clearReserved_p != rhs_storage._clearReserved_p {return false} + if _storage._clearRetention_p != rhs_storage._clearRetention_p {return false} if _storage._clearRubyPackage_p != rhs_storage._clearRubyPackage_p {return false} + if _storage._clearSemantic_p != rhs_storage._clearSemantic_p {return false} if _storage._clearServerStreaming_p != rhs_storage._clearServerStreaming_p {return false} if _storage._clearSourceCodeInfo_p != rhs_storage._clearSourceCodeInfo_p {return false} if _storage._clearSourceContext_p != rhs_storage._clearSourceContext_p {return false} @@ -10640,22 +11555,30 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._clearTrailingComments_p != rhs_storage._clearTrailingComments_p {return false} if _storage._clearType_p != rhs_storage._clearType_p {return false} if _storage._clearTypeName_p != rhs_storage._clearTypeName_p {return false} + if _storage._clearUnverifiedLazy_p != rhs_storage._clearUnverifiedLazy_p {return false} + if _storage._clearUtf8Validation_p != rhs_storage._clearUtf8Validation_p {return false} if _storage._clearValue_p != rhs_storage._clearValue_p {return false} + if _storage._clearVerification_p != rhs_storage._clearVerification_p {return false} + if _storage._clearVisibility_p != rhs_storage._clearVisibility_p {return false} if _storage._clearWeak_p != rhs_storage._clearWeak_p {return false} if _storage._clientStreaming != rhs_storage._clientStreaming {return false} + if _storage._code != rhs_storage._code {return false} if _storage._codePoint != rhs_storage._codePoint {return false} if _storage._codeUnits != rhs_storage._codeUnits {return false} if _storage._collection != rhs_storage._collection {return false} - if _storage._com != rhs_storage._com {return false} if _storage._comma != rhs_storage._comma {return false} + if _storage._consumedBytes != rhs_storage._consumedBytes {return false} + if _storage._contains != rhs_storage._contains {return false} if _storage._contentsOf != rhs_storage._contentsOf {return false} if _storage._contiguousBytes != rhs_storage._contiguousBytes {return false} + if _storage._copy != rhs_storage._copy {return false} if _storage._count != rhs_storage._count {return false} if _storage._countVarintsInBuffer != rhs_storage._countVarintsInBuffer {return false} if _storage._csharpNamespace != rhs_storage._csharpNamespace {return false} if _storage._ctype != rhs_storage._ctype {return false} if _storage._customCodable != rhs_storage._customCodable {return false} if _storage._customDebugStringConvertible != rhs_storage._customDebugStringConvertible {return false} + if _storage._customStringConvertible != rhs_storage._customStringConvertible {return false} if _storage._d != rhs_storage._d {return false} if _storage._data != rhs_storage._data {return false} if _storage._dataResult != rhs_storage._dataResult {return false} @@ -10663,6 +11586,8 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._daySec != rhs_storage._daySec {return false} if _storage._daysSinceEpoch != rhs_storage._daysSinceEpoch {return false} if _storage._debugDescription_p != rhs_storage._debugDescription_p {return false} + if _storage._debugRedact != rhs_storage._debugRedact {return false} + if _storage._declaration != rhs_storage._declaration {return false} if _storage._decoded != rhs_storage._decoded {return false} if _storage._decodedFromJsonnull != rhs_storage._decodedFromJsonnull {return false} if _storage._decodeExtensionField != rhs_storage._decodeExtensionField {return false} @@ -10711,11 +11636,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._decodeSingularUint64Field != rhs_storage._decodeSingularUint64Field {return false} if _storage._decodeTextFormat != rhs_storage._decodeTextFormat {return false} if _storage._defaultAnyTypeUrlprefix != rhs_storage._defaultAnyTypeUrlprefix {return false} + if _storage._defaults != rhs_storage._defaults {return false} + if _storage._defaultSymbolVisibility != rhs_storage._defaultSymbolVisibility {return false} if _storage._defaultValue != rhs_storage._defaultValue {return false} if _storage._dependency != rhs_storage._dependency {return false} if _storage._deprecated != rhs_storage._deprecated {return false} + if _storage._deprecatedLegacyJsonFieldConflicts != rhs_storage._deprecatedLegacyJsonFieldConflicts {return false} + if _storage._deprecationWarning != rhs_storage._deprecationWarning {return false} if _storage._description_p != rhs_storage._description_p {return false} - if _storage._descriptorProto != rhs_storage._descriptorProto {return false} if _storage._dictionary != rhs_storage._dictionary {return false} if _storage._dictionaryLiteral != rhs_storage._dictionaryLiteral {return false} if _storage._digit != rhs_storage._digit {return false} @@ -10726,17 +11654,23 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._digitValue != rhs_storage._digitValue {return false} if _storage._discardableResult != rhs_storage._discardableResult {return false} if _storage._discardUnknownFields != rhs_storage._discardUnknownFields {return false} - if _storage._distance != rhs_storage._distance {return false} if _storage._double != rhs_storage._double {return false} if _storage._doubleValue != rhs_storage._doubleValue {return false} if _storage._duration != rhs_storage._duration {return false} if _storage._e != rhs_storage._e {return false} + if _storage._edition != rhs_storage._edition {return false} + if _storage._editionDefault != rhs_storage._editionDefault {return false} + if _storage._editionDefaults != rhs_storage._editionDefaults {return false} + if _storage._editionDeprecated != rhs_storage._editionDeprecated {return false} + if _storage._editionIntroduced != rhs_storage._editionIntroduced {return false} + if _storage._editionRemoved != rhs_storage._editionRemoved {return false} if _storage._element != rhs_storage._element {return false} if _storage._elements != rhs_storage._elements {return false} + if _storage._else != rhs_storage._else {return false} if _storage._emitExtensionFieldName != rhs_storage._emitExtensionFieldName {return false} if _storage._emitFieldName != rhs_storage._emitFieldName {return false} if _storage._emitFieldNumber != rhs_storage._emitFieldNumber {return false} - if _storage._empty != rhs_storage._empty {return false} + if _storage._emptyAnyTypeURL != rhs_storage._emptyAnyTypeURL {return false} if _storage._emptyData != rhs_storage._emptyData {return false} if _storage._encodeAsBytes != rhs_storage._encodeAsBytes {return false} if _storage._encoded != rhs_storage._encoded {return false} @@ -10749,16 +11683,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._endMessageField != rhs_storage._endMessageField {return false} if _storage._endObject != rhs_storage._endObject {return false} if _storage._endRegularField != rhs_storage._endRegularField {return false} + if _storage._enforceNamingStyle != rhs_storage._enforceNamingStyle {return false} if _storage._enum != rhs_storage._enum {return false} - if _storage._enumDescriptorProto != rhs_storage._enumDescriptorProto {return false} - if _storage._enumOptions != rhs_storage._enumOptions {return false} if _storage._enumReservedRange != rhs_storage._enumReservedRange {return false} if _storage._enumType != rhs_storage._enumType {return false} if _storage._enumvalue != rhs_storage._enumvalue {return false} - if _storage._enumValueDescriptorProto != rhs_storage._enumValueDescriptorProto {return false} - if _storage._enumValueOptions != rhs_storage._enumValueOptions {return false} if _storage._equatable != rhs_storage._equatable {return false} if _storage._error != rhs_storage._error {return false} + if _storage._execute != rhs_storage._execute {return false} if _storage._expressibleByArrayLiteral != rhs_storage._expressibleByArrayLiteral {return false} if _storage._expressibleByDictionaryLiteral != rhs_storage._expressibleByDictionaryLiteral {return false} if _storage._ext != rhs_storage._ext {return false} @@ -10773,37 +11705,38 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._extensionFieldValueSet != rhs_storage._extensionFieldValueSet {return false} if _storage._extensionMap != rhs_storage._extensionMap {return false} if _storage._extensionRange != rhs_storage._extensionRange {return false} - if _storage._extensionRangeOptions != rhs_storage._extensionRangeOptions {return false} if _storage._extensions != rhs_storage._extensions {return false} if _storage._extras != rhs_storage._extras {return false} if _storage._f != rhs_storage._f {return false} if _storage._false != rhs_storage._false {return false} + if _storage._features != rhs_storage._features {return false} + if _storage._featureSetEditionDefault != rhs_storage._featureSetEditionDefault {return false} + if _storage._featureSupport != rhs_storage._featureSupport {return false} if _storage._field != rhs_storage._field {return false} if _storage._fieldData != rhs_storage._fieldData {return false} - if _storage._fieldDescriptorProto != rhs_storage._fieldDescriptorProto {return false} - if _storage._fieldMask != rhs_storage._fieldMask {return false} + if _storage._fieldMaskError != rhs_storage._fieldMaskError {return false} if _storage._fieldName != rhs_storage._fieldName {return false} if _storage._fieldNameCount != rhs_storage._fieldNameCount {return false} if _storage._fieldNum != rhs_storage._fieldNum {return false} if _storage._fieldNumber != rhs_storage._fieldNumber {return false} if _storage._fieldNumberForProto != rhs_storage._fieldNumberForProto {return false} - if _storage._fieldOptions != rhs_storage._fieldOptions {return false} + if _storage._fieldPresence != rhs_storage._fieldPresence {return false} if _storage._fields != rhs_storage._fields {return false} if _storage._fieldSize != rhs_storage._fieldSize {return false} if _storage._fieldTag != rhs_storage._fieldTag {return false} if _storage._fieldType != rhs_storage._fieldType {return false} if _storage._file != rhs_storage._file {return false} - if _storage._fileDescriptorProto != rhs_storage._fileDescriptorProto {return false} - if _storage._fileDescriptorSet != rhs_storage._fileDescriptorSet {return false} if _storage._fileName != rhs_storage._fileName {return false} - if _storage._fileOptions != rhs_storage._fileOptions {return false} if _storage._filter != rhs_storage._filter {return false} + if _storage._final != rhs_storage._final {return false} + if _storage._finiteOnly != rhs_storage._finiteOnly {return false} if _storage._first != rhs_storage._first {return false} if _storage._firstItem != rhs_storage._firstItem {return false} + if _storage._fixedFeatures != rhs_storage._fixedFeatures {return false} if _storage._float != rhs_storage._float {return false} if _storage._floatLiteral != rhs_storage._floatLiteral {return false} if _storage._floatLiteralType != rhs_storage._floatLiteralType {return false} - if _storage._floatValue != rhs_storage._floatValue {return false} + if _storage._for != rhs_storage._for {return false} if _storage._forMessageName != rhs_storage._forMessageName {return false} if _storage._formUnion != rhs_storage._formUnion {return false} if _storage._forReadingFrom != rhs_storage._forReadingFrom {return false} @@ -10815,12 +11748,12 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._fromAscii4 != rhs_storage._fromAscii4 {return false} if _storage._fromByteOffset != rhs_storage._fromByteOffset {return false} if _storage._fromHexDigit != rhs_storage._fromHexDigit {return false} + if _storage._fullName != rhs_storage._fullName {return false} if _storage._func != rhs_storage._func {return false} + if _storage._function != rhs_storage._function {return false} if _storage._g != rhs_storage._g {return false} - if _storage._generatedCodeInfo != rhs_storage._generatedCodeInfo {return false} if _storage._get != rhs_storage._get {return false} if _storage._getExtensionValue != rhs_storage._getExtensionValue {return false} - if _storage._googleapis != rhs_storage._googleapis {return false} if _storage._googleProtobufAny != rhs_storage._googleProtobufAny {return false} if _storage._googleProtobufApi != rhs_storage._googleProtobufApi {return false} if _storage._googleProtobufBoolValue != rhs_storage._googleProtobufBoolValue {return false} @@ -10828,6 +11761,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._googleProtobufDescriptorProto != rhs_storage._googleProtobufDescriptorProto {return false} if _storage._googleProtobufDoubleValue != rhs_storage._googleProtobufDoubleValue {return false} if _storage._googleProtobufDuration != rhs_storage._googleProtobufDuration {return false} + if _storage._googleProtobufEdition != rhs_storage._googleProtobufEdition {return false} if _storage._googleProtobufEmpty != rhs_storage._googleProtobufEmpty {return false} if _storage._googleProtobufEnum != rhs_storage._googleProtobufEnum {return false} if _storage._googleProtobufEnumDescriptorProto != rhs_storage._googleProtobufEnumDescriptorProto {return false} @@ -10836,6 +11770,8 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._googleProtobufEnumValueDescriptorProto != rhs_storage._googleProtobufEnumValueDescriptorProto {return false} if _storage._googleProtobufEnumValueOptions != rhs_storage._googleProtobufEnumValueOptions {return false} if _storage._googleProtobufExtensionRangeOptions != rhs_storage._googleProtobufExtensionRangeOptions {return false} + if _storage._googleProtobufFeatureSet != rhs_storage._googleProtobufFeatureSet {return false} + if _storage._googleProtobufFeatureSetDefaults != rhs_storage._googleProtobufFeatureSetDefaults {return false} if _storage._googleProtobufField != rhs_storage._googleProtobufField {return false} if _storage._googleProtobufFieldDescriptorProto != rhs_storage._googleProtobufFieldDescriptorProto {return false} if _storage._googleProtobufFieldMask != rhs_storage._googleProtobufFieldMask {return false} @@ -10863,6 +11799,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._googleProtobufSourceContext != rhs_storage._googleProtobufSourceContext {return false} if _storage._googleProtobufStringValue != rhs_storage._googleProtobufStringValue {return false} if _storage._googleProtobufStruct != rhs_storage._googleProtobufStruct {return false} + if _storage._googleProtobufSymbolVisibility != rhs_storage._googleProtobufSymbolVisibility {return false} if _storage._googleProtobufSyntax != rhs_storage._googleProtobufSyntax {return false} if _storage._googleProtobufTimestamp != rhs_storage._googleProtobufTimestamp {return false} if _storage._googleProtobufType != rhs_storage._googleProtobufType {return false} @@ -10871,12 +11808,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._googleProtobufUninterpretedOption != rhs_storage._googleProtobufUninterpretedOption {return false} if _storage._googleProtobufValue != rhs_storage._googleProtobufValue {return false} if _storage._goPackage != rhs_storage._goPackage {return false} + if _storage._gotData != rhs_storage._gotData {return false} if _storage._group != rhs_storage._group {return false} if _storage._groupFieldNumberStack != rhs_storage._groupFieldNumberStack {return false} if _storage._groupSize != rhs_storage._groupSize {return false} - if _storage._h != rhs_storage._h {return false} + if _storage._guard != rhs_storage._guard {return false} if _storage._hadOneofValue != rhs_storage._hadOneofValue {return false} if _storage._handleConflictingOneOf != rhs_storage._handleConflictingOneOf {return false} + if _storage._handleInstruction != rhs_storage._handleInstruction {return false} if _storage._hasAggregateValue_p != rhs_storage._hasAggregateValue_p {return false} if _storage._hasAllowAlias_p != rhs_storage._hasAllowAlias_p {return false} if _storage._hasBegin_p != rhs_storage._hasBegin_p {return false} @@ -10885,17 +11824,33 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._hasClientStreaming_p != rhs_storage._hasClientStreaming_p {return false} if _storage._hasCsharpNamespace_p != rhs_storage._hasCsharpNamespace_p {return false} if _storage._hasCtype_p != rhs_storage._hasCtype_p {return false} + if _storage._hasData_p != rhs_storage._hasData_p {return false} + if _storage._hasDebugRedact_p != rhs_storage._hasDebugRedact_p {return false} + if _storage._hasDefaultSymbolVisibility_p != rhs_storage._hasDefaultSymbolVisibility_p {return false} if _storage._hasDefaultValue_p != rhs_storage._hasDefaultValue_p {return false} if _storage._hasDeprecated_p != rhs_storage._hasDeprecated_p {return false} + if _storage._hasDeprecatedLegacyJsonFieldConflicts_p != rhs_storage._hasDeprecatedLegacyJsonFieldConflicts_p {return false} + if _storage._hasDeprecationWarning_p != rhs_storage._hasDeprecationWarning_p {return false} if _storage._hasDoubleValue_p != rhs_storage._hasDoubleValue_p {return false} + if _storage._hasEdition_p != rhs_storage._hasEdition_p {return false} + if _storage._hasEditionDeprecated_p != rhs_storage._hasEditionDeprecated_p {return false} + if _storage._hasEditionIntroduced_p != rhs_storage._hasEditionIntroduced_p {return false} + if _storage._hasEditionRemoved_p != rhs_storage._hasEditionRemoved_p {return false} if _storage._hasEnd_p != rhs_storage._hasEnd_p {return false} + if _storage._hasEnforceNamingStyle_p != rhs_storage._hasEnforceNamingStyle_p {return false} + if _storage._hasEnumType_p != rhs_storage._hasEnumType_p {return false} + if _storage._hasExplicitDelta_p != rhs_storage._hasExplicitDelta_p {return false} if _storage._hasExtendee_p != rhs_storage._hasExtendee_p {return false} if _storage._hasExtensionValue_p != rhs_storage._hasExtensionValue_p {return false} + if _storage._hasFeatures_p != rhs_storage._hasFeatures_p {return false} + if _storage._hasFeatureSupport_p != rhs_storage._hasFeatureSupport_p {return false} + if _storage._hasFieldPresence_p != rhs_storage._hasFieldPresence_p {return false} + if _storage._hasFixedFeatures_p != rhs_storage._hasFixedFeatures_p {return false} + if _storage._hasFullName_p != rhs_storage._hasFullName_p {return false} if _storage._hasGoPackage_p != rhs_storage._hasGoPackage_p {return false} if _storage._hash != rhs_storage._hash {return false} if _storage._hashable != rhs_storage._hashable {return false} if _storage._hasher != rhs_storage._hasher {return false} - if _storage._hashValue_p != rhs_storage._hashValue_p {return false} if _storage._hashVisitor != rhs_storage._hashVisitor {return false} if _storage._hasIdempotencyLevel_p != rhs_storage._hasIdempotencyLevel_p {return false} if _storage._hasIdentifierValue_p != rhs_storage._hasIdentifierValue_p {return false} @@ -10907,13 +11862,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._hasJavaOuterClassname_p != rhs_storage._hasJavaOuterClassname_p {return false} if _storage._hasJavaPackage_p != rhs_storage._hasJavaPackage_p {return false} if _storage._hasJavaStringCheckUtf8_p != rhs_storage._hasJavaStringCheckUtf8_p {return false} + if _storage._hasJsonFormat_p != rhs_storage._hasJsonFormat_p {return false} if _storage._hasJsonName_p != rhs_storage._hasJsonName_p {return false} if _storage._hasJstype_p != rhs_storage._hasJstype_p {return false} if _storage._hasLabel_p != rhs_storage._hasLabel_p {return false} if _storage._hasLazy_p != rhs_storage._hasLazy_p {return false} if _storage._hasLeadingComments_p != rhs_storage._hasLeadingComments_p {return false} if _storage._hasMapEntry_p != rhs_storage._hasMapEntry_p {return false} + if _storage._hasMaximumEdition_p != rhs_storage._hasMaximumEdition_p {return false} + if _storage._hasMessageEncoding_p != rhs_storage._hasMessageEncoding_p {return false} if _storage._hasMessageSetWireFormat_p != rhs_storage._hasMessageSetWireFormat_p {return false} + if _storage._hasMinimumEdition_p != rhs_storage._hasMinimumEdition_p {return false} if _storage._hasName_p != rhs_storage._hasName_p {return false} if _storage._hasNamePart_p != rhs_storage._hasNamePart_p {return false} if _storage._hasNegativeIntValue_p != rhs_storage._hasNegativeIntValue_p {return false} @@ -10924,16 +11883,22 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._hasOptimizeFor_p != rhs_storage._hasOptimizeFor_p {return false} if _storage._hasOptions_p != rhs_storage._hasOptions_p {return false} if _storage._hasOutputType_p != rhs_storage._hasOutputType_p {return false} + if _storage._hasOverridableFeatures_p != rhs_storage._hasOverridableFeatures_p {return false} if _storage._hasPackage_p != rhs_storage._hasPackage_p {return false} if _storage._hasPacked_p != rhs_storage._hasPacked_p {return false} if _storage._hasPhpClassPrefix_p != rhs_storage._hasPhpClassPrefix_p {return false} - if _storage._hasPhpGenericServices_p != rhs_storage._hasPhpGenericServices_p {return false} if _storage._hasPhpMetadataNamespace_p != rhs_storage._hasPhpMetadataNamespace_p {return false} if _storage._hasPhpNamespace_p != rhs_storage._hasPhpNamespace_p {return false} if _storage._hasPositiveIntValue_p != rhs_storage._hasPositiveIntValue_p {return false} if _storage._hasProto3Optional_p != rhs_storage._hasProto3Optional_p {return false} if _storage._hasPyGenericServices_p != rhs_storage._hasPyGenericServices_p {return false} + if _storage._hasRemovalError_p != rhs_storage._hasRemovalError_p {return false} + if _storage._hasRepeated_p != rhs_storage._hasRepeated_p {return false} + if _storage._hasRepeatedFieldEncoding_p != rhs_storage._hasRepeatedFieldEncoding_p {return false} + if _storage._hasReserved_p != rhs_storage._hasReserved_p {return false} + if _storage._hasRetention_p != rhs_storage._hasRetention_p {return false} if _storage._hasRubyPackage_p != rhs_storage._hasRubyPackage_p {return false} + if _storage._hasSemantic_p != rhs_storage._hasSemantic_p {return false} if _storage._hasServerStreaming_p != rhs_storage._hasServerStreaming_p {return false} if _storage._hasSourceCodeInfo_p != rhs_storage._hasSourceCodeInfo_p {return false} if _storage._hasSourceContext_p != rhs_storage._hasSourceContext_p {return false} @@ -10945,40 +11910,49 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._hasTrailingComments_p != rhs_storage._hasTrailingComments_p {return false} if _storage._hasType_p != rhs_storage._hasType_p {return false} if _storage._hasTypeName_p != rhs_storage._hasTypeName_p {return false} + if _storage._hasUnverifiedLazy_p != rhs_storage._hasUnverifiedLazy_p {return false} + if _storage._hasUtf8Validation_p != rhs_storage._hasUtf8Validation_p {return false} if _storage._hasValue_p != rhs_storage._hasValue_p {return false} + if _storage._hasVerification_p != rhs_storage._hasVerification_p {return false} + if _storage._hasVisibility_p != rhs_storage._hasVisibility_p {return false} if _storage._hasWeak_p != rhs_storage._hasWeak_p {return false} if _storage._hour != rhs_storage._hour {return false} if _storage._i != rhs_storage._i {return false} if _storage._idempotencyLevel != rhs_storage._idempotencyLevel {return false} if _storage._identifierValue != rhs_storage._identifierValue {return false} if _storage._if != rhs_storage._if {return false} + if _storage._ignoreUnknownExtensionFields != rhs_storage._ignoreUnknownExtensionFields {return false} if _storage._ignoreUnknownFields != rhs_storage._ignoreUnknownFields {return false} if _storage._index != rhs_storage._index {return false} if _storage._init_p != rhs_storage._init_p {return false} if _storage._inout != rhs_storage._inout {return false} if _storage._inputType != rhs_storage._inputType {return false} if _storage._insert != rhs_storage._insert {return false} + if _storage._instruction != rhs_storage._instruction {return false} if _storage._int != rhs_storage._int {return false} if _storage._int32 != rhs_storage._int32 {return false} - if _storage._int32Value != rhs_storage._int32Value {return false} if _storage._int64 != rhs_storage._int64 {return false} - if _storage._int64Value != rhs_storage._int64Value {return false} if _storage._int8 != rhs_storage._int8 {return false} if _storage._integerLiteral != rhs_storage._integerLiteral {return false} if _storage._integerLiteralType != rhs_storage._integerLiteralType {return false} if _storage._intern != rhs_storage._intern {return false} if _storage._internal != rhs_storage._internal {return false} if _storage._internalState != rhs_storage._internalState {return false} + if _storage._intersect != rhs_storage._intersect {return false} if _storage._into != rhs_storage._into {return false} if _storage._ints != rhs_storage._ints {return false} + if _storage._invalidAnyTypeURL != rhs_storage._invalidAnyTypeURL {return false} if _storage._isA != rhs_storage._isA {return false} if _storage._isEqual != rhs_storage._isEqual {return false} if _storage._isEqualTo != rhs_storage._isEqualTo {return false} if _storage._isExtension != rhs_storage._isExtension {return false} if _storage._isInitialized_p != rhs_storage._isInitialized_p {return false} + if _storage._isNegative != rhs_storage._isNegative {return false} + if _storage._isPathValid != rhs_storage._isPathValid {return false} + if _storage._isReserved != rhs_storage._isReserved {return false} + if _storage._isValid != rhs_storage._isValid {return false} if _storage._itemTagsEncodedSize != rhs_storage._itemTagsEncodedSize {return false} if _storage._iterator != rhs_storage._iterator {return false} - if _storage._i2166136261 != rhs_storage._i2166136261 {return false} if _storage._javaGenerateEqualsAndHash != rhs_storage._javaGenerateEqualsAndHash {return false} if _storage._javaGenericServices != rhs_storage._javaGenericServices {return false} if _storage._javaMultipleFiles != rhs_storage._javaMultipleFiles {return false} @@ -10986,12 +11960,15 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._javaPackage != rhs_storage._javaPackage {return false} if _storage._javaStringCheckUtf8 != rhs_storage._javaStringCheckUtf8 {return false} if _storage._jsondecoder != rhs_storage._jsondecoder {return false} + if _storage._jsondecoding != rhs_storage._jsondecoding {return false} if _storage._jsondecodingError != rhs_storage._jsondecodingError {return false} if _storage._jsondecodingOptions != rhs_storage._jsondecodingOptions {return false} if _storage._jsonEncoder != rhs_storage._jsonEncoder {return false} + if _storage._jsonencoding != rhs_storage._jsonencoding {return false} if _storage._jsonencodingError != rhs_storage._jsonencodingError {return false} if _storage._jsonencodingOptions != rhs_storage._jsonencodingOptions {return false} if _storage._jsonencodingVisitor != rhs_storage._jsonencodingVisitor {return false} + if _storage._jsonFormat != rhs_storage._jsonFormat {return false} if _storage._jsonmapEncodingVisitor != rhs_storage._jsonmapEncodingVisitor {return false} if _storage._jsonName != rhs_storage._jsonName {return false} if _storage._jsonPath != rhs_storage._jsonPath {return false} @@ -10999,11 +11976,14 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._jsonscanner != rhs_storage._jsonscanner {return false} if _storage._jsonString != rhs_storage._jsonString {return false} if _storage._jsonText != rhs_storage._jsonText {return false} + if _storage._jsonUtf8Bytes != rhs_storage._jsonUtf8Bytes {return false} if _storage._jsonUtf8Data != rhs_storage._jsonUtf8Data {return false} if _storage._jstype != rhs_storage._jstype {return false} if _storage._k != rhs_storage._k {return false} + if _storage._kChunkSize != rhs_storage._kChunkSize {return false} if _storage._key != rhs_storage._key {return false} if _storage._keyField != rhs_storage._keyField {return false} + if _storage._keyFieldOpt != rhs_storage._keyFieldOpt {return false} if _storage._keyType != rhs_storage._keyType {return false} if _storage._kind != rhs_storage._kind {return false} if _storage._l != rhs_storage._l {return false} @@ -11015,42 +11995,44 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._lessThan != rhs_storage._lessThan {return false} if _storage._let != rhs_storage._let {return false} if _storage._lhs != rhs_storage._lhs {return false} + if _storage._line != rhs_storage._line {return false} if _storage._list != rhs_storage._list {return false} if _storage._listOfMessages != rhs_storage._listOfMessages {return false} if _storage._listValue != rhs_storage._listValue {return false} if _storage._littleEndian != rhs_storage._littleEndian {return false} - if _storage._littleEndianBytes != rhs_storage._littleEndianBytes {return false} if _storage._load != rhs_storage._load {return false} if _storage._localHasher != rhs_storage._localHasher {return false} if _storage._location != rhs_storage._location {return false} if _storage._m != rhs_storage._m {return false} if _storage._major != rhs_storage._major {return false} + if _storage._makeAsyncIterator != rhs_storage._makeAsyncIterator {return false} if _storage._makeIterator != rhs_storage._makeIterator {return false} + if _storage._malformedLength != rhs_storage._malformedLength {return false} if _storage._mapEntry != rhs_storage._mapEntry {return false} - if _storage._mapHash != rhs_storage._mapHash {return false} if _storage._mapKeyType != rhs_storage._mapKeyType {return false} - if _storage._mapNameResolver != rhs_storage._mapNameResolver {return false} if _storage._mapToMessages != rhs_storage._mapToMessages {return false} if _storage._mapValueType != rhs_storage._mapValueType {return false} if _storage._mapVisitor != rhs_storage._mapVisitor {return false} + if _storage._mask != rhs_storage._mask {return false} + if _storage._maximumEdition != rhs_storage._maximumEdition {return false} if _storage._mdayStart != rhs_storage._mdayStart {return false} if _storage._merge != rhs_storage._merge {return false} + if _storage._mergeOptions != rhs_storage._mergeOptions {return false} if _storage._message != rhs_storage._message {return false} if _storage._messageDepthLimit != rhs_storage._messageDepthLimit {return false} + if _storage._messageEncoding != rhs_storage._messageEncoding {return false} if _storage._messageExtension != rhs_storage._messageExtension {return false} if _storage._messageImplementationBase != rhs_storage._messageImplementationBase {return false} - if _storage._messageOptions != rhs_storage._messageOptions {return false} if _storage._messageSet != rhs_storage._messageSet {return false} if _storage._messageSetWireFormat != rhs_storage._messageSetWireFormat {return false} + if _storage._messageSize != rhs_storage._messageSize {return false} if _storage._messageType != rhs_storage._messageType {return false} if _storage._method != rhs_storage._method {return false} - if _storage._methodDescriptorProto != rhs_storage._methodDescriptorProto {return false} - if _storage._methodOptions != rhs_storage._methodOptions {return false} if _storage._methods != rhs_storage._methods {return false} + if _storage._min != rhs_storage._min {return false} + if _storage._minimumEdition != rhs_storage._minimumEdition {return false} if _storage._minor != rhs_storage._minor {return false} - if _storage._mixin != rhs_storage._mixin {return false} if _storage._mixins != rhs_storage._mixins {return false} - if _storage._modifier != rhs_storage._modifier {return false} if _storage._modify != rhs_storage._modify {return false} if _storage._month != rhs_storage._month {return false} if _storage._msgExtension != rhs_storage._msgExtension {return false} @@ -11060,44 +12042,53 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._nameDescription != rhs_storage._nameDescription {return false} if _storage._nameMap != rhs_storage._nameMap {return false} if _storage._namePart != rhs_storage._namePart {return false} - if _storage._nameResolver != rhs_storage._nameResolver {return false} if _storage._names != rhs_storage._names {return false} if _storage._nanos != rhs_storage._nanos {return false} - if _storage._nativeBytes != rhs_storage._nativeBytes {return false} - if _storage._nativeEndianBytes != rhs_storage._nativeEndianBytes {return false} if _storage._negativeIntValue != rhs_storage._negativeIntValue {return false} if _storage._nestedType != rhs_storage._nestedType {return false} + if _storage._newExtensible != rhs_storage._newExtensible {return false} if _storage._newL != rhs_storage._newL {return false} if _storage._newList != rhs_storage._newList {return false} + if _storage._newMessage != rhs_storage._newMessage {return false} if _storage._newValue != rhs_storage._newValue {return false} + if _storage._next != rhs_storage._next {return false} if _storage._nextByte != rhs_storage._nextByte {return false} if _storage._nextFieldNumber != rhs_storage._nextFieldNumber {return false} + if _storage._nextInstruction != rhs_storage._nextInstruction {return false} + if _storage._nextInt32 != rhs_storage._nextInt32 {return false} + if _storage._nextNullTerminatedString != rhs_storage._nextNullTerminatedString {return false} + if _storage._nextNullTerminatedStringArray != rhs_storage._nextNullTerminatedStringArray {return false} + if _storage._nextNumber != rhs_storage._nextNumber {return false} + if _storage._nextUint64 != rhs_storage._nextUint64 {return false} + if _storage._nextVarInt != rhs_storage._nextVarInt {return false} if _storage._nil != rhs_storage._nil {return false} if _storage._nilLiteral != rhs_storage._nilLiteral {return false} + if _storage._noBytesAvailable != rhs_storage._noBytesAvailable {return false} if _storage._noStandardDescriptorAccessor != rhs_storage._noStandardDescriptorAccessor {return false} if _storage._nullValue != rhs_storage._nullValue {return false} if _storage._number != rhs_storage._number {return false} if _storage._numberValue != rhs_storage._numberValue {return false} if _storage._objcClassPrefix != rhs_storage._objcClassPrefix {return false} if _storage._of != rhs_storage._of {return false} + if _storage._oneOfKind != rhs_storage._oneOfKind {return false} if _storage._oneofDecl != rhs_storage._oneofDecl {return false} - if _storage._oneofDescriptorProto != rhs_storage._oneofDescriptorProto {return false} if _storage._oneofIndex != rhs_storage._oneofIndex {return false} - if _storage._oneofOptions != rhs_storage._oneofOptions {return false} if _storage._oneofs != rhs_storage._oneofs {return false} - if _storage._oneOfKind != rhs_storage._oneOfKind {return false} if _storage._optimizeFor != rhs_storage._optimizeFor {return false} if _storage._optimizeMode != rhs_storage._optimizeMode {return false} - if _storage._option != rhs_storage._option {return false} if _storage._optionalEnumExtensionField != rhs_storage._optionalEnumExtensionField {return false} if _storage._optionalExtensionField != rhs_storage._optionalExtensionField {return false} if _storage._optionalGroupExtensionField != rhs_storage._optionalGroupExtensionField {return false} if _storage._optionalMessageExtensionField != rhs_storage._optionalMessageExtensionField {return false} + if _storage._optionDependency != rhs_storage._optionDependency {return false} + if _storage._optionRetention != rhs_storage._optionRetention {return false} if _storage._options != rhs_storage._options {return false} + if _storage._optionTargetType != rhs_storage._optionTargetType {return false} if _storage._other != rhs_storage._other {return false} if _storage._others != rhs_storage._others {return false} if _storage._out != rhs_storage._out {return false} if _storage._outputType != rhs_storage._outputType {return false} + if _storage._overridableFeatures != rhs_storage._overridableFeatures {return false} if _storage._p != rhs_storage._p {return false} if _storage._package != rhs_storage._package {return false} if _storage._packed != rhs_storage._packed {return false} @@ -11108,27 +12099,39 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._parse != rhs_storage._parse {return false} if _storage._partial != rhs_storage._partial {return false} if _storage._path != rhs_storage._path {return false} + if _storage._pathDecoder != rhs_storage._pathDecoder {return false} + if _storage._pathDecodingError != rhs_storage._pathDecodingError {return false} if _storage._paths != rhs_storage._paths {return false} + if _storage._pathVisitor != rhs_storage._pathVisitor {return false} if _storage._payload != rhs_storage._payload {return false} if _storage._payloadSize != rhs_storage._payloadSize {return false} if _storage._phpClassPrefix != rhs_storage._phpClassPrefix {return false} - if _storage._phpGenericServices != rhs_storage._phpGenericServices {return false} if _storage._phpMetadataNamespace != rhs_storage._phpMetadataNamespace {return false} if _storage._phpNamespace != rhs_storage._phpNamespace {return false} - if _storage._pointer != rhs_storage._pointer {return false} if _storage._pos != rhs_storage._pos {return false} if _storage._positiveIntValue != rhs_storage._positiveIntValue {return false} if _storage._prefix != rhs_storage._prefix {return false} if _storage._preserveProtoFieldNames != rhs_storage._preserveProtoFieldNames {return false} if _storage._preTraverse != rhs_storage._preTraverse {return false} + if _storage._previousNumber != rhs_storage._previousNumber {return false} + if _storage._prevPath != rhs_storage._prevPath {return false} if _storage._printUnknownFields != rhs_storage._printUnknownFields {return false} + if _storage._programBuffer != rhs_storage._programBuffer {return false} + if _storage._programFormat != rhs_storage._programFormat {return false} if _storage._proto2 != rhs_storage._proto2 {return false} if _storage._proto3DefaultValue != rhs_storage._proto3DefaultValue {return false} if _storage._proto3Optional != rhs_storage._proto3Optional {return false} - if _storage._protobufApiversionCheck != rhs_storage._protobufApiversionCheck {return false} + if _storage._protobufExtensionFieldValues != rhs_storage._protobufExtensionFieldValues {return false} + if _storage._protobufFieldNumber != rhs_storage._protobufFieldNumber {return false} + if _storage._protobufGeneratedIsEqualTo != rhs_storage._protobufGeneratedIsEqualTo {return false} + if _storage._protobufNameMap != rhs_storage._protobufNameMap {return false} + if _storage._protobufNewField != rhs_storage._protobufNewField {return false} + if _storage._protobufPackage != rhs_storage._protobufPackage {return false} if _storage._protobufApiversion2 != rhs_storage._protobufApiversion2 {return false} + if _storage._protobufApiversionCheck != rhs_storage._protobufApiversionCheck {return false} if _storage._protobufBool != rhs_storage._protobufBool {return false} if _storage._protobufBytes != rhs_storage._protobufBytes {return false} + if _storage._protobufData != rhs_storage._protobufData {return false} if _storage._protobufDouble != rhs_storage._protobufDouble {return false} if _storage._protobufEnumMap != rhs_storage._protobufEnumMap {return false} if _storage._protobufExtension != rhs_storage._protobufExtension {return false} @@ -11146,12 +12149,6 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._protobufString != rhs_storage._protobufString {return false} if _storage._protobufUint32 != rhs_storage._protobufUint32 {return false} if _storage._protobufUint64 != rhs_storage._protobufUint64 {return false} - if _storage._protobufExtensionFieldValues != rhs_storage._protobufExtensionFieldValues {return false} - if _storage._protobufFieldNumber != rhs_storage._protobufFieldNumber {return false} - if _storage._protobufGeneratedIsEqualTo != rhs_storage._protobufGeneratedIsEqualTo {return false} - if _storage._protobufNameMap != rhs_storage._protobufNameMap {return false} - if _storage._protobufNewField != rhs_storage._protobufNewField {return false} - if _storage._protobufPackage != rhs_storage._protobufPackage {return false} if _storage._protocol != rhs_storage._protocol {return false} if _storage._protoFieldName != rhs_storage._protoFieldName {return false} if _storage._protoMessageName != rhs_storage._protoMessageName {return false} @@ -11173,25 +12170,33 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._putVarInt != rhs_storage._putVarInt {return false} if _storage._putZigZagVarInt != rhs_storage._putZigZagVarInt {return false} if _storage._pyGenericServices != rhs_storage._pyGenericServices {return false} + if _storage._r != rhs_storage._r {return false} if _storage._rawChars != rhs_storage._rawChars {return false} if _storage._rawRepresentable != rhs_storage._rawRepresentable {return false} if _storage._rawValue != rhs_storage._rawValue {return false} if _storage._read4HexDigits != rhs_storage._read4HexDigits {return false} + if _storage._readBytes != rhs_storage._readBytes {return false} + if _storage._reader != rhs_storage._reader {return false} if _storage._register != rhs_storage._register {return false} + if _storage._remainingProgram != rhs_storage._remainingProgram {return false} + if _storage._removalError != rhs_storage._removalError {return false} + if _storage._removingAllFieldsOf != rhs_storage._removingAllFieldsOf {return false} + if _storage._repeated != rhs_storage._repeated {return false} if _storage._repeatedEnumExtensionField != rhs_storage._repeatedEnumExtensionField {return false} if _storage._repeatedExtensionField != rhs_storage._repeatedExtensionField {return false} + if _storage._repeatedFieldEncoding != rhs_storage._repeatedFieldEncoding {return false} if _storage._repeatedGroupExtensionField != rhs_storage._repeatedGroupExtensionField {return false} if _storage._repeatedMessageExtensionField != rhs_storage._repeatedMessageExtensionField {return false} + if _storage._repeating != rhs_storage._repeating {return false} + if _storage._replaceRepeatedFields != rhs_storage._replaceRepeatedFields {return false} if _storage._requestStreaming != rhs_storage._requestStreaming {return false} if _storage._requestTypeURL != rhs_storage._requestTypeURL {return false} if _storage._requiredSize != rhs_storage._requiredSize {return false} - if _storage._reservedName != rhs_storage._reservedName {return false} - if _storage._reservedRange != rhs_storage._reservedRange {return false} if _storage._responseStreaming != rhs_storage._responseStreaming {return false} if _storage._responseTypeURL != rhs_storage._responseTypeURL {return false} if _storage._result != rhs_storage._result {return false} + if _storage._retention != rhs_storage._retention {return false} if _storage._rethrows != rhs_storage._rethrows {return false} - if _storage._return != rhs_storage._return {return false} if _storage._returnType != rhs_storage._returnType {return false} if _storage._revision != rhs_storage._revision {return false} if _storage._rhs != rhs_storage._rhs {return false} @@ -11201,27 +12206,32 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._sawBackslash != rhs_storage._sawBackslash {return false} if _storage._sawSection4Characters != rhs_storage._sawSection4Characters {return false} if _storage._sawSection5Characters != rhs_storage._sawSection5Characters {return false} + if _storage._scalar != rhs_storage._scalar {return false} + if _storage._scan != rhs_storage._scan {return false} if _storage._scanner != rhs_storage._scanner {return false} if _storage._seconds != rhs_storage._seconds {return false} if _storage._self_p != rhs_storage._self_p {return false} + if _storage._semantic != rhs_storage._semantic {return false} + if _storage._sendable != rhs_storage._sendable {return false} if _storage._separator != rhs_storage._separator {return false} if _storage._serialize != rhs_storage._serialize {return false} + if _storage._serializedBytes != rhs_storage._serializedBytes {return false} if _storage._serializedData != rhs_storage._serializedData {return false} if _storage._serializedSize != rhs_storage._serializedSize {return false} if _storage._serverStreaming != rhs_storage._serverStreaming {return false} if _storage._service != rhs_storage._service {return false} - if _storage._serviceDescriptorProto != rhs_storage._serviceDescriptorProto {return false} - if _storage._serviceOptions != rhs_storage._serviceOptions {return false} if _storage._set != rhs_storage._set {return false} if _storage._setExtensionValue != rhs_storage._setExtensionValue {return false} if _storage._shift != rhs_storage._shift {return false} if _storage._simpleExtensionMap != rhs_storage._simpleExtensionMap {return false} + if _storage._size != rhs_storage._size {return false} if _storage._sizer != rhs_storage._sizer {return false} if _storage._source != rhs_storage._source {return false} if _storage._sourceCodeInfo != rhs_storage._sourceCodeInfo {return false} if _storage._sourceContext != rhs_storage._sourceContext {return false} if _storage._sourceEncoding != rhs_storage._sourceEncoding {return false} if _storage._sourceFile != rhs_storage._sourceFile {return false} + if _storage._sourceLocation != rhs_storage._sourceLocation {return false} if _storage._span != rhs_storage._span {return false} if _storage._split != rhs_storage._split {return false} if _storage._start != rhs_storage._start {return false} @@ -11245,13 +12255,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._structValue != rhs_storage._structValue {return false} if _storage._subDecoder != rhs_storage._subDecoder {return false} if _storage._subscript != rhs_storage._subscript {return false} + if _storage._subtract != rhs_storage._subtract {return false} if _storage._subVisitor != rhs_storage._subVisitor {return false} if _storage._swift != rhs_storage._swift {return false} if _storage._swiftPrefix != rhs_storage._swiftPrefix {return false} - if _storage._swiftProtobuf != rhs_storage._swiftProtobuf {return false} + if _storage._swiftProtobufContiguousBytes != rhs_storage._swiftProtobufContiguousBytes {return false} + if _storage._swiftProtobufError != rhs_storage._swiftProtobufError {return false} if _storage._syntax != rhs_storage._syntax {return false} if _storage._t != rhs_storage._t {return false} if _storage._tag != rhs_storage._tag {return false} + if _storage._targets != rhs_storage._targets {return false} if _storage._terminator != rhs_storage._terminator {return false} if _storage._testDecoder != rhs_storage._testDecoder {return false} if _storage._text != rhs_storage._text {return false} @@ -11262,16 +12275,19 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._textFormatEncodingOptions != rhs_storage._textFormatEncodingOptions {return false} if _storage._textFormatEncodingVisitor != rhs_storage._textFormatEncodingVisitor {return false} if _storage._textFormatString != rhs_storage._textFormatString {return false} + if _storage._throwOrIgnore != rhs_storage._throwOrIgnore {return false} if _storage._throws != rhs_storage._throws {return false} if _storage._timeInterval != rhs_storage._timeInterval {return false} if _storage._timeIntervalSince1970 != rhs_storage._timeIntervalSince1970 {return false} if _storage._timeIntervalSinceReferenceDate != rhs_storage._timeIntervalSinceReferenceDate {return false} - if _storage._timestamp != rhs_storage._timestamp {return false} + if _storage._tmp != rhs_storage._tmp {return false} + if _storage._tooLarge != rhs_storage._tooLarge {return false} if _storage._total != rhs_storage._total {return false} if _storage._totalArrayDepth != rhs_storage._totalArrayDepth {return false} if _storage._totalSize != rhs_storage._totalSize {return false} if _storage._trailingComments != rhs_storage._trailingComments {return false} if _storage._traverse != rhs_storage._traverse {return false} + if _storage._trim != rhs_storage._trim {return false} if _storage._true != rhs_storage._true {return false} if _storage._try != rhs_storage._try {return false} if _storage._type != rhs_storage._type {return false} @@ -11283,10 +12299,10 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._typeUnknown != rhs_storage._typeUnknown {return false} if _storage._typeURL != rhs_storage._typeURL {return false} if _storage._uint32 != rhs_storage._uint32 {return false} - if _storage._uint32Value != rhs_storage._uint32Value {return false} if _storage._uint64 != rhs_storage._uint64 {return false} - if _storage._uint64Value != rhs_storage._uint64Value {return false} if _storage._uint8 != rhs_storage._uint8 {return false} + if _storage._unchecked != rhs_storage._unchecked {return false} + if _storage._unicode != rhs_storage._unicode {return false} if _storage._unicodeScalarLiteral != rhs_storage._unicodeScalarLiteral {return false} if _storage._unicodeScalarLiteralType != rhs_storage._unicodeScalarLiteralType {return false} if _storage._unicodeScalars != rhs_storage._unicodeScalars {return false} @@ -11301,14 +12317,17 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._unsafeBufferPointer != rhs_storage._unsafeBufferPointer {return false} if _storage._unsafeMutablePointer != rhs_storage._unsafeMutablePointer {return false} if _storage._unsafeMutableRawBufferPointer != rhs_storage._unsafeMutableRawBufferPointer {return false} - if _storage._unsafeMutableRawPointer != rhs_storage._unsafeMutableRawPointer {return false} if _storage._unsafeRawBufferPointer != rhs_storage._unsafeRawBufferPointer {return false} if _storage._unsafeRawPointer != rhs_storage._unsafeRawPointer {return false} + if _storage._unverifiedLazy != rhs_storage._unverifiedLazy {return false} if _storage._updatedOptions != rhs_storage._updatedOptions {return false} + if _storage._uppercasedAssumingAscii != rhs_storage._uppercasedAssumingAscii {return false} if _storage._url != rhs_storage._url {return false} + if _storage._useDeterministicOrdering != rhs_storage._useDeterministicOrdering {return false} if _storage._utf8 != rhs_storage._utf8 {return false} if _storage._utf8Ptr != rhs_storage._utf8Ptr {return false} if _storage._utf8ToDouble != rhs_storage._utf8ToDouble {return false} + if _storage._utf8Validation != rhs_storage._utf8Validation {return false} if _storage._utf8View != rhs_storage._utf8View {return false} if _storage._v != rhs_storage._v {return false} if _storage._value != rhs_storage._value {return false} @@ -11316,8 +12335,12 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._values != rhs_storage._values {return false} if _storage._valueType != rhs_storage._valueType {return false} if _storage._var != rhs_storage._var {return false} + if _storage._verification != rhs_storage._verification {return false} + if _storage._verificationState != rhs_storage._verificationState {return false} if _storage._version != rhs_storage._version {return false} if _storage._versionString != rhs_storage._versionString {return false} + if _storage._visibility != rhs_storage._visibility {return false} + if _storage._visibilityFeature != rhs_storage._visibilityFeature {return false} if _storage._visitExtensionFields != rhs_storage._visitExtensionFields {return false} if _storage._visitExtensionFieldsAsMessageSet != rhs_storage._visitExtensionFieldsAsMessageSet {return false} if _storage._visitMapField != rhs_storage._visitMapField {return false} @@ -11376,6 +12399,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._visitSingularUint32Field != rhs_storage._visitSingularUint32Field {return false} if _storage._visitSingularUint64Field != rhs_storage._visitSingularUint64Field {return false} if _storage._visitUnknown != rhs_storage._visitUnknown {return false} + if _storage._void != rhs_storage._void {return false} if _storage._wasDecoded != rhs_storage._wasDecoded {return false} if _storage._weak != rhs_storage._weak {return false} if _storage._weakDependency != rhs_storage._weakDependency {return false} @@ -11385,7 +12409,9 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedFields: SwiftProtobuf. if _storage._withUnsafeBytes != rhs_storage._withUnsafeBytes {return false} if _storage._withUnsafeMutableBytes != rhs_storage._withUnsafeMutableBytes {return false} if _storage._work != rhs_storage._work {return false} + if _storage._wrapped != rhs_storage._wrapped {return false} if _storage._wrappedType != rhs_storage._wrappedType {return false} + if _storage._wrappedValue != rhs_storage._wrappedValue {return false} if _storage._written != rhs_storage._written {return false} if _storage._yday != rhs_storage._yday {return false} return true diff --git a/Tests/SwiftProtobufTests/generated_swift_names_messages.pb.swift b/Tests/SwiftProtobufTests/generated_swift_names_messages.pb.swift index 3253d43d4..b772dbc59 100644 --- a/Tests/SwiftProtobufTests/generated_swift_names_messages.pb.swift +++ b/Tests/SwiftProtobufTests/generated_swift_names_messages.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: generated_swift_names_messages.proto @@ -11,7 +12,6 @@ /// Protoc errors imply this file is being generated incorrectly /// Swift compile errors are probably bugs in protoc-gen-swift -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -24,14 +24,26 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { +struct SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: Sendable { // 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() - struct adjusted { + struct addPath: Sendable { + // 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 addPath: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct adjusted: Sendable { // 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. @@ -43,7 +55,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct aggregateValue { + struct aggregateValue: Sendable { // 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. @@ -55,7 +67,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct allCases { + struct allCases: Sendable { // 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. @@ -67,7 +79,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct allowAlias { + struct allowAlias: Sendable { // 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. @@ -79,7 +91,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct alwaysPrintEnumsAsInts { + struct alwaysPrintEnumsAsInts: Sendable { // 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. @@ -91,7 +103,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct annotation { + struct alwaysPrintInt64sAsNumbers: Sendable { + // 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 alwaysPrintInt64SAsNumbers: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct annotation: Sendable { // 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. @@ -103,7 +127,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct any { + struct any: Sendable { // 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. @@ -115,7 +139,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct AnyExtensionField { + struct AnyExtensionField: Sendable { // 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. @@ -127,7 +151,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct AnyMessageExtension { + struct AnyMessageExtension: Sendable { // 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. @@ -139,7 +163,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct AnyMessageStorage { + struct AnyMessageStorage: Sendable { // 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. @@ -151,7 +175,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct AnyUnpackError { + struct AnyUnpackError: Sendable { // 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. @@ -163,19 +187,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Api { + struct append: Sendable { // 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 api: Int32 = 0 + var append: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct appended { + struct appended: Sendable { // 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. @@ -187,7 +211,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct appendUIntHex { + struct appendUIntHex: Sendable { // 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. @@ -199,7 +223,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct appendUnknown { + struct appendUnknown: Sendable { // 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. @@ -211,7 +235,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct areAllInitialized { + struct areAllInitialized: Sendable { // 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. @@ -223,7 +247,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct array { + struct Array: Sendable { // 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. @@ -235,7 +259,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct arrayDepth { + struct arrayDepth: Sendable { // 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. @@ -247,7 +271,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct arrayLiteral { + struct arrayLiteral: Sendable { // 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. @@ -259,7 +283,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct arraySeparator { + struct arraySeparator: Sendable { // 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. @@ -271,7 +295,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct asMessage { + struct asMessage: Sendable { // 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. @@ -283,7 +307,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct asciiOpenCurlyBracket { + struct asciiOpenCurlyBracket: Sendable { // 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. @@ -295,7 +319,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct asciiZero { + struct asciiZero: Sendable { // 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. @@ -307,7 +331,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct available { + struct async: Sendable { + // 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 async: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct AsyncIterator: Sendable { + // 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 asyncIterator: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct AsyncIteratorProtocol: Sendable { + // 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 asyncIteratorProtocol: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct AsyncMessageSequence: Sendable { + // 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 asyncMessageSequence: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct available: Sendable { // 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. @@ -319,7 +391,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct b { + struct b: Sendable { // 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. @@ -331,7 +403,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct base64Values { + struct Base: Sendable { + // 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 base: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct base64Values: Sendable { // 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. @@ -343,7 +427,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct baseAddress { + struct baseAddress: Sendable { // 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. @@ -355,7 +439,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BaseType { + struct BaseType: Sendable { // 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. @@ -367,7 +451,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct begin { + struct begin: Sendable { // 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. @@ -379,7 +463,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct binary { + struct binary: Sendable { // 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. @@ -391,7 +475,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryDecoder { + struct BinaryDecoder: Sendable { // 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. @@ -403,7 +487,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryDecodingError { + struct BinaryDecoding: Sendable { + // 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 binaryDecoding: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct BinaryDecodingError: Sendable { // 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. @@ -415,7 +511,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryDecodingOptions { + struct BinaryDecodingOptions: Sendable { // 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. @@ -427,7 +523,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryDelimited { + struct BinaryDelimited: Sendable { // 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. @@ -439,7 +535,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryEncoder { + struct BinaryEncoder: Sendable { // 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. @@ -451,7 +547,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryEncodingError { + struct BinaryEncodingError: Sendable { // 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. @@ -463,7 +559,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryEncodingMessageSetSizeVisitor { + struct BinaryEncodingMessageSetSizeVisitor: Sendable { // 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. @@ -475,7 +571,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryEncodingMessageSetVisitor { + struct BinaryEncodingMessageSetVisitor: Sendable { // 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. @@ -487,7 +583,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryEncodingSizeVisitor { + struct BinaryEncodingOptions: Sendable { + // 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 binaryEncodingOptions: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct BinaryEncodingSizeVisitor: Sendable { // 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. @@ -499,7 +607,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BinaryEncodingVisitor { + struct BinaryEncodingVisitor: Sendable { // 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. @@ -511,7 +619,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct binaryOptions { + struct binaryOptions: Sendable { // 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. @@ -523,7 +631,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct body { + struct binaryProtobufDelimitedMessages: Sendable { + // 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 binaryProtobufDelimitedMessages: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct BinaryStreamDecoding: Sendable { + // 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 binaryStreamDecoding: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct binaryStreamDecodingError: Sendable { + // 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 binaryStreamDecodingError: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct bitPattern: Sendable { + // 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 bitPattern: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct body: Sendable { // 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. @@ -535,7 +691,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BoolMessage { + struct BoolMessage: Sendable { // 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. @@ -547,7 +703,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct booleanLiteral { + struct booleanLiteral: Sendable { // 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. @@ -559,7 +715,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct BooleanLiteralType { + struct BooleanLiteralType: Sendable { // 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. @@ -571,7 +727,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct boolValue { + struct boolValue: Sendable { // 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. @@ -583,7 +739,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct bytes { + struct buffer: Sendable { + // 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 buffer: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct byte: Sendable { + // 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 byte: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct bytecode: Sendable { + // 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 bytecode: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct BytecodeReader: Sendable { + // 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 bytecodeReader: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct bytes: Sendable { // 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. @@ -595,7 +799,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct bytesInGroup { + struct bytesInGroup: Sendable { // 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. @@ -607,31 +811,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct bytesRead { + struct bytesNeeded: Sendable { // 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 bytesRead: Int32 = 0 + var bytesNeeded: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct BytesValue { + struct bytesRead: Sendable { // 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 bytesValue: Int32 = 0 + var bytesRead: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct c { + struct c: Sendable { // 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. @@ -643,7 +847,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct capitalizeNext { + struct canonical: Sendable { + // 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 canonical: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct capitalizeNext: Sendable { // 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. @@ -655,7 +871,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct cardinality { + struct cardinality: Sendable { // 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. @@ -667,7 +883,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ccEnableArenas { + struct CaseIterable: Sendable { + // 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 caseIterable: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct castedValue: Sendable { + // 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 castedValue: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct ccEnableArenas: Sendable { // 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. @@ -679,7 +919,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ccGenericServices { + struct ccGenericServices: Sendable { // 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. @@ -691,7 +931,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Character { + struct Character: Sendable { // 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. @@ -703,7 +943,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct chars { + struct chars: Sendable { // 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. @@ -715,7 +955,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct classMessage { + struct checkProgramFormat: Sendable { + // 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 checkProgramFormat: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct chunk: Sendable { + // 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 chunk: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct classMessage: Sendable { // 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. @@ -727,7 +991,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearAggregateValue { + struct clearAggregateValue: Sendable { // 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. @@ -739,7 +1003,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearAllowAlias { + struct clearAllowAlias: Sendable { // 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. @@ -751,7 +1015,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearBegin { + struct clearBegin: Sendable { // 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. @@ -763,7 +1027,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearCcEnableArenas { + struct clearCcEnableArenas: Sendable { // 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. @@ -775,7 +1039,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearCcGenericServices { + struct clearCcGenericServices: Sendable { // 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. @@ -787,7 +1051,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearClientStreaming { + struct clearClientStreaming: Sendable { // 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. @@ -799,7 +1063,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearCsharpNamespace { + struct clearCsharpNamespace: Sendable { // 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. @@ -811,7 +1075,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearCtype { + struct clearCtype: Sendable { // 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. @@ -823,7 +1087,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearDefaultValue { + struct clearDebugRedact: Sendable { + // 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 clearDebugRedact_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearDefaultSymbolVisibility: Sendable { + // 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 clearDefaultSymbolVisibility_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearDefaultValue: Sendable { // 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. @@ -835,7 +1123,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearDeprecated { + struct clearDeprecated: Sendable { // 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. @@ -847,7 +1135,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearDoubleValue { + struct clearDeprecatedLegacyJsonFieldConflicts: Sendable { + // 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 clearDeprecatedLegacyJsonFieldConflicts_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearDeprecationWarning: Sendable { + // 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 clearDeprecationWarning_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearDoubleValue: Sendable { // 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. @@ -859,7 +1171,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearEnd { + struct clearEdition: Sendable { + // 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 clearEdition_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearEditionDeprecated: Sendable { + // 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 clearEditionDeprecated_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearEditionIntroduced: Sendable { + // 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 clearEditionIntroduced_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearEditionRemoved: Sendable { + // 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 clearEditionRemoved_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearEnd: Sendable { // 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. @@ -871,7 +1231,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearExtendee { + struct clearEnforceNamingStyle: Sendable { + // 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 clearEnforceNamingStyle_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearEnumType: Sendable { + // 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 clearEnumType_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearExtendee: Sendable { // 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. @@ -883,7 +1267,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearExtensionValue { + struct clearExtensionValue: Sendable { // 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. @@ -895,7 +1279,67 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearGoPackage { + struct clearFeatures: Sendable { + // 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 clearFeatures_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearFeatureSupport: Sendable { + // 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 clearFeatureSupport_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearFieldPresence: Sendable { + // 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 clearFieldPresence_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearFixedFeatures: Sendable { + // 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 clearFixedFeatures_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearFullName: Sendable { + // 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 clearFullName_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearGoPackage: Sendable { // 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. @@ -907,7 +1351,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearIdempotencyLevel { + struct clearIdempotencyLevel: Sendable { // 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. @@ -919,7 +1363,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearIdentifierValue { + struct clearIdentifierValue: Sendable { // 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. @@ -931,7 +1375,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearInputType { + struct clearInputType: Sendable { // 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. @@ -943,7 +1387,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearIsExtension { + struct clearIsExtension: Sendable { // 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. @@ -955,7 +1399,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearJavaGenerateEqualsAndHash { + struct clearJavaGenerateEqualsAndHash: Sendable { // 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. @@ -967,7 +1411,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearJavaGenericServices { + struct clearJavaGenericServices: Sendable { // 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. @@ -979,7 +1423,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearJavaMultipleFiles { + struct clearJavaMultipleFiles: Sendable { // 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. @@ -991,7 +1435,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearJavaOuterClassname { + struct clearJavaOuterClassname: Sendable { // 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. @@ -1003,7 +1447,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearJavaPackage { + struct clearJavaPackage: Sendable { // 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. @@ -1015,7 +1459,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearJavaStringCheckUtf8 { + struct clearJavaStringCheckUtf8: Sendable { // 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. @@ -1027,7 +1471,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearJsonName { + struct clearJsonFormat: Sendable { + // 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 clearJsonFormat_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearJsonName: Sendable { // 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. @@ -1039,7 +1495,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearJstype { + struct clearJstype: Sendable { // 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. @@ -1051,7 +1507,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearLabel { + struct clearLabel: Sendable { // 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. @@ -1063,7 +1519,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearLazy { + struct clearLazy: Sendable { // 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. @@ -1075,7 +1531,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearLeadingComments { + struct clearLeadingComments: Sendable { // 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. @@ -1087,7 +1543,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearMapEntry { + struct clearMapEntry: Sendable { // 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. @@ -1099,7 +1555,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearMessageSetWireFormat { + struct clearMaximumEdition: Sendable { + // 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 clearMaximumEdition_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearMessageEncoding: Sendable { + // 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 clearMessageEncoding_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearMessageSetWireFormat: Sendable { // 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. @@ -1111,7 +1591,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearName { + struct clearMinimumEdition: Sendable { + // 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 clearMinimumEdition_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearName: Sendable { // 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. @@ -1123,7 +1615,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearNamePart { + struct clearNamePart: Sendable { // 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. @@ -1135,7 +1627,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearNegativeIntValue { + struct clearNegativeIntValue: Sendable { // 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. @@ -1147,7 +1639,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearNoStandardDescriptorAccessor { + struct clearNoStandardDescriptorAccessor: Sendable { // 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. @@ -1159,7 +1651,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearNumber { + struct clearNumber: Sendable { // 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. @@ -1171,7 +1663,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearObjcClassPrefix { + struct clearObjcClassPrefix: Sendable { // 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. @@ -1183,7 +1675,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearOneofIndex { + struct clearOneofIndex: Sendable { // 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. @@ -1195,7 +1687,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearOptimizeFor { + struct clearOptimizeFor: Sendable { // 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. @@ -1207,7 +1699,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearOptions { + struct clearOptions: Sendable { // 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. @@ -1219,7 +1711,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearOutputType { + struct clearOutputType: Sendable { // 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. @@ -1231,55 +1723,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearPackage { + struct clearOverridableFeatures: Sendable { // 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 clearPackage_p: Int32 = 0 + var clearOverridableFeatures_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct clearPacked { + struct clearPackage: Sendable { // 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 clearPacked_p: Int32 = 0 + var clearPackage_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct clearPhpClassPrefix { + struct clearPacked: Sendable { // 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 clearPhpClassPrefix_p: Int32 = 0 + var clearPacked_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct clearPhpGenericServices { + struct clearPhpClassPrefix: Sendable { // 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 clearPhpGenericServices_p: Int32 = 0 + var clearPhpClassPrefix_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct clearPhpMetadataNamespace { + struct clearPhpMetadataNamespace: Sendable { // 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. @@ -1291,7 +1783,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearPhpNamespace { + struct clearPhpNamespace: Sendable { // 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. @@ -1303,7 +1795,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearPositiveIntValue { + struct clearPositiveIntValue: Sendable { // 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. @@ -1315,7 +1807,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearProto3Optional { + struct clearProto3Optional: Sendable { // 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. @@ -1327,7 +1819,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearPyGenericServices { + struct clearPyGenericServices: Sendable { // 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. @@ -1339,7 +1831,67 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearRubyPackage { + struct clearRemovalError: Sendable { + // 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 clearRemovalError_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearRepeated: Sendable { + // 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 clearRepeated_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearRepeatedFieldEncoding: Sendable { + // 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 clearRepeatedFieldEncoding_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearReserved: Sendable { + // 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 clearReserved_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearRetention: Sendable { + // 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 clearRetention_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearRubyPackage: Sendable { // 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. @@ -1351,7 +1903,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearServerStreaming { + struct clearSemantic: Sendable { + // 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 clearSemantic_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearServerStreaming: Sendable { // 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. @@ -1363,7 +1927,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearSourceCodeInfo { + struct clearSourceCodeInfo: Sendable { // 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. @@ -1375,7 +1939,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearSourceContext { + struct clearSourceContext: Sendable { // 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. @@ -1387,7 +1951,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearSourceFile { + struct clearSourceFile: Sendable { // 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. @@ -1399,7 +1963,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearStart { + struct clearStart: Sendable { // 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. @@ -1411,7 +1975,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearStringValue { + struct clearStringValue: Sendable { // 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. @@ -1423,7 +1987,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearSwiftPrefix { + struct clearSwiftPrefix: Sendable { // 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. @@ -1435,7 +1999,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearSyntax { + struct clearSyntax: Sendable { // 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. @@ -1447,7 +2011,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearTrailingComments { + struct clearTrailingComments: Sendable { // 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. @@ -1459,7 +2023,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearType { + struct clearType: Sendable { // 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. @@ -1471,7 +2035,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearTypeName { + struct clearTypeName: Sendable { // 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. @@ -1483,7 +2047,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearValue { + struct clearUnverifiedLazy: Sendable { + // 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 clearUnverifiedLazy_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearUtf8Validation: Sendable { + // 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 clearUtf8Validation_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearValue: Sendable { // 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. @@ -1495,7 +2083,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clearWeak { + struct clearVerification: Sendable { + // 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 clearVerification_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearVisibility: Sendable { + // 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 clearVisibility_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct clearWeak: Sendable { // 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. @@ -1507,7 +2119,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct clientStreaming { + struct clientStreaming: Sendable { // 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. @@ -1519,7 +2131,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct codePoint { + struct code: Sendable { + // 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 code: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct codePoint: Sendable { // 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. @@ -1531,7 +2155,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct codeUnits { + struct codeUnits: Sendable { // 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. @@ -1543,7 +2167,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Collection { + struct Collection: Sendable { // 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. @@ -1555,31 +2179,43 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct com { + struct comma: Sendable { // 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 com: Int32 = 0 + var comma: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct comma { + struct consumedBytes: Sendable { // 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 comma: Int32 = 0 + var consumedBytes: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct contains: Sendable { + // 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 contains: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct contentsOf { + struct contentsOf: Sendable { // 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. @@ -1591,7 +2227,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ContiguousBytes { + struct ContiguousBytes: Sendable { // 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. @@ -1603,7 +2239,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct count { + struct copy: Sendable { + // 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 copy: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct count: Sendable { // 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. @@ -1615,7 +2263,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct countVarintsInBuffer { + struct countVarintsInBuffer: Sendable { // 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. @@ -1627,7 +2275,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct csharpNamespace { + struct csharpNamespace: Sendable { // 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. @@ -1639,7 +2287,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ctype { + struct ctype: Sendable { // 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. @@ -1651,7 +2299,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct customCodable { + struct customCodable: Sendable { // 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. @@ -1663,7 +2311,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct CustomDebugStringConvertible { + struct CustomDebugStringConvertible: Sendable { // 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. @@ -1675,7 +2323,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct d { + struct CustomStringConvertible: Sendable { + // 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 customStringConvertible: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct D: Sendable { // 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. @@ -1687,7 +2347,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct DataMessage { + struct DataMessage: Sendable { // 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. @@ -1699,7 +2359,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct dataResult { + struct dataResult: Sendable { // 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. @@ -1711,7 +2371,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct date { + struct date: Sendable { // 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. @@ -1723,7 +2383,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct daySec { + struct daySec: Sendable { // 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. @@ -1735,7 +2395,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct daysSinceEpoch { + struct daysSinceEpoch: Sendable { // 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. @@ -1747,7 +2407,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct debugDescriptionMessage { + struct debugDescriptionMessage: Sendable { // 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. @@ -1759,7 +2419,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decoded { + struct debugRedact: Sendable { + // 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 debugRedact: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct declaration: Sendable { + // 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 declaration: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct decoded: Sendable { // 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. @@ -1771,7 +2455,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodedFromJSONNull { + struct decodedFromJSONNull: Sendable { // 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. @@ -1783,7 +2467,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeExtensionField { + struct decodeExtensionField: Sendable { // 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. @@ -1795,7 +2479,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeExtensionFieldsAsMessageSet { + struct decodeExtensionFieldsAsMessageSet: Sendable { // 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. @@ -1807,7 +2491,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeJSON { + struct decodeJSON: Sendable { // 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. @@ -1819,7 +2503,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeMapField { + struct decodeMapField: Sendable { // 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. @@ -1831,7 +2515,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeMessageMessage { + struct decodeMessageMessage: Sendable { // 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. @@ -1843,7 +2527,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decoder { + struct Decoder: Sendable { // 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. @@ -1855,7 +2539,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeated { + struct decodeRepeated: Sendable { // 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. @@ -1867,7 +2551,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedBoolField { + struct decodeRepeatedBoolField: Sendable { // 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. @@ -1879,7 +2563,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedBytesField { + struct decodeRepeatedBytesField: Sendable { // 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. @@ -1891,7 +2575,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedDoubleField { + struct decodeRepeatedDoubleField: Sendable { // 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. @@ -1903,7 +2587,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedEnumField { + struct decodeRepeatedEnumField: Sendable { // 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. @@ -1915,7 +2599,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedFixed32Field { + struct decodeRepeatedFixed32Field: Sendable { // 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. @@ -1927,7 +2611,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedFixed64Field { + struct decodeRepeatedFixed64Field: Sendable { // 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. @@ -1939,7 +2623,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedFloatField { + struct decodeRepeatedFloatField: Sendable { // 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. @@ -1951,7 +2635,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedGroupField { + struct decodeRepeatedGroupField: Sendable { // 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. @@ -1963,7 +2647,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedInt32Field { + struct decodeRepeatedInt32Field: Sendable { // 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. @@ -1975,7 +2659,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedInt64Field { + struct decodeRepeatedInt64Field: Sendable { // 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. @@ -1987,7 +2671,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedMessageField { + struct decodeRepeatedMessageField: Sendable { // 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. @@ -1999,7 +2683,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedSFixed32Field { + struct decodeRepeatedSFixed32Field: Sendable { // 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. @@ -2011,7 +2695,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedSFixed64Field { + struct decodeRepeatedSFixed64Field: Sendable { // 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. @@ -2023,7 +2707,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedSInt32Field { + struct decodeRepeatedSInt32Field: Sendable { // 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. @@ -2035,7 +2719,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedSInt64Field { + struct decodeRepeatedSInt64Field: Sendable { // 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. @@ -2047,7 +2731,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedStringField { + struct decodeRepeatedStringField: Sendable { // 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. @@ -2059,7 +2743,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedUInt32Field { + struct decodeRepeatedUInt32Field: Sendable { // 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. @@ -2071,7 +2755,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeRepeatedUInt64Field { + struct decodeRepeatedUInt64Field: Sendable { // 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. @@ -2083,7 +2767,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingular { + struct decodeSingular: Sendable { // 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. @@ -2095,7 +2779,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularBoolField { + struct decodeSingularBoolField: Sendable { // 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. @@ -2107,7 +2791,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularBytesField { + struct decodeSingularBytesField: Sendable { // 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. @@ -2119,7 +2803,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularDoubleField { + struct decodeSingularDoubleField: Sendable { // 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. @@ -2131,7 +2815,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularEnumField { + struct decodeSingularEnumField: Sendable { // 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. @@ -2143,7 +2827,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularFixed32Field { + struct decodeSingularFixed32Field: Sendable { // 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. @@ -2155,7 +2839,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularFixed64Field { + struct decodeSingularFixed64Field: Sendable { // 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. @@ -2167,7 +2851,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularFloatField { + struct decodeSingularFloatField: Sendable { // 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. @@ -2179,7 +2863,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularGroupField { + struct decodeSingularGroupField: Sendable { // 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. @@ -2191,7 +2875,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularInt32Field { + struct decodeSingularInt32Field: Sendable { // 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. @@ -2203,7 +2887,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularInt64Field { + struct decodeSingularInt64Field: Sendable { // 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. @@ -2215,7 +2899,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularMessageField { + struct decodeSingularMessageField: Sendable { // 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. @@ -2227,7 +2911,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularSFixed32Field { + struct decodeSingularSFixed32Field: Sendable { // 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. @@ -2239,7 +2923,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularSFixed64Field { + struct decodeSingularSFixed64Field: Sendable { // 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. @@ -2251,7 +2935,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularSInt32Field { + struct decodeSingularSInt32Field: Sendable { // 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. @@ -2263,7 +2947,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularSInt64Field { + struct decodeSingularSInt64Field: Sendable { // 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. @@ -2275,7 +2959,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularStringField { + struct decodeSingularStringField: Sendable { // 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. @@ -2287,7 +2971,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularUInt32Field { + struct decodeSingularUInt32Field: Sendable { // 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. @@ -2299,7 +2983,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeSingularUInt64Field { + struct decodeSingularUInt64Field: Sendable { // 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. @@ -2311,7 +2995,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct decodeTextFormat { + struct decodeTextFormat: Sendable { // 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. @@ -2323,7 +3007,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct defaultAnyTypeURLPrefix { + struct defaultAnyTypeURLPrefix: Sendable { // 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. @@ -2335,7 +3019,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct defaultValue { + struct defaults: Sendable { + // 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 defaults: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct defaultSymbolVisibility: Sendable { + // 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 defaultSymbolVisibility: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct defaultValue: Sendable { // 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. @@ -2347,7 +3055,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct dependency { + struct dependency: Sendable { // 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. @@ -2359,7 +3067,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct deprecated { + struct deprecated: Sendable { // 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. @@ -2371,31 +3079,43 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct descriptionMessage { + struct deprecatedLegacyJsonFieldConflicts: Sendable { // 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 description_p: Int32 = 0 + var deprecatedLegacyJsonFieldConflicts: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct DescriptorProto { + struct deprecationWarning: Sendable { // 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 descriptorProto: Int32 = 0 + var deprecationWarning: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Dictionary { + struct descriptionMessage: Sendable { + // 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 description_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct Dictionary: Sendable { // 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. @@ -2407,7 +3127,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct dictionaryLiteral { + struct dictionaryLiteral: Sendable { // 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. @@ -2419,7 +3139,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct digit { + struct digit: Sendable { // 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. @@ -2431,7 +3151,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct digit0 { + struct digit0: Sendable { // 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. @@ -2443,7 +3163,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct digit1 { + struct digit1: Sendable { // 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. @@ -2455,7 +3175,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct digitCount { + struct digitCount: Sendable { // 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. @@ -2467,7 +3187,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct digits { + struct digits: Sendable { // 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. @@ -2479,7 +3199,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct digitValue { + struct digitValue: Sendable { // 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. @@ -2491,7 +3211,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct discardableResult { + struct discardableResult: Sendable { // 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. @@ -2503,7 +3223,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct discardUnknownFields { + struct discardUnknownFields: Sendable { // 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. @@ -2515,379 +3235,415 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct distance { + struct DoubleMessage: Sendable { // 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 distance: Int32 = 0 + var double: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct double { + struct doubleValue: Sendable { // 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 double: Int32 = 0 + var doubleValue: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct doubleValue { + struct duration: Sendable { // 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 doubleValue: Int32 = 0 + var duration: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Duration { + struct E: Sendable { // 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 duration: Int32 = 0 + var e: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct E { + struct edition: Sendable { // 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 e: Int32 = 0 + var edition: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Element { + struct EditionDefault: Sendable { // 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 element: Int32 = 0 + var editionDefault: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct elements { + struct editionDefaults: Sendable { // 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 elements: Int32 = 0 + var editionDefaults: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct emitExtensionFieldName { + struct editionDeprecated: Sendable { // 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 emitExtensionFieldName: Int32 = 0 + var editionDeprecated: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct emitFieldName { + struct editionIntroduced: Sendable { // 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 emitFieldName: Int32 = 0 + var editionIntroduced: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct emitFieldNumber { + struct editionRemoved: Sendable { // 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 emitFieldNumber: Int32 = 0 + var editionRemoved: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Empty { + struct Element: Sendable { // 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 empty: Int32 = 0 + var element: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct emptyData { + struct elements: Sendable { // 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 emptyData: Int32 = 0 + var elements: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct encodeAsBytes { + struct elseMessage: Sendable { // 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 encodeAsBytes: Int32 = 0 + var `else`: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct encoded { + struct emitExtensionFieldName: Sendable { // 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 encoded: Int32 = 0 + var emitExtensionFieldName: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct encodedJSONString { + struct emitFieldName: Sendable { // 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 encodedJsonstring: Int32 = 0 + var emitFieldName: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct encodedSize { + struct emitFieldNumber: Sendable { // 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 encodedSize: Int32 = 0 + var emitFieldNumber: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct encodeField { + struct emptyAnyTypeURL: Sendable { // 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 encodeField: Int32 = 0 + var emptyAnyTypeURL: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct encoder { + struct emptyData: Sendable { // 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 encoder: Int32 = 0 + var emptyData: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct end { + struct encodeAsBytes: Sendable { // 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 end: Int32 = 0 + var encodeAsBytes: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct endArray { + struct encoded: Sendable { // 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 endArray: Int32 = 0 + var encoded: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct endMessageField { + struct encodedJSONString: Sendable { // 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 endMessageField: Int32 = 0 + var encodedJsonstring: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct endObject { + struct encodedSize: Sendable { // 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 endObject: Int32 = 0 + var encodedSize: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct endRegularField { + struct encodeField: Sendable { // 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 endRegularField: Int32 = 0 + var encodeField: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct enumMessage { + struct encoder: Sendable { // 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 `enum`: Int32 = 0 + var encoder: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct EnumDescriptorProto { + struct end: Sendable { // 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 enumDescriptorProto: Int32 = 0 + var end: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct EnumOptions { + struct endArray: Sendable { // 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 enumOptions: Int32 = 0 + var endArray: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct EnumReservedRange { + struct endMessageField: Sendable { // 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 enumReservedRange: Int32 = 0 + var endMessageField: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct enumType { + struct endObject: Sendable { // 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 enumType: Int32 = 0 + var endObject: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct enumvalue { + struct endRegularField: Sendable { // 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 enumvalue: Int32 = 0 + var endRegularField: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct enforceNamingStyle: Sendable { + // 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 enforceNamingStyle: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct enumMessage: Sendable { + // 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 `enum`: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct EnumValueDescriptorProto { + struct EnumReservedRange: Sendable { // 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 enumValueDescriptorProto: Int32 = 0 + var enumReservedRange: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct EnumValueOptions { + struct enumType: Sendable { // 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 enumValueOptions: Int32 = 0 + var enumType: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Equatable { + struct enumvalue: Sendable { + // 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 enumvalue: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct EquatableMessage: Sendable { // 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. @@ -2899,7 +3655,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Error { + struct Error: Sendable { // 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. @@ -2911,7 +3667,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ExpressibleByArrayLiteral { + struct execute: Sendable { + // 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 execute: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct ExpressibleByArrayLiteral: Sendable { // 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. @@ -2923,7 +3691,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ExpressibleByDictionaryLiteral { + struct ExpressibleByDictionaryLiteral: Sendable { // 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. @@ -2935,7 +3703,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ext { + struct ext: Sendable { // 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. @@ -2947,7 +3715,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct extDecoder { + struct extDecoder: Sendable { // 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. @@ -2959,7 +3727,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct extendedGraphemeClusterLiteral { + struct extendedGraphemeClusterLiteral: Sendable { // 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. @@ -2971,7 +3739,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ExtendedGraphemeClusterLiteralType { + struct ExtendedGraphemeClusterLiteralType: Sendable { // 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. @@ -2983,7 +3751,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct extendee { + struct extendee: Sendable { // 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. @@ -2995,7 +3763,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ExtensibleMessage { + struct ExtensibleMessage: Sendable { // 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. @@ -3007,7 +3775,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct extensionMessage { + struct extensionMessage: Sendable { // 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. @@ -3019,7 +3787,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ExtensionField { + struct ExtensionField: Sendable { // 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. @@ -3031,7 +3799,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct extensionFieldNumber { + struct extensionFieldNumber: Sendable { // 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. @@ -3043,7 +3811,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ExtensionFieldValueSet { + struct ExtensionFieldValueSet: Sendable { // 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. @@ -3055,7 +3823,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ExtensionMap { + struct ExtensionMap: Sendable { // 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. @@ -3067,7 +3835,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct extensionRange { + struct extensionRange: Sendable { // 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. @@ -3079,115 +3847,127 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ExtensionRangeOptions { + struct extensions: Sendable { // 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 extensionRangeOptions: Int32 = 0 + var extensions: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct extensions { + struct extras: Sendable { // 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 extensions: Int32 = 0 + var extras: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct extras { + struct F: Sendable { // 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 extras: Int32 = 0 + var f: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct F { + struct falseMessage: Sendable { // 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 f: Int32 = 0 + var `false`: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct falseMessage { + struct features: Sendable { // 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 `false`: Int32 = 0 + var features: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct field { + struct FeatureSetEditionDefault: Sendable { // 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 field: Int32 = 0 + var featureSetEditionDefault: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct fieldData { + struct featureSupport: Sendable { // 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 fieldData: Int32 = 0 + var featureSupport: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct FieldDescriptorProto { + struct field: Sendable { // 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 fieldDescriptorProto: Int32 = 0 + var field: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct FieldMask { + struct fieldData: Sendable { // 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 fieldMask: Int32 = 0 + var fieldData: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct fieldName { + struct FieldMaskError: Sendable { + // 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 fieldMaskError: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct fieldName: Sendable { // 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. @@ -3199,7 +3979,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fieldNameCount { + struct fieldNameCount: Sendable { // 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. @@ -3211,7 +3991,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fieldNum { + struct fieldNum: Sendable { // 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. @@ -3223,7 +4003,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fieldNumber { + struct fieldNumber: Sendable { // 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. @@ -3235,7 +4015,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fieldNumberForProto { + struct fieldNumberForProto: Sendable { // 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. @@ -3247,19 +4027,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct FieldOptions { + struct fieldPresence: Sendable { // 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 fieldOptions: Int32 = 0 + var fieldPresence: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct fields { + struct fields: Sendable { // 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. @@ -3271,7 +4051,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fieldSize { + struct fieldSize: Sendable { // 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. @@ -3283,7 +4063,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct FieldTag { + struct FieldTag: Sendable { // 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. @@ -3295,7 +4075,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fieldType { + struct FieldType: Sendable { // 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. @@ -3307,7 +4087,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct file { + struct file: Sendable { // 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. @@ -3319,91 +4099,91 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct FileDescriptorProto { + struct fileName: Sendable { // 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 fileDescriptorProto: Int32 = 0 + var fileName: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct FileDescriptorSet { + struct filter: Sendable { // 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 fileDescriptorSet: Int32 = 0 + var filter: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct fileName { + struct final: Sendable { // 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 fileName: Int32 = 0 + var final: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct FileOptions { + struct finiteOnly: Sendable { // 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 fileOptions: Int32 = 0 + var finiteOnly: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct filter { + struct first: Sendable { // 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 filter: Int32 = 0 + var first: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct first { + struct firstItem: Sendable { // 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 first: Int32 = 0 + var firstItem: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct firstItem { + struct fixedFeatures: Sendable { // 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 firstItem: Int32 = 0 + var fixedFeatures: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct float { + struct FloatMessage: Sendable { // 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. @@ -3415,7 +4195,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct floatLiteral { + struct floatLiteral: Sendable { // 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. @@ -3427,7 +4207,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct FloatLiteralType { + struct FloatLiteralType: Sendable { // 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. @@ -3439,19 +4219,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct FloatValue { + struct forMessage: Sendable { // 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 floatValue: Int32 = 0 + var `for`: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct forMessageName { + struct forMessageName: Sendable { // 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. @@ -3463,7 +4243,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct formUnion { + struct formUnion: Sendable { // 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. @@ -3475,7 +4255,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct forReadingFrom { + struct forReadingFrom: Sendable { // 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. @@ -3487,7 +4267,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct forTypeURL { + struct forTypeURL: Sendable { // 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. @@ -3499,7 +4279,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ForwardParser { + struct ForwardParser: Sendable { // 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. @@ -3511,7 +4291,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct forWritingInto { + struct forWritingInto: Sendable { // 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. @@ -3523,7 +4303,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct from { + struct from: Sendable { // 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. @@ -3535,7 +4315,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fromAscii2 { + struct fromAscii2: Sendable { // 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. @@ -3547,7 +4327,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fromAscii4 { + struct fromAscii4: Sendable { // 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. @@ -3559,7 +4339,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fromByteOffset { + struct fromByteOffset: Sendable { // 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. @@ -3571,7 +4351,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct fromHexDigit { + struct fromHexDigit: Sendable { // 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. @@ -3583,79 +4363,79 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct funcMessage { + struct fullName: Sendable { // 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 `func`: Int32 = 0 + var fullName: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct G { + struct funcMessage: Sendable { // 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 g: Int32 = 0 + var `func`: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct GeneratedCodeInfo { + struct function: Sendable { // 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 generatedCodeInfo: Int32 = 0 + var function: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct get { + struct G: Sendable { // 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 get: Int32 = 0 + var g: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct getExtensionValue { + struct get: Sendable { // 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 getExtensionValue: Int32 = 0 + var get: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct googleapis { + struct getExtensionValue: Sendable { // 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 googleapis: Int32 = 0 + var getExtensionValue: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Google_Protobuf_Any { + struct Google_Protobuf_Any: Sendable { // 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. @@ -3667,7 +4447,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Api { + struct Google_Protobuf_Api: Sendable { // 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. @@ -3679,7 +4459,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_BoolValue { + struct Google_Protobuf_BoolValue: Sendable { // 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. @@ -3691,7 +4471,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_BytesValue { + struct Google_Protobuf_BytesValue: Sendable { // 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. @@ -3703,7 +4483,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_DescriptorProto { + struct Google_Protobuf_DescriptorProto: Sendable { // 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. @@ -3715,7 +4495,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_DoubleValue { + struct Google_Protobuf_DoubleValue: Sendable { // 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. @@ -3727,7 +4507,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Duration { + struct Google_Protobuf_Duration: Sendable { // 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. @@ -3739,7 +4519,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Empty { + struct Google_Protobuf_Edition: Sendable { + // 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 googleProtobufEdition: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct Google_Protobuf_Empty: Sendable { // 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. @@ -3751,7 +4543,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Enum { + struct Google_Protobuf_Enum: Sendable { // 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. @@ -3763,7 +4555,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_EnumDescriptorProto { + struct Google_Protobuf_EnumDescriptorProto: Sendable { // 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. @@ -3775,7 +4567,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_EnumOptions { + struct Google_Protobuf_EnumOptions: Sendable { // 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. @@ -3787,7 +4579,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_EnumValue { + struct Google_Protobuf_EnumValue: Sendable { // 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. @@ -3799,7 +4591,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_EnumValueDescriptorProto { + struct Google_Protobuf_EnumValueDescriptorProto: Sendable { // 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. @@ -3811,7 +4603,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_EnumValueOptions { + struct Google_Protobuf_EnumValueOptions: Sendable { // 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. @@ -3823,7 +4615,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_ExtensionRangeOptions { + struct Google_Protobuf_ExtensionRangeOptions: Sendable { // 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. @@ -3835,7 +4627,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Field { + struct Google_Protobuf_FeatureSet: Sendable { + // 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 googleProtobufFeatureSet: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct Google_Protobuf_FeatureSetDefaults: Sendable { + // 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 googleProtobufFeatureSetDefaults: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct Google_Protobuf_Field: Sendable { // 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. @@ -3847,7 +4663,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_FieldDescriptorProto { + struct Google_Protobuf_FieldDescriptorProto: Sendable { // 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. @@ -3859,7 +4675,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_FieldMask { + struct Google_Protobuf_FieldMask: Sendable { // 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. @@ -3871,7 +4687,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_FieldOptions { + struct Google_Protobuf_FieldOptions: Sendable { // 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. @@ -3883,7 +4699,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_FileDescriptorProto { + struct Google_Protobuf_FileDescriptorProto: Sendable { // 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. @@ -3895,7 +4711,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_FileDescriptorSet { + struct Google_Protobuf_FileDescriptorSet: Sendable { // 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. @@ -3907,7 +4723,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_FileOptions { + struct Google_Protobuf_FileOptions: Sendable { // 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. @@ -3919,7 +4735,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_FloatValue { + struct Google_Protobuf_FloatValue: Sendable { // 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. @@ -3931,7 +4747,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_GeneratedCodeInfo { + struct Google_Protobuf_GeneratedCodeInfo: Sendable { // 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. @@ -3943,7 +4759,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Int32Value { + struct Google_Protobuf_Int32Value: Sendable { // 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. @@ -3955,7 +4771,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Int64Value { + struct Google_Protobuf_Int64Value: Sendable { // 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. @@ -3967,7 +4783,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_ListValue { + struct Google_Protobuf_ListValue: Sendable { // 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. @@ -3979,7 +4795,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_MessageOptions { + struct Google_Protobuf_MessageOptions: Sendable { // 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. @@ -3991,7 +4807,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Method { + struct Google_Protobuf_Method: Sendable { // 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. @@ -4003,7 +4819,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_MethodDescriptorProto { + struct Google_Protobuf_MethodDescriptorProto: Sendable { // 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. @@ -4015,7 +4831,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_MethodOptions { + struct Google_Protobuf_MethodOptions: Sendable { // 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. @@ -4027,7 +4843,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Mixin { + struct Google_Protobuf_Mixin: Sendable { // 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. @@ -4039,7 +4855,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_NullValue { + struct Google_Protobuf_NullValue: Sendable { // 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. @@ -4051,7 +4867,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_OneofDescriptorProto { + struct Google_Protobuf_OneofDescriptorProto: Sendable { // 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. @@ -4063,7 +4879,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_OneofOptions { + struct Google_Protobuf_OneofOptions: Sendable { // 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. @@ -4075,7 +4891,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Option { + struct Google_Protobuf_Option: Sendable { // 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. @@ -4087,7 +4903,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_ServiceDescriptorProto { + struct Google_Protobuf_ServiceDescriptorProto: Sendable { // 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. @@ -4099,7 +4915,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_ServiceOptions { + struct Google_Protobuf_ServiceOptions: Sendable { // 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. @@ -4111,7 +4927,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_SourceCodeInfo { + struct Google_Protobuf_SourceCodeInfo: Sendable { // 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. @@ -4123,7 +4939,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_SourceContext { + struct Google_Protobuf_SourceContext: Sendable { // 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. @@ -4135,7 +4951,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_StringValue { + struct Google_Protobuf_StringValue: Sendable { // 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. @@ -4147,7 +4963,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Struct { + struct Google_Protobuf_Struct: Sendable { // 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. @@ -4159,7 +4975,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Syntax { + struct Google_Protobuf_SymbolVisibility: Sendable { + // 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 googleProtobufSymbolVisibility: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct Google_Protobuf_Syntax: Sendable { // 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. @@ -4171,7 +4999,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Timestamp { + struct Google_Protobuf_Timestamp: Sendable { // 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. @@ -4183,7 +5011,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Type { + struct Google_Protobuf_Type: Sendable { // 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. @@ -4195,7 +5023,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_UInt32Value { + struct Google_Protobuf_UInt32Value: Sendable { // 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. @@ -4207,7 +5035,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_UInt64Value { + struct Google_Protobuf_UInt64Value: Sendable { // 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. @@ -4219,7 +5047,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_UninterpretedOption { + struct Google_Protobuf_UninterpretedOption: Sendable { // 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. @@ -4231,7 +5059,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Google_Protobuf_Value { + struct Google_Protobuf_Value: Sendable { // 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. @@ -4243,7 +5071,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct goPackage { + struct goPackage: Sendable { // 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. @@ -4255,7 +5083,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct group { + struct gotData: Sendable { + // 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 gotData: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct group: Sendable { // 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. @@ -4267,7 +5107,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct groupFieldNumberStack { + struct groupFieldNumberStack: Sendable { // 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. @@ -4279,7 +5119,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct groupSize { + struct groupSize: Sendable { // 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. @@ -4291,19 +5131,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct h { + struct guardMessage: Sendable { // 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 h: Int32 = 0 + var `guard`: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct hadOneofValue { + struct hadOneofValue: Sendable { // 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. @@ -4315,7 +5155,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct handleConflictingOneOf { + struct handleConflictingOneOf: Sendable { // 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. @@ -4327,7 +5167,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasAggregateValue { + struct handleInstruction: Sendable { + // 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 handleInstruction: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasAggregateValue: Sendable { // 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. @@ -4339,7 +5191,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasAllowAlias { + struct hasAllowAlias: Sendable { // 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. @@ -4351,7 +5203,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasBegin { + struct hasBegin: Sendable { // 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. @@ -4363,7 +5215,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasCcEnableArenas { + struct hasCcEnableArenas: Sendable { // 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. @@ -4375,7 +5227,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasCcGenericServices { + struct hasCcGenericServices: Sendable { // 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. @@ -4387,7 +5239,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasClientStreaming { + struct hasClientStreaming: Sendable { // 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. @@ -4399,7 +5251,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasCsharpNamespace { + struct hasCsharpNamespace: Sendable { // 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. @@ -4411,7 +5263,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasCtype { + struct hasCtype: Sendable { // 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. @@ -4423,7 +5275,43 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasDefaultValue { + struct hasData: Sendable { + // 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 hasData_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasDebugRedact: Sendable { + // 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 hasDebugRedact_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasDefaultSymbolVisibility: Sendable { + // 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 hasDefaultSymbolVisibility_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasDefaultValue: Sendable { // 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. @@ -4435,7 +5323,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasDeprecated { + struct hasDeprecated: Sendable { // 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. @@ -4447,7 +5335,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasDoubleValue { + struct hasDeprecatedLegacyJsonFieldConflicts: Sendable { + // 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 hasDeprecatedLegacyJsonFieldConflicts_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasDeprecationWarning: Sendable { + // 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 hasDeprecationWarning_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasDoubleValue: Sendable { // 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. @@ -4459,7 +5371,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasEnd { + struct hasEdition: Sendable { + // 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 hasEdition_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasEditionDeprecated: Sendable { + // 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 hasEditionDeprecated_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasEditionIntroduced: Sendable { + // 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 hasEditionIntroduced_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasEditionRemoved: Sendable { + // 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 hasEditionRemoved_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasEnd: Sendable { // 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. @@ -4471,7 +5431,43 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasExtendee { + struct hasEnforceNamingStyle: Sendable { + // 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 hasEnforceNamingStyle_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasEnumType: Sendable { + // 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 hasEnumType_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasExplicitDelta: Sendable { + // 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 hasExplicitDelta_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasExtendee: Sendable { // 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. @@ -4483,7 +5479,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasExtensionValue { + struct hasExtensionValue: Sendable { // 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. @@ -4495,67 +5491,115 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasGoPackage { + struct hasFeatures: Sendable { // 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 hasGoPackage_p: Int32 = 0 + var hasFeatures_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct hash { + struct hasFeatureSupport: Sendable { // 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 hash: Int32 = 0 + var hasFeatureSupport_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Hashable { + struct hasFieldPresence: Sendable { // 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 hashable: Int32 = 0 + var hasFieldPresence_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct hasher { + struct hasFixedFeatures: Sendable { // 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 hasher: Int32 = 0 + var hasFixedFeatures_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasFullName: Sendable { + // 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 hasFullName_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasGoPackage: Sendable { + // 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 hasGoPackage_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hash: Sendable { + // 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 hash: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct hashValueMessage { + struct HashableMessage: Sendable { // 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 hashValue_p: Int32 = 0 + var hashable: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct HashVisitor { + struct hasher: Sendable { + // 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 hasher: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct HashVisitor: Sendable { // 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. @@ -4567,7 +5611,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasIdempotencyLevel { + struct hasIdempotencyLevel: Sendable { // 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. @@ -4579,7 +5623,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasIdentifierValue { + struct hasIdentifierValue: Sendable { // 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. @@ -4591,7 +5635,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasInputType { + struct hasInputType: Sendable { // 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. @@ -4603,7 +5647,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasIsExtension { + struct hasIsExtension: Sendable { // 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. @@ -4615,7 +5659,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasJavaGenerateEqualsAndHash { + struct hasJavaGenerateEqualsAndHash: Sendable { // 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. @@ -4627,7 +5671,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasJavaGenericServices { + struct hasJavaGenericServices: Sendable { // 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. @@ -4639,7 +5683,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasJavaMultipleFiles { + struct hasJavaMultipleFiles: Sendable { // 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. @@ -4651,7 +5695,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasJavaOuterClassname { + struct hasJavaOuterClassname: Sendable { // 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. @@ -4663,7 +5707,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasJavaPackage { + struct hasJavaPackage: Sendable { // 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. @@ -4675,7 +5719,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasJavaStringCheckUtf8 { + struct hasJavaStringCheckUtf8: Sendable { // 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. @@ -4687,7 +5731,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasJsonName { + struct hasJsonFormat: Sendable { + // 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 hasJsonFormat_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasJsonName: Sendable { // 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. @@ -4699,7 +5755,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasJstype { + struct hasJstype: Sendable { // 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. @@ -4711,7 +5767,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasLabel { + struct hasLabel: Sendable { // 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. @@ -4723,7 +5779,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasLazy { + struct hasLazy: Sendable { // 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. @@ -4735,7 +5791,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasLeadingComments { + struct hasLeadingComments: Sendable { // 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. @@ -4747,7 +5803,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasMapEntry { + struct hasMapEntry: Sendable { // 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. @@ -4759,7 +5815,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasMessageSetWireFormat { + struct hasMaximumEdition: Sendable { + // 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 hasMaximumEdition_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasMessageEncoding: Sendable { + // 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 hasMessageEncoding_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasMessageSetWireFormat: Sendable { // 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. @@ -4771,7 +5851,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasName { + struct hasMinimumEdition: Sendable { + // 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 hasMinimumEdition_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasName: Sendable { // 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. @@ -4783,7 +5875,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasNamePart { + struct hasNamePart: Sendable { // 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. @@ -4795,7 +5887,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasNegativeIntValue { + struct hasNegativeIntValue: Sendable { // 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. @@ -4807,7 +5899,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasNoStandardDescriptorAccessor { + struct hasNoStandardDescriptorAccessor: Sendable { // 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. @@ -4819,7 +5911,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasNumber { + struct hasNumber: Sendable { // 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. @@ -4831,7 +5923,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasObjcClassPrefix { + struct hasObjcClassPrefix: Sendable { // 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. @@ -4843,7 +5935,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasOneofIndex { + struct hasOneofIndex: Sendable { // 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. @@ -4855,7 +5947,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasOptimizeFor { + struct hasOptimizeFor: Sendable { // 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. @@ -4867,7 +5959,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasOptions { + struct hasOptions: Sendable { // 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. @@ -4879,7 +5971,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasOutputType { + struct hasOutputType: Sendable { // 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. @@ -4891,55 +5983,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasPackage { + struct hasOverridableFeatures: Sendable { // 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 hasPackage_p: Int32 = 0 + var hasOverridableFeatures_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct hasPacked { + struct hasPackage: Sendable { // 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 hasPacked_p: Int32 = 0 + var hasPackage_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct hasPhpClassPrefix { + struct hasPacked: Sendable { // 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 hasPhpClassPrefix_p: Int32 = 0 + var hasPacked_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct hasPhpGenericServices { + struct hasPhpClassPrefix: Sendable { // 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 hasPhpGenericServices_p: Int32 = 0 + var hasPhpClassPrefix_p: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct hasPhpMetadataNamespace { + struct hasPhpMetadataNamespace: Sendable { // 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. @@ -4951,7 +6043,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasPhpNamespace { + struct hasPhpNamespace: Sendable { // 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. @@ -4963,7 +6055,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasPositiveIntValue { + struct hasPositiveIntValue: Sendable { // 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. @@ -4975,7 +6067,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasProto3Optional { + struct hasProto3Optional: Sendable { // 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. @@ -4987,7 +6079,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasPyGenericServices { + struct hasPyGenericServices: Sendable { // 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. @@ -4999,7 +6091,67 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasRubyPackage { + struct hasRemovalError: Sendable { + // 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 hasRemovalError_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasRepeated: Sendable { + // 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 hasRepeated_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasRepeatedFieldEncoding: Sendable { + // 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 hasRepeatedFieldEncoding_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasReserved: Sendable { + // 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 hasReserved_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasRetention: Sendable { + // 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 hasRetention_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasRubyPackage: Sendable { // 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. @@ -5011,7 +6163,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasServerStreaming { + struct hasSemantic: Sendable { + // 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 hasSemantic_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasServerStreaming: Sendable { // 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. @@ -5023,7 +6187,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasSourceCodeInfo { + struct hasSourceCodeInfo: Sendable { // 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. @@ -5035,7 +6199,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasSourceContext { + struct hasSourceContext: Sendable { // 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. @@ -5047,7 +6211,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasSourceFile { + struct hasSourceFile: Sendable { // 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. @@ -5059,7 +6223,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasStart { + struct hasStart: Sendable { // 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. @@ -5071,7 +6235,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasStringValue { + struct hasStringValue: Sendable { // 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. @@ -5083,7 +6247,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasSwiftPrefix { + struct hasSwiftPrefix: Sendable { // 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. @@ -5095,7 +6259,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasSyntax { + struct hasSyntax: Sendable { // 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. @@ -5107,7 +6271,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasTrailingComments { + struct hasTrailingComments: Sendable { // 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. @@ -5119,7 +6283,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasType { + struct hasType: Sendable { // 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. @@ -5131,7 +6295,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasTypeName { + struct hasTypeName: Sendable { // 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. @@ -5143,7 +6307,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasValue { + struct hasUnverifiedLazy: Sendable { + // 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 hasUnverifiedLazy_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasUtf8Validation: Sendable { + // 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 hasUtf8Validation_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasValue: Sendable { // 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. @@ -5155,7 +6343,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hasWeak { + struct hasVerification: Sendable { + // 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 hasVerification_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasVisibility: Sendable { + // 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 hasVisibility_p: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct hasWeak: Sendable { // 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. @@ -5167,7 +6379,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct hour { + struct hour: Sendable { // 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. @@ -5179,7 +6391,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct i { + struct i: Sendable { // 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. @@ -5191,7 +6403,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct idempotencyLevel { + struct idempotencyLevel: Sendable { // 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. @@ -5203,7 +6415,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct identifierValue { + struct identifierValue: Sendable { // 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. @@ -5215,7 +6427,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ifMessage { + struct ifMessage: Sendable { // 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. @@ -5227,7 +6439,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ignoreUnknownFields { + struct ignoreUnknownExtensionFields: Sendable { + // 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 ignoreUnknownExtensionFields: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct ignoreUnknownFields: Sendable { // 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. @@ -5239,7 +6463,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct index { + struct index: Sendable { // 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. @@ -5251,7 +6475,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct initMessage { + struct initMessage: Sendable { // 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. @@ -5263,7 +6487,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct inoutMessage { + struct inoutMessage: Sendable { // 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. @@ -5275,7 +6499,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct inputType { + struct inputType: Sendable { // 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. @@ -5287,7 +6511,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct insert { + struct insert: Sendable { // 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. @@ -5299,43 +6523,43 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct IntMessage { + struct Instruction: Sendable { // 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 int: Int32 = 0 + var instruction: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Int32Message { + struct IntMessage: Sendable { // 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 int32: Int32 = 0 + var int: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Int32Value { + struct Int32Message: Sendable { // 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 int32Value: Int32 = 0 + var int32: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Int64Message { + struct Int64Message: Sendable { // 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. @@ -5347,91 +6571,91 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Int64Value { + struct Int8: Sendable { // 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 int64Value: Int32 = 0 + var int8: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Int8 { + struct integerLiteral: Sendable { // 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 int8: Int32 = 0 + var integerLiteral: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct integerLiteral { + struct IntegerLiteralType: Sendable { // 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 integerLiteral: Int32 = 0 + var integerLiteralType: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct IntegerLiteralType { + struct intern: Sendable { // 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 integerLiteralType: Int32 = 0 + var intern: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct intern { + struct Internal: Sendable { // 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 intern: Int32 = 0 + var `internal`: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Internal { + struct InternalState: Sendable { // 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 `internal`: Int32 = 0 + var internalState: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct InternalState { + struct intersect: Sendable { // 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 internalState: Int32 = 0 + var intersect: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct into { + struct into: Sendable { // 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. @@ -5443,7 +6667,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ints { + struct ints: Sendable { // 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. @@ -5455,7 +6679,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct isA { + struct invalidAnyTypeURL: Sendable { + // 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 invalidAnyTypeURL: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct isA: Sendable { // 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. @@ -5467,7 +6703,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct isEqual { + struct isEqual: Sendable { // 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. @@ -5479,7 +6715,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct isEqualTo { + struct isEqualTo: Sendable { // 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. @@ -5491,7 +6727,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct isExtension { + struct isExtension: Sendable { // 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. @@ -5503,7 +6739,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct isInitializedMessage { + struct isInitializedMessage: Sendable { // 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. @@ -5515,43 +6751,79 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct itemTagsEncodedSize { + struct isNegative: Sendable { // 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 itemTagsEncodedSize: Int32 = 0 + var isNegative: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Iterator { + struct isPathValid: Sendable { // 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 iterator: Int32 = 0 + var isPathValid: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct i_2166136261 { + struct isReserved: Sendable { // 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 i2166136261: Int32 = 0 + var isReserved: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct isValid: Sendable { + // 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 isValid: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct itemTagsEncodedSize: Sendable { + // 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 itemTagsEncodedSize: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct iterator: Sendable { + // 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 iterator: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct javaGenerateEqualsAndHash { + struct javaGenerateEqualsAndHash: Sendable { // 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. @@ -5563,7 +6835,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct javaGenericServices { + struct javaGenericServices: Sendable { // 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. @@ -5575,7 +6847,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct javaMultipleFiles { + struct javaMultipleFiles: Sendable { // 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. @@ -5587,7 +6859,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct javaOuterClassname { + struct javaOuterClassname: Sendable { // 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. @@ -5599,7 +6871,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct javaPackage { + struct javaPackage: Sendable { // 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. @@ -5611,7 +6883,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct javaStringCheckUtf8 { + struct javaStringCheckUtf8: Sendable { // 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. @@ -5623,7 +6895,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct JSONDecoder { + struct JSONDecoder: Sendable { // 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. @@ -5635,7 +6907,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct JSONDecodingError { + struct JSONDecoding: Sendable { + // 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 jsondecoding: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct JSONDecodingError: Sendable { // 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. @@ -5647,7 +6931,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct JSONDecodingOptions { + struct JSONDecodingOptions: Sendable { // 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. @@ -5659,7 +6943,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct jsonEncoder { + struct jsonEncoder: Sendable { // 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. @@ -5671,7 +6955,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct JSONEncodingError { + struct JSONEncoding: Sendable { + // 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 jsonencoding: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct JSONEncodingError: Sendable { // 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. @@ -5683,7 +6979,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct JSONEncodingOptions { + struct JSONEncodingOptions: Sendable { // 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. @@ -5695,7 +6991,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct JSONEncodingVisitor { + struct JSONEncodingVisitor: Sendable { // 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. @@ -5707,7 +7003,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct JSONMapEncodingVisitor { + struct jsonFormat: Sendable { + // 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 jsonFormat: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct JSONMapEncodingVisitor: Sendable { // 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. @@ -5719,7 +7027,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct jsonName { + struct jsonName: Sendable { // 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. @@ -5731,7 +7039,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct jsonPath { + struct jsonPath: Sendable { // 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. @@ -5743,7 +7051,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct jsonPaths { + struct jsonPaths: Sendable { // 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. @@ -5755,7 +7063,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct JSONScanner { + struct JSONScanner: Sendable { // 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. @@ -5767,7 +7075,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct jsonString { + struct jsonString: Sendable { // 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. @@ -5779,7 +7087,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct jsonText { + struct jsonText: Sendable { // 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. @@ -5791,7 +7099,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct jsonUTF8Data { + struct jsonUTF8Bytes: Sendable { + // 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 jsonUtf8Bytes: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct jsonUTF8Data: Sendable { // 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. @@ -5803,7 +7123,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct jstype { + struct jstype: Sendable { // 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. @@ -5815,7 +7135,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct k { + struct k: Sendable { // 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. @@ -5827,7 +7147,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Key { + struct kChunkSize: Sendable { + // 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 kChunkSize: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct Key: Sendable { // 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. @@ -5839,7 +7171,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct keyField { + struct keyField: Sendable { // 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. @@ -5851,7 +7183,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct KeyType { + struct keyFieldOpt: Sendable { + // 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 keyFieldOpt: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct KeyType: Sendable { // 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. @@ -5863,7 +7207,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct kind { + struct kind: Sendable { // 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. @@ -5875,7 +7219,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct l { + struct l: Sendable { // 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. @@ -5887,7 +7231,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct label { + struct label: Sendable { // 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. @@ -5899,7 +7243,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct lazy { + struct lazy: Sendable { // 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. @@ -5911,7 +7255,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct leadingComments { + struct leadingComments: Sendable { // 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. @@ -5923,7 +7267,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct leadingDetachedComments { + struct leadingDetachedComments: Sendable { // 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. @@ -5935,7 +7279,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct length { + struct length: Sendable { // 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. @@ -5947,7 +7291,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct lessThan { + struct lessThan: Sendable { // 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. @@ -5959,7 +7303,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct letMessage { + struct letMessage: Sendable { // 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. @@ -5971,7 +7315,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct lhs { + struct lhs: Sendable { // 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. @@ -5983,67 +7327,67 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct list { + struct line: Sendable { // 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 list: Int32 = 0 + var line: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct listOfMessages { + struct list: Sendable { // 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 listOfMessages: Int32 = 0 + var list: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct listValue { + struct listOfMessages: Sendable { // 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 listValue: Int32 = 0 + var listOfMessages: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct littleEndian { + struct listValue: Sendable { // 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 littleEndian: Int32 = 0 + var listValue: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct littleEndianBytes { + struct littleEndian: Sendable { // 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 littleEndianBytes: Int32 = 0 + var littleEndian: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct load { + struct load: Sendable { // 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. @@ -6055,7 +7399,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct localHasher { + struct localHasher: Sendable { // 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. @@ -6067,7 +7411,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct location { + struct location: Sendable { // 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. @@ -6079,7 +7423,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct M { + struct M: Sendable { // 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. @@ -6091,7 +7435,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct major { + struct major: Sendable { // 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. @@ -6103,67 +7447,67 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct makeIterator { + struct makeAsyncIterator: Sendable { // 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 makeIterator: Int32 = 0 + var makeAsyncIterator: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct mapEntry { + struct makeIterator: Sendable { // 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 mapEntry: Int32 = 0 + var makeIterator: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct mapHash { + struct malformedLength: Sendable { // 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 mapHash: Int32 = 0 + var malformedLength: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct MapKeyType { + struct mapEntry: Sendable { // 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 mapKeyType: Int32 = 0 + var mapEntry: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct mapNameResolver { + struct MapKeyType: Sendable { // 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 mapNameResolver: Int32 = 0 + var mapKeyType: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct mapToMessages { + struct mapToMessages: Sendable { // 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. @@ -6175,7 +7519,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct MapValueType { + struct MapValueType: Sendable { // 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. @@ -6187,7 +7531,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct mapVisitor { + struct mapVisitor: Sendable { // 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. @@ -6199,7 +7543,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct mdayStart { + struct mask: Sendable { + // 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 mask: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct maximumEdition: Sendable { + // 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 maximumEdition: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct mdayStart: Sendable { // 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. @@ -6211,7 +7579,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct merge { + struct merge: Sendable { // 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. @@ -6223,139 +7591,139 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct message { + struct MergeOptions: Sendable { // 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 message: Int32 = 0 + var mergeOptions: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct messageDepthLimit { + struct message: Sendable { // 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 messageDepthLimit: Int32 = 0 + var message: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct MessageExtension { + struct messageDepthLimit: Sendable { // 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 messageExtension: Int32 = 0 + var messageDepthLimit: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct MessageImplementationBase { + struct messageEncoding: Sendable { // 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 messageImplementationBase: Int32 = 0 + var messageEncoding: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct MessageOptions { + struct MessageExtension: Sendable { // 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 messageOptions: Int32 = 0 + var messageExtension: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct MessageSet { + struct MessageImplementationBase: Sendable { // 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 messageSet: Int32 = 0 + var messageImplementationBase: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct messageSetWireFormat { + struct MessageSet: Sendable { // 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 messageSetWireFormat: Int32 = 0 + var messageSet: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct messageType { + struct messageSetWireFormat: Sendable { // 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 messageType: Int32 = 0 + var messageSetWireFormat: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Method { + struct messageSize: Sendable { // 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 method: Int32 = 0 + var messageSize: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct MethodDescriptorProto { + struct messageType: Sendable { // 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 methodDescriptorProto: Int32 = 0 + var messageType: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct MethodOptions { + struct method: Sendable { // 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 methodOptions: Int32 = 0 + var method: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct methods { + struct methods: Sendable { // 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. @@ -6367,55 +7735,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct minor { + struct min: Sendable { // 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 minor: Int32 = 0 + var min: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Mixin { + struct minimumEdition: Sendable { // 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 mixin: Int32 = 0 + var minimumEdition: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct mixins { + struct minor: Sendable { // 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 mixins: Int32 = 0 + var minor: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct modifier { + struct mixins: Sendable { // 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 modifier: Int32 = 0 + var mixins: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct modify { + struct modify: Sendable { // 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. @@ -6427,7 +7795,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct month { + struct month: Sendable { // 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. @@ -6439,7 +7807,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct msgExtension { + struct msgExtension: Sendable { // 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. @@ -6451,7 +7819,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct mutating { + struct mutating: Sendable { // 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. @@ -6463,7 +7831,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct n { + struct n: Sendable { // 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. @@ -6475,7 +7843,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct name { + struct name: Sendable { // 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. @@ -6487,7 +7855,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct NameDescription { + struct NameDescription: Sendable { // 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. @@ -6499,7 +7867,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct NameMap { + struct NameMap: Sendable { // 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. @@ -6511,7 +7879,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct NamePart { + struct NamePart: Sendable { // 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. @@ -6523,127 +7891,127 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct nameResolver { + struct names: Sendable { // 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 nameResolver: Int32 = 0 + var names: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct names { + struct nanos: Sendable { // 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 names: Int32 = 0 + var nanos: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct nanos { + struct negativeIntValue: Sendable { // 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 nanos: Int32 = 0 + var negativeIntValue: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct nativeBytes { + struct nestedType: Sendable { // 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 nativeBytes: Int32 = 0 + var nestedType: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct nativeEndianBytes { + struct newExtensible: Sendable { // 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 nativeEndianBytes: Int32 = 0 + var newExtensible: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct negativeIntValue { + struct newL: Sendable { // 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 negativeIntValue: Int32 = 0 + var newL: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct nestedType { + struct newList: Sendable { // 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 nestedType: Int32 = 0 + var newList: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct newL { + struct newMessage: Sendable { // 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 newL: Int32 = 0 + var newMessage: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct newList { + struct newValue: Sendable { // 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 newList: Int32 = 0 + var newValue: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct newValue { + struct next: Sendable { // 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 newValue: Int32 = 0 + var next: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct nextByte { + struct nextByte: Sendable { // 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. @@ -6655,7 +8023,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct nextFieldNumber { + struct nextFieldNumber: Sendable { // 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. @@ -6667,7 +8035,91 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct nilMessage { + struct nextInstruction: Sendable { + // 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 nextInstruction: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct nextInt32: Sendable { + // 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 nextInt32: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct nextNullTerminatedString: Sendable { + // 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 nextNullTerminatedString: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct nextNullTerminatedStringArray: Sendable { + // 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 nextNullTerminatedStringArray: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct nextNumber: Sendable { + // 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 nextNumber: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct nextUInt64: Sendable { + // 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 nextUint64: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct nextVarInt: Sendable { + // 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 nextVarInt: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct nilMessage: Sendable { // 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. @@ -6679,7 +8131,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct nilLiteral { + struct nilLiteral: Sendable { // 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. @@ -6691,7 +8143,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct noStandardDescriptorAccessor { + struct noBytesAvailable: Sendable { + // 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 noBytesAvailable: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct noStandardDescriptorAccessor: Sendable { // 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. @@ -6703,7 +8167,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct nullValue { + struct nullValue: Sendable { // 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. @@ -6715,7 +8179,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct number { + struct number: Sendable { // 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. @@ -6727,7 +8191,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct numberValue { + struct numberValue: Sendable { // 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. @@ -6739,7 +8203,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct objcClassPrefix { + struct objcClassPrefix: Sendable { // 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. @@ -6751,7 +8215,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct of { + struct of: Sendable { // 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. @@ -6763,31 +8227,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct oneofDecl { + struct OneOf_Kind: Sendable { // 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 oneofDecl: Int32 = 0 + var oneOfKind: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct OneofDescriptorProto { + struct oneofDecl: Sendable { // 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 oneofDescriptorProto: Int32 = 0 + var oneofDecl: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct oneofIndex { + struct oneofIndex: Sendable { // 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. @@ -6799,139 +8263,139 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct OneofOptions { + struct oneofs: Sendable { // 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 oneofOptions: Int32 = 0 + var oneofs: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct oneofs { + struct optimizeFor: Sendable { // 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 oneofs: Int32 = 0 + var optimizeFor: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct OneOf_Kind { + struct OptimizeMode: Sendable { // 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 oneOfKind: Int32 = 0 + var optimizeMode: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct optimizeFor { + struct OptionalEnumExtensionField: Sendable { // 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 optimizeFor: Int32 = 0 + var optionalEnumExtensionField: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct OptimizeMode { + struct OptionalExtensionField: Sendable { // 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 optimizeMode: Int32 = 0 + var optionalExtensionField: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct Option { + struct OptionalGroupExtensionField: Sendable { // 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 option: Int32 = 0 + var optionalGroupExtensionField: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct OptionalEnumExtensionField { + struct OptionalMessageExtensionField: Sendable { // 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 optionalEnumExtensionField: Int32 = 0 + var optionalMessageExtensionField: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct OptionalExtensionField { + struct optionDependency: Sendable { // 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 optionalExtensionField: Int32 = 0 + var optionDependency: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct OptionalGroupExtensionField { + struct OptionRetention: Sendable { // 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 optionalGroupExtensionField: Int32 = 0 + var optionRetention: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct OptionalMessageExtensionField { + struct options: Sendable { // 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 optionalMessageExtensionField: Int32 = 0 + var options: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct options { + struct OptionTargetType: Sendable { // 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 options: Int32 = 0 + var optionTargetType: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct other { + struct other: Sendable { // 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. @@ -6943,7 +8407,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct others { + struct others: Sendable { // 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. @@ -6955,7 +8419,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct out { + struct out: Sendable { // 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. @@ -6967,7 +8431,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct outputType { + struct outputType: Sendable { // 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. @@ -6979,7 +8443,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct p { + struct overridableFeatures: Sendable { + // 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 overridableFeatures: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct p: Sendable { // 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. @@ -6991,7 +8467,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct package { + struct package: Sendable { // 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. @@ -7003,7 +8479,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct packed { + struct packed: Sendable { // 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. @@ -7015,7 +8491,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct PackedEnumExtensionField { + struct PackedEnumExtensionField: Sendable { // 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. @@ -7027,7 +8503,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct PackedExtensionField { + struct PackedExtensionField: Sendable { // 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. @@ -7039,7 +8515,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct padding { + struct padding: Sendable { // 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. @@ -7051,7 +8527,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct parent { + struct parent: Sendable { // 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. @@ -7063,7 +8539,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct parse { + struct parse: Sendable { // 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. @@ -7075,7 +8551,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct partial { + struct partial: Sendable { // 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. @@ -7087,7 +8563,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct path { + struct path: Sendable { // 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. @@ -7099,103 +8575,115 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct paths { + struct PathDecoder: Sendable { // 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 paths: Int32 = 0 + var pathDecoder: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct payload { + struct PathDecodingError: Sendable { // 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 payload: Int32 = 0 + var pathDecodingError: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct payloadSize { + struct paths: Sendable { // 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 payloadSize: Int32 = 0 + var paths: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct phpClassPrefix { + struct PathVisitor: Sendable { // 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 phpClassPrefix: Int32 = 0 + var pathVisitor: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct payload: Sendable { + // 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 payload: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct phpGenericServices { + struct payloadSize: Sendable { // 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 phpGenericServices: Int32 = 0 + var payloadSize: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct phpMetadataNamespace { + struct phpClassPrefix: Sendable { // 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 phpMetadataNamespace: Int32 = 0 + var phpClassPrefix: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct phpNamespace { + struct phpMetadataNamespace: Sendable { // 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 phpNamespace: Int32 = 0 + var phpMetadataNamespace: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct pointer { + struct phpNamespace: Sendable { // 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 pointer: Int32 = 0 + var phpNamespace: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct pos { + struct pos: Sendable { // 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. @@ -7207,7 +8695,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct positiveIntValue { + struct positiveIntValue: Sendable { // 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. @@ -7219,7 +8707,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct prefix { + struct prefix: Sendable { // 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. @@ -7231,7 +8719,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct preserveProtoFieldNames { + struct preserveProtoFieldNames: Sendable { // 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. @@ -7243,7 +8731,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct preTraverse { + struct preTraverse: Sendable { // 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. @@ -7255,7 +8743,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct printUnknownFields { + struct previousNumber: Sendable { + // 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 previousNumber: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct prevPath: Sendable { + // 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 prevPath: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct printUnknownFields: Sendable { // 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. @@ -7267,7 +8779,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct proto2 { + struct programBuffer: Sendable { + // 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 programBuffer: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct programFormat: Sendable { + // 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 programFormat: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct proto2: Sendable { // 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. @@ -7279,7 +8815,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct proto3DefaultValue { + struct proto3DefaultValue: Sendable { // 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. @@ -7291,7 +8827,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct proto3Optional { + struct proto3Optional: Sendable { // 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. @@ -7303,331 +8839,343 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ProtobufAPIVersionCheck { + struct protobuf_extensionFieldValues: Sendable { // 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 protobufApiversionCheck: Int32 = 0 + var protobufExtensionFieldValues: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufAPIVersion_2 { + struct protobuf_fieldNumber: Sendable { // 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 protobufApiversion2: Int32 = 0 + var protobufFieldNumber: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufBool { + struct protobuf_generated_isEqualTo: Sendable { // 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 protobufBool: Int32 = 0 + var protobufGeneratedIsEqualTo: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufBytes { + struct protobuf_nameMap: Sendable { // 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 protobufBytes: Int32 = 0 + var protobufNameMap: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufDouble { + struct protobuf_newField: Sendable { // 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 protobufDouble: Int32 = 0 + var protobufNewField: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufEnumMap { + struct protobuf_package: Sendable { // 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 protobufEnumMap: Int32 = 0 + var protobufPackage: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct protobufExtension { + struct ProtobufAPIVersion_2: Sendable { // 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 protobufExtension: Int32 = 0 + var protobufApiversion2: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufFixed32 { + struct ProtobufAPIVersionCheck: Sendable { // 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 protobufFixed32: Int32 = 0 + var protobufApiversionCheck: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufFixed64 { + struct ProtobufBool: Sendable { // 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 protobufFixed64: Int32 = 0 + var protobufBool: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufFloat { + struct ProtobufBytes: Sendable { // 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 protobufFloat: Int32 = 0 + var protobufBytes: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufInt32 { + struct protobufData: Sendable { // 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 protobufInt32: Int32 = 0 + var protobufData: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufInt64 { + struct ProtobufDouble: Sendable { // 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 protobufInt64: Int32 = 0 + var protobufDouble: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufMap { + struct ProtobufEnumMap: Sendable { // 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 protobufMap: Int32 = 0 + var protobufEnumMap: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufMessageMap { + struct protobufExtension: Sendable { // 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 protobufMessageMap: Int32 = 0 + var protobufExtension: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufSFixed32 { + struct ProtobufFixed32: Sendable { // 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 protobufSfixed32: Int32 = 0 + var protobufFixed32: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufSFixed64 { + struct ProtobufFixed64: Sendable { // 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 protobufSfixed64: Int32 = 0 + var protobufFixed64: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufSInt32 { + struct ProtobufFloat: Sendable { // 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 protobufSint32: Int32 = 0 + var protobufFloat: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufSInt64 { + struct ProtobufInt32: Sendable { // 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 protobufSint64: Int32 = 0 + var protobufInt32: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufString { + struct ProtobufInt64: Sendable { // 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 protobufString: Int32 = 0 + var protobufInt64: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufUInt32 { + struct ProtobufMap: Sendable { // 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 protobufUint32: Int32 = 0 + var protobufMap: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ProtobufUInt64 { + struct ProtobufMessageMap: Sendable { // 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 protobufUint64: Int32 = 0 + var protobufMessageMap: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct protobuf_extensionFieldValues { + struct ProtobufSFixed32: Sendable { // 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 protobufExtensionFieldValues: Int32 = 0 + var protobufSfixed32: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct protobuf_fieldNumber { + struct ProtobufSFixed64: Sendable { // 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 protobufFieldNumber: Int32 = 0 + var protobufSfixed64: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct protobuf_generated_isEqualTo { + struct ProtobufSInt32: Sendable { // 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 protobufGeneratedIsEqualTo: Int32 = 0 + var protobufSint32: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct protobuf_nameMap { + struct ProtobufSInt64: Sendable { // 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 protobufNameMap: Int32 = 0 + var protobufSint64: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct protobuf_newField { + struct ProtobufString: Sendable { // 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 protobufNewField: Int32 = 0 + var protobufString: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct protobuf_package { + struct ProtobufUInt32: Sendable { // 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 protobufPackage: Int32 = 0 + var protobufUint32: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct ProtobufUInt64: Sendable { + // 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 protobufUint64: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct protocolMessage { + struct protocolMessage: Sendable { // 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. @@ -7639,7 +9187,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct protoFieldName { + struct protoFieldName: Sendable { // 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. @@ -7651,7 +9199,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct protoMessageNameMessage { + struct protoMessageNameMessage: Sendable { // 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. @@ -7663,7 +9211,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ProtoNameProviding { + struct ProtoNameProviding: Sendable { // 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. @@ -7675,7 +9223,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct protoPaths { + struct protoPaths: Sendable { // 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. @@ -7687,7 +9235,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct publicMessage { + struct publicMessage: Sendable { // 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. @@ -7699,7 +9247,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct publicDependency { + struct publicDependency: Sendable { // 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. @@ -7711,7 +9259,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putBoolValue { + struct putBoolValue: Sendable { // 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. @@ -7723,7 +9271,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putBytesValue { + struct putBytesValue: Sendable { // 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. @@ -7735,7 +9283,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putDoubleValue { + struct putDoubleValue: Sendable { // 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. @@ -7747,7 +9295,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putEnumValue { + struct putEnumValue: Sendable { // 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. @@ -7759,7 +9307,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putFixedUInt32 { + struct putFixedUInt32: Sendable { // 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. @@ -7771,7 +9319,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putFixedUInt64 { + struct putFixedUInt64: Sendable { // 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. @@ -7783,7 +9331,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putFloatValue { + struct putFloatValue: Sendable { // 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. @@ -7795,7 +9343,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putInt64 { + struct putInt64: Sendable { // 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. @@ -7807,7 +9355,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putStringValue { + struct putStringValue: Sendable { // 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. @@ -7819,7 +9367,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putUInt64 { + struct putUInt64: Sendable { // 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. @@ -7831,7 +9379,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putUInt64Hex { + struct putUInt64Hex: Sendable { // 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. @@ -7843,7 +9391,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putVarInt { + struct putVarInt: Sendable { // 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. @@ -7855,7 +9403,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct putZigZagVarInt { + struct putZigZagVarInt: Sendable { // 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. @@ -7867,7 +9415,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct pyGenericServices { + struct pyGenericServices: Sendable { // 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. @@ -7879,7 +9427,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct rawChars { + struct R: Sendable { + // 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 r: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct rawChars: Sendable { // 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. @@ -7891,7 +9451,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct RawRepresentable { + struct RawRepresentable: Sendable { // 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. @@ -7903,7 +9463,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct RawValue { + struct RawValue: Sendable { // 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. @@ -7915,7 +9475,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct read4HexDigits { + struct read4HexDigits: Sendable { // 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. @@ -7927,7 +9487,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct register { + struct readBytes: Sendable { + // 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 readBytes: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct reader: Sendable { + // 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 reader: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct register: Sendable { // 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. @@ -7939,7 +9523,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct RepeatedEnumExtensionField { + struct remainingProgram: Sendable { + // 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 remainingProgram: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct removalError: Sendable { + // 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 removalError: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct removingAllFieldsOf: Sendable { + // 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 removingAllFieldsOf: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct repeated: Sendable { + // 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 repeated: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct RepeatedEnumExtensionField: Sendable { // 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. @@ -7951,7 +9583,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct RepeatedExtensionField { + struct RepeatedExtensionField: Sendable { // 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. @@ -7963,7 +9595,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct RepeatedGroupExtensionField { + struct repeatedFieldEncoding: Sendable { + // 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 repeatedFieldEncoding: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct RepeatedGroupExtensionField: Sendable { // 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. @@ -7975,7 +9619,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct RepeatedMessageExtensionField { + struct RepeatedMessageExtensionField: Sendable { // 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. @@ -7987,67 +9631,67 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct requestStreaming { + struct repeating: Sendable { // 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 requestStreaming: Int32 = 0 + var repeating: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct requestTypeURL { + struct replaceRepeatedFields: Sendable { // 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 requestTypeURL: Int32 = 0 + var replaceRepeatedFields: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct requiredSize { + struct requestStreaming: Sendable { // 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 requiredSize: Int32 = 0 + var requestStreaming: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct reservedName { + struct requestTypeURL: Sendable { // 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 reservedName: Int32 = 0 + var requestTypeURL: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct reservedRange { + struct requiredSize: Sendable { // 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 reservedRange: Int32 = 0 + var requiredSize: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct responseStreaming { + struct responseStreaming: Sendable { // 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. @@ -8059,7 +9703,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct responseTypeURL { + struct responseTypeURL: Sendable { // 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. @@ -8071,7 +9715,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct result { + struct result: Sendable { // 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. @@ -8083,31 +9727,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct rethrowsMessage { + struct retention: Sendable { // 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 `rethrows`: Int32 = 0 + var retention: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct returnMessage { + struct rethrowsMessage: Sendable { // 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 `return`: Int32 = 0 + var `rethrows`: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ReturnType { + struct ReturnType: Sendable { // 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. @@ -8119,7 +9763,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct revision { + struct revision: Sendable { // 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. @@ -8131,7 +9775,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct rhs { + struct rhs: Sendable { // 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. @@ -8143,7 +9787,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct root { + struct root: Sendable { // 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. @@ -8155,7 +9799,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct rubyPackage { + struct rubyPackage: Sendable { // 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. @@ -8167,7 +9811,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct s { + struct s: Sendable { // 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. @@ -8179,7 +9823,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct sawBackslash { + struct sawBackslash: Sendable { // 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. @@ -8191,7 +9835,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct sawSection4Characters { + struct sawSection4Characters: Sendable { // 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. @@ -8203,7 +9847,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct sawSection5Characters { + struct sawSection5Characters: Sendable { // 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. @@ -8215,7 +9859,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct scanner { + struct Scalar: Sendable { + // 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 scalar: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct scan: Sendable { + // 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 scan: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct scanner: Sendable { // 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. @@ -8227,7 +9895,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct seconds { + struct seconds: Sendable { // 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. @@ -8239,7 +9907,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct selfMessage { + struct selfMessage: Sendable { // 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. @@ -8251,103 +9919,115 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct separator { + struct semantic: Sendable { // 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 separator: Int32 = 0 + var semantic: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct serialize { + struct SendableMessage: Sendable { // 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 serialize: Int32 = 0 + var sendable: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct serializedData { + struct separator: Sendable { // 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 serializedData: Int32 = 0 + var separator: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct serializedSize { + struct serialize: Sendable { // 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 serializedSize: Int32 = 0 + var serialize: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct serverStreaming { + struct serializedBytes: Sendable { // 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 serverStreaming: Int32 = 0 + var serializedBytes: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct service { + struct serializedData: Sendable { // 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 service: Int32 = 0 + var serializedData: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct serializedSize: Sendable { + // 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 serializedSize: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ServiceDescriptorProto { + struct serverStreaming: Sendable { // 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 serviceDescriptorProto: Int32 = 0 + var serverStreaming: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct ServiceOptions { + struct service: Sendable { // 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 serviceOptions: Int32 = 0 + var service: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct set { + struct set: Sendable { // 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. @@ -8359,7 +10039,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct setExtensionValue { + struct setExtensionValue: Sendable { // 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. @@ -8371,7 +10051,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct shift { + struct shift: Sendable { // 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. @@ -8383,7 +10063,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct SimpleExtensionMap { + struct SimpleExtensionMap: Sendable { // 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. @@ -8395,7 +10075,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct sizer { + struct size: Sendable { + // 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 size: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct sizer: Sendable { // 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. @@ -8407,7 +10099,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct source { + struct source: Sendable { // 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. @@ -8419,7 +10111,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct sourceCodeInfo { + struct sourceCodeInfo: Sendable { // 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. @@ -8431,7 +10123,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct sourceContext { + struct sourceContext: Sendable { // 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. @@ -8443,7 +10135,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct sourceEncoding { + struct sourceEncoding: Sendable { // 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. @@ -8455,7 +10147,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct sourceFile { + struct sourceFile: Sendable { // 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. @@ -8467,7 +10159,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct span { + struct SourceLocation: Sendable { + // 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 sourceLocation: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct span: Sendable { // 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. @@ -8479,7 +10183,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct split { + struct split: Sendable { // 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. @@ -8491,7 +10195,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct start { + struct start: Sendable { // 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. @@ -8503,7 +10207,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct startArray { + struct startArray: Sendable { // 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. @@ -8515,7 +10219,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct startArrayObject { + struct startArrayObject: Sendable { // 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. @@ -8527,7 +10231,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct startField { + struct startField: Sendable { // 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. @@ -8539,7 +10243,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct startIndex { + struct startIndex: Sendable { // 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. @@ -8551,7 +10255,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct startMessageField { + struct startMessageField: Sendable { // 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. @@ -8563,7 +10267,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct startObject { + struct startObject: Sendable { // 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. @@ -8575,7 +10279,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct startRegularField { + struct startRegularField: Sendable { // 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. @@ -8587,7 +10291,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct state { + struct state: Sendable { // 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. @@ -8599,7 +10303,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct staticMessage { + struct staticMessage: Sendable { // 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. @@ -8611,7 +10315,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct StaticString { + struct StaticString: Sendable { // 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. @@ -8623,7 +10327,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct storage { + struct storage: Sendable { // 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. @@ -8635,7 +10339,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct StringMessage { + struct StringMessage: Sendable { // 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. @@ -8647,7 +10351,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct stringLiteral { + struct stringLiteral: Sendable { // 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. @@ -8659,7 +10363,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct StringLiteralType { + struct StringLiteralType: Sendable { // 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. @@ -8671,7 +10375,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct stringResult { + struct stringResult: Sendable { // 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. @@ -8683,7 +10387,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct stringValue { + struct stringValue: Sendable { // 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. @@ -8695,7 +10399,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct structMessage { + struct structMessage: Sendable { // 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. @@ -8707,7 +10411,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct structValue { + struct structValue: Sendable { // 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. @@ -8719,7 +10423,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct subDecoder { + struct subDecoder: Sendable { // 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. @@ -8731,7 +10435,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct subscriptMessage { + struct subscriptMessage: Sendable { // 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. @@ -8743,7 +10447,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct subVisitor { + struct subtract: Sendable { + // 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 subtract: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct subVisitor: Sendable { // 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. @@ -8755,7 +10471,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Swift { + struct SwiftMessage: Sendable { // 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. @@ -8767,7 +10483,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct swiftPrefix { + struct swiftPrefix: Sendable { // 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. @@ -8779,19 +10495,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct SwiftProtobufMessage { + struct SwiftProtobufContiguousBytes: Sendable { // 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 swiftProtobuf: Int32 = 0 + var swiftProtobufContiguousBytes: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct syntax { + struct SwiftProtobufError: Sendable { + // 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 swiftProtobufError: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct syntax: Sendable { // 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. @@ -8803,7 +10531,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct T { + struct T: Sendable { // 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. @@ -8815,7 +10543,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct tag { + struct tag: Sendable { // 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. @@ -8827,7 +10555,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct terminator { + struct targets: Sendable { + // 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 targets: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct terminator: Sendable { // 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. @@ -8839,7 +10579,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct testDecoder { + struct testDecoder: Sendable { // 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. @@ -8851,7 +10591,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct text { + struct text: Sendable { // 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. @@ -8863,7 +10603,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct textDecoder { + struct textDecoder: Sendable { // 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. @@ -8875,7 +10615,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct TextFormatDecoder { + struct TextFormatDecoder: Sendable { // 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. @@ -8887,7 +10627,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct TextFormatDecodingError { + struct TextFormatDecodingError: Sendable { // 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. @@ -8899,7 +10639,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct TextFormatDecodingOptions { + struct TextFormatDecodingOptions: Sendable { // 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. @@ -8911,7 +10651,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct TextFormatEncodingOptions { + struct TextFormatEncodingOptions: Sendable { // 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. @@ -8923,7 +10663,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct TextFormatEncodingVisitor { + struct TextFormatEncodingVisitor: Sendable { // 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. @@ -8935,7 +10675,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct textFormatString { + struct textFormatString: Sendable { // 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. @@ -8947,7 +10687,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct throwsMessage { + struct throwOrIgnore: Sendable { + // 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 throwOrIgnore: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct throwsMessage: Sendable { // 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. @@ -8959,7 +10711,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct timeInterval { + struct timeInterval: Sendable { // 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. @@ -8971,7 +10723,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct timeIntervalSince1970 { + struct timeIntervalSince1970: Sendable { // 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. @@ -8983,7 +10735,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct timeIntervalSinceReferenceDate { + struct timeIntervalSinceReferenceDate: Sendable { // 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. @@ -8995,19 +10747,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Timestamp { + struct tmp: Sendable { // 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 timestamp: Int32 = 0 + var tmp: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct total { + struct tooLarge: Sendable { + // 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 tooLarge: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct total: Sendable { // 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. @@ -9019,7 +10783,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct totalArrayDepth { + struct totalArrayDepth: Sendable { // 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. @@ -9031,7 +10795,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct totalSize { + struct totalSize: Sendable { // 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. @@ -9043,7 +10807,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct trailingComments { + struct trailingComments: Sendable { // 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. @@ -9055,7 +10819,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct traverseMessage { + struct traverseMessage: Sendable { // 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. @@ -9067,7 +10831,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct trueMessage { + struct trim: Sendable { + // 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 trim: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct trueMessage: Sendable { // 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. @@ -9079,7 +10855,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct tryMessage { + struct tryMessage: Sendable { // 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. @@ -9091,7 +10867,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct type { + struct type: Sendable { // 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. @@ -9103,7 +10879,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct typealiasMessage { + struct typealiasMessage: Sendable { // 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. @@ -9115,7 +10891,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct TypeEnum { + struct TypeEnum: Sendable { // 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. @@ -9127,7 +10903,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct typeName { + struct typeName: Sendable { // 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. @@ -9139,7 +10915,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct typePrefix { + struct typePrefix: Sendable { // 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. @@ -9151,7 +10927,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct typeStart { + struct typeStart: Sendable { // 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. @@ -9163,7 +10939,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct typeUnknown { + struct typeUnknown: Sendable { // 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. @@ -9175,7 +10951,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct typeURL { + struct typeURL: Sendable { // 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. @@ -9187,7 +10963,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UInt32Message { + struct UInt32Message: Sendable { // 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. @@ -9199,55 +10975,55 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UInt32Value { + struct UInt64Message: Sendable { // 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 uint32Value: Int32 = 0 + var uint64: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct UInt64Message { + struct UInt8: Sendable { // 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 uint64: Int32 = 0 + var uint8: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct UInt64Value { + struct unchecked: Sendable { // 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 uint64Value: Int32 = 0 + var unchecked: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct UInt8 { + struct Unicode: Sendable { // 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 uint8: Int32 = 0 + var unicode: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct unicodeScalarLiteral { + struct unicodeScalarLiteral: Sendable { // 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. @@ -9259,7 +11035,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UnicodeScalarLiteralType { + struct UnicodeScalarLiteralType: Sendable { // 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. @@ -9271,7 +11047,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct unicodeScalars { + struct unicodeScalars: Sendable { // 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. @@ -9283,7 +11059,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UnicodeScalarView { + struct UnicodeScalarView: Sendable { // 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. @@ -9295,7 +11071,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct uninterpretedOption { + struct uninterpretedOption: Sendable { // 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. @@ -9307,7 +11083,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct union { + struct union: Sendable { // 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. @@ -9319,7 +11095,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct uniqueStorage { + struct uniqueStorage: Sendable { // 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. @@ -9331,7 +11107,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct unknown { + struct unknown: Sendable { // 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. @@ -9343,7 +11119,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct unknownFieldsMessage { + struct unknownFieldsMessage: Sendable { // 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. @@ -9355,7 +11131,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UnknownStorage { + struct UnknownStorage: Sendable { // 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. @@ -9367,7 +11143,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct unpackTo { + struct unpackTo: Sendable { // 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. @@ -9379,7 +11155,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UnsafeBufferPointer { + struct UnsafeBufferPointer: Sendable { // 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. @@ -9391,7 +11167,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UnsafeMutablePointer { + struct UnsafeMutablePointer: Sendable { // 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. @@ -9403,7 +11179,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UnsafeMutableRawBufferPointer { + struct UnsafeMutableRawBufferPointer: Sendable { // 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. @@ -9415,43 +11191,43 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UnsafeMutableRawPointer { + struct UnsafeRawBufferPointer: Sendable { // 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 unsafeMutableRawPointer: Int32 = 0 + var unsafeRawBufferPointer: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct UnsafeRawBufferPointer { + struct UnsafeRawPointer: Sendable { // 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 unsafeRawBufferPointer: Int32 = 0 + var unsafeRawPointer: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct UnsafeRawPointer { + struct unverifiedLazy: Sendable { // 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 unsafeRawPointer: Int32 = 0 + var unverifiedLazy: Int32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } - struct updatedOptions { + struct updatedOptions: Sendable { // 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. @@ -9463,7 +11239,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct url { + struct uppercasedAssumingASCII: Sendable { + // 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 uppercasedAssumingAscii: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct url: Sendable { // 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. @@ -9475,7 +11263,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct utf8 { + struct useDeterministicOrdering: Sendable { + // 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 useDeterministicOrdering: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct utf8: Sendable { // 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. @@ -9487,7 +11287,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct utf8Ptr { + struct utf8Ptr: Sendable { // 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. @@ -9499,7 +11299,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct utf8ToDouble { + struct utf8ToDouble: Sendable { // 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. @@ -9511,7 +11311,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct UTF8View { + struct utf8Validation: Sendable { + // 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 utf8Validation: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct UTF8View: Sendable { // 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. @@ -9523,7 +11335,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct v { + struct V: Sendable { // 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. @@ -9535,7 +11347,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct value { + struct value: Sendable { // 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. @@ -9547,7 +11359,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct valueField { + struct valueField: Sendable { // 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. @@ -9559,7 +11371,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct values { + struct values: Sendable { // 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. @@ -9571,7 +11383,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct ValueType { + struct ValueType: Sendable { // 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. @@ -9583,7 +11395,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct varMessage { + struct varMessage: Sendable { // 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. @@ -9595,7 +11407,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct Version { + struct verification: Sendable { + // 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 verification: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct VerificationState: Sendable { + // 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 verificationState: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct version: Sendable { // 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. @@ -9607,7 +11443,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct versionString { + struct versionString: Sendable { // 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. @@ -9619,7 +11455,31 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitExtensionFields { + struct visibility: Sendable { + // 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 visibility: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct VisibilityFeature: Sendable { + // 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 visibilityFeature: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct visitExtensionFields: Sendable { // 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. @@ -9631,7 +11491,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitExtensionFieldsAsMessageSet { + struct visitExtensionFieldsAsMessageSet: Sendable { // 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. @@ -9643,7 +11503,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitMapField { + struct visitMapField: Sendable { // 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. @@ -9655,7 +11515,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitor { + struct Visitor: Sendable { // 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. @@ -9667,7 +11527,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPacked { + struct visitPacked: Sendable { // 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. @@ -9679,7 +11539,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedBoolField { + struct visitPackedBoolField: Sendable { // 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. @@ -9691,7 +11551,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedDoubleField { + struct visitPackedDoubleField: Sendable { // 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. @@ -9703,7 +11563,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedEnumField { + struct visitPackedEnumField: Sendable { // 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. @@ -9715,7 +11575,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedFixed32Field { + struct visitPackedFixed32Field: Sendable { // 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. @@ -9727,7 +11587,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedFixed64Field { + struct visitPackedFixed64Field: Sendable { // 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. @@ -9739,7 +11599,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedFloatField { + struct visitPackedFloatField: Sendable { // 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. @@ -9751,7 +11611,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedInt32Field { + struct visitPackedInt32Field: Sendable { // 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. @@ -9763,7 +11623,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedInt64Field { + struct visitPackedInt64Field: Sendable { // 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. @@ -9775,7 +11635,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedSFixed32Field { + struct visitPackedSFixed32Field: Sendable { // 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. @@ -9787,7 +11647,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedSFixed64Field { + struct visitPackedSFixed64Field: Sendable { // 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. @@ -9799,7 +11659,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedSInt32Field { + struct visitPackedSInt32Field: Sendable { // 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. @@ -9811,7 +11671,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedSInt64Field { + struct visitPackedSInt64Field: Sendable { // 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. @@ -9823,7 +11683,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedUInt32Field { + struct visitPackedUInt32Field: Sendable { // 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. @@ -9835,7 +11695,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitPackedUInt64Field { + struct visitPackedUInt64Field: Sendable { // 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. @@ -9847,7 +11707,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeated { + struct visitRepeated: Sendable { // 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. @@ -9859,7 +11719,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedBoolField { + struct visitRepeatedBoolField: Sendable { // 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. @@ -9871,7 +11731,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedBytesField { + struct visitRepeatedBytesField: Sendable { // 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. @@ -9883,7 +11743,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedDoubleField { + struct visitRepeatedDoubleField: Sendable { // 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. @@ -9895,7 +11755,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedEnumField { + struct visitRepeatedEnumField: Sendable { // 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. @@ -9907,7 +11767,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedFixed32Field { + struct visitRepeatedFixed32Field: Sendable { // 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. @@ -9919,7 +11779,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedFixed64Field { + struct visitRepeatedFixed64Field: Sendable { // 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. @@ -9931,7 +11791,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedFloatField { + struct visitRepeatedFloatField: Sendable { // 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. @@ -9943,7 +11803,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedGroupField { + struct visitRepeatedGroupField: Sendable { // 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. @@ -9955,7 +11815,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedInt32Field { + struct visitRepeatedInt32Field: Sendable { // 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. @@ -9967,7 +11827,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedInt64Field { + struct visitRepeatedInt64Field: Sendable { // 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. @@ -9979,7 +11839,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedMessageField { + struct visitRepeatedMessageField: Sendable { // 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. @@ -9991,7 +11851,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedSFixed32Field { + struct visitRepeatedSFixed32Field: Sendable { // 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. @@ -10003,7 +11863,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedSFixed64Field { + struct visitRepeatedSFixed64Field: Sendable { // 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. @@ -10015,7 +11875,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedSInt32Field { + struct visitRepeatedSInt32Field: Sendable { // 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. @@ -10027,7 +11887,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedSInt64Field { + struct visitRepeatedSInt64Field: Sendable { // 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. @@ -10039,7 +11899,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedStringField { + struct visitRepeatedStringField: Sendable { // 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. @@ -10051,7 +11911,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedUInt32Field { + struct visitRepeatedUInt32Field: Sendable { // 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. @@ -10063,7 +11923,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitRepeatedUInt64Field { + struct visitRepeatedUInt64Field: Sendable { // 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. @@ -10075,7 +11935,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingular { + struct visitSingular: Sendable { // 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. @@ -10087,7 +11947,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularBoolField { + struct visitSingularBoolField: Sendable { // 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. @@ -10099,7 +11959,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularBytesField { + struct visitSingularBytesField: Sendable { // 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. @@ -10111,7 +11971,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularDoubleField { + struct visitSingularDoubleField: Sendable { // 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. @@ -10123,7 +11983,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularEnumField { + struct visitSingularEnumField: Sendable { // 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. @@ -10135,7 +11995,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularFixed32Field { + struct visitSingularFixed32Field: Sendable { // 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. @@ -10147,7 +12007,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularFixed64Field { + struct visitSingularFixed64Field: Sendable { // 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. @@ -10159,7 +12019,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularFloatField { + struct visitSingularFloatField: Sendable { // 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. @@ -10171,7 +12031,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularGroupField { + struct visitSingularGroupField: Sendable { // 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. @@ -10183,7 +12043,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularInt32Field { + struct visitSingularInt32Field: Sendable { // 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. @@ -10195,7 +12055,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularInt64Field { + struct visitSingularInt64Field: Sendable { // 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. @@ -10207,7 +12067,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularMessageField { + struct visitSingularMessageField: Sendable { // 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. @@ -10219,7 +12079,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularSFixed32Field { + struct visitSingularSFixed32Field: Sendable { // 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. @@ -10231,7 +12091,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularSFixed64Field { + struct visitSingularSFixed64Field: Sendable { // 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. @@ -10243,7 +12103,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularSInt32Field { + struct visitSingularSInt32Field: Sendable { // 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. @@ -10255,7 +12115,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularSInt64Field { + struct visitSingularSInt64Field: Sendable { // 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. @@ -10267,7 +12127,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularStringField { + struct visitSingularStringField: Sendable { // 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. @@ -10279,7 +12139,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularUInt32Field { + struct visitSingularUInt32Field: Sendable { // 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. @@ -10291,7 +12151,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitSingularUInt64Field { + struct visitSingularUInt64Field: Sendable { // 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. @@ -10303,7 +12163,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct visitUnknown { + struct visitUnknown: Sendable { // 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. @@ -10315,7 +12175,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct wasDecoded { + struct Void: Sendable { + // 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 void: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct wasDecoded: Sendable { // 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. @@ -10327,7 +12199,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct weak { + struct weak: Sendable { // 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. @@ -10339,7 +12211,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct weakDependency { + struct weakDependency: Sendable { // 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. @@ -10351,7 +12223,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct whereMessage { + struct whereMessage: Sendable { // 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. @@ -10363,7 +12235,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct wireFormat { + struct wireFormat: Sendable { // 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. @@ -10375,7 +12247,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct with { + struct with: Sendable { // 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. @@ -10387,7 +12259,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct withUnsafeBytes { + struct withUnsafeBytes: Sendable { // 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. @@ -10399,7 +12271,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct withUnsafeMutableBytes { + struct withUnsafeMutableBytes: Sendable { // 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. @@ -10411,7 +12283,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct work { + struct work: Sendable { // 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. @@ -10423,7 +12295,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct WrappedType { + struct Wrapped: Sendable { + // 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 wrapped: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct WrappedType: Sendable { // 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. @@ -10435,7 +12319,19 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct written { + struct wrappedValue: Sendable { + // 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 wrappedValue: Int32 = 0 + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + struct written: Sendable { // 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. @@ -10447,7 +12343,7 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } - struct yday { + struct yday: Sendable { // 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. @@ -10462,907 +12358,62 @@ struct ProtobufUnittestGenerated_GeneratedSwiftReservedMessages { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.adjusted: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.aggregateValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allCases: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allowAlias: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.alwaysPrintEnumsAsInts: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.annotation: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.any: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageStorage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyUnpackError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Api: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appended: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUIntHex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUnknown: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.areAllInitialized: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.array: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayDepth: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arraySeparator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiOpenCurlyBracket: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiZero: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.available: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.b: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.base64Values: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.baseAddress: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BaseType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.begin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binary: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDelimited: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetSizeVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingSizeVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binaryOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.body: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BoolMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.booleanLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BooleanLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.boolValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesInGroup: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesRead: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BytesValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.c: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.capitalizeNext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.cardinality: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccEnableArenas: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Character: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.chars: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.classMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAggregateValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAllowAlias: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearBegin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcEnableArenas: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearClientStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCsharpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCtype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDefaultValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDeprecated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDoubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearEnd: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtendee: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtensionValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearGoPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdempotencyLevel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdentifierValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearInputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIsExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGenerateEqualsAndHash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaMultipleFiles: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaOuterClassname: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaStringCheckUtf8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJsonName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJstype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLabel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLazy: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLeadingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMapEntry: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMessageSetWireFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNamePart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNegativeIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNoStandardDescriptorAccessor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearObjcClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOneofIndex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptimizeFor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOutputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPacked: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpMetadataNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPositiveIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearProto3Optional: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPyGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearRubyPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearServerStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceContext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceFile: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSwiftPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSyntax: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTrailingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTypeName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearWeak: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clientStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codePoint: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codeUnits: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Collection: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.com: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.comma: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.contentsOf: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ContiguousBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.count: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.countVarintsInBuffer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.csharpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ctype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.customCodable: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.CustomDebugStringConvertible: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.d: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DataMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dataResult: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.date: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daySec: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daysSinceEpoch: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.debugDescriptionMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoded: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodedFromJSONNull: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensionFieldsAsMessageSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeJSON: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMapField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMessageMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedBytesField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedGroupField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedStringField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingular: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularBytesField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularGroupField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularStringField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeTextFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultAnyTypeURLPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dependency: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.deprecated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.descriptionMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Dictionary: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dictionaryLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit0: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit1: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitCount: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digits: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardableResult: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardUnknownFields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.distance: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.double: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.doubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Duration: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.E: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Element: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.elements: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitExtensionFieldName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Empty: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emptyData: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeAsBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoded: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedJSONString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.end: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endArray: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endObject: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endRegularField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumReservedRange: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumvalue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Equatable: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Error: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleByArrayLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleByDictionaryLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendedGraphemeClusterLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtendedGraphemeClusterLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendee: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensibleMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionFieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionFieldValueSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionRange: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionRangeOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extras: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.F: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.falseMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldData: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldMask: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNameCount: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumberForProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldTag: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.file: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescriptorSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fileName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.filter: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.first: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.firstItem: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.float: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.floatLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forMessageName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.formUnion: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forReadingFrom: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forTypeURL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ForwardParser: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forWritingInto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.from: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii2: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii4: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromByteOffset: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromHexDigit: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.funcMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.G: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.GeneratedCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.get: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.getExtensionValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.googleapis: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Any: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Api: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_BoolValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_BytesValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_DescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_DoubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Duration: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Empty: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Enum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ExtensionRangeOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldMask: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FloatValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_GeneratedCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Int32Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Int64Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ListValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MessageOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Method: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Mixin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_NullValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Option: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceContext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_StringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Struct: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Syntax: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Timestamp: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Type: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt32Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt64Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UninterpretedOption: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.goPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.group: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupFieldNumberStack: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.h: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hadOneofValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.handleConflictingOneOf: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAggregateValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAllowAlias: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasBegin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcEnableArenas: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasClientStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCsharpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCtype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDefaultValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDeprecated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDoubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasEnd: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtendee: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtensionValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasGoPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Hashable: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasher: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hashValueMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.HashVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdempotencyLevel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdentifierValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasInputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIsExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGenerateEqualsAndHash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaMultipleFiles: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaOuterClassname: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaStringCheckUtf8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJsonName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJstype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLabel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLazy: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLeadingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMapEntry: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMessageSetWireFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNamePart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNegativeIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNoStandardDescriptorAccessor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasObjcClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOneofIndex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptimizeFor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOutputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPacked: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpMetadataNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPositiveIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasProto3Optional: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPyGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasRubyPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasServerStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceContext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceFile: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSwiftPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSyntax: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTrailingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTypeName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasWeak: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hour: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.idempotencyLevel: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.identifierValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ifMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ignoreUnknownFields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.index: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.initMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inoutMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.insert: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Message: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Message: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.integerLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntegerLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.intern: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Internal: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.InternalState: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.into: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ints: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isA: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqual: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqualTo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isInitializedMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.itemTagsEncodedSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Iterator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i_2166136261: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenerateEqualsAndHash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaMultipleFiles: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaOuterClassname: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaStringCheckUtf8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonEncoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONMapEncodingVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPath: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPaths: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONScanner: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonText: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonUTF8Data: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jstype: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.k: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Key: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.keyField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.KeyType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.kind: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.l: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.label: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lazy: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingDetachedComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.length: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lessThan: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.letMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lhs: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.list: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listOfMessages: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndian: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndianBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.load: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.localHasher: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.location: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.M: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.major: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.makeIterator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapEntry: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapHash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapKeyType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapNameResolver: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapToMessages: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapValueType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mdayStart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.merge: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.message: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageDepthLimit: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageImplementationBase: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageSetWireFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Method: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.methods: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.minor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Mixin: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mixins: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modifier: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modify: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.month: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.msgExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mutating: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.n: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.name: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameDescription: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NamePart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nameResolver: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.names: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nanos: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeEndianBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.negativeIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nestedType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newList: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextByte: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextFieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.noStandardDescriptorAccessor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nullValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.number: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.numberValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.objcClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.of: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofDecl: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofIndex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofs: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneOf_Kind: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.optimizeFor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptimizeMode: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Option: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalEnumExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalGroupExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalMessageExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.options: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.other: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.others: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.out: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.outputType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.p: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.package: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.packed: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedEnumExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.padding: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parent: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parse: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.partial: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.path: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.paths: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payload: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payloadSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpClassPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpMetadataNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpNamespace: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pos: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.positiveIntValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.prefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preserveProtoFieldNames: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preTraverse: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.printUnknownFields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto2: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3DefaultValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3Optional: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVersionCheck: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVersion_2: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBool: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufDouble: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufEnumMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobufExtension: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFloat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMessageMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixed32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixed64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_extensionFieldValues: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_fieldNumber: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_generated_isEqualTo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_nameMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_newField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_package: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protocolMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoFieldName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageNameMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtoNameProviding: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoPaths: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicDependency: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBoolValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBytesValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putDoubleValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putEnumValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt32: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFloatValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putStringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64Hex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putVarInt: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putZigZagVarInt: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pyGenericServices: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rawChars: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawRepresentable: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.read4HexDigits: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.register: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedEnumExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedGroupExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedMessageExtensionField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestTypeURL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requiredSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedRange: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseTypeURL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.result: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rethrowsMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.returnMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ReturnType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.revision: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rhs: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.root: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rubyPackage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.s: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawBackslash: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection4Characters: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection5Characters: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.scanner: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.seconds: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.selfMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.separator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serialize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedData: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serverStreaming: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.service: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceDescriptorProto: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.set: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.setExtensionValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.shift: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SimpleExtensionMap: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sizer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.source: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceCodeInfo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceContext: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceEncoding: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceFile: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.span: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.split: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.start: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArray: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArrayObject: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startIndex: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startObject: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startRegularField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.state: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.staticMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StaticString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.storage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringResult: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structValue: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subscriptMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Swift: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.swiftPrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SwiftProtobufMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.syntax: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.T: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tag: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.terminator: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.testDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.text: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecoder: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecodingError: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEncodingOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEncodingVisitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textFormatString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.throwsMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeInterval: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalSince1970: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalSinceReferenceDate: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Timestamp: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.total: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalArrayDepth: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalSize: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trailingComments: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.traverseMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trueMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tryMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.type: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typealiasMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TypeEnum: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeName: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typePrefix: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeStart: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeUnknown: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeURL: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt32Message: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt32Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Message: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalarLiteral: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalarLiteralType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalars: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalarView: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uninterpretedOption: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.union: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uniqueStorage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknown: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknownFieldsMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnknownStorage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unpackTo: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeBufferPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutablePointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutableRawBufferPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutableRawPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawBufferPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawPointer: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.updatedOptions: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.url: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8Ptr: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8ToDouble: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UTF8View: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.v: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.value: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.valueField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.values: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ValueType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.varMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Version: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.versionString: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensionFields: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensionFieldsAsMessageSet: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitMapField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitor: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPacked: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedBytesField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedGroupField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedStringField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularBoolField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularBytesField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularDoubleField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularEnumField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFloatField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularGroupField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularMessageField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSFixed32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSFixed64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularStringField: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularUInt32Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularUInt64Field: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitUnknown: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wasDecoded: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weak: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weakDependency: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.whereMessage: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wireFormat: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.with: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeMutableBytes: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.work: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.WrappedType: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.written: @unchecked Sendable {} -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.yday: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest_generated" +fileprivate let _protobuf_package = "swift_proto_testing.generated" -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".GeneratedSwiftReservedMessages" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.addPath: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".addPath" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}addPath\0") + + 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.addPath) }() + default: break + } } } func traverse(visitor: inout V) throws { + if self.addPath != 0 { + try visitor.visitSingularInt32Field(value: self.addPath, fieldNumber: 1) + } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.addPath, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.addPath) -> Bool { + if lhs.addPath != rhs.addPath {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.adjusted: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".adjusted" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "adjusted"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.adjusted: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".adjusted" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}adjusted\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11383,18 +12434,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.adjusted: Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.adjusted, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.adjusted) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.adjusted, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.adjusted) -> Bool { if lhs.adjusted != rhs.adjusted {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.aggregateValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".aggregateValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "aggregateValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.aggregateValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".aggregateValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}aggregateValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11415,18 +12464,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.aggregateValu try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.aggregateValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.aggregateValue) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.aggregateValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.aggregateValue) -> Bool { if lhs.aggregateValue != rhs.aggregateValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allCases: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".allCases" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "allCases"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.allCases: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".allCases" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}allCases\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11447,18 +12494,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allCases: Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allCases, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allCases) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.allCases, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.allCases) -> Bool { if lhs.allCases != rhs.allCases {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allowAlias: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".allowAlias" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "allowAlias"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.allowAlias: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".allowAlias" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}allowAlias\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11479,18 +12524,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allowAlias: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allowAlias, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.allowAlias) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.allowAlias, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.allowAlias) -> Bool { if lhs.allowAlias != rhs.allowAlias {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.alwaysPrintEnumsAsInts: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".alwaysPrintEnumsAsInts" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "alwaysPrintEnumsAsInts"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.alwaysPrintEnumsAsInts: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".alwaysPrintEnumsAsInts" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}alwaysPrintEnumsAsInts\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11511,18 +12554,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.alwaysPrintEn try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.alwaysPrintEnumsAsInts, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.alwaysPrintEnumsAsInts) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.alwaysPrintEnumsAsInts, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.alwaysPrintEnumsAsInts) -> Bool { if lhs.alwaysPrintEnumsAsInts != rhs.alwaysPrintEnumsAsInts {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.annotation: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".annotation" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "annotation"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.alwaysPrintInt64sAsNumbers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".alwaysPrintInt64sAsNumbers" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}alwaysPrintInt64sAsNumbers\0") + + 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.alwaysPrintInt64SAsNumbers) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.alwaysPrintInt64SAsNumbers != 0 { + try visitor.visitSingularInt32Field(value: self.alwaysPrintInt64SAsNumbers, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.alwaysPrintInt64sAsNumbers, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.alwaysPrintInt64sAsNumbers) -> Bool { + if lhs.alwaysPrintInt64SAsNumbers != rhs.alwaysPrintInt64SAsNumbers {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.annotation: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".annotation" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}annotation\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11543,18 +12614,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.annotation: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.annotation, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.annotation) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.annotation, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.annotation) -> Bool { if lhs.annotation != rhs.annotation {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.any: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".any" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "any"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.any: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".any" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}any\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11575,18 +12644,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.any: SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.any, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.any) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.any, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.any) -> Bool { if lhs.any != rhs.any {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".AnyExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "AnyExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".AnyExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}AnyExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11607,18 +12674,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyExtensionF try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyExtensionField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyExtensionField) -> Bool { if lhs.anyExtensionField != rhs.anyExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".AnyMessageExtension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "AnyMessageExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyMessageExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".AnyMessageExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}AnyMessageExtension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11639,18 +12704,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageExt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageExtension, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageExtension) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyMessageExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyMessageExtension) -> Bool { if lhs.anyMessageExtension != rhs.anyMessageExtension {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".AnyMessageStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "AnyMessageStorage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyMessageStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".AnyMessageStorage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}AnyMessageStorage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11671,18 +12734,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageSto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageStorage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyMessageStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyMessageStorage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyMessageStorage) -> Bool { if lhs.anyMessageStorage != rhs.anyMessageStorage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyUnpackError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".AnyUnpackError" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "AnyUnpackError"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyUnpackError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".AnyUnpackError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}AnyUnpackError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11703,18 +12764,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyUnpackErro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyUnpackError, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.AnyUnpackError) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyUnpackError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AnyUnpackError) -> Bool { if lhs.anyUnpackError != rhs.anyUnpackError {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Api: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Api" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Api"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.append: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".append" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}append\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11722,31 +12781,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Api: SwiftPro // 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.api) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.append) }() default: break } } } func traverse(visitor: inout V) throws { - if self.api != 0 { - try visitor.visitSingularInt32Field(value: self.api, fieldNumber: 1) + if self.append != 0 { + try visitor.visitSingularInt32Field(value: self.append, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Api, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Api) -> Bool { - if lhs.api != rhs.api {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.append, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.append) -> Bool { + if lhs.append != rhs.append {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appended: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".appended" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "appended"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appended: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".appended" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}appended\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11767,18 +12824,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appended: Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appended, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appended) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appended, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appended) -> Bool { if lhs.appended != rhs.appended {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUIntHex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".appendUIntHex" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "appendUIntHex"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appendUIntHex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".appendUIntHex" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}appendUIntHex\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11799,18 +12854,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUIntHex try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUIntHex, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUIntHex) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appendUIntHex, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appendUIntHex) -> Bool { if lhs.appendUintHex != rhs.appendUintHex {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUnknown: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".appendUnknown" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "appendUnknown"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appendUnknown: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".appendUnknown" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}appendUnknown\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11831,18 +12884,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUnknown try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUnknown, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.appendUnknown) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appendUnknown, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.appendUnknown) -> Bool { if lhs.appendUnknown != rhs.appendUnknown {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.areAllInitialized: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".areAllInitialized" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "areAllInitialized"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.areAllInitialized: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".areAllInitialized" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}areAllInitialized\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11863,18 +12914,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.areAllInitial try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.areAllInitialized, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.areAllInitialized) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.areAllInitialized, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.areAllInitialized) -> Bool { if lhs.areAllInitialized != rhs.areAllInitialized {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.array: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".array" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "array"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Array: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Array" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Array\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11895,18 +12944,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.array: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.array, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.array) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Array, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Array) -> Bool { if lhs.array != rhs.array {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayDepth: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".arrayDepth" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "arrayDepth"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arrayDepth: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".arrayDepth" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}arrayDepth\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11927,18 +12974,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayDepth: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayDepth, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayDepth) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arrayDepth, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arrayDepth) -> Bool { if lhs.arrayDepth != rhs.arrayDepth {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".arrayLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "arrayLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arrayLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".arrayLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}arrayLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11959,18 +13004,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayLiteral: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arrayLiteral) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arrayLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arrayLiteral) -> Bool { if lhs.arrayLiteral != rhs.arrayLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arraySeparator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".arraySeparator" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "arraySeparator"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arraySeparator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".arraySeparator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}arraySeparator\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11991,18 +13034,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arraySeparato try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arraySeparator, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.arraySeparator) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arraySeparator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.arraySeparator) -> Bool { if lhs.arraySeparator != rhs.arraySeparator {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".as" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "as"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".as" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}as\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12023,18 +13064,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asMessage: Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asMessage) -> Bool { if lhs.`as` != rhs.`as` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiOpenCurlyBracket: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".asciiOpenCurlyBracket" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "asciiOpenCurlyBracket"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asciiOpenCurlyBracket: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".asciiOpenCurlyBracket" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}asciiOpenCurlyBracket\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12055,18 +13094,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiOpenCurl try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiOpenCurlyBracket, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiOpenCurlyBracket) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asciiOpenCurlyBracket, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asciiOpenCurlyBracket) -> Bool { if lhs.asciiOpenCurlyBracket != rhs.asciiOpenCurlyBracket {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiZero: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".asciiZero" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "asciiZero"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asciiZero: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".asciiZero" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}asciiZero\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12087,18 +13124,136 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiZero: Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiZero, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.asciiZero) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asciiZero, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.asciiZero) -> Bool { if lhs.asciiZero != rhs.asciiZero {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.available: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".available" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "available"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.async: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".async" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}async\0") + + 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.async) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.async != 0 { + try visitor.visitSingularInt32Field(value: self.async, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.async, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.async) -> Bool { + if lhs.async != rhs.async {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncIterator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".AsyncIterator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}AsyncIterator\0") + + 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.asyncIterator) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.asyncIterator != 0 { + try visitor.visitSingularInt32Field(value: self.asyncIterator, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncIterator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncIterator) -> Bool { + if lhs.asyncIterator != rhs.asyncIterator {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncIteratorProtocol: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".AsyncIteratorProtocol" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}AsyncIteratorProtocol\0") + + 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.asyncIteratorProtocol) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.asyncIteratorProtocol != 0 { + try visitor.visitSingularInt32Field(value: self.asyncIteratorProtocol, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncIteratorProtocol, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncIteratorProtocol) -> Bool { + if lhs.asyncIteratorProtocol != rhs.asyncIteratorProtocol {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncMessageSequence: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".AsyncMessageSequence" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}AsyncMessageSequence\0") + + 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.asyncMessageSequence) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.asyncMessageSequence != 0 { + try visitor.visitSingularInt32Field(value: self.asyncMessageSequence, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncMessageSequence, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.AsyncMessageSequence) -> Bool { + if lhs.asyncMessageSequence != rhs.asyncMessageSequence {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.available: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".available" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}available\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12119,18 +13274,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.available: Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.available, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.available) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.available, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.available) -> Bool { if lhs.available != rhs.available {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.b: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".b" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "b"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.b: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".b" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}b\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12151,18 +13304,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.b: SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.b, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.b) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.b, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.b) -> Bool { if lhs.b != rhs.b {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.base64Values: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".base64Values" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "base64Values"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Base: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Base" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Base\0") + + 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.base) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.base != 0 { + try visitor.visitSingularInt32Field(value: self.base, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Base, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Base) -> Bool { + if lhs.base != rhs.base {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.base64Values: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".base64Values" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}base64Values\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12183,18 +13364,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.base64Values: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.base64Values, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.base64Values) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.base64Values, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.base64Values) -> Bool { if lhs.base64Values != rhs.base64Values {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.baseAddress: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".baseAddress" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "baseAddress"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.baseAddress: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".baseAddress" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}baseAddress\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12215,18 +13394,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.baseAddress: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.baseAddress, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.baseAddress) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.baseAddress, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.baseAddress) -> Bool { if lhs.baseAddress != rhs.baseAddress {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BaseType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BaseType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BaseType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BaseType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BaseType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BaseType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12247,18 +13424,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BaseType: Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BaseType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BaseType) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BaseType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BaseType) -> Bool { if lhs.baseType != rhs.baseType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.begin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".begin" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "begin"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.begin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".begin" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}begin\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12279,18 +13454,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.begin: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.begin, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.begin) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.begin, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.begin) -> Bool { if lhs.begin != rhs.begin {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binary: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".binary" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "binary"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binary: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".binary" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}binary\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12311,18 +13484,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binary: Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binary, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binary) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binary, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binary) -> Bool { if lhs.binary != rhs.binary {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryDecoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryDecoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryDecoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12343,18 +13514,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecoder try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecoder) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecoder) -> Bool { if lhs.binaryDecoder != rhs.binaryDecoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryDecodingError" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryDecodingError"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryDecoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryDecoding\0") + + 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.binaryDecoding) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.binaryDecoding != 0 { + try visitor.visitSingularInt32Field(value: self.binaryDecoding, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecoding) -> Bool { + if lhs.binaryDecoding != rhs.binaryDecoding {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryDecodingError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryDecodingError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12375,18 +13574,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodin try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodingError, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodingError) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecodingError) -> Bool { if lhs.binaryDecodingError != rhs.binaryDecodingError {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryDecodingOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryDecodingOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryDecodingOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryDecodingOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12407,18 +13604,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodin try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodingOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDecodingOptions) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecodingOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDecodingOptions) -> Bool { if lhs.binaryDecodingOptions != rhs.binaryDecodingOptions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDelimited: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryDelimited" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryDelimited"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDelimited: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryDelimited" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryDelimited\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12439,18 +13634,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDelimit try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDelimited, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryDelimited) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDelimited, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryDelimited) -> Bool { if lhs.binaryDelimited != rhs.binaryDelimited {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryEncoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryEncoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12471,18 +13664,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncoder try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncoder) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncoder) -> Bool { if lhs.binaryEncoder != rhs.binaryEncoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingError" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryEncodingError"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryEncodingError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12503,18 +13694,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodin try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingError, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingError) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingError) -> Bool { if lhs.binaryEncodingError != rhs.binaryEncodingError {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetSizeVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingMessageSetSizeVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryEncodingMessageSetSizeVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetSizeVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingMessageSetSizeVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryEncodingMessageSetSizeVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12535,18 +13724,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodin try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetSizeVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetSizeVisitor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetSizeVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetSizeVisitor) -> Bool { if lhs.binaryEncodingMessageSetSizeVisitor != rhs.binaryEncodingMessageSetSizeVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingMessageSetVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryEncodingMessageSetVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingMessageSetVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryEncodingMessageSetVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12567,18 +13754,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodin try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetVisitor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingMessageSetVisitor) -> Bool { if lhs.binaryEncodingMessageSetVisitor != rhs.binaryEncodingMessageSetVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingSizeVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingSizeVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryEncodingSizeVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryEncodingOptions\0") + + 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.binaryEncodingOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.binaryEncodingOptions != 0 { + try visitor.visitSingularInt32Field(value: self.binaryEncodingOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingOptions) -> Bool { + if lhs.binaryEncodingOptions != rhs.binaryEncodingOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingSizeVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingSizeVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryEncodingSizeVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12599,18 +13814,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodin try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingSizeVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingSizeVisitor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingSizeVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingSizeVisitor) -> Bool { if lhs.binaryEncodingSizeVisitor != rhs.binaryEncodingSizeVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BinaryEncodingVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryEncodingVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryEncodingVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12631,18 +13844,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodin try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BinaryEncodingVisitor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryEncodingVisitor) -> Bool { if lhs.binaryEncodingVisitor != rhs.binaryEncodingVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binaryOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".binaryOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "binaryOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".binaryOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}binaryOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12663,18 +13874,136 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binaryOptions try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binaryOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.binaryOptions) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryOptions) -> Bool { if lhs.binaryOptions != rhs.binaryOptions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.body: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".body" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "body"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryProtobufDelimitedMessages: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".binaryProtobufDelimitedMessages" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}binaryProtobufDelimitedMessages\0") + + 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.binaryProtobufDelimitedMessages) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.binaryProtobufDelimitedMessages != 0 { + try visitor.visitSingularInt32Field(value: self.binaryProtobufDelimitedMessages, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryProtobufDelimitedMessages, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryProtobufDelimitedMessages) -> Bool { + if lhs.binaryProtobufDelimitedMessages != rhs.binaryProtobufDelimitedMessages {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryStreamDecoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BinaryStreamDecoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BinaryStreamDecoding\0") + + 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.binaryStreamDecoding) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.binaryStreamDecoding != 0 { + try visitor.visitSingularInt32Field(value: self.binaryStreamDecoding, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryStreamDecoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BinaryStreamDecoding) -> Bool { + if lhs.binaryStreamDecoding != rhs.binaryStreamDecoding {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryStreamDecodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".binaryStreamDecodingError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}binaryStreamDecodingError\0") + + 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.binaryStreamDecodingError) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.binaryStreamDecodingError != 0 { + try visitor.visitSingularInt32Field(value: self.binaryStreamDecodingError, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryStreamDecodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.binaryStreamDecodingError) -> Bool { + if lhs.binaryStreamDecodingError != rhs.binaryStreamDecodingError {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bitPattern: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".bitPattern" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bitPattern\0") + + 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.bitPattern) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.bitPattern != 0 { + try visitor.visitSingularInt32Field(value: self.bitPattern, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bitPattern, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bitPattern) -> Bool { + if lhs.bitPattern != rhs.bitPattern {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.body: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".body" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}body\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12695,18 +14024,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.body: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.body, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.body) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.body, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.body) -> Bool { if lhs.body != rhs.body {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BoolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Bool" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Bool"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BoolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Bool" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Bool\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12727,18 +14054,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BoolMessage: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BoolMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BoolMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BoolMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BoolMessage) -> Bool { if lhs.bool != rhs.bool {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.booleanLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".booleanLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "booleanLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.booleanLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".booleanLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}booleanLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12759,18 +14084,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.booleanLitera try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.booleanLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.booleanLiteral) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.booleanLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.booleanLiteral) -> Bool { if lhs.booleanLiteral != rhs.booleanLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BooleanLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BooleanLiteralType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BooleanLiteralType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BooleanLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BooleanLiteralType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BooleanLiteralType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12791,18 +14114,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BooleanLitera try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BooleanLiteralType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BooleanLiteralType) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BooleanLiteralType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BooleanLiteralType) -> Bool { if lhs.booleanLiteralType != rhs.booleanLiteralType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.boolValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".boolValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "boolValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.boolValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".boolValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}boolValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12823,18 +14144,136 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.boolValue: Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.boolValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.boolValue) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.boolValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.boolValue) -> Bool { if lhs.boolValue != rhs.boolValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".bytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.buffer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".buffer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}buffer\0") + + 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.buffer) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.buffer != 0 { + try visitor.visitSingularInt32Field(value: self.buffer, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.buffer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.buffer) -> Bool { + if lhs.buffer != rhs.buffer {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.byte: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".byte" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}byte\0") + + 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.byte) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.byte != 0 { + try visitor.visitSingularInt32Field(value: self.byte, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.byte, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.byte) -> Bool { + if lhs.byte != rhs.byte {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytecode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".bytecode" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bytecode\0") + + 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.bytecode) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.bytecode != 0 { + try visitor.visitSingularInt32Field(value: self.bytecode, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytecode, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytecode) -> Bool { + if lhs.bytecode != rhs.bytecode {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BytecodeReader: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".BytecodeReader" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}BytecodeReader\0") + + 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.bytecodeReader) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.bytecodeReader != 0 { + try visitor.visitSingularInt32Field(value: self.bytecodeReader, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BytecodeReader, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.BytecodeReader) -> Bool { + if lhs.bytecodeReader != rhs.bytecodeReader {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".bytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12855,18 +14294,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytes: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytes, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytes) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytes) -> Bool { if lhs.bytes != rhs.bytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesInGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".bytesInGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bytesInGroup"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesInGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".bytesInGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bytesInGroup\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12887,18 +14324,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesInGroup: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesInGroup, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesInGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesInGroup, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesInGroup) -> Bool { if lhs.bytesInGroup != rhs.bytesInGroup {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesRead: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".bytesRead" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bytesRead"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesNeeded: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".bytesNeeded" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bytesNeeded\0") + + 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.bytesNeeded) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.bytesNeeded != 0 { + try visitor.visitSingularInt32Field(value: self.bytesNeeded, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesNeeded, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesNeeded) -> Bool { + if lhs.bytesNeeded != rhs.bytesNeeded {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesRead: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".bytesRead" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bytesRead\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12919,18 +14384,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesRead: Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesRead, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.bytesRead) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesRead, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.bytesRead) -> Bool { if lhs.bytesRead != rhs.bytesRead {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BytesValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".BytesValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "BytesValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.c: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".c" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12938,31 +14401,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BytesValue: S // 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.bytesValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.c) }() default: break } } } func traverse(visitor: inout V) throws { - if self.bytesValue != 0 { - try visitor.visitSingularInt32Field(value: self.bytesValue, fieldNumber: 1) + if self.c != 0 { + try visitor.visitSingularInt32Field(value: self.c, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BytesValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.BytesValue) -> Bool { - if lhs.bytesValue != rhs.bytesValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.c, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.c) -> Bool { + if lhs.c != rhs.c {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.c: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".c" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.canonical: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".canonical" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}canonical\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12970,31 +14431,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.c: SwiftProto // 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.c) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.canonical) }() default: break } } } func traverse(visitor: inout V) throws { - if self.c != 0 { - try visitor.visitSingularInt32Field(value: self.c, fieldNumber: 1) + if self.canonical != 0 { + try visitor.visitSingularInt32Field(value: self.canonical, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.c, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.c) -> Bool { - if lhs.c != rhs.c {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.canonical, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.canonical) -> Bool { + if lhs.canonical != rhs.canonical {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.capitalizeNext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".capitalizeNext" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "capitalizeNext"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.capitalizeNext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".capitalizeNext" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}capitalizeNext\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13015,18 +14474,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.capitalizeNex try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.capitalizeNext, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.capitalizeNext) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.capitalizeNext, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.capitalizeNext) -> Bool { if lhs.capitalizeNext != rhs.capitalizeNext {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.cardinality: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".cardinality" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "cardinality"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.cardinality: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".cardinality" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}cardinality\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13047,18 +14504,76 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.cardinality: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.cardinality, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.cardinality) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.cardinality, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.cardinality) -> Bool { if lhs.cardinality != rhs.cardinality {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccEnableArenas: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ccEnableArenas" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ccEnableArenas"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CaseIterable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".CaseIterable" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}CaseIterable\0") + + 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.caseIterable) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.caseIterable != 0 { + try visitor.visitSingularInt32Field(value: self.caseIterable, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CaseIterable, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CaseIterable) -> Bool { + if lhs.caseIterable != rhs.caseIterable {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.castedValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".castedValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}castedValue\0") + + 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.castedValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.castedValue != 0 { + try visitor.visitSingularInt32Field(value: self.castedValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.castedValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.castedValue) -> Bool { + if lhs.castedValue != rhs.castedValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ccEnableArenas: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ccEnableArenas" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ccEnableArenas\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13079,18 +14594,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccEnableArena try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccEnableArenas, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccEnableArenas) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ccEnableArenas, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ccEnableArenas) -> Bool { if lhs.ccEnableArenas != rhs.ccEnableArenas {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ccGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ccGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ccGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ccGenericServices" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ccGenericServices\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13111,18 +14624,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccGenericServ try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ccGenericServices) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ccGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ccGenericServices) -> Bool { if lhs.ccGenericServices != rhs.ccGenericServices {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Character: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Character" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Character"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Character: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Character" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Character\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13143,18 +14654,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Character: Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Character, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Character) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Character, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Character) -> Bool { if lhs.character != rhs.character {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.chars: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".chars" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "chars"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.chars: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".chars" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}chars\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13175,18 +14684,76 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.chars: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.chars, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.chars) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.chars, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.chars) -> Bool { if lhs.chars != rhs.chars {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.classMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".class" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "class"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.checkProgramFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".checkProgramFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}checkProgramFormat\0") + + 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.checkProgramFormat) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.checkProgramFormat != 0 { + try visitor.visitSingularInt32Field(value: self.checkProgramFormat, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.checkProgramFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.checkProgramFormat) -> Bool { + if lhs.checkProgramFormat != rhs.checkProgramFormat {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.chunk: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".chunk" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}chunk\0") + + 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.chunk) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.chunk != 0 { + try visitor.visitSingularInt32Field(value: self.chunk, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.chunk, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.chunk) -> Bool { + if lhs.chunk != rhs.chunk {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.classMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".class" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}class\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13207,18 +14774,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.classMessage: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.classMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.classMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.classMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.classMessage) -> Bool { if lhs.`class` != rhs.`class` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAggregateValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearAggregateValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearAggregateValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearAggregateValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearAggregateValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearAggregateValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13239,18 +14804,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAggregat try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAggregateValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAggregateValue) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearAggregateValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearAggregateValue) -> Bool { if lhs.clearAggregateValue_p != rhs.clearAggregateValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAllowAlias: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearAllowAlias" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearAllowAlias"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearAllowAlias: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearAllowAlias" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearAllowAlias\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13271,18 +14834,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAllowAli try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAllowAlias, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearAllowAlias) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearAllowAlias, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearAllowAlias) -> Bool { if lhs.clearAllowAlias_p != rhs.clearAllowAlias_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearBegin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearBegin" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearBegin"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearBegin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearBegin" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearBegin\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13303,18 +14864,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearBegin: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearBegin, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearBegin) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearBegin, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearBegin) -> Bool { if lhs.clearBegin_p != rhs.clearBegin_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcEnableArenas: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearCcEnableArenas" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearCcEnableArenas"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCcEnableArenas: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearCcEnableArenas" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearCcEnableArenas\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13335,18 +14894,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcEnable try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcEnableArenas, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcEnableArenas) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCcEnableArenas, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCcEnableArenas) -> Bool { if lhs.clearCcEnableArenas_p != rhs.clearCcEnableArenas_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearCcGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearCcGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCcGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearCcGenericServices" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearCcGenericServices\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13367,18 +14924,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcGeneri try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCcGenericServices) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCcGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCcGenericServices) -> Bool { if lhs.clearCcGenericServices_p != rhs.clearCcGenericServices_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearClientStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearClientStreaming" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearClientStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearClientStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearClientStreaming" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearClientStreaming\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13399,18 +14954,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearClientSt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearClientStreaming, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearClientStreaming) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearClientStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearClientStreaming) -> Bool { if lhs.clearClientStreaming_p != rhs.clearClientStreaming_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCsharpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearCsharpNamespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearCsharpNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCsharpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearCsharpNamespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearCsharpNamespace\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13431,18 +14984,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCsharpNa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCsharpNamespace, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCsharpNamespace) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCsharpNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCsharpNamespace) -> Bool { if lhs.clearCsharpNamespace_p != rhs.clearCsharpNamespace_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCtype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearCtype" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearCtype"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCtype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearCtype" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearCtype\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13463,18 +15014,76 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCtype: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCtype, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearCtype) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCtype, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearCtype) -> Bool { if lhs.clearCtype_p != rhs.clearCtype_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDefaultValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDefaultValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearDefaultValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDebugRedact: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDebugRedact" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearDebugRedact\0") + + 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.clearDebugRedact_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.clearDebugRedact_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearDebugRedact_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDebugRedact, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDebugRedact) -> Bool { + if lhs.clearDebugRedact_p != rhs.clearDebugRedact_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDefaultSymbolVisibility: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDefaultSymbolVisibility" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearDefaultSymbolVisibility\0") + + 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.clearDefaultSymbolVisibility_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.clearDefaultSymbolVisibility_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearDefaultSymbolVisibility_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDefaultSymbolVisibility, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDefaultSymbolVisibility) -> Bool { + if lhs.clearDefaultSymbolVisibility_p != rhs.clearDefaultSymbolVisibility_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDefaultValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDefaultValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearDefaultValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13495,18 +15104,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDefaultV try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDefaultValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDefaultValue) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDefaultValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDefaultValue) -> Bool { if lhs.clearDefaultValue_p != rhs.clearDefaultValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDeprecated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDeprecated" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearDeprecated"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDeprecated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearDeprecated\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13527,18 +15134,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDeprecat try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDeprecated, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDeprecated) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecated) -> Bool { if lhs.clearDeprecated_p != rhs.clearDeprecated_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDoubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDoubleValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearDoubleValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecatedLegacyJsonFieldConflicts: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDeprecatedLegacyJsonFieldConflicts" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearDeprecatedLegacyJsonFieldConflicts\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13546,31 +15151,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDoubleVa // 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.clearDoubleValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearDeprecatedLegacyJsonFieldConflicts_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearDoubleValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearDoubleValue_p, fieldNumber: 1) + if self.clearDeprecatedLegacyJsonFieldConflicts_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearDeprecatedLegacyJsonFieldConflicts_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDoubleValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearDoubleValue) -> Bool { - if lhs.clearDoubleValue_p != rhs.clearDoubleValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecatedLegacyJsonFieldConflicts, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecatedLegacyJsonFieldConflicts) -> Bool { + if lhs.clearDeprecatedLegacyJsonFieldConflicts_p != rhs.clearDeprecatedLegacyJsonFieldConflicts_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearEnd: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearEnd" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearEnd"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecationWarning: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDeprecationWarning" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearDeprecationWarning\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13578,31 +15181,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearEnd: Swi // 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.clearEnd_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearDeprecationWarning_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearEnd_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearEnd_p, fieldNumber: 1) + if self.clearDeprecationWarning_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearDeprecationWarning_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearEnd, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearEnd) -> Bool { - if lhs.clearEnd_p != rhs.clearEnd_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecationWarning, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDeprecationWarning) -> Bool { + if lhs.clearDeprecationWarning_p != rhs.clearDeprecationWarning_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtendee: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearExtendee" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearExtendee"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDoubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearDoubleValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearDoubleValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13610,31 +15211,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtendee // 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.clearExtendee_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearDoubleValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearExtendee_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearExtendee_p, fieldNumber: 1) + if self.clearDoubleValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearDoubleValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtendee, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtendee) -> Bool { - if lhs.clearExtendee_p != rhs.clearExtendee_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDoubleValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearDoubleValue) -> Bool { + if lhs.clearDoubleValue_p != rhs.clearDoubleValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtensionValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearExtensionValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearExtensionValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearEdition\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13642,31 +15241,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtensio // 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.clearExtensionValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearEdition_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearExtensionValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearExtensionValue_p, fieldNumber: 1) + if self.clearEdition_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearEdition_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtensionValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearExtensionValue) -> Bool { - if lhs.clearExtensionValue_p != rhs.clearExtensionValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEdition) -> Bool { + if lhs.clearEdition_p != rhs.clearEdition_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearGoPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearGoPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearGoPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditionDeprecated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearEditionDeprecated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearEditionDeprecated\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13674,31 +15271,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearGoPackag // 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.clearGoPackage_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearEditionDeprecated_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearGoPackage_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearGoPackage_p, fieldNumber: 1) + if self.clearEditionDeprecated_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearEditionDeprecated_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearGoPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearGoPackage) -> Bool { - if lhs.clearGoPackage_p != rhs.clearGoPackage_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditionDeprecated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditionDeprecated) -> Bool { + if lhs.clearEditionDeprecated_p != rhs.clearEditionDeprecated_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdempotencyLevel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearIdempotencyLevel" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearIdempotencyLevel"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditionIntroduced: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearEditionIntroduced" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearEditionIntroduced\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13706,31 +15301,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdempote // 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.clearIdempotencyLevel_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearEditionIntroduced_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearIdempotencyLevel_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearIdempotencyLevel_p, fieldNumber: 1) + if self.clearEditionIntroduced_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearEditionIntroduced_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdempotencyLevel, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdempotencyLevel) -> Bool { - if lhs.clearIdempotencyLevel_p != rhs.clearIdempotencyLevel_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditionIntroduced, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditionIntroduced) -> Bool { + if lhs.clearEditionIntroduced_p != rhs.clearEditionIntroduced_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdentifierValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearIdentifierValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearIdentifierValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditionRemoved: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearEditionRemoved" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearEditionRemoved\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13738,31 +15331,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdentifi // 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.clearIdentifierValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearEditionRemoved_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearIdentifierValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearIdentifierValue_p, fieldNumber: 1) + if self.clearEditionRemoved_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearEditionRemoved_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdentifierValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIdentifierValue) -> Bool { - if lhs.clearIdentifierValue_p != rhs.clearIdentifierValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditionRemoved, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEditionRemoved) -> Bool { + if lhs.clearEditionRemoved_p != rhs.clearEditionRemoved_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearInputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearInputType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearInputType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnd: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearEnd" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearEnd\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13770,31 +15361,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearInputTyp // 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.clearInputType_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearEnd_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearInputType_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearInputType_p, fieldNumber: 1) + if self.clearEnd_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearEnd_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearInputType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearInputType) -> Bool { - if lhs.clearInputType_p != rhs.clearInputType_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnd, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnd) -> Bool { + if lhs.clearEnd_p != rhs.clearEnd_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIsExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearIsExtension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearIsExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnforceNamingStyle: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearEnforceNamingStyle" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearEnforceNamingStyle\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13802,31 +15391,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIsExtens // 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.clearIsExtension_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearEnforceNamingStyle_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearIsExtension_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearIsExtension_p, fieldNumber: 1) + if self.clearEnforceNamingStyle_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearEnforceNamingStyle_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIsExtension, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearIsExtension) -> Bool { - if lhs.clearIsExtension_p != rhs.clearIsExtension_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnforceNamingStyle, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnforceNamingStyle) -> Bool { + if lhs.clearEnforceNamingStyle_p != rhs.clearEnforceNamingStyle_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGenerateEqualsAndHash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaGenerateEqualsAndHash" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearJavaGenerateEqualsAndHash"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnumType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearEnumType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearEnumType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13834,31 +15421,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGene // 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.clearJavaGenerateEqualsAndHash_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearEnumType_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearJavaGenerateEqualsAndHash_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearJavaGenerateEqualsAndHash_p, fieldNumber: 1) + if self.clearEnumType_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearEnumType_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGenerateEqualsAndHash, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGenerateEqualsAndHash) -> Bool { - if lhs.clearJavaGenerateEqualsAndHash_p != rhs.clearJavaGenerateEqualsAndHash_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnumType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearEnumType) -> Bool { + if lhs.clearEnumType_p != rhs.clearEnumType_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearJavaGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearExtendee: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearExtendee" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearExtendee\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13866,31 +15451,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGene // 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.clearJavaGenericServices_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearExtendee_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearJavaGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearJavaGenericServices_p, fieldNumber: 1) + if self.clearExtendee_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearExtendee_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaGenericServices) -> Bool { - if lhs.clearJavaGenericServices_p != rhs.clearJavaGenericServices_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearExtendee, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearExtendee) -> Bool { + if lhs.clearExtendee_p != rhs.clearExtendee_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaMultipleFiles: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaMultipleFiles" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearJavaMultipleFiles"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearExtensionValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearExtensionValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearExtensionValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13898,31 +15481,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaMult // 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.clearJavaMultipleFiles_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearExtensionValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearJavaMultipleFiles_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearJavaMultipleFiles_p, fieldNumber: 1) + if self.clearExtensionValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearExtensionValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaMultipleFiles, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaMultipleFiles) -> Bool { - if lhs.clearJavaMultipleFiles_p != rhs.clearJavaMultipleFiles_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearExtensionValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearExtensionValue) -> Bool { + if lhs.clearExtensionValue_p != rhs.clearExtensionValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaOuterClassname: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaOuterClassname" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearJavaOuterClassname"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearFeatures\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13930,31 +15511,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaOute // 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.clearJavaOuterClassname_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearFeatures_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearJavaOuterClassname_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearJavaOuterClassname_p, fieldNumber: 1) + if self.clearFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearFeatures_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaOuterClassname, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaOuterClassname) -> Bool { - if lhs.clearJavaOuterClassname_p != rhs.clearJavaOuterClassname_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFeatures, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFeatures) -> Bool { + if lhs.clearFeatures_p != rhs.clearFeatures_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearJavaPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFeatureSupport: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearFeatureSupport" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearFeatureSupport\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13962,31 +15541,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaPack // 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.clearJavaPackage_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearFeatureSupport_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearJavaPackage_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearJavaPackage_p, fieldNumber: 1) + if self.clearFeatureSupport_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearFeatureSupport_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaPackage) -> Bool { - if lhs.clearJavaPackage_p != rhs.clearJavaPackage_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFeatureSupport, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFeatureSupport) -> Bool { + if lhs.clearFeatureSupport_p != rhs.clearFeatureSupport_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaStringCheckUtf8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaStringCheckUtf8" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearJavaStringCheckUtf8"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFieldPresence: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearFieldPresence" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearFieldPresence\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13994,31 +15571,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaStri // 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.clearJavaStringCheckUtf8_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearFieldPresence_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearJavaStringCheckUtf8_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearJavaStringCheckUtf8_p, fieldNumber: 1) + if self.clearFieldPresence_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearFieldPresence_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaStringCheckUtf8, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJavaStringCheckUtf8) -> Bool { - if lhs.clearJavaStringCheckUtf8_p != rhs.clearJavaStringCheckUtf8_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFieldPresence, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFieldPresence) -> Bool { + if lhs.clearFieldPresence_p != rhs.clearFieldPresence_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJsonName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJsonName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearJsonName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFixedFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearFixedFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearFixedFeatures\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14026,31 +15601,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJsonName // 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.clearJsonName_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearFixedFeatures_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearJsonName_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearJsonName_p, fieldNumber: 1) + if self.clearFixedFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearFixedFeatures_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJsonName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJsonName) -> Bool { - if lhs.clearJsonName_p != rhs.clearJsonName_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFixedFeatures, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFixedFeatures) -> Bool { + if lhs.clearFixedFeatures_p != rhs.clearFixedFeatures_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJstype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJstype" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearJstype"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFullName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearFullName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearFullName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14058,31 +15631,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJstype: // 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.clearJstype_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearFullName_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearJstype_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearJstype_p, fieldNumber: 1) + if self.clearFullName_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearFullName_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJstype, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearJstype) -> Bool { - if lhs.clearJstype_p != rhs.clearJstype_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFullName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearFullName) -> Bool { + if lhs.clearFullName_p != rhs.clearFullName_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLabel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearLabel" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearLabel"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearGoPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearGoPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearGoPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14090,31 +15661,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLabel: S // 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.clearLabel_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearGoPackage_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearLabel_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearLabel_p, fieldNumber: 1) + if self.clearGoPackage_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearGoPackage_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLabel, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLabel) -> Bool { - if lhs.clearLabel_p != rhs.clearLabel_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearGoPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearGoPackage) -> Bool { + if lhs.clearGoPackage_p != rhs.clearGoPackage_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearLazy" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearLazy"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIdempotencyLevel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearIdempotencyLevel" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearIdempotencyLevel\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14122,31 +15691,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLazy: Sw // 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.clearLazy_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearIdempotencyLevel_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearLazy_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearLazy_p, fieldNumber: 1) + if self.clearIdempotencyLevel_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearIdempotencyLevel_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLazy, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLazy) -> Bool { - if lhs.clearLazy_p != rhs.clearLazy_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIdempotencyLevel, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIdempotencyLevel) -> Bool { + if lhs.clearIdempotencyLevel_p != rhs.clearIdempotencyLevel_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLeadingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearLeadingComments" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearLeadingComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIdentifierValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearIdentifierValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearIdentifierValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14154,31 +15721,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLeadingC // 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.clearLeadingComments_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearIdentifierValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearLeadingComments_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearLeadingComments_p, fieldNumber: 1) + if self.clearIdentifierValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearIdentifierValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLeadingComments, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearLeadingComments) -> Bool { - if lhs.clearLeadingComments_p != rhs.clearLeadingComments_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIdentifierValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIdentifierValue) -> Bool { + if lhs.clearIdentifierValue_p != rhs.clearIdentifierValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMapEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearMapEntry" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearMapEntry"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearInputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearInputType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearInputType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14186,31 +15751,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMapEntry // 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.clearMapEntry_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearInputType_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearMapEntry_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearMapEntry_p, fieldNumber: 1) + if self.clearInputType_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearInputType_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMapEntry, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMapEntry) -> Bool { - if lhs.clearMapEntry_p != rhs.clearMapEntry_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearInputType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearInputType) -> Bool { + if lhs.clearInputType_p != rhs.clearInputType_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMessageSetWireFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearMessageSetWireFormat" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearMessageSetWireFormat"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIsExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearIsExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearIsExtension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14218,31 +15781,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMessageS // 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.clearMessageSetWireFormat_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearIsExtension_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearMessageSetWireFormat_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearMessageSetWireFormat_p, fieldNumber: 1) + if self.clearIsExtension_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearIsExtension_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMessageSetWireFormat, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearMessageSetWireFormat) -> Bool { - if lhs.clearMessageSetWireFormat_p != rhs.clearMessageSetWireFormat_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIsExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearIsExtension) -> Bool { + if lhs.clearIsExtension_p != rhs.clearIsExtension_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaGenerateEqualsAndHash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaGenerateEqualsAndHash" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearJavaGenerateEqualsAndHash\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14250,31 +15811,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearName: Sw // 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.clearName_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearJavaGenerateEqualsAndHash_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearName_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearName_p, fieldNumber: 1) + if self.clearJavaGenerateEqualsAndHash_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearJavaGenerateEqualsAndHash_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearName) -> Bool { - if lhs.clearName_p != rhs.clearName_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaGenerateEqualsAndHash, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaGenerateEqualsAndHash) -> Bool { + if lhs.clearJavaGenerateEqualsAndHash_p != rhs.clearJavaGenerateEqualsAndHash_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNamePart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearNamePart" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearNamePart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaGenericServices" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearJavaGenericServices\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14282,31 +15841,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNamePart // 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.clearNamePart_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearJavaGenericServices_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearNamePart_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearNamePart_p, fieldNumber: 1) + if self.clearJavaGenericServices_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearJavaGenericServices_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNamePart, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNamePart) -> Bool { - if lhs.clearNamePart_p != rhs.clearNamePart_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaGenericServices) -> Bool { + if lhs.clearJavaGenericServices_p != rhs.clearJavaGenericServices_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNegativeIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearNegativeIntValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearNegativeIntValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaMultipleFiles: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaMultipleFiles" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearJavaMultipleFiles\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14314,31 +15871,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNegative // 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.clearNegativeIntValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearJavaMultipleFiles_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearNegativeIntValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearNegativeIntValue_p, fieldNumber: 1) + if self.clearJavaMultipleFiles_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearJavaMultipleFiles_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNegativeIntValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNegativeIntValue) -> Bool { - if lhs.clearNegativeIntValue_p != rhs.clearNegativeIntValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaMultipleFiles, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaMultipleFiles) -> Bool { + if lhs.clearJavaMultipleFiles_p != rhs.clearJavaMultipleFiles_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNoStandardDescriptorAccessor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearNoStandardDescriptorAccessor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearNoStandardDescriptorAccessor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaOuterClassname: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaOuterClassname" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearJavaOuterClassname\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14346,31 +15901,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNoStanda // 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.clearNoStandardDescriptorAccessor_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearJavaOuterClassname_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearNoStandardDescriptorAccessor_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearNoStandardDescriptorAccessor_p, fieldNumber: 1) + if self.clearJavaOuterClassname_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearJavaOuterClassname_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNoStandardDescriptorAccessor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNoStandardDescriptorAccessor) -> Bool { - if lhs.clearNoStandardDescriptorAccessor_p != rhs.clearNoStandardDescriptorAccessor_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaOuterClassname, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaOuterClassname) -> Bool { + if lhs.clearJavaOuterClassname_p != rhs.clearJavaOuterClassname_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearJavaPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14378,31 +15931,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNumber: // 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.clearNumber_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearJavaPackage_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearNumber_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearNumber_p, fieldNumber: 1) + if self.clearJavaPackage_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearJavaPackage_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNumber, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearNumber) -> Bool { - if lhs.clearNumber_p != rhs.clearNumber_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaPackage) -> Bool { + if lhs.clearJavaPackage_p != rhs.clearJavaPackage_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearObjcClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearObjcClassPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearObjcClassPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaStringCheckUtf8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJavaStringCheckUtf8" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearJavaStringCheckUtf8\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14410,31 +15961,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearObjcClas // 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.clearObjcClassPrefix_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearJavaStringCheckUtf8_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearObjcClassPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearObjcClassPrefix_p, fieldNumber: 1) + if self.clearJavaStringCheckUtf8_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearJavaStringCheckUtf8_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearObjcClassPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearObjcClassPrefix) -> Bool { - if lhs.clearObjcClassPrefix_p != rhs.clearObjcClassPrefix_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaStringCheckUtf8, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJavaStringCheckUtf8) -> Bool { + if lhs.clearJavaStringCheckUtf8_p != rhs.clearJavaStringCheckUtf8_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOneofIndex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearOneofIndex" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearOneofIndex"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJsonFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJsonFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearJsonFormat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14442,31 +15991,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOneofInd // 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.clearOneofIndex_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearJsonFormat_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearOneofIndex_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearOneofIndex_p, fieldNumber: 1) + if self.clearJsonFormat_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearJsonFormat_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOneofIndex, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOneofIndex) -> Bool { - if lhs.clearOneofIndex_p != rhs.clearOneofIndex_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJsonFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJsonFormat) -> Bool { + if lhs.clearJsonFormat_p != rhs.clearJsonFormat_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptimizeFor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearOptimizeFor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearOptimizeFor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJsonName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJsonName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearJsonName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14474,31 +16021,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptimize // 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.clearOptimizeFor_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearJsonName_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearOptimizeFor_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearOptimizeFor_p, fieldNumber: 1) + if self.clearJsonName_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearJsonName_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptimizeFor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptimizeFor) -> Bool { - if lhs.clearOptimizeFor_p != rhs.clearOptimizeFor_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJsonName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJsonName) -> Bool { + if lhs.clearJsonName_p != rhs.clearJsonName_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJstype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearJstype" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearJstype\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14506,31 +16051,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptions: // 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.clearOptions_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearJstype_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearOptions_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearOptions_p, fieldNumber: 1) + if self.clearJstype_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearJstype_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOptions) -> Bool { - if lhs.clearOptions_p != rhs.clearOptions_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJstype, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearJstype) -> Bool { + if lhs.clearJstype_p != rhs.clearJstype_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOutputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearOutputType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearOutputType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLabel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearLabel" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearLabel\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14538,31 +16081,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOutputTy // 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.clearOutputType_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearLabel_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearOutputType_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearOutputType_p, fieldNumber: 1) + if self.clearLabel_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearLabel_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOutputType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearOutputType) -> Bool { - if lhs.clearOutputType_p != rhs.clearOutputType_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLabel, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLabel) -> Bool { + if lhs.clearLabel_p != rhs.clearLabel_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearLazy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearLazy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14570,31 +16111,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPackage: // 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.clearPackage_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearLazy_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearPackage_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearPackage_p, fieldNumber: 1) + if self.clearLazy_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearLazy_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPackage) -> Bool { - if lhs.clearPackage_p != rhs.clearPackage_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLazy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLazy) -> Bool { + if lhs.clearLazy_p != rhs.clearLazy_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPacked: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPacked" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearPacked"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLeadingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearLeadingComments" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearLeadingComments\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14602,31 +16141,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPacked: // 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.clearPacked_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearLeadingComments_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearPacked_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearPacked_p, fieldNumber: 1) + if self.clearLeadingComments_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearLeadingComments_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPacked, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPacked) -> Bool { - if lhs.clearPacked_p != rhs.clearPacked_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLeadingComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearLeadingComments) -> Bool { + if lhs.clearLeadingComments_p != rhs.clearLeadingComments_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPhpClassPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearPhpClassPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMapEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearMapEntry" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearMapEntry\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14634,31 +16171,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpClass // 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.clearPhpClassPrefix_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearMapEntry_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearPhpClassPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearPhpClassPrefix_p, fieldNumber: 1) + if self.clearMapEntry_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearMapEntry_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpClassPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpClassPrefix) -> Bool { - if lhs.clearPhpClassPrefix_p != rhs.clearPhpClassPrefix_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMapEntry, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMapEntry) -> Bool { + if lhs.clearMapEntry_p != rhs.clearMapEntry_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPhpGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearPhpGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMaximumEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearMaximumEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearMaximumEdition\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14666,31 +16201,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpGener // 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.clearPhpGenericServices_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearMaximumEdition_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearPhpGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearPhpGenericServices_p, fieldNumber: 1) + if self.clearMaximumEdition_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearMaximumEdition_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpGenericServices) -> Bool { - if lhs.clearPhpGenericServices_p != rhs.clearPhpGenericServices_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMaximumEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMaximumEdition) -> Bool { + if lhs.clearMaximumEdition_p != rhs.clearMaximumEdition_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpMetadataNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPhpMetadataNamespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearPhpMetadataNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMessageEncoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearMessageEncoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearMessageEncoding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14698,31 +16231,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpMetad // 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.clearPhpMetadataNamespace_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearMessageEncoding_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearPhpMetadataNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearPhpMetadataNamespace_p, fieldNumber: 1) + if self.clearMessageEncoding_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearMessageEncoding_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpMetadataNamespace, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpMetadataNamespace) -> Bool { - if lhs.clearPhpMetadataNamespace_p != rhs.clearPhpMetadataNamespace_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMessageEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMessageEncoding) -> Bool { + if lhs.clearMessageEncoding_p != rhs.clearMessageEncoding_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPhpNamespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearPhpNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMessageSetWireFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearMessageSetWireFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearMessageSetWireFormat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14730,31 +16261,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpNames // 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.clearPhpNamespace_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearMessageSetWireFormat_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearPhpNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearPhpNamespace_p, fieldNumber: 1) + if self.clearMessageSetWireFormat_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearMessageSetWireFormat_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpNamespace, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPhpNamespace) -> Bool { - if lhs.clearPhpNamespace_p != rhs.clearPhpNamespace_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMessageSetWireFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMessageSetWireFormat) -> Bool { + if lhs.clearMessageSetWireFormat_p != rhs.clearMessageSetWireFormat_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPositiveIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPositiveIntValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearPositiveIntValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMinimumEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearMinimumEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearMinimumEdition\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14762,31 +16291,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPositive // 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.clearPositiveIntValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearMinimumEdition_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearPositiveIntValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearPositiveIntValue_p, fieldNumber: 1) + if self.clearMinimumEdition_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearMinimumEdition_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPositiveIntValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPositiveIntValue) -> Bool { - if lhs.clearPositiveIntValue_p != rhs.clearPositiveIntValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMinimumEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearMinimumEdition) -> Bool { + if lhs.clearMinimumEdition_p != rhs.clearMinimumEdition_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearProto3Optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearProto3Optional" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearProto3Optional"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14794,31 +16321,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearProto3Op // 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.clearProto3Optional_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearName_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearProto3Optional_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearProto3Optional_p, fieldNumber: 1) + if self.clearName_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearName_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearProto3Optional, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearProto3Optional) -> Bool { - if lhs.clearProto3Optional_p != rhs.clearProto3Optional_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearName) -> Bool { + if lhs.clearName_p != rhs.clearName_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPyGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPyGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearPyGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNamePart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearNamePart" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearNamePart\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14826,31 +16351,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPyGeneri // 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.clearPyGenericServices_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearNamePart_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearPyGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearPyGenericServices_p, fieldNumber: 1) + if self.clearNamePart_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearNamePart_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPyGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearPyGenericServices) -> Bool { - if lhs.clearPyGenericServices_p != rhs.clearPyGenericServices_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNamePart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNamePart) -> Bool { + if lhs.clearNamePart_p != rhs.clearNamePart_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearRubyPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearRubyPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearRubyPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNegativeIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearNegativeIntValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearNegativeIntValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14858,31 +16381,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearRubyPack // 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.clearRubyPackage_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearNegativeIntValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearRubyPackage_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearRubyPackage_p, fieldNumber: 1) + if self.clearNegativeIntValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearNegativeIntValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearRubyPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearRubyPackage) -> Bool { - if lhs.clearRubyPackage_p != rhs.clearRubyPackage_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNegativeIntValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNegativeIntValue) -> Bool { + if lhs.clearNegativeIntValue_p != rhs.clearNegativeIntValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearServerStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearServerStreaming" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearServerStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNoStandardDescriptorAccessor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearNoStandardDescriptorAccessor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearNoStandardDescriptorAccessor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14890,31 +16411,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearServerSt // 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.clearServerStreaming_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearNoStandardDescriptorAccessor_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearServerStreaming_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearServerStreaming_p, fieldNumber: 1) + if self.clearNoStandardDescriptorAccessor_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearNoStandardDescriptorAccessor_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearServerStreaming, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearServerStreaming) -> Bool { - if lhs.clearServerStreaming_p != rhs.clearServerStreaming_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNoStandardDescriptorAccessor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNoStandardDescriptorAccessor) -> Bool { + if lhs.clearNoStandardDescriptorAccessor_p != rhs.clearNoStandardDescriptorAccessor_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSourceCodeInfo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearSourceCodeInfo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearNumber\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14922,31 +16441,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceCo // 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.clearSourceCodeInfo_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearNumber_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearSourceCodeInfo_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearSourceCodeInfo_p, fieldNumber: 1) + if self.clearNumber_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearNumber_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceCodeInfo, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceCodeInfo) -> Bool { - if lhs.clearSourceCodeInfo_p != rhs.clearSourceCodeInfo_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearNumber) -> Bool { + if lhs.clearNumber_p != rhs.clearNumber_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceContext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSourceContext" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearSourceContext"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearObjcClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearObjcClassPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearObjcClassPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14954,31 +16471,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceCo // 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.clearSourceContext_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearObjcClassPrefix_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearSourceContext_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearSourceContext_p, fieldNumber: 1) + if self.clearObjcClassPrefix_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearObjcClassPrefix_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceContext, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceContext) -> Bool { - if lhs.clearSourceContext_p != rhs.clearSourceContext_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearObjcClassPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearObjcClassPrefix) -> Bool { + if lhs.clearObjcClassPrefix_p != rhs.clearObjcClassPrefix_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceFile: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSourceFile" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearSourceFile"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOneofIndex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearOneofIndex" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearOneofIndex\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -14986,31 +16501,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceFi // 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.clearSourceFile_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearOneofIndex_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearSourceFile_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearSourceFile_p, fieldNumber: 1) + if self.clearOneofIndex_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearOneofIndex_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceFile, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSourceFile) -> Bool { - if lhs.clearSourceFile_p != rhs.clearSourceFile_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOneofIndex, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOneofIndex) -> Bool { + if lhs.clearOneofIndex_p != rhs.clearOneofIndex_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearStart" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearStart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOptimizeFor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearOptimizeFor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearOptimizeFor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15018,31 +16531,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStart: S // 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.clearStart_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearOptimizeFor_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearStart_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearStart_p, fieldNumber: 1) + if self.clearOptimizeFor_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearOptimizeFor_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStart, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStart) -> Bool { - if lhs.clearStart_p != rhs.clearStart_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOptimizeFor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOptimizeFor) -> Bool { + if lhs.clearOptimizeFor_p != rhs.clearOptimizeFor_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearStringValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearStringValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15050,31 +16561,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStringVa // 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.clearStringValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearOptions_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearStringValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearStringValue_p, fieldNumber: 1) + if self.clearOptions_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearOptions_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStringValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearStringValue) -> Bool { - if lhs.clearStringValue_p != rhs.clearStringValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOptions) -> Bool { + if lhs.clearOptions_p != rhs.clearOptions_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSwiftPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSwiftPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearSwiftPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOutputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearOutputType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearOutputType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15082,31 +16591,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSwiftPre // 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.clearSwiftPrefix_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearOutputType_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearSwiftPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearSwiftPrefix_p, fieldNumber: 1) + if self.clearOutputType_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearOutputType_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSwiftPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSwiftPrefix) -> Bool { - if lhs.clearSwiftPrefix_p != rhs.clearSwiftPrefix_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOutputType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOutputType) -> Bool { + if lhs.clearOutputType_p != rhs.clearOutputType_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSyntax: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSyntax" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearSyntax"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOverridableFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearOverridableFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearOverridableFeatures\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15114,31 +16621,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSyntax: // 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.clearSyntax_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearOverridableFeatures_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearSyntax_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearSyntax_p, fieldNumber: 1) + if self.clearOverridableFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearOverridableFeatures_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSyntax, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearSyntax) -> Bool { - if lhs.clearSyntax_p != rhs.clearSyntax_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOverridableFeatures, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearOverridableFeatures) -> Bool { + if lhs.clearOverridableFeatures_p != rhs.clearOverridableFeatures_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTrailingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearTrailingComments" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearTrailingComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15146,31 +16651,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTrailing // 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.clearTrailingComments_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearPackage_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearTrailingComments_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearTrailingComments_p, fieldNumber: 1) + if self.clearPackage_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearPackage_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTrailingComments, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTrailingComments) -> Bool { - if lhs.clearTrailingComments_p != rhs.clearTrailingComments_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPackage) -> Bool { + if lhs.clearPackage_p != rhs.clearPackage_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPacked: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPacked" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearPacked\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15178,31 +16681,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearType: Sw // 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.clearType_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearPacked_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearType_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearType_p, fieldNumber: 1) + if self.clearPacked_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearPacked_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearType) -> Bool { - if lhs.clearType_p != rhs.clearType_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPacked, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPacked) -> Bool { + if lhs.clearPacked_p != rhs.clearPacked_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTypeName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearTypeName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearTypeName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPhpClassPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearPhpClassPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15210,31 +16711,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTypeName // 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.clearTypeName_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearPhpClassPrefix_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearTypeName_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearTypeName_p, fieldNumber: 1) + if self.clearPhpClassPrefix_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearPhpClassPrefix_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTypeName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearTypeName) -> Bool { - if lhs.clearTypeName_p != rhs.clearTypeName_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpClassPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpClassPrefix) -> Bool { + if lhs.clearPhpClassPrefix_p != rhs.clearPhpClassPrefix_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpMetadataNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPhpMetadataNamespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearPhpMetadataNamespace\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15242,31 +16741,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearValue: S // 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.clearValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearPhpMetadataNamespace_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearValue_p, fieldNumber: 1) + if self.clearPhpMetadataNamespace_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearPhpMetadataNamespace_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearValue) -> Bool { - if lhs.clearValue_p != rhs.clearValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpMetadataNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpMetadataNamespace) -> Bool { + if lhs.clearPhpMetadataNamespace_p != rhs.clearPhpMetadataNamespace_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearWeak: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clearWeak" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clearWeak"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPhpNamespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearPhpNamespace\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15274,31 +16771,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearWeak: Sw // 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.clearWeak_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearPhpNamespace_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clearWeak_p != 0 { - try visitor.visitSingularInt32Field(value: self.clearWeak_p, fieldNumber: 1) + if self.clearPhpNamespace_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearPhpNamespace_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearWeak, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clearWeak) -> Bool { - if lhs.clearWeak_p != rhs.clearWeak_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPhpNamespace) -> Bool { + if lhs.clearPhpNamespace_p != rhs.clearPhpNamespace_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clientStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".clientStreaming" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clientStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPositiveIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPositiveIntValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearPositiveIntValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15306,31 +16801,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clientStreami // 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.clientStreaming) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearPositiveIntValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.clientStreaming != 0 { - try visitor.visitSingularInt32Field(value: self.clientStreaming, fieldNumber: 1) + if self.clearPositiveIntValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearPositiveIntValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clientStreaming, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.clientStreaming) -> Bool { - if lhs.clientStreaming != rhs.clientStreaming {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPositiveIntValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPositiveIntValue) -> Bool { + if lhs.clearPositiveIntValue_p != rhs.clearPositiveIntValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codePoint: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".codePoint" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "codePoint"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearProto3Optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearProto3Optional" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearProto3Optional\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15338,31 +16831,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codePoint: Sw // 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.codePoint) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearProto3Optional_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.codePoint != 0 { - try visitor.visitSingularInt32Field(value: self.codePoint, fieldNumber: 1) + if self.clearProto3Optional_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearProto3Optional_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codePoint, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codePoint) -> Bool { - if lhs.codePoint != rhs.codePoint {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearProto3Optional, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearProto3Optional) -> Bool { + if lhs.clearProto3Optional_p != rhs.clearProto3Optional_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codeUnits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".codeUnits" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "codeUnits"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPyGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearPyGenericServices" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearPyGenericServices\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15370,31 +16861,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codeUnits: Sw // 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.codeUnits) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearPyGenericServices_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.codeUnits != 0 { - try visitor.visitSingularInt32Field(value: self.codeUnits, fieldNumber: 1) + if self.clearPyGenericServices_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearPyGenericServices_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codeUnits, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.codeUnits) -> Bool { - if lhs.codeUnits != rhs.codeUnits {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPyGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearPyGenericServices) -> Bool { + if lhs.clearPyGenericServices_p != rhs.clearPyGenericServices_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Collection: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Collection" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Collection"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRemovalError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearRemovalError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearRemovalError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15402,31 +16891,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Collection: S // 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.collection) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearRemovalError_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.collection != 0 { - try visitor.visitSingularInt32Field(value: self.collection, fieldNumber: 1) + if self.clearRemovalError_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearRemovalError_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Collection, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Collection) -> Bool { - if lhs.collection != rhs.collection {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRemovalError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRemovalError) -> Bool { + if lhs.clearRemovalError_p != rhs.clearRemovalError_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.com: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".com" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "com"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRepeated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearRepeated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearRepeated\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15434,31 +16921,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.com: SwiftPro // 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.com) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearRepeated_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.com != 0 { - try visitor.visitSingularInt32Field(value: self.com, fieldNumber: 1) + if self.clearRepeated_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearRepeated_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.com, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.com) -> Bool { - if lhs.com != rhs.com {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRepeated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRepeated) -> Bool { + if lhs.clearRepeated_p != rhs.clearRepeated_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.comma: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".comma" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "comma"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRepeatedFieldEncoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearRepeatedFieldEncoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearRepeatedFieldEncoding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15466,31 +16951,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.comma: SwiftP // 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.comma) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearRepeatedFieldEncoding_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.comma != 0 { - try visitor.visitSingularInt32Field(value: self.comma, fieldNumber: 1) + if self.clearRepeatedFieldEncoding_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearRepeatedFieldEncoding_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.comma, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.comma) -> Bool { - if lhs.comma != rhs.comma {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRepeatedFieldEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRepeatedFieldEncoding) -> Bool { + if lhs.clearRepeatedFieldEncoding_p != rhs.clearRepeatedFieldEncoding_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.contentsOf: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".contentsOf" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "contentsOf"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearReserved: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearReserved" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearReserved\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15498,31 +16981,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.contentsOf: S // 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.contentsOf) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearReserved_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.contentsOf != 0 { - try visitor.visitSingularInt32Field(value: self.contentsOf, fieldNumber: 1) + if self.clearReserved_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearReserved_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.contentsOf, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.contentsOf) -> Bool { - if lhs.contentsOf != rhs.contentsOf {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearReserved, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearReserved) -> Bool { + if lhs.clearReserved_p != rhs.clearReserved_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ContiguousBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ContiguousBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ContiguousBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRetention: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearRetention" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearRetention\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15530,31 +17011,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ContiguousByt // 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.contiguousBytes) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearRetention_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.contiguousBytes != 0 { - try visitor.visitSingularInt32Field(value: self.contiguousBytes, fieldNumber: 1) + if self.clearRetention_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearRetention_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ContiguousBytes, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ContiguousBytes) -> Bool { - if lhs.contiguousBytes != rhs.contiguousBytes {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRetention, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRetention) -> Bool { + if lhs.clearRetention_p != rhs.clearRetention_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.count: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".count" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "count"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRubyPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearRubyPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearRubyPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15562,31 +17041,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.count: SwiftP // 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.count) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearRubyPackage_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.count != 0 { - try visitor.visitSingularInt32Field(value: self.count, fieldNumber: 1) + if self.clearRubyPackage_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearRubyPackage_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.count, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.count) -> Bool { - if lhs.count != rhs.count {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRubyPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearRubyPackage) -> Bool { + if lhs.clearRubyPackage_p != rhs.clearRubyPackage_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.countVarintsInBuffer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".countVarintsInBuffer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "countVarintsInBuffer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSemantic: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSemantic" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearSemantic\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15594,31 +17071,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.countVarintsI // 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.countVarintsInBuffer) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearSemantic_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.countVarintsInBuffer != 0 { - try visitor.visitSingularInt32Field(value: self.countVarintsInBuffer, fieldNumber: 1) + if self.clearSemantic_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearSemantic_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.countVarintsInBuffer, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.countVarintsInBuffer) -> Bool { - if lhs.countVarintsInBuffer != rhs.countVarintsInBuffer {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSemantic, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSemantic) -> Bool { + if lhs.clearSemantic_p != rhs.clearSemantic_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.csharpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".csharpNamespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "csharpNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearServerStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearServerStreaming" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearServerStreaming\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15626,31 +17101,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.csharpNamespa // 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.csharpNamespace) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearServerStreaming_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.csharpNamespace != 0 { - try visitor.visitSingularInt32Field(value: self.csharpNamespace, fieldNumber: 1) + if self.clearServerStreaming_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearServerStreaming_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.csharpNamespace, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.csharpNamespace) -> Bool { - if lhs.csharpNamespace != rhs.csharpNamespace {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearServerStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearServerStreaming) -> Bool { + if lhs.clearServerStreaming_p != rhs.clearServerStreaming_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ctype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ctype" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ctype"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSourceCodeInfo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearSourceCodeInfo\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15658,31 +17131,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ctype: SwiftP // 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.ctype) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearSourceCodeInfo_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.ctype != 0 { - try visitor.visitSingularInt32Field(value: self.ctype, fieldNumber: 1) + if self.clearSourceCodeInfo_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearSourceCodeInfo_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ctype, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ctype) -> Bool { - if lhs.ctype != rhs.ctype {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceCodeInfo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceCodeInfo) -> Bool { + if lhs.clearSourceCodeInfo_p != rhs.clearSourceCodeInfo_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.customCodable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".customCodable" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "customCodable"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceContext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSourceContext" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearSourceContext\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15690,31 +17161,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.customCodable // 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.customCodable) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearSourceContext_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.customCodable != 0 { - try visitor.visitSingularInt32Field(value: self.customCodable, fieldNumber: 1) + if self.clearSourceContext_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearSourceContext_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.customCodable, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.customCodable) -> Bool { - if lhs.customCodable != rhs.customCodable {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceContext, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceContext) -> Bool { + if lhs.clearSourceContext_p != rhs.clearSourceContext_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.CustomDebugStringConvertible: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".CustomDebugStringConvertible" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "CustomDebugStringConvertible"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceFile: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSourceFile" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearSourceFile\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15722,31 +17191,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.CustomDebugSt // 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.customDebugStringConvertible) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearSourceFile_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.customDebugStringConvertible != 0 { - try visitor.visitSingularInt32Field(value: self.customDebugStringConvertible, fieldNumber: 1) + if self.clearSourceFile_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearSourceFile_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.CustomDebugStringConvertible, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.CustomDebugStringConvertible) -> Bool { - if lhs.customDebugStringConvertible != rhs.customDebugStringConvertible {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceFile, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSourceFile) -> Bool { + if lhs.clearSourceFile_p != rhs.clearSourceFile_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.d: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".d" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "d"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearStart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearStart" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearStart\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15754,31 +17221,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.d: SwiftProto // 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.d) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearStart_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.d != 0 { - try visitor.visitSingularInt32Field(value: self.d, fieldNumber: 1) + if self.clearStart_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearStart_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.d, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.d) -> Bool { - if lhs.d != rhs.d {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearStart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearStart) -> Bool { + if lhs.clearStart_p != rhs.clearStart_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Data" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Data"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearStringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearStringValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearStringValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15786,31 +17251,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DataMessage: // 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.data) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearStringValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.data != 0 { - try visitor.visitSingularInt32Field(value: self.data, fieldNumber: 1) + if self.clearStringValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearStringValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DataMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DataMessage) -> Bool { - if lhs.data != rhs.data {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearStringValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearStringValue) -> Bool { + if lhs.clearStringValue_p != rhs.clearStringValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dataResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".dataResult" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "dataResult"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSwiftPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSwiftPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearSwiftPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15818,31 +17281,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dataResult: S // 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.dataResult) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearSwiftPrefix_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.dataResult != 0 { - try visitor.visitSingularInt32Field(value: self.dataResult, fieldNumber: 1) + if self.clearSwiftPrefix_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearSwiftPrefix_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dataResult, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dataResult) -> Bool { - if lhs.dataResult != rhs.dataResult {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSwiftPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSwiftPrefix) -> Bool { + if lhs.clearSwiftPrefix_p != rhs.clearSwiftPrefix_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.date: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".date" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "date"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSyntax: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearSyntax" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearSyntax\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15850,31 +17311,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.date: SwiftPr // 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.date) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearSyntax_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.date != 0 { - try visitor.visitSingularInt32Field(value: self.date, fieldNumber: 1) + if self.clearSyntax_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearSyntax_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.date, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.date) -> Bool { - if lhs.date != rhs.date {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSyntax, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearSyntax) -> Bool { + if lhs.clearSyntax_p != rhs.clearSyntax_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daySec: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".daySec" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "daySec"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearTrailingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearTrailingComments" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearTrailingComments\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15882,31 +17341,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daySec: Swift // 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.daySec) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearTrailingComments_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.daySec != 0 { - try visitor.visitSingularInt32Field(value: self.daySec, fieldNumber: 1) + if self.clearTrailingComments_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearTrailingComments_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daySec, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daySec) -> Bool { - if lhs.daySec != rhs.daySec {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearTrailingComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearTrailingComments) -> Bool { + if lhs.clearTrailingComments_p != rhs.clearTrailingComments_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daysSinceEpoch: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".daysSinceEpoch" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "daysSinceEpoch"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15914,31 +17371,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daysSinceEpoc // 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.daysSinceEpoch) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearType_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.daysSinceEpoch != 0 { - try visitor.visitSingularInt32Field(value: self.daysSinceEpoch, fieldNumber: 1) + if self.clearType_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearType_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daysSinceEpoch, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.daysSinceEpoch) -> Bool { - if lhs.daysSinceEpoch != rhs.daysSinceEpoch {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearType) -> Bool { + if lhs.clearType_p != rhs.clearType_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.debugDescriptionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".debugDescription" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "debugDescription"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearTypeName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearTypeName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearTypeName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15946,31 +17401,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.debugDescript // 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.debugDescription_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearTypeName_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.debugDescription_p != 0 { - try visitor.visitSingularInt32Field(value: self.debugDescription_p, fieldNumber: 1) + if self.clearTypeName_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearTypeName_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.debugDescriptionMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.debugDescriptionMessage) -> Bool { - if lhs.debugDescription_p != rhs.debugDescription_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearTypeName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearTypeName) -> Bool { + if lhs.clearTypeName_p != rhs.clearTypeName_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoded: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decoded" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decoded"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearUnverifiedLazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearUnverifiedLazy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearUnverifiedLazy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -15978,31 +17431,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoded: Swif // 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.decoded) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearUnverifiedLazy_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decoded != 0 { - try visitor.visitSingularInt32Field(value: self.decoded, fieldNumber: 1) + if self.clearUnverifiedLazy_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearUnverifiedLazy_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoded, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoded) -> Bool { - if lhs.decoded != rhs.decoded {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearUnverifiedLazy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearUnverifiedLazy) -> Bool { + if lhs.clearUnverifiedLazy_p != rhs.clearUnverifiedLazy_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodedFromJSONNull: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodedFromJSONNull" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodedFromJSONNull"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearUtf8Validation: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearUtf8Validation" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearUtf8Validation\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16010,31 +17461,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodedFromJS // 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.decodedFromJsonnull) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearUtf8Validation_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodedFromJsonnull != 0 { - try visitor.visitSingularInt32Field(value: self.decodedFromJsonnull, fieldNumber: 1) + if self.clearUtf8Validation_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearUtf8Validation_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodedFromJSONNull, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodedFromJSONNull) -> Bool { - if lhs.decodedFromJsonnull != rhs.decodedFromJsonnull {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearUtf8Validation, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearUtf8Validation) -> Bool { + if lhs.clearUtf8Validation_p != rhs.clearUtf8Validation_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16042,31 +17491,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensi // 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.decodeExtensionField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeExtensionField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeExtensionField, fieldNumber: 1) + if self.clearValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensionField) -> Bool { - if lhs.decodeExtensionField != rhs.decodeExtensionField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearValue) -> Bool { + if lhs.clearValue_p != rhs.clearValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensionFieldsAsMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeExtensionFieldsAsMessageSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeExtensionFieldsAsMessageSet"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearVerification: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearVerification" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearVerification\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16074,31 +17521,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensi // 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.decodeExtensionFieldsAsMessageSet) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearVerification_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeExtensionFieldsAsMessageSet != 0 { - try visitor.visitSingularInt32Field(value: self.decodeExtensionFieldsAsMessageSet, fieldNumber: 1) + if self.clearVerification_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearVerification_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensionFieldsAsMessageSet, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeExtensionFieldsAsMessageSet) -> Bool { - if lhs.decodeExtensionFieldsAsMessageSet != rhs.decodeExtensionFieldsAsMessageSet {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearVerification, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearVerification) -> Bool { + if lhs.clearVerification_p != rhs.clearVerification_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeJSON: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeJSON" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeJSON"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearVisibility: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearVisibility" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearVisibility\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16106,31 +17551,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeJSON: S // 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.decodeJson) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearVisibility_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeJson != 0 { - try visitor.visitSingularInt32Field(value: self.decodeJson, fieldNumber: 1) + if self.clearVisibility_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearVisibility_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeJSON, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeJSON) -> Bool { - if lhs.decodeJson != rhs.decodeJson {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearVisibility, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearVisibility) -> Bool { + if lhs.clearVisibility_p != rhs.clearVisibility_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMapField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeMapField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeMapField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearWeak: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clearWeak" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clearWeak\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16138,31 +17581,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMapFiel // 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.decodeMapField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clearWeak_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeMapField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeMapField, fieldNumber: 1) + if self.clearWeak_p != 0 { + try visitor.visitSingularInt32Field(value: self.clearWeak_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMapField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMapField) -> Bool { - if lhs.decodeMapField != rhs.decodeMapField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearWeak, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clearWeak) -> Bool { + if lhs.clearWeak_p != rhs.clearWeak_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMessageMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeMessage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clientStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".clientStreaming" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clientStreaming\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16170,31 +17611,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMessage // 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.decodeMessage) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.clientStreaming) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeMessage != 0 { - try visitor.visitSingularInt32Field(value: self.decodeMessage, fieldNumber: 1) + if self.clientStreaming != 0 { + try visitor.visitSingularInt32Field(value: self.clientStreaming, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMessageMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeMessageMessage) -> Bool { - if lhs.decodeMessage != rhs.decodeMessage {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clientStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.clientStreaming) -> Bool { + if lhs.clientStreaming != rhs.clientStreaming {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.code: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".code" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}code\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16202,31 +17641,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoder: Swif // 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.decoder) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.code) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decoder != 0 { - try visitor.visitSingularInt32Field(value: self.decoder, fieldNumber: 1) + if self.code != 0 { + try visitor.visitSingularInt32Field(value: self.code, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decoder) -> Bool { - if lhs.decoder != rhs.decoder {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.code, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.code) -> Bool { + if lhs.code != rhs.code {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeated" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeated"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.codePoint: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".codePoint" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}codePoint\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16234,31 +17671,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeated) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.codePoint) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeated != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeated, fieldNumber: 1) + if self.codePoint != 0 { + try visitor.visitSingularInt32Field(value: self.codePoint, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeated, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeated) -> Bool { - if lhs.decodeRepeated != rhs.decodeRepeated {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.codePoint, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.codePoint) -> Bool { + if lhs.codePoint != rhs.codePoint {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedBoolField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedBoolField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.codeUnits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".codeUnits" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}codeUnits\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16266,31 +17701,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedBoolField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.codeUnits) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedBoolField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedBoolField, fieldNumber: 1) + if self.codeUnits != 0 { + try visitor.visitSingularInt32Field(value: self.codeUnits, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedBoolField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedBoolField) -> Bool { - if lhs.decodeRepeatedBoolField != rhs.decodeRepeatedBoolField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.codeUnits, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.codeUnits) -> Bool { + if lhs.codeUnits != rhs.codeUnits {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedBytesField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedBytesField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedBytesField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Collection: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Collection" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Collection\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16298,31 +17731,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedBytesField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.collection) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedBytesField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedBytesField, fieldNumber: 1) + if self.collection != 0 { + try visitor.visitSingularInt32Field(value: self.collection, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedBytesField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedBytesField) -> Bool { - if lhs.decodeRepeatedBytesField != rhs.decodeRepeatedBytesField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Collection, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Collection) -> Bool { + if lhs.collection != rhs.collection {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedDoubleField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedDoubleField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.comma: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".comma" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}comma\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16330,31 +17761,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedDoubleField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.comma) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedDoubleField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedDoubleField, fieldNumber: 1) + if self.comma != 0 { + try visitor.visitSingularInt32Field(value: self.comma, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedDoubleField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedDoubleField) -> Bool { - if lhs.decodeRepeatedDoubleField != rhs.decodeRepeatedDoubleField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.comma, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.comma) -> Bool { + if lhs.comma != rhs.comma {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedEnumField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedEnumField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.consumedBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".consumedBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}consumedBytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16362,31 +17791,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedEnumField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.consumedBytes) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedEnumField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedEnumField, fieldNumber: 1) + if self.consumedBytes != 0 { + try visitor.visitSingularInt32Field(value: self.consumedBytes, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedEnumField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedEnumField) -> Bool { - if lhs.decodeRepeatedEnumField != rhs.decodeRepeatedEnumField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.consumedBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.consumedBytes) -> Bool { + if lhs.consumedBytes != rhs.consumedBytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.contains: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".contains" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}contains\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16394,31 +17821,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedFixed32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.contains) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedFixed32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedFixed32Field, fieldNumber: 1) + if self.contains != 0 { + try visitor.visitSingularInt32Field(value: self.contains, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFixed32Field) -> Bool { - if lhs.decodeRepeatedFixed32Field != rhs.decodeRepeatedFixed32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.contains, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.contains) -> Bool { + if lhs.contains != rhs.contains {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.contentsOf: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".contentsOf" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}contentsOf\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16426,31 +17851,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedFixed64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.contentsOf) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedFixed64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedFixed64Field, fieldNumber: 1) + if self.contentsOf != 0 { + try visitor.visitSingularInt32Field(value: self.contentsOf, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFixed64Field) -> Bool { - if lhs.decodeRepeatedFixed64Field != rhs.decodeRepeatedFixed64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.contentsOf, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.contentsOf) -> Bool { + if lhs.contentsOf != rhs.contentsOf {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedFloatField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedFloatField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ContiguousBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ContiguousBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ContiguousBytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16458,31 +17881,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedFloatField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.contiguousBytes) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedFloatField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedFloatField, fieldNumber: 1) + if self.contiguousBytes != 0 { + try visitor.visitSingularInt32Field(value: self.contiguousBytes, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFloatField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedFloatField) -> Bool { - if lhs.decodeRepeatedFloatField != rhs.decodeRepeatedFloatField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ContiguousBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ContiguousBytes) -> Bool { + if lhs.contiguousBytes != rhs.contiguousBytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedGroupField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedGroupField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.copy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".copy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}copy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16490,31 +17911,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedGroupField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.copy) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedGroupField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedGroupField, fieldNumber: 1) + if self.copy != 0 { + try visitor.visitSingularInt32Field(value: self.copy, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedGroupField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedGroupField) -> Bool { - if lhs.decodeRepeatedGroupField != rhs.decodeRepeatedGroupField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.copy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.copy) -> Bool { + if lhs.copy != rhs.copy {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.count: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".count" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}count\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16522,31 +17941,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedInt32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.count) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedInt32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedInt32Field, fieldNumber: 1) + if self.count != 0 { + try visitor.visitSingularInt32Field(value: self.count, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedInt32Field) -> Bool { - if lhs.decodeRepeatedInt32Field != rhs.decodeRepeatedInt32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.count, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.count) -> Bool { + if lhs.count != rhs.count {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.countVarintsInBuffer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".countVarintsInBuffer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}countVarintsInBuffer\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16554,31 +17971,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedInt64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.countVarintsInBuffer) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedInt64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedInt64Field, fieldNumber: 1) + if self.countVarintsInBuffer != 0 { + try visitor.visitSingularInt32Field(value: self.countVarintsInBuffer, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedInt64Field) -> Bool { - if lhs.decodeRepeatedInt64Field != rhs.decodeRepeatedInt64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.countVarintsInBuffer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.countVarintsInBuffer) -> Bool { + if lhs.countVarintsInBuffer != rhs.countVarintsInBuffer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedMessageField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedMessageField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.csharpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".csharpNamespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}csharpNamespace\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16586,31 +18001,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedMessageField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.csharpNamespace) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedMessageField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedMessageField, fieldNumber: 1) + if self.csharpNamespace != 0 { + try visitor.visitSingularInt32Field(value: self.csharpNamespace, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedMessageField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedMessageField) -> Bool { - if lhs.decodeRepeatedMessageField != rhs.decodeRepeatedMessageField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.csharpNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.csharpNamespace) -> Bool { + if lhs.csharpNamespace != rhs.csharpNamespace {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedSFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedSFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ctype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ctype" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ctype\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16618,31 +18031,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedSfixed32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.ctype) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedSfixed32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedSfixed32Field, fieldNumber: 1) + if self.ctype != 0 { + try visitor.visitSingularInt32Field(value: self.ctype, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed32Field) -> Bool { - if lhs.decodeRepeatedSfixed32Field != rhs.decodeRepeatedSfixed32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ctype, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ctype) -> Bool { + if lhs.ctype != rhs.ctype {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedSFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedSFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.customCodable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".customCodable" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}customCodable\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16650,31 +18061,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedSfixed64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.customCodable) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedSfixed64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedSfixed64Field, fieldNumber: 1) + if self.customCodable != 0 { + try visitor.visitSingularInt32Field(value: self.customCodable, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed64Field) -> Bool { - if lhs.decodeRepeatedSfixed64Field != rhs.decodeRepeatedSfixed64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.customCodable, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.customCodable) -> Bool { + if lhs.customCodable != rhs.customCodable {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedSInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedSInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CustomDebugStringConvertible: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".CustomDebugStringConvertible" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}CustomDebugStringConvertible\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16682,31 +18091,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedSint32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.customDebugStringConvertible) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedSint32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedSint32Field, fieldNumber: 1) + if self.customDebugStringConvertible != 0 { + try visitor.visitSingularInt32Field(value: self.customDebugStringConvertible, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSInt32Field) -> Bool { - if lhs.decodeRepeatedSint32Field != rhs.decodeRepeatedSint32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CustomDebugStringConvertible, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CustomDebugStringConvertible) -> Bool { + if lhs.customDebugStringConvertible != rhs.customDebugStringConvertible {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedSInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedSInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CustomStringConvertible: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".CustomStringConvertible" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}CustomStringConvertible\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16714,31 +18121,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedSint64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.customStringConvertible) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedSint64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedSint64Field, fieldNumber: 1) + if self.customStringConvertible != 0 { + try visitor.visitSingularInt32Field(value: self.customStringConvertible, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedSInt64Field) -> Bool { - if lhs.decodeRepeatedSint64Field != rhs.decodeRepeatedSint64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CustomStringConvertible, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.CustomStringConvertible) -> Bool { + if lhs.customStringConvertible != rhs.customStringConvertible {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedStringField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedStringField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedStringField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.D: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".D" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}D\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16746,31 +18151,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedStringField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.d) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedStringField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedStringField, fieldNumber: 1) + if self.d != 0 { + try visitor.visitSingularInt32Field(value: self.d, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedStringField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedStringField) -> Bool { - if lhs.decodeRepeatedStringField != rhs.decodeRepeatedStringField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.D, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.D) -> Bool { + if lhs.d != rhs.d {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedUInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedUInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DataMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Data\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16778,31 +18181,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedUint32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.data) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedUint32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedUint32Field, fieldNumber: 1) + if self.data != 0 { + try visitor.visitSingularInt32Field(value: self.data, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedUInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedUInt32Field) -> Bool { - if lhs.decodeRepeatedUint32Field != rhs.decodeRepeatedUint32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DataMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DataMessage) -> Bool { + if lhs.data != rhs.data {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedUInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeRepeatedUInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dataResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".dataResult" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}dataResult\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16810,31 +18211,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeate // 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.decodeRepeatedUint64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.dataResult) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeRepeatedUint64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeRepeatedUint64Field, fieldNumber: 1) + if self.dataResult != 0 { + try visitor.visitSingularInt32Field(value: self.dataResult, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedUInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeRepeatedUInt64Field) -> Bool { - if lhs.decodeRepeatedUint64Field != rhs.decodeRepeatedUint64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dataResult, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dataResult) -> Bool { + if lhs.dataResult != rhs.dataResult {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingular: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingular" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingular"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.date: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".date" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}date\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16842,31 +18241,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingular) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.date) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingular != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingular, fieldNumber: 1) + if self.date != 0 { + try visitor.visitSingularInt32Field(value: self.date, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingular, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingular) -> Bool { - if lhs.decodeSingular != rhs.decodeSingular {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.date, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.date) -> Bool { + if lhs.date != rhs.date {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularBoolField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularBoolField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.daySec: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".daySec" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}daySec\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16874,31 +18271,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularBoolField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.daySec) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularBoolField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularBoolField, fieldNumber: 1) + if self.daySec != 0 { + try visitor.visitSingularInt32Field(value: self.daySec, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularBoolField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularBoolField) -> Bool { - if lhs.decodeSingularBoolField != rhs.decodeSingularBoolField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.daySec, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.daySec) -> Bool { + if lhs.daySec != rhs.daySec {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularBytesField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularBytesField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularBytesField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.daysSinceEpoch: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".daysSinceEpoch" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}daysSinceEpoch\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16906,31 +18301,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularBytesField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.daysSinceEpoch) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularBytesField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularBytesField, fieldNumber: 1) + if self.daysSinceEpoch != 0 { + try visitor.visitSingularInt32Field(value: self.daysSinceEpoch, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularBytesField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularBytesField) -> Bool { - if lhs.decodeSingularBytesField != rhs.decodeSingularBytesField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.daysSinceEpoch, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.daysSinceEpoch) -> Bool { + if lhs.daysSinceEpoch != rhs.daysSinceEpoch {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularDoubleField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularDoubleField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.debugDescriptionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".debugDescription" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}debugDescription\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16938,31 +18331,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularDoubleField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.debugDescription_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularDoubleField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularDoubleField, fieldNumber: 1) + if self.debugDescription_p != 0 { + try visitor.visitSingularInt32Field(value: self.debugDescription_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularDoubleField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularDoubleField) -> Bool { - if lhs.decodeSingularDoubleField != rhs.decodeSingularDoubleField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.debugDescriptionMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.debugDescriptionMessage) -> Bool { + if lhs.debugDescription_p != rhs.debugDescription_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularEnumField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularEnumField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.debugRedact: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".debugRedact" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}debugRedact\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -16970,31 +18361,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularEnumField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.debugRedact) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularEnumField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularEnumField, fieldNumber: 1) + if self.debugRedact != 0 { + try visitor.visitSingularInt32Field(value: self.debugRedact, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularEnumField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularEnumField) -> Bool { - if lhs.decodeSingularEnumField != rhs.decodeSingularEnumField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.debugRedact, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.debugRedact) -> Bool { + if lhs.debugRedact != rhs.debugRedact {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.declaration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".declaration" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}declaration\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17002,31 +18391,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularFixed32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.declaration) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularFixed32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularFixed32Field, fieldNumber: 1) + if self.declaration != 0 { + try visitor.visitSingularInt32Field(value: self.declaration, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFixed32Field) -> Bool { - if lhs.decodeSingularFixed32Field != rhs.decodeSingularFixed32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.declaration, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.declaration) -> Bool { + if lhs.declaration != rhs.declaration {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decoded: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decoded" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decoded\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17034,31 +18421,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularFixed64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decoded) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularFixed64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularFixed64Field, fieldNumber: 1) + if self.decoded != 0 { + try visitor.visitSingularInt32Field(value: self.decoded, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFixed64Field) -> Bool { - if lhs.decodeSingularFixed64Field != rhs.decodeSingularFixed64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decoded, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decoded) -> Bool { + if lhs.decoded != rhs.decoded {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularFloatField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularFloatField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodedFromJSONNull: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodedFromJSONNull" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodedFromJSONNull\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17066,31 +18451,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularFloatField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodedFromJsonnull) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularFloatField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularFloatField, fieldNumber: 1) + if self.decodedFromJsonnull != 0 { + try visitor.visitSingularInt32Field(value: self.decodedFromJsonnull, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFloatField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularFloatField) -> Bool { - if lhs.decodeSingularFloatField != rhs.decodeSingularFloatField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodedFromJSONNull, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodedFromJSONNull) -> Bool { + if lhs.decodedFromJsonnull != rhs.decodedFromJsonnull {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularGroupField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularGroupField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17098,31 +18481,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularGroupField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeExtensionField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularGroupField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularGroupField, fieldNumber: 1) + if self.decodeExtensionField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeExtensionField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularGroupField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularGroupField) -> Bool { - if lhs.decodeSingularGroupField != rhs.decodeSingularGroupField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeExtensionField) -> Bool { + if lhs.decodeExtensionField != rhs.decodeExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeExtensionFieldsAsMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeExtensionFieldsAsMessageSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeExtensionFieldsAsMessageSet\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17130,31 +18511,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularInt32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeExtensionFieldsAsMessageSet) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularInt32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularInt32Field, fieldNumber: 1) + if self.decodeExtensionFieldsAsMessageSet != 0 { + try visitor.visitSingularInt32Field(value: self.decodeExtensionFieldsAsMessageSet, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularInt32Field) -> Bool { - if lhs.decodeSingularInt32Field != rhs.decodeSingularInt32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeExtensionFieldsAsMessageSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeExtensionFieldsAsMessageSet) -> Bool { + if lhs.decodeExtensionFieldsAsMessageSet != rhs.decodeExtensionFieldsAsMessageSet {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeJSON: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeJSON" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeJSON\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17162,31 +18541,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularInt64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeJson) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularInt64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularInt64Field, fieldNumber: 1) + if self.decodeJson != 0 { + try visitor.visitSingularInt32Field(value: self.decodeJson, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularInt64Field) -> Bool { - if lhs.decodeSingularInt64Field != rhs.decodeSingularInt64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeJSON, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeJSON) -> Bool { + if lhs.decodeJson != rhs.decodeJson {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularMessageField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularMessageField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeMapField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeMapField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeMapField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17194,31 +18571,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularMessageField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeMapField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularMessageField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularMessageField, fieldNumber: 1) + if self.decodeMapField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeMapField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularMessageField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularMessageField) -> Bool { - if lhs.decodeSingularMessageField != rhs.decodeSingularMessageField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeMapField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeMapField) -> Bool { + if lhs.decodeMapField != rhs.decodeMapField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularSFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularSFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeMessageMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeMessage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17226,31 +18601,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularSfixed32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeMessage) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularSfixed32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularSfixed32Field, fieldNumber: 1) + if self.decodeMessage != 0 { + try visitor.visitSingularInt32Field(value: self.decodeMessage, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSFixed32Field) -> Bool { - if lhs.decodeSingularSfixed32Field != rhs.decodeSingularSfixed32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeMessageMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeMessageMessage) -> Bool { + if lhs.decodeMessage != rhs.decodeMessage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularSFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularSFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Decoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Decoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Decoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17258,31 +18631,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularSfixed64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decoder) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularSfixed64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularSfixed64Field, fieldNumber: 1) + if self.decoder != 0 { + try visitor.visitSingularInt32Field(value: self.decoder, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSFixed64Field) -> Bool { - if lhs.decodeSingularSfixed64Field != rhs.decodeSingularSfixed64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Decoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Decoder) -> Bool { + if lhs.decoder != rhs.decoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularSInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularSInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeated\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17290,31 +18661,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularSint32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeated) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularSint32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularSint32Field, fieldNumber: 1) + if self.decodeRepeated != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeated, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSInt32Field) -> Bool { - if lhs.decodeSingularSint32Field != rhs.decodeSingularSint32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeated) -> Bool { + if lhs.decodeRepeated != rhs.decodeRepeated {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularSInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularSInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedBoolField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedBoolField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17322,31 +18691,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularSint64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedBoolField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularSint64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularSint64Field, fieldNumber: 1) + if self.decodeRepeatedBoolField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedBoolField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularSInt64Field) -> Bool { - if lhs.decodeSingularSint64Field != rhs.decodeSingularSint64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedBoolField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedBoolField) -> Bool { + if lhs.decodeRepeatedBoolField != rhs.decodeRepeatedBoolField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularStringField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularStringField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularStringField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedBytesField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedBytesField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedBytesField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17354,31 +18721,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularStringField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedBytesField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularStringField != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularStringField, fieldNumber: 1) + if self.decodeRepeatedBytesField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedBytesField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularStringField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularStringField) -> Bool { - if lhs.decodeSingularStringField != rhs.decodeSingularStringField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedBytesField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedBytesField) -> Bool { + if lhs.decodeRepeatedBytesField != rhs.decodeRepeatedBytesField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularUInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularUInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedDoubleField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedDoubleField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17386,31 +18751,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularUint32Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedDoubleField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularUint32Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularUint32Field, fieldNumber: 1) + if self.decodeRepeatedDoubleField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedDoubleField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularUInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularUInt32Field) -> Bool { - if lhs.decodeSingularUint32Field != rhs.decodeSingularUint32Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedDoubleField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedDoubleField) -> Bool { + if lhs.decodeRepeatedDoubleField != rhs.decodeRepeatedDoubleField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularUInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeSingularUInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedEnumField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedEnumField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17418,31 +18781,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingula // 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.decodeSingularUint64Field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedEnumField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeSingularUint64Field != 0 { - try visitor.visitSingularInt32Field(value: self.decodeSingularUint64Field, fieldNumber: 1) + if self.decodeRepeatedEnumField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedEnumField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularUInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeSingularUInt64Field) -> Bool { - if lhs.decodeSingularUint64Field != rhs.decodeSingularUint64Field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedEnumField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedEnumField) -> Bool { + if lhs.decodeRepeatedEnumField != rhs.decodeRepeatedEnumField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeTextFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeTextFormat" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decodeTextFormat"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17450,31 +18811,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeTextFor // 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.decodeTextFormat) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedFixed32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.decodeTextFormat != 0 { - try visitor.visitSingularInt32Field(value: self.decodeTextFormat, fieldNumber: 1) + if self.decodeRepeatedFixed32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedFixed32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeTextFormat, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.decodeTextFormat) -> Bool { - if lhs.decodeTextFormat != rhs.decodeTextFormat {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFixed32Field) -> Bool { + if lhs.decodeRepeatedFixed32Field != rhs.decodeRepeatedFixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultAnyTypeURLPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".defaultAnyTypeURLPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "defaultAnyTypeURLPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17482,31 +18841,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultAnyTyp // 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.defaultAnyTypeUrlprefix) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedFixed64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.defaultAnyTypeUrlprefix != 0 { - try visitor.visitSingularInt32Field(value: self.defaultAnyTypeUrlprefix, fieldNumber: 1) + if self.decodeRepeatedFixed64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedFixed64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultAnyTypeURLPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultAnyTypeURLPrefix) -> Bool { - if lhs.defaultAnyTypeUrlprefix != rhs.defaultAnyTypeUrlprefix {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFixed64Field) -> Bool { + if lhs.decodeRepeatedFixed64Field != rhs.decodeRepeatedFixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".defaultValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "defaultValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedFloatField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedFloatField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17514,31 +18871,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultValue: // 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.defaultValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedFloatField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.defaultValue != 0 { - try visitor.visitSingularInt32Field(value: self.defaultValue, fieldNumber: 1) + if self.decodeRepeatedFloatField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedFloatField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.defaultValue) -> Bool { - if lhs.defaultValue != rhs.defaultValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFloatField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedFloatField) -> Bool { + if lhs.decodeRepeatedFloatField != rhs.decodeRepeatedFloatField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dependency: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".dependency" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "dependency"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedGroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedGroupField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17546,31 +18901,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dependency: S // 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.dependency) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedGroupField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.dependency != 0 { - try visitor.visitSingularInt32Field(value: self.dependency, fieldNumber: 1) + if self.decodeRepeatedGroupField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedGroupField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dependency, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dependency) -> Bool { - if lhs.dependency != rhs.dependency {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedGroupField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedGroupField) -> Bool { + if lhs.decodeRepeatedGroupField != rhs.decodeRepeatedGroupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.deprecated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".deprecated" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "deprecated"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17578,31 +18931,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.deprecated: S // 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.deprecated) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedInt32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.deprecated != 0 { - try visitor.visitSingularInt32Field(value: self.deprecated, fieldNumber: 1) + if self.decodeRepeatedInt32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedInt32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.deprecated, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.deprecated) -> Bool { - if lhs.deprecated != rhs.deprecated {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedInt32Field) -> Bool { + if lhs.decodeRepeatedInt32Field != rhs.decodeRepeatedInt32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.descriptionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".description" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "description"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17610,31 +18961,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.descriptionMe // 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.description_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedInt64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.description_p != 0 { - try visitor.visitSingularInt32Field(value: self.description_p, fieldNumber: 1) + if self.decodeRepeatedInt64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedInt64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.descriptionMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.descriptionMessage) -> Bool { - if lhs.description_p != rhs.description_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedInt64Field) -> Bool { + if lhs.decodeRepeatedInt64Field != rhs.decodeRepeatedInt64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".DescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "DescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedMessageField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedMessageField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17642,31 +18991,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DescriptorPro // 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.descriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedMessageField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.descriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.descriptorProto, fieldNumber: 1) + if self.decodeRepeatedMessageField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedMessageField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.DescriptorProto) -> Bool { - if lhs.descriptorProto != rhs.descriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedMessageField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedMessageField) -> Bool { + if lhs.decodeRepeatedMessageField != rhs.decodeRepeatedMessageField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Dictionary: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Dictionary" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Dictionary"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedSFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedSFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17674,31 +19021,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Dictionary: S // 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.dictionary) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedSfixed32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.dictionary != 0 { - try visitor.visitSingularInt32Field(value: self.dictionary, fieldNumber: 1) + if self.decodeRepeatedSfixed32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedSfixed32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Dictionary, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Dictionary) -> Bool { - if lhs.dictionary != rhs.dictionary {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed32Field) -> Bool { + if lhs.decodeRepeatedSfixed32Field != rhs.decodeRepeatedSfixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dictionaryLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".dictionaryLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "dictionaryLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedSFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedSFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17706,31 +19051,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dictionaryLit // 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.dictionaryLiteral) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedSfixed64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.dictionaryLiteral != 0 { - try visitor.visitSingularInt32Field(value: self.dictionaryLiteral, fieldNumber: 1) + if self.decodeRepeatedSfixed64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedSfixed64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dictionaryLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.dictionaryLiteral) -> Bool { - if lhs.dictionaryLiteral != rhs.dictionaryLiteral {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSFixed64Field) -> Bool { + if lhs.decodeRepeatedSfixed64Field != rhs.decodeRepeatedSfixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".digit" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "digit"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedSInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedSInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17738,31 +19081,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit: SwiftP // 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.digit) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedSint32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.digit != 0 { - try visitor.visitSingularInt32Field(value: self.digit, fieldNumber: 1) + if self.decodeRepeatedSint32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedSint32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit) -> Bool { - if lhs.digit != rhs.digit {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSInt32Field) -> Bool { + if lhs.decodeRepeatedSint32Field != rhs.decodeRepeatedSint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit0: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".digit0" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "digit0"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedSInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedSInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17770,31 +19111,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit0: Swift // 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.digit0) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedSint64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.digit0 != 0 { - try visitor.visitSingularInt32Field(value: self.digit0, fieldNumber: 1) + if self.decodeRepeatedSint64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedSint64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit0, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit0) -> Bool { - if lhs.digit0 != rhs.digit0 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedSInt64Field) -> Bool { + if lhs.decodeRepeatedSint64Field != rhs.decodeRepeatedSint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".digit1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "digit1"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedStringField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedStringField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedStringField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17802,31 +19141,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit1: Swift // 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.digit1) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedStringField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.digit1 != 0 { - try visitor.visitSingularInt32Field(value: self.digit1, fieldNumber: 1) + if self.decodeRepeatedStringField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedStringField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit1, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digit1) -> Bool { - if lhs.digit1 != rhs.digit1 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedStringField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedStringField) -> Bool { + if lhs.decodeRepeatedStringField != rhs.decodeRepeatedStringField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".digitCount" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "digitCount"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedUInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedUInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17834,31 +19171,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitCount: S // 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.digitCount) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedUint32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.digitCount != 0 { - try visitor.visitSingularInt32Field(value: self.digitCount, fieldNumber: 1) + if self.decodeRepeatedUint32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedUint32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitCount, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitCount) -> Bool { - if lhs.digitCount != rhs.digitCount {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedUInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedUInt32Field) -> Bool { + if lhs.decodeRepeatedUint32Field != rhs.decodeRepeatedUint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".digits" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "digits"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeRepeatedUInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeRepeatedUInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17866,31 +19201,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digits: Swift // 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.digits) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeRepeatedUint64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.digits != 0 { - try visitor.visitSingularInt32Field(value: self.digits, fieldNumber: 1) + if self.decodeRepeatedUint64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeRepeatedUint64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digits, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digits) -> Bool { - if lhs.digits != rhs.digits {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedUInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeRepeatedUInt64Field) -> Bool { + if lhs.decodeRepeatedUint64Field != rhs.decodeRepeatedUint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".digitValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "digitValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingular: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingular" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingular\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17898,31 +19231,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitValue: S // 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.digitValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingular) }() default: break } } } func traverse(visitor: inout V) throws { - if self.digitValue != 0 { - try visitor.visitSingularInt32Field(value: self.digitValue, fieldNumber: 1) + if self.decodeSingular != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingular, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.digitValue) -> Bool { - if lhs.digitValue != rhs.digitValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingular, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingular) -> Bool { + if lhs.decodeSingular != rhs.decodeSingular {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardableResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".discardableResult" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "discardableResult"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularBoolField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularBoolField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17930,31 +19261,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardableRe // 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.discardableResult) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularBoolField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.discardableResult != 0 { - try visitor.visitSingularInt32Field(value: self.discardableResult, fieldNumber: 1) + if self.decodeSingularBoolField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularBoolField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardableResult, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardableResult) -> Bool { - if lhs.discardableResult != rhs.discardableResult {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularBoolField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularBoolField) -> Bool { + if lhs.decodeSingularBoolField != rhs.decodeSingularBoolField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardUnknownFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".discardUnknownFields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "discardUnknownFields"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularBytesField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularBytesField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularBytesField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17962,31 +19291,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardUnknow // 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.discardUnknownFields) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularBytesField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.discardUnknownFields != 0 { - try visitor.visitSingularInt32Field(value: self.discardUnknownFields, fieldNumber: 1) + if self.decodeSingularBytesField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularBytesField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardUnknownFields, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.discardUnknownFields) -> Bool { - if lhs.discardUnknownFields != rhs.discardUnknownFields {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularBytesField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularBytesField) -> Bool { + if lhs.decodeSingularBytesField != rhs.decodeSingularBytesField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.distance: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".distance" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "distance"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularDoubleField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularDoubleField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -17994,31 +19321,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.distance: Swi // 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.distance) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularDoubleField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.distance != 0 { - try visitor.visitSingularInt32Field(value: self.distance, fieldNumber: 1) + if self.decodeSingularDoubleField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularDoubleField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.distance, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.distance) -> Bool { - if lhs.distance != rhs.distance {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularDoubleField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularDoubleField) -> Bool { + if lhs.decodeSingularDoubleField != rhs.decodeSingularDoubleField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.double: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".double" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "double"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularEnumField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularEnumField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18026,31 +19351,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.double: Swift // 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.double) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularEnumField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.double != 0 { - try visitor.visitSingularInt32Field(value: self.double, fieldNumber: 1) + if self.decodeSingularEnumField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularEnumField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.double, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.double) -> Bool { - if lhs.double != rhs.double {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularEnumField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularEnumField) -> Bool { + if lhs.decodeSingularEnumField != rhs.decodeSingularEnumField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.doubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".doubleValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "doubleValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18058,31 +19381,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.doubleValue: // 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.doubleValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularFixed32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.doubleValue != 0 { - try visitor.visitSingularInt32Field(value: self.doubleValue, fieldNumber: 1) + if self.decodeSingularFixed32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularFixed32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.doubleValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.doubleValue) -> Bool { - if lhs.doubleValue != rhs.doubleValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFixed32Field) -> Bool { + if lhs.decodeSingularFixed32Field != rhs.decodeSingularFixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Duration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Duration" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Duration"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18090,31 +19411,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Duration: Swi // 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.duration) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularFixed64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.duration != 0 { - try visitor.visitSingularInt32Field(value: self.duration, fieldNumber: 1) + if self.decodeSingularFixed64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularFixed64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Duration, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Duration) -> Bool { - if lhs.duration != rhs.duration {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFixed64Field) -> Bool { + if lhs.decodeSingularFixed64Field != rhs.decodeSingularFixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.E: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".E" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "E"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularFloatField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularFloatField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18122,31 +19441,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.E: SwiftProto // 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.e) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularFloatField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.e != 0 { - try visitor.visitSingularInt32Field(value: self.e, fieldNumber: 1) + if self.decodeSingularFloatField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularFloatField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.E, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.E) -> Bool { - if lhs.e != rhs.e {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFloatField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularFloatField) -> Bool { + if lhs.decodeSingularFloatField != rhs.decodeSingularFloatField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Element: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Element" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Element"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularGroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularGroupField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18154,31 +19471,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Element: Swif // 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.element) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularGroupField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.element != 0 { - try visitor.visitSingularInt32Field(value: self.element, fieldNumber: 1) + if self.decodeSingularGroupField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularGroupField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Element, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Element) -> Bool { - if lhs.element != rhs.element {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularGroupField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularGroupField) -> Bool { + if lhs.decodeSingularGroupField != rhs.decodeSingularGroupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.elements: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".elements" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "elements"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18186,31 +19501,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.elements: Swi // 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.elements) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularInt32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.elements != 0 { - try visitor.visitSingularInt32Field(value: self.elements, fieldNumber: 1) + if self.decodeSingularInt32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularInt32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.elements, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.elements) -> Bool { - if lhs.elements != rhs.elements {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularInt32Field) -> Bool { + if lhs.decodeSingularInt32Field != rhs.decodeSingularInt32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitExtensionFieldName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".emitExtensionFieldName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "emitExtensionFieldName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18218,31 +19531,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitExtension // 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.emitExtensionFieldName) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularInt64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.emitExtensionFieldName != 0 { - try visitor.visitSingularInt32Field(value: self.emitExtensionFieldName, fieldNumber: 1) + if self.decodeSingularInt64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularInt64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitExtensionFieldName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitExtensionFieldName) -> Bool { - if lhs.emitExtensionFieldName != rhs.emitExtensionFieldName {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularInt64Field) -> Bool { + if lhs.decodeSingularInt64Field != rhs.decodeSingularInt64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".emitFieldName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "emitFieldName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularMessageField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularMessageField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18250,31 +19561,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldName // 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.emitFieldName) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularMessageField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.emitFieldName != 0 { - try visitor.visitSingularInt32Field(value: self.emitFieldName, fieldNumber: 1) + if self.decodeSingularMessageField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularMessageField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldName) -> Bool { - if lhs.emitFieldName != rhs.emitFieldName {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularMessageField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularMessageField) -> Bool { + if lhs.decodeSingularMessageField != rhs.decodeSingularMessageField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".emitFieldNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "emitFieldNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularSFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularSFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18282,31 +19591,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldNumb // 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.emitFieldNumber) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularSfixed32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.emitFieldNumber != 0 { - try visitor.visitSingularInt32Field(value: self.emitFieldNumber, fieldNumber: 1) + if self.decodeSingularSfixed32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularSfixed32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldNumber, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emitFieldNumber) -> Bool { - if lhs.emitFieldNumber != rhs.emitFieldNumber {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSFixed32Field) -> Bool { + if lhs.decodeSingularSfixed32Field != rhs.decodeSingularSfixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Empty: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Empty" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Empty"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularSFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularSFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18314,31 +19621,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Empty: SwiftP // 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.empty) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularSfixed64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.empty != 0 { - try visitor.visitSingularInt32Field(value: self.empty, fieldNumber: 1) + if self.decodeSingularSfixed64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularSfixed64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Empty, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Empty) -> Bool { - if lhs.empty != rhs.empty {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSFixed64Field) -> Bool { + if lhs.decodeSingularSfixed64Field != rhs.decodeSingularSfixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emptyData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".emptyData" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "emptyData"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularSInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularSInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18346,31 +19651,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emptyData: Sw // 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.emptyData) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularSint32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.emptyData != 0 { - try visitor.visitSingularInt32Field(value: self.emptyData, fieldNumber: 1) + if self.decodeSingularSint32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularSint32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emptyData, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.emptyData) -> Bool { - if lhs.emptyData != rhs.emptyData {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSInt32Field) -> Bool { + if lhs.decodeSingularSint32Field != rhs.decodeSingularSint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeAsBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".encodeAsBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "encodeAsBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularSInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularSInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18378,31 +19681,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeAsBytes // 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.encodeAsBytes) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularSint64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.encodeAsBytes != 0 { - try visitor.visitSingularInt32Field(value: self.encodeAsBytes, fieldNumber: 1) + if self.decodeSingularSint64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularSint64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeAsBytes, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeAsBytes) -> Bool { - if lhs.encodeAsBytes != rhs.encodeAsBytes {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularSInt64Field) -> Bool { + if lhs.decodeSingularSint64Field != rhs.decodeSingularSint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoded: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".encoded" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "encoded"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularStringField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularStringField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularStringField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18410,31 +19711,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoded: Swif // 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.encoded) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularStringField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.encoded != 0 { - try visitor.visitSingularInt32Field(value: self.encoded, fieldNumber: 1) + if self.decodeSingularStringField != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularStringField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoded, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoded) -> Bool { - if lhs.encoded != rhs.encoded {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularStringField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularStringField) -> Bool { + if lhs.decodeSingularStringField != rhs.decodeSingularStringField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedJSONString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".encodedJSONString" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "encodedJSONString"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularUInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularUInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18442,31 +19741,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedJSONSt // 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.encodedJsonstring) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularUint32Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.encodedJsonstring != 0 { - try visitor.visitSingularInt32Field(value: self.encodedJsonstring, fieldNumber: 1) + if self.decodeSingularUint32Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularUint32Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedJSONString, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedJSONString) -> Bool { - if lhs.encodedJsonstring != rhs.encodedJsonstring {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularUInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularUInt32Field) -> Bool { + if lhs.decodeSingularUint32Field != rhs.decodeSingularUint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".encodedSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "encodedSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeSingularUInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeSingularUInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18474,31 +19771,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedSize: // 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.encodedSize) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeSingularUint64Field) }() default: break } } } func traverse(visitor: inout V) throws { - if self.encodedSize != 0 { - try visitor.visitSingularInt32Field(value: self.encodedSize, fieldNumber: 1) + if self.decodeSingularUint64Field != 0 { + try visitor.visitSingularInt32Field(value: self.decodeSingularUint64Field, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedSize, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodedSize) -> Bool { - if lhs.encodedSize != rhs.encodedSize {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularUInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeSingularUInt64Field) -> Bool { + if lhs.decodeSingularUint64Field != rhs.decodeSingularUint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".encodeField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "encodeField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeTextFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".decodeTextFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decodeTextFormat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18506,31 +19801,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeField: // 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.encodeField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.decodeTextFormat) }() default: break } } } func traverse(visitor: inout V) throws { - if self.encodeField != 0 { - try visitor.visitSingularInt32Field(value: self.encodeField, fieldNumber: 1) + if self.decodeTextFormat != 0 { + try visitor.visitSingularInt32Field(value: self.decodeTextFormat, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encodeField) -> Bool { - if lhs.encodeField != rhs.encodeField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeTextFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.decodeTextFormat) -> Bool { + if lhs.decodeTextFormat != rhs.decodeTextFormat {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".encoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "encoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultAnyTypeURLPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".defaultAnyTypeURLPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}defaultAnyTypeURLPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18538,31 +19831,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoder: Swif // 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.encoder) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.defaultAnyTypeUrlprefix) }() default: break } } } func traverse(visitor: inout V) throws { - if self.encoder != 0 { - try visitor.visitSingularInt32Field(value: self.encoder, fieldNumber: 1) + if self.defaultAnyTypeUrlprefix != 0 { + try visitor.visitSingularInt32Field(value: self.defaultAnyTypeUrlprefix, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.encoder) -> Bool { - if lhs.encoder != rhs.encoder {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultAnyTypeURLPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultAnyTypeURLPrefix) -> Bool { + if lhs.defaultAnyTypeUrlprefix != rhs.defaultAnyTypeUrlprefix {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.end: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".end" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "end"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaults: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".defaults" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}defaults\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18570,31 +19861,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.end: SwiftPro // 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.end) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.defaults) }() default: break } } } func traverse(visitor: inout V) throws { - if self.end != 0 { - try visitor.visitSingularInt32Field(value: self.end, fieldNumber: 1) + if self.defaults != 0 { + try visitor.visitSingularInt32Field(value: self.defaults, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.end, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.end) -> Bool { - if lhs.end != rhs.end {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaults, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaults) -> Bool { + if lhs.defaults != rhs.defaults {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endArray: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".endArray" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "endArray"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultSymbolVisibility: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".defaultSymbolVisibility" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}defaultSymbolVisibility\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18602,31 +19891,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endArray: Swi // 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.endArray) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.defaultSymbolVisibility) }() default: break } } } func traverse(visitor: inout V) throws { - if self.endArray != 0 { - try visitor.visitSingularInt32Field(value: self.endArray, fieldNumber: 1) + if self.defaultSymbolVisibility != 0 { + try visitor.visitSingularInt32Field(value: self.defaultSymbolVisibility, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endArray, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endArray) -> Bool { - if lhs.endArray != rhs.endArray {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultSymbolVisibility, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultSymbolVisibility) -> Bool { + if lhs.defaultSymbolVisibility != rhs.defaultSymbolVisibility {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".endMessageField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "endMessageField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".defaultValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}defaultValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18634,31 +19921,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endMessageFie // 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.endMessageField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.defaultValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.endMessageField != 0 { - try visitor.visitSingularInt32Field(value: self.endMessageField, fieldNumber: 1) + if self.defaultValue != 0 { + try visitor.visitSingularInt32Field(value: self.defaultValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endMessageField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endMessageField) -> Bool { - if lhs.endMessageField != rhs.endMessageField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.defaultValue) -> Bool { + if lhs.defaultValue != rhs.defaultValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endObject: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".endObject" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "endObject"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dependency: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".dependency" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}dependency\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18666,31 +19951,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endObject: Sw // 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.endObject) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.dependency) }() default: break } } } func traverse(visitor: inout V) throws { - if self.endObject != 0 { - try visitor.visitSingularInt32Field(value: self.endObject, fieldNumber: 1) + if self.dependency != 0 { + try visitor.visitSingularInt32Field(value: self.dependency, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endObject, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endObject) -> Bool { - if lhs.endObject != rhs.endObject {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dependency, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dependency) -> Bool { + if lhs.dependency != rhs.dependency {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endRegularField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".endRegularField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "endRegularField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".deprecated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}deprecated\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18698,31 +19981,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endRegularFie // 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.endRegularField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.deprecated) }() default: break } } } func traverse(visitor: inout V) throws { - if self.endRegularField != 0 { - try visitor.visitSingularInt32Field(value: self.endRegularField, fieldNumber: 1) + if self.deprecated != 0 { + try visitor.visitSingularInt32Field(value: self.deprecated, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endRegularField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.endRegularField) -> Bool { - if lhs.endRegularField != rhs.endRegularField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecated) -> Bool { + if lhs.deprecated != rhs.deprecated {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".enum" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "enum"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecatedLegacyJsonFieldConflicts: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".deprecatedLegacyJsonFieldConflicts" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}deprecatedLegacyJsonFieldConflicts\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18730,31 +20011,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumMessage: // 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.`enum`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.deprecatedLegacyJsonFieldConflicts) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`enum` != 0 { - try visitor.visitSingularInt32Field(value: self.`enum`, fieldNumber: 1) + if self.deprecatedLegacyJsonFieldConflicts != 0 { + try visitor.visitSingularInt32Field(value: self.deprecatedLegacyJsonFieldConflicts, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumMessage) -> Bool { - if lhs.`enum` != rhs.`enum` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecatedLegacyJsonFieldConflicts, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecatedLegacyJsonFieldConflicts) -> Bool { + if lhs.deprecatedLegacyJsonFieldConflicts != rhs.deprecatedLegacyJsonFieldConflicts {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".EnumDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "EnumDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecationWarning: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".deprecationWarning" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}deprecationWarning\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18762,31 +20041,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumDescripto // 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.enumDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.deprecationWarning) }() default: break } } } func traverse(visitor: inout V) throws { - if self.enumDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.enumDescriptorProto, fieldNumber: 1) + if self.deprecationWarning != 0 { + try visitor.visitSingularInt32Field(value: self.deprecationWarning, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumDescriptorProto) -> Bool { - if lhs.enumDescriptorProto != rhs.enumDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecationWarning, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.deprecationWarning) -> Bool { + if lhs.deprecationWarning != rhs.deprecationWarning {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".EnumOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "EnumOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.descriptionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".description" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}description\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18794,31 +20071,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumOptions: // 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.enumOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.description_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.enumOptions != 0 { - try visitor.visitSingularInt32Field(value: self.enumOptions, fieldNumber: 1) + if self.description_p != 0 { + try visitor.visitSingularInt32Field(value: self.description_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumOptions) -> Bool { - if lhs.enumOptions != rhs.enumOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.descriptionMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.descriptionMessage) -> Bool { + if lhs.description_p != rhs.description_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumReservedRange: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".EnumReservedRange" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "EnumReservedRange"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Dictionary: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Dictionary" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Dictionary\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18826,31 +20101,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumReservedR // 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.enumReservedRange) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.dictionary) }() default: break } } } func traverse(visitor: inout V) throws { - if self.enumReservedRange != 0 { - try visitor.visitSingularInt32Field(value: self.enumReservedRange, fieldNumber: 1) + if self.dictionary != 0 { + try visitor.visitSingularInt32Field(value: self.dictionary, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumReservedRange, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumReservedRange) -> Bool { - if lhs.enumReservedRange != rhs.enumReservedRange {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Dictionary, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Dictionary) -> Bool { + if lhs.dictionary != rhs.dictionary {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".enumType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "enumType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dictionaryLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".dictionaryLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}dictionaryLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18858,31 +20131,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumType: Swi // 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.enumType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.dictionaryLiteral) }() default: break } } } func traverse(visitor: inout V) throws { - if self.enumType != 0 { - try visitor.visitSingularInt32Field(value: self.enumType, fieldNumber: 1) + if self.dictionaryLiteral != 0 { + try visitor.visitSingularInt32Field(value: self.dictionaryLiteral, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumType) -> Bool { - if lhs.enumType != rhs.enumType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dictionaryLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.dictionaryLiteral) -> Bool { + if lhs.dictionaryLiteral != rhs.dictionaryLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumvalue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".enumvalue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "enumvalue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".digit" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}digit\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18890,31 +20161,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumvalue: Sw // 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.enumvalue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.digit) }() default: break } } } func traverse(visitor: inout V) throws { - if self.enumvalue != 0 { - try visitor.visitSingularInt32Field(value: self.enumvalue, fieldNumber: 1) + if self.digit != 0 { + try visitor.visitSingularInt32Field(value: self.digit, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumvalue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.enumvalue) -> Bool { - if lhs.enumvalue != rhs.enumvalue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit) -> Bool { + if lhs.digit != rhs.digit {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".EnumValueDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "EnumValueDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit0: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".digit0" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}digit0\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18922,31 +20191,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueDesc // 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.enumValueDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.digit0) }() default: break } } } func traverse(visitor: inout V) throws { - if self.enumValueDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.enumValueDescriptorProto, fieldNumber: 1) + if self.digit0 != 0 { + try visitor.visitSingularInt32Field(value: self.digit0, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueDescriptorProto) -> Bool { - if lhs.enumValueDescriptorProto != rhs.enumValueDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit0, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit0) -> Bool { + if lhs.digit0 != rhs.digit0 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".EnumValueOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "EnumValueOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".digit1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}digit1\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18954,31 +20221,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueOpti // 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.enumValueOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.digit1) }() default: break } } } func traverse(visitor: inout V) throws { - if self.enumValueOptions != 0 { - try visitor.visitSingularInt32Field(value: self.enumValueOptions, fieldNumber: 1) + if self.digit1 != 0 { + try visitor.visitSingularInt32Field(value: self.digit1, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.EnumValueOptions) -> Bool { - if lhs.enumValueOptions != rhs.enumValueOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit1, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digit1) -> Bool { + if lhs.digit1 != rhs.digit1 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Equatable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Equatable" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Equatable"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digitCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".digitCount" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}digitCount\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18986,31 +20251,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Equatable: Sw // 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.equatable) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.digitCount) }() default: break } } } func traverse(visitor: inout V) throws { - if self.equatable != 0 { - try visitor.visitSingularInt32Field(value: self.equatable, fieldNumber: 1) + if self.digitCount != 0 { + try visitor.visitSingularInt32Field(value: self.digitCount, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Equatable, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Equatable) -> Bool { - if lhs.equatable != rhs.equatable {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digitCount, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digitCount) -> Bool { + if lhs.digitCount != rhs.digitCount {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Error: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Error" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Error"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".digits" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}digits\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19018,31 +20281,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Error: SwiftP // 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.error) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.digits) }() default: break } } } func traverse(visitor: inout V) throws { - if self.error != 0 { - try visitor.visitSingularInt32Field(value: self.error, fieldNumber: 1) + if self.digits != 0 { + try visitor.visitSingularInt32Field(value: self.digits, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Error, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Error) -> Bool { - if lhs.error != rhs.error {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digits, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digits) -> Bool { + if lhs.digits != rhs.digits {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleByArrayLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ExpressibleByArrayLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ExpressibleByArrayLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digitValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".digitValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}digitValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19050,31 +20311,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleBy // 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.expressibleByArrayLiteral) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.digitValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.expressibleByArrayLiteral != 0 { - try visitor.visitSingularInt32Field(value: self.expressibleByArrayLiteral, fieldNumber: 1) + if self.digitValue != 0 { + try visitor.visitSingularInt32Field(value: self.digitValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleByArrayLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleByArrayLiteral) -> Bool { - if lhs.expressibleByArrayLiteral != rhs.expressibleByArrayLiteral {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digitValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.digitValue) -> Bool { + if lhs.digitValue != rhs.digitValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleByDictionaryLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ExpressibleByDictionaryLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ExpressibleByDictionaryLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.discardableResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".discardableResult" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}discardableResult\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19082,31 +20341,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleBy // 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.expressibleByDictionaryLiteral) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.discardableResult) }() default: break } } } func traverse(visitor: inout V) throws { - if self.expressibleByDictionaryLiteral != 0 { - try visitor.visitSingularInt32Field(value: self.expressibleByDictionaryLiteral, fieldNumber: 1) + if self.discardableResult != 0 { + try visitor.visitSingularInt32Field(value: self.discardableResult, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleByDictionaryLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExpressibleByDictionaryLiteral) -> Bool { - if lhs.expressibleByDictionaryLiteral != rhs.expressibleByDictionaryLiteral {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.discardableResult, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.discardableResult) -> Bool { + if lhs.discardableResult != rhs.discardableResult {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ext" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ext"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.discardUnknownFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".discardUnknownFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}discardUnknownFields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19114,31 +20371,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ext: SwiftPro // 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.ext) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.discardUnknownFields) }() default: break } } } func traverse(visitor: inout V) throws { - if self.ext != 0 { - try visitor.visitSingularInt32Field(value: self.ext, fieldNumber: 1) + if self.discardUnknownFields != 0 { + try visitor.visitSingularInt32Field(value: self.discardUnknownFields, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ext, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ext) -> Bool { - if lhs.ext != rhs.ext {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.discardUnknownFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.discardUnknownFields) -> Bool { + if lhs.discardUnknownFields != rhs.discardUnknownFields {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".extDecoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DoubleMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Double" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Double\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19146,31 +20401,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extDecoder: S // 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.extDecoder) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.double) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extDecoder != 0 { - try visitor.visitSingularInt32Field(value: self.extDecoder, fieldNumber: 1) + if self.double != 0 { + try visitor.visitSingularInt32Field(value: self.double, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extDecoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extDecoder) -> Bool { - if lhs.extDecoder != rhs.extDecoder {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DoubleMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.DoubleMessage) -> Bool { + if lhs.double != rhs.double {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendedGraphemeClusterLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".extendedGraphemeClusterLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extendedGraphemeClusterLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.doubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".doubleValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}doubleValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19178,31 +20431,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendedGraph // 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.extendedGraphemeClusterLiteral) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.doubleValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extendedGraphemeClusterLiteral != 0 { - try visitor.visitSingularInt32Field(value: self.extendedGraphemeClusterLiteral, fieldNumber: 1) + if self.doubleValue != 0 { + try visitor.visitSingularInt32Field(value: self.doubleValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendedGraphemeClusterLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendedGraphemeClusterLiteral) -> Bool { - if lhs.extendedGraphemeClusterLiteral != rhs.extendedGraphemeClusterLiteral {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.doubleValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.doubleValue) -> Bool { + if lhs.doubleValue != rhs.doubleValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtendedGraphemeClusterLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtendedGraphemeClusterLiteralType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ExtendedGraphemeClusterLiteralType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.duration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".duration" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}duration\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19210,31 +20461,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtendedGraph // 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.extendedGraphemeClusterLiteralType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.duration) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extendedGraphemeClusterLiteralType != 0 { - try visitor.visitSingularInt32Field(value: self.extendedGraphemeClusterLiteralType, fieldNumber: 1) + if self.duration != 0 { + try visitor.visitSingularInt32Field(value: self.duration, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtendedGraphemeClusterLiteralType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtendedGraphemeClusterLiteralType) -> Bool { - if lhs.extendedGraphemeClusterLiteralType != rhs.extendedGraphemeClusterLiteralType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.duration, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.duration) -> Bool { + if lhs.duration != rhs.duration {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendee: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".extendee" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extendee"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.E: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".E" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}E\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19242,31 +20491,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendee: Swi // 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.extendee) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.e) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extendee != 0 { - try visitor.visitSingularInt32Field(value: self.extendee, fieldNumber: 1) + if self.e != 0 { + try visitor.visitSingularInt32Field(value: self.e, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendee, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extendee) -> Bool { - if lhs.extendee != rhs.extendee {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.E, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.E) -> Bool { + if lhs.e != rhs.e {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensibleMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensibleMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ExtensibleMessage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.edition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".edition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}edition\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19274,31 +20521,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensibleMes // 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.extensibleMessage) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.edition) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extensibleMessage != 0 { - try visitor.visitSingularInt32Field(value: self.extensibleMessage, fieldNumber: 1) + if self.edition != 0 { + try visitor.visitSingularInt32Field(value: self.edition, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensibleMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensibleMessage) -> Bool { - if lhs.extensibleMessage != rhs.extensibleMessage {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.edition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.edition) -> Bool { + if lhs.edition != rhs.edition {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".extension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EditionDefault: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".EditionDefault" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}EditionDefault\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19306,31 +20551,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionMess // 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.`extension`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.editionDefault) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`extension` != 0 { - try visitor.visitSingularInt32Field(value: self.`extension`, fieldNumber: 1) + if self.editionDefault != 0 { + try visitor.visitSingularInt32Field(value: self.editionDefault, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionMessage) -> Bool { - if lhs.`extension` != rhs.`extension` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EditionDefault, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EditionDefault) -> Bool { + if lhs.editionDefault != rhs.editionDefault {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionDefaults: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".editionDefaults" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}editionDefaults\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19338,31 +20581,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionFiel // 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.extensionField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.editionDefaults) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extensionField != 0 { - try visitor.visitSingularInt32Field(value: self.extensionField, fieldNumber: 1) + if self.editionDefaults != 0 { + try visitor.visitSingularInt32Field(value: self.editionDefaults, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionField) -> Bool { - if lhs.extensionField != rhs.extensionField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionDefaults, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionDefaults) -> Bool { + if lhs.editionDefaults != rhs.editionDefaults {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".extensionFieldNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extensionFieldNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionDeprecated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".editionDeprecated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}editionDeprecated\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19370,31 +20611,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionFiel // 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.extensionFieldNumber) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.editionDeprecated) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extensionFieldNumber != 0 { - try visitor.visitSingularInt32Field(value: self.extensionFieldNumber, fieldNumber: 1) + if self.editionDeprecated != 0 { + try visitor.visitSingularInt32Field(value: self.editionDeprecated, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionFieldNumber, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionFieldNumber) -> Bool { - if lhs.extensionFieldNumber != rhs.extensionFieldNumber {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionDeprecated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionDeprecated) -> Bool { + if lhs.editionDeprecated != rhs.editionDeprecated {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionFieldValueSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensionFieldValueSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ExtensionFieldValueSet"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionIntroduced: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".editionIntroduced" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}editionIntroduced\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19402,31 +20641,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionFiel // 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.extensionFieldValueSet) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.editionIntroduced) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extensionFieldValueSet != 0 { - try visitor.visitSingularInt32Field(value: self.extensionFieldValueSet, fieldNumber: 1) + if self.editionIntroduced != 0 { + try visitor.visitSingularInt32Field(value: self.editionIntroduced, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionFieldValueSet, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionFieldValueSet) -> Bool { - if lhs.extensionFieldValueSet != rhs.extensionFieldValueSet {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionIntroduced, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionIntroduced) -> Bool { + if lhs.editionIntroduced != rhs.editionIntroduced {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensionMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ExtensionMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionRemoved: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".editionRemoved" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}editionRemoved\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19434,31 +20671,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionMap: // 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.extensionMap) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.editionRemoved) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extensionMap != 0 { - try visitor.visitSingularInt32Field(value: self.extensionMap, fieldNumber: 1) + if self.editionRemoved != 0 { + try visitor.visitSingularInt32Field(value: self.editionRemoved, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionMap, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionMap) -> Bool { - if lhs.extensionMap != rhs.extensionMap {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionRemoved, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.editionRemoved) -> Bool { + if lhs.editionRemoved != rhs.editionRemoved {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionRange: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".extensionRange" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extensionRange"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Element: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Element" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Element\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19466,31 +20701,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionRang // 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.extensionRange) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.element) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extensionRange != 0 { - try visitor.visitSingularInt32Field(value: self.extensionRange, fieldNumber: 1) + if self.element != 0 { + try visitor.visitSingularInt32Field(value: self.element, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionRange, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensionRange) -> Bool { - if lhs.extensionRange != rhs.extensionRange {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Element, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Element) -> Bool { + if lhs.element != rhs.element {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionRangeOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensionRangeOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ExtensionRangeOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.elements: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".elements" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}elements\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19498,31 +20731,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionRang // 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.extensionRangeOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.elements) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extensionRangeOptions != 0 { - try visitor.visitSingularInt32Field(value: self.extensionRangeOptions, fieldNumber: 1) + if self.elements != 0 { + try visitor.visitSingularInt32Field(value: self.elements, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionRangeOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ExtensionRangeOptions) -> Bool { - if lhs.extensionRangeOptions != rhs.extensionRangeOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.elements, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.elements) -> Bool { + if lhs.elements != rhs.elements {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".extensions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extensions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.elseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".else" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}else\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19530,31 +20761,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensions: S // 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.extensions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`else`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extensions != 0 { - try visitor.visitSingularInt32Field(value: self.extensions, fieldNumber: 1) + if self.`else` != 0 { + try visitor.visitSingularInt32Field(value: self.`else`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extensions) -> Bool { - if lhs.extensions != rhs.extensions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.elseMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.elseMessage) -> Bool { + if lhs.`else` != rhs.`else` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extras: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".extras" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extras"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitExtensionFieldName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".emitExtensionFieldName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}emitExtensionFieldName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19562,31 +20791,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extras: Swift // 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.extras) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.emitExtensionFieldName) }() default: break } } } func traverse(visitor: inout V) throws { - if self.extras != 0 { - try visitor.visitSingularInt32Field(value: self.extras, fieldNumber: 1) + if self.emitExtensionFieldName != 0 { + try visitor.visitSingularInt32Field(value: self.emitExtensionFieldName, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extras, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.extras) -> Bool { - if lhs.extras != rhs.extras {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitExtensionFieldName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitExtensionFieldName) -> Bool { + if lhs.emitExtensionFieldName != rhs.emitExtensionFieldName {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.F: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".F" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "F"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitFieldName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".emitFieldName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}emitFieldName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19594,31 +20821,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.F: SwiftProto // 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.f) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.emitFieldName) }() default: break } } } func traverse(visitor: inout V) throws { - if self.f != 0 { - try visitor.visitSingularInt32Field(value: self.f, fieldNumber: 1) + if self.emitFieldName != 0 { + try visitor.visitSingularInt32Field(value: self.emitFieldName, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.F, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.F) -> Bool { - if lhs.f != rhs.f {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitFieldName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitFieldName) -> Bool { + if lhs.emitFieldName != rhs.emitFieldName {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.falseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".false" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "false"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".emitFieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}emitFieldNumber\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19626,31 +20851,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.falseMessage: // 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.`false`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.emitFieldNumber) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`false` != 0 { - try visitor.visitSingularInt32Field(value: self.`false`, fieldNumber: 1) + if self.emitFieldNumber != 0 { + try visitor.visitSingularInt32Field(value: self.emitFieldNumber, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.falseMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.falseMessage) -> Bool { - if lhs.`false` != rhs.`false` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitFieldNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emitFieldNumber) -> Bool { + if lhs.emitFieldNumber != rhs.emitFieldNumber {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emptyAnyTypeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".emptyAnyTypeURL" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}emptyAnyTypeURL\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19658,31 +20881,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.field: SwiftP // 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.field) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.emptyAnyTypeURL) }() default: break } } } func traverse(visitor: inout V) throws { - if self.field != 0 { - try visitor.visitSingularInt32Field(value: self.field, fieldNumber: 1) + if self.emptyAnyTypeURL != 0 { + try visitor.visitSingularInt32Field(value: self.emptyAnyTypeURL, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.field) -> Bool { - if lhs.field != rhs.field {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emptyAnyTypeURL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emptyAnyTypeURL) -> Bool { + if lhs.emptyAnyTypeURL != rhs.emptyAnyTypeURL {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldData" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fieldData"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emptyData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".emptyData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}emptyData\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19690,31 +20911,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldData: Sw // 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.fieldData) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.emptyData) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldData != 0 { - try visitor.visitSingularInt32Field(value: self.fieldData, fieldNumber: 1) + if self.emptyData != 0 { + try visitor.visitSingularInt32Field(value: self.emptyData, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldData, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldData) -> Bool { - if lhs.fieldData != rhs.fieldData {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emptyData, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.emptyData) -> Bool { + if lhs.emptyData != rhs.emptyData {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".FieldDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FieldDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodeAsBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".encodeAsBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}encodeAsBytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19722,31 +20941,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldDescript // 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.fieldDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.encodeAsBytes) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.fieldDescriptorProto, fieldNumber: 1) + if self.encodeAsBytes != 0 { + try visitor.visitSingularInt32Field(value: self.encodeAsBytes, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldDescriptorProto) -> Bool { - if lhs.fieldDescriptorProto != rhs.fieldDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodeAsBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodeAsBytes) -> Bool { + if lhs.encodeAsBytes != rhs.encodeAsBytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldMask: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".FieldMask" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FieldMask"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encoded: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".encoded" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}encoded\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19754,31 +20971,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldMask: Sw // 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.fieldMask) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.encoded) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldMask != 0 { - try visitor.visitSingularInt32Field(value: self.fieldMask, fieldNumber: 1) + if self.encoded != 0 { + try visitor.visitSingularInt32Field(value: self.encoded, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldMask, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldMask) -> Bool { - if lhs.fieldMask != rhs.fieldMask {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encoded, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encoded) -> Bool { + if lhs.encoded != rhs.encoded {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fieldName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodedJSONString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".encodedJSONString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}encodedJSONString\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19786,31 +21001,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldName: Sw // 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.fieldName) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.encodedJsonstring) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldName != 0 { - try visitor.visitSingularInt32Field(value: self.fieldName, fieldNumber: 1) + if self.encodedJsonstring != 0 { + try visitor.visitSingularInt32Field(value: self.encodedJsonstring, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldName) -> Bool { - if lhs.fieldName != rhs.fieldName {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodedJSONString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodedJSONString) -> Bool { + if lhs.encodedJsonstring != rhs.encodedJsonstring {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNameCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldNameCount" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fieldNameCount"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".encodedSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}encodedSize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19818,31 +21031,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNameCoun // 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.fieldNameCount) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.encodedSize) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldNameCount != 0 { - try visitor.visitSingularInt32Field(value: self.fieldNameCount, fieldNumber: 1) + if self.encodedSize != 0 { + try visitor.visitSingularInt32Field(value: self.encodedSize, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNameCount, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNameCount) -> Bool { - if lhs.fieldNameCount != rhs.fieldNameCount {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodedSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodedSize) -> Bool { + if lhs.encodedSize != rhs.encodedSize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldNum" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fieldNum"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodeField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".encodeField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}encodeField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19850,31 +21061,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNum: Swi // 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.fieldNum) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.encodeField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldNum != 0 { - try visitor.visitSingularInt32Field(value: self.fieldNum, fieldNumber: 1) + if self.encodeField != 0 { + try visitor.visitSingularInt32Field(value: self.encodeField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNum, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNum) -> Bool { - if lhs.fieldNum != rhs.fieldNum {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodeField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encodeField) -> Bool { + if lhs.encodeField != rhs.encodeField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fieldNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".encoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}encoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19882,31 +21091,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumber: // 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.fieldNumber) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.encoder) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldNumber != 0 { - try visitor.visitSingularInt32Field(value: self.fieldNumber, fieldNumber: 1) + if self.encoder != 0 { + try visitor.visitSingularInt32Field(value: self.encoder, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumber, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumber) -> Bool { - if lhs.fieldNumber != rhs.fieldNumber {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.encoder) -> Bool { + if lhs.encoder != rhs.encoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumberForProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldNumberForProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fieldNumberForProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.end: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".end" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}end\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19914,31 +21121,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumberFo // 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.fieldNumberForProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.end) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldNumberForProto != 0 { - try visitor.visitSingularInt32Field(value: self.fieldNumberForProto, fieldNumber: 1) + if self.end != 0 { + try visitor.visitSingularInt32Field(value: self.end, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumberForProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldNumberForProto) -> Bool { - if lhs.fieldNumberForProto != rhs.fieldNumberForProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.end, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.end) -> Bool { + if lhs.end != rhs.end {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".FieldOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FieldOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endArray: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".endArray" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}endArray\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19946,31 +21151,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldOptions: // 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.fieldOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.endArray) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldOptions != 0 { - try visitor.visitSingularInt32Field(value: self.fieldOptions, fieldNumber: 1) + if self.endArray != 0 { + try visitor.visitSingularInt32Field(value: self.endArray, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldOptions) -> Bool { - if lhs.fieldOptions != rhs.fieldOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endArray, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endArray) -> Bool { + if lhs.endArray != rhs.endArray {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fields"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".endMessageField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}endMessageField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19978,31 +21181,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fields: Swift // 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.fields) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.endMessageField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fields != 0 { - try visitor.visitSingularInt32Field(value: self.fields, fieldNumber: 1) + if self.endMessageField != 0 { + try visitor.visitSingularInt32Field(value: self.endMessageField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fields, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fields) -> Bool { - if lhs.fields != rhs.fields {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endMessageField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endMessageField) -> Bool { + if lhs.endMessageField != rhs.endMessageField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fieldSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endObject: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".endObject" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}endObject\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20010,31 +21211,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldSize: Sw // 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.fieldSize) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.endObject) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldSize != 0 { - try visitor.visitSingularInt32Field(value: self.fieldSize, fieldNumber: 1) + if self.endObject != 0 { + try visitor.visitSingularInt32Field(value: self.endObject, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldSize, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldSize) -> Bool { - if lhs.fieldSize != rhs.fieldSize {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endObject, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endObject) -> Bool { + if lhs.endObject != rhs.endObject {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldTag: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".FieldTag" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FieldTag"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endRegularField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".endRegularField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}endRegularField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20042,31 +21241,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldTag: Swi // 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.fieldTag) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.endRegularField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldTag != 0 { - try visitor.visitSingularInt32Field(value: self.fieldTag, fieldNumber: 1) + if self.endRegularField != 0 { + try visitor.visitSingularInt32Field(value: self.endRegularField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldTag, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FieldTag) -> Bool { - if lhs.fieldTag != rhs.fieldTag {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endRegularField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.endRegularField) -> Bool { + if lhs.endRegularField != rhs.endRegularField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fieldType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enforceNamingStyle: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".enforceNamingStyle" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}enforceNamingStyle\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20074,31 +21271,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldType: Sw // 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.fieldType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.enforceNamingStyle) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fieldType != 0 { - try visitor.visitSingularInt32Field(value: self.fieldType, fieldNumber: 1) + if self.enforceNamingStyle != 0 { + try visitor.visitSingularInt32Field(value: self.enforceNamingStyle, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fieldType) -> Bool { - if lhs.fieldType != rhs.fieldType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enforceNamingStyle, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enforceNamingStyle) -> Bool { + if lhs.enforceNamingStyle != rhs.enforceNamingStyle {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.file: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".file" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "file"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".enum" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20106,31 +21301,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.file: SwiftPr // 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.file) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`enum`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.file != 0 { - try visitor.visitSingularInt32Field(value: self.file, fieldNumber: 1) + if self.`enum` != 0 { + try visitor.visitSingularInt32Field(value: self.`enum`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.file, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.file) -> Bool { - if lhs.file != rhs.file {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumMessage) -> Bool { + if lhs.`enum` != rhs.`enum` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".FileDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FileDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumReservedRange: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".EnumReservedRange" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}EnumReservedRange\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20138,31 +21331,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescripto // 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.fileDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.enumReservedRange) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fileDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.fileDescriptorProto, fieldNumber: 1) + if self.enumReservedRange != 0 { + try visitor.visitSingularInt32Field(value: self.enumReservedRange, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescriptorProto) -> Bool { - if lhs.fileDescriptorProto != rhs.fileDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumReservedRange, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EnumReservedRange) -> Bool { + if lhs.enumReservedRange != rhs.enumReservedRange {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescriptorSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".FileDescriptorSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FileDescriptorSet"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".enumType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}enumType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20170,31 +21361,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescripto // 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.fileDescriptorSet) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.enumType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fileDescriptorSet != 0 { - try visitor.visitSingularInt32Field(value: self.fileDescriptorSet, fieldNumber: 1) + if self.enumType != 0 { + try visitor.visitSingularInt32Field(value: self.enumType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescriptorSet, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileDescriptorSet) -> Bool { - if lhs.fileDescriptorSet != rhs.fileDescriptorSet {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumType) -> Bool { + if lhs.enumType != rhs.enumType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fileName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fileName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fileName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumvalue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".enumvalue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}enumvalue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20202,31 +21391,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fileName: Swi // 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.fileName) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.enumvalue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fileName != 0 { - try visitor.visitSingularInt32Field(value: self.fileName, fieldNumber: 1) + if self.enumvalue != 0 { + try visitor.visitSingularInt32Field(value: self.enumvalue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fileName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fileName) -> Bool { - if lhs.fileName != rhs.fileName {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumvalue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.enumvalue) -> Bool { + if lhs.enumvalue != rhs.enumvalue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".FileOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FileOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EquatableMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Equatable" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Equatable\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20234,31 +21421,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileOptions: // 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.fileOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.equatable) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fileOptions != 0 { - try visitor.visitSingularInt32Field(value: self.fileOptions, fieldNumber: 1) + if self.equatable != 0 { + try visitor.visitSingularInt32Field(value: self.equatable, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FileOptions) -> Bool { - if lhs.fileOptions != rhs.fileOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EquatableMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.EquatableMessage) -> Bool { + if lhs.equatable != rhs.equatable {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.filter: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".filter" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "filter"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Error: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Error" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Error\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20266,31 +21451,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.filter: Swift // 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.filter) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.error) }() default: break } } } func traverse(visitor: inout V) throws { - if self.filter != 0 { - try visitor.visitSingularInt32Field(value: self.filter, fieldNumber: 1) + if self.error != 0 { + try visitor.visitSingularInt32Field(value: self.error, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.filter, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.filter) -> Bool { - if lhs.filter != rhs.filter {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Error, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Error) -> Bool { + if lhs.error != rhs.error {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.first: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".first" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "first"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.execute: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".execute" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}execute\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20298,31 +21481,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.first: SwiftP // 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.first) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.execute) }() default: break } } } func traverse(visitor: inout V) throws { - if self.first != 0 { - try visitor.visitSingularInt32Field(value: self.first, fieldNumber: 1) + if self.execute != 0 { + try visitor.visitSingularInt32Field(value: self.execute, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.first, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.first) -> Bool { - if lhs.first != rhs.first {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.execute, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.execute) -> Bool { + if lhs.execute != rhs.execute {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.firstItem: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".firstItem" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "firstItem"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExpressibleByArrayLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ExpressibleByArrayLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ExpressibleByArrayLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20330,31 +21511,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.firstItem: Sw // 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.firstItem) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.expressibleByArrayLiteral) }() default: break } } } func traverse(visitor: inout V) throws { - if self.firstItem != 0 { - try visitor.visitSingularInt32Field(value: self.firstItem, fieldNumber: 1) + if self.expressibleByArrayLiteral != 0 { + try visitor.visitSingularInt32Field(value: self.expressibleByArrayLiteral, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.firstItem, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.firstItem) -> Bool { - if lhs.firstItem != rhs.firstItem {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExpressibleByArrayLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExpressibleByArrayLiteral) -> Bool { + if lhs.expressibleByArrayLiteral != rhs.expressibleByArrayLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.float: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".float" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "float"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExpressibleByDictionaryLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ExpressibleByDictionaryLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ExpressibleByDictionaryLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20362,31 +21541,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.float: SwiftP // 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.float) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.expressibleByDictionaryLiteral) }() default: break } } } func traverse(visitor: inout V) throws { - if self.float != 0 { - try visitor.visitSingularInt32Field(value: self.float, fieldNumber: 1) + if self.expressibleByDictionaryLiteral != 0 { + try visitor.visitSingularInt32Field(value: self.expressibleByDictionaryLiteral, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.float, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.float) -> Bool { - if lhs.float != rhs.float {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExpressibleByDictionaryLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExpressibleByDictionaryLiteral) -> Bool { + if lhs.expressibleByDictionaryLiteral != rhs.expressibleByDictionaryLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.floatLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".floatLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "floatLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ext" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ext\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20394,31 +21571,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.floatLiteral: // 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.floatLiteral) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.ext) }() default: break } } } func traverse(visitor: inout V) throws { - if self.floatLiteral != 0 { - try visitor.visitSingularInt32Field(value: self.floatLiteral, fieldNumber: 1) + if self.ext != 0 { + try visitor.visitSingularInt32Field(value: self.ext, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.floatLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.floatLiteral) -> Bool { - if lhs.floatLiteral != rhs.floatLiteral {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ext, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ext) -> Bool { + if lhs.ext != rhs.ext {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".FloatLiteralType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FloatLiteralType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".extDecoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extDecoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20426,31 +21601,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatLiteralT // 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.floatLiteralType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extDecoder) }() default: break } } } func traverse(visitor: inout V) throws { - if self.floatLiteralType != 0 { - try visitor.visitSingularInt32Field(value: self.floatLiteralType, fieldNumber: 1) + if self.extDecoder != 0 { + try visitor.visitSingularInt32Field(value: self.extDecoder, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatLiteralType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatLiteralType) -> Bool { - if lhs.floatLiteralType != rhs.floatLiteralType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extDecoder) -> Bool { + if lhs.extDecoder != rhs.extDecoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".FloatValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FloatValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extendedGraphemeClusterLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".extendedGraphemeClusterLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extendedGraphemeClusterLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20458,31 +21631,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatValue: S // 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.floatValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extendedGraphemeClusterLiteral) }() default: break } } } func traverse(visitor: inout V) throws { - if self.floatValue != 0 { - try visitor.visitSingularInt32Field(value: self.floatValue, fieldNumber: 1) + if self.extendedGraphemeClusterLiteral != 0 { + try visitor.visitSingularInt32Field(value: self.extendedGraphemeClusterLiteral, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.FloatValue) -> Bool { - if lhs.floatValue != rhs.floatValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extendedGraphemeClusterLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extendedGraphemeClusterLiteral) -> Bool { + if lhs.extendedGraphemeClusterLiteral != rhs.extendedGraphemeClusterLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forMessageName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".forMessageName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "forMessageName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtendedGraphemeClusterLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtendedGraphemeClusterLiteralType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ExtendedGraphemeClusterLiteralType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20490,31 +21661,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forMessageNam // 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.forMessageName) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extendedGraphemeClusterLiteralType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.forMessageName != 0 { - try visitor.visitSingularInt32Field(value: self.forMessageName, fieldNumber: 1) + if self.extendedGraphemeClusterLiteralType != 0 { + try visitor.visitSingularInt32Field(value: self.extendedGraphemeClusterLiteralType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forMessageName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forMessageName) -> Bool { - if lhs.forMessageName != rhs.forMessageName {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtendedGraphemeClusterLiteralType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtendedGraphemeClusterLiteralType) -> Bool { + if lhs.extendedGraphemeClusterLiteralType != rhs.extendedGraphemeClusterLiteralType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.formUnion: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".formUnion" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "formUnion"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extendee: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".extendee" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extendee\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20522,31 +21691,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.formUnion: Sw // 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.formUnion) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extendee) }() default: break } } } func traverse(visitor: inout V) throws { - if self.formUnion != 0 { - try visitor.visitSingularInt32Field(value: self.formUnion, fieldNumber: 1) + if self.extendee != 0 { + try visitor.visitSingularInt32Field(value: self.extendee, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.formUnion, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.formUnion) -> Bool { - if lhs.formUnion != rhs.formUnion {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extendee, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extendee) -> Bool { + if lhs.extendee != rhs.extendee {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forReadingFrom: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".forReadingFrom" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "forReadingFrom"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensibleMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensibleMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ExtensibleMessage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20554,31 +21721,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forReadingFro // 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.forReadingFrom) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extensibleMessage) }() default: break } } } func traverse(visitor: inout V) throws { - if self.forReadingFrom != 0 { - try visitor.visitSingularInt32Field(value: self.forReadingFrom, fieldNumber: 1) + if self.extensibleMessage != 0 { + try visitor.visitSingularInt32Field(value: self.extensibleMessage, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forReadingFrom, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forReadingFrom) -> Bool { - if lhs.forReadingFrom != rhs.forReadingFrom {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensibleMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensibleMessage) -> Bool { + if lhs.extensibleMessage != rhs.extensibleMessage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forTypeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".forTypeURL" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "forTypeURL"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".extension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20586,31 +21751,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forTypeURL: S // 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.forTypeURL) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`extension`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.forTypeURL != 0 { - try visitor.visitSingularInt32Field(value: self.forTypeURL, fieldNumber: 1) + if self.`extension` != 0 { + try visitor.visitSingularInt32Field(value: self.`extension`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forTypeURL, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forTypeURL) -> Bool { - if lhs.forTypeURL != rhs.forTypeURL {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionMessage) -> Bool { + if lhs.`extension` != rhs.`extension` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ForwardParser: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ForwardParser" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ForwardParser"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20618,31 +21781,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ForwardParser // 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.forwardParser) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extensionField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.forwardParser != 0 { - try visitor.visitSingularInt32Field(value: self.forwardParser, fieldNumber: 1) + if self.extensionField != 0 { + try visitor.visitSingularInt32Field(value: self.extensionField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ForwardParser, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ForwardParser) -> Bool { - if lhs.forwardParser != rhs.forwardParser {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionField) -> Bool { + if lhs.extensionField != rhs.extensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forWritingInto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".forWritingInto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "forWritingInto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".extensionFieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extensionFieldNumber\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20650,31 +21811,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forWritingInt // 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.forWritingInto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extensionFieldNumber) }() default: break } } } func traverse(visitor: inout V) throws { - if self.forWritingInto != 0 { - try visitor.visitSingularInt32Field(value: self.forWritingInto, fieldNumber: 1) + if self.extensionFieldNumber != 0 { + try visitor.visitSingularInt32Field(value: self.extensionFieldNumber, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forWritingInto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.forWritingInto) -> Bool { - if lhs.forWritingInto != rhs.forWritingInto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionFieldNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionFieldNumber) -> Bool { + if lhs.extensionFieldNumber != rhs.extensionFieldNumber {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.from: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".from" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "from"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionFieldValueSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensionFieldValueSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ExtensionFieldValueSet\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20682,31 +21841,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.from: SwiftPr // 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.from) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extensionFieldValueSet) }() default: break } } } func traverse(visitor: inout V) throws { - if self.from != 0 { - try visitor.visitSingularInt32Field(value: self.from, fieldNumber: 1) + if self.extensionFieldValueSet != 0 { + try visitor.visitSingularInt32Field(value: self.extensionFieldValueSet, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.from, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.from) -> Bool { - if lhs.from != rhs.from {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionFieldValueSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionFieldValueSet) -> Bool { + if lhs.extensionFieldValueSet != rhs.extensionFieldValueSet {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fromAscii2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fromAscii2"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ExtensionMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ExtensionMap\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20714,31 +21871,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii2: S // 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.fromAscii2) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extensionMap) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fromAscii2 != 0 { - try visitor.visitSingularInt32Field(value: self.fromAscii2, fieldNumber: 1) + if self.extensionMap != 0 { + try visitor.visitSingularInt32Field(value: self.extensionMap, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii2, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii2) -> Bool { - if lhs.fromAscii2 != rhs.fromAscii2 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ExtensionMap) -> Bool { + if lhs.extensionMap != rhs.extensionMap {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fromAscii4" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fromAscii4"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionRange: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".extensionRange" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extensionRange\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20746,31 +21901,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii4: S // 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.fromAscii4) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extensionRange) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fromAscii4 != 0 { - try visitor.visitSingularInt32Field(value: self.fromAscii4, fieldNumber: 1) + if self.extensionRange != 0 { + try visitor.visitSingularInt32Field(value: self.extensionRange, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii4, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromAscii4) -> Bool { - if lhs.fromAscii4 != rhs.fromAscii4 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionRange, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensionRange) -> Bool { + if lhs.extensionRange != rhs.extensionRange {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromByteOffset: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fromByteOffset" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fromByteOffset"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".extensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extensions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20778,31 +21931,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromByteOffse // 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.fromByteOffset) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extensions) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fromByteOffset != 0 { - try visitor.visitSingularInt32Field(value: self.fromByteOffset, fieldNumber: 1) + if self.extensions != 0 { + try visitor.visitSingularInt32Field(value: self.extensions, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromByteOffset, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromByteOffset) -> Bool { - if lhs.fromByteOffset != rhs.fromByteOffset {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extensions) -> Bool { + if lhs.extensions != rhs.extensions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromHexDigit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".fromHexDigit" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fromHexDigit"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extras: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".extras" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extras\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20810,31 +21961,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromHexDigit: // 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.fromHexDigit) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.extras) }() default: break } } } func traverse(visitor: inout V) throws { - if self.fromHexDigit != 0 { - try visitor.visitSingularInt32Field(value: self.fromHexDigit, fieldNumber: 1) + if self.extras != 0 { + try visitor.visitSingularInt32Field(value: self.extras, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromHexDigit, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.fromHexDigit) -> Bool { - if lhs.fromHexDigit != rhs.fromHexDigit {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extras, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.extras) -> Bool { + if lhs.extras != rhs.extras {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.funcMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".func" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "func"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.F: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".F" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}F\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20842,31 +21991,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.funcMessage: // 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.`func`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.f) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`func` != 0 { - try visitor.visitSingularInt32Field(value: self.`func`, fieldNumber: 1) + if self.f != 0 { + try visitor.visitSingularInt32Field(value: self.f, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.funcMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.funcMessage) -> Bool { - if lhs.`func` != rhs.`func` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.F, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.F) -> Bool { + if lhs.f != rhs.f {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.G: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".G" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "G"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.falseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".false" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}false\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20874,31 +22021,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.G: SwiftProto // 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.g) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`false`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.g != 0 { - try visitor.visitSingularInt32Field(value: self.g, fieldNumber: 1) + if self.`false` != 0 { + try visitor.visitSingularInt32Field(value: self.`false`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.G, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.G) -> Bool { - if lhs.g != rhs.g {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.falseMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.falseMessage) -> Bool { + if lhs.`false` != rhs.`false` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.GeneratedCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".GeneratedCodeInfo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "GeneratedCodeInfo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.features: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".features" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}features\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20906,31 +22051,1289 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.GeneratedCode // 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.generatedCodeInfo) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.features) }() default: break } } } func traverse(visitor: inout V) throws { - if self.generatedCodeInfo != 0 { - try visitor.visitSingularInt32Field(value: self.generatedCodeInfo, fieldNumber: 1) + if self.features != 0 { + try visitor.visitSingularInt32Field(value: self.features, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.GeneratedCodeInfo, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.GeneratedCodeInfo) -> Bool { - if lhs.generatedCodeInfo != rhs.generatedCodeInfo {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.features, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.features) -> Bool { + if lhs.features != rhs.features {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.get: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".get" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "get"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FeatureSetEditionDefault: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".FeatureSetEditionDefault" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FeatureSetEditionDefault\0") + + 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.featureSetEditionDefault) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.featureSetEditionDefault != 0 { + try visitor.visitSingularInt32Field(value: self.featureSetEditionDefault, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FeatureSetEditionDefault, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FeatureSetEditionDefault) -> Bool { + if lhs.featureSetEditionDefault != rhs.featureSetEditionDefault {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.featureSupport: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".featureSupport" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}featureSupport\0") + + 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.featureSupport) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.featureSupport != 0 { + try visitor.visitSingularInt32Field(value: self.featureSupport, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.featureSupport, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.featureSupport) -> Bool { + if lhs.featureSupport != rhs.featureSupport {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field\0") + + 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.field) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.field != 0 { + try visitor.visitSingularInt32Field(value: self.field, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.field) -> Bool { + if lhs.field != rhs.field {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fieldData\0") + + 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.fieldData) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldData != 0 { + try visitor.visitSingularInt32Field(value: self.fieldData, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldData, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldData) -> Bool { + if lhs.fieldData != rhs.fieldData {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldMaskError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".FieldMaskError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FieldMaskError\0") + + 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.fieldMaskError) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldMaskError != 0 { + try visitor.visitSingularInt32Field(value: self.fieldMaskError, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldMaskError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldMaskError) -> Bool { + if lhs.fieldMaskError != rhs.fieldMaskError {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fieldName\0") + + 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.fieldName) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldName != 0 { + try visitor.visitSingularInt32Field(value: self.fieldName, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldName) -> Bool { + if lhs.fieldName != rhs.fieldName {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNameCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldNameCount" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fieldNameCount\0") + + 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.fieldNameCount) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldNameCount != 0 { + try visitor.visitSingularInt32Field(value: self.fieldNameCount, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNameCount, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNameCount) -> Bool { + if lhs.fieldNameCount != rhs.fieldNameCount {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldNum" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fieldNum\0") + + 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.fieldNum) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldNum != 0 { + try visitor.visitSingularInt32Field(value: self.fieldNum, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNum, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNum) -> Bool { + if lhs.fieldNum != rhs.fieldNum {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fieldNumber\0") + + 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.fieldNumber) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldNumber != 0 { + try visitor.visitSingularInt32Field(value: self.fieldNumber, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNumber) -> Bool { + if lhs.fieldNumber != rhs.fieldNumber {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNumberForProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldNumberForProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fieldNumberForProto\0") + + 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.fieldNumberForProto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldNumberForProto != 0 { + try visitor.visitSingularInt32Field(value: self.fieldNumberForProto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNumberForProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldNumberForProto) -> Bool { + if lhs.fieldNumberForProto != rhs.fieldNumberForProto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldPresence: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldPresence" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fieldPresence\0") + + 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.fieldPresence) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldPresence != 0 { + try visitor.visitSingularInt32Field(value: self.fieldPresence, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldPresence, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldPresence) -> Bool { + if lhs.fieldPresence != rhs.fieldPresence {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fields\0") + + 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.fields) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fields != 0 { + try visitor.visitSingularInt32Field(value: self.fields, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fields) -> Bool { + if lhs.fields != rhs.fields {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fieldSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fieldSize\0") + + 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.fieldSize) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldSize != 0 { + try visitor.visitSingularInt32Field(value: self.fieldSize, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fieldSize) -> Bool { + if lhs.fieldSize != rhs.fieldSize {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldTag: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".FieldTag" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FieldTag\0") + + 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.fieldTag) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldTag != 0 { + try visitor.visitSingularInt32Field(value: self.fieldTag, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldTag, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldTag) -> Bool { + if lhs.fieldTag != rhs.fieldTag {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".FieldType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FieldType\0") + + 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.fieldType) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fieldType != 0 { + try visitor.visitSingularInt32Field(value: self.fieldType, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FieldType) -> Bool { + if lhs.fieldType != rhs.fieldType {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.file: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".file" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}file\0") + + 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.file) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.file != 0 { + try visitor.visitSingularInt32Field(value: self.file, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.file, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.file) -> Bool { + if lhs.file != rhs.file {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fileName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fileName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fileName\0") + + 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.fileName) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fileName != 0 { + try visitor.visitSingularInt32Field(value: self.fileName, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fileName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fileName) -> Bool { + if lhs.fileName != rhs.fileName {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.filter: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".filter" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}filter\0") + + 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.filter) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.filter != 0 { + try visitor.visitSingularInt32Field(value: self.filter, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.filter, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.filter) -> Bool { + if lhs.filter != rhs.filter {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.final: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".final" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}final\0") + + 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.final) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.final != 0 { + try visitor.visitSingularInt32Field(value: self.final, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.final, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.final) -> Bool { + if lhs.final != rhs.final {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.finiteOnly: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".finiteOnly" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}finiteOnly\0") + + 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.finiteOnly) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.finiteOnly != 0 { + try visitor.visitSingularInt32Field(value: self.finiteOnly, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.finiteOnly, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.finiteOnly) -> Bool { + if lhs.finiteOnly != rhs.finiteOnly {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.first: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".first" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}first\0") + + 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.first) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.first != 0 { + try visitor.visitSingularInt32Field(value: self.first, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.first, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.first) -> Bool { + if lhs.first != rhs.first {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.firstItem: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".firstItem" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}firstItem\0") + + 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.firstItem) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.firstItem != 0 { + try visitor.visitSingularInt32Field(value: self.firstItem, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.firstItem, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.firstItem) -> Bool { + if lhs.firstItem != rhs.firstItem {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fixedFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fixedFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fixedFeatures\0") + + 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.fixedFeatures) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fixedFeatures != 0 { + try visitor.visitSingularInt32Field(value: self.fixedFeatures, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fixedFeatures, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fixedFeatures) -> Bool { + if lhs.fixedFeatures != rhs.fixedFeatures {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Float" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Float\0") + + 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.float) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.float != 0 { + try visitor.visitSingularInt32Field(value: self.float, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatMessage) -> Bool { + if lhs.float != rhs.float {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.floatLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".floatLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}floatLiteral\0") + + 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.floatLiteral) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.floatLiteral != 0 { + try visitor.visitSingularInt32Field(value: self.floatLiteral, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.floatLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.floatLiteral) -> Bool { + if lhs.floatLiteral != rhs.floatLiteral {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".FloatLiteralType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FloatLiteralType\0") + + 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.floatLiteralType) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.floatLiteralType != 0 { + try visitor.visitSingularInt32Field(value: self.floatLiteralType, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatLiteralType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.FloatLiteralType) -> Bool { + if lhs.floatLiteralType != rhs.floatLiteralType {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".for" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}for\0") + + 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.`for`) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.`for` != 0 { + try visitor.visitSingularInt32Field(value: self.`for`, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forMessage) -> Bool { + if lhs.`for` != rhs.`for` {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forMessageName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".forMessageName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}forMessageName\0") + + 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.forMessageName) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.forMessageName != 0 { + try visitor.visitSingularInt32Field(value: self.forMessageName, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forMessageName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forMessageName) -> Bool { + if lhs.forMessageName != rhs.forMessageName {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.formUnion: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".formUnion" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}formUnion\0") + + 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.formUnion) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.formUnion != 0 { + try visitor.visitSingularInt32Field(value: self.formUnion, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.formUnion, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.formUnion) -> Bool { + if lhs.formUnion != rhs.formUnion {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forReadingFrom: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".forReadingFrom" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}forReadingFrom\0") + + 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.forReadingFrom) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.forReadingFrom != 0 { + try visitor.visitSingularInt32Field(value: self.forReadingFrom, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forReadingFrom, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forReadingFrom) -> Bool { + if lhs.forReadingFrom != rhs.forReadingFrom {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forTypeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".forTypeURL" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}forTypeURL\0") + + 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.forTypeURL) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.forTypeURL != 0 { + try visitor.visitSingularInt32Field(value: self.forTypeURL, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forTypeURL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forTypeURL) -> Bool { + if lhs.forTypeURL != rhs.forTypeURL {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ForwardParser: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ForwardParser" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ForwardParser\0") + + 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.forwardParser) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.forwardParser != 0 { + try visitor.visitSingularInt32Field(value: self.forwardParser, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ForwardParser, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ForwardParser) -> Bool { + if lhs.forwardParser != rhs.forwardParser {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forWritingInto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".forWritingInto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}forWritingInto\0") + + 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.forWritingInto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.forWritingInto != 0 { + try visitor.visitSingularInt32Field(value: self.forWritingInto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forWritingInto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.forWritingInto) -> Bool { + if lhs.forWritingInto != rhs.forWritingInto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.from: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".from" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}from\0") + + 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.from) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.from != 0 { + try visitor.visitSingularInt32Field(value: self.from, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.from, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.from) -> Bool { + if lhs.from != rhs.from {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromAscii2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fromAscii2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fromAscii2\0") + + 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.fromAscii2) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fromAscii2 != 0 { + try visitor.visitSingularInt32Field(value: self.fromAscii2, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromAscii2, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromAscii2) -> Bool { + if lhs.fromAscii2 != rhs.fromAscii2 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromAscii4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fromAscii4" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fromAscii4\0") + + 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.fromAscii4) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fromAscii4 != 0 { + try visitor.visitSingularInt32Field(value: self.fromAscii4, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromAscii4, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromAscii4) -> Bool { + if lhs.fromAscii4 != rhs.fromAscii4 {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromByteOffset: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fromByteOffset" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fromByteOffset\0") + + 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.fromByteOffset) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fromByteOffset != 0 { + try visitor.visitSingularInt32Field(value: self.fromByteOffset, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromByteOffset, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromByteOffset) -> Bool { + if lhs.fromByteOffset != rhs.fromByteOffset {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromHexDigit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fromHexDigit" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fromHexDigit\0") + + 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.fromHexDigit) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fromHexDigit != 0 { + try visitor.visitSingularInt32Field(value: self.fromHexDigit, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromHexDigit, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fromHexDigit) -> Bool { + if lhs.fromHexDigit != rhs.fromHexDigit {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fullName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".fullName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fullName\0") + + 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.fullName) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.fullName != 0 { + try visitor.visitSingularInt32Field(value: self.fullName, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fullName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.fullName) -> Bool { + if lhs.fullName != rhs.fullName {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.funcMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".func" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}func\0") + + 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.`func`) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.`func` != 0 { + try visitor.visitSingularInt32Field(value: self.`func`, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.funcMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.funcMessage) -> Bool { + if lhs.`func` != rhs.`func` {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.function: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".function" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}function\0") + + 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.function) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.function != 0 { + try visitor.visitSingularInt32Field(value: self.function, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.function, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.function) -> Bool { + if lhs.function != rhs.function {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.G: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".G" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}G\0") + + 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.g) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.g != 0 { + try visitor.visitSingularInt32Field(value: self.g, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.G, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.G) -> Bool { + if lhs.g != rhs.g {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.get: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".get" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}get\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20945,24 +23348,1522 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.get: SwiftPro } func traverse(visitor: inout V) throws { - if self.get != 0 { - try visitor.visitSingularInt32Field(value: self.get, fieldNumber: 1) + if self.get != 0 { + try visitor.visitSingularInt32Field(value: self.get, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.get, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.get) -> Bool { + if lhs.get != rhs.get {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.getExtensionValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".getExtensionValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}getExtensionValue\0") + + 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.getExtensionValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.getExtensionValue != 0 { + try visitor.visitSingularInt32Field(value: self.getExtensionValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.getExtensionValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.getExtensionValue) -> Bool { + if lhs.getExtensionValue != rhs.getExtensionValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Any: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Any" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Any\0") + + 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.googleProtobufAny) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufAny != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufAny, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Any, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Any) -> Bool { + if lhs.googleProtobufAny != rhs.googleProtobufAny {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Api: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Api" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Api\0") + + 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.googleProtobufApi) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufApi != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufApi, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Api, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Api) -> Bool { + if lhs.googleProtobufApi != rhs.googleProtobufApi {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_BoolValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_BoolValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_BoolValue\0") + + 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.googleProtobufBoolValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufBoolValue != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufBoolValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_BoolValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_BoolValue) -> Bool { + if lhs.googleProtobufBoolValue != rhs.googleProtobufBoolValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_BytesValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_BytesValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_BytesValue\0") + + 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.googleProtobufBytesValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufBytesValue != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufBytesValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_BytesValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_BytesValue) -> Bool { + if lhs.googleProtobufBytesValue != rhs.googleProtobufBytesValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_DescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_DescriptorProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_DescriptorProto\0") + + 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.googleProtobufDescriptorProto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufDescriptorProto != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufDescriptorProto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_DescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_DescriptorProto) -> Bool { + if lhs.googleProtobufDescriptorProto != rhs.googleProtobufDescriptorProto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_DoubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_DoubleValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_DoubleValue\0") + + 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.googleProtobufDoubleValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufDoubleValue != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufDoubleValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_DoubleValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_DoubleValue) -> Bool { + if lhs.googleProtobufDoubleValue != rhs.googleProtobufDoubleValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Duration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Duration" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Duration\0") + + 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.googleProtobufDuration) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufDuration != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufDuration, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Duration, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Duration) -> Bool { + if lhs.googleProtobufDuration != rhs.googleProtobufDuration {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Edition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Edition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Edition\0") + + 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.googleProtobufEdition) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufEdition != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufEdition, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Edition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Edition) -> Bool { + if lhs.googleProtobufEdition != rhs.googleProtobufEdition {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Empty: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Empty" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Empty\0") + + 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.googleProtobufEmpty) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufEmpty != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufEmpty, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Empty, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Empty) -> Bool { + if lhs.googleProtobufEmpty != rhs.googleProtobufEmpty {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Enum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Enum" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Enum\0") + + 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.googleProtobufEnum) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufEnum != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufEnum, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Enum, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Enum) -> Bool { + if lhs.googleProtobufEnum != rhs.googleProtobufEnum {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumDescriptorProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_EnumDescriptorProto\0") + + 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.googleProtobufEnumDescriptorProto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufEnumDescriptorProto != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufEnumDescriptorProto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumDescriptorProto) -> Bool { + if lhs.googleProtobufEnumDescriptorProto != rhs.googleProtobufEnumDescriptorProto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_EnumOptions\0") + + 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.googleProtobufEnumOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufEnumOptions != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufEnumOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumOptions) -> Bool { + if lhs.googleProtobufEnumOptions != rhs.googleProtobufEnumOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_EnumValue\0") + + 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.googleProtobufEnumValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufEnumValue != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufEnumValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValue) -> Bool { + if lhs.googleProtobufEnumValue != rhs.googleProtobufEnumValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumValueDescriptorProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_EnumValueDescriptorProto\0") + + 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.googleProtobufEnumValueDescriptorProto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufEnumValueDescriptorProto != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufEnumValueDescriptorProto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueDescriptorProto) -> Bool { + if lhs.googleProtobufEnumValueDescriptorProto != rhs.googleProtobufEnumValueDescriptorProto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumValueOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_EnumValueOptions\0") + + 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.googleProtobufEnumValueOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufEnumValueOptions != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufEnumValueOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueOptions) -> Bool { + if lhs.googleProtobufEnumValueOptions != rhs.googleProtobufEnumValueOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_ExtensionRangeOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_ExtensionRangeOptions\0") + + 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.googleProtobufExtensionRangeOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufExtensionRangeOptions != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufExtensionRangeOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ExtensionRangeOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ExtensionRangeOptions) -> Bool { + if lhs.googleProtobufExtensionRangeOptions != rhs.googleProtobufExtensionRangeOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FeatureSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FeatureSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_FeatureSet\0") + + 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.googleProtobufFeatureSet) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufFeatureSet != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufFeatureSet, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FeatureSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FeatureSet) -> Bool { + if lhs.googleProtobufFeatureSet != rhs.googleProtobufFeatureSet {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FeatureSetDefaults: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FeatureSetDefaults" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_FeatureSetDefaults\0") + + 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.googleProtobufFeatureSetDefaults) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufFeatureSetDefaults != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufFeatureSetDefaults, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FeatureSetDefaults, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FeatureSetDefaults) -> Bool { + if lhs.googleProtobufFeatureSetDefaults != rhs.googleProtobufFeatureSetDefaults {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Field\0") + + 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.googleProtobufField) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufField != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufField, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Field) -> Bool { + if lhs.googleProtobufField != rhs.googleProtobufField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FieldDescriptorProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_FieldDescriptorProto\0") + + 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.googleProtobufFieldDescriptorProto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufFieldDescriptorProto != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufFieldDescriptorProto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldDescriptorProto) -> Bool { + if lhs.googleProtobufFieldDescriptorProto != rhs.googleProtobufFieldDescriptorProto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldMask: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FieldMask" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_FieldMask\0") + + 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.googleProtobufFieldMask) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufFieldMask != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufFieldMask, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldMask, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldMask) -> Bool { + if lhs.googleProtobufFieldMask != rhs.googleProtobufFieldMask {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FieldOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_FieldOptions\0") + + 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.googleProtobufFieldOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufFieldOptions != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufFieldOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldOptions) -> Bool { + if lhs.googleProtobufFieldOptions != rhs.googleProtobufFieldOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FileDescriptorProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_FileDescriptorProto\0") + + 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.googleProtobufFileDescriptorProto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufFileDescriptorProto != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufFileDescriptorProto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorProto) -> Bool { + if lhs.googleProtobufFileDescriptorProto != rhs.googleProtobufFileDescriptorProto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FileDescriptorSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_FileDescriptorSet\0") + + 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.googleProtobufFileDescriptorSet) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufFileDescriptorSet != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufFileDescriptorSet, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorSet) -> Bool { + if lhs.googleProtobufFileDescriptorSet != rhs.googleProtobufFileDescriptorSet {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FileOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_FileOptions\0") + + 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.googleProtobufFileOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufFileOptions != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufFileOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FileOptions) -> Bool { + if lhs.googleProtobufFileOptions != rhs.googleProtobufFileOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FloatValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FloatValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_FloatValue\0") + + 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.googleProtobufFloatValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufFloatValue != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufFloatValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FloatValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_FloatValue) -> Bool { + if lhs.googleProtobufFloatValue != rhs.googleProtobufFloatValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_GeneratedCodeInfo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_GeneratedCodeInfo\0") + + 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.googleProtobufGeneratedCodeInfo) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufGeneratedCodeInfo != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufGeneratedCodeInfo, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_GeneratedCodeInfo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_GeneratedCodeInfo) -> Bool { + if lhs.googleProtobufGeneratedCodeInfo != rhs.googleProtobufGeneratedCodeInfo {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Int32Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Int32Value" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Int32Value\0") + + 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.googleProtobufInt32Value) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufInt32Value != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufInt32Value, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Int32Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Int32Value) -> Bool { + if lhs.googleProtobufInt32Value != rhs.googleProtobufInt32Value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Int64Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Int64Value" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Int64Value\0") + + 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.googleProtobufInt64Value) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufInt64Value != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufInt64Value, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Int64Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Int64Value) -> Bool { + if lhs.googleProtobufInt64Value != rhs.googleProtobufInt64Value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ListValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_ListValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_ListValue\0") + + 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.googleProtobufListValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufListValue != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufListValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ListValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ListValue) -> Bool { + if lhs.googleProtobufListValue != rhs.googleProtobufListValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MessageOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_MessageOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_MessageOptions\0") + + 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.googleProtobufMessageOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufMessageOptions != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufMessageOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MessageOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MessageOptions) -> Bool { + if lhs.googleProtobufMessageOptions != rhs.googleProtobufMessageOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Method: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Method" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Method\0") + + 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.googleProtobufMethod) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufMethod != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufMethod, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Method, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Method) -> Bool { + if lhs.googleProtobufMethod != rhs.googleProtobufMethod {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_MethodDescriptorProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_MethodDescriptorProto\0") + + 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.googleProtobufMethodDescriptorProto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufMethodDescriptorProto != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufMethodDescriptorProto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodDescriptorProto) -> Bool { + if lhs.googleProtobufMethodDescriptorProto != rhs.googleProtobufMethodDescriptorProto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_MethodOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_MethodOptions\0") + + 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.googleProtobufMethodOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufMethodOptions != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufMethodOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodOptions) -> Bool { + if lhs.googleProtobufMethodOptions != rhs.googleProtobufMethodOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Mixin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Mixin" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Mixin\0") + + 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.googleProtobufMixin) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufMixin != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufMixin, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Mixin, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Mixin) -> Bool { + if lhs.googleProtobufMixin != rhs.googleProtobufMixin {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_NullValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_NullValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_NullValue\0") + + 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.googleProtobufNullValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufNullValue != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufNullValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_NullValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_NullValue) -> Bool { + if lhs.googleProtobufNullValue != rhs.googleProtobufNullValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_OneofDescriptorProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_OneofDescriptorProto\0") + + 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.googleProtobufOneofDescriptorProto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufOneofDescriptorProto != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufOneofDescriptorProto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofDescriptorProto) -> Bool { + if lhs.googleProtobufOneofDescriptorProto != rhs.googleProtobufOneofDescriptorProto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_OneofOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_OneofOptions\0") + + 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.googleProtobufOneofOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufOneofOptions != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufOneofOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofOptions) -> Bool { + if lhs.googleProtobufOneofOptions != rhs.googleProtobufOneofOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Option: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Option" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Option\0") + + 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.googleProtobufOption) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufOption != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufOption, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Option, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Option) -> Bool { + if lhs.googleProtobufOption != rhs.googleProtobufOption {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_ServiceDescriptorProto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_ServiceDescriptorProto\0") + + 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.googleProtobufServiceDescriptorProto) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufServiceDescriptorProto != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufServiceDescriptorProto, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceDescriptorProto, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceDescriptorProto) -> Bool { + if lhs.googleProtobufServiceDescriptorProto != rhs.googleProtobufServiceDescriptorProto {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_ServiceOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_ServiceOptions\0") + + 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.googleProtobufServiceOptions) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufServiceOptions != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufServiceOptions, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceOptions) -> Bool { + if lhs.googleProtobufServiceOptions != rhs.googleProtobufServiceOptions {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_SourceCodeInfo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_SourceCodeInfo\0") + + 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.googleProtobufSourceCodeInfo) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufSourceCodeInfo != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufSourceCodeInfo, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceCodeInfo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceCodeInfo) -> Bool { + if lhs.googleProtobufSourceCodeInfo != rhs.googleProtobufSourceCodeInfo {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceContext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_SourceContext" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_SourceContext\0") + + 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.googleProtobufSourceContext) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufSourceContext != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufSourceContext, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceContext, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceContext) -> Bool { + if lhs.googleProtobufSourceContext != rhs.googleProtobufSourceContext {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_StringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_StringValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_StringValue\0") + + 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.googleProtobufStringValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufStringValue != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufStringValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_StringValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_StringValue) -> Bool { + if lhs.googleProtobufStringValue != rhs.googleProtobufStringValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Struct: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Struct" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Struct\0") + + 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.googleProtobufStruct) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufStruct != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufStruct, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Struct, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Struct) -> Bool { + if lhs.googleProtobufStruct != rhs.googleProtobufStruct {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SymbolVisibility: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_SymbolVisibility" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_SymbolVisibility\0") + + 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.googleProtobufSymbolVisibility) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufSymbolVisibility != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufSymbolVisibility, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SymbolVisibility, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_SymbolVisibility) -> Bool { + if lhs.googleProtobufSymbolVisibility != rhs.googleProtobufSymbolVisibility {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Syntax: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Syntax" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Syntax\0") + + 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.googleProtobufSyntax) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufSyntax != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufSyntax, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Syntax, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Syntax) -> Bool { + if lhs.googleProtobufSyntax != rhs.googleProtobufSyntax {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Timestamp: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Timestamp" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Timestamp\0") + + 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.googleProtobufTimestamp) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufTimestamp != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufTimestamp, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Timestamp, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Timestamp) -> Bool { + if lhs.googleProtobufTimestamp != rhs.googleProtobufTimestamp {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Type: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Type" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Type\0") + + 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.googleProtobufType) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.googleProtobufType != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.get, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.get) -> Bool { - if lhs.get != rhs.get {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Type, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Type) -> Bool { + if lhs.googleProtobufType != rhs.googleProtobufType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.getExtensionValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".getExtensionValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "getExtensionValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt32Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_UInt32Value" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_UInt32Value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20970,31 +24871,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.getExtensionV // 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.getExtensionValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.googleProtobufUint32Value) }() default: break } } } func traverse(visitor: inout V) throws { - if self.getExtensionValue != 0 { - try visitor.visitSingularInt32Field(value: self.getExtensionValue, fieldNumber: 1) + if self.googleProtobufUint32Value != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufUint32Value, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.getExtensionValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.getExtensionValue) -> Bool { - if lhs.getExtensionValue != rhs.getExtensionValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt32Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt32Value) -> Bool { + if lhs.googleProtobufUint32Value != rhs.googleProtobufUint32Value {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.googleapis: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".googleapis" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "googleapis"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt64Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_UInt64Value" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_UInt64Value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21002,31 +24901,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.googleapis: S // 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.googleapis) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.googleProtobufUint64Value) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleapis != 0 { - try visitor.visitSingularInt32Field(value: self.googleapis, fieldNumber: 1) + if self.googleProtobufUint64Value != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufUint64Value, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.googleapis, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.googleapis) -> Bool { - if lhs.googleapis != rhs.googleapis {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt64Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt64Value) -> Bool { + if lhs.googleProtobufUint64Value != rhs.googleProtobufUint64Value {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Any: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Any" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Any"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UninterpretedOption: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_UninterpretedOption" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_UninterpretedOption\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21034,31 +24931,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufAny) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.googleProtobufUninterpretedOption) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufAny != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufAny, fieldNumber: 1) + if self.googleProtobufUninterpretedOption != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufUninterpretedOption, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Any, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Any) -> Bool { - if lhs.googleProtobufAny != rhs.googleProtobufAny {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UninterpretedOption, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_UninterpretedOption) -> Bool { + if lhs.googleProtobufUninterpretedOption != rhs.googleProtobufUninterpretedOption {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Api: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Api" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Api"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Value" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}Google_Protobuf_Value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21066,31 +24961,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufApi) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.googleProtobufValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufApi != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufApi, fieldNumber: 1) + if self.googleProtobufValue != 0 { + try visitor.visitSingularInt32Field(value: self.googleProtobufValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Api, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Api) -> Bool { - if lhs.googleProtobufApi != rhs.googleProtobufApi {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Google_Protobuf_Value) -> Bool { + if lhs.googleProtobufValue != rhs.googleProtobufValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_BoolValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_BoolValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_BoolValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.goPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".goPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}goPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21098,31 +24991,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufBoolValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.goPackage) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufBoolValue != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufBoolValue, fieldNumber: 1) + if self.goPackage != 0 { + try visitor.visitSingularInt32Field(value: self.goPackage, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_BoolValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_BoolValue) -> Bool { - if lhs.googleProtobufBoolValue != rhs.googleProtobufBoolValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.goPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.goPackage) -> Bool { + if lhs.goPackage != rhs.goPackage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_BytesValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_BytesValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_BytesValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.gotData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".gotData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}gotData\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21130,31 +25021,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufBytesValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.gotData) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufBytesValue != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufBytesValue, fieldNumber: 1) + if self.gotData != 0 { + try visitor.visitSingularInt32Field(value: self.gotData, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_BytesValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_BytesValue) -> Bool { - if lhs.googleProtobufBytesValue != rhs.googleProtobufBytesValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.gotData, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.gotData) -> Bool { + if lhs.gotData != rhs.gotData {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_DescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_DescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_DescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.group: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".group" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}group\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21162,31 +25051,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.group) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufDescriptorProto, fieldNumber: 1) + if self.group != 0 { + try visitor.visitSingularInt32Field(value: self.group, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_DescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_DescriptorProto) -> Bool { - if lhs.googleProtobufDescriptorProto != rhs.googleProtobufDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.group, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.group) -> Bool { + if lhs.group != rhs.group {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_DoubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_DoubleValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_DoubleValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.groupFieldNumberStack: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".groupFieldNumberStack" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}groupFieldNumberStack\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21194,31 +25081,569 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufDoubleValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.groupFieldNumberStack) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufDoubleValue != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufDoubleValue, fieldNumber: 1) + if self.groupFieldNumberStack != 0 { + try visitor.visitSingularInt32Field(value: self.groupFieldNumberStack, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_DoubleValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_DoubleValue) -> Bool { - if lhs.googleProtobufDoubleValue != rhs.googleProtobufDoubleValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.groupFieldNumberStack, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.groupFieldNumberStack) -> Bool { + if lhs.groupFieldNumberStack != rhs.groupFieldNumberStack {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.groupSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".groupSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}groupSize\0") + + 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.groupSize) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.groupSize != 0 { + try visitor.visitSingularInt32Field(value: self.groupSize, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.groupSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.groupSize) -> Bool { + if lhs.groupSize != rhs.groupSize {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.guardMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".guard" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}guard\0") + + 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.`guard`) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.`guard` != 0 { + try visitor.visitSingularInt32Field(value: self.`guard`, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.guardMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.guardMessage) -> Bool { + if lhs.`guard` != rhs.`guard` {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hadOneofValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hadOneofValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hadOneofValue\0") + + 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.hadOneofValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hadOneofValue != 0 { + try visitor.visitSingularInt32Field(value: self.hadOneofValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hadOneofValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hadOneofValue) -> Bool { + if lhs.hadOneofValue != rhs.hadOneofValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.handleConflictingOneOf: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".handleConflictingOneOf" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}handleConflictingOneOf\0") + + 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.handleConflictingOneOf) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.handleConflictingOneOf != 0 { + try visitor.visitSingularInt32Field(value: self.handleConflictingOneOf, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.handleConflictingOneOf, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.handleConflictingOneOf) -> Bool { + if lhs.handleConflictingOneOf != rhs.handleConflictingOneOf {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.handleInstruction: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".handleInstruction" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}handleInstruction\0") + + 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.handleInstruction) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.handleInstruction != 0 { + try visitor.visitSingularInt32Field(value: self.handleInstruction, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.handleInstruction, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.handleInstruction) -> Bool { + if lhs.handleInstruction != rhs.handleInstruction {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasAggregateValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasAggregateValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasAggregateValue\0") + + 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.hasAggregateValue_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasAggregateValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasAggregateValue_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasAggregateValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasAggregateValue) -> Bool { + if lhs.hasAggregateValue_p != rhs.hasAggregateValue_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasAllowAlias: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasAllowAlias" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasAllowAlias\0") + + 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.hasAllowAlias_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasAllowAlias_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasAllowAlias_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasAllowAlias, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasAllowAlias) -> Bool { + if lhs.hasAllowAlias_p != rhs.hasAllowAlias_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasBegin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasBegin" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasBegin\0") + + 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.hasBegin_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasBegin_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasBegin_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasBegin, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasBegin) -> Bool { + if lhs.hasBegin_p != rhs.hasBegin_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCcEnableArenas: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasCcEnableArenas" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasCcEnableArenas\0") + + 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.hasCcEnableArenas_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasCcEnableArenas_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasCcEnableArenas_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCcEnableArenas, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCcEnableArenas) -> Bool { + if lhs.hasCcEnableArenas_p != rhs.hasCcEnableArenas_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCcGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasCcGenericServices" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasCcGenericServices\0") + + 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.hasCcGenericServices_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasCcGenericServices_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasCcGenericServices_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCcGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCcGenericServices) -> Bool { + if lhs.hasCcGenericServices_p != rhs.hasCcGenericServices_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasClientStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasClientStreaming" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasClientStreaming\0") + + 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.hasClientStreaming_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasClientStreaming_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasClientStreaming_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasClientStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasClientStreaming) -> Bool { + if lhs.hasClientStreaming_p != rhs.hasClientStreaming_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCsharpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasCsharpNamespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasCsharpNamespace\0") + + 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.hasCsharpNamespace_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasCsharpNamespace_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasCsharpNamespace_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCsharpNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCsharpNamespace) -> Bool { + if lhs.hasCsharpNamespace_p != rhs.hasCsharpNamespace_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCtype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasCtype" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasCtype\0") + + 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.hasCtype_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasCtype_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasCtype_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCtype, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasCtype) -> Bool { + if lhs.hasCtype_p != rhs.hasCtype_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasData\0") + + 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.hasData_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasData_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasData_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasData, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasData) -> Bool { + if lhs.hasData_p != rhs.hasData_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDebugRedact: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDebugRedact" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasDebugRedact\0") + + 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.hasDebugRedact_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasDebugRedact_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasDebugRedact_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDebugRedact, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDebugRedact) -> Bool { + if lhs.hasDebugRedact_p != rhs.hasDebugRedact_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDefaultSymbolVisibility: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDefaultSymbolVisibility" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasDefaultSymbolVisibility\0") + + 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.hasDefaultSymbolVisibility_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasDefaultSymbolVisibility_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasDefaultSymbolVisibility_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDefaultSymbolVisibility, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDefaultSymbolVisibility) -> Bool { + if lhs.hasDefaultSymbolVisibility_p != rhs.hasDefaultSymbolVisibility_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDefaultValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDefaultValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasDefaultValue\0") + + 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.hasDefaultValue_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasDefaultValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasDefaultValue_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDefaultValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDefaultValue) -> Bool { + if lhs.hasDefaultValue_p != rhs.hasDefaultValue_p {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDeprecated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasDeprecated\0") + + 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.hasDeprecated_p) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.hasDeprecated_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasDeprecated_p, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecated) -> Bool { + if lhs.hasDeprecated_p != rhs.hasDeprecated_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Duration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Duration" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Duration"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecatedLegacyJsonFieldConflicts: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDeprecatedLegacyJsonFieldConflicts" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasDeprecatedLegacyJsonFieldConflicts\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21226,31 +25651,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufDuration) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasDeprecatedLegacyJsonFieldConflicts_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufDuration != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufDuration, fieldNumber: 1) + if self.hasDeprecatedLegacyJsonFieldConflicts_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasDeprecatedLegacyJsonFieldConflicts_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Duration, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Duration) -> Bool { - if lhs.googleProtobufDuration != rhs.googleProtobufDuration {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecatedLegacyJsonFieldConflicts, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecatedLegacyJsonFieldConflicts) -> Bool { + if lhs.hasDeprecatedLegacyJsonFieldConflicts_p != rhs.hasDeprecatedLegacyJsonFieldConflicts_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Empty: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Empty" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Empty"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecationWarning: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDeprecationWarning" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasDeprecationWarning\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21258,31 +25681,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufEmpty) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasDeprecationWarning_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufEmpty != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufEmpty, fieldNumber: 1) + if self.hasDeprecationWarning_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasDeprecationWarning_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Empty, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Empty) -> Bool { - if lhs.googleProtobufEmpty != rhs.googleProtobufEmpty {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecationWarning, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDeprecationWarning) -> Bool { + if lhs.hasDeprecationWarning_p != rhs.hasDeprecationWarning_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Enum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Enum" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Enum"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDoubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDoubleValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasDoubleValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21290,31 +25711,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufEnum) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasDoubleValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufEnum != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufEnum, fieldNumber: 1) + if self.hasDoubleValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasDoubleValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Enum, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Enum) -> Bool { - if lhs.googleProtobufEnum != rhs.googleProtobufEnum {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDoubleValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasDoubleValue) -> Bool { + if lhs.hasDoubleValue_p != rhs.hasDoubleValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_EnumDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasEdition\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21322,31 +25741,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufEnumDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasEdition_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufEnumDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufEnumDescriptorProto, fieldNumber: 1) + if self.hasEdition_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasEdition_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumDescriptorProto) -> Bool { - if lhs.googleProtobufEnumDescriptorProto != rhs.googleProtobufEnumDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEdition) -> Bool { + if lhs.hasEdition_p != rhs.hasEdition_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_EnumOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEditionDeprecated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasEditionDeprecated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasEditionDeprecated\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21354,31 +25771,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufEnumOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasEditionDeprecated_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufEnumOptions != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufEnumOptions, fieldNumber: 1) + if self.hasEditionDeprecated_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasEditionDeprecated_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumOptions) -> Bool { - if lhs.googleProtobufEnumOptions != rhs.googleProtobufEnumOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEditionDeprecated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEditionDeprecated) -> Bool { + if lhs.hasEditionDeprecated_p != rhs.hasEditionDeprecated_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_EnumValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEditionIntroduced: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasEditionIntroduced" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasEditionIntroduced\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21386,31 +25801,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufEnumValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasEditionIntroduced_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufEnumValue != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufEnumValue, fieldNumber: 1) + if self.hasEditionIntroduced_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasEditionIntroduced_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValue) -> Bool { - if lhs.googleProtobufEnumValue != rhs.googleProtobufEnumValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEditionIntroduced, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEditionIntroduced) -> Bool { + if lhs.hasEditionIntroduced_p != rhs.hasEditionIntroduced_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumValueDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_EnumValueDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEditionRemoved: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasEditionRemoved" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasEditionRemoved\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21418,31 +25831,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufEnumValueDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasEditionRemoved_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufEnumValueDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufEnumValueDescriptorProto, fieldNumber: 1) + if self.hasEditionRemoved_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasEditionRemoved_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueDescriptorProto) -> Bool { - if lhs.googleProtobufEnumValueDescriptorProto != rhs.googleProtobufEnumValueDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEditionRemoved, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEditionRemoved) -> Bool { + if lhs.hasEditionRemoved_p != rhs.hasEditionRemoved_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_EnumValueOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_EnumValueOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnd: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasEnd" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasEnd\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21450,31 +25861,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufEnumValueOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasEnd_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufEnumValueOptions != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufEnumValueOptions, fieldNumber: 1) + if self.hasEnd_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasEnd_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_EnumValueOptions) -> Bool { - if lhs.googleProtobufEnumValueOptions != rhs.googleProtobufEnumValueOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnd, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnd) -> Bool { + if lhs.hasEnd_p != rhs.hasEnd_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_ExtensionRangeOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_ExtensionRangeOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnforceNamingStyle: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasEnforceNamingStyle" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasEnforceNamingStyle\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21482,31 +25891,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufExtensionRangeOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasEnforceNamingStyle_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufExtensionRangeOptions != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufExtensionRangeOptions, fieldNumber: 1) + if self.hasEnforceNamingStyle_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasEnforceNamingStyle_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ExtensionRangeOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ExtensionRangeOptions) -> Bool { - if lhs.googleProtobufExtensionRangeOptions != rhs.googleProtobufExtensionRangeOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnforceNamingStyle, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnforceNamingStyle) -> Bool { + if lhs.hasEnforceNamingStyle_p != rhs.hasEnforceNamingStyle_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnumType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasEnumType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasEnumType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21514,31 +25921,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasEnumType_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufField != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufField, fieldNumber: 1) + if self.hasEnumType_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasEnumType_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Field) -> Bool { - if lhs.googleProtobufField != rhs.googleProtobufField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnumType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasEnumType) -> Bool { + if lhs.hasEnumType_p != rhs.hasEnumType_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FieldDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_FieldDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExplicitDelta: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasExplicitDelta" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasExplicitDelta\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21546,31 +25951,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufFieldDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasExplicitDelta_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufFieldDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufFieldDescriptorProto, fieldNumber: 1) + if self.hasExplicitDelta_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasExplicitDelta_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldDescriptorProto) -> Bool { - if lhs.googleProtobufFieldDescriptorProto != rhs.googleProtobufFieldDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExplicitDelta, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExplicitDelta) -> Bool { + if lhs.hasExplicitDelta_p != rhs.hasExplicitDelta_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldMask: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FieldMask" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_FieldMask"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExtendee: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasExtendee" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasExtendee\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21578,31 +25981,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufFieldMask) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasExtendee_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufFieldMask != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufFieldMask, fieldNumber: 1) + if self.hasExtendee_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasExtendee_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldMask, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldMask) -> Bool { - if lhs.googleProtobufFieldMask != rhs.googleProtobufFieldMask {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExtendee, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExtendee) -> Bool { + if lhs.hasExtendee_p != rhs.hasExtendee_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FieldOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_FieldOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExtensionValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasExtensionValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasExtensionValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21610,31 +26011,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufFieldOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasExtensionValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufFieldOptions != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufFieldOptions, fieldNumber: 1) + if self.hasExtensionValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasExtensionValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FieldOptions) -> Bool { - if lhs.googleProtobufFieldOptions != rhs.googleProtobufFieldOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExtensionValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasExtensionValue) -> Bool { + if lhs.hasExtensionValue_p != rhs.hasExtensionValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FileDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_FileDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasFeatures\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21642,31 +26041,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufFileDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasFeatures_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufFileDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufFileDescriptorProto, fieldNumber: 1) + if self.hasFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasFeatures_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorProto) -> Bool { - if lhs.googleProtobufFileDescriptorProto != rhs.googleProtobufFileDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFeatures, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFeatures) -> Bool { + if lhs.hasFeatures_p != rhs.hasFeatures_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FileDescriptorSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_FileDescriptorSet"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFeatureSupport: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasFeatureSupport" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasFeatureSupport\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21674,31 +26071,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufFileDescriptorSet) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasFeatureSupport_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufFileDescriptorSet != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufFileDescriptorSet, fieldNumber: 1) + if self.hasFeatureSupport_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasFeatureSupport_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorSet, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileDescriptorSet) -> Bool { - if lhs.googleProtobufFileDescriptorSet != rhs.googleProtobufFileDescriptorSet {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFeatureSupport, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFeatureSupport) -> Bool { + if lhs.hasFeatureSupport_p != rhs.hasFeatureSupport_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FileOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_FileOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFieldPresence: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasFieldPresence" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasFieldPresence\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21706,31 +26101,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufFileOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasFieldPresence_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufFileOptions != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufFileOptions, fieldNumber: 1) + if self.hasFieldPresence_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasFieldPresence_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FileOptions) -> Bool { - if lhs.googleProtobufFileOptions != rhs.googleProtobufFileOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFieldPresence, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFieldPresence) -> Bool { + if lhs.hasFieldPresence_p != rhs.hasFieldPresence_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FloatValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_FloatValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_FloatValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFixedFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasFixedFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasFixedFeatures\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21738,31 +26131,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufFloatValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasFixedFeatures_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufFloatValue != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufFloatValue, fieldNumber: 1) + if self.hasFixedFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasFixedFeatures_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FloatValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_FloatValue) -> Bool { - if lhs.googleProtobufFloatValue != rhs.googleProtobufFloatValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFixedFeatures, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFixedFeatures) -> Bool { + if lhs.hasFixedFeatures_p != rhs.hasFixedFeatures_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_GeneratedCodeInfo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_GeneratedCodeInfo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFullName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasFullName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasFullName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21770,31 +26161,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufGeneratedCodeInfo) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasFullName_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufGeneratedCodeInfo != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufGeneratedCodeInfo, fieldNumber: 1) + if self.hasFullName_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasFullName_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_GeneratedCodeInfo, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_GeneratedCodeInfo) -> Bool { - if lhs.googleProtobufGeneratedCodeInfo != rhs.googleProtobufGeneratedCodeInfo {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFullName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasFullName) -> Bool { + if lhs.hasFullName_p != rhs.hasFullName_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Int32Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Int32Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Int32Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasGoPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasGoPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasGoPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21802,31 +26191,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufInt32Value) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasGoPackage_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufInt32Value != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufInt32Value, fieldNumber: 1) + if self.hasGoPackage_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasGoPackage_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Int32Value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Int32Value) -> Bool { - if lhs.googleProtobufInt32Value != rhs.googleProtobufInt32Value {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasGoPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasGoPackage) -> Bool { + if lhs.hasGoPackage_p != rhs.hasGoPackage_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Int64Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Int64Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Int64Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hash" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hash\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21834,31 +26221,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufInt64Value) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hash) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufInt64Value != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufInt64Value, fieldNumber: 1) + if self.hash != 0 { + try visitor.visitSingularInt32Field(value: self.hash, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Int64Value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Int64Value) -> Bool { - if lhs.googleProtobufInt64Value != rhs.googleProtobufInt64Value {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hash, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hash) -> Bool { + if lhs.hash != rhs.hash {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ListValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_ListValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_ListValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.HashableMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Hashable" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Hashable\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21866,31 +26251,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufListValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hashable) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufListValue != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufListValue, fieldNumber: 1) + if self.hashable != 0 { + try visitor.visitSingularInt32Field(value: self.hashable, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ListValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ListValue) -> Bool { - if lhs.googleProtobufListValue != rhs.googleProtobufListValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.HashableMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.HashableMessage) -> Bool { + if lhs.hashable != rhs.hashable {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MessageOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_MessageOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_MessageOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasher: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasher" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasher\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21898,31 +26281,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufMessageOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasher) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufMessageOptions != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufMessageOptions, fieldNumber: 1) + if self.hasher != 0 { + try visitor.visitSingularInt32Field(value: self.hasher, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MessageOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MessageOptions) -> Bool { - if lhs.googleProtobufMessageOptions != rhs.googleProtobufMessageOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasher, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasher) -> Bool { + if lhs.hasher != rhs.hasher {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Method: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Method" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Method"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.HashVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".HashVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}HashVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21930,31 +26311,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufMethod) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hashVisitor) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufMethod != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufMethod, fieldNumber: 1) + if self.hashVisitor != 0 { + try visitor.visitSingularInt32Field(value: self.hashVisitor, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Method, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Method) -> Bool { - if lhs.googleProtobufMethod != rhs.googleProtobufMethod {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.HashVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.HashVisitor) -> Bool { + if lhs.hashVisitor != rhs.hashVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_MethodDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_MethodDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIdempotencyLevel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasIdempotencyLevel" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasIdempotencyLevel\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21962,31 +26341,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufMethodDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasIdempotencyLevel_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufMethodDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufMethodDescriptorProto, fieldNumber: 1) + if self.hasIdempotencyLevel_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasIdempotencyLevel_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodDescriptorProto) -> Bool { - if lhs.googleProtobufMethodDescriptorProto != rhs.googleProtobufMethodDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIdempotencyLevel, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIdempotencyLevel) -> Bool { + if lhs.hasIdempotencyLevel_p != rhs.hasIdempotencyLevel_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_MethodOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_MethodOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIdentifierValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasIdentifierValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasIdentifierValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21994,31 +26371,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufMethodOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasIdentifierValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufMethodOptions != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufMethodOptions, fieldNumber: 1) + if self.hasIdentifierValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasIdentifierValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_MethodOptions) -> Bool { - if lhs.googleProtobufMethodOptions != rhs.googleProtobufMethodOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIdentifierValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIdentifierValue) -> Bool { + if lhs.hasIdentifierValue_p != rhs.hasIdentifierValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Mixin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Mixin" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Mixin"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasInputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasInputType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasInputType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22026,31 +26401,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufMixin) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasInputType_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufMixin != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufMixin, fieldNumber: 1) + if self.hasInputType_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasInputType_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Mixin, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Mixin) -> Bool { - if lhs.googleProtobufMixin != rhs.googleProtobufMixin {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasInputType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasInputType) -> Bool { + if lhs.hasInputType_p != rhs.hasInputType_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_NullValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_NullValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_NullValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIsExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasIsExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasIsExtension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22058,31 +26431,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufNullValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasIsExtension_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufNullValue != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufNullValue, fieldNumber: 1) + if self.hasIsExtension_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasIsExtension_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_NullValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_NullValue) -> Bool { - if lhs.googleProtobufNullValue != rhs.googleProtobufNullValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIsExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasIsExtension) -> Bool { + if lhs.hasIsExtension_p != rhs.hasIsExtension_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_OneofDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_OneofDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaGenerateEqualsAndHash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaGenerateEqualsAndHash" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasJavaGenerateEqualsAndHash\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22090,31 +26461,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufOneofDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasJavaGenerateEqualsAndHash_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufOneofDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufOneofDescriptorProto, fieldNumber: 1) + if self.hasJavaGenerateEqualsAndHash_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasJavaGenerateEqualsAndHash_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofDescriptorProto) -> Bool { - if lhs.googleProtobufOneofDescriptorProto != rhs.googleProtobufOneofDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaGenerateEqualsAndHash, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaGenerateEqualsAndHash) -> Bool { + if lhs.hasJavaGenerateEqualsAndHash_p != rhs.hasJavaGenerateEqualsAndHash_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_OneofOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_OneofOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaGenericServices" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasJavaGenericServices\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22122,31 +26491,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufOneofOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasJavaGenericServices_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufOneofOptions != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufOneofOptions, fieldNumber: 1) + if self.hasJavaGenericServices_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasJavaGenericServices_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_OneofOptions) -> Bool { - if lhs.googleProtobufOneofOptions != rhs.googleProtobufOneofOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaGenericServices) -> Bool { + if lhs.hasJavaGenericServices_p != rhs.hasJavaGenericServices_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Option: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Option" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Option"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaMultipleFiles: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaMultipleFiles" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasJavaMultipleFiles\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22154,31 +26521,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufOption) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasJavaMultipleFiles_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufOption != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufOption, fieldNumber: 1) + if self.hasJavaMultipleFiles_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasJavaMultipleFiles_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Option, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Option) -> Bool { - if lhs.googleProtobufOption != rhs.googleProtobufOption {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaMultipleFiles, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaMultipleFiles) -> Bool { + if lhs.hasJavaMultipleFiles_p != rhs.hasJavaMultipleFiles_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_ServiceDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_ServiceDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaOuterClassname: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaOuterClassname" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasJavaOuterClassname\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22186,31 +26551,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufServiceDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasJavaOuterClassname_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufServiceDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufServiceDescriptorProto, fieldNumber: 1) + if self.hasJavaOuterClassname_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasJavaOuterClassname_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceDescriptorProto) -> Bool { - if lhs.googleProtobufServiceDescriptorProto != rhs.googleProtobufServiceDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaOuterClassname, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaOuterClassname) -> Bool { + if lhs.hasJavaOuterClassname_p != rhs.hasJavaOuterClassname_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_ServiceOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_ServiceOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasJavaPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22218,31 +26581,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufServiceOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasJavaPackage_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufServiceOptions != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufServiceOptions, fieldNumber: 1) + if self.hasJavaPackage_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasJavaPackage_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_ServiceOptions) -> Bool { - if lhs.googleProtobufServiceOptions != rhs.googleProtobufServiceOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaPackage) -> Bool { + if lhs.hasJavaPackage_p != rhs.hasJavaPackage_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_SourceCodeInfo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_SourceCodeInfo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaStringCheckUtf8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaStringCheckUtf8" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasJavaStringCheckUtf8\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22250,31 +26611,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufSourceCodeInfo) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasJavaStringCheckUtf8_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufSourceCodeInfo != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufSourceCodeInfo, fieldNumber: 1) + if self.hasJavaStringCheckUtf8_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasJavaStringCheckUtf8_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceCodeInfo, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceCodeInfo) -> Bool { - if lhs.googleProtobufSourceCodeInfo != rhs.googleProtobufSourceCodeInfo {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaStringCheckUtf8, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJavaStringCheckUtf8) -> Bool { + if lhs.hasJavaStringCheckUtf8_p != rhs.hasJavaStringCheckUtf8_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceContext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_SourceContext" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_SourceContext"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJsonFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJsonFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasJsonFormat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22282,31 +26641,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufSourceContext) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasJsonFormat_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufSourceContext != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufSourceContext, fieldNumber: 1) + if self.hasJsonFormat_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasJsonFormat_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceContext, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_SourceContext) -> Bool { - if lhs.googleProtobufSourceContext != rhs.googleProtobufSourceContext {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJsonFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJsonFormat) -> Bool { + if lhs.hasJsonFormat_p != rhs.hasJsonFormat_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_StringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_StringValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_StringValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJsonName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJsonName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasJsonName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22314,31 +26671,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufStringValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasJsonName_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufStringValue != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufStringValue, fieldNumber: 1) + if self.hasJsonName_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasJsonName_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_StringValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_StringValue) -> Bool { - if lhs.googleProtobufStringValue != rhs.googleProtobufStringValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJsonName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJsonName) -> Bool { + if lhs.hasJsonName_p != rhs.hasJsonName_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Struct: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Struct" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Struct"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJstype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJstype" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasJstype\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22346,31 +26701,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufStruct) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasJstype_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufStruct != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufStruct, fieldNumber: 1) + if self.hasJstype_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasJstype_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Struct, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Struct) -> Bool { - if lhs.googleProtobufStruct != rhs.googleProtobufStruct {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJstype, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasJstype) -> Bool { + if lhs.hasJstype_p != rhs.hasJstype_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Syntax: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Syntax" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Syntax"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLabel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasLabel" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasLabel\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22378,31 +26731,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufSyntax) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasLabel_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufSyntax != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufSyntax, fieldNumber: 1) + if self.hasLabel_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasLabel_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Syntax, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Syntax) -> Bool { - if lhs.googleProtobufSyntax != rhs.googleProtobufSyntax {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLabel, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLabel) -> Bool { + if lhs.hasLabel_p != rhs.hasLabel_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Timestamp: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Timestamp" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Timestamp"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasLazy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasLazy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22410,31 +26761,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufTimestamp) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasLazy_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufTimestamp != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufTimestamp, fieldNumber: 1) + if self.hasLazy_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasLazy_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Timestamp, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Timestamp) -> Bool { - if lhs.googleProtobufTimestamp != rhs.googleProtobufTimestamp {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLazy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLazy) -> Bool { + if lhs.hasLazy_p != rhs.hasLazy_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Type: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Type" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Type"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLeadingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasLeadingComments" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasLeadingComments\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22442,31 +26791,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasLeadingComments_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufType != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufType, fieldNumber: 1) + if self.hasLeadingComments_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasLeadingComments_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Type, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Type) -> Bool { - if lhs.googleProtobufType != rhs.googleProtobufType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLeadingComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasLeadingComments) -> Bool { + if lhs.hasLeadingComments_p != rhs.hasLeadingComments_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt32Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_UInt32Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_UInt32Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMapEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasMapEntry" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasMapEntry\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22474,31 +26821,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufUint32Value) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasMapEntry_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufUint32Value != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufUint32Value, fieldNumber: 1) + if self.hasMapEntry_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasMapEntry_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt32Value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt32Value) -> Bool { - if lhs.googleProtobufUint32Value != rhs.googleProtobufUint32Value {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMapEntry, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMapEntry) -> Bool { + if lhs.hasMapEntry_p != rhs.hasMapEntry_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt64Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_UInt64Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_UInt64Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMaximumEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasMaximumEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasMaximumEdition\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22506,31 +26851,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufUint64Value) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasMaximumEdition_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufUint64Value != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufUint64Value, fieldNumber: 1) + if self.hasMaximumEdition_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasMaximumEdition_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt64Value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UInt64Value) -> Bool { - if lhs.googleProtobufUint64Value != rhs.googleProtobufUint64Value {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMaximumEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMaximumEdition) -> Bool { + if lhs.hasMaximumEdition_p != rhs.hasMaximumEdition_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UninterpretedOption: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_UninterpretedOption" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_UninterpretedOption"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMessageEncoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasMessageEncoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasMessageEncoding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22538,31 +26881,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufUninterpretedOption) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasMessageEncoding_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufUninterpretedOption != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufUninterpretedOption, fieldNumber: 1) + if self.hasMessageEncoding_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasMessageEncoding_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UninterpretedOption, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_UninterpretedOption) -> Bool { - if lhs.googleProtobufUninterpretedOption != rhs.googleProtobufUninterpretedOption {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMessageEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMessageEncoding) -> Bool { + if lhs.hasMessageEncoding_p != rhs.hasMessageEncoding_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Google_Protobuf_Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "Google_Protobuf_Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMessageSetWireFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasMessageSetWireFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasMessageSetWireFormat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22570,31 +26911,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protob // 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.googleProtobufValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasMessageSetWireFormat_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.googleProtobufValue != 0 { - try visitor.visitSingularInt32Field(value: self.googleProtobufValue, fieldNumber: 1) + if self.hasMessageSetWireFormat_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasMessageSetWireFormat_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Google_Protobuf_Value) -> Bool { - if lhs.googleProtobufValue != rhs.googleProtobufValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMessageSetWireFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMessageSetWireFormat) -> Bool { + if lhs.hasMessageSetWireFormat_p != rhs.hasMessageSetWireFormat_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.goPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".goPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "goPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMinimumEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasMinimumEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasMinimumEdition\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22602,31 +26941,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.goPackage: Sw // 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.goPackage) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasMinimumEdition_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.goPackage != 0 { - try visitor.visitSingularInt32Field(value: self.goPackage, fieldNumber: 1) + if self.hasMinimumEdition_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasMinimumEdition_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.goPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.goPackage) -> Bool { - if lhs.goPackage != rhs.goPackage {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMinimumEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasMinimumEdition) -> Bool { + if lhs.hasMinimumEdition_p != rhs.hasMinimumEdition_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.group: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".group" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "group"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22634,31 +26971,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.group: SwiftP // 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.group) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasName_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.group != 0 { - try visitor.visitSingularInt32Field(value: self.group, fieldNumber: 1) + if self.hasName_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasName_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.group, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.group) -> Bool { - if lhs.group != rhs.group {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasName) -> Bool { + if lhs.hasName_p != rhs.hasName_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupFieldNumberStack: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".groupFieldNumberStack" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "groupFieldNumberStack"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNamePart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasNamePart" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasNamePart\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22666,31 +27001,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupFieldNum // 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.groupFieldNumberStack) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasNamePart_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.groupFieldNumberStack != 0 { - try visitor.visitSingularInt32Field(value: self.groupFieldNumberStack, fieldNumber: 1) + if self.hasNamePart_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasNamePart_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupFieldNumberStack, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupFieldNumberStack) -> Bool { - if lhs.groupFieldNumberStack != rhs.groupFieldNumberStack {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNamePart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNamePart) -> Bool { + if lhs.hasNamePart_p != rhs.hasNamePart_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".groupSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "groupSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNegativeIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasNegativeIntValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasNegativeIntValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22698,31 +27031,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupSize: Sw // 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.groupSize) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasNegativeIntValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.groupSize != 0 { - try visitor.visitSingularInt32Field(value: self.groupSize, fieldNumber: 1) + if self.hasNegativeIntValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasNegativeIntValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupSize, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.groupSize) -> Bool { - if lhs.groupSize != rhs.groupSize {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNegativeIntValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNegativeIntValue) -> Bool { + if lhs.hasNegativeIntValue_p != rhs.hasNegativeIntValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.h: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".h" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "h"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNoStandardDescriptorAccessor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasNoStandardDescriptorAccessor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasNoStandardDescriptorAccessor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22730,31 +27061,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.h: SwiftProto // 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.h) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasNoStandardDescriptorAccessor_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.h != 0 { - try visitor.visitSingularInt32Field(value: self.h, fieldNumber: 1) + if self.hasNoStandardDescriptorAccessor_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasNoStandardDescriptorAccessor_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.h, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.h) -> Bool { - if lhs.h != rhs.h {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNoStandardDescriptorAccessor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNoStandardDescriptorAccessor) -> Bool { + if lhs.hasNoStandardDescriptorAccessor_p != rhs.hasNoStandardDescriptorAccessor_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hadOneofValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hadOneofValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hadOneofValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasNumber\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22762,31 +27091,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hadOneofValue // 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.hadOneofValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasNumber_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hadOneofValue != 0 { - try visitor.visitSingularInt32Field(value: self.hadOneofValue, fieldNumber: 1) + if self.hasNumber_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasNumber_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hadOneofValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hadOneofValue) -> Bool { - if lhs.hadOneofValue != rhs.hadOneofValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasNumber) -> Bool { + if lhs.hasNumber_p != rhs.hasNumber_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.handleConflictingOneOf: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".handleConflictingOneOf" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "handleConflictingOneOf"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasObjcClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasObjcClassPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasObjcClassPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22794,31 +27121,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.handleConflic // 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.handleConflictingOneOf) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasObjcClassPrefix_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.handleConflictingOneOf != 0 { - try visitor.visitSingularInt32Field(value: self.handleConflictingOneOf, fieldNumber: 1) + if self.hasObjcClassPrefix_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasObjcClassPrefix_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.handleConflictingOneOf, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.handleConflictingOneOf) -> Bool { - if lhs.handleConflictingOneOf != rhs.handleConflictingOneOf {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasObjcClassPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasObjcClassPrefix) -> Bool { + if lhs.hasObjcClassPrefix_p != rhs.hasObjcClassPrefix_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAggregateValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasAggregateValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasAggregateValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOneofIndex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasOneofIndex" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasOneofIndex\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22826,31 +27151,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAggregateV // 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.hasAggregateValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasOneofIndex_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasAggregateValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasAggregateValue_p, fieldNumber: 1) + if self.hasOneofIndex_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasOneofIndex_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAggregateValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAggregateValue) -> Bool { - if lhs.hasAggregateValue_p != rhs.hasAggregateValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOneofIndex, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOneofIndex) -> Bool { + if lhs.hasOneofIndex_p != rhs.hasOneofIndex_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAllowAlias: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasAllowAlias" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasAllowAlias"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOptimizeFor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasOptimizeFor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasOptimizeFor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22858,31 +27181,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAllowAlias // 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.hasAllowAlias_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasOptimizeFor_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasAllowAlias_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasAllowAlias_p, fieldNumber: 1) + if self.hasOptimizeFor_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasOptimizeFor_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAllowAlias, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasAllowAlias) -> Bool { - if lhs.hasAllowAlias_p != rhs.hasAllowAlias_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOptimizeFor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOptimizeFor) -> Bool { + if lhs.hasOptimizeFor_p != rhs.hasOptimizeFor_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasBegin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasBegin" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasBegin"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22890,31 +27211,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasBegin: Swi // 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.hasBegin_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasOptions_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasBegin_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasBegin_p, fieldNumber: 1) + if self.hasOptions_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasOptions_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasBegin, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasBegin) -> Bool { - if lhs.hasBegin_p != rhs.hasBegin_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOptions) -> Bool { + if lhs.hasOptions_p != rhs.hasOptions_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcEnableArenas: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasCcEnableArenas" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasCcEnableArenas"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOutputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasOutputType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasOutputType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22922,31 +27241,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcEnableAr // 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.hasCcEnableArenas_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasOutputType_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasCcEnableArenas_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasCcEnableArenas_p, fieldNumber: 1) + if self.hasOutputType_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasOutputType_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcEnableArenas, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcEnableArenas) -> Bool { - if lhs.hasCcEnableArenas_p != rhs.hasCcEnableArenas_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOutputType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOutputType) -> Bool { + if lhs.hasOutputType_p != rhs.hasOutputType_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasCcGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasCcGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOverridableFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasOverridableFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasOverridableFeatures\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22954,31 +27271,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcGenericS // 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.hasCcGenericServices_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasOverridableFeatures_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasCcGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasCcGenericServices_p, fieldNumber: 1) + if self.hasOverridableFeatures_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasOverridableFeatures_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCcGenericServices) -> Bool { - if lhs.hasCcGenericServices_p != rhs.hasCcGenericServices_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOverridableFeatures, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasOverridableFeatures) -> Bool { + if lhs.hasOverridableFeatures_p != rhs.hasOverridableFeatures_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasClientStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasClientStreaming" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasClientStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22986,31 +27301,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasClientStre // 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.hasClientStreaming_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasPackage_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasClientStreaming_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasClientStreaming_p, fieldNumber: 1) + if self.hasPackage_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasPackage_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasClientStreaming, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasClientStreaming) -> Bool { - if lhs.hasClientStreaming_p != rhs.hasClientStreaming_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPackage) -> Bool { + if lhs.hasPackage_p != rhs.hasPackage_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCsharpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasCsharpNamespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasCsharpNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPacked: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPacked" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasPacked\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23018,31 +27331,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCsharpName // 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.hasCsharpNamespace_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasPacked_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasCsharpNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasCsharpNamespace_p, fieldNumber: 1) + if self.hasPacked_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasPacked_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCsharpNamespace, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCsharpNamespace) -> Bool { - if lhs.hasCsharpNamespace_p != rhs.hasCsharpNamespace_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPacked, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPacked) -> Bool { + if lhs.hasPacked_p != rhs.hasPacked_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCtype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasCtype" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasCtype"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPhpClassPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasPhpClassPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23050,31 +27361,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCtype: Swi // 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.hasCtype_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasPhpClassPrefix_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasCtype_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasCtype_p, fieldNumber: 1) + if self.hasPhpClassPrefix_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasPhpClassPrefix_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCtype, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasCtype) -> Bool { - if lhs.hasCtype_p != rhs.hasCtype_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpClassPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpClassPrefix) -> Bool { + if lhs.hasPhpClassPrefix_p != rhs.hasPhpClassPrefix_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDefaultValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDefaultValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasDefaultValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpMetadataNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPhpMetadataNamespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasPhpMetadataNamespace\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23082,31 +27391,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDefaultVal // 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.hasDefaultValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasPhpMetadataNamespace_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasDefaultValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasDefaultValue_p, fieldNumber: 1) + if self.hasPhpMetadataNamespace_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasPhpMetadataNamespace_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDefaultValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDefaultValue) -> Bool { - if lhs.hasDefaultValue_p != rhs.hasDefaultValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpMetadataNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpMetadataNamespace) -> Bool { + if lhs.hasPhpMetadataNamespace_p != rhs.hasPhpMetadataNamespace_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDeprecated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDeprecated" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasDeprecated"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPhpNamespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasPhpNamespace\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23114,31 +27421,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDeprecated // 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.hasDeprecated_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasPhpNamespace_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasDeprecated_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasDeprecated_p, fieldNumber: 1) + if self.hasPhpNamespace_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasPhpNamespace_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDeprecated, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDeprecated) -> Bool { - if lhs.hasDeprecated_p != rhs.hasDeprecated_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPhpNamespace) -> Bool { + if lhs.hasPhpNamespace_p != rhs.hasPhpNamespace_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDoubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasDoubleValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasDoubleValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPositiveIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPositiveIntValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasPositiveIntValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23146,31 +27451,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDoubleValu // 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.hasDoubleValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasPositiveIntValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasDoubleValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasDoubleValue_p, fieldNumber: 1) + if self.hasPositiveIntValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasPositiveIntValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDoubleValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasDoubleValue) -> Bool { - if lhs.hasDoubleValue_p != rhs.hasDoubleValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPositiveIntValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPositiveIntValue) -> Bool { + if lhs.hasPositiveIntValue_p != rhs.hasPositiveIntValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasEnd: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasEnd" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasEnd"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasProto3Optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasProto3Optional" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasProto3Optional\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23178,31 +27481,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasEnd: Swift // 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.hasEnd_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasProto3Optional_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasEnd_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasEnd_p, fieldNumber: 1) + if self.hasProto3Optional_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasProto3Optional_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasEnd, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasEnd) -> Bool { - if lhs.hasEnd_p != rhs.hasEnd_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasProto3Optional, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasProto3Optional) -> Bool { + if lhs.hasProto3Optional_p != rhs.hasProto3Optional_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtendee: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasExtendee" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasExtendee"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPyGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPyGenericServices" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasPyGenericServices\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23210,31 +27511,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtendee: // 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.hasExtendee_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasPyGenericServices_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasExtendee_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasExtendee_p, fieldNumber: 1) + if self.hasPyGenericServices_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasPyGenericServices_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtendee, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtendee) -> Bool { - if lhs.hasExtendee_p != rhs.hasExtendee_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPyGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasPyGenericServices) -> Bool { + if lhs.hasPyGenericServices_p != rhs.hasPyGenericServices_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtensionValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasExtensionValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasExtensionValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRemovalError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasRemovalError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasRemovalError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23242,31 +27541,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtensionV // 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.hasExtensionValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasRemovalError_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasExtensionValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasExtensionValue_p, fieldNumber: 1) + if self.hasRemovalError_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasRemovalError_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtensionValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasExtensionValue) -> Bool { - if lhs.hasExtensionValue_p != rhs.hasExtensionValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRemovalError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRemovalError) -> Bool { + if lhs.hasRemovalError_p != rhs.hasRemovalError_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasGoPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasGoPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasGoPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRepeated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasRepeated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasRepeated\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23274,31 +27571,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasGoPackage: // 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.hasGoPackage_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasRepeated_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasGoPackage_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasGoPackage_p, fieldNumber: 1) + if self.hasRepeated_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasRepeated_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasGoPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasGoPackage) -> Bool { - if lhs.hasGoPackage_p != rhs.hasGoPackage_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRepeated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRepeated) -> Bool { + if lhs.hasRepeated_p != rhs.hasRepeated_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hash" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hash"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRepeatedFieldEncoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasRepeatedFieldEncoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasRepeatedFieldEncoding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23306,31 +27601,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hash: SwiftPr // 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.hash) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasRepeatedFieldEncoding_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hash != 0 { - try visitor.visitSingularInt32Field(value: self.hash, fieldNumber: 1) + if self.hasRepeatedFieldEncoding_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasRepeatedFieldEncoding_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hash, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hash) -> Bool { - if lhs.hash != rhs.hash {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRepeatedFieldEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRepeatedFieldEncoding) -> Bool { + if lhs.hasRepeatedFieldEncoding_p != rhs.hasRepeatedFieldEncoding_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Hashable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Hashable" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Hashable"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasReserved: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasReserved" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasReserved\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23338,31 +27631,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Hashable: Swi // 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.hashable) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasReserved_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hashable != 0 { - try visitor.visitSingularInt32Field(value: self.hashable, fieldNumber: 1) + if self.hasReserved_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasReserved_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Hashable, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Hashable) -> Bool { - if lhs.hashable != rhs.hashable {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasReserved, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasReserved) -> Bool { + if lhs.hasReserved_p != rhs.hasReserved_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasher: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasher" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasher"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRetention: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasRetention" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasRetention\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23370,31 +27661,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasher: Swift // 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.hasher) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasRetention_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasher != 0 { - try visitor.visitSingularInt32Field(value: self.hasher, fieldNumber: 1) + if self.hasRetention_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasRetention_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasher, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasher) -> Bool { - if lhs.hasher != rhs.hasher {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRetention, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRetention) -> Bool { + if lhs.hasRetention_p != rhs.hasRetention_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hashValueMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hashValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hashValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRubyPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasRubyPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasRubyPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23402,31 +27691,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hashValueMess // 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.hashValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasRubyPackage_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hashValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hashValue_p, fieldNumber: 1) + if self.hasRubyPackage_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasRubyPackage_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hashValueMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hashValueMessage) -> Bool { - if lhs.hashValue_p != rhs.hashValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRubyPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasRubyPackage) -> Bool { + if lhs.hasRubyPackage_p != rhs.hasRubyPackage_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.HashVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".HashVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "HashVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSemantic: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSemantic" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasSemantic\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23434,31 +27721,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.HashVisitor: // 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.hashVisitor) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasSemantic_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hashVisitor != 0 { - try visitor.visitSingularInt32Field(value: self.hashVisitor, fieldNumber: 1) + if self.hasSemantic_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasSemantic_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.HashVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.HashVisitor) -> Bool { - if lhs.hashVisitor != rhs.hashVisitor {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSemantic, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSemantic) -> Bool { + if lhs.hasSemantic_p != rhs.hasSemantic_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdempotencyLevel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasIdempotencyLevel" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasIdempotencyLevel"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasServerStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasServerStreaming" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasServerStreaming\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23466,31 +27751,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdempotenc // 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.hasIdempotencyLevel_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasServerStreaming_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasIdempotencyLevel_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasIdempotencyLevel_p, fieldNumber: 1) + if self.hasServerStreaming_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasServerStreaming_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdempotencyLevel, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdempotencyLevel) -> Bool { - if lhs.hasIdempotencyLevel_p != rhs.hasIdempotencyLevel_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasServerStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasServerStreaming) -> Bool { + if lhs.hasServerStreaming_p != rhs.hasServerStreaming_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdentifierValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasIdentifierValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasIdentifierValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSourceCodeInfo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasSourceCodeInfo\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23498,31 +27781,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdentifier // 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.hasIdentifierValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasSourceCodeInfo_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasIdentifierValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasIdentifierValue_p, fieldNumber: 1) + if self.hasSourceCodeInfo_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasSourceCodeInfo_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdentifierValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIdentifierValue) -> Bool { - if lhs.hasIdentifierValue_p != rhs.hasIdentifierValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceCodeInfo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceCodeInfo) -> Bool { + if lhs.hasSourceCodeInfo_p != rhs.hasSourceCodeInfo_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasInputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasInputType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasInputType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceContext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSourceContext" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasSourceContext\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23530,31 +27811,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasInputType: // 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.hasInputType_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasSourceContext_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasInputType_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasInputType_p, fieldNumber: 1) + if self.hasSourceContext_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasSourceContext_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasInputType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasInputType) -> Bool { - if lhs.hasInputType_p != rhs.hasInputType_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceContext, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceContext) -> Bool { + if lhs.hasSourceContext_p != rhs.hasSourceContext_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIsExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasIsExtension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasIsExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceFile: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSourceFile" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasSourceFile\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23562,31 +27841,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIsExtensio // 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.hasIsExtension_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasSourceFile_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasIsExtension_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasIsExtension_p, fieldNumber: 1) + if self.hasSourceFile_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasSourceFile_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIsExtension, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasIsExtension) -> Bool { - if lhs.hasIsExtension_p != rhs.hasIsExtension_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceFile, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSourceFile) -> Bool { + if lhs.hasSourceFile_p != rhs.hasSourceFile_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGenerateEqualsAndHash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaGenerateEqualsAndHash" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasJavaGenerateEqualsAndHash"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasStart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasStart" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasStart\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23594,31 +27871,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGenera // 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.hasJavaGenerateEqualsAndHash_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasStart_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasJavaGenerateEqualsAndHash_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasJavaGenerateEqualsAndHash_p, fieldNumber: 1) + if self.hasStart_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasStart_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGenerateEqualsAndHash, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGenerateEqualsAndHash) -> Bool { - if lhs.hasJavaGenerateEqualsAndHash_p != rhs.hasJavaGenerateEqualsAndHash_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasStart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasStart) -> Bool { + if lhs.hasStart_p != rhs.hasStart_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasJavaGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasStringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasStringValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasStringValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23626,31 +27901,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGeneri // 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.hasJavaGenericServices_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasStringValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasJavaGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasJavaGenericServices_p, fieldNumber: 1) + if self.hasStringValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasStringValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaGenericServices) -> Bool { - if lhs.hasJavaGenericServices_p != rhs.hasJavaGenericServices_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasStringValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasStringValue) -> Bool { + if lhs.hasStringValue_p != rhs.hasStringValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaMultipleFiles: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaMultipleFiles" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasJavaMultipleFiles"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSwiftPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSwiftPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasSwiftPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23658,31 +27931,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaMultip // 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.hasJavaMultipleFiles_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasSwiftPrefix_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasJavaMultipleFiles_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasJavaMultipleFiles_p, fieldNumber: 1) + if self.hasSwiftPrefix_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasSwiftPrefix_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaMultipleFiles, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaMultipleFiles) -> Bool { - if lhs.hasJavaMultipleFiles_p != rhs.hasJavaMultipleFiles_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSwiftPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSwiftPrefix) -> Bool { + if lhs.hasSwiftPrefix_p != rhs.hasSwiftPrefix_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaOuterClassname: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaOuterClassname" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasJavaOuterClassname"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSyntax: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSyntax" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasSyntax\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23690,31 +27961,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaOuterC // 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.hasJavaOuterClassname_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasSyntax_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasJavaOuterClassname_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasJavaOuterClassname_p, fieldNumber: 1) + if self.hasSyntax_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasSyntax_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaOuterClassname, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaOuterClassname) -> Bool { - if lhs.hasJavaOuterClassname_p != rhs.hasJavaOuterClassname_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSyntax, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasSyntax) -> Bool { + if lhs.hasSyntax_p != rhs.hasSyntax_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasJavaPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasTrailingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasTrailingComments" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasTrailingComments\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23722,31 +27991,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaPackag // 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.hasJavaPackage_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasTrailingComments_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasJavaPackage_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasJavaPackage_p, fieldNumber: 1) + if self.hasTrailingComments_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasTrailingComments_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaPackage) -> Bool { - if lhs.hasJavaPackage_p != rhs.hasJavaPackage_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasTrailingComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasTrailingComments) -> Bool { + if lhs.hasTrailingComments_p != rhs.hasTrailingComments_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaStringCheckUtf8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJavaStringCheckUtf8" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasJavaStringCheckUtf8"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23754,31 +28021,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaString // 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.hasJavaStringCheckUtf8_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasType_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasJavaStringCheckUtf8_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasJavaStringCheckUtf8_p, fieldNumber: 1) + if self.hasType_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasType_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaStringCheckUtf8, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJavaStringCheckUtf8) -> Bool { - if lhs.hasJavaStringCheckUtf8_p != rhs.hasJavaStringCheckUtf8_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasType) -> Bool { + if lhs.hasType_p != rhs.hasType_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJsonName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJsonName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasJsonName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasTypeName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasTypeName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasTypeName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23786,31 +28051,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJsonName: // 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.hasJsonName_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasTypeName_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasJsonName_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasJsonName_p, fieldNumber: 1) + if self.hasTypeName_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasTypeName_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJsonName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJsonName) -> Bool { - if lhs.hasJsonName_p != rhs.hasJsonName_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasTypeName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasTypeName) -> Bool { + if lhs.hasTypeName_p != rhs.hasTypeName_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJstype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasJstype" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasJstype"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasUnverifiedLazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasUnverifiedLazy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasUnverifiedLazy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23818,31 +28081,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJstype: Sw // 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.hasJstype_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasUnverifiedLazy_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasJstype_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasJstype_p, fieldNumber: 1) + if self.hasUnverifiedLazy_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasUnverifiedLazy_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJstype, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasJstype) -> Bool { - if lhs.hasJstype_p != rhs.hasJstype_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasUnverifiedLazy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasUnverifiedLazy) -> Bool { + if lhs.hasUnverifiedLazy_p != rhs.hasUnverifiedLazy_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLabel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasLabel" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasLabel"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasUtf8Validation: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasUtf8Validation" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasUtf8Validation\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23850,31 +28111,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLabel: Swi // 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.hasLabel_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasUtf8Validation_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasLabel_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasLabel_p, fieldNumber: 1) + if self.hasUtf8Validation_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasUtf8Validation_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLabel, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLabel) -> Bool { - if lhs.hasLabel_p != rhs.hasLabel_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasUtf8Validation, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasUtf8Validation) -> Bool { + if lhs.hasUtf8Validation_p != rhs.hasUtf8Validation_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasLazy" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasLazy"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23882,31 +28141,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLazy: Swif // 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.hasLazy_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasValue_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasLazy_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasLazy_p, fieldNumber: 1) + if self.hasValue_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasValue_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLazy, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLazy) -> Bool { - if lhs.hasLazy_p != rhs.hasLazy_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasValue) -> Bool { + if lhs.hasValue_p != rhs.hasValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLeadingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasLeadingComments" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasLeadingComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasVerification: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasVerification" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasVerification\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23914,31 +28171,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLeadingCom // 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.hasLeadingComments_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasVerification_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasLeadingComments_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasLeadingComments_p, fieldNumber: 1) + if self.hasVerification_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasVerification_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLeadingComments, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasLeadingComments) -> Bool { - if lhs.hasLeadingComments_p != rhs.hasLeadingComments_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasVerification, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasVerification) -> Bool { + if lhs.hasVerification_p != rhs.hasVerification_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMapEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasMapEntry" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasMapEntry"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasVisibility: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasVisibility" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasVisibility\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23946,31 +28201,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMapEntry: // 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.hasMapEntry_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasVisibility_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasMapEntry_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasMapEntry_p, fieldNumber: 1) + if self.hasVisibility_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasVisibility_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMapEntry, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMapEntry) -> Bool { - if lhs.hasMapEntry_p != rhs.hasMapEntry_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasVisibility, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasVisibility) -> Bool { + if lhs.hasVisibility_p != rhs.hasVisibility_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMessageSetWireFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasMessageSetWireFormat" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasMessageSetWireFormat"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasWeak: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hasWeak" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hasWeak\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23978,31 +28231,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMessageSet // 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.hasMessageSetWireFormat_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hasWeak_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasMessageSetWireFormat_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasMessageSetWireFormat_p, fieldNumber: 1) + if self.hasWeak_p != 0 { + try visitor.visitSingularInt32Field(value: self.hasWeak_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMessageSetWireFormat, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasMessageSetWireFormat) -> Bool { - if lhs.hasMessageSetWireFormat_p != rhs.hasMessageSetWireFormat_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasWeak, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hasWeak) -> Bool { + if lhs.hasWeak_p != rhs.hasWeak_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hour: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".hour" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hour\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24010,31 +28261,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasName: Swif // 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.hasName_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.hour) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasName_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasName_p, fieldNumber: 1) + if self.hour != 0 { + try visitor.visitSingularInt32Field(value: self.hour, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasName) -> Bool { - if lhs.hasName_p != rhs.hasName_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hour, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.hour) -> Bool { + if lhs.hour != rhs.hour {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNamePart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasNamePart" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasNamePart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.i: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".i" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}i\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24042,31 +28291,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNamePart: // 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.hasNamePart_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.i) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasNamePart_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasNamePart_p, fieldNumber: 1) + if self.i != 0 { + try visitor.visitSingularInt32Field(value: self.i, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNamePart, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNamePart) -> Bool { - if lhs.hasNamePart_p != rhs.hasNamePart_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.i, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.i) -> Bool { + if lhs.i != rhs.i {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNegativeIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasNegativeIntValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasNegativeIntValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.idempotencyLevel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".idempotencyLevel" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}idempotencyLevel\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24074,31 +28321,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNegativeIn // 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.hasNegativeIntValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.idempotencyLevel) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasNegativeIntValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasNegativeIntValue_p, fieldNumber: 1) + if self.idempotencyLevel != 0 { + try visitor.visitSingularInt32Field(value: self.idempotencyLevel, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNegativeIntValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNegativeIntValue) -> Bool { - if lhs.hasNegativeIntValue_p != rhs.hasNegativeIntValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.idempotencyLevel, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.idempotencyLevel) -> Bool { + if lhs.idempotencyLevel != rhs.idempotencyLevel {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNoStandardDescriptorAccessor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasNoStandardDescriptorAccessor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasNoStandardDescriptorAccessor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.identifierValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".identifierValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}identifierValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24106,31 +28351,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNoStandard // 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.hasNoStandardDescriptorAccessor_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.identifierValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasNoStandardDescriptorAccessor_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasNoStandardDescriptorAccessor_p, fieldNumber: 1) + if self.identifierValue != 0 { + try visitor.visitSingularInt32Field(value: self.identifierValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNoStandardDescriptorAccessor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNoStandardDescriptorAccessor) -> Bool { - if lhs.hasNoStandardDescriptorAccessor_p != rhs.hasNoStandardDescriptorAccessor_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.identifierValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.identifierValue) -> Bool { + if lhs.identifierValue != rhs.identifierValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ifMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".if" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}if\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24138,31 +28381,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNumber: Sw // 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.hasNumber_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`if`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasNumber_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasNumber_p, fieldNumber: 1) + if self.`if` != 0 { + try visitor.visitSingularInt32Field(value: self.`if`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNumber, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasNumber) -> Bool { - if lhs.hasNumber_p != rhs.hasNumber_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ifMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ifMessage) -> Bool { + if lhs.`if` != rhs.`if` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasObjcClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasObjcClassPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasObjcClassPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ignoreUnknownExtensionFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ignoreUnknownExtensionFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ignoreUnknownExtensionFields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24170,31 +28411,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasObjcClassP // 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.hasObjcClassPrefix_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.ignoreUnknownExtensionFields) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasObjcClassPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasObjcClassPrefix_p, fieldNumber: 1) + if self.ignoreUnknownExtensionFields != 0 { + try visitor.visitSingularInt32Field(value: self.ignoreUnknownExtensionFields, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasObjcClassPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasObjcClassPrefix) -> Bool { - if lhs.hasObjcClassPrefix_p != rhs.hasObjcClassPrefix_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ignoreUnknownExtensionFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ignoreUnknownExtensionFields) -> Bool { + if lhs.ignoreUnknownExtensionFields != rhs.ignoreUnknownExtensionFields {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOneofIndex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasOneofIndex" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasOneofIndex"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ignoreUnknownFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ignoreUnknownFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ignoreUnknownFields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24202,31 +28441,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOneofIndex // 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.hasOneofIndex_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.ignoreUnknownFields) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasOneofIndex_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasOneofIndex_p, fieldNumber: 1) + if self.ignoreUnknownFields != 0 { + try visitor.visitSingularInt32Field(value: self.ignoreUnknownFields, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOneofIndex, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOneofIndex) -> Bool { - if lhs.hasOneofIndex_p != rhs.hasOneofIndex_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ignoreUnknownFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ignoreUnknownFields) -> Bool { + if lhs.ignoreUnknownFields != rhs.ignoreUnknownFields {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptimizeFor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasOptimizeFor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasOptimizeFor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.index: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".index" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}index\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24234,31 +28471,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptimizeFo // 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.hasOptimizeFor_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.index) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasOptimizeFor_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasOptimizeFor_p, fieldNumber: 1) + if self.index != 0 { + try visitor.visitSingularInt32Field(value: self.index, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptimizeFor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptimizeFor) -> Bool { - if lhs.hasOptimizeFor_p != rhs.hasOptimizeFor_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.index, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.index) -> Bool { + if lhs.index != rhs.index {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.initMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".init" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}init\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24266,31 +28501,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptions: S // 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.hasOptions_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.init_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasOptions_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasOptions_p, fieldNumber: 1) + if self.init_p != 0 { + try visitor.visitSingularInt32Field(value: self.init_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOptions) -> Bool { - if lhs.hasOptions_p != rhs.hasOptions_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.initMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.initMessage) -> Bool { + if lhs.init_p != rhs.init_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOutputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasOutputType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasOutputType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.inoutMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".inout" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}inout\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24298,31 +28531,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOutputType // 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.hasOutputType_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`inout`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasOutputType_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasOutputType_p, fieldNumber: 1) + if self.`inout` != 0 { + try visitor.visitSingularInt32Field(value: self.`inout`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOutputType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasOutputType) -> Bool { - if lhs.hasOutputType_p != rhs.hasOutputType_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.inoutMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.inoutMessage) -> Bool { + if lhs.`inout` != rhs.`inout` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.inputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".inputType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}inputType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24330,31 +28561,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPackage: S // 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.hasPackage_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.inputType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasPackage_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasPackage_p, fieldNumber: 1) + if self.inputType != 0 { + try visitor.visitSingularInt32Field(value: self.inputType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPackage) -> Bool { - if lhs.hasPackage_p != rhs.hasPackage_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.inputType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.inputType) -> Bool { + if lhs.inputType != rhs.inputType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPacked: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPacked" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasPacked"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.insert: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".insert" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}insert\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24362,31 +28591,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPacked: Sw // 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.hasPacked_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.insert) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasPacked_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasPacked_p, fieldNumber: 1) + if self.insert != 0 { + try visitor.visitSingularInt32Field(value: self.insert, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPacked, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPacked) -> Bool { - if lhs.hasPacked_p != rhs.hasPacked_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.insert, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.insert) -> Bool { + if lhs.insert != rhs.insert {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPhpClassPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasPhpClassPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Instruction: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Instruction" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Instruction\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24394,31 +28621,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpClassPr // 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.hasPhpClassPrefix_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.instruction) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasPhpClassPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasPhpClassPrefix_p, fieldNumber: 1) + if self.instruction != 0 { + try visitor.visitSingularInt32Field(value: self.instruction, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpClassPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpClassPrefix) -> Bool { - if lhs.hasPhpClassPrefix_p != rhs.hasPhpClassPrefix_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Instruction, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Instruction) -> Bool { + if lhs.instruction != rhs.instruction {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPhpGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasPhpGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.IntMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Int" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Int\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24426,31 +28651,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpGeneric // 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.hasPhpGenericServices_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.int) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasPhpGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasPhpGenericServices_p, fieldNumber: 1) + if self.int != 0 { + try visitor.visitSingularInt32Field(value: self.int, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpGenericServices) -> Bool { - if lhs.hasPhpGenericServices_p != rhs.hasPhpGenericServices_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.IntMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.IntMessage) -> Bool { + if lhs.int != rhs.int {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpMetadataNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPhpMetadataNamespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasPhpMetadataNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int32Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Int32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Int32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24458,31 +28681,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpMetadat // 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.hasPhpMetadataNamespace_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.int32) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasPhpMetadataNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasPhpMetadataNamespace_p, fieldNumber: 1) + if self.int32 != 0 { + try visitor.visitSingularInt32Field(value: self.int32, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpMetadataNamespace, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpMetadataNamespace) -> Bool { - if lhs.hasPhpMetadataNamespace_p != rhs.hasPhpMetadataNamespace_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int32Message, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int32Message) -> Bool { + if lhs.int32 != rhs.int32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPhpNamespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasPhpNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int64Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Int64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Int64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24490,31 +28711,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpNamespa // 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.hasPhpNamespace_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.int64) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasPhpNamespace_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasPhpNamespace_p, fieldNumber: 1) + if self.int64 != 0 { + try visitor.visitSingularInt32Field(value: self.int64, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpNamespace, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPhpNamespace) -> Bool { - if lhs.hasPhpNamespace_p != rhs.hasPhpNamespace_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int64Message, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int64Message) -> Bool { + if lhs.int64 != rhs.int64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPositiveIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPositiveIntValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasPositiveIntValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Int8" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Int8\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24522,31 +28741,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPositiveIn // 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.hasPositiveIntValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.int8) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasPositiveIntValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasPositiveIntValue_p, fieldNumber: 1) + if self.int8 != 0 { + try visitor.visitSingularInt32Field(value: self.int8, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPositiveIntValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPositiveIntValue) -> Bool { - if lhs.hasPositiveIntValue_p != rhs.hasPositiveIntValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int8, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Int8) -> Bool { + if lhs.int8 != rhs.int8 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasProto3Optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasProto3Optional" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasProto3Optional"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.integerLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".integerLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}integerLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24554,31 +28771,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasProto3Opti // 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.hasProto3Optional_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.integerLiteral) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasProto3Optional_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasProto3Optional_p, fieldNumber: 1) + if self.integerLiteral != 0 { + try visitor.visitSingularInt32Field(value: self.integerLiteral, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasProto3Optional, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasProto3Optional) -> Bool { - if lhs.hasProto3Optional_p != rhs.hasProto3Optional_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.integerLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.integerLiteral) -> Bool { + if lhs.integerLiteral != rhs.integerLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPyGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasPyGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasPyGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.IntegerLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".IntegerLiteralType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}IntegerLiteralType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24586,31 +28801,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPyGenericS // 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.hasPyGenericServices_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.integerLiteralType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasPyGenericServices_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasPyGenericServices_p, fieldNumber: 1) + if self.integerLiteralType != 0 { + try visitor.visitSingularInt32Field(value: self.integerLiteralType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPyGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasPyGenericServices) -> Bool { - if lhs.hasPyGenericServices_p != rhs.hasPyGenericServices_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.IntegerLiteralType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.IntegerLiteralType) -> Bool { + if lhs.integerLiteralType != rhs.integerLiteralType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasRubyPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasRubyPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasRubyPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.intern: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".intern" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}intern\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24618,31 +28831,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasRubyPackag // 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.hasRubyPackage_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.intern) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasRubyPackage_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasRubyPackage_p, fieldNumber: 1) + if self.intern != 0 { + try visitor.visitSingularInt32Field(value: self.intern, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasRubyPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasRubyPackage) -> Bool { - if lhs.hasRubyPackage_p != rhs.hasRubyPackage_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.intern, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.intern) -> Bool { + if lhs.intern != rhs.intern {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasServerStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasServerStreaming" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasServerStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Internal: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Internal" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Internal\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24650,31 +28861,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasServerStre // 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.hasServerStreaming_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`internal`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasServerStreaming_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasServerStreaming_p, fieldNumber: 1) + if self.`internal` != 0 { + try visitor.visitSingularInt32Field(value: self.`internal`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasServerStreaming, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasServerStreaming) -> Bool { - if lhs.hasServerStreaming_p != rhs.hasServerStreaming_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Internal, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Internal) -> Bool { + if lhs.`internal` != rhs.`internal` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSourceCodeInfo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasSourceCodeInfo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.InternalState: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".InternalState" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}InternalState\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24682,31 +28891,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceCode // 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.hasSourceCodeInfo_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.internalState) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasSourceCodeInfo_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasSourceCodeInfo_p, fieldNumber: 1) + if self.internalState != 0 { + try visitor.visitSingularInt32Field(value: self.internalState, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceCodeInfo, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceCodeInfo) -> Bool { - if lhs.hasSourceCodeInfo_p != rhs.hasSourceCodeInfo_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.InternalState, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.InternalState) -> Bool { + if lhs.internalState != rhs.internalState {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceContext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSourceContext" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasSourceContext"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.intersect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".intersect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}intersect\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24714,31 +28921,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceCont // 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.hasSourceContext_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.intersect) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasSourceContext_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasSourceContext_p, fieldNumber: 1) + if self.intersect != 0 { + try visitor.visitSingularInt32Field(value: self.intersect, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceContext, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceContext) -> Bool { - if lhs.hasSourceContext_p != rhs.hasSourceContext_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.intersect, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.intersect) -> Bool { + if lhs.intersect != rhs.intersect {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceFile: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSourceFile" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasSourceFile"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.into: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".into" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}into\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24746,31 +28951,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceFile // 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.hasSourceFile_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.into) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasSourceFile_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasSourceFile_p, fieldNumber: 1) + if self.into != 0 { + try visitor.visitSingularInt32Field(value: self.into, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceFile, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSourceFile) -> Bool { - if lhs.hasSourceFile_p != rhs.hasSourceFile_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.into, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.into) -> Bool { + if lhs.into != rhs.into {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasStart" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasStart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ints: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ints" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ints\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24778,31 +28981,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStart: Swi // 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.hasStart_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.ints) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasStart_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasStart_p, fieldNumber: 1) + if self.ints != 0 { + try visitor.visitSingularInt32Field(value: self.ints, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStart, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStart) -> Bool { - if lhs.hasStart_p != rhs.hasStart_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ints, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ints) -> Bool { + if lhs.ints != rhs.ints {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasStringValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasStringValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.invalidAnyTypeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".invalidAnyTypeURL" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}invalidAnyTypeURL\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24810,31 +29011,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStringValu // 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.hasStringValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.invalidAnyTypeURL) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasStringValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasStringValue_p, fieldNumber: 1) + if self.invalidAnyTypeURL != 0 { + try visitor.visitSingularInt32Field(value: self.invalidAnyTypeURL, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStringValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasStringValue) -> Bool { - if lhs.hasStringValue_p != rhs.hasStringValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.invalidAnyTypeURL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.invalidAnyTypeURL) -> Bool { + if lhs.invalidAnyTypeURL != rhs.invalidAnyTypeURL {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSwiftPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSwiftPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasSwiftPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isA: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isA" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isA\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24842,31 +29041,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSwiftPrefi // 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.hasSwiftPrefix_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.isA) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasSwiftPrefix_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasSwiftPrefix_p, fieldNumber: 1) + if self.isA != 0 { + try visitor.visitSingularInt32Field(value: self.isA, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSwiftPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSwiftPrefix) -> Bool { - if lhs.hasSwiftPrefix_p != rhs.hasSwiftPrefix_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isA, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isA) -> Bool { + if lhs.isA != rhs.isA {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSyntax: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasSyntax" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasSyntax"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isEqual: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isEqual" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isEqual\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24874,31 +29071,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSyntax: Sw // 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.hasSyntax_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.isEqual) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasSyntax_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasSyntax_p, fieldNumber: 1) + if self.isEqual != 0 { + try visitor.visitSingularInt32Field(value: self.isEqual, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSyntax, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasSyntax) -> Bool { - if lhs.hasSyntax_p != rhs.hasSyntax_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isEqual, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isEqual) -> Bool { + if lhs.isEqual != rhs.isEqual {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTrailingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasTrailingComments" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasTrailingComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isEqualTo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isEqualTo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isEqualTo\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24906,31 +29101,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTrailingCo // 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.hasTrailingComments_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.isEqualTo) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasTrailingComments_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasTrailingComments_p, fieldNumber: 1) + if self.isEqualTo != 0 { + try visitor.visitSingularInt32Field(value: self.isEqualTo, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTrailingComments, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTrailingComments) -> Bool { - if lhs.hasTrailingComments_p != rhs.hasTrailingComments_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isEqualTo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isEqualTo) -> Bool { + if lhs.isEqualTo != rhs.isEqualTo {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isExtension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24938,31 +29131,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasType: Swif // 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.hasType_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.isExtension) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasType_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasType_p, fieldNumber: 1) + if self.isExtension != 0 { + try visitor.visitSingularInt32Field(value: self.isExtension, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasType) -> Bool { - if lhs.hasType_p != rhs.hasType_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isExtension) -> Bool { + if lhs.isExtension != rhs.isExtension {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTypeName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasTypeName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasTypeName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isInitializedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isInitialized" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isInitialized\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24970,31 +29161,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTypeName: // 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.hasTypeName_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.isInitialized_p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasTypeName_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasTypeName_p, fieldNumber: 1) + if self.isInitialized_p != 0 { + try visitor.visitSingularInt32Field(value: self.isInitialized_p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTypeName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasTypeName) -> Bool { - if lhs.hasTypeName_p != rhs.hasTypeName_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isInitializedMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isInitializedMessage) -> Bool { + if lhs.isInitialized_p != rhs.isInitialized_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isNegative: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isNegative" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isNegative\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25002,31 +29191,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasValue: Swi // 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.hasValue_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.isNegative) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasValue_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasValue_p, fieldNumber: 1) + if self.isNegative != 0 { + try visitor.visitSingularInt32Field(value: self.isNegative, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasValue) -> Bool { - if lhs.hasValue_p != rhs.hasValue_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isNegative, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isNegative) -> Bool { + if lhs.isNegative != rhs.isNegative {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasWeak: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hasWeak" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hasWeak"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isPathValid: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isPathValid" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isPathValid\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25034,31 +29221,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasWeak: Swif // 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.hasWeak_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.isPathValid) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hasWeak_p != 0 { - try visitor.visitSingularInt32Field(value: self.hasWeak_p, fieldNumber: 1) + if self.isPathValid != 0 { + try visitor.visitSingularInt32Field(value: self.isPathValid, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasWeak, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hasWeak) -> Bool { - if lhs.hasWeak_p != rhs.hasWeak_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isPathValid, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isPathValid) -> Bool { + if lhs.isPathValid != rhs.isPathValid {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hour: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".hour" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hour"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isReserved: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isReserved" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isReserved\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25066,31 +29251,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hour: SwiftPr // 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.hour) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.isReserved) }() default: break } } } func traverse(visitor: inout V) throws { - if self.hour != 0 { - try visitor.visitSingularInt32Field(value: self.hour, fieldNumber: 1) + if self.isReserved != 0 { + try visitor.visitSingularInt32Field(value: self.isReserved, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hour, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.hour) -> Bool { - if lhs.hour != rhs.hour {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isReserved, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isReserved) -> Bool { + if lhs.isReserved != rhs.isReserved {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".i" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "i"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isValid: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".isValid" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isValid\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25098,31 +29281,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i: SwiftProto // 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.i) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.isValid) }() default: break } } } func traverse(visitor: inout V) throws { - if self.i != 0 { - try visitor.visitSingularInt32Field(value: self.i, fieldNumber: 1) + if self.isValid != 0 { + try visitor.visitSingularInt32Field(value: self.isValid, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i) -> Bool { - if lhs.i != rhs.i {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isValid, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.isValid) -> Bool { + if lhs.isValid != rhs.isValid {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.idempotencyLevel: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".idempotencyLevel" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "idempotencyLevel"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.itemTagsEncodedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".itemTagsEncodedSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}itemTagsEncodedSize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25130,31 +29311,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.idempotencyLe // 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.idempotencyLevel) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.itemTagsEncodedSize) }() default: break } } } func traverse(visitor: inout V) throws { - if self.idempotencyLevel != 0 { - try visitor.visitSingularInt32Field(value: self.idempotencyLevel, fieldNumber: 1) + if self.itemTagsEncodedSize != 0 { + try visitor.visitSingularInt32Field(value: self.itemTagsEncodedSize, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.idempotencyLevel, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.idempotencyLevel) -> Bool { - if lhs.idempotencyLevel != rhs.idempotencyLevel {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.itemTagsEncodedSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.itemTagsEncodedSize) -> Bool { + if lhs.itemTagsEncodedSize != rhs.itemTagsEncodedSize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.identifierValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".identifierValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "identifierValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.iterator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".iterator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}iterator\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25162,31 +29341,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.identifierVal // 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.identifierValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.iterator) }() default: break } } } func traverse(visitor: inout V) throws { - if self.identifierValue != 0 { - try visitor.visitSingularInt32Field(value: self.identifierValue, fieldNumber: 1) + if self.iterator != 0 { + try visitor.visitSingularInt32Field(value: self.iterator, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.identifierValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.identifierValue) -> Bool { - if lhs.identifierValue != rhs.identifierValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.iterator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.iterator) -> Bool { + if lhs.iterator != rhs.iterator {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ifMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".if" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "if"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaGenerateEqualsAndHash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".javaGenerateEqualsAndHash" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}javaGenerateEqualsAndHash\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25194,31 +29371,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ifMessage: Sw // 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.`if`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.javaGenerateEqualsAndHash) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`if` != 0 { - try visitor.visitSingularInt32Field(value: self.`if`, fieldNumber: 1) + if self.javaGenerateEqualsAndHash != 0 { + try visitor.visitSingularInt32Field(value: self.javaGenerateEqualsAndHash, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ifMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ifMessage) -> Bool { - if lhs.`if` != rhs.`if` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaGenerateEqualsAndHash, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaGenerateEqualsAndHash) -> Bool { + if lhs.javaGenerateEqualsAndHash != rhs.javaGenerateEqualsAndHash {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ignoreUnknownFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ignoreUnknownFields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ignoreUnknownFields"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".javaGenericServices" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}javaGenericServices\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25226,31 +29401,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ignoreUnknown // 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.ignoreUnknownFields) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.javaGenericServices) }() default: break } } } func traverse(visitor: inout V) throws { - if self.ignoreUnknownFields != 0 { - try visitor.visitSingularInt32Field(value: self.ignoreUnknownFields, fieldNumber: 1) + if self.javaGenericServices != 0 { + try visitor.visitSingularInt32Field(value: self.javaGenericServices, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ignoreUnknownFields, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ignoreUnknownFields) -> Bool { - if lhs.ignoreUnknownFields != rhs.ignoreUnknownFields {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaGenericServices) -> Bool { + if lhs.javaGenericServices != rhs.javaGenericServices {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.index: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".index" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "index"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaMultipleFiles: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".javaMultipleFiles" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}javaMultipleFiles\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25258,31 +29431,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.index: SwiftP // 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.index) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.javaMultipleFiles) }() default: break } } } func traverse(visitor: inout V) throws { - if self.index != 0 { - try visitor.visitSingularInt32Field(value: self.index, fieldNumber: 1) + if self.javaMultipleFiles != 0 { + try visitor.visitSingularInt32Field(value: self.javaMultipleFiles, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.index, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.index) -> Bool { - if lhs.index != rhs.index {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaMultipleFiles, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaMultipleFiles) -> Bool { + if lhs.javaMultipleFiles != rhs.javaMultipleFiles {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.initMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".init" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "init"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaOuterClassname: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".javaOuterClassname" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}javaOuterClassname\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25290,31 +29461,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.initMessage: // 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.init_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.javaOuterClassname) }() default: break } } } func traverse(visitor: inout V) throws { - if self.init_p != 0 { - try visitor.visitSingularInt32Field(value: self.init_p, fieldNumber: 1) + if self.javaOuterClassname != 0 { + try visitor.visitSingularInt32Field(value: self.javaOuterClassname, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.initMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.initMessage) -> Bool { - if lhs.init_p != rhs.init_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaOuterClassname, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaOuterClassname) -> Bool { + if lhs.javaOuterClassname != rhs.javaOuterClassname {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inoutMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".inout" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "inout"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".javaPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}javaPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25322,31 +29491,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inoutMessage: // 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.`inout`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.javaPackage) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`inout` != 0 { - try visitor.visitSingularInt32Field(value: self.`inout`, fieldNumber: 1) + if self.javaPackage != 0 { + try visitor.visitSingularInt32Field(value: self.javaPackage, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inoutMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inoutMessage) -> Bool { - if lhs.`inout` != rhs.`inout` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaPackage) -> Bool { + if lhs.javaPackage != rhs.javaPackage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".inputType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "inputType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaStringCheckUtf8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".javaStringCheckUtf8" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}javaStringCheckUtf8\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25354,31 +29521,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inputType: Sw // 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.inputType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.javaStringCheckUtf8) }() default: break } } } func traverse(visitor: inout V) throws { - if self.inputType != 0 { - try visitor.visitSingularInt32Field(value: self.inputType, fieldNumber: 1) + if self.javaStringCheckUtf8 != 0 { + try visitor.visitSingularInt32Field(value: self.javaStringCheckUtf8, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inputType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.inputType) -> Bool { - if lhs.inputType != rhs.inputType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaStringCheckUtf8, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.javaStringCheckUtf8) -> Bool { + if lhs.javaStringCheckUtf8 != rhs.javaStringCheckUtf8 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.insert: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".insert" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "insert"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONDecoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONDecoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25386,31 +29551,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.insert: Swift // 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.insert) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsondecoder) }() default: break } } } func traverse(visitor: inout V) throws { - if self.insert != 0 { - try visitor.visitSingularInt32Field(value: self.insert, fieldNumber: 1) + if self.jsondecoder != 0 { + try visitor.visitSingularInt32Field(value: self.jsondecoder, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.insert, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.insert) -> Bool { - if lhs.insert != rhs.insert {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecoder) -> Bool { + if lhs.jsondecoder != rhs.jsondecoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Int" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Int"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONDecoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONDecoding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25418,31 +29581,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntMessage: S // 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.int) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsondecoding) }() default: break } } } func traverse(visitor: inout V) throws { - if self.int != 0 { - try visitor.visitSingularInt32Field(value: self.int, fieldNumber: 1) + if self.jsondecoding != 0 { + try visitor.visitSingularInt32Field(value: self.jsondecoding, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntMessage) -> Bool { - if lhs.int != rhs.int {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecoding) -> Bool { + if lhs.jsondecoding != rhs.jsondecoding {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Int32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Int32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONDecodingError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONDecodingError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25450,31 +29611,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Message: // 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.int32) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsondecodingError) }() default: break } } } func traverse(visitor: inout V) throws { - if self.int32 != 0 { - try visitor.visitSingularInt32Field(value: self.int32, fieldNumber: 1) + if self.jsondecodingError != 0 { + try visitor.visitSingularInt32Field(value: self.jsondecodingError, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Message, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Message) -> Bool { - if lhs.int32 != rhs.int32 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecodingError) -> Bool { + if lhs.jsondecodingError != rhs.jsondecodingError {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Int32Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Int32Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONDecodingOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONDecodingOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25482,31 +29641,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Value: S // 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.int32Value) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsondecodingOptions) }() default: break } } } func traverse(visitor: inout V) throws { - if self.int32Value != 0 { - try visitor.visitSingularInt32Field(value: self.int32Value, fieldNumber: 1) + if self.jsondecodingOptions != 0 { + try visitor.visitSingularInt32Field(value: self.jsondecodingOptions, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int32Value) -> Bool { - if lhs.int32Value != rhs.int32Value {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecodingOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONDecodingOptions) -> Bool { + if lhs.jsondecodingOptions != rhs.jsondecodingOptions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Int64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Int64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonEncoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonEncoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonEncoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25514,31 +29671,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Message: // 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.int64) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonEncoder) }() default: break } } } func traverse(visitor: inout V) throws { - if self.int64 != 0 { - try visitor.visitSingularInt32Field(value: self.int64, fieldNumber: 1) + if self.jsonEncoder != 0 { + try visitor.visitSingularInt32Field(value: self.jsonEncoder, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Message, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Message) -> Bool { - if lhs.int64 != rhs.int64 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonEncoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonEncoder) -> Bool { + if lhs.jsonEncoder != rhs.jsonEncoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Int64Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Int64Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONEncoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONEncoding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25546,31 +29701,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Value: S // 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.int64Value) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonencoding) }() default: break } } } func traverse(visitor: inout V) throws { - if self.int64Value != 0 { - try visitor.visitSingularInt32Field(value: self.int64Value, fieldNumber: 1) + if self.jsonencoding != 0 { + try visitor.visitSingularInt32Field(value: self.jsonencoding, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int64Value) -> Bool { - if lhs.int64Value != rhs.int64Value {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncoding) -> Bool { + if lhs.jsonencoding != rhs.jsonencoding {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Int8" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Int8"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONEncodingError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONEncodingError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25578,31 +29731,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int8: SwiftPr // 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.int8) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonencodingError) }() default: break } } } func traverse(visitor: inout V) throws { - if self.int8 != 0 { - try visitor.visitSingularInt32Field(value: self.int8, fieldNumber: 1) + if self.jsonencodingError != 0 { + try visitor.visitSingularInt32Field(value: self.jsonencodingError, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int8, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Int8) -> Bool { - if lhs.int8 != rhs.int8 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingError) -> Bool { + if lhs.jsonencodingError != rhs.jsonencodingError {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.integerLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".integerLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "integerLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONEncodingOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONEncodingOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25610,31 +29761,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.integerLitera // 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.integerLiteral) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonencodingOptions) }() default: break } } } func traverse(visitor: inout V) throws { - if self.integerLiteral != 0 { - try visitor.visitSingularInt32Field(value: self.integerLiteral, fieldNumber: 1) + if self.jsonencodingOptions != 0 { + try visitor.visitSingularInt32Field(value: self.jsonencodingOptions, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.integerLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.integerLiteral) -> Bool { - if lhs.integerLiteral != rhs.integerLiteral {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingOptions) -> Bool { + if lhs.jsonencodingOptions != rhs.jsonencodingOptions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntegerLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".IntegerLiteralType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "IntegerLiteralType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONEncodingVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONEncodingVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25642,31 +29791,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntegerLitera // 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.integerLiteralType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonencodingVisitor) }() default: break } } } func traverse(visitor: inout V) throws { - if self.integerLiteralType != 0 { - try visitor.visitSingularInt32Field(value: self.integerLiteralType, fieldNumber: 1) + if self.jsonencodingVisitor != 0 { + try visitor.visitSingularInt32Field(value: self.jsonencodingVisitor, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntegerLiteralType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.IntegerLiteralType) -> Bool { - if lhs.integerLiteralType != rhs.integerLiteralType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONEncodingVisitor) -> Bool { + if lhs.jsonencodingVisitor != rhs.jsonencodingVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.intern: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".intern" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "intern"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonFormat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25674,31 +29821,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.intern: Swift // 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.intern) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonFormat) }() default: break } } } func traverse(visitor: inout V) throws { - if self.intern != 0 { - try visitor.visitSingularInt32Field(value: self.intern, fieldNumber: 1) + if self.jsonFormat != 0 { + try visitor.visitSingularInt32Field(value: self.jsonFormat, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.intern, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.intern) -> Bool { - if lhs.intern != rhs.intern {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonFormat) -> Bool { + if lhs.jsonFormat != rhs.jsonFormat {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Internal: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Internal" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Internal"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONMapEncodingVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONMapEncodingVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONMapEncodingVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25706,31 +29851,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Internal: Swi // 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.`internal`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonmapEncodingVisitor) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`internal` != 0 { - try visitor.visitSingularInt32Field(value: self.`internal`, fieldNumber: 1) + if self.jsonmapEncodingVisitor != 0 { + try visitor.visitSingularInt32Field(value: self.jsonmapEncodingVisitor, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Internal, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Internal) -> Bool { - if lhs.`internal` != rhs.`internal` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONMapEncodingVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONMapEncodingVisitor) -> Bool { + if lhs.jsonmapEncodingVisitor != rhs.jsonmapEncodingVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.InternalState: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".InternalState" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "InternalState"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25738,31 +29881,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.InternalState // 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.internalState) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonName) }() default: break } } } func traverse(visitor: inout V) throws { - if self.internalState != 0 { - try visitor.visitSingularInt32Field(value: self.internalState, fieldNumber: 1) + if self.jsonName != 0 { + try visitor.visitSingularInt32Field(value: self.jsonName, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.InternalState, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.InternalState) -> Bool { - if lhs.internalState != rhs.internalState {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonName) -> Bool { + if lhs.jsonName != rhs.jsonName {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.into: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".into" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "into"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonPath: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonPath" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonPath\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25770,31 +29911,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.into: SwiftPr // 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.into) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonPath) }() default: break } } } func traverse(visitor: inout V) throws { - if self.into != 0 { - try visitor.visitSingularInt32Field(value: self.into, fieldNumber: 1) + if self.jsonPath != 0 { + try visitor.visitSingularInt32Field(value: self.jsonPath, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.into, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.into) -> Bool { - if lhs.into != rhs.into {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonPath, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonPath) -> Bool { + if lhs.jsonPath != rhs.jsonPath {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ints: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ints" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ints"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonPaths: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonPaths" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonPaths\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25802,31 +29941,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ints: SwiftPr // 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.ints) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonPaths) }() default: break } } } func traverse(visitor: inout V) throws { - if self.ints != 0 { - try visitor.visitSingularInt32Field(value: self.ints, fieldNumber: 1) + if self.jsonPaths != 0 { + try visitor.visitSingularInt32Field(value: self.jsonPaths, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ints, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ints) -> Bool { - if lhs.ints != rhs.ints {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonPaths, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonPaths) -> Bool { + if lhs.jsonPaths != rhs.jsonPaths {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isA: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".isA" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "isA"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONScanner: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONScanner" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}JSONScanner\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25834,31 +29971,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isA: SwiftPro // 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.isA) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonscanner) }() default: break } } } func traverse(visitor: inout V) throws { - if self.isA != 0 { - try visitor.visitSingularInt32Field(value: self.isA, fieldNumber: 1) + if self.jsonscanner != 0 { + try visitor.visitSingularInt32Field(value: self.jsonscanner, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isA, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isA) -> Bool { - if lhs.isA != rhs.isA {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONScanner, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.JSONScanner) -> Bool { + if lhs.jsonscanner != rhs.jsonscanner {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqual: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".isEqual" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "isEqual"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonString\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25866,31 +30001,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqual: Swif // 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.isEqual) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonString) }() default: break } } } func traverse(visitor: inout V) throws { - if self.isEqual != 0 { - try visitor.visitSingularInt32Field(value: self.isEqual, fieldNumber: 1) + if self.jsonString != 0 { + try visitor.visitSingularInt32Field(value: self.jsonString, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqual, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqual) -> Bool { - if lhs.isEqual != rhs.isEqual {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonString) -> Bool { + if lhs.jsonString != rhs.jsonString {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqualTo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".isEqualTo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "isEqualTo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonText: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonText" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonText\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25898,31 +30031,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqualTo: Sw // 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.isEqualTo) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonText) }() default: break } } } func traverse(visitor: inout V) throws { - if self.isEqualTo != 0 { - try visitor.visitSingularInt32Field(value: self.isEqualTo, fieldNumber: 1) + if self.jsonText != 0 { + try visitor.visitSingularInt32Field(value: self.jsonText, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqualTo, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isEqualTo) -> Bool { - if lhs.isEqualTo != rhs.isEqualTo {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonText, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonText) -> Bool { + if lhs.jsonText != rhs.jsonText {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".isExtension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "isExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonUTF8Bytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonUTF8Bytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonUTF8Bytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25930,31 +30061,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isExtension: // 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.isExtension) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonUtf8Bytes) }() default: break } } } func traverse(visitor: inout V) throws { - if self.isExtension != 0 { - try visitor.visitSingularInt32Field(value: self.isExtension, fieldNumber: 1) + if self.jsonUtf8Bytes != 0 { + try visitor.visitSingularInt32Field(value: self.jsonUtf8Bytes, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isExtension, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isExtension) -> Bool { - if lhs.isExtension != rhs.isExtension {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonUTF8Bytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonUTF8Bytes) -> Bool { + if lhs.jsonUtf8Bytes != rhs.jsonUtf8Bytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isInitializedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".isInitialized" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "isInitialized"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonUTF8Data: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonUTF8Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonUTF8Data\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25962,31 +30091,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isInitialized // 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.isInitialized_p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jsonUtf8Data) }() default: break } } } func traverse(visitor: inout V) throws { - if self.isInitialized_p != 0 { - try visitor.visitSingularInt32Field(value: self.isInitialized_p, fieldNumber: 1) + if self.jsonUtf8Data != 0 { + try visitor.visitSingularInt32Field(value: self.jsonUtf8Data, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isInitializedMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.isInitializedMessage) -> Bool { - if lhs.isInitialized_p != rhs.isInitialized_p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonUTF8Data, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jsonUTF8Data) -> Bool { + if lhs.jsonUtf8Data != rhs.jsonUtf8Data {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.itemTagsEncodedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".itemTagsEncodedSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "itemTagsEncodedSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jstype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".jstype" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jstype\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25994,31 +30121,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.itemTagsEncod // 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.itemTagsEncodedSize) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.jstype) }() default: break } } } func traverse(visitor: inout V) throws { - if self.itemTagsEncodedSize != 0 { - try visitor.visitSingularInt32Field(value: self.itemTagsEncodedSize, fieldNumber: 1) + if self.jstype != 0 { + try visitor.visitSingularInt32Field(value: self.jstype, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.itemTagsEncodedSize, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.itemTagsEncodedSize) -> Bool { - if lhs.itemTagsEncodedSize != rhs.itemTagsEncodedSize {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jstype, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.jstype) -> Bool { + if lhs.jstype != rhs.jstype {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Iterator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Iterator" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Iterator"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.k: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".k" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}k\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26026,31 +30151,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Iterator: Swi // 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.iterator) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.k) }() default: break } } } func traverse(visitor: inout V) throws { - if self.iterator != 0 { - try visitor.visitSingularInt32Field(value: self.iterator, fieldNumber: 1) + if self.k != 0 { + try visitor.visitSingularInt32Field(value: self.k, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Iterator, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Iterator) -> Bool { - if lhs.iterator != rhs.iterator {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.k, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.k) -> Bool { + if lhs.k != rhs.k {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i_2166136261: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".i_2166136261" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "i_2166136261"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.kChunkSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".kChunkSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}kChunkSize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26058,31 +30181,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i_2166136261: // 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.i2166136261) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.kChunkSize) }() default: break } } } func traverse(visitor: inout V) throws { - if self.i2166136261 != 0 { - try visitor.visitSingularInt32Field(value: self.i2166136261, fieldNumber: 1) + if self.kChunkSize != 0 { + try visitor.visitSingularInt32Field(value: self.kChunkSize, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i_2166136261, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.i_2166136261) -> Bool { - if lhs.i2166136261 != rhs.i2166136261 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.kChunkSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.kChunkSize) -> Bool { + if lhs.kChunkSize != rhs.kChunkSize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenerateEqualsAndHash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".javaGenerateEqualsAndHash" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "javaGenerateEqualsAndHash"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Key: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Key" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Key\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26090,31 +30211,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenerateE // 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.javaGenerateEqualsAndHash) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.key) }() default: break } } } func traverse(visitor: inout V) throws { - if self.javaGenerateEqualsAndHash != 0 { - try visitor.visitSingularInt32Field(value: self.javaGenerateEqualsAndHash, fieldNumber: 1) + if self.key != 0 { + try visitor.visitSingularInt32Field(value: self.key, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenerateEqualsAndHash, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenerateEqualsAndHash) -> Bool { - if lhs.javaGenerateEqualsAndHash != rhs.javaGenerateEqualsAndHash {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Key, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Key) -> Bool { + if lhs.key != rhs.key {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".javaGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "javaGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.keyField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".keyField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}keyField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26122,31 +30241,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenericSe // 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.javaGenericServices) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.keyField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.javaGenericServices != 0 { - try visitor.visitSingularInt32Field(value: self.javaGenericServices, fieldNumber: 1) + if self.keyField != 0 { + try visitor.visitSingularInt32Field(value: self.keyField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaGenericServices) -> Bool { - if lhs.javaGenericServices != rhs.javaGenericServices {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.keyField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.keyField) -> Bool { + if lhs.keyField != rhs.keyField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaMultipleFiles: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".javaMultipleFiles" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "javaMultipleFiles"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.keyFieldOpt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".keyFieldOpt" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}keyFieldOpt\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26154,31 +30271,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaMultipleF // 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.javaMultipleFiles) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.keyFieldOpt) }() default: break } } } func traverse(visitor: inout V) throws { - if self.javaMultipleFiles != 0 { - try visitor.visitSingularInt32Field(value: self.javaMultipleFiles, fieldNumber: 1) + if self.keyFieldOpt != 0 { + try visitor.visitSingularInt32Field(value: self.keyFieldOpt, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaMultipleFiles, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaMultipleFiles) -> Bool { - if lhs.javaMultipleFiles != rhs.javaMultipleFiles {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.keyFieldOpt, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.keyFieldOpt) -> Bool { + if lhs.keyFieldOpt != rhs.keyFieldOpt {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaOuterClassname: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".javaOuterClassname" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "javaOuterClassname"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.KeyType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".KeyType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}KeyType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26186,31 +30301,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaOuterClas // 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.javaOuterClassname) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.keyType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.javaOuterClassname != 0 { - try visitor.visitSingularInt32Field(value: self.javaOuterClassname, fieldNumber: 1) + if self.keyType != 0 { + try visitor.visitSingularInt32Field(value: self.keyType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaOuterClassname, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaOuterClassname) -> Bool { - if lhs.javaOuterClassname != rhs.javaOuterClassname {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.KeyType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.KeyType) -> Bool { + if lhs.keyType != rhs.keyType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".javaPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "javaPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.kind: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".kind" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}kind\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26218,31 +30331,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaPackage: // 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.javaPackage) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.kind) }() default: break } } } func traverse(visitor: inout V) throws { - if self.javaPackage != 0 { - try visitor.visitSingularInt32Field(value: self.javaPackage, fieldNumber: 1) + if self.kind != 0 { + try visitor.visitSingularInt32Field(value: self.kind, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaPackage) -> Bool { - if lhs.javaPackage != rhs.javaPackage {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.kind, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.kind) -> Bool { + if lhs.kind != rhs.kind {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaStringCheckUtf8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".javaStringCheckUtf8" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "javaStringCheckUtf8"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.l: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".l" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}l\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26250,31 +30361,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaStringChe // 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.javaStringCheckUtf8) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.l) }() default: break } } } func traverse(visitor: inout V) throws { - if self.javaStringCheckUtf8 != 0 { - try visitor.visitSingularInt32Field(value: self.javaStringCheckUtf8, fieldNumber: 1) + if self.l != 0 { + try visitor.visitSingularInt32Field(value: self.l, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaStringCheckUtf8, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.javaStringCheckUtf8) -> Bool { - if lhs.javaStringCheckUtf8 != rhs.javaStringCheckUtf8 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.l, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.l) -> Bool { + if lhs.l != rhs.l {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONDecoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "JSONDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.label: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".label" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}label\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26282,31 +30391,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecoder: // 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.jsondecoder) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.label) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsondecoder != 0 { - try visitor.visitSingularInt32Field(value: self.jsondecoder, fieldNumber: 1) + if self.label != 0 { + try visitor.visitSingularInt32Field(value: self.label, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecoder) -> Bool { - if lhs.jsondecoder != rhs.jsondecoder {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.label, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.label) -> Bool { + if lhs.label != rhs.label {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONDecodingError" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "JSONDecodingError"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".lazy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}lazy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26314,31 +30421,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingE // 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.jsondecodingError) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.lazy) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsondecodingError != 0 { - try visitor.visitSingularInt32Field(value: self.jsondecodingError, fieldNumber: 1) + if self.lazy != 0 { + try visitor.visitSingularInt32Field(value: self.lazy, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingError, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingError) -> Bool { - if lhs.jsondecodingError != rhs.jsondecodingError {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lazy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lazy) -> Bool { + if lhs.lazy != rhs.lazy {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONDecodingOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "JSONDecodingOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.leadingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".leadingComments" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}leadingComments\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26346,31 +30451,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingO // 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.jsondecodingOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.leadingComments) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsondecodingOptions != 0 { - try visitor.visitSingularInt32Field(value: self.jsondecodingOptions, fieldNumber: 1) + if self.leadingComments != 0 { + try visitor.visitSingularInt32Field(value: self.leadingComments, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONDecodingOptions) -> Bool { - if lhs.jsondecodingOptions != rhs.jsondecodingOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.leadingComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.leadingComments) -> Bool { + if lhs.leadingComments != rhs.leadingComments {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonEncoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonEncoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jsonEncoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.leadingDetachedComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".leadingDetachedComments" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}leadingDetachedComments\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26378,31 +30481,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonEncoder: // 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.jsonEncoder) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.leadingDetachedComments) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonEncoder != 0 { - try visitor.visitSingularInt32Field(value: self.jsonEncoder, fieldNumber: 1) + if self.leadingDetachedComments != 0 { + try visitor.visitSingularInt32Field(value: self.leadingDetachedComments, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonEncoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonEncoder) -> Bool { - if lhs.jsonEncoder != rhs.jsonEncoder {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.leadingDetachedComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.leadingDetachedComments) -> Bool { + if lhs.leadingDetachedComments != rhs.leadingDetachedComments {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONEncodingError" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "JSONEncodingError"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.length: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".length" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}length\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26410,31 +30511,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingE // 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.jsonencodingError) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.length) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonencodingError != 0 { - try visitor.visitSingularInt32Field(value: self.jsonencodingError, fieldNumber: 1) + if self.length != 0 { + try visitor.visitSingularInt32Field(value: self.length, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingError, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingError) -> Bool { - if lhs.jsonencodingError != rhs.jsonencodingError {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.length, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.length) -> Bool { + if lhs.length != rhs.length {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONEncodingOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "JSONEncodingOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lessThan: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".lessThan" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}lessThan\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26442,31 +30541,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingO // 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.jsonencodingOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.lessThan) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonencodingOptions != 0 { - try visitor.visitSingularInt32Field(value: self.jsonencodingOptions, fieldNumber: 1) + if self.lessThan != 0 { + try visitor.visitSingularInt32Field(value: self.lessThan, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingOptions) -> Bool { - if lhs.jsonencodingOptions != rhs.jsonencodingOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lessThan, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lessThan) -> Bool { + if lhs.lessThan != rhs.lessThan {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONEncodingVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "JSONEncodingVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.letMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".let" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}let\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26474,31 +30571,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingV // 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.jsonencodingVisitor) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`let`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonencodingVisitor != 0 { - try visitor.visitSingularInt32Field(value: self.jsonencodingVisitor, fieldNumber: 1) + if self.`let` != 0 { + try visitor.visitSingularInt32Field(value: self.`let`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONEncodingVisitor) -> Bool { - if lhs.jsonencodingVisitor != rhs.jsonencodingVisitor {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.letMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.letMessage) -> Bool { + if lhs.`let` != rhs.`let` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONMapEncodingVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONMapEncodingVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "JSONMapEncodingVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lhs: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".lhs" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}lhs\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26506,31 +30601,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONMapEncodi // 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.jsonmapEncodingVisitor) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.lhs) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonmapEncodingVisitor != 0 { - try visitor.visitSingularInt32Field(value: self.jsonmapEncodingVisitor, fieldNumber: 1) + if self.lhs != 0 { + try visitor.visitSingularInt32Field(value: self.lhs, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONMapEncodingVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONMapEncodingVisitor) -> Bool { - if lhs.jsonmapEncodingVisitor != rhs.jsonmapEncodingVisitor {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lhs, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.lhs) -> Bool { + if lhs.lhs != rhs.lhs {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jsonName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.line: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".line" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}line\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26538,31 +30631,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonName: Swi // 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.jsonName) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.line) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonName != 0 { - try visitor.visitSingularInt32Field(value: self.jsonName, fieldNumber: 1) + if self.line != 0 { + try visitor.visitSingularInt32Field(value: self.line, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonName) -> Bool { - if lhs.jsonName != rhs.jsonName {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.line, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.line) -> Bool { + if lhs.line != rhs.line {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPath: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonPath" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jsonPath"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.list: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".list" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}list\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26570,31 +30661,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPath: Swi // 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.jsonPath) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.list) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonPath != 0 { - try visitor.visitSingularInt32Field(value: self.jsonPath, fieldNumber: 1) + if self.list != 0 { + try visitor.visitSingularInt32Field(value: self.list, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPath, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPath) -> Bool { - if lhs.jsonPath != rhs.jsonPath {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.list, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.list) -> Bool { + if lhs.list != rhs.list {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPaths: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonPaths" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jsonPaths"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.listOfMessages: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".listOfMessages" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}listOfMessages\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26602,31 +30691,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPaths: Sw // 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.jsonPaths) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.listOfMessages) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonPaths != 0 { - try visitor.visitSingularInt32Field(value: self.jsonPaths, fieldNumber: 1) + if self.listOfMessages != 0 { + try visitor.visitSingularInt32Field(value: self.listOfMessages, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPaths, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonPaths) -> Bool { - if lhs.jsonPaths != rhs.jsonPaths {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.listOfMessages, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.listOfMessages) -> Bool { + if lhs.listOfMessages != rhs.listOfMessages {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONScanner: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".JSONScanner" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "JSONScanner"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.listValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".listValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}listValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26634,31 +30721,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONScanner: // 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.jsonscanner) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.listValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonscanner != 0 { - try visitor.visitSingularInt32Field(value: self.jsonscanner, fieldNumber: 1) + if self.listValue != 0 { + try visitor.visitSingularInt32Field(value: self.listValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONScanner, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.JSONScanner) -> Bool { - if lhs.jsonscanner != rhs.jsonscanner {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.listValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.listValue) -> Bool { + if lhs.listValue != rhs.listValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonString" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jsonString"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.littleEndian: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".littleEndian" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}littleEndian\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26666,31 +30751,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonString: S // 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.jsonString) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.littleEndian) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonString != 0 { - try visitor.visitSingularInt32Field(value: self.jsonString, fieldNumber: 1) + if self.littleEndian != 0 { + try visitor.visitSingularInt32Field(value: self.littleEndian, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonString, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonString) -> Bool { - if lhs.jsonString != rhs.jsonString {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.littleEndian, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.littleEndian) -> Bool { + if lhs.littleEndian != rhs.littleEndian {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonText: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonText" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jsonText"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.load: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".load" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}load\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26698,31 +30781,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonText: Swi // 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.jsonText) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.load) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonText != 0 { - try visitor.visitSingularInt32Field(value: self.jsonText, fieldNumber: 1) + if self.load != 0 { + try visitor.visitSingularInt32Field(value: self.load, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonText, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonText) -> Bool { - if lhs.jsonText != rhs.jsonText {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.load, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.load) -> Bool { + if lhs.load != rhs.load {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonUTF8Data: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".jsonUTF8Data" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jsonUTF8Data"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.localHasher: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".localHasher" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}localHasher\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26730,31 +30811,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonUTF8Data: // 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.jsonUtf8Data) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.localHasher) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jsonUtf8Data != 0 { - try visitor.visitSingularInt32Field(value: self.jsonUtf8Data, fieldNumber: 1) + if self.localHasher != 0 { + try visitor.visitSingularInt32Field(value: self.localHasher, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonUTF8Data, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jsonUTF8Data) -> Bool { - if lhs.jsonUtf8Data != rhs.jsonUtf8Data {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.localHasher, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.localHasher) -> Bool { + if lhs.localHasher != rhs.localHasher {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jstype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".jstype" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jstype"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.location: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".location" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}location\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26762,31 +30841,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jstype: Swift // 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.jstype) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.location) }() default: break } } } func traverse(visitor: inout V) throws { - if self.jstype != 0 { - try visitor.visitSingularInt32Field(value: self.jstype, fieldNumber: 1) + if self.location != 0 { + try visitor.visitSingularInt32Field(value: self.location, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jstype, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.jstype) -> Bool { - if lhs.jstype != rhs.jstype {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.location, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.location) -> Bool { + if lhs.location != rhs.location {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.k: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".k" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "k"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.M: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".M" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}M\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26794,31 +30871,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.k: SwiftProto // 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.k) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.m) }() default: break } } } func traverse(visitor: inout V) throws { - if self.k != 0 { - try visitor.visitSingularInt32Field(value: self.k, fieldNumber: 1) + if self.m != 0 { + try visitor.visitSingularInt32Field(value: self.m, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.k, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.k) -> Bool { - if lhs.k != rhs.k {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.M, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.M) -> Bool { + if lhs.m != rhs.m {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Key: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Key" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Key"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.major: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".major" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}major\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26826,31 +30901,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Key: SwiftPro // 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.key) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.major) }() default: break } } } func traverse(visitor: inout V) throws { - if self.key != 0 { - try visitor.visitSingularInt32Field(value: self.key, fieldNumber: 1) + if self.major != 0 { + try visitor.visitSingularInt32Field(value: self.major, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Key, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Key) -> Bool { - if lhs.key != rhs.key {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.major, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.major) -> Bool { + if lhs.major != rhs.major {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.keyField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".keyField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "keyField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeAsyncIterator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".makeAsyncIterator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}makeAsyncIterator\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26858,31 +30931,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.keyField: Swi // 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.keyField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.makeAsyncIterator) }() default: break } } } func traverse(visitor: inout V) throws { - if self.keyField != 0 { - try visitor.visitSingularInt32Field(value: self.keyField, fieldNumber: 1) + if self.makeAsyncIterator != 0 { + try visitor.visitSingularInt32Field(value: self.makeAsyncIterator, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.keyField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.keyField) -> Bool { - if lhs.keyField != rhs.keyField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeAsyncIterator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeAsyncIterator) -> Bool { + if lhs.makeAsyncIterator != rhs.makeAsyncIterator {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.KeyType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".KeyType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "KeyType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeIterator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".makeIterator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}makeIterator\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26890,31 +30961,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.KeyType: Swif // 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.keyType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.makeIterator) }() default: break } } } func traverse(visitor: inout V) throws { - if self.keyType != 0 { - try visitor.visitSingularInt32Field(value: self.keyType, fieldNumber: 1) + if self.makeIterator != 0 { + try visitor.visitSingularInt32Field(value: self.makeIterator, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.KeyType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.KeyType) -> Bool { - if lhs.keyType != rhs.keyType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeIterator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.makeIterator) -> Bool { + if lhs.makeIterator != rhs.makeIterator {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.kind: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".kind" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "kind"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.malformedLength: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".malformedLength" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}malformedLength\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26922,31 +30991,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.kind: SwiftPr // 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.kind) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.malformedLength) }() default: break } } } func traverse(visitor: inout V) throws { - if self.kind != 0 { - try visitor.visitSingularInt32Field(value: self.kind, fieldNumber: 1) + if self.malformedLength != 0 { + try visitor.visitSingularInt32Field(value: self.malformedLength, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.kind, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.kind) -> Bool { - if lhs.kind != rhs.kind {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.malformedLength, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.malformedLength) -> Bool { + if lhs.malformedLength != rhs.malformedLength {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.l: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".l" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "l"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".mapEntry" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mapEntry\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26954,31 +31021,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.l: SwiftProto // 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.l) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mapEntry) }() default: break } } } func traverse(visitor: inout V) throws { - if self.l != 0 { - try visitor.visitSingularInt32Field(value: self.l, fieldNumber: 1) + if self.mapEntry != 0 { + try visitor.visitSingularInt32Field(value: self.mapEntry, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.l, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.l) -> Bool { - if lhs.l != rhs.l {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapEntry, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapEntry) -> Bool { + if lhs.mapEntry != rhs.mapEntry {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.label: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".label" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "label"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MapKeyType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".MapKeyType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}MapKeyType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26986,31 +31051,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.label: SwiftP // 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.label) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mapKeyType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.label != 0 { - try visitor.visitSingularInt32Field(value: self.label, fieldNumber: 1) + if self.mapKeyType != 0 { + try visitor.visitSingularInt32Field(value: self.mapKeyType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.label, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.label) -> Bool { - if lhs.label != rhs.label {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MapKeyType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MapKeyType) -> Bool { + if lhs.mapKeyType != rhs.mapKeyType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".lazy" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "lazy"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapToMessages: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".mapToMessages" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mapToMessages\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27018,31 +31081,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lazy: SwiftPr // 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.lazy) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mapToMessages) }() default: break } } } func traverse(visitor: inout V) throws { - if self.lazy != 0 { - try visitor.visitSingularInt32Field(value: self.lazy, fieldNumber: 1) + if self.mapToMessages != 0 { + try visitor.visitSingularInt32Field(value: self.mapToMessages, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lazy, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lazy) -> Bool { - if lhs.lazy != rhs.lazy {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapToMessages, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapToMessages) -> Bool { + if lhs.mapToMessages != rhs.mapToMessages {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".leadingComments" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "leadingComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MapValueType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".MapValueType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}MapValueType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27050,31 +31111,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingCommen // 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.leadingComments) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mapValueType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.leadingComments != 0 { - try visitor.visitSingularInt32Field(value: self.leadingComments, fieldNumber: 1) + if self.mapValueType != 0 { + try visitor.visitSingularInt32Field(value: self.mapValueType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingComments, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingComments) -> Bool { - if lhs.leadingComments != rhs.leadingComments {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MapValueType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MapValueType) -> Bool { + if lhs.mapValueType != rhs.mapValueType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingDetachedComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".leadingDetachedComments" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "leadingDetachedComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".mapVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mapVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27082,31 +31141,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingDetach // 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.leadingDetachedComments) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mapVisitor) }() default: break } } } func traverse(visitor: inout V) throws { - if self.leadingDetachedComments != 0 { - try visitor.visitSingularInt32Field(value: self.leadingDetachedComments, fieldNumber: 1) + if self.mapVisitor != 0 { + try visitor.visitSingularInt32Field(value: self.mapVisitor, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingDetachedComments, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.leadingDetachedComments) -> Bool { - if lhs.leadingDetachedComments != rhs.leadingDetachedComments {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mapVisitor) -> Bool { + if lhs.mapVisitor != rhs.mapVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.length: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".length" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "length"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mask: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".mask" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mask\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27114,31 +31171,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.length: Swift // 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.length) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mask) }() default: break } } } func traverse(visitor: inout V) throws { - if self.length != 0 { - try visitor.visitSingularInt32Field(value: self.length, fieldNumber: 1) + if self.mask != 0 { + try visitor.visitSingularInt32Field(value: self.mask, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.length, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.length) -> Bool { - if lhs.length != rhs.length {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mask, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mask) -> Bool { + if lhs.mask != rhs.mask {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lessThan: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".lessThan" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "lessThan"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.maximumEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".maximumEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}maximumEdition\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27146,31 +31201,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lessThan: Swi // 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.lessThan) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.maximumEdition) }() default: break } } } func traverse(visitor: inout V) throws { - if self.lessThan != 0 { - try visitor.visitSingularInt32Field(value: self.lessThan, fieldNumber: 1) + if self.maximumEdition != 0 { + try visitor.visitSingularInt32Field(value: self.maximumEdition, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lessThan, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lessThan) -> Bool { - if lhs.lessThan != rhs.lessThan {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.maximumEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.maximumEdition) -> Bool { + if lhs.maximumEdition != rhs.maximumEdition {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.letMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".let" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "let"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mdayStart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".mdayStart" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mdayStart\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27178,31 +31231,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.letMessage: S // 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.`let`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mdayStart) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`let` != 0 { - try visitor.visitSingularInt32Field(value: self.`let`, fieldNumber: 1) + if self.mdayStart != 0 { + try visitor.visitSingularInt32Field(value: self.mdayStart, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.letMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.letMessage) -> Bool { - if lhs.`let` != rhs.`let` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mdayStart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mdayStart) -> Bool { + if lhs.mdayStart != rhs.mdayStart {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lhs: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".lhs" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "lhs"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.merge: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".merge" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}merge\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27210,31 +31261,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lhs: SwiftPro // 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.lhs) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.merge) }() default: break } } } func traverse(visitor: inout V) throws { - if self.lhs != 0 { - try visitor.visitSingularInt32Field(value: self.lhs, fieldNumber: 1) + if self.merge != 0 { + try visitor.visitSingularInt32Field(value: self.merge, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lhs, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.lhs) -> Bool { - if lhs.lhs != rhs.lhs {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.merge, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.merge) -> Bool { + if lhs.merge != rhs.merge {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.list: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".list" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "list"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MergeOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".MergeOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}MergeOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27242,31 +31291,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.list: SwiftPr // 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.list) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mergeOptions) }() default: break } } } func traverse(visitor: inout V) throws { - if self.list != 0 { - try visitor.visitSingularInt32Field(value: self.list, fieldNumber: 1) + if self.mergeOptions != 0 { + try visitor.visitSingularInt32Field(value: self.mergeOptions, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.list, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.list) -> Bool { - if lhs.list != rhs.list {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MergeOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MergeOptions) -> Bool { + if lhs.mergeOptions != rhs.mergeOptions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listOfMessages: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".listOfMessages" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "listOfMessages"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".message" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}message\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27274,31 +31321,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listOfMessage // 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.listOfMessages) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.message) }() default: break } } } func traverse(visitor: inout V) throws { - if self.listOfMessages != 0 { - try visitor.visitSingularInt32Field(value: self.listOfMessages, fieldNumber: 1) + if self.message != 0 { + try visitor.visitSingularInt32Field(value: self.message, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listOfMessages, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listOfMessages) -> Bool { - if lhs.listOfMessages != rhs.listOfMessages {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.message, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.message) -> Bool { + if lhs.message != rhs.message {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".listValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "listValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageDepthLimit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".messageDepthLimit" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}messageDepthLimit\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27306,31 +31351,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listValue: Sw // 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.listValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.messageDepthLimit) }() default: break } } } func traverse(visitor: inout V) throws { - if self.listValue != 0 { - try visitor.visitSingularInt32Field(value: self.listValue, fieldNumber: 1) + if self.messageDepthLimit != 0 { + try visitor.visitSingularInt32Field(value: self.messageDepthLimit, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.listValue) -> Bool { - if lhs.listValue != rhs.listValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageDepthLimit, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageDepthLimit) -> Bool { + if lhs.messageDepthLimit != rhs.messageDepthLimit {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndian: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".littleEndian" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "littleEndian"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageEncoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".messageEncoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}messageEncoding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27338,31 +31381,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndian: // 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.littleEndian) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.messageEncoding) }() default: break } } } func traverse(visitor: inout V) throws { - if self.littleEndian != 0 { - try visitor.visitSingularInt32Field(value: self.littleEndian, fieldNumber: 1) + if self.messageEncoding != 0 { + try visitor.visitSingularInt32Field(value: self.messageEncoding, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndian, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndian) -> Bool { - if lhs.littleEndian != rhs.littleEndian {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageEncoding) -> Bool { + if lhs.messageEncoding != rhs.messageEncoding {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndianBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".littleEndianBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "littleEndianBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".MessageExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}MessageExtension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27370,31 +31411,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndianB // 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.littleEndianBytes) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.messageExtension) }() default: break } } } func traverse(visitor: inout V) throws { - if self.littleEndianBytes != 0 { - try visitor.visitSingularInt32Field(value: self.littleEndianBytes, fieldNumber: 1) + if self.messageExtension != 0 { + try visitor.visitSingularInt32Field(value: self.messageExtension, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndianBytes, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.littleEndianBytes) -> Bool { - if lhs.littleEndianBytes != rhs.littleEndianBytes {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageExtension) -> Bool { + if lhs.messageExtension != rhs.messageExtension {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.load: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".load" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "load"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageImplementationBase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".MessageImplementationBase" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}MessageImplementationBase\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27402,31 +31441,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.load: SwiftPr // 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.load) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.messageImplementationBase) }() default: break } } } func traverse(visitor: inout V) throws { - if self.load != 0 { - try visitor.visitSingularInt32Field(value: self.load, fieldNumber: 1) + if self.messageImplementationBase != 0 { + try visitor.visitSingularInt32Field(value: self.messageImplementationBase, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.load, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.load) -> Bool { - if lhs.load != rhs.load {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageImplementationBase, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageImplementationBase) -> Bool { + if lhs.messageImplementationBase != rhs.messageImplementationBase {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.localHasher: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".localHasher" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "localHasher"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".MessageSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}MessageSet\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27434,31 +31471,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.localHasher: // 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.localHasher) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.messageSet) }() default: break } } } func traverse(visitor: inout V) throws { - if self.localHasher != 0 { - try visitor.visitSingularInt32Field(value: self.localHasher, fieldNumber: 1) + if self.messageSet != 0 { + try visitor.visitSingularInt32Field(value: self.messageSet, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.localHasher, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.localHasher) -> Bool { - if lhs.localHasher != rhs.localHasher {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.MessageSet) -> Bool { + if lhs.messageSet != rhs.messageSet {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.location: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".location" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "location"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageSetWireFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".messageSetWireFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}messageSetWireFormat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27466,31 +31501,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.location: Swi // 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.location) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.messageSetWireFormat) }() default: break } } } func traverse(visitor: inout V) throws { - if self.location != 0 { - try visitor.visitSingularInt32Field(value: self.location, fieldNumber: 1) + if self.messageSetWireFormat != 0 { + try visitor.visitSingularInt32Field(value: self.messageSetWireFormat, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.location, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.location) -> Bool { - if lhs.location != rhs.location {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageSetWireFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageSetWireFormat) -> Bool { + if lhs.messageSetWireFormat != rhs.messageSetWireFormat {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.M: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".M" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "M"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".messageSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}messageSize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27498,31 +31531,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.M: SwiftProto // 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.m) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.messageSize) }() default: break } } } func traverse(visitor: inout V) throws { - if self.m != 0 { - try visitor.visitSingularInt32Field(value: self.m, fieldNumber: 1) + if self.messageSize != 0 { + try visitor.visitSingularInt32Field(value: self.messageSize, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.M, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.M) -> Bool { - if lhs.m != rhs.m {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageSize) -> Bool { + if lhs.messageSize != rhs.messageSize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.major: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".major" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "major"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".messageType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}messageType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27530,31 +31561,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.major: SwiftP // 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.major) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.messageType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.major != 0 { - try visitor.visitSingularInt32Field(value: self.major, fieldNumber: 1) + if self.messageType != 0 { + try visitor.visitSingularInt32Field(value: self.messageType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.major, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.major) -> Bool { - if lhs.major != rhs.major {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.messageType) -> Bool { + if lhs.messageType != rhs.messageType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.makeIterator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".makeIterator" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "makeIterator"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.method: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".method" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}method\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27562,31 +31591,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.makeIterator: // 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.makeIterator) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.method) }() default: break } } } func traverse(visitor: inout V) throws { - if self.makeIterator != 0 { - try visitor.visitSingularInt32Field(value: self.makeIterator, fieldNumber: 1) + if self.method != 0 { + try visitor.visitSingularInt32Field(value: self.method, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.makeIterator, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.makeIterator) -> Bool { - if lhs.makeIterator != rhs.makeIterator {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.method, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.method) -> Bool { + if lhs.method != rhs.method {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".mapEntry" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mapEntry"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.methods: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".methods" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}methods\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27594,31 +31621,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapEntry: Swi // 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.mapEntry) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.methods) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mapEntry != 0 { - try visitor.visitSingularInt32Field(value: self.mapEntry, fieldNumber: 1) + if self.methods != 0 { + try visitor.visitSingularInt32Field(value: self.methods, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapEntry, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapEntry) -> Bool { - if lhs.mapEntry != rhs.mapEntry {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.methods, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.methods) -> Bool { + if lhs.methods != rhs.methods {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapHash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".mapHash" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mapHash"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.min: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".min" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}min\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27626,31 +31651,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapHash: Swif // 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.mapHash) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.min) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mapHash != 0 { - try visitor.visitSingularInt32Field(value: self.mapHash, fieldNumber: 1) + if self.min != 0 { + try visitor.visitSingularInt32Field(value: self.min, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapHash, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapHash) -> Bool { - if lhs.mapHash != rhs.mapHash {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.min, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.min) -> Bool { + if lhs.min != rhs.min {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapKeyType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".MapKeyType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "MapKeyType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.minimumEdition: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".minimumEdition" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}minimumEdition\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27658,31 +31681,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapKeyType: S // 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.mapKeyType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.minimumEdition) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mapKeyType != 0 { - try visitor.visitSingularInt32Field(value: self.mapKeyType, fieldNumber: 1) + if self.minimumEdition != 0 { + try visitor.visitSingularInt32Field(value: self.minimumEdition, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapKeyType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapKeyType) -> Bool { - if lhs.mapKeyType != rhs.mapKeyType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.minimumEdition, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.minimumEdition) -> Bool { + if lhs.minimumEdition != rhs.minimumEdition {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapNameResolver: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".mapNameResolver" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mapNameResolver"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.minor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".minor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}minor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27690,31 +31711,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapNameResolv // 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.mapNameResolver) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.minor) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mapNameResolver != 0 { - try visitor.visitSingularInt32Field(value: self.mapNameResolver, fieldNumber: 1) + if self.minor != 0 { + try visitor.visitSingularInt32Field(value: self.minor, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapNameResolver, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapNameResolver) -> Bool { - if lhs.mapNameResolver != rhs.mapNameResolver {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.minor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.minor) -> Bool { + if lhs.minor != rhs.minor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapToMessages: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".mapToMessages" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mapToMessages"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mixins: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".mixins" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mixins\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27722,31 +31741,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapToMessages // 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.mapToMessages) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mixins) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mapToMessages != 0 { - try visitor.visitSingularInt32Field(value: self.mapToMessages, fieldNumber: 1) + if self.mixins != 0 { + try visitor.visitSingularInt32Field(value: self.mixins, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapToMessages, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapToMessages) -> Bool { - if lhs.mapToMessages != rhs.mapToMessages {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mixins, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mixins) -> Bool { + if lhs.mixins != rhs.mixins {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapValueType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".MapValueType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "MapValueType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.modify: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".modify" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}modify\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27754,31 +31771,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapValueType: // 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.mapValueType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.modify) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mapValueType != 0 { - try visitor.visitSingularInt32Field(value: self.mapValueType, fieldNumber: 1) + if self.modify != 0 { + try visitor.visitSingularInt32Field(value: self.modify, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapValueType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MapValueType) -> Bool { - if lhs.mapValueType != rhs.mapValueType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.modify, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.modify) -> Bool { + if lhs.modify != rhs.modify {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".mapVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mapVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.month: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".month" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}month\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27786,31 +31801,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapVisitor: S // 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.mapVisitor) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.month) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mapVisitor != 0 { - try visitor.visitSingularInt32Field(value: self.mapVisitor, fieldNumber: 1) + if self.month != 0 { + try visitor.visitSingularInt32Field(value: self.month, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mapVisitor) -> Bool { - if lhs.mapVisitor != rhs.mapVisitor {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.month, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.month) -> Bool { + if lhs.month != rhs.month {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mdayStart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".mdayStart" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mdayStart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.msgExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".msgExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}msgExtension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27818,31 +31831,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mdayStart: Sw // 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.mdayStart) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.msgExtension) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mdayStart != 0 { - try visitor.visitSingularInt32Field(value: self.mdayStart, fieldNumber: 1) + if self.msgExtension != 0 { + try visitor.visitSingularInt32Field(value: self.msgExtension, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mdayStart, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mdayStart) -> Bool { - if lhs.mdayStart != rhs.mdayStart {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.msgExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.msgExtension) -> Bool { + if lhs.msgExtension != rhs.msgExtension {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.merge: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".merge" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "merge"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mutating: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".mutating" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mutating\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27850,31 +31861,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.merge: SwiftP // 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.merge) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.mutating) }() default: break } } } func traverse(visitor: inout V) throws { - if self.merge != 0 { - try visitor.visitSingularInt32Field(value: self.merge, fieldNumber: 1) + if self.mutating != 0 { + try visitor.visitSingularInt32Field(value: self.mutating, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.merge, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.merge) -> Bool { - if lhs.merge != rhs.merge {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mutating, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.mutating) -> Bool { + if lhs.mutating != rhs.mutating {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".message" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "message"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.n: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".n" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}n\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27882,31 +31891,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.message: Swif // 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.message) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.n) }() default: break } } } func traverse(visitor: inout V) throws { - if self.message != 0 { - try visitor.visitSingularInt32Field(value: self.message, fieldNumber: 1) + if self.n != 0 { + try visitor.visitSingularInt32Field(value: self.n, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.message, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.message) -> Bool { - if lhs.message != rhs.message {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.n, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.n) -> Bool { + if lhs.n != rhs.n {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageDepthLimit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".messageDepthLimit" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "messageDepthLimit"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.name: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".name" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}name\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27914,31 +31921,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageDepthL // 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.messageDepthLimit) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.name) }() default: break } } } func traverse(visitor: inout V) throws { - if self.messageDepthLimit != 0 { - try visitor.visitSingularInt32Field(value: self.messageDepthLimit, fieldNumber: 1) + if self.name != 0 { + try visitor.visitSingularInt32Field(value: self.name, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageDepthLimit, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageDepthLimit) -> Bool { - if lhs.messageDepthLimit != rhs.messageDepthLimit {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.name, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.name) -> Bool { + if lhs.name != rhs.name {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".MessageExtension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "MessageExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NameDescription: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".NameDescription" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}NameDescription\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27946,31 +31951,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageExtens // 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.messageExtension) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nameDescription) }() default: break } } } func traverse(visitor: inout V) throws { - if self.messageExtension != 0 { - try visitor.visitSingularInt32Field(value: self.messageExtension, fieldNumber: 1) + if self.nameDescription != 0 { + try visitor.visitSingularInt32Field(value: self.nameDescription, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageExtension, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageExtension) -> Bool { - if lhs.messageExtension != rhs.messageExtension {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NameDescription, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NameDescription) -> Bool { + if lhs.nameDescription != rhs.nameDescription {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageImplementationBase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".MessageImplementationBase" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "MessageImplementationBase"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NameMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".NameMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}NameMap\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27978,31 +31981,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageImplem // 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.messageImplementationBase) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nameMap) }() default: break } } } func traverse(visitor: inout V) throws { - if self.messageImplementationBase != 0 { - try visitor.visitSingularInt32Field(value: self.messageImplementationBase, fieldNumber: 1) + if self.nameMap != 0 { + try visitor.visitSingularInt32Field(value: self.nameMap, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageImplementationBase, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageImplementationBase) -> Bool { - if lhs.messageImplementationBase != rhs.messageImplementationBase {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NameMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NameMap) -> Bool { + if lhs.nameMap != rhs.nameMap {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".MessageOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "MessageOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NamePart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".NamePart" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}NamePart\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28010,31 +32011,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageOption // 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.messageOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.namePart) }() default: break } } } func traverse(visitor: inout V) throws { - if self.messageOptions != 0 { - try visitor.visitSingularInt32Field(value: self.messageOptions, fieldNumber: 1) + if self.namePart != 0 { + try visitor.visitSingularInt32Field(value: self.namePart, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageOptions) -> Bool { - if lhs.messageOptions != rhs.messageOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NamePart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.NamePart) -> Bool { + if lhs.namePart != rhs.namePart {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".MessageSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "MessageSet"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.names: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".names" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}names\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28042,31 +32041,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageSet: S // 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.messageSet) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.names) }() default: break } } } func traverse(visitor: inout V) throws { - if self.messageSet != 0 { - try visitor.visitSingularInt32Field(value: self.messageSet, fieldNumber: 1) + if self.names != 0 { + try visitor.visitSingularInt32Field(value: self.names, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageSet, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MessageSet) -> Bool { - if lhs.messageSet != rhs.messageSet {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.names, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.names) -> Bool { + if lhs.names != rhs.names {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageSetWireFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".messageSetWireFormat" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "messageSetWireFormat"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nanos: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nanos" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nanos\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28074,31 +32071,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageSetWir // 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.messageSetWireFormat) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nanos) }() default: break } } } func traverse(visitor: inout V) throws { - if self.messageSetWireFormat != 0 { - try visitor.visitSingularInt32Field(value: self.messageSetWireFormat, fieldNumber: 1) + if self.nanos != 0 { + try visitor.visitSingularInt32Field(value: self.nanos, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageSetWireFormat, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageSetWireFormat) -> Bool { - if lhs.messageSetWireFormat != rhs.messageSetWireFormat {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nanos, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nanos) -> Bool { + if lhs.nanos != rhs.nanos {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".messageType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "messageType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.negativeIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".negativeIntValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}negativeIntValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28106,31 +32101,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageType: // 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.messageType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.negativeIntValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.messageType != 0 { - try visitor.visitSingularInt32Field(value: self.messageType, fieldNumber: 1) + if self.negativeIntValue != 0 { + try visitor.visitSingularInt32Field(value: self.negativeIntValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.messageType) -> Bool { - if lhs.messageType != rhs.messageType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.negativeIntValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.negativeIntValue) -> Bool { + if lhs.negativeIntValue != rhs.negativeIntValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Method: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Method" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Method"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nestedType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nestedType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nestedType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28138,31 +32131,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Method: Swift // 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.method) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nestedType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.method != 0 { - try visitor.visitSingularInt32Field(value: self.method, fieldNumber: 1) + if self.nestedType != 0 { + try visitor.visitSingularInt32Field(value: self.nestedType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Method, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Method) -> Bool { - if lhs.method != rhs.method {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nestedType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nestedType) -> Bool { + if lhs.nestedType != rhs.nestedType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".MethodDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "MethodDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newExtensible: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".newExtensible" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}newExtensible\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28170,31 +32161,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodDescrip // 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.methodDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.newExtensible) }() default: break } } } func traverse(visitor: inout V) throws { - if self.methodDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.methodDescriptorProto, fieldNumber: 1) + if self.newExtensible != 0 { + try visitor.visitSingularInt32Field(value: self.newExtensible, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodDescriptorProto) -> Bool { - if lhs.methodDescriptorProto != rhs.methodDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newExtensible, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newExtensible) -> Bool { + if lhs.newExtensible != rhs.newExtensible {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".MethodOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "MethodOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".newL" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}newL\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28202,31 +32191,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodOptions // 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.methodOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.newL) }() default: break } } } func traverse(visitor: inout V) throws { - if self.methodOptions != 0 { - try visitor.visitSingularInt32Field(value: self.methodOptions, fieldNumber: 1) + if self.newL != 0 { + try visitor.visitSingularInt32Field(value: self.newL, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.MethodOptions) -> Bool { - if lhs.methodOptions != rhs.methodOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newL) -> Bool { + if lhs.newL != rhs.newL {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.methods: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".methods" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "methods"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newList: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".newList" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}newList\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28234,31 +32221,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.methods: Swif // 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.methods) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.newList) }() default: break } } } func traverse(visitor: inout V) throws { - if self.methods != 0 { - try visitor.visitSingularInt32Field(value: self.methods, fieldNumber: 1) + if self.newList != 0 { + try visitor.visitSingularInt32Field(value: self.newList, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.methods, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.methods) -> Bool { - if lhs.methods != rhs.methods {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newList, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newList) -> Bool { + if lhs.newList != rhs.newList {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.minor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".minor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "minor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".newMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}newMessage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28266,31 +32251,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.minor: SwiftP // 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.minor) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.newMessage) }() default: break } } } func traverse(visitor: inout V) throws { - if self.minor != 0 { - try visitor.visitSingularInt32Field(value: self.minor, fieldNumber: 1) + if self.newMessage != 0 { + try visitor.visitSingularInt32Field(value: self.newMessage, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.minor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.minor) -> Bool { - if lhs.minor != rhs.minor {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newMessage) -> Bool { + if lhs.newMessage != rhs.newMessage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Mixin: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Mixin" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Mixin"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".newValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}newValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28298,31 +32281,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Mixin: SwiftP // 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.mixin) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.newValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mixin != 0 { - try visitor.visitSingularInt32Field(value: self.mixin, fieldNumber: 1) + if self.newValue != 0 { + try visitor.visitSingularInt32Field(value: self.newValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Mixin, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Mixin) -> Bool { - if lhs.mixin != rhs.mixin {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.newValue) -> Bool { + if lhs.newValue != rhs.newValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mixins: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".mixins" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mixins"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.next: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".next" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}next\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28330,31 +32311,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mixins: Swift // 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.mixins) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.next) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mixins != 0 { - try visitor.visitSingularInt32Field(value: self.mixins, fieldNumber: 1) + if self.next != 0 { + try visitor.visitSingularInt32Field(value: self.next, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mixins, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mixins) -> Bool { - if lhs.mixins != rhs.mixins {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.next, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.next) -> Bool { + if lhs.next != rhs.next {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modifier: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".modifier" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "modifier"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextByte: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nextByte" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nextByte\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28362,31 +32341,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modifier: Swi // 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.modifier) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nextByte) }() default: break } } } func traverse(visitor: inout V) throws { - if self.modifier != 0 { - try visitor.visitSingularInt32Field(value: self.modifier, fieldNumber: 1) + if self.nextByte != 0 { + try visitor.visitSingularInt32Field(value: self.nextByte, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modifier, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modifier) -> Bool { - if lhs.modifier != rhs.modifier {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextByte, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextByte) -> Bool { + if lhs.nextByte != rhs.nextByte {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modify: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".modify" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "modify"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nextFieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nextFieldNumber\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28394,31 +32371,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modify: Swift // 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.modify) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nextFieldNumber) }() default: break } } } func traverse(visitor: inout V) throws { - if self.modify != 0 { - try visitor.visitSingularInt32Field(value: self.modify, fieldNumber: 1) + if self.nextFieldNumber != 0 { + try visitor.visitSingularInt32Field(value: self.nextFieldNumber, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modify, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.modify) -> Bool { - if lhs.modify != rhs.modify {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextFieldNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextFieldNumber) -> Bool { + if lhs.nextFieldNumber != rhs.nextFieldNumber {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.month: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".month" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "month"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextInstruction: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nextInstruction" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nextInstruction\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28426,31 +32401,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.month: SwiftP // 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.month) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nextInstruction) }() default: break } } } func traverse(visitor: inout V) throws { - if self.month != 0 { - try visitor.visitSingularInt32Field(value: self.month, fieldNumber: 1) + if self.nextInstruction != 0 { + try visitor.visitSingularInt32Field(value: self.nextInstruction, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.month, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.month) -> Bool { - if lhs.month != rhs.month {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextInstruction, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextInstruction) -> Bool { + if lhs.nextInstruction != rhs.nextInstruction {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.msgExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".msgExtension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "msgExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nextInt32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nextInt32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28458,31 +32431,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.msgExtension: // 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.msgExtension) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nextInt32) }() default: break } } } func traverse(visitor: inout V) throws { - if self.msgExtension != 0 { - try visitor.visitSingularInt32Field(value: self.msgExtension, fieldNumber: 1) + if self.nextInt32 != 0 { + try visitor.visitSingularInt32Field(value: self.nextInt32, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.msgExtension, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.msgExtension) -> Bool { - if lhs.msgExtension != rhs.msgExtension {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextInt32) -> Bool { + if lhs.nextInt32 != rhs.nextInt32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mutating: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".mutating" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mutating"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextNullTerminatedString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nextNullTerminatedString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nextNullTerminatedString\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28490,31 +32461,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mutating: Swi // 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.mutating) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nextNullTerminatedString) }() default: break } } } func traverse(visitor: inout V) throws { - if self.mutating != 0 { - try visitor.visitSingularInt32Field(value: self.mutating, fieldNumber: 1) + if self.nextNullTerminatedString != 0 { + try visitor.visitSingularInt32Field(value: self.nextNullTerminatedString, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mutating, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.mutating) -> Bool { - if lhs.mutating != rhs.mutating {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextNullTerminatedString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextNullTerminatedString) -> Bool { + if lhs.nextNullTerminatedString != rhs.nextNullTerminatedString {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.n: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".n" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "n"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextNullTerminatedStringArray: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nextNullTerminatedStringArray" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nextNullTerminatedStringArray\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28522,31 +32491,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.n: SwiftProto // 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.n) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nextNullTerminatedStringArray) }() default: break } } } func traverse(visitor: inout V) throws { - if self.n != 0 { - try visitor.visitSingularInt32Field(value: self.n, fieldNumber: 1) + if self.nextNullTerminatedStringArray != 0 { + try visitor.visitSingularInt32Field(value: self.nextNullTerminatedStringArray, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.n, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.n) -> Bool { - if lhs.n != rhs.n {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextNullTerminatedStringArray, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextNullTerminatedStringArray) -> Bool { + if lhs.nextNullTerminatedStringArray != rhs.nextNullTerminatedStringArray {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.name: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".name" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "name"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nextNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nextNumber\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28554,31 +32521,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.name: SwiftPr // 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.name) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nextNumber) }() default: break } } } func traverse(visitor: inout V) throws { - if self.name != 0 { - try visitor.visitSingularInt32Field(value: self.name, fieldNumber: 1) + if self.nextNumber != 0 { + try visitor.visitSingularInt32Field(value: self.nextNumber, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.name, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.name) -> Bool { - if lhs.name != rhs.name {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextNumber) -> Bool { + if lhs.nextNumber != rhs.nextNumber {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameDescription: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".NameDescription" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "NameDescription"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextUInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nextUInt64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nextUInt64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28586,31 +32551,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameDescripti // 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.nameDescription) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nextUint64) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nameDescription != 0 { - try visitor.visitSingularInt32Field(value: self.nameDescription, fieldNumber: 1) + if self.nextUint64 != 0 { + try visitor.visitSingularInt32Field(value: self.nextUint64, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameDescription, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameDescription) -> Bool { - if lhs.nameDescription != rhs.nameDescription {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextUInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextUInt64) -> Bool { + if lhs.nextUint64 != rhs.nextUint64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".NameMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "NameMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextVarInt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nextVarInt" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nextVarInt\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28618,31 +32581,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameMap: Swif // 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.nameMap) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nextVarInt) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nameMap != 0 { - try visitor.visitSingularInt32Field(value: self.nameMap, fieldNumber: 1) + if self.nextVarInt != 0 { + try visitor.visitSingularInt32Field(value: self.nextVarInt, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameMap, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NameMap) -> Bool { - if lhs.nameMap != rhs.nameMap {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextVarInt, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nextVarInt) -> Bool { + if lhs.nextVarInt != rhs.nextVarInt {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NamePart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".NamePart" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "NamePart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nilMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nil" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nil\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28650,31 +32611,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NamePart: Swi // 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.namePart) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`nil`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.namePart != 0 { - try visitor.visitSingularInt32Field(value: self.namePart, fieldNumber: 1) + if self.`nil` != 0 { + try visitor.visitSingularInt32Field(value: self.`nil`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NamePart, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.NamePart) -> Bool { - if lhs.namePart != rhs.namePart {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nilMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nilMessage) -> Bool { + if lhs.`nil` != rhs.`nil` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nameResolver: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nameResolver" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nameResolver"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nilLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nilLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nilLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28682,31 +32641,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nameResolver: // 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.nameResolver) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nilLiteral) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nameResolver != 0 { - try visitor.visitSingularInt32Field(value: self.nameResolver, fieldNumber: 1) + if self.nilLiteral != 0 { + try visitor.visitSingularInt32Field(value: self.nilLiteral, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nameResolver, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nameResolver) -> Bool { - if lhs.nameResolver != rhs.nameResolver {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nilLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nilLiteral) -> Bool { + if lhs.nilLiteral != rhs.nilLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.names: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".names" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "names"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.noBytesAvailable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".noBytesAvailable" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}noBytesAvailable\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28714,31 +32671,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.names: SwiftP // 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.names) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.noBytesAvailable) }() default: break } } } func traverse(visitor: inout V) throws { - if self.names != 0 { - try visitor.visitSingularInt32Field(value: self.names, fieldNumber: 1) + if self.noBytesAvailable != 0 { + try visitor.visitSingularInt32Field(value: self.noBytesAvailable, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.names, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.names) -> Bool { - if lhs.names != rhs.names {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.noBytesAvailable, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.noBytesAvailable) -> Bool { + if lhs.noBytesAvailable != rhs.noBytesAvailable {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nanos: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nanos" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nanos"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.noStandardDescriptorAccessor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".noStandardDescriptorAccessor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}noStandardDescriptorAccessor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28746,31 +32701,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nanos: SwiftP // 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.nanos) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.noStandardDescriptorAccessor) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nanos != 0 { - try visitor.visitSingularInt32Field(value: self.nanos, fieldNumber: 1) + if self.noStandardDescriptorAccessor != 0 { + try visitor.visitSingularInt32Field(value: self.noStandardDescriptorAccessor, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nanos, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nanos) -> Bool { - if lhs.nanos != rhs.nanos {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.noStandardDescriptorAccessor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.noStandardDescriptorAccessor) -> Bool { + if lhs.noStandardDescriptorAccessor != rhs.noStandardDescriptorAccessor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nativeBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nativeBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nullValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".nullValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nullValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28778,31 +32731,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeBytes: // 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.nativeBytes) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.nullValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nativeBytes != 0 { - try visitor.visitSingularInt32Field(value: self.nativeBytes, fieldNumber: 1) + if self.nullValue != 0 { + try visitor.visitSingularInt32Field(value: self.nullValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeBytes, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeBytes) -> Bool { - if lhs.nativeBytes != rhs.nativeBytes {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nullValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.nullValue) -> Bool { + if lhs.nullValue != rhs.nullValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeEndianBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nativeEndianBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nativeEndianBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.number: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".number" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}number\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28810,31 +32761,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeEndianB // 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.nativeEndianBytes) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.number) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nativeEndianBytes != 0 { - try visitor.visitSingularInt32Field(value: self.nativeEndianBytes, fieldNumber: 1) + if self.number != 0 { + try visitor.visitSingularInt32Field(value: self.number, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeEndianBytes, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nativeEndianBytes) -> Bool { - if lhs.nativeEndianBytes != rhs.nativeEndianBytes {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.number, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.number) -> Bool { + if lhs.number != rhs.number {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.negativeIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".negativeIntValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "negativeIntValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.numberValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".numberValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}numberValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28842,31 +32791,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.negativeIntVa // 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.negativeIntValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.numberValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.negativeIntValue != 0 { - try visitor.visitSingularInt32Field(value: self.negativeIntValue, fieldNumber: 1) + if self.numberValue != 0 { + try visitor.visitSingularInt32Field(value: self.numberValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.negativeIntValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.negativeIntValue) -> Bool { - if lhs.negativeIntValue != rhs.negativeIntValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.numberValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.numberValue) -> Bool { + if lhs.numberValue != rhs.numberValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nestedType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nestedType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nestedType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.objcClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".objcClassPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}objcClassPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28874,31 +32821,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nestedType: S // 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.nestedType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.objcClassPrefix) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nestedType != 0 { - try visitor.visitSingularInt32Field(value: self.nestedType, fieldNumber: 1) + if self.objcClassPrefix != 0 { + try visitor.visitSingularInt32Field(value: self.objcClassPrefix, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nestedType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nestedType) -> Bool { - if lhs.nestedType != rhs.nestedType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.objcClassPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.objcClassPrefix) -> Bool { + if lhs.objcClassPrefix != rhs.objcClassPrefix {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".newL" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "newL"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.of: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".of" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}of\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28906,31 +32851,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newL: SwiftPr // 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.newL) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.of) }() default: break } } } func traverse(visitor: inout V) throws { - if self.newL != 0 { - try visitor.visitSingularInt32Field(value: self.newL, fieldNumber: 1) + if self.of != 0 { + try visitor.visitSingularInt32Field(value: self.of, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newL, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newL) -> Bool { - if lhs.newL != rhs.newL {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.of, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.of) -> Bool { + if lhs.of != rhs.of {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newList: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".newList" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "newList"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OneOf_Kind: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".OneOf_Kind" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}OneOf_Kind\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28938,31 +32881,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newList: Swif // 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.newList) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.oneOfKind) }() default: break } } } func traverse(visitor: inout V) throws { - if self.newList != 0 { - try visitor.visitSingularInt32Field(value: self.newList, fieldNumber: 1) + if self.oneOfKind != 0 { + try visitor.visitSingularInt32Field(value: self.oneOfKind, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newList, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newList) -> Bool { - if lhs.newList != rhs.newList {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OneOf_Kind, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OneOf_Kind) -> Bool { + if lhs.oneOfKind != rhs.oneOfKind {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".newValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "newValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofDecl: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".oneofDecl" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}oneofDecl\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28970,31 +32911,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newValue: Swi // 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.newValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.oneofDecl) }() default: break } } } func traverse(visitor: inout V) throws { - if self.newValue != 0 { - try visitor.visitSingularInt32Field(value: self.newValue, fieldNumber: 1) + if self.oneofDecl != 0 { + try visitor.visitSingularInt32Field(value: self.oneofDecl, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.newValue) -> Bool { - if lhs.newValue != rhs.newValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofDecl, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofDecl) -> Bool { + if lhs.oneofDecl != rhs.oneofDecl {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextByte: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nextByte" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nextByte"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofIndex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".oneofIndex" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}oneofIndex\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29002,31 +32941,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextByte: Swi // 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.nextByte) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.oneofIndex) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nextByte != 0 { - try visitor.visitSingularInt32Field(value: self.nextByte, fieldNumber: 1) + if self.oneofIndex != 0 { + try visitor.visitSingularInt32Field(value: self.oneofIndex, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextByte, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextByte) -> Bool { - if lhs.nextByte != rhs.nextByte {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofIndex, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofIndex) -> Bool { + if lhs.oneofIndex != rhs.oneofIndex {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nextFieldNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nextFieldNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofs: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".oneofs" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}oneofs\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29034,31 +32971,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextFieldNumb // 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.nextFieldNumber) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.oneofs) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nextFieldNumber != 0 { - try visitor.visitSingularInt32Field(value: self.nextFieldNumber, fieldNumber: 1) + if self.oneofs != 0 { + try visitor.visitSingularInt32Field(value: self.oneofs, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextFieldNumber, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nextFieldNumber) -> Bool { - if lhs.nextFieldNumber != rhs.nextFieldNumber {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofs, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.oneofs) -> Bool { + if lhs.oneofs != rhs.oneofs {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nil" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nil"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.optimizeFor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".optimizeFor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}optimizeFor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29066,31 +33001,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilMessage: S // 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.`nil`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.optimizeFor) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`nil` != 0 { - try visitor.visitSingularInt32Field(value: self.`nil`, fieldNumber: 1) + if self.optimizeFor != 0 { + try visitor.visitSingularInt32Field(value: self.optimizeFor, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilMessage) -> Bool { - if lhs.`nil` != rhs.`nil` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.optimizeFor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.optimizeFor) -> Bool { + if lhs.optimizeFor != rhs.optimizeFor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nilLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nilLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptimizeMode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".OptimizeMode" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OptimizeMode\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29098,31 +33031,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilLiteral: S // 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.nilLiteral) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.optimizeMode) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nilLiteral != 0 { - try visitor.visitSingularInt32Field(value: self.nilLiteral, fieldNumber: 1) + if self.optimizeMode != 0 { + try visitor.visitSingularInt32Field(value: self.optimizeMode, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nilLiteral) -> Bool { - if lhs.nilLiteral != rhs.nilLiteral {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptimizeMode, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptimizeMode) -> Bool { + if lhs.optimizeMode != rhs.optimizeMode {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.noStandardDescriptorAccessor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".noStandardDescriptorAccessor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "noStandardDescriptorAccessor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalEnumExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionalEnumExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OptionalEnumExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29130,31 +33061,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.noStandardDes // 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.noStandardDescriptorAccessor) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.optionalEnumExtensionField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.noStandardDescriptorAccessor != 0 { - try visitor.visitSingularInt32Field(value: self.noStandardDescriptorAccessor, fieldNumber: 1) + if self.optionalEnumExtensionField != 0 { + try visitor.visitSingularInt32Field(value: self.optionalEnumExtensionField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.noStandardDescriptorAccessor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.noStandardDescriptorAccessor) -> Bool { - if lhs.noStandardDescriptorAccessor != rhs.noStandardDescriptorAccessor {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalEnumExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalEnumExtensionField) -> Bool { + if lhs.optionalEnumExtensionField != rhs.optionalEnumExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nullValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".nullValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nullValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionalExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OptionalExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29162,31 +33091,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nullValue: Sw // 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.nullValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.optionalExtensionField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.nullValue != 0 { - try visitor.visitSingularInt32Field(value: self.nullValue, fieldNumber: 1) + if self.optionalExtensionField != 0 { + try visitor.visitSingularInt32Field(value: self.optionalExtensionField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nullValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.nullValue) -> Bool { - if lhs.nullValue != rhs.nullValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalExtensionField) -> Bool { + if lhs.optionalExtensionField != rhs.optionalExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.number: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".number" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "number"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalGroupExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionalGroupExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OptionalGroupExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29194,31 +33121,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.number: Swift // 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.number) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.optionalGroupExtensionField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.number != 0 { - try visitor.visitSingularInt32Field(value: self.number, fieldNumber: 1) + if self.optionalGroupExtensionField != 0 { + try visitor.visitSingularInt32Field(value: self.optionalGroupExtensionField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.number, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.number) -> Bool { - if lhs.number != rhs.number {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalGroupExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalGroupExtensionField) -> Bool { + if lhs.optionalGroupExtensionField != rhs.optionalGroupExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.numberValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".numberValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "numberValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalMessageExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionalMessageExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OptionalMessageExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29226,31 +33151,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.numberValue: // 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.numberValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.optionalMessageExtensionField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.numberValue != 0 { - try visitor.visitSingularInt32Field(value: self.numberValue, fieldNumber: 1) + if self.optionalMessageExtensionField != 0 { + try visitor.visitSingularInt32Field(value: self.optionalMessageExtensionField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.numberValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.numberValue) -> Bool { - if lhs.numberValue != rhs.numberValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalMessageExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionalMessageExtensionField) -> Bool { + if lhs.optionalMessageExtensionField != rhs.optionalMessageExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.objcClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".objcClassPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "objcClassPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.optionDependency: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".optionDependency" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}optionDependency\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29258,31 +33181,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.objcClassPref // 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.objcClassPrefix) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.optionDependency) }() default: break } } } func traverse(visitor: inout V) throws { - if self.objcClassPrefix != 0 { - try visitor.visitSingularInt32Field(value: self.objcClassPrefix, fieldNumber: 1) + if self.optionDependency != 0 { + try visitor.visitSingularInt32Field(value: self.optionDependency, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.objcClassPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.objcClassPrefix) -> Bool { - if lhs.objcClassPrefix != rhs.objcClassPrefix {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.optionDependency, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.optionDependency) -> Bool { + if lhs.optionDependency != rhs.optionDependency {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.of: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".of" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "of"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionRetention: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionRetention" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OptionRetention\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29290,31 +33211,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.of: SwiftProt // 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.of) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.optionRetention) }() default: break } } } func traverse(visitor: inout V) throws { - if self.of != 0 { - try visitor.visitSingularInt32Field(value: self.of, fieldNumber: 1) + if self.optionRetention != 0 { + try visitor.visitSingularInt32Field(value: self.optionRetention, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.of, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.of) -> Bool { - if lhs.of != rhs.of {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionRetention, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionRetention) -> Bool { + if lhs.optionRetention != rhs.optionRetention {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofDecl: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".oneofDecl" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "oneofDecl"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.options: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".options" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}options\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29322,31 +33241,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofDecl: Sw // 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.oneofDecl) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.options) }() default: break } } } func traverse(visitor: inout V) throws { - if self.oneofDecl != 0 { - try visitor.visitSingularInt32Field(value: self.oneofDecl, fieldNumber: 1) + if self.options != 0 { + try visitor.visitSingularInt32Field(value: self.options, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofDecl, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofDecl) -> Bool { - if lhs.oneofDecl != rhs.oneofDecl {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.options, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.options) -> Bool { + if lhs.options != rhs.options {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".OneofDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "OneofDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionTargetType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionTargetType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OptionTargetType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29354,31 +33271,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofDescript // 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.oneofDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.optionTargetType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.oneofDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.oneofDescriptorProto, fieldNumber: 1) + if self.optionTargetType != 0 { + try visitor.visitSingularInt32Field(value: self.optionTargetType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofDescriptorProto) -> Bool { - if lhs.oneofDescriptorProto != rhs.oneofDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionTargetType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.OptionTargetType) -> Bool { + if lhs.optionTargetType != rhs.optionTargetType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofIndex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".oneofIndex" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "oneofIndex"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.other: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".other" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}other\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29386,31 +33301,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofIndex: S // 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.oneofIndex) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.other) }() default: break } } } func traverse(visitor: inout V) throws { - if self.oneofIndex != 0 { - try visitor.visitSingularInt32Field(value: self.oneofIndex, fieldNumber: 1) + if self.other != 0 { + try visitor.visitSingularInt32Field(value: self.other, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofIndex, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofIndex) -> Bool { - if lhs.oneofIndex != rhs.oneofIndex {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.other, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.other) -> Bool { + if lhs.other != rhs.other {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".OneofOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "OneofOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.others: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".others" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}others\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29418,31 +33331,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofOptions: // 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.oneofOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.others) }() default: break } } } func traverse(visitor: inout V) throws { - if self.oneofOptions != 0 { - try visitor.visitSingularInt32Field(value: self.oneofOptions, fieldNumber: 1) + if self.others != 0 { + try visitor.visitSingularInt32Field(value: self.others, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneofOptions) -> Bool { - if lhs.oneofOptions != rhs.oneofOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.others, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.others) -> Bool { + if lhs.others != rhs.others {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofs: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".oneofs" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "oneofs"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.out: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".out" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}out\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29450,31 +33361,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofs: Swift // 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.oneofs) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.out) }() default: break } } } func traverse(visitor: inout V) throws { - if self.oneofs != 0 { - try visitor.visitSingularInt32Field(value: self.oneofs, fieldNumber: 1) + if self.out != 0 { + try visitor.visitSingularInt32Field(value: self.out, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofs, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.oneofs) -> Bool { - if lhs.oneofs != rhs.oneofs {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.out, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.out) -> Bool { + if lhs.out != rhs.out {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneOf_Kind: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".OneOf_Kind" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "OneOf_Kind"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.outputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".outputType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}outputType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29482,31 +33391,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneOf_Kind: S // 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.oneOfKind) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.outputType) }() default: break } } } func traverse(visitor: inout V) throws { - if self.oneOfKind != 0 { - try visitor.visitSingularInt32Field(value: self.oneOfKind, fieldNumber: 1) + if self.outputType != 0 { + try visitor.visitSingularInt32Field(value: self.outputType, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneOf_Kind, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OneOf_Kind) -> Bool { - if lhs.oneOfKind != rhs.oneOfKind {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.outputType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.outputType) -> Bool { + if lhs.outputType != rhs.outputType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.optimizeFor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".optimizeFor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "optimizeFor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.overridableFeatures: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".overridableFeatures" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}overridableFeatures\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29514,31 +33421,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.optimizeFor: // 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.optimizeFor) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.overridableFeatures) }() default: break } } } func traverse(visitor: inout V) throws { - if self.optimizeFor != 0 { - try visitor.visitSingularInt32Field(value: self.optimizeFor, fieldNumber: 1) + if self.overridableFeatures != 0 { + try visitor.visitSingularInt32Field(value: self.overridableFeatures, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.optimizeFor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.optimizeFor) -> Bool { - if lhs.optimizeFor != rhs.optimizeFor {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.overridableFeatures, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.overridableFeatures) -> Bool { + if lhs.overridableFeatures != rhs.overridableFeatures {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptimizeMode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".OptimizeMode" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "OptimizeMode"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.p: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".p" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}p\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29546,31 +33451,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptimizeMode: // 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.optimizeMode) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.p) }() default: break } } } func traverse(visitor: inout V) throws { - if self.optimizeMode != 0 { - try visitor.visitSingularInt32Field(value: self.optimizeMode, fieldNumber: 1) + if self.p != 0 { + try visitor.visitSingularInt32Field(value: self.p, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptimizeMode, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptimizeMode) -> Bool { - if lhs.optimizeMode != rhs.optimizeMode {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.p, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.p) -> Bool { + if lhs.p != rhs.p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Option: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Option" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Option"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.package: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".package" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}package\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29578,31 +33481,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Option: Swift // 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.option) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.package) }() default: break } } } func traverse(visitor: inout V) throws { - if self.option != 0 { - try visitor.visitSingularInt32Field(value: self.option, fieldNumber: 1) + if self.package != 0 { + try visitor.visitSingularInt32Field(value: self.package, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Option, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Option) -> Bool { - if lhs.option != rhs.option {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.package, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.package) -> Bool { + if lhs.package != rhs.package {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalEnumExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionalEnumExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "OptionalEnumExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packed: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".packed" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}packed\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29610,31 +33511,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalEnumE // 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.optionalEnumExtensionField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.packed) }() default: break } } } func traverse(visitor: inout V) throws { - if self.optionalEnumExtensionField != 0 { - try visitor.visitSingularInt32Field(value: self.optionalEnumExtensionField, fieldNumber: 1) + if self.packed != 0 { + try visitor.visitSingularInt32Field(value: self.packed, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalEnumExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalEnumExtensionField) -> Bool { - if lhs.optionalEnumExtensionField != rhs.optionalEnumExtensionField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packed, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.packed) -> Bool { + if lhs.packed != rhs.packed {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionalExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "OptionalExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedEnumExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".PackedEnumExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}PackedEnumExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29642,31 +33541,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalExten // 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.optionalExtensionField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.packedEnumExtensionField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.optionalExtensionField != 0 { - try visitor.visitSingularInt32Field(value: self.optionalExtensionField, fieldNumber: 1) + if self.packedEnumExtensionField != 0 { + try visitor.visitSingularInt32Field(value: self.packedEnumExtensionField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalExtensionField) -> Bool { - if lhs.optionalExtensionField != rhs.optionalExtensionField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedEnumExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedEnumExtensionField) -> Bool { + if lhs.packedEnumExtensionField != rhs.packedEnumExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalGroupExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionalGroupExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "OptionalGroupExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".PackedExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}PackedExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29674,31 +33571,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalGroup // 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.optionalGroupExtensionField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.packedExtensionField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.optionalGroupExtensionField != 0 { - try visitor.visitSingularInt32Field(value: self.optionalGroupExtensionField, fieldNumber: 1) + if self.packedExtensionField != 0 { + try visitor.visitSingularInt32Field(value: self.packedExtensionField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalGroupExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalGroupExtensionField) -> Bool { - if lhs.optionalGroupExtensionField != rhs.optionalGroupExtensionField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PackedExtensionField) -> Bool { + if lhs.packedExtensionField != rhs.packedExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalMessageExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".OptionalMessageExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "OptionalMessageExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.padding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".padding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}padding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29706,31 +33601,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalMessa // 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.optionalMessageExtensionField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.padding) }() default: break } } } func traverse(visitor: inout V) throws { - if self.optionalMessageExtensionField != 0 { - try visitor.visitSingularInt32Field(value: self.optionalMessageExtensionField, fieldNumber: 1) + if self.padding != 0 { + try visitor.visitSingularInt32Field(value: self.padding, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalMessageExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.OptionalMessageExtensionField) -> Bool { - if lhs.optionalMessageExtensionField != rhs.optionalMessageExtensionField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.padding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.padding) -> Bool { + if lhs.padding != rhs.padding {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.options: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".options" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "options"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.parent: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".parent" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}parent\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29738,31 +33631,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.options: Swif // 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.options) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.parent) }() default: break } } } func traverse(visitor: inout V) throws { - if self.options != 0 { - try visitor.visitSingularInt32Field(value: self.options, fieldNumber: 1) + if self.parent != 0 { + try visitor.visitSingularInt32Field(value: self.parent, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.options, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.options) -> Bool { - if lhs.options != rhs.options {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.parent, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.parent) -> Bool { + if lhs.parent != rhs.parent {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.other: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".other" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "other"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.parse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".parse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}parse\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29770,31 +33661,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.other: SwiftP // 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.other) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.parse) }() default: break } } } func traverse(visitor: inout V) throws { - if self.other != 0 { - try visitor.visitSingularInt32Field(value: self.other, fieldNumber: 1) + if self.parse != 0 { + try visitor.visitSingularInt32Field(value: self.parse, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.other, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.other) -> Bool { - if lhs.other != rhs.other {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.parse, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.parse) -> Bool { + if lhs.parse != rhs.parse {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.others: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".others" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "others"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.partial: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".partial" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}partial\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29802,31 +33691,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.others: Swift // 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.others) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.partial) }() default: break } } } func traverse(visitor: inout V) throws { - if self.others != 0 { - try visitor.visitSingularInt32Field(value: self.others, fieldNumber: 1) + if self.partial != 0 { + try visitor.visitSingularInt32Field(value: self.partial, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.others, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.others) -> Bool { - if lhs.others != rhs.others {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.partial, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.partial) -> Bool { + if lhs.partial != rhs.partial {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.out: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".out" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "out"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.path: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".path" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}path\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29834,31 +33721,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.out: SwiftPro // 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.out) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.path) }() default: break } } } func traverse(visitor: inout V) throws { - if self.out != 0 { - try visitor.visitSingularInt32Field(value: self.out, fieldNumber: 1) + if self.path != 0 { + try visitor.visitSingularInt32Field(value: self.path, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.out, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.out) -> Bool { - if lhs.out != rhs.out {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.path, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.path) -> Bool { + if lhs.path != rhs.path {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.outputType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".outputType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "outputType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PathDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".PathDecoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}PathDecoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29866,31 +33751,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.outputType: S // 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.outputType) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.pathDecoder) }() default: break } } } func traverse(visitor: inout V) throws { - if self.outputType != 0 { - try visitor.visitSingularInt32Field(value: self.outputType, fieldNumber: 1) + if self.pathDecoder != 0 { + try visitor.visitSingularInt32Field(value: self.pathDecoder, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.outputType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.outputType) -> Bool { - if lhs.outputType != rhs.outputType {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PathDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PathDecoder) -> Bool { + if lhs.pathDecoder != rhs.pathDecoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.p: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".p" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "p"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PathDecodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".PathDecodingError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}PathDecodingError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29898,31 +33781,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.p: SwiftProto // 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.p) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.pathDecodingError) }() default: break } } } func traverse(visitor: inout V) throws { - if self.p != 0 { - try visitor.visitSingularInt32Field(value: self.p, fieldNumber: 1) + if self.pathDecodingError != 0 { + try visitor.visitSingularInt32Field(value: self.pathDecodingError, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.p, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.p) -> Bool { - if lhs.p != rhs.p {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PathDecodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PathDecodingError) -> Bool { + if lhs.pathDecodingError != rhs.pathDecodingError {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.package: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".package" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "package"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.paths: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".paths" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}paths\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29930,31 +33811,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.package: Swif // 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.package) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.paths) }() default: break } } } func traverse(visitor: inout V) throws { - if self.package != 0 { - try visitor.visitSingularInt32Field(value: self.package, fieldNumber: 1) + if self.paths != 0 { + try visitor.visitSingularInt32Field(value: self.paths, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.package, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.package) -> Bool { - if lhs.package != rhs.package {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.paths, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.paths) -> Bool { + if lhs.paths != rhs.paths {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.packed: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".packed" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "packed"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PathVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".PathVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}PathVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29962,31 +33841,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.packed: Swift // 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.packed) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.pathVisitor) }() default: break } } } func traverse(visitor: inout V) throws { - if self.packed != 0 { - try visitor.visitSingularInt32Field(value: self.packed, fieldNumber: 1) + if self.pathVisitor != 0 { + try visitor.visitSingularInt32Field(value: self.pathVisitor, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.packed, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.packed) -> Bool { - if lhs.packed != rhs.packed {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PathVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.PathVisitor) -> Bool { + if lhs.pathVisitor != rhs.pathVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedEnumExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".PackedEnumExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "PackedEnumExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.payload: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".payload" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}payload\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -29994,31 +33871,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedEnumExt // 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.packedEnumExtensionField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.payload) }() default: break } } } func traverse(visitor: inout V) throws { - if self.packedEnumExtensionField != 0 { - try visitor.visitSingularInt32Field(value: self.packedEnumExtensionField, fieldNumber: 1) + if self.payload != 0 { + try visitor.visitSingularInt32Field(value: self.payload, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedEnumExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedEnumExtensionField) -> Bool { - if lhs.packedEnumExtensionField != rhs.packedEnumExtensionField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.payload, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.payload) -> Bool { + if lhs.payload != rhs.payload {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".PackedExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "PackedExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.payloadSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".payloadSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}payloadSize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30026,31 +33901,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedExtensi // 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.packedExtensionField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.payloadSize) }() default: break } } } func traverse(visitor: inout V) throws { - if self.packedExtensionField != 0 { - try visitor.visitSingularInt32Field(value: self.packedExtensionField, fieldNumber: 1) + if self.payloadSize != 0 { + try visitor.visitSingularInt32Field(value: self.payloadSize, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.PackedExtensionField) -> Bool { - if lhs.packedExtensionField != rhs.packedExtensionField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.payloadSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.payloadSize) -> Bool { + if lhs.payloadSize != rhs.payloadSize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.padding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".padding" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "padding"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".phpClassPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}phpClassPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30058,31 +33931,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.padding: Swif // 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.padding) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.phpClassPrefix) }() default: break } } } func traverse(visitor: inout V) throws { - if self.padding != 0 { - try visitor.visitSingularInt32Field(value: self.padding, fieldNumber: 1) + if self.phpClassPrefix != 0 { + try visitor.visitSingularInt32Field(value: self.phpClassPrefix, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.padding, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.padding) -> Bool { - if lhs.padding != rhs.padding {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpClassPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpClassPrefix) -> Bool { + if lhs.phpClassPrefix != rhs.phpClassPrefix {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parent: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".parent" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "parent"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpMetadataNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".phpMetadataNamespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}phpMetadataNamespace\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30090,31 +33961,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parent: Swift // 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.parent) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.phpMetadataNamespace) }() default: break } } } func traverse(visitor: inout V) throws { - if self.parent != 0 { - try visitor.visitSingularInt32Field(value: self.parent, fieldNumber: 1) + if self.phpMetadataNamespace != 0 { + try visitor.visitSingularInt32Field(value: self.phpMetadataNamespace, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parent, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parent) -> Bool { - if lhs.parent != rhs.parent {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpMetadataNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpMetadataNamespace) -> Bool { + if lhs.phpMetadataNamespace != rhs.phpMetadataNamespace {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".parse" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "parse"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".phpNamespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}phpNamespace\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30122,31 +33991,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parse: SwiftP // 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.parse) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.phpNamespace) }() default: break } } } func traverse(visitor: inout V) throws { - if self.parse != 0 { - try visitor.visitSingularInt32Field(value: self.parse, fieldNumber: 1) + if self.phpNamespace != 0 { + try visitor.visitSingularInt32Field(value: self.phpNamespace, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parse, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.parse) -> Bool { - if lhs.parse != rhs.parse {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpNamespace, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.phpNamespace) -> Bool { + if lhs.phpNamespace != rhs.phpNamespace {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.partial: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".partial" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "partial"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.pos: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".pos" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}pos\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30154,31 +34021,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.partial: Swif // 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.partial) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.pos) }() default: break } } } func traverse(visitor: inout V) throws { - if self.partial != 0 { - try visitor.visitSingularInt32Field(value: self.partial, fieldNumber: 1) + if self.pos != 0 { + try visitor.visitSingularInt32Field(value: self.pos, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.partial, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.partial) -> Bool { - if lhs.partial != rhs.partial {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.pos, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.pos) -> Bool { + if lhs.pos != rhs.pos {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.path: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".path" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "path"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.positiveIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".positiveIntValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}positiveIntValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30186,31 +34051,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.path: SwiftPr // 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.path) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.positiveIntValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.path != 0 { - try visitor.visitSingularInt32Field(value: self.path, fieldNumber: 1) + if self.positiveIntValue != 0 { + try visitor.visitSingularInt32Field(value: self.positiveIntValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.path, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.path) -> Bool { - if lhs.path != rhs.path {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.positiveIntValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.positiveIntValue) -> Bool { + if lhs.positiveIntValue != rhs.positiveIntValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.paths: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".paths" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "paths"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.prefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".prefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}prefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30218,31 +34081,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.paths: SwiftP // 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.paths) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.prefix) }() default: break } } } func traverse(visitor: inout V) throws { - if self.paths != 0 { - try visitor.visitSingularInt32Field(value: self.paths, fieldNumber: 1) + if self.prefix != 0 { + try visitor.visitSingularInt32Field(value: self.prefix, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.paths, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.paths) -> Bool { - if lhs.paths != rhs.paths {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.prefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.prefix) -> Bool { + if lhs.prefix != rhs.prefix {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payload: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".payload" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "payload"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.preserveProtoFieldNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".preserveProtoFieldNames" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}preserveProtoFieldNames\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30250,31 +34111,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payload: Swif // 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.payload) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.preserveProtoFieldNames) }() default: break } } } func traverse(visitor: inout V) throws { - if self.payload != 0 { - try visitor.visitSingularInt32Field(value: self.payload, fieldNumber: 1) + if self.preserveProtoFieldNames != 0 { + try visitor.visitSingularInt32Field(value: self.preserveProtoFieldNames, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payload, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payload) -> Bool { - if lhs.payload != rhs.payload {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.preserveProtoFieldNames, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.preserveProtoFieldNames) -> Bool { + if lhs.preserveProtoFieldNames != rhs.preserveProtoFieldNames {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payloadSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".payloadSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "payloadSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.preTraverse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".preTraverse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}preTraverse\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30282,31 +34141,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payloadSize: // 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.payloadSize) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.preTraverse) }() default: break } } } func traverse(visitor: inout V) throws { - if self.payloadSize != 0 { - try visitor.visitSingularInt32Field(value: self.payloadSize, fieldNumber: 1) + if self.preTraverse != 0 { + try visitor.visitSingularInt32Field(value: self.preTraverse, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payloadSize, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.payloadSize) -> Bool { - if lhs.payloadSize != rhs.payloadSize {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.preTraverse, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.preTraverse) -> Bool { + if lhs.preTraverse != rhs.preTraverse {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpClassPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".phpClassPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "phpClassPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.previousNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".previousNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}previousNumber\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30314,31 +34171,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpClassPrefi // 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.phpClassPrefix) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.previousNumber) }() default: break } } } func traverse(visitor: inout V) throws { - if self.phpClassPrefix != 0 { - try visitor.visitSingularInt32Field(value: self.phpClassPrefix, fieldNumber: 1) + if self.previousNumber != 0 { + try visitor.visitSingularInt32Field(value: self.previousNumber, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpClassPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpClassPrefix) -> Bool { - if lhs.phpClassPrefix != rhs.phpClassPrefix {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.previousNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.previousNumber) -> Bool { + if lhs.previousNumber != rhs.previousNumber {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".phpGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "phpGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.prevPath: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".prevPath" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}prevPath\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30346,31 +34201,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpGenericSer // 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.phpGenericServices) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.prevPath) }() default: break } } } func traverse(visitor: inout V) throws { - if self.phpGenericServices != 0 { - try visitor.visitSingularInt32Field(value: self.phpGenericServices, fieldNumber: 1) + if self.prevPath != 0 { + try visitor.visitSingularInt32Field(value: self.prevPath, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpGenericServices) -> Bool { - if lhs.phpGenericServices != rhs.phpGenericServices {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.prevPath, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.prevPath) -> Bool { + if lhs.prevPath != rhs.prevPath {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpMetadataNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".phpMetadataNamespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "phpMetadataNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.printUnknownFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".printUnknownFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}printUnknownFields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30378,31 +34231,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpMetadataNa // 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.phpMetadataNamespace) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.printUnknownFields) }() default: break } } } func traverse(visitor: inout V) throws { - if self.phpMetadataNamespace != 0 { - try visitor.visitSingularInt32Field(value: self.phpMetadataNamespace, fieldNumber: 1) + if self.printUnknownFields != 0 { + try visitor.visitSingularInt32Field(value: self.printUnknownFields, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpMetadataNamespace, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpMetadataNamespace) -> Bool { - if lhs.phpMetadataNamespace != rhs.phpMetadataNamespace {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.printUnknownFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.printUnknownFields) -> Bool { + if lhs.printUnknownFields != rhs.printUnknownFields {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpNamespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".phpNamespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "phpNamespace"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.programBuffer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".programBuffer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}programBuffer\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30410,31 +34261,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpNamespace: // 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.phpNamespace) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.programBuffer) }() default: break } } } func traverse(visitor: inout V) throws { - if self.phpNamespace != 0 { - try visitor.visitSingularInt32Field(value: self.phpNamespace, fieldNumber: 1) + if self.programBuffer != 0 { + try visitor.visitSingularInt32Field(value: self.programBuffer, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpNamespace, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.phpNamespace) -> Bool { - if lhs.phpNamespace != rhs.phpNamespace {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.programBuffer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.programBuffer) -> Bool { + if lhs.programBuffer != rhs.programBuffer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".pointer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "pointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.programFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".programFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}programFormat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30442,31 +34291,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pointer: Swif // 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.pointer) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.programFormat) }() default: break } } } func traverse(visitor: inout V) throws { - if self.pointer != 0 { - try visitor.visitSingularInt32Field(value: self.pointer, fieldNumber: 1) + if self.programFormat != 0 { + try visitor.visitSingularInt32Field(value: self.programFormat, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pointer, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pointer) -> Bool { - if lhs.pointer != rhs.pointer {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.programFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.programFormat) -> Bool { + if lhs.programFormat != rhs.programFormat {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pos: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".pos" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "pos"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".proto2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}proto2\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30474,31 +34321,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pos: SwiftPro // 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.pos) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.proto2) }() default: break } } } func traverse(visitor: inout V) throws { - if self.pos != 0 { - try visitor.visitSingularInt32Field(value: self.pos, fieldNumber: 1) + if self.proto2 != 0 { + try visitor.visitSingularInt32Field(value: self.proto2, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pos, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pos) -> Bool { - if lhs.pos != rhs.pos {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto2, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto2) -> Bool { + if lhs.proto2 != rhs.proto2 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.positiveIntValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".positiveIntValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "positiveIntValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto3DefaultValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".proto3DefaultValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}proto3DefaultValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30506,31 +34351,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.positiveIntVa // 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.positiveIntValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.proto3DefaultValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.positiveIntValue != 0 { - try visitor.visitSingularInt32Field(value: self.positiveIntValue, fieldNumber: 1) + if self.proto3DefaultValue != 0 { + try visitor.visitSingularInt32Field(value: self.proto3DefaultValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.positiveIntValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.positiveIntValue) -> Bool { - if lhs.positiveIntValue != rhs.positiveIntValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto3DefaultValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto3DefaultValue) -> Bool { + if lhs.proto3DefaultValue != rhs.proto3DefaultValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.prefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".prefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "prefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto3Optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".proto3Optional" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}proto3Optional\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30538,31 +34381,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.prefix: Swift // 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.prefix) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.proto3Optional) }() default: break } } } func traverse(visitor: inout V) throws { - if self.prefix != 0 { - try visitor.visitSingularInt32Field(value: self.prefix, fieldNumber: 1) + if self.proto3Optional != 0 { + try visitor.visitSingularInt32Field(value: self.proto3Optional, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.prefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.prefix) -> Bool { - if lhs.prefix != rhs.prefix {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto3Optional, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.proto3Optional) -> Bool { + if lhs.proto3Optional != rhs.proto3Optional {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preserveProtoFieldNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".preserveProtoFieldNames" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "preserveProtoFieldNames"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_extensionFieldValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_extensionFieldValues" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}protobuf_extensionFieldValues\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30570,31 +34411,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preserveProto // 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.preserveProtoFieldNames) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protobufExtensionFieldValues) }() default: break } } } func traverse(visitor: inout V) throws { - if self.preserveProtoFieldNames != 0 { - try visitor.visitSingularInt32Field(value: self.preserveProtoFieldNames, fieldNumber: 1) + if self.protobufExtensionFieldValues != 0 { + try visitor.visitSingularInt32Field(value: self.protobufExtensionFieldValues, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preserveProtoFieldNames, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preserveProtoFieldNames) -> Bool { - if lhs.preserveProtoFieldNames != rhs.preserveProtoFieldNames {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_extensionFieldValues, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_extensionFieldValues) -> Bool { + if lhs.protobufExtensionFieldValues != rhs.protobufExtensionFieldValues {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preTraverse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".preTraverse" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "preTraverse"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_fieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_fieldNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}protobuf_fieldNumber\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30602,31 +34441,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preTraverse: // 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.preTraverse) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protobufFieldNumber) }() default: break } } } func traverse(visitor: inout V) throws { - if self.preTraverse != 0 { - try visitor.visitSingularInt32Field(value: self.preTraverse, fieldNumber: 1) + if self.protobufFieldNumber != 0 { + try visitor.visitSingularInt32Field(value: self.protobufFieldNumber, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preTraverse, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.preTraverse) -> Bool { - if lhs.preTraverse != rhs.preTraverse {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_fieldNumber, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_fieldNumber) -> Bool { + if lhs.protobufFieldNumber != rhs.protobufFieldNumber {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.printUnknownFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".printUnknownFields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "printUnknownFields"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_generated_isEqualTo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_generated_isEqualTo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}protobuf_generated_isEqualTo\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30634,31 +34471,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.printUnknownF // 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.printUnknownFields) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protobufGeneratedIsEqualTo) }() default: break } } } func traverse(visitor: inout V) throws { - if self.printUnknownFields != 0 { - try visitor.visitSingularInt32Field(value: self.printUnknownFields, fieldNumber: 1) + if self.protobufGeneratedIsEqualTo != 0 { + try visitor.visitSingularInt32Field(value: self.protobufGeneratedIsEqualTo, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.printUnknownFields, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.printUnknownFields) -> Bool { - if lhs.printUnknownFields != rhs.printUnknownFields {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_generated_isEqualTo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_generated_isEqualTo) -> Bool { + if lhs.protobufGeneratedIsEqualTo != rhs.protobufGeneratedIsEqualTo {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".proto2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "proto2"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_nameMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_nameMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}protobuf_nameMap\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30666,31 +34501,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto2: Swift // 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.proto2) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protobufNameMap) }() default: break } } } func traverse(visitor: inout V) throws { - if self.proto2 != 0 { - try visitor.visitSingularInt32Field(value: self.proto2, fieldNumber: 1) + if self.protobufNameMap != 0 { + try visitor.visitSingularInt32Field(value: self.protobufNameMap, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto2, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto2) -> Bool { - if lhs.proto2 != rhs.proto2 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_nameMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_nameMap) -> Bool { + if lhs.protobufNameMap != rhs.protobufNameMap {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3DefaultValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".proto3DefaultValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "proto3DefaultValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_newField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_newField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}protobuf_newField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30698,31 +34531,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3Default // 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.proto3DefaultValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protobufNewField) }() default: break } } } func traverse(visitor: inout V) throws { - if self.proto3DefaultValue != 0 { - try visitor.visitSingularInt32Field(value: self.proto3DefaultValue, fieldNumber: 1) + if self.protobufNewField != 0 { + try visitor.visitSingularInt32Field(value: self.protobufNewField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3DefaultValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3DefaultValue) -> Bool { - if lhs.proto3DefaultValue != rhs.proto3DefaultValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_newField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_newField) -> Bool { + if lhs.protobufNewField != rhs.protobufNewField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3Optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".proto3Optional" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "proto3Optional"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_package: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_package" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}protobuf_package\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30730,31 +34561,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3Optiona // 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.proto3Optional) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protobufPackage) }() default: break } } } func traverse(visitor: inout V) throws { - if self.proto3Optional != 0 { - try visitor.visitSingularInt32Field(value: self.proto3Optional, fieldNumber: 1) + if self.protobufPackage != 0 { + try visitor.visitSingularInt32Field(value: self.protobufPackage, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3Optional, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.proto3Optional) -> Bool { - if lhs.proto3Optional != rhs.proto3Optional {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_package, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobuf_package) -> Bool { + if lhs.protobufPackage != rhs.protobufPackage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVersionCheck: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufAPIVersionCheck" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufAPIVersionCheck"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufAPIVersion_2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufAPIVersion_2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}ProtobufAPIVersion_2\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30762,31 +34591,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVe // 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.protobufApiversionCheck) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protobufApiversion2) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protobufApiversionCheck != 0 { - try visitor.visitSingularInt32Field(value: self.protobufApiversionCheck, fieldNumber: 1) + if self.protobufApiversion2 != 0 { + try visitor.visitSingularInt32Field(value: self.protobufApiversion2, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVersionCheck, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVersionCheck) -> Bool { - if lhs.protobufApiversionCheck != rhs.protobufApiversionCheck {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufAPIVersion_2, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufAPIVersion_2) -> Bool { + if lhs.protobufApiversion2 != rhs.protobufApiversion2 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVersion_2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufAPIVersion_2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "ProtobufAPIVersion_2"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufAPIVersionCheck: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufAPIVersionCheck" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufAPIVersionCheck\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30794,31 +34621,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVe // 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.protobufApiversion2) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protobufApiversionCheck) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protobufApiversion2 != 0 { - try visitor.visitSingularInt32Field(value: self.protobufApiversion2, fieldNumber: 1) + if self.protobufApiversionCheck != 0 { + try visitor.visitSingularInt32Field(value: self.protobufApiversionCheck, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVersion_2, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufAPIVersion_2) -> Bool { - if lhs.protobufApiversion2 != rhs.protobufApiversion2 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufAPIVersionCheck, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufAPIVersionCheck) -> Bool { + if lhs.protobufApiversionCheck != rhs.protobufApiversionCheck {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBool: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufBool" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufBool"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufBool: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufBool" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufBool\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30839,18 +34664,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBool: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBool, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBool) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufBool, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufBool) -> Bool { if lhs.protobufBool != rhs.protobufBool {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufBytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30871,18 +34694,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBytes try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBytes, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufBytes) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufBytes) -> Bool { if lhs.protobufBytes != rhs.protobufBytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufDouble: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufDouble" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufDouble"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobufData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protobufData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}protobufData\0") + + 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.protobufData) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.protobufData != 0 { + try visitor.visitSingularInt32Field(value: self.protobufData, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobufData, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobufData) -> Bool { + if lhs.protobufData != rhs.protobufData {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufDouble: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufDouble" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufDouble\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30903,18 +34754,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufDoubl try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufDouble, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufDouble) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufDouble, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufDouble) -> Bool { if lhs.protobufDouble != rhs.protobufDouble {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufEnumMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufEnumMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufEnumMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufEnumMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufEnumMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufEnumMap\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30935,18 +34784,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufEnumM try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufEnumMap, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufEnumMap) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufEnumMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufEnumMap) -> Bool { if lhs.protobufEnumMap != rhs.protobufEnumMap {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobufExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protobufExtension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "protobufExtension"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobufExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protobufExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}protobufExtension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30967,18 +34814,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobufExten try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobufExtension, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobufExtension) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobufExtension, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protobufExtension) -> Bool { if lhs.protobufExtension != rhs.protobufExtension {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufFixed32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufFixed32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufFixed32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufFixed32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -30999,18 +34844,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed32, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed32) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFixed32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFixed32) -> Bool { if lhs.protobufFixed32 != rhs.protobufFixed32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufFixed64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufFixed64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFixed64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufFixed64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufFixed64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31031,18 +34874,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed64, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFixed64) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFixed64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFixed64) -> Bool { if lhs.protobufFixed64 != rhs.protobufFixed64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFloat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufFloat" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufFloat"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFloat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufFloat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufFloat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31063,18 +34904,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFloat try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFloat, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufFloat) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFloat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufFloat) -> Bool { if lhs.protobufFloat != rhs.protobufFloat {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufInt32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufInt32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufInt32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufInt32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31095,18 +34934,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt32 try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt32, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt32) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufInt32) -> Bool { if lhs.protobufInt32 != rhs.protobufInt32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufInt64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufInt64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufInt64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31127,18 +34964,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt64 try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt64, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufInt64) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufInt64) -> Bool { if lhs.protobufInt64 != rhs.protobufInt64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufMap\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31159,18 +34994,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMap: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMap, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMap) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufMap) -> Bool { if lhs.protobufMap != rhs.protobufMap {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMessageMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufMessageMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufMessageMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufMessageMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufMessageMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufMessageMap\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31191,18 +35024,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMessa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMessageMap, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufMessageMap) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufMessageMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufMessageMap) -> Bool { if lhs.protobufMessageMap != rhs.protobufMessageMap {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufSFixed32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufSFixed32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufSFixed32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufSFixed32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31223,18 +35054,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixe try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixed32, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixed32) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSFixed32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSFixed32) -> Bool { if lhs.protobufSfixed32 != rhs.protobufSfixed32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixed64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufSFixed64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufSFixed64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSFixed64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufSFixed64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufSFixed64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31255,18 +35084,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixe try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixed64, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSFixed64) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSFixed64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSFixed64) -> Bool { if lhs.protobufSfixed64 != rhs.protobufSfixed64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufSInt32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufSInt32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufSInt32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufSInt32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31287,18 +35114,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt3 try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt32, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt32) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSInt32) -> Bool { if lhs.protobufSint32 != rhs.protobufSint32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufSInt64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufSInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufSInt64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufSInt64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31319,18 +35144,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt6 try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt64, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufSInt64) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufSInt64) -> Bool { if lhs.protobufSint64 != rhs.protobufSint64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufString" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufString"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufString\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31351,18 +35174,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufStrin try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufString, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufString) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufString) -> Bool { if lhs.protobufString != rhs.protobufString {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufUInt32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufUInt32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufUInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufUInt32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufUInt32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31383,18 +35204,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt3 try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt32, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt32) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufUInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufUInt32) -> Bool { if lhs.protobufUint32 != rhs.protobufUint32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufUInt64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtobufUInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufUInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtobufUInt64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtobufUInt64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31415,18 +35234,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt6 try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt64, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtobufUInt64) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufUInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtobufUInt64) -> Bool { if lhs.protobufUint64 != rhs.protobufUint64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_extensionFieldValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_extensionFieldValues" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "protobuf_extensionFieldValues"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protocolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protocol" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}protocol\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31434,31 +35251,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_exte // 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.protobufExtensionFieldValues) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`protocol`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protobufExtensionFieldValues != 0 { - try visitor.visitSingularInt32Field(value: self.protobufExtensionFieldValues, fieldNumber: 1) + if self.`protocol` != 0 { + try visitor.visitSingularInt32Field(value: self.`protocol`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_extensionFieldValues, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_extensionFieldValues) -> Bool { - if lhs.protobufExtensionFieldValues != rhs.protobufExtensionFieldValues {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protocolMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protocolMessage) -> Bool { + if lhs.`protocol` != rhs.`protocol` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_fieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_fieldNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "protobuf_fieldNumber"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoFieldName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protoFieldName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}protoFieldName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31466,31 +35281,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_fiel // 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.protobufFieldNumber) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protoFieldName) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protobufFieldNumber != 0 { - try visitor.visitSingularInt32Field(value: self.protobufFieldNumber, fieldNumber: 1) + if self.protoFieldName != 0 { + try visitor.visitSingularInt32Field(value: self.protoFieldName, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_fieldNumber, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_fieldNumber) -> Bool { - if lhs.protobufFieldNumber != rhs.protobufFieldNumber {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoFieldName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoFieldName) -> Bool { + if lhs.protoFieldName != rhs.protoFieldName {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_generated_isEqualTo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_generated_isEqualTo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "protobuf_generated_isEqualTo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageNameMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protoMessageName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}protoMessageName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31498,31 +35311,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_gene // 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.protobufGeneratedIsEqualTo) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protoMessageName) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protobufGeneratedIsEqualTo != 0 { - try visitor.visitSingularInt32Field(value: self.protobufGeneratedIsEqualTo, fieldNumber: 1) + if self.protoMessageName != 0 { + try visitor.visitSingularInt32Field(value: self.protoMessageName, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_generated_isEqualTo, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_generated_isEqualTo) -> Bool { - if lhs.protobufGeneratedIsEqualTo != rhs.protobufGeneratedIsEqualTo {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageNameMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageNameMessage) -> Bool { + if lhs.protoMessageName != rhs.protoMessageName {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_nameMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_nameMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "protobuf_nameMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtoNameProviding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtoNameProviding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProtoNameProviding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31530,31 +35341,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_name // 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.protobufNameMap) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protoNameProviding) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protobufNameMap != 0 { - try visitor.visitSingularInt32Field(value: self.protobufNameMap, fieldNumber: 1) + if self.protoNameProviding != 0 { + try visitor.visitSingularInt32Field(value: self.protoNameProviding, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_nameMap, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_nameMap) -> Bool { - if lhs.protobufNameMap != rhs.protobufNameMap {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtoNameProviding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ProtoNameProviding) -> Bool { + if lhs.protoNameProviding != rhs.protoNameProviding {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_newField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_newField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "protobuf_newField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoPaths: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".protoPaths" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}protoPaths\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31562,31 +35371,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_newF // 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.protobufNewField) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.protoPaths) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protobufNewField != 0 { - try visitor.visitSingularInt32Field(value: self.protobufNewField, fieldNumber: 1) + if self.protoPaths != 0 { + try visitor.visitSingularInt32Field(value: self.protoPaths, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_newField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_newField) -> Bool { - if lhs.protobufNewField != rhs.protobufNewField {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoPaths, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoPaths) -> Bool { + if lhs.protoPaths != rhs.protoPaths {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_package: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protobuf_package" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "protobuf_package"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.publicMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".public" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}public\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31594,31 +35401,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_pack // 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.protobufPackage) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`public`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protobufPackage != 0 { - try visitor.visitSingularInt32Field(value: self.protobufPackage, fieldNumber: 1) + if self.`public` != 0 { + try visitor.visitSingularInt32Field(value: self.`public`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_package, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protobuf_package) -> Bool { - if lhs.protobufPackage != rhs.protobufPackage {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.publicMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.publicMessage) -> Bool { + if lhs.`public` != rhs.`public` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protocolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protocol" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "protocol"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.publicDependency: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".publicDependency" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}publicDependency\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31626,31 +35431,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protocolMessa // 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.`protocol`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.publicDependency) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`protocol` != 0 { - try visitor.visitSingularInt32Field(value: self.`protocol`, fieldNumber: 1) + if self.publicDependency != 0 { + try visitor.visitSingularInt32Field(value: self.publicDependency, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protocolMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protocolMessage) -> Bool { - if lhs.`protocol` != rhs.`protocol` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.publicDependency, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.publicDependency) -> Bool { + if lhs.publicDependency != rhs.publicDependency {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoFieldName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protoFieldName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "protoFieldName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putBoolValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putBoolValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putBoolValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31658,31 +35461,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoFieldNam // 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.protoFieldName) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putBoolValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protoFieldName != 0 { - try visitor.visitSingularInt32Field(value: self.protoFieldName, fieldNumber: 1) + if self.putBoolValue != 0 { + try visitor.visitSingularInt32Field(value: self.putBoolValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoFieldName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoFieldName) -> Bool { - if lhs.protoFieldName != rhs.protoFieldName {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putBoolValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putBoolValue) -> Bool { + if lhs.putBoolValue != rhs.putBoolValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageNameMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protoMessageName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "protoMessageName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putBytesValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putBytesValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putBytesValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31690,31 +35491,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageN // 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.protoMessageName) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putBytesValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protoMessageName != 0 { - try visitor.visitSingularInt32Field(value: self.protoMessageName, fieldNumber: 1) + if self.putBytesValue != 0 { + try visitor.visitSingularInt32Field(value: self.putBytesValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageNameMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageNameMessage) -> Bool { - if lhs.protoMessageName != rhs.protoMessageName {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putBytesValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putBytesValue) -> Bool { + if lhs.putBytesValue != rhs.putBytesValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtoNameProviding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ProtoNameProviding" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProtoNameProviding"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putDoubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putDoubleValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putDoubleValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31722,31 +35521,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtoNameProv // 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.protoNameProviding) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putDoubleValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protoNameProviding != 0 { - try visitor.visitSingularInt32Field(value: self.protoNameProviding, fieldNumber: 1) + if self.putDoubleValue != 0 { + try visitor.visitSingularInt32Field(value: self.putDoubleValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtoNameProviding, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ProtoNameProviding) -> Bool { - if lhs.protoNameProviding != rhs.protoNameProviding {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putDoubleValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putDoubleValue) -> Bool { + if lhs.putDoubleValue != rhs.putDoubleValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoPaths: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".protoPaths" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "protoPaths"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putEnumValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putEnumValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putEnumValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31754,31 +35551,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoPaths: S // 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.protoPaths) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putEnumValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.protoPaths != 0 { - try visitor.visitSingularInt32Field(value: self.protoPaths, fieldNumber: 1) + if self.putEnumValue != 0 { + try visitor.visitSingularInt32Field(value: self.putEnumValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoPaths, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoPaths) -> Bool { - if lhs.protoPaths != rhs.protoPaths {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putEnumValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putEnumValue) -> Bool { + if lhs.putEnumValue != rhs.putEnumValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".public" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "public"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFixedUInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putFixedUInt32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putFixedUInt32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31786,31 +35581,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicMessage // 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.`public`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putFixedUint32) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`public` != 0 { - try visitor.visitSingularInt32Field(value: self.`public`, fieldNumber: 1) + if self.putFixedUint32 != 0 { + try visitor.visitSingularInt32Field(value: self.putFixedUint32, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicMessage) -> Bool { - if lhs.`public` != rhs.`public` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFixedUInt32, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFixedUInt32) -> Bool { + if lhs.putFixedUint32 != rhs.putFixedUint32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicDependency: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".publicDependency" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "publicDependency"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFixedUInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putFixedUInt64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putFixedUInt64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31818,31 +35611,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicDepende // 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.publicDependency) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putFixedUint64) }() default: break } } } func traverse(visitor: inout V) throws { - if self.publicDependency != 0 { - try visitor.visitSingularInt32Field(value: self.publicDependency, fieldNumber: 1) + if self.putFixedUint64 != 0 { + try visitor.visitSingularInt32Field(value: self.putFixedUint64, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicDependency, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.publicDependency) -> Bool { - if lhs.publicDependency != rhs.publicDependency {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFixedUInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFixedUInt64) -> Bool { + if lhs.putFixedUint64 != rhs.putFixedUint64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBoolValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putBoolValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putBoolValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFloatValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putFloatValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putFloatValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31850,31 +35641,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBoolValue: // 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.putBoolValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putFloatValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putBoolValue != 0 { - try visitor.visitSingularInt32Field(value: self.putBoolValue, fieldNumber: 1) + if self.putFloatValue != 0 { + try visitor.visitSingularInt32Field(value: self.putFloatValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBoolValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBoolValue) -> Bool { - if lhs.putBoolValue != rhs.putBoolValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFloatValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putFloatValue) -> Bool { + if lhs.putFloatValue != rhs.putFloatValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBytesValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putBytesValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putBytesValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putInt64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putInt64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31882,31 +35671,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBytesValue // 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.putBytesValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putInt64) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putBytesValue != 0 { - try visitor.visitSingularInt32Field(value: self.putBytesValue, fieldNumber: 1) + if self.putInt64 != 0 { + try visitor.visitSingularInt32Field(value: self.putInt64, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBytesValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putBytesValue) -> Bool { - if lhs.putBytesValue != rhs.putBytesValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putInt64) -> Bool { + if lhs.putInt64 != rhs.putInt64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putDoubleValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putDoubleValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putDoubleValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putStringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putStringValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putStringValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31914,31 +35701,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putDoubleValu // 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.putDoubleValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putStringValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putDoubleValue != 0 { - try visitor.visitSingularInt32Field(value: self.putDoubleValue, fieldNumber: 1) + if self.putStringValue != 0 { + try visitor.visitSingularInt32Field(value: self.putStringValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putDoubleValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putDoubleValue) -> Bool { - if lhs.putDoubleValue != rhs.putDoubleValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putStringValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putStringValue) -> Bool { + if lhs.putStringValue != rhs.putStringValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putEnumValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putEnumValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putEnumValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putUInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putUInt64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putUInt64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31946,31 +35731,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putEnumValue: // 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.putEnumValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putUint64) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putEnumValue != 0 { - try visitor.visitSingularInt32Field(value: self.putEnumValue, fieldNumber: 1) + if self.putUint64 != 0 { + try visitor.visitSingularInt32Field(value: self.putUint64, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putEnumValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putEnumValue) -> Bool { - if lhs.putEnumValue != rhs.putEnumValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putUInt64, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putUInt64) -> Bool { + if lhs.putUint64 != rhs.putUint64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putFixedUInt32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putFixedUInt32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putUInt64Hex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putUInt64Hex" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putUInt64Hex\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -31978,31 +35761,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt3 // 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.putFixedUint32) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putUint64Hex) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putFixedUint32 != 0 { - try visitor.visitSingularInt32Field(value: self.putFixedUint32, fieldNumber: 1) + if self.putUint64Hex != 0 { + try visitor.visitSingularInt32Field(value: self.putUint64Hex, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt32, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt32) -> Bool { - if lhs.putFixedUint32 != rhs.putFixedUint32 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putUInt64Hex, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putUInt64Hex) -> Bool { + if lhs.putUint64Hex != rhs.putUint64Hex {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putFixedUInt64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putFixedUInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putVarInt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putVarInt" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putVarInt\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32010,31 +35791,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt6 // 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.putFixedUint64) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putVarInt) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putFixedUint64 != 0 { - try visitor.visitSingularInt32Field(value: self.putFixedUint64, fieldNumber: 1) + if self.putVarInt != 0 { + try visitor.visitSingularInt32Field(value: self.putVarInt, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt64, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFixedUInt64) -> Bool { - if lhs.putFixedUint64 != rhs.putFixedUint64 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putVarInt, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putVarInt) -> Bool { + if lhs.putVarInt != rhs.putVarInt {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFloatValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putFloatValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putFloatValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putZigZagVarInt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".putZigZagVarInt" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}putZigZagVarInt\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32042,31 +35821,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFloatValue // 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.putFloatValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.putZigZagVarInt) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putFloatValue != 0 { - try visitor.visitSingularInt32Field(value: self.putFloatValue, fieldNumber: 1) + if self.putZigZagVarInt != 0 { + try visitor.visitSingularInt32Field(value: self.putZigZagVarInt, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFloatValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putFloatValue) -> Bool { - if lhs.putFloatValue != rhs.putFloatValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putZigZagVarInt, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.putZigZagVarInt) -> Bool { + if lhs.putZigZagVarInt != rhs.putZigZagVarInt {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putInt64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.pyGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".pyGenericServices" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}pyGenericServices\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32074,31 +35851,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putInt64: Swi // 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.putInt64) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.pyGenericServices) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putInt64 != 0 { - try visitor.visitSingularInt32Field(value: self.putInt64, fieldNumber: 1) + if self.pyGenericServices != 0 { + try visitor.visitSingularInt32Field(value: self.pyGenericServices, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putInt64, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putInt64) -> Bool { - if lhs.putInt64 != rhs.putInt64 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.pyGenericServices, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.pyGenericServices) -> Bool { + if lhs.pyGenericServices != rhs.pyGenericServices {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putStringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putStringValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putStringValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.R: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".R" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}R\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32106,31 +35881,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putStringValu // 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.putStringValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.r) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putStringValue != 0 { - try visitor.visitSingularInt32Field(value: self.putStringValue, fieldNumber: 1) + if self.r != 0 { + try visitor.visitSingularInt32Field(value: self.r, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putStringValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putStringValue) -> Bool { - if lhs.putStringValue != rhs.putStringValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.R, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.R) -> Bool { + if lhs.r != rhs.r {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putUInt64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putUInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rawChars: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".rawChars" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}rawChars\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32138,31 +35911,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64: Sw // 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.putUint64) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.rawChars) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putUint64 != 0 { - try visitor.visitSingularInt32Field(value: self.putUint64, fieldNumber: 1) + if self.rawChars != 0 { + try visitor.visitSingularInt32Field(value: self.rawChars, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64) -> Bool { - if lhs.putUint64 != rhs.putUint64 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rawChars, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rawChars) -> Bool { + if lhs.rawChars != rhs.rawChars {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64Hex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putUInt64Hex" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putUInt64Hex"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RawRepresentable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".RawRepresentable" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}RawRepresentable\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32170,31 +35941,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64Hex: // 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.putUint64Hex) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.rawRepresentable) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putUint64Hex != 0 { - try visitor.visitSingularInt32Field(value: self.putUint64Hex, fieldNumber: 1) + if self.rawRepresentable != 0 { + try visitor.visitSingularInt32Field(value: self.rawRepresentable, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64Hex, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putUInt64Hex) -> Bool { - if lhs.putUint64Hex != rhs.putUint64Hex {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RawRepresentable, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RawRepresentable) -> Bool { + if lhs.rawRepresentable != rhs.rawRepresentable {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putVarInt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putVarInt" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putVarInt"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RawValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".RawValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}RawValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32202,31 +35971,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putVarInt: Sw // 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.putVarInt) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.rawValue) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putVarInt != 0 { - try visitor.visitSingularInt32Field(value: self.putVarInt, fieldNumber: 1) + if self.rawValue != 0 { + try visitor.visitSingularInt32Field(value: self.rawValue, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putVarInt, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putVarInt) -> Bool { - if lhs.putVarInt != rhs.putVarInt {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RawValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RawValue) -> Bool { + if lhs.rawValue != rhs.rawValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putZigZagVarInt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".putZigZagVarInt" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "putZigZagVarInt"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.read4HexDigits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".read4HexDigits" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}read4HexDigits\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32234,31 +36001,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putZigZagVarI // 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.putZigZagVarInt) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.read4HexDigits) }() default: break } } } func traverse(visitor: inout V) throws { - if self.putZigZagVarInt != 0 { - try visitor.visitSingularInt32Field(value: self.putZigZagVarInt, fieldNumber: 1) + if self.read4HexDigits != 0 { + try visitor.visitSingularInt32Field(value: self.read4HexDigits, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putZigZagVarInt, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.putZigZagVarInt) -> Bool { - if lhs.putZigZagVarInt != rhs.putZigZagVarInt {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.read4HexDigits, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.read4HexDigits) -> Bool { + if lhs.read4HexDigits != rhs.read4HexDigits {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pyGenericServices: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".pyGenericServices" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "pyGenericServices"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.readBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".readBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}readBytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32266,31 +36031,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pyGenericServ // 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.pyGenericServices) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.readBytes) }() default: break } } } func traverse(visitor: inout V) throws { - if self.pyGenericServices != 0 { - try visitor.visitSingularInt32Field(value: self.pyGenericServices, fieldNumber: 1) + if self.readBytes != 0 { + try visitor.visitSingularInt32Field(value: self.readBytes, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pyGenericServices, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.pyGenericServices) -> Bool { - if lhs.pyGenericServices != rhs.pyGenericServices {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.readBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.readBytes) -> Bool { + if lhs.readBytes != rhs.readBytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rawChars: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".rawChars" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "rawChars"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.reader: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".reader" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}reader\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32298,31 +36061,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rawChars: Swi // 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.rawChars) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.reader) }() default: break } } } func traverse(visitor: inout V) throws { - if self.rawChars != 0 { - try visitor.visitSingularInt32Field(value: self.rawChars, fieldNumber: 1) + if self.reader != 0 { + try visitor.visitSingularInt32Field(value: self.reader, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rawChars, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rawChars) -> Bool { - if lhs.rawChars != rhs.rawChars {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.reader, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.reader) -> Bool { + if lhs.reader != rhs.reader {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawRepresentable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".RawRepresentable" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "RawRepresentable"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.register: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".register" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}register\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32330,31 +36091,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawRepresenta // 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.rawRepresentable) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.register) }() default: break } } } func traverse(visitor: inout V) throws { - if self.rawRepresentable != 0 { - try visitor.visitSingularInt32Field(value: self.rawRepresentable, fieldNumber: 1) + if self.register != 0 { + try visitor.visitSingularInt32Field(value: self.register, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawRepresentable, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawRepresentable) -> Bool { - if lhs.rawRepresentable != rhs.rawRepresentable {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.register, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.register) -> Bool { + if lhs.register != rhs.register {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".RawValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "RawValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.remainingProgram: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".remainingProgram" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}remainingProgram\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32362,31 +36121,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawValue: Swi // 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.rawValue) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.remainingProgram) }() default: break } } } func traverse(visitor: inout V) throws { - if self.rawValue != 0 { - try visitor.visitSingularInt32Field(value: self.rawValue, fieldNumber: 1) + if self.remainingProgram != 0 { + try visitor.visitSingularInt32Field(value: self.remainingProgram, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RawValue) -> Bool { - if lhs.rawValue != rhs.rawValue {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.remainingProgram, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.remainingProgram) -> Bool { + if lhs.remainingProgram != rhs.remainingProgram {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.read4HexDigits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".read4HexDigits" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "read4HexDigits"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.removalError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".removalError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}removalError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32394,31 +36151,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.read4HexDigit // 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.read4HexDigits) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.removalError) }() default: break } } } func traverse(visitor: inout V) throws { - if self.read4HexDigits != 0 { - try visitor.visitSingularInt32Field(value: self.read4HexDigits, fieldNumber: 1) + if self.removalError != 0 { + try visitor.visitSingularInt32Field(value: self.removalError, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.read4HexDigits, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.read4HexDigits) -> Bool { - if lhs.read4HexDigits != rhs.read4HexDigits {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.removalError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.removalError) -> Bool { + if lhs.removalError != rhs.removalError {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.register: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".register" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "register"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.removingAllFieldsOf: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".removingAllFieldsOf" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}removingAllFieldsOf\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32426,31 +36181,59 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.register: Swi // 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.register) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.removingAllFieldsOf) }() default: break } } } func traverse(visitor: inout V) throws { - if self.register != 0 { - try visitor.visitSingularInt32Field(value: self.register, fieldNumber: 1) + if self.removingAllFieldsOf != 0 { + try visitor.visitSingularInt32Field(value: self.removingAllFieldsOf, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.register, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.register) -> Bool { - if lhs.register != rhs.register {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.removingAllFieldsOf, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.removingAllFieldsOf) -> Bool { + if lhs.removingAllFieldsOf != rhs.removingAllFieldsOf {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}repeated\0") + + 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.repeated) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.repeated != 0 { + try visitor.visitSingularInt32Field(value: self.repeated, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeated) -> Bool { + if lhs.repeated != rhs.repeated {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedEnumExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedEnumExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "RepeatedEnumExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedEnumExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedEnumExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}RepeatedEnumExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32471,18 +36254,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedEnumE try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedEnumExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedEnumExtensionField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedEnumExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedEnumExtensionField) -> Bool { if lhs.repeatedEnumExtensionField != rhs.repeatedEnumExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "RepeatedExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}RepeatedExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32503,18 +36284,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedExten try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedExtensionField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedExtensionField) -> Bool { if lhs.repeatedExtensionField != rhs.repeatedExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedGroupExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedGroupExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "RepeatedGroupExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFieldEncoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeatedFieldEncoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}repeatedFieldEncoding\0") + + 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.repeatedFieldEncoding) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.repeatedFieldEncoding != 0 { + try visitor.visitSingularInt32Field(value: self.repeatedFieldEncoding, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFieldEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeatedFieldEncoding) -> Bool { + if lhs.repeatedFieldEncoding != rhs.repeatedFieldEncoding {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedGroupExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedGroupExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}RepeatedGroupExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32535,18 +36344,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedGroup try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedGroupExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedGroupExtensionField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedGroupExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedGroupExtensionField) -> Bool { if lhs.repeatedGroupExtensionField != rhs.repeatedGroupExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedMessageExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedMessageExtensionField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "RepeatedMessageExtensionField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedMessageExtensionField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".RepeatedMessageExtensionField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}RepeatedMessageExtensionField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32567,18 +36374,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedMessa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedMessageExtensionField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.RepeatedMessageExtensionField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedMessageExtensionField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.RepeatedMessageExtensionField) -> Bool { if lhs.repeatedMessageExtensionField != rhs.repeatedMessageExtensionField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".requestStreaming" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "requestStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeating: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".repeating" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}repeating\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32586,31 +36391,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestStream // 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.requestStreaming) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.repeating) }() default: break } } } func traverse(visitor: inout V) throws { - if self.requestStreaming != 0 { - try visitor.visitSingularInt32Field(value: self.requestStreaming, fieldNumber: 1) + if self.repeating != 0 { + try visitor.visitSingularInt32Field(value: self.repeating, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestStreaming, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestStreaming) -> Bool { - if lhs.requestStreaming != rhs.requestStreaming {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeating, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.repeating) -> Bool { + if lhs.repeating != rhs.repeating {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestTypeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".requestTypeURL" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "requestTypeURL"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.replaceRepeatedFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".replaceRepeatedFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}replaceRepeatedFields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32618,31 +36421,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestTypeUR // 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.requestTypeURL) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.replaceRepeatedFields) }() default: break } } } func traverse(visitor: inout V) throws { - if self.requestTypeURL != 0 { - try visitor.visitSingularInt32Field(value: self.requestTypeURL, fieldNumber: 1) + if self.replaceRepeatedFields != 0 { + try visitor.visitSingularInt32Field(value: self.replaceRepeatedFields, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestTypeURL, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requestTypeURL) -> Bool { - if lhs.requestTypeURL != rhs.requestTypeURL {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.replaceRepeatedFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.replaceRepeatedFields) -> Bool { + if lhs.replaceRepeatedFields != rhs.replaceRepeatedFields {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requiredSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".requiredSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "requiredSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requestStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".requestStreaming" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}requestStreaming\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32650,31 +36451,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requiredSize: // 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.requiredSize) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.requestStreaming) }() default: break } } } func traverse(visitor: inout V) throws { - if self.requiredSize != 0 { - try visitor.visitSingularInt32Field(value: self.requiredSize, fieldNumber: 1) + if self.requestStreaming != 0 { + try visitor.visitSingularInt32Field(value: self.requestStreaming, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requiredSize, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.requiredSize) -> Bool { - if lhs.requiredSize != rhs.requiredSize {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requestStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requestStreaming) -> Bool { + if lhs.requestStreaming != rhs.requestStreaming {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".reservedName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "reservedName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requestTypeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".requestTypeURL" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}requestTypeURL\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32682,31 +36481,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedName: // 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.reservedName) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.requestTypeURL) }() default: break } } } func traverse(visitor: inout V) throws { - if self.reservedName != 0 { - try visitor.visitSingularInt32Field(value: self.reservedName, fieldNumber: 1) + if self.requestTypeURL != 0 { + try visitor.visitSingularInt32Field(value: self.requestTypeURL, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedName) -> Bool { - if lhs.reservedName != rhs.reservedName {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requestTypeURL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requestTypeURL) -> Bool { + if lhs.requestTypeURL != rhs.requestTypeURL {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedRange: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".reservedRange" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "reservedRange"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requiredSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".requiredSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}requiredSize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32714,31 +36511,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedRange // 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.reservedRange) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.requiredSize) }() default: break } } } func traverse(visitor: inout V) throws { - if self.reservedRange != 0 { - try visitor.visitSingularInt32Field(value: self.reservedRange, fieldNumber: 1) + if self.requiredSize != 0 { + try visitor.visitSingularInt32Field(value: self.requiredSize, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedRange, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.reservedRange) -> Bool { - if lhs.reservedRange != rhs.reservedRange {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requiredSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.requiredSize) -> Bool { + if lhs.requiredSize != rhs.requiredSize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".responseStreaming" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "responseStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.responseStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".responseStreaming" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}responseStreaming\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32759,18 +36554,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseStrea try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseStreaming, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseStreaming) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.responseStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.responseStreaming) -> Bool { if lhs.responseStreaming != rhs.responseStreaming {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseTypeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".responseTypeURL" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "responseTypeURL"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.responseTypeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".responseTypeURL" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}responseTypeURL\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32791,18 +36584,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseTypeU try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseTypeURL, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.responseTypeURL) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.responseTypeURL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.responseTypeURL) -> Bool { if lhs.responseTypeURL != rhs.responseTypeURL {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.result: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".result" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "result"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.result: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".result" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}result\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32823,18 +36614,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.result: Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.result, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.result) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.result, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.result) -> Bool { if lhs.result != rhs.result {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rethrowsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".rethrows" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "rethrows"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.retention: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".retention" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}retention\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32842,31 +36631,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rethrowsMessa // 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.`rethrows`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.retention) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`rethrows` != 0 { - try visitor.visitSingularInt32Field(value: self.`rethrows`, fieldNumber: 1) + if self.retention != 0 { + try visitor.visitSingularInt32Field(value: self.retention, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rethrowsMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rethrowsMessage) -> Bool { - if lhs.`rethrows` != rhs.`rethrows` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.retention, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.retention) -> Bool { + if lhs.retention != rhs.retention {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.returnMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".return" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "return"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rethrowsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".rethrows" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}rethrows\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32874,31 +36661,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.returnMessage // 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.`return`) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.`rethrows`) }() default: break } } } func traverse(visitor: inout V) throws { - if self.`return` != 0 { - try visitor.visitSingularInt32Field(value: self.`return`, fieldNumber: 1) + if self.`rethrows` != 0 { + try visitor.visitSingularInt32Field(value: self.`rethrows`, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.returnMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.returnMessage) -> Bool { - if lhs.`return` != rhs.`return` {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rethrowsMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rethrowsMessage) -> Bool { + if lhs.`rethrows` != rhs.`rethrows` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ReturnType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ReturnType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ReturnType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ReturnType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ReturnType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ReturnType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32919,18 +36704,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ReturnType: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ReturnType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ReturnType) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ReturnType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ReturnType) -> Bool { if lhs.returnType != rhs.returnType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.revision: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".revision" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "revision"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.revision: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".revision" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}revision\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32951,18 +36734,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.revision: Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.revision, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.revision) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.revision, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.revision) -> Bool { if lhs.revision != rhs.revision {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rhs: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".rhs" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "rhs"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rhs: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".rhs" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}rhs\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -32983,18 +36764,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rhs: SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rhs, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rhs) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rhs, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rhs) -> Bool { if lhs.rhs != rhs.rhs {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.root: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".root" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "root"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.root: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".root" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}root\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33015,18 +36794,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.root: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.root, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.root) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.root, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.root) -> Bool { if lhs.root != rhs.root {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rubyPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".rubyPackage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "rubyPackage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rubyPackage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".rubyPackage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}rubyPackage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33047,18 +36824,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rubyPackage: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rubyPackage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.rubyPackage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rubyPackage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.rubyPackage) -> Bool { if lhs.rubyPackage != rhs.rubyPackage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.s: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".s" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "s"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.s: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".s" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}s\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33079,18 +36854,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.s: SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.s, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.s) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.s, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.s) -> Bool { if lhs.s != rhs.s {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawBackslash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".sawBackslash" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sawBackslash"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawBackslash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sawBackslash" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sawBackslash\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33111,18 +36884,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawBackslash: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawBackslash, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawBackslash) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawBackslash, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawBackslash) -> Bool { if lhs.sawBackslash != rhs.sawBackslash {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection4Characters: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".sawSection4Characters" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sawSection4Characters"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection4Characters: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sawSection4Characters" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sawSection4Characters\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33143,18 +36914,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection4Ch try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection4Characters, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection4Characters) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection4Characters, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection4Characters) -> Bool { if lhs.sawSection4Characters != rhs.sawSection4Characters {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection5Characters: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".sawSection5Characters" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sawSection5Characters"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection5Characters: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sawSection5Characters" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sawSection5Characters\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33175,18 +36944,76 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection5Ch try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection5Characters, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sawSection5Characters) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection5Characters, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sawSection5Characters) -> Bool { if lhs.sawSection5Characters != rhs.sawSection5Characters {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.scanner: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".scanner" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "scanner"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Scalar: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Scalar" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Scalar\0") + + 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.scalar) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.scalar != 0 { + try visitor.visitSingularInt32Field(value: self.scalar, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Scalar, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Scalar) -> Bool { + if lhs.scalar != rhs.scalar {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scan: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".scan" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}scan\0") + + 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.scan) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.scan != 0 { + try visitor.visitSingularInt32Field(value: self.scan, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scan, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scan) -> Bool { + if lhs.scan != rhs.scan {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scanner: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".scanner" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}scanner\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33207,18 +37034,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.scanner: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.scanner, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.scanner) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scanner, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.scanner) -> Bool { if lhs.scanner != rhs.scanner {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.seconds: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".seconds" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "seconds"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.seconds: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".seconds" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}seconds\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33239,18 +37064,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.seconds: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.seconds, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.seconds) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.seconds, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.seconds) -> Bool { if lhs.seconds != rhs.seconds {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.selfMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".self" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "self"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.selfMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".self" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}self\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33271,18 +37094,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.selfMessage: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.selfMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.selfMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.selfMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.selfMessage) -> Bool { if lhs.self_p != rhs.self_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.separator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".separator" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "separator"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.semantic: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".semantic" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}semantic\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33290,31 +37111,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.separator: Sw // 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.separator) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.semantic) }() default: break } } } func traverse(visitor: inout V) throws { - if self.separator != 0 { - try visitor.visitSingularInt32Field(value: self.separator, fieldNumber: 1) + if self.semantic != 0 { + try visitor.visitSingularInt32Field(value: self.semantic, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.separator, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.separator) -> Bool { - if lhs.separator != rhs.separator {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.semantic, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.semantic) -> Bool { + if lhs.semantic != rhs.semantic {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serialize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".serialize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "serialize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SendableMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Sendable" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Sendable\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33322,31 +37141,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serialize: Sw // 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.serialize) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.sendable) }() default: break } } } func traverse(visitor: inout V) throws { - if self.serialize != 0 { - try visitor.visitSingularInt32Field(value: self.serialize, fieldNumber: 1) + if self.sendable != 0 { + try visitor.visitSingularInt32Field(value: self.sendable, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serialize, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serialize) -> Bool { - if lhs.serialize != rhs.serialize {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SendableMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SendableMessage) -> Bool { + if lhs.sendable != rhs.sendable {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".serializedData" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "serializedData"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.separator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".separator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}separator\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33354,31 +37171,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedDat // 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.serializedData) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.separator) }() default: break } } } func traverse(visitor: inout V) throws { - if self.serializedData != 0 { - try visitor.visitSingularInt32Field(value: self.serializedData, fieldNumber: 1) + if self.separator != 0 { + try visitor.visitSingularInt32Field(value: self.separator, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedData, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedData) -> Bool { - if lhs.serializedData != rhs.serializedData {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.separator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.separator) -> Bool { + if lhs.separator != rhs.separator {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".serializedSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "serializedSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serialize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serialize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}serialize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33386,31 +37201,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedSiz // 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.serializedSize) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.serialize) }() default: break } } } func traverse(visitor: inout V) throws { - if self.serializedSize != 0 { - try visitor.visitSingularInt32Field(value: self.serializedSize, fieldNumber: 1) + if self.serialize != 0 { + try visitor.visitSingularInt32Field(value: self.serialize, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedSize, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serializedSize) -> Bool { - if lhs.serializedSize != rhs.serializedSize {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serialize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serialize) -> Bool { + if lhs.serialize != rhs.serialize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serverStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".serverStreaming" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "serverStreaming"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serializedBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}serializedBytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33418,31 +37231,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serverStreami // 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.serverStreaming) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.serializedBytes) }() default: break } } } func traverse(visitor: inout V) throws { - if self.serverStreaming != 0 { - try visitor.visitSingularInt32Field(value: self.serverStreaming, fieldNumber: 1) + if self.serializedBytes != 0 { + try visitor.visitSingularInt32Field(value: self.serializedBytes, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serverStreaming, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.serverStreaming) -> Bool { - if lhs.serverStreaming != rhs.serverStreaming {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedBytes) -> Bool { + if lhs.serializedBytes != rhs.serializedBytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.service: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".service" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "service"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serializedData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}serializedData\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33450,31 +37261,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.service: Swif // 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.service) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.serializedData) }() default: break } } } func traverse(visitor: inout V) throws { - if self.service != 0 { - try visitor.visitSingularInt32Field(value: self.service, fieldNumber: 1) + if self.serializedData != 0 { + try visitor.visitSingularInt32Field(value: self.serializedData, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.service, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.service) -> Bool { - if lhs.service != rhs.service {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedData, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedData) -> Bool { + if lhs.serializedData != rhs.serializedData {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceDescriptorProto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ServiceDescriptorProto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ServiceDescriptorProto"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serializedSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}serializedSize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33482,31 +37291,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceDescri // 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.serviceDescriptorProto) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.serializedSize) }() default: break } } } func traverse(visitor: inout V) throws { - if self.serviceDescriptorProto != 0 { - try visitor.visitSingularInt32Field(value: self.serviceDescriptorProto, fieldNumber: 1) + if self.serializedSize != 0 { + try visitor.visitSingularInt32Field(value: self.serializedSize, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceDescriptorProto, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceDescriptorProto) -> Bool { - if lhs.serviceDescriptorProto != rhs.serviceDescriptorProto {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serializedSize) -> Bool { + if lhs.serializedSize != rhs.serializedSize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ServiceOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ServiceOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serverStreaming: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".serverStreaming" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}serverStreaming\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33514,31 +37321,59 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceOption // 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.serviceOptions) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.serverStreaming) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.serverStreaming != 0 { + try visitor.visitSingularInt32Field(value: self.serverStreaming, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serverStreaming, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.serverStreaming) -> Bool { + if lhs.serverStreaming != rhs.serverStreaming {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.service: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".service" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}service\0") + + 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.service) }() default: break } } } func traverse(visitor: inout V) throws { - if self.serviceOptions != 0 { - try visitor.visitSingularInt32Field(value: self.serviceOptions, fieldNumber: 1) + if self.service != 0 { + try visitor.visitSingularInt32Field(value: self.service, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ServiceOptions) -> Bool { - if lhs.serviceOptions != rhs.serviceOptions {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.service, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.service) -> Bool { + if lhs.service != rhs.service {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.set: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".set" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "set"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.set: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".set" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}set\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33559,18 +37394,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.set: SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.set, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.set) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.set, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.set) -> Bool { if lhs.set != rhs.set {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.setExtensionValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".setExtensionValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "setExtensionValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.setExtensionValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".setExtensionValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}setExtensionValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33591,18 +37424,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.setExtensionV try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.setExtensionValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.setExtensionValue) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.setExtensionValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.setExtensionValue) -> Bool { if lhs.setExtensionValue != rhs.setExtensionValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.shift: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".shift" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "shift"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.shift: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".shift" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}shift\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33623,18 +37454,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.shift: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.shift, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.shift) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.shift, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.shift) -> Bool { if lhs.shift != rhs.shift {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SimpleExtensionMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".SimpleExtensionMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "SimpleExtensionMap"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SimpleExtensionMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".SimpleExtensionMap" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}SimpleExtensionMap\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33655,18 +37484,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SimpleExtensi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SimpleExtensionMap, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SimpleExtensionMap) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SimpleExtensionMap, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SimpleExtensionMap) -> Bool { if lhs.simpleExtensionMap != rhs.simpleExtensionMap {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sizer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".sizer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sizer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.size: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".size" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}size\0") + + 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.size) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.size != 0 { + try visitor.visitSingularInt32Field(value: self.size, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.size, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.size) -> Bool { + if lhs.size != rhs.size {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sizer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sizer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sizer\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33687,18 +37544,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sizer: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sizer, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sizer) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sizer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sizer) -> Bool { if lhs.sizer != rhs.sizer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.source: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".source" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "source"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.source: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".source" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}source\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33719,18 +37574,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.source: Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.source, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.source) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.source, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.source) -> Bool { if lhs.source != rhs.source {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".sourceCodeInfo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sourceCodeInfo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceCodeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sourceCodeInfo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sourceCodeInfo\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33751,18 +37604,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceCodeInf try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceCodeInfo, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceCodeInfo) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceCodeInfo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceCodeInfo) -> Bool { if lhs.sourceCodeInfo != rhs.sourceCodeInfo {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceContext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".sourceContext" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sourceContext"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceContext: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sourceContext" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sourceContext\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33783,18 +37634,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceContext try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceContext, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceContext) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceContext, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceContext) -> Bool { if lhs.sourceContext != rhs.sourceContext {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceEncoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".sourceEncoding" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sourceEncoding"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceEncoding: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sourceEncoding" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sourceEncoding\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33815,18 +37664,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceEncodin try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceEncoding, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceEncoding) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceEncoding, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceEncoding) -> Bool { if lhs.sourceEncoding != rhs.sourceEncoding {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceFile: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".sourceFile" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sourceFile"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceFile: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".sourceFile" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sourceFile\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33847,18 +37694,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceFile: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceFile, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.sourceFile) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceFile, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.sourceFile) -> Bool { if lhs.sourceFile != rhs.sourceFile {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.span: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".span" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "span"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SourceLocation: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".SourceLocation" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}SourceLocation\0") + + 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.sourceLocation) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.sourceLocation != 0 { + try visitor.visitSingularInt32Field(value: self.sourceLocation, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SourceLocation, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SourceLocation) -> Bool { + if lhs.sourceLocation != rhs.sourceLocation {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.span: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".span" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}span\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33879,18 +37754,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.span: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.span, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.span) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.span, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.span) -> Bool { if lhs.span != rhs.span {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.split: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".split" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "split"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.split: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".split" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}split\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33911,18 +37784,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.split: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.split, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.split) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.split, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.split) -> Bool { if lhs.split != rhs.split {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.start: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".start" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "start"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.start: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".start" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}start\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33943,18 +37814,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.start: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.start, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.start) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.start, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.start) -> Bool { if lhs.start != rhs.start {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArray: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".startArray" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "startArray"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startArray: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".startArray" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}startArray\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -33975,18 +37844,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArray: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArray, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArray) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startArray, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startArray) -> Bool { if lhs.startArray != rhs.startArray {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArrayObject: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".startArrayObject" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "startArrayObject"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startArrayObject: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".startArrayObject" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}startArrayObject\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34007,18 +37874,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArrayObj try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArrayObject, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startArrayObject) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startArrayObject, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startArrayObject) -> Bool { if lhs.startArrayObject != rhs.startArrayObject {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".startField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "startField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".startField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}startField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34039,18 +37904,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startField: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startField) -> Bool { if lhs.startField != rhs.startField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startIndex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".startIndex" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "startIndex"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startIndex: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".startIndex" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}startIndex\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34071,18 +37934,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startIndex: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startIndex, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startIndex) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startIndex, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startIndex) -> Bool { if lhs.startIndex != rhs.startIndex {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".startMessageField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "startMessageField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".startMessageField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}startMessageField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34103,18 +37964,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startMessageF try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startMessageField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startMessageField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startMessageField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startMessageField) -> Bool { if lhs.startMessageField != rhs.startMessageField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startObject: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".startObject" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "startObject"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startObject: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".startObject" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}startObject\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34135,18 +37994,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startObject: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startObject, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startObject) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startObject, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startObject) -> Bool { if lhs.startObject != rhs.startObject {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startRegularField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".startRegularField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "startRegularField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startRegularField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".startRegularField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}startRegularField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34167,18 +38024,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startRegularF try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startRegularField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.startRegularField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startRegularField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.startRegularField) -> Bool { if lhs.startRegularField != rhs.startRegularField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.state: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".state" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "state"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.state: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".state" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}state\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34199,18 +38054,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.state: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.state, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.state) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.state, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.state) -> Bool { if lhs.state != rhs.state {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.staticMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".static" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "static"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.staticMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".static" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}static\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34231,18 +38084,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.staticMessage try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.staticMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.staticMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.staticMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.staticMessage) -> Bool { if lhs.`static` != rhs.`static` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StaticString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".StaticString" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "StaticString"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StaticString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".StaticString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}StaticString\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34263,18 +38114,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StaticString: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StaticString, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StaticString) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StaticString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StaticString) -> Bool { if lhs.staticString != rhs.staticString {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.storage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".storage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "storage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.storage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".storage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}storage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34295,18 +38144,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.storage: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.storage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.storage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.storage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.storage) -> Bool { if lhs.storage != rhs.storage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".String" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "String"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StringMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".String" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}String\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34327,18 +38174,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringMessage try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StringMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StringMessage) -> Bool { if lhs.string != rhs.string {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".stringLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "stringLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".stringLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}stringLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34359,18 +38204,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringLiteral try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringLiteral) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringLiteral) -> Bool { if lhs.stringLiteral != rhs.stringLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".StringLiteralType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "StringLiteralType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StringLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".StringLiteralType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}StringLiteralType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34391,18 +38234,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringLiteral try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringLiteralType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.StringLiteralType) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StringLiteralType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.StringLiteralType) -> Bool { if lhs.stringLiteralType != rhs.stringLiteralType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".stringResult" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "stringResult"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".stringResult" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}stringResult\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34423,18 +38264,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringResult: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringResult, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringResult) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringResult, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringResult) -> Bool { if lhs.stringResult != rhs.stringResult {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".stringValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "stringValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".stringValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}stringValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34455,18 +38294,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringValue: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.stringValue) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.stringValue) -> Bool { if lhs.stringValue != rhs.stringValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".struct" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "struct"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.structMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".struct" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}struct\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34487,18 +38324,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structMessage try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.structMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.structMessage) -> Bool { if lhs.`struct` != rhs.`struct` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".structValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "structValue"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.structValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".structValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}structValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34519,18 +38354,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structValue: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structValue, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.structValue) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.structValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.structValue) -> Bool { if lhs.structValue != rhs.structValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".subDecoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "subDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".subDecoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}subDecoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34551,18 +38384,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subDecoder: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subDecoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subDecoder) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subDecoder) -> Bool { if lhs.subDecoder != rhs.subDecoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subscriptMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".subscript" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "subscript"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subscriptMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".subscript" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}subscript\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34583,18 +38414,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subscriptMess try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subscriptMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subscriptMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subscriptMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subscriptMessage) -> Bool { if lhs.`subscript` != rhs.`subscript` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".subVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "subVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subtract: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".subtract" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}subtract\0") + + 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.subtract) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.subtract != 0 { + try visitor.visitSingularInt32Field(value: self.subtract, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subtract, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subtract) -> Bool { + if lhs.subtract != rhs.subtract {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".subVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}subVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34615,18 +38474,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subVisitor: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.subVisitor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.subVisitor) -> Bool { if lhs.subVisitor != rhs.subVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Swift: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Swift" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Swift"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Swift" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Swift\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34647,18 +38504,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Swift: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Swift, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Swift) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftMessage) -> Bool { if lhs.swift != rhs.swift {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.swiftPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".swiftPrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "swiftPrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.swiftPrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".swiftPrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}swiftPrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34679,18 +38534,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.swiftPrefix: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.swiftPrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.swiftPrefix) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.swiftPrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.swiftPrefix) -> Bool { if lhs.swiftPrefix != rhs.swiftPrefix {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SwiftProtobufMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".SwiftProtobuf" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "SwiftProtobuf"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftProtobufContiguousBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".SwiftProtobufContiguousBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}SwiftProtobufContiguousBytes\0") + + 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.swiftProtobufContiguousBytes) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.swiftProtobufContiguousBytes != 0 { + try visitor.visitSingularInt32Field(value: self.swiftProtobufContiguousBytes, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftProtobufContiguousBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftProtobufContiguousBytes) -> Bool { + if lhs.swiftProtobufContiguousBytes != rhs.swiftProtobufContiguousBytes {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftProtobufError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".SwiftProtobufError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}SwiftProtobufError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34698,31 +38581,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SwiftProtobuf // 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.swiftProtobuf) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.swiftProtobufError) }() default: break } } } func traverse(visitor: inout V) throws { - if self.swiftProtobuf != 0 { - try visitor.visitSingularInt32Field(value: self.swiftProtobuf, fieldNumber: 1) + if self.swiftProtobufError != 0 { + try visitor.visitSingularInt32Field(value: self.swiftProtobufError, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SwiftProtobufMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.SwiftProtobufMessage) -> Bool { - if lhs.swiftProtobuf != rhs.swiftProtobuf {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftProtobufError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.SwiftProtobufError) -> Bool { + if lhs.swiftProtobufError != rhs.swiftProtobufError {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.syntax: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".syntax" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "syntax"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.syntax: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".syntax" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}syntax\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34743,18 +38624,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.syntax: Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.syntax, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.syntax) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.syntax, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.syntax) -> Bool { if lhs.syntax != rhs.syntax {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.T: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".T" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "T"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.T: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".T" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}T\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34775,18 +38654,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.T: SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.T, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.T) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.T, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.T) -> Bool { if lhs.t != rhs.t {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tag: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".tag" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "tag"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tag: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".tag" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}tag\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34807,18 +38684,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tag: SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tag, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tag) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tag, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tag) -> Bool { if lhs.tag != rhs.tag {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.terminator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".terminator" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "terminator"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.targets: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".targets" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}targets\0") + + 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.targets) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.targets != 0 { + try visitor.visitSingularInt32Field(value: self.targets, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.targets, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.targets) -> Bool { + if lhs.targets != rhs.targets {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.terminator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".terminator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}terminator\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34839,18 +38744,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.terminator: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.terminator, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.terminator) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.terminator, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.terminator) -> Bool { if lhs.terminator != rhs.terminator {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.testDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".testDecoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "testDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.testDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".testDecoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}testDecoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34871,18 +38774,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.testDecoder: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.testDecoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.testDecoder) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.testDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.testDecoder) -> Bool { if lhs.testDecoder != rhs.testDecoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.text: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".text" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "text"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.text: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".text" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}text\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34903,18 +38804,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.text: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.text, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.text) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.text, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.text) -> Bool { if lhs.text != rhs.text {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".textDecoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "textDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.textDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".textDecoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}textDecoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34935,18 +38834,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textDecoder: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textDecoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textDecoder) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.textDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.textDecoder) -> Bool { if lhs.textDecoder != rhs.textDecoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatDecoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TextFormatDecoder"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatDecoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}TextFormatDecoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34967,18 +38864,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDec try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecoder, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecoder) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecoder, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecoder) -> Bool { if lhs.textFormatDecoder != rhs.textFormatDecoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatDecodingError" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TextFormatDecodingError"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecodingError: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatDecodingError" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}TextFormatDecodingError\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -34999,18 +38894,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDec try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecodingError, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecodingError) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecodingError, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecodingError) -> Bool { if lhs.textFormatDecodingError != rhs.textFormatDecodingError {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatDecodingOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TextFormatDecodingOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatDecodingOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}TextFormatDecodingOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35031,18 +38924,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDec try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecodingOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatDecodingOptions) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecodingOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatDecodingOptions) -> Bool { if lhs.textFormatDecodingOptions != rhs.textFormatDecodingOptions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEncodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatEncodingOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TextFormatEncodingOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatEncodingOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatEncodingOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}TextFormatEncodingOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35063,18 +38954,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEnc try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEncodingOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEncodingOptions) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatEncodingOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatEncodingOptions) -> Bool { if lhs.textFormatEncodingOptions != rhs.textFormatEncodingOptions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEncodingVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatEncodingVisitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TextFormatEncodingVisitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatEncodingVisitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".TextFormatEncodingVisitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}TextFormatEncodingVisitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35095,18 +38984,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEnc try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEncodingVisitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TextFormatEncodingVisitor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatEncodingVisitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TextFormatEncodingVisitor) -> Bool { if lhs.textFormatEncodingVisitor != rhs.textFormatEncodingVisitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textFormatString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".textFormatString" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "textFormatString"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.textFormatString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".textFormatString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}textFormatString\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35127,18 +39014,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textFormatStr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textFormatString, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.textFormatString) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.textFormatString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.textFormatString) -> Bool { if lhs.textFormatString != rhs.textFormatString {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.throwsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".throws" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "throws"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.throwOrIgnore: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".throwOrIgnore" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}throwOrIgnore\0") + + 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.throwOrIgnore) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.throwOrIgnore != 0 { + try visitor.visitSingularInt32Field(value: self.throwOrIgnore, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.throwOrIgnore, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.throwOrIgnore) -> Bool { + if lhs.throwOrIgnore != rhs.throwOrIgnore {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.throwsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".throws" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}throws\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35159,18 +39074,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.throwsMessage try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.throwsMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.throwsMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.throwsMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.throwsMessage) -> Bool { if lhs.`throws` != rhs.`throws` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeInterval: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".timeInterval" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "timeInterval"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeInterval: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".timeInterval" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}timeInterval\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35191,18 +39104,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeInterval: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeInterval, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeInterval) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeInterval, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeInterval) -> Bool { if lhs.timeInterval != rhs.timeInterval {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalSince1970: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".timeIntervalSince1970" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "timeIntervalSince1970"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeIntervalSince1970: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".timeIntervalSince1970" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}timeIntervalSince1970\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35223,18 +39134,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalS try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalSince1970, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalSince1970) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeIntervalSince1970, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeIntervalSince1970) -> Bool { if lhs.timeIntervalSince1970 != rhs.timeIntervalSince1970 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalSinceReferenceDate: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".timeIntervalSinceReferenceDate" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "timeIntervalSinceReferenceDate"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeIntervalSinceReferenceDate: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".timeIntervalSinceReferenceDate" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}timeIntervalSinceReferenceDate\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35255,18 +39164,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalS try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalSinceReferenceDate, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.timeIntervalSinceReferenceDate) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeIntervalSinceReferenceDate, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.timeIntervalSinceReferenceDate) -> Bool { if lhs.timeIntervalSinceReferenceDate != rhs.timeIntervalSinceReferenceDate {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Timestamp: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Timestamp" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Timestamp"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tmp: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".tmp" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}tmp\0") + + 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.tmp) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.tmp != 0 { + try visitor.visitSingularInt32Field(value: self.tmp, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tmp, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tmp) -> Bool { + if lhs.tmp != rhs.tmp {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tooLarge: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".tooLarge" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}tooLarge\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35274,31 +39211,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Timestamp: Sw // 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.timestamp) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.tooLarge) }() default: break } } } func traverse(visitor: inout V) throws { - if self.timestamp != 0 { - try visitor.visitSingularInt32Field(value: self.timestamp, fieldNumber: 1) + if self.tooLarge != 0 { + try visitor.visitSingularInt32Field(value: self.tooLarge, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Timestamp, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Timestamp) -> Bool { - if lhs.timestamp != rhs.timestamp {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tooLarge, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tooLarge) -> Bool { + if lhs.tooLarge != rhs.tooLarge {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.total: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".total" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "total"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.total: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".total" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}total\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35319,18 +39254,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.total: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.total, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.total) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.total, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.total) -> Bool { if lhs.total != rhs.total {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalArrayDepth: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".totalArrayDepth" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "totalArrayDepth"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.totalArrayDepth: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".totalArrayDepth" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}totalArrayDepth\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35351,18 +39284,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalArrayDep try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalArrayDepth, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalArrayDepth) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.totalArrayDepth, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.totalArrayDepth) -> Bool { if lhs.totalArrayDepth != rhs.totalArrayDepth {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".totalSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "totalSize"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.totalSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".totalSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}totalSize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35383,18 +39314,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalSize: Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalSize, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.totalSize) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.totalSize, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.totalSize) -> Bool { if lhs.totalSize != rhs.totalSize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trailingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".trailingComments" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "trailingComments"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trailingComments: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".trailingComments" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}trailingComments\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35415,18 +39344,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trailingComme try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trailingComments, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trailingComments) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trailingComments, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trailingComments) -> Bool { if lhs.trailingComments != rhs.trailingComments {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.traverseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".traverse" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "traverse"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.traverseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".traverse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}traverse\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35447,18 +39374,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.traverseMessa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.traverseMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.traverseMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.traverseMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.traverseMessage) -> Bool { if lhs.traverse != rhs.traverse {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trueMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".true" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "true"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trim: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".trim" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}trim\0") + + 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.trim) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.trim != 0 { + try visitor.visitSingularInt32Field(value: self.trim, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trim, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trim) -> Bool { + if lhs.trim != rhs.trim {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trueMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".true" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}true\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35479,18 +39434,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trueMessage: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trueMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.trueMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trueMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.trueMessage) -> Bool { if lhs.`true` != rhs.`true` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tryMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".try" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "try"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tryMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".try" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}try\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35511,18 +39464,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tryMessage: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tryMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.tryMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tryMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.tryMessage) -> Bool { if lhs.`try` != rhs.`try` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.type: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".type" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "type"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.type: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".type" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}type\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35543,18 +39494,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.type: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.type, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.type) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.type, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.type) -> Bool { if lhs.type != rhs.type {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typealiasMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".typealias" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typealias"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typealiasMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".typealias" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typealias\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35575,18 +39524,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typealiasMess try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typealiasMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typealiasMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typealiasMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typealiasMessage) -> Bool { if lhs.`typealias` != rhs.`typealias` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TypeEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".TypeEnum" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TypeEnum"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TypeEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".TypeEnum" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}TypeEnum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35607,18 +39554,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TypeEnum: Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TypeEnum, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.TypeEnum) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TypeEnum, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.TypeEnum) -> Bool { if lhs.typeEnum != rhs.typeEnum {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".typeName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typeName"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".typeName" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typeName\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35639,18 +39584,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeName: Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeName, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeName) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeName, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeName) -> Bool { if lhs.typeName != rhs.typeName {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typePrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".typePrefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typePrefix"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typePrefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".typePrefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typePrefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35671,18 +39614,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typePrefix: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typePrefix, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typePrefix) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typePrefix, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typePrefix) -> Bool { if lhs.typePrefix != rhs.typePrefix {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeStart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".typeStart" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typeStart"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeStart: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".typeStart" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typeStart\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35703,18 +39644,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeStart: Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeStart, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeStart) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeStart, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeStart) -> Bool { if lhs.typeStart != rhs.typeStart {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeUnknown: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".typeUnknown" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typeUnknown"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeUnknown: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".typeUnknown" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typeUnknown\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35735,18 +39674,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeUnknown: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeUnknown, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeUnknown) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeUnknown, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeUnknown) -> Bool { if lhs.typeUnknown != rhs.typeUnknown {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".typeURL" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typeURL"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeURL: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".typeURL" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typeURL\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35767,18 +39704,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeURL: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeURL, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.typeURL) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeURL, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.typeURL) -> Bool { if lhs.typeURL != rhs.typeURL {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt32Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UInt32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UInt32"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt32Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UInt32" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UInt32\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35799,50 +39734,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt32Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt32Message, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt32Message) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt32Message, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt32Message) -> Bool { if lhs.uint32 != rhs.uint32 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt32Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UInt32Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UInt32Value"), - ] - - 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.uint32Value) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if self.uint32Value != 0 { - try visitor.visitSingularInt32Field(value: self.uint32Value, fieldNumber: 1) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt32Value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt32Value) -> Bool { - if lhs.uint32Value != rhs.uint32Value {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UInt64" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UInt64"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt64Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UInt64" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UInt64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35863,18 +39764,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Message, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Message) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt64Message, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt64Message) -> Bool { if lhs.uint64 != rhs.uint64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UInt64Value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UInt64Value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UInt8" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UInt8\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35882,31 +39781,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Value: // 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.uint64Value) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.uint8) }() default: break } } } func traverse(visitor: inout V) throws { - if self.uint64Value != 0 { - try visitor.visitSingularInt32Field(value: self.uint64Value, fieldNumber: 1) + if self.uint8 != 0 { + try visitor.visitSingularInt32Field(value: self.uint8, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt64Value) -> Bool { - if lhs.uint64Value != rhs.uint64Value {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt8, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UInt8) -> Bool { + if lhs.uint8 != rhs.uint8 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UInt8" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UInt8"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unchecked: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".unchecked" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unchecked\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35914,31 +39811,59 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt8: SwiftP // 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.uint8) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.unchecked) }() default: break } } } func traverse(visitor: inout V) throws { - if self.uint8 != 0 { - try visitor.visitSingularInt32Field(value: self.uint8, fieldNumber: 1) + if self.unchecked != 0 { + try visitor.visitSingularInt32Field(value: self.unchecked, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt8, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UInt8) -> Bool { - if lhs.uint8 != rhs.uint8 {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unchecked, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unchecked) -> Bool { + if lhs.unchecked != rhs.unchecked {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Unicode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Unicode" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Unicode\0") + + 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.unicode) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.unicode != 0 { + try visitor.visitSingularInt32Field(value: self.unicode, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Unicode, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Unicode) -> Bool { + if lhs.unicode != rhs.unicode {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalarLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".unicodeScalarLiteral" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "unicodeScalarLiteral"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unicodeScalarLiteral: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".unicodeScalarLiteral" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unicodeScalarLiteral\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35959,18 +39884,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalar try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalarLiteral, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalarLiteral) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unicodeScalarLiteral, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unicodeScalarLiteral) -> Bool { if lhs.unicodeScalarLiteral != rhs.unicodeScalarLiteral {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalarLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UnicodeScalarLiteralType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UnicodeScalarLiteralType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnicodeScalarLiteralType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UnicodeScalarLiteralType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UnicodeScalarLiteralType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -35991,18 +39914,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalar try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalarLiteralType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalarLiteralType) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnicodeScalarLiteralType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnicodeScalarLiteralType) -> Bool { if lhs.unicodeScalarLiteralType != rhs.unicodeScalarLiteralType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalars: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".unicodeScalars" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "unicodeScalars"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unicodeScalars: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".unicodeScalars" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unicodeScalars\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36023,18 +39944,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalar try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalars, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unicodeScalars) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unicodeScalars, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unicodeScalars) -> Bool { if lhs.unicodeScalars != rhs.unicodeScalars {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalarView: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UnicodeScalarView" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UnicodeScalarView"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnicodeScalarView: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UnicodeScalarView" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UnicodeScalarView\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36055,18 +39974,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalar try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalarView, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnicodeScalarView) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnicodeScalarView, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnicodeScalarView) -> Bool { if lhs.unicodeScalarView != rhs.unicodeScalarView {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uninterpretedOption: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".uninterpretedOption" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "uninterpretedOption"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uninterpretedOption: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".uninterpretedOption" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}uninterpretedOption\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36087,18 +40004,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uninterpreted try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uninterpretedOption, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uninterpretedOption) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uninterpretedOption, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uninterpretedOption) -> Bool { if lhs.uninterpretedOption != rhs.uninterpretedOption {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.union: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".union" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "union"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.union: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".union" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}union\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36119,18 +40034,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.union: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.union, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.union) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.union, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.union) -> Bool { if lhs.union != rhs.union {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uniqueStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".uniqueStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "uniqueStorage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uniqueStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".uniqueStorage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}uniqueStorage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36151,18 +40064,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uniqueStorage try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uniqueStorage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.uniqueStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uniqueStorage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uniqueStorage) -> Bool { if lhs.uniqueStorage != rhs.uniqueStorage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknown: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".unknown" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "unknown"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unknown: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".unknown" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unknown\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36183,18 +40094,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknown: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknown, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknown) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unknown, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unknown) -> Bool { if lhs.unknown != rhs.unknown {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknownFieldsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".unknownFields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "unknownFields"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unknownFieldsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".unknownFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unknownFields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36215,18 +40124,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknownFields try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknownFieldsMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unknownFieldsMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unknownFieldsMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unknownFieldsMessage) -> Bool { if lhs.unknownFields_p != rhs.unknownFields_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnknownStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UnknownStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UnknownStorage"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnknownStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UnknownStorage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UnknownStorage\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36247,18 +40154,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnknownStorag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnknownStorage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnknownStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnknownStorage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnknownStorage) -> Bool { if lhs.unknownStorage != rhs.unknownStorage {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unpackTo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".unpackTo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "unpackTo"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unpackTo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".unpackTo" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unpackTo\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36279,18 +40184,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unpackTo: Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unpackTo, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.unpackTo) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unpackTo, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unpackTo) -> Bool { if lhs.unpackTo != rhs.unpackTo {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeBufferPointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeBufferPointer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UnsafeBufferPointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeBufferPointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeBufferPointer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UnsafeBufferPointer\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36311,18 +40214,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeBufferP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeBufferPointer, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeBufferPointer) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeBufferPointer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeBufferPointer) -> Bool { if lhs.unsafeBufferPointer != rhs.unsafeBufferPointer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutablePointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeMutablePointer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UnsafeMutablePointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeMutablePointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeMutablePointer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UnsafeMutablePointer\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36343,18 +40244,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutable try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutablePointer, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutablePointer) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeMutablePointer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeMutablePointer) -> Bool { if lhs.unsafeMutablePointer != rhs.unsafeMutablePointer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutableRawBufferPointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeMutableRawBufferPointer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UnsafeMutableRawBufferPointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeMutableRawBufferPointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeMutableRawBufferPointer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UnsafeMutableRawBufferPointer\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36375,18 +40274,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutable try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutableRawBufferPointer, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutableRawBufferPointer) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeMutableRawBufferPointer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeMutableRawBufferPointer) -> Bool { if lhs.unsafeMutableRawBufferPointer != rhs.unsafeMutableRawBufferPointer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutableRawPointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeMutableRawPointer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UnsafeMutableRawPointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeRawBufferPointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeRawBufferPointer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UnsafeRawBufferPointer\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36394,31 +40291,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutable // 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.unsafeMutableRawPointer) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.unsafeRawBufferPointer) }() default: break } } } func traverse(visitor: inout V) throws { - if self.unsafeMutableRawPointer != 0 { - try visitor.visitSingularInt32Field(value: self.unsafeMutableRawPointer, fieldNumber: 1) + if self.unsafeRawBufferPointer != 0 { + try visitor.visitSingularInt32Field(value: self.unsafeRawBufferPointer, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutableRawPointer, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeMutableRawPointer) -> Bool { - if lhs.unsafeMutableRawPointer != rhs.unsafeMutableRawPointer {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeRawBufferPointer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeRawBufferPointer) -> Bool { + if lhs.unsafeRawBufferPointer != rhs.unsafeRawBufferPointer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawBufferPointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeRawBufferPointer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UnsafeRawBufferPointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeRawPointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeRawPointer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UnsafeRawPointer\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36426,31 +40321,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawBuff // 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.unsafeRawBufferPointer) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.unsafeRawPointer) }() default: break } } } func traverse(visitor: inout V) throws { - if self.unsafeRawBufferPointer != 0 { - try visitor.visitSingularInt32Field(value: self.unsafeRawBufferPointer, fieldNumber: 1) + if self.unsafeRawPointer != 0 { + try visitor.visitSingularInt32Field(value: self.unsafeRawPointer, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawBufferPointer, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawBufferPointer) -> Bool { - if lhs.unsafeRawBufferPointer != rhs.unsafeRawBufferPointer {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeRawPointer, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UnsafeRawPointer) -> Bool { + if lhs.unsafeRawPointer != rhs.unsafeRawPointer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawPointer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UnsafeRawPointer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UnsafeRawPointer"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unverifiedLazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".unverifiedLazy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unverifiedLazy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36458,31 +40351,29 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawPoin // 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.unsafeRawPointer) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self.unverifiedLazy) }() default: break } } } func traverse(visitor: inout V) throws { - if self.unsafeRawPointer != 0 { - try visitor.visitSingularInt32Field(value: self.unsafeRawPointer, fieldNumber: 1) + if self.unverifiedLazy != 0 { + try visitor.visitSingularInt32Field(value: self.unverifiedLazy, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawPointer, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UnsafeRawPointer) -> Bool { - if lhs.unsafeRawPointer != rhs.unsafeRawPointer {return false} + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unverifiedLazy, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.unverifiedLazy) -> Bool { + if lhs.unverifiedLazy != rhs.unverifiedLazy {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.updatedOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".updatedOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "updatedOptions"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.updatedOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".updatedOptions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}updatedOptions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36503,18 +40394,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.updatedOption try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.updatedOptions, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.updatedOptions) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.updatedOptions, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.updatedOptions) -> Bool { if lhs.updatedOptions != rhs.updatedOptions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.url: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".url" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "url"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uppercasedAssumingASCII: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".uppercasedAssumingASCII" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}uppercasedAssumingASCII\0") + + 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.uppercasedAssumingAscii) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.uppercasedAssumingAscii != 0 { + try visitor.visitSingularInt32Field(value: self.uppercasedAssumingAscii, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uppercasedAssumingASCII, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.uppercasedAssumingASCII) -> Bool { + if lhs.uppercasedAssumingAscii != rhs.uppercasedAssumingAscii {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.url: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".url" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}url\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36535,18 +40454,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.url: SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.url, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.url) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.url, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.url) -> Bool { if lhs.url != rhs.url {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".utf8" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "utf8"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.useDeterministicOrdering: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".useDeterministicOrdering" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}useDeterministicOrdering\0") + + 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.useDeterministicOrdering) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.useDeterministicOrdering != 0 { + try visitor.visitSingularInt32Field(value: self.useDeterministicOrdering, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.useDeterministicOrdering, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.useDeterministicOrdering) -> Bool { + if lhs.useDeterministicOrdering != rhs.useDeterministicOrdering {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".utf8" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}utf8\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36567,18 +40514,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8) -> Bool { if lhs.utf8 != rhs.utf8 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8Ptr: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".utf8Ptr" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "utf8Ptr"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8Ptr: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".utf8Ptr" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}utf8Ptr\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36599,18 +40544,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8Ptr: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8Ptr, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8Ptr) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8Ptr, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8Ptr) -> Bool { if lhs.utf8Ptr != rhs.utf8Ptr {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8ToDouble: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".utf8ToDouble" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "utf8ToDouble"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8ToDouble: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".utf8ToDouble" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}utf8ToDouble\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36631,18 +40574,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8ToDouble: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8ToDouble, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.utf8ToDouble) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8ToDouble, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8ToDouble) -> Bool { if lhs.utf8ToDouble != rhs.utf8ToDouble {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UTF8View: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".UTF8View" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UTF8View"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8Validation: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".utf8Validation" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}utf8Validation\0") + + 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.utf8Validation) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.utf8Validation != 0 { + try visitor.visitSingularInt32Field(value: self.utf8Validation, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8Validation, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.utf8Validation) -> Bool { + if lhs.utf8Validation != rhs.utf8Validation {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UTF8View: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".UTF8View" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UTF8View\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36663,18 +40634,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UTF8View: Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UTF8View, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.UTF8View) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UTF8View, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.UTF8View) -> Bool { if lhs.utf8View != rhs.utf8View {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.v: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".v" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "v"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.V: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".V" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}V\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36695,18 +40664,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.v: SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.v, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.v) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.V, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.V) -> Bool { if lhs.v != rhs.v {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".value" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.value: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".value" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36727,18 +40694,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.value: SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.value, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.value) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.value, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.value) -> Bool { if lhs.value != rhs.value {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.valueField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".valueField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "valueField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.valueField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".valueField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}valueField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36759,18 +40724,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.valueField: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.valueField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.valueField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.valueField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.valueField) -> Bool { if lhs.valueField != rhs.valueField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.values: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".values" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "values"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.values: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".values" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}values\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36791,18 +40754,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.values: Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.values, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.values) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.values, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.values) -> Bool { if lhs.values != rhs.values {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ValueType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".ValueType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ValueType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ValueType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".ValueType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ValueType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36823,18 +40784,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ValueType: Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ValueType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.ValueType) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ValueType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.ValueType) -> Bool { if lhs.valueType != rhs.valueType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.varMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".var" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "var"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.varMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".var" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}var\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36855,18 +40814,76 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.varMessage: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.varMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.varMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.varMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.varMessage) -> Bool { if lhs.`var` != rhs.`var` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Version: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".Version" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Version"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.verification: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".verification" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}verification\0") + + 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.verification) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.verification != 0 { + try visitor.visitSingularInt32Field(value: self.verification, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.verification, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.verification) -> Bool { + if lhs.verification != rhs.verification {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.VerificationState: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".VerificationState" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}VerificationState\0") + + 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.verificationState) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.verificationState != 0 { + try visitor.visitSingularInt32Field(value: self.verificationState, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.VerificationState, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.VerificationState) -> Bool { + if lhs.verificationState != rhs.verificationState {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.version: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".version" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}version\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36887,18 +40904,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Version: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Version, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.Version) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.version, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.version) -> Bool { if lhs.version != rhs.version {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.versionString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".versionString" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "versionString"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.versionString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".versionString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}versionString\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36919,18 +40934,76 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.versionString try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.versionString, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.versionString) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.versionString, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.versionString) -> Bool { if lhs.versionString != rhs.versionString {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensionFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitExtensionFields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitExtensionFields"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visibility: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visibility" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visibility\0") + + 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.visibility) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.visibility != 0 { + try visitor.visitSingularInt32Field(value: self.visibility, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visibility, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visibility) -> Bool { + if lhs.visibility != rhs.visibility {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.VisibilityFeature: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".VisibilityFeature" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}VisibilityFeature\0") + + 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.visibilityFeature) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.visibilityFeature != 0 { + try visitor.visitSingularInt32Field(value: self.visibilityFeature, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.VisibilityFeature, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.VisibilityFeature) -> Bool { + if lhs.visibilityFeature != rhs.visibilityFeature {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitExtensionFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitExtensionFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitExtensionFields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36951,18 +41024,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensio try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensionFields, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensionFields) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitExtensionFields, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitExtensionFields) -> Bool { if lhs.visitExtensionFields != rhs.visitExtensionFields {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensionFieldsAsMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitExtensionFieldsAsMessageSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitExtensionFieldsAsMessageSet"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitExtensionFieldsAsMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitExtensionFieldsAsMessageSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitExtensionFieldsAsMessageSet\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -36983,18 +41054,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensio try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensionFieldsAsMessageSet, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitExtensionFieldsAsMessageSet) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitExtensionFieldsAsMessageSet, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitExtensionFieldsAsMessageSet) -> Bool { if lhs.visitExtensionFieldsAsMessageSet != rhs.visitExtensionFieldsAsMessageSet {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitMapField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitMapField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitMapField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitMapField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitMapField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitMapField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37015,18 +41084,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitMapField try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitMapField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitMapField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitMapField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitMapField) -> Bool { if lhs.visitMapField != rhs.visitMapField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitor"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Visitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Visitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Visitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37047,18 +41114,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitor: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitor, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Visitor, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Visitor) -> Bool { if lhs.visitor != rhs.visitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPacked: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPacked" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPacked"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPacked" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPacked\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37079,18 +41144,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPacked: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPacked, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPacked) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPacked) -> Bool { if lhs.visitPacked != rhs.visitPacked {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedBoolField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedBoolField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedBoolField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedBoolField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37111,18 +41174,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedBo try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedBoolField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedBoolField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedBoolField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedBoolField) -> Bool { if lhs.visitPackedBoolField != rhs.visitPackedBoolField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedDoubleField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedDoubleField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedDoubleField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedDoubleField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37143,18 +41204,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedDo try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedDoubleField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedDoubleField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedDoubleField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedDoubleField) -> Bool { if lhs.visitPackedDoubleField != rhs.visitPackedDoubleField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedEnumField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedEnumField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedEnumField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedEnumField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37175,18 +41234,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedEn try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedEnumField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedEnumField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedEnumField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedEnumField) -> Bool { if lhs.visitPackedEnumField != rhs.visitPackedEnumField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37207,18 +41264,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFixed32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFixed32Field) -> Bool { if lhs.visitPackedFixed32Field != rhs.visitPackedFixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37239,18 +41294,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFixed64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFixed64Field) -> Bool { if lhs.visitPackedFixed64Field != rhs.visitPackedFixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedFloatField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedFloatField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedFloatField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedFloatField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37271,18 +41324,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFl try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFloatField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedFloatField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFloatField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedFloatField) -> Bool { if lhs.visitPackedFloatField != rhs.visitPackedFloatField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37303,18 +41354,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedIn try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedInt32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedInt32Field) -> Bool { if lhs.visitPackedInt32Field != rhs.visitPackedInt32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37335,18 +41384,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedIn try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedInt64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedInt64Field) -> Bool { if lhs.visitPackedInt64Field != rhs.visitPackedInt64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedSFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedSFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedSFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedSFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37367,18 +41414,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSF try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSFixed32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSFixed32Field) -> Bool { if lhs.visitPackedSfixed32Field != rhs.visitPackedSfixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedSFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedSFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedSFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedSFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37399,18 +41444,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSF try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSFixed64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSFixed64Field) -> Bool { if lhs.visitPackedSfixed64Field != rhs.visitPackedSfixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedSInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedSInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedSInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedSInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37431,18 +41474,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSI try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSInt32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSInt32Field) -> Bool { if lhs.visitPackedSint32Field != rhs.visitPackedSint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedSInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedSInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedSInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedSInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37463,18 +41504,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSI try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedSInt64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedSInt64Field) -> Bool { if lhs.visitPackedSint64Field != rhs.visitPackedSint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedUInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedUInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedUInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedUInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37495,18 +41534,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUI try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUInt32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedUInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedUInt32Field) -> Bool { if lhs.visitPackedUint32Field != rhs.visitPackedUint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedUInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitPackedUInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitPackedUInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitPackedUInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37527,18 +41564,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUI try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitPackedUInt64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedUInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitPackedUInt64Field) -> Bool { if lhs.visitPackedUint64Field != rhs.visitPackedUint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeated" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeated"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeated: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeated" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeated\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37559,18 +41594,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeated, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeated) -> Bool { if lhs.visitRepeated != rhs.visitRepeated {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedBoolField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedBoolField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedBoolField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedBoolField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37591,18 +41624,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedBoolField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedBoolField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedBoolField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedBoolField) -> Bool { if lhs.visitRepeatedBoolField != rhs.visitRepeatedBoolField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedBytesField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedBytesField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedBytesField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedBytesField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedBytesField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedBytesField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37623,18 +41654,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedBytesField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedBytesField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedBytesField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedBytesField) -> Bool { if lhs.visitRepeatedBytesField != rhs.visitRepeatedBytesField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedDoubleField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedDoubleField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedDoubleField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedDoubleField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37655,18 +41684,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedDoubleField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedDoubleField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedDoubleField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedDoubleField) -> Bool { if lhs.visitRepeatedDoubleField != rhs.visitRepeatedDoubleField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedEnumField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedEnumField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedEnumField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedEnumField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37687,18 +41714,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedEnumField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedEnumField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedEnumField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedEnumField) -> Bool { if lhs.visitRepeatedEnumField != rhs.visitRepeatedEnumField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37719,18 +41744,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFixed32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFixed32Field) -> Bool { if lhs.visitRepeatedFixed32Field != rhs.visitRepeatedFixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37751,18 +41774,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFixed64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFixed64Field) -> Bool { if lhs.visitRepeatedFixed64Field != rhs.visitRepeatedFixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedFloatField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedFloatField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedFloatField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedFloatField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37783,18 +41804,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFloatField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedFloatField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFloatField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedFloatField) -> Bool { if lhs.visitRepeatedFloatField != rhs.visitRepeatedFloatField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedGroupField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedGroupField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedGroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedGroupField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37815,18 +41834,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedGroupField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedGroupField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedGroupField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedGroupField) -> Bool { if lhs.visitRepeatedGroupField != rhs.visitRepeatedGroupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37847,18 +41864,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedInt32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedInt32Field) -> Bool { if lhs.visitRepeatedInt32Field != rhs.visitRepeatedInt32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37879,18 +41894,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedInt64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedInt64Field) -> Bool { if lhs.visitRepeatedInt64Field != rhs.visitRepeatedInt64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedMessageField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedMessageField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedMessageField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedMessageField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37911,18 +41924,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedMessageField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedMessageField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedMessageField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedMessageField) -> Bool { if lhs.visitRepeatedMessageField != rhs.visitRepeatedMessageField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedSFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedSFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedSFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedSFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37943,18 +41954,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSFixed32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSFixed32Field) -> Bool { if lhs.visitRepeatedSfixed32Field != rhs.visitRepeatedSfixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedSFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedSFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedSFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedSFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -37975,18 +41984,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSFixed64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSFixed64Field) -> Bool { if lhs.visitRepeatedSfixed64Field != rhs.visitRepeatedSfixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedSInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedSInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedSInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedSInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38007,18 +42014,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSInt32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSInt32Field) -> Bool { if lhs.visitRepeatedSint32Field != rhs.visitRepeatedSint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedSInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedSInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedSInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedSInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38039,18 +42044,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedSInt64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedSInt64Field) -> Bool { if lhs.visitRepeatedSint64Field != rhs.visitRepeatedSint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedStringField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedStringField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedStringField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedStringField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedStringField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedStringField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38071,18 +42074,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedStringField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedStringField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedStringField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedStringField) -> Bool { if lhs.visitRepeatedStringField != rhs.visitRepeatedStringField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedUInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedUInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedUInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedUInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38103,18 +42104,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedUInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedUInt32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedUInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedUInt32Field) -> Bool { if lhs.visitRepeatedUint32Field != rhs.visitRepeatedUint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedUInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitRepeatedUInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitRepeatedUInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitRepeatedUInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38135,18 +42134,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeated try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedUInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitRepeatedUInt64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedUInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitRepeatedUInt64Field) -> Bool { if lhs.visitRepeatedUint64Field != rhs.visitRepeatedUint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingular" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingular"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingular: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingular" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingular\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38167,18 +42164,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingular, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingular) -> Bool { if lhs.visitSingular != rhs.visitSingular {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularBoolField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularBoolField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularBoolField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularBoolField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularBoolField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38199,18 +42194,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularBoolField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularBoolField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularBoolField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularBoolField) -> Bool { if lhs.visitSingularBoolField != rhs.visitSingularBoolField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularBytesField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularBytesField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularBytesField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularBytesField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularBytesField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularBytesField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38231,18 +42224,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularBytesField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularBytesField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularBytesField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularBytesField) -> Bool { if lhs.visitSingularBytesField != rhs.visitSingularBytesField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularDoubleField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularDoubleField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularDoubleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularDoubleField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularDoubleField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38263,18 +42254,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularDoubleField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularDoubleField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularDoubleField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularDoubleField) -> Bool { if lhs.visitSingularDoubleField != rhs.visitSingularDoubleField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularEnumField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularEnumField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularEnumField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularEnumField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularEnumField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38295,18 +42284,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularEnumField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularEnumField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularEnumField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularEnumField) -> Bool { if lhs.visitSingularEnumField != rhs.visitSingularEnumField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38327,18 +42314,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFixed32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFixed32Field) -> Bool { if lhs.visitSingularFixed32Field != rhs.visitSingularFixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38359,18 +42344,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFixed64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFixed64Field) -> Bool { if lhs.visitSingularFixed64Field != rhs.visitSingularFixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularFloatField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularFloatField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFloatField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularFloatField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularFloatField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38391,18 +42374,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFloatField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularFloatField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFloatField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularFloatField) -> Bool { if lhs.visitSingularFloatField != rhs.visitSingularFloatField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularGroupField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularGroupField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularGroupField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularGroupField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularGroupField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38423,18 +42404,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularGroupField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularGroupField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularGroupField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularGroupField) -> Bool { if lhs.visitSingularGroupField != rhs.visitSingularGroupField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38455,18 +42434,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularInt32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularInt32Field) -> Bool { if lhs.visitSingularInt32Field != rhs.visitSingularInt32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38487,18 +42464,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularInt64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularInt64Field) -> Bool { if lhs.visitSingularInt64Field != rhs.visitSingularInt64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularMessageField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularMessageField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularMessageField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularMessageField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularMessageField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38519,18 +42494,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularMessageField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularMessageField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularMessageField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularMessageField) -> Bool { if lhs.visitSingularMessageField != rhs.visitSingularMessageField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularSFixed32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularSFixed32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSFixed32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularSFixed32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularSFixed32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38551,18 +42524,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSFixed32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSFixed32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSFixed32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSFixed32Field) -> Bool { if lhs.visitSingularSfixed32Field != rhs.visitSingularSfixed32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularSFixed64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularSFixed64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSFixed64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularSFixed64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularSFixed64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38583,18 +42554,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSFixed64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSFixed64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSFixed64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSFixed64Field) -> Bool { if lhs.visitSingularSfixed64Field != rhs.visitSingularSfixed64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularSInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularSInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularSInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularSInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38615,18 +42584,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSInt32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSInt32Field) -> Bool { if lhs.visitSingularSint32Field != rhs.visitSingularSint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularSInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularSInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularSInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularSInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38647,18 +42614,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularSInt64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularSInt64Field) -> Bool { if lhs.visitSingularSint64Field != rhs.visitSingularSint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularStringField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularStringField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularStringField"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularStringField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularStringField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularStringField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38679,18 +42644,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularStringField, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularStringField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularStringField, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularStringField) -> Bool { if lhs.visitSingularStringField != rhs.visitSingularStringField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularUInt32Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularUInt32Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularUInt32Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularUInt32Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularUInt32Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38711,18 +42674,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularUInt32Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularUInt32Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularUInt32Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularUInt32Field) -> Bool { if lhs.visitSingularUint32Field != rhs.visitSingularUint32Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularUInt64Field" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitSingularUInt64Field"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularUInt64Field: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitSingularUInt64Field" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitSingularUInt64Field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38743,18 +42704,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingular try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularUInt64Field, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitSingularUInt64Field) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularUInt64Field, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitSingularUInt64Field) -> Bool { if lhs.visitSingularUint64Field != rhs.visitSingularUint64Field {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitUnknown: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".visitUnknown" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "visitUnknown"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitUnknown: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".visitUnknown" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}visitUnknown\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38775,18 +42734,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitUnknown: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitUnknown, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.visitUnknown) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitUnknown, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.visitUnknown) -> Bool { if lhs.visitUnknown != rhs.visitUnknown {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wasDecoded: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".wasDecoded" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "wasDecoded"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Void: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Void" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Void\0") + + 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.void) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.void != 0 { + try visitor.visitSingularInt32Field(value: self.void, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Void, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Void) -> Bool { + if lhs.void != rhs.void {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wasDecoded: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".wasDecoded" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}wasDecoded\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38807,18 +42794,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wasDecoded: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wasDecoded, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wasDecoded) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wasDecoded, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wasDecoded) -> Bool { if lhs.wasDecoded != rhs.wasDecoded {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weak: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".weak" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "weak"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.weak: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".weak" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}weak\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38839,18 +42824,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weak: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weak, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weak) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.weak, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.weak) -> Bool { if lhs.weak != rhs.weak {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weakDependency: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".weakDependency" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "weakDependency"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.weakDependency: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".weakDependency" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}weakDependency\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38871,18 +42854,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weakDependenc try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weakDependency, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.weakDependency) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.weakDependency, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.weakDependency) -> Bool { if lhs.weakDependency != rhs.weakDependency {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.whereMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".where" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "where"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.whereMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".where" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}where\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38903,18 +42884,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.whereMessage: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.whereMessage, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.whereMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.whereMessage, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.whereMessage) -> Bool { if lhs.`where` != rhs.`where` {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wireFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".wireFormat" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "wireFormat"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wireFormat: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".wireFormat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}wireFormat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38935,18 +42914,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wireFormat: S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wireFormat, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.wireFormat) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wireFormat, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wireFormat) -> Bool { if lhs.wireFormat != rhs.wireFormat {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.with: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".with" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "with"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.with: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".with" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}with\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38967,18 +42944,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.with: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.with, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.with) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.with, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.with) -> Bool { if lhs.with != rhs.with {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".withUnsafeBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "withUnsafeBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.withUnsafeBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".withUnsafeBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}withUnsafeBytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -38999,18 +42974,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeByt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeBytes, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeBytes) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.withUnsafeBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.withUnsafeBytes) -> Bool { if lhs.withUnsafeBytes != rhs.withUnsafeBytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeMutableBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".withUnsafeMutableBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "withUnsafeMutableBytes"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.withUnsafeMutableBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".withUnsafeMutableBytes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}withUnsafeMutableBytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -39031,18 +43004,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeMut try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeMutableBytes, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.withUnsafeMutableBytes) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.withUnsafeMutableBytes, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.withUnsafeMutableBytes) -> Bool { if lhs.withUnsafeMutableBytes != rhs.withUnsafeMutableBytes {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.work: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".work" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "work"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.work: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".work" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}work\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -39063,18 +43034,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.work: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.work, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.work) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.work, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.work) -> Bool { if lhs.work != rhs.work {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.WrappedType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".WrappedType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "WrappedType"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Wrapped: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".Wrapped" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Wrapped\0") + + 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.wrapped) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.wrapped != 0 { + try visitor.visitSingularInt32Field(value: self.wrapped, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Wrapped, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.Wrapped) -> Bool { + if lhs.wrapped != rhs.wrapped {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.WrappedType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".WrappedType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}WrappedType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -39095,18 +43094,46 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.WrappedType: try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.WrappedType, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.WrappedType) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.WrappedType, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.WrappedType) -> Bool { if lhs.wrappedType != rhs.wrappedType {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.written: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".written" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "written"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wrappedValue: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".wrappedValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}wrappedValue\0") + + 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.wrappedValue) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if self.wrappedValue != 0 { + try visitor.visitSingularInt32Field(value: self.wrappedValue, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wrappedValue, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.wrappedValue) -> Bool { + if lhs.wrappedValue != rhs.wrappedValue {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.written: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".written" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}written\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -39127,18 +43154,16 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.written: Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.written, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.written) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.written, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.written) -> Bool { if lhs.written != rhs.written {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.yday: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.protoMessageName + ".yday" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "yday"), - ] +extension SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.yday: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.protoMessageName + ".yday" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}yday\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -39159,7 +43184,7 @@ extension ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.yday: SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.yday, rhs: ProtobufUnittestGenerated_GeneratedSwiftReservedMessages.yday) -> Bool { + static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.yday, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedMessages.yday) -> Bool { if lhs.yday != rhs.yday {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Tests/SwiftProtobufTests/map_proto2_unittest.pb.swift b/Tests/SwiftProtobufTests/map_proto2_unittest.pb.swift index 5d0aa252e..dd462caed 100644 --- a/Tests/SwiftProtobufTests/map_proto2_unittest.pb.swift +++ b/Tests/SwiftProtobufTests/map_proto2_unittest.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/map_proto2_unittest.proto +// Source: map_proto2_unittest.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -37,7 +38,6 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -50,230 +50,122 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum ProtobufUnittest_Proto2MapEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 0 - case bar // = 1 - case baz // = 2 +enum SwiftProtoTesting_Proto2MapEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 init() { self = .foo } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .foo - case 1: self = .bar - case 2: self = .baz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo: return 0 - case .bar: return 1 - case .baz: return 2 - } - } - } -#if swift(>=4.2) - -extension ProtobufUnittest_Proto2MapEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -enum ProtobufUnittest_Proto2MapEnumPlusExtra: SwiftProtobuf.Enum { - typealias RawValue = Int - case eProto2MapEnumFoo // = 0 - case eProto2MapEnumBar // = 1 - case eProto2MapEnumBaz // = 2 - case eProto2MapEnumExtra // = 3 +enum SwiftProtoTesting_Proto2MapEnumPlusExtra: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case eProto2MapEnumFoo = 0 + case eProto2MapEnumBar = 1 + case eProto2MapEnumBaz = 2 + case eProto2MapEnumExtra = 3 init() { self = .eProto2MapEnumFoo } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .eProto2MapEnumFoo - case 1: self = .eProto2MapEnumBar - case 2: self = .eProto2MapEnumBaz - case 3: self = .eProto2MapEnumExtra - default: return nil - } - } - - var rawValue: Int { - switch self { - case .eProto2MapEnumFoo: return 0 - case .eProto2MapEnumBar: return 1 - case .eProto2MapEnumBaz: return 2 - case .eProto2MapEnumExtra: return 3 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_Proto2MapEnumPlusExtra: CaseIterable { - // Support synthesized by the compiler. } -#endif // swift(>=4.2) - -struct ProtobufUnittest_TestEnumMap { +struct SwiftProtoTesting_TestEnumMap: Sendable { // 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 knownMapField: Dictionary = [:] + var knownMapField: Dictionary = [:] - var unknownMapField: Dictionary = [:] + var unknownMapField: Dictionary = [:] - var unknownFields = SwiftProtobuf.UnknownStorage() + /// Other maps with all key types to test the unknown entry serialization + var unknownMapFieldInt64: Dictionary = [:] - init() {} -} + var unknownMapFieldUint64: Dictionary = [:] -struct ProtobufUnittest_TestEnumMapPlusExtra { - // 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 unknownMapFieldInt32: Dictionary = [:] - var knownMapField: Dictionary = [:] + var unknownMapFieldUint32: Dictionary = [:] - var unknownMapField: Dictionary = [:] + var unknownMapFieldFixed32: Dictionary = [:] - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownMapFieldFixed64: Dictionary = [:] - init() {} -} + var unknownMapFieldBool: Dictionary = [:] -struct ProtobufUnittest_TestImportEnumMap { - // 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 unknownMapFieldString: Dictionary = [:] - var importEnumAmp: Dictionary = [:] + var unknownMapFieldSint32: Dictionary = [:] - var unknownFields = SwiftProtobuf.UnknownStorage() + var unknownMapFieldSint64: Dictionary = [:] - init() {} -} + var unknownMapFieldSfixed32: Dictionary = [:] -struct ProtobufUnittest_TestIntIntMap { - // 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 m: Dictionary = [:] + var unknownMapFieldSfixed64: Dictionary = [:] var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } -/// Test all key types: string, plus the non-floating-point scalars. -struct ProtobufUnittest_TestMaps { +struct SwiftProtoTesting_TestEnumMapPlusExtra: Sendable { // 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 mInt32: Dictionary = [:] - - var mInt64: Dictionary = [:] + var knownMapField: Dictionary = [:] - var mUint32: Dictionary = [:] + var unknownMapField: Dictionary = [:] - var mUint64: Dictionary = [:] + /// Other maps with all key types to test the unknown entry serialization + var unknownMapFieldInt64: Dictionary = [:] - var mSint32: Dictionary = [:] + var unknownMapFieldUint64: Dictionary = [:] - var mSint64: Dictionary = [:] + var unknownMapFieldInt32: Dictionary = [:] - var mFixed32: Dictionary = [:] + var unknownMapFieldUint32: Dictionary = [:] - var mFixed64: Dictionary = [:] + var unknownMapFieldFixed32: Dictionary = [:] - var mSfixed32: Dictionary = [:] + var unknownMapFieldFixed64: Dictionary = [:] - var mSfixed64: Dictionary = [:] + var unknownMapFieldBool: Dictionary = [:] - var mBool: Dictionary = [:] + var unknownMapFieldString: Dictionary = [:] - var mString: Dictionary = [:] + var unknownMapFieldSint32: Dictionary = [:] - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} + var unknownMapFieldSint64: Dictionary = [:] -/// Test maps in submessages. -struct ProtobufUnittest_TestSubmessageMaps { - // 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 unknownMapFieldSfixed32: Dictionary = [:] - var m: ProtobufUnittest_TestMaps { - get {return _m ?? ProtobufUnittest_TestMaps()} - set {_m = newValue} - } - /// Returns true if `m` has been explicitly set. - var hasM: Bool {return self._m != nil} - /// Clears the value of `m`. Subsequent reads from it will return its default value. - mutating func clearM() {self._m = nil} + var unknownMapFieldSfixed64: Dictionary = [:] var unknownFields = SwiftProtobuf.UnknownStorage() init() {} - - fileprivate var _m: ProtobufUnittest_TestMaps? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_Proto2MapEnum: @unchecked Sendable {} -extension ProtobufUnittest_Proto2MapEnumPlusExtra: @unchecked Sendable {} -extension ProtobufUnittest_TestEnumMap: @unchecked Sendable {} -extension ProtobufUnittest_TestEnumMapPlusExtra: @unchecked Sendable {} -extension ProtobufUnittest_TestImportEnumMap: @unchecked Sendable {} -extension ProtobufUnittest_TestIntIntMap: @unchecked Sendable {} -extension ProtobufUnittest_TestMaps: @unchecked Sendable {} -extension ProtobufUnittest_TestSubmessageMaps: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_Proto2MapEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "PROTO2_MAP_ENUM_FOO"), - 1: .same(proto: "PROTO2_MAP_ENUM_BAR"), - 2: .same(proto: "PROTO2_MAP_ENUM_BAZ"), - ] +extension SwiftProtoTesting_Proto2MapEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0PROTO2_MAP_ENUM_FOO\0\u{1}PROTO2_MAP_ENUM_BAR\0\u{1}PROTO2_MAP_ENUM_BAZ\0") } -extension ProtobufUnittest_Proto2MapEnumPlusExtra: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "E_PROTO2_MAP_ENUM_FOO"), - 1: .same(proto: "E_PROTO2_MAP_ENUM_BAR"), - 2: .same(proto: "E_PROTO2_MAP_ENUM_BAZ"), - 3: .same(proto: "E_PROTO2_MAP_ENUM_EXTRA"), - ] +extension SwiftProtoTesting_Proto2MapEnumPlusExtra: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0E_PROTO2_MAP_ENUM_FOO\0\u{1}E_PROTO2_MAP_ENUM_BAR\0\u{1}E_PROTO2_MAP_ENUM_BAZ\0\u{1}E_PROTO2_MAP_ENUM_EXTRA\0") } -extension ProtobufUnittest_TestEnumMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_TestEnumMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestEnumMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 101: .standard(proto: "known_map_field"), - 102: .standard(proto: "unknown_map_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}e\u{1}known_map_field\0\u{3}unknown_map_field\0\u{4}b\u{1}unknown_map_field_int64\0\u{3}unknown_map_field_uint64\0\u{3}unknown_map_field_int32\0\u{3}unknown_map_field_uint32\0\u{3}unknown_map_field_fixed32\0\u{3}unknown_map_field_fixed64\0\u{3}unknown_map_field_bool\0\u{3}unknown_map_field_string\0\u{3}unknown_map_field_sint32\0\u{3}unknown_map_field_sint64\0\u{3}unknown_map_field_sfixed32\0\u{3}unknown_map_field_sfixed64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -281,8 +173,20 @@ extension ProtobufUnittest_TestEnumMap: SwiftProtobuf.Message, SwiftProtobuf._Me // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { - case 101: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.knownMapField) }() - case 102: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapField) }() + case 101: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.knownMapField) }() + case 102: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapField) }() + case 200: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldInt64) }() + case 201: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldUint64) }() + case 202: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldInt32) }() + case 203: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldUint32) }() + case 204: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldFixed32) }() + case 205: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldFixed64) }() + case 206: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldBool) }() + case 207: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldString) }() + case 208: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSint32) }() + case 209: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSint64) }() + case 210: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSfixed32) }() + case 211: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSfixed64) }() default: break } } @@ -290,140 +194,73 @@ extension ProtobufUnittest_TestEnumMap: SwiftProtobuf.Message, SwiftProtobuf._Me func traverse(visitor: inout V) throws { if !self.knownMapField.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.knownMapField, fieldNumber: 101) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.knownMapField, fieldNumber: 101) } if !self.unknownMapField.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapField, fieldNumber: 102) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapField, fieldNumber: 102) } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestEnumMap, rhs: ProtobufUnittest_TestEnumMap) -> Bool { - if lhs.knownMapField != rhs.knownMapField {return false} - if lhs.unknownMapField != rhs.unknownMapField {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestEnumMapPlusExtra: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestEnumMapPlusExtra" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 101: .standard(proto: "known_map_field"), - 102: .standard(proto: "unknown_map_field"), - ] - - 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 101: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.knownMapField) }() - case 102: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapField) }() - default: break - } + if !self.unknownMapFieldInt64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldInt64, fieldNumber: 200) } - } - - func traverse(visitor: inout V) throws { - if !self.knownMapField.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.knownMapField, fieldNumber: 101) + if !self.unknownMapFieldUint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldUint64, fieldNumber: 201) } - if !self.unknownMapField.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapField, fieldNumber: 102) + if !self.unknownMapFieldInt32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldInt32, fieldNumber: 202) } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestEnumMapPlusExtra, rhs: ProtobufUnittest_TestEnumMapPlusExtra) -> Bool { - if lhs.knownMapField != rhs.knownMapField {return false} - if lhs.unknownMapField != rhs.unknownMapField {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestImportEnumMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestImportEnumMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "import_enum_amp"), - ] - - 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.importEnumAmp) }() - default: break - } + if !self.unknownMapFieldUint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldUint32, fieldNumber: 203) } - } - - func traverse(visitor: inout V) throws { - if !self.importEnumAmp.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.importEnumAmp, fieldNumber: 1) + if !self.unknownMapFieldFixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldFixed32, fieldNumber: 204) } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestImportEnumMap, rhs: ProtobufUnittest_TestImportEnumMap) -> Bool { - if lhs.importEnumAmp != rhs.importEnumAmp {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestIntIntMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestIntIntMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "m"), - ] - - 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.m) }() - default: break - } + if !self.unknownMapFieldFixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldFixed64, fieldNumber: 205) } - } - - func traverse(visitor: inout V) throws { - if !self.m.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.m, fieldNumber: 1) + if !self.unknownMapFieldBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldBool, fieldNumber: 206) + } + if !self.unknownMapFieldString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldString, fieldNumber: 207) + } + if !self.unknownMapFieldSint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSint32, fieldNumber: 208) + } + if !self.unknownMapFieldSint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSint64, fieldNumber: 209) + } + if !self.unknownMapFieldSfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSfixed32, fieldNumber: 210) + } + if !self.unknownMapFieldSfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSfixed64, fieldNumber: 211) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestIntIntMap, rhs: ProtobufUnittest_TestIntIntMap) -> Bool { - if lhs.m != rhs.m {return false} + static func ==(lhs: SwiftProtoTesting_TestEnumMap, rhs: SwiftProtoTesting_TestEnumMap) -> Bool { + if lhs.knownMapField != rhs.knownMapField {return false} + if lhs.unknownMapField != rhs.unknownMapField {return false} + if lhs.unknownMapFieldInt64 != rhs.unknownMapFieldInt64 {return false} + if lhs.unknownMapFieldUint64 != rhs.unknownMapFieldUint64 {return false} + if lhs.unknownMapFieldInt32 != rhs.unknownMapFieldInt32 {return false} + if lhs.unknownMapFieldUint32 != rhs.unknownMapFieldUint32 {return false} + if lhs.unknownMapFieldFixed32 != rhs.unknownMapFieldFixed32 {return false} + if lhs.unknownMapFieldFixed64 != rhs.unknownMapFieldFixed64 {return false} + if lhs.unknownMapFieldBool != rhs.unknownMapFieldBool {return false} + if lhs.unknownMapFieldString != rhs.unknownMapFieldString {return false} + if lhs.unknownMapFieldSint32 != rhs.unknownMapFieldSint32 {return false} + if lhs.unknownMapFieldSint64 != rhs.unknownMapFieldSint64 {return false} + if lhs.unknownMapFieldSfixed32 != rhs.unknownMapFieldSfixed32 {return false} + if lhs.unknownMapFieldSfixed64 != rhs.unknownMapFieldSfixed64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestMaps: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMaps" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "m_int32"), - 2: .standard(proto: "m_int64"), - 3: .standard(proto: "m_uint32"), - 4: .standard(proto: "m_uint64"), - 5: .standard(proto: "m_sint32"), - 6: .standard(proto: "m_sint64"), - 7: .standard(proto: "m_fixed32"), - 8: .standard(proto: "m_fixed64"), - 9: .standard(proto: "m_sfixed32"), - 10: .standard(proto: "m_sfixed64"), - 11: .standard(proto: "m_bool"), - 12: .standard(proto: "m_string"), - ] +extension SwiftProtoTesting_TestEnumMapPlusExtra: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEnumMapPlusExtra" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}e\u{1}known_map_field\0\u{3}unknown_map_field\0\u{4}b\u{1}unknown_map_field_int64\0\u{3}unknown_map_field_uint64\0\u{3}unknown_map_field_int32\0\u{3}unknown_map_field_uint32\0\u{3}unknown_map_field_fixed32\0\u{3}unknown_map_field_fixed64\0\u{3}unknown_map_field_bool\0\u{3}unknown_map_field_string\0\u{3}unknown_map_field_sint32\0\u{3}unknown_map_field_sint64\0\u{3}unknown_map_field_sfixed32\0\u{3}unknown_map_field_sfixed64\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -431,112 +268,86 @@ extension ProtobufUnittest_TestMaps: SwiftProtobuf.Message, SwiftProtobuf._Messa // 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mInt32) }() - case 2: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mInt64) }() - case 3: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mUint32) }() - case 4: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mUint64) }() - case 5: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mSint32) }() - case 6: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mSint64) }() - case 7: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mFixed32) }() - case 8: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mFixed64) }() - case 9: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mSfixed32) }() - case 10: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mSfixed64) }() - case 11: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mBool) }() - case 12: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mString) }() + case 101: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.knownMapField) }() + case 102: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapField) }() + case 200: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldInt64) }() + case 201: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldUint64) }() + case 202: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldInt32) }() + case 203: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldUint32) }() + case 204: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldFixed32) }() + case 205: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldFixed64) }() + case 206: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldBool) }() + case 207: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldString) }() + case 208: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSint32) }() + case 209: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSint64) }() + case 210: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSfixed32) }() + case 211: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &self.unknownMapFieldSfixed64) }() default: break } } } func traverse(visitor: inout V) throws { - if !self.mInt32.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mInt32, fieldNumber: 1) + if !self.knownMapField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.knownMapField, fieldNumber: 101) } - if !self.mInt64.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mInt64, fieldNumber: 2) + if !self.unknownMapField.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapField, fieldNumber: 102) } - if !self.mUint32.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mUint32, fieldNumber: 3) + if !self.unknownMapFieldInt64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldInt64, fieldNumber: 200) } - if !self.mUint64.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mUint64, fieldNumber: 4) + if !self.unknownMapFieldUint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldUint64, fieldNumber: 201) } - if !self.mSint32.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mSint32, fieldNumber: 5) + if !self.unknownMapFieldInt32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldInt32, fieldNumber: 202) } - if !self.mSint64.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mSint64, fieldNumber: 6) + if !self.unknownMapFieldUint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldUint32, fieldNumber: 203) } - if !self.mFixed32.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mFixed32, fieldNumber: 7) + if !self.unknownMapFieldFixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldFixed32, fieldNumber: 204) } - if !self.mFixed64.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mFixed64, fieldNumber: 8) + if !self.unknownMapFieldFixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldFixed64, fieldNumber: 205) } - if !self.mSfixed32.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mSfixed32, fieldNumber: 9) + if !self.unknownMapFieldBool.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldBool, fieldNumber: 206) } - if !self.mSfixed64.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mSfixed64, fieldNumber: 10) + if !self.unknownMapFieldString.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldString, fieldNumber: 207) } - if !self.mBool.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mBool, fieldNumber: 11) + if !self.unknownMapFieldSint32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSint32, fieldNumber: 208) } - if !self.mString.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mString, fieldNumber: 12) + if !self.unknownMapFieldSint64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSint64, fieldNumber: 209) } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMaps, rhs: ProtobufUnittest_TestMaps) -> Bool { - if lhs.mInt32 != rhs.mInt32 {return false} - if lhs.mInt64 != rhs.mInt64 {return false} - if lhs.mUint32 != rhs.mUint32 {return false} - if lhs.mUint64 != rhs.mUint64 {return false} - if lhs.mSint32 != rhs.mSint32 {return false} - if lhs.mSint64 != rhs.mSint64 {return false} - if lhs.mFixed32 != rhs.mFixed32 {return false} - if lhs.mFixed64 != rhs.mFixed64 {return false} - if lhs.mSfixed32 != rhs.mSfixed32 {return false} - if lhs.mSfixed64 != rhs.mSfixed64 {return false} - if lhs.mBool != rhs.mBool {return false} - if lhs.mString != rhs.mString {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestSubmessageMaps: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestSubmessageMaps" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "m"), - ] - - 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.decodeSingularMessageField(value: &self._m) }() - default: break - } + if !self.unknownMapFieldSfixed32.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSfixed32, fieldNumber: 210) + } + if !self.unknownMapFieldSfixed64.isEmpty { + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: self.unknownMapFieldSfixed64, fieldNumber: 211) } - } - - 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 - try { if let v = self._m { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestSubmessageMaps, rhs: ProtobufUnittest_TestSubmessageMaps) -> Bool { - if lhs._m != rhs._m {return false} + static func ==(lhs: SwiftProtoTesting_TestEnumMapPlusExtra, rhs: SwiftProtoTesting_TestEnumMapPlusExtra) -> Bool { + if lhs.knownMapField != rhs.knownMapField {return false} + if lhs.unknownMapField != rhs.unknownMapField {return false} + if lhs.unknownMapFieldInt64 != rhs.unknownMapFieldInt64 {return false} + if lhs.unknownMapFieldUint64 != rhs.unknownMapFieldUint64 {return false} + if lhs.unknownMapFieldInt32 != rhs.unknownMapFieldInt32 {return false} + if lhs.unknownMapFieldUint32 != rhs.unknownMapFieldUint32 {return false} + if lhs.unknownMapFieldFixed32 != rhs.unknownMapFieldFixed32 {return false} + if lhs.unknownMapFieldFixed64 != rhs.unknownMapFieldFixed64 {return false} + if lhs.unknownMapFieldBool != rhs.unknownMapFieldBool {return false} + if lhs.unknownMapFieldString != rhs.unknownMapFieldString {return false} + if lhs.unknownMapFieldSint32 != rhs.unknownMapFieldSint32 {return false} + if lhs.unknownMapFieldSint64 != rhs.unknownMapFieldSint64 {return false} + if lhs.unknownMapFieldSfixed32 != rhs.unknownMapFieldSfixed32 {return false} + if lhs.unknownMapFieldSfixed64 != rhs.unknownMapFieldSfixed64 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } diff --git a/Tests/SwiftProtobufTests/map_unittest.pb.swift b/Tests/SwiftProtobufTests/map_unittest.pb.swift index b8592f732..5e8d3423b 100644 --- a/Tests/SwiftProtobufTests/map_unittest.pb.swift +++ b/Tests/SwiftProtobufTests/map_unittest.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/map_unittest.proto +// Source: map_unittest.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -50,7 +51,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum ProtobufUnittest_MapEnum: SwiftProtobuf.Enum { +enum SwiftProtoTesting_MapEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foo // = 0 case bar // = 1 @@ -79,119 +80,113 @@ enum ProtobufUnittest_MapEnum: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension ProtobufUnittest_MapEnum: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittest_MapEnum] = [ + static let allCases: [SwiftProtoTesting_MapEnum] = [ .foo, .bar, .baz, ] -} -#endif // swift(>=4.2) +} /// Tests maps. -struct ProtobufUnittest_TestMap { +struct SwiftProtoTesting_TestMap: @unchecked Sendable { // 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 mapInt32Int32: Dictionary { - get {return _storage._mapInt32Int32} + get {_storage._mapInt32Int32} set {_uniqueStorage()._mapInt32Int32 = newValue} } var mapInt64Int64: Dictionary { - get {return _storage._mapInt64Int64} + get {_storage._mapInt64Int64} set {_uniqueStorage()._mapInt64Int64 = newValue} } var mapUint32Uint32: Dictionary { - get {return _storage._mapUint32Uint32} + get {_storage._mapUint32Uint32} set {_uniqueStorage()._mapUint32Uint32 = newValue} } var mapUint64Uint64: Dictionary { - get {return _storage._mapUint64Uint64} + get {_storage._mapUint64Uint64} set {_uniqueStorage()._mapUint64Uint64 = newValue} } var mapSint32Sint32: Dictionary { - get {return _storage._mapSint32Sint32} + get {_storage._mapSint32Sint32} set {_uniqueStorage()._mapSint32Sint32 = newValue} } var mapSint64Sint64: Dictionary { - get {return _storage._mapSint64Sint64} + get {_storage._mapSint64Sint64} set {_uniqueStorage()._mapSint64Sint64 = newValue} } var mapFixed32Fixed32: Dictionary { - get {return _storage._mapFixed32Fixed32} + get {_storage._mapFixed32Fixed32} set {_uniqueStorage()._mapFixed32Fixed32 = newValue} } var mapFixed64Fixed64: Dictionary { - get {return _storage._mapFixed64Fixed64} + get {_storage._mapFixed64Fixed64} set {_uniqueStorage()._mapFixed64Fixed64 = newValue} } var mapSfixed32Sfixed32: Dictionary { - get {return _storage._mapSfixed32Sfixed32} + get {_storage._mapSfixed32Sfixed32} set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} } var mapSfixed64Sfixed64: Dictionary { - get {return _storage._mapSfixed64Sfixed64} + get {_storage._mapSfixed64Sfixed64} set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} } var mapInt32Float: Dictionary { - get {return _storage._mapInt32Float} + get {_storage._mapInt32Float} set {_uniqueStorage()._mapInt32Float = newValue} } var mapInt32Double: Dictionary { - get {return _storage._mapInt32Double} + get {_storage._mapInt32Double} set {_uniqueStorage()._mapInt32Double = newValue} } var mapBoolBool: Dictionary { - get {return _storage._mapBoolBool} + get {_storage._mapBoolBool} set {_uniqueStorage()._mapBoolBool = newValue} } var mapStringString: Dictionary { - get {return _storage._mapStringString} + get {_storage._mapStringString} set {_uniqueStorage()._mapStringString = newValue} } var mapInt32Bytes: Dictionary { - get {return _storage._mapInt32Bytes} + get {_storage._mapInt32Bytes} set {_uniqueStorage()._mapInt32Bytes = newValue} } - var mapInt32Enum: Dictionary { - get {return _storage._mapInt32Enum} + var mapInt32Enum: Dictionary { + get {_storage._mapInt32Enum} set {_uniqueStorage()._mapInt32Enum = newValue} } - var mapInt32ForeignMessage: Dictionary { - get {return _storage._mapInt32ForeignMessage} + var mapInt32ForeignMessage: Dictionary { + get {_storage._mapInt32ForeignMessage} set {_uniqueStorage()._mapInt32ForeignMessage = newValue} } - var mapStringForeignMessage: Dictionary { - get {return _storage._mapStringForeignMessage} + var mapStringForeignMessage: Dictionary { + get {_storage._mapStringForeignMessage} set {_uniqueStorage()._mapStringForeignMessage = newValue} } - var mapInt32AllTypes: Dictionary { - get {return _storage._mapInt32AllTypes} + var mapInt32AllTypes: Dictionary { + get {_storage._mapInt32AllTypes} set {_uniqueStorage()._mapInt32AllTypes = newValue} } @@ -202,288 +197,42 @@ struct ProtobufUnittest_TestMap { fileprivate var _storage = _StorageClass.defaultInstance } -struct ProtobufUnittest_TestMapSubmessage { - // 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 testMap: ProtobufUnittest_TestMap { - get {return _testMap ?? ProtobufUnittest_TestMap()} - set {_testMap = newValue} - } - /// Returns true if `testMap` has been explicitly set. - var hasTestMap: Bool {return self._testMap != nil} - /// Clears the value of `testMap`. Subsequent reads from it will return its default value. - mutating func clearTestMap() {self._testMap = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _testMap: ProtobufUnittest_TestMap? = nil -} - -struct ProtobufUnittest_TestMessageMap { - // 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 mapInt32Message: Dictionary = [:] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -/// Two map fields share the same entry default instance. -struct ProtobufUnittest_TestSameTypeMap { - // 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 map1: Dictionary = [:] - - var map2: Dictionary = [:] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - /// Test embedded message with required fields -struct ProtobufUnittest_TestRequiredMessageMap { - // 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 mapField: Dictionary = [:] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -struct ProtobufUnittest_TestArenaMap { - // 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 mapInt32Int32: Dictionary { - get {return _storage._mapInt32Int32} - set {_uniqueStorage()._mapInt32Int32 = newValue} - } - - var mapInt64Int64: Dictionary { - get {return _storage._mapInt64Int64} - set {_uniqueStorage()._mapInt64Int64 = newValue} - } - - var mapUint32Uint32: Dictionary { - get {return _storage._mapUint32Uint32} - set {_uniqueStorage()._mapUint32Uint32 = newValue} - } - - var mapUint64Uint64: Dictionary { - get {return _storage._mapUint64Uint64} - set {_uniqueStorage()._mapUint64Uint64 = newValue} - } - - var mapSint32Sint32: Dictionary { - get {return _storage._mapSint32Sint32} - set {_uniqueStorage()._mapSint32Sint32 = newValue} - } - - var mapSint64Sint64: Dictionary { - get {return _storage._mapSint64Sint64} - set {_uniqueStorage()._mapSint64Sint64 = newValue} - } - - var mapFixed32Fixed32: Dictionary { - get {return _storage._mapFixed32Fixed32} - set {_uniqueStorage()._mapFixed32Fixed32 = newValue} - } - - var mapFixed64Fixed64: Dictionary { - get {return _storage._mapFixed64Fixed64} - set {_uniqueStorage()._mapFixed64Fixed64 = newValue} - } - - var mapSfixed32Sfixed32: Dictionary { - get {return _storage._mapSfixed32Sfixed32} - set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} - } - - var mapSfixed64Sfixed64: Dictionary { - get {return _storage._mapSfixed64Sfixed64} - set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} - } - - var mapInt32Float: Dictionary { - get {return _storage._mapInt32Float} - set {_uniqueStorage()._mapInt32Float = newValue} - } - - var mapInt32Double: Dictionary { - get {return _storage._mapInt32Double} - set {_uniqueStorage()._mapInt32Double = newValue} - } - - var mapBoolBool: Dictionary { - get {return _storage._mapBoolBool} - set {_uniqueStorage()._mapBoolBool = newValue} - } - - var mapStringString: Dictionary { - get {return _storage._mapStringString} - set {_uniqueStorage()._mapStringString = newValue} - } - - var mapInt32Bytes: Dictionary { - get {return _storage._mapInt32Bytes} - set {_uniqueStorage()._mapInt32Bytes = newValue} - } - - var mapInt32Enum: Dictionary { - get {return _storage._mapInt32Enum} - set {_uniqueStorage()._mapInt32Enum = newValue} - } - - var mapInt32ForeignMessage: Dictionary { - get {return _storage._mapInt32ForeignMessage} - set {_uniqueStorage()._mapInt32ForeignMessage = newValue} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -/// Previously, message containing enum called Type cannot be used as value of -/// map field. -struct ProtobufUnittest_MessageContainingEnumCalledType { +struct SwiftProtoTesting_TestRequiredMessageMap: Sendable { // 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 type: Dictionary = [:] + var mapField: Dictionary = [:] var unknownFields = SwiftProtobuf.UnknownStorage() - enum TypeEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 0 - case UNRECOGNIZED(Int) - - init() { - self = .foo - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .foo - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .foo: return 0 - case .UNRECOGNIZED(let i): return i - } - } - - } - init() {} } -#if swift(>=4.2) - -extension ProtobufUnittest_MessageContainingEnumCalledType.TypeEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittest_MessageContainingEnumCalledType.TypeEnum] = [ - .foo, - ] -} - -#endif // swift(>=4.2) - -/// Previously, message cannot contain map field called "entry". -struct ProtobufUnittest_MessageContainingMapCalledEntry { +struct SwiftProtoTesting_TestRecursiveMapMessage: Sendable { // 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 entry: Dictionary = [:] + var a: Dictionary = [:] var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } -struct ProtobufUnittest_TestRecursiveMapMessage { - // 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 a: Dictionary = [:] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_MapEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestMap: @unchecked Sendable {} -extension ProtobufUnittest_TestMapSubmessage: @unchecked Sendable {} -extension ProtobufUnittest_TestMessageMap: @unchecked Sendable {} -extension ProtobufUnittest_TestSameTypeMap: @unchecked Sendable {} -extension ProtobufUnittest_TestRequiredMessageMap: @unchecked Sendable {} -extension ProtobufUnittest_TestArenaMap: @unchecked Sendable {} -extension ProtobufUnittest_MessageContainingEnumCalledType: @unchecked Sendable {} -extension ProtobufUnittest_MessageContainingEnumCalledType.TypeEnum: @unchecked Sendable {} -extension ProtobufUnittest_MessageContainingMapCalledEntry: @unchecked Sendable {} -extension ProtobufUnittest_TestRecursiveMapMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_MapEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "MAP_ENUM_FOO"), - 1: .same(proto: "MAP_ENUM_BAR"), - 2: .same(proto: "MAP_ENUM_BAZ"), - ] +extension SwiftProtoTesting_MapEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0MAP_ENUM_FOO\0\u{1}MAP_ENUM_BAR\0\u{1}MAP_ENUM_BAZ\0") } -extension ProtobufUnittest_TestMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_TestMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "map_int32_int32"), - 2: .standard(proto: "map_int64_int64"), - 3: .standard(proto: "map_uint32_uint32"), - 4: .standard(proto: "map_uint64_uint64"), - 5: .standard(proto: "map_sint32_sint32"), - 6: .standard(proto: "map_sint64_sint64"), - 7: .standard(proto: "map_fixed32_fixed32"), - 8: .standard(proto: "map_fixed64_fixed64"), - 9: .standard(proto: "map_sfixed32_sfixed32"), - 10: .standard(proto: "map_sfixed64_sfixed64"), - 11: .standard(proto: "map_int32_float"), - 12: .standard(proto: "map_int32_double"), - 13: .standard(proto: "map_bool_bool"), - 14: .standard(proto: "map_string_string"), - 15: .standard(proto: "map_int32_bytes"), - 16: .standard(proto: "map_int32_enum"), - 17: .standard(proto: "map_int32_foreign_message"), - 18: .standard(proto: "map_string_foreign_message"), - 19: .standard(proto: "map_int32_all_types"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_int32_bytes\0\u{3}map_int32_enum\0\u{3}map_int32_foreign_message\0\u{3}map_string_foreign_message\0\u{3}map_int32_all_types\0") fileprivate class _StorageClass { var _mapInt32Int32: Dictionary = [:] @@ -501,12 +250,16 @@ extension ProtobufUnittest_TestMap: SwiftProtobuf.Message, SwiftProtobuf._Messag var _mapBoolBool: Dictionary = [:] var _mapStringString: Dictionary = [:] var _mapInt32Bytes: Dictionary = [:] - var _mapInt32Enum: Dictionary = [:] - var _mapInt32ForeignMessage: Dictionary = [:] - var _mapStringForeignMessage: Dictionary = [:] - var _mapInt32AllTypes: Dictionary = [:] + var _mapInt32Enum: Dictionary = [:] + var _mapInt32ForeignMessage: Dictionary = [:] + var _mapStringForeignMessage: Dictionary = [:] + var _mapInt32AllTypes: Dictionary = [:] - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -563,10 +316,10 @@ extension ProtobufUnittest_TestMap: SwiftProtobuf.Message, SwiftProtobuf._Messag case 13: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() case 14: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() case 15: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bytes) }() - case 16: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() - case 17: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32ForeignMessage) }() - case 18: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() - case 19: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32AllTypes) }() + case 16: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() + case 17: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32ForeignMessage) }() + case 18: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() + case 19: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32AllTypes) }() default: break } } @@ -621,22 +374,22 @@ extension ProtobufUnittest_TestMap: SwiftProtobuf.Message, SwiftProtobuf._Messag try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bytes, fieldNumber: 15) } if !_storage._mapInt32Enum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 16) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 16) } if !_storage._mapInt32ForeignMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32ForeignMessage, fieldNumber: 17) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32ForeignMessage, fieldNumber: 17) } if !_storage._mapStringForeignMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 18) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 18) } if !_storage._mapInt32AllTypes.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32AllTypes, fieldNumber: 19) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32AllTypes, fieldNumber: 19) } } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestMap, rhs: ProtobufUnittest_TestMap) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestMap, rhs: SwiftProtoTesting_TestMap) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -669,117 +422,9 @@ extension ProtobufUnittest_TestMap: SwiftProtobuf.Message, SwiftProtobuf._Messag } } -extension ProtobufUnittest_TestMapSubmessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMapSubmessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "test_map"), - ] - - 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.decodeSingularMessageField(value: &self._testMap) }() - 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 - try { if let v = self._testMap { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMapSubmessage, rhs: ProtobufUnittest_TestMapSubmessage) -> Bool { - if lhs._testMap != rhs._testMap {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestMessageMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMessageMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "map_int32_message"), - ] - - 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapInt32Message) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.mapInt32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapInt32Message, fieldNumber: 1) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMessageMap, rhs: ProtobufUnittest_TestMessageMap) -> Bool { - if lhs.mapInt32Message != rhs.mapInt32Message {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestSameTypeMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestSameTypeMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "map1"), - 2: .same(proto: "map2"), - ] - - 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.map1) }() - case 2: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.map2) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.map1.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.map1, fieldNumber: 1) - } - if !self.map2.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.map2, fieldNumber: 2) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestSameTypeMap, rhs: ProtobufUnittest_TestSameTypeMap) -> Bool { - if lhs.map1 != rhs.map1 {return false} - if lhs.map2 != rhs.map2 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestRequiredMessageMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_TestRequiredMessageMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestRequiredMessageMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "map_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}map_field\0") public var isInitialized: Bool { if !SwiftProtobuf.Internal.areAllInitialized(self.mapField) {return false} @@ -792,7 +437,7 @@ extension ProtobufUnittest_TestRequiredMessageMap: SwiftProtobuf.Message, SwiftP // 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapField) }() + case 1: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.mapField) }() default: break } } @@ -800,285 +445,21 @@ extension ProtobufUnittest_TestRequiredMessageMap: SwiftProtobuf.Message, SwiftP func traverse(visitor: inout V) throws { if !self.mapField.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapField, fieldNumber: 1) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.mapField, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestRequiredMessageMap, rhs: ProtobufUnittest_TestRequiredMessageMap) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestRequiredMessageMap, rhs: SwiftProtoTesting_TestRequiredMessageMap) -> Bool { if lhs.mapField != rhs.mapField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestArenaMap: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestArenaMap" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "map_int32_int32"), - 2: .standard(proto: "map_int64_int64"), - 3: .standard(proto: "map_uint32_uint32"), - 4: .standard(proto: "map_uint64_uint64"), - 5: .standard(proto: "map_sint32_sint32"), - 6: .standard(proto: "map_sint64_sint64"), - 7: .standard(proto: "map_fixed32_fixed32"), - 8: .standard(proto: "map_fixed64_fixed64"), - 9: .standard(proto: "map_sfixed32_sfixed32"), - 10: .standard(proto: "map_sfixed64_sfixed64"), - 11: .standard(proto: "map_int32_float"), - 12: .standard(proto: "map_int32_double"), - 13: .standard(proto: "map_bool_bool"), - 14: .standard(proto: "map_string_string"), - 15: .standard(proto: "map_int32_bytes"), - 16: .standard(proto: "map_int32_enum"), - 17: .standard(proto: "map_int32_foreign_message"), - ] - - fileprivate class _StorageClass { - var _mapInt32Int32: Dictionary = [:] - var _mapInt64Int64: Dictionary = [:] - var _mapUint32Uint32: Dictionary = [:] - var _mapUint64Uint64: Dictionary = [:] - var _mapSint32Sint32: Dictionary = [:] - var _mapSint64Sint64: Dictionary = [:] - var _mapFixed32Fixed32: Dictionary = [:] - var _mapFixed64Fixed64: Dictionary = [:] - var _mapSfixed32Sfixed32: Dictionary = [:] - var _mapSfixed64Sfixed64: Dictionary = [:] - var _mapInt32Float: Dictionary = [:] - var _mapInt32Double: Dictionary = [:] - var _mapBoolBool: Dictionary = [:] - var _mapStringString: Dictionary = [:] - var _mapInt32Bytes: Dictionary = [:] - var _mapInt32Enum: Dictionary = [:] - var _mapInt32ForeignMessage: Dictionary = [:] - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _mapInt32Int32 = source._mapInt32Int32 - _mapInt64Int64 = source._mapInt64Int64 - _mapUint32Uint32 = source._mapUint32Uint32 - _mapUint64Uint64 = source._mapUint64Uint64 - _mapSint32Sint32 = source._mapSint32Sint32 - _mapSint64Sint64 = source._mapSint64Sint64 - _mapFixed32Fixed32 = source._mapFixed32Fixed32 - _mapFixed64Fixed64 = source._mapFixed64Fixed64 - _mapSfixed32Sfixed32 = source._mapSfixed32Sfixed32 - _mapSfixed64Sfixed64 = source._mapSfixed64Sfixed64 - _mapInt32Float = source._mapInt32Float - _mapInt32Double = source._mapInt32Double - _mapBoolBool = source._mapBoolBool - _mapStringString = source._mapStringString - _mapInt32Bytes = source._mapInt32Bytes - _mapInt32Enum = source._mapInt32Enum - _mapInt32ForeignMessage = source._mapInt32ForeignMessage - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Int32) }() - case 2: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() - case 3: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() - case 4: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint64Uint64) }() - case 5: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint32Sint32) }() - case 6: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSint64Sint64) }() - case 7: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed32Fixed32) }() - case 8: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapFixed64Fixed64) }() - case 9: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed32Sfixed32) }() - case 10: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapSfixed64Sfixed64) }() - case 11: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Float) }() - case 12: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Double) }() - case 13: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() - case 14: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() - case 15: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bytes) }() - case 16: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() - case 17: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32ForeignMessage) }() - default: break - } - } - } - } - - func traverse(visitor: inout V) throws { - try withExtendedLifetime(_storage) { (_storage: _StorageClass) in - if !_storage._mapInt32Int32.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Int32, fieldNumber: 1) - } - if !_storage._mapInt64Int64.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt64Int64, fieldNumber: 2) - } - if !_storage._mapUint32Uint32.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint32Uint32, fieldNumber: 3) - } - if !_storage._mapUint64Uint64.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapUint64Uint64, fieldNumber: 4) - } - if !_storage._mapSint32Sint32.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint32Sint32, fieldNumber: 5) - } - if !_storage._mapSint64Sint64.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSint64Sint64, fieldNumber: 6) - } - if !_storage._mapFixed32Fixed32.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed32Fixed32, fieldNumber: 7) - } - if !_storage._mapFixed64Fixed64.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapFixed64Fixed64, fieldNumber: 8) - } - if !_storage._mapSfixed32Sfixed32.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed32Sfixed32, fieldNumber: 9) - } - if !_storage._mapSfixed64Sfixed64.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapSfixed64Sfixed64, fieldNumber: 10) - } - if !_storage._mapInt32Float.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Float, fieldNumber: 11) - } - if !_storage._mapInt32Double.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Double, fieldNumber: 12) - } - if !_storage._mapBoolBool.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapBoolBool, fieldNumber: 13) - } - if !_storage._mapStringString.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringString, fieldNumber: 14) - } - if !_storage._mapInt32Bytes.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bytes, fieldNumber: 15) - } - if !_storage._mapInt32Enum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 16) - } - if !_storage._mapInt32ForeignMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32ForeignMessage, fieldNumber: 17) - } - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestArenaMap, rhs: ProtobufUnittest_TestArenaMap) -> 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._mapInt32Int32 != rhs_storage._mapInt32Int32 {return false} - if _storage._mapInt64Int64 != rhs_storage._mapInt64Int64 {return false} - if _storage._mapUint32Uint32 != rhs_storage._mapUint32Uint32 {return false} - if _storage._mapUint64Uint64 != rhs_storage._mapUint64Uint64 {return false} - if _storage._mapSint32Sint32 != rhs_storage._mapSint32Sint32 {return false} - if _storage._mapSint64Sint64 != rhs_storage._mapSint64Sint64 {return false} - if _storage._mapFixed32Fixed32 != rhs_storage._mapFixed32Fixed32 {return false} - if _storage._mapFixed64Fixed64 != rhs_storage._mapFixed64Fixed64 {return false} - if _storage._mapSfixed32Sfixed32 != rhs_storage._mapSfixed32Sfixed32 {return false} - if _storage._mapSfixed64Sfixed64 != rhs_storage._mapSfixed64Sfixed64 {return false} - if _storage._mapInt32Float != rhs_storage._mapInt32Float {return false} - if _storage._mapInt32Double != rhs_storage._mapInt32Double {return false} - if _storage._mapBoolBool != rhs_storage._mapBoolBool {return false} - if _storage._mapStringString != rhs_storage._mapStringString {return false} - if _storage._mapInt32Bytes != rhs_storage._mapInt32Bytes {return false} - if _storage._mapInt32Enum != rhs_storage._mapInt32Enum {return false} - if _storage._mapInt32ForeignMessage != rhs_storage._mapInt32ForeignMessage {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_MessageContainingEnumCalledType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".MessageContainingEnumCalledType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "type"), - ] - - 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.type) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.type.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.type, fieldNumber: 1) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_MessageContainingEnumCalledType, rhs: ProtobufUnittest_MessageContainingEnumCalledType) -> Bool { - if lhs.type != rhs.type {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_MessageContainingEnumCalledType.TypeEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "TYPE_FOO"), - ] -} - -extension ProtobufUnittest_MessageContainingMapCalledEntry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".MessageContainingMapCalledEntry" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "entry"), - ] - - 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.entry) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.entry.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.entry, fieldNumber: 1) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_MessageContainingMapCalledEntry, rhs: ProtobufUnittest_MessageContainingMapCalledEntry) -> Bool { - if lhs.entry != rhs.entry {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestRecursiveMapMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_TestRecursiveMapMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestRecursiveMapMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1086,7 +467,7 @@ extension ProtobufUnittest_TestRecursiveMapMessage: SwiftProtobuf.Message, Swift // 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.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.a) }() + case 1: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &self.a) }() default: break } } @@ -1094,12 +475,12 @@ extension ProtobufUnittest_TestRecursiveMapMessage: SwiftProtobuf.Message, Swift func traverse(visitor: inout V) throws { if !self.a.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.a, fieldNumber: 1) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: self.a, fieldNumber: 1) } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestRecursiveMapMessage, rhs: ProtobufUnittest_TestRecursiveMapMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestRecursiveMapMessage, rhs: SwiftProtoTesting_TestRecursiveMapMessage) -> Bool { if lhs.a != rhs.a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Tests/SwiftProtobufTests/test_messages_proto3.pb.swift b/Tests/SwiftProtobufTests/test_messages_proto3.pb.swift index 4bd18c700..e23805db1 100644 --- a/Tests/SwiftProtobufTests/test_messages_proto3.pb.swift +++ b/Tests/SwiftProtobufTests/test_messages_proto3.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/test_messages_proto3.proto +// Source: test_messages_proto3.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -36,12 +37,6 @@ // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// -// Test schema for proto3 messages. This test schema is used by: -// -// - benchmarks -// - fuzz tests -// - conformance tests import Foundation import SwiftProtobuf @@ -56,50 +51,6 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum ProtobufTestMessages_Proto3_ForeignEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foreignFoo // = 0 - case foreignBar // = 1 - case foreignBaz // = 2 - case UNRECOGNIZED(Int) - - init() { - self = .foreignFoo - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .foreignFoo - case 1: self = .foreignBar - case 2: self = .foreignBaz - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .foreignFoo: return 0 - case .foreignBar: return 1 - case .foreignBaz: return 2 - case .UNRECOGNIZED(let i): return i - } - } - -} - -#if swift(>=4.2) - -extension ProtobufTestMessages_Proto3_ForeignEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufTestMessages_Proto3_ForeignEnum] = [ - .foreignFoo, - .foreignBar, - .foreignBaz, - ] -} - -#endif // swift(>=4.2) - /// This proto includes every type of field in both singular and repeated /// forms. /// @@ -107,483 +58,273 @@ extension ProtobufTestMessages_Proto3_ForeignEnum: CaseIterable { /// submessages of this message. So for example, a fuzz test of TestAllTypes /// could trigger bugs that occur in any message type in this file. We verify /// this stays true in a unit test. -struct ProtobufTestMessages_Proto3_TestAllTypesProto3 { +struct SwiftProtoTesting_Test3_TestAllTypesProto3: @unchecked Sendable { // 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. /// Singular var optionalInt32: Int32 { - get {return _storage._optionalInt32} + get {_storage._optionalInt32} set {_uniqueStorage()._optionalInt32 = newValue} } var optionalInt64: Int64 { - get {return _storage._optionalInt64} + get {_storage._optionalInt64} set {_uniqueStorage()._optionalInt64 = newValue} } var optionalUint32: UInt32 { - get {return _storage._optionalUint32} + get {_storage._optionalUint32} set {_uniqueStorage()._optionalUint32 = newValue} } var optionalUint64: UInt64 { - get {return _storage._optionalUint64} + get {_storage._optionalUint64} set {_uniqueStorage()._optionalUint64 = newValue} } var optionalSint32: Int32 { - get {return _storage._optionalSint32} + get {_storage._optionalSint32} set {_uniqueStorage()._optionalSint32 = newValue} } var optionalSint64: Int64 { - get {return _storage._optionalSint64} + get {_storage._optionalSint64} set {_uniqueStorage()._optionalSint64 = newValue} } var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32} + get {_storage._optionalFixed32} set {_uniqueStorage()._optionalFixed32 = newValue} } var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64} + get {_storage._optionalFixed64} set {_uniqueStorage()._optionalFixed64 = newValue} } var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32} + get {_storage._optionalSfixed32} set {_uniqueStorage()._optionalSfixed32 = newValue} } var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64} + get {_storage._optionalSfixed64} set {_uniqueStorage()._optionalSfixed64 = newValue} } var optionalFloat: Float { - get {return _storage._optionalFloat} + get {_storage._optionalFloat} set {_uniqueStorage()._optionalFloat = newValue} } var optionalDouble: Double { - get {return _storage._optionalDouble} + get {_storage._optionalDouble} set {_uniqueStorage()._optionalDouble = newValue} } var optionalBool: Bool { - get {return _storage._optionalBool} + get {_storage._optionalBool} set {_uniqueStorage()._optionalBool = newValue} } var optionalString: String { - get {return _storage._optionalString} + get {_storage._optionalString} set {_uniqueStorage()._optionalString = newValue} } var optionalBytes: Data { - get {return _storage._optionalBytes} + get {_storage._optionalBytes} set {_uniqueStorage()._optionalBytes = newValue} } - var optionalNestedMessage: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage { - get {return _storage._optionalNestedMessage ?? ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage()} + var optionalNestedMessage: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage { + get {_storage._optionalNestedMessage ?? SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage()} set {_uniqueStorage()._optionalNestedMessage = newValue} } /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} - var optionalForeignMessage: ProtobufTestMessages_Proto3_ForeignMessage { - get {return _storage._optionalForeignMessage ?? ProtobufTestMessages_Proto3_ForeignMessage()} - set {_uniqueStorage()._optionalForeignMessage = newValue} - } - /// Returns true if `optionalForeignMessage` has been explicitly set. - var hasOptionalForeignMessage: Bool {return _storage._optionalForeignMessage != nil} - /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} - - var optionalNestedEnum: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum { - get {return _storage._optionalNestedEnum} + var optionalNestedEnum: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum { + get {_storage._optionalNestedEnum} set {_uniqueStorage()._optionalNestedEnum = newValue} } - var optionalForeignEnum: ProtobufTestMessages_Proto3_ForeignEnum { - get {return _storage._optionalForeignEnum} - set {_uniqueStorage()._optionalForeignEnum = newValue} - } - - var optionalAliasedEnum: ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum { - get {return _storage._optionalAliasedEnum} - set {_uniqueStorage()._optionalAliasedEnum = newValue} - } - - var optionalStringPiece: String { - get {return _storage._optionalStringPiece} - set {_uniqueStorage()._optionalStringPiece = newValue} - } - - var optionalCord: String { - get {return _storage._optionalCord} - set {_uniqueStorage()._optionalCord = newValue} - } - - var recursiveMessage: ProtobufTestMessages_Proto3_TestAllTypesProto3 { - get {return _storage._recursiveMessage ?? ProtobufTestMessages_Proto3_TestAllTypesProto3()} - set {_uniqueStorage()._recursiveMessage = newValue} - } - /// Returns true if `recursiveMessage` has been explicitly set. - var hasRecursiveMessage: Bool {return _storage._recursiveMessage != nil} - /// Clears the value of `recursiveMessage`. Subsequent reads from it will return its default value. - mutating func clearRecursiveMessage() {_uniqueStorage()._recursiveMessage = nil} - /// Repeated var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } - var repeatedNestedMessage: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage] { - get {return _storage._repeatedNestedMessage} + var repeatedNestedMessage: [SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage] { + get {_storage._repeatedNestedMessage} set {_uniqueStorage()._repeatedNestedMessage = newValue} } - var repeatedForeignMessage: [ProtobufTestMessages_Proto3_ForeignMessage] { - get {return _storage._repeatedForeignMessage} - set {_uniqueStorage()._repeatedForeignMessage = newValue} - } - - var repeatedNestedEnum: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] { - get {return _storage._repeatedNestedEnum} + var repeatedNestedEnum: [SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum] { + get {_storage._repeatedNestedEnum} set {_uniqueStorage()._repeatedNestedEnum = newValue} } - var repeatedForeignEnum: [ProtobufTestMessages_Proto3_ForeignEnum] { - get {return _storage._repeatedForeignEnum} - set {_uniqueStorage()._repeatedForeignEnum = newValue} - } - - var repeatedStringPiece: [String] { - get {return _storage._repeatedStringPiece} - set {_uniqueStorage()._repeatedStringPiece = newValue} - } - - var repeatedCord: [String] { - get {return _storage._repeatedCord} - set {_uniqueStorage()._repeatedCord = newValue} - } - - /// Packed - var packedInt32: [Int32] { - get {return _storage._packedInt32} - set {_uniqueStorage()._packedInt32 = newValue} - } - - var packedInt64: [Int64] { - get {return _storage._packedInt64} - set {_uniqueStorage()._packedInt64 = newValue} - } - - var packedUint32: [UInt32] { - get {return _storage._packedUint32} - set {_uniqueStorage()._packedUint32 = newValue} - } - - var packedUint64: [UInt64] { - get {return _storage._packedUint64} - set {_uniqueStorage()._packedUint64 = newValue} - } - - var packedSint32: [Int32] { - get {return _storage._packedSint32} - set {_uniqueStorage()._packedSint32 = newValue} - } - - var packedSint64: [Int64] { - get {return _storage._packedSint64} - set {_uniqueStorage()._packedSint64 = newValue} - } - - var packedFixed32: [UInt32] { - get {return _storage._packedFixed32} - set {_uniqueStorage()._packedFixed32 = newValue} - } - - var packedFixed64: [UInt64] { - get {return _storage._packedFixed64} - set {_uniqueStorage()._packedFixed64 = newValue} - } - - var packedSfixed32: [Int32] { - get {return _storage._packedSfixed32} - set {_uniqueStorage()._packedSfixed32 = newValue} - } - - var packedSfixed64: [Int64] { - get {return _storage._packedSfixed64} - set {_uniqueStorage()._packedSfixed64 = newValue} - } - - var packedFloat: [Float] { - get {return _storage._packedFloat} - set {_uniqueStorage()._packedFloat = newValue} - } - - var packedDouble: [Double] { - get {return _storage._packedDouble} - set {_uniqueStorage()._packedDouble = newValue} - } - - var packedBool: [Bool] { - get {return _storage._packedBool} - set {_uniqueStorage()._packedBool = newValue} - } - - var packedNestedEnum: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] { - get {return _storage._packedNestedEnum} - set {_uniqueStorage()._packedNestedEnum = newValue} - } - - /// Unpacked - var unpackedInt32: [Int32] { - get {return _storage._unpackedInt32} - set {_uniqueStorage()._unpackedInt32 = newValue} - } - - var unpackedInt64: [Int64] { - get {return _storage._unpackedInt64} - set {_uniqueStorage()._unpackedInt64 = newValue} - } - - var unpackedUint32: [UInt32] { - get {return _storage._unpackedUint32} - set {_uniqueStorage()._unpackedUint32 = newValue} - } - - var unpackedUint64: [UInt64] { - get {return _storage._unpackedUint64} - set {_uniqueStorage()._unpackedUint64 = newValue} - } - - var unpackedSint32: [Int32] { - get {return _storage._unpackedSint32} - set {_uniqueStorage()._unpackedSint32 = newValue} - } - - var unpackedSint64: [Int64] { - get {return _storage._unpackedSint64} - set {_uniqueStorage()._unpackedSint64 = newValue} - } - - var unpackedFixed32: [UInt32] { - get {return _storage._unpackedFixed32} - set {_uniqueStorage()._unpackedFixed32 = newValue} - } - - var unpackedFixed64: [UInt64] { - get {return _storage._unpackedFixed64} - set {_uniqueStorage()._unpackedFixed64 = newValue} - } - - var unpackedSfixed32: [Int32] { - get {return _storage._unpackedSfixed32} - set {_uniqueStorage()._unpackedSfixed32 = newValue} - } - - var unpackedSfixed64: [Int64] { - get {return _storage._unpackedSfixed64} - set {_uniqueStorage()._unpackedSfixed64 = newValue} - } - - var unpackedFloat: [Float] { - get {return _storage._unpackedFloat} - set {_uniqueStorage()._unpackedFloat = newValue} - } - - var unpackedDouble: [Double] { - get {return _storage._unpackedDouble} - set {_uniqueStorage()._unpackedDouble = newValue} - } - - var unpackedBool: [Bool] { - get {return _storage._unpackedBool} - set {_uniqueStorage()._unpackedBool = newValue} - } - - var unpackedNestedEnum: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] { - get {return _storage._unpackedNestedEnum} - set {_uniqueStorage()._unpackedNestedEnum = newValue} - } - /// Map var mapInt32Int32: Dictionary { - get {return _storage._mapInt32Int32} + get {_storage._mapInt32Int32} set {_uniqueStorage()._mapInt32Int32 = newValue} } var mapInt64Int64: Dictionary { - get {return _storage._mapInt64Int64} + get {_storage._mapInt64Int64} set {_uniqueStorage()._mapInt64Int64 = newValue} } var mapUint32Uint32: Dictionary { - get {return _storage._mapUint32Uint32} + get {_storage._mapUint32Uint32} set {_uniqueStorage()._mapUint32Uint32 = newValue} } var mapUint64Uint64: Dictionary { - get {return _storage._mapUint64Uint64} + get {_storage._mapUint64Uint64} set {_uniqueStorage()._mapUint64Uint64 = newValue} } var mapSint32Sint32: Dictionary { - get {return _storage._mapSint32Sint32} + get {_storage._mapSint32Sint32} set {_uniqueStorage()._mapSint32Sint32 = newValue} } var mapSint64Sint64: Dictionary { - get {return _storage._mapSint64Sint64} + get {_storage._mapSint64Sint64} set {_uniqueStorage()._mapSint64Sint64 = newValue} } var mapFixed32Fixed32: Dictionary { - get {return _storage._mapFixed32Fixed32} + get {_storage._mapFixed32Fixed32} set {_uniqueStorage()._mapFixed32Fixed32 = newValue} } var mapFixed64Fixed64: Dictionary { - get {return _storage._mapFixed64Fixed64} + get {_storage._mapFixed64Fixed64} set {_uniqueStorage()._mapFixed64Fixed64 = newValue} } var mapSfixed32Sfixed32: Dictionary { - get {return _storage._mapSfixed32Sfixed32} + get {_storage._mapSfixed32Sfixed32} set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} } var mapSfixed64Sfixed64: Dictionary { - get {return _storage._mapSfixed64Sfixed64} + get {_storage._mapSfixed64Sfixed64} set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} } var mapInt32Float: Dictionary { - get {return _storage._mapInt32Float} + get {_storage._mapInt32Float} set {_uniqueStorage()._mapInt32Float = newValue} } var mapInt32Double: Dictionary { - get {return _storage._mapInt32Double} + get {_storage._mapInt32Double} set {_uniqueStorage()._mapInt32Double = newValue} } var mapBoolBool: Dictionary { - get {return _storage._mapBoolBool} + get {_storage._mapBoolBool} set {_uniqueStorage()._mapBoolBool = newValue} } var mapStringString: Dictionary { - get {return _storage._mapStringString} + get {_storage._mapStringString} set {_uniqueStorage()._mapStringString = newValue} } var mapStringBytes: Dictionary { - get {return _storage._mapStringBytes} + get {_storage._mapStringBytes} set {_uniqueStorage()._mapStringBytes = newValue} } - var mapStringNestedMessage: Dictionary { - get {return _storage._mapStringNestedMessage} + var mapStringNestedMessage: Dictionary { + get {_storage._mapStringNestedMessage} set {_uniqueStorage()._mapStringNestedMessage = newValue} } - var mapStringForeignMessage: Dictionary { - get {return _storage._mapStringForeignMessage} - set {_uniqueStorage()._mapStringForeignMessage = newValue} - } - - var mapStringNestedEnum: Dictionary { - get {return _storage._mapStringNestedEnum} + var mapStringNestedEnum: Dictionary { + get {_storage._mapStringNestedEnum} set {_uniqueStorage()._mapStringNestedEnum = newValue} } - var mapStringForeignEnum: Dictionary { - get {return _storage._mapStringForeignEnum} - set {_uniqueStorage()._mapStringForeignEnum = newValue} - } - var oneofField: OneOf_OneofField? { get {return _storage._oneofField} set {_uniqueStorage()._oneofField = newValue} @@ -597,10 +338,10 @@ struct ProtobufTestMessages_Proto3_TestAllTypesProto3 { set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} } - var oneofNestedMessage: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage { + var oneofNestedMessage: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage { get { if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} - return ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage() + return SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage() } set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} } @@ -653,7 +394,7 @@ struct ProtobufTestMessages_Proto3_TestAllTypesProto3 { set {_uniqueStorage()._oneofField = .oneofDouble(newValue)} } - var oneofEnum: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum { + var oneofEnum: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum { get { if case .oneofEnum(let v)? = _storage._oneofField {return v} return .foo @@ -671,384 +412,334 @@ struct ProtobufTestMessages_Proto3_TestAllTypesProto3 { /// Well-known types var optionalBoolWrapper: SwiftProtobuf.Google_Protobuf_BoolValue { - get {return _storage._optionalBoolWrapper ?? SwiftProtobuf.Google_Protobuf_BoolValue()} + get {_storage._optionalBoolWrapper ?? SwiftProtobuf.Google_Protobuf_BoolValue()} set {_uniqueStorage()._optionalBoolWrapper = newValue} } /// Returns true if `optionalBoolWrapper` has been explicitly set. - var hasOptionalBoolWrapper: Bool {return _storage._optionalBoolWrapper != nil} + var hasOptionalBoolWrapper: Bool {_storage._optionalBoolWrapper != nil} /// Clears the value of `optionalBoolWrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalBoolWrapper() {_uniqueStorage()._optionalBoolWrapper = nil} var optionalInt32Wrapper: SwiftProtobuf.Google_Protobuf_Int32Value { - get {return _storage._optionalInt32Wrapper ?? SwiftProtobuf.Google_Protobuf_Int32Value()} + get {_storage._optionalInt32Wrapper ?? SwiftProtobuf.Google_Protobuf_Int32Value()} set {_uniqueStorage()._optionalInt32Wrapper = newValue} } /// Returns true if `optionalInt32Wrapper` has been explicitly set. - var hasOptionalInt32Wrapper: Bool {return _storage._optionalInt32Wrapper != nil} + var hasOptionalInt32Wrapper: Bool {_storage._optionalInt32Wrapper != nil} /// Clears the value of `optionalInt32Wrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalInt32Wrapper() {_uniqueStorage()._optionalInt32Wrapper = nil} var optionalInt64Wrapper: SwiftProtobuf.Google_Protobuf_Int64Value { - get {return _storage._optionalInt64Wrapper ?? SwiftProtobuf.Google_Protobuf_Int64Value()} + get {_storage._optionalInt64Wrapper ?? SwiftProtobuf.Google_Protobuf_Int64Value()} set {_uniqueStorage()._optionalInt64Wrapper = newValue} } /// Returns true if `optionalInt64Wrapper` has been explicitly set. - var hasOptionalInt64Wrapper: Bool {return _storage._optionalInt64Wrapper != nil} + var hasOptionalInt64Wrapper: Bool {_storage._optionalInt64Wrapper != nil} /// Clears the value of `optionalInt64Wrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalInt64Wrapper() {_uniqueStorage()._optionalInt64Wrapper = nil} var optionalUint32Wrapper: SwiftProtobuf.Google_Protobuf_UInt32Value { - get {return _storage._optionalUint32Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} + get {_storage._optionalUint32Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} set {_uniqueStorage()._optionalUint32Wrapper = newValue} } /// Returns true if `optionalUint32Wrapper` has been explicitly set. - var hasOptionalUint32Wrapper: Bool {return _storage._optionalUint32Wrapper != nil} + var hasOptionalUint32Wrapper: Bool {_storage._optionalUint32Wrapper != nil} /// Clears the value of `optionalUint32Wrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalUint32Wrapper() {_uniqueStorage()._optionalUint32Wrapper = nil} var optionalUint64Wrapper: SwiftProtobuf.Google_Protobuf_UInt64Value { - get {return _storage._optionalUint64Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} + get {_storage._optionalUint64Wrapper ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} set {_uniqueStorage()._optionalUint64Wrapper = newValue} } /// Returns true if `optionalUint64Wrapper` has been explicitly set. - var hasOptionalUint64Wrapper: Bool {return _storage._optionalUint64Wrapper != nil} + var hasOptionalUint64Wrapper: Bool {_storage._optionalUint64Wrapper != nil} /// Clears the value of `optionalUint64Wrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalUint64Wrapper() {_uniqueStorage()._optionalUint64Wrapper = nil} var optionalFloatWrapper: SwiftProtobuf.Google_Protobuf_FloatValue { - get {return _storage._optionalFloatWrapper ?? SwiftProtobuf.Google_Protobuf_FloatValue()} + get {_storage._optionalFloatWrapper ?? SwiftProtobuf.Google_Protobuf_FloatValue()} set {_uniqueStorage()._optionalFloatWrapper = newValue} } /// Returns true if `optionalFloatWrapper` has been explicitly set. - var hasOptionalFloatWrapper: Bool {return _storage._optionalFloatWrapper != nil} + var hasOptionalFloatWrapper: Bool {_storage._optionalFloatWrapper != nil} /// Clears the value of `optionalFloatWrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalFloatWrapper() {_uniqueStorage()._optionalFloatWrapper = nil} var optionalDoubleWrapper: SwiftProtobuf.Google_Protobuf_DoubleValue { - get {return _storage._optionalDoubleWrapper ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} + get {_storage._optionalDoubleWrapper ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} set {_uniqueStorage()._optionalDoubleWrapper = newValue} } /// Returns true if `optionalDoubleWrapper` has been explicitly set. - var hasOptionalDoubleWrapper: Bool {return _storage._optionalDoubleWrapper != nil} + var hasOptionalDoubleWrapper: Bool {_storage._optionalDoubleWrapper != nil} /// Clears the value of `optionalDoubleWrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalDoubleWrapper() {_uniqueStorage()._optionalDoubleWrapper = nil} var optionalStringWrapper: SwiftProtobuf.Google_Protobuf_StringValue { - get {return _storage._optionalStringWrapper ?? SwiftProtobuf.Google_Protobuf_StringValue()} + get {_storage._optionalStringWrapper ?? SwiftProtobuf.Google_Protobuf_StringValue()} set {_uniqueStorage()._optionalStringWrapper = newValue} } /// Returns true if `optionalStringWrapper` has been explicitly set. - var hasOptionalStringWrapper: Bool {return _storage._optionalStringWrapper != nil} + var hasOptionalStringWrapper: Bool {_storage._optionalStringWrapper != nil} /// Clears the value of `optionalStringWrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalStringWrapper() {_uniqueStorage()._optionalStringWrapper = nil} var optionalBytesWrapper: SwiftProtobuf.Google_Protobuf_BytesValue { - get {return _storage._optionalBytesWrapper ?? SwiftProtobuf.Google_Protobuf_BytesValue()} + get {_storage._optionalBytesWrapper ?? SwiftProtobuf.Google_Protobuf_BytesValue()} set {_uniqueStorage()._optionalBytesWrapper = newValue} } /// Returns true if `optionalBytesWrapper` has been explicitly set. - var hasOptionalBytesWrapper: Bool {return _storage._optionalBytesWrapper != nil} + var hasOptionalBytesWrapper: Bool {_storage._optionalBytesWrapper != nil} /// Clears the value of `optionalBytesWrapper`. Subsequent reads from it will return its default value. mutating func clearOptionalBytesWrapper() {_uniqueStorage()._optionalBytesWrapper = nil} var repeatedBoolWrapper: [SwiftProtobuf.Google_Protobuf_BoolValue] { - get {return _storage._repeatedBoolWrapper} + get {_storage._repeatedBoolWrapper} set {_uniqueStorage()._repeatedBoolWrapper = newValue} } var repeatedInt32Wrapper: [SwiftProtobuf.Google_Protobuf_Int32Value] { - get {return _storage._repeatedInt32Wrapper} + get {_storage._repeatedInt32Wrapper} set {_uniqueStorage()._repeatedInt32Wrapper = newValue} } var repeatedInt64Wrapper: [SwiftProtobuf.Google_Protobuf_Int64Value] { - get {return _storage._repeatedInt64Wrapper} + get {_storage._repeatedInt64Wrapper} set {_uniqueStorage()._repeatedInt64Wrapper = newValue} } var repeatedUint32Wrapper: [SwiftProtobuf.Google_Protobuf_UInt32Value] { - get {return _storage._repeatedUint32Wrapper} + get {_storage._repeatedUint32Wrapper} set {_uniqueStorage()._repeatedUint32Wrapper = newValue} } var repeatedUint64Wrapper: [SwiftProtobuf.Google_Protobuf_UInt64Value] { - get {return _storage._repeatedUint64Wrapper} + get {_storage._repeatedUint64Wrapper} set {_uniqueStorage()._repeatedUint64Wrapper = newValue} } var repeatedFloatWrapper: [SwiftProtobuf.Google_Protobuf_FloatValue] { - get {return _storage._repeatedFloatWrapper} + get {_storage._repeatedFloatWrapper} set {_uniqueStorage()._repeatedFloatWrapper = newValue} } var repeatedDoubleWrapper: [SwiftProtobuf.Google_Protobuf_DoubleValue] { - get {return _storage._repeatedDoubleWrapper} + get {_storage._repeatedDoubleWrapper} set {_uniqueStorage()._repeatedDoubleWrapper = newValue} } var repeatedStringWrapper: [SwiftProtobuf.Google_Protobuf_StringValue] { - get {return _storage._repeatedStringWrapper} + get {_storage._repeatedStringWrapper} set {_uniqueStorage()._repeatedStringWrapper = newValue} } var repeatedBytesWrapper: [SwiftProtobuf.Google_Protobuf_BytesValue] { - get {return _storage._repeatedBytesWrapper} + get {_storage._repeatedBytesWrapper} set {_uniqueStorage()._repeatedBytesWrapper = newValue} } var optionalDuration: SwiftProtobuf.Google_Protobuf_Duration { - get {return _storage._optionalDuration ?? SwiftProtobuf.Google_Protobuf_Duration()} + get {_storage._optionalDuration ?? SwiftProtobuf.Google_Protobuf_Duration()} set {_uniqueStorage()._optionalDuration = newValue} } /// Returns true if `optionalDuration` has been explicitly set. - var hasOptionalDuration: Bool {return _storage._optionalDuration != nil} + var hasOptionalDuration: Bool {_storage._optionalDuration != nil} /// Clears the value of `optionalDuration`. Subsequent reads from it will return its default value. mutating func clearOptionalDuration() {_uniqueStorage()._optionalDuration = nil} var optionalTimestamp: SwiftProtobuf.Google_Protobuf_Timestamp { - get {return _storage._optionalTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()} + get {_storage._optionalTimestamp ?? SwiftProtobuf.Google_Protobuf_Timestamp()} set {_uniqueStorage()._optionalTimestamp = newValue} } /// Returns true if `optionalTimestamp` has been explicitly set. - var hasOptionalTimestamp: Bool {return _storage._optionalTimestamp != nil} + var hasOptionalTimestamp: Bool {_storage._optionalTimestamp != nil} /// Clears the value of `optionalTimestamp`. Subsequent reads from it will return its default value. mutating func clearOptionalTimestamp() {_uniqueStorage()._optionalTimestamp = nil} var optionalFieldMask: SwiftProtobuf.Google_Protobuf_FieldMask { - get {return _storage._optionalFieldMask ?? SwiftProtobuf.Google_Protobuf_FieldMask()} + get {_storage._optionalFieldMask ?? SwiftProtobuf.Google_Protobuf_FieldMask()} set {_uniqueStorage()._optionalFieldMask = newValue} } /// Returns true if `optionalFieldMask` has been explicitly set. - var hasOptionalFieldMask: Bool {return _storage._optionalFieldMask != nil} + var hasOptionalFieldMask: Bool {_storage._optionalFieldMask != nil} /// Clears the value of `optionalFieldMask`. Subsequent reads from it will return its default value. mutating func clearOptionalFieldMask() {_uniqueStorage()._optionalFieldMask = nil} var optionalStruct: SwiftProtobuf.Google_Protobuf_Struct { - get {return _storage._optionalStruct ?? SwiftProtobuf.Google_Protobuf_Struct()} + get {_storage._optionalStruct ?? SwiftProtobuf.Google_Protobuf_Struct()} set {_uniqueStorage()._optionalStruct = newValue} } /// Returns true if `optionalStruct` has been explicitly set. - var hasOptionalStruct: Bool {return _storage._optionalStruct != nil} + var hasOptionalStruct: Bool {_storage._optionalStruct != nil} /// Clears the value of `optionalStruct`. Subsequent reads from it will return its default value. mutating func clearOptionalStruct() {_uniqueStorage()._optionalStruct = nil} var optionalAny: SwiftProtobuf.Google_Protobuf_Any { - get {return _storage._optionalAny ?? SwiftProtobuf.Google_Protobuf_Any()} + get {_storage._optionalAny ?? SwiftProtobuf.Google_Protobuf_Any()} set {_uniqueStorage()._optionalAny = newValue} } /// Returns true if `optionalAny` has been explicitly set. - var hasOptionalAny: Bool {return _storage._optionalAny != nil} + var hasOptionalAny: Bool {_storage._optionalAny != nil} /// Clears the value of `optionalAny`. Subsequent reads from it will return its default value. mutating func clearOptionalAny() {_uniqueStorage()._optionalAny = nil} var optionalValue: SwiftProtobuf.Google_Protobuf_Value { - get {return _storage._optionalValue ?? SwiftProtobuf.Google_Protobuf_Value()} + get {_storage._optionalValue ?? SwiftProtobuf.Google_Protobuf_Value()} set {_uniqueStorage()._optionalValue = newValue} } /// Returns true if `optionalValue` has been explicitly set. - var hasOptionalValue: Bool {return _storage._optionalValue != nil} + var hasOptionalValue: Bool {_storage._optionalValue != nil} /// Clears the value of `optionalValue`. Subsequent reads from it will return its default value. mutating func clearOptionalValue() {_uniqueStorage()._optionalValue = nil} var optionalNullValue: SwiftProtobuf.Google_Protobuf_NullValue { - get {return _storage._optionalNullValue} + get {_storage._optionalNullValue} set {_uniqueStorage()._optionalNullValue = newValue} } var repeatedDuration: [SwiftProtobuf.Google_Protobuf_Duration] { - get {return _storage._repeatedDuration} + get {_storage._repeatedDuration} set {_uniqueStorage()._repeatedDuration = newValue} } var repeatedTimestamp: [SwiftProtobuf.Google_Protobuf_Timestamp] { - get {return _storage._repeatedTimestamp} + get {_storage._repeatedTimestamp} set {_uniqueStorage()._repeatedTimestamp = newValue} } var repeatedFieldmask: [SwiftProtobuf.Google_Protobuf_FieldMask] { - get {return _storage._repeatedFieldmask} + get {_storage._repeatedFieldmask} set {_uniqueStorage()._repeatedFieldmask = newValue} } var repeatedStruct: [SwiftProtobuf.Google_Protobuf_Struct] { - get {return _storage._repeatedStruct} + get {_storage._repeatedStruct} set {_uniqueStorage()._repeatedStruct = newValue} } var repeatedAny: [SwiftProtobuf.Google_Protobuf_Any] { - get {return _storage._repeatedAny} + get {_storage._repeatedAny} set {_uniqueStorage()._repeatedAny = newValue} } var repeatedValue: [SwiftProtobuf.Google_Protobuf_Value] { - get {return _storage._repeatedValue} + get {_storage._repeatedValue} set {_uniqueStorage()._repeatedValue = newValue} } var repeatedListValue: [SwiftProtobuf.Google_Protobuf_ListValue] { - get {return _storage._repeatedListValue} + get {_storage._repeatedListValue} set {_uniqueStorage()._repeatedListValue = newValue} } /// Test field-name-to-JSON-name convention. /// (protobuf says names can be any valid C/C++ identifier.) var fieldname1: Int32 { - get {return _storage._fieldname1} + get {_storage._fieldname1} set {_uniqueStorage()._fieldname1 = newValue} } var fieldName2: Int32 { - get {return _storage._fieldName2} + get {_storage._fieldName2} set {_uniqueStorage()._fieldName2 = newValue} } var fieldName3: Int32 { - get {return _storage._fieldName3} + get {_storage._fieldName3} set {_uniqueStorage()._fieldName3 = newValue} } var field_Name4_: Int32 { - get {return _storage._field_Name4_} + get {_storage._field_Name4_} set {_uniqueStorage()._field_Name4_ = newValue} } var field0Name5: Int32 { - get {return _storage._field0Name5} + get {_storage._field0Name5} set {_uniqueStorage()._field0Name5 = newValue} } var field0Name6: Int32 { - get {return _storage._field0Name6} + get {_storage._field0Name6} set {_uniqueStorage()._field0Name6 = newValue} } var fieldName7: Int32 { - get {return _storage._fieldName7} + get {_storage._fieldName7} set {_uniqueStorage()._fieldName7 = newValue} } var fieldName8: Int32 { - get {return _storage._fieldName8} + get {_storage._fieldName8} set {_uniqueStorage()._fieldName8 = newValue} } var fieldName9: Int32 { - get {return _storage._fieldName9} + get {_storage._fieldName9} set {_uniqueStorage()._fieldName9 = newValue} } var fieldName10: Int32 { - get {return _storage._fieldName10} + get {_storage._fieldName10} set {_uniqueStorage()._fieldName10 = newValue} } var fieldName11: Int32 { - get {return _storage._fieldName11} + get {_storage._fieldName11} set {_uniqueStorage()._fieldName11 = newValue} } var fieldName12: Int32 { - get {return _storage._fieldName12} + get {_storage._fieldName12} set {_uniqueStorage()._fieldName12 = newValue} } var _FieldName13: Int32 { - get {return _storage.__FieldName13} + get {_storage.__FieldName13} set {_uniqueStorage().__FieldName13 = newValue} } var _FieldName14: Int32 { - get {return _storage.__FieldName14} + get {_storage.__FieldName14} set {_uniqueStorage().__FieldName14 = newValue} } var field_Name15: Int32 { - get {return _storage._field_Name15} + get {_storage._field_Name15} set {_uniqueStorage()._field_Name15 = newValue} } var field_Name16: Int32 { - get {return _storage._field_Name16} + get {_storage._field_Name16} set {_uniqueStorage()._field_Name16 = newValue} } var fieldName17__: Int32 { - get {return _storage._fieldName17__} + get {_storage._fieldName17__} set {_uniqueStorage()._fieldName17__ = newValue} } var fieldName18__: Int32 { - get {return _storage._fieldName18__} + get {_storage._fieldName18__} set {_uniqueStorage()._fieldName18__ = newValue} } var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case oneofUint32(UInt32) - case oneofNestedMessage(ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage) + case oneofNestedMessage(SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage) case oneofString(String) case oneofBytes(Data) case oneofBool(Bool) case oneofUint64(UInt64) case oneofFloat(Float) case oneofDouble(Double) - case oneofEnum(ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum) + case oneofEnum(SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum) case oneofNullValue(SwiftProtobuf.Google_Protobuf_NullValue) - #if !swift(>=4.1) - static func ==(lhs: ProtobufTestMessages_Proto3_TestAllTypesProto3.OneOf_OneofField, rhs: ProtobufTestMessages_Proto3_TestAllTypesProto3.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBool, .oneofBool): return { - guard case .oneofBool(let l) = lhs, case .oneofBool(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint64, .oneofUint64): return { - guard case .oneofUint64(let l) = lhs, case .oneofUint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFloat, .oneofFloat): return { - guard case .oneofFloat(let l) = lhs, case .oneofFloat(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofDouble, .oneofDouble): return { - guard case .oneofDouble(let l) = lhs, case .oneofDouble(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofEnum, .oneofEnum): return { - guard case .oneofEnum(let l) = lhs, case .oneofEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNullValue, .oneofNullValue): return { - guard case .oneofNullValue(let l) = lhs, case .oneofNullValue(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum NestedEnum: SwiftProtobuf.Enum { + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foo // = 0 case bar // = 1 @@ -1082,57 +773,32 @@ struct ProtobufTestMessages_Proto3_TestAllTypesProto3 { } } - } - - enum AliasedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aliasFoo // = 0 - case aliasBar // = 1 - case aliasBaz // = 2 - static let qux = aliasBaz - static let bAz = aliasBaz - case UNRECOGNIZED(Int) - - init() { - self = .aliasFoo - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aliasFoo - case 1: self = .aliasBar - case 2: self = .aliasBaz - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .aliasFoo: return 0 - case .aliasBar: return 1 - case .aliasBaz: return 2 - case .UNRECOGNIZED(let i): return i - } - } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum] = [ + .foo, + .bar, + .baz, + .neg, + ] } - struct NestedMessage { + struct NestedMessage: @unchecked Sendable { // 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 a: Int32 { - get {return _storage._a} + get {_storage._a} set {_uniqueStorage()._a = newValue} } - var corecursive: ProtobufTestMessages_Proto3_TestAllTypesProto3 { - get {return _storage._corecursive ?? ProtobufTestMessages_Proto3_TestAllTypesProto3()} + var corecursive: SwiftProtoTesting_Test3_TestAllTypesProto3 { + get {_storage._corecursive ?? SwiftProtoTesting_Test3_TestAllTypesProto3()} set {_uniqueStorage()._corecursive = newValue} } /// Returns true if `corecursive` has been explicitly set. - var hasCorecursive: Bool {return _storage._corecursive != nil} + var hasCorecursive: Bool {_storage._corecursive != nil} /// Clears the value of `corecursive`. Subsequent reads from it will return its default value. mutating func clearCorecursive() {_uniqueStorage()._corecursive = nil} @@ -1148,281 +814,13 @@ struct ProtobufTestMessages_Proto3_TestAllTypesProto3 { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] = [ - .foo, - .bar, - .baz, - .neg, - ] -} - -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum] = [ - .aliasFoo, - .aliasBar, - .aliasBaz, - ] -} - -#endif // swift(>=4.2) - -struct ProtobufTestMessages_Proto3_ForeignMessage { - // 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 c: Int32 = 0 - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -struct ProtobufTestMessages_Proto3_NullHypothesisProto3 { - // 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 ProtobufTestMessages_Proto3_EnumOnlyProto3 { - // 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() - - enum BoolEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case kFalse // = 0 - case kTrue // = 1 - case UNRECOGNIZED(Int) - - init() { - self = .kFalse - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .kFalse - case 1: self = .kTrue - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .kFalse: return 0 - case .kTrue: return 1 - case .UNRECOGNIZED(let i): return i - } - } - - } - - init() {} -} - -#if swift(>=4.2) - -extension ProtobufTestMessages_Proto3_EnumOnlyProto3.BoolEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufTestMessages_Proto3_EnumOnlyProto3.BoolEnum] = [ - .kFalse, - .kTrue, - ] -} - -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufTestMessages_Proto3_ForeignEnum: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_TestAllTypesProto3: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_ForeignMessage: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_NullHypothesisProto3: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_EnumOnlyProto3: @unchecked Sendable {} -extension ProtobufTestMessages_Proto3_EnumOnlyProto3.BoolEnum: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_test_messages.proto3" +fileprivate let _protobuf_package = "swift_proto_testing.test3" -extension ProtobufTestMessages_Proto3_ForeignEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOREIGN_FOO"), - 1: .same(proto: "FOREIGN_BAR"), - 2: .same(proto: "FOREIGN_BAZ"), - ] -} - -extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Test3_TestAllTypesProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestAllTypesProto3" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "optional_foreign_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "optional_foreign_enum"), - 23: .standard(proto: "optional_aliased_enum"), - 24: .standard(proto: "optional_string_piece"), - 25: .standard(proto: "optional_cord"), - 27: .standard(proto: "recursive_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 48: .standard(proto: "repeated_nested_message"), - 49: .standard(proto: "repeated_foreign_message"), - 51: .standard(proto: "repeated_nested_enum"), - 52: .standard(proto: "repeated_foreign_enum"), - 54: .standard(proto: "repeated_string_piece"), - 55: .standard(proto: "repeated_cord"), - 75: .standard(proto: "packed_int32"), - 76: .standard(proto: "packed_int64"), - 77: .standard(proto: "packed_uint32"), - 78: .standard(proto: "packed_uint64"), - 79: .standard(proto: "packed_sint32"), - 80: .standard(proto: "packed_sint64"), - 81: .standard(proto: "packed_fixed32"), - 82: .standard(proto: "packed_fixed64"), - 83: .standard(proto: "packed_sfixed32"), - 84: .standard(proto: "packed_sfixed64"), - 85: .standard(proto: "packed_float"), - 86: .standard(proto: "packed_double"), - 87: .standard(proto: "packed_bool"), - 88: .standard(proto: "packed_nested_enum"), - 89: .standard(proto: "unpacked_int32"), - 90: .standard(proto: "unpacked_int64"), - 91: .standard(proto: "unpacked_uint32"), - 92: .standard(proto: "unpacked_uint64"), - 93: .standard(proto: "unpacked_sint32"), - 94: .standard(proto: "unpacked_sint64"), - 95: .standard(proto: "unpacked_fixed32"), - 96: .standard(proto: "unpacked_fixed64"), - 97: .standard(proto: "unpacked_sfixed32"), - 98: .standard(proto: "unpacked_sfixed64"), - 99: .standard(proto: "unpacked_float"), - 100: .standard(proto: "unpacked_double"), - 101: .standard(proto: "unpacked_bool"), - 102: .standard(proto: "unpacked_nested_enum"), - 56: .standard(proto: "map_int32_int32"), - 57: .standard(proto: "map_int64_int64"), - 58: .standard(proto: "map_uint32_uint32"), - 59: .standard(proto: "map_uint64_uint64"), - 60: .standard(proto: "map_sint32_sint32"), - 61: .standard(proto: "map_sint64_sint64"), - 62: .standard(proto: "map_fixed32_fixed32"), - 63: .standard(proto: "map_fixed64_fixed64"), - 64: .standard(proto: "map_sfixed32_sfixed32"), - 65: .standard(proto: "map_sfixed64_sfixed64"), - 66: .standard(proto: "map_int32_float"), - 67: .standard(proto: "map_int32_double"), - 68: .standard(proto: "map_bool_bool"), - 69: .standard(proto: "map_string_string"), - 70: .standard(proto: "map_string_bytes"), - 71: .standard(proto: "map_string_nested_message"), - 72: .standard(proto: "map_string_foreign_message"), - 73: .standard(proto: "map_string_nested_enum"), - 74: .standard(proto: "map_string_foreign_enum"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - 115: .standard(proto: "oneof_bool"), - 116: .standard(proto: "oneof_uint64"), - 117: .standard(proto: "oneof_float"), - 118: .standard(proto: "oneof_double"), - 119: .standard(proto: "oneof_enum"), - 120: .standard(proto: "oneof_null_value"), - 201: .standard(proto: "optional_bool_wrapper"), - 202: .standard(proto: "optional_int32_wrapper"), - 203: .standard(proto: "optional_int64_wrapper"), - 204: .standard(proto: "optional_uint32_wrapper"), - 205: .standard(proto: "optional_uint64_wrapper"), - 206: .standard(proto: "optional_float_wrapper"), - 207: .standard(proto: "optional_double_wrapper"), - 208: .standard(proto: "optional_string_wrapper"), - 209: .standard(proto: "optional_bytes_wrapper"), - 211: .standard(proto: "repeated_bool_wrapper"), - 212: .standard(proto: "repeated_int32_wrapper"), - 213: .standard(proto: "repeated_int64_wrapper"), - 214: .standard(proto: "repeated_uint32_wrapper"), - 215: .standard(proto: "repeated_uint64_wrapper"), - 216: .standard(proto: "repeated_float_wrapper"), - 217: .standard(proto: "repeated_double_wrapper"), - 218: .standard(proto: "repeated_string_wrapper"), - 219: .standard(proto: "repeated_bytes_wrapper"), - 301: .standard(proto: "optional_duration"), - 302: .standard(proto: "optional_timestamp"), - 303: .standard(proto: "optional_field_mask"), - 304: .standard(proto: "optional_struct"), - 305: .standard(proto: "optional_any"), - 306: .standard(proto: "optional_value"), - 307: .standard(proto: "optional_null_value"), - 311: .standard(proto: "repeated_duration"), - 312: .standard(proto: "repeated_timestamp"), - 313: .standard(proto: "repeated_fieldmask"), - 324: .standard(proto: "repeated_struct"), - 315: .standard(proto: "repeated_any"), - 316: .standard(proto: "repeated_value"), - 317: .standard(proto: "repeated_list_value"), - 401: .same(proto: "fieldname1"), - 402: .standard(proto: "field_name2"), - 403: .standard(proto: "_field_name3"), - 404: .standard(proto: "field__name4_"), - 405: .same(proto: "field0name5"), - 406: .standard(proto: "field_0_name6"), - 407: .same(proto: "fieldName7"), - 408: .same(proto: "FieldName8"), - 409: .standard(proto: "field_Name9"), - 410: .standard(proto: "Field_Name10"), - 411: .standard(proto: "FIELD_NAME11"), - 412: .standard(proto: "FIELD_name12"), - 413: .standard(proto: "__field_name13"), - 414: .standard(proto: "__Field_name14"), - 415: .standard(proto: "field__name15"), - 416: .standard(proto: "field__Name16"), - 417: .standard(proto: "field_name17__"), - 418: .standard(proto: "Field_name18__"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{4}\u{3}optional_nested_enum\0\u{4}\u{a}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{4}\u{3}repeated_nested_enum\0\u{4}\u{5}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_nested_message\0\u{4}\u{2}map_string_nested_enum\0\u{4}&oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{3}oneof_bool\0\u{3}oneof_uint64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_enum\0\u{3}oneof_null_value\0\u{4}Q\u{1}optional_bool_wrapper\0\u{3}optional_int32_wrapper\0\u{3}optional_int64_wrapper\0\u{3}optional_uint32_wrapper\0\u{3}optional_uint64_wrapper\0\u{3}optional_float_wrapper\0\u{3}optional_double_wrapper\0\u{3}optional_string_wrapper\0\u{3}optional_bytes_wrapper\0\u{4}\u{2}repeated_bool_wrapper\0\u{3}repeated_int32_wrapper\0\u{3}repeated_int64_wrapper\0\u{3}repeated_uint32_wrapper\0\u{3}repeated_uint64_wrapper\0\u{3}repeated_float_wrapper\0\u{3}repeated_double_wrapper\0\u{3}repeated_string_wrapper\0\u{3}repeated_bytes_wrapper\0\u{4}R\u{1}optional_duration\0\u{3}optional_timestamp\0\u{3}optional_field_mask\0\u{3}optional_struct\0\u{3}optional_any\0\u{3}optional_value\0\u{3}optional_null_value\0\u{4}\u{4}repeated_duration\0\u{3}repeated_timestamp\0\u{3}repeated_fieldmask\0\u{4}\u{2}repeated_any\0\u{3}repeated_value\0\u{3}repeated_list_value\0\u{4}\u{7}repeated_struct\0\u{2}M\u{1}fieldname1\0\u{3}field_name2\0\u{3}_field_name3\0\u{3}field__name4_\0\u{1}field0name5\0\u{3}field_0_name6\0\u{1}fieldName7\0\u{1}FieldName8\0\u{3}field_Name9\0\u{3}Field_Name10\0\u{3}FIELD_NAME11\0\u{3}FIELD_name12\0\u{3}__field_name13\0\u{3}__Field_name14\0\u{3}field__name15\0\u{3}field__Name16\0\u{3}field_name17__\0\u{3}Field_name18__\0\u{c}u\u{7}\u{a}") fileprivate class _StorageClass { var _optionalInt32: Int32 = 0 @@ -1440,14 +838,8 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, var _optionalBool: Bool = false var _optionalString: String = String() var _optionalBytes: Data = Data() - var _optionalNestedMessage: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage? = nil - var _optionalForeignMessage: ProtobufTestMessages_Proto3_ForeignMessage? = nil - var _optionalNestedEnum: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum = .foo - var _optionalForeignEnum: ProtobufTestMessages_Proto3_ForeignEnum = .foreignFoo - var _optionalAliasedEnum: ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum = .aliasFoo - var _optionalStringPiece: String = String() - var _optionalCord: String = String() - var _recursiveMessage: ProtobufTestMessages_Proto3_TestAllTypesProto3? = nil + var _optionalNestedMessage: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage? = nil + var _optionalNestedEnum: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum = .foo var _repeatedInt32: [Int32] = [] var _repeatedInt64: [Int64] = [] var _repeatedUint32: [UInt32] = [] @@ -1463,40 +855,8 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, var _repeatedBool: [Bool] = [] var _repeatedString: [String] = [] var _repeatedBytes: [Data] = [] - var _repeatedNestedMessage: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage] = [] - var _repeatedForeignMessage: [ProtobufTestMessages_Proto3_ForeignMessage] = [] - var _repeatedNestedEnum: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] = [] - var _repeatedForeignEnum: [ProtobufTestMessages_Proto3_ForeignEnum] = [] - var _repeatedStringPiece: [String] = [] - var _repeatedCord: [String] = [] - var _packedInt32: [Int32] = [] - var _packedInt64: [Int64] = [] - var _packedUint32: [UInt32] = [] - var _packedUint64: [UInt64] = [] - var _packedSint32: [Int32] = [] - var _packedSint64: [Int64] = [] - var _packedFixed32: [UInt32] = [] - var _packedFixed64: [UInt64] = [] - var _packedSfixed32: [Int32] = [] - var _packedSfixed64: [Int64] = [] - var _packedFloat: [Float] = [] - var _packedDouble: [Double] = [] - var _packedBool: [Bool] = [] - var _packedNestedEnum: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] = [] - var _unpackedInt32: [Int32] = [] - var _unpackedInt64: [Int64] = [] - var _unpackedUint32: [UInt32] = [] - var _unpackedUint64: [UInt64] = [] - var _unpackedSint32: [Int32] = [] - var _unpackedSint64: [Int64] = [] - var _unpackedFixed32: [UInt32] = [] - var _unpackedFixed64: [UInt64] = [] - var _unpackedSfixed32: [Int32] = [] - var _unpackedSfixed64: [Int64] = [] - var _unpackedFloat: [Float] = [] - var _unpackedDouble: [Double] = [] - var _unpackedBool: [Bool] = [] - var _unpackedNestedEnum: [ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum] = [] + var _repeatedNestedMessage: [SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage] = [] + var _repeatedNestedEnum: [SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum] = [] var _mapInt32Int32: Dictionary = [:] var _mapInt64Int64: Dictionary = [:] var _mapUint32Uint32: Dictionary = [:] @@ -1512,11 +872,9 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, var _mapBoolBool: Dictionary = [:] var _mapStringString: Dictionary = [:] var _mapStringBytes: Dictionary = [:] - var _mapStringNestedMessage: Dictionary = [:] - var _mapStringForeignMessage: Dictionary = [:] - var _mapStringNestedEnum: Dictionary = [:] - var _mapStringForeignEnum: Dictionary = [:] - var _oneofField: ProtobufTestMessages_Proto3_TestAllTypesProto3.OneOf_OneofField? + var _mapStringNestedMessage: Dictionary = [:] + var _mapStringNestedEnum: Dictionary = [:] + var _oneofField: SwiftProtoTesting_Test3_TestAllTypesProto3.OneOf_OneofField? var _optionalBoolWrapper: SwiftProtobuf.Google_Protobuf_BoolValue? = nil var _optionalInt32Wrapper: SwiftProtobuf.Google_Protobuf_Int32Value? = nil var _optionalInt64Wrapper: SwiftProtobuf.Google_Protobuf_Int64Value? = nil @@ -1568,7 +926,11 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, var _fieldName17__: Int32 = 0 var _fieldName18__: Int32 = 0 - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1589,13 +951,7 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, _optionalString = source._optionalString _optionalBytes = source._optionalBytes _optionalNestedMessage = source._optionalNestedMessage - _optionalForeignMessage = source._optionalForeignMessage _optionalNestedEnum = source._optionalNestedEnum - _optionalForeignEnum = source._optionalForeignEnum - _optionalAliasedEnum = source._optionalAliasedEnum - _optionalStringPiece = source._optionalStringPiece - _optionalCord = source._optionalCord - _recursiveMessage = source._recursiveMessage _repeatedInt32 = source._repeatedInt32 _repeatedInt64 = source._repeatedInt64 _repeatedUint32 = source._repeatedUint32 @@ -1612,39 +968,7 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, _repeatedString = source._repeatedString _repeatedBytes = source._repeatedBytes _repeatedNestedMessage = source._repeatedNestedMessage - _repeatedForeignMessage = source._repeatedForeignMessage _repeatedNestedEnum = source._repeatedNestedEnum - _repeatedForeignEnum = source._repeatedForeignEnum - _repeatedStringPiece = source._repeatedStringPiece - _repeatedCord = source._repeatedCord - _packedInt32 = source._packedInt32 - _packedInt64 = source._packedInt64 - _packedUint32 = source._packedUint32 - _packedUint64 = source._packedUint64 - _packedSint32 = source._packedSint32 - _packedSint64 = source._packedSint64 - _packedFixed32 = source._packedFixed32 - _packedFixed64 = source._packedFixed64 - _packedSfixed32 = source._packedSfixed32 - _packedSfixed64 = source._packedSfixed64 - _packedFloat = source._packedFloat - _packedDouble = source._packedDouble - _packedBool = source._packedBool - _packedNestedEnum = source._packedNestedEnum - _unpackedInt32 = source._unpackedInt32 - _unpackedInt64 = source._unpackedInt64 - _unpackedUint32 = source._unpackedUint32 - _unpackedUint64 = source._unpackedUint64 - _unpackedSint32 = source._unpackedSint32 - _unpackedSint64 = source._unpackedSint64 - _unpackedFixed32 = source._unpackedFixed32 - _unpackedFixed64 = source._unpackedFixed64 - _unpackedSfixed32 = source._unpackedSfixed32 - _unpackedSfixed64 = source._unpackedSfixed64 - _unpackedFloat = source._unpackedFloat - _unpackedDouble = source._unpackedDouble - _unpackedBool = source._unpackedBool - _unpackedNestedEnum = source._unpackedNestedEnum _mapInt32Int32 = source._mapInt32Int32 _mapInt64Int64 = source._mapInt64Int64 _mapUint32Uint32 = source._mapUint32Uint32 @@ -1661,9 +985,7 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, _mapStringString = source._mapStringString _mapStringBytes = source._mapStringBytes _mapStringNestedMessage = source._mapStringNestedMessage - _mapStringForeignMessage = source._mapStringForeignMessage _mapStringNestedEnum = source._mapStringNestedEnum - _mapStringForeignEnum = source._mapStringForeignEnum _oneofField = source._oneofField _optionalBoolWrapper = source._optionalBoolWrapper _optionalInt32Wrapper = source._optionalInt32Wrapper @@ -1749,13 +1071,7 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() - case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() - case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() - case 23: try { try decoder.decodeSingularEnumField(value: &_storage._optionalAliasedEnum) }() - case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() - case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() - case 27: try { try decoder.decodeSingularMessageField(value: &_storage._recursiveMessage) }() case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() @@ -1772,11 +1088,7 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() - case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() - case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() - case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() - case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() case 56: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Int32) }() case 57: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt64Int64) }() case 58: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapUint32Uint32) }() @@ -1792,38 +1104,8 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, case 68: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() case 69: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() case 70: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() - case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringNestedMessage) }() - case 72: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringForeignMessage) }() - case 73: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringNestedEnum) }() - case 74: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringForeignEnum) }() - case 75: try { try decoder.decodeRepeatedInt32Field(value: &_storage._packedInt32) }() - case 76: try { try decoder.decodeRepeatedInt64Field(value: &_storage._packedInt64) }() - case 77: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._packedUint32) }() - case 78: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._packedUint64) }() - case 79: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._packedSint32) }() - case 80: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._packedSint64) }() - case 81: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._packedFixed32) }() - case 82: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._packedFixed64) }() - case 83: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._packedSfixed32) }() - case 84: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._packedSfixed64) }() - case 85: try { try decoder.decodeRepeatedFloatField(value: &_storage._packedFloat) }() - case 86: try { try decoder.decodeRepeatedDoubleField(value: &_storage._packedDouble) }() - case 87: try { try decoder.decodeRepeatedBoolField(value: &_storage._packedBool) }() - case 88: try { try decoder.decodeRepeatedEnumField(value: &_storage._packedNestedEnum) }() - case 89: try { try decoder.decodeRepeatedInt32Field(value: &_storage._unpackedInt32) }() - case 90: try { try decoder.decodeRepeatedInt64Field(value: &_storage._unpackedInt64) }() - case 91: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._unpackedUint32) }() - case 92: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._unpackedUint64) }() - case 93: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._unpackedSint32) }() - case 94: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._unpackedSint64) }() - case 95: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._unpackedFixed32) }() - case 96: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._unpackedFixed64) }() - case 97: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._unpackedSfixed32) }() - case 98: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._unpackedSfixed64) }() - case 99: try { try decoder.decodeRepeatedFloatField(value: &_storage._unpackedFloat) }() - case 100: try { try decoder.decodeRepeatedDoubleField(value: &_storage._unpackedDouble) }() - case 101: try { try decoder.decodeRepeatedBoolField(value: &_storage._unpackedBool) }() - case 102: try { try decoder.decodeRepeatedEnumField(value: &_storage._unpackedNestedEnum) }() + case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringNestedMessage) }() + case 73: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapStringNestedEnum) }() case 111: try { var v: UInt32? try decoder.decodeSingularUInt32Field(value: &v) @@ -1833,7 +1115,7 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, } }() case 112: try { - var v: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage? + var v: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage? var hadOneofValue = false if let current = _storage._oneofField { hadOneofValue = true @@ -1894,7 +1176,7 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, } }() case 119: try { - var v: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum? + var v: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum? try decoder.decodeSingularEnumField(value: &v) if let v = v { if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} @@ -2001,10 +1283,10 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, if _storage._optionalSfixed64 != 0 { try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) } - if _storage._optionalFloat != 0 { + if _storage._optionalFloat.bitPattern != 0 { try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) } - if _storage._optionalDouble != 0 { + if _storage._optionalDouble.bitPattern != 0 { try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) } if _storage._optionalBool != false { @@ -2019,27 +1301,9 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, try { if let v = _storage._optionalNestedMessage { try visitor.visitSingularMessageField(value: v, fieldNumber: 18) } }() - try { if let v = _storage._optionalForeignMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 19) - } }() if _storage._optionalNestedEnum != .foo { try visitor.visitSingularEnumField(value: _storage._optionalNestedEnum, fieldNumber: 21) } - if _storage._optionalForeignEnum != .foreignFoo { - try visitor.visitSingularEnumField(value: _storage._optionalForeignEnum, fieldNumber: 22) - } - if _storage._optionalAliasedEnum != .aliasFoo { - try visitor.visitSingularEnumField(value: _storage._optionalAliasedEnum, fieldNumber: 23) - } - if !_storage._optionalStringPiece.isEmpty { - try visitor.visitSingularStringField(value: _storage._optionalStringPiece, fieldNumber: 24) - } - if !_storage._optionalCord.isEmpty { - try visitor.visitSingularStringField(value: _storage._optionalCord, fieldNumber: 25) - } - try { if let v = _storage._recursiveMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 27) - } }() if !_storage._repeatedInt32.isEmpty { try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) } @@ -2088,21 +1352,9 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, if !_storage._repeatedNestedMessage.isEmpty { try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) } - if !_storage._repeatedForeignMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) - } if !_storage._repeatedNestedEnum.isEmpty { try visitor.visitPackedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) } - if !_storage._repeatedForeignEnum.isEmpty { - try visitor.visitPackedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) - } - if !_storage._repeatedStringPiece.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) - } - if !_storage._repeatedCord.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) - } if !_storage._mapInt32Int32.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Int32, fieldNumber: 56) } @@ -2149,100 +1401,10 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 70) } if !_storage._mapStringNestedMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringNestedMessage, fieldNumber: 71) - } - if !_storage._mapStringForeignMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringForeignMessage, fieldNumber: 72) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringNestedMessage, fieldNumber: 71) } if !_storage._mapStringNestedEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringNestedEnum, fieldNumber: 73) - } - if !_storage._mapStringForeignEnum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringForeignEnum, fieldNumber: 74) - } - if !_storage._packedInt32.isEmpty { - try visitor.visitPackedInt32Field(value: _storage._packedInt32, fieldNumber: 75) - } - if !_storage._packedInt64.isEmpty { - try visitor.visitPackedInt64Field(value: _storage._packedInt64, fieldNumber: 76) - } - if !_storage._packedUint32.isEmpty { - try visitor.visitPackedUInt32Field(value: _storage._packedUint32, fieldNumber: 77) - } - if !_storage._packedUint64.isEmpty { - try visitor.visitPackedUInt64Field(value: _storage._packedUint64, fieldNumber: 78) - } - if !_storage._packedSint32.isEmpty { - try visitor.visitPackedSInt32Field(value: _storage._packedSint32, fieldNumber: 79) - } - if !_storage._packedSint64.isEmpty { - try visitor.visitPackedSInt64Field(value: _storage._packedSint64, fieldNumber: 80) - } - if !_storage._packedFixed32.isEmpty { - try visitor.visitPackedFixed32Field(value: _storage._packedFixed32, fieldNumber: 81) - } - if !_storage._packedFixed64.isEmpty { - try visitor.visitPackedFixed64Field(value: _storage._packedFixed64, fieldNumber: 82) - } - if !_storage._packedSfixed32.isEmpty { - try visitor.visitPackedSFixed32Field(value: _storage._packedSfixed32, fieldNumber: 83) - } - if !_storage._packedSfixed64.isEmpty { - try visitor.visitPackedSFixed64Field(value: _storage._packedSfixed64, fieldNumber: 84) - } - if !_storage._packedFloat.isEmpty { - try visitor.visitPackedFloatField(value: _storage._packedFloat, fieldNumber: 85) - } - if !_storage._packedDouble.isEmpty { - try visitor.visitPackedDoubleField(value: _storage._packedDouble, fieldNumber: 86) - } - if !_storage._packedBool.isEmpty { - try visitor.visitPackedBoolField(value: _storage._packedBool, fieldNumber: 87) - } - if !_storage._packedNestedEnum.isEmpty { - try visitor.visitPackedEnumField(value: _storage._packedNestedEnum, fieldNumber: 88) - } - if !_storage._unpackedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: _storage._unpackedInt32, fieldNumber: 89) - } - if !_storage._unpackedInt64.isEmpty { - try visitor.visitRepeatedInt64Field(value: _storage._unpackedInt64, fieldNumber: 90) - } - if !_storage._unpackedUint32.isEmpty { - try visitor.visitRepeatedUInt32Field(value: _storage._unpackedUint32, fieldNumber: 91) - } - if !_storage._unpackedUint64.isEmpty { - try visitor.visitRepeatedUInt64Field(value: _storage._unpackedUint64, fieldNumber: 92) - } - if !_storage._unpackedSint32.isEmpty { - try visitor.visitRepeatedSInt32Field(value: _storage._unpackedSint32, fieldNumber: 93) - } - if !_storage._unpackedSint64.isEmpty { - try visitor.visitRepeatedSInt64Field(value: _storage._unpackedSint64, fieldNumber: 94) - } - if !_storage._unpackedFixed32.isEmpty { - try visitor.visitRepeatedFixed32Field(value: _storage._unpackedFixed32, fieldNumber: 95) - } - if !_storage._unpackedFixed64.isEmpty { - try visitor.visitRepeatedFixed64Field(value: _storage._unpackedFixed64, fieldNumber: 96) - } - if !_storage._unpackedSfixed32.isEmpty { - try visitor.visitRepeatedSFixed32Field(value: _storage._unpackedSfixed32, fieldNumber: 97) - } - if !_storage._unpackedSfixed64.isEmpty { - try visitor.visitRepeatedSFixed64Field(value: _storage._unpackedSfixed64, fieldNumber: 98) - } - if !_storage._unpackedFloat.isEmpty { - try visitor.visitRepeatedFloatField(value: _storage._unpackedFloat, fieldNumber: 99) - } - if !_storage._unpackedDouble.isEmpty { - try visitor.visitRepeatedDoubleField(value: _storage._unpackedDouble, fieldNumber: 100) - } - if !_storage._unpackedBool.isEmpty { - try visitor.visitRepeatedBoolField(value: _storage._unpackedBool, fieldNumber: 101) - } - if !_storage._unpackedNestedEnum.isEmpty { - try visitor.visitRepeatedEnumField(value: _storage._unpackedNestedEnum, fieldNumber: 102) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapStringNestedEnum, fieldNumber: 73) } switch _storage._oneofField { case .oneofUint32?: try { @@ -2441,7 +1603,7 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufTestMessages_Proto3_TestAllTypesProto3, rhs: ProtobufTestMessages_Proto3_TestAllTypesProto3) -> Bool { + static func ==(lhs: SwiftProtoTesting_Test3_TestAllTypesProto3, rhs: SwiftProtoTesting_Test3_TestAllTypesProto3) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -2462,13 +1624,7 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, if _storage._optionalString != rhs_storage._optionalString {return false} if _storage._optionalBytes != rhs_storage._optionalBytes {return false} if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} - if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} - if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} - if _storage._optionalAliasedEnum != rhs_storage._optionalAliasedEnum {return false} - if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} - if _storage._optionalCord != rhs_storage._optionalCord {return false} - if _storage._recursiveMessage != rhs_storage._recursiveMessage {return false} if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} @@ -2485,39 +1641,7 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, if _storage._repeatedString != rhs_storage._repeatedString {return false} if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} - if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} - if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} - if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} - if _storage._repeatedCord != rhs_storage._repeatedCord {return false} - if _storage._packedInt32 != rhs_storage._packedInt32 {return false} - if _storage._packedInt64 != rhs_storage._packedInt64 {return false} - if _storage._packedUint32 != rhs_storage._packedUint32 {return false} - if _storage._packedUint64 != rhs_storage._packedUint64 {return false} - if _storage._packedSint32 != rhs_storage._packedSint32 {return false} - if _storage._packedSint64 != rhs_storage._packedSint64 {return false} - if _storage._packedFixed32 != rhs_storage._packedFixed32 {return false} - if _storage._packedFixed64 != rhs_storage._packedFixed64 {return false} - if _storage._packedSfixed32 != rhs_storage._packedSfixed32 {return false} - if _storage._packedSfixed64 != rhs_storage._packedSfixed64 {return false} - if _storage._packedFloat != rhs_storage._packedFloat {return false} - if _storage._packedDouble != rhs_storage._packedDouble {return false} - if _storage._packedBool != rhs_storage._packedBool {return false} - if _storage._packedNestedEnum != rhs_storage._packedNestedEnum {return false} - if _storage._unpackedInt32 != rhs_storage._unpackedInt32 {return false} - if _storage._unpackedInt64 != rhs_storage._unpackedInt64 {return false} - if _storage._unpackedUint32 != rhs_storage._unpackedUint32 {return false} - if _storage._unpackedUint64 != rhs_storage._unpackedUint64 {return false} - if _storage._unpackedSint32 != rhs_storage._unpackedSint32 {return false} - if _storage._unpackedSint64 != rhs_storage._unpackedSint64 {return false} - if _storage._unpackedFixed32 != rhs_storage._unpackedFixed32 {return false} - if _storage._unpackedFixed64 != rhs_storage._unpackedFixed64 {return false} - if _storage._unpackedSfixed32 != rhs_storage._unpackedSfixed32 {return false} - if _storage._unpackedSfixed64 != rhs_storage._unpackedSfixed64 {return false} - if _storage._unpackedFloat != rhs_storage._unpackedFloat {return false} - if _storage._unpackedDouble != rhs_storage._unpackedDouble {return false} - if _storage._unpackedBool != rhs_storage._unpackedBool {return false} - if _storage._unpackedNestedEnum != rhs_storage._unpackedNestedEnum {return false} if _storage._mapInt32Int32 != rhs_storage._mapInt32Int32 {return false} if _storage._mapInt64Int64 != rhs_storage._mapInt64Int64 {return false} if _storage._mapUint32Uint32 != rhs_storage._mapUint32Uint32 {return false} @@ -2534,9 +1658,7 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, if _storage._mapStringString != rhs_storage._mapStringString {return false} if _storage._mapStringBytes != rhs_storage._mapStringBytes {return false} if _storage._mapStringNestedMessage != rhs_storage._mapStringNestedMessage {return false} - if _storage._mapStringForeignMessage != rhs_storage._mapStringForeignMessage {return false} if _storage._mapStringNestedEnum != rhs_storage._mapStringNestedEnum {return false} - if _storage._mapStringForeignEnum != rhs_storage._mapStringForeignEnum {return false} if _storage._oneofField != rhs_storage._oneofField {return false} if _storage._optionalBoolWrapper != rhs_storage._optionalBoolWrapper {return false} if _storage._optionalInt32Wrapper != rhs_storage._optionalInt32Wrapper {return false} @@ -2597,35 +1719,23 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3: SwiftProtobuf.Message, } } -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -1: .same(proto: "NEG"), - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - ] +extension SwiftProtoTesting_Test3_TestAllTypesProto3.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") } -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.AliasedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ALIAS_FOO"), - 1: .same(proto: "ALIAS_BAR"), - 2: .aliased(proto: "ALIAS_BAZ", aliases: ["QUX", "qux", "bAz"]), - ] -} - -extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufTestMessages_Proto3_TestAllTypesProto3.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 2: .same(proto: "corecursive"), - ] +extension SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Test3_TestAllTypesProto3.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}corecursive\0") fileprivate class _StorageClass { var _a: Int32 = 0 - var _corecursive: ProtobufTestMessages_Proto3_TestAllTypesProto3? = nil + var _corecursive: SwiftProtoTesting_Test3_TestAllTypesProto3? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -2674,7 +1784,7 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage: SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage, rhs: ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage, rhs: SwiftProtoTesting_Test3_TestAllTypesProto3.NestedMessage) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -2689,80 +1799,3 @@ extension ProtobufTestMessages_Proto3_TestAllTypesProto3.NestedMessage: SwiftPro return true } } - -extension ProtobufTestMessages_Proto3_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ForeignMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - ] - - 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.c) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if self.c != 0 { - try visitor.visitSingularInt32Field(value: self.c, fieldNumber: 1) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufTestMessages_Proto3_ForeignMessage, rhs: ProtobufTestMessages_Proto3_ForeignMessage) -> Bool { - if lhs.c != rhs.c {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufTestMessages_Proto3_NullHypothesisProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".NullHypothesisProto3" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufTestMessages_Proto3_NullHypothesisProto3, rhs: ProtobufTestMessages_Proto3_NullHypothesisProto3) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufTestMessages_Proto3_EnumOnlyProto3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".EnumOnlyProto3" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufTestMessages_Proto3_EnumOnlyProto3, rhs: ProtobufTestMessages_Proto3_EnumOnlyProto3) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufTestMessages_Proto3_EnumOnlyProto3.BoolEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "kFalse"), - 1: .same(proto: "kTrue"), - ] -} diff --git a/Tests/SwiftProtobufTests/unittest.pb.swift b/Tests/SwiftProtobufTests/unittest.pb.swift index f86c07c75..025b39a54 100644 --- a/Tests/SwiftProtobufTests/unittest.pb.swift +++ b/Tests/SwiftProtobufTests/unittest.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest.proto +// Source: unittest.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -58,49 +59,22 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum ProtobufUnittest_ForeignEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foreignFoo // = 4 - case foreignBar // = 5 - case foreignBaz // = 6 +enum SwiftProtoTesting_ForeignEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foreignFoo = 4 + case foreignBar = 5 + case foreignBaz = 6 init() { self = .foreignFoo } - init?(rawValue: Int) { - switch rawValue { - case 4: self = .foreignFoo - case 5: self = .foreignBar - case 6: self = .foreignBaz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foreignFoo: return 4 - case .foreignBar: return 5 - case .foreignBaz: return 6 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_ForeignEnum: CaseIterable { - // Support synthesized by the compiler. } -#endif // swift(>=4.2) - /// Test an enum that has multiple values with the same number. -enum ProtobufUnittest_TestEnumWithDupValue: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo1 // = 1 - case bar1 // = 2 - case baz // = 3 +enum SwiftProtoTesting_TestEnumWithDupValue: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo1 = 1 + case bar1 = 2 + case baz = 3 static let foo2 = foo1 static let bar2 = bar1 @@ -108,964 +82,498 @@ enum ProtobufUnittest_TestEnumWithDupValue: SwiftProtobuf.Enum { self = .foo1 } - init?(rawValue: Int) { - switch rawValue { - case 1: self = .foo1 - case 2: self = .bar1 - case 3: self = .baz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo1: return 1 - case .bar1: return 2 - case .baz: return 3 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_TestEnumWithDupValue: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// Test an enum with large, unordered values. -enum ProtobufUnittest_TestSparseEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case sparseA // = 123 - case sparseB // = 62374 - case sparseC // = 12589234 - case sparseD // = -15 - case sparseE // = -53452 - case sparseF // = 0 - case sparseG // = 2 - - init() { - self = .sparseA - } - - init?(rawValue: Int) { - switch rawValue { - case -53452: self = .sparseE - case -15: self = .sparseD - case 0: self = .sparseF - case 2: self = .sparseG - case 123: self = .sparseA - case 62374: self = .sparseB - case 12589234: self = .sparseC - default: return nil - } - } - - var rawValue: Int { - switch self { - case .sparseE: return -53452 - case .sparseD: return -15 - case .sparseF: return 0 - case .sparseG: return 2 - case .sparseA: return 123 - case .sparseB: return 62374 - case .sparseC: return 12589234 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_TestSparseEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -enum ProtobufUnittest_VeryLargeEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case enumLabelDefault // = 0 - case enumLabel1 // = 1 - case enumLabel2 // = 2 - case enumLabel3 // = 3 - case enumLabel4 // = 4 - case enumLabel5 // = 5 - case enumLabel6 // = 6 - case enumLabel7 // = 7 - case enumLabel8 // = 8 - case enumLabel9 // = 9 - case enumLabel10 // = 10 - case enumLabel11 // = 11 - case enumLabel12 // = 12 - case enumLabel13 // = 13 - case enumLabel14 // = 14 - case enumLabel15 // = 15 - case enumLabel16 // = 16 - case enumLabel17 // = 17 - case enumLabel18 // = 18 - case enumLabel19 // = 19 - case enumLabel20 // = 20 - case enumLabel21 // = 21 - case enumLabel22 // = 22 - case enumLabel23 // = 23 - case enumLabel24 // = 24 - case enumLabel25 // = 25 - case enumLabel26 // = 26 - case enumLabel27 // = 27 - case enumLabel28 // = 28 - case enumLabel29 // = 29 - case enumLabel30 // = 30 - case enumLabel31 // = 31 - case enumLabel32 // = 32 - case enumLabel33 // = 33 - case enumLabel34 // = 34 - case enumLabel35 // = 35 - case enumLabel36 // = 36 - case enumLabel37 // = 37 - case enumLabel38 // = 38 - case enumLabel39 // = 39 - case enumLabel40 // = 40 - case enumLabel41 // = 41 - case enumLabel42 // = 42 - case enumLabel43 // = 43 - case enumLabel44 // = 44 - case enumLabel45 // = 45 - case enumLabel46 // = 46 - case enumLabel47 // = 47 - case enumLabel48 // = 48 - case enumLabel49 // = 49 - case enumLabel50 // = 50 - case enumLabel51 // = 51 - case enumLabel52 // = 52 - case enumLabel53 // = 53 - case enumLabel54 // = 54 - case enumLabel55 // = 55 - case enumLabel56 // = 56 - case enumLabel57 // = 57 - case enumLabel58 // = 58 - case enumLabel59 // = 59 - case enumLabel60 // = 60 - case enumLabel61 // = 61 - case enumLabel62 // = 62 - case enumLabel63 // = 63 - case enumLabel64 // = 64 - case enumLabel65 // = 65 - case enumLabel66 // = 66 - case enumLabel67 // = 67 - case enumLabel68 // = 68 - case enumLabel69 // = 69 - case enumLabel70 // = 70 - case enumLabel71 // = 71 - case enumLabel72 // = 72 - case enumLabel73 // = 73 - case enumLabel74 // = 74 - case enumLabel75 // = 75 - case enumLabel76 // = 76 - case enumLabel77 // = 77 - case enumLabel78 // = 78 - case enumLabel79 // = 79 - case enumLabel80 // = 80 - case enumLabel81 // = 81 - case enumLabel82 // = 82 - case enumLabel83 // = 83 - case enumLabel84 // = 84 - case enumLabel85 // = 85 - case enumLabel86 // = 86 - case enumLabel87 // = 87 - case enumLabel88 // = 88 - case enumLabel89 // = 89 - case enumLabel90 // = 90 - case enumLabel91 // = 91 - case enumLabel92 // = 92 - case enumLabel93 // = 93 - case enumLabel94 // = 94 - case enumLabel95 // = 95 - case enumLabel96 // = 96 - case enumLabel97 // = 97 - case enumLabel98 // = 98 - case enumLabel99 // = 99 - case enumLabel100 // = 100 - - init() { - self = .enumLabelDefault - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .enumLabelDefault - case 1: self = .enumLabel1 - case 2: self = .enumLabel2 - case 3: self = .enumLabel3 - case 4: self = .enumLabel4 - case 5: self = .enumLabel5 - case 6: self = .enumLabel6 - case 7: self = .enumLabel7 - case 8: self = .enumLabel8 - case 9: self = .enumLabel9 - case 10: self = .enumLabel10 - case 11: self = .enumLabel11 - case 12: self = .enumLabel12 - case 13: self = .enumLabel13 - case 14: self = .enumLabel14 - case 15: self = .enumLabel15 - case 16: self = .enumLabel16 - case 17: self = .enumLabel17 - case 18: self = .enumLabel18 - case 19: self = .enumLabel19 - case 20: self = .enumLabel20 - case 21: self = .enumLabel21 - case 22: self = .enumLabel22 - case 23: self = .enumLabel23 - case 24: self = .enumLabel24 - case 25: self = .enumLabel25 - case 26: self = .enumLabel26 - case 27: self = .enumLabel27 - case 28: self = .enumLabel28 - case 29: self = .enumLabel29 - case 30: self = .enumLabel30 - case 31: self = .enumLabel31 - case 32: self = .enumLabel32 - case 33: self = .enumLabel33 - case 34: self = .enumLabel34 - case 35: self = .enumLabel35 - case 36: self = .enumLabel36 - case 37: self = .enumLabel37 - case 38: self = .enumLabel38 - case 39: self = .enumLabel39 - case 40: self = .enumLabel40 - case 41: self = .enumLabel41 - case 42: self = .enumLabel42 - case 43: self = .enumLabel43 - case 44: self = .enumLabel44 - case 45: self = .enumLabel45 - case 46: self = .enumLabel46 - case 47: self = .enumLabel47 - case 48: self = .enumLabel48 - case 49: self = .enumLabel49 - case 50: self = .enumLabel50 - case 51: self = .enumLabel51 - case 52: self = .enumLabel52 - case 53: self = .enumLabel53 - case 54: self = .enumLabel54 - case 55: self = .enumLabel55 - case 56: self = .enumLabel56 - case 57: self = .enumLabel57 - case 58: self = .enumLabel58 - case 59: self = .enumLabel59 - case 60: self = .enumLabel60 - case 61: self = .enumLabel61 - case 62: self = .enumLabel62 - case 63: self = .enumLabel63 - case 64: self = .enumLabel64 - case 65: self = .enumLabel65 - case 66: self = .enumLabel66 - case 67: self = .enumLabel67 - case 68: self = .enumLabel68 - case 69: self = .enumLabel69 - case 70: self = .enumLabel70 - case 71: self = .enumLabel71 - case 72: self = .enumLabel72 - case 73: self = .enumLabel73 - case 74: self = .enumLabel74 - case 75: self = .enumLabel75 - case 76: self = .enumLabel76 - case 77: self = .enumLabel77 - case 78: self = .enumLabel78 - case 79: self = .enumLabel79 - case 80: self = .enumLabel80 - case 81: self = .enumLabel81 - case 82: self = .enumLabel82 - case 83: self = .enumLabel83 - case 84: self = .enumLabel84 - case 85: self = .enumLabel85 - case 86: self = .enumLabel86 - case 87: self = .enumLabel87 - case 88: self = .enumLabel88 - case 89: self = .enumLabel89 - case 90: self = .enumLabel90 - case 91: self = .enumLabel91 - case 92: self = .enumLabel92 - case 93: self = .enumLabel93 - case 94: self = .enumLabel94 - case 95: self = .enumLabel95 - case 96: self = .enumLabel96 - case 97: self = .enumLabel97 - case 98: self = .enumLabel98 - case 99: self = .enumLabel99 - case 100: self = .enumLabel100 - default: return nil - } - } - - var rawValue: Int { - switch self { - case .enumLabelDefault: return 0 - case .enumLabel1: return 1 - case .enumLabel2: return 2 - case .enumLabel3: return 3 - case .enumLabel4: return 4 - case .enumLabel5: return 5 - case .enumLabel6: return 6 - case .enumLabel7: return 7 - case .enumLabel8: return 8 - case .enumLabel9: return 9 - case .enumLabel10: return 10 - case .enumLabel11: return 11 - case .enumLabel12: return 12 - case .enumLabel13: return 13 - case .enumLabel14: return 14 - case .enumLabel15: return 15 - case .enumLabel16: return 16 - case .enumLabel17: return 17 - case .enumLabel18: return 18 - case .enumLabel19: return 19 - case .enumLabel20: return 20 - case .enumLabel21: return 21 - case .enumLabel22: return 22 - case .enumLabel23: return 23 - case .enumLabel24: return 24 - case .enumLabel25: return 25 - case .enumLabel26: return 26 - case .enumLabel27: return 27 - case .enumLabel28: return 28 - case .enumLabel29: return 29 - case .enumLabel30: return 30 - case .enumLabel31: return 31 - case .enumLabel32: return 32 - case .enumLabel33: return 33 - case .enumLabel34: return 34 - case .enumLabel35: return 35 - case .enumLabel36: return 36 - case .enumLabel37: return 37 - case .enumLabel38: return 38 - case .enumLabel39: return 39 - case .enumLabel40: return 40 - case .enumLabel41: return 41 - case .enumLabel42: return 42 - case .enumLabel43: return 43 - case .enumLabel44: return 44 - case .enumLabel45: return 45 - case .enumLabel46: return 46 - case .enumLabel47: return 47 - case .enumLabel48: return 48 - case .enumLabel49: return 49 - case .enumLabel50: return 50 - case .enumLabel51: return 51 - case .enumLabel52: return 52 - case .enumLabel53: return 53 - case .enumLabel54: return 54 - case .enumLabel55: return 55 - case .enumLabel56: return 56 - case .enumLabel57: return 57 - case .enumLabel58: return 58 - case .enumLabel59: return 59 - case .enumLabel60: return 60 - case .enumLabel61: return 61 - case .enumLabel62: return 62 - case .enumLabel63: return 63 - case .enumLabel64: return 64 - case .enumLabel65: return 65 - case .enumLabel66: return 66 - case .enumLabel67: return 67 - case .enumLabel68: return 68 - case .enumLabel69: return 69 - case .enumLabel70: return 70 - case .enumLabel71: return 71 - case .enumLabel72: return 72 - case .enumLabel73: return 73 - case .enumLabel74: return 74 - case .enumLabel75: return 75 - case .enumLabel76: return 76 - case .enumLabel77: return 77 - case .enumLabel78: return 78 - case .enumLabel79: return 79 - case .enumLabel80: return 80 - case .enumLabel81: return 81 - case .enumLabel82: return 82 - case .enumLabel83: return 83 - case .enumLabel84: return 84 - case .enumLabel85: return 85 - case .enumLabel86: return 86 - case .enumLabel87: return 87 - case .enumLabel88: return 88 - case .enumLabel89: return 89 - case .enumLabel90: return 90 - case .enumLabel91: return 91 - case .enumLabel92: return 92 - case .enumLabel93: return 93 - case .enumLabel94: return 94 - case .enumLabel95: return 95 - case .enumLabel96: return 96 - case .enumLabel97: return 97 - case .enumLabel98: return 98 - case .enumLabel99: return 99 - case .enumLabel100: return 100 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_VeryLargeEnum: CaseIterable { - // Support synthesized by the compiler. } -#endif // swift(>=4.2) - /// This proto includes every type of field in both singular and repeated /// forms. -struct ProtobufUnittest_TestAllTypes { +struct SwiftProtoTesting_TestAllTypes: @unchecked Sendable { // 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. /// Singular var optionalInt32: Int32 { - get {return _storage._optionalInt32 ?? 0} + get {_storage._optionalInt32 ?? 0} set {_uniqueStorage()._optionalInt32 = newValue} } /// Returns true if `optionalInt32` has been explicitly set. - var hasOptionalInt32: Bool {return _storage._optionalInt32 != nil} + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} var optionalInt64: Int64 { - get {return _storage._optionalInt64 ?? 0} + get {_storage._optionalInt64 ?? 0} set {_uniqueStorage()._optionalInt64 = newValue} } /// Returns true if `optionalInt64` has been explicitly set. - var hasOptionalInt64: Bool {return _storage._optionalInt64 != nil} + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} var optionalUint32: UInt32 { - get {return _storage._optionalUint32 ?? 0} + get {_storage._optionalUint32 ?? 0} set {_uniqueStorage()._optionalUint32 = newValue} } /// Returns true if `optionalUint32` has been explicitly set. - var hasOptionalUint32: Bool {return _storage._optionalUint32 != nil} + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} var optionalUint64: UInt64 { - get {return _storage._optionalUint64 ?? 0} + get {_storage._optionalUint64 ?? 0} set {_uniqueStorage()._optionalUint64 = newValue} } /// Returns true if `optionalUint64` has been explicitly set. - var hasOptionalUint64: Bool {return _storage._optionalUint64 != nil} + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} var optionalSint32: Int32 { - get {return _storage._optionalSint32 ?? 0} + get {_storage._optionalSint32 ?? 0} set {_uniqueStorage()._optionalSint32 = newValue} } /// Returns true if `optionalSint32` has been explicitly set. - var hasOptionalSint32: Bool {return _storage._optionalSint32 != nil} + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} var optionalSint64: Int64 { - get {return _storage._optionalSint64 ?? 0} + get {_storage._optionalSint64 ?? 0} set {_uniqueStorage()._optionalSint64 = newValue} } /// Returns true if `optionalSint64` has been explicitly set. - var hasOptionalSint64: Bool {return _storage._optionalSint64 != nil} + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32 ?? 0} + get {_storage._optionalFixed32 ?? 0} set {_uniqueStorage()._optionalFixed32 = newValue} } /// Returns true if `optionalFixed32` has been explicitly set. - var hasOptionalFixed32: Bool {return _storage._optionalFixed32 != nil} + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64 ?? 0} + get {_storage._optionalFixed64 ?? 0} set {_uniqueStorage()._optionalFixed64 = newValue} } /// Returns true if `optionalFixed64` has been explicitly set. - var hasOptionalFixed64: Bool {return _storage._optionalFixed64 != nil} + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32 ?? 0} + get {_storage._optionalSfixed32 ?? 0} set {_uniqueStorage()._optionalSfixed32 = newValue} } /// Returns true if `optionalSfixed32` has been explicitly set. - var hasOptionalSfixed32: Bool {return _storage._optionalSfixed32 != nil} + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64 ?? 0} + get {_storage._optionalSfixed64 ?? 0} set {_uniqueStorage()._optionalSfixed64 = newValue} } /// Returns true if `optionalSfixed64` has been explicitly set. - var hasOptionalSfixed64: Bool {return _storage._optionalSfixed64 != nil} + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} var optionalFloat: Float { - get {return _storage._optionalFloat ?? 0} + get {_storage._optionalFloat ?? 0} set {_uniqueStorage()._optionalFloat = newValue} } /// Returns true if `optionalFloat` has been explicitly set. - var hasOptionalFloat: Bool {return _storage._optionalFloat != nil} + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} var optionalDouble: Double { - get {return _storage._optionalDouble ?? 0} + get {_storage._optionalDouble ?? 0} set {_uniqueStorage()._optionalDouble = newValue} } /// Returns true if `optionalDouble` has been explicitly set. - var hasOptionalDouble: Bool {return _storage._optionalDouble != nil} + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} var optionalBool: Bool { - get {return _storage._optionalBool ?? false} + get {_storage._optionalBool ?? false} set {_uniqueStorage()._optionalBool = newValue} } /// Returns true if `optionalBool` has been explicitly set. - var hasOptionalBool: Bool {return _storage._optionalBool != nil} + var hasOptionalBool: Bool {_storage._optionalBool != nil} /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} var optionalString: String { - get {return _storage._optionalString ?? String()} + get {_storage._optionalString ?? String()} set {_uniqueStorage()._optionalString = newValue} } /// Returns true if `optionalString` has been explicitly set. - var hasOptionalString: Bool {return _storage._optionalString != nil} + var hasOptionalString: Bool {_storage._optionalString != nil} /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} var optionalBytes: Data { - get {return _storage._optionalBytes ?? Data()} + get {_storage._optionalBytes ?? Data()} set {_uniqueStorage()._optionalBytes = newValue} } /// Returns true if `optionalBytes` has been explicitly set. - var hasOptionalBytes: Bool {return _storage._optionalBytes != nil} + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} - var optionalGroup: ProtobufUnittest_TestAllTypes.OptionalGroup { - get {return _storage._optionalGroup ?? ProtobufUnittest_TestAllTypes.OptionalGroup()} + var optionalGroup: SwiftProtoTesting_TestAllTypes.OptionalGroup { + get {_storage._optionalGroup ?? SwiftProtoTesting_TestAllTypes.OptionalGroup()} set {_uniqueStorage()._optionalGroup = newValue} } /// Returns true if `optionalGroup` has been explicitly set. - var hasOptionalGroup: Bool {return _storage._optionalGroup != nil} + var hasOptionalGroup: Bool {_storage._optionalGroup != nil} /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. mutating func clearOptionalGroup() {_uniqueStorage()._optionalGroup = nil} - var optionalNestedMessage: ProtobufUnittest_TestAllTypes.NestedMessage { - get {return _storage._optionalNestedMessage ?? ProtobufUnittest_TestAllTypes.NestedMessage()} + var optionalNestedMessage: SwiftProtoTesting_TestAllTypes.NestedMessage { + get {_storage._optionalNestedMessage ?? SwiftProtoTesting_TestAllTypes.NestedMessage()} set {_uniqueStorage()._optionalNestedMessage = newValue} } /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} - var optionalForeignMessage: ProtobufUnittest_ForeignMessage { - get {return _storage._optionalForeignMessage ?? ProtobufUnittest_ForeignMessage()} + var optionalForeignMessage: SwiftProtoTesting_ForeignMessage { + get {_storage._optionalForeignMessage ?? SwiftProtoTesting_ForeignMessage()} set {_uniqueStorage()._optionalForeignMessage = newValue} } /// Returns true if `optionalForeignMessage` has been explicitly set. - var hasOptionalForeignMessage: Bool {return _storage._optionalForeignMessage != nil} + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} - var optionalImportMessage: ProtobufUnittestImport_ImportMessage { - get {return _storage._optionalImportMessage ?? ProtobufUnittestImport_ImportMessage()} + var optionalImportMessage: SwiftProtoTesting_Import_ImportMessage { + get {_storage._optionalImportMessage ?? SwiftProtoTesting_Import_ImportMessage()} set {_uniqueStorage()._optionalImportMessage = newValue} } /// Returns true if `optionalImportMessage` has been explicitly set. - var hasOptionalImportMessage: Bool {return _storage._optionalImportMessage != nil} + var hasOptionalImportMessage: Bool {_storage._optionalImportMessage != nil} /// Clears the value of `optionalImportMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalImportMessage() {_uniqueStorage()._optionalImportMessage = nil} - var optionalNestedEnum: ProtobufUnittest_TestAllTypes.NestedEnum { - get {return _storage._optionalNestedEnum ?? .foo} + var optionalNestedEnum: SwiftProtoTesting_TestAllTypes.NestedEnum { + get {_storage._optionalNestedEnum ?? .foo} set {_uniqueStorage()._optionalNestedEnum = newValue} } /// Returns true if `optionalNestedEnum` has been explicitly set. - var hasOptionalNestedEnum: Bool {return _storage._optionalNestedEnum != nil} + var hasOptionalNestedEnum: Bool {_storage._optionalNestedEnum != nil} /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} - var optionalForeignEnum: ProtobufUnittest_ForeignEnum { - get {return _storage._optionalForeignEnum ?? .foreignFoo} + var optionalForeignEnum: SwiftProtoTesting_ForeignEnum { + get {_storage._optionalForeignEnum ?? .foreignFoo} set {_uniqueStorage()._optionalForeignEnum = newValue} } /// Returns true if `optionalForeignEnum` has been explicitly set. - var hasOptionalForeignEnum: Bool {return _storage._optionalForeignEnum != nil} + var hasOptionalForeignEnum: Bool {_storage._optionalForeignEnum != nil} /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. mutating func clearOptionalForeignEnum() {_uniqueStorage()._optionalForeignEnum = nil} - var optionalImportEnum: ProtobufUnittestImport_ImportEnum { - get {return _storage._optionalImportEnum ?? .importFoo} + var optionalImportEnum: SwiftProtoTesting_Import_ImportEnum { + get {_storage._optionalImportEnum ?? .importFoo} set {_uniqueStorage()._optionalImportEnum = newValue} } /// Returns true if `optionalImportEnum` has been explicitly set. - var hasOptionalImportEnum: Bool {return _storage._optionalImportEnum != nil} + var hasOptionalImportEnum: Bool {_storage._optionalImportEnum != nil} /// Clears the value of `optionalImportEnum`. Subsequent reads from it will return its default value. mutating func clearOptionalImportEnum() {_uniqueStorage()._optionalImportEnum = nil} - var optionalStringPiece: String { - get {return _storage._optionalStringPiece ?? String()} - set {_uniqueStorage()._optionalStringPiece = newValue} - } - /// Returns true if `optionalStringPiece` has been explicitly set. - var hasOptionalStringPiece: Bool {return _storage._optionalStringPiece != nil} - /// Clears the value of `optionalStringPiece`. Subsequent reads from it will return its default value. - mutating func clearOptionalStringPiece() {_uniqueStorage()._optionalStringPiece = nil} - - var optionalCord: String { - get {return _storage._optionalCord ?? String()} - set {_uniqueStorage()._optionalCord = newValue} - } - /// Returns true if `optionalCord` has been explicitly set. - var hasOptionalCord: Bool {return _storage._optionalCord != nil} - /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. - mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} - /// Defined in unittest_import_public.proto - var optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessage { - get {return _storage._optionalPublicImportMessage ?? ProtobufUnittestImport_PublicImportMessage()} + var optionalPublicImportMessage: SwiftProtoTesting_Import_PublicImportMessage { + get {_storage._optionalPublicImportMessage ?? SwiftProtoTesting_Import_PublicImportMessage()} set {_uniqueStorage()._optionalPublicImportMessage = newValue} } /// Returns true if `optionalPublicImportMessage` has been explicitly set. - var hasOptionalPublicImportMessage: Bool {return _storage._optionalPublicImportMessage != nil} + var hasOptionalPublicImportMessage: Bool {_storage._optionalPublicImportMessage != nil} /// Clears the value of `optionalPublicImportMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalPublicImportMessage() {_uniqueStorage()._optionalPublicImportMessage = nil} - var optionalLazyMessage: ProtobufUnittest_TestAllTypes.NestedMessage { - get {return _storage._optionalLazyMessage ?? ProtobufUnittest_TestAllTypes.NestedMessage()} - set {_uniqueStorage()._optionalLazyMessage = newValue} - } - /// Returns true if `optionalLazyMessage` has been explicitly set. - var hasOptionalLazyMessage: Bool {return _storage._optionalLazyMessage != nil} - /// Clears the value of `optionalLazyMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalLazyMessage() {_uniqueStorage()._optionalLazyMessage = nil} - /// Repeated var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } - var repeatedGroup: [ProtobufUnittest_TestAllTypes.RepeatedGroup] { - get {return _storage._repeatedGroup} + var repeatedGroup: [SwiftProtoTesting_TestAllTypes.RepeatedGroup] { + get {_storage._repeatedGroup} set {_uniqueStorage()._repeatedGroup = newValue} } - var repeatedNestedMessage: [ProtobufUnittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedNestedMessage} + var repeatedNestedMessage: [SwiftProtoTesting_TestAllTypes.NestedMessage] { + get {_storage._repeatedNestedMessage} set {_uniqueStorage()._repeatedNestedMessage = newValue} } - var repeatedForeignMessage: [ProtobufUnittest_ForeignMessage] { - get {return _storage._repeatedForeignMessage} + var repeatedForeignMessage: [SwiftProtoTesting_ForeignMessage] { + get {_storage._repeatedForeignMessage} set {_uniqueStorage()._repeatedForeignMessage = newValue} } - var repeatedImportMessage: [ProtobufUnittestImport_ImportMessage] { - get {return _storage._repeatedImportMessage} + var repeatedImportMessage: [SwiftProtoTesting_Import_ImportMessage] { + get {_storage._repeatedImportMessage} set {_uniqueStorage()._repeatedImportMessage = newValue} } - var repeatedNestedEnum: [ProtobufUnittest_TestAllTypes.NestedEnum] { - get {return _storage._repeatedNestedEnum} + var repeatedNestedEnum: [SwiftProtoTesting_TestAllTypes.NestedEnum] { + get {_storage._repeatedNestedEnum} set {_uniqueStorage()._repeatedNestedEnum = newValue} } - var repeatedForeignEnum: [ProtobufUnittest_ForeignEnum] { - get {return _storage._repeatedForeignEnum} + var repeatedForeignEnum: [SwiftProtoTesting_ForeignEnum] { + get {_storage._repeatedForeignEnum} set {_uniqueStorage()._repeatedForeignEnum = newValue} } - var repeatedImportEnum: [ProtobufUnittestImport_ImportEnum] { - get {return _storage._repeatedImportEnum} + var repeatedImportEnum: [SwiftProtoTesting_Import_ImportEnum] { + get {_storage._repeatedImportEnum} set {_uniqueStorage()._repeatedImportEnum = newValue} } - var repeatedStringPiece: [String] { - get {return _storage._repeatedStringPiece} - set {_uniqueStorage()._repeatedStringPiece = newValue} - } - - var repeatedCord: [String] { - get {return _storage._repeatedCord} - set {_uniqueStorage()._repeatedCord = newValue} - } - - var repeatedLazyMessage: [ProtobufUnittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedLazyMessage} - set {_uniqueStorage()._repeatedLazyMessage = newValue} - } - /// Singular with defaults var defaultInt32: Int32 { - get {return _storage._defaultInt32 ?? 41} + get {_storage._defaultInt32 ?? 41} set {_uniqueStorage()._defaultInt32 = newValue} } /// Returns true if `defaultInt32` has been explicitly set. - var hasDefaultInt32: Bool {return _storage._defaultInt32 != nil} + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} var defaultInt64: Int64 { - get {return _storage._defaultInt64 ?? 42} + get {_storage._defaultInt64 ?? 42} set {_uniqueStorage()._defaultInt64 = newValue} } /// Returns true if `defaultInt64` has been explicitly set. - var hasDefaultInt64: Bool {return _storage._defaultInt64 != nil} + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} var defaultUint32: UInt32 { - get {return _storage._defaultUint32 ?? 43} + get {_storage._defaultUint32 ?? 43} set {_uniqueStorage()._defaultUint32 = newValue} } /// Returns true if `defaultUint32` has been explicitly set. - var hasDefaultUint32: Bool {return _storage._defaultUint32 != nil} + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} var defaultUint64: UInt64 { - get {return _storage._defaultUint64 ?? 44} + get {_storage._defaultUint64 ?? 44} set {_uniqueStorage()._defaultUint64 = newValue} } /// Returns true if `defaultUint64` has been explicitly set. - var hasDefaultUint64: Bool {return _storage._defaultUint64 != nil} + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} var defaultSint32: Int32 { - get {return _storage._defaultSint32 ?? -45} + get {_storage._defaultSint32 ?? -45} set {_uniqueStorage()._defaultSint32 = newValue} } /// Returns true if `defaultSint32` has been explicitly set. - var hasDefaultSint32: Bool {return _storage._defaultSint32 != nil} + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} var defaultSint64: Int64 { - get {return _storage._defaultSint64 ?? 46} + get {_storage._defaultSint64 ?? 46} set {_uniqueStorage()._defaultSint64 = newValue} } /// Returns true if `defaultSint64` has been explicitly set. - var hasDefaultSint64: Bool {return _storage._defaultSint64 != nil} + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} var defaultFixed32: UInt32 { - get {return _storage._defaultFixed32 ?? 47} + get {_storage._defaultFixed32 ?? 47} set {_uniqueStorage()._defaultFixed32 = newValue} } /// Returns true if `defaultFixed32` has been explicitly set. - var hasDefaultFixed32: Bool {return _storage._defaultFixed32 != nil} + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} var defaultFixed64: UInt64 { - get {return _storage._defaultFixed64 ?? 48} + get {_storage._defaultFixed64 ?? 48} set {_uniqueStorage()._defaultFixed64 = newValue} } /// Returns true if `defaultFixed64` has been explicitly set. - var hasDefaultFixed64: Bool {return _storage._defaultFixed64 != nil} + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} var defaultSfixed32: Int32 { - get {return _storage._defaultSfixed32 ?? 49} + get {_storage._defaultSfixed32 ?? 49} set {_uniqueStorage()._defaultSfixed32 = newValue} } /// Returns true if `defaultSfixed32` has been explicitly set. - var hasDefaultSfixed32: Bool {return _storage._defaultSfixed32 != nil} + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} var defaultSfixed64: Int64 { - get {return _storage._defaultSfixed64 ?? -50} + get {_storage._defaultSfixed64 ?? -50} set {_uniqueStorage()._defaultSfixed64 = newValue} } /// Returns true if `defaultSfixed64` has been explicitly set. - var hasDefaultSfixed64: Bool {return _storage._defaultSfixed64 != nil} + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} var defaultFloat: Float { - get {return _storage._defaultFloat ?? 51.5} + get {_storage._defaultFloat ?? 51.5} set {_uniqueStorage()._defaultFloat = newValue} } /// Returns true if `defaultFloat` has been explicitly set. - var hasDefaultFloat: Bool {return _storage._defaultFloat != nil} + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} var defaultDouble: Double { - get {return _storage._defaultDouble ?? 52000} + get {_storage._defaultDouble ?? 52000} set {_uniqueStorage()._defaultDouble = newValue} } /// Returns true if `defaultDouble` has been explicitly set. - var hasDefaultDouble: Bool {return _storage._defaultDouble != nil} + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} var defaultBool: Bool { - get {return _storage._defaultBool ?? true} + get {_storage._defaultBool ?? true} set {_uniqueStorage()._defaultBool = newValue} } /// Returns true if `defaultBool` has been explicitly set. - var hasDefaultBool: Bool {return _storage._defaultBool != nil} + var hasDefaultBool: Bool {_storage._defaultBool != nil} /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} var defaultString: String { - get {return _storage._defaultString ?? "hello"} + get {_storage._defaultString ?? "hello"} set {_uniqueStorage()._defaultString = newValue} } /// Returns true if `defaultString` has been explicitly set. - var hasDefaultString: Bool {return _storage._defaultString != nil} + var hasDefaultString: Bool {_storage._defaultString != nil} /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} var defaultBytes: Data { - get {return _storage._defaultBytes ?? Data([119, 111, 114, 108, 100])} + get {_storage._defaultBytes ?? Data([119, 111, 114, 108, 100])} set {_uniqueStorage()._defaultBytes = newValue} } /// Returns true if `defaultBytes` has been explicitly set. - var hasDefaultBytes: Bool {return _storage._defaultBytes != nil} + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} - var defaultNestedEnum: ProtobufUnittest_TestAllTypes.NestedEnum { - get {return _storage._defaultNestedEnum ?? .bar} + var defaultNestedEnum: SwiftProtoTesting_TestAllTypes.NestedEnum { + get {_storage._defaultNestedEnum ?? .bar} set {_uniqueStorage()._defaultNestedEnum = newValue} } /// Returns true if `defaultNestedEnum` has been explicitly set. - var hasDefaultNestedEnum: Bool {return _storage._defaultNestedEnum != nil} + var hasDefaultNestedEnum: Bool {_storage._defaultNestedEnum != nil} /// Clears the value of `defaultNestedEnum`. Subsequent reads from it will return its default value. mutating func clearDefaultNestedEnum() {_uniqueStorage()._defaultNestedEnum = nil} - var defaultForeignEnum: ProtobufUnittest_ForeignEnum { - get {return _storage._defaultForeignEnum ?? .foreignBar} + var defaultForeignEnum: SwiftProtoTesting_ForeignEnum { + get {_storage._defaultForeignEnum ?? .foreignBar} set {_uniqueStorage()._defaultForeignEnum = newValue} } /// Returns true if `defaultForeignEnum` has been explicitly set. - var hasDefaultForeignEnum: Bool {return _storage._defaultForeignEnum != nil} + var hasDefaultForeignEnum: Bool {_storage._defaultForeignEnum != nil} /// Clears the value of `defaultForeignEnum`. Subsequent reads from it will return its default value. mutating func clearDefaultForeignEnum() {_uniqueStorage()._defaultForeignEnum = nil} - var defaultImportEnum: ProtobufUnittestImport_ImportEnum { - get {return _storage._defaultImportEnum ?? .importBar} + var defaultImportEnum: SwiftProtoTesting_Import_ImportEnum { + get {_storage._defaultImportEnum ?? .importBar} set {_uniqueStorage()._defaultImportEnum = newValue} } /// Returns true if `defaultImportEnum` has been explicitly set. - var hasDefaultImportEnum: Bool {return _storage._defaultImportEnum != nil} + var hasDefaultImportEnum: Bool {_storage._defaultImportEnum != nil} /// Clears the value of `defaultImportEnum`. Subsequent reads from it will return its default value. mutating func clearDefaultImportEnum() {_uniqueStorage()._defaultImportEnum = nil} - var defaultStringPiece: String { - get {return _storage._defaultStringPiece ?? "abc"} - set {_uniqueStorage()._defaultStringPiece = newValue} - } - /// Returns true if `defaultStringPiece` has been explicitly set. - var hasDefaultStringPiece: Bool {return _storage._defaultStringPiece != nil} - /// Clears the value of `defaultStringPiece`. Subsequent reads from it will return its default value. - mutating func clearDefaultStringPiece() {_uniqueStorage()._defaultStringPiece = nil} - - var defaultCord: String { - get {return _storage._defaultCord ?? "123"} - set {_uniqueStorage()._defaultCord = newValue} - } - /// Returns true if `defaultCord` has been explicitly set. - var hasDefaultCord: Bool {return _storage._defaultCord != nil} - /// Clears the value of `defaultCord`. Subsequent reads from it will return its default value. - mutating func clearDefaultCord() {_uniqueStorage()._defaultCord = nil} - /// For oneof test var oneofField: OneOf_OneofField? { get {return _storage._oneofField} @@ -1080,10 +588,10 @@ struct ProtobufUnittest_TestAllTypes { set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} } - var oneofNestedMessage: ProtobufUnittest_TestAllTypes.NestedMessage { + var oneofNestedMessage: SwiftProtoTesting_TestAllTypes.NestedMessage { get { if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} - return ProtobufUnittest_TestAllTypes.NestedMessage() + return SwiftProtoTesting_TestAllTypes.NestedMessage() } set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} } @@ -1107,75 +615,29 @@ struct ProtobufUnittest_TestAllTypes { var unknownFields = SwiftProtobuf.UnknownStorage() /// For oneof test - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case oneofUint32(UInt32) - case oneofNestedMessage(ProtobufUnittest_TestAllTypes.NestedMessage) + case oneofNestedMessage(SwiftProtoTesting_TestAllTypes.NestedMessage) case oneofString(String) case oneofBytes(Data) - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestAllTypes.OneOf_OneofField, rhs: ProtobufUnittest_TestAllTypes.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum NestedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 1 - case bar // = 2 - case baz // = 3 + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 1 + case bar = 2 + case baz = 3 /// Intentionally negative. - case neg // = -1 + case neg = -1 init() { self = .foo } - init?(rawValue: Int) { - switch rawValue { - case -1: self = .neg - case 1: self = .foo - case 2: self = .bar - case 3: self = .baz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .neg: return -1 - case .foo: return 1 - case .bar: return 2 - case .baz: return 3 - } - } - } - struct NestedMessage { + struct NestedMessage: Sendable { // 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. @@ -1184,11 +646,11 @@ struct ProtobufUnittest_TestAllTypes { /// a local variable named "b" in one of the generated methods. Doh. /// This file needs to compile in proto1 to test backwards-compatibility. var bb: Int32 { - get {return _bb ?? 0} + get {_bb ?? 0} set {_bb = newValue} } /// Returns true if `bb` has been explicitly set. - var hasBb: Bool {return self._bb != nil} + var hasBb: Bool {self._bb != nil} /// Clears the value of `bb`. Subsequent reads from it will return its default value. mutating func clearBb() {self._bb = nil} @@ -1199,17 +661,17 @@ struct ProtobufUnittest_TestAllTypes { fileprivate var _bb: Int32? = nil } - struct OptionalGroup { + struct OptionalGroup: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -1220,17 +682,17 @@ struct ProtobufUnittest_TestAllTypes { fileprivate var _a: Int32? = nil } - struct RepeatedGroup { + struct RepeatedGroup: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -1246,40 +708,32 @@ struct ProtobufUnittest_TestAllTypes { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension ProtobufUnittest_TestAllTypes.NestedEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - /// This proto includes a recursively nested message. -struct ProtobufUnittest_NestedTestAllTypes { +struct SwiftProtoTesting_NestedTestAllTypes: @unchecked Sendable { // 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 child: ProtobufUnittest_NestedTestAllTypes { - get {return _storage._child ?? ProtobufUnittest_NestedTestAllTypes()} + var child: SwiftProtoTesting_NestedTestAllTypes { + get {_storage._child ?? SwiftProtoTesting_NestedTestAllTypes()} set {_uniqueStorage()._child = newValue} } /// Returns true if `child` has been explicitly set. - var hasChild: Bool {return _storage._child != nil} + var hasChild: Bool {_storage._child != nil} /// Clears the value of `child`. Subsequent reads from it will return its default value. mutating func clearChild() {_uniqueStorage()._child = nil} - var payload: ProtobufUnittest_TestAllTypes { - get {return _storage._payload ?? ProtobufUnittest_TestAllTypes()} + var payload: SwiftProtoTesting_TestAllTypes { + get {_storage._payload ?? SwiftProtoTesting_TestAllTypes()} set {_uniqueStorage()._payload = newValue} } /// Returns true if `payload` has been explicitly set. - var hasPayload: Bool {return _storage._payload != nil} + var hasPayload: Bool {_storage._payload != nil} /// Clears the value of `payload`. Subsequent reads from it will return its default value. mutating func clearPayload() {_uniqueStorage()._payload = nil} - var repeatedChild: [ProtobufUnittest_NestedTestAllTypes] { - get {return _storage._repeatedChild} + var repeatedChild: [SwiftProtoTesting_NestedTestAllTypes] { + get {_storage._repeatedChild} set {_uniqueStorage()._repeatedChild = newValue} } @@ -1290,87 +744,28 @@ struct ProtobufUnittest_NestedTestAllTypes { fileprivate var _storage = _StorageClass.defaultInstance } -struct ProtobufUnittest_TestDeprecatedFields { - // 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 deprecatedInt32: Int32 { - get {return _deprecatedInt32 ?? 0} - set {_deprecatedInt32 = newValue} - } - /// Returns true if `deprecatedInt32` has been explicitly set. - var hasDeprecatedInt32: Bool {return self._deprecatedInt32 != nil} - /// Clears the value of `deprecatedInt32`. Subsequent reads from it will return its default value. - mutating func clearDeprecatedInt32() {self._deprecatedInt32 = nil} - - var oneofFields: ProtobufUnittest_TestDeprecatedFields.OneOf_OneofFields? = nil - - var deprecatedInt32InOneof: Int32 { - get { - if case .deprecatedInt32InOneof(let v)? = oneofFields {return v} - return 0 - } - set {oneofFields = .deprecatedInt32InOneof(newValue)} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum OneOf_OneofFields: Equatable { - case deprecatedInt32InOneof(Int32) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestDeprecatedFields.OneOf_OneofFields, rhs: ProtobufUnittest_TestDeprecatedFields.OneOf_OneofFields) -> 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 (.deprecatedInt32InOneof, .deprecatedInt32InOneof): return { - guard case .deprecatedInt32InOneof(let l) = lhs, case .deprecatedInt32InOneof(let r) = rhs else { preconditionFailure() } - return l == r - }() - } - } - #endif - } - - init() {} - - fileprivate var _deprecatedInt32: Int32? = nil -} - -struct ProtobufUnittest_TestDeprecatedMessage { - // 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() {} -} - /// Define these after TestAllTypes to make sure the compiler can handle /// that. -struct ProtobufUnittest_ForeignMessage { +struct SwiftProtoTesting_ForeignMessage: Sendable { // 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 c: Int32 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} var d: Int32 { - get {return _d ?? 0} + get {_d ?? 0} set {_d = newValue} } /// Returns true if `d` has been explicitly set. - var hasD: Bool {return self._d != nil} + var hasD: Bool {self._d != nil} /// Clears the value of `d`. Subsequent reads from it will return its default value. mutating func clearD() {self._d = nil} @@ -1382,17 +777,7 @@ struct ProtobufUnittest_ForeignMessage { fileprivate var _d: Int32? = nil } -struct ProtobufUnittest_TestReservedFields { - // 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 ProtobufUnittest_TestAllExtensions: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_TestAllExtensions: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -1404,17 +789,17 @@ struct ProtobufUnittest_TestAllExtensions: SwiftProtobuf.ExtensibleMessage { var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct ProtobufUnittest_OptionalGroup_extension { +struct SwiftProtoTesting_OptionalGroup_extension: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -1425,17 +810,17 @@ struct ProtobufUnittest_OptionalGroup_extension { fileprivate var _a: Int32? = nil } -struct ProtobufUnittest_RepeatedGroup_extension { +struct SwiftProtoTesting_RepeatedGroup_extension: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -1446,140 +831,14 @@ struct ProtobufUnittest_RepeatedGroup_extension { fileprivate var _a: Int32? = nil } -struct ProtobufUnittest_TestGroup { - // 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 optionalGroup: ProtobufUnittest_TestGroup.OptionalGroup { - get {return _optionalGroup ?? ProtobufUnittest_TestGroup.OptionalGroup()} - set {_optionalGroup = newValue} - } - /// Returns true if `optionalGroup` has been explicitly set. - var hasOptionalGroup: Bool {return self._optionalGroup != nil} - /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. - mutating func clearOptionalGroup() {self._optionalGroup = nil} - - var optionalForeignEnum: ProtobufUnittest_ForeignEnum { - get {return _optionalForeignEnum ?? .foreignFoo} - set {_optionalForeignEnum = newValue} - } - /// Returns true if `optionalForeignEnum` has been explicitly set. - var hasOptionalForeignEnum: Bool {return self._optionalForeignEnum != nil} - /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. - mutating func clearOptionalForeignEnum() {self._optionalForeignEnum = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct OptionalGroup { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil - } - - init() {} - - fileprivate var _optionalGroup: ProtobufUnittest_TestGroup.OptionalGroup? = nil - fileprivate var _optionalForeignEnum: ProtobufUnittest_ForeignEnum? = nil -} - -struct ProtobufUnittest_TestGroupExtension: 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() -} - -struct ProtobufUnittest_TestNestedExtension { - // 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() - - struct OptionalGroup_extension { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil - } - - init() {} -} - -struct ProtobufUnittest_TestChildExtension { +struct SwiftProtoTesting_TestNestedExtension: Sendable { // 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 a: String { - get {return _a ?? String()} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var b: String { - get {return _b ?? String()} - set {_b = newValue} - } - /// Returns true if `b` has been explicitly set. - var hasB: Bool {return self._b != nil} - /// Clears the value of `b`. Subsequent reads from it will return its default value. - mutating func clearB() {self._b = nil} - - var optionalExtension: ProtobufUnittest_TestAllExtensions { - get {return _optionalExtension ?? ProtobufUnittest_TestAllExtensions()} - set {_optionalExtension = newValue} - } - /// Returns true if `optionalExtension` has been explicitly set. - var hasOptionalExtension: Bool {return self._optionalExtension != nil} - /// Clears the value of `optionalExtension`. Subsequent reads from it will return its default value. - mutating func clearOptionalExtension() {self._optionalExtension = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() init() {} - - fileprivate var _a: String? = nil - fileprivate var _b: String? = nil - fileprivate var _optionalExtension: ProtobufUnittest_TestAllExtensions? = nil } /// We have separate messages for testing required fields because it's @@ -1587,310 +846,319 @@ struct ProtobufUnittest_TestChildExtension { /// do anything with it. Note that we don't need to test every type of /// required filed because the code output is basically identical to /// optional fields for all types. -struct ProtobufUnittest_TestRequired { +struct SwiftProtoTesting_TestRequired: @unchecked Sendable { // 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 a: Int32 { - get {return _storage._a ?? 0} + get {_storage._a ?? 0} set {_uniqueStorage()._a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return _storage._a != nil} + var hasA: Bool {_storage._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {_uniqueStorage()._a = nil} var dummy2: Int32 { - get {return _storage._dummy2 ?? 0} + get {_storage._dummy2 ?? 0} set {_uniqueStorage()._dummy2 = newValue} } /// Returns true if `dummy2` has been explicitly set. - var hasDummy2: Bool {return _storage._dummy2 != nil} + var hasDummy2: Bool {_storage._dummy2 != nil} /// Clears the value of `dummy2`. Subsequent reads from it will return its default value. mutating func clearDummy2() {_uniqueStorage()._dummy2 = nil} var b: Int32 { - get {return _storage._b ?? 0} + get {_storage._b ?? 0} set {_uniqueStorage()._b = newValue} } /// Returns true if `b` has been explicitly set. - var hasB: Bool {return _storage._b != nil} + var hasB: Bool {_storage._b != nil} /// Clears the value of `b`. Subsequent reads from it will return its default value. mutating func clearB() {_uniqueStorage()._b = nil} /// Pad the field count to 32 so that we can test that IsInitialized() /// properly checks multiple elements of has_bits_. var dummy4: Int32 { - get {return _storage._dummy4 ?? 0} + get {_storage._dummy4 ?? 0} set {_uniqueStorage()._dummy4 = newValue} } /// Returns true if `dummy4` has been explicitly set. - var hasDummy4: Bool {return _storage._dummy4 != nil} + var hasDummy4: Bool {_storage._dummy4 != nil} /// Clears the value of `dummy4`. Subsequent reads from it will return its default value. mutating func clearDummy4() {_uniqueStorage()._dummy4 = nil} var dummy5: Int32 { - get {return _storage._dummy5 ?? 0} + get {_storage._dummy5 ?? 0} set {_uniqueStorage()._dummy5 = newValue} } /// Returns true if `dummy5` has been explicitly set. - var hasDummy5: Bool {return _storage._dummy5 != nil} + var hasDummy5: Bool {_storage._dummy5 != nil} /// Clears the value of `dummy5`. Subsequent reads from it will return its default value. mutating func clearDummy5() {_uniqueStorage()._dummy5 = nil} var dummy6: Int32 { - get {return _storage._dummy6 ?? 0} + get {_storage._dummy6 ?? 0} set {_uniqueStorage()._dummy6 = newValue} } /// Returns true if `dummy6` has been explicitly set. - var hasDummy6: Bool {return _storage._dummy6 != nil} + var hasDummy6: Bool {_storage._dummy6 != nil} /// Clears the value of `dummy6`. Subsequent reads from it will return its default value. mutating func clearDummy6() {_uniqueStorage()._dummy6 = nil} var dummy7: Int32 { - get {return _storage._dummy7 ?? 0} + get {_storage._dummy7 ?? 0} set {_uniqueStorage()._dummy7 = newValue} } /// Returns true if `dummy7` has been explicitly set. - var hasDummy7: Bool {return _storage._dummy7 != nil} + var hasDummy7: Bool {_storage._dummy7 != nil} /// Clears the value of `dummy7`. Subsequent reads from it will return its default value. mutating func clearDummy7() {_uniqueStorage()._dummy7 = nil} var dummy8: Int32 { - get {return _storage._dummy8 ?? 0} + get {_storage._dummy8 ?? 0} set {_uniqueStorage()._dummy8 = newValue} } /// Returns true if `dummy8` has been explicitly set. - var hasDummy8: Bool {return _storage._dummy8 != nil} + var hasDummy8: Bool {_storage._dummy8 != nil} /// Clears the value of `dummy8`. Subsequent reads from it will return its default value. mutating func clearDummy8() {_uniqueStorage()._dummy8 = nil} var dummy9: Int32 { - get {return _storage._dummy9 ?? 0} + get {_storage._dummy9 ?? 0} set {_uniqueStorage()._dummy9 = newValue} } /// Returns true if `dummy9` has been explicitly set. - var hasDummy9: Bool {return _storage._dummy9 != nil} + var hasDummy9: Bool {_storage._dummy9 != nil} /// Clears the value of `dummy9`. Subsequent reads from it will return its default value. mutating func clearDummy9() {_uniqueStorage()._dummy9 = nil} var dummy10: Int32 { - get {return _storage._dummy10 ?? 0} + get {_storage._dummy10 ?? 0} set {_uniqueStorage()._dummy10 = newValue} } /// Returns true if `dummy10` has been explicitly set. - var hasDummy10: Bool {return _storage._dummy10 != nil} + var hasDummy10: Bool {_storage._dummy10 != nil} /// Clears the value of `dummy10`. Subsequent reads from it will return its default value. mutating func clearDummy10() {_uniqueStorage()._dummy10 = nil} var dummy11: Int32 { - get {return _storage._dummy11 ?? 0} + get {_storage._dummy11 ?? 0} set {_uniqueStorage()._dummy11 = newValue} } /// Returns true if `dummy11` has been explicitly set. - var hasDummy11: Bool {return _storage._dummy11 != nil} + var hasDummy11: Bool {_storage._dummy11 != nil} /// Clears the value of `dummy11`. Subsequent reads from it will return its default value. mutating func clearDummy11() {_uniqueStorage()._dummy11 = nil} var dummy12: Int32 { - get {return _storage._dummy12 ?? 0} + get {_storage._dummy12 ?? 0} set {_uniqueStorage()._dummy12 = newValue} } /// Returns true if `dummy12` has been explicitly set. - var hasDummy12: Bool {return _storage._dummy12 != nil} + var hasDummy12: Bool {_storage._dummy12 != nil} /// Clears the value of `dummy12`. Subsequent reads from it will return its default value. mutating func clearDummy12() {_uniqueStorage()._dummy12 = nil} var dummy13: Int32 { - get {return _storage._dummy13 ?? 0} + get {_storage._dummy13 ?? 0} set {_uniqueStorage()._dummy13 = newValue} } /// Returns true if `dummy13` has been explicitly set. - var hasDummy13: Bool {return _storage._dummy13 != nil} + var hasDummy13: Bool {_storage._dummy13 != nil} /// Clears the value of `dummy13`. Subsequent reads from it will return its default value. mutating func clearDummy13() {_uniqueStorage()._dummy13 = nil} var dummy14: Int32 { - get {return _storage._dummy14 ?? 0} + get {_storage._dummy14 ?? 0} set {_uniqueStorage()._dummy14 = newValue} } /// Returns true if `dummy14` has been explicitly set. - var hasDummy14: Bool {return _storage._dummy14 != nil} + var hasDummy14: Bool {_storage._dummy14 != nil} /// Clears the value of `dummy14`. Subsequent reads from it will return its default value. mutating func clearDummy14() {_uniqueStorage()._dummy14 = nil} var dummy15: Int32 { - get {return _storage._dummy15 ?? 0} + get {_storage._dummy15 ?? 0} set {_uniqueStorage()._dummy15 = newValue} } /// Returns true if `dummy15` has been explicitly set. - var hasDummy15: Bool {return _storage._dummy15 != nil} + var hasDummy15: Bool {_storage._dummy15 != nil} /// Clears the value of `dummy15`. Subsequent reads from it will return its default value. mutating func clearDummy15() {_uniqueStorage()._dummy15 = nil} var dummy16: Int32 { - get {return _storage._dummy16 ?? 0} + get {_storage._dummy16 ?? 0} set {_uniqueStorage()._dummy16 = newValue} } /// Returns true if `dummy16` has been explicitly set. - var hasDummy16: Bool {return _storage._dummy16 != nil} + var hasDummy16: Bool {_storage._dummy16 != nil} /// Clears the value of `dummy16`. Subsequent reads from it will return its default value. mutating func clearDummy16() {_uniqueStorage()._dummy16 = nil} var dummy17: Int32 { - get {return _storage._dummy17 ?? 0} + get {_storage._dummy17 ?? 0} set {_uniqueStorage()._dummy17 = newValue} } /// Returns true if `dummy17` has been explicitly set. - var hasDummy17: Bool {return _storage._dummy17 != nil} + var hasDummy17: Bool {_storage._dummy17 != nil} /// Clears the value of `dummy17`. Subsequent reads from it will return its default value. mutating func clearDummy17() {_uniqueStorage()._dummy17 = nil} var dummy18: Int32 { - get {return _storage._dummy18 ?? 0} + get {_storage._dummy18 ?? 0} set {_uniqueStorage()._dummy18 = newValue} } /// Returns true if `dummy18` has been explicitly set. - var hasDummy18: Bool {return _storage._dummy18 != nil} + var hasDummy18: Bool {_storage._dummy18 != nil} /// Clears the value of `dummy18`. Subsequent reads from it will return its default value. mutating func clearDummy18() {_uniqueStorage()._dummy18 = nil} var dummy19: Int32 { - get {return _storage._dummy19 ?? 0} + get {_storage._dummy19 ?? 0} set {_uniqueStorage()._dummy19 = newValue} } /// Returns true if `dummy19` has been explicitly set. - var hasDummy19: Bool {return _storage._dummy19 != nil} + var hasDummy19: Bool {_storage._dummy19 != nil} /// Clears the value of `dummy19`. Subsequent reads from it will return its default value. mutating func clearDummy19() {_uniqueStorage()._dummy19 = nil} var dummy20: Int32 { - get {return _storage._dummy20 ?? 0} + get {_storage._dummy20 ?? 0} set {_uniqueStorage()._dummy20 = newValue} } /// Returns true if `dummy20` has been explicitly set. - var hasDummy20: Bool {return _storage._dummy20 != nil} + var hasDummy20: Bool {_storage._dummy20 != nil} /// Clears the value of `dummy20`. Subsequent reads from it will return its default value. mutating func clearDummy20() {_uniqueStorage()._dummy20 = nil} var dummy21: Int32 { - get {return _storage._dummy21 ?? 0} + get {_storage._dummy21 ?? 0} set {_uniqueStorage()._dummy21 = newValue} } /// Returns true if `dummy21` has been explicitly set. - var hasDummy21: Bool {return _storage._dummy21 != nil} + var hasDummy21: Bool {_storage._dummy21 != nil} /// Clears the value of `dummy21`. Subsequent reads from it will return its default value. mutating func clearDummy21() {_uniqueStorage()._dummy21 = nil} var dummy22: Int32 { - get {return _storage._dummy22 ?? 0} + get {_storage._dummy22 ?? 0} set {_uniqueStorage()._dummy22 = newValue} } /// Returns true if `dummy22` has been explicitly set. - var hasDummy22: Bool {return _storage._dummy22 != nil} + var hasDummy22: Bool {_storage._dummy22 != nil} /// Clears the value of `dummy22`. Subsequent reads from it will return its default value. mutating func clearDummy22() {_uniqueStorage()._dummy22 = nil} var dummy23: Int32 { - get {return _storage._dummy23 ?? 0} + get {_storage._dummy23 ?? 0} set {_uniqueStorage()._dummy23 = newValue} } /// Returns true if `dummy23` has been explicitly set. - var hasDummy23: Bool {return _storage._dummy23 != nil} + var hasDummy23: Bool {_storage._dummy23 != nil} /// Clears the value of `dummy23`. Subsequent reads from it will return its default value. mutating func clearDummy23() {_uniqueStorage()._dummy23 = nil} var dummy24: Int32 { - get {return _storage._dummy24 ?? 0} + get {_storage._dummy24 ?? 0} set {_uniqueStorage()._dummy24 = newValue} } /// Returns true if `dummy24` has been explicitly set. - var hasDummy24: Bool {return _storage._dummy24 != nil} + var hasDummy24: Bool {_storage._dummy24 != nil} /// Clears the value of `dummy24`. Subsequent reads from it will return its default value. mutating func clearDummy24() {_uniqueStorage()._dummy24 = nil} var dummy25: Int32 { - get {return _storage._dummy25 ?? 0} + get {_storage._dummy25 ?? 0} set {_uniqueStorage()._dummy25 = newValue} } /// Returns true if `dummy25` has been explicitly set. - var hasDummy25: Bool {return _storage._dummy25 != nil} + var hasDummy25: Bool {_storage._dummy25 != nil} /// Clears the value of `dummy25`. Subsequent reads from it will return its default value. mutating func clearDummy25() {_uniqueStorage()._dummy25 = nil} var dummy26: Int32 { - get {return _storage._dummy26 ?? 0} + get {_storage._dummy26 ?? 0} set {_uniqueStorage()._dummy26 = newValue} } /// Returns true if `dummy26` has been explicitly set. - var hasDummy26: Bool {return _storage._dummy26 != nil} + var hasDummy26: Bool {_storage._dummy26 != nil} /// Clears the value of `dummy26`. Subsequent reads from it will return its default value. mutating func clearDummy26() {_uniqueStorage()._dummy26 = nil} var dummy27: Int32 { - get {return _storage._dummy27 ?? 0} + get {_storage._dummy27 ?? 0} set {_uniqueStorage()._dummy27 = newValue} } /// Returns true if `dummy27` has been explicitly set. - var hasDummy27: Bool {return _storage._dummy27 != nil} + var hasDummy27: Bool {_storage._dummy27 != nil} /// Clears the value of `dummy27`. Subsequent reads from it will return its default value. mutating func clearDummy27() {_uniqueStorage()._dummy27 = nil} var dummy28: Int32 { - get {return _storage._dummy28 ?? 0} + get {_storage._dummy28 ?? 0} set {_uniqueStorage()._dummy28 = newValue} } /// Returns true if `dummy28` has been explicitly set. - var hasDummy28: Bool {return _storage._dummy28 != nil} + var hasDummy28: Bool {_storage._dummy28 != nil} /// Clears the value of `dummy28`. Subsequent reads from it will return its default value. mutating func clearDummy28() {_uniqueStorage()._dummy28 = nil} var dummy29: Int32 { - get {return _storage._dummy29 ?? 0} + get {_storage._dummy29 ?? 0} set {_uniqueStorage()._dummy29 = newValue} } /// Returns true if `dummy29` has been explicitly set. - var hasDummy29: Bool {return _storage._dummy29 != nil} + var hasDummy29: Bool {_storage._dummy29 != nil} /// Clears the value of `dummy29`. Subsequent reads from it will return its default value. mutating func clearDummy29() {_uniqueStorage()._dummy29 = nil} var dummy30: Int32 { - get {return _storage._dummy30 ?? 0} + get {_storage._dummy30 ?? 0} set {_uniqueStorage()._dummy30 = newValue} } /// Returns true if `dummy30` has been explicitly set. - var hasDummy30: Bool {return _storage._dummy30 != nil} + var hasDummy30: Bool {_storage._dummy30 != nil} /// Clears the value of `dummy30`. Subsequent reads from it will return its default value. mutating func clearDummy30() {_uniqueStorage()._dummy30 = nil} var dummy31: Int32 { - get {return _storage._dummy31 ?? 0} + get {_storage._dummy31 ?? 0} set {_uniqueStorage()._dummy31 = newValue} } /// Returns true if `dummy31` has been explicitly set. - var hasDummy31: Bool {return _storage._dummy31 != nil} + var hasDummy31: Bool {_storage._dummy31 != nil} /// Clears the value of `dummy31`. Subsequent reads from it will return its default value. mutating func clearDummy31() {_uniqueStorage()._dummy31 = nil} var dummy32: Int32 { - get {return _storage._dummy32 ?? 0} + get {_storage._dummy32 ?? 0} set {_uniqueStorage()._dummy32 = newValue} } /// Returns true if `dummy32` has been explicitly set. - var hasDummy32: Bool {return _storage._dummy32 != nil} + var hasDummy32: Bool {_storage._dummy32 != nil} /// Clears the value of `dummy32`. Subsequent reads from it will return its default value. mutating func clearDummy32() {_uniqueStorage()._dummy32 = nil} var c: Int32 { - get {return _storage._c ?? 0} + get {_storage._c ?? 0} set {_uniqueStorage()._c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return _storage._c != nil} + var hasC: Bool {_storage._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {_uniqueStorage()._c = nil} + var optionalForeign: SwiftProtoTesting_ForeignMessage { + get {_storage._optionalForeign ?? SwiftProtoTesting_ForeignMessage()} + set {_uniqueStorage()._optionalForeign = newValue} + } + /// Returns true if `optionalForeign` has been explicitly set. + var hasOptionalForeign: Bool {_storage._optionalForeign != nil} + /// Clears the value of `optionalForeign`. Subsequent reads from it will return its default value. + mutating func clearOptionalForeign() {_uniqueStorage()._optionalForeign = nil} + var unknownFields = SwiftProtobuf.UnknownStorage() init() {} @@ -1898,28 +1166,28 @@ struct ProtobufUnittest_TestRequired { fileprivate var _storage = _StorageClass.defaultInstance } -struct ProtobufUnittest_TestRequiredForeign { +struct SwiftProtoTesting_TestRequiredForeign: Sendable { // 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 optionalMessage: ProtobufUnittest_TestRequired { - get {return _optionalMessage ?? ProtobufUnittest_TestRequired()} + var optionalMessage: SwiftProtoTesting_TestRequired { + get {_optionalMessage ?? SwiftProtoTesting_TestRequired()} set {_optionalMessage = newValue} } /// Returns true if `optionalMessage` has been explicitly set. - var hasOptionalMessage: Bool {return self._optionalMessage != nil} + var hasOptionalMessage: Bool {self._optionalMessage != nil} /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalMessage() {self._optionalMessage = nil} - var repeatedMessage: [ProtobufUnittest_TestRequired] = [] + var repeatedMessage: [SwiftProtoTesting_TestRequired] = [] var dummy: Int32 { - get {return _dummy ?? 0} + get {_dummy ?? 0} set {_dummy = newValue} } /// Returns true if `dummy` has been explicitly set. - var hasDummy: Bool {return self._dummy != nil} + var hasDummy: Bool {self._dummy != nil} /// Clears the value of `dummy`. Subsequent reads from it will return its default value. mutating func clearDummy() {self._dummy = nil} @@ -1927,32 +1195,32 @@ struct ProtobufUnittest_TestRequiredForeign { init() {} - fileprivate var _optionalMessage: ProtobufUnittest_TestRequired? = nil + fileprivate var _optionalMessage: SwiftProtoTesting_TestRequired? = nil fileprivate var _dummy: Int32? = nil } -struct ProtobufUnittest_TestRequiredMessage { +struct SwiftProtoTesting_TestRequiredMessage: Sendable { // 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 optionalMessage: ProtobufUnittest_TestRequired { - get {return _optionalMessage ?? ProtobufUnittest_TestRequired()} + var optionalMessage: SwiftProtoTesting_TestRequired { + get {_optionalMessage ?? SwiftProtoTesting_TestRequired()} set {_optionalMessage = newValue} } /// Returns true if `optionalMessage` has been explicitly set. - var hasOptionalMessage: Bool {return self._optionalMessage != nil} + var hasOptionalMessage: Bool {self._optionalMessage != nil} /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalMessage() {self._optionalMessage = nil} - var repeatedMessage: [ProtobufUnittest_TestRequired] = [] + var repeatedMessage: [SwiftProtoTesting_TestRequired] = [] - var requiredMessage: ProtobufUnittest_TestRequired { - get {return _requiredMessage ?? ProtobufUnittest_TestRequired()} + var requiredMessage: SwiftProtoTesting_TestRequired { + get {_requiredMessage ?? SwiftProtoTesting_TestRequired()} set {_requiredMessage = newValue} } /// Returns true if `requiredMessage` has been explicitly set. - var hasRequiredMessage: Bool {return self._requiredMessage != nil} + var hasRequiredMessage: Bool {self._requiredMessage != nil} /// Clears the value of `requiredMessage`. Subsequent reads from it will return its default value. mutating func clearRequiredMessage() {self._requiredMessage = nil} @@ -1960,176 +1228,75 @@ struct ProtobufUnittest_TestRequiredMessage { init() {} - fileprivate var _optionalMessage: ProtobufUnittest_TestRequired? = nil - fileprivate var _requiredMessage: ProtobufUnittest_TestRequired? = nil + fileprivate var _optionalMessage: SwiftProtoTesting_TestRequired? = nil + fileprivate var _requiredMessage: SwiftProtoTesting_TestRequired? = nil } -/// Test that we can use NestedMessage from outside TestAllTypes. -struct ProtobufUnittest_TestForeignNested { +/// TestEmptyMessage is used to test unknown field support. +struct SwiftProtoTesting_TestEmptyMessage: Sendable { // 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 foreignNested: ProtobufUnittest_TestAllTypes.NestedMessage { - get {return _foreignNested ?? ProtobufUnittest_TestAllTypes.NestedMessage()} - set {_foreignNested = newValue} - } - /// Returns true if `foreignNested` has been explicitly set. - var hasForeignNested: Bool {return self._foreignNested != nil} - /// Clears the value of `foreignNested`. Subsequent reads from it will return its default value. - mutating func clearForeignNested() {self._foreignNested = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() init() {} - - fileprivate var _foreignNested: ProtobufUnittest_TestAllTypes.NestedMessage? = nil } -/// TestEmptyMessage is used to test unknown field support. -struct ProtobufUnittest_TestEmptyMessage { +/// Test that really large tag numbers don't break anything. +struct SwiftProtoTesting_TestReallyLargeTagNumber: Sendable { // 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() {} -} + /// The largest possible tag number is 2^28 - 1, since the wire format uses + /// three bits to communicate wire type. + var a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} -/// Like above, but declare all field numbers as potential extensions. No -/// actual extensions should ever be defined for this type. -struct ProtobufUnittest_TestEmptyMessageWithExtensions: 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 bb: Int32 { + get {_bb ?? 0} + set {_bb = newValue} + } + /// Returns true if `bb` has been explicitly set. + var hasBb: Bool {self._bb != nil} + /// Clears the value of `bb`. Subsequent reads from it will return its default value. + mutating func clearBb() {self._bb = nil} var unknownFields = SwiftProtobuf.UnknownStorage() init() {} - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _a: Int32? = nil + fileprivate var _bb: Int32? = nil } -/// Needed for a Python test. -struct ProtobufUnittest_TestPickleNestedMessage { +struct SwiftProtoTesting_TestRecursiveMessage: @unchecked Sendable { // 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() - - struct NestedMessage { - // 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 bb: Int32 { - get {return _bb ?? 0} - set {_bb = newValue} - } - /// Returns true if `bb` has been explicitly set. - var hasBb: Bool {return self._bb != nil} - /// Clears the value of `bb`. Subsequent reads from it will return its default value. - mutating func clearBb() {self._bb = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct NestedNestedMessage { - // 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 cc: Int32 { - get {return _cc ?? 0} - set {_cc = newValue} - } - /// Returns true if `cc` has been explicitly set. - var hasCc: Bool {return self._cc != nil} - /// Clears the value of `cc`. Subsequent reads from it will return its default value. - mutating func clearCc() {self._cc = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _cc: Int32? = nil - } - - init() {} - - fileprivate var _bb: Int32? = nil - } - - init() {} -} - -struct ProtobufUnittest_TestMultipleExtensionRanges: 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() -} - -/// Test that really large tag numbers don't break anything. -struct ProtobufUnittest_TestReallyLargeTagNumber { - // 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. - - /// The largest possible tag number is 2^28 - 1, since the wire format uses - /// three bits to communicate wire type. - var a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var bb: Int32 { - get {return _bb ?? 0} - set {_bb = newValue} - } - /// Returns true if `bb` has been explicitly set. - var hasBb: Bool {return self._bb != nil} - /// Clears the value of `bb`. Subsequent reads from it will return its default value. - mutating func clearBb() {self._bb = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil - fileprivate var _bb: Int32? = nil -} - -struct ProtobufUnittest_TestRecursiveMessage { - // 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 a: ProtobufUnittest_TestRecursiveMessage { - get {return _storage._a ?? ProtobufUnittest_TestRecursiveMessage()} - set {_uniqueStorage()._a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return _storage._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {_uniqueStorage()._a = nil} + var a: SwiftProtoTesting_TestRecursiveMessage { + get {_storage._a ?? SwiftProtoTesting_TestRecursiveMessage()} + set {_uniqueStorage()._a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {_storage._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {_uniqueStorage()._a = nil} var i: Int32 { - get {return _storage._i ?? 0} + get {_storage._i ?? 0} set {_uniqueStorage()._i = newValue} } /// Returns true if `i` has been explicitly set. - var hasI: Bool {return _storage._i != nil} + var hasI: Bool {_storage._i != nil} /// Clears the value of `i`. Subsequent reads from it will return its default value. mutating func clearI() {_uniqueStorage()._i = nil} @@ -2140,8810 +1307,2572 @@ struct ProtobufUnittest_TestRecursiveMessage { fileprivate var _storage = _StorageClass.defaultInstance } -/// Test that mutual recursion works. -struct ProtobufUnittest_TestMutualRecursionA { +/// We list fields out of order, to ensure that we're using field number and not +/// field index to determine serialization order. +struct SwiftProtoTesting_TestFieldOrderings: SwiftProtobuf.ExtensibleMessage, Sendable { // 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 bb: ProtobufUnittest_TestMutualRecursionB { - get {return _storage._bb ?? ProtobufUnittest_TestMutualRecursionB()} - set {_uniqueStorage()._bb = newValue} + var myString: String { + get {_myString ?? String()} + set {_myString = newValue} } - /// Returns true if `bb` has been explicitly set. - var hasBb: Bool {return _storage._bb != nil} - /// Clears the value of `bb`. Subsequent reads from it will return its default value. - mutating func clearBb() {_uniqueStorage()._bb = nil} + /// Returns true if `myString` has been explicitly set. + var hasMyString: Bool {self._myString != nil} + /// Clears the value of `myString`. Subsequent reads from it will return its default value. + mutating func clearMyString() {self._myString = nil} - var subGroup: ProtobufUnittest_TestMutualRecursionA.SubGroup { - get {return _storage._subGroup ?? ProtobufUnittest_TestMutualRecursionA.SubGroup()} - set {_uniqueStorage()._subGroup = newValue} + var myInt: Int64 { + get {_myInt ?? 0} + set {_myInt = newValue} } - /// Returns true if `subGroup` has been explicitly set. - var hasSubGroup: Bool {return _storage._subGroup != nil} - /// Clears the value of `subGroup`. Subsequent reads from it will return its default value. - mutating func clearSubGroup() {_uniqueStorage()._subGroup = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - 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 b: ProtobufUnittest_TestMutualRecursionB { - get {return _storage._b ?? ProtobufUnittest_TestMutualRecursionB()} - set {_uniqueStorage()._b = newValue} - } - /// Returns true if `b` has been explicitly set. - var hasB: Bool {return _storage._b != nil} - /// Clears the value of `b`. Subsequent reads from it will return its default value. - mutating func clearB() {_uniqueStorage()._b = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() + /// Returns true if `myInt` has been explicitly set. + var hasMyInt: Bool {self._myInt != nil} + /// Clears the value of `myInt`. Subsequent reads from it will return its default value. + mutating func clearMyInt() {self._myInt = nil} - init() {} + var myFloat: Float { + get {_myFloat ?? 0} + set {_myFloat = newValue} + } + /// Returns true if `myFloat` has been explicitly set. + var hasMyFloat: Bool {self._myFloat != nil} + /// Clears the value of `myFloat`. Subsequent reads from it will return its default value. + mutating func clearMyFloat() {self._myFloat = nil} - fileprivate var _storage = _StorageClass.defaultInstance + var optionalNestedMessage: SwiftProtoTesting_TestFieldOrderings.NestedMessage { + get {_optionalNestedMessage ?? SwiftProtoTesting_TestFieldOrderings.NestedMessage()} + set {_optionalNestedMessage = newValue} } + /// Returns true if `optionalNestedMessage` has been explicitly set. + var hasOptionalNestedMessage: Bool {self._optionalNestedMessage != nil} + /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. + mutating func clearOptionalNestedMessage() {self._optionalNestedMessage = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() - struct SubGroup { + struct NestedMessage: Sendable { // 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. - /// Needed because of bug in javatest - var subMessage: ProtobufUnittest_TestMutualRecursionA.SubMessage { - get {return _storage._subMessage ?? ProtobufUnittest_TestMutualRecursionA.SubMessage()} - set {_uniqueStorage()._subMessage = newValue} + var oo: Int64 { + get {_oo ?? 0} + set {_oo = newValue} } - /// Returns true if `subMessage` has been explicitly set. - var hasSubMessage: Bool {return _storage._subMessage != nil} - /// Clears the value of `subMessage`. Subsequent reads from it will return its default value. - mutating func clearSubMessage() {_uniqueStorage()._subMessage = nil} - - var notInThisScc: ProtobufUnittest_TestAllTypes { - get {return _storage._notInThisScc ?? ProtobufUnittest_TestAllTypes()} - set {_uniqueStorage()._notInThisScc = newValue} + /// Returns true if `oo` has been explicitly set. + var hasOo: Bool {self._oo != nil} + /// Clears the value of `oo`. Subsequent reads from it will return its default value. + mutating func clearOo() {self._oo = nil} + + /// The field name "b" fails to compile in proto1 because it conflicts with + /// a local variable named "b" in one of the generated methods. Doh. + /// This file needs to compile in proto1 to test backwards-compatibility. + var bb: Int32 { + get {_bb ?? 0} + set {_bb = newValue} } - /// Returns true if `notInThisScc` has been explicitly set. - var hasNotInThisScc: Bool {return _storage._notInThisScc != nil} - /// Clears the value of `notInThisScc`. Subsequent reads from it will return its default value. - mutating func clearNotInThisScc() {_uniqueStorage()._notInThisScc = nil} + /// Returns true if `bb` has been explicitly set. + var hasBb: Bool {self._bb != nil} + /// Clears the value of `bb`. Subsequent reads from it will return its default value. + mutating func clearBb() {self._bb = nil} var unknownFields = SwiftProtobuf.UnknownStorage() init() {} - fileprivate var _storage = _StorageClass.defaultInstance + fileprivate var _oo: Int64? = nil + fileprivate var _bb: Int32? = nil } init() {} - fileprivate var _storage = _StorageClass.defaultInstance + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _myString: String? = nil + fileprivate var _myInt: Int64? = nil + fileprivate var _myFloat: Float? = nil + fileprivate var _optionalNestedMessage: SwiftProtoTesting_TestFieldOrderings.NestedMessage? = nil } -struct ProtobufUnittest_TestMutualRecursionB { +struct SwiftProtoTesting_TestExtremeDefaultValues: @unchecked Sendable { // 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 a: ProtobufUnittest_TestMutualRecursionA { - get {return _storage._a ?? ProtobufUnittest_TestMutualRecursionA()} - set {_uniqueStorage()._a = newValue} + var escapedBytes: Data { + get {_storage._escapedBytes ?? Data([0, 1, 7, 8, 12, 10, 13, 9, 11, 92, 39, 34, 254])} + set {_uniqueStorage()._escapedBytes = newValue} } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return _storage._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {_uniqueStorage()._a = nil} + /// Returns true if `escapedBytes` has been explicitly set. + var hasEscapedBytes: Bool {_storage._escapedBytes != nil} + /// Clears the value of `escapedBytes`. Subsequent reads from it will return its default value. + mutating func clearEscapedBytes() {_uniqueStorage()._escapedBytes = nil} - var optionalInt32: Int32 { - get {return _storage._optionalInt32 ?? 0} - set {_uniqueStorage()._optionalInt32 = newValue} + var largeUint32: UInt32 { + get {_storage._largeUint32 ?? 4294967295} + set {_uniqueStorage()._largeUint32 = newValue} } - /// Returns true if `optionalInt32` has been explicitly set. - var hasOptionalInt32: Bool {return _storage._optionalInt32 != nil} - /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. - mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -struct ProtobufUnittest_TestIsInitialized { - // 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. + /// Returns true if `largeUint32` has been explicitly set. + var hasLargeUint32: Bool {_storage._largeUint32 != nil} + /// Clears the value of `largeUint32`. Subsequent reads from it will return its default value. + mutating func clearLargeUint32() {_uniqueStorage()._largeUint32 = nil} - var subMessage: ProtobufUnittest_TestIsInitialized.SubMessage { - get {return _subMessage ?? ProtobufUnittest_TestIsInitialized.SubMessage()} - set {_subMessage = newValue} + var largeUint64: UInt64 { + get {_storage._largeUint64 ?? 18446744073709551615} + set {_uniqueStorage()._largeUint64 = newValue} } - /// Returns true if `subMessage` has been explicitly set. - var hasSubMessage: Bool {return self._subMessage != nil} - /// Clears the value of `subMessage`. Subsequent reads from it will return its default value. - mutating func clearSubMessage() {self._subMessage = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - 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 subGroup: ProtobufUnittest_TestIsInitialized.SubMessage.SubGroup { - get {return _subGroup ?? ProtobufUnittest_TestIsInitialized.SubMessage.SubGroup()} - set {_subGroup = newValue} - } - /// Returns true if `subGroup` has been explicitly set. - var hasSubGroup: Bool {return self._subGroup != nil} - /// Clears the value of `subGroup`. Subsequent reads from it will return its default value. - mutating func clearSubGroup() {self._subGroup = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct SubGroup { - // 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 i: Int32 { - get {return _i ?? 0} - set {_i = newValue} - } - /// Returns true if `i` has been explicitly set. - var hasI: Bool {return self._i != nil} - /// Clears the value of `i`. Subsequent reads from it will return its default value. - mutating func clearI() {self._i = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _i: Int32? = nil - } - - init() {} + /// Returns true if `largeUint64` has been explicitly set. + var hasLargeUint64: Bool {_storage._largeUint64 != nil} + /// Clears the value of `largeUint64`. Subsequent reads from it will return its default value. + mutating func clearLargeUint64() {_uniqueStorage()._largeUint64 = nil} - fileprivate var _subGroup: ProtobufUnittest_TestIsInitialized.SubMessage.SubGroup? = nil + var smallInt32: Int32 { + get {_storage._smallInt32 ?? -2147483647} + set {_uniqueStorage()._smallInt32 = newValue} } + /// Returns true if `smallInt32` has been explicitly set. + var hasSmallInt32: Bool {_storage._smallInt32 != nil} + /// Clears the value of `smallInt32`. Subsequent reads from it will return its default value. + mutating func clearSmallInt32() {_uniqueStorage()._smallInt32 = nil} - init() {} - - fileprivate var _subMessage: ProtobufUnittest_TestIsInitialized.SubMessage? = nil -} + var smallInt64: Int64 { + get {_storage._smallInt64 ?? -9223372036854775807} + set {_uniqueStorage()._smallInt64 = newValue} + } + /// Returns true if `smallInt64` has been explicitly set. + var hasSmallInt64: Bool {_storage._smallInt64 != nil} + /// Clears the value of `smallInt64`. Subsequent reads from it will return its default value. + mutating func clearSmallInt64() {_uniqueStorage()._smallInt64 = nil} -/// Test that groups have disjoint field numbers from their siblings and -/// parents. This is NOT possible in proto1; only google.protobuf. When attempting -/// to compile with proto1, this will emit an error; so we only include it -/// in protobuf_unittest_proto. -struct ProtobufUnittest_TestDupFieldNumber { - // 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 reallySmallInt32: Int32 { + get {_storage._reallySmallInt32 ?? -2147483648} + set {_uniqueStorage()._reallySmallInt32 = newValue} + } + /// Returns true if `reallySmallInt32` has been explicitly set. + var hasReallySmallInt32: Bool {_storage._reallySmallInt32 != nil} + /// Clears the value of `reallySmallInt32`. Subsequent reads from it will return its default value. + mutating func clearReallySmallInt32() {_uniqueStorage()._reallySmallInt32 = nil} - /// NO_PROTO1 - var a: Int32 { - get {return _a ?? 0} - set {_a = newValue} + var reallySmallInt64: Int64 { + get {_storage._reallySmallInt64 ?? -9223372036854775808} + set {_uniqueStorage()._reallySmallInt64 = newValue} } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} + /// Returns true if `reallySmallInt64` has been explicitly set. + var hasReallySmallInt64: Bool {_storage._reallySmallInt64 != nil} + /// Clears the value of `reallySmallInt64`. Subsequent reads from it will return its default value. + mutating func clearReallySmallInt64() {_uniqueStorage()._reallySmallInt64 = nil} - var foo: ProtobufUnittest_TestDupFieldNumber.Foo { - get {return _foo ?? ProtobufUnittest_TestDupFieldNumber.Foo()} - set {_foo = newValue} + /// The default value here is UTF-8 for "\u1234". (We could also just type + /// the UTF-8 text directly into this text file rather than escape it, but + /// lots of people use editors that would be confused by this.) + var utf8String: String { + get {_storage._utf8String ?? "ሴ"} + set {_uniqueStorage()._utf8String = newValue} } - /// Returns true if `foo` has been explicitly set. - var hasFoo: Bool {return self._foo != nil} - /// Clears the value of `foo`. Subsequent reads from it will return its default value. - mutating func clearFoo() {self._foo = nil} + /// Returns true if `utf8String` has been explicitly set. + var hasUtf8String: Bool {_storage._utf8String != nil} + /// Clears the value of `utf8String`. Subsequent reads from it will return its default value. + mutating func clearUtf8String() {_uniqueStorage()._utf8String = nil} - var bar: ProtobufUnittest_TestDupFieldNumber.Bar { - get {return _bar ?? ProtobufUnittest_TestDupFieldNumber.Bar()} - set {_bar = newValue} + /// Tests for single-precision floating-point values. + var zeroFloat: Float { + get {_storage._zeroFloat ?? 0} + set {_uniqueStorage()._zeroFloat = newValue} } - /// Returns true if `bar` has been explicitly set. - var hasBar: Bool {return self._bar != nil} - /// Clears the value of `bar`. Subsequent reads from it will return its default value. - mutating func clearBar() {self._bar = nil} + /// Returns true if `zeroFloat` has been explicitly set. + var hasZeroFloat: Bool {_storage._zeroFloat != nil} + /// Clears the value of `zeroFloat`. Subsequent reads from it will return its default value. + mutating func clearZeroFloat() {_uniqueStorage()._zeroFloat = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var oneFloat: Float { + get {_storage._oneFloat ?? 1} + set {_uniqueStorage()._oneFloat = newValue} + } + /// Returns true if `oneFloat` has been explicitly set. + var hasOneFloat: Bool {_storage._oneFloat != nil} + /// Clears the value of `oneFloat`. Subsequent reads from it will return its default value. + mutating func clearOneFloat() {_uniqueStorage()._oneFloat = nil} - struct Foo { - // 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 smallFloat: Float { + get {_storage._smallFloat ?? 1.5} + set {_uniqueStorage()._smallFloat = newValue} + } + /// Returns true if `smallFloat` has been explicitly set. + var hasSmallFloat: Bool {_storage._smallFloat != nil} + /// Clears the value of `smallFloat`. Subsequent reads from it will return its default value. + mutating func clearSmallFloat() {_uniqueStorage()._smallFloat = nil} - var a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} + var negativeOneFloat: Float { + get {_storage._negativeOneFloat ?? -1} + set {_uniqueStorage()._negativeOneFloat = newValue} + } + /// Returns true if `negativeOneFloat` has been explicitly set. + var hasNegativeOneFloat: Bool {_storage._negativeOneFloat != nil} + /// Clears the value of `negativeOneFloat`. Subsequent reads from it will return its default value. + mutating func clearNegativeOneFloat() {_uniqueStorage()._negativeOneFloat = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var negativeFloat: Float { + get {_storage._negativeFloat ?? -1.5} + set {_uniqueStorage()._negativeFloat = newValue} + } + /// Returns true if `negativeFloat` has been explicitly set. + var hasNegativeFloat: Bool {_storage._negativeFloat != nil} + /// Clears the value of `negativeFloat`. Subsequent reads from it will return its default value. + mutating func clearNegativeFloat() {_uniqueStorage()._negativeFloat = nil} - init() {} + /// Using exponents + var largeFloat: Float { + get {_storage._largeFloat ?? 2e+08} + set {_uniqueStorage()._largeFloat = newValue} + } + /// Returns true if `largeFloat` has been explicitly set. + var hasLargeFloat: Bool {_storage._largeFloat != nil} + /// Clears the value of `largeFloat`. Subsequent reads from it will return its default value. + mutating func clearLargeFloat() {_uniqueStorage()._largeFloat = nil} - fileprivate var _a: Int32? = nil + var smallNegativeFloat: Float { + get {_storage._smallNegativeFloat ?? -8e-28} + set {_uniqueStorage()._smallNegativeFloat = newValue} } + /// Returns true if `smallNegativeFloat` has been explicitly set. + var hasSmallNegativeFloat: Bool {_storage._smallNegativeFloat != nil} + /// Clears the value of `smallNegativeFloat`. Subsequent reads from it will return its default value. + mutating func clearSmallNegativeFloat() {_uniqueStorage()._smallNegativeFloat = nil} - struct Bar { - // 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. + /// Text for nonfinite floating-point values. + var infDouble: Double { + get {_storage._infDouble ?? Double.infinity} + set {_uniqueStorage()._infDouble = newValue} + } + /// Returns true if `infDouble` has been explicitly set. + var hasInfDouble: Bool {_storage._infDouble != nil} + /// Clears the value of `infDouble`. Subsequent reads from it will return its default value. + mutating func clearInfDouble() {_uniqueStorage()._infDouble = nil} - var a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} + var negInfDouble: Double { + get {_storage._negInfDouble ?? -Double.infinity} + set {_uniqueStorage()._negInfDouble = newValue} + } + /// Returns true if `negInfDouble` has been explicitly set. + var hasNegInfDouble: Bool {_storage._negInfDouble != nil} + /// Clears the value of `negInfDouble`. Subsequent reads from it will return its default value. + mutating func clearNegInfDouble() {_uniqueStorage()._negInfDouble = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var nanDouble: Double { + get {_storage._nanDouble ?? Double.nan} + set {_uniqueStorage()._nanDouble = newValue} + } + /// Returns true if `nanDouble` has been explicitly set. + var hasNanDouble: Bool {_storage._nanDouble != nil} + /// Clears the value of `nanDouble`. Subsequent reads from it will return its default value. + mutating func clearNanDouble() {_uniqueStorage()._nanDouble = nil} - init() {} + var infFloat: Float { + get {_storage._infFloat ?? Float.infinity} + set {_uniqueStorage()._infFloat = newValue} + } + /// Returns true if `infFloat` has been explicitly set. + var hasInfFloat: Bool {_storage._infFloat != nil} + /// Clears the value of `infFloat`. Subsequent reads from it will return its default value. + mutating func clearInfFloat() {_uniqueStorage()._infFloat = nil} - fileprivate var _a: Int32? = nil + var negInfFloat: Float { + get {_storage._negInfFloat ?? -Float.infinity} + set {_uniqueStorage()._negInfFloat = newValue} } + /// Returns true if `negInfFloat` has been explicitly set. + var hasNegInfFloat: Bool {_storage._negInfFloat != nil} + /// Clears the value of `negInfFloat`. Subsequent reads from it will return its default value. + mutating func clearNegInfFloat() {_uniqueStorage()._negInfFloat = nil} - init() {} + var nanFloat: Float { + get {_storage._nanFloat ?? Float.nan} + set {_uniqueStorage()._nanFloat = newValue} + } + /// Returns true if `nanFloat` has been explicitly set. + var hasNanFloat: Bool {_storage._nanFloat != nil} + /// Clears the value of `nanFloat`. Subsequent reads from it will return its default value. + mutating func clearNanFloat() {_uniqueStorage()._nanFloat = nil} - fileprivate var _a: Int32? = nil - fileprivate var _foo: ProtobufUnittest_TestDupFieldNumber.Foo? = nil - fileprivate var _bar: ProtobufUnittest_TestDupFieldNumber.Bar? = nil -} + /// Tests for C++ trigraphs. + /// Trigraphs should be escaped in C++ generated files, but they should not be + /// escaped for other languages. + /// Note that in .proto file, "\?" is a valid way to escape ? in string + /// literals. + var cppTrigraph: String { + get {_storage._cppTrigraph ?? "? ? ?? ?? ??? ??/ ??-"} + set {_uniqueStorage()._cppTrigraph = newValue} + } + /// Returns true if `cppTrigraph` has been explicitly set. + var hasCppTrigraph: Bool {_storage._cppTrigraph != nil} + /// Clears the value of `cppTrigraph`. Subsequent reads from it will return its default value. + mutating func clearCppTrigraph() {_uniqueStorage()._cppTrigraph = nil} -/// Additional messages for testing lazy fields. -struct ProtobufUnittest_TestEagerMessage { - // 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. + /// String defaults containing the character '\000' + var stringWithZero: String { + get {_storage._stringWithZero ?? "hel\0lo"} + set {_uniqueStorage()._stringWithZero = newValue} + } + /// Returns true if `stringWithZero` has been explicitly set. + var hasStringWithZero: Bool {_storage._stringWithZero != nil} + /// Clears the value of `stringWithZero`. Subsequent reads from it will return its default value. + mutating func clearStringWithZero() {_uniqueStorage()._stringWithZero = nil} - var subMessage: ProtobufUnittest_TestAllTypes { - get {return _subMessage ?? ProtobufUnittest_TestAllTypes()} - set {_subMessage = newValue} + var bytesWithZero: Data { + get {_storage._bytesWithZero ?? Data([119, 111, 114, 0, 108, 100])} + set {_uniqueStorage()._bytesWithZero = newValue} + } + /// Returns true if `bytesWithZero` has been explicitly set. + var hasBytesWithZero: Bool {_storage._bytesWithZero != nil} + /// Clears the value of `bytesWithZero`. Subsequent reads from it will return its default value. + mutating func clearBytesWithZero() {_uniqueStorage()._bytesWithZero = nil} + + var replacementString: String { + get {_storage._replacementString ?? "${unknown}"} + set {_uniqueStorage()._replacementString = newValue} } - /// Returns true if `subMessage` has been explicitly set. - var hasSubMessage: Bool {return self._subMessage != nil} - /// Clears the value of `subMessage`. Subsequent reads from it will return its default value. - mutating func clearSubMessage() {self._subMessage = nil} + /// Returns true if `replacementString` has been explicitly set. + var hasReplacementString: Bool {_storage._replacementString != nil} + /// Clears the value of `replacementString`. Subsequent reads from it will return its default value. + mutating func clearReplacementString() {_uniqueStorage()._replacementString = nil} var unknownFields = SwiftProtobuf.UnknownStorage() init() {} - fileprivate var _subMessage: ProtobufUnittest_TestAllTypes? = nil + fileprivate var _storage = _StorageClass.defaultInstance } -struct ProtobufUnittest_TestLazyMessage { +/// Test oneofs. +struct SwiftProtoTesting_TestOneof: Sendable { // 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 subMessage: ProtobufUnittest_TestAllTypes { - get {return _subMessage ?? ProtobufUnittest_TestAllTypes()} - set {_subMessage = newValue} - } - /// Returns true if `subMessage` has been explicitly set. - var hasSubMessage: Bool {return self._subMessage != nil} - /// Clears the value of `subMessage`. Subsequent reads from it will return its default value. - mutating func clearSubMessage() {self._subMessage = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() + var foo: SwiftProtoTesting_TestOneof.OneOf_Foo? = nil - init() {} + var fooInt: Int32 { + get { + if case .fooInt(let v)? = foo {return v} + return 0 + } + set {foo = .fooInt(newValue)} + } - fileprivate var _subMessage: ProtobufUnittest_TestAllTypes? = nil -} + var fooString: String { + get { + if case .fooString(let v)? = foo {return v} + return String() + } + set {foo = .fooString(newValue)} + } -/// Needed for a Python test. -struct ProtobufUnittest_TestNestedMessageHasBits { - // 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 fooMessage: SwiftProtoTesting_TestAllTypes { + get { + if case .fooMessage(let v)? = foo {return v} + return SwiftProtoTesting_TestAllTypes() + } + set {foo = .fooMessage(newValue)} + } - var optionalNestedMessage: ProtobufUnittest_TestNestedMessageHasBits.NestedMessage { - get {return _optionalNestedMessage ?? ProtobufUnittest_TestNestedMessageHasBits.NestedMessage()} - set {_optionalNestedMessage = newValue} + var fooGroup: SwiftProtoTesting_TestOneof.FooGroup { + get { + if case .fooGroup(let v)? = foo {return v} + return SwiftProtoTesting_TestOneof.FooGroup() + } + set {foo = .fooGroup(newValue)} } - /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return self._optionalNestedMessage != nil} - /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalNestedMessage() {self._optionalNestedMessage = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - struct NestedMessage { + enum OneOf_Foo: Equatable, Sendable { + case fooInt(Int32) + case fooString(String) + case fooMessage(SwiftProtoTesting_TestAllTypes) + case fooGroup(SwiftProtoTesting_TestOneof.FooGroup) + + } + + struct FooGroup: Sendable { // 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 nestedmessageRepeatedInt32: [Int32] = [] + var a: Int32 { + get {_a ?? 0} + set {_a = newValue} + } + /// Returns true if `a` has been explicitly set. + var hasA: Bool {self._a != nil} + /// Clears the value of `a`. Subsequent reads from it will return its default value. + mutating func clearA() {self._a = nil} - var nestedmessageRepeatedForeignmessage: [ProtobufUnittest_ForeignMessage] = [] + var b: String { + get {_b ?? String()} + set {_b = newValue} + } + /// Returns true if `b` has been explicitly set. + var hasB: Bool {self._b != nil} + /// Clears the value of `b`. Subsequent reads from it will return its default value. + mutating func clearB() {self._b = nil} var unknownFields = SwiftProtobuf.UnknownStorage() init() {} + + fileprivate var _a: Int32? = nil + fileprivate var _b: String? = nil } init() {} - - fileprivate var _optionalNestedMessage: ProtobufUnittest_TestNestedMessageHasBits.NestedMessage? = nil } -/// Test message with CamelCase field names. This violates Protocol Buffer -/// standard style. -struct ProtobufUnittest_TestCamelCaseFieldNames { +struct SwiftProtoTesting_TestRequiredOneof: Sendable { // 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 primitiveField: Int32 { - get {return _primitiveField ?? 0} - set {_primitiveField = newValue} - } - /// Returns true if `primitiveField` has been explicitly set. - var hasPrimitiveField: Bool {return self._primitiveField != nil} - /// Clears the value of `primitiveField`. Subsequent reads from it will return its default value. - mutating func clearPrimitiveField() {self._primitiveField = nil} + var foo: SwiftProtoTesting_TestRequiredOneof.OneOf_Foo? = nil - var stringField: String { - get {return _stringField ?? String()} - set {_stringField = newValue} + var fooInt: Int32 { + get { + if case .fooInt(let v)? = foo {return v} + return 0 + } + set {foo = .fooInt(newValue)} } - /// Returns true if `stringField` has been explicitly set. - var hasStringField: Bool {return self._stringField != nil} - /// Clears the value of `stringField`. Subsequent reads from it will return its default value. - mutating func clearStringField() {self._stringField = nil} - var enumField: ProtobufUnittest_ForeignEnum { - get {return _enumField ?? .foreignFoo} - set {_enumField = newValue} + var fooString: String { + get { + if case .fooString(let v)? = foo {return v} + return String() + } + set {foo = .fooString(newValue)} } - /// Returns true if `enumField` has been explicitly set. - var hasEnumField: Bool {return self._enumField != nil} - /// Clears the value of `enumField`. Subsequent reads from it will return its default value. - mutating func clearEnumField() {self._enumField = nil} - var messageField: ProtobufUnittest_ForeignMessage { - get {return _messageField ?? ProtobufUnittest_ForeignMessage()} - set {_messageField = newValue} + var fooMessage: SwiftProtoTesting_TestRequiredOneof.NestedMessage { + get { + if case .fooMessage(let v)? = foo {return v} + return SwiftProtoTesting_TestRequiredOneof.NestedMessage() + } + set {foo = .fooMessage(newValue)} } - /// Returns true if `messageField` has been explicitly set. - var hasMessageField: Bool {return self._messageField != nil} - /// Clears the value of `messageField`. Subsequent reads from it will return its default value. - mutating func clearMessageField() {self._messageField = nil} - var stringPieceField: String { - get {return _stringPieceField ?? String()} - set {_stringPieceField = newValue} - } - /// Returns true if `stringPieceField` has been explicitly set. - var hasStringPieceField: Bool {return self._stringPieceField != nil} - /// Clears the value of `stringPieceField`. Subsequent reads from it will return its default value. - mutating func clearStringPieceField() {self._stringPieceField = nil} + var unknownFields = SwiftProtobuf.UnknownStorage() - var cordField: String { - get {return _cordField ?? String()} - set {_cordField = newValue} - } - /// Returns true if `cordField` has been explicitly set. - var hasCordField: Bool {return self._cordField != nil} - /// Clears the value of `cordField`. Subsequent reads from it will return its default value. - mutating func clearCordField() {self._cordField = nil} + enum OneOf_Foo: Equatable, Sendable { + case fooInt(Int32) + case fooString(String) + case fooMessage(SwiftProtoTesting_TestRequiredOneof.NestedMessage) - var repeatedPrimitiveField: [Int32] = [] + fileprivate var isInitialized: Bool { + guard case .fooMessage(let v) = self else {return true} + return v.isInitialized + } - var repeatedStringField: [String] = [] + } - var repeatedEnumField: [ProtobufUnittest_ForeignEnum] = [] + struct NestedMessage: Sendable { + // 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 repeatedMessageField: [ProtobufUnittest_ForeignMessage] = [] + var requiredDouble: Double { + get {_requiredDouble ?? 0} + set {_requiredDouble = newValue} + } + /// Returns true if `requiredDouble` has been explicitly set. + var hasRequiredDouble: Bool {self._requiredDouble != nil} + /// Clears the value of `requiredDouble`. Subsequent reads from it will return its default value. + mutating func clearRequiredDouble() {self._requiredDouble = nil} - var repeatedStringPieceField: [String] = [] + var unknownFields = SwiftProtobuf.UnknownStorage() - var repeatedCordField: [String] = [] + init() {} - var unknownFields = SwiftProtobuf.UnknownStorage() + fileprivate var _requiredDouble: Double? = nil + } init() {} - - fileprivate var _primitiveField: Int32? = nil - fileprivate var _stringField: String? = nil - fileprivate var _enumField: ProtobufUnittest_ForeignEnum? = nil - fileprivate var _messageField: ProtobufUnittest_ForeignMessage? = nil - fileprivate var _stringPieceField: String? = nil - fileprivate var _cordField: String? = nil } -/// We list fields out of order, to ensure that we're using field number and not -/// field index to determine serialization order. -struct ProtobufUnittest_TestFieldOrderings: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_TestPackedTypes: Sendable { // 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 myString: String { - get {return _myString ?? String()} - set {_myString = newValue} - } - /// Returns true if `myString` has been explicitly set. - var hasMyString: Bool {return self._myString != nil} - /// Clears the value of `myString`. Subsequent reads from it will return its default value. - mutating func clearMyString() {self._myString = nil} + var packedInt32: [Int32] = [] - var myInt: Int64 { - get {return _myInt ?? 0} - set {_myInt = newValue} - } - /// Returns true if `myInt` has been explicitly set. - var hasMyInt: Bool {return self._myInt != nil} - /// Clears the value of `myInt`. Subsequent reads from it will return its default value. - mutating func clearMyInt() {self._myInt = nil} + var packedInt64: [Int64] = [] - var myFloat: Float { - get {return _myFloat ?? 0} - set {_myFloat = newValue} - } - /// Returns true if `myFloat` has been explicitly set. - var hasMyFloat: Bool {return self._myFloat != nil} - /// Clears the value of `myFloat`. Subsequent reads from it will return its default value. - mutating func clearMyFloat() {self._myFloat = nil} + var packedUint32: [UInt32] = [] - var optionalNestedMessage: ProtobufUnittest_TestFieldOrderings.NestedMessage { - get {return _optionalNestedMessage ?? ProtobufUnittest_TestFieldOrderings.NestedMessage()} - set {_optionalNestedMessage = newValue} - } - /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return self._optionalNestedMessage != nil} - /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalNestedMessage() {self._optionalNestedMessage = nil} + var packedUint64: [UInt64] = [] - var unknownFields = SwiftProtobuf.UnknownStorage() + var packedSint32: [Int32] = [] - struct NestedMessage { - // 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 packedSint64: [Int64] = [] - var oo: Int64 { - get {return _oo ?? 0} - set {_oo = newValue} - } - /// Returns true if `oo` has been explicitly set. - var hasOo: Bool {return self._oo != nil} - /// Clears the value of `oo`. Subsequent reads from it will return its default value. - mutating func clearOo() {self._oo = nil} + var packedFixed32: [UInt32] = [] - /// The field name "b" fails to compile in proto1 because it conflicts with - /// a local variable named "b" in one of the generated methods. Doh. - /// This file needs to compile in proto1 to test backwards-compatibility. - var bb: Int32 { - get {return _bb ?? 0} - set {_bb = newValue} - } - /// Returns true if `bb` has been explicitly set. - var hasBb: Bool {return self._bb != nil} - /// Clears the value of `bb`. Subsequent reads from it will return its default value. - mutating func clearBb() {self._bb = nil} + var packedFixed64: [UInt64] = [] - var unknownFields = SwiftProtobuf.UnknownStorage() + var packedSfixed32: [Int32] = [] - init() {} + var packedSfixed64: [Int64] = [] - fileprivate var _oo: Int64? = nil - fileprivate var _bb: Int32? = nil - } + var packedFloat: [Float] = [] - init() {} + var packedDouble: [Double] = [] - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _myString: String? = nil - fileprivate var _myInt: Int64? = nil - fileprivate var _myFloat: Float? = nil - fileprivate var _optionalNestedMessage: ProtobufUnittest_TestFieldOrderings.NestedMessage? = nil + var packedBool: [Bool] = [] + + var packedEnum: [SwiftProtoTesting_ForeignEnum] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} } -struct ProtobufUnittest_TestExtensionOrderings1 { +/// A message with the same fields as TestPackedTypes, but without packing. Used +/// to test packed <-> unpacked wire compatibility. +struct SwiftProtoTesting_TestUnpackedTypes: Sendable { // 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 myString: String { - get {return _myString ?? String()} - set {_myString = newValue} - } - /// Returns true if `myString` has been explicitly set. - var hasMyString: Bool {return self._myString != nil} - /// Clears the value of `myString`. Subsequent reads from it will return its default value. - mutating func clearMyString() {self._myString = nil} + var unpackedInt32: [Int32] = [] + + var unpackedInt64: [Int64] = [] + + var unpackedUint32: [UInt32] = [] + + var unpackedUint64: [UInt64] = [] + + var unpackedSint32: [Int32] = [] + + var unpackedSint64: [Int64] = [] + + var unpackedFixed32: [UInt32] = [] + + var unpackedFixed64: [UInt64] = [] + + var unpackedSfixed32: [Int32] = [] + + var unpackedSfixed64: [Int64] = [] + + var unpackedFloat: [Float] = [] + + var unpackedDouble: [Double] = [] + + var unpackedBool: [Bool] = [] + + var unpackedEnum: [SwiftProtoTesting_ForeignEnum] = [] var unknownFields = SwiftProtobuf.UnknownStorage() init() {} +} - fileprivate var _myString: String? = nil +struct SwiftProtoTesting_TestPackedExtensions: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() } -struct ProtobufUnittest_TestExtensionOrderings2 { +/// Test that if an optional or required message/group field appears multiple +/// times in the input, they need to be merged. +struct SwiftProtoTesting_TestParsingMerge: SwiftProtobuf.ExtensibleMessage, Sendable { // 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 myString: String { - get {return _myString ?? String()} - set {_myString = newValue} + var requiredAllTypes: SwiftProtoTesting_TestAllTypes { + get {_requiredAllTypes ?? SwiftProtoTesting_TestAllTypes()} + set {_requiredAllTypes = newValue} } - /// Returns true if `myString` has been explicitly set. - var hasMyString: Bool {return self._myString != nil} - /// Clears the value of `myString`. Subsequent reads from it will return its default value. - mutating func clearMyString() {self._myString = nil} + /// Returns true if `requiredAllTypes` has been explicitly set. + var hasRequiredAllTypes: Bool {self._requiredAllTypes != nil} + /// Clears the value of `requiredAllTypes`. Subsequent reads from it will return its default value. + mutating func clearRequiredAllTypes() {self._requiredAllTypes = nil} + + var optionalAllTypes: SwiftProtoTesting_TestAllTypes { + get {_optionalAllTypes ?? SwiftProtoTesting_TestAllTypes()} + set {_optionalAllTypes = newValue} + } + /// Returns true if `optionalAllTypes` has been explicitly set. + var hasOptionalAllTypes: Bool {self._optionalAllTypes != nil} + /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} + + var repeatedAllTypes: [SwiftProtoTesting_TestAllTypes] = [] + + var optionalGroup: SwiftProtoTesting_TestParsingMerge.OptionalGroup { + get {_optionalGroup ?? SwiftProtoTesting_TestParsingMerge.OptionalGroup()} + set {_optionalGroup = newValue} + } + /// Returns true if `optionalGroup` has been explicitly set. + var hasOptionalGroup: Bool {self._optionalGroup != nil} + /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroup() {self._optionalGroup = nil} + + var repeatedGroup: [SwiftProtoTesting_TestParsingMerge.RepeatedGroup] = [] var unknownFields = SwiftProtobuf.UnknownStorage() - struct TestExtensionOrderings3 { + /// RepeatedFieldsGenerator defines matching field types as TestParsingMerge, + /// except that all fields are repeated. In the tests, we will serialize the + /// RepeatedFieldsGenerator to bytes, and parse the bytes to TestParsingMerge. + /// Repeated fields in RepeatedFieldsGenerator are expected to be merged into + /// the corresponding required/optional fields in TestParsingMerge. + struct RepeatedFieldsGenerator: Sendable { + // 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: [SwiftProtoTesting_TestAllTypes] = [] + + var field2: [SwiftProtoTesting_TestAllTypes] = [] + + var field3: [SwiftProtoTesting_TestAllTypes] = [] + + var group1: [SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group1] = [] + + var group2: [SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group2] = [] + + var ext1: [SwiftProtoTesting_TestAllTypes] = [] + + var ext2: [SwiftProtoTesting_TestAllTypes] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct Group1: Sendable { + // 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: SwiftProtoTesting_TestAllTypes { + get {_field1 ?? SwiftProtoTesting_TestAllTypes()} + set {_field1 = newValue} + } + /// Returns true if `field1` has been explicitly set. + var hasField1: Bool {self._field1 != nil} + /// Clears the value of `field1`. Subsequent reads from it will return its default value. + mutating func clearField1() {self._field1 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _field1: SwiftProtoTesting_TestAllTypes? = nil + } + + struct Group2: Sendable { + // 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: SwiftProtoTesting_TestAllTypes { + get {_field1 ?? SwiftProtoTesting_TestAllTypes()} + set {_field1 = newValue} + } + /// Returns true if `field1` has been explicitly set. + var hasField1: Bool {self._field1 != nil} + /// Clears the value of `field1`. Subsequent reads from it will return its default value. + mutating func clearField1() {self._field1 = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _field1: SwiftProtoTesting_TestAllTypes? = nil + } + + init() {} + } + + struct OptionalGroup: Sendable { + // 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 optionalGroupAllTypes: SwiftProtoTesting_TestAllTypes { + get {_optionalGroupAllTypes ?? SwiftProtoTesting_TestAllTypes()} + set {_optionalGroupAllTypes = newValue} + } + /// Returns true if `optionalGroupAllTypes` has been explicitly set. + var hasOptionalGroupAllTypes: Bool {self._optionalGroupAllTypes != nil} + /// Clears the value of `optionalGroupAllTypes`. Subsequent reads from it will return its default value. + mutating func clearOptionalGroupAllTypes() {self._optionalGroupAllTypes = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _optionalGroupAllTypes: SwiftProtoTesting_TestAllTypes? = nil + } + + struct RepeatedGroup: Sendable { // 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 myString: String { - get {return _myString ?? String()} - set {_myString = newValue} + var repeatedGroupAllTypes: SwiftProtoTesting_TestAllTypes { + get {_repeatedGroupAllTypes ?? SwiftProtoTesting_TestAllTypes()} + set {_repeatedGroupAllTypes = newValue} } - /// Returns true if `myString` has been explicitly set. - var hasMyString: Bool {return self._myString != nil} - /// Clears the value of `myString`. Subsequent reads from it will return its default value. - mutating func clearMyString() {self._myString = nil} + /// Returns true if `repeatedGroupAllTypes` has been explicitly set. + var hasRepeatedGroupAllTypes: Bool {self._repeatedGroupAllTypes != nil} + /// Clears the value of `repeatedGroupAllTypes`. Subsequent reads from it will return its default value. + mutating func clearRepeatedGroupAllTypes() {self._repeatedGroupAllTypes = nil} var unknownFields = SwiftProtobuf.UnknownStorage() init() {} - fileprivate var _myString: String? = nil + fileprivate var _repeatedGroupAllTypes: SwiftProtoTesting_TestAllTypes? = nil } init() {} - fileprivate var _myString: String? = nil + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _requiredAllTypes: SwiftProtoTesting_TestAllTypes? = nil + fileprivate var _optionalAllTypes: SwiftProtoTesting_TestAllTypes? = nil + fileprivate var _optionalGroup: SwiftProtoTesting_TestParsingMerge.OptionalGroup? = nil } -struct ProtobufUnittest_TestExtremeDefaultValues { - // 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. +// MARK: - Extension support defined in unittest.proto. - var escapedBytes: Data { - get {return _storage._escapedBytes ?? Data([0, 1, 7, 8, 12, 10, 13, 9, 11, 92, 39, 34, 254])} - set {_uniqueStorage()._escapedBytes = newValue} - } - /// Returns true if `escapedBytes` has been explicitly set. - var hasEscapedBytes: Bool {return _storage._escapedBytes != nil} - /// Clears the value of `escapedBytes`. Subsequent reads from it will return its default value. - mutating func clearEscapedBytes() {_uniqueStorage()._escapedBytes = nil} +// MARK: - Extension Properties - var largeUint32: UInt32 { - get {return _storage._largeUint32 ?? 4294967295} - set {_uniqueStorage()._largeUint32 = newValue} +// Swift Extensions on the extended 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 SwiftProtoTesting_TestAllExtensions { + + /// Singular + var SwiftProtoTesting_optionalInt32Extension: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_int32_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_int32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_int32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalInt32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_int32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_int32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalInt32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_int32_extension) } - /// Returns true if `largeUint32` has been explicitly set. - var hasLargeUint32: Bool {return _storage._largeUint32 != nil} - /// Clears the value of `largeUint32`. Subsequent reads from it will return its default value. - mutating func clearLargeUint32() {_uniqueStorage()._largeUint32 = nil} - var largeUint64: UInt64 { - get {return _storage._largeUint64 ?? 18446744073709551615} - set {_uniqueStorage()._largeUint64 = newValue} + var SwiftProtoTesting_optionalInt64Extension: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_int64_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_int64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_int64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalInt64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_int64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_int64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalInt64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_int64_extension) } - /// Returns true if `largeUint64` has been explicitly set. - var hasLargeUint64: Bool {return _storage._largeUint64 != nil} - /// Clears the value of `largeUint64`. Subsequent reads from it will return its default value. - mutating func clearLargeUint64() {_uniqueStorage()._largeUint64 = nil} - var smallInt32: Int32 { - get {return _storage._smallInt32 ?? -2147483647} - set {_uniqueStorage()._smallInt32 = newValue} + var SwiftProtoTesting_optionalUint32Extension: UInt32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_uint32_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_uint32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_uint32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalUint32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_uint32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_uint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalUint32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_uint32_extension) } - /// Returns true if `smallInt32` has been explicitly set. - var hasSmallInt32: Bool {return _storage._smallInt32 != nil} - /// Clears the value of `smallInt32`. Subsequent reads from it will return its default value. - mutating func clearSmallInt32() {_uniqueStorage()._smallInt32 = nil} - var smallInt64: Int64 { - get {return _storage._smallInt64 ?? -9223372036854775807} - set {_uniqueStorage()._smallInt64 = newValue} + var SwiftProtoTesting_optionalUint64Extension: UInt64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_uint64_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_uint64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_uint64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalUint64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_uint64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_uint64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalUint64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_uint64_extension) } - /// Returns true if `smallInt64` has been explicitly set. - var hasSmallInt64: Bool {return _storage._smallInt64 != nil} - /// Clears the value of `smallInt64`. Subsequent reads from it will return its default value. - mutating func clearSmallInt64() {_uniqueStorage()._smallInt64 = nil} - var reallySmallInt32: Int32 { - get {return _storage._reallySmallInt32 ?? -2147483648} - set {_uniqueStorage()._reallySmallInt32 = newValue} + var SwiftProtoTesting_optionalSint32Extension: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sint32_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sint32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_sint32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalSint32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sint32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_sint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalSint32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sint32_extension) } - /// Returns true if `reallySmallInt32` has been explicitly set. - var hasReallySmallInt32: Bool {return _storage._reallySmallInt32 != nil} - /// Clears the value of `reallySmallInt32`. Subsequent reads from it will return its default value. - mutating func clearReallySmallInt32() {_uniqueStorage()._reallySmallInt32 = nil} - var reallySmallInt64: Int64 { - get {return _storage._reallySmallInt64 ?? -9223372036854775808} - set {_uniqueStorage()._reallySmallInt64 = newValue} + var SwiftProtoTesting_optionalSint64Extension: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sint64_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sint64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_sint64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalSint64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sint64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_sint64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalSint64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sint64_extension) } - /// Returns true if `reallySmallInt64` has been explicitly set. - var hasReallySmallInt64: Bool {return _storage._reallySmallInt64 != nil} - /// Clears the value of `reallySmallInt64`. Subsequent reads from it will return its default value. - mutating func clearReallySmallInt64() {_uniqueStorage()._reallySmallInt64 = nil} - /// The default value here is UTF-8 for "\u1234". (We could also just type - /// the UTF-8 text directly into this text file rather than escape it, but - /// lots of people use editors that would be confused by this.) - var utf8String: String { - get {return _storage._utf8String ?? "ሴ"} - set {_uniqueStorage()._utf8String = newValue} + var SwiftProtoTesting_optionalFixed32Extension: UInt32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_fixed32_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_fixed32_extension, value: newValue)} } - /// Returns true if `utf8String` has been explicitly set. - var hasUtf8String: Bool {return _storage._utf8String != nil} - /// Clears the value of `utf8String`. Subsequent reads from it will return its default value. - mutating func clearUtf8String() {_uniqueStorage()._utf8String = nil} - - /// Tests for single-precision floating-point values. - var zeroFloat: Float { - get {return _storage._zeroFloat ?? 0} - set {_uniqueStorage()._zeroFloat = newValue} + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_fixed32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalFixed32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_fixed32_extension) } - /// Returns true if `zeroFloat` has been explicitly set. - var hasZeroFloat: Bool {return _storage._zeroFloat != nil} - /// Clears the value of `zeroFloat`. Subsequent reads from it will return its default value. - mutating func clearZeroFloat() {_uniqueStorage()._zeroFloat = nil} - - var oneFloat: Float { - get {return _storage._oneFloat ?? 1} - set {_uniqueStorage()._oneFloat = newValue} + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_fixed32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalFixed32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_fixed32_extension) } - /// Returns true if `oneFloat` has been explicitly set. - var hasOneFloat: Bool {return _storage._oneFloat != nil} - /// Clears the value of `oneFloat`. Subsequent reads from it will return its default value. - mutating func clearOneFloat() {_uniqueStorage()._oneFloat = nil} - var smallFloat: Float { - get {return _storage._smallFloat ?? 1.5} - set {_uniqueStorage()._smallFloat = newValue} + var SwiftProtoTesting_optionalFixed64Extension: UInt64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_fixed64_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_fixed64_extension, value: newValue)} } - /// Returns true if `smallFloat` has been explicitly set. - var hasSmallFloat: Bool {return _storage._smallFloat != nil} - /// Clears the value of `smallFloat`. Subsequent reads from it will return its default value. - mutating func clearSmallFloat() {_uniqueStorage()._smallFloat = nil} - - var negativeOneFloat: Float { - get {return _storage._negativeOneFloat ?? -1} - set {_uniqueStorage()._negativeOneFloat = newValue} + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_fixed64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalFixed64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_fixed64_extension) } - /// Returns true if `negativeOneFloat` has been explicitly set. - var hasNegativeOneFloat: Bool {return _storage._negativeOneFloat != nil} - /// Clears the value of `negativeOneFloat`. Subsequent reads from it will return its default value. - mutating func clearNegativeOneFloat() {_uniqueStorage()._negativeOneFloat = nil} - - var negativeFloat: Float { - get {return _storage._negativeFloat ?? -1.5} - set {_uniqueStorage()._negativeFloat = newValue} + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_fixed64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalFixed64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_fixed64_extension) } - /// Returns true if `negativeFloat` has been explicitly set. - var hasNegativeFloat: Bool {return _storage._negativeFloat != nil} - /// Clears the value of `negativeFloat`. Subsequent reads from it will return its default value. - mutating func clearNegativeFloat() {_uniqueStorage()._negativeFloat = nil} - /// Using exponents - var largeFloat: Float { - get {return _storage._largeFloat ?? 2e+08} - set {_uniqueStorage()._largeFloat = newValue} + var SwiftProtoTesting_optionalSfixed32Extension: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sfixed32_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sfixed32_extension, value: newValue)} } - /// Returns true if `largeFloat` has been explicitly set. - var hasLargeFloat: Bool {return _storage._largeFloat != nil} - /// Clears the value of `largeFloat`. Subsequent reads from it will return its default value. - mutating func clearLargeFloat() {_uniqueStorage()._largeFloat = nil} - - var smallNegativeFloat: Float { - get {return _storage._smallNegativeFloat ?? -8e-28} - set {_uniqueStorage()._smallNegativeFloat = newValue} + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_sfixed32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalSfixed32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sfixed32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_sfixed32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalSfixed32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sfixed32_extension) } - /// Returns true if `smallNegativeFloat` has been explicitly set. - var hasSmallNegativeFloat: Bool {return _storage._smallNegativeFloat != nil} - /// Clears the value of `smallNegativeFloat`. Subsequent reads from it will return its default value. - mutating func clearSmallNegativeFloat() {_uniqueStorage()._smallNegativeFloat = nil} - /// Text for nonfinite floating-point values. - var infDouble: Double { - get {return _storage._infDouble ?? Double.infinity} - set {_uniqueStorage()._infDouble = newValue} + var SwiftProtoTesting_optionalSfixed64Extension: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sfixed64_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sfixed64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_sfixed64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalSfixed64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sfixed64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_sfixed64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalSfixed64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_sfixed64_extension) } - /// Returns true if `infDouble` has been explicitly set. - var hasInfDouble: Bool {return _storage._infDouble != nil} - /// Clears the value of `infDouble`. Subsequent reads from it will return its default value. - mutating func clearInfDouble() {_uniqueStorage()._infDouble = nil} - var negInfDouble: Double { - get {return _storage._negInfDouble ?? -Double.infinity} - set {_uniqueStorage()._negInfDouble = newValue} + var SwiftProtoTesting_optionalFloatExtension: Float { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_float_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_float_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_float_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalFloatExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_float_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_float_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalFloatExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_float_extension) } - /// Returns true if `negInfDouble` has been explicitly set. - var hasNegInfDouble: Bool {return _storage._negInfDouble != nil} - /// Clears the value of `negInfDouble`. Subsequent reads from it will return its default value. - mutating func clearNegInfDouble() {_uniqueStorage()._negInfDouble = nil} - var nanDouble: Double { - get {return _storage._nanDouble ?? Double.nan} - set {_uniqueStorage()._nanDouble = newValue} + var SwiftProtoTesting_optionalDoubleExtension: Double { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_double_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_double_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_double_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalDoubleExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_double_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_double_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalDoubleExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_double_extension) } - /// Returns true if `nanDouble` has been explicitly set. - var hasNanDouble: Bool {return _storage._nanDouble != nil} - /// Clears the value of `nanDouble`. Subsequent reads from it will return its default value. - mutating func clearNanDouble() {_uniqueStorage()._nanDouble = nil} - var infFloat: Float { - get {return _storage._infFloat ?? Float.infinity} - set {_uniqueStorage()._infFloat = newValue} + var SwiftProtoTesting_optionalBoolExtension: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_bool_extension) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_bool_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_bool_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalBoolExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_bool_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_bool_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalBoolExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_bool_extension) } - /// Returns true if `infFloat` has been explicitly set. - var hasInfFloat: Bool {return _storage._infFloat != nil} - /// Clears the value of `infFloat`. Subsequent reads from it will return its default value. - mutating func clearInfFloat() {_uniqueStorage()._infFloat = nil} - var negInfFloat: Float { - get {return _storage._negInfFloat ?? -Float.infinity} - set {_uniqueStorage()._negInfFloat = newValue} + var SwiftProtoTesting_optionalStringExtension: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_string_extension) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_string_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_string_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalStringExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_string_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_string_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalStringExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_string_extension) } - /// Returns true if `negInfFloat` has been explicitly set. - var hasNegInfFloat: Bool {return _storage._negInfFloat != nil} - /// Clears the value of `negInfFloat`. Subsequent reads from it will return its default value. - mutating func clearNegInfFloat() {_uniqueStorage()._negInfFloat = nil} - var nanFloat: Float { - get {return _storage._nanFloat ?? Float.nan} - set {_uniqueStorage()._nanFloat = newValue} + var SwiftProtoTesting_optionalBytesExtension: Data { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_bytes_extension) ?? Data()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_bytes_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_bytes_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalBytesExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_bytes_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_bytes_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalBytesExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_bytes_extension) } - /// Returns true if `nanFloat` has been explicitly set. - var hasNanFloat: Bool {return _storage._nanFloat != nil} - /// Clears the value of `nanFloat`. Subsequent reads from it will return its default value. - mutating func clearNanFloat() {_uniqueStorage()._nanFloat = nil} - /// Tests for C++ trigraphs. - /// Trigraphs should be escaped in C++ generated files, but they should not be - /// escaped for other languages. - /// Note that in .proto file, "\?" is a valid way to escape ? in string - /// literals. - var cppTrigraph: String { - get {return _storage._cppTrigraph ?? "? ? ?? ?? ??? ??/ ??-"} - set {_uniqueStorage()._cppTrigraph = newValue} + var SwiftProtoTesting_optionalGroupExtension: SwiftProtoTesting_OptionalGroup_extension { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_OptionalGroup_extension) ?? SwiftProtoTesting_OptionalGroup_extension()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_OptionalGroup_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_OptionalGroup_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalGroupExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_OptionalGroup_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_OptionalGroup_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalGroupExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_OptionalGroup_extension) } - /// Returns true if `cppTrigraph` has been explicitly set. - var hasCppTrigraph: Bool {return _storage._cppTrigraph != nil} - /// Clears the value of `cppTrigraph`. Subsequent reads from it will return its default value. - mutating func clearCppTrigraph() {_uniqueStorage()._cppTrigraph = nil} - /// String defaults containing the character '\000' - var stringWithZero: String { - get {return _storage._stringWithZero ?? "hel\0lo"} - set {_uniqueStorage()._stringWithZero = newValue} + var SwiftProtoTesting_optionalNestedMessageExtension: SwiftProtoTesting_TestAllTypes.NestedMessage { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_nested_message_extension) ?? SwiftProtoTesting_TestAllTypes.NestedMessage()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_nested_message_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_nested_message_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalNestedMessageExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_nested_message_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_nested_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalNestedMessageExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_nested_message_extension) } - /// Returns true if `stringWithZero` has been explicitly set. - var hasStringWithZero: Bool {return _storage._stringWithZero != nil} - /// Clears the value of `stringWithZero`. Subsequent reads from it will return its default value. - mutating func clearStringWithZero() {_uniqueStorage()._stringWithZero = nil} - var bytesWithZero: Data { - get {return _storage._bytesWithZero ?? Data([119, 111, 114, 0, 108, 100])} - set {_uniqueStorage()._bytesWithZero = newValue} + var SwiftProtoTesting_optionalForeignMessageExtension: SwiftProtoTesting_ForeignMessage { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_foreign_message_extension) ?? SwiftProtoTesting_ForeignMessage()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_foreign_message_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_foreign_message_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalForeignMessageExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_foreign_message_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_foreign_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalForeignMessageExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_foreign_message_extension) } - /// Returns true if `bytesWithZero` has been explicitly set. - var hasBytesWithZero: Bool {return _storage._bytesWithZero != nil} - /// Clears the value of `bytesWithZero`. Subsequent reads from it will return its default value. - mutating func clearBytesWithZero() {_uniqueStorage()._bytesWithZero = nil} - var stringPieceWithZero: String { - get {return _storage._stringPieceWithZero ?? "ab\0c"} - set {_uniqueStorage()._stringPieceWithZero = newValue} + var SwiftProtoTesting_optionalImportMessageExtension: SwiftProtoTesting_Import_ImportMessage { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_import_message_extension) ?? SwiftProtoTesting_Import_ImportMessage()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_import_message_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_import_message_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalImportMessageExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_import_message_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_import_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalImportMessageExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_import_message_extension) } - /// Returns true if `stringPieceWithZero` has been explicitly set. - var hasStringPieceWithZero: Bool {return _storage._stringPieceWithZero != nil} - /// Clears the value of `stringPieceWithZero`. Subsequent reads from it will return its default value. - mutating func clearStringPieceWithZero() {_uniqueStorage()._stringPieceWithZero = nil} - var cordWithZero: String { - get {return _storage._cordWithZero ?? "12\03"} - set {_uniqueStorage()._cordWithZero = newValue} + var SwiftProtoTesting_optionalNestedEnumExtension: SwiftProtoTesting_TestAllTypes.NestedEnum { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_nested_enum_extension) ?? .foo} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_nested_enum_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_nested_enum_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalNestedEnumExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_nested_enum_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_nested_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalNestedEnumExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_nested_enum_extension) } - /// Returns true if `cordWithZero` has been explicitly set. - var hasCordWithZero: Bool {return _storage._cordWithZero != nil} - /// Clears the value of `cordWithZero`. Subsequent reads from it will return its default value. - mutating func clearCordWithZero() {_uniqueStorage()._cordWithZero = nil} - var replacementString: String { - get {return _storage._replacementString ?? "${unknown}"} - set {_uniqueStorage()._replacementString = newValue} + var SwiftProtoTesting_optionalForeignEnumExtension: SwiftProtoTesting_ForeignEnum { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_foreign_enum_extension) ?? .foreignFoo} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_foreign_enum_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_foreign_enum_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalForeignEnumExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_foreign_enum_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_foreign_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalForeignEnumExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_foreign_enum_extension) } - /// Returns true if `replacementString` has been explicitly set. - var hasReplacementString: Bool {return _storage._replacementString != nil} - /// Clears the value of `replacementString`. Subsequent reads from it will return its default value. - mutating func clearReplacementString() {_uniqueStorage()._replacementString = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var SwiftProtoTesting_optionalImportEnumExtension: SwiftProtoTesting_Import_ImportEnum { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_import_enum_extension) ?? .importFoo} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_import_enum_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_import_enum_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalImportEnumExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_import_enum_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_import_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalImportEnumExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_import_enum_extension) + } - init() {} + var SwiftProtoTesting_optionalPublicImportMessageExtension: SwiftProtoTesting_Import_PublicImportMessage { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_optional_public_import_message_extension) ?? SwiftProtoTesting_Import_PublicImportMessage()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_optional_public_import_message_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_optional_public_import_message_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_optionalPublicImportMessageExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_optional_public_import_message_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_optional_public_import_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_optionalPublicImportMessageExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_optional_public_import_message_extension) + } - fileprivate var _storage = _StorageClass.defaultInstance -} + /// Repeated + var SwiftProtoTesting_repeatedInt32Extension: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_int32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_int32_extension, value: newValue)} + } -struct ProtobufUnittest_SparseEnumMessage { - // 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 SwiftProtoTesting_repeatedInt64Extension: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_int64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_int64_extension, value: newValue)} + } - var sparseEnum: ProtobufUnittest_TestSparseEnum { - get {return _sparseEnum ?? .sparseA} - set {_sparseEnum = newValue} + var SwiftProtoTesting_repeatedUint32Extension: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_uint32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_uint32_extension, value: newValue)} } - /// Returns true if `sparseEnum` has been explicitly set. - var hasSparseEnum: Bool {return self._sparseEnum != nil} - /// Clears the value of `sparseEnum`. Subsequent reads from it will return its default value. - mutating func clearSparseEnum() {self._sparseEnum = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var SwiftProtoTesting_repeatedUint64Extension: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_uint64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_uint64_extension, value: newValue)} + } - init() {} + var SwiftProtoTesting_repeatedSint32Extension: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_sint32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_sint32_extension, value: newValue)} + } - fileprivate var _sparseEnum: ProtobufUnittest_TestSparseEnum? = nil -} + var SwiftProtoTesting_repeatedSint64Extension: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_sint64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_sint64_extension, value: newValue)} + } -/// Test String and Bytes: string is for valid UTF-8 strings -struct ProtobufUnittest_OneString { - // 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 SwiftProtoTesting_repeatedFixed32Extension: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_fixed32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_fixed32_extension, value: newValue)} + } - var data: String { - get {return _data ?? String()} - set {_data = newValue} + var SwiftProtoTesting_repeatedFixed64Extension: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_fixed64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_fixed64_extension, value: newValue)} } - /// Returns true if `data` has been explicitly set. - var hasData: Bool {return self._data != nil} - /// Clears the value of `data`. Subsequent reads from it will return its default value. - mutating func clearData() {self._data = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var SwiftProtoTesting_repeatedSfixed32Extension: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_sfixed32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_sfixed32_extension, value: newValue)} + } - init() {} + var SwiftProtoTesting_repeatedSfixed64Extension: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_sfixed64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_sfixed64_extension, value: newValue)} + } - fileprivate var _data: String? = nil -} + var SwiftProtoTesting_repeatedFloatExtension: [Float] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_float_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_float_extension, value: newValue)} + } -struct ProtobufUnittest_MoreString { - // 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 SwiftProtoTesting_repeatedDoubleExtension: [Double] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_double_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_double_extension, value: newValue)} + } - var data: [String] = [] + var SwiftProtoTesting_repeatedBoolExtension: [Bool] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_bool_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_bool_extension, value: newValue)} + } - var unknownFields = SwiftProtobuf.UnknownStorage() + var SwiftProtoTesting_repeatedStringExtension: [String] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_string_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_string_extension, value: newValue)} + } - init() {} -} + var SwiftProtoTesting_repeatedBytesExtension: [Data] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_bytes_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_bytes_extension, value: newValue)} + } -struct ProtobufUnittest_OneBytes { - // 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 SwiftProtoTesting_repeatedGroupExtension: [SwiftProtoTesting_RepeatedGroup_extension] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_RepeatedGroup_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_RepeatedGroup_extension, value: newValue)} + } - var data: Data { - get {return _data ?? Data()} - set {_data = newValue} + var SwiftProtoTesting_repeatedNestedMessageExtension: [SwiftProtoTesting_TestAllTypes.NestedMessage] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_nested_message_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_nested_message_extension, value: newValue)} } - /// Returns true if `data` has been explicitly set. - var hasData: Bool {return self._data != nil} - /// Clears the value of `data`. Subsequent reads from it will return its default value. - mutating func clearData() {self._data = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var SwiftProtoTesting_repeatedForeignMessageExtension: [SwiftProtoTesting_ForeignMessage] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_foreign_message_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_foreign_message_extension, value: newValue)} + } - init() {} + var SwiftProtoTesting_repeatedImportMessageExtension: [SwiftProtoTesting_Import_ImportMessage] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_import_message_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_import_message_extension, value: newValue)} + } - fileprivate var _data: Data? = nil -} + var SwiftProtoTesting_repeatedNestedEnumExtension: [SwiftProtoTesting_TestAllTypes.NestedEnum] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_nested_enum_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_nested_enum_extension, value: newValue)} + } -struct ProtobufUnittest_MoreBytes { - // 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 SwiftProtoTesting_repeatedForeignEnumExtension: [SwiftProtoTesting_ForeignEnum] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_foreign_enum_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_foreign_enum_extension, value: newValue)} + } - var data: [Data] = [] + var SwiftProtoTesting_repeatedImportEnumExtension: [SwiftProtoTesting_Import_ImportEnum] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_import_enum_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_repeated_import_enum_extension, value: newValue)} + } - var unknownFields = SwiftProtobuf.UnknownStorage() + /// Singular with defaults + var SwiftProtoTesting_defaultInt32Extension: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_int32_extension) ?? 41} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_int32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_int32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultInt32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_int32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_int32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultInt32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_int32_extension) + } - init() {} -} + var SwiftProtoTesting_defaultInt64Extension: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_int64_extension) ?? 42} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_int64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_int64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultInt64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_int64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_int64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultInt64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_int64_extension) + } -/// Test int32, uint32, int64, uint64, and bool are all compatible -struct ProtobufUnittest_Int32Message { - // 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 SwiftProtoTesting_defaultUint32Extension: UInt32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_uint32_extension) ?? 43} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_uint32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_uint32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultUint32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_uint32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_uint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultUint32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_uint32_extension) + } - var data: Int32 { - get {return _data ?? 0} - set {_data = newValue} + var SwiftProtoTesting_defaultUint64Extension: UInt64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_uint64_extension) ?? 44} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_uint64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_uint64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultUint64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_uint64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_uint64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultUint64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_uint64_extension) } - /// Returns true if `data` has been explicitly set. - var hasData: Bool {return self._data != nil} - /// Clears the value of `data`. Subsequent reads from it will return its default value. - mutating func clearData() {self._data = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var SwiftProtoTesting_defaultSint32Extension: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_sint32_extension) ?? -45} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_sint32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_sint32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultSint32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_sint32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_sint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultSint32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_sint32_extension) + } - init() {} - - fileprivate var _data: Int32? = nil -} + var SwiftProtoTesting_defaultSint64Extension: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_sint64_extension) ?? 46} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_sint64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_sint64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultSint64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_sint64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_sint64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultSint64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_sint64_extension) + } -struct ProtobufUnittest_Uint32Message { - // 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 SwiftProtoTesting_defaultFixed32Extension: UInt32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_fixed32_extension) ?? 47} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_fixed32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_fixed32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultFixed32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_fixed32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_fixed32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultFixed32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_fixed32_extension) + } - var data: UInt32 { - get {return _data ?? 0} - set {_data = newValue} + var SwiftProtoTesting_defaultFixed64Extension: UInt64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_fixed64_extension) ?? 48} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_fixed64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_fixed64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultFixed64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_fixed64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_fixed64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultFixed64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_fixed64_extension) } - /// Returns true if `data` has been explicitly set. - var hasData: Bool {return self._data != nil} - /// Clears the value of `data`. Subsequent reads from it will return its default value. - mutating func clearData() {self._data = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var SwiftProtoTesting_defaultSfixed32Extension: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_sfixed32_extension) ?? 49} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_sfixed32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_sfixed32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultSfixed32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_sfixed32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_sfixed32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultSfixed32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_sfixed32_extension) + } - init() {} + var SwiftProtoTesting_defaultSfixed64Extension: Int64 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_sfixed64_extension) ?? -50} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_sfixed64_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_sfixed64_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultSfixed64Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_sfixed64_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_sfixed64_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultSfixed64Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_sfixed64_extension) + } - fileprivate var _data: UInt32? = nil -} + var SwiftProtoTesting_defaultFloatExtension: Float { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_float_extension) ?? 51.5} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_float_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_float_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultFloatExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_float_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_float_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultFloatExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_float_extension) + } -struct ProtobufUnittest_Int64Message { - // 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 SwiftProtoTesting_defaultDoubleExtension: Double { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_double_extension) ?? 52000} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_double_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_double_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultDoubleExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_double_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_double_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultDoubleExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_double_extension) + } - var data: Int64 { - get {return _data ?? 0} - set {_data = newValue} + var SwiftProtoTesting_defaultBoolExtension: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_bool_extension) ?? true} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_bool_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_bool_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultBoolExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_bool_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_bool_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultBoolExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_bool_extension) } - /// Returns true if `data` has been explicitly set. - var hasData: Bool {return self._data != nil} - /// Clears the value of `data`. Subsequent reads from it will return its default value. - mutating func clearData() {self._data = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + var SwiftProtoTesting_defaultStringExtension: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_string_extension) ?? "hello"} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_string_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_string_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultStringExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_string_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_string_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultStringExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_string_extension) + } - init() {} + var SwiftProtoTesting_defaultBytesExtension: Data { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_bytes_extension) ?? Data([119, 111, 114, 108, 100])} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_bytes_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_bytes_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultBytesExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_bytes_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_bytes_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultBytesExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_bytes_extension) + } - fileprivate var _data: Int64? = nil -} + var SwiftProtoTesting_defaultNestedEnumExtension: SwiftProtoTesting_TestAllTypes.NestedEnum { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_nested_enum_extension) ?? .bar} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_nested_enum_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_nested_enum_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultNestedEnumExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_nested_enum_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_nested_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultNestedEnumExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_nested_enum_extension) + } -struct ProtobufUnittest_Uint64Message { - // 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 SwiftProtoTesting_defaultForeignEnumExtension: SwiftProtoTesting_ForeignEnum { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_foreign_enum_extension) ?? .foreignBar} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_foreign_enum_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_foreign_enum_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultForeignEnumExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_foreign_enum_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_foreign_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultForeignEnumExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_foreign_enum_extension) + } - var data: UInt64 { - get {return _data ?? 0} - set {_data = newValue} + var SwiftProtoTesting_defaultImportEnumExtension: SwiftProtoTesting_Import_ImportEnum { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_default_import_enum_extension) ?? .importBar} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_default_import_enum_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_default_import_enum_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_defaultImportEnumExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_default_import_enum_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_default_import_enum_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_defaultImportEnumExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_default_import_enum_extension) } - /// Returns true if `data` has been explicitly set. - var hasData: Bool {return self._data != nil} - /// Clears the value of `data`. Subsequent reads from it will return its default value. - mutating func clearData() {self._data = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + /// For oneof test + var SwiftProtoTesting_oneofUint32Extension: UInt32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_uint32_extension) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_uint32_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_oneof_uint32_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_oneofUint32Extension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_uint32_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_oneof_uint32_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_oneofUint32Extension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_uint32_extension) + } - init() {} + var SwiftProtoTesting_oneofNestedMessageExtension: SwiftProtoTesting_TestAllTypes.NestedMessage { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_nested_message_extension) ?? SwiftProtoTesting_TestAllTypes.NestedMessage()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_nested_message_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_oneof_nested_message_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_oneofNestedMessageExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_nested_message_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_oneof_nested_message_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_oneofNestedMessageExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_nested_message_extension) + } - fileprivate var _data: UInt64? = nil -} + var SwiftProtoTesting_oneofStringExtension: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_string_extension) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_string_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_oneof_string_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_oneofStringExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_string_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_oneof_string_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_oneofStringExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_string_extension) + } -struct ProtobufUnittest_BoolMessage { - // 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 SwiftProtoTesting_oneofBytesExtension: Data { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_bytes_extension) ?? Data()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_bytes_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_oneof_bytes_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_oneofBytesExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_bytes_extension) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_oneof_bytes_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_oneofBytesExtension() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_oneof_bytes_extension) + } - var data: Bool { - get {return _data ?? false} - set {_data = newValue} + /// Check for bug where string extensions declared in tested scope did not + /// compile. + var SwiftProtoTesting_TestNestedExtension_test: String { + get {return getExtensionValue(ext: SwiftProtoTesting_TestNestedExtension.Extensions.test) ?? "test"} + set {setExtensionValue(ext: SwiftProtoTesting_TestNestedExtension.Extensions.test, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_TestNestedExtension.Extensions.test` + /// has been explicitly set. + var hasSwiftProtoTesting_TestNestedExtension_test: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_TestNestedExtension.Extensions.test) + } + /// Clears the value of extension `SwiftProtoTesting_TestNestedExtension.Extensions.test`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_TestNestedExtension_test() { + clearExtensionValue(ext: SwiftProtoTesting_TestNestedExtension.Extensions.test) } - /// Returns true if `data` has been explicitly set. - var hasData: Bool {return self._data != nil} - /// Clears the value of `data`. Subsequent reads from it will return its default value. - mutating func clearData() {self._data = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() + /// Used to test if generated extension name is correct when there are + /// underscores. + var SwiftProtoTesting_TestNestedExtension_nestedStringExtension: String { + get {return getExtensionValue(ext: SwiftProtoTesting_TestNestedExtension.Extensions.nested_string_extension) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_TestNestedExtension.Extensions.nested_string_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_TestNestedExtension.Extensions.nested_string_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_TestNestedExtension_nestedStringExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_TestNestedExtension.Extensions.nested_string_extension) + } + /// Clears the value of extension `SwiftProtoTesting_TestNestedExtension.Extensions.nested_string_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_TestNestedExtension_nestedStringExtension() { + clearExtensionValue(ext: SwiftProtoTesting_TestNestedExtension.Extensions.nested_string_extension) + } - init() {} + var SwiftProtoTesting_TestRequired_single: SwiftProtoTesting_TestRequired { + get {return getExtensionValue(ext: SwiftProtoTesting_TestRequired.Extensions.single) ?? SwiftProtoTesting_TestRequired()} + set {setExtensionValue(ext: SwiftProtoTesting_TestRequired.Extensions.single, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_TestRequired.Extensions.single` + /// has been explicitly set. + var hasSwiftProtoTesting_TestRequired_single: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_TestRequired.Extensions.single) + } + /// Clears the value of extension `SwiftProtoTesting_TestRequired.Extensions.single`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_TestRequired_single() { + clearExtensionValue(ext: SwiftProtoTesting_TestRequired.Extensions.single) + } - fileprivate var _data: Bool? = nil + var SwiftProtoTesting_TestRequired_multi: [SwiftProtoTesting_TestRequired] { + get {return getExtensionValue(ext: SwiftProtoTesting_TestRequired.Extensions.multi) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_TestRequired.Extensions.multi, value: newValue)} + } } -/// Test oneofs. -struct ProtobufUnittest_TestOneof { - // 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. +extension SwiftProtoTesting_TestFieldOrderings { - var foo: ProtobufUnittest_TestOneof.OneOf_Foo? = nil + var SwiftProtoTesting_myExtensionString: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_my_extension_string) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_my_extension_string, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_my_extension_string` + /// has been explicitly set. + var hasSwiftProtoTesting_myExtensionString: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_my_extension_string) + } + /// Clears the value of extension `SwiftProtoTesting_Extensions_my_extension_string`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_myExtensionString() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_my_extension_string) + } - var fooInt: Int32 { - get { - if case .fooInt(let v)? = foo {return v} - return 0 - } - set {foo = .fooInt(newValue)} + var SwiftProtoTesting_myExtensionInt: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_my_extension_int) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_my_extension_int, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Extensions_my_extension_int` + /// has been explicitly set. + var hasSwiftProtoTesting_myExtensionInt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_my_extension_int) } + /// Clears the value of extension `SwiftProtoTesting_Extensions_my_extension_int`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_myExtensionInt() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_my_extension_int) + } +} - var fooString: String { - get { - if case .fooString(let v)? = foo {return v} - return String() - } - set {foo = .fooString(newValue)} +extension SwiftProtoTesting_TestPackedExtensions { + + var SwiftProtoTesting_packedInt32Extension: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_int32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_int32_extension, value: newValue)} } - var fooMessage: ProtobufUnittest_TestAllTypes { - get { - if case .fooMessage(let v)? = foo {return v} - return ProtobufUnittest_TestAllTypes() - } - set {foo = .fooMessage(newValue)} + var SwiftProtoTesting_packedInt64Extension: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_int64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_int64_extension, value: newValue)} } - var fooGroup: ProtobufUnittest_TestOneof.FooGroup { - get { - if case .fooGroup(let v)? = foo {return v} - return ProtobufUnittest_TestOneof.FooGroup() - } - set {foo = .fooGroup(newValue)} + var SwiftProtoTesting_packedUint32Extension: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_uint32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_uint32_extension, value: newValue)} } - var unknownFields = SwiftProtobuf.UnknownStorage() + var SwiftProtoTesting_packedUint64Extension: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_uint64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_uint64_extension, value: newValue)} + } - enum OneOf_Foo: Equatable { - case fooInt(Int32) - case fooString(String) - case fooMessage(ProtobufUnittest_TestAllTypes) - case fooGroup(ProtobufUnittest_TestOneof.FooGroup) + var SwiftProtoTesting_packedSint32Extension: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_sint32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_sint32_extension, value: newValue)} + } - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestOneof.OneOf_Foo, rhs: ProtobufUnittest_TestOneof.OneOf_Foo) -> 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 (.fooInt, .fooInt): return { - guard case .fooInt(let l) = lhs, case .fooInt(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooString, .fooString): return { - guard case .fooString(let l) = lhs, case .fooString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooMessage, .fooMessage): return { - guard case .fooMessage(let l) = lhs, case .fooMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooGroup, .fooGroup): return { - guard case .fooGroup(let l) = lhs, case .fooGroup(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif + var SwiftProtoTesting_packedSint64Extension: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_sint64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_sint64_extension, value: newValue)} } - struct FooGroup { - // 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 SwiftProtoTesting_packedFixed32Extension: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_fixed32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_fixed32_extension, value: newValue)} + } - var a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} + var SwiftProtoTesting_packedFixed64Extension: [UInt64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_fixed64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_fixed64_extension, value: newValue)} + } - var b: String { - get {return _b ?? String()} - set {_b = newValue} - } - /// Returns true if `b` has been explicitly set. - var hasB: Bool {return self._b != nil} - /// Clears the value of `b`. Subsequent reads from it will return its default value. - mutating func clearB() {self._b = nil} + var SwiftProtoTesting_packedSfixed32Extension: [Int32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_sfixed32_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_sfixed32_extension, value: newValue)} + } - var unknownFields = SwiftProtobuf.UnknownStorage() + var SwiftProtoTesting_packedSfixed64Extension: [Int64] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_sfixed64_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_sfixed64_extension, value: newValue)} + } - init() {} + var SwiftProtoTesting_packedFloatExtension: [Float] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_float_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_float_extension, value: newValue)} + } - fileprivate var _a: Int32? = nil - fileprivate var _b: String? = nil + var SwiftProtoTesting_packedDoubleExtension: [Double] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_double_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_double_extension, value: newValue)} } - init() {} + var SwiftProtoTesting_packedBoolExtension: [Bool] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_bool_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_bool_extension, value: newValue)} + } + + var SwiftProtoTesting_packedEnumExtension: [SwiftProtoTesting_ForeignEnum] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_packed_enum_extension) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_packed_enum_extension, value: newValue)} + } } -struct ProtobufUnittest_TestOneofBackwardsCompatible { - // 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. +extension SwiftProtoTesting_TestParsingMerge { - var fooInt: Int32 { - get {return _fooInt ?? 0} - set {_fooInt = newValue} + var SwiftProtoTesting_TestParsingMerge_optionalExt: SwiftProtoTesting_TestAllTypes { + get {return getExtensionValue(ext: SwiftProtoTesting_TestParsingMerge.Extensions.optional_ext) ?? SwiftProtoTesting_TestAllTypes()} + set {setExtensionValue(ext: SwiftProtoTesting_TestParsingMerge.Extensions.optional_ext, value: newValue)} } - /// Returns true if `fooInt` has been explicitly set. - var hasFooInt: Bool {return self._fooInt != nil} - /// Clears the value of `fooInt`. Subsequent reads from it will return its default value. - mutating func clearFooInt() {self._fooInt = nil} - - var fooString: String { - get {return _fooString ?? String()} - set {_fooString = newValue} + /// Returns true if extension `SwiftProtoTesting_TestParsingMerge.Extensions.optional_ext` + /// has been explicitly set. + var hasSwiftProtoTesting_TestParsingMerge_optionalExt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_TestParsingMerge.Extensions.optional_ext) } - /// Returns true if `fooString` has been explicitly set. - var hasFooString: Bool {return self._fooString != nil} - /// Clears the value of `fooString`. Subsequent reads from it will return its default value. - mutating func clearFooString() {self._fooString = nil} - - var fooMessage: ProtobufUnittest_TestAllTypes { - get {return _fooMessage ?? ProtobufUnittest_TestAllTypes()} - set {_fooMessage = newValue} + /// Clears the value of extension `SwiftProtoTesting_TestParsingMerge.Extensions.optional_ext`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_TestParsingMerge_optionalExt() { + clearExtensionValue(ext: SwiftProtoTesting_TestParsingMerge.Extensions.optional_ext) } - /// Returns true if `fooMessage` has been explicitly set. - var hasFooMessage: Bool {return self._fooMessage != nil} - /// Clears the value of `fooMessage`. Subsequent reads from it will return its default value. - mutating func clearFooMessage() {self._fooMessage = nil} - var fooGroup: ProtobufUnittest_TestOneofBackwardsCompatible.FooGroup { - get {return _fooGroup ?? ProtobufUnittest_TestOneofBackwardsCompatible.FooGroup()} - set {_fooGroup = newValue} + var SwiftProtoTesting_TestParsingMerge_repeatedExt: [SwiftProtoTesting_TestAllTypes] { + get {return getExtensionValue(ext: SwiftProtoTesting_TestParsingMerge.Extensions.repeated_ext) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_TestParsingMerge.Extensions.repeated_ext, value: newValue)} } - /// Returns true if `fooGroup` has been explicitly set. - var hasFooGroup: Bool {return self._fooGroup != nil} - /// Clears the value of `fooGroup`. Subsequent reads from it will return its default value. - mutating func clearFooGroup() {self._fooGroup = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() +} - struct FooGroup { - // 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. +// MARK: - File's ExtensionMap: SwiftProtoTesting_Unittest_Extensions - var a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} +/// 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 SwiftProtoTesting_Unittest_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Extensions_optional_int32_extension, + SwiftProtoTesting_Extensions_optional_int64_extension, + SwiftProtoTesting_Extensions_optional_uint32_extension, + SwiftProtoTesting_Extensions_optional_uint64_extension, + SwiftProtoTesting_Extensions_optional_sint32_extension, + SwiftProtoTesting_Extensions_optional_sint64_extension, + SwiftProtoTesting_Extensions_optional_fixed32_extension, + SwiftProtoTesting_Extensions_optional_fixed64_extension, + SwiftProtoTesting_Extensions_optional_sfixed32_extension, + SwiftProtoTesting_Extensions_optional_sfixed64_extension, + SwiftProtoTesting_Extensions_optional_float_extension, + SwiftProtoTesting_Extensions_optional_double_extension, + SwiftProtoTesting_Extensions_optional_bool_extension, + SwiftProtoTesting_Extensions_optional_string_extension, + SwiftProtoTesting_Extensions_optional_bytes_extension, + SwiftProtoTesting_Extensions_OptionalGroup_extension, + SwiftProtoTesting_Extensions_optional_nested_message_extension, + SwiftProtoTesting_Extensions_optional_foreign_message_extension, + SwiftProtoTesting_Extensions_optional_import_message_extension, + SwiftProtoTesting_Extensions_optional_nested_enum_extension, + SwiftProtoTesting_Extensions_optional_foreign_enum_extension, + SwiftProtoTesting_Extensions_optional_import_enum_extension, + SwiftProtoTesting_Extensions_optional_public_import_message_extension, + SwiftProtoTesting_Extensions_repeated_int32_extension, + SwiftProtoTesting_Extensions_repeated_int64_extension, + SwiftProtoTesting_Extensions_repeated_uint32_extension, + SwiftProtoTesting_Extensions_repeated_uint64_extension, + SwiftProtoTesting_Extensions_repeated_sint32_extension, + SwiftProtoTesting_Extensions_repeated_sint64_extension, + SwiftProtoTesting_Extensions_repeated_fixed32_extension, + SwiftProtoTesting_Extensions_repeated_fixed64_extension, + SwiftProtoTesting_Extensions_repeated_sfixed32_extension, + SwiftProtoTesting_Extensions_repeated_sfixed64_extension, + SwiftProtoTesting_Extensions_repeated_float_extension, + SwiftProtoTesting_Extensions_repeated_double_extension, + SwiftProtoTesting_Extensions_repeated_bool_extension, + SwiftProtoTesting_Extensions_repeated_string_extension, + SwiftProtoTesting_Extensions_repeated_bytes_extension, + SwiftProtoTesting_Extensions_RepeatedGroup_extension, + SwiftProtoTesting_Extensions_repeated_nested_message_extension, + SwiftProtoTesting_Extensions_repeated_foreign_message_extension, + SwiftProtoTesting_Extensions_repeated_import_message_extension, + SwiftProtoTesting_Extensions_repeated_nested_enum_extension, + SwiftProtoTesting_Extensions_repeated_foreign_enum_extension, + SwiftProtoTesting_Extensions_repeated_import_enum_extension, + SwiftProtoTesting_Extensions_default_int32_extension, + SwiftProtoTesting_Extensions_default_int64_extension, + SwiftProtoTesting_Extensions_default_uint32_extension, + SwiftProtoTesting_Extensions_default_uint64_extension, + SwiftProtoTesting_Extensions_default_sint32_extension, + SwiftProtoTesting_Extensions_default_sint64_extension, + SwiftProtoTesting_Extensions_default_fixed32_extension, + SwiftProtoTesting_Extensions_default_fixed64_extension, + SwiftProtoTesting_Extensions_default_sfixed32_extension, + SwiftProtoTesting_Extensions_default_sfixed64_extension, + SwiftProtoTesting_Extensions_default_float_extension, + SwiftProtoTesting_Extensions_default_double_extension, + SwiftProtoTesting_Extensions_default_bool_extension, + SwiftProtoTesting_Extensions_default_string_extension, + SwiftProtoTesting_Extensions_default_bytes_extension, + SwiftProtoTesting_Extensions_default_nested_enum_extension, + SwiftProtoTesting_Extensions_default_foreign_enum_extension, + SwiftProtoTesting_Extensions_default_import_enum_extension, + SwiftProtoTesting_Extensions_oneof_uint32_extension, + SwiftProtoTesting_Extensions_oneof_nested_message_extension, + SwiftProtoTesting_Extensions_oneof_string_extension, + SwiftProtoTesting_Extensions_oneof_bytes_extension, + SwiftProtoTesting_Extensions_my_extension_string, + SwiftProtoTesting_Extensions_my_extension_int, + SwiftProtoTesting_Extensions_packed_int32_extension, + SwiftProtoTesting_Extensions_packed_int64_extension, + SwiftProtoTesting_Extensions_packed_uint32_extension, + SwiftProtoTesting_Extensions_packed_uint64_extension, + SwiftProtoTesting_Extensions_packed_sint32_extension, + SwiftProtoTesting_Extensions_packed_sint64_extension, + SwiftProtoTesting_Extensions_packed_fixed32_extension, + SwiftProtoTesting_Extensions_packed_fixed64_extension, + SwiftProtoTesting_Extensions_packed_sfixed32_extension, + SwiftProtoTesting_Extensions_packed_sfixed64_extension, + SwiftProtoTesting_Extensions_packed_float_extension, + SwiftProtoTesting_Extensions_packed_double_extension, + SwiftProtoTesting_Extensions_packed_bool_extension, + SwiftProtoTesting_Extensions_packed_enum_extension, + SwiftProtoTesting_TestNestedExtension.Extensions.test, + SwiftProtoTesting_TestNestedExtension.Extensions.nested_string_extension, + SwiftProtoTesting_TestRequired.Extensions.single, + SwiftProtoTesting_TestRequired.Extensions.multi, + SwiftProtoTesting_TestParsingMerge.Extensions.optional_ext, + SwiftProtoTesting_TestParsingMerge.Extensions.repeated_ext +] - var b: String { - get {return _b ?? String()} - set {_b = newValue} - } - /// Returns true if `b` has been explicitly set. - var hasB: Bool {return self._b != nil} - /// Clears the value of `b`. Subsequent reads from it will return its default value. - mutating func clearB() {self._b = nil} +// 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. - var unknownFields = SwiftProtobuf.UnknownStorage() +/// Singular +let SwiftProtoTesting_Extensions_optional_int32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 1, + fieldName: "swift_proto_testing.optional_int32_extension" +) - init() {} +let SwiftProtoTesting_Extensions_optional_int64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 2, + fieldName: "swift_proto_testing.optional_int64_extension" +) - fileprivate var _a: Int32? = nil - fileprivate var _b: String? = nil - } +let SwiftProtoTesting_Extensions_optional_uint32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 3, + fieldName: "swift_proto_testing.optional_uint32_extension" +) - init() {} +let SwiftProtoTesting_Extensions_optional_uint64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 4, + fieldName: "swift_proto_testing.optional_uint64_extension" +) - fileprivate var _fooInt: Int32? = nil - fileprivate var _fooString: String? = nil - fileprivate var _fooMessage: ProtobufUnittest_TestAllTypes? = nil - fileprivate var _fooGroup: ProtobufUnittest_TestOneofBackwardsCompatible.FooGroup? = nil -} +let SwiftProtoTesting_Extensions_optional_sint32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 5, + fieldName: "swift_proto_testing.optional_sint32_extension" +) -struct ProtobufUnittest_TestOneof2 { - // 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 foo: ProtobufUnittest_TestOneof2.OneOf_Foo? = nil +let SwiftProtoTesting_Extensions_optional_sint64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 6, + fieldName: "swift_proto_testing.optional_sint64_extension" +) - var fooInt: Int32 { - get { - if case .fooInt(let v)? = foo {return v} - return 0 - } - set {foo = .fooInt(newValue)} - } +let SwiftProtoTesting_Extensions_optional_fixed32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 7, + fieldName: "swift_proto_testing.optional_fixed32_extension" +) - var fooString: String { - get { - if case .fooString(let v)? = foo {return v} - return String() - } - set {foo = .fooString(newValue)} - } +let SwiftProtoTesting_Extensions_optional_fixed64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 8, + fieldName: "swift_proto_testing.optional_fixed64_extension" +) - var fooCord: String { - get { - if case .fooCord(let v)? = foo {return v} - return String() - } - set {foo = .fooCord(newValue)} - } +let SwiftProtoTesting_Extensions_optional_sfixed32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 9, + fieldName: "swift_proto_testing.optional_sfixed32_extension" +) - var fooStringPiece: String { - get { - if case .fooStringPiece(let v)? = foo {return v} - return String() - } - set {foo = .fooStringPiece(newValue)} - } +let SwiftProtoTesting_Extensions_optional_sfixed64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 10, + fieldName: "swift_proto_testing.optional_sfixed64_extension" +) - var fooBytes: Data { - get { - if case .fooBytes(let v)? = foo {return v} - return Data() - } - set {foo = .fooBytes(newValue)} - } +let SwiftProtoTesting_Extensions_optional_float_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 11, + fieldName: "swift_proto_testing.optional_float_extension" +) - var fooEnum: ProtobufUnittest_TestOneof2.NestedEnum { - get { - if case .fooEnum(let v)? = foo {return v} - return .foo - } - set {foo = .fooEnum(newValue)} - } +let SwiftProtoTesting_Extensions_optional_double_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 12, + fieldName: "swift_proto_testing.optional_double_extension" +) - var fooMessage: ProtobufUnittest_TestOneof2.NestedMessage { - get { - if case .fooMessage(let v)? = foo {return v} - return ProtobufUnittest_TestOneof2.NestedMessage() - } - set {foo = .fooMessage(newValue)} - } +let SwiftProtoTesting_Extensions_optional_bool_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 13, + fieldName: "swift_proto_testing.optional_bool_extension" +) - var fooGroup: ProtobufUnittest_TestOneof2.FooGroup { - get { - if case .fooGroup(let v)? = foo {return v} - return ProtobufUnittest_TestOneof2.FooGroup() - } - set {foo = .fooGroup(newValue)} - } +let SwiftProtoTesting_Extensions_optional_string_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 14, + fieldName: "swift_proto_testing.optional_string_extension" +) - var fooLazyMessage: ProtobufUnittest_TestOneof2.NestedMessage { - get { - if case .fooLazyMessage(let v)? = foo {return v} - return ProtobufUnittest_TestOneof2.NestedMessage() - } - set {foo = .fooLazyMessage(newValue)} - } +let SwiftProtoTesting_Extensions_optional_bytes_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 15, + fieldName: "swift_proto_testing.optional_bytes_extension" +) - var bar: ProtobufUnittest_TestOneof2.OneOf_Bar? = nil +let SwiftProtoTesting_Extensions_OptionalGroup_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 16, + fieldName: "swift_proto_testing.optionalgroup_extension" +) - var barInt: Int32 { - get { - if case .barInt(let v)? = bar {return v} - return 5 - } - set {bar = .barInt(newValue)} - } +let SwiftProtoTesting_Extensions_optional_nested_message_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 18, + fieldName: "swift_proto_testing.optional_nested_message_extension" +) - var barString: String { - get { - if case .barString(let v)? = bar {return v} - return "STRING" - } - set {bar = .barString(newValue)} - } +let SwiftProtoTesting_Extensions_optional_foreign_message_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 19, + fieldName: "swift_proto_testing.optional_foreign_message_extension" +) - var barCord: String { - get { - if case .barCord(let v)? = bar {return v} - return "CORD" - } - set {bar = .barCord(newValue)} - } +let SwiftProtoTesting_Extensions_optional_import_message_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 20, + fieldName: "swift_proto_testing.optional_import_message_extension" +) - var barStringPiece: String { - get { - if case .barStringPiece(let v)? = bar {return v} - return "SPIECE" - } - set {bar = .barStringPiece(newValue)} - } +let SwiftProtoTesting_Extensions_optional_nested_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 21, + fieldName: "swift_proto_testing.optional_nested_enum_extension" +) - var barBytes: Data { - get { - if case .barBytes(let v)? = bar {return v} - return Data([66, 89, 84, 69, 83]) - } - set {bar = .barBytes(newValue)} - } +let SwiftProtoTesting_Extensions_optional_foreign_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 22, + fieldName: "swift_proto_testing.optional_foreign_enum_extension" +) - var barEnum: ProtobufUnittest_TestOneof2.NestedEnum { - get { - if case .barEnum(let v)? = bar {return v} - return .bar - } - set {bar = .barEnum(newValue)} - } +let SwiftProtoTesting_Extensions_optional_import_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 23, + fieldName: "swift_proto_testing.optional_import_enum_extension" +) - var barStringWithEmptyDefault: String { - get { - if case .barStringWithEmptyDefault(let v)? = bar {return v} - return String() - } - set {bar = .barStringWithEmptyDefault(newValue)} - } +let SwiftProtoTesting_Extensions_optional_public_import_message_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 26, + fieldName: "swift_proto_testing.optional_public_import_message_extension" +) - var barCordWithEmptyDefault: String { - get { - if case .barCordWithEmptyDefault(let v)? = bar {return v} - return String() - } - set {bar = .barCordWithEmptyDefault(newValue)} - } +/// Repeated +let SwiftProtoTesting_Extensions_repeated_int32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 31, + fieldName: "swift_proto_testing.repeated_int32_extension" +) - var barStringPieceWithEmptyDefault: String { - get { - if case .barStringPieceWithEmptyDefault(let v)? = bar {return v} - return String() - } - set {bar = .barStringPieceWithEmptyDefault(newValue)} - } +let SwiftProtoTesting_Extensions_repeated_int64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 32, + fieldName: "swift_proto_testing.repeated_int64_extension" +) - var barBytesWithEmptyDefault: Data { - get { - if case .barBytesWithEmptyDefault(let v)? = bar {return v} - return Data() - } - set {bar = .barBytesWithEmptyDefault(newValue)} - } +let SwiftProtoTesting_Extensions_repeated_uint32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 33, + fieldName: "swift_proto_testing.repeated_uint32_extension" +) - var bazInt: Int32 { - get {return _bazInt ?? 0} - set {_bazInt = newValue} - } - /// Returns true if `bazInt` has been explicitly set. - var hasBazInt: Bool {return self._bazInt != nil} - /// Clears the value of `bazInt`. Subsequent reads from it will return its default value. - mutating func clearBazInt() {self._bazInt = nil} +let SwiftProtoTesting_Extensions_repeated_uint64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 34, + fieldName: "swift_proto_testing.repeated_uint64_extension" +) - var bazString: String { - get {return _bazString ?? "BAZ"} - set {_bazString = newValue} - } - /// Returns true if `bazString` has been explicitly set. - var hasBazString: Bool {return self._bazString != nil} - /// Clears the value of `bazString`. Subsequent reads from it will return its default value. - mutating func clearBazString() {self._bazString = nil} +let SwiftProtoTesting_Extensions_repeated_sint32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 35, + fieldName: "swift_proto_testing.repeated_sint32_extension" +) - var unknownFields = SwiftProtobuf.UnknownStorage() +let SwiftProtoTesting_Extensions_repeated_sint64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 36, + fieldName: "swift_proto_testing.repeated_sint64_extension" +) - enum OneOf_Foo: Equatable { - case fooInt(Int32) - case fooString(String) - case fooCord(String) - case fooStringPiece(String) - case fooBytes(Data) - case fooEnum(ProtobufUnittest_TestOneof2.NestedEnum) - case fooMessage(ProtobufUnittest_TestOneof2.NestedMessage) - case fooGroup(ProtobufUnittest_TestOneof2.FooGroup) - case fooLazyMessage(ProtobufUnittest_TestOneof2.NestedMessage) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestOneof2.OneOf_Foo, rhs: ProtobufUnittest_TestOneof2.OneOf_Foo) -> 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 (.fooInt, .fooInt): return { - guard case .fooInt(let l) = lhs, case .fooInt(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooString, .fooString): return { - guard case .fooString(let l) = lhs, case .fooString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooCord, .fooCord): return { - guard case .fooCord(let l) = lhs, case .fooCord(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooStringPiece, .fooStringPiece): return { - guard case .fooStringPiece(let l) = lhs, case .fooStringPiece(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooBytes, .fooBytes): return { - guard case .fooBytes(let l) = lhs, case .fooBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooEnum, .fooEnum): return { - guard case .fooEnum(let l) = lhs, case .fooEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooMessage, .fooMessage): return { - guard case .fooMessage(let l) = lhs, case .fooMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooGroup, .fooGroup): return { - guard case .fooGroup(let l) = lhs, case .fooGroup(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooLazyMessage, .fooLazyMessage): return { - guard case .fooLazyMessage(let l) = lhs, case .fooLazyMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif - } - - enum OneOf_Bar: Equatable { - case barInt(Int32) - case barString(String) - case barCord(String) - case barStringPiece(String) - case barBytes(Data) - case barEnum(ProtobufUnittest_TestOneof2.NestedEnum) - case barStringWithEmptyDefault(String) - case barCordWithEmptyDefault(String) - case barStringPieceWithEmptyDefault(String) - case barBytesWithEmptyDefault(Data) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestOneof2.OneOf_Bar, rhs: ProtobufUnittest_TestOneof2.OneOf_Bar) -> 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 (.barInt, .barInt): return { - guard case .barInt(let l) = lhs, case .barInt(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.barString, .barString): return { - guard case .barString(let l) = lhs, case .barString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.barCord, .barCord): return { - guard case .barCord(let l) = lhs, case .barCord(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.barStringPiece, .barStringPiece): return { - guard case .barStringPiece(let l) = lhs, case .barStringPiece(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.barBytes, .barBytes): return { - guard case .barBytes(let l) = lhs, case .barBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.barEnum, .barEnum): return { - guard case .barEnum(let l) = lhs, case .barEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.barStringWithEmptyDefault, .barStringWithEmptyDefault): return { - guard case .barStringWithEmptyDefault(let l) = lhs, case .barStringWithEmptyDefault(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.barCordWithEmptyDefault, .barCordWithEmptyDefault): return { - guard case .barCordWithEmptyDefault(let l) = lhs, case .barCordWithEmptyDefault(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.barStringPieceWithEmptyDefault, .barStringPieceWithEmptyDefault): return { - guard case .barStringPieceWithEmptyDefault(let l) = lhs, case .barStringPieceWithEmptyDefault(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.barBytesWithEmptyDefault, .barBytesWithEmptyDefault): return { - guard case .barBytesWithEmptyDefault(let l) = lhs, case .barBytesWithEmptyDefault(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif - } +let SwiftProtoTesting_Extensions_repeated_fixed32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 37, + fieldName: "swift_proto_testing.repeated_fixed32_extension" +) - enum NestedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 1 - case bar // = 2 - case baz // = 3 +let SwiftProtoTesting_Extensions_repeated_fixed64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 38, + fieldName: "swift_proto_testing.repeated_fixed64_extension" +) - init() { - self = .foo - } +let SwiftProtoTesting_Extensions_repeated_sfixed32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 39, + fieldName: "swift_proto_testing.repeated_sfixed32_extension" +) - init?(rawValue: Int) { - switch rawValue { - case 1: self = .foo - case 2: self = .bar - case 3: self = .baz - default: return nil - } - } +let SwiftProtoTesting_Extensions_repeated_sfixed64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 40, + fieldName: "swift_proto_testing.repeated_sfixed64_extension" +) - var rawValue: Int { - switch self { - case .foo: return 1 - case .bar: return 2 - case .baz: return 3 - } - } +let SwiftProtoTesting_Extensions_repeated_float_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 41, + fieldName: "swift_proto_testing.repeated_float_extension" +) - } +let SwiftProtoTesting_Extensions_repeated_double_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 42, + fieldName: "swift_proto_testing.repeated_double_extension" +) - struct FooGroup { - // 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. +let SwiftProtoTesting_Extensions_repeated_bool_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 43, + fieldName: "swift_proto_testing.repeated_bool_extension" +) - var a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} +let SwiftProtoTesting_Extensions_repeated_string_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 44, + fieldName: "swift_proto_testing.repeated_string_extension" +) - var b: String { - get {return _b ?? String()} - set {_b = newValue} - } - /// Returns true if `b` has been explicitly set. - var hasB: Bool {return self._b != nil} - /// Clears the value of `b`. Subsequent reads from it will return its default value. - mutating func clearB() {self._b = nil} +let SwiftProtoTesting_Extensions_repeated_bytes_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 45, + fieldName: "swift_proto_testing.repeated_bytes_extension" +) - var unknownFields = SwiftProtobuf.UnknownStorage() +let SwiftProtoTesting_Extensions_RepeatedGroup_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 46, + fieldName: "swift_proto_testing.repeatedgroup_extension" +) - init() {} +let SwiftProtoTesting_Extensions_repeated_nested_message_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 48, + fieldName: "swift_proto_testing.repeated_nested_message_extension" +) - fileprivate var _a: Int32? = nil - fileprivate var _b: String? = nil - } +let SwiftProtoTesting_Extensions_repeated_foreign_message_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 49, + fieldName: "swift_proto_testing.repeated_foreign_message_extension" +) - struct NestedMessage { - // 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. +let SwiftProtoTesting_Extensions_repeated_import_message_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 50, + fieldName: "swift_proto_testing.repeated_import_message_extension" +) - var quxInt: Int64 { - get {return _quxInt ?? 0} - set {_quxInt = newValue} - } - /// Returns true if `quxInt` has been explicitly set. - var hasQuxInt: Bool {return self._quxInt != nil} - /// Clears the value of `quxInt`. Subsequent reads from it will return its default value. - mutating func clearQuxInt() {self._quxInt = nil} +let SwiftProtoTesting_Extensions_repeated_nested_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 51, + fieldName: "swift_proto_testing.repeated_nested_enum_extension" +) - var corgeInt: [Int32] = [] +let SwiftProtoTesting_Extensions_repeated_foreign_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 52, + fieldName: "swift_proto_testing.repeated_foreign_enum_extension" +) - var unknownFields = SwiftProtobuf.UnknownStorage() +let SwiftProtoTesting_Extensions_repeated_import_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 53, + fieldName: "swift_proto_testing.repeated_import_enum_extension" +) - init() {} +/// Singular with defaults +let SwiftProtoTesting_Extensions_default_int32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 61, + fieldName: "swift_proto_testing.default_int32_extension" +) - fileprivate var _quxInt: Int64? = nil - } +let SwiftProtoTesting_Extensions_default_int64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 62, + fieldName: "swift_proto_testing.default_int64_extension" +) - init() {} +let SwiftProtoTesting_Extensions_default_uint32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 63, + fieldName: "swift_proto_testing.default_uint32_extension" +) - fileprivate var _bazInt: Int32? = nil - fileprivate var _bazString: String? = nil -} +let SwiftProtoTesting_Extensions_default_uint64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 64, + fieldName: "swift_proto_testing.default_uint64_extension" +) -#if swift(>=4.2) +let SwiftProtoTesting_Extensions_default_sint32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 65, + fieldName: "swift_proto_testing.default_sint32_extension" +) -extension ProtobufUnittest_TestOneof2.NestedEnum: CaseIterable { - // Support synthesized by the compiler. -} +let SwiftProtoTesting_Extensions_default_sint64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 66, + fieldName: "swift_proto_testing.default_sint64_extension" +) -#endif // swift(>=4.2) +let SwiftProtoTesting_Extensions_default_fixed32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 67, + fieldName: "swift_proto_testing.default_fixed32_extension" +) -struct ProtobufUnittest_TestRequiredOneof { - // 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. +let SwiftProtoTesting_Extensions_default_fixed64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 68, + fieldName: "swift_proto_testing.default_fixed64_extension" +) - var foo: ProtobufUnittest_TestRequiredOneof.OneOf_Foo? = nil +let SwiftProtoTesting_Extensions_default_sfixed32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 69, + fieldName: "swift_proto_testing.default_sfixed32_extension" +) - var fooInt: Int32 { - get { - if case .fooInt(let v)? = foo {return v} - return 0 - } - set {foo = .fooInt(newValue)} - } - - var fooString: String { - get { - if case .fooString(let v)? = foo {return v} - return String() - } - set {foo = .fooString(newValue)} - } - - var fooMessage: ProtobufUnittest_TestRequiredOneof.NestedMessage { - get { - if case .fooMessage(let v)? = foo {return v} - return ProtobufUnittest_TestRequiredOneof.NestedMessage() - } - set {foo = .fooMessage(newValue)} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum OneOf_Foo: Equatable { - case fooInt(Int32) - case fooString(String) - case fooMessage(ProtobufUnittest_TestRequiredOneof.NestedMessage) - - fileprivate var isInitialized: Bool { - guard case .fooMessage(let v) = self else {return true} - return v.isInitialized - } - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestRequiredOneof.OneOf_Foo, rhs: ProtobufUnittest_TestRequiredOneof.OneOf_Foo) -> 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 (.fooInt, .fooInt): return { - guard case .fooInt(let l) = lhs, case .fooInt(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooString, .fooString): return { - guard case .fooString(let l) = lhs, case .fooString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fooMessage, .fooMessage): return { - guard case .fooMessage(let l) = lhs, case .fooMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif - } - - struct NestedMessage { - // 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 requiredDouble: Double { - get {return _requiredDouble ?? 0} - set {_requiredDouble = newValue} - } - /// Returns true if `requiredDouble` has been explicitly set. - var hasRequiredDouble: Bool {return self._requiredDouble != nil} - /// Clears the value of `requiredDouble`. Subsequent reads from it will return its default value. - mutating func clearRequiredDouble() {self._requiredDouble = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _requiredDouble: Double? = nil - } - - init() {} -} - -struct ProtobufUnittest_TestPackedTypes { - // 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 packedInt32: [Int32] = [] - - var packedInt64: [Int64] = [] - - var packedUint32: [UInt32] = [] +let SwiftProtoTesting_Extensions_default_sfixed64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 70, + fieldName: "swift_proto_testing.default_sfixed64_extension" +) - var packedUint64: [UInt64] = [] +let SwiftProtoTesting_Extensions_default_float_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 71, + fieldName: "swift_proto_testing.default_float_extension" +) - var packedSint32: [Int32] = [] +let SwiftProtoTesting_Extensions_default_double_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 72, + fieldName: "swift_proto_testing.default_double_extension" +) - var packedSint64: [Int64] = [] +let SwiftProtoTesting_Extensions_default_bool_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 73, + fieldName: "swift_proto_testing.default_bool_extension" +) - var packedFixed32: [UInt32] = [] +let SwiftProtoTesting_Extensions_default_string_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 74, + fieldName: "swift_proto_testing.default_string_extension" +) - var packedFixed64: [UInt64] = [] +let SwiftProtoTesting_Extensions_default_bytes_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 75, + fieldName: "swift_proto_testing.default_bytes_extension" +) - var packedSfixed32: [Int32] = [] +let SwiftProtoTesting_Extensions_default_nested_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 81, + fieldName: "swift_proto_testing.default_nested_enum_extension" +) - var packedSfixed64: [Int64] = [] +let SwiftProtoTesting_Extensions_default_foreign_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 82, + fieldName: "swift_proto_testing.default_foreign_enum_extension" +) - var packedFloat: [Float] = [] +let SwiftProtoTesting_Extensions_default_import_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 83, + fieldName: "swift_proto_testing.default_import_enum_extension" +) - var packedDouble: [Double] = [] +/// For oneof test +let SwiftProtoTesting_Extensions_oneof_uint32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 111, + fieldName: "swift_proto_testing.oneof_uint32_extension" +) - var packedBool: [Bool] = [] +let SwiftProtoTesting_Extensions_oneof_nested_message_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 112, + fieldName: "swift_proto_testing.oneof_nested_message_extension" +) - var packedEnum: [ProtobufUnittest_ForeignEnum] = [] +let SwiftProtoTesting_Extensions_oneof_string_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 113, + fieldName: "swift_proto_testing.oneof_string_extension" +) - var unknownFields = SwiftProtobuf.UnknownStorage() +let SwiftProtoTesting_Extensions_oneof_bytes_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 114, + fieldName: "swift_proto_testing.oneof_bytes_extension" +) - init() {} -} +let SwiftProtoTesting_Extensions_my_extension_string = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestFieldOrderings>( + _protobuf_fieldNumber: 50, + fieldName: "swift_proto_testing.my_extension_string" +) -/// A message with the same fields as TestPackedTypes, but without packing. Used -/// to test packed <-> unpacked wire compatibility. -struct ProtobufUnittest_TestUnpackedTypes { - // 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. +let SwiftProtoTesting_Extensions_my_extension_int = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestFieldOrderings>( + _protobuf_fieldNumber: 5, + fieldName: "swift_proto_testing.my_extension_int" +) - var unpackedInt32: [Int32] = [] +let SwiftProtoTesting_Extensions_packed_int32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 90, + fieldName: "swift_proto_testing.packed_int32_extension" +) - var unpackedInt64: [Int64] = [] +let SwiftProtoTesting_Extensions_packed_int64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 91, + fieldName: "swift_proto_testing.packed_int64_extension" +) - var unpackedUint32: [UInt32] = [] +let SwiftProtoTesting_Extensions_packed_uint32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 92, + fieldName: "swift_proto_testing.packed_uint32_extension" +) - var unpackedUint64: [UInt64] = [] +let SwiftProtoTesting_Extensions_packed_uint64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 93, + fieldName: "swift_proto_testing.packed_uint64_extension" +) - var unpackedSint32: [Int32] = [] +let SwiftProtoTesting_Extensions_packed_sint32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 94, + fieldName: "swift_proto_testing.packed_sint32_extension" +) - var unpackedSint64: [Int64] = [] +let SwiftProtoTesting_Extensions_packed_sint64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 95, + fieldName: "swift_proto_testing.packed_sint64_extension" +) - var unpackedFixed32: [UInt32] = [] +let SwiftProtoTesting_Extensions_packed_fixed32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 96, + fieldName: "swift_proto_testing.packed_fixed32_extension" +) - var unpackedFixed64: [UInt64] = [] +let SwiftProtoTesting_Extensions_packed_fixed64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 97, + fieldName: "swift_proto_testing.packed_fixed64_extension" +) - var unpackedSfixed32: [Int32] = [] +let SwiftProtoTesting_Extensions_packed_sfixed32_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 98, + fieldName: "swift_proto_testing.packed_sfixed32_extension" +) - var unpackedSfixed64: [Int64] = [] +let SwiftProtoTesting_Extensions_packed_sfixed64_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 99, + fieldName: "swift_proto_testing.packed_sfixed64_extension" +) - var unpackedFloat: [Float] = [] +let SwiftProtoTesting_Extensions_packed_float_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 100, + fieldName: "swift_proto_testing.packed_float_extension" +) - var unpackedDouble: [Double] = [] +let SwiftProtoTesting_Extensions_packed_double_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 101, + fieldName: "swift_proto_testing.packed_double_extension" +) - var unpackedBool: [Bool] = [] +let SwiftProtoTesting_Extensions_packed_bool_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 102, + fieldName: "swift_proto_testing.packed_bool_extension" +) - var unpackedEnum: [ProtobufUnittest_ForeignEnum] = [] +let SwiftProtoTesting_Extensions_packed_enum_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestPackedExtensions>( + _protobuf_fieldNumber: 103, + fieldName: "swift_proto_testing.packed_enum_extension" +) - var unknownFields = SwiftProtobuf.UnknownStorage() +extension SwiftProtoTesting_TestNestedExtension { + enum Extensions { + /// Check for bug where string extensions declared in tested scope did not + /// compile. + static let test = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 1002, + fieldName: "swift_proto_testing.TestNestedExtension.test" + ) - init() {} + /// Used to test if generated extension name is correct when there are + /// underscores. + static let nested_string_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 1003, + fieldName: "swift_proto_testing.TestNestedExtension.nested_string_extension" + ) + } } -struct ProtobufUnittest_TestPackedExtensions: 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. +extension SwiftProtoTesting_TestRequired { + enum Extensions { + static let single = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 1000, + fieldName: "swift_proto_testing.TestRequired.single" + ) - var unknownFields = SwiftProtobuf.UnknownStorage() + static let multi = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestAllExtensions>( + _protobuf_fieldNumber: 1001, + fieldName: "swift_proto_testing.TestRequired.multi" + ) + } +} - init() {} +extension SwiftProtoTesting_TestParsingMerge { + enum Extensions { + static let optional_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestParsingMerge>( + _protobuf_fieldNumber: 1000, + fieldName: "swift_proto_testing.TestParsingMerge.optional_ext" + ) - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + static let repeated_ext = SwiftProtobuf.MessageExtension, SwiftProtoTesting_TestParsingMerge>( + _protobuf_fieldNumber: 1001, + fieldName: "swift_proto_testing.TestParsingMerge.repeated_ext" + ) + } } -struct ProtobufUnittest_TestUnpackedExtensions: 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. +// MARK: - Code below here is support for the SwiftProtobuf runtime. - var unknownFields = SwiftProtobuf.UnknownStorage() +fileprivate let _protobuf_package = "swift_proto_testing" - init() {} +extension SwiftProtoTesting_ForeignEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{4}FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") +} - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() +extension SwiftProtoTesting_TestEnumWithDupValue: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{9}FOO1\0\u{1}FOO2\0\u{9}BAR1\0\u{1}BAR2\0\u{1}BAZ\0") } -/// Used by ExtensionSetTest/DynamicExtensions. The test actually builds -/// a set of extensions to TestAllExtensions dynamically, based on the fields -/// of this message type. -struct ProtobufUnittest_TestDynamicExtensions { - // 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. +extension SwiftProtoTesting_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{7}OptionalGroup\0\u{4}\u{2}optional_nested_message\0\u{3}optional_foreign_message\0\u{3}optional_import_message\0\u{3}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{3}optional_import_enum\0\u{4}\u{3}optional_public_import_message\0\u{4}\u{5}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{7}RepeatedGroup\0\u{4}\u{2}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{3}repeated_import_message\0\u{3}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{3}repeated_import_enum\0\u{4}\u{8}default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{4}\u{6}default_nested_enum\0\u{3}default_foreign_enum\0\u{3}default_import_enum\0\u{4}\u{1c}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{b}something_old\0\u{b}reserved_field\0\u{b}something_long_gone\0\u{c}JIt\u{3}\u{1}\u{c}LIt\u{3}\u{1}\u{c}lHt\u{3}\u{a}\u{c}~Ht\u{3}\u{2}\u{c}KIt\u{3}\u{1}") - var scalarExtension: UInt32 { - get {return _scalarExtension ?? 0} - set {_scalarExtension = newValue} - } - /// Returns true if `scalarExtension` has been explicitly set. - var hasScalarExtension: Bool {return self._scalarExtension != nil} - /// Clears the value of `scalarExtension`. Subsequent reads from it will return its default value. - mutating func clearScalarExtension() {self._scalarExtension = nil} + fileprivate class _StorageClass { + var _optionalInt32: Int32? = nil + var _optionalInt64: Int64? = nil + var _optionalUint32: UInt32? = nil + var _optionalUint64: UInt64? = nil + var _optionalSint32: Int32? = nil + var _optionalSint64: Int64? = nil + var _optionalFixed32: UInt32? = nil + var _optionalFixed64: UInt64? = nil + var _optionalSfixed32: Int32? = nil + var _optionalSfixed64: Int64? = nil + var _optionalFloat: Float? = nil + var _optionalDouble: Double? = nil + var _optionalBool: Bool? = nil + var _optionalString: String? = nil + var _optionalBytes: Data? = nil + var _optionalGroup: SwiftProtoTesting_TestAllTypes.OptionalGroup? = nil + var _optionalNestedMessage: SwiftProtoTesting_TestAllTypes.NestedMessage? = nil + var _optionalForeignMessage: SwiftProtoTesting_ForeignMessage? = nil + var _optionalImportMessage: SwiftProtoTesting_Import_ImportMessage? = nil + var _optionalNestedEnum: SwiftProtoTesting_TestAllTypes.NestedEnum? = nil + var _optionalForeignEnum: SwiftProtoTesting_ForeignEnum? = nil + var _optionalImportEnum: SwiftProtoTesting_Import_ImportEnum? = nil + var _optionalPublicImportMessage: SwiftProtoTesting_Import_PublicImportMessage? = nil + var _repeatedInt32: [Int32] = [] + var _repeatedInt64: [Int64] = [] + var _repeatedUint32: [UInt32] = [] + var _repeatedUint64: [UInt64] = [] + var _repeatedSint32: [Int32] = [] + var _repeatedSint64: [Int64] = [] + var _repeatedFixed32: [UInt32] = [] + var _repeatedFixed64: [UInt64] = [] + var _repeatedSfixed32: [Int32] = [] + var _repeatedSfixed64: [Int64] = [] + var _repeatedFloat: [Float] = [] + var _repeatedDouble: [Double] = [] + var _repeatedBool: [Bool] = [] + var _repeatedString: [String] = [] + var _repeatedBytes: [Data] = [] + var _repeatedGroup: [SwiftProtoTesting_TestAllTypes.RepeatedGroup] = [] + var _repeatedNestedMessage: [SwiftProtoTesting_TestAllTypes.NestedMessage] = [] + var _repeatedForeignMessage: [SwiftProtoTesting_ForeignMessage] = [] + var _repeatedImportMessage: [SwiftProtoTesting_Import_ImportMessage] = [] + var _repeatedNestedEnum: [SwiftProtoTesting_TestAllTypes.NestedEnum] = [] + var _repeatedForeignEnum: [SwiftProtoTesting_ForeignEnum] = [] + var _repeatedImportEnum: [SwiftProtoTesting_Import_ImportEnum] = [] + var _defaultInt32: Int32? = nil + var _defaultInt64: Int64? = nil + var _defaultUint32: UInt32? = nil + var _defaultUint64: UInt64? = nil + var _defaultSint32: Int32? = nil + var _defaultSint64: Int64? = nil + var _defaultFixed32: UInt32? = nil + var _defaultFixed64: UInt64? = nil + var _defaultSfixed32: Int32? = nil + var _defaultSfixed64: Int64? = nil + var _defaultFloat: Float? = nil + var _defaultDouble: Double? = nil + var _defaultBool: Bool? = nil + var _defaultString: String? = nil + var _defaultBytes: Data? = nil + var _defaultNestedEnum: SwiftProtoTesting_TestAllTypes.NestedEnum? = nil + var _defaultForeignEnum: SwiftProtoTesting_ForeignEnum? = nil + var _defaultImportEnum: SwiftProtoTesting_Import_ImportEnum? = nil + var _oneofField: SwiftProtoTesting_TestAllTypes.OneOf_OneofField? - var enumExtension: ProtobufUnittest_ForeignEnum { - get {return _enumExtension ?? .foreignFoo} - set {_enumExtension = newValue} - } - /// Returns true if `enumExtension` has been explicitly set. - var hasEnumExtension: Bool {return self._enumExtension != nil} - /// Clears the value of `enumExtension`. Subsequent reads from it will return its default value. - mutating func clearEnumExtension() {self._enumExtension = nil} + // 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() - var dynamicEnumExtension: ProtobufUnittest_TestDynamicExtensions.DynamicEnumType { - get {return _dynamicEnumExtension ?? .dynamicFoo} - set {_dynamicEnumExtension = newValue} - } - /// Returns true if `dynamicEnumExtension` has been explicitly set. - var hasDynamicEnumExtension: Bool {return self._dynamicEnumExtension != nil} - /// Clears the value of `dynamicEnumExtension`. Subsequent reads from it will return its default value. - mutating func clearDynamicEnumExtension() {self._dynamicEnumExtension = nil} - - var messageExtension: ProtobufUnittest_ForeignMessage { - get {return _messageExtension ?? ProtobufUnittest_ForeignMessage()} - set {_messageExtension = newValue} - } - /// Returns true if `messageExtension` has been explicitly set. - var hasMessageExtension: Bool {return self._messageExtension != nil} - /// Clears the value of `messageExtension`. Subsequent reads from it will return its default value. - mutating func clearMessageExtension() {self._messageExtension = nil} - - var dynamicMessageExtension: ProtobufUnittest_TestDynamicExtensions.DynamicMessageType { - get {return _dynamicMessageExtension ?? ProtobufUnittest_TestDynamicExtensions.DynamicMessageType()} - set {_dynamicMessageExtension = newValue} - } - /// Returns true if `dynamicMessageExtension` has been explicitly set. - var hasDynamicMessageExtension: Bool {return self._dynamicMessageExtension != nil} - /// Clears the value of `dynamicMessageExtension`. Subsequent reads from it will return its default value. - mutating func clearDynamicMessageExtension() {self._dynamicMessageExtension = nil} - - var repeatedExtension: [String] = [] - - var packedExtension: [Int32] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum DynamicEnumType: SwiftProtobuf.Enum { - typealias RawValue = Int - case dynamicFoo // = 2200 - case dynamicBar // = 2201 - case dynamicBaz // = 2202 - - init() { - self = .dynamicFoo - } - - init?(rawValue: Int) { - switch rawValue { - case 2200: self = .dynamicFoo - case 2201: self = .dynamicBar - case 2202: self = .dynamicBaz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .dynamicFoo: return 2200 - case .dynamicBar: return 2201 - case .dynamicBaz: return 2202 - } - } - - } - - struct DynamicMessageType { - // 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 dynamicField: Int32 { - get {return _dynamicField ?? 0} - set {_dynamicField = newValue} - } - /// Returns true if `dynamicField` has been explicitly set. - var hasDynamicField: Bool {return self._dynamicField != nil} - /// Clears the value of `dynamicField`. Subsequent reads from it will return its default value. - mutating func clearDynamicField() {self._dynamicField = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _dynamicField: Int32? = nil - } - - init() {} - - fileprivate var _scalarExtension: UInt32? = nil - fileprivate var _enumExtension: ProtobufUnittest_ForeignEnum? = nil - fileprivate var _dynamicEnumExtension: ProtobufUnittest_TestDynamicExtensions.DynamicEnumType? = nil - fileprivate var _messageExtension: ProtobufUnittest_ForeignMessage? = nil - fileprivate var _dynamicMessageExtension: ProtobufUnittest_TestDynamicExtensions.DynamicMessageType? = nil -} - -#if swift(>=4.2) - -extension ProtobufUnittest_TestDynamicExtensions.DynamicEnumType: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_TestRepeatedScalarDifferentTagSizes { - // 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. - - /// Parsing repeated fixed size values used to fail. This message needs to be - /// used in order to get a tag of the right size; all of the repeated fields - /// in TestAllTypes didn't trigger the check. - var repeatedFixed32: [UInt32] = [] - - /// Check for a varint type, just for good measure. - var repeatedInt32: [Int32] = [] - - /// These have two-byte tags. - var repeatedFixed64: [UInt64] = [] - - var repeatedInt64: [Int64] = [] - - /// Three byte tags. - var repeatedFloat: [Float] = [] - - var repeatedUint64: [UInt64] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -/// Test that if an optional or required message/group field appears multiple -/// times in the input, they need to be merged. -struct ProtobufUnittest_TestParsingMerge: 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 requiredAllTypes: ProtobufUnittest_TestAllTypes { - get {return _requiredAllTypes ?? ProtobufUnittest_TestAllTypes()} - set {_requiredAllTypes = newValue} - } - /// Returns true if `requiredAllTypes` has been explicitly set. - var hasRequiredAllTypes: Bool {return self._requiredAllTypes != nil} - /// Clears the value of `requiredAllTypes`. Subsequent reads from it will return its default value. - mutating func clearRequiredAllTypes() {self._requiredAllTypes = nil} - - var optionalAllTypes: ProtobufUnittest_TestAllTypes { - get {return _optionalAllTypes ?? ProtobufUnittest_TestAllTypes()} - set {_optionalAllTypes = newValue} - } - /// Returns true if `optionalAllTypes` has been explicitly set. - var hasOptionalAllTypes: Bool {return self._optionalAllTypes != nil} - /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. - mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} - - var repeatedAllTypes: [ProtobufUnittest_TestAllTypes] = [] - - var optionalGroup: ProtobufUnittest_TestParsingMerge.OptionalGroup { - get {return _optionalGroup ?? ProtobufUnittest_TestParsingMerge.OptionalGroup()} - set {_optionalGroup = newValue} - } - /// Returns true if `optionalGroup` has been explicitly set. - var hasOptionalGroup: Bool {return self._optionalGroup != nil} - /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. - mutating func clearOptionalGroup() {self._optionalGroup = nil} - - var repeatedGroup: [ProtobufUnittest_TestParsingMerge.RepeatedGroup] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - /// RepeatedFieldsGenerator defines matching field types as TestParsingMerge, - /// except that all fields are repeated. In the tests, we will serialize the - /// RepeatedFieldsGenerator to bytes, and parse the bytes to TestParsingMerge. - /// Repeated fields in RepeatedFieldsGenerator are expected to be merged into - /// the corresponding required/optional fields in TestParsingMerge. - struct RepeatedFieldsGenerator { - // 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: [ProtobufUnittest_TestAllTypes] = [] - - var field2: [ProtobufUnittest_TestAllTypes] = [] - - var field3: [ProtobufUnittest_TestAllTypes] = [] - - var group1: [ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group1] = [] - - var group2: [ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group2] = [] - - var ext1: [ProtobufUnittest_TestAllTypes] = [] - - var ext2: [ProtobufUnittest_TestAllTypes] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct Group1 { - // 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: ProtobufUnittest_TestAllTypes { - get {return _field1 ?? ProtobufUnittest_TestAllTypes()} - 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 unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _field1: ProtobufUnittest_TestAllTypes? = nil - } - - struct Group2 { - // 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: ProtobufUnittest_TestAllTypes { - get {return _field1 ?? ProtobufUnittest_TestAllTypes()} - 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 unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _field1: ProtobufUnittest_TestAllTypes? = nil - } - - init() {} - } - - struct OptionalGroup { - // 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 optionalGroupAllTypes: ProtobufUnittest_TestAllTypes { - get {return _optionalGroupAllTypes ?? ProtobufUnittest_TestAllTypes()} - set {_optionalGroupAllTypes = newValue} - } - /// Returns true if `optionalGroupAllTypes` has been explicitly set. - var hasOptionalGroupAllTypes: Bool {return self._optionalGroupAllTypes != nil} - /// Clears the value of `optionalGroupAllTypes`. Subsequent reads from it will return its default value. - mutating func clearOptionalGroupAllTypes() {self._optionalGroupAllTypes = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _optionalGroupAllTypes: ProtobufUnittest_TestAllTypes? = nil - } - - struct RepeatedGroup { - // 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 repeatedGroupAllTypes: ProtobufUnittest_TestAllTypes { - get {return _repeatedGroupAllTypes ?? ProtobufUnittest_TestAllTypes()} - set {_repeatedGroupAllTypes = newValue} - } - /// Returns true if `repeatedGroupAllTypes` has been explicitly set. - var hasRepeatedGroupAllTypes: Bool {return self._repeatedGroupAllTypes != nil} - /// Clears the value of `repeatedGroupAllTypes`. Subsequent reads from it will return its default value. - mutating func clearRepeatedGroupAllTypes() {self._repeatedGroupAllTypes = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _repeatedGroupAllTypes: ProtobufUnittest_TestAllTypes? = nil - } - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _requiredAllTypes: ProtobufUnittest_TestAllTypes? = nil - fileprivate var _optionalAllTypes: ProtobufUnittest_TestAllTypes? = nil - fileprivate var _optionalGroup: ProtobufUnittest_TestParsingMerge.OptionalGroup? = nil -} - -struct ProtobufUnittest_TestCommentInjectionMessage { - // 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. - - /// */ <- This should not close the generated doc comment - var a: String { - get {return _a ?? "*/ <- Neither should this."} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: String? = nil -} - -/// Test that RPC services work. -struct ProtobufUnittest_FooRequest { - // 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 ProtobufUnittest_FooResponse { - // 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 ProtobufUnittest_FooClientMessage { - // 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 ProtobufUnittest_FooServerMessage { - // 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 ProtobufUnittest_BarRequest { - // 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 ProtobufUnittest_BarResponse { - // 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 ProtobufUnittest_TestJsonName { - // 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 fieldName1: Int32 { - get {return _fieldName1 ?? 0} - set {_fieldName1 = newValue} - } - /// Returns true if `fieldName1` has been explicitly set. - var hasFieldName1: Bool {return self._fieldName1 != nil} - /// Clears the value of `fieldName1`. Subsequent reads from it will return its default value. - mutating func clearFieldName1() {self._fieldName1 = nil} - - var fieldName2: Int32 { - get {return _fieldName2 ?? 0} - set {_fieldName2 = newValue} - } - /// Returns true if `fieldName2` has been explicitly set. - var hasFieldName2: Bool {return self._fieldName2 != nil} - /// Clears the value of `fieldName2`. Subsequent reads from it will return its default value. - mutating func clearFieldName2() {self._fieldName2 = nil} - - var fieldName3: Int32 { - get {return _fieldName3 ?? 0} - set {_fieldName3 = newValue} - } - /// Returns true if `fieldName3` has been explicitly set. - var hasFieldName3: Bool {return self._fieldName3 != nil} - /// Clears the value of `fieldName3`. Subsequent reads from it will return its default value. - mutating func clearFieldName3() {self._fieldName3 = nil} - - var fieldName4: Int32 { - get {return _fieldName4 ?? 0} - set {_fieldName4 = newValue} - } - /// Returns true if `fieldName4` has been explicitly set. - var hasFieldName4: Bool {return self._fieldName4 != nil} - /// Clears the value of `fieldName4`. Subsequent reads from it will return its default value. - mutating func clearFieldName4() {self._fieldName4 = nil} - - var fieldName5: Int32 { - get {return _fieldName5 ?? 0} - set {_fieldName5 = newValue} - } - /// Returns true if `fieldName5` has been explicitly set. - var hasFieldName5: Bool {return self._fieldName5 != nil} - /// Clears the value of `fieldName5`. Subsequent reads from it will return its default value. - mutating func clearFieldName5() {self._fieldName5 = nil} - - var fieldName6: Int32 { - get {return _fieldName6 ?? 0} - set {_fieldName6 = newValue} - } - /// Returns true if `fieldName6` has been explicitly set. - var hasFieldName6: Bool {return self._fieldName6 != nil} - /// Clears the value of `fieldName6`. Subsequent reads from it will return its default value. - mutating func clearFieldName6() {self._fieldName6 = nil} - - var fieldname7: Int32 { - get {return _fieldname7 ?? 0} - set {_fieldname7 = newValue} - } - /// Returns true if `fieldname7` has been explicitly set. - var hasFieldname7: Bool {return self._fieldname7 != nil} - /// Clears the value of `fieldname7`. Subsequent reads from it will return its default value. - mutating func clearFieldname7() {self._fieldname7 = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _fieldName1: Int32? = nil - fileprivate var _fieldName2: Int32? = nil - fileprivate var _fieldName3: Int32? = nil - fileprivate var _fieldName4: Int32? = nil - fileprivate var _fieldName5: Int32? = nil - fileprivate var _fieldName6: Int32? = nil - fileprivate var _fieldname7: Int32? = nil -} - -struct ProtobufUnittest_TestHugeFieldNumbers: 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 optionalInt32: Int32 { - get {return _optionalInt32 ?? 0} - set {_optionalInt32 = newValue} - } - /// Returns true if `optionalInt32` has been explicitly set. - var hasOptionalInt32: Bool {return self._optionalInt32 != nil} - /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. - mutating func clearOptionalInt32() {self._optionalInt32 = nil} - - var fixed32: Int32 { - get {return _fixed32 ?? 0} - set {_fixed32 = newValue} - } - /// Returns true if `fixed32` has been explicitly set. - var hasFixed32: Bool {return self._fixed32 != nil} - /// Clears the value of `fixed32`. Subsequent reads from it will return its default value. - mutating func clearFixed32() {self._fixed32 = nil} - - var repeatedInt32: [Int32] = [] - - var packedInt32: [Int32] = [] - - var optionalEnum: ProtobufUnittest_ForeignEnum { - get {return _optionalEnum ?? .foreignFoo} - set {_optionalEnum = newValue} - } - /// Returns true if `optionalEnum` has been explicitly set. - var hasOptionalEnum: Bool {return self._optionalEnum != nil} - /// Clears the value of `optionalEnum`. Subsequent reads from it will return its default value. - mutating func clearOptionalEnum() {self._optionalEnum = nil} - - var optionalString: String { - get {return _optionalString ?? String()} - set {_optionalString = newValue} - } - /// Returns true if `optionalString` has been explicitly set. - var hasOptionalString: Bool {return self._optionalString != nil} - /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. - mutating func clearOptionalString() {self._optionalString = nil} - - var optionalBytes: Data { - get {return _optionalBytes ?? Data()} - set {_optionalBytes = newValue} - } - /// Returns true if `optionalBytes` has been explicitly set. - var hasOptionalBytes: Bool {return self._optionalBytes != nil} - /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. - mutating func clearOptionalBytes() {self._optionalBytes = nil} - - var optionalMessage: ProtobufUnittest_ForeignMessage { - get {return _optionalMessage ?? ProtobufUnittest_ForeignMessage()} - set {_optionalMessage = newValue} - } - /// Returns true if `optionalMessage` has been explicitly set. - var hasOptionalMessage: Bool {return self._optionalMessage != nil} - /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalMessage() {self._optionalMessage = nil} - - var optionalGroup: ProtobufUnittest_TestHugeFieldNumbers.OptionalGroup { - get {return _optionalGroup ?? ProtobufUnittest_TestHugeFieldNumbers.OptionalGroup()} - set {_optionalGroup = newValue} - } - /// Returns true if `optionalGroup` has been explicitly set. - var hasOptionalGroup: Bool {return self._optionalGroup != nil} - /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. - mutating func clearOptionalGroup() {self._optionalGroup = nil} - - var stringStringMap: Dictionary = [:] - - var oneofField: ProtobufUnittest_TestHugeFieldNumbers.OneOf_OneofField? = nil - - var oneofUint32: UInt32 { - get { - if case .oneofUint32(let v)? = oneofField {return v} - return 0 - } - set {oneofField = .oneofUint32(newValue)} - } - - var oneofTestAllTypes: ProtobufUnittest_TestAllTypes { - get { - if case .oneofTestAllTypes(let v)? = oneofField {return v} - return ProtobufUnittest_TestAllTypes() - } - set {oneofField = .oneofTestAllTypes(newValue)} - } - - var oneofString: String { - get { - if case .oneofString(let v)? = oneofField {return v} - return String() - } - set {oneofField = .oneofString(newValue)} - } - - var oneofBytes: Data { - get { - if case .oneofBytes(let v)? = oneofField {return v} - return Data() - } - set {oneofField = .oneofBytes(newValue)} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum OneOf_OneofField: Equatable { - case oneofUint32(UInt32) - case oneofTestAllTypes(ProtobufUnittest_TestAllTypes) - case oneofString(String) - case oneofBytes(Data) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestHugeFieldNumbers.OneOf_OneofField, rhs: ProtobufUnittest_TestHugeFieldNumbers.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofTestAllTypes, .oneofTestAllTypes): return { - guard case .oneofTestAllTypes(let l) = lhs, case .oneofTestAllTypes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif - } - - struct OptionalGroup { - // 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 groupA: Int32 { - get {return _groupA ?? 0} - set {_groupA = newValue} - } - /// Returns true if `groupA` has been explicitly set. - var hasGroupA: Bool {return self._groupA != nil} - /// Clears the value of `groupA`. Subsequent reads from it will return its default value. - mutating func clearGroupA() {self._groupA = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _groupA: Int32? = nil - } - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _optionalInt32: Int32? = nil - fileprivate var _fixed32: Int32? = nil - fileprivate var _optionalEnum: ProtobufUnittest_ForeignEnum? = nil - fileprivate var _optionalString: String? = nil - fileprivate var _optionalBytes: Data? = nil - fileprivate var _optionalMessage: ProtobufUnittest_ForeignMessage? = nil - fileprivate var _optionalGroup: ProtobufUnittest_TestHugeFieldNumbers.OptionalGroup? = nil -} - -struct ProtobufUnittest_TestExtensionInsideTable: 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 field3: Int32 { - get {return _field3 ?? 0} - set {_field3 = newValue} - } - /// Returns true if `field3` has been explicitly set. - var hasField3: Bool {return self._field3 != nil} - /// Clears the value of `field3`. Subsequent reads from it will return its default value. - mutating func clearField3() {self._field3 = nil} - - var field4: Int32 { - get {return _field4 ?? 0} - set {_field4 = newValue} - } - /// Returns true if `field4` has been explicitly set. - var hasField4: Bool {return self._field4 != nil} - /// Clears the value of `field4`. Subsequent reads from it will return its default value. - mutating func clearField4() {self._field4 = 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 field7: Int32 { - get {return _field7 ?? 0} - set {_field7 = newValue} - } - /// Returns true if `field7` has been explicitly set. - var hasField7: Bool {return self._field7 != nil} - /// Clears the value of `field7`. Subsequent reads from it will return its default value. - mutating func clearField7() {self._field7 = nil} - - var field8: Int32 { - get {return _field8 ?? 0} - set {_field8 = newValue} - } - /// Returns true if `field8` has been explicitly set. - var hasField8: Bool {return self._field8 != nil} - /// Clears the value of `field8`. Subsequent reads from it will return its default value. - mutating func clearField8() {self._field8 = nil} - - var field9: Int32 { - get {return _field9 ?? 0} - set {_field9 = newValue} - } - /// Returns true if `field9` has been explicitly set. - var hasField9: Bool {return self._field9 != nil} - /// Clears the value of `field9`. Subsequent reads from it will return its default value. - mutating func clearField9() {self._field9 = nil} - - var field10: Int32 { - get {return _field10 ?? 0} - set {_field10 = newValue} - } - /// Returns true if `field10` has been explicitly set. - var hasField10: Bool {return self._field10 != nil} - /// Clears the value of `field10`. Subsequent reads from it will return its default value. - mutating func clearField10() {self._field10 = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _field1: Int32? = nil - fileprivate var _field2: Int32? = nil - fileprivate var _field3: Int32? = nil - fileprivate var _field4: Int32? = nil - fileprivate var _field6: Int32? = nil - fileprivate var _field7: Int32? = nil - fileprivate var _field8: Int32? = nil - fileprivate var _field9: Int32? = nil - fileprivate var _field10: Int32? = nil -} - -struct ProtobufUnittest_TestExtensionRangeSerialize: 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 fooOne: Int32 { - get {return _fooOne ?? 0} - set {_fooOne = newValue} - } - /// Returns true if `fooOne` has been explicitly set. - var hasFooOne: Bool {return self._fooOne != nil} - /// Clears the value of `fooOne`. Subsequent reads from it will return its default value. - mutating func clearFooOne() {self._fooOne = nil} - - var fooTwo: Int32 { - get {return _fooTwo ?? 0} - set {_fooTwo = newValue} - } - /// Returns true if `fooTwo` has been explicitly set. - var hasFooTwo: Bool {return self._fooTwo != nil} - /// Clears the value of `fooTwo`. Subsequent reads from it will return its default value. - mutating func clearFooTwo() {self._fooTwo = nil} - - var fooThree: Int32 { - get {return _fooThree ?? 0} - set {_fooThree = newValue} - } - /// Returns true if `fooThree` has been explicitly set. - var hasFooThree: Bool {return self._fooThree != nil} - /// Clears the value of `fooThree`. Subsequent reads from it will return its default value. - mutating func clearFooThree() {self._fooThree = nil} - - var fooFour: Int32 { - get {return _fooFour ?? 0} - set {_fooFour = newValue} - } - /// Returns true if `fooFour` has been explicitly set. - var hasFooFour: Bool {return self._fooFour != nil} - /// Clears the value of `fooFour`. Subsequent reads from it will return its default value. - mutating func clearFooFour() {self._fooFour = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _fooOne: Int32? = nil - fileprivate var _fooTwo: Int32? = nil - fileprivate var _fooThree: Int32? = nil - fileprivate var _fooFour: Int32? = nil -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_ForeignEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestEnumWithDupValue: @unchecked Sendable {} -extension ProtobufUnittest_TestSparseEnum: @unchecked Sendable {} -extension ProtobufUnittest_VeryLargeEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypes: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypes.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypes.NestedEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypes.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypes.OptionalGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypes.RepeatedGroup: @unchecked Sendable {} -extension ProtobufUnittest_NestedTestAllTypes: @unchecked Sendable {} -extension ProtobufUnittest_TestDeprecatedFields: @unchecked Sendable {} -extension ProtobufUnittest_TestDeprecatedFields.OneOf_OneofFields: @unchecked Sendable {} -extension ProtobufUnittest_TestDeprecatedMessage: @unchecked Sendable {} -extension ProtobufUnittest_ForeignMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestReservedFields: @unchecked Sendable {} -extension ProtobufUnittest_TestAllExtensions: @unchecked Sendable {} -extension ProtobufUnittest_OptionalGroup_extension: @unchecked Sendable {} -extension ProtobufUnittest_RepeatedGroup_extension: @unchecked Sendable {} -extension ProtobufUnittest_TestGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestGroup.OptionalGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestGroupExtension: @unchecked Sendable {} -extension ProtobufUnittest_TestNestedExtension: @unchecked Sendable {} -extension ProtobufUnittest_TestNestedExtension.OptionalGroup_extension: @unchecked Sendable {} -extension ProtobufUnittest_TestChildExtension: @unchecked Sendable {} -extension ProtobufUnittest_TestRequired: @unchecked Sendable {} -extension ProtobufUnittest_TestRequiredForeign: @unchecked Sendable {} -extension ProtobufUnittest_TestRequiredMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestForeignNested: @unchecked Sendable {} -extension ProtobufUnittest_TestEmptyMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestEmptyMessageWithExtensions: @unchecked Sendable {} -extension ProtobufUnittest_TestPickleNestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestPickleNestedMessage.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestMultipleExtensionRanges: @unchecked Sendable {} -extension ProtobufUnittest_TestReallyLargeTagNumber: @unchecked Sendable {} -extension ProtobufUnittest_TestRecursiveMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestMutualRecursionA: @unchecked Sendable {} -extension ProtobufUnittest_TestMutualRecursionA.SubMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestMutualRecursionA.SubGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestMutualRecursionB: @unchecked Sendable {} -extension ProtobufUnittest_TestIsInitialized: @unchecked Sendable {} -extension ProtobufUnittest_TestIsInitialized.SubMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestIsInitialized.SubMessage.SubGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestDupFieldNumber: @unchecked Sendable {} -extension ProtobufUnittest_TestDupFieldNumber.Foo: @unchecked Sendable {} -extension ProtobufUnittest_TestDupFieldNumber.Bar: @unchecked Sendable {} -extension ProtobufUnittest_TestEagerMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestLazyMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestNestedMessageHasBits: @unchecked Sendable {} -extension ProtobufUnittest_TestNestedMessageHasBits.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestCamelCaseFieldNames: @unchecked Sendable {} -extension ProtobufUnittest_TestFieldOrderings: @unchecked Sendable {} -extension ProtobufUnittest_TestFieldOrderings.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestExtensionOrderings1: @unchecked Sendable {} -extension ProtobufUnittest_TestExtensionOrderings2: @unchecked Sendable {} -extension ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3: @unchecked Sendable {} -extension ProtobufUnittest_TestExtremeDefaultValues: @unchecked Sendable {} -extension ProtobufUnittest_SparseEnumMessage: @unchecked Sendable {} -extension ProtobufUnittest_OneString: @unchecked Sendable {} -extension ProtobufUnittest_MoreString: @unchecked Sendable {} -extension ProtobufUnittest_OneBytes: @unchecked Sendable {} -extension ProtobufUnittest_MoreBytes: @unchecked Sendable {} -extension ProtobufUnittest_Int32Message: @unchecked Sendable {} -extension ProtobufUnittest_Uint32Message: @unchecked Sendable {} -extension ProtobufUnittest_Int64Message: @unchecked Sendable {} -extension ProtobufUnittest_Uint64Message: @unchecked Sendable {} -extension ProtobufUnittest_BoolMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestOneof: @unchecked Sendable {} -extension ProtobufUnittest_TestOneof.OneOf_Foo: @unchecked Sendable {} -extension ProtobufUnittest_TestOneof.FooGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestOneofBackwardsCompatible: @unchecked Sendable {} -extension ProtobufUnittest_TestOneofBackwardsCompatible.FooGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestOneof2: @unchecked Sendable {} -extension ProtobufUnittest_TestOneof2.OneOf_Foo: @unchecked Sendable {} -extension ProtobufUnittest_TestOneof2.OneOf_Bar: @unchecked Sendable {} -extension ProtobufUnittest_TestOneof2.NestedEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestOneof2.FooGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestOneof2.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestRequiredOneof: @unchecked Sendable {} -extension ProtobufUnittest_TestRequiredOneof.OneOf_Foo: @unchecked Sendable {} -extension ProtobufUnittest_TestRequiredOneof.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestPackedTypes: @unchecked Sendable {} -extension ProtobufUnittest_TestUnpackedTypes: @unchecked Sendable {} -extension ProtobufUnittest_TestPackedExtensions: @unchecked Sendable {} -extension ProtobufUnittest_TestUnpackedExtensions: @unchecked Sendable {} -extension ProtobufUnittest_TestDynamicExtensions: @unchecked Sendable {} -extension ProtobufUnittest_TestDynamicExtensions.DynamicEnumType: @unchecked Sendable {} -extension ProtobufUnittest_TestDynamicExtensions.DynamicMessageType: @unchecked Sendable {} -extension ProtobufUnittest_TestRepeatedScalarDifferentTagSizes: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMerge: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group1: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group2: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMerge.OptionalGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMerge.RepeatedGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestCommentInjectionMessage: @unchecked Sendable {} -extension ProtobufUnittest_FooRequest: @unchecked Sendable {} -extension ProtobufUnittest_FooResponse: @unchecked Sendable {} -extension ProtobufUnittest_FooClientMessage: @unchecked Sendable {} -extension ProtobufUnittest_FooServerMessage: @unchecked Sendable {} -extension ProtobufUnittest_BarRequest: @unchecked Sendable {} -extension ProtobufUnittest_BarResponse: @unchecked Sendable {} -extension ProtobufUnittest_TestJsonName: @unchecked Sendable {} -extension ProtobufUnittest_TestHugeFieldNumbers: @unchecked Sendable {} -extension ProtobufUnittest_TestHugeFieldNumbers.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufUnittest_TestHugeFieldNumbers.OptionalGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestExtensionInsideTable: @unchecked Sendable {} -extension ProtobufUnittest_TestExtensionRangeSerialize: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Extension support defined in unittest.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 ProtobufUnittest_TestAllExtensions { - - /// Singular - var ProtobufUnittest_optionalInt32Extension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_int32_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_int32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_int32_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalInt32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_int32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_int32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalInt32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_int32_extension) - } - - var ProtobufUnittest_optionalInt64Extension: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_int64_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_int64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_int64_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalInt64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_int64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_int64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalInt64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_int64_extension) - } - - var ProtobufUnittest_optionalUint32Extension: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint32_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_uint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalUint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_uint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalUint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint32_extension) - } - - var ProtobufUnittest_optionalUint64Extension: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint64_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_uint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalUint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_uint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalUint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint64_extension) - } - - var ProtobufUnittest_optionalSint32Extension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint32_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_sint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalSint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_sint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalSint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint32_extension) - } - - var ProtobufUnittest_optionalSint64Extension: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint64_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_sint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalSint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_sint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalSint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint64_extension) - } - - var ProtobufUnittest_optionalFixed32Extension: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed32_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_fixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalFixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_fixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalFixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed32_extension) - } - - var ProtobufUnittest_optionalFixed64Extension: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed64_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_fixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalFixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_fixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalFixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed64_extension) - } - - var ProtobufUnittest_optionalSfixed32Extension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed32_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_sfixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalSfixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_sfixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalSfixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed32_extension) - } - - var ProtobufUnittest_optionalSfixed64Extension: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed64_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_sfixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalSfixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_sfixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalSfixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed64_extension) - } - - var ProtobufUnittest_optionalFloatExtension: Float { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_float_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_float_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_float_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalFloatExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_float_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_float_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalFloatExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_float_extension) - } - - var ProtobufUnittest_optionalDoubleExtension: Double { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_double_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_double_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_double_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalDoubleExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_double_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_double_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalDoubleExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_double_extension) - } - - var ProtobufUnittest_optionalBoolExtension: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_bool_extension) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_bool_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_bool_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalBoolExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_bool_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_bool_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalBoolExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_bool_extension) - } - - var ProtobufUnittest_optionalStringExtension: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_extension) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_string_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalStringExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_string_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalStringExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_extension) - } - - var ProtobufUnittest_optionalBytesExtension: Data { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_bytes_extension) ?? Data()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_bytes_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_bytes_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalBytesExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_bytes_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_bytes_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalBytesExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_bytes_extension) - } - - var ProtobufUnittest_optionalGroupExtension: ProtobufUnittest_OptionalGroup_extension { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_OptionalGroup_extension) ?? ProtobufUnittest_OptionalGroup_extension()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_OptionalGroup_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_OptionalGroup_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalGroupExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_OptionalGroup_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_OptionalGroup_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalGroupExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_OptionalGroup_extension) - } - - var ProtobufUnittest_optionalNestedMessageExtension: ProtobufUnittest_TestAllTypes.NestedMessage { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_message_extension) ?? ProtobufUnittest_TestAllTypes.NestedMessage()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_nested_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalNestedMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_nested_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalNestedMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_message_extension) - } - - var ProtobufUnittest_optionalForeignMessageExtension: ProtobufUnittest_ForeignMessage { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_message_extension) ?? ProtobufUnittest_ForeignMessage()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_foreign_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalForeignMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_foreign_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalForeignMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_message_extension) - } - - var ProtobufUnittest_optionalImportMessageExtension: ProtobufUnittestImport_ImportMessage { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_message_extension) ?? ProtobufUnittestImport_ImportMessage()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_import_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalImportMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_import_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalImportMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_message_extension) - } - - var ProtobufUnittest_optionalNestedEnumExtension: ProtobufUnittest_TestAllTypes.NestedEnum { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_enum_extension) ?? .foo} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_nested_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalNestedEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_nested_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalNestedEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_enum_extension) - } - - var ProtobufUnittest_optionalForeignEnumExtension: ProtobufUnittest_ForeignEnum { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_enum_extension) ?? .foreignFoo} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_foreign_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalForeignEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_foreign_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalForeignEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_enum_extension) - } - - var ProtobufUnittest_optionalImportEnumExtension: ProtobufUnittestImport_ImportEnum { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_enum_extension) ?? .importFoo} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_import_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalImportEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_import_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalImportEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_enum_extension) - } - - var ProtobufUnittest_optionalStringPieceExtension: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_piece_extension) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_piece_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_string_piece_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalStringPieceExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_piece_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_string_piece_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalStringPieceExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_piece_extension) - } - - var ProtobufUnittest_optionalCordExtension: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_cord_extension) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_cord_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_cord_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalCordExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_cord_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_cord_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalCordExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_cord_extension) - } - - var ProtobufUnittest_optionalPublicImportMessageExtension: ProtobufUnittestImport_PublicImportMessage { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_public_import_message_extension) ?? ProtobufUnittestImport_PublicImportMessage()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_public_import_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_public_import_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalPublicImportMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_public_import_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_public_import_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalPublicImportMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_public_import_message_extension) - } - - var ProtobufUnittest_optionalLazyMessageExtension: ProtobufUnittest_TestAllTypes.NestedMessage { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_lazy_message_extension) ?? ProtobufUnittest_TestAllTypes.NestedMessage()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_lazy_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_lazy_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_optionalLazyMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_lazy_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_lazy_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalLazyMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_lazy_message_extension) - } - - /// Repeated - var ProtobufUnittest_repeatedInt32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_int32_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedInt32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_int32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedInt32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int32_extension) - } - - var ProtobufUnittest_repeatedInt64Extension: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_int64_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedInt64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_int64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedInt64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int64_extension) - } - - var ProtobufUnittest_repeatedUint32Extension: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_uint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedUint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_uint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedUint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint32_extension) - } - - var ProtobufUnittest_repeatedUint64Extension: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_uint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedUint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_uint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedUint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint64_extension) - } - - var ProtobufUnittest_repeatedSint32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_sint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedSint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_sint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedSint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint32_extension) - } - - var ProtobufUnittest_repeatedSint64Extension: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_sint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedSint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_sint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedSint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint64_extension) - } - - var ProtobufUnittest_repeatedFixed32Extension: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_fixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedFixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_fixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedFixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed32_extension) - } - - var ProtobufUnittest_repeatedFixed64Extension: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_fixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedFixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_fixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedFixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed64_extension) - } - - var ProtobufUnittest_repeatedSfixed32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_sfixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedSfixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_sfixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedSfixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed32_extension) - } - - var ProtobufUnittest_repeatedSfixed64Extension: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_sfixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedSfixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_sfixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedSfixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed64_extension) - } - - var ProtobufUnittest_repeatedFloatExtension: [Float] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_float_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_float_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_float_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedFloatExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_float_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_float_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedFloatExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_float_extension) - } - - var ProtobufUnittest_repeatedDoubleExtension: [Double] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_double_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_double_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_double_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedDoubleExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_double_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_double_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedDoubleExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_double_extension) - } - - var ProtobufUnittest_repeatedBoolExtension: [Bool] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bool_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bool_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_bool_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedBoolExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bool_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_bool_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedBoolExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bool_extension) - } - - var ProtobufUnittest_repeatedStringExtension: [String] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_string_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedStringExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_string_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedStringExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_extension) - } - - var ProtobufUnittest_repeatedBytesExtension: [Data] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bytes_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bytes_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_bytes_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedBytesExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bytes_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_bytes_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedBytesExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bytes_extension) - } - - var ProtobufUnittest_repeatedGroupExtension: [ProtobufUnittest_RepeatedGroup_extension] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_RepeatedGroup_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_RepeatedGroup_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_RepeatedGroup_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedGroupExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_RepeatedGroup_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_RepeatedGroup_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedGroupExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_RepeatedGroup_extension) - } - - var ProtobufUnittest_repeatedNestedMessageExtension: [ProtobufUnittest_TestAllTypes.NestedMessage] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_message_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_nested_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedNestedMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_nested_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedNestedMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_message_extension) - } - - var ProtobufUnittest_repeatedForeignMessageExtension: [ProtobufUnittest_ForeignMessage] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_message_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_foreign_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedForeignMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_foreign_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedForeignMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_message_extension) - } - - var ProtobufUnittest_repeatedImportMessageExtension: [ProtobufUnittestImport_ImportMessage] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_message_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_import_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedImportMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_import_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedImportMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_message_extension) - } - - var ProtobufUnittest_repeatedNestedEnumExtension: [ProtobufUnittest_TestAllTypes.NestedEnum] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_enum_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_nested_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedNestedEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_nested_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedNestedEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_enum_extension) - } - - var ProtobufUnittest_repeatedForeignEnumExtension: [ProtobufUnittest_ForeignEnum] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_enum_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_foreign_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedForeignEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_foreign_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedForeignEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_enum_extension) - } - - var ProtobufUnittest_repeatedImportEnumExtension: [ProtobufUnittestImport_ImportEnum] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_enum_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_import_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedImportEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_import_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedImportEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_enum_extension) - } - - var ProtobufUnittest_repeatedStringPieceExtension: [String] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_piece_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_piece_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_string_piece_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedStringPieceExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_piece_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_string_piece_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedStringPieceExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_piece_extension) - } - - var ProtobufUnittest_repeatedCordExtension: [String] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_cord_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_cord_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_cord_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedCordExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_cord_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_cord_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedCordExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_cord_extension) - } - - var ProtobufUnittest_repeatedLazyMessageExtension: [ProtobufUnittest_TestAllTypes.NestedMessage] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_lazy_message_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_lazy_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_lazy_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_repeatedLazyMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_lazy_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_lazy_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedLazyMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_lazy_message_extension) - } - - /// Singular with defaults - var ProtobufUnittest_defaultInt32Extension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_int32_extension) ?? 41} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_int32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_int32_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultInt32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_int32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_int32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultInt32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_int32_extension) - } - - var ProtobufUnittest_defaultInt64Extension: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_int64_extension) ?? 42} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_int64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_int64_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultInt64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_int64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_int64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultInt64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_int64_extension) - } - - var ProtobufUnittest_defaultUint32Extension: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_uint32_extension) ?? 43} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_uint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_uint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultUint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_uint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_uint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultUint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_uint32_extension) - } - - var ProtobufUnittest_defaultUint64Extension: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_uint64_extension) ?? 44} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_uint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_uint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultUint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_uint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_uint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultUint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_uint64_extension) - } - - var ProtobufUnittest_defaultSint32Extension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_sint32_extension) ?? -45} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_sint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_sint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultSint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_sint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_sint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultSint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_sint32_extension) - } - - var ProtobufUnittest_defaultSint64Extension: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_sint64_extension) ?? 46} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_sint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_sint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultSint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_sint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_sint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultSint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_sint64_extension) - } - - var ProtobufUnittest_defaultFixed32Extension: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed32_extension) ?? 47} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_fixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultFixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_fixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultFixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed32_extension) - } - - var ProtobufUnittest_defaultFixed64Extension: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed64_extension) ?? 48} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_fixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultFixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_fixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultFixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed64_extension) - } - - var ProtobufUnittest_defaultSfixed32Extension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed32_extension) ?? 49} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_sfixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultSfixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_sfixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultSfixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed32_extension) - } - - var ProtobufUnittest_defaultSfixed64Extension: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed64_extension) ?? -50} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_sfixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultSfixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_sfixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultSfixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed64_extension) - } - - var ProtobufUnittest_defaultFloatExtension: Float { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_float_extension) ?? 51.5} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_float_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_float_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultFloatExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_float_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_float_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultFloatExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_float_extension) - } - - var ProtobufUnittest_defaultDoubleExtension: Double { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_double_extension) ?? 52000} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_double_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_double_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultDoubleExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_double_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_double_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultDoubleExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_double_extension) - } - - var ProtobufUnittest_defaultBoolExtension: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_bool_extension) ?? true} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_bool_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_bool_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultBoolExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_bool_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_bool_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultBoolExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_bool_extension) - } - - var ProtobufUnittest_defaultStringExtension: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_string_extension) ?? "hello"} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_string_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_string_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultStringExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_string_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_string_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultStringExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_string_extension) - } - - var ProtobufUnittest_defaultBytesExtension: Data { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_bytes_extension) ?? Data([119, 111, 114, 108, 100])} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_bytes_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_bytes_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultBytesExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_bytes_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_bytes_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultBytesExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_bytes_extension) - } - - var ProtobufUnittest_defaultNestedEnumExtension: ProtobufUnittest_TestAllTypes.NestedEnum { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_nested_enum_extension) ?? .bar} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_nested_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_nested_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultNestedEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_nested_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_nested_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultNestedEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_nested_enum_extension) - } - - var ProtobufUnittest_defaultForeignEnumExtension: ProtobufUnittest_ForeignEnum { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_foreign_enum_extension) ?? .foreignBar} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_foreign_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_foreign_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultForeignEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_foreign_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_foreign_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultForeignEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_foreign_enum_extension) - } - - var ProtobufUnittest_defaultImportEnumExtension: ProtobufUnittestImport_ImportEnum { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_import_enum_extension) ?? .importBar} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_import_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_import_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultImportEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_import_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_import_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultImportEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_import_enum_extension) - } - - var ProtobufUnittest_defaultStringPieceExtension: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_string_piece_extension) ?? "abc"} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_string_piece_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_string_piece_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultStringPieceExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_string_piece_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_string_piece_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultStringPieceExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_string_piece_extension) - } - - var ProtobufUnittest_defaultCordExtension: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_cord_extension) ?? "123"} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_cord_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_cord_extension` - /// has been explicitly set. - var hasProtobufUnittest_defaultCordExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_cord_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_cord_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultCordExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_cord_extension) - } - - /// For oneof test - var ProtobufUnittest_oneofUint32Extension: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_oneof_uint32_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_oneof_uint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_oneof_uint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_oneofUint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_oneof_uint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_oneof_uint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_oneofUint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_oneof_uint32_extension) - } - - var ProtobufUnittest_oneofNestedMessageExtension: ProtobufUnittest_TestAllTypes.NestedMessage { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_oneof_nested_message_extension) ?? ProtobufUnittest_TestAllTypes.NestedMessage()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_oneof_nested_message_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_oneof_nested_message_extension` - /// has been explicitly set. - var hasProtobufUnittest_oneofNestedMessageExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_oneof_nested_message_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_oneof_nested_message_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_oneofNestedMessageExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_oneof_nested_message_extension) - } - - var ProtobufUnittest_oneofStringExtension: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_oneof_string_extension) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_oneof_string_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_oneof_string_extension` - /// has been explicitly set. - var hasProtobufUnittest_oneofStringExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_oneof_string_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_oneof_string_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_oneofStringExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_oneof_string_extension) - } - - var ProtobufUnittest_oneofBytesExtension: Data { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_oneof_bytes_extension) ?? Data()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_oneof_bytes_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_oneof_bytes_extension` - /// has been explicitly set. - var hasProtobufUnittest_oneofBytesExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_oneof_bytes_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_oneof_bytes_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_oneofBytesExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_oneof_bytes_extension) - } - - /// Check for bug where string extensions declared in tested scope did not - /// compile. - var ProtobufUnittest_TestNestedExtension_test: String { - get {return getExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.test) ?? "test"} - set {setExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.test, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestNestedExtension.Extensions.test` - /// has been explicitly set. - var hasProtobufUnittest_TestNestedExtension_test: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.test) - } - /// Clears the value of extension `ProtobufUnittest_TestNestedExtension.Extensions.test`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestNestedExtension_test() { - clearExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.test) - } - - /// Used to test if generated extension name is correct when there are - /// underscores. - var ProtobufUnittest_TestNestedExtension_nestedStringExtension: String { - get {return getExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.nested_string_extension) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.nested_string_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestNestedExtension.Extensions.nested_string_extension` - /// has been explicitly set. - var hasProtobufUnittest_TestNestedExtension_nestedStringExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.nested_string_extension) - } - /// Clears the value of extension `ProtobufUnittest_TestNestedExtension.Extensions.nested_string_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestNestedExtension_nestedStringExtension() { - clearExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.nested_string_extension) - } - - var ProtobufUnittest_TestRequired_single: ProtobufUnittest_TestRequired { - get {return getExtensionValue(ext: ProtobufUnittest_TestRequired.Extensions.single) ?? ProtobufUnittest_TestRequired()} - set {setExtensionValue(ext: ProtobufUnittest_TestRequired.Extensions.single, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestRequired.Extensions.single` - /// has been explicitly set. - var hasProtobufUnittest_TestRequired_single: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestRequired.Extensions.single) - } - /// Clears the value of extension `ProtobufUnittest_TestRequired.Extensions.single`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestRequired_single() { - clearExtensionValue(ext: ProtobufUnittest_TestRequired.Extensions.single) - } - - var ProtobufUnittest_TestRequired_multi: [ProtobufUnittest_TestRequired] { - get {return getExtensionValue(ext: ProtobufUnittest_TestRequired.Extensions.multi) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_TestRequired.Extensions.multi, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestRequired.Extensions.multi` - /// has been explicitly set. - var hasProtobufUnittest_TestRequired_multi: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestRequired.Extensions.multi) - } - /// Clears the value of extension `ProtobufUnittest_TestRequired.Extensions.multi`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestRequired_multi() { - clearExtensionValue(ext: ProtobufUnittest_TestRequired.Extensions.multi) - } -} - -extension ProtobufUnittest_TestExtensionInsideTable { - - var ProtobufUnittest_testExtensionInsideTableExtension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_test_extension_inside_table_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_test_extension_inside_table_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_test_extension_inside_table_extension` - /// has been explicitly set. - var hasProtobufUnittest_testExtensionInsideTableExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_test_extension_inside_table_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_test_extension_inside_table_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_testExtensionInsideTableExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_test_extension_inside_table_extension) - } -} - -extension ProtobufUnittest_TestExtensionRangeSerialize { - - var ProtobufUnittest_TestExtensionRangeSerialize_barOne: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_one) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_one, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_one` - /// has been explicitly set. - var hasProtobufUnittest_TestExtensionRangeSerialize_barOne: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_one) - } - /// Clears the value of extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_one`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestExtensionRangeSerialize_barOne() { - clearExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_one) - } - - var ProtobufUnittest_TestExtensionRangeSerialize_barTwo: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_two) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_two, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_two` - /// has been explicitly set. - var hasProtobufUnittest_TestExtensionRangeSerialize_barTwo: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_two) - } - /// Clears the value of extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_two`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestExtensionRangeSerialize_barTwo() { - clearExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_two) - } - - var ProtobufUnittest_TestExtensionRangeSerialize_barThree: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_three) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_three, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_three` - /// has been explicitly set. - var hasProtobufUnittest_TestExtensionRangeSerialize_barThree: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_three) - } - /// Clears the value of extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_three`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestExtensionRangeSerialize_barThree() { - clearExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_three) - } - - var ProtobufUnittest_TestExtensionRangeSerialize_barFour: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_four) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_four, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_four` - /// has been explicitly set. - var hasProtobufUnittest_TestExtensionRangeSerialize_barFour: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_four) - } - /// Clears the value of extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_four`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestExtensionRangeSerialize_barFour() { - clearExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_four) - } - - var ProtobufUnittest_TestExtensionRangeSerialize_barFive: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_five) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_five, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_five` - /// has been explicitly set. - var hasProtobufUnittest_TestExtensionRangeSerialize_barFive: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_five) - } - /// Clears the value of extension `ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_five`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestExtensionRangeSerialize_barFive() { - clearExtensionValue(ext: ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_five) - } -} - -extension ProtobufUnittest_TestFieldOrderings { - - var ProtobufUnittest_myExtensionString: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_my_extension_string) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_my_extension_string, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_my_extension_string` - /// has been explicitly set. - var hasProtobufUnittest_myExtensionString: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_my_extension_string) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_my_extension_string`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_myExtensionString() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_my_extension_string) - } - - var ProtobufUnittest_myExtensionInt: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_my_extension_int) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_my_extension_int, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_my_extension_int` - /// has been explicitly set. - var hasProtobufUnittest_myExtensionInt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_my_extension_int) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_my_extension_int`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_myExtensionInt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_my_extension_int) - } - - var ProtobufUnittest_TestExtensionOrderings1_testExtOrderings1: ProtobufUnittest_TestExtensionOrderings1 { - get {return getExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1) ?? ProtobufUnittest_TestExtensionOrderings1()} - set {setExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1` - /// has been explicitly set. - var hasProtobufUnittest_TestExtensionOrderings1_testExtOrderings1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1) - } - /// Clears the value of extension `ProtobufUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestExtensionOrderings1_testExtOrderings1() { - clearExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1) - } - - var ProtobufUnittest_TestExtensionOrderings2_testExtOrderings2: ProtobufUnittest_TestExtensionOrderings2 { - get {return getExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2) ?? ProtobufUnittest_TestExtensionOrderings2()} - set {setExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2` - /// has been explicitly set. - var hasProtobufUnittest_TestExtensionOrderings2_testExtOrderings2: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2) - } - /// Clears the value of extension `ProtobufUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestExtensionOrderings2_testExtOrderings2() { - clearExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2) - } - - var ProtobufUnittest_TestExtensionOrderings2_TestExtensionOrderings3_testExtOrderings3: ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3 { - get {return getExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3) ?? ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3()} - set {setExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3` - /// has been explicitly set. - var hasProtobufUnittest_TestExtensionOrderings2_TestExtensionOrderings3_testExtOrderings3: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3) - } - /// Clears the value of extension `ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestExtensionOrderings2_TestExtensionOrderings3_testExtOrderings3() { - clearExtensionValue(ext: ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3) - } -} - -extension ProtobufUnittest_TestGroupExtension { - - var ProtobufUnittest_TestNestedExtension_optionalGroupExtension: ProtobufUnittest_TestNestedExtension.OptionalGroup_extension { - get {return getExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.OptionalGroup_extension) ?? ProtobufUnittest_TestNestedExtension.OptionalGroup_extension()} - set {setExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.OptionalGroup_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestNestedExtension.Extensions.OptionalGroup_extension` - /// has been explicitly set. - var hasProtobufUnittest_TestNestedExtension_optionalGroupExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.OptionalGroup_extension) - } - /// Clears the value of extension `ProtobufUnittest_TestNestedExtension.Extensions.OptionalGroup_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestNestedExtension_optionalGroupExtension() { - clearExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.OptionalGroup_extension) - } - - var ProtobufUnittest_TestNestedExtension_optionalForeignEnumExtension: ProtobufUnittest_ForeignEnum { - get {return getExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension) ?? .foreignFoo} - set {setExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_TestNestedExtension_optionalForeignEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestNestedExtension_optionalForeignEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension) - } -} - -extension ProtobufUnittest_TestHugeFieldNumbers { - - var ProtobufUnittest_testAllTypes: ProtobufUnittest_TestAllTypes { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_test_all_types) ?? ProtobufUnittest_TestAllTypes()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_test_all_types, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_test_all_types` - /// has been explicitly set. - var hasProtobufUnittest_testAllTypes: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_test_all_types) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_test_all_types`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_testAllTypes() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_test_all_types) - } -} - -extension ProtobufUnittest_TestPackedExtensions { - - var ProtobufUnittest_packedInt32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_int32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_int32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_int32_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedInt32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_int32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_int32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedInt32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_int32_extension) - } - - var ProtobufUnittest_packedInt64Extension: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_int64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_int64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_int64_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedInt64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_int64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_int64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedInt64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_int64_extension) - } - - var ProtobufUnittest_packedUint32Extension: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_uint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedUint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_uint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedUint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint32_extension) - } - - var ProtobufUnittest_packedUint64Extension: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_uint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedUint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_uint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedUint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint64_extension) - } - - var ProtobufUnittest_packedSint32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_sint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedSint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_sint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedSint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint32_extension) - } - - var ProtobufUnittest_packedSint64Extension: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_sint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedSint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_sint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedSint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint64_extension) - } - - var ProtobufUnittest_packedFixed32Extension: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_fixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedFixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_fixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedFixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed32_extension) - } - - var ProtobufUnittest_packedFixed64Extension: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_fixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedFixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_fixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedFixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed64_extension) - } - - var ProtobufUnittest_packedSfixed32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_sfixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedSfixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_sfixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedSfixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed32_extension) - } - - var ProtobufUnittest_packedSfixed64Extension: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_sfixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedSfixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_sfixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedSfixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed64_extension) - } - - var ProtobufUnittest_packedFloatExtension: [Float] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_float_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_float_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_float_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedFloatExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_float_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_float_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedFloatExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_float_extension) - } - - var ProtobufUnittest_packedDoubleExtension: [Double] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_double_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_double_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_double_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedDoubleExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_double_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_double_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedDoubleExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_double_extension) - } - - var ProtobufUnittest_packedBoolExtension: [Bool] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_bool_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_bool_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_bool_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedBoolExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_bool_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_bool_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedBoolExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_bool_extension) - } - - var ProtobufUnittest_packedEnumExtension: [ProtobufUnittest_ForeignEnum] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_enum_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_packedEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_enum_extension) - } -} - -extension ProtobufUnittest_TestParsingMerge { - - var ProtobufUnittest_TestParsingMerge_optionalExt: ProtobufUnittest_TestAllTypes { - get {return getExtensionValue(ext: ProtobufUnittest_TestParsingMerge.Extensions.optional_ext) ?? ProtobufUnittest_TestAllTypes()} - set {setExtensionValue(ext: ProtobufUnittest_TestParsingMerge.Extensions.optional_ext, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestParsingMerge.Extensions.optional_ext` - /// has been explicitly set. - var hasProtobufUnittest_TestParsingMerge_optionalExt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestParsingMerge.Extensions.optional_ext) - } - /// Clears the value of extension `ProtobufUnittest_TestParsingMerge.Extensions.optional_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestParsingMerge_optionalExt() { - clearExtensionValue(ext: ProtobufUnittest_TestParsingMerge.Extensions.optional_ext) - } - - var ProtobufUnittest_TestParsingMerge_repeatedExt: [ProtobufUnittest_TestAllTypes] { - get {return getExtensionValue(ext: ProtobufUnittest_TestParsingMerge.Extensions.repeated_ext) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_TestParsingMerge.Extensions.repeated_ext, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestParsingMerge.Extensions.repeated_ext` - /// has been explicitly set. - var hasProtobufUnittest_TestParsingMerge_repeatedExt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestParsingMerge.Extensions.repeated_ext) - } - /// Clears the value of extension `ProtobufUnittest_TestParsingMerge.Extensions.repeated_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestParsingMerge_repeatedExt() { - clearExtensionValue(ext: ProtobufUnittest_TestParsingMerge.Extensions.repeated_ext) - } -} - -extension ProtobufUnittest_TestUnpackedExtensions { - - var ProtobufUnittest_unpackedInt32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_int32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_int32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_int32_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedInt32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_int32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_int32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedInt32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_int32_extension) - } - - var ProtobufUnittest_unpackedInt64Extension: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_int64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_int64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_int64_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedInt64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_int64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_int64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedInt64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_int64_extension) - } - - var ProtobufUnittest_unpackedUint32Extension: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_uint32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_uint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_uint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedUint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_uint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_uint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedUint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_uint32_extension) - } - - var ProtobufUnittest_unpackedUint64Extension: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_uint64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_uint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_uint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedUint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_uint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_uint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedUint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_uint64_extension) - } - - var ProtobufUnittest_unpackedSint32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sint32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sint32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_sint32_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedSint32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sint32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_sint32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedSint32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sint32_extension) - } - - var ProtobufUnittest_unpackedSint64Extension: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sint64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sint64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_sint64_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedSint64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sint64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_sint64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedSint64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sint64_extension) - } - - var ProtobufUnittest_unpackedFixed32Extension: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_fixed32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_fixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_fixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedFixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_fixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_fixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedFixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_fixed32_extension) - } - - var ProtobufUnittest_unpackedFixed64Extension: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_fixed64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_fixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_fixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedFixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_fixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_fixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedFixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_fixed64_extension) - } - - var ProtobufUnittest_unpackedSfixed32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sfixed32_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sfixed32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_sfixed32_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedSfixed32Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sfixed32_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_sfixed32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedSfixed32Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sfixed32_extension) - } - - var ProtobufUnittest_unpackedSfixed64Extension: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sfixed64_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sfixed64_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_sfixed64_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedSfixed64Extension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sfixed64_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_sfixed64_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedSfixed64Extension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_sfixed64_extension) - } - - var ProtobufUnittest_unpackedFloatExtension: [Float] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_float_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_float_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_float_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedFloatExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_float_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_float_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedFloatExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_float_extension) - } - - var ProtobufUnittest_unpackedDoubleExtension: [Double] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_double_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_double_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_double_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedDoubleExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_double_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_double_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedDoubleExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_double_extension) - } - - var ProtobufUnittest_unpackedBoolExtension: [Bool] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_bool_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_bool_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_bool_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedBoolExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_bool_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_bool_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedBoolExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_bool_extension) - } - - var ProtobufUnittest_unpackedEnumExtension: [ProtobufUnittest_ForeignEnum] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_enum_extension) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_enum_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_unpacked_enum_extension` - /// has been explicitly set. - var hasProtobufUnittest_unpackedEnumExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_enum_extension) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_unpacked_enum_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_unpackedEnumExtension() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_unpacked_enum_extension) - } - -} - -// MARK: - File's ExtensionMap: ProtobufUnittest_Unittest_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 ProtobufUnittest_Unittest_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_Extensions_optional_int32_extension, - ProtobufUnittest_Extensions_optional_int64_extension, - ProtobufUnittest_Extensions_optional_uint32_extension, - ProtobufUnittest_Extensions_optional_uint64_extension, - ProtobufUnittest_Extensions_optional_sint32_extension, - ProtobufUnittest_Extensions_optional_sint64_extension, - ProtobufUnittest_Extensions_optional_fixed32_extension, - ProtobufUnittest_Extensions_optional_fixed64_extension, - ProtobufUnittest_Extensions_optional_sfixed32_extension, - ProtobufUnittest_Extensions_optional_sfixed64_extension, - ProtobufUnittest_Extensions_optional_float_extension, - ProtobufUnittest_Extensions_optional_double_extension, - ProtobufUnittest_Extensions_optional_bool_extension, - ProtobufUnittest_Extensions_optional_string_extension, - ProtobufUnittest_Extensions_optional_bytes_extension, - ProtobufUnittest_Extensions_OptionalGroup_extension, - ProtobufUnittest_Extensions_optional_nested_message_extension, - ProtobufUnittest_Extensions_optional_foreign_message_extension, - ProtobufUnittest_Extensions_optional_import_message_extension, - ProtobufUnittest_Extensions_optional_nested_enum_extension, - ProtobufUnittest_Extensions_optional_foreign_enum_extension, - ProtobufUnittest_Extensions_optional_import_enum_extension, - ProtobufUnittest_Extensions_optional_string_piece_extension, - ProtobufUnittest_Extensions_optional_cord_extension, - ProtobufUnittest_Extensions_optional_public_import_message_extension, - ProtobufUnittest_Extensions_optional_lazy_message_extension, - ProtobufUnittest_Extensions_repeated_int32_extension, - ProtobufUnittest_Extensions_repeated_int64_extension, - ProtobufUnittest_Extensions_repeated_uint32_extension, - ProtobufUnittest_Extensions_repeated_uint64_extension, - ProtobufUnittest_Extensions_repeated_sint32_extension, - ProtobufUnittest_Extensions_repeated_sint64_extension, - ProtobufUnittest_Extensions_repeated_fixed32_extension, - ProtobufUnittest_Extensions_repeated_fixed64_extension, - ProtobufUnittest_Extensions_repeated_sfixed32_extension, - ProtobufUnittest_Extensions_repeated_sfixed64_extension, - ProtobufUnittest_Extensions_repeated_float_extension, - ProtobufUnittest_Extensions_repeated_double_extension, - ProtobufUnittest_Extensions_repeated_bool_extension, - ProtobufUnittest_Extensions_repeated_string_extension, - ProtobufUnittest_Extensions_repeated_bytes_extension, - ProtobufUnittest_Extensions_RepeatedGroup_extension, - ProtobufUnittest_Extensions_repeated_nested_message_extension, - ProtobufUnittest_Extensions_repeated_foreign_message_extension, - ProtobufUnittest_Extensions_repeated_import_message_extension, - ProtobufUnittest_Extensions_repeated_nested_enum_extension, - ProtobufUnittest_Extensions_repeated_foreign_enum_extension, - ProtobufUnittest_Extensions_repeated_import_enum_extension, - ProtobufUnittest_Extensions_repeated_string_piece_extension, - ProtobufUnittest_Extensions_repeated_cord_extension, - ProtobufUnittest_Extensions_repeated_lazy_message_extension, - ProtobufUnittest_Extensions_default_int32_extension, - ProtobufUnittest_Extensions_default_int64_extension, - ProtobufUnittest_Extensions_default_uint32_extension, - ProtobufUnittest_Extensions_default_uint64_extension, - ProtobufUnittest_Extensions_default_sint32_extension, - ProtobufUnittest_Extensions_default_sint64_extension, - ProtobufUnittest_Extensions_default_fixed32_extension, - ProtobufUnittest_Extensions_default_fixed64_extension, - ProtobufUnittest_Extensions_default_sfixed32_extension, - ProtobufUnittest_Extensions_default_sfixed64_extension, - ProtobufUnittest_Extensions_default_float_extension, - ProtobufUnittest_Extensions_default_double_extension, - ProtobufUnittest_Extensions_default_bool_extension, - ProtobufUnittest_Extensions_default_string_extension, - ProtobufUnittest_Extensions_default_bytes_extension, - ProtobufUnittest_Extensions_default_nested_enum_extension, - ProtobufUnittest_Extensions_default_foreign_enum_extension, - ProtobufUnittest_Extensions_default_import_enum_extension, - ProtobufUnittest_Extensions_default_string_piece_extension, - ProtobufUnittest_Extensions_default_cord_extension, - ProtobufUnittest_Extensions_oneof_uint32_extension, - ProtobufUnittest_Extensions_oneof_nested_message_extension, - ProtobufUnittest_Extensions_oneof_string_extension, - ProtobufUnittest_Extensions_oneof_bytes_extension, - ProtobufUnittest_Extensions_my_extension_string, - ProtobufUnittest_Extensions_my_extension_int, - ProtobufUnittest_Extensions_packed_int32_extension, - ProtobufUnittest_Extensions_packed_int64_extension, - ProtobufUnittest_Extensions_packed_uint32_extension, - ProtobufUnittest_Extensions_packed_uint64_extension, - ProtobufUnittest_Extensions_packed_sint32_extension, - ProtobufUnittest_Extensions_packed_sint64_extension, - ProtobufUnittest_Extensions_packed_fixed32_extension, - ProtobufUnittest_Extensions_packed_fixed64_extension, - ProtobufUnittest_Extensions_packed_sfixed32_extension, - ProtobufUnittest_Extensions_packed_sfixed64_extension, - ProtobufUnittest_Extensions_packed_float_extension, - ProtobufUnittest_Extensions_packed_double_extension, - ProtobufUnittest_Extensions_packed_bool_extension, - ProtobufUnittest_Extensions_packed_enum_extension, - ProtobufUnittest_Extensions_unpacked_int32_extension, - ProtobufUnittest_Extensions_unpacked_int64_extension, - ProtobufUnittest_Extensions_unpacked_uint32_extension, - ProtobufUnittest_Extensions_unpacked_uint64_extension, - ProtobufUnittest_Extensions_unpacked_sint32_extension, - ProtobufUnittest_Extensions_unpacked_sint64_extension, - ProtobufUnittest_Extensions_unpacked_fixed32_extension, - ProtobufUnittest_Extensions_unpacked_fixed64_extension, - ProtobufUnittest_Extensions_unpacked_sfixed32_extension, - ProtobufUnittest_Extensions_unpacked_sfixed64_extension, - ProtobufUnittest_Extensions_unpacked_float_extension, - ProtobufUnittest_Extensions_unpacked_double_extension, - ProtobufUnittest_Extensions_unpacked_bool_extension, - ProtobufUnittest_Extensions_unpacked_enum_extension, - ProtobufUnittest_Extensions_test_all_types, - ProtobufUnittest_Extensions_test_extension_inside_table_extension, - ProtobufUnittest_TestNestedExtension.Extensions.test, - ProtobufUnittest_TestNestedExtension.Extensions.nested_string_extension, - ProtobufUnittest_TestNestedExtension.Extensions.OptionalGroup_extension, - ProtobufUnittest_TestNestedExtension.Extensions.optional_foreign_enum_extension, - ProtobufUnittest_TestRequired.Extensions.single, - ProtobufUnittest_TestRequired.Extensions.multi, - ProtobufUnittest_TestExtensionOrderings1.Extensions.test_ext_orderings1, - ProtobufUnittest_TestExtensionOrderings2.Extensions.test_ext_orderings2, - ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3.Extensions.test_ext_orderings3, - ProtobufUnittest_TestParsingMerge.Extensions.optional_ext, - ProtobufUnittest_TestParsingMerge.Extensions.repeated_ext, - ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_one, - ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_two, - ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_three, - ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_four, - ProtobufUnittest_TestExtensionRangeSerialize.Extensions.bar_five -] - -// 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. - -/// Singular -let ProtobufUnittest_Extensions_optional_int32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 1, - fieldName: "protobuf_unittest.optional_int32_extension" -) - -let ProtobufUnittest_Extensions_optional_int64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 2, - fieldName: "protobuf_unittest.optional_int64_extension" -) - -let ProtobufUnittest_Extensions_optional_uint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 3, - fieldName: "protobuf_unittest.optional_uint32_extension" -) - -let ProtobufUnittest_Extensions_optional_uint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 4, - fieldName: "protobuf_unittest.optional_uint64_extension" -) - -let ProtobufUnittest_Extensions_optional_sint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 5, - fieldName: "protobuf_unittest.optional_sint32_extension" -) - -let ProtobufUnittest_Extensions_optional_sint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 6, - fieldName: "protobuf_unittest.optional_sint64_extension" -) - -let ProtobufUnittest_Extensions_optional_fixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 7, - fieldName: "protobuf_unittest.optional_fixed32_extension" -) - -let ProtobufUnittest_Extensions_optional_fixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 8, - fieldName: "protobuf_unittest.optional_fixed64_extension" -) - -let ProtobufUnittest_Extensions_optional_sfixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 9, - fieldName: "protobuf_unittest.optional_sfixed32_extension" -) - -let ProtobufUnittest_Extensions_optional_sfixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 10, - fieldName: "protobuf_unittest.optional_sfixed64_extension" -) - -let ProtobufUnittest_Extensions_optional_float_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 11, - fieldName: "protobuf_unittest.optional_float_extension" -) - -let ProtobufUnittest_Extensions_optional_double_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 12, - fieldName: "protobuf_unittest.optional_double_extension" -) - -let ProtobufUnittest_Extensions_optional_bool_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 13, - fieldName: "protobuf_unittest.optional_bool_extension" -) - -let ProtobufUnittest_Extensions_optional_string_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 14, - fieldName: "protobuf_unittest.optional_string_extension" -) - -let ProtobufUnittest_Extensions_optional_bytes_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 15, - fieldName: "protobuf_unittest.optional_bytes_extension" -) - -let ProtobufUnittest_Extensions_OptionalGroup_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 16, - fieldName: "protobuf_unittest.optionalgroup_extension" -) - -let ProtobufUnittest_Extensions_optional_nested_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 18, - fieldName: "protobuf_unittest.optional_nested_message_extension" -) - -let ProtobufUnittest_Extensions_optional_foreign_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 19, - fieldName: "protobuf_unittest.optional_foreign_message_extension" -) - -let ProtobufUnittest_Extensions_optional_import_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 20, - fieldName: "protobuf_unittest.optional_import_message_extension" -) - -let ProtobufUnittest_Extensions_optional_nested_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 21, - fieldName: "protobuf_unittest.optional_nested_enum_extension" -) - -let ProtobufUnittest_Extensions_optional_foreign_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 22, - fieldName: "protobuf_unittest.optional_foreign_enum_extension" -) - -let ProtobufUnittest_Extensions_optional_import_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 23, - fieldName: "protobuf_unittest.optional_import_enum_extension" -) - -let ProtobufUnittest_Extensions_optional_string_piece_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 24, - fieldName: "protobuf_unittest.optional_string_piece_extension" -) - -let ProtobufUnittest_Extensions_optional_cord_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 25, - fieldName: "protobuf_unittest.optional_cord_extension" -) - -let ProtobufUnittest_Extensions_optional_public_import_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 26, - fieldName: "protobuf_unittest.optional_public_import_message_extension" -) - -let ProtobufUnittest_Extensions_optional_lazy_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 27, - fieldName: "protobuf_unittest.optional_lazy_message_extension" -) - -/// Repeated -let ProtobufUnittest_Extensions_repeated_int32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 31, - fieldName: "protobuf_unittest.repeated_int32_extension" -) - -let ProtobufUnittest_Extensions_repeated_int64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 32, - fieldName: "protobuf_unittest.repeated_int64_extension" -) - -let ProtobufUnittest_Extensions_repeated_uint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 33, - fieldName: "protobuf_unittest.repeated_uint32_extension" -) - -let ProtobufUnittest_Extensions_repeated_uint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 34, - fieldName: "protobuf_unittest.repeated_uint64_extension" -) - -let ProtobufUnittest_Extensions_repeated_sint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 35, - fieldName: "protobuf_unittest.repeated_sint32_extension" -) - -let ProtobufUnittest_Extensions_repeated_sint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 36, - fieldName: "protobuf_unittest.repeated_sint64_extension" -) - -let ProtobufUnittest_Extensions_repeated_fixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 37, - fieldName: "protobuf_unittest.repeated_fixed32_extension" -) - -let ProtobufUnittest_Extensions_repeated_fixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 38, - fieldName: "protobuf_unittest.repeated_fixed64_extension" -) - -let ProtobufUnittest_Extensions_repeated_sfixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 39, - fieldName: "protobuf_unittest.repeated_sfixed32_extension" -) - -let ProtobufUnittest_Extensions_repeated_sfixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 40, - fieldName: "protobuf_unittest.repeated_sfixed64_extension" -) - -let ProtobufUnittest_Extensions_repeated_float_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 41, - fieldName: "protobuf_unittest.repeated_float_extension" -) - -let ProtobufUnittest_Extensions_repeated_double_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 42, - fieldName: "protobuf_unittest.repeated_double_extension" -) - -let ProtobufUnittest_Extensions_repeated_bool_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 43, - fieldName: "protobuf_unittest.repeated_bool_extension" -) - -let ProtobufUnittest_Extensions_repeated_string_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 44, - fieldName: "protobuf_unittest.repeated_string_extension" -) - -let ProtobufUnittest_Extensions_repeated_bytes_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 45, - fieldName: "protobuf_unittest.repeated_bytes_extension" -) - -let ProtobufUnittest_Extensions_RepeatedGroup_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 46, - fieldName: "protobuf_unittest.repeatedgroup_extension" -) - -let ProtobufUnittest_Extensions_repeated_nested_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 48, - fieldName: "protobuf_unittest.repeated_nested_message_extension" -) - -let ProtobufUnittest_Extensions_repeated_foreign_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 49, - fieldName: "protobuf_unittest.repeated_foreign_message_extension" -) - -let ProtobufUnittest_Extensions_repeated_import_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 50, - fieldName: "protobuf_unittest.repeated_import_message_extension" -) - -let ProtobufUnittest_Extensions_repeated_nested_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 51, - fieldName: "protobuf_unittest.repeated_nested_enum_extension" -) - -let ProtobufUnittest_Extensions_repeated_foreign_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 52, - fieldName: "protobuf_unittest.repeated_foreign_enum_extension" -) - -let ProtobufUnittest_Extensions_repeated_import_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 53, - fieldName: "protobuf_unittest.repeated_import_enum_extension" -) - -let ProtobufUnittest_Extensions_repeated_string_piece_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 54, - fieldName: "protobuf_unittest.repeated_string_piece_extension" -) - -let ProtobufUnittest_Extensions_repeated_cord_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 55, - fieldName: "protobuf_unittest.repeated_cord_extension" -) - -let ProtobufUnittest_Extensions_repeated_lazy_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 57, - fieldName: "protobuf_unittest.repeated_lazy_message_extension" -) - -/// Singular with defaults -let ProtobufUnittest_Extensions_default_int32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 61, - fieldName: "protobuf_unittest.default_int32_extension" -) - -let ProtobufUnittest_Extensions_default_int64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 62, - fieldName: "protobuf_unittest.default_int64_extension" -) - -let ProtobufUnittest_Extensions_default_uint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 63, - fieldName: "protobuf_unittest.default_uint32_extension" -) - -let ProtobufUnittest_Extensions_default_uint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 64, - fieldName: "protobuf_unittest.default_uint64_extension" -) - -let ProtobufUnittest_Extensions_default_sint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 65, - fieldName: "protobuf_unittest.default_sint32_extension" -) - -let ProtobufUnittest_Extensions_default_sint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 66, - fieldName: "protobuf_unittest.default_sint64_extension" -) - -let ProtobufUnittest_Extensions_default_fixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 67, - fieldName: "protobuf_unittest.default_fixed32_extension" -) - -let ProtobufUnittest_Extensions_default_fixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 68, - fieldName: "protobuf_unittest.default_fixed64_extension" -) - -let ProtobufUnittest_Extensions_default_sfixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 69, - fieldName: "protobuf_unittest.default_sfixed32_extension" -) - -let ProtobufUnittest_Extensions_default_sfixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 70, - fieldName: "protobuf_unittest.default_sfixed64_extension" -) - -let ProtobufUnittest_Extensions_default_float_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 71, - fieldName: "protobuf_unittest.default_float_extension" -) - -let ProtobufUnittest_Extensions_default_double_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 72, - fieldName: "protobuf_unittest.default_double_extension" -) - -let ProtobufUnittest_Extensions_default_bool_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 73, - fieldName: "protobuf_unittest.default_bool_extension" -) - -let ProtobufUnittest_Extensions_default_string_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 74, - fieldName: "protobuf_unittest.default_string_extension" -) - -let ProtobufUnittest_Extensions_default_bytes_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 75, - fieldName: "protobuf_unittest.default_bytes_extension" -) - -let ProtobufUnittest_Extensions_default_nested_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 81, - fieldName: "protobuf_unittest.default_nested_enum_extension" -) - -let ProtobufUnittest_Extensions_default_foreign_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 82, - fieldName: "protobuf_unittest.default_foreign_enum_extension" -) - -let ProtobufUnittest_Extensions_default_import_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 83, - fieldName: "protobuf_unittest.default_import_enum_extension" -) - -let ProtobufUnittest_Extensions_default_string_piece_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 84, - fieldName: "protobuf_unittest.default_string_piece_extension" -) - -let ProtobufUnittest_Extensions_default_cord_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 85, - fieldName: "protobuf_unittest.default_cord_extension" -) - -/// For oneof test -let ProtobufUnittest_Extensions_oneof_uint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 111, - fieldName: "protobuf_unittest.oneof_uint32_extension" -) - -let ProtobufUnittest_Extensions_oneof_nested_message_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 112, - fieldName: "protobuf_unittest.oneof_nested_message_extension" -) - -let ProtobufUnittest_Extensions_oneof_string_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 113, - fieldName: "protobuf_unittest.oneof_string_extension" -) - -let ProtobufUnittest_Extensions_oneof_bytes_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 114, - fieldName: "protobuf_unittest.oneof_bytes_extension" -) - -let ProtobufUnittest_Extensions_my_extension_string = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestFieldOrderings>( - _protobuf_fieldNumber: 50, - fieldName: "protobuf_unittest.my_extension_string" -) - -let ProtobufUnittest_Extensions_my_extension_int = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestFieldOrderings>( - _protobuf_fieldNumber: 5, - fieldName: "protobuf_unittest.my_extension_int" -) - -let ProtobufUnittest_Extensions_packed_int32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 90, - fieldName: "protobuf_unittest.packed_int32_extension" -) - -let ProtobufUnittest_Extensions_packed_int64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 91, - fieldName: "protobuf_unittest.packed_int64_extension" -) - -let ProtobufUnittest_Extensions_packed_uint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 92, - fieldName: "protobuf_unittest.packed_uint32_extension" -) - -let ProtobufUnittest_Extensions_packed_uint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 93, - fieldName: "protobuf_unittest.packed_uint64_extension" -) - -let ProtobufUnittest_Extensions_packed_sint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 94, - fieldName: "protobuf_unittest.packed_sint32_extension" -) - -let ProtobufUnittest_Extensions_packed_sint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 95, - fieldName: "protobuf_unittest.packed_sint64_extension" -) - -let ProtobufUnittest_Extensions_packed_fixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 96, - fieldName: "protobuf_unittest.packed_fixed32_extension" -) - -let ProtobufUnittest_Extensions_packed_fixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 97, - fieldName: "protobuf_unittest.packed_fixed64_extension" -) - -let ProtobufUnittest_Extensions_packed_sfixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 98, - fieldName: "protobuf_unittest.packed_sfixed32_extension" -) - -let ProtobufUnittest_Extensions_packed_sfixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 99, - fieldName: "protobuf_unittest.packed_sfixed64_extension" -) - -let ProtobufUnittest_Extensions_packed_float_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 100, - fieldName: "protobuf_unittest.packed_float_extension" -) - -let ProtobufUnittest_Extensions_packed_double_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 101, - fieldName: "protobuf_unittest.packed_double_extension" -) - -let ProtobufUnittest_Extensions_packed_bool_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 102, - fieldName: "protobuf_unittest.packed_bool_extension" -) - -let ProtobufUnittest_Extensions_packed_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensions>( - _protobuf_fieldNumber: 103, - fieldName: "protobuf_unittest.packed_enum_extension" -) - -let ProtobufUnittest_Extensions_unpacked_int32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 90, - fieldName: "protobuf_unittest.unpacked_int32_extension" -) - -let ProtobufUnittest_Extensions_unpacked_int64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 91, - fieldName: "protobuf_unittest.unpacked_int64_extension" -) - -let ProtobufUnittest_Extensions_unpacked_uint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 92, - fieldName: "protobuf_unittest.unpacked_uint32_extension" -) - -let ProtobufUnittest_Extensions_unpacked_uint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 93, - fieldName: "protobuf_unittest.unpacked_uint64_extension" -) - -let ProtobufUnittest_Extensions_unpacked_sint32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 94, - fieldName: "protobuf_unittest.unpacked_sint32_extension" -) - -let ProtobufUnittest_Extensions_unpacked_sint64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 95, - fieldName: "protobuf_unittest.unpacked_sint64_extension" -) - -let ProtobufUnittest_Extensions_unpacked_fixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 96, - fieldName: "protobuf_unittest.unpacked_fixed32_extension" -) - -let ProtobufUnittest_Extensions_unpacked_fixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 97, - fieldName: "protobuf_unittest.unpacked_fixed64_extension" -) - -let ProtobufUnittest_Extensions_unpacked_sfixed32_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 98, - fieldName: "protobuf_unittest.unpacked_sfixed32_extension" -) - -let ProtobufUnittest_Extensions_unpacked_sfixed64_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 99, - fieldName: "protobuf_unittest.unpacked_sfixed64_extension" -) - -let ProtobufUnittest_Extensions_unpacked_float_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 100, - fieldName: "protobuf_unittest.unpacked_float_extension" -) - -let ProtobufUnittest_Extensions_unpacked_double_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 101, - fieldName: "protobuf_unittest.unpacked_double_extension" -) - -let ProtobufUnittest_Extensions_unpacked_bool_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 102, - fieldName: "protobuf_unittest.unpacked_bool_extension" -) - -let ProtobufUnittest_Extensions_unpacked_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestUnpackedExtensions>( - _protobuf_fieldNumber: 103, - fieldName: "protobuf_unittest.unpacked_enum_extension" -) - -let ProtobufUnittest_Extensions_test_all_types = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestHugeFieldNumbers>( - _protobuf_fieldNumber: 536860000, - fieldName: "protobuf_unittest.test_all_types" -) - -let ProtobufUnittest_Extensions_test_extension_inside_table_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestExtensionInsideTable>( - _protobuf_fieldNumber: 5, - fieldName: "protobuf_unittest.test_extension_inside_table_extension" -) - -extension ProtobufUnittest_TestNestedExtension { - enum Extensions { - /// Check for bug where string extensions declared in tested scope did not - /// compile. - static let test = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 1002, - fieldName: "protobuf_unittest.TestNestedExtension.test" - ) - - /// Used to test if generated extension name is correct when there are - /// underscores. - static let nested_string_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 1003, - fieldName: "protobuf_unittest.TestNestedExtension.nested_string_extension" - ) - - static let OptionalGroup_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestGroupExtension>( - _protobuf_fieldNumber: 16, - fieldName: "protobuf_unittest.TestNestedExtension.optionalgroup_extension" - ) - - static let optional_foreign_enum_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestGroupExtension>( - _protobuf_fieldNumber: 22, - fieldName: "protobuf_unittest.TestNestedExtension.optional_foreign_enum_extension" - ) - } -} - -extension ProtobufUnittest_TestRequired { - enum Extensions { - static let single = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 1000, - fieldName: "protobuf_unittest.TestRequired.single" - ) - - static let multi = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensions>( - _protobuf_fieldNumber: 1001, - fieldName: "protobuf_unittest.TestRequired.multi" - ) - } -} - -extension ProtobufUnittest_TestExtensionOrderings1 { - enum Extensions { - static let test_ext_orderings1 = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestFieldOrderings>( - _protobuf_fieldNumber: 13, - fieldName: "protobuf_unittest.TestExtensionOrderings1.test_ext_orderings1" - ) - } -} - -extension ProtobufUnittest_TestExtensionOrderings2 { - enum Extensions { - static let test_ext_orderings2 = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestFieldOrderings>( - _protobuf_fieldNumber: 12, - fieldName: "protobuf_unittest.TestExtensionOrderings2.test_ext_orderings2" - ) - } -} - -extension ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3 { - enum Extensions { - static let test_ext_orderings3 = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestFieldOrderings>( - _protobuf_fieldNumber: 14, - fieldName: "protobuf_unittest.TestExtensionOrderings2.TestExtensionOrderings3.test_ext_orderings3" - ) - } -} - -extension ProtobufUnittest_TestParsingMerge { - enum Extensions { - static let optional_ext = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestParsingMerge>( - _protobuf_fieldNumber: 1000, - fieldName: "protobuf_unittest.TestParsingMerge.optional_ext" - ) - - static let repeated_ext = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestParsingMerge>( - _protobuf_fieldNumber: 1001, - fieldName: "protobuf_unittest.TestParsingMerge.repeated_ext" - ) - } -} - -extension ProtobufUnittest_TestExtensionRangeSerialize { - enum Extensions { - static let bar_one = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestExtensionRangeSerialize>( - _protobuf_fieldNumber: 2, - fieldName: "protobuf_unittest.TestExtensionRangeSerialize.bar_one" - ) - - static let bar_two = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestExtensionRangeSerialize>( - _protobuf_fieldNumber: 4, - fieldName: "protobuf_unittest.TestExtensionRangeSerialize.bar_two" - ) - - static let bar_three = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestExtensionRangeSerialize>( - _protobuf_fieldNumber: 10, - fieldName: "protobuf_unittest.TestExtensionRangeSerialize.bar_three" - ) - - static let bar_four = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestExtensionRangeSerialize>( - _protobuf_fieldNumber: 15, - fieldName: "protobuf_unittest.TestExtensionRangeSerialize.bar_four" - ) - - static let bar_five = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestExtensionRangeSerialize>( - _protobuf_fieldNumber: 19, - fieldName: "protobuf_unittest.TestExtensionRangeSerialize.bar_five" - ) - } -} - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest" - -extension ProtobufUnittest_ForeignEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 4: .same(proto: "FOREIGN_FOO"), - 5: .same(proto: "FOREIGN_BAR"), - 6: .same(proto: "FOREIGN_BAZ"), - ] -} - -extension ProtobufUnittest_TestEnumWithDupValue: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .aliased(proto: "FOO1", aliases: ["FOO2"]), - 2: .aliased(proto: "BAR1", aliases: ["BAR2"]), - 3: .same(proto: "BAZ"), - ] -} - -extension ProtobufUnittest_TestSparseEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -53452: .same(proto: "SPARSE_E"), - -15: .same(proto: "SPARSE_D"), - 0: .same(proto: "SPARSE_F"), - 2: .same(proto: "SPARSE_G"), - 123: .same(proto: "SPARSE_A"), - 62374: .same(proto: "SPARSE_B"), - 12589234: .same(proto: "SPARSE_C"), - ] -} - -extension ProtobufUnittest_VeryLargeEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ENUM_LABEL_DEFAULT"), - 1: .same(proto: "ENUM_LABEL_1"), - 2: .same(proto: "ENUM_LABEL_2"), - 3: .same(proto: "ENUM_LABEL_3"), - 4: .same(proto: "ENUM_LABEL_4"), - 5: .same(proto: "ENUM_LABEL_5"), - 6: .same(proto: "ENUM_LABEL_6"), - 7: .same(proto: "ENUM_LABEL_7"), - 8: .same(proto: "ENUM_LABEL_8"), - 9: .same(proto: "ENUM_LABEL_9"), - 10: .same(proto: "ENUM_LABEL_10"), - 11: .same(proto: "ENUM_LABEL_11"), - 12: .same(proto: "ENUM_LABEL_12"), - 13: .same(proto: "ENUM_LABEL_13"), - 14: .same(proto: "ENUM_LABEL_14"), - 15: .same(proto: "ENUM_LABEL_15"), - 16: .same(proto: "ENUM_LABEL_16"), - 17: .same(proto: "ENUM_LABEL_17"), - 18: .same(proto: "ENUM_LABEL_18"), - 19: .same(proto: "ENUM_LABEL_19"), - 20: .same(proto: "ENUM_LABEL_20"), - 21: .same(proto: "ENUM_LABEL_21"), - 22: .same(proto: "ENUM_LABEL_22"), - 23: .same(proto: "ENUM_LABEL_23"), - 24: .same(proto: "ENUM_LABEL_24"), - 25: .same(proto: "ENUM_LABEL_25"), - 26: .same(proto: "ENUM_LABEL_26"), - 27: .same(proto: "ENUM_LABEL_27"), - 28: .same(proto: "ENUM_LABEL_28"), - 29: .same(proto: "ENUM_LABEL_29"), - 30: .same(proto: "ENUM_LABEL_30"), - 31: .same(proto: "ENUM_LABEL_31"), - 32: .same(proto: "ENUM_LABEL_32"), - 33: .same(proto: "ENUM_LABEL_33"), - 34: .same(proto: "ENUM_LABEL_34"), - 35: .same(proto: "ENUM_LABEL_35"), - 36: .same(proto: "ENUM_LABEL_36"), - 37: .same(proto: "ENUM_LABEL_37"), - 38: .same(proto: "ENUM_LABEL_38"), - 39: .same(proto: "ENUM_LABEL_39"), - 40: .same(proto: "ENUM_LABEL_40"), - 41: .same(proto: "ENUM_LABEL_41"), - 42: .same(proto: "ENUM_LABEL_42"), - 43: .same(proto: "ENUM_LABEL_43"), - 44: .same(proto: "ENUM_LABEL_44"), - 45: .same(proto: "ENUM_LABEL_45"), - 46: .same(proto: "ENUM_LABEL_46"), - 47: .same(proto: "ENUM_LABEL_47"), - 48: .same(proto: "ENUM_LABEL_48"), - 49: .same(proto: "ENUM_LABEL_49"), - 50: .same(proto: "ENUM_LABEL_50"), - 51: .same(proto: "ENUM_LABEL_51"), - 52: .same(proto: "ENUM_LABEL_52"), - 53: .same(proto: "ENUM_LABEL_53"), - 54: .same(proto: "ENUM_LABEL_54"), - 55: .same(proto: "ENUM_LABEL_55"), - 56: .same(proto: "ENUM_LABEL_56"), - 57: .same(proto: "ENUM_LABEL_57"), - 58: .same(proto: "ENUM_LABEL_58"), - 59: .same(proto: "ENUM_LABEL_59"), - 60: .same(proto: "ENUM_LABEL_60"), - 61: .same(proto: "ENUM_LABEL_61"), - 62: .same(proto: "ENUM_LABEL_62"), - 63: .same(proto: "ENUM_LABEL_63"), - 64: .same(proto: "ENUM_LABEL_64"), - 65: .same(proto: "ENUM_LABEL_65"), - 66: .same(proto: "ENUM_LABEL_66"), - 67: .same(proto: "ENUM_LABEL_67"), - 68: .same(proto: "ENUM_LABEL_68"), - 69: .same(proto: "ENUM_LABEL_69"), - 70: .same(proto: "ENUM_LABEL_70"), - 71: .same(proto: "ENUM_LABEL_71"), - 72: .same(proto: "ENUM_LABEL_72"), - 73: .same(proto: "ENUM_LABEL_73"), - 74: .same(proto: "ENUM_LABEL_74"), - 75: .same(proto: "ENUM_LABEL_75"), - 76: .same(proto: "ENUM_LABEL_76"), - 77: .same(proto: "ENUM_LABEL_77"), - 78: .same(proto: "ENUM_LABEL_78"), - 79: .same(proto: "ENUM_LABEL_79"), - 80: .same(proto: "ENUM_LABEL_80"), - 81: .same(proto: "ENUM_LABEL_81"), - 82: .same(proto: "ENUM_LABEL_82"), - 83: .same(proto: "ENUM_LABEL_83"), - 84: .same(proto: "ENUM_LABEL_84"), - 85: .same(proto: "ENUM_LABEL_85"), - 86: .same(proto: "ENUM_LABEL_86"), - 87: .same(proto: "ENUM_LABEL_87"), - 88: .same(proto: "ENUM_LABEL_88"), - 89: .same(proto: "ENUM_LABEL_89"), - 90: .same(proto: "ENUM_LABEL_90"), - 91: .same(proto: "ENUM_LABEL_91"), - 92: .same(proto: "ENUM_LABEL_92"), - 93: .same(proto: "ENUM_LABEL_93"), - 94: .same(proto: "ENUM_LABEL_94"), - 95: .same(proto: "ENUM_LABEL_95"), - 96: .same(proto: "ENUM_LABEL_96"), - 97: .same(proto: "ENUM_LABEL_97"), - 98: .same(proto: "ENUM_LABEL_98"), - 99: .same(proto: "ENUM_LABEL_99"), - 100: .same(proto: "ENUM_LABEL_100"), - ] -} - -extension ProtobufUnittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 16: .unique(proto: "OptionalGroup", json: "optionalgroup"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "optional_foreign_message"), - 20: .standard(proto: "optional_import_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "optional_foreign_enum"), - 23: .standard(proto: "optional_import_enum"), - 24: .standard(proto: "optional_string_piece"), - 25: .standard(proto: "optional_cord"), - 26: .standard(proto: "optional_public_import_message"), - 27: .standard(proto: "optional_lazy_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 46: .unique(proto: "RepeatedGroup", json: "repeatedgroup"), - 48: .standard(proto: "repeated_nested_message"), - 49: .standard(proto: "repeated_foreign_message"), - 50: .standard(proto: "repeated_import_message"), - 51: .standard(proto: "repeated_nested_enum"), - 52: .standard(proto: "repeated_foreign_enum"), - 53: .standard(proto: "repeated_import_enum"), - 54: .standard(proto: "repeated_string_piece"), - 55: .standard(proto: "repeated_cord"), - 57: .standard(proto: "repeated_lazy_message"), - 61: .standard(proto: "default_int32"), - 62: .standard(proto: "default_int64"), - 63: .standard(proto: "default_uint32"), - 64: .standard(proto: "default_uint64"), - 65: .standard(proto: "default_sint32"), - 66: .standard(proto: "default_sint64"), - 67: .standard(proto: "default_fixed32"), - 68: .standard(proto: "default_fixed64"), - 69: .standard(proto: "default_sfixed32"), - 70: .standard(proto: "default_sfixed64"), - 71: .standard(proto: "default_float"), - 72: .standard(proto: "default_double"), - 73: .standard(proto: "default_bool"), - 74: .standard(proto: "default_string"), - 75: .standard(proto: "default_bytes"), - 81: .standard(proto: "default_nested_enum"), - 82: .standard(proto: "default_foreign_enum"), - 83: .standard(proto: "default_import_enum"), - 84: .standard(proto: "default_string_piece"), - 85: .standard(proto: "default_cord"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - ] - - fileprivate class _StorageClass { - var _optionalInt32: Int32? = nil - var _optionalInt64: Int64? = nil - var _optionalUint32: UInt32? = nil - var _optionalUint64: UInt64? = nil - var _optionalSint32: Int32? = nil - var _optionalSint64: Int64? = nil - var _optionalFixed32: UInt32? = nil - var _optionalFixed64: UInt64? = nil - var _optionalSfixed32: Int32? = nil - var _optionalSfixed64: Int64? = nil - var _optionalFloat: Float? = nil - var _optionalDouble: Double? = nil - var _optionalBool: Bool? = nil - var _optionalString: String? = nil - var _optionalBytes: Data? = nil - var _optionalGroup: ProtobufUnittest_TestAllTypes.OptionalGroup? = nil - var _optionalNestedMessage: ProtobufUnittest_TestAllTypes.NestedMessage? = nil - var _optionalForeignMessage: ProtobufUnittest_ForeignMessage? = nil - var _optionalImportMessage: ProtobufUnittestImport_ImportMessage? = nil - var _optionalNestedEnum: ProtobufUnittest_TestAllTypes.NestedEnum? = nil - var _optionalForeignEnum: ProtobufUnittest_ForeignEnum? = nil - var _optionalImportEnum: ProtobufUnittestImport_ImportEnum? = nil - var _optionalStringPiece: String? = nil - var _optionalCord: String? = nil - var _optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessage? = nil - var _optionalLazyMessage: ProtobufUnittest_TestAllTypes.NestedMessage? = nil - var _repeatedInt32: [Int32] = [] - var _repeatedInt64: [Int64] = [] - var _repeatedUint32: [UInt32] = [] - var _repeatedUint64: [UInt64] = [] - var _repeatedSint32: [Int32] = [] - var _repeatedSint64: [Int64] = [] - var _repeatedFixed32: [UInt32] = [] - var _repeatedFixed64: [UInt64] = [] - var _repeatedSfixed32: [Int32] = [] - var _repeatedSfixed64: [Int64] = [] - var _repeatedFloat: [Float] = [] - var _repeatedDouble: [Double] = [] - var _repeatedBool: [Bool] = [] - var _repeatedString: [String] = [] - var _repeatedBytes: [Data] = [] - var _repeatedGroup: [ProtobufUnittest_TestAllTypes.RepeatedGroup] = [] - var _repeatedNestedMessage: [ProtobufUnittest_TestAllTypes.NestedMessage] = [] - var _repeatedForeignMessage: [ProtobufUnittest_ForeignMessage] = [] - var _repeatedImportMessage: [ProtobufUnittestImport_ImportMessage] = [] - var _repeatedNestedEnum: [ProtobufUnittest_TestAllTypes.NestedEnum] = [] - var _repeatedForeignEnum: [ProtobufUnittest_ForeignEnum] = [] - var _repeatedImportEnum: [ProtobufUnittestImport_ImportEnum] = [] - var _repeatedStringPiece: [String] = [] - var _repeatedCord: [String] = [] - var _repeatedLazyMessage: [ProtobufUnittest_TestAllTypes.NestedMessage] = [] - var _defaultInt32: Int32? = nil - var _defaultInt64: Int64? = nil - var _defaultUint32: UInt32? = nil - var _defaultUint64: UInt64? = nil - var _defaultSint32: Int32? = nil - var _defaultSint64: Int64? = nil - var _defaultFixed32: UInt32? = nil - var _defaultFixed64: UInt64? = nil - var _defaultSfixed32: Int32? = nil - var _defaultSfixed64: Int64? = nil - var _defaultFloat: Float? = nil - var _defaultDouble: Double? = nil - var _defaultBool: Bool? = nil - var _defaultString: String? = nil - var _defaultBytes: Data? = nil - var _defaultNestedEnum: ProtobufUnittest_TestAllTypes.NestedEnum? = nil - var _defaultForeignEnum: ProtobufUnittest_ForeignEnum? = nil - var _defaultImportEnum: ProtobufUnittestImport_ImportEnum? = nil - var _defaultStringPiece: String? = nil - var _defaultCord: String? = nil - var _oneofField: ProtobufUnittest_TestAllTypes.OneOf_OneofField? - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _optionalInt32 = source._optionalInt32 - _optionalInt64 = source._optionalInt64 - _optionalUint32 = source._optionalUint32 - _optionalUint64 = source._optionalUint64 - _optionalSint32 = source._optionalSint32 - _optionalSint64 = source._optionalSint64 - _optionalFixed32 = source._optionalFixed32 - _optionalFixed64 = source._optionalFixed64 - _optionalSfixed32 = source._optionalSfixed32 - _optionalSfixed64 = source._optionalSfixed64 - _optionalFloat = source._optionalFloat - _optionalDouble = source._optionalDouble - _optionalBool = source._optionalBool - _optionalString = source._optionalString - _optionalBytes = source._optionalBytes - _optionalGroup = source._optionalGroup - _optionalNestedMessage = source._optionalNestedMessage - _optionalForeignMessage = source._optionalForeignMessage - _optionalImportMessage = source._optionalImportMessage - _optionalNestedEnum = source._optionalNestedEnum - _optionalForeignEnum = source._optionalForeignEnum - _optionalImportEnum = source._optionalImportEnum - _optionalStringPiece = source._optionalStringPiece - _optionalCord = source._optionalCord - _optionalPublicImportMessage = source._optionalPublicImportMessage - _optionalLazyMessage = source._optionalLazyMessage - _repeatedInt32 = source._repeatedInt32 - _repeatedInt64 = source._repeatedInt64 - _repeatedUint32 = source._repeatedUint32 - _repeatedUint64 = source._repeatedUint64 - _repeatedSint32 = source._repeatedSint32 - _repeatedSint64 = source._repeatedSint64 - _repeatedFixed32 = source._repeatedFixed32 - _repeatedFixed64 = source._repeatedFixed64 - _repeatedSfixed32 = source._repeatedSfixed32 - _repeatedSfixed64 = source._repeatedSfixed64 - _repeatedFloat = source._repeatedFloat - _repeatedDouble = source._repeatedDouble - _repeatedBool = source._repeatedBool - _repeatedString = source._repeatedString - _repeatedBytes = source._repeatedBytes - _repeatedGroup = source._repeatedGroup - _repeatedNestedMessage = source._repeatedNestedMessage - _repeatedForeignMessage = source._repeatedForeignMessage - _repeatedImportMessage = source._repeatedImportMessage - _repeatedNestedEnum = source._repeatedNestedEnum - _repeatedForeignEnum = source._repeatedForeignEnum - _repeatedImportEnum = source._repeatedImportEnum - _repeatedStringPiece = source._repeatedStringPiece - _repeatedCord = source._repeatedCord - _repeatedLazyMessage = source._repeatedLazyMessage - _defaultInt32 = source._defaultInt32 - _defaultInt64 = source._defaultInt64 - _defaultUint32 = source._defaultUint32 - _defaultUint64 = source._defaultUint64 - _defaultSint32 = source._defaultSint32 - _defaultSint64 = source._defaultSint64 - _defaultFixed32 = source._defaultFixed32 - _defaultFixed64 = source._defaultFixed64 - _defaultSfixed32 = source._defaultSfixed32 - _defaultSfixed64 = source._defaultSfixed64 - _defaultFloat = source._defaultFloat - _defaultDouble = source._defaultDouble - _defaultBool = source._defaultBool - _defaultString = source._defaultString - _defaultBytes = source._defaultBytes - _defaultNestedEnum = source._defaultNestedEnum - _defaultForeignEnum = source._defaultForeignEnum - _defaultImportEnum = source._defaultImportEnum - _defaultStringPiece = source._defaultStringPiece - _defaultCord = source._defaultCord - _oneofField = source._oneofField - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._optionalInt32) }() - case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() - case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() - case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() - case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() - case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() - case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() - case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() - case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() - case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() - case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() - case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() - case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() - case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() - case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() - case 16: try { try decoder.decodeSingularGroupField(value: &_storage._optionalGroup) }() - case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() - case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() - case 20: try { try decoder.decodeSingularMessageField(value: &_storage._optionalImportMessage) }() - case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() - case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() - case 23: try { try decoder.decodeSingularEnumField(value: &_storage._optionalImportEnum) }() - case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() - case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() - case 26: try { try decoder.decodeSingularMessageField(value: &_storage._optionalPublicImportMessage) }() - case 27: try { try decoder.decodeSingularMessageField(value: &_storage._optionalLazyMessage) }() - case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() - case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() - case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() - case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() - case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() - case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() - case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() - case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() - case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() - case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() - case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() - case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() - case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() - case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() - case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() - case 46: try { try decoder.decodeRepeatedGroupField(value: &_storage._repeatedGroup) }() - case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() - case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() - case 50: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedImportMessage) }() - case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() - case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() - case 53: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedImportEnum) }() - case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() - case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() - case 57: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedLazyMessage) }() - case 61: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() - case 62: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() - case 63: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() - case 64: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() - case 65: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() - case 66: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() - case 67: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() - case 68: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() - case 69: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() - case 70: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() - case 71: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() - case 72: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() - case 73: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() - case 74: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() - case 75: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() - case 81: try { try decoder.decodeSingularEnumField(value: &_storage._defaultNestedEnum) }() - case 82: try { try decoder.decodeSingularEnumField(value: &_storage._defaultForeignEnum) }() - case 83: try { try decoder.decodeSingularEnumField(value: &_storage._defaultImportEnum) }() - case 84: try { try decoder.decodeSingularStringField(value: &_storage._defaultStringPiece) }() - case 85: try { try decoder.decodeSingularStringField(value: &_storage._defaultCord) }() - case 111: try { - var v: UInt32? - try decoder.decodeSingularUInt32Field(value: &v) - if let v = v { - if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofUint32(v) - } - }() - case 112: try { - var v: ProtobufUnittest_TestAllTypes.NestedMessage? - var hadOneofValue = false - if let current = _storage._oneofField { - hadOneofValue = true - if case .oneofNestedMessage(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofNestedMessage(v) - } - }() - case 113: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofString(v) - } - }() - case 114: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofBytes(v) - } - }() - default: break - } - } - } - } - - func traverse(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._optionalInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._optionalInt64 { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) - } }() - try { if let v = _storage._optionalUint32 { - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) - } }() - try { if let v = _storage._optionalUint64 { - try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) - } }() - try { if let v = _storage._optionalSint32 { - try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) - } }() - try { if let v = _storage._optionalSint64 { - try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) - } }() - try { if let v = _storage._optionalFixed32 { - try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) - } }() - try { if let v = _storage._optionalFixed64 { - try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) - } }() - try { if let v = _storage._optionalSfixed32 { - try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) - } }() - try { if let v = _storage._optionalSfixed64 { - try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) - } }() - try { if let v = _storage._optionalFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 11) - } }() - try { if let v = _storage._optionalDouble { - try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) - } }() - try { if let v = _storage._optionalBool { - try visitor.visitSingularBoolField(value: v, fieldNumber: 13) - } }() - try { if let v = _storage._optionalString { - try visitor.visitSingularStringField(value: v, fieldNumber: 14) - } }() - try { if let v = _storage._optionalBytes { - try visitor.visitSingularBytesField(value: v, fieldNumber: 15) - } }() - try { if let v = _storage._optionalGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 16) - } }() - try { if let v = _storage._optionalNestedMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 18) - } }() - try { if let v = _storage._optionalForeignMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 19) - } }() - try { if let v = _storage._optionalImportMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 20) - } }() - try { if let v = _storage._optionalNestedEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 21) - } }() - try { if let v = _storage._optionalForeignEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 22) - } }() - try { if let v = _storage._optionalImportEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 23) - } }() - try { if let v = _storage._optionalStringPiece { - try visitor.visitSingularStringField(value: v, fieldNumber: 24) - } }() - try { if let v = _storage._optionalCord { - try visitor.visitSingularStringField(value: v, fieldNumber: 25) - } }() - try { if let v = _storage._optionalPublicImportMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 26) - } }() - try { if let v = _storage._optionalLazyMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 27) - } }() - if !_storage._repeatedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) - } - if !_storage._repeatedInt64.isEmpty { - try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) - } - if !_storage._repeatedUint32.isEmpty { - try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) - } - if !_storage._repeatedUint64.isEmpty { - try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) - } - if !_storage._repeatedSint32.isEmpty { - try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) - } - if !_storage._repeatedSint64.isEmpty { - try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) - } - if !_storage._repeatedFixed32.isEmpty { - try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) - } - if !_storage._repeatedFixed64.isEmpty { - try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) - } - if !_storage._repeatedSfixed32.isEmpty { - try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) - } - if !_storage._repeatedSfixed64.isEmpty { - try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) - } - if !_storage._repeatedFloat.isEmpty { - try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) - } - if !_storage._repeatedDouble.isEmpty { - try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) - } - if !_storage._repeatedBool.isEmpty { - try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43) - } - if !_storage._repeatedString.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) - } - if !_storage._repeatedBytes.isEmpty { - try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) - } - if !_storage._repeatedGroup.isEmpty { - try visitor.visitRepeatedGroupField(value: _storage._repeatedGroup, fieldNumber: 46) - } - if !_storage._repeatedNestedMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) - } - if !_storage._repeatedForeignMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) - } - if !_storage._repeatedImportMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedImportMessage, fieldNumber: 50) - } - if !_storage._repeatedNestedEnum.isEmpty { - try visitor.visitRepeatedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) - } - if !_storage._repeatedForeignEnum.isEmpty { - try visitor.visitRepeatedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) - } - if !_storage._repeatedImportEnum.isEmpty { - try visitor.visitRepeatedEnumField(value: _storage._repeatedImportEnum, fieldNumber: 53) - } - if !_storage._repeatedStringPiece.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) - } - if !_storage._repeatedCord.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) - } - if !_storage._repeatedLazyMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedLazyMessage, fieldNumber: 57) - } - try { if let v = _storage._defaultInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 61) - } }() - try { if let v = _storage._defaultInt64 { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 62) - } }() - try { if let v = _storage._defaultUint32 { - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63) - } }() - try { if let v = _storage._defaultUint64 { - try visitor.visitSingularUInt64Field(value: v, fieldNumber: 64) - } }() - try { if let v = _storage._defaultSint32 { - try visitor.visitSingularSInt32Field(value: v, fieldNumber: 65) - } }() - try { if let v = _storage._defaultSint64 { - try visitor.visitSingularSInt64Field(value: v, fieldNumber: 66) - } }() - try { if let v = _storage._defaultFixed32 { - try visitor.visitSingularFixed32Field(value: v, fieldNumber: 67) - } }() - try { if let v = _storage._defaultFixed64 { - try visitor.visitSingularFixed64Field(value: v, fieldNumber: 68) - } }() - try { if let v = _storage._defaultSfixed32 { - try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 69) - } }() - try { if let v = _storage._defaultSfixed64 { - try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 70) - } }() - try { if let v = _storage._defaultFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 71) - } }() - try { if let v = _storage._defaultDouble { - try visitor.visitSingularDoubleField(value: v, fieldNumber: 72) - } }() - try { if let v = _storage._defaultBool { - try visitor.visitSingularBoolField(value: v, fieldNumber: 73) - } }() - try { if let v = _storage._defaultString { - try visitor.visitSingularStringField(value: v, fieldNumber: 74) - } }() - try { if let v = _storage._defaultBytes { - try visitor.visitSingularBytesField(value: v, fieldNumber: 75) - } }() - try { if let v = _storage._defaultNestedEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 81) - } }() - try { if let v = _storage._defaultForeignEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 82) - } }() - try { if let v = _storage._defaultImportEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 83) - } }() - try { if let v = _storage._defaultStringPiece { - try visitor.visitSingularStringField(value: v, fieldNumber: 84) - } }() - try { if let v = _storage._defaultCord { - try visitor.visitSingularStringField(value: v, fieldNumber: 85) - } }() - switch _storage._oneofField { - case .oneofUint32?: try { - guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) - }() - case .oneofNestedMessage?: try { - guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 112) - }() - case .oneofString?: try { - guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 113) - }() - case .oneofBytes?: try { - guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 114) - }() - case nil: break - } - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllTypes, rhs: ProtobufUnittest_TestAllTypes) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} - if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} - if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} - if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} - if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} - if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} - if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} - if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} - if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} - if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} - if _storage._optionalFloat != rhs_storage._optionalFloat {return false} - if _storage._optionalDouble != rhs_storage._optionalDouble {return false} - if _storage._optionalBool != rhs_storage._optionalBool {return false} - if _storage._optionalString != rhs_storage._optionalString {return false} - if _storage._optionalBytes != rhs_storage._optionalBytes {return false} - if _storage._optionalGroup != rhs_storage._optionalGroup {return false} - if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} - if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} - if _storage._optionalImportMessage != rhs_storage._optionalImportMessage {return false} - if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} - if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} - if _storage._optionalImportEnum != rhs_storage._optionalImportEnum {return false} - if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} - if _storage._optionalCord != rhs_storage._optionalCord {return false} - if _storage._optionalPublicImportMessage != rhs_storage._optionalPublicImportMessage {return false} - if _storage._optionalLazyMessage != rhs_storage._optionalLazyMessage {return false} - if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} - if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} - if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} - if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} - if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} - if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} - if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} - if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} - if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} - if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} - if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} - if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} - if _storage._repeatedBool != rhs_storage._repeatedBool {return false} - if _storage._repeatedString != rhs_storage._repeatedString {return false} - if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} - if _storage._repeatedGroup != rhs_storage._repeatedGroup {return false} - if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} - if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} - if _storage._repeatedImportMessage != rhs_storage._repeatedImportMessage {return false} - if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} - if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} - if _storage._repeatedImportEnum != rhs_storage._repeatedImportEnum {return false} - if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} - if _storage._repeatedCord != rhs_storage._repeatedCord {return false} - if _storage._repeatedLazyMessage != rhs_storage._repeatedLazyMessage {return false} - if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} - if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} - if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} - if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} - if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} - if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} - if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} - if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} - if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} - if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} - if _storage._defaultFloat != rhs_storage._defaultFloat {return false} - if _storage._defaultDouble != rhs_storage._defaultDouble {return false} - if _storage._defaultBool != rhs_storage._defaultBool {return false} - if _storage._defaultString != rhs_storage._defaultString {return false} - if _storage._defaultBytes != rhs_storage._defaultBytes {return false} - if _storage._defaultNestedEnum != rhs_storage._defaultNestedEnum {return false} - if _storage._defaultForeignEnum != rhs_storage._defaultForeignEnum {return false} - if _storage._defaultImportEnum != rhs_storage._defaultImportEnum {return false} - if _storage._defaultStringPiece != rhs_storage._defaultStringPiece {return false} - if _storage._defaultCord != rhs_storage._defaultCord {return false} - if _storage._oneofField != rhs_storage._oneofField {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestAllTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -1: .same(proto: "NEG"), - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - 3: .same(proto: "BAZ"), - ] -} - -extension ProtobufUnittest_TestAllTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestAllTypes.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - ] - - 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._bb) }() - 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 - try { if let v = self._bb { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllTypes.NestedMessage, rhs: ProtobufUnittest_TestAllTypes.NestedMessage) -> Bool { - if lhs._bb != rhs._bb {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestAllTypes.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestAllTypes.protoMessageName + ".OptionalGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 17: .same(proto: "a"), - ] - - 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllTypes.OptionalGroup, rhs: ProtobufUnittest_TestAllTypes.OptionalGroup) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestAllTypes.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestAllTypes.protoMessageName + ".RepeatedGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 47: .same(proto: "a"), - ] - - 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 47: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllTypes.RepeatedGroup, rhs: ProtobufUnittest_TestAllTypes.RepeatedGroup) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".NestedTestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "child"), - 2: .same(proto: "payload"), - 3: .standard(proto: "repeated_child"), - ] - - fileprivate class _StorageClass { - var _child: ProtobufUnittest_NestedTestAllTypes? = nil - var _payload: ProtobufUnittest_TestAllTypes? = nil - var _repeatedChild: [ProtobufUnittest_NestedTestAllTypes] = [] - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _child = source._child - _payload = source._payload - _repeatedChild = source._repeatedChild - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._child) }() - case 2: try { try decoder.decodeSingularMessageField(value: &_storage._payload) }() - case 3: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedChild) }() - default: break - } - } - } - } - - func traverse(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._child { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._payload { - try visitor.visitSingularMessageField(value: v, fieldNumber: 2) - } }() - if !_storage._repeatedChild.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedChild, fieldNumber: 3) - } - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_NestedTestAllTypes, rhs: ProtobufUnittest_NestedTestAllTypes) -> 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._child != rhs_storage._child {return false} - if _storage._payload != rhs_storage._payload {return false} - if _storage._repeatedChild != rhs_storage._repeatedChild {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestDeprecatedFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestDeprecatedFields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "deprecated_int32"), - 2: .standard(proto: "deprecated_int32_in_oneof"), - ] - - 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._deprecatedInt32) }() - case 2: try { - var v: Int32? - try decoder.decodeSingularInt32Field(value: &v) - if let v = v { - if self.oneofFields != nil {try decoder.handleConflictingOneOf()} - self.oneofFields = .deprecatedInt32InOneof(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 - try { if let v = self._deprecatedInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if case .deprecatedInt32InOneof(let v)? = self.oneofFields { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestDeprecatedFields, rhs: ProtobufUnittest_TestDeprecatedFields) -> Bool { - if lhs._deprecatedInt32 != rhs._deprecatedInt32 {return false} - if lhs.oneofFields != rhs.oneofFields {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestDeprecatedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestDeprecatedMessage" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestDeprecatedMessage, rhs: ProtobufUnittest_TestDeprecatedMessage) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ForeignMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - 2: .same(proto: "d"), - ] - - 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._c) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &self._d) }() - 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 - try { if let v = self._c { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._d { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_ForeignMessage, rhs: ProtobufUnittest_ForeignMessage) -> Bool { - if lhs._c != rhs._c {return false} - if lhs._d != rhs._d {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestReservedFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestReservedFields" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestReservedFields, rhs: ProtobufUnittest_TestReservedFields) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestAllExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestAllExtensions" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestAllExtensions.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllExtensions, rhs: ProtobufUnittest_TestAllExtensions) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_OptionalGroup_extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".OptionalGroup_extension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 17: .same(proto: "a"), - ] - - 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_OptionalGroup_extension, rhs: ProtobufUnittest_OptionalGroup_extension) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_RepeatedGroup_extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".RepeatedGroup_extension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 47: .same(proto: "a"), - ] - - 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 47: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_RepeatedGroup_extension, rhs: ProtobufUnittest_RepeatedGroup_extension) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 16: .unique(proto: "OptionalGroup", json: "optionalgroup"), - 22: .standard(proto: "optional_foreign_enum"), - ] - - 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 16: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() - case 22: try { try decoder.decodeSingularEnumField(value: &self._optionalForeignEnum) }() - 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 - try { if let v = self._optionalGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 16) - } }() - try { if let v = self._optionalForeignEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 22) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestGroup, rhs: ProtobufUnittest_TestGroup) -> Bool { - if lhs._optionalGroup != rhs._optionalGroup {return false} - if lhs._optionalForeignEnum != rhs._optionalForeignEnum {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestGroup.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestGroup.protoMessageName + ".OptionalGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 17: .same(proto: "a"), - ] - - 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestGroup.OptionalGroup, rhs: ProtobufUnittest_TestGroup.OptionalGroup) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestGroupExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestGroupExtension" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestGroupExtension.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestGroupExtension, rhs: ProtobufUnittest_TestGroupExtension) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestNestedExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestNestedExtension" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestNestedExtension, rhs: ProtobufUnittest_TestNestedExtension) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestNestedExtension.OptionalGroup_extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestNestedExtension.protoMessageName + ".OptionalGroup_extension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 17: .same(proto: "a"), - ] - - 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestNestedExtension.OptionalGroup_extension, rhs: ProtobufUnittest_TestNestedExtension.OptionalGroup_extension) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestChildExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestChildExtension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 2: .same(proto: "b"), - 3: .standard(proto: "optional_extension"), - ] - - public var isInitialized: Bool { - if let v = self._optionalExtension, !v.isInitialized {return false} - return true - } - - 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._a) }() - case 2: try { try decoder.decodeSingularStringField(value: &self._b) }() - case 3: try { try decoder.decodeSingularMessageField(value: &self._optionalExtension) }() - 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 - try { if let v = self._a { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try { if let v = self._b { - try visitor.visitSingularStringField(value: v, fieldNumber: 2) - } }() - try { if let v = self._optionalExtension { - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestChildExtension, rhs: ProtobufUnittest_TestChildExtension) -> Bool { - if lhs._a != rhs._a {return false} - if lhs._b != rhs._b {return false} - if lhs._optionalExtension != rhs._optionalExtension {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestRequired: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestRequired" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 2: .same(proto: "dummy2"), - 3: .same(proto: "b"), - 4: .same(proto: "dummy4"), - 5: .same(proto: "dummy5"), - 6: .same(proto: "dummy6"), - 7: .same(proto: "dummy7"), - 8: .same(proto: "dummy8"), - 9: .same(proto: "dummy9"), - 10: .same(proto: "dummy10"), - 11: .same(proto: "dummy11"), - 12: .same(proto: "dummy12"), - 13: .same(proto: "dummy13"), - 14: .same(proto: "dummy14"), - 15: .same(proto: "dummy15"), - 16: .same(proto: "dummy16"), - 17: .same(proto: "dummy17"), - 18: .same(proto: "dummy18"), - 19: .same(proto: "dummy19"), - 20: .same(proto: "dummy20"), - 21: .same(proto: "dummy21"), - 22: .same(proto: "dummy22"), - 23: .same(proto: "dummy23"), - 24: .same(proto: "dummy24"), - 25: .same(proto: "dummy25"), - 26: .same(proto: "dummy26"), - 27: .same(proto: "dummy27"), - 28: .same(proto: "dummy28"), - 29: .same(proto: "dummy29"), - 30: .same(proto: "dummy30"), - 31: .same(proto: "dummy31"), - 32: .same(proto: "dummy32"), - 33: .same(proto: "c"), - ] - - fileprivate class _StorageClass { - var _a: Int32? = nil - var _dummy2: Int32? = nil - var _b: Int32? = nil - var _dummy4: Int32? = nil - var _dummy5: Int32? = nil - var _dummy6: Int32? = nil - var _dummy7: Int32? = nil - var _dummy8: Int32? = nil - var _dummy9: Int32? = nil - var _dummy10: Int32? = nil - var _dummy11: Int32? = nil - var _dummy12: Int32? = nil - var _dummy13: Int32? = nil - var _dummy14: Int32? = nil - var _dummy15: Int32? = nil - var _dummy16: Int32? = nil - var _dummy17: Int32? = nil - var _dummy18: Int32? = nil - var _dummy19: Int32? = nil - var _dummy20: Int32? = nil - var _dummy21: Int32? = nil - var _dummy22: Int32? = nil - var _dummy23: Int32? = nil - var _dummy24: Int32? = nil - var _dummy25: Int32? = nil - var _dummy26: Int32? = nil - var _dummy27: Int32? = nil - var _dummy28: Int32? = nil - var _dummy29: Int32? = nil - var _dummy30: Int32? = nil - var _dummy31: Int32? = nil - var _dummy32: Int32? = nil - var _c: Int32? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _a = source._a - _dummy2 = source._dummy2 - _b = source._b - _dummy4 = source._dummy4 - _dummy5 = source._dummy5 - _dummy6 = source._dummy6 - _dummy7 = source._dummy7 - _dummy8 = source._dummy8 - _dummy9 = source._dummy9 - _dummy10 = source._dummy10 - _dummy11 = source._dummy11 - _dummy12 = source._dummy12 - _dummy13 = source._dummy13 - _dummy14 = source._dummy14 - _dummy15 = source._dummy15 - _dummy16 = source._dummy16 - _dummy17 = source._dummy17 - _dummy18 = source._dummy18 - _dummy19 = source._dummy19 - _dummy20 = source._dummy20 - _dummy21 = source._dummy21 - _dummy22 = source._dummy22 - _dummy23 = source._dummy23 - _dummy24 = source._dummy24 - _dummy25 = source._dummy25 - _dummy26 = source._dummy26 - _dummy27 = source._dummy27 - _dummy28 = source._dummy28 - _dummy29 = source._dummy29 - _dummy30 = source._dummy30 - _dummy31 = source._dummy31 - _dummy32 = source._dummy32 - _c = source._c - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - public var isInitialized: Bool { - return withExtendedLifetime(_storage) { (_storage: _StorageClass) in - if _storage._a == nil {return false} - if _storage._b == nil {return false} - if _storage._c == nil {return false} - return true - } - } - - mutating func decodeMessage(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._a) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy2) }() - case 3: try { try decoder.decodeSingularInt32Field(value: &_storage._b) }() - case 4: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy4) }() - case 5: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy5) }() - case 6: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy6) }() - case 7: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy7) }() - case 8: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy8) }() - case 9: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy9) }() - case 10: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy10) }() - case 11: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy11) }() - case 12: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy12) }() - case 13: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy13) }() - case 14: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy14) }() - case 15: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy15) }() - case 16: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy16) }() - case 17: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy17) }() - case 18: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy18) }() - case 19: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy19) }() - case 20: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy20) }() - case 21: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy21) }() - case 22: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy22) }() - case 23: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy23) }() - case 24: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy24) }() - case 25: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy25) }() - case 26: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy26) }() - case 27: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy27) }() - case 28: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy28) }() - case 29: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy29) }() - case 30: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy30) }() - case 31: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy31) }() - case 32: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy32) }() - case 33: try { try decoder.decodeSingularInt32Field(value: &_storage._c) }() - default: break - } - } - } - } - - func traverse(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._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._dummy2 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try { if let v = _storage._b { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) - } }() - try { if let v = _storage._dummy4 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) - } }() - try { if let v = _storage._dummy5 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) - } }() - try { if let v = _storage._dummy6 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) - } }() - try { if let v = _storage._dummy7 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) - } }() - try { if let v = _storage._dummy8 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 8) - } }() - try { if let v = _storage._dummy9 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) - } }() - try { if let v = _storage._dummy10 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 10) - } }() - try { if let v = _storage._dummy11 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 11) - } }() - try { if let v = _storage._dummy12 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 12) - } }() - try { if let v = _storage._dummy13 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 13) - } }() - try { if let v = _storage._dummy14 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 14) - } }() - try { if let v = _storage._dummy15 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 15) - } }() - try { if let v = _storage._dummy16 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 16) - } }() - try { if let v = _storage._dummy17 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) - } }() - try { if let v = _storage._dummy18 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 18) - } }() - try { if let v = _storage._dummy19 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 19) - } }() - try { if let v = _storage._dummy20 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 20) - } }() - try { if let v = _storage._dummy21 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 21) - } }() - try { if let v = _storage._dummy22 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 22) - } }() - try { if let v = _storage._dummy23 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 23) - } }() - try { if let v = _storage._dummy24 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 24) - } }() - try { if let v = _storage._dummy25 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 25) - } }() - try { if let v = _storage._dummy26 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 26) - } }() - try { if let v = _storage._dummy27 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 27) - } }() - try { if let v = _storage._dummy28 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 28) - } }() - try { if let v = _storage._dummy29 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 29) - } }() - try { if let v = _storage._dummy30 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 30) - } }() - try { if let v = _storage._dummy31 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 31) - } }() - try { if let v = _storage._dummy32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 32) - } }() - try { if let v = _storage._c { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 33) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestRequired, rhs: ProtobufUnittest_TestRequired) -> 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._a != rhs_storage._a {return false} - if _storage._dummy2 != rhs_storage._dummy2 {return false} - if _storage._b != rhs_storage._b {return false} - if _storage._dummy4 != rhs_storage._dummy4 {return false} - if _storage._dummy5 != rhs_storage._dummy5 {return false} - if _storage._dummy6 != rhs_storage._dummy6 {return false} - if _storage._dummy7 != rhs_storage._dummy7 {return false} - if _storage._dummy8 != rhs_storage._dummy8 {return false} - if _storage._dummy9 != rhs_storage._dummy9 {return false} - if _storage._dummy10 != rhs_storage._dummy10 {return false} - if _storage._dummy11 != rhs_storage._dummy11 {return false} - if _storage._dummy12 != rhs_storage._dummy12 {return false} - if _storage._dummy13 != rhs_storage._dummy13 {return false} - if _storage._dummy14 != rhs_storage._dummy14 {return false} - if _storage._dummy15 != rhs_storage._dummy15 {return false} - if _storage._dummy16 != rhs_storage._dummy16 {return false} - if _storage._dummy17 != rhs_storage._dummy17 {return false} - if _storage._dummy18 != rhs_storage._dummy18 {return false} - if _storage._dummy19 != rhs_storage._dummy19 {return false} - if _storage._dummy20 != rhs_storage._dummy20 {return false} - if _storage._dummy21 != rhs_storage._dummy21 {return false} - if _storage._dummy22 != rhs_storage._dummy22 {return false} - if _storage._dummy23 != rhs_storage._dummy23 {return false} - if _storage._dummy24 != rhs_storage._dummy24 {return false} - if _storage._dummy25 != rhs_storage._dummy25 {return false} - if _storage._dummy26 != rhs_storage._dummy26 {return false} - if _storage._dummy27 != rhs_storage._dummy27 {return false} - if _storage._dummy28 != rhs_storage._dummy28 {return false} - if _storage._dummy29 != rhs_storage._dummy29 {return false} - if _storage._dummy30 != rhs_storage._dummy30 {return false} - if _storage._dummy31 != rhs_storage._dummy31 {return false} - if _storage._dummy32 != rhs_storage._dummy32 {return false} - if _storage._c != rhs_storage._c {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestRequiredForeign: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestRequiredForeign" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_message"), - 2: .standard(proto: "repeated_message"), - 3: .same(proto: "dummy"), - ] - - public var isInitialized: Bool { - if let v = self._optionalMessage, !v.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.repeatedMessage) {return false} - return true - } - - 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.decodeSingularMessageField(value: &self._optionalMessage) }() - case 2: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedMessage) }() - case 3: try { try decoder.decodeSingularInt32Field(value: &self._dummy) }() - 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 - try { if let v = self._optionalMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - if !self.repeatedMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: self.repeatedMessage, fieldNumber: 2) - } - try { if let v = self._dummy { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestRequiredForeign, rhs: ProtobufUnittest_TestRequiredForeign) -> Bool { - if lhs._optionalMessage != rhs._optionalMessage {return false} - if lhs.repeatedMessage != rhs.repeatedMessage {return false} - if lhs._dummy != rhs._dummy {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestRequiredMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestRequiredMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_message"), - 2: .standard(proto: "repeated_message"), - 3: .standard(proto: "required_message"), - ] - - public var isInitialized: Bool { - if self._requiredMessage == nil {return false} - if let v = self._optionalMessage, !v.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.repeatedMessage) {return false} - if let v = self._requiredMessage, !v.isInitialized {return false} - return true - } - - 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.decodeSingularMessageField(value: &self._optionalMessage) }() - case 2: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedMessage) }() - case 3: try { try decoder.decodeSingularMessageField(value: &self._requiredMessage) }() - 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 - try { if let v = self._optionalMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - if !self.repeatedMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: self.repeatedMessage, fieldNumber: 2) - } - try { if let v = self._requiredMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestRequiredMessage, rhs: ProtobufUnittest_TestRequiredMessage) -> Bool { - if lhs._optionalMessage != rhs._optionalMessage {return false} - if lhs.repeatedMessage != rhs.repeatedMessage {return false} - if lhs._requiredMessage != rhs._requiredMessage {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestForeignNested: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestForeignNested" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "foreign_nested"), - ] - - 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.decodeSingularMessageField(value: &self._foreignNested) }() - 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 - try { if let v = self._foreignNested { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestForeignNested, rhs: ProtobufUnittest_TestForeignNested) -> Bool { - if lhs._foreignNested != rhs._foreignNested {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestEmptyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestEmptyMessage" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestEmptyMessage, rhs: ProtobufUnittest_TestEmptyMessage) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestEmptyMessageWithExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestEmptyMessageWithExtensions" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestEmptyMessageWithExtensions.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestEmptyMessageWithExtensions, rhs: ProtobufUnittest_TestEmptyMessageWithExtensions) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestPickleNestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestPickleNestedMessage" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestPickleNestedMessage, rhs: ProtobufUnittest_TestPickleNestedMessage) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestPickleNestedMessage.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestPickleNestedMessage.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - ] - - 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._bb) }() - 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 - try { if let v = self._bb { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestPickleNestedMessage.NestedMessage, rhs: ProtobufUnittest_TestPickleNestedMessage.NestedMessage) -> Bool { - if lhs._bb != rhs._bb {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestPickleNestedMessage.NestedMessage.protoMessageName + ".NestedNestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "cc"), - ] - - 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._cc) }() - 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 - try { if let v = self._cc { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage, rhs: ProtobufUnittest_TestPickleNestedMessage.NestedMessage.NestedNestedMessage) -> Bool { - if lhs._cc != rhs._cc {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestMultipleExtensionRanges: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMultipleExtensionRanges" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (42 == fieldNumber) || (4143 <= fieldNumber && fieldNumber < 4244) || (65536 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestMultipleExtensionRanges.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 42, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMultipleExtensionRanges, rhs: ProtobufUnittest_TestMultipleExtensionRanges) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestReallyLargeTagNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestReallyLargeTagNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 268435455: .same(proto: "bb"), - ] - - 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._a) }() - case 268435455: try { try decoder.decodeSingularInt32Field(value: &self._bb) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._bb { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 268435455) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestReallyLargeTagNumber, rhs: ProtobufUnittest_TestReallyLargeTagNumber) -> Bool { - if lhs._a != rhs._a {return false} - if lhs._bb != rhs._bb {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestRecursiveMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestRecursiveMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 2: .same(proto: "i"), - ] - - fileprivate class _StorageClass { - var _a: ProtobufUnittest_TestRecursiveMessage? = nil - var _i: Int32? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _a = source._a - _i = source._i - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._a) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._i) }() - default: break - } - } - } - } - - func traverse(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._a { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._i { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestRecursiveMessage, rhs: ProtobufUnittest_TestRecursiveMessage) -> 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._a != rhs_storage._a {return false} - if _storage._i != rhs_storage._i {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestMutualRecursionA: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMutualRecursionA" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - 2: .unique(proto: "SubGroup", json: "subgroup"), - ] - - fileprivate class _StorageClass { - var _bb: ProtobufUnittest_TestMutualRecursionB? = nil - var _subGroup: ProtobufUnittest_TestMutualRecursionA.SubGroup? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _bb = source._bb - _subGroup = source._subGroup - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._bb) }() - case 2: try { try decoder.decodeSingularGroupField(value: &_storage._subGroup) }() - default: break - } - } - } - } - - func traverse(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._bb { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._subGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 2) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMutualRecursionA, rhs: ProtobufUnittest_TestMutualRecursionA) -> 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._bb != rhs_storage._bb {return false} - if _storage._subGroup != rhs_storage._subGroup {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestMutualRecursionA.SubMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestMutualRecursionA.protoMessageName + ".SubMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "b"), - ] - - fileprivate class _StorageClass { - var _b: ProtobufUnittest_TestMutualRecursionB? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _b = source._b - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._b) }() - default: break - } - } - } - } - - func traverse(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._b { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMutualRecursionA.SubMessage, rhs: ProtobufUnittest_TestMutualRecursionA.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._b != rhs_storage._b {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestMutualRecursionA.SubGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestMutualRecursionA.protoMessageName + ".SubGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 3: .standard(proto: "sub_message"), - 4: .standard(proto: "not_in_this_scc"), - ] - - fileprivate class _StorageClass { - var _subMessage: ProtobufUnittest_TestMutualRecursionA.SubMessage? = nil - var _notInThisScc: ProtobufUnittest_TestAllTypes? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _subMessage = source._subMessage - _notInThisScc = source._notInThisScc - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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 3: try { try decoder.decodeSingularMessageField(value: &_storage._subMessage) }() - case 4: try { try decoder.decodeSingularMessageField(value: &_storage._notInThisScc) }() - default: break - } - } - } - } - - func traverse(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._subMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - } }() - try { if let v = _storage._notInThisScc { - try visitor.visitSingularMessageField(value: v, fieldNumber: 4) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMutualRecursionA.SubGroup, rhs: ProtobufUnittest_TestMutualRecursionA.SubGroup) -> 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._subMessage != rhs_storage._subMessage {return false} - if _storage._notInThisScc != rhs_storage._notInThisScc {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestMutualRecursionB: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMutualRecursionB" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 2: .standard(proto: "optional_int32"), - ] - - fileprivate class _StorageClass { - var _a: ProtobufUnittest_TestMutualRecursionA? = nil - var _optionalInt32: Int32? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _a = source._a - _optionalInt32 = source._optionalInt32 - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._a) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._optionalInt32) }() - default: break - } - } - } - } - - func traverse(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._a { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._optionalInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMutualRecursionB, rhs: ProtobufUnittest_TestMutualRecursionB) -> 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._a != rhs_storage._a {return false} - if _storage._optionalInt32 != rhs_storage._optionalInt32 {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestIsInitialized: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestIsInitialized" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "sub_message"), - ] - - public var isInitialized: Bool { - if let v = self._subMessage, !v.isInitialized {return false} - return true - } - - 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.decodeSingularMessageField(value: &self._subMessage) }() - 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 - try { if let v = self._subMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestIsInitialized, rhs: ProtobufUnittest_TestIsInitialized) -> Bool { - if lhs._subMessage != rhs._subMessage {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestIsInitialized.SubMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestIsInitialized.protoMessageName + ".SubMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .unique(proto: "SubGroup", json: "subgroup"), - ] - - public var isInitialized: Bool { - if let v = self._subGroup, !v.isInitialized {return false} - return true - } - - 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.decodeSingularGroupField(value: &self._subGroup) }() - 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 - try { if let v = self._subGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestIsInitialized.SubMessage, rhs: ProtobufUnittest_TestIsInitialized.SubMessage) -> Bool { - if lhs._subGroup != rhs._subGroup {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestIsInitialized.SubMessage.SubGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestIsInitialized.SubMessage.protoMessageName + ".SubGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2: .same(proto: "i"), - ] - - public var isInitialized: Bool { - if self._i == nil {return false} - return true - } - - 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 2: try { try decoder.decodeSingularInt32Field(value: &self._i) }() - 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 - try { if let v = self._i { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestIsInitialized.SubMessage.SubGroup, rhs: ProtobufUnittest_TestIsInitialized.SubMessage.SubGroup) -> Bool { - if lhs._i != rhs._i {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestDupFieldNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestDupFieldNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 2: .unique(proto: "Foo", json: "foo"), - 3: .unique(proto: "Bar", json: "bar"), - ] - - 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._a) }() - case 2: try { try decoder.decodeSingularGroupField(value: &self._foo) }() - case 3: try { try decoder.decodeSingularGroupField(value: &self._bar) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._foo { - try visitor.visitSingularGroupField(value: v, fieldNumber: 2) - } }() - try { if let v = self._bar { - try visitor.visitSingularGroupField(value: v, fieldNumber: 3) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestDupFieldNumber, rhs: ProtobufUnittest_TestDupFieldNumber) -> Bool { - if lhs._a != rhs._a {return false} - if lhs._foo != rhs._foo {return false} - if lhs._bar != rhs._bar {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestDupFieldNumber.Foo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestDupFieldNumber.protoMessageName + ".Foo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] - - 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._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestDupFieldNumber.Foo, rhs: ProtobufUnittest_TestDupFieldNumber.Foo) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestDupFieldNumber.Bar: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestDupFieldNumber.protoMessageName + ".Bar" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] - - 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._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestDupFieldNumber.Bar, rhs: ProtobufUnittest_TestDupFieldNumber.Bar) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestEagerMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestEagerMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "sub_message"), - ] - - 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.decodeSingularMessageField(value: &self._subMessage) }() - 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 - try { if let v = self._subMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestEagerMessage, rhs: ProtobufUnittest_TestEagerMessage) -> Bool { - if lhs._subMessage != rhs._subMessage {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestLazyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestLazyMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "sub_message"), - ] - - 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.decodeSingularMessageField(value: &self._subMessage) }() - 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 - try { if let v = self._subMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestLazyMessage, rhs: ProtobufUnittest_TestLazyMessage) -> Bool { - if lhs._subMessage != rhs._subMessage {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestNestedMessageHasBits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestNestedMessageHasBits" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_nested_message"), - ] - - 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.decodeSingularMessageField(value: &self._optionalNestedMessage) }() - 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 - try { if let v = self._optionalNestedMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestNestedMessageHasBits, rhs: ProtobufUnittest_TestNestedMessageHasBits) -> Bool { - if lhs._optionalNestedMessage != rhs._optionalNestedMessage {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestNestedMessageHasBits.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestNestedMessageHasBits.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "nestedmessage_repeated_int32"), - 2: .standard(proto: "nestedmessage_repeated_foreignmessage"), - ] - - 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.decodeRepeatedInt32Field(value: &self.nestedmessageRepeatedInt32) }() - case 2: try { try decoder.decodeRepeatedMessageField(value: &self.nestedmessageRepeatedForeignmessage) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.nestedmessageRepeatedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.nestedmessageRepeatedInt32, fieldNumber: 1) - } - if !self.nestedmessageRepeatedForeignmessage.isEmpty { - try visitor.visitRepeatedMessageField(value: self.nestedmessageRepeatedForeignmessage, fieldNumber: 2) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestNestedMessageHasBits.NestedMessage, rhs: ProtobufUnittest_TestNestedMessageHasBits.NestedMessage) -> Bool { - if lhs.nestedmessageRepeatedInt32 != rhs.nestedmessageRepeatedInt32 {return false} - if lhs.nestedmessageRepeatedForeignmessage != rhs.nestedmessageRepeatedForeignmessage {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestCamelCaseFieldNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestCamelCaseFieldNames" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "PrimitiveField"), - 2: .same(proto: "StringField"), - 3: .same(proto: "EnumField"), - 4: .same(proto: "MessageField"), - 5: .same(proto: "StringPieceField"), - 6: .same(proto: "CordField"), - 7: .same(proto: "RepeatedPrimitiveField"), - 8: .same(proto: "RepeatedStringField"), - 9: .same(proto: "RepeatedEnumField"), - 10: .same(proto: "RepeatedMessageField"), - 11: .same(proto: "RepeatedStringPieceField"), - 12: .same(proto: "RepeatedCordField"), - ] - - 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._primitiveField) }() - case 2: try { try decoder.decodeSingularStringField(value: &self._stringField) }() - case 3: try { try decoder.decodeSingularEnumField(value: &self._enumField) }() - case 4: try { try decoder.decodeSingularMessageField(value: &self._messageField) }() - case 5: try { try decoder.decodeSingularStringField(value: &self._stringPieceField) }() - case 6: try { try decoder.decodeSingularStringField(value: &self._cordField) }() - case 7: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedPrimitiveField) }() - case 8: try { try decoder.decodeRepeatedStringField(value: &self.repeatedStringField) }() - case 9: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedEnumField) }() - case 10: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedMessageField) }() - case 11: try { try decoder.decodeRepeatedStringField(value: &self.repeatedStringPieceField) }() - case 12: try { try decoder.decodeRepeatedStringField(value: &self.repeatedCordField) }() - 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 - try { if let v = self._primitiveField { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._stringField { - try visitor.visitSingularStringField(value: v, fieldNumber: 2) - } }() - try { if let v = self._enumField { - try visitor.visitSingularEnumField(value: v, fieldNumber: 3) - } }() - try { if let v = self._messageField { - try visitor.visitSingularMessageField(value: v, fieldNumber: 4) - } }() - try { if let v = self._stringPieceField { - try visitor.visitSingularStringField(value: v, fieldNumber: 5) - } }() - try { if let v = self._cordField { - try visitor.visitSingularStringField(value: v, fieldNumber: 6) - } }() - if !self.repeatedPrimitiveField.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.repeatedPrimitiveField, fieldNumber: 7) - } - if !self.repeatedStringField.isEmpty { - try visitor.visitRepeatedStringField(value: self.repeatedStringField, fieldNumber: 8) - } - if !self.repeatedEnumField.isEmpty { - try visitor.visitRepeatedEnumField(value: self.repeatedEnumField, fieldNumber: 9) - } - if !self.repeatedMessageField.isEmpty { - try visitor.visitRepeatedMessageField(value: self.repeatedMessageField, fieldNumber: 10) - } - if !self.repeatedStringPieceField.isEmpty { - try visitor.visitRepeatedStringField(value: self.repeatedStringPieceField, fieldNumber: 11) - } - if !self.repeatedCordField.isEmpty { - try visitor.visitRepeatedStringField(value: self.repeatedCordField, fieldNumber: 12) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestCamelCaseFieldNames, rhs: ProtobufUnittest_TestCamelCaseFieldNames) -> Bool { - if lhs._primitiveField != rhs._primitiveField {return false} - if lhs._stringField != rhs._stringField {return false} - if lhs._enumField != rhs._enumField {return false} - if lhs._messageField != rhs._messageField {return false} - if lhs._stringPieceField != rhs._stringPieceField {return false} - if lhs._cordField != rhs._cordField {return false} - if lhs.repeatedPrimitiveField != rhs.repeatedPrimitiveField {return false} - if lhs.repeatedStringField != rhs.repeatedStringField {return false} - if lhs.repeatedEnumField != rhs.repeatedEnumField {return false} - if lhs.repeatedMessageField != rhs.repeatedMessageField {return false} - if lhs.repeatedStringPieceField != rhs.repeatedStringPieceField {return false} - if lhs.repeatedCordField != rhs.repeatedCordField {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestFieldOrderings: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestFieldOrderings" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 11: .standard(proto: "my_string"), - 1: .standard(proto: "my_int"), - 101: .standard(proto: "my_float"), - 200: .standard(proto: "optional_nested_message"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - 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.decodeSingularInt64Field(value: &self._myInt) }() - case 11: try { try decoder.decodeSingularStringField(value: &self._myString) }() - case 101: try { try decoder.decodeSingularFloatField(value: &self._myFloat) }() - case 200: try { try decoder.decodeSingularMessageField(value: &self._optionalNestedMessage) }() - case 2..<11, 12..<101: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestFieldOrderings.self, fieldNumber: fieldNumber) }() - 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 - try { if let v = self._myInt { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 1) - } }() - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2, end: 11) - try { if let v = self._myString { - try visitor.visitSingularStringField(value: v, fieldNumber: 11) - } }() - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 12, end: 101) - try { if let v = self._myFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 101) - } }() - try { if let v = self._optionalNestedMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 200) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestFieldOrderings, rhs: ProtobufUnittest_TestFieldOrderings) -> Bool { - if lhs._myString != rhs._myString {return false} - if lhs._myInt != rhs._myInt {return false} - if lhs._myFloat != rhs._myFloat {return false} - if lhs._optionalNestedMessage != rhs._optionalNestedMessage {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestFieldOrderings.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestFieldOrderings.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2: .same(proto: "oo"), - 1: .same(proto: "bb"), - ] - - 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._bb) }() - case 2: try { try decoder.decodeSingularInt64Field(value: &self._oo) }() - 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 - try { if let v = self._bb { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._oo { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestFieldOrderings.NestedMessage, rhs: ProtobufUnittest_TestFieldOrderings.NestedMessage) -> Bool { - if lhs._oo != rhs._oo {return false} - if lhs._bb != rhs._bb {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestExtensionOrderings1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestExtensionOrderings1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "my_string"), - ] - - 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._myString) }() - 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 - try { if let v = self._myString { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestExtensionOrderings1, rhs: ProtobufUnittest_TestExtensionOrderings1) -> Bool { - if lhs._myString != rhs._myString {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestExtensionOrderings2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestExtensionOrderings2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "my_string"), - ] - - 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._myString) }() - 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 - try { if let v = self._myString { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestExtensionOrderings2, rhs: ProtobufUnittest_TestExtensionOrderings2) -> Bool { - if lhs._myString != rhs._myString {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestExtensionOrderings2.protoMessageName + ".TestExtensionOrderings3" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "my_string"), - ] - - 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._myString) }() - 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 - try { if let v = self._myString { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3, rhs: ProtobufUnittest_TestExtensionOrderings2.TestExtensionOrderings3) -> Bool { - if lhs._myString != rhs._myString {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestExtremeDefaultValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestExtremeDefaultValues" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "escaped_bytes"), - 2: .standard(proto: "large_uint32"), - 3: .standard(proto: "large_uint64"), - 4: .standard(proto: "small_int32"), - 5: .standard(proto: "small_int64"), - 21: .standard(proto: "really_small_int32"), - 22: .standard(proto: "really_small_int64"), - 6: .standard(proto: "utf8_string"), - 7: .standard(proto: "zero_float"), - 8: .standard(proto: "one_float"), - 9: .standard(proto: "small_float"), - 10: .standard(proto: "negative_one_float"), - 11: .standard(proto: "negative_float"), - 12: .standard(proto: "large_float"), - 13: .standard(proto: "small_negative_float"), - 14: .standard(proto: "inf_double"), - 15: .standard(proto: "neg_inf_double"), - 16: .standard(proto: "nan_double"), - 17: .standard(proto: "inf_float"), - 18: .standard(proto: "neg_inf_float"), - 19: .standard(proto: "nan_float"), - 20: .standard(proto: "cpp_trigraph"), - 23: .standard(proto: "string_with_zero"), - 24: .standard(proto: "bytes_with_zero"), - 25: .standard(proto: "string_piece_with_zero"), - 26: .standard(proto: "cord_with_zero"), - 27: .standard(proto: "replacement_string"), - ] - - fileprivate class _StorageClass { - var _escapedBytes: Data? = nil - var _largeUint32: UInt32? = nil - var _largeUint64: UInt64? = nil - var _smallInt32: Int32? = nil - var _smallInt64: Int64? = nil - var _reallySmallInt32: Int32? = nil - var _reallySmallInt64: Int64? = nil - var _utf8String: String? = nil - var _zeroFloat: Float? = nil - var _oneFloat: Float? = nil - var _smallFloat: Float? = nil - var _negativeOneFloat: Float? = nil - var _negativeFloat: Float? = nil - var _largeFloat: Float? = nil - var _smallNegativeFloat: Float? = nil - var _infDouble: Double? = nil - var _negInfDouble: Double? = nil - var _nanDouble: Double? = nil - var _infFloat: Float? = nil - var _negInfFloat: Float? = nil - var _nanFloat: Float? = nil - var _cppTrigraph: String? = nil - var _stringWithZero: String? = nil - var _bytesWithZero: Data? = nil - var _stringPieceWithZero: String? = nil - var _cordWithZero: String? = nil - var _replacementString: String? = nil - - static let defaultInstance = _StorageClass() - - private init() {} + private init() {} init(copying source: _StorageClass) { - _escapedBytes = source._escapedBytes - _largeUint32 = source._largeUint32 - _largeUint64 = source._largeUint64 - _smallInt32 = source._smallInt32 - _smallInt64 = source._smallInt64 - _reallySmallInt32 = source._reallySmallInt32 - _reallySmallInt64 = source._reallySmallInt64 - _utf8String = source._utf8String - _zeroFloat = source._zeroFloat - _oneFloat = source._oneFloat - _smallFloat = source._smallFloat - _negativeOneFloat = source._negativeOneFloat - _negativeFloat = source._negativeFloat - _largeFloat = source._largeFloat - _smallNegativeFloat = source._smallNegativeFloat - _infDouble = source._infDouble - _negInfDouble = source._negInfDouble - _nanDouble = source._nanDouble - _infFloat = source._infFloat - _negInfFloat = source._negInfFloat - _nanFloat = source._nanFloat - _cppTrigraph = source._cppTrigraph - _stringWithZero = source._stringWithZero - _bytesWithZero = source._bytesWithZero - _stringPieceWithZero = source._stringPieceWithZero - _cordWithZero = source._cordWithZero - _replacementString = source._replacementString - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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.decodeSingularBytesField(value: &_storage._escapedBytes) }() - case 2: try { try decoder.decodeSingularUInt32Field(value: &_storage._largeUint32) }() - case 3: try { try decoder.decodeSingularUInt64Field(value: &_storage._largeUint64) }() - case 4: try { try decoder.decodeSingularInt32Field(value: &_storage._smallInt32) }() - case 5: try { try decoder.decodeSingularInt64Field(value: &_storage._smallInt64) }() - case 6: try { try decoder.decodeSingularStringField(value: &_storage._utf8String) }() - case 7: try { try decoder.decodeSingularFloatField(value: &_storage._zeroFloat) }() - case 8: try { try decoder.decodeSingularFloatField(value: &_storage._oneFloat) }() - case 9: try { try decoder.decodeSingularFloatField(value: &_storage._smallFloat) }() - case 10: try { try decoder.decodeSingularFloatField(value: &_storage._negativeOneFloat) }() - case 11: try { try decoder.decodeSingularFloatField(value: &_storage._negativeFloat) }() - case 12: try { try decoder.decodeSingularFloatField(value: &_storage._largeFloat) }() - case 13: try { try decoder.decodeSingularFloatField(value: &_storage._smallNegativeFloat) }() - case 14: try { try decoder.decodeSingularDoubleField(value: &_storage._infDouble) }() - case 15: try { try decoder.decodeSingularDoubleField(value: &_storage._negInfDouble) }() - case 16: try { try decoder.decodeSingularDoubleField(value: &_storage._nanDouble) }() - case 17: try { try decoder.decodeSingularFloatField(value: &_storage._infFloat) }() - case 18: try { try decoder.decodeSingularFloatField(value: &_storage._negInfFloat) }() - case 19: try { try decoder.decodeSingularFloatField(value: &_storage._nanFloat) }() - case 20: try { try decoder.decodeSingularStringField(value: &_storage._cppTrigraph) }() - case 21: try { try decoder.decodeSingularInt32Field(value: &_storage._reallySmallInt32) }() - case 22: try { try decoder.decodeSingularInt64Field(value: &_storage._reallySmallInt64) }() - case 23: try { try decoder.decodeSingularStringField(value: &_storage._stringWithZero) }() - case 24: try { try decoder.decodeSingularBytesField(value: &_storage._bytesWithZero) }() - case 25: try { try decoder.decodeSingularStringField(value: &_storage._stringPieceWithZero) }() - case 26: try { try decoder.decodeSingularStringField(value: &_storage._cordWithZero) }() - case 27: try { try decoder.decodeSingularStringField(value: &_storage._replacementString) }() + _optionalInt32 = source._optionalInt32 + _optionalInt64 = source._optionalInt64 + _optionalUint32 = source._optionalUint32 + _optionalUint64 = source._optionalUint64 + _optionalSint32 = source._optionalSint32 + _optionalSint64 = source._optionalSint64 + _optionalFixed32 = source._optionalFixed32 + _optionalFixed64 = source._optionalFixed64 + _optionalSfixed32 = source._optionalSfixed32 + _optionalSfixed64 = source._optionalSfixed64 + _optionalFloat = source._optionalFloat + _optionalDouble = source._optionalDouble + _optionalBool = source._optionalBool + _optionalString = source._optionalString + _optionalBytes = source._optionalBytes + _optionalGroup = source._optionalGroup + _optionalNestedMessage = source._optionalNestedMessage + _optionalForeignMessage = source._optionalForeignMessage + _optionalImportMessage = source._optionalImportMessage + _optionalNestedEnum = source._optionalNestedEnum + _optionalForeignEnum = source._optionalForeignEnum + _optionalImportEnum = source._optionalImportEnum + _optionalPublicImportMessage = source._optionalPublicImportMessage + _repeatedInt32 = source._repeatedInt32 + _repeatedInt64 = source._repeatedInt64 + _repeatedUint32 = source._repeatedUint32 + _repeatedUint64 = source._repeatedUint64 + _repeatedSint32 = source._repeatedSint32 + _repeatedSint64 = source._repeatedSint64 + _repeatedFixed32 = source._repeatedFixed32 + _repeatedFixed64 = source._repeatedFixed64 + _repeatedSfixed32 = source._repeatedSfixed32 + _repeatedSfixed64 = source._repeatedSfixed64 + _repeatedFloat = source._repeatedFloat + _repeatedDouble = source._repeatedDouble + _repeatedBool = source._repeatedBool + _repeatedString = source._repeatedString + _repeatedBytes = source._repeatedBytes + _repeatedGroup = source._repeatedGroup + _repeatedNestedMessage = source._repeatedNestedMessage + _repeatedForeignMessage = source._repeatedForeignMessage + _repeatedImportMessage = source._repeatedImportMessage + _repeatedNestedEnum = source._repeatedNestedEnum + _repeatedForeignEnum = source._repeatedForeignEnum + _repeatedImportEnum = source._repeatedImportEnum + _defaultInt32 = source._defaultInt32 + _defaultInt64 = source._defaultInt64 + _defaultUint32 = source._defaultUint32 + _defaultUint64 = source._defaultUint64 + _defaultSint32 = source._defaultSint32 + _defaultSint64 = source._defaultSint64 + _defaultFixed32 = source._defaultFixed32 + _defaultFixed64 = source._defaultFixed64 + _defaultSfixed32 = source._defaultSfixed32 + _defaultSfixed64 = source._defaultSfixed64 + _defaultFloat = source._defaultFloat + _defaultDouble = source._defaultDouble + _defaultBool = source._defaultBool + _defaultString = source._defaultString + _defaultBytes = source._defaultBytes + _defaultNestedEnum = source._defaultNestedEnum + _defaultForeignEnum = source._defaultForeignEnum + _defaultImportEnum = source._defaultImportEnum + _oneofField = source._oneofField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._optionalInt32) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() + case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() + case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() + case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() + case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() + case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() + case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() + case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() + case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() + case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() + case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() + case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() + case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() + case 16: try { try decoder.decodeSingularGroupField(value: &_storage._optionalGroup) }() + case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() + case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() + case 20: try { try decoder.decodeSingularMessageField(value: &_storage._optionalImportMessage) }() + case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() + case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() + case 23: try { try decoder.decodeSingularEnumField(value: &_storage._optionalImportEnum) }() + case 26: try { try decoder.decodeSingularMessageField(value: &_storage._optionalPublicImportMessage) }() + case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() + case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() + case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() + case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() + case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() + case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() + case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() + case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() + case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() + case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() + case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() + case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() + case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() + case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() + case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() + case 46: try { try decoder.decodeRepeatedGroupField(value: &_storage._repeatedGroup) }() + case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() + case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() + case 50: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedImportMessage) }() + case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() + case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() + case 53: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedImportEnum) }() + case 61: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() + case 62: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() + case 63: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() + case 64: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() + case 65: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() + case 66: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() + case 67: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() + case 68: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() + case 69: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() + case 70: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() + case 71: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() + case 72: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() + case 73: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() + case 74: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() + case 75: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() + case 81: try { try decoder.decodeSingularEnumField(value: &_storage._defaultNestedEnum) }() + case 82: try { try decoder.decodeSingularEnumField(value: &_storage._defaultForeignEnum) }() + case 83: try { try decoder.decodeSingularEnumField(value: &_storage._defaultImportEnum) }() + case 111: try { + var v: UInt32? + try decoder.decodeSingularUInt32Field(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofUint32(v) + } + }() + case 112: try { + var v: SwiftProtoTesting_TestAllTypes.NestedMessage? + var hadOneofValue = false + if let current = _storage._oneofField { + hadOneofValue = true + if case .oneofNestedMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofNestedMessage(v) + } + }() + case 113: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofString(v) + } + }() + case 114: try { + var v: Data? + try decoder.decodeSingularBytesField(value: &v) + if let v = v { + if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} + _storage._oneofField = .oneofBytes(v) + } + }() default: break } } @@ -10956,309 +3885,303 @@ extension ProtobufUnittest_TestExtremeDefaultValues: SwiftProtobuf.Message, Swif // 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._escapedBytes { - try visitor.visitSingularBytesField(value: v, fieldNumber: 1) + try { if let v = _storage._optionalInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) } }() - try { if let v = _storage._largeUint32 { - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2) + try { if let v = _storage._optionalInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) } }() - try { if let v = _storage._largeUint64 { - try visitor.visitSingularUInt64Field(value: v, fieldNumber: 3) + try { if let v = _storage._optionalUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) } }() - try { if let v = _storage._smallInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + try { if let v = _storage._optionalUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) } }() - try { if let v = _storage._smallInt64 { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 5) + try { if let v = _storage._optionalSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) } }() - try { if let v = _storage._utf8String { - try visitor.visitSingularStringField(value: v, fieldNumber: 6) + try { if let v = _storage._optionalSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) } }() - try { if let v = _storage._zeroFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 7) + try { if let v = _storage._optionalFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) } }() - try { if let v = _storage._oneFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 8) + try { if let v = _storage._optionalFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) } }() - try { if let v = _storage._smallFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 9) + try { if let v = _storage._optionalSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) } }() - try { if let v = _storage._negativeOneFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 10) + try { if let v = _storage._optionalSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._optionalFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._optionalDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._optionalBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._optionalString { + try visitor.visitSingularStringField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._optionalBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._optionalForeignMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._optionalImportMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 20) + } }() + try { if let v = _storage._optionalNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._optionalForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._optionalImportEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 23) + } }() + try { if let v = _storage._optionalPublicImportMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 26) + } }() + if !_storage._repeatedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) + } + if !_storage._repeatedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) + } + if !_storage._repeatedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) + } + if !_storage._repeatedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) + } + if !_storage._repeatedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) + } + if !_storage._repeatedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) + } + if !_storage._repeatedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) + } + if !_storage._repeatedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) + } + if !_storage._repeatedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) + } + if !_storage._repeatedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) + } + if !_storage._repeatedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) + } + if !_storage._repeatedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) + } + if !_storage._repeatedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43) + } + if !_storage._repeatedString.isEmpty { + try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) + } + if !_storage._repeatedBytes.isEmpty { + try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) + } + if !_storage._repeatedGroup.isEmpty { + try visitor.visitRepeatedGroupField(value: _storage._repeatedGroup, fieldNumber: 46) + } + if !_storage._repeatedNestedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) + } + if !_storage._repeatedForeignMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) + } + if !_storage._repeatedImportMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedImportMessage, fieldNumber: 50) + } + if !_storage._repeatedNestedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) + } + if !_storage._repeatedForeignEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) + } + if !_storage._repeatedImportEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: _storage._repeatedImportEnum, fieldNumber: 53) + } + try { if let v = _storage._defaultInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 61) } }() - try { if let v = _storage._negativeFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + try { if let v = _storage._defaultInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 62) } }() - try { if let v = _storage._largeFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 12) + try { if let v = _storage._defaultUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63) } }() - try { if let v = _storage._smallNegativeFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 13) + try { if let v = _storage._defaultUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 64) } }() - try { if let v = _storage._infDouble { - try visitor.visitSingularDoubleField(value: v, fieldNumber: 14) + try { if let v = _storage._defaultSint32 { + try visitor.visitSingularSInt32Field(value: v, fieldNumber: 65) } }() - try { if let v = _storage._negInfDouble { - try visitor.visitSingularDoubleField(value: v, fieldNumber: 15) + try { if let v = _storage._defaultSint64 { + try visitor.visitSingularSInt64Field(value: v, fieldNumber: 66) } }() - try { if let v = _storage._nanDouble { - try visitor.visitSingularDoubleField(value: v, fieldNumber: 16) + try { if let v = _storage._defaultFixed32 { + try visitor.visitSingularFixed32Field(value: v, fieldNumber: 67) } }() - try { if let v = _storage._infFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 17) + try { if let v = _storage._defaultFixed64 { + try visitor.visitSingularFixed64Field(value: v, fieldNumber: 68) } }() - try { if let v = _storage._negInfFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 18) + try { if let v = _storage._defaultSfixed32 { + try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 69) } }() - try { if let v = _storage._nanFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 19) + try { if let v = _storage._defaultSfixed64 { + try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 70) } }() - try { if let v = _storage._cppTrigraph { - try visitor.visitSingularStringField(value: v, fieldNumber: 20) + try { if let v = _storage._defaultFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 71) } }() - try { if let v = _storage._reallySmallInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 21) + try { if let v = _storage._defaultDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 72) } }() - try { if let v = _storage._reallySmallInt64 { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 22) + try { if let v = _storage._defaultBool { + try visitor.visitSingularBoolField(value: v, fieldNumber: 73) } }() - try { if let v = _storage._stringWithZero { - try visitor.visitSingularStringField(value: v, fieldNumber: 23) + try { if let v = _storage._defaultString { + try visitor.visitSingularStringField(value: v, fieldNumber: 74) } }() - try { if let v = _storage._bytesWithZero { - try visitor.visitSingularBytesField(value: v, fieldNumber: 24) + try { if let v = _storage._defaultBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 75) } }() - try { if let v = _storage._stringPieceWithZero { - try visitor.visitSingularStringField(value: v, fieldNumber: 25) + try { if let v = _storage._defaultNestedEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 81) } }() - try { if let v = _storage._cordWithZero { - try visitor.visitSingularStringField(value: v, fieldNumber: 26) + try { if let v = _storage._defaultForeignEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 82) } }() - try { if let v = _storage._replacementString { - try visitor.visitSingularStringField(value: v, fieldNumber: 27) + try { if let v = _storage._defaultImportEnum { + try visitor.visitSingularEnumField(value: v, fieldNumber: 83) } }() + switch _storage._oneofField { + case .oneofUint32?: try { + guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) + }() + case .oneofNestedMessage?: try { + guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 112) + }() + case .oneofString?: try { + guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 113) + }() + case .oneofBytes?: try { + guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } + try visitor.visitSingularBytesField(value: v, fieldNumber: 114) + }() + case nil: break + } } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestExtremeDefaultValues, rhs: ProtobufUnittest_TestExtremeDefaultValues) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestAllTypes, rhs: SwiftProtoTesting_TestAllTypes) -> 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._escapedBytes != rhs_storage._escapedBytes {return false} - if _storage._largeUint32 != rhs_storage._largeUint32 {return false} - if _storage._largeUint64 != rhs_storage._largeUint64 {return false} - if _storage._smallInt32 != rhs_storage._smallInt32 {return false} - if _storage._smallInt64 != rhs_storage._smallInt64 {return false} - if _storage._reallySmallInt32 != rhs_storage._reallySmallInt32 {return false} - if _storage._reallySmallInt64 != rhs_storage._reallySmallInt64 {return false} - if _storage._utf8String != rhs_storage._utf8String {return false} - if _storage._zeroFloat != rhs_storage._zeroFloat {return false} - if _storage._oneFloat != rhs_storage._oneFloat {return false} - if _storage._smallFloat != rhs_storage._smallFloat {return false} - if _storage._negativeOneFloat != rhs_storage._negativeOneFloat {return false} - if _storage._negativeFloat != rhs_storage._negativeFloat {return false} - if _storage._largeFloat != rhs_storage._largeFloat {return false} - if _storage._smallNegativeFloat != rhs_storage._smallNegativeFloat {return false} - if _storage._infDouble != rhs_storage._infDouble {return false} - if _storage._negInfDouble != rhs_storage._negInfDouble {return false} - if _storage._nanDouble != rhs_storage._nanDouble {return false} - if _storage._infFloat != rhs_storage._infFloat {return false} - if _storage._negInfFloat != rhs_storage._negInfFloat {return false} - if _storage._nanFloat != rhs_storage._nanFloat {return false} - if _storage._cppTrigraph != rhs_storage._cppTrigraph {return false} - if _storage._stringWithZero != rhs_storage._stringWithZero {return false} - if _storage._bytesWithZero != rhs_storage._bytesWithZero {return false} - if _storage._stringPieceWithZero != rhs_storage._stringPieceWithZero {return false} - if _storage._cordWithZero != rhs_storage._cordWithZero {return false} - if _storage._replacementString != rhs_storage._replacementString {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_SparseEnumMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".SparseEnumMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "sparse_enum"), - ] - - 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._sparseEnum) }() - 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 - try { if let v = self._sparseEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_SparseEnumMessage, rhs: ProtobufUnittest_SparseEnumMessage) -> Bool { - if lhs._sparseEnum != rhs._sparseEnum {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_OneString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".OneString" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] - - 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._data) }() - 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 - try { if let v = self._data { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_OneString, rhs: ProtobufUnittest_OneString) -> Bool { - if lhs._data != rhs._data {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_MoreString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".MoreString" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] - - 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.decodeRepeatedStringField(value: &self.data) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.data.isEmpty { - try visitor.visitRepeatedStringField(value: self.data, fieldNumber: 1) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_MoreString, rhs: ProtobufUnittest_MoreString) -> Bool { - if lhs.data != rhs.data {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_OneBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".OneBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] - - 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.decodeSingularBytesField(value: &self._data) }() - default: break + if _storage._optionalInt32 != rhs_storage._optionalInt32 {return false} + if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} + if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} + if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} + if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} + if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} + if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} + if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} + if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} + if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} + if _storage._optionalFloat != rhs_storage._optionalFloat {return false} + if _storage._optionalDouble != rhs_storage._optionalDouble {return false} + if _storage._optionalBool != rhs_storage._optionalBool {return false} + if _storage._optionalString != rhs_storage._optionalString {return false} + if _storage._optionalBytes != rhs_storage._optionalBytes {return false} + if _storage._optionalGroup != rhs_storage._optionalGroup {return false} + if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} + if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} + if _storage._optionalImportMessage != rhs_storage._optionalImportMessage {return false} + if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} + if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} + if _storage._optionalImportEnum != rhs_storage._optionalImportEnum {return false} + if _storage._optionalPublicImportMessage != rhs_storage._optionalPublicImportMessage {return false} + if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} + if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} + if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} + if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} + if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} + if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} + if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} + if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} + if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} + if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} + if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} + if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} + if _storage._repeatedBool != rhs_storage._repeatedBool {return false} + if _storage._repeatedString != rhs_storage._repeatedString {return false} + if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} + if _storage._repeatedGroup != rhs_storage._repeatedGroup {return false} + if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} + if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} + if _storage._repeatedImportMessage != rhs_storage._repeatedImportMessage {return false} + if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} + if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} + if _storage._repeatedImportEnum != rhs_storage._repeatedImportEnum {return false} + if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} + if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} + if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} + if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} + if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} + if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} + if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} + if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} + if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} + if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} + if _storage._defaultFloat != rhs_storage._defaultFloat {return false} + if _storage._defaultDouble != rhs_storage._defaultDouble {return false} + if _storage._defaultBool != rhs_storage._defaultBool {return false} + if _storage._defaultString != rhs_storage._defaultString {return false} + if _storage._defaultBytes != rhs_storage._defaultBytes {return false} + if _storage._defaultNestedEnum != rhs_storage._defaultNestedEnum {return false} + if _storage._defaultForeignEnum != rhs_storage._defaultForeignEnum {return false} + if _storage._defaultImportEnum != rhs_storage._defaultImportEnum {return false} + if _storage._oneofField != rhs_storage._oneofField {return false} + return true } + if !storagesAreEqual {return false} } - } - - 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 - try { if let v = self._data { - try visitor.visitSingularBytesField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_OneBytes, rhs: ProtobufUnittest_OneBytes) -> Bool { - if lhs._data != rhs._data {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_MoreBytes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".MoreBytes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] - - 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.decodeRepeatedBytesField(value: &self.data) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.data.isEmpty { - try visitor.visitRepeatedBytesField(value: self.data, fieldNumber: 1) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_MoreBytes, rhs: ProtobufUnittest_MoreBytes) -> Bool { - if lhs.data != rhs.data {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } +extension SwiftProtoTesting_TestAllTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{2}\u{2}FOO\0\u{1}BAR\0\u{1}BAZ\0") } -extension ProtobufUnittest_Int32Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".Int32Message" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] +extension SwiftProtoTesting_TestAllTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestAllTypes.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11266,7 +4189,7 @@ extension ProtobufUnittest_Int32Message: SwiftProtobuf.Message, SwiftProtobuf._M // 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._data) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self._bb) }() default: break } } @@ -11277,24 +4200,22 @@ extension ProtobufUnittest_Int32Message: SwiftProtobuf.Message, SwiftProtobuf._M // 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._data { + try { if let v = self._bb { try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Int32Message, rhs: ProtobufUnittest_Int32Message) -> Bool { - if lhs._data != rhs._data {return false} + static func ==(lhs: SwiftProtoTesting_TestAllTypes.NestedMessage, rhs: SwiftProtoTesting_TestAllTypes.NestedMessage) -> Bool { + if lhs._bb != rhs._bb {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Uint32Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".Uint32Message" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] +extension SwiftProtoTesting_TestAllTypes.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestAllTypes.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{11}a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11302,7 +4223,7 @@ extension ProtobufUnittest_Uint32Message: SwiftProtobuf.Message, SwiftProtobuf._ // 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._data) }() + case 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() default: break } } @@ -11313,24 +4234,22 @@ extension ProtobufUnittest_Uint32Message: SwiftProtobuf.Message, SwiftProtobuf._ // 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._data { - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 1) + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Uint32Message, rhs: ProtobufUnittest_Uint32Message) -> Bool { - if lhs._data != rhs._data {return false} + static func ==(lhs: SwiftProtoTesting_TestAllTypes.OptionalGroup, rhs: SwiftProtoTesting_TestAllTypes.OptionalGroup) -> Bool { + if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Int64Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".Int64Message" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] +extension SwiftProtoTesting_TestAllTypes.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestAllTypes.protoMessageName + ".RepeatedGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}/a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11338,7 +4257,7 @@ extension ProtobufUnittest_Int64Message: SwiftProtobuf.Message, SwiftProtobuf._M // 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.decodeSingularInt64Field(value: &self._data) }() + case 47: try { try decoder.decodeSingularInt32Field(value: &self._a) }() default: break } } @@ -11349,237 +4268,106 @@ extension ProtobufUnittest_Int64Message: SwiftProtobuf.Message, SwiftProtobuf._M // 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._data { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 1) + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Int64Message, rhs: ProtobufUnittest_Int64Message) -> Bool { - if lhs._data != rhs._data {return false} + static func ==(lhs: SwiftProtoTesting_TestAllTypes.RepeatedGroup, rhs: SwiftProtoTesting_TestAllTypes.RepeatedGroup) -> Bool { + if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Uint64Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".Uint64Message" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] - - 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.decodeSingularUInt64Field(value: &self._data) }() - default: break - } - } - } +extension SwiftProtoTesting_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NestedTestAllTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}child\0\u{1}payload\0\u{3}repeated_child\0") - 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 - try { if let v = self._data { - try visitor.visitSingularUInt64Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } + fileprivate class _StorageClass { + var _child: SwiftProtoTesting_NestedTestAllTypes? = nil + var _payload: SwiftProtoTesting_TestAllTypes? = nil + var _repeatedChild: [SwiftProtoTesting_NestedTestAllTypes] = [] - static func ==(lhs: ProtobufUnittest_Uint64Message, rhs: ProtobufUnittest_Uint64Message) -> Bool { - if lhs._data != rhs._data {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} + // 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() -extension ProtobufUnittest_BoolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".BoolMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] + private init() {} - 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.decodeSingularBoolField(value: &self._data) }() - default: break - } + init(copying source: _StorageClass) { + _child = source._child + _payload = source._payload + _repeatedChild = source._repeatedChild } } - 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 - try { if let v = self._data { - try visitor.visitSingularBoolField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_BoolMessage, rhs: ProtobufUnittest_BoolMessage) -> Bool { - if lhs._data != rhs._data {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage } -} - -extension ProtobufUnittest_TestOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestOneof" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "foo_int"), - 2: .standard(proto: "foo_string"), - 3: .standard(proto: "foo_message"), - 4: .unique(proto: "FooGroup", json: "foogroup"), - ] 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: Int32? - try decoder.decodeSingularInt32Field(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooInt(v) - } - }() - case 2: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooString(v) - } - }() - case 3: try { - var v: ProtobufUnittest_TestAllTypes? - var hadOneofValue = false - if let current = self.foo { - hadOneofValue = true - if case .fooMessage(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.foo = .fooMessage(v) - } - }() - case 4: try { - var v: ProtobufUnittest_TestOneof.FooGroup? - var hadOneofValue = false - if let current = self.foo { - hadOneofValue = true - if case .fooGroup(let m) = current {v = m} - } - try decoder.decodeSingularGroupField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.foo = .fooGroup(v) + _ = _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._child) }() + case 2: try { try decoder.decodeSingularMessageField(value: &_storage._payload) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedChild) }() + default: break } - }() - 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.foo { - case .fooInt?: try { - guard case .fooInt(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - }() - case .fooString?: try { - guard case .fooString(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 2) - }() - case .fooMessage?: try { - guard case .fooMessage(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - }() - case .fooGroup?: try { - guard case .fooGroup(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularGroupField(value: v, fieldNumber: 4) - }() - case nil: break - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestOneof, rhs: ProtobufUnittest_TestOneof) -> Bool { - if lhs.foo != rhs.foo {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestOneof.FooGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestOneof.protoMessageName + ".FooGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 5: .same(proto: "a"), - 6: .same(proto: "b"), - ] - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { + try withExtendedLifetime(_storage) { (_storage: _StorageClass) in // 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 5: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - case 6: try { try decoder.decodeSingularStringField(value: &self._b) }() - default: break + // 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._child { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._payload { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + if !_storage._repeatedChild.isEmpty { + try visitor.visitRepeatedMessageField(value: _storage._repeatedChild, fieldNumber: 3) } } - } - - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) - } }() - try { if let v = self._b { - try visitor.visitSingularStringField(value: v, fieldNumber: 6) - } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestOneof.FooGroup, rhs: ProtobufUnittest_TestOneof.FooGroup) -> Bool { - if lhs._a != rhs._a {return false} - if lhs._b != rhs._b {return false} + static func ==(lhs: SwiftProtoTesting_NestedTestAllTypes, rhs: SwiftProtoTesting_NestedTestAllTypes) -> 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._child != rhs_storage._child {return false} + if _storage._payload != rhs_storage._payload {return false} + if _storage._repeatedChild != rhs_storage._repeatedChild {return false} + return true + } + if !storagesAreEqual {return false} + } if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestOneofBackwardsCompatible: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestOneofBackwardsCompatible" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "foo_int"), - 2: .standard(proto: "foo_string"), - 3: .standard(proto: "foo_message"), - 4: .unique(proto: "FooGroup", json: "foogroup"), - ] +extension SwiftProtoTesting_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ForeignMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0\u{1}d\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11587,10 +4375,8 @@ extension ProtobufUnittest_TestOneofBackwardsCompatible: SwiftProtobuf.Message, // 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._fooInt) }() - case 2: try { try decoder.decodeSingularStringField(value: &self._fooString) }() - case 3: try { try decoder.decodeSingularMessageField(value: &self._fooMessage) }() - case 4: try { try decoder.decodeSingularGroupField(value: &self._fooGroup) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self._c) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._d) }() default: break } } @@ -11601,98 +4387,55 @@ extension ProtobufUnittest_TestOneofBackwardsCompatible: SwiftProtobuf.Message, // 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._fooInt { + try { if let v = self._c { try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) } }() - try { if let v = self._fooString { - try visitor.visitSingularStringField(value: v, fieldNumber: 2) - } }() - try { if let v = self._fooMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - } }() - try { if let v = self._fooGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 4) + try { if let v = self._d { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestOneofBackwardsCompatible, rhs: ProtobufUnittest_TestOneofBackwardsCompatible) -> Bool { - if lhs._fooInt != rhs._fooInt {return false} - if lhs._fooString != rhs._fooString {return false} - if lhs._fooMessage != rhs._fooMessage {return false} - if lhs._fooGroup != rhs._fooGroup {return false} + static func ==(lhs: SwiftProtoTesting_ForeignMessage, rhs: SwiftProtoTesting_ForeignMessage) -> Bool { + if lhs._c != rhs._c {return false} + if lhs._d != rhs._d {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestOneofBackwardsCompatible.FooGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestOneofBackwardsCompatible.protoMessageName + ".FooGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 5: .same(proto: "a"), - 6: .same(proto: "b"), - ] +extension SwiftProtoTesting_TestAllExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestAllExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } 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 5: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - case 6: try { try decoder.decodeSingularStringField(value: &self._b) }() - default: break + if (1 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_TestAllExtensions.self, fieldNumber: fieldNumber) } } } 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) - } }() - try { if let v = self._b { - try visitor.visitSingularStringField(value: v, fieldNumber: 6) - } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestOneofBackwardsCompatible.FooGroup, rhs: ProtobufUnittest_TestOneofBackwardsCompatible.FooGroup) -> Bool { - if lhs._a != rhs._a {return false} - if lhs._b != rhs._b {return false} + static func ==(lhs: SwiftProtoTesting_TestAllExtensions, rhs: SwiftProtoTesting_TestAllExtensions) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension ProtobufUnittest_TestOneof2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestOneof2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "foo_int"), - 2: .standard(proto: "foo_string"), - 3: .standard(proto: "foo_cord"), - 4: .standard(proto: "foo_string_piece"), - 5: .standard(proto: "foo_bytes"), - 6: .standard(proto: "foo_enum"), - 7: .standard(proto: "foo_message"), - 8: .unique(proto: "FooGroup", json: "foogroup"), - 11: .standard(proto: "foo_lazy_message"), - 12: .standard(proto: "bar_int"), - 13: .standard(proto: "bar_string"), - 14: .standard(proto: "bar_cord"), - 15: .standard(proto: "bar_string_piece"), - 16: .standard(proto: "bar_bytes"), - 17: .standard(proto: "bar_enum"), - 20: .standard(proto: "bar_string_with_empty_default"), - 21: .standard(proto: "bar_cord_with_empty_default"), - 22: .standard(proto: "bar_string_piece_with_empty_default"), - 23: .standard(proto: "bar_bytes_with_empty_default"), - 18: .standard(proto: "baz_int"), - 19: .standard(proto: "baz_string"), - ] +extension SwiftProtoTesting_OptionalGroup_extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".OptionalGroup_extension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{11}a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -11700,175 +4443,7 @@ extension ProtobufUnittest_TestOneof2: SwiftProtobuf.Message, SwiftProtobuf._Mes // 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: Int32? - try decoder.decodeSingularInt32Field(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooInt(v) - } - }() - case 2: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooString(v) - } - }() - case 3: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooCord(v) - } - }() - case 4: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooStringPiece(v) - } - }() - case 5: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooBytes(v) - } - }() - case 6: try { - var v: ProtobufUnittest_TestOneof2.NestedEnum? - try decoder.decodeSingularEnumField(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooEnum(v) - } - }() - case 7: try { - var v: ProtobufUnittest_TestOneof2.NestedMessage? - var hadOneofValue = false - if let current = self.foo { - hadOneofValue = true - if case .fooMessage(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.foo = .fooMessage(v) - } - }() - case 8: try { - var v: ProtobufUnittest_TestOneof2.FooGroup? - var hadOneofValue = false - if let current = self.foo { - hadOneofValue = true - if case .fooGroup(let m) = current {v = m} - } - try decoder.decodeSingularGroupField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.foo = .fooGroup(v) - } - }() - case 11: try { - var v: ProtobufUnittest_TestOneof2.NestedMessage? - var hadOneofValue = false - if let current = self.foo { - hadOneofValue = true - if case .fooLazyMessage(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.foo = .fooLazyMessage(v) - } - }() - case 12: try { - var v: Int32? - try decoder.decodeSingularInt32Field(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barInt(v) - } - }() - case 13: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barString(v) - } - }() - case 14: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barCord(v) - } - }() - case 15: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barStringPiece(v) - } - }() - case 16: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barBytes(v) - } - }() - case 17: try { - var v: ProtobufUnittest_TestOneof2.NestedEnum? - try decoder.decodeSingularEnumField(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barEnum(v) - } - }() - case 18: try { try decoder.decodeSingularInt32Field(value: &self._bazInt) }() - case 19: try { try decoder.decodeSingularStringField(value: &self._bazString) }() - case 20: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barStringWithEmptyDefault(v) - } - }() - case 21: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barCordWithEmptyDefault(v) - } - }() - case 22: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barStringPieceWithEmptyDefault(v) - } - }() - case 23: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if self.bar != nil {try decoder.handleConflictingOneOf()} - self.bar = .barBytesWithEmptyDefault(v) - } - }() + case 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() default: break } } @@ -11879,124 +4454,22 @@ extension ProtobufUnittest_TestOneof2: SwiftProtobuf.Message, SwiftProtobuf._Mes // 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.foo { - case .fooInt?: try { - guard case .fooInt(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - }() - case .fooString?: try { - guard case .fooString(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 2) - }() - case .fooCord?: try { - guard case .fooCord(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 3) - }() - case .fooStringPiece?: try { - guard case .fooStringPiece(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 4) - }() - case .fooBytes?: try { - guard case .fooBytes(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 5) - }() - case .fooEnum?: try { - guard case .fooEnum(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularEnumField(value: v, fieldNumber: 6) - }() - case .fooMessage?: try { - guard case .fooMessage(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 7) - }() - case .fooGroup?: try { - guard case .fooGroup(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularGroupField(value: v, fieldNumber: 8) - }() - case .fooLazyMessage?: try { - guard case .fooLazyMessage(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 11) - }() - case nil: break - } - switch self.bar { - case .barInt?: try { - guard case .barInt(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularInt32Field(value: v, fieldNumber: 12) - }() - case .barString?: try { - guard case .barString(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 13) - }() - case .barCord?: try { - guard case .barCord(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 14) - }() - case .barStringPiece?: try { - guard case .barStringPiece(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 15) - }() - case .barBytes?: try { - guard case .barBytes(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 16) - }() - case .barEnum?: try { - guard case .barEnum(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularEnumField(value: v, fieldNumber: 17) - }() - default: break - } - try { if let v = self._bazInt { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 18) - } }() - try { if let v = self._bazString { - try visitor.visitSingularStringField(value: v, fieldNumber: 19) + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) } }() - switch self.bar { - case .barStringWithEmptyDefault?: try { - guard case .barStringWithEmptyDefault(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 20) - }() - case .barCordWithEmptyDefault?: try { - guard case .barCordWithEmptyDefault(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 21) - }() - case .barStringPieceWithEmptyDefault?: try { - guard case .barStringPieceWithEmptyDefault(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 22) - }() - case .barBytesWithEmptyDefault?: try { - guard case .barBytesWithEmptyDefault(let v)? = self.bar else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 23) - }() - default: break - } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestOneof2, rhs: ProtobufUnittest_TestOneof2) -> Bool { - if lhs.foo != rhs.foo {return false} - if lhs.bar != rhs.bar {return false} - if lhs._bazInt != rhs._bazInt {return false} - if lhs._bazString != rhs._bazString {return false} + static func ==(lhs: SwiftProtoTesting_OptionalGroup_extension, rhs: SwiftProtoTesting_OptionalGroup_extension) -> Bool { + if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestOneof2.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - 3: .same(proto: "BAZ"), - ] -} - -extension ProtobufUnittest_TestOneof2.FooGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestOneof2.protoMessageName + ".FooGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 9: .same(proto: "a"), - 10: .same(proto: "b"), - ] +extension SwiftProtoTesting_RepeatedGroup_extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".RepeatedGroup_extension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}/a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12004,8 +4477,7 @@ extension ProtobufUnittest_TestOneof2.FooGroup: SwiftProtobuf.Message, SwiftProt // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { - case 9: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - case 10: try { try decoder.decodeSingularStringField(value: &self._b) }() + case 47: try { try decoder.decodeSingularInt32Field(value: &self._a) }() default: break } } @@ -12017,155 +4489,354 @@ extension ProtobufUnittest_TestOneof2.FooGroup: SwiftProtobuf.Message, SwiftProt // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and // https://github.com/apple/swift-protobuf/issues/1182 try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) - } }() - try { if let v = self._b { - try visitor.visitSingularStringField(value: v, fieldNumber: 10) + try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestOneof2.FooGroup, rhs: ProtobufUnittest_TestOneof2.FooGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_RepeatedGroup_extension, rhs: SwiftProtoTesting_RepeatedGroup_extension) -> Bool { if lhs._a != rhs._a {return false} - if lhs._b != rhs._b {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestOneof2.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestOneof2.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "qux_int"), - 2: .standard(proto: "corge_int"), - ] +extension SwiftProtoTesting_TestNestedExtension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestNestedExtension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestNestedExtension, rhs: SwiftProtoTesting_TestNestedExtension) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestRequired: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequired" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}dummy2\0\u{1}b\0\u{1}dummy4\0\u{1}dummy5\0\u{1}dummy6\0\u{1}dummy7\0\u{1}dummy8\0\u{1}dummy9\0\u{1}dummy10\0\u{1}dummy11\0\u{1}dummy12\0\u{1}dummy13\0\u{1}dummy14\0\u{1}dummy15\0\u{1}dummy16\0\u{1}dummy17\0\u{1}dummy18\0\u{1}dummy19\0\u{1}dummy20\0\u{1}dummy21\0\u{1}dummy22\0\u{1}dummy23\0\u{1}dummy24\0\u{1}dummy25\0\u{1}dummy26\0\u{1}dummy27\0\u{1}dummy28\0\u{1}dummy29\0\u{1}dummy30\0\u{1}dummy31\0\u{1}dummy32\0\u{1}c\0\u{3}optional_foreign\0") + + fileprivate class _StorageClass { + var _a: Int32? = nil + var _dummy2: Int32? = nil + var _b: Int32? = nil + var _dummy4: Int32? = nil + var _dummy5: Int32? = nil + var _dummy6: Int32? = nil + var _dummy7: Int32? = nil + var _dummy8: Int32? = nil + var _dummy9: Int32? = nil + var _dummy10: Int32? = nil + var _dummy11: Int32? = nil + var _dummy12: Int32? = nil + var _dummy13: Int32? = nil + var _dummy14: Int32? = nil + var _dummy15: Int32? = nil + var _dummy16: Int32? = nil + var _dummy17: Int32? = nil + var _dummy18: Int32? = nil + var _dummy19: Int32? = nil + var _dummy20: Int32? = nil + var _dummy21: Int32? = nil + var _dummy22: Int32? = nil + var _dummy23: Int32? = nil + var _dummy24: Int32? = nil + var _dummy25: Int32? = nil + var _dummy26: Int32? = nil + var _dummy27: Int32? = nil + var _dummy28: Int32? = nil + var _dummy29: Int32? = nil + var _dummy30: Int32? = nil + var _dummy31: Int32? = nil + var _dummy32: Int32? = nil + var _c: Int32? = nil + var _optionalForeign: SwiftProtoTesting_ForeignMessage? = nil + + // 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() - 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.decodeSingularInt64Field(value: &self._quxInt) }() - case 2: try { try decoder.decodeRepeatedInt32Field(value: &self.corgeInt) }() - default: break - } - } - } + private init() {} - 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 - try { if let v = self._quxInt { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 1) - } }() - if !self.corgeInt.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.corgeInt, fieldNumber: 2) + init(copying source: _StorageClass) { + _a = source._a + _dummy2 = source._dummy2 + _b = source._b + _dummy4 = source._dummy4 + _dummy5 = source._dummy5 + _dummy6 = source._dummy6 + _dummy7 = source._dummy7 + _dummy8 = source._dummy8 + _dummy9 = source._dummy9 + _dummy10 = source._dummy10 + _dummy11 = source._dummy11 + _dummy12 = source._dummy12 + _dummy13 = source._dummy13 + _dummy14 = source._dummy14 + _dummy15 = source._dummy15 + _dummy16 = source._dummy16 + _dummy17 = source._dummy17 + _dummy18 = source._dummy18 + _dummy19 = source._dummy19 + _dummy20 = source._dummy20 + _dummy21 = source._dummy21 + _dummy22 = source._dummy22 + _dummy23 = source._dummy23 + _dummy24 = source._dummy24 + _dummy25 = source._dummy25 + _dummy26 = source._dummy26 + _dummy27 = source._dummy27 + _dummy28 = source._dummy28 + _dummy29 = source._dummy29 + _dummy30 = source._dummy30 + _dummy31 = source._dummy31 + _dummy32 = source._dummy32 + _c = source._c + _optionalForeign = source._optionalForeign } - try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestOneof2.NestedMessage, rhs: ProtobufUnittest_TestOneof2.NestedMessage) -> Bool { - if lhs._quxInt != rhs._quxInt {return false} - if lhs.corgeInt != rhs.corgeInt {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage } -} - -extension ProtobufUnittest_TestRequiredOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestRequiredOneof" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "foo_int"), - 2: .standard(proto: "foo_string"), - 3: .standard(proto: "foo_message"), - ] public var isInitialized: Bool { - if let v = self.foo, !v.isInitialized {return false} - return true + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._a == nil {return false} + if _storage._b == nil {return false} + if _storage._c == nil {return false} + return true + } } 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: Int32? - try decoder.decodeSingularInt32Field(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooInt(v) - } - }() - case 2: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooString(v) - } - }() - case 3: try { - var v: ProtobufUnittest_TestRequiredOneof.NestedMessage? - var hadOneofValue = false - if let current = self.foo { - hadOneofValue = true - if case .fooMessage(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.foo = .fooMessage(v) + _ = _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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy2) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &_storage._b) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy4) }() + case 5: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy5) }() + case 6: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy6) }() + case 7: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy7) }() + case 8: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy8) }() + case 9: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy9) }() + case 10: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy10) }() + case 11: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy11) }() + case 12: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy12) }() + case 13: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy13) }() + case 14: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy14) }() + case 15: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy15) }() + case 16: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy16) }() + case 17: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy17) }() + case 18: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy18) }() + case 19: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy19) }() + case 20: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy20) }() + case 21: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy21) }() + case 22: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy22) }() + case 23: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy23) }() + case 24: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy24) }() + case 25: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy25) }() + case 26: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy26) }() + case 27: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy27) }() + case 28: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy28) }() + case 29: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy29) }() + case 30: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy30) }() + case 31: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy31) }() + case 32: try { try decoder.decodeSingularInt32Field(value: &_storage._dummy32) }() + case 33: try { try decoder.decodeSingularInt32Field(value: &_storage._c) }() + case 34: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeign) }() + default: break } - }() - 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.foo { - case .fooInt?: try { - guard case .fooInt(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - }() - case .fooString?: try { - guard case .fooString(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 2) - }() - case .fooMessage?: try { - guard case .fooMessage(let v)? = self.foo else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - }() - case nil: break + 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._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._dummy2 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._b { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._dummy4 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._dummy5 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._dummy6 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._dummy7 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._dummy8 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._dummy9 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._dummy10 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._dummy11 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._dummy12 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._dummy13 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._dummy14 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._dummy15 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._dummy16 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._dummy17 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) + } }() + try { if let v = _storage._dummy18 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._dummy19 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._dummy20 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 20) + } }() + try { if let v = _storage._dummy21 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._dummy22 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._dummy23 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 23) + } }() + try { if let v = _storage._dummy24 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._dummy25 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 25) + } }() + try { if let v = _storage._dummy26 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 26) + } }() + try { if let v = _storage._dummy27 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 27) + } }() + try { if let v = _storage._dummy28 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 28) + } }() + try { if let v = _storage._dummy29 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 29) + } }() + try { if let v = _storage._dummy30 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 30) + } }() + try { if let v = _storage._dummy31 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 31) + } }() + try { if let v = _storage._dummy32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 32) + } }() + try { if let v = _storage._c { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 33) + } }() + try { if let v = _storage._optionalForeign { + try visitor.visitSingularMessageField(value: v, fieldNumber: 34) + } }() } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestRequiredOneof, rhs: ProtobufUnittest_TestRequiredOneof) -> Bool { - if lhs.foo != rhs.foo {return false} + static func ==(lhs: SwiftProtoTesting_TestRequired, rhs: SwiftProtoTesting_TestRequired) -> 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._a != rhs_storage._a {return false} + if _storage._dummy2 != rhs_storage._dummy2 {return false} + if _storage._b != rhs_storage._b {return false} + if _storage._dummy4 != rhs_storage._dummy4 {return false} + if _storage._dummy5 != rhs_storage._dummy5 {return false} + if _storage._dummy6 != rhs_storage._dummy6 {return false} + if _storage._dummy7 != rhs_storage._dummy7 {return false} + if _storage._dummy8 != rhs_storage._dummy8 {return false} + if _storage._dummy9 != rhs_storage._dummy9 {return false} + if _storage._dummy10 != rhs_storage._dummy10 {return false} + if _storage._dummy11 != rhs_storage._dummy11 {return false} + if _storage._dummy12 != rhs_storage._dummy12 {return false} + if _storage._dummy13 != rhs_storage._dummy13 {return false} + if _storage._dummy14 != rhs_storage._dummy14 {return false} + if _storage._dummy15 != rhs_storage._dummy15 {return false} + if _storage._dummy16 != rhs_storage._dummy16 {return false} + if _storage._dummy17 != rhs_storage._dummy17 {return false} + if _storage._dummy18 != rhs_storage._dummy18 {return false} + if _storage._dummy19 != rhs_storage._dummy19 {return false} + if _storage._dummy20 != rhs_storage._dummy20 {return false} + if _storage._dummy21 != rhs_storage._dummy21 {return false} + if _storage._dummy22 != rhs_storage._dummy22 {return false} + if _storage._dummy23 != rhs_storage._dummy23 {return false} + if _storage._dummy24 != rhs_storage._dummy24 {return false} + if _storage._dummy25 != rhs_storage._dummy25 {return false} + if _storage._dummy26 != rhs_storage._dummy26 {return false} + if _storage._dummy27 != rhs_storage._dummy27 {return false} + if _storage._dummy28 != rhs_storage._dummy28 {return false} + if _storage._dummy29 != rhs_storage._dummy29 {return false} + if _storage._dummy30 != rhs_storage._dummy30 {return false} + if _storage._dummy31 != rhs_storage._dummy31 {return false} + if _storage._dummy32 != rhs_storage._dummy32 {return false} + if _storage._c != rhs_storage._c {return false} + if _storage._optionalForeign != rhs_storage._optionalForeign {return false} + return true + } + if !storagesAreEqual {return false} + } if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestRequiredOneof.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestRequiredOneof.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "required_double"), - ] +extension SwiftProtoTesting_TestRequiredForeign: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredForeign" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_message\0\u{3}repeated_message\0\u{1}dummy\0") public var isInitialized: Bool { - if self._requiredDouble == nil {return false} + if let v = self._optionalMessage, !v.isInitialized {return false} + if !SwiftProtobuf.Internal.areAllInitialized(self.repeatedMessage) {return false} return true } @@ -12175,7 +4846,9 @@ extension ProtobufUnittest_TestRequiredOneof.NestedMessage: SwiftProtobuf.Messag // 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.decodeSingularDoubleField(value: &self._requiredDouble) }() + case 1: try { try decoder.decodeSingularMessageField(value: &self._optionalMessage) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedMessage) }() + case 3: try { try decoder.decodeSingularInt32Field(value: &self._dummy) }() default: break } } @@ -12185,309 +4858,102 @@ extension ProtobufUnittest_TestRequiredOneof.NestedMessage: SwiftProtobuf.Messag // 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._requiredDouble { - try visitor.visitSingularDoubleField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestRequiredOneof.NestedMessage, rhs: ProtobufUnittest_TestRequiredOneof.NestedMessage) -> Bool { - if lhs._requiredDouble != rhs._requiredDouble {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestPackedTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 90: .standard(proto: "packed_int32"), - 91: .standard(proto: "packed_int64"), - 92: .standard(proto: "packed_uint32"), - 93: .standard(proto: "packed_uint64"), - 94: .standard(proto: "packed_sint32"), - 95: .standard(proto: "packed_sint64"), - 96: .standard(proto: "packed_fixed32"), - 97: .standard(proto: "packed_fixed64"), - 98: .standard(proto: "packed_sfixed32"), - 99: .standard(proto: "packed_sfixed64"), - 100: .standard(proto: "packed_float"), - 101: .standard(proto: "packed_double"), - 102: .standard(proto: "packed_bool"), - 103: .standard(proto: "packed_enum"), - ] - - 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 90: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32) }() - case 91: try { try decoder.decodeRepeatedInt64Field(value: &self.packedInt64) }() - case 92: try { try decoder.decodeRepeatedUInt32Field(value: &self.packedUint32) }() - case 93: try { try decoder.decodeRepeatedUInt64Field(value: &self.packedUint64) }() - case 94: try { try decoder.decodeRepeatedSInt32Field(value: &self.packedSint32) }() - case 95: try { try decoder.decodeRepeatedSInt64Field(value: &self.packedSint64) }() - case 96: try { try decoder.decodeRepeatedFixed32Field(value: &self.packedFixed32) }() - case 97: try { try decoder.decodeRepeatedFixed64Field(value: &self.packedFixed64) }() - case 98: try { try decoder.decodeRepeatedSFixed32Field(value: &self.packedSfixed32) }() - case 99: try { try decoder.decodeRepeatedSFixed64Field(value: &self.packedSfixed64) }() - case 100: try { try decoder.decodeRepeatedFloatField(value: &self.packedFloat) }() - case 101: try { try decoder.decodeRepeatedDoubleField(value: &self.packedDouble) }() - case 102: try { try decoder.decodeRepeatedBoolField(value: &self.packedBool) }() - case 103: try { try decoder.decodeRepeatedEnumField(value: &self.packedEnum) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.packedInt32.isEmpty { - try visitor.visitPackedInt32Field(value: self.packedInt32, fieldNumber: 90) - } - if !self.packedInt64.isEmpty { - try visitor.visitPackedInt64Field(value: self.packedInt64, fieldNumber: 91) - } - if !self.packedUint32.isEmpty { - try visitor.visitPackedUInt32Field(value: self.packedUint32, fieldNumber: 92) - } - if !self.packedUint64.isEmpty { - try visitor.visitPackedUInt64Field(value: self.packedUint64, fieldNumber: 93) - } - if !self.packedSint32.isEmpty { - try visitor.visitPackedSInt32Field(value: self.packedSint32, fieldNumber: 94) - } - if !self.packedSint64.isEmpty { - try visitor.visitPackedSInt64Field(value: self.packedSint64, fieldNumber: 95) - } - if !self.packedFixed32.isEmpty { - try visitor.visitPackedFixed32Field(value: self.packedFixed32, fieldNumber: 96) - } - if !self.packedFixed64.isEmpty { - try visitor.visitPackedFixed64Field(value: self.packedFixed64, fieldNumber: 97) - } - if !self.packedSfixed32.isEmpty { - try visitor.visitPackedSFixed32Field(value: self.packedSfixed32, fieldNumber: 98) - } - if !self.packedSfixed64.isEmpty { - try visitor.visitPackedSFixed64Field(value: self.packedSfixed64, fieldNumber: 99) - } - if !self.packedFloat.isEmpty { - try visitor.visitPackedFloatField(value: self.packedFloat, fieldNumber: 100) - } - if !self.packedDouble.isEmpty { - try visitor.visitPackedDoubleField(value: self.packedDouble, fieldNumber: 101) - } - if !self.packedBool.isEmpty { - try visitor.visitPackedBoolField(value: self.packedBool, fieldNumber: 102) - } - if !self.packedEnum.isEmpty { - try visitor.visitPackedEnumField(value: self.packedEnum, fieldNumber: 103) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestPackedTypes, rhs: ProtobufUnittest_TestPackedTypes) -> Bool { - if lhs.packedInt32 != rhs.packedInt32 {return false} - if lhs.packedInt64 != rhs.packedInt64 {return false} - if lhs.packedUint32 != rhs.packedUint32 {return false} - if lhs.packedUint64 != rhs.packedUint64 {return false} - if lhs.packedSint32 != rhs.packedSint32 {return false} - if lhs.packedSint64 != rhs.packedSint64 {return false} - if lhs.packedFixed32 != rhs.packedFixed32 {return false} - if lhs.packedFixed64 != rhs.packedFixed64 {return false} - if lhs.packedSfixed32 != rhs.packedSfixed32 {return false} - if lhs.packedSfixed64 != rhs.packedSfixed64 {return false} - if lhs.packedFloat != rhs.packedFloat {return false} - if lhs.packedDouble != rhs.packedDouble {return false} - if lhs.packedBool != rhs.packedBool {return false} - if lhs.packedEnum != rhs.packedEnum {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestUnpackedTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 90: .standard(proto: "unpacked_int32"), - 91: .standard(proto: "unpacked_int64"), - 92: .standard(proto: "unpacked_uint32"), - 93: .standard(proto: "unpacked_uint64"), - 94: .standard(proto: "unpacked_sint32"), - 95: .standard(proto: "unpacked_sint64"), - 96: .standard(proto: "unpacked_fixed32"), - 97: .standard(proto: "unpacked_fixed64"), - 98: .standard(proto: "unpacked_sfixed32"), - 99: .standard(proto: "unpacked_sfixed64"), - 100: .standard(proto: "unpacked_float"), - 101: .standard(proto: "unpacked_double"), - 102: .standard(proto: "unpacked_bool"), - 103: .standard(proto: "unpacked_enum"), - ] - - 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 90: try { try decoder.decodeRepeatedInt32Field(value: &self.unpackedInt32) }() - case 91: try { try decoder.decodeRepeatedInt64Field(value: &self.unpackedInt64) }() - case 92: try { try decoder.decodeRepeatedUInt32Field(value: &self.unpackedUint32) }() - case 93: try { try decoder.decodeRepeatedUInt64Field(value: &self.unpackedUint64) }() - case 94: try { try decoder.decodeRepeatedSInt32Field(value: &self.unpackedSint32) }() - case 95: try { try decoder.decodeRepeatedSInt64Field(value: &self.unpackedSint64) }() - case 96: try { try decoder.decodeRepeatedFixed32Field(value: &self.unpackedFixed32) }() - case 97: try { try decoder.decodeRepeatedFixed64Field(value: &self.unpackedFixed64) }() - case 98: try { try decoder.decodeRepeatedSFixed32Field(value: &self.unpackedSfixed32) }() - case 99: try { try decoder.decodeRepeatedSFixed64Field(value: &self.unpackedSfixed64) }() - case 100: try { try decoder.decodeRepeatedFloatField(value: &self.unpackedFloat) }() - case 101: try { try decoder.decodeRepeatedDoubleField(value: &self.unpackedDouble) }() - case 102: try { try decoder.decodeRepeatedBoolField(value: &self.unpackedBool) }() - case 103: try { try decoder.decodeRepeatedEnumField(value: &self.unpackedEnum) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.unpackedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.unpackedInt32, fieldNumber: 90) - } - if !self.unpackedInt64.isEmpty { - try visitor.visitRepeatedInt64Field(value: self.unpackedInt64, fieldNumber: 91) - } - if !self.unpackedUint32.isEmpty { - try visitor.visitRepeatedUInt32Field(value: self.unpackedUint32, fieldNumber: 92) - } - if !self.unpackedUint64.isEmpty { - try visitor.visitRepeatedUInt64Field(value: self.unpackedUint64, fieldNumber: 93) - } - if !self.unpackedSint32.isEmpty { - try visitor.visitRepeatedSInt32Field(value: self.unpackedSint32, fieldNumber: 94) - } - if !self.unpackedSint64.isEmpty { - try visitor.visitRepeatedSInt64Field(value: self.unpackedSint64, fieldNumber: 95) - } - if !self.unpackedFixed32.isEmpty { - try visitor.visitRepeatedFixed32Field(value: self.unpackedFixed32, fieldNumber: 96) - } - if !self.unpackedFixed64.isEmpty { - try visitor.visitRepeatedFixed64Field(value: self.unpackedFixed64, fieldNumber: 97) - } - if !self.unpackedSfixed32.isEmpty { - try visitor.visitRepeatedSFixed32Field(value: self.unpackedSfixed32, fieldNumber: 98) - } - if !self.unpackedSfixed64.isEmpty { - try visitor.visitRepeatedSFixed64Field(value: self.unpackedSfixed64, fieldNumber: 99) - } - if !self.unpackedFloat.isEmpty { - try visitor.visitRepeatedFloatField(value: self.unpackedFloat, fieldNumber: 100) - } - if !self.unpackedDouble.isEmpty { - try visitor.visitRepeatedDoubleField(value: self.unpackedDouble, fieldNumber: 101) - } - if !self.unpackedBool.isEmpty { - try visitor.visitRepeatedBoolField(value: self.unpackedBool, fieldNumber: 102) - } - if !self.unpackedEnum.isEmpty { - try visitor.visitRepeatedEnumField(value: self.unpackedEnum, fieldNumber: 103) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestUnpackedTypes, rhs: ProtobufUnittest_TestUnpackedTypes) -> Bool { - if lhs.unpackedInt32 != rhs.unpackedInt32 {return false} - if lhs.unpackedInt64 != rhs.unpackedInt64 {return false} - if lhs.unpackedUint32 != rhs.unpackedUint32 {return false} - if lhs.unpackedUint64 != rhs.unpackedUint64 {return false} - if lhs.unpackedSint32 != rhs.unpackedSint32 {return false} - if lhs.unpackedSint64 != rhs.unpackedSint64 {return false} - if lhs.unpackedFixed32 != rhs.unpackedFixed32 {return false} - if lhs.unpackedFixed64 != rhs.unpackedFixed64 {return false} - if lhs.unpackedSfixed32 != rhs.unpackedSfixed32 {return false} - if lhs.unpackedSfixed64 != rhs.unpackedSfixed64 {return false} - if lhs.unpackedFloat != rhs.unpackedFloat {return false} - if lhs.unpackedDouble != rhs.unpackedDouble {return false} - if lhs.unpackedBool != rhs.unpackedBool {return false} - if lhs.unpackedEnum != rhs.unpackedEnum {return false} + // https://github.com/apple/swift-protobuf/issues/1182 + try { if let v = self._optionalMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + if !self.repeatedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedMessage, fieldNumber: 2) + } + try { if let v = self._dummy { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestRequiredForeign, rhs: SwiftProtoTesting_TestRequiredForeign) -> Bool { + if lhs._optionalMessage != rhs._optionalMessage {return false} + if lhs.repeatedMessage != rhs.repeatedMessage {return false} + if lhs._dummy != rhs._dummy {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestPackedExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestPackedExtensions" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() +extension SwiftProtoTesting_TestRequiredMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_message\0\u{3}repeated_message\0\u{3}required_message\0") public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} + if self._requiredMessage == nil {return false} + if let v = self._optionalMessage, !v.isInitialized {return false} + if !SwiftProtobuf.Internal.areAllInitialized(self.repeatedMessage) {return false} + if let v = self._requiredMessage, !v.isInitialized {return false} return true } mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { - if (1 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestPackedExtensions.self, fieldNumber: fieldNumber) + // 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._optionalMessage) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedMessage) }() + case 3: try { try decoder.decodeSingularMessageField(value: &self._requiredMessage) }() + default: break } } } func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) + // 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._optionalMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + if !self.repeatedMessage.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedMessage, fieldNumber: 2) + } + try { if let v = self._requiredMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestPackedExtensions, rhs: ProtobufUnittest_TestPackedExtensions) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestRequiredMessage, rhs: SwiftProtoTesting_TestRequiredMessage) -> Bool { + if lhs._optionalMessage != rhs._optionalMessage {return false} + if lhs.repeatedMessage != rhs.repeatedMessage {return false} + if lhs._requiredMessage != rhs._requiredMessage {return false} if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension ProtobufUnittest_TestUnpackedExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestUnpackedExtensions" +extension SwiftProtoTesting_TestEmptyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestEmptyMessage" static let _protobuf_nameMap = SwiftProtobuf._NameMap() - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestUnpackedExtensions.self, fieldNumber: fieldNumber) - } - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestUnpackedExtensions, rhs: ProtobufUnittest_TestUnpackedExtensions) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestEmptyMessage, rhs: SwiftProtoTesting_TestEmptyMessage) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension ProtobufUnittest_TestDynamicExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestDynamicExtensions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2000: .standard(proto: "scalar_extension"), - 2001: .standard(proto: "enum_extension"), - 2002: .standard(proto: "dynamic_enum_extension"), - 2003: .standard(proto: "message_extension"), - 2004: .standard(proto: "dynamic_message_extension"), - 2005: .standard(proto: "repeated_extension"), - 2006: .standard(proto: "packed_extension"), - ] +extension SwiftProtoTesting_TestReallyLargeTagNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestReallyLargeTagNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{2}~\u{7f}\u{7f}\u{7f}\u{f}bb\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12495,13 +4961,8 @@ extension ProtobufUnittest_TestDynamicExtensions: SwiftProtobuf.Message, SwiftPr // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { - case 2000: try { try decoder.decodeSingularFixed32Field(value: &self._scalarExtension) }() - case 2001: try { try decoder.decodeSingularEnumField(value: &self._enumExtension) }() - case 2002: try { try decoder.decodeSingularEnumField(value: &self._dynamicEnumExtension) }() - case 2003: try { try decoder.decodeSingularMessageField(value: &self._messageExtension) }() - case 2004: try { try decoder.decodeSingularMessageField(value: &self._dynamicMessageExtension) }() - case 2005: try { try decoder.decodeRepeatedStringField(value: &self.repeatedExtension) }() - case 2006: try { try decoder.decodeRepeatedSInt32Field(value: &self.packedExtension) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + case 268435455: try { try decoder.decodeSingularInt32Field(value: &self._bb) }() default: break } } @@ -12512,56 +4973,108 @@ extension ProtobufUnittest_TestDynamicExtensions: SwiftProtobuf.Message, SwiftPr // 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._scalarExtension { - try visitor.visitSingularFixed32Field(value: v, fieldNumber: 2000) - } }() - try { if let v = self._enumExtension { - try visitor.visitSingularEnumField(value: v, fieldNumber: 2001) - } }() - try { if let v = self._dynamicEnumExtension { - try visitor.visitSingularEnumField(value: v, fieldNumber: 2002) - } }() - try { if let v = self._messageExtension { - try visitor.visitSingularMessageField(value: v, fieldNumber: 2003) + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) } }() - try { if let v = self._dynamicMessageExtension { - try visitor.visitSingularMessageField(value: v, fieldNumber: 2004) + try { if let v = self._bb { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 268435455) } }() - if !self.repeatedExtension.isEmpty { - try visitor.visitRepeatedStringField(value: self.repeatedExtension, fieldNumber: 2005) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestReallyLargeTagNumber, rhs: SwiftProtoTesting_TestReallyLargeTagNumber) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._bb != rhs._bb {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_TestRecursiveMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRecursiveMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}i\0") + + fileprivate class _StorageClass { + var _a: SwiftProtoTesting_TestRecursiveMessage? = nil + var _i: Int32? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _a = source._a + _i = source._i + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + mutating func decodeMessage(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._a) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._i) }() + default: break + } + } } - if !self.packedExtension.isEmpty { - try visitor.visitPackedSInt32Field(value: self.packedExtension, fieldNumber: 2006) + } + + func traverse(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._a { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._i { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestDynamicExtensions, rhs: ProtobufUnittest_TestDynamicExtensions) -> Bool { - if lhs._scalarExtension != rhs._scalarExtension {return false} - if lhs._enumExtension != rhs._enumExtension {return false} - if lhs._dynamicEnumExtension != rhs._dynamicEnumExtension {return false} - if lhs._messageExtension != rhs._messageExtension {return false} - if lhs._dynamicMessageExtension != rhs._dynamicMessageExtension {return false} - if lhs.repeatedExtension != rhs.repeatedExtension {return false} - if lhs.packedExtension != rhs.packedExtension {return false} + static func ==(lhs: SwiftProtoTesting_TestRecursiveMessage, rhs: SwiftProtoTesting_TestRecursiveMessage) -> 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._a != rhs_storage._a {return false} + if _storage._i != rhs_storage._i {return false} + return true + } + if !storagesAreEqual {return false} + } if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestDynamicExtensions.DynamicEnumType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2200: .same(proto: "DYNAMIC_FOO"), - 2201: .same(proto: "DYNAMIC_BAR"), - 2202: .same(proto: "DYNAMIC_BAZ"), - ] -} +extension SwiftProtoTesting_TestFieldOrderings: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestFieldOrderings" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}my_int\0\u{4}\u{a}my_string\0\u{4}Z\u{1}my_float\0\u{4}c\u{1}optional_nested_message\0") -extension ProtobufUnittest_TestDynamicExtensions.DynamicMessageType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestDynamicExtensions.protoMessageName + ".DynamicMessageType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2100: .standard(proto: "dynamic_field"), - ] + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12569,7 +5082,12 @@ extension ProtobufUnittest_TestDynamicExtensions.DynamicMessageType: SwiftProtob // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { - case 2100: try { try decoder.decodeSingularInt32Field(value: &self._dynamicField) }() + case 1: try { try decoder.decodeSingularInt64Field(value: &self._myInt) }() + case 11: try { try decoder.decodeSingularStringField(value: &self._myString) }() + case 101: try { try decoder.decodeSingularFloatField(value: &self._myFloat) }() + case 200: try { try decoder.decodeSingularMessageField(value: &self._optionalNestedMessage) }() + case 2..<11, 12..<101: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_TestFieldOrderings.self, fieldNumber: fieldNumber) }() default: break } } @@ -12580,29 +5098,37 @@ extension ProtobufUnittest_TestDynamicExtensions.DynamicMessageType: SwiftProtob // 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._dynamicField { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2100) + try { if let v = self._myInt { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 1) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2, end: 11) + try { if let v = self._myString { + try visitor.visitSingularStringField(value: v, fieldNumber: 11) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 12, end: 101) + try { if let v = self._myFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 101) + } }() + try { if let v = self._optionalNestedMessage { + try visitor.visitSingularMessageField(value: v, fieldNumber: 200) } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestDynamicExtensions.DynamicMessageType, rhs: ProtobufUnittest_TestDynamicExtensions.DynamicMessageType) -> Bool { - if lhs._dynamicField != rhs._dynamicField {return false} + static func ==(lhs: SwiftProtoTesting_TestFieldOrderings, rhs: SwiftProtoTesting_TestFieldOrderings) -> Bool { + if lhs._myString != rhs._myString {return false} + if lhs._myInt != rhs._myInt {return false} + if lhs._myFloat != rhs._myFloat {return false} + if lhs._optionalNestedMessage != rhs._optionalNestedMessage {return false} if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension ProtobufUnittest_TestRepeatedScalarDifferentTagSizes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestRepeatedScalarDifferentTagSizes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 12: .standard(proto: "repeated_fixed32"), - 13: .standard(proto: "repeated_int32"), - 2046: .standard(proto: "repeated_fixed64"), - 2047: .standard(proto: "repeated_int64"), - 262142: .standard(proto: "repeated_float"), - 262143: .standard(proto: "repeated_uint64"), - ] +extension SwiftProtoTesting_TestFieldOrderings.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestFieldOrderings.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0\u{1}oo\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12610,132 +5136,276 @@ extension ProtobufUnittest_TestRepeatedScalarDifferentTagSizes: SwiftProtobuf.Me // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { - case 12: try { try decoder.decodeRepeatedFixed32Field(value: &self.repeatedFixed32) }() - case 13: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() - case 2046: try { try decoder.decodeRepeatedFixed64Field(value: &self.repeatedFixed64) }() - case 2047: try { try decoder.decodeRepeatedInt64Field(value: &self.repeatedInt64) }() - case 262142: try { try decoder.decodeRepeatedFloatField(value: &self.repeatedFloat) }() - case 262143: try { try decoder.decodeRepeatedUInt64Field(value: &self.repeatedUint64) }() + case 1: try { try decoder.decodeSingularInt32Field(value: &self._bb) }() + case 2: try { try decoder.decodeSingularInt64Field(value: &self._oo) }() default: break } } } func traverse(visitor: inout V) throws { - if !self.repeatedFixed32.isEmpty { - try visitor.visitRepeatedFixed32Field(value: self.repeatedFixed32, fieldNumber: 12) - } - if !self.repeatedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 13) - } - if !self.repeatedFixed64.isEmpty { - try visitor.visitRepeatedFixed64Field(value: self.repeatedFixed64, fieldNumber: 2046) - } - if !self.repeatedInt64.isEmpty { - try visitor.visitRepeatedInt64Field(value: self.repeatedInt64, fieldNumber: 2047) - } - if !self.repeatedFloat.isEmpty { - try visitor.visitRepeatedFloatField(value: self.repeatedFloat, fieldNumber: 262142) - } - if !self.repeatedUint64.isEmpty { - try visitor.visitRepeatedUInt64Field(value: self.repeatedUint64, fieldNumber: 262143) - } + // 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._bb { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._oo { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) + } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestRepeatedScalarDifferentTagSizes, rhs: ProtobufUnittest_TestRepeatedScalarDifferentTagSizes) -> Bool { - if lhs.repeatedFixed32 != rhs.repeatedFixed32 {return false} - if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} - if lhs.repeatedFixed64 != rhs.repeatedFixed64 {return false} - if lhs.repeatedInt64 != rhs.repeatedInt64 {return false} - if lhs.repeatedFloat != rhs.repeatedFloat {return false} - if lhs.repeatedUint64 != rhs.repeatedUint64 {return false} + static func ==(lhs: SwiftProtoTesting_TestFieldOrderings.NestedMessage, rhs: SwiftProtoTesting_TestFieldOrderings.NestedMessage) -> Bool { + if lhs._oo != rhs._oo {return false} + if lhs._bb != rhs._bb {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestParsingMerge: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestParsingMerge" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "required_all_types"), - 2: .standard(proto: "optional_all_types"), - 3: .standard(proto: "repeated_all_types"), - 10: .unique(proto: "OptionalGroup", json: "optionalgroup"), - 20: .unique(proto: "RepeatedGroup", json: "repeatedgroup"), - ] +extension SwiftProtoTesting_TestExtremeDefaultValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestExtremeDefaultValues" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}escaped_bytes\0\u{3}large_uint32\0\u{3}large_uint64\0\u{3}small_int32\0\u{3}small_int64\0\u{3}utf8_string\0\u{3}zero_float\0\u{3}one_float\0\u{3}small_float\0\u{3}negative_one_float\0\u{3}negative_float\0\u{3}large_float\0\u{3}small_negative_float\0\u{3}inf_double\0\u{3}neg_inf_double\0\u{3}nan_double\0\u{3}inf_float\0\u{3}neg_inf_float\0\u{3}nan_float\0\u{3}cpp_trigraph\0\u{3}really_small_int32\0\u{3}really_small_int64\0\u{3}string_with_zero\0\u{3}bytes_with_zero\0\u{4}\u{3}replacement_string\0") - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - if self._requiredAllTypes == nil {return false} - return true + fileprivate class _StorageClass { + var _escapedBytes: Data? = nil + var _largeUint32: UInt32? = nil + var _largeUint64: UInt64? = nil + var _smallInt32: Int32? = nil + var _smallInt64: Int64? = nil + var _reallySmallInt32: Int32? = nil + var _reallySmallInt64: Int64? = nil + var _utf8String: String? = nil + var _zeroFloat: Float? = nil + var _oneFloat: Float? = nil + var _smallFloat: Float? = nil + var _negativeOneFloat: Float? = nil + var _negativeFloat: Float? = nil + var _largeFloat: Float? = nil + var _smallNegativeFloat: Float? = nil + var _infDouble: Double? = nil + var _negInfDouble: Double? = nil + var _nanDouble: Double? = nil + var _infFloat: Float? = nil + var _negInfFloat: Float? = nil + var _nanFloat: Float? = nil + var _cppTrigraph: String? = nil + var _stringWithZero: String? = nil + var _bytesWithZero: Data? = nil + var _replacementString: String? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _escapedBytes = source._escapedBytes + _largeUint32 = source._largeUint32 + _largeUint64 = source._largeUint64 + _smallInt32 = source._smallInt32 + _smallInt64 = source._smallInt64 + _reallySmallInt32 = source._reallySmallInt32 + _reallySmallInt64 = source._reallySmallInt64 + _utf8String = source._utf8String + _zeroFloat = source._zeroFloat + _oneFloat = source._oneFloat + _smallFloat = source._smallFloat + _negativeOneFloat = source._negativeOneFloat + _negativeFloat = source._negativeFloat + _largeFloat = source._largeFloat + _smallNegativeFloat = source._smallNegativeFloat + _infDouble = source._infDouble + _negInfDouble = source._negInfDouble + _nanDouble = source._nanDouble + _infFloat = source._infFloat + _negInfFloat = source._negInfFloat + _nanFloat = source._nanFloat + _cppTrigraph = source._cppTrigraph + _stringWithZero = source._stringWithZero + _bytesWithZero = source._bytesWithZero + _replacementString = source._replacementString + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage } 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.decodeSingularMessageField(value: &self._requiredAllTypes) }() - case 2: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() - case 3: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() - case 10: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() - case 20: try { try decoder.decodeRepeatedGroupField(value: &self.repeatedGroup) }() - case 1000..<536870912: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestParsingMerge.self, fieldNumber: fieldNumber) }() - default: break + _ = _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.decodeSingularBytesField(value: &_storage._escapedBytes) }() + case 2: try { try decoder.decodeSingularUInt32Field(value: &_storage._largeUint32) }() + case 3: try { try decoder.decodeSingularUInt64Field(value: &_storage._largeUint64) }() + case 4: try { try decoder.decodeSingularInt32Field(value: &_storage._smallInt32) }() + case 5: try { try decoder.decodeSingularInt64Field(value: &_storage._smallInt64) }() + case 6: try { try decoder.decodeSingularStringField(value: &_storage._utf8String) }() + case 7: try { try decoder.decodeSingularFloatField(value: &_storage._zeroFloat) }() + case 8: try { try decoder.decodeSingularFloatField(value: &_storage._oneFloat) }() + case 9: try { try decoder.decodeSingularFloatField(value: &_storage._smallFloat) }() + case 10: try { try decoder.decodeSingularFloatField(value: &_storage._negativeOneFloat) }() + case 11: try { try decoder.decodeSingularFloatField(value: &_storage._negativeFloat) }() + case 12: try { try decoder.decodeSingularFloatField(value: &_storage._largeFloat) }() + case 13: try { try decoder.decodeSingularFloatField(value: &_storage._smallNegativeFloat) }() + case 14: try { try decoder.decodeSingularDoubleField(value: &_storage._infDouble) }() + case 15: try { try decoder.decodeSingularDoubleField(value: &_storage._negInfDouble) }() + case 16: try { try decoder.decodeSingularDoubleField(value: &_storage._nanDouble) }() + case 17: try { try decoder.decodeSingularFloatField(value: &_storage._infFloat) }() + case 18: try { try decoder.decodeSingularFloatField(value: &_storage._negInfFloat) }() + case 19: try { try decoder.decodeSingularFloatField(value: &_storage._nanFloat) }() + case 20: try { try decoder.decodeSingularStringField(value: &_storage._cppTrigraph) }() + case 21: try { try decoder.decodeSingularInt32Field(value: &_storage._reallySmallInt32) }() + case 22: try { try decoder.decodeSingularInt64Field(value: &_storage._reallySmallInt64) }() + case 23: try { try decoder.decodeSingularStringField(value: &_storage._stringWithZero) }() + case 24: try { try decoder.decodeSingularBytesField(value: &_storage._bytesWithZero) }() + case 27: try { try decoder.decodeSingularStringField(value: &_storage._replacementString) }() + 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 - try { if let v = self._requiredAllTypes { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = self._optionalAllTypes { - try visitor.visitSingularMessageField(value: v, fieldNumber: 2) - } }() - if !self.repeatedAllTypes.isEmpty { - try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 3) - } - try { if let v = self._optionalGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 10) - } }() - if !self.repeatedGroup.isEmpty { - try visitor.visitRepeatedGroupField(value: self.repeatedGroup, fieldNumber: 20) + 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._escapedBytes { + try visitor.visitSingularBytesField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._largeUint32 { + try visitor.visitSingularUInt32Field(value: v, fieldNumber: 2) + } }() + try { if let v = _storage._largeUint64 { + try visitor.visitSingularUInt64Field(value: v, fieldNumber: 3) + } }() + try { if let v = _storage._smallInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + } }() + try { if let v = _storage._smallInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 5) + } }() + try { if let v = _storage._utf8String { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) + } }() + try { if let v = _storage._zeroFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 7) + } }() + try { if let v = _storage._oneFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 8) + } }() + try { if let v = _storage._smallFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 9) + } }() + try { if let v = _storage._negativeOneFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 10) + } }() + try { if let v = _storage._negativeFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 11) + } }() + try { if let v = _storage._largeFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 12) + } }() + try { if let v = _storage._smallNegativeFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 13) + } }() + try { if let v = _storage._infDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 14) + } }() + try { if let v = _storage._negInfDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 15) + } }() + try { if let v = _storage._nanDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 16) + } }() + try { if let v = _storage._infFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 17) + } }() + try { if let v = _storage._negInfFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 18) + } }() + try { if let v = _storage._nanFloat { + try visitor.visitSingularFloatField(value: v, fieldNumber: 19) + } }() + try { if let v = _storage._cppTrigraph { + try visitor.visitSingularStringField(value: v, fieldNumber: 20) + } }() + try { if let v = _storage._reallySmallInt32 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 21) + } }() + try { if let v = _storage._reallySmallInt64 { + try visitor.visitSingularInt64Field(value: v, fieldNumber: 22) + } }() + try { if let v = _storage._stringWithZero { + try visitor.visitSingularStringField(value: v, fieldNumber: 23) + } }() + try { if let v = _storage._bytesWithZero { + try visitor.visitSingularBytesField(value: v, fieldNumber: 24) + } }() + try { if let v = _storage._replacementString { + try visitor.visitSingularStringField(value: v, fieldNumber: 27) + } }() } - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestParsingMerge, rhs: ProtobufUnittest_TestParsingMerge) -> Bool { - if lhs._requiredAllTypes != rhs._requiredAllTypes {return false} - if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} - if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} - if lhs._optionalGroup != rhs._optionalGroup {return false} - if lhs.repeatedGroup != rhs.repeatedGroup {return false} + static func ==(lhs: SwiftProtoTesting_TestExtremeDefaultValues, rhs: SwiftProtoTesting_TestExtremeDefaultValues) -> 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._escapedBytes != rhs_storage._escapedBytes {return false} + if _storage._largeUint32 != rhs_storage._largeUint32 {return false} + if _storage._largeUint64 != rhs_storage._largeUint64 {return false} + if _storage._smallInt32 != rhs_storage._smallInt32 {return false} + if _storage._smallInt64 != rhs_storage._smallInt64 {return false} + if _storage._reallySmallInt32 != rhs_storage._reallySmallInt32 {return false} + if _storage._reallySmallInt64 != rhs_storage._reallySmallInt64 {return false} + if _storage._utf8String != rhs_storage._utf8String {return false} + if _storage._zeroFloat != rhs_storage._zeroFloat {return false} + if _storage._oneFloat != rhs_storage._oneFloat {return false} + if _storage._smallFloat != rhs_storage._smallFloat {return false} + if _storage._negativeOneFloat != rhs_storage._negativeOneFloat {return false} + if _storage._negativeFloat != rhs_storage._negativeFloat {return false} + if _storage._largeFloat != rhs_storage._largeFloat {return false} + if _storage._smallNegativeFloat != rhs_storage._smallNegativeFloat {return false} + if _storage._infDouble != rhs_storage._infDouble {return false} + if _storage._negInfDouble != rhs_storage._negInfDouble {return false} + if _storage._nanDouble != rhs_storage._nanDouble {return false} + if _storage._infFloat != rhs_storage._infFloat {return false} + if _storage._negInfFloat != rhs_storage._negInfFloat {return false} + if _storage._nanFloat != rhs_storage._nanFloat {return false} + if _storage._cppTrigraph != rhs_storage._cppTrigraph {return false} + if _storage._stringWithZero != rhs_storage._stringWithZero {return false} + if _storage._bytesWithZero != rhs_storage._bytesWithZero {return false} + if _storage._replacementString != rhs_storage._replacementString {return false} + return true + } + if !storagesAreEqual {return false} + } if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMerge.protoMessageName + ".RepeatedFieldsGenerator" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "field1"), - 2: .same(proto: "field2"), - 3: .same(proto: "field3"), - 10: .unique(proto: "Group1", json: "group1"), - 20: .unique(proto: "Group2", json: "group2"), - 1000: .same(proto: "ext1"), - 1001: .same(proto: "ext2"), - ] +extension SwiftProtoTesting_TestOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}foo_int\0\u{3}foo_string\0\u{3}foo_message\0\u{7}FooGroup\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12743,61 +5413,90 @@ extension ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator: SwiftProtob // 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.decodeRepeatedMessageField(value: &self.field1) }() - case 2: try { try decoder.decodeRepeatedMessageField(value: &self.field2) }() - case 3: try { try decoder.decodeRepeatedMessageField(value: &self.field3) }() - case 10: try { try decoder.decodeRepeatedGroupField(value: &self.group1) }() - case 20: try { try decoder.decodeRepeatedGroupField(value: &self.group2) }() - case 1000: try { try decoder.decodeRepeatedMessageField(value: &self.ext1) }() - case 1001: try { try decoder.decodeRepeatedMessageField(value: &self.ext2) }() + case 1: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooInt(v) + } + }() + case 2: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooString(v) + } + }() + case 3: try { + var v: SwiftProtoTesting_TestAllTypes? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooMessage(v) + } + }() + case 4: try { + var v: SwiftProtoTesting_TestOneof.FooGroup? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooGroup(let m) = current {v = m} + } + try decoder.decodeSingularGroupField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooGroup(v) + } + }() default: break } } } func traverse(visitor: inout V) throws { - if !self.field1.isEmpty { - try visitor.visitRepeatedMessageField(value: self.field1, fieldNumber: 1) - } - if !self.field2.isEmpty { - try visitor.visitRepeatedMessageField(value: self.field2, fieldNumber: 2) - } - if !self.field3.isEmpty { - try visitor.visitRepeatedMessageField(value: self.field3, fieldNumber: 3) - } - if !self.group1.isEmpty { - try visitor.visitRepeatedGroupField(value: self.group1, fieldNumber: 10) - } - if !self.group2.isEmpty { - try visitor.visitRepeatedGroupField(value: self.group2, fieldNumber: 20) - } - if !self.ext1.isEmpty { - try visitor.visitRepeatedMessageField(value: self.ext1, fieldNumber: 1000) - } - if !self.ext2.isEmpty { - try visitor.visitRepeatedMessageField(value: self.ext2, fieldNumber: 1001) + // 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.foo { + case .fooInt?: try { + guard case .fooInt(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + }() + case .fooString?: try { + guard case .fooString(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + }() + case .fooMessage?: try { + guard case .fooMessage(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + }() + case .fooGroup?: try { + guard case .fooGroup(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularGroupField(value: v, fieldNumber: 4) + }() + case nil: break } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator, rhs: ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator) -> Bool { - if lhs.field1 != rhs.field1 {return false} - if lhs.field2 != rhs.field2 {return false} - if lhs.field3 != rhs.field3 {return false} - if lhs.group1 != rhs.group1 {return false} - if lhs.group2 != rhs.group2 {return false} - if lhs.ext1 != rhs.ext1 {return false} - if lhs.ext2 != rhs.ext2 {return false} + static func ==(lhs: SwiftProtoTesting_TestOneof, rhs: SwiftProtoTesting_TestOneof) -> Bool { + if lhs.foo != rhs.foo {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.protoMessageName + ".Group1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 11: .same(proto: "field1"), - ] +extension SwiftProtoTesting_TestOneof.FooGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestOneof.protoMessageName + ".FooGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{5}a\0\u{1}b\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12805,7 +5504,8 @@ extension ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group1: Swif // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { - case 11: try { try decoder.decodeSingularMessageField(value: &self._field1) }() + case 5: try { try decoder.decodeSingularInt32Field(value: &self._a) }() + case 6: try { try decoder.decodeSingularStringField(value: &self._b) }() default: break } } @@ -12816,24 +5516,31 @@ extension ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group1: Swif // 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.visitSingularMessageField(value: v, fieldNumber: 11) + try { if let v = self._a { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) + } }() + try { if let v = self._b { + try visitor.visitSingularStringField(value: v, fieldNumber: 6) } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group1, rhs: ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group1) -> Bool { - if lhs._field1 != rhs._field1 {return false} + static func ==(lhs: SwiftProtoTesting_TestOneof.FooGroup, rhs: SwiftProtoTesting_TestOneof.FooGroup) -> Bool { + if lhs._a != rhs._a {return false} + if lhs._b != rhs._b {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.protoMessageName + ".Group2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 21: .same(proto: "field1"), - ] +extension SwiftProtoTesting_TestRequiredOneof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestRequiredOneof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}foo_int\0\u{3}foo_string\0\u{3}foo_message\0") + + public var isInitialized: Bool { + if let v = self.foo, !v.isInitialized {return false} + return true + } mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12841,7 +5548,35 @@ extension ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group2: Swif // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { - case 21: try { try decoder.decodeSingularMessageField(value: &self._field1) }() + case 1: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooInt(v) + } + }() + case 2: try { + var v: String? + try decoder.decodeSingularStringField(value: &v) + if let v = v { + if self.foo != nil {try decoder.handleConflictingOneOf()} + self.foo = .fooString(v) + } + }() + case 3: try { + var v: SwiftProtoTesting_TestRequiredOneof.NestedMessage? + var hadOneofValue = false + if let current = self.foo { + hadOneofValue = true + if case .fooMessage(let m) = current {v = m} + } + try decoder.decodeSingularMessageField(value: &v) + if let v = v { + if hadOneofValue {try decoder.handleConflictingOneOf()} + self.foo = .fooMessage(v) + } + }() default: break } } @@ -12852,24 +5587,39 @@ extension ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group2: Swif // 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.visitSingularMessageField(value: v, fieldNumber: 21) - } }() + switch self.foo { + case .fooInt?: try { + guard case .fooInt(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + }() + case .fooString?: try { + guard case .fooString(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularStringField(value: v, fieldNumber: 2) + }() + case .fooMessage?: try { + guard case .fooMessage(let v)? = self.foo else { preconditionFailure() } + try visitor.visitSingularMessageField(value: v, fieldNumber: 3) + }() + case nil: break + } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group2, rhs: ProtobufUnittest_TestParsingMerge.RepeatedFieldsGenerator.Group2) -> Bool { - if lhs._field1 != rhs._field1 {return false} + static func ==(lhs: SwiftProtoTesting_TestRequiredOneof, rhs: SwiftProtoTesting_TestRequiredOneof) -> Bool { + if lhs.foo != rhs.foo {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestParsingMerge.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMerge.protoMessageName + ".OptionalGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 11: .standard(proto: "optional_group_all_types"), - ] +extension SwiftProtoTesting_TestRequiredOneof.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestRequiredOneof.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_double\0") + + public var isInitialized: Bool { + if self._requiredDouble == nil {return false} + return true + } mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12877,7 +5627,7 @@ extension ProtobufUnittest_TestParsingMerge.OptionalGroup: SwiftProtobuf.Message // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { - case 11: try { try decoder.decodeSingularMessageField(value: &self._optionalGroupAllTypes) }() + case 1: try { try decoder.decodeSingularDoubleField(value: &self._requiredDouble) }() default: break } } @@ -12888,24 +5638,22 @@ extension ProtobufUnittest_TestParsingMerge.OptionalGroup: SwiftProtobuf.Message // 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._optionalGroupAllTypes { - try visitor.visitSingularMessageField(value: v, fieldNumber: 11) + try { if let v = self._requiredDouble { + try visitor.visitSingularDoubleField(value: v, fieldNumber: 1) } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestParsingMerge.OptionalGroup, rhs: ProtobufUnittest_TestParsingMerge.OptionalGroup) -> Bool { - if lhs._optionalGroupAllTypes != rhs._optionalGroupAllTypes {return false} + static func ==(lhs: SwiftProtoTesting_TestRequiredOneof.NestedMessage, rhs: SwiftProtoTesting_TestRequiredOneof.NestedMessage) -> Bool { + if lhs._requiredDouble != rhs._requiredDouble {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestParsingMerge.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMerge.protoMessageName + ".RepeatedGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 21: .standard(proto: "repeated_group_all_types"), - ] +extension SwiftProtoTesting_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestPackedTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}Z\u{1}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12913,35 +5661,94 @@ extension ProtobufUnittest_TestParsingMerge.RepeatedGroup: SwiftProtobuf.Message // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { - case 21: try { try decoder.decodeSingularMessageField(value: &self._repeatedGroupAllTypes) }() + case 90: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32) }() + case 91: try { try decoder.decodeRepeatedInt64Field(value: &self.packedInt64) }() + case 92: try { try decoder.decodeRepeatedUInt32Field(value: &self.packedUint32) }() + case 93: try { try decoder.decodeRepeatedUInt64Field(value: &self.packedUint64) }() + case 94: try { try decoder.decodeRepeatedSInt32Field(value: &self.packedSint32) }() + case 95: try { try decoder.decodeRepeatedSInt64Field(value: &self.packedSint64) }() + case 96: try { try decoder.decodeRepeatedFixed32Field(value: &self.packedFixed32) }() + case 97: try { try decoder.decodeRepeatedFixed64Field(value: &self.packedFixed64) }() + case 98: try { try decoder.decodeRepeatedSFixed32Field(value: &self.packedSfixed32) }() + case 99: try { try decoder.decodeRepeatedSFixed64Field(value: &self.packedSfixed64) }() + case 100: try { try decoder.decodeRepeatedFloatField(value: &self.packedFloat) }() + case 101: try { try decoder.decodeRepeatedDoubleField(value: &self.packedDouble) }() + case 102: try { try decoder.decodeRepeatedBoolField(value: &self.packedBool) }() + case 103: try { try decoder.decodeRepeatedEnumField(value: &self.packedEnum) }() 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 - try { if let v = self._repeatedGroupAllTypes { - try visitor.visitSingularMessageField(value: v, fieldNumber: 21) - } }() + if !self.packedInt32.isEmpty { + try visitor.visitPackedInt32Field(value: self.packedInt32, fieldNumber: 90) + } + if !self.packedInt64.isEmpty { + try visitor.visitPackedInt64Field(value: self.packedInt64, fieldNumber: 91) + } + if !self.packedUint32.isEmpty { + try visitor.visitPackedUInt32Field(value: self.packedUint32, fieldNumber: 92) + } + if !self.packedUint64.isEmpty { + try visitor.visitPackedUInt64Field(value: self.packedUint64, fieldNumber: 93) + } + if !self.packedSint32.isEmpty { + try visitor.visitPackedSInt32Field(value: self.packedSint32, fieldNumber: 94) + } + if !self.packedSint64.isEmpty { + try visitor.visitPackedSInt64Field(value: self.packedSint64, fieldNumber: 95) + } + if !self.packedFixed32.isEmpty { + try visitor.visitPackedFixed32Field(value: self.packedFixed32, fieldNumber: 96) + } + if !self.packedFixed64.isEmpty { + try visitor.visitPackedFixed64Field(value: self.packedFixed64, fieldNumber: 97) + } + if !self.packedSfixed32.isEmpty { + try visitor.visitPackedSFixed32Field(value: self.packedSfixed32, fieldNumber: 98) + } + if !self.packedSfixed64.isEmpty { + try visitor.visitPackedSFixed64Field(value: self.packedSfixed64, fieldNumber: 99) + } + if !self.packedFloat.isEmpty { + try visitor.visitPackedFloatField(value: self.packedFloat, fieldNumber: 100) + } + if !self.packedDouble.isEmpty { + try visitor.visitPackedDoubleField(value: self.packedDouble, fieldNumber: 101) + } + if !self.packedBool.isEmpty { + try visitor.visitPackedBoolField(value: self.packedBool, fieldNumber: 102) + } + if !self.packedEnum.isEmpty { + try visitor.visitPackedEnumField(value: self.packedEnum, fieldNumber: 103) + } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestParsingMerge.RepeatedGroup, rhs: ProtobufUnittest_TestParsingMerge.RepeatedGroup) -> Bool { - if lhs._repeatedGroupAllTypes != rhs._repeatedGroupAllTypes {return false} + static func ==(lhs: SwiftProtoTesting_TestPackedTypes, rhs: SwiftProtoTesting_TestPackedTypes) -> Bool { + if lhs.packedInt32 != rhs.packedInt32 {return false} + if lhs.packedInt64 != rhs.packedInt64 {return false} + if lhs.packedUint32 != rhs.packedUint32 {return false} + if lhs.packedUint64 != rhs.packedUint64 {return false} + if lhs.packedSint32 != rhs.packedSint32 {return false} + if lhs.packedSint64 != rhs.packedSint64 {return false} + if lhs.packedFixed32 != rhs.packedFixed32 {return false} + if lhs.packedFixed64 != rhs.packedFixed64 {return false} + if lhs.packedSfixed32 != rhs.packedSfixed32 {return false} + if lhs.packedSfixed64 != rhs.packedSfixed64 {return false} + if lhs.packedFloat != rhs.packedFloat {return false} + if lhs.packedDouble != rhs.packedDouble {return false} + if lhs.packedBool != rhs.packedBool {return false} + if lhs.packedEnum != rhs.packedEnum {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestCommentInjectionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestCommentInjectionMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] +extension SwiftProtoTesting_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestUnpackedTypes" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}Z\u{1}unpacked_int32\0\u{3}unpacked_int64\0\u{3}unpacked_uint32\0\u{3}unpacked_uint64\0\u{3}unpacked_sint32\0\u{3}unpacked_sint64\0\u{3}unpacked_fixed32\0\u{3}unpacked_fixed64\0\u{3}unpacked_sfixed32\0\u{3}unpacked_sfixed64\0\u{3}unpacked_float\0\u{3}unpacked_double\0\u{3}unpacked_bool\0\u{3}unpacked_enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -12949,155 +5756,187 @@ extension ProtobufUnittest_TestCommentInjectionMessage: SwiftProtobuf.Message, S // 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._a) }() + case 90: try { try decoder.decodeRepeatedInt32Field(value: &self.unpackedInt32) }() + case 91: try { try decoder.decodeRepeatedInt64Field(value: &self.unpackedInt64) }() + case 92: try { try decoder.decodeRepeatedUInt32Field(value: &self.unpackedUint32) }() + case 93: try { try decoder.decodeRepeatedUInt64Field(value: &self.unpackedUint64) }() + case 94: try { try decoder.decodeRepeatedSInt32Field(value: &self.unpackedSint32) }() + case 95: try { try decoder.decodeRepeatedSInt64Field(value: &self.unpackedSint64) }() + case 96: try { try decoder.decodeRepeatedFixed32Field(value: &self.unpackedFixed32) }() + case 97: try { try decoder.decodeRepeatedFixed64Field(value: &self.unpackedFixed64) }() + case 98: try { try decoder.decodeRepeatedSFixed32Field(value: &self.unpackedSfixed32) }() + case 99: try { try decoder.decodeRepeatedSFixed64Field(value: &self.unpackedSfixed64) }() + case 100: try { try decoder.decodeRepeatedFloatField(value: &self.unpackedFloat) }() + case 101: try { try decoder.decodeRepeatedDoubleField(value: &self.unpackedDouble) }() + case 102: try { try decoder.decodeRepeatedBoolField(value: &self.unpackedBool) }() + case 103: try { try decoder.decodeRepeatedEnumField(value: &self.unpackedEnum) }() 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 - try { if let v = self._a { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestCommentInjectionMessage, rhs: ProtobufUnittest_TestCommentInjectionMessage) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_FooRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".FooRequest" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { + if !self.unpackedInt32.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.unpackedInt32, fieldNumber: 90) + } + if !self.unpackedInt64.isEmpty { + try visitor.visitRepeatedInt64Field(value: self.unpackedInt64, fieldNumber: 91) + } + if !self.unpackedUint32.isEmpty { + try visitor.visitRepeatedUInt32Field(value: self.unpackedUint32, fieldNumber: 92) + } + if !self.unpackedUint64.isEmpty { + try visitor.visitRepeatedUInt64Field(value: self.unpackedUint64, fieldNumber: 93) + } + if !self.unpackedSint32.isEmpty { + try visitor.visitRepeatedSInt32Field(value: self.unpackedSint32, fieldNumber: 94) + } + if !self.unpackedSint64.isEmpty { + try visitor.visitRepeatedSInt64Field(value: self.unpackedSint64, fieldNumber: 95) + } + if !self.unpackedFixed32.isEmpty { + try visitor.visitRepeatedFixed32Field(value: self.unpackedFixed32, fieldNumber: 96) + } + if !self.unpackedFixed64.isEmpty { + try visitor.visitRepeatedFixed64Field(value: self.unpackedFixed64, fieldNumber: 97) + } + if !self.unpackedSfixed32.isEmpty { + try visitor.visitRepeatedSFixed32Field(value: self.unpackedSfixed32, fieldNumber: 98) + } + if !self.unpackedSfixed64.isEmpty { + try visitor.visitRepeatedSFixed64Field(value: self.unpackedSfixed64, fieldNumber: 99) + } + if !self.unpackedFloat.isEmpty { + try visitor.visitRepeatedFloatField(value: self.unpackedFloat, fieldNumber: 100) } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_FooRequest, rhs: ProtobufUnittest_FooRequest) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_FooResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".FooResponse" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { + if !self.unpackedDouble.isEmpty { + try visitor.visitRepeatedDoubleField(value: self.unpackedDouble, fieldNumber: 101) + } + if !self.unpackedBool.isEmpty { + try visitor.visitRepeatedBoolField(value: self.unpackedBool, fieldNumber: 102) + } + if !self.unpackedEnum.isEmpty { + try visitor.visitRepeatedEnumField(value: self.unpackedEnum, fieldNumber: 103) } - } - - func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_FooResponse, rhs: ProtobufUnittest_FooResponse) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestUnpackedTypes, rhs: SwiftProtoTesting_TestUnpackedTypes) -> Bool { + if lhs.unpackedInt32 != rhs.unpackedInt32 {return false} + if lhs.unpackedInt64 != rhs.unpackedInt64 {return false} + if lhs.unpackedUint32 != rhs.unpackedUint32 {return false} + if lhs.unpackedUint64 != rhs.unpackedUint64 {return false} + if lhs.unpackedSint32 != rhs.unpackedSint32 {return false} + if lhs.unpackedSint64 != rhs.unpackedSint64 {return false} + if lhs.unpackedFixed32 != rhs.unpackedFixed32 {return false} + if lhs.unpackedFixed64 != rhs.unpackedFixed64 {return false} + if lhs.unpackedSfixed32 != rhs.unpackedSfixed32 {return false} + if lhs.unpackedSfixed64 != rhs.unpackedSfixed64 {return false} + if lhs.unpackedFloat != rhs.unpackedFloat {return false} + if lhs.unpackedDouble != rhs.unpackedDouble {return false} + if lhs.unpackedBool != rhs.unpackedBool {return false} + if lhs.unpackedEnum != rhs.unpackedEnum {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_FooClientMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".FooClientMessage" +extension SwiftProtoTesting_TestPackedExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestPackedExtensions" static let _protobuf_nameMap = SwiftProtobuf._NameMap() - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_FooClientMessage, rhs: ProtobufUnittest_FooClientMessage) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} return true } -} - -extension ProtobufUnittest_FooServerMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".FooServerMessage" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { + while let fieldNumber = try decoder.nextFieldNumber() { + if (1 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_TestPackedExtensions.self, fieldNumber: fieldNumber) + } } } func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_FooServerMessage, rhs: ProtobufUnittest_FooServerMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestPackedExtensions, rhs: SwiftProtoTesting_TestPackedExtensions) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension ProtobufUnittest_BarRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".BarRequest" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } +extension SwiftProtoTesting_TestParsingMerge: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestParsingMerge" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_all_types\0\u{3}optional_all_types\0\u{3}repeated_all_types\0\u{8}\u{7}OptionalGroup\0\u{8}\u{a}RepeatedGroup\0") - static func ==(lhs: ProtobufUnittest_BarRequest, rhs: ProtobufUnittest_BarRequest) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + if self._requiredAllTypes == nil {return false} return true } -} - -extension ProtobufUnittest_BarResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".BarResponse" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { + 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._requiredAllTypes) }() + case 2: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() + case 10: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() + case 20: try { try decoder.decodeRepeatedGroupField(value: &self.repeatedGroup) }() + case 1000..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_TestParsingMerge.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._requiredAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) + } }() + try { if let v = self._optionalAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 2) + } }() + if !self.repeatedAllTypes.isEmpty { + try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 3) + } + try { if let v = self._optionalGroup { + try visitor.visitSingularGroupField(value: v, fieldNumber: 10) + } }() + if !self.repeatedGroup.isEmpty { + try visitor.visitRepeatedGroupField(value: self.repeatedGroup, fieldNumber: 20) + } + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_BarResponse, rhs: ProtobufUnittest_BarResponse) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestParsingMerge, rhs: SwiftProtoTesting_TestParsingMerge) -> Bool { + if lhs._requiredAllTypes != rhs._requiredAllTypes {return false} + if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} + if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} + if lhs._optionalGroup != rhs._optionalGroup {return false} + if lhs.repeatedGroup != rhs.repeatedGroup {return false} if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension ProtobufUnittest_TestJsonName: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestJsonName" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "field_name1"), - 2: .same(proto: "fieldName2"), - 3: .same(proto: "FieldName3"), - 4: .standard(proto: "_field_name4"), - 5: .standard(proto: "FIELD_NAME5"), - 6: .unique(proto: "field_name6", json: "@type"), - 7: .same(proto: "fieldname7"), - ] +extension SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestParsingMerge.protoMessageName + ".RepeatedFieldsGenerator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field1\0\u{1}field2\0\u{1}field3\0\u{8}\u{7}Group1\0\u{8}\u{a}Group2\0\u{2}T\u{f}ext1\0\u{1}ext2\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13105,83 +5944,59 @@ extension ProtobufUnittest_TestJsonName: SwiftProtobuf.Message, SwiftProtobuf._M // 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._fieldName1) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &self._fieldName2) }() - case 3: try { try decoder.decodeSingularInt32Field(value: &self._fieldName3) }() - case 4: try { try decoder.decodeSingularInt32Field(value: &self._fieldName4) }() - case 5: try { try decoder.decodeSingularInt32Field(value: &self._fieldName5) }() - case 6: try { try decoder.decodeSingularInt32Field(value: &self._fieldName6) }() - case 7: try { try decoder.decodeSingularInt32Field(value: &self._fieldname7) }() + case 1: try { try decoder.decodeRepeatedMessageField(value: &self.field1) }() + case 2: try { try decoder.decodeRepeatedMessageField(value: &self.field2) }() + case 3: try { try decoder.decodeRepeatedMessageField(value: &self.field3) }() + case 10: try { try decoder.decodeRepeatedGroupField(value: &self.group1) }() + case 20: try { try decoder.decodeRepeatedGroupField(value: &self.group2) }() + case 1000: try { try decoder.decodeRepeatedMessageField(value: &self.ext1) }() + case 1001: try { try decoder.decodeRepeatedMessageField(value: &self.ext2) }() 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 - try { if let v = self._fieldName1 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._fieldName2 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try { if let v = self._fieldName3 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) - } }() - try { if let v = self._fieldName4 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) - } }() - try { if let v = self._fieldName5 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) - } }() - try { if let v = self._fieldName6 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) - } }() - try { if let v = self._fieldname7 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) - } }() + if !self.field1.isEmpty { + try visitor.visitRepeatedMessageField(value: self.field1, fieldNumber: 1) + } + if !self.field2.isEmpty { + try visitor.visitRepeatedMessageField(value: self.field2, fieldNumber: 2) + } + if !self.field3.isEmpty { + try visitor.visitRepeatedMessageField(value: self.field3, fieldNumber: 3) + } + if !self.group1.isEmpty { + try visitor.visitRepeatedGroupField(value: self.group1, fieldNumber: 10) + } + if !self.group2.isEmpty { + try visitor.visitRepeatedGroupField(value: self.group2, fieldNumber: 20) + } + if !self.ext1.isEmpty { + try visitor.visitRepeatedMessageField(value: self.ext1, fieldNumber: 1000) + } + if !self.ext2.isEmpty { + try visitor.visitRepeatedMessageField(value: self.ext2, fieldNumber: 1001) + } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestJsonName, rhs: ProtobufUnittest_TestJsonName) -> Bool { - if lhs._fieldName1 != rhs._fieldName1 {return false} - if lhs._fieldName2 != rhs._fieldName2 {return false} - if lhs._fieldName3 != rhs._fieldName3 {return false} - if lhs._fieldName4 != rhs._fieldName4 {return false} - if lhs._fieldName5 != rhs._fieldName5 {return false} - if lhs._fieldName6 != rhs._fieldName6 {return false} - if lhs._fieldname7 != rhs._fieldname7 {return false} + static func ==(lhs: SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator, rhs: SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator) -> Bool { + if lhs.field1 != rhs.field1 {return false} + if lhs.field2 != rhs.field2 {return false} + if lhs.field3 != rhs.field3 {return false} + if lhs.group1 != rhs.group1 {return false} + if lhs.group2 != rhs.group2 {return false} + if lhs.ext1 != rhs.ext1 {return false} + if lhs.ext2 != rhs.ext2 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestHugeFieldNumbers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestHugeFieldNumbers" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 536870000: .standard(proto: "optional_int32"), - 536870001: .standard(proto: "fixed_32"), - 536870002: .standard(proto: "repeated_int32"), - 536870003: .standard(proto: "packed_int32"), - 536870004: .standard(proto: "optional_enum"), - 536870005: .standard(proto: "optional_string"), - 536870006: .standard(proto: "optional_bytes"), - 536870007: .standard(proto: "optional_message"), - 536870008: .unique(proto: "OptionalGroup", json: "optionalgroup"), - 536870010: .standard(proto: "string_string_map"), - 536870011: .standard(proto: "oneof_uint32"), - 536870012: .standard(proto: "oneof_test_all_types"), - 536870013: .standard(proto: "oneof_string"), - 536870014: .standard(proto: "oneof_bytes"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } +extension SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.protoMessageName + ".Group1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{b}field1\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13189,55 +6004,7 @@ extension ProtobufUnittest_TestHugeFieldNumbers: SwiftProtobuf.Message, SwiftPro // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { - case 536870000: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32) }() - case 536870001: try { try decoder.decodeSingularInt32Field(value: &self._fixed32) }() - case 536870002: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() - case 536870003: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32) }() - case 536870004: try { try decoder.decodeSingularEnumField(value: &self._optionalEnum) }() - case 536870005: try { try decoder.decodeSingularStringField(value: &self._optionalString) }() - case 536870006: try { try decoder.decodeSingularBytesField(value: &self._optionalBytes) }() - case 536870007: try { try decoder.decodeSingularMessageField(value: &self._optionalMessage) }() - case 536870008: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() - case 536870010: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.stringStringMap) }() - case 536870011: try { - var v: UInt32? - try decoder.decodeSingularUInt32Field(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofUint32(v) - } - }() - case 536870012: try { - var v: ProtobufUnittest_TestAllTypes? - var hadOneofValue = false - if let current = self.oneofField { - hadOneofValue = true - if case .oneofTestAllTypes(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofTestAllTypes(v) - } - }() - case 536870013: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofString(v) - } - }() - case 536870014: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofBytes(v) - } - }() - case 536860000..<536870000: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestHugeFieldNumbers.self, fieldNumber: fieldNumber) }() + case 11: try { try decoder.decodeSingularMessageField(value: &self._field1) }() default: break } } @@ -13248,82 +6015,22 @@ extension ProtobufUnittest_TestHugeFieldNumbers: SwiftProtobuf.Message, SwiftPro // 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: 536860000, end: 536870000) - try { if let v = self._optionalInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870000) - } }() - try { if let v = self._fixed32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870001) - } }() - if !self.repeatedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 536870002) - } - if !self.packedInt32.isEmpty { - try visitor.visitPackedInt32Field(value: self.packedInt32, fieldNumber: 536870003) - } - try { if let v = self._optionalEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 536870004) - } }() - try { if let v = self._optionalString { - try visitor.visitSingularStringField(value: v, fieldNumber: 536870005) - } }() - try { if let v = self._optionalBytes { - try visitor.visitSingularBytesField(value: v, fieldNumber: 536870006) - } }() - try { if let v = self._optionalMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 536870007) - } }() - try { if let v = self._optionalGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 536870008) + try { if let v = self._field1 { + try visitor.visitSingularMessageField(value: v, fieldNumber: 11) } }() - if !self.stringStringMap.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.stringStringMap, fieldNumber: 536870010) - } - switch self.oneofField { - case .oneofUint32?: try { - guard case .oneofUint32(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 536870011) - }() - case .oneofTestAllTypes?: try { - guard case .oneofTestAllTypes(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 536870012) - }() - case .oneofString?: try { - guard case .oneofString(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 536870013) - }() - case .oneofBytes?: try { - guard case .oneofBytes(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 536870014) - }() - case nil: break - } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestHugeFieldNumbers, rhs: ProtobufUnittest_TestHugeFieldNumbers) -> Bool { - if lhs._optionalInt32 != rhs._optionalInt32 {return false} - if lhs._fixed32 != rhs._fixed32 {return false} - if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} - if lhs.packedInt32 != rhs.packedInt32 {return false} - if lhs._optionalEnum != rhs._optionalEnum {return false} - if lhs._optionalString != rhs._optionalString {return false} - if lhs._optionalBytes != rhs._optionalBytes {return false} - if lhs._optionalMessage != rhs._optionalMessage {return false} - if lhs._optionalGroup != rhs._optionalGroup {return false} - if lhs.stringStringMap != rhs.stringStringMap {return false} - if lhs.oneofField != rhs.oneofField {return false} + static func ==(lhs: SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group1, rhs: SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group1) -> Bool { + if lhs._field1 != rhs._field1 {return false} if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension ProtobufUnittest_TestHugeFieldNumbers.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestHugeFieldNumbers.protoMessageName + ".OptionalGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 536870009: .standard(proto: "group_a"), - ] +extension SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.protoMessageName + ".Group2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{15}field1\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13331,7 +6038,7 @@ extension ProtobufUnittest_TestHugeFieldNumbers.OptionalGroup: SwiftProtobuf.Mes // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { - case 536870009: try { try decoder.decodeSingularInt32Field(value: &self._groupA) }() + case 21: try { try decoder.decodeSingularMessageField(value: &self._field1) }() default: break } } @@ -13342,37 +6049,22 @@ extension ProtobufUnittest_TestHugeFieldNumbers.OptionalGroup: SwiftProtobuf.Mes // 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._groupA { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870009) + try { if let v = self._field1 { + try visitor.visitSingularMessageField(value: v, fieldNumber: 21) } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestHugeFieldNumbers.OptionalGroup, rhs: ProtobufUnittest_TestHugeFieldNumbers.OptionalGroup) -> Bool { - if lhs._groupA != rhs._groupA {return false} + static func ==(lhs: SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group2, rhs: SwiftProtoTesting_TestParsingMerge.RepeatedFieldsGenerator.Group2) -> Bool { + if lhs._field1 != rhs._field1 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestExtensionInsideTable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestExtensionInsideTable" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "field1"), - 2: .same(proto: "field2"), - 3: .same(proto: "field3"), - 4: .same(proto: "field4"), - 6: .same(proto: "field6"), - 7: .same(proto: "field7"), - 8: .same(proto: "field8"), - 9: .same(proto: "field9"), - 10: .same(proto: "field10"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } +extension SwiftProtoTesting_TestParsingMerge.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestParsingMerge.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{b}optional_group_all_types\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13380,17 +6072,7 @@ extension ProtobufUnittest_TestExtensionInsideTable: SwiftProtobuf.Message, Swif // 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 3: try { try decoder.decodeSingularInt32Field(value: &self._field3) }() - case 4: try { try decoder.decodeSingularInt32Field(value: &self._field4) }() - case 6: try { try decoder.decodeSingularInt32Field(value: &self._field6) }() - case 7: try { try decoder.decodeSingularInt32Field(value: &self._field7) }() - case 8: try { try decoder.decodeSingularInt32Field(value: &self._field8) }() - case 9: try { try decoder.decodeSingularInt32Field(value: &self._field9) }() - case 10: try { try decoder.decodeSingularInt32Field(value: &self._field10) }() - case 5: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestExtensionInsideTable.self, fieldNumber: fieldNumber) }() + case 11: try { try decoder.decodeSingularMessageField(value: &self._optionalGroupAllTypes) }() default: break } } @@ -13401,66 +6083,22 @@ extension ProtobufUnittest_TestExtensionInsideTable: SwiftProtobuf.Message, Swif // 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 { if let v = self._field3 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) - } }() - try { if let v = self._field4 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) - } }() - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 5, end: 6) - try { if let v = self._field6 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) - } }() - try { if let v = self._field7 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) - } }() - try { if let v = self._field8 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 8) - } }() - try { if let v = self._field9 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) - } }() - try { if let v = self._field10 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 10) + try { if let v = self._optionalGroupAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 11) } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestExtensionInsideTable, rhs: ProtobufUnittest_TestExtensionInsideTable) -> Bool { - if lhs._field1 != rhs._field1 {return false} - if lhs._field2 != rhs._field2 {return false} - if lhs._field3 != rhs._field3 {return false} - if lhs._field4 != rhs._field4 {return false} - if lhs._field6 != rhs._field6 {return false} - if lhs._field7 != rhs._field7 {return false} - if lhs._field8 != rhs._field8 {return false} - if lhs._field9 != rhs._field9 {return false} - if lhs._field10 != rhs._field10 {return false} + static func ==(lhs: SwiftProtoTesting_TestParsingMerge.OptionalGroup, rhs: SwiftProtoTesting_TestParsingMerge.OptionalGroup) -> Bool { + if lhs._optionalGroupAllTypes != rhs._optionalGroupAllTypes {return false} if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension ProtobufUnittest_TestExtensionRangeSerialize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestExtensionRangeSerialize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "foo_one"), - 6: .standard(proto: "foo_two"), - 7: .standard(proto: "foo_three"), - 13: .standard(proto: "foo_four"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } +extension SwiftProtoTesting_TestParsingMerge.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestParsingMerge.protoMessageName + ".RepeatedGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{15}repeated_group_all_types\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -13468,12 +6106,7 @@ extension ProtobufUnittest_TestExtensionRangeSerialize: SwiftProtobuf.Message, S // 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._fooOne) }() - case 6: try { try decoder.decodeSingularInt32Field(value: &self._fooTwo) }() - case 7: try { try decoder.decodeSingularInt32Field(value: &self._fooThree) }() - case 13: try { try decoder.decodeSingularInt32Field(value: &self._fooFour) }() - case 2..<5, 9..<11, 15, 17, 19: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestExtensionRangeSerialize.self, fieldNumber: fieldNumber) }() + case 21: try { try decoder.decodeSingularMessageField(value: &self._repeatedGroupAllTypes) }() default: break } } @@ -13484,31 +6117,15 @@ extension ProtobufUnittest_TestExtensionRangeSerialize: SwiftProtobuf.Message, S // 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._fooOne { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 2, end: 5) - try { if let v = self._fooTwo { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) - } }() - try { if let v = self._fooThree { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) - } }() - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 9, end: 11) - try { if let v = self._fooFour { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 13) + try { if let v = self._repeatedGroupAllTypes { + try visitor.visitSingularMessageField(value: v, fieldNumber: 21) } }() - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 15, end: 20) try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestExtensionRangeSerialize, rhs: ProtobufUnittest_TestExtensionRangeSerialize) -> Bool { - if lhs._fooOne != rhs._fooOne {return false} - if lhs._fooTwo != rhs._fooTwo {return false} - if lhs._fooThree != rhs._fooThree {return false} - if lhs._fooFour != rhs._fooFour {return false} + static func ==(lhs: SwiftProtoTesting_TestParsingMerge.RepeatedGroup, rhs: SwiftProtoTesting_TestParsingMerge.RepeatedGroup) -> Bool { + if lhs._repeatedGroupAllTypes != rhs._repeatedGroupAllTypes {return false} if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } diff --git a/Tests/SwiftProtobufTests/unittest_arena.pb.swift b/Tests/SwiftProtobufTests/unittest_arena.pb.swift deleted file mode 100644 index d5a360b82..000000000 --- a/Tests/SwiftProtobufTests/unittest_arena.pb.swift +++ /dev/null @@ -1,161 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_arena.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -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 Proto2ArenaUnittest_NestedMessage { - // 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 d: Int32 { - get {return _d ?? 0} - set {_d = newValue} - } - /// Returns true if `d` has been explicitly set. - var hasD: Bool {return self._d != nil} - /// Clears the value of `d`. Subsequent reads from it will return its default value. - mutating func clearD() {self._d = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _d: Int32? = nil -} - -struct Proto2ArenaUnittest_ArenaMessage { - // 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 repeatedNestedMessage: [Proto2ArenaUnittest_NestedMessage] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension Proto2ArenaUnittest_NestedMessage: @unchecked Sendable {} -extension Proto2ArenaUnittest_ArenaMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "proto2_arena_unittest" - -extension Proto2ArenaUnittest_NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "d"), - ] - - 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._d) }() - 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 - try { if let v = self._d { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: Proto2ArenaUnittest_NestedMessage, rhs: Proto2ArenaUnittest_NestedMessage) -> Bool { - if lhs._d != rhs._d {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension Proto2ArenaUnittest_ArenaMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ArenaMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "repeated_nested_message"), - ] - - 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.decodeRepeatedMessageField(value: &self.repeatedNestedMessage) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.repeatedNestedMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: self.repeatedNestedMessage, fieldNumber: 1) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: Proto2ArenaUnittest_ArenaMessage, rhs: Proto2ArenaUnittest_ArenaMessage) -> Bool { - if lhs.repeatedNestedMessage != rhs.repeatedNestedMessage {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Tests/SwiftProtobufTests/unittest_custom_options.pb.swift b/Tests/SwiftProtobufTests/unittest_custom_options.pb.swift deleted file mode 100644 index ba00a6a54..000000000 --- a/Tests/SwiftProtobufTests/unittest_custom_options.pb.swift +++ /dev/null @@ -1,2910 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_custom_options.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: benjy@google.com (Benjy Weinberger) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// A proto file used to test the "custom options" feature of google.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 -} - -enum ProtobufUnittest_MethodOpt1: SwiftProtobuf.Enum { - typealias RawValue = Int - case val1 // = 1 - case val2 // = 2 - - init() { - self = .val1 - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .val1 - case 2: self = .val2 - default: return nil - } - } - - var rawValue: Int { - switch self { - case .val1: return 1 - case .val2: return 2 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_MethodOpt1: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -enum ProtobufUnittest_AggregateEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case value // = 1 - - init() { - self = .value - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .value - default: return nil - } - } - - var rawValue: Int { - switch self { - case .value: return 1 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_AggregateEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// A test message with custom options at all possible locations (and also some -/// regular options, to make sure they interact nicely). -struct ProtobufUnittest_TestMessageWithCustomOptions { - // 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 _field1 ?? String()} - 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 anOneof: ProtobufUnittest_TestMessageWithCustomOptions.OneOf_AnOneof? = nil - - var oneofField: Int32 { - get { - if case .oneofField(let v)? = anOneof {return v} - return 0 - } - set {anOneof = .oneofField(newValue)} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum OneOf_AnOneof: Equatable { - case oneofField(Int32) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestMessageWithCustomOptions.OneOf_AnOneof, rhs: ProtobufUnittest_TestMessageWithCustomOptions.OneOf_AnOneof) -> 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 (.oneofField, .oneofField): return { - guard case .oneofField(let l) = lhs, case .oneofField(let r) = rhs else { preconditionFailure() } - return l == r - }() - } - } - #endif - } - - enum AnEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case val1 // = 1 - case val2 // = 2 - - init() { - self = .val1 - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .val1 - case 2: self = .val2 - default: return nil - } - } - - var rawValue: Int { - switch self { - case .val1: return 1 - case .val2: return 2 - } - } - - } - - init() {} - - fileprivate var _field1: String? = nil -} - -#if swift(>=4.2) - -extension ProtobufUnittest_TestMessageWithCustomOptions.AnEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// A test RPC service with custom options at all possible locations (and also -/// some regular options, to make sure they interact nicely). -struct ProtobufUnittest_CustomOptionFooRequest { - // 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 ProtobufUnittest_CustomOptionFooResponse { - // 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 ProtobufUnittest_CustomOptionFooClientMessage { - // 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 ProtobufUnittest_CustomOptionFooServerMessage { - // 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 ProtobufUnittest_DummyMessageContainingEnum { - // 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() - - enum TestEnumType: SwiftProtobuf.Enum { - typealias RawValue = Int - case testOptionEnumType1 // = 22 - case testOptionEnumType2 // = -23 - - init() { - self = .testOptionEnumType1 - } - - init?(rawValue: Int) { - switch rawValue { - case -23: self = .testOptionEnumType2 - case 22: self = .testOptionEnumType1 - default: return nil - } - } - - var rawValue: Int { - switch self { - case .testOptionEnumType2: return -23 - case .testOptionEnumType1: return 22 - } - } - - } - - init() {} -} - -#if swift(>=4.2) - -extension ProtobufUnittest_DummyMessageContainingEnum.TestEnumType: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_DummyMessageInvalidAsOptionType { - // 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 ProtobufUnittest_CustomOptionMinIntegerValues { - // 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 ProtobufUnittest_CustomOptionMaxIntegerValues { - // 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 ProtobufUnittest_CustomOptionOtherValues { - // 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 ProtobufUnittest_SettingRealsFromPositiveInts { - // 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 ProtobufUnittest_SettingRealsFromNegativeInts { - // 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 ProtobufUnittest_ComplexOptionType1: 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 foo: Int32 { - get {return _foo ?? 0} - set {_foo = newValue} - } - /// Returns true if `foo` has been explicitly set. - var hasFoo: Bool {return self._foo != nil} - /// Clears the value of `foo`. Subsequent reads from it will return its default value. - mutating func clearFoo() {self._foo = nil} - - var foo2: Int32 { - get {return _foo2 ?? 0} - set {_foo2 = newValue} - } - /// Returns true if `foo2` has been explicitly set. - var hasFoo2: Bool {return self._foo2 != nil} - /// Clears the value of `foo2`. Subsequent reads from it will return its default value. - mutating func clearFoo2() {self._foo2 = nil} - - var foo3: Int32 { - get {return _foo3 ?? 0} - set {_foo3 = newValue} - } - /// Returns true if `foo3` has been explicitly set. - var hasFoo3: Bool {return self._foo3 != nil} - /// Clears the value of `foo3`. Subsequent reads from it will return its default value. - mutating func clearFoo3() {self._foo3 = nil} - - var foo4: [Int32] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _foo: Int32? = nil - fileprivate var _foo2: Int32? = nil - fileprivate var _foo3: Int32? = nil -} - -struct ProtobufUnittest_ComplexOptionType2: 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 bar: ProtobufUnittest_ComplexOptionType1 { - get {return _bar ?? ProtobufUnittest_ComplexOptionType1()} - set {_bar = newValue} - } - /// Returns true if `bar` has been explicitly set. - var hasBar: Bool {return self._bar != nil} - /// Clears the value of `bar`. Subsequent reads from it will return its default value. - mutating func clearBar() {self._bar = nil} - - var baz: Int32 { - get {return _baz ?? 0} - set {_baz = newValue} - } - /// Returns true if `baz` has been explicitly set. - var hasBaz: Bool {return self._baz != nil} - /// Clears the value of `baz`. Subsequent reads from it will return its default value. - mutating func clearBaz() {self._baz = nil} - - var fred: ProtobufUnittest_ComplexOptionType2.ComplexOptionType4 { - get {return _fred ?? ProtobufUnittest_ComplexOptionType2.ComplexOptionType4()} - set {_fred = newValue} - } - /// Returns true if `fred` has been explicitly set. - var hasFred: Bool {return self._fred != nil} - /// Clears the value of `fred`. Subsequent reads from it will return its default value. - mutating func clearFred() {self._fred = nil} - - var barney: [ProtobufUnittest_ComplexOptionType2.ComplexOptionType4] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct ComplexOptionType4 { - // 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 waldo: Int32 { - get {return _waldo ?? 0} - set {_waldo = newValue} - } - /// Returns true if `waldo` has been explicitly set. - var hasWaldo: Bool {return self._waldo != nil} - /// Clears the value of `waldo`. Subsequent reads from it will return its default value. - mutating func clearWaldo() {self._waldo = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _waldo: Int32? = nil - } - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _bar: ProtobufUnittest_ComplexOptionType1? = nil - fileprivate var _baz: Int32? = nil - fileprivate var _fred: ProtobufUnittest_ComplexOptionType2.ComplexOptionType4? = nil -} - -struct ProtobufUnittest_ComplexOptionType3 { - // 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 qux: Int32 { - get {return _qux ?? 0} - set {_qux = newValue} - } - /// Returns true if `qux` has been explicitly set. - var hasQux: Bool {return self._qux != nil} - /// Clears the value of `qux`. Subsequent reads from it will return its default value. - mutating func clearQux() {self._qux = nil} - - var complexOptionType5: ProtobufUnittest_ComplexOptionType3.ComplexOptionType5 { - get {return _complexOptionType5 ?? ProtobufUnittest_ComplexOptionType3.ComplexOptionType5()} - set {_complexOptionType5 = newValue} - } - /// Returns true if `complexOptionType5` has been explicitly set. - var hasComplexOptionType5: Bool {return self._complexOptionType5 != nil} - /// Clears the value of `complexOptionType5`. Subsequent reads from it will return its default value. - mutating func clearComplexOptionType5() {self._complexOptionType5 = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct ComplexOptionType5 { - // 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 plugh: Int32 { - get {return _plugh ?? 0} - set {_plugh = newValue} - } - /// Returns true if `plugh` has been explicitly set. - var hasPlugh: Bool {return self._plugh != nil} - /// Clears the value of `plugh`. Subsequent reads from it will return its default value. - mutating func clearPlugh() {self._plugh = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _plugh: Int32? = nil - } - - init() {} - - fileprivate var _qux: Int32? = nil - fileprivate var _complexOptionType5: ProtobufUnittest_ComplexOptionType3.ComplexOptionType5? = nil -} - -struct ProtobufUnittest_ComplexOpt6 { - // 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 xyzzy: Int32 { - get {return _xyzzy ?? 0} - set {_xyzzy = newValue} - } - /// Returns true if `xyzzy` has been explicitly set. - var hasXyzzy: Bool {return self._xyzzy != nil} - /// Clears the value of `xyzzy`. Subsequent reads from it will return its default value. - mutating func clearXyzzy() {self._xyzzy = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _xyzzy: Int32? = nil -} - -/// Note that we try various different ways of naming the same extension. -struct ProtobufUnittest_VariousComplexOptions { - // 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 ProtobufUnittest_AggregateMessageSet: 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() -} - -struct ProtobufUnittest_AggregateMessageSetElement { - // 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 s: String { - get {return _s ?? String()} - set {_s = newValue} - } - /// Returns true if `s` has been explicitly set. - var hasS: Bool {return self._s != nil} - /// Clears the value of `s`. Subsequent reads from it will return its default value. - mutating func clearS() {self._s = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _s: String? = nil -} - -/// A helper type used to test aggregate option parsing -struct ProtobufUnittest_Aggregate { - // 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 i: Int32 { - get {return _storage._i ?? 0} - set {_uniqueStorage()._i = newValue} - } - /// Returns true if `i` has been explicitly set. - var hasI: Bool {return _storage._i != nil} - /// Clears the value of `i`. Subsequent reads from it will return its default value. - mutating func clearI() {_uniqueStorage()._i = nil} - - var s: String { - get {return _storage._s ?? String()} - set {_uniqueStorage()._s = newValue} - } - /// Returns true if `s` has been explicitly set. - var hasS: Bool {return _storage._s != nil} - /// Clears the value of `s`. Subsequent reads from it will return its default value. - mutating func clearS() {_uniqueStorage()._s = nil} - - /// A nested object - var sub: ProtobufUnittest_Aggregate { - get {return _storage._sub ?? ProtobufUnittest_Aggregate()} - set {_uniqueStorage()._sub = newValue} - } - /// Returns true if `sub` has been explicitly set. - var hasSub: Bool {return _storage._sub != nil} - /// Clears the value of `sub`. Subsequent reads from it will return its default value. - mutating func clearSub() {_uniqueStorage()._sub = nil} - - /// To test the parsing of extensions inside aggregate values - var file: SwiftProtobuf.Google_Protobuf_FileOptions { - get {return _storage._file ?? SwiftProtobuf.Google_Protobuf_FileOptions()} - set {_uniqueStorage()._file = newValue} - } - /// Returns true if `file` has been explicitly set. - var hasFile: Bool {return _storage._file != nil} - /// Clears the value of `file`. Subsequent reads from it will return its default value. - mutating func clearFile() {_uniqueStorage()._file = nil} - - /// An embedded message set - var mset: ProtobufUnittest_AggregateMessageSet { - get {return _storage._mset ?? ProtobufUnittest_AggregateMessageSet()} - set {_uniqueStorage()._mset = newValue} - } - /// Returns true if `mset` has been explicitly set. - var hasMset: Bool {return _storage._mset != nil} - /// Clears the value of `mset`. Subsequent reads from it will return its default value. - mutating func clearMset() {_uniqueStorage()._mset = nil} - - /// An any - var any: SwiftProtobuf.Google_Protobuf_Any { - get {return _storage._any ?? SwiftProtobuf.Google_Protobuf_Any()} - set {_uniqueStorage()._any = newValue} - } - /// Returns true if `any` has been explicitly set. - var hasAny: Bool {return _storage._any != nil} - /// Clears the value of `any`. Subsequent reads from it will return its default value. - mutating func clearAny() {_uniqueStorage()._any = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -struct ProtobufUnittest_AggregateMessage { - // 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 fieldname: Int32 { - get {return _fieldname ?? 0} - set {_fieldname = newValue} - } - /// Returns true if `fieldname` has been explicitly set. - var hasFieldname: Bool {return self._fieldname != nil} - /// Clears the value of `fieldname`. Subsequent reads from it will return its default value. - mutating func clearFieldname() {self._fieldname = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _fieldname: Int32? = nil -} - -/// Test custom options for nested type. -struct ProtobufUnittest_NestedOptionType { - // 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() - - enum NestedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case value // = 1 - - init() { - self = .value - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .value - default: return nil - } - } - - var rawValue: Int { - switch self { - case .value: return 1 - } - } - - } - - struct NestedMessage { - // 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 nestedField: Int32 { - get {return _nestedField ?? 0} - set {_nestedField = newValue} - } - /// Returns true if `nestedField` has been explicitly set. - var hasNestedField: Bool {return self._nestedField != nil} - /// Clears the value of `nestedField`. Subsequent reads from it will return its default value. - mutating func clearNestedField() {self._nestedField = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _nestedField: Int32? = nil - } - - init() {} -} - -#if swift(>=4.2) - -extension ProtobufUnittest_NestedOptionType.NestedEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// Custom message option that has a required enum field. -/// WARNING: this is strongly discouraged! -struct ProtobufUnittest_OldOptionType { - // 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 value: ProtobufUnittest_OldOptionType.TestEnum { - get {return _value ?? .oldValue} - set {_value = newValue} - } - /// Returns true if `value` has been explicitly set. - var hasValue: Bool {return self._value != nil} - /// Clears the value of `value`. Subsequent reads from it will return its default value. - mutating func clearValue() {self._value = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum TestEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case oldValue // = 0 - - init() { - self = .oldValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .oldValue - default: return nil - } - } - - var rawValue: Int { - switch self { - case .oldValue: return 0 - } - } - - } - - init() {} - - fileprivate var _value: ProtobufUnittest_OldOptionType.TestEnum? = nil -} - -#if swift(>=4.2) - -extension ProtobufUnittest_OldOptionType.TestEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// Updated version of the custom option above. -struct ProtobufUnittest_NewOptionType { - // 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 value: ProtobufUnittest_NewOptionType.TestEnum { - get {return _value ?? .oldValue} - set {_value = newValue} - } - /// Returns true if `value` has been explicitly set. - var hasValue: Bool {return self._value != nil} - /// Clears the value of `value`. Subsequent reads from it will return its default value. - mutating func clearValue() {self._value = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum TestEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case oldValue // = 0 - case newValue // = 1 - - init() { - self = .oldValue - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .oldValue - case 1: self = .newValue - default: return nil - } - } - - var rawValue: Int { - switch self { - case .oldValue: return 0 - case .newValue: return 1 - } - } - - } - - init() {} - - fileprivate var _value: ProtobufUnittest_NewOptionType.TestEnum? = nil -} - -#if swift(>=4.2) - -extension ProtobufUnittest_NewOptionType.TestEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// Test message using the "required_enum_opt" option defined above. -struct ProtobufUnittest_TestMessageWithRequiredEnumOption { - // 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() {} -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_MethodOpt1: @unchecked Sendable {} -extension ProtobufUnittest_AggregateEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestMessageWithCustomOptions: @unchecked Sendable {} -extension ProtobufUnittest_TestMessageWithCustomOptions.OneOf_AnOneof: @unchecked Sendable {} -extension ProtobufUnittest_TestMessageWithCustomOptions.AnEnum: @unchecked Sendable {} -extension ProtobufUnittest_CustomOptionFooRequest: @unchecked Sendable {} -extension ProtobufUnittest_CustomOptionFooResponse: @unchecked Sendable {} -extension ProtobufUnittest_CustomOptionFooClientMessage: @unchecked Sendable {} -extension ProtobufUnittest_CustomOptionFooServerMessage: @unchecked Sendable {} -extension ProtobufUnittest_DummyMessageContainingEnum: @unchecked Sendable {} -extension ProtobufUnittest_DummyMessageContainingEnum.TestEnumType: @unchecked Sendable {} -extension ProtobufUnittest_DummyMessageInvalidAsOptionType: @unchecked Sendable {} -extension ProtobufUnittest_CustomOptionMinIntegerValues: @unchecked Sendable {} -extension ProtobufUnittest_CustomOptionMaxIntegerValues: @unchecked Sendable {} -extension ProtobufUnittest_CustomOptionOtherValues: @unchecked Sendable {} -extension ProtobufUnittest_SettingRealsFromPositiveInts: @unchecked Sendable {} -extension ProtobufUnittest_SettingRealsFromNegativeInts: @unchecked Sendable {} -extension ProtobufUnittest_ComplexOptionType1: @unchecked Sendable {} -extension ProtobufUnittest_ComplexOptionType2: @unchecked Sendable {} -extension ProtobufUnittest_ComplexOptionType2.ComplexOptionType4: @unchecked Sendable {} -extension ProtobufUnittest_ComplexOptionType3: @unchecked Sendable {} -extension ProtobufUnittest_ComplexOptionType3.ComplexOptionType5: @unchecked Sendable {} -extension ProtobufUnittest_ComplexOpt6: @unchecked Sendable {} -extension ProtobufUnittest_VariousComplexOptions: @unchecked Sendable {} -extension ProtobufUnittest_AggregateMessageSet: @unchecked Sendable {} -extension ProtobufUnittest_AggregateMessageSetElement: @unchecked Sendable {} -extension ProtobufUnittest_Aggregate: @unchecked Sendable {} -extension ProtobufUnittest_AggregateMessage: @unchecked Sendable {} -extension ProtobufUnittest_NestedOptionType: @unchecked Sendable {} -extension ProtobufUnittest_NestedOptionType.NestedEnum: @unchecked Sendable {} -extension ProtobufUnittest_NestedOptionType.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_OldOptionType: @unchecked Sendable {} -extension ProtobufUnittest_OldOptionType.TestEnum: @unchecked Sendable {} -extension ProtobufUnittest_NewOptionType: @unchecked Sendable {} -extension ProtobufUnittest_NewOptionType.TestEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestMessageWithRequiredEnumOption: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Extension support defined in unittest_custom_options.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 ProtobufUnittest_AggregateMessageSet { - - var ProtobufUnittest_AggregateMessageSetElement_messageSetExtension: ProtobufUnittest_AggregateMessageSetElement { - get {return getExtensionValue(ext: ProtobufUnittest_AggregateMessageSetElement.Extensions.message_set_extension) ?? ProtobufUnittest_AggregateMessageSetElement()} - set {setExtensionValue(ext: ProtobufUnittest_AggregateMessageSetElement.Extensions.message_set_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_AggregateMessageSetElement.Extensions.message_set_extension` - /// has been explicitly set. - var hasProtobufUnittest_AggregateMessageSetElement_messageSetExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_AggregateMessageSetElement.Extensions.message_set_extension) - } - /// Clears the value of extension `ProtobufUnittest_AggregateMessageSetElement.Extensions.message_set_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_AggregateMessageSetElement_messageSetExtension() { - clearExtensionValue(ext: ProtobufUnittest_AggregateMessageSetElement.Extensions.message_set_extension) - } -} - -extension ProtobufUnittest_ComplexOptionType1 { - - var ProtobufUnittest_quux: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_quux) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_quux, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_quux` - /// has been explicitly set. - var hasProtobufUnittest_quux: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_quux) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_quux`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_quux() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_quux) - } - - var ProtobufUnittest_corge: ProtobufUnittest_ComplexOptionType3 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_corge) ?? ProtobufUnittest_ComplexOptionType3()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_corge, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_corge` - /// has been explicitly set. - var hasProtobufUnittest_corge: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_corge) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_corge`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_corge() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_corge) - } -} - -extension ProtobufUnittest_ComplexOptionType2 { - - var ProtobufUnittest_grault: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_grault) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_grault, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_grault` - /// has been explicitly set. - var hasProtobufUnittest_grault: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_grault) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_grault`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_grault() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_grault) - } - - var ProtobufUnittest_garply: ProtobufUnittest_ComplexOptionType1 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_garply) ?? ProtobufUnittest_ComplexOptionType1()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_garply, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_garply` - /// has been explicitly set. - var hasProtobufUnittest_garply: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_garply) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_garply`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_garply() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_garply) - } -} - -extension SwiftProtobuf.Google_Protobuf_EnumOptions { - - var ProtobufUnittest_enumOpt1: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_enum_opt1) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_enum_opt1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_enum_opt1` - /// has been explicitly set. - var hasProtobufUnittest_enumOpt1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_enum_opt1) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_enum_opt1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_enumOpt1() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_enum_opt1) - } - - var ProtobufUnittest_enumopt: ProtobufUnittest_Aggregate { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_enumopt) ?? ProtobufUnittest_Aggregate()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_enumopt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_enumopt` - /// has been explicitly set. - var hasProtobufUnittest_enumopt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_enumopt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_enumopt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_enumopt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_enumopt) - } -} - -extension SwiftProtobuf.Google_Protobuf_EnumValueOptions { - - var ProtobufUnittest_enumValueOpt1: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_enum_value_opt1) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_enum_value_opt1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_enum_value_opt1` - /// has been explicitly set. - var hasProtobufUnittest_enumValueOpt1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_enum_value_opt1) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_enum_value_opt1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_enumValueOpt1() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_enum_value_opt1) - } - - var ProtobufUnittest_enumvalopt: ProtobufUnittest_Aggregate { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_enumvalopt) ?? ProtobufUnittest_Aggregate()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_enumvalopt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_enumvalopt` - /// has been explicitly set. - var hasProtobufUnittest_enumvalopt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_enumvalopt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_enumvalopt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_enumvalopt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_enumvalopt) - } -} - -extension SwiftProtobuf.Google_Protobuf_FieldOptions { - - var ProtobufUnittest_fieldOpt1: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_field_opt1) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_field_opt1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_field_opt1` - /// has been explicitly set. - var hasProtobufUnittest_fieldOpt1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_field_opt1) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_field_opt1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_fieldOpt1() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_field_opt1) - } - - /// This is useful for testing that we correctly register default values for - /// extension options. - var ProtobufUnittest_fieldOpt2: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_field_opt2) ?? 42} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_field_opt2, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_field_opt2` - /// has been explicitly set. - var hasProtobufUnittest_fieldOpt2: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_field_opt2) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_field_opt2`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_fieldOpt2() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_field_opt2) - } - - var ProtobufUnittest_fieldopt: ProtobufUnittest_Aggregate { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_fieldopt) ?? ProtobufUnittest_Aggregate()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_fieldopt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_fieldopt` - /// has been explicitly set. - var hasProtobufUnittest_fieldopt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_fieldopt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_fieldopt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_fieldopt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_fieldopt) - } -} - -extension SwiftProtobuf.Google_Protobuf_FileOptions { - - var ProtobufUnittest_fileOpt1: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_file_opt1) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_file_opt1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_file_opt1` - /// has been explicitly set. - var hasProtobufUnittest_fileOpt1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_file_opt1) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_file_opt1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_fileOpt1() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_file_opt1) - } - - var ProtobufUnittest_fileopt: ProtobufUnittest_Aggregate { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_fileopt) ?? ProtobufUnittest_Aggregate()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_fileopt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_fileopt` - /// has been explicitly set. - var hasProtobufUnittest_fileopt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_fileopt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_fileopt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_fileopt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_fileopt) - } - - var ProtobufUnittest_Aggregate_nested: ProtobufUnittest_Aggregate { - get {return getExtensionValue(ext: ProtobufUnittest_Aggregate.Extensions.nested) ?? ProtobufUnittest_Aggregate()} - set {setExtensionValue(ext: ProtobufUnittest_Aggregate.Extensions.nested, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Aggregate.Extensions.nested` - /// has been explicitly set. - var hasProtobufUnittest_Aggregate_nested: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Aggregate.Extensions.nested) - } - /// Clears the value of extension `ProtobufUnittest_Aggregate.Extensions.nested`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Aggregate_nested() { - clearExtensionValue(ext: ProtobufUnittest_Aggregate.Extensions.nested) - } - - var ProtobufUnittest_NestedOptionType_nestedExtension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_NestedOptionType.Extensions.nested_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_NestedOptionType.Extensions.nested_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_NestedOptionType.Extensions.nested_extension` - /// has been explicitly set. - var hasProtobufUnittest_NestedOptionType_nestedExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_NestedOptionType.Extensions.nested_extension) - } - /// Clears the value of extension `ProtobufUnittest_NestedOptionType.Extensions.nested_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_NestedOptionType_nestedExtension() { - clearExtensionValue(ext: ProtobufUnittest_NestedOptionType.Extensions.nested_extension) - } -} - -extension SwiftProtobuf.Google_Protobuf_MessageOptions { - - var ProtobufUnittest_messageOpt1: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_message_opt1) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_message_opt1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_message_opt1` - /// has been explicitly set. - var hasProtobufUnittest_messageOpt1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_message_opt1) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_message_opt1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_messageOpt1() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_message_opt1) - } - - var ProtobufUnittest_boolOpt: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_bool_opt) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_bool_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_bool_opt` - /// has been explicitly set. - var hasProtobufUnittest_boolOpt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_bool_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_bool_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_boolOpt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_bool_opt) - } - - var ProtobufUnittest_int32Opt: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_int32_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_int32_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_int32_opt` - /// has been explicitly set. - var hasProtobufUnittest_int32Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_int32_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_int32_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_int32Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_int32_opt) - } - - var ProtobufUnittest_int64Opt: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_int64_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_int64_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_int64_opt` - /// has been explicitly set. - var hasProtobufUnittest_int64Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_int64_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_int64_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_int64Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_int64_opt) - } - - var ProtobufUnittest_uint32Opt: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_uint32_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_uint32_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_uint32_opt` - /// has been explicitly set. - var hasProtobufUnittest_uint32Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_uint32_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_uint32_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_uint32Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_uint32_opt) - } - - var ProtobufUnittest_uint64Opt: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_uint64_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_uint64_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_uint64_opt` - /// has been explicitly set. - var hasProtobufUnittest_uint64Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_uint64_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_uint64_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_uint64Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_uint64_opt) - } - - var ProtobufUnittest_sint32Opt: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_sint32_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_sint32_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_sint32_opt` - /// has been explicitly set. - var hasProtobufUnittest_sint32Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_sint32_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_sint32_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_sint32Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_sint32_opt) - } - - var ProtobufUnittest_sint64Opt: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_sint64_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_sint64_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_sint64_opt` - /// has been explicitly set. - var hasProtobufUnittest_sint64Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_sint64_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_sint64_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_sint64Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_sint64_opt) - } - - var ProtobufUnittest_fixed32Opt: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_fixed32_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_fixed32_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_fixed32_opt` - /// has been explicitly set. - var hasProtobufUnittest_fixed32Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_fixed32_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_fixed32_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_fixed32Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_fixed32_opt) - } - - var ProtobufUnittest_fixed64Opt: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_fixed64_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_fixed64_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_fixed64_opt` - /// has been explicitly set. - var hasProtobufUnittest_fixed64Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_fixed64_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_fixed64_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_fixed64Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_fixed64_opt) - } - - var ProtobufUnittest_sfixed32Opt: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_sfixed32_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_sfixed32_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_sfixed32_opt` - /// has been explicitly set. - var hasProtobufUnittest_sfixed32Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_sfixed32_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_sfixed32_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_sfixed32Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_sfixed32_opt) - } - - var ProtobufUnittest_sfixed64Opt: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_sfixed64_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_sfixed64_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_sfixed64_opt` - /// has been explicitly set. - var hasProtobufUnittest_sfixed64Opt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_sfixed64_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_sfixed64_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_sfixed64Opt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_sfixed64_opt) - } - - var ProtobufUnittest_floatOpt: Float { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_float_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_float_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_float_opt` - /// has been explicitly set. - var hasProtobufUnittest_floatOpt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_float_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_float_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_floatOpt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_float_opt) - } - - var ProtobufUnittest_doubleOpt: Double { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_double_opt) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_double_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_double_opt` - /// has been explicitly set. - var hasProtobufUnittest_doubleOpt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_double_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_double_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_doubleOpt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_double_opt) - } - - var ProtobufUnittest_stringOpt: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_string_opt) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_string_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_string_opt` - /// has been explicitly set. - var hasProtobufUnittest_stringOpt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_string_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_string_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_stringOpt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_string_opt) - } - - var ProtobufUnittest_bytesOpt: Data { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_bytes_opt) ?? Data()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_bytes_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_bytes_opt` - /// has been explicitly set. - var hasProtobufUnittest_bytesOpt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_bytes_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_bytes_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_bytesOpt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_bytes_opt) - } - - var ProtobufUnittest_enumOpt: ProtobufUnittest_DummyMessageContainingEnum.TestEnumType { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_enum_opt) ?? .testOptionEnumType1} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_enum_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_enum_opt` - /// has been explicitly set. - var hasProtobufUnittest_enumOpt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_enum_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_enum_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_enumOpt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_enum_opt) - } - - var ProtobufUnittest_messageTypeOpt: ProtobufUnittest_DummyMessageInvalidAsOptionType { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_message_type_opt) ?? ProtobufUnittest_DummyMessageInvalidAsOptionType()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_message_type_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_message_type_opt` - /// has been explicitly set. - var hasProtobufUnittest_messageTypeOpt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_message_type_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_message_type_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_messageTypeOpt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_message_type_opt) - } - - var ProtobufUnittest_complexOpt1: ProtobufUnittest_ComplexOptionType1 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt1) ?? ProtobufUnittest_ComplexOptionType1()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_complex_opt1` - /// has been explicitly set. - var hasProtobufUnittest_complexOpt1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt1) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_complex_opt1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_complexOpt1() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt1) - } - - var ProtobufUnittest_complexOpt2: ProtobufUnittest_ComplexOptionType2 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt2) ?? ProtobufUnittest_ComplexOptionType2()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt2, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_complex_opt2` - /// has been explicitly set. - var hasProtobufUnittest_complexOpt2: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt2) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_complex_opt2`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_complexOpt2() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt2) - } - - var ProtobufUnittest_complexOpt3: ProtobufUnittest_ComplexOptionType3 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt3) ?? ProtobufUnittest_ComplexOptionType3()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt3, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_complex_opt3` - /// has been explicitly set. - var hasProtobufUnittest_complexOpt3: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt3) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_complex_opt3`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_complexOpt3() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_complex_opt3) - } - - var ProtobufUnittest_complexOpt6: ProtobufUnittest_ComplexOpt6 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_ComplexOpt6) ?? ProtobufUnittest_ComplexOpt6()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_ComplexOpt6, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_ComplexOpt6` - /// has been explicitly set. - var hasProtobufUnittest_complexOpt6: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_ComplexOpt6) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_ComplexOpt6`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_complexOpt6() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_ComplexOpt6) - } - - var ProtobufUnittest_msgopt: ProtobufUnittest_Aggregate { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_msgopt) ?? ProtobufUnittest_Aggregate()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_msgopt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_msgopt` - /// has been explicitly set. - var hasProtobufUnittest_msgopt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_msgopt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_msgopt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_msgopt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_msgopt) - } - - var ProtobufUnittest_requiredEnumOpt: ProtobufUnittest_OldOptionType { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_required_enum_opt) ?? ProtobufUnittest_OldOptionType()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_required_enum_opt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_required_enum_opt` - /// has been explicitly set. - var hasProtobufUnittest_requiredEnumOpt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_required_enum_opt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_required_enum_opt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_requiredEnumOpt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_required_enum_opt) - } - - var ProtobufUnittest_ComplexOptionType2_ComplexOptionType4_complexOpt4: ProtobufUnittest_ComplexOptionType2.ComplexOptionType4 { - get {return getExtensionValue(ext: ProtobufUnittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4) ?? ProtobufUnittest_ComplexOptionType2.ComplexOptionType4()} - set {setExtensionValue(ext: ProtobufUnittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4` - /// has been explicitly set. - var hasProtobufUnittest_ComplexOptionType2_ComplexOptionType4_complexOpt4: Bool { - return hasExtensionValue(ext: ProtobufUnittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4) - } - /// Clears the value of extension `ProtobufUnittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_ComplexOptionType2_ComplexOptionType4_complexOpt4() { - clearExtensionValue(ext: ProtobufUnittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4) - } -} - -extension SwiftProtobuf.Google_Protobuf_MethodOptions { - - var ProtobufUnittest_methodOpt1: ProtobufUnittest_MethodOpt1 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_method_opt1) ?? .val1} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_method_opt1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_method_opt1` - /// has been explicitly set. - var hasProtobufUnittest_methodOpt1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_method_opt1) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_method_opt1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_methodOpt1() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_method_opt1) - } - - var ProtobufUnittest_methodopt: ProtobufUnittest_Aggregate { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_methodopt) ?? ProtobufUnittest_Aggregate()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_methodopt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_methodopt` - /// has been explicitly set. - var hasProtobufUnittest_methodopt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_methodopt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_methodopt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_methodopt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_methodopt) - } -} - -extension SwiftProtobuf.Google_Protobuf_OneofOptions { - - var ProtobufUnittest_oneofOpt1: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_oneof_opt1) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_oneof_opt1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_oneof_opt1` - /// has been explicitly set. - var hasProtobufUnittest_oneofOpt1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_oneof_opt1) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_oneof_opt1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_oneofOpt1() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_oneof_opt1) - } -} - -extension SwiftProtobuf.Google_Protobuf_ServiceOptions { - - var ProtobufUnittest_serviceOpt1: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_service_opt1) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_service_opt1, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_service_opt1` - /// has been explicitly set. - var hasProtobufUnittest_serviceOpt1: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_service_opt1) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_service_opt1`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_serviceOpt1() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_service_opt1) - } - - var ProtobufUnittest_serviceopt: ProtobufUnittest_Aggregate { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_serviceopt) ?? ProtobufUnittest_Aggregate()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_serviceopt, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_serviceopt` - /// has been explicitly set. - var hasProtobufUnittest_serviceopt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_serviceopt) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_serviceopt`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_serviceopt() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_serviceopt) - } - -} - -// MARK: - File's ExtensionMap: ProtobufUnittest_UnittestCustomOptions_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 ProtobufUnittest_UnittestCustomOptions_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_Extensions_file_opt1, - ProtobufUnittest_Extensions_message_opt1, - ProtobufUnittest_Extensions_field_opt1, - ProtobufUnittest_Extensions_field_opt2, - ProtobufUnittest_Extensions_oneof_opt1, - ProtobufUnittest_Extensions_enum_opt1, - ProtobufUnittest_Extensions_enum_value_opt1, - ProtobufUnittest_Extensions_service_opt1, - ProtobufUnittest_Extensions_method_opt1, - ProtobufUnittest_Extensions_bool_opt, - ProtobufUnittest_Extensions_int32_opt, - ProtobufUnittest_Extensions_int64_opt, - ProtobufUnittest_Extensions_uint32_opt, - ProtobufUnittest_Extensions_uint64_opt, - ProtobufUnittest_Extensions_sint32_opt, - ProtobufUnittest_Extensions_sint64_opt, - ProtobufUnittest_Extensions_fixed32_opt, - ProtobufUnittest_Extensions_fixed64_opt, - ProtobufUnittest_Extensions_sfixed32_opt, - ProtobufUnittest_Extensions_sfixed64_opt, - ProtobufUnittest_Extensions_float_opt, - ProtobufUnittest_Extensions_double_opt, - ProtobufUnittest_Extensions_string_opt, - ProtobufUnittest_Extensions_bytes_opt, - ProtobufUnittest_Extensions_enum_opt, - ProtobufUnittest_Extensions_message_type_opt, - ProtobufUnittest_Extensions_quux, - ProtobufUnittest_Extensions_corge, - ProtobufUnittest_Extensions_grault, - ProtobufUnittest_Extensions_garply, - ProtobufUnittest_Extensions_complex_opt1, - ProtobufUnittest_Extensions_complex_opt2, - ProtobufUnittest_Extensions_complex_opt3, - ProtobufUnittest_Extensions_ComplexOpt6, - ProtobufUnittest_Extensions_fileopt, - ProtobufUnittest_Extensions_msgopt, - ProtobufUnittest_Extensions_fieldopt, - ProtobufUnittest_Extensions_enumopt, - ProtobufUnittest_Extensions_enumvalopt, - ProtobufUnittest_Extensions_serviceopt, - ProtobufUnittest_Extensions_methodopt, - ProtobufUnittest_Extensions_required_enum_opt, - ProtobufUnittest_ComplexOptionType2.ComplexOptionType4.Extensions.complex_opt4, - ProtobufUnittest_AggregateMessageSetElement.Extensions.message_set_extension, - ProtobufUnittest_Aggregate.Extensions.nested, - ProtobufUnittest_NestedOptionType.Extensions.nested_extension -] - -// 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 ProtobufUnittest_Extensions_file_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( - _protobuf_fieldNumber: 7736974, - fieldName: "protobuf_unittest.file_opt1" -) - -let ProtobufUnittest_Extensions_message_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7739036, - fieldName: "protobuf_unittest.message_opt1" -) - -let ProtobufUnittest_Extensions_field_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FieldOptions>( - _protobuf_fieldNumber: 7740936, - fieldName: "protobuf_unittest.field_opt1" -) - -/// This is useful for testing that we correctly register default values for -/// extension options. -let ProtobufUnittest_Extensions_field_opt2 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FieldOptions>( - _protobuf_fieldNumber: 7753913, - fieldName: "protobuf_unittest.field_opt2" -) - -let ProtobufUnittest_Extensions_oneof_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_OneofOptions>( - _protobuf_fieldNumber: 7740111, - fieldName: "protobuf_unittest.oneof_opt1" -) - -let ProtobufUnittest_Extensions_enum_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_EnumOptions>( - _protobuf_fieldNumber: 7753576, - fieldName: "protobuf_unittest.enum_opt1" -) - -let ProtobufUnittest_Extensions_enum_value_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_EnumValueOptions>( - _protobuf_fieldNumber: 1560678, - fieldName: "protobuf_unittest.enum_value_opt1" -) - -let ProtobufUnittest_Extensions_service_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_ServiceOptions>( - _protobuf_fieldNumber: 7887650, - fieldName: "protobuf_unittest.service_opt1" -) - -let ProtobufUnittest_Extensions_method_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MethodOptions>( - _protobuf_fieldNumber: 7890860, - fieldName: "protobuf_unittest.method_opt1" -) - -let ProtobufUnittest_Extensions_bool_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7706090, - fieldName: "protobuf_unittest.bool_opt" -) - -let ProtobufUnittest_Extensions_int32_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7705709, - fieldName: "protobuf_unittest.int32_opt" -) - -let ProtobufUnittest_Extensions_int64_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7705542, - fieldName: "protobuf_unittest.int64_opt" -) - -let ProtobufUnittest_Extensions_uint32_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7704880, - fieldName: "protobuf_unittest.uint32_opt" -) - -let ProtobufUnittest_Extensions_uint64_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7702367, - fieldName: "protobuf_unittest.uint64_opt" -) - -let ProtobufUnittest_Extensions_sint32_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7701568, - fieldName: "protobuf_unittest.sint32_opt" -) - -let ProtobufUnittest_Extensions_sint64_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7700863, - fieldName: "protobuf_unittest.sint64_opt" -) - -let ProtobufUnittest_Extensions_fixed32_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7700307, - fieldName: "protobuf_unittest.fixed32_opt" -) - -let ProtobufUnittest_Extensions_fixed64_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7700194, - fieldName: "protobuf_unittest.fixed64_opt" -) - -let ProtobufUnittest_Extensions_sfixed32_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7698645, - fieldName: "protobuf_unittest.sfixed32_opt" -) - -let ProtobufUnittest_Extensions_sfixed64_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7685475, - fieldName: "protobuf_unittest.sfixed64_opt" -) - -let ProtobufUnittest_Extensions_float_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7675390, - fieldName: "protobuf_unittest.float_opt" -) - -let ProtobufUnittest_Extensions_double_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7673293, - fieldName: "protobuf_unittest.double_opt" -) - -let ProtobufUnittest_Extensions_string_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7673285, - fieldName: "protobuf_unittest.string_opt" -) - -let ProtobufUnittest_Extensions_bytes_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7673238, - fieldName: "protobuf_unittest.bytes_opt" -) - -let ProtobufUnittest_Extensions_enum_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7673233, - fieldName: "protobuf_unittest.enum_opt" -) - -let ProtobufUnittest_Extensions_message_type_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7665967, - fieldName: "protobuf_unittest.message_type_opt" -) - -let ProtobufUnittest_Extensions_quux = SwiftProtobuf.MessageExtension, ProtobufUnittest_ComplexOptionType1>( - _protobuf_fieldNumber: 7663707, - fieldName: "protobuf_unittest.quux" -) - -let ProtobufUnittest_Extensions_corge = SwiftProtobuf.MessageExtension, ProtobufUnittest_ComplexOptionType1>( - _protobuf_fieldNumber: 7663442, - fieldName: "protobuf_unittest.corge" -) - -let ProtobufUnittest_Extensions_grault = SwiftProtobuf.MessageExtension, ProtobufUnittest_ComplexOptionType2>( - _protobuf_fieldNumber: 7650927, - fieldName: "protobuf_unittest.grault" -) - -let ProtobufUnittest_Extensions_garply = SwiftProtobuf.MessageExtension, ProtobufUnittest_ComplexOptionType2>( - _protobuf_fieldNumber: 7649992, - fieldName: "protobuf_unittest.garply" -) - -let ProtobufUnittest_Extensions_complex_opt1 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7646756, - fieldName: "protobuf_unittest.complex_opt1" -) - -let ProtobufUnittest_Extensions_complex_opt2 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7636949, - fieldName: "protobuf_unittest.complex_opt2" -) - -let ProtobufUnittest_Extensions_complex_opt3 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7636463, - fieldName: "protobuf_unittest.complex_opt3" -) - -let ProtobufUnittest_Extensions_ComplexOpt6 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7595468, - fieldName: "protobuf_unittest.complexopt6" -) - -let ProtobufUnittest_Extensions_fileopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( - _protobuf_fieldNumber: 15478479, - fieldName: "protobuf_unittest.fileopt" -) - -let ProtobufUnittest_Extensions_msgopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 15480088, - fieldName: "protobuf_unittest.msgopt" -) - -let ProtobufUnittest_Extensions_fieldopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FieldOptions>( - _protobuf_fieldNumber: 15481374, - fieldName: "protobuf_unittest.fieldopt" -) - -let ProtobufUnittest_Extensions_enumopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_EnumOptions>( - _protobuf_fieldNumber: 15483218, - fieldName: "protobuf_unittest.enumopt" -) - -let ProtobufUnittest_Extensions_enumvalopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_EnumValueOptions>( - _protobuf_fieldNumber: 15486921, - fieldName: "protobuf_unittest.enumvalopt" -) - -let ProtobufUnittest_Extensions_serviceopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_ServiceOptions>( - _protobuf_fieldNumber: 15497145, - fieldName: "protobuf_unittest.serviceopt" -) - -let ProtobufUnittest_Extensions_methodopt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MethodOptions>( - _protobuf_fieldNumber: 15512713, - fieldName: "protobuf_unittest.methodopt" -) - -let ProtobufUnittest_Extensions_required_enum_opt = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 106161807, - fieldName: "protobuf_unittest.required_enum_opt" -) - -extension ProtobufUnittest_ComplexOptionType2.ComplexOptionType4 { - enum Extensions { - static let complex_opt4 = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 7633546, - fieldName: "protobuf_unittest.ComplexOptionType2.ComplexOptionType4.complex_opt4" - ) - } -} - -extension ProtobufUnittest_AggregateMessageSetElement { - enum Extensions { - static let message_set_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_AggregateMessageSet>( - _protobuf_fieldNumber: 15447542, - fieldName: "protobuf_unittest.AggregateMessageSetElement" - ) - } -} - -extension ProtobufUnittest_Aggregate { - enum Extensions { - static let nested = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( - _protobuf_fieldNumber: 15476903, - fieldName: "protobuf_unittest.Aggregate.nested" - ) - } -} - -extension ProtobufUnittest_NestedOptionType { - enum Extensions { - static let nested_extension = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_FileOptions>( - _protobuf_fieldNumber: 7912573, - fieldName: "protobuf_unittest.NestedOptionType.nested_extension" - ) - } -} - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest" - -extension ProtobufUnittest_MethodOpt1: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "METHODOPT1_VAL1"), - 2: .same(proto: "METHODOPT1_VAL2"), - ] -} - -extension ProtobufUnittest_AggregateEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "VALUE"), - ] -} - -extension ProtobufUnittest_TestMessageWithCustomOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMessageWithCustomOptions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "field1"), - 2: .standard(proto: "oneof_field"), - ] - - 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._field1) }() - case 2: try { - var v: Int32? - try decoder.decodeSingularInt32Field(value: &v) - if let v = v { - if self.anOneof != nil {try decoder.handleConflictingOneOf()} - self.anOneof = .oneofField(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 - try { if let v = self._field1 { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try { if case .oneofField(let v)? = self.anOneof { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMessageWithCustomOptions, rhs: ProtobufUnittest_TestMessageWithCustomOptions) -> Bool { - if lhs._field1 != rhs._field1 {return false} - if lhs.anOneof != rhs.anOneof {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestMessageWithCustomOptions.AnEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ANENUM_VAL1"), - 2: .same(proto: "ANENUM_VAL2"), - ] -} - -extension ProtobufUnittest_CustomOptionFooRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".CustomOptionFooRequest" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_CustomOptionFooRequest, rhs: ProtobufUnittest_CustomOptionFooRequest) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_CustomOptionFooResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".CustomOptionFooResponse" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_CustomOptionFooResponse, rhs: ProtobufUnittest_CustomOptionFooResponse) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_CustomOptionFooClientMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".CustomOptionFooClientMessage" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_CustomOptionFooClientMessage, rhs: ProtobufUnittest_CustomOptionFooClientMessage) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_CustomOptionFooServerMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".CustomOptionFooServerMessage" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_CustomOptionFooServerMessage, rhs: ProtobufUnittest_CustomOptionFooServerMessage) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_DummyMessageContainingEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".DummyMessageContainingEnum" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_DummyMessageContainingEnum, rhs: ProtobufUnittest_DummyMessageContainingEnum) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_DummyMessageContainingEnum.TestEnumType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -23: .same(proto: "TEST_OPTION_ENUM_TYPE2"), - 22: .same(proto: "TEST_OPTION_ENUM_TYPE1"), - ] -} - -extension ProtobufUnittest_DummyMessageInvalidAsOptionType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".DummyMessageInvalidAsOptionType" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_DummyMessageInvalidAsOptionType, rhs: ProtobufUnittest_DummyMessageInvalidAsOptionType) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_CustomOptionMinIntegerValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".CustomOptionMinIntegerValues" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_CustomOptionMinIntegerValues, rhs: ProtobufUnittest_CustomOptionMinIntegerValues) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_CustomOptionMaxIntegerValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".CustomOptionMaxIntegerValues" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_CustomOptionMaxIntegerValues, rhs: ProtobufUnittest_CustomOptionMaxIntegerValues) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_CustomOptionOtherValues: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".CustomOptionOtherValues" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_CustomOptionOtherValues, rhs: ProtobufUnittest_CustomOptionOtherValues) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_SettingRealsFromPositiveInts: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".SettingRealsFromPositiveInts" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_SettingRealsFromPositiveInts, rhs: ProtobufUnittest_SettingRealsFromPositiveInts) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_SettingRealsFromNegativeInts: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".SettingRealsFromNegativeInts" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_SettingRealsFromNegativeInts, rhs: ProtobufUnittest_SettingRealsFromNegativeInts) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_ComplexOptionType1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ComplexOptionType1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "foo"), - 2: .same(proto: "foo2"), - 3: .same(proto: "foo3"), - 4: .same(proto: "foo4"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - 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._foo) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &self._foo2) }() - case 3: try { try decoder.decodeSingularInt32Field(value: &self._foo3) }() - case 4: try { try decoder.decodeRepeatedInt32Field(value: &self.foo4) }() - case 100..<536870912: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_ComplexOptionType1.self, fieldNumber: fieldNumber) }() - 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 - try { if let v = self._foo { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._foo2 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try { if let v = self._foo3 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) - } }() - if !self.foo4.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.foo4, fieldNumber: 4) - } - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 100, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_ComplexOptionType1, rhs: ProtobufUnittest_ComplexOptionType1) -> Bool { - if lhs._foo != rhs._foo {return false} - if lhs._foo2 != rhs._foo2 {return false} - if lhs._foo3 != rhs._foo3 {return false} - if lhs.foo4 != rhs.foo4 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_ComplexOptionType2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ComplexOptionType2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bar"), - 2: .same(proto: "baz"), - 3: .same(proto: "fred"), - 4: .same(proto: "barney"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - if let v = self._bar, !v.isInitialized {return false} - return true - } - - 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.decodeSingularMessageField(value: &self._bar) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &self._baz) }() - case 3: try { try decoder.decodeSingularMessageField(value: &self._fred) }() - case 4: try { try decoder.decodeRepeatedMessageField(value: &self.barney) }() - case 100..<536870912: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_ComplexOptionType2.self, fieldNumber: fieldNumber) }() - 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 - try { if let v = self._bar { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = self._baz { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try { if let v = self._fred { - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - } }() - if !self.barney.isEmpty { - try visitor.visitRepeatedMessageField(value: self.barney, fieldNumber: 4) - } - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 100, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_ComplexOptionType2, rhs: ProtobufUnittest_ComplexOptionType2) -> Bool { - if lhs._bar != rhs._bar {return false} - if lhs._baz != rhs._baz {return false} - if lhs._fred != rhs._fred {return false} - if lhs.barney != rhs.barney {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_ComplexOptionType2.ComplexOptionType4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_ComplexOptionType2.protoMessageName + ".ComplexOptionType4" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "waldo"), - ] - - 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._waldo) }() - 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 - try { if let v = self._waldo { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_ComplexOptionType2.ComplexOptionType4, rhs: ProtobufUnittest_ComplexOptionType2.ComplexOptionType4) -> Bool { - if lhs._waldo != rhs._waldo {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_ComplexOptionType3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ComplexOptionType3" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "qux"), - 2: .unique(proto: "ComplexOptionType5", json: "complexoptiontype5"), - ] - - 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._qux) }() - case 2: try { try decoder.decodeSingularGroupField(value: &self._complexOptionType5) }() - 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 - try { if let v = self._qux { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._complexOptionType5 { - try visitor.visitSingularGroupField(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_ComplexOptionType3, rhs: ProtobufUnittest_ComplexOptionType3) -> Bool { - if lhs._qux != rhs._qux {return false} - if lhs._complexOptionType5 != rhs._complexOptionType5 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_ComplexOptionType3.ComplexOptionType5: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_ComplexOptionType3.protoMessageName + ".ComplexOptionType5" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 3: .same(proto: "plugh"), - ] - - 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 3: try { try decoder.decodeSingularInt32Field(value: &self._plugh) }() - 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 - try { if let v = self._plugh { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_ComplexOptionType3.ComplexOptionType5, rhs: ProtobufUnittest_ComplexOptionType3.ComplexOptionType5) -> Bool { - if lhs._plugh != rhs._plugh {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_ComplexOpt6: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ComplexOpt6" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 7593951: .same(proto: "xyzzy"), - ] - - 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 7593951: try { try decoder.decodeSingularInt32Field(value: &self._xyzzy) }() - 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 - try { if let v = self._xyzzy { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 7593951) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_ComplexOpt6, rhs: ProtobufUnittest_ComplexOpt6) -> Bool { - if lhs._xyzzy != rhs._xyzzy {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_VariousComplexOptions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".VariousComplexOptions" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_VariousComplexOptions, rhs: ProtobufUnittest_VariousComplexOptions) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_AggregateMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".AggregateMessageSet" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_AggregateMessageSet.self) - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFieldsAsMessageSet(fields: _protobuf_extensionFieldValues, start: 4, end: 2147483647) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_AggregateMessageSet, rhs: ProtobufUnittest_AggregateMessageSet) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_AggregateMessageSetElement: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".AggregateMessageSetElement" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "s"), - ] - - 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._s) }() - 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 - try { if let v = self._s { - try visitor.visitSingularStringField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_AggregateMessageSetElement, rhs: ProtobufUnittest_AggregateMessageSetElement) -> Bool { - if lhs._s != rhs._s {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_Aggregate: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".Aggregate" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "i"), - 2: .same(proto: "s"), - 3: .same(proto: "sub"), - 4: .same(proto: "file"), - 5: .same(proto: "mset"), - 6: .same(proto: "any"), - ] - - fileprivate class _StorageClass { - var _i: Int32? = nil - var _s: String? = nil - var _sub: ProtobufUnittest_Aggregate? = nil - var _file: SwiftProtobuf.Google_Protobuf_FileOptions? = nil - var _mset: ProtobufUnittest_AggregateMessageSet? = nil - var _any: SwiftProtobuf.Google_Protobuf_Any? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _i = source._i - _s = source._s - _sub = source._sub - _file = source._file - _mset = source._mset - _any = source._any - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - public var isInitialized: Bool { - return withExtendedLifetime(_storage) { (_storage: _StorageClass) in - if let v = _storage._sub, !v.isInitialized {return false} - if let v = _storage._file, !v.isInitialized {return false} - if let v = _storage._mset, !v.isInitialized {return false} - return true - } - } - - mutating func decodeMessage(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._i) }() - case 2: try { try decoder.decodeSingularStringField(value: &_storage._s) }() - case 3: try { try decoder.decodeSingularMessageField(value: &_storage._sub) }() - case 4: try { try decoder.decodeSingularMessageField(value: &_storage._file) }() - case 5: try { try decoder.decodeSingularMessageField(value: &_storage._mset) }() - case 6: try { try decoder.decodeSingularMessageField(value: &_storage._any) }() - default: break - } - } - } - } - - func traverse(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._i { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._s { - try visitor.visitSingularStringField(value: v, fieldNumber: 2) - } }() - try { if let v = _storage._sub { - try visitor.visitSingularMessageField(value: v, fieldNumber: 3) - } }() - try { if let v = _storage._file { - try visitor.visitSingularMessageField(value: v, fieldNumber: 4) - } }() - try { if let v = _storage._mset { - try visitor.visitSingularMessageField(value: v, fieldNumber: 5) - } }() - try { if let v = _storage._any { - try visitor.visitSingularMessageField(value: v, fieldNumber: 6) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_Aggregate, rhs: ProtobufUnittest_Aggregate) -> 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._i != rhs_storage._i {return false} - if _storage._s != rhs_storage._s {return false} - if _storage._sub != rhs_storage._sub {return false} - if _storage._file != rhs_storage._file {return false} - if _storage._mset != rhs_storage._mset {return false} - if _storage._any != rhs_storage._any {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_AggregateMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".AggregateMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fieldname"), - ] - - 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._fieldname) }() - 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 - try { if let v = self._fieldname { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_AggregateMessage, rhs: ProtobufUnittest_AggregateMessage) -> Bool { - if lhs._fieldname != rhs._fieldname {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_NestedOptionType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".NestedOptionType" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_NestedOptionType, rhs: ProtobufUnittest_NestedOptionType) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_NestedOptionType.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "NESTED_ENUM_VALUE"), - ] -} - -extension ProtobufUnittest_NestedOptionType.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_NestedOptionType.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "nested_field"), - ] - - 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._nestedField) }() - 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 - try { if let v = self._nestedField { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_NestedOptionType.NestedMessage, rhs: ProtobufUnittest_NestedOptionType.NestedMessage) -> Bool { - if lhs._nestedField != rhs._nestedField {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_OldOptionType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".OldOptionType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] - - public var isInitialized: Bool { - if self._value == nil {return false} - return true - } - - 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._value) }() - 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 - try { if let v = self._value { - try visitor.visitSingularEnumField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_OldOptionType, rhs: ProtobufUnittest_OldOptionType) -> Bool { - if lhs._value != rhs._value {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_OldOptionType.TestEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "OLD_VALUE"), - ] -} - -extension ProtobufUnittest_NewOptionType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".NewOptionType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "value"), - ] - - public var isInitialized: Bool { - if self._value == nil {return false} - return true - } - - 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._value) }() - 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 - try { if let v = self._value { - try visitor.visitSingularEnumField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_NewOptionType, rhs: ProtobufUnittest_NewOptionType) -> Bool { - if lhs._value != rhs._value {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_NewOptionType.TestEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "OLD_VALUE"), - 1: .same(proto: "NEW_VALUE"), - ] -} - -extension ProtobufUnittest_TestMessageWithRequiredEnumOption: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMessageWithRequiredEnumOption" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestMessageWithRequiredEnumOption, rhs: ProtobufUnittest_TestMessageWithRequiredEnumOption) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Tests/SwiftProtobufTests/unittest_drop_unknown_fields.pb.swift b/Tests/SwiftProtobufTests/unittest_drop_unknown_fields.pb.swift deleted file mode 100644 index f84a8cef6..000000000 --- a/Tests/SwiftProtobufTests/unittest_drop_unknown_fields.pb.swift +++ /dev/null @@ -1,283 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_drop_unknown_fields.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -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 UnittestDropUnknownFields_Foo { - // 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 int32Value: Int32 = 0 - - var enumValue: UnittestDropUnknownFields_Foo.NestedEnum = .foo - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum NestedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 0 - case bar // = 1 - case baz // = 2 - case UNRECOGNIZED(Int) - - init() { - self = .foo - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .foo - case 1: self = .bar - case 2: self = .baz - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .foo: return 0 - case .bar: return 1 - case .baz: return 2 - case .UNRECOGNIZED(let i): return i - } - } - - } - - init() {} -} - -#if swift(>=4.2) - -extension UnittestDropUnknownFields_Foo.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [UnittestDropUnknownFields_Foo.NestedEnum] = [ - .foo, - .bar, - .baz, - ] -} - -#endif // swift(>=4.2) - -struct UnittestDropUnknownFields_FooWithExtraFields { - // 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 int32Value: Int32 = 0 - - var enumValue: UnittestDropUnknownFields_FooWithExtraFields.NestedEnum = .foo - - var extraInt32Value: Int32 = 0 - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum NestedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 0 - case bar // = 1 - case baz // = 2 - case qux // = 3 - case UNRECOGNIZED(Int) - - init() { - self = .foo - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .foo - case 1: self = .bar - case 2: self = .baz - case 3: self = .qux - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .foo: return 0 - case .bar: return 1 - case .baz: return 2 - case .qux: return 3 - case .UNRECOGNIZED(let i): return i - } - } - - } - - init() {} -} - -#if swift(>=4.2) - -extension UnittestDropUnknownFields_FooWithExtraFields.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [UnittestDropUnknownFields_FooWithExtraFields.NestedEnum] = [ - .foo, - .bar, - .baz, - .qux, - ] -} - -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension UnittestDropUnknownFields_Foo: @unchecked Sendable {} -extension UnittestDropUnknownFields_Foo.NestedEnum: @unchecked Sendable {} -extension UnittestDropUnknownFields_FooWithExtraFields: @unchecked Sendable {} -extension UnittestDropUnknownFields_FooWithExtraFields.NestedEnum: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "unittest_drop_unknown_fields" - -extension UnittestDropUnknownFields_Foo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".Foo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "int32_value"), - 2: .standard(proto: "enum_value"), - ] - - 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.int32Value) }() - case 2: try { try decoder.decodeSingularEnumField(value: &self.enumValue) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if self.int32Value != 0 { - try visitor.visitSingularInt32Field(value: self.int32Value, fieldNumber: 1) - } - if self.enumValue != .foo { - try visitor.visitSingularEnumField(value: self.enumValue, fieldNumber: 2) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: UnittestDropUnknownFields_Foo, rhs: UnittestDropUnknownFields_Foo) -> Bool { - if lhs.int32Value != rhs.int32Value {return false} - if lhs.enumValue != rhs.enumValue {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension UnittestDropUnknownFields_Foo.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - ] -} - -extension UnittestDropUnknownFields_FooWithExtraFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".FooWithExtraFields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "int32_value"), - 2: .standard(proto: "enum_value"), - 3: .standard(proto: "extra_int32_value"), - ] - - 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.int32Value) }() - case 2: try { try decoder.decodeSingularEnumField(value: &self.enumValue) }() - case 3: try { try decoder.decodeSingularInt32Field(value: &self.extraInt32Value) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if self.int32Value != 0 { - try visitor.visitSingularInt32Field(value: self.int32Value, fieldNumber: 1) - } - if self.enumValue != .foo { - try visitor.visitSingularEnumField(value: self.enumValue, fieldNumber: 2) - } - if self.extraInt32Value != 0 { - try visitor.visitSingularInt32Field(value: self.extraInt32Value, fieldNumber: 3) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: UnittestDropUnknownFields_FooWithExtraFields, rhs: UnittestDropUnknownFields_FooWithExtraFields) -> Bool { - if lhs.int32Value != rhs.int32Value {return false} - if lhs.enumValue != rhs.enumValue {return false} - if lhs.extraInt32Value != rhs.extraInt32Value {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension UnittestDropUnknownFields_FooWithExtraFields.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - 3: .same(proto: "QUX"), - ] -} diff --git a/Tests/SwiftProtobufTests/unittest_embed_optimize_for.pb.swift b/Tests/SwiftProtobufTests/unittest_embed_optimize_for.pb.swift deleted file mode 100644 index dceee5a77..000000000 --- a/Tests/SwiftProtobufTests/unittest_embed_optimize_for.pb.swift +++ /dev/null @@ -1,138 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_embed_optimize_for.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// A proto file which imports a proto file that uses optimize_for = CODE_SIZE. - -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 ProtobufUnittest_TestEmbedOptimizedForSize { - // 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. - - /// Test that embedding a message which has optimize_for = CODE_SIZE into - /// one optimized for speed works. - var optionalMessage: ProtobufUnittest_TestOptimizedForSize { - get {return _optionalMessage ?? ProtobufUnittest_TestOptimizedForSize()} - set {_optionalMessage = newValue} - } - /// Returns true if `optionalMessage` has been explicitly set. - var hasOptionalMessage: Bool {return self._optionalMessage != nil} - /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalMessage() {self._optionalMessage = nil} - - var repeatedMessage: [ProtobufUnittest_TestOptimizedForSize] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _optionalMessage: ProtobufUnittest_TestOptimizedForSize? = nil -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_TestEmbedOptimizedForSize: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest" - -extension ProtobufUnittest_TestEmbedOptimizedForSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestEmbedOptimizedForSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_message"), - 2: .standard(proto: "repeated_message"), - ] - - public var isInitialized: Bool { - if let v = self._optionalMessage, !v.isInitialized {return false} - if !SwiftProtobuf.Internal.areAllInitialized(self.repeatedMessage) {return false} - return true - } - - 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.decodeSingularMessageField(value: &self._optionalMessage) }() - case 2: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedMessage) }() - 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 - try { if let v = self._optionalMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - if !self.repeatedMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: self.repeatedMessage, fieldNumber: 2) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestEmbedOptimizedForSize, rhs: ProtobufUnittest_TestEmbedOptimizedForSize) -> Bool { - if lhs._optionalMessage != rhs._optionalMessage {return false} - if lhs.repeatedMessage != rhs.repeatedMessage {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Tests/SwiftProtobufTests/unittest_empty.pb.swift b/Tests/SwiftProtobufTests/unittest_empty.pb.swift deleted file mode 100644 index 3c31eb186..000000000 --- a/Tests/SwiftProtobufTests/unittest_empty.pb.swift +++ /dev/null @@ -1,58 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_empty.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// This file intentionally left blank. (At one point this wouldn't compile -// correctly.) - -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 -} diff --git a/Tests/SwiftProtobufTests/unittest_import.pb.swift b/Tests/SwiftProtobufTests/unittest_import.pb.swift index 2a159da09..a682a26cd 100644 --- a/Tests/SwiftProtobufTests/unittest_import.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_import.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_import.proto +// Source: unittest_import.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -43,7 +44,6 @@ // // A proto file which is imported by unittest.proto to test importing. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -56,92 +56,28 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum ProtobufUnittestImport_ImportEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case importFoo // = 7 - case importBar // = 8 - case importBaz // = 9 +enum SwiftProtoTesting_Import_ImportEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case importFoo = 7 + case importBar = 8 + case importBaz = 9 init() { self = .importFoo } - init?(rawValue: Int) { - switch rawValue { - case 7: self = .importFoo - case 8: self = .importBar - case 9: self = .importBaz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .importFoo: return 7 - case .importBar: return 8 - case .importBaz: return 9 - } - } - } -#if swift(>=4.2) - -extension ProtobufUnittestImport_ImportEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// To use an enum in a map, it must has the first value as 0. -enum ProtobufUnittestImport_ImportEnumForMap: SwiftProtobuf.Enum { - typealias RawValue = Int - case unknown // = 0 - case foo // = 1 - case bar // = 2 - - init() { - self = .unknown - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .unknown - case 1: self = .foo - case 2: self = .bar - default: return nil - } - } - - var rawValue: Int { - switch self { - case .unknown: return 0 - case .foo: return 1 - case .bar: return 2 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittestImport_ImportEnumForMap: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittestImport_ImportMessage { +struct SwiftProtoTesting_Import_ImportMessage: Sendable { // 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 d: Int32 { - get {return _d ?? 0} + get {_d ?? 0} set {_d = newValue} } /// Returns true if `d` has been explicitly set. - var hasD: Bool {return self._d != nil} + var hasD: Bool {self._d != nil} /// Clears the value of `d`. Subsequent reads from it will return its default value. mutating func clearD() {self._d = nil} @@ -152,37 +88,17 @@ struct ProtobufUnittestImport_ImportMessage { fileprivate var _d: Int32? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittestImport_ImportEnum: @unchecked Sendable {} -extension ProtobufUnittestImport_ImportEnumForMap: @unchecked Sendable {} -extension ProtobufUnittestImport_ImportMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest_import" - -extension ProtobufUnittestImport_ImportEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 7: .same(proto: "IMPORT_FOO"), - 8: .same(proto: "IMPORT_BAR"), - 9: .same(proto: "IMPORT_BAZ"), - ] -} +fileprivate let _protobuf_package = "swift_proto_testing.import" -extension ProtobufUnittestImport_ImportEnumForMap: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "UNKNOWN"), - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - ] +extension SwiftProtoTesting_Import_ImportEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7}IMPORT_FOO\0\u{1}IMPORT_BAR\0\u{1}IMPORT_BAZ\0") } -extension ProtobufUnittestImport_ImportMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Import_ImportMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ImportMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "d"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}d\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -207,7 +123,7 @@ extension ProtobufUnittestImport_ImportMessage: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestImport_ImportMessage, rhs: ProtobufUnittestImport_ImportMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Import_ImportMessage, rhs: SwiftProtoTesting_Import_ImportMessage) -> Bool { if lhs._d != rhs._d {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Tests/SwiftProtobufTests/unittest_import_lite.pb.swift b/Tests/SwiftProtobufTests/unittest_import_lite.pb.swift deleted file mode 100644 index 3ede8968c..000000000 --- a/Tests/SwiftProtobufTests/unittest_import_lite.pb.swift +++ /dev/null @@ -1,166 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_import_lite.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) -// -// This is like unittest_import.proto but with optimize_for = LITE_RUNTIME. - -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 ProtobufUnittestImport_ImportEnumLite: SwiftProtobuf.Enum { - typealias RawValue = Int - case importLiteFoo // = 7 - case importLiteBar // = 8 - case importLiteBaz // = 9 - - init() { - self = .importLiteFoo - } - - init?(rawValue: Int) { - switch rawValue { - case 7: self = .importLiteFoo - case 8: self = .importLiteBar - case 9: self = .importLiteBaz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .importLiteFoo: return 7 - case .importLiteBar: return 8 - case .importLiteBaz: return 9 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittestImport_ImportEnumLite: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittestImport_ImportMessageLite { - // 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 d: Int32 { - get {return _d ?? 0} - set {_d = newValue} - } - /// Returns true if `d` has been explicitly set. - var hasD: Bool {return self._d != nil} - /// Clears the value of `d`. Subsequent reads from it will return its default value. - mutating func clearD() {self._d = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _d: Int32? = nil -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittestImport_ImportEnumLite: @unchecked Sendable {} -extension ProtobufUnittestImport_ImportMessageLite: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest_import" - -extension ProtobufUnittestImport_ImportEnumLite: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 7: .same(proto: "IMPORT_LITE_FOO"), - 8: .same(proto: "IMPORT_LITE_BAR"), - 9: .same(proto: "IMPORT_LITE_BAZ"), - ] -} - -extension ProtobufUnittestImport_ImportMessageLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ImportMessageLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "d"), - ] - - 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._d) }() - 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 - try { if let v = self._d { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittestImport_ImportMessageLite, rhs: ProtobufUnittestImport_ImportMessageLite) -> Bool { - if lhs._d != rhs._d {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Tests/SwiftProtobufTests/unittest_import_public.pb.swift b/Tests/SwiftProtobufTests/unittest_import_public.pb.swift index d049db08c..f1008d656 100644 --- a/Tests/SwiftProtobufTests/unittest_import_public.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_import_public.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_import_public.proto +// Source: unittest_import_public.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -39,7 +40,6 @@ // Author: liujisi@google.com (Pherl Liu) -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -52,17 +52,17 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittestImport_PublicImportMessage { +struct SwiftProtoTesting_Import_PublicImportMessage: Sendable { // 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 e: Int32 { - get {return _e ?? 0} + get {_e ?? 0} set {_e = newValue} } /// Returns true if `e` has been explicitly set. - var hasE: Bool {return self._e != nil} + var hasE: Bool {self._e != nil} /// Clears the value of `e`. Subsequent reads from it will return its default value. mutating func clearE() {self._e = nil} @@ -73,19 +73,13 @@ struct ProtobufUnittestImport_PublicImportMessage { fileprivate var _e: Int32? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittestImport_PublicImportMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest_import" +fileprivate let _protobuf_package = "swift_proto_testing.import" -extension ProtobufUnittestImport_PublicImportMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Import_PublicImportMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".PublicImportMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "e"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}e\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -110,7 +104,7 @@ extension ProtobufUnittestImport_PublicImportMessage: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittestImport_PublicImportMessage, rhs: ProtobufUnittestImport_PublicImportMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Import_PublicImportMessage, rhs: SwiftProtoTesting_Import_PublicImportMessage) -> Bool { if lhs._e != rhs._e {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Tests/SwiftProtobufTests/unittest_lite.pb.swift b/Tests/SwiftProtobufTests/unittest_lite.pb.swift deleted file mode 100644 index 0be873709..000000000 --- a/Tests/SwiftProtobufTests/unittest_lite.pb.swift +++ /dev/null @@ -1,6197 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_lite.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) -// -// This is like unittest.proto but with optimize_for = LITE_RUNTIME. - -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 ProtobufUnittest_ForeignEnumLite: SwiftProtobuf.Enum { - typealias RawValue = Int - case foreignLiteFoo // = 4 - case foreignLiteBaz // = 6 - case foreignLiteBar // = 5 - - init() { - self = .foreignLiteFoo - } - - init?(rawValue: Int) { - switch rawValue { - case 4: self = .foreignLiteFoo - case 5: self = .foreignLiteBar - case 6: self = .foreignLiteBaz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foreignLiteFoo: return 4 - case .foreignLiteBar: return 5 - case .foreignLiteBaz: return 6 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_ForeignEnumLite: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -enum ProtobufUnittest_V1EnumLite: SwiftProtobuf.Enum { - typealias RawValue = Int - case v1First // = 1 - - init() { - self = .v1First - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .v1First - default: return nil - } - } - - var rawValue: Int { - switch self { - case .v1First: return 1 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_V1EnumLite: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -enum ProtobufUnittest_V2EnumLite: SwiftProtobuf.Enum { - typealias RawValue = Int - case v2First // = 1 - case v2Second // = 2 - - init() { - self = .v2First - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .v2First - case 2: self = .v2Second - default: return nil - } - } - - var rawValue: Int { - switch self { - case .v2First: return 1 - case .v2Second: return 2 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_V2EnumLite: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -/// Same as TestAllTypes but with the lite runtime. -struct ProtobufUnittest_TestAllTypesLite { - // 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. - - /// Singular - var optionalInt32: Int32 { - get {return _storage._optionalInt32 ?? 0} - set {_uniqueStorage()._optionalInt32 = newValue} - } - /// Returns true if `optionalInt32` has been explicitly set. - var hasOptionalInt32: Bool {return _storage._optionalInt32 != nil} - /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. - mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} - - var optionalInt64: Int64 { - get {return _storage._optionalInt64 ?? 0} - set {_uniqueStorage()._optionalInt64 = newValue} - } - /// Returns true if `optionalInt64` has been explicitly set. - var hasOptionalInt64: Bool {return _storage._optionalInt64 != nil} - /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. - mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} - - var optionalUint32: UInt32 { - get {return _storage._optionalUint32 ?? 0} - set {_uniqueStorage()._optionalUint32 = newValue} - } - /// Returns true if `optionalUint32` has been explicitly set. - var hasOptionalUint32: Bool {return _storage._optionalUint32 != nil} - /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. - mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} - - var optionalUint64: UInt64 { - get {return _storage._optionalUint64 ?? 0} - set {_uniqueStorage()._optionalUint64 = newValue} - } - /// Returns true if `optionalUint64` has been explicitly set. - var hasOptionalUint64: Bool {return _storage._optionalUint64 != nil} - /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. - mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} - - var optionalSint32: Int32 { - get {return _storage._optionalSint32 ?? 0} - set {_uniqueStorage()._optionalSint32 = newValue} - } - /// Returns true if `optionalSint32` has been explicitly set. - var hasOptionalSint32: Bool {return _storage._optionalSint32 != nil} - /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. - mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} - - var optionalSint64: Int64 { - get {return _storage._optionalSint64 ?? 0} - set {_uniqueStorage()._optionalSint64 = newValue} - } - /// Returns true if `optionalSint64` has been explicitly set. - var hasOptionalSint64: Bool {return _storage._optionalSint64 != nil} - /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. - mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} - - var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32 ?? 0} - set {_uniqueStorage()._optionalFixed32 = newValue} - } - /// Returns true if `optionalFixed32` has been explicitly set. - var hasOptionalFixed32: Bool {return _storage._optionalFixed32 != nil} - /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. - mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} - - var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64 ?? 0} - set {_uniqueStorage()._optionalFixed64 = newValue} - } - /// Returns true if `optionalFixed64` has been explicitly set. - var hasOptionalFixed64: Bool {return _storage._optionalFixed64 != nil} - /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. - mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} - - var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32 ?? 0} - set {_uniqueStorage()._optionalSfixed32 = newValue} - } - /// Returns true if `optionalSfixed32` has been explicitly set. - var hasOptionalSfixed32: Bool {return _storage._optionalSfixed32 != nil} - /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. - mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} - - var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64 ?? 0} - set {_uniqueStorage()._optionalSfixed64 = newValue} - } - /// Returns true if `optionalSfixed64` has been explicitly set. - var hasOptionalSfixed64: Bool {return _storage._optionalSfixed64 != nil} - /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. - mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} - - var optionalFloat: Float { - get {return _storage._optionalFloat ?? 0} - set {_uniqueStorage()._optionalFloat = newValue} - } - /// Returns true if `optionalFloat` has been explicitly set. - var hasOptionalFloat: Bool {return _storage._optionalFloat != nil} - /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. - mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} - - var optionalDouble: Double { - get {return _storage._optionalDouble ?? 0} - set {_uniqueStorage()._optionalDouble = newValue} - } - /// Returns true if `optionalDouble` has been explicitly set. - var hasOptionalDouble: Bool {return _storage._optionalDouble != nil} - /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. - mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} - - var optionalBool: Bool { - get {return _storage._optionalBool ?? false} - set {_uniqueStorage()._optionalBool = newValue} - } - /// Returns true if `optionalBool` has been explicitly set. - var hasOptionalBool: Bool {return _storage._optionalBool != nil} - /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. - mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} - - var optionalString: String { - get {return _storage._optionalString ?? String()} - set {_uniqueStorage()._optionalString = newValue} - } - /// Returns true if `optionalString` has been explicitly set. - var hasOptionalString: Bool {return _storage._optionalString != nil} - /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. - mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} - - var optionalBytes: Data { - get {return _storage._optionalBytes ?? Data()} - set {_uniqueStorage()._optionalBytes = newValue} - } - /// Returns true if `optionalBytes` has been explicitly set. - var hasOptionalBytes: Bool {return _storage._optionalBytes != nil} - /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. - mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} - - var optionalGroup: ProtobufUnittest_TestAllTypesLite.OptionalGroup { - get {return _storage._optionalGroup ?? ProtobufUnittest_TestAllTypesLite.OptionalGroup()} - set {_uniqueStorage()._optionalGroup = newValue} - } - /// Returns true if `optionalGroup` has been explicitly set. - var hasOptionalGroup: Bool {return _storage._optionalGroup != nil} - /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. - mutating func clearOptionalGroup() {_uniqueStorage()._optionalGroup = nil} - - var optionalNestedMessage: ProtobufUnittest_TestAllTypesLite.NestedMessage { - get {return _storage._optionalNestedMessage ?? ProtobufUnittest_TestAllTypesLite.NestedMessage()} - set {_uniqueStorage()._optionalNestedMessage = newValue} - } - /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} - /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} - - var optionalForeignMessage: ProtobufUnittest_ForeignMessageLite { - get {return _storage._optionalForeignMessage ?? ProtobufUnittest_ForeignMessageLite()} - set {_uniqueStorage()._optionalForeignMessage = newValue} - } - /// Returns true if `optionalForeignMessage` has been explicitly set. - var hasOptionalForeignMessage: Bool {return _storage._optionalForeignMessage != nil} - /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} - - var optionalImportMessage: ProtobufUnittestImport_ImportMessageLite { - get {return _storage._optionalImportMessage ?? ProtobufUnittestImport_ImportMessageLite()} - set {_uniqueStorage()._optionalImportMessage = newValue} - } - /// Returns true if `optionalImportMessage` has been explicitly set. - var hasOptionalImportMessage: Bool {return _storage._optionalImportMessage != nil} - /// Clears the value of `optionalImportMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalImportMessage() {_uniqueStorage()._optionalImportMessage = nil} - - var optionalNestedEnum: ProtobufUnittest_TestAllTypesLite.NestedEnum { - get {return _storage._optionalNestedEnum ?? .foo} - set {_uniqueStorage()._optionalNestedEnum = newValue} - } - /// Returns true if `optionalNestedEnum` has been explicitly set. - var hasOptionalNestedEnum: Bool {return _storage._optionalNestedEnum != nil} - /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. - mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} - - var optionalForeignEnum: ProtobufUnittest_ForeignEnumLite { - get {return _storage._optionalForeignEnum ?? .foreignLiteFoo} - set {_uniqueStorage()._optionalForeignEnum = newValue} - } - /// Returns true if `optionalForeignEnum` has been explicitly set. - var hasOptionalForeignEnum: Bool {return _storage._optionalForeignEnum != nil} - /// Clears the value of `optionalForeignEnum`. Subsequent reads from it will return its default value. - mutating func clearOptionalForeignEnum() {_uniqueStorage()._optionalForeignEnum = nil} - - var optionalImportEnum: ProtobufUnittestImport_ImportEnumLite { - get {return _storage._optionalImportEnum ?? .importLiteFoo} - set {_uniqueStorage()._optionalImportEnum = newValue} - } - /// Returns true if `optionalImportEnum` has been explicitly set. - var hasOptionalImportEnum: Bool {return _storage._optionalImportEnum != nil} - /// Clears the value of `optionalImportEnum`. Subsequent reads from it will return its default value. - mutating func clearOptionalImportEnum() {_uniqueStorage()._optionalImportEnum = nil} - - var optionalStringPiece: String { - get {return _storage._optionalStringPiece ?? String()} - set {_uniqueStorage()._optionalStringPiece = newValue} - } - /// Returns true if `optionalStringPiece` has been explicitly set. - var hasOptionalStringPiece: Bool {return _storage._optionalStringPiece != nil} - /// Clears the value of `optionalStringPiece`. Subsequent reads from it will return its default value. - mutating func clearOptionalStringPiece() {_uniqueStorage()._optionalStringPiece = nil} - - var optionalCord: String { - get {return _storage._optionalCord ?? String()} - set {_uniqueStorage()._optionalCord = newValue} - } - /// Returns true if `optionalCord` has been explicitly set. - var hasOptionalCord: Bool {return _storage._optionalCord != nil} - /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. - mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} - - /// Defined in unittest_import_public.proto - var optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessageLite { - get {return _storage._optionalPublicImportMessage ?? ProtobufUnittestImport_PublicImportMessageLite()} - set {_uniqueStorage()._optionalPublicImportMessage = newValue} - } - /// Returns true if `optionalPublicImportMessage` has been explicitly set. - var hasOptionalPublicImportMessage: Bool {return _storage._optionalPublicImportMessage != nil} - /// Clears the value of `optionalPublicImportMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalPublicImportMessage() {_uniqueStorage()._optionalPublicImportMessage = nil} - - var optionalLazyMessage: ProtobufUnittest_TestAllTypesLite.NestedMessage { - get {return _storage._optionalLazyMessage ?? ProtobufUnittest_TestAllTypesLite.NestedMessage()} - set {_uniqueStorage()._optionalLazyMessage = newValue} - } - /// Returns true if `optionalLazyMessage` has been explicitly set. - var hasOptionalLazyMessage: Bool {return _storage._optionalLazyMessage != nil} - /// Clears the value of `optionalLazyMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalLazyMessage() {_uniqueStorage()._optionalLazyMessage = nil} - - /// Repeated - var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} - set {_uniqueStorage()._repeatedInt32 = newValue} - } - - var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} - set {_uniqueStorage()._repeatedInt64 = newValue} - } - - var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} - set {_uniqueStorage()._repeatedUint32 = newValue} - } - - var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} - set {_uniqueStorage()._repeatedUint64 = newValue} - } - - var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} - set {_uniqueStorage()._repeatedSint32 = newValue} - } - - var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} - set {_uniqueStorage()._repeatedSint64 = newValue} - } - - var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} - set {_uniqueStorage()._repeatedFixed32 = newValue} - } - - var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} - set {_uniqueStorage()._repeatedFixed64 = newValue} - } - - var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} - set {_uniqueStorage()._repeatedSfixed32 = newValue} - } - - var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} - set {_uniqueStorage()._repeatedSfixed64 = newValue} - } - - var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} - set {_uniqueStorage()._repeatedFloat = newValue} - } - - var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} - set {_uniqueStorage()._repeatedDouble = newValue} - } - - var repeatedBool: [Bool] { - get {return _storage._repeatedBool} - set {_uniqueStorage()._repeatedBool = newValue} - } - - var repeatedString: [String] { - get {return _storage._repeatedString} - set {_uniqueStorage()._repeatedString = newValue} - } - - var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} - set {_uniqueStorage()._repeatedBytes = newValue} - } - - var repeatedGroup: [ProtobufUnittest_TestAllTypesLite.RepeatedGroup] { - get {return _storage._repeatedGroup} - set {_uniqueStorage()._repeatedGroup = newValue} - } - - var repeatedNestedMessage: [ProtobufUnittest_TestAllTypesLite.NestedMessage] { - get {return _storage._repeatedNestedMessage} - set {_uniqueStorage()._repeatedNestedMessage = newValue} - } - - var repeatedForeignMessage: [ProtobufUnittest_ForeignMessageLite] { - get {return _storage._repeatedForeignMessage} - set {_uniqueStorage()._repeatedForeignMessage = newValue} - } - - var repeatedImportMessage: [ProtobufUnittestImport_ImportMessageLite] { - get {return _storage._repeatedImportMessage} - set {_uniqueStorage()._repeatedImportMessage = newValue} - } - - var repeatedNestedEnum: [ProtobufUnittest_TestAllTypesLite.NestedEnum] { - get {return _storage._repeatedNestedEnum} - set {_uniqueStorage()._repeatedNestedEnum = newValue} - } - - var repeatedForeignEnum: [ProtobufUnittest_ForeignEnumLite] { - get {return _storage._repeatedForeignEnum} - set {_uniqueStorage()._repeatedForeignEnum = newValue} - } - - var repeatedImportEnum: [ProtobufUnittestImport_ImportEnumLite] { - get {return _storage._repeatedImportEnum} - set {_uniqueStorage()._repeatedImportEnum = newValue} - } - - var repeatedStringPiece: [String] { - get {return _storage._repeatedStringPiece} - set {_uniqueStorage()._repeatedStringPiece = newValue} - } - - var repeatedCord: [String] { - get {return _storage._repeatedCord} - set {_uniqueStorage()._repeatedCord = newValue} - } - - var repeatedLazyMessage: [ProtobufUnittest_TestAllTypesLite.NestedMessage] { - get {return _storage._repeatedLazyMessage} - set {_uniqueStorage()._repeatedLazyMessage = newValue} - } - - /// Singular with defaults - var defaultInt32: Int32 { - get {return _storage._defaultInt32 ?? 41} - set {_uniqueStorage()._defaultInt32 = newValue} - } - /// Returns true if `defaultInt32` has been explicitly set. - var hasDefaultInt32: Bool {return _storage._defaultInt32 != nil} - /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. - mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} - - var defaultInt64: Int64 { - get {return _storage._defaultInt64 ?? 42} - set {_uniqueStorage()._defaultInt64 = newValue} - } - /// Returns true if `defaultInt64` has been explicitly set. - var hasDefaultInt64: Bool {return _storage._defaultInt64 != nil} - /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. - mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} - - var defaultUint32: UInt32 { - get {return _storage._defaultUint32 ?? 43} - set {_uniqueStorage()._defaultUint32 = newValue} - } - /// Returns true if `defaultUint32` has been explicitly set. - var hasDefaultUint32: Bool {return _storage._defaultUint32 != nil} - /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. - mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} - - var defaultUint64: UInt64 { - get {return _storage._defaultUint64 ?? 44} - set {_uniqueStorage()._defaultUint64 = newValue} - } - /// Returns true if `defaultUint64` has been explicitly set. - var hasDefaultUint64: Bool {return _storage._defaultUint64 != nil} - /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. - mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} - - var defaultSint32: Int32 { - get {return _storage._defaultSint32 ?? -45} - set {_uniqueStorage()._defaultSint32 = newValue} - } - /// Returns true if `defaultSint32` has been explicitly set. - var hasDefaultSint32: Bool {return _storage._defaultSint32 != nil} - /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. - mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} - - var defaultSint64: Int64 { - get {return _storage._defaultSint64 ?? 46} - set {_uniqueStorage()._defaultSint64 = newValue} - } - /// Returns true if `defaultSint64` has been explicitly set. - var hasDefaultSint64: Bool {return _storage._defaultSint64 != nil} - /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. - mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} - - var defaultFixed32: UInt32 { - get {return _storage._defaultFixed32 ?? 47} - set {_uniqueStorage()._defaultFixed32 = newValue} - } - /// Returns true if `defaultFixed32` has been explicitly set. - var hasDefaultFixed32: Bool {return _storage._defaultFixed32 != nil} - /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. - mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} - - var defaultFixed64: UInt64 { - get {return _storage._defaultFixed64 ?? 48} - set {_uniqueStorage()._defaultFixed64 = newValue} - } - /// Returns true if `defaultFixed64` has been explicitly set. - var hasDefaultFixed64: Bool {return _storage._defaultFixed64 != nil} - /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. - mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} - - var defaultSfixed32: Int32 { - get {return _storage._defaultSfixed32 ?? 49} - set {_uniqueStorage()._defaultSfixed32 = newValue} - } - /// Returns true if `defaultSfixed32` has been explicitly set. - var hasDefaultSfixed32: Bool {return _storage._defaultSfixed32 != nil} - /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. - mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} - - var defaultSfixed64: Int64 { - get {return _storage._defaultSfixed64 ?? -50} - set {_uniqueStorage()._defaultSfixed64 = newValue} - } - /// Returns true if `defaultSfixed64` has been explicitly set. - var hasDefaultSfixed64: Bool {return _storage._defaultSfixed64 != nil} - /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. - mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} - - var defaultFloat: Float { - get {return _storage._defaultFloat ?? 51.5} - set {_uniqueStorage()._defaultFloat = newValue} - } - /// Returns true if `defaultFloat` has been explicitly set. - var hasDefaultFloat: Bool {return _storage._defaultFloat != nil} - /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. - mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} - - var defaultDouble: Double { - get {return _storage._defaultDouble ?? 52000} - set {_uniqueStorage()._defaultDouble = newValue} - } - /// Returns true if `defaultDouble` has been explicitly set. - var hasDefaultDouble: Bool {return _storage._defaultDouble != nil} - /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. - mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} - - var defaultBool: Bool { - get {return _storage._defaultBool ?? true} - set {_uniqueStorage()._defaultBool = newValue} - } - /// Returns true if `defaultBool` has been explicitly set. - var hasDefaultBool: Bool {return _storage._defaultBool != nil} - /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. - mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} - - var defaultString: String { - get {return _storage._defaultString ?? "hello"} - set {_uniqueStorage()._defaultString = newValue} - } - /// Returns true if `defaultString` has been explicitly set. - var hasDefaultString: Bool {return _storage._defaultString != nil} - /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. - mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} - - var defaultBytes: Data { - get {return _storage._defaultBytes ?? Data([119, 111, 114, 108, 100])} - set {_uniqueStorage()._defaultBytes = newValue} - } - /// Returns true if `defaultBytes` has been explicitly set. - var hasDefaultBytes: Bool {return _storage._defaultBytes != nil} - /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. - mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} - - var defaultNestedEnum: ProtobufUnittest_TestAllTypesLite.NestedEnum { - get {return _storage._defaultNestedEnum ?? .bar} - set {_uniqueStorage()._defaultNestedEnum = newValue} - } - /// Returns true if `defaultNestedEnum` has been explicitly set. - var hasDefaultNestedEnum: Bool {return _storage._defaultNestedEnum != nil} - /// Clears the value of `defaultNestedEnum`. Subsequent reads from it will return its default value. - mutating func clearDefaultNestedEnum() {_uniqueStorage()._defaultNestedEnum = nil} - - var defaultForeignEnum: ProtobufUnittest_ForeignEnumLite { - get {return _storage._defaultForeignEnum ?? .foreignLiteBar} - set {_uniqueStorage()._defaultForeignEnum = newValue} - } - /// Returns true if `defaultForeignEnum` has been explicitly set. - var hasDefaultForeignEnum: Bool {return _storage._defaultForeignEnum != nil} - /// Clears the value of `defaultForeignEnum`. Subsequent reads from it will return its default value. - mutating func clearDefaultForeignEnum() {_uniqueStorage()._defaultForeignEnum = nil} - - var defaultImportEnum: ProtobufUnittestImport_ImportEnumLite { - get {return _storage._defaultImportEnum ?? .importLiteBar} - set {_uniqueStorage()._defaultImportEnum = newValue} - } - /// Returns true if `defaultImportEnum` has been explicitly set. - var hasDefaultImportEnum: Bool {return _storage._defaultImportEnum != nil} - /// Clears the value of `defaultImportEnum`. Subsequent reads from it will return its default value. - mutating func clearDefaultImportEnum() {_uniqueStorage()._defaultImportEnum = nil} - - var defaultStringPiece: String { - get {return _storage._defaultStringPiece ?? "abc"} - set {_uniqueStorage()._defaultStringPiece = newValue} - } - /// Returns true if `defaultStringPiece` has been explicitly set. - var hasDefaultStringPiece: Bool {return _storage._defaultStringPiece != nil} - /// Clears the value of `defaultStringPiece`. Subsequent reads from it will return its default value. - mutating func clearDefaultStringPiece() {_uniqueStorage()._defaultStringPiece = nil} - - var defaultCord: String { - get {return _storage._defaultCord ?? "123"} - set {_uniqueStorage()._defaultCord = newValue} - } - /// Returns true if `defaultCord` has been explicitly set. - var hasDefaultCord: Bool {return _storage._defaultCord != nil} - /// Clears the value of `defaultCord`. Subsequent reads from it will return its default value. - mutating func clearDefaultCord() {_uniqueStorage()._defaultCord = nil} - - /// For oneof test - var oneofField: OneOf_OneofField? { - get {return _storage._oneofField} - set {_uniqueStorage()._oneofField = newValue} - } - - var oneofUint32: UInt32 { - get { - if case .oneofUint32(let v)? = _storage._oneofField {return v} - return 0 - } - set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} - } - - var oneofNestedMessage: ProtobufUnittest_TestAllTypesLite.NestedMessage { - get { - if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} - return ProtobufUnittest_TestAllTypesLite.NestedMessage() - } - set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} - } - - var oneofString: String { - get { - if case .oneofString(let v)? = _storage._oneofField {return v} - return String() - } - set {_uniqueStorage()._oneofField = .oneofString(newValue)} - } - - var oneofBytes: Data { - get { - if case .oneofBytes(let v)? = _storage._oneofField {return v} - return Data() - } - set {_uniqueStorage()._oneofField = .oneofBytes(newValue)} - } - - var oneofLazyNestedMessage: ProtobufUnittest_TestAllTypesLite.NestedMessage { - get { - if case .oneofLazyNestedMessage(let v)? = _storage._oneofField {return v} - return ProtobufUnittest_TestAllTypesLite.NestedMessage() - } - set {_uniqueStorage()._oneofField = .oneofLazyNestedMessage(newValue)} - } - - var oneofNestedMessage2: ProtobufUnittest_TestAllTypesLite.NestedMessage2 { - get { - if case .oneofNestedMessage2(let v)? = _storage._oneofField {return v} - return ProtobufUnittest_TestAllTypesLite.NestedMessage2() - } - set {_uniqueStorage()._oneofField = .oneofNestedMessage2(newValue)} - } - - /// Tests toString for non-repeated fields with a list suffix - var deceptivelyNamedList: Int32 { - get {return _storage._deceptivelyNamedList ?? 0} - set {_uniqueStorage()._deceptivelyNamedList = newValue} - } - /// Returns true if `deceptivelyNamedList` has been explicitly set. - var hasDeceptivelyNamedList: Bool {return _storage._deceptivelyNamedList != nil} - /// Clears the value of `deceptivelyNamedList`. Subsequent reads from it will return its default value. - mutating func clearDeceptivelyNamedList() {_uniqueStorage()._deceptivelyNamedList = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - /// For oneof test - enum OneOf_OneofField: Equatable { - case oneofUint32(UInt32) - case oneofNestedMessage(ProtobufUnittest_TestAllTypesLite.NestedMessage) - case oneofString(String) - case oneofBytes(Data) - case oneofLazyNestedMessage(ProtobufUnittest_TestAllTypesLite.NestedMessage) - case oneofNestedMessage2(ProtobufUnittest_TestAllTypesLite.NestedMessage2) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestAllTypesLite.OneOf_OneofField, rhs: ProtobufUnittest_TestAllTypesLite.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofLazyNestedMessage, .oneofLazyNestedMessage): return { - guard case .oneofLazyNestedMessage(let l) = lhs, case .oneofLazyNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage2, .oneofNestedMessage2): return { - guard case .oneofNestedMessage2(let l) = lhs, case .oneofNestedMessage2(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif - } - - enum NestedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 1 - case bar // = 2 - case baz // = 3 - - init() { - self = .foo - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .foo - case 2: self = .bar - case 3: self = .baz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo: return 1 - case .bar: return 2 - case .baz: return 3 - } - } - - } - - struct NestedMessage { - // 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 bb: Int32 { - get {return _bb ?? 0} - set {_bb = newValue} - } - /// Returns true if `bb` has been explicitly set. - var hasBb: Bool {return self._bb != nil} - /// Clears the value of `bb`. Subsequent reads from it will return its default value. - mutating func clearBb() {self._bb = nil} - - var cc: Int64 { - get {return _cc ?? 0} - set {_cc = newValue} - } - /// Returns true if `cc` has been explicitly set. - var hasCc: Bool {return self._cc != nil} - /// Clears the value of `cc`. Subsequent reads from it will return its default value. - mutating func clearCc() {self._cc = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _bb: Int32? = nil - fileprivate var _cc: Int64? = nil - } - - struct NestedMessage2 { - // 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 dd: Int32 { - get {return _dd ?? 0} - set {_dd = newValue} - } - /// Returns true if `dd` has been explicitly set. - var hasDd: Bool {return self._dd != nil} - /// Clears the value of `dd`. Subsequent reads from it will return its default value. - mutating func clearDd() {self._dd = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _dd: Int32? = nil - } - - struct OptionalGroup { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil - } - - struct RepeatedGroup { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil - } - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -#if swift(>=4.2) - -extension ProtobufUnittest_TestAllTypesLite.NestedEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_ForeignMessageLite { - // 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 c: Int32 { - get {return _c ?? 0} - set {_c = newValue} - } - /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} - /// Clears the value of `c`. Subsequent reads from it will return its default value. - mutating func clearC() {self._c = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _c: Int32? = nil -} - -struct ProtobufUnittest_TestPackedTypesLite { - // 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 packedInt32: [Int32] = [] - - var packedInt64: [Int64] = [] - - var packedUint32: [UInt32] = [] - - var packedUint64: [UInt64] = [] - - var packedSint32: [Int32] = [] - - var packedSint64: [Int64] = [] - - var packedFixed32: [UInt32] = [] - - var packedFixed64: [UInt64] = [] - - var packedSfixed32: [Int32] = [] - - var packedSfixed64: [Int64] = [] - - var packedFloat: [Float] = [] - - var packedDouble: [Double] = [] - - var packedBool: [Bool] = [] - - var packedEnum: [ProtobufUnittest_ForeignEnumLite] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -struct ProtobufUnittest_TestAllExtensionsLite: 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() -} - -struct ProtobufUnittest_OptionalGroup_extension_lite { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil -} - -struct ProtobufUnittest_RepeatedGroup_extension_lite { - // 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _a: Int32? = nil -} - -struct ProtobufUnittest_TestPackedExtensionsLite: 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() -} - -struct ProtobufUnittest_TestNestedExtensionLite { - // 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() {} -} - -/// Test that deprecated fields work. We only verify that they compile (at one -/// point this failed). -struct ProtobufUnittest_TestDeprecatedLite { - // 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 deprecatedField: Int32 { - get {return _storage._deprecatedField ?? 0} - set {_uniqueStorage()._deprecatedField = newValue} - } - /// Returns true if `deprecatedField` has been explicitly set. - var hasDeprecatedField: Bool {return _storage._deprecatedField != nil} - /// Clears the value of `deprecatedField`. Subsequent reads from it will return its default value. - mutating func clearDeprecatedField() {_uniqueStorage()._deprecatedField = nil} - - var deprecatedField2: Int32 { - get {return _storage._deprecatedField2 ?? 0} - set {_uniqueStorage()._deprecatedField2 = newValue} - } - /// Returns true if `deprecatedField2` has been explicitly set. - var hasDeprecatedField2: Bool {return _storage._deprecatedField2 != nil} - /// Clears the value of `deprecatedField2`. Subsequent reads from it will return its default value. - mutating func clearDeprecatedField2() {_uniqueStorage()._deprecatedField2 = nil} - - var deprecatedField3: String { - get {return _storage._deprecatedField3 ?? String()} - set {_uniqueStorage()._deprecatedField3 = newValue} - } - /// Returns true if `deprecatedField3` has been explicitly set. - var hasDeprecatedField3: Bool {return _storage._deprecatedField3 != nil} - /// Clears the value of `deprecatedField3`. Subsequent reads from it will return its default value. - mutating func clearDeprecatedField3() {_uniqueStorage()._deprecatedField3 = nil} - - var deprecatedField4: ProtobufUnittest_TestDeprecatedLite { - get {return _storage._deprecatedField4 ?? ProtobufUnittest_TestDeprecatedLite()} - set {_uniqueStorage()._deprecatedField4 = newValue} - } - /// Returns true if `deprecatedField4` has been explicitly set. - var hasDeprecatedField4: Bool {return _storage._deprecatedField4 != nil} - /// Clears the value of `deprecatedField4`. Subsequent reads from it will return its default value. - mutating func clearDeprecatedField4() {_uniqueStorage()._deprecatedField4 = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -/// See the comments of the same type in unittest.proto. -struct ProtobufUnittest_TestParsingMergeLite: 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 requiredAllTypes: ProtobufUnittest_TestAllTypesLite { - get {return _requiredAllTypes ?? ProtobufUnittest_TestAllTypesLite()} - set {_requiredAllTypes = newValue} - } - /// Returns true if `requiredAllTypes` has been explicitly set. - var hasRequiredAllTypes: Bool {return self._requiredAllTypes != nil} - /// Clears the value of `requiredAllTypes`. Subsequent reads from it will return its default value. - mutating func clearRequiredAllTypes() {self._requiredAllTypes = nil} - - var optionalAllTypes: ProtobufUnittest_TestAllTypesLite { - get {return _optionalAllTypes ?? ProtobufUnittest_TestAllTypesLite()} - set {_optionalAllTypes = newValue} - } - /// Returns true if `optionalAllTypes` has been explicitly set. - var hasOptionalAllTypes: Bool {return self._optionalAllTypes != nil} - /// Clears the value of `optionalAllTypes`. Subsequent reads from it will return its default value. - mutating func clearOptionalAllTypes() {self._optionalAllTypes = nil} - - var repeatedAllTypes: [ProtobufUnittest_TestAllTypesLite] = [] - - var optionalGroup: ProtobufUnittest_TestParsingMergeLite.OptionalGroup { - get {return _optionalGroup ?? ProtobufUnittest_TestParsingMergeLite.OptionalGroup()} - set {_optionalGroup = newValue} - } - /// Returns true if `optionalGroup` has been explicitly set. - var hasOptionalGroup: Bool {return self._optionalGroup != nil} - /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. - mutating func clearOptionalGroup() {self._optionalGroup = nil} - - var repeatedGroup: [ProtobufUnittest_TestParsingMergeLite.RepeatedGroup] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct RepeatedFieldsGenerator { - // 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: [ProtobufUnittest_TestAllTypesLite] = [] - - var field2: [ProtobufUnittest_TestAllTypesLite] = [] - - var field3: [ProtobufUnittest_TestAllTypesLite] = [] - - var group1: [ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group1] = [] - - var group2: [ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group2] = [] - - var ext1: [ProtobufUnittest_TestAllTypesLite] = [] - - var ext2: [ProtobufUnittest_TestAllTypesLite] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct Group1 { - // 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: ProtobufUnittest_TestAllTypesLite { - get {return _field1 ?? ProtobufUnittest_TestAllTypesLite()} - 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 unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _field1: ProtobufUnittest_TestAllTypesLite? = nil - } - - struct Group2 { - // 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: ProtobufUnittest_TestAllTypesLite { - get {return _field1 ?? ProtobufUnittest_TestAllTypesLite()} - 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 unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _field1: ProtobufUnittest_TestAllTypesLite? = nil - } - - init() {} - } - - struct OptionalGroup { - // 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 optionalGroupAllTypes: ProtobufUnittest_TestAllTypesLite { - get {return _optionalGroupAllTypes ?? ProtobufUnittest_TestAllTypesLite()} - set {_optionalGroupAllTypes = newValue} - } - /// Returns true if `optionalGroupAllTypes` has been explicitly set. - var hasOptionalGroupAllTypes: Bool {return self._optionalGroupAllTypes != nil} - /// Clears the value of `optionalGroupAllTypes`. Subsequent reads from it will return its default value. - mutating func clearOptionalGroupAllTypes() {self._optionalGroupAllTypes = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _optionalGroupAllTypes: ProtobufUnittest_TestAllTypesLite? = nil - } - - struct RepeatedGroup { - // 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 repeatedGroupAllTypes: ProtobufUnittest_TestAllTypesLite { - get {return _repeatedGroupAllTypes ?? ProtobufUnittest_TestAllTypesLite()} - set {_repeatedGroupAllTypes = newValue} - } - /// Returns true if `repeatedGroupAllTypes` has been explicitly set. - var hasRepeatedGroupAllTypes: Bool {return self._repeatedGroupAllTypes != nil} - /// Clears the value of `repeatedGroupAllTypes`. Subsequent reads from it will return its default value. - mutating func clearRepeatedGroupAllTypes() {self._repeatedGroupAllTypes = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _repeatedGroupAllTypes: ProtobufUnittest_TestAllTypesLite? = nil - } - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _requiredAllTypes: ProtobufUnittest_TestAllTypesLite? = nil - fileprivate var _optionalAllTypes: ProtobufUnittest_TestAllTypesLite? = nil - fileprivate var _optionalGroup: ProtobufUnittest_TestParsingMergeLite.OptionalGroup? = nil -} - -/// TestEmptyMessageLite is used to test unknown fields support in lite mode. -struct ProtobufUnittest_TestEmptyMessageLite { - // 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() {} -} - -/// Like above, but declare all field numbers as potential extensions. No -/// actual extensions should ever be defined for this type. -struct ProtobufUnittest_TestEmptyMessageWithExtensionsLite: 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() -} - -struct ProtobufUnittest_V1MessageLite { - // 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 intField: Int32 { - get {return _intField ?? 0} - set {_intField = newValue} - } - /// Returns true if `intField` has been explicitly set. - var hasIntField: Bool {return self._intField != nil} - /// Clears the value of `intField`. Subsequent reads from it will return its default value. - mutating func clearIntField() {self._intField = nil} - - var enumField: ProtobufUnittest_V1EnumLite { - get {return _enumField ?? .v1First} - set {_enumField = newValue} - } - /// Returns true if `enumField` has been explicitly set. - var hasEnumField: Bool {return self._enumField != nil} - /// Clears the value of `enumField`. Subsequent reads from it will return its default value. - mutating func clearEnumField() {self._enumField = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _intField: Int32? = nil - fileprivate var _enumField: ProtobufUnittest_V1EnumLite? = nil -} - -struct ProtobufUnittest_V2MessageLite { - // 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 intField: Int32 { - get {return _intField ?? 0} - set {_intField = newValue} - } - /// Returns true if `intField` has been explicitly set. - var hasIntField: Bool {return self._intField != nil} - /// Clears the value of `intField`. Subsequent reads from it will return its default value. - mutating func clearIntField() {self._intField = nil} - - var enumField: ProtobufUnittest_V2EnumLite { - get {return _enumField ?? .v2First} - set {_enumField = newValue} - } - /// Returns true if `enumField` has been explicitly set. - var hasEnumField: Bool {return self._enumField != nil} - /// Clears the value of `enumField`. Subsequent reads from it will return its default value. - mutating func clearEnumField() {self._enumField = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _intField: Int32? = nil - fileprivate var _enumField: ProtobufUnittest_V2EnumLite? = nil -} - -struct ProtobufUnittest_TestHugeFieldNumbersLite: 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 optionalInt32: Int32 { - get {return _optionalInt32 ?? 0} - set {_optionalInt32 = newValue} - } - /// Returns true if `optionalInt32` has been explicitly set. - var hasOptionalInt32: Bool {return self._optionalInt32 != nil} - /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. - mutating func clearOptionalInt32() {self._optionalInt32 = nil} - - var fixed32: Int32 { - get {return _fixed32 ?? 0} - set {_fixed32 = newValue} - } - /// Returns true if `fixed32` has been explicitly set. - var hasFixed32: Bool {return self._fixed32 != nil} - /// Clears the value of `fixed32`. Subsequent reads from it will return its default value. - mutating func clearFixed32() {self._fixed32 = nil} - - var repeatedInt32: [Int32] = [] - - var packedInt32: [Int32] = [] - - var optionalEnum: ProtobufUnittest_ForeignEnumLite { - get {return _optionalEnum ?? .foreignLiteFoo} - set {_optionalEnum = newValue} - } - /// Returns true if `optionalEnum` has been explicitly set. - var hasOptionalEnum: Bool {return self._optionalEnum != nil} - /// Clears the value of `optionalEnum`. Subsequent reads from it will return its default value. - mutating func clearOptionalEnum() {self._optionalEnum = nil} - - var optionalString: String { - get {return _optionalString ?? String()} - set {_optionalString = newValue} - } - /// Returns true if `optionalString` has been explicitly set. - var hasOptionalString: Bool {return self._optionalString != nil} - /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. - mutating func clearOptionalString() {self._optionalString = nil} - - var optionalBytes: Data { - get {return _optionalBytes ?? Data()} - set {_optionalBytes = newValue} - } - /// Returns true if `optionalBytes` has been explicitly set. - var hasOptionalBytes: Bool {return self._optionalBytes != nil} - /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. - mutating func clearOptionalBytes() {self._optionalBytes = nil} - - var optionalMessage: ProtobufUnittest_ForeignMessageLite { - get {return _optionalMessage ?? ProtobufUnittest_ForeignMessageLite()} - set {_optionalMessage = newValue} - } - /// Returns true if `optionalMessage` has been explicitly set. - var hasOptionalMessage: Bool {return self._optionalMessage != nil} - /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalMessage() {self._optionalMessage = nil} - - var optionalGroup: ProtobufUnittest_TestHugeFieldNumbersLite.OptionalGroup { - get {return _optionalGroup ?? ProtobufUnittest_TestHugeFieldNumbersLite.OptionalGroup()} - set {_optionalGroup = newValue} - } - /// Returns true if `optionalGroup` has been explicitly set. - var hasOptionalGroup: Bool {return self._optionalGroup != nil} - /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. - mutating func clearOptionalGroup() {self._optionalGroup = nil} - - var stringStringMap: Dictionary = [:] - - var oneofField: ProtobufUnittest_TestHugeFieldNumbersLite.OneOf_OneofField? = nil - - var oneofUint32: UInt32 { - get { - if case .oneofUint32(let v)? = oneofField {return v} - return 0 - } - set {oneofField = .oneofUint32(newValue)} - } - - var oneofTestAllTypes: ProtobufUnittest_TestAllTypesLite { - get { - if case .oneofTestAllTypes(let v)? = oneofField {return v} - return ProtobufUnittest_TestAllTypesLite() - } - set {oneofField = .oneofTestAllTypes(newValue)} - } - - var oneofString: String { - get { - if case .oneofString(let v)? = oneofField {return v} - return String() - } - set {oneofField = .oneofString(newValue)} - } - - var oneofBytes: Data { - get { - if case .oneofBytes(let v)? = oneofField {return v} - return Data() - } - set {oneofField = .oneofBytes(newValue)} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum OneOf_OneofField: Equatable { - case oneofUint32(UInt32) - case oneofTestAllTypes(ProtobufUnittest_TestAllTypesLite) - case oneofString(String) - case oneofBytes(Data) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestHugeFieldNumbersLite.OneOf_OneofField, rhs: ProtobufUnittest_TestHugeFieldNumbersLite.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofTestAllTypes, .oneofTestAllTypes): return { - guard case .oneofTestAllTypes(let l) = lhs, case .oneofTestAllTypes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif - } - - struct OptionalGroup { - // 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 groupA: Int32 { - get {return _groupA ?? 0} - set {_groupA = newValue} - } - /// Returns true if `groupA` has been explicitly set. - var hasGroupA: Bool {return self._groupA != nil} - /// Clears the value of `groupA`. Subsequent reads from it will return its default value. - mutating func clearGroupA() {self._groupA = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _groupA: Int32? = nil - } - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _optionalInt32: Int32? = nil - fileprivate var _fixed32: Int32? = nil - fileprivate var _optionalEnum: ProtobufUnittest_ForeignEnumLite? = nil - fileprivate var _optionalString: String? = nil - fileprivate var _optionalBytes: Data? = nil - fileprivate var _optionalMessage: ProtobufUnittest_ForeignMessageLite? = nil - fileprivate var _optionalGroup: ProtobufUnittest_TestHugeFieldNumbersLite.OptionalGroup? = nil -} - -struct ProtobufUnittest_TestOneofParsingLite { - // 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 oneofField: ProtobufUnittest_TestOneofParsingLite.OneOf_OneofField? = nil - - var oneofInt32: Int32 { - get { - if case .oneofInt32(let v)? = oneofField {return v} - return 0 - } - set {oneofField = .oneofInt32(newValue)} - } - - var oneofSubmessage: ProtobufUnittest_TestAllTypesLite { - get { - if case .oneofSubmessage(let v)? = oneofField {return v} - return ProtobufUnittest_TestAllTypesLite() - } - set {oneofField = .oneofSubmessage(newValue)} - } - - var oneofString: String { - get { - if case .oneofString(let v)? = oneofField {return v} - return String() - } - set {oneofField = .oneofString(newValue)} - } - - var oneofBytes: Data { - get { - if case .oneofBytes(let v)? = oneofField {return v} - return Data([100, 101, 102, 97, 117, 108, 116, 32, 98, 121, 116, 101, 115]) - } - set {oneofField = .oneofBytes(newValue)} - } - - var oneofStringCord: String { - get { - if case .oneofStringCord(let v)? = oneofField {return v} - return "default Cord" - } - set {oneofField = .oneofStringCord(newValue)} - } - - var oneofBytesCord: Data { - get { - if case .oneofBytesCord(let v)? = oneofField {return v} - return Data() - } - set {oneofField = .oneofBytesCord(newValue)} - } - - var oneofStringStringPiece: String { - get { - if case .oneofStringStringPiece(let v)? = oneofField {return v} - return String() - } - set {oneofField = .oneofStringStringPiece(newValue)} - } - - var oneofBytesStringPiece: Data { - get { - if case .oneofBytesStringPiece(let v)? = oneofField {return v} - return Data([100, 101, 102, 97, 117, 108, 116, 32, 83, 116, 114, 105, 110, 103, 80, 105, 101, 99, 101]) - } - set {oneofField = .oneofBytesStringPiece(newValue)} - } - - var oneofEnum: ProtobufUnittest_V2EnumLite { - get { - if case .oneofEnum(let v)? = oneofField {return v} - return .v2First - } - set {oneofField = .oneofEnum(newValue)} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - enum OneOf_OneofField: Equatable { - case oneofInt32(Int32) - case oneofSubmessage(ProtobufUnittest_TestAllTypesLite) - case oneofString(String) - case oneofBytes(Data) - case oneofStringCord(String) - case oneofBytesCord(Data) - case oneofStringStringPiece(String) - case oneofBytesStringPiece(Data) - case oneofEnum(ProtobufUnittest_V2EnumLite) - - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestOneofParsingLite.OneOf_OneofField, rhs: ProtobufUnittest_TestOneofParsingLite.OneOf_OneofField) -> 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 (.oneofInt32, .oneofInt32): return { - guard case .oneofInt32(let l) = lhs, case .oneofInt32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSubmessage, .oneofSubmessage): return { - guard case .oneofSubmessage(let l) = lhs, case .oneofSubmessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofStringCord, .oneofStringCord): return { - guard case .oneofStringCord(let l) = lhs, case .oneofStringCord(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytesCord, .oneofBytesCord): return { - guard case .oneofBytesCord(let l) = lhs, case .oneofBytesCord(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofStringStringPiece, .oneofStringStringPiece): return { - guard case .oneofStringStringPiece(let l) = lhs, case .oneofStringStringPiece(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytesStringPiece, .oneofBytesStringPiece): return { - guard case .oneofBytesStringPiece(let l) = lhs, case .oneofBytesStringPiece(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofEnum, .oneofEnum): return { - guard case .oneofEnum(let l) = lhs, case .oneofEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif - } - - init() {} -} - -/// The following four messages are set up to test for wire compatibility between -/// packed and non-packed repeated fields. We use the field number 2048, because -/// that is large enough to require a 3-byte varint for the tag. -struct ProtobufUnittest_PackedInt32 { - // 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 repeatedInt32: [Int32] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -struct ProtobufUnittest_NonPackedInt32 { - // 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 repeatedInt32: [Int32] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -struct ProtobufUnittest_PackedFixed32 { - // 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 repeatedFixed32: [UInt32] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -struct ProtobufUnittest_NonPackedFixed32 { - // 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 repeatedFixed32: [UInt32] = [] - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -/// Test an enum that has multiple values with the same number. -struct ProtobufUnittest_DupEnum { - // 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() - - enum TestEnumWithDupValueLite: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo1 // = 1 - case bar1 // = 2 - case baz // = 3 - static let foo2 = foo1 - static let bar2 = bar1 - - init() { - self = .foo1 - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .foo1 - case 2: self = .bar1 - case 3: self = .baz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo1: return 1 - case .bar1: return 2 - case .baz: return 3 - } - } - - } - - init() {} -} - -#if swift(>=4.2) - -extension ProtobufUnittest_DupEnum.TestEnumWithDupValueLite: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_RecursiveMessage { - // 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 recurse: ProtobufUnittest_RecursiveMessage { - get {return _storage._recurse ?? ProtobufUnittest_RecursiveMessage()} - set {_uniqueStorage()._recurse = newValue} - } - /// Returns true if `recurse` has been explicitly set. - var hasRecurse: Bool {return _storage._recurse != nil} - /// Clears the value of `recurse`. Subsequent reads from it will return its default value. - mutating func clearRecurse() {_uniqueStorage()._recurse = nil} - - var payload: Data { - get {return _storage._payload ?? Data()} - set {_uniqueStorage()._payload = newValue} - } - /// Returns true if `payload` has been explicitly set. - var hasPayload: Bool {return _storage._payload != nil} - /// Clears the value of `payload`. Subsequent reads from it will return its default value. - mutating func clearPayload() {_uniqueStorage()._payload = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_ForeignEnumLite: @unchecked Sendable {} -extension ProtobufUnittest_V1EnumLite: @unchecked Sendable {} -extension ProtobufUnittest_V2EnumLite: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypesLite: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypesLite.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypesLite.NestedEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypesLite.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypesLite.NestedMessage2: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypesLite.OptionalGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestAllTypesLite.RepeatedGroup: @unchecked Sendable {} -extension ProtobufUnittest_ForeignMessageLite: @unchecked Sendable {} -extension ProtobufUnittest_TestPackedTypesLite: @unchecked Sendable {} -extension ProtobufUnittest_TestAllExtensionsLite: @unchecked Sendable {} -extension ProtobufUnittest_OptionalGroup_extension_lite: @unchecked Sendable {} -extension ProtobufUnittest_RepeatedGroup_extension_lite: @unchecked Sendable {} -extension ProtobufUnittest_TestPackedExtensionsLite: @unchecked Sendable {} -extension ProtobufUnittest_TestNestedExtensionLite: @unchecked Sendable {} -extension ProtobufUnittest_TestDeprecatedLite: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMergeLite: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group1: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group2: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMergeLite.OptionalGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestParsingMergeLite.RepeatedGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestEmptyMessageLite: @unchecked Sendable {} -extension ProtobufUnittest_TestEmptyMessageWithExtensionsLite: @unchecked Sendable {} -extension ProtobufUnittest_V1MessageLite: @unchecked Sendable {} -extension ProtobufUnittest_V2MessageLite: @unchecked Sendable {} -extension ProtobufUnittest_TestHugeFieldNumbersLite: @unchecked Sendable {} -extension ProtobufUnittest_TestHugeFieldNumbersLite.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufUnittest_TestHugeFieldNumbersLite.OptionalGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestOneofParsingLite: @unchecked Sendable {} -extension ProtobufUnittest_TestOneofParsingLite.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufUnittest_PackedInt32: @unchecked Sendable {} -extension ProtobufUnittest_NonPackedInt32: @unchecked Sendable {} -extension ProtobufUnittest_PackedFixed32: @unchecked Sendable {} -extension ProtobufUnittest_NonPackedFixed32: @unchecked Sendable {} -extension ProtobufUnittest_DupEnum: @unchecked Sendable {} -extension ProtobufUnittest_DupEnum.TestEnumWithDupValueLite: @unchecked Sendable {} -extension ProtobufUnittest_RecursiveMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Extension support defined in unittest_lite.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 ProtobufUnittest_TestAllExtensionsLite { - - /// Singular - var ProtobufUnittest_optionalInt32ExtensionLite: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_int32_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_int32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_int32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalInt32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_int32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_int32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalInt32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_int32_extension_lite) - } - - var ProtobufUnittest_optionalInt64ExtensionLite: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_int64_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_int64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_int64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalInt64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_int64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_int64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalInt64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_int64_extension_lite) - } - - var ProtobufUnittest_optionalUint32ExtensionLite: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint32_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_uint32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalUint32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_uint32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalUint32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint32_extension_lite) - } - - var ProtobufUnittest_optionalUint64ExtensionLite: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint64_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_uint64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalUint64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_uint64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalUint64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_uint64_extension_lite) - } - - var ProtobufUnittest_optionalSint32ExtensionLite: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint32_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_sint32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalSint32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_sint32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalSint32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint32_extension_lite) - } - - var ProtobufUnittest_optionalSint64ExtensionLite: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint64_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_sint64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalSint64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_sint64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalSint64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_sint64_extension_lite) - } - - var ProtobufUnittest_optionalFixed32ExtensionLite: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed32_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_fixed32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalFixed32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_fixed32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalFixed32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed32_extension_lite) - } - - var ProtobufUnittest_optionalFixed64ExtensionLite: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed64_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_fixed64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalFixed64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_fixed64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalFixed64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_fixed64_extension_lite) - } - - var ProtobufUnittest_optionalSfixed32ExtensionLite: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed32_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_sfixed32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalSfixed32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_sfixed32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalSfixed32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed32_extension_lite) - } - - var ProtobufUnittest_optionalSfixed64ExtensionLite: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed64_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_sfixed64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalSfixed64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_sfixed64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalSfixed64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_sfixed64_extension_lite) - } - - var ProtobufUnittest_optionalFloatExtensionLite: Float { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_float_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_float_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_float_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalFloatExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_float_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_float_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalFloatExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_float_extension_lite) - } - - var ProtobufUnittest_optionalDoubleExtensionLite: Double { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_double_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_double_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_double_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalDoubleExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_double_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_double_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalDoubleExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_double_extension_lite) - } - - var ProtobufUnittest_optionalBoolExtensionLite: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_bool_extension_lite) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_bool_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_bool_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalBoolExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_bool_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_bool_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalBoolExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_bool_extension_lite) - } - - var ProtobufUnittest_optionalStringExtensionLite: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_extension_lite) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_string_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalStringExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_string_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalStringExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_extension_lite) - } - - var ProtobufUnittest_optionalBytesExtensionLite: Data { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_bytes_extension_lite) ?? Data()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_bytes_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_bytes_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalBytesExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_bytes_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_bytes_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalBytesExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_bytes_extension_lite) - } - - var ProtobufUnittest_optionalGroupExtensionLite: ProtobufUnittest_OptionalGroup_extension_lite { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_OptionalGroup_extension_lite) ?? ProtobufUnittest_OptionalGroup_extension_lite()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_OptionalGroup_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_OptionalGroup_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalGroupExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_OptionalGroup_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_OptionalGroup_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalGroupExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_OptionalGroup_extension_lite) - } - - var ProtobufUnittest_optionalNestedMessageExtensionLite: ProtobufUnittest_TestAllTypesLite.NestedMessage { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_message_extension_lite) ?? ProtobufUnittest_TestAllTypesLite.NestedMessage()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_nested_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalNestedMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_nested_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalNestedMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_message_extension_lite) - } - - var ProtobufUnittest_optionalForeignMessageExtensionLite: ProtobufUnittest_ForeignMessageLite { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_message_extension_lite) ?? ProtobufUnittest_ForeignMessageLite()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_foreign_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalForeignMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_foreign_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalForeignMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_message_extension_lite) - } - - var ProtobufUnittest_optionalImportMessageExtensionLite: ProtobufUnittestImport_ImportMessageLite { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_message_extension_lite) ?? ProtobufUnittestImport_ImportMessageLite()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_import_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalImportMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_import_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalImportMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_message_extension_lite) - } - - var ProtobufUnittest_optionalNestedEnumExtensionLite: ProtobufUnittest_TestAllTypesLite.NestedEnum { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_enum_extension_lite) ?? .foo} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_nested_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalNestedEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_nested_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalNestedEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_nested_enum_extension_lite) - } - - var ProtobufUnittest_optionalForeignEnumExtensionLite: ProtobufUnittest_ForeignEnumLite { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_enum_extension_lite) ?? .foreignLiteFoo} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_foreign_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalForeignEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_foreign_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalForeignEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_foreign_enum_extension_lite) - } - - var ProtobufUnittest_optionalImportEnumExtensionLite: ProtobufUnittestImport_ImportEnumLite { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_enum_extension_lite) ?? .importLiteFoo} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_import_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalImportEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_import_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalImportEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_import_enum_extension_lite) - } - - var ProtobufUnittest_optionalStringPieceExtensionLite: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_piece_extension_lite) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_piece_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_string_piece_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalStringPieceExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_piece_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_string_piece_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalStringPieceExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_string_piece_extension_lite) - } - - var ProtobufUnittest_optionalCordExtensionLite: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_cord_extension_lite) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_cord_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_cord_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalCordExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_cord_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_cord_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalCordExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_cord_extension_lite) - } - - var ProtobufUnittest_optionalPublicImportMessageExtensionLite: ProtobufUnittestImport_PublicImportMessageLite { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_public_import_message_extension_lite) ?? ProtobufUnittestImport_PublicImportMessageLite()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_public_import_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_public_import_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalPublicImportMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_public_import_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_public_import_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalPublicImportMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_public_import_message_extension_lite) - } - - var ProtobufUnittest_optionalLazyMessageExtensionLite: ProtobufUnittest_TestAllTypesLite.NestedMessage { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_optional_lazy_message_extension_lite) ?? ProtobufUnittest_TestAllTypesLite.NestedMessage()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_optional_lazy_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_optional_lazy_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_optionalLazyMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_optional_lazy_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_optional_lazy_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_optionalLazyMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_optional_lazy_message_extension_lite) - } - - /// Repeated - var ProtobufUnittest_repeatedInt32ExtensionLite: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_int32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedInt32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_int32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedInt32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int32_extension_lite) - } - - var ProtobufUnittest_repeatedInt64ExtensionLite: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_int64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedInt64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_int64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedInt64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_int64_extension_lite) - } - - var ProtobufUnittest_repeatedUint32ExtensionLite: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_uint32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedUint32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_uint32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedUint32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint32_extension_lite) - } - - var ProtobufUnittest_repeatedUint64ExtensionLite: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_uint64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedUint64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_uint64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedUint64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_uint64_extension_lite) - } - - var ProtobufUnittest_repeatedSint32ExtensionLite: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_sint32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedSint32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_sint32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedSint32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint32_extension_lite) - } - - var ProtobufUnittest_repeatedSint64ExtensionLite: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_sint64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedSint64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_sint64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedSint64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sint64_extension_lite) - } - - var ProtobufUnittest_repeatedFixed32ExtensionLite: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_fixed32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedFixed32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_fixed32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedFixed32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed32_extension_lite) - } - - var ProtobufUnittest_repeatedFixed64ExtensionLite: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_fixed64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedFixed64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_fixed64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedFixed64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_fixed64_extension_lite) - } - - var ProtobufUnittest_repeatedSfixed32ExtensionLite: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_sfixed32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedSfixed32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_sfixed32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedSfixed32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed32_extension_lite) - } - - var ProtobufUnittest_repeatedSfixed64ExtensionLite: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_sfixed64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedSfixed64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_sfixed64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedSfixed64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_sfixed64_extension_lite) - } - - var ProtobufUnittest_repeatedFloatExtensionLite: [Float] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_float_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_float_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_float_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedFloatExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_float_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_float_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedFloatExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_float_extension_lite) - } - - var ProtobufUnittest_repeatedDoubleExtensionLite: [Double] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_double_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_double_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_double_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedDoubleExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_double_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_double_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedDoubleExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_double_extension_lite) - } - - var ProtobufUnittest_repeatedBoolExtensionLite: [Bool] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bool_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bool_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_bool_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedBoolExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bool_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_bool_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedBoolExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bool_extension_lite) - } - - var ProtobufUnittest_repeatedStringExtensionLite: [String] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_string_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedStringExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_string_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedStringExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_extension_lite) - } - - var ProtobufUnittest_repeatedBytesExtensionLite: [Data] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bytes_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bytes_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_bytes_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedBytesExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bytes_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_bytes_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedBytesExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_bytes_extension_lite) - } - - var ProtobufUnittest_repeatedGroupExtensionLite: [ProtobufUnittest_RepeatedGroup_extension_lite] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_RepeatedGroup_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_RepeatedGroup_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_RepeatedGroup_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedGroupExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_RepeatedGroup_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_RepeatedGroup_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedGroupExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_RepeatedGroup_extension_lite) - } - - var ProtobufUnittest_repeatedNestedMessageExtensionLite: [ProtobufUnittest_TestAllTypesLite.NestedMessage] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_message_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_nested_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedNestedMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_nested_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedNestedMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_message_extension_lite) - } - - var ProtobufUnittest_repeatedForeignMessageExtensionLite: [ProtobufUnittest_ForeignMessageLite] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_message_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_foreign_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedForeignMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_foreign_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedForeignMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_message_extension_lite) - } - - var ProtobufUnittest_repeatedImportMessageExtensionLite: [ProtobufUnittestImport_ImportMessageLite] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_message_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_import_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedImportMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_import_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedImportMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_message_extension_lite) - } - - var ProtobufUnittest_repeatedNestedEnumExtensionLite: [ProtobufUnittest_TestAllTypesLite.NestedEnum] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_enum_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_nested_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedNestedEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_nested_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedNestedEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_nested_enum_extension_lite) - } - - var ProtobufUnittest_repeatedForeignEnumExtensionLite: [ProtobufUnittest_ForeignEnumLite] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_enum_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_foreign_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedForeignEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_foreign_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedForeignEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_foreign_enum_extension_lite) - } - - var ProtobufUnittest_repeatedImportEnumExtensionLite: [ProtobufUnittestImport_ImportEnumLite] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_enum_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_import_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedImportEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_import_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedImportEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_import_enum_extension_lite) - } - - var ProtobufUnittest_repeatedStringPieceExtensionLite: [String] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_piece_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_piece_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_string_piece_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedStringPieceExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_piece_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_string_piece_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedStringPieceExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_string_piece_extension_lite) - } - - var ProtobufUnittest_repeatedCordExtensionLite: [String] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_cord_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_cord_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_cord_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedCordExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_cord_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_cord_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedCordExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_cord_extension_lite) - } - - var ProtobufUnittest_repeatedLazyMessageExtensionLite: [ProtobufUnittest_TestAllTypesLite.NestedMessage] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_repeated_lazy_message_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_repeated_lazy_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_repeated_lazy_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_repeatedLazyMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_repeated_lazy_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_repeated_lazy_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_repeatedLazyMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_repeated_lazy_message_extension_lite) - } - - /// Singular with defaults - var ProtobufUnittest_defaultInt32ExtensionLite: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_int32_extension_lite) ?? 41} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_int32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_int32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultInt32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_int32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_int32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultInt32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_int32_extension_lite) - } - - var ProtobufUnittest_defaultInt64ExtensionLite: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_int64_extension_lite) ?? 42} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_int64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_int64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultInt64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_int64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_int64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultInt64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_int64_extension_lite) - } - - var ProtobufUnittest_defaultUint32ExtensionLite: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_uint32_extension_lite) ?? 43} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_uint32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_uint32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultUint32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_uint32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_uint32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultUint32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_uint32_extension_lite) - } - - var ProtobufUnittest_defaultUint64ExtensionLite: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_uint64_extension_lite) ?? 44} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_uint64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_uint64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultUint64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_uint64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_uint64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultUint64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_uint64_extension_lite) - } - - var ProtobufUnittest_defaultSint32ExtensionLite: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_sint32_extension_lite) ?? -45} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_sint32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_sint32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultSint32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_sint32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_sint32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultSint32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_sint32_extension_lite) - } - - var ProtobufUnittest_defaultSint64ExtensionLite: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_sint64_extension_lite) ?? 46} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_sint64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_sint64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultSint64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_sint64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_sint64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultSint64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_sint64_extension_lite) - } - - var ProtobufUnittest_defaultFixed32ExtensionLite: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed32_extension_lite) ?? 47} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_fixed32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultFixed32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_fixed32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultFixed32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed32_extension_lite) - } - - var ProtobufUnittest_defaultFixed64ExtensionLite: UInt64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed64_extension_lite) ?? 48} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_fixed64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultFixed64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_fixed64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultFixed64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_fixed64_extension_lite) - } - - var ProtobufUnittest_defaultSfixed32ExtensionLite: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed32_extension_lite) ?? 49} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_sfixed32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultSfixed32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_sfixed32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultSfixed32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed32_extension_lite) - } - - var ProtobufUnittest_defaultSfixed64ExtensionLite: Int64 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed64_extension_lite) ?? -50} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_sfixed64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultSfixed64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_sfixed64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultSfixed64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_sfixed64_extension_lite) - } - - var ProtobufUnittest_defaultFloatExtensionLite: Float { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_float_extension_lite) ?? 51.5} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_float_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_float_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultFloatExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_float_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_float_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultFloatExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_float_extension_lite) - } - - var ProtobufUnittest_defaultDoubleExtensionLite: Double { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_double_extension_lite) ?? 52000} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_double_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_double_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultDoubleExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_double_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_double_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultDoubleExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_double_extension_lite) - } - - var ProtobufUnittest_defaultBoolExtensionLite: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_bool_extension_lite) ?? true} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_bool_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_bool_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultBoolExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_bool_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_bool_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultBoolExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_bool_extension_lite) - } - - var ProtobufUnittest_defaultStringExtensionLite: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_string_extension_lite) ?? "hello"} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_string_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_string_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultStringExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_string_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_string_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultStringExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_string_extension_lite) - } - - var ProtobufUnittest_defaultBytesExtensionLite: Data { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_bytes_extension_lite) ?? Data([119, 111, 114, 108, 100])} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_bytes_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_bytes_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultBytesExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_bytes_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_bytes_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultBytesExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_bytes_extension_lite) - } - - var ProtobufUnittest_defaultNestedEnumExtensionLite: ProtobufUnittest_TestAllTypesLite.NestedEnum { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_nested_enum_extension_lite) ?? .bar} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_nested_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_nested_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultNestedEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_nested_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_nested_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultNestedEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_nested_enum_extension_lite) - } - - var ProtobufUnittest_defaultForeignEnumExtensionLite: ProtobufUnittest_ForeignEnumLite { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_foreign_enum_extension_lite) ?? .foreignLiteBar} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_foreign_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_foreign_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultForeignEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_foreign_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_foreign_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultForeignEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_foreign_enum_extension_lite) - } - - var ProtobufUnittest_defaultImportEnumExtensionLite: ProtobufUnittestImport_ImportEnumLite { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_import_enum_extension_lite) ?? .importLiteBar} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_import_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_import_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultImportEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_import_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_import_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultImportEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_import_enum_extension_lite) - } - - var ProtobufUnittest_defaultStringPieceExtensionLite: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_string_piece_extension_lite) ?? "abc"} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_string_piece_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_string_piece_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultStringPieceExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_string_piece_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_string_piece_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultStringPieceExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_string_piece_extension_lite) - } - - var ProtobufUnittest_defaultCordExtensionLite: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_default_cord_extension_lite) ?? "123"} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_default_cord_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_default_cord_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_defaultCordExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_default_cord_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_default_cord_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_defaultCordExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_default_cord_extension_lite) - } - - /// For oneof test - var ProtobufUnittest_oneofUint32ExtensionLite: UInt32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_oneof_uint32_extension_lite) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_oneof_uint32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_oneof_uint32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_oneofUint32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_oneof_uint32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_oneof_uint32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_oneofUint32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_oneof_uint32_extension_lite) - } - - var ProtobufUnittest_oneofNestedMessageExtensionLite: ProtobufUnittest_TestAllTypesLite.NestedMessage { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_oneof_nested_message_extension_lite) ?? ProtobufUnittest_TestAllTypesLite.NestedMessage()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_oneof_nested_message_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_oneof_nested_message_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_oneofNestedMessageExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_oneof_nested_message_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_oneof_nested_message_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_oneofNestedMessageExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_oneof_nested_message_extension_lite) - } - - var ProtobufUnittest_oneofStringExtensionLite: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_oneof_string_extension_lite) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_oneof_string_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_oneof_string_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_oneofStringExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_oneof_string_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_oneof_string_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_oneofStringExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_oneof_string_extension_lite) - } - - var ProtobufUnittest_oneofBytesExtensionLite: Data { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_oneof_bytes_extension_lite) ?? Data()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_oneof_bytes_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_oneof_bytes_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_oneofBytesExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_oneof_bytes_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_oneof_bytes_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_oneofBytesExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_oneof_bytes_extension_lite) - } - - var ProtobufUnittest_TestNestedExtensionLite_nestedExtension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_TestNestedExtensionLite.Extensions.nested_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_TestNestedExtensionLite.Extensions.nested_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestNestedExtensionLite.Extensions.nested_extension` - /// has been explicitly set. - var hasProtobufUnittest_TestNestedExtensionLite_nestedExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestNestedExtensionLite.Extensions.nested_extension) - } - /// Clears the value of extension `ProtobufUnittest_TestNestedExtensionLite.Extensions.nested_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestNestedExtensionLite_nestedExtension() { - clearExtensionValue(ext: ProtobufUnittest_TestNestedExtensionLite.Extensions.nested_extension) - } -} - -extension ProtobufUnittest_TestHugeFieldNumbersLite { - - var ProtobufUnittest_testAllTypesLite: ProtobufUnittest_TestAllTypesLite { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_test_all_types_lite) ?? ProtobufUnittest_TestAllTypesLite()} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_test_all_types_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_test_all_types_lite` - /// has been explicitly set. - var hasProtobufUnittest_testAllTypesLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_test_all_types_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_test_all_types_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_testAllTypesLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_test_all_types_lite) - } -} - -extension ProtobufUnittest_TestPackedExtensionsLite { - - var ProtobufUnittest_packedInt32ExtensionLite: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_int32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_int32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_int32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedInt32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_int32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_int32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedInt32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_int32_extension_lite) - } - - var ProtobufUnittest_packedInt64ExtensionLite: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_int64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_int64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_int64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedInt64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_int64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_int64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedInt64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_int64_extension_lite) - } - - var ProtobufUnittest_packedUint32ExtensionLite: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_uint32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedUint32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_uint32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedUint32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint32_extension_lite) - } - - var ProtobufUnittest_packedUint64ExtensionLite: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_uint64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedUint64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_uint64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedUint64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_uint64_extension_lite) - } - - var ProtobufUnittest_packedSint32ExtensionLite: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_sint32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedSint32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_sint32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedSint32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint32_extension_lite) - } - - var ProtobufUnittest_packedSint64ExtensionLite: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_sint64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedSint64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_sint64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedSint64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_sint64_extension_lite) - } - - var ProtobufUnittest_packedFixed32ExtensionLite: [UInt32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_fixed32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedFixed32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_fixed32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedFixed32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed32_extension_lite) - } - - var ProtobufUnittest_packedFixed64ExtensionLite: [UInt64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_fixed64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedFixed64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_fixed64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedFixed64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_fixed64_extension_lite) - } - - var ProtobufUnittest_packedSfixed32ExtensionLite: [Int32] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed32_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed32_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_sfixed32_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedSfixed32ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed32_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_sfixed32_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedSfixed32ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed32_extension_lite) - } - - var ProtobufUnittest_packedSfixed64ExtensionLite: [Int64] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed64_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed64_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_sfixed64_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedSfixed64ExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed64_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_sfixed64_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedSfixed64ExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_sfixed64_extension_lite) - } - - var ProtobufUnittest_packedFloatExtensionLite: [Float] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_float_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_float_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_float_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedFloatExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_float_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_float_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedFloatExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_float_extension_lite) - } - - var ProtobufUnittest_packedDoubleExtensionLite: [Double] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_double_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_double_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_double_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedDoubleExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_double_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_double_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedDoubleExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_double_extension_lite) - } - - var ProtobufUnittest_packedBoolExtensionLite: [Bool] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_bool_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_bool_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_bool_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedBoolExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_bool_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_bool_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedBoolExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_bool_extension_lite) - } - - var ProtobufUnittest_packedEnumExtensionLite: [ProtobufUnittest_ForeignEnumLite] { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_packed_enum_extension_lite) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_packed_enum_extension_lite, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Extensions_packed_enum_extension_lite` - /// has been explicitly set. - var hasProtobufUnittest_packedEnumExtensionLite: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_packed_enum_extension_lite) - } - /// Clears the value of extension `ProtobufUnittest_Extensions_packed_enum_extension_lite`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_packedEnumExtensionLite() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_packed_enum_extension_lite) - } -} - -extension ProtobufUnittest_TestParsingMergeLite { - - var ProtobufUnittest_TestParsingMergeLite_optionalExt: ProtobufUnittest_TestAllTypesLite { - get {return getExtensionValue(ext: ProtobufUnittest_TestParsingMergeLite.Extensions.optional_ext) ?? ProtobufUnittest_TestAllTypesLite()} - set {setExtensionValue(ext: ProtobufUnittest_TestParsingMergeLite.Extensions.optional_ext, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestParsingMergeLite.Extensions.optional_ext` - /// has been explicitly set. - var hasProtobufUnittest_TestParsingMergeLite_optionalExt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestParsingMergeLite.Extensions.optional_ext) - } - /// Clears the value of extension `ProtobufUnittest_TestParsingMergeLite.Extensions.optional_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestParsingMergeLite_optionalExt() { - clearExtensionValue(ext: ProtobufUnittest_TestParsingMergeLite.Extensions.optional_ext) - } - - var ProtobufUnittest_TestParsingMergeLite_repeatedExt: [ProtobufUnittest_TestAllTypesLite] { - get {return getExtensionValue(ext: ProtobufUnittest_TestParsingMergeLite.Extensions.repeated_ext) ?? []} - set {setExtensionValue(ext: ProtobufUnittest_TestParsingMergeLite.Extensions.repeated_ext, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_TestParsingMergeLite.Extensions.repeated_ext` - /// has been explicitly set. - var hasProtobufUnittest_TestParsingMergeLite_repeatedExt: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestParsingMergeLite.Extensions.repeated_ext) - } - /// Clears the value of extension `ProtobufUnittest_TestParsingMergeLite.Extensions.repeated_ext`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestParsingMergeLite_repeatedExt() { - clearExtensionValue(ext: ProtobufUnittest_TestParsingMergeLite.Extensions.repeated_ext) - } - -} - -// MARK: - File's ExtensionMap: ProtobufUnittest_UnittestLite_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 ProtobufUnittest_UnittestLite_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_Extensions_optional_int32_extension_lite, - ProtobufUnittest_Extensions_optional_int64_extension_lite, - ProtobufUnittest_Extensions_optional_uint32_extension_lite, - ProtobufUnittest_Extensions_optional_uint64_extension_lite, - ProtobufUnittest_Extensions_optional_sint32_extension_lite, - ProtobufUnittest_Extensions_optional_sint64_extension_lite, - ProtobufUnittest_Extensions_optional_fixed32_extension_lite, - ProtobufUnittest_Extensions_optional_fixed64_extension_lite, - ProtobufUnittest_Extensions_optional_sfixed32_extension_lite, - ProtobufUnittest_Extensions_optional_sfixed64_extension_lite, - ProtobufUnittest_Extensions_optional_float_extension_lite, - ProtobufUnittest_Extensions_optional_double_extension_lite, - ProtobufUnittest_Extensions_optional_bool_extension_lite, - ProtobufUnittest_Extensions_optional_string_extension_lite, - ProtobufUnittest_Extensions_optional_bytes_extension_lite, - ProtobufUnittest_Extensions_OptionalGroup_extension_lite, - ProtobufUnittest_Extensions_optional_nested_message_extension_lite, - ProtobufUnittest_Extensions_optional_foreign_message_extension_lite, - ProtobufUnittest_Extensions_optional_import_message_extension_lite, - ProtobufUnittest_Extensions_optional_nested_enum_extension_lite, - ProtobufUnittest_Extensions_optional_foreign_enum_extension_lite, - ProtobufUnittest_Extensions_optional_import_enum_extension_lite, - ProtobufUnittest_Extensions_optional_string_piece_extension_lite, - ProtobufUnittest_Extensions_optional_cord_extension_lite, - ProtobufUnittest_Extensions_optional_public_import_message_extension_lite, - ProtobufUnittest_Extensions_optional_lazy_message_extension_lite, - ProtobufUnittest_Extensions_repeated_int32_extension_lite, - ProtobufUnittest_Extensions_repeated_int64_extension_lite, - ProtobufUnittest_Extensions_repeated_uint32_extension_lite, - ProtobufUnittest_Extensions_repeated_uint64_extension_lite, - ProtobufUnittest_Extensions_repeated_sint32_extension_lite, - ProtobufUnittest_Extensions_repeated_sint64_extension_lite, - ProtobufUnittest_Extensions_repeated_fixed32_extension_lite, - ProtobufUnittest_Extensions_repeated_fixed64_extension_lite, - ProtobufUnittest_Extensions_repeated_sfixed32_extension_lite, - ProtobufUnittest_Extensions_repeated_sfixed64_extension_lite, - ProtobufUnittest_Extensions_repeated_float_extension_lite, - ProtobufUnittest_Extensions_repeated_double_extension_lite, - ProtobufUnittest_Extensions_repeated_bool_extension_lite, - ProtobufUnittest_Extensions_repeated_string_extension_lite, - ProtobufUnittest_Extensions_repeated_bytes_extension_lite, - ProtobufUnittest_Extensions_RepeatedGroup_extension_lite, - ProtobufUnittest_Extensions_repeated_nested_message_extension_lite, - ProtobufUnittest_Extensions_repeated_foreign_message_extension_lite, - ProtobufUnittest_Extensions_repeated_import_message_extension_lite, - ProtobufUnittest_Extensions_repeated_nested_enum_extension_lite, - ProtobufUnittest_Extensions_repeated_foreign_enum_extension_lite, - ProtobufUnittest_Extensions_repeated_import_enum_extension_lite, - ProtobufUnittest_Extensions_repeated_string_piece_extension_lite, - ProtobufUnittest_Extensions_repeated_cord_extension_lite, - ProtobufUnittest_Extensions_repeated_lazy_message_extension_lite, - ProtobufUnittest_Extensions_default_int32_extension_lite, - ProtobufUnittest_Extensions_default_int64_extension_lite, - ProtobufUnittest_Extensions_default_uint32_extension_lite, - ProtobufUnittest_Extensions_default_uint64_extension_lite, - ProtobufUnittest_Extensions_default_sint32_extension_lite, - ProtobufUnittest_Extensions_default_sint64_extension_lite, - ProtobufUnittest_Extensions_default_fixed32_extension_lite, - ProtobufUnittest_Extensions_default_fixed64_extension_lite, - ProtobufUnittest_Extensions_default_sfixed32_extension_lite, - ProtobufUnittest_Extensions_default_sfixed64_extension_lite, - ProtobufUnittest_Extensions_default_float_extension_lite, - ProtobufUnittest_Extensions_default_double_extension_lite, - ProtobufUnittest_Extensions_default_bool_extension_lite, - ProtobufUnittest_Extensions_default_string_extension_lite, - ProtobufUnittest_Extensions_default_bytes_extension_lite, - ProtobufUnittest_Extensions_default_nested_enum_extension_lite, - ProtobufUnittest_Extensions_default_foreign_enum_extension_lite, - ProtobufUnittest_Extensions_default_import_enum_extension_lite, - ProtobufUnittest_Extensions_default_string_piece_extension_lite, - ProtobufUnittest_Extensions_default_cord_extension_lite, - ProtobufUnittest_Extensions_oneof_uint32_extension_lite, - ProtobufUnittest_Extensions_oneof_nested_message_extension_lite, - ProtobufUnittest_Extensions_oneof_string_extension_lite, - ProtobufUnittest_Extensions_oneof_bytes_extension_lite, - ProtobufUnittest_Extensions_packed_int32_extension_lite, - ProtobufUnittest_Extensions_packed_int64_extension_lite, - ProtobufUnittest_Extensions_packed_uint32_extension_lite, - ProtobufUnittest_Extensions_packed_uint64_extension_lite, - ProtobufUnittest_Extensions_packed_sint32_extension_lite, - ProtobufUnittest_Extensions_packed_sint64_extension_lite, - ProtobufUnittest_Extensions_packed_fixed32_extension_lite, - ProtobufUnittest_Extensions_packed_fixed64_extension_lite, - ProtobufUnittest_Extensions_packed_sfixed32_extension_lite, - ProtobufUnittest_Extensions_packed_sfixed64_extension_lite, - ProtobufUnittest_Extensions_packed_float_extension_lite, - ProtobufUnittest_Extensions_packed_double_extension_lite, - ProtobufUnittest_Extensions_packed_bool_extension_lite, - ProtobufUnittest_Extensions_packed_enum_extension_lite, - ProtobufUnittest_Extensions_test_all_types_lite, - ProtobufUnittest_TestNestedExtensionLite.Extensions.nested_extension, - ProtobufUnittest_TestParsingMergeLite.Extensions.optional_ext, - ProtobufUnittest_TestParsingMergeLite.Extensions.repeated_ext -] - -// 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. - -/// Singular -let ProtobufUnittest_Extensions_optional_int32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 1, - fieldName: "protobuf_unittest.optional_int32_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_int64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 2, - fieldName: "protobuf_unittest.optional_int64_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_uint32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 3, - fieldName: "protobuf_unittest.optional_uint32_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_uint64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 4, - fieldName: "protobuf_unittest.optional_uint64_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_sint32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 5, - fieldName: "protobuf_unittest.optional_sint32_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_sint64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 6, - fieldName: "protobuf_unittest.optional_sint64_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_fixed32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 7, - fieldName: "protobuf_unittest.optional_fixed32_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_fixed64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 8, - fieldName: "protobuf_unittest.optional_fixed64_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_sfixed32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 9, - fieldName: "protobuf_unittest.optional_sfixed32_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_sfixed64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 10, - fieldName: "protobuf_unittest.optional_sfixed64_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_float_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 11, - fieldName: "protobuf_unittest.optional_float_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_double_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 12, - fieldName: "protobuf_unittest.optional_double_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_bool_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 13, - fieldName: "protobuf_unittest.optional_bool_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_string_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 14, - fieldName: "protobuf_unittest.optional_string_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_bytes_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 15, - fieldName: "protobuf_unittest.optional_bytes_extension_lite" -) - -let ProtobufUnittest_Extensions_OptionalGroup_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 16, - fieldName: "protobuf_unittest.optionalgroup_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_nested_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 18, - fieldName: "protobuf_unittest.optional_nested_message_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_foreign_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 19, - fieldName: "protobuf_unittest.optional_foreign_message_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_import_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 20, - fieldName: "protobuf_unittest.optional_import_message_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_nested_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 21, - fieldName: "protobuf_unittest.optional_nested_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_foreign_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 22, - fieldName: "protobuf_unittest.optional_foreign_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_import_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 23, - fieldName: "protobuf_unittest.optional_import_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_string_piece_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 24, - fieldName: "protobuf_unittest.optional_string_piece_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_cord_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 25, - fieldName: "protobuf_unittest.optional_cord_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_public_import_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 26, - fieldName: "protobuf_unittest.optional_public_import_message_extension_lite" -) - -let ProtobufUnittest_Extensions_optional_lazy_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 27, - fieldName: "protobuf_unittest.optional_lazy_message_extension_lite" -) - -/// Repeated -let ProtobufUnittest_Extensions_repeated_int32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 31, - fieldName: "protobuf_unittest.repeated_int32_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_int64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 32, - fieldName: "protobuf_unittest.repeated_int64_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_uint32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 33, - fieldName: "protobuf_unittest.repeated_uint32_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_uint64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 34, - fieldName: "protobuf_unittest.repeated_uint64_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_sint32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 35, - fieldName: "protobuf_unittest.repeated_sint32_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_sint64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 36, - fieldName: "protobuf_unittest.repeated_sint64_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_fixed32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 37, - fieldName: "protobuf_unittest.repeated_fixed32_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_fixed64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 38, - fieldName: "protobuf_unittest.repeated_fixed64_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_sfixed32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 39, - fieldName: "protobuf_unittest.repeated_sfixed32_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_sfixed64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 40, - fieldName: "protobuf_unittest.repeated_sfixed64_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_float_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 41, - fieldName: "protobuf_unittest.repeated_float_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_double_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 42, - fieldName: "protobuf_unittest.repeated_double_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_bool_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 43, - fieldName: "protobuf_unittest.repeated_bool_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_string_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 44, - fieldName: "protobuf_unittest.repeated_string_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_bytes_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 45, - fieldName: "protobuf_unittest.repeated_bytes_extension_lite" -) - -let ProtobufUnittest_Extensions_RepeatedGroup_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 46, - fieldName: "protobuf_unittest.repeatedgroup_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_nested_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 48, - fieldName: "protobuf_unittest.repeated_nested_message_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_foreign_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 49, - fieldName: "protobuf_unittest.repeated_foreign_message_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_import_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 50, - fieldName: "protobuf_unittest.repeated_import_message_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_nested_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 51, - fieldName: "protobuf_unittest.repeated_nested_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_foreign_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 52, - fieldName: "protobuf_unittest.repeated_foreign_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_import_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 53, - fieldName: "protobuf_unittest.repeated_import_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_string_piece_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 54, - fieldName: "protobuf_unittest.repeated_string_piece_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_cord_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 55, - fieldName: "protobuf_unittest.repeated_cord_extension_lite" -) - -let ProtobufUnittest_Extensions_repeated_lazy_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 57, - fieldName: "protobuf_unittest.repeated_lazy_message_extension_lite" -) - -/// Singular with defaults -let ProtobufUnittest_Extensions_default_int32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 61, - fieldName: "protobuf_unittest.default_int32_extension_lite" -) - -let ProtobufUnittest_Extensions_default_int64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 62, - fieldName: "protobuf_unittest.default_int64_extension_lite" -) - -let ProtobufUnittest_Extensions_default_uint32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 63, - fieldName: "protobuf_unittest.default_uint32_extension_lite" -) - -let ProtobufUnittest_Extensions_default_uint64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 64, - fieldName: "protobuf_unittest.default_uint64_extension_lite" -) - -let ProtobufUnittest_Extensions_default_sint32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 65, - fieldName: "protobuf_unittest.default_sint32_extension_lite" -) - -let ProtobufUnittest_Extensions_default_sint64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 66, - fieldName: "protobuf_unittest.default_sint64_extension_lite" -) - -let ProtobufUnittest_Extensions_default_fixed32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 67, - fieldName: "protobuf_unittest.default_fixed32_extension_lite" -) - -let ProtobufUnittest_Extensions_default_fixed64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 68, - fieldName: "protobuf_unittest.default_fixed64_extension_lite" -) - -let ProtobufUnittest_Extensions_default_sfixed32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 69, - fieldName: "protobuf_unittest.default_sfixed32_extension_lite" -) - -let ProtobufUnittest_Extensions_default_sfixed64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 70, - fieldName: "protobuf_unittest.default_sfixed64_extension_lite" -) - -let ProtobufUnittest_Extensions_default_float_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 71, - fieldName: "protobuf_unittest.default_float_extension_lite" -) - -let ProtobufUnittest_Extensions_default_double_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 72, - fieldName: "protobuf_unittest.default_double_extension_lite" -) - -let ProtobufUnittest_Extensions_default_bool_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 73, - fieldName: "protobuf_unittest.default_bool_extension_lite" -) - -let ProtobufUnittest_Extensions_default_string_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 74, - fieldName: "protobuf_unittest.default_string_extension_lite" -) - -let ProtobufUnittest_Extensions_default_bytes_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 75, - fieldName: "protobuf_unittest.default_bytes_extension_lite" -) - -let ProtobufUnittest_Extensions_default_nested_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 81, - fieldName: "protobuf_unittest.default_nested_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_default_foreign_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 82, - fieldName: "protobuf_unittest.default_foreign_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_default_import_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 83, - fieldName: "protobuf_unittest.default_import_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_default_string_piece_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 84, - fieldName: "protobuf_unittest.default_string_piece_extension_lite" -) - -let ProtobufUnittest_Extensions_default_cord_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 85, - fieldName: "protobuf_unittest.default_cord_extension_lite" -) - -/// For oneof test -let ProtobufUnittest_Extensions_oneof_uint32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 111, - fieldName: "protobuf_unittest.oneof_uint32_extension_lite" -) - -let ProtobufUnittest_Extensions_oneof_nested_message_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 112, - fieldName: "protobuf_unittest.oneof_nested_message_extension_lite" -) - -let ProtobufUnittest_Extensions_oneof_string_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 113, - fieldName: "protobuf_unittest.oneof_string_extension_lite" -) - -let ProtobufUnittest_Extensions_oneof_bytes_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 114, - fieldName: "protobuf_unittest.oneof_bytes_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_int32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 90, - fieldName: "protobuf_unittest.packed_int32_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_int64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 91, - fieldName: "protobuf_unittest.packed_int64_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_uint32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 92, - fieldName: "protobuf_unittest.packed_uint32_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_uint64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 93, - fieldName: "protobuf_unittest.packed_uint64_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_sint32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 94, - fieldName: "protobuf_unittest.packed_sint32_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_sint64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 95, - fieldName: "protobuf_unittest.packed_sint64_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_fixed32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 96, - fieldName: "protobuf_unittest.packed_fixed32_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_fixed64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 97, - fieldName: "protobuf_unittest.packed_fixed64_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_sfixed32_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 98, - fieldName: "protobuf_unittest.packed_sfixed32_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_sfixed64_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 99, - fieldName: "protobuf_unittest.packed_sfixed64_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_float_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 100, - fieldName: "protobuf_unittest.packed_float_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_double_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 101, - fieldName: "protobuf_unittest.packed_double_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_bool_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 102, - fieldName: "protobuf_unittest.packed_bool_extension_lite" -) - -let ProtobufUnittest_Extensions_packed_enum_extension_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestPackedExtensionsLite>( - _protobuf_fieldNumber: 103, - fieldName: "protobuf_unittest.packed_enum_extension_lite" -) - -let ProtobufUnittest_Extensions_test_all_types_lite = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestHugeFieldNumbersLite>( - _protobuf_fieldNumber: 536860000, - fieldName: "protobuf_unittest.test_all_types_lite" -) - -extension ProtobufUnittest_TestNestedExtensionLite { - enum Extensions { - static let nested_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestAllExtensionsLite>( - _protobuf_fieldNumber: 12345, - fieldName: "protobuf_unittest.TestNestedExtensionLite.nested_extension" - ) - } -} - -extension ProtobufUnittest_TestParsingMergeLite { - enum Extensions { - static let optional_ext = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestParsingMergeLite>( - _protobuf_fieldNumber: 1000, - fieldName: "protobuf_unittest.TestParsingMergeLite.optional_ext" - ) - - static let repeated_ext = SwiftProtobuf.MessageExtension, ProtobufUnittest_TestParsingMergeLite>( - _protobuf_fieldNumber: 1001, - fieldName: "protobuf_unittest.TestParsingMergeLite.repeated_ext" - ) - } -} - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest" - -extension ProtobufUnittest_ForeignEnumLite: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 4: .same(proto: "FOREIGN_LITE_FOO"), - 5: .same(proto: "FOREIGN_LITE_BAR"), - 6: .same(proto: "FOREIGN_LITE_BAZ"), - ] -} - -extension ProtobufUnittest_V1EnumLite: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "V1_FIRST"), - ] -} - -extension ProtobufUnittest_V2EnumLite: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "V2_FIRST"), - 2: .same(proto: "V2_SECOND"), - ] -} - -extension ProtobufUnittest_TestAllTypesLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestAllTypesLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 16: .unique(proto: "OptionalGroup", json: "optionalgroup"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "optional_foreign_message"), - 20: .standard(proto: "optional_import_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "optional_foreign_enum"), - 23: .standard(proto: "optional_import_enum"), - 24: .standard(proto: "optional_string_piece"), - 25: .standard(proto: "optional_cord"), - 26: .standard(proto: "optional_public_import_message"), - 27: .standard(proto: "optional_lazy_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 46: .unique(proto: "RepeatedGroup", json: "repeatedgroup"), - 48: .standard(proto: "repeated_nested_message"), - 49: .standard(proto: "repeated_foreign_message"), - 50: .standard(proto: "repeated_import_message"), - 51: .standard(proto: "repeated_nested_enum"), - 52: .standard(proto: "repeated_foreign_enum"), - 53: .standard(proto: "repeated_import_enum"), - 54: .standard(proto: "repeated_string_piece"), - 55: .standard(proto: "repeated_cord"), - 57: .standard(proto: "repeated_lazy_message"), - 61: .standard(proto: "default_int32"), - 62: .standard(proto: "default_int64"), - 63: .standard(proto: "default_uint32"), - 64: .standard(proto: "default_uint64"), - 65: .standard(proto: "default_sint32"), - 66: .standard(proto: "default_sint64"), - 67: .standard(proto: "default_fixed32"), - 68: .standard(proto: "default_fixed64"), - 69: .standard(proto: "default_sfixed32"), - 70: .standard(proto: "default_sfixed64"), - 71: .standard(proto: "default_float"), - 72: .standard(proto: "default_double"), - 73: .standard(proto: "default_bool"), - 74: .standard(proto: "default_string"), - 75: .standard(proto: "default_bytes"), - 81: .standard(proto: "default_nested_enum"), - 82: .standard(proto: "default_foreign_enum"), - 83: .standard(proto: "default_import_enum"), - 84: .standard(proto: "default_string_piece"), - 85: .standard(proto: "default_cord"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - 115: .standard(proto: "oneof_lazy_nested_message"), - 117: .standard(proto: "oneof_nested_message2"), - 116: .standard(proto: "deceptively_named_list"), - ] - - fileprivate class _StorageClass { - var _optionalInt32: Int32? = nil - var _optionalInt64: Int64? = nil - var _optionalUint32: UInt32? = nil - var _optionalUint64: UInt64? = nil - var _optionalSint32: Int32? = nil - var _optionalSint64: Int64? = nil - var _optionalFixed32: UInt32? = nil - var _optionalFixed64: UInt64? = nil - var _optionalSfixed32: Int32? = nil - var _optionalSfixed64: Int64? = nil - var _optionalFloat: Float? = nil - var _optionalDouble: Double? = nil - var _optionalBool: Bool? = nil - var _optionalString: String? = nil - var _optionalBytes: Data? = nil - var _optionalGroup: ProtobufUnittest_TestAllTypesLite.OptionalGroup? = nil - var _optionalNestedMessage: ProtobufUnittest_TestAllTypesLite.NestedMessage? = nil - var _optionalForeignMessage: ProtobufUnittest_ForeignMessageLite? = nil - var _optionalImportMessage: ProtobufUnittestImport_ImportMessageLite? = nil - var _optionalNestedEnum: ProtobufUnittest_TestAllTypesLite.NestedEnum? = nil - var _optionalForeignEnum: ProtobufUnittest_ForeignEnumLite? = nil - var _optionalImportEnum: ProtobufUnittestImport_ImportEnumLite? = nil - var _optionalStringPiece: String? = nil - var _optionalCord: String? = nil - var _optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessageLite? = nil - var _optionalLazyMessage: ProtobufUnittest_TestAllTypesLite.NestedMessage? = nil - var _repeatedInt32: [Int32] = [] - var _repeatedInt64: [Int64] = [] - var _repeatedUint32: [UInt32] = [] - var _repeatedUint64: [UInt64] = [] - var _repeatedSint32: [Int32] = [] - var _repeatedSint64: [Int64] = [] - var _repeatedFixed32: [UInt32] = [] - var _repeatedFixed64: [UInt64] = [] - var _repeatedSfixed32: [Int32] = [] - var _repeatedSfixed64: [Int64] = [] - var _repeatedFloat: [Float] = [] - var _repeatedDouble: [Double] = [] - var _repeatedBool: [Bool] = [] - var _repeatedString: [String] = [] - var _repeatedBytes: [Data] = [] - var _repeatedGroup: [ProtobufUnittest_TestAllTypesLite.RepeatedGroup] = [] - var _repeatedNestedMessage: [ProtobufUnittest_TestAllTypesLite.NestedMessage] = [] - var _repeatedForeignMessage: [ProtobufUnittest_ForeignMessageLite] = [] - var _repeatedImportMessage: [ProtobufUnittestImport_ImportMessageLite] = [] - var _repeatedNestedEnum: [ProtobufUnittest_TestAllTypesLite.NestedEnum] = [] - var _repeatedForeignEnum: [ProtobufUnittest_ForeignEnumLite] = [] - var _repeatedImportEnum: [ProtobufUnittestImport_ImportEnumLite] = [] - var _repeatedStringPiece: [String] = [] - var _repeatedCord: [String] = [] - var _repeatedLazyMessage: [ProtobufUnittest_TestAllTypesLite.NestedMessage] = [] - var _defaultInt32: Int32? = nil - var _defaultInt64: Int64? = nil - var _defaultUint32: UInt32? = nil - var _defaultUint64: UInt64? = nil - var _defaultSint32: Int32? = nil - var _defaultSint64: Int64? = nil - var _defaultFixed32: UInt32? = nil - var _defaultFixed64: UInt64? = nil - var _defaultSfixed32: Int32? = nil - var _defaultSfixed64: Int64? = nil - var _defaultFloat: Float? = nil - var _defaultDouble: Double? = nil - var _defaultBool: Bool? = nil - var _defaultString: String? = nil - var _defaultBytes: Data? = nil - var _defaultNestedEnum: ProtobufUnittest_TestAllTypesLite.NestedEnum? = nil - var _defaultForeignEnum: ProtobufUnittest_ForeignEnumLite? = nil - var _defaultImportEnum: ProtobufUnittestImport_ImportEnumLite? = nil - var _defaultStringPiece: String? = nil - var _defaultCord: String? = nil - var _oneofField: ProtobufUnittest_TestAllTypesLite.OneOf_OneofField? - var _deceptivelyNamedList: Int32? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _optionalInt32 = source._optionalInt32 - _optionalInt64 = source._optionalInt64 - _optionalUint32 = source._optionalUint32 - _optionalUint64 = source._optionalUint64 - _optionalSint32 = source._optionalSint32 - _optionalSint64 = source._optionalSint64 - _optionalFixed32 = source._optionalFixed32 - _optionalFixed64 = source._optionalFixed64 - _optionalSfixed32 = source._optionalSfixed32 - _optionalSfixed64 = source._optionalSfixed64 - _optionalFloat = source._optionalFloat - _optionalDouble = source._optionalDouble - _optionalBool = source._optionalBool - _optionalString = source._optionalString - _optionalBytes = source._optionalBytes - _optionalGroup = source._optionalGroup - _optionalNestedMessage = source._optionalNestedMessage - _optionalForeignMessage = source._optionalForeignMessage - _optionalImportMessage = source._optionalImportMessage - _optionalNestedEnum = source._optionalNestedEnum - _optionalForeignEnum = source._optionalForeignEnum - _optionalImportEnum = source._optionalImportEnum - _optionalStringPiece = source._optionalStringPiece - _optionalCord = source._optionalCord - _optionalPublicImportMessage = source._optionalPublicImportMessage - _optionalLazyMessage = source._optionalLazyMessage - _repeatedInt32 = source._repeatedInt32 - _repeatedInt64 = source._repeatedInt64 - _repeatedUint32 = source._repeatedUint32 - _repeatedUint64 = source._repeatedUint64 - _repeatedSint32 = source._repeatedSint32 - _repeatedSint64 = source._repeatedSint64 - _repeatedFixed32 = source._repeatedFixed32 - _repeatedFixed64 = source._repeatedFixed64 - _repeatedSfixed32 = source._repeatedSfixed32 - _repeatedSfixed64 = source._repeatedSfixed64 - _repeatedFloat = source._repeatedFloat - _repeatedDouble = source._repeatedDouble - _repeatedBool = source._repeatedBool - _repeatedString = source._repeatedString - _repeatedBytes = source._repeatedBytes - _repeatedGroup = source._repeatedGroup - _repeatedNestedMessage = source._repeatedNestedMessage - _repeatedForeignMessage = source._repeatedForeignMessage - _repeatedImportMessage = source._repeatedImportMessage - _repeatedNestedEnum = source._repeatedNestedEnum - _repeatedForeignEnum = source._repeatedForeignEnum - _repeatedImportEnum = source._repeatedImportEnum - _repeatedStringPiece = source._repeatedStringPiece - _repeatedCord = source._repeatedCord - _repeatedLazyMessage = source._repeatedLazyMessage - _defaultInt32 = source._defaultInt32 - _defaultInt64 = source._defaultInt64 - _defaultUint32 = source._defaultUint32 - _defaultUint64 = source._defaultUint64 - _defaultSint32 = source._defaultSint32 - _defaultSint64 = source._defaultSint64 - _defaultFixed32 = source._defaultFixed32 - _defaultFixed64 = source._defaultFixed64 - _defaultSfixed32 = source._defaultSfixed32 - _defaultSfixed64 = source._defaultSfixed64 - _defaultFloat = source._defaultFloat - _defaultDouble = source._defaultDouble - _defaultBool = source._defaultBool - _defaultString = source._defaultString - _defaultBytes = source._defaultBytes - _defaultNestedEnum = source._defaultNestedEnum - _defaultForeignEnum = source._defaultForeignEnum - _defaultImportEnum = source._defaultImportEnum - _defaultStringPiece = source._defaultStringPiece - _defaultCord = source._defaultCord - _oneofField = source._oneofField - _deceptivelyNamedList = source._deceptivelyNamedList - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._optionalInt32) }() - case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() - case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() - case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() - case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() - case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() - case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() - case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() - case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() - case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() - case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() - case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() - case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() - case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() - case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() - case 16: try { try decoder.decodeSingularGroupField(value: &_storage._optionalGroup) }() - case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() - case 19: try { try decoder.decodeSingularMessageField(value: &_storage._optionalForeignMessage) }() - case 20: try { try decoder.decodeSingularMessageField(value: &_storage._optionalImportMessage) }() - case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() - case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() - case 23: try { try decoder.decodeSingularEnumField(value: &_storage._optionalImportEnum) }() - case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() - case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() - case 26: try { try decoder.decodeSingularMessageField(value: &_storage._optionalPublicImportMessage) }() - case 27: try { try decoder.decodeSingularMessageField(value: &_storage._optionalLazyMessage) }() - case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() - case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() - case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() - case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() - case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() - case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() - case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() - case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() - case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() - case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() - case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() - case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() - case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() - case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() - case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() - case 46: try { try decoder.decodeRepeatedGroupField(value: &_storage._repeatedGroup) }() - case 48: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedNestedMessage) }() - case 49: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedForeignMessage) }() - case 50: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedImportMessage) }() - case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() - case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() - case 53: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedImportEnum) }() - case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() - case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() - case 57: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedLazyMessage) }() - case 61: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() - case 62: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() - case 63: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() - case 64: try { try decoder.decodeSingularUInt64Field(value: &_storage._defaultUint64) }() - case 65: try { try decoder.decodeSingularSInt32Field(value: &_storage._defaultSint32) }() - case 66: try { try decoder.decodeSingularSInt64Field(value: &_storage._defaultSint64) }() - case 67: try { try decoder.decodeSingularFixed32Field(value: &_storage._defaultFixed32) }() - case 68: try { try decoder.decodeSingularFixed64Field(value: &_storage._defaultFixed64) }() - case 69: try { try decoder.decodeSingularSFixed32Field(value: &_storage._defaultSfixed32) }() - case 70: try { try decoder.decodeSingularSFixed64Field(value: &_storage._defaultSfixed64) }() - case 71: try { try decoder.decodeSingularFloatField(value: &_storage._defaultFloat) }() - case 72: try { try decoder.decodeSingularDoubleField(value: &_storage._defaultDouble) }() - case 73: try { try decoder.decodeSingularBoolField(value: &_storage._defaultBool) }() - case 74: try { try decoder.decodeSingularStringField(value: &_storage._defaultString) }() - case 75: try { try decoder.decodeSingularBytesField(value: &_storage._defaultBytes) }() - case 81: try { try decoder.decodeSingularEnumField(value: &_storage._defaultNestedEnum) }() - case 82: try { try decoder.decodeSingularEnumField(value: &_storage._defaultForeignEnum) }() - case 83: try { try decoder.decodeSingularEnumField(value: &_storage._defaultImportEnum) }() - case 84: try { try decoder.decodeSingularStringField(value: &_storage._defaultStringPiece) }() - case 85: try { try decoder.decodeSingularStringField(value: &_storage._defaultCord) }() - case 111: try { - var v: UInt32? - try decoder.decodeSingularUInt32Field(value: &v) - if let v = v { - if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofUint32(v) - } - }() - case 112: try { - var v: ProtobufUnittest_TestAllTypesLite.NestedMessage? - var hadOneofValue = false - if let current = _storage._oneofField { - hadOneofValue = true - if case .oneofNestedMessage(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofNestedMessage(v) - } - }() - case 113: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofString(v) - } - }() - case 114: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if _storage._oneofField != nil {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofBytes(v) - } - }() - case 115: try { - var v: ProtobufUnittest_TestAllTypesLite.NestedMessage? - var hadOneofValue = false - if let current = _storage._oneofField { - hadOneofValue = true - if case .oneofLazyNestedMessage(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofLazyNestedMessage(v) - } - }() - case 116: try { try decoder.decodeSingularInt32Field(value: &_storage._deceptivelyNamedList) }() - case 117: try { - var v: ProtobufUnittest_TestAllTypesLite.NestedMessage2? - var hadOneofValue = false - if let current = _storage._oneofField { - hadOneofValue = true - if case .oneofNestedMessage2(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - _storage._oneofField = .oneofNestedMessage2(v) - } - }() - default: break - } - } - } - } - - func traverse(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._optionalInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._optionalInt64 { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) - } }() - try { if let v = _storage._optionalUint32 { - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 3) - } }() - try { if let v = _storage._optionalUint64 { - try visitor.visitSingularUInt64Field(value: v, fieldNumber: 4) - } }() - try { if let v = _storage._optionalSint32 { - try visitor.visitSingularSInt32Field(value: v, fieldNumber: 5) - } }() - try { if let v = _storage._optionalSint64 { - try visitor.visitSingularSInt64Field(value: v, fieldNumber: 6) - } }() - try { if let v = _storage._optionalFixed32 { - try visitor.visitSingularFixed32Field(value: v, fieldNumber: 7) - } }() - try { if let v = _storage._optionalFixed64 { - try visitor.visitSingularFixed64Field(value: v, fieldNumber: 8) - } }() - try { if let v = _storage._optionalSfixed32 { - try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 9) - } }() - try { if let v = _storage._optionalSfixed64 { - try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 10) - } }() - try { if let v = _storage._optionalFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 11) - } }() - try { if let v = _storage._optionalDouble { - try visitor.visitSingularDoubleField(value: v, fieldNumber: 12) - } }() - try { if let v = _storage._optionalBool { - try visitor.visitSingularBoolField(value: v, fieldNumber: 13) - } }() - try { if let v = _storage._optionalString { - try visitor.visitSingularStringField(value: v, fieldNumber: 14) - } }() - try { if let v = _storage._optionalBytes { - try visitor.visitSingularBytesField(value: v, fieldNumber: 15) - } }() - try { if let v = _storage._optionalGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 16) - } }() - try { if let v = _storage._optionalNestedMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 18) - } }() - try { if let v = _storage._optionalForeignMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 19) - } }() - try { if let v = _storage._optionalImportMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 20) - } }() - try { if let v = _storage._optionalNestedEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 21) - } }() - try { if let v = _storage._optionalForeignEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 22) - } }() - try { if let v = _storage._optionalImportEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 23) - } }() - try { if let v = _storage._optionalStringPiece { - try visitor.visitSingularStringField(value: v, fieldNumber: 24) - } }() - try { if let v = _storage._optionalCord { - try visitor.visitSingularStringField(value: v, fieldNumber: 25) - } }() - try { if let v = _storage._optionalPublicImportMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 26) - } }() - try { if let v = _storage._optionalLazyMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 27) - } }() - if !_storage._repeatedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) - } - if !_storage._repeatedInt64.isEmpty { - try visitor.visitRepeatedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) - } - if !_storage._repeatedUint32.isEmpty { - try visitor.visitRepeatedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) - } - if !_storage._repeatedUint64.isEmpty { - try visitor.visitRepeatedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) - } - if !_storage._repeatedSint32.isEmpty { - try visitor.visitRepeatedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) - } - if !_storage._repeatedSint64.isEmpty { - try visitor.visitRepeatedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) - } - if !_storage._repeatedFixed32.isEmpty { - try visitor.visitRepeatedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) - } - if !_storage._repeatedFixed64.isEmpty { - try visitor.visitRepeatedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) - } - if !_storage._repeatedSfixed32.isEmpty { - try visitor.visitRepeatedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) - } - if !_storage._repeatedSfixed64.isEmpty { - try visitor.visitRepeatedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) - } - if !_storage._repeatedFloat.isEmpty { - try visitor.visitRepeatedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) - } - if !_storage._repeatedDouble.isEmpty { - try visitor.visitRepeatedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) - } - if !_storage._repeatedBool.isEmpty { - try visitor.visitRepeatedBoolField(value: _storage._repeatedBool, fieldNumber: 43) - } - if !_storage._repeatedString.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) - } - if !_storage._repeatedBytes.isEmpty { - try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) - } - if !_storage._repeatedGroup.isEmpty { - try visitor.visitRepeatedGroupField(value: _storage._repeatedGroup, fieldNumber: 46) - } - if !_storage._repeatedNestedMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedNestedMessage, fieldNumber: 48) - } - if !_storage._repeatedForeignMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedForeignMessage, fieldNumber: 49) - } - if !_storage._repeatedImportMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedImportMessage, fieldNumber: 50) - } - if !_storage._repeatedNestedEnum.isEmpty { - try visitor.visitRepeatedEnumField(value: _storage._repeatedNestedEnum, fieldNumber: 51) - } - if !_storage._repeatedForeignEnum.isEmpty { - try visitor.visitRepeatedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) - } - if !_storage._repeatedImportEnum.isEmpty { - try visitor.visitRepeatedEnumField(value: _storage._repeatedImportEnum, fieldNumber: 53) - } - if !_storage._repeatedStringPiece.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) - } - if !_storage._repeatedCord.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) - } - if !_storage._repeatedLazyMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedLazyMessage, fieldNumber: 57) - } - try { if let v = _storage._defaultInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 61) - } }() - try { if let v = _storage._defaultInt64 { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 62) - } }() - try { if let v = _storage._defaultUint32 { - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 63) - } }() - try { if let v = _storage._defaultUint64 { - try visitor.visitSingularUInt64Field(value: v, fieldNumber: 64) - } }() - try { if let v = _storage._defaultSint32 { - try visitor.visitSingularSInt32Field(value: v, fieldNumber: 65) - } }() - try { if let v = _storage._defaultSint64 { - try visitor.visitSingularSInt64Field(value: v, fieldNumber: 66) - } }() - try { if let v = _storage._defaultFixed32 { - try visitor.visitSingularFixed32Field(value: v, fieldNumber: 67) - } }() - try { if let v = _storage._defaultFixed64 { - try visitor.visitSingularFixed64Field(value: v, fieldNumber: 68) - } }() - try { if let v = _storage._defaultSfixed32 { - try visitor.visitSingularSFixed32Field(value: v, fieldNumber: 69) - } }() - try { if let v = _storage._defaultSfixed64 { - try visitor.visitSingularSFixed64Field(value: v, fieldNumber: 70) - } }() - try { if let v = _storage._defaultFloat { - try visitor.visitSingularFloatField(value: v, fieldNumber: 71) - } }() - try { if let v = _storage._defaultDouble { - try visitor.visitSingularDoubleField(value: v, fieldNumber: 72) - } }() - try { if let v = _storage._defaultBool { - try visitor.visitSingularBoolField(value: v, fieldNumber: 73) - } }() - try { if let v = _storage._defaultString { - try visitor.visitSingularStringField(value: v, fieldNumber: 74) - } }() - try { if let v = _storage._defaultBytes { - try visitor.visitSingularBytesField(value: v, fieldNumber: 75) - } }() - try { if let v = _storage._defaultNestedEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 81) - } }() - try { if let v = _storage._defaultForeignEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 82) - } }() - try { if let v = _storage._defaultImportEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 83) - } }() - try { if let v = _storage._defaultStringPiece { - try visitor.visitSingularStringField(value: v, fieldNumber: 84) - } }() - try { if let v = _storage._defaultCord { - try visitor.visitSingularStringField(value: v, fieldNumber: 85) - } }() - switch _storage._oneofField { - case .oneofUint32?: try { - guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 111) - }() - case .oneofNestedMessage?: try { - guard case .oneofNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 112) - }() - case .oneofString?: try { - guard case .oneofString(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 113) - }() - case .oneofBytes?: try { - guard case .oneofBytes(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 114) - }() - case .oneofLazyNestedMessage?: try { - guard case .oneofLazyNestedMessage(let v)? = _storage._oneofField else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 115) - }() - default: break - } - try { if let v = _storage._deceptivelyNamedList { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 116) - } }() - try { if case .oneofNestedMessage2(let v)? = _storage._oneofField { - try visitor.visitSingularMessageField(value: v, fieldNumber: 117) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllTypesLite, rhs: ProtobufUnittest_TestAllTypesLite) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} - if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} - if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} - if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} - if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} - if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} - if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} - if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} - if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} - if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} - if _storage._optionalFloat != rhs_storage._optionalFloat {return false} - if _storage._optionalDouble != rhs_storage._optionalDouble {return false} - if _storage._optionalBool != rhs_storage._optionalBool {return false} - if _storage._optionalString != rhs_storage._optionalString {return false} - if _storage._optionalBytes != rhs_storage._optionalBytes {return false} - if _storage._optionalGroup != rhs_storage._optionalGroup {return false} - if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} - if _storage._optionalForeignMessage != rhs_storage._optionalForeignMessage {return false} - if _storage._optionalImportMessage != rhs_storage._optionalImportMessage {return false} - if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} - if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} - if _storage._optionalImportEnum != rhs_storage._optionalImportEnum {return false} - if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} - if _storage._optionalCord != rhs_storage._optionalCord {return false} - if _storage._optionalPublicImportMessage != rhs_storage._optionalPublicImportMessage {return false} - if _storage._optionalLazyMessage != rhs_storage._optionalLazyMessage {return false} - if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} - if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} - if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} - if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} - if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} - if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} - if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} - if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} - if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} - if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} - if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} - if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} - if _storage._repeatedBool != rhs_storage._repeatedBool {return false} - if _storage._repeatedString != rhs_storage._repeatedString {return false} - if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} - if _storage._repeatedGroup != rhs_storage._repeatedGroup {return false} - if _storage._repeatedNestedMessage != rhs_storage._repeatedNestedMessage {return false} - if _storage._repeatedForeignMessage != rhs_storage._repeatedForeignMessage {return false} - if _storage._repeatedImportMessage != rhs_storage._repeatedImportMessage {return false} - if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} - if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} - if _storage._repeatedImportEnum != rhs_storage._repeatedImportEnum {return false} - if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} - if _storage._repeatedCord != rhs_storage._repeatedCord {return false} - if _storage._repeatedLazyMessage != rhs_storage._repeatedLazyMessage {return false} - if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} - if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} - if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} - if _storage._defaultUint64 != rhs_storage._defaultUint64 {return false} - if _storage._defaultSint32 != rhs_storage._defaultSint32 {return false} - if _storage._defaultSint64 != rhs_storage._defaultSint64 {return false} - if _storage._defaultFixed32 != rhs_storage._defaultFixed32 {return false} - if _storage._defaultFixed64 != rhs_storage._defaultFixed64 {return false} - if _storage._defaultSfixed32 != rhs_storage._defaultSfixed32 {return false} - if _storage._defaultSfixed64 != rhs_storage._defaultSfixed64 {return false} - if _storage._defaultFloat != rhs_storage._defaultFloat {return false} - if _storage._defaultDouble != rhs_storage._defaultDouble {return false} - if _storage._defaultBool != rhs_storage._defaultBool {return false} - if _storage._defaultString != rhs_storage._defaultString {return false} - if _storage._defaultBytes != rhs_storage._defaultBytes {return false} - if _storage._defaultNestedEnum != rhs_storage._defaultNestedEnum {return false} - if _storage._defaultForeignEnum != rhs_storage._defaultForeignEnum {return false} - if _storage._defaultImportEnum != rhs_storage._defaultImportEnum {return false} - if _storage._defaultStringPiece != rhs_storage._defaultStringPiece {return false} - if _storage._defaultCord != rhs_storage._defaultCord {return false} - if _storage._oneofField != rhs_storage._oneofField {return false} - if _storage._deceptivelyNamedList != rhs_storage._deceptivelyNamedList {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestAllTypesLite.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - 3: .same(proto: "BAZ"), - ] -} - -extension ProtobufUnittest_TestAllTypesLite.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestAllTypesLite.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - 2: .same(proto: "cc"), - ] - - 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._bb) }() - case 2: try { try decoder.decodeSingularInt64Field(value: &self._cc) }() - 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 - try { if let v = self._bb { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._cc { - try visitor.visitSingularInt64Field(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllTypesLite.NestedMessage, rhs: ProtobufUnittest_TestAllTypesLite.NestedMessage) -> Bool { - if lhs._bb != rhs._bb {return false} - if lhs._cc != rhs._cc {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestAllTypesLite.NestedMessage2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestAllTypesLite.protoMessageName + ".NestedMessage2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "dd"), - ] - - 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._dd) }() - 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 - try { if let v = self._dd { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllTypesLite.NestedMessage2, rhs: ProtobufUnittest_TestAllTypesLite.NestedMessage2) -> Bool { - if lhs._dd != rhs._dd {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestAllTypesLite.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestAllTypesLite.protoMessageName + ".OptionalGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 17: .same(proto: "a"), - ] - - 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllTypesLite.OptionalGroup, rhs: ProtobufUnittest_TestAllTypesLite.OptionalGroup) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestAllTypesLite.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestAllTypesLite.protoMessageName + ".RepeatedGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 47: .same(proto: "a"), - ] - - 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 47: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllTypesLite.RepeatedGroup, rhs: ProtobufUnittest_TestAllTypesLite.RepeatedGroup) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_ForeignMessageLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".ForeignMessageLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - ] - - 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._c) }() - 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 - try { if let v = self._c { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_ForeignMessageLite, rhs: ProtobufUnittest_ForeignMessageLite) -> Bool { - if lhs._c != rhs._c {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestPackedTypesLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestPackedTypesLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 90: .standard(proto: "packed_int32"), - 91: .standard(proto: "packed_int64"), - 92: .standard(proto: "packed_uint32"), - 93: .standard(proto: "packed_uint64"), - 94: .standard(proto: "packed_sint32"), - 95: .standard(proto: "packed_sint64"), - 96: .standard(proto: "packed_fixed32"), - 97: .standard(proto: "packed_fixed64"), - 98: .standard(proto: "packed_sfixed32"), - 99: .standard(proto: "packed_sfixed64"), - 100: .standard(proto: "packed_float"), - 101: .standard(proto: "packed_double"), - 102: .standard(proto: "packed_bool"), - 103: .standard(proto: "packed_enum"), - ] - - 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 90: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32) }() - case 91: try { try decoder.decodeRepeatedInt64Field(value: &self.packedInt64) }() - case 92: try { try decoder.decodeRepeatedUInt32Field(value: &self.packedUint32) }() - case 93: try { try decoder.decodeRepeatedUInt64Field(value: &self.packedUint64) }() - case 94: try { try decoder.decodeRepeatedSInt32Field(value: &self.packedSint32) }() - case 95: try { try decoder.decodeRepeatedSInt64Field(value: &self.packedSint64) }() - case 96: try { try decoder.decodeRepeatedFixed32Field(value: &self.packedFixed32) }() - case 97: try { try decoder.decodeRepeatedFixed64Field(value: &self.packedFixed64) }() - case 98: try { try decoder.decodeRepeatedSFixed32Field(value: &self.packedSfixed32) }() - case 99: try { try decoder.decodeRepeatedSFixed64Field(value: &self.packedSfixed64) }() - case 100: try { try decoder.decodeRepeatedFloatField(value: &self.packedFloat) }() - case 101: try { try decoder.decodeRepeatedDoubleField(value: &self.packedDouble) }() - case 102: try { try decoder.decodeRepeatedBoolField(value: &self.packedBool) }() - case 103: try { try decoder.decodeRepeatedEnumField(value: &self.packedEnum) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.packedInt32.isEmpty { - try visitor.visitPackedInt32Field(value: self.packedInt32, fieldNumber: 90) - } - if !self.packedInt64.isEmpty { - try visitor.visitPackedInt64Field(value: self.packedInt64, fieldNumber: 91) - } - if !self.packedUint32.isEmpty { - try visitor.visitPackedUInt32Field(value: self.packedUint32, fieldNumber: 92) - } - if !self.packedUint64.isEmpty { - try visitor.visitPackedUInt64Field(value: self.packedUint64, fieldNumber: 93) - } - if !self.packedSint32.isEmpty { - try visitor.visitPackedSInt32Field(value: self.packedSint32, fieldNumber: 94) - } - if !self.packedSint64.isEmpty { - try visitor.visitPackedSInt64Field(value: self.packedSint64, fieldNumber: 95) - } - if !self.packedFixed32.isEmpty { - try visitor.visitPackedFixed32Field(value: self.packedFixed32, fieldNumber: 96) - } - if !self.packedFixed64.isEmpty { - try visitor.visitPackedFixed64Field(value: self.packedFixed64, fieldNumber: 97) - } - if !self.packedSfixed32.isEmpty { - try visitor.visitPackedSFixed32Field(value: self.packedSfixed32, fieldNumber: 98) - } - if !self.packedSfixed64.isEmpty { - try visitor.visitPackedSFixed64Field(value: self.packedSfixed64, fieldNumber: 99) - } - if !self.packedFloat.isEmpty { - try visitor.visitPackedFloatField(value: self.packedFloat, fieldNumber: 100) - } - if !self.packedDouble.isEmpty { - try visitor.visitPackedDoubleField(value: self.packedDouble, fieldNumber: 101) - } - if !self.packedBool.isEmpty { - try visitor.visitPackedBoolField(value: self.packedBool, fieldNumber: 102) - } - if !self.packedEnum.isEmpty { - try visitor.visitPackedEnumField(value: self.packedEnum, fieldNumber: 103) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestPackedTypesLite, rhs: ProtobufUnittest_TestPackedTypesLite) -> Bool { - if lhs.packedInt32 != rhs.packedInt32 {return false} - if lhs.packedInt64 != rhs.packedInt64 {return false} - if lhs.packedUint32 != rhs.packedUint32 {return false} - if lhs.packedUint64 != rhs.packedUint64 {return false} - if lhs.packedSint32 != rhs.packedSint32 {return false} - if lhs.packedSint64 != rhs.packedSint64 {return false} - if lhs.packedFixed32 != rhs.packedFixed32 {return false} - if lhs.packedFixed64 != rhs.packedFixed64 {return false} - if lhs.packedSfixed32 != rhs.packedSfixed32 {return false} - if lhs.packedSfixed64 != rhs.packedSfixed64 {return false} - if lhs.packedFloat != rhs.packedFloat {return false} - if lhs.packedDouble != rhs.packedDouble {return false} - if lhs.packedBool != rhs.packedBool {return false} - if lhs.packedEnum != rhs.packedEnum {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestAllExtensionsLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestAllExtensionsLite" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestAllExtensionsLite.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestAllExtensionsLite, rhs: ProtobufUnittest_TestAllExtensionsLite) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_OptionalGroup_extension_lite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".OptionalGroup_extension_lite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 17: .same(proto: "a"), - ] - - 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 17: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_OptionalGroup_extension_lite, rhs: ProtobufUnittest_OptionalGroup_extension_lite) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_RepeatedGroup_extension_lite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".RepeatedGroup_extension_lite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 47: .same(proto: "a"), - ] - - 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 47: try { try decoder.decodeSingularInt32Field(value: &self._a) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_RepeatedGroup_extension_lite, rhs: ProtobufUnittest_RepeatedGroup_extension_lite) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestPackedExtensionsLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestPackedExtensionsLite" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestPackedExtensionsLite.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestPackedExtensionsLite, rhs: ProtobufUnittest_TestPackedExtensionsLite) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestNestedExtensionLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestNestedExtensionLite" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestNestedExtensionLite, rhs: ProtobufUnittest_TestNestedExtensionLite) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestDeprecatedLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestDeprecatedLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "deprecated_field"), - 2: .standard(proto: "deprecated_field2"), - 3: .standard(proto: "deprecated_field3"), - 4: .standard(proto: "deprecated_field4"), - ] - - fileprivate class _StorageClass { - var _deprecatedField: Int32? = nil - var _deprecatedField2: Int32? = nil - var _deprecatedField3: String? = nil - var _deprecatedField4: ProtobufUnittest_TestDeprecatedLite? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _deprecatedField = source._deprecatedField - _deprecatedField2 = source._deprecatedField2 - _deprecatedField3 = source._deprecatedField3 - _deprecatedField4 = source._deprecatedField4 - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - public var isInitialized: Bool { - return withExtendedLifetime(_storage) { (_storage: _StorageClass) in - if _storage._deprecatedField2 == nil {return false} - if let v = _storage._deprecatedField4, !v.isInitialized {return false} - return true - } - } - - mutating func decodeMessage(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._deprecatedField) }() - case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._deprecatedField2) }() - case 3: try { try decoder.decodeSingularStringField(value: &_storage._deprecatedField3) }() - case 4: try { try decoder.decodeSingularMessageField(value: &_storage._deprecatedField4) }() - default: break - } - } - } - } - - func traverse(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._deprecatedField { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._deprecatedField2 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) - } }() - try { if let v = _storage._deprecatedField3 { - try visitor.visitSingularStringField(value: v, fieldNumber: 3) - } }() - try { if let v = _storage._deprecatedField4 { - try visitor.visitSingularMessageField(value: v, fieldNumber: 4) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestDeprecatedLite, rhs: ProtobufUnittest_TestDeprecatedLite) -> 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._deprecatedField != rhs_storage._deprecatedField {return false} - if _storage._deprecatedField2 != rhs_storage._deprecatedField2 {return false} - if _storage._deprecatedField3 != rhs_storage._deprecatedField3 {return false} - if _storage._deprecatedField4 != rhs_storage._deprecatedField4 {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestParsingMergeLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestParsingMergeLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "required_all_types"), - 2: .standard(proto: "optional_all_types"), - 3: .standard(proto: "repeated_all_types"), - 10: .unique(proto: "OptionalGroup", json: "optionalgroup"), - 20: .unique(proto: "RepeatedGroup", json: "repeatedgroup"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - if self._requiredAllTypes == nil {return false} - return true - } - - 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.decodeSingularMessageField(value: &self._requiredAllTypes) }() - case 2: try { try decoder.decodeSingularMessageField(value: &self._optionalAllTypes) }() - case 3: try { try decoder.decodeRepeatedMessageField(value: &self.repeatedAllTypes) }() - case 10: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() - case 20: try { try decoder.decodeRepeatedGroupField(value: &self.repeatedGroup) }() - case 1000..<536870912: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestParsingMergeLite.self, fieldNumber: fieldNumber) }() - 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 - try { if let v = self._requiredAllTypes { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = self._optionalAllTypes { - try visitor.visitSingularMessageField(value: v, fieldNumber: 2) - } }() - if !self.repeatedAllTypes.isEmpty { - try visitor.visitRepeatedMessageField(value: self.repeatedAllTypes, fieldNumber: 3) - } - try { if let v = self._optionalGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 10) - } }() - if !self.repeatedGroup.isEmpty { - try visitor.visitRepeatedGroupField(value: self.repeatedGroup, fieldNumber: 20) - } - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestParsingMergeLite, rhs: ProtobufUnittest_TestParsingMergeLite) -> Bool { - if lhs._requiredAllTypes != rhs._requiredAllTypes {return false} - if lhs._optionalAllTypes != rhs._optionalAllTypes {return false} - if lhs.repeatedAllTypes != rhs.repeatedAllTypes {return false} - if lhs._optionalGroup != rhs._optionalGroup {return false} - if lhs.repeatedGroup != rhs.repeatedGroup {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMergeLite.protoMessageName + ".RepeatedFieldsGenerator" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "field1"), - 2: .same(proto: "field2"), - 3: .same(proto: "field3"), - 10: .unique(proto: "Group1", json: "group1"), - 20: .unique(proto: "Group2", json: "group2"), - 1000: .same(proto: "ext1"), - 1001: .same(proto: "ext2"), - ] - - 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.decodeRepeatedMessageField(value: &self.field1) }() - case 2: try { try decoder.decodeRepeatedMessageField(value: &self.field2) }() - case 3: try { try decoder.decodeRepeatedMessageField(value: &self.field3) }() - case 10: try { try decoder.decodeRepeatedGroupField(value: &self.group1) }() - case 20: try { try decoder.decodeRepeatedGroupField(value: &self.group2) }() - case 1000: try { try decoder.decodeRepeatedMessageField(value: &self.ext1) }() - case 1001: try { try decoder.decodeRepeatedMessageField(value: &self.ext2) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.field1.isEmpty { - try visitor.visitRepeatedMessageField(value: self.field1, fieldNumber: 1) - } - if !self.field2.isEmpty { - try visitor.visitRepeatedMessageField(value: self.field2, fieldNumber: 2) - } - if !self.field3.isEmpty { - try visitor.visitRepeatedMessageField(value: self.field3, fieldNumber: 3) - } - if !self.group1.isEmpty { - try visitor.visitRepeatedGroupField(value: self.group1, fieldNumber: 10) - } - if !self.group2.isEmpty { - try visitor.visitRepeatedGroupField(value: self.group2, fieldNumber: 20) - } - if !self.ext1.isEmpty { - try visitor.visitRepeatedMessageField(value: self.ext1, fieldNumber: 1000) - } - if !self.ext2.isEmpty { - try visitor.visitRepeatedMessageField(value: self.ext2, fieldNumber: 1001) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator, rhs: ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator) -> Bool { - if lhs.field1 != rhs.field1 {return false} - if lhs.field2 != rhs.field2 {return false} - if lhs.field3 != rhs.field3 {return false} - if lhs.group1 != rhs.group1 {return false} - if lhs.group2 != rhs.group2 {return false} - if lhs.ext1 != rhs.ext1 {return false} - if lhs.ext2 != rhs.ext2 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.protoMessageName + ".Group1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 11: .same(proto: "field1"), - ] - - 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 11: try { try decoder.decodeSingularMessageField(value: &self._field1) }() - 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 - try { if let v = self._field1 { - try visitor.visitSingularMessageField(value: v, fieldNumber: 11) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group1, rhs: ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group1) -> Bool { - if lhs._field1 != rhs._field1 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.protoMessageName + ".Group2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 21: .same(proto: "field1"), - ] - - 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 21: try { try decoder.decodeSingularMessageField(value: &self._field1) }() - 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 - try { if let v = self._field1 { - try visitor.visitSingularMessageField(value: v, fieldNumber: 21) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group2, rhs: ProtobufUnittest_TestParsingMergeLite.RepeatedFieldsGenerator.Group2) -> Bool { - if lhs._field1 != rhs._field1 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestParsingMergeLite.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMergeLite.protoMessageName + ".OptionalGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 11: .standard(proto: "optional_group_all_types"), - ] - - 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 11: try { try decoder.decodeSingularMessageField(value: &self._optionalGroupAllTypes) }() - 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 - try { if let v = self._optionalGroupAllTypes { - try visitor.visitSingularMessageField(value: v, fieldNumber: 11) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestParsingMergeLite.OptionalGroup, rhs: ProtobufUnittest_TestParsingMergeLite.OptionalGroup) -> Bool { - if lhs._optionalGroupAllTypes != rhs._optionalGroupAllTypes {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestParsingMergeLite.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestParsingMergeLite.protoMessageName + ".RepeatedGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 21: .standard(proto: "repeated_group_all_types"), - ] - - 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 21: try { try decoder.decodeSingularMessageField(value: &self._repeatedGroupAllTypes) }() - 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 - try { if let v = self._repeatedGroupAllTypes { - try visitor.visitSingularMessageField(value: v, fieldNumber: 21) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestParsingMergeLite.RepeatedGroup, rhs: ProtobufUnittest_TestParsingMergeLite.RepeatedGroup) -> Bool { - if lhs._repeatedGroupAllTypes != rhs._repeatedGroupAllTypes {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestEmptyMessageLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestEmptyMessageLite" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestEmptyMessageLite, rhs: ProtobufUnittest_TestEmptyMessageLite) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestEmptyMessageWithExtensionsLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestEmptyMessageWithExtensionsLite" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestEmptyMessageWithExtensionsLite.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestEmptyMessageWithExtensionsLite, rhs: ProtobufUnittest_TestEmptyMessageWithExtensionsLite) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_V1MessageLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".V1MessageLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "int_field"), - 2: .standard(proto: "enum_field"), - ] - - public var isInitialized: Bool { - if self._intField == nil {return false} - return true - } - - 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._intField) }() - case 2: try { try decoder.decodeSingularEnumField(value: &self._enumField) }() - 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 - try { if let v = self._intField { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._enumField { - try visitor.visitSingularEnumField(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_V1MessageLite, rhs: ProtobufUnittest_V1MessageLite) -> Bool { - if lhs._intField != rhs._intField {return false} - if lhs._enumField != rhs._enumField {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_V2MessageLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".V2MessageLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "int_field"), - 2: .standard(proto: "enum_field"), - ] - - public var isInitialized: Bool { - if self._intField == nil {return false} - return true - } - - 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._intField) }() - case 2: try { try decoder.decodeSingularEnumField(value: &self._enumField) }() - 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 - try { if let v = self._intField { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try { if let v = self._enumField { - try visitor.visitSingularEnumField(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_V2MessageLite, rhs: ProtobufUnittest_V2MessageLite) -> Bool { - if lhs._intField != rhs._intField {return false} - if lhs._enumField != rhs._enumField {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestHugeFieldNumbersLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestHugeFieldNumbersLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 536870000: .standard(proto: "optional_int32"), - 536870001: .standard(proto: "fixed_32"), - 536870002: .standard(proto: "repeated_int32"), - 536870003: .standard(proto: "packed_int32"), - 536870004: .standard(proto: "optional_enum"), - 536870005: .standard(proto: "optional_string"), - 536870006: .standard(proto: "optional_bytes"), - 536870007: .standard(proto: "optional_message"), - 536870008: .unique(proto: "OptionalGroup", json: "optionalgroup"), - 536870010: .standard(proto: "string_string_map"), - 536870011: .standard(proto: "oneof_uint32"), - 536870012: .standard(proto: "oneof_test_all_types"), - 536870013: .standard(proto: "oneof_string"), - 536870014: .standard(proto: "oneof_bytes"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - 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 536870000: try { try decoder.decodeSingularInt32Field(value: &self._optionalInt32) }() - case 536870001: try { try decoder.decodeSingularInt32Field(value: &self._fixed32) }() - case 536870002: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() - case 536870003: try { try decoder.decodeRepeatedInt32Field(value: &self.packedInt32) }() - case 536870004: try { try decoder.decodeSingularEnumField(value: &self._optionalEnum) }() - case 536870005: try { try decoder.decodeSingularStringField(value: &self._optionalString) }() - case 536870006: try { try decoder.decodeSingularBytesField(value: &self._optionalBytes) }() - case 536870007: try { try decoder.decodeSingularMessageField(value: &self._optionalMessage) }() - case 536870008: try { try decoder.decodeSingularGroupField(value: &self._optionalGroup) }() - case 536870010: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &self.stringStringMap) }() - case 536870011: try { - var v: UInt32? - try decoder.decodeSingularUInt32Field(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofUint32(v) - } - }() - case 536870012: try { - var v: ProtobufUnittest_TestAllTypesLite? - var hadOneofValue = false - if let current = self.oneofField { - hadOneofValue = true - if case .oneofTestAllTypes(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofTestAllTypes(v) - } - }() - case 536870013: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofString(v) - } - }() - case 536870014: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofBytes(v) - } - }() - case 536860000..<536870000: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_TestHugeFieldNumbersLite.self, fieldNumber: fieldNumber) }() - 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 - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 536860000, end: 536870000) - try { if let v = self._optionalInt32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870000) - } }() - try { if let v = self._fixed32 { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870001) - } }() - if !self.repeatedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 536870002) - } - if !self.packedInt32.isEmpty { - try visitor.visitPackedInt32Field(value: self.packedInt32, fieldNumber: 536870003) - } - try { if let v = self._optionalEnum { - try visitor.visitSingularEnumField(value: v, fieldNumber: 536870004) - } }() - try { if let v = self._optionalString { - try visitor.visitSingularStringField(value: v, fieldNumber: 536870005) - } }() - try { if let v = self._optionalBytes { - try visitor.visitSingularBytesField(value: v, fieldNumber: 536870006) - } }() - try { if let v = self._optionalMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 536870007) - } }() - try { if let v = self._optionalGroup { - try visitor.visitSingularGroupField(value: v, fieldNumber: 536870008) - } }() - if !self.stringStringMap.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: self.stringStringMap, fieldNumber: 536870010) - } - switch self.oneofField { - case .oneofUint32?: try { - guard case .oneofUint32(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularUInt32Field(value: v, fieldNumber: 536870011) - }() - case .oneofTestAllTypes?: try { - guard case .oneofTestAllTypes(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 536870012) - }() - case .oneofString?: try { - guard case .oneofString(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 536870013) - }() - case .oneofBytes?: try { - guard case .oneofBytes(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 536870014) - }() - case nil: break - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestHugeFieldNumbersLite, rhs: ProtobufUnittest_TestHugeFieldNumbersLite) -> Bool { - if lhs._optionalInt32 != rhs._optionalInt32 {return false} - if lhs._fixed32 != rhs._fixed32 {return false} - if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} - if lhs.packedInt32 != rhs.packedInt32 {return false} - if lhs._optionalEnum != rhs._optionalEnum {return false} - if lhs._optionalString != rhs._optionalString {return false} - if lhs._optionalBytes != rhs._optionalBytes {return false} - if lhs._optionalMessage != rhs._optionalMessage {return false} - if lhs._optionalGroup != rhs._optionalGroup {return false} - if lhs.stringStringMap != rhs.stringStringMap {return false} - if lhs.oneofField != rhs.oneofField {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufUnittest_TestHugeFieldNumbersLite.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestHugeFieldNumbersLite.protoMessageName + ".OptionalGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 536870009: .standard(proto: "group_a"), - ] - - 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 536870009: try { try decoder.decodeSingularInt32Field(value: &self._groupA) }() - 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 - try { if let v = self._groupA { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 536870009) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestHugeFieldNumbersLite.OptionalGroup, rhs: ProtobufUnittest_TestHugeFieldNumbersLite.OptionalGroup) -> Bool { - if lhs._groupA != rhs._groupA {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestOneofParsingLite: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestOneofParsingLite" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "oneof_int32"), - 2: .standard(proto: "oneof_submessage"), - 3: .standard(proto: "oneof_string"), - 4: .standard(proto: "oneof_bytes"), - 5: .standard(proto: "oneof_string_cord"), - 6: .standard(proto: "oneof_bytes_cord"), - 7: .standard(proto: "oneof_string_string_piece"), - 8: .standard(proto: "oneof_bytes_string_piece"), - 9: .standard(proto: "oneof_enum"), - ] - - 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: Int32? - try decoder.decodeSingularInt32Field(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofInt32(v) - } - }() - case 2: try { - var v: ProtobufUnittest_TestAllTypesLite? - var hadOneofValue = false - if let current = self.oneofField { - hadOneofValue = true - if case .oneofSubmessage(let m) = current {v = m} - } - try decoder.decodeSingularMessageField(value: &v) - if let v = v { - if hadOneofValue {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofSubmessage(v) - } - }() - case 3: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofString(v) - } - }() - case 4: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofBytes(v) - } - }() - case 5: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofStringCord(v) - } - }() - case 6: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofBytesCord(v) - } - }() - case 7: try { - var v: String? - try decoder.decodeSingularStringField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofStringStringPiece(v) - } - }() - case 8: try { - var v: Data? - try decoder.decodeSingularBytesField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofBytesStringPiece(v) - } - }() - case 9: try { - var v: ProtobufUnittest_V2EnumLite? - try decoder.decodeSingularEnumField(value: &v) - if let v = v { - if self.oneofField != nil {try decoder.handleConflictingOneOf()} - self.oneofField = .oneofEnum(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.oneofField { - case .oneofInt32?: try { - guard case .oneofInt32(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - }() - case .oneofSubmessage?: try { - guard case .oneofSubmessage(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularMessageField(value: v, fieldNumber: 2) - }() - case .oneofString?: try { - guard case .oneofString(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 3) - }() - case .oneofBytes?: try { - guard case .oneofBytes(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 4) - }() - case .oneofStringCord?: try { - guard case .oneofStringCord(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 5) - }() - case .oneofBytesCord?: try { - guard case .oneofBytesCord(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 6) - }() - case .oneofStringStringPiece?: try { - guard case .oneofStringStringPiece(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularStringField(value: v, fieldNumber: 7) - }() - case .oneofBytesStringPiece?: try { - guard case .oneofBytesStringPiece(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularBytesField(value: v, fieldNumber: 8) - }() - case .oneofEnum?: try { - guard case .oneofEnum(let v)? = self.oneofField else { preconditionFailure() } - try visitor.visitSingularEnumField(value: v, fieldNumber: 9) - }() - case nil: break - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestOneofParsingLite, rhs: ProtobufUnittest_TestOneofParsingLite) -> Bool { - if lhs.oneofField != rhs.oneofField {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_PackedInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".PackedInt32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2048: .standard(proto: "repeated_int32"), - ] - - 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 2048: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.repeatedInt32.isEmpty { - try visitor.visitPackedInt32Field(value: self.repeatedInt32, fieldNumber: 2048) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_PackedInt32, rhs: ProtobufUnittest_PackedInt32) -> Bool { - if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_NonPackedInt32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".NonPackedInt32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2048: .standard(proto: "repeated_int32"), - ] - - 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 2048: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatedInt32) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.repeatedInt32.isEmpty { - try visitor.visitRepeatedInt32Field(value: self.repeatedInt32, fieldNumber: 2048) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_NonPackedInt32, rhs: ProtobufUnittest_NonPackedInt32) -> Bool { - if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_PackedFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".PackedFixed32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2048: .standard(proto: "repeated_fixed32"), - ] - - 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 2048: try { try decoder.decodeRepeatedFixed32Field(value: &self.repeatedFixed32) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.repeatedFixed32.isEmpty { - try visitor.visitPackedFixed32Field(value: self.repeatedFixed32, fieldNumber: 2048) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_PackedFixed32, rhs: ProtobufUnittest_PackedFixed32) -> Bool { - if lhs.repeatedFixed32 != rhs.repeatedFixed32 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_NonPackedFixed32: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".NonPackedFixed32" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2048: .standard(proto: "repeated_fixed32"), - ] - - 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 2048: try { try decoder.decodeRepeatedFixed32Field(value: &self.repeatedFixed32) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.repeatedFixed32.isEmpty { - try visitor.visitRepeatedFixed32Field(value: self.repeatedFixed32, fieldNumber: 2048) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_NonPackedFixed32, rhs: ProtobufUnittest_NonPackedFixed32) -> Bool { - if lhs.repeatedFixed32 != rhs.repeatedFixed32 {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_DupEnum: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".DupEnum" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_DupEnum, rhs: ProtobufUnittest_DupEnum) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_DupEnum.TestEnumWithDupValueLite: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .aliased(proto: "FOO1", aliases: ["FOO2"]), - 2: .aliased(proto: "BAR1", aliases: ["BAR2"]), - 3: .same(proto: "BAZ"), - ] -} - -extension ProtobufUnittest_RecursiveMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".RecursiveMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "recurse"), - 2: .same(proto: "payload"), - ] - - fileprivate class _StorageClass { - var _recurse: ProtobufUnittest_RecursiveMessage? = nil - var _payload: Data? = nil - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _recurse = source._recurse - _payload = source._payload - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._recurse) }() - case 2: try { try decoder.decodeSingularBytesField(value: &_storage._payload) }() - default: break - } - } - } - } - - func traverse(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._recurse { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = _storage._payload { - try visitor.visitSingularBytesField(value: v, fieldNumber: 2) - } }() - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_RecursiveMessage, rhs: ProtobufUnittest_RecursiveMessage) -> 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._recurse != rhs_storage._recurse {return false} - if _storage._payload != rhs_storage._payload {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Tests/SwiftProtobufTests/unittest_mset.pb.swift b/Tests/SwiftProtobufTests/unittest_mset.pb.swift index c8f8c90f1..b2edf38ae 100644 --- a/Tests/SwiftProtobufTests/unittest_mset.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_mset.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_mset.proto +// Source: unittest_mset.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -57,17 +58,17 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_TestMessageSetContainer { +struct SwiftProtoTesting_TestMessageSetContainer: Sendable { // 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 messageSet: Proto2WireformatUnittest_TestMessageSet { - get {return _messageSet ?? Proto2WireformatUnittest_TestMessageSet()} + var messageSet: SwiftProtoTesting_WireFormat_TestMessageSet { + get {_messageSet ?? SwiftProtoTesting_WireFormat_TestMessageSet()} set {_messageSet = newValue} } /// Returns true if `messageSet` has been explicitly set. - var hasMessageSet: Bool {return self._messageSet != nil} + var hasMessageSet: Bool {self._messageSet != nil} /// Clears the value of `messageSet`. Subsequent reads from it will return its default value. mutating func clearMessageSet() {self._messageSet = nil} @@ -75,61 +76,65 @@ struct ProtobufUnittest_TestMessageSetContainer { init() {} - fileprivate var _messageSet: Proto2WireformatUnittest_TestMessageSet? = nil + fileprivate var _messageSet: SwiftProtoTesting_WireFormat_TestMessageSet? = nil } -struct ProtobufUnittest_TestMessageSetExtension1 { +/// A message without the message_set_wire_format option but still supports +/// extensions. +struct SwiftProtoTesting_MessageEx: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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() +} + +struct SwiftProtoTesting_TestMessageSetExtension1: Sendable { // 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 i: Int32 { - get {return _i ?? 0} + get {_i ?? 0} set {_i = newValue} } /// Returns true if `i` has been explicitly set. - var hasI: Bool {return self._i != nil} + var hasI: Bool {self._i != nil} /// Clears the value of `i`. Subsequent reads from it will return its default value. mutating func clearI() {self._i = nil} - var recursive: Proto2WireformatUnittest_TestMessageSet { - get {return _recursive ?? Proto2WireformatUnittest_TestMessageSet()} + var recursive: SwiftProtoTesting_WireFormat_TestMessageSet { + get {_recursive ?? SwiftProtoTesting_WireFormat_TestMessageSet()} set {_recursive = newValue} } /// Returns true if `recursive` has been explicitly set. - var hasRecursive: Bool {return self._recursive != nil} + var hasRecursive: Bool {self._recursive != nil} /// Clears the value of `recursive`. Subsequent reads from it will return its default value. mutating func clearRecursive() {self._recursive = nil} - var testAliasing: String { - get {return _testAliasing ?? String()} - set {_testAliasing = newValue} - } - /// Returns true if `testAliasing` has been explicitly set. - var hasTestAliasing: Bool {return self._testAliasing != nil} - /// Clears the value of `testAliasing`. Subsequent reads from it will return its default value. - mutating func clearTestAliasing() {self._testAliasing = nil} - var unknownFields = SwiftProtobuf.UnknownStorage() init() {} fileprivate var _i: Int32? = nil - fileprivate var _recursive: Proto2WireformatUnittest_TestMessageSet? = nil - fileprivate var _testAliasing: String? = nil + fileprivate var _recursive: SwiftProtoTesting_WireFormat_TestMessageSet? = nil } -struct ProtobufUnittest_TestMessageSetExtension2 { +struct SwiftProtoTesting_TestMessageSetExtension2: Sendable { // 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 str: String { - get {return _str ?? String()} + get {_str ?? String()} set {_str = newValue} } /// Returns true if `str` has been explicitly set. - var hasStr: Bool {return self._str != nil} + var hasStr: Bool {self._str != nil} /// Clears the value of `str`. Subsequent reads from it will return its default value. mutating func clearStr() {self._str = nil} @@ -140,36 +145,59 @@ struct ProtobufUnittest_TestMessageSetExtension2 { fileprivate var _str: String? = nil } +/// This isn't on swift_proto_testing.wire_format.TestMessageSet, so it will be unknown +/// when parsing there. +struct SwiftProtoTesting_TestMessageSetExtension3: Sendable { + // 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 x: Int32 { + get {_x ?? 0} + set {_x = newValue} + } + /// Returns true if `x` has been explicitly set. + var hasX: Bool {self._x != nil} + /// Clears the value of `x`. Subsequent reads from it will return its default value. + mutating func clearX() {self._x = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _x: Int32? = nil +} + /// MessageSet wire format is equivalent to this. -struct ProtobufUnittest_RawMessageSet { +struct SwiftProtoTesting_RawMessageSet: Sendable { // 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 item: [ProtobufUnittest_RawMessageSet.Item] = [] + var item: [SwiftProtoTesting_RawMessageSet.Item] = [] var unknownFields = SwiftProtobuf.UnknownStorage() - struct Item { + struct Item: Sendable { // 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 typeID: Int32 { - get {return _typeID ?? 0} + get {_typeID ?? 0} set {_typeID = newValue} } /// Returns true if `typeID` has been explicitly set. - var hasTypeID: Bool {return self._typeID != nil} + var hasTypeID: Bool {self._typeID != nil} /// Clears the value of `typeID`. Subsequent reads from it will return its default value. mutating func clearTypeID() {self._typeID = nil} var message: Data { - get {return _message ?? Data()} + get {_message ?? Data()} set {_message = newValue} } /// Returns true if `message` has been explicitly set. - var hasMessage: Bool {return self._message != nil} + var hasMessage: Bool {self._message != nil} /// Clears the value of `message`. Subsequent reads from it will return its default value. mutating func clearMessage() {self._message = nil} @@ -184,99 +212,166 @@ struct ProtobufUnittest_RawMessageSet { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_TestMessageSetContainer: @unchecked Sendable {} -extension ProtobufUnittest_TestMessageSetExtension1: @unchecked Sendable {} -extension ProtobufUnittest_TestMessageSetExtension2: @unchecked Sendable {} -extension ProtobufUnittest_RawMessageSet: @unchecked Sendable {} -extension ProtobufUnittest_RawMessageSet.Item: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) +/// MessageSet wire format is equivalent to this but since the fields +/// are repeated they can be left off or over present to testing. +struct SwiftProtoTesting_RawBreakableMessageSet: Sendable { + // 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 item: [SwiftProtoTesting_RawBreakableMessageSet.Item] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + struct Item: Sendable { + // 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 typeID: [Int32] = [] + + var message: [Data] = [] + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + } + + init() {} +} // MARK: - Extension support defined in unittest_mset.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 Proto2WireformatUnittest_TestMessageSet { +extension SwiftProtoTesting_MessageEx { + + var SwiftProtoTesting_TestMessageSetExtension1_doppelgangerMessageSetExtension: SwiftProtoTesting_TestMessageSetExtension1 { + get {return getExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension1.Extensions.doppelganger_message_set_extension) ?? SwiftProtoTesting_TestMessageSetExtension1()} + set {setExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension1.Extensions.doppelganger_message_set_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_TestMessageSetExtension1.Extensions.doppelganger_message_set_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_TestMessageSetExtension1_doppelgangerMessageSetExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension1.Extensions.doppelganger_message_set_extension) + } + /// Clears the value of extension `SwiftProtoTesting_TestMessageSetExtension1.Extensions.doppelganger_message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_TestMessageSetExtension1_doppelgangerMessageSetExtension() { + clearExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension1.Extensions.doppelganger_message_set_extension) + } + + var SwiftProtoTesting_TestMessageSetExtension3_doppelgangerMessageSetExtension: SwiftProtoTesting_TestMessageSetExtension3 { + get {return getExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension3.Extensions.doppelganger_message_set_extension) ?? SwiftProtoTesting_TestMessageSetExtension3()} + set {setExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension3.Extensions.doppelganger_message_set_extension, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_TestMessageSetExtension3.Extensions.doppelganger_message_set_extension` + /// has been explicitly set. + var hasSwiftProtoTesting_TestMessageSetExtension3_doppelgangerMessageSetExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension3.Extensions.doppelganger_message_set_extension) + } + /// Clears the value of extension `SwiftProtoTesting_TestMessageSetExtension3.Extensions.doppelganger_message_set_extension`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_TestMessageSetExtension3_doppelgangerMessageSetExtension() { + clearExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension3.Extensions.doppelganger_message_set_extension) + } +} + +extension SwiftProtoTesting_WireFormat_TestMessageSet { - var ProtobufUnittest_TestMessageSetExtension1_messageSetExtension: ProtobufUnittest_TestMessageSetExtension1 { - get {return getExtensionValue(ext: ProtobufUnittest_TestMessageSetExtension1.Extensions.message_set_extension) ?? ProtobufUnittest_TestMessageSetExtension1()} - set {setExtensionValue(ext: ProtobufUnittest_TestMessageSetExtension1.Extensions.message_set_extension, value: newValue)} + var SwiftProtoTesting_TestMessageSetExtension1_messageSetExtension: SwiftProtoTesting_TestMessageSetExtension1 { + get {return getExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension) ?? SwiftProtoTesting_TestMessageSetExtension1()} + set {setExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_TestMessageSetExtension1.Extensions.message_set_extension` + /// Returns true if extension `SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension` /// has been explicitly set. - var hasProtobufUnittest_TestMessageSetExtension1_messageSetExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestMessageSetExtension1.Extensions.message_set_extension) + var hasSwiftProtoTesting_TestMessageSetExtension1_messageSetExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension) } - /// Clears the value of extension `ProtobufUnittest_TestMessageSetExtension1.Extensions.message_set_extension`. + /// Clears the value of extension `SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestMessageSetExtension1_messageSetExtension() { - clearExtensionValue(ext: ProtobufUnittest_TestMessageSetExtension1.Extensions.message_set_extension) + mutating func clearSwiftProtoTesting_TestMessageSetExtension1_messageSetExtension() { + clearExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension) } - var ProtobufUnittest_TestMessageSetExtension2_messageSetExtension: ProtobufUnittest_TestMessageSetExtension2 { - get {return getExtensionValue(ext: ProtobufUnittest_TestMessageSetExtension2.Extensions.message_set_extension) ?? ProtobufUnittest_TestMessageSetExtension2()} - set {setExtensionValue(ext: ProtobufUnittest_TestMessageSetExtension2.Extensions.message_set_extension, value: newValue)} + var SwiftProtoTesting_TestMessageSetExtension2_messageSetExtension: SwiftProtoTesting_TestMessageSetExtension2 { + get {return getExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension) ?? SwiftProtoTesting_TestMessageSetExtension2()} + set {setExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_TestMessageSetExtension2.Extensions.message_set_extension` + /// Returns true if extension `SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension` /// has been explicitly set. - var hasProtobufUnittest_TestMessageSetExtension2_messageSetExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_TestMessageSetExtension2.Extensions.message_set_extension) + var hasSwiftProtoTesting_TestMessageSetExtension2_messageSetExtension: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension) } - /// Clears the value of extension `ProtobufUnittest_TestMessageSetExtension2.Extensions.message_set_extension`. + /// Clears the value of extension `SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_TestMessageSetExtension2_messageSetExtension() { - clearExtensionValue(ext: ProtobufUnittest_TestMessageSetExtension2.Extensions.message_set_extension) + mutating func clearSwiftProtoTesting_TestMessageSetExtension2_messageSetExtension() { + clearExtensionValue(ext: SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension) } } -// MARK: - File's ExtensionMap: ProtobufUnittest_UnittestMset_Extensions +// MARK: - File's ExtensionMap: SwiftProtoTesting_UnittestMset_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 ProtobufUnittest_UnittestMset_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_TestMessageSetExtension1.Extensions.message_set_extension, - ProtobufUnittest_TestMessageSetExtension2.Extensions.message_set_extension +let SwiftProtoTesting_UnittestMset_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_TestMessageSetExtension1.Extensions.message_set_extension, + SwiftProtoTesting_TestMessageSetExtension1.Extensions.doppelganger_message_set_extension, + SwiftProtoTesting_TestMessageSetExtension2.Extensions.message_set_extension, + SwiftProtoTesting_TestMessageSetExtension3.Extensions.doppelganger_message_set_extension ] // 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. -extension ProtobufUnittest_TestMessageSetExtension1 { +extension SwiftProtoTesting_TestMessageSetExtension1 { enum Extensions { - static let message_set_extension = SwiftProtobuf.MessageExtension, Proto2WireformatUnittest_TestMessageSet>( + static let message_set_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_WireFormat_TestMessageSet>( + _protobuf_fieldNumber: 1545008, + fieldName: "swift_proto_testing.TestMessageSetExtension1" + ) + + static let doppelganger_message_set_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_MessageEx>( _protobuf_fieldNumber: 1545008, - fieldName: "protobuf_unittest.TestMessageSetExtension1" + fieldName: "swift_proto_testing.TestMessageSetExtension1.doppelganger_message_set_extension" ) } } -extension ProtobufUnittest_TestMessageSetExtension2 { +extension SwiftProtoTesting_TestMessageSetExtension2 { enum Extensions { - static let message_set_extension = SwiftProtobuf.MessageExtension, Proto2WireformatUnittest_TestMessageSet>( + static let message_set_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_WireFormat_TestMessageSet>( _protobuf_fieldNumber: 1547769, - fieldName: "protobuf_unittest.TestMessageSetExtension2" + fieldName: "swift_proto_testing.TestMessageSetExtension2" + ) + } +} + +extension SwiftProtoTesting_TestMessageSetExtension3 { + enum Extensions { + static let doppelganger_message_set_extension = SwiftProtobuf.MessageExtension, SwiftProtoTesting_MessageEx>( + _protobuf_fieldNumber: 1547770, + fieldName: "swift_proto_testing.TestMessageSetExtension3.doppelganger_message_set_extension" ) } } // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_TestMessageSetContainer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_TestMessageSetContainer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestMessageSetContainer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "message_set"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}message_set\0") public var isInitialized: Bool { if let v = self._messageSet, !v.isInitialized {return false} @@ -306,20 +401,45 @@ extension ProtobufUnittest_TestMessageSetContainer: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestMessageSetContainer, rhs: ProtobufUnittest_TestMessageSetContainer) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestMessageSetContainer, rhs: SwiftProtoTesting_TestMessageSetContainer) -> Bool { if lhs._messageSet != rhs._messageSet {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestMessageSetExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_MessageEx: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MessageEx" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + mutating func decodeMessage(decoder: inout D) throws { + while let fieldNumber = try decoder.nextFieldNumber() { + if (4 <= fieldNumber && fieldNumber < 536870912) { + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_MessageEx.self, fieldNumber: fieldNumber) + } + } + } + + func traverse(visitor: inout V) throws { + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 4, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_MessageEx, rhs: SwiftProtoTesting_MessageEx) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension SwiftProtoTesting_TestMessageSetExtension1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestMessageSetExtension1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 15: .same(proto: "i"), - 16: .same(proto: "recursive"), - 17: .standard(proto: "test_aliasing"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{f}i\0\u{1}recursive\0") public var isInitialized: Bool { if let v = self._recursive, !v.isInitialized {return false} @@ -334,7 +454,6 @@ extension ProtobufUnittest_TestMessageSetExtension1: SwiftProtobuf.Message, Swif switch fieldNumber { case 15: try { try decoder.decodeSingularInt32Field(value: &self._i) }() case 16: try { try decoder.decodeSingularMessageField(value: &self._recursive) }() - case 17: try { try decoder.decodeSingularStringField(value: &self._testAliasing) }() default: break } } @@ -351,26 +470,20 @@ extension ProtobufUnittest_TestMessageSetExtension1: SwiftProtobuf.Message, Swif try { if let v = self._recursive { try visitor.visitSingularMessageField(value: v, fieldNumber: 16) } }() - try { if let v = self._testAliasing { - try visitor.visitSingularStringField(value: v, fieldNumber: 17) - } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestMessageSetExtension1, rhs: ProtobufUnittest_TestMessageSetExtension1) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestMessageSetExtension1, rhs: SwiftProtoTesting_TestMessageSetExtension1) -> Bool { if lhs._i != rhs._i {return false} if lhs._recursive != rhs._recursive {return false} - if lhs._testAliasing != rhs._testAliasing {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestMessageSetExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_TestMessageSetExtension2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestMessageSetExtension2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 25: .same(proto: "str"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{19}str\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -395,18 +508,50 @@ extension ProtobufUnittest_TestMessageSetExtension2: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestMessageSetExtension2, rhs: ProtobufUnittest_TestMessageSetExtension2) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestMessageSetExtension2, rhs: SwiftProtoTesting_TestMessageSetExtension2) -> Bool { if lhs._str != rhs._str {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_RawMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_TestMessageSetExtension3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestMessageSetExtension3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{1a}x\0") + + 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 26: try { try decoder.decodeSingularInt32Field(value: &self._x) }() + 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 + try { if let v = self._x { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 26) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_TestMessageSetExtension3, rhs: SwiftProtoTesting_TestMessageSetExtension3) -> Bool { + if lhs._x != rhs._x {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_RawMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".RawMessageSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .unique(proto: "Item", json: "item"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{7}Item\0") public var isInitialized: Bool { if !SwiftProtobuf.Internal.areAllInitialized(self.item) {return false} @@ -432,19 +577,16 @@ extension ProtobufUnittest_RawMessageSet: SwiftProtobuf.Message, SwiftProtobuf._ try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_RawMessageSet, rhs: ProtobufUnittest_RawMessageSet) -> Bool { + static func ==(lhs: SwiftProtoTesting_RawMessageSet, rhs: SwiftProtoTesting_RawMessageSet) -> Bool { if lhs.item != rhs.item {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_RawMessageSet.Item: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_RawMessageSet.protoMessageName + ".Item" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2: .standard(proto: "type_id"), - 3: .same(proto: "message"), - ] +extension SwiftProtoTesting_RawMessageSet.Item: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_RawMessageSet.protoMessageName + ".Item" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{2}type_id\0\u{1}message\0") public var isInitialized: Bool { if self._typeID == nil {return false} @@ -479,10 +621,75 @@ extension ProtobufUnittest_RawMessageSet.Item: SwiftProtobuf.Message, SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_RawMessageSet.Item, rhs: ProtobufUnittest_RawMessageSet.Item) -> Bool { + static func ==(lhs: SwiftProtoTesting_RawMessageSet.Item, rhs: SwiftProtoTesting_RawMessageSet.Item) -> Bool { if lhs._typeID != rhs._typeID {return false} if lhs._message != rhs._message {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } + +extension SwiftProtoTesting_RawBreakableMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".RawBreakableMessageSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{7}Item\0") + + 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.decodeRepeatedGroupField(value: &self.item) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.item.isEmpty { + try visitor.visitRepeatedGroupField(value: self.item, fieldNumber: 1) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_RawBreakableMessageSet, rhs: SwiftProtoTesting_RawBreakableMessageSet) -> Bool { + if lhs.item != rhs.item {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_RawBreakableMessageSet.Item: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_RawBreakableMessageSet.protoMessageName + ".Item" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{2}type_id\0\u{1}message\0") + + 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 2: try { try decoder.decodeRepeatedInt32Field(value: &self.typeID) }() + case 3: try { try decoder.decodeRepeatedBytesField(value: &self.message) }() + default: break + } + } + } + + func traverse(visitor: inout V) throws { + if !self.typeID.isEmpty { + try visitor.visitRepeatedInt32Field(value: self.typeID, fieldNumber: 2) + } + if !self.message.isEmpty { + try visitor.visitRepeatedBytesField(value: self.message, fieldNumber: 3) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_RawBreakableMessageSet.Item, rhs: SwiftProtoTesting_RawBreakableMessageSet.Item) -> Bool { + if lhs.typeID != rhs.typeID {return false} + if lhs.message != rhs.message {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Tests/SwiftProtobufTests/unittest_mset_wire_format.pb.swift b/Tests/SwiftProtobufTests/unittest_mset_wire_format.pb.swift index c44d6e7a2..0f94f6c9d 100644 --- a/Tests/SwiftProtobufTests/unittest_mset_wire_format.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_mset_wire_format.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_mset_wire_format.proto +// Source: unittest_mset_wire_format.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -43,7 +44,6 @@ // // This file contains messages for testing message_set_wire_format. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -57,7 +57,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP } /// A message with message_set_wire_format. -struct Proto2WireformatUnittest_TestMessageSet: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_WireFormat_TestMessageSet: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -69,37 +69,11 @@ struct Proto2WireformatUnittest_TestMessageSet: SwiftProtobuf.ExtensibleMessage var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct Proto2WireformatUnittest_TestMessageSetWireFormatContainer { - // 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 messageSet: Proto2WireformatUnittest_TestMessageSet { - get {return _messageSet ?? Proto2WireformatUnittest_TestMessageSet()} - set {_messageSet = newValue} - } - /// Returns true if `messageSet` has been explicitly set. - var hasMessageSet: Bool {return self._messageSet != nil} - /// Clears the value of `messageSet`. Subsequent reads from it will return its default value. - mutating func clearMessageSet() {self._messageSet = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _messageSet: Proto2WireformatUnittest_TestMessageSet? = nil -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension Proto2WireformatUnittest_TestMessageSet: @unchecked Sendable {} -extension Proto2WireformatUnittest_TestMessageSetWireFormatContainer: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "proto2_wireformat_unittest" +fileprivate let _protobuf_package = "swift_proto_testing.wire_format" -extension Proto2WireformatUnittest_TestMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_WireFormat_TestMessageSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestMessageSet" static let _protobuf_nameMap = SwiftProtobuf._NameMap() @@ -109,7 +83,7 @@ extension Proto2WireformatUnittest_TestMessageSet: SwiftProtobuf.Message, SwiftP } mutating func decodeMessage(decoder: inout D) throws { - try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: Proto2WireformatUnittest_TestMessageSet.self) + try decoder.decodeExtensionFieldsAsMessageSet(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_WireFormat_TestMessageSet.self) } func traverse(visitor: inout V) throws { @@ -117,50 +91,9 @@ extension Proto2WireformatUnittest_TestMessageSet: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto2WireformatUnittest_TestMessageSet, rhs: Proto2WireformatUnittest_TestMessageSet) -> Bool { + static func ==(lhs: SwiftProtoTesting_WireFormat_TestMessageSet, rhs: SwiftProtoTesting_WireFormat_TestMessageSet) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } - -extension Proto2WireformatUnittest_TestMessageSetWireFormatContainer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMessageSetWireFormatContainer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "message_set"), - ] - - public var isInitialized: Bool { - if let v = self._messageSet, !v.isInitialized {return false} - return true - } - - 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.decodeSingularMessageField(value: &self._messageSet) }() - 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 - try { if let v = self._messageSet { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: Proto2WireformatUnittest_TestMessageSetWireFormatContainer, rhs: Proto2WireformatUnittest_TestMessageSetWireFormatContainer) -> Bool { - if lhs._messageSet != rhs._messageSet {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Tests/SwiftProtobufTests/unittest_no_generic_services.pb.swift b/Tests/SwiftProtobufTests/unittest_no_generic_services.pb.swift deleted file mode 100644 index 536191da6..000000000 --- a/Tests/SwiftProtobufTests/unittest_no_generic_services.pb.swift +++ /dev/null @@ -1,213 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_no_generic_services.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Author: kenton@google.com (Kenton Varda) - -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 ProtobufUnittest_NoGenericServicesTest_TestEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 1 - - init() { - self = .foo - } - - init?(rawValue: Int) { - switch rawValue { - case 1: self = .foo - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo: return 1 - } - } - -} - -#if swift(>=4.2) - -extension ProtobufUnittest_NoGenericServicesTest_TestEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_NoGenericServicesTest_TestMessage: 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 a: Int32 { - get {return _a ?? 0} - set {_a = newValue} - } - /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} - /// Clears the value of `a`. Subsequent reads from it will return its default value. - mutating func clearA() {self._a = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() - fileprivate var _a: Int32? = nil -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_NoGenericServicesTest_TestEnum: @unchecked Sendable {} -extension ProtobufUnittest_NoGenericServicesTest_TestMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Extension support defined in unittest_no_generic_services.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 ProtobufUnittest_NoGenericServicesTest_TestMessage { - - var ProtobufUnittest_NoGenericServicesTest_testExtension: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_NoGenericServicesTest_Extensions_test_extension) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_NoGenericServicesTest_Extensions_test_extension, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_NoGenericServicesTest_Extensions_test_extension` - /// has been explicitly set. - var hasProtobufUnittest_NoGenericServicesTest_testExtension: Bool { - return hasExtensionValue(ext: ProtobufUnittest_NoGenericServicesTest_Extensions_test_extension) - } - /// Clears the value of extension `ProtobufUnittest_NoGenericServicesTest_Extensions_test_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_NoGenericServicesTest_testExtension() { - clearExtensionValue(ext: ProtobufUnittest_NoGenericServicesTest_Extensions_test_extension) - } - -} - -// MARK: - File's ExtensionMap: ProtobufUnittest_NoGenericServicesTest_UnittestNoGenericServices_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 ProtobufUnittest_NoGenericServicesTest_UnittestNoGenericServices_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_NoGenericServicesTest_Extensions_test_extension -] - -// 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 ProtobufUnittest_NoGenericServicesTest_Extensions_test_extension = SwiftProtobuf.MessageExtension, ProtobufUnittest_NoGenericServicesTest_TestMessage>( - _protobuf_fieldNumber: 1000, - fieldName: "protobuf_unittest.no_generic_services_test.test_extension" -) - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_unittest.no_generic_services_test" - -extension ProtobufUnittest_NoGenericServicesTest_TestEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FOO"), - ] -} - -extension ProtobufUnittest_NoGenericServicesTest_TestMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - 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._a) }() - case 1000..<536870912: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_NoGenericServicesTest_TestMessage.self, fieldNumber: fieldNumber) }() - 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 - try { if let v = self._a { - try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) - } }() - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1000, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_NoGenericServicesTest_TestMessage, rhs: ProtobufUnittest_NoGenericServicesTest_TestMessage) -> Bool { - if lhs._a != rhs._a {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} diff --git a/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum.pb.swift b/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum.pb.swift index d5f420d0f..a2b0d5e2a 100644 --- a/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_preserve_unknown_enum.proto +// Source: unittest_preserve_unknown_enum.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -37,7 +38,6 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -50,7 +50,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum Proto3PreserveUnknownEnumUnittest_MyEnum: SwiftProtobuf.Enum { +enum SwiftProtoTesting_UnknownEnum_Proto3_MyEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foo // = 0 case bar // = 1 @@ -79,22 +79,16 @@ enum Proto3PreserveUnknownEnumUnittest_MyEnum: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension Proto3PreserveUnknownEnumUnittest_MyEnum: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto3PreserveUnknownEnumUnittest_MyEnum] = [ + static let allCases: [SwiftProtoTesting_UnknownEnum_Proto3_MyEnum] = [ .foo, .bar, .baz, ] -} -#endif // swift(>=4.2) +} -enum Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra: SwiftProtobuf.Enum { +enum SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case eFoo // = 0 case eBar // = 1 @@ -126,39 +120,33 @@ enum Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra] = [ + static let allCases: [SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra] = [ .eFoo, .eBar, .eBaz, .eExtra, ] -} -#endif // swift(>=4.2) +} -struct Proto3PreserveUnknownEnumUnittest_MyMessage { +struct SwiftProtoTesting_UnknownEnum_Proto3_MyMessage: Sendable { // 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 e: Proto3PreserveUnknownEnumUnittest_MyEnum = .foo + var e: SwiftProtoTesting_UnknownEnum_Proto3_MyEnum = .foo - var repeatedE: [Proto3PreserveUnknownEnumUnittest_MyEnum] = [] + var repeatedE: [SwiftProtoTesting_UnknownEnum_Proto3_MyEnum] = [] - var repeatedPackedE: [Proto3PreserveUnknownEnumUnittest_MyEnum] = [] + var repeatedPackedE: [SwiftProtoTesting_UnknownEnum_Proto3_MyEnum] = [] /// not packed - var repeatedPackedUnexpectedE: [Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra] = [] + var repeatedPackedUnexpectedE: [SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra] = [] - var o: Proto3PreserveUnknownEnumUnittest_MyMessage.OneOf_O? = nil + var o: SwiftProtoTesting_UnknownEnum_Proto3_MyMessage.OneOf_O? = nil - var oneofE1: Proto3PreserveUnknownEnumUnittest_MyEnum { + var oneofE1: SwiftProtoTesting_UnknownEnum_Proto3_MyEnum { get { if case .oneofE1(let v)? = o {return v} return .foo @@ -166,7 +154,7 @@ struct Proto3PreserveUnknownEnumUnittest_MyMessage { set {o = .oneofE1(newValue)} } - var oneofE2: Proto3PreserveUnknownEnumUnittest_MyEnum { + var oneofE2: SwiftProtoTesting_UnknownEnum_Proto3_MyEnum { get { if case .oneofE2(let v)? = o {return v} return .foo @@ -176,49 +164,31 @@ struct Proto3PreserveUnknownEnumUnittest_MyMessage { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_O: Equatable { - case oneofE1(Proto3PreserveUnknownEnumUnittest_MyEnum) - case oneofE2(Proto3PreserveUnknownEnumUnittest_MyEnum) + enum OneOf_O: Equatable, Sendable { + case oneofE1(SwiftProtoTesting_UnknownEnum_Proto3_MyEnum) + case oneofE2(SwiftProtoTesting_UnknownEnum_Proto3_MyEnum) - #if !swift(>=4.1) - static func ==(lhs: Proto3PreserveUnknownEnumUnittest_MyMessage.OneOf_O, rhs: Proto3PreserveUnknownEnumUnittest_MyMessage.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 (.oneofE1, .oneofE1): return { - guard case .oneofE1(let l) = lhs, case .oneofE1(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofE2, .oneofE2): return { - guard case .oneofE2(let l) = lhs, case .oneofE2(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } init() {} } -struct Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra { +struct SwiftProtoTesting_UnknownEnum_Proto3_MyMessagePlusExtra: Sendable { // 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 e: Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra = .eFoo + var e: SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra = .eFoo - var repeatedE: [Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra] = [] + var repeatedE: [SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra] = [] - var repeatedPackedE: [Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra] = [] + var repeatedPackedE: [SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra] = [] - var repeatedPackedUnexpectedE: [Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra] = [] + var repeatedPackedUnexpectedE: [SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra] = [] - var o: Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra.OneOf_O? = nil + var o: SwiftProtoTesting_UnknownEnum_Proto3_MyMessagePlusExtra.OneOf_O? = nil - var oneofE1: Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra { + var oneofE1: SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra { get { if case .oneofE1(let v)? = o {return v} return .eFoo @@ -226,7 +196,7 @@ struct Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra { set {o = .oneofE1(newValue)} } - var oneofE2: Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra { + var oneofE2: SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra { get { if case .oneofE2(let v)? = o {return v} return .eFoo @@ -236,73 +206,30 @@ struct Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_O: Equatable { - case oneofE1(Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra) - case oneofE2(Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra) + enum OneOf_O: Equatable, Sendable { + case oneofE1(SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra) + case oneofE2(SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra) - #if !swift(>=4.1) - static func ==(lhs: Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra.OneOf_O, rhs: Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra.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 (.oneofE1, .oneofE1): return { - guard case .oneofE1(let l) = lhs, case .oneofE1(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofE2, .oneofE2): return { - guard case .oneofE2(let l) = lhs, case .oneofE2(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension Proto3PreserveUnknownEnumUnittest_MyEnum: @unchecked Sendable {} -extension Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra: @unchecked Sendable {} -extension Proto3PreserveUnknownEnumUnittest_MyMessage: @unchecked Sendable {} -extension Proto3PreserveUnknownEnumUnittest_MyMessage.OneOf_O: @unchecked Sendable {} -extension Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra: @unchecked Sendable {} -extension Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra.OneOf_O: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "proto3_preserve_unknown_enum_unittest" +fileprivate let _protobuf_package = "swift_proto_testing.unknown_enum.proto3" -extension Proto3PreserveUnknownEnumUnittest_MyEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - ] +extension SwiftProtoTesting_UnknownEnum_Proto3_MyEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOO\0\u{1}BAR\0\u{1}BAZ\0") } -extension Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "E_FOO"), - 1: .same(proto: "E_BAR"), - 2: .same(proto: "E_BAZ"), - 3: .same(proto: "E_EXTRA"), - ] +extension SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0E_FOO\0\u{1}E_BAR\0\u{1}E_BAZ\0\u{1}E_EXTRA\0") } -extension Proto3PreserveUnknownEnumUnittest_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_UnknownEnum_Proto3_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MyMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "e"), - 2: .standard(proto: "repeated_e"), - 3: .standard(proto: "repeated_packed_e"), - 4: .standard(proto: "repeated_packed_unexpected_e"), - 5: .standard(proto: "oneof_e_1"), - 6: .standard(proto: "oneof_e_2"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}e\0\u{3}repeated_e\0\u{3}repeated_packed_e\0\u{3}repeated_packed_unexpected_e\0\u{3}oneof_e_1\0\u{3}oneof_e_2\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -315,7 +242,7 @@ extension Proto3PreserveUnknownEnumUnittest_MyMessage: SwiftProtobuf.Message, Sw case 3: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedPackedE) }() case 4: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedPackedUnexpectedE) }() case 5: try { - var v: Proto3PreserveUnknownEnumUnittest_MyEnum? + var v: SwiftProtoTesting_UnknownEnum_Proto3_MyEnum? try decoder.decodeSingularEnumField(value: &v) if let v = v { if self.o != nil {try decoder.handleConflictingOneOf()} @@ -323,7 +250,7 @@ extension Proto3PreserveUnknownEnumUnittest_MyMessage: SwiftProtobuf.Message, Sw } }() case 6: try { - var v: Proto3PreserveUnknownEnumUnittest_MyEnum? + var v: SwiftProtoTesting_UnknownEnum_Proto3_MyEnum? try decoder.decodeSingularEnumField(value: &v) if let v = v { if self.o != nil {try decoder.handleConflictingOneOf()} @@ -366,7 +293,7 @@ extension Proto3PreserveUnknownEnumUnittest_MyMessage: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3PreserveUnknownEnumUnittest_MyMessage, rhs: Proto3PreserveUnknownEnumUnittest_MyMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_UnknownEnum_Proto3_MyMessage, rhs: SwiftProtoTesting_UnknownEnum_Proto3_MyMessage) -> Bool { if lhs.e != rhs.e {return false} if lhs.repeatedE != rhs.repeatedE {return false} if lhs.repeatedPackedE != rhs.repeatedPackedE {return false} @@ -377,16 +304,9 @@ extension Proto3PreserveUnknownEnumUnittest_MyMessage: SwiftProtobuf.Message, Sw } } -extension Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_UnknownEnum_Proto3_MyMessagePlusExtra: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MyMessagePlusExtra" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "e"), - 2: .standard(proto: "repeated_e"), - 3: .standard(proto: "repeated_packed_e"), - 4: .standard(proto: "repeated_packed_unexpected_e"), - 5: .standard(proto: "oneof_e_1"), - 6: .standard(proto: "oneof_e_2"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}e\0\u{3}repeated_e\0\u{3}repeated_packed_e\0\u{3}repeated_packed_unexpected_e\0\u{3}oneof_e_1\0\u{3}oneof_e_2\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -399,7 +319,7 @@ extension Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra: SwiftProtobuf.Me case 3: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedPackedE) }() case 4: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedPackedUnexpectedE) }() case 5: try { - var v: Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra? + var v: SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra? try decoder.decodeSingularEnumField(value: &v) if let v = v { if self.o != nil {try decoder.handleConflictingOneOf()} @@ -407,7 +327,7 @@ extension Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra: SwiftProtobuf.Me } }() case 6: try { - var v: Proto3PreserveUnknownEnumUnittest_MyEnumPlusExtra? + var v: SwiftProtoTesting_UnknownEnum_Proto3_MyEnumPlusExtra? try decoder.decodeSingularEnumField(value: &v) if let v = v { if self.o != nil {try decoder.handleConflictingOneOf()} @@ -450,7 +370,7 @@ extension Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra: SwiftProtobuf.Me try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra, rhs: Proto3PreserveUnknownEnumUnittest_MyMessagePlusExtra) -> Bool { + static func ==(lhs: SwiftProtoTesting_UnknownEnum_Proto3_MyMessagePlusExtra, rhs: SwiftProtoTesting_UnknownEnum_Proto3_MyMessagePlusExtra) -> Bool { if lhs.e != rhs.e {return false} if lhs.repeatedE != rhs.repeatedE {return false} if lhs.repeatedPackedE != rhs.repeatedPackedE {return false} diff --git a/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum2.pb.swift b/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum2.pb.swift index afa3f8b27..87e2ba7ec 100644 --- a/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum2.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_preserve_unknown_enum2.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_preserve_unknown_enum2.proto +// Source: unittest_preserve_unknown_enum2.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -37,7 +38,6 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -50,67 +50,41 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum Proto2PreserveUnknownEnumUnittest_MyEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 0 - case bar // = 1 - case baz // = 2 +enum SwiftProtoTesting_UnknownEnum_Proto2_MyEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 init() { self = .foo } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .foo - case 1: self = .bar - case 2: self = .baz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo: return 0 - case .bar: return 1 - case .baz: return 2 - } - } - -} - -#if swift(>=4.2) - -extension Proto2PreserveUnknownEnumUnittest_MyEnum: CaseIterable { - // Support synthesized by the compiler. } -#endif // swift(>=4.2) - -struct Proto2PreserveUnknownEnumUnittest_MyMessage { +struct SwiftProtoTesting_UnknownEnum_Proto2_MyMessage: Sendable { // 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 e: Proto2PreserveUnknownEnumUnittest_MyEnum { - get {return _e ?? .foo} + var e: SwiftProtoTesting_UnknownEnum_Proto2_MyEnum { + get {_e ?? .foo} set {_e = newValue} } /// Returns true if `e` has been explicitly set. - var hasE: Bool {return self._e != nil} + var hasE: Bool {self._e != nil} /// Clears the value of `e`. Subsequent reads from it will return its default value. mutating func clearE() {self._e = nil} - var repeatedE: [Proto2PreserveUnknownEnumUnittest_MyEnum] = [] + var repeatedE: [SwiftProtoTesting_UnknownEnum_Proto2_MyEnum] = [] - var repeatedPackedE: [Proto2PreserveUnknownEnumUnittest_MyEnum] = [] + var repeatedPackedE: [SwiftProtoTesting_UnknownEnum_Proto2_MyEnum] = [] /// not packed - var repeatedPackedUnexpectedE: [Proto2PreserveUnknownEnumUnittest_MyEnum] = [] + var repeatedPackedUnexpectedE: [SwiftProtoTesting_UnknownEnum_Proto2_MyEnum] = [] - var o: Proto2PreserveUnknownEnumUnittest_MyMessage.OneOf_O? = nil + var o: SwiftProtoTesting_UnknownEnum_Proto2_MyMessage.OneOf_O? = nil - var oneofE1: Proto2PreserveUnknownEnumUnittest_MyEnum { + var oneofE1: SwiftProtoTesting_UnknownEnum_Proto2_MyEnum { get { if case .oneofE1(let v)? = o {return v} return .foo @@ -118,7 +92,7 @@ struct Proto2PreserveUnknownEnumUnittest_MyMessage { set {o = .oneofE1(newValue)} } - var oneofE2: Proto2PreserveUnknownEnumUnittest_MyEnum { + var oneofE2: SwiftProtoTesting_UnknownEnum_Proto2_MyEnum { get { if case .oneofE2(let v)? = o {return v} return .foo @@ -128,63 +102,28 @@ struct Proto2PreserveUnknownEnumUnittest_MyMessage { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_O: Equatable { - case oneofE1(Proto2PreserveUnknownEnumUnittest_MyEnum) - case oneofE2(Proto2PreserveUnknownEnumUnittest_MyEnum) + enum OneOf_O: Equatable, Sendable { + case oneofE1(SwiftProtoTesting_UnknownEnum_Proto2_MyEnum) + case oneofE2(SwiftProtoTesting_UnknownEnum_Proto2_MyEnum) - #if !swift(>=4.1) - static func ==(lhs: Proto2PreserveUnknownEnumUnittest_MyMessage.OneOf_O, rhs: Proto2PreserveUnknownEnumUnittest_MyMessage.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 (.oneofE1, .oneofE1): return { - guard case .oneofE1(let l) = lhs, case .oneofE1(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofE2, .oneofE2): return { - guard case .oneofE2(let l) = lhs, case .oneofE2(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } init() {} - fileprivate var _e: Proto2PreserveUnknownEnumUnittest_MyEnum? = nil + fileprivate var _e: SwiftProtoTesting_UnknownEnum_Proto2_MyEnum? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension Proto2PreserveUnknownEnumUnittest_MyEnum: @unchecked Sendable {} -extension Proto2PreserveUnknownEnumUnittest_MyMessage: @unchecked Sendable {} -extension Proto2PreserveUnknownEnumUnittest_MyMessage.OneOf_O: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "proto2_preserve_unknown_enum_unittest" +fileprivate let _protobuf_package = "swift_proto_testing.unknown_enum.proto2" -extension Proto2PreserveUnknownEnumUnittest_MyEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - ] +extension SwiftProtoTesting_UnknownEnum_Proto2_MyEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOO\0\u{1}BAR\0\u{1}BAZ\0") } -extension Proto2PreserveUnknownEnumUnittest_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_UnknownEnum_Proto2_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MyMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "e"), - 2: .standard(proto: "repeated_e"), - 3: .standard(proto: "repeated_packed_e"), - 4: .standard(proto: "repeated_packed_unexpected_e"), - 5: .standard(proto: "oneof_e_1"), - 6: .standard(proto: "oneof_e_2"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}e\0\u{3}repeated_e\0\u{3}repeated_packed_e\0\u{3}repeated_packed_unexpected_e\0\u{3}oneof_e_1\0\u{3}oneof_e_2\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -197,7 +136,7 @@ extension Proto2PreserveUnknownEnumUnittest_MyMessage: SwiftProtobuf.Message, Sw case 3: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedPackedE) }() case 4: try { try decoder.decodeRepeatedEnumField(value: &self.repeatedPackedUnexpectedE) }() case 5: try { - var v: Proto2PreserveUnknownEnumUnittest_MyEnum? + var v: SwiftProtoTesting_UnknownEnum_Proto2_MyEnum? try decoder.decodeSingularEnumField(value: &v) if let v = v { if self.o != nil {try decoder.handleConflictingOneOf()} @@ -205,7 +144,7 @@ extension Proto2PreserveUnknownEnumUnittest_MyMessage: SwiftProtobuf.Message, Sw } }() case 6: try { - var v: Proto2PreserveUnknownEnumUnittest_MyEnum? + var v: SwiftProtoTesting_UnknownEnum_Proto2_MyEnum? try decoder.decodeSingularEnumField(value: &v) if let v = v { if self.o != nil {try decoder.handleConflictingOneOf()} @@ -248,7 +187,7 @@ extension Proto2PreserveUnknownEnumUnittest_MyMessage: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto2PreserveUnknownEnumUnittest_MyMessage, rhs: Proto2PreserveUnknownEnumUnittest_MyMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_UnknownEnum_Proto2_MyMessage, rhs: SwiftProtoTesting_UnknownEnum_Proto2_MyMessage) -> Bool { if lhs._e != rhs._e {return false} if lhs.repeatedE != rhs.repeatedE {return false} if lhs.repeatedPackedE != rhs.repeatedPackedE {return false} diff --git a/Tests/SwiftProtobufTests/unittest_proto3.pb.swift b/Tests/SwiftProtobufTests/unittest_proto3.pb.swift index d847df7fc..b27fa0d4d 100644 --- a/Tests/SwiftProtobufTests/unittest_proto3.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_proto3.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_proto3.proto +// Source: unittest_proto3.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -50,7 +51,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum Proto3Unittest_ForeignEnum: SwiftProtobuf.Enum { +enum SwiftProtoTesting_Proto3_ForeignEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foreignZero // = 0 case foreignFoo // = 4 @@ -82,296 +83,247 @@ enum Proto3Unittest_ForeignEnum: SwiftProtobuf.Enum { } } -} - -#if swift(>=4.2) - -extension Proto3Unittest_ForeignEnum: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto3Unittest_ForeignEnum] = [ + static let allCases: [SwiftProtoTesting_Proto3_ForeignEnum] = [ .foreignZero, .foreignFoo, .foreignBar, .foreignBaz, ] -} -#endif // swift(>=4.2) +} /// This proto includes every type of field in both singular and repeated /// forms. -struct Proto3Unittest_TestAllTypes { +struct SwiftProtoTesting_Proto3_TestAllTypes: @unchecked Sendable { // 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. /// Singular var optionalInt32: Int32 { - get {return _storage._optionalInt32} + get {_storage._optionalInt32} set {_uniqueStorage()._optionalInt32 = newValue} } var optionalInt64: Int64 { - get {return _storage._optionalInt64} + get {_storage._optionalInt64} set {_uniqueStorage()._optionalInt64 = newValue} } var optionalUint32: UInt32 { - get {return _storage._optionalUint32} + get {_storage._optionalUint32} set {_uniqueStorage()._optionalUint32 = newValue} } var optionalUint64: UInt64 { - get {return _storage._optionalUint64} + get {_storage._optionalUint64} set {_uniqueStorage()._optionalUint64 = newValue} } var optionalSint32: Int32 { - get {return _storage._optionalSint32} + get {_storage._optionalSint32} set {_uniqueStorage()._optionalSint32 = newValue} } var optionalSint64: Int64 { - get {return _storage._optionalSint64} + get {_storage._optionalSint64} set {_uniqueStorage()._optionalSint64 = newValue} } var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32} + get {_storage._optionalFixed32} set {_uniqueStorage()._optionalFixed32 = newValue} } var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64} + get {_storage._optionalFixed64} set {_uniqueStorage()._optionalFixed64 = newValue} } var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32} + get {_storage._optionalSfixed32} set {_uniqueStorage()._optionalSfixed32 = newValue} } var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64} + get {_storage._optionalSfixed64} set {_uniqueStorage()._optionalSfixed64 = newValue} } var optionalFloat: Float { - get {return _storage._optionalFloat} + get {_storage._optionalFloat} set {_uniqueStorage()._optionalFloat = newValue} } var optionalDouble: Double { - get {return _storage._optionalDouble} + get {_storage._optionalDouble} set {_uniqueStorage()._optionalDouble = newValue} } var optionalBool: Bool { - get {return _storage._optionalBool} + get {_storage._optionalBool} set {_uniqueStorage()._optionalBool = newValue} } var optionalString: String { - get {return _storage._optionalString} + get {_storage._optionalString} set {_uniqueStorage()._optionalString = newValue} } var optionalBytes: Data { - get {return _storage._optionalBytes} + get {_storage._optionalBytes} set {_uniqueStorage()._optionalBytes = newValue} } - var optionalNestedMessage: Proto3Unittest_TestAllTypes.NestedMessage { - get {return _storage._optionalNestedMessage ?? Proto3Unittest_TestAllTypes.NestedMessage()} + var optionalNestedMessage: SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage { + get {_storage._optionalNestedMessage ?? SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage()} set {_uniqueStorage()._optionalNestedMessage = newValue} } /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} - var optionalForeignMessage: Proto3Unittest_ForeignMessage { - get {return _storage._optionalForeignMessage ?? Proto3Unittest_ForeignMessage()} + var optionalForeignMessage: SwiftProtoTesting_Proto3_ForeignMessage { + get {_storage._optionalForeignMessage ?? SwiftProtoTesting_Proto3_ForeignMessage()} set {_uniqueStorage()._optionalForeignMessage = newValue} } /// Returns true if `optionalForeignMessage` has been explicitly set. - var hasOptionalForeignMessage: Bool {return _storage._optionalForeignMessage != nil} + var hasOptionalForeignMessage: Bool {_storage._optionalForeignMessage != nil} /// Clears the value of `optionalForeignMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalForeignMessage() {_uniqueStorage()._optionalForeignMessage = nil} - var optionalImportMessage: ProtobufUnittestImport_ImportMessage { - get {return _storage._optionalImportMessage ?? ProtobufUnittestImport_ImportMessage()} + var optionalImportMessage: SwiftProtoTesting_Import_ImportMessage { + get {_storage._optionalImportMessage ?? SwiftProtoTesting_Import_ImportMessage()} set {_uniqueStorage()._optionalImportMessage = newValue} } /// Returns true if `optionalImportMessage` has been explicitly set. - var hasOptionalImportMessage: Bool {return _storage._optionalImportMessage != nil} + var hasOptionalImportMessage: Bool {_storage._optionalImportMessage != nil} /// Clears the value of `optionalImportMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalImportMessage() {_uniqueStorage()._optionalImportMessage = nil} - var optionalNestedEnum: Proto3Unittest_TestAllTypes.NestedEnum { - get {return _storage._optionalNestedEnum} + var optionalNestedEnum: SwiftProtoTesting_Proto3_TestAllTypes.NestedEnum { + get {_storage._optionalNestedEnum} set {_uniqueStorage()._optionalNestedEnum = newValue} } - var optionalForeignEnum: Proto3Unittest_ForeignEnum { - get {return _storage._optionalForeignEnum} + var optionalForeignEnum: SwiftProtoTesting_Proto3_ForeignEnum { + get {_storage._optionalForeignEnum} set {_uniqueStorage()._optionalForeignEnum = newValue} } - var optionalStringPiece: String { - get {return _storage._optionalStringPiece} - set {_uniqueStorage()._optionalStringPiece = newValue} - } - - var optionalCord: String { - get {return _storage._optionalCord} - set {_uniqueStorage()._optionalCord = newValue} - } - /// Defined in unittest_import_public.proto - var optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessage { - get {return _storage._optionalPublicImportMessage ?? ProtobufUnittestImport_PublicImportMessage()} + var optionalPublicImportMessage: SwiftProtoTesting_Import_PublicImportMessage { + get {_storage._optionalPublicImportMessage ?? SwiftProtoTesting_Import_PublicImportMessage()} set {_uniqueStorage()._optionalPublicImportMessage = newValue} } /// Returns true if `optionalPublicImportMessage` has been explicitly set. - var hasOptionalPublicImportMessage: Bool {return _storage._optionalPublicImportMessage != nil} + var hasOptionalPublicImportMessage: Bool {_storage._optionalPublicImportMessage != nil} /// Clears the value of `optionalPublicImportMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalPublicImportMessage() {_uniqueStorage()._optionalPublicImportMessage = nil} - var optionalLazyMessage: Proto3Unittest_TestAllTypes.NestedMessage { - get {return _storage._optionalLazyMessage ?? Proto3Unittest_TestAllTypes.NestedMessage()} - set {_uniqueStorage()._optionalLazyMessage = newValue} - } - /// Returns true if `optionalLazyMessage` has been explicitly set. - var hasOptionalLazyMessage: Bool {return _storage._optionalLazyMessage != nil} - /// Clears the value of `optionalLazyMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalLazyMessage() {_uniqueStorage()._optionalLazyMessage = nil} - - var optionalLazyImportMessage: ProtobufUnittestImport_ImportMessage { - get {return _storage._optionalLazyImportMessage ?? ProtobufUnittestImport_ImportMessage()} - set {_uniqueStorage()._optionalLazyImportMessage = newValue} - } - /// Returns true if `optionalLazyImportMessage` has been explicitly set. - var hasOptionalLazyImportMessage: Bool {return _storage._optionalLazyImportMessage != nil} - /// Clears the value of `optionalLazyImportMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalLazyImportMessage() {_uniqueStorage()._optionalLazyImportMessage = nil} - /// Repeated var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } - var repeatedNestedMessage: [Proto3Unittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedNestedMessage} + var repeatedNestedMessage: [SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage] { + get {_storage._repeatedNestedMessage} set {_uniqueStorage()._repeatedNestedMessage = newValue} } - var repeatedForeignMessage: [Proto3Unittest_ForeignMessage] { - get {return _storage._repeatedForeignMessage} + var repeatedForeignMessage: [SwiftProtoTesting_Proto3_ForeignMessage] { + get {_storage._repeatedForeignMessage} set {_uniqueStorage()._repeatedForeignMessage = newValue} } - var repeatedImportMessage: [ProtobufUnittestImport_ImportMessage] { - get {return _storage._repeatedImportMessage} + var repeatedImportMessage: [SwiftProtoTesting_Import_ImportMessage] { + get {_storage._repeatedImportMessage} set {_uniqueStorage()._repeatedImportMessage = newValue} } - var repeatedNestedEnum: [Proto3Unittest_TestAllTypes.NestedEnum] { - get {return _storage._repeatedNestedEnum} + var repeatedNestedEnum: [SwiftProtoTesting_Proto3_TestAllTypes.NestedEnum] { + get {_storage._repeatedNestedEnum} set {_uniqueStorage()._repeatedNestedEnum = newValue} } - var repeatedForeignEnum: [Proto3Unittest_ForeignEnum] { - get {return _storage._repeatedForeignEnum} + var repeatedForeignEnum: [SwiftProtoTesting_Proto3_ForeignEnum] { + get {_storage._repeatedForeignEnum} set {_uniqueStorage()._repeatedForeignEnum = newValue} } - var repeatedStringPiece: [String] { - get {return _storage._repeatedStringPiece} - set {_uniqueStorage()._repeatedStringPiece = newValue} - } - - var repeatedCord: [String] { - get {return _storage._repeatedCord} - set {_uniqueStorage()._repeatedCord = newValue} - } - - var repeatedLazyMessage: [Proto3Unittest_TestAllTypes.NestedMessage] { - get {return _storage._repeatedLazyMessage} - set {_uniqueStorage()._repeatedLazyMessage = newValue} - } - var oneofField: OneOf_OneofField? { get {return _storage._oneofField} set {_uniqueStorage()._oneofField = newValue} @@ -385,10 +337,10 @@ struct Proto3Unittest_TestAllTypes { set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} } - var oneofNestedMessage: Proto3Unittest_TestAllTypes.NestedMessage { + var oneofNestedMessage: SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage { get { if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} - return Proto3Unittest_TestAllTypes.NestedMessage() + return SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage() } set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} } @@ -411,41 +363,15 @@ struct Proto3Unittest_TestAllTypes { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case oneofUint32(UInt32) - case oneofNestedMessage(Proto3Unittest_TestAllTypes.NestedMessage) + case oneofNestedMessage(SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage) case oneofString(String) case oneofBytes(Data) - #if !swift(>=4.1) - static func ==(lhs: Proto3Unittest_TestAllTypes.OneOf_OneofField, rhs: Proto3Unittest_TestAllTypes.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum NestedEnum: SwiftProtobuf.Enum { + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case zero // = 0 case foo // = 1 @@ -482,9 +408,18 @@ struct Proto3Unittest_TestAllTypes { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Proto3_TestAllTypes.NestedEnum] = [ + .zero, + .foo, + .bar, + .baz, + .neg, + ] + } - struct NestedMessage { + struct NestedMessage: Sendable { // 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. @@ -504,22 +439,7 @@ struct Proto3Unittest_TestAllTypes { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension Proto3Unittest_TestAllTypes.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto3Unittest_TestAllTypes.NestedEnum] = [ - .zero, - .foo, - .bar, - .baz, - .neg, - ] -} - -#endif // swift(>=4.2) - -struct Proto3Unittest_TestPackedTypes { +struct SwiftProtoTesting_Proto3_TestPackedTypes: Sendable { // 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. @@ -550,7 +470,7 @@ struct Proto3Unittest_TestPackedTypes { var packedBool: [Bool] = [] - var packedEnum: [Proto3Unittest_ForeignEnum] = [] + var packedEnum: [SwiftProtoTesting_Proto3_ForeignEnum] = [] var unknownFields = SwiftProtobuf.UnknownStorage() @@ -558,7 +478,7 @@ struct Proto3Unittest_TestPackedTypes { } /// Explicitly set packed to false -struct Proto3Unittest_TestUnpackedTypes { +struct SwiftProtoTesting_Proto3_TestUnpackedTypes: Sendable { // 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. @@ -589,7 +509,7 @@ struct Proto3Unittest_TestUnpackedTypes { var repeatedBool: [Bool] = [] - var repeatedNestedEnum: [Proto3Unittest_TestAllTypes.NestedEnum] = [] + var repeatedNestedEnum: [SwiftProtoTesting_Proto3_TestAllTypes.NestedEnum] = [] var unknownFields = SwiftProtobuf.UnknownStorage() @@ -597,26 +517,26 @@ struct Proto3Unittest_TestUnpackedTypes { } /// This proto includes a recursively nested message. -struct Proto3Unittest_NestedTestAllTypes { +struct SwiftProtoTesting_Proto3_NestedTestAllTypes: @unchecked Sendable { // 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 child: Proto3Unittest_NestedTestAllTypes { - get {return _storage._child ?? Proto3Unittest_NestedTestAllTypes()} + var child: SwiftProtoTesting_Proto3_NestedTestAllTypes { + get {_storage._child ?? SwiftProtoTesting_Proto3_NestedTestAllTypes()} set {_uniqueStorage()._child = newValue} } /// Returns true if `child` has been explicitly set. - var hasChild: Bool {return _storage._child != nil} + var hasChild: Bool {_storage._child != nil} /// Clears the value of `child`. Subsequent reads from it will return its default value. mutating func clearChild() {_uniqueStorage()._child = nil} - var payload: Proto3Unittest_TestAllTypes { - get {return _storage._payload ?? Proto3Unittest_TestAllTypes()} + var payload: SwiftProtoTesting_Proto3_TestAllTypes { + get {_storage._payload ?? SwiftProtoTesting_Proto3_TestAllTypes()} set {_uniqueStorage()._payload = newValue} } /// Returns true if `payload` has been explicitly set. - var hasPayload: Bool {return _storage._payload != nil} + var hasPayload: Bool {_storage._payload != nil} /// Clears the value of `payload`. Subsequent reads from it will return its default value. mutating func clearPayload() {_uniqueStorage()._payload = nil} @@ -629,7 +549,7 @@ struct Proto3Unittest_NestedTestAllTypes { /// Define these after TestAllTypes to make sure the compiler can handle /// that. -struct Proto3Unittest_ForeignMessage { +struct SwiftProtoTesting_Proto3_ForeignMessage: Sendable { // 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. @@ -642,7 +562,7 @@ struct Proto3Unittest_ForeignMessage { } /// TestEmptyMessage is used to test behavior of unknown fields. -struct Proto3Unittest_TestEmptyMessage { +struct SwiftProtoTesting_Proto3_TestEmptyMessage: Sendable { // 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. @@ -652,195 +572,39 @@ struct Proto3Unittest_TestEmptyMessage { init() {} } -/// TestMessageWithDummy is also used to test behavior of unknown fields. -struct Proto3Unittest_TestMessageWithDummy { +/// Test a proto3 defined message with a proto2 as a field that has required fields. +struct SwiftProtoTesting_Proto3_TestProto2Required: Sendable { // 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. - /// This field is only here for triggering copy-on-write; it's not intended to - /// be serialized. - var dummy: Bool = false - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} -} - -/// Same layout as TestOneof2 in unittest.proto to test unknown enum value -/// parsing behavior in oneof. -struct Proto3Unittest_TestOneof2 { - // 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 foo: Proto3Unittest_TestOneof2.OneOf_Foo? = nil - - var fooEnum: Proto3Unittest_TestOneof2.NestedEnum { - get { - if case .fooEnum(let v)? = foo {return v} - return .unknown - } - set {foo = .fooEnum(newValue)} + var proto2: SwiftProtoTesting_TestRequired { + get {_proto2 ?? SwiftProtoTesting_TestRequired()} + set {_proto2 = newValue} } + /// Returns true if `proto2` has been explicitly set. + var hasProto2: Bool {self._proto2 != nil} + /// Clears the value of `proto2`. Subsequent reads from it will return its default value. + mutating func clearProto2() {self._proto2 = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_Foo: Equatable { - case fooEnum(Proto3Unittest_TestOneof2.NestedEnum) - - #if !swift(>=4.1) - static func ==(lhs: Proto3Unittest_TestOneof2.OneOf_Foo, rhs: Proto3Unittest_TestOneof2.OneOf_Foo) -> 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 (.fooEnum, .fooEnum): return { - guard case .fooEnum(let l) = lhs, case .fooEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - } - } - #endif - } - - enum NestedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case unknown // = 0 - case foo // = 1 - case bar // = 2 - case baz // = 3 - case UNRECOGNIZED(Int) - - init() { - self = .unknown - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .unknown - case 1: self = .foo - case 2: self = .bar - case 3: self = .baz - default: self = .UNRECOGNIZED(rawValue) - } - } - - var rawValue: Int { - switch self { - case .unknown: return 0 - case .foo: return 1 - case .bar: return 2 - case .baz: return 3 - case .UNRECOGNIZED(let i): return i - } - } - - } - init() {} -} - -#if swift(>=4.2) -extension Proto3Unittest_TestOneof2.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Proto3Unittest_TestOneof2.NestedEnum] = [ - .unknown, - .foo, - .bar, - .baz, - ] + fileprivate var _proto2: SwiftProtoTesting_TestRequired? = nil } -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension Proto3Unittest_ForeignEnum: @unchecked Sendable {} -extension Proto3Unittest_TestAllTypes: @unchecked Sendable {} -extension Proto3Unittest_TestAllTypes.OneOf_OneofField: @unchecked Sendable {} -extension Proto3Unittest_TestAllTypes.NestedEnum: @unchecked Sendable {} -extension Proto3Unittest_TestAllTypes.NestedMessage: @unchecked Sendable {} -extension Proto3Unittest_TestPackedTypes: @unchecked Sendable {} -extension Proto3Unittest_TestUnpackedTypes: @unchecked Sendable {} -extension Proto3Unittest_NestedTestAllTypes: @unchecked Sendable {} -extension Proto3Unittest_ForeignMessage: @unchecked Sendable {} -extension Proto3Unittest_TestEmptyMessage: @unchecked Sendable {} -extension Proto3Unittest_TestMessageWithDummy: @unchecked Sendable {} -extension Proto3Unittest_TestOneof2: @unchecked Sendable {} -extension Proto3Unittest_TestOneof2.OneOf_Foo: @unchecked Sendable {} -extension Proto3Unittest_TestOneof2.NestedEnum: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "proto3_unittest" +fileprivate let _protobuf_package = "swift_proto_testing.proto3" -extension Proto3Unittest_ForeignEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOREIGN_ZERO"), - 4: .same(proto: "FOREIGN_FOO"), - 5: .same(proto: "FOREIGN_BAR"), - 6: .same(proto: "FOREIGN_BAZ"), - ] +extension SwiftProtoTesting_Proto3_ForeignEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOREIGN_ZERO\0\u{2}\u{4}FOREIGN_FOO\0\u{1}FOREIGN_BAR\0\u{1}FOREIGN_BAZ\0") } -extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Proto3_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "optional_foreign_message"), - 20: .standard(proto: "optional_import_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "optional_foreign_enum"), - 24: .standard(proto: "optional_string_piece"), - 25: .standard(proto: "optional_cord"), - 26: .standard(proto: "optional_public_import_message"), - 27: .standard(proto: "optional_lazy_message"), - 115: .standard(proto: "optional_lazy_import_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 48: .standard(proto: "repeated_nested_message"), - 49: .standard(proto: "repeated_foreign_message"), - 50: .standard(proto: "repeated_import_message"), - 51: .standard(proto: "repeated_nested_enum"), - 52: .standard(proto: "repeated_foreign_enum"), - 54: .standard(proto: "repeated_string_piece"), - 55: .standard(proto: "repeated_cord"), - 57: .standard(proto: "repeated_lazy_message"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{3}optional_foreign_message\0\u{3}optional_import_message\0\u{3}optional_nested_enum\0\u{3}optional_foreign_enum\0\u{4}\u{4}optional_public_import_message\0\u{4}\u{5}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_nested_message\0\u{3}repeated_foreign_message\0\u{3}repeated_import_message\0\u{3}repeated_nested_enum\0\u{3}repeated_foreign_enum\0\u{4};oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0") fileprivate class _StorageClass { var _optionalInt32: Int32 = 0 @@ -858,16 +622,12 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes var _optionalBool: Bool = false var _optionalString: String = String() var _optionalBytes: Data = Data() - var _optionalNestedMessage: Proto3Unittest_TestAllTypes.NestedMessage? = nil - var _optionalForeignMessage: Proto3Unittest_ForeignMessage? = nil - var _optionalImportMessage: ProtobufUnittestImport_ImportMessage? = nil - var _optionalNestedEnum: Proto3Unittest_TestAllTypes.NestedEnum = .zero - var _optionalForeignEnum: Proto3Unittest_ForeignEnum = .foreignZero - var _optionalStringPiece: String = String() - var _optionalCord: String = String() - var _optionalPublicImportMessage: ProtobufUnittestImport_PublicImportMessage? = nil - var _optionalLazyMessage: Proto3Unittest_TestAllTypes.NestedMessage? = nil - var _optionalLazyImportMessage: ProtobufUnittestImport_ImportMessage? = nil + var _optionalNestedMessage: SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage? = nil + var _optionalForeignMessage: SwiftProtoTesting_Proto3_ForeignMessage? = nil + var _optionalImportMessage: SwiftProtoTesting_Import_ImportMessage? = nil + var _optionalNestedEnum: SwiftProtoTesting_Proto3_TestAllTypes.NestedEnum = .zero + var _optionalForeignEnum: SwiftProtoTesting_Proto3_ForeignEnum = .foreignZero + var _optionalPublicImportMessage: SwiftProtoTesting_Import_PublicImportMessage? = nil var _repeatedInt32: [Int32] = [] var _repeatedInt64: [Int64] = [] var _repeatedUint32: [UInt32] = [] @@ -883,17 +643,18 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes var _repeatedBool: [Bool] = [] var _repeatedString: [String] = [] var _repeatedBytes: [Data] = [] - var _repeatedNestedMessage: [Proto3Unittest_TestAllTypes.NestedMessage] = [] - var _repeatedForeignMessage: [Proto3Unittest_ForeignMessage] = [] - var _repeatedImportMessage: [ProtobufUnittestImport_ImportMessage] = [] - var _repeatedNestedEnum: [Proto3Unittest_TestAllTypes.NestedEnum] = [] - var _repeatedForeignEnum: [Proto3Unittest_ForeignEnum] = [] - var _repeatedStringPiece: [String] = [] - var _repeatedCord: [String] = [] - var _repeatedLazyMessage: [Proto3Unittest_TestAllTypes.NestedMessage] = [] - var _oneofField: Proto3Unittest_TestAllTypes.OneOf_OneofField? - - static let defaultInstance = _StorageClass() + var _repeatedNestedMessage: [SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage] = [] + var _repeatedForeignMessage: [SwiftProtoTesting_Proto3_ForeignMessage] = [] + var _repeatedImportMessage: [SwiftProtoTesting_Import_ImportMessage] = [] + var _repeatedNestedEnum: [SwiftProtoTesting_Proto3_TestAllTypes.NestedEnum] = [] + var _repeatedForeignEnum: [SwiftProtoTesting_Proto3_ForeignEnum] = [] + var _oneofField: SwiftProtoTesting_Proto3_TestAllTypes.OneOf_OneofField? + + // 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() private init() {} @@ -918,11 +679,7 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes _optionalImportMessage = source._optionalImportMessage _optionalNestedEnum = source._optionalNestedEnum _optionalForeignEnum = source._optionalForeignEnum - _optionalStringPiece = source._optionalStringPiece - _optionalCord = source._optionalCord _optionalPublicImportMessage = source._optionalPublicImportMessage - _optionalLazyMessage = source._optionalLazyMessage - _optionalLazyImportMessage = source._optionalLazyImportMessage _repeatedInt32 = source._repeatedInt32 _repeatedInt64 = source._repeatedInt64 _repeatedUint32 = source._repeatedUint32 @@ -943,9 +700,6 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes _repeatedImportMessage = source._repeatedImportMessage _repeatedNestedEnum = source._repeatedNestedEnum _repeatedForeignEnum = source._repeatedForeignEnum - _repeatedStringPiece = source._repeatedStringPiece - _repeatedCord = source._repeatedCord - _repeatedLazyMessage = source._repeatedLazyMessage _oneofField = source._oneofField } } @@ -985,10 +739,7 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes case 20: try { try decoder.decodeSingularMessageField(value: &_storage._optionalImportMessage) }() case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() case 22: try { try decoder.decodeSingularEnumField(value: &_storage._optionalForeignEnum) }() - case 24: try { try decoder.decodeSingularStringField(value: &_storage._optionalStringPiece) }() - case 25: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() case 26: try { try decoder.decodeSingularMessageField(value: &_storage._optionalPublicImportMessage) }() - case 27: try { try decoder.decodeSingularMessageField(value: &_storage._optionalLazyMessage) }() case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() @@ -1009,9 +760,6 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes case 50: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedImportMessage) }() case 51: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedNestedEnum) }() case 52: try { try decoder.decodeRepeatedEnumField(value: &_storage._repeatedForeignEnum) }() - case 54: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedStringPiece) }() - case 55: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedCord) }() - case 57: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedLazyMessage) }() case 111: try { var v: UInt32? try decoder.decodeSingularUInt32Field(value: &v) @@ -1021,7 +769,7 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes } }() case 112: try { - var v: Proto3Unittest_TestAllTypes.NestedMessage? + var v: SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage? var hadOneofValue = false if let current = _storage._oneofField { hadOneofValue = true @@ -1049,7 +797,6 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes _storage._oneofField = .oneofBytes(v) } }() - case 115: try { try decoder.decodeSingularMessageField(value: &_storage._optionalLazyImportMessage) }() default: break } } @@ -1092,10 +839,10 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes if _storage._optionalSfixed64 != 0 { try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) } - if _storage._optionalFloat != 0 { + if _storage._optionalFloat.bitPattern != 0 { try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) } - if _storage._optionalDouble != 0 { + if _storage._optionalDouble.bitPattern != 0 { try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) } if _storage._optionalBool != false { @@ -1122,18 +869,9 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes if _storage._optionalForeignEnum != .foreignZero { try visitor.visitSingularEnumField(value: _storage._optionalForeignEnum, fieldNumber: 22) } - if !_storage._optionalStringPiece.isEmpty { - try visitor.visitSingularStringField(value: _storage._optionalStringPiece, fieldNumber: 24) - } - if !_storage._optionalCord.isEmpty { - try visitor.visitSingularStringField(value: _storage._optionalCord, fieldNumber: 25) - } try { if let v = _storage._optionalPublicImportMessage { try visitor.visitSingularMessageField(value: v, fieldNumber: 26) } }() - try { if let v = _storage._optionalLazyMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 27) - } }() if !_storage._repeatedInt32.isEmpty { try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) } @@ -1194,15 +932,6 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes if !_storage._repeatedForeignEnum.isEmpty { try visitor.visitPackedEnumField(value: _storage._repeatedForeignEnum, fieldNumber: 52) } - if !_storage._repeatedStringPiece.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedStringPiece, fieldNumber: 54) - } - if !_storage._repeatedCord.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedCord, fieldNumber: 55) - } - if !_storage._repeatedLazyMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedLazyMessage, fieldNumber: 57) - } switch _storage._oneofField { case .oneofUint32?: try { guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } @@ -1222,14 +951,11 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes }() case nil: break } - try { if let v = _storage._optionalLazyImportMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 115) - } }() } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3Unittest_TestAllTypes, rhs: Proto3Unittest_TestAllTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_Proto3_TestAllTypes, rhs: SwiftProtoTesting_Proto3_TestAllTypes) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -1254,11 +980,7 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes if _storage._optionalImportMessage != rhs_storage._optionalImportMessage {return false} if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} if _storage._optionalForeignEnum != rhs_storage._optionalForeignEnum {return false} - if _storage._optionalStringPiece != rhs_storage._optionalStringPiece {return false} - if _storage._optionalCord != rhs_storage._optionalCord {return false} if _storage._optionalPublicImportMessage != rhs_storage._optionalPublicImportMessage {return false} - if _storage._optionalLazyMessage != rhs_storage._optionalLazyMessage {return false} - if _storage._optionalLazyImportMessage != rhs_storage._optionalLazyImportMessage {return false} if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} @@ -1279,9 +1001,6 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes if _storage._repeatedImportMessage != rhs_storage._repeatedImportMessage {return false} if _storage._repeatedNestedEnum != rhs_storage._repeatedNestedEnum {return false} if _storage._repeatedForeignEnum != rhs_storage._repeatedForeignEnum {return false} - if _storage._repeatedStringPiece != rhs_storage._repeatedStringPiece {return false} - if _storage._repeatedCord != rhs_storage._repeatedCord {return false} - if _storage._repeatedLazyMessage != rhs_storage._repeatedLazyMessage {return false} if _storage._oneofField != rhs_storage._oneofField {return false} return true } @@ -1292,21 +1011,13 @@ extension Proto3Unittest_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._Mes } } -extension Proto3Unittest_TestAllTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -1: .same(proto: "NEG"), - 0: .same(proto: "ZERO"), - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - 3: .same(proto: "BAZ"), - ] +extension SwiftProtoTesting_Proto3_TestAllTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}ZERO\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") } -extension Proto3Unittest_TestAllTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = Proto3Unittest_TestAllTypes.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - ] +extension SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Proto3_TestAllTypes.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1327,31 +1038,16 @@ extension Proto3Unittest_TestAllTypes.NestedMessage: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3Unittest_TestAllTypes.NestedMessage, rhs: Proto3Unittest_TestAllTypes.NestedMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage, rhs: SwiftProtoTesting_Proto3_TestAllTypes.NestedMessage) -> Bool { if lhs.bb != rhs.bb {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Proto3Unittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Proto3_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestPackedTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 90: .standard(proto: "packed_int32"), - 91: .standard(proto: "packed_int64"), - 92: .standard(proto: "packed_uint32"), - 93: .standard(proto: "packed_uint64"), - 94: .standard(proto: "packed_sint32"), - 95: .standard(proto: "packed_sint64"), - 96: .standard(proto: "packed_fixed32"), - 97: .standard(proto: "packed_fixed64"), - 98: .standard(proto: "packed_sfixed32"), - 99: .standard(proto: "packed_sfixed64"), - 100: .standard(proto: "packed_float"), - 101: .standard(proto: "packed_double"), - 102: .standard(proto: "packed_bool"), - 103: .standard(proto: "packed_enum"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}Z\u{1}packed_int32\0\u{3}packed_int64\0\u{3}packed_uint32\0\u{3}packed_uint64\0\u{3}packed_sint32\0\u{3}packed_sint64\0\u{3}packed_fixed32\0\u{3}packed_fixed64\0\u{3}packed_sfixed32\0\u{3}packed_sfixed64\0\u{3}packed_float\0\u{3}packed_double\0\u{3}packed_bool\0\u{3}packed_enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1424,7 +1120,7 @@ extension Proto3Unittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._ try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3Unittest_TestPackedTypes, rhs: Proto3Unittest_TestPackedTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_Proto3_TestPackedTypes, rhs: SwiftProtoTesting_Proto3_TestPackedTypes) -> Bool { if lhs.packedInt32 != rhs.packedInt32 {return false} if lhs.packedInt64 != rhs.packedInt64 {return false} if lhs.packedUint32 != rhs.packedUint32 {return false} @@ -1444,24 +1140,9 @@ extension Proto3Unittest_TestPackedTypes: SwiftProtobuf.Message, SwiftProtobuf._ } } -extension Proto3Unittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Proto3_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestUnpackedTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "repeated_int32"), - 2: .standard(proto: "repeated_int64"), - 3: .standard(proto: "repeated_uint32"), - 4: .standard(proto: "repeated_uint64"), - 5: .standard(proto: "repeated_sint32"), - 6: .standard(proto: "repeated_sint64"), - 7: .standard(proto: "repeated_fixed32"), - 8: .standard(proto: "repeated_fixed64"), - 9: .standard(proto: "repeated_sfixed32"), - 10: .standard(proto: "repeated_sfixed64"), - 11: .standard(proto: "repeated_float"), - 12: .standard(proto: "repeated_double"), - 13: .standard(proto: "repeated_bool"), - 14: .standard(proto: "repeated_nested_enum"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_nested_enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1534,7 +1215,7 @@ extension Proto3Unittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3Unittest_TestUnpackedTypes, rhs: Proto3Unittest_TestUnpackedTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_Proto3_TestUnpackedTypes, rhs: SwiftProtoTesting_Proto3_TestUnpackedTypes) -> Bool { if lhs.repeatedInt32 != rhs.repeatedInt32 {return false} if lhs.repeatedInt64 != rhs.repeatedInt64 {return false} if lhs.repeatedUint32 != rhs.repeatedUint32 {return false} @@ -1554,18 +1235,19 @@ extension Proto3Unittest_TestUnpackedTypes: SwiftProtobuf.Message, SwiftProtobuf } } -extension Proto3Unittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Proto3_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".NestedTestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "child"), - 2: .same(proto: "payload"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}child\0\u{1}payload\0") fileprivate class _StorageClass { - var _child: Proto3Unittest_NestedTestAllTypes? = nil - var _payload: Proto3Unittest_TestAllTypes? = nil + var _child: SwiftProtoTesting_Proto3_NestedTestAllTypes? = nil + var _payload: SwiftProtoTesting_Proto3_TestAllTypes? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1614,7 +1296,7 @@ extension Proto3Unittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobu try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3Unittest_NestedTestAllTypes, rhs: Proto3Unittest_NestedTestAllTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_Proto3_NestedTestAllTypes, rhs: SwiftProtoTesting_Proto3_NestedTestAllTypes) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -1630,11 +1312,9 @@ extension Proto3Unittest_NestedTestAllTypes: SwiftProtobuf.Message, SwiftProtobu } } -extension Proto3Unittest_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Proto3_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ForeignMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1655,69 +1335,40 @@ extension Proto3Unittest_ForeignMessage: SwiftProtobuf.Message, SwiftProtobuf._M try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3Unittest_ForeignMessage, rhs: Proto3Unittest_ForeignMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Proto3_ForeignMessage, rhs: SwiftProtoTesting_Proto3_ForeignMessage) -> Bool { if lhs.c != rhs.c {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Proto3Unittest_TestEmptyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Proto3_TestEmptyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestEmptyMessage" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3Unittest_TestEmptyMessage, rhs: Proto3Unittest_TestEmptyMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Proto3_TestEmptyMessage, rhs: SwiftProtoTesting_Proto3_TestEmptyMessage) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Proto3Unittest_TestMessageWithDummy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestMessageWithDummy" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 536870911: .same(proto: "dummy"), - ] +extension SwiftProtoTesting_Proto3_TestProto2Required: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".TestProto2Required" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}proto2\0") - 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 536870911: try { try decoder.decodeSingularBoolField(value: &self.dummy) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if self.dummy != false { - try visitor.visitSingularBoolField(value: self.dummy, fieldNumber: 536870911) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: Proto3Unittest_TestMessageWithDummy, rhs: Proto3Unittest_TestMessageWithDummy) -> Bool { - if lhs.dummy != rhs.dummy {return false} - if lhs.unknownFields != rhs.unknownFields {return false} + public var isInitialized: Bool { + if let v = self._proto2, !v.isInitialized {return false} return true } -} - -extension Proto3Unittest_TestOneof2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestOneof2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 6: .standard(proto: "foo_enum"), - ] mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1725,14 +1376,7 @@ extension Proto3Unittest_TestOneof2: SwiftProtobuf.Message, SwiftProtobuf._Messa // 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 { - var v: Proto3Unittest_TestOneof2.NestedEnum? - try decoder.decodeSingularEnumField(value: &v) - if let v = v { - if self.foo != nil {try decoder.handleConflictingOneOf()} - self.foo = .fooEnum(v) - } - }() + case 1: try { try decoder.decodeSingularMessageField(value: &self._proto2) }() default: break } } @@ -1743,24 +1387,15 @@ extension Proto3Unittest_TestOneof2: SwiftProtobuf.Message, SwiftProtobuf._Messa // 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 case .fooEnum(let v)? = self.foo { - try visitor.visitSingularEnumField(value: v, fieldNumber: 6) + try { if let v = self._proto2 { + try visitor.visitSingularMessageField(value: v, fieldNumber: 1) } }() try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Proto3Unittest_TestOneof2, rhs: Proto3Unittest_TestOneof2) -> Bool { - if lhs.foo != rhs.foo {return false} + static func ==(lhs: SwiftProtoTesting_Proto3_TestProto2Required, rhs: SwiftProtoTesting_Proto3_TestProto2Required) -> Bool { + if lhs._proto2 != rhs._proto2 {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } - -extension Proto3Unittest_TestOneof2.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "UNKNOWN"), - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - 3: .same(proto: "BAZ"), - ] -} diff --git a/Tests/SwiftProtobufTests/unittest_proto3_optional.pb.swift b/Tests/SwiftProtobufTests/unittest_proto3_optional.pb.swift index d453ef7d6..f49518041 100644 --- a/Tests/SwiftProtobufTests/unittest_proto3_optional.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_proto3_optional.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_proto3_optional.proto +// Source: unittest_proto3_optional.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -50,197 +51,179 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_TestProto3Optional { +struct SwiftProtoTesting_TestProto3Optional: @unchecked Sendable { // 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. /// Singular var optionalInt32: Int32 { - get {return _storage._optionalInt32 ?? 0} + get {_storage._optionalInt32 ?? 0} set {_uniqueStorage()._optionalInt32 = newValue} } /// Returns true if `optionalInt32` has been explicitly set. - var hasOptionalInt32: Bool {return _storage._optionalInt32 != nil} + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} var optionalInt64: Int64 { - get {return _storage._optionalInt64 ?? 0} + get {_storage._optionalInt64 ?? 0} set {_uniqueStorage()._optionalInt64 = newValue} } /// Returns true if `optionalInt64` has been explicitly set. - var hasOptionalInt64: Bool {return _storage._optionalInt64 != nil} + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} var optionalUint32: UInt32 { - get {return _storage._optionalUint32 ?? 0} + get {_storage._optionalUint32 ?? 0} set {_uniqueStorage()._optionalUint32 = newValue} } /// Returns true if `optionalUint32` has been explicitly set. - var hasOptionalUint32: Bool {return _storage._optionalUint32 != nil} + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} var optionalUint64: UInt64 { - get {return _storage._optionalUint64 ?? 0} + get {_storage._optionalUint64 ?? 0} set {_uniqueStorage()._optionalUint64 = newValue} } /// Returns true if `optionalUint64` has been explicitly set. - var hasOptionalUint64: Bool {return _storage._optionalUint64 != nil} + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} var optionalSint32: Int32 { - get {return _storage._optionalSint32 ?? 0} + get {_storage._optionalSint32 ?? 0} set {_uniqueStorage()._optionalSint32 = newValue} } /// Returns true if `optionalSint32` has been explicitly set. - var hasOptionalSint32: Bool {return _storage._optionalSint32 != nil} + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} var optionalSint64: Int64 { - get {return _storage._optionalSint64 ?? 0} + get {_storage._optionalSint64 ?? 0} set {_uniqueStorage()._optionalSint64 = newValue} } /// Returns true if `optionalSint64` has been explicitly set. - var hasOptionalSint64: Bool {return _storage._optionalSint64 != nil} + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32 ?? 0} + get {_storage._optionalFixed32 ?? 0} set {_uniqueStorage()._optionalFixed32 = newValue} } /// Returns true if `optionalFixed32` has been explicitly set. - var hasOptionalFixed32: Bool {return _storage._optionalFixed32 != nil} + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64 ?? 0} + get {_storage._optionalFixed64 ?? 0} set {_uniqueStorage()._optionalFixed64 = newValue} } /// Returns true if `optionalFixed64` has been explicitly set. - var hasOptionalFixed64: Bool {return _storage._optionalFixed64 != nil} + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32 ?? 0} + get {_storage._optionalSfixed32 ?? 0} set {_uniqueStorage()._optionalSfixed32 = newValue} } /// Returns true if `optionalSfixed32` has been explicitly set. - var hasOptionalSfixed32: Bool {return _storage._optionalSfixed32 != nil} + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64 ?? 0} + get {_storage._optionalSfixed64 ?? 0} set {_uniqueStorage()._optionalSfixed64 = newValue} } /// Returns true if `optionalSfixed64` has been explicitly set. - var hasOptionalSfixed64: Bool {return _storage._optionalSfixed64 != nil} + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} var optionalFloat: Float { - get {return _storage._optionalFloat ?? 0} + get {_storage._optionalFloat ?? 0} set {_uniqueStorage()._optionalFloat = newValue} } /// Returns true if `optionalFloat` has been explicitly set. - var hasOptionalFloat: Bool {return _storage._optionalFloat != nil} + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} var optionalDouble: Double { - get {return _storage._optionalDouble ?? 0} + get {_storage._optionalDouble ?? 0} set {_uniqueStorage()._optionalDouble = newValue} } /// Returns true if `optionalDouble` has been explicitly set. - var hasOptionalDouble: Bool {return _storage._optionalDouble != nil} + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} var optionalBool: Bool { - get {return _storage._optionalBool ?? false} + get {_storage._optionalBool ?? false} set {_uniqueStorage()._optionalBool = newValue} } /// Returns true if `optionalBool` has been explicitly set. - var hasOptionalBool: Bool {return _storage._optionalBool != nil} + var hasOptionalBool: Bool {_storage._optionalBool != nil} /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} var optionalString: String { - get {return _storage._optionalString ?? String()} + get {_storage._optionalString ?? String()} set {_uniqueStorage()._optionalString = newValue} } /// Returns true if `optionalString` has been explicitly set. - var hasOptionalString: Bool {return _storage._optionalString != nil} + var hasOptionalString: Bool {_storage._optionalString != nil} /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} var optionalBytes: Data { - get {return _storage._optionalBytes ?? Data()} + get {_storage._optionalBytes ?? Data()} set {_uniqueStorage()._optionalBytes = newValue} } /// Returns true if `optionalBytes` has been explicitly set. - var hasOptionalBytes: Bool {return _storage._optionalBytes != nil} + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} - var optionalCord: String { - get {return _storage._optionalCord ?? String()} - set {_uniqueStorage()._optionalCord = newValue} - } - /// Returns true if `optionalCord` has been explicitly set. - var hasOptionalCord: Bool {return _storage._optionalCord != nil} - /// Clears the value of `optionalCord`. Subsequent reads from it will return its default value. - mutating func clearOptionalCord() {_uniqueStorage()._optionalCord = nil} - - var optionalNestedMessage: ProtobufUnittest_TestProto3Optional.NestedMessage { - get {return _storage._optionalNestedMessage ?? ProtobufUnittest_TestProto3Optional.NestedMessage()} + var optionalNestedMessage: SwiftProtoTesting_TestProto3Optional.NestedMessage { + get {_storage._optionalNestedMessage ?? SwiftProtoTesting_TestProto3Optional.NestedMessage()} set {_uniqueStorage()._optionalNestedMessage = newValue} } /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return _storage._optionalNestedMessage != nil} + var hasOptionalNestedMessage: Bool {_storage._optionalNestedMessage != nil} /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedMessage() {_uniqueStorage()._optionalNestedMessage = nil} - var lazyNestedMessage: ProtobufUnittest_TestProto3Optional.NestedMessage { - get {return _storage._lazyNestedMessage ?? ProtobufUnittest_TestProto3Optional.NestedMessage()} - set {_uniqueStorage()._lazyNestedMessage = newValue} - } - /// Returns true if `lazyNestedMessage` has been explicitly set. - var hasLazyNestedMessage: Bool {return _storage._lazyNestedMessage != nil} - /// Clears the value of `lazyNestedMessage`. Subsequent reads from it will return its default value. - mutating func clearLazyNestedMessage() {_uniqueStorage()._lazyNestedMessage = nil} - - var optionalNestedEnum: ProtobufUnittest_TestProto3Optional.NestedEnum { - get {return _storage._optionalNestedEnum ?? .unspecified} + var optionalNestedEnum: SwiftProtoTesting_TestProto3Optional.NestedEnum { + get {_storage._optionalNestedEnum ?? .unspecified} set {_uniqueStorage()._optionalNestedEnum = newValue} } /// Returns true if `optionalNestedEnum` has been explicitly set. - var hasOptionalNestedEnum: Bool {return _storage._optionalNestedEnum != nil} + var hasOptionalNestedEnum: Bool {_storage._optionalNestedEnum != nil} /// Clears the value of `optionalNestedEnum`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedEnum() {_uniqueStorage()._optionalNestedEnum = nil} /// Add some non-optional fields to verify we can mix them. var singularInt32: Int32 { - get {return _storage._singularInt32} + get {_storage._singularInt32} set {_uniqueStorage()._singularInt32 = newValue} } var singularInt64: Int64 { - get {return _storage._singularInt64} + get {_storage._singularInt64} set {_uniqueStorage()._singularInt64 = newValue} } var unknownFields = SwiftProtobuf.UnknownStorage() - enum NestedEnum: SwiftProtobuf.Enum { + enum NestedEnum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case unspecified // = 0 case foo // = 1 @@ -277,9 +260,18 @@ struct ProtobufUnittest_TestProto3Optional { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_TestProto3Optional.NestedEnum] = [ + .unspecified, + .foo, + .bar, + .baz, + .neg, + ] + } - struct NestedMessage { + struct NestedMessage: Sendable { // 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. @@ -288,11 +280,11 @@ struct ProtobufUnittest_TestProto3Optional { /// a local variable named "b" in one of the generated methods. Doh. /// This file needs to compile in proto1 to test backwards-compatibility. var bb: Int32 { - get {return _bb ?? 0} + get {_bb ?? 0} set {_bb = newValue} } /// Returns true if `bb` has been explicitly set. - var hasBb: Bool {return self._bb != nil} + var hasBb: Bool {self._bb != nil} /// Clears the value of `bb`. Subsequent reads from it will return its default value. mutating func clearBb() {self._bb = nil} @@ -308,184 +300,13 @@ struct ProtobufUnittest_TestProto3Optional { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension ProtobufUnittest_TestProto3Optional.NestedEnum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittest_TestProto3Optional.NestedEnum] = [ - .unspecified, - .foo, - .bar, - .baz, - .neg, - ] -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_TestProto3OptionalMessage { - // 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 nestedMessage: ProtobufUnittest_TestProto3OptionalMessage.NestedMessage { - get {return _nestedMessage ?? ProtobufUnittest_TestProto3OptionalMessage.NestedMessage()} - set {_nestedMessage = newValue} - } - /// Returns true if `nestedMessage` has been explicitly set. - var hasNestedMessage: Bool {return self._nestedMessage != nil} - /// Clears the value of `nestedMessage`. Subsequent reads from it will return its default value. - mutating func clearNestedMessage() {self._nestedMessage = nil} - - var optionalNestedMessage: ProtobufUnittest_TestProto3OptionalMessage.NestedMessage { - get {return _optionalNestedMessage ?? ProtobufUnittest_TestProto3OptionalMessage.NestedMessage()} - set {_optionalNestedMessage = newValue} - } - /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return self._optionalNestedMessage != nil} - /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. - mutating func clearOptionalNestedMessage() {self._optionalNestedMessage = nil} - - var unknownFields = SwiftProtobuf.UnknownStorage() - - struct NestedMessage { - // 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 s: String = String() - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - } - - init() {} - - fileprivate var _nestedMessage: ProtobufUnittest_TestProto3OptionalMessage.NestedMessage? = nil - fileprivate var _optionalNestedMessage: ProtobufUnittest_TestProto3OptionalMessage.NestedMessage? = nil -} - -struct ProtobufUnittest_Proto3OptionalExtensions { - // 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() {} -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_TestProto3Optional: @unchecked Sendable {} -extension ProtobufUnittest_TestProto3Optional.NestedEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestProto3Optional.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestProto3OptionalMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestProto3OptionalMessage.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_Proto3OptionalExtensions: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Extension support defined in unittest_proto3_optional.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_MessageOptions { - - var ProtobufUnittest_Proto3OptionalExtensions_extNoOptional: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_no_optional) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_no_optional, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_no_optional` - /// has been explicitly set. - var hasProtobufUnittest_Proto3OptionalExtensions_extNoOptional: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_no_optional) - } - /// Clears the value of extension `ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_no_optional`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Proto3OptionalExtensions_extNoOptional() { - clearExtensionValue(ext: ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_no_optional) - } - - var ProtobufUnittest_Proto3OptionalExtensions_extWithOptional: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_with_optional) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_with_optional, value: newValue)} - } - /// Returns true if extension `ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_with_optional` - /// has been explicitly set. - var hasProtobufUnittest_Proto3OptionalExtensions_extWithOptional: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_with_optional) - } - /// Clears the value of extension `ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_with_optional`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Proto3OptionalExtensions_extWithOptional() { - clearExtensionValue(ext: ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_with_optional) - } - -} - -// MARK: - File's ExtensionMap: ProtobufUnittest_UnittestProto3Optional_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 ProtobufUnittest_UnittestProto3Optional_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_no_optional, - ProtobufUnittest_Proto3OptionalExtensions.Extensions.ext_with_optional -] - -// 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. - -extension ProtobufUnittest_Proto3OptionalExtensions { - enum Extensions { - static let ext_no_optional = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 355886728, - fieldName: "protobuf_unittest.Proto3OptionalExtensions.ext_no_optional" - ) - - static let ext_with_optional = SwiftProtobuf.MessageExtension, SwiftProtobuf.Google_Protobuf_MessageOptions>( - _protobuf_fieldNumber: 355886729, - fieldName: "protobuf_unittest.Proto3OptionalExtensions.ext_with_optional" - ) - } -} - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_TestProto3Optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_TestProto3Optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestProto3Optional" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 16: .standard(proto: "optional_cord"), - 18: .standard(proto: "optional_nested_message"), - 19: .standard(proto: "lazy_nested_message"), - 21: .standard(proto: "optional_nested_enum"), - 22: .standard(proto: "singular_int32"), - 23: .standard(proto: "singular_int64"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_nested_message\0\u{4}\u{3}optional_nested_enum\0\u{3}singular_int32\0\u{3}singular_int64\0") fileprivate class _StorageClass { var _optionalInt32: Int32? = nil @@ -503,14 +324,16 @@ extension ProtobufUnittest_TestProto3Optional: SwiftProtobuf.Message, SwiftProto var _optionalBool: Bool? = nil var _optionalString: String? = nil var _optionalBytes: Data? = nil - var _optionalCord: String? = nil - var _optionalNestedMessage: ProtobufUnittest_TestProto3Optional.NestedMessage? = nil - var _lazyNestedMessage: ProtobufUnittest_TestProto3Optional.NestedMessage? = nil - var _optionalNestedEnum: ProtobufUnittest_TestProto3Optional.NestedEnum? = nil + var _optionalNestedMessage: SwiftProtoTesting_TestProto3Optional.NestedMessage? = nil + var _optionalNestedEnum: SwiftProtoTesting_TestProto3Optional.NestedEnum? = nil var _singularInt32: Int32 = 0 var _singularInt64: Int64 = 0 - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -530,9 +353,7 @@ extension ProtobufUnittest_TestProto3Optional: SwiftProtobuf.Message, SwiftProto _optionalBool = source._optionalBool _optionalString = source._optionalString _optionalBytes = source._optionalBytes - _optionalCord = source._optionalCord _optionalNestedMessage = source._optionalNestedMessage - _lazyNestedMessage = source._lazyNestedMessage _optionalNestedEnum = source._optionalNestedEnum _singularInt32 = source._singularInt32 _singularInt64 = source._singularInt64 @@ -569,9 +390,7 @@ extension ProtobufUnittest_TestProto3Optional: SwiftProtobuf.Message, SwiftProto case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() - case 16: try { try decoder.decodeSingularStringField(value: &_storage._optionalCord) }() case 18: try { try decoder.decodeSingularMessageField(value: &_storage._optionalNestedMessage) }() - case 19: try { try decoder.decodeSingularMessageField(value: &_storage._lazyNestedMessage) }() case 21: try { try decoder.decodeSingularEnumField(value: &_storage._optionalNestedEnum) }() case 22: try { try decoder.decodeSingularInt32Field(value: &_storage._singularInt32) }() case 23: try { try decoder.decodeSingularInt64Field(value: &_storage._singularInt64) }() @@ -632,15 +451,9 @@ extension ProtobufUnittest_TestProto3Optional: SwiftProtobuf.Message, SwiftProto try { if let v = _storage._optionalBytes { try visitor.visitSingularBytesField(value: v, fieldNumber: 15) } }() - try { if let v = _storage._optionalCord { - try visitor.visitSingularStringField(value: v, fieldNumber: 16) - } }() try { if let v = _storage._optionalNestedMessage { try visitor.visitSingularMessageField(value: v, fieldNumber: 18) } }() - try { if let v = _storage._lazyNestedMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 19) - } }() try { if let v = _storage._optionalNestedEnum { try visitor.visitSingularEnumField(value: v, fieldNumber: 21) } }() @@ -654,7 +467,7 @@ extension ProtobufUnittest_TestProto3Optional: SwiftProtobuf.Message, SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestProto3Optional, rhs: ProtobufUnittest_TestProto3Optional) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestProto3Optional, rhs: SwiftProtoTesting_TestProto3Optional) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -674,9 +487,7 @@ extension ProtobufUnittest_TestProto3Optional: SwiftProtobuf.Message, SwiftProto if _storage._optionalBool != rhs_storage._optionalBool {return false} if _storage._optionalString != rhs_storage._optionalString {return false} if _storage._optionalBytes != rhs_storage._optionalBytes {return false} - if _storage._optionalCord != rhs_storage._optionalCord {return false} if _storage._optionalNestedMessage != rhs_storage._optionalNestedMessage {return false} - if _storage._lazyNestedMessage != rhs_storage._lazyNestedMessage {return false} if _storage._optionalNestedEnum != rhs_storage._optionalNestedEnum {return false} if _storage._singularInt32 != rhs_storage._singularInt32 {return false} if _storage._singularInt64 != rhs_storage._singularInt64 {return false} @@ -689,21 +500,13 @@ extension ProtobufUnittest_TestProto3Optional: SwiftProtobuf.Message, SwiftProto } } -extension ProtobufUnittest_TestProto3Optional.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -1: .same(proto: "NEG"), - 0: .same(proto: "UNSPECIFIED"), - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - 3: .same(proto: "BAZ"), - ] +extension SwiftProtoTesting_TestProto3Optional.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{1}UNSPECIFIED\0\u{1}FOO\0\u{1}BAR\0\u{1}BAZ\0") } -extension ProtobufUnittest_TestProto3Optional.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestProto3Optional.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - ] +extension SwiftProtoTesting_TestProto3Optional.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestProto3Optional.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -728,102 +531,9 @@ extension ProtobufUnittest_TestProto3Optional.NestedMessage: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestProto3Optional.NestedMessage, rhs: ProtobufUnittest_TestProto3Optional.NestedMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestProto3Optional.NestedMessage, rhs: SwiftProtoTesting_TestProto3Optional.NestedMessage) -> Bool { if lhs._bb != rhs._bb {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } - -extension ProtobufUnittest_TestProto3OptionalMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestProto3OptionalMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "nested_message"), - 2: .standard(proto: "optional_nested_message"), - ] - - 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.decodeSingularMessageField(value: &self._nestedMessage) }() - case 2: try { try decoder.decodeSingularMessageField(value: &self._optionalNestedMessage) }() - 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 - try { if let v = self._nestedMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 1) - } }() - try { if let v = self._optionalNestedMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 2) - } }() - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestProto3OptionalMessage, rhs: ProtobufUnittest_TestProto3OptionalMessage) -> Bool { - if lhs._nestedMessage != rhs._nestedMessage {return false} - if lhs._optionalNestedMessage != rhs._optionalNestedMessage {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_TestProto3OptionalMessage.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestProto3OptionalMessage.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "s"), - ] - - 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.s) }() - default: break - } - } - } - - func traverse(visitor: inout V) throws { - if !self.s.isEmpty { - try visitor.visitSingularStringField(value: self.s, fieldNumber: 1) - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_TestProto3OptionalMessage.NestedMessage, rhs: ProtobufUnittest_TestProto3OptionalMessage.NestedMessage) -> Bool { - if lhs.s != rhs.s {return false} - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} - -extension ProtobufUnittest_Proto3OptionalExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".Proto3OptionalExtensions" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufUnittest_Proto3OptionalExtensions, rhs: ProtobufUnittest_Proto3OptionalExtensions) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Tests/SwiftProtobufTests/unittest_swift_all_required_types.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_all_required_types.pb.swift index 8100bd2ad..747fc46d3 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_all_required_types.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_all_required_types.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_all_required_types.proto @@ -52,428 +53,383 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_TestAllRequiredTypes { +struct SwiftProtoTesting_TestAllRequiredTypes: @unchecked Sendable { // 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. /// Singular var requiredInt32: Int32 { - get {return _storage._requiredInt32 ?? 0} + get {_storage._requiredInt32 ?? 0} set {_uniqueStorage()._requiredInt32 = newValue} } /// Returns true if `requiredInt32` has been explicitly set. - var hasRequiredInt32: Bool {return _storage._requiredInt32 != nil} + var hasRequiredInt32: Bool {_storage._requiredInt32 != nil} /// Clears the value of `requiredInt32`. Subsequent reads from it will return its default value. mutating func clearRequiredInt32() {_uniqueStorage()._requiredInt32 = nil} var requiredInt64: Int64 { - get {return _storage._requiredInt64 ?? 0} + get {_storage._requiredInt64 ?? 0} set {_uniqueStorage()._requiredInt64 = newValue} } /// Returns true if `requiredInt64` has been explicitly set. - var hasRequiredInt64: Bool {return _storage._requiredInt64 != nil} + var hasRequiredInt64: Bool {_storage._requiredInt64 != nil} /// Clears the value of `requiredInt64`. Subsequent reads from it will return its default value. mutating func clearRequiredInt64() {_uniqueStorage()._requiredInt64 = nil} var requiredUint32: UInt32 { - get {return _storage._requiredUint32 ?? 0} + get {_storage._requiredUint32 ?? 0} set {_uniqueStorage()._requiredUint32 = newValue} } /// Returns true if `requiredUint32` has been explicitly set. - var hasRequiredUint32: Bool {return _storage._requiredUint32 != nil} + var hasRequiredUint32: Bool {_storage._requiredUint32 != nil} /// Clears the value of `requiredUint32`. Subsequent reads from it will return its default value. mutating func clearRequiredUint32() {_uniqueStorage()._requiredUint32 = nil} var requiredUint64: UInt64 { - get {return _storage._requiredUint64 ?? 0} + get {_storage._requiredUint64 ?? 0} set {_uniqueStorage()._requiredUint64 = newValue} } /// Returns true if `requiredUint64` has been explicitly set. - var hasRequiredUint64: Bool {return _storage._requiredUint64 != nil} + var hasRequiredUint64: Bool {_storage._requiredUint64 != nil} /// Clears the value of `requiredUint64`. Subsequent reads from it will return its default value. mutating func clearRequiredUint64() {_uniqueStorage()._requiredUint64 = nil} var requiredSint32: Int32 { - get {return _storage._requiredSint32 ?? 0} + get {_storage._requiredSint32 ?? 0} set {_uniqueStorage()._requiredSint32 = newValue} } /// Returns true if `requiredSint32` has been explicitly set. - var hasRequiredSint32: Bool {return _storage._requiredSint32 != nil} + var hasRequiredSint32: Bool {_storage._requiredSint32 != nil} /// Clears the value of `requiredSint32`. Subsequent reads from it will return its default value. mutating func clearRequiredSint32() {_uniqueStorage()._requiredSint32 = nil} var requiredSint64: Int64 { - get {return _storage._requiredSint64 ?? 0} + get {_storage._requiredSint64 ?? 0} set {_uniqueStorage()._requiredSint64 = newValue} } /// Returns true if `requiredSint64` has been explicitly set. - var hasRequiredSint64: Bool {return _storage._requiredSint64 != nil} + var hasRequiredSint64: Bool {_storage._requiredSint64 != nil} /// Clears the value of `requiredSint64`. Subsequent reads from it will return its default value. mutating func clearRequiredSint64() {_uniqueStorage()._requiredSint64 = nil} var requiredFixed32: UInt32 { - get {return _storage._requiredFixed32 ?? 0} + get {_storage._requiredFixed32 ?? 0} set {_uniqueStorage()._requiredFixed32 = newValue} } /// Returns true if `requiredFixed32` has been explicitly set. - var hasRequiredFixed32: Bool {return _storage._requiredFixed32 != nil} + var hasRequiredFixed32: Bool {_storage._requiredFixed32 != nil} /// Clears the value of `requiredFixed32`. Subsequent reads from it will return its default value. mutating func clearRequiredFixed32() {_uniqueStorage()._requiredFixed32 = nil} var requiredFixed64: UInt64 { - get {return _storage._requiredFixed64 ?? 0} + get {_storage._requiredFixed64 ?? 0} set {_uniqueStorage()._requiredFixed64 = newValue} } /// Returns true if `requiredFixed64` has been explicitly set. - var hasRequiredFixed64: Bool {return _storage._requiredFixed64 != nil} + var hasRequiredFixed64: Bool {_storage._requiredFixed64 != nil} /// Clears the value of `requiredFixed64`. Subsequent reads from it will return its default value. mutating func clearRequiredFixed64() {_uniqueStorage()._requiredFixed64 = nil} var requiredSfixed32: Int32 { - get {return _storage._requiredSfixed32 ?? 0} + get {_storage._requiredSfixed32 ?? 0} set {_uniqueStorage()._requiredSfixed32 = newValue} } /// Returns true if `requiredSfixed32` has been explicitly set. - var hasRequiredSfixed32: Bool {return _storage._requiredSfixed32 != nil} + var hasRequiredSfixed32: Bool {_storage._requiredSfixed32 != nil} /// Clears the value of `requiredSfixed32`. Subsequent reads from it will return its default value. mutating func clearRequiredSfixed32() {_uniqueStorage()._requiredSfixed32 = nil} var requiredSfixed64: Int64 { - get {return _storage._requiredSfixed64 ?? 0} + get {_storage._requiredSfixed64 ?? 0} set {_uniqueStorage()._requiredSfixed64 = newValue} } /// Returns true if `requiredSfixed64` has been explicitly set. - var hasRequiredSfixed64: Bool {return _storage._requiredSfixed64 != nil} + var hasRequiredSfixed64: Bool {_storage._requiredSfixed64 != nil} /// Clears the value of `requiredSfixed64`. Subsequent reads from it will return its default value. mutating func clearRequiredSfixed64() {_uniqueStorage()._requiredSfixed64 = nil} var requiredFloat: Float { - get {return _storage._requiredFloat ?? 0} + get {_storage._requiredFloat ?? 0} set {_uniqueStorage()._requiredFloat = newValue} } /// Returns true if `requiredFloat` has been explicitly set. - var hasRequiredFloat: Bool {return _storage._requiredFloat != nil} + var hasRequiredFloat: Bool {_storage._requiredFloat != nil} /// Clears the value of `requiredFloat`. Subsequent reads from it will return its default value. mutating func clearRequiredFloat() {_uniqueStorage()._requiredFloat = nil} var requiredDouble: Double { - get {return _storage._requiredDouble ?? 0} + get {_storage._requiredDouble ?? 0} set {_uniqueStorage()._requiredDouble = newValue} } /// Returns true if `requiredDouble` has been explicitly set. - var hasRequiredDouble: Bool {return _storage._requiredDouble != nil} + var hasRequiredDouble: Bool {_storage._requiredDouble != nil} /// Clears the value of `requiredDouble`. Subsequent reads from it will return its default value. mutating func clearRequiredDouble() {_uniqueStorage()._requiredDouble = nil} var requiredBool: Bool { - get {return _storage._requiredBool ?? false} + get {_storage._requiredBool ?? false} set {_uniqueStorage()._requiredBool = newValue} } /// Returns true if `requiredBool` has been explicitly set. - var hasRequiredBool: Bool {return _storage._requiredBool != nil} + var hasRequiredBool: Bool {_storage._requiredBool != nil} /// Clears the value of `requiredBool`. Subsequent reads from it will return its default value. mutating func clearRequiredBool() {_uniqueStorage()._requiredBool = nil} var requiredString: String { - get {return _storage._requiredString ?? String()} + get {_storage._requiredString ?? String()} set {_uniqueStorage()._requiredString = newValue} } /// Returns true if `requiredString` has been explicitly set. - var hasRequiredString: Bool {return _storage._requiredString != nil} + var hasRequiredString: Bool {_storage._requiredString != nil} /// Clears the value of `requiredString`. Subsequent reads from it will return its default value. mutating func clearRequiredString() {_uniqueStorage()._requiredString = nil} var requiredBytes: Data { - get {return _storage._requiredBytes ?? Data()} + get {_storage._requiredBytes ?? Data()} set {_uniqueStorage()._requiredBytes = newValue} } /// Returns true if `requiredBytes` has been explicitly set. - var hasRequiredBytes: Bool {return _storage._requiredBytes != nil} + var hasRequiredBytes: Bool {_storage._requiredBytes != nil} /// Clears the value of `requiredBytes`. Subsequent reads from it will return its default value. mutating func clearRequiredBytes() {_uniqueStorage()._requiredBytes = nil} - var requiredGroup: ProtobufUnittest_TestAllRequiredTypes.RequiredGroup { - get {return _storage._requiredGroup ?? ProtobufUnittest_TestAllRequiredTypes.RequiredGroup()} + var requiredGroup: SwiftProtoTesting_TestAllRequiredTypes.RequiredGroup { + get {_storage._requiredGroup ?? SwiftProtoTesting_TestAllRequiredTypes.RequiredGroup()} set {_uniqueStorage()._requiredGroup = newValue} } /// Returns true if `requiredGroup` has been explicitly set. - var hasRequiredGroup: Bool {return _storage._requiredGroup != nil} + var hasRequiredGroup: Bool {_storage._requiredGroup != nil} /// Clears the value of `requiredGroup`. Subsequent reads from it will return its default value. mutating func clearRequiredGroup() {_uniqueStorage()._requiredGroup = nil} - var requiredNestedMessage: ProtobufUnittest_TestAllRequiredTypes.NestedMessage { - get {return _storage._requiredNestedMessage ?? ProtobufUnittest_TestAllRequiredTypes.NestedMessage()} + var requiredNestedMessage: SwiftProtoTesting_TestAllRequiredTypes.NestedMessage { + get {_storage._requiredNestedMessage ?? SwiftProtoTesting_TestAllRequiredTypes.NestedMessage()} set {_uniqueStorage()._requiredNestedMessage = newValue} } /// Returns true if `requiredNestedMessage` has been explicitly set. - var hasRequiredNestedMessage: Bool {return _storage._requiredNestedMessage != nil} + var hasRequiredNestedMessage: Bool {_storage._requiredNestedMessage != nil} /// Clears the value of `requiredNestedMessage`. Subsequent reads from it will return its default value. mutating func clearRequiredNestedMessage() {_uniqueStorage()._requiredNestedMessage = nil} - var requiredForeignMessage: ProtobufUnittest_ForeignMessage { - get {return _storage._requiredForeignMessage ?? ProtobufUnittest_ForeignMessage()} + var requiredForeignMessage: SwiftProtoTesting_ForeignMessage { + get {_storage._requiredForeignMessage ?? SwiftProtoTesting_ForeignMessage()} set {_uniqueStorage()._requiredForeignMessage = newValue} } /// Returns true if `requiredForeignMessage` has been explicitly set. - var hasRequiredForeignMessage: Bool {return _storage._requiredForeignMessage != nil} + var hasRequiredForeignMessage: Bool {_storage._requiredForeignMessage != nil} /// Clears the value of `requiredForeignMessage`. Subsequent reads from it will return its default value. mutating func clearRequiredForeignMessage() {_uniqueStorage()._requiredForeignMessage = nil} - var requiredImportMessage: ProtobufUnittestImport_ImportMessage { - get {return _storage._requiredImportMessage ?? ProtobufUnittestImport_ImportMessage()} + var requiredImportMessage: SwiftProtoTesting_Import_ImportMessage { + get {_storage._requiredImportMessage ?? SwiftProtoTesting_Import_ImportMessage()} set {_uniqueStorage()._requiredImportMessage = newValue} } /// Returns true if `requiredImportMessage` has been explicitly set. - var hasRequiredImportMessage: Bool {return _storage._requiredImportMessage != nil} + var hasRequiredImportMessage: Bool {_storage._requiredImportMessage != nil} /// Clears the value of `requiredImportMessage`. Subsequent reads from it will return its default value. mutating func clearRequiredImportMessage() {_uniqueStorage()._requiredImportMessage = nil} - var requiredNestedEnum: ProtobufUnittest_TestAllRequiredTypes.NestedEnum { - get {return _storage._requiredNestedEnum ?? .foo} + var requiredNestedEnum: SwiftProtoTesting_TestAllRequiredTypes.NestedEnum { + get {_storage._requiredNestedEnum ?? .foo} set {_uniqueStorage()._requiredNestedEnum = newValue} } /// Returns true if `requiredNestedEnum` has been explicitly set. - var hasRequiredNestedEnum: Bool {return _storage._requiredNestedEnum != nil} + var hasRequiredNestedEnum: Bool {_storage._requiredNestedEnum != nil} /// Clears the value of `requiredNestedEnum`. Subsequent reads from it will return its default value. mutating func clearRequiredNestedEnum() {_uniqueStorage()._requiredNestedEnum = nil} - var requiredForeignEnum: ProtobufUnittest_ForeignEnum { - get {return _storage._requiredForeignEnum ?? .foreignFoo} + var requiredForeignEnum: SwiftProtoTesting_ForeignEnum { + get {_storage._requiredForeignEnum ?? .foreignFoo} set {_uniqueStorage()._requiredForeignEnum = newValue} } /// Returns true if `requiredForeignEnum` has been explicitly set. - var hasRequiredForeignEnum: Bool {return _storage._requiredForeignEnum != nil} + var hasRequiredForeignEnum: Bool {_storage._requiredForeignEnum != nil} /// Clears the value of `requiredForeignEnum`. Subsequent reads from it will return its default value. mutating func clearRequiredForeignEnum() {_uniqueStorage()._requiredForeignEnum = nil} - var requiredImportEnum: ProtobufUnittestImport_ImportEnum { - get {return _storage._requiredImportEnum ?? .importFoo} + var requiredImportEnum: SwiftProtoTesting_Import_ImportEnum { + get {_storage._requiredImportEnum ?? .importFoo} set {_uniqueStorage()._requiredImportEnum = newValue} } /// Returns true if `requiredImportEnum` has been explicitly set. - var hasRequiredImportEnum: Bool {return _storage._requiredImportEnum != nil} + var hasRequiredImportEnum: Bool {_storage._requiredImportEnum != nil} /// Clears the value of `requiredImportEnum`. Subsequent reads from it will return its default value. mutating func clearRequiredImportEnum() {_uniqueStorage()._requiredImportEnum = nil} - var requiredStringPiece: String { - get {return _storage._requiredStringPiece ?? String()} - set {_uniqueStorage()._requiredStringPiece = newValue} - } - /// Returns true if `requiredStringPiece` has been explicitly set. - var hasRequiredStringPiece: Bool {return _storage._requiredStringPiece != nil} - /// Clears the value of `requiredStringPiece`. Subsequent reads from it will return its default value. - mutating func clearRequiredStringPiece() {_uniqueStorage()._requiredStringPiece = nil} - - var requiredCord: String { - get {return _storage._requiredCord ?? String()} - set {_uniqueStorage()._requiredCord = newValue} - } - /// Returns true if `requiredCord` has been explicitly set. - var hasRequiredCord: Bool {return _storage._requiredCord != nil} - /// Clears the value of `requiredCord`. Subsequent reads from it will return its default value. - mutating func clearRequiredCord() {_uniqueStorage()._requiredCord = nil} - /// Defined in unittest_import_public.proto - var requiredPublicImportMessage: ProtobufUnittestImport_PublicImportMessage { - get {return _storage._requiredPublicImportMessage ?? ProtobufUnittestImport_PublicImportMessage()} + var requiredPublicImportMessage: SwiftProtoTesting_Import_PublicImportMessage { + get {_storage._requiredPublicImportMessage ?? SwiftProtoTesting_Import_PublicImportMessage()} set {_uniqueStorage()._requiredPublicImportMessage = newValue} } /// Returns true if `requiredPublicImportMessage` has been explicitly set. - var hasRequiredPublicImportMessage: Bool {return _storage._requiredPublicImportMessage != nil} + var hasRequiredPublicImportMessage: Bool {_storage._requiredPublicImportMessage != nil} /// Clears the value of `requiredPublicImportMessage`. Subsequent reads from it will return its default value. mutating func clearRequiredPublicImportMessage() {_uniqueStorage()._requiredPublicImportMessage = nil} - var requiredLazyMessage: ProtobufUnittest_TestAllRequiredTypes.NestedMessage { - get {return _storage._requiredLazyMessage ?? ProtobufUnittest_TestAllRequiredTypes.NestedMessage()} - set {_uniqueStorage()._requiredLazyMessage = newValue} - } - /// Returns true if `requiredLazyMessage` has been explicitly set. - var hasRequiredLazyMessage: Bool {return _storage._requiredLazyMessage != nil} - /// Clears the value of `requiredLazyMessage`. Subsequent reads from it will return its default value. - mutating func clearRequiredLazyMessage() {_uniqueStorage()._requiredLazyMessage = nil} - /// Singular with defaults var defaultInt32: Int32 { - get {return _storage._defaultInt32 ?? 41} + get {_storage._defaultInt32 ?? 41} set {_uniqueStorage()._defaultInt32 = newValue} } /// Returns true if `defaultInt32` has been explicitly set. - var hasDefaultInt32: Bool {return _storage._defaultInt32 != nil} + var hasDefaultInt32: Bool {_storage._defaultInt32 != nil} /// Clears the value of `defaultInt32`. Subsequent reads from it will return its default value. mutating func clearDefaultInt32() {_uniqueStorage()._defaultInt32 = nil} var defaultInt64: Int64 { - get {return _storage._defaultInt64 ?? 42} + get {_storage._defaultInt64 ?? 42} set {_uniqueStorage()._defaultInt64 = newValue} } /// Returns true if `defaultInt64` has been explicitly set. - var hasDefaultInt64: Bool {return _storage._defaultInt64 != nil} + var hasDefaultInt64: Bool {_storage._defaultInt64 != nil} /// Clears the value of `defaultInt64`. Subsequent reads from it will return its default value. mutating func clearDefaultInt64() {_uniqueStorage()._defaultInt64 = nil} var defaultUint32: UInt32 { - get {return _storage._defaultUint32 ?? 43} + get {_storage._defaultUint32 ?? 43} set {_uniqueStorage()._defaultUint32 = newValue} } /// Returns true if `defaultUint32` has been explicitly set. - var hasDefaultUint32: Bool {return _storage._defaultUint32 != nil} + var hasDefaultUint32: Bool {_storage._defaultUint32 != nil} /// Clears the value of `defaultUint32`. Subsequent reads from it will return its default value. mutating func clearDefaultUint32() {_uniqueStorage()._defaultUint32 = nil} var defaultUint64: UInt64 { - get {return _storage._defaultUint64 ?? 44} + get {_storage._defaultUint64 ?? 44} set {_uniqueStorage()._defaultUint64 = newValue} } /// Returns true if `defaultUint64` has been explicitly set. - var hasDefaultUint64: Bool {return _storage._defaultUint64 != nil} + var hasDefaultUint64: Bool {_storage._defaultUint64 != nil} /// Clears the value of `defaultUint64`. Subsequent reads from it will return its default value. mutating func clearDefaultUint64() {_uniqueStorage()._defaultUint64 = nil} var defaultSint32: Int32 { - get {return _storage._defaultSint32 ?? -45} + get {_storage._defaultSint32 ?? -45} set {_uniqueStorage()._defaultSint32 = newValue} } /// Returns true if `defaultSint32` has been explicitly set. - var hasDefaultSint32: Bool {return _storage._defaultSint32 != nil} + var hasDefaultSint32: Bool {_storage._defaultSint32 != nil} /// Clears the value of `defaultSint32`. Subsequent reads from it will return its default value. mutating func clearDefaultSint32() {_uniqueStorage()._defaultSint32 = nil} var defaultSint64: Int64 { - get {return _storage._defaultSint64 ?? 46} + get {_storage._defaultSint64 ?? 46} set {_uniqueStorage()._defaultSint64 = newValue} } /// Returns true if `defaultSint64` has been explicitly set. - var hasDefaultSint64: Bool {return _storage._defaultSint64 != nil} + var hasDefaultSint64: Bool {_storage._defaultSint64 != nil} /// Clears the value of `defaultSint64`. Subsequent reads from it will return its default value. mutating func clearDefaultSint64() {_uniqueStorage()._defaultSint64 = nil} var defaultFixed32: UInt32 { - get {return _storage._defaultFixed32 ?? 47} + get {_storage._defaultFixed32 ?? 47} set {_uniqueStorage()._defaultFixed32 = newValue} } /// Returns true if `defaultFixed32` has been explicitly set. - var hasDefaultFixed32: Bool {return _storage._defaultFixed32 != nil} + var hasDefaultFixed32: Bool {_storage._defaultFixed32 != nil} /// Clears the value of `defaultFixed32`. Subsequent reads from it will return its default value. mutating func clearDefaultFixed32() {_uniqueStorage()._defaultFixed32 = nil} var defaultFixed64: UInt64 { - get {return _storage._defaultFixed64 ?? 48} + get {_storage._defaultFixed64 ?? 48} set {_uniqueStorage()._defaultFixed64 = newValue} } /// Returns true if `defaultFixed64` has been explicitly set. - var hasDefaultFixed64: Bool {return _storage._defaultFixed64 != nil} + var hasDefaultFixed64: Bool {_storage._defaultFixed64 != nil} /// Clears the value of `defaultFixed64`. Subsequent reads from it will return its default value. mutating func clearDefaultFixed64() {_uniqueStorage()._defaultFixed64 = nil} var defaultSfixed32: Int32 { - get {return _storage._defaultSfixed32 ?? 49} + get {_storage._defaultSfixed32 ?? 49} set {_uniqueStorage()._defaultSfixed32 = newValue} } /// Returns true if `defaultSfixed32` has been explicitly set. - var hasDefaultSfixed32: Bool {return _storage._defaultSfixed32 != nil} + var hasDefaultSfixed32: Bool {_storage._defaultSfixed32 != nil} /// Clears the value of `defaultSfixed32`. Subsequent reads from it will return its default value. mutating func clearDefaultSfixed32() {_uniqueStorage()._defaultSfixed32 = nil} var defaultSfixed64: Int64 { - get {return _storage._defaultSfixed64 ?? -50} + get {_storage._defaultSfixed64 ?? -50} set {_uniqueStorage()._defaultSfixed64 = newValue} } /// Returns true if `defaultSfixed64` has been explicitly set. - var hasDefaultSfixed64: Bool {return _storage._defaultSfixed64 != nil} + var hasDefaultSfixed64: Bool {_storage._defaultSfixed64 != nil} /// Clears the value of `defaultSfixed64`. Subsequent reads from it will return its default value. mutating func clearDefaultSfixed64() {_uniqueStorage()._defaultSfixed64 = nil} var defaultFloat: Float { - get {return _storage._defaultFloat ?? 51.5} + get {_storage._defaultFloat ?? 51.5} set {_uniqueStorage()._defaultFloat = newValue} } /// Returns true if `defaultFloat` has been explicitly set. - var hasDefaultFloat: Bool {return _storage._defaultFloat != nil} + var hasDefaultFloat: Bool {_storage._defaultFloat != nil} /// Clears the value of `defaultFloat`. Subsequent reads from it will return its default value. mutating func clearDefaultFloat() {_uniqueStorage()._defaultFloat = nil} var defaultDouble: Double { - get {return _storage._defaultDouble ?? 52000} + get {_storage._defaultDouble ?? 52000} set {_uniqueStorage()._defaultDouble = newValue} } /// Returns true if `defaultDouble` has been explicitly set. - var hasDefaultDouble: Bool {return _storage._defaultDouble != nil} + var hasDefaultDouble: Bool {_storage._defaultDouble != nil} /// Clears the value of `defaultDouble`. Subsequent reads from it will return its default value. mutating func clearDefaultDouble() {_uniqueStorage()._defaultDouble = nil} var defaultBool: Bool { - get {return _storage._defaultBool ?? true} + get {_storage._defaultBool ?? true} set {_uniqueStorage()._defaultBool = newValue} } /// Returns true if `defaultBool` has been explicitly set. - var hasDefaultBool: Bool {return _storage._defaultBool != nil} + var hasDefaultBool: Bool {_storage._defaultBool != nil} /// Clears the value of `defaultBool`. Subsequent reads from it will return its default value. mutating func clearDefaultBool() {_uniqueStorage()._defaultBool = nil} var defaultString: String { - get {return _storage._defaultString ?? "hello"} + get {_storage._defaultString ?? "hello"} set {_uniqueStorage()._defaultString = newValue} } /// Returns true if `defaultString` has been explicitly set. - var hasDefaultString: Bool {return _storage._defaultString != nil} + var hasDefaultString: Bool {_storage._defaultString != nil} /// Clears the value of `defaultString`. Subsequent reads from it will return its default value. mutating func clearDefaultString() {_uniqueStorage()._defaultString = nil} var defaultBytes: Data { - get {return _storage._defaultBytes ?? Data([119, 111, 114, 108, 100])} + get {_storage._defaultBytes ?? Data([119, 111, 114, 108, 100])} set {_uniqueStorage()._defaultBytes = newValue} } /// Returns true if `defaultBytes` has been explicitly set. - var hasDefaultBytes: Bool {return _storage._defaultBytes != nil} + var hasDefaultBytes: Bool {_storage._defaultBytes != nil} /// Clears the value of `defaultBytes`. Subsequent reads from it will return its default value. mutating func clearDefaultBytes() {_uniqueStorage()._defaultBytes = nil} - var defaultNestedEnum: ProtobufUnittest_TestAllRequiredTypes.NestedEnum { - get {return _storage._defaultNestedEnum ?? .bar} + var defaultNestedEnum: SwiftProtoTesting_TestAllRequiredTypes.NestedEnum { + get {_storage._defaultNestedEnum ?? .bar} set {_uniqueStorage()._defaultNestedEnum = newValue} } /// Returns true if `defaultNestedEnum` has been explicitly set. - var hasDefaultNestedEnum: Bool {return _storage._defaultNestedEnum != nil} + var hasDefaultNestedEnum: Bool {_storage._defaultNestedEnum != nil} /// Clears the value of `defaultNestedEnum`. Subsequent reads from it will return its default value. mutating func clearDefaultNestedEnum() {_uniqueStorage()._defaultNestedEnum = nil} - var defaultForeignEnum: ProtobufUnittest_ForeignEnum { - get {return _storage._defaultForeignEnum ?? .foreignBar} + var defaultForeignEnum: SwiftProtoTesting_ForeignEnum { + get {_storage._defaultForeignEnum ?? .foreignBar} set {_uniqueStorage()._defaultForeignEnum = newValue} } /// Returns true if `defaultForeignEnum` has been explicitly set. - var hasDefaultForeignEnum: Bool {return _storage._defaultForeignEnum != nil} + var hasDefaultForeignEnum: Bool {_storage._defaultForeignEnum != nil} /// Clears the value of `defaultForeignEnum`. Subsequent reads from it will return its default value. mutating func clearDefaultForeignEnum() {_uniqueStorage()._defaultForeignEnum = nil} - var defaultImportEnum: ProtobufUnittestImport_ImportEnum { - get {return _storage._defaultImportEnum ?? .importBar} + var defaultImportEnum: SwiftProtoTesting_Import_ImportEnum { + get {_storage._defaultImportEnum ?? .importBar} set {_uniqueStorage()._defaultImportEnum = newValue} } /// Returns true if `defaultImportEnum` has been explicitly set. - var hasDefaultImportEnum: Bool {return _storage._defaultImportEnum != nil} + var hasDefaultImportEnum: Bool {_storage._defaultImportEnum != nil} /// Clears the value of `defaultImportEnum`. Subsequent reads from it will return its default value. mutating func clearDefaultImportEnum() {_uniqueStorage()._defaultImportEnum = nil} - var defaultStringPiece: String { - get {return _storage._defaultStringPiece ?? "abc"} - set {_uniqueStorage()._defaultStringPiece = newValue} - } - /// Returns true if `defaultStringPiece` has been explicitly set. - var hasDefaultStringPiece: Bool {return _storage._defaultStringPiece != nil} - /// Clears the value of `defaultStringPiece`. Subsequent reads from it will return its default value. - mutating func clearDefaultStringPiece() {_uniqueStorage()._defaultStringPiece = nil} - - var defaultCord: String { - get {return _storage._defaultCord ?? "123"} - set {_uniqueStorage()._defaultCord = newValue} - } - /// Returns true if `defaultCord` has been explicitly set. - var hasDefaultCord: Bool {return _storage._defaultCord != nil} - /// Clears the value of `defaultCord`. Subsequent reads from it will return its default value. - mutating func clearDefaultCord() {_uniqueStorage()._defaultCord = nil} - /// For oneof test var oneofField: OneOf_OneofField? { get {return _storage._oneofField} @@ -488,10 +444,10 @@ struct ProtobufUnittest_TestAllRequiredTypes { set {_uniqueStorage()._oneofField = .oneofUint32(newValue)} } - var oneofNestedMessage: ProtobufUnittest_TestAllRequiredTypes.NestedMessage { + var oneofNestedMessage: SwiftProtoTesting_TestAllRequiredTypes.NestedMessage { get { if case .oneofNestedMessage(let v)? = _storage._oneofField {return v} - return ProtobufUnittest_TestAllRequiredTypes.NestedMessage() + return SwiftProtoTesting_TestAllRequiredTypes.NestedMessage() } set {_uniqueStorage()._oneofField = .oneofNestedMessage(newValue)} } @@ -515,9 +471,9 @@ struct ProtobufUnittest_TestAllRequiredTypes { var unknownFields = SwiftProtobuf.UnknownStorage() /// For oneof test - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case oneofUint32(UInt32) - case oneofNestedMessage(ProtobufUnittest_TestAllRequiredTypes.NestedMessage) + case oneofNestedMessage(SwiftProtoTesting_TestAllRequiredTypes.NestedMessage) case oneofString(String) case oneofBytes(Data) @@ -526,69 +482,23 @@ struct ProtobufUnittest_TestAllRequiredTypes { return v.isInitialized } - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_TestAllRequiredTypes.OneOf_OneofField, rhs: ProtobufUnittest_TestAllRequiredTypes.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum NestedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 1 - case bar // = 2 - case baz // = 3 + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 1 + case bar = 2 + case baz = 3 /// Intentionally negative. - case neg // = -1 + case neg = -1 init() { self = .foo } - init?(rawValue: Int) { - switch rawValue { - case -1: self = .neg - case 1: self = .foo - case 2: self = .bar - case 3: self = .baz - default: return nil - } - } - - var rawValue: Int { - switch self { - case .neg: return -1 - case .foo: return 1 - case .bar: return 2 - case .baz: return 3 - } - } - } - struct NestedMessage { + struct NestedMessage: Sendable { // 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. @@ -597,11 +507,11 @@ struct ProtobufUnittest_TestAllRequiredTypes { /// a local variable named "b" in one of the generated methods. Doh. /// This file needs to compile in proto1 to test backwards-compatibility. var bb: Int32 { - get {return _bb ?? 0} + get {_bb ?? 0} set {_bb = newValue} } /// Returns true if `bb` has been explicitly set. - var hasBb: Bool {return self._bb != nil} + var hasBb: Bool {self._bb != nil} /// Clears the value of `bb`. Subsequent reads from it will return its default value. mutating func clearBb() {self._bb = nil} @@ -612,17 +522,17 @@ struct ProtobufUnittest_TestAllRequiredTypes { fileprivate var _bb: Int32? = nil } - struct RequiredGroup { + struct RequiredGroup: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -638,97 +548,75 @@ struct ProtobufUnittest_TestAllRequiredTypes { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension ProtobufUnittest_TestAllRequiredTypes.NestedEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_TestSomeRequiredTypes { +struct SwiftProtoTesting_TestSomeRequiredTypes: Sendable { // 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. /// Singular var requiredInt32: Int32 { - get {return _requiredInt32 ?? 0} + get {_requiredInt32 ?? 0} set {_requiredInt32 = newValue} } /// Returns true if `requiredInt32` has been explicitly set. - var hasRequiredInt32: Bool {return self._requiredInt32 != nil} + var hasRequiredInt32: Bool {self._requiredInt32 != nil} /// Clears the value of `requiredInt32`. Subsequent reads from it will return its default value. mutating func clearRequiredInt32() {self._requiredInt32 = nil} var requiredFloat: Float { - get {return _requiredFloat ?? 0} + get {_requiredFloat ?? 0} set {_requiredFloat = newValue} } /// Returns true if `requiredFloat` has been explicitly set. - var hasRequiredFloat: Bool {return self._requiredFloat != nil} + var hasRequiredFloat: Bool {self._requiredFloat != nil} /// Clears the value of `requiredFloat`. Subsequent reads from it will return its default value. mutating func clearRequiredFloat() {self._requiredFloat = nil} var requiredBool: Bool { - get {return _requiredBool ?? false} + get {_requiredBool ?? false} set {_requiredBool = newValue} } /// Returns true if `requiredBool` has been explicitly set. - var hasRequiredBool: Bool {return self._requiredBool != nil} + var hasRequiredBool: Bool {self._requiredBool != nil} /// Clears the value of `requiredBool`. Subsequent reads from it will return its default value. mutating func clearRequiredBool() {self._requiredBool = nil} var requiredString: String { - get {return _requiredString ?? String()} + get {_requiredString ?? String()} set {_requiredString = newValue} } /// Returns true if `requiredString` has been explicitly set. - var hasRequiredString: Bool {return self._requiredString != nil} + var hasRequiredString: Bool {self._requiredString != nil} /// Clears the value of `requiredString`. Subsequent reads from it will return its default value. mutating func clearRequiredString() {self._requiredString = nil} var requiredBytes: Data { - get {return _requiredBytes ?? Data()} + get {_requiredBytes ?? Data()} set {_requiredBytes = newValue} } /// Returns true if `requiredBytes` has been explicitly set. - var hasRequiredBytes: Bool {return self._requiredBytes != nil} + var hasRequiredBytes: Bool {self._requiredBytes != nil} /// Clears the value of `requiredBytes`. Subsequent reads from it will return its default value. mutating func clearRequiredBytes() {self._requiredBytes = nil} - var requiredNestedEnum: ProtobufUnittest_TestSomeRequiredTypes.NestedEnum { - get {return _requiredNestedEnum ?? .foo} + var requiredNestedEnum: SwiftProtoTesting_TestSomeRequiredTypes.NestedEnum { + get {_requiredNestedEnum ?? .foo} set {_requiredNestedEnum = newValue} } /// Returns true if `requiredNestedEnum` has been explicitly set. - var hasRequiredNestedEnum: Bool {return self._requiredNestedEnum != nil} + var hasRequiredNestedEnum: Bool {self._requiredNestedEnum != nil} /// Clears the value of `requiredNestedEnum`. Subsequent reads from it will return its default value. mutating func clearRequiredNestedEnum() {self._requiredNestedEnum = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - enum NestedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 1 + enum NestedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 1 init() { self = .foo } - init?(rawValue: Int) { - switch rawValue { - case 1: self = .foo - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo: return 1 - } - } - } init() {} @@ -738,85 +626,16 @@ struct ProtobufUnittest_TestSomeRequiredTypes { fileprivate var _requiredBool: Bool? = nil fileprivate var _requiredString: String? = nil fileprivate var _requiredBytes: Data? = nil - fileprivate var _requiredNestedEnum: ProtobufUnittest_TestSomeRequiredTypes.NestedEnum? = nil -} - -#if swift(>=4.2) - -extension ProtobufUnittest_TestSomeRequiredTypes.NestedEnum: CaseIterable { - // Support synthesized by the compiler. + fileprivate var _requiredNestedEnum: SwiftProtoTesting_TestSomeRequiredTypes.NestedEnum? = nil } -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_TestAllRequiredTypes: @unchecked Sendable {} -extension ProtobufUnittest_TestAllRequiredTypes.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufUnittest_TestAllRequiredTypes.NestedEnum: @unchecked Sendable {} -extension ProtobufUnittest_TestAllRequiredTypes.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_TestAllRequiredTypes.RequiredGroup: @unchecked Sendable {} -extension ProtobufUnittest_TestSomeRequiredTypes: @unchecked Sendable {} -extension ProtobufUnittest_TestSomeRequiredTypes.NestedEnum: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestAllRequiredTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "required_int32"), - 2: .standard(proto: "required_int64"), - 3: .standard(proto: "required_uint32"), - 4: .standard(proto: "required_uint64"), - 5: .standard(proto: "required_sint32"), - 6: .standard(proto: "required_sint64"), - 7: .standard(proto: "required_fixed32"), - 8: .standard(proto: "required_fixed64"), - 9: .standard(proto: "required_sfixed32"), - 10: .standard(proto: "required_sfixed64"), - 11: .standard(proto: "required_float"), - 12: .standard(proto: "required_double"), - 13: .standard(proto: "required_bool"), - 14: .standard(proto: "required_string"), - 15: .standard(proto: "required_bytes"), - 16: .unique(proto: "RequiredGroup", json: "requiredgroup"), - 18: .standard(proto: "required_nested_message"), - 19: .standard(proto: "required_foreign_message"), - 20: .standard(proto: "required_import_message"), - 21: .standard(proto: "required_nested_enum"), - 22: .standard(proto: "required_foreign_enum"), - 23: .standard(proto: "required_import_enum"), - 24: .standard(proto: "required_string_piece"), - 25: .standard(proto: "required_cord"), - 26: .standard(proto: "required_public_import_message"), - 27: .standard(proto: "required_lazy_message"), - 61: .standard(proto: "default_int32"), - 62: .standard(proto: "default_int64"), - 63: .standard(proto: "default_uint32"), - 64: .standard(proto: "default_uint64"), - 65: .standard(proto: "default_sint32"), - 66: .standard(proto: "default_sint64"), - 67: .standard(proto: "default_fixed32"), - 68: .standard(proto: "default_fixed64"), - 69: .standard(proto: "default_sfixed32"), - 70: .standard(proto: "default_sfixed64"), - 71: .standard(proto: "default_float"), - 72: .standard(proto: "default_double"), - 73: .standard(proto: "default_bool"), - 74: .standard(proto: "default_string"), - 75: .standard(proto: "default_bytes"), - 81: .standard(proto: "default_nested_enum"), - 82: .standard(proto: "default_foreign_enum"), - 83: .standard(proto: "default_import_enum"), - 84: .standard(proto: "default_string_piece"), - 85: .standard(proto: "default_cord"), - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_int32\0\u{3}required_int64\0\u{3}required_uint32\0\u{3}required_uint64\0\u{3}required_sint32\0\u{3}required_sint64\0\u{3}required_fixed32\0\u{3}required_fixed64\0\u{3}required_sfixed32\0\u{3}required_sfixed64\0\u{3}required_float\0\u{3}required_double\0\u{3}required_bool\0\u{3}required_string\0\u{3}required_bytes\0\u{7}RequiredGroup\0\u{4}\u{2}required_nested_message\0\u{3}required_foreign_message\0\u{3}required_import_message\0\u{3}required_nested_enum\0\u{3}required_foreign_enum\0\u{3}required_import_enum\0\u{4}\u{3}required_public_import_message\0\u{4}#default_int32\0\u{3}default_int64\0\u{3}default_uint32\0\u{3}default_uint64\0\u{3}default_sint32\0\u{3}default_sint64\0\u{3}default_fixed32\0\u{3}default_fixed64\0\u{3}default_sfixed32\0\u{3}default_sfixed64\0\u{3}default_float\0\u{3}default_double\0\u{3}default_bool\0\u{3}default_string\0\u{3}default_bytes\0\u{4}\u{6}default_nested_enum\0\u{3}default_foreign_enum\0\u{3}default_import_enum\0\u{4}\u{1c}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0") fileprivate class _StorageClass { var _requiredInt32: Int32? = nil @@ -834,17 +653,14 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro var _requiredBool: Bool? = nil var _requiredString: String? = nil var _requiredBytes: Data? = nil - var _requiredGroup: ProtobufUnittest_TestAllRequiredTypes.RequiredGroup? = nil - var _requiredNestedMessage: ProtobufUnittest_TestAllRequiredTypes.NestedMessage? = nil - var _requiredForeignMessage: ProtobufUnittest_ForeignMessage? = nil - var _requiredImportMessage: ProtobufUnittestImport_ImportMessage? = nil - var _requiredNestedEnum: ProtobufUnittest_TestAllRequiredTypes.NestedEnum? = nil - var _requiredForeignEnum: ProtobufUnittest_ForeignEnum? = nil - var _requiredImportEnum: ProtobufUnittestImport_ImportEnum? = nil - var _requiredStringPiece: String? = nil - var _requiredCord: String? = nil - var _requiredPublicImportMessage: ProtobufUnittestImport_PublicImportMessage? = nil - var _requiredLazyMessage: ProtobufUnittest_TestAllRequiredTypes.NestedMessage? = nil + var _requiredGroup: SwiftProtoTesting_TestAllRequiredTypes.RequiredGroup? = nil + var _requiredNestedMessage: SwiftProtoTesting_TestAllRequiredTypes.NestedMessage? = nil + var _requiredForeignMessage: SwiftProtoTesting_ForeignMessage? = nil + var _requiredImportMessage: SwiftProtoTesting_Import_ImportMessage? = nil + var _requiredNestedEnum: SwiftProtoTesting_TestAllRequiredTypes.NestedEnum? = nil + var _requiredForeignEnum: SwiftProtoTesting_ForeignEnum? = nil + var _requiredImportEnum: SwiftProtoTesting_Import_ImportEnum? = nil + var _requiredPublicImportMessage: SwiftProtoTesting_Import_PublicImportMessage? = nil var _defaultInt32: Int32? = nil var _defaultInt64: Int64? = nil var _defaultUint32: UInt32? = nil @@ -860,14 +676,16 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro var _defaultBool: Bool? = nil var _defaultString: String? = nil var _defaultBytes: Data? = nil - var _defaultNestedEnum: ProtobufUnittest_TestAllRequiredTypes.NestedEnum? = nil - var _defaultForeignEnum: ProtobufUnittest_ForeignEnum? = nil - var _defaultImportEnum: ProtobufUnittestImport_ImportEnum? = nil - var _defaultStringPiece: String? = nil - var _defaultCord: String? = nil - var _oneofField: ProtobufUnittest_TestAllRequiredTypes.OneOf_OneofField? + var _defaultNestedEnum: SwiftProtoTesting_TestAllRequiredTypes.NestedEnum? = nil + var _defaultForeignEnum: SwiftProtoTesting_ForeignEnum? = nil + var _defaultImportEnum: SwiftProtoTesting_Import_ImportEnum? = nil + var _oneofField: SwiftProtoTesting_TestAllRequiredTypes.OneOf_OneofField? - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -894,10 +712,7 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro _requiredNestedEnum = source._requiredNestedEnum _requiredForeignEnum = source._requiredForeignEnum _requiredImportEnum = source._requiredImportEnum - _requiredStringPiece = source._requiredStringPiece - _requiredCord = source._requiredCord _requiredPublicImportMessage = source._requiredPublicImportMessage - _requiredLazyMessage = source._requiredLazyMessage _defaultInt32 = source._defaultInt32 _defaultInt64 = source._defaultInt64 _defaultUint32 = source._defaultUint32 @@ -916,8 +731,6 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro _defaultNestedEnum = source._defaultNestedEnum _defaultForeignEnum = source._defaultForeignEnum _defaultImportEnum = source._defaultImportEnum - _defaultStringPiece = source._defaultStringPiece - _defaultCord = source._defaultCord _oneofField = source._oneofField } } @@ -953,10 +766,7 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro if _storage._requiredNestedEnum == nil {return false} if _storage._requiredForeignEnum == nil {return false} if _storage._requiredImportEnum == nil {return false} - if _storage._requiredStringPiece == nil {return false} - if _storage._requiredCord == nil {return false} if _storage._requiredPublicImportMessage == nil {return false} - if _storage._requiredLazyMessage == nil {return false} if _storage._defaultInt32 == nil {return false} if _storage._defaultInt64 == nil {return false} if _storage._defaultUint32 == nil {return false} @@ -975,11 +785,8 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro if _storage._defaultNestedEnum == nil {return false} if _storage._defaultForeignEnum == nil {return false} if _storage._defaultImportEnum == nil {return false} - if _storage._defaultStringPiece == nil {return false} - if _storage._defaultCord == nil {return false} if let v = _storage._requiredGroup, !v.isInitialized {return false} if let v = _storage._requiredNestedMessage, !v.isInitialized {return false} - if let v = _storage._requiredLazyMessage, !v.isInitialized {return false} if let v = _storage._oneofField, !v.isInitialized {return false} return true } @@ -1015,10 +822,7 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro case 21: try { try decoder.decodeSingularEnumField(value: &_storage._requiredNestedEnum) }() case 22: try { try decoder.decodeSingularEnumField(value: &_storage._requiredForeignEnum) }() case 23: try { try decoder.decodeSingularEnumField(value: &_storage._requiredImportEnum) }() - case 24: try { try decoder.decodeSingularStringField(value: &_storage._requiredStringPiece) }() - case 25: try { try decoder.decodeSingularStringField(value: &_storage._requiredCord) }() case 26: try { try decoder.decodeSingularMessageField(value: &_storage._requiredPublicImportMessage) }() - case 27: try { try decoder.decodeSingularMessageField(value: &_storage._requiredLazyMessage) }() case 61: try { try decoder.decodeSingularInt32Field(value: &_storage._defaultInt32) }() case 62: try { try decoder.decodeSingularInt64Field(value: &_storage._defaultInt64) }() case 63: try { try decoder.decodeSingularUInt32Field(value: &_storage._defaultUint32) }() @@ -1037,8 +841,6 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro case 81: try { try decoder.decodeSingularEnumField(value: &_storage._defaultNestedEnum) }() case 82: try { try decoder.decodeSingularEnumField(value: &_storage._defaultForeignEnum) }() case 83: try { try decoder.decodeSingularEnumField(value: &_storage._defaultImportEnum) }() - case 84: try { try decoder.decodeSingularStringField(value: &_storage._defaultStringPiece) }() - case 85: try { try decoder.decodeSingularStringField(value: &_storage._defaultCord) }() case 111: try { var v: UInt32? try decoder.decodeSingularUInt32Field(value: &v) @@ -1048,7 +850,7 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro } }() case 112: try { - var v: ProtobufUnittest_TestAllRequiredTypes.NestedMessage? + var v: SwiftProtoTesting_TestAllRequiredTypes.NestedMessage? var hadOneofValue = false if let current = _storage._oneofField { hadOneofValue = true @@ -1154,18 +956,9 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro try { if let v = _storage._requiredImportEnum { try visitor.visitSingularEnumField(value: v, fieldNumber: 23) } }() - try { if let v = _storage._requiredStringPiece { - try visitor.visitSingularStringField(value: v, fieldNumber: 24) - } }() - try { if let v = _storage._requiredCord { - try visitor.visitSingularStringField(value: v, fieldNumber: 25) - } }() try { if let v = _storage._requiredPublicImportMessage { try visitor.visitSingularMessageField(value: v, fieldNumber: 26) } }() - try { if let v = _storage._requiredLazyMessage { - try visitor.visitSingularMessageField(value: v, fieldNumber: 27) - } }() try { if let v = _storage._defaultInt32 { try visitor.visitSingularInt32Field(value: v, fieldNumber: 61) } }() @@ -1220,12 +1013,6 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro try { if let v = _storage._defaultImportEnum { try visitor.visitSingularEnumField(value: v, fieldNumber: 83) } }() - try { if let v = _storage._defaultStringPiece { - try visitor.visitSingularStringField(value: v, fieldNumber: 84) - } }() - try { if let v = _storage._defaultCord { - try visitor.visitSingularStringField(value: v, fieldNumber: 85) - } }() switch _storage._oneofField { case .oneofUint32?: try { guard case .oneofUint32(let v)? = _storage._oneofField else { preconditionFailure() } @@ -1249,7 +1036,7 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestAllRequiredTypes, rhs: ProtobufUnittest_TestAllRequiredTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestAllRequiredTypes, rhs: SwiftProtoTesting_TestAllRequiredTypes) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -1276,10 +1063,7 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro if _storage._requiredNestedEnum != rhs_storage._requiredNestedEnum {return false} if _storage._requiredForeignEnum != rhs_storage._requiredForeignEnum {return false} if _storage._requiredImportEnum != rhs_storage._requiredImportEnum {return false} - if _storage._requiredStringPiece != rhs_storage._requiredStringPiece {return false} - if _storage._requiredCord != rhs_storage._requiredCord {return false} if _storage._requiredPublicImportMessage != rhs_storage._requiredPublicImportMessage {return false} - if _storage._requiredLazyMessage != rhs_storage._requiredLazyMessage {return false} if _storage._defaultInt32 != rhs_storage._defaultInt32 {return false} if _storage._defaultInt64 != rhs_storage._defaultInt64 {return false} if _storage._defaultUint32 != rhs_storage._defaultUint32 {return false} @@ -1298,8 +1082,6 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro if _storage._defaultNestedEnum != rhs_storage._defaultNestedEnum {return false} if _storage._defaultForeignEnum != rhs_storage._defaultForeignEnum {return false} if _storage._defaultImportEnum != rhs_storage._defaultImportEnum {return false} - if _storage._defaultStringPiece != rhs_storage._defaultStringPiece {return false} - if _storage._defaultCord != rhs_storage._defaultCord {return false} if _storage._oneofField != rhs_storage._oneofField {return false} return true } @@ -1310,20 +1092,13 @@ extension ProtobufUnittest_TestAllRequiredTypes: SwiftProtobuf.Message, SwiftPro } } -extension ProtobufUnittest_TestAllRequiredTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - -1: .same(proto: "NEG"), - 1: .same(proto: "FOO"), - 2: .same(proto: "BAR"), - 3: .same(proto: "BAZ"), - ] +extension SwiftProtoTesting_TestAllRequiredTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3}NEG\0\u{2}\u{2}FOO\0\u{1}BAR\0\u{1}BAZ\0") } -extension ProtobufUnittest_TestAllRequiredTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestAllRequiredTypes.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bb"), - ] +extension SwiftProtoTesting_TestAllRequiredTypes.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestAllRequiredTypes.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0") public var isInitialized: Bool { if self._bb == nil {return false} @@ -1353,18 +1128,16 @@ extension ProtobufUnittest_TestAllRequiredTypes.NestedMessage: SwiftProtobuf.Mes try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestAllRequiredTypes.NestedMessage, rhs: ProtobufUnittest_TestAllRequiredTypes.NestedMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestAllRequiredTypes.NestedMessage, rhs: SwiftProtoTesting_TestAllRequiredTypes.NestedMessage) -> Bool { if lhs._bb != rhs._bb {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestAllRequiredTypes.RequiredGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_TestAllRequiredTypes.protoMessageName + ".RequiredGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 17: .same(proto: "a"), - ] +extension SwiftProtoTesting_TestAllRequiredTypes.RequiredGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_TestAllRequiredTypes.protoMessageName + ".RequiredGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{11}a\0") public var isInitialized: Bool { if self._a == nil {return false} @@ -1394,23 +1167,16 @@ extension ProtobufUnittest_TestAllRequiredTypes.RequiredGroup: SwiftProtobuf.Mes try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestAllRequiredTypes.RequiredGroup, rhs: ProtobufUnittest_TestAllRequiredTypes.RequiredGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestAllRequiredTypes.RequiredGroup, rhs: SwiftProtoTesting_TestAllRequiredTypes.RequiredGroup) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_TestSomeRequiredTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_TestSomeRequiredTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestSomeRequiredTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "required_int32"), - 2: .standard(proto: "required_float"), - 3: .standard(proto: "required_bool"), - 4: .standard(proto: "required_string"), - 5: .standard(proto: "required_bytes"), - 6: .standard(proto: "required_nested_enum"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}required_int32\0\u{3}required_float\0\u{3}required_bool\0\u{3}required_string\0\u{3}required_bytes\0\u{3}required_nested_enum\0") public var isInitialized: Bool { if self._requiredInt32 == nil {return false} @@ -1465,7 +1231,7 @@ extension ProtobufUnittest_TestSomeRequiredTypes: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestSomeRequiredTypes, rhs: ProtobufUnittest_TestSomeRequiredTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestSomeRequiredTypes, rhs: SwiftProtoTesting_TestSomeRequiredTypes) -> Bool { if lhs._requiredInt32 != rhs._requiredInt32 {return false} if lhs._requiredFloat != rhs._requiredFloat {return false} if lhs._requiredBool != rhs._requiredBool {return false} @@ -1477,8 +1243,6 @@ extension ProtobufUnittest_TestSomeRequiredTypes: SwiftProtobuf.Message, SwiftPr } } -extension ProtobufUnittest_TestSomeRequiredTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FOO"), - ] +extension SwiftProtoTesting_TestSomeRequiredTypes.NestedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FOO\0") } diff --git a/Tests/SwiftProtobufTests/unittest_swift_cycle.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_cycle.pb.swift index 87145ef2b..b8af04e6c 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_cycle.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_cycle.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_cycle.proto @@ -36,7 +37,6 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -49,35 +49,35 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_CycleFoo { +struct SwiftProtoTesting_CycleFoo: @unchecked Sendable { // 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 aFoo: ProtobufUnittest_CycleFoo { - get {return _storage._aFoo ?? ProtobufUnittest_CycleFoo()} + var aFoo: SwiftProtoTesting_CycleFoo { + get {_storage._aFoo ?? SwiftProtoTesting_CycleFoo()} set {_uniqueStorage()._aFoo = newValue} } /// Returns true if `aFoo` has been explicitly set. - var hasAFoo: Bool {return _storage._aFoo != nil} + var hasAFoo: Bool {_storage._aFoo != nil} /// Clears the value of `aFoo`. Subsequent reads from it will return its default value. mutating func clearAFoo() {_uniqueStorage()._aFoo = nil} - var aBar: ProtobufUnittest_CycleBar { - get {return _storage._aBar ?? ProtobufUnittest_CycleBar()} + var aBar: SwiftProtoTesting_CycleBar { + get {_storage._aBar ?? SwiftProtoTesting_CycleBar()} set {_uniqueStorage()._aBar = newValue} } /// Returns true if `aBar` has been explicitly set. - var hasABar: Bool {return _storage._aBar != nil} + var hasABar: Bool {_storage._aBar != nil} /// Clears the value of `aBar`. Subsequent reads from it will return its default value. mutating func clearABar() {_uniqueStorage()._aBar = nil} - var aBaz: ProtobufUnittest_CycleBaz { - get {return _storage._aBaz ?? ProtobufUnittest_CycleBaz()} + var aBaz: SwiftProtoTesting_CycleBaz { + get {_storage._aBaz ?? SwiftProtoTesting_CycleBaz()} set {_uniqueStorage()._aBaz = newValue} } /// Returns true if `aBaz` has been explicitly set. - var hasABaz: Bool {return _storage._aBaz != nil} + var hasABaz: Bool {_storage._aBaz != nil} /// Clears the value of `aBaz`. Subsequent reads from it will return its default value. mutating func clearABaz() {_uniqueStorage()._aBaz = nil} @@ -88,35 +88,35 @@ struct ProtobufUnittest_CycleFoo { fileprivate var _storage = _StorageClass.defaultInstance } -struct ProtobufUnittest_CycleBar { +struct SwiftProtoTesting_CycleBar: @unchecked Sendable { // 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 aBar: ProtobufUnittest_CycleBar { - get {return _storage._aBar ?? ProtobufUnittest_CycleBar()} + var aBar: SwiftProtoTesting_CycleBar { + get {_storage._aBar ?? SwiftProtoTesting_CycleBar()} set {_uniqueStorage()._aBar = newValue} } /// Returns true if `aBar` has been explicitly set. - var hasABar: Bool {return _storage._aBar != nil} + var hasABar: Bool {_storage._aBar != nil} /// Clears the value of `aBar`. Subsequent reads from it will return its default value. mutating func clearABar() {_uniqueStorage()._aBar = nil} - var aBaz: ProtobufUnittest_CycleBaz { - get {return _storage._aBaz ?? ProtobufUnittest_CycleBaz()} + var aBaz: SwiftProtoTesting_CycleBaz { + get {_storage._aBaz ?? SwiftProtoTesting_CycleBaz()} set {_uniqueStorage()._aBaz = newValue} } /// Returns true if `aBaz` has been explicitly set. - var hasABaz: Bool {return _storage._aBaz != nil} + var hasABaz: Bool {_storage._aBaz != nil} /// Clears the value of `aBaz`. Subsequent reads from it will return its default value. mutating func clearABaz() {_uniqueStorage()._aBaz = nil} - var aFoo: ProtobufUnittest_CycleFoo { - get {return _storage._aFoo ?? ProtobufUnittest_CycleFoo()} + var aFoo: SwiftProtoTesting_CycleFoo { + get {_storage._aFoo ?? SwiftProtoTesting_CycleFoo()} set {_uniqueStorage()._aFoo = newValue} } /// Returns true if `aFoo` has been explicitly set. - var hasAFoo: Bool {return _storage._aFoo != nil} + var hasAFoo: Bool {_storage._aFoo != nil} /// Clears the value of `aFoo`. Subsequent reads from it will return its default value. mutating func clearAFoo() {_uniqueStorage()._aFoo = nil} @@ -127,35 +127,35 @@ struct ProtobufUnittest_CycleBar { fileprivate var _storage = _StorageClass.defaultInstance } -struct ProtobufUnittest_CycleBaz { +struct SwiftProtoTesting_CycleBaz: @unchecked Sendable { // 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 aBaz: ProtobufUnittest_CycleBaz { - get {return _storage._aBaz ?? ProtobufUnittest_CycleBaz()} + var aBaz: SwiftProtoTesting_CycleBaz { + get {_storage._aBaz ?? SwiftProtoTesting_CycleBaz()} set {_uniqueStorage()._aBaz = newValue} } /// Returns true if `aBaz` has been explicitly set. - var hasABaz: Bool {return _storage._aBaz != nil} + var hasABaz: Bool {_storage._aBaz != nil} /// Clears the value of `aBaz`. Subsequent reads from it will return its default value. mutating func clearABaz() {_uniqueStorage()._aBaz = nil} - var aFoo: ProtobufUnittest_CycleFoo { - get {return _storage._aFoo ?? ProtobufUnittest_CycleFoo()} + var aFoo: SwiftProtoTesting_CycleFoo { + get {_storage._aFoo ?? SwiftProtoTesting_CycleFoo()} set {_uniqueStorage()._aFoo = newValue} } /// Returns true if `aFoo` has been explicitly set. - var hasAFoo: Bool {return _storage._aFoo != nil} + var hasAFoo: Bool {_storage._aFoo != nil} /// Clears the value of `aFoo`. Subsequent reads from it will return its default value. mutating func clearAFoo() {_uniqueStorage()._aFoo = nil} - var aBar: ProtobufUnittest_CycleBar { - get {return _storage._aBar ?? ProtobufUnittest_CycleBar()} + var aBar: SwiftProtoTesting_CycleBar { + get {_storage._aBar ?? SwiftProtoTesting_CycleBar()} set {_uniqueStorage()._aBar = newValue} } /// Returns true if `aBar` has been explicitly set. - var hasABar: Bool {return _storage._aBar != nil} + var hasABar: Bool {_storage._aBar != nil} /// Clears the value of `aBar`. Subsequent reads from it will return its default value. mutating func clearABar() {_uniqueStorage()._aBar = nil} @@ -166,30 +166,24 @@ struct ProtobufUnittest_CycleBaz { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_CycleFoo: @unchecked Sendable {} -extension ProtobufUnittest_CycleBar: @unchecked Sendable {} -extension ProtobufUnittest_CycleBaz: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_CycleFoo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_CycleFoo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".CycleFoo" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "a_foo"), - 2: .standard(proto: "a_bar"), - 3: .standard(proto: "a_baz"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}a_foo\0\u{3}a_bar\0\u{3}a_baz\0") fileprivate class _StorageClass { - var _aFoo: ProtobufUnittest_CycleFoo? = nil - var _aBar: ProtobufUnittest_CycleBar? = nil - var _aBaz: ProtobufUnittest_CycleBaz? = nil + var _aFoo: SwiftProtoTesting_CycleFoo? = nil + var _aBar: SwiftProtoTesting_CycleBar? = nil + var _aBaz: SwiftProtoTesting_CycleBaz? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -243,7 +237,7 @@ extension ProtobufUnittest_CycleFoo: SwiftProtobuf.Message, SwiftProtobuf._Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_CycleFoo, rhs: ProtobufUnittest_CycleFoo) -> Bool { + static func ==(lhs: SwiftProtoTesting_CycleFoo, rhs: SwiftProtoTesting_CycleFoo) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -260,20 +254,20 @@ extension ProtobufUnittest_CycleFoo: SwiftProtobuf.Message, SwiftProtobuf._Messa } } -extension ProtobufUnittest_CycleBar: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_CycleBar: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".CycleBar" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "a_bar"), - 2: .standard(proto: "a_baz"), - 3: .standard(proto: "a_foo"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}a_bar\0\u{3}a_baz\0\u{3}a_foo\0") fileprivate class _StorageClass { - var _aBar: ProtobufUnittest_CycleBar? = nil - var _aBaz: ProtobufUnittest_CycleBaz? = nil - var _aFoo: ProtobufUnittest_CycleFoo? = nil + var _aBar: SwiftProtoTesting_CycleBar? = nil + var _aBaz: SwiftProtoTesting_CycleBaz? = nil + var _aFoo: SwiftProtoTesting_CycleFoo? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -327,7 +321,7 @@ extension ProtobufUnittest_CycleBar: SwiftProtobuf.Message, SwiftProtobuf._Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_CycleBar, rhs: ProtobufUnittest_CycleBar) -> Bool { + static func ==(lhs: SwiftProtoTesting_CycleBar, rhs: SwiftProtoTesting_CycleBar) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -344,20 +338,20 @@ extension ProtobufUnittest_CycleBar: SwiftProtobuf.Message, SwiftProtobuf._Messa } } -extension ProtobufUnittest_CycleBaz: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_CycleBaz: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".CycleBaz" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "a_baz"), - 2: .standard(proto: "a_foo"), - 3: .standard(proto: "a_bar"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}a_baz\0\u{3}a_foo\0\u{3}a_bar\0") fileprivate class _StorageClass { - var _aBaz: ProtobufUnittest_CycleBaz? = nil - var _aFoo: ProtobufUnittest_CycleFoo? = nil - var _aBar: ProtobufUnittest_CycleBar? = nil + var _aBaz: SwiftProtoTesting_CycleBaz? = nil + var _aFoo: SwiftProtoTesting_CycleFoo? = nil + var _aBar: SwiftProtoTesting_CycleBar? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -411,7 +405,7 @@ extension ProtobufUnittest_CycleBaz: SwiftProtobuf.Message, SwiftProtobuf._Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_CycleBaz, rhs: ProtobufUnittest_CycleBaz) -> Bool { + static func ==(lhs: SwiftProtoTesting_CycleBaz, rhs: SwiftProtoTesting_CycleBaz) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 diff --git a/Tests/SwiftProtobufTests/unittest_swift_deprecated.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_deprecated.pb.swift new file mode 100644 index 000000000..d9ddca6e6 --- /dev/null +++ b/Tests/SwiftProtobufTests/unittest_swift_deprecated.pb.swift @@ -0,0 +1,615 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: unittest_swift_deprecated.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protos/unittest_swift_deprecated.proto - test proto +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2023 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 generation support of deprecated attributes. +/// +// ----------------------------------------------------------------------------- + +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 +} + +/// An enum value marked as deprecated. +enum SwiftProtoTesting_Deprecated_MyEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case one = 1 + + /// Enum comment + /// + /// NOTE: This enum value was marked as deprecated in the .proto file + case two = 2 + + /// NOTE: This enum value was marked as deprecated in the .proto file + case three = 3 + + init() { + self = .one + } + +} + +/// Whole enum marked as deprecated. +/// +/// NOTE: This enum was marked as deprecated in the .proto file. +enum SwiftProtoTesting_Deprecated_MyEnum2: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case one = 1 + case two = 2 + case three = 3 + + init() { + self = .one + } + +} + +/// Marking fields as deprecated. +struct SwiftProtoTesting_Deprecated_MyMsg: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { + // 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. + + /// Field comment + /// + /// NOTE: This field was marked as deprecated in the .proto file. + var stringField: String { + get {_storage._stringField ?? String()} + set {_uniqueStorage()._stringField = newValue} + } + /// Returns true if `stringField` has been explicitly set. + var hasStringField: Bool {_storage._stringField != nil} + /// Clears the value of `stringField`. Subsequent reads from it will return its default value. + mutating func clearStringField() {_uniqueStorage()._stringField = nil} + + /// NOTE: This field was marked as deprecated in the .proto file. + var intField: Int32 { + get {_storage._intField ?? 0} + set {_uniqueStorage()._intField = newValue} + } + /// Returns true if `intField` has been explicitly set. + var hasIntField: Bool {_storage._intField != nil} + /// Clears the value of `intField`. Subsequent reads from it will return its default value. + mutating func clearIntField() {_uniqueStorage()._intField = nil} + + /// NOTE: This field was marked as deprecated in the .proto file. + var fixedField: [UInt32] { + get {_storage._fixedField} + set {_uniqueStorage()._fixedField = newValue} + } + + /// NOTE: This field was marked as deprecated in the .proto file. + var msgField: SwiftProtoTesting_Deprecated_MyMsg { + get {_storage._msgField ?? SwiftProtoTesting_Deprecated_MyMsg()} + set {_uniqueStorage()._msgField = newValue} + } + /// Returns true if `msgField` has been explicitly set. + var hasMsgField: Bool {_storage._msgField != nil} + /// Clears the value of `msgField`. Subsequent reads from it will return its default value. + mutating func clearMsgField() {_uniqueStorage()._msgField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _storage = _StorageClass.defaultInstance +} + +/// Marking extension fields (scoped to a message) as deprecated. +struct SwiftProtoTesting_Deprecated_MsgScope: Sendable { + // 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() {} +} + +/// Whole message marked as deprecated. +/// +/// NOTE: This message was marked as deprecated in the .proto file. +struct SwiftProtoTesting_Deprecated_MyMsg2: @unchecked Sendable { + // 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 stringField: String { + get {_storage._stringField ?? String()} + set {_uniqueStorage()._stringField = newValue} + } + /// Returns true if `stringField` has been explicitly set. + var hasStringField: Bool {_storage._stringField != nil} + /// Clears the value of `stringField`. Subsequent reads from it will return its default value. + mutating func clearStringField() {_uniqueStorage()._stringField = nil} + + var intField: Int32 { + get {_storage._intField ?? 0} + set {_uniqueStorage()._intField = newValue} + } + /// Returns true if `intField` has been explicitly set. + var hasIntField: Bool {_storage._intField != nil} + /// Clears the value of `intField`. Subsequent reads from it will return its default value. + mutating func clearIntField() {_uniqueStorage()._intField = nil} + + var fixedField: [UInt32] { + get {_storage._fixedField} + set {_uniqueStorage()._fixedField = newValue} + } + + var msgField: SwiftProtoTesting_Deprecated_MyMsg2 { + get {_storage._msgField ?? SwiftProtoTesting_Deprecated_MyMsg2()} + set {_uniqueStorage()._msgField = newValue} + } + /// Returns true if `msgField` has been explicitly set. + var hasMsgField: Bool {_storage._msgField != nil} + /// Clears the value of `msgField`. Subsequent reads from it will return its default value. + mutating func clearMsgField() {_uniqueStorage()._msgField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + fileprivate var _storage = _StorageClass.defaultInstance +} + +// MARK: - Extension support defined in unittest_swift_deprecated.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 SwiftProtoTesting_Deprecated_MyMsg { + + /// Extension field comment + /// + /// NOTE: This extension field was marked as deprecated in the .proto file. + var SwiftProtoTesting_Deprecated_stringExtField: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_string_ext_field) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_string_ext_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Deprecated_Extensions_string_ext_field` + /// has been explicitly set. + var hasSwiftProtoTesting_Deprecated_stringExtField: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_string_ext_field) + } + /// Clears the value of extension `SwiftProtoTesting_Deprecated_Extensions_string_ext_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_Deprecated_stringExtField() { + clearExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_string_ext_field) + } + + /// NOTE: This extension field was marked as deprecated in the .proto file. + var SwiftProtoTesting_Deprecated_intExtField: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_int_ext_field) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_int_ext_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Deprecated_Extensions_int_ext_field` + /// has been explicitly set. + var hasSwiftProtoTesting_Deprecated_intExtField: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_int_ext_field) + } + /// Clears the value of extension `SwiftProtoTesting_Deprecated_Extensions_int_ext_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_Deprecated_intExtField() { + clearExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_int_ext_field) + } + + /// NOTE: This extension field was marked as deprecated in the .proto file. + var SwiftProtoTesting_Deprecated_fixedExtField: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_fixed_ext_field) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_fixed_ext_field, value: newValue)} + } + + /// NOTE: This extension field was marked as deprecated in the .proto file. + var SwiftProtoTesting_Deprecated_msgExtField: SwiftProtoTesting_Deprecated_MyMsg { + get {return getExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_msg_ext_field) ?? SwiftProtoTesting_Deprecated_MyMsg()} + set {setExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_msg_ext_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Deprecated_Extensions_msg_ext_field` + /// has been explicitly set. + var hasSwiftProtoTesting_Deprecated_msgExtField: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_msg_ext_field) + } + /// Clears the value of extension `SwiftProtoTesting_Deprecated_Extensions_msg_ext_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_Deprecated_msgExtField() { + clearExtensionValue(ext: SwiftProtoTesting_Deprecated_Extensions_msg_ext_field) + } + + /// Another extension field comment + /// + /// NOTE: This extension field was marked as deprecated in the .proto file. + var SwiftProtoTesting_Deprecated_MsgScope_stringExt2Field: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.string_ext2_field) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.string_ext2_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Deprecated_MsgScope.Extensions.string_ext2_field` + /// has been explicitly set. + var hasSwiftProtoTesting_Deprecated_MsgScope_stringExt2Field: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.string_ext2_field) + } + /// Clears the value of extension `SwiftProtoTesting_Deprecated_MsgScope.Extensions.string_ext2_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_Deprecated_MsgScope_stringExt2Field() { + clearExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.string_ext2_field) + } + + /// NOTE: This extension field was marked as deprecated in the .proto file. + var SwiftProtoTesting_Deprecated_MsgScope_intExt2Field: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.int_ext2_field) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.int_ext2_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Deprecated_MsgScope.Extensions.int_ext2_field` + /// has been explicitly set. + var hasSwiftProtoTesting_Deprecated_MsgScope_intExt2Field: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.int_ext2_field) + } + /// Clears the value of extension `SwiftProtoTesting_Deprecated_MsgScope.Extensions.int_ext2_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_Deprecated_MsgScope_intExt2Field() { + clearExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.int_ext2_field) + } + + /// NOTE: This extension field was marked as deprecated in the .proto file. + var SwiftProtoTesting_Deprecated_MsgScope_fixedExt2Field: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.fixed_ext2_field) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.fixed_ext2_field, value: newValue)} + } + + /// NOTE: This extension field was marked as deprecated in the .proto file. + var SwiftProtoTesting_Deprecated_MsgScope_msgExt2Field: SwiftProtoTesting_Deprecated_MyMsg { + get {return getExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.msg_ext2_field) ?? SwiftProtoTesting_Deprecated_MyMsg()} + set {setExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.msg_ext2_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_Deprecated_MsgScope.Extensions.msg_ext2_field` + /// has been explicitly set. + var hasSwiftProtoTesting_Deprecated_MsgScope_msgExt2Field: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.msg_ext2_field) + } + /// Clears the value of extension `SwiftProtoTesting_Deprecated_MsgScope.Extensions.msg_ext2_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_Deprecated_MsgScope_msgExt2Field() { + clearExtensionValue(ext: SwiftProtoTesting_Deprecated_MsgScope.Extensions.msg_ext2_field) + } + +} + +// MARK: - File's ExtensionMap: SwiftProtoTesting_Deprecated_UnittestSwiftDeprecated_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 SwiftProtoTesting_Deprecated_UnittestSwiftDeprecated_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Deprecated_Extensions_string_ext_field, + SwiftProtoTesting_Deprecated_Extensions_int_ext_field, + SwiftProtoTesting_Deprecated_Extensions_fixed_ext_field, + SwiftProtoTesting_Deprecated_Extensions_msg_ext_field, + SwiftProtoTesting_Deprecated_MsgScope.Extensions.string_ext2_field, + SwiftProtoTesting_Deprecated_MsgScope.Extensions.int_ext2_field, + SwiftProtoTesting_Deprecated_MsgScope.Extensions.fixed_ext2_field, + SwiftProtoTesting_Deprecated_MsgScope.Extensions.msg_ext2_field +] + +// 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. + +/// Extension field comment +/// +/// NOTE: This extension field was marked as deprecated in the .proto file. +let SwiftProtoTesting_Deprecated_Extensions_string_ext_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Deprecated_MyMsg>( + _protobuf_fieldNumber: 101, + fieldName: "swift_proto_testing.deprecated.string_ext_field" +) + +/// NOTE: This extension field was marked as deprecated in the .proto file. +let SwiftProtoTesting_Deprecated_Extensions_int_ext_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Deprecated_MyMsg>( + _protobuf_fieldNumber: 102, + fieldName: "swift_proto_testing.deprecated.int_ext_field" +) + +/// NOTE: This extension field was marked as deprecated in the .proto file. +let SwiftProtoTesting_Deprecated_Extensions_fixed_ext_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Deprecated_MyMsg>( + _protobuf_fieldNumber: 103, + fieldName: "swift_proto_testing.deprecated.fixed_ext_field" +) + +/// NOTE: This extension field was marked as deprecated in the .proto file. +let SwiftProtoTesting_Deprecated_Extensions_msg_ext_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Deprecated_MyMsg>( + _protobuf_fieldNumber: 104, + fieldName: "swift_proto_testing.deprecated.msg_ext_field" +) + +extension SwiftProtoTesting_Deprecated_MsgScope { + enum Extensions { + /// Another extension field comment + /// + /// NOTE: This extension field was marked as deprecated in the .proto file. + static let string_ext2_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Deprecated_MyMsg>( + _protobuf_fieldNumber: 201, + fieldName: "swift_proto_testing.deprecated.MsgScope.string_ext2_field" + ) + + /// NOTE: This extension field was marked as deprecated in the .proto file. + static let int_ext2_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Deprecated_MyMsg>( + _protobuf_fieldNumber: 202, + fieldName: "swift_proto_testing.deprecated.MsgScope.int_ext2_field" + ) + + /// NOTE: This extension field was marked as deprecated in the .proto file. + static let fixed_ext2_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Deprecated_MyMsg>( + _protobuf_fieldNumber: 203, + fieldName: "swift_proto_testing.deprecated.MsgScope.fixed_ext2_field" + ) + + /// NOTE: This extension field was marked as deprecated in the .proto file. + static let msg_ext2_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Deprecated_MyMsg>( + _protobuf_fieldNumber: 204, + fieldName: "swift_proto_testing.deprecated.MsgScope.msg_ext2_field" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_proto_testing.deprecated" + +extension SwiftProtoTesting_Deprecated_MyEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}MYENUM_ONE\0\u{1}MYENUM_TWO\0\u{1}MYENUM_THREE\0") +} + +extension SwiftProtoTesting_Deprecated_MyEnum2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}MYENUM2_ONE\0\u{1}MYENUM2_TWO\0\u{1}MYENUM2_THREE\0") +} + +extension SwiftProtoTesting_Deprecated_MyMsg: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MyMsg" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}string_field\0\u{3}int_field\0\u{3}fixed_field\0\u{3}msg_field\0") + + fileprivate class _StorageClass { + var _stringField: String? = nil + var _intField: Int32? = nil + var _fixedField: [UInt32] = [] + var _msgField: SwiftProtoTesting_Deprecated_MyMsg? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _stringField = source._stringField + _intField = source._intField + _fixedField = source._fixedField + _msgField = source._msgField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._intField == nil {return false} + if let v = _storage._msgField, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._stringField) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._intField) }() + case 3: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._fixedField) }() + case 4: try { try decoder.decodeSingularMessageField(value: &_storage._msgField) }() + case 100..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Deprecated_MyMsg.self, fieldNumber: fieldNumber) }() + default: break + } + } + } + } + + func traverse(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._stringField { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._intField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + if !_storage._fixedField.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._fixedField, fieldNumber: 3) + } + try { if let v = _storage._msgField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 100, end: 536870912) + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Deprecated_MyMsg, rhs: SwiftProtoTesting_Deprecated_MyMsg) -> 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._stringField != rhs_storage._stringField {return false} + if _storage._intField != rhs_storage._intField {return false} + if _storage._fixedField != rhs_storage._fixedField {return false} + if _storage._msgField != rhs_storage._msgField {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension SwiftProtoTesting_Deprecated_MsgScope: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MsgScope" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Deprecated_MsgScope, rhs: SwiftProtoTesting_Deprecated_MsgScope) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} + +extension SwiftProtoTesting_Deprecated_MyMsg2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MyMsg2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}string_field\0\u{3}int_field\0\u{3}fixed_field\0\u{3}msg_field\0") + + fileprivate class _StorageClass { + var _stringField: String? = nil + var _intField: Int32? = nil + var _fixedField: [UInt32] = [] + var _msgField: SwiftProtoTesting_Deprecated_MyMsg2? = nil + + // 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() + + private init() {} + + init(copying source: _StorageClass) { + _stringField = source._stringField + _intField = source._intField + _fixedField = source._fixedField + _msgField = source._msgField + } + } + + fileprivate mutating func _uniqueStorage() -> _StorageClass { + if !isKnownUniquelyReferenced(&_storage) { + _storage = _StorageClass(copying: _storage) + } + return _storage + } + + public var isInitialized: Bool { + return withExtendedLifetime(_storage) { (_storage: _StorageClass) in + if _storage._intField == nil {return false} + if let v = _storage._msgField, !v.isInitialized {return false} + return true + } + } + + mutating func decodeMessage(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._stringField) }() + case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._intField) }() + case 3: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._fixedField) }() + case 4: try { try decoder.decodeSingularMessageField(value: &_storage._msgField) }() + default: break + } + } + } + } + + func traverse(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._stringField { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try { if let v = _storage._intField { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + if !_storage._fixedField.isEmpty { + try visitor.visitRepeatedFixed32Field(value: _storage._fixedField, fieldNumber: 3) + } + try { if let v = _storage._msgField { + try visitor.visitSingularMessageField(value: v, fieldNumber: 4) + } }() + } + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_Deprecated_MyMsg2, rhs: SwiftProtoTesting_Deprecated_MyMsg2) -> 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._stringField != rhs_storage._stringField {return false} + if _storage._intField != rhs_storage._intField {return false} + if _storage._fixedField != rhs_storage._fixedField {return false} + if _storage._msgField != rhs_storage._msgField {return false} + return true + } + if !storagesAreEqual {return false} + } + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Tests/SwiftProtobufTests/unittest_swift_deprecated_file.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_deprecated_file.pb.swift new file mode 100644 index 000000000..ced4ce578 --- /dev/null +++ b/Tests/SwiftProtobufTests/unittest_swift_deprecated_file.pb.swift @@ -0,0 +1,357 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: unittest_swift_deprecated_file.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protos/unittest_swift_deprecated_file.proto - test proto +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2023 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 generation support of deprecated attributes. +/// +// ----------------------------------------------------------------------------- + +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 +} + +/// NOTE: The whole .proto file that defined this enum was marked as deprecated. +enum SwiftProtoTesting_DeprecatedFile_MyEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case one = 1 + case two = 2 + case three = 3 + + init() { + self = .one + } + +} + +/// Message comment +/// +/// NOTE: The whole .proto file that defined this message was marked as deprecated. +struct SwiftProtoTesting_DeprecatedFile_MyMsg: SwiftProtobuf.ExtensibleMessage, Sendable { + // 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 stringField: String { + get {_stringField ?? String()} + set {_stringField = newValue} + } + /// Returns true if `stringField` has been explicitly set. + var hasStringField: Bool {self._stringField != nil} + /// Clears the value of `stringField`. Subsequent reads from it will return its default value. + mutating func clearStringField() {self._stringField = nil} + + var unknownFields = SwiftProtobuf.UnknownStorage() + + init() {} + + var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() + fileprivate var _stringField: String? = nil +} + +/// NOTE: The whole .proto file that defined this message was marked as deprecated. +struct SwiftProtoTesting_DeprecatedFile_MsgScope: Sendable { + // 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() {} +} + +// MARK: - Extension support defined in unittest_swift_deprecated_file.proto. + +// MARK: - Extension Properties + +// Swift Extensions on the extended 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 SwiftProtoTesting_DeprecatedFile_MyMsg { + + /// Extension field comment + /// + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + var SwiftProtoTesting_DeprecatedFile_stringExtField: String { + get {return getExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_string_ext_field) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_string_ext_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_DeprecatedFile_Extensions_string_ext_field` + /// has been explicitly set. + var hasSwiftProtoTesting_DeprecatedFile_stringExtField: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_string_ext_field) + } + /// Clears the value of extension `SwiftProtoTesting_DeprecatedFile_Extensions_string_ext_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_DeprecatedFile_stringExtField() { + clearExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_string_ext_field) + } + + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + var SwiftProtoTesting_DeprecatedFile_intExtField: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_int_ext_field) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_int_ext_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_DeprecatedFile_Extensions_int_ext_field` + /// has been explicitly set. + var hasSwiftProtoTesting_DeprecatedFile_intExtField: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_int_ext_field) + } + /// Clears the value of extension `SwiftProtoTesting_DeprecatedFile_Extensions_int_ext_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_DeprecatedFile_intExtField() { + clearExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_int_ext_field) + } + + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + var SwiftProtoTesting_DeprecatedFile_fixedExtField: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_fixed_ext_field) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_fixed_ext_field, value: newValue)} + } + + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + var SwiftProtoTesting_DeprecatedFile_msgExtField: SwiftProtoTesting_DeprecatedFile_MyMsg { + get {return getExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_msg_ext_field) ?? SwiftProtoTesting_DeprecatedFile_MyMsg()} + set {setExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_msg_ext_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_DeprecatedFile_Extensions_msg_ext_field` + /// has been explicitly set. + var hasSwiftProtoTesting_DeprecatedFile_msgExtField: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_msg_ext_field) + } + /// Clears the value of extension `SwiftProtoTesting_DeprecatedFile_Extensions_msg_ext_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_DeprecatedFile_msgExtField() { + clearExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_Extensions_msg_ext_field) + } + + /// Another extension field comment + /// + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + var SwiftProtoTesting_DeprecatedFile_MsgScope_stringExt2Field: String { + get {return getExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.string_ext2_field) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.string_ext2_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.string_ext2_field` + /// has been explicitly set. + var hasSwiftProtoTesting_DeprecatedFile_MsgScope_stringExt2Field: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.string_ext2_field) + } + /// Clears the value of extension `SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.string_ext2_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_DeprecatedFile_MsgScope_stringExt2Field() { + clearExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.string_ext2_field) + } + + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + var SwiftProtoTesting_DeprecatedFile_MsgScope_intExt2Field: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.int_ext2_field) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.int_ext2_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.int_ext2_field` + /// has been explicitly set. + var hasSwiftProtoTesting_DeprecatedFile_MsgScope_intExt2Field: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.int_ext2_field) + } + /// Clears the value of extension `SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.int_ext2_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_DeprecatedFile_MsgScope_intExt2Field() { + clearExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.int_ext2_field) + } + + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + var SwiftProtoTesting_DeprecatedFile_MsgScope_fixedExt2Field: [UInt32] { + get {return getExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.fixed_ext2_field) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.fixed_ext2_field, value: newValue)} + } + + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + var SwiftProtoTesting_DeprecatedFile_MsgScope_msgExt2Field: SwiftProtoTesting_DeprecatedFile_MyMsg { + get {return getExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.msg_ext2_field) ?? SwiftProtoTesting_DeprecatedFile_MyMsg()} + set {setExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.msg_ext2_field, value: newValue)} + } + /// Returns true if extension `SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.msg_ext2_field` + /// has been explicitly set. + var hasSwiftProtoTesting_DeprecatedFile_MsgScope_msgExt2Field: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.msg_ext2_field) + } + /// Clears the value of extension `SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.msg_ext2_field`. + /// Subsequent reads from it will return its default value. + mutating func clearSwiftProtoTesting_DeprecatedFile_MsgScope_msgExt2Field() { + clearExtensionValue(ext: SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.msg_ext2_field) + } + +} + +// MARK: - File's ExtensionMap: SwiftProtoTesting_DeprecatedFile_UnittestSwiftDeprecatedFile_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 SwiftProtoTesting_DeprecatedFile_UnittestSwiftDeprecatedFile_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_DeprecatedFile_Extensions_string_ext_field, + SwiftProtoTesting_DeprecatedFile_Extensions_int_ext_field, + SwiftProtoTesting_DeprecatedFile_Extensions_fixed_ext_field, + SwiftProtoTesting_DeprecatedFile_Extensions_msg_ext_field, + SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.string_ext2_field, + SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.int_ext2_field, + SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.fixed_ext2_field, + SwiftProtoTesting_DeprecatedFile_MsgScope.Extensions.msg_ext2_field +] + +// 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. + +/// Extension field comment +/// +/// NOTE: The whole .proto file that defined this extension field was marked as deprecated. +let SwiftProtoTesting_DeprecatedFile_Extensions_string_ext_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_DeprecatedFile_MyMsg>( + _protobuf_fieldNumber: 101, + fieldName: "swift_proto_testing.deprecated_file.string_ext_field" +) + +/// NOTE: The whole .proto file that defined this extension field was marked as deprecated. +let SwiftProtoTesting_DeprecatedFile_Extensions_int_ext_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_DeprecatedFile_MyMsg>( + _protobuf_fieldNumber: 102, + fieldName: "swift_proto_testing.deprecated_file.int_ext_field" +) + +/// NOTE: The whole .proto file that defined this extension field was marked as deprecated. +let SwiftProtoTesting_DeprecatedFile_Extensions_fixed_ext_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_DeprecatedFile_MyMsg>( + _protobuf_fieldNumber: 103, + fieldName: "swift_proto_testing.deprecated_file.fixed_ext_field" +) + +/// NOTE: The whole .proto file that defined this extension field was marked as deprecated. +let SwiftProtoTesting_DeprecatedFile_Extensions_msg_ext_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_DeprecatedFile_MyMsg>( + _protobuf_fieldNumber: 104, + fieldName: "swift_proto_testing.deprecated_file.msg_ext_field" +) + +extension SwiftProtoTesting_DeprecatedFile_MsgScope { + enum Extensions { + /// Another extension field comment + /// + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + static let string_ext2_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_DeprecatedFile_MyMsg>( + _protobuf_fieldNumber: 201, + fieldName: "swift_proto_testing.deprecated_file.MsgScope.string_ext2_field" + ) + + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + static let int_ext2_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_DeprecatedFile_MyMsg>( + _protobuf_fieldNumber: 202, + fieldName: "swift_proto_testing.deprecated_file.MsgScope.int_ext2_field" + ) + + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + static let fixed_ext2_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_DeprecatedFile_MyMsg>( + _protobuf_fieldNumber: 203, + fieldName: "swift_proto_testing.deprecated_file.MsgScope.fixed_ext2_field" + ) + + /// NOTE: The whole .proto file that defined this extension field was marked as deprecated. + static let msg_ext2_field = SwiftProtobuf.MessageExtension, SwiftProtoTesting_DeprecatedFile_MyMsg>( + _protobuf_fieldNumber: 204, + fieldName: "swift_proto_testing.deprecated_file.MsgScope.msg_ext2_field" + ) + } +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_proto_testing.deprecated_file" + +extension SwiftProtoTesting_DeprecatedFile_MyEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}MYENUM_ONE\0\u{1}MYENUM_TWO\0\u{1}MYENUM_THREE\0") +} + +extension SwiftProtoTesting_DeprecatedFile_MyMsg: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MyMsg" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}string_field\0") + + public var isInitialized: Bool { + if !_protobuf_extensionFieldValues.isInitialized {return false} + return true + } + + 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._stringField) }() + case 100..<536870912: + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_DeprecatedFile_MyMsg.self, fieldNumber: fieldNumber) }() + 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 + try { if let v = self._stringField { + try visitor.visitSingularStringField(value: v, fieldNumber: 1) + } }() + try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 100, end: 536870912) + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_DeprecatedFile_MyMsg, rhs: SwiftProtoTesting_DeprecatedFile_MyMsg) -> Bool { + if lhs._stringField != rhs._stringField {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} + return true + } +} + +extension SwiftProtoTesting_DeprecatedFile_MsgScope: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".MsgScope" + static let _protobuf_nameMap = SwiftProtobuf._NameMap() + + mutating func decodeMessage(decoder: inout D) throws { + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} + } + + func traverse(visitor: inout V) throws { + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_DeprecatedFile_MsgScope, rhs: SwiftProtoTesting_DeprecatedFile_MsgScope) -> Bool { + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Tests/SwiftProtobufTests/unittest_swift_enum_optional_default.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_enum_optional_default.pb.swift index b731aa90c..14acd40f2 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_enum_optional_default.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_enum_optional_default.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_enum_optional_default.proto @@ -23,7 +24,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -36,61 +36,47 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_Extend_EnumOptionalDefault { +struct SwiftProtoTesting_Extend_EnumOptionalDefault: Sendable { // 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() - struct NestedMessage { + struct NestedMessage: @unchecked Sendable { // 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. /// The circular reference here forces the generator to /// implement heap-backed storage. - var message: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage { - get {return _storage._message ?? ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage()} + var message: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage { + get {_storage._message ?? SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage()} set {_uniqueStorage()._message = newValue} } /// Returns true if `message` has been explicitly set. - var hasMessage: Bool {return _storage._message != nil} + var hasMessage: Bool {_storage._message != nil} /// Clears the value of `message`. Subsequent reads from it will return its default value. mutating func clearMessage() {_uniqueStorage()._message = nil} - var optionalEnum: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage.Enum { - get {return _storage._optionalEnum ?? .foo} + var optionalEnum: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage.Enum { + get {_storage._optionalEnum ?? .foo} set {_uniqueStorage()._optionalEnum = newValue} } /// Returns true if `optionalEnum` has been explicitly set. - var hasOptionalEnum: Bool {return _storage._optionalEnum != nil} + var hasOptionalEnum: Bool {_storage._optionalEnum != nil} /// Clears the value of `optionalEnum`. Subsequent reads from it will return its default value. mutating func clearOptionalEnum() {_uniqueStorage()._optionalEnum = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - enum Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 0 + enum Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 init() { self = .foo } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .foo - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo: return 0 - } - } - } init() {} @@ -98,108 +84,75 @@ struct ProtobufUnittest_Extend_EnumOptionalDefault { fileprivate var _storage = _StorageClass.defaultInstance } - struct NestedMessage2 { + struct NestedMessage2: Sendable { // 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 optionalEnum: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2.Enum { - get {return _optionalEnum ?? .foo} + var optionalEnum: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage2.Enum { + get {_optionalEnum ?? .foo} set {_optionalEnum = newValue} } /// Returns true if `optionalEnum` has been explicitly set. - var hasOptionalEnum: Bool {return self._optionalEnum != nil} + var hasOptionalEnum: Bool {self._optionalEnum != nil} /// Clears the value of `optionalEnum`. Subsequent reads from it will return its default value. mutating func clearOptionalEnum() {self._optionalEnum = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - enum Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 0 + enum Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 init() { self = .foo } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .foo - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo: return 0 - } - } - } init() {} - fileprivate var _optionalEnum: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2.Enum? = nil + fileprivate var _optionalEnum: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage2.Enum? = nil } init() {} } -#if swift(>=4.2) - -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage.Enum: CaseIterable { - // Support synthesized by the compiler. -} - -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2.Enum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_Extend_EnumOptionalDefault: @unchecked Sendable {} -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage: @unchecked Sendable {} -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage.Enum: @unchecked Sendable {} -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2: @unchecked Sendable {} -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2.Enum: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest.extend" +fileprivate let _protobuf_package = "swift_proto_testing.extend" -extension ProtobufUnittest_Extend_EnumOptionalDefault: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend_EnumOptionalDefault: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".EnumOptionalDefault" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_EnumOptionalDefault, rhs: ProtobufUnittest_Extend_EnumOptionalDefault) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_EnumOptionalDefault, rhs: SwiftProtoTesting_Extend_EnumOptionalDefault) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_Extend_EnumOptionalDefault.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "message"), - 17: .standard(proto: "optional_enum"), - ] +extension SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Extend_EnumOptionalDefault.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}message\0\u{4}\u{10}optional_enum\0") fileprivate class _StorageClass { - var _message: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage? = nil - var _optionalEnum: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage.Enum? = nil + var _message: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage? = nil + var _optionalEnum: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage.Enum? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -248,7 +201,7 @@ extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage: SwiftProtob try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage, rhs: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage, rhs: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -264,17 +217,13 @@ extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage: SwiftProtob } } -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage.Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOO"), - ] +extension SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage.Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOO\0") } -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_Extend_EnumOptionalDefault.protoMessageName + ".NestedMessage2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 17: .standard(proto: "optional_enum"), - ] +extension SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Extend_EnumOptionalDefault.protoMessageName + ".NestedMessage2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{11}optional_enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -299,15 +248,13 @@ extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2: SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2, rhs: ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage2, rhs: SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage2) -> Bool { if lhs._optionalEnum != rhs._optionalEnum {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Extend_EnumOptionalDefault.NestedMessage2.Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOO"), - ] +extension SwiftProtoTesting_Extend_EnumOptionalDefault.NestedMessage2.Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOO\0") } diff --git a/Reference/unittest_swift_enum.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_enum_proto2.pb.swift similarity index 50% rename from Reference/unittest_swift_enum.pb.swift rename to Tests/SwiftProtobufTests/unittest_swift_enum_proto2.pb.swift index 638298ced..f31aa1d97 100644 --- a/Reference/unittest_swift_enum.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_enum_proto2.pb.swift @@ -1,8 +1,9 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: unittest_swift_enum.proto +// Source: unittest_swift_enum_proto2.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ @@ -37,7 +38,6 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -50,223 +50,98 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_SwiftEnumTest { +struct SwiftProtoTesting_Enum2_SwiftEnumTest: Sendable { // 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 values1: [ProtobufUnittest_SwiftEnumTest.EnumTest1] = [] + var values1: [SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTest1] = [] - var values2: [ProtobufUnittest_SwiftEnumTest.EnumTest2] = [] + var values2: [SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTest2] = [] - var values3: [ProtobufUnittest_SwiftEnumTest.EnumTestNoStem] = [] + var values3: [SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTestNoStem] = [] - var values4: [ProtobufUnittest_SwiftEnumTest.EnumTestReservedWord] = [] + var values4: [SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTestReservedWord] = [] var unknownFields = SwiftProtobuf.UnknownStorage() - enum EnumTest1: SwiftProtobuf.Enum { - typealias RawValue = Int - case firstValue // = 1 - case secondValue // = 2 + enum EnumTest1: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case firstValue = 1 + case secondValue = 2 init() { self = .firstValue } - init?(rawValue: Int) { - switch rawValue { - case 1: self = .firstValue - case 2: self = .secondValue - default: return nil - } - } - - var rawValue: Int { - switch self { - case .firstValue: return 1 - case .secondValue: return 2 - } - } - } - enum EnumTest2: SwiftProtobuf.Enum { - typealias RawValue = Int - case firstValue // = 1 - case secondValue // = 2 + enum EnumTest2: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case firstValue = 1 + case secondValue = 2 init() { self = .firstValue } - init?(rawValue: Int) { - switch rawValue { - case 1: self = .firstValue - case 2: self = .secondValue - default: return nil - } - } - - var rawValue: Int { - switch self { - case .firstValue: return 1 - case .secondValue: return 2 - } - } - } - enum EnumTestNoStem: SwiftProtobuf.Enum { - typealias RawValue = Int - case enumTestNoStem1 // = 1 - case enumTestNoStem2 // = 2 + enum EnumTestNoStem: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case enumTestNoStem1 = 1 + case enumTestNoStem2 = 2 init() { self = .enumTestNoStem1 } - init?(rawValue: Int) { - switch rawValue { - case 1: self = .enumTestNoStem1 - case 2: self = .enumTestNoStem2 - default: return nil - } - } - - var rawValue: Int { - switch self { - case .enumTestNoStem1: return 1 - case .enumTestNoStem2: return 2 - } - } - } - enum EnumTestReservedWord: SwiftProtobuf.Enum { - typealias RawValue = Int - case `var` // = 1 - case notReserved // = 2 + enum EnumTestReservedWord: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case `var` = 1 + case notReserved = 2 init() { self = .var } - init?(rawValue: Int) { - switch rawValue { - case 1: self = .var - case 2: self = .notReserved - default: return nil - } - } - - var rawValue: Int { - switch self { - case .var: return 1 - case .notReserved: return 2 - } - } - } init() {} } -#if swift(>=4.2) - -extension ProtobufUnittest_SwiftEnumTest.EnumTest1: CaseIterable { - // Support synthesized by the compiler. -} - -extension ProtobufUnittest_SwiftEnumTest.EnumTest2: CaseIterable { - // Support synthesized by the compiler. -} - -extension ProtobufUnittest_SwiftEnumTest.EnumTestNoStem: CaseIterable { - // Support synthesized by the compiler. -} - -extension ProtobufUnittest_SwiftEnumTest.EnumTestReservedWord: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_SwiftEnumWithAliasTest { +struct SwiftProtoTesting_Enum2_SwiftEnumWithAliasTest: Sendable { // 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 values: [ProtobufUnittest_SwiftEnumWithAliasTest.EnumWithAlias] = [] + var values: [SwiftProtoTesting_Enum2_SwiftEnumWithAliasTest.EnumWithAlias] = [] var unknownFields = SwiftProtobuf.UnknownStorage() - enum EnumWithAlias: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo1 // = 1 + enum EnumWithAlias: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo1 = 1 static let foo2 = foo1 /// out of value order to test allCases - case baz1 // = 3 - case bar1 // = 2 + case baz1 = 3 + case bar1 = 2 static let bar2 = bar1 init() { self = .foo1 } - init?(rawValue: Int) { - switch rawValue { - case 1: self = .foo1 - case 2: self = .bar1 - case 3: self = .baz1 - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo1: return 1 - case .bar1: return 2 - case .baz1: return 3 - } - } - } init() {} } -#if swift(>=4.2) - -extension ProtobufUnittest_SwiftEnumWithAliasTest.EnumWithAlias: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_SwiftEnumTest: @unchecked Sendable {} -extension ProtobufUnittest_SwiftEnumTest.EnumTest1: @unchecked Sendable {} -extension ProtobufUnittest_SwiftEnumTest.EnumTest2: @unchecked Sendable {} -extension ProtobufUnittest_SwiftEnumTest.EnumTestNoStem: @unchecked Sendable {} -extension ProtobufUnittest_SwiftEnumTest.EnumTestReservedWord: @unchecked Sendable {} -extension ProtobufUnittest_SwiftEnumWithAliasTest: @unchecked Sendable {} -extension ProtobufUnittest_SwiftEnumWithAliasTest.EnumWithAlias: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing.enum2" -extension ProtobufUnittest_SwiftEnumTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Enum2_SwiftEnumTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SwiftEnumTest" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "values1"), - 2: .same(proto: "values2"), - 3: .same(proto: "values3"), - 4: .same(proto: "values4"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}values1\0\u{1}values2\0\u{1}values3\0\u{1}values4\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -299,7 +174,7 @@ extension ProtobufUnittest_SwiftEnumTest: SwiftProtobuf.Message, SwiftProtobuf._ try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_SwiftEnumTest, rhs: ProtobufUnittest_SwiftEnumTest) -> Bool { + static func ==(lhs: SwiftProtoTesting_Enum2_SwiftEnumTest, rhs: SwiftProtoTesting_Enum2_SwiftEnumTest) -> Bool { if lhs.values1 != rhs.values1 {return false} if lhs.values2 != rhs.values2 {return false} if lhs.values3 != rhs.values3 {return false} @@ -309,39 +184,25 @@ extension ProtobufUnittest_SwiftEnumTest: SwiftProtobuf.Message, SwiftProtobuf._ } } -extension ProtobufUnittest_SwiftEnumTest.EnumTest1: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ENUM_TEST_1_FIRST_VALUE"), - 2: .same(proto: "ENUM_TEST_1_SECOND_VALUE"), - ] +extension SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTest1: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ENUM_TEST_1_FIRST_VALUE\0\u{1}ENUM_TEST_1_SECOND_VALUE\0") } -extension ProtobufUnittest_SwiftEnumTest.EnumTest2: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ENUM_TEST_2_FIRST_VALUE"), - 2: .same(proto: "SECOND_VALUE"), - ] +extension SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTest2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ENUM_TEST_2_FIRST_VALUE\0\u{1}SECOND_VALUE\0") } -extension ProtobufUnittest_SwiftEnumTest.EnumTestNoStem: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ENUM_TEST_NO_STEM_1"), - 2: .same(proto: "ENUM_TEST_NO_STEM_2"), - ] +extension SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTestNoStem: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ENUM_TEST_NO_STEM_1\0\u{1}ENUM_TEST_NO_STEM_2\0") } -extension ProtobufUnittest_SwiftEnumTest.EnumTestReservedWord: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ENUM_TEST_RESERVED_WORD_VAR"), - 2: .same(proto: "ENUM_TEST_RESERVED_WORD_NOT_RESERVED"), - ] +extension SwiftProtoTesting_Enum2_SwiftEnumTest.EnumTestReservedWord: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ENUM_TEST_RESERVED_WORD_VAR\0\u{1}ENUM_TEST_RESERVED_WORD_NOT_RESERVED\0") } -extension ProtobufUnittest_SwiftEnumWithAliasTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Enum2_SwiftEnumWithAliasTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SwiftEnumWithAliasTest" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "values"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}values\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -362,17 +223,13 @@ extension ProtobufUnittest_SwiftEnumWithAliasTest: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_SwiftEnumWithAliasTest, rhs: ProtobufUnittest_SwiftEnumWithAliasTest) -> Bool { + static func ==(lhs: SwiftProtoTesting_Enum2_SwiftEnumWithAliasTest, rhs: SwiftProtoTesting_Enum2_SwiftEnumWithAliasTest) -> Bool { if lhs.values != rhs.values {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_SwiftEnumWithAliasTest.EnumWithAlias: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .aliased(proto: "FOO1", aliases: ["FOO2"]), - 2: .aliased(proto: "BAR1", aliases: ["BAR2"]), - 3: .same(proto: "BAZ1"), - ] +extension SwiftProtoTesting_Enum2_SwiftEnumWithAliasTest.EnumWithAlias: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{9}FOO1\0\u{1}FOO2\0\u{9}BAR1\0\u{1}BAR2\0\u{1}BAZ1\0") } diff --git a/Tests/SwiftProtobufTests/unittest_swift_enum_proto3.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_enum_proto3.pb.swift index 1733eb031..cb14ffe62 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_enum_proto3.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_enum_proto3.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_enum_proto3.proto @@ -37,7 +38,6 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -50,22 +50,22 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct Protobuf3Unittest_SwiftEnumTest { +struct SwiftProtoTesting_Enum3_SwiftEnumTest: Sendable { // 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 values1: [Protobuf3Unittest_SwiftEnumTest.EnumTest1] = [] + var values1: [SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTest1] = [] - var values2: [Protobuf3Unittest_SwiftEnumTest.EnumTest2] = [] + var values2: [SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTest2] = [] - var values3: [Protobuf3Unittest_SwiftEnumTest.EnumTestNoStem] = [] + var values3: [SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTestNoStem] = [] - var values4: [Protobuf3Unittest_SwiftEnumTest.EnumTestReservedWord] = [] + var values4: [SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTestReservedWord] = [] var unknownFields = SwiftProtobuf.UnknownStorage() - enum EnumTest1: SwiftProtobuf.Enum { + enum EnumTest1: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case firstValue // = 0 case secondValue // = 2 @@ -91,9 +91,15 @@ struct Protobuf3Unittest_SwiftEnumTest { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTest1] = [ + .firstValue, + .secondValue, + ] + } - enum EnumTest2: SwiftProtobuf.Enum { + enum EnumTest2: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case firstValue // = 0 case secondValue // = 2 @@ -119,9 +125,15 @@ struct Protobuf3Unittest_SwiftEnumTest { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTest2] = [ + .firstValue, + .secondValue, + ] + } - enum EnumTestNoStem: SwiftProtobuf.Enum { + enum EnumTestNoStem: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case enumTestNoStem1 // = 0 case enumTestNoStem2 // = 2 @@ -147,9 +159,15 @@ struct Protobuf3Unittest_SwiftEnumTest { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTestNoStem] = [ + .enumTestNoStem1, + .enumTestNoStem2, + ] + } - enum EnumTestReservedWord: SwiftProtobuf.Enum { + enum EnumTestReservedWord: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case `var` // = 0 case notReserved // = 2 @@ -175,57 +193,27 @@ struct Protobuf3Unittest_SwiftEnumTest { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTestReservedWord] = [ + .var, + .notReserved, + ] + } init() {} } -#if swift(>=4.2) - -extension Protobuf3Unittest_SwiftEnumTest.EnumTest1: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Protobuf3Unittest_SwiftEnumTest.EnumTest1] = [ - .firstValue, - .secondValue, - ] -} - -extension Protobuf3Unittest_SwiftEnumTest.EnumTest2: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Protobuf3Unittest_SwiftEnumTest.EnumTest2] = [ - .firstValue, - .secondValue, - ] -} - -extension Protobuf3Unittest_SwiftEnumTest.EnumTestNoStem: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Protobuf3Unittest_SwiftEnumTest.EnumTestNoStem] = [ - .enumTestNoStem1, - .enumTestNoStem2, - ] -} - -extension Protobuf3Unittest_SwiftEnumTest.EnumTestReservedWord: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Protobuf3Unittest_SwiftEnumTest.EnumTestReservedWord] = [ - .var, - .notReserved, - ] -} - -#endif // swift(>=4.2) - -struct Protobuf3Unittest_SwiftEnumWithAliasTest { +struct SwiftProtoTesting_Enum3_SwiftEnumWithAliasTest: Sendable { // 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 values: [Protobuf3Unittest_SwiftEnumWithAliasTest.EnumWithAlias] = [] + var values: [SwiftProtoTesting_Enum3_SwiftEnumWithAliasTest.EnumWithAlias] = [] var unknownFields = SwiftProtobuf.UnknownStorage() - enum EnumWithAlias: SwiftProtobuf.Enum { + enum EnumWithAlias: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foo1 // = 0 static let foo2 = foo1 @@ -258,46 +246,25 @@ struct Protobuf3Unittest_SwiftEnumWithAliasTest { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Enum3_SwiftEnumWithAliasTest.EnumWithAlias] = [ + .foo1, + .baz1, + .bar1, + ] + } init() {} } -#if swift(>=4.2) - -extension Protobuf3Unittest_SwiftEnumWithAliasTest.EnumWithAlias: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [Protobuf3Unittest_SwiftEnumWithAliasTest.EnumWithAlias] = [ - .foo1, - .baz1, - .bar1, - ] -} - -#endif // swift(>=4.2) - -#if swift(>=5.5) && canImport(_Concurrency) -extension Protobuf3Unittest_SwiftEnumTest: @unchecked Sendable {} -extension Protobuf3Unittest_SwiftEnumTest.EnumTest1: @unchecked Sendable {} -extension Protobuf3Unittest_SwiftEnumTest.EnumTest2: @unchecked Sendable {} -extension Protobuf3Unittest_SwiftEnumTest.EnumTestNoStem: @unchecked Sendable {} -extension Protobuf3Unittest_SwiftEnumTest.EnumTestReservedWord: @unchecked Sendable {} -extension Protobuf3Unittest_SwiftEnumWithAliasTest: @unchecked Sendable {} -extension Protobuf3Unittest_SwiftEnumWithAliasTest.EnumWithAlias: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf3_unittest" +fileprivate let _protobuf_package = "swift_proto_testing.enum3" -extension Protobuf3Unittest_SwiftEnumTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Enum3_SwiftEnumTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SwiftEnumTest" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "values1"), - 2: .same(proto: "values2"), - 3: .same(proto: "values3"), - 4: .same(proto: "values4"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}values1\0\u{1}values2\0\u{1}values3\0\u{1}values4\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -330,7 +297,7 @@ extension Protobuf3Unittest_SwiftEnumTest: SwiftProtobuf.Message, SwiftProtobuf. try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Protobuf3Unittest_SwiftEnumTest, rhs: Protobuf3Unittest_SwiftEnumTest) -> Bool { + static func ==(lhs: SwiftProtoTesting_Enum3_SwiftEnumTest, rhs: SwiftProtoTesting_Enum3_SwiftEnumTest) -> Bool { if lhs.values1 != rhs.values1 {return false} if lhs.values2 != rhs.values2 {return false} if lhs.values3 != rhs.values3 {return false} @@ -340,39 +307,25 @@ extension Protobuf3Unittest_SwiftEnumTest: SwiftProtobuf.Message, SwiftProtobuf. } } -extension Protobuf3Unittest_SwiftEnumTest.EnumTest1: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ENUM_TEST_1_FIRST_VALUE"), - 2: .same(proto: "ENUM_TEST_1_SECOND_VALUE"), - ] +extension SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTest1: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ENUM_TEST_1_FIRST_VALUE\0\u{2}\u{2}ENUM_TEST_1_SECOND_VALUE\0") } -extension Protobuf3Unittest_SwiftEnumTest.EnumTest2: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ENUM_TEST_2_FIRST_VALUE"), - 2: .same(proto: "SECOND_VALUE"), - ] +extension SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTest2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ENUM_TEST_2_FIRST_VALUE\0\u{2}\u{2}SECOND_VALUE\0") } -extension Protobuf3Unittest_SwiftEnumTest.EnumTestNoStem: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ENUM_TEST_NO_STEM_1"), - 2: .same(proto: "ENUM_TEST_NO_STEM_2"), - ] +extension SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTestNoStem: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ENUM_TEST_NO_STEM_1\0\u{2}\u{2}ENUM_TEST_NO_STEM_2\0") } -extension Protobuf3Unittest_SwiftEnumTest.EnumTestReservedWord: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ENUM_TEST_RESERVED_WORD_VAR"), - 2: .same(proto: "ENUM_TEST_RESERVED_WORD_NOT_RESERVED"), - ] +extension SwiftProtoTesting_Enum3_SwiftEnumTest.EnumTestReservedWord: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ENUM_TEST_RESERVED_WORD_VAR\0\u{2}\u{2}ENUM_TEST_RESERVED_WORD_NOT_RESERVED\0") } -extension Protobuf3Unittest_SwiftEnumWithAliasTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Enum3_SwiftEnumWithAliasTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SwiftEnumWithAliasTest" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "values"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}values\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -393,17 +346,13 @@ extension Protobuf3Unittest_SwiftEnumWithAliasTest: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Protobuf3Unittest_SwiftEnumWithAliasTest, rhs: Protobuf3Unittest_SwiftEnumWithAliasTest) -> Bool { + static func ==(lhs: SwiftProtoTesting_Enum3_SwiftEnumWithAliasTest, rhs: SwiftProtoTesting_Enum3_SwiftEnumWithAliasTest) -> Bool { if lhs.values != rhs.values {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension Protobuf3Unittest_SwiftEnumWithAliasTest.EnumWithAlias: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .aliased(proto: "FOO1", aliases: ["FOO2"]), - 2: .aliased(proto: "BAR1", aliases: ["BAR2"]), - 3: .same(proto: "BAZ1"), - ] +extension SwiftProtoTesting_Enum3_SwiftEnumWithAliasTest.EnumWithAlias: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{a}\0FOO1\0\u{1}FOO2\0\u{a}\u{2}BAR1\0\u{1}BAR2\0\u{1}BAZ1\0") } diff --git a/Tests/SwiftProtobufTests/unittest_swift_extension.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_extension.pb.swift index 3783af78a..0389f7b4f 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_extension.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_extension.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_extension.proto @@ -23,7 +24,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -36,31 +36,31 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_Extend_Foo { +struct SwiftProtoTesting_Extend_Foo: Sendable { // 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() - struct Bar { + struct Bar: Sendable { // 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() - struct Baz: SwiftProtobuf.ExtensibleMessage { + struct Baz: SwiftProtobuf.ExtensibleMessage, Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -78,18 +78,18 @@ struct ProtobufUnittest_Extend_Foo { init() {} } -struct ProtobufUnittest_Extend_C { +struct SwiftProtoTesting_Extend_C: Sendable { // 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. /// extensions 10 to 20; var c: Int64 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -100,7 +100,7 @@ struct ProtobufUnittest_Extend_C { fileprivate var _c: Int64? = nil } -struct ProtobufUnittest_Extend_Msg1: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Extend_Msg1: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -112,7 +112,7 @@ struct ProtobufUnittest_Extend_Msg1: SwiftProtobuf.ExtensibleMessage { var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct ProtobufUnittest_Extend_Msg2: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Extend_Msg2: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -124,17 +124,17 @@ struct ProtobufUnittest_Extend_Msg2: SwiftProtobuf.ExtensibleMessage { var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct ProtobufUnittest_Extend_MsgNoStorage: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Extend_MsgNoStorage: SwiftProtobuf.ExtensibleMessage, Sendable { // 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 x: Int32 { - get {return _x ?? 0} + get {_x ?? 0} set {_x = newValue} } /// Returns true if `x` has been explicitly set. - var hasX: Bool {return self._x != nil} + var hasX: Bool {self._x != nil} /// Clears the value of `x`. Subsequent reads from it will return its default value. mutating func clearX() {self._x = nil} @@ -146,27 +146,27 @@ struct ProtobufUnittest_Extend_MsgNoStorage: SwiftProtobuf.ExtensibleMessage { fileprivate var _x: Int32? = nil } -struct ProtobufUnittest_Extend_MsgUsesStorage: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Extend_MsgUsesStorage: SwiftProtobuf.ExtensibleMessage, @unchecked Sendable { // 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 x: Int32 { - get {return _storage._x ?? 0} + get {_storage._x ?? 0} set {_uniqueStorage()._x = newValue} } /// Returns true if `x` has been explicitly set. - var hasX: Bool {return _storage._x != nil} + var hasX: Bool {_storage._x != nil} /// Clears the value of `x`. Subsequent reads from it will return its default value. mutating func clearX() {_uniqueStorage()._x = nil} /// Recursive class (i.e. - can build a graph), forces _StorageClass. - var y: ProtobufUnittest_Extend_MsgUsesStorage { - get {return _storage._y ?? ProtobufUnittest_Extend_MsgUsesStorage()} + var y: SwiftProtoTesting_Extend_MsgUsesStorage { + get {_storage._y ?? SwiftProtoTesting_Extend_MsgUsesStorage()} set {_uniqueStorage()._y = newValue} } /// Returns true if `y` has been explicitly set. - var hasY: Bool {return _storage._y != nil} + var hasY: Bool {_storage._y != nil} /// Clears the value of `y`. Subsequent reads from it will return its default value. mutating func clearY() {_uniqueStorage()._y = nil} @@ -178,291 +178,278 @@ struct ProtobufUnittest_Extend_MsgUsesStorage: SwiftProtobuf.ExtensibleMessage { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_Extend_Foo: @unchecked Sendable {} -extension ProtobufUnittest_Extend_Foo.Bar: @unchecked Sendable {} -extension ProtobufUnittest_Extend_Foo.Bar.Baz: @unchecked Sendable {} -extension ProtobufUnittest_Extend_C: @unchecked Sendable {} -extension ProtobufUnittest_Extend_Msg1: @unchecked Sendable {} -extension ProtobufUnittest_Extend_Msg2: @unchecked Sendable {} -extension ProtobufUnittest_Extend_MsgNoStorage: @unchecked Sendable {} -extension ProtobufUnittest_Extend_MsgUsesStorage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_extension.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 ProtobufUnittest_Extend_Foo.Bar.Baz { +extension SwiftProtoTesting_Extend_Foo.Bar.Baz { - var ProtobufUnittest_Extend_b: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extend_Extensions_b) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extend_Extensions_b, value: newValue)} + var SwiftProtoTesting_Extend_b: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_b) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_b, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend_Extensions_b` + /// Returns true if extension `SwiftProtoTesting_Extend_Extensions_b` /// has been explicitly set. - var hasProtobufUnittest_Extend_b: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend_Extensions_b) + var hasSwiftProtoTesting_Extend_b: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_b) } - /// Clears the value of extension `ProtobufUnittest_Extend_Extensions_b`. + /// Clears the value of extension `SwiftProtoTesting_Extend_Extensions_b`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend_b() { - clearExtensionValue(ext: ProtobufUnittest_Extend_Extensions_b) + mutating func clearSwiftProtoTesting_Extend_b() { + clearExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_b) } - var ProtobufUnittest_Extend_c: ProtobufUnittest_Extend_C { - get {return getExtensionValue(ext: ProtobufUnittest_Extend_Extensions_C) ?? ProtobufUnittest_Extend_C()} - set {setExtensionValue(ext: ProtobufUnittest_Extend_Extensions_C, value: newValue)} + var SwiftProtoTesting_Extend_c: SwiftProtoTesting_Extend_C { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_C) ?? SwiftProtoTesting_Extend_C()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_C, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend_Extensions_C` + /// Returns true if extension `SwiftProtoTesting_Extend_Extensions_C` /// has been explicitly set. - var hasProtobufUnittest_Extend_c: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend_Extensions_C) + var hasSwiftProtoTesting_Extend_c: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_C) } - /// Clears the value of extension `ProtobufUnittest_Extend_Extensions_C`. + /// Clears the value of extension `SwiftProtoTesting_Extend_Extensions_C`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend_c() { - clearExtensionValue(ext: ProtobufUnittest_Extend_Extensions_C) + mutating func clearSwiftProtoTesting_Extend_c() { + clearExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_C) } } -extension ProtobufUnittest_Extend_Msg1 { +extension SwiftProtoTesting_Extend_Msg1 { - var ProtobufUnittest_Extend_aB: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extend_Extensions_a_b) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extend_Extensions_a_b, value: newValue)} + var SwiftProtoTesting_Extend_aB: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_a_b) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_a_b, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend_Extensions_a_b` + /// Returns true if extension `SwiftProtoTesting_Extend_Extensions_a_b` /// has been explicitly set. - var hasProtobufUnittest_Extend_aB: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend_Extensions_a_b) + var hasSwiftProtoTesting_Extend_aB: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_a_b) } - /// Clears the value of extension `ProtobufUnittest_Extend_Extensions_a_b`. + /// Clears the value of extension `SwiftProtoTesting_Extend_Extensions_a_b`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend_aB() { - clearExtensionValue(ext: ProtobufUnittest_Extend_Extensions_a_b) + mutating func clearSwiftProtoTesting_Extend_aB() { + clearExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_a_b) } - var ProtobufUnittest_Extend_m2: ProtobufUnittest_Extend_Msg2 { - get {return getExtensionValue(ext: ProtobufUnittest_Extend_Extensions_m2) ?? ProtobufUnittest_Extend_Msg2()} - set {setExtensionValue(ext: ProtobufUnittest_Extend_Extensions_m2, value: newValue)} + var SwiftProtoTesting_Extend_m2: SwiftProtoTesting_Extend_Msg2 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_m2) ?? SwiftProtoTesting_Extend_Msg2()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_m2, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend_Extensions_m2` + /// Returns true if extension `SwiftProtoTesting_Extend_Extensions_m2` /// has been explicitly set. - var hasProtobufUnittest_Extend_m2: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend_Extensions_m2) + var hasSwiftProtoTesting_Extend_m2: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_m2) } - /// Clears the value of extension `ProtobufUnittest_Extend_Extensions_m2`. + /// Clears the value of extension `SwiftProtoTesting_Extend_Extensions_m2`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend_m2() { - clearExtensionValue(ext: ProtobufUnittest_Extend_Extensions_m2) + mutating func clearSwiftProtoTesting_Extend_m2() { + clearExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_m2) } } -extension ProtobufUnittest_Extend_Msg2 { +extension SwiftProtoTesting_Extend_Msg2 { - var ProtobufUnittest_Extend_aB: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extend_Extensions_aB) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extend_Extensions_aB, value: newValue)} + var SwiftProtoTesting_Extend_aB: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_aB) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_aB, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend_Extensions_aB` + /// Returns true if extension `SwiftProtoTesting_Extend_Extensions_aB` /// has been explicitly set. - var hasProtobufUnittest_Extend_aB: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend_Extensions_aB) + var hasSwiftProtoTesting_Extend_aB: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_aB) } - /// Clears the value of extension `ProtobufUnittest_Extend_Extensions_aB`. + /// Clears the value of extension `SwiftProtoTesting_Extend_Extensions_aB`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend_aB() { - clearExtensionValue(ext: ProtobufUnittest_Extend_Extensions_aB) + mutating func clearSwiftProtoTesting_Extend_aB() { + clearExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_aB) } } -extension ProtobufUnittest_Extend_MsgNoStorage { +extension SwiftProtoTesting_Extend_MsgNoStorage { - var ProtobufUnittest_Extend_extA: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_a) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_a, value: newValue)} + var SwiftProtoTesting_Extend_extA: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_a) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_a, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend_Extensions_ext_a` + /// Returns true if extension `SwiftProtoTesting_Extend_Extensions_ext_a` /// has been explicitly set. - var hasProtobufUnittest_Extend_extA: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_a) + var hasSwiftProtoTesting_Extend_extA: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_a) } - /// Clears the value of extension `ProtobufUnittest_Extend_Extensions_ext_a`. + /// Clears the value of extension `SwiftProtoTesting_Extend_Extensions_ext_a`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend_extA() { - clearExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_a) + mutating func clearSwiftProtoTesting_Extend_extA() { + clearExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_a) } - var ProtobufUnittest_Extend_extB: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_b) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_b, value: newValue)} + var SwiftProtoTesting_Extend_extB: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_b) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_b, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend_Extensions_ext_b` + /// Returns true if extension `SwiftProtoTesting_Extend_Extensions_ext_b` /// has been explicitly set. - var hasProtobufUnittest_Extend_extB: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_b) + var hasSwiftProtoTesting_Extend_extB: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_b) } - /// Clears the value of extension `ProtobufUnittest_Extend_Extensions_ext_b`. + /// Clears the value of extension `SwiftProtoTesting_Extend_Extensions_ext_b`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend_extB() { - clearExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_b) + mutating func clearSwiftProtoTesting_Extend_extB() { + clearExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_b) } } -extension ProtobufUnittest_Extend_MsgUsesStorage { +extension SwiftProtoTesting_Extend_MsgUsesStorage { - var ProtobufUnittest_Extend_extC: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_c) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_c, value: newValue)} + var SwiftProtoTesting_Extend_extC: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_c) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_c, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend_Extensions_ext_c` + /// Returns true if extension `SwiftProtoTesting_Extend_Extensions_ext_c` /// has been explicitly set. - var hasProtobufUnittest_Extend_extC: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_c) + var hasSwiftProtoTesting_Extend_extC: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_c) } - /// Clears the value of extension `ProtobufUnittest_Extend_Extensions_ext_c`. + /// Clears the value of extension `SwiftProtoTesting_Extend_Extensions_ext_c`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend_extC() { - clearExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_c) + mutating func clearSwiftProtoTesting_Extend_extC() { + clearExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_c) } - var ProtobufUnittest_Extend_extD: Int32 { - get {return getExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_d) ?? 0} - set {setExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_d, value: newValue)} + var SwiftProtoTesting_Extend_extD: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_d) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_d, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend_Extensions_ext_d` + /// Returns true if extension `SwiftProtoTesting_Extend_Extensions_ext_d` /// has been explicitly set. - var hasProtobufUnittest_Extend_extD: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_d) + var hasSwiftProtoTesting_Extend_extD: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_d) } - /// Clears the value of extension `ProtobufUnittest_Extend_Extensions_ext_d`. + /// Clears the value of extension `SwiftProtoTesting_Extend_Extensions_ext_d`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend_extD() { - clearExtensionValue(ext: ProtobufUnittest_Extend_Extensions_ext_d) + mutating func clearSwiftProtoTesting_Extend_extD() { + clearExtensionValue(ext: SwiftProtoTesting_Extend_Extensions_ext_d) } } -// MARK: - File's ExtensionMap: ProtobufUnittest_Extend_UnittestSwiftExtension_Extensions +// MARK: - File's ExtensionMap: SwiftProtoTesting_Extend_UnittestSwiftExtension_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 ProtobufUnittest_Extend_UnittestSwiftExtension_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_Extend_Extensions_b, - ProtobufUnittest_Extend_Extensions_C, - ProtobufUnittest_Extend_Extensions_a_b, - ProtobufUnittest_Extend_Extensions_m2, - ProtobufUnittest_Extend_Extensions_aB, - ProtobufUnittest_Extend_Extensions_ext_a, - ProtobufUnittest_Extend_Extensions_ext_b, - ProtobufUnittest_Extend_Extensions_ext_c, - ProtobufUnittest_Extend_Extensions_ext_d +let SwiftProtoTesting_Extend_UnittestSwiftExtension_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Extend_Extensions_b, + SwiftProtoTesting_Extend_Extensions_C, + SwiftProtoTesting_Extend_Extensions_a_b, + SwiftProtoTesting_Extend_Extensions_m2, + SwiftProtoTesting_Extend_Extensions_aB, + SwiftProtoTesting_Extend_Extensions_ext_a, + SwiftProtoTesting_Extend_Extensions_ext_b, + SwiftProtoTesting_Extend_Extensions_ext_c, + SwiftProtoTesting_Extend_Extensions_ext_d ] // 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 ProtobufUnittest_Extend_Extensions_b = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( +let SwiftProtoTesting_Extend_Extensions_b = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 100, - fieldName: "protobuf_unittest.extend.b" + fieldName: "swift_proto_testing.extend.b" ) -let ProtobufUnittest_Extend_Extensions_C = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( +let SwiftProtoTesting_Extend_Extensions_C = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 101, - fieldName: "protobuf_unittest.extend.c" + fieldName: "swift_proto_testing.extend.c" ) -let ProtobufUnittest_Extend_Extensions_a_b = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Msg1>( +let SwiftProtoTesting_Extend_Extensions_a_b = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Msg1>( _protobuf_fieldNumber: 1, - fieldName: "protobuf_unittest.extend.a_b" + fieldName: "swift_proto_testing.extend.a_b" ) -let ProtobufUnittest_Extend_Extensions_m2 = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Msg1>( +let SwiftProtoTesting_Extend_Extensions_m2 = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Msg1>( _protobuf_fieldNumber: 2, - fieldName: "protobuf_unittest.extend.m2" + fieldName: "swift_proto_testing.extend.m2" ) -let ProtobufUnittest_Extend_Extensions_aB = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Msg2>( +let SwiftProtoTesting_Extend_Extensions_aB = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Msg2>( _protobuf_fieldNumber: 1, - fieldName: "protobuf_unittest.extend.aB" + fieldName: "swift_proto_testing.extend.aB" ) -let ProtobufUnittest_Extend_Extensions_ext_a = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_MsgNoStorage>( +let SwiftProtoTesting_Extend_Extensions_ext_a = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_MsgNoStorage>( _protobuf_fieldNumber: 100, - fieldName: "protobuf_unittest.extend.ext_a" + fieldName: "swift_proto_testing.extend.ext_a" ) -let ProtobufUnittest_Extend_Extensions_ext_b = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_MsgNoStorage>( +let SwiftProtoTesting_Extend_Extensions_ext_b = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_MsgNoStorage>( _protobuf_fieldNumber: 101, - fieldName: "protobuf_unittest.extend.ext_b" + fieldName: "swift_proto_testing.extend.ext_b" ) -let ProtobufUnittest_Extend_Extensions_ext_c = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_MsgUsesStorage>( +let SwiftProtoTesting_Extend_Extensions_ext_c = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_MsgUsesStorage>( _protobuf_fieldNumber: 100, - fieldName: "protobuf_unittest.extend.ext_c" + fieldName: "swift_proto_testing.extend.ext_c" ) -let ProtobufUnittest_Extend_Extensions_ext_d = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_MsgUsesStorage>( +let SwiftProtoTesting_Extend_Extensions_ext_d = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_MsgUsesStorage>( _protobuf_fieldNumber: 101, - fieldName: "protobuf_unittest.extend.ext_d" + fieldName: "swift_proto_testing.extend.ext_d" ) // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest.extend" +fileprivate let _protobuf_package = "swift_proto_testing.extend" -extension ProtobufUnittest_Extend_Foo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend_Foo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Foo" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_Foo, rhs: ProtobufUnittest_Extend_Foo) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_Foo, rhs: SwiftProtoTesting_Extend_Foo) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Extend_Foo.Bar: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_Extend_Foo.protoMessageName + ".Bar" +extension SwiftProtoTesting_Extend_Foo.Bar: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Extend_Foo.protoMessageName + ".Bar" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_Foo.Bar, rhs: ProtobufUnittest_Extend_Foo.Bar) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_Foo.Bar, rhs: SwiftProtoTesting_Extend_Foo.Bar) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Extend_Foo.Bar.Baz: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_Extend_Foo.Bar.protoMessageName + ".Baz" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] +extension SwiftProtoTesting_Extend_Foo.Bar.Baz: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Extend_Foo.Bar.protoMessageName + ".Baz" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} @@ -477,7 +464,7 @@ extension ProtobufUnittest_Extend_Foo.Bar.Baz: SwiftProtobuf.Message, SwiftProto switch fieldNumber { case 1: try { try decoder.decodeSingularInt32Field(value: &self._a) }() case 100..<1001: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_Extend_Foo.Bar.Baz.self, fieldNumber: fieldNumber) }() + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Extend_Foo.Bar.Baz.self, fieldNumber: fieldNumber) }() default: break } } @@ -495,7 +482,7 @@ extension ProtobufUnittest_Extend_Foo.Bar.Baz: SwiftProtobuf.Message, SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_Foo.Bar.Baz, rhs: ProtobufUnittest_Extend_Foo.Bar.Baz) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_Foo.Bar.Baz, rhs: SwiftProtoTesting_Extend_Foo.Bar.Baz) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} @@ -503,11 +490,9 @@ extension ProtobufUnittest_Extend_Foo.Bar.Baz: SwiftProtobuf.Message, SwiftProto } } -extension ProtobufUnittest_Extend_C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend_C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".C" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 999: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}g\u{f}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -532,14 +517,14 @@ extension ProtobufUnittest_Extend_C: SwiftProtobuf.Message, SwiftProtobuf._Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_C, rhs: ProtobufUnittest_Extend_C) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_C, rhs: SwiftProtoTesting_Extend_C) -> Bool { if lhs._c != rhs._c {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Extend_Msg1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend_Msg1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg1" static let _protobuf_nameMap = SwiftProtobuf._NameMap() @@ -551,7 +536,7 @@ extension ProtobufUnittest_Extend_Msg1: SwiftProtobuf.Message, SwiftProtobuf._Me mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { if (1 <= fieldNumber && fieldNumber < 1001) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_Extend_Msg1.self, fieldNumber: fieldNumber) + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Extend_Msg1.self, fieldNumber: fieldNumber) } } } @@ -561,14 +546,14 @@ extension ProtobufUnittest_Extend_Msg1: SwiftProtobuf.Message, SwiftProtobuf._Me try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_Msg1, rhs: ProtobufUnittest_Extend_Msg1) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_Msg1, rhs: SwiftProtoTesting_Extend_Msg1) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension ProtobufUnittest_Extend_Msg2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend_Msg2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg2" static let _protobuf_nameMap = SwiftProtobuf._NameMap() @@ -580,7 +565,7 @@ extension ProtobufUnittest_Extend_Msg2: SwiftProtobuf.Message, SwiftProtobuf._Me mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { if (1 <= fieldNumber && fieldNumber < 1001) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_Extend_Msg2.self, fieldNumber: fieldNumber) + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Extend_Msg2.self, fieldNumber: fieldNumber) } } } @@ -590,18 +575,16 @@ extension ProtobufUnittest_Extend_Msg2: SwiftProtobuf.Message, SwiftProtobuf._Me try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_Msg2, rhs: ProtobufUnittest_Extend_Msg2) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_Msg2, rhs: SwiftProtoTesting_Extend_Msg2) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension ProtobufUnittest_Extend_MsgNoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend_MsgNoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MsgNoStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "x"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}x\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} @@ -616,7 +599,7 @@ extension ProtobufUnittest_Extend_MsgNoStorage: SwiftProtobuf.Message, SwiftProt switch fieldNumber { case 1: try { try decoder.decodeSingularInt32Field(value: &self._x) }() case 100..<201: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_Extend_MsgNoStorage.self, fieldNumber: fieldNumber) }() + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Extend_MsgNoStorage.self, fieldNumber: fieldNumber) }() default: break } } @@ -634,7 +617,7 @@ extension ProtobufUnittest_Extend_MsgNoStorage: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_MsgNoStorage, rhs: ProtobufUnittest_Extend_MsgNoStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_MsgNoStorage, rhs: SwiftProtoTesting_Extend_MsgNoStorage) -> Bool { if lhs._x != rhs._x {return false} if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} @@ -642,18 +625,19 @@ extension ProtobufUnittest_Extend_MsgNoStorage: SwiftProtobuf.Message, SwiftProt } } -extension ProtobufUnittest_Extend_MsgUsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend_MsgUsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MsgUsesStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "x"), - 2: .same(proto: "y"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}x\0\u{1}y\0") fileprivate class _StorageClass { var _x: Int32? = nil - var _y: ProtobufUnittest_Extend_MsgUsesStorage? = nil + var _y: SwiftProtoTesting_Extend_MsgUsesStorage? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -689,7 +673,7 @@ extension ProtobufUnittest_Extend_MsgUsesStorage: SwiftProtobuf.Message, SwiftPr case 1: try { try decoder.decodeSingularInt32Field(value: &_storage._x) }() case 2: try { try decoder.decodeSingularMessageField(value: &_storage._y) }() case 100..<201: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_Extend_MsgUsesStorage.self, fieldNumber: fieldNumber) }() + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Extend_MsgUsesStorage.self, fieldNumber: fieldNumber) }() default: break } } @@ -713,7 +697,7 @@ extension ProtobufUnittest_Extend_MsgUsesStorage: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend_MsgUsesStorage, rhs: ProtobufUnittest_Extend_MsgUsesStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend_MsgUsesStorage, rhs: SwiftProtoTesting_Extend_MsgUsesStorage) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 diff --git a/Tests/SwiftProtobufTests/unittest_swift_extension2.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_extension2.pb.swift index b7be0dc6a..ae118afb2 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_extension2.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_extension2.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_extension2.proto @@ -25,7 +26,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -38,24 +38,24 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_Extend2_MyMessage { +struct SwiftProtoTesting_Extend2_MyMessage: Sendable { // 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() - struct C { + struct C: Sendable { // 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 c: Int64 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -69,17 +69,17 @@ struct ProtobufUnittest_Extend2_MyMessage { init() {} } -struct ProtobufUnittest_Extend2_C { +struct SwiftProtoTesting_Extend2_C: Sendable { // 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 c: Int64 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -90,154 +90,146 @@ struct ProtobufUnittest_Extend2_C { fileprivate var _c: Int64? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_Extend2_MyMessage: @unchecked Sendable {} -extension ProtobufUnittest_Extend2_MyMessage.C: @unchecked Sendable {} -extension ProtobufUnittest_Extend2_C: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_extension2.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 ProtobufUnittest_Extend_Foo.Bar.Baz { +extension SwiftProtoTesting_Extend_Foo.Bar.Baz { - var ProtobufUnittest_Extend2_b: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extend2_Extensions_b) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extend2_Extensions_b, value: newValue)} + var SwiftProtoTesting_Extend2_b: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend2_Extensions_b) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend2_Extensions_b, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend2_Extensions_b` + /// Returns true if extension `SwiftProtoTesting_Extend2_Extensions_b` /// has been explicitly set. - var hasProtobufUnittest_Extend2_b: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend2_Extensions_b) + var hasSwiftProtoTesting_Extend2_b: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend2_Extensions_b) } - /// Clears the value of extension `ProtobufUnittest_Extend2_Extensions_b`. + /// Clears the value of extension `SwiftProtoTesting_Extend2_Extensions_b`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend2_b() { - clearExtensionValue(ext: ProtobufUnittest_Extend2_Extensions_b) + mutating func clearSwiftProtoTesting_Extend2_b() { + clearExtensionValue(ext: SwiftProtoTesting_Extend2_Extensions_b) } - var ProtobufUnittest_Extend2_c: ProtobufUnittest_Extend2_C { - get {return getExtensionValue(ext: ProtobufUnittest_Extend2_Extensions_C) ?? ProtobufUnittest_Extend2_C()} - set {setExtensionValue(ext: ProtobufUnittest_Extend2_Extensions_C, value: newValue)} + var SwiftProtoTesting_Extend2_c: SwiftProtoTesting_Extend2_C { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend2_Extensions_C) ?? SwiftProtoTesting_Extend2_C()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend2_Extensions_C, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend2_Extensions_C` + /// Returns true if extension `SwiftProtoTesting_Extend2_Extensions_C` /// has been explicitly set. - var hasProtobufUnittest_Extend2_c: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend2_Extensions_C) + var hasSwiftProtoTesting_Extend2_c: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend2_Extensions_C) } - /// Clears the value of extension `ProtobufUnittest_Extend2_Extensions_C`. + /// Clears the value of extension `SwiftProtoTesting_Extend2_Extensions_C`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend2_c() { - clearExtensionValue(ext: ProtobufUnittest_Extend2_Extensions_C) + mutating func clearSwiftProtoTesting_Extend2_c() { + clearExtensionValue(ext: SwiftProtoTesting_Extend2_Extensions_C) } - var ProtobufUnittest_Extend2_MyMessage_b: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extend2_MyMessage.Extensions.b) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extend2_MyMessage.Extensions.b, value: newValue)} + var SwiftProtoTesting_Extend2_MyMessage_b: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend2_MyMessage.Extensions.b) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend2_MyMessage.Extensions.b, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend2_MyMessage.Extensions.b` + /// Returns true if extension `SwiftProtoTesting_Extend2_MyMessage.Extensions.b` /// has been explicitly set. - var hasProtobufUnittest_Extend2_MyMessage_b: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend2_MyMessage.Extensions.b) + var hasSwiftProtoTesting_Extend2_MyMessage_b: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend2_MyMessage.Extensions.b) } - /// Clears the value of extension `ProtobufUnittest_Extend2_MyMessage.Extensions.b`. + /// Clears the value of extension `SwiftProtoTesting_Extend2_MyMessage.Extensions.b`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend2_MyMessage_b() { - clearExtensionValue(ext: ProtobufUnittest_Extend2_MyMessage.Extensions.b) + mutating func clearSwiftProtoTesting_Extend2_MyMessage_b() { + clearExtensionValue(ext: SwiftProtoTesting_Extend2_MyMessage.Extensions.b) } - var ProtobufUnittest_Extend2_MyMessage_c: ProtobufUnittest_Extend2_MyMessage.C { - get {return getExtensionValue(ext: ProtobufUnittest_Extend2_MyMessage.Extensions.C) ?? ProtobufUnittest_Extend2_MyMessage.C()} - set {setExtensionValue(ext: ProtobufUnittest_Extend2_MyMessage.Extensions.C, value: newValue)} + var SwiftProtoTesting_Extend2_MyMessage_c: SwiftProtoTesting_Extend2_MyMessage.C { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend2_MyMessage.Extensions.C) ?? SwiftProtoTesting_Extend2_MyMessage.C()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend2_MyMessage.Extensions.C, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend2_MyMessage.Extensions.C` + /// Returns true if extension `SwiftProtoTesting_Extend2_MyMessage.Extensions.C` /// has been explicitly set. - var hasProtobufUnittest_Extend2_MyMessage_c: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend2_MyMessage.Extensions.C) + var hasSwiftProtoTesting_Extend2_MyMessage_c: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend2_MyMessage.Extensions.C) } - /// Clears the value of extension `ProtobufUnittest_Extend2_MyMessage.Extensions.C`. + /// Clears the value of extension `SwiftProtoTesting_Extend2_MyMessage.Extensions.C`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend2_MyMessage_c() { - clearExtensionValue(ext: ProtobufUnittest_Extend2_MyMessage.Extensions.C) + mutating func clearSwiftProtoTesting_Extend2_MyMessage_c() { + clearExtensionValue(ext: SwiftProtoTesting_Extend2_MyMessage.Extensions.C) } } -// MARK: - File's ExtensionMap: ProtobufUnittest_Extend2_UnittestSwiftExtension2_Extensions +// MARK: - File's ExtensionMap: SwiftProtoTesting_Extend2_UnittestSwiftExtension2_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 ProtobufUnittest_Extend2_UnittestSwiftExtension2_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_Extend2_Extensions_b, - ProtobufUnittest_Extend2_Extensions_C, - ProtobufUnittest_Extend2_MyMessage.Extensions.b, - ProtobufUnittest_Extend2_MyMessage.Extensions.C +let SwiftProtoTesting_Extend2_UnittestSwiftExtension2_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Extend2_Extensions_b, + SwiftProtoTesting_Extend2_Extensions_C, + SwiftProtoTesting_Extend2_MyMessage.Extensions.b, + SwiftProtoTesting_Extend2_MyMessage.Extensions.C ] // 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 ProtobufUnittest_Extend2_Extensions_b = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( +let SwiftProtoTesting_Extend2_Extensions_b = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 220, - fieldName: "protobuf_unittest.extend2.b" + fieldName: "swift_proto_testing.extend2.b" ) -let ProtobufUnittest_Extend2_Extensions_C = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( +let SwiftProtoTesting_Extend2_Extensions_C = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 221, - fieldName: "protobuf_unittest.extend2.c" + fieldName: "swift_proto_testing.extend2.c" ) -extension ProtobufUnittest_Extend2_MyMessage { +extension SwiftProtoTesting_Extend2_MyMessage { enum Extensions { - static let b = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( + static let b = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 210, - fieldName: "protobuf_unittest.extend2.MyMessage.b" + fieldName: "swift_proto_testing.extend2.MyMessage.b" ) - static let C = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( + static let C = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 211, - fieldName: "protobuf_unittest.extend2.MyMessage.c" + fieldName: "swift_proto_testing.extend2.MyMessage.c" ) } } // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest.extend2" +fileprivate let _protobuf_package = "swift_proto_testing.extend2" -extension ProtobufUnittest_Extend2_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend2_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MyMessage" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend2_MyMessage, rhs: ProtobufUnittest_Extend2_MyMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend2_MyMessage, rhs: SwiftProtoTesting_Extend2_MyMessage) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Extend2_MyMessage.C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_Extend2_MyMessage.protoMessageName + ".C" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1210: .same(proto: "c"), - ] +extension SwiftProtoTesting_Extend2_MyMessage.C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Extend2_MyMessage.protoMessageName + ".C" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}z\u{12}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -262,18 +254,16 @@ extension ProtobufUnittest_Extend2_MyMessage.C: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend2_MyMessage.C, rhs: ProtobufUnittest_Extend2_MyMessage.C) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend2_MyMessage.C, rhs: SwiftProtoTesting_Extend2_MyMessage.C) -> Bool { if lhs._c != rhs._c {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Extend2_C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend2_C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".C" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1220: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}D\u{13}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -298,7 +288,7 @@ extension ProtobufUnittest_Extend2_C: SwiftProtobuf.Message, SwiftProtobuf._Mess try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend2_C, rhs: ProtobufUnittest_Extend2_C) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend2_C, rhs: SwiftProtoTesting_Extend2_C) -> Bool { if lhs._c != rhs._c {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Tests/SwiftProtobufTests/unittest_swift_extension3.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_extension3.pb.swift index 565d776f3..9d784d6cc 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_extension3.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_extension3.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_extension3.proto @@ -25,7 +26,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -38,24 +38,24 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_Extend3_MyMessage { +struct SwiftProtoTesting_Extend3_MyMessage: Sendable { // 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() - struct C { + struct C: Sendable { // 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 c: Int64 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -69,17 +69,17 @@ struct ProtobufUnittest_Extend3_MyMessage { init() {} } -struct ProtobufUnittest_Extend3_C { +struct SwiftProtoTesting_Extend3_C: Sendable { // 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 c: Int64 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -90,154 +90,146 @@ struct ProtobufUnittest_Extend3_C { fileprivate var _c: Int64? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_Extend3_MyMessage: @unchecked Sendable {} -extension ProtobufUnittest_Extend3_MyMessage.C: @unchecked Sendable {} -extension ProtobufUnittest_Extend3_C: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_extension3.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 ProtobufUnittest_Extend_Foo.Bar.Baz { +extension SwiftProtoTesting_Extend_Foo.Bar.Baz { - var ProtobufUnittest_Extend3_b: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extend3_Extensions_b) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extend3_Extensions_b, value: newValue)} + var SwiftProtoTesting_Extend3_b: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend3_Extensions_b) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend3_Extensions_b, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend3_Extensions_b` + /// Returns true if extension `SwiftProtoTesting_Extend3_Extensions_b` /// has been explicitly set. - var hasProtobufUnittest_Extend3_b: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend3_Extensions_b) + var hasSwiftProtoTesting_Extend3_b: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend3_Extensions_b) } - /// Clears the value of extension `ProtobufUnittest_Extend3_Extensions_b`. + /// Clears the value of extension `SwiftProtoTesting_Extend3_Extensions_b`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend3_b() { - clearExtensionValue(ext: ProtobufUnittest_Extend3_Extensions_b) + mutating func clearSwiftProtoTesting_Extend3_b() { + clearExtensionValue(ext: SwiftProtoTesting_Extend3_Extensions_b) } - var ProtobufUnittest_Extend3_c: ProtobufUnittest_Extend3_C { - get {return getExtensionValue(ext: ProtobufUnittest_Extend3_Extensions_C) ?? ProtobufUnittest_Extend3_C()} - set {setExtensionValue(ext: ProtobufUnittest_Extend3_Extensions_C, value: newValue)} + var SwiftProtoTesting_Extend3_c: SwiftProtoTesting_Extend3_C { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend3_Extensions_C) ?? SwiftProtoTesting_Extend3_C()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend3_Extensions_C, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend3_Extensions_C` + /// Returns true if extension `SwiftProtoTesting_Extend3_Extensions_C` /// has been explicitly set. - var hasProtobufUnittest_Extend3_c: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend3_Extensions_C) + var hasSwiftProtoTesting_Extend3_c: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend3_Extensions_C) } - /// Clears the value of extension `ProtobufUnittest_Extend3_Extensions_C`. + /// Clears the value of extension `SwiftProtoTesting_Extend3_Extensions_C`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend3_c() { - clearExtensionValue(ext: ProtobufUnittest_Extend3_Extensions_C) + mutating func clearSwiftProtoTesting_Extend3_c() { + clearExtensionValue(ext: SwiftProtoTesting_Extend3_Extensions_C) } - var ProtobufUnittest_Extend3_MyMessage_b: String { - get {return getExtensionValue(ext: ProtobufUnittest_Extend3_MyMessage.Extensions.b) ?? String()} - set {setExtensionValue(ext: ProtobufUnittest_Extend3_MyMessage.Extensions.b, value: newValue)} + var SwiftProtoTesting_Extend3_MyMessage_b: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend3_MyMessage.Extensions.b) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend3_MyMessage.Extensions.b, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend3_MyMessage.Extensions.b` + /// Returns true if extension `SwiftProtoTesting_Extend3_MyMessage.Extensions.b` /// has been explicitly set. - var hasProtobufUnittest_Extend3_MyMessage_b: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend3_MyMessage.Extensions.b) + var hasSwiftProtoTesting_Extend3_MyMessage_b: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend3_MyMessage.Extensions.b) } - /// Clears the value of extension `ProtobufUnittest_Extend3_MyMessage.Extensions.b`. + /// Clears the value of extension `SwiftProtoTesting_Extend3_MyMessage.Extensions.b`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend3_MyMessage_b() { - clearExtensionValue(ext: ProtobufUnittest_Extend3_MyMessage.Extensions.b) + mutating func clearSwiftProtoTesting_Extend3_MyMessage_b() { + clearExtensionValue(ext: SwiftProtoTesting_Extend3_MyMessage.Extensions.b) } - var ProtobufUnittest_Extend3_MyMessage_c: ProtobufUnittest_Extend3_MyMessage.C { - get {return getExtensionValue(ext: ProtobufUnittest_Extend3_MyMessage.Extensions.C) ?? ProtobufUnittest_Extend3_MyMessage.C()} - set {setExtensionValue(ext: ProtobufUnittest_Extend3_MyMessage.Extensions.C, value: newValue)} + var SwiftProtoTesting_Extend3_MyMessage_c: SwiftProtoTesting_Extend3_MyMessage.C { + get {return getExtensionValue(ext: SwiftProtoTesting_Extend3_MyMessage.Extensions.C) ?? SwiftProtoTesting_Extend3_MyMessage.C()} + set {setExtensionValue(ext: SwiftProtoTesting_Extend3_MyMessage.Extensions.C, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extend3_MyMessage.Extensions.C` + /// Returns true if extension `SwiftProtoTesting_Extend3_MyMessage.Extensions.C` /// has been explicitly set. - var hasProtobufUnittest_Extend3_MyMessage_c: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extend3_MyMessage.Extensions.C) + var hasSwiftProtoTesting_Extend3_MyMessage_c: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extend3_MyMessage.Extensions.C) } - /// Clears the value of extension `ProtobufUnittest_Extend3_MyMessage.Extensions.C`. + /// Clears the value of extension `SwiftProtoTesting_Extend3_MyMessage.Extensions.C`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_Extend3_MyMessage_c() { - clearExtensionValue(ext: ProtobufUnittest_Extend3_MyMessage.Extensions.C) + mutating func clearSwiftProtoTesting_Extend3_MyMessage_c() { + clearExtensionValue(ext: SwiftProtoTesting_Extend3_MyMessage.Extensions.C) } } -// MARK: - File's ExtensionMap: ProtobufUnittest_Extend3_UnittestSwiftExtension3_Extensions +// MARK: - File's ExtensionMap: SwiftProtoTesting_Extend3_UnittestSwiftExtension3_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 ProtobufUnittest_Extend3_UnittestSwiftExtension3_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_Extend3_Extensions_b, - ProtobufUnittest_Extend3_Extensions_C, - ProtobufUnittest_Extend3_MyMessage.Extensions.b, - ProtobufUnittest_Extend3_MyMessage.Extensions.C +let SwiftProtoTesting_Extend3_UnittestSwiftExtension3_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Extend3_Extensions_b, + SwiftProtoTesting_Extend3_Extensions_C, + SwiftProtoTesting_Extend3_MyMessage.Extensions.b, + SwiftProtoTesting_Extend3_MyMessage.Extensions.C ] // 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 ProtobufUnittest_Extend3_Extensions_b = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( +let SwiftProtoTesting_Extend3_Extensions_b = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 320, - fieldName: "protobuf_unittest.extend3.b" + fieldName: "swift_proto_testing.extend3.b" ) -let ProtobufUnittest_Extend3_Extensions_C = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( +let SwiftProtoTesting_Extend3_Extensions_C = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 321, - fieldName: "protobuf_unittest.extend3.c" + fieldName: "swift_proto_testing.extend3.c" ) -extension ProtobufUnittest_Extend3_MyMessage { +extension SwiftProtoTesting_Extend3_MyMessage { enum Extensions { - static let b = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( + static let b = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 310, - fieldName: "protobuf_unittest.extend3.MyMessage.b" + fieldName: "swift_proto_testing.extend3.MyMessage.b" ) - static let C = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( + static let C = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 311, - fieldName: "protobuf_unittest.extend3.MyMessage.c" + fieldName: "swift_proto_testing.extend3.MyMessage.c" ) } } // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest.extend3" +fileprivate let _protobuf_package = "swift_proto_testing.extend3" -extension ProtobufUnittest_Extend3_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend3_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MyMessage" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend3_MyMessage, rhs: ProtobufUnittest_Extend3_MyMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend3_MyMessage, rhs: SwiftProtoTesting_Extend3_MyMessage) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Extend3_MyMessage.C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_Extend3_MyMessage.protoMessageName + ".C" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1310: .same(proto: "c"), - ] +extension SwiftProtoTesting_Extend3_MyMessage.C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Extend3_MyMessage.protoMessageName + ".C" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}^\u{14}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -262,18 +254,16 @@ extension ProtobufUnittest_Extend3_MyMessage.C: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend3_MyMessage.C, rhs: ProtobufUnittest_Extend3_MyMessage.C) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend3_MyMessage.C, rhs: SwiftProtoTesting_Extend3_MyMessage.C) -> Bool { if lhs._c != rhs._c {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Extend3_C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Extend3_C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".C" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1320: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}h\u{14}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -298,7 +288,7 @@ extension ProtobufUnittest_Extend3_C: SwiftProtobuf.Message, SwiftProtobuf._Mess try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Extend3_C, rhs: ProtobufUnittest_Extend3_C) -> Bool { + static func ==(lhs: SwiftProtoTesting_Extend3_C, rhs: SwiftProtoTesting_Extend3_C) -> Bool { if lhs._c != rhs._c {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Tests/SwiftProtobufTests/unittest_swift_extension4.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_extension4.pb.swift index 99074cc4e..221d20ff8 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_extension4.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_extension4.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_extension4.proto @@ -25,7 +26,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -38,24 +38,24 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct Ext4MyMessage { +struct Ext4MyMessage: Sendable { // 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() - struct C { + struct C: Sendable { // 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 c: Int64 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -69,17 +69,17 @@ struct Ext4MyMessage { init() {} } -struct Ext4C { +struct Ext4C: Sendable { // 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 c: Int64 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -90,22 +90,16 @@ struct Ext4C { fileprivate var _c: Int64? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension Ext4MyMessage: @unchecked Sendable {} -extension Ext4MyMessage.C: @unchecked Sendable {} -extension Ext4C: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_extension4.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 ProtobufUnittest_Extend_Foo.Bar.Baz { +extension SwiftProtoTesting_Extend_Foo.Bar.Baz { var Ext4b: String { get {return getExtensionValue(ext: Ext4Extensions_b) ?? String()} @@ -186,41 +180,41 @@ let Ext4UnittestSwiftExtension4_Extensions: SwiftProtobuf.SimpleExtensionMap = [ // constructing a `SimpleExtensionMap`, otherwise, use the above _Extension Properties_ // accessors for the extension fields on the messages directly. -let Ext4Extensions_b = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( +let Ext4Extensions_b = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 420, - fieldName: "protobuf_unittest.extend4.b" + fieldName: "swift_proto_testing.extend4.b" ) -let Ext4Extensions_C = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( +let Ext4Extensions_C = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 421, - fieldName: "protobuf_unittest.extend4.c" + fieldName: "swift_proto_testing.extend4.c" ) extension Ext4MyMessage { enum Extensions { - static let b = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( + static let b = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 410, - fieldName: "protobuf_unittest.extend4.MyMessage.b" + fieldName: "swift_proto_testing.extend4.MyMessage.b" ) - static let C = SwiftProtobuf.MessageExtension, ProtobufUnittest_Extend_Foo.Bar.Baz>( + static let C = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Extend_Foo.Bar.Baz>( _protobuf_fieldNumber: 411, - fieldName: "protobuf_unittest.extend4.MyMessage.c" + fieldName: "swift_proto_testing.extend4.MyMessage.c" ) } } // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest.extend4" +fileprivate let _protobuf_package = "swift_proto_testing.extend4" extension Ext4MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MyMessage" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { @@ -235,9 +229,7 @@ extension Ext4MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementa extension Ext4MyMessage.C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = Ext4MyMessage.protoMessageName + ".C" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1410: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}B\u{16}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -271,9 +263,7 @@ extension Ext4MyMessage.C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplemen extension Ext4C: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".C" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1420: .same(proto: "c"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}L\u{16}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { diff --git a/Tests/SwiftProtobufTests/unittest_swift_fieldorder.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_fieldorder.pb.swift index a32539341..491060e03 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_fieldorder.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_fieldorder.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_fieldorder.proto @@ -23,7 +24,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -36,39 +36,39 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct Swift_Protobuf_TestFieldOrderings: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Order_TestFieldOrderings: SwiftProtobuf.ExtensibleMessage, Sendable { // 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 myString: String { - get {return _myString ?? String()} + get {_myString ?? String()} set {_myString = newValue} } /// Returns true if `myString` has been explicitly set. - var hasMyString: Bool {return self._myString != nil} + var hasMyString: Bool {self._myString != nil} /// Clears the value of `myString`. Subsequent reads from it will return its default value. mutating func clearMyString() {self._myString = nil} var myInt: Int64 { - get {return _myInt ?? 0} + get {_myInt ?? 0} set {_myInt = newValue} } /// Returns true if `myInt` has been explicitly set. - var hasMyInt: Bool {return self._myInt != nil} + var hasMyInt: Bool {self._myInt != nil} /// Clears the value of `myInt`. Subsequent reads from it will return its default value. mutating func clearMyInt() {self._myInt = nil} var myFloat: Float { - get {return _myFloat ?? 0} + get {_myFloat ?? 0} set {_myFloat = newValue} } /// Returns true if `myFloat` has been explicitly set. - var hasMyFloat: Bool {return self._myFloat != nil} + var hasMyFloat: Bool {self._myFloat != nil} /// Clears the value of `myFloat`. Subsequent reads from it will return its default value. mutating func clearMyFloat() {self._myFloat = nil} - var options: Swift_Protobuf_TestFieldOrderings.OneOf_Options? = nil + var options: SwiftProtoTesting_Order_TestFieldOrderings.OneOf_Options? = nil var oneofInt64: Int64 { get { @@ -102,71 +102,45 @@ struct Swift_Protobuf_TestFieldOrderings: SwiftProtobuf.ExtensibleMessage { set {options = .oneofInt32(newValue)} } - var optionalNestedMessage: Swift_Protobuf_TestFieldOrderings.NestedMessage { - get {return _optionalNestedMessage ?? Swift_Protobuf_TestFieldOrderings.NestedMessage()} + var optionalNestedMessage: SwiftProtoTesting_Order_TestFieldOrderings.NestedMessage { + get {_optionalNestedMessage ?? SwiftProtoTesting_Order_TestFieldOrderings.NestedMessage()} set {_optionalNestedMessage = newValue} } /// Returns true if `optionalNestedMessage` has been explicitly set. - var hasOptionalNestedMessage: Bool {return self._optionalNestedMessage != nil} + var hasOptionalNestedMessage: Bool {self._optionalNestedMessage != nil} /// Clears the value of `optionalNestedMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalNestedMessage() {self._optionalNestedMessage = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_Options: Equatable { + enum OneOf_Options: Equatable, Sendable { case oneofInt64(Int64) case oneofBool(Bool) case oneofString(String) case oneofInt32(Int32) - #if !swift(>=4.1) - static func ==(lhs: Swift_Protobuf_TestFieldOrderings.OneOf_Options, rhs: Swift_Protobuf_TestFieldOrderings.OneOf_Options) -> 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 (.oneofInt64, .oneofInt64): return { - guard case .oneofInt64(let l) = lhs, case .oneofInt64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBool, .oneofBool): return { - guard case .oneofBool(let l) = lhs, case .oneofBool(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofInt32, .oneofInt32): return { - guard case .oneofInt32(let l) = lhs, case .oneofInt32(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - struct NestedMessage { + struct NestedMessage: Sendable { // 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 oo: Int64 { - get {return _oo ?? 0} + get {_oo ?? 0} set {_oo = newValue} } /// Returns true if `oo` has been explicitly set. - var hasOo: Bool {return self._oo != nil} + var hasOo: Bool {self._oo != nil} /// Clears the value of `oo`. Subsequent reads from it will return its default value. mutating func clearOo() {self._oo = nil} var bb: Int32 { - get {return _bb ?? 0} + get {_bb ?? 0} set {_bb = newValue} } /// Returns true if `bb` has been explicitly set. - var hasBb: Bool {return self._bb != nil} + var hasBb: Bool {self._bb != nil} /// Clears the value of `bb`. Subsequent reads from it will return its default value. mutating func clearBb() {self._bb = nil} @@ -184,18 +158,18 @@ struct Swift_Protobuf_TestFieldOrderings: SwiftProtobuf.ExtensibleMessage { fileprivate var _myString: String? = nil fileprivate var _myInt: Int64? = nil fileprivate var _myFloat: Float? = nil - fileprivate var _optionalNestedMessage: Swift_Protobuf_TestFieldOrderings.NestedMessage? = nil + fileprivate var _optionalNestedMessage: SwiftProtoTesting_Order_TestFieldOrderings.NestedMessage? = nil } /// These checks how the traverse() generated for a oneof /// deals with field orders. Currently requires inspecting the code. -struct Swift_Protobuf_OneofTraversalGeneration: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Order_OneofTraversalGeneration: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. /// Gaps, not no issues, no start:end: on traverse(). - var oGood: Swift_Protobuf_OneofTraversalGeneration.OneOf_OGood? = nil + var oGood: SwiftProtoTesting_Order_OneofTraversalGeneration.OneOf_OGood? = nil var a: Int32 { get { @@ -214,7 +188,7 @@ struct Swift_Protobuf_OneofTraversalGeneration: SwiftProtobuf.ExtensibleMessage } /// Gaps with a field in the middle of the range. - var oConflictField: Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictField? = nil + var oConflictField: SwiftProtoTesting_Order_OneofTraversalGeneration.OneOf_OConflictField? = nil var a2: Int32 { get { @@ -234,16 +208,16 @@ struct Swift_Protobuf_OneofTraversalGeneration: SwiftProtobuf.ExtensibleMessage /// In the middle of previous oneof field ranges. var m: Int32 { - get {return _m ?? 0} + get {_m ?? 0} set {_m = newValue} } /// Returns true if `m` has been explicitly set. - var hasM: Bool {return self._m != nil} + var hasM: Bool {self._m != nil} /// Clears the value of `m`. Subsequent reads from it will return its default value. mutating func clearM() {self._m = nil} /// Gaps with an extension range in the middle of the range. - var oConflictExtensionsStart: Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictExtensionsStart? = nil + var oConflictExtensionsStart: SwiftProtoTesting_Order_OneofTraversalGeneration.OneOf_OConflictExtensionsStart? = nil var a3: Int32 { get { @@ -262,7 +236,7 @@ struct Swift_Protobuf_OneofTraversalGeneration: SwiftProtobuf.ExtensibleMessage } /// Gaps with an extension range in the middle of the range. - var oConflictExtensionsEnd: Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictExtensionsEnd? = nil + var oConflictExtensionsEnd: SwiftProtoTesting_Order_OneofTraversalGeneration.OneOf_OConflictExtensionsEnd? = nil var a4: Int32 { get { @@ -283,103 +257,31 @@ struct Swift_Protobuf_OneofTraversalGeneration: SwiftProtobuf.ExtensibleMessage var unknownFields = SwiftProtobuf.UnknownStorage() /// Gaps, not no issues, no start:end: on traverse(). - enum OneOf_OGood: Equatable { + enum OneOf_OGood: Equatable, Sendable { case a(Int32) case b(Int32) - #if !swift(>=4.1) - static func ==(lhs: Swift_Protobuf_OneofTraversalGeneration.OneOf_OGood, rhs: Swift_Protobuf_OneofTraversalGeneration.OneOf_OGood) -> 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 (.a, .a): return { - guard case .a(let l) = lhs, case .a(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.b, .b): return { - guard case .b(let l) = lhs, case .b(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } /// Gaps with a field in the middle of the range. - enum OneOf_OConflictField: Equatable { + enum OneOf_OConflictField: Equatable, Sendable { case a2(Int32) case b2(Int32) - #if !swift(>=4.1) - static func ==(lhs: Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictField, rhs: Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictField) -> 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 (.a2, .a2): return { - guard case .a2(let l) = lhs, case .a2(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.b2, .b2): return { - guard case .b2(let l) = lhs, case .b2(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } /// Gaps with an extension range in the middle of the range. - enum OneOf_OConflictExtensionsStart: Equatable { + enum OneOf_OConflictExtensionsStart: Equatable, Sendable { case a3(Int32) case b3(Int32) - #if !swift(>=4.1) - static func ==(lhs: Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictExtensionsStart, rhs: Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictExtensionsStart) -> 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 (.a3, .a3): return { - guard case .a3(let l) = lhs, case .a3(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.b3, .b3): return { - guard case .b3(let l) = lhs, case .b3(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } /// Gaps with an extension range in the middle of the range. - enum OneOf_OConflictExtensionsEnd: Equatable { + enum OneOf_OConflictExtensionsEnd: Equatable, Sendable { case a4(Int32) case b4(Int32) - #if !swift(>=4.1) - static func ==(lhs: Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictExtensionsEnd, rhs: Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictExtensionsEnd) -> 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 (.a4, .a4): return { - guard case .a4(let l) = lhs, case .a4(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.b4, .b4): return { - guard case .b4(let l) = lhs, case .b4(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } init() {} @@ -388,101 +290,81 @@ struct Swift_Protobuf_OneofTraversalGeneration: SwiftProtobuf.ExtensibleMessage fileprivate var _m: Int32? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension Swift_Protobuf_TestFieldOrderings: @unchecked Sendable {} -extension Swift_Protobuf_TestFieldOrderings.OneOf_Options: @unchecked Sendable {} -extension Swift_Protobuf_TestFieldOrderings.NestedMessage: @unchecked Sendable {} -extension Swift_Protobuf_OneofTraversalGeneration: @unchecked Sendable {} -extension Swift_Protobuf_OneofTraversalGeneration.OneOf_OGood: @unchecked Sendable {} -extension Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictField: @unchecked Sendable {} -extension Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictExtensionsStart: @unchecked Sendable {} -extension Swift_Protobuf_OneofTraversalGeneration.OneOf_OConflictExtensionsEnd: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_fieldorder.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 Swift_Protobuf_TestFieldOrderings { +extension SwiftProtoTesting_Order_TestFieldOrderings { - var Swift_Protobuf_myExtensionString: String { - get {return getExtensionValue(ext: Swift_Protobuf_Extensions_my_extension_string) ?? String()} - set {setExtensionValue(ext: Swift_Protobuf_Extensions_my_extension_string, value: newValue)} + var SwiftProtoTesting_Order_myExtensionString: String { + get {return getExtensionValue(ext: SwiftProtoTesting_Order_Extensions_my_extension_string) ?? String()} + set {setExtensionValue(ext: SwiftProtoTesting_Order_Extensions_my_extension_string, value: newValue)} } - /// Returns true if extension `Swift_Protobuf_Extensions_my_extension_string` + /// Returns true if extension `SwiftProtoTesting_Order_Extensions_my_extension_string` /// has been explicitly set. - var hasSwift_Protobuf_myExtensionString: Bool { - return hasExtensionValue(ext: Swift_Protobuf_Extensions_my_extension_string) + var hasSwiftProtoTesting_Order_myExtensionString: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Order_Extensions_my_extension_string) } - /// Clears the value of extension `Swift_Protobuf_Extensions_my_extension_string`. + /// Clears the value of extension `SwiftProtoTesting_Order_Extensions_my_extension_string`. /// Subsequent reads from it will return its default value. - mutating func clearSwift_Protobuf_myExtensionString() { - clearExtensionValue(ext: Swift_Protobuf_Extensions_my_extension_string) + mutating func clearSwiftProtoTesting_Order_myExtensionString() { + clearExtensionValue(ext: SwiftProtoTesting_Order_Extensions_my_extension_string) } - var Swift_Protobuf_myExtensionInt: Int32 { - get {return getExtensionValue(ext: Swift_Protobuf_Extensions_my_extension_int) ?? 0} - set {setExtensionValue(ext: Swift_Protobuf_Extensions_my_extension_int, value: newValue)} + var SwiftProtoTesting_Order_myExtensionInt: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Order_Extensions_my_extension_int) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Order_Extensions_my_extension_int, value: newValue)} } - /// Returns true if extension `Swift_Protobuf_Extensions_my_extension_int` + /// Returns true if extension `SwiftProtoTesting_Order_Extensions_my_extension_int` /// has been explicitly set. - var hasSwift_Protobuf_myExtensionInt: Bool { - return hasExtensionValue(ext: Swift_Protobuf_Extensions_my_extension_int) + var hasSwiftProtoTesting_Order_myExtensionInt: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Order_Extensions_my_extension_int) } - /// Clears the value of extension `Swift_Protobuf_Extensions_my_extension_int`. + /// Clears the value of extension `SwiftProtoTesting_Order_Extensions_my_extension_int`. /// Subsequent reads from it will return its default value. - mutating func clearSwift_Protobuf_myExtensionInt() { - clearExtensionValue(ext: Swift_Protobuf_Extensions_my_extension_int) + mutating func clearSwiftProtoTesting_Order_myExtensionInt() { + clearExtensionValue(ext: SwiftProtoTesting_Order_Extensions_my_extension_int) } } -// MARK: - File's ExtensionMap: Swift_Protobuf_UnittestSwiftFieldorder_Extensions +// MARK: - File's ExtensionMap: SwiftProtoTesting_Order_UnittestSwiftFieldorder_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 Swift_Protobuf_UnittestSwiftFieldorder_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - Swift_Protobuf_Extensions_my_extension_string, - Swift_Protobuf_Extensions_my_extension_int +let SwiftProtoTesting_Order_UnittestSwiftFieldorder_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Order_Extensions_my_extension_string, + SwiftProtoTesting_Order_Extensions_my_extension_int ] // 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 Swift_Protobuf_Extensions_my_extension_string = SwiftProtobuf.MessageExtension, Swift_Protobuf_TestFieldOrderings>( +let SwiftProtoTesting_Order_Extensions_my_extension_string = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Order_TestFieldOrderings>( _protobuf_fieldNumber: 50, - fieldName: "swift.protobuf.my_extension_string" + fieldName: "swift_proto_testing.order.my_extension_string" ) -let Swift_Protobuf_Extensions_my_extension_int = SwiftProtobuf.MessageExtension, Swift_Protobuf_TestFieldOrderings>( +let SwiftProtoTesting_Order_Extensions_my_extension_int = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Order_TestFieldOrderings>( _protobuf_fieldNumber: 5, - fieldName: "swift.protobuf.my_extension_int" + fieldName: "swift_proto_testing.order.my_extension_int" ) // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "swift.protobuf" +fileprivate let _protobuf_package = "swift_proto_testing.order" -extension Swift_Protobuf_TestFieldOrderings: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Order_TestFieldOrderings: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestFieldOrderings" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 11: .standard(proto: "my_string"), - 1: .standard(proto: "my_int"), - 101: .standard(proto: "my_float"), - 60: .standard(proto: "oneof_int64"), - 9: .standard(proto: "oneof_bool"), - 150: .standard(proto: "oneof_string"), - 10: .standard(proto: "oneof_int32"), - 200: .standard(proto: "optional_nested_message"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}my_int\0\u{4}\u{8}oneof_bool\0\u{3}oneof_int32\0\u{3}my_string\0\u{4}1oneof_int64\0\u{4})my_float\0\u{4}1oneof_string\0\u{4}2optional_nested_message\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} @@ -532,7 +414,7 @@ extension Swift_Protobuf_TestFieldOrderings: SwiftProtobuf.Message, SwiftProtobu }() case 200: try { try decoder.decodeSingularMessageField(value: &self._optionalNestedMessage) }() case 2..<9, 12..<56: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Swift_Protobuf_TestFieldOrderings.self, fieldNumber: fieldNumber) }() + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Order_TestFieldOrderings.self, fieldNumber: fieldNumber) }() default: break } } @@ -577,7 +459,7 @@ extension Swift_Protobuf_TestFieldOrderings: SwiftProtobuf.Message, SwiftProtobu try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Swift_Protobuf_TestFieldOrderings, rhs: Swift_Protobuf_TestFieldOrderings) -> Bool { + static func ==(lhs: SwiftProtoTesting_Order_TestFieldOrderings, rhs: SwiftProtoTesting_Order_TestFieldOrderings) -> Bool { if lhs._myString != rhs._myString {return false} if lhs._myInt != rhs._myInt {return false} if lhs._myFloat != rhs._myFloat {return false} @@ -589,12 +471,9 @@ extension Swift_Protobuf_TestFieldOrderings: SwiftProtobuf.Message, SwiftProtobu } } -extension Swift_Protobuf_TestFieldOrderings.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = Swift_Protobuf_TestFieldOrderings.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 2: .same(proto: "oo"), - 1: .same(proto: "bb"), - ] +extension SwiftProtoTesting_Order_TestFieldOrderings.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Order_TestFieldOrderings.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bb\0\u{1}oo\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -623,7 +502,7 @@ extension Swift_Protobuf_TestFieldOrderings.NestedMessage: SwiftProtobuf.Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Swift_Protobuf_TestFieldOrderings.NestedMessage, rhs: Swift_Protobuf_TestFieldOrderings.NestedMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Order_TestFieldOrderings.NestedMessage, rhs: SwiftProtoTesting_Order_TestFieldOrderings.NestedMessage) -> Bool { if lhs._oo != rhs._oo {return false} if lhs._bb != rhs._bb {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -631,19 +510,9 @@ extension Swift_Protobuf_TestFieldOrderings.NestedMessage: SwiftProtobuf.Message } } -extension Swift_Protobuf_OneofTraversalGeneration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Order_OneofTraversalGeneration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".OneofTraversalGeneration" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 26: .same(proto: "b"), - 101: .same(proto: "a2"), - 126: .same(proto: "b2"), - 113: .same(proto: "m"), - 201: .same(proto: "a3"), - 226: .same(proto: "b3"), - 301: .same(proto: "a4"), - 326: .same(proto: "b4"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{2}\u{19}b\0\u{2}K\u{1}a2\0\u{2}\u{c}m\0\u{2}\u{d}b2\0\u{2}K\u{1}a3\0\u{2}\u{19}b3\0\u{2}K\u{1}a4\0\u{2}\u{19}b4\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} @@ -722,7 +591,7 @@ extension Swift_Protobuf_OneofTraversalGeneration: SwiftProtobuf.Message, SwiftP } }() case 202, 325: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: Swift_Protobuf_OneofTraversalGeneration.self, fieldNumber: fieldNumber) }() + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Order_OneofTraversalGeneration.self, fieldNumber: fieldNumber) }() default: break } } @@ -770,7 +639,7 @@ extension Swift_Protobuf_OneofTraversalGeneration: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: Swift_Protobuf_OneofTraversalGeneration, rhs: Swift_Protobuf_OneofTraversalGeneration) -> Bool { + static func ==(lhs: SwiftProtoTesting_Order_OneofTraversalGeneration, rhs: SwiftProtoTesting_Order_OneofTraversalGeneration) -> Bool { if lhs.oGood != rhs.oGood {return false} if lhs.oConflictField != rhs.oConflictField {return false} if lhs._m != rhs._m {return false} diff --git a/Tests/SwiftProtobufTests/unittest_swift_groups.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_groups.pb.swift index 79c852988..6f52ff8da 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_groups.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_groups.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_groups.proto @@ -37,7 +38,6 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -51,17 +51,17 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP } /// Same field number appears inside and outside of the group. -struct SwiftTestGroupExtensions: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_GroupExtensions: SwiftProtobuf.ExtensibleMessage, Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -73,17 +73,17 @@ struct SwiftTestGroupExtensions: SwiftProtobuf.ExtensibleMessage { fileprivate var _a: Int32? = nil } -struct ExtensionGroup { +struct SwiftProtoTesting_ExtensionGroup: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -94,17 +94,17 @@ struct ExtensionGroup { fileprivate var _a: Int32? = nil } -struct RepeatedExtensionGroup { +struct SwiftProtoTesting_RepeatedExtensionGroup: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -115,17 +115,17 @@ struct RepeatedExtensionGroup { fileprivate var _a: Int32? = nil } -struct SwiftTestGroupUnextended { +struct SwiftProtoTesting_GroupUnextended: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -136,69 +136,69 @@ struct SwiftTestGroupUnextended { fileprivate var _a: Int32? = nil } -struct SwiftTestNestingGroupsMessage { +struct SwiftProtoTesting_NestingGroupsMessage: Sendable { // 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 outerA: Int32 { - get {return _outerA ?? 0} + get {_outerA ?? 0} set {_outerA = newValue} } /// Returns true if `outerA` has been explicitly set. - var hasOuterA: Bool {return self._outerA != nil} + var hasOuterA: Bool {self._outerA != nil} /// Clears the value of `outerA`. Subsequent reads from it will return its default value. mutating func clearOuterA() {self._outerA = nil} - var subGroup1: SwiftTestNestingGroupsMessage.SubGroup1 { - get {return _subGroup1 ?? SwiftTestNestingGroupsMessage.SubGroup1()} + var subGroup1: SwiftProtoTesting_NestingGroupsMessage.SubGroup1 { + get {_subGroup1 ?? SwiftProtoTesting_NestingGroupsMessage.SubGroup1()} set {_subGroup1 = newValue} } /// Returns true if `subGroup1` has been explicitly set. - var hasSubGroup1: Bool {return self._subGroup1 != nil} + var hasSubGroup1: Bool {self._subGroup1 != nil} /// Clears the value of `subGroup1`. Subsequent reads from it will return its default value. mutating func clearSubGroup1() {self._subGroup1 = nil} - var subGroup3: [SwiftTestNestingGroupsMessage.SubGroup3] = [] + var subGroup3: [SwiftProtoTesting_NestingGroupsMessage.SubGroup3] = [] var unknownFields = SwiftProtobuf.UnknownStorage() - struct SubGroup1 { + struct SubGroup1: Sendable { // 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 sub1A: Int32 { - get {return _sub1A ?? 0} + get {_sub1A ?? 0} set {_sub1A = newValue} } /// Returns true if `sub1A` has been explicitly set. - var hasSub1A: Bool {return self._sub1A != nil} + var hasSub1A: Bool {self._sub1A != nil} /// Clears the value of `sub1A`. Subsequent reads from it will return its default value. mutating func clearSub1A() {self._sub1A = nil} - var subGroup2: SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2 { - get {return _subGroup2 ?? SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2()} + var subGroup2: SwiftProtoTesting_NestingGroupsMessage.SubGroup1.SubGroup2 { + get {_subGroup2 ?? SwiftProtoTesting_NestingGroupsMessage.SubGroup1.SubGroup2()} set {_subGroup2 = newValue} } /// Returns true if `subGroup2` has been explicitly set. - var hasSubGroup2: Bool {return self._subGroup2 != nil} + var hasSubGroup2: Bool {self._subGroup2 != nil} /// Clears the value of `subGroup2`. Subsequent reads from it will return its default value. mutating func clearSubGroup2() {self._subGroup2 = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - struct SubGroup2 { + struct SubGroup2: Sendable { // 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 sub2A: Int32 { - get {return _sub2A ?? 0} + get {_sub2A ?? 0} set {_sub2A = newValue} } /// Returns true if `sub2A` has been explicitly set. - var hasSub2A: Bool {return self._sub2A != nil} + var hasSub2A: Bool {self._sub2A != nil} /// Clears the value of `sub2A`. Subsequent reads from it will return its default value. mutating func clearSub2A() {self._sub2A = nil} @@ -212,38 +212,38 @@ struct SwiftTestNestingGroupsMessage { init() {} fileprivate var _sub1A: Int32? = nil - fileprivate var _subGroup2: SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2? = nil + fileprivate var _subGroup2: SwiftProtoTesting_NestingGroupsMessage.SubGroup1.SubGroup2? = nil } - struct SubGroup3 { + struct SubGroup3: Sendable { // 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 sub3A: Int32 { - get {return _sub3A ?? 0} + get {_sub3A ?? 0} set {_sub3A = newValue} } /// Returns true if `sub3A` has been explicitly set. - var hasSub3A: Bool {return self._sub3A != nil} + var hasSub3A: Bool {self._sub3A != nil} /// Clears the value of `sub3A`. Subsequent reads from it will return its default value. mutating func clearSub3A() {self._sub3A = nil} - var subGroup4: [SwiftTestNestingGroupsMessage.SubGroup3.SubGroup4] = [] + var subGroup4: [SwiftProtoTesting_NestingGroupsMessage.SubGroup3.SubGroup4] = [] var unknownFields = SwiftProtobuf.UnknownStorage() - struct SubGroup4 { + struct SubGroup4: Sendable { // 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 sub4A: Int32 { - get {return _sub4A ?? 0} + get {_sub4A ?? 0} set {_sub4A = newValue} } /// Returns true if `sub4A` has been explicitly set. - var hasSub4A: Bool {return self._sub4A != nil} + var hasSub4A: Bool {self._sub4A != nil} /// Clears the value of `sub4A`. Subsequent reads from it will return its default value. mutating func clearSub4A() {self._sub4A = nil} @@ -262,96 +262,74 @@ struct SwiftTestNestingGroupsMessage { init() {} fileprivate var _outerA: Int32? = nil - fileprivate var _subGroup1: SwiftTestNestingGroupsMessage.SubGroup1? = nil + fileprivate var _subGroup1: SwiftProtoTesting_NestingGroupsMessage.SubGroup1? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension SwiftTestGroupExtensions: @unchecked Sendable {} -extension ExtensionGroup: @unchecked Sendable {} -extension RepeatedExtensionGroup: @unchecked Sendable {} -extension SwiftTestGroupUnextended: @unchecked Sendable {} -extension SwiftTestNestingGroupsMessage: @unchecked Sendable {} -extension SwiftTestNestingGroupsMessage.SubGroup1: @unchecked Sendable {} -extension SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2: @unchecked Sendable {} -extension SwiftTestNestingGroupsMessage.SubGroup3: @unchecked Sendable {} -extension SwiftTestNestingGroupsMessage.SubGroup3.SubGroup4: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_groups.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 SwiftTestGroupExtensions { +extension SwiftProtoTesting_GroupExtensions { - var extensionGroup: ExtensionGroup { - get {return getExtensionValue(ext: Extensions_ExtensionGroup) ?? ExtensionGroup()} - set {setExtensionValue(ext: Extensions_ExtensionGroup, value: newValue)} + var SwiftProtoTesting_extensionGroup: SwiftProtoTesting_ExtensionGroup { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_ExtensionGroup) ?? SwiftProtoTesting_ExtensionGroup()} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_ExtensionGroup, value: newValue)} } - /// Returns true if extension `Extensions_ExtensionGroup` + /// Returns true if extension `SwiftProtoTesting_Extensions_ExtensionGroup` /// has been explicitly set. - var hasExtensionGroup: Bool { - return hasExtensionValue(ext: Extensions_ExtensionGroup) + var hasSwiftProtoTesting_extensionGroup: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_ExtensionGroup) } - /// Clears the value of extension `Extensions_ExtensionGroup`. + /// Clears the value of extension `SwiftProtoTesting_Extensions_ExtensionGroup`. /// Subsequent reads from it will return its default value. - mutating func clearExtensionGroup() { - clearExtensionValue(ext: Extensions_ExtensionGroup) + mutating func clearSwiftProtoTesting_extensionGroup() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_ExtensionGroup) } - var repeatedExtensionGroup: [RepeatedExtensionGroup] { - get {return getExtensionValue(ext: Extensions_RepeatedExtensionGroup) ?? []} - set {setExtensionValue(ext: Extensions_RepeatedExtensionGroup, value: newValue)} - } - /// Returns true if extension `Extensions_RepeatedExtensionGroup` - /// has been explicitly set. - var hasRepeatedExtensionGroup: Bool { - return hasExtensionValue(ext: Extensions_RepeatedExtensionGroup) - } - /// Clears the value of extension `Extensions_RepeatedExtensionGroup`. - /// Subsequent reads from it will return its default value. - mutating func clearRepeatedExtensionGroup() { - clearExtensionValue(ext: Extensions_RepeatedExtensionGroup) + var SwiftProtoTesting_repeatedExtensionGroup: [SwiftProtoTesting_RepeatedExtensionGroup] { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_RepeatedExtensionGroup) ?? []} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_RepeatedExtensionGroup, value: newValue)} } } -// MARK: - File's ExtensionMap: UnittestSwiftGroups_Extensions +// MARK: - File's ExtensionMap: SwiftProtoTesting_UnittestSwiftGroups_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 UnittestSwiftGroups_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - Extensions_ExtensionGroup, - Extensions_RepeatedExtensionGroup +let SwiftProtoTesting_UnittestSwiftGroups_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Extensions_ExtensionGroup, + SwiftProtoTesting_Extensions_RepeatedExtensionGroup ] // 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 Extensions_ExtensionGroup = SwiftProtobuf.MessageExtension, SwiftTestGroupExtensions>( +let SwiftProtoTesting_Extensions_ExtensionGroup = SwiftProtobuf.MessageExtension, SwiftProtoTesting_GroupExtensions>( _protobuf_fieldNumber: 2, - fieldName: "extensiongroup" + fieldName: "swift_proto_testing.extensiongroup" ) -let Extensions_RepeatedExtensionGroup = SwiftProtobuf.MessageExtension, SwiftTestGroupExtensions>( +let SwiftProtoTesting_Extensions_RepeatedExtensionGroup = SwiftProtobuf.MessageExtension, SwiftProtoTesting_GroupExtensions>( _protobuf_fieldNumber: 3, - fieldName: "repeatedextensiongroup" + fieldName: "swift_proto_testing.repeatedextensiongroup" ) // MARK: - Code below here is support for the SwiftProtobuf runtime. -extension SwiftTestGroupExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = "SwiftTestGroupExtensions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] +fileprivate let _protobuf_package = "swift_proto_testing" + +extension SwiftProtoTesting_GroupExtensions: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GroupExtensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") public var isInitialized: Bool { if !_protobuf_extensionFieldValues.isInitialized {return false} @@ -366,7 +344,7 @@ extension SwiftTestGroupExtensions: SwiftProtobuf.Message, SwiftProtobuf._Messag switch fieldNumber { case 1: try { try decoder.decodeSingularInt32Field(value: &self._a) }() case 2..<11: - try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftTestGroupExtensions.self, fieldNumber: fieldNumber) }() + try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_GroupExtensions.self, fieldNumber: fieldNumber) }() default: break } } @@ -384,7 +362,7 @@ extension SwiftTestGroupExtensions: SwiftProtobuf.Message, SwiftProtobuf._Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftTestGroupExtensions, rhs: SwiftTestGroupExtensions) -> Bool { + static func ==(lhs: SwiftProtoTesting_GroupExtensions, rhs: SwiftProtoTesting_GroupExtensions) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} @@ -392,11 +370,9 @@ extension SwiftTestGroupExtensions: SwiftProtobuf.Message, SwiftProtobuf._Messag } } -extension ExtensionGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = "ExtensionGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] +extension SwiftProtoTesting_ExtensionGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".ExtensionGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -421,18 +397,16 @@ extension ExtensionGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplement try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ExtensionGroup, rhs: ExtensionGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_ExtensionGroup, rhs: SwiftProtoTesting_ExtensionGroup) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension RepeatedExtensionGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = "RepeatedExtensionGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] +extension SwiftProtoTesting_RepeatedExtensionGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".RepeatedExtensionGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -457,18 +431,16 @@ extension RepeatedExtensionGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageI try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: RepeatedExtensionGroup, rhs: RepeatedExtensionGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_RepeatedExtensionGroup, rhs: SwiftProtoTesting_RepeatedExtensionGroup) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftTestGroupUnextended: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = "SwiftTestGroupUnextended" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] +extension SwiftProtoTesting_GroupUnextended: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".GroupUnextended" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -493,20 +465,16 @@ extension SwiftTestGroupUnextended: SwiftProtobuf.Message, SwiftProtobuf._Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftTestGroupUnextended, rhs: SwiftTestGroupUnextended) -> Bool { + static func ==(lhs: SwiftProtoTesting_GroupUnextended, rhs: SwiftProtoTesting_GroupUnextended) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftTestNestingGroupsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = "SwiftTestNestingGroupsMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "outer_a"), - 2: .unique(proto: "SubGroup1", json: "subgroup1"), - 3: .unique(proto: "SubGroup3", json: "subgroup3"), - ] +extension SwiftProtoTesting_NestingGroupsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".NestingGroupsMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}outer_a\0\u{7}SubGroup1\0\u{7}SubGroup3\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -539,7 +507,7 @@ extension SwiftTestNestingGroupsMessage: SwiftProtobuf.Message, SwiftProtobuf._M try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftTestNestingGroupsMessage, rhs: SwiftTestNestingGroupsMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_NestingGroupsMessage, rhs: SwiftProtoTesting_NestingGroupsMessage) -> Bool { if lhs._outerA != rhs._outerA {return false} if lhs._subGroup1 != rhs._subGroup1 {return false} if lhs.subGroup3 != rhs.subGroup3 {return false} @@ -548,12 +516,9 @@ extension SwiftTestNestingGroupsMessage: SwiftProtobuf.Message, SwiftProtobuf._M } } -extension SwiftTestNestingGroupsMessage.SubGroup1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftTestNestingGroupsMessage.protoMessageName + ".SubGroup1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "sub1_a"), - 2: .unique(proto: "SubGroup2", json: "subgroup2"), - ] +extension SwiftProtoTesting_NestingGroupsMessage.SubGroup1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_NestingGroupsMessage.protoMessageName + ".SubGroup1" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}sub1_a\0\u{7}SubGroup2\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -582,7 +547,7 @@ extension SwiftTestNestingGroupsMessage.SubGroup1: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftTestNestingGroupsMessage.SubGroup1, rhs: SwiftTestNestingGroupsMessage.SubGroup1) -> Bool { + static func ==(lhs: SwiftProtoTesting_NestingGroupsMessage.SubGroup1, rhs: SwiftProtoTesting_NestingGroupsMessage.SubGroup1) -> Bool { if lhs._sub1A != rhs._sub1A {return false} if lhs._subGroup2 != rhs._subGroup2 {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -590,11 +555,9 @@ extension SwiftTestNestingGroupsMessage.SubGroup1: SwiftProtobuf.Message, SwiftP } } -extension SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftTestNestingGroupsMessage.SubGroup1.protoMessageName + ".SubGroup2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "sub2_a"), - ] +extension SwiftProtoTesting_NestingGroupsMessage.SubGroup1.SubGroup2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_NestingGroupsMessage.SubGroup1.protoMessageName + ".SubGroup2" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}sub2_a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -619,19 +582,16 @@ extension SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2, rhs: SwiftTestNestingGroupsMessage.SubGroup1.SubGroup2) -> Bool { + static func ==(lhs: SwiftProtoTesting_NestingGroupsMessage.SubGroup1.SubGroup2, rhs: SwiftProtoTesting_NestingGroupsMessage.SubGroup1.SubGroup2) -> Bool { if lhs._sub2A != rhs._sub2A {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftTestNestingGroupsMessage.SubGroup3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftTestNestingGroupsMessage.protoMessageName + ".SubGroup3" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "sub3_a"), - 2: .unique(proto: "SubGroup4", json: "subgroup4"), - ] +extension SwiftProtoTesting_NestingGroupsMessage.SubGroup3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_NestingGroupsMessage.protoMessageName + ".SubGroup3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}sub3_a\0\u{7}SubGroup4\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -660,7 +620,7 @@ extension SwiftTestNestingGroupsMessage.SubGroup3: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftTestNestingGroupsMessage.SubGroup3, rhs: SwiftTestNestingGroupsMessage.SubGroup3) -> Bool { + static func ==(lhs: SwiftProtoTesting_NestingGroupsMessage.SubGroup3, rhs: SwiftProtoTesting_NestingGroupsMessage.SubGroup3) -> Bool { if lhs._sub3A != rhs._sub3A {return false} if lhs.subGroup4 != rhs.subGroup4 {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -668,11 +628,9 @@ extension SwiftTestNestingGroupsMessage.SubGroup3: SwiftProtobuf.Message, SwiftP } } -extension SwiftTestNestingGroupsMessage.SubGroup3.SubGroup4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftTestNestingGroupsMessage.SubGroup3.protoMessageName + ".SubGroup4" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "sub4_a"), - ] +extension SwiftProtoTesting_NestingGroupsMessage.SubGroup3.SubGroup4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_NestingGroupsMessage.SubGroup3.protoMessageName + ".SubGroup4" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}sub4_a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -697,7 +655,7 @@ extension SwiftTestNestingGroupsMessage.SubGroup3.SubGroup4: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftTestNestingGroupsMessage.SubGroup3.SubGroup4, rhs: SwiftTestNestingGroupsMessage.SubGroup3.SubGroup4) -> Bool { + static func ==(lhs: SwiftProtoTesting_NestingGroupsMessage.SubGroup3.SubGroup4, rhs: SwiftProtoTesting_NestingGroupsMessage.SubGroup3.SubGroup4) -> Bool { if lhs._sub4A != rhs._sub4A {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Tests/SwiftProtobufTests/unittest_swift_json.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_json.pb.swift index 36e6d685f..afd415b8d 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_json.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_json.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_json.proto @@ -16,7 +17,6 @@ // See http://swift.org/LICENSE.txt for license information // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -29,7 +29,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_SwiftJSONTest { +struct SwiftProtoTesting_SwiftJSONTest: Sendable { // 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. @@ -42,19 +42,13 @@ struct ProtobufUnittest_SwiftJSONTest { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_SwiftJSONTest: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_SwiftJSONTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_SwiftJSONTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SwiftJSONTest" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 318: .standard(proto: "repeated_null_value"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}~\u{4}repeated_null_value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -75,7 +69,7 @@ extension ProtobufUnittest_SwiftJSONTest: SwiftProtobuf.Message, SwiftProtobuf._ try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_SwiftJSONTest, rhs: ProtobufUnittest_SwiftJSONTest) -> Bool { + static func ==(lhs: SwiftProtoTesting_SwiftJSONTest, rhs: SwiftProtoTesting_SwiftJSONTest) -> Bool { if lhs.repeatedNullValue != rhs.repeatedNullValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Tests/SwiftProtobufTests/unittest_swift_naming.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_naming.pb.swift index c55c0afab..2ab44a455 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_naming.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_naming.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_naming.proto @@ -25,7 +26,6 @@ /// proto2 syntax is used so the has*/clear* names also get generated. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -38,663 +38,226 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -enum SwiftUnittest_Names_EnumFieldNames: SwiftProtobuf.Enum { - typealias RawValue = Int - case a // = 0 - case string // = 1 - case int // = 2 - case double // = 3 - case float // = 4 - case uint // = 5 - case hashValue_ // = 6 - case description_ // = 7 - case debugDescription_ // = 8 - case swift // = 9 - case unrecognized // = 10 - case `class` // = 11 - case `deinit` // = 12 - case `enum` // = 13 - case `extension` // = 14 - case `func` // = 15 - case `import` // = 16 - case init_ // = 17 - case `inout` // = 18 - case `internal` // = 19 - case `let` // = 20 - case `operator` // = 21 - case `private` // = 22 - case `protocol` // = 23 - case `public` // = 24 - case `static` // = 25 - case `struct` // = 26 - case `subscript` // = 27 - case `typealias` // = 28 - case `var` // = 29 - case `break` // = 30 - case `case` // = 31 - case `continue` // = 32 - case `default` // = 33 - case `defer` // = 34 - case `do` // = 35 - case `else` // = 36 - case `fallthrough` // = 37 - case `for` // = 38 - case `guard` // = 39 - case `if` // = 40 - case `in` // = 41 - case `repeat` // = 42 - case `return` // = 43 - case `switch` // = 44 - case `where` // = 45 - case `while` // = 46 - case `as` // = 47 - case `catch` // = 48 - case dynamicType_ // = 49 - case `false` // = 50 - case `is` // = 51 - case `nil` // = 52 - case `rethrows` // = 53 - case `super` // = 54 - case self_ // = 55 - case `throw` // = 57 - case `throws` // = 58 - case `true` // = 59 - case `try` // = 60 - case _Column__ // = 61 - case _File__ // = 62 - case _Function__ // = 63 - case _Line__ // = 64 - case ___ // = 65 - case `associativity` // = 66 - case convenience // = 67 - case dynamic // = 68 - case didSet // = 69 - case final // = 70 - case get // = 71 - case infix // = 72 - case indirect // = 73 - case lazy // = 74 - case left // = 75 - case mutating // = 76 - case none // = 77 - case nonmutating // = 78 - case `optional` // = 79 - case override // = 80 - case postfix // = 81 - case precedence // = 82 - case prefix // = 83 - case `required` // = 85 - case right // = 86 - case set // = 87 - case type // = 88 - case unowned // = 89 - case weak // = 90 - case willSet // = 91 +enum SwiftProtoTesting_Names_EnumFieldNames: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case a = 0 + case string = 1 + case int = 2 + case double = 3 + case float = 4 + case uint = 5 + case hashValue_ = 6 + case description_ = 7 + case debugDescription_ = 8 + case swift = 9 + case unrecognized = 10 + case `class` = 11 + case `deinit` = 12 + case `enum` = 13 + case `extension` = 14 + case `func` = 15 + case `import` = 16 + case init_ = 17 + case `inout` = 18 + case `internal` = 19 + case `let` = 20 + case `operator` = 21 + case `private` = 22 + case `protocol` = 23 + case `public` = 24 + case `static` = 25 + case `struct` = 26 + case `subscript` = 27 + case `typealias` = 28 + case `var` = 29 + case `break` = 30 + case `case` = 31 + case `continue` = 32 + case `default` = 33 + case `defer` = 34 + case `do` = 35 + case `else` = 36 + case `fallthrough` = 37 + case `for` = 38 + case `guard` = 39 + case `if` = 40 + case `in` = 41 + case `repeat` = 42 + case `return` = 43 + case `switch` = 44 + case `where` = 45 + case `while` = 46 + case `as` = 47 + case `catch` = 48 + case dynamicType_ = 49 + case `false` = 50 + case `is` = 51 + case `nil` = 52 + case `rethrows` = 53 + case `super` = 54 + case self_ = 55 + case `throw` = 57 + case `throws` = 58 + case `true` = 59 + case `try` = 60 + case _Column__ = 61 + case _File__ = 62 + case _Function__ = 63 + case _Line__ = 64 + case ___ = 65 + case `associativity` = 66 + case convenience = 67 + case dynamic = 68 + case didSet = 69 + case final = 70 + case get = 71 + case infix = 72 + case indirect = 73 + case lazy = 74 + case left = 75 + case mutating = 76 + case none = 77 + case nonmutating = 78 + case `optional` = 79 + case override = 80 + case postfix = 81 + case precedence = 82 + case prefix = 83 + case `required` = 85 + case right = 86 + case set = 87 + case type = 88 + case unowned = 89 + case weak = 90 + case willSet = 91 /// id = 92; - case cmd // = 93 - case out // = 96 - case bycopy // = 98 - case byref // = 99 - case oneway // = 100 - case and // = 102 - case andEq // = 103 - case alignas // = 104 - case alignof // = 105 - case asm // = 106 - case auto // = 107 - case bitand // = 108 - case bitor // = 109 - case bool // = 110 - case char // = 114 - case char16T // = 115 - case char32T // = 116 - case compl // = 118 - case const // = 119 - case constexpr // = 120 - case constCast // = 121 - case decltype // = 123 - case delete // = 125 - case dynamicCast // = 127 - case explicit // = 130 - case export // = 131 - case extern // = 132 - case friend // = 136 - case goto // = 137 - case inline // = 139 - case long // = 141 - case mutable // = 142 - case namespace // = 143 - case new // = 144 - case noexcept // = 145 - case not // = 146 - case notEq // = 147 - case nullptr // = 148 - case or // = 150 - case orEq // = 151 - case protected // = 153 - case register // = 155 - case reinterpretCast // = 156 - case short // = 158 - case signed // = 159 - case sizeof // = 160 - case staticAssert // = 162 - case staticCast // = 163 - case template // = 166 - case this // = 167 - case threadLocal // = 168 - case typedef // = 172 - case typeid // = 173 - case typename // = 174 - case union // = 175 - case unsigned // = 176 - case using // = 177 - case virtual // = 178 - case void // = 179 - case volatile // = 180 - case wcharT // = 181 - case xor // = 183 - case xorEq // = 184 - case restrict // = 185 - case category // = 186 - case ivar // = 187 - case method // = 188 - case finalize // = 192 - case hash // = 193 - case dealloc // = 194 - case superclass // = 197 - case retain // = 198 - case release // = 199 - case autorelease // = 200 - case retainCount // = 201 - case zone // = 202 - case isProxy // = 203 - case copy // = 204 - case mutableCopy // = 205 - case classForCoder // = 206 - case clear // = 207 - case data // = 208 - case delimitedData // = 209 - case descriptor // = 210 - case extensionRegistry // = 211 - case extensionsCurrentlySet // = 212 - case isInitialized // = 213 - case serializedSize // = 214 - case sortedExtensionsInUse // = 215 - case unknownFields // = 216 - case fixed // = 217 - case fract // = 218 - case size // = 219 - case logicalAddress // = 220 - case physicalAddress // = 221 - case byteCount // = 222 - case byteOffset // = 223 - case duration // = 224 - case absoluteTime // = 225 - case optionBits // = 226 - case itemCount // = 227 - case pbversion // = 228 - case scriptCode // = 229 - case langCode // = 230 - case regionCode // = 231 - case ostype // = 232 - case processSerialNumber // = 233 - case point // = 234 - case rect // = 235 - case fixedPoint // = 236 - case fixedRect // = 237 - case style // = 238 - case styleParameter // = 239 - case styleField // = 240 - case timeScale // = 241 - case timeBase // = 242 - case timeRecord // = 243 - case extensions // = 244 + case cmd = 93 + case out = 96 + case bycopy = 98 + case byref = 99 + case oneway = 100 + case and = 102 + case andEq = 103 + case alignas = 104 + case alignof = 105 + case asm = 106 + case auto = 107 + case bitand = 108 + case bitor = 109 + case bool = 110 + case char = 114 + case char16T = 115 + case char32T = 116 + case compl = 118 + case const = 119 + case constexpr = 120 + case constCast = 121 + case decltype = 123 + case delete = 125 + case dynamicCast = 127 + case explicit = 130 + case export = 131 + case extern = 132 + case friend = 136 + case goto = 137 + case inline = 139 + case long = 141 + case mutable = 142 + case namespace = 143 + case new = 144 + case noexcept = 145 + case not = 146 + case notEq = 147 + case nullptr = 148 + case or = 150 + case orEq = 151 + case protected = 153 + case register = 155 + case reinterpretCast = 156 + case short = 158 + case signed = 159 + case sizeof = 160 + case staticAssert = 162 + case staticCast = 163 + case template = 166 + case this = 167 + case threadLocal = 168 + case typedef = 172 + case typeid = 173 + case typename = 174 + case union = 175 + case unsigned = 176 + case using = 177 + case virtual = 178 + case void = 179 + case volatile = 180 + case wcharT = 181 + case xor = 183 + case xorEq = 184 + case restrict = 185 + case category = 186 + case ivar = 187 + case method = 188 + case finalize = 192 + case hash = 193 + case dealloc = 194 + case superclass = 197 + case retain = 198 + case release = 199 + case autorelease = 200 + case retainCount = 201 + case zone = 202 + case isProxy = 203 + case copy = 204 + case mutableCopy = 205 + case classForCoder = 206 + case clear = 207 + case data = 208 + case delimitedData = 209 + case descriptor = 210 + case extensionRegistry = 211 + case extensionsCurrentlySet = 212 + case isInitialized = 213 + case serializedSize = 214 + case sortedExtensionsInUse = 215 + case unknownFields = 216 + case fixed = 217 + case fract = 218 + case size = 219 + case logicalAddress = 220 + case physicalAddress = 221 + case byteCount = 222 + case byteOffset = 223 + case duration = 224 + case absoluteTime = 225 + case optionBits = 226 + case itemCount = 227 + case pbversion = 228 + case scriptCode = 229 + case langCode = 230 + case regionCode = 231 + case ostype = 232 + case processSerialNumber = 233 + case point = 234 + case rect = 235 + case fixedPoint = 236 + case fixedRect = 237 + case style = 238 + case styleParameter = 239 + case styleField = 240 + case timeScale = 241 + case timeBase = 242 + case timeRecord = 243 + case extensions = 244 init() { self = .a } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .a - case 1: self = .string - case 2: self = .int - case 3: self = .double - case 4: self = .float - case 5: self = .uint - case 6: self = .hashValue_ - case 7: self = .description_ - case 8: self = .debugDescription_ - case 9: self = .swift - case 10: self = .unrecognized - case 11: self = .class - case 12: self = .deinit - case 13: self = .enum - case 14: self = .extension - case 15: self = .func - case 16: self = .import - case 17: self = .init_ - case 18: self = .inout - case 19: self = .internal - case 20: self = .let - case 21: self = .operator - case 22: self = .private - case 23: self = .protocol - case 24: self = .public - case 25: self = .static - case 26: self = .struct - case 27: self = .subscript - case 28: self = .typealias - case 29: self = .var - case 30: self = .break - case 31: self = .case - case 32: self = .continue - case 33: self = .default - case 34: self = .defer - case 35: self = .do - case 36: self = .else - case 37: self = .fallthrough - case 38: self = .for - case 39: self = .guard - case 40: self = .if - case 41: self = .in - case 42: self = .repeat - case 43: self = .return - case 44: self = .switch - case 45: self = .where - case 46: self = .while - case 47: self = .as - case 48: self = .catch - case 49: self = .dynamicType_ - case 50: self = .false - case 51: self = .is - case 52: self = .nil - case 53: self = .rethrows - case 54: self = .super - case 55: self = .self_ - case 57: self = .throw - case 58: self = .throws - case 59: self = .true - case 60: self = .try - case 61: self = ._Column__ - case 62: self = ._File__ - case 63: self = ._Function__ - case 64: self = ._Line__ - case 65: self = .___ - case 66: self = .associativity - case 67: self = .convenience - case 68: self = .dynamic - case 69: self = .didSet - case 70: self = .final - case 71: self = .get - case 72: self = .infix - case 73: self = .indirect - case 74: self = .lazy - case 75: self = .left - case 76: self = .mutating - case 77: self = .none - case 78: self = .nonmutating - case 79: self = .optional - case 80: self = .override - case 81: self = .postfix - case 82: self = .precedence - case 83: self = .prefix - case 85: self = .required - case 86: self = .right - case 87: self = .set - case 88: self = .type - case 89: self = .unowned - case 90: self = .weak - case 91: self = .willSet - case 93: self = .cmd - case 96: self = .out - case 98: self = .bycopy - case 99: self = .byref - case 100: self = .oneway - case 102: self = .and - case 103: self = .andEq - case 104: self = .alignas - case 105: self = .alignof - case 106: self = .asm - case 107: self = .auto - case 108: self = .bitand - case 109: self = .bitor - case 110: self = .bool - case 114: self = .char - case 115: self = .char16T - case 116: self = .char32T - case 118: self = .compl - case 119: self = .const - case 120: self = .constexpr - case 121: self = .constCast - case 123: self = .decltype - case 125: self = .delete - case 127: self = .dynamicCast - case 130: self = .explicit - case 131: self = .export - case 132: self = .extern - case 136: self = .friend - case 137: self = .goto - case 139: self = .inline - case 141: self = .long - case 142: self = .mutable - case 143: self = .namespace - case 144: self = .new - case 145: self = .noexcept - case 146: self = .not - case 147: self = .notEq - case 148: self = .nullptr - case 150: self = .or - case 151: self = .orEq - case 153: self = .protected - case 155: self = .register - case 156: self = .reinterpretCast - case 158: self = .short - case 159: self = .signed - case 160: self = .sizeof - case 162: self = .staticAssert - case 163: self = .staticCast - case 166: self = .template - case 167: self = .this - case 168: self = .threadLocal - case 172: self = .typedef - case 173: self = .typeid - case 174: self = .typename - case 175: self = .union - case 176: self = .unsigned - case 177: self = .using - case 178: self = .virtual - case 179: self = .void - case 180: self = .volatile - case 181: self = .wcharT - case 183: self = .xor - case 184: self = .xorEq - case 185: self = .restrict - case 186: self = .category - case 187: self = .ivar - case 188: self = .method - case 192: self = .finalize - case 193: self = .hash - case 194: self = .dealloc - case 197: self = .superclass - case 198: self = .retain - case 199: self = .release - case 200: self = .autorelease - case 201: self = .retainCount - case 202: self = .zone - case 203: self = .isProxy - case 204: self = .copy - case 205: self = .mutableCopy - case 206: self = .classForCoder - case 207: self = .clear - case 208: self = .data - case 209: self = .delimitedData - case 210: self = .descriptor - case 211: self = .extensionRegistry - case 212: self = .extensionsCurrentlySet - case 213: self = .isInitialized - case 214: self = .serializedSize - case 215: self = .sortedExtensionsInUse - case 216: self = .unknownFields - case 217: self = .fixed - case 218: self = .fract - case 219: self = .size - case 220: self = .logicalAddress - case 221: self = .physicalAddress - case 222: self = .byteCount - case 223: self = .byteOffset - case 224: self = .duration - case 225: self = .absoluteTime - case 226: self = .optionBits - case 227: self = .itemCount - case 228: self = .pbversion - case 229: self = .scriptCode - case 230: self = .langCode - case 231: self = .regionCode - case 232: self = .ostype - case 233: self = .processSerialNumber - case 234: self = .point - case 235: self = .rect - case 236: self = .fixedPoint - case 237: self = .fixedRect - case 238: self = .style - case 239: self = .styleParameter - case 240: self = .styleField - case 241: self = .timeScale - case 242: self = .timeBase - case 243: self = .timeRecord - case 244: self = .extensions - default: return nil - } - } - - var rawValue: Int { - switch self { - case .a: return 0 - case .string: return 1 - case .int: return 2 - case .double: return 3 - case .float: return 4 - case .uint: return 5 - case .hashValue_: return 6 - case .description_: return 7 - case .debugDescription_: return 8 - case .swift: return 9 - case .unrecognized: return 10 - case .class: return 11 - case .deinit: return 12 - case .enum: return 13 - case .extension: return 14 - case .func: return 15 - case .import: return 16 - case .init_: return 17 - case .inout: return 18 - case .internal: return 19 - case .let: return 20 - case .operator: return 21 - case .private: return 22 - case .protocol: return 23 - case .public: return 24 - case .static: return 25 - case .struct: return 26 - case .subscript: return 27 - case .typealias: return 28 - case .var: return 29 - case .break: return 30 - case .case: return 31 - case .continue: return 32 - case .default: return 33 - case .defer: return 34 - case .do: return 35 - case .else: return 36 - case .fallthrough: return 37 - case .for: return 38 - case .guard: return 39 - case .if: return 40 - case .in: return 41 - case .repeat: return 42 - case .return: return 43 - case .switch: return 44 - case .where: return 45 - case .while: return 46 - case .as: return 47 - case .catch: return 48 - case .dynamicType_: return 49 - case .false: return 50 - case .is: return 51 - case .nil: return 52 - case .rethrows: return 53 - case .super: return 54 - case .self_: return 55 - case .throw: return 57 - case .throws: return 58 - case .true: return 59 - case .try: return 60 - case ._Column__: return 61 - case ._File__: return 62 - case ._Function__: return 63 - case ._Line__: return 64 - case .___: return 65 - case .associativity: return 66 - case .convenience: return 67 - case .dynamic: return 68 - case .didSet: return 69 - case .final: return 70 - case .get: return 71 - case .infix: return 72 - case .indirect: return 73 - case .lazy: return 74 - case .left: return 75 - case .mutating: return 76 - case .none: return 77 - case .nonmutating: return 78 - case .optional: return 79 - case .override: return 80 - case .postfix: return 81 - case .precedence: return 82 - case .prefix: return 83 - case .required: return 85 - case .right: return 86 - case .set: return 87 - case .type: return 88 - case .unowned: return 89 - case .weak: return 90 - case .willSet: return 91 - case .cmd: return 93 - case .out: return 96 - case .bycopy: return 98 - case .byref: return 99 - case .oneway: return 100 - case .and: return 102 - case .andEq: return 103 - case .alignas: return 104 - case .alignof: return 105 - case .asm: return 106 - case .auto: return 107 - case .bitand: return 108 - case .bitor: return 109 - case .bool: return 110 - case .char: return 114 - case .char16T: return 115 - case .char32T: return 116 - case .compl: return 118 - case .const: return 119 - case .constexpr: return 120 - case .constCast: return 121 - case .decltype: return 123 - case .delete: return 125 - case .dynamicCast: return 127 - case .explicit: return 130 - case .export: return 131 - case .extern: return 132 - case .friend: return 136 - case .goto: return 137 - case .inline: return 139 - case .long: return 141 - case .mutable: return 142 - case .namespace: return 143 - case .new: return 144 - case .noexcept: return 145 - case .not: return 146 - case .notEq: return 147 - case .nullptr: return 148 - case .or: return 150 - case .orEq: return 151 - case .protected: return 153 - case .register: return 155 - case .reinterpretCast: return 156 - case .short: return 158 - case .signed: return 159 - case .sizeof: return 160 - case .staticAssert: return 162 - case .staticCast: return 163 - case .template: return 166 - case .this: return 167 - case .threadLocal: return 168 - case .typedef: return 172 - case .typeid: return 173 - case .typename: return 174 - case .union: return 175 - case .unsigned: return 176 - case .using: return 177 - case .virtual: return 178 - case .void: return 179 - case .volatile: return 180 - case .wcharT: return 181 - case .xor: return 183 - case .xorEq: return 184 - case .restrict: return 185 - case .category: return 186 - case .ivar: return 187 - case .method: return 188 - case .finalize: return 192 - case .hash: return 193 - case .dealloc: return 194 - case .superclass: return 197 - case .retain: return 198 - case .release: return 199 - case .autorelease: return 200 - case .retainCount: return 201 - case .zone: return 202 - case .isProxy: return 203 - case .copy: return 204 - case .mutableCopy: return 205 - case .classForCoder: return 206 - case .clear: return 207 - case .data: return 208 - case .delimitedData: return 209 - case .descriptor: return 210 - case .extensionRegistry: return 211 - case .extensionsCurrentlySet: return 212 - case .isInitialized: return 213 - case .serializedSize: return 214 - case .sortedExtensionsInUse: return 215 - case .unknownFields: return 216 - case .fixed: return 217 - case .fract: return 218 - case .size: return 219 - case .logicalAddress: return 220 - case .physicalAddress: return 221 - case .byteCount: return 222 - case .byteOffset: return 223 - case .duration: return 224 - case .absoluteTime: return 225 - case .optionBits: return 226 - case .itemCount: return 227 - case .pbversion: return 228 - case .scriptCode: return 229 - case .langCode: return 230 - case .regionCode: return 231 - case .ostype: return 232 - case .processSerialNumber: return 233 - case .point: return 234 - case .rect: return 235 - case .fixedPoint: return 236 - case .fixedRect: return 237 - case .style: return 238 - case .styleParameter: return 239 - case .styleField: return 240 - case .timeScale: return 241 - case .timeBase: return 242 - case .timeRecord: return 243 - case .extensions: return 244 - } - } - -} - -#if swift(>=4.2) - -extension SwiftUnittest_Names_EnumFieldNames: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -enum SwiftUnittest_Names_EnumFieldNames2: SwiftProtobuf.Enum { - typealias RawValue = Int - case aa // = 0 +} + +enum SwiftProtoTesting_Names_EnumFieldNames2: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aa = 0 /// protoc no longer allows enum naming that would differ only in underscores. /// Initial commit: @@ -703,38 +266,15 @@ enum SwiftUnittest_Names_EnumFieldNames2: SwiftProtobuf.Enum { /// https://github.com/protocolbuffers/protobuf/pull/2204 /// So this is in a second enum so it won't cause issues with the '_' one; /// but still ensure things generator correctly. - case ____ // = 1065 + case ____ = 1065 init() { self = .aa } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aa - case 1065: self = .____ - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aa: return 0 - case .____: return 1065 - } - } - } -#if swift(>=4.2) - -extension SwiftUnittest_Names_EnumFieldNames2: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct SwiftUnittest_Names_Foo: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Names_Foo: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -746,2006 +286,2006 @@ struct SwiftUnittest_Names_Foo: SwiftProtobuf.ExtensibleMessage { var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct SwiftUnittest_Names_FieldNames { +struct SwiftProtoTesting_Names_FieldNames: @unchecked Sendable { // 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 string: Int32 { - get {return _storage._string ?? 0} + get {_storage._string ?? 0} set {_uniqueStorage()._string = newValue} } /// Returns true if `string` has been explicitly set. - var hasString: Bool {return _storage._string != nil} + var hasString: Bool {_storage._string != nil} /// Clears the value of `string`. Subsequent reads from it will return its default value. mutating func clearString() {_uniqueStorage()._string = nil} var int: Int32 { - get {return _storage._int ?? 0} + get {_storage._int ?? 0} set {_uniqueStorage()._int = newValue} } /// Returns true if `int` has been explicitly set. - var hasInt: Bool {return _storage._int != nil} + var hasInt: Bool {_storage._int != nil} /// Clears the value of `int`. Subsequent reads from it will return its default value. mutating func clearInt() {_uniqueStorage()._int = nil} var double: Int32 { - get {return _storage._double ?? 0} + get {_storage._double ?? 0} set {_uniqueStorage()._double = newValue} } /// Returns true if `double` has been explicitly set. - var hasDouble: Bool {return _storage._double != nil} + var hasDouble: Bool {_storage._double != nil} /// Clears the value of `double`. Subsequent reads from it will return its default value. mutating func clearDouble() {_uniqueStorage()._double = nil} var float: Int32 { - get {return _storage._float ?? 0} + get {_storage._float ?? 0} set {_uniqueStorage()._float = newValue} } /// Returns true if `float` has been explicitly set. - var hasFloat: Bool {return _storage._float != nil} + var hasFloat: Bool {_storage._float != nil} /// Clears the value of `float`. Subsequent reads from it will return its default value. mutating func clearFloat() {_uniqueStorage()._float = nil} var uint: Int32 { - get {return _storage._uint ?? 0} + get {_storage._uint ?? 0} set {_uniqueStorage()._uint = newValue} } /// Returns true if `uint` has been explicitly set. - var hasUint: Bool {return _storage._uint != nil} + var hasUint: Bool {_storage._uint != nil} /// Clears the value of `uint`. Subsequent reads from it will return its default value. mutating func clearUint() {_uniqueStorage()._uint = nil} var hashValue_p: Int32 { - get {return _storage._hashValue_p ?? 0} + get {_storage._hashValue_p ?? 0} set {_uniqueStorage()._hashValue_p = newValue} } /// Returns true if `hashValue_p` has been explicitly set. - var hasHashValue_p: Bool {return _storage._hashValue_p != nil} + var hasHashValue_p: Bool {_storage._hashValue_p != nil} /// Clears the value of `hashValue_p`. Subsequent reads from it will return its default value. mutating func clearHashValue_p() {_uniqueStorage()._hashValue_p = nil} var description_p: Int32 { - get {return _storage._description_p ?? 0} + get {_storage._description_p ?? 0} set {_uniqueStorage()._description_p = newValue} } /// Returns true if `description_p` has been explicitly set. - var hasDescription_p: Bool {return _storage._description_p != nil} + var hasDescription_p: Bool {_storage._description_p != nil} /// Clears the value of `description_p`. Subsequent reads from it will return its default value. mutating func clearDescription_p() {_uniqueStorage()._description_p = nil} var debugDescription_p: Int32 { - get {return _storage._debugDescription_p ?? 0} + get {_storage._debugDescription_p ?? 0} set {_uniqueStorage()._debugDescription_p = newValue} } /// Returns true if `debugDescription_p` has been explicitly set. - var hasDebugDescription_p: Bool {return _storage._debugDescription_p != nil} + var hasDebugDescription_p: Bool {_storage._debugDescription_p != nil} /// Clears the value of `debugDescription_p`. Subsequent reads from it will return its default value. mutating func clearDebugDescription_p() {_uniqueStorage()._debugDescription_p = nil} var swift: Int32 { - get {return _storage._swift ?? 0} + get {_storage._swift ?? 0} set {_uniqueStorage()._swift = newValue} } /// Returns true if `swift` has been explicitly set. - var hasSwift: Bool {return _storage._swift != nil} + var hasSwift: Bool {_storage._swift != nil} /// Clears the value of `swift`. Subsequent reads from it will return its default value. mutating func clearSwift() {_uniqueStorage()._swift = nil} var unrecognized: Int32 { - get {return _storage._unrecognized ?? 0} + get {_storage._unrecognized ?? 0} set {_uniqueStorage()._unrecognized = newValue} } /// Returns true if `unrecognized` has been explicitly set. - var hasUnrecognized: Bool {return _storage._unrecognized != nil} + var hasUnrecognized: Bool {_storage._unrecognized != nil} /// Clears the value of `unrecognized`. Subsequent reads from it will return its default value. mutating func clearUnrecognized() {_uniqueStorage()._unrecognized = nil} var `class`: Int32 { - get {return _storage._class ?? 0} + get {_storage._class ?? 0} set {_uniqueStorage()._class = newValue} } /// Returns true if ``class`` has been explicitly set. - var hasClass: Bool {return _storage._class != nil} + var hasClass: Bool {_storage._class != nil} /// Clears the value of ``class``. Subsequent reads from it will return its default value. mutating func clearClass() {_uniqueStorage()._class = nil} var `deinit`: Int32 { - get {return _storage._deinit ?? 0} + get {_storage._deinit ?? 0} set {_uniqueStorage()._deinit = newValue} } /// Returns true if ``deinit`` has been explicitly set. - var hasDeinit: Bool {return _storage._deinit != nil} + var hasDeinit: Bool {_storage._deinit != nil} /// Clears the value of ``deinit``. Subsequent reads from it will return its default value. mutating func clearDeinit() {_uniqueStorage()._deinit = nil} var `enum`: Int32 { - get {return _storage._enum ?? 0} + get {_storage._enum ?? 0} set {_uniqueStorage()._enum = newValue} } /// Returns true if ``enum`` has been explicitly set. - var hasEnum: Bool {return _storage._enum != nil} + var hasEnum: Bool {_storage._enum != nil} /// Clears the value of ``enum``. Subsequent reads from it will return its default value. mutating func clearEnum() {_uniqueStorage()._enum = nil} var `func`: Int32 { - get {return _storage._func ?? 0} + get {_storage._func ?? 0} set {_uniqueStorage()._func = newValue} } /// Returns true if ``func`` has been explicitly set. - var hasFunc: Bool {return _storage._func != nil} + var hasFunc: Bool {_storage._func != nil} /// Clears the value of ``func``. Subsequent reads from it will return its default value. mutating func clearFunc() {_uniqueStorage()._func = nil} var `import`: Int32 { - get {return _storage._import ?? 0} + get {_storage._import ?? 0} set {_uniqueStorage()._import = newValue} } /// Returns true if ``import`` has been explicitly set. - var hasImport: Bool {return _storage._import != nil} + var hasImport: Bool {_storage._import != nil} /// Clears the value of ``import``. Subsequent reads from it will return its default value. mutating func clearImport() {_uniqueStorage()._import = nil} var init_p: Int32 { - get {return _storage._init_p ?? 0} + get {_storage._init_p ?? 0} set {_uniqueStorage()._init_p = newValue} } /// Returns true if `init_p` has been explicitly set. - var hasInit_p: Bool {return _storage._init_p != nil} + var hasInit_p: Bool {_storage._init_p != nil} /// Clears the value of `init_p`. Subsequent reads from it will return its default value. mutating func clearInit_p() {_uniqueStorage()._init_p = nil} var `inout`: Int32 { - get {return _storage._inout ?? 0} + get {_storage._inout ?? 0} set {_uniqueStorage()._inout = newValue} } /// Returns true if ``inout`` has been explicitly set. - var hasInout: Bool {return _storage._inout != nil} + var hasInout: Bool {_storage._inout != nil} /// Clears the value of ``inout``. Subsequent reads from it will return its default value. mutating func clearInout() {_uniqueStorage()._inout = nil} var `internal`: Int32 { - get {return _storage._internal ?? 0} + get {_storage._internal ?? 0} set {_uniqueStorage()._internal = newValue} } /// Returns true if ``internal`` has been explicitly set. - var hasInternal: Bool {return _storage._internal != nil} + var hasInternal: Bool {_storage._internal != nil} /// Clears the value of ``internal``. Subsequent reads from it will return its default value. mutating func clearInternal() {_uniqueStorage()._internal = nil} var `let`: Int32 { - get {return _storage._let ?? 0} + get {_storage._let ?? 0} set {_uniqueStorage()._let = newValue} } /// Returns true if ``let`` has been explicitly set. - var hasLet: Bool {return _storage._let != nil} + var hasLet: Bool {_storage._let != nil} /// Clears the value of ``let``. Subsequent reads from it will return its default value. mutating func clearLet() {_uniqueStorage()._let = nil} var `operator`: Int32 { - get {return _storage._operator ?? 0} + get {_storage._operator ?? 0} set {_uniqueStorage()._operator = newValue} } /// Returns true if ``operator`` has been explicitly set. - var hasOperator: Bool {return _storage._operator != nil} + var hasOperator: Bool {_storage._operator != nil} /// Clears the value of ``operator``. Subsequent reads from it will return its default value. mutating func clearOperator() {_uniqueStorage()._operator = nil} var `private`: Int32 { - get {return _storage._private ?? 0} + get {_storage._private ?? 0} set {_uniqueStorage()._private = newValue} } /// Returns true if ``private`` has been explicitly set. - var hasPrivate: Bool {return _storage._private != nil} + var hasPrivate: Bool {_storage._private != nil} /// Clears the value of ``private``. Subsequent reads from it will return its default value. mutating func clearPrivate() {_uniqueStorage()._private = nil} var `protocol`: Int32 { - get {return _storage._protocol ?? 0} + get {_storage._protocol ?? 0} set {_uniqueStorage()._protocol = newValue} } /// Returns true if ``protocol`` has been explicitly set. - var hasProtocol: Bool {return _storage._protocol != nil} + var hasProtocol: Bool {_storage._protocol != nil} /// Clears the value of ``protocol``. Subsequent reads from it will return its default value. mutating func clearProtocol() {_uniqueStorage()._protocol = nil} var `public`: Int32 { - get {return _storage._public ?? 0} + get {_storage._public ?? 0} set {_uniqueStorage()._public = newValue} } /// Returns true if ``public`` has been explicitly set. - var hasPublic: Bool {return _storage._public != nil} + var hasPublic: Bool {_storage._public != nil} /// Clears the value of ``public``. Subsequent reads from it will return its default value. mutating func clearPublic() {_uniqueStorage()._public = nil} var `static`: Int32 { - get {return _storage._static ?? 0} + get {_storage._static ?? 0} set {_uniqueStorage()._static = newValue} } /// Returns true if ``static`` has been explicitly set. - var hasStatic: Bool {return _storage._static != nil} + var hasStatic: Bool {_storage._static != nil} /// Clears the value of ``static``. Subsequent reads from it will return its default value. mutating func clearStatic() {_uniqueStorage()._static = nil} var `struct`: Int32 { - get {return _storage._struct ?? 0} + get {_storage._struct ?? 0} set {_uniqueStorage()._struct = newValue} } /// Returns true if ``struct`` has been explicitly set. - var hasStruct: Bool {return _storage._struct != nil} + var hasStruct: Bool {_storage._struct != nil} /// Clears the value of ``struct``. Subsequent reads from it will return its default value. mutating func clearStruct() {_uniqueStorage()._struct = nil} var `subscript`: Int32 { - get {return _storage._subscript ?? 0} + get {_storage._subscript ?? 0} set {_uniqueStorage()._subscript = newValue} } /// Returns true if ``subscript`` has been explicitly set. - var hasSubscript: Bool {return _storage._subscript != nil} + var hasSubscript: Bool {_storage._subscript != nil} /// Clears the value of ``subscript``. Subsequent reads from it will return its default value. mutating func clearSubscript() {_uniqueStorage()._subscript = nil} var `typealias`: Int32 { - get {return _storage._typealias ?? 0} + get {_storage._typealias ?? 0} set {_uniqueStorage()._typealias = newValue} } /// Returns true if ``typealias`` has been explicitly set. - var hasTypealias: Bool {return _storage._typealias != nil} + var hasTypealias: Bool {_storage._typealias != nil} /// Clears the value of ``typealias``. Subsequent reads from it will return its default value. mutating func clearTypealias() {_uniqueStorage()._typealias = nil} var `var`: Int32 { - get {return _storage._var ?? 0} + get {_storage._var ?? 0} set {_uniqueStorage()._var = newValue} } /// Returns true if ``var`` has been explicitly set. - var hasVar: Bool {return _storage._var != nil} + var hasVar: Bool {_storage._var != nil} /// Clears the value of ``var``. Subsequent reads from it will return its default value. mutating func clearVar() {_uniqueStorage()._var = nil} var `break`: Int32 { - get {return _storage._break ?? 0} + get {_storage._break ?? 0} set {_uniqueStorage()._break = newValue} } /// Returns true if ``break`` has been explicitly set. - var hasBreak: Bool {return _storage._break != nil} + var hasBreak: Bool {_storage._break != nil} /// Clears the value of ``break``. Subsequent reads from it will return its default value. mutating func clearBreak() {_uniqueStorage()._break = nil} var `case`: Int32 { - get {return _storage._case ?? 0} + get {_storage._case ?? 0} set {_uniqueStorage()._case = newValue} } /// Returns true if ``case`` has been explicitly set. - var hasCase: Bool {return _storage._case != nil} + var hasCase: Bool {_storage._case != nil} /// Clears the value of ``case``. Subsequent reads from it will return its default value. mutating func clearCase() {_uniqueStorage()._case = nil} var `continue`: Int32 { - get {return _storage._continue ?? 0} + get {_storage._continue ?? 0} set {_uniqueStorage()._continue = newValue} } /// Returns true if ``continue`` has been explicitly set. - var hasContinue: Bool {return _storage._continue != nil} + var hasContinue: Bool {_storage._continue != nil} /// Clears the value of ``continue``. Subsequent reads from it will return its default value. mutating func clearContinue() {_uniqueStorage()._continue = nil} var `default`: Int32 { - get {return _storage._default ?? 0} + get {_storage._default ?? 0} set {_uniqueStorage()._default = newValue} } /// Returns true if ``default`` has been explicitly set. - var hasDefault: Bool {return _storage._default != nil} + var hasDefault: Bool {_storage._default != nil} /// Clears the value of ``default``. Subsequent reads from it will return its default value. mutating func clearDefault() {_uniqueStorage()._default = nil} var `defer`: Int32 { - get {return _storage._defer ?? 0} + get {_storage._defer ?? 0} set {_uniqueStorage()._defer = newValue} } /// Returns true if ``defer`` has been explicitly set. - var hasDefer: Bool {return _storage._defer != nil} + var hasDefer: Bool {_storage._defer != nil} /// Clears the value of ``defer``. Subsequent reads from it will return its default value. mutating func clearDefer() {_uniqueStorage()._defer = nil} var `do`: Int32 { - get {return _storage._do ?? 0} + get {_storage._do ?? 0} set {_uniqueStorage()._do = newValue} } /// Returns true if ``do`` has been explicitly set. - var hasDo: Bool {return _storage._do != nil} + var hasDo: Bool {_storage._do != nil} /// Clears the value of ``do``. Subsequent reads from it will return its default value. mutating func clearDo() {_uniqueStorage()._do = nil} var `else`: Int32 { - get {return _storage._else ?? 0} + get {_storage._else ?? 0} set {_uniqueStorage()._else = newValue} } /// Returns true if ``else`` has been explicitly set. - var hasElse: Bool {return _storage._else != nil} + var hasElse: Bool {_storage._else != nil} /// Clears the value of ``else``. Subsequent reads from it will return its default value. mutating func clearElse() {_uniqueStorage()._else = nil} var `fallthrough`: Int32 { - get {return _storage._fallthrough ?? 0} + get {_storage._fallthrough ?? 0} set {_uniqueStorage()._fallthrough = newValue} } /// Returns true if ``fallthrough`` has been explicitly set. - var hasFallthrough: Bool {return _storage._fallthrough != nil} + var hasFallthrough: Bool {_storage._fallthrough != nil} /// Clears the value of ``fallthrough``. Subsequent reads from it will return its default value. mutating func clearFallthrough() {_uniqueStorage()._fallthrough = nil} var `for`: Int32 { - get {return _storage._for ?? 0} + get {_storage._for ?? 0} set {_uniqueStorage()._for = newValue} } /// Returns true if ``for`` has been explicitly set. - var hasFor: Bool {return _storage._for != nil} + var hasFor: Bool {_storage._for != nil} /// Clears the value of ``for``. Subsequent reads from it will return its default value. mutating func clearFor() {_uniqueStorage()._for = nil} var `guard`: Int32 { - get {return _storage._guard ?? 0} + get {_storage._guard ?? 0} set {_uniqueStorage()._guard = newValue} } /// Returns true if ``guard`` has been explicitly set. - var hasGuard: Bool {return _storage._guard != nil} + var hasGuard: Bool {_storage._guard != nil} /// Clears the value of ``guard``. Subsequent reads from it will return its default value. mutating func clearGuard() {_uniqueStorage()._guard = nil} var `if`: Int32 { - get {return _storage._if ?? 0} + get {_storage._if ?? 0} set {_uniqueStorage()._if = newValue} } /// Returns true if ``if`` has been explicitly set. - var hasIf: Bool {return _storage._if != nil} + var hasIf: Bool {_storage._if != nil} /// Clears the value of ``if``. Subsequent reads from it will return its default value. mutating func clearIf() {_uniqueStorage()._if = nil} var `in`: Int32 { - get {return _storage._in ?? 0} + get {_storage._in ?? 0} set {_uniqueStorage()._in = newValue} } /// Returns true if ``in`` has been explicitly set. - var hasIn: Bool {return _storage._in != nil} + var hasIn: Bool {_storage._in != nil} /// Clears the value of ``in``. Subsequent reads from it will return its default value. mutating func clearIn() {_uniqueStorage()._in = nil} var `repeat`: Int32 { - get {return _storage._repeat ?? 0} + get {_storage._repeat ?? 0} set {_uniqueStorage()._repeat = newValue} } /// Returns true if ``repeat`` has been explicitly set. - var hasRepeat: Bool {return _storage._repeat != nil} + var hasRepeat: Bool {_storage._repeat != nil} /// Clears the value of ``repeat``. Subsequent reads from it will return its default value. mutating func clearRepeat() {_uniqueStorage()._repeat = nil} var `return`: Int32 { - get {return _storage._return ?? 0} + get {_storage._return ?? 0} set {_uniqueStorage()._return = newValue} } /// Returns true if ``return`` has been explicitly set. - var hasReturn: Bool {return _storage._return != nil} + var hasReturn: Bool {_storage._return != nil} /// Clears the value of ``return``. Subsequent reads from it will return its default value. mutating func clearReturn() {_uniqueStorage()._return = nil} var `switch`: Int32 { - get {return _storage._switch ?? 0} + get {_storage._switch ?? 0} set {_uniqueStorage()._switch = newValue} } /// Returns true if ``switch`` has been explicitly set. - var hasSwitch: Bool {return _storage._switch != nil} + var hasSwitch: Bool {_storage._switch != nil} /// Clears the value of ``switch``. Subsequent reads from it will return its default value. mutating func clearSwitch() {_uniqueStorage()._switch = nil} var `where`: Int32 { - get {return _storage._where ?? 0} + get {_storage._where ?? 0} set {_uniqueStorage()._where = newValue} } /// Returns true if ``where`` has been explicitly set. - var hasWhere: Bool {return _storage._where != nil} + var hasWhere: Bool {_storage._where != nil} /// Clears the value of ``where``. Subsequent reads from it will return its default value. mutating func clearWhere() {_uniqueStorage()._where = nil} var `while`: Int32 { - get {return _storage._while ?? 0} + get {_storage._while ?? 0} set {_uniqueStorage()._while = newValue} } /// Returns true if ``while`` has been explicitly set. - var hasWhile: Bool {return _storage._while != nil} + var hasWhile: Bool {_storage._while != nil} /// Clears the value of ``while``. Subsequent reads from it will return its default value. mutating func clearWhile() {_uniqueStorage()._while = nil} var `as`: Int32 { - get {return _storage._as ?? 0} + get {_storage._as ?? 0} set {_uniqueStorage()._as = newValue} } /// Returns true if ``as`` has been explicitly set. - var hasAs: Bool {return _storage._as != nil} + var hasAs: Bool {_storage._as != nil} /// Clears the value of ``as``. Subsequent reads from it will return its default value. mutating func clearAs() {_uniqueStorage()._as = nil} var `catch`: Int32 { - get {return _storage._catch ?? 0} + get {_storage._catch ?? 0} set {_uniqueStorage()._catch = newValue} } /// Returns true if ``catch`` has been explicitly set. - var hasCatch: Bool {return _storage._catch != nil} + var hasCatch: Bool {_storage._catch != nil} /// Clears the value of ``catch``. Subsequent reads from it will return its default value. mutating func clearCatch() {_uniqueStorage()._catch = nil} var dynamicType_p: Int32 { - get {return _storage._dynamicType_p ?? 0} + get {_storage._dynamicType_p ?? 0} set {_uniqueStorage()._dynamicType_p = newValue} } /// Returns true if `dynamicType_p` has been explicitly set. - var hasDynamicType_p: Bool {return _storage._dynamicType_p != nil} + var hasDynamicType_p: Bool {_storage._dynamicType_p != nil} /// Clears the value of `dynamicType_p`. Subsequent reads from it will return its default value. mutating func clearDynamicType_p() {_uniqueStorage()._dynamicType_p = nil} var `false`: Int32 { - get {return _storage._false ?? 0} + get {_storage._false ?? 0} set {_uniqueStorage()._false = newValue} } /// Returns true if ``false`` has been explicitly set. - var hasFalse: Bool {return _storage._false != nil} + var hasFalse: Bool {_storage._false != nil} /// Clears the value of ``false``. Subsequent reads from it will return its default value. mutating func clearFalse() {_uniqueStorage()._false = nil} var `is`: Int32 { - get {return _storage._is ?? 0} + get {_storage._is ?? 0} set {_uniqueStorage()._is = newValue} } /// Returns true if ``is`` has been explicitly set. - var hasIs: Bool {return _storage._is != nil} + var hasIs: Bool {_storage._is != nil} /// Clears the value of ``is``. Subsequent reads from it will return its default value. mutating func clearIs() {_uniqueStorage()._is = nil} var `nil`: Int32 { - get {return _storage._nil ?? 0} + get {_storage._nil ?? 0} set {_uniqueStorage()._nil = newValue} } /// Returns true if ``nil`` has been explicitly set. - var hasNil: Bool {return _storage._nil != nil} + var hasNil: Bool {_storage._nil != nil} /// Clears the value of ``nil``. Subsequent reads from it will return its default value. mutating func clearNil() {_uniqueStorage()._nil = nil} var `rethrows`: Int32 { - get {return _storage._rethrows ?? 0} + get {_storage._rethrows ?? 0} set {_uniqueStorage()._rethrows = newValue} } /// Returns true if ``rethrows`` has been explicitly set. - var hasRethrows: Bool {return _storage._rethrows != nil} + var hasRethrows: Bool {_storage._rethrows != nil} /// Clears the value of ``rethrows``. Subsequent reads from it will return its default value. mutating func clearRethrows() {_uniqueStorage()._rethrows = nil} var `super`: Int32 { - get {return _storage._super ?? 0} + get {_storage._super ?? 0} set {_uniqueStorage()._super = newValue} } /// Returns true if ``super`` has been explicitly set. - var hasSuper: Bool {return _storage._super != nil} + var hasSuper: Bool {_storage._super != nil} /// Clears the value of ``super``. Subsequent reads from it will return its default value. mutating func clearSuper() {_uniqueStorage()._super = nil} var self_p: Int32 { - get {return _storage._self_p ?? 0} + get {_storage._self_p ?? 0} set {_uniqueStorage()._self_p = newValue} } /// Returns true if `self_p` has been explicitly set. - var hasSelf_p: Bool {return _storage._self_p != nil} + var hasSelf_p: Bool {_storage._self_p != nil} /// Clears the value of `self_p`. Subsequent reads from it will return its default value. mutating func clearSelf_p() {_uniqueStorage()._self_p = nil} var `throw`: Int32 { - get {return _storage._throw ?? 0} + get {_storage._throw ?? 0} set {_uniqueStorage()._throw = newValue} } /// Returns true if ``throw`` has been explicitly set. - var hasThrow: Bool {return _storage._throw != nil} + var hasThrow: Bool {_storage._throw != nil} /// Clears the value of ``throw``. Subsequent reads from it will return its default value. mutating func clearThrow() {_uniqueStorage()._throw = nil} var `throws`: Int32 { - get {return _storage._throws ?? 0} + get {_storage._throws ?? 0} set {_uniqueStorage()._throws = newValue} } /// Returns true if ``throws`` has been explicitly set. - var hasThrows: Bool {return _storage._throws != nil} + var hasThrows: Bool {_storage._throws != nil} /// Clears the value of ``throws``. Subsequent reads from it will return its default value. mutating func clearThrows() {_uniqueStorage()._throws = nil} var `true`: Int32 { - get {return _storage._true ?? 0} + get {_storage._true ?? 0} set {_uniqueStorage()._true = newValue} } /// Returns true if ``true`` has been explicitly set. - var hasTrue: Bool {return _storage._true != nil} + var hasTrue: Bool {_storage._true != nil} /// Clears the value of ``true``. Subsequent reads from it will return its default value. mutating func clearTrue() {_uniqueStorage()._true = nil} var `try`: Int32 { - get {return _storage._try ?? 0} + get {_storage._try ?? 0} set {_uniqueStorage()._try = newValue} } /// Returns true if ``try`` has been explicitly set. - var hasTry: Bool {return _storage._try != nil} + var hasTry: Bool {_storage._try != nil} /// Clears the value of ``try``. Subsequent reads from it will return its default value. mutating func clearTry() {_uniqueStorage()._try = nil} var _Column__: Int32 { - get {return _storage.__Column__ ?? 0} + get {_storage.__Column__ ?? 0} set {_uniqueStorage().__Column__ = newValue} } /// Returns true if `_Column__` has been explicitly set. - var has_Column__: Bool {return _storage.__Column__ != nil} + var has_Column__: Bool {_storage.__Column__ != nil} /// Clears the value of `_Column__`. Subsequent reads from it will return its default value. mutating func clear_Column__() {_uniqueStorage().__Column__ = nil} var _File__: Int32 { - get {return _storage.__File__ ?? 0} + get {_storage.__File__ ?? 0} set {_uniqueStorage().__File__ = newValue} } /// Returns true if `_File__` has been explicitly set. - var has_File__: Bool {return _storage.__File__ != nil} + var has_File__: Bool {_storage.__File__ != nil} /// Clears the value of `_File__`. Subsequent reads from it will return its default value. mutating func clear_File__() {_uniqueStorage().__File__ = nil} var _Function__: Int32 { - get {return _storage.__Function__ ?? 0} + get {_storage.__Function__ ?? 0} set {_uniqueStorage().__Function__ = newValue} } /// Returns true if `_Function__` has been explicitly set. - var has_Function__: Bool {return _storage.__Function__ != nil} + var has_Function__: Bool {_storage.__Function__ != nil} /// Clears the value of `_Function__`. Subsequent reads from it will return its default value. mutating func clear_Function__() {_uniqueStorage().__Function__ = nil} var _Line__: Int32 { - get {return _storage.__Line__ ?? 0} + get {_storage.__Line__ ?? 0} set {_uniqueStorage().__Line__ = newValue} } /// Returns true if `_Line__` has been explicitly set. - var has_Line__: Bool {return _storage.__Line__ != nil} + var has_Line__: Bool {_storage.__Line__ != nil} /// Clears the value of `_Line__`. Subsequent reads from it will return its default value. mutating func clear_Line__() {_uniqueStorage().__Line__ = nil} var ___: Int32 { - get {return _storage.____ ?? 0} + get {_storage.____ ?? 0} set {_uniqueStorage().____ = newValue} } /// Returns true if `___` has been explicitly set. - var has___: Bool {return _storage.____ != nil} + var has___: Bool {_storage.____ != nil} /// Clears the value of `___`. Subsequent reads from it will return its default value. mutating func clear___() {_uniqueStorage().____ = nil} var associativity: Int32 { - get {return _storage._associativity ?? 0} + get {_storage._associativity ?? 0} set {_uniqueStorage()._associativity = newValue} } /// Returns true if `associativity` has been explicitly set. - var hasAssociativity: Bool {return _storage._associativity != nil} + var hasAssociativity: Bool {_storage._associativity != nil} /// Clears the value of `associativity`. Subsequent reads from it will return its default value. mutating func clearAssociativity() {_uniqueStorage()._associativity = nil} var convenience: Int32 { - get {return _storage._convenience ?? 0} + get {_storage._convenience ?? 0} set {_uniqueStorage()._convenience = newValue} } /// Returns true if `convenience` has been explicitly set. - var hasConvenience: Bool {return _storage._convenience != nil} + var hasConvenience: Bool {_storage._convenience != nil} /// Clears the value of `convenience`. Subsequent reads from it will return its default value. mutating func clearConvenience() {_uniqueStorage()._convenience = nil} var dynamic: Int32 { - get {return _storage._dynamic ?? 0} + get {_storage._dynamic ?? 0} set {_uniqueStorage()._dynamic = newValue} } /// Returns true if `dynamic` has been explicitly set. - var hasDynamic: Bool {return _storage._dynamic != nil} + var hasDynamic: Bool {_storage._dynamic != nil} /// Clears the value of `dynamic`. Subsequent reads from it will return its default value. mutating func clearDynamic() {_uniqueStorage()._dynamic = nil} var didSet: Int32 { - get {return _storage._didSet ?? 0} + get {_storage._didSet ?? 0} set {_uniqueStorage()._didSet = newValue} } /// Returns true if `didSet` has been explicitly set. - var hasDidSet: Bool {return _storage._didSet != nil} + var hasDidSet: Bool {_storage._didSet != nil} /// Clears the value of `didSet`. Subsequent reads from it will return its default value. mutating func clearDidSet() {_uniqueStorage()._didSet = nil} var final: Int32 { - get {return _storage._final ?? 0} + get {_storage._final ?? 0} set {_uniqueStorage()._final = newValue} } /// Returns true if `final` has been explicitly set. - var hasFinal: Bool {return _storage._final != nil} + var hasFinal: Bool {_storage._final != nil} /// Clears the value of `final`. Subsequent reads from it will return its default value. mutating func clearFinal() {_uniqueStorage()._final = nil} var get: Int32 { - get {return _storage._get ?? 0} + get {_storage._get ?? 0} set {_uniqueStorage()._get = newValue} } /// Returns true if `get` has been explicitly set. - var hasGet: Bool {return _storage._get != nil} + var hasGet: Bool {_storage._get != nil} /// Clears the value of `get`. Subsequent reads from it will return its default value. mutating func clearGet() {_uniqueStorage()._get = nil} var infix: Int32 { - get {return _storage._infix ?? 0} + get {_storage._infix ?? 0} set {_uniqueStorage()._infix = newValue} } /// Returns true if `infix` has been explicitly set. - var hasInfix: Bool {return _storage._infix != nil} + var hasInfix: Bool {_storage._infix != nil} /// Clears the value of `infix`. Subsequent reads from it will return its default value. mutating func clearInfix() {_uniqueStorage()._infix = nil} var indirect: Int32 { - get {return _storage._indirect ?? 0} + get {_storage._indirect ?? 0} set {_uniqueStorage()._indirect = newValue} } /// Returns true if `indirect` has been explicitly set. - var hasIndirect: Bool {return _storage._indirect != nil} + var hasIndirect: Bool {_storage._indirect != nil} /// Clears the value of `indirect`. Subsequent reads from it will return its default value. mutating func clearIndirect() {_uniqueStorage()._indirect = nil} var lazy: Int32 { - get {return _storage._lazy ?? 0} + get {_storage._lazy ?? 0} set {_uniqueStorage()._lazy = newValue} } /// Returns true if `lazy` has been explicitly set. - var hasLazy: Bool {return _storage._lazy != nil} + var hasLazy: Bool {_storage._lazy != nil} /// Clears the value of `lazy`. Subsequent reads from it will return its default value. mutating func clearLazy() {_uniqueStorage()._lazy = nil} var left: Int32 { - get {return _storage._left ?? 0} + get {_storage._left ?? 0} set {_uniqueStorage()._left = newValue} } /// Returns true if `left` has been explicitly set. - var hasLeft: Bool {return _storage._left != nil} + var hasLeft: Bool {_storage._left != nil} /// Clears the value of `left`. Subsequent reads from it will return its default value. mutating func clearLeft() {_uniqueStorage()._left = nil} var mutating: Int32 { - get {return _storage._mutating ?? 0} + get {_storage._mutating ?? 0} set {_uniqueStorage()._mutating = newValue} } /// Returns true if `mutating` has been explicitly set. - var hasMutating: Bool {return _storage._mutating != nil} + var hasMutating: Bool {_storage._mutating != nil} /// Clears the value of `mutating`. Subsequent reads from it will return its default value. mutating func clearMutating() {_uniqueStorage()._mutating = nil} var none: Int32 { - get {return _storage._none ?? 0} + get {_storage._none ?? 0} set {_uniqueStorage()._none = newValue} } /// Returns true if `none` has been explicitly set. - var hasNone: Bool {return _storage._none != nil} + var hasNone: Bool {_storage._none != nil} /// Clears the value of `none`. Subsequent reads from it will return its default value. mutating func clearNone() {_uniqueStorage()._none = nil} var nonmutating: Int32 { - get {return _storage._nonmutating ?? 0} + get {_storage._nonmutating ?? 0} set {_uniqueStorage()._nonmutating = newValue} } /// Returns true if `nonmutating` has been explicitly set. - var hasNonmutating: Bool {return _storage._nonmutating != nil} + var hasNonmutating: Bool {_storage._nonmutating != nil} /// Clears the value of `nonmutating`. Subsequent reads from it will return its default value. mutating func clearNonmutating() {_uniqueStorage()._nonmutating = nil} var optional: Int32 { - get {return _storage._optional ?? 0} + get {_storage._optional ?? 0} set {_uniqueStorage()._optional = newValue} } /// Returns true if `optional` has been explicitly set. - var hasOptional: Bool {return _storage._optional != nil} + var hasOptional: Bool {_storage._optional != nil} /// Clears the value of `optional`. Subsequent reads from it will return its default value. mutating func clearOptional() {_uniqueStorage()._optional = nil} var override: Int32 { - get {return _storage._override ?? 0} + get {_storage._override ?? 0} set {_uniqueStorage()._override = newValue} } /// Returns true if `override` has been explicitly set. - var hasOverride: Bool {return _storage._override != nil} + var hasOverride: Bool {_storage._override != nil} /// Clears the value of `override`. Subsequent reads from it will return its default value. mutating func clearOverride() {_uniqueStorage()._override = nil} var postfix: Int32 { - get {return _storage._postfix ?? 0} + get {_storage._postfix ?? 0} set {_uniqueStorage()._postfix = newValue} } /// Returns true if `postfix` has been explicitly set. - var hasPostfix: Bool {return _storage._postfix != nil} + var hasPostfix: Bool {_storage._postfix != nil} /// Clears the value of `postfix`. Subsequent reads from it will return its default value. mutating func clearPostfix() {_uniqueStorage()._postfix = nil} var precedence: Int32 { - get {return _storage._precedence ?? 0} + get {_storage._precedence ?? 0} set {_uniqueStorage()._precedence = newValue} } /// Returns true if `precedence` has been explicitly set. - var hasPrecedence: Bool {return _storage._precedence != nil} + var hasPrecedence: Bool {_storage._precedence != nil} /// Clears the value of `precedence`. Subsequent reads from it will return its default value. mutating func clearPrecedence() {_uniqueStorage()._precedence = nil} var prefix: Int32 { - get {return _storage._prefix ?? 0} + get {_storage._prefix ?? 0} set {_uniqueStorage()._prefix = newValue} } /// Returns true if `prefix` has been explicitly set. - var hasPrefix: Bool {return _storage._prefix != nil} + var hasPrefix: Bool {_storage._prefix != nil} /// Clears the value of `prefix`. Subsequent reads from it will return its default value. mutating func clearPrefix() {_uniqueStorage()._prefix = nil} var required: Int32 { - get {return _storage._required ?? 0} + get {_storage._required ?? 0} set {_uniqueStorage()._required = newValue} } /// Returns true if `required` has been explicitly set. - var hasRequired: Bool {return _storage._required != nil} + var hasRequired: Bool {_storage._required != nil} /// Clears the value of `required`. Subsequent reads from it will return its default value. mutating func clearRequired() {_uniqueStorage()._required = nil} var right: Int32 { - get {return _storage._right ?? 0} + get {_storage._right ?? 0} set {_uniqueStorage()._right = newValue} } /// Returns true if `right` has been explicitly set. - var hasRight: Bool {return _storage._right != nil} + var hasRight: Bool {_storage._right != nil} /// Clears the value of `right`. Subsequent reads from it will return its default value. mutating func clearRight() {_uniqueStorage()._right = nil} var set: Int32 { - get {return _storage._set ?? 0} + get {_storage._set ?? 0} set {_uniqueStorage()._set = newValue} } /// Returns true if `set` has been explicitly set. - var hasSet: Bool {return _storage._set != nil} + var hasSet: Bool {_storage._set != nil} /// Clears the value of `set`. Subsequent reads from it will return its default value. mutating func clearSet() {_uniqueStorage()._set = nil} var type: Int32 { - get {return _storage._type ?? 0} + get {_storage._type ?? 0} set {_uniqueStorage()._type = newValue} } /// Returns true if `type` has been explicitly set. - var hasType: Bool {return _storage._type != nil} + var hasType: Bool {_storage._type != nil} /// Clears the value of `type`. Subsequent reads from it will return its default value. mutating func clearType() {_uniqueStorage()._type = nil} var unowned: Int32 { - get {return _storage._unowned ?? 0} + get {_storage._unowned ?? 0} set {_uniqueStorage()._unowned = newValue} } /// Returns true if `unowned` has been explicitly set. - var hasUnowned: Bool {return _storage._unowned != nil} + var hasUnowned: Bool {_storage._unowned != nil} /// Clears the value of `unowned`. Subsequent reads from it will return its default value. mutating func clearUnowned() {_uniqueStorage()._unowned = nil} var weak: Int32 { - get {return _storage._weak ?? 0} + get {_storage._weak ?? 0} set {_uniqueStorage()._weak = newValue} } /// Returns true if `weak` has been explicitly set. - var hasWeak: Bool {return _storage._weak != nil} + var hasWeak: Bool {_storage._weak != nil} /// Clears the value of `weak`. Subsequent reads from it will return its default value. mutating func clearWeak() {_uniqueStorage()._weak = nil} var willSet: Int32 { - get {return _storage._willSet ?? 0} + get {_storage._willSet ?? 0} set {_uniqueStorage()._willSet = newValue} } /// Returns true if `willSet` has been explicitly set. - var hasWillSet: Bool {return _storage._willSet != nil} + var hasWillSet: Bool {_storage._willSet != nil} /// Clears the value of `willSet`. Subsequent reads from it will return its default value. mutating func clearWillSet() {_uniqueStorage()._willSet = nil} var id: Int32 { - get {return _storage._id ?? 0} + get {_storage._id ?? 0} set {_uniqueStorage()._id = newValue} } /// Returns true if `id` has been explicitly set. - var hasID: Bool {return _storage._id != nil} + var hasID: Bool {_storage._id != nil} /// Clears the value of `id`. Subsequent reads from it will return its default value. mutating func clearID() {_uniqueStorage()._id = nil} var cmd: Int32 { - get {return _storage._cmd ?? 0} + get {_storage._cmd ?? 0} set {_uniqueStorage()._cmd = newValue} } /// Returns true if `cmd` has been explicitly set. - var hasCmd: Bool {return _storage._cmd != nil} + var hasCmd: Bool {_storage._cmd != nil} /// Clears the value of `cmd`. Subsequent reads from it will return its default value. mutating func clearCmd() {_uniqueStorage()._cmd = nil} var out: Int32 { - get {return _storage._out ?? 0} + get {_storage._out ?? 0} set {_uniqueStorage()._out = newValue} } /// Returns true if `out` has been explicitly set. - var hasOut: Bool {return _storage._out != nil} + var hasOut: Bool {_storage._out != nil} /// Clears the value of `out`. Subsequent reads from it will return its default value. mutating func clearOut() {_uniqueStorage()._out = nil} var bycopy: Int32 { - get {return _storage._bycopy ?? 0} + get {_storage._bycopy ?? 0} set {_uniqueStorage()._bycopy = newValue} } /// Returns true if `bycopy` has been explicitly set. - var hasBycopy: Bool {return _storage._bycopy != nil} + var hasBycopy: Bool {_storage._bycopy != nil} /// Clears the value of `bycopy`. Subsequent reads from it will return its default value. mutating func clearBycopy() {_uniqueStorage()._bycopy = nil} var byref: Int32 { - get {return _storage._byref ?? 0} + get {_storage._byref ?? 0} set {_uniqueStorage()._byref = newValue} } /// Returns true if `byref` has been explicitly set. - var hasByref: Bool {return _storage._byref != nil} + var hasByref: Bool {_storage._byref != nil} /// Clears the value of `byref`. Subsequent reads from it will return its default value. mutating func clearByref() {_uniqueStorage()._byref = nil} var oneway: Int32 { - get {return _storage._oneway ?? 0} + get {_storage._oneway ?? 0} set {_uniqueStorage()._oneway = newValue} } /// Returns true if `oneway` has been explicitly set. - var hasOneway: Bool {return _storage._oneway != nil} + var hasOneway: Bool {_storage._oneway != nil} /// Clears the value of `oneway`. Subsequent reads from it will return its default value. mutating func clearOneway() {_uniqueStorage()._oneway = nil} var and: Int32 { - get {return _storage._and ?? 0} + get {_storage._and ?? 0} set {_uniqueStorage()._and = newValue} } /// Returns true if `and` has been explicitly set. - var hasAnd: Bool {return _storage._and != nil} + var hasAnd: Bool {_storage._and != nil} /// Clears the value of `and`. Subsequent reads from it will return its default value. mutating func clearAnd() {_uniqueStorage()._and = nil} var andEq: Int32 { - get {return _storage._andEq ?? 0} + get {_storage._andEq ?? 0} set {_uniqueStorage()._andEq = newValue} } /// Returns true if `andEq` has been explicitly set. - var hasAndEq: Bool {return _storage._andEq != nil} + var hasAndEq: Bool {_storage._andEq != nil} /// Clears the value of `andEq`. Subsequent reads from it will return its default value. mutating func clearAndEq() {_uniqueStorage()._andEq = nil} var alignas: Int32 { - get {return _storage._alignas ?? 0} + get {_storage._alignas ?? 0} set {_uniqueStorage()._alignas = newValue} } /// Returns true if `alignas` has been explicitly set. - var hasAlignas: Bool {return _storage._alignas != nil} + var hasAlignas: Bool {_storage._alignas != nil} /// Clears the value of `alignas`. Subsequent reads from it will return its default value. mutating func clearAlignas() {_uniqueStorage()._alignas = nil} var alignof: Int32 { - get {return _storage._alignof ?? 0} + get {_storage._alignof ?? 0} set {_uniqueStorage()._alignof = newValue} } /// Returns true if `alignof` has been explicitly set. - var hasAlignof: Bool {return _storage._alignof != nil} + var hasAlignof: Bool {_storage._alignof != nil} /// Clears the value of `alignof`. Subsequent reads from it will return its default value. mutating func clearAlignof() {_uniqueStorage()._alignof = nil} var asm: Int32 { - get {return _storage._asm ?? 0} + get {_storage._asm ?? 0} set {_uniqueStorage()._asm = newValue} } /// Returns true if `asm` has been explicitly set. - var hasAsm: Bool {return _storage._asm != nil} + var hasAsm: Bool {_storage._asm != nil} /// Clears the value of `asm`. Subsequent reads from it will return its default value. mutating func clearAsm() {_uniqueStorage()._asm = nil} var auto: Int32 { - get {return _storage._auto ?? 0} + get {_storage._auto ?? 0} set {_uniqueStorage()._auto = newValue} } /// Returns true if `auto` has been explicitly set. - var hasAuto: Bool {return _storage._auto != nil} + var hasAuto: Bool {_storage._auto != nil} /// Clears the value of `auto`. Subsequent reads from it will return its default value. mutating func clearAuto() {_uniqueStorage()._auto = nil} var bitand: Int32 { - get {return _storage._bitand ?? 0} + get {_storage._bitand ?? 0} set {_uniqueStorage()._bitand = newValue} } /// Returns true if `bitand` has been explicitly set. - var hasBitand: Bool {return _storage._bitand != nil} + var hasBitand: Bool {_storage._bitand != nil} /// Clears the value of `bitand`. Subsequent reads from it will return its default value. mutating func clearBitand() {_uniqueStorage()._bitand = nil} var bitor: Int32 { - get {return _storage._bitor ?? 0} + get {_storage._bitor ?? 0} set {_uniqueStorage()._bitor = newValue} } /// Returns true if `bitor` has been explicitly set. - var hasBitor: Bool {return _storage._bitor != nil} + var hasBitor: Bool {_storage._bitor != nil} /// Clears the value of `bitor`. Subsequent reads from it will return its default value. mutating func clearBitor() {_uniqueStorage()._bitor = nil} var bool: Int32 { - get {return _storage._bool ?? 0} + get {_storage._bool ?? 0} set {_uniqueStorage()._bool = newValue} } /// Returns true if `bool` has been explicitly set. - var hasBool: Bool {return _storage._bool != nil} + var hasBool: Bool {_storage._bool != nil} /// Clears the value of `bool`. Subsequent reads from it will return its default value. mutating func clearBool() {_uniqueStorage()._bool = nil} var char: Int32 { - get {return _storage._char ?? 0} + get {_storage._char ?? 0} set {_uniqueStorage()._char = newValue} } /// Returns true if `char` has been explicitly set. - var hasChar: Bool {return _storage._char != nil} + var hasChar: Bool {_storage._char != nil} /// Clears the value of `char`. Subsequent reads from it will return its default value. mutating func clearChar() {_uniqueStorage()._char = nil} var char16T: Int32 { - get {return _storage._char16T ?? 0} + get {_storage._char16T ?? 0} set {_uniqueStorage()._char16T = newValue} } /// Returns true if `char16T` has been explicitly set. - var hasChar16T: Bool {return _storage._char16T != nil} + var hasChar16T: Bool {_storage._char16T != nil} /// Clears the value of `char16T`. Subsequent reads from it will return its default value. mutating func clearChar16T() {_uniqueStorage()._char16T = nil} var char32T: Int32 { - get {return _storage._char32T ?? 0} + get {_storage._char32T ?? 0} set {_uniqueStorage()._char32T = newValue} } /// Returns true if `char32T` has been explicitly set. - var hasChar32T: Bool {return _storage._char32T != nil} + var hasChar32T: Bool {_storage._char32T != nil} /// Clears the value of `char32T`. Subsequent reads from it will return its default value. mutating func clearChar32T() {_uniqueStorage()._char32T = nil} var compl: Int32 { - get {return _storage._compl ?? 0} + get {_storage._compl ?? 0} set {_uniqueStorage()._compl = newValue} } /// Returns true if `compl` has been explicitly set. - var hasCompl: Bool {return _storage._compl != nil} + var hasCompl: Bool {_storage._compl != nil} /// Clears the value of `compl`. Subsequent reads from it will return its default value. mutating func clearCompl() {_uniqueStorage()._compl = nil} var const: Int32 { - get {return _storage._const ?? 0} + get {_storage._const ?? 0} set {_uniqueStorage()._const = newValue} } /// Returns true if `const` has been explicitly set. - var hasConst: Bool {return _storage._const != nil} + var hasConst: Bool {_storage._const != nil} /// Clears the value of `const`. Subsequent reads from it will return its default value. mutating func clearConst() {_uniqueStorage()._const = nil} var constexpr: Int32 { - get {return _storage._constexpr ?? 0} + get {_storage._constexpr ?? 0} set {_uniqueStorage()._constexpr = newValue} } /// Returns true if `constexpr` has been explicitly set. - var hasConstexpr: Bool {return _storage._constexpr != nil} + var hasConstexpr: Bool {_storage._constexpr != nil} /// Clears the value of `constexpr`. Subsequent reads from it will return its default value. mutating func clearConstexpr() {_uniqueStorage()._constexpr = nil} var constCast: Int32 { - get {return _storage._constCast ?? 0} + get {_storage._constCast ?? 0} set {_uniqueStorage()._constCast = newValue} } /// Returns true if `constCast` has been explicitly set. - var hasConstCast: Bool {return _storage._constCast != nil} + var hasConstCast: Bool {_storage._constCast != nil} /// Clears the value of `constCast`. Subsequent reads from it will return its default value. mutating func clearConstCast() {_uniqueStorage()._constCast = nil} var decltype: Int32 { - get {return _storage._decltype ?? 0} + get {_storage._decltype ?? 0} set {_uniqueStorage()._decltype = newValue} } /// Returns true if `decltype` has been explicitly set. - var hasDecltype: Bool {return _storage._decltype != nil} + var hasDecltype: Bool {_storage._decltype != nil} /// Clears the value of `decltype`. Subsequent reads from it will return its default value. mutating func clearDecltype() {_uniqueStorage()._decltype = nil} var delete: Int32 { - get {return _storage._delete ?? 0} + get {_storage._delete ?? 0} set {_uniqueStorage()._delete = newValue} } /// Returns true if `delete` has been explicitly set. - var hasDelete: Bool {return _storage._delete != nil} + var hasDelete: Bool {_storage._delete != nil} /// Clears the value of `delete`. Subsequent reads from it will return its default value. mutating func clearDelete() {_uniqueStorage()._delete = nil} var dynamicCast: Int32 { - get {return _storage._dynamicCast ?? 0} + get {_storage._dynamicCast ?? 0} set {_uniqueStorage()._dynamicCast = newValue} } /// Returns true if `dynamicCast` has been explicitly set. - var hasDynamicCast: Bool {return _storage._dynamicCast != nil} + var hasDynamicCast: Bool {_storage._dynamicCast != nil} /// Clears the value of `dynamicCast`. Subsequent reads from it will return its default value. mutating func clearDynamicCast() {_uniqueStorage()._dynamicCast = nil} var explicit: Int32 { - get {return _storage._explicit ?? 0} + get {_storage._explicit ?? 0} set {_uniqueStorage()._explicit = newValue} } /// Returns true if `explicit` has been explicitly set. - var hasExplicit: Bool {return _storage._explicit != nil} + var hasExplicit: Bool {_storage._explicit != nil} /// Clears the value of `explicit`. Subsequent reads from it will return its default value. mutating func clearExplicit() {_uniqueStorage()._explicit = nil} var export: Int32 { - get {return _storage._export ?? 0} + get {_storage._export ?? 0} set {_uniqueStorage()._export = newValue} } /// Returns true if `export` has been explicitly set. - var hasExport: Bool {return _storage._export != nil} + var hasExport: Bool {_storage._export != nil} /// Clears the value of `export`. Subsequent reads from it will return its default value. mutating func clearExport() {_uniqueStorage()._export = nil} var extern: Int32 { - get {return _storage._extern ?? 0} + get {_storage._extern ?? 0} set {_uniqueStorage()._extern = newValue} } /// Returns true if `extern` has been explicitly set. - var hasExtern: Bool {return _storage._extern != nil} + var hasExtern: Bool {_storage._extern != nil} /// Clears the value of `extern`. Subsequent reads from it will return its default value. mutating func clearExtern() {_uniqueStorage()._extern = nil} var friend: Int32 { - get {return _storage._friend ?? 0} + get {_storage._friend ?? 0} set {_uniqueStorage()._friend = newValue} } /// Returns true if `friend` has been explicitly set. - var hasFriend: Bool {return _storage._friend != nil} + var hasFriend: Bool {_storage._friend != nil} /// Clears the value of `friend`. Subsequent reads from it will return its default value. mutating func clearFriend() {_uniqueStorage()._friend = nil} var goto: Int32 { - get {return _storage._goto ?? 0} + get {_storage._goto ?? 0} set {_uniqueStorage()._goto = newValue} } /// Returns true if `goto` has been explicitly set. - var hasGoto: Bool {return _storage._goto != nil} + var hasGoto: Bool {_storage._goto != nil} /// Clears the value of `goto`. Subsequent reads from it will return its default value. mutating func clearGoto() {_uniqueStorage()._goto = nil} var inline: Int32 { - get {return _storage._inline ?? 0} + get {_storage._inline ?? 0} set {_uniqueStorage()._inline = newValue} } /// Returns true if `inline` has been explicitly set. - var hasInline: Bool {return _storage._inline != nil} + var hasInline: Bool {_storage._inline != nil} /// Clears the value of `inline`. Subsequent reads from it will return its default value. mutating func clearInline() {_uniqueStorage()._inline = nil} var long: Int32 { - get {return _storage._long ?? 0} + get {_storage._long ?? 0} set {_uniqueStorage()._long = newValue} } /// Returns true if `long` has been explicitly set. - var hasLong: Bool {return _storage._long != nil} + var hasLong: Bool {_storage._long != nil} /// Clears the value of `long`. Subsequent reads from it will return its default value. mutating func clearLong() {_uniqueStorage()._long = nil} var mutable: Int32 { - get {return _storage._mutable ?? 0} + get {_storage._mutable ?? 0} set {_uniqueStorage()._mutable = newValue} } /// Returns true if `mutable` has been explicitly set. - var hasMutable: Bool {return _storage._mutable != nil} + var hasMutable: Bool {_storage._mutable != nil} /// Clears the value of `mutable`. Subsequent reads from it will return its default value. mutating func clearMutable() {_uniqueStorage()._mutable = nil} var namespace: Int32 { - get {return _storage._namespace ?? 0} + get {_storage._namespace ?? 0} set {_uniqueStorage()._namespace = newValue} } /// Returns true if `namespace` has been explicitly set. - var hasNamespace: Bool {return _storage._namespace != nil} + var hasNamespace: Bool {_storage._namespace != nil} /// Clears the value of `namespace`. Subsequent reads from it will return its default value. mutating func clearNamespace() {_uniqueStorage()._namespace = nil} var new: Int32 { - get {return _storage._new ?? 0} + get {_storage._new ?? 0} set {_uniqueStorage()._new = newValue} } /// Returns true if `new` has been explicitly set. - var hasNew: Bool {return _storage._new != nil} + var hasNew: Bool {_storage._new != nil} /// Clears the value of `new`. Subsequent reads from it will return its default value. mutating func clearNew() {_uniqueStorage()._new = nil} var noexcept: Int32 { - get {return _storage._noexcept ?? 0} + get {_storage._noexcept ?? 0} set {_uniqueStorage()._noexcept = newValue} } /// Returns true if `noexcept` has been explicitly set. - var hasNoexcept: Bool {return _storage._noexcept != nil} + var hasNoexcept: Bool {_storage._noexcept != nil} /// Clears the value of `noexcept`. Subsequent reads from it will return its default value. mutating func clearNoexcept() {_uniqueStorage()._noexcept = nil} var not: Int32 { - get {return _storage._not ?? 0} + get {_storage._not ?? 0} set {_uniqueStorage()._not = newValue} } /// Returns true if `not` has been explicitly set. - var hasNot: Bool {return _storage._not != nil} + var hasNot: Bool {_storage._not != nil} /// Clears the value of `not`. Subsequent reads from it will return its default value. mutating func clearNot() {_uniqueStorage()._not = nil} var notEq: Int32 { - get {return _storage._notEq ?? 0} + get {_storage._notEq ?? 0} set {_uniqueStorage()._notEq = newValue} } /// Returns true if `notEq` has been explicitly set. - var hasNotEq: Bool {return _storage._notEq != nil} + var hasNotEq: Bool {_storage._notEq != nil} /// Clears the value of `notEq`. Subsequent reads from it will return its default value. mutating func clearNotEq() {_uniqueStorage()._notEq = nil} var nullptr: Int32 { - get {return _storage._nullptr ?? 0} + get {_storage._nullptr ?? 0} set {_uniqueStorage()._nullptr = newValue} } /// Returns true if `nullptr` has been explicitly set. - var hasNullptr: Bool {return _storage._nullptr != nil} + var hasNullptr: Bool {_storage._nullptr != nil} /// Clears the value of `nullptr`. Subsequent reads from it will return its default value. mutating func clearNullptr() {_uniqueStorage()._nullptr = nil} var or: Int32 { - get {return _storage._or ?? 0} + get {_storage._or ?? 0} set {_uniqueStorage()._or = newValue} } /// Returns true if `or` has been explicitly set. - var hasOr: Bool {return _storage._or != nil} + var hasOr: Bool {_storage._or != nil} /// Clears the value of `or`. Subsequent reads from it will return its default value. mutating func clearOr() {_uniqueStorage()._or = nil} var orEq: Int32 { - get {return _storage._orEq ?? 0} + get {_storage._orEq ?? 0} set {_uniqueStorage()._orEq = newValue} } /// Returns true if `orEq` has been explicitly set. - var hasOrEq: Bool {return _storage._orEq != nil} + var hasOrEq: Bool {_storage._orEq != nil} /// Clears the value of `orEq`. Subsequent reads from it will return its default value. mutating func clearOrEq() {_uniqueStorage()._orEq = nil} var protected: Int32 { - get {return _storage._protected ?? 0} + get {_storage._protected ?? 0} set {_uniqueStorage()._protected = newValue} } /// Returns true if `protected` has been explicitly set. - var hasProtected: Bool {return _storage._protected != nil} + var hasProtected: Bool {_storage._protected != nil} /// Clears the value of `protected`. Subsequent reads from it will return its default value. mutating func clearProtected() {_uniqueStorage()._protected = nil} var register: Int32 { - get {return _storage._register ?? 0} + get {_storage._register ?? 0} set {_uniqueStorage()._register = newValue} } /// Returns true if `register` has been explicitly set. - var hasRegister: Bool {return _storage._register != nil} + var hasRegister: Bool {_storage._register != nil} /// Clears the value of `register`. Subsequent reads from it will return its default value. mutating func clearRegister() {_uniqueStorage()._register = nil} var reinterpretCast: Int32 { - get {return _storage._reinterpretCast ?? 0} + get {_storage._reinterpretCast ?? 0} set {_uniqueStorage()._reinterpretCast = newValue} } /// Returns true if `reinterpretCast` has been explicitly set. - var hasReinterpretCast: Bool {return _storage._reinterpretCast != nil} + var hasReinterpretCast: Bool {_storage._reinterpretCast != nil} /// Clears the value of `reinterpretCast`. Subsequent reads from it will return its default value. mutating func clearReinterpretCast() {_uniqueStorage()._reinterpretCast = nil} var short: Int32 { - get {return _storage._short ?? 0} + get {_storage._short ?? 0} set {_uniqueStorage()._short = newValue} } /// Returns true if `short` has been explicitly set. - var hasShort: Bool {return _storage._short != nil} + var hasShort: Bool {_storage._short != nil} /// Clears the value of `short`. Subsequent reads from it will return its default value. mutating func clearShort() {_uniqueStorage()._short = nil} var signed: Int32 { - get {return _storage._signed ?? 0} + get {_storage._signed ?? 0} set {_uniqueStorage()._signed = newValue} } /// Returns true if `signed` has been explicitly set. - var hasSigned: Bool {return _storage._signed != nil} + var hasSigned: Bool {_storage._signed != nil} /// Clears the value of `signed`. Subsequent reads from it will return its default value. mutating func clearSigned() {_uniqueStorage()._signed = nil} var sizeof: Int32 { - get {return _storage._sizeof ?? 0} + get {_storage._sizeof ?? 0} set {_uniqueStorage()._sizeof = newValue} } /// Returns true if `sizeof` has been explicitly set. - var hasSizeof: Bool {return _storage._sizeof != nil} + var hasSizeof: Bool {_storage._sizeof != nil} /// Clears the value of `sizeof`. Subsequent reads from it will return its default value. mutating func clearSizeof() {_uniqueStorage()._sizeof = nil} var staticAssert: Int32 { - get {return _storage._staticAssert ?? 0} + get {_storage._staticAssert ?? 0} set {_uniqueStorage()._staticAssert = newValue} } /// Returns true if `staticAssert` has been explicitly set. - var hasStaticAssert: Bool {return _storage._staticAssert != nil} + var hasStaticAssert: Bool {_storage._staticAssert != nil} /// Clears the value of `staticAssert`. Subsequent reads from it will return its default value. mutating func clearStaticAssert() {_uniqueStorage()._staticAssert = nil} var staticCast: Int32 { - get {return _storage._staticCast ?? 0} + get {_storage._staticCast ?? 0} set {_uniqueStorage()._staticCast = newValue} } /// Returns true if `staticCast` has been explicitly set. - var hasStaticCast: Bool {return _storage._staticCast != nil} + var hasStaticCast: Bool {_storage._staticCast != nil} /// Clears the value of `staticCast`. Subsequent reads from it will return its default value. mutating func clearStaticCast() {_uniqueStorage()._staticCast = nil} var template: Int32 { - get {return _storage._template ?? 0} + get {_storage._template ?? 0} set {_uniqueStorage()._template = newValue} } /// Returns true if `template` has been explicitly set. - var hasTemplate: Bool {return _storage._template != nil} + var hasTemplate: Bool {_storage._template != nil} /// Clears the value of `template`. Subsequent reads from it will return its default value. mutating func clearTemplate() {_uniqueStorage()._template = nil} var this: Int32 { - get {return _storage._this ?? 0} + get {_storage._this ?? 0} set {_uniqueStorage()._this = newValue} } /// Returns true if `this` has been explicitly set. - var hasThis: Bool {return _storage._this != nil} + var hasThis: Bool {_storage._this != nil} /// Clears the value of `this`. Subsequent reads from it will return its default value. mutating func clearThis() {_uniqueStorage()._this = nil} var threadLocal: Int32 { - get {return _storage._threadLocal ?? 0} + get {_storage._threadLocal ?? 0} set {_uniqueStorage()._threadLocal = newValue} } /// Returns true if `threadLocal` has been explicitly set. - var hasThreadLocal: Bool {return _storage._threadLocal != nil} + var hasThreadLocal: Bool {_storage._threadLocal != nil} /// Clears the value of `threadLocal`. Subsequent reads from it will return its default value. mutating func clearThreadLocal() {_uniqueStorage()._threadLocal = nil} var typedef: Int32 { - get {return _storage._typedef ?? 0} + get {_storage._typedef ?? 0} set {_uniqueStorage()._typedef = newValue} } /// Returns true if `typedef` has been explicitly set. - var hasTypedef: Bool {return _storage._typedef != nil} + var hasTypedef: Bool {_storage._typedef != nil} /// Clears the value of `typedef`. Subsequent reads from it will return its default value. mutating func clearTypedef() {_uniqueStorage()._typedef = nil} var typeid: Int32 { - get {return _storage._typeid ?? 0} + get {_storage._typeid ?? 0} set {_uniqueStorage()._typeid = newValue} } /// Returns true if `typeid` has been explicitly set. - var hasTypeid: Bool {return _storage._typeid != nil} + var hasTypeid: Bool {_storage._typeid != nil} /// Clears the value of `typeid`. Subsequent reads from it will return its default value. mutating func clearTypeid() {_uniqueStorage()._typeid = nil} var typename: Int32 { - get {return _storage._typename ?? 0} + get {_storage._typename ?? 0} set {_uniqueStorage()._typename = newValue} } /// Returns true if `typename` has been explicitly set. - var hasTypename: Bool {return _storage._typename != nil} + var hasTypename: Bool {_storage._typename != nil} /// Clears the value of `typename`. Subsequent reads from it will return its default value. mutating func clearTypename() {_uniqueStorage()._typename = nil} var union: Int32 { - get {return _storage._union ?? 0} + get {_storage._union ?? 0} set {_uniqueStorage()._union = newValue} } /// Returns true if `union` has been explicitly set. - var hasUnion: Bool {return _storage._union != nil} + var hasUnion: Bool {_storage._union != nil} /// Clears the value of `union`. Subsequent reads from it will return its default value. mutating func clearUnion() {_uniqueStorage()._union = nil} var unsigned: Int32 { - get {return _storage._unsigned ?? 0} + get {_storage._unsigned ?? 0} set {_uniqueStorage()._unsigned = newValue} } /// Returns true if `unsigned` has been explicitly set. - var hasUnsigned: Bool {return _storage._unsigned != nil} + var hasUnsigned: Bool {_storage._unsigned != nil} /// Clears the value of `unsigned`. Subsequent reads from it will return its default value. mutating func clearUnsigned() {_uniqueStorage()._unsigned = nil} var using: Int32 { - get {return _storage._using ?? 0} + get {_storage._using ?? 0} set {_uniqueStorage()._using = newValue} } /// Returns true if `using` has been explicitly set. - var hasUsing: Bool {return _storage._using != nil} + var hasUsing: Bool {_storage._using != nil} /// Clears the value of `using`. Subsequent reads from it will return its default value. mutating func clearUsing() {_uniqueStorage()._using = nil} var virtual: Int32 { - get {return _storage._virtual ?? 0} + get {_storage._virtual ?? 0} set {_uniqueStorage()._virtual = newValue} } /// Returns true if `virtual` has been explicitly set. - var hasVirtual: Bool {return _storage._virtual != nil} + var hasVirtual: Bool {_storage._virtual != nil} /// Clears the value of `virtual`. Subsequent reads from it will return its default value. mutating func clearVirtual() {_uniqueStorage()._virtual = nil} var void: Int32 { - get {return _storage._void ?? 0} + get {_storage._void ?? 0} set {_uniqueStorage()._void = newValue} } /// Returns true if `void` has been explicitly set. - var hasVoid: Bool {return _storage._void != nil} + var hasVoid: Bool {_storage._void != nil} /// Clears the value of `void`. Subsequent reads from it will return its default value. mutating func clearVoid() {_uniqueStorage()._void = nil} var volatile: Int32 { - get {return _storage._volatile ?? 0} + get {_storage._volatile ?? 0} set {_uniqueStorage()._volatile = newValue} } /// Returns true if `volatile` has been explicitly set. - var hasVolatile: Bool {return _storage._volatile != nil} + var hasVolatile: Bool {_storage._volatile != nil} /// Clears the value of `volatile`. Subsequent reads from it will return its default value. mutating func clearVolatile() {_uniqueStorage()._volatile = nil} var wcharT: Int32 { - get {return _storage._wcharT ?? 0} + get {_storage._wcharT ?? 0} set {_uniqueStorage()._wcharT = newValue} } /// Returns true if `wcharT` has been explicitly set. - var hasWcharT: Bool {return _storage._wcharT != nil} + var hasWcharT: Bool {_storage._wcharT != nil} /// Clears the value of `wcharT`. Subsequent reads from it will return its default value. mutating func clearWcharT() {_uniqueStorage()._wcharT = nil} var xor: Int32 { - get {return _storage._xor ?? 0} + get {_storage._xor ?? 0} set {_uniqueStorage()._xor = newValue} } /// Returns true if `xor` has been explicitly set. - var hasXor: Bool {return _storage._xor != nil} + var hasXor: Bool {_storage._xor != nil} /// Clears the value of `xor`. Subsequent reads from it will return its default value. mutating func clearXor() {_uniqueStorage()._xor = nil} var xorEq: Int32 { - get {return _storage._xorEq ?? 0} + get {_storage._xorEq ?? 0} set {_uniqueStorage()._xorEq = newValue} } /// Returns true if `xorEq` has been explicitly set. - var hasXorEq: Bool {return _storage._xorEq != nil} + var hasXorEq: Bool {_storage._xorEq != nil} /// Clears the value of `xorEq`. Subsequent reads from it will return its default value. mutating func clearXorEq() {_uniqueStorage()._xorEq = nil} var restrict: Int32 { - get {return _storage._restrict ?? 0} + get {_storage._restrict ?? 0} set {_uniqueStorage()._restrict = newValue} } /// Returns true if `restrict` has been explicitly set. - var hasRestrict: Bool {return _storage._restrict != nil} + var hasRestrict: Bool {_storage._restrict != nil} /// Clears the value of `restrict`. Subsequent reads from it will return its default value. mutating func clearRestrict() {_uniqueStorage()._restrict = nil} var category: Int32 { - get {return _storage._category ?? 0} + get {_storage._category ?? 0} set {_uniqueStorage()._category = newValue} } /// Returns true if `category` has been explicitly set. - var hasCategory: Bool {return _storage._category != nil} + var hasCategory: Bool {_storage._category != nil} /// Clears the value of `category`. Subsequent reads from it will return its default value. mutating func clearCategory() {_uniqueStorage()._category = nil} var ivar: Int32 { - get {return _storage._ivar ?? 0} + get {_storage._ivar ?? 0} set {_uniqueStorage()._ivar = newValue} } /// Returns true if `ivar` has been explicitly set. - var hasIvar: Bool {return _storage._ivar != nil} + var hasIvar: Bool {_storage._ivar != nil} /// Clears the value of `ivar`. Subsequent reads from it will return its default value. mutating func clearIvar() {_uniqueStorage()._ivar = nil} var method: Int32 { - get {return _storage._method ?? 0} + get {_storage._method ?? 0} set {_uniqueStorage()._method = newValue} } /// Returns true if `method` has been explicitly set. - var hasMethod: Bool {return _storage._method != nil} + var hasMethod: Bool {_storage._method != nil} /// Clears the value of `method`. Subsequent reads from it will return its default value. mutating func clearMethod() {_uniqueStorage()._method = nil} var finalize: Int32 { - get {return _storage._finalize ?? 0} + get {_storage._finalize ?? 0} set {_uniqueStorage()._finalize = newValue} } /// Returns true if `finalize` has been explicitly set. - var hasFinalize: Bool {return _storage._finalize != nil} + var hasFinalize: Bool {_storage._finalize != nil} /// Clears the value of `finalize`. Subsequent reads from it will return its default value. mutating func clearFinalize() {_uniqueStorage()._finalize = nil} var hash: Int32 { - get {return _storage._hash ?? 0} + get {_storage._hash ?? 0} set {_uniqueStorage()._hash = newValue} } /// Returns true if `hash` has been explicitly set. - var hasHash: Bool {return _storage._hash != nil} + var hasHash: Bool {_storage._hash != nil} /// Clears the value of `hash`. Subsequent reads from it will return its default value. mutating func clearHash() {_uniqueStorage()._hash = nil} var dealloc: Int32 { - get {return _storage._dealloc ?? 0} + get {_storage._dealloc ?? 0} set {_uniqueStorage()._dealloc = newValue} } /// Returns true if `dealloc` has been explicitly set. - var hasDealloc: Bool {return _storage._dealloc != nil} + var hasDealloc: Bool {_storage._dealloc != nil} /// Clears the value of `dealloc`. Subsequent reads from it will return its default value. mutating func clearDealloc() {_uniqueStorage()._dealloc = nil} var superclass: Int32 { - get {return _storage._superclass ?? 0} + get {_storage._superclass ?? 0} set {_uniqueStorage()._superclass = newValue} } /// Returns true if `superclass` has been explicitly set. - var hasSuperclass: Bool {return _storage._superclass != nil} + var hasSuperclass: Bool {_storage._superclass != nil} /// Clears the value of `superclass`. Subsequent reads from it will return its default value. mutating func clearSuperclass() {_uniqueStorage()._superclass = nil} var retain: Int32 { - get {return _storage._retain ?? 0} + get {_storage._retain ?? 0} set {_uniqueStorage()._retain = newValue} } /// Returns true if `retain` has been explicitly set. - var hasRetain: Bool {return _storage._retain != nil} + var hasRetain: Bool {_storage._retain != nil} /// Clears the value of `retain`. Subsequent reads from it will return its default value. mutating func clearRetain() {_uniqueStorage()._retain = nil} var release: Int32 { - get {return _storage._release ?? 0} + get {_storage._release ?? 0} set {_uniqueStorage()._release = newValue} } /// Returns true if `release` has been explicitly set. - var hasRelease: Bool {return _storage._release != nil} + var hasRelease: Bool {_storage._release != nil} /// Clears the value of `release`. Subsequent reads from it will return its default value. mutating func clearRelease() {_uniqueStorage()._release = nil} var autorelease: Int32 { - get {return _storage._autorelease ?? 0} + get {_storage._autorelease ?? 0} set {_uniqueStorage()._autorelease = newValue} } /// Returns true if `autorelease` has been explicitly set. - var hasAutorelease: Bool {return _storage._autorelease != nil} + var hasAutorelease: Bool {_storage._autorelease != nil} /// Clears the value of `autorelease`. Subsequent reads from it will return its default value. mutating func clearAutorelease() {_uniqueStorage()._autorelease = nil} var retainCount: Int32 { - get {return _storage._retainCount ?? 0} + get {_storage._retainCount ?? 0} set {_uniqueStorage()._retainCount = newValue} } /// Returns true if `retainCount` has been explicitly set. - var hasRetainCount: Bool {return _storage._retainCount != nil} + var hasRetainCount: Bool {_storage._retainCount != nil} /// Clears the value of `retainCount`. Subsequent reads from it will return its default value. mutating func clearRetainCount() {_uniqueStorage()._retainCount = nil} var zone: Int32 { - get {return _storage._zone ?? 0} + get {_storage._zone ?? 0} set {_uniqueStorage()._zone = newValue} } /// Returns true if `zone` has been explicitly set. - var hasZone: Bool {return _storage._zone != nil} + var hasZone: Bool {_storage._zone != nil} /// Clears the value of `zone`. Subsequent reads from it will return its default value. mutating func clearZone() {_uniqueStorage()._zone = nil} var isProxy: Int32 { - get {return _storage._isProxy ?? 0} + get {_storage._isProxy ?? 0} set {_uniqueStorage()._isProxy = newValue} } /// Returns true if `isProxy` has been explicitly set. - var hasIsProxy: Bool {return _storage._isProxy != nil} + var hasIsProxy: Bool {_storage._isProxy != nil} /// Clears the value of `isProxy`. Subsequent reads from it will return its default value. mutating func clearIsProxy() {_uniqueStorage()._isProxy = nil} var copy: Int32 { - get {return _storage._copy ?? 0} + get {_storage._copy ?? 0} set {_uniqueStorage()._copy = newValue} } /// Returns true if `copy` has been explicitly set. - var hasCopy: Bool {return _storage._copy != nil} + var hasCopy: Bool {_storage._copy != nil} /// Clears the value of `copy`. Subsequent reads from it will return its default value. mutating func clearCopy() {_uniqueStorage()._copy = nil} var mutableCopy: Int32 { - get {return _storage._mutableCopy ?? 0} + get {_storage._mutableCopy ?? 0} set {_uniqueStorage()._mutableCopy = newValue} } /// Returns true if `mutableCopy` has been explicitly set. - var hasMutableCopy: Bool {return _storage._mutableCopy != nil} + var hasMutableCopy: Bool {_storage._mutableCopy != nil} /// Clears the value of `mutableCopy`. Subsequent reads from it will return its default value. mutating func clearMutableCopy() {_uniqueStorage()._mutableCopy = nil} var classForCoder: Int32 { - get {return _storage._classForCoder ?? 0} + get {_storage._classForCoder ?? 0} set {_uniqueStorage()._classForCoder = newValue} } /// Returns true if `classForCoder` has been explicitly set. - var hasClassForCoder: Bool {return _storage._classForCoder != nil} + var hasClassForCoder: Bool {_storage._classForCoder != nil} /// Clears the value of `classForCoder`. Subsequent reads from it will return its default value. mutating func clearClassForCoder() {_uniqueStorage()._classForCoder = nil} var clear: Int32 { - get {return _storage._clear ?? 0} + get {_storage._clear ?? 0} set {_uniqueStorage()._clear = newValue} } /// Returns true if `clear` has been explicitly set. - var hasClear: Bool {return _storage._clear != nil} + var hasClear: Bool {_storage._clear != nil} /// Clears the value of `clear`. Subsequent reads from it will return its default value. mutating func clearClear() {_uniqueStorage()._clear = nil} var data: Int32 { - get {return _storage._data ?? 0} + get {_storage._data ?? 0} set {_uniqueStorage()._data = newValue} } /// Returns true if `data` has been explicitly set. - var hasData: Bool {return _storage._data != nil} + var hasData: Bool {_storage._data != nil} /// Clears the value of `data`. Subsequent reads from it will return its default value. mutating func clearData() {_uniqueStorage()._data = nil} var delimitedData: Int32 { - get {return _storage._delimitedData ?? 0} + get {_storage._delimitedData ?? 0} set {_uniqueStorage()._delimitedData = newValue} } /// Returns true if `delimitedData` has been explicitly set. - var hasDelimitedData: Bool {return _storage._delimitedData != nil} + var hasDelimitedData: Bool {_storage._delimitedData != nil} /// Clears the value of `delimitedData`. Subsequent reads from it will return its default value. mutating func clearDelimitedData() {_uniqueStorage()._delimitedData = nil} var descriptor: Int32 { - get {return _storage._descriptor ?? 0} + get {_storage._descriptor ?? 0} set {_uniqueStorage()._descriptor = newValue} } /// Returns true if `descriptor` has been explicitly set. - var hasDescriptor: Bool {return _storage._descriptor != nil} + var hasDescriptor: Bool {_storage._descriptor != nil} /// Clears the value of `descriptor`. Subsequent reads from it will return its default value. mutating func clearDescriptor() {_uniqueStorage()._descriptor = nil} var extensionRegistry: Int32 { - get {return _storage._extensionRegistry ?? 0} + get {_storage._extensionRegistry ?? 0} set {_uniqueStorage()._extensionRegistry = newValue} } /// Returns true if `extensionRegistry` has been explicitly set. - var hasExtensionRegistry: Bool {return _storage._extensionRegistry != nil} + var hasExtensionRegistry: Bool {_storage._extensionRegistry != nil} /// Clears the value of `extensionRegistry`. Subsequent reads from it will return its default value. mutating func clearExtensionRegistry() {_uniqueStorage()._extensionRegistry = nil} var extensionsCurrentlySet: Int32 { - get {return _storage._extensionsCurrentlySet ?? 0} + get {_storage._extensionsCurrentlySet ?? 0} set {_uniqueStorage()._extensionsCurrentlySet = newValue} } /// Returns true if `extensionsCurrentlySet` has been explicitly set. - var hasExtensionsCurrentlySet: Bool {return _storage._extensionsCurrentlySet != nil} + var hasExtensionsCurrentlySet: Bool {_storage._extensionsCurrentlySet != nil} /// Clears the value of `extensionsCurrentlySet`. Subsequent reads from it will return its default value. mutating func clearExtensionsCurrentlySet() {_uniqueStorage()._extensionsCurrentlySet = nil} var isInitialized_p: Int32 { - get {return _storage._isInitialized_p ?? 0} + get {_storage._isInitialized_p ?? 0} set {_uniqueStorage()._isInitialized_p = newValue} } /// Returns true if `isInitialized_p` has been explicitly set. - var hasIsInitialized_p: Bool {return _storage._isInitialized_p != nil} + var hasIsInitialized_p: Bool {_storage._isInitialized_p != nil} /// Clears the value of `isInitialized_p`. Subsequent reads from it will return its default value. mutating func clearIsInitialized_p() {_uniqueStorage()._isInitialized_p = nil} var serializedSize: Int32 { - get {return _storage._serializedSize ?? 0} + get {_storage._serializedSize ?? 0} set {_uniqueStorage()._serializedSize = newValue} } /// Returns true if `serializedSize` has been explicitly set. - var hasSerializedSize: Bool {return _storage._serializedSize != nil} + var hasSerializedSize: Bool {_storage._serializedSize != nil} /// Clears the value of `serializedSize`. Subsequent reads from it will return its default value. mutating func clearSerializedSize() {_uniqueStorage()._serializedSize = nil} var sortedExtensionsInUse: Int32 { - get {return _storage._sortedExtensionsInUse ?? 0} + get {_storage._sortedExtensionsInUse ?? 0} set {_uniqueStorage()._sortedExtensionsInUse = newValue} } /// Returns true if `sortedExtensionsInUse` has been explicitly set. - var hasSortedExtensionsInUse: Bool {return _storage._sortedExtensionsInUse != nil} + var hasSortedExtensionsInUse: Bool {_storage._sortedExtensionsInUse != nil} /// Clears the value of `sortedExtensionsInUse`. Subsequent reads from it will return its default value. mutating func clearSortedExtensionsInUse() {_uniqueStorage()._sortedExtensionsInUse = nil} var unknownFields_p: Int32 { - get {return _storage._unknownFields_p ?? 0} + get {_storage._unknownFields_p ?? 0} set {_uniqueStorage()._unknownFields_p = newValue} } /// Returns true if `unknownFields_p` has been explicitly set. - var hasUnknownFields_p: Bool {return _storage._unknownFields_p != nil} + var hasUnknownFields_p: Bool {_storage._unknownFields_p != nil} /// Clears the value of `unknownFields_p`. Subsequent reads from it will return its default value. mutating func clearUnknownFields_p() {_uniqueStorage()._unknownFields_p = nil} var fixed: Int32 { - get {return _storage._fixed ?? 0} + get {_storage._fixed ?? 0} set {_uniqueStorage()._fixed = newValue} } /// Returns true if `fixed` has been explicitly set. - var hasFixed: Bool {return _storage._fixed != nil} + var hasFixed: Bool {_storage._fixed != nil} /// Clears the value of `fixed`. Subsequent reads from it will return its default value. mutating func clearFixed() {_uniqueStorage()._fixed = nil} var fract: Int32 { - get {return _storage._fract ?? 0} + get {_storage._fract ?? 0} set {_uniqueStorage()._fract = newValue} } /// Returns true if `fract` has been explicitly set. - var hasFract: Bool {return _storage._fract != nil} + var hasFract: Bool {_storage._fract != nil} /// Clears the value of `fract`. Subsequent reads from it will return its default value. mutating func clearFract() {_uniqueStorage()._fract = nil} var size: Int32 { - get {return _storage._size ?? 0} + get {_storage._size ?? 0} set {_uniqueStorage()._size = newValue} } /// Returns true if `size` has been explicitly set. - var hasSize: Bool {return _storage._size != nil} + var hasSize: Bool {_storage._size != nil} /// Clears the value of `size`. Subsequent reads from it will return its default value. mutating func clearSize() {_uniqueStorage()._size = nil} var logicalAddress: Int32 { - get {return _storage._logicalAddress ?? 0} + get {_storage._logicalAddress ?? 0} set {_uniqueStorage()._logicalAddress = newValue} } /// Returns true if `logicalAddress` has been explicitly set. - var hasLogicalAddress: Bool {return _storage._logicalAddress != nil} + var hasLogicalAddress: Bool {_storage._logicalAddress != nil} /// Clears the value of `logicalAddress`. Subsequent reads from it will return its default value. mutating func clearLogicalAddress() {_uniqueStorage()._logicalAddress = nil} var physicalAddress: Int32 { - get {return _storage._physicalAddress ?? 0} + get {_storage._physicalAddress ?? 0} set {_uniqueStorage()._physicalAddress = newValue} } /// Returns true if `physicalAddress` has been explicitly set. - var hasPhysicalAddress: Bool {return _storage._physicalAddress != nil} + var hasPhysicalAddress: Bool {_storage._physicalAddress != nil} /// Clears the value of `physicalAddress`. Subsequent reads from it will return its default value. mutating func clearPhysicalAddress() {_uniqueStorage()._physicalAddress = nil} var byteCount: Int32 { - get {return _storage._byteCount ?? 0} + get {_storage._byteCount ?? 0} set {_uniqueStorage()._byteCount = newValue} } /// Returns true if `byteCount` has been explicitly set. - var hasByteCount: Bool {return _storage._byteCount != nil} + var hasByteCount: Bool {_storage._byteCount != nil} /// Clears the value of `byteCount`. Subsequent reads from it will return its default value. mutating func clearByteCount() {_uniqueStorage()._byteCount = nil} var byteOffset: Int32 { - get {return _storage._byteOffset ?? 0} + get {_storage._byteOffset ?? 0} set {_uniqueStorage()._byteOffset = newValue} } /// Returns true if `byteOffset` has been explicitly set. - var hasByteOffset: Bool {return _storage._byteOffset != nil} + var hasByteOffset: Bool {_storage._byteOffset != nil} /// Clears the value of `byteOffset`. Subsequent reads from it will return its default value. mutating func clearByteOffset() {_uniqueStorage()._byteOffset = nil} var duration: Int32 { - get {return _storage._duration ?? 0} + get {_storage._duration ?? 0} set {_uniqueStorage()._duration = newValue} } /// Returns true if `duration` has been explicitly set. - var hasDuration: Bool {return _storage._duration != nil} + var hasDuration: Bool {_storage._duration != nil} /// Clears the value of `duration`. Subsequent reads from it will return its default value. mutating func clearDuration() {_uniqueStorage()._duration = nil} var absoluteTime: Int32 { - get {return _storage._absoluteTime ?? 0} + get {_storage._absoluteTime ?? 0} set {_uniqueStorage()._absoluteTime = newValue} } /// Returns true if `absoluteTime` has been explicitly set. - var hasAbsoluteTime: Bool {return _storage._absoluteTime != nil} + var hasAbsoluteTime: Bool {_storage._absoluteTime != nil} /// Clears the value of `absoluteTime`. Subsequent reads from it will return its default value. mutating func clearAbsoluteTime() {_uniqueStorage()._absoluteTime = nil} var optionBits: Int32 { - get {return _storage._optionBits ?? 0} + get {_storage._optionBits ?? 0} set {_uniqueStorage()._optionBits = newValue} } /// Returns true if `optionBits` has been explicitly set. - var hasOptionBits: Bool {return _storage._optionBits != nil} + var hasOptionBits: Bool {_storage._optionBits != nil} /// Clears the value of `optionBits`. Subsequent reads from it will return its default value. mutating func clearOptionBits() {_uniqueStorage()._optionBits = nil} var itemCount: Int32 { - get {return _storage._itemCount ?? 0} + get {_storage._itemCount ?? 0} set {_uniqueStorage()._itemCount = newValue} } /// Returns true if `itemCount` has been explicitly set. - var hasItemCount: Bool {return _storage._itemCount != nil} + var hasItemCount: Bool {_storage._itemCount != nil} /// Clears the value of `itemCount`. Subsequent reads from it will return its default value. mutating func clearItemCount() {_uniqueStorage()._itemCount = nil} var pbversion: Int32 { - get {return _storage._pbversion ?? 0} + get {_storage._pbversion ?? 0} set {_uniqueStorage()._pbversion = newValue} } /// Returns true if `pbversion` has been explicitly set. - var hasPbversion: Bool {return _storage._pbversion != nil} + var hasPbversion: Bool {_storage._pbversion != nil} /// Clears the value of `pbversion`. Subsequent reads from it will return its default value. mutating func clearPbversion() {_uniqueStorage()._pbversion = nil} var scriptCode: Int32 { - get {return _storage._scriptCode ?? 0} + get {_storage._scriptCode ?? 0} set {_uniqueStorage()._scriptCode = newValue} } /// Returns true if `scriptCode` has been explicitly set. - var hasScriptCode: Bool {return _storage._scriptCode != nil} + var hasScriptCode: Bool {_storage._scriptCode != nil} /// Clears the value of `scriptCode`. Subsequent reads from it will return its default value. mutating func clearScriptCode() {_uniqueStorage()._scriptCode = nil} var langCode: Int32 { - get {return _storage._langCode ?? 0} + get {_storage._langCode ?? 0} set {_uniqueStorage()._langCode = newValue} } /// Returns true if `langCode` has been explicitly set. - var hasLangCode: Bool {return _storage._langCode != nil} + var hasLangCode: Bool {_storage._langCode != nil} /// Clears the value of `langCode`. Subsequent reads from it will return its default value. mutating func clearLangCode() {_uniqueStorage()._langCode = nil} var regionCode: Int32 { - get {return _storage._regionCode ?? 0} + get {_storage._regionCode ?? 0} set {_uniqueStorage()._regionCode = newValue} } /// Returns true if `regionCode` has been explicitly set. - var hasRegionCode: Bool {return _storage._regionCode != nil} + var hasRegionCode: Bool {_storage._regionCode != nil} /// Clears the value of `regionCode`. Subsequent reads from it will return its default value. mutating func clearRegionCode() {_uniqueStorage()._regionCode = nil} var ostype: Int32 { - get {return _storage._ostype ?? 0} + get {_storage._ostype ?? 0} set {_uniqueStorage()._ostype = newValue} } /// Returns true if `ostype` has been explicitly set. - var hasOstype: Bool {return _storage._ostype != nil} + var hasOstype: Bool {_storage._ostype != nil} /// Clears the value of `ostype`. Subsequent reads from it will return its default value. mutating func clearOstype() {_uniqueStorage()._ostype = nil} var processSerialNumber: Int32 { - get {return _storage._processSerialNumber ?? 0} + get {_storage._processSerialNumber ?? 0} set {_uniqueStorage()._processSerialNumber = newValue} } /// Returns true if `processSerialNumber` has been explicitly set. - var hasProcessSerialNumber: Bool {return _storage._processSerialNumber != nil} + var hasProcessSerialNumber: Bool {_storage._processSerialNumber != nil} /// Clears the value of `processSerialNumber`. Subsequent reads from it will return its default value. mutating func clearProcessSerialNumber() {_uniqueStorage()._processSerialNumber = nil} var point: Int32 { - get {return _storage._point ?? 0} + get {_storage._point ?? 0} set {_uniqueStorage()._point = newValue} } /// Returns true if `point` has been explicitly set. - var hasPoint: Bool {return _storage._point != nil} + var hasPoint: Bool {_storage._point != nil} /// Clears the value of `point`. Subsequent reads from it will return its default value. mutating func clearPoint() {_uniqueStorage()._point = nil} var rect: Int32 { - get {return _storage._rect ?? 0} + get {_storage._rect ?? 0} set {_uniqueStorage()._rect = newValue} } /// Returns true if `rect` has been explicitly set. - var hasRect: Bool {return _storage._rect != nil} + var hasRect: Bool {_storage._rect != nil} /// Clears the value of `rect`. Subsequent reads from it will return its default value. mutating func clearRect() {_uniqueStorage()._rect = nil} var fixedPoint: Int32 { - get {return _storage._fixedPoint ?? 0} + get {_storage._fixedPoint ?? 0} set {_uniqueStorage()._fixedPoint = newValue} } /// Returns true if `fixedPoint` has been explicitly set. - var hasFixedPoint: Bool {return _storage._fixedPoint != nil} + var hasFixedPoint: Bool {_storage._fixedPoint != nil} /// Clears the value of `fixedPoint`. Subsequent reads from it will return its default value. mutating func clearFixedPoint() {_uniqueStorage()._fixedPoint = nil} var fixedRect: Int32 { - get {return _storage._fixedRect ?? 0} + get {_storage._fixedRect ?? 0} set {_uniqueStorage()._fixedRect = newValue} } /// Returns true if `fixedRect` has been explicitly set. - var hasFixedRect: Bool {return _storage._fixedRect != nil} + var hasFixedRect: Bool {_storage._fixedRect != nil} /// Clears the value of `fixedRect`. Subsequent reads from it will return its default value. mutating func clearFixedRect() {_uniqueStorage()._fixedRect = nil} var style: Int32 { - get {return _storage._style ?? 0} + get {_storage._style ?? 0} set {_uniqueStorage()._style = newValue} } /// Returns true if `style` has been explicitly set. - var hasStyle: Bool {return _storage._style != nil} + var hasStyle: Bool {_storage._style != nil} /// Clears the value of `style`. Subsequent reads from it will return its default value. mutating func clearStyle() {_uniqueStorage()._style = nil} var styleParameter: Int32 { - get {return _storage._styleParameter ?? 0} + get {_storage._styleParameter ?? 0} set {_uniqueStorage()._styleParameter = newValue} } /// Returns true if `styleParameter` has been explicitly set. - var hasStyleParameter: Bool {return _storage._styleParameter != nil} + var hasStyleParameter: Bool {_storage._styleParameter != nil} /// Clears the value of `styleParameter`. Subsequent reads from it will return its default value. mutating func clearStyleParameter() {_uniqueStorage()._styleParameter = nil} var styleField: Int32 { - get {return _storage._styleField ?? 0} + get {_storage._styleField ?? 0} set {_uniqueStorage()._styleField = newValue} } /// Returns true if `styleField` has been explicitly set. - var hasStyleField: Bool {return _storage._styleField != nil} + var hasStyleField: Bool {_storage._styleField != nil} /// Clears the value of `styleField`. Subsequent reads from it will return its default value. mutating func clearStyleField() {_uniqueStorage()._styleField = nil} var timeScale: Int32 { - get {return _storage._timeScale ?? 0} + get {_storage._timeScale ?? 0} set {_uniqueStorage()._timeScale = newValue} } /// Returns true if `timeScale` has been explicitly set. - var hasTimeScale: Bool {return _storage._timeScale != nil} + var hasTimeScale: Bool {_storage._timeScale != nil} /// Clears the value of `timeScale`. Subsequent reads from it will return its default value. mutating func clearTimeScale() {_uniqueStorage()._timeScale = nil} var timeBase: Int32 { - get {return _storage._timeBase ?? 0} + get {_storage._timeBase ?? 0} set {_uniqueStorage()._timeBase = newValue} } /// Returns true if `timeBase` has been explicitly set. - var hasTimeBase: Bool {return _storage._timeBase != nil} + var hasTimeBase: Bool {_storage._timeBase != nil} /// Clears the value of `timeBase`. Subsequent reads from it will return its default value. mutating func clearTimeBase() {_uniqueStorage()._timeBase = nil} var timeRecord: Int32 { - get {return _storage._timeRecord ?? 0} + get {_storage._timeRecord ?? 0} set {_uniqueStorage()._timeRecord = newValue} } /// Returns true if `timeRecord` has been explicitly set. - var hasTimeRecord: Bool {return _storage._timeRecord != nil} + var hasTimeRecord: Bool {_storage._timeRecord != nil} /// Clears the value of `timeRecord`. Subsequent reads from it will return its default value. mutating func clearTimeRecord() {_uniqueStorage()._timeRecord = nil} - var jsonShouldBeOverriden: Int32 { - get {return _storage._jsonShouldBeOverriden ?? 0} - set {_uniqueStorage()._jsonShouldBeOverriden = newValue} + var jsonShouldBeOverridden: Int32 { + get {_storage._jsonShouldBeOverridden ?? 0} + set {_uniqueStorage()._jsonShouldBeOverridden = newValue} } - /// Returns true if `jsonShouldBeOverriden` has been explicitly set. - var hasJsonShouldBeOverriden: Bool {return _storage._jsonShouldBeOverriden != nil} - /// Clears the value of `jsonShouldBeOverriden`. Subsequent reads from it will return its default value. - mutating func clearJsonShouldBeOverriden() {_uniqueStorage()._jsonShouldBeOverriden = nil} + /// Returns true if `jsonShouldBeOverridden` has been explicitly set. + var hasJsonShouldBeOverridden: Bool {_storage._jsonShouldBeOverridden != nil} + /// Clears the value of `jsonShouldBeOverridden`. Subsequent reads from it will return its default value. + mutating func clearJsonShouldBeOverridden() {_uniqueStorage()._jsonShouldBeOverridden = nil} var any: Int32 { - get {return _storage._any ?? 0} + get {_storage._any ?? 0} set {_uniqueStorage()._any = newValue} } /// Returns true if `any` has been explicitly set. - var hasAny: Bool {return _storage._any != nil} + var hasAny: Bool {_storage._any != nil} /// Clears the value of `any`. Subsequent reads from it will return its default value. mutating func clearAny() {_uniqueStorage()._any = nil} var int32: Int32 { - get {return _storage._int32 ?? 0} + get {_storage._int32 ?? 0} set {_uniqueStorage()._int32 = newValue} } /// Returns true if `int32` has been explicitly set. - var hasInt32: Bool {return _storage._int32 != nil} + var hasInt32: Bool {_storage._int32 != nil} /// Clears the value of `int32`. Subsequent reads from it will return its default value. mutating func clearInt32() {_uniqueStorage()._int32 = nil} var int64: Int32 { - get {return _storage._int64 ?? 0} + get {_storage._int64 ?? 0} set {_uniqueStorage()._int64 = newValue} } /// Returns true if `int64` has been explicitly set. - var hasInt64: Bool {return _storage._int64 != nil} + var hasInt64: Bool {_storage._int64 != nil} /// Clears the value of `int64`. Subsequent reads from it will return its default value. mutating func clearInt64() {_uniqueStorage()._int64 = nil} var uint32: Int32 { - get {return _storage._uint32 ?? 0} + get {_storage._uint32 ?? 0} set {_uniqueStorage()._uint32 = newValue} } /// Returns true if `uint32` has been explicitly set. - var hasUint32: Bool {return _storage._uint32 != nil} + var hasUint32: Bool {_storage._uint32 != nil} /// Clears the value of `uint32`. Subsequent reads from it will return its default value. mutating func clearUint32() {_uniqueStorage()._uint32 = nil} var uint64: Int32 { - get {return _storage._uint64 ?? 0} + get {_storage._uint64 ?? 0} set {_uniqueStorage()._uint64 = newValue} } /// Returns true if `uint64` has been explicitly set. - var hasUint64: Bool {return _storage._uint64 != nil} + var hasUint64: Bool {_storage._uint64 != nil} /// Clears the value of `uint64`. Subsequent reads from it will return its default value. mutating func clearUint64() {_uniqueStorage()._uint64 = nil} var `associatedtype`: Int32 { - get {return _storage._associatedtype ?? 0} + get {_storage._associatedtype ?? 0} set {_uniqueStorage()._associatedtype = newValue} } /// Returns true if ``associatedtype`` has been explicitly set. - var hasAssociatedtype: Bool {return _storage._associatedtype != nil} + var hasAssociatedtype: Bool {_storage._associatedtype != nil} /// Clears the value of ``associatedtype``. Subsequent reads from it will return its default value. mutating func clearAssociatedtype() {_uniqueStorage()._associatedtype = nil} var `fileprivate`: Int32 { - get {return _storage._fileprivate ?? 0} + get {_storage._fileprivate ?? 0} set {_uniqueStorage()._fileprivate = newValue} } /// Returns true if ``fileprivate`` has been explicitly set. - var hasFileprivate: Bool {return _storage._fileprivate != nil} + var hasFileprivate: Bool {_storage._fileprivate != nil} /// Clears the value of ``fileprivate``. Subsequent reads from it will return its default value. mutating func clearFileprivate() {_uniqueStorage()._fileprivate = nil} var `open`: Int32 { - get {return _storage._open ?? 0} + get {_storage._open ?? 0} set {_uniqueStorage()._open = newValue} } /// Returns true if ``open`` has been explicitly set. - var hasOpen: Bool {return _storage._open != nil} + var hasOpen: Bool {_storage._open != nil} /// Clears the value of ``open``. Subsequent reads from it will return its default value. mutating func clearOpen() {_uniqueStorage()._open = nil} var serializedData: Int32 { - get {return _storage._serializedData ?? 0} + get {_storage._serializedData ?? 0} set {_uniqueStorage()._serializedData = newValue} } /// Returns true if `serializedData` has been explicitly set. - var hasSerializedData: Bool {return _storage._serializedData != nil} + var hasSerializedData: Bool {_storage._serializedData != nil} /// Clears the value of `serializedData`. Subsequent reads from it will return its default value. mutating func clearSerializedData() {_uniqueStorage()._serializedData = nil} var hasSerializedData_p: Int32 { - get {return _storage._hasSerializedData_p ?? 0} + get {_storage._hasSerializedData_p ?? 0} set {_uniqueStorage()._hasSerializedData_p = newValue} } /// Returns true if `hasSerializedData_p` has been explicitly set. - var hasHasSerializedData_p: Bool {return _storage._hasSerializedData_p != nil} + var hasHasSerializedData_p: Bool {_storage._hasSerializedData_p != nil} /// Clears the value of `hasSerializedData_p`. Subsequent reads from it will return its default value. mutating func clearHasSerializedData_p() {_uniqueStorage()._hasSerializedData_p = nil} var clearSerializedData_p: Int32 { - get {return _storage._clearSerializedData_p ?? 0} + get {_storage._clearSerializedData_p ?? 0} set {_uniqueStorage()._clearSerializedData_p = newValue} } /// Returns true if `clearSerializedData_p` has been explicitly set. - var hasClearSerializedData_p: Bool {return _storage._clearSerializedData_p != nil} + var hasClearSerializedData_p: Bool {_storage._clearSerializedData_p != nil} /// Clears the value of `clearSerializedData_p`. Subsequent reads from it will return its default value. mutating func clearClearSerializedData_p() {_uniqueStorage()._clearSerializedData_p = nil} var jsonUtf8Data: Int32 { - get {return _storage._jsonUtf8Data ?? 0} + get {_storage._jsonUtf8Data ?? 0} set {_uniqueStorage()._jsonUtf8Data = newValue} } /// Returns true if `jsonUtf8Data` has been explicitly set. - var hasJsonUtf8Data: Bool {return _storage._jsonUtf8Data != nil} + var hasJsonUtf8Data: Bool {_storage._jsonUtf8Data != nil} /// Clears the value of `jsonUtf8Data`. Subsequent reads from it will return its default value. mutating func clearJsonUtf8Data() {_uniqueStorage()._jsonUtf8Data = nil} var jsonString: Int32 { - get {return _storage._jsonString ?? 0} + get {_storage._jsonString ?? 0} set {_uniqueStorage()._jsonString = newValue} } /// Returns true if `jsonString` has been explicitly set. - var hasJsonString: Bool {return _storage._jsonString != nil} + var hasJsonString: Bool {_storage._jsonString != nil} /// Clears the value of `jsonString`. Subsequent reads from it will return its default value. mutating func clearJsonString() {_uniqueStorage()._jsonString = nil} var `extension`: Int32 { - get {return _storage._extension ?? 0} + get {_storage._extension ?? 0} set {_uniqueStorage()._extension = newValue} } /// Returns true if ``extension`` has been explicitly set. - var hasExtension: Bool {return _storage._extension != nil} + var hasExtension: Bool {_storage._extension != nil} /// Clears the value of ``extension``. Subsequent reads from it will return its default value. mutating func clearExtension() {_uniqueStorage()._extension = nil} var extensions: Int32 { - get {return _storage._extensions ?? 0} + get {_storage._extensions ?? 0} set {_uniqueStorage()._extensions = newValue} } /// Returns true if `extensions` has been explicitly set. - var hasExtensions: Bool {return _storage._extensions != nil} + var hasExtensions: Bool {_storage._extensions != nil} /// Clears the value of `extensions`. Subsequent reads from it will return its default value. mutating func clearExtensions() {_uniqueStorage()._extensions = nil} @@ -2756,24 +2296,24 @@ struct SwiftUnittest_Names_FieldNames { fileprivate var _storage = _StorageClass.defaultInstance } -struct SwiftUnittest_Names_MessageNames { +struct SwiftProtoTesting_Names_MessageNames: Sendable { // 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() - struct StringMessage { + struct StringMessage: Sendable { // 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 string: Int32 { - get {return _string ?? 0} + get {_string ?? 0} set {_string = newValue} } /// Returns true if `string` has been explicitly set. - var hasString: Bool {return self._string != nil} + var hasString: Bool {self._string != nil} /// Clears the value of `string`. Subsequent reads from it will return its default value. mutating func clearString() {self._string = nil} @@ -2784,17 +2324,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _string: Int32? = nil } - struct ProtocolMessage { + struct ProtocolMessage: Sendable { // 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 `protocol`: Int32 { - get {return _protocol ?? 0} + get {_protocol ?? 0} set {_protocol = newValue} } /// Returns true if ``protocol`` has been explicitly set. - var hasProtocol: Bool {return self._protocol != nil} + var hasProtocol: Bool {self._protocol != nil} /// Clears the value of ``protocol``. Subsequent reads from it will return its default value. mutating func clearProtocol() {self._protocol = nil} @@ -2805,17 +2345,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _protocol: Int32? = nil } - struct IntMessage { + struct IntMessage: Sendable { // 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 int: Int32 { - get {return _int ?? 0} + get {_int ?? 0} set {_int = newValue} } /// Returns true if `int` has been explicitly set. - var hasInt: Bool {return self._int != nil} + var hasInt: Bool {self._int != nil} /// Clears the value of `int`. Subsequent reads from it will return its default value. mutating func clearInt() {self._int = nil} @@ -2826,17 +2366,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _int: Int32? = nil } - struct DoubleMessage { + struct DoubleMessage: Sendable { // 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 double: Int32 { - get {return _double ?? 0} + get {_double ?? 0} set {_double = newValue} } /// Returns true if `double` has been explicitly set. - var hasDouble: Bool {return self._double != nil} + var hasDouble: Bool {self._double != nil} /// Clears the value of `double`. Subsequent reads from it will return its default value. mutating func clearDouble() {self._double = nil} @@ -2847,17 +2387,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _double: Int32? = nil } - struct FloatMessage { + struct FloatMessage: Sendable { // 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 float: Int32 { - get {return _float ?? 0} + get {_float ?? 0} set {_float = newValue} } /// Returns true if `float` has been explicitly set. - var hasFloat: Bool {return self._float != nil} + var hasFloat: Bool {self._float != nil} /// Clears the value of `float`. Subsequent reads from it will return its default value. mutating func clearFloat() {self._float = nil} @@ -2868,17 +2408,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _float: Int32? = nil } - struct UIntMessage { + struct UIntMessage: Sendable { // 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 uint: Int32 { - get {return _uint ?? 0} + get {_uint ?? 0} set {_uint = newValue} } /// Returns true if `uint` has been explicitly set. - var hasUint: Bool {return self._uint != nil} + var hasUint: Bool {self._uint != nil} /// Clears the value of `uint`. Subsequent reads from it will return its default value. mutating func clearUint() {self._uint = nil} @@ -2889,17 +2429,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _uint: Int32? = nil } - struct hashValueMessage { + struct hashValueMessage: Sendable { // 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 hashValue_p: Int32 { - get {return _hashValue_p ?? 0} + get {_hashValue_p ?? 0} set {_hashValue_p = newValue} } /// Returns true if `hashValue_p` has been explicitly set. - var hasHashValue_p: Bool {return self._hashValue_p != nil} + var hasHashValue_p: Bool {self._hashValue_p != nil} /// Clears the value of `hashValue_p`. Subsequent reads from it will return its default value. mutating func clearHashValue_p() {self._hashValue_p = nil} @@ -2910,17 +2450,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _hashValue_p: Int32? = nil } - struct descriptionMessage { + struct descriptionMessage: Sendable { // 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 description_p: Int32 { - get {return _description_p ?? 0} + get {_description_p ?? 0} set {_description_p = newValue} } /// Returns true if `description_p` has been explicitly set. - var hasDescription_p: Bool {return self._description_p != nil} + var hasDescription_p: Bool {self._description_p != nil} /// Clears the value of `description_p`. Subsequent reads from it will return its default value. mutating func clearDescription_p() {self._description_p = nil} @@ -2931,17 +2471,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _description_p: Int32? = nil } - struct debugDescriptionMessage { + struct debugDescriptionMessage: Sendable { // 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 debugDescription_p: Int32 { - get {return _debugDescription_p ?? 0} + get {_debugDescription_p ?? 0} set {_debugDescription_p = newValue} } /// Returns true if `debugDescription_p` has been explicitly set. - var hasDebugDescription_p: Bool {return self._debugDescription_p != nil} + var hasDebugDescription_p: Bool {self._debugDescription_p != nil} /// Clears the value of `debugDescription_p`. Subsequent reads from it will return its default value. mutating func clearDebugDescription_p() {self._debugDescription_p = nil} @@ -2952,17 +2492,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _debugDescription_p: Int32? = nil } - struct Swift { + struct SwiftMessage: Sendable { // 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 swift: Int32 { - get {return _swift ?? 0} + get {_swift ?? 0} set {_swift = newValue} } /// Returns true if `swift` has been explicitly set. - var hasSwift: Bool {return self._swift != nil} + var hasSwift: Bool {self._swift != nil} /// Clears the value of `swift`. Subsequent reads from it will return its default value. mutating func clearSwift() {self._swift = nil} @@ -2973,17 +2513,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _swift: Int32? = nil } - struct UNRECOGNIZED { + struct UNRECOGNIZED: Sendable { // 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 unrecognized: Int32 { - get {return _unrecognized ?? 0} + get {_unrecognized ?? 0} set {_unrecognized = newValue} } /// Returns true if `unrecognized` has been explicitly set. - var hasUnrecognized: Bool {return self._unrecognized != nil} + var hasUnrecognized: Bool {self._unrecognized != nil} /// Clears the value of `unrecognized`. Subsequent reads from it will return its default value. mutating func clearUnrecognized() {self._unrecognized = nil} @@ -2994,17 +2534,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _unrecognized: Int32? = nil } - struct classMessage { + struct classMessage: Sendable { // 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 `class`: Int32 { - get {return _class ?? 0} + get {_class ?? 0} set {_class = newValue} } /// Returns true if ``class`` has been explicitly set. - var hasClass: Bool {return self._class != nil} + var hasClass: Bool {self._class != nil} /// Clears the value of ``class``. Subsequent reads from it will return its default value. mutating func clearClass() {self._class = nil} @@ -3015,17 +2555,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _class: Int32? = nil } - struct deinitMessage { + struct deinitMessage: Sendable { // 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 `deinit`: Int32 { - get {return _deinit ?? 0} + get {_deinit ?? 0} set {_deinit = newValue} } /// Returns true if ``deinit`` has been explicitly set. - var hasDeinit: Bool {return self._deinit != nil} + var hasDeinit: Bool {self._deinit != nil} /// Clears the value of ``deinit``. Subsequent reads from it will return its default value. mutating func clearDeinit() {self._deinit = nil} @@ -3036,17 +2576,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _deinit: Int32? = nil } - struct enumMessage { + struct enumMessage: Sendable { // 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 `enum`: Int32 { - get {return _enum ?? 0} + get {_enum ?? 0} set {_enum = newValue} } /// Returns true if ``enum`` has been explicitly set. - var hasEnum: Bool {return self._enum != nil} + var hasEnum: Bool {self._enum != nil} /// Clears the value of ``enum``. Subsequent reads from it will return its default value. mutating func clearEnum() {self._enum = nil} @@ -3057,17 +2597,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _enum: Int32? = nil } - struct extensionMessage { + struct extensionMessage: Sendable { // 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 `extension`: Int32 { - get {return _extension ?? 0} + get {_extension ?? 0} set {_extension = newValue} } /// Returns true if ``extension`` has been explicitly set. - var hasExtension: Bool {return self._extension != nil} + var hasExtension: Bool {self._extension != nil} /// Clears the value of ``extension``. Subsequent reads from it will return its default value. mutating func clearExtension() {self._extension = nil} @@ -3078,17 +2618,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _extension: Int32? = nil } - struct funcMessage { + struct funcMessage: Sendable { // 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 `func`: Int32 { - get {return _func ?? 0} + get {_func ?? 0} set {_func = newValue} } /// Returns true if ``func`` has been explicitly set. - var hasFunc: Bool {return self._func != nil} + var hasFunc: Bool {self._func != nil} /// Clears the value of ``func``. Subsequent reads from it will return its default value. mutating func clearFunc() {self._func = nil} @@ -3099,17 +2639,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _func: Int32? = nil } - struct importMessage { + struct importMessage: Sendable { // 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 `import`: Int32 { - get {return _import ?? 0} + get {_import ?? 0} set {_import = newValue} } /// Returns true if ``import`` has been explicitly set. - var hasImport: Bool {return self._import != nil} + var hasImport: Bool {self._import != nil} /// Clears the value of ``import``. Subsequent reads from it will return its default value. mutating func clearImport() {self._import = nil} @@ -3120,17 +2660,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _import: Int32? = nil } - struct initMessage { + struct initMessage: Sendable { // 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 init_p: Int32 { - get {return _init_p ?? 0} + get {_init_p ?? 0} set {_init_p = newValue} } /// Returns true if `init_p` has been explicitly set. - var hasInit_p: Bool {return self._init_p != nil} + var hasInit_p: Bool {self._init_p != nil} /// Clears the value of `init_p`. Subsequent reads from it will return its default value. mutating func clearInit_p() {self._init_p = nil} @@ -3141,17 +2681,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _init_p: Int32? = nil } - struct inoutMessage { + struct inoutMessage: Sendable { // 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 `inout`: Int32 { - get {return _inout ?? 0} + get {_inout ?? 0} set {_inout = newValue} } /// Returns true if ``inout`` has been explicitly set. - var hasInout: Bool {return self._inout != nil} + var hasInout: Bool {self._inout != nil} /// Clears the value of ``inout``. Subsequent reads from it will return its default value. mutating func clearInout() {self._inout = nil} @@ -3162,17 +2702,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _inout: Int32? = nil } - struct internalMessage { + struct internalMessage: Sendable { // 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 `internal`: Int32 { - get {return _internal ?? 0} + get {_internal ?? 0} set {_internal = newValue} } /// Returns true if ``internal`` has been explicitly set. - var hasInternal: Bool {return self._internal != nil} + var hasInternal: Bool {self._internal != nil} /// Clears the value of ``internal``. Subsequent reads from it will return its default value. mutating func clearInternal() {self._internal = nil} @@ -3183,17 +2723,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _internal: Int32? = nil } - struct letMessage { + struct letMessage: Sendable { // 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 `let`: Int32 { - get {return _let ?? 0} + get {_let ?? 0} set {_let = newValue} } /// Returns true if ``let`` has been explicitly set. - var hasLet: Bool {return self._let != nil} + var hasLet: Bool {self._let != nil} /// Clears the value of ``let``. Subsequent reads from it will return its default value. mutating func clearLet() {self._let = nil} @@ -3204,17 +2744,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _let: Int32? = nil } - struct operatorMessage { + struct operatorMessage: Sendable { // 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 `operator`: Int32 { - get {return _operator ?? 0} + get {_operator ?? 0} set {_operator = newValue} } /// Returns true if ``operator`` has been explicitly set. - var hasOperator: Bool {return self._operator != nil} + var hasOperator: Bool {self._operator != nil} /// Clears the value of ``operator``. Subsequent reads from it will return its default value. mutating func clearOperator() {self._operator = nil} @@ -3225,17 +2765,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _operator: Int32? = nil } - struct privateMessage { + struct privateMessage: Sendable { // 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 `private`: Int32 { - get {return _private ?? 0} + get {_private ?? 0} set {_private = newValue} } /// Returns true if ``private`` has been explicitly set. - var hasPrivate: Bool {return self._private != nil} + var hasPrivate: Bool {self._private != nil} /// Clears the value of ``private``. Subsequent reads from it will return its default value. mutating func clearPrivate() {self._private = nil} @@ -3246,17 +2786,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _private: Int32? = nil } - struct protocolMessage { + struct protocolMessage: Sendable { // 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 `protocol`: Int32 { - get {return _protocol ?? 0} + get {_protocol ?? 0} set {_protocol = newValue} } /// Returns true if ``protocol`` has been explicitly set. - var hasProtocol: Bool {return self._protocol != nil} + var hasProtocol: Bool {self._protocol != nil} /// Clears the value of ``protocol``. Subsequent reads from it will return its default value. mutating func clearProtocol() {self._protocol = nil} @@ -3267,17 +2807,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _protocol: Int32? = nil } - struct publicMessage { + struct publicMessage: Sendable { // 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 `public`: Int32 { - get {return _public ?? 0} + get {_public ?? 0} set {_public = newValue} } /// Returns true if ``public`` has been explicitly set. - var hasPublic: Bool {return self._public != nil} + var hasPublic: Bool {self._public != nil} /// Clears the value of ``public``. Subsequent reads from it will return its default value. mutating func clearPublic() {self._public = nil} @@ -3288,17 +2828,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _public: Int32? = nil } - struct staticMessage { + struct staticMessage: Sendable { // 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 `static`: Int32 { - get {return _static ?? 0} + get {_static ?? 0} set {_static = newValue} } /// Returns true if ``static`` has been explicitly set. - var hasStatic: Bool {return self._static != nil} + var hasStatic: Bool {self._static != nil} /// Clears the value of ``static``. Subsequent reads from it will return its default value. mutating func clearStatic() {self._static = nil} @@ -3309,17 +2849,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _static: Int32? = nil } - struct structMessage { + struct structMessage: Sendable { // 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 `struct`: Int32 { - get {return _struct ?? 0} + get {_struct ?? 0} set {_struct = newValue} } /// Returns true if ``struct`` has been explicitly set. - var hasStruct: Bool {return self._struct != nil} + var hasStruct: Bool {self._struct != nil} /// Clears the value of ``struct``. Subsequent reads from it will return its default value. mutating func clearStruct() {self._struct = nil} @@ -3330,17 +2870,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _struct: Int32? = nil } - struct subscriptMessage { + struct subscriptMessage: Sendable { // 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 `subscript`: Int32 { - get {return _subscript ?? 0} + get {_subscript ?? 0} set {_subscript = newValue} } /// Returns true if ``subscript`` has been explicitly set. - var hasSubscript: Bool {return self._subscript != nil} + var hasSubscript: Bool {self._subscript != nil} /// Clears the value of ``subscript``. Subsequent reads from it will return its default value. mutating func clearSubscript() {self._subscript = nil} @@ -3351,17 +2891,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _subscript: Int32? = nil } - struct typealiasMessage { + struct typealiasMessage: Sendable { // 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 `typealias`: Int32 { - get {return _typealias ?? 0} + get {_typealias ?? 0} set {_typealias = newValue} } /// Returns true if ``typealias`` has been explicitly set. - var hasTypealias: Bool {return self._typealias != nil} + var hasTypealias: Bool {self._typealias != nil} /// Clears the value of ``typealias``. Subsequent reads from it will return its default value. mutating func clearTypealias() {self._typealias = nil} @@ -3372,17 +2912,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _typealias: Int32? = nil } - struct varMessage { + struct varMessage: Sendable { // 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 `var`: Int32 { - get {return _var ?? 0} + get {_var ?? 0} set {_var = newValue} } /// Returns true if ``var`` has been explicitly set. - var hasVar: Bool {return self._var != nil} + var hasVar: Bool {self._var != nil} /// Clears the value of ``var``. Subsequent reads from it will return its default value. mutating func clearVar() {self._var = nil} @@ -3393,17 +2933,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _var: Int32? = nil } - struct breakMessage { + struct breakMessage: Sendable { // 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 `break`: Int32 { - get {return _break ?? 0} + get {_break ?? 0} set {_break = newValue} } /// Returns true if ``break`` has been explicitly set. - var hasBreak: Bool {return self._break != nil} + var hasBreak: Bool {self._break != nil} /// Clears the value of ``break``. Subsequent reads from it will return its default value. mutating func clearBreak() {self._break = nil} @@ -3414,17 +2954,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _break: Int32? = nil } - struct caseMessage { + struct caseMessage: Sendable { // 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 `case`: Int32 { - get {return _case ?? 0} + get {_case ?? 0} set {_case = newValue} } /// Returns true if ``case`` has been explicitly set. - var hasCase: Bool {return self._case != nil} + var hasCase: Bool {self._case != nil} /// Clears the value of ``case``. Subsequent reads from it will return its default value. mutating func clearCase() {self._case = nil} @@ -3435,17 +2975,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _case: Int32? = nil } - struct continueMessage { + struct continueMessage: Sendable { // 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 `continue`: Int32 { - get {return _continue ?? 0} + get {_continue ?? 0} set {_continue = newValue} } /// Returns true if ``continue`` has been explicitly set. - var hasContinue: Bool {return self._continue != nil} + var hasContinue: Bool {self._continue != nil} /// Clears the value of ``continue``. Subsequent reads from it will return its default value. mutating func clearContinue() {self._continue = nil} @@ -3456,17 +2996,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _continue: Int32? = nil } - struct defaultMessage { + struct defaultMessage: Sendable { // 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 `default`: Int32 { - get {return _default ?? 0} + get {_default ?? 0} set {_default = newValue} } /// Returns true if ``default`` has been explicitly set. - var hasDefault: Bool {return self._default != nil} + var hasDefault: Bool {self._default != nil} /// Clears the value of ``default``. Subsequent reads from it will return its default value. mutating func clearDefault() {self._default = nil} @@ -3477,17 +3017,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _default: Int32? = nil } - struct deferMessage { + struct deferMessage: Sendable { // 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 `defer`: Int32 { - get {return _defer ?? 0} + get {_defer ?? 0} set {_defer = newValue} } /// Returns true if ``defer`` has been explicitly set. - var hasDefer: Bool {return self._defer != nil} + var hasDefer: Bool {self._defer != nil} /// Clears the value of ``defer``. Subsequent reads from it will return its default value. mutating func clearDefer() {self._defer = nil} @@ -3498,17 +3038,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _defer: Int32? = nil } - struct doMessage { + struct doMessage: Sendable { // 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 `do`: Int32 { - get {return _do ?? 0} + get {_do ?? 0} set {_do = newValue} } /// Returns true if ``do`` has been explicitly set. - var hasDo: Bool {return self._do != nil} + var hasDo: Bool {self._do != nil} /// Clears the value of ``do``. Subsequent reads from it will return its default value. mutating func clearDo() {self._do = nil} @@ -3519,17 +3059,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _do: Int32? = nil } - struct elseMessage { + struct elseMessage: Sendable { // 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 `else`: Int32 { - get {return _else ?? 0} + get {_else ?? 0} set {_else = newValue} } /// Returns true if ``else`` has been explicitly set. - var hasElse: Bool {return self._else != nil} + var hasElse: Bool {self._else != nil} /// Clears the value of ``else``. Subsequent reads from it will return its default value. mutating func clearElse() {self._else = nil} @@ -3540,17 +3080,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _else: Int32? = nil } - struct fallthroughMessage { + struct fallthroughMessage: Sendable { // 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 `fallthrough`: Int32 { - get {return _fallthrough ?? 0} + get {_fallthrough ?? 0} set {_fallthrough = newValue} } /// Returns true if ``fallthrough`` has been explicitly set. - var hasFallthrough: Bool {return self._fallthrough != nil} + var hasFallthrough: Bool {self._fallthrough != nil} /// Clears the value of ``fallthrough``. Subsequent reads from it will return its default value. mutating func clearFallthrough() {self._fallthrough = nil} @@ -3561,17 +3101,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _fallthrough: Int32? = nil } - struct forMessage { + struct forMessage: Sendable { // 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 `for`: Int32 { - get {return _for ?? 0} + get {_for ?? 0} set {_for = newValue} } /// Returns true if ``for`` has been explicitly set. - var hasFor: Bool {return self._for != nil} + var hasFor: Bool {self._for != nil} /// Clears the value of ``for``. Subsequent reads from it will return its default value. mutating func clearFor() {self._for = nil} @@ -3582,17 +3122,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _for: Int32? = nil } - struct guardMessage { + struct guardMessage: Sendable { // 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 `guard`: Int32 { - get {return _guard ?? 0} + get {_guard ?? 0} set {_guard = newValue} } /// Returns true if ``guard`` has been explicitly set. - var hasGuard: Bool {return self._guard != nil} + var hasGuard: Bool {self._guard != nil} /// Clears the value of ``guard``. Subsequent reads from it will return its default value. mutating func clearGuard() {self._guard = nil} @@ -3603,17 +3143,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _guard: Int32? = nil } - struct ifMessage { + struct ifMessage: Sendable { // 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 `if`: Int32 { - get {return _if ?? 0} + get {_if ?? 0} set {_if = newValue} } /// Returns true if ``if`` has been explicitly set. - var hasIf: Bool {return self._if != nil} + var hasIf: Bool {self._if != nil} /// Clears the value of ``if``. Subsequent reads from it will return its default value. mutating func clearIf() {self._if = nil} @@ -3624,17 +3164,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _if: Int32? = nil } - struct inMessage { + struct inMessage: Sendable { // 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 `in`: Int32 { - get {return _in ?? 0} + get {_in ?? 0} set {_in = newValue} } /// Returns true if ``in`` has been explicitly set. - var hasIn: Bool {return self._in != nil} + var hasIn: Bool {self._in != nil} /// Clears the value of ``in``. Subsequent reads from it will return its default value. mutating func clearIn() {self._in = nil} @@ -3645,17 +3185,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _in: Int32? = nil } - struct repeatMessage { + struct repeatMessage: Sendable { // 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 `repeat`: Int32 { - get {return _repeat ?? 0} + get {_repeat ?? 0} set {_repeat = newValue} } /// Returns true if ``repeat`` has been explicitly set. - var hasRepeat: Bool {return self._repeat != nil} + var hasRepeat: Bool {self._repeat != nil} /// Clears the value of ``repeat``. Subsequent reads from it will return its default value. mutating func clearRepeat() {self._repeat = nil} @@ -3666,17 +3206,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _repeat: Int32? = nil } - struct returnMessage { + struct returnMessage: Sendable { // 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 `return`: Int32 { - get {return _return ?? 0} + get {_return ?? 0} set {_return = newValue} } /// Returns true if ``return`` has been explicitly set. - var hasReturn: Bool {return self._return != nil} + var hasReturn: Bool {self._return != nil} /// Clears the value of ``return``. Subsequent reads from it will return its default value. mutating func clearReturn() {self._return = nil} @@ -3687,17 +3227,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _return: Int32? = nil } - struct switchMessage { + struct switchMessage: Sendable { // 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 `switch`: Int32 { - get {return _switch ?? 0} + get {_switch ?? 0} set {_switch = newValue} } /// Returns true if ``switch`` has been explicitly set. - var hasSwitch: Bool {return self._switch != nil} + var hasSwitch: Bool {self._switch != nil} /// Clears the value of ``switch``. Subsequent reads from it will return its default value. mutating func clearSwitch() {self._switch = nil} @@ -3708,17 +3248,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _switch: Int32? = nil } - struct whereMessage { + struct whereMessage: Sendable { // 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 `where`: Int32 { - get {return _where ?? 0} + get {_where ?? 0} set {_where = newValue} } /// Returns true if ``where`` has been explicitly set. - var hasWhere: Bool {return self._where != nil} + var hasWhere: Bool {self._where != nil} /// Clears the value of ``where``. Subsequent reads from it will return its default value. mutating func clearWhere() {self._where = nil} @@ -3729,17 +3269,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _where: Int32? = nil } - struct whileMessage { + struct whileMessage: Sendable { // 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 `while`: Int32 { - get {return _while ?? 0} + get {_while ?? 0} set {_while = newValue} } /// Returns true if ``while`` has been explicitly set. - var hasWhile: Bool {return self._while != nil} + var hasWhile: Bool {self._while != nil} /// Clears the value of ``while``. Subsequent reads from it will return its default value. mutating func clearWhile() {self._while = nil} @@ -3750,17 +3290,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _while: Int32? = nil } - struct asMessage { + struct asMessage: Sendable { // 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 `as`: Int32 { - get {return _as ?? 0} + get {_as ?? 0} set {_as = newValue} } /// Returns true if ``as`` has been explicitly set. - var hasAs: Bool {return self._as != nil} + var hasAs: Bool {self._as != nil} /// Clears the value of ``as``. Subsequent reads from it will return its default value. mutating func clearAs() {self._as = nil} @@ -3771,17 +3311,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _as: Int32? = nil } - struct catchMessage { + struct catchMessage: Sendable { // 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 `catch`: Int32 { - get {return _catch ?? 0} + get {_catch ?? 0} set {_catch = newValue} } /// Returns true if ``catch`` has been explicitly set. - var hasCatch: Bool {return self._catch != nil} + var hasCatch: Bool {self._catch != nil} /// Clears the value of ``catch``. Subsequent reads from it will return its default value. mutating func clearCatch() {self._catch = nil} @@ -3792,17 +3332,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _catch: Int32? = nil } - struct dynamicTypeMessage { + struct dynamicTypeMessage: Sendable { // 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 dynamicType_p: Int32 { - get {return _dynamicType_p ?? 0} + get {_dynamicType_p ?? 0} set {_dynamicType_p = newValue} } /// Returns true if `dynamicType_p` has been explicitly set. - var hasDynamicType_p: Bool {return self._dynamicType_p != nil} + var hasDynamicType_p: Bool {self._dynamicType_p != nil} /// Clears the value of `dynamicType_p`. Subsequent reads from it will return its default value. mutating func clearDynamicType_p() {self._dynamicType_p = nil} @@ -3813,17 +3353,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _dynamicType_p: Int32? = nil } - struct falseMessage { + struct falseMessage: Sendable { // 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 `false`: Int32 { - get {return _false ?? 0} + get {_false ?? 0} set {_false = newValue} } /// Returns true if ``false`` has been explicitly set. - var hasFalse: Bool {return self._false != nil} + var hasFalse: Bool {self._false != nil} /// Clears the value of ``false``. Subsequent reads from it will return its default value. mutating func clearFalse() {self._false = nil} @@ -3834,17 +3374,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _false: Int32? = nil } - struct isMessage { + struct isMessage: Sendable { // 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 `is`: Int32 { - get {return _is ?? 0} + get {_is ?? 0} set {_is = newValue} } /// Returns true if ``is`` has been explicitly set. - var hasIs: Bool {return self._is != nil} + var hasIs: Bool {self._is != nil} /// Clears the value of ``is``. Subsequent reads from it will return its default value. mutating func clearIs() {self._is = nil} @@ -3855,17 +3395,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _is: Int32? = nil } - struct nilMessage { + struct nilMessage: Sendable { // 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 `nil`: Int32 { - get {return _nil ?? 0} + get {_nil ?? 0} set {_nil = newValue} } /// Returns true if ``nil`` has been explicitly set. - var hasNil: Bool {return self._nil != nil} + var hasNil: Bool {self._nil != nil} /// Clears the value of ``nil``. Subsequent reads from it will return its default value. mutating func clearNil() {self._nil = nil} @@ -3876,17 +3416,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _nil: Int32? = nil } - struct rethrowsMessage { + struct rethrowsMessage: Sendable { // 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 `rethrows`: Int32 { - get {return _rethrows ?? 0} + get {_rethrows ?? 0} set {_rethrows = newValue} } /// Returns true if ``rethrows`` has been explicitly set. - var hasRethrows: Bool {return self._rethrows != nil} + var hasRethrows: Bool {self._rethrows != nil} /// Clears the value of ``rethrows``. Subsequent reads from it will return its default value. mutating func clearRethrows() {self._rethrows = nil} @@ -3897,17 +3437,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _rethrows: Int32? = nil } - struct superMessage { + struct superMessage: Sendable { // 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 `super`: Int32 { - get {return _super ?? 0} + get {_super ?? 0} set {_super = newValue} } /// Returns true if ``super`` has been explicitly set. - var hasSuper: Bool {return self._super != nil} + var hasSuper: Bool {self._super != nil} /// Clears the value of ``super``. Subsequent reads from it will return its default value. mutating func clearSuper() {self._super = nil} @@ -3918,17 +3458,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _super: Int32? = nil } - struct selfMessage { + struct selfMessage: Sendable { // 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 self_p: Int32 { - get {return _self_p ?? 0} + get {_self_p ?? 0} set {_self_p = newValue} } /// Returns true if `self_p` has been explicitly set. - var hasSelf_p: Bool {return self._self_p != nil} + var hasSelf_p: Bool {self._self_p != nil} /// Clears the value of `self_p`. Subsequent reads from it will return its default value. mutating func clearSelf_p() {self._self_p = nil} @@ -3939,17 +3479,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _self_p: Int32? = nil } - struct throwMessage { + struct throwMessage: Sendable { // 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 `throw`: Int32 { - get {return _throw ?? 0} + get {_throw ?? 0} set {_throw = newValue} } /// Returns true if ``throw`` has been explicitly set. - var hasThrow: Bool {return self._throw != nil} + var hasThrow: Bool {self._throw != nil} /// Clears the value of ``throw``. Subsequent reads from it will return its default value. mutating func clearThrow() {self._throw = nil} @@ -3960,17 +3500,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _throw: Int32? = nil } - struct throwsMessage { + struct throwsMessage: Sendable { // 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 `throws`: Int32 { - get {return _throws ?? 0} + get {_throws ?? 0} set {_throws = newValue} } /// Returns true if ``throws`` has been explicitly set. - var hasThrows: Bool {return self._throws != nil} + var hasThrows: Bool {self._throws != nil} /// Clears the value of ``throws``. Subsequent reads from it will return its default value. mutating func clearThrows() {self._throws = nil} @@ -3981,17 +3521,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _throws: Int32? = nil } - struct trueMessage { + struct trueMessage: Sendable { // 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 `true`: Int32 { - get {return _true ?? 0} + get {_true ?? 0} set {_true = newValue} } /// Returns true if ``true`` has been explicitly set. - var hasTrue: Bool {return self._true != nil} + var hasTrue: Bool {self._true != nil} /// Clears the value of ``true``. Subsequent reads from it will return its default value. mutating func clearTrue() {self._true = nil} @@ -4002,17 +3542,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _true: Int32? = nil } - struct tryMessage { + struct tryMessage: Sendable { // 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 `try`: Int32 { - get {return _try ?? 0} + get {_try ?? 0} set {_try = newValue} } /// Returns true if ``try`` has been explicitly set. - var hasTry: Bool {return self._try != nil} + var hasTry: Bool {self._try != nil} /// Clears the value of ``try``. Subsequent reads from it will return its default value. mutating func clearTry() {self._try = nil} @@ -4023,17 +3563,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _try: Int32? = nil } - struct __COLUMN__Message { + struct __COLUMN__Message: Sendable { // 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 _Column__: Int32 { - get {return __Column__ ?? 0} + get {__Column__ ?? 0} set {__Column__ = newValue} } /// Returns true if `_Column__` has been explicitly set. - var has_Column__: Bool {return self.__Column__ != nil} + var has_Column__: Bool {self.__Column__ != nil} /// Clears the value of `_Column__`. Subsequent reads from it will return its default value. mutating func clear_Column__() {self.__Column__ = nil} @@ -4044,17 +3584,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var __Column__: Int32? = nil } - struct __FILE__Message { + struct __FILE__Message: Sendable { // 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 _File__: Int32 { - get {return __File__ ?? 0} + get {__File__ ?? 0} set {__File__ = newValue} } /// Returns true if `_File__` has been explicitly set. - var has_File__: Bool {return self.__File__ != nil} + var has_File__: Bool {self.__File__ != nil} /// Clears the value of `_File__`. Subsequent reads from it will return its default value. mutating func clear_File__() {self.__File__ = nil} @@ -4065,17 +3605,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var __File__: Int32? = nil } - struct __FUNCTION__Message { + struct __FUNCTION__Message: Sendable { // 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 _Function__: Int32 { - get {return __Function__ ?? 0} + get {__Function__ ?? 0} set {__Function__ = newValue} } /// Returns true if `_Function__` has been explicitly set. - var has_Function__: Bool {return self.__Function__ != nil} + var has_Function__: Bool {self.__Function__ != nil} /// Clears the value of `_Function__`. Subsequent reads from it will return its default value. mutating func clear_Function__() {self.__Function__ = nil} @@ -4086,17 +3626,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var __Function__: Int32? = nil } - struct __LINE__Message { + struct __LINE__Message: Sendable { // 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 _Line__: Int32 { - get {return __Line__ ?? 0} + get {__Line__ ?? 0} set {__Line__ = newValue} } /// Returns true if `_Line__` has been explicitly set. - var has_Line__: Bool {return self.__Line__ != nil} + var has_Line__: Bool {self.__Line__ != nil} /// Clears the value of `_Line__`. Subsequent reads from it will return its default value. mutating func clear_Line__() {self.__Line__ = nil} @@ -4107,17 +3647,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var __Line__: Int32? = nil } - struct _Message { + struct _Message: Sendable { // 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 ___: Int32 { - get {return ____ ?? 0} + get {____ ?? 0} set {____ = newValue} } /// Returns true if `___` has been explicitly set. - var has___: Bool {return self.____ != nil} + var has___: Bool {self.____ != nil} /// Clears the value of `___`. Subsequent reads from it will return its default value. mutating func clear___() {self.____ = nil} @@ -4128,17 +3668,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var ____: Int32? = nil } - struct __Message { + struct __Message: Sendable { // 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 ____: Int32 { - get {return _____ ?? 0} + get {_____ ?? 0} set {_____ = newValue} } /// Returns true if `____` has been explicitly set. - var has____: Bool {return self._____ != nil} + var has____: Bool {self._____ != nil} /// Clears the value of `____`. Subsequent reads from it will return its default value. mutating func clear____() {self._____ = nil} @@ -4149,17 +3689,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _____: Int32? = nil } - struct associativity { + struct associativity: Sendable { // 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 associativity: Int32 { - get {return _associativity ?? 0} + get {_associativity ?? 0} set {_associativity = newValue} } /// Returns true if `associativity` has been explicitly set. - var hasAssociativity: Bool {return self._associativity != nil} + var hasAssociativity: Bool {self._associativity != nil} /// Clears the value of `associativity`. Subsequent reads from it will return its default value. mutating func clearAssociativity() {self._associativity = nil} @@ -4170,17 +3710,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _associativity: Int32? = nil } - struct convenience { + struct convenience: Sendable { // 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 convenience: Int32 { - get {return _convenience ?? 0} + get {_convenience ?? 0} set {_convenience = newValue} } /// Returns true if `convenience` has been explicitly set. - var hasConvenience: Bool {return self._convenience != nil} + var hasConvenience: Bool {self._convenience != nil} /// Clears the value of `convenience`. Subsequent reads from it will return its default value. mutating func clearConvenience() {self._convenience = nil} @@ -4191,17 +3731,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _convenience: Int32? = nil } - struct dynamic { + struct dynamic: Sendable { // 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 dynamic: Int32 { - get {return _dynamic ?? 0} + get {_dynamic ?? 0} set {_dynamic = newValue} } /// Returns true if `dynamic` has been explicitly set. - var hasDynamic: Bool {return self._dynamic != nil} + var hasDynamic: Bool {self._dynamic != nil} /// Clears the value of `dynamic`. Subsequent reads from it will return its default value. mutating func clearDynamic() {self._dynamic = nil} @@ -4212,17 +3752,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _dynamic: Int32? = nil } - struct didSet { + struct didSet: Sendable { // 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 didSet: Int32 { - get {return _didSet ?? 0} + get {_didSet ?? 0} set {_didSet = newValue} } /// Returns true if `didSet` has been explicitly set. - var hasDidSet: Bool {return self._didSet != nil} + var hasDidSet: Bool {self._didSet != nil} /// Clears the value of `didSet`. Subsequent reads from it will return its default value. mutating func clearDidSet() {self._didSet = nil} @@ -4233,17 +3773,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _didSet: Int32? = nil } - struct final { + struct final: Sendable { // 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 final: Int32 { - get {return _final ?? 0} + get {_final ?? 0} set {_final = newValue} } /// Returns true if `final` has been explicitly set. - var hasFinal: Bool {return self._final != nil} + var hasFinal: Bool {self._final != nil} /// Clears the value of `final`. Subsequent reads from it will return its default value. mutating func clearFinal() {self._final = nil} @@ -4254,17 +3794,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _final: Int32? = nil } - struct get { + struct get: Sendable { // 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 get: Int32 { - get {return _get ?? 0} + get {_get ?? 0} set {_get = newValue} } /// Returns true if `get` has been explicitly set. - var hasGet: Bool {return self._get != nil} + var hasGet: Bool {self._get != nil} /// Clears the value of `get`. Subsequent reads from it will return its default value. mutating func clearGet() {self._get = nil} @@ -4275,17 +3815,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _get: Int32? = nil } - struct infix { + struct infix: Sendable { // 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 infix: Int32 { - get {return _infix ?? 0} + get {_infix ?? 0} set {_infix = newValue} } /// Returns true if `infix` has been explicitly set. - var hasInfix: Bool {return self._infix != nil} + var hasInfix: Bool {self._infix != nil} /// Clears the value of `infix`. Subsequent reads from it will return its default value. mutating func clearInfix() {self._infix = nil} @@ -4296,17 +3836,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _infix: Int32? = nil } - struct indirect { + struct indirect: Sendable { // 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 indirect: Int32 { - get {return _indirect ?? 0} + get {_indirect ?? 0} set {_indirect = newValue} } /// Returns true if `indirect` has been explicitly set. - var hasIndirect: Bool {return self._indirect != nil} + var hasIndirect: Bool {self._indirect != nil} /// Clears the value of `indirect`. Subsequent reads from it will return its default value. mutating func clearIndirect() {self._indirect = nil} @@ -4317,17 +3857,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _indirect: Int32? = nil } - struct lazy { + struct lazy: Sendable { // 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 lazy: Int32 { - get {return _lazy ?? 0} + get {_lazy ?? 0} set {_lazy = newValue} } /// Returns true if `lazy` has been explicitly set. - var hasLazy: Bool {return self._lazy != nil} + var hasLazy: Bool {self._lazy != nil} /// Clears the value of `lazy`. Subsequent reads from it will return its default value. mutating func clearLazy() {self._lazy = nil} @@ -4338,17 +3878,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _lazy: Int32? = nil } - struct left { + struct left: Sendable { // 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: Int32 { - get {return _left ?? 0} + get {_left ?? 0} set {_left = newValue} } /// Returns true if `left` has been explicitly set. - var hasLeft: Bool {return self._left != nil} + var hasLeft: Bool {self._left != nil} /// Clears the value of `left`. Subsequent reads from it will return its default value. mutating func clearLeft() {self._left = nil} @@ -4359,17 +3899,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _left: Int32? = nil } - struct mutating { + struct mutating: Sendable { // 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 mutating: Int32 { - get {return _mutating ?? 0} + get {_mutating ?? 0} set {_mutating = newValue} } /// Returns true if `mutating` has been explicitly set. - var hasMutating: Bool {return self._mutating != nil} + var hasMutating: Bool {self._mutating != nil} /// Clears the value of `mutating`. Subsequent reads from it will return its default value. mutating func clearMutating() {self._mutating = nil} @@ -4380,17 +3920,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _mutating: Int32? = nil } - struct none { + struct none: Sendable { // 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 none: Int32 { - get {return _none ?? 0} + get {_none ?? 0} set {_none = newValue} } /// Returns true if `none` has been explicitly set. - var hasNone: Bool {return self._none != nil} + var hasNone: Bool {self._none != nil} /// Clears the value of `none`. Subsequent reads from it will return its default value. mutating func clearNone() {self._none = nil} @@ -4401,17 +3941,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _none: Int32? = nil } - struct nonmutating { + struct nonmutating: Sendable { // 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 nonmutating: Int32 { - get {return _nonmutating ?? 0} + get {_nonmutating ?? 0} set {_nonmutating = newValue} } /// Returns true if `nonmutating` has been explicitly set. - var hasNonmutating: Bool {return self._nonmutating != nil} + var hasNonmutating: Bool {self._nonmutating != nil} /// Clears the value of `nonmutating`. Subsequent reads from it will return its default value. mutating func clearNonmutating() {self._nonmutating = nil} @@ -4422,17 +3962,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _nonmutating: Int32? = nil } - struct optional { + struct optional: Sendable { // 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 optional: Int32 { - get {return _optional ?? 0} + get {_optional ?? 0} set {_optional = newValue} } /// Returns true if `optional` has been explicitly set. - var hasOptional: Bool {return self._optional != nil} + var hasOptional: Bool {self._optional != nil} /// Clears the value of `optional`. Subsequent reads from it will return its default value. mutating func clearOptional() {self._optional = nil} @@ -4443,17 +3983,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _optional: Int32? = nil } - struct override { + struct override: Sendable { // 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 override: Int32 { - get {return _override ?? 0} + get {_override ?? 0} set {_override = newValue} } /// Returns true if `override` has been explicitly set. - var hasOverride: Bool {return self._override != nil} + var hasOverride: Bool {self._override != nil} /// Clears the value of `override`. Subsequent reads from it will return its default value. mutating func clearOverride() {self._override = nil} @@ -4464,17 +4004,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _override: Int32? = nil } - struct postfix { + struct postfix: Sendable { // 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 postfix: Int32 { - get {return _postfix ?? 0} + get {_postfix ?? 0} set {_postfix = newValue} } /// Returns true if `postfix` has been explicitly set. - var hasPostfix: Bool {return self._postfix != nil} + var hasPostfix: Bool {self._postfix != nil} /// Clears the value of `postfix`. Subsequent reads from it will return its default value. mutating func clearPostfix() {self._postfix = nil} @@ -4485,17 +4025,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _postfix: Int32? = nil } - struct precedence { + struct precedence: Sendable { // 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 precedence: Int32 { - get {return _precedence ?? 0} + get {_precedence ?? 0} set {_precedence = newValue} } /// Returns true if `precedence` has been explicitly set. - var hasPrecedence: Bool {return self._precedence != nil} + var hasPrecedence: Bool {self._precedence != nil} /// Clears the value of `precedence`. Subsequent reads from it will return its default value. mutating func clearPrecedence() {self._precedence = nil} @@ -4506,17 +4046,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _precedence: Int32? = nil } - struct prefix { + struct prefix: Sendable { // 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 prefix: Int32 { - get {return _prefix ?? 0} + get {_prefix ?? 0} set {_prefix = newValue} } /// Returns true if `prefix` has been explicitly set. - var hasPrefix: Bool {return self._prefix != nil} + var hasPrefix: Bool {self._prefix != nil} /// Clears the value of `prefix`. Subsequent reads from it will return its default value. mutating func clearPrefix() {self._prefix = nil} @@ -4527,17 +4067,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _prefix: Int32? = nil } - struct required { + struct required: Sendable { // 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 required: Int32 { - get {return _required ?? 0} + get {_required ?? 0} set {_required = newValue} } /// Returns true if `required` has been explicitly set. - var hasRequired: Bool {return self._required != nil} + var hasRequired: Bool {self._required != nil} /// Clears the value of `required`. Subsequent reads from it will return its default value. mutating func clearRequired() {self._required = nil} @@ -4548,17 +4088,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _required: Int32? = nil } - struct right { + struct right: Sendable { // 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 right: Int32 { - get {return _right ?? 0} + get {_right ?? 0} set {_right = newValue} } /// Returns true if `right` has been explicitly set. - var hasRight: Bool {return self._right != nil} + var hasRight: Bool {self._right != nil} /// Clears the value of `right`. Subsequent reads from it will return its default value. mutating func clearRight() {self._right = nil} @@ -4569,17 +4109,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _right: Int32? = nil } - struct set { + struct set: Sendable { // 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 set: Int32 { - get {return _set ?? 0} + get {_set ?? 0} set {_set = newValue} } /// Returns true if `set` has been explicitly set. - var hasSet: Bool {return self._set != nil} + var hasSet: Bool {self._set != nil} /// Clears the value of `set`. Subsequent reads from it will return its default value. mutating func clearSet() {self._set = nil} @@ -4590,17 +4130,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _set: Int32? = nil } - struct TypeMessage { + struct TypeMessage: Sendable { // 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 type: Int32 { - get {return _type ?? 0} + get {_type ?? 0} set {_type = newValue} } /// Returns true if `type` has been explicitly set. - var hasType: Bool {return self._type != nil} + var hasType: Bool {self._type != nil} /// Clears the value of `type`. Subsequent reads from it will return its default value. mutating func clearType() {self._type = nil} @@ -4611,17 +4151,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _type: Int32? = nil } - struct unowned { + struct unowned: Sendable { // 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 unowned: Int32 { - get {return _unowned ?? 0} + get {_unowned ?? 0} set {_unowned = newValue} } /// Returns true if `unowned` has been explicitly set. - var hasUnowned: Bool {return self._unowned != nil} + var hasUnowned: Bool {self._unowned != nil} /// Clears the value of `unowned`. Subsequent reads from it will return its default value. mutating func clearUnowned() {self._unowned = nil} @@ -4632,17 +4172,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _unowned: Int32? = nil } - struct weak { + struct weak: Sendable { // 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 weak: Int32 { - get {return _weak ?? 0} + get {_weak ?? 0} set {_weak = newValue} } /// Returns true if `weak` has been explicitly set. - var hasWeak: Bool {return self._weak != nil} + var hasWeak: Bool {self._weak != nil} /// Clears the value of `weak`. Subsequent reads from it will return its default value. mutating func clearWeak() {self._weak = nil} @@ -4653,17 +4193,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _weak: Int32? = nil } - struct willSet { + struct willSet: Sendable { // 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 willSet: Int32 { - get {return _willSet ?? 0} + get {_willSet ?? 0} set {_willSet = newValue} } /// Returns true if `willSet` has been explicitly set. - var hasWillSet: Bool {return self._willSet != nil} + var hasWillSet: Bool {self._willSet != nil} /// Clears the value of `willSet`. Subsequent reads from it will return its default value. mutating func clearWillSet() {self._willSet = nil} @@ -4674,17 +4214,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _willSet: Int32? = nil } - struct id { + struct id: Sendable { // 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 id: Int32 { - get {return _id ?? 0} + get {_id ?? 0} set {_id = newValue} } /// Returns true if `id` has been explicitly set. - var hasID: Bool {return self._id != nil} + var hasID: Bool {self._id != nil} /// Clears the value of `id`. Subsequent reads from it will return its default value. mutating func clearID() {self._id = nil} @@ -4695,17 +4235,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _id: Int32? = nil } - struct _cmd { + struct _cmd: Sendable { // 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 cmd: Int32 { - get {return _cmd ?? 0} + get {_cmd ?? 0} set {_cmd = newValue} } /// Returns true if `cmd` has been explicitly set. - var hasCmd: Bool {return self._cmd != nil} + var hasCmd: Bool {self._cmd != nil} /// Clears the value of `cmd`. Subsequent reads from it will return its default value. mutating func clearCmd() {self._cmd = nil} @@ -4716,17 +4256,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _cmd: Int32? = nil } - struct out { + struct out: Sendable { // 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 out: Int32 { - get {return _out ?? 0} + get {_out ?? 0} set {_out = newValue} } /// Returns true if `out` has been explicitly set. - var hasOut: Bool {return self._out != nil} + var hasOut: Bool {self._out != nil} /// Clears the value of `out`. Subsequent reads from it will return its default value. mutating func clearOut() {self._out = nil} @@ -4737,17 +4277,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _out: Int32? = nil } - struct bycopy { + struct bycopy: Sendable { // 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 bycopy: Int32 { - get {return _bycopy ?? 0} + get {_bycopy ?? 0} set {_bycopy = newValue} } /// Returns true if `bycopy` has been explicitly set. - var hasBycopy: Bool {return self._bycopy != nil} + var hasBycopy: Bool {self._bycopy != nil} /// Clears the value of `bycopy`. Subsequent reads from it will return its default value. mutating func clearBycopy() {self._bycopy = nil} @@ -4758,17 +4298,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _bycopy: Int32? = nil } - struct byref { + struct byref: Sendable { // 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 byref: Int32 { - get {return _byref ?? 0} + get {_byref ?? 0} set {_byref = newValue} } /// Returns true if `byref` has been explicitly set. - var hasByref: Bool {return self._byref != nil} + var hasByref: Bool {self._byref != nil} /// Clears the value of `byref`. Subsequent reads from it will return its default value. mutating func clearByref() {self._byref = nil} @@ -4779,17 +4319,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _byref: Int32? = nil } - struct oneway { + struct oneway: Sendable { // 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 oneway: Int32 { - get {return _oneway ?? 0} + get {_oneway ?? 0} set {_oneway = newValue} } /// Returns true if `oneway` has been explicitly set. - var hasOneway: Bool {return self._oneway != nil} + var hasOneway: Bool {self._oneway != nil} /// Clears the value of `oneway`. Subsequent reads from it will return its default value. mutating func clearOneway() {self._oneway = nil} @@ -4800,17 +4340,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _oneway: Int32? = nil } - struct and { + struct and: Sendable { // 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 and: Int32 { - get {return _and ?? 0} + get {_and ?? 0} set {_and = newValue} } /// Returns true if `and` has been explicitly set. - var hasAnd: Bool {return self._and != nil} + var hasAnd: Bool {self._and != nil} /// Clears the value of `and`. Subsequent reads from it will return its default value. mutating func clearAnd() {self._and = nil} @@ -4821,17 +4361,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _and: Int32? = nil } - struct and_eq { + struct and_eq: Sendable { // 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 andEq: Int32 { - get {return _andEq ?? 0} + get {_andEq ?? 0} set {_andEq = newValue} } /// Returns true if `andEq` has been explicitly set. - var hasAndEq: Bool {return self._andEq != nil} + var hasAndEq: Bool {self._andEq != nil} /// Clears the value of `andEq`. Subsequent reads from it will return its default value. mutating func clearAndEq() {self._andEq = nil} @@ -4842,17 +4382,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _andEq: Int32? = nil } - struct alignas { + struct alignas: Sendable { // 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 alignas: Int32 { - get {return _alignas ?? 0} + get {_alignas ?? 0} set {_alignas = newValue} } /// Returns true if `alignas` has been explicitly set. - var hasAlignas: Bool {return self._alignas != nil} + var hasAlignas: Bool {self._alignas != nil} /// Clears the value of `alignas`. Subsequent reads from it will return its default value. mutating func clearAlignas() {self._alignas = nil} @@ -4863,17 +4403,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _alignas: Int32? = nil } - struct alignof { + struct alignof: Sendable { // 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 alignof: Int32 { - get {return _alignof ?? 0} + get {_alignof ?? 0} set {_alignof = newValue} } /// Returns true if `alignof` has been explicitly set. - var hasAlignof: Bool {return self._alignof != nil} + var hasAlignof: Bool {self._alignof != nil} /// Clears the value of `alignof`. Subsequent reads from it will return its default value. mutating func clearAlignof() {self._alignof = nil} @@ -4884,17 +4424,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _alignof: Int32? = nil } - struct asm { + struct asm: Sendable { // 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 asm: Int32 { - get {return _asm ?? 0} + get {_asm ?? 0} set {_asm = newValue} } /// Returns true if `asm` has been explicitly set. - var hasAsm: Bool {return self._asm != nil} + var hasAsm: Bool {self._asm != nil} /// Clears the value of `asm`. Subsequent reads from it will return its default value. mutating func clearAsm() {self._asm = nil} @@ -4905,17 +4445,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _asm: Int32? = nil } - struct auto { + struct auto: Sendable { // 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 auto: Int32 { - get {return _auto ?? 0} + get {_auto ?? 0} set {_auto = newValue} } /// Returns true if `auto` has been explicitly set. - var hasAuto: Bool {return self._auto != nil} + var hasAuto: Bool {self._auto != nil} /// Clears the value of `auto`. Subsequent reads from it will return its default value. mutating func clearAuto() {self._auto = nil} @@ -4926,17 +4466,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _auto: Int32? = nil } - struct bitand { + struct bitand: Sendable { // 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 bitand: Int32 { - get {return _bitand ?? 0} + get {_bitand ?? 0} set {_bitand = newValue} } /// Returns true if `bitand` has been explicitly set. - var hasBitand: Bool {return self._bitand != nil} + var hasBitand: Bool {self._bitand != nil} /// Clears the value of `bitand`. Subsequent reads from it will return its default value. mutating func clearBitand() {self._bitand = nil} @@ -4947,17 +4487,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _bitand: Int32? = nil } - struct bitor { + struct bitor: Sendable { // 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 bitor: Int32 { - get {return _bitor ?? 0} + get {_bitor ?? 0} set {_bitor = newValue} } /// Returns true if `bitor` has been explicitly set. - var hasBitor: Bool {return self._bitor != nil} + var hasBitor: Bool {self._bitor != nil} /// Clears the value of `bitor`. Subsequent reads from it will return its default value. mutating func clearBitor() {self._bitor = nil} @@ -4968,17 +4508,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _bitor: Int32? = nil } - struct bool { + struct bool: Sendable { // 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 bool: Int32 { - get {return _bool ?? 0} + get {_bool ?? 0} set {_bool = newValue} } /// Returns true if `bool` has been explicitly set. - var hasBool: Bool {return self._bool != nil} + var hasBool: Bool {self._bool != nil} /// Clears the value of `bool`. Subsequent reads from it will return its default value. mutating func clearBool() {self._bool = nil} @@ -4989,17 +4529,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _bool: Int32? = nil } - struct char { + struct char: Sendable { // 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 char: Int32 { - get {return _char ?? 0} + get {_char ?? 0} set {_char = newValue} } /// Returns true if `char` has been explicitly set. - var hasChar: Bool {return self._char != nil} + var hasChar: Bool {self._char != nil} /// Clears the value of `char`. Subsequent reads from it will return its default value. mutating func clearChar() {self._char = nil} @@ -5010,17 +4550,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _char: Int32? = nil } - struct char16_t { + struct char16_t: Sendable { // 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 char16T: Int32 { - get {return _char16T ?? 0} + get {_char16T ?? 0} set {_char16T = newValue} } /// Returns true if `char16T` has been explicitly set. - var hasChar16T: Bool {return self._char16T != nil} + var hasChar16T: Bool {self._char16T != nil} /// Clears the value of `char16T`. Subsequent reads from it will return its default value. mutating func clearChar16T() {self._char16T = nil} @@ -5031,17 +4571,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _char16T: Int32? = nil } - struct char32_t { + struct char32_t: Sendable { // 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 char32T: Int32 { - get {return _char32T ?? 0} + get {_char32T ?? 0} set {_char32T = newValue} } /// Returns true if `char32T` has been explicitly set. - var hasChar32T: Bool {return self._char32T != nil} + var hasChar32T: Bool {self._char32T != nil} /// Clears the value of `char32T`. Subsequent reads from it will return its default value. mutating func clearChar32T() {self._char32T = nil} @@ -5052,17 +4592,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _char32T: Int32? = nil } - struct compl { + struct compl: Sendable { // 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 compl: Int32 { - get {return _compl ?? 0} + get {_compl ?? 0} set {_compl = newValue} } /// Returns true if `compl` has been explicitly set. - var hasCompl: Bool {return self._compl != nil} + var hasCompl: Bool {self._compl != nil} /// Clears the value of `compl`. Subsequent reads from it will return its default value. mutating func clearCompl() {self._compl = nil} @@ -5073,17 +4613,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _compl: Int32? = nil } - struct const { + struct const: Sendable { // 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 const: Int32 { - get {return _const ?? 0} + get {_const ?? 0} set {_const = newValue} } /// Returns true if `const` has been explicitly set. - var hasConst: Bool {return self._const != nil} + var hasConst: Bool {self._const != nil} /// Clears the value of `const`. Subsequent reads from it will return its default value. mutating func clearConst() {self._const = nil} @@ -5094,17 +4634,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _const: Int32? = nil } - struct constexpr { + struct constexpr: Sendable { // 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 constexpr: Int32 { - get {return _constexpr ?? 0} + get {_constexpr ?? 0} set {_constexpr = newValue} } /// Returns true if `constexpr` has been explicitly set. - var hasConstexpr: Bool {return self._constexpr != nil} + var hasConstexpr: Bool {self._constexpr != nil} /// Clears the value of `constexpr`. Subsequent reads from it will return its default value. mutating func clearConstexpr() {self._constexpr = nil} @@ -5115,17 +4655,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _constexpr: Int32? = nil } - struct const_cast { + struct const_cast: Sendable { // 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 constCast: Int32 { - get {return _constCast ?? 0} + get {_constCast ?? 0} set {_constCast = newValue} } /// Returns true if `constCast` has been explicitly set. - var hasConstCast: Bool {return self._constCast != nil} + var hasConstCast: Bool {self._constCast != nil} /// Clears the value of `constCast`. Subsequent reads from it will return its default value. mutating func clearConstCast() {self._constCast = nil} @@ -5136,17 +4676,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _constCast: Int32? = nil } - struct decltype { + struct decltype: Sendable { // 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 decltype: Int32 { - get {return _decltype ?? 0} + get {_decltype ?? 0} set {_decltype = newValue} } /// Returns true if `decltype` has been explicitly set. - var hasDecltype: Bool {return self._decltype != nil} + var hasDecltype: Bool {self._decltype != nil} /// Clears the value of `decltype`. Subsequent reads from it will return its default value. mutating func clearDecltype() {self._decltype = nil} @@ -5157,17 +4697,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _decltype: Int32? = nil } - struct delete { + struct delete: Sendable { // 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 delete: Int32 { - get {return _delete ?? 0} + get {_delete ?? 0} set {_delete = newValue} } /// Returns true if `delete` has been explicitly set. - var hasDelete: Bool {return self._delete != nil} + var hasDelete: Bool {self._delete != nil} /// Clears the value of `delete`. Subsequent reads from it will return its default value. mutating func clearDelete() {self._delete = nil} @@ -5178,17 +4718,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _delete: Int32? = nil } - struct dynamic_cast { + struct dynamic_cast: Sendable { // 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 dynamicCast: Int32 { - get {return _dynamicCast ?? 0} + get {_dynamicCast ?? 0} set {_dynamicCast = newValue} } /// Returns true if `dynamicCast` has been explicitly set. - var hasDynamicCast: Bool {return self._dynamicCast != nil} + var hasDynamicCast: Bool {self._dynamicCast != nil} /// Clears the value of `dynamicCast`. Subsequent reads from it will return its default value. mutating func clearDynamicCast() {self._dynamicCast = nil} @@ -5199,17 +4739,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _dynamicCast: Int32? = nil } - struct explicit { + struct explicit: Sendable { // 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 explicit: Int32 { - get {return _explicit ?? 0} + get {_explicit ?? 0} set {_explicit = newValue} } /// Returns true if `explicit` has been explicitly set. - var hasExplicit: Bool {return self._explicit != nil} + var hasExplicit: Bool {self._explicit != nil} /// Clears the value of `explicit`. Subsequent reads from it will return its default value. mutating func clearExplicit() {self._explicit = nil} @@ -5220,17 +4760,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _explicit: Int32? = nil } - struct export { + struct export: Sendable { // 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 export: Int32 { - get {return _export ?? 0} + get {_export ?? 0} set {_export = newValue} } /// Returns true if `export` has been explicitly set. - var hasExport: Bool {return self._export != nil} + var hasExport: Bool {self._export != nil} /// Clears the value of `export`. Subsequent reads from it will return its default value. mutating func clearExport() {self._export = nil} @@ -5241,17 +4781,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _export: Int32? = nil } - struct extern { + struct extern: Sendable { // 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 extern: Int32 { - get {return _extern ?? 0} + get {_extern ?? 0} set {_extern = newValue} } /// Returns true if `extern` has been explicitly set. - var hasExtern: Bool {return self._extern != nil} + var hasExtern: Bool {self._extern != nil} /// Clears the value of `extern`. Subsequent reads from it will return its default value. mutating func clearExtern() {self._extern = nil} @@ -5262,17 +4802,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _extern: Int32? = nil } - struct friend { + struct friend: Sendable { // 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 friend: Int32 { - get {return _friend ?? 0} + get {_friend ?? 0} set {_friend = newValue} } /// Returns true if `friend` has been explicitly set. - var hasFriend: Bool {return self._friend != nil} + var hasFriend: Bool {self._friend != nil} /// Clears the value of `friend`. Subsequent reads from it will return its default value. mutating func clearFriend() {self._friend = nil} @@ -5283,17 +4823,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _friend: Int32? = nil } - struct goto { + struct goto: Sendable { // 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 goto: Int32 { - get {return _goto ?? 0} + get {_goto ?? 0} set {_goto = newValue} } /// Returns true if `goto` has been explicitly set. - var hasGoto: Bool {return self._goto != nil} + var hasGoto: Bool {self._goto != nil} /// Clears the value of `goto`. Subsequent reads from it will return its default value. mutating func clearGoto() {self._goto = nil} @@ -5304,17 +4844,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _goto: Int32? = nil } - struct inline { + struct inline: Sendable { // 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 inline: Int32 { - get {return _inline ?? 0} + get {_inline ?? 0} set {_inline = newValue} } /// Returns true if `inline` has been explicitly set. - var hasInline: Bool {return self._inline != nil} + var hasInline: Bool {self._inline != nil} /// Clears the value of `inline`. Subsequent reads from it will return its default value. mutating func clearInline() {self._inline = nil} @@ -5325,17 +4865,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _inline: Int32? = nil } - struct long { + struct long: Sendable { // 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 long: Int32 { - get {return _long ?? 0} + get {_long ?? 0} set {_long = newValue} } /// Returns true if `long` has been explicitly set. - var hasLong: Bool {return self._long != nil} + var hasLong: Bool {self._long != nil} /// Clears the value of `long`. Subsequent reads from it will return its default value. mutating func clearLong() {self._long = nil} @@ -5346,17 +4886,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _long: Int32? = nil } - struct mutable { + struct mutable: Sendable { // 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 mutable: Int32 { - get {return _mutable ?? 0} + get {_mutable ?? 0} set {_mutable = newValue} } /// Returns true if `mutable` has been explicitly set. - var hasMutable: Bool {return self._mutable != nil} + var hasMutable: Bool {self._mutable != nil} /// Clears the value of `mutable`. Subsequent reads from it will return its default value. mutating func clearMutable() {self._mutable = nil} @@ -5367,17 +4907,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _mutable: Int32? = nil } - struct namespace { + struct namespace: Sendable { // 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 namespace: Int32 { - get {return _namespace ?? 0} + get {_namespace ?? 0} set {_namespace = newValue} } /// Returns true if `namespace` has been explicitly set. - var hasNamespace: Bool {return self._namespace != nil} + var hasNamespace: Bool {self._namespace != nil} /// Clears the value of `namespace`. Subsequent reads from it will return its default value. mutating func clearNamespace() {self._namespace = nil} @@ -5388,17 +4928,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _namespace: Int32? = nil } - struct new { + struct new: Sendable { // 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 new: Int32 { - get {return _new ?? 0} + get {_new ?? 0} set {_new = newValue} } /// Returns true if `new` has been explicitly set. - var hasNew: Bool {return self._new != nil} + var hasNew: Bool {self._new != nil} /// Clears the value of `new`. Subsequent reads from it will return its default value. mutating func clearNew() {self._new = nil} @@ -5409,17 +4949,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _new: Int32? = nil } - struct noexcept { + struct noexcept: Sendable { // 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 noexcept: Int32 { - get {return _noexcept ?? 0} + get {_noexcept ?? 0} set {_noexcept = newValue} } /// Returns true if `noexcept` has been explicitly set. - var hasNoexcept: Bool {return self._noexcept != nil} + var hasNoexcept: Bool {self._noexcept != nil} /// Clears the value of `noexcept`. Subsequent reads from it will return its default value. mutating func clearNoexcept() {self._noexcept = nil} @@ -5430,17 +4970,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _noexcept: Int32? = nil } - struct not { + struct not: Sendable { // 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 not: Int32 { - get {return _not ?? 0} + get {_not ?? 0} set {_not = newValue} } /// Returns true if `not` has been explicitly set. - var hasNot: Bool {return self._not != nil} + var hasNot: Bool {self._not != nil} /// Clears the value of `not`. Subsequent reads from it will return its default value. mutating func clearNot() {self._not = nil} @@ -5451,17 +4991,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _not: Int32? = nil } - struct not_eq { + struct not_eq: Sendable { // 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 notEq: Int32 { - get {return _notEq ?? 0} + get {_notEq ?? 0} set {_notEq = newValue} } /// Returns true if `notEq` has been explicitly set. - var hasNotEq: Bool {return self._notEq != nil} + var hasNotEq: Bool {self._notEq != nil} /// Clears the value of `notEq`. Subsequent reads from it will return its default value. mutating func clearNotEq() {self._notEq = nil} @@ -5472,17 +5012,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _notEq: Int32? = nil } - struct nullptr { + struct nullptr: Sendable { // 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 nullptr: Int32 { - get {return _nullptr ?? 0} + get {_nullptr ?? 0} set {_nullptr = newValue} } /// Returns true if `nullptr` has been explicitly set. - var hasNullptr: Bool {return self._nullptr != nil} + var hasNullptr: Bool {self._nullptr != nil} /// Clears the value of `nullptr`. Subsequent reads from it will return its default value. mutating func clearNullptr() {self._nullptr = nil} @@ -5493,17 +5033,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _nullptr: Int32? = nil } - struct or { + struct or: Sendable { // 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 or: Int32 { - get {return _or ?? 0} + get {_or ?? 0} set {_or = newValue} } /// Returns true if `or` has been explicitly set. - var hasOr: Bool {return self._or != nil} + var hasOr: Bool {self._or != nil} /// Clears the value of `or`. Subsequent reads from it will return its default value. mutating func clearOr() {self._or = nil} @@ -5514,17 +5054,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _or: Int32? = nil } - struct or_eq { + struct or_eq: Sendable { // 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 orEq: Int32 { - get {return _orEq ?? 0} + get {_orEq ?? 0} set {_orEq = newValue} } /// Returns true if `orEq` has been explicitly set. - var hasOrEq: Bool {return self._orEq != nil} + var hasOrEq: Bool {self._orEq != nil} /// Clears the value of `orEq`. Subsequent reads from it will return its default value. mutating func clearOrEq() {self._orEq = nil} @@ -5535,17 +5075,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _orEq: Int32? = nil } - struct protected { + struct protected: Sendable { // 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 protected: Int32 { - get {return _protected ?? 0} + get {_protected ?? 0} set {_protected = newValue} } /// Returns true if `protected` has been explicitly set. - var hasProtected: Bool {return self._protected != nil} + var hasProtected: Bool {self._protected != nil} /// Clears the value of `protected`. Subsequent reads from it will return its default value. mutating func clearProtected() {self._protected = nil} @@ -5556,17 +5096,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _protected: Int32? = nil } - struct register { + struct register: Sendable { // 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 register: Int32 { - get {return _register ?? 0} + get {_register ?? 0} set {_register = newValue} } /// Returns true if `register` has been explicitly set. - var hasRegister: Bool {return self._register != nil} + var hasRegister: Bool {self._register != nil} /// Clears the value of `register`. Subsequent reads from it will return its default value. mutating func clearRegister() {self._register = nil} @@ -5577,17 +5117,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _register: Int32? = nil } - struct reinterpret_cast { + struct reinterpret_cast: Sendable { // 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 reinterpretCast: Int32 { - get {return _reinterpretCast ?? 0} + get {_reinterpretCast ?? 0} set {_reinterpretCast = newValue} } /// Returns true if `reinterpretCast` has been explicitly set. - var hasReinterpretCast: Bool {return self._reinterpretCast != nil} + var hasReinterpretCast: Bool {self._reinterpretCast != nil} /// Clears the value of `reinterpretCast`. Subsequent reads from it will return its default value. mutating func clearReinterpretCast() {self._reinterpretCast = nil} @@ -5598,17 +5138,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _reinterpretCast: Int32? = nil } - struct short { + struct short: Sendable { // 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 short: Int32 { - get {return _short ?? 0} + get {_short ?? 0} set {_short = newValue} } /// Returns true if `short` has been explicitly set. - var hasShort: Bool {return self._short != nil} + var hasShort: Bool {self._short != nil} /// Clears the value of `short`. Subsequent reads from it will return its default value. mutating func clearShort() {self._short = nil} @@ -5619,17 +5159,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _short: Int32? = nil } - struct signed { + struct signed: Sendable { // 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 signed: Int32 { - get {return _signed ?? 0} + get {_signed ?? 0} set {_signed = newValue} } /// Returns true if `signed` has been explicitly set. - var hasSigned: Bool {return self._signed != nil} + var hasSigned: Bool {self._signed != nil} /// Clears the value of `signed`. Subsequent reads from it will return its default value. mutating func clearSigned() {self._signed = nil} @@ -5640,17 +5180,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _signed: Int32? = nil } - struct sizeof { + struct sizeof: Sendable { // 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 sizeof: Int32 { - get {return _sizeof ?? 0} + get {_sizeof ?? 0} set {_sizeof = newValue} } /// Returns true if `sizeof` has been explicitly set. - var hasSizeof: Bool {return self._sizeof != nil} + var hasSizeof: Bool {self._sizeof != nil} /// Clears the value of `sizeof`. Subsequent reads from it will return its default value. mutating func clearSizeof() {self._sizeof = nil} @@ -5661,17 +5201,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _sizeof: Int32? = nil } - struct static_assert { + struct static_assert: Sendable { // 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 staticAssert: Int32 { - get {return _staticAssert ?? 0} + get {_staticAssert ?? 0} set {_staticAssert = newValue} } /// Returns true if `staticAssert` has been explicitly set. - var hasStaticAssert: Bool {return self._staticAssert != nil} + var hasStaticAssert: Bool {self._staticAssert != nil} /// Clears the value of `staticAssert`. Subsequent reads from it will return its default value. mutating func clearStaticAssert() {self._staticAssert = nil} @@ -5682,17 +5222,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _staticAssert: Int32? = nil } - struct static_cast { + struct static_cast: Sendable { // 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 staticCast: Int32 { - get {return _staticCast ?? 0} + get {_staticCast ?? 0} set {_staticCast = newValue} } /// Returns true if `staticCast` has been explicitly set. - var hasStaticCast: Bool {return self._staticCast != nil} + var hasStaticCast: Bool {self._staticCast != nil} /// Clears the value of `staticCast`. Subsequent reads from it will return its default value. mutating func clearStaticCast() {self._staticCast = nil} @@ -5703,17 +5243,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _staticCast: Int32? = nil } - struct template { + struct template: Sendable { // 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 template: Int32 { - get {return _template ?? 0} + get {_template ?? 0} set {_template = newValue} } /// Returns true if `template` has been explicitly set. - var hasTemplate: Bool {return self._template != nil} + var hasTemplate: Bool {self._template != nil} /// Clears the value of `template`. Subsequent reads from it will return its default value. mutating func clearTemplate() {self._template = nil} @@ -5724,17 +5264,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _template: Int32? = nil } - struct this { + struct this: Sendable { // 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 this: Int32 { - get {return _this ?? 0} + get {_this ?? 0} set {_this = newValue} } /// Returns true if `this` has been explicitly set. - var hasThis: Bool {return self._this != nil} + var hasThis: Bool {self._this != nil} /// Clears the value of `this`. Subsequent reads from it will return its default value. mutating func clearThis() {self._this = nil} @@ -5745,17 +5285,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _this: Int32? = nil } - struct thread_local { + struct thread_local: Sendable { // 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 threadLocal: Int32 { - get {return _threadLocal ?? 0} + get {_threadLocal ?? 0} set {_threadLocal = newValue} } /// Returns true if `threadLocal` has been explicitly set. - var hasThreadLocal: Bool {return self._threadLocal != nil} + var hasThreadLocal: Bool {self._threadLocal != nil} /// Clears the value of `threadLocal`. Subsequent reads from it will return its default value. mutating func clearThreadLocal() {self._threadLocal = nil} @@ -5766,17 +5306,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _threadLocal: Int32? = nil } - struct typedef { + struct typedef: Sendable { // 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 typedef: Int32 { - get {return _typedef ?? 0} + get {_typedef ?? 0} set {_typedef = newValue} } /// Returns true if `typedef` has been explicitly set. - var hasTypedef: Bool {return self._typedef != nil} + var hasTypedef: Bool {self._typedef != nil} /// Clears the value of `typedef`. Subsequent reads from it will return its default value. mutating func clearTypedef() {self._typedef = nil} @@ -5787,17 +5327,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _typedef: Int32? = nil } - struct typeid { + struct typeid: Sendable { // 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 typeid: Int32 { - get {return _typeid ?? 0} + get {_typeid ?? 0} set {_typeid = newValue} } /// Returns true if `typeid` has been explicitly set. - var hasTypeid: Bool {return self._typeid != nil} + var hasTypeid: Bool {self._typeid != nil} /// Clears the value of `typeid`. Subsequent reads from it will return its default value. mutating func clearTypeid() {self._typeid = nil} @@ -5808,17 +5348,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _typeid: Int32? = nil } - struct typename { + struct typename: Sendable { // 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 typename: Int32 { - get {return _typename ?? 0} + get {_typename ?? 0} set {_typename = newValue} } /// Returns true if `typename` has been explicitly set. - var hasTypename: Bool {return self._typename != nil} + var hasTypename: Bool {self._typename != nil} /// Clears the value of `typename`. Subsequent reads from it will return its default value. mutating func clearTypename() {self._typename = nil} @@ -5829,17 +5369,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _typename: Int32? = nil } - struct union { + struct union: Sendable { // 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 union: Int32 { - get {return _union ?? 0} + get {_union ?? 0} set {_union = newValue} } /// Returns true if `union` has been explicitly set. - var hasUnion: Bool {return self._union != nil} + var hasUnion: Bool {self._union != nil} /// Clears the value of `union`. Subsequent reads from it will return its default value. mutating func clearUnion() {self._union = nil} @@ -5850,17 +5390,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _union: Int32? = nil } - struct unsigned { + struct unsigned: Sendable { // 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 unsigned: Int32 { - get {return _unsigned ?? 0} + get {_unsigned ?? 0} set {_unsigned = newValue} } /// Returns true if `unsigned` has been explicitly set. - var hasUnsigned: Bool {return self._unsigned != nil} + var hasUnsigned: Bool {self._unsigned != nil} /// Clears the value of `unsigned`. Subsequent reads from it will return its default value. mutating func clearUnsigned() {self._unsigned = nil} @@ -5871,17 +5411,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _unsigned: Int32? = nil } - struct using { + struct using: Sendable { // 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 using: Int32 { - get {return _using ?? 0} + get {_using ?? 0} set {_using = newValue} } /// Returns true if `using` has been explicitly set. - var hasUsing: Bool {return self._using != nil} + var hasUsing: Bool {self._using != nil} /// Clears the value of `using`. Subsequent reads from it will return its default value. mutating func clearUsing() {self._using = nil} @@ -5892,17 +5432,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _using: Int32? = nil } - struct virtual { + struct virtual: Sendable { // 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 virtual: Int32 { - get {return _virtual ?? 0} + get {_virtual ?? 0} set {_virtual = newValue} } /// Returns true if `virtual` has been explicitly set. - var hasVirtual: Bool {return self._virtual != nil} + var hasVirtual: Bool {self._virtual != nil} /// Clears the value of `virtual`. Subsequent reads from it will return its default value. mutating func clearVirtual() {self._virtual = nil} @@ -5913,17 +5453,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _virtual: Int32? = nil } - struct void { + struct void: Sendable { // 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 void: Int32 { - get {return _void ?? 0} + get {_void ?? 0} set {_void = newValue} } /// Returns true if `void` has been explicitly set. - var hasVoid: Bool {return self._void != nil} + var hasVoid: Bool {self._void != nil} /// Clears the value of `void`. Subsequent reads from it will return its default value. mutating func clearVoid() {self._void = nil} @@ -5934,17 +5474,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _void: Int32? = nil } - struct volatile { + struct volatile: Sendable { // 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 volatile: Int32 { - get {return _volatile ?? 0} + get {_volatile ?? 0} set {_volatile = newValue} } /// Returns true if `volatile` has been explicitly set. - var hasVolatile: Bool {return self._volatile != nil} + var hasVolatile: Bool {self._volatile != nil} /// Clears the value of `volatile`. Subsequent reads from it will return its default value. mutating func clearVolatile() {self._volatile = nil} @@ -5955,17 +5495,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _volatile: Int32? = nil } - struct wchar_t { + struct wchar_t: Sendable { // 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 wcharT: Int32 { - get {return _wcharT ?? 0} + get {_wcharT ?? 0} set {_wcharT = newValue} } /// Returns true if `wcharT` has been explicitly set. - var hasWcharT: Bool {return self._wcharT != nil} + var hasWcharT: Bool {self._wcharT != nil} /// Clears the value of `wcharT`. Subsequent reads from it will return its default value. mutating func clearWcharT() {self._wcharT = nil} @@ -5976,17 +5516,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _wcharT: Int32? = nil } - struct xor { + struct xor: Sendable { // 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 xor: Int32 { - get {return _xor ?? 0} + get {_xor ?? 0} set {_xor = newValue} } /// Returns true if `xor` has been explicitly set. - var hasXor: Bool {return self._xor != nil} + var hasXor: Bool {self._xor != nil} /// Clears the value of `xor`. Subsequent reads from it will return its default value. mutating func clearXor() {self._xor = nil} @@ -5997,17 +5537,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _xor: Int32? = nil } - struct xor_eq { + struct xor_eq: Sendable { // 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 xorEq: Int32 { - get {return _xorEq ?? 0} + get {_xorEq ?? 0} set {_xorEq = newValue} } /// Returns true if `xorEq` has been explicitly set. - var hasXorEq: Bool {return self._xorEq != nil} + var hasXorEq: Bool {self._xorEq != nil} /// Clears the value of `xorEq`. Subsequent reads from it will return its default value. mutating func clearXorEq() {self._xorEq = nil} @@ -6018,17 +5558,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _xorEq: Int32? = nil } - struct restrict { + struct restrict: Sendable { // 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 restrict: Int32 { - get {return _restrict ?? 0} + get {_restrict ?? 0} set {_restrict = newValue} } /// Returns true if `restrict` has been explicitly set. - var hasRestrict: Bool {return self._restrict != nil} + var hasRestrict: Bool {self._restrict != nil} /// Clears the value of `restrict`. Subsequent reads from it will return its default value. mutating func clearRestrict() {self._restrict = nil} @@ -6039,17 +5579,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _restrict: Int32? = nil } - struct Category { + struct Category: Sendable { // 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 category: Int32 { - get {return _category ?? 0} + get {_category ?? 0} set {_category = newValue} } /// Returns true if `category` has been explicitly set. - var hasCategory: Bool {return self._category != nil} + var hasCategory: Bool {self._category != nil} /// Clears the value of `category`. Subsequent reads from it will return its default value. mutating func clearCategory() {self._category = nil} @@ -6060,17 +5600,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _category: Int32? = nil } - struct Ivar { + struct Ivar: Sendable { // 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 ivar: Int32 { - get {return _ivar ?? 0} + get {_ivar ?? 0} set {_ivar = newValue} } /// Returns true if `ivar` has been explicitly set. - var hasIvar: Bool {return self._ivar != nil} + var hasIvar: Bool {self._ivar != nil} /// Clears the value of `ivar`. Subsequent reads from it will return its default value. mutating func clearIvar() {self._ivar = nil} @@ -6081,17 +5621,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _ivar: Int32? = nil } - struct Method { + struct Method: Sendable { // 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 method: Int32 { - get {return _method ?? 0} + get {_method ?? 0} set {_method = newValue} } /// Returns true if `method` has been explicitly set. - var hasMethod: Bool {return self._method != nil} + var hasMethod: Bool {self._method != nil} /// Clears the value of `method`. Subsequent reads from it will return its default value. mutating func clearMethod() {self._method = nil} @@ -6102,17 +5642,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _method: Int32? = nil } - struct finalize { + struct finalize: Sendable { // 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 finalize: Int32 { - get {return _finalize ?? 0} + get {_finalize ?? 0} set {_finalize = newValue} } /// Returns true if `finalize` has been explicitly set. - var hasFinalize: Bool {return self._finalize != nil} + var hasFinalize: Bool {self._finalize != nil} /// Clears the value of `finalize`. Subsequent reads from it will return its default value. mutating func clearFinalize() {self._finalize = nil} @@ -6123,17 +5663,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _finalize: Int32? = nil } - struct hash { + struct hash: Sendable { // 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 hash: Int32 { - get {return _hash ?? 0} + get {_hash ?? 0} set {_hash = newValue} } /// Returns true if `hash` has been explicitly set. - var hasHash: Bool {return self._hash != nil} + var hasHash: Bool {self._hash != nil} /// Clears the value of `hash`. Subsequent reads from it will return its default value. mutating func clearHash() {self._hash = nil} @@ -6144,17 +5684,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _hash: Int32? = nil } - struct dealloc { + struct dealloc: Sendable { // 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 dealloc: Int32 { - get {return _dealloc ?? 0} + get {_dealloc ?? 0} set {_dealloc = newValue} } /// Returns true if `dealloc` has been explicitly set. - var hasDealloc: Bool {return self._dealloc != nil} + var hasDealloc: Bool {self._dealloc != nil} /// Clears the value of `dealloc`. Subsequent reads from it will return its default value. mutating func clearDealloc() {self._dealloc = nil} @@ -6165,17 +5705,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _dealloc: Int32? = nil } - struct superclass { + struct superclass: Sendable { // 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 superclass: Int32 { - get {return _superclass ?? 0} + get {_superclass ?? 0} set {_superclass = newValue} } /// Returns true if `superclass` has been explicitly set. - var hasSuperclass: Bool {return self._superclass != nil} + var hasSuperclass: Bool {self._superclass != nil} /// Clears the value of `superclass`. Subsequent reads from it will return its default value. mutating func clearSuperclass() {self._superclass = nil} @@ -6186,17 +5726,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _superclass: Int32? = nil } - struct retain { + struct retain: Sendable { // 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 retain: Int32 { - get {return _retain ?? 0} + get {_retain ?? 0} set {_retain = newValue} } /// Returns true if `retain` has been explicitly set. - var hasRetain: Bool {return self._retain != nil} + var hasRetain: Bool {self._retain != nil} /// Clears the value of `retain`. Subsequent reads from it will return its default value. mutating func clearRetain() {self._retain = nil} @@ -6207,17 +5747,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _retain: Int32? = nil } - struct release { + struct release: Sendable { // 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 release: Int32 { - get {return _release ?? 0} + get {_release ?? 0} set {_release = newValue} } /// Returns true if `release` has been explicitly set. - var hasRelease: Bool {return self._release != nil} + var hasRelease: Bool {self._release != nil} /// Clears the value of `release`. Subsequent reads from it will return its default value. mutating func clearRelease() {self._release = nil} @@ -6228,17 +5768,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _release: Int32? = nil } - struct autorelease { + struct autorelease: Sendable { // 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 autorelease: Int32 { - get {return _autorelease ?? 0} + get {_autorelease ?? 0} set {_autorelease = newValue} } /// Returns true if `autorelease` has been explicitly set. - var hasAutorelease: Bool {return self._autorelease != nil} + var hasAutorelease: Bool {self._autorelease != nil} /// Clears the value of `autorelease`. Subsequent reads from it will return its default value. mutating func clearAutorelease() {self._autorelease = nil} @@ -6249,17 +5789,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _autorelease: Int32? = nil } - struct retainCount { + struct retainCount: Sendable { // 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 retainCount: Int32 { - get {return _retainCount ?? 0} + get {_retainCount ?? 0} set {_retainCount = newValue} } /// Returns true if `retainCount` has been explicitly set. - var hasRetainCount: Bool {return self._retainCount != nil} + var hasRetainCount: Bool {self._retainCount != nil} /// Clears the value of `retainCount`. Subsequent reads from it will return its default value. mutating func clearRetainCount() {self._retainCount = nil} @@ -6270,17 +5810,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _retainCount: Int32? = nil } - struct zone { + struct zone: Sendable { // 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 zone: Int32 { - get {return _zone ?? 0} + get {_zone ?? 0} set {_zone = newValue} } /// Returns true if `zone` has been explicitly set. - var hasZone: Bool {return self._zone != nil} + var hasZone: Bool {self._zone != nil} /// Clears the value of `zone`. Subsequent reads from it will return its default value. mutating func clearZone() {self._zone = nil} @@ -6291,17 +5831,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _zone: Int32? = nil } - struct isProxy { + struct isProxy: Sendable { // 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 isProxy: Int32 { - get {return _isProxy ?? 0} + get {_isProxy ?? 0} set {_isProxy = newValue} } /// Returns true if `isProxy` has been explicitly set. - var hasIsProxy: Bool {return self._isProxy != nil} + var hasIsProxy: Bool {self._isProxy != nil} /// Clears the value of `isProxy`. Subsequent reads from it will return its default value. mutating func clearIsProxy() {self._isProxy = nil} @@ -6312,17 +5852,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _isProxy: Int32? = nil } - struct copy { + struct copy: Sendable { // 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 copy: Int32 { - get {return _copy ?? 0} + get {_copy ?? 0} set {_copy = newValue} } /// Returns true if `copy` has been explicitly set. - var hasCopy: Bool {return self._copy != nil} + var hasCopy: Bool {self._copy != nil} /// Clears the value of `copy`. Subsequent reads from it will return its default value. mutating func clearCopy() {self._copy = nil} @@ -6333,17 +5873,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _copy: Int32? = nil } - struct mutableCopy { + struct mutableCopy: Sendable { // 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 mutableCopy: Int32 { - get {return _mutableCopy ?? 0} + get {_mutableCopy ?? 0} set {_mutableCopy = newValue} } /// Returns true if `mutableCopy` has been explicitly set. - var hasMutableCopy: Bool {return self._mutableCopy != nil} + var hasMutableCopy: Bool {self._mutableCopy != nil} /// Clears the value of `mutableCopy`. Subsequent reads from it will return its default value. mutating func clearMutableCopy() {self._mutableCopy = nil} @@ -6354,17 +5894,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _mutableCopy: Int32? = nil } - struct classForCoder { + struct classForCoder: Sendable { // 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 classForCoder: Int32 { - get {return _classForCoder ?? 0} + get {_classForCoder ?? 0} set {_classForCoder = newValue} } /// Returns true if `classForCoder` has been explicitly set. - var hasClassForCoder: Bool {return self._classForCoder != nil} + var hasClassForCoder: Bool {self._classForCoder != nil} /// Clears the value of `classForCoder`. Subsequent reads from it will return its default value. mutating func clearClassForCoder() {self._classForCoder = nil} @@ -6375,17 +5915,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _classForCoder: Int32? = nil } - struct clear { + struct clear: Sendable { // 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 clear: Int32 { - get {return _clear ?? 0} + get {_clear ?? 0} set {_clear = newValue} } /// Returns true if `clear` has been explicitly set. - var hasClear: Bool {return self._clear != nil} + var hasClear: Bool {self._clear != nil} /// Clears the value of `clear`. Subsequent reads from it will return its default value. mutating func clearClear() {self._clear = nil} @@ -6396,17 +5936,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _clear: Int32? = nil } - struct data { + struct data: Sendable { // 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 data: Int32 { - get {return _data ?? 0} + get {_data ?? 0} set {_data = newValue} } /// Returns true if `data` has been explicitly set. - var hasData: Bool {return self._data != nil} + var hasData: Bool {self._data != nil} /// Clears the value of `data`. Subsequent reads from it will return its default value. mutating func clearData() {self._data = nil} @@ -6417,17 +5957,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _data: Int32? = nil } - struct delimitedData { + struct delimitedData: Sendable { // 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 delimitedData: Int32 { - get {return _delimitedData ?? 0} + get {_delimitedData ?? 0} set {_delimitedData = newValue} } /// Returns true if `delimitedData` has been explicitly set. - var hasDelimitedData: Bool {return self._delimitedData != nil} + var hasDelimitedData: Bool {self._delimitedData != nil} /// Clears the value of `delimitedData`. Subsequent reads from it will return its default value. mutating func clearDelimitedData() {self._delimitedData = nil} @@ -6438,17 +5978,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _delimitedData: Int32? = nil } - struct descriptor { + struct descriptor: Sendable { // 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 descriptor: Int32 { - get {return _descriptor ?? 0} + get {_descriptor ?? 0} set {_descriptor = newValue} } /// Returns true if `descriptor` has been explicitly set. - var hasDescriptor: Bool {return self._descriptor != nil} + var hasDescriptor: Bool {self._descriptor != nil} /// Clears the value of `descriptor`. Subsequent reads from it will return its default value. mutating func clearDescriptor() {self._descriptor = nil} @@ -6459,17 +5999,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _descriptor: Int32? = nil } - struct extensionRegistry { + struct extensionRegistry: Sendable { // 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 extensionRegistry: Int32 { - get {return _extensionRegistry ?? 0} + get {_extensionRegistry ?? 0} set {_extensionRegistry = newValue} } /// Returns true if `extensionRegistry` has been explicitly set. - var hasExtensionRegistry: Bool {return self._extensionRegistry != nil} + var hasExtensionRegistry: Bool {self._extensionRegistry != nil} /// Clears the value of `extensionRegistry`. Subsequent reads from it will return its default value. mutating func clearExtensionRegistry() {self._extensionRegistry = nil} @@ -6480,17 +6020,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _extensionRegistry: Int32? = nil } - struct extensionsCurrentlySet { + struct extensionsCurrentlySet: Sendable { // 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 extensionsCurrentlySet: Int32 { - get {return _extensionsCurrentlySet ?? 0} + get {_extensionsCurrentlySet ?? 0} set {_extensionsCurrentlySet = newValue} } /// Returns true if `extensionsCurrentlySet` has been explicitly set. - var hasExtensionsCurrentlySet: Bool {return self._extensionsCurrentlySet != nil} + var hasExtensionsCurrentlySet: Bool {self._extensionsCurrentlySet != nil} /// Clears the value of `extensionsCurrentlySet`. Subsequent reads from it will return its default value. mutating func clearExtensionsCurrentlySet() {self._extensionsCurrentlySet = nil} @@ -6501,17 +6041,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _extensionsCurrentlySet: Int32? = nil } - struct isInitializedMessage { + struct isInitializedMessage: Sendable { // 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 isInitialized_p: Int32 { - get {return _isInitialized_p ?? 0} + get {_isInitialized_p ?? 0} set {_isInitialized_p = newValue} } /// Returns true if `isInitialized_p` has been explicitly set. - var hasIsInitialized_p: Bool {return self._isInitialized_p != nil} + var hasIsInitialized_p: Bool {self._isInitialized_p != nil} /// Clears the value of `isInitialized_p`. Subsequent reads from it will return its default value. mutating func clearIsInitialized_p() {self._isInitialized_p = nil} @@ -6522,17 +6062,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _isInitialized_p: Int32? = nil } - struct serializedSize { + struct serializedSize: Sendable { // 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 serializedSize: Int32 { - get {return _serializedSize ?? 0} + get {_serializedSize ?? 0} set {_serializedSize = newValue} } /// Returns true if `serializedSize` has been explicitly set. - var hasSerializedSize: Bool {return self._serializedSize != nil} + var hasSerializedSize: Bool {self._serializedSize != nil} /// Clears the value of `serializedSize`. Subsequent reads from it will return its default value. mutating func clearSerializedSize() {self._serializedSize = nil} @@ -6543,17 +6083,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _serializedSize: Int32? = nil } - struct sortedExtensionsInUse { + struct sortedExtensionsInUse: Sendable { // 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 sortedExtensionsInUse: Int32 { - get {return _sortedExtensionsInUse ?? 0} + get {_sortedExtensionsInUse ?? 0} set {_sortedExtensionsInUse = newValue} } /// Returns true if `sortedExtensionsInUse` has been explicitly set. - var hasSortedExtensionsInUse: Bool {return self._sortedExtensionsInUse != nil} + var hasSortedExtensionsInUse: Bool {self._sortedExtensionsInUse != nil} /// Clears the value of `sortedExtensionsInUse`. Subsequent reads from it will return its default value. mutating func clearSortedExtensionsInUse() {self._sortedExtensionsInUse = nil} @@ -6564,17 +6104,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _sortedExtensionsInUse: Int32? = nil } - struct unknownFieldsMessage { + struct unknownFieldsMessage: Sendable { // 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_p: Int32 { - get {return _unknownFields_p ?? 0} + get {_unknownFields_p ?? 0} set {_unknownFields_p = newValue} } /// Returns true if `unknownFields_p` has been explicitly set. - var hasUnknownFields_p: Bool {return self._unknownFields_p != nil} + var hasUnknownFields_p: Bool {self._unknownFields_p != nil} /// Clears the value of `unknownFields_p`. Subsequent reads from it will return its default value. mutating func clearUnknownFields_p() {self._unknownFields_p = nil} @@ -6585,17 +6125,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _unknownFields_p: Int32? = nil } - struct Fixed { + struct Fixed: Sendable { // 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 fixed: Int32 { - get {return _fixed ?? 0} + get {_fixed ?? 0} set {_fixed = newValue} } /// Returns true if `fixed` has been explicitly set. - var hasFixed: Bool {return self._fixed != nil} + var hasFixed: Bool {self._fixed != nil} /// Clears the value of `fixed`. Subsequent reads from it will return its default value. mutating func clearFixed() {self._fixed = nil} @@ -6606,17 +6146,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _fixed: Int32? = nil } - struct Fract { + struct Fract: Sendable { // 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 fract: Int32 { - get {return _fract ?? 0} + get {_fract ?? 0} set {_fract = newValue} } /// Returns true if `fract` has been explicitly set. - var hasFract: Bool {return self._fract != nil} + var hasFract: Bool {self._fract != nil} /// Clears the value of `fract`. Subsequent reads from it will return its default value. mutating func clearFract() {self._fract = nil} @@ -6627,17 +6167,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _fract: Int32? = nil } - struct Size { + struct Size: Sendable { // 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 size: Int32 { - get {return _size ?? 0} + get {_size ?? 0} set {_size = newValue} } /// Returns true if `size` has been explicitly set. - var hasSize: Bool {return self._size != nil} + var hasSize: Bool {self._size != nil} /// Clears the value of `size`. Subsequent reads from it will return its default value. mutating func clearSize() {self._size = nil} @@ -6648,17 +6188,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _size: Int32? = nil } - struct LogicalAddress { + struct LogicalAddress: Sendable { // 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 logicalAddress: Int32 { - get {return _logicalAddress ?? 0} + get {_logicalAddress ?? 0} set {_logicalAddress = newValue} } /// Returns true if `logicalAddress` has been explicitly set. - var hasLogicalAddress: Bool {return self._logicalAddress != nil} + var hasLogicalAddress: Bool {self._logicalAddress != nil} /// Clears the value of `logicalAddress`. Subsequent reads from it will return its default value. mutating func clearLogicalAddress() {self._logicalAddress = nil} @@ -6669,17 +6209,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _logicalAddress: Int32? = nil } - struct PhysicalAddress { + struct PhysicalAddress: Sendable { // 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 physicalAddress: Int32 { - get {return _physicalAddress ?? 0} + get {_physicalAddress ?? 0} set {_physicalAddress = newValue} } /// Returns true if `physicalAddress` has been explicitly set. - var hasPhysicalAddress: Bool {return self._physicalAddress != nil} + var hasPhysicalAddress: Bool {self._physicalAddress != nil} /// Clears the value of `physicalAddress`. Subsequent reads from it will return its default value. mutating func clearPhysicalAddress() {self._physicalAddress = nil} @@ -6690,17 +6230,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _physicalAddress: Int32? = nil } - struct ByteCount { + struct ByteCount: Sendable { // 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 byteCount: Int32 { - get {return _byteCount ?? 0} + get {_byteCount ?? 0} set {_byteCount = newValue} } /// Returns true if `byteCount` has been explicitly set. - var hasByteCount: Bool {return self._byteCount != nil} + var hasByteCount: Bool {self._byteCount != nil} /// Clears the value of `byteCount`. Subsequent reads from it will return its default value. mutating func clearByteCount() {self._byteCount = nil} @@ -6711,17 +6251,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _byteCount: Int32? = nil } - struct ByteOffset { + struct ByteOffset: Sendable { // 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 byteOffset: Int32 { - get {return _byteOffset ?? 0} + get {_byteOffset ?? 0} set {_byteOffset = newValue} } /// Returns true if `byteOffset` has been explicitly set. - var hasByteOffset: Bool {return self._byteOffset != nil} + var hasByteOffset: Bool {self._byteOffset != nil} /// Clears the value of `byteOffset`. Subsequent reads from it will return its default value. mutating func clearByteOffset() {self._byteOffset = nil} @@ -6732,17 +6272,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _byteOffset: Int32? = nil } - struct Duration { + struct Duration: Sendable { // 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 duration: Int32 { - get {return _duration ?? 0} + get {_duration ?? 0} set {_duration = newValue} } /// Returns true if `duration` has been explicitly set. - var hasDuration: Bool {return self._duration != nil} + var hasDuration: Bool {self._duration != nil} /// Clears the value of `duration`. Subsequent reads from it will return its default value. mutating func clearDuration() {self._duration = nil} @@ -6753,17 +6293,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _duration: Int32? = nil } - struct AbsoluteTime { + struct AbsoluteTime: Sendable { // 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 absoluteTime: Int32 { - get {return _absoluteTime ?? 0} + get {_absoluteTime ?? 0} set {_absoluteTime = newValue} } /// Returns true if `absoluteTime` has been explicitly set. - var hasAbsoluteTime: Bool {return self._absoluteTime != nil} + var hasAbsoluteTime: Bool {self._absoluteTime != nil} /// Clears the value of `absoluteTime`. Subsequent reads from it will return its default value. mutating func clearAbsoluteTime() {self._absoluteTime = nil} @@ -6774,17 +6314,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _absoluteTime: Int32? = nil } - struct OptionBits { + struct OptionBits: Sendable { // 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 optionBits: Int32 { - get {return _optionBits ?? 0} + get {_optionBits ?? 0} set {_optionBits = newValue} } /// Returns true if `optionBits` has been explicitly set. - var hasOptionBits: Bool {return self._optionBits != nil} + var hasOptionBits: Bool {self._optionBits != nil} /// Clears the value of `optionBits`. Subsequent reads from it will return its default value. mutating func clearOptionBits() {self._optionBits = nil} @@ -6795,17 +6335,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _optionBits: Int32? = nil } - struct ItemCount { + struct ItemCount: Sendable { // 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 itemCount: Int32 { - get {return _itemCount ?? 0} + get {_itemCount ?? 0} set {_itemCount = newValue} } /// Returns true if `itemCount` has been explicitly set. - var hasItemCount: Bool {return self._itemCount != nil} + var hasItemCount: Bool {self._itemCount != nil} /// Clears the value of `itemCount`. Subsequent reads from it will return its default value. mutating func clearItemCount() {self._itemCount = nil} @@ -6816,17 +6356,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _itemCount: Int32? = nil } - struct PBVersion { + struct PBVersion: Sendable { // 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 pbversion: Int32 { - get {return _pbversion ?? 0} + get {_pbversion ?? 0} set {_pbversion = newValue} } /// Returns true if `pbversion` has been explicitly set. - var hasPbversion: Bool {return self._pbversion != nil} + var hasPbversion: Bool {self._pbversion != nil} /// Clears the value of `pbversion`. Subsequent reads from it will return its default value. mutating func clearPbversion() {self._pbversion = nil} @@ -6837,17 +6377,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _pbversion: Int32? = nil } - struct ScriptCode { + struct ScriptCode: Sendable { // 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 scriptCode: Int32 { - get {return _scriptCode ?? 0} + get {_scriptCode ?? 0} set {_scriptCode = newValue} } /// Returns true if `scriptCode` has been explicitly set. - var hasScriptCode: Bool {return self._scriptCode != nil} + var hasScriptCode: Bool {self._scriptCode != nil} /// Clears the value of `scriptCode`. Subsequent reads from it will return its default value. mutating func clearScriptCode() {self._scriptCode = nil} @@ -6858,17 +6398,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _scriptCode: Int32? = nil } - struct LangCode { + struct LangCode: Sendable { // 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 langCode: Int32 { - get {return _langCode ?? 0} + get {_langCode ?? 0} set {_langCode = newValue} } /// Returns true if `langCode` has been explicitly set. - var hasLangCode: Bool {return self._langCode != nil} + var hasLangCode: Bool {self._langCode != nil} /// Clears the value of `langCode`. Subsequent reads from it will return its default value. mutating func clearLangCode() {self._langCode = nil} @@ -6879,17 +6419,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _langCode: Int32? = nil } - struct RegionCode { + struct RegionCode: Sendable { // 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 regionCode: Int32 { - get {return _regionCode ?? 0} + get {_regionCode ?? 0} set {_regionCode = newValue} } /// Returns true if `regionCode` has been explicitly set. - var hasRegionCode: Bool {return self._regionCode != nil} + var hasRegionCode: Bool {self._regionCode != nil} /// Clears the value of `regionCode`. Subsequent reads from it will return its default value. mutating func clearRegionCode() {self._regionCode = nil} @@ -6900,17 +6440,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _regionCode: Int32? = nil } - struct OSType { + struct OSType: Sendable { // 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 ostype: Int32 { - get {return _ostype ?? 0} + get {_ostype ?? 0} set {_ostype = newValue} } /// Returns true if `ostype` has been explicitly set. - var hasOstype: Bool {return self._ostype != nil} + var hasOstype: Bool {self._ostype != nil} /// Clears the value of `ostype`. Subsequent reads from it will return its default value. mutating func clearOstype() {self._ostype = nil} @@ -6921,17 +6461,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _ostype: Int32? = nil } - struct ProcessSerialNumber { + struct ProcessSerialNumber: Sendable { // 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 processSerialNumber: Int32 { - get {return _processSerialNumber ?? 0} + get {_processSerialNumber ?? 0} set {_processSerialNumber = newValue} } /// Returns true if `processSerialNumber` has been explicitly set. - var hasProcessSerialNumber: Bool {return self._processSerialNumber != nil} + var hasProcessSerialNumber: Bool {self._processSerialNumber != nil} /// Clears the value of `processSerialNumber`. Subsequent reads from it will return its default value. mutating func clearProcessSerialNumber() {self._processSerialNumber = nil} @@ -6942,17 +6482,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _processSerialNumber: Int32? = nil } - struct Point { + struct Point: Sendable { // 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 point: Int32 { - get {return _point ?? 0} + get {_point ?? 0} set {_point = newValue} } /// Returns true if `point` has been explicitly set. - var hasPoint: Bool {return self._point != nil} + var hasPoint: Bool {self._point != nil} /// Clears the value of `point`. Subsequent reads from it will return its default value. mutating func clearPoint() {self._point = nil} @@ -6963,17 +6503,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _point: Int32? = nil } - struct Rect { + struct Rect: Sendable { // 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 rect: Int32 { - get {return _rect ?? 0} + get {_rect ?? 0} set {_rect = newValue} } /// Returns true if `rect` has been explicitly set. - var hasRect: Bool {return self._rect != nil} + var hasRect: Bool {self._rect != nil} /// Clears the value of `rect`. Subsequent reads from it will return its default value. mutating func clearRect() {self._rect = nil} @@ -6984,17 +6524,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _rect: Int32? = nil } - struct FixedPoint { + struct FixedPoint: Sendable { // 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 fixedPoint: Int32 { - get {return _fixedPoint ?? 0} + get {_fixedPoint ?? 0} set {_fixedPoint = newValue} } /// Returns true if `fixedPoint` has been explicitly set. - var hasFixedPoint: Bool {return self._fixedPoint != nil} + var hasFixedPoint: Bool {self._fixedPoint != nil} /// Clears the value of `fixedPoint`. Subsequent reads from it will return its default value. mutating func clearFixedPoint() {self._fixedPoint = nil} @@ -7005,17 +6545,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _fixedPoint: Int32? = nil } - struct FixedRect { + struct FixedRect: Sendable { // 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 fixedRect: Int32 { - get {return _fixedRect ?? 0} + get {_fixedRect ?? 0} set {_fixedRect = newValue} } /// Returns true if `fixedRect` has been explicitly set. - var hasFixedRect: Bool {return self._fixedRect != nil} + var hasFixedRect: Bool {self._fixedRect != nil} /// Clears the value of `fixedRect`. Subsequent reads from it will return its default value. mutating func clearFixedRect() {self._fixedRect = nil} @@ -7026,17 +6566,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _fixedRect: Int32? = nil } - struct Style { + struct Style: Sendable { // 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 style: Int32 { - get {return _style ?? 0} + get {_style ?? 0} set {_style = newValue} } /// Returns true if `style` has been explicitly set. - var hasStyle: Bool {return self._style != nil} + var hasStyle: Bool {self._style != nil} /// Clears the value of `style`. Subsequent reads from it will return its default value. mutating func clearStyle() {self._style = nil} @@ -7047,17 +6587,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _style: Int32? = nil } - struct StyleParameter { + struct StyleParameter: Sendable { // 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 styleParameter: Int32 { - get {return _styleParameter ?? 0} + get {_styleParameter ?? 0} set {_styleParameter = newValue} } /// Returns true if `styleParameter` has been explicitly set. - var hasStyleParameter: Bool {return self._styleParameter != nil} + var hasStyleParameter: Bool {self._styleParameter != nil} /// Clears the value of `styleParameter`. Subsequent reads from it will return its default value. mutating func clearStyleParameter() {self._styleParameter = nil} @@ -7068,17 +6608,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _styleParameter: Int32? = nil } - struct StyleField { + struct StyleField: Sendable { // 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 styleField: Int32 { - get {return _styleField ?? 0} + get {_styleField ?? 0} set {_styleField = newValue} } /// Returns true if `styleField` has been explicitly set. - var hasStyleField: Bool {return self._styleField != nil} + var hasStyleField: Bool {self._styleField != nil} /// Clears the value of `styleField`. Subsequent reads from it will return its default value. mutating func clearStyleField() {self._styleField = nil} @@ -7089,17 +6629,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _styleField: Int32? = nil } - struct TimeScale { + struct TimeScale: Sendable { // 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 timeScale: Int32 { - get {return _timeScale ?? 0} + get {_timeScale ?? 0} set {_timeScale = newValue} } /// Returns true if `timeScale` has been explicitly set. - var hasTimeScale: Bool {return self._timeScale != nil} + var hasTimeScale: Bool {self._timeScale != nil} /// Clears the value of `timeScale`. Subsequent reads from it will return its default value. mutating func clearTimeScale() {self._timeScale = nil} @@ -7110,17 +6650,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _timeScale: Int32? = nil } - struct TimeBase { + struct TimeBase: Sendable { // 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 timeBase: Int32 { - get {return _timeBase ?? 0} + get {_timeBase ?? 0} set {_timeBase = newValue} } /// Returns true if `timeBase` has been explicitly set. - var hasTimeBase: Bool {return self._timeBase != nil} + var hasTimeBase: Bool {self._timeBase != nil} /// Clears the value of `timeBase`. Subsequent reads from it will return its default value. mutating func clearTimeBase() {self._timeBase = nil} @@ -7131,17 +6671,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _timeBase: Int32? = nil } - struct TimeRecord { + struct TimeRecord: Sendable { // 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 timeRecord: Int32 { - get {return _timeRecord ?? 0} + get {_timeRecord ?? 0} set {_timeRecord = newValue} } /// Returns true if `timeRecord` has been explicitly set. - var hasTimeRecord: Bool {return self._timeRecord != nil} + var hasTimeRecord: Bool {self._timeRecord != nil} /// Clears the value of `timeRecord`. Subsequent reads from it will return its default value. mutating func clearTimeRecord() {self._timeRecord = nil} @@ -7152,17 +6692,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _timeRecord: Int32? = nil } - struct serializedData { + struct serializedData: Sendable { // 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 serializedData: Int32 { - get {return _serializedData ?? 0} + get {_serializedData ?? 0} set {_serializedData = newValue} } /// Returns true if `serializedData` has been explicitly set. - var hasSerializedData: Bool {return self._serializedData != nil} + var hasSerializedData: Bool {self._serializedData != nil} /// Clears the value of `serializedData`. Subsequent reads from it will return its default value. mutating func clearSerializedData() {self._serializedData = nil} @@ -7173,17 +6713,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _serializedData: Int32? = nil } - struct jsonUTF8Data { + struct jsonUTF8Data: Sendable { // 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 jsonUtf8Data: Int32 { - get {return _jsonUtf8Data ?? 0} + get {_jsonUtf8Data ?? 0} set {_jsonUtf8Data = newValue} } /// Returns true if `jsonUtf8Data` has been explicitly set. - var hasJsonUtf8Data: Bool {return self._jsonUtf8Data != nil} + var hasJsonUtf8Data: Bool {self._jsonUtf8Data != nil} /// Clears the value of `jsonUtf8Data`. Subsequent reads from it will return its default value. mutating func clearJsonUtf8Data() {self._jsonUtf8Data = nil} @@ -7194,17 +6734,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _jsonUtf8Data: Int32? = nil } - struct jsonString { + struct jsonString: Sendable { // 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 jsonString: Int32 { - get {return _jsonString ?? 0} + get {_jsonString ?? 0} set {_jsonString = newValue} } /// Returns true if `jsonString` has been explicitly set. - var hasJsonString: Bool {return self._jsonString != nil} + var hasJsonString: Bool {self._jsonString != nil} /// Clears the value of `jsonString`. Subsequent reads from it will return its default value. mutating func clearJsonString() {self._jsonString = nil} @@ -7215,17 +6755,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _jsonString: Int32? = nil } - struct Extension { + struct Extension: Sendable { // 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 `extension`: Int32 { - get {return _extension ?? 0} + get {_extension ?? 0} set {_extension = newValue} } /// Returns true if ``extension`` has been explicitly set. - var hasExtension: Bool {return self._extension != nil} + var hasExtension: Bool {self._extension != nil} /// Clears the value of ``extension``. Subsequent reads from it will return its default value. mutating func clearExtension() {self._extension = nil} @@ -7236,17 +6776,17 @@ struct SwiftUnittest_Names_MessageNames { fileprivate var _extension: Int32? = nil } - struct ExtensionsMessage { + struct ExtensionsMessage: Sendable { // 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 extensions: Int32 { - get {return _extensions ?? 0} + get {_extensions ?? 0} set {_extensions = newValue} } /// Returns true if `extensions` has been explicitly set. - var hasExtensions: Bool {return self._extensions != nil} + var hasExtensions: Bool {self._extensions != nil} /// Clears the value of `extensions`. Subsequent reads from it will return its default value. mutating func clearExtensions() {self._extensions = nil} @@ -7260,5879 +6800,2077 @@ struct SwiftUnittest_Names_MessageNames { init() {} } -struct SwiftUnittest_Names_EnumNames { +struct SwiftProtoTesting_Names_EnumNames: Sendable { // 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() - enum StringEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aString // = 0 + enum StringEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aString = 0 init() { self = .aString } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aString - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aString: return 0 - } - } - } - enum ProtocolEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aProtocol // = 0 + enum ProtocolEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aProtocol = 0 init() { self = .aProtocol } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aProtocol - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aProtocol: return 0 - } - } - } - enum IntEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aInt // = 0 + enum IntEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aInt = 0 init() { self = .aInt } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aInt - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aInt: return 0 - } - } - } - enum DoubleEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aDouble // = 0 + enum DoubleEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aDouble = 0 init() { self = .aDouble } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aDouble - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aDouble: return 0 - } - } - } - enum FloatEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aFloat // = 0 + enum FloatEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aFloat = 0 init() { self = .aFloat } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aFloat - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aFloat: return 0 - } - } - } - enum UIntEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aUint // = 0 + enum UIntEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aUint = 0 init() { self = .aUint } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aUint - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aUint: return 0 - } - } - } - enum hashValueEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case ahashValue // = 0 + enum hashValueEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ahashValue = 0 init() { self = .ahashValue } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ahashValue - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ahashValue: return 0 - } - } - } - enum descriptionEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case adescription // = 0 + enum descriptionEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adescription = 0 init() { self = .adescription } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adescription - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adescription: return 0 - } - } - } - enum debugDescriptionEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case adebugDescription // = 0 + enum debugDescriptionEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adebugDescription = 0 init() { self = .adebugDescription } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adebugDescription - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adebugDescription: return 0 - } - } - } - enum Swift: SwiftProtobuf.Enum { - typealias RawValue = Int - case aSwift // = 0 + enum SwiftEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aSwift = 0 init() { self = .aSwift } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aSwift - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aSwift: return 0 - } - } - } - enum UNRECOGNIZED: SwiftProtobuf.Enum { - typealias RawValue = Int - case aUnrecognized // = 0 + enum UNRECOGNIZED: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aUnrecognized = 0 init() { self = .aUnrecognized } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aUnrecognized - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aUnrecognized: return 0 - } - } - } - enum classEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aclass // = 0 + enum classEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aclass = 0 init() { self = .aclass } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aclass - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aclass: return 0 - } - } - } - enum deinitEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case adeinit // = 0 + enum deinitEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adeinit = 0 init() { self = .adeinit } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adeinit - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adeinit: return 0 - } - } - } - enum enumEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aenum // = 0 + enum enumEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aenum = 0 init() { self = .aenum } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aenum - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aenum: return 0 - } - } - } - enum extensionEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aextension // = 0 + enum extensionEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aextension = 0 init() { self = .aextension } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aextension - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aextension: return 0 - } - } - } - enum funcEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case afunc // = 0 + enum funcEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case afunc = 0 init() { self = .afunc } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .afunc - default: return nil - } - } - - var rawValue: Int { - switch self { - case .afunc: return 0 - } - } - } - enum importEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aimport // = 0 + enum importEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aimport = 0 init() { self = .aimport } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aimport - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aimport: return 0 - } - } - } - enum initEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case ainit // = 0 + enum initEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ainit = 0 init() { self = .ainit } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ainit - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ainit: return 0 - } - } - } - enum inoutEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case ainout // = 0 + enum inoutEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ainout = 0 init() { self = .ainout } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ainout - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ainout: return 0 - } - } - } - enum internalEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case ainternal // = 0 + enum internalEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ainternal = 0 init() { self = .ainternal } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ainternal - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ainternal: return 0 - } - } - } - enum letEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case alet // = 0 + enum letEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case alet = 0 init() { self = .alet } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .alet - default: return nil - } - } - - var rawValue: Int { - switch self { - case .alet: return 0 - } - } - } - enum operatorEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aoperator // = 0 + enum operatorEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aoperator = 0 init() { self = .aoperator } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aoperator - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aoperator: return 0 - } - } - } - enum privateEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aprivate // = 0 + enum privateEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aprivate = 0 init() { self = .aprivate } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aprivate - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aprivate: return 0 - } - } - } - enum protocolEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aprotocol // = 0 + enum protocolEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aprotocol = 0 init() { self = .aprotocol } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aprotocol - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aprotocol: return 0 - } - } - } - enum publicEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case apublic // = 0 + enum publicEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case apublic = 0 init() { self = .apublic } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .apublic - default: return nil - } - } - - var rawValue: Int { - switch self { - case .apublic: return 0 - } - } - } - enum staticEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case astatic // = 0 + enum staticEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case astatic = 0 init() { self = .astatic } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .astatic - default: return nil - } - } - - var rawValue: Int { - switch self { - case .astatic: return 0 - } - } - } - enum structEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case astruct // = 0 + enum structEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case astruct = 0 init() { self = .astruct } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .astruct - default: return nil - } - } - - var rawValue: Int { - switch self { - case .astruct: return 0 - } - } - } - enum subscriptEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case asubscript // = 0 + enum subscriptEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case asubscript = 0 init() { self = .asubscript } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .asubscript - default: return nil - } - } - - var rawValue: Int { - switch self { - case .asubscript: return 0 - } - } - } - enum typealiasEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case atypealias // = 0 + enum typealiasEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case atypealias = 0 init() { self = .atypealias } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .atypealias - default: return nil - } - } - - var rawValue: Int { - switch self { - case .atypealias: return 0 - } - } - } - enum varEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case avar // = 0 + enum varEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case avar = 0 init() { self = .avar } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .avar - default: return nil - } - } - - var rawValue: Int { - switch self { - case .avar: return 0 - } - } - } - enum breakEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case abreak // = 0 + enum breakEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case abreak = 0 init() { self = .abreak } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .abreak - default: return nil - } - } - - var rawValue: Int { - switch self { - case .abreak: return 0 - } - } - } - enum caseEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case acase // = 0 + enum caseEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case acase = 0 init() { self = .acase } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .acase - default: return nil - } - } - - var rawValue: Int { - switch self { - case .acase: return 0 - } - } - } - enum continueEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case acontinue // = 0 + enum continueEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case acontinue = 0 init() { self = .acontinue } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .acontinue - default: return nil - } - } - - var rawValue: Int { - switch self { - case .acontinue: return 0 - } - } - } - enum defaultEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case adefault // = 0 + enum defaultEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adefault = 0 init() { self = .adefault } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adefault - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adefault: return 0 - } - } - } - enum deferEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case adefer // = 0 + enum deferEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adefer = 0 init() { self = .adefer } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adefer - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adefer: return 0 - } - } - } - enum doEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case ado // = 0 + enum doEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ado = 0 init() { self = .ado } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ado - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ado: return 0 - } - } - } - enum elseEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aelse // = 0 + enum elseEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aelse = 0 init() { self = .aelse } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aelse - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aelse: return 0 - } - } - } - enum fallthroughEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case afallthrough // = 0 + enum fallthroughEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case afallthrough = 0 init() { self = .afallthrough } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .afallthrough - default: return nil - } - } - - var rawValue: Int { - switch self { - case .afallthrough: return 0 - } - } - } - enum forEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case afor // = 0 + enum forEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case afor = 0 init() { self = .afor } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .afor - default: return nil - } - } - - var rawValue: Int { - switch self { - case .afor: return 0 - } - } - } - enum guardEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aguard // = 0 + enum guardEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aguard = 0 init() { self = .aguard } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aguard - default: return nil - } - } + } - var rawValue: Int { - switch self { - case .aguard: return 0 - } + enum ifEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aif = 0 + + init() { + self = .aif } } - enum ifEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aif // = 0 + enum inEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ain = 0 init() { - self = .aif - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aif - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aif: return 0 - } - } - - } - - enum inEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case ain // = 0 - - init() { - self = .ain - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ain - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ain: return 0 - } + self = .ain } } - enum repeatEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case arepeat // = 0 + enum repeatEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case arepeat = 0 init() { self = .arepeat } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .arepeat - default: return nil - } - } - - var rawValue: Int { - switch self { - case .arepeat: return 0 - } - } - } - enum returnEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case areturn // = 0 + enum returnEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case areturn = 0 init() { self = .areturn } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .areturn - default: return nil - } - } - - var rawValue: Int { - switch self { - case .areturn: return 0 - } - } - } - enum switchEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aswitch // = 0 + enum switchEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aswitch = 0 init() { self = .aswitch } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aswitch - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aswitch: return 0 - } - } - } - enum whereEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case awhere // = 0 + enum whereEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case awhere = 0 init() { self = .awhere } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .awhere - default: return nil - } - } - - var rawValue: Int { - switch self { - case .awhere: return 0 - } - } - } - enum whileEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case awhile // = 0 + enum whileEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case awhile = 0 init() { self = .awhile } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .awhile - default: return nil - } - } - - var rawValue: Int { - switch self { - case .awhile: return 0 - } - } - } - enum asEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aas // = 0 + enum asEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aas = 0 init() { self = .aas } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aas - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aas: return 0 - } - } - } - enum catchEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case acatch // = 0 + enum catchEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case acatch = 0 init() { self = .acatch } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .acatch - default: return nil - } - } - - var rawValue: Int { - switch self { - case .acatch: return 0 - } - } - } - enum dynamicTypeEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case adynamicType // = 0 + enum dynamicTypeEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adynamicType = 0 init() { self = .adynamicType } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adynamicType - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adynamicType: return 0 - } - } - } - enum falseEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case afalse // = 0 + enum falseEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case afalse = 0 init() { self = .afalse } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .afalse - default: return nil - } - } - - var rawValue: Int { - switch self { - case .afalse: return 0 - } - } - } - enum isEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case ais // = 0 + enum isEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ais = 0 init() { self = .ais } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ais - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ais: return 0 - } - } - } - enum nilEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case anil // = 0 + enum nilEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case anil = 0 init() { self = .anil } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .anil - default: return nil - } - } - - var rawValue: Int { - switch self { - case .anil: return 0 - } - } - } - enum rethrowsEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case arethrows // = 0 + enum rethrowsEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case arethrows = 0 init() { self = .arethrows } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .arethrows - default: return nil - } - } - - var rawValue: Int { - switch self { - case .arethrows: return 0 - } - } - } - enum superEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case asuper // = 0 + enum superEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case asuper = 0 init() { self = .asuper } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .asuper - default: return nil - } - } - - var rawValue: Int { - switch self { - case .asuper: return 0 - } - } - } - enum selfEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aself // = 0 + enum selfEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aself = 0 init() { self = .aself } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aself - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aself: return 0 - } - } - } - enum throwEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case athrow // = 0 + enum throwEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case athrow = 0 init() { self = .athrow } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .athrow - default: return nil - } - } - - var rawValue: Int { - switch self { - case .athrow: return 0 - } - } - } - enum throwsEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case athrows // = 0 + enum throwsEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case athrows = 0 init() { self = .athrows } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .athrows - default: return nil - } - } - - var rawValue: Int { - switch self { - case .athrows: return 0 - } - } - } - enum trueEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case atrue // = 0 + enum trueEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case atrue = 0 init() { self = .atrue } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .atrue - default: return nil - } - } - - var rawValue: Int { - switch self { - case .atrue: return 0 - } - } - } - enum tryEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case atry // = 0 + enum tryEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case atry = 0 init() { self = .atry } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .atry - default: return nil - } - } - - var rawValue: Int { - switch self { - case .atry: return 0 - } - } - } - enum __COLUMN__Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case a_Column__ // = 0 + enum __COLUMN__Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case a_Column__ = 0 init() { self = .a_Column__ } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .a_Column__ - default: return nil - } - } - - var rawValue: Int { - switch self { - case .a_Column__: return 0 - } - } - } - enum __FILE__Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case a_File__ // = 0 + enum __FILE__Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case a_File__ = 0 init() { self = .a_File__ } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .a_File__ - default: return nil - } - } - - var rawValue: Int { - switch self { - case .a_File__: return 0 - } - } - } - enum __FUNCTION__Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case a_Function__ // = 0 + enum __FUNCTION__Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case a_Function__ = 0 init() { self = .a_Function__ } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .a_Function__ - default: return nil - } - } - - var rawValue: Int { - switch self { - case .a_Function__: return 0 - } - } - } - enum __LINE__Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case a_Line__ // = 0 + enum __LINE__Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case a_Line__ = 0 init() { self = .a_Line__ } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .a_Line__ - default: return nil - } - } - - var rawValue: Int { - switch self { - case .a_Line__: return 0 - } - } - } - enum _Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case a_ // = 0 + enum _Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case a_ = 0 init() { self = .a_ } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .a_ - default: return nil - } - } - - var rawValue: Int { - switch self { - case .a_: return 0 - } - } - } - enum __Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case a__ // = 0 + enum __Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case a__ = 0 init() { self = .a__ } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .a__ - default: return nil - } - } - - var rawValue: Int { - switch self { - case .a__: return 0 - } - } - } - enum associativity: SwiftProtobuf.Enum { - typealias RawValue = Int - case aassociativity // = 0 + enum associativity: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aassociativity = 0 init() { self = .aassociativity } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aassociativity - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aassociativity: return 0 - } - } - } - enum convenience: SwiftProtobuf.Enum { - typealias RawValue = Int - case aconvenience // = 0 + enum convenience: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aconvenience = 0 init() { self = .aconvenience } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aconvenience - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aconvenience: return 0 - } - } - } - enum dynamic: SwiftProtobuf.Enum { - typealias RawValue = Int - case adynamic // = 0 + enum dynamic: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adynamic = 0 init() { self = .adynamic } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adynamic - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adynamic: return 0 - } - } - } - enum didSet: SwiftProtobuf.Enum { - typealias RawValue = Int - case adidSet // = 0 + enum didSet: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adidSet = 0 init() { self = .adidSet } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adidSet - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adidSet: return 0 - } - } - } - enum final: SwiftProtobuf.Enum { - typealias RawValue = Int - case afinal // = 0 + enum final: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case afinal = 0 init() { self = .afinal } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .afinal - default: return nil - } - } - - var rawValue: Int { - switch self { - case .afinal: return 0 - } - } - } - enum get: SwiftProtobuf.Enum { - typealias RawValue = Int - case aget // = 0 + enum get: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aget = 0 init() { self = .aget } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aget - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aget: return 0 - } - } - } - enum infix: SwiftProtobuf.Enum { - typealias RawValue = Int - case ainfix // = 0 + enum infix: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ainfix = 0 init() { self = .ainfix } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ainfix - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ainfix: return 0 - } - } - } - enum indirect: SwiftProtobuf.Enum { - typealias RawValue = Int - case aindirect // = 0 + enum indirect: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aindirect = 0 init() { self = .aindirect } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aindirect - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aindirect: return 0 - } - } - } - enum lazy: SwiftProtobuf.Enum { - typealias RawValue = Int - case alazy // = 0 + enum lazy: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case alazy = 0 init() { self = .alazy } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .alazy - default: return nil - } - } - - var rawValue: Int { - switch self { - case .alazy: return 0 - } - } - } - enum left: SwiftProtobuf.Enum { - typealias RawValue = Int - case aleft // = 0 + enum left: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aleft = 0 init() { self = .aleft } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aleft - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aleft: return 0 - } - } - } - enum mutating: SwiftProtobuf.Enum { - typealias RawValue = Int - case amutating // = 0 + enum mutating: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case amutating = 0 init() { self = .amutating } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .amutating - default: return nil - } - } - - var rawValue: Int { - switch self { - case .amutating: return 0 - } - } - } - enum none: SwiftProtobuf.Enum { - typealias RawValue = Int - case anone // = 0 + enum none: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case anone = 0 init() { self = .anone } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .anone - default: return nil - } - } - - var rawValue: Int { - switch self { - case .anone: return 0 - } - } - } - enum nonmutating: SwiftProtobuf.Enum { - typealias RawValue = Int - case anonmutating // = 0 + enum nonmutating: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case anonmutating = 0 init() { self = .anonmutating } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .anonmutating - default: return nil - } - } - - var rawValue: Int { - switch self { - case .anonmutating: return 0 - } - } - } - enum optional: SwiftProtobuf.Enum { - typealias RawValue = Int - case aoptional // = 0 + enum optional: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aoptional = 0 init() { self = .aoptional } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aoptional - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aoptional: return 0 - } - } - } - enum override: SwiftProtobuf.Enum { - typealias RawValue = Int - case aoverride // = 0 + enum override: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aoverride = 0 init() { self = .aoverride } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aoverride - default: return nil - } - } + } - var rawValue: Int { - switch self { - case .aoverride: return 0 - } + enum postfix: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case apostfix = 0 + + init() { + self = .apostfix } } - enum postfix: SwiftProtobuf.Enum { - typealias RawValue = Int - case apostfix // = 0 + enum precedence: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aprecedence = 0 init() { - self = .apostfix - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .apostfix - default: return nil - } - } - - var rawValue: Int { - switch self { - case .apostfix: return 0 - } - } - - } - - enum precedence: SwiftProtobuf.Enum { - typealias RawValue = Int - case aprecedence // = 0 - - init() { - self = .aprecedence - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aprecedence - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aprecedence: return 0 - } + self = .aprecedence } } - enum prefix: SwiftProtobuf.Enum { - typealias RawValue = Int - case aprefix // = 0 + enum prefix: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aprefix = 0 init() { self = .aprefix } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aprefix - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aprefix: return 0 - } - } - } - enum required: SwiftProtobuf.Enum { - typealias RawValue = Int - case arequired // = 0 + enum required: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case arequired = 0 init() { self = .arequired } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .arequired - default: return nil - } - } - - var rawValue: Int { - switch self { - case .arequired: return 0 - } - } - } - enum right: SwiftProtobuf.Enum { - typealias RawValue = Int - case aright // = 0 + enum right: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aright = 0 init() { self = .aright } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aright - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aright: return 0 - } - } - } - enum set: SwiftProtobuf.Enum { - typealias RawValue = Int - case aset // = 0 + enum set: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aset = 0 init() { self = .aset } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aset - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aset: return 0 - } - } - } - enum TypeEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aType // = 0 + enum TypeEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aType = 0 init() { self = .aType } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aType - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aType: return 0 - } - } - } - enum unowned: SwiftProtobuf.Enum { - typealias RawValue = Int - case aunowned // = 0 + enum unowned: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aunowned = 0 init() { self = .aunowned } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aunowned - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aunowned: return 0 - } - } - } - enum weak: SwiftProtobuf.Enum { - typealias RawValue = Int - case aweak // = 0 + enum weak: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aweak = 0 init() { self = .aweak } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aweak - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aweak: return 0 - } - } - } - enum willSet: SwiftProtobuf.Enum { - typealias RawValue = Int - case awillSet // = 0 + enum willSet: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case awillSet = 0 init() { self = .awillSet } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .awillSet - default: return nil - } - } - - var rawValue: Int { - switch self { - case .awillSet: return 0 - } - } - } - enum id: SwiftProtobuf.Enum { - typealias RawValue = Int - case aid // = 0 + enum id: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aid = 0 init() { self = .aid } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aid - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aid: return 0 - } - } - } - enum _cmd: SwiftProtobuf.Enum { - typealias RawValue = Int - case aCmd // = 0 + enum _cmd: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aCmd = 0 init() { self = .aCmd } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aCmd - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aCmd: return 0 - } - } - } - enum out: SwiftProtobuf.Enum { - typealias RawValue = Int - case aout // = 0 + enum out: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aout = 0 init() { self = .aout } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aout - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aout: return 0 - } - } - } - enum bycopy: SwiftProtobuf.Enum { - typealias RawValue = Int - case abycopy // = 0 + enum bycopy: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case abycopy = 0 init() { self = .abycopy } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .abycopy - default: return nil - } - } - - var rawValue: Int { - switch self { - case .abycopy: return 0 - } - } - } - enum byref: SwiftProtobuf.Enum { - typealias RawValue = Int - case abyref // = 0 + enum byref: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case abyref = 0 init() { self = .abyref } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .abyref - default: return nil - } - } - - var rawValue: Int { - switch self { - case .abyref: return 0 - } - } - } - enum oneway: SwiftProtobuf.Enum { - typealias RawValue = Int - case aoneway // = 0 + enum oneway: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aoneway = 0 init() { self = .aoneway } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aoneway - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aoneway: return 0 - } - } - } - enum and: SwiftProtobuf.Enum { - typealias RawValue = Int - case aand // = 0 + enum and: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aand = 0 init() { self = .aand } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aand - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aand: return 0 - } - } - } - enum and_eq: SwiftProtobuf.Enum { - typealias RawValue = Int - case aandEq // = 0 + enum and_eq: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aandEq = 0 init() { self = .aandEq } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aandEq - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aandEq: return 0 - } - } - } - enum alignas: SwiftProtobuf.Enum { - typealias RawValue = Int - case aalignas // = 0 + enum alignas: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aalignas = 0 init() { self = .aalignas } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aalignas - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aalignas: return 0 - } - } - } - enum alignof: SwiftProtobuf.Enum { - typealias RawValue = Int - case aalignof // = 0 + enum alignof: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aalignof = 0 init() { self = .aalignof } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aalignof - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aalignof: return 0 - } - } - } - enum asm: SwiftProtobuf.Enum { - typealias RawValue = Int - case aasm // = 0 + enum asm: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aasm = 0 init() { self = .aasm } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aasm - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aasm: return 0 - } - } - } - enum auto: SwiftProtobuf.Enum { - typealias RawValue = Int - case aauto // = 0 + enum auto: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aauto = 0 init() { self = .aauto } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aauto - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aauto: return 0 - } - } - } - enum bitand: SwiftProtobuf.Enum { - typealias RawValue = Int - case abitand // = 0 + enum bitand: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case abitand = 0 init() { self = .abitand } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .abitand - default: return nil - } - } - - var rawValue: Int { - switch self { - case .abitand: return 0 - } - } - } - enum bitor: SwiftProtobuf.Enum { - typealias RawValue = Int - case abitor // = 0 + enum bitor: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case abitor = 0 init() { self = .abitor } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .abitor - default: return nil - } - } - - var rawValue: Int { - switch self { - case .abitor: return 0 - } - } - } - enum bool: SwiftProtobuf.Enum { - typealias RawValue = Int - case abool // = 0 + enum bool: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case abool = 0 init() { self = .abool } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .abool - default: return nil - } - } - - var rawValue: Int { - switch self { - case .abool: return 0 - } - } - } - enum char: SwiftProtobuf.Enum { - typealias RawValue = Int - case achar // = 0 + enum char: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case achar = 0 init() { self = .achar } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .achar - default: return nil - } - } - - var rawValue: Int { - switch self { - case .achar: return 0 - } - } - } - enum char16_t: SwiftProtobuf.Enum { - typealias RawValue = Int - case achar16T // = 0 + enum char16_t: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case achar16T = 0 init() { self = .achar16T } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .achar16T - default: return nil - } - } - - var rawValue: Int { - switch self { - case .achar16T: return 0 - } - } - } - enum char32_t: SwiftProtobuf.Enum { - typealias RawValue = Int - case achar32T // = 0 + enum char32_t: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case achar32T = 0 init() { self = .achar32T } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .achar32T - default: return nil - } - } - - var rawValue: Int { - switch self { - case .achar32T: return 0 - } - } - } - enum compl: SwiftProtobuf.Enum { - typealias RawValue = Int - case acompl // = 0 + enum compl: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case acompl = 0 init() { self = .acompl } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .acompl - default: return nil - } - } - - var rawValue: Int { - switch self { - case .acompl: return 0 - } - } - } - enum const: SwiftProtobuf.Enum { - typealias RawValue = Int - case aconst // = 0 + enum const: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aconst = 0 init() { self = .aconst } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aconst - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aconst: return 0 - } - } - } - enum constexpr: SwiftProtobuf.Enum { - typealias RawValue = Int - case aconstexpr // = 0 + enum constexpr: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aconstexpr = 0 init() { self = .aconstexpr } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aconstexpr - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aconstexpr: return 0 - } - } - } - enum const_cast: SwiftProtobuf.Enum { - typealias RawValue = Int - case aconstCast // = 0 + enum const_cast: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aconstCast = 0 init() { self = .aconstCast } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aconstCast - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aconstCast: return 0 - } - } - } - enum decltype: SwiftProtobuf.Enum { - typealias RawValue = Int - case adecltype // = 0 + enum decltype: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adecltype = 0 init() { self = .adecltype } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adecltype - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adecltype: return 0 - } - } - } - enum delete: SwiftProtobuf.Enum { - typealias RawValue = Int - case adelete // = 0 + enum delete: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adelete = 0 init() { self = .adelete } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adelete - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adelete: return 0 - } - } - } - enum dynamic_cast: SwiftProtobuf.Enum { - typealias RawValue = Int - case adynamicCast // = 0 + enum dynamic_cast: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adynamicCast = 0 init() { self = .adynamicCast } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adynamicCast - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adynamicCast: return 0 - } - } - } - enum explicit: SwiftProtobuf.Enum { - typealias RawValue = Int - case aexplicit // = 0 + enum explicit: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aexplicit = 0 init() { self = .aexplicit } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aexplicit - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aexplicit: return 0 - } - } - } - enum export: SwiftProtobuf.Enum { - typealias RawValue = Int - case aexport // = 0 + enum export: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aexport = 0 init() { self = .aexport } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aexport - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aexport: return 0 - } - } - } - enum extern: SwiftProtobuf.Enum { - typealias RawValue = Int - case aextern // = 0 + enum extern: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aextern = 0 init() { self = .aextern } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aextern - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aextern: return 0 - } - } - } - enum friend: SwiftProtobuf.Enum { - typealias RawValue = Int - case afriend // = 0 + enum friend: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case afriend = 0 init() { self = .afriend } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .afriend - default: return nil - } - } - - var rawValue: Int { - switch self { - case .afriend: return 0 - } - } - } - enum goto: SwiftProtobuf.Enum { - typealias RawValue = Int - case agoto // = 0 + enum goto: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case agoto = 0 init() { self = .agoto } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .agoto - default: return nil - } - } - - var rawValue: Int { - switch self { - case .agoto: return 0 - } - } - } - enum inline: SwiftProtobuf.Enum { - typealias RawValue = Int - case ainline // = 0 + enum inline: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ainline = 0 init() { self = .ainline } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ainline - default: return nil - } - } + } - var rawValue: Int { - switch self { - case .ainline: return 0 - } + enum long: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case along = 0 + + init() { + self = .along } } - enum long: SwiftProtobuf.Enum { - typealias RawValue = Int - case along // = 0 + enum mutable: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case amutable = 0 init() { - self = .along - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .along - default: return nil - } - } - - var rawValue: Int { - switch self { - case .along: return 0 - } - } - - } - - enum mutable: SwiftProtobuf.Enum { - typealias RawValue = Int - case amutable // = 0 - - init() { - self = .amutable - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .amutable - default: return nil - } - } - - var rawValue: Int { - switch self { - case .amutable: return 0 - } + self = .amutable } } - enum namespace: SwiftProtobuf.Enum { - typealias RawValue = Int - case anamespace // = 0 + enum namespace: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case anamespace = 0 init() { self = .anamespace } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .anamespace - default: return nil - } - } - - var rawValue: Int { - switch self { - case .anamespace: return 0 - } - } - } - enum new: SwiftProtobuf.Enum { - typealias RawValue = Int - case anew // = 0 + enum new: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case anew = 0 init() { self = .anew } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .anew - default: return nil - } - } - - var rawValue: Int { - switch self { - case .anew: return 0 - } - } - } - enum noexcept: SwiftProtobuf.Enum { - typealias RawValue = Int - case anoexcept // = 0 + enum noexcept: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case anoexcept = 0 init() { self = .anoexcept } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .anoexcept - default: return nil - } - } - - var rawValue: Int { - switch self { - case .anoexcept: return 0 - } - } - } - enum not: SwiftProtobuf.Enum { - typealias RawValue = Int - case anot // = 0 + enum not: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case anot = 0 init() { self = .anot } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .anot - default: return nil - } - } - - var rawValue: Int { - switch self { - case .anot: return 0 - } - } - } - enum not_eq: SwiftProtobuf.Enum { - typealias RawValue = Int - case anotEq // = 0 + enum not_eq: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case anotEq = 0 init() { self = .anotEq } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .anotEq - default: return nil - } - } - - var rawValue: Int { - switch self { - case .anotEq: return 0 - } - } - } - enum nullptr: SwiftProtobuf.Enum { - typealias RawValue = Int - case anullptr // = 0 + enum nullptr: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case anullptr = 0 init() { self = .anullptr } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .anullptr - default: return nil - } - } - - var rawValue: Int { - switch self { - case .anullptr: return 0 - } - } - } - enum or: SwiftProtobuf.Enum { - typealias RawValue = Int - case aor // = 0 + enum or: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aor = 0 init() { self = .aor } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aor - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aor: return 0 - } - } - } - enum or_eq: SwiftProtobuf.Enum { - typealias RawValue = Int - case aorEq // = 0 + enum or_eq: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aorEq = 0 init() { self = .aorEq } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aorEq - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aorEq: return 0 - } - } - } - enum protected: SwiftProtobuf.Enum { - typealias RawValue = Int - case aprotected // = 0 + enum protected: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aprotected = 0 init() { self = .aprotected } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aprotected - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aprotected: return 0 - } - } - } - enum register: SwiftProtobuf.Enum { - typealias RawValue = Int - case aregister // = 0 + enum register: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aregister = 0 init() { self = .aregister } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aregister - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aregister: return 0 - } - } - } - enum reinterpret_cast: SwiftProtobuf.Enum { - typealias RawValue = Int - case areinterpretCast // = 0 + enum reinterpret_cast: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case areinterpretCast = 0 init() { self = .areinterpretCast } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .areinterpretCast - default: return nil - } - } - - var rawValue: Int { - switch self { - case .areinterpretCast: return 0 - } - } - } - enum short: SwiftProtobuf.Enum { - typealias RawValue = Int - case ashort // = 0 + enum short: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ashort = 0 init() { self = .ashort } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ashort - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ashort: return 0 - } - } - } - enum signed: SwiftProtobuf.Enum { - typealias RawValue = Int - case asigned // = 0 + enum signed: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case asigned = 0 init() { self = .asigned } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .asigned - default: return nil - } - } - - var rawValue: Int { - switch self { - case .asigned: return 0 - } - } - } - enum sizeof: SwiftProtobuf.Enum { - typealias RawValue = Int - case asizeof // = 0 + enum sizeof: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case asizeof = 0 init() { self = .asizeof } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .asizeof - default: return nil - } - } - - var rawValue: Int { - switch self { - case .asizeof: return 0 - } - } - } - enum static_assert: SwiftProtobuf.Enum { - typealias RawValue = Int - case astaticAssert // = 0 + enum static_assert: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case astaticAssert = 0 init() { self = .astaticAssert } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .astaticAssert - default: return nil - } - } - - var rawValue: Int { - switch self { - case .astaticAssert: return 0 - } - } - } - enum static_cast: SwiftProtobuf.Enum { - typealias RawValue = Int - case astaticCast // = 0 + enum static_cast: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case astaticCast = 0 init() { self = .astaticCast } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .astaticCast - default: return nil - } - } - - var rawValue: Int { - switch self { - case .astaticCast: return 0 - } - } - } - enum template: SwiftProtobuf.Enum { - typealias RawValue = Int - case atemplate // = 0 + enum template: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case atemplate = 0 init() { self = .atemplate } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .atemplate - default: return nil - } - } - - var rawValue: Int { - switch self { - case .atemplate: return 0 - } - } - } - enum this: SwiftProtobuf.Enum { - typealias RawValue = Int - case athis // = 0 + enum this: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case athis = 0 init() { self = .athis } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .athis - default: return nil - } - } - - var rawValue: Int { - switch self { - case .athis: return 0 - } - } - } - enum thread_local: SwiftProtobuf.Enum { - typealias RawValue = Int - case athreadLocal // = 0 + enum thread_local: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case athreadLocal = 0 init() { self = .athreadLocal } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .athreadLocal - default: return nil - } - } - - var rawValue: Int { - switch self { - case .athreadLocal: return 0 - } - } - } - enum typedef: SwiftProtobuf.Enum { - typealias RawValue = Int - case atypedef // = 0 + enum typedef: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case atypedef = 0 init() { self = .atypedef } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .atypedef - default: return nil - } - } - - var rawValue: Int { - switch self { - case .atypedef: return 0 - } - } - } - enum typeid: SwiftProtobuf.Enum { - typealias RawValue = Int - case atypeid // = 0 + enum typeid: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case atypeid = 0 init() { self = .atypeid } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .atypeid - default: return nil - } - } - - var rawValue: Int { - switch self { - case .atypeid: return 0 - } - } - } - enum typename: SwiftProtobuf.Enum { - typealias RawValue = Int - case atypename // = 0 + enum typename: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case atypename = 0 init() { self = .atypename } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .atypename - default: return nil - } - } - - var rawValue: Int { - switch self { - case .atypename: return 0 - } - } - } - enum union: SwiftProtobuf.Enum { - typealias RawValue = Int - case aunion // = 0 + enum union: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aunion = 0 init() { self = .aunion } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aunion - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aunion: return 0 - } - } - } - enum unsigned: SwiftProtobuf.Enum { - typealias RawValue = Int - case aunsigned // = 0 + enum unsigned: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aunsigned = 0 init() { self = .aunsigned } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aunsigned - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aunsigned: return 0 - } - } - } - enum using: SwiftProtobuf.Enum { - typealias RawValue = Int - case ausing // = 0 + enum using: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ausing = 0 init() { self = .ausing } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ausing - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ausing: return 0 - } - } - } - enum virtual: SwiftProtobuf.Enum { - typealias RawValue = Int - case avirtual // = 0 + enum virtual: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case avirtual = 0 init() { self = .avirtual } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .avirtual - default: return nil - } - } - - var rawValue: Int { - switch self { - case .avirtual: return 0 - } - } - } - enum void: SwiftProtobuf.Enum { - typealias RawValue = Int - case avoid // = 0 + enum void: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case avoid = 0 init() { self = .avoid } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .avoid - default: return nil - } - } - - var rawValue: Int { - switch self { - case .avoid: return 0 - } - } - } - enum volatile: SwiftProtobuf.Enum { - typealias RawValue = Int - case avolatile // = 0 + enum volatile: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case avolatile = 0 init() { self = .avolatile } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .avolatile - default: return nil - } - } - - var rawValue: Int { - switch self { - case .avolatile: return 0 - } - } - } - enum wchar_t: SwiftProtobuf.Enum { - typealias RawValue = Int - case awcharT // = 0 + enum wchar_t: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case awcharT = 0 init() { self = .awcharT } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .awcharT - default: return nil - } - } - - var rawValue: Int { - switch self { - case .awcharT: return 0 - } - } - } - enum xor: SwiftProtobuf.Enum { - typealias RawValue = Int - case axor // = 0 + enum xor: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case axor = 0 init() { self = .axor } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .axor - default: return nil - } - } - - var rawValue: Int { - switch self { - case .axor: return 0 - } - } - } - enum xor_eq: SwiftProtobuf.Enum { - typealias RawValue = Int - case axorEq // = 0 + enum xor_eq: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case axorEq = 0 init() { self = .axorEq } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .axorEq - default: return nil - } - } - - var rawValue: Int { - switch self { - case .axorEq: return 0 - } - } - } - enum restrict: SwiftProtobuf.Enum { - typealias RawValue = Int - case arestrict // = 0 + enum restrict: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case arestrict = 0 init() { self = .arestrict } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .arestrict - default: return nil - } - } - - var rawValue: Int { - switch self { - case .arestrict: return 0 - } - } - } - enum Category: SwiftProtobuf.Enum { - typealias RawValue = Int - case aCategory // = 0 + enum Category: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aCategory = 0 init() { self = .aCategory } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aCategory - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aCategory: return 0 - } - } - } - enum Ivar: SwiftProtobuf.Enum { - typealias RawValue = Int - case aIvar // = 0 + enum Ivar: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aIvar = 0 init() { self = .aIvar } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aIvar - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aIvar: return 0 - } - } - } - enum Method: SwiftProtobuf.Enum { - typealias RawValue = Int - case aMethod // = 0 + enum Method: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aMethod = 0 init() { self = .aMethod } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aMethod - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aMethod: return 0 - } - } - } - enum finalize: SwiftProtobuf.Enum { - typealias RawValue = Int - case afinalize // = 0 + enum finalize: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case afinalize = 0 init() { self = .afinalize } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .afinalize - default: return nil - } - } - - var rawValue: Int { - switch self { - case .afinalize: return 0 - } - } - } - enum hash: SwiftProtobuf.Enum { - typealias RawValue = Int - case ahash // = 0 + enum hash: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case ahash = 0 init() { self = .ahash } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .ahash - default: return nil - } - } - - var rawValue: Int { - switch self { - case .ahash: return 0 - } - } - } - enum dealloc: SwiftProtobuf.Enum { - typealias RawValue = Int - case adealloc // = 0 + enum dealloc: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adealloc = 0 init() { self = .adealloc } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adealloc - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adealloc: return 0 - } - } - } - enum superclass: SwiftProtobuf.Enum { - typealias RawValue = Int - case asuperclass // = 0 + enum superclass: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case asuperclass = 0 init() { self = .asuperclass } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .asuperclass - default: return nil - } - } + } - var rawValue: Int { - switch self { - case .asuperclass: return 0 - } + enum retain: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aretain = 0 + + init() { + self = .aretain } } - enum retain: SwiftProtobuf.Enum { - typealias RawValue = Int - case aretain // = 0 + enum release: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case arelease = 0 init() { - self = .aretain - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aretain - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aretain: return 0 - } - } - - } - - enum release: SwiftProtobuf.Enum { - typealias RawValue = Int - case arelease // = 0 - - init() { - self = .arelease - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .arelease - default: return nil - } - } - - var rawValue: Int { - switch self { - case .arelease: return 0 - } + self = .arelease } } - enum autorelease: SwiftProtobuf.Enum { - typealias RawValue = Int - case aautorelease // = 0 + enum autorelease: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aautorelease = 0 init() { self = .aautorelease } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aautorelease - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aautorelease: return 0 - } - } - } - enum retainCount: SwiftProtobuf.Enum { - typealias RawValue = Int - case aretainCount // = 0 + enum retainCount: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aretainCount = 0 init() { self = .aretainCount } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aretainCount - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aretainCount: return 0 - } - } - } - enum zone: SwiftProtobuf.Enum { - typealias RawValue = Int - case azone // = 0 + enum zone: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case azone = 0 init() { self = .azone } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .azone - default: return nil - } - } - - var rawValue: Int { - switch self { - case .azone: return 0 - } - } - } - enum isProxy: SwiftProtobuf.Enum { - typealias RawValue = Int - case aisProxy // = 0 + enum isProxy: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aisProxy = 0 init() { self = .aisProxy } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aisProxy - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aisProxy: return 0 - } - } - } - enum copy: SwiftProtobuf.Enum { - typealias RawValue = Int - case acopy // = 0 + enum copy: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case acopy = 0 init() { self = .acopy } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .acopy - default: return nil - } - } - - var rawValue: Int { - switch self { - case .acopy: return 0 - } - } - } - enum mutableCopy: SwiftProtobuf.Enum { - typealias RawValue = Int - case amutableCopy // = 0 + enum mutableCopy: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case amutableCopy = 0 init() { self = .amutableCopy } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .amutableCopy - default: return nil - } - } - - var rawValue: Int { - switch self { - case .amutableCopy: return 0 - } - } - } - enum classForCoder: SwiftProtobuf.Enum { - typealias RawValue = Int - case aclassForCoder // = 0 + enum classForCoder: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aclassForCoder = 0 init() { self = .aclassForCoder } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aclassForCoder - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aclassForCoder: return 0 - } - } - } - enum clear: SwiftProtobuf.Enum { - typealias RawValue = Int - case aclear // = 0 + enum clear: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aclear = 0 init() { self = .aclear } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aclear - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aclear: return 0 - } - } - } - enum data: SwiftProtobuf.Enum { - typealias RawValue = Int - case adata // = 0 + enum data: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adata = 0 init() { self = .adata } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adata - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adata: return 0 - } - } - } - enum delimitedData: SwiftProtobuf.Enum { - typealias RawValue = Int - case adelimitedData // = 0 + enum delimitedData: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adelimitedData = 0 init() { self = .adelimitedData } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adelimitedData - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adelimitedData: return 0 - } - } - } - enum descriptor: SwiftProtobuf.Enum { - typealias RawValue = Int - case adescriptor // = 0 + enum descriptor: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case adescriptor = 0 init() { self = .adescriptor } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .adescriptor - default: return nil - } - } - - var rawValue: Int { - switch self { - case .adescriptor: return 0 - } - } - } - enum extensionRegistry: SwiftProtobuf.Enum { - typealias RawValue = Int - case aextensionRegistry // = 0 + enum extensionRegistry: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aextensionRegistry = 0 init() { self = .aextensionRegistry } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aextensionRegistry - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aextensionRegistry: return 0 - } - } - } - enum extensionsCurrentlySet: SwiftProtobuf.Enum { - typealias RawValue = Int - case aextensionsCurrentlySet // = 0 + enum extensionsCurrentlySet: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aextensionsCurrentlySet = 0 init() { self = .aextensionsCurrentlySet } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aextensionsCurrentlySet - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aextensionsCurrentlySet: return 0 - } - } - } - enum isInitializedEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aisInitialized // = 0 + enum isInitializedEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aisInitialized = 0 init() { self = .aisInitialized } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aisInitialized - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aisInitialized: return 0 - } - } - } - enum serializedSize: SwiftProtobuf.Enum { - typealias RawValue = Int - case aserializedSize // = 0 + enum serializedSize: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aserializedSize = 0 init() { self = .aserializedSize } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aserializedSize - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aserializedSize: return 0 - } - } - } - enum sortedExtensionsInUse: SwiftProtobuf.Enum { - typealias RawValue = Int - case asortedExtensionsInUse // = 0 + enum sortedExtensionsInUse: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case asortedExtensionsInUse = 0 init() { self = .asortedExtensionsInUse - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .asortedExtensionsInUse - default: return nil - } - } - - var rawValue: Int { - switch self { - case .asortedExtensionsInUse: return 0 - } - } - - } - - enum unknownFieldsEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aunknownFields // = 0 - - init() { - self = .aunknownFields - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aunknownFields - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aunknownFields: return 0 - } - } - - } - - enum Fixed: SwiftProtobuf.Enum { - typealias RawValue = Int - case aFixed // = 0 - - init() { - self = .aFixed - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aFixed - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aFixed: return 0 - } - } - - } - - enum Fract: SwiftProtobuf.Enum { - typealias RawValue = Int - case aFract // = 0 - - init() { - self = .aFract - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aFract - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aFract: return 0 - } - } - - } - - enum Size: SwiftProtobuf.Enum { - typealias RawValue = Int - case aSize // = 0 - - init() { - self = .aSize - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aSize - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aSize: return 0 - } - } - - } - - enum LogicalAddress: SwiftProtobuf.Enum { - typealias RawValue = Int - case aLogicalAddress // = 0 - - init() { - self = .aLogicalAddress - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aLogicalAddress - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aLogicalAddress: return 0 - } - } - - } - - enum PhysicalAddress: SwiftProtobuf.Enum { - typealias RawValue = Int - case aPhysicalAddress // = 0 - - init() { - self = .aPhysicalAddress - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aPhysicalAddress - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aPhysicalAddress: return 0 - } - } - - } - - enum ByteCount: SwiftProtobuf.Enum { - typealias RawValue = Int - case aByteCount // = 0 - - init() { - self = .aByteCount - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aByteCount - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aByteCount: return 0 - } - } - - } - - enum ByteOffset: SwiftProtobuf.Enum { - typealias RawValue = Int - case aByteOffset // = 0 - - init() { - self = .aByteOffset - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aByteOffset - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aByteOffset: return 0 - } - } - - } - - enum Duration: SwiftProtobuf.Enum { - typealias RawValue = Int - case aDuration // = 0 - - init() { - self = .aDuration - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aDuration - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aDuration: return 0 - } - } - - } - - enum AbsoluteTime: SwiftProtobuf.Enum { - typealias RawValue = Int - case aAbsoluteTime // = 0 - - init() { - self = .aAbsoluteTime - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aAbsoluteTime - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aAbsoluteTime: return 0 - } - } - - } - - enum OptionBits: SwiftProtobuf.Enum { - typealias RawValue = Int - case aOptionBits // = 0 - - init() { - self = .aOptionBits - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aOptionBits - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aOptionBits: return 0 - } - } - - } - - enum ItemCount: SwiftProtobuf.Enum { - typealias RawValue = Int - case aItemCount // = 0 - - init() { - self = .aItemCount - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aItemCount - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aItemCount: return 0 - } - } - - } - - enum PBVersion: SwiftProtobuf.Enum { - typealias RawValue = Int - case aPbversion // = 0 - - init() { - self = .aPbversion - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aPbversion - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aPbversion: return 0 - } - } - - } - - enum ScriptCode: SwiftProtobuf.Enum { - typealias RawValue = Int - case aScriptCode // = 0 - - init() { - self = .aScriptCode - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aScriptCode - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aScriptCode: return 0 - } - } - - } - - enum LangCode: SwiftProtobuf.Enum { - typealias RawValue = Int - case aLangCode // = 0 - - init() { - self = .aLangCode - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aLangCode - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aLangCode: return 0 - } - } - - } - - enum RegionCode: SwiftProtobuf.Enum { - typealias RawValue = Int - case aRegionCode // = 0 - - init() { - self = .aRegionCode - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aRegionCode - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aRegionCode: return 0 - } - } - - } - - enum OSType: SwiftProtobuf.Enum { - typealias RawValue = Int - case aOstype // = 0 - - init() { - self = .aOstype - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aOstype - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aOstype: return 0 - } - } - - } - - enum ProcessSerialNumber: SwiftProtobuf.Enum { - typealias RawValue = Int - case aProcessSerialNumber // = 0 - - init() { - self = .aProcessSerialNumber - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aProcessSerialNumber - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aProcessSerialNumber: return 0 - } - } - - } - - enum Point: SwiftProtobuf.Enum { - typealias RawValue = Int - case aPoint // = 0 - - init() { - self = .aPoint - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aPoint - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aPoint: return 0 - } - } - - } - - enum Rect: SwiftProtobuf.Enum { - typealias RawValue = Int - case aRect // = 0 - - init() { - self = .aRect - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aRect - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aRect: return 0 - } - } - - } - - enum FixedPoint: SwiftProtobuf.Enum { - typealias RawValue = Int - case aFixedPoint // = 0 - - init() { - self = .aFixedPoint - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aFixedPoint - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aFixedPoint: return 0 - } - } - - } - - enum FixedRect: SwiftProtobuf.Enum { - typealias RawValue = Int - case aFixedRect // = 0 - - init() { - self = .aFixedRect - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aFixedRect - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aFixedRect: return 0 - } - } - - } - - enum Style: SwiftProtobuf.Enum { - typealias RawValue = Int - case aStyle // = 0 - - init() { - self = .aStyle - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aStyle - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aStyle: return 0 - } - } - - } - - enum StyleParameter: SwiftProtobuf.Enum { - typealias RawValue = Int - case aStyleParameter // = 0 - - init() { - self = .aStyleParameter - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aStyleParameter - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aStyleParameter: return 0 - } - } - - } - - enum StyleField: SwiftProtobuf.Enum { - typealias RawValue = Int - case aStyleField // = 0 - - init() { - self = .aStyleField - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aStyleField - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aStyleField: return 0 - } - } - - } - - enum TimeScale: SwiftProtobuf.Enum { - typealias RawValue = Int - case aTimeScale // = 0 - - init() { - self = .aTimeScale - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aTimeScale - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aTimeScale: return 0 - } - } - - } - - enum TimeBase: SwiftProtobuf.Enum { - typealias RawValue = Int - case aTimeBase // = 0 - - init() { - self = .aTimeBase - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aTimeBase - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aTimeBase: return 0 - } - } - - } - - enum TimeRecord: SwiftProtobuf.Enum { - typealias RawValue = Int - case aTimeRecord // = 0 - - init() { - self = .aTimeRecord - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aTimeRecord - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aTimeRecord: return 0 - } - } - - } - - enum Extension: SwiftProtobuf.Enum { - typealias RawValue = Int - case aExtension // = 0 - - init() { - self = .aExtension - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aExtension - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aExtension: return 0 - } - } - - } - - enum ExtensionsEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case aExtensions // = 0 - - init() { - self = .aExtensions - } - - init?(rawValue: Int) { - switch rawValue { - case 0: self = .aExtensions - default: return nil - } - } - - var rawValue: Int { - switch self { - case .aExtensions: return 0 - } - } - - } - - init() {} -} - -#if swift(>=4.2) - -extension SwiftUnittest_Names_EnumNames.StringEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.ProtocolEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.IntEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.DoubleEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.FloatEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.UIntEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.hashValueEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.descriptionEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.debugDescriptionEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.Swift: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.UNRECOGNIZED: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.classEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.deinitEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.enumEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.extensionEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.funcEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.importEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.initEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.inoutEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.internalEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.letEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.operatorEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.privateEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.protocolEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.publicEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.staticEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.structEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.subscriptEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.typealiasEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.varEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.breakEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.caseEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.continueEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.defaultEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.deferEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.doEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.elseEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.fallthroughEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.forEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.guardEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.ifEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.inEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.repeatEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.returnEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.switchEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.whereEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.whileEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.asEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.catchEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.dynamicTypeEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.falseEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.isEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.nilEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.rethrowsEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.superEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.selfEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.throwEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.throwsEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.trueEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.tryEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.__COLUMN__Enum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.__FILE__Enum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.__FUNCTION__Enum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.__LINE__Enum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames._Enum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.__Enum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.associativity: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.convenience: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.dynamic: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.didSet: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.final: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.get: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.infix: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.indirect: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.lazy: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.left: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.mutating: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.none: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.nonmutating: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.optional: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.override: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.postfix: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.precedence: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.prefix: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.required: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.right: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.set: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.TypeEnum: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.unowned: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.weak: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.willSet: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.id: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames._cmd: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.out: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.bycopy: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.byref: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.oneway: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.and: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.and_eq: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.alignas: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.alignof: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.asm: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.auto: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.bitand: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.bitor: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.bool: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.char: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.char16_t: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.char32_t: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.compl: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.const: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.constexpr: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.const_cast: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.decltype: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.delete: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.dynamic_cast: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.explicit: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.export: CaseIterable { - // Support synthesized by the compiler. -} - -extension SwiftUnittest_Names_EnumNames.extern: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.friend: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.goto: CaseIterable { - // Support synthesized by the compiler. -} + enum unknownFieldsEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aunknownFields = 0 -extension SwiftUnittest_Names_EnumNames.inline: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aunknownFields + } -extension SwiftUnittest_Names_EnumNames.long: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.mutable: CaseIterable { - // Support synthesized by the compiler. -} + enum Fixed: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aFixed = 0 -extension SwiftUnittest_Names_EnumNames.namespace: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aFixed + } -extension SwiftUnittest_Names_EnumNames.new: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.noexcept: CaseIterable { - // Support synthesized by the compiler. -} + enum Fract: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aFract = 0 -extension SwiftUnittest_Names_EnumNames.not: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aFract + } -extension SwiftUnittest_Names_EnumNames.not_eq: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.nullptr: CaseIterable { - // Support synthesized by the compiler. -} + enum Size: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aSize = 0 -extension SwiftUnittest_Names_EnumNames.or: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aSize + } -extension SwiftUnittest_Names_EnumNames.or_eq: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.protected: CaseIterable { - // Support synthesized by the compiler. -} + enum LogicalAddress: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aLogicalAddress = 0 -extension SwiftUnittest_Names_EnumNames.register: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aLogicalAddress + } -extension SwiftUnittest_Names_EnumNames.reinterpret_cast: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.short: CaseIterable { - // Support synthesized by the compiler. -} + enum PhysicalAddress: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aPhysicalAddress = 0 -extension SwiftUnittest_Names_EnumNames.signed: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aPhysicalAddress + } -extension SwiftUnittest_Names_EnumNames.sizeof: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.static_assert: CaseIterable { - // Support synthesized by the compiler. -} + enum ByteCount: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aByteCount = 0 -extension SwiftUnittest_Names_EnumNames.static_cast: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aByteCount + } -extension SwiftUnittest_Names_EnumNames.template: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.this: CaseIterable { - // Support synthesized by the compiler. -} + enum ByteOffset: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aByteOffset = 0 -extension SwiftUnittest_Names_EnumNames.thread_local: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aByteOffset + } -extension SwiftUnittest_Names_EnumNames.typedef: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.typeid: CaseIterable { - // Support synthesized by the compiler. -} + enum Duration: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aDuration = 0 -extension SwiftUnittest_Names_EnumNames.typename: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aDuration + } -extension SwiftUnittest_Names_EnumNames.union: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.unsigned: CaseIterable { - // Support synthesized by the compiler. -} + enum AbsoluteTime: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aAbsoluteTime = 0 -extension SwiftUnittest_Names_EnumNames.using: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aAbsoluteTime + } -extension SwiftUnittest_Names_EnumNames.virtual: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.void: CaseIterable { - // Support synthesized by the compiler. -} + enum OptionBits: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aOptionBits = 0 -extension SwiftUnittest_Names_EnumNames.volatile: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aOptionBits + } -extension SwiftUnittest_Names_EnumNames.wchar_t: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.xor: CaseIterable { - // Support synthesized by the compiler. -} + enum ItemCount: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aItemCount = 0 -extension SwiftUnittest_Names_EnumNames.xor_eq: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aItemCount + } -extension SwiftUnittest_Names_EnumNames.restrict: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.Category: CaseIterable { - // Support synthesized by the compiler. -} + enum PBVersion: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aPbversion = 0 -extension SwiftUnittest_Names_EnumNames.Ivar: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aPbversion + } -extension SwiftUnittest_Names_EnumNames.Method: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.finalize: CaseIterable { - // Support synthesized by the compiler. -} + enum ScriptCode: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aScriptCode = 0 -extension SwiftUnittest_Names_EnumNames.hash: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aScriptCode + } -extension SwiftUnittest_Names_EnumNames.dealloc: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.superclass: CaseIterable { - // Support synthesized by the compiler. -} + enum LangCode: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aLangCode = 0 -extension SwiftUnittest_Names_EnumNames.retain: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aLangCode + } -extension SwiftUnittest_Names_EnumNames.release: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.autorelease: CaseIterable { - // Support synthesized by the compiler. -} + enum RegionCode: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aRegionCode = 0 -extension SwiftUnittest_Names_EnumNames.retainCount: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aRegionCode + } -extension SwiftUnittest_Names_EnumNames.zone: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.isProxy: CaseIterable { - // Support synthesized by the compiler. -} + enum OSType: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aOstype = 0 -extension SwiftUnittest_Names_EnumNames.copy: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aOstype + } -extension SwiftUnittest_Names_EnumNames.mutableCopy: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.classForCoder: CaseIterable { - // Support synthesized by the compiler. -} + enum ProcessSerialNumber: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aProcessSerialNumber = 0 -extension SwiftUnittest_Names_EnumNames.clear: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aProcessSerialNumber + } -extension SwiftUnittest_Names_EnumNames.data: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.delimitedData: CaseIterable { - // Support synthesized by the compiler. -} + enum Point: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aPoint = 0 -extension SwiftUnittest_Names_EnumNames.descriptor: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aPoint + } -extension SwiftUnittest_Names_EnumNames.extensionRegistry: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.extensionsCurrentlySet: CaseIterable { - // Support synthesized by the compiler. -} + enum Rect: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aRect = 0 -extension SwiftUnittest_Names_EnumNames.isInitializedEnum: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aRect + } -extension SwiftUnittest_Names_EnumNames.serializedSize: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.sortedExtensionsInUse: CaseIterable { - // Support synthesized by the compiler. -} + enum FixedPoint: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aFixedPoint = 0 -extension SwiftUnittest_Names_EnumNames.unknownFieldsEnum: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aFixedPoint + } -extension SwiftUnittest_Names_EnumNames.Fixed: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.Fract: CaseIterable { - // Support synthesized by the compiler. -} + enum FixedRect: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aFixedRect = 0 -extension SwiftUnittest_Names_EnumNames.Size: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aFixedRect + } -extension SwiftUnittest_Names_EnumNames.LogicalAddress: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.PhysicalAddress: CaseIterable { - // Support synthesized by the compiler. -} + enum Style: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aStyle = 0 -extension SwiftUnittest_Names_EnumNames.ByteCount: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aStyle + } -extension SwiftUnittest_Names_EnumNames.ByteOffset: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.Duration: CaseIterable { - // Support synthesized by the compiler. -} + enum StyleParameter: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aStyleParameter = 0 -extension SwiftUnittest_Names_EnumNames.AbsoluteTime: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aStyleParameter + } -extension SwiftUnittest_Names_EnumNames.OptionBits: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.ItemCount: CaseIterable { - // Support synthesized by the compiler. -} + enum StyleField: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aStyleField = 0 -extension SwiftUnittest_Names_EnumNames.PBVersion: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aStyleField + } -extension SwiftUnittest_Names_EnumNames.ScriptCode: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.LangCode: CaseIterable { - // Support synthesized by the compiler. -} + enum TimeScale: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aTimeScale = 0 -extension SwiftUnittest_Names_EnumNames.RegionCode: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aTimeScale + } -extension SwiftUnittest_Names_EnumNames.OSType: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.ProcessSerialNumber: CaseIterable { - // Support synthesized by the compiler. -} + enum TimeBase: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aTimeBase = 0 -extension SwiftUnittest_Names_EnumNames.Point: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aTimeBase + } -extension SwiftUnittest_Names_EnumNames.Rect: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.FixedPoint: CaseIterable { - // Support synthesized by the compiler. -} + enum TimeRecord: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aTimeRecord = 0 -extension SwiftUnittest_Names_EnumNames.FixedRect: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aTimeRecord + } -extension SwiftUnittest_Names_EnumNames.Style: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.StyleParameter: CaseIterable { - // Support synthesized by the compiler. -} + enum Extension: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aExtension = 0 -extension SwiftUnittest_Names_EnumNames.StyleField: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aExtension + } -extension SwiftUnittest_Names_EnumNames.TimeScale: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.TimeBase: CaseIterable { - // Support synthesized by the compiler. -} + enum ExtensionsEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case aExtensions = 0 -extension SwiftUnittest_Names_EnumNames.TimeRecord: CaseIterable { - // Support synthesized by the compiler. -} + init() { + self = .aExtensions + } -extension SwiftUnittest_Names_EnumNames.Extension: CaseIterable { - // Support synthesized by the compiler. -} + } -extension SwiftUnittest_Names_EnumNames.ExtensionsEnum: CaseIterable { - // Support synthesized by the compiler. + init() {} } -#endif // swift(>=4.2) - -struct SwiftUnittest_Names_FieldNamingInitials { +struct SwiftProtoTesting_Names_FieldNamingInitials: Sendable { // 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() - struct Lowers { + struct Lowers: @unchecked Sendable { // 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 http: Int32 { - get {return _storage._http ?? 0} + get {_storage._http ?? 0} set {_uniqueStorage()._http = newValue} } /// Returns true if `http` has been explicitly set. - var hasHTTP: Bool {return _storage._http != nil} + var hasHTTP: Bool {_storage._http != nil} /// Clears the value of `http`. Subsequent reads from it will return its default value. mutating func clearHTTP() {_uniqueStorage()._http = nil} var httpRequest: Int32 { - get {return _storage._httpRequest ?? 0} + get {_storage._httpRequest ?? 0} set {_uniqueStorage()._httpRequest = newValue} } /// Returns true if `httpRequest` has been explicitly set. - var hasHTTPRequest: Bool {return _storage._httpRequest != nil} + var hasHTTPRequest: Bool {_storage._httpRequest != nil} /// Clears the value of `httpRequest`. Subsequent reads from it will return its default value. mutating func clearHTTPRequest() {_uniqueStorage()._httpRequest = nil} var theHTTPRequest: Int32 { - get {return _storage._theHTTPRequest ?? 0} + get {_storage._theHTTPRequest ?? 0} set {_uniqueStorage()._theHTTPRequest = newValue} } /// Returns true if `theHTTPRequest` has been explicitly set. - var hasTheHTTPRequest: Bool {return _storage._theHTTPRequest != nil} + var hasTheHTTPRequest: Bool {_storage._theHTTPRequest != nil} /// Clears the value of `theHTTPRequest`. Subsequent reads from it will return its default value. mutating func clearTheHTTPRequest() {_uniqueStorage()._theHTTPRequest = nil} var theHTTP: Int32 { - get {return _storage._theHTTP ?? 0} + get {_storage._theHTTP ?? 0} set {_uniqueStorage()._theHTTP = newValue} } /// Returns true if `theHTTP` has been explicitly set. - var hasTheHTTP: Bool {return _storage._theHTTP != nil} + var hasTheHTTP: Bool {_storage._theHTTP != nil} /// Clears the value of `theHTTP`. Subsequent reads from it will return its default value. mutating func clearTheHTTP() {_uniqueStorage()._theHTTP = nil} var https: Int32 { - get {return _storage._https ?? 0} + get {_storage._https ?? 0} set {_uniqueStorage()._https = newValue} } /// Returns true if `https` has been explicitly set. - var hasHTTPS: Bool {return _storage._https != nil} + var hasHTTPS: Bool {_storage._https != nil} /// Clears the value of `https`. Subsequent reads from it will return its default value. mutating func clearHTTPS() {_uniqueStorage()._https = nil} var httpsRequest: Int32 { - get {return _storage._httpsRequest ?? 0} + get {_storage._httpsRequest ?? 0} set {_uniqueStorage()._httpsRequest = newValue} } /// Returns true if `httpsRequest` has been explicitly set. - var hasHTTPSRequest: Bool {return _storage._httpsRequest != nil} + var hasHTTPSRequest: Bool {_storage._httpsRequest != nil} /// Clears the value of `httpsRequest`. Subsequent reads from it will return its default value. mutating func clearHTTPSRequest() {_uniqueStorage()._httpsRequest = nil} var theHTTPSRequest: Int32 { - get {return _storage._theHTTPSRequest ?? 0} + get {_storage._theHTTPSRequest ?? 0} set {_uniqueStorage()._theHTTPSRequest = newValue} } /// Returns true if `theHTTPSRequest` has been explicitly set. - var hasTheHTTPSRequest: Bool {return _storage._theHTTPSRequest != nil} + var hasTheHTTPSRequest: Bool {_storage._theHTTPSRequest != nil} /// Clears the value of `theHTTPSRequest`. Subsequent reads from it will return its default value. mutating func clearTheHTTPSRequest() {_uniqueStorage()._theHTTPSRequest = nil} var theHTTPS: Int32 { - get {return _storage._theHTTPS ?? 0} + get {_storage._theHTTPS ?? 0} set {_uniqueStorage()._theHTTPS = newValue} } /// Returns true if `theHTTPS` has been explicitly set. - var hasTheHTTPS: Bool {return _storage._theHTTPS != nil} + var hasTheHTTPS: Bool {_storage._theHTTPS != nil} /// Clears the value of `theHTTPS`. Subsequent reads from it will return its default value. mutating func clearTheHTTPS() {_uniqueStorage()._theHTTPS = nil} var url: Int32 { - get {return _storage._url ?? 0} + get {_storage._url ?? 0} set {_uniqueStorage()._url = newValue} } /// Returns true if `url` has been explicitly set. - var hasURL: Bool {return _storage._url != nil} + var hasURL: Bool {_storage._url != nil} /// Clears the value of `url`. Subsequent reads from it will return its default value. mutating func clearURL() {_uniqueStorage()._url = nil} var urlValue: Int32 { - get {return _storage._urlValue ?? 0} + get {_storage._urlValue ?? 0} set {_uniqueStorage()._urlValue = newValue} } /// Returns true if `urlValue` has been explicitly set. - var hasURLValue: Bool {return _storage._urlValue != nil} + var hasURLValue: Bool {_storage._urlValue != nil} /// Clears the value of `urlValue`. Subsequent reads from it will return its default value. mutating func clearURLValue() {_uniqueStorage()._urlValue = nil} var theURLValue: Int32 { - get {return _storage._theURLValue ?? 0} + get {_storage._theURLValue ?? 0} set {_uniqueStorage()._theURLValue = newValue} } /// Returns true if `theURLValue` has been explicitly set. - var hasTheURLValue: Bool {return _storage._theURLValue != nil} + var hasTheURLValue: Bool {_storage._theURLValue != nil} /// Clears the value of `theURLValue`. Subsequent reads from it will return its default value. mutating func clearTheURLValue() {_uniqueStorage()._theURLValue = nil} var theURL: Int32 { - get {return _storage._theURL ?? 0} + get {_storage._theURL ?? 0} set {_uniqueStorage()._theURL = newValue} } /// Returns true if `theURL` has been explicitly set. - var hasTheURL: Bool {return _storage._theURL != nil} + var hasTheURL: Bool {_storage._theURL != nil} /// Clears the value of `theURL`. Subsequent reads from it will return its default value. mutating func clearTheURL() {_uniqueStorage()._theURL = nil} var aBC: Int32 { - get {return _storage._aBC ?? 0} + get {_storage._aBC ?? 0} set {_uniqueStorage()._aBC = newValue} } /// Returns true if `aBC` has been explicitly set. - var hasABC: Bool {return _storage._aBC != nil} + var hasABC: Bool {_storage._aBC != nil} /// Clears the value of `aBC`. Subsequent reads from it will return its default value. mutating func clearABC() {_uniqueStorage()._aBC = nil} var id: Int32 { - get {return _storage._id ?? 0} + get {_storage._id ?? 0} set {_uniqueStorage()._id = newValue} } /// Returns true if `id` has been explicitly set. - var hasID: Bool {return _storage._id != nil} + var hasID: Bool {_storage._id != nil} /// Clears the value of `id`. Subsequent reads from it will return its default value. mutating func clearID() {_uniqueStorage()._id = nil} var idNumber: Int32 { - get {return _storage._idNumber ?? 0} + get {_storage._idNumber ?? 0} set {_uniqueStorage()._idNumber = newValue} } /// Returns true if `idNumber` has been explicitly set. - var hasIDNumber: Bool {return _storage._idNumber != nil} + var hasIDNumber: Bool {_storage._idNumber != nil} /// Clears the value of `idNumber`. Subsequent reads from it will return its default value. mutating func clearIDNumber() {_uniqueStorage()._idNumber = nil} var theIDNumber: Int32 { - get {return _storage._theIDNumber ?? 0} + get {_storage._theIDNumber ?? 0} set {_uniqueStorage()._theIDNumber = newValue} } /// Returns true if `theIDNumber` has been explicitly set. - var hasTheIDNumber: Bool {return _storage._theIDNumber != nil} + var hasTheIDNumber: Bool {_storage._theIDNumber != nil} /// Clears the value of `theIDNumber`. Subsequent reads from it will return its default value. mutating func clearTheIDNumber() {_uniqueStorage()._theIDNumber = nil} var requestID: Int32 { - get {return _storage._requestID ?? 0} + get {_storage._requestID ?? 0} set {_uniqueStorage()._requestID = newValue} } /// Returns true if `requestID` has been explicitly set. - var hasRequestID: Bool {return _storage._requestID != nil} + var hasRequestID: Bool {_storage._requestID != nil} /// Clears the value of `requestID`. Subsequent reads from it will return its default value. mutating func clearRequestID() {_uniqueStorage()._requestID = nil} @@ -13143,152 +8881,152 @@ struct SwiftUnittest_Names_FieldNamingInitials { fileprivate var _storage = _StorageClass.defaultInstance } - struct Uppers { + struct Uppers: Sendable { // 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 http: Int32 { - get {return _http ?? 0} + get {_http ?? 0} set {_http = newValue} } /// Returns true if `http` has been explicitly set. - var hasHTTP: Bool {return self._http != nil} + var hasHTTP: Bool {self._http != nil} /// Clears the value of `http`. Subsequent reads from it will return its default value. mutating func clearHTTP() {self._http = nil} var httpRequest: Int32 { - get {return _httpRequest ?? 0} + get {_httpRequest ?? 0} set {_httpRequest = newValue} } /// Returns true if `httpRequest` has been explicitly set. - var hasHTTPRequest: Bool {return self._httpRequest != nil} + var hasHTTPRequest: Bool {self._httpRequest != nil} /// Clears the value of `httpRequest`. Subsequent reads from it will return its default value. mutating func clearHTTPRequest() {self._httpRequest = nil} var theHTTPRequest: Int32 { - get {return _theHTTPRequest ?? 0} + get {_theHTTPRequest ?? 0} set {_theHTTPRequest = newValue} } /// Returns true if `theHTTPRequest` has been explicitly set. - var hasTheHTTPRequest: Bool {return self._theHTTPRequest != nil} + var hasTheHTTPRequest: Bool {self._theHTTPRequest != nil} /// Clears the value of `theHTTPRequest`. Subsequent reads from it will return its default value. mutating func clearTheHTTPRequest() {self._theHTTPRequest = nil} var theHTTP: Int32 { - get {return _theHTTP ?? 0} + get {_theHTTP ?? 0} set {_theHTTP = newValue} } /// Returns true if `theHTTP` has been explicitly set. - var hasTheHTTP: Bool {return self._theHTTP != nil} + var hasTheHTTP: Bool {self._theHTTP != nil} /// Clears the value of `theHTTP`. Subsequent reads from it will return its default value. mutating func clearTheHTTP() {self._theHTTP = nil} var https: Int32 { - get {return _https ?? 0} + get {_https ?? 0} set {_https = newValue} } /// Returns true if `https` has been explicitly set. - var hasHTTPS: Bool {return self._https != nil} + var hasHTTPS: Bool {self._https != nil} /// Clears the value of `https`. Subsequent reads from it will return its default value. mutating func clearHTTPS() {self._https = nil} var httpsRequest: Int32 { - get {return _httpsRequest ?? 0} + get {_httpsRequest ?? 0} set {_httpsRequest = newValue} } /// Returns true if `httpsRequest` has been explicitly set. - var hasHTTPSRequest: Bool {return self._httpsRequest != nil} + var hasHTTPSRequest: Bool {self._httpsRequest != nil} /// Clears the value of `httpsRequest`. Subsequent reads from it will return its default value. mutating func clearHTTPSRequest() {self._httpsRequest = nil} var theHTTPSRequest: Int32 { - get {return _theHTTPSRequest ?? 0} + get {_theHTTPSRequest ?? 0} set {_theHTTPSRequest = newValue} } /// Returns true if `theHTTPSRequest` has been explicitly set. - var hasTheHTTPSRequest: Bool {return self._theHTTPSRequest != nil} + var hasTheHTTPSRequest: Bool {self._theHTTPSRequest != nil} /// Clears the value of `theHTTPSRequest`. Subsequent reads from it will return its default value. mutating func clearTheHTTPSRequest() {self._theHTTPSRequest = nil} var theHTTPS: Int32 { - get {return _theHTTPS ?? 0} + get {_theHTTPS ?? 0} set {_theHTTPS = newValue} } /// Returns true if `theHTTPS` has been explicitly set. - var hasTheHTTPS: Bool {return self._theHTTPS != nil} + var hasTheHTTPS: Bool {self._theHTTPS != nil} /// Clears the value of `theHTTPS`. Subsequent reads from it will return its default value. mutating func clearTheHTTPS() {self._theHTTPS = nil} var url: Int32 { - get {return _url ?? 0} + get {_url ?? 0} set {_url = newValue} } /// Returns true if `url` has been explicitly set. - var hasURL: Bool {return self._url != nil} + var hasURL: Bool {self._url != nil} /// Clears the value of `url`. Subsequent reads from it will return its default value. mutating func clearURL() {self._url = nil} var urlValue: Int32 { - get {return _urlValue ?? 0} + get {_urlValue ?? 0} set {_urlValue = newValue} } /// Returns true if `urlValue` has been explicitly set. - var hasURLValue: Bool {return self._urlValue != nil} + var hasURLValue: Bool {self._urlValue != nil} /// Clears the value of `urlValue`. Subsequent reads from it will return its default value. mutating func clearURLValue() {self._urlValue = nil} var theURLValue: Int32 { - get {return _theURLValue ?? 0} + get {_theURLValue ?? 0} set {_theURLValue = newValue} } /// Returns true if `theURLValue` has been explicitly set. - var hasTheURLValue: Bool {return self._theURLValue != nil} + var hasTheURLValue: Bool {self._theURLValue != nil} /// Clears the value of `theURLValue`. Subsequent reads from it will return its default value. mutating func clearTheURLValue() {self._theURLValue = nil} var theURL: Int32 { - get {return _theURL ?? 0} + get {_theURL ?? 0} set {_theURL = newValue} } /// Returns true if `theURL` has been explicitly set. - var hasTheURL: Bool {return self._theURL != nil} + var hasTheURL: Bool {self._theURL != nil} /// Clears the value of `theURL`. Subsequent reads from it will return its default value. mutating func clearTheURL() {self._theURL = nil} var id: Int32 { - get {return _id ?? 0} + get {_id ?? 0} set {_id = newValue} } /// Returns true if `id` has been explicitly set. - var hasID: Bool {return self._id != nil} + var hasID: Bool {self._id != nil} /// Clears the value of `id`. Subsequent reads from it will return its default value. mutating func clearID() {self._id = nil} var idNumber: Int32 { - get {return _idNumber ?? 0} + get {_idNumber ?? 0} set {_idNumber = newValue} } /// Returns true if `idNumber` has been explicitly set. - var hasIDNumber: Bool {return self._idNumber != nil} + var hasIDNumber: Bool {self._idNumber != nil} /// Clears the value of `idNumber`. Subsequent reads from it will return its default value. mutating func clearIDNumber() {self._idNumber = nil} var theIDNumber: Int32 { - get {return _theIDNumber ?? 0} + get {_theIDNumber ?? 0} set {_theIDNumber = newValue} } /// Returns true if `theIDNumber` has been explicitly set. - var hasTheIDNumber: Bool {return self._theIDNumber != nil} + var hasTheIDNumber: Bool {self._theIDNumber != nil} /// Clears the value of `theIDNumber`. Subsequent reads from it will return its default value. mutating func clearTheIDNumber() {self._theIDNumber = nil} var requestID: Int32 { - get {return _requestID ?? 0} + get {_requestID ?? 0} set {_requestID = newValue} } /// Returns true if `requestID` has been explicitly set. - var hasRequestID: Bool {return self._requestID != nil} + var hasRequestID: Bool {self._requestID != nil} /// Clears the value of `requestID`. Subsequent reads from it will return its default value. mutating func clearRequestID() {self._requestID = nil} @@ -13314,152 +9052,152 @@ struct SwiftUnittest_Names_FieldNamingInitials { fileprivate var _requestID: Int32? = nil } - struct WordCase { + struct WordCase: Sendable { // 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 http: Int32 { - get {return _http ?? 0} + get {_http ?? 0} set {_http = newValue} } /// Returns true if `http` has been explicitly set. - var hasHTTP: Bool {return self._http != nil} + var hasHTTP: Bool {self._http != nil} /// Clears the value of `http`. Subsequent reads from it will return its default value. mutating func clearHTTP() {self._http = nil} var httpRequest: Int32 { - get {return _httpRequest ?? 0} + get {_httpRequest ?? 0} set {_httpRequest = newValue} } /// Returns true if `httpRequest` has been explicitly set. - var hasHTTPRequest: Bool {return self._httpRequest != nil} + var hasHTTPRequest: Bool {self._httpRequest != nil} /// Clears the value of `httpRequest`. Subsequent reads from it will return its default value. mutating func clearHTTPRequest() {self._httpRequest = nil} var theHTTPRequest: Int32 { - get {return _theHTTPRequest ?? 0} + get {_theHTTPRequest ?? 0} set {_theHTTPRequest = newValue} } /// Returns true if `theHTTPRequest` has been explicitly set. - var hasTheHTTPRequest: Bool {return self._theHTTPRequest != nil} + var hasTheHTTPRequest: Bool {self._theHTTPRequest != nil} /// Clears the value of `theHTTPRequest`. Subsequent reads from it will return its default value. mutating func clearTheHTTPRequest() {self._theHTTPRequest = nil} var theHTTP: Int32 { - get {return _theHTTP ?? 0} + get {_theHTTP ?? 0} set {_theHTTP = newValue} } /// Returns true if `theHTTP` has been explicitly set. - var hasTheHTTP: Bool {return self._theHTTP != nil} + var hasTheHTTP: Bool {self._theHTTP != nil} /// Clears the value of `theHTTP`. Subsequent reads from it will return its default value. mutating func clearTheHTTP() {self._theHTTP = nil} var https: Int32 { - get {return _https ?? 0} + get {_https ?? 0} set {_https = newValue} } /// Returns true if `https` has been explicitly set. - var hasHTTPS: Bool {return self._https != nil} + var hasHTTPS: Bool {self._https != nil} /// Clears the value of `https`. Subsequent reads from it will return its default value. mutating func clearHTTPS() {self._https = nil} var httpsRequest: Int32 { - get {return _httpsRequest ?? 0} + get {_httpsRequest ?? 0} set {_httpsRequest = newValue} } /// Returns true if `httpsRequest` has been explicitly set. - var hasHTTPSRequest: Bool {return self._httpsRequest != nil} + var hasHTTPSRequest: Bool {self._httpsRequest != nil} /// Clears the value of `httpsRequest`. Subsequent reads from it will return its default value. mutating func clearHTTPSRequest() {self._httpsRequest = nil} var theHTTPSRequest: Int32 { - get {return _theHTTPSRequest ?? 0} + get {_theHTTPSRequest ?? 0} set {_theHTTPSRequest = newValue} } /// Returns true if `theHTTPSRequest` has been explicitly set. - var hasTheHTTPSRequest: Bool {return self._theHTTPSRequest != nil} + var hasTheHTTPSRequest: Bool {self._theHTTPSRequest != nil} /// Clears the value of `theHTTPSRequest`. Subsequent reads from it will return its default value. mutating func clearTheHTTPSRequest() {self._theHTTPSRequest = nil} var theHTTPS: Int32 { - get {return _theHTTPS ?? 0} + get {_theHTTPS ?? 0} set {_theHTTPS = newValue} } /// Returns true if `theHTTPS` has been explicitly set. - var hasTheHTTPS: Bool {return self._theHTTPS != nil} + var hasTheHTTPS: Bool {self._theHTTPS != nil} /// Clears the value of `theHTTPS`. Subsequent reads from it will return its default value. mutating func clearTheHTTPS() {self._theHTTPS = nil} var url: Int32 { - get {return _url ?? 0} + get {_url ?? 0} set {_url = newValue} } /// Returns true if `url` has been explicitly set. - var hasURL: Bool {return self._url != nil} + var hasURL: Bool {self._url != nil} /// Clears the value of `url`. Subsequent reads from it will return its default value. mutating func clearURL() {self._url = nil} var urlValue: Int32 { - get {return _urlValue ?? 0} + get {_urlValue ?? 0} set {_urlValue = newValue} } /// Returns true if `urlValue` has been explicitly set. - var hasURLValue: Bool {return self._urlValue != nil} + var hasURLValue: Bool {self._urlValue != nil} /// Clears the value of `urlValue`. Subsequent reads from it will return its default value. mutating func clearURLValue() {self._urlValue = nil} var theURLValue: Int32 { - get {return _theURLValue ?? 0} + get {_theURLValue ?? 0} set {_theURLValue = newValue} } /// Returns true if `theURLValue` has been explicitly set. - var hasTheURLValue: Bool {return self._theURLValue != nil} + var hasTheURLValue: Bool {self._theURLValue != nil} /// Clears the value of `theURLValue`. Subsequent reads from it will return its default value. mutating func clearTheURLValue() {self._theURLValue = nil} var theURL: Int32 { - get {return _theURL ?? 0} + get {_theURL ?? 0} set {_theURL = newValue} } /// Returns true if `theURL` has been explicitly set. - var hasTheURL: Bool {return self._theURL != nil} + var hasTheURL: Bool {self._theURL != nil} /// Clears the value of `theURL`. Subsequent reads from it will return its default value. mutating func clearTheURL() {self._theURL = nil} var id: Int32 { - get {return _id ?? 0} + get {_id ?? 0} set {_id = newValue} } /// Returns true if `id` has been explicitly set. - var hasID: Bool {return self._id != nil} + var hasID: Bool {self._id != nil} /// Clears the value of `id`. Subsequent reads from it will return its default value. mutating func clearID() {self._id = nil} var idNumber: Int32 { - get {return _idNumber ?? 0} + get {_idNumber ?? 0} set {_idNumber = newValue} } /// Returns true if `idNumber` has been explicitly set. - var hasIDNumber: Bool {return self._idNumber != nil} + var hasIDNumber: Bool {self._idNumber != nil} /// Clears the value of `idNumber`. Subsequent reads from it will return its default value. mutating func clearIDNumber() {self._idNumber = nil} var theIDNumber: Int32 { - get {return _theIDNumber ?? 0} + get {_theIDNumber ?? 0} set {_theIDNumber = newValue} } /// Returns true if `theIDNumber` has been explicitly set. - var hasTheIDNumber: Bool {return self._theIDNumber != nil} + var hasTheIDNumber: Bool {self._theIDNumber != nil} /// Clears the value of `theIDNumber`. Subsequent reads from it will return its default value. mutating func clearTheIDNumber() {self._theIDNumber = nil} var requestID: Int32 { - get {return _requestID ?? 0} + get {_requestID ?? 0} set {_requestID = newValue} } /// Returns true if `requestID` has been explicitly set. - var hasRequestID: Bool {return self._requestID != nil} + var hasRequestID: Bool {self._requestID != nil} /// Clears the value of `requestID`. Subsequent reads from it will return its default value. mutating func clearRequestID() {self._requestID = nil} @@ -13488,7 +9226,7 @@ struct SwiftUnittest_Names_FieldNamingInitials { init() {} } -struct SwiftUnittest_Names_ExtensionNamingInitials: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Names_ExtensionNamingInitials: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -13500,7 +9238,7 @@ struct SwiftUnittest_Names_ExtensionNamingInitials: SwiftProtobuf.ExtensibleMess var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct SwiftUnittest_Names_Lowers { +struct SwiftProtoTesting_Names_Lowers: Sendable { // 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. @@ -13510,7 +9248,7 @@ struct SwiftUnittest_Names_Lowers { init() {} } -struct SwiftUnittest_Names_Uppers { +struct SwiftProtoTesting_Names_Uppers: Sendable { // 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. @@ -13520,7 +9258,7 @@ struct SwiftUnittest_Names_Uppers { init() {} } -struct SwiftUnittest_Names_WordCase { +struct SwiftProtoTesting_Names_WordCase: Sendable { // 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. @@ -13530,7 +9268,7 @@ struct SwiftUnittest_Names_WordCase { init() {} } -struct SwiftUnittest_Names_ExtensionNamingInitialsLowers: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Names_ExtensionNamingInitialsLowers: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -13542,7 +9280,7 @@ struct SwiftUnittest_Names_ExtensionNamingInitialsLowers: SwiftProtobuf.Extensib var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct SwiftUnittest_Names_ExtensionNamingInitialsUppers: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Names_ExtensionNamingInitialsUppers: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -13554,7 +9292,7 @@ struct SwiftUnittest_Names_ExtensionNamingInitialsUppers: SwiftProtobuf.Extensib var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct SwiftUnittest_Names_ExtensionNamingInitialsWordCase: SwiftProtobuf.ExtensibleMessage { +struct SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -13566,39 +9304,39 @@ struct SwiftUnittest_Names_ExtensionNamingInitialsWordCase: SwiftProtobuf.Extens var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -struct SwiftUnittest_Names_ValidIdentifiers { +struct SwiftProtoTesting_Names_ValidIdentifiers: Sendable { // 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 _1Field: Int32 { - get {return __1Field ?? 0} + get {__1Field ?? 0} set {__1Field = newValue} } /// Returns true if `_1Field` has been explicitly set. - var has_1Field: Bool {return self.__1Field != nil} + var has_1Field: Bool {self.__1Field != nil} /// Clears the value of `_1Field`. Subsequent reads from it will return its default value. mutating func clear_1Field() {self.__1Field = nil} var field: Int32 { - get {return _field ?? 0} + get {_field ?? 0} set {_field = newValue} } /// Returns true if `field` has been explicitly set. - var hasField: Bool {return self._field != nil} + var hasField: Bool {self._field != nil} /// Clears the value of `field`. Subsequent reads from it will return its default value. mutating func clearField() {self._field = nil} var _3Field3: Int32 { - get {return __3Field3 ?? 0} + get {__3Field3 ?? 0} set {__3Field3 = newValue} } /// Returns true if `_3Field3` has been explicitly set. - var has_3Field3: Bool {return self.__3Field3 != nil} + var has_3Field3: Bool {self.__3Field3 != nil} /// Clears the value of `_3Field3`. Subsequent reads from it will return its default value. mutating func clear_3Field3() {self.__3Field3 = nil} - var _2Of: SwiftUnittest_Names_ValidIdentifiers.OneOf__2Of? = nil + var _2Of: SwiftProtoTesting_Names_ValidIdentifiers.OneOf__2Of? = nil var _4: Int32 { get { @@ -13616,79 +9354,41 @@ struct SwiftUnittest_Names_ValidIdentifiers { set {_2Of = ._5Field(newValue)} } - var enumField: SwiftUnittest_Names_ValidIdentifiers.TestEnum { - get {return _enumField ?? .testEnum0} + var enumField: SwiftProtoTesting_Names_ValidIdentifiers.TestEnum { + get {_enumField ?? .testEnum0} set {_enumField = newValue} } /// Returns true if `enumField` has been explicitly set. - var hasEnumField: Bool {return self._enumField != nil} + var hasEnumField: Bool {self._enumField != nil} /// Clears the value of `enumField`. Subsequent reads from it will return its default value. mutating func clearEnumField() {self._enumField = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf__2Of: Equatable { + enum OneOf__2Of: Equatable, Sendable { case _4(Int32) case _5Field(Int32) - #if !swift(>=4.1) - static func ==(lhs: SwiftUnittest_Names_ValidIdentifiers.OneOf__2Of, rhs: SwiftUnittest_Names_ValidIdentifiers.OneOf__2Of) -> 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 (._4, ._4): return { - guard case ._4(let l) = lhs, case ._4(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (._5Field, ._5Field): return { - guard case ._5Field(let l) = lhs, case ._5Field(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum TestEnum: SwiftProtobuf.Enum { - typealias RawValue = Int + enum TestEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { /// Won't prefix strip - case testEnum0 // = 0 + case testEnum0 = 0 /// Will prefix strip - case first // = 1 + case first = 1 /// Leading underscore & number, keeps that. - case _2 // = 2 + case _2 = 2 /// Leading underscore & number, keeps that. - case _3Value // = 3 + case _3Value = 3 init() { self = .testEnum0 } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .testEnum0 - case 1: self = .first - case 2: self = ._2 - case 3: self = ._3Value - default: return nil - } - } - - var rawValue: Int { - switch self { - case .testEnum0: return 0 - case .first: return 1 - case ._2: return 2 - case ._3Value: return 3 - } - } - } init() {} @@ -13696,26 +9396,18 @@ struct SwiftUnittest_Names_ValidIdentifiers { fileprivate var __1Field: Int32? = nil fileprivate var _field: Int32? = nil fileprivate var __3Field3: Int32? = nil - fileprivate var _enumField: SwiftUnittest_Names_ValidIdentifiers.TestEnum? = nil + fileprivate var _enumField: SwiftProtoTesting_Names_ValidIdentifiers.TestEnum? = nil } -#if swift(>=4.2) - -extension SwiftUnittest_Names_ValidIdentifiers.TestEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - /// For issue #1084 - If the generated code compiles, things are good. /// /// This gets special handling because of the generated setter. -struct SwiftUnittest_Names_SpecialNames1 { +struct SwiftProtoTesting_Names_SpecialNames1: Sendable { // 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 newValue: SwiftUnittest_Names_SpecialNames1.OneOf_NewValue? = nil + var newValue: SwiftProtoTesting_Names_SpecialNames1.OneOf_NewValue? = nil var str: String { get { @@ -13727,39 +9419,26 @@ struct SwiftUnittest_Names_SpecialNames1 { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_NewValue: Equatable { + enum OneOf_NewValue: Equatable, Sendable { case str(String) - #if !swift(>=4.1) - static func ==(lhs: SwiftUnittest_Names_SpecialNames1.OneOf_NewValue, rhs: SwiftUnittest_Names_SpecialNames1.OneOf_NewValue) -> 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 (.str, .str): return { - guard case .str(let l) = lhs, case .str(let r) = rhs else { preconditionFailure() } - return l == r - }() - } - } - #endif } init() {} } /// No special handling needed in the generator. -struct SwiftUnittest_Names_SpecialNames2 { +struct SwiftProtoTesting_Names_SpecialNames2: Sendable { // 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 newValue: String { - get {return _newValue ?? String()} + get {_newValue ?? String()} set {_newValue = newValue} } /// Returns true if `newValue` has been explicitly set. - var hasNewValue: Bool {return self._newValue != nil} + var hasNewValue: Bool {self._newValue != nil} /// Clears the value of `newValue`. Subsequent reads from it will return its default value. mutating func clearNewValue() {self._newValue = nil} @@ -13771,7 +9450,7 @@ struct SwiftUnittest_Names_SpecialNames2 { } /// No special handling needed in the generator. -struct SwiftUnittest_Names_SpecialNames3 { +struct SwiftProtoTesting_Names_SpecialNames3: @unchecked Sendable { // 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. @@ -13789,33 +9468,20 @@ struct SwiftUnittest_Names_SpecialNames3 { set {_uniqueStorage()._newValue = .str(newValue)} } - var forcesStorage: SwiftUnittest_Names_SpecialNames3 { - get {return _storage._forcesStorage ?? SwiftUnittest_Names_SpecialNames3()} + var forcesStorage: SwiftProtoTesting_Names_SpecialNames3 { + get {_storage._forcesStorage ?? SwiftProtoTesting_Names_SpecialNames3()} set {_uniqueStorage()._forcesStorage = newValue} } /// Returns true if `forcesStorage` has been explicitly set. - var hasForcesStorage: Bool {return _storage._forcesStorage != nil} + var hasForcesStorage: Bool {_storage._forcesStorage != nil} /// Clears the value of `forcesStorage`. Subsequent reads from it will return its default value. mutating func clearForcesStorage() {_uniqueStorage()._forcesStorage = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_NewValue: Equatable { + enum OneOf_NewValue: Equatable, Sendable { case str(String) - #if !swift(>=4.1) - static func ==(lhs: SwiftUnittest_Names_SpecialNames3.OneOf_NewValue, rhs: SwiftUnittest_Names_SpecialNames3.OneOf_NewValue) -> 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 (.str, .str): return { - guard case .str(let l) = lhs, case .str(let r) = rhs else { preconditionFailure() } - return l == r - }() - } - } - #endif } init() {} @@ -13824,26 +9490,26 @@ struct SwiftUnittest_Names_SpecialNames3 { } /// No special handling needed in the generator. -struct SwiftUnittest_Names_SpecialNames4 { +struct SwiftProtoTesting_Names_SpecialNames4: @unchecked Sendable { // 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 newValue: String { - get {return _storage._newValue ?? String()} + get {_storage._newValue ?? String()} set {_uniqueStorage()._newValue = newValue} } /// Returns true if `newValue` has been explicitly set. - var hasNewValue: Bool {return _storage._newValue != nil} + var hasNewValue: Bool {_storage._newValue != nil} /// Clears the value of `newValue`. Subsequent reads from it will return its default value. mutating func clearNewValue() {_uniqueStorage()._newValue = nil} - var forcesStorage: SwiftUnittest_Names_SpecialNames4 { - get {return _storage._forcesStorage ?? SwiftUnittest_Names_SpecialNames4()} + var forcesStorage: SwiftProtoTesting_Names_SpecialNames4 { + get {_storage._forcesStorage ?? SwiftProtoTesting_Names_SpecialNames4()} set {_uniqueStorage()._forcesStorage = newValue} } /// Returns true if `forcesStorage` has been explicitly set. - var hasForcesStorage: Bool {return _storage._forcesStorage != nil} + var hasForcesStorage: Bool {_storage._forcesStorage != nil} /// Clears the value of `forcesStorage`. Subsequent reads from it will return its default value. mutating func clearForcesStorage() {_uniqueStorage()._forcesStorage = nil} @@ -13854,2889 +9520,2223 @@ struct SwiftUnittest_Names_SpecialNames4 { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=5.5) && canImport(_Concurrency) -extension SwiftUnittest_Names_EnumFieldNames: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumFieldNames2: @unchecked Sendable {} -extension SwiftUnittest_Names_Foo: @unchecked Sendable {} -extension SwiftUnittest_Names_FieldNames: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.StringMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.ProtocolMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.IntMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.DoubleMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.FloatMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.UIntMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.hashValueMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.descriptionMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.debugDescriptionMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Swift: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.UNRECOGNIZED: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.classMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.deinitMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.enumMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.extensionMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.funcMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.importMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.initMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.inoutMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.internalMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.letMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.operatorMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.privateMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.protocolMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.publicMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.staticMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.structMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.subscriptMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.typealiasMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.varMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.breakMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.caseMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.continueMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.defaultMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.deferMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.doMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.elseMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.fallthroughMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.forMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.guardMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.ifMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.inMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.repeatMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.returnMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.switchMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.whereMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.whileMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.asMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.catchMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.dynamicTypeMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.falseMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.isMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.nilMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.rethrowsMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.superMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.selfMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.throwMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.throwsMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.trueMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.tryMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.__COLUMN__Message: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.__FILE__Message: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.__FUNCTION__Message: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.__LINE__Message: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames._Message: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.__Message: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.associativity: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.convenience: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.dynamic: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.didSet: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.final: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.get: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.infix: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.indirect: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.lazy: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.left: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.mutating: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.none: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.nonmutating: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.optional: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.override: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.postfix: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.precedence: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.prefix: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.required: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.right: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.set: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.TypeMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.unowned: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.weak: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.willSet: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.id: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames._cmd: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.out: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.bycopy: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.byref: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.oneway: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.and: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.and_eq: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.alignas: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.alignof: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.asm: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.auto: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.bitand: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.bitor: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.bool: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.char: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.char16_t: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.char32_t: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.compl: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.const: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.constexpr: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.const_cast: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.decltype: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.delete: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.dynamic_cast: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.explicit: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.export: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.extern: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.friend: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.goto: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.inline: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.long: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.mutable: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.namespace: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.new: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.noexcept: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.not: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.not_eq: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.nullptr: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.or: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.or_eq: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.protected: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.register: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.reinterpret_cast: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.short: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.signed: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.sizeof: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.static_assert: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.static_cast: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.template: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.this: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.thread_local: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.typedef: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.typeid: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.typename: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.union: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.unsigned: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.using: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.virtual: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.void: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.volatile: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.wchar_t: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.xor: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.xor_eq: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.restrict: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Category: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Ivar: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Method: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.finalize: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.hash: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.dealloc: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.superclass: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.retain: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.release: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.autorelease: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.retainCount: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.zone: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.isProxy: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.copy: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.mutableCopy: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.classForCoder: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.clear: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.data: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.delimitedData: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.descriptor: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.extensionRegistry: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.extensionsCurrentlySet: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.isInitializedMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.serializedSize: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.sortedExtensionsInUse: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.unknownFieldsMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Fixed: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Fract: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Size: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.LogicalAddress: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.PhysicalAddress: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.ByteCount: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.ByteOffset: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Duration: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.AbsoluteTime: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.OptionBits: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.ItemCount: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.PBVersion: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.ScriptCode: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.LangCode: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.RegionCode: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.OSType: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.ProcessSerialNumber: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Point: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Rect: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.FixedPoint: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.FixedRect: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Style: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.StyleParameter: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.StyleField: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.TimeScale: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.TimeBase: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.TimeRecord: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.serializedData: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.jsonUTF8Data: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.jsonString: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.Extension: @unchecked Sendable {} -extension SwiftUnittest_Names_MessageNames.ExtensionsMessage: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.StringEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.ProtocolEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.IntEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.DoubleEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.FloatEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.UIntEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.hashValueEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.descriptionEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.debugDescriptionEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Swift: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.UNRECOGNIZED: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.classEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.deinitEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.enumEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.extensionEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.funcEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.importEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.initEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.inoutEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.internalEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.letEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.operatorEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.privateEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.protocolEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.publicEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.staticEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.structEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.subscriptEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.typealiasEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.varEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.breakEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.caseEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.continueEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.defaultEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.deferEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.doEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.elseEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.fallthroughEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.forEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.guardEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.ifEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.inEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.repeatEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.returnEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.switchEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.whereEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.whileEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.asEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.catchEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.dynamicTypeEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.falseEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.isEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.nilEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.rethrowsEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.superEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.selfEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.throwEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.throwsEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.trueEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.tryEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.__COLUMN__Enum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.__FILE__Enum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.__FUNCTION__Enum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.__LINE__Enum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames._Enum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.__Enum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.associativity: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.convenience: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.dynamic: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.didSet: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.final: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.get: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.infix: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.indirect: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.lazy: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.left: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.mutating: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.none: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.nonmutating: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.optional: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.override: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.postfix: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.precedence: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.prefix: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.required: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.right: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.set: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.TypeEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.unowned: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.weak: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.willSet: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.id: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames._cmd: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.out: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.bycopy: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.byref: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.oneway: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.and: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.and_eq: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.alignas: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.alignof: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.asm: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.auto: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.bitand: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.bitor: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.bool: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.char: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.char16_t: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.char32_t: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.compl: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.const: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.constexpr: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.const_cast: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.decltype: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.delete: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.dynamic_cast: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.explicit: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.export: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.extern: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.friend: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.goto: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.inline: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.long: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.mutable: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.namespace: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.new: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.noexcept: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.not: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.not_eq: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.nullptr: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.or: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.or_eq: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.protected: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.register: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.reinterpret_cast: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.short: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.signed: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.sizeof: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.static_assert: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.static_cast: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.template: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.this: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.thread_local: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.typedef: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.typeid: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.typename: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.union: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.unsigned: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.using: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.virtual: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.void: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.volatile: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.wchar_t: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.xor: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.xor_eq: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.restrict: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Category: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Ivar: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Method: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.finalize: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.hash: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.dealloc: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.superclass: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.retain: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.release: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.autorelease: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.retainCount: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.zone: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.isProxy: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.copy: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.mutableCopy: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.classForCoder: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.clear: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.data: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.delimitedData: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.descriptor: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.extensionRegistry: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.extensionsCurrentlySet: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.isInitializedEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.serializedSize: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.sortedExtensionsInUse: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.unknownFieldsEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Fixed: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Fract: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Size: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.LogicalAddress: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.PhysicalAddress: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.ByteCount: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.ByteOffset: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Duration: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.AbsoluteTime: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.OptionBits: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.ItemCount: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.PBVersion: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.ScriptCode: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.LangCode: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.RegionCode: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.OSType: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.ProcessSerialNumber: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Point: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Rect: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.FixedPoint: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.FixedRect: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Style: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.StyleParameter: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.StyleField: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.TimeScale: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.TimeBase: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.TimeRecord: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.Extension: @unchecked Sendable {} -extension SwiftUnittest_Names_EnumNames.ExtensionsEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_FieldNamingInitials: @unchecked Sendable {} -extension SwiftUnittest_Names_FieldNamingInitials.Lowers: @unchecked Sendable {} -extension SwiftUnittest_Names_FieldNamingInitials.Uppers: @unchecked Sendable {} -extension SwiftUnittest_Names_FieldNamingInitials.WordCase: @unchecked Sendable {} -extension SwiftUnittest_Names_ExtensionNamingInitials: @unchecked Sendable {} -extension SwiftUnittest_Names_Lowers: @unchecked Sendable {} -extension SwiftUnittest_Names_Uppers: @unchecked Sendable {} -extension SwiftUnittest_Names_WordCase: @unchecked Sendable {} -extension SwiftUnittest_Names_ExtensionNamingInitialsLowers: @unchecked Sendable {} -extension SwiftUnittest_Names_ExtensionNamingInitialsUppers: @unchecked Sendable {} -extension SwiftUnittest_Names_ExtensionNamingInitialsWordCase: @unchecked Sendable {} -extension SwiftUnittest_Names_ValidIdentifiers: @unchecked Sendable {} -extension SwiftUnittest_Names_ValidIdentifiers.OneOf__2Of: @unchecked Sendable {} -extension SwiftUnittest_Names_ValidIdentifiers.TestEnum: @unchecked Sendable {} -extension SwiftUnittest_Names_SpecialNames1: @unchecked Sendable {} -extension SwiftUnittest_Names_SpecialNames1.OneOf_NewValue: @unchecked Sendable {} -extension SwiftUnittest_Names_SpecialNames2: @unchecked Sendable {} -extension SwiftUnittest_Names_SpecialNames3: @unchecked Sendable {} -extension SwiftUnittest_Names_SpecialNames3.OneOf_NewValue: @unchecked Sendable {} -extension SwiftUnittest_Names_SpecialNames4: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_naming.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 SwiftUnittest_Names_ExtensionNamingInitials { +extension SwiftProtoTesting_Names_ExtensionNamingInitials { - var SwiftUnittest_Names_Lowers_http: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.http) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.http, value: newValue)} + var SwiftProtoTesting_Names_Lowers_http: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.http) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.http, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.http` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.http` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_http: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.http) + var hasSwiftProtoTesting_Names_Lowers_http: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.http) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.http`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.http`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_http() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.http) + mutating func clearSwiftProtoTesting_Names_Lowers_http() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.http) } - var SwiftUnittest_Names_Lowers_httpRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.http_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.http_request, value: newValue)} + var SwiftProtoTesting_Names_Lowers_httpRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.http_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.http_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.http_request` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.http_request` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_httpRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.http_request) + var hasSwiftProtoTesting_Names_Lowers_httpRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.http_request) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.http_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.http_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_httpRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.http_request) + mutating func clearSwiftProtoTesting_Names_Lowers_httpRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.http_request) } - var SwiftUnittest_Names_Lowers_theHTTPRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_http_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_http_request, value: newValue)} + var SwiftProtoTesting_Names_Lowers_theHTTPRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_http_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_http_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.the_http_request` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.the_http_request` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_theHTTPRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_http_request) + var hasSwiftProtoTesting_Names_Lowers_theHTTPRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_http_request) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.the_http_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.the_http_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_theHTTPRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_http_request) + mutating func clearSwiftProtoTesting_Names_Lowers_theHTTPRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_http_request) } - var SwiftUnittest_Names_Lowers_theHTTP: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_http) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_http, value: newValue)} + var SwiftProtoTesting_Names_Lowers_theHTTP: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_http) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_http, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.the_http` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.the_http` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_theHTTP: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_http) + var hasSwiftProtoTesting_Names_Lowers_theHTTP: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_http) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.the_http`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.the_http`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_theHTTP() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_http) + mutating func clearSwiftProtoTesting_Names_Lowers_theHTTP() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_http) } - var SwiftUnittest_Names_Lowers_https: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.https) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.https, value: newValue)} + var SwiftProtoTesting_Names_Lowers_https: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.https) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.https, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.https` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.https` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_https: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.https) + var hasSwiftProtoTesting_Names_Lowers_https: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.https) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.https`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.https`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_https() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.https) + mutating func clearSwiftProtoTesting_Names_Lowers_https() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.https) } - var SwiftUnittest_Names_Lowers_httpsRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.https_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.https_request, value: newValue)} + var SwiftProtoTesting_Names_Lowers_httpsRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.https_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.https_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.https_request` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.https_request` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_httpsRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.https_request) + var hasSwiftProtoTesting_Names_Lowers_httpsRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.https_request) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.https_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.https_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_httpsRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.https_request) + mutating func clearSwiftProtoTesting_Names_Lowers_httpsRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.https_request) } - var SwiftUnittest_Names_Lowers_theHTTPSRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_https_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_https_request, value: newValue)} + var SwiftProtoTesting_Names_Lowers_theHTTPSRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_https_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_https_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.the_https_request` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.the_https_request` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_theHTTPSRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_https_request) + var hasSwiftProtoTesting_Names_Lowers_theHTTPSRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_https_request) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.the_https_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.the_https_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_theHTTPSRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_https_request) + mutating func clearSwiftProtoTesting_Names_Lowers_theHTTPSRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_https_request) } - var SwiftUnittest_Names_Lowers_theHTTPS: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_https) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_https, value: newValue)} + var SwiftProtoTesting_Names_Lowers_theHTTPS: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_https) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_https, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.the_https` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.the_https` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_theHTTPS: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_https) + var hasSwiftProtoTesting_Names_Lowers_theHTTPS: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_https) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.the_https`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.the_https`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_theHTTPS() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_https) + mutating func clearSwiftProtoTesting_Names_Lowers_theHTTPS() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_https) } - var SwiftUnittest_Names_Lowers_url: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.url) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.url, value: newValue)} + var SwiftProtoTesting_Names_Lowers_url: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.url) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.url, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.url` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.url` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_url: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.url) + var hasSwiftProtoTesting_Names_Lowers_url: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.url) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.url`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.url`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_url() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.url) + mutating func clearSwiftProtoTesting_Names_Lowers_url() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.url) } - var SwiftUnittest_Names_Lowers_urlValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.url_value) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.url_value, value: newValue)} + var SwiftProtoTesting_Names_Lowers_urlValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.url_value) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.url_value, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.url_value` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.url_value` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_urlValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.url_value) + var hasSwiftProtoTesting_Names_Lowers_urlValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.url_value) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.url_value`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.url_value`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_urlValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.url_value) + mutating func clearSwiftProtoTesting_Names_Lowers_urlValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.url_value) } - var SwiftUnittest_Names_Lowers_theURLValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_url_value) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_url_value, value: newValue)} + var SwiftProtoTesting_Names_Lowers_theURLValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_url_value) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_url_value, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.the_url_value` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.the_url_value` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_theURLValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_url_value) + var hasSwiftProtoTesting_Names_Lowers_theURLValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_url_value) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.the_url_value`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.the_url_value`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_theURLValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_url_value) + mutating func clearSwiftProtoTesting_Names_Lowers_theURLValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_url_value) } - var SwiftUnittest_Names_Lowers_theURL: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_url) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_url, value: newValue)} + var SwiftProtoTesting_Names_Lowers_theURL: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_url) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_url, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.the_url` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.the_url` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_theURL: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_url) + var hasSwiftProtoTesting_Names_Lowers_theURL: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_url) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.the_url`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.the_url`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_theURL() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_url) + mutating func clearSwiftProtoTesting_Names_Lowers_theURL() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_url) } - var SwiftUnittest_Names_Lowers_aBC: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.a_b_c) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.a_b_c, value: newValue)} + var SwiftProtoTesting_Names_Lowers_aBC: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.a_b_c) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.a_b_c, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.a_b_c` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.a_b_c` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_aBC: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.a_b_c) + var hasSwiftProtoTesting_Names_Lowers_aBC: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.a_b_c) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.a_b_c`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.a_b_c`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_aBC() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.a_b_c) + mutating func clearSwiftProtoTesting_Names_Lowers_aBC() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.a_b_c) } - var SwiftUnittest_Names_Lowers_id: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.id) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.id, value: newValue)} + var SwiftProtoTesting_Names_Lowers_id: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.id) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.id, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.id` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.id` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_id: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.id) + var hasSwiftProtoTesting_Names_Lowers_id: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.id) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.id`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.id`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_id() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.id) + mutating func clearSwiftProtoTesting_Names_Lowers_id() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.id) } - var SwiftUnittest_Names_Lowers_idNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.id_number) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.id_number, value: newValue)} + var SwiftProtoTesting_Names_Lowers_idNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.id_number) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.id_number, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.id_number` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.id_number` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_idNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.id_number) + var hasSwiftProtoTesting_Names_Lowers_idNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.id_number) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.id_number`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.id_number`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_idNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.id_number) + mutating func clearSwiftProtoTesting_Names_Lowers_idNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.id_number) } - var SwiftUnittest_Names_Lowers_theIDNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_id_number) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_id_number, value: newValue)} + var SwiftProtoTesting_Names_Lowers_theIDNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_id_number) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_id_number, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.the_id_number` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.the_id_number` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_theIDNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_id_number) + var hasSwiftProtoTesting_Names_Lowers_theIDNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_id_number) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.the_id_number`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.the_id_number`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_theIDNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.the_id_number) + mutating func clearSwiftProtoTesting_Names_Lowers_theIDNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.the_id_number) } - var SwiftUnittest_Names_Lowers_requestID: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.request_id) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.request_id, value: newValue)} + var SwiftProtoTesting_Names_Lowers_requestID: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.request_id) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.request_id, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Lowers.Extensions.request_id` + /// Returns true if extension `SwiftProtoTesting_Names_Lowers.Extensions.request_id` /// has been explicitly set. - var hasSwiftUnittest_Names_Lowers_requestID: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.request_id) + var hasSwiftProtoTesting_Names_Lowers_requestID: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.request_id) } - /// Clears the value of extension `SwiftUnittest_Names_Lowers.Extensions.request_id`. + /// Clears the value of extension `SwiftProtoTesting_Names_Lowers.Extensions.request_id`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Lowers_requestID() { - clearExtensionValue(ext: SwiftUnittest_Names_Lowers.Extensions.request_id) + mutating func clearSwiftProtoTesting_Names_Lowers_requestID() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Lowers.Extensions.request_id) } - var SwiftUnittest_Names_Uppers_http: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTP) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTP, value: newValue)} + var SwiftProtoTesting_Names_Uppers_http: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTP) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTP, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.HTTP` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.HTTP` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_http: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTP) + var hasSwiftProtoTesting_Names_Uppers_http: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTP) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.HTTP`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.HTTP`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_http() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTP) + mutating func clearSwiftProtoTesting_Names_Uppers_http() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTP) } - var SwiftUnittest_Names_Uppers_httpRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTP_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTP_request, value: newValue)} + var SwiftProtoTesting_Names_Uppers_httpRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTP_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTP_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.HTTP_request` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.HTTP_request` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_httpRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTP_request) + var hasSwiftProtoTesting_Names_Uppers_httpRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTP_request) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.HTTP_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.HTTP_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_httpRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTP_request) + mutating func clearSwiftProtoTesting_Names_Uppers_httpRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTP_request) } - var SwiftUnittest_Names_Uppers_theHTTPRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTP_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTP_request, value: newValue)} + var SwiftProtoTesting_Names_Uppers_theHTTPRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.the_HTTP_request` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP_request` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_theHTTPRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTP_request) + var hasSwiftProtoTesting_Names_Uppers_theHTTPRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP_request) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.the_HTTP_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_theHTTPRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTP_request) + mutating func clearSwiftProtoTesting_Names_Uppers_theHTTPRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP_request) } - var SwiftUnittest_Names_Uppers_theHTTP: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTP) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTP, value: newValue)} + var SwiftProtoTesting_Names_Uppers_theHTTP: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.the_HTTP` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_theHTTP: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTP) + var hasSwiftProtoTesting_Names_Uppers_theHTTP: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.the_HTTP`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_theHTTP() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTP) + mutating func clearSwiftProtoTesting_Names_Uppers_theHTTP() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP) } - var SwiftUnittest_Names_Uppers_https: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTPS) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTPS, value: newValue)} + var SwiftProtoTesting_Names_Uppers_https: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTPS) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTPS, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.HTTPS` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.HTTPS` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_https: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTPS) + var hasSwiftProtoTesting_Names_Uppers_https: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTPS) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.HTTPS`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.HTTPS`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_https() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTPS) + mutating func clearSwiftProtoTesting_Names_Uppers_https() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTPS) } - var SwiftUnittest_Names_Uppers_httpsRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTPS_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTPS_request, value: newValue)} + var SwiftProtoTesting_Names_Uppers_httpsRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTPS_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTPS_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.HTTPS_request` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.HTTPS_request` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_httpsRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTPS_request) + var hasSwiftProtoTesting_Names_Uppers_httpsRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTPS_request) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.HTTPS_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.HTTPS_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_httpsRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.HTTPS_request) + mutating func clearSwiftProtoTesting_Names_Uppers_httpsRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.HTTPS_request) } - var SwiftUnittest_Names_Uppers_theHTTPSRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTPS_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTPS_request, value: newValue)} + var SwiftProtoTesting_Names_Uppers_theHTTPSRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.the_HTTPS_request` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS_request` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_theHTTPSRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTPS_request) + var hasSwiftProtoTesting_Names_Uppers_theHTTPSRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS_request) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.the_HTTPS_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_theHTTPSRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTPS_request) + mutating func clearSwiftProtoTesting_Names_Uppers_theHTTPSRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS_request) } - var SwiftUnittest_Names_Uppers_theHTTPS: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTPS) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTPS, value: newValue)} + var SwiftProtoTesting_Names_Uppers_theHTTPS: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.the_HTTPS` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_theHTTPS: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTPS) + var hasSwiftProtoTesting_Names_Uppers_theHTTPS: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.the_HTTPS`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_theHTTPS() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_HTTPS) + mutating func clearSwiftProtoTesting_Names_Uppers_theHTTPS() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS) } - var SwiftUnittest_Names_Uppers_url: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.URL) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.URL, value: newValue)} + var SwiftProtoTesting_Names_Uppers_url: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.URL) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.URL, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.URL` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.URL` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_url: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.URL) + var hasSwiftProtoTesting_Names_Uppers_url: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.URL) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.URL`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.URL`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_url() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.URL) + mutating func clearSwiftProtoTesting_Names_Uppers_url() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.URL) } - var SwiftUnittest_Names_Uppers_urlValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.URL_value) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.URL_value, value: newValue)} + var SwiftProtoTesting_Names_Uppers_urlValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.URL_value) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.URL_value, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.URL_value` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.URL_value` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_urlValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.URL_value) + var hasSwiftProtoTesting_Names_Uppers_urlValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.URL_value) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.URL_value`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.URL_value`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_urlValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.URL_value) + mutating func clearSwiftProtoTesting_Names_Uppers_urlValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.URL_value) } - var SwiftUnittest_Names_Uppers_theURLValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_URL_value) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_URL_value, value: newValue)} + var SwiftProtoTesting_Names_Uppers_theURLValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_URL_value) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_URL_value, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.the_URL_value` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.the_URL_value` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_theURLValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_URL_value) + var hasSwiftProtoTesting_Names_Uppers_theURLValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_URL_value) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.the_URL_value`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.the_URL_value`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_theURLValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_URL_value) + mutating func clearSwiftProtoTesting_Names_Uppers_theURLValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_URL_value) } - var SwiftUnittest_Names_Uppers_theURL: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_URL) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_URL, value: newValue)} + var SwiftProtoTesting_Names_Uppers_theURL: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_URL) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_URL, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.the_URL` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.the_URL` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_theURL: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_URL) + var hasSwiftProtoTesting_Names_Uppers_theURL: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_URL) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.the_URL`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.the_URL`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_theURL() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_URL) + mutating func clearSwiftProtoTesting_Names_Uppers_theURL() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_URL) } - var SwiftUnittest_Names_Uppers_id: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.ID) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.ID, value: newValue)} + var SwiftProtoTesting_Names_Uppers_id: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.ID) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.ID, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.ID` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.ID` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_id: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.ID) + var hasSwiftProtoTesting_Names_Uppers_id: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.ID) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.ID`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.ID`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_id() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.ID) + mutating func clearSwiftProtoTesting_Names_Uppers_id() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.ID) } - var SwiftUnittest_Names_Uppers_idNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.ID_number) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.ID_number, value: newValue)} + var SwiftProtoTesting_Names_Uppers_idNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.ID_number) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.ID_number, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.ID_number` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.ID_number` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_idNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.ID_number) + var hasSwiftProtoTesting_Names_Uppers_idNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.ID_number) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.ID_number`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.ID_number`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_idNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.ID_number) + mutating func clearSwiftProtoTesting_Names_Uppers_idNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.ID_number) } - var SwiftUnittest_Names_Uppers_theIDNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_ID_number) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_ID_number, value: newValue)} + var SwiftProtoTesting_Names_Uppers_theIDNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_ID_number) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_ID_number, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.the_ID_number` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.the_ID_number` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_theIDNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_ID_number) + var hasSwiftProtoTesting_Names_Uppers_theIDNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_ID_number) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.the_ID_number`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.the_ID_number`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_theIDNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.the_ID_number) + mutating func clearSwiftProtoTesting_Names_Uppers_theIDNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.the_ID_number) } - var SwiftUnittest_Names_Uppers_requestID: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.request_ID) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.request_ID, value: newValue)} + var SwiftProtoTesting_Names_Uppers_requestID: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.request_ID) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.request_ID, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Uppers.Extensions.request_ID` + /// Returns true if extension `SwiftProtoTesting_Names_Uppers.Extensions.request_ID` /// has been explicitly set. - var hasSwiftUnittest_Names_Uppers_requestID: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.request_ID) + var hasSwiftProtoTesting_Names_Uppers_requestID: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.request_ID) } - /// Clears the value of extension `SwiftUnittest_Names_Uppers.Extensions.request_ID`. + /// Clears the value of extension `SwiftProtoTesting_Names_Uppers.Extensions.request_ID`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_Uppers_requestID() { - clearExtensionValue(ext: SwiftUnittest_Names_Uppers.Extensions.request_ID) + mutating func clearSwiftProtoTesting_Names_Uppers_requestID() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Uppers.Extensions.request_ID) } - var SwiftUnittest_Names_WordCase_http: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Http) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Http, value: newValue)} + var SwiftProtoTesting_Names_WordCase_http: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Http) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Http, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.Http` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.Http` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_http: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Http) + var hasSwiftProtoTesting_Names_WordCase_http: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Http) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.Http`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.Http`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_http() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Http) + mutating func clearSwiftProtoTesting_Names_WordCase_http() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Http) } - var SwiftUnittest_Names_WordCase_httpRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.HttpRequest) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.HttpRequest, value: newValue)} + var SwiftProtoTesting_Names_WordCase_httpRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.HttpRequest) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.HttpRequest, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.HttpRequest` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.HttpRequest` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_httpRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.HttpRequest) + var hasSwiftProtoTesting_Names_WordCase_httpRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.HttpRequest) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.HttpRequest`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.HttpRequest`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_httpRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.HttpRequest) + mutating func clearSwiftProtoTesting_Names_WordCase_httpRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.HttpRequest) } - var SwiftUnittest_Names_WordCase_theHTTPRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttpRequest) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttpRequest, value: newValue)} + var SwiftProtoTesting_Names_WordCase_theHTTPRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttpRequest) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttpRequest, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.TheHttpRequest` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.TheHttpRequest` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_theHTTPRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttpRequest) + var hasSwiftProtoTesting_Names_WordCase_theHTTPRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttpRequest) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.TheHttpRequest`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.TheHttpRequest`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_theHTTPRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttpRequest) + mutating func clearSwiftProtoTesting_Names_WordCase_theHTTPRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttpRequest) } - var SwiftUnittest_Names_WordCase_theHTTP: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttp) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttp, value: newValue)} + var SwiftProtoTesting_Names_WordCase_theHTTP: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttp) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttp, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.TheHttp` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.TheHttp` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_theHTTP: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttp) + var hasSwiftProtoTesting_Names_WordCase_theHTTP: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttp) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.TheHttp`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.TheHttp`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_theHTTP() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttp) + mutating func clearSwiftProtoTesting_Names_WordCase_theHTTP() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttp) } - var SwiftUnittest_Names_WordCase_https: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Https) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Https, value: newValue)} + var SwiftProtoTesting_Names_WordCase_https: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Https) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Https, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.Https` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.Https` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_https: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Https) + var hasSwiftProtoTesting_Names_WordCase_https: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Https) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.Https`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.Https`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_https() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Https) + mutating func clearSwiftProtoTesting_Names_WordCase_https() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Https) } - var SwiftUnittest_Names_WordCase_httpsRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.HttpsRequest) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.HttpsRequest, value: newValue)} + var SwiftProtoTesting_Names_WordCase_httpsRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.HttpsRequest) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.HttpsRequest, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.HttpsRequest` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.HttpsRequest` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_httpsRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.HttpsRequest) + var hasSwiftProtoTesting_Names_WordCase_httpsRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.HttpsRequest) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.HttpsRequest`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.HttpsRequest`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_httpsRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.HttpsRequest) + mutating func clearSwiftProtoTesting_Names_WordCase_httpsRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.HttpsRequest) } - var SwiftUnittest_Names_WordCase_theHTTPSRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttpsRequest) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttpsRequest, value: newValue)} + var SwiftProtoTesting_Names_WordCase_theHTTPSRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttpsRequest) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttpsRequest, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.TheHttpsRequest` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.TheHttpsRequest` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_theHTTPSRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttpsRequest) + var hasSwiftProtoTesting_Names_WordCase_theHTTPSRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttpsRequest) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.TheHttpsRequest`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.TheHttpsRequest`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_theHTTPSRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttpsRequest) + mutating func clearSwiftProtoTesting_Names_WordCase_theHTTPSRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttpsRequest) } - var SwiftUnittest_Names_WordCase_theHTTPS: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttps) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttps, value: newValue)} + var SwiftProtoTesting_Names_WordCase_theHTTPS: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttps) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttps, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.TheHttps` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.TheHttps` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_theHTTPS: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttps) + var hasSwiftProtoTesting_Names_WordCase_theHTTPS: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttps) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.TheHttps`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.TheHttps`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_theHTTPS() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheHttps) + mutating func clearSwiftProtoTesting_Names_WordCase_theHTTPS() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheHttps) } - var SwiftUnittest_Names_WordCase_url: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Url) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Url, value: newValue)} + var SwiftProtoTesting_Names_WordCase_url: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Url) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Url, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.Url` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.Url` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_url: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Url) + var hasSwiftProtoTesting_Names_WordCase_url: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Url) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.Url`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.Url`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_url() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Url) + mutating func clearSwiftProtoTesting_Names_WordCase_url() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Url) } - var SwiftUnittest_Names_WordCase_urlValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.UrlValue) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.UrlValue, value: newValue)} + var SwiftProtoTesting_Names_WordCase_urlValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.UrlValue) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.UrlValue, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.UrlValue` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.UrlValue` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_urlValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.UrlValue) + var hasSwiftProtoTesting_Names_WordCase_urlValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.UrlValue) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.UrlValue`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.UrlValue`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_urlValue() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.UrlValue) + mutating func clearSwiftProtoTesting_Names_WordCase_urlValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.UrlValue) } - var SwiftUnittest_Names_WordCase_theURLValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheUrlValue) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheUrlValue, value: newValue)} + var SwiftProtoTesting_Names_WordCase_theURLValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheUrlValue) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheUrlValue, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.TheUrlValue` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.TheUrlValue` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_theURLValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheUrlValue) + var hasSwiftProtoTesting_Names_WordCase_theURLValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheUrlValue) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.TheUrlValue`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.TheUrlValue`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_theURLValue() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheUrlValue) + mutating func clearSwiftProtoTesting_Names_WordCase_theURLValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheUrlValue) } - var SwiftUnittest_Names_WordCase_theURL: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheUrl) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheUrl, value: newValue)} + var SwiftProtoTesting_Names_WordCase_theURL: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheUrl) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheUrl, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.TheUrl` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.TheUrl` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_theURL: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheUrl) + var hasSwiftProtoTesting_Names_WordCase_theURL: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheUrl) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.TheUrl`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.TheUrl`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_theURL() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheUrl) + mutating func clearSwiftProtoTesting_Names_WordCase_theURL() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheUrl) } - var SwiftUnittest_Names_WordCase_id: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Id) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Id, value: newValue)} + var SwiftProtoTesting_Names_WordCase_id: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Id) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Id, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.Id` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.Id` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_id: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Id) + var hasSwiftProtoTesting_Names_WordCase_id: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Id) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.Id`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.Id`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_id() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.Id) + mutating func clearSwiftProtoTesting_Names_WordCase_id() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.Id) } - var SwiftUnittest_Names_WordCase_idNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.IdNumber) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.IdNumber, value: newValue)} + var SwiftProtoTesting_Names_WordCase_idNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.IdNumber) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.IdNumber, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.IdNumber` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.IdNumber` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_idNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.IdNumber) + var hasSwiftProtoTesting_Names_WordCase_idNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.IdNumber) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.IdNumber`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.IdNumber`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_idNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.IdNumber) + mutating func clearSwiftProtoTesting_Names_WordCase_idNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.IdNumber) } - var SwiftUnittest_Names_WordCase_theIDNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheIdNumber) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheIdNumber, value: newValue)} + var SwiftProtoTesting_Names_WordCase_theIDNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheIdNumber) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheIdNumber, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.TheIdNumber` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.TheIdNumber` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_theIDNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheIdNumber) + var hasSwiftProtoTesting_Names_WordCase_theIDNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheIdNumber) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.TheIdNumber`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.TheIdNumber`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_theIDNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.TheIdNumber) + mutating func clearSwiftProtoTesting_Names_WordCase_theIDNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.TheIdNumber) } - var SwiftUnittest_Names_WordCase_requestID: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.RequestId) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.RequestId, value: newValue)} + var SwiftProtoTesting_Names_WordCase_requestID: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.RequestId) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.RequestId, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_WordCase.Extensions.RequestId` + /// Returns true if extension `SwiftProtoTesting_Names_WordCase.Extensions.RequestId` /// has been explicitly set. - var hasSwiftUnittest_Names_WordCase_requestID: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.RequestId) + var hasSwiftProtoTesting_Names_WordCase_requestID: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.RequestId) } - /// Clears the value of extension `SwiftUnittest_Names_WordCase.Extensions.RequestId`. + /// Clears the value of extension `SwiftProtoTesting_Names_WordCase.Extensions.RequestId`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_WordCase_requestID() { - clearExtensionValue(ext: SwiftUnittest_Names_WordCase.Extensions.RequestId) + mutating func clearSwiftProtoTesting_Names_WordCase_requestID() { + clearExtensionValue(ext: SwiftProtoTesting_Names_WordCase.Extensions.RequestId) } } -extension SwiftUnittest_Names_ExtensionNamingInitialsLowers { +extension SwiftProtoTesting_Names_ExtensionNamingInitialsLowers { - var SwiftUnittest_Names_http: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_http) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_http, value: newValue)} + var SwiftProtoTesting_Names_http: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_http) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_http, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_http` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_http` /// has been explicitly set. - var hasSwiftUnittest_Names_http: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_http) + var hasSwiftProtoTesting_Names_http: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_http) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_http`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_http`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_http() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_http) + mutating func clearSwiftProtoTesting_Names_http() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_http) } - var SwiftUnittest_Names_httpRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_http_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_http_request, value: newValue)} + var SwiftProtoTesting_Names_httpRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_http_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_http_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_http_request` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_http_request` /// has been explicitly set. - var hasSwiftUnittest_Names_httpRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_http_request) + var hasSwiftProtoTesting_Names_httpRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_http_request) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_http_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_http_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_httpRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_http_request) + mutating func clearSwiftProtoTesting_Names_httpRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_http_request) } - var SwiftUnittest_Names_theHTTPRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_http_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_http_request, value: newValue)} + var SwiftProtoTesting_Names_theHTTPRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_http_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_http_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_http_request` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_http_request` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTPRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_http_request) + var hasSwiftProtoTesting_Names_theHTTPRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_http_request) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_http_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_http_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTPRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_http_request) + mutating func clearSwiftProtoTesting_Names_theHTTPRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_http_request) } - var SwiftUnittest_Names_theHTTP: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_http) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_http, value: newValue)} + var SwiftProtoTesting_Names_theHTTP: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_http) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_http, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_http` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_http` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTP: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_http) + var hasSwiftProtoTesting_Names_theHTTP: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_http) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_http`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_http`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTP() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_http) + mutating func clearSwiftProtoTesting_Names_theHTTP() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_http) } - var SwiftUnittest_Names_https: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_https) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_https, value: newValue)} + var SwiftProtoTesting_Names_https: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_https) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_https, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_https` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_https` /// has been explicitly set. - var hasSwiftUnittest_Names_https: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_https) + var hasSwiftProtoTesting_Names_https: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_https) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_https`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_https`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_https() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_https) + mutating func clearSwiftProtoTesting_Names_https() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_https) } - var SwiftUnittest_Names_httpsRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_https_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_https_request, value: newValue)} + var SwiftProtoTesting_Names_httpsRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_https_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_https_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_https_request` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_https_request` /// has been explicitly set. - var hasSwiftUnittest_Names_httpsRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_https_request) + var hasSwiftProtoTesting_Names_httpsRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_https_request) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_https_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_https_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_httpsRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_https_request) + mutating func clearSwiftProtoTesting_Names_httpsRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_https_request) } - var SwiftUnittest_Names_theHTTPSRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_https_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_https_request, value: newValue)} + var SwiftProtoTesting_Names_theHTTPSRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_https_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_https_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_https_request` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_https_request` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTPSRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_https_request) + var hasSwiftProtoTesting_Names_theHTTPSRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_https_request) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_https_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_https_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTPSRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_https_request) + mutating func clearSwiftProtoTesting_Names_theHTTPSRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_https_request) } - var SwiftUnittest_Names_theHTTPS: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_https) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_https, value: newValue)} + var SwiftProtoTesting_Names_theHTTPS: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_https) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_https, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_https` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_https` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTPS: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_https) + var hasSwiftProtoTesting_Names_theHTTPS: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_https) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_https`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_https`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTPS() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_https) + mutating func clearSwiftProtoTesting_Names_theHTTPS() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_https) } - var SwiftUnittest_Names_url: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_url) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_url, value: newValue)} + var SwiftProtoTesting_Names_url: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_url) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_url, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_url` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_url` /// has been explicitly set. - var hasSwiftUnittest_Names_url: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_url) + var hasSwiftProtoTesting_Names_url: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_url) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_url`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_url`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_url() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_url) + mutating func clearSwiftProtoTesting_Names_url() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_url) } - var SwiftUnittest_Names_urlValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_url_value) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_url_value, value: newValue)} + var SwiftProtoTesting_Names_urlValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_url_value) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_url_value, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_url_value` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_url_value` /// has been explicitly set. - var hasSwiftUnittest_Names_urlValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_url_value) + var hasSwiftProtoTesting_Names_urlValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_url_value) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_url_value`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_url_value`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_urlValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_url_value) + mutating func clearSwiftProtoTesting_Names_urlValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_url_value) } - var SwiftUnittest_Names_theURLValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_url_value) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_url_value, value: newValue)} + var SwiftProtoTesting_Names_theURLValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_url_value) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_url_value, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_url_value` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_url_value` /// has been explicitly set. - var hasSwiftUnittest_Names_theURLValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_url_value) + var hasSwiftProtoTesting_Names_theURLValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_url_value) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_url_value`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_url_value`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theURLValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_url_value) + mutating func clearSwiftProtoTesting_Names_theURLValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_url_value) } - var SwiftUnittest_Names_theURL: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_url) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_url, value: newValue)} + var SwiftProtoTesting_Names_theURL: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_url) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_url, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_url` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_url` /// has been explicitly set. - var hasSwiftUnittest_Names_theURL: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_url) + var hasSwiftProtoTesting_Names_theURL: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_url) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_url`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_url`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theURL() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_url) + mutating func clearSwiftProtoTesting_Names_theURL() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_url) } - var SwiftUnittest_Names_aBC: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_a_b_c) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_a_b_c, value: newValue)} + var SwiftProtoTesting_Names_aBC: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_a_b_c) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_a_b_c, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_a_b_c` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_a_b_c` /// has been explicitly set. - var hasSwiftUnittest_Names_aBC: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_a_b_c) + var hasSwiftProtoTesting_Names_aBC: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_a_b_c) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_a_b_c`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_a_b_c`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_aBC() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_a_b_c) + mutating func clearSwiftProtoTesting_Names_aBC() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_a_b_c) } - var SwiftUnittest_Names_id: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_id) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_id, value: newValue)} + var SwiftProtoTesting_Names_id: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_id) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_id, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_id` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_id` /// has been explicitly set. - var hasSwiftUnittest_Names_id: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_id) + var hasSwiftProtoTesting_Names_id: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_id) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_id`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_id`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_id() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_id) + mutating func clearSwiftProtoTesting_Names_id() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_id) } - var SwiftUnittest_Names_idNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_id_number) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_id_number, value: newValue)} + var SwiftProtoTesting_Names_idNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_id_number) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_id_number, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_id_number` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_id_number` /// has been explicitly set. - var hasSwiftUnittest_Names_idNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_id_number) + var hasSwiftProtoTesting_Names_idNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_id_number) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_id_number`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_id_number`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_idNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_id_number) + mutating func clearSwiftProtoTesting_Names_idNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_id_number) } - var SwiftUnittest_Names_theIDNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_id_number) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_id_number, value: newValue)} + var SwiftProtoTesting_Names_theIDNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_id_number) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_id_number, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_id_number` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_id_number` /// has been explicitly set. - var hasSwiftUnittest_Names_theIDNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_id_number) + var hasSwiftProtoTesting_Names_theIDNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_id_number) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_id_number`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_id_number`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theIDNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_id_number) + mutating func clearSwiftProtoTesting_Names_theIDNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_id_number) } - var SwiftUnittest_Names_requestID: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_request_id) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_request_id, value: newValue)} + var SwiftProtoTesting_Names_requestID: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_request_id) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_request_id, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_request_id` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_request_id` /// has been explicitly set. - var hasSwiftUnittest_Names_requestID: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_request_id) + var hasSwiftProtoTesting_Names_requestID: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_request_id) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_request_id`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_request_id`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_requestID() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_request_id) + mutating func clearSwiftProtoTesting_Names_requestID() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_request_id) } } -extension SwiftUnittest_Names_ExtensionNamingInitialsUppers { +extension SwiftProtoTesting_Names_ExtensionNamingInitialsUppers { - var SwiftUnittest_Names_http: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTP) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTP, value: newValue)} + var SwiftProtoTesting_Names_http: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTP) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTP, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_HTTP` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_HTTP` /// has been explicitly set. - var hasSwiftUnittest_Names_http: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTP) + var hasSwiftProtoTesting_Names_http: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTP) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_HTTP`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_HTTP`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_http() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTP) + mutating func clearSwiftProtoTesting_Names_http() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTP) } - var SwiftUnittest_Names_httpRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTP_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTP_request, value: newValue)} + var SwiftProtoTesting_Names_httpRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTP_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTP_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_HTTP_request` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_HTTP_request` /// has been explicitly set. - var hasSwiftUnittest_Names_httpRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTP_request) + var hasSwiftProtoTesting_Names_httpRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTP_request) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_HTTP_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_HTTP_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_httpRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTP_request) + mutating func clearSwiftProtoTesting_Names_httpRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTP_request) } - var SwiftUnittest_Names_theHTTPRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTP_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTP_request, value: newValue)} + var SwiftProtoTesting_Names_theHTTPRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTP_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTP_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_HTTP_request` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_HTTP_request` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTPRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTP_request) + var hasSwiftProtoTesting_Names_theHTTPRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTP_request) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_HTTP_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_HTTP_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTPRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTP_request) + mutating func clearSwiftProtoTesting_Names_theHTTPRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTP_request) } - var SwiftUnittest_Names_theHTTP: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTP) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTP, value: newValue)} + var SwiftProtoTesting_Names_theHTTP: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTP) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTP, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_HTTP` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_HTTP` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTP: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTP) + var hasSwiftProtoTesting_Names_theHTTP: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTP) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_HTTP`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_HTTP`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTP() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTP) + mutating func clearSwiftProtoTesting_Names_theHTTP() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTP) } - var SwiftUnittest_Names_https: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTPS) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTPS, value: newValue)} + var SwiftProtoTesting_Names_https: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTPS) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTPS, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_HTTPS` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_HTTPS` /// has been explicitly set. - var hasSwiftUnittest_Names_https: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTPS) + var hasSwiftProtoTesting_Names_https: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTPS) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_HTTPS`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_HTTPS`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_https() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTPS) + mutating func clearSwiftProtoTesting_Names_https() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTPS) } - var SwiftUnittest_Names_httpsRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTPS_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTPS_request, value: newValue)} + var SwiftProtoTesting_Names_httpsRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTPS_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTPS_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_HTTPS_request` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_HTTPS_request` /// has been explicitly set. - var hasSwiftUnittest_Names_httpsRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTPS_request) + var hasSwiftProtoTesting_Names_httpsRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTPS_request) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_HTTPS_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_HTTPS_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_httpsRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_HTTPS_request) + mutating func clearSwiftProtoTesting_Names_httpsRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HTTPS_request) } - var SwiftUnittest_Names_theHTTPSRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTPS_request) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTPS_request, value: newValue)} + var SwiftProtoTesting_Names_theHTTPSRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTPS_request) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTPS_request, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_HTTPS_request` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_HTTPS_request` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTPSRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTPS_request) + var hasSwiftProtoTesting_Names_theHTTPSRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTPS_request) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_HTTPS_request`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_HTTPS_request`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTPSRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTPS_request) + mutating func clearSwiftProtoTesting_Names_theHTTPSRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTPS_request) } - var SwiftUnittest_Names_theHTTPS: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTPS) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTPS, value: newValue)} + var SwiftProtoTesting_Names_theHTTPS: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTPS) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTPS, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_HTTPS` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_HTTPS` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTPS: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTPS) + var hasSwiftProtoTesting_Names_theHTTPS: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTPS) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_HTTPS`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_HTTPS`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTPS() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_HTTPS) + mutating func clearSwiftProtoTesting_Names_theHTTPS() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_HTTPS) } - var SwiftUnittest_Names_url: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_URL) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_URL, value: newValue)} + var SwiftProtoTesting_Names_url: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_URL) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_URL, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_URL` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_URL` /// has been explicitly set. - var hasSwiftUnittest_Names_url: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_URL) + var hasSwiftProtoTesting_Names_url: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_URL) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_URL`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_URL`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_url() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_URL) + mutating func clearSwiftProtoTesting_Names_url() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_URL) } - var SwiftUnittest_Names_urlValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_URL_value) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_URL_value, value: newValue)} + var SwiftProtoTesting_Names_urlValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_URL_value) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_URL_value, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_URL_value` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_URL_value` /// has been explicitly set. - var hasSwiftUnittest_Names_urlValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_URL_value) + var hasSwiftProtoTesting_Names_urlValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_URL_value) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_URL_value`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_URL_value`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_urlValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_URL_value) + mutating func clearSwiftProtoTesting_Names_urlValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_URL_value) } - var SwiftUnittest_Names_theURLValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_URL_value) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_URL_value, value: newValue)} + var SwiftProtoTesting_Names_theURLValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_URL_value) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_URL_value, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_URL_value` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_URL_value` /// has been explicitly set. - var hasSwiftUnittest_Names_theURLValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_URL_value) + var hasSwiftProtoTesting_Names_theURLValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_URL_value) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_URL_value`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_URL_value`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theURLValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_URL_value) + mutating func clearSwiftProtoTesting_Names_theURLValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_URL_value) } - var SwiftUnittest_Names_theURL: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_URL) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_URL, value: newValue)} + var SwiftProtoTesting_Names_theURL: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_URL) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_URL, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_URL` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_URL` /// has been explicitly set. - var hasSwiftUnittest_Names_theURL: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_URL) + var hasSwiftProtoTesting_Names_theURL: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_URL) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_URL`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_URL`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theURL() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_URL) + mutating func clearSwiftProtoTesting_Names_theURL() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_URL) } - var SwiftUnittest_Names_id: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_ID) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_ID, value: newValue)} + var SwiftProtoTesting_Names_id: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_ID) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_ID, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_ID` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_ID` /// has been explicitly set. - var hasSwiftUnittest_Names_id: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_ID) + var hasSwiftProtoTesting_Names_id: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_ID) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_ID`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_ID`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_id() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_ID) + mutating func clearSwiftProtoTesting_Names_id() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_ID) } - var SwiftUnittest_Names_idNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_ID_number) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_ID_number, value: newValue)} + var SwiftProtoTesting_Names_idNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_ID_number) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_ID_number, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_ID_number` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_ID_number` /// has been explicitly set. - var hasSwiftUnittest_Names_idNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_ID_number) + var hasSwiftProtoTesting_Names_idNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_ID_number) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_ID_number`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_ID_number`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_idNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_ID_number) + mutating func clearSwiftProtoTesting_Names_idNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_ID_number) } - var SwiftUnittest_Names_theIDNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_the_ID_number) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_the_ID_number, value: newValue)} + var SwiftProtoTesting_Names_theIDNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_ID_number) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_ID_number, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_the_ID_number` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_the_ID_number` /// has been explicitly set. - var hasSwiftUnittest_Names_theIDNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_the_ID_number) + var hasSwiftProtoTesting_Names_theIDNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_ID_number) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_the_ID_number`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_the_ID_number`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theIDNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_the_ID_number) + mutating func clearSwiftProtoTesting_Names_theIDNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_the_ID_number) } - var SwiftUnittest_Names_requestID: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_request_ID) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_request_ID, value: newValue)} + var SwiftProtoTesting_Names_requestID: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_request_ID) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_request_ID, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_request_ID` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_request_ID` /// has been explicitly set. - var hasSwiftUnittest_Names_requestID: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_request_ID) + var hasSwiftProtoTesting_Names_requestID: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_request_ID) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_request_ID`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_request_ID`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_requestID() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_request_ID) + mutating func clearSwiftProtoTesting_Names_requestID() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_request_ID) } } -extension SwiftUnittest_Names_ExtensionNamingInitialsWordCase { +extension SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase { - var SwiftUnittest_Names_http: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_Http) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_Http, value: newValue)} + var SwiftProtoTesting_Names_http: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Http) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Http, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_Http` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_Http` /// has been explicitly set. - var hasSwiftUnittest_Names_http: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_Http) + var hasSwiftProtoTesting_Names_http: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Http) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_Http`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_Http`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_http() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_Http) + mutating func clearSwiftProtoTesting_Names_http() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Http) } - var SwiftUnittest_Names_httpRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_HttpRequest) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_HttpRequest, value: newValue)} + var SwiftProtoTesting_Names_httpRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HttpRequest) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HttpRequest, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_HttpRequest` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_HttpRequest` /// has been explicitly set. - var hasSwiftUnittest_Names_httpRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_HttpRequest) + var hasSwiftProtoTesting_Names_httpRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HttpRequest) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_HttpRequest`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_HttpRequest`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_httpRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_HttpRequest) + mutating func clearSwiftProtoTesting_Names_httpRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HttpRequest) } - var SwiftUnittest_Names_theHTTPRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttpRequest) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttpRequest, value: newValue)} + var SwiftProtoTesting_Names_theHTTPRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttpRequest) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttpRequest, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_TheHttpRequest` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_TheHttpRequest` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTPRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttpRequest) + var hasSwiftProtoTesting_Names_theHTTPRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttpRequest) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_TheHttpRequest`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_TheHttpRequest`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTPRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttpRequest) + mutating func clearSwiftProtoTesting_Names_theHTTPRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttpRequest) } - var SwiftUnittest_Names_theHTTP: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttp) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttp, value: newValue)} + var SwiftProtoTesting_Names_theHTTP: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttp) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttp, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_TheHttp` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_TheHttp` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTP: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttp) + var hasSwiftProtoTesting_Names_theHTTP: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttp) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_TheHttp`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_TheHttp`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTP() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttp) + mutating func clearSwiftProtoTesting_Names_theHTTP() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttp) } - var SwiftUnittest_Names_https: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_Https) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_Https, value: newValue)} + var SwiftProtoTesting_Names_https: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Https) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Https, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_Https` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_Https` /// has been explicitly set. - var hasSwiftUnittest_Names_https: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_Https) + var hasSwiftProtoTesting_Names_https: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Https) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_Https`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_Https`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_https() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_Https) + mutating func clearSwiftProtoTesting_Names_https() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Https) } - var SwiftUnittest_Names_httpsRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_HttpsRequest) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_HttpsRequest, value: newValue)} + var SwiftProtoTesting_Names_httpsRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HttpsRequest) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HttpsRequest, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_HttpsRequest` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_HttpsRequest` /// has been explicitly set. - var hasSwiftUnittest_Names_httpsRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_HttpsRequest) + var hasSwiftProtoTesting_Names_httpsRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HttpsRequest) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_HttpsRequest`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_HttpsRequest`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_httpsRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_HttpsRequest) + mutating func clearSwiftProtoTesting_Names_httpsRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_HttpsRequest) } - var SwiftUnittest_Names_theHTTPSRequest: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttpsRequest) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttpsRequest, value: newValue)} + var SwiftProtoTesting_Names_theHTTPSRequest: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttpsRequest) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttpsRequest, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_TheHttpsRequest` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_TheHttpsRequest` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTPSRequest: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttpsRequest) + var hasSwiftProtoTesting_Names_theHTTPSRequest: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttpsRequest) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_TheHttpsRequest`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_TheHttpsRequest`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTPSRequest() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttpsRequest) + mutating func clearSwiftProtoTesting_Names_theHTTPSRequest() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttpsRequest) } - var SwiftUnittest_Names_theHTTPS: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttps) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttps, value: newValue)} + var SwiftProtoTesting_Names_theHTTPS: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttps) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttps, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_TheHttps` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_TheHttps` /// has been explicitly set. - var hasSwiftUnittest_Names_theHTTPS: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttps) + var hasSwiftProtoTesting_Names_theHTTPS: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttps) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_TheHttps`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_TheHttps`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theHTTPS() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_TheHttps) + mutating func clearSwiftProtoTesting_Names_theHTTPS() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheHttps) } - var SwiftUnittest_Names_url: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_Url) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_Url, value: newValue)} + var SwiftProtoTesting_Names_url: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Url) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Url, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_Url` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_Url` /// has been explicitly set. - var hasSwiftUnittest_Names_url: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_Url) + var hasSwiftProtoTesting_Names_url: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Url) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_Url`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_Url`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_url() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_Url) + mutating func clearSwiftProtoTesting_Names_url() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Url) } - var SwiftUnittest_Names_urlValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_UrlValue) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_UrlValue, value: newValue)} + var SwiftProtoTesting_Names_urlValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_UrlValue) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_UrlValue, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_UrlValue` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_UrlValue` /// has been explicitly set. - var hasSwiftUnittest_Names_urlValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_UrlValue) + var hasSwiftProtoTesting_Names_urlValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_UrlValue) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_UrlValue`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_UrlValue`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_urlValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_UrlValue) + mutating func clearSwiftProtoTesting_Names_urlValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_UrlValue) } - var SwiftUnittest_Names_theURLValue: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_TheUrlValue) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_TheUrlValue, value: newValue)} + var SwiftProtoTesting_Names_theURLValue: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheUrlValue) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheUrlValue, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_TheUrlValue` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_TheUrlValue` /// has been explicitly set. - var hasSwiftUnittest_Names_theURLValue: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_TheUrlValue) + var hasSwiftProtoTesting_Names_theURLValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheUrlValue) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_TheUrlValue`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_TheUrlValue`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theURLValue() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_TheUrlValue) + mutating func clearSwiftProtoTesting_Names_theURLValue() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheUrlValue) } - var SwiftUnittest_Names_theURL: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_TheUrl) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_TheUrl, value: newValue)} + var SwiftProtoTesting_Names_theURL: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheUrl) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheUrl, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_TheUrl` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_TheUrl` /// has been explicitly set. - var hasSwiftUnittest_Names_theURL: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_TheUrl) + var hasSwiftProtoTesting_Names_theURL: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheUrl) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_TheUrl`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_TheUrl`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theURL() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_TheUrl) + mutating func clearSwiftProtoTesting_Names_theURL() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheUrl) } - var SwiftUnittest_Names_id: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_Id) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_Id, value: newValue)} + var SwiftProtoTesting_Names_id: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Id) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Id, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_Id` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_Id` /// has been explicitly set. - var hasSwiftUnittest_Names_id: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_Id) + var hasSwiftProtoTesting_Names_id: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Id) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_Id`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_Id`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_id() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_Id) + mutating func clearSwiftProtoTesting_Names_id() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_Id) } - var SwiftUnittest_Names_idNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_IdNumber) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_IdNumber, value: newValue)} + var SwiftProtoTesting_Names_idNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_IdNumber) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_IdNumber, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_IdNumber` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_IdNumber` /// has been explicitly set. - var hasSwiftUnittest_Names_idNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_IdNumber) + var hasSwiftProtoTesting_Names_idNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_IdNumber) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_IdNumber`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_IdNumber`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_idNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_IdNumber) + mutating func clearSwiftProtoTesting_Names_idNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_IdNumber) } - var SwiftUnittest_Names_theIDNumber: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_TheIdNumber) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_TheIdNumber, value: newValue)} + var SwiftProtoTesting_Names_theIDNumber: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheIdNumber) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheIdNumber, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_TheIdNumber` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_TheIdNumber` /// has been explicitly set. - var hasSwiftUnittest_Names_theIDNumber: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_TheIdNumber) + var hasSwiftProtoTesting_Names_theIDNumber: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheIdNumber) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_TheIdNumber`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_TheIdNumber`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_theIDNumber() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_TheIdNumber) + mutating func clearSwiftProtoTesting_Names_theIDNumber() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_TheIdNumber) } - var SwiftUnittest_Names_requestID: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_Extensions_RequestId) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_Extensions_RequestId, value: newValue)} + var SwiftProtoTesting_Names_requestID: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_Extensions_RequestId) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_Extensions_RequestId, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_Extensions_RequestId` + /// Returns true if extension `SwiftProtoTesting_Names_Extensions_RequestId` /// has been explicitly set. - var hasSwiftUnittest_Names_requestID: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_Extensions_RequestId) + var hasSwiftProtoTesting_Names_requestID: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_Extensions_RequestId) } - /// Clears the value of extension `SwiftUnittest_Names_Extensions_RequestId`. + /// Clears the value of extension `SwiftProtoTesting_Names_Extensions_RequestId`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_requestID() { - clearExtensionValue(ext: SwiftUnittest_Names_Extensions_RequestId) + mutating func clearSwiftProtoTesting_Names_requestID() { + clearExtensionValue(ext: SwiftProtoTesting_Names_Extensions_RequestId) } } -extension SwiftUnittest_Names_Foo { +extension SwiftProtoTesting_Names_Foo { - var SwiftUnittest_Names_FieldNames_foo1: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_FieldNames.Extensions.foo1) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_FieldNames.Extensions.foo1, value: newValue)} + var SwiftProtoTesting_Names_FieldNames_foo1: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_FieldNames.Extensions.foo1) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_FieldNames.Extensions.foo1, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_FieldNames.Extensions.foo1` + /// Returns true if extension `SwiftProtoTesting_Names_FieldNames.Extensions.foo1` /// has been explicitly set. - var hasSwiftUnittest_Names_FieldNames_foo1: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_FieldNames.Extensions.foo1) + var hasSwiftProtoTesting_Names_FieldNames_foo1: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_FieldNames.Extensions.foo1) } - /// Clears the value of extension `SwiftUnittest_Names_FieldNames.Extensions.foo1`. + /// Clears the value of extension `SwiftProtoTesting_Names_FieldNames.Extensions.foo1`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_FieldNames_foo1() { - clearExtensionValue(ext: SwiftUnittest_Names_FieldNames.Extensions.foo1) + mutating func clearSwiftProtoTesting_Names_FieldNames_foo1() { + clearExtensionValue(ext: SwiftProtoTesting_Names_FieldNames.Extensions.foo1) } - var SwiftUnittest_Names_MessageNames_foo2: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_MessageNames.Extensions.foo2) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_MessageNames.Extensions.foo2, value: newValue)} + var SwiftProtoTesting_Names_MessageNames_foo2: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.Extensions.foo2) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.Extensions.foo2, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_MessageNames.Extensions.foo2` + /// Returns true if extension `SwiftProtoTesting_Names_MessageNames.Extensions.foo2` /// has been explicitly set. - var hasSwiftUnittest_Names_MessageNames_foo2: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_MessageNames.Extensions.foo2) + var hasSwiftProtoTesting_Names_MessageNames_foo2: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.Extensions.foo2) } - /// Clears the value of extension `SwiftUnittest_Names_MessageNames.Extensions.foo2`. + /// Clears the value of extension `SwiftProtoTesting_Names_MessageNames.Extensions.foo2`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_MessageNames_foo2() { - clearExtensionValue(ext: SwiftUnittest_Names_MessageNames.Extensions.foo2) + mutating func clearSwiftProtoTesting_Names_MessageNames_foo2() { + clearExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.Extensions.foo2) } - var SwiftUnittest_Names_MessageNames_foo4: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_MessageNames.Extensions.foo4) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_MessageNames.Extensions.foo4, value: newValue)} + var SwiftProtoTesting_Names_MessageNames_foo4: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.Extensions.foo4) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.Extensions.foo4, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_MessageNames.Extensions.foo4` + /// Returns true if extension `SwiftProtoTesting_Names_MessageNames.Extensions.foo4` /// has been explicitly set. - var hasSwiftUnittest_Names_MessageNames_foo4: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_MessageNames.Extensions.foo4) + var hasSwiftProtoTesting_Names_MessageNames_foo4: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.Extensions.foo4) } - /// Clears the value of extension `SwiftUnittest_Names_MessageNames.Extensions.foo4`. + /// Clears the value of extension `SwiftProtoTesting_Names_MessageNames.Extensions.foo4`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_MessageNames_foo4() { - clearExtensionValue(ext: SwiftUnittest_Names_MessageNames.Extensions.foo4) + mutating func clearSwiftProtoTesting_Names_MessageNames_foo4() { + clearExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.Extensions.foo4) } - var SwiftUnittest_Names_MessageNames_StringMessage_foo3: Int32 { - get {return getExtensionValue(ext: SwiftUnittest_Names_MessageNames.StringMessage.Extensions.foo3) ?? 0} - set {setExtensionValue(ext: SwiftUnittest_Names_MessageNames.StringMessage.Extensions.foo3, value: newValue)} + var SwiftProtoTesting_Names_MessageNames_StringMessage_foo3: Int32 { + get {return getExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.StringMessage.Extensions.foo3) ?? 0} + set {setExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.StringMessage.Extensions.foo3, value: newValue)} } - /// Returns true if extension `SwiftUnittest_Names_MessageNames.StringMessage.Extensions.foo3` + /// Returns true if extension `SwiftProtoTesting_Names_MessageNames.StringMessage.Extensions.foo3` /// has been explicitly set. - var hasSwiftUnittest_Names_MessageNames_StringMessage_foo3: Bool { - return hasExtensionValue(ext: SwiftUnittest_Names_MessageNames.StringMessage.Extensions.foo3) + var hasSwiftProtoTesting_Names_MessageNames_StringMessage_foo3: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.StringMessage.Extensions.foo3) } - /// Clears the value of extension `SwiftUnittest_Names_MessageNames.StringMessage.Extensions.foo3`. + /// Clears the value of extension `SwiftProtoTesting_Names_MessageNames.StringMessage.Extensions.foo3`. /// Subsequent reads from it will return its default value. - mutating func clearSwiftUnittest_Names_MessageNames_StringMessage_foo3() { - clearExtensionValue(ext: SwiftUnittest_Names_MessageNames.StringMessage.Extensions.foo3) + mutating func clearSwiftProtoTesting_Names_MessageNames_StringMessage_foo3() { + clearExtensionValue(ext: SwiftProtoTesting_Names_MessageNames.StringMessage.Extensions.foo3) } } -// MARK: - File's ExtensionMap: SwiftUnittest_Names_UnittestSwiftNaming_Extensions +// MARK: - File's ExtensionMap: SwiftProtoTesting_Names_UnittestSwiftNaming_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 SwiftUnittest_Names_UnittestSwiftNaming_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - SwiftUnittest_Names_Extensions_http, - SwiftUnittest_Names_Extensions_http_request, - SwiftUnittest_Names_Extensions_the_http_request, - SwiftUnittest_Names_Extensions_the_http, - SwiftUnittest_Names_Extensions_https, - SwiftUnittest_Names_Extensions_https_request, - SwiftUnittest_Names_Extensions_the_https_request, - SwiftUnittest_Names_Extensions_the_https, - SwiftUnittest_Names_Extensions_url, - SwiftUnittest_Names_Extensions_url_value, - SwiftUnittest_Names_Extensions_the_url_value, - SwiftUnittest_Names_Extensions_the_url, - SwiftUnittest_Names_Extensions_a_b_c, - SwiftUnittest_Names_Extensions_id, - SwiftUnittest_Names_Extensions_id_number, - SwiftUnittest_Names_Extensions_the_id_number, - SwiftUnittest_Names_Extensions_request_id, - SwiftUnittest_Names_Extensions_HTTP, - SwiftUnittest_Names_Extensions_HTTP_request, - SwiftUnittest_Names_Extensions_the_HTTP_request, - SwiftUnittest_Names_Extensions_the_HTTP, - SwiftUnittest_Names_Extensions_HTTPS, - SwiftUnittest_Names_Extensions_HTTPS_request, - SwiftUnittest_Names_Extensions_the_HTTPS_request, - SwiftUnittest_Names_Extensions_the_HTTPS, - SwiftUnittest_Names_Extensions_URL, - SwiftUnittest_Names_Extensions_URL_value, - SwiftUnittest_Names_Extensions_the_URL_value, - SwiftUnittest_Names_Extensions_the_URL, - SwiftUnittest_Names_Extensions_ID, - SwiftUnittest_Names_Extensions_ID_number, - SwiftUnittest_Names_Extensions_the_ID_number, - SwiftUnittest_Names_Extensions_request_ID, - SwiftUnittest_Names_Extensions_Http, - SwiftUnittest_Names_Extensions_HttpRequest, - SwiftUnittest_Names_Extensions_TheHttpRequest, - SwiftUnittest_Names_Extensions_TheHttp, - SwiftUnittest_Names_Extensions_Https, - SwiftUnittest_Names_Extensions_HttpsRequest, - SwiftUnittest_Names_Extensions_TheHttpsRequest, - SwiftUnittest_Names_Extensions_TheHttps, - SwiftUnittest_Names_Extensions_Url, - SwiftUnittest_Names_Extensions_UrlValue, - SwiftUnittest_Names_Extensions_TheUrlValue, - SwiftUnittest_Names_Extensions_TheUrl, - SwiftUnittest_Names_Extensions_Id, - SwiftUnittest_Names_Extensions_IdNumber, - SwiftUnittest_Names_Extensions_TheIdNumber, - SwiftUnittest_Names_Extensions_RequestId, - SwiftUnittest_Names_FieldNames.Extensions.foo1, - SwiftUnittest_Names_MessageNames.Extensions.foo2, - SwiftUnittest_Names_MessageNames.Extensions.foo4, - SwiftUnittest_Names_MessageNames.StringMessage.Extensions.foo3, - SwiftUnittest_Names_Lowers.Extensions.http, - SwiftUnittest_Names_Lowers.Extensions.http_request, - SwiftUnittest_Names_Lowers.Extensions.the_http_request, - SwiftUnittest_Names_Lowers.Extensions.the_http, - SwiftUnittest_Names_Lowers.Extensions.https, - SwiftUnittest_Names_Lowers.Extensions.https_request, - SwiftUnittest_Names_Lowers.Extensions.the_https_request, - SwiftUnittest_Names_Lowers.Extensions.the_https, - SwiftUnittest_Names_Lowers.Extensions.url, - SwiftUnittest_Names_Lowers.Extensions.url_value, - SwiftUnittest_Names_Lowers.Extensions.the_url_value, - SwiftUnittest_Names_Lowers.Extensions.the_url, - SwiftUnittest_Names_Lowers.Extensions.a_b_c, - SwiftUnittest_Names_Lowers.Extensions.id, - SwiftUnittest_Names_Lowers.Extensions.id_number, - SwiftUnittest_Names_Lowers.Extensions.the_id_number, - SwiftUnittest_Names_Lowers.Extensions.request_id, - SwiftUnittest_Names_Uppers.Extensions.HTTP, - SwiftUnittest_Names_Uppers.Extensions.HTTP_request, - SwiftUnittest_Names_Uppers.Extensions.the_HTTP_request, - SwiftUnittest_Names_Uppers.Extensions.the_HTTP, - SwiftUnittest_Names_Uppers.Extensions.HTTPS, - SwiftUnittest_Names_Uppers.Extensions.HTTPS_request, - SwiftUnittest_Names_Uppers.Extensions.the_HTTPS_request, - SwiftUnittest_Names_Uppers.Extensions.the_HTTPS, - SwiftUnittest_Names_Uppers.Extensions.URL, - SwiftUnittest_Names_Uppers.Extensions.URL_value, - SwiftUnittest_Names_Uppers.Extensions.the_URL_value, - SwiftUnittest_Names_Uppers.Extensions.the_URL, - SwiftUnittest_Names_Uppers.Extensions.ID, - SwiftUnittest_Names_Uppers.Extensions.ID_number, - SwiftUnittest_Names_Uppers.Extensions.the_ID_number, - SwiftUnittest_Names_Uppers.Extensions.request_ID, - SwiftUnittest_Names_WordCase.Extensions.Http, - SwiftUnittest_Names_WordCase.Extensions.HttpRequest, - SwiftUnittest_Names_WordCase.Extensions.TheHttpRequest, - SwiftUnittest_Names_WordCase.Extensions.TheHttp, - SwiftUnittest_Names_WordCase.Extensions.Https, - SwiftUnittest_Names_WordCase.Extensions.HttpsRequest, - SwiftUnittest_Names_WordCase.Extensions.TheHttpsRequest, - SwiftUnittest_Names_WordCase.Extensions.TheHttps, - SwiftUnittest_Names_WordCase.Extensions.Url, - SwiftUnittest_Names_WordCase.Extensions.UrlValue, - SwiftUnittest_Names_WordCase.Extensions.TheUrlValue, - SwiftUnittest_Names_WordCase.Extensions.TheUrl, - SwiftUnittest_Names_WordCase.Extensions.Id, - SwiftUnittest_Names_WordCase.Extensions.IdNumber, - SwiftUnittest_Names_WordCase.Extensions.TheIdNumber, - SwiftUnittest_Names_WordCase.Extensions.RequestId +let SwiftProtoTesting_Names_UnittestSwiftNaming_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Names_Extensions_http, + SwiftProtoTesting_Names_Extensions_http_request, + SwiftProtoTesting_Names_Extensions_the_http_request, + SwiftProtoTesting_Names_Extensions_the_http, + SwiftProtoTesting_Names_Extensions_https, + SwiftProtoTesting_Names_Extensions_https_request, + SwiftProtoTesting_Names_Extensions_the_https_request, + SwiftProtoTesting_Names_Extensions_the_https, + SwiftProtoTesting_Names_Extensions_url, + SwiftProtoTesting_Names_Extensions_url_value, + SwiftProtoTesting_Names_Extensions_the_url_value, + SwiftProtoTesting_Names_Extensions_the_url, + SwiftProtoTesting_Names_Extensions_a_b_c, + SwiftProtoTesting_Names_Extensions_id, + SwiftProtoTesting_Names_Extensions_id_number, + SwiftProtoTesting_Names_Extensions_the_id_number, + SwiftProtoTesting_Names_Extensions_request_id, + SwiftProtoTesting_Names_Extensions_HTTP, + SwiftProtoTesting_Names_Extensions_HTTP_request, + SwiftProtoTesting_Names_Extensions_the_HTTP_request, + SwiftProtoTesting_Names_Extensions_the_HTTP, + SwiftProtoTesting_Names_Extensions_HTTPS, + SwiftProtoTesting_Names_Extensions_HTTPS_request, + SwiftProtoTesting_Names_Extensions_the_HTTPS_request, + SwiftProtoTesting_Names_Extensions_the_HTTPS, + SwiftProtoTesting_Names_Extensions_URL, + SwiftProtoTesting_Names_Extensions_URL_value, + SwiftProtoTesting_Names_Extensions_the_URL_value, + SwiftProtoTesting_Names_Extensions_the_URL, + SwiftProtoTesting_Names_Extensions_ID, + SwiftProtoTesting_Names_Extensions_ID_number, + SwiftProtoTesting_Names_Extensions_the_ID_number, + SwiftProtoTesting_Names_Extensions_request_ID, + SwiftProtoTesting_Names_Extensions_Http, + SwiftProtoTesting_Names_Extensions_HttpRequest, + SwiftProtoTesting_Names_Extensions_TheHttpRequest, + SwiftProtoTesting_Names_Extensions_TheHttp, + SwiftProtoTesting_Names_Extensions_Https, + SwiftProtoTesting_Names_Extensions_HttpsRequest, + SwiftProtoTesting_Names_Extensions_TheHttpsRequest, + SwiftProtoTesting_Names_Extensions_TheHttps, + SwiftProtoTesting_Names_Extensions_Url, + SwiftProtoTesting_Names_Extensions_UrlValue, + SwiftProtoTesting_Names_Extensions_TheUrlValue, + SwiftProtoTesting_Names_Extensions_TheUrl, + SwiftProtoTesting_Names_Extensions_Id, + SwiftProtoTesting_Names_Extensions_IdNumber, + SwiftProtoTesting_Names_Extensions_TheIdNumber, + SwiftProtoTesting_Names_Extensions_RequestId, + SwiftProtoTesting_Names_FieldNames.Extensions.foo1, + SwiftProtoTesting_Names_MessageNames.Extensions.foo2, + SwiftProtoTesting_Names_MessageNames.Extensions.foo4, + SwiftProtoTesting_Names_MessageNames.StringMessage.Extensions.foo3, + SwiftProtoTesting_Names_Lowers.Extensions.http, + SwiftProtoTesting_Names_Lowers.Extensions.http_request, + SwiftProtoTesting_Names_Lowers.Extensions.the_http_request, + SwiftProtoTesting_Names_Lowers.Extensions.the_http, + SwiftProtoTesting_Names_Lowers.Extensions.https, + SwiftProtoTesting_Names_Lowers.Extensions.https_request, + SwiftProtoTesting_Names_Lowers.Extensions.the_https_request, + SwiftProtoTesting_Names_Lowers.Extensions.the_https, + SwiftProtoTesting_Names_Lowers.Extensions.url, + SwiftProtoTesting_Names_Lowers.Extensions.url_value, + SwiftProtoTesting_Names_Lowers.Extensions.the_url_value, + SwiftProtoTesting_Names_Lowers.Extensions.the_url, + SwiftProtoTesting_Names_Lowers.Extensions.a_b_c, + SwiftProtoTesting_Names_Lowers.Extensions.id, + SwiftProtoTesting_Names_Lowers.Extensions.id_number, + SwiftProtoTesting_Names_Lowers.Extensions.the_id_number, + SwiftProtoTesting_Names_Lowers.Extensions.request_id, + SwiftProtoTesting_Names_Uppers.Extensions.HTTP, + SwiftProtoTesting_Names_Uppers.Extensions.HTTP_request, + SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP_request, + SwiftProtoTesting_Names_Uppers.Extensions.the_HTTP, + SwiftProtoTesting_Names_Uppers.Extensions.HTTPS, + SwiftProtoTesting_Names_Uppers.Extensions.HTTPS_request, + SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS_request, + SwiftProtoTesting_Names_Uppers.Extensions.the_HTTPS, + SwiftProtoTesting_Names_Uppers.Extensions.URL, + SwiftProtoTesting_Names_Uppers.Extensions.URL_value, + SwiftProtoTesting_Names_Uppers.Extensions.the_URL_value, + SwiftProtoTesting_Names_Uppers.Extensions.the_URL, + SwiftProtoTesting_Names_Uppers.Extensions.ID, + SwiftProtoTesting_Names_Uppers.Extensions.ID_number, + SwiftProtoTesting_Names_Uppers.Extensions.the_ID_number, + SwiftProtoTesting_Names_Uppers.Extensions.request_ID, + SwiftProtoTesting_Names_WordCase.Extensions.Http, + SwiftProtoTesting_Names_WordCase.Extensions.HttpRequest, + SwiftProtoTesting_Names_WordCase.Extensions.TheHttpRequest, + SwiftProtoTesting_Names_WordCase.Extensions.TheHttp, + SwiftProtoTesting_Names_WordCase.Extensions.Https, + SwiftProtoTesting_Names_WordCase.Extensions.HttpsRequest, + SwiftProtoTesting_Names_WordCase.Extensions.TheHttpsRequest, + SwiftProtoTesting_Names_WordCase.Extensions.TheHttps, + SwiftProtoTesting_Names_WordCase.Extensions.Url, + SwiftProtoTesting_Names_WordCase.Extensions.UrlValue, + SwiftProtoTesting_Names_WordCase.Extensions.TheUrlValue, + SwiftProtoTesting_Names_WordCase.Extensions.TheUrl, + SwiftProtoTesting_Names_WordCase.Extensions.Id, + SwiftProtoTesting_Names_WordCase.Extensions.IdNumber, + SwiftProtoTesting_Names_WordCase.Extensions.TheIdNumber, + SwiftProtoTesting_Names_WordCase.Extensions.RequestId ] // 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 SwiftUnittest_Names_Extensions_http = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_http = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 1, - fieldName: "swift_unittest.names.http" + fieldName: "swift_proto_testing.names.http" ) -let SwiftUnittest_Names_Extensions_http_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_http_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 2, - fieldName: "swift_unittest.names.http_request" + fieldName: "swift_proto_testing.names.http_request" ) -let SwiftUnittest_Names_Extensions_the_http_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_the_http_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 3, - fieldName: "swift_unittest.names.the_http_request" + fieldName: "swift_proto_testing.names.the_http_request" ) -let SwiftUnittest_Names_Extensions_the_http = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_the_http = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 4, - fieldName: "swift_unittest.names.the_http" + fieldName: "swift_proto_testing.names.the_http" ) -let SwiftUnittest_Names_Extensions_https = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_https = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 11, - fieldName: "swift_unittest.names.https" + fieldName: "swift_proto_testing.names.https" ) -let SwiftUnittest_Names_Extensions_https_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_https_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 12, - fieldName: "swift_unittest.names.https_request" + fieldName: "swift_proto_testing.names.https_request" ) -let SwiftUnittest_Names_Extensions_the_https_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_the_https_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 13, - fieldName: "swift_unittest.names.the_https_request" + fieldName: "swift_proto_testing.names.the_https_request" ) -let SwiftUnittest_Names_Extensions_the_https = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_the_https = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 14, - fieldName: "swift_unittest.names.the_https" + fieldName: "swift_proto_testing.names.the_https" ) -let SwiftUnittest_Names_Extensions_url = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_url = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 21, - fieldName: "swift_unittest.names.url" + fieldName: "swift_proto_testing.names.url" ) -let SwiftUnittest_Names_Extensions_url_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_url_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 22, - fieldName: "swift_unittest.names.url_value" + fieldName: "swift_proto_testing.names.url_value" ) -let SwiftUnittest_Names_Extensions_the_url_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_the_url_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 23, - fieldName: "swift_unittest.names.the_url_value" + fieldName: "swift_proto_testing.names.the_url_value" ) -let SwiftUnittest_Names_Extensions_the_url = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_the_url = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 24, - fieldName: "swift_unittest.names.the_url" + fieldName: "swift_proto_testing.names.the_url" ) -let SwiftUnittest_Names_Extensions_a_b_c = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_a_b_c = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 31, - fieldName: "swift_unittest.names.a_b_c" + fieldName: "swift_proto_testing.names.a_b_c" ) -let SwiftUnittest_Names_Extensions_id = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_id = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 41, - fieldName: "swift_unittest.names.id" + fieldName: "swift_proto_testing.names.id" ) -let SwiftUnittest_Names_Extensions_id_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_id_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 42, - fieldName: "swift_unittest.names.id_number" + fieldName: "swift_proto_testing.names.id_number" ) -let SwiftUnittest_Names_Extensions_the_id_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_the_id_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 43, - fieldName: "swift_unittest.names.the_id_number" + fieldName: "swift_proto_testing.names.the_id_number" ) -let SwiftUnittest_Names_Extensions_request_id = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let SwiftProtoTesting_Names_Extensions_request_id = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 44, - fieldName: "swift_unittest.names.request_id" + fieldName: "swift_proto_testing.names.request_id" ) -let SwiftUnittest_Names_Extensions_HTTP = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_HTTP = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 1, - fieldName: "swift_unittest.names.HTTP" + fieldName: "swift_proto_testing.names.HTTP" ) -let SwiftUnittest_Names_Extensions_HTTP_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_HTTP_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 2, - fieldName: "swift_unittest.names.HTTP_request" + fieldName: "swift_proto_testing.names.HTTP_request" ) -let SwiftUnittest_Names_Extensions_the_HTTP_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_the_HTTP_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 3, - fieldName: "swift_unittest.names.the_HTTP_request" + fieldName: "swift_proto_testing.names.the_HTTP_request" ) -let SwiftUnittest_Names_Extensions_the_HTTP = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_the_HTTP = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 4, - fieldName: "swift_unittest.names.the_HTTP" + fieldName: "swift_proto_testing.names.the_HTTP" ) -let SwiftUnittest_Names_Extensions_HTTPS = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_HTTPS = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 11, - fieldName: "swift_unittest.names.HTTPS" + fieldName: "swift_proto_testing.names.HTTPS" ) -let SwiftUnittest_Names_Extensions_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 12, - fieldName: "swift_unittest.names.HTTPS_request" + fieldName: "swift_proto_testing.names.HTTPS_request" ) -let SwiftUnittest_Names_Extensions_the_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_the_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 13, - fieldName: "swift_unittest.names.the_HTTPS_request" + fieldName: "swift_proto_testing.names.the_HTTPS_request" ) -let SwiftUnittest_Names_Extensions_the_HTTPS = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_the_HTTPS = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 14, - fieldName: "swift_unittest.names.the_HTTPS" + fieldName: "swift_proto_testing.names.the_HTTPS" ) -let SwiftUnittest_Names_Extensions_URL = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_URL = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 21, - fieldName: "swift_unittest.names.URL" + fieldName: "swift_proto_testing.names.URL" ) -let SwiftUnittest_Names_Extensions_URL_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_URL_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 22, - fieldName: "swift_unittest.names.URL_value" + fieldName: "swift_proto_testing.names.URL_value" ) -let SwiftUnittest_Names_Extensions_the_URL_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_the_URL_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 23, - fieldName: "swift_unittest.names.the_URL_value" + fieldName: "swift_proto_testing.names.the_URL_value" ) -let SwiftUnittest_Names_Extensions_the_URL = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_the_URL = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 24, - fieldName: "swift_unittest.names.the_URL" + fieldName: "swift_proto_testing.names.the_URL" ) -let SwiftUnittest_Names_Extensions_ID = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_ID = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 41, - fieldName: "swift_unittest.names.ID" + fieldName: "swift_proto_testing.names.ID" ) -let SwiftUnittest_Names_Extensions_ID_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_ID_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 42, - fieldName: "swift_unittest.names.ID_number" + fieldName: "swift_proto_testing.names.ID_number" ) -let SwiftUnittest_Names_Extensions_the_ID_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_the_ID_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 43, - fieldName: "swift_unittest.names.the_ID_number" + fieldName: "swift_proto_testing.names.the_ID_number" ) -let SwiftUnittest_Names_Extensions_request_ID = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let SwiftProtoTesting_Names_Extensions_request_ID = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 44, - fieldName: "swift_unittest.names.request_ID" + fieldName: "swift_proto_testing.names.request_ID" ) -let SwiftUnittest_Names_Extensions_Http = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_Http = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 1, - fieldName: "swift_unittest.names.Http" + fieldName: "swift_proto_testing.names.Http" ) -let SwiftUnittest_Names_Extensions_HttpRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_HttpRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 2, - fieldName: "swift_unittest.names.HttpRequest" + fieldName: "swift_proto_testing.names.HttpRequest" ) -let SwiftUnittest_Names_Extensions_TheHttpRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_TheHttpRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 3, - fieldName: "swift_unittest.names.TheHttpRequest" + fieldName: "swift_proto_testing.names.TheHttpRequest" ) -let SwiftUnittest_Names_Extensions_TheHttp = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_TheHttp = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 4, - fieldName: "swift_unittest.names.TheHttp" + fieldName: "swift_proto_testing.names.TheHttp" ) -let SwiftUnittest_Names_Extensions_Https = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_Https = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 11, - fieldName: "swift_unittest.names.Https" + fieldName: "swift_proto_testing.names.Https" ) -let SwiftUnittest_Names_Extensions_HttpsRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_HttpsRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 12, - fieldName: "swift_unittest.names.HttpsRequest" + fieldName: "swift_proto_testing.names.HttpsRequest" ) -let SwiftUnittest_Names_Extensions_TheHttpsRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_TheHttpsRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 13, - fieldName: "swift_unittest.names.TheHttpsRequest" + fieldName: "swift_proto_testing.names.TheHttpsRequest" ) -let SwiftUnittest_Names_Extensions_TheHttps = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_TheHttps = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 14, - fieldName: "swift_unittest.names.TheHttps" + fieldName: "swift_proto_testing.names.TheHttps" ) -let SwiftUnittest_Names_Extensions_Url = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_Url = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 21, - fieldName: "swift_unittest.names.Url" + fieldName: "swift_proto_testing.names.Url" ) -let SwiftUnittest_Names_Extensions_UrlValue = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_UrlValue = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 22, - fieldName: "swift_unittest.names.UrlValue" + fieldName: "swift_proto_testing.names.UrlValue" ) -let SwiftUnittest_Names_Extensions_TheUrlValue = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_TheUrlValue = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 23, - fieldName: "swift_unittest.names.TheUrlValue" + fieldName: "swift_proto_testing.names.TheUrlValue" ) -let SwiftUnittest_Names_Extensions_TheUrl = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_TheUrl = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 24, - fieldName: "swift_unittest.names.TheUrl" + fieldName: "swift_proto_testing.names.TheUrl" ) -let SwiftUnittest_Names_Extensions_Id = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_Id = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 41, - fieldName: "swift_unittest.names.Id" + fieldName: "swift_proto_testing.names.Id" ) -let SwiftUnittest_Names_Extensions_IdNumber = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_IdNumber = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 42, - fieldName: "swift_unittest.names.IdNumber" + fieldName: "swift_proto_testing.names.IdNumber" ) -let SwiftUnittest_Names_Extensions_TheIdNumber = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_TheIdNumber = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 43, - fieldName: "swift_unittest.names.TheIdNumber" + fieldName: "swift_proto_testing.names.TheIdNumber" ) -let SwiftUnittest_Names_Extensions_RequestId = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let SwiftProtoTesting_Names_Extensions_RequestId = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 44, - fieldName: "swift_unittest.names.RequestId" + fieldName: "swift_proto_testing.names.RequestId" ) -extension SwiftUnittest_Names_FieldNames { +extension SwiftProtoTesting_Names_FieldNames { enum Extensions { - static let foo1 = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_Foo>( + static let foo1 = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_Foo>( _protobuf_fieldNumber: 1, - fieldName: "swift_unittest.names.FieldNames.foo1" + fieldName: "swift_proto_testing.names.FieldNames.foo1" ) } } -extension SwiftUnittest_Names_MessageNames { +extension SwiftProtoTesting_Names_MessageNames { enum Extensions { - static let foo2 = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_Foo>( + static let foo2 = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_Foo>( _protobuf_fieldNumber: 2, - fieldName: "swift_unittest.names.MessageNames.foo2" + fieldName: "swift_proto_testing.names.MessageNames.foo2" ) - static let foo4 = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_Foo>( + static let foo4 = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_Foo>( _protobuf_fieldNumber: 4, - fieldName: "swift_unittest.names.MessageNames.foo4" + fieldName: "swift_proto_testing.names.MessageNames.foo4" ) } } -extension SwiftUnittest_Names_MessageNames.StringMessage { +extension SwiftProtoTesting_Names_MessageNames.StringMessage { enum Extensions { - static let foo3 = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_Foo>( + static let foo3 = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_Foo>( _protobuf_fieldNumber: 3, - fieldName: "swift_unittest.names.MessageNames.String.foo3" + fieldName: "swift_proto_testing.names.MessageNames.String.foo3" ) } } -extension SwiftUnittest_Names_Lowers { +extension SwiftProtoTesting_Names_Lowers { enum Extensions { - static let http = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let http = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 1, - fieldName: "swift_unittest.names.Lowers.http" + fieldName: "swift_proto_testing.names.Lowers.http" ) - static let http_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let http_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 2, - fieldName: "swift_unittest.names.Lowers.http_request" + fieldName: "swift_proto_testing.names.Lowers.http_request" ) - static let the_http_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_http_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 3, - fieldName: "swift_unittest.names.Lowers.the_http_request" + fieldName: "swift_proto_testing.names.Lowers.the_http_request" ) - static let the_http = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_http = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 4, - fieldName: "swift_unittest.names.Lowers.the_http" + fieldName: "swift_proto_testing.names.Lowers.the_http" ) - static let https = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let https = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 11, - fieldName: "swift_unittest.names.Lowers.https" + fieldName: "swift_proto_testing.names.Lowers.https" ) - static let https_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let https_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 12, - fieldName: "swift_unittest.names.Lowers.https_request" + fieldName: "swift_proto_testing.names.Lowers.https_request" ) - static let the_https_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_https_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 13, - fieldName: "swift_unittest.names.Lowers.the_https_request" + fieldName: "swift_proto_testing.names.Lowers.the_https_request" ) - static let the_https = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_https = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 14, - fieldName: "swift_unittest.names.Lowers.the_https" + fieldName: "swift_proto_testing.names.Lowers.the_https" ) - static let url = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let url = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 21, - fieldName: "swift_unittest.names.Lowers.url" + fieldName: "swift_proto_testing.names.Lowers.url" ) - static let url_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let url_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 22, - fieldName: "swift_unittest.names.Lowers.url_value" + fieldName: "swift_proto_testing.names.Lowers.url_value" ) - static let the_url_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_url_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 23, - fieldName: "swift_unittest.names.Lowers.the_url_value" + fieldName: "swift_proto_testing.names.Lowers.the_url_value" ) - static let the_url = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_url = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 24, - fieldName: "swift_unittest.names.Lowers.the_url" + fieldName: "swift_proto_testing.names.Lowers.the_url" ) - static let a_b_c = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let a_b_c = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 31, - fieldName: "swift_unittest.names.Lowers.a_b_c" + fieldName: "swift_proto_testing.names.Lowers.a_b_c" ) - static let id = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let id = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 41, - fieldName: "swift_unittest.names.Lowers.id" + fieldName: "swift_proto_testing.names.Lowers.id" ) - static let id_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let id_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 42, - fieldName: "swift_unittest.names.Lowers.id_number" + fieldName: "swift_proto_testing.names.Lowers.id_number" ) - static let the_id_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_id_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 43, - fieldName: "swift_unittest.names.Lowers.the_id_number" + fieldName: "swift_proto_testing.names.Lowers.the_id_number" ) - static let request_id = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let request_id = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 44, - fieldName: "swift_unittest.names.Lowers.request_id" + fieldName: "swift_proto_testing.names.Lowers.request_id" ) } } -extension SwiftUnittest_Names_Uppers { +extension SwiftProtoTesting_Names_Uppers { enum Extensions { - static let HTTP = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let HTTP = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 101, - fieldName: "swift_unittest.names.Uppers.HTTP" + fieldName: "swift_proto_testing.names.Uppers.HTTP" ) - static let HTTP_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let HTTP_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 102, - fieldName: "swift_unittest.names.Uppers.HTTP_request" + fieldName: "swift_proto_testing.names.Uppers.HTTP_request" ) - static let the_HTTP_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_HTTP_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 103, - fieldName: "swift_unittest.names.Uppers.the_HTTP_request" + fieldName: "swift_proto_testing.names.Uppers.the_HTTP_request" ) - static let the_HTTP = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_HTTP = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 104, - fieldName: "swift_unittest.names.Uppers.the_HTTP" + fieldName: "swift_proto_testing.names.Uppers.the_HTTP" ) - static let HTTPS = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let HTTPS = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 111, - fieldName: "swift_unittest.names.Uppers.HTTPS" + fieldName: "swift_proto_testing.names.Uppers.HTTPS" ) - static let HTTPS_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let HTTPS_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 112, - fieldName: "swift_unittest.names.Uppers.HTTPS_request" + fieldName: "swift_proto_testing.names.Uppers.HTTPS_request" ) - static let the_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 113, - fieldName: "swift_unittest.names.Uppers.the_HTTPS_request" + fieldName: "swift_proto_testing.names.Uppers.the_HTTPS_request" ) - static let the_HTTPS = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_HTTPS = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 114, - fieldName: "swift_unittest.names.Uppers.the_HTTPS" + fieldName: "swift_proto_testing.names.Uppers.the_HTTPS" ) - static let URL = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let URL = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 121, - fieldName: "swift_unittest.names.Uppers.URL" + fieldName: "swift_proto_testing.names.Uppers.URL" ) - static let URL_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let URL_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 122, - fieldName: "swift_unittest.names.Uppers.URL_value" + fieldName: "swift_proto_testing.names.Uppers.URL_value" ) - static let the_URL_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_URL_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 123, - fieldName: "swift_unittest.names.Uppers.the_URL_value" + fieldName: "swift_proto_testing.names.Uppers.the_URL_value" ) - static let the_URL = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_URL = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 124, - fieldName: "swift_unittest.names.Uppers.the_URL" + fieldName: "swift_proto_testing.names.Uppers.the_URL" ) - static let ID = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let ID = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 141, - fieldName: "swift_unittest.names.Uppers.ID" + fieldName: "swift_proto_testing.names.Uppers.ID" ) - static let ID_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let ID_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 142, - fieldName: "swift_unittest.names.Uppers.ID_number" + fieldName: "swift_proto_testing.names.Uppers.ID_number" ) - static let the_ID_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let the_ID_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 143, - fieldName: "swift_unittest.names.Uppers.the_ID_number" + fieldName: "swift_proto_testing.names.Uppers.the_ID_number" ) - static let request_ID = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let request_ID = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 144, - fieldName: "swift_unittest.names.Uppers.request_ID" + fieldName: "swift_proto_testing.names.Uppers.request_ID" ) } } -extension SwiftUnittest_Names_WordCase { +extension SwiftProtoTesting_Names_WordCase { enum Extensions { - static let Http = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let Http = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 201, - fieldName: "swift_unittest.names.WordCase.Http" + fieldName: "swift_proto_testing.names.WordCase.Http" ) - static let HttpRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let HttpRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 202, - fieldName: "swift_unittest.names.WordCase.HttpRequest" + fieldName: "swift_proto_testing.names.WordCase.HttpRequest" ) - static let TheHttpRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let TheHttpRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 203, - fieldName: "swift_unittest.names.WordCase.TheHttpRequest" + fieldName: "swift_proto_testing.names.WordCase.TheHttpRequest" ) - static let TheHttp = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let TheHttp = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 204, - fieldName: "swift_unittest.names.WordCase.TheHttp" + fieldName: "swift_proto_testing.names.WordCase.TheHttp" ) - static let Https = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let Https = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 211, - fieldName: "swift_unittest.names.WordCase.Https" + fieldName: "swift_proto_testing.names.WordCase.Https" ) - static let HttpsRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let HttpsRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 212, - fieldName: "swift_unittest.names.WordCase.HttpsRequest" + fieldName: "swift_proto_testing.names.WordCase.HttpsRequest" ) - static let TheHttpsRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let TheHttpsRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 213, - fieldName: "swift_unittest.names.WordCase.TheHttpsRequest" + fieldName: "swift_proto_testing.names.WordCase.TheHttpsRequest" ) - static let TheHttps = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let TheHttps = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 214, - fieldName: "swift_unittest.names.WordCase.TheHttps" + fieldName: "swift_proto_testing.names.WordCase.TheHttps" ) - static let Url = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let Url = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 221, - fieldName: "swift_unittest.names.WordCase.Url" + fieldName: "swift_proto_testing.names.WordCase.Url" ) - static let UrlValue = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let UrlValue = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 222, - fieldName: "swift_unittest.names.WordCase.UrlValue" + fieldName: "swift_proto_testing.names.WordCase.UrlValue" ) - static let TheUrlValue = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let TheUrlValue = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 223, - fieldName: "swift_unittest.names.WordCase.TheUrlValue" + fieldName: "swift_proto_testing.names.WordCase.TheUrlValue" ) - static let TheUrl = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let TheUrl = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 224, - fieldName: "swift_unittest.names.WordCase.TheUrl" + fieldName: "swift_proto_testing.names.WordCase.TheUrl" ) - static let Id = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let Id = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 241, - fieldName: "swift_unittest.names.WordCase.Id" + fieldName: "swift_proto_testing.names.WordCase.Id" ) - static let IdNumber = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let IdNumber = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 242, - fieldName: "swift_unittest.names.WordCase.IdNumber" + fieldName: "swift_proto_testing.names.WordCase.IdNumber" ) - static let TheIdNumber = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let TheIdNumber = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 243, - fieldName: "swift_unittest.names.WordCase.TheIdNumber" + fieldName: "swift_proto_testing.names.WordCase.TheIdNumber" ) - static let RequestId = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitials>( + static let RequestId = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitials>( _protobuf_fieldNumber: 244, - fieldName: "swift_unittest.names.WordCase.RequestId" + fieldName: "swift_proto_testing.names.WordCase.RequestId" ) } } // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "swift_unittest.names" - -extension SwiftUnittest_Names_EnumFieldNames: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "A"), - 1: .same(proto: "String"), - 2: .same(proto: "Int"), - 3: .same(proto: "Double"), - 4: .same(proto: "Float"), - 5: .same(proto: "UInt"), - 6: .same(proto: "hashValue"), - 7: .same(proto: "description"), - 8: .same(proto: "debugDescription"), - 9: .same(proto: "Swift"), - 10: .same(proto: "UNRECOGNIZED"), - 11: .same(proto: "class"), - 12: .same(proto: "deinit"), - 13: .same(proto: "enum"), - 14: .same(proto: "extension"), - 15: .same(proto: "func"), - 16: .same(proto: "import"), - 17: .same(proto: "init"), - 18: .same(proto: "inout"), - 19: .same(proto: "internal"), - 20: .same(proto: "let"), - 21: .same(proto: "operator"), - 22: .same(proto: "private"), - 23: .same(proto: "protocol"), - 24: .same(proto: "public"), - 25: .same(proto: "static"), - 26: .same(proto: "struct"), - 27: .same(proto: "subscript"), - 28: .same(proto: "typealias"), - 29: .same(proto: "var"), - 30: .same(proto: "break"), - 31: .same(proto: "case"), - 32: .same(proto: "continue"), - 33: .same(proto: "default"), - 34: .same(proto: "defer"), - 35: .same(proto: "do"), - 36: .same(proto: "else"), - 37: .same(proto: "fallthrough"), - 38: .same(proto: "for"), - 39: .same(proto: "guard"), - 40: .same(proto: "if"), - 41: .same(proto: "in"), - 42: .same(proto: "repeat"), - 43: .same(proto: "return"), - 44: .same(proto: "switch"), - 45: .same(proto: "where"), - 46: .same(proto: "while"), - 47: .same(proto: "as"), - 48: .same(proto: "catch"), - 49: .same(proto: "dynamicType"), - 50: .same(proto: "false"), - 51: .same(proto: "is"), - 52: .same(proto: "nil"), - 53: .same(proto: "rethrows"), - 54: .same(proto: "super"), - 55: .same(proto: "self"), - 57: .same(proto: "throw"), - 58: .same(proto: "throws"), - 59: .same(proto: "true"), - 60: .same(proto: "try"), - 61: .same(proto: "__COLUMN__"), - 62: .same(proto: "__FILE__"), - 63: .same(proto: "__FUNCTION__"), - 64: .same(proto: "__LINE__"), - 65: .same(proto: "_"), - 66: .same(proto: "associativity"), - 67: .same(proto: "convenience"), - 68: .same(proto: "dynamic"), - 69: .same(proto: "didSet"), - 70: .same(proto: "final"), - 71: .same(proto: "get"), - 72: .same(proto: "infix"), - 73: .same(proto: "indirect"), - 74: .same(proto: "lazy"), - 75: .same(proto: "left"), - 76: .same(proto: "mutating"), - 77: .same(proto: "none"), - 78: .same(proto: "nonmutating"), - 79: .same(proto: "optional"), - 80: .same(proto: "override"), - 81: .same(proto: "postfix"), - 82: .same(proto: "precedence"), - 83: .same(proto: "prefix"), - 85: .same(proto: "required"), - 86: .same(proto: "right"), - 87: .same(proto: "set"), - 88: .same(proto: "Type"), - 89: .same(proto: "unowned"), - 90: .same(proto: "weak"), - 91: .same(proto: "willSet"), - 93: .same(proto: "_cmd"), - 96: .same(proto: "out"), - 98: .same(proto: "bycopy"), - 99: .same(proto: "byref"), - 100: .same(proto: "oneway"), - 102: .same(proto: "and"), - 103: .same(proto: "and_eq"), - 104: .same(proto: "alignas"), - 105: .same(proto: "alignof"), - 106: .same(proto: "asm"), - 107: .same(proto: "auto"), - 108: .same(proto: "bitand"), - 109: .same(proto: "bitor"), - 110: .same(proto: "bool"), - 114: .same(proto: "char"), - 115: .same(proto: "char16_t"), - 116: .same(proto: "char32_t"), - 118: .same(proto: "compl"), - 119: .same(proto: "const"), - 120: .same(proto: "constexpr"), - 121: .same(proto: "const_cast"), - 123: .same(proto: "decltype"), - 125: .same(proto: "delete"), - 127: .same(proto: "dynamic_cast"), - 130: .same(proto: "explicit"), - 131: .same(proto: "export"), - 132: .same(proto: "extern"), - 136: .same(proto: "friend"), - 137: .same(proto: "goto"), - 139: .same(proto: "inline"), - 141: .same(proto: "long"), - 142: .same(proto: "mutable"), - 143: .same(proto: "namespace"), - 144: .same(proto: "new"), - 145: .same(proto: "noexcept"), - 146: .same(proto: "not"), - 147: .same(proto: "not_eq"), - 148: .same(proto: "nullptr"), - 150: .same(proto: "or"), - 151: .same(proto: "or_eq"), - 153: .same(proto: "protected"), - 155: .same(proto: "register"), - 156: .same(proto: "reinterpret_cast"), - 158: .same(proto: "short"), - 159: .same(proto: "signed"), - 160: .same(proto: "sizeof"), - 162: .same(proto: "static_assert"), - 163: .same(proto: "static_cast"), - 166: .same(proto: "template"), - 167: .same(proto: "this"), - 168: .same(proto: "thread_local"), - 172: .same(proto: "typedef"), - 173: .same(proto: "typeid"), - 174: .same(proto: "typename"), - 175: .same(proto: "union"), - 176: .same(proto: "unsigned"), - 177: .same(proto: "using"), - 178: .same(proto: "virtual"), - 179: .same(proto: "void"), - 180: .same(proto: "volatile"), - 181: .same(proto: "wchar_t"), - 183: .same(proto: "xor"), - 184: .same(proto: "xor_eq"), - 185: .same(proto: "restrict"), - 186: .same(proto: "Category"), - 187: .same(proto: "Ivar"), - 188: .same(proto: "Method"), - 192: .same(proto: "finalize"), - 193: .same(proto: "hash"), - 194: .same(proto: "dealloc"), - 197: .same(proto: "superclass"), - 198: .same(proto: "retain"), - 199: .same(proto: "release"), - 200: .same(proto: "autorelease"), - 201: .same(proto: "retainCount"), - 202: .same(proto: "zone"), - 203: .same(proto: "isProxy"), - 204: .same(proto: "copy"), - 205: .same(proto: "mutableCopy"), - 206: .same(proto: "classForCoder"), - 207: .same(proto: "clear"), - 208: .same(proto: "data"), - 209: .same(proto: "delimitedData"), - 210: .same(proto: "descriptor"), - 211: .same(proto: "extensionRegistry"), - 212: .same(proto: "extensionsCurrentlySet"), - 213: .same(proto: "isInitialized"), - 214: .same(proto: "serializedSize"), - 215: .same(proto: "sortedExtensionsInUse"), - 216: .same(proto: "unknownFields"), - 217: .same(proto: "Fixed"), - 218: .same(proto: "Fract"), - 219: .same(proto: "Size"), - 220: .same(proto: "LogicalAddress"), - 221: .same(proto: "PhysicalAddress"), - 222: .same(proto: "ByteCount"), - 223: .same(proto: "ByteOffset"), - 224: .same(proto: "Duration"), - 225: .same(proto: "AbsoluteTime"), - 226: .same(proto: "OptionBits"), - 227: .same(proto: "ItemCount"), - 228: .same(proto: "PBVersion"), - 229: .same(proto: "ScriptCode"), - 230: .same(proto: "LangCode"), - 231: .same(proto: "RegionCode"), - 232: .same(proto: "OSType"), - 233: .same(proto: "ProcessSerialNumber"), - 234: .same(proto: "Point"), - 235: .same(proto: "Rect"), - 236: .same(proto: "FixedPoint"), - 237: .same(proto: "FixedRect"), - 238: .same(proto: "Style"), - 239: .same(proto: "StyleParameter"), - 240: .same(proto: "StyleField"), - 241: .same(proto: "TimeScale"), - 242: .same(proto: "TimeBase"), - 243: .same(proto: "TimeRecord"), - 244: .same(proto: "Extensions"), - ] -} - -extension SwiftUnittest_Names_EnumFieldNames2: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "AA"), - 1065: .same(proto: "__"), - ] -} - -extension SwiftUnittest_Names_Foo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +fileprivate let _protobuf_package = "swift_proto_testing.names" + +extension SwiftProtoTesting_Names_EnumFieldNames: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0A\0\u{1}String\0\u{1}Int\0\u{1}Double\0\u{1}Float\0\u{1}UInt\0\u{1}hashValue\0\u{1}description\0\u{1}debugDescription\0\u{1}Swift\0\u{1}UNRECOGNIZED\0\u{1}class\0\u{1}deinit\0\u{1}enum\0\u{1}extension\0\u{1}func\0\u{1}import\0\u{1}init\0\u{1}inout\0\u{1}internal\0\u{1}let\0\u{1}operator\0\u{1}private\0\u{1}protocol\0\u{1}public\0\u{1}static\0\u{1}struct\0\u{1}subscript\0\u{1}typealias\0\u{1}var\0\u{1}break\0\u{1}case\0\u{1}continue\0\u{1}default\0\u{1}defer\0\u{1}do\0\u{1}else\0\u{1}fallthrough\0\u{1}for\0\u{1}guard\0\u{1}if\0\u{1}in\0\u{1}repeat\0\u{1}return\0\u{1}switch\0\u{1}where\0\u{1}while\0\u{1}as\0\u{1}catch\0\u{1}dynamicType\0\u{1}false\0\u{1}is\0\u{1}nil\0\u{1}rethrows\0\u{1}super\0\u{1}self\0\u{2}\u{2}throw\0\u{1}throws\0\u{1}true\0\u{1}try\0\u{1}__COLUMN__\0\u{1}__FILE__\0\u{1}__FUNCTION__\0\u{1}__LINE__\0\u{1}_\0\u{1}associativity\0\u{1}convenience\0\u{1}dynamic\0\u{1}didSet\0\u{1}final\0\u{1}get\0\u{1}infix\0\u{1}indirect\0\u{1}lazy\0\u{1}left\0\u{1}mutating\0\u{1}none\0\u{1}nonmutating\0\u{1}optional\0\u{1}override\0\u{1}postfix\0\u{1}precedence\0\u{1}prefix\0\u{2}\u{2}required\0\u{1}right\0\u{1}set\0\u{1}Type\0\u{1}unowned\0\u{1}weak\0\u{1}willSet\0\u{2}\u{2}_cmd\0\u{2}\u{3}out\0\u{2}\u{2}bycopy\0\u{1}byref\0\u{1}oneway\0\u{2}\u{2}and\0\u{1}and_eq\0\u{1}alignas\0\u{1}alignof\0\u{1}asm\0\u{1}auto\0\u{1}bitand\0\u{1}bitor\0\u{1}bool\0\u{2}\u{4}char\0\u{1}char16_t\0\u{1}char32_t\0\u{2}\u{2}compl\0\u{1}const\0\u{1}constexpr\0\u{1}const_cast\0\u{2}\u{2}decltype\0\u{2}\u{2}delete\0\u{2}\u{2}dynamic_cast\0\u{2}\u{3}explicit\0\u{1}export\0\u{1}extern\0\u{2}\u{4}friend\0\u{1}goto\0\u{2}\u{2}inline\0\u{2}\u{2}long\0\u{1}mutable\0\u{1}namespace\0\u{1}new\0\u{1}noexcept\0\u{1}not\0\u{1}not_eq\0\u{1}nullptr\0\u{2}\u{2}or\0\u{1}or_eq\0\u{2}\u{2}protected\0\u{2}\u{2}register\0\u{1}reinterpret_cast\0\u{2}\u{2}short\0\u{1}signed\0\u{1}sizeof\0\u{2}\u{2}static_assert\0\u{1}static_cast\0\u{2}\u{3}template\0\u{1}this\0\u{1}thread_local\0\u{2}\u{4}typedef\0\u{1}typeid\0\u{1}typename\0\u{1}union\0\u{1}unsigned\0\u{1}using\0\u{1}virtual\0\u{1}void\0\u{1}volatile\0\u{1}wchar_t\0\u{2}\u{2}xor\0\u{1}xor_eq\0\u{1}restrict\0\u{1}Category\0\u{1}Ivar\0\u{1}Method\0\u{2}\u{4}finalize\0\u{1}hash\0\u{1}dealloc\0\u{2}\u{3}superclass\0\u{1}retain\0\u{1}release\0\u{1}autorelease\0\u{1}retainCount\0\u{1}zone\0\u{1}isProxy\0\u{1}copy\0\u{1}mutableCopy\0\u{1}classForCoder\0\u{1}clear\0\u{1}data\0\u{1}delimitedData\0\u{1}descriptor\0\u{1}extensionRegistry\0\u{1}extensionsCurrentlySet\0\u{1}isInitialized\0\u{1}serializedSize\0\u{1}sortedExtensionsInUse\0\u{1}unknownFields\0\u{1}Fixed\0\u{1}Fract\0\u{1}Size\0\u{1}LogicalAddress\0\u{1}PhysicalAddress\0\u{1}ByteCount\0\u{1}ByteOffset\0\u{1}Duration\0\u{1}AbsoluteTime\0\u{1}OptionBits\0\u{1}ItemCount\0\u{1}PBVersion\0\u{1}ScriptCode\0\u{1}LangCode\0\u{1}RegionCode\0\u{1}OSType\0\u{1}ProcessSerialNumber\0\u{1}Point\0\u{1}Rect\0\u{1}FixedPoint\0\u{1}FixedRect\0\u{1}Style\0\u{1}StyleParameter\0\u{1}StyleField\0\u{1}TimeScale\0\u{1}TimeBase\0\u{1}TimeRecord\0\u{1}Extensions\0") +} + +extension SwiftProtoTesting_Names_EnumFieldNames2: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0AA\0\u{2}i\u{10}__\0") +} + +extension SwiftProtoTesting_Names_Foo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Foo" static let _protobuf_nameMap = SwiftProtobuf._NameMap() @@ -16748,7 +11748,7 @@ extension SwiftUnittest_Names_Foo: SwiftProtobuf.Message, SwiftProtobuf._Message mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { if (1 <= fieldNumber && fieldNumber < 5001) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftUnittest_Names_Foo.self, fieldNumber: fieldNumber) + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Names_Foo.self, fieldNumber: fieldNumber) } } } @@ -16758,239 +11758,16 @@ extension SwiftUnittest_Names_Foo: SwiftProtobuf.Message, SwiftProtobuf._Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_Foo, rhs: SwiftUnittest_Names_Foo) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_Foo, rhs: SwiftProtoTesting_Names_Foo) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension SwiftUnittest_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".FieldNames" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "String"), - 2: .same(proto: "Int"), - 3: .same(proto: "Double"), - 4: .same(proto: "Float"), - 5: .same(proto: "UInt"), - 6: .same(proto: "hashValue"), - 7: .same(proto: "description"), - 8: .same(proto: "debugDescription"), - 9: .same(proto: "Swift"), - 10: .same(proto: "UNRECOGNIZED"), - 11: .same(proto: "class"), - 12: .same(proto: "deinit"), - 13: .same(proto: "enum"), - 15: .same(proto: "func"), - 16: .same(proto: "import"), - 17: .same(proto: "init"), - 18: .same(proto: "inout"), - 19: .same(proto: "internal"), - 20: .same(proto: "let"), - 21: .same(proto: "operator"), - 22: .same(proto: "private"), - 23: .same(proto: "protocol"), - 24: .same(proto: "public"), - 25: .same(proto: "static"), - 26: .same(proto: "struct"), - 27: .same(proto: "subscript"), - 28: .same(proto: "typealias"), - 29: .same(proto: "var"), - 30: .same(proto: "break"), - 31: .same(proto: "case"), - 32: .same(proto: "continue"), - 33: .same(proto: "default"), - 34: .same(proto: "defer"), - 35: .same(proto: "do"), - 36: .same(proto: "else"), - 37: .same(proto: "fallthrough"), - 38: .same(proto: "for"), - 39: .same(proto: "guard"), - 40: .same(proto: "if"), - 41: .same(proto: "in"), - 42: .same(proto: "repeat"), - 43: .same(proto: "return"), - 44: .same(proto: "switch"), - 45: .same(proto: "where"), - 46: .same(proto: "while"), - 47: .same(proto: "as"), - 48: .same(proto: "catch"), - 49: .same(proto: "dynamicType"), - 50: .same(proto: "false"), - 51: .same(proto: "is"), - 52: .same(proto: "nil"), - 53: .same(proto: "rethrows"), - 54: .same(proto: "super"), - 55: .same(proto: "self"), - 57: .same(proto: "throw"), - 58: .same(proto: "throws"), - 59: .same(proto: "true"), - 60: .same(proto: "try"), - 61: .standard(proto: "__COLUMN__"), - 62: .standard(proto: "__FILE__"), - 63: .standard(proto: "__FUNCTION__"), - 64: .standard(proto: "__LINE__"), - 65: .standard(proto: "_"), - 66: .same(proto: "associativity"), - 67: .same(proto: "convenience"), - 68: .same(proto: "dynamic"), - 69: .same(proto: "didSet"), - 70: .same(proto: "final"), - 71: .same(proto: "get"), - 72: .same(proto: "infix"), - 73: .same(proto: "indirect"), - 74: .same(proto: "lazy"), - 75: .same(proto: "left"), - 76: .same(proto: "mutating"), - 77: .same(proto: "none"), - 78: .same(proto: "nonmutating"), - 79: .same(proto: "optional"), - 80: .same(proto: "override"), - 81: .same(proto: "postfix"), - 82: .same(proto: "precedence"), - 83: .same(proto: "prefix"), - 85: .same(proto: "required"), - 86: .same(proto: "right"), - 87: .same(proto: "set"), - 88: .same(proto: "Type"), - 89: .same(proto: "unowned"), - 90: .same(proto: "weak"), - 91: .same(proto: "willSet"), - 92: .same(proto: "id"), - 93: .standard(proto: "_cmd"), - 96: .same(proto: "out"), - 98: .same(proto: "bycopy"), - 99: .same(proto: "byref"), - 100: .same(proto: "oneway"), - 102: .same(proto: "and"), - 103: .standard(proto: "and_eq"), - 104: .same(proto: "alignas"), - 105: .same(proto: "alignof"), - 106: .same(proto: "asm"), - 107: .same(proto: "auto"), - 108: .same(proto: "bitand"), - 109: .same(proto: "bitor"), - 110: .same(proto: "bool"), - 114: .same(proto: "char"), - 115: .standard(proto: "char16_t"), - 116: .standard(proto: "char32_t"), - 118: .same(proto: "compl"), - 119: .same(proto: "const"), - 120: .same(proto: "constexpr"), - 121: .standard(proto: "const_cast"), - 123: .same(proto: "decltype"), - 125: .same(proto: "delete"), - 127: .standard(proto: "dynamic_cast"), - 130: .same(proto: "explicit"), - 131: .same(proto: "export"), - 132: .same(proto: "extern"), - 136: .same(proto: "friend"), - 137: .same(proto: "goto"), - 139: .same(proto: "inline"), - 141: .same(proto: "long"), - 142: .same(proto: "mutable"), - 143: .same(proto: "namespace"), - 144: .same(proto: "new"), - 145: .same(proto: "noexcept"), - 146: .same(proto: "not"), - 147: .standard(proto: "not_eq"), - 148: .same(proto: "nullptr"), - 150: .same(proto: "or"), - 151: .standard(proto: "or_eq"), - 153: .same(proto: "protected"), - 155: .same(proto: "register"), - 156: .standard(proto: "reinterpret_cast"), - 158: .same(proto: "short"), - 159: .same(proto: "signed"), - 160: .same(proto: "sizeof"), - 162: .standard(proto: "static_assert"), - 163: .standard(proto: "static_cast"), - 166: .same(proto: "template"), - 167: .same(proto: "this"), - 168: .standard(proto: "thread_local"), - 172: .same(proto: "typedef"), - 173: .same(proto: "typeid"), - 174: .same(proto: "typename"), - 175: .same(proto: "union"), - 176: .same(proto: "unsigned"), - 177: .same(proto: "using"), - 178: .same(proto: "virtual"), - 179: .same(proto: "void"), - 180: .same(proto: "volatile"), - 181: .standard(proto: "wchar_t"), - 183: .same(proto: "xor"), - 184: .standard(proto: "xor_eq"), - 185: .same(proto: "restrict"), - 186: .same(proto: "Category"), - 187: .same(proto: "Ivar"), - 188: .same(proto: "Method"), - 192: .same(proto: "finalize"), - 193: .same(proto: "hash"), - 194: .same(proto: "dealloc"), - 197: .same(proto: "superclass"), - 198: .same(proto: "retain"), - 199: .same(proto: "release"), - 200: .same(proto: "autorelease"), - 201: .same(proto: "retainCount"), - 202: .same(proto: "zone"), - 203: .same(proto: "isProxy"), - 204: .same(proto: "copy"), - 205: .same(proto: "mutableCopy"), - 206: .same(proto: "classForCoder"), - 207: .same(proto: "clear"), - 208: .same(proto: "data"), - 209: .same(proto: "delimitedData"), - 210: .same(proto: "descriptor"), - 211: .same(proto: "extensionRegistry"), - 212: .same(proto: "extensionsCurrentlySet"), - 213: .same(proto: "isInitialized"), - 214: .same(proto: "serializedSize"), - 215: .same(proto: "sortedExtensionsInUse"), - 216: .same(proto: "unknownFields"), - 217: .same(proto: "Fixed"), - 218: .same(proto: "Fract"), - 219: .same(proto: "Size"), - 220: .same(proto: "LogicalAddress"), - 221: .same(proto: "PhysicalAddress"), - 222: .same(proto: "ByteCount"), - 223: .same(proto: "ByteOffset"), - 224: .same(proto: "Duration"), - 225: .same(proto: "AbsoluteTime"), - 226: .same(proto: "OptionBits"), - 227: .same(proto: "ItemCount"), - 228: .same(proto: "PBVersion"), - 229: .same(proto: "ScriptCode"), - 230: .same(proto: "LangCode"), - 231: .same(proto: "RegionCode"), - 232: .same(proto: "OSType"), - 233: .same(proto: "ProcessSerialNumber"), - 234: .same(proto: "Point"), - 235: .same(proto: "Rect"), - 236: .same(proto: "FixedPoint"), - 237: .same(proto: "FixedRect"), - 238: .same(proto: "Style"), - 239: .same(proto: "StyleParameter"), - 240: .same(proto: "StyleField"), - 241: .same(proto: "TimeScale"), - 242: .same(proto: "TimeBase"), - 243: .same(proto: "TimeRecord"), - 244: .unique(proto: "json_should_be_overriden", json: "json_was_overridden"), - 245: .same(proto: "Any"), - 246: .same(proto: "Int32"), - 247: .same(proto: "Int64"), - 250: .same(proto: "UInt32"), - 251: .same(proto: "UInt64"), - 252: .same(proto: "associatedtype"), - 253: .same(proto: "fileprivate"), - 254: .same(proto: "open"), - 255: .same(proto: "serializedData"), - 256: .same(proto: "hasSerializedData"), - 257: .same(proto: "clearSerializedData"), - 258: .same(proto: "jsonUTF8Data"), - 259: .same(proto: "jsonString"), - 260: .same(proto: "Extension"), - 261: .same(proto: "Extensions"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}String\0\u{1}Int\0\u{1}Double\0\u{1}Float\0\u{1}UInt\0\u{1}hashValue\0\u{1}description\0\u{1}debugDescription\0\u{1}Swift\0\u{1}UNRECOGNIZED\0\u{1}class\0\u{1}deinit\0\u{1}enum\0\u{2}\u{2}func\0\u{1}import\0\u{1}init\0\u{1}inout\0\u{1}internal\0\u{1}let\0\u{1}operator\0\u{1}private\0\u{1}protocol\0\u{1}public\0\u{1}static\0\u{1}struct\0\u{1}subscript\0\u{1}typealias\0\u{1}var\0\u{1}break\0\u{1}case\0\u{1}continue\0\u{1}default\0\u{1}defer\0\u{1}do\0\u{1}else\0\u{1}fallthrough\0\u{1}for\0\u{1}guard\0\u{1}if\0\u{1}in\0\u{1}repeat\0\u{1}return\0\u{1}switch\0\u{1}where\0\u{1}while\0\u{1}as\0\u{1}catch\0\u{1}dynamicType\0\u{1}false\0\u{1}is\0\u{1}nil\0\u{1}rethrows\0\u{1}super\0\u{1}self\0\u{2}\u{2}throw\0\u{1}throws\0\u{1}true\0\u{1}try\0\u{3}__COLUMN__\0\u{3}__FILE__\0\u{3}__FUNCTION__\0\u{3}__LINE__\0\u{3}_\0\u{1}associativity\0\u{1}convenience\0\u{1}dynamic\0\u{1}didSet\0\u{1}final\0\u{1}get\0\u{1}infix\0\u{1}indirect\0\u{1}lazy\0\u{1}left\0\u{1}mutating\0\u{1}none\0\u{1}nonmutating\0\u{1}optional\0\u{1}override\0\u{1}postfix\0\u{1}precedence\0\u{1}prefix\0\u{2}\u{2}required\0\u{1}right\0\u{1}set\0\u{1}Type\0\u{1}unowned\0\u{1}weak\0\u{1}willSet\0\u{1}id\0\u{3}_cmd\0\u{2}\u{3}out\0\u{2}\u{2}bycopy\0\u{1}byref\0\u{1}oneway\0\u{2}\u{2}and\0\u{3}and_eq\0\u{1}alignas\0\u{1}alignof\0\u{1}asm\0\u{1}auto\0\u{1}bitand\0\u{1}bitor\0\u{1}bool\0\u{2}\u{4}char\0\u{3}char16_t\0\u{3}char32_t\0\u{2}\u{2}compl\0\u{1}const\0\u{1}constexpr\0\u{3}const_cast\0\u{2}\u{2}decltype\0\u{2}\u{2}delete\0\u{4}\u{2}dynamic_cast\0\u{2}\u{3}explicit\0\u{1}export\0\u{1}extern\0\u{2}\u{4}friend\0\u{1}goto\0\u{2}\u{2}inline\0\u{2}\u{2}long\0\u{1}mutable\0\u{1}namespace\0\u{1}new\0\u{1}noexcept\0\u{1}not\0\u{3}not_eq\0\u{1}nullptr\0\u{2}\u{2}or\0\u{3}or_eq\0\u{2}\u{2}protected\0\u{2}\u{2}register\0\u{3}reinterpret_cast\0\u{2}\u{2}short\0\u{1}signed\0\u{1}sizeof\0\u{4}\u{2}static_assert\0\u{3}static_cast\0\u{2}\u{3}template\0\u{1}this\0\u{3}thread_local\0\u{2}\u{4}typedef\0\u{1}typeid\0\u{1}typename\0\u{1}union\0\u{1}unsigned\0\u{1}using\0\u{1}virtual\0\u{1}void\0\u{1}volatile\0\u{3}wchar_t\0\u{2}\u{2}xor\0\u{3}xor_eq\0\u{1}restrict\0\u{1}Category\0\u{1}Ivar\0\u{1}Method\0\u{2}\u{4}finalize\0\u{1}hash\0\u{1}dealloc\0\u{2}\u{3}superclass\0\u{1}retain\0\u{1}release\0\u{1}autorelease\0\u{1}retainCount\0\u{1}zone\0\u{1}isProxy\0\u{1}copy\0\u{1}mutableCopy\0\u{1}classForCoder\0\u{1}clear\0\u{1}data\0\u{1}delimitedData\0\u{1}descriptor\0\u{1}extensionRegistry\0\u{1}extensionsCurrentlySet\0\u{1}isInitialized\0\u{1}serializedSize\0\u{1}sortedExtensionsInUse\0\u{1}unknownFields\0\u{1}Fixed\0\u{1}Fract\0\u{1}Size\0\u{1}LogicalAddress\0\u{1}PhysicalAddress\0\u{1}ByteCount\0\u{1}ByteOffset\0\u{1}Duration\0\u{1}AbsoluteTime\0\u{1}OptionBits\0\u{1}ItemCount\0\u{1}PBVersion\0\u{1}ScriptCode\0\u{1}LangCode\0\u{1}RegionCode\0\u{1}OSType\0\u{1}ProcessSerialNumber\0\u{1}Point\0\u{1}Rect\0\u{1}FixedPoint\0\u{1}FixedRect\0\u{1}Style\0\u{1}StyleParameter\0\u{1}StyleField\0\u{1}TimeScale\0\u{1}TimeBase\0\u{1}TimeRecord\0\u{5}json_should_be_overridden\0json_was_overridden\0\u{1}Any\0\u{1}Int32\0\u{1}Int64\0\u{2}\u{3}UInt32\0\u{1}UInt64\0\u{1}associatedtype\0\u{1}fileprivate\0\u{1}open\0\u{1}serializedData\0\u{1}hasSerializedData\0\u{1}clearSerializedData\0\u{1}jsonUTF8Data\0\u{1}jsonString\0\u{1}Extension\0\u{1}Extensions\0") fileprivate class _StorageClass { var _string: Int32? = nil @@ -17199,7 +11976,7 @@ extension SwiftUnittest_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._ var _timeScale: Int32? = nil var _timeBase: Int32? = nil var _timeRecord: Int32? = nil - var _jsonShouldBeOverriden: Int32? = nil + var _jsonShouldBeOverridden: Int32? = nil var _any: Int32? = nil var _int32: Int32? = nil var _int64: Int32? = nil @@ -17216,7 +11993,11 @@ extension SwiftUnittest_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._ var _extension: Int32? = nil var _extensions: Int32? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -17427,7 +12208,7 @@ extension SwiftUnittest_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._ _timeScale = source._timeScale _timeBase = source._timeBase _timeRecord = source._timeRecord - _jsonShouldBeOverriden = source._jsonShouldBeOverriden + _jsonShouldBeOverridden = source._jsonShouldBeOverridden _any = source._any _int32 = source._int32 _int64 = source._int64 @@ -17667,7 +12448,7 @@ extension SwiftUnittest_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._ case 241: try { try decoder.decodeSingularInt32Field(value: &_storage._timeScale) }() case 242: try { try decoder.decodeSingularInt32Field(value: &_storage._timeBase) }() case 243: try { try decoder.decodeSingularInt32Field(value: &_storage._timeRecord) }() - case 244: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonShouldBeOverriden) }() + case 244: try { try decoder.decodeSingularInt32Field(value: &_storage._jsonShouldBeOverridden) }() case 245: try { try decoder.decodeSingularInt32Field(value: &_storage._any) }() case 246: try { try decoder.decodeSingularInt32Field(value: &_storage._int32) }() case 247: try { try decoder.decodeSingularInt32Field(value: &_storage._int64) }() @@ -18313,7 +13094,7 @@ extension SwiftUnittest_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._ try { if let v = _storage._timeRecord { try visitor.visitSingularInt32Field(value: v, fieldNumber: 243) } }() - try { if let v = _storage._jsonShouldBeOverriden { + try { if let v = _storage._jsonShouldBeOverridden { try visitor.visitSingularInt32Field(value: v, fieldNumber: 244) } }() try { if let v = _storage._any { @@ -18365,7 +13146,7 @@ extension SwiftUnittest_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._ try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_FieldNames, rhs: SwiftUnittest_Names_FieldNames) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_FieldNames, rhs: SwiftProtoTesting_Names_FieldNames) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -18576,7 +13357,7 @@ extension SwiftUnittest_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._ if _storage._timeScale != rhs_storage._timeScale {return false} if _storage._timeBase != rhs_storage._timeBase {return false} if _storage._timeRecord != rhs_storage._timeRecord {return false} - if _storage._jsonShouldBeOverriden != rhs_storage._jsonShouldBeOverriden {return false} + if _storage._jsonShouldBeOverridden != rhs_storage._jsonShouldBeOverridden {return false} if _storage._any != rhs_storage._any {return false} if _storage._int32 != rhs_storage._int32 {return false} if _storage._int64 != rhs_storage._int64 {return false} @@ -18601,30 +13382,28 @@ extension SwiftUnittest_Names_FieldNames: SwiftProtobuf.Message, SwiftProtobuf._ } } -extension SwiftUnittest_Names_MessageNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_MessageNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MessageNames" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames, rhs: SwiftUnittest_Names_MessageNames) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames, rhs: SwiftProtoTesting_Names_MessageNames) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.StringMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".String" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "String"), - ] +extension SwiftProtoTesting_Names_MessageNames.StringMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".String" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}String\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18649,18 +13428,16 @@ extension SwiftUnittest_Names_MessageNames.StringMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.StringMessage, rhs: SwiftUnittest_Names_MessageNames.StringMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.StringMessage, rhs: SwiftProtoTesting_Names_MessageNames.StringMessage) -> Bool { if lhs._string != rhs._string {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.ProtocolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Protocol" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Protocol"), - ] +extension SwiftProtoTesting_Names_MessageNames.ProtocolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Protocol" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Protocol\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18685,18 +13462,16 @@ extension SwiftUnittest_Names_MessageNames.ProtocolMessage: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.ProtocolMessage, rhs: SwiftUnittest_Names_MessageNames.ProtocolMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ProtocolMessage, rhs: SwiftProtoTesting_Names_MessageNames.ProtocolMessage) -> Bool { if lhs._protocol != rhs._protocol {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.IntMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Int" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Int"), - ] +extension SwiftProtoTesting_Names_MessageNames.IntMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Int" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Int\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18721,18 +13496,16 @@ extension SwiftUnittest_Names_MessageNames.IntMessage: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.IntMessage, rhs: SwiftUnittest_Names_MessageNames.IntMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.IntMessage, rhs: SwiftProtoTesting_Names_MessageNames.IntMessage) -> Bool { if lhs._int != rhs._int {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.DoubleMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Double" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Double"), - ] +extension SwiftProtoTesting_Names_MessageNames.DoubleMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Double" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Double\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18757,18 +13530,16 @@ extension SwiftUnittest_Names_MessageNames.DoubleMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.DoubleMessage, rhs: SwiftUnittest_Names_MessageNames.DoubleMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.DoubleMessage, rhs: SwiftProtoTesting_Names_MessageNames.DoubleMessage) -> Bool { if lhs._double != rhs._double {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.FloatMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Float" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Float"), - ] +extension SwiftProtoTesting_Names_MessageNames.FloatMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Float" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Float\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18793,18 +13564,16 @@ extension SwiftUnittest_Names_MessageNames.FloatMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.FloatMessage, rhs: SwiftUnittest_Names_MessageNames.FloatMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.FloatMessage, rhs: SwiftProtoTesting_Names_MessageNames.FloatMessage) -> Bool { if lhs._float != rhs._float {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.UIntMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".UInt" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UInt"), - ] +extension SwiftProtoTesting_Names_MessageNames.UIntMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".UInt" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UInt\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18829,18 +13598,16 @@ extension SwiftUnittest_Names_MessageNames.UIntMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.UIntMessage, rhs: SwiftUnittest_Names_MessageNames.UIntMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.UIntMessage, rhs: SwiftProtoTesting_Names_MessageNames.UIntMessage) -> Bool { if lhs._uint != rhs._uint {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.hashValueMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".hashValue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hashValue"), - ] +extension SwiftProtoTesting_Names_MessageNames.hashValueMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".hashValue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hashValue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18865,18 +13632,16 @@ extension SwiftUnittest_Names_MessageNames.hashValueMessage: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.hashValueMessage, rhs: SwiftUnittest_Names_MessageNames.hashValueMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.hashValueMessage, rhs: SwiftProtoTesting_Names_MessageNames.hashValueMessage) -> Bool { if lhs._hashValue_p != rhs._hashValue_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.descriptionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".description" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "description"), - ] +extension SwiftProtoTesting_Names_MessageNames.descriptionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".description" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}description\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18901,18 +13666,16 @@ extension SwiftUnittest_Names_MessageNames.descriptionMessage: SwiftProtobuf.Mes try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.descriptionMessage, rhs: SwiftUnittest_Names_MessageNames.descriptionMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.descriptionMessage, rhs: SwiftProtoTesting_Names_MessageNames.descriptionMessage) -> Bool { if lhs._description_p != rhs._description_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.debugDescriptionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".debugDescription" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "debugDescription"), - ] +extension SwiftProtoTesting_Names_MessageNames.debugDescriptionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".debugDescription" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}debugDescription\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18937,18 +13700,16 @@ extension SwiftUnittest_Names_MessageNames.debugDescriptionMessage: SwiftProtobu try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.debugDescriptionMessage, rhs: SwiftUnittest_Names_MessageNames.debugDescriptionMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.debugDescriptionMessage, rhs: SwiftProtoTesting_Names_MessageNames.debugDescriptionMessage) -> Bool { if lhs._debugDescription_p != rhs._debugDescription_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Swift: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Swift" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Swift"), - ] +extension SwiftProtoTesting_Names_MessageNames.SwiftMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Swift" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Swift\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -18973,18 +13734,16 @@ extension SwiftUnittest_Names_MessageNames.Swift: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Swift, rhs: SwiftUnittest_Names_MessageNames.Swift) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.SwiftMessage, rhs: SwiftProtoTesting_Names_MessageNames.SwiftMessage) -> Bool { if lhs._swift != rhs._swift {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.UNRECOGNIZED: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".UNRECOGNIZED" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "UNRECOGNIZED"), - ] +extension SwiftProtoTesting_Names_MessageNames.UNRECOGNIZED: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".UNRECOGNIZED" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}UNRECOGNIZED\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19009,18 +13768,16 @@ extension SwiftUnittest_Names_MessageNames.UNRECOGNIZED: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.UNRECOGNIZED, rhs: SwiftUnittest_Names_MessageNames.UNRECOGNIZED) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.UNRECOGNIZED, rhs: SwiftProtoTesting_Names_MessageNames.UNRECOGNIZED) -> Bool { if lhs._unrecognized != rhs._unrecognized {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.classMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".class" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "class"), - ] +extension SwiftProtoTesting_Names_MessageNames.classMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".class" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}class\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19045,18 +13802,16 @@ extension SwiftUnittest_Names_MessageNames.classMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.classMessage, rhs: SwiftUnittest_Names_MessageNames.classMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.classMessage, rhs: SwiftProtoTesting_Names_MessageNames.classMessage) -> Bool { if lhs._class != rhs._class {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.deinitMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".deinit" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "deinit"), - ] +extension SwiftProtoTesting_Names_MessageNames.deinitMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".deinit" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}deinit\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19081,18 +13836,16 @@ extension SwiftUnittest_Names_MessageNames.deinitMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.deinitMessage, rhs: SwiftUnittest_Names_MessageNames.deinitMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.deinitMessage, rhs: SwiftProtoTesting_Names_MessageNames.deinitMessage) -> Bool { if lhs._deinit != rhs._deinit {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.enumMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".enum" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "enum"), - ] +extension SwiftProtoTesting_Names_MessageNames.enumMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".enum" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}enum\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19117,18 +13870,16 @@ extension SwiftUnittest_Names_MessageNames.enumMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.enumMessage, rhs: SwiftUnittest_Names_MessageNames.enumMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.enumMessage, rhs: SwiftProtoTesting_Names_MessageNames.enumMessage) -> Bool { if lhs._enum != rhs._enum {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.extensionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".extension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extension"), - ] +extension SwiftProtoTesting_Names_MessageNames.extensionMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".extension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19153,18 +13904,16 @@ extension SwiftUnittest_Names_MessageNames.extensionMessage: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.extensionMessage, rhs: SwiftUnittest_Names_MessageNames.extensionMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.extensionMessage, rhs: SwiftProtoTesting_Names_MessageNames.extensionMessage) -> Bool { if lhs._extension != rhs._extension {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.funcMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".func" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "func"), - ] +extension SwiftProtoTesting_Names_MessageNames.funcMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".func" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}func\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19189,18 +13938,16 @@ extension SwiftUnittest_Names_MessageNames.funcMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.funcMessage, rhs: SwiftUnittest_Names_MessageNames.funcMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.funcMessage, rhs: SwiftProtoTesting_Names_MessageNames.funcMessage) -> Bool { if lhs._func != rhs._func {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.importMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".import" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "import"), - ] +extension SwiftProtoTesting_Names_MessageNames.importMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".import" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}import\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19225,18 +13972,16 @@ extension SwiftUnittest_Names_MessageNames.importMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.importMessage, rhs: SwiftUnittest_Names_MessageNames.importMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.importMessage, rhs: SwiftProtoTesting_Names_MessageNames.importMessage) -> Bool { if lhs._import != rhs._import {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.initMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".init" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "init"), - ] +extension SwiftProtoTesting_Names_MessageNames.initMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".init" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}init\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19261,18 +14006,16 @@ extension SwiftUnittest_Names_MessageNames.initMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.initMessage, rhs: SwiftUnittest_Names_MessageNames.initMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.initMessage, rhs: SwiftProtoTesting_Names_MessageNames.initMessage) -> Bool { if lhs._init_p != rhs._init_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.inoutMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".inout" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "inout"), - ] +extension SwiftProtoTesting_Names_MessageNames.inoutMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".inout" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}inout\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19297,18 +14040,16 @@ extension SwiftUnittest_Names_MessageNames.inoutMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.inoutMessage, rhs: SwiftUnittest_Names_MessageNames.inoutMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.inoutMessage, rhs: SwiftProtoTesting_Names_MessageNames.inoutMessage) -> Bool { if lhs._inout != rhs._inout {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.internalMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".internal" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "internal"), - ] +extension SwiftProtoTesting_Names_MessageNames.internalMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".internal" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}internal\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19333,18 +14074,16 @@ extension SwiftUnittest_Names_MessageNames.internalMessage: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.internalMessage, rhs: SwiftUnittest_Names_MessageNames.internalMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.internalMessage, rhs: SwiftProtoTesting_Names_MessageNames.internalMessage) -> Bool { if lhs._internal != rhs._internal {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.letMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".let" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "let"), - ] +extension SwiftProtoTesting_Names_MessageNames.letMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".let" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}let\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19369,18 +14108,16 @@ extension SwiftUnittest_Names_MessageNames.letMessage: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.letMessage, rhs: SwiftUnittest_Names_MessageNames.letMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.letMessage, rhs: SwiftProtoTesting_Names_MessageNames.letMessage) -> Bool { if lhs._let != rhs._let {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.operatorMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".operator" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "operator"), - ] +extension SwiftProtoTesting_Names_MessageNames.operatorMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".operator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}operator\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19405,18 +14142,16 @@ extension SwiftUnittest_Names_MessageNames.operatorMessage: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.operatorMessage, rhs: SwiftUnittest_Names_MessageNames.operatorMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.operatorMessage, rhs: SwiftProtoTesting_Names_MessageNames.operatorMessage) -> Bool { if lhs._operator != rhs._operator {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.privateMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".private" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "private"), - ] +extension SwiftProtoTesting_Names_MessageNames.privateMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".private" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}private\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19441,18 +14176,16 @@ extension SwiftUnittest_Names_MessageNames.privateMessage: SwiftProtobuf.Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.privateMessage, rhs: SwiftUnittest_Names_MessageNames.privateMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.privateMessage, rhs: SwiftProtoTesting_Names_MessageNames.privateMessage) -> Bool { if lhs._private != rhs._private {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.protocolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".protocol" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "protocol"), - ] +extension SwiftProtoTesting_Names_MessageNames.protocolMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".protocol" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}protocol\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19477,18 +14210,16 @@ extension SwiftUnittest_Names_MessageNames.protocolMessage: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.protocolMessage, rhs: SwiftUnittest_Names_MessageNames.protocolMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.protocolMessage, rhs: SwiftProtoTesting_Names_MessageNames.protocolMessage) -> Bool { if lhs._protocol != rhs._protocol {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.publicMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".public" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "public"), - ] +extension SwiftProtoTesting_Names_MessageNames.publicMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".public" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}public\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19513,18 +14244,16 @@ extension SwiftUnittest_Names_MessageNames.publicMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.publicMessage, rhs: SwiftUnittest_Names_MessageNames.publicMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.publicMessage, rhs: SwiftProtoTesting_Names_MessageNames.publicMessage) -> Bool { if lhs._public != rhs._public {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.staticMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".static" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "static"), - ] +extension SwiftProtoTesting_Names_MessageNames.staticMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".static" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}static\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19549,18 +14278,16 @@ extension SwiftUnittest_Names_MessageNames.staticMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.staticMessage, rhs: SwiftUnittest_Names_MessageNames.staticMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.staticMessage, rhs: SwiftProtoTesting_Names_MessageNames.staticMessage) -> Bool { if lhs._static != rhs._static {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.structMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".struct" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "struct"), - ] +extension SwiftProtoTesting_Names_MessageNames.structMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".struct" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}struct\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19585,18 +14312,16 @@ extension SwiftUnittest_Names_MessageNames.structMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.structMessage, rhs: SwiftUnittest_Names_MessageNames.structMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.structMessage, rhs: SwiftProtoTesting_Names_MessageNames.structMessage) -> Bool { if lhs._struct != rhs._struct {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.subscriptMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".subscript" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "subscript"), - ] +extension SwiftProtoTesting_Names_MessageNames.subscriptMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".subscript" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}subscript\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19621,18 +14346,16 @@ extension SwiftUnittest_Names_MessageNames.subscriptMessage: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.subscriptMessage, rhs: SwiftUnittest_Names_MessageNames.subscriptMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.subscriptMessage, rhs: SwiftProtoTesting_Names_MessageNames.subscriptMessage) -> Bool { if lhs._subscript != rhs._subscript {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.typealiasMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".typealias" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typealias"), - ] +extension SwiftProtoTesting_Names_MessageNames.typealiasMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".typealias" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typealias\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19657,18 +14380,16 @@ extension SwiftUnittest_Names_MessageNames.typealiasMessage: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.typealiasMessage, rhs: SwiftUnittest_Names_MessageNames.typealiasMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.typealiasMessage, rhs: SwiftProtoTesting_Names_MessageNames.typealiasMessage) -> Bool { if lhs._typealias != rhs._typealias {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.varMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".var" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "var"), - ] +extension SwiftProtoTesting_Names_MessageNames.varMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".var" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}var\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19693,18 +14414,16 @@ extension SwiftUnittest_Names_MessageNames.varMessage: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.varMessage, rhs: SwiftUnittest_Names_MessageNames.varMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.varMessage, rhs: SwiftProtoTesting_Names_MessageNames.varMessage) -> Bool { if lhs._var != rhs._var {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.breakMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".break" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "break"), - ] +extension SwiftProtoTesting_Names_MessageNames.breakMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".break" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}break\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19729,18 +14448,16 @@ extension SwiftUnittest_Names_MessageNames.breakMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.breakMessage, rhs: SwiftUnittest_Names_MessageNames.breakMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.breakMessage, rhs: SwiftProtoTesting_Names_MessageNames.breakMessage) -> Bool { if lhs._break != rhs._break {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.caseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".case" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "case"), - ] +extension SwiftProtoTesting_Names_MessageNames.caseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".case" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}case\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19765,18 +14482,16 @@ extension SwiftUnittest_Names_MessageNames.caseMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.caseMessage, rhs: SwiftUnittest_Names_MessageNames.caseMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.caseMessage, rhs: SwiftProtoTesting_Names_MessageNames.caseMessage) -> Bool { if lhs._case != rhs._case {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.continueMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".continue" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "continue"), - ] +extension SwiftProtoTesting_Names_MessageNames.continueMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".continue" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}continue\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19801,18 +14516,16 @@ extension SwiftUnittest_Names_MessageNames.continueMessage: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.continueMessage, rhs: SwiftUnittest_Names_MessageNames.continueMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.continueMessage, rhs: SwiftProtoTesting_Names_MessageNames.continueMessage) -> Bool { if lhs._continue != rhs._continue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.defaultMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".default" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "default"), - ] +extension SwiftProtoTesting_Names_MessageNames.defaultMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".default" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}default\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19837,18 +14550,16 @@ extension SwiftUnittest_Names_MessageNames.defaultMessage: SwiftProtobuf.Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.defaultMessage, rhs: SwiftUnittest_Names_MessageNames.defaultMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.defaultMessage, rhs: SwiftProtoTesting_Names_MessageNames.defaultMessage) -> Bool { if lhs._default != rhs._default {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.deferMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".defer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "defer"), - ] +extension SwiftProtoTesting_Names_MessageNames.deferMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".defer" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}defer\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19873,18 +14584,16 @@ extension SwiftUnittest_Names_MessageNames.deferMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.deferMessage, rhs: SwiftUnittest_Names_MessageNames.deferMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.deferMessage, rhs: SwiftProtoTesting_Names_MessageNames.deferMessage) -> Bool { if lhs._defer != rhs._defer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.doMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".do" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "do"), - ] +extension SwiftProtoTesting_Names_MessageNames.doMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".do" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}do\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19909,18 +14618,16 @@ extension SwiftUnittest_Names_MessageNames.doMessage: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.doMessage, rhs: SwiftUnittest_Names_MessageNames.doMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.doMessage, rhs: SwiftProtoTesting_Names_MessageNames.doMessage) -> Bool { if lhs._do != rhs._do {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.elseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".else" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "else"), - ] +extension SwiftProtoTesting_Names_MessageNames.elseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".else" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}else\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19945,18 +14652,16 @@ extension SwiftUnittest_Names_MessageNames.elseMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.elseMessage, rhs: SwiftUnittest_Names_MessageNames.elseMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.elseMessage, rhs: SwiftProtoTesting_Names_MessageNames.elseMessage) -> Bool { if lhs._else != rhs._else {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.fallthroughMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".fallthrough" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "fallthrough"), - ] +extension SwiftProtoTesting_Names_MessageNames.fallthroughMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".fallthrough" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}fallthrough\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -19981,18 +14686,16 @@ extension SwiftUnittest_Names_MessageNames.fallthroughMessage: SwiftProtobuf.Mes try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.fallthroughMessage, rhs: SwiftUnittest_Names_MessageNames.fallthroughMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.fallthroughMessage, rhs: SwiftProtoTesting_Names_MessageNames.fallthroughMessage) -> Bool { if lhs._fallthrough != rhs._fallthrough {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.forMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".for" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "for"), - ] +extension SwiftProtoTesting_Names_MessageNames.forMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".for" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}for\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20017,18 +14720,16 @@ extension SwiftUnittest_Names_MessageNames.forMessage: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.forMessage, rhs: SwiftUnittest_Names_MessageNames.forMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.forMessage, rhs: SwiftProtoTesting_Names_MessageNames.forMessage) -> Bool { if lhs._for != rhs._for {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.guardMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".guard" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "guard"), - ] +extension SwiftProtoTesting_Names_MessageNames.guardMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".guard" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}guard\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20053,18 +14754,16 @@ extension SwiftUnittest_Names_MessageNames.guardMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.guardMessage, rhs: SwiftUnittest_Names_MessageNames.guardMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.guardMessage, rhs: SwiftProtoTesting_Names_MessageNames.guardMessage) -> Bool { if lhs._guard != rhs._guard {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.ifMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".if" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "if"), - ] +extension SwiftProtoTesting_Names_MessageNames.ifMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".if" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}if\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20089,18 +14788,16 @@ extension SwiftUnittest_Names_MessageNames.ifMessage: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.ifMessage, rhs: SwiftUnittest_Names_MessageNames.ifMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ifMessage, rhs: SwiftProtoTesting_Names_MessageNames.ifMessage) -> Bool { if lhs._if != rhs._if {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.inMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".in" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "in"), - ] +extension SwiftProtoTesting_Names_MessageNames.inMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".in" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}in\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20125,18 +14822,16 @@ extension SwiftUnittest_Names_MessageNames.inMessage: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.inMessage, rhs: SwiftUnittest_Names_MessageNames.inMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.inMessage, rhs: SwiftProtoTesting_Names_MessageNames.inMessage) -> Bool { if lhs._in != rhs._in {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.repeatMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".repeat" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "repeat"), - ] +extension SwiftProtoTesting_Names_MessageNames.repeatMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".repeat" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}repeat\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20161,18 +14856,16 @@ extension SwiftUnittest_Names_MessageNames.repeatMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.repeatMessage, rhs: SwiftUnittest_Names_MessageNames.repeatMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.repeatMessage, rhs: SwiftProtoTesting_Names_MessageNames.repeatMessage) -> Bool { if lhs._repeat != rhs._repeat {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.returnMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".return" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "return"), - ] +extension SwiftProtoTesting_Names_MessageNames.returnMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".return" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}return\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20197,18 +14890,16 @@ extension SwiftUnittest_Names_MessageNames.returnMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.returnMessage, rhs: SwiftUnittest_Names_MessageNames.returnMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.returnMessage, rhs: SwiftProtoTesting_Names_MessageNames.returnMessage) -> Bool { if lhs._return != rhs._return {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.switchMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".switch" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "switch"), - ] +extension SwiftProtoTesting_Names_MessageNames.switchMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".switch" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}switch\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20233,18 +14924,16 @@ extension SwiftUnittest_Names_MessageNames.switchMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.switchMessage, rhs: SwiftUnittest_Names_MessageNames.switchMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.switchMessage, rhs: SwiftProtoTesting_Names_MessageNames.switchMessage) -> Bool { if lhs._switch != rhs._switch {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.whereMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".where" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "where"), - ] +extension SwiftProtoTesting_Names_MessageNames.whereMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".where" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}where\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20269,18 +14958,16 @@ extension SwiftUnittest_Names_MessageNames.whereMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.whereMessage, rhs: SwiftUnittest_Names_MessageNames.whereMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.whereMessage, rhs: SwiftProtoTesting_Names_MessageNames.whereMessage) -> Bool { if lhs._where != rhs._where {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.whileMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".while" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "while"), - ] +extension SwiftProtoTesting_Names_MessageNames.whileMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".while" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}while\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20305,18 +14992,16 @@ extension SwiftUnittest_Names_MessageNames.whileMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.whileMessage, rhs: SwiftUnittest_Names_MessageNames.whileMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.whileMessage, rhs: SwiftProtoTesting_Names_MessageNames.whileMessage) -> Bool { if lhs._while != rhs._while {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.asMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".as" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "as"), - ] +extension SwiftProtoTesting_Names_MessageNames.asMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".as" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}as\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20341,18 +15026,16 @@ extension SwiftUnittest_Names_MessageNames.asMessage: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.asMessage, rhs: SwiftUnittest_Names_MessageNames.asMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.asMessage, rhs: SwiftProtoTesting_Names_MessageNames.asMessage) -> Bool { if lhs._as != rhs._as {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.catchMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".catch" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "catch"), - ] +extension SwiftProtoTesting_Names_MessageNames.catchMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".catch" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}catch\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20377,18 +15060,16 @@ extension SwiftUnittest_Names_MessageNames.catchMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.catchMessage, rhs: SwiftUnittest_Names_MessageNames.catchMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.catchMessage, rhs: SwiftProtoTesting_Names_MessageNames.catchMessage) -> Bool { if lhs._catch != rhs._catch {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.dynamicTypeMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".dynamicType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "dynamicType"), - ] +extension SwiftProtoTesting_Names_MessageNames.dynamicTypeMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".dynamicType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}dynamicType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20413,18 +15094,16 @@ extension SwiftUnittest_Names_MessageNames.dynamicTypeMessage: SwiftProtobuf.Mes try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.dynamicTypeMessage, rhs: SwiftUnittest_Names_MessageNames.dynamicTypeMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.dynamicTypeMessage, rhs: SwiftProtoTesting_Names_MessageNames.dynamicTypeMessage) -> Bool { if lhs._dynamicType_p != rhs._dynamicType_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.falseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".false" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "false"), - ] +extension SwiftProtoTesting_Names_MessageNames.falseMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".false" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}false\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20449,18 +15128,16 @@ extension SwiftUnittest_Names_MessageNames.falseMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.falseMessage, rhs: SwiftUnittest_Names_MessageNames.falseMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.falseMessage, rhs: SwiftProtoTesting_Names_MessageNames.falseMessage) -> Bool { if lhs._false != rhs._false {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.isMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".is" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "is"), - ] +extension SwiftProtoTesting_Names_MessageNames.isMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".is" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}is\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20485,18 +15162,16 @@ extension SwiftUnittest_Names_MessageNames.isMessage: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.isMessage, rhs: SwiftUnittest_Names_MessageNames.isMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.isMessage, rhs: SwiftProtoTesting_Names_MessageNames.isMessage) -> Bool { if lhs._is != rhs._is {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.nilMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".nil" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nil"), - ] +extension SwiftProtoTesting_Names_MessageNames.nilMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".nil" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nil\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20521,18 +15196,16 @@ extension SwiftUnittest_Names_MessageNames.nilMessage: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.nilMessage, rhs: SwiftUnittest_Names_MessageNames.nilMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.nilMessage, rhs: SwiftProtoTesting_Names_MessageNames.nilMessage) -> Bool { if lhs._nil != rhs._nil {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.rethrowsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".rethrows" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "rethrows"), - ] +extension SwiftProtoTesting_Names_MessageNames.rethrowsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".rethrows" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}rethrows\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20557,18 +15230,16 @@ extension SwiftUnittest_Names_MessageNames.rethrowsMessage: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.rethrowsMessage, rhs: SwiftUnittest_Names_MessageNames.rethrowsMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.rethrowsMessage, rhs: SwiftProtoTesting_Names_MessageNames.rethrowsMessage) -> Bool { if lhs._rethrows != rhs._rethrows {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.superMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".super" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "super"), - ] +extension SwiftProtoTesting_Names_MessageNames.superMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".super" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}super\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20593,18 +15264,16 @@ extension SwiftUnittest_Names_MessageNames.superMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.superMessage, rhs: SwiftUnittest_Names_MessageNames.superMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.superMessage, rhs: SwiftProtoTesting_Names_MessageNames.superMessage) -> Bool { if lhs._super != rhs._super {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.selfMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".self" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "self"), - ] +extension SwiftProtoTesting_Names_MessageNames.selfMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".self" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}self\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20629,18 +15298,16 @@ extension SwiftUnittest_Names_MessageNames.selfMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.selfMessage, rhs: SwiftUnittest_Names_MessageNames.selfMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.selfMessage, rhs: SwiftProtoTesting_Names_MessageNames.selfMessage) -> Bool { if lhs._self_p != rhs._self_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.throwMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".throw" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "throw"), - ] +extension SwiftProtoTesting_Names_MessageNames.throwMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".throw" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}throw\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20665,18 +15332,16 @@ extension SwiftUnittest_Names_MessageNames.throwMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.throwMessage, rhs: SwiftUnittest_Names_MessageNames.throwMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.throwMessage, rhs: SwiftProtoTesting_Names_MessageNames.throwMessage) -> Bool { if lhs._throw != rhs._throw {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.throwsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".throws" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "throws"), - ] +extension SwiftProtoTesting_Names_MessageNames.throwsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".throws" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}throws\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20701,18 +15366,16 @@ extension SwiftUnittest_Names_MessageNames.throwsMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.throwsMessage, rhs: SwiftUnittest_Names_MessageNames.throwsMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.throwsMessage, rhs: SwiftProtoTesting_Names_MessageNames.throwsMessage) -> Bool { if lhs._throws != rhs._throws {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.trueMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".true" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "true"), - ] +extension SwiftProtoTesting_Names_MessageNames.trueMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".true" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}true\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20737,18 +15400,16 @@ extension SwiftUnittest_Names_MessageNames.trueMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.trueMessage, rhs: SwiftUnittest_Names_MessageNames.trueMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.trueMessage, rhs: SwiftProtoTesting_Names_MessageNames.trueMessage) -> Bool { if lhs._true != rhs._true {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.tryMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".try" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "try"), - ] +extension SwiftProtoTesting_Names_MessageNames.tryMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".try" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}try\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20773,18 +15434,16 @@ extension SwiftUnittest_Names_MessageNames.tryMessage: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.tryMessage, rhs: SwiftUnittest_Names_MessageNames.tryMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.tryMessage, rhs: SwiftProtoTesting_Names_MessageNames.tryMessage) -> Bool { if lhs._try != rhs._try {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.__COLUMN__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".__COLUMN__" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "__COLUMN__"), - ] +extension SwiftProtoTesting_Names_MessageNames.__COLUMN__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".__COLUMN__" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}__COLUMN__\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20809,18 +15468,16 @@ extension SwiftUnittest_Names_MessageNames.__COLUMN__Message: SwiftProtobuf.Mess try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.__COLUMN__Message, rhs: SwiftUnittest_Names_MessageNames.__COLUMN__Message) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.__COLUMN__Message, rhs: SwiftProtoTesting_Names_MessageNames.__COLUMN__Message) -> Bool { if lhs.__Column__ != rhs.__Column__ {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.__FILE__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".__FILE__" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "__FILE__"), - ] +extension SwiftProtoTesting_Names_MessageNames.__FILE__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".__FILE__" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}__FILE__\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20845,18 +15502,16 @@ extension SwiftUnittest_Names_MessageNames.__FILE__Message: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.__FILE__Message, rhs: SwiftUnittest_Names_MessageNames.__FILE__Message) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.__FILE__Message, rhs: SwiftProtoTesting_Names_MessageNames.__FILE__Message) -> Bool { if lhs.__File__ != rhs.__File__ {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.__FUNCTION__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".__FUNCTION__" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "__FUNCTION__"), - ] +extension SwiftProtoTesting_Names_MessageNames.__FUNCTION__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".__FUNCTION__" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}__FUNCTION__\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20881,18 +15536,16 @@ extension SwiftUnittest_Names_MessageNames.__FUNCTION__Message: SwiftProtobuf.Me try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.__FUNCTION__Message, rhs: SwiftUnittest_Names_MessageNames.__FUNCTION__Message) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.__FUNCTION__Message, rhs: SwiftProtoTesting_Names_MessageNames.__FUNCTION__Message) -> Bool { if lhs.__Function__ != rhs.__Function__ {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.__LINE__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".__LINE__" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "__LINE__"), - ] +extension SwiftProtoTesting_Names_MessageNames.__LINE__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".__LINE__" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}__LINE__\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20917,18 +15570,16 @@ extension SwiftUnittest_Names_MessageNames.__LINE__Message: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.__LINE__Message, rhs: SwiftUnittest_Names_MessageNames.__LINE__Message) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.__LINE__Message, rhs: SwiftProtoTesting_Names_MessageNames.__LINE__Message) -> Bool { if lhs.__Line__ != rhs.__Line__ {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames._Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + "._" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "_"), - ] +extension SwiftProtoTesting_Names_MessageNames._Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + "._" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}_\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20953,18 +15604,16 @@ extension SwiftUnittest_Names_MessageNames._Message: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames._Message, rhs: SwiftUnittest_Names_MessageNames._Message) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames._Message, rhs: SwiftProtoTesting_Names_MessageNames._Message) -> Bool { if lhs.____ != rhs.____ {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".__" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "__"), - ] +extension SwiftProtoTesting_Names_MessageNames.__Message: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".__" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}__\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -20989,18 +15638,16 @@ extension SwiftUnittest_Names_MessageNames.__Message: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.__Message, rhs: SwiftUnittest_Names_MessageNames.__Message) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.__Message, rhs: SwiftProtoTesting_Names_MessageNames.__Message) -> Bool { if lhs._____ != rhs._____ {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.associativity: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".associativity" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "associativity"), - ] +extension SwiftProtoTesting_Names_MessageNames.associativity: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".associativity" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}associativity\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21025,18 +15672,16 @@ extension SwiftUnittest_Names_MessageNames.associativity: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.associativity, rhs: SwiftUnittest_Names_MessageNames.associativity) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.associativity, rhs: SwiftProtoTesting_Names_MessageNames.associativity) -> Bool { if lhs._associativity != rhs._associativity {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.convenience: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".convenience" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "convenience"), - ] +extension SwiftProtoTesting_Names_MessageNames.convenience: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".convenience" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}convenience\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21061,18 +15706,16 @@ extension SwiftUnittest_Names_MessageNames.convenience: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.convenience, rhs: SwiftUnittest_Names_MessageNames.convenience) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.convenience, rhs: SwiftProtoTesting_Names_MessageNames.convenience) -> Bool { if lhs._convenience != rhs._convenience {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.dynamic: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".dynamic" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "dynamic"), - ] +extension SwiftProtoTesting_Names_MessageNames.dynamic: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".dynamic" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}dynamic\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21097,18 +15740,16 @@ extension SwiftUnittest_Names_MessageNames.dynamic: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.dynamic, rhs: SwiftUnittest_Names_MessageNames.dynamic) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.dynamic, rhs: SwiftProtoTesting_Names_MessageNames.dynamic) -> Bool { if lhs._dynamic != rhs._dynamic {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.didSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".didSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "didSet"), - ] +extension SwiftProtoTesting_Names_MessageNames.didSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".didSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}didSet\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21133,18 +15774,16 @@ extension SwiftUnittest_Names_MessageNames.didSet: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.didSet, rhs: SwiftUnittest_Names_MessageNames.didSet) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.didSet, rhs: SwiftProtoTesting_Names_MessageNames.didSet) -> Bool { if lhs._didSet != rhs._didSet {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.final: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".final" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "final"), - ] +extension SwiftProtoTesting_Names_MessageNames.final: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".final" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}final\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21169,18 +15808,16 @@ extension SwiftUnittest_Names_MessageNames.final: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.final, rhs: SwiftUnittest_Names_MessageNames.final) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.final, rhs: SwiftProtoTesting_Names_MessageNames.final) -> Bool { if lhs._final != rhs._final {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.get: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".get" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "get"), - ] +extension SwiftProtoTesting_Names_MessageNames.get: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".get" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}get\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21205,18 +15842,16 @@ extension SwiftUnittest_Names_MessageNames.get: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.get, rhs: SwiftUnittest_Names_MessageNames.get) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.get, rhs: SwiftProtoTesting_Names_MessageNames.get) -> Bool { if lhs._get != rhs._get {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.infix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".infix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "infix"), - ] +extension SwiftProtoTesting_Names_MessageNames.infix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".infix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}infix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21241,18 +15876,16 @@ extension SwiftUnittest_Names_MessageNames.infix: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.infix, rhs: SwiftUnittest_Names_MessageNames.infix) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.infix, rhs: SwiftProtoTesting_Names_MessageNames.infix) -> Bool { if lhs._infix != rhs._infix {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.indirect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".indirect" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "indirect"), - ] +extension SwiftProtoTesting_Names_MessageNames.indirect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".indirect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}indirect\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21277,18 +15910,16 @@ extension SwiftUnittest_Names_MessageNames.indirect: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.indirect, rhs: SwiftUnittest_Names_MessageNames.indirect) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.indirect, rhs: SwiftProtoTesting_Names_MessageNames.indirect) -> Bool { if lhs._indirect != rhs._indirect {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.lazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".lazy" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "lazy"), - ] +extension SwiftProtoTesting_Names_MessageNames.lazy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".lazy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}lazy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21313,18 +15944,16 @@ extension SwiftUnittest_Names_MessageNames.lazy: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.lazy, rhs: SwiftUnittest_Names_MessageNames.lazy) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.lazy, rhs: SwiftProtoTesting_Names_MessageNames.lazy) -> Bool { if lhs._lazy != rhs._lazy {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.left: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".left" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "left"), - ] +extension SwiftProtoTesting_Names_MessageNames.left: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".left" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}left\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21349,18 +15978,16 @@ extension SwiftUnittest_Names_MessageNames.left: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.left, rhs: SwiftUnittest_Names_MessageNames.left) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.left, rhs: SwiftProtoTesting_Names_MessageNames.left) -> Bool { if lhs._left != rhs._left {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.mutating: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".mutating" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mutating"), - ] +extension SwiftProtoTesting_Names_MessageNames.mutating: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".mutating" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mutating\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21385,18 +16012,16 @@ extension SwiftUnittest_Names_MessageNames.mutating: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.mutating, rhs: SwiftUnittest_Names_MessageNames.mutating) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.mutating, rhs: SwiftProtoTesting_Names_MessageNames.mutating) -> Bool { if lhs._mutating != rhs._mutating {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.none: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".none" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "none"), - ] +extension SwiftProtoTesting_Names_MessageNames.none: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".none" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}none\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21421,18 +16046,16 @@ extension SwiftUnittest_Names_MessageNames.none: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.none, rhs: SwiftUnittest_Names_MessageNames.none) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.none, rhs: SwiftProtoTesting_Names_MessageNames.none) -> Bool { if lhs._none != rhs._none {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.nonmutating: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".nonmutating" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nonmutating"), - ] +extension SwiftProtoTesting_Names_MessageNames.nonmutating: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".nonmutating" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nonmutating\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21457,18 +16080,16 @@ extension SwiftUnittest_Names_MessageNames.nonmutating: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.nonmutating, rhs: SwiftUnittest_Names_MessageNames.nonmutating) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.nonmutating, rhs: SwiftProtoTesting_Names_MessageNames.nonmutating) -> Bool { if lhs._nonmutating != rhs._nonmutating {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".optional" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "optional"), - ] +extension SwiftProtoTesting_Names_MessageNames.optional: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".optional" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}optional\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21493,18 +16114,16 @@ extension SwiftUnittest_Names_MessageNames.optional: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.optional, rhs: SwiftUnittest_Names_MessageNames.optional) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.optional, rhs: SwiftProtoTesting_Names_MessageNames.optional) -> Bool { if lhs._optional != rhs._optional {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.override: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".override" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "override"), - ] +extension SwiftProtoTesting_Names_MessageNames.override: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".override" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}override\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21529,18 +16148,16 @@ extension SwiftUnittest_Names_MessageNames.override: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.override, rhs: SwiftUnittest_Names_MessageNames.override) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.override, rhs: SwiftProtoTesting_Names_MessageNames.override) -> Bool { if lhs._override != rhs._override {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.postfix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".postfix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "postfix"), - ] +extension SwiftProtoTesting_Names_MessageNames.postfix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".postfix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}postfix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21565,18 +16182,16 @@ extension SwiftUnittest_Names_MessageNames.postfix: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.postfix, rhs: SwiftUnittest_Names_MessageNames.postfix) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.postfix, rhs: SwiftProtoTesting_Names_MessageNames.postfix) -> Bool { if lhs._postfix != rhs._postfix {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.precedence: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".precedence" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "precedence"), - ] +extension SwiftProtoTesting_Names_MessageNames.precedence: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".precedence" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}precedence\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21601,18 +16216,16 @@ extension SwiftUnittest_Names_MessageNames.precedence: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.precedence, rhs: SwiftUnittest_Names_MessageNames.precedence) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.precedence, rhs: SwiftProtoTesting_Names_MessageNames.precedence) -> Bool { if lhs._precedence != rhs._precedence {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.prefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".prefix" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "prefix"), - ] +extension SwiftProtoTesting_Names_MessageNames.prefix: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".prefix" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}prefix\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21637,18 +16250,16 @@ extension SwiftUnittest_Names_MessageNames.prefix: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.prefix, rhs: SwiftUnittest_Names_MessageNames.prefix) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.prefix, rhs: SwiftProtoTesting_Names_MessageNames.prefix) -> Bool { if lhs._prefix != rhs._prefix {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.required: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".required" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "required"), - ] +extension SwiftProtoTesting_Names_MessageNames.required: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".required" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}required\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21673,18 +16284,16 @@ extension SwiftUnittest_Names_MessageNames.required: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.required, rhs: SwiftUnittest_Names_MessageNames.required) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.required, rhs: SwiftProtoTesting_Names_MessageNames.required) -> Bool { if lhs._required != rhs._required {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.right: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".right" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "right"), - ] +extension SwiftProtoTesting_Names_MessageNames.right: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".right" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}right\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21709,18 +16318,16 @@ extension SwiftUnittest_Names_MessageNames.right: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.right, rhs: SwiftUnittest_Names_MessageNames.right) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.right, rhs: SwiftProtoTesting_Names_MessageNames.right) -> Bool { if lhs._right != rhs._right {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.set: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".set" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "set"), - ] +extension SwiftProtoTesting_Names_MessageNames.set: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".set" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}set\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21745,18 +16352,16 @@ extension SwiftUnittest_Names_MessageNames.set: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.set, rhs: SwiftUnittest_Names_MessageNames.set) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.set, rhs: SwiftProtoTesting_Names_MessageNames.set) -> Bool { if lhs._set != rhs._set {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.TypeMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Type" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Type"), - ] +extension SwiftProtoTesting_Names_MessageNames.TypeMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Type" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Type\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21781,18 +16386,16 @@ extension SwiftUnittest_Names_MessageNames.TypeMessage: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.TypeMessage, rhs: SwiftUnittest_Names_MessageNames.TypeMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.TypeMessage, rhs: SwiftProtoTesting_Names_MessageNames.TypeMessage) -> Bool { if lhs._type != rhs._type {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.unowned: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".unowned" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "unowned"), - ] +extension SwiftProtoTesting_Names_MessageNames.unowned: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".unowned" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unowned\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21817,18 +16420,16 @@ extension SwiftUnittest_Names_MessageNames.unowned: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.unowned, rhs: SwiftUnittest_Names_MessageNames.unowned) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.unowned, rhs: SwiftProtoTesting_Names_MessageNames.unowned) -> Bool { if lhs._unowned != rhs._unowned {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.weak: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".weak" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "weak"), - ] +extension SwiftProtoTesting_Names_MessageNames.weak: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".weak" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}weak\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21853,18 +16454,16 @@ extension SwiftUnittest_Names_MessageNames.weak: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.weak, rhs: SwiftUnittest_Names_MessageNames.weak) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.weak, rhs: SwiftProtoTesting_Names_MessageNames.weak) -> Bool { if lhs._weak != rhs._weak {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.willSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".willSet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "willSet"), - ] +extension SwiftProtoTesting_Names_MessageNames.willSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".willSet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}willSet\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21889,18 +16488,16 @@ extension SwiftUnittest_Names_MessageNames.willSet: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.willSet, rhs: SwiftUnittest_Names_MessageNames.willSet) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.willSet, rhs: SwiftProtoTesting_Names_MessageNames.willSet) -> Bool { if lhs._willSet != rhs._willSet {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.id: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".id" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "id"), - ] +extension SwiftProtoTesting_Names_MessageNames.id: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".id" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}id\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21925,18 +16522,16 @@ extension SwiftUnittest_Names_MessageNames.id: SwiftProtobuf.Message, SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.id, rhs: SwiftUnittest_Names_MessageNames.id) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.id, rhs: SwiftProtoTesting_Names_MessageNames.id) -> Bool { if lhs._id != rhs._id {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames._cmd: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + "._cmd" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "_cmd"), - ] +extension SwiftProtoTesting_Names_MessageNames._cmd: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + "._cmd" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}_cmd\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21961,18 +16556,16 @@ extension SwiftUnittest_Names_MessageNames._cmd: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames._cmd, rhs: SwiftUnittest_Names_MessageNames._cmd) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames._cmd, rhs: SwiftProtoTesting_Names_MessageNames._cmd) -> Bool { if lhs._cmd != rhs._cmd {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.out: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".out" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "out"), - ] +extension SwiftProtoTesting_Names_MessageNames.out: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".out" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}out\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -21997,18 +16590,16 @@ extension SwiftUnittest_Names_MessageNames.out: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.out, rhs: SwiftUnittest_Names_MessageNames.out) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.out, rhs: SwiftProtoTesting_Names_MessageNames.out) -> Bool { if lhs._out != rhs._out {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.bycopy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".bycopy" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bycopy"), - ] +extension SwiftProtoTesting_Names_MessageNames.bycopy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".bycopy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bycopy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22033,18 +16624,16 @@ extension SwiftUnittest_Names_MessageNames.bycopy: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.bycopy, rhs: SwiftUnittest_Names_MessageNames.bycopy) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.bycopy, rhs: SwiftProtoTesting_Names_MessageNames.bycopy) -> Bool { if lhs._bycopy != rhs._bycopy {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.byref: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".byref" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "byref"), - ] +extension SwiftProtoTesting_Names_MessageNames.byref: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".byref" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}byref\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22069,18 +16658,16 @@ extension SwiftUnittest_Names_MessageNames.byref: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.byref, rhs: SwiftUnittest_Names_MessageNames.byref) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.byref, rhs: SwiftProtoTesting_Names_MessageNames.byref) -> Bool { if lhs._byref != rhs._byref {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.oneway: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".oneway" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "oneway"), - ] +extension SwiftProtoTesting_Names_MessageNames.oneway: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".oneway" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}oneway\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22105,18 +16692,16 @@ extension SwiftUnittest_Names_MessageNames.oneway: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.oneway, rhs: SwiftUnittest_Names_MessageNames.oneway) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.oneway, rhs: SwiftProtoTesting_Names_MessageNames.oneway) -> Bool { if lhs._oneway != rhs._oneway {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.and: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".and" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "and"), - ] +extension SwiftProtoTesting_Names_MessageNames.and: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".and" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}and\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22141,18 +16726,16 @@ extension SwiftUnittest_Names_MessageNames.and: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.and, rhs: SwiftUnittest_Names_MessageNames.and) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.and, rhs: SwiftProtoTesting_Names_MessageNames.and) -> Bool { if lhs._and != rhs._and {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.and_eq: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".and_eq" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "and_eq"), - ] +extension SwiftProtoTesting_Names_MessageNames.and_eq: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".and_eq" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}and_eq\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22177,18 +16760,16 @@ extension SwiftUnittest_Names_MessageNames.and_eq: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.and_eq, rhs: SwiftUnittest_Names_MessageNames.and_eq) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.and_eq, rhs: SwiftProtoTesting_Names_MessageNames.and_eq) -> Bool { if lhs._andEq != rhs._andEq {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.alignas: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".alignas" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "alignas"), - ] +extension SwiftProtoTesting_Names_MessageNames.alignas: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".alignas" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}alignas\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22213,18 +16794,16 @@ extension SwiftUnittest_Names_MessageNames.alignas: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.alignas, rhs: SwiftUnittest_Names_MessageNames.alignas) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.alignas, rhs: SwiftProtoTesting_Names_MessageNames.alignas) -> Bool { if lhs._alignas != rhs._alignas {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.alignof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".alignof" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "alignof"), - ] +extension SwiftProtoTesting_Names_MessageNames.alignof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".alignof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}alignof\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22249,18 +16828,16 @@ extension SwiftUnittest_Names_MessageNames.alignof: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.alignof, rhs: SwiftUnittest_Names_MessageNames.alignof) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.alignof, rhs: SwiftProtoTesting_Names_MessageNames.alignof) -> Bool { if lhs._alignof != rhs._alignof {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.asm: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".asm" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "asm"), - ] +extension SwiftProtoTesting_Names_MessageNames.asm: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".asm" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}asm\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22285,18 +16862,16 @@ extension SwiftUnittest_Names_MessageNames.asm: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.asm, rhs: SwiftUnittest_Names_MessageNames.asm) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.asm, rhs: SwiftProtoTesting_Names_MessageNames.asm) -> Bool { if lhs._asm != rhs._asm {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.auto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".auto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "auto"), - ] +extension SwiftProtoTesting_Names_MessageNames.auto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".auto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}auto\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22321,18 +16896,16 @@ extension SwiftUnittest_Names_MessageNames.auto: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.auto, rhs: SwiftUnittest_Names_MessageNames.auto) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.auto, rhs: SwiftProtoTesting_Names_MessageNames.auto) -> Bool { if lhs._auto != rhs._auto {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.bitand: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".bitand" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bitand"), - ] +extension SwiftProtoTesting_Names_MessageNames.bitand: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".bitand" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bitand\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22357,18 +16930,16 @@ extension SwiftUnittest_Names_MessageNames.bitand: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.bitand, rhs: SwiftUnittest_Names_MessageNames.bitand) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.bitand, rhs: SwiftProtoTesting_Names_MessageNames.bitand) -> Bool { if lhs._bitand != rhs._bitand {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.bitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".bitor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bitor"), - ] +extension SwiftProtoTesting_Names_MessageNames.bitor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".bitor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bitor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22393,18 +16964,16 @@ extension SwiftUnittest_Names_MessageNames.bitor: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.bitor, rhs: SwiftUnittest_Names_MessageNames.bitor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.bitor, rhs: SwiftProtoTesting_Names_MessageNames.bitor) -> Bool { if lhs._bitor != rhs._bitor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.bool: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".bool" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "bool"), - ] +extension SwiftProtoTesting_Names_MessageNames.bool: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".bool" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}bool\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22429,18 +16998,16 @@ extension SwiftUnittest_Names_MessageNames.bool: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.bool, rhs: SwiftUnittest_Names_MessageNames.bool) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.bool, rhs: SwiftProtoTesting_Names_MessageNames.bool) -> Bool { if lhs._bool != rhs._bool {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.char: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".char" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "char"), - ] +extension SwiftProtoTesting_Names_MessageNames.char: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".char" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}char\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22465,18 +17032,16 @@ extension SwiftUnittest_Names_MessageNames.char: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.char, rhs: SwiftUnittest_Names_MessageNames.char) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.char, rhs: SwiftProtoTesting_Names_MessageNames.char) -> Bool { if lhs._char != rhs._char {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.char16_t: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".char16_t" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "char16_t"), - ] +extension SwiftProtoTesting_Names_MessageNames.char16_t: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".char16_t" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}char16_t\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22501,18 +17066,16 @@ extension SwiftUnittest_Names_MessageNames.char16_t: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.char16_t, rhs: SwiftUnittest_Names_MessageNames.char16_t) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.char16_t, rhs: SwiftProtoTesting_Names_MessageNames.char16_t) -> Bool { if lhs._char16T != rhs._char16T {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.char32_t: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".char32_t" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "char32_t"), - ] +extension SwiftProtoTesting_Names_MessageNames.char32_t: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".char32_t" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}char32_t\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22537,18 +17100,16 @@ extension SwiftUnittest_Names_MessageNames.char32_t: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.char32_t, rhs: SwiftUnittest_Names_MessageNames.char32_t) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.char32_t, rhs: SwiftProtoTesting_Names_MessageNames.char32_t) -> Bool { if lhs._char32T != rhs._char32T {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.compl: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".compl" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "compl"), - ] +extension SwiftProtoTesting_Names_MessageNames.compl: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".compl" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}compl\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22573,18 +17134,16 @@ extension SwiftUnittest_Names_MessageNames.compl: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.compl, rhs: SwiftUnittest_Names_MessageNames.compl) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.compl, rhs: SwiftProtoTesting_Names_MessageNames.compl) -> Bool { if lhs._compl != rhs._compl {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.const: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".const" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "const"), - ] +extension SwiftProtoTesting_Names_MessageNames.const: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".const" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}const\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22609,18 +17168,16 @@ extension SwiftUnittest_Names_MessageNames.const: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.const, rhs: SwiftUnittest_Names_MessageNames.const) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.const, rhs: SwiftProtoTesting_Names_MessageNames.const) -> Bool { if lhs._const != rhs._const {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.constexpr: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".constexpr" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "constexpr"), - ] +extension SwiftProtoTesting_Names_MessageNames.constexpr: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".constexpr" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}constexpr\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22645,18 +17202,16 @@ extension SwiftUnittest_Names_MessageNames.constexpr: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.constexpr, rhs: SwiftUnittest_Names_MessageNames.constexpr) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.constexpr, rhs: SwiftProtoTesting_Names_MessageNames.constexpr) -> Bool { if lhs._constexpr != rhs._constexpr {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.const_cast: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".const_cast" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "const_cast"), - ] +extension SwiftProtoTesting_Names_MessageNames.const_cast: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".const_cast" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}const_cast\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22681,18 +17236,16 @@ extension SwiftUnittest_Names_MessageNames.const_cast: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.const_cast, rhs: SwiftUnittest_Names_MessageNames.const_cast) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.const_cast, rhs: SwiftProtoTesting_Names_MessageNames.const_cast) -> Bool { if lhs._constCast != rhs._constCast {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.decltype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".decltype" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "decltype"), - ] +extension SwiftProtoTesting_Names_MessageNames.decltype: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".decltype" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}decltype\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22717,18 +17270,16 @@ extension SwiftUnittest_Names_MessageNames.decltype: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.decltype, rhs: SwiftUnittest_Names_MessageNames.decltype) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.decltype, rhs: SwiftProtoTesting_Names_MessageNames.decltype) -> Bool { if lhs._decltype != rhs._decltype {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.delete: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".delete" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "delete"), - ] +extension SwiftProtoTesting_Names_MessageNames.delete: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".delete" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}delete\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22753,18 +17304,16 @@ extension SwiftUnittest_Names_MessageNames.delete: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.delete, rhs: SwiftUnittest_Names_MessageNames.delete) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.delete, rhs: SwiftProtoTesting_Names_MessageNames.delete) -> Bool { if lhs._delete != rhs._delete {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.dynamic_cast: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".dynamic_cast" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "dynamic_cast"), - ] +extension SwiftProtoTesting_Names_MessageNames.dynamic_cast: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".dynamic_cast" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}dynamic_cast\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22789,18 +17338,16 @@ extension SwiftUnittest_Names_MessageNames.dynamic_cast: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.dynamic_cast, rhs: SwiftUnittest_Names_MessageNames.dynamic_cast) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.dynamic_cast, rhs: SwiftProtoTesting_Names_MessageNames.dynamic_cast) -> Bool { if lhs._dynamicCast != rhs._dynamicCast {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.explicit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".explicit" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "explicit"), - ] +extension SwiftProtoTesting_Names_MessageNames.explicit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".explicit" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}explicit\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22825,18 +17372,16 @@ extension SwiftUnittest_Names_MessageNames.explicit: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.explicit, rhs: SwiftUnittest_Names_MessageNames.explicit) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.explicit, rhs: SwiftProtoTesting_Names_MessageNames.explicit) -> Bool { if lhs._explicit != rhs._explicit {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.export: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".export" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "export"), - ] +extension SwiftProtoTesting_Names_MessageNames.export: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".export" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}export\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22861,18 +17406,16 @@ extension SwiftUnittest_Names_MessageNames.export: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.export, rhs: SwiftUnittest_Names_MessageNames.export) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.export, rhs: SwiftProtoTesting_Names_MessageNames.export) -> Bool { if lhs._export != rhs._export {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.extern: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".extern" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extern"), - ] +extension SwiftProtoTesting_Names_MessageNames.extern: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".extern" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extern\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22897,18 +17440,16 @@ extension SwiftUnittest_Names_MessageNames.extern: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.extern, rhs: SwiftUnittest_Names_MessageNames.extern) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.extern, rhs: SwiftProtoTesting_Names_MessageNames.extern) -> Bool { if lhs._extern != rhs._extern {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.friend: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".friend" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "friend"), - ] +extension SwiftProtoTesting_Names_MessageNames.friend: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".friend" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}friend\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22933,18 +17474,16 @@ extension SwiftUnittest_Names_MessageNames.friend: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.friend, rhs: SwiftUnittest_Names_MessageNames.friend) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.friend, rhs: SwiftProtoTesting_Names_MessageNames.friend) -> Bool { if lhs._friend != rhs._friend {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.goto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".goto" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "goto"), - ] +extension SwiftProtoTesting_Names_MessageNames.goto: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".goto" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}goto\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -22969,18 +17508,16 @@ extension SwiftUnittest_Names_MessageNames.goto: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.goto, rhs: SwiftUnittest_Names_MessageNames.goto) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.goto, rhs: SwiftProtoTesting_Names_MessageNames.goto) -> Bool { if lhs._goto != rhs._goto {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.inline: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".inline" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "inline"), - ] +extension SwiftProtoTesting_Names_MessageNames.inline: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".inline" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}inline\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23005,18 +17542,16 @@ extension SwiftUnittest_Names_MessageNames.inline: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.inline, rhs: SwiftUnittest_Names_MessageNames.inline) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.inline, rhs: SwiftProtoTesting_Names_MessageNames.inline) -> Bool { if lhs._inline != rhs._inline {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.long: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".long" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "long"), - ] +extension SwiftProtoTesting_Names_MessageNames.long: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".long" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}long\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23041,18 +17576,16 @@ extension SwiftUnittest_Names_MessageNames.long: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.long, rhs: SwiftUnittest_Names_MessageNames.long) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.long, rhs: SwiftProtoTesting_Names_MessageNames.long) -> Bool { if lhs._long != rhs._long {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.mutable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".mutable" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mutable"), - ] +extension SwiftProtoTesting_Names_MessageNames.mutable: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".mutable" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mutable\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23077,18 +17610,16 @@ extension SwiftUnittest_Names_MessageNames.mutable: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.mutable, rhs: SwiftUnittest_Names_MessageNames.mutable) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.mutable, rhs: SwiftProtoTesting_Names_MessageNames.mutable) -> Bool { if lhs._mutable != rhs._mutable {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.namespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".namespace" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "namespace"), - ] +extension SwiftProtoTesting_Names_MessageNames.namespace: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".namespace" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}namespace\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23113,18 +17644,16 @@ extension SwiftUnittest_Names_MessageNames.namespace: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.namespace, rhs: SwiftUnittest_Names_MessageNames.namespace) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.namespace, rhs: SwiftProtoTesting_Names_MessageNames.namespace) -> Bool { if lhs._namespace != rhs._namespace {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.new: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".new" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "new"), - ] +extension SwiftProtoTesting_Names_MessageNames.new: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".new" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}new\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23149,18 +17678,16 @@ extension SwiftUnittest_Names_MessageNames.new: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.new, rhs: SwiftUnittest_Names_MessageNames.new) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.new, rhs: SwiftProtoTesting_Names_MessageNames.new) -> Bool { if lhs._new != rhs._new {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.noexcept: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".noexcept" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "noexcept"), - ] +extension SwiftProtoTesting_Names_MessageNames.noexcept: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".noexcept" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}noexcept\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23185,18 +17712,16 @@ extension SwiftUnittest_Names_MessageNames.noexcept: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.noexcept, rhs: SwiftUnittest_Names_MessageNames.noexcept) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.noexcept, rhs: SwiftProtoTesting_Names_MessageNames.noexcept) -> Bool { if lhs._noexcept != rhs._noexcept {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.not: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".not" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "not"), - ] +extension SwiftProtoTesting_Names_MessageNames.not: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".not" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}not\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23221,18 +17746,16 @@ extension SwiftUnittest_Names_MessageNames.not: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.not, rhs: SwiftUnittest_Names_MessageNames.not) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.not, rhs: SwiftProtoTesting_Names_MessageNames.not) -> Bool { if lhs._not != rhs._not {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.not_eq: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".not_eq" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "not_eq"), - ] +extension SwiftProtoTesting_Names_MessageNames.not_eq: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".not_eq" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}not_eq\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23257,18 +17780,16 @@ extension SwiftUnittest_Names_MessageNames.not_eq: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.not_eq, rhs: SwiftUnittest_Names_MessageNames.not_eq) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.not_eq, rhs: SwiftProtoTesting_Names_MessageNames.not_eq) -> Bool { if lhs._notEq != rhs._notEq {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.nullptr: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".nullptr" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "nullptr"), - ] +extension SwiftProtoTesting_Names_MessageNames.nullptr: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".nullptr" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}nullptr\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23293,18 +17814,16 @@ extension SwiftUnittest_Names_MessageNames.nullptr: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.nullptr, rhs: SwiftUnittest_Names_MessageNames.nullptr) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.nullptr, rhs: SwiftProtoTesting_Names_MessageNames.nullptr) -> Bool { if lhs._nullptr != rhs._nullptr {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.or: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".or" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "or"), - ] +extension SwiftProtoTesting_Names_MessageNames.or: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".or" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}or\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23329,18 +17848,16 @@ extension SwiftUnittest_Names_MessageNames.or: SwiftProtobuf.Message, SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.or, rhs: SwiftUnittest_Names_MessageNames.or) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.or, rhs: SwiftProtoTesting_Names_MessageNames.or) -> Bool { if lhs._or != rhs._or {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.or_eq: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".or_eq" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "or_eq"), - ] +extension SwiftProtoTesting_Names_MessageNames.or_eq: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".or_eq" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}or_eq\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23365,18 +17882,16 @@ extension SwiftUnittest_Names_MessageNames.or_eq: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.or_eq, rhs: SwiftUnittest_Names_MessageNames.or_eq) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.or_eq, rhs: SwiftProtoTesting_Names_MessageNames.or_eq) -> Bool { if lhs._orEq != rhs._orEq {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.protected: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".protected" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "protected"), - ] +extension SwiftProtoTesting_Names_MessageNames.protected: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".protected" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}protected\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23401,18 +17916,16 @@ extension SwiftUnittest_Names_MessageNames.protected: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.protected, rhs: SwiftUnittest_Names_MessageNames.protected) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.protected, rhs: SwiftProtoTesting_Names_MessageNames.protected) -> Bool { if lhs._protected != rhs._protected {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.register: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".register" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "register"), - ] +extension SwiftProtoTesting_Names_MessageNames.register: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".register" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}register\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23437,18 +17950,16 @@ extension SwiftUnittest_Names_MessageNames.register: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.register, rhs: SwiftUnittest_Names_MessageNames.register) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.register, rhs: SwiftProtoTesting_Names_MessageNames.register) -> Bool { if lhs._register != rhs._register {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.reinterpret_cast: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".reinterpret_cast" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "reinterpret_cast"), - ] +extension SwiftProtoTesting_Names_MessageNames.reinterpret_cast: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".reinterpret_cast" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}reinterpret_cast\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23473,18 +17984,16 @@ extension SwiftUnittest_Names_MessageNames.reinterpret_cast: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.reinterpret_cast, rhs: SwiftUnittest_Names_MessageNames.reinterpret_cast) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.reinterpret_cast, rhs: SwiftProtoTesting_Names_MessageNames.reinterpret_cast) -> Bool { if lhs._reinterpretCast != rhs._reinterpretCast {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.short: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".short" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "short"), - ] +extension SwiftProtoTesting_Names_MessageNames.short: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".short" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}short\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23509,18 +18018,16 @@ extension SwiftUnittest_Names_MessageNames.short: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.short, rhs: SwiftUnittest_Names_MessageNames.short) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.short, rhs: SwiftProtoTesting_Names_MessageNames.short) -> Bool { if lhs._short != rhs._short {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.signed: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".signed" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "signed"), - ] +extension SwiftProtoTesting_Names_MessageNames.signed: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".signed" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}signed\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23545,18 +18052,16 @@ extension SwiftUnittest_Names_MessageNames.signed: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.signed, rhs: SwiftUnittest_Names_MessageNames.signed) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.signed, rhs: SwiftProtoTesting_Names_MessageNames.signed) -> Bool { if lhs._signed != rhs._signed {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.sizeof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".sizeof" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sizeof"), - ] +extension SwiftProtoTesting_Names_MessageNames.sizeof: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".sizeof" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sizeof\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23581,18 +18086,16 @@ extension SwiftUnittest_Names_MessageNames.sizeof: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.sizeof, rhs: SwiftUnittest_Names_MessageNames.sizeof) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.sizeof, rhs: SwiftProtoTesting_Names_MessageNames.sizeof) -> Bool { if lhs._sizeof != rhs._sizeof {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.static_assert: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".static_assert" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "static_assert"), - ] +extension SwiftProtoTesting_Names_MessageNames.static_assert: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".static_assert" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}static_assert\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23617,18 +18120,16 @@ extension SwiftUnittest_Names_MessageNames.static_assert: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.static_assert, rhs: SwiftUnittest_Names_MessageNames.static_assert) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.static_assert, rhs: SwiftProtoTesting_Names_MessageNames.static_assert) -> Bool { if lhs._staticAssert != rhs._staticAssert {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.static_cast: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".static_cast" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "static_cast"), - ] +extension SwiftProtoTesting_Names_MessageNames.static_cast: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".static_cast" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}static_cast\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23653,18 +18154,16 @@ extension SwiftUnittest_Names_MessageNames.static_cast: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.static_cast, rhs: SwiftUnittest_Names_MessageNames.static_cast) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.static_cast, rhs: SwiftProtoTesting_Names_MessageNames.static_cast) -> Bool { if lhs._staticCast != rhs._staticCast {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.template: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".template" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "template"), - ] +extension SwiftProtoTesting_Names_MessageNames.template: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".template" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}template\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23689,18 +18188,16 @@ extension SwiftUnittest_Names_MessageNames.template: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.template, rhs: SwiftUnittest_Names_MessageNames.template) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.template, rhs: SwiftProtoTesting_Names_MessageNames.template) -> Bool { if lhs._template != rhs._template {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.this: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".this" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "this"), - ] +extension SwiftProtoTesting_Names_MessageNames.this: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".this" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}this\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23725,18 +18222,16 @@ extension SwiftUnittest_Names_MessageNames.this: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.this, rhs: SwiftUnittest_Names_MessageNames.this) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.this, rhs: SwiftProtoTesting_Names_MessageNames.this) -> Bool { if lhs._this != rhs._this {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.thread_local: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".thread_local" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "thread_local"), - ] +extension SwiftProtoTesting_Names_MessageNames.thread_local: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".thread_local" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}thread_local\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23761,18 +18256,16 @@ extension SwiftUnittest_Names_MessageNames.thread_local: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.thread_local, rhs: SwiftUnittest_Names_MessageNames.thread_local) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.thread_local, rhs: SwiftProtoTesting_Names_MessageNames.thread_local) -> Bool { if lhs._threadLocal != rhs._threadLocal {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.typedef: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".typedef" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typedef"), - ] +extension SwiftProtoTesting_Names_MessageNames.typedef: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".typedef" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typedef\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23797,18 +18290,16 @@ extension SwiftUnittest_Names_MessageNames.typedef: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.typedef, rhs: SwiftUnittest_Names_MessageNames.typedef) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.typedef, rhs: SwiftProtoTesting_Names_MessageNames.typedef) -> Bool { if lhs._typedef != rhs._typedef {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.typeid: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".typeid" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typeid"), - ] +extension SwiftProtoTesting_Names_MessageNames.typeid: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".typeid" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typeid\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23833,18 +18324,16 @@ extension SwiftUnittest_Names_MessageNames.typeid: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.typeid, rhs: SwiftUnittest_Names_MessageNames.typeid) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.typeid, rhs: SwiftProtoTesting_Names_MessageNames.typeid) -> Bool { if lhs._typeid != rhs._typeid {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.typename: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".typename" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "typename"), - ] +extension SwiftProtoTesting_Names_MessageNames.typename: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".typename" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}typename\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23869,18 +18358,16 @@ extension SwiftUnittest_Names_MessageNames.typename: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.typename, rhs: SwiftUnittest_Names_MessageNames.typename) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.typename, rhs: SwiftProtoTesting_Names_MessageNames.typename) -> Bool { if lhs._typename != rhs._typename {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.union: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".union" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "union"), - ] +extension SwiftProtoTesting_Names_MessageNames.union: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".union" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}union\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23905,18 +18392,16 @@ extension SwiftUnittest_Names_MessageNames.union: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.union, rhs: SwiftUnittest_Names_MessageNames.union) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.union, rhs: SwiftProtoTesting_Names_MessageNames.union) -> Bool { if lhs._union != rhs._union {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.unsigned: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".unsigned" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "unsigned"), - ] +extension SwiftProtoTesting_Names_MessageNames.unsigned: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".unsigned" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unsigned\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23941,18 +18426,16 @@ extension SwiftUnittest_Names_MessageNames.unsigned: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.unsigned, rhs: SwiftUnittest_Names_MessageNames.unsigned) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.unsigned, rhs: SwiftProtoTesting_Names_MessageNames.unsigned) -> Bool { if lhs._unsigned != rhs._unsigned {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.using: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".using" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "using"), - ] +extension SwiftProtoTesting_Names_MessageNames.using: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".using" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}using\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -23977,18 +18460,16 @@ extension SwiftUnittest_Names_MessageNames.using: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.using, rhs: SwiftUnittest_Names_MessageNames.using) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.using, rhs: SwiftProtoTesting_Names_MessageNames.using) -> Bool { if lhs._using != rhs._using {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.virtual: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".virtual" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "virtual"), - ] +extension SwiftProtoTesting_Names_MessageNames.virtual: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".virtual" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}virtual\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24013,18 +18494,16 @@ extension SwiftUnittest_Names_MessageNames.virtual: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.virtual, rhs: SwiftUnittest_Names_MessageNames.virtual) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.virtual, rhs: SwiftProtoTesting_Names_MessageNames.virtual) -> Bool { if lhs._virtual != rhs._virtual {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.void: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".void" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "void"), - ] +extension SwiftProtoTesting_Names_MessageNames.void: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".void" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}void\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24049,18 +18528,16 @@ extension SwiftUnittest_Names_MessageNames.void: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.void, rhs: SwiftUnittest_Names_MessageNames.void) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.void, rhs: SwiftProtoTesting_Names_MessageNames.void) -> Bool { if lhs._void != rhs._void {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.volatile: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".volatile" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "volatile"), - ] +extension SwiftProtoTesting_Names_MessageNames.volatile: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".volatile" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}volatile\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24085,18 +18562,16 @@ extension SwiftUnittest_Names_MessageNames.volatile: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.volatile, rhs: SwiftUnittest_Names_MessageNames.volatile) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.volatile, rhs: SwiftProtoTesting_Names_MessageNames.volatile) -> Bool { if lhs._volatile != rhs._volatile {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.wchar_t: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".wchar_t" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "wchar_t"), - ] +extension SwiftProtoTesting_Names_MessageNames.wchar_t: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".wchar_t" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}wchar_t\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24121,18 +18596,16 @@ extension SwiftUnittest_Names_MessageNames.wchar_t: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.wchar_t, rhs: SwiftUnittest_Names_MessageNames.wchar_t) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.wchar_t, rhs: SwiftProtoTesting_Names_MessageNames.wchar_t) -> Bool { if lhs._wcharT != rhs._wcharT {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.xor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".xor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "xor"), - ] +extension SwiftProtoTesting_Names_MessageNames.xor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".xor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}xor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24157,18 +18630,16 @@ extension SwiftUnittest_Names_MessageNames.xor: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.xor, rhs: SwiftUnittest_Names_MessageNames.xor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.xor, rhs: SwiftProtoTesting_Names_MessageNames.xor) -> Bool { if lhs._xor != rhs._xor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.xor_eq: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".xor_eq" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "xor_eq"), - ] +extension SwiftProtoTesting_Names_MessageNames.xor_eq: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".xor_eq" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}xor_eq\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24193,18 +18664,16 @@ extension SwiftUnittest_Names_MessageNames.xor_eq: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.xor_eq, rhs: SwiftUnittest_Names_MessageNames.xor_eq) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.xor_eq, rhs: SwiftProtoTesting_Names_MessageNames.xor_eq) -> Bool { if lhs._xorEq != rhs._xorEq {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.restrict: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".restrict" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "restrict"), - ] +extension SwiftProtoTesting_Names_MessageNames.restrict: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".restrict" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}restrict\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24229,18 +18698,16 @@ extension SwiftUnittest_Names_MessageNames.restrict: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.restrict, rhs: SwiftUnittest_Names_MessageNames.restrict) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.restrict, rhs: SwiftProtoTesting_Names_MessageNames.restrict) -> Bool { if lhs._restrict != rhs._restrict {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Category: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Category" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Category"), - ] +extension SwiftProtoTesting_Names_MessageNames.Category: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Category" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Category\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24265,18 +18732,16 @@ extension SwiftUnittest_Names_MessageNames.Category: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Category, rhs: SwiftUnittest_Names_MessageNames.Category) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Category, rhs: SwiftProtoTesting_Names_MessageNames.Category) -> Bool { if lhs._category != rhs._category {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Ivar: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Ivar" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Ivar"), - ] +extension SwiftProtoTesting_Names_MessageNames.Ivar: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Ivar" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Ivar\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24301,18 +18766,16 @@ extension SwiftUnittest_Names_MessageNames.Ivar: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Ivar, rhs: SwiftUnittest_Names_MessageNames.Ivar) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Ivar, rhs: SwiftProtoTesting_Names_MessageNames.Ivar) -> Bool { if lhs._ivar != rhs._ivar {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Method: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Method" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Method"), - ] +extension SwiftProtoTesting_Names_MessageNames.Method: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Method" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Method\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24337,18 +18800,16 @@ extension SwiftUnittest_Names_MessageNames.Method: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Method, rhs: SwiftUnittest_Names_MessageNames.Method) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Method, rhs: SwiftProtoTesting_Names_MessageNames.Method) -> Bool { if lhs._method != rhs._method {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.finalize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".finalize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "finalize"), - ] +extension SwiftProtoTesting_Names_MessageNames.finalize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".finalize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}finalize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24373,18 +18834,16 @@ extension SwiftUnittest_Names_MessageNames.finalize: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.finalize, rhs: SwiftUnittest_Names_MessageNames.finalize) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.finalize, rhs: SwiftProtoTesting_Names_MessageNames.finalize) -> Bool { if lhs._finalize != rhs._finalize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.hash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".hash" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "hash"), - ] +extension SwiftProtoTesting_Names_MessageNames.hash: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".hash" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}hash\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24409,18 +18868,16 @@ extension SwiftUnittest_Names_MessageNames.hash: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.hash, rhs: SwiftUnittest_Names_MessageNames.hash) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.hash, rhs: SwiftProtoTesting_Names_MessageNames.hash) -> Bool { if lhs._hash != rhs._hash {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.dealloc: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".dealloc" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "dealloc"), - ] +extension SwiftProtoTesting_Names_MessageNames.dealloc: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".dealloc" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}dealloc\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24445,18 +18902,16 @@ extension SwiftUnittest_Names_MessageNames.dealloc: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.dealloc, rhs: SwiftUnittest_Names_MessageNames.dealloc) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.dealloc, rhs: SwiftProtoTesting_Names_MessageNames.dealloc) -> Bool { if lhs._dealloc != rhs._dealloc {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.superclass: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".superclass" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "superclass"), - ] +extension SwiftProtoTesting_Names_MessageNames.superclass: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".superclass" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}superclass\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24481,18 +18936,16 @@ extension SwiftUnittest_Names_MessageNames.superclass: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.superclass, rhs: SwiftUnittest_Names_MessageNames.superclass) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.superclass, rhs: SwiftProtoTesting_Names_MessageNames.superclass) -> Bool { if lhs._superclass != rhs._superclass {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.retain: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".retain" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "retain"), - ] +extension SwiftProtoTesting_Names_MessageNames.retain: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".retain" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}retain\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24517,18 +18970,16 @@ extension SwiftUnittest_Names_MessageNames.retain: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.retain, rhs: SwiftUnittest_Names_MessageNames.retain) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.retain, rhs: SwiftProtoTesting_Names_MessageNames.retain) -> Bool { if lhs._retain != rhs._retain {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.release: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".release" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "release"), - ] +extension SwiftProtoTesting_Names_MessageNames.release: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".release" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}release\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24553,18 +19004,16 @@ extension SwiftUnittest_Names_MessageNames.release: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.release, rhs: SwiftUnittest_Names_MessageNames.release) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.release, rhs: SwiftProtoTesting_Names_MessageNames.release) -> Bool { if lhs._release != rhs._release {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.autorelease: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".autorelease" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "autorelease"), - ] +extension SwiftProtoTesting_Names_MessageNames.autorelease: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".autorelease" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}autorelease\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24589,18 +19038,16 @@ extension SwiftUnittest_Names_MessageNames.autorelease: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.autorelease, rhs: SwiftUnittest_Names_MessageNames.autorelease) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.autorelease, rhs: SwiftProtoTesting_Names_MessageNames.autorelease) -> Bool { if lhs._autorelease != rhs._autorelease {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.retainCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".retainCount" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "retainCount"), - ] +extension SwiftProtoTesting_Names_MessageNames.retainCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".retainCount" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}retainCount\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24625,18 +19072,16 @@ extension SwiftUnittest_Names_MessageNames.retainCount: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.retainCount, rhs: SwiftUnittest_Names_MessageNames.retainCount) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.retainCount, rhs: SwiftProtoTesting_Names_MessageNames.retainCount) -> Bool { if lhs._retainCount != rhs._retainCount {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.zone: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".zone" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "zone"), - ] +extension SwiftProtoTesting_Names_MessageNames.zone: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".zone" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}zone\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24661,18 +19106,16 @@ extension SwiftUnittest_Names_MessageNames.zone: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.zone, rhs: SwiftUnittest_Names_MessageNames.zone) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.zone, rhs: SwiftProtoTesting_Names_MessageNames.zone) -> Bool { if lhs._zone != rhs._zone {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.isProxy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".isProxy" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "isProxy"), - ] +extension SwiftProtoTesting_Names_MessageNames.isProxy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".isProxy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isProxy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24697,18 +19140,16 @@ extension SwiftUnittest_Names_MessageNames.isProxy: SwiftProtobuf.Message, Swift try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.isProxy, rhs: SwiftUnittest_Names_MessageNames.isProxy) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.isProxy, rhs: SwiftProtoTesting_Names_MessageNames.isProxy) -> Bool { if lhs._isProxy != rhs._isProxy {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.copy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".copy" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "copy"), - ] +extension SwiftProtoTesting_Names_MessageNames.copy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".copy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}copy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24733,18 +19174,16 @@ extension SwiftUnittest_Names_MessageNames.copy: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.copy, rhs: SwiftUnittest_Names_MessageNames.copy) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.copy, rhs: SwiftProtoTesting_Names_MessageNames.copy) -> Bool { if lhs._copy != rhs._copy {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.mutableCopy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".mutableCopy" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "mutableCopy"), - ] +extension SwiftProtoTesting_Names_MessageNames.mutableCopy: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".mutableCopy" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}mutableCopy\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24769,18 +19208,16 @@ extension SwiftUnittest_Names_MessageNames.mutableCopy: SwiftProtobuf.Message, S try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.mutableCopy, rhs: SwiftUnittest_Names_MessageNames.mutableCopy) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.mutableCopy, rhs: SwiftProtoTesting_Names_MessageNames.mutableCopy) -> Bool { if lhs._mutableCopy != rhs._mutableCopy {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.classForCoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".classForCoder" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "classForCoder"), - ] +extension SwiftProtoTesting_Names_MessageNames.classForCoder: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".classForCoder" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}classForCoder\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24805,18 +19242,16 @@ extension SwiftUnittest_Names_MessageNames.classForCoder: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.classForCoder, rhs: SwiftUnittest_Names_MessageNames.classForCoder) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.classForCoder, rhs: SwiftProtoTesting_Names_MessageNames.classForCoder) -> Bool { if lhs._classForCoder != rhs._classForCoder {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.clear: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".clear" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "clear"), - ] +extension SwiftProtoTesting_Names_MessageNames.clear: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".clear" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}clear\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24841,18 +19276,16 @@ extension SwiftUnittest_Names_MessageNames.clear: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.clear, rhs: SwiftUnittest_Names_MessageNames.clear) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.clear, rhs: SwiftProtoTesting_Names_MessageNames.clear) -> Bool { if lhs._clear != rhs._clear {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.data: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".data" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "data"), - ] +extension SwiftProtoTesting_Names_MessageNames.data: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}data\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24877,18 +19310,16 @@ extension SwiftUnittest_Names_MessageNames.data: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.data, rhs: SwiftUnittest_Names_MessageNames.data) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.data, rhs: SwiftProtoTesting_Names_MessageNames.data) -> Bool { if lhs._data != rhs._data {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.delimitedData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".delimitedData" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "delimitedData"), - ] +extension SwiftProtoTesting_Names_MessageNames.delimitedData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".delimitedData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}delimitedData\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24913,18 +19344,16 @@ extension SwiftUnittest_Names_MessageNames.delimitedData: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.delimitedData, rhs: SwiftUnittest_Names_MessageNames.delimitedData) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.delimitedData, rhs: SwiftProtoTesting_Names_MessageNames.delimitedData) -> Bool { if lhs._delimitedData != rhs._delimitedData {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.descriptor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".descriptor" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "descriptor"), - ] +extension SwiftProtoTesting_Names_MessageNames.descriptor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".descriptor" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}descriptor\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24949,18 +19378,16 @@ extension SwiftUnittest_Names_MessageNames.descriptor: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.descriptor, rhs: SwiftUnittest_Names_MessageNames.descriptor) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.descriptor, rhs: SwiftProtoTesting_Names_MessageNames.descriptor) -> Bool { if lhs._descriptor != rhs._descriptor {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.extensionRegistry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".extensionRegistry" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extensionRegistry"), - ] +extension SwiftProtoTesting_Names_MessageNames.extensionRegistry: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".extensionRegistry" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extensionRegistry\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -24985,18 +19412,16 @@ extension SwiftUnittest_Names_MessageNames.extensionRegistry: SwiftProtobuf.Mess try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.extensionRegistry, rhs: SwiftUnittest_Names_MessageNames.extensionRegistry) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.extensionRegistry, rhs: SwiftProtoTesting_Names_MessageNames.extensionRegistry) -> Bool { if lhs._extensionRegistry != rhs._extensionRegistry {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.extensionsCurrentlySet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".extensionsCurrentlySet" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "extensionsCurrentlySet"), - ] +extension SwiftProtoTesting_Names_MessageNames.extensionsCurrentlySet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".extensionsCurrentlySet" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}extensionsCurrentlySet\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25021,18 +19446,16 @@ extension SwiftUnittest_Names_MessageNames.extensionsCurrentlySet: SwiftProtobuf try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.extensionsCurrentlySet, rhs: SwiftUnittest_Names_MessageNames.extensionsCurrentlySet) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.extensionsCurrentlySet, rhs: SwiftProtoTesting_Names_MessageNames.extensionsCurrentlySet) -> Bool { if lhs._extensionsCurrentlySet != rhs._extensionsCurrentlySet {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.isInitializedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".isInitialized" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "isInitialized"), - ] +extension SwiftProtoTesting_Names_MessageNames.isInitializedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".isInitialized" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}isInitialized\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25057,18 +19480,16 @@ extension SwiftUnittest_Names_MessageNames.isInitializedMessage: SwiftProtobuf.M try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.isInitializedMessage, rhs: SwiftUnittest_Names_MessageNames.isInitializedMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.isInitializedMessage, rhs: SwiftProtoTesting_Names_MessageNames.isInitializedMessage) -> Bool { if lhs._isInitialized_p != rhs._isInitialized_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.serializedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".serializedSize" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "serializedSize"), - ] +extension SwiftProtoTesting_Names_MessageNames.serializedSize: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".serializedSize" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}serializedSize\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25093,18 +19514,16 @@ extension SwiftUnittest_Names_MessageNames.serializedSize: SwiftProtobuf.Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.serializedSize, rhs: SwiftUnittest_Names_MessageNames.serializedSize) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.serializedSize, rhs: SwiftProtoTesting_Names_MessageNames.serializedSize) -> Bool { if lhs._serializedSize != rhs._serializedSize {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.sortedExtensionsInUse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".sortedExtensionsInUse" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "sortedExtensionsInUse"), - ] +extension SwiftProtoTesting_Names_MessageNames.sortedExtensionsInUse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".sortedExtensionsInUse" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}sortedExtensionsInUse\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25129,18 +19548,16 @@ extension SwiftUnittest_Names_MessageNames.sortedExtensionsInUse: SwiftProtobuf. try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.sortedExtensionsInUse, rhs: SwiftUnittest_Names_MessageNames.sortedExtensionsInUse) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.sortedExtensionsInUse, rhs: SwiftProtoTesting_Names_MessageNames.sortedExtensionsInUse) -> Bool { if lhs._sortedExtensionsInUse != rhs._sortedExtensionsInUse {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.unknownFieldsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".unknownFields" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "unknownFields"), - ] +extension SwiftProtoTesting_Names_MessageNames.unknownFieldsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".unknownFields" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}unknownFields\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25165,18 +19582,16 @@ extension SwiftUnittest_Names_MessageNames.unknownFieldsMessage: SwiftProtobuf.M try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.unknownFieldsMessage, rhs: SwiftUnittest_Names_MessageNames.unknownFieldsMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.unknownFieldsMessage, rhs: SwiftProtoTesting_Names_MessageNames.unknownFieldsMessage) -> Bool { if lhs._unknownFields_p != rhs._unknownFields_p {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Fixed: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Fixed" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Fixed"), - ] +extension SwiftProtoTesting_Names_MessageNames.Fixed: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Fixed" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Fixed\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25201,18 +19616,16 @@ extension SwiftUnittest_Names_MessageNames.Fixed: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Fixed, rhs: SwiftUnittest_Names_MessageNames.Fixed) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Fixed, rhs: SwiftProtoTesting_Names_MessageNames.Fixed) -> Bool { if lhs._fixed != rhs._fixed {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Fract: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Fract" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Fract"), - ] +extension SwiftProtoTesting_Names_MessageNames.Fract: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Fract" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Fract\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25237,18 +19650,16 @@ extension SwiftUnittest_Names_MessageNames.Fract: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Fract, rhs: SwiftUnittest_Names_MessageNames.Fract) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Fract, rhs: SwiftProtoTesting_Names_MessageNames.Fract) -> Bool { if lhs._fract != rhs._fract {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Size: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Size" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Size"), - ] +extension SwiftProtoTesting_Names_MessageNames.Size: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Size" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Size\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25273,18 +19684,16 @@ extension SwiftUnittest_Names_MessageNames.Size: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Size, rhs: SwiftUnittest_Names_MessageNames.Size) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Size, rhs: SwiftProtoTesting_Names_MessageNames.Size) -> Bool { if lhs._size != rhs._size {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.LogicalAddress: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".LogicalAddress" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "LogicalAddress"), - ] +extension SwiftProtoTesting_Names_MessageNames.LogicalAddress: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".LogicalAddress" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}LogicalAddress\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25309,18 +19718,16 @@ extension SwiftUnittest_Names_MessageNames.LogicalAddress: SwiftProtobuf.Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.LogicalAddress, rhs: SwiftUnittest_Names_MessageNames.LogicalAddress) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.LogicalAddress, rhs: SwiftProtoTesting_Names_MessageNames.LogicalAddress) -> Bool { if lhs._logicalAddress != rhs._logicalAddress {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.PhysicalAddress: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".PhysicalAddress" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "PhysicalAddress"), - ] +extension SwiftProtoTesting_Names_MessageNames.PhysicalAddress: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".PhysicalAddress" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}PhysicalAddress\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25345,18 +19752,16 @@ extension SwiftUnittest_Names_MessageNames.PhysicalAddress: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.PhysicalAddress, rhs: SwiftUnittest_Names_MessageNames.PhysicalAddress) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.PhysicalAddress, rhs: SwiftProtoTesting_Names_MessageNames.PhysicalAddress) -> Bool { if lhs._physicalAddress != rhs._physicalAddress {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.ByteCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".ByteCount" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ByteCount"), - ] +extension SwiftProtoTesting_Names_MessageNames.ByteCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".ByteCount" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ByteCount\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25381,18 +19786,16 @@ extension SwiftUnittest_Names_MessageNames.ByteCount: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.ByteCount, rhs: SwiftUnittest_Names_MessageNames.ByteCount) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ByteCount, rhs: SwiftProtoTesting_Names_MessageNames.ByteCount) -> Bool { if lhs._byteCount != rhs._byteCount {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.ByteOffset: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".ByteOffset" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ByteOffset"), - ] +extension SwiftProtoTesting_Names_MessageNames.ByteOffset: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".ByteOffset" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ByteOffset\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25417,18 +19820,16 @@ extension SwiftUnittest_Names_MessageNames.ByteOffset: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.ByteOffset, rhs: SwiftUnittest_Names_MessageNames.ByteOffset) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ByteOffset, rhs: SwiftProtoTesting_Names_MessageNames.ByteOffset) -> Bool { if lhs._byteOffset != rhs._byteOffset {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Duration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Duration" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Duration"), - ] +extension SwiftProtoTesting_Names_MessageNames.Duration: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Duration" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Duration\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25453,18 +19854,16 @@ extension SwiftUnittest_Names_MessageNames.Duration: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Duration, rhs: SwiftUnittest_Names_MessageNames.Duration) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Duration, rhs: SwiftProtoTesting_Names_MessageNames.Duration) -> Bool { if lhs._duration != rhs._duration {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.AbsoluteTime: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".AbsoluteTime" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "AbsoluteTime"), - ] +extension SwiftProtoTesting_Names_MessageNames.AbsoluteTime: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".AbsoluteTime" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}AbsoluteTime\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25489,18 +19888,16 @@ extension SwiftUnittest_Names_MessageNames.AbsoluteTime: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.AbsoluteTime, rhs: SwiftUnittest_Names_MessageNames.AbsoluteTime) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.AbsoluteTime, rhs: SwiftProtoTesting_Names_MessageNames.AbsoluteTime) -> Bool { if lhs._absoluteTime != rhs._absoluteTime {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.OptionBits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".OptionBits" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "OptionBits"), - ] +extension SwiftProtoTesting_Names_MessageNames.OptionBits: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".OptionBits" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OptionBits\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25525,18 +19922,16 @@ extension SwiftUnittest_Names_MessageNames.OptionBits: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.OptionBits, rhs: SwiftUnittest_Names_MessageNames.OptionBits) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.OptionBits, rhs: SwiftProtoTesting_Names_MessageNames.OptionBits) -> Bool { if lhs._optionBits != rhs._optionBits {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.ItemCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".ItemCount" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ItemCount"), - ] +extension SwiftProtoTesting_Names_MessageNames.ItemCount: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".ItemCount" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ItemCount\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25561,18 +19956,16 @@ extension SwiftUnittest_Names_MessageNames.ItemCount: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.ItemCount, rhs: SwiftUnittest_Names_MessageNames.ItemCount) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ItemCount, rhs: SwiftProtoTesting_Names_MessageNames.ItemCount) -> Bool { if lhs._itemCount != rhs._itemCount {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.PBVersion: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".PBVersion" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "PBVersion"), - ] +extension SwiftProtoTesting_Names_MessageNames.PBVersion: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".PBVersion" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}PBVersion\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25597,18 +19990,16 @@ extension SwiftUnittest_Names_MessageNames.PBVersion: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.PBVersion, rhs: SwiftUnittest_Names_MessageNames.PBVersion) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.PBVersion, rhs: SwiftProtoTesting_Names_MessageNames.PBVersion) -> Bool { if lhs._pbversion != rhs._pbversion {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.ScriptCode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".ScriptCode" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ScriptCode"), - ] +extension SwiftProtoTesting_Names_MessageNames.ScriptCode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".ScriptCode" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ScriptCode\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25633,18 +20024,16 @@ extension SwiftUnittest_Names_MessageNames.ScriptCode: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.ScriptCode, rhs: SwiftUnittest_Names_MessageNames.ScriptCode) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ScriptCode, rhs: SwiftProtoTesting_Names_MessageNames.ScriptCode) -> Bool { if lhs._scriptCode != rhs._scriptCode {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.LangCode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".LangCode" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "LangCode"), - ] +extension SwiftProtoTesting_Names_MessageNames.LangCode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".LangCode" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}LangCode\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25669,18 +20058,16 @@ extension SwiftUnittest_Names_MessageNames.LangCode: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.LangCode, rhs: SwiftUnittest_Names_MessageNames.LangCode) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.LangCode, rhs: SwiftProtoTesting_Names_MessageNames.LangCode) -> Bool { if lhs._langCode != rhs._langCode {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.RegionCode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".RegionCode" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "RegionCode"), - ] +extension SwiftProtoTesting_Names_MessageNames.RegionCode: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".RegionCode" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}RegionCode\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25705,18 +20092,16 @@ extension SwiftUnittest_Names_MessageNames.RegionCode: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.RegionCode, rhs: SwiftUnittest_Names_MessageNames.RegionCode) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.RegionCode, rhs: SwiftProtoTesting_Names_MessageNames.RegionCode) -> Bool { if lhs._regionCode != rhs._regionCode {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.OSType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".OSType" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "OSType"), - ] +extension SwiftProtoTesting_Names_MessageNames.OSType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".OSType" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}OSType\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25741,18 +20126,16 @@ extension SwiftUnittest_Names_MessageNames.OSType: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.OSType, rhs: SwiftUnittest_Names_MessageNames.OSType) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.OSType, rhs: SwiftProtoTesting_Names_MessageNames.OSType) -> Bool { if lhs._ostype != rhs._ostype {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.ProcessSerialNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".ProcessSerialNumber" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "ProcessSerialNumber"), - ] +extension SwiftProtoTesting_Names_MessageNames.ProcessSerialNumber: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".ProcessSerialNumber" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}ProcessSerialNumber\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25777,18 +20160,16 @@ extension SwiftUnittest_Names_MessageNames.ProcessSerialNumber: SwiftProtobuf.Me try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.ProcessSerialNumber, rhs: SwiftUnittest_Names_MessageNames.ProcessSerialNumber) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ProcessSerialNumber, rhs: SwiftProtoTesting_Names_MessageNames.ProcessSerialNumber) -> Bool { if lhs._processSerialNumber != rhs._processSerialNumber {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Point: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Point" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Point"), - ] +extension SwiftProtoTesting_Names_MessageNames.Point: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Point" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Point\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25813,18 +20194,16 @@ extension SwiftUnittest_Names_MessageNames.Point: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Point, rhs: SwiftUnittest_Names_MessageNames.Point) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Point, rhs: SwiftProtoTesting_Names_MessageNames.Point) -> Bool { if lhs._point != rhs._point {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Rect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Rect" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Rect"), - ] +extension SwiftProtoTesting_Names_MessageNames.Rect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Rect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Rect\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25849,18 +20228,16 @@ extension SwiftUnittest_Names_MessageNames.Rect: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Rect, rhs: SwiftUnittest_Names_MessageNames.Rect) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Rect, rhs: SwiftProtoTesting_Names_MessageNames.Rect) -> Bool { if lhs._rect != rhs._rect {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.FixedPoint: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".FixedPoint" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FixedPoint"), - ] +extension SwiftProtoTesting_Names_MessageNames.FixedPoint: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".FixedPoint" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FixedPoint\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25885,18 +20262,16 @@ extension SwiftUnittest_Names_MessageNames.FixedPoint: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.FixedPoint, rhs: SwiftUnittest_Names_MessageNames.FixedPoint) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.FixedPoint, rhs: SwiftProtoTesting_Names_MessageNames.FixedPoint) -> Bool { if lhs._fixedPoint != rhs._fixedPoint {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.FixedRect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".FixedRect" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "FixedRect"), - ] +extension SwiftProtoTesting_Names_MessageNames.FixedRect: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".FixedRect" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}FixedRect\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25921,18 +20296,16 @@ extension SwiftUnittest_Names_MessageNames.FixedRect: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.FixedRect, rhs: SwiftUnittest_Names_MessageNames.FixedRect) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.FixedRect, rhs: SwiftProtoTesting_Names_MessageNames.FixedRect) -> Bool { if lhs._fixedRect != rhs._fixedRect {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Style: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Style" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Style"), - ] +extension SwiftProtoTesting_Names_MessageNames.Style: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Style" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Style\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25957,18 +20330,16 @@ extension SwiftUnittest_Names_MessageNames.Style: SwiftProtobuf.Message, SwiftPr try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Style, rhs: SwiftUnittest_Names_MessageNames.Style) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Style, rhs: SwiftProtoTesting_Names_MessageNames.Style) -> Bool { if lhs._style != rhs._style {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.StyleParameter: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".StyleParameter" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "StyleParameter"), - ] +extension SwiftProtoTesting_Names_MessageNames.StyleParameter: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".StyleParameter" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}StyleParameter\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -25993,18 +20364,16 @@ extension SwiftUnittest_Names_MessageNames.StyleParameter: SwiftProtobuf.Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.StyleParameter, rhs: SwiftUnittest_Names_MessageNames.StyleParameter) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.StyleParameter, rhs: SwiftProtoTesting_Names_MessageNames.StyleParameter) -> Bool { if lhs._styleParameter != rhs._styleParameter {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.StyleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".StyleField" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "StyleField"), - ] +extension SwiftProtoTesting_Names_MessageNames.StyleField: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".StyleField" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}StyleField\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26029,18 +20398,16 @@ extension SwiftUnittest_Names_MessageNames.StyleField: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.StyleField, rhs: SwiftUnittest_Names_MessageNames.StyleField) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.StyleField, rhs: SwiftProtoTesting_Names_MessageNames.StyleField) -> Bool { if lhs._styleField != rhs._styleField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.TimeScale: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".TimeScale" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TimeScale"), - ] +extension SwiftProtoTesting_Names_MessageNames.TimeScale: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".TimeScale" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}TimeScale\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26065,18 +20432,16 @@ extension SwiftUnittest_Names_MessageNames.TimeScale: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.TimeScale, rhs: SwiftUnittest_Names_MessageNames.TimeScale) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.TimeScale, rhs: SwiftProtoTesting_Names_MessageNames.TimeScale) -> Bool { if lhs._timeScale != rhs._timeScale {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.TimeBase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".TimeBase" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TimeBase"), - ] +extension SwiftProtoTesting_Names_MessageNames.TimeBase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".TimeBase" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}TimeBase\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26101,18 +20466,16 @@ extension SwiftUnittest_Names_MessageNames.TimeBase: SwiftProtobuf.Message, Swif try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.TimeBase, rhs: SwiftUnittest_Names_MessageNames.TimeBase) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.TimeBase, rhs: SwiftProtoTesting_Names_MessageNames.TimeBase) -> Bool { if lhs._timeBase != rhs._timeBase {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.TimeRecord: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".TimeRecord" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "TimeRecord"), - ] +extension SwiftProtoTesting_Names_MessageNames.TimeRecord: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".TimeRecord" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}TimeRecord\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26137,18 +20500,16 @@ extension SwiftUnittest_Names_MessageNames.TimeRecord: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.TimeRecord, rhs: SwiftUnittest_Names_MessageNames.TimeRecord) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.TimeRecord, rhs: SwiftProtoTesting_Names_MessageNames.TimeRecord) -> Bool { if lhs._timeRecord != rhs._timeRecord {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.serializedData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".serializedData" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "serializedData"), - ] +extension SwiftProtoTesting_Names_MessageNames.serializedData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".serializedData" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}serializedData\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26173,18 +20534,16 @@ extension SwiftUnittest_Names_MessageNames.serializedData: SwiftProtobuf.Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.serializedData, rhs: SwiftUnittest_Names_MessageNames.serializedData) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.serializedData, rhs: SwiftProtoTesting_Names_MessageNames.serializedData) -> Bool { if lhs._serializedData != rhs._serializedData {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.jsonUTF8Data: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".jsonUTF8Data" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jsonUTF8Data"), - ] +extension SwiftProtoTesting_Names_MessageNames.jsonUTF8Data: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".jsonUTF8Data" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonUTF8Data\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26209,18 +20568,16 @@ extension SwiftUnittest_Names_MessageNames.jsonUTF8Data: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.jsonUTF8Data, rhs: SwiftUnittest_Names_MessageNames.jsonUTF8Data) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.jsonUTF8Data, rhs: SwiftProtoTesting_Names_MessageNames.jsonUTF8Data) -> Bool { if lhs._jsonUtf8Data != rhs._jsonUtf8Data {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.jsonString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".jsonString" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "jsonString"), - ] +extension SwiftProtoTesting_Names_MessageNames.jsonString: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".jsonString" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}jsonString\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26245,18 +20602,16 @@ extension SwiftUnittest_Names_MessageNames.jsonString: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.jsonString, rhs: SwiftUnittest_Names_MessageNames.jsonString) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.jsonString, rhs: SwiftProtoTesting_Names_MessageNames.jsonString) -> Bool { if lhs._jsonString != rhs._jsonString {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.Extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Extension" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Extension"), - ] +extension SwiftProtoTesting_Names_MessageNames.Extension: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Extension" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Extension\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26281,18 +20636,16 @@ extension SwiftUnittest_Names_MessageNames.Extension: SwiftProtobuf.Message, Swi try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.Extension, rhs: SwiftUnittest_Names_MessageNames.Extension) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.Extension, rhs: SwiftProtoTesting_Names_MessageNames.Extension) -> Bool { if lhs._extension != rhs._extension {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_MessageNames.ExtensionsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_MessageNames.protoMessageName + ".Extensions" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Extensions"), - ] +extension SwiftProtoTesting_Names_MessageNames.ExtensionsMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_MessageNames.protoMessageName + ".Extensions" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Extensions\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -26317,1338 +20670,898 @@ extension SwiftUnittest_Names_MessageNames.ExtensionsMessage: SwiftProtobuf.Mess try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_MessageNames.ExtensionsMessage, rhs: SwiftUnittest_Names_MessageNames.ExtensionsMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_MessageNames.ExtensionsMessage, rhs: SwiftProtoTesting_Names_MessageNames.ExtensionsMessage) -> Bool { if lhs._extensions != rhs._extensions {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_EnumNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_EnumNames: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".EnumNames" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_EnumNames, rhs: SwiftUnittest_Names_EnumNames) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_EnumNames, rhs: SwiftProtoTesting_Names_EnumNames) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_EnumNames.StringEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aString"), - ] +extension SwiftProtoTesting_Names_EnumNames.StringEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aString\0") } -extension SwiftUnittest_Names_EnumNames.ProtocolEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aProtocol"), - ] +extension SwiftProtoTesting_Names_EnumNames.ProtocolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aProtocol\0") } -extension SwiftUnittest_Names_EnumNames.IntEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aInt"), - ] +extension SwiftProtoTesting_Names_EnumNames.IntEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aInt\0") } -extension SwiftUnittest_Names_EnumNames.DoubleEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aDouble"), - ] +extension SwiftProtoTesting_Names_EnumNames.DoubleEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aDouble\0") } -extension SwiftUnittest_Names_EnumNames.FloatEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aFloat"), - ] +extension SwiftProtoTesting_Names_EnumNames.FloatEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aFloat\0") } -extension SwiftUnittest_Names_EnumNames.UIntEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aUInt"), - ] +extension SwiftProtoTesting_Names_EnumNames.UIntEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aUInt\0") } -extension SwiftUnittest_Names_EnumNames.hashValueEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ahashValue"), - ] +extension SwiftProtoTesting_Names_EnumNames.hashValueEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ahashValue\0") } -extension SwiftUnittest_Names_EnumNames.descriptionEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adescription"), - ] +extension SwiftProtoTesting_Names_EnumNames.descriptionEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adescription\0") } -extension SwiftUnittest_Names_EnumNames.debugDescriptionEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adebugDescription"), - ] +extension SwiftProtoTesting_Names_EnumNames.debugDescriptionEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adebugDescription\0") } -extension SwiftUnittest_Names_EnumNames.Swift: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aSwift"), - ] +extension SwiftProtoTesting_Names_EnumNames.SwiftEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aSwift\0") } -extension SwiftUnittest_Names_EnumNames.UNRECOGNIZED: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aUNRECOGNIZED"), - ] +extension SwiftProtoTesting_Names_EnumNames.UNRECOGNIZED: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aUNRECOGNIZED\0") } -extension SwiftUnittest_Names_EnumNames.classEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aclass"), - ] +extension SwiftProtoTesting_Names_EnumNames.classEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aclass\0") } -extension SwiftUnittest_Names_EnumNames.deinitEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adeinit"), - ] +extension SwiftProtoTesting_Names_EnumNames.deinitEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adeinit\0") } -extension SwiftUnittest_Names_EnumNames.enumEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aenum"), - ] +extension SwiftProtoTesting_Names_EnumNames.enumEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aenum\0") } -extension SwiftUnittest_Names_EnumNames.extensionEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aextension"), - ] +extension SwiftProtoTesting_Names_EnumNames.extensionEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aextension\0") } -extension SwiftUnittest_Names_EnumNames.funcEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "afunc"), - ] +extension SwiftProtoTesting_Names_EnumNames.funcEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0afunc\0") } -extension SwiftUnittest_Names_EnumNames.importEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aimport"), - ] +extension SwiftProtoTesting_Names_EnumNames.importEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aimport\0") } -extension SwiftUnittest_Names_EnumNames.initEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ainit"), - ] +extension SwiftProtoTesting_Names_EnumNames.initEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ainit\0") } -extension SwiftUnittest_Names_EnumNames.inoutEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ainout"), - ] +extension SwiftProtoTesting_Names_EnumNames.inoutEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ainout\0") } -extension SwiftUnittest_Names_EnumNames.internalEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ainternal"), - ] +extension SwiftProtoTesting_Names_EnumNames.internalEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ainternal\0") } -extension SwiftUnittest_Names_EnumNames.letEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "alet"), - ] +extension SwiftProtoTesting_Names_EnumNames.letEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0alet\0") } -extension SwiftUnittest_Names_EnumNames.operatorEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aoperator"), - ] +extension SwiftProtoTesting_Names_EnumNames.operatorEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aoperator\0") } -extension SwiftUnittest_Names_EnumNames.privateEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aprivate"), - ] +extension SwiftProtoTesting_Names_EnumNames.privateEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aprivate\0") } -extension SwiftUnittest_Names_EnumNames.protocolEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aprotocol"), - ] +extension SwiftProtoTesting_Names_EnumNames.protocolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aprotocol\0") } -extension SwiftUnittest_Names_EnumNames.publicEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "apublic"), - ] +extension SwiftProtoTesting_Names_EnumNames.publicEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0apublic\0") } -extension SwiftUnittest_Names_EnumNames.staticEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "astatic"), - ] +extension SwiftProtoTesting_Names_EnumNames.staticEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0astatic\0") } -extension SwiftUnittest_Names_EnumNames.structEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "astruct"), - ] +extension SwiftProtoTesting_Names_EnumNames.structEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0astruct\0") } -extension SwiftUnittest_Names_EnumNames.subscriptEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "asubscript"), - ] +extension SwiftProtoTesting_Names_EnumNames.subscriptEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0asubscript\0") } -extension SwiftUnittest_Names_EnumNames.typealiasEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "atypealias"), - ] +extension SwiftProtoTesting_Names_EnumNames.typealiasEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0atypealias\0") } -extension SwiftUnittest_Names_EnumNames.varEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "avar"), - ] +extension SwiftProtoTesting_Names_EnumNames.varEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0avar\0") } -extension SwiftUnittest_Names_EnumNames.breakEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "abreak"), - ] +extension SwiftProtoTesting_Names_EnumNames.breakEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0abreak\0") } -extension SwiftUnittest_Names_EnumNames.caseEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "acase"), - ] +extension SwiftProtoTesting_Names_EnumNames.caseEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0acase\0") } -extension SwiftUnittest_Names_EnumNames.continueEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "acontinue"), - ] +extension SwiftProtoTesting_Names_EnumNames.continueEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0acontinue\0") } -extension SwiftUnittest_Names_EnumNames.defaultEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adefault"), - ] +extension SwiftProtoTesting_Names_EnumNames.defaultEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adefault\0") } -extension SwiftUnittest_Names_EnumNames.deferEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adefer"), - ] +extension SwiftProtoTesting_Names_EnumNames.deferEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adefer\0") } -extension SwiftUnittest_Names_EnumNames.doEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ado"), - ] +extension SwiftProtoTesting_Names_EnumNames.doEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ado\0") } -extension SwiftUnittest_Names_EnumNames.elseEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aelse"), - ] +extension SwiftProtoTesting_Names_EnumNames.elseEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aelse\0") } -extension SwiftUnittest_Names_EnumNames.fallthroughEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "afallthrough"), - ] +extension SwiftProtoTesting_Names_EnumNames.fallthroughEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0afallthrough\0") } -extension SwiftUnittest_Names_EnumNames.forEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "afor"), - ] +extension SwiftProtoTesting_Names_EnumNames.forEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0afor\0") } -extension SwiftUnittest_Names_EnumNames.guardEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aguard"), - ] +extension SwiftProtoTesting_Names_EnumNames.guardEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aguard\0") } -extension SwiftUnittest_Names_EnumNames.ifEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aif"), - ] +extension SwiftProtoTesting_Names_EnumNames.ifEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aif\0") } -extension SwiftUnittest_Names_EnumNames.inEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ain"), - ] +extension SwiftProtoTesting_Names_EnumNames.inEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ain\0") } -extension SwiftUnittest_Names_EnumNames.repeatEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "arepeat"), - ] +extension SwiftProtoTesting_Names_EnumNames.repeatEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0arepeat\0") } -extension SwiftUnittest_Names_EnumNames.returnEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "areturn"), - ] +extension SwiftProtoTesting_Names_EnumNames.returnEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0areturn\0") } -extension SwiftUnittest_Names_EnumNames.switchEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aswitch"), - ] +extension SwiftProtoTesting_Names_EnumNames.switchEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aswitch\0") } -extension SwiftUnittest_Names_EnumNames.whereEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "awhere"), - ] +extension SwiftProtoTesting_Names_EnumNames.whereEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0awhere\0") } -extension SwiftUnittest_Names_EnumNames.whileEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "awhile"), - ] +extension SwiftProtoTesting_Names_EnumNames.whileEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0awhile\0") } -extension SwiftUnittest_Names_EnumNames.asEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aas"), - ] +extension SwiftProtoTesting_Names_EnumNames.asEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aas\0") } -extension SwiftUnittest_Names_EnumNames.catchEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "acatch"), - ] +extension SwiftProtoTesting_Names_EnumNames.catchEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0acatch\0") } -extension SwiftUnittest_Names_EnumNames.dynamicTypeEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adynamicType"), - ] +extension SwiftProtoTesting_Names_EnumNames.dynamicTypeEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adynamicType\0") } -extension SwiftUnittest_Names_EnumNames.falseEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "afalse"), - ] +extension SwiftProtoTesting_Names_EnumNames.falseEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0afalse\0") } -extension SwiftUnittest_Names_EnumNames.isEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ais"), - ] +extension SwiftProtoTesting_Names_EnumNames.isEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ais\0") } -extension SwiftUnittest_Names_EnumNames.nilEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "anil"), - ] +extension SwiftProtoTesting_Names_EnumNames.nilEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0anil\0") } -extension SwiftUnittest_Names_EnumNames.rethrowsEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "arethrows"), - ] +extension SwiftProtoTesting_Names_EnumNames.rethrowsEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0arethrows\0") } -extension SwiftUnittest_Names_EnumNames.superEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "asuper"), - ] +extension SwiftProtoTesting_Names_EnumNames.superEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0asuper\0") } -extension SwiftUnittest_Names_EnumNames.selfEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aself"), - ] +extension SwiftProtoTesting_Names_EnumNames.selfEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aself\0") } -extension SwiftUnittest_Names_EnumNames.throwEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "athrow"), - ] +extension SwiftProtoTesting_Names_EnumNames.throwEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0athrow\0") } -extension SwiftUnittest_Names_EnumNames.throwsEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "athrows"), - ] +extension SwiftProtoTesting_Names_EnumNames.throwsEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0athrows\0") } -extension SwiftUnittest_Names_EnumNames.trueEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "atrue"), - ] +extension SwiftProtoTesting_Names_EnumNames.trueEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0atrue\0") } -extension SwiftUnittest_Names_EnumNames.tryEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "atry"), - ] +extension SwiftProtoTesting_Names_EnumNames.tryEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0atry\0") } -extension SwiftUnittest_Names_EnumNames.__COLUMN__Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "a__COLUMN__"), - ] +extension SwiftProtoTesting_Names_EnumNames.__COLUMN__Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0a__COLUMN__\0") } -extension SwiftUnittest_Names_EnumNames.__FILE__Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "a__FILE__"), - ] +extension SwiftProtoTesting_Names_EnumNames.__FILE__Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0a__FILE__\0") } -extension SwiftUnittest_Names_EnumNames.__FUNCTION__Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "a__FUNCTION__"), - ] +extension SwiftProtoTesting_Names_EnumNames.__FUNCTION__Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0a__FUNCTION__\0") } -extension SwiftUnittest_Names_EnumNames.__LINE__Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "a__LINE__"), - ] +extension SwiftProtoTesting_Names_EnumNames.__LINE__Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0a__LINE__\0") } -extension SwiftUnittest_Names_EnumNames._Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "a_"), - ] +extension SwiftProtoTesting_Names_EnumNames._Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0a_\0") } -extension SwiftUnittest_Names_EnumNames.__Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "a__"), - ] +extension SwiftProtoTesting_Names_EnumNames.__Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0a__\0") } -extension SwiftUnittest_Names_EnumNames.associativity: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aassociativity"), - ] +extension SwiftProtoTesting_Names_EnumNames.associativity: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aassociativity\0") } -extension SwiftUnittest_Names_EnumNames.convenience: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aconvenience"), - ] +extension SwiftProtoTesting_Names_EnumNames.convenience: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aconvenience\0") } -extension SwiftUnittest_Names_EnumNames.dynamic: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adynamic"), - ] +extension SwiftProtoTesting_Names_EnumNames.dynamic: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adynamic\0") } -extension SwiftUnittest_Names_EnumNames.didSet: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adidSet"), - ] +extension SwiftProtoTesting_Names_EnumNames.didSet: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adidSet\0") } -extension SwiftUnittest_Names_EnumNames.final: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "afinal"), - ] +extension SwiftProtoTesting_Names_EnumNames.final: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0afinal\0") } -extension SwiftUnittest_Names_EnumNames.get: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aget"), - ] +extension SwiftProtoTesting_Names_EnumNames.get: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aget\0") } -extension SwiftUnittest_Names_EnumNames.infix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ainfix"), - ] +extension SwiftProtoTesting_Names_EnumNames.infix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ainfix\0") } -extension SwiftUnittest_Names_EnumNames.indirect: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aindirect"), - ] +extension SwiftProtoTesting_Names_EnumNames.indirect: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aindirect\0") } -extension SwiftUnittest_Names_EnumNames.lazy: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "alazy"), - ] +extension SwiftProtoTesting_Names_EnumNames.lazy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0alazy\0") } -extension SwiftUnittest_Names_EnumNames.left: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aleft"), - ] +extension SwiftProtoTesting_Names_EnumNames.left: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aleft\0") } -extension SwiftUnittest_Names_EnumNames.mutating: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "amutating"), - ] +extension SwiftProtoTesting_Names_EnumNames.mutating: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0amutating\0") } -extension SwiftUnittest_Names_EnumNames.none: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "anone"), - ] +extension SwiftProtoTesting_Names_EnumNames.none: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0anone\0") } -extension SwiftUnittest_Names_EnumNames.nonmutating: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "anonmutating"), - ] +extension SwiftProtoTesting_Names_EnumNames.nonmutating: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0anonmutating\0") } -extension SwiftUnittest_Names_EnumNames.optional: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aoptional"), - ] +extension SwiftProtoTesting_Names_EnumNames.optional: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aoptional\0") } -extension SwiftUnittest_Names_EnumNames.override: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aoverride"), - ] +extension SwiftProtoTesting_Names_EnumNames.override: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aoverride\0") } -extension SwiftUnittest_Names_EnumNames.postfix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "apostfix"), - ] +extension SwiftProtoTesting_Names_EnumNames.postfix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0apostfix\0") } -extension SwiftUnittest_Names_EnumNames.precedence: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aprecedence"), - ] +extension SwiftProtoTesting_Names_EnumNames.precedence: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aprecedence\0") } -extension SwiftUnittest_Names_EnumNames.prefix: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aprefix"), - ] +extension SwiftProtoTesting_Names_EnumNames.prefix: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aprefix\0") } -extension SwiftUnittest_Names_EnumNames.required: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "arequired"), - ] +extension SwiftProtoTesting_Names_EnumNames.required: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0arequired\0") } -extension SwiftUnittest_Names_EnumNames.right: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aright"), - ] +extension SwiftProtoTesting_Names_EnumNames.right: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aright\0") } -extension SwiftUnittest_Names_EnumNames.set: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aset"), - ] +extension SwiftProtoTesting_Names_EnumNames.set: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aset\0") } -extension SwiftUnittest_Names_EnumNames.TypeEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aType"), - ] +extension SwiftProtoTesting_Names_EnumNames.TypeEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aType\0") } -extension SwiftUnittest_Names_EnumNames.unowned: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aunowned"), - ] +extension SwiftProtoTesting_Names_EnumNames.unowned: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aunowned\0") } -extension SwiftUnittest_Names_EnumNames.weak: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aweak"), - ] +extension SwiftProtoTesting_Names_EnumNames.weak: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aweak\0") } -extension SwiftUnittest_Names_EnumNames.willSet: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "awillSet"), - ] +extension SwiftProtoTesting_Names_EnumNames.willSet: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0awillSet\0") } -extension SwiftUnittest_Names_EnumNames.id: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aid"), - ] +extension SwiftProtoTesting_Names_EnumNames.id: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aid\0") } -extension SwiftUnittest_Names_EnumNames._cmd: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "a_cmd"), - ] +extension SwiftProtoTesting_Names_EnumNames._cmd: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0a_cmd\0") } -extension SwiftUnittest_Names_EnumNames.out: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aout"), - ] +extension SwiftProtoTesting_Names_EnumNames.out: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aout\0") } -extension SwiftUnittest_Names_EnumNames.bycopy: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "abycopy"), - ] +extension SwiftProtoTesting_Names_EnumNames.bycopy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0abycopy\0") } -extension SwiftUnittest_Names_EnumNames.byref: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "abyref"), - ] +extension SwiftProtoTesting_Names_EnumNames.byref: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0abyref\0") } -extension SwiftUnittest_Names_EnumNames.oneway: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aoneway"), - ] +extension SwiftProtoTesting_Names_EnumNames.oneway: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aoneway\0") } -extension SwiftUnittest_Names_EnumNames.and: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aand"), - ] +extension SwiftProtoTesting_Names_EnumNames.and: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aand\0") } -extension SwiftUnittest_Names_EnumNames.and_eq: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aand_eq"), - ] +extension SwiftProtoTesting_Names_EnumNames.and_eq: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aand_eq\0") } -extension SwiftUnittest_Names_EnumNames.alignas: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aalignas"), - ] +extension SwiftProtoTesting_Names_EnumNames.alignas: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aalignas\0") } -extension SwiftUnittest_Names_EnumNames.alignof: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aalignof"), - ] +extension SwiftProtoTesting_Names_EnumNames.alignof: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aalignof\0") } -extension SwiftUnittest_Names_EnumNames.asm: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aasm"), - ] +extension SwiftProtoTesting_Names_EnumNames.asm: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aasm\0") } -extension SwiftUnittest_Names_EnumNames.auto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aauto"), - ] +extension SwiftProtoTesting_Names_EnumNames.auto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aauto\0") } -extension SwiftUnittest_Names_EnumNames.bitand: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "abitand"), - ] +extension SwiftProtoTesting_Names_EnumNames.bitand: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0abitand\0") } -extension SwiftUnittest_Names_EnumNames.bitor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "abitor"), - ] +extension SwiftProtoTesting_Names_EnumNames.bitor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0abitor\0") } -extension SwiftUnittest_Names_EnumNames.bool: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "abool"), - ] +extension SwiftProtoTesting_Names_EnumNames.bool: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0abool\0") } -extension SwiftUnittest_Names_EnumNames.char: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "achar"), - ] +extension SwiftProtoTesting_Names_EnumNames.char: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0achar\0") } -extension SwiftUnittest_Names_EnumNames.char16_t: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "achar16_t"), - ] +extension SwiftProtoTesting_Names_EnumNames.char16_t: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0achar16_t\0") } -extension SwiftUnittest_Names_EnumNames.char32_t: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "achar32_t"), - ] +extension SwiftProtoTesting_Names_EnumNames.char32_t: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0achar32_t\0") } -extension SwiftUnittest_Names_EnumNames.compl: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "acompl"), - ] +extension SwiftProtoTesting_Names_EnumNames.compl: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0acompl\0") } -extension SwiftUnittest_Names_EnumNames.const: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aconst"), - ] +extension SwiftProtoTesting_Names_EnumNames.const: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aconst\0") } -extension SwiftUnittest_Names_EnumNames.constexpr: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aconstexpr"), - ] +extension SwiftProtoTesting_Names_EnumNames.constexpr: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aconstexpr\0") } -extension SwiftUnittest_Names_EnumNames.const_cast: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aconst_cast"), - ] +extension SwiftProtoTesting_Names_EnumNames.const_cast: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aconst_cast\0") } -extension SwiftUnittest_Names_EnumNames.decltype: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adecltype"), - ] +extension SwiftProtoTesting_Names_EnumNames.decltype: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adecltype\0") } -extension SwiftUnittest_Names_EnumNames.delete: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adelete"), - ] +extension SwiftProtoTesting_Names_EnumNames.delete: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adelete\0") } -extension SwiftUnittest_Names_EnumNames.dynamic_cast: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adynamic_cast"), - ] +extension SwiftProtoTesting_Names_EnumNames.dynamic_cast: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adynamic_cast\0") } -extension SwiftUnittest_Names_EnumNames.explicit: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aexplicit"), - ] +extension SwiftProtoTesting_Names_EnumNames.explicit: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aexplicit\0") } -extension SwiftUnittest_Names_EnumNames.export: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aexport"), - ] +extension SwiftProtoTesting_Names_EnumNames.export: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aexport\0") } -extension SwiftUnittest_Names_EnumNames.extern: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aextern"), - ] +extension SwiftProtoTesting_Names_EnumNames.extern: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aextern\0") } -extension SwiftUnittest_Names_EnumNames.friend: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "afriend"), - ] +extension SwiftProtoTesting_Names_EnumNames.friend: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0afriend\0") } -extension SwiftUnittest_Names_EnumNames.goto: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "agoto"), - ] +extension SwiftProtoTesting_Names_EnumNames.goto: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0agoto\0") } -extension SwiftUnittest_Names_EnumNames.inline: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ainline"), - ] +extension SwiftProtoTesting_Names_EnumNames.inline: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ainline\0") } -extension SwiftUnittest_Names_EnumNames.long: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "along"), - ] +extension SwiftProtoTesting_Names_EnumNames.long: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0along\0") } -extension SwiftUnittest_Names_EnumNames.mutable: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "amutable"), - ] +extension SwiftProtoTesting_Names_EnumNames.mutable: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0amutable\0") } -extension SwiftUnittest_Names_EnumNames.namespace: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "anamespace"), - ] +extension SwiftProtoTesting_Names_EnumNames.namespace: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0anamespace\0") } -extension SwiftUnittest_Names_EnumNames.new: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "anew"), - ] +extension SwiftProtoTesting_Names_EnumNames.new: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0anew\0") } -extension SwiftUnittest_Names_EnumNames.noexcept: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "anoexcept"), - ] +extension SwiftProtoTesting_Names_EnumNames.noexcept: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0anoexcept\0") } -extension SwiftUnittest_Names_EnumNames.not: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "anot"), - ] +extension SwiftProtoTesting_Names_EnumNames.not: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0anot\0") } -extension SwiftUnittest_Names_EnumNames.not_eq: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "anot_eq"), - ] +extension SwiftProtoTesting_Names_EnumNames.not_eq: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0anot_eq\0") } -extension SwiftUnittest_Names_EnumNames.nullptr: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "anullptr"), - ] +extension SwiftProtoTesting_Names_EnumNames.nullptr: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0anullptr\0") } -extension SwiftUnittest_Names_EnumNames.or: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aor"), - ] +extension SwiftProtoTesting_Names_EnumNames.or: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aor\0") } -extension SwiftUnittest_Names_EnumNames.or_eq: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aor_eq"), - ] +extension SwiftProtoTesting_Names_EnumNames.or_eq: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aor_eq\0") } -extension SwiftUnittest_Names_EnumNames.protected: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aprotected"), - ] +extension SwiftProtoTesting_Names_EnumNames.protected: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aprotected\0") } -extension SwiftUnittest_Names_EnumNames.register: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aregister"), - ] +extension SwiftProtoTesting_Names_EnumNames.register: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aregister\0") } -extension SwiftUnittest_Names_EnumNames.reinterpret_cast: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "areinterpret_cast"), - ] +extension SwiftProtoTesting_Names_EnumNames.reinterpret_cast: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0areinterpret_cast\0") } -extension SwiftUnittest_Names_EnumNames.short: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ashort"), - ] +extension SwiftProtoTesting_Names_EnumNames.short: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ashort\0") } -extension SwiftUnittest_Names_EnumNames.signed: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "asigned"), - ] +extension SwiftProtoTesting_Names_EnumNames.signed: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0asigned\0") } -extension SwiftUnittest_Names_EnumNames.sizeof: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "asizeof"), - ] +extension SwiftProtoTesting_Names_EnumNames.sizeof: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0asizeof\0") } -extension SwiftUnittest_Names_EnumNames.static_assert: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "astatic_assert"), - ] +extension SwiftProtoTesting_Names_EnumNames.static_assert: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0astatic_assert\0") } -extension SwiftUnittest_Names_EnumNames.static_cast: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "astatic_cast"), - ] +extension SwiftProtoTesting_Names_EnumNames.static_cast: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0astatic_cast\0") } -extension SwiftUnittest_Names_EnumNames.template: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "atemplate"), - ] +extension SwiftProtoTesting_Names_EnumNames.template: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0atemplate\0") } -extension SwiftUnittest_Names_EnumNames.this: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "athis"), - ] +extension SwiftProtoTesting_Names_EnumNames.this: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0athis\0") } -extension SwiftUnittest_Names_EnumNames.thread_local: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "athread_local"), - ] +extension SwiftProtoTesting_Names_EnumNames.thread_local: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0athread_local\0") } -extension SwiftUnittest_Names_EnumNames.typedef: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "atypedef"), - ] +extension SwiftProtoTesting_Names_EnumNames.typedef: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0atypedef\0") } -extension SwiftUnittest_Names_EnumNames.typeid: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "atypeid"), - ] +extension SwiftProtoTesting_Names_EnumNames.typeid: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0atypeid\0") } -extension SwiftUnittest_Names_EnumNames.typename: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "atypename"), - ] +extension SwiftProtoTesting_Names_EnumNames.typename: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0atypename\0") } -extension SwiftUnittest_Names_EnumNames.union: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aunion"), - ] +extension SwiftProtoTesting_Names_EnumNames.union: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aunion\0") } -extension SwiftUnittest_Names_EnumNames.unsigned: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aunsigned"), - ] +extension SwiftProtoTesting_Names_EnumNames.unsigned: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aunsigned\0") } -extension SwiftUnittest_Names_EnumNames.using: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ausing"), - ] +extension SwiftProtoTesting_Names_EnumNames.using: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ausing\0") } -extension SwiftUnittest_Names_EnumNames.virtual: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "avirtual"), - ] +extension SwiftProtoTesting_Names_EnumNames.virtual: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0avirtual\0") } -extension SwiftUnittest_Names_EnumNames.void: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "avoid"), - ] +extension SwiftProtoTesting_Names_EnumNames.void: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0avoid\0") } -extension SwiftUnittest_Names_EnumNames.volatile: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "avolatile"), - ] +extension SwiftProtoTesting_Names_EnumNames.volatile: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0avolatile\0") } -extension SwiftUnittest_Names_EnumNames.wchar_t: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "awchar_t"), - ] +extension SwiftProtoTesting_Names_EnumNames.wchar_t: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0awchar_t\0") } -extension SwiftUnittest_Names_EnumNames.xor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "axor"), - ] +extension SwiftProtoTesting_Names_EnumNames.xor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0axor\0") } -extension SwiftUnittest_Names_EnumNames.xor_eq: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "axor_eq"), - ] +extension SwiftProtoTesting_Names_EnumNames.xor_eq: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0axor_eq\0") } -extension SwiftUnittest_Names_EnumNames.restrict: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "arestrict"), - ] +extension SwiftProtoTesting_Names_EnumNames.restrict: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0arestrict\0") } -extension SwiftUnittest_Names_EnumNames.Category: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aCategory"), - ] +extension SwiftProtoTesting_Names_EnumNames.Category: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aCategory\0") } -extension SwiftUnittest_Names_EnumNames.Ivar: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aIvar"), - ] +extension SwiftProtoTesting_Names_EnumNames.Ivar: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aIvar\0") } -extension SwiftUnittest_Names_EnumNames.Method: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aMethod"), - ] +extension SwiftProtoTesting_Names_EnumNames.Method: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aMethod\0") } -extension SwiftUnittest_Names_EnumNames.finalize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "afinalize"), - ] +extension SwiftProtoTesting_Names_EnumNames.finalize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0afinalize\0") } -extension SwiftUnittest_Names_EnumNames.hash: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "ahash"), - ] +extension SwiftProtoTesting_Names_EnumNames.hash: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0ahash\0") } -extension SwiftUnittest_Names_EnumNames.dealloc: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adealloc"), - ] +extension SwiftProtoTesting_Names_EnumNames.dealloc: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adealloc\0") } -extension SwiftUnittest_Names_EnumNames.superclass: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "asuperclass"), - ] +extension SwiftProtoTesting_Names_EnumNames.superclass: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0asuperclass\0") } -extension SwiftUnittest_Names_EnumNames.retain: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aretain"), - ] +extension SwiftProtoTesting_Names_EnumNames.retain: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aretain\0") } -extension SwiftUnittest_Names_EnumNames.release: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "arelease"), - ] +extension SwiftProtoTesting_Names_EnumNames.release: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0arelease\0") } -extension SwiftUnittest_Names_EnumNames.autorelease: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aautorelease"), - ] +extension SwiftProtoTesting_Names_EnumNames.autorelease: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aautorelease\0") } -extension SwiftUnittest_Names_EnumNames.retainCount: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aretainCount"), - ] +extension SwiftProtoTesting_Names_EnumNames.retainCount: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aretainCount\0") } -extension SwiftUnittest_Names_EnumNames.zone: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "azone"), - ] +extension SwiftProtoTesting_Names_EnumNames.zone: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0azone\0") } -extension SwiftUnittest_Names_EnumNames.isProxy: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aisProxy"), - ] +extension SwiftProtoTesting_Names_EnumNames.isProxy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aisProxy\0") } -extension SwiftUnittest_Names_EnumNames.copy: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "acopy"), - ] +extension SwiftProtoTesting_Names_EnumNames.copy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0acopy\0") } -extension SwiftUnittest_Names_EnumNames.mutableCopy: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "amutableCopy"), - ] +extension SwiftProtoTesting_Names_EnumNames.mutableCopy: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0amutableCopy\0") } -extension SwiftUnittest_Names_EnumNames.classForCoder: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aclassForCoder"), - ] +extension SwiftProtoTesting_Names_EnumNames.classForCoder: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aclassForCoder\0") } -extension SwiftUnittest_Names_EnumNames.clear: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aclear"), - ] +extension SwiftProtoTesting_Names_EnumNames.clear: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aclear\0") } -extension SwiftUnittest_Names_EnumNames.data: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adata"), - ] +extension SwiftProtoTesting_Names_EnumNames.data: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adata\0") } -extension SwiftUnittest_Names_EnumNames.delimitedData: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adelimitedData"), - ] +extension SwiftProtoTesting_Names_EnumNames.delimitedData: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adelimitedData\0") } -extension SwiftUnittest_Names_EnumNames.descriptor: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "adescriptor"), - ] +extension SwiftProtoTesting_Names_EnumNames.descriptor: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0adescriptor\0") } -extension SwiftUnittest_Names_EnumNames.extensionRegistry: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aextensionRegistry"), - ] +extension SwiftProtoTesting_Names_EnumNames.extensionRegistry: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aextensionRegistry\0") } -extension SwiftUnittest_Names_EnumNames.extensionsCurrentlySet: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aextensionsCurrentlySet"), - ] +extension SwiftProtoTesting_Names_EnumNames.extensionsCurrentlySet: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aextensionsCurrentlySet\0") } -extension SwiftUnittest_Names_EnumNames.isInitializedEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aisInitialized"), - ] +extension SwiftProtoTesting_Names_EnumNames.isInitializedEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aisInitialized\0") } -extension SwiftUnittest_Names_EnumNames.serializedSize: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aserializedSize"), - ] +extension SwiftProtoTesting_Names_EnumNames.serializedSize: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aserializedSize\0") } -extension SwiftUnittest_Names_EnumNames.sortedExtensionsInUse: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "asortedExtensionsInUse"), - ] +extension SwiftProtoTesting_Names_EnumNames.sortedExtensionsInUse: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0asortedExtensionsInUse\0") } -extension SwiftUnittest_Names_EnumNames.unknownFieldsEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aunknownFields"), - ] +extension SwiftProtoTesting_Names_EnumNames.unknownFieldsEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aunknownFields\0") } -extension SwiftUnittest_Names_EnumNames.Fixed: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aFixed"), - ] +extension SwiftProtoTesting_Names_EnumNames.Fixed: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aFixed\0") } -extension SwiftUnittest_Names_EnumNames.Fract: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aFract"), - ] +extension SwiftProtoTesting_Names_EnumNames.Fract: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aFract\0") } -extension SwiftUnittest_Names_EnumNames.Size: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aSize"), - ] +extension SwiftProtoTesting_Names_EnumNames.Size: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aSize\0") } -extension SwiftUnittest_Names_EnumNames.LogicalAddress: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aLogicalAddress"), - ] +extension SwiftProtoTesting_Names_EnumNames.LogicalAddress: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aLogicalAddress\0") } -extension SwiftUnittest_Names_EnumNames.PhysicalAddress: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aPhysicalAddress"), - ] +extension SwiftProtoTesting_Names_EnumNames.PhysicalAddress: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aPhysicalAddress\0") } -extension SwiftUnittest_Names_EnumNames.ByteCount: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aByteCount"), - ] +extension SwiftProtoTesting_Names_EnumNames.ByteCount: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aByteCount\0") } -extension SwiftUnittest_Names_EnumNames.ByteOffset: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aByteOffset"), - ] +extension SwiftProtoTesting_Names_EnumNames.ByteOffset: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aByteOffset\0") } -extension SwiftUnittest_Names_EnumNames.Duration: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aDuration"), - ] +extension SwiftProtoTesting_Names_EnumNames.Duration: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aDuration\0") } -extension SwiftUnittest_Names_EnumNames.AbsoluteTime: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aAbsoluteTime"), - ] +extension SwiftProtoTesting_Names_EnumNames.AbsoluteTime: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aAbsoluteTime\0") } -extension SwiftUnittest_Names_EnumNames.OptionBits: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aOptionBits"), - ] +extension SwiftProtoTesting_Names_EnumNames.OptionBits: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aOptionBits\0") } -extension SwiftUnittest_Names_EnumNames.ItemCount: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aItemCount"), - ] +extension SwiftProtoTesting_Names_EnumNames.ItemCount: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aItemCount\0") } -extension SwiftUnittest_Names_EnumNames.PBVersion: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aPBVersion"), - ] +extension SwiftProtoTesting_Names_EnumNames.PBVersion: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aPBVersion\0") } -extension SwiftUnittest_Names_EnumNames.ScriptCode: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aScriptCode"), - ] +extension SwiftProtoTesting_Names_EnumNames.ScriptCode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aScriptCode\0") } -extension SwiftUnittest_Names_EnumNames.LangCode: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aLangCode"), - ] +extension SwiftProtoTesting_Names_EnumNames.LangCode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aLangCode\0") } -extension SwiftUnittest_Names_EnumNames.RegionCode: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aRegionCode"), - ] +extension SwiftProtoTesting_Names_EnumNames.RegionCode: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aRegionCode\0") } -extension SwiftUnittest_Names_EnumNames.OSType: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aOSType"), - ] +extension SwiftProtoTesting_Names_EnumNames.OSType: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aOSType\0") } -extension SwiftUnittest_Names_EnumNames.ProcessSerialNumber: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aProcessSerialNumber"), - ] +extension SwiftProtoTesting_Names_EnumNames.ProcessSerialNumber: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aProcessSerialNumber\0") } -extension SwiftUnittest_Names_EnumNames.Point: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aPoint"), - ] +extension SwiftProtoTesting_Names_EnumNames.Point: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aPoint\0") } -extension SwiftUnittest_Names_EnumNames.Rect: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aRect"), - ] +extension SwiftProtoTesting_Names_EnumNames.Rect: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aRect\0") } -extension SwiftUnittest_Names_EnumNames.FixedPoint: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aFixedPoint"), - ] +extension SwiftProtoTesting_Names_EnumNames.FixedPoint: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aFixedPoint\0") } -extension SwiftUnittest_Names_EnumNames.FixedRect: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aFixedRect"), - ] +extension SwiftProtoTesting_Names_EnumNames.FixedRect: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aFixedRect\0") } -extension SwiftUnittest_Names_EnumNames.Style: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aStyle"), - ] +extension SwiftProtoTesting_Names_EnumNames.Style: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aStyle\0") } -extension SwiftUnittest_Names_EnumNames.StyleParameter: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aStyleParameter"), - ] +extension SwiftProtoTesting_Names_EnumNames.StyleParameter: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aStyleParameter\0") } -extension SwiftUnittest_Names_EnumNames.StyleField: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aStyleField"), - ] +extension SwiftProtoTesting_Names_EnumNames.StyleField: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aStyleField\0") } -extension SwiftUnittest_Names_EnumNames.TimeScale: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aTimeScale"), - ] +extension SwiftProtoTesting_Names_EnumNames.TimeScale: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aTimeScale\0") } -extension SwiftUnittest_Names_EnumNames.TimeBase: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aTimeBase"), - ] +extension SwiftProtoTesting_Names_EnumNames.TimeBase: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aTimeBase\0") } -extension SwiftUnittest_Names_EnumNames.TimeRecord: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aTimeRecord"), - ] +extension SwiftProtoTesting_Names_EnumNames.TimeRecord: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aTimeRecord\0") } -extension SwiftUnittest_Names_EnumNames.Extension: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aExtension"), - ] +extension SwiftProtoTesting_Names_EnumNames.Extension: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aExtension\0") } -extension SwiftUnittest_Names_EnumNames.ExtensionsEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "aExtensions"), - ] +extension SwiftProtoTesting_Names_EnumNames.ExtensionsEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0aExtensions\0") } -extension SwiftUnittest_Names_FieldNamingInitials: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_FieldNamingInitials: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".FieldNamingInitials" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_FieldNamingInitials, rhs: SwiftUnittest_Names_FieldNamingInitials) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_FieldNamingInitials, rhs: SwiftProtoTesting_Names_FieldNamingInitials) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_FieldNamingInitials.Lowers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_FieldNamingInitials.protoMessageName + ".Lowers" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "http"), - 2: .standard(proto: "http_request"), - 3: .standard(proto: "the_http_request"), - 4: .standard(proto: "the_http"), - 11: .same(proto: "https"), - 12: .standard(proto: "https_request"), - 13: .standard(proto: "the_https_request"), - 14: .standard(proto: "the_https"), - 21: .same(proto: "url"), - 22: .standard(proto: "url_value"), - 23: .standard(proto: "the_url_value"), - 24: .standard(proto: "the_url"), - 31: .standard(proto: "a_b_c"), - 41: .same(proto: "id"), - 42: .standard(proto: "id_number"), - 43: .standard(proto: "the_id_number"), - 44: .standard(proto: "request_id"), - ] +extension SwiftProtoTesting_Names_FieldNamingInitials.Lowers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_FieldNamingInitials.protoMessageName + ".Lowers" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}http\0\u{3}http_request\0\u{3}the_http_request\0\u{3}the_http\0\u{2}\u{7}https\0\u{3}https_request\0\u{3}the_https_request\0\u{3}the_https\0\u{2}\u{7}url\0\u{3}url_value\0\u{3}the_url_value\0\u{3}the_url\0\u{4}\u{7}a_b_c\0\u{2}\u{a}id\0\u{3}id_number\0\u{3}the_id_number\0\u{3}request_id\0") fileprivate class _StorageClass { var _http: Int32? = nil @@ -27669,7 +21582,11 @@ extension SwiftUnittest_Names_FieldNamingInitials.Lowers: SwiftProtobuf.Message, var _theIDNumber: Int32? = nil var _requestID: Int32? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -27793,7 +21710,7 @@ extension SwiftUnittest_Names_FieldNamingInitials.Lowers: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_FieldNamingInitials.Lowers, rhs: SwiftUnittest_Names_FieldNamingInitials.Lowers) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_FieldNamingInitials.Lowers, rhs: SwiftProtoTesting_Names_FieldNamingInitials.Lowers) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -27824,26 +21741,9 @@ extension SwiftUnittest_Names_FieldNamingInitials.Lowers: SwiftProtobuf.Message, } } -extension SwiftUnittest_Names_FieldNamingInitials.Uppers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_FieldNamingInitials.protoMessageName + ".Uppers" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "HTTP"), - 2: .standard(proto: "HTTP_request"), - 3: .standard(proto: "the_HTTP_request"), - 4: .standard(proto: "the_HTTP"), - 11: .same(proto: "HTTPS"), - 12: .standard(proto: "HTTPS_request"), - 13: .standard(proto: "the_HTTPS_request"), - 14: .standard(proto: "the_HTTPS"), - 21: .same(proto: "URL"), - 22: .standard(proto: "URL_value"), - 23: .standard(proto: "the_URL_value"), - 24: .standard(proto: "the_URL"), - 41: .same(proto: "ID"), - 42: .standard(proto: "ID_number"), - 43: .standard(proto: "the_ID_number"), - 44: .standard(proto: "request_ID"), - ] +extension SwiftProtoTesting_Names_FieldNamingInitials.Uppers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_FieldNamingInitials.protoMessageName + ".Uppers" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}HTTP\0\u{3}HTTP_request\0\u{3}the_HTTP_request\0\u{3}the_HTTP\0\u{2}\u{7}HTTPS\0\u{3}HTTPS_request\0\u{3}the_HTTPS_request\0\u{3}the_HTTPS\0\u{2}\u{7}URL\0\u{3}URL_value\0\u{3}the_URL_value\0\u{3}the_URL\0\u{2}\u{11}ID\0\u{3}ID_number\0\u{3}the_ID_number\0\u{3}request_ID\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -27928,7 +21828,7 @@ extension SwiftUnittest_Names_FieldNamingInitials.Uppers: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_FieldNamingInitials.Uppers, rhs: SwiftUnittest_Names_FieldNamingInitials.Uppers) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_FieldNamingInitials.Uppers, rhs: SwiftProtoTesting_Names_FieldNamingInitials.Uppers) -> Bool { if lhs._http != rhs._http {return false} if lhs._httpRequest != rhs._httpRequest {return false} if lhs._theHTTPRequest != rhs._theHTTPRequest {return false} @@ -27950,26 +21850,9 @@ extension SwiftUnittest_Names_FieldNamingInitials.Uppers: SwiftProtobuf.Message, } } -extension SwiftUnittest_Names_FieldNamingInitials.WordCase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_Names_FieldNamingInitials.protoMessageName + ".WordCase" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "Http"), - 2: .same(proto: "HttpRequest"), - 3: .same(proto: "TheHttpRequest"), - 4: .same(proto: "TheHttp"), - 11: .same(proto: "Https"), - 12: .same(proto: "HttpsRequest"), - 13: .same(proto: "TheHttpsRequest"), - 14: .same(proto: "TheHttps"), - 21: .same(proto: "Url"), - 22: .same(proto: "UrlValue"), - 23: .same(proto: "TheUrlValue"), - 24: .same(proto: "TheUrl"), - 41: .same(proto: "Id"), - 42: .same(proto: "IdNumber"), - 43: .same(proto: "TheIdNumber"), - 44: .same(proto: "RequestId"), - ] +extension SwiftProtoTesting_Names_FieldNamingInitials.WordCase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Names_FieldNamingInitials.protoMessageName + ".WordCase" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}Http\0\u{1}HttpRequest\0\u{1}TheHttpRequest\0\u{1}TheHttp\0\u{2}\u{7}Https\0\u{1}HttpsRequest\0\u{1}TheHttpsRequest\0\u{1}TheHttps\0\u{2}\u{7}Url\0\u{1}UrlValue\0\u{1}TheUrlValue\0\u{1}TheUrl\0\u{2}\u{11}Id\0\u{1}IdNumber\0\u{1}TheIdNumber\0\u{1}RequestId\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28054,7 +21937,7 @@ extension SwiftUnittest_Names_FieldNamingInitials.WordCase: SwiftProtobuf.Messag try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_FieldNamingInitials.WordCase, rhs: SwiftUnittest_Names_FieldNamingInitials.WordCase) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_FieldNamingInitials.WordCase, rhs: SwiftProtoTesting_Names_FieldNamingInitials.WordCase) -> Bool { if lhs._http != rhs._http {return false} if lhs._httpRequest != rhs._httpRequest {return false} if lhs._theHTTPRequest != rhs._theHTTPRequest {return false} @@ -28076,7 +21959,7 @@ extension SwiftUnittest_Names_FieldNamingInitials.WordCase: SwiftProtobuf.Messag } } -extension SwiftUnittest_Names_ExtensionNamingInitials: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_ExtensionNamingInitials: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ExtensionNamingInitials" static let _protobuf_nameMap = SwiftProtobuf._NameMap() @@ -28088,7 +21971,7 @@ extension SwiftUnittest_Names_ExtensionNamingInitials: SwiftProtobuf.Message, Sw mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { if (1 <= fieldNumber && fieldNumber < 1001) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftUnittest_Names_ExtensionNamingInitials.self, fieldNumber: fieldNumber) + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Names_ExtensionNamingInitials.self, fieldNumber: fieldNumber) } } } @@ -28098,71 +21981,71 @@ extension SwiftUnittest_Names_ExtensionNamingInitials: SwiftProtobuf.Message, Sw try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_ExtensionNamingInitials, rhs: SwiftUnittest_Names_ExtensionNamingInitials) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_ExtensionNamingInitials, rhs: SwiftProtoTesting_Names_ExtensionNamingInitials) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension SwiftUnittest_Names_Lowers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_Lowers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Lowers" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_Lowers, rhs: SwiftUnittest_Names_Lowers) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_Lowers, rhs: SwiftProtoTesting_Names_Lowers) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_Uppers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_Uppers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Uppers" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_Uppers, rhs: SwiftUnittest_Names_Uppers) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_Uppers, rhs: SwiftProtoTesting_Names_Uppers) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_WordCase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_WordCase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".WordCase" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_WordCase, rhs: SwiftUnittest_Names_WordCase) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_WordCase, rhs: SwiftProtoTesting_Names_WordCase) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_ExtensionNamingInitialsLowers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_ExtensionNamingInitialsLowers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ExtensionNamingInitialsLowers" static let _protobuf_nameMap = SwiftProtobuf._NameMap() @@ -28174,7 +22057,7 @@ extension SwiftUnittest_Names_ExtensionNamingInitialsLowers: SwiftProtobuf.Messa mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { if (1 <= fieldNumber && fieldNumber < 1001) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftUnittest_Names_ExtensionNamingInitialsLowers.self, fieldNumber: fieldNumber) + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Names_ExtensionNamingInitialsLowers.self, fieldNumber: fieldNumber) } } } @@ -28184,14 +22067,14 @@ extension SwiftUnittest_Names_ExtensionNamingInitialsLowers: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_ExtensionNamingInitialsLowers, rhs: SwiftUnittest_Names_ExtensionNamingInitialsLowers) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_ExtensionNamingInitialsLowers, rhs: SwiftProtoTesting_Names_ExtensionNamingInitialsLowers) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension SwiftUnittest_Names_ExtensionNamingInitialsUppers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_ExtensionNamingInitialsUppers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ExtensionNamingInitialsUppers" static let _protobuf_nameMap = SwiftProtobuf._NameMap() @@ -28203,7 +22086,7 @@ extension SwiftUnittest_Names_ExtensionNamingInitialsUppers: SwiftProtobuf.Messa mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { if (1 <= fieldNumber && fieldNumber < 1001) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftUnittest_Names_ExtensionNamingInitialsUppers.self, fieldNumber: fieldNumber) + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Names_ExtensionNamingInitialsUppers.self, fieldNumber: fieldNumber) } } } @@ -28213,14 +22096,14 @@ extension SwiftUnittest_Names_ExtensionNamingInitialsUppers: SwiftProtobuf.Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_ExtensionNamingInitialsUppers, rhs: SwiftUnittest_Names_ExtensionNamingInitialsUppers) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_ExtensionNamingInitialsUppers, rhs: SwiftProtoTesting_Names_ExtensionNamingInitialsUppers) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension SwiftUnittest_Names_ExtensionNamingInitialsWordCase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ExtensionNamingInitialsWordCase" static let _protobuf_nameMap = SwiftProtobuf._NameMap() @@ -28232,7 +22115,7 @@ extension SwiftUnittest_Names_ExtensionNamingInitialsWordCase: SwiftProtobuf.Mes mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { if (1 <= fieldNumber && fieldNumber < 1001) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftUnittest_Names_ExtensionNamingInitialsWordCase.self, fieldNumber: fieldNumber) + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase.self, fieldNumber: fieldNumber) } } } @@ -28242,23 +22125,16 @@ extension SwiftUnittest_Names_ExtensionNamingInitialsWordCase: SwiftProtobuf.Mes try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_ExtensionNamingInitialsWordCase, rhs: SwiftUnittest_Names_ExtensionNamingInitialsWordCase) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase, rhs: SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension SwiftUnittest_Names_ValidIdentifiers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_ValidIdentifiers: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".ValidIdentifiers" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "_1field"), - 2: .standard(proto: "_field"), - 3: .standard(proto: "_3field_3"), - 4: .standard(proto: "_4"), - 5: .standard(proto: "_5field"), - 6: .standard(proto: "enum_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}_1field\0\u{3}_field\0\u{3}_3field_3\0\u{3}_4\0\u{3}_5field\0\u{3}enum_field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28322,7 +22198,7 @@ extension SwiftUnittest_Names_ValidIdentifiers: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_ValidIdentifiers, rhs: SwiftUnittest_Names_ValidIdentifiers) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_ValidIdentifiers, rhs: SwiftProtoTesting_Names_ValidIdentifiers) -> Bool { if lhs.__1Field != rhs.__1Field {return false} if lhs._field != rhs._field {return false} if lhs.__3Field3 != rhs.__3Field3 {return false} @@ -28333,20 +22209,13 @@ extension SwiftUnittest_Names_ValidIdentifiers: SwiftProtobuf.Message, SwiftProt } } -extension SwiftUnittest_Names_ValidIdentifiers.TestEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "TEST_ENUM_0"), - 1: .same(proto: "TEST_ENUM_FIRST"), - 2: .same(proto: "_2"), - 3: .same(proto: "_3_VALUE"), - ] +extension SwiftProtoTesting_Names_ValidIdentifiers.TestEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0TEST_ENUM_0\0\u{1}TEST_ENUM_FIRST\0\u{1}_2\0\u{1}_3_VALUE\0") } -extension SwiftUnittest_Names_SpecialNames1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_SpecialNames1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SpecialNames1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "str"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}str\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28378,18 +22247,16 @@ extension SwiftUnittest_Names_SpecialNames1: SwiftProtobuf.Message, SwiftProtobu try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_SpecialNames1, rhs: SwiftUnittest_Names_SpecialNames1) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_SpecialNames1, rhs: SwiftProtoTesting_Names_SpecialNames1) -> Bool { if lhs.newValue != rhs.newValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_SpecialNames2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_SpecialNames2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SpecialNames2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "new_value"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}new_value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -28414,25 +22281,26 @@ extension SwiftUnittest_Names_SpecialNames2: SwiftProtobuf.Message, SwiftProtobu try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_SpecialNames2, rhs: SwiftUnittest_Names_SpecialNames2) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_SpecialNames2, rhs: SwiftProtoTesting_Names_SpecialNames2) -> Bool { if lhs._newValue != rhs._newValue {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_Names_SpecialNames3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_SpecialNames3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SpecialNames3" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "str"), - 2: .standard(proto: "forces_storage"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}str\0\u{3}forces_storage\0") fileprivate class _StorageClass { - var _newValue: SwiftUnittest_Names_SpecialNames3.OneOf_NewValue? - var _forcesStorage: SwiftUnittest_Names_SpecialNames3? = nil + var _newValue: SwiftProtoTesting_Names_SpecialNames3.OneOf_NewValue? + var _forcesStorage: SwiftProtoTesting_Names_SpecialNames3? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -28488,7 +22356,7 @@ extension SwiftUnittest_Names_SpecialNames3: SwiftProtobuf.Message, SwiftProtobu try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_SpecialNames3, rhs: SwiftUnittest_Names_SpecialNames3) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_SpecialNames3, rhs: SwiftProtoTesting_Names_SpecialNames3) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -28504,18 +22372,19 @@ extension SwiftUnittest_Names_SpecialNames3: SwiftProtobuf.Message, SwiftProtobu } } -extension SwiftUnittest_Names_SpecialNames4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Names_SpecialNames4: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SpecialNames4" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "new_value"), - 2: .standard(proto: "forces_storage"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}new_value\0\u{3}forces_storage\0") fileprivate class _StorageClass { var _newValue: String? = nil - var _forcesStorage: SwiftUnittest_Names_SpecialNames4? = nil + var _forcesStorage: SwiftProtoTesting_Names_SpecialNames4? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -28564,7 +22433,7 @@ extension SwiftUnittest_Names_SpecialNames4: SwiftProtobuf.Message, SwiftProtobu try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_Names_SpecialNames4, rhs: SwiftUnittest_Names_SpecialNames4) -> Bool { + static func ==(lhs: SwiftProtoTesting_Names_SpecialNames4, rhs: SwiftProtoTesting_Names_SpecialNames4) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 diff --git a/Tests/SwiftProtobufTests/unittest_swift_naming_no_prefix.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_naming_no_prefix.pb.swift index 025642f22..9cd93c6ad 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_naming_no_prefix.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_naming_no_prefix.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_naming_no_prefix.proto @@ -23,7 +24,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -40,7 +40,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// /// Top level extensions declarations are qualified with `Extensions_`, so there is nothing special /// is needed in generation handling. -struct BaseMessage: SwiftProtobuf.ExtensibleMessage { +struct BaseMessage: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -52,15 +52,11 @@ struct BaseMessage: SwiftProtobuf.ExtensibleMessage { var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } -#if swift(>=5.5) && canImport(_Concurrency) -extension BaseMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_naming_no_prefix.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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. @@ -83,7 +79,7 @@ extension BaseMessage { } } -extension SwiftUnittest_Names_ExtensionNamingInitialsLowers { +extension SwiftProtoTesting_Names_ExtensionNamingInitialsLowers { var http: Int32 { get {return getExtensionValue(ext: Extensions_http) ?? 0} @@ -341,7 +337,7 @@ extension SwiftUnittest_Names_ExtensionNamingInitialsLowers { } } -extension SwiftUnittest_Names_ExtensionNamingInitialsUppers { +extension SwiftProtoTesting_Names_ExtensionNamingInitialsUppers { var http: Int32 { get {return getExtensionValue(ext: Extensions_HTTP) ?? 0} @@ -584,7 +580,7 @@ extension SwiftUnittest_Names_ExtensionNamingInitialsUppers { } } -extension SwiftUnittest_Names_ExtensionNamingInitialsWordCase { +extension SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase { var http: Int32 { get {return getExtensionValue(ext: Extensions_Http) ?? 0} @@ -891,247 +887,247 @@ let UnittestSwiftNamingNoPrefix_Extensions: SwiftProtobuf.SimpleExtensionMap = [ // constructing a `SimpleExtensionMap`, otherwise, use the above _Extension Properties_ // accessors for the extension fields on the messages directly. -let Extensions_http = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_http = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 101, fieldName: "http" ) -let Extensions_http_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_http_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 102, fieldName: "http_request" ) -let Extensions_the_http_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_the_http_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 103, fieldName: "the_http_request" ) -let Extensions_the_http = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_the_http = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 104, fieldName: "the_http" ) -let Extensions_https = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_https = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 111, fieldName: "https" ) -let Extensions_https_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_https_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 112, fieldName: "https_request" ) -let Extensions_the_https_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_the_https_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 113, fieldName: "the_https_request" ) -let Extensions_the_https = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_the_https = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 114, fieldName: "the_https" ) -let Extensions_url = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_url = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 121, fieldName: "url" ) -let Extensions_url_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_url_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 122, fieldName: "url_value" ) -let Extensions_the_url_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_the_url_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 123, fieldName: "the_url_value" ) -let Extensions_the_url = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_the_url = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 124, fieldName: "the_url" ) -let Extensions_a_b_c = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_a_b_c = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 131, fieldName: "a_b_c" ) -let Extensions_id = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_id = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 141, fieldName: "id" ) -let Extensions_id_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_id_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 142, fieldName: "id_number" ) -let Extensions_the_id_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_the_id_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 143, fieldName: "the_id_number" ) -let Extensions_request_id = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsLowers>( +let Extensions_request_id = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsLowers>( _protobuf_fieldNumber: 144, fieldName: "request_id" ) -let Extensions_HTTP = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_HTTP = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 101, fieldName: "HTTP" ) -let Extensions_HTTP_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_HTTP_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 102, fieldName: "HTTP_request" ) -let Extensions_the_HTTP_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_the_HTTP_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 103, fieldName: "the_HTTP_request" ) -let Extensions_the_HTTP = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_the_HTTP = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 104, fieldName: "the_HTTP" ) -let Extensions_HTTPS = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_HTTPS = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 111, fieldName: "HTTPS" ) -let Extensions_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 112, fieldName: "HTTPS_request" ) -let Extensions_the_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_the_HTTPS_request = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 113, fieldName: "the_HTTPS_request" ) -let Extensions_the_HTTPS = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_the_HTTPS = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 114, fieldName: "the_HTTPS" ) -let Extensions_URL = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_URL = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 121, fieldName: "URL" ) -let Extensions_URL_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_URL_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 122, fieldName: "URL_value" ) -let Extensions_the_URL_value = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_the_URL_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 123, fieldName: "the_URL_value" ) -let Extensions_the_URL = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_the_URL = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 124, fieldName: "the_URL" ) -let Extensions_ID = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_ID = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 141, fieldName: "ID" ) -let Extensions_ID_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_ID_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 142, fieldName: "ID_number" ) -let Extensions_the_ID_number = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_the_ID_number = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 143, fieldName: "the_ID_number" ) -let Extensions_request_ID = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsUppers>( +let Extensions_request_ID = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsUppers>( _protobuf_fieldNumber: 144, fieldName: "request_ID" ) -let Extensions_Http = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_Http = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 101, fieldName: "Http" ) -let Extensions_HttpRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_HttpRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 102, fieldName: "HttpRequest" ) -let Extensions_TheHttpRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_TheHttpRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 103, fieldName: "TheHttpRequest" ) -let Extensions_TheHttp = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_TheHttp = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 104, fieldName: "TheHttp" ) -let Extensions_Https = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_Https = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 111, fieldName: "Https" ) -let Extensions_HttpsRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_HttpsRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 112, fieldName: "HttpsRequest" ) -let Extensions_TheHttpsRequest = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_TheHttpsRequest = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 113, fieldName: "TheHttpsRequest" ) -let Extensions_TheHttps = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_TheHttps = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 114, fieldName: "TheHttps" ) -let Extensions_Url = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_Url = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 121, fieldName: "Url" ) -let Extensions_UrlValue = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_UrlValue = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 122, fieldName: "UrlValue" ) -let Extensions_TheUrlValue = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_TheUrlValue = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 123, fieldName: "TheUrlValue" ) -let Extensions_TheUrl = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_TheUrl = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 124, fieldName: "TheUrl" ) -let Extensions_Id = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_Id = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 141, fieldName: "Id" ) -let Extensions_IdNumber = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_IdNumber = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 142, fieldName: "IdNumber" ) -let Extensions_TheIdNumber = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_TheIdNumber = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 143, fieldName: "TheIdNumber" ) -let Extensions_RequestId = SwiftProtobuf.MessageExtension, SwiftUnittest_Names_ExtensionNamingInitialsWordCase>( +let Extensions_RequestId = SwiftProtobuf.MessageExtension, SwiftProtoTesting_Names_ExtensionNamingInitialsWordCase>( _protobuf_fieldNumber: 144, fieldName: "RequestId" ) diff --git a/Tests/SwiftProtobufTests/unittest_swift_naming_number_prefix.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_naming_number_prefix.pb.swift index c4e7d1cdf..0afb04ca6 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_naming_number_prefix.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_naming_number_prefix.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_naming_number_prefix.proto @@ -23,7 +24,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -36,17 +36,17 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct _4fun_Mumble_MyMessage { +struct _4fun_SwiftProtoTesting_Mumble_MyMessage: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -57,19 +57,13 @@ struct _4fun_Mumble_MyMessage { fileprivate var _a: Int32? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension _4fun_Mumble_MyMessage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "_4fun.mumble" +fileprivate let _protobuf_package = "_4fun.swift_proto_testing.mumble" -extension _4fun_Mumble_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension _4fun_SwiftProtoTesting_Mumble_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MyMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -94,7 +88,7 @@ extension _4fun_Mumble_MyMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageI try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: _4fun_Mumble_MyMessage, rhs: _4fun_Mumble_MyMessage) -> Bool { + static func ==(lhs: _4fun_SwiftProtoTesting_Mumble_MyMessage, rhs: _4fun_SwiftProtoTesting_Mumble_MyMessage) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true diff --git a/Tests/SwiftProtobufTests/unittest_swift_oneof_all_required.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_oneof_all_required.pb.swift index 8adcf5714..d82adff86 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_oneof_all_required.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_oneof_all_required.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_oneof_all_required.proto @@ -37,7 +38,6 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -50,17 +50,17 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_OneOfOptionMessage1 { +struct SwiftProtoTesting_OneOfOptionMessage1: Sendable { // 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 requiredField: Int32 { - get {return _requiredField ?? 0} + get {_requiredField ?? 0} set {_requiredField = newValue} } /// Returns true if `requiredField` has been explicitly set. - var hasRequiredField: Bool {return self._requiredField != nil} + var hasRequiredField: Bool {self._requiredField != nil} /// Clears the value of `requiredField`. Subsequent reads from it will return its default value. mutating func clearRequiredField() {self._requiredField = nil} @@ -71,17 +71,17 @@ struct ProtobufUnittest_OneOfOptionMessage1 { fileprivate var _requiredField: Int32? = nil } -struct ProtobufUnittest_OneOfOptionMessage2 { +struct SwiftProtoTesting_OneOfOptionMessage2: Sendable { // 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 requiredField: Int32 { - get {return _requiredField ?? 0} + get {_requiredField ?? 0} set {_requiredField = newValue} } /// Returns true if `requiredField` has been explicitly set. - var hasRequiredField: Bool {return self._requiredField != nil} + var hasRequiredField: Bool {self._requiredField != nil} /// Clears the value of `requiredField`. Subsequent reads from it will return its default value. mutating func clearRequiredField() {self._requiredField = nil} @@ -92,33 +92,33 @@ struct ProtobufUnittest_OneOfOptionMessage2 { fileprivate var _requiredField: Int32? = nil } -struct ProtobufUnittest_OneOfContainer { +struct SwiftProtoTesting_OneOfContainer: Sendable { // 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 option: ProtobufUnittest_OneOfContainer.OneOf_Option? = nil + var option: SwiftProtoTesting_OneOfContainer.OneOf_Option? = nil - var option1: ProtobufUnittest_OneOfOptionMessage1 { + var option1: SwiftProtoTesting_OneOfOptionMessage1 { get { if case .option1(let v)? = option {return v} - return ProtobufUnittest_OneOfOptionMessage1() + return SwiftProtoTesting_OneOfOptionMessage1() } set {option = .option1(newValue)} } - var option2: ProtobufUnittest_OneOfOptionMessage2 { + var option2: SwiftProtoTesting_OneOfOptionMessage2 { get { if case .option2(let v)? = option {return v} - return ProtobufUnittest_OneOfOptionMessage2() + return SwiftProtoTesting_OneOfOptionMessage2() } set {option = .option2(newValue)} } - var option3: ProtobufUnittest_OneOfContainer.Option3 { + var option3: SwiftProtoTesting_OneOfContainer.Option3 { get { if case .option3(let v)? = option {return v} - return ProtobufUnittest_OneOfContainer.Option3() + return SwiftProtoTesting_OneOfContainer.Option3() } set {option = .option3(newValue)} } @@ -133,10 +133,10 @@ struct ProtobufUnittest_OneOfContainer { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_Option: Equatable { - case option1(ProtobufUnittest_OneOfOptionMessage1) - case option2(ProtobufUnittest_OneOfOptionMessage2) - case option3(ProtobufUnittest_OneOfContainer.Option3) + enum OneOf_Option: Equatable, Sendable { + case option1(SwiftProtoTesting_OneOfOptionMessage1) + case option2(SwiftProtoTesting_OneOfOptionMessage2) + case option3(SwiftProtoTesting_OneOfContainer.Option3) case option4(Int32) fileprivate var isInitialized: Bool { @@ -160,54 +160,28 @@ struct ProtobufUnittest_OneOfContainer { } } - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_OneOfContainer.OneOf_Option, rhs: ProtobufUnittest_OneOfContainer.OneOf_Option) -> 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 (.option1, .option1): return { - guard case .option1(let l) = lhs, case .option1(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.option2, .option2): return { - guard case .option2(let l) = lhs, case .option2(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.option3, .option3): return { - guard case .option3(let l) = lhs, case .option3(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.option4, .option4): return { - guard case .option4(let l) = lhs, case .option4(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - struct Option3 { + struct Option3: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} var b: String { - get {return _b ?? String()} + get {_b ?? String()} set {_b = newValue} } /// Returns true if `b` has been explicitly set. - var hasB: Bool {return self._b != nil} + var hasB: Bool {self._b != nil} /// Clears the value of `b`. Subsequent reads from it will return its default value. mutating func clearB() {self._b = nil} @@ -222,23 +196,13 @@ struct ProtobufUnittest_OneOfContainer { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_OneOfOptionMessage1: @unchecked Sendable {} -extension ProtobufUnittest_OneOfOptionMessage2: @unchecked Sendable {} -extension ProtobufUnittest_OneOfContainer: @unchecked Sendable {} -extension ProtobufUnittest_OneOfContainer.OneOf_Option: @unchecked Sendable {} -extension ProtobufUnittest_OneOfContainer.Option3: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_OneOfOptionMessage1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_OneOfOptionMessage1: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".OneOfOptionMessage1" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "requiredField"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}requiredField\0") public var isInitialized: Bool { if self._requiredField == nil {return false} @@ -268,18 +232,16 @@ extension ProtobufUnittest_OneOfOptionMessage1: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_OneOfOptionMessage1, rhs: ProtobufUnittest_OneOfOptionMessage1) -> Bool { + static func ==(lhs: SwiftProtoTesting_OneOfOptionMessage1, rhs: SwiftProtoTesting_OneOfOptionMessage1) -> Bool { if lhs._requiredField != rhs._requiredField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_OneOfOptionMessage2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_OneOfOptionMessage2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".OneOfOptionMessage2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "requiredField"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}requiredField\0") public var isInitialized: Bool { if self._requiredField == nil {return false} @@ -309,21 +271,16 @@ extension ProtobufUnittest_OneOfOptionMessage2: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_OneOfOptionMessage2, rhs: ProtobufUnittest_OneOfOptionMessage2) -> Bool { + static func ==(lhs: SwiftProtoTesting_OneOfOptionMessage2, rhs: SwiftProtoTesting_OneOfOptionMessage2) -> Bool { if lhs._requiredField != rhs._requiredField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_OneOfContainer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_OneOfContainer: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".OneOfContainer" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "option1"), - 2: .same(proto: "option2"), - 3: .unique(proto: "Option3", json: "option3"), - 6: .same(proto: "option4"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}option1\0\u{1}option2\0\u{7}Option3\0\u{2}\u{3}option4\0") public var isInitialized: Bool { if let v = self.option, !v.isInitialized {return false} @@ -337,7 +294,7 @@ extension ProtobufUnittest_OneOfContainer: SwiftProtobuf.Message, SwiftProtobuf. // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { case 1: try { - var v: ProtobufUnittest_OneOfOptionMessage1? + var v: SwiftProtoTesting_OneOfOptionMessage1? var hadOneofValue = false if let current = self.option { hadOneofValue = true @@ -350,7 +307,7 @@ extension ProtobufUnittest_OneOfContainer: SwiftProtobuf.Message, SwiftProtobuf. } }() case 2: try { - var v: ProtobufUnittest_OneOfOptionMessage2? + var v: SwiftProtoTesting_OneOfOptionMessage2? var hadOneofValue = false if let current = self.option { hadOneofValue = true @@ -363,7 +320,7 @@ extension ProtobufUnittest_OneOfContainer: SwiftProtobuf.Message, SwiftProtobuf. } }() case 3: try { - var v: ProtobufUnittest_OneOfContainer.Option3? + var v: SwiftProtoTesting_OneOfContainer.Option3? var hadOneofValue = false if let current = self.option { hadOneofValue = true @@ -415,19 +372,16 @@ extension ProtobufUnittest_OneOfContainer: SwiftProtobuf.Message, SwiftProtobuf. try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_OneOfContainer, rhs: ProtobufUnittest_OneOfContainer) -> Bool { + static func ==(lhs: SwiftProtoTesting_OneOfContainer, rhs: SwiftProtoTesting_OneOfContainer) -> Bool { if lhs.option != rhs.option {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_OneOfContainer.Option3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_OneOfContainer.protoMessageName + ".Option3" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 4: .same(proto: "a"), - 5: .same(proto: "b"), - ] +extension SwiftProtoTesting_OneOfContainer.Option3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_OneOfContainer.protoMessageName + ".Option3" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{4}a\0\u{1}b\0") public var isInitialized: Bool { if self._a == nil {return false} @@ -461,7 +415,7 @@ extension ProtobufUnittest_OneOfContainer.Option3: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_OneOfContainer.Option3, rhs: ProtobufUnittest_OneOfContainer.Option3) -> Bool { + static func ==(lhs: SwiftProtoTesting_OneOfContainer.Option3, rhs: SwiftProtoTesting_OneOfContainer.Option3) -> Bool { if lhs._a != rhs._a {return false} if lhs._b != rhs._b {return false} if lhs.unknownFields != rhs.unknownFields {return false} diff --git a/Tests/SwiftProtobufTests/unittest_swift_oneof_merging.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_oneof_merging.pb.swift index 13e3ce71e..63aeddadf 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_oneof_merging.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_oneof_merging.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_oneof_merging.proto @@ -38,12 +39,12 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct SwiftUnittest_TestMessage { +struct SwiftProtoTesting_Merging_TestMessage: Sendable { // 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 oneofField: SwiftUnittest_TestMessage.OneOf_OneofField? = nil + var oneofField: SwiftProtoTesting_Merging_TestMessage.OneOf_OneofField? = nil var oneofUint32: UInt32 { get { @@ -53,10 +54,10 @@ struct SwiftUnittest_TestMessage { set {oneofField = .oneofUint32(newValue)} } - var oneofNestedMessage: SwiftUnittest_TestMessage.NestedMessage { + var oneofNestedMessage: SwiftProtoTesting_Merging_TestMessage.NestedMessage { get { if case .oneofNestedMessage(let v)? = oneofField {return v} - return SwiftUnittest_TestMessage.NestedMessage() + return SwiftProtoTesting_Merging_TestMessage.NestedMessage() } set {oneofField = .oneofNestedMessage(newValue)} } @@ -79,69 +80,43 @@ struct SwiftUnittest_TestMessage { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case oneofUint32(UInt32) - case oneofNestedMessage(SwiftUnittest_TestMessage.NestedMessage) + case oneofNestedMessage(SwiftProtoTesting_Merging_TestMessage.NestedMessage) case oneofString(String) case oneofBytes(Data) - #if !swift(>=4.1) - static func ==(lhs: SwiftUnittest_TestMessage.OneOf_OneofField, rhs: SwiftUnittest_TestMessage.OneOf_OneofField) -> 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 (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofNestedMessage, .oneofNestedMessage): return { - guard case .oneofNestedMessage(let l) = lhs, case .oneofNestedMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - struct NestedMessage { + struct NestedMessage: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} var b: Int32 { - get {return _b ?? 0} + get {_b ?? 0} set {_b = newValue} } /// Returns true if `b` has been explicitly set. - var hasB: Bool {return self._b != nil} + var hasB: Bool {self._b != nil} /// Clears the value of `b`. Subsequent reads from it will return its default value. mutating func clearB() {self._b = nil} var c: Int32 { - get {return _c ?? 0} + get {_c ?? 0} set {_c = newValue} } /// Returns true if `c` has been explicitly set. - var hasC: Bool {return self._c != nil} + var hasC: Bool {self._c != nil} /// Clears the value of `c`. Subsequent reads from it will return its default value. mutating func clearC() {self._c = nil} @@ -157,32 +132,32 @@ struct SwiftUnittest_TestMessage { init() {} } -struct SwiftUnittest_TestParsingMerge { +struct SwiftProtoTesting_Merging_TestParsingMerge: Sendable { // 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 optionalMessage: SwiftUnittest_TestMessage { - get {return _optionalMessage ?? SwiftUnittest_TestMessage()} + var optionalMessage: SwiftProtoTesting_Merging_TestMessage { + get {_optionalMessage ?? SwiftProtoTesting_Merging_TestMessage()} set {_optionalMessage = newValue} } /// Returns true if `optionalMessage` has been explicitly set. - var hasOptionalMessage: Bool {return self._optionalMessage != nil} + var hasOptionalMessage: Bool {self._optionalMessage != nil} /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalMessage() {self._optionalMessage = nil} - var repeatedMessage: [SwiftUnittest_TestMessage] = [] + var repeatedMessage: [SwiftProtoTesting_Merging_TestMessage] = [] var unknownFields = SwiftProtobuf.UnknownStorage() - struct RepeatedFieldsGenerator { + struct RepeatedFieldsGenerator: Sendable { // 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: [SwiftUnittest_TestMessage] = [] + var field1: [SwiftProtoTesting_Merging_TestMessage] = [] - var field2: [SwiftUnittest_TestMessage] = [] + var field2: [SwiftProtoTesting_Merging_TestMessage] = [] var unknownFields = SwiftProtobuf.UnknownStorage() @@ -191,29 +166,16 @@ struct SwiftUnittest_TestParsingMerge { init() {} - fileprivate var _optionalMessage: SwiftUnittest_TestMessage? = nil + fileprivate var _optionalMessage: SwiftProtoTesting_Merging_TestMessage? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension SwiftUnittest_TestMessage: @unchecked Sendable {} -extension SwiftUnittest_TestMessage.OneOf_OneofField: @unchecked Sendable {} -extension SwiftUnittest_TestMessage.NestedMessage: @unchecked Sendable {} -extension SwiftUnittest_TestParsingMerge: @unchecked Sendable {} -extension SwiftUnittest_TestParsingMerge.RepeatedFieldsGenerator: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "swift_unittest" +fileprivate let _protobuf_package = "swift_proto_testing.merging" -extension SwiftUnittest_TestMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Merging_TestMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 111: .standard(proto: "oneof_uint32"), - 112: .standard(proto: "oneof_nested_message"), - 113: .standard(proto: "oneof_string"), - 114: .standard(proto: "oneof_bytes"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}o\u{1}oneof_uint32\0\u{3}oneof_nested_message\0\u{3}oneof_string\0\u{3}oneof_bytes\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -230,7 +192,7 @@ extension SwiftUnittest_TestMessage: SwiftProtobuf.Message, SwiftProtobuf._Messa } }() case 112: try { - var v: SwiftUnittest_TestMessage.NestedMessage? + var v: SwiftProtoTesting_Merging_TestMessage.NestedMessage? var hadOneofValue = false if let current = self.oneofField { hadOneofValue = true @@ -290,20 +252,16 @@ extension SwiftUnittest_TestMessage: SwiftProtobuf.Message, SwiftProtobuf._Messa try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_TestMessage, rhs: SwiftUnittest_TestMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Merging_TestMessage, rhs: SwiftProtoTesting_Merging_TestMessage) -> Bool { if lhs.oneofField != rhs.oneofField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension SwiftUnittest_TestMessage.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_TestMessage.protoMessageName + ".NestedMessage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - 2: .same(proto: "b"), - 3: .same(proto: "c"), - ] +extension SwiftProtoTesting_Merging_TestMessage.NestedMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Merging_TestMessage.protoMessageName + ".NestedMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0\u{1}b\0\u{1}c\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -336,7 +294,7 @@ extension SwiftUnittest_TestMessage.NestedMessage: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_TestMessage.NestedMessage, rhs: SwiftUnittest_TestMessage.NestedMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Merging_TestMessage.NestedMessage, rhs: SwiftProtoTesting_Merging_TestMessage.NestedMessage) -> Bool { if lhs._a != rhs._a {return false} if lhs._b != rhs._b {return false} if lhs._c != rhs._c {return false} @@ -345,12 +303,9 @@ extension SwiftUnittest_TestMessage.NestedMessage: SwiftProtobuf.Message, SwiftP } } -extension SwiftUnittest_TestParsingMerge: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Merging_TestParsingMerge: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestParsingMerge" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_message"), - 2: .standard(proto: "repeated_message"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_message\0\u{3}repeated_message\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -379,7 +334,7 @@ extension SwiftUnittest_TestParsingMerge: SwiftProtobuf.Message, SwiftProtobuf._ try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_TestParsingMerge, rhs: SwiftUnittest_TestParsingMerge) -> Bool { + static func ==(lhs: SwiftProtoTesting_Merging_TestParsingMerge, rhs: SwiftProtoTesting_Merging_TestParsingMerge) -> Bool { if lhs._optionalMessage != rhs._optionalMessage {return false} if lhs.repeatedMessage != rhs.repeatedMessage {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -387,12 +342,9 @@ extension SwiftUnittest_TestParsingMerge: SwiftProtobuf.Message, SwiftProtobuf._ } } -extension SwiftUnittest_TestParsingMerge.RepeatedFieldsGenerator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = SwiftUnittest_TestParsingMerge.protoMessageName + ".RepeatedFieldsGenerator" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "field1"), - 2: .same(proto: "field2"), - ] +extension SwiftProtoTesting_Merging_TestParsingMerge.RepeatedFieldsGenerator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Merging_TestParsingMerge.protoMessageName + ".RepeatedFieldsGenerator" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}field1\0\u{1}field2\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -417,7 +369,7 @@ extension SwiftUnittest_TestParsingMerge.RepeatedFieldsGenerator: SwiftProtobuf. try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: SwiftUnittest_TestParsingMerge.RepeatedFieldsGenerator, rhs: SwiftUnittest_TestParsingMerge.RepeatedFieldsGenerator) -> Bool { + static func ==(lhs: SwiftProtoTesting_Merging_TestParsingMerge.RepeatedFieldsGenerator, rhs: SwiftProtoTesting_Merging_TestParsingMerge.RepeatedFieldsGenerator) -> Bool { if lhs.field1 != rhs.field1 {return false} if lhs.field2 != rhs.field2 {return false} if lhs.unknownFields != rhs.unknownFields {return false} diff --git a/Tests/SwiftProtobufTests/unittest_swift_oneof_switch_split.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_oneof_switch_split.pb.swift new file mode 100644 index 000000000..8a0d891d2 --- /dev/null +++ b/Tests/SwiftProtobufTests/unittest_swift_oneof_switch_split.pb.swift @@ -0,0 +1,10789 @@ +// DO NOT EDIT. +// swift-format-ignore-file +// swiftlint:disable all +// +// Generated by the Swift generator plugin for the protocol buffer compiler. +// Source: unittest_swift_oneof_switch_split.proto +// +// For information on using the generated types, please see the documentation: +// https://github.com/apple/swift-protobuf/ + +// Protos/Tests/SwiftProtobufTests/unittest_swift_oneof_switch_split.proto +// Test for switch statement splitting in oneof traverse generation +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2025 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 +// +// ----------------------------------------------------------------------------- +/// +/// This message tests oneof switch splitting with interleaved non-oneof fields. +/// - Regular fields at 2, 251, 502, and 509 break oneof into multiple chunks +/// - Regular field at 2 creates first break +/// - Regular field at 251 creates second break +/// - Regular field at 502 creates third break +/// - Regular field at 509 creates fourth break +/// - The oneof fields are also reordered to test proper sorting in generated code +/// +// ----------------------------------------------------------------------------- + +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 SwiftProtoTesting_SwitchSplit_SwitchSplitMessage: Sendable { + // 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. + + /// Regular fields that split the oneof into chunks + var regularField002: Int32 { + get {_regularField002 ?? 0} + set {_regularField002 = newValue} + } + /// Returns true if `regularField002` has been explicitly set. + var hasRegularField002: Bool {self._regularField002 != nil} + /// Clears the value of `regularField002`. Subsequent reads from it will return its default value. + mutating func clearRegularField002() {self._regularField002 = nil} + + var regularField251: Int32 { + get {_regularField251 ?? 0} + set {_regularField251 = newValue} + } + /// Returns true if `regularField251` has been explicitly set. + var hasRegularField251: Bool {self._regularField251 != nil} + /// Clears the value of `regularField251`. Subsequent reads from it will return its default value. + mutating func clearRegularField251() {self._regularField251 = nil} + + var regularField502: Int32 { + get {_regularField502 ?? 0} + set {_regularField502 = newValue} + } + /// Returns true if `regularField502` has been explicitly set. + var hasRegularField502: Bool {self._regularField502 != nil} + /// Clears the value of `regularField502`. Subsequent reads from it will return its default value. + mutating func clearRegularField502() {self._regularField502 = nil} + + var regularField509: Int32 { + get {_regularField509 ?? 0} + set {_regularField509 = newValue} + } + /// Returns true if `regularField509` has been explicitly set. + var hasRegularField509: Bool {self._regularField509 != nil} + /// Clears the value of `regularField509`. Subsequent reads from it will return its default value. + mutating func clearRegularField509() {self._regularField509 = nil} + + var value: SwiftProtoTesting_SwitchSplit_SwitchSplitMessage.OneOf_Value? = nil + + var field001: Int32 { + get { + if case .field001(let v)? = value {return v} + return 0 + } + set {value = .field001(newValue)} + } + + var field003: Int32 { + get { + if case .field003(let v)? = value {return v} + return 0 + } + set {value = .field003(newValue)} + } + + var field004: Int32 { + get { + if case .field004(let v)? = value {return v} + return 0 + } + set {value = .field004(newValue)} + } + + var field005: Int32 { + get { + if case .field005(let v)? = value {return v} + return 0 + } + set {value = .field005(newValue)} + } + + var field006: Int32 { + get { + if case .field006(let v)? = value {return v} + return 0 + } + set {value = .field006(newValue)} + } + + var field007: Int32 { + get { + if case .field007(let v)? = value {return v} + return 0 + } + set {value = .field007(newValue)} + } + + var field008: Int32 { + get { + if case .field008(let v)? = value {return v} + return 0 + } + set {value = .field008(newValue)} + } + + var field009: Int32 { + get { + if case .field009(let v)? = value {return v} + return 0 + } + set {value = .field009(newValue)} + } + + var field010: Int32 { + get { + if case .field010(let v)? = value {return v} + return 0 + } + set {value = .field010(newValue)} + } + + var field011: Int32 { + get { + if case .field011(let v)? = value {return v} + return 0 + } + set {value = .field011(newValue)} + } + + var field012: Int32 { + get { + if case .field012(let v)? = value {return v} + return 0 + } + set {value = .field012(newValue)} + } + + var field013: Int32 { + get { + if case .field013(let v)? = value {return v} + return 0 + } + set {value = .field013(newValue)} + } + + var field014: Int32 { + get { + if case .field014(let v)? = value {return v} + return 0 + } + set {value = .field014(newValue)} + } + + var field015: Int32 { + get { + if case .field015(let v)? = value {return v} + return 0 + } + set {value = .field015(newValue)} + } + + var field016: Int32 { + get { + if case .field016(let v)? = value {return v} + return 0 + } + set {value = .field016(newValue)} + } + + var field017: Int32 { + get { + if case .field017(let v)? = value {return v} + return 0 + } + set {value = .field017(newValue)} + } + + var field018: Int32 { + get { + if case .field018(let v)? = value {return v} + return 0 + } + set {value = .field018(newValue)} + } + + var field019: Int32 { + get { + if case .field019(let v)? = value {return v} + return 0 + } + set {value = .field019(newValue)} + } + + var field020: Int32 { + get { + if case .field020(let v)? = value {return v} + return 0 + } + set {value = .field020(newValue)} + } + + var field021: Int32 { + get { + if case .field021(let v)? = value {return v} + return 0 + } + set {value = .field021(newValue)} + } + + var field022: Int32 { + get { + if case .field022(let v)? = value {return v} + return 0 + } + set {value = .field022(newValue)} + } + + var field023: Int32 { + get { + if case .field023(let v)? = value {return v} + return 0 + } + set {value = .field023(newValue)} + } + + var field024: Int32 { + get { + if case .field024(let v)? = value {return v} + return 0 + } + set {value = .field024(newValue)} + } + + var field025: Int32 { + get { + if case .field025(let v)? = value {return v} + return 0 + } + set {value = .field025(newValue)} + } + + var field026: Int32 { + get { + if case .field026(let v)? = value {return v} + return 0 + } + set {value = .field026(newValue)} + } + + var field027: Int32 { + get { + if case .field027(let v)? = value {return v} + return 0 + } + set {value = .field027(newValue)} + } + + var field028: Int32 { + get { + if case .field028(let v)? = value {return v} + return 0 + } + set {value = .field028(newValue)} + } + + var field029: Int32 { + get { + if case .field029(let v)? = value {return v} + return 0 + } + set {value = .field029(newValue)} + } + + var field030: Int32 { + get { + if case .field030(let v)? = value {return v} + return 0 + } + set {value = .field030(newValue)} + } + + var field031: Int32 { + get { + if case .field031(let v)? = value {return v} + return 0 + } + set {value = .field031(newValue)} + } + + var field032: Int32 { + get { + if case .field032(let v)? = value {return v} + return 0 + } + set {value = .field032(newValue)} + } + + var field033: Int32 { + get { + if case .field033(let v)? = value {return v} + return 0 + } + set {value = .field033(newValue)} + } + + var field034: Int32 { + get { + if case .field034(let v)? = value {return v} + return 0 + } + set {value = .field034(newValue)} + } + + var field035: Int32 { + get { + if case .field035(let v)? = value {return v} + return 0 + } + set {value = .field035(newValue)} + } + + var field036: Int32 { + get { + if case .field036(let v)? = value {return v} + return 0 + } + set {value = .field036(newValue)} + } + + var field037: Int32 { + get { + if case .field037(let v)? = value {return v} + return 0 + } + set {value = .field037(newValue)} + } + + var field038: Int32 { + get { + if case .field038(let v)? = value {return v} + return 0 + } + set {value = .field038(newValue)} + } + + var field039: Int32 { + get { + if case .field039(let v)? = value {return v} + return 0 + } + set {value = .field039(newValue)} + } + + var field040: Int32 { + get { + if case .field040(let v)? = value {return v} + return 0 + } + set {value = .field040(newValue)} + } + + var field041: Int32 { + get { + if case .field041(let v)? = value {return v} + return 0 + } + set {value = .field041(newValue)} + } + + var field042: Int32 { + get { + if case .field042(let v)? = value {return v} + return 0 + } + set {value = .field042(newValue)} + } + + var field043: Int32 { + get { + if case .field043(let v)? = value {return v} + return 0 + } + set {value = .field043(newValue)} + } + + var field044: Int32 { + get { + if case .field044(let v)? = value {return v} + return 0 + } + set {value = .field044(newValue)} + } + + var field045: Int32 { + get { + if case .field045(let v)? = value {return v} + return 0 + } + set {value = .field045(newValue)} + } + + var field046: Int32 { + get { + if case .field046(let v)? = value {return v} + return 0 + } + set {value = .field046(newValue)} + } + + var field047: Int32 { + get { + if case .field047(let v)? = value {return v} + return 0 + } + set {value = .field047(newValue)} + } + + var field048: Int32 { + get { + if case .field048(let v)? = value {return v} + return 0 + } + set {value = .field048(newValue)} + } + + var field049: Int32 { + get { + if case .field049(let v)? = value {return v} + return 0 + } + set {value = .field049(newValue)} + } + + var field050: Int32 { + get { + if case .field050(let v)? = value {return v} + return 0 + } + set {value = .field050(newValue)} + } + + var field051: Int32 { + get { + if case .field051(let v)? = value {return v} + return 0 + } + set {value = .field051(newValue)} + } + + var field052: Int32 { + get { + if case .field052(let v)? = value {return v} + return 0 + } + set {value = .field052(newValue)} + } + + var field053: Int32 { + get { + if case .field053(let v)? = value {return v} + return 0 + } + set {value = .field053(newValue)} + } + + var field054: Int32 { + get { + if case .field054(let v)? = value {return v} + return 0 + } + set {value = .field054(newValue)} + } + + var field055: Int32 { + get { + if case .field055(let v)? = value {return v} + return 0 + } + set {value = .field055(newValue)} + } + + var field056: Int32 { + get { + if case .field056(let v)? = value {return v} + return 0 + } + set {value = .field056(newValue)} + } + + var field057: Int32 { + get { + if case .field057(let v)? = value {return v} + return 0 + } + set {value = .field057(newValue)} + } + + var field058: Int32 { + get { + if case .field058(let v)? = value {return v} + return 0 + } + set {value = .field058(newValue)} + } + + var field059: Int32 { + get { + if case .field059(let v)? = value {return v} + return 0 + } + set {value = .field059(newValue)} + } + + var field060: Int32 { + get { + if case .field060(let v)? = value {return v} + return 0 + } + set {value = .field060(newValue)} + } + + var field061: Int32 { + get { + if case .field061(let v)? = value {return v} + return 0 + } + set {value = .field061(newValue)} + } + + var field062: Int32 { + get { + if case .field062(let v)? = value {return v} + return 0 + } + set {value = .field062(newValue)} + } + + var field063: Int32 { + get { + if case .field063(let v)? = value {return v} + return 0 + } + set {value = .field063(newValue)} + } + + var field064: Int32 { + get { + if case .field064(let v)? = value {return v} + return 0 + } + set {value = .field064(newValue)} + } + + var field065: Int32 { + get { + if case .field065(let v)? = value {return v} + return 0 + } + set {value = .field065(newValue)} + } + + var field066: Int32 { + get { + if case .field066(let v)? = value {return v} + return 0 + } + set {value = .field066(newValue)} + } + + var field067: Int32 { + get { + if case .field067(let v)? = value {return v} + return 0 + } + set {value = .field067(newValue)} + } + + var field068: Int32 { + get { + if case .field068(let v)? = value {return v} + return 0 + } + set {value = .field068(newValue)} + } + + var field069: Int32 { + get { + if case .field069(let v)? = value {return v} + return 0 + } + set {value = .field069(newValue)} + } + + var field070: Int32 { + get { + if case .field070(let v)? = value {return v} + return 0 + } + set {value = .field070(newValue)} + } + + var field071: Int32 { + get { + if case .field071(let v)? = value {return v} + return 0 + } + set {value = .field071(newValue)} + } + + var field072: Int32 { + get { + if case .field072(let v)? = value {return v} + return 0 + } + set {value = .field072(newValue)} + } + + var field073: Int32 { + get { + if case .field073(let v)? = value {return v} + return 0 + } + set {value = .field073(newValue)} + } + + var field074: Int32 { + get { + if case .field074(let v)? = value {return v} + return 0 + } + set {value = .field074(newValue)} + } + + var field075: Int32 { + get { + if case .field075(let v)? = value {return v} + return 0 + } + set {value = .field075(newValue)} + } + + var field076: Int32 { + get { + if case .field076(let v)? = value {return v} + return 0 + } + set {value = .field076(newValue)} + } + + var field077: Int32 { + get { + if case .field077(let v)? = value {return v} + return 0 + } + set {value = .field077(newValue)} + } + + var field078: Int32 { + get { + if case .field078(let v)? = value {return v} + return 0 + } + set {value = .field078(newValue)} + } + + var field079: Int32 { + get { + if case .field079(let v)? = value {return v} + return 0 + } + set {value = .field079(newValue)} + } + + var field080: Int32 { + get { + if case .field080(let v)? = value {return v} + return 0 + } + set {value = .field080(newValue)} + } + + var field081: Int32 { + get { + if case .field081(let v)? = value {return v} + return 0 + } + set {value = .field081(newValue)} + } + + var field082: Int32 { + get { + if case .field082(let v)? = value {return v} + return 0 + } + set {value = .field082(newValue)} + } + + var field083: Int32 { + get { + if case .field083(let v)? = value {return v} + return 0 + } + set {value = .field083(newValue)} + } + + var field084: Int32 { + get { + if case .field084(let v)? = value {return v} + return 0 + } + set {value = .field084(newValue)} + } + + var field085: Int32 { + get { + if case .field085(let v)? = value {return v} + return 0 + } + set {value = .field085(newValue)} + } + + var field086: Int32 { + get { + if case .field086(let v)? = value {return v} + return 0 + } + set {value = .field086(newValue)} + } + + var field087: Int32 { + get { + if case .field087(let v)? = value {return v} + return 0 + } + set {value = .field087(newValue)} + } + + var field088: Int32 { + get { + if case .field088(let v)? = value {return v} + return 0 + } + set {value = .field088(newValue)} + } + + var field089: Int32 { + get { + if case .field089(let v)? = value {return v} + return 0 + } + set {value = .field089(newValue)} + } + + var field090: Int32 { + get { + if case .field090(let v)? = value {return v} + return 0 + } + set {value = .field090(newValue)} + } + + var field091: Int32 { + get { + if case .field091(let v)? = value {return v} + return 0 + } + set {value = .field091(newValue)} + } + + var field092: Int32 { + get { + if case .field092(let v)? = value {return v} + return 0 + } + set {value = .field092(newValue)} + } + + var field093: Int32 { + get { + if case .field093(let v)? = value {return v} + return 0 + } + set {value = .field093(newValue)} + } + + var field094: Int32 { + get { + if case .field094(let v)? = value {return v} + return 0 + } + set {value = .field094(newValue)} + } + + var field095: Int32 { + get { + if case .field095(let v)? = value {return v} + return 0 + } + set {value = .field095(newValue)} + } + + var field096: Int32 { + get { + if case .field096(let v)? = value {return v} + return 0 + } + set {value = .field096(newValue)} + } + + var field097: Int32 { + get { + if case .field097(let v)? = value {return v} + return 0 + } + set {value = .field097(newValue)} + } + + var field098: Int32 { + get { + if case .field098(let v)? = value {return v} + return 0 + } + set {value = .field098(newValue)} + } + + var field099: Int32 { + get { + if case .field099(let v)? = value {return v} + return 0 + } + set {value = .field099(newValue)} + } + + var field100: Int32 { + get { + if case .field100(let v)? = value {return v} + return 0 + } + set {value = .field100(newValue)} + } + + var field101: Int32 { + get { + if case .field101(let v)? = value {return v} + return 0 + } + set {value = .field101(newValue)} + } + + var field102: Int32 { + get { + if case .field102(let v)? = value {return v} + return 0 + } + set {value = .field102(newValue)} + } + + var field103: Int32 { + get { + if case .field103(let v)? = value {return v} + return 0 + } + set {value = .field103(newValue)} + } + + var field104: Int32 { + get { + if case .field104(let v)? = value {return v} + return 0 + } + set {value = .field104(newValue)} + } + + var field105: Int32 { + get { + if case .field105(let v)? = value {return v} + return 0 + } + set {value = .field105(newValue)} + } + + var field106: Int32 { + get { + if case .field106(let v)? = value {return v} + return 0 + } + set {value = .field106(newValue)} + } + + var field107: Int32 { + get { + if case .field107(let v)? = value {return v} + return 0 + } + set {value = .field107(newValue)} + } + + var field108: Int32 { + get { + if case .field108(let v)? = value {return v} + return 0 + } + set {value = .field108(newValue)} + } + + var field109: Int32 { + get { + if case .field109(let v)? = value {return v} + return 0 + } + set {value = .field109(newValue)} + } + + var field110: Int32 { + get { + if case .field110(let v)? = value {return v} + return 0 + } + set {value = .field110(newValue)} + } + + var field111: Int32 { + get { + if case .field111(let v)? = value {return v} + return 0 + } + set {value = .field111(newValue)} + } + + var field112: Int32 { + get { + if case .field112(let v)? = value {return v} + return 0 + } + set {value = .field112(newValue)} + } + + var field113: Int32 { + get { + if case .field113(let v)? = value {return v} + return 0 + } + set {value = .field113(newValue)} + } + + var field114: Int32 { + get { + if case .field114(let v)? = value {return v} + return 0 + } + set {value = .field114(newValue)} + } + + var field115: Int32 { + get { + if case .field115(let v)? = value {return v} + return 0 + } + set {value = .field115(newValue)} + } + + var field116: Int32 { + get { + if case .field116(let v)? = value {return v} + return 0 + } + set {value = .field116(newValue)} + } + + var field117: Int32 { + get { + if case .field117(let v)? = value {return v} + return 0 + } + set {value = .field117(newValue)} + } + + var field118: Int32 { + get { + if case .field118(let v)? = value {return v} + return 0 + } + set {value = .field118(newValue)} + } + + var field119: Int32 { + get { + if case .field119(let v)? = value {return v} + return 0 + } + set {value = .field119(newValue)} + } + + var field120: Int32 { + get { + if case .field120(let v)? = value {return v} + return 0 + } + set {value = .field120(newValue)} + } + + var field121: Int32 { + get { + if case .field121(let v)? = value {return v} + return 0 + } + set {value = .field121(newValue)} + } + + var field122: Int32 { + get { + if case .field122(let v)? = value {return v} + return 0 + } + set {value = .field122(newValue)} + } + + var field123: Int32 { + get { + if case .field123(let v)? = value {return v} + return 0 + } + set {value = .field123(newValue)} + } + + var field124: Int32 { + get { + if case .field124(let v)? = value {return v} + return 0 + } + set {value = .field124(newValue)} + } + + var field125: Int32 { + get { + if case .field125(let v)? = value {return v} + return 0 + } + set {value = .field125(newValue)} + } + + var field126: Int32 { + get { + if case .field126(let v)? = value {return v} + return 0 + } + set {value = .field126(newValue)} + } + + var field127: Int32 { + get { + if case .field127(let v)? = value {return v} + return 0 + } + set {value = .field127(newValue)} + } + + var field128: Int32 { + get { + if case .field128(let v)? = value {return v} + return 0 + } + set {value = .field128(newValue)} + } + + var field129: Int32 { + get { + if case .field129(let v)? = value {return v} + return 0 + } + set {value = .field129(newValue)} + } + + var field130: Int32 { + get { + if case .field130(let v)? = value {return v} + return 0 + } + set {value = .field130(newValue)} + } + + var field131: Int32 { + get { + if case .field131(let v)? = value {return v} + return 0 + } + set {value = .field131(newValue)} + } + + var field132: Int32 { + get { + if case .field132(let v)? = value {return v} + return 0 + } + set {value = .field132(newValue)} + } + + var field133: Int32 { + get { + if case .field133(let v)? = value {return v} + return 0 + } + set {value = .field133(newValue)} + } + + var field134: Int32 { + get { + if case .field134(let v)? = value {return v} + return 0 + } + set {value = .field134(newValue)} + } + + var field135: Int32 { + get { + if case .field135(let v)? = value {return v} + return 0 + } + set {value = .field135(newValue)} + } + + var field136: Int32 { + get { + if case .field136(let v)? = value {return v} + return 0 + } + set {value = .field136(newValue)} + } + + var field137: Int32 { + get { + if case .field137(let v)? = value {return v} + return 0 + } + set {value = .field137(newValue)} + } + + var field138: Int32 { + get { + if case .field138(let v)? = value {return v} + return 0 + } + set {value = .field138(newValue)} + } + + var field139: Int32 { + get { + if case .field139(let v)? = value {return v} + return 0 + } + set {value = .field139(newValue)} + } + + var field140: Int32 { + get { + if case .field140(let v)? = value {return v} + return 0 + } + set {value = .field140(newValue)} + } + + var field141: Int32 { + get { + if case .field141(let v)? = value {return v} + return 0 + } + set {value = .field141(newValue)} + } + + var field142: Int32 { + get { + if case .field142(let v)? = value {return v} + return 0 + } + set {value = .field142(newValue)} + } + + var field143: Int32 { + get { + if case .field143(let v)? = value {return v} + return 0 + } + set {value = .field143(newValue)} + } + + var field144: Int32 { + get { + if case .field144(let v)? = value {return v} + return 0 + } + set {value = .field144(newValue)} + } + + var field145: Int32 { + get { + if case .field145(let v)? = value {return v} + return 0 + } + set {value = .field145(newValue)} + } + + var field146: Int32 { + get { + if case .field146(let v)? = value {return v} + return 0 + } + set {value = .field146(newValue)} + } + + var field147: Int32 { + get { + if case .field147(let v)? = value {return v} + return 0 + } + set {value = .field147(newValue)} + } + + var field148: Int32 { + get { + if case .field148(let v)? = value {return v} + return 0 + } + set {value = .field148(newValue)} + } + + var field149: Int32 { + get { + if case .field149(let v)? = value {return v} + return 0 + } + set {value = .field149(newValue)} + } + + var field150: Int32 { + get { + if case .field150(let v)? = value {return v} + return 0 + } + set {value = .field150(newValue)} + } + + var field151: Int32 { + get { + if case .field151(let v)? = value {return v} + return 0 + } + set {value = .field151(newValue)} + } + + var field152: Int32 { + get { + if case .field152(let v)? = value {return v} + return 0 + } + set {value = .field152(newValue)} + } + + var field153: Int32 { + get { + if case .field153(let v)? = value {return v} + return 0 + } + set {value = .field153(newValue)} + } + + var field154: Int32 { + get { + if case .field154(let v)? = value {return v} + return 0 + } + set {value = .field154(newValue)} + } + + var field155: Int32 { + get { + if case .field155(let v)? = value {return v} + return 0 + } + set {value = .field155(newValue)} + } + + var field156: Int32 { + get { + if case .field156(let v)? = value {return v} + return 0 + } + set {value = .field156(newValue)} + } + + var field157: Int32 { + get { + if case .field157(let v)? = value {return v} + return 0 + } + set {value = .field157(newValue)} + } + + var field158: Int32 { + get { + if case .field158(let v)? = value {return v} + return 0 + } + set {value = .field158(newValue)} + } + + var field159: Int32 { + get { + if case .field159(let v)? = value {return v} + return 0 + } + set {value = .field159(newValue)} + } + + var field160: Int32 { + get { + if case .field160(let v)? = value {return v} + return 0 + } + set {value = .field160(newValue)} + } + + var field161: Int32 { + get { + if case .field161(let v)? = value {return v} + return 0 + } + set {value = .field161(newValue)} + } + + var field162: Int32 { + get { + if case .field162(let v)? = value {return v} + return 0 + } + set {value = .field162(newValue)} + } + + var field163: Int32 { + get { + if case .field163(let v)? = value {return v} + return 0 + } + set {value = .field163(newValue)} + } + + var field164: Int32 { + get { + if case .field164(let v)? = value {return v} + return 0 + } + set {value = .field164(newValue)} + } + + var field165: Int32 { + get { + if case .field165(let v)? = value {return v} + return 0 + } + set {value = .field165(newValue)} + } + + var field166: Int32 { + get { + if case .field166(let v)? = value {return v} + return 0 + } + set {value = .field166(newValue)} + } + + var field167: Int32 { + get { + if case .field167(let v)? = value {return v} + return 0 + } + set {value = .field167(newValue)} + } + + var field168: Int32 { + get { + if case .field168(let v)? = value {return v} + return 0 + } + set {value = .field168(newValue)} + } + + var field169: Int32 { + get { + if case .field169(let v)? = value {return v} + return 0 + } + set {value = .field169(newValue)} + } + + var field170: Int32 { + get { + if case .field170(let v)? = value {return v} + return 0 + } + set {value = .field170(newValue)} + } + + var field171: Int32 { + get { + if case .field171(let v)? = value {return v} + return 0 + } + set {value = .field171(newValue)} + } + + var field172: Int32 { + get { + if case .field172(let v)? = value {return v} + return 0 + } + set {value = .field172(newValue)} + } + + var field173: Int32 { + get { + if case .field173(let v)? = value {return v} + return 0 + } + set {value = .field173(newValue)} + } + + var field174: Int32 { + get { + if case .field174(let v)? = value {return v} + return 0 + } + set {value = .field174(newValue)} + } + + var field175: Int32 { + get { + if case .field175(let v)? = value {return v} + return 0 + } + set {value = .field175(newValue)} + } + + var field176: Int32 { + get { + if case .field176(let v)? = value {return v} + return 0 + } + set {value = .field176(newValue)} + } + + var field177: Int32 { + get { + if case .field177(let v)? = value {return v} + return 0 + } + set {value = .field177(newValue)} + } + + var field178: Int32 { + get { + if case .field178(let v)? = value {return v} + return 0 + } + set {value = .field178(newValue)} + } + + var field179: Int32 { + get { + if case .field179(let v)? = value {return v} + return 0 + } + set {value = .field179(newValue)} + } + + var field180: Int32 { + get { + if case .field180(let v)? = value {return v} + return 0 + } + set {value = .field180(newValue)} + } + + var field181: Int32 { + get { + if case .field181(let v)? = value {return v} + return 0 + } + set {value = .field181(newValue)} + } + + var field182: Int32 { + get { + if case .field182(let v)? = value {return v} + return 0 + } + set {value = .field182(newValue)} + } + + var field183: Int32 { + get { + if case .field183(let v)? = value {return v} + return 0 + } + set {value = .field183(newValue)} + } + + var field184: Int32 { + get { + if case .field184(let v)? = value {return v} + return 0 + } + set {value = .field184(newValue)} + } + + var field185: Int32 { + get { + if case .field185(let v)? = value {return v} + return 0 + } + set {value = .field185(newValue)} + } + + var field186: Int32 { + get { + if case .field186(let v)? = value {return v} + return 0 + } + set {value = .field186(newValue)} + } + + var field187: Int32 { + get { + if case .field187(let v)? = value {return v} + return 0 + } + set {value = .field187(newValue)} + } + + var field188: Int32 { + get { + if case .field188(let v)? = value {return v} + return 0 + } + set {value = .field188(newValue)} + } + + var field189: Int32 { + get { + if case .field189(let v)? = value {return v} + return 0 + } + set {value = .field189(newValue)} + } + + var field190: Int32 { + get { + if case .field190(let v)? = value {return v} + return 0 + } + set {value = .field190(newValue)} + } + + var field191: Int32 { + get { + if case .field191(let v)? = value {return v} + return 0 + } + set {value = .field191(newValue)} + } + + var field192: Int32 { + get { + if case .field192(let v)? = value {return v} + return 0 + } + set {value = .field192(newValue)} + } + + var field193: Int32 { + get { + if case .field193(let v)? = value {return v} + return 0 + } + set {value = .field193(newValue)} + } + + var field194: Int32 { + get { + if case .field194(let v)? = value {return v} + return 0 + } + set {value = .field194(newValue)} + } + + var field195: Int32 { + get { + if case .field195(let v)? = value {return v} + return 0 + } + set {value = .field195(newValue)} + } + + var field196: Int32 { + get { + if case .field196(let v)? = value {return v} + return 0 + } + set {value = .field196(newValue)} + } + + var field197: Int32 { + get { + if case .field197(let v)? = value {return v} + return 0 + } + set {value = .field197(newValue)} + } + + var field198: Int32 { + get { + if case .field198(let v)? = value {return v} + return 0 + } + set {value = .field198(newValue)} + } + + var field199: Int32 { + get { + if case .field199(let v)? = value {return v} + return 0 + } + set {value = .field199(newValue)} + } + + var field200: Int32 { + get { + if case .field200(let v)? = value {return v} + return 0 + } + set {value = .field200(newValue)} + } + + var field201: Int32 { + get { + if case .field201(let v)? = value {return v} + return 0 + } + set {value = .field201(newValue)} + } + + var field202: Int32 { + get { + if case .field202(let v)? = value {return v} + return 0 + } + set {value = .field202(newValue)} + } + + var field203: Int32 { + get { + if case .field203(let v)? = value {return v} + return 0 + } + set {value = .field203(newValue)} + } + + var field204: Int32 { + get { + if case .field204(let v)? = value {return v} + return 0 + } + set {value = .field204(newValue)} + } + + var field205: Int32 { + get { + if case .field205(let v)? = value {return v} + return 0 + } + set {value = .field205(newValue)} + } + + var field206: Int32 { + get { + if case .field206(let v)? = value {return v} + return 0 + } + set {value = .field206(newValue)} + } + + var field207: Int32 { + get { + if case .field207(let v)? = value {return v} + return 0 + } + set {value = .field207(newValue)} + } + + var field208: Int32 { + get { + if case .field208(let v)? = value {return v} + return 0 + } + set {value = .field208(newValue)} + } + + var field209: Int32 { + get { + if case .field209(let v)? = value {return v} + return 0 + } + set {value = .field209(newValue)} + } + + var field210: Int32 { + get { + if case .field210(let v)? = value {return v} + return 0 + } + set {value = .field210(newValue)} + } + + var field211: Int32 { + get { + if case .field211(let v)? = value {return v} + return 0 + } + set {value = .field211(newValue)} + } + + var field212: Int32 { + get { + if case .field212(let v)? = value {return v} + return 0 + } + set {value = .field212(newValue)} + } + + var field213: Int32 { + get { + if case .field213(let v)? = value {return v} + return 0 + } + set {value = .field213(newValue)} + } + + var field214: Int32 { + get { + if case .field214(let v)? = value {return v} + return 0 + } + set {value = .field214(newValue)} + } + + var field215: Int32 { + get { + if case .field215(let v)? = value {return v} + return 0 + } + set {value = .field215(newValue)} + } + + var field216: Int32 { + get { + if case .field216(let v)? = value {return v} + return 0 + } + set {value = .field216(newValue)} + } + + var field217: Int32 { + get { + if case .field217(let v)? = value {return v} + return 0 + } + set {value = .field217(newValue)} + } + + var field218: Int32 { + get { + if case .field218(let v)? = value {return v} + return 0 + } + set {value = .field218(newValue)} + } + + var field219: Int32 { + get { + if case .field219(let v)? = value {return v} + return 0 + } + set {value = .field219(newValue)} + } + + var field220: Int32 { + get { + if case .field220(let v)? = value {return v} + return 0 + } + set {value = .field220(newValue)} + } + + var field221: Int32 { + get { + if case .field221(let v)? = value {return v} + return 0 + } + set {value = .field221(newValue)} + } + + var field222: Int32 { + get { + if case .field222(let v)? = value {return v} + return 0 + } + set {value = .field222(newValue)} + } + + var field223: Int32 { + get { + if case .field223(let v)? = value {return v} + return 0 + } + set {value = .field223(newValue)} + } + + var field224: Int32 { + get { + if case .field224(let v)? = value {return v} + return 0 + } + set {value = .field224(newValue)} + } + + var field225: Int32 { + get { + if case .field225(let v)? = value {return v} + return 0 + } + set {value = .field225(newValue)} + } + + var field226: Int32 { + get { + if case .field226(let v)? = value {return v} + return 0 + } + set {value = .field226(newValue)} + } + + var field227: Int32 { + get { + if case .field227(let v)? = value {return v} + return 0 + } + set {value = .field227(newValue)} + } + + var field228: Int32 { + get { + if case .field228(let v)? = value {return v} + return 0 + } + set {value = .field228(newValue)} + } + + var field229: Int32 { + get { + if case .field229(let v)? = value {return v} + return 0 + } + set {value = .field229(newValue)} + } + + var field230: Int32 { + get { + if case .field230(let v)? = value {return v} + return 0 + } + set {value = .field230(newValue)} + } + + var field231: Int32 { + get { + if case .field231(let v)? = value {return v} + return 0 + } + set {value = .field231(newValue)} + } + + var field232: Int32 { + get { + if case .field232(let v)? = value {return v} + return 0 + } + set {value = .field232(newValue)} + } + + var field233: Int32 { + get { + if case .field233(let v)? = value {return v} + return 0 + } + set {value = .field233(newValue)} + } + + var field234: Int32 { + get { + if case .field234(let v)? = value {return v} + return 0 + } + set {value = .field234(newValue)} + } + + var field235: Int32 { + get { + if case .field235(let v)? = value {return v} + return 0 + } + set {value = .field235(newValue)} + } + + var field236: Int32 { + get { + if case .field236(let v)? = value {return v} + return 0 + } + set {value = .field236(newValue)} + } + + var field237: Int32 { + get { + if case .field237(let v)? = value {return v} + return 0 + } + set {value = .field237(newValue)} + } + + var field238: Int32 { + get { + if case .field238(let v)? = value {return v} + return 0 + } + set {value = .field238(newValue)} + } + + var field239: Int32 { + get { + if case .field239(let v)? = value {return v} + return 0 + } + set {value = .field239(newValue)} + } + + var field240: Int32 { + get { + if case .field240(let v)? = value {return v} + return 0 + } + set {value = .field240(newValue)} + } + + var field241: Int32 { + get { + if case .field241(let v)? = value {return v} + return 0 + } + set {value = .field241(newValue)} + } + + var field242: Int32 { + get { + if case .field242(let v)? = value {return v} + return 0 + } + set {value = .field242(newValue)} + } + + var field243: Int32 { + get { + if case .field243(let v)? = value {return v} + return 0 + } + set {value = .field243(newValue)} + } + + var field244: Int32 { + get { + if case .field244(let v)? = value {return v} + return 0 + } + set {value = .field244(newValue)} + } + + var field245: Int32 { + get { + if case .field245(let v)? = value {return v} + return 0 + } + set {value = .field245(newValue)} + } + + var field246: Int32 { + get { + if case .field246(let v)? = value {return v} + return 0 + } + set {value = .field246(newValue)} + } + + var field247: Int32 { + get { + if case .field247(let v)? = value {return v} + return 0 + } + set {value = .field247(newValue)} + } + + var field248: Int32 { + get { + if case .field248(let v)? = value {return v} + return 0 + } + set {value = .field248(newValue)} + } + + var field249: Int32 { + get { + if case .field249(let v)? = value {return v} + return 0 + } + set {value = .field249(newValue)} + } + + var field250: Int32 { + get { + if case .field250(let v)? = value {return v} + return 0 + } + set {value = .field250(newValue)} + } + + var field252: Int32 { + get { + if case .field252(let v)? = value {return v} + return 0 + } + set {value = .field252(newValue)} + } + + var field253: Int32 { + get { + if case .field253(let v)? = value {return v} + return 0 + } + set {value = .field253(newValue)} + } + + var field254: Int32 { + get { + if case .field254(let v)? = value {return v} + return 0 + } + set {value = .field254(newValue)} + } + + var field255: Int32 { + get { + if case .field255(let v)? = value {return v} + return 0 + } + set {value = .field255(newValue)} + } + + var field256: Int32 { + get { + if case .field256(let v)? = value {return v} + return 0 + } + set {value = .field256(newValue)} + } + + var field257: Int32 { + get { + if case .field257(let v)? = value {return v} + return 0 + } + set {value = .field257(newValue)} + } + + var field258: Int32 { + get { + if case .field258(let v)? = value {return v} + return 0 + } + set {value = .field258(newValue)} + } + + var field259: Int32 { + get { + if case .field259(let v)? = value {return v} + return 0 + } + set {value = .field259(newValue)} + } + + var field260: Int32 { + get { + if case .field260(let v)? = value {return v} + return 0 + } + set {value = .field260(newValue)} + } + + var field261: Int32 { + get { + if case .field261(let v)? = value {return v} + return 0 + } + set {value = .field261(newValue)} + } + + var field262: Int32 { + get { + if case .field262(let v)? = value {return v} + return 0 + } + set {value = .field262(newValue)} + } + + var field263: Int32 { + get { + if case .field263(let v)? = value {return v} + return 0 + } + set {value = .field263(newValue)} + } + + var field264: Int32 { + get { + if case .field264(let v)? = value {return v} + return 0 + } + set {value = .field264(newValue)} + } + + var field265: Int32 { + get { + if case .field265(let v)? = value {return v} + return 0 + } + set {value = .field265(newValue)} + } + + var field266: Int32 { + get { + if case .field266(let v)? = value {return v} + return 0 + } + set {value = .field266(newValue)} + } + + var field267: Int32 { + get { + if case .field267(let v)? = value {return v} + return 0 + } + set {value = .field267(newValue)} + } + + var field268: Int32 { + get { + if case .field268(let v)? = value {return v} + return 0 + } + set {value = .field268(newValue)} + } + + var field269: Int32 { + get { + if case .field269(let v)? = value {return v} + return 0 + } + set {value = .field269(newValue)} + } + + var field270: Int32 { + get { + if case .field270(let v)? = value {return v} + return 0 + } + set {value = .field270(newValue)} + } + + var field271: Int32 { + get { + if case .field271(let v)? = value {return v} + return 0 + } + set {value = .field271(newValue)} + } + + var field272: Int32 { + get { + if case .field272(let v)? = value {return v} + return 0 + } + set {value = .field272(newValue)} + } + + var field273: Int32 { + get { + if case .field273(let v)? = value {return v} + return 0 + } + set {value = .field273(newValue)} + } + + var field274: Int32 { + get { + if case .field274(let v)? = value {return v} + return 0 + } + set {value = .field274(newValue)} + } + + var field275: Int32 { + get { + if case .field275(let v)? = value {return v} + return 0 + } + set {value = .field275(newValue)} + } + + var field276: Int32 { + get { + if case .field276(let v)? = value {return v} + return 0 + } + set {value = .field276(newValue)} + } + + var field277: Int32 { + get { + if case .field277(let v)? = value {return v} + return 0 + } + set {value = .field277(newValue)} + } + + var field278: Int32 { + get { + if case .field278(let v)? = value {return v} + return 0 + } + set {value = .field278(newValue)} + } + + var field279: Int32 { + get { + if case .field279(let v)? = value {return v} + return 0 + } + set {value = .field279(newValue)} + } + + var field280: Int32 { + get { + if case .field280(let v)? = value {return v} + return 0 + } + set {value = .field280(newValue)} + } + + var field281: Int32 { + get { + if case .field281(let v)? = value {return v} + return 0 + } + set {value = .field281(newValue)} + } + + var field282: Int32 { + get { + if case .field282(let v)? = value {return v} + return 0 + } + set {value = .field282(newValue)} + } + + var field283: Int32 { + get { + if case .field283(let v)? = value {return v} + return 0 + } + set {value = .field283(newValue)} + } + + var field284: Int32 { + get { + if case .field284(let v)? = value {return v} + return 0 + } + set {value = .field284(newValue)} + } + + var field285: Int32 { + get { + if case .field285(let v)? = value {return v} + return 0 + } + set {value = .field285(newValue)} + } + + var field286: Int32 { + get { + if case .field286(let v)? = value {return v} + return 0 + } + set {value = .field286(newValue)} + } + + var field287: Int32 { + get { + if case .field287(let v)? = value {return v} + return 0 + } + set {value = .field287(newValue)} + } + + var field288: Int32 { + get { + if case .field288(let v)? = value {return v} + return 0 + } + set {value = .field288(newValue)} + } + + var field289: Int32 { + get { + if case .field289(let v)? = value {return v} + return 0 + } + set {value = .field289(newValue)} + } + + var field290: Int32 { + get { + if case .field290(let v)? = value {return v} + return 0 + } + set {value = .field290(newValue)} + } + + var field291: Int32 { + get { + if case .field291(let v)? = value {return v} + return 0 + } + set {value = .field291(newValue)} + } + + var field292: Int32 { + get { + if case .field292(let v)? = value {return v} + return 0 + } + set {value = .field292(newValue)} + } + + var field293: Int32 { + get { + if case .field293(let v)? = value {return v} + return 0 + } + set {value = .field293(newValue)} + } + + var field294: Int32 { + get { + if case .field294(let v)? = value {return v} + return 0 + } + set {value = .field294(newValue)} + } + + var field295: Int32 { + get { + if case .field295(let v)? = value {return v} + return 0 + } + set {value = .field295(newValue)} + } + + var field296: Int32 { + get { + if case .field296(let v)? = value {return v} + return 0 + } + set {value = .field296(newValue)} + } + + var field297: Int32 { + get { + if case .field297(let v)? = value {return v} + return 0 + } + set {value = .field297(newValue)} + } + + var field298: Int32 { + get { + if case .field298(let v)? = value {return v} + return 0 + } + set {value = .field298(newValue)} + } + + var field299: Int32 { + get { + if case .field299(let v)? = value {return v} + return 0 + } + set {value = .field299(newValue)} + } + + var field300: Int32 { + get { + if case .field300(let v)? = value {return v} + return 0 + } + set {value = .field300(newValue)} + } + + var field301: Int32 { + get { + if case .field301(let v)? = value {return v} + return 0 + } + set {value = .field301(newValue)} + } + + var field302: Int32 { + get { + if case .field302(let v)? = value {return v} + return 0 + } + set {value = .field302(newValue)} + } + + var field303: Int32 { + get { + if case .field303(let v)? = value {return v} + return 0 + } + set {value = .field303(newValue)} + } + + var field304: Int32 { + get { + if case .field304(let v)? = value {return v} + return 0 + } + set {value = .field304(newValue)} + } + + var field305: Int32 { + get { + if case .field305(let v)? = value {return v} + return 0 + } + set {value = .field305(newValue)} + } + + var field306: Int32 { + get { + if case .field306(let v)? = value {return v} + return 0 + } + set {value = .field306(newValue)} + } + + var field307: Int32 { + get { + if case .field307(let v)? = value {return v} + return 0 + } + set {value = .field307(newValue)} + } + + var field308: Int32 { + get { + if case .field308(let v)? = value {return v} + return 0 + } + set {value = .field308(newValue)} + } + + var field309: Int32 { + get { + if case .field309(let v)? = value {return v} + return 0 + } + set {value = .field309(newValue)} + } + + var field310: Int32 { + get { + if case .field310(let v)? = value {return v} + return 0 + } + set {value = .field310(newValue)} + } + + var field311: Int32 { + get { + if case .field311(let v)? = value {return v} + return 0 + } + set {value = .field311(newValue)} + } + + var field312: Int32 { + get { + if case .field312(let v)? = value {return v} + return 0 + } + set {value = .field312(newValue)} + } + + var field313: Int32 { + get { + if case .field313(let v)? = value {return v} + return 0 + } + set {value = .field313(newValue)} + } + + var field314: Int32 { + get { + if case .field314(let v)? = value {return v} + return 0 + } + set {value = .field314(newValue)} + } + + var field315: Int32 { + get { + if case .field315(let v)? = value {return v} + return 0 + } + set {value = .field315(newValue)} + } + + var field316: Int32 { + get { + if case .field316(let v)? = value {return v} + return 0 + } + set {value = .field316(newValue)} + } + + var field317: Int32 { + get { + if case .field317(let v)? = value {return v} + return 0 + } + set {value = .field317(newValue)} + } + + var field318: Int32 { + get { + if case .field318(let v)? = value {return v} + return 0 + } + set {value = .field318(newValue)} + } + + var field319: Int32 { + get { + if case .field319(let v)? = value {return v} + return 0 + } + set {value = .field319(newValue)} + } + + var field320: Int32 { + get { + if case .field320(let v)? = value {return v} + return 0 + } + set {value = .field320(newValue)} + } + + var field321: Int32 { + get { + if case .field321(let v)? = value {return v} + return 0 + } + set {value = .field321(newValue)} + } + + var field322: Int32 { + get { + if case .field322(let v)? = value {return v} + return 0 + } + set {value = .field322(newValue)} + } + + var field323: Int32 { + get { + if case .field323(let v)? = value {return v} + return 0 + } + set {value = .field323(newValue)} + } + + var field324: Int32 { + get { + if case .field324(let v)? = value {return v} + return 0 + } + set {value = .field324(newValue)} + } + + var field325: Int32 { + get { + if case .field325(let v)? = value {return v} + return 0 + } + set {value = .field325(newValue)} + } + + var field326: Int32 { + get { + if case .field326(let v)? = value {return v} + return 0 + } + set {value = .field326(newValue)} + } + + var field327: Int32 { + get { + if case .field327(let v)? = value {return v} + return 0 + } + set {value = .field327(newValue)} + } + + var field328: Int32 { + get { + if case .field328(let v)? = value {return v} + return 0 + } + set {value = .field328(newValue)} + } + + var field329: Int32 { + get { + if case .field329(let v)? = value {return v} + return 0 + } + set {value = .field329(newValue)} + } + + var field330: Int32 { + get { + if case .field330(let v)? = value {return v} + return 0 + } + set {value = .field330(newValue)} + } + + var field331: Int32 { + get { + if case .field331(let v)? = value {return v} + return 0 + } + set {value = .field331(newValue)} + } + + var field332: Int32 { + get { + if case .field332(let v)? = value {return v} + return 0 + } + set {value = .field332(newValue)} + } + + var field333: Int32 { + get { + if case .field333(let v)? = value {return v} + return 0 + } + set {value = .field333(newValue)} + } + + var field334: Int32 { + get { + if case .field334(let v)? = value {return v} + return 0 + } + set {value = .field334(newValue)} + } + + var field335: Int32 { + get { + if case .field335(let v)? = value {return v} + return 0 + } + set {value = .field335(newValue)} + } + + var field336: Int32 { + get { + if case .field336(let v)? = value {return v} + return 0 + } + set {value = .field336(newValue)} + } + + var field337: Int32 { + get { + if case .field337(let v)? = value {return v} + return 0 + } + set {value = .field337(newValue)} + } + + var field338: Int32 { + get { + if case .field338(let v)? = value {return v} + return 0 + } + set {value = .field338(newValue)} + } + + var field339: Int32 { + get { + if case .field339(let v)? = value {return v} + return 0 + } + set {value = .field339(newValue)} + } + + var field340: Int32 { + get { + if case .field340(let v)? = value {return v} + return 0 + } + set {value = .field340(newValue)} + } + + var field341: Int32 { + get { + if case .field341(let v)? = value {return v} + return 0 + } + set {value = .field341(newValue)} + } + + var field342: Int32 { + get { + if case .field342(let v)? = value {return v} + return 0 + } + set {value = .field342(newValue)} + } + + var field343: Int32 { + get { + if case .field343(let v)? = value {return v} + return 0 + } + set {value = .field343(newValue)} + } + + var field344: Int32 { + get { + if case .field344(let v)? = value {return v} + return 0 + } + set {value = .field344(newValue)} + } + + var field345: Int32 { + get { + if case .field345(let v)? = value {return v} + return 0 + } + set {value = .field345(newValue)} + } + + var field346: Int32 { + get { + if case .field346(let v)? = value {return v} + return 0 + } + set {value = .field346(newValue)} + } + + var field347: Int32 { + get { + if case .field347(let v)? = value {return v} + return 0 + } + set {value = .field347(newValue)} + } + + var field348: Int32 { + get { + if case .field348(let v)? = value {return v} + return 0 + } + set {value = .field348(newValue)} + } + + var field349: Int32 { + get { + if case .field349(let v)? = value {return v} + return 0 + } + set {value = .field349(newValue)} + } + + var field350: Int32 { + get { + if case .field350(let v)? = value {return v} + return 0 + } + set {value = .field350(newValue)} + } + + var field351: Int32 { + get { + if case .field351(let v)? = value {return v} + return 0 + } + set {value = .field351(newValue)} + } + + var field352: Int32 { + get { + if case .field352(let v)? = value {return v} + return 0 + } + set {value = .field352(newValue)} + } + + var field353: Int32 { + get { + if case .field353(let v)? = value {return v} + return 0 + } + set {value = .field353(newValue)} + } + + var field354: Int32 { + get { + if case .field354(let v)? = value {return v} + return 0 + } + set {value = .field354(newValue)} + } + + var field355: Int32 { + get { + if case .field355(let v)? = value {return v} + return 0 + } + set {value = .field355(newValue)} + } + + var field356: Int32 { + get { + if case .field356(let v)? = value {return v} + return 0 + } + set {value = .field356(newValue)} + } + + var field357: Int32 { + get { + if case .field357(let v)? = value {return v} + return 0 + } + set {value = .field357(newValue)} + } + + var field358: Int32 { + get { + if case .field358(let v)? = value {return v} + return 0 + } + set {value = .field358(newValue)} + } + + var field359: Int32 { + get { + if case .field359(let v)? = value {return v} + return 0 + } + set {value = .field359(newValue)} + } + + var field360: Int32 { + get { + if case .field360(let v)? = value {return v} + return 0 + } + set {value = .field360(newValue)} + } + + var field361: Int32 { + get { + if case .field361(let v)? = value {return v} + return 0 + } + set {value = .field361(newValue)} + } + + var field362: Int32 { + get { + if case .field362(let v)? = value {return v} + return 0 + } + set {value = .field362(newValue)} + } + + var field363: Int32 { + get { + if case .field363(let v)? = value {return v} + return 0 + } + set {value = .field363(newValue)} + } + + var field364: Int32 { + get { + if case .field364(let v)? = value {return v} + return 0 + } + set {value = .field364(newValue)} + } + + var field365: Int32 { + get { + if case .field365(let v)? = value {return v} + return 0 + } + set {value = .field365(newValue)} + } + + var field366: Int32 { + get { + if case .field366(let v)? = value {return v} + return 0 + } + set {value = .field366(newValue)} + } + + var field367: Int32 { + get { + if case .field367(let v)? = value {return v} + return 0 + } + set {value = .field367(newValue)} + } + + var field368: Int32 { + get { + if case .field368(let v)? = value {return v} + return 0 + } + set {value = .field368(newValue)} + } + + var field369: Int32 { + get { + if case .field369(let v)? = value {return v} + return 0 + } + set {value = .field369(newValue)} + } + + var field370: Int32 { + get { + if case .field370(let v)? = value {return v} + return 0 + } + set {value = .field370(newValue)} + } + + var field371: Int32 { + get { + if case .field371(let v)? = value {return v} + return 0 + } + set {value = .field371(newValue)} + } + + var field372: Int32 { + get { + if case .field372(let v)? = value {return v} + return 0 + } + set {value = .field372(newValue)} + } + + var field373: Int32 { + get { + if case .field373(let v)? = value {return v} + return 0 + } + set {value = .field373(newValue)} + } + + var field374: Int32 { + get { + if case .field374(let v)? = value {return v} + return 0 + } + set {value = .field374(newValue)} + } + + var field375: Int32 { + get { + if case .field375(let v)? = value {return v} + return 0 + } + set {value = .field375(newValue)} + } + + var field376: Int32 { + get { + if case .field376(let v)? = value {return v} + return 0 + } + set {value = .field376(newValue)} + } + + var field377: Int32 { + get { + if case .field377(let v)? = value {return v} + return 0 + } + set {value = .field377(newValue)} + } + + var field378: Int32 { + get { + if case .field378(let v)? = value {return v} + return 0 + } + set {value = .field378(newValue)} + } + + var field379: Int32 { + get { + if case .field379(let v)? = value {return v} + return 0 + } + set {value = .field379(newValue)} + } + + var field380: Int32 { + get { + if case .field380(let v)? = value {return v} + return 0 + } + set {value = .field380(newValue)} + } + + var field381: Int32 { + get { + if case .field381(let v)? = value {return v} + return 0 + } + set {value = .field381(newValue)} + } + + var field382: Int32 { + get { + if case .field382(let v)? = value {return v} + return 0 + } + set {value = .field382(newValue)} + } + + var field383: Int32 { + get { + if case .field383(let v)? = value {return v} + return 0 + } + set {value = .field383(newValue)} + } + + var field384: Int32 { + get { + if case .field384(let v)? = value {return v} + return 0 + } + set {value = .field384(newValue)} + } + + var field385: Int32 { + get { + if case .field385(let v)? = value {return v} + return 0 + } + set {value = .field385(newValue)} + } + + var field386: Int32 { + get { + if case .field386(let v)? = value {return v} + return 0 + } + set {value = .field386(newValue)} + } + + var field387: Int32 { + get { + if case .field387(let v)? = value {return v} + return 0 + } + set {value = .field387(newValue)} + } + + var field388: Int32 { + get { + if case .field388(let v)? = value {return v} + return 0 + } + set {value = .field388(newValue)} + } + + var field389: Int32 { + get { + if case .field389(let v)? = value {return v} + return 0 + } + set {value = .field389(newValue)} + } + + var field390: Int32 { + get { + if case .field390(let v)? = value {return v} + return 0 + } + set {value = .field390(newValue)} + } + + var field391: Int32 { + get { + if case .field391(let v)? = value {return v} + return 0 + } + set {value = .field391(newValue)} + } + + var field392: Int32 { + get { + if case .field392(let v)? = value {return v} + return 0 + } + set {value = .field392(newValue)} + } + + var field393: Int32 { + get { + if case .field393(let v)? = value {return v} + return 0 + } + set {value = .field393(newValue)} + } + + var field394: Int32 { + get { + if case .field394(let v)? = value {return v} + return 0 + } + set {value = .field394(newValue)} + } + + var field395: Int32 { + get { + if case .field395(let v)? = value {return v} + return 0 + } + set {value = .field395(newValue)} + } + + var field396: Int32 { + get { + if case .field396(let v)? = value {return v} + return 0 + } + set {value = .field396(newValue)} + } + + var field397: Int32 { + get { + if case .field397(let v)? = value {return v} + return 0 + } + set {value = .field397(newValue)} + } + + var field398: Int32 { + get { + if case .field398(let v)? = value {return v} + return 0 + } + set {value = .field398(newValue)} + } + + var field399: Int32 { + get { + if case .field399(let v)? = value {return v} + return 0 + } + set {value = .field399(newValue)} + } + + var field400: Int32 { + get { + if case .field400(let v)? = value {return v} + return 0 + } + set {value = .field400(newValue)} + } + + var field401: Int32 { + get { + if case .field401(let v)? = value {return v} + return 0 + } + set {value = .field401(newValue)} + } + + var field402: Int32 { + get { + if case .field402(let v)? = value {return v} + return 0 + } + set {value = .field402(newValue)} + } + + var field403: Int32 { + get { + if case .field403(let v)? = value {return v} + return 0 + } + set {value = .field403(newValue)} + } + + var field404: Int32 { + get { + if case .field404(let v)? = value {return v} + return 0 + } + set {value = .field404(newValue)} + } + + var field405: Int32 { + get { + if case .field405(let v)? = value {return v} + return 0 + } + set {value = .field405(newValue)} + } + + var field406: Int32 { + get { + if case .field406(let v)? = value {return v} + return 0 + } + set {value = .field406(newValue)} + } + + var field407: Int32 { + get { + if case .field407(let v)? = value {return v} + return 0 + } + set {value = .field407(newValue)} + } + + var field408: Int32 { + get { + if case .field408(let v)? = value {return v} + return 0 + } + set {value = .field408(newValue)} + } + + var field409: Int32 { + get { + if case .field409(let v)? = value {return v} + return 0 + } + set {value = .field409(newValue)} + } + + var field410: Int32 { + get { + if case .field410(let v)? = value {return v} + return 0 + } + set {value = .field410(newValue)} + } + + var field411: Int32 { + get { + if case .field411(let v)? = value {return v} + return 0 + } + set {value = .field411(newValue)} + } + + var field412: Int32 { + get { + if case .field412(let v)? = value {return v} + return 0 + } + set {value = .field412(newValue)} + } + + var field413: Int32 { + get { + if case .field413(let v)? = value {return v} + return 0 + } + set {value = .field413(newValue)} + } + + var field414: Int32 { + get { + if case .field414(let v)? = value {return v} + return 0 + } + set {value = .field414(newValue)} + } + + var field415: Int32 { + get { + if case .field415(let v)? = value {return v} + return 0 + } + set {value = .field415(newValue)} + } + + var field416: Int32 { + get { + if case .field416(let v)? = value {return v} + return 0 + } + set {value = .field416(newValue)} + } + + var field417: Int32 { + get { + if case .field417(let v)? = value {return v} + return 0 + } + set {value = .field417(newValue)} + } + + var field418: Int32 { + get { + if case .field418(let v)? = value {return v} + return 0 + } + set {value = .field418(newValue)} + } + + var field419: Int32 { + get { + if case .field419(let v)? = value {return v} + return 0 + } + set {value = .field419(newValue)} + } + + var field420: Int32 { + get { + if case .field420(let v)? = value {return v} + return 0 + } + set {value = .field420(newValue)} + } + + var field421: Int32 { + get { + if case .field421(let v)? = value {return v} + return 0 + } + set {value = .field421(newValue)} + } + + var field422: Int32 { + get { + if case .field422(let v)? = value {return v} + return 0 + } + set {value = .field422(newValue)} + } + + var field423: Int32 { + get { + if case .field423(let v)? = value {return v} + return 0 + } + set {value = .field423(newValue)} + } + + var field424: Int32 { + get { + if case .field424(let v)? = value {return v} + return 0 + } + set {value = .field424(newValue)} + } + + var field425: Int32 { + get { + if case .field425(let v)? = value {return v} + return 0 + } + set {value = .field425(newValue)} + } + + var field426: Int32 { + get { + if case .field426(let v)? = value {return v} + return 0 + } + set {value = .field426(newValue)} + } + + var field427: Int32 { + get { + if case .field427(let v)? = value {return v} + return 0 + } + set {value = .field427(newValue)} + } + + var field428: Int32 { + get { + if case .field428(let v)? = value {return v} + return 0 + } + set {value = .field428(newValue)} + } + + var field429: Int32 { + get { + if case .field429(let v)? = value {return v} + return 0 + } + set {value = .field429(newValue)} + } + + var field430: Int32 { + get { + if case .field430(let v)? = value {return v} + return 0 + } + set {value = .field430(newValue)} + } + + var field431: Int32 { + get { + if case .field431(let v)? = value {return v} + return 0 + } + set {value = .field431(newValue)} + } + + var field432: Int32 { + get { + if case .field432(let v)? = value {return v} + return 0 + } + set {value = .field432(newValue)} + } + + var field433: Int32 { + get { + if case .field433(let v)? = value {return v} + return 0 + } + set {value = .field433(newValue)} + } + + var field434: Int32 { + get { + if case .field434(let v)? = value {return v} + return 0 + } + set {value = .field434(newValue)} + } + + var field435: Int32 { + get { + if case .field435(let v)? = value {return v} + return 0 + } + set {value = .field435(newValue)} + } + + var field436: Int32 { + get { + if case .field436(let v)? = value {return v} + return 0 + } + set {value = .field436(newValue)} + } + + var field437: Int32 { + get { + if case .field437(let v)? = value {return v} + return 0 + } + set {value = .field437(newValue)} + } + + var field438: Int32 { + get { + if case .field438(let v)? = value {return v} + return 0 + } + set {value = .field438(newValue)} + } + + var field439: Int32 { + get { + if case .field439(let v)? = value {return v} + return 0 + } + set {value = .field439(newValue)} + } + + var field440: Int32 { + get { + if case .field440(let v)? = value {return v} + return 0 + } + set {value = .field440(newValue)} + } + + var field441: Int32 { + get { + if case .field441(let v)? = value {return v} + return 0 + } + set {value = .field441(newValue)} + } + + var field442: Int32 { + get { + if case .field442(let v)? = value {return v} + return 0 + } + set {value = .field442(newValue)} + } + + var field443: Int32 { + get { + if case .field443(let v)? = value {return v} + return 0 + } + set {value = .field443(newValue)} + } + + var field444: Int32 { + get { + if case .field444(let v)? = value {return v} + return 0 + } + set {value = .field444(newValue)} + } + + var field445: Int32 { + get { + if case .field445(let v)? = value {return v} + return 0 + } + set {value = .field445(newValue)} + } + + var field446: Int32 { + get { + if case .field446(let v)? = value {return v} + return 0 + } + set {value = .field446(newValue)} + } + + var field447: Int32 { + get { + if case .field447(let v)? = value {return v} + return 0 + } + set {value = .field447(newValue)} + } + + var field448: Int32 { + get { + if case .field448(let v)? = value {return v} + return 0 + } + set {value = .field448(newValue)} + } + + var field449: Int32 { + get { + if case .field449(let v)? = value {return v} + return 0 + } + set {value = .field449(newValue)} + } + + var field450: Int32 { + get { + if case .field450(let v)? = value {return v} + return 0 + } + set {value = .field450(newValue)} + } + + var field451: Int32 { + get { + if case .field451(let v)? = value {return v} + return 0 + } + set {value = .field451(newValue)} + } + + var field452: Int32 { + get { + if case .field452(let v)? = value {return v} + return 0 + } + set {value = .field452(newValue)} + } + + var field453: Int32 { + get { + if case .field453(let v)? = value {return v} + return 0 + } + set {value = .field453(newValue)} + } + + var field454: Int32 { + get { + if case .field454(let v)? = value {return v} + return 0 + } + set {value = .field454(newValue)} + } + + var field455: Int32 { + get { + if case .field455(let v)? = value {return v} + return 0 + } + set {value = .field455(newValue)} + } + + var field456: Int32 { + get { + if case .field456(let v)? = value {return v} + return 0 + } + set {value = .field456(newValue)} + } + + var field457: Int32 { + get { + if case .field457(let v)? = value {return v} + return 0 + } + set {value = .field457(newValue)} + } + + var field458: Int32 { + get { + if case .field458(let v)? = value {return v} + return 0 + } + set {value = .field458(newValue)} + } + + var field459: Int32 { + get { + if case .field459(let v)? = value {return v} + return 0 + } + set {value = .field459(newValue)} + } + + var field460: Int32 { + get { + if case .field460(let v)? = value {return v} + return 0 + } + set {value = .field460(newValue)} + } + + var field461: Int32 { + get { + if case .field461(let v)? = value {return v} + return 0 + } + set {value = .field461(newValue)} + } + + var field462: Int32 { + get { + if case .field462(let v)? = value {return v} + return 0 + } + set {value = .field462(newValue)} + } + + var field463: Int32 { + get { + if case .field463(let v)? = value {return v} + return 0 + } + set {value = .field463(newValue)} + } + + var field464: Int32 { + get { + if case .field464(let v)? = value {return v} + return 0 + } + set {value = .field464(newValue)} + } + + var field465: Int32 { + get { + if case .field465(let v)? = value {return v} + return 0 + } + set {value = .field465(newValue)} + } + + var field466: Int32 { + get { + if case .field466(let v)? = value {return v} + return 0 + } + set {value = .field466(newValue)} + } + + var field467: Int32 { + get { + if case .field467(let v)? = value {return v} + return 0 + } + set {value = .field467(newValue)} + } + + var field468: Int32 { + get { + if case .field468(let v)? = value {return v} + return 0 + } + set {value = .field468(newValue)} + } + + var field469: Int32 { + get { + if case .field469(let v)? = value {return v} + return 0 + } + set {value = .field469(newValue)} + } + + var field470: Int32 { + get { + if case .field470(let v)? = value {return v} + return 0 + } + set {value = .field470(newValue)} + } + + var field471: Int32 { + get { + if case .field471(let v)? = value {return v} + return 0 + } + set {value = .field471(newValue)} + } + + var field472: Int32 { + get { + if case .field472(let v)? = value {return v} + return 0 + } + set {value = .field472(newValue)} + } + + var field473: Int32 { + get { + if case .field473(let v)? = value {return v} + return 0 + } + set {value = .field473(newValue)} + } + + var field474: Int32 { + get { + if case .field474(let v)? = value {return v} + return 0 + } + set {value = .field474(newValue)} + } + + var field475: Int32 { + get { + if case .field475(let v)? = value {return v} + return 0 + } + set {value = .field475(newValue)} + } + + var field476: Int32 { + get { + if case .field476(let v)? = value {return v} + return 0 + } + set {value = .field476(newValue)} + } + + var field477: Int32 { + get { + if case .field477(let v)? = value {return v} + return 0 + } + set {value = .field477(newValue)} + } + + var field478: Int32 { + get { + if case .field478(let v)? = value {return v} + return 0 + } + set {value = .field478(newValue)} + } + + var field479: Int32 { + get { + if case .field479(let v)? = value {return v} + return 0 + } + set {value = .field479(newValue)} + } + + var field480: Int32 { + get { + if case .field480(let v)? = value {return v} + return 0 + } + set {value = .field480(newValue)} + } + + var field481: Int32 { + get { + if case .field481(let v)? = value {return v} + return 0 + } + set {value = .field481(newValue)} + } + + var field482: Int32 { + get { + if case .field482(let v)? = value {return v} + return 0 + } + set {value = .field482(newValue)} + } + + var field483: Int32 { + get { + if case .field483(let v)? = value {return v} + return 0 + } + set {value = .field483(newValue)} + } + + var field484: Int32 { + get { + if case .field484(let v)? = value {return v} + return 0 + } + set {value = .field484(newValue)} + } + + var field485: Int32 { + get { + if case .field485(let v)? = value {return v} + return 0 + } + set {value = .field485(newValue)} + } + + var field486: Int32 { + get { + if case .field486(let v)? = value {return v} + return 0 + } + set {value = .field486(newValue)} + } + + var field487: Int32 { + get { + if case .field487(let v)? = value {return v} + return 0 + } + set {value = .field487(newValue)} + } + + var field488: Int32 { + get { + if case .field488(let v)? = value {return v} + return 0 + } + set {value = .field488(newValue)} + } + + var field489: Int32 { + get { + if case .field489(let v)? = value {return v} + return 0 + } + set {value = .field489(newValue)} + } + + var field490: Int32 { + get { + if case .field490(let v)? = value {return v} + return 0 + } + set {value = .field490(newValue)} + } + + var field491: Int32 { + get { + if case .field491(let v)? = value {return v} + return 0 + } + set {value = .field491(newValue)} + } + + var field492: Int32 { + get { + if case .field492(let v)? = value {return v} + return 0 + } + set {value = .field492(newValue)} + } + + var field493: Int32 { + get { + if case .field493(let v)? = value {return v} + return 0 + } + set {value = .field493(newValue)} + } + + var field494: Int32 { + get { + if case .field494(let v)? = value {return v} + return 0 + } + set {value = .field494(newValue)} + } + + var field495: Int32 { + get { + if case .field495(let v)? = value {return v} + return 0 + } + set {value = .field495(newValue)} + } + + var field496: Int32 { + get { + if case .field496(let v)? = value {return v} + return 0 + } + set {value = .field496(newValue)} + } + + var field497: Int32 { + get { + if case .field497(let v)? = value {return v} + return 0 + } + set {value = .field497(newValue)} + } + + var field498: Int32 { + get { + if case .field498(let v)? = value {return v} + return 0 + } + set {value = .field498(newValue)} + } + + var field499: Int32 { + get { + if case .field499(let v)? = value {return v} + return 0 + } + set {value = .field499(newValue)} + } + + var field500: Int32 { + get { + if case .field500(let v)? = value {return v} + return 0 + } + set {value = .field500(newValue)} + } + + var field501: Int32 { + get { + if case .field501(let v)? = value {return v} + return 0 + } + set {value = .field501(newValue)} + } + + var field503: Int32 { + get { + if case .field503(let v)? = value {return v} + return 0 + } + set {value = .field503(newValue)} + } + + var field504: Int32 { + get { + if case .field504(let v)? = value {return v} + return 0 + } + set {value = .field504(newValue)} + } + + var field505: Int32 { + get { + if case .field505(let v)? = value {return v} + return 0 + } + set {value = .field505(newValue)} + } + + var field506: Int32 { + get { + if case .field506(let v)? = value {return v} + return 0 + } + set {value = .field506(newValue)} + } + + var field507: Int32 { + get { + if case .field507(let v)? = value {return v} + return 0 + } + set {value = .field507(newValue)} + } + + var field508: Int32 { + get { + if case .field508(let v)? = value {return v} + return 0 + } + set {value = .field508(newValue)} + } + + var field510: Int32 { + get { + if case .field510(let v)? = value {return v} + return 0 + } + set {value = .field510(newValue)} + } + + var unknownFields = SwiftProtobuf.UnknownStorage() + + enum OneOf_Value: Equatable, Sendable { + case field001(Int32) + case field003(Int32) + case field004(Int32) + case field005(Int32) + case field006(Int32) + case field007(Int32) + case field008(Int32) + case field009(Int32) + case field010(Int32) + case field011(Int32) + case field012(Int32) + case field013(Int32) + case field014(Int32) + case field015(Int32) + case field016(Int32) + case field017(Int32) + case field018(Int32) + case field019(Int32) + case field020(Int32) + case field021(Int32) + case field022(Int32) + case field023(Int32) + case field024(Int32) + case field025(Int32) + case field026(Int32) + case field027(Int32) + case field028(Int32) + case field029(Int32) + case field030(Int32) + case field031(Int32) + case field032(Int32) + case field033(Int32) + case field034(Int32) + case field035(Int32) + case field036(Int32) + case field037(Int32) + case field038(Int32) + case field039(Int32) + case field040(Int32) + case field041(Int32) + case field042(Int32) + case field043(Int32) + case field044(Int32) + case field045(Int32) + case field046(Int32) + case field047(Int32) + case field048(Int32) + case field049(Int32) + case field050(Int32) + case field051(Int32) + case field052(Int32) + case field053(Int32) + case field054(Int32) + case field055(Int32) + case field056(Int32) + case field057(Int32) + case field058(Int32) + case field059(Int32) + case field060(Int32) + case field061(Int32) + case field062(Int32) + case field063(Int32) + case field064(Int32) + case field065(Int32) + case field066(Int32) + case field067(Int32) + case field068(Int32) + case field069(Int32) + case field070(Int32) + case field071(Int32) + case field072(Int32) + case field073(Int32) + case field074(Int32) + case field075(Int32) + case field076(Int32) + case field077(Int32) + case field078(Int32) + case field079(Int32) + case field080(Int32) + case field081(Int32) + case field082(Int32) + case field083(Int32) + case field084(Int32) + case field085(Int32) + case field086(Int32) + case field087(Int32) + case field088(Int32) + case field089(Int32) + case field090(Int32) + case field091(Int32) + case field092(Int32) + case field093(Int32) + case field094(Int32) + case field095(Int32) + case field096(Int32) + case field097(Int32) + case field098(Int32) + case field099(Int32) + case field100(Int32) + case field101(Int32) + case field102(Int32) + case field103(Int32) + case field104(Int32) + case field105(Int32) + case field106(Int32) + case field107(Int32) + case field108(Int32) + case field109(Int32) + case field110(Int32) + case field111(Int32) + case field112(Int32) + case field113(Int32) + case field114(Int32) + case field115(Int32) + case field116(Int32) + case field117(Int32) + case field118(Int32) + case field119(Int32) + case field120(Int32) + case field121(Int32) + case field122(Int32) + case field123(Int32) + case field124(Int32) + case field125(Int32) + case field126(Int32) + case field127(Int32) + case field128(Int32) + case field129(Int32) + case field130(Int32) + case field131(Int32) + case field132(Int32) + case field133(Int32) + case field134(Int32) + case field135(Int32) + case field136(Int32) + case field137(Int32) + case field138(Int32) + case field139(Int32) + case field140(Int32) + case field141(Int32) + case field142(Int32) + case field143(Int32) + case field144(Int32) + case field145(Int32) + case field146(Int32) + case field147(Int32) + case field148(Int32) + case field149(Int32) + case field150(Int32) + case field151(Int32) + case field152(Int32) + case field153(Int32) + case field154(Int32) + case field155(Int32) + case field156(Int32) + case field157(Int32) + case field158(Int32) + case field159(Int32) + case field160(Int32) + case field161(Int32) + case field162(Int32) + case field163(Int32) + case field164(Int32) + case field165(Int32) + case field166(Int32) + case field167(Int32) + case field168(Int32) + case field169(Int32) + case field170(Int32) + case field171(Int32) + case field172(Int32) + case field173(Int32) + case field174(Int32) + case field175(Int32) + case field176(Int32) + case field177(Int32) + case field178(Int32) + case field179(Int32) + case field180(Int32) + case field181(Int32) + case field182(Int32) + case field183(Int32) + case field184(Int32) + case field185(Int32) + case field186(Int32) + case field187(Int32) + case field188(Int32) + case field189(Int32) + case field190(Int32) + case field191(Int32) + case field192(Int32) + case field193(Int32) + case field194(Int32) + case field195(Int32) + case field196(Int32) + case field197(Int32) + case field198(Int32) + case field199(Int32) + case field200(Int32) + case field201(Int32) + case field202(Int32) + case field203(Int32) + case field204(Int32) + case field205(Int32) + case field206(Int32) + case field207(Int32) + case field208(Int32) + case field209(Int32) + case field210(Int32) + case field211(Int32) + case field212(Int32) + case field213(Int32) + case field214(Int32) + case field215(Int32) + case field216(Int32) + case field217(Int32) + case field218(Int32) + case field219(Int32) + case field220(Int32) + case field221(Int32) + case field222(Int32) + case field223(Int32) + case field224(Int32) + case field225(Int32) + case field226(Int32) + case field227(Int32) + case field228(Int32) + case field229(Int32) + case field230(Int32) + case field231(Int32) + case field232(Int32) + case field233(Int32) + case field234(Int32) + case field235(Int32) + case field236(Int32) + case field237(Int32) + case field238(Int32) + case field239(Int32) + case field240(Int32) + case field241(Int32) + case field242(Int32) + case field243(Int32) + case field244(Int32) + case field245(Int32) + case field246(Int32) + case field247(Int32) + case field248(Int32) + case field249(Int32) + case field250(Int32) + case field252(Int32) + case field253(Int32) + case field254(Int32) + case field255(Int32) + case field256(Int32) + case field257(Int32) + case field258(Int32) + case field259(Int32) + case field260(Int32) + case field261(Int32) + case field262(Int32) + case field263(Int32) + case field264(Int32) + case field265(Int32) + case field266(Int32) + case field267(Int32) + case field268(Int32) + case field269(Int32) + case field270(Int32) + case field271(Int32) + case field272(Int32) + case field273(Int32) + case field274(Int32) + case field275(Int32) + case field276(Int32) + case field277(Int32) + case field278(Int32) + case field279(Int32) + case field280(Int32) + case field281(Int32) + case field282(Int32) + case field283(Int32) + case field284(Int32) + case field285(Int32) + case field286(Int32) + case field287(Int32) + case field288(Int32) + case field289(Int32) + case field290(Int32) + case field291(Int32) + case field292(Int32) + case field293(Int32) + case field294(Int32) + case field295(Int32) + case field296(Int32) + case field297(Int32) + case field298(Int32) + case field299(Int32) + case field300(Int32) + case field301(Int32) + case field302(Int32) + case field303(Int32) + case field304(Int32) + case field305(Int32) + case field306(Int32) + case field307(Int32) + case field308(Int32) + case field309(Int32) + case field310(Int32) + case field311(Int32) + case field312(Int32) + case field313(Int32) + case field314(Int32) + case field315(Int32) + case field316(Int32) + case field317(Int32) + case field318(Int32) + case field319(Int32) + case field320(Int32) + case field321(Int32) + case field322(Int32) + case field323(Int32) + case field324(Int32) + case field325(Int32) + case field326(Int32) + case field327(Int32) + case field328(Int32) + case field329(Int32) + case field330(Int32) + case field331(Int32) + case field332(Int32) + case field333(Int32) + case field334(Int32) + case field335(Int32) + case field336(Int32) + case field337(Int32) + case field338(Int32) + case field339(Int32) + case field340(Int32) + case field341(Int32) + case field342(Int32) + case field343(Int32) + case field344(Int32) + case field345(Int32) + case field346(Int32) + case field347(Int32) + case field348(Int32) + case field349(Int32) + case field350(Int32) + case field351(Int32) + case field352(Int32) + case field353(Int32) + case field354(Int32) + case field355(Int32) + case field356(Int32) + case field357(Int32) + case field358(Int32) + case field359(Int32) + case field360(Int32) + case field361(Int32) + case field362(Int32) + case field363(Int32) + case field364(Int32) + case field365(Int32) + case field366(Int32) + case field367(Int32) + case field368(Int32) + case field369(Int32) + case field370(Int32) + case field371(Int32) + case field372(Int32) + case field373(Int32) + case field374(Int32) + case field375(Int32) + case field376(Int32) + case field377(Int32) + case field378(Int32) + case field379(Int32) + case field380(Int32) + case field381(Int32) + case field382(Int32) + case field383(Int32) + case field384(Int32) + case field385(Int32) + case field386(Int32) + case field387(Int32) + case field388(Int32) + case field389(Int32) + case field390(Int32) + case field391(Int32) + case field392(Int32) + case field393(Int32) + case field394(Int32) + case field395(Int32) + case field396(Int32) + case field397(Int32) + case field398(Int32) + case field399(Int32) + case field400(Int32) + case field401(Int32) + case field402(Int32) + case field403(Int32) + case field404(Int32) + case field405(Int32) + case field406(Int32) + case field407(Int32) + case field408(Int32) + case field409(Int32) + case field410(Int32) + case field411(Int32) + case field412(Int32) + case field413(Int32) + case field414(Int32) + case field415(Int32) + case field416(Int32) + case field417(Int32) + case field418(Int32) + case field419(Int32) + case field420(Int32) + case field421(Int32) + case field422(Int32) + case field423(Int32) + case field424(Int32) + case field425(Int32) + case field426(Int32) + case field427(Int32) + case field428(Int32) + case field429(Int32) + case field430(Int32) + case field431(Int32) + case field432(Int32) + case field433(Int32) + case field434(Int32) + case field435(Int32) + case field436(Int32) + case field437(Int32) + case field438(Int32) + case field439(Int32) + case field440(Int32) + case field441(Int32) + case field442(Int32) + case field443(Int32) + case field444(Int32) + case field445(Int32) + case field446(Int32) + case field447(Int32) + case field448(Int32) + case field449(Int32) + case field450(Int32) + case field451(Int32) + case field452(Int32) + case field453(Int32) + case field454(Int32) + case field455(Int32) + case field456(Int32) + case field457(Int32) + case field458(Int32) + case field459(Int32) + case field460(Int32) + case field461(Int32) + case field462(Int32) + case field463(Int32) + case field464(Int32) + case field465(Int32) + case field466(Int32) + case field467(Int32) + case field468(Int32) + case field469(Int32) + case field470(Int32) + case field471(Int32) + case field472(Int32) + case field473(Int32) + case field474(Int32) + case field475(Int32) + case field476(Int32) + case field477(Int32) + case field478(Int32) + case field479(Int32) + case field480(Int32) + case field481(Int32) + case field482(Int32) + case field483(Int32) + case field484(Int32) + case field485(Int32) + case field486(Int32) + case field487(Int32) + case field488(Int32) + case field489(Int32) + case field490(Int32) + case field491(Int32) + case field492(Int32) + case field493(Int32) + case field494(Int32) + case field495(Int32) + case field496(Int32) + case field497(Int32) + case field498(Int32) + case field499(Int32) + case field500(Int32) + case field501(Int32) + case field503(Int32) + case field504(Int32) + case field505(Int32) + case field506(Int32) + case field507(Int32) + case field508(Int32) + case field510(Int32) + + } + + init() {} + + fileprivate var _regularField002: Int32? = nil + fileprivate var _regularField251: Int32? = nil + fileprivate var _regularField502: Int32? = nil + fileprivate var _regularField509: Int32? = nil +} + +// MARK: - Code below here is support for the SwiftProtobuf runtime. + +fileprivate let _protobuf_package = "swift_proto_testing.switch_split" + +extension SwiftProtoTesting_SwitchSplit_SwitchSplitMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = _protobuf_package + ".SwitchSplitMessage" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}field_001\0\u{3}regular_field_002\0\u{3}field_003\0\u{3}field_004\0\u{3}field_005\0\u{3}field_006\0\u{3}field_007\0\u{3}field_008\0\u{3}field_009\0\u{3}field_050\0\u{3}field_011\0\u{3}field_012\0\u{3}field_013\0\u{3}field_014\0\u{3}field_015\0\u{3}field_016\0\u{3}field_017\0\u{3}field_018\0\u{3}field_019\0\u{3}field_020\0\u{3}field_021\0\u{3}field_022\0\u{3}field_023\0\u{3}field_024\0\u{3}field_025\0\u{3}field_026\0\u{3}field_027\0\u{3}field_028\0\u{3}field_029\0\u{3}field_030\0\u{3}field_031\0\u{3}field_032\0\u{3}field_033\0\u{3}field_034\0\u{3}field_035\0\u{3}field_036\0\u{3}field_037\0\u{3}field_038\0\u{3}field_039\0\u{3}field_040\0\u{3}field_041\0\u{3}field_042\0\u{3}field_043\0\u{3}field_044\0\u{3}field_045\0\u{3}field_046\0\u{3}field_047\0\u{3}field_048\0\u{3}field_049\0\u{3}field_010\0\u{3}field_051\0\u{3}field_052\0\u{3}field_053\0\u{3}field_054\0\u{3}field_055\0\u{3}field_056\0\u{3}field_057\0\u{3}field_058\0\u{3}field_059\0\u{3}field_060\0\u{3}field_061\0\u{3}field_062\0\u{3}field_063\0\u{3}field_064\0\u{3}field_065\0\u{3}field_066\0\u{3}field_067\0\u{3}field_068\0\u{3}field_069\0\u{3}field_070\0\u{3}field_071\0\u{3}field_072\0\u{3}field_073\0\u{3}field_074\0\u{3}field_075\0\u{3}field_076\0\u{3}field_077\0\u{3}field_078\0\u{3}field_079\0\u{3}field_080\0\u{3}field_081\0\u{3}field_082\0\u{3}field_083\0\u{3}field_084\0\u{3}field_085\0\u{3}field_086\0\u{3}field_087\0\u{3}field_088\0\u{3}field_089\0\u{3}field_090\0\u{3}field_091\0\u{3}field_092\0\u{3}field_093\0\u{3}field_094\0\u{3}field_095\0\u{3}field_096\0\u{3}field_097\0\u{3}field_098\0\u{3}field_099\0\u{3}field_200\0\u{3}field_101\0\u{3}field_102\0\u{3}field_103\0\u{3}field_104\0\u{3}field_105\0\u{3}field_106\0\u{3}field_107\0\u{3}field_108\0\u{3}field_109\0\u{3}field_110\0\u{3}field_111\0\u{3}field_112\0\u{3}field_113\0\u{3}field_114\0\u{3}field_115\0\u{3}field_116\0\u{3}field_117\0\u{3}field_118\0\u{3}field_119\0\u{3}field_120\0\u{3}field_121\0\u{3}field_122\0\u{3}field_123\0\u{3}field_124\0\u{3}field_125\0\u{3}field_126\0\u{3}field_127\0\u{3}field_128\0\u{3}field_129\0\u{3}field_130\0\u{3}field_131\0\u{3}field_132\0\u{3}field_133\0\u{3}field_134\0\u{3}field_135\0\u{3}field_136\0\u{3}field_137\0\u{3}field_138\0\u{3}field_139\0\u{3}field_140\0\u{3}field_141\0\u{3}field_142\0\u{3}field_143\0\u{3}field_144\0\u{3}field_145\0\u{3}field_146\0\u{3}field_147\0\u{3}field_148\0\u{3}field_149\0\u{3}field_150\0\u{3}field_151\0\u{3}field_152\0\u{3}field_153\0\u{3}field_154\0\u{3}field_155\0\u{3}field_156\0\u{3}field_157\0\u{3}field_158\0\u{3}field_159\0\u{3}field_160\0\u{3}field_161\0\u{3}field_162\0\u{3}field_163\0\u{3}field_164\0\u{3}field_165\0\u{3}field_166\0\u{3}field_167\0\u{3}field_168\0\u{3}field_169\0\u{3}field_170\0\u{3}field_171\0\u{3}field_172\0\u{3}field_173\0\u{3}field_174\0\u{3}field_175\0\u{3}field_176\0\u{3}field_177\0\u{3}field_178\0\u{3}field_179\0\u{3}field_180\0\u{3}field_181\0\u{3}field_182\0\u{3}field_183\0\u{3}field_184\0\u{3}field_185\0\u{3}field_186\0\u{3}field_187\0\u{3}field_188\0\u{3}field_189\0\u{3}field_190\0\u{3}field_191\0\u{3}field_192\0\u{3}field_193\0\u{3}field_194\0\u{3}field_195\0\u{3}field_196\0\u{3}field_197\0\u{3}field_198\0\u{3}field_199\0\u{3}field_100\0\u{3}field_201\0\u{3}field_202\0\u{3}field_203\0\u{3}field_204\0\u{3}field_205\0\u{3}field_206\0\u{3}field_207\0\u{3}field_208\0\u{3}field_209\0\u{3}field_210\0\u{3}field_211\0\u{3}field_212\0\u{3}field_213\0\u{3}field_214\0\u{3}field_215\0\u{3}field_216\0\u{3}field_217\0\u{3}field_218\0\u{3}field_219\0\u{3}field_220\0\u{3}field_221\0\u{3}field_222\0\u{3}field_223\0\u{3}field_224\0\u{3}field_225\0\u{3}field_226\0\u{3}field_227\0\u{3}field_228\0\u{3}field_229\0\u{3}field_230\0\u{3}field_231\0\u{3}field_232\0\u{3}field_233\0\u{3}field_234\0\u{3}field_235\0\u{3}field_236\0\u{3}field_237\0\u{3}field_238\0\u{3}field_239\0\u{3}field_240\0\u{3}field_241\0\u{3}field_242\0\u{3}field_243\0\u{3}field_244\0\u{3}field_245\0\u{3}field_246\0\u{3}field_247\0\u{3}field_248\0\u{3}field_249\0\u{3}field_250\0\u{3}regular_field_251\0\u{3}field_252\0\u{3}field_253\0\u{3}field_254\0\u{3}field_255\0\u{3}field_256\0\u{3}field_257\0\u{3}field_258\0\u{3}field_259\0\u{3}field_260\0\u{3}field_261\0\u{3}field_262\0\u{3}field_263\0\u{3}field_264\0\u{3}field_265\0\u{3}field_266\0\u{3}field_267\0\u{3}field_268\0\u{3}field_269\0\u{3}field_270\0\u{3}field_271\0\u{3}field_272\0\u{3}field_273\0\u{3}field_274\0\u{3}field_275\0\u{3}field_276\0\u{3}field_277\0\u{3}field_278\0\u{3}field_279\0\u{3}field_280\0\u{3}field_281\0\u{3}field_282\0\u{3}field_283\0\u{3}field_284\0\u{3}field_285\0\u{3}field_286\0\u{3}field_287\0\u{3}field_288\0\u{3}field_289\0\u{3}field_290\0\u{3}field_291\0\u{3}field_292\0\u{3}field_293\0\u{3}field_294\0\u{3}field_295\0\u{3}field_296\0\u{3}field_297\0\u{3}field_298\0\u{3}field_299\0\u{3}field_400\0\u{3}field_301\0\u{3}field_302\0\u{3}field_303\0\u{3}field_304\0\u{3}field_305\0\u{3}field_306\0\u{3}field_307\0\u{3}field_308\0\u{3}field_309\0\u{3}field_310\0\u{3}field_311\0\u{3}field_312\0\u{3}field_313\0\u{3}field_314\0\u{3}field_315\0\u{3}field_316\0\u{3}field_317\0\u{3}field_318\0\u{3}field_319\0\u{3}field_320\0\u{3}field_321\0\u{3}field_322\0\u{3}field_323\0\u{3}field_324\0\u{3}field_325\0\u{3}field_326\0\u{3}field_327\0\u{3}field_328\0\u{3}field_329\0\u{3}field_330\0\u{3}field_331\0\u{3}field_332\0\u{3}field_333\0\u{3}field_334\0\u{3}field_335\0\u{3}field_336\0\u{3}field_337\0\u{3}field_338\0\u{3}field_339\0\u{3}field_340\0\u{3}field_341\0\u{3}field_342\0\u{3}field_343\0\u{3}field_344\0\u{3}field_345\0\u{3}field_346\0\u{3}field_347\0\u{3}field_348\0\u{3}field_349\0\u{3}field_350\0\u{3}field_351\0\u{3}field_352\0\u{3}field_353\0\u{3}field_354\0\u{3}field_355\0\u{3}field_356\0\u{3}field_357\0\u{3}field_358\0\u{3}field_359\0\u{3}field_360\0\u{3}field_361\0\u{3}field_362\0\u{3}field_363\0\u{3}field_364\0\u{3}field_365\0\u{3}field_366\0\u{3}field_367\0\u{3}field_368\0\u{3}field_369\0\u{3}field_370\0\u{3}field_371\0\u{3}field_372\0\u{3}field_373\0\u{3}field_374\0\u{3}field_375\0\u{3}field_376\0\u{3}field_377\0\u{3}field_378\0\u{3}field_379\0\u{3}field_380\0\u{3}field_381\0\u{3}field_382\0\u{3}field_383\0\u{3}field_384\0\u{3}field_385\0\u{3}field_386\0\u{3}field_387\0\u{3}field_388\0\u{3}field_389\0\u{3}field_390\0\u{3}field_391\0\u{3}field_392\0\u{3}field_393\0\u{3}field_394\0\u{3}field_395\0\u{3}field_396\0\u{3}field_397\0\u{3}field_398\0\u{3}field_399\0\u{3}field_300\0\u{3}field_401\0\u{3}field_402\0\u{3}field_403\0\u{3}field_404\0\u{3}field_405\0\u{3}field_406\0\u{3}field_407\0\u{3}field_408\0\u{3}field_409\0\u{3}field_410\0\u{3}field_411\0\u{3}field_412\0\u{3}field_413\0\u{3}field_414\0\u{3}field_415\0\u{3}field_416\0\u{3}field_417\0\u{3}field_418\0\u{3}field_419\0\u{3}field_420\0\u{3}field_421\0\u{3}field_422\0\u{3}field_423\0\u{3}field_424\0\u{3}field_425\0\u{3}field_426\0\u{3}field_427\0\u{3}field_428\0\u{3}field_429\0\u{3}field_430\0\u{3}field_431\0\u{3}field_432\0\u{3}field_433\0\u{3}field_434\0\u{3}field_435\0\u{3}field_436\0\u{3}field_437\0\u{3}field_438\0\u{3}field_439\0\u{3}field_440\0\u{3}field_441\0\u{3}field_442\0\u{3}field_443\0\u{3}field_444\0\u{3}field_445\0\u{3}field_446\0\u{3}field_447\0\u{3}field_448\0\u{3}field_449\0\u{3}field_450\0\u{3}field_451\0\u{3}field_452\0\u{3}field_453\0\u{3}field_454\0\u{3}field_455\0\u{3}field_456\0\u{3}field_457\0\u{3}field_458\0\u{3}field_459\0\u{3}field_460\0\u{3}field_461\0\u{3}field_462\0\u{3}field_463\0\u{3}field_464\0\u{3}field_465\0\u{3}field_466\0\u{3}field_467\0\u{3}field_468\0\u{3}field_469\0\u{3}field_470\0\u{3}field_471\0\u{3}field_472\0\u{3}field_473\0\u{3}field_474\0\u{3}field_475\0\u{3}field_476\0\u{3}field_477\0\u{3}field_478\0\u{3}field_479\0\u{3}field_480\0\u{3}field_481\0\u{3}field_482\0\u{3}field_483\0\u{3}field_484\0\u{3}field_485\0\u{3}field_486\0\u{3}field_487\0\u{3}field_488\0\u{3}field_489\0\u{3}field_490\0\u{3}field_491\0\u{3}field_492\0\u{3}field_493\0\u{3}field_494\0\u{3}field_495\0\u{3}field_496\0\u{3}field_497\0\u{3}field_498\0\u{3}field_499\0\u{3}field_500\0\u{3}field_501\0\u{3}regular_field_502\0\u{3}field_503\0\u{3}field_504\0\u{3}field_505\0\u{3}field_506\0\u{3}field_507\0\u{3}field_508\0\u{3}regular_field_509\0\u{3}field_510\0") + + 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: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field001(v) + } + }() + case 2: try { try decoder.decodeSingularInt32Field(value: &self._regularField002) }() + case 3: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field003(v) + } + }() + case 4: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field004(v) + } + }() + case 5: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field005(v) + } + }() + case 6: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field006(v) + } + }() + case 7: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field007(v) + } + }() + case 8: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field008(v) + } + }() + case 9: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field009(v) + } + }() + case 10: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field050(v) + } + }() + case 11: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field011(v) + } + }() + case 12: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field012(v) + } + }() + case 13: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field013(v) + } + }() + case 14: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field014(v) + } + }() + case 15: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field015(v) + } + }() + case 16: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field016(v) + } + }() + case 17: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field017(v) + } + }() + case 18: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field018(v) + } + }() + case 19: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field019(v) + } + }() + case 20: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field020(v) + } + }() + case 21: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field021(v) + } + }() + case 22: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field022(v) + } + }() + case 23: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field023(v) + } + }() + case 24: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field024(v) + } + }() + case 25: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field025(v) + } + }() + case 26: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field026(v) + } + }() + case 27: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field027(v) + } + }() + case 28: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field028(v) + } + }() + case 29: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field029(v) + } + }() + case 30: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field030(v) + } + }() + case 31: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field031(v) + } + }() + case 32: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field032(v) + } + }() + case 33: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field033(v) + } + }() + case 34: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field034(v) + } + }() + case 35: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field035(v) + } + }() + case 36: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field036(v) + } + }() + case 37: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field037(v) + } + }() + case 38: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field038(v) + } + }() + case 39: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field039(v) + } + }() + case 40: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field040(v) + } + }() + case 41: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field041(v) + } + }() + case 42: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field042(v) + } + }() + case 43: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field043(v) + } + }() + case 44: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field044(v) + } + }() + case 45: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field045(v) + } + }() + case 46: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field046(v) + } + }() + case 47: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field047(v) + } + }() + case 48: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field048(v) + } + }() + case 49: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field049(v) + } + }() + case 50: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field010(v) + } + }() + case 51: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field051(v) + } + }() + case 52: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field052(v) + } + }() + case 53: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field053(v) + } + }() + case 54: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field054(v) + } + }() + case 55: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field055(v) + } + }() + case 56: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field056(v) + } + }() + case 57: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field057(v) + } + }() + case 58: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field058(v) + } + }() + case 59: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field059(v) + } + }() + case 60: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field060(v) + } + }() + case 61: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field061(v) + } + }() + case 62: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field062(v) + } + }() + case 63: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field063(v) + } + }() + case 64: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field064(v) + } + }() + case 65: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field065(v) + } + }() + case 66: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field066(v) + } + }() + case 67: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field067(v) + } + }() + case 68: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field068(v) + } + }() + case 69: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field069(v) + } + }() + case 70: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field070(v) + } + }() + case 71: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field071(v) + } + }() + case 72: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field072(v) + } + }() + case 73: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field073(v) + } + }() + case 74: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field074(v) + } + }() + case 75: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field075(v) + } + }() + case 76: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field076(v) + } + }() + case 77: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field077(v) + } + }() + case 78: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field078(v) + } + }() + case 79: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field079(v) + } + }() + case 80: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field080(v) + } + }() + case 81: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field081(v) + } + }() + case 82: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field082(v) + } + }() + case 83: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field083(v) + } + }() + case 84: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field084(v) + } + }() + case 85: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field085(v) + } + }() + case 86: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field086(v) + } + }() + case 87: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field087(v) + } + }() + case 88: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field088(v) + } + }() + case 89: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field089(v) + } + }() + case 90: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field090(v) + } + }() + case 91: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field091(v) + } + }() + case 92: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field092(v) + } + }() + case 93: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field093(v) + } + }() + case 94: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field094(v) + } + }() + case 95: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field095(v) + } + }() + case 96: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field096(v) + } + }() + case 97: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field097(v) + } + }() + case 98: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field098(v) + } + }() + case 99: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field099(v) + } + }() + case 100: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field200(v) + } + }() + case 101: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field101(v) + } + }() + case 102: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field102(v) + } + }() + case 103: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field103(v) + } + }() + case 104: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field104(v) + } + }() + case 105: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field105(v) + } + }() + case 106: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field106(v) + } + }() + case 107: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field107(v) + } + }() + case 108: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field108(v) + } + }() + case 109: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field109(v) + } + }() + case 110: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field110(v) + } + }() + case 111: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field111(v) + } + }() + case 112: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field112(v) + } + }() + case 113: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field113(v) + } + }() + case 114: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field114(v) + } + }() + case 115: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field115(v) + } + }() + case 116: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field116(v) + } + }() + case 117: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field117(v) + } + }() + case 118: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field118(v) + } + }() + case 119: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field119(v) + } + }() + case 120: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field120(v) + } + }() + case 121: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field121(v) + } + }() + case 122: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field122(v) + } + }() + case 123: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field123(v) + } + }() + case 124: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field124(v) + } + }() + case 125: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field125(v) + } + }() + case 126: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field126(v) + } + }() + case 127: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field127(v) + } + }() + case 128: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field128(v) + } + }() + case 129: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field129(v) + } + }() + case 130: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field130(v) + } + }() + case 131: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field131(v) + } + }() + case 132: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field132(v) + } + }() + case 133: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field133(v) + } + }() + case 134: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field134(v) + } + }() + case 135: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field135(v) + } + }() + case 136: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field136(v) + } + }() + case 137: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field137(v) + } + }() + case 138: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field138(v) + } + }() + case 139: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field139(v) + } + }() + case 140: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field140(v) + } + }() + case 141: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field141(v) + } + }() + case 142: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field142(v) + } + }() + case 143: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field143(v) + } + }() + case 144: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field144(v) + } + }() + case 145: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field145(v) + } + }() + case 146: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field146(v) + } + }() + case 147: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field147(v) + } + }() + case 148: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field148(v) + } + }() + case 149: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field149(v) + } + }() + case 150: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field150(v) + } + }() + case 151: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field151(v) + } + }() + case 152: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field152(v) + } + }() + case 153: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field153(v) + } + }() + case 154: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field154(v) + } + }() + case 155: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field155(v) + } + }() + case 156: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field156(v) + } + }() + case 157: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field157(v) + } + }() + case 158: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field158(v) + } + }() + case 159: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field159(v) + } + }() + case 160: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field160(v) + } + }() + case 161: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field161(v) + } + }() + case 162: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field162(v) + } + }() + case 163: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field163(v) + } + }() + case 164: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field164(v) + } + }() + case 165: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field165(v) + } + }() + case 166: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field166(v) + } + }() + case 167: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field167(v) + } + }() + case 168: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field168(v) + } + }() + case 169: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field169(v) + } + }() + case 170: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field170(v) + } + }() + case 171: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field171(v) + } + }() + case 172: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field172(v) + } + }() + case 173: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field173(v) + } + }() + case 174: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field174(v) + } + }() + case 175: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field175(v) + } + }() + case 176: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field176(v) + } + }() + case 177: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field177(v) + } + }() + case 178: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field178(v) + } + }() + case 179: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field179(v) + } + }() + case 180: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field180(v) + } + }() + case 181: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field181(v) + } + }() + case 182: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field182(v) + } + }() + case 183: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field183(v) + } + }() + case 184: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field184(v) + } + }() + case 185: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field185(v) + } + }() + case 186: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field186(v) + } + }() + case 187: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field187(v) + } + }() + case 188: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field188(v) + } + }() + case 189: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field189(v) + } + }() + case 190: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field190(v) + } + }() + case 191: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field191(v) + } + }() + case 192: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field192(v) + } + }() + case 193: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field193(v) + } + }() + case 194: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field194(v) + } + }() + case 195: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field195(v) + } + }() + case 196: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field196(v) + } + }() + case 197: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field197(v) + } + }() + case 198: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field198(v) + } + }() + case 199: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field199(v) + } + }() + case 200: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field100(v) + } + }() + case 201: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field201(v) + } + }() + case 202: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field202(v) + } + }() + case 203: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field203(v) + } + }() + case 204: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field204(v) + } + }() + case 205: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field205(v) + } + }() + case 206: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field206(v) + } + }() + case 207: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field207(v) + } + }() + case 208: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field208(v) + } + }() + case 209: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field209(v) + } + }() + case 210: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field210(v) + } + }() + case 211: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field211(v) + } + }() + case 212: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field212(v) + } + }() + case 213: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field213(v) + } + }() + case 214: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field214(v) + } + }() + case 215: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field215(v) + } + }() + case 216: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field216(v) + } + }() + case 217: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field217(v) + } + }() + case 218: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field218(v) + } + }() + case 219: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field219(v) + } + }() + case 220: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field220(v) + } + }() + case 221: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field221(v) + } + }() + case 222: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field222(v) + } + }() + case 223: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field223(v) + } + }() + case 224: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field224(v) + } + }() + case 225: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field225(v) + } + }() + case 226: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field226(v) + } + }() + case 227: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field227(v) + } + }() + case 228: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field228(v) + } + }() + case 229: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field229(v) + } + }() + case 230: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field230(v) + } + }() + case 231: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field231(v) + } + }() + case 232: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field232(v) + } + }() + case 233: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field233(v) + } + }() + case 234: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field234(v) + } + }() + case 235: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field235(v) + } + }() + case 236: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field236(v) + } + }() + case 237: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field237(v) + } + }() + case 238: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field238(v) + } + }() + case 239: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field239(v) + } + }() + case 240: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field240(v) + } + }() + case 241: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field241(v) + } + }() + case 242: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field242(v) + } + }() + case 243: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field243(v) + } + }() + case 244: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field244(v) + } + }() + case 245: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field245(v) + } + }() + case 246: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field246(v) + } + }() + case 247: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field247(v) + } + }() + case 248: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field248(v) + } + }() + case 249: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field249(v) + } + }() + case 250: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field250(v) + } + }() + case 251: try { try decoder.decodeSingularInt32Field(value: &self._regularField251) }() + case 252: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field252(v) + } + }() + case 253: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field253(v) + } + }() + case 254: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field254(v) + } + }() + case 255: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field255(v) + } + }() + case 256: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field256(v) + } + }() + case 257: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field257(v) + } + }() + case 258: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field258(v) + } + }() + case 259: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field259(v) + } + }() + case 260: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field260(v) + } + }() + case 261: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field261(v) + } + }() + case 262: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field262(v) + } + }() + case 263: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field263(v) + } + }() + case 264: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field264(v) + } + }() + case 265: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field265(v) + } + }() + case 266: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field266(v) + } + }() + case 267: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field267(v) + } + }() + case 268: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field268(v) + } + }() + case 269: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field269(v) + } + }() + case 270: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field270(v) + } + }() + case 271: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field271(v) + } + }() + case 272: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field272(v) + } + }() + case 273: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field273(v) + } + }() + case 274: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field274(v) + } + }() + case 275: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field275(v) + } + }() + case 276: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field276(v) + } + }() + case 277: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field277(v) + } + }() + case 278: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field278(v) + } + }() + case 279: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field279(v) + } + }() + case 280: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field280(v) + } + }() + case 281: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field281(v) + } + }() + case 282: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field282(v) + } + }() + case 283: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field283(v) + } + }() + case 284: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field284(v) + } + }() + case 285: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field285(v) + } + }() + case 286: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field286(v) + } + }() + case 287: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field287(v) + } + }() + case 288: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field288(v) + } + }() + case 289: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field289(v) + } + }() + case 290: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field290(v) + } + }() + case 291: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field291(v) + } + }() + case 292: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field292(v) + } + }() + case 293: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field293(v) + } + }() + case 294: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field294(v) + } + }() + case 295: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field295(v) + } + }() + case 296: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field296(v) + } + }() + case 297: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field297(v) + } + }() + case 298: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field298(v) + } + }() + case 299: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field299(v) + } + }() + case 300: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field400(v) + } + }() + case 301: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field301(v) + } + }() + case 302: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field302(v) + } + }() + case 303: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field303(v) + } + }() + case 304: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field304(v) + } + }() + case 305: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field305(v) + } + }() + case 306: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field306(v) + } + }() + case 307: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field307(v) + } + }() + case 308: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field308(v) + } + }() + case 309: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field309(v) + } + }() + case 310: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field310(v) + } + }() + case 311: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field311(v) + } + }() + case 312: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field312(v) + } + }() + case 313: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field313(v) + } + }() + case 314: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field314(v) + } + }() + case 315: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field315(v) + } + }() + case 316: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field316(v) + } + }() + case 317: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field317(v) + } + }() + case 318: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field318(v) + } + }() + case 319: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field319(v) + } + }() + case 320: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field320(v) + } + }() + case 321: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field321(v) + } + }() + case 322: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field322(v) + } + }() + case 323: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field323(v) + } + }() + case 324: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field324(v) + } + }() + case 325: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field325(v) + } + }() + case 326: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field326(v) + } + }() + case 327: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field327(v) + } + }() + case 328: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field328(v) + } + }() + case 329: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field329(v) + } + }() + case 330: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field330(v) + } + }() + case 331: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field331(v) + } + }() + case 332: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field332(v) + } + }() + case 333: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field333(v) + } + }() + case 334: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field334(v) + } + }() + case 335: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field335(v) + } + }() + case 336: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field336(v) + } + }() + case 337: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field337(v) + } + }() + case 338: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field338(v) + } + }() + case 339: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field339(v) + } + }() + case 340: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field340(v) + } + }() + case 341: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field341(v) + } + }() + case 342: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field342(v) + } + }() + case 343: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field343(v) + } + }() + case 344: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field344(v) + } + }() + case 345: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field345(v) + } + }() + case 346: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field346(v) + } + }() + case 347: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field347(v) + } + }() + case 348: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field348(v) + } + }() + case 349: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field349(v) + } + }() + case 350: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field350(v) + } + }() + case 351: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field351(v) + } + }() + case 352: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field352(v) + } + }() + case 353: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field353(v) + } + }() + case 354: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field354(v) + } + }() + case 355: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field355(v) + } + }() + case 356: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field356(v) + } + }() + case 357: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field357(v) + } + }() + case 358: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field358(v) + } + }() + case 359: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field359(v) + } + }() + case 360: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field360(v) + } + }() + case 361: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field361(v) + } + }() + case 362: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field362(v) + } + }() + case 363: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field363(v) + } + }() + case 364: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field364(v) + } + }() + case 365: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field365(v) + } + }() + case 366: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field366(v) + } + }() + case 367: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field367(v) + } + }() + case 368: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field368(v) + } + }() + case 369: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field369(v) + } + }() + case 370: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field370(v) + } + }() + case 371: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field371(v) + } + }() + case 372: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field372(v) + } + }() + case 373: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field373(v) + } + }() + case 374: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field374(v) + } + }() + case 375: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field375(v) + } + }() + case 376: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field376(v) + } + }() + case 377: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field377(v) + } + }() + case 378: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field378(v) + } + }() + case 379: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field379(v) + } + }() + case 380: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field380(v) + } + }() + case 381: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field381(v) + } + }() + case 382: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field382(v) + } + }() + case 383: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field383(v) + } + }() + case 384: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field384(v) + } + }() + case 385: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field385(v) + } + }() + case 386: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field386(v) + } + }() + case 387: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field387(v) + } + }() + case 388: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field388(v) + } + }() + case 389: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field389(v) + } + }() + case 390: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field390(v) + } + }() + case 391: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field391(v) + } + }() + case 392: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field392(v) + } + }() + case 393: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field393(v) + } + }() + case 394: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field394(v) + } + }() + case 395: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field395(v) + } + }() + case 396: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field396(v) + } + }() + case 397: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field397(v) + } + }() + case 398: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field398(v) + } + }() + case 399: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field399(v) + } + }() + case 400: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field300(v) + } + }() + case 401: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field401(v) + } + }() + case 402: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field402(v) + } + }() + case 403: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field403(v) + } + }() + case 404: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field404(v) + } + }() + case 405: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field405(v) + } + }() + case 406: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field406(v) + } + }() + case 407: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field407(v) + } + }() + case 408: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field408(v) + } + }() + case 409: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field409(v) + } + }() + case 410: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field410(v) + } + }() + case 411: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field411(v) + } + }() + case 412: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field412(v) + } + }() + case 413: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field413(v) + } + }() + case 414: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field414(v) + } + }() + case 415: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field415(v) + } + }() + case 416: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field416(v) + } + }() + case 417: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field417(v) + } + }() + case 418: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field418(v) + } + }() + case 419: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field419(v) + } + }() + case 420: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field420(v) + } + }() + case 421: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field421(v) + } + }() + case 422: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field422(v) + } + }() + case 423: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field423(v) + } + }() + case 424: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field424(v) + } + }() + case 425: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field425(v) + } + }() + case 426: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field426(v) + } + }() + case 427: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field427(v) + } + }() + case 428: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field428(v) + } + }() + case 429: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field429(v) + } + }() + case 430: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field430(v) + } + }() + case 431: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field431(v) + } + }() + case 432: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field432(v) + } + }() + case 433: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field433(v) + } + }() + case 434: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field434(v) + } + }() + case 435: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field435(v) + } + }() + case 436: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field436(v) + } + }() + case 437: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field437(v) + } + }() + case 438: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field438(v) + } + }() + case 439: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field439(v) + } + }() + case 440: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field440(v) + } + }() + case 441: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field441(v) + } + }() + case 442: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field442(v) + } + }() + case 443: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field443(v) + } + }() + case 444: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field444(v) + } + }() + case 445: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field445(v) + } + }() + case 446: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field446(v) + } + }() + case 447: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field447(v) + } + }() + case 448: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field448(v) + } + }() + case 449: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field449(v) + } + }() + case 450: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field450(v) + } + }() + case 451: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field451(v) + } + }() + case 452: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field452(v) + } + }() + case 453: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field453(v) + } + }() + case 454: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field454(v) + } + }() + case 455: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field455(v) + } + }() + case 456: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field456(v) + } + }() + case 457: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field457(v) + } + }() + case 458: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field458(v) + } + }() + case 459: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field459(v) + } + }() + case 460: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field460(v) + } + }() + case 461: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field461(v) + } + }() + case 462: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field462(v) + } + }() + case 463: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field463(v) + } + }() + case 464: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field464(v) + } + }() + case 465: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field465(v) + } + }() + case 466: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field466(v) + } + }() + case 467: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field467(v) + } + }() + case 468: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field468(v) + } + }() + case 469: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field469(v) + } + }() + case 470: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field470(v) + } + }() + case 471: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field471(v) + } + }() + case 472: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field472(v) + } + }() + case 473: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field473(v) + } + }() + case 474: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field474(v) + } + }() + case 475: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field475(v) + } + }() + case 476: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field476(v) + } + }() + case 477: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field477(v) + } + }() + case 478: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field478(v) + } + }() + case 479: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field479(v) + } + }() + case 480: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field480(v) + } + }() + case 481: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field481(v) + } + }() + case 482: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field482(v) + } + }() + case 483: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field483(v) + } + }() + case 484: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field484(v) + } + }() + case 485: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field485(v) + } + }() + case 486: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field486(v) + } + }() + case 487: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field487(v) + } + }() + case 488: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field488(v) + } + }() + case 489: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field489(v) + } + }() + case 490: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field490(v) + } + }() + case 491: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field491(v) + } + }() + case 492: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field492(v) + } + }() + case 493: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field493(v) + } + }() + case 494: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field494(v) + } + }() + case 495: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field495(v) + } + }() + case 496: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field496(v) + } + }() + case 497: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field497(v) + } + }() + case 498: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field498(v) + } + }() + case 499: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field499(v) + } + }() + case 500: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field500(v) + } + }() + case 501: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field501(v) + } + }() + case 502: try { try decoder.decodeSingularInt32Field(value: &self._regularField502) }() + case 503: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field503(v) + } + }() + case 504: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field504(v) + } + }() + case 505: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field505(v) + } + }() + case 506: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field506(v) + } + }() + case 507: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field507(v) + } + }() + case 508: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field508(v) + } + }() + case 509: try { try decoder.decodeSingularInt32Field(value: &self._regularField509) }() + case 510: try { + var v: Int32? + try decoder.decodeSingularInt32Field(value: &v) + if let v = v { + if self.value != nil {try decoder.handleConflictingOneOf()} + self.value = .field510(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 + try { if case .field001(let v)? = self.value { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 1) + } }() + try { if let v = self._regularField002 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 2) + } }() + switch self.value { + case .field003?: try { + guard case .field003(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 3) + }() + case .field004?: try { + guard case .field004(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 4) + }() + case .field005?: try { + guard case .field005(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 5) + }() + case .field006?: try { + guard case .field006(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 6) + }() + case .field007?: try { + guard case .field007(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 7) + }() + case .field008?: try { + guard case .field008(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 8) + }() + case .field009?: try { + guard case .field009(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 9) + }() + case .field050?: try { + guard case .field050(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 10) + }() + case .field011?: try { + guard case .field011(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 11) + }() + case .field012?: try { + guard case .field012(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 12) + }() + case .field013?: try { + guard case .field013(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 13) + }() + case .field014?: try { + guard case .field014(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 14) + }() + case .field015?: try { + guard case .field015(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 15) + }() + case .field016?: try { + guard case .field016(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 16) + }() + case .field017?: try { + guard case .field017(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 17) + }() + case .field018?: try { + guard case .field018(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 18) + }() + case .field019?: try { + guard case .field019(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 19) + }() + case .field020?: try { + guard case .field020(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 20) + }() + case .field021?: try { + guard case .field021(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 21) + }() + case .field022?: try { + guard case .field022(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 22) + }() + case .field023?: try { + guard case .field023(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 23) + }() + case .field024?: try { + guard case .field024(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 24) + }() + case .field025?: try { + guard case .field025(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 25) + }() + case .field026?: try { + guard case .field026(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 26) + }() + case .field027?: try { + guard case .field027(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 27) + }() + case .field028?: try { + guard case .field028(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 28) + }() + case .field029?: try { + guard case .field029(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 29) + }() + case .field030?: try { + guard case .field030(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 30) + }() + case .field031?: try { + guard case .field031(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 31) + }() + case .field032?: try { + guard case .field032(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 32) + }() + case .field033?: try { + guard case .field033(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 33) + }() + case .field034?: try { + guard case .field034(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 34) + }() + case .field035?: try { + guard case .field035(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 35) + }() + case .field036?: try { + guard case .field036(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 36) + }() + case .field037?: try { + guard case .field037(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 37) + }() + case .field038?: try { + guard case .field038(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 38) + }() + case .field039?: try { + guard case .field039(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 39) + }() + case .field040?: try { + guard case .field040(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 40) + }() + case .field041?: try { + guard case .field041(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 41) + }() + case .field042?: try { + guard case .field042(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 42) + }() + case .field043?: try { + guard case .field043(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 43) + }() + case .field044?: try { + guard case .field044(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 44) + }() + case .field045?: try { + guard case .field045(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 45) + }() + case .field046?: try { + guard case .field046(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 46) + }() + case .field047?: try { + guard case .field047(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 47) + }() + case .field048?: try { + guard case .field048(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 48) + }() + case .field049?: try { + guard case .field049(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 49) + }() + case .field010?: try { + guard case .field010(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 50) + }() + case .field051?: try { + guard case .field051(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 51) + }() + case .field052?: try { + guard case .field052(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 52) + }() + case .field053?: try { + guard case .field053(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 53) + }() + case .field054?: try { + guard case .field054(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 54) + }() + case .field055?: try { + guard case .field055(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 55) + }() + case .field056?: try { + guard case .field056(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 56) + }() + case .field057?: try { + guard case .field057(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 57) + }() + case .field058?: try { + guard case .field058(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 58) + }() + case .field059?: try { + guard case .field059(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 59) + }() + case .field060?: try { + guard case .field060(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 60) + }() + case .field061?: try { + guard case .field061(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 61) + }() + case .field062?: try { + guard case .field062(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 62) + }() + case .field063?: try { + guard case .field063(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 63) + }() + case .field064?: try { + guard case .field064(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 64) + }() + case .field065?: try { + guard case .field065(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 65) + }() + case .field066?: try { + guard case .field066(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 66) + }() + case .field067?: try { + guard case .field067(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 67) + }() + case .field068?: try { + guard case .field068(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 68) + }() + case .field069?: try { + guard case .field069(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 69) + }() + case .field070?: try { + guard case .field070(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 70) + }() + case .field071?: try { + guard case .field071(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 71) + }() + case .field072?: try { + guard case .field072(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 72) + }() + case .field073?: try { + guard case .field073(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 73) + }() + case .field074?: try { + guard case .field074(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 74) + }() + case .field075?: try { + guard case .field075(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 75) + }() + case .field076?: try { + guard case .field076(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 76) + }() + case .field077?: try { + guard case .field077(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 77) + }() + case .field078?: try { + guard case .field078(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 78) + }() + case .field079?: try { + guard case .field079(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 79) + }() + case .field080?: try { + guard case .field080(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 80) + }() + case .field081?: try { + guard case .field081(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 81) + }() + case .field082?: try { + guard case .field082(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 82) + }() + case .field083?: try { + guard case .field083(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 83) + }() + case .field084?: try { + guard case .field084(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 84) + }() + case .field085?: try { + guard case .field085(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 85) + }() + case .field086?: try { + guard case .field086(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 86) + }() + case .field087?: try { + guard case .field087(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 87) + }() + case .field088?: try { + guard case .field088(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 88) + }() + case .field089?: try { + guard case .field089(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 89) + }() + case .field090?: try { + guard case .field090(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 90) + }() + case .field091?: try { + guard case .field091(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 91) + }() + case .field092?: try { + guard case .field092(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 92) + }() + case .field093?: try { + guard case .field093(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 93) + }() + case .field094?: try { + guard case .field094(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 94) + }() + case .field095?: try { + guard case .field095(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 95) + }() + case .field096?: try { + guard case .field096(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 96) + }() + case .field097?: try { + guard case .field097(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 97) + }() + case .field098?: try { + guard case .field098(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 98) + }() + case .field099?: try { + guard case .field099(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 99) + }() + case .field200?: try { + guard case .field200(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 100) + }() + case .field101?: try { + guard case .field101(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 101) + }() + case .field102?: try { + guard case .field102(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 102) + }() + case .field103?: try { + guard case .field103(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 103) + }() + case .field104?: try { + guard case .field104(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 104) + }() + case .field105?: try { + guard case .field105(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 105) + }() + case .field106?: try { + guard case .field106(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 106) + }() + case .field107?: try { + guard case .field107(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 107) + }() + case .field108?: try { + guard case .field108(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 108) + }() + case .field109?: try { + guard case .field109(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 109) + }() + case .field110?: try { + guard case .field110(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 110) + }() + case .field111?: try { + guard case .field111(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 111) + }() + case .field112?: try { + guard case .field112(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 112) + }() + case .field113?: try { + guard case .field113(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 113) + }() + case .field114?: try { + guard case .field114(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 114) + }() + case .field115?: try { + guard case .field115(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 115) + }() + case .field116?: try { + guard case .field116(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 116) + }() + case .field117?: try { + guard case .field117(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 117) + }() + case .field118?: try { + guard case .field118(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 118) + }() + case .field119?: try { + guard case .field119(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 119) + }() + case .field120?: try { + guard case .field120(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 120) + }() + case .field121?: try { + guard case .field121(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 121) + }() + case .field122?: try { + guard case .field122(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 122) + }() + case .field123?: try { + guard case .field123(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 123) + }() + case .field124?: try { + guard case .field124(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 124) + }() + case .field125?: try { + guard case .field125(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 125) + }() + case .field126?: try { + guard case .field126(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 126) + }() + case .field127?: try { + guard case .field127(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 127) + }() + case .field128?: try { + guard case .field128(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 128) + }() + case .field129?: try { + guard case .field129(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 129) + }() + case .field130?: try { + guard case .field130(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 130) + }() + case .field131?: try { + guard case .field131(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 131) + }() + case .field132?: try { + guard case .field132(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 132) + }() + case .field133?: try { + guard case .field133(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 133) + }() + case .field134?: try { + guard case .field134(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 134) + }() + case .field135?: try { + guard case .field135(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 135) + }() + case .field136?: try { + guard case .field136(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 136) + }() + case .field137?: try { + guard case .field137(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 137) + }() + case .field138?: try { + guard case .field138(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 138) + }() + case .field139?: try { + guard case .field139(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 139) + }() + case .field140?: try { + guard case .field140(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 140) + }() + case .field141?: try { + guard case .field141(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 141) + }() + case .field142?: try { + guard case .field142(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 142) + }() + case .field143?: try { + guard case .field143(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 143) + }() + case .field144?: try { + guard case .field144(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 144) + }() + case .field145?: try { + guard case .field145(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 145) + }() + case .field146?: try { + guard case .field146(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 146) + }() + case .field147?: try { + guard case .field147(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 147) + }() + case .field148?: try { + guard case .field148(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 148) + }() + case .field149?: try { + guard case .field149(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 149) + }() + case .field150?: try { + guard case .field150(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 150) + }() + case .field151?: try { + guard case .field151(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 151) + }() + case .field152?: try { + guard case .field152(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 152) + }() + case .field153?: try { + guard case .field153(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 153) + }() + case .field154?: try { + guard case .field154(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 154) + }() + case .field155?: try { + guard case .field155(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 155) + }() + case .field156?: try { + guard case .field156(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 156) + }() + case .field157?: try { + guard case .field157(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 157) + }() + case .field158?: try { + guard case .field158(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 158) + }() + case .field159?: try { + guard case .field159(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 159) + }() + case .field160?: try { + guard case .field160(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 160) + }() + case .field161?: try { + guard case .field161(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 161) + }() + case .field162?: try { + guard case .field162(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 162) + }() + case .field163?: try { + guard case .field163(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 163) + }() + case .field164?: try { + guard case .field164(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 164) + }() + case .field165?: try { + guard case .field165(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 165) + }() + case .field166?: try { + guard case .field166(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 166) + }() + case .field167?: try { + guard case .field167(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 167) + }() + case .field168?: try { + guard case .field168(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 168) + }() + case .field169?: try { + guard case .field169(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 169) + }() + case .field170?: try { + guard case .field170(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 170) + }() + case .field171?: try { + guard case .field171(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 171) + }() + case .field172?: try { + guard case .field172(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 172) + }() + case .field173?: try { + guard case .field173(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 173) + }() + case .field174?: try { + guard case .field174(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 174) + }() + case .field175?: try { + guard case .field175(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 175) + }() + case .field176?: try { + guard case .field176(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 176) + }() + case .field177?: try { + guard case .field177(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 177) + }() + case .field178?: try { + guard case .field178(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 178) + }() + case .field179?: try { + guard case .field179(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 179) + }() + case .field180?: try { + guard case .field180(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 180) + }() + case .field181?: try { + guard case .field181(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 181) + }() + case .field182?: try { + guard case .field182(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 182) + }() + case .field183?: try { + guard case .field183(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 183) + }() + case .field184?: try { + guard case .field184(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 184) + }() + case .field185?: try { + guard case .field185(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 185) + }() + case .field186?: try { + guard case .field186(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 186) + }() + case .field187?: try { + guard case .field187(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 187) + }() + case .field188?: try { + guard case .field188(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 188) + }() + case .field189?: try { + guard case .field189(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 189) + }() + case .field190?: try { + guard case .field190(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 190) + }() + case .field191?: try { + guard case .field191(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 191) + }() + case .field192?: try { + guard case .field192(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 192) + }() + case .field193?: try { + guard case .field193(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 193) + }() + case .field194?: try { + guard case .field194(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 194) + }() + case .field195?: try { + guard case .field195(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 195) + }() + case .field196?: try { + guard case .field196(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 196) + }() + case .field197?: try { + guard case .field197(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 197) + }() + case .field198?: try { + guard case .field198(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 198) + }() + case .field199?: try { + guard case .field199(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 199) + }() + case .field100?: try { + guard case .field100(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 200) + }() + case .field201?: try { + guard case .field201(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 201) + }() + case .field202?: try { + guard case .field202(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 202) + }() + case .field203?: try { + guard case .field203(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 203) + }() + case .field204?: try { + guard case .field204(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 204) + }() + case .field205?: try { + guard case .field205(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 205) + }() + case .field206?: try { + guard case .field206(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 206) + }() + case .field207?: try { + guard case .field207(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 207) + }() + case .field208?: try { + guard case .field208(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 208) + }() + case .field209?: try { + guard case .field209(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 209) + }() + case .field210?: try { + guard case .field210(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 210) + }() + case .field211?: try { + guard case .field211(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 211) + }() + case .field212?: try { + guard case .field212(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 212) + }() + case .field213?: try { + guard case .field213(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 213) + }() + case .field214?: try { + guard case .field214(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 214) + }() + case .field215?: try { + guard case .field215(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 215) + }() + case .field216?: try { + guard case .field216(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 216) + }() + case .field217?: try { + guard case .field217(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 217) + }() + case .field218?: try { + guard case .field218(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 218) + }() + case .field219?: try { + guard case .field219(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 219) + }() + case .field220?: try { + guard case .field220(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 220) + }() + case .field221?: try { + guard case .field221(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 221) + }() + case .field222?: try { + guard case .field222(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 222) + }() + case .field223?: try { + guard case .field223(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 223) + }() + case .field224?: try { + guard case .field224(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 224) + }() + case .field225?: try { + guard case .field225(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 225) + }() + case .field226?: try { + guard case .field226(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 226) + }() + case .field227?: try { + guard case .field227(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 227) + }() + case .field228?: try { + guard case .field228(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 228) + }() + case .field229?: try { + guard case .field229(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 229) + }() + case .field230?: try { + guard case .field230(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 230) + }() + case .field231?: try { + guard case .field231(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 231) + }() + case .field232?: try { + guard case .field232(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 232) + }() + case .field233?: try { + guard case .field233(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 233) + }() + case .field234?: try { + guard case .field234(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 234) + }() + case .field235?: try { + guard case .field235(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 235) + }() + case .field236?: try { + guard case .field236(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 236) + }() + case .field237?: try { + guard case .field237(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 237) + }() + case .field238?: try { + guard case .field238(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 238) + }() + case .field239?: try { + guard case .field239(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 239) + }() + case .field240?: try { + guard case .field240(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 240) + }() + case .field241?: try { + guard case .field241(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 241) + }() + case .field242?: try { + guard case .field242(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 242) + }() + case .field243?: try { + guard case .field243(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 243) + }() + case .field244?: try { + guard case .field244(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 244) + }() + case .field245?: try { + guard case .field245(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 245) + }() + case .field246?: try { + guard case .field246(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 246) + }() + case .field247?: try { + guard case .field247(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 247) + }() + case .field248?: try { + guard case .field248(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 248) + }() + case .field249?: try { + guard case .field249(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 249) + }() + case .field250?: try { + guard case .field250(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 250) + }() + default: break + } + try { if let v = self._regularField251 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 251) + } }() + switch self.value { + case .field252?: try { + guard case .field252(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 252) + }() + case .field253?: try { + guard case .field253(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 253) + }() + case .field254?: try { + guard case .field254(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 254) + }() + case .field255?: try { + guard case .field255(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 255) + }() + case .field256?: try { + guard case .field256(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 256) + }() + case .field257?: try { + guard case .field257(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 257) + }() + case .field258?: try { + guard case .field258(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 258) + }() + case .field259?: try { + guard case .field259(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 259) + }() + case .field260?: try { + guard case .field260(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 260) + }() + case .field261?: try { + guard case .field261(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 261) + }() + case .field262?: try { + guard case .field262(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 262) + }() + case .field263?: try { + guard case .field263(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 263) + }() + case .field264?: try { + guard case .field264(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 264) + }() + case .field265?: try { + guard case .field265(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 265) + }() + case .field266?: try { + guard case .field266(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 266) + }() + case .field267?: try { + guard case .field267(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 267) + }() + case .field268?: try { + guard case .field268(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 268) + }() + case .field269?: try { + guard case .field269(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 269) + }() + case .field270?: try { + guard case .field270(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 270) + }() + case .field271?: try { + guard case .field271(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 271) + }() + case .field272?: try { + guard case .field272(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 272) + }() + case .field273?: try { + guard case .field273(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 273) + }() + case .field274?: try { + guard case .field274(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 274) + }() + case .field275?: try { + guard case .field275(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 275) + }() + case .field276?: try { + guard case .field276(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 276) + }() + case .field277?: try { + guard case .field277(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 277) + }() + case .field278?: try { + guard case .field278(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 278) + }() + case .field279?: try { + guard case .field279(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 279) + }() + case .field280?: try { + guard case .field280(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 280) + }() + case .field281?: try { + guard case .field281(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 281) + }() + case .field282?: try { + guard case .field282(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 282) + }() + case .field283?: try { + guard case .field283(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 283) + }() + case .field284?: try { + guard case .field284(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 284) + }() + case .field285?: try { + guard case .field285(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 285) + }() + case .field286?: try { + guard case .field286(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 286) + }() + case .field287?: try { + guard case .field287(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 287) + }() + case .field288?: try { + guard case .field288(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 288) + }() + case .field289?: try { + guard case .field289(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 289) + }() + case .field290?: try { + guard case .field290(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 290) + }() + case .field291?: try { + guard case .field291(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 291) + }() + case .field292?: try { + guard case .field292(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 292) + }() + case .field293?: try { + guard case .field293(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 293) + }() + case .field294?: try { + guard case .field294(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 294) + }() + case .field295?: try { + guard case .field295(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 295) + }() + case .field296?: try { + guard case .field296(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 296) + }() + case .field297?: try { + guard case .field297(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 297) + }() + case .field298?: try { + guard case .field298(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 298) + }() + case .field299?: try { + guard case .field299(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 299) + }() + case .field400?: try { + guard case .field400(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 300) + }() + case .field301?: try { + guard case .field301(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 301) + }() + case .field302?: try { + guard case .field302(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 302) + }() + case .field303?: try { + guard case .field303(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 303) + }() + case .field304?: try { + guard case .field304(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 304) + }() + case .field305?: try { + guard case .field305(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 305) + }() + case .field306?: try { + guard case .field306(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 306) + }() + case .field307?: try { + guard case .field307(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 307) + }() + case .field308?: try { + guard case .field308(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 308) + }() + case .field309?: try { + guard case .field309(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 309) + }() + case .field310?: try { + guard case .field310(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 310) + }() + case .field311?: try { + guard case .field311(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 311) + }() + case .field312?: try { + guard case .field312(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 312) + }() + case .field313?: try { + guard case .field313(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 313) + }() + case .field314?: try { + guard case .field314(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 314) + }() + case .field315?: try { + guard case .field315(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 315) + }() + case .field316?: try { + guard case .field316(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 316) + }() + case .field317?: try { + guard case .field317(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 317) + }() + case .field318?: try { + guard case .field318(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 318) + }() + case .field319?: try { + guard case .field319(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 319) + }() + case .field320?: try { + guard case .field320(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 320) + }() + case .field321?: try { + guard case .field321(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 321) + }() + case .field322?: try { + guard case .field322(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 322) + }() + case .field323?: try { + guard case .field323(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 323) + }() + case .field324?: try { + guard case .field324(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 324) + }() + case .field325?: try { + guard case .field325(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 325) + }() + case .field326?: try { + guard case .field326(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 326) + }() + case .field327?: try { + guard case .field327(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 327) + }() + case .field328?: try { + guard case .field328(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 328) + }() + case .field329?: try { + guard case .field329(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 329) + }() + case .field330?: try { + guard case .field330(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 330) + }() + case .field331?: try { + guard case .field331(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 331) + }() + case .field332?: try { + guard case .field332(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 332) + }() + case .field333?: try { + guard case .field333(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 333) + }() + case .field334?: try { + guard case .field334(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 334) + }() + case .field335?: try { + guard case .field335(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 335) + }() + case .field336?: try { + guard case .field336(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 336) + }() + case .field337?: try { + guard case .field337(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 337) + }() + case .field338?: try { + guard case .field338(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 338) + }() + case .field339?: try { + guard case .field339(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 339) + }() + case .field340?: try { + guard case .field340(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 340) + }() + case .field341?: try { + guard case .field341(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 341) + }() + case .field342?: try { + guard case .field342(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 342) + }() + case .field343?: try { + guard case .field343(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 343) + }() + case .field344?: try { + guard case .field344(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 344) + }() + case .field345?: try { + guard case .field345(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 345) + }() + case .field346?: try { + guard case .field346(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 346) + }() + case .field347?: try { + guard case .field347(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 347) + }() + case .field348?: try { + guard case .field348(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 348) + }() + case .field349?: try { + guard case .field349(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 349) + }() + case .field350?: try { + guard case .field350(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 350) + }() + case .field351?: try { + guard case .field351(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 351) + }() + case .field352?: try { + guard case .field352(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 352) + }() + case .field353?: try { + guard case .field353(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 353) + }() + case .field354?: try { + guard case .field354(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 354) + }() + case .field355?: try { + guard case .field355(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 355) + }() + case .field356?: try { + guard case .field356(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 356) + }() + case .field357?: try { + guard case .field357(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 357) + }() + case .field358?: try { + guard case .field358(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 358) + }() + case .field359?: try { + guard case .field359(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 359) + }() + case .field360?: try { + guard case .field360(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 360) + }() + case .field361?: try { + guard case .field361(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 361) + }() + case .field362?: try { + guard case .field362(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 362) + }() + case .field363?: try { + guard case .field363(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 363) + }() + case .field364?: try { + guard case .field364(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 364) + }() + case .field365?: try { + guard case .field365(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 365) + }() + case .field366?: try { + guard case .field366(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 366) + }() + case .field367?: try { + guard case .field367(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 367) + }() + case .field368?: try { + guard case .field368(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 368) + }() + case .field369?: try { + guard case .field369(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 369) + }() + case .field370?: try { + guard case .field370(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 370) + }() + case .field371?: try { + guard case .field371(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 371) + }() + case .field372?: try { + guard case .field372(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 372) + }() + case .field373?: try { + guard case .field373(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 373) + }() + case .field374?: try { + guard case .field374(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 374) + }() + case .field375?: try { + guard case .field375(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 375) + }() + case .field376?: try { + guard case .field376(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 376) + }() + case .field377?: try { + guard case .field377(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 377) + }() + case .field378?: try { + guard case .field378(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 378) + }() + case .field379?: try { + guard case .field379(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 379) + }() + case .field380?: try { + guard case .field380(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 380) + }() + case .field381?: try { + guard case .field381(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 381) + }() + case .field382?: try { + guard case .field382(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 382) + }() + case .field383?: try { + guard case .field383(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 383) + }() + case .field384?: try { + guard case .field384(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 384) + }() + case .field385?: try { + guard case .field385(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 385) + }() + case .field386?: try { + guard case .field386(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 386) + }() + case .field387?: try { + guard case .field387(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 387) + }() + case .field388?: try { + guard case .field388(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 388) + }() + case .field389?: try { + guard case .field389(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 389) + }() + case .field390?: try { + guard case .field390(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 390) + }() + case .field391?: try { + guard case .field391(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 391) + }() + case .field392?: try { + guard case .field392(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 392) + }() + case .field393?: try { + guard case .field393(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 393) + }() + case .field394?: try { + guard case .field394(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 394) + }() + case .field395?: try { + guard case .field395(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 395) + }() + case .field396?: try { + guard case .field396(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 396) + }() + case .field397?: try { + guard case .field397(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 397) + }() + case .field398?: try { + guard case .field398(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 398) + }() + case .field399?: try { + guard case .field399(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 399) + }() + case .field300?: try { + guard case .field300(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 400) + }() + case .field401?: try { + guard case .field401(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 401) + }() + case .field402?: try { + guard case .field402(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 402) + }() + case .field403?: try { + guard case .field403(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 403) + }() + case .field404?: try { + guard case .field404(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 404) + }() + case .field405?: try { + guard case .field405(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 405) + }() + case .field406?: try { + guard case .field406(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 406) + }() + case .field407?: try { + guard case .field407(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 407) + }() + case .field408?: try { + guard case .field408(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 408) + }() + case .field409?: try { + guard case .field409(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 409) + }() + case .field410?: try { + guard case .field410(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 410) + }() + case .field411?: try { + guard case .field411(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 411) + }() + case .field412?: try { + guard case .field412(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 412) + }() + case .field413?: try { + guard case .field413(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 413) + }() + case .field414?: try { + guard case .field414(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 414) + }() + case .field415?: try { + guard case .field415(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 415) + }() + case .field416?: try { + guard case .field416(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 416) + }() + case .field417?: try { + guard case .field417(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 417) + }() + case .field418?: try { + guard case .field418(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 418) + }() + case .field419?: try { + guard case .field419(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 419) + }() + case .field420?: try { + guard case .field420(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 420) + }() + case .field421?: try { + guard case .field421(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 421) + }() + case .field422?: try { + guard case .field422(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 422) + }() + case .field423?: try { + guard case .field423(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 423) + }() + case .field424?: try { + guard case .field424(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 424) + }() + case .field425?: try { + guard case .field425(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 425) + }() + case .field426?: try { + guard case .field426(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 426) + }() + case .field427?: try { + guard case .field427(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 427) + }() + case .field428?: try { + guard case .field428(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 428) + }() + case .field429?: try { + guard case .field429(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 429) + }() + case .field430?: try { + guard case .field430(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 430) + }() + case .field431?: try { + guard case .field431(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 431) + }() + case .field432?: try { + guard case .field432(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 432) + }() + case .field433?: try { + guard case .field433(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 433) + }() + case .field434?: try { + guard case .field434(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 434) + }() + case .field435?: try { + guard case .field435(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 435) + }() + case .field436?: try { + guard case .field436(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 436) + }() + case .field437?: try { + guard case .field437(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 437) + }() + case .field438?: try { + guard case .field438(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 438) + }() + case .field439?: try { + guard case .field439(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 439) + }() + case .field440?: try { + guard case .field440(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 440) + }() + case .field441?: try { + guard case .field441(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 441) + }() + case .field442?: try { + guard case .field442(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 442) + }() + case .field443?: try { + guard case .field443(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 443) + }() + case .field444?: try { + guard case .field444(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 444) + }() + case .field445?: try { + guard case .field445(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 445) + }() + case .field446?: try { + guard case .field446(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 446) + }() + case .field447?: try { + guard case .field447(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 447) + }() + case .field448?: try { + guard case .field448(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 448) + }() + case .field449?: try { + guard case .field449(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 449) + }() + case .field450?: try { + guard case .field450(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 450) + }() + case .field451?: try { + guard case .field451(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 451) + }() + case .field452?: try { + guard case .field452(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 452) + }() + case .field453?: try { + guard case .field453(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 453) + }() + case .field454?: try { + guard case .field454(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 454) + }() + case .field455?: try { + guard case .field455(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 455) + }() + case .field456?: try { + guard case .field456(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 456) + }() + case .field457?: try { + guard case .field457(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 457) + }() + case .field458?: try { + guard case .field458(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 458) + }() + case .field459?: try { + guard case .field459(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 459) + }() + case .field460?: try { + guard case .field460(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 460) + }() + case .field461?: try { + guard case .field461(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 461) + }() + case .field462?: try { + guard case .field462(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 462) + }() + case .field463?: try { + guard case .field463(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 463) + }() + case .field464?: try { + guard case .field464(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 464) + }() + case .field465?: try { + guard case .field465(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 465) + }() + case .field466?: try { + guard case .field466(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 466) + }() + case .field467?: try { + guard case .field467(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 467) + }() + case .field468?: try { + guard case .field468(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 468) + }() + case .field469?: try { + guard case .field469(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 469) + }() + case .field470?: try { + guard case .field470(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 470) + }() + case .field471?: try { + guard case .field471(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 471) + }() + case .field472?: try { + guard case .field472(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 472) + }() + case .field473?: try { + guard case .field473(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 473) + }() + case .field474?: try { + guard case .field474(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 474) + }() + case .field475?: try { + guard case .field475(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 475) + }() + case .field476?: try { + guard case .field476(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 476) + }() + case .field477?: try { + guard case .field477(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 477) + }() + case .field478?: try { + guard case .field478(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 478) + }() + case .field479?: try { + guard case .field479(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 479) + }() + case .field480?: try { + guard case .field480(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 480) + }() + case .field481?: try { + guard case .field481(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 481) + }() + case .field482?: try { + guard case .field482(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 482) + }() + case .field483?: try { + guard case .field483(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 483) + }() + case .field484?: try { + guard case .field484(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 484) + }() + case .field485?: try { + guard case .field485(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 485) + }() + case .field486?: try { + guard case .field486(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 486) + }() + case .field487?: try { + guard case .field487(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 487) + }() + case .field488?: try { + guard case .field488(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 488) + }() + case .field489?: try { + guard case .field489(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 489) + }() + case .field490?: try { + guard case .field490(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 490) + }() + case .field491?: try { + guard case .field491(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 491) + }() + case .field492?: try { + guard case .field492(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 492) + }() + case .field493?: try { + guard case .field493(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 493) + }() + case .field494?: try { + guard case .field494(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 494) + }() + case .field495?: try { + guard case .field495(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 495) + }() + case .field496?: try { + guard case .field496(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 496) + }() + case .field497?: try { + guard case .field497(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 497) + }() + case .field498?: try { + guard case .field498(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 498) + }() + case .field499?: try { + guard case .field499(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 499) + }() + case .field500?: try { + guard case .field500(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 500) + }() + case .field501?: try { + guard case .field501(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 501) + }() + default: break + } + try { if let v = self._regularField502 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 502) + } }() + switch self.value { + case .field503?: try { + guard case .field503(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 503) + }() + case .field504?: try { + guard case .field504(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 504) + }() + case .field505?: try { + guard case .field505(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 505) + }() + case .field506?: try { + guard case .field506(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 506) + }() + case .field507?: try { + guard case .field507(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 507) + }() + case .field508?: try { + guard case .field508(let v)? = self.value else { preconditionFailure() } + try visitor.visitSingularInt32Field(value: v, fieldNumber: 508) + }() + default: break + } + try { if let v = self._regularField509 { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 509) + } }() + try { if case .field510(let v)? = self.value { + try visitor.visitSingularInt32Field(value: v, fieldNumber: 510) + } }() + try unknownFields.traverse(visitor: &visitor) + } + + static func ==(lhs: SwiftProtoTesting_SwitchSplit_SwitchSplitMessage, rhs: SwiftProtoTesting_SwitchSplit_SwitchSplitMessage) -> Bool { + if lhs._regularField002 != rhs._regularField002 {return false} + if lhs._regularField251 != rhs._regularField251 {return false} + if lhs._regularField502 != rhs._regularField502 {return false} + if lhs._regularField509 != rhs._regularField509 {return false} + if lhs.value != rhs.value {return false} + if lhs.unknownFields != rhs.unknownFields {return false} + return true + } +} diff --git a/Tests/SwiftProtobufTests/unittest_swift_performance.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_performance.pb.swift deleted file mode 100644 index 2609e2597..000000000 --- a/Tests/SwiftProtobufTests/unittest_swift_performance.pb.swift +++ /dev/null @@ -1,546 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: unittest_swift_performance.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -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 Swift_Performance_TestAllTypes { - // 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. - - /// One of every singular field type - var optionalInt32: Int32 { - get {return _storage._optionalInt32} - set {_uniqueStorage()._optionalInt32 = newValue} - } - - var optionalInt64: Int64 { - get {return _storage._optionalInt64} - set {_uniqueStorage()._optionalInt64 = newValue} - } - - var optionalUint32: UInt32 { - get {return _storage._optionalUint32} - set {_uniqueStorage()._optionalUint32 = newValue} - } - - var optionalUint64: UInt64 { - get {return _storage._optionalUint64} - set {_uniqueStorage()._optionalUint64 = newValue} - } - - var optionalSint32: Int32 { - get {return _storage._optionalSint32} - set {_uniqueStorage()._optionalSint32 = newValue} - } - - var optionalSint64: Int64 { - get {return _storage._optionalSint64} - set {_uniqueStorage()._optionalSint64 = newValue} - } - - var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32} - set {_uniqueStorage()._optionalFixed32 = newValue} - } - - var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64} - set {_uniqueStorage()._optionalFixed64 = newValue} - } - - var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32} - set {_uniqueStorage()._optionalSfixed32 = newValue} - } - - var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64} - set {_uniqueStorage()._optionalSfixed64 = newValue} - } - - var optionalFloat: Float { - get {return _storage._optionalFloat} - set {_uniqueStorage()._optionalFloat = newValue} - } - - var optionalDouble: Double { - get {return _storage._optionalDouble} - set {_uniqueStorage()._optionalDouble = newValue} - } - - var optionalBool: Bool { - get {return _storage._optionalBool} - set {_uniqueStorage()._optionalBool = newValue} - } - - var optionalString: String { - get {return _storage._optionalString} - set {_uniqueStorage()._optionalString = newValue} - } - - var optionalBytes: Data { - get {return _storage._optionalBytes} - set {_uniqueStorage()._optionalBytes = newValue} - } - - var repeatedRecursiveMessage: [Swift_Performance_TestAllTypes] { - get {return _storage._repeatedRecursiveMessage} - set {_uniqueStorage()._repeatedRecursiveMessage = newValue} - } - - /// Repeated - var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} - set {_uniqueStorage()._repeatedInt32 = newValue} - } - - var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} - set {_uniqueStorage()._repeatedInt64 = newValue} - } - - var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} - set {_uniqueStorage()._repeatedUint32 = newValue} - } - - var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} - set {_uniqueStorage()._repeatedUint64 = newValue} - } - - var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} - set {_uniqueStorage()._repeatedSint32 = newValue} - } - - var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} - set {_uniqueStorage()._repeatedSint64 = newValue} - } - - var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} - set {_uniqueStorage()._repeatedFixed32 = newValue} - } - - var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} - set {_uniqueStorage()._repeatedFixed64 = newValue} - } - - var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} - set {_uniqueStorage()._repeatedSfixed32 = newValue} - } - - var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} - set {_uniqueStorage()._repeatedSfixed64 = newValue} - } - - var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} - set {_uniqueStorage()._repeatedFloat = newValue} - } - - var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} - set {_uniqueStorage()._repeatedDouble = newValue} - } - - var repeatedBool: [Bool] { - get {return _storage._repeatedBool} - set {_uniqueStorage()._repeatedBool = newValue} - } - - var repeatedString: [String] { - get {return _storage._repeatedString} - set {_uniqueStorage()._repeatedString = newValue} - } - - var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} - set {_uniqueStorage()._repeatedBytes = newValue} - } - - /// Map - var mapStringMessage: Dictionary { - get {return _storage._mapStringMessage} - set {_uniqueStorage()._mapStringMessage = newValue} - } - - var unknownFields = SwiftProtobuf.UnknownStorage() - - init() {} - - fileprivate var _storage = _StorageClass.defaultInstance -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension Swift_Performance_TestAllTypes: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "swift.performance" - -extension Swift_Performance_TestAllTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestAllTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 27: .standard(proto: "repeated_recursive_message"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 71: .standard(proto: "map_string_message"), - ] - - fileprivate class _StorageClass { - var _optionalInt32: Int32 = 0 - var _optionalInt64: Int64 = 0 - var _optionalUint32: UInt32 = 0 - var _optionalUint64: UInt64 = 0 - var _optionalSint32: Int32 = 0 - var _optionalSint64: Int64 = 0 - var _optionalFixed32: UInt32 = 0 - var _optionalFixed64: UInt64 = 0 - var _optionalSfixed32: Int32 = 0 - var _optionalSfixed64: Int64 = 0 - var _optionalFloat: Float = 0 - var _optionalDouble: Double = 0 - var _optionalBool: Bool = false - var _optionalString: String = String() - var _optionalBytes: Data = Data() - var _repeatedRecursiveMessage: [Swift_Performance_TestAllTypes] = [] - var _repeatedInt32: [Int32] = [] - var _repeatedInt64: [Int64] = [] - var _repeatedUint32: [UInt32] = [] - var _repeatedUint64: [UInt64] = [] - var _repeatedSint32: [Int32] = [] - var _repeatedSint64: [Int64] = [] - var _repeatedFixed32: [UInt32] = [] - var _repeatedFixed64: [UInt64] = [] - var _repeatedSfixed32: [Int32] = [] - var _repeatedSfixed64: [Int64] = [] - var _repeatedFloat: [Float] = [] - var _repeatedDouble: [Double] = [] - var _repeatedBool: [Bool] = [] - var _repeatedString: [String] = [] - var _repeatedBytes: [Data] = [] - var _mapStringMessage: Dictionary = [:] - - static let defaultInstance = _StorageClass() - - private init() {} - - init(copying source: _StorageClass) { - _optionalInt32 = source._optionalInt32 - _optionalInt64 = source._optionalInt64 - _optionalUint32 = source._optionalUint32 - _optionalUint64 = source._optionalUint64 - _optionalSint32 = source._optionalSint32 - _optionalSint64 = source._optionalSint64 - _optionalFixed32 = source._optionalFixed32 - _optionalFixed64 = source._optionalFixed64 - _optionalSfixed32 = source._optionalSfixed32 - _optionalSfixed64 = source._optionalSfixed64 - _optionalFloat = source._optionalFloat - _optionalDouble = source._optionalDouble - _optionalBool = source._optionalBool - _optionalString = source._optionalString - _optionalBytes = source._optionalBytes - _repeatedRecursiveMessage = source._repeatedRecursiveMessage - _repeatedInt32 = source._repeatedInt32 - _repeatedInt64 = source._repeatedInt64 - _repeatedUint32 = source._repeatedUint32 - _repeatedUint64 = source._repeatedUint64 - _repeatedSint32 = source._repeatedSint32 - _repeatedSint64 = source._repeatedSint64 - _repeatedFixed32 = source._repeatedFixed32 - _repeatedFixed64 = source._repeatedFixed64 - _repeatedSfixed32 = source._repeatedSfixed32 - _repeatedSfixed64 = source._repeatedSfixed64 - _repeatedFloat = source._repeatedFloat - _repeatedDouble = source._repeatedDouble - _repeatedBool = source._repeatedBool - _repeatedString = source._repeatedString - _repeatedBytes = source._repeatedBytes - _mapStringMessage = source._mapStringMessage - } - } - - fileprivate mutating func _uniqueStorage() -> _StorageClass { - if !isKnownUniquelyReferenced(&_storage) { - _storage = _StorageClass(copying: _storage) - } - return _storage - } - - mutating func decodeMessage(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._optionalInt32) }() - case 2: try { try decoder.decodeSingularInt64Field(value: &_storage._optionalInt64) }() - case 3: try { try decoder.decodeSingularUInt32Field(value: &_storage._optionalUint32) }() - case 4: try { try decoder.decodeSingularUInt64Field(value: &_storage._optionalUint64) }() - case 5: try { try decoder.decodeSingularSInt32Field(value: &_storage._optionalSint32) }() - case 6: try { try decoder.decodeSingularSInt64Field(value: &_storage._optionalSint64) }() - case 7: try { try decoder.decodeSingularFixed32Field(value: &_storage._optionalFixed32) }() - case 8: try { try decoder.decodeSingularFixed64Field(value: &_storage._optionalFixed64) }() - case 9: try { try decoder.decodeSingularSFixed32Field(value: &_storage._optionalSfixed32) }() - case 10: try { try decoder.decodeSingularSFixed64Field(value: &_storage._optionalSfixed64) }() - case 11: try { try decoder.decodeSingularFloatField(value: &_storage._optionalFloat) }() - case 12: try { try decoder.decodeSingularDoubleField(value: &_storage._optionalDouble) }() - case 13: try { try decoder.decodeSingularBoolField(value: &_storage._optionalBool) }() - case 14: try { try decoder.decodeSingularStringField(value: &_storage._optionalString) }() - case 15: try { try decoder.decodeSingularBytesField(value: &_storage._optionalBytes) }() - case 27: try { try decoder.decodeRepeatedMessageField(value: &_storage._repeatedRecursiveMessage) }() - case 31: try { try decoder.decodeRepeatedInt32Field(value: &_storage._repeatedInt32) }() - case 32: try { try decoder.decodeRepeatedInt64Field(value: &_storage._repeatedInt64) }() - case 33: try { try decoder.decodeRepeatedUInt32Field(value: &_storage._repeatedUint32) }() - case 34: try { try decoder.decodeRepeatedUInt64Field(value: &_storage._repeatedUint64) }() - case 35: try { try decoder.decodeRepeatedSInt32Field(value: &_storage._repeatedSint32) }() - case 36: try { try decoder.decodeRepeatedSInt64Field(value: &_storage._repeatedSint64) }() - case 37: try { try decoder.decodeRepeatedFixed32Field(value: &_storage._repeatedFixed32) }() - case 38: try { try decoder.decodeRepeatedFixed64Field(value: &_storage._repeatedFixed64) }() - case 39: try { try decoder.decodeRepeatedSFixed32Field(value: &_storage._repeatedSfixed32) }() - case 40: try { try decoder.decodeRepeatedSFixed64Field(value: &_storage._repeatedSfixed64) }() - case 41: try { try decoder.decodeRepeatedFloatField(value: &_storage._repeatedFloat) }() - case 42: try { try decoder.decodeRepeatedDoubleField(value: &_storage._repeatedDouble) }() - case 43: try { try decoder.decodeRepeatedBoolField(value: &_storage._repeatedBool) }() - case 44: try { try decoder.decodeRepeatedStringField(value: &_storage._repeatedString) }() - case 45: try { try decoder.decodeRepeatedBytesField(value: &_storage._repeatedBytes) }() - case 71: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringMessage) }() - default: break - } - } - } - } - - func traverse(visitor: inout V) throws { - try withExtendedLifetime(_storage) { (_storage: _StorageClass) in - if _storage._optionalInt32 != 0 { - try visitor.visitSingularInt32Field(value: _storage._optionalInt32, fieldNumber: 1) - } - if _storage._optionalInt64 != 0 { - try visitor.visitSingularInt64Field(value: _storage._optionalInt64, fieldNumber: 2) - } - if _storage._optionalUint32 != 0 { - try visitor.visitSingularUInt32Field(value: _storage._optionalUint32, fieldNumber: 3) - } - if _storage._optionalUint64 != 0 { - try visitor.visitSingularUInt64Field(value: _storage._optionalUint64, fieldNumber: 4) - } - if _storage._optionalSint32 != 0 { - try visitor.visitSingularSInt32Field(value: _storage._optionalSint32, fieldNumber: 5) - } - if _storage._optionalSint64 != 0 { - try visitor.visitSingularSInt64Field(value: _storage._optionalSint64, fieldNumber: 6) - } - if _storage._optionalFixed32 != 0 { - try visitor.visitSingularFixed32Field(value: _storage._optionalFixed32, fieldNumber: 7) - } - if _storage._optionalFixed64 != 0 { - try visitor.visitSingularFixed64Field(value: _storage._optionalFixed64, fieldNumber: 8) - } - if _storage._optionalSfixed32 != 0 { - try visitor.visitSingularSFixed32Field(value: _storage._optionalSfixed32, fieldNumber: 9) - } - if _storage._optionalSfixed64 != 0 { - try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) - } - if _storage._optionalFloat != 0 { - try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) - } - if _storage._optionalDouble != 0 { - try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) - } - if _storage._optionalBool != false { - try visitor.visitSingularBoolField(value: _storage._optionalBool, fieldNumber: 13) - } - if !_storage._optionalString.isEmpty { - try visitor.visitSingularStringField(value: _storage._optionalString, fieldNumber: 14) - } - if !_storage._optionalBytes.isEmpty { - try visitor.visitSingularBytesField(value: _storage._optionalBytes, fieldNumber: 15) - } - if !_storage._repeatedRecursiveMessage.isEmpty { - try visitor.visitRepeatedMessageField(value: _storage._repeatedRecursiveMessage, fieldNumber: 27) - } - if !_storage._repeatedInt32.isEmpty { - try visitor.visitPackedInt32Field(value: _storage._repeatedInt32, fieldNumber: 31) - } - if !_storage._repeatedInt64.isEmpty { - try visitor.visitPackedInt64Field(value: _storage._repeatedInt64, fieldNumber: 32) - } - if !_storage._repeatedUint32.isEmpty { - try visitor.visitPackedUInt32Field(value: _storage._repeatedUint32, fieldNumber: 33) - } - if !_storage._repeatedUint64.isEmpty { - try visitor.visitPackedUInt64Field(value: _storage._repeatedUint64, fieldNumber: 34) - } - if !_storage._repeatedSint32.isEmpty { - try visitor.visitPackedSInt32Field(value: _storage._repeatedSint32, fieldNumber: 35) - } - if !_storage._repeatedSint64.isEmpty { - try visitor.visitPackedSInt64Field(value: _storage._repeatedSint64, fieldNumber: 36) - } - if !_storage._repeatedFixed32.isEmpty { - try visitor.visitPackedFixed32Field(value: _storage._repeatedFixed32, fieldNumber: 37) - } - if !_storage._repeatedFixed64.isEmpty { - try visitor.visitPackedFixed64Field(value: _storage._repeatedFixed64, fieldNumber: 38) - } - if !_storage._repeatedSfixed32.isEmpty { - try visitor.visitPackedSFixed32Field(value: _storage._repeatedSfixed32, fieldNumber: 39) - } - if !_storage._repeatedSfixed64.isEmpty { - try visitor.visitPackedSFixed64Field(value: _storage._repeatedSfixed64, fieldNumber: 40) - } - if !_storage._repeatedFloat.isEmpty { - try visitor.visitPackedFloatField(value: _storage._repeatedFloat, fieldNumber: 41) - } - if !_storage._repeatedDouble.isEmpty { - try visitor.visitPackedDoubleField(value: _storage._repeatedDouble, fieldNumber: 42) - } - if !_storage._repeatedBool.isEmpty { - try visitor.visitPackedBoolField(value: _storage._repeatedBool, fieldNumber: 43) - } - if !_storage._repeatedString.isEmpty { - try visitor.visitRepeatedStringField(value: _storage._repeatedString, fieldNumber: 44) - } - if !_storage._repeatedBytes.isEmpty { - try visitor.visitRepeatedBytesField(value: _storage._repeatedBytes, fieldNumber: 45) - } - if !_storage._mapStringMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringMessage, fieldNumber: 71) - } - } - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: Swift_Performance_TestAllTypes, rhs: Swift_Performance_TestAllTypes) -> 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._optionalInt32 != rhs_storage._optionalInt32 {return false} - if _storage._optionalInt64 != rhs_storage._optionalInt64 {return false} - if _storage._optionalUint32 != rhs_storage._optionalUint32 {return false} - if _storage._optionalUint64 != rhs_storage._optionalUint64 {return false} - if _storage._optionalSint32 != rhs_storage._optionalSint32 {return false} - if _storage._optionalSint64 != rhs_storage._optionalSint64 {return false} - if _storage._optionalFixed32 != rhs_storage._optionalFixed32 {return false} - if _storage._optionalFixed64 != rhs_storage._optionalFixed64 {return false} - if _storage._optionalSfixed32 != rhs_storage._optionalSfixed32 {return false} - if _storage._optionalSfixed64 != rhs_storage._optionalSfixed64 {return false} - if _storage._optionalFloat != rhs_storage._optionalFloat {return false} - if _storage._optionalDouble != rhs_storage._optionalDouble {return false} - if _storage._optionalBool != rhs_storage._optionalBool {return false} - if _storage._optionalString != rhs_storage._optionalString {return false} - if _storage._optionalBytes != rhs_storage._optionalBytes {return false} - if _storage._repeatedRecursiveMessage != rhs_storage._repeatedRecursiveMessage {return false} - if _storage._repeatedInt32 != rhs_storage._repeatedInt32 {return false} - if _storage._repeatedInt64 != rhs_storage._repeatedInt64 {return false} - if _storage._repeatedUint32 != rhs_storage._repeatedUint32 {return false} - if _storage._repeatedUint64 != rhs_storage._repeatedUint64 {return false} - if _storage._repeatedSint32 != rhs_storage._repeatedSint32 {return false} - if _storage._repeatedSint64 != rhs_storage._repeatedSint64 {return false} - if _storage._repeatedFixed32 != rhs_storage._repeatedFixed32 {return false} - if _storage._repeatedFixed64 != rhs_storage._repeatedFixed64 {return false} - if _storage._repeatedSfixed32 != rhs_storage._repeatedSfixed32 {return false} - if _storage._repeatedSfixed64 != rhs_storage._repeatedSfixed64 {return false} - if _storage._repeatedFloat != rhs_storage._repeatedFloat {return false} - if _storage._repeatedDouble != rhs_storage._repeatedDouble {return false} - if _storage._repeatedBool != rhs_storage._repeatedBool {return false} - if _storage._repeatedString != rhs_storage._repeatedString {return false} - if _storage._repeatedBytes != rhs_storage._repeatedBytes {return false} - if _storage._mapStringMessage != rhs_storage._mapStringMessage {return false} - return true - } - if !storagesAreEqual {return false} - } - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Tests/SwiftProtobufTests/unittest_swift_reserved.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_reserved.pb.swift index 5e081f63b..ec473cedf 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_reserved.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_reserved.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_reserved.proto @@ -23,7 +24,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -36,150 +36,112 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_SwiftReservedTest { +struct SwiftProtoTesting_SwiftReservedTest: Sendable { // 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. /// static r/o properties on Message, ensure they still work as fields. var protoMessageName: Int32 { - get {return _protoMessageName ?? 0} + get {_protoMessageName ?? 0} set {_protoMessageName = newValue} } /// Returns true if `protoMessageName` has been explicitly set. - var hasProtoMessageName: Bool {return self._protoMessageName != nil} + var hasProtoMessageName: Bool {self._protoMessageName != nil} /// Clears the value of `protoMessageName`. Subsequent reads from it will return its default value. mutating func clearProtoMessageName() {self._protoMessageName = nil} var protoPackageName: Int32 { - get {return _protoPackageName ?? 0} + get {_protoPackageName ?? 0} set {_protoPackageName = newValue} } /// Returns true if `protoPackageName` has been explicitly set. - var hasProtoPackageName: Bool {return self._protoPackageName != nil} + var hasProtoPackageName: Bool {self._protoPackageName != nil} /// Clears the value of `protoPackageName`. Subsequent reads from it will return its default value. mutating func clearProtoPackageName() {self._protoPackageName = nil} var anyTypePrefix: Int32 { - get {return _anyTypePrefix ?? 0} + get {_anyTypePrefix ?? 0} set {_anyTypePrefix = newValue} } /// Returns true if `anyTypePrefix` has been explicitly set. - var hasAnyTypePrefix: Bool {return self._anyTypePrefix != nil} + var hasAnyTypePrefix: Bool {self._anyTypePrefix != nil} /// Clears the value of `anyTypePrefix`. Subsequent reads from it will return its default value. mutating func clearAnyTypePrefix() {self._anyTypePrefix = nil} var anyTypeURL: Int32 { - get {return _anyTypeURL ?? 0} + get {_anyTypeURL ?? 0} set {_anyTypeURL = newValue} } /// Returns true if `anyTypeURL` has been explicitly set. - var hasAnyTypeURL: Bool {return self._anyTypeURL != nil} + var hasAnyTypeURL: Bool {self._anyTypeURL != nil} /// Clears the value of `anyTypeURL`. Subsequent reads from it will return its default value. mutating func clearAnyTypeURL() {self._anyTypeURL = nil} /// r/o properties on Message, ensure it gets remapped. var isInitialized_p: String { - get {return _isInitialized_p ?? String()} + get {_isInitialized_p ?? String()} set {_isInitialized_p = newValue} } /// Returns true if `isInitialized_p` has been explicitly set. - var hasIsInitialized_p: Bool {return self._isInitialized_p != nil} + var hasIsInitialized_p: Bool {self._isInitialized_p != nil} /// Clears the value of `isInitialized_p`. Subsequent reads from it will return its default value. mutating func clearIsInitialized_p() {self._isInitialized_p = nil} var hashValue_p: String { - get {return _hashValue_p ?? String()} + get {_hashValue_p ?? String()} set {_hashValue_p = newValue} } /// Returns true if `hashValue_p` has been explicitly set. - var hasHashValue_p: Bool {return self._hashValue_p != nil} + var hasHashValue_p: Bool {self._hashValue_p != nil} /// Clears the value of `hashValue_p`. Subsequent reads from it will return its default value. mutating func clearHashValue_p() {self._hashValue_p = nil} var debugDescription_p: Int32 { - get {return _debugDescription_p ?? 0} + get {_debugDescription_p ?? 0} set {_debugDescription_p = newValue} } /// Returns true if `debugDescription_p` has been explicitly set. - var hasDebugDescription_p: Bool {return self._debugDescription_p != nil} + var hasDebugDescription_p: Bool {self._debugDescription_p != nil} /// Clears the value of `debugDescription_p`. Subsequent reads from it will return its default value. mutating func clearDebugDescription_p() {self._debugDescription_p = nil} /// Prompt code generator to build an 'isInitialized' test var requiredInt: Int32 { - get {return _requiredInt ?? 0} + get {_requiredInt ?? 0} set {_requiredInt = newValue} } /// Returns true if `requiredInt` has been explicitly set. - var hasRequiredInt: Bool {return self._requiredInt != nil} + var hasRequiredInt: Bool {self._requiredInt != nil} /// Clears the value of `requiredInt`. Subsequent reads from it will return its default value. mutating func clearRequiredInt() {self._requiredInt = nil} var unknownFields = SwiftProtobuf.UnknownStorage() - enum Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case double // = 1 - case json // = 2 - case `class` // = 3 - case ___ // = 4 - case self_ // = 5 - case type // = 6 + enum Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case double = 1 + case json = 2 + case `class` = 3 + case ___ = 4 + case self_ = 5 + case type = 6 init() { self = .double } - init?(rawValue: Int) { - switch rawValue { - case 1: self = .double - case 2: self = .json - case 3: self = .class - case 4: self = .___ - case 5: self = .self_ - case 6: self = .type - default: return nil - } - } - - var rawValue: Int { - switch self { - case .double: return 1 - case .json: return 2 - case .class: return 3 - case .___: return 4 - case .self_: return 5 - case .type: return 6 - } - } - } - enum ProtocolEnum: SwiftProtobuf.Enum { - typealias RawValue = Int - case a // = 1 + enum ProtocolEnum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case a = 1 init() { self = .a } - init?(rawValue: Int) { - switch rawValue { - case 1: self = .a - default: return nil - } - } - - var rawValue: Int { - switch self { - case .a: return 1 - } - } - } - struct classMessage: SwiftProtobuf.ExtensibleMessage { + struct classMessage: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -191,7 +153,7 @@ struct ProtobufUnittest_SwiftReservedTest { var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } - struct TypeMessage: SwiftProtobuf.ExtensibleMessage { + struct TypeMessage: SwiftProtobuf.ExtensibleMessage, Sendable { // 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. @@ -203,7 +165,7 @@ struct ProtobufUnittest_SwiftReservedTest { var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet() } - struct isEqual { + struct isEqual: Sendable { // 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. @@ -225,19 +187,7 @@ struct ProtobufUnittest_SwiftReservedTest { fileprivate var _requiredInt: Int32? = nil } -#if swift(>=4.2) - -extension ProtobufUnittest_SwiftReservedTest.Enum: CaseIterable { - // Support synthesized by the compiler. -} - -extension ProtobufUnittest_SwiftReservedTest.ProtocolEnum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_SwiftReservedTestExt { +struct SwiftProtoTesting_SwiftReservedTestExt: Sendable { // 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. @@ -247,236 +197,226 @@ struct ProtobufUnittest_SwiftReservedTestExt { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_SwiftReservedTest: @unchecked Sendable {} -extension ProtobufUnittest_SwiftReservedTest.Enum: @unchecked Sendable {} -extension ProtobufUnittest_SwiftReservedTest.ProtocolEnum: @unchecked Sendable {} -extension ProtobufUnittest_SwiftReservedTest.classMessage: @unchecked Sendable {} -extension ProtobufUnittest_SwiftReservedTest.TypeMessage: @unchecked Sendable {} -extension ProtobufUnittest_SwiftReservedTest.isEqual: @unchecked Sendable {} -extension ProtobufUnittest_SwiftReservedTestExt: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_reserved.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 ProtobufUnittest_SwiftReservedTest.classMessage { +extension SwiftProtoTesting_SwiftReservedTest.classMessage { /// Won't get _p added because it is fully qualified. - var ProtobufUnittest_debugDescription: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_debug_description) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_debug_description, value: newValue)} + var SwiftProtoTesting_debugDescription: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_debug_description) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_debug_description, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extensions_debug_description` + /// Returns true if extension `SwiftProtoTesting_Extensions_debug_description` /// has been explicitly set. - var hasProtobufUnittest_debugDescription: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_debug_description) + var hasSwiftProtoTesting_debugDescription: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_debug_description) } - /// Clears the value of extension `ProtobufUnittest_Extensions_debug_description`. + /// Clears the value of extension `SwiftProtoTesting_Extensions_debug_description`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_debugDescription() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_debug_description) + mutating func clearSwiftProtoTesting_debugDescription() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_debug_description) } /// These are scoped to the file, so the package prefix (or a Swift prefix) /// will get added to them to they aren't going to get renamed. - var ProtobufUnittest_as: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_as) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_as, value: newValue)} + var SwiftProtoTesting_as: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_as) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_as, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extensions_as` + /// Returns true if extension `SwiftProtoTesting_Extensions_as` /// has been explicitly set. - var hasProtobufUnittest_as: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_as) + var hasSwiftProtoTesting_as: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_as) } - /// Clears the value of extension `ProtobufUnittest_Extensions_as`. + /// Clears the value of extension `SwiftProtoTesting_Extensions_as`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_as() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_as) + mutating func clearSwiftProtoTesting_as() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_as) } - var ProtobufUnittest_var: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_var) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_var, value: newValue)} + var SwiftProtoTesting_var: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_var) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_var, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extensions_var` + /// Returns true if extension `SwiftProtoTesting_Extensions_var` /// has been explicitly set. - var hasProtobufUnittest_var: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_var) + var hasSwiftProtoTesting_var: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_var) } - /// Clears the value of extension `ProtobufUnittest_Extensions_var`. + /// Clears the value of extension `SwiftProtoTesting_Extensions_var`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_var() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_var) + mutating func clearSwiftProtoTesting_var() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_var) } - var ProtobufUnittest_try: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_try) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_try, value: newValue)} + var SwiftProtoTesting_try: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_try) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_try, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extensions_try` + /// Returns true if extension `SwiftProtoTesting_Extensions_try` /// has been explicitly set. - var hasProtobufUnittest_try: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_try) + var hasSwiftProtoTesting_try: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_try) } - /// Clears the value of extension `ProtobufUnittest_Extensions_try`. + /// Clears the value of extension `SwiftProtoTesting_Extensions_try`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_try() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_try) + mutating func clearSwiftProtoTesting_try() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_try) } - var ProtobufUnittest_do: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_do) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_do, value: newValue)} + var SwiftProtoTesting_do: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_do) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_do, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extensions_do` + /// Returns true if extension `SwiftProtoTesting_Extensions_do` /// has been explicitly set. - var hasProtobufUnittest_do: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_do) + var hasSwiftProtoTesting_do: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_do) } - /// Clears the value of extension `ProtobufUnittest_Extensions_do`. + /// Clears the value of extension `SwiftProtoTesting_Extensions_do`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_do() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_do) + mutating func clearSwiftProtoTesting_do() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_do) } - var ProtobufUnittest_nil: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_Extensions_nil) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_Extensions_nil, value: newValue)} + var SwiftProtoTesting_nil: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_Extensions_nil) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_Extensions_nil, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_Extensions_nil` + /// Returns true if extension `SwiftProtoTesting_Extensions_nil` /// has been explicitly set. - var hasProtobufUnittest_nil: Bool { - return hasExtensionValue(ext: ProtobufUnittest_Extensions_nil) + var hasSwiftProtoTesting_nil: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_Extensions_nil) } - /// Clears the value of extension `ProtobufUnittest_Extensions_nil`. + /// Clears the value of extension `SwiftProtoTesting_Extensions_nil`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_nil() { - clearExtensionValue(ext: ProtobufUnittest_Extensions_nil) + mutating func clearSwiftProtoTesting_nil() { + clearExtensionValue(ext: SwiftProtoTesting_Extensions_nil) } /// This will end up in the "enum Extensions" to scope it, but there /// the raw form is used ("hash_value", not the Swift one "hashValue"), /// so there is no conflict, and no renaming happens. - var ProtobufUnittest_SwiftReservedTestExt_hashValue: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.hash_value) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.hash_value, value: newValue)} + var SwiftProtoTesting_SwiftReservedTestExt_hashValue: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.hash_value) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.hash_value, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.hash_value` + /// Returns true if extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.hash_value` /// has been explicitly set. - var hasProtobufUnittest_SwiftReservedTestExt_hashValue: Bool { - return hasExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.hash_value) + var hasSwiftProtoTesting_SwiftReservedTestExt_hashValue: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.hash_value) } - /// Clears the value of extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.hash_value`. + /// Clears the value of extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.hash_value`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_SwiftReservedTestExt_hashValue() { - clearExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.hash_value) + mutating func clearSwiftProtoTesting_SwiftReservedTestExt_hashValue() { + clearExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.hash_value) } /// Reserved words, since these end up in the "struct Extensions", they /// can't just be get their names, and sanitation kicks. - var ProtobufUnittest_SwiftReservedTestExt_as: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.as) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.as, value: newValue)} + var SwiftProtoTesting_SwiftReservedTestExt_as: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.as) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.as, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.as` + /// Returns true if extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.as` /// has been explicitly set. - var hasProtobufUnittest_SwiftReservedTestExt_as: Bool { - return hasExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.as) + var hasSwiftProtoTesting_SwiftReservedTestExt_as: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.as) } - /// Clears the value of extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.as`. + /// Clears the value of extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.as`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_SwiftReservedTestExt_as() { - clearExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.as) + mutating func clearSwiftProtoTesting_SwiftReservedTestExt_as() { + clearExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.as) } - var ProtobufUnittest_SwiftReservedTestExt_var: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.var) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.var, value: newValue)} + var SwiftProtoTesting_SwiftReservedTestExt_var: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.var) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.var, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.var` + /// Returns true if extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.var` /// has been explicitly set. - var hasProtobufUnittest_SwiftReservedTestExt_var: Bool { - return hasExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.var) + var hasSwiftProtoTesting_SwiftReservedTestExt_var: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.var) } - /// Clears the value of extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.var`. + /// Clears the value of extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.var`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_SwiftReservedTestExt_var() { - clearExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.var) + mutating func clearSwiftProtoTesting_SwiftReservedTestExt_var() { + clearExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.var) } - var ProtobufUnittest_SwiftReservedTestExt_try: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.try) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.try, value: newValue)} + var SwiftProtoTesting_SwiftReservedTestExt_try: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.try) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.try, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.try` + /// Returns true if extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.try` /// has been explicitly set. - var hasProtobufUnittest_SwiftReservedTestExt_try: Bool { - return hasExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.try) + var hasSwiftProtoTesting_SwiftReservedTestExt_try: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.try) } - /// Clears the value of extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.try`. + /// Clears the value of extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.try`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_SwiftReservedTestExt_try() { - clearExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.try) + mutating func clearSwiftProtoTesting_SwiftReservedTestExt_try() { + clearExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.try) } - var ProtobufUnittest_SwiftReservedTestExt_do: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.do) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.do, value: newValue)} + var SwiftProtoTesting_SwiftReservedTestExt_do: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.do) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.do, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.do` + /// Returns true if extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.do` /// has been explicitly set. - var hasProtobufUnittest_SwiftReservedTestExt_do: Bool { - return hasExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.do) + var hasSwiftProtoTesting_SwiftReservedTestExt_do: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.do) } - /// Clears the value of extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.do`. + /// Clears the value of extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.do`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_SwiftReservedTestExt_do() { - clearExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.do) + mutating func clearSwiftProtoTesting_SwiftReservedTestExt_do() { + clearExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.do) } - var ProtobufUnittest_SwiftReservedTestExt_nil: Bool { - get {return getExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.nil) ?? false} - set {setExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.nil, value: newValue)} + var SwiftProtoTesting_SwiftReservedTestExt_nil: Bool { + get {return getExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.nil) ?? false} + set {setExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.nil, value: newValue)} } - /// Returns true if extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.nil` + /// Returns true if extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.nil` /// has been explicitly set. - var hasProtobufUnittest_SwiftReservedTestExt_nil: Bool { - return hasExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.nil) + var hasSwiftProtoTesting_SwiftReservedTestExt_nil: Bool { + return hasExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.nil) } - /// Clears the value of extension `ProtobufUnittest_SwiftReservedTestExt.Extensions.nil`. + /// Clears the value of extension `SwiftProtoTesting_SwiftReservedTestExt.Extensions.nil`. /// Subsequent reads from it will return its default value. - mutating func clearProtobufUnittest_SwiftReservedTestExt_nil() { - clearExtensionValue(ext: ProtobufUnittest_SwiftReservedTestExt.Extensions.nil) + mutating func clearSwiftProtoTesting_SwiftReservedTestExt_nil() { + clearExtensionValue(ext: SwiftProtoTesting_SwiftReservedTestExt.Extensions.nil) } } -// MARK: - File's ExtensionMap: ProtobufUnittest_UnittestSwiftReserved_Extensions +// MARK: - File's ExtensionMap: SwiftProtoTesting_UnittestSwiftReserved_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 ProtobufUnittest_UnittestSwiftReserved_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufUnittest_Extensions_debug_description, - ProtobufUnittest_Extensions_as, - ProtobufUnittest_Extensions_var, - ProtobufUnittest_Extensions_try, - ProtobufUnittest_Extensions_do, - ProtobufUnittest_Extensions_nil, - ProtobufUnittest_SwiftReservedTestExt.Extensions.hash_value, - ProtobufUnittest_SwiftReservedTestExt.Extensions.as, - ProtobufUnittest_SwiftReservedTestExt.Extensions.var, - ProtobufUnittest_SwiftReservedTestExt.Extensions.try, - ProtobufUnittest_SwiftReservedTestExt.Extensions.do, - ProtobufUnittest_SwiftReservedTestExt.Extensions.nil +let SwiftProtoTesting_UnittestSwiftReserved_Extensions: SwiftProtobuf.SimpleExtensionMap = [ + SwiftProtoTesting_Extensions_debug_description, + SwiftProtoTesting_Extensions_as, + SwiftProtoTesting_Extensions_var, + SwiftProtoTesting_Extensions_try, + SwiftProtoTesting_Extensions_do, + SwiftProtoTesting_Extensions_nil, + SwiftProtoTesting_SwiftReservedTestExt.Extensions.hash_value, + SwiftProtoTesting_SwiftReservedTestExt.Extensions.as, + SwiftProtoTesting_SwiftReservedTestExt.Extensions.var, + SwiftProtoTesting_SwiftReservedTestExt.Extensions.try, + SwiftProtoTesting_SwiftReservedTestExt.Extensions.do, + SwiftProtoTesting_SwiftReservedTestExt.Extensions.nil ] // Extension Objects - The only reason these might be needed is when manually @@ -484,93 +424,84 @@ let ProtobufUnittest_UnittestSwiftReserved_Extensions: SwiftProtobuf.SimpleExten // accessors for the extension fields on the messages directly. /// Won't get _p added because it is fully qualified. -let ProtobufUnittest_Extensions_debug_description = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( +let SwiftProtoTesting_Extensions_debug_description = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( _protobuf_fieldNumber: 1000, - fieldName: "protobuf_unittest.debug_description" + fieldName: "swift_proto_testing.debug_description" ) /// These are scoped to the file, so the package prefix (or a Swift prefix) /// will get added to them to they aren't going to get renamed. -let ProtobufUnittest_Extensions_as = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( +let SwiftProtoTesting_Extensions_as = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( _protobuf_fieldNumber: 1012, - fieldName: "protobuf_unittest.as" + fieldName: "swift_proto_testing.as" ) -let ProtobufUnittest_Extensions_var = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( +let SwiftProtoTesting_Extensions_var = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( _protobuf_fieldNumber: 1013, - fieldName: "protobuf_unittest.var" + fieldName: "swift_proto_testing.var" ) -let ProtobufUnittest_Extensions_try = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( +let SwiftProtoTesting_Extensions_try = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( _protobuf_fieldNumber: 1014, - fieldName: "protobuf_unittest.try" + fieldName: "swift_proto_testing.try" ) -let ProtobufUnittest_Extensions_do = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( +let SwiftProtoTesting_Extensions_do = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( _protobuf_fieldNumber: 1015, - fieldName: "protobuf_unittest.do" + fieldName: "swift_proto_testing.do" ) -let ProtobufUnittest_Extensions_nil = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( +let SwiftProtoTesting_Extensions_nil = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( _protobuf_fieldNumber: 1016, - fieldName: "protobuf_unittest.nil" + fieldName: "swift_proto_testing.nil" ) -extension ProtobufUnittest_SwiftReservedTestExt { +extension SwiftProtoTesting_SwiftReservedTestExt { enum Extensions { /// This will end up in the "enum Extensions" to scope it, but there /// the raw form is used ("hash_value", not the Swift one "hashValue"), /// so there is no conflict, and no renaming happens. - static let hash_value = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( + static let hash_value = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( _protobuf_fieldNumber: 1001, - fieldName: "protobuf_unittest.SwiftReservedTestExt.hash_value" + fieldName: "swift_proto_testing.SwiftReservedTestExt.hash_value" ) /// Reserved words, since these end up in the "struct Extensions", they /// can't just be get their names, and sanitation kicks. - static let `as` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( + static let `as` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( _protobuf_fieldNumber: 1022, - fieldName: "protobuf_unittest.SwiftReservedTestExt.as" + fieldName: "swift_proto_testing.SwiftReservedTestExt.as" ) - static let `var` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( + static let `var` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( _protobuf_fieldNumber: 1023, - fieldName: "protobuf_unittest.SwiftReservedTestExt.var" + fieldName: "swift_proto_testing.SwiftReservedTestExt.var" ) - static let `try` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( + static let `try` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( _protobuf_fieldNumber: 1024, - fieldName: "protobuf_unittest.SwiftReservedTestExt.try" + fieldName: "swift_proto_testing.SwiftReservedTestExt.try" ) - static let `do` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( + static let `do` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( _protobuf_fieldNumber: 1025, - fieldName: "protobuf_unittest.SwiftReservedTestExt.do" + fieldName: "swift_proto_testing.SwiftReservedTestExt.do" ) - static let `nil` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.classMessage>( + static let `nil` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.classMessage>( _protobuf_fieldNumber: 1026, - fieldName: "protobuf_unittest.SwiftReservedTestExt.nil" + fieldName: "swift_proto_testing.SwiftReservedTestExt.nil" ) } } // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_SwiftReservedTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_SwiftReservedTest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SwiftReservedTest" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 10: .standard(proto: "proto_message_name"), - 11: .standard(proto: "proto_package_name"), - 12: .standard(proto: "any_type_prefix"), - 13: .standard(proto: "any_type_url"), - 20: .standard(proto: "is_initialized"), - 21: .standard(proto: "hash_value"), - 22: .standard(proto: "debug_description"), - 30: .standard(proto: "required_int"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{4}\u{a}proto_message_name\0\u{3}proto_package_name\0\u{3}any_type_prefix\0\u{3}any_type_url\0\u{4}\u{7}is_initialized\0\u{3}hash_value\0\u{3}debug_description\0\u{4}\u{8}required_int\0") public var isInitialized: Bool { if self._requiredInt == nil {return false} @@ -628,7 +559,7 @@ extension ProtobufUnittest_SwiftReservedTest: SwiftProtobuf.Message, SwiftProtob try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_SwiftReservedTest, rhs: ProtobufUnittest_SwiftReservedTest) -> Bool { + static func ==(lhs: SwiftProtoTesting_SwiftReservedTest, rhs: SwiftProtoTesting_SwiftReservedTest) -> Bool { if lhs._protoMessageName != rhs._protoMessageName {return false} if lhs._protoPackageName != rhs._protoPackageName {return false} if lhs._anyTypePrefix != rhs._anyTypePrefix {return false} @@ -642,25 +573,16 @@ extension ProtobufUnittest_SwiftReservedTest: SwiftProtobuf.Message, SwiftProtob } } -extension ProtobufUnittest_SwiftReservedTest.Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "DOUBLE"), - 2: .same(proto: "JSON"), - 3: .same(proto: "CLASS"), - 4: .same(proto: "_"), - 5: .same(proto: "SELF"), - 6: .same(proto: "TYPE"), - ] +extension SwiftProtoTesting_SwiftReservedTest.Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}DOUBLE\0\u{1}JSON\0\u{1}CLASS\0\u{1}_\0\u{1}SELF\0\u{1}TYPE\0") } -extension ProtobufUnittest_SwiftReservedTest.ProtocolEnum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .same(proto: "a"), - ] +extension SwiftProtoTesting_SwiftReservedTest.ProtocolEnum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}a\0") } -extension ProtobufUnittest_SwiftReservedTest.classMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_SwiftReservedTest.protoMessageName + ".class" +extension SwiftProtoTesting_SwiftReservedTest.classMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_SwiftReservedTest.protoMessageName + ".class" static let _protobuf_nameMap = SwiftProtobuf._NameMap() public var isInitialized: Bool { @@ -671,7 +593,7 @@ extension ProtobufUnittest_SwiftReservedTest.classMessage: SwiftProtobuf.Message mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { if (1000 <= fieldNumber && fieldNumber < 2001) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_SwiftReservedTest.classMessage.self, fieldNumber: fieldNumber) + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_SwiftReservedTest.classMessage.self, fieldNumber: fieldNumber) } } } @@ -681,15 +603,15 @@ extension ProtobufUnittest_SwiftReservedTest.classMessage: SwiftProtobuf.Message try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_SwiftReservedTest.classMessage, rhs: ProtobufUnittest_SwiftReservedTest.classMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_SwiftReservedTest.classMessage, rhs: SwiftProtoTesting_SwiftReservedTest.classMessage) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension ProtobufUnittest_SwiftReservedTest.TypeMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_SwiftReservedTest.protoMessageName + ".Type" +extension SwiftProtoTesting_SwiftReservedTest.TypeMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_SwiftReservedTest.protoMessageName + ".Type" static let _protobuf_nameMap = SwiftProtobuf._NameMap() public var isInitialized: Bool { @@ -700,7 +622,7 @@ extension ProtobufUnittest_SwiftReservedTest.TypeMessage: SwiftProtobuf.Message, mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { if (1000 <= fieldNumber && fieldNumber < 2001) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufUnittest_SwiftReservedTest.TypeMessage.self, fieldNumber: fieldNumber) + try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SwiftProtoTesting_SwiftReservedTest.TypeMessage.self, fieldNumber: fieldNumber) } } } @@ -710,46 +632,46 @@ extension ProtobufUnittest_SwiftReservedTest.TypeMessage: SwiftProtobuf.Message, try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_SwiftReservedTest.TypeMessage, rhs: ProtobufUnittest_SwiftReservedTest.TypeMessage) -> Bool { + static func ==(lhs: SwiftProtoTesting_SwiftReservedTest.TypeMessage, rhs: SwiftProtoTesting_SwiftReservedTest.TypeMessage) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} return true } } -extension ProtobufUnittest_SwiftReservedTest.isEqual: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_SwiftReservedTest.protoMessageName + ".isEqual" +extension SwiftProtoTesting_SwiftReservedTest.isEqual: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_SwiftReservedTest.protoMessageName + ".isEqual" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_SwiftReservedTest.isEqual, rhs: ProtobufUnittest_SwiftReservedTest.isEqual) -> Bool { + static func ==(lhs: SwiftProtoTesting_SwiftReservedTest.isEqual, rhs: SwiftProtoTesting_SwiftReservedTest.isEqual) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_SwiftReservedTestExt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_SwiftReservedTestExt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".SwiftReservedTestExt" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_SwiftReservedTestExt, rhs: ProtobufUnittest_SwiftReservedTestExt) -> Bool { + static func ==(lhs: SwiftProtoTesting_SwiftReservedTestExt, rhs: SwiftProtoTesting_SwiftReservedTestExt) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } diff --git a/Tests/SwiftProtobufTests/unittest_swift_reserved_ext.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_reserved_ext.pb.swift index 238f3b59c..ab98d6d0d 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_reserved_ext.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_reserved_ext.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_reserved_ext.proto @@ -23,7 +24,6 @@ /// // ----------------------------------------------------------------------------- -import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -36,7 +36,7 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct SwiftReservedTestExt2 { +struct SwiftReservedTestExt2: Sendable { // 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. @@ -46,20 +46,16 @@ struct SwiftReservedTestExt2 { init() {} } -#if swift(>=5.5) && canImport(_Concurrency) -extension SwiftReservedTestExt2: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Extension support defined in unittest_swift_reserved_ext.proto. // MARK: - Extension Properties -// Swift Extensions on the exteneded Messages to add easy access to the declared +// Swift Extensions on the extended 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 ProtobufUnittest_SwiftReservedTest.TypeMessage { +extension SwiftProtoTesting_SwiftReservedTest.TypeMessage { /// Will get _p added because it has no package/swift prefix to scope and /// would otherwise be a problem when added to the message. @@ -275,67 +271,67 @@ let UnittestSwiftReservedExt_Extensions: SwiftProtobuf.SimpleExtensionMap = [ /// Will get _p added because it has no package/swift prefix to scope and /// would otherwise be a problem when added to the message. -let Extensions_debugDescription = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( +let Extensions_debugDescription = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1000, fieldName: "debugDescription" ) /// These will get _p added for the same reasoning. -let Extensions_as = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( +let Extensions_as = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1012, fieldName: "as" ) -let Extensions_var = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( +let Extensions_var = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1013, fieldName: "var" ) -let Extensions_try = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( +let Extensions_try = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1014, fieldName: "try" ) -let Extensions_do = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( +let Extensions_do = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1015, fieldName: "do" ) -let Extensions_nil = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( +let Extensions_nil = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1016, fieldName: "nil" ) extension SwiftReservedTestExt2 { enum Extensions { - static let hashValue_ = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( + static let hashValue_ = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1001, fieldName: "SwiftReservedTestExt2.hashValue" ) /// Reserved words, since these end up in the "enum Extensions", they /// can't just be get their names, and sanitation kicks. - static let `as` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( + static let `as` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1022, fieldName: "SwiftReservedTestExt2.as" ) - static let `var` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( + static let `var` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1023, fieldName: "SwiftReservedTestExt2.var" ) - static let `try` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( + static let `try` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1024, fieldName: "SwiftReservedTestExt2.try" ) - static let `do` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( + static let `do` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1025, fieldName: "SwiftReservedTestExt2.do" ) - static let `nil` = SwiftProtobuf.MessageExtension, ProtobufUnittest_SwiftReservedTest.TypeMessage>( + static let `nil` = SwiftProtobuf.MessageExtension, SwiftProtoTesting_SwiftReservedTest.TypeMessage>( _protobuf_fieldNumber: 1026, fieldName: "SwiftReservedTestExt2.nil" ) @@ -349,8 +345,8 @@ extension SwiftReservedTestExt2: SwiftProtobuf.Message, SwiftProtobuf._MessageIm static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { diff --git a/Tests/SwiftProtobufTests/unittest_swift_runtime_proto2.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_runtime_proto2.pb.swift index ec106e899..594485dc3 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_runtime_proto2.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_runtime_proto2.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_runtime_proto2.proto @@ -49,260 +50,260 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_Message2 { +struct SwiftProtoTesting_Message2: @unchecked Sendable { // 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 optionalInt32: Int32 { - get {return _storage._optionalInt32 ?? 0} + get {_storage._optionalInt32 ?? 0} set {_uniqueStorage()._optionalInt32 = newValue} } /// Returns true if `optionalInt32` has been explicitly set. - var hasOptionalInt32: Bool {return _storage._optionalInt32 != nil} + var hasOptionalInt32: Bool {_storage._optionalInt32 != nil} /// Clears the value of `optionalInt32`. Subsequent reads from it will return its default value. mutating func clearOptionalInt32() {_uniqueStorage()._optionalInt32 = nil} var optionalInt64: Int64 { - get {return _storage._optionalInt64 ?? 0} + get {_storage._optionalInt64 ?? 0} set {_uniqueStorage()._optionalInt64 = newValue} } /// Returns true if `optionalInt64` has been explicitly set. - var hasOptionalInt64: Bool {return _storage._optionalInt64 != nil} + var hasOptionalInt64: Bool {_storage._optionalInt64 != nil} /// Clears the value of `optionalInt64`. Subsequent reads from it will return its default value. mutating func clearOptionalInt64() {_uniqueStorage()._optionalInt64 = nil} var optionalUint32: UInt32 { - get {return _storage._optionalUint32 ?? 0} + get {_storage._optionalUint32 ?? 0} set {_uniqueStorage()._optionalUint32 = newValue} } /// Returns true if `optionalUint32` has been explicitly set. - var hasOptionalUint32: Bool {return _storage._optionalUint32 != nil} + var hasOptionalUint32: Bool {_storage._optionalUint32 != nil} /// Clears the value of `optionalUint32`. Subsequent reads from it will return its default value. mutating func clearOptionalUint32() {_uniqueStorage()._optionalUint32 = nil} var optionalUint64: UInt64 { - get {return _storage._optionalUint64 ?? 0} + get {_storage._optionalUint64 ?? 0} set {_uniqueStorage()._optionalUint64 = newValue} } /// Returns true if `optionalUint64` has been explicitly set. - var hasOptionalUint64: Bool {return _storage._optionalUint64 != nil} + var hasOptionalUint64: Bool {_storage._optionalUint64 != nil} /// Clears the value of `optionalUint64`. Subsequent reads from it will return its default value. mutating func clearOptionalUint64() {_uniqueStorage()._optionalUint64 = nil} var optionalSint32: Int32 { - get {return _storage._optionalSint32 ?? 0} + get {_storage._optionalSint32 ?? 0} set {_uniqueStorage()._optionalSint32 = newValue} } /// Returns true if `optionalSint32` has been explicitly set. - var hasOptionalSint32: Bool {return _storage._optionalSint32 != nil} + var hasOptionalSint32: Bool {_storage._optionalSint32 != nil} /// Clears the value of `optionalSint32`. Subsequent reads from it will return its default value. mutating func clearOptionalSint32() {_uniqueStorage()._optionalSint32 = nil} var optionalSint64: Int64 { - get {return _storage._optionalSint64 ?? 0} + get {_storage._optionalSint64 ?? 0} set {_uniqueStorage()._optionalSint64 = newValue} } /// Returns true if `optionalSint64` has been explicitly set. - var hasOptionalSint64: Bool {return _storage._optionalSint64 != nil} + var hasOptionalSint64: Bool {_storage._optionalSint64 != nil} /// Clears the value of `optionalSint64`. Subsequent reads from it will return its default value. mutating func clearOptionalSint64() {_uniqueStorage()._optionalSint64 = nil} var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32 ?? 0} + get {_storage._optionalFixed32 ?? 0} set {_uniqueStorage()._optionalFixed32 = newValue} } /// Returns true if `optionalFixed32` has been explicitly set. - var hasOptionalFixed32: Bool {return _storage._optionalFixed32 != nil} + var hasOptionalFixed32: Bool {_storage._optionalFixed32 != nil} /// Clears the value of `optionalFixed32`. Subsequent reads from it will return its default value. mutating func clearOptionalFixed32() {_uniqueStorage()._optionalFixed32 = nil} var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64 ?? 0} + get {_storage._optionalFixed64 ?? 0} set {_uniqueStorage()._optionalFixed64 = newValue} } /// Returns true if `optionalFixed64` has been explicitly set. - var hasOptionalFixed64: Bool {return _storage._optionalFixed64 != nil} + var hasOptionalFixed64: Bool {_storage._optionalFixed64 != nil} /// Clears the value of `optionalFixed64`. Subsequent reads from it will return its default value. mutating func clearOptionalFixed64() {_uniqueStorage()._optionalFixed64 = nil} var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32 ?? 0} + get {_storage._optionalSfixed32 ?? 0} set {_uniqueStorage()._optionalSfixed32 = newValue} } /// Returns true if `optionalSfixed32` has been explicitly set. - var hasOptionalSfixed32: Bool {return _storage._optionalSfixed32 != nil} + var hasOptionalSfixed32: Bool {_storage._optionalSfixed32 != nil} /// Clears the value of `optionalSfixed32`. Subsequent reads from it will return its default value. mutating func clearOptionalSfixed32() {_uniqueStorage()._optionalSfixed32 = nil} var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64 ?? 0} + get {_storage._optionalSfixed64 ?? 0} set {_uniqueStorage()._optionalSfixed64 = newValue} } /// Returns true if `optionalSfixed64` has been explicitly set. - var hasOptionalSfixed64: Bool {return _storage._optionalSfixed64 != nil} + var hasOptionalSfixed64: Bool {_storage._optionalSfixed64 != nil} /// Clears the value of `optionalSfixed64`. Subsequent reads from it will return its default value. mutating func clearOptionalSfixed64() {_uniqueStorage()._optionalSfixed64 = nil} var optionalFloat: Float { - get {return _storage._optionalFloat ?? 0} + get {_storage._optionalFloat ?? 0} set {_uniqueStorage()._optionalFloat = newValue} } /// Returns true if `optionalFloat` has been explicitly set. - var hasOptionalFloat: Bool {return _storage._optionalFloat != nil} + var hasOptionalFloat: Bool {_storage._optionalFloat != nil} /// Clears the value of `optionalFloat`. Subsequent reads from it will return its default value. mutating func clearOptionalFloat() {_uniqueStorage()._optionalFloat = nil} var optionalDouble: Double { - get {return _storage._optionalDouble ?? 0} + get {_storage._optionalDouble ?? 0} set {_uniqueStorage()._optionalDouble = newValue} } /// Returns true if `optionalDouble` has been explicitly set. - var hasOptionalDouble: Bool {return _storage._optionalDouble != nil} + var hasOptionalDouble: Bool {_storage._optionalDouble != nil} /// Clears the value of `optionalDouble`. Subsequent reads from it will return its default value. mutating func clearOptionalDouble() {_uniqueStorage()._optionalDouble = nil} var optionalBool: Bool { - get {return _storage._optionalBool ?? false} + get {_storage._optionalBool ?? false} set {_uniqueStorage()._optionalBool = newValue} } /// Returns true if `optionalBool` has been explicitly set. - var hasOptionalBool: Bool {return _storage._optionalBool != nil} + var hasOptionalBool: Bool {_storage._optionalBool != nil} /// Clears the value of `optionalBool`. Subsequent reads from it will return its default value. mutating func clearOptionalBool() {_uniqueStorage()._optionalBool = nil} var optionalString: String { - get {return _storage._optionalString ?? String()} + get {_storage._optionalString ?? String()} set {_uniqueStorage()._optionalString = newValue} } /// Returns true if `optionalString` has been explicitly set. - var hasOptionalString: Bool {return _storage._optionalString != nil} + var hasOptionalString: Bool {_storage._optionalString != nil} /// Clears the value of `optionalString`. Subsequent reads from it will return its default value. mutating func clearOptionalString() {_uniqueStorage()._optionalString = nil} var optionalBytes: Data { - get {return _storage._optionalBytes ?? Data()} + get {_storage._optionalBytes ?? Data()} set {_uniqueStorage()._optionalBytes = newValue} } /// Returns true if `optionalBytes` has been explicitly set. - var hasOptionalBytes: Bool {return _storage._optionalBytes != nil} + var hasOptionalBytes: Bool {_storage._optionalBytes != nil} /// Clears the value of `optionalBytes`. Subsequent reads from it will return its default value. mutating func clearOptionalBytes() {_uniqueStorage()._optionalBytes = nil} - var optionalGroup: ProtobufUnittest_Message2.OptionalGroup { - get {return _storage._optionalGroup ?? ProtobufUnittest_Message2.OptionalGroup()} + var optionalGroup: SwiftProtoTesting_Message2.OptionalGroup { + get {_storage._optionalGroup ?? SwiftProtoTesting_Message2.OptionalGroup()} set {_uniqueStorage()._optionalGroup = newValue} } /// Returns true if `optionalGroup` has been explicitly set. - var hasOptionalGroup: Bool {return _storage._optionalGroup != nil} + var hasOptionalGroup: Bool {_storage._optionalGroup != nil} /// Clears the value of `optionalGroup`. Subsequent reads from it will return its default value. mutating func clearOptionalGroup() {_uniqueStorage()._optionalGroup = nil} - var optionalMessage: ProtobufUnittest_Message2 { - get {return _storage._optionalMessage ?? ProtobufUnittest_Message2()} + var optionalMessage: SwiftProtoTesting_Message2 { + get {_storage._optionalMessage ?? SwiftProtoTesting_Message2()} set {_uniqueStorage()._optionalMessage = newValue} } /// Returns true if `optionalMessage` has been explicitly set. - var hasOptionalMessage: Bool {return _storage._optionalMessage != nil} + var hasOptionalMessage: Bool {_storage._optionalMessage != nil} /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalMessage() {_uniqueStorage()._optionalMessage = nil} - var optionalEnum: ProtobufUnittest_Message2.Enum { - get {return _storage._optionalEnum ?? .foo} + var optionalEnum: SwiftProtoTesting_Message2.Enum { + get {_storage._optionalEnum ?? .foo} set {_uniqueStorage()._optionalEnum = newValue} } /// Returns true if `optionalEnum` has been explicitly set. - var hasOptionalEnum: Bool {return _storage._optionalEnum != nil} + var hasOptionalEnum: Bool {_storage._optionalEnum != nil} /// Clears the value of `optionalEnum`. Subsequent reads from it will return its default value. mutating func clearOptionalEnum() {_uniqueStorage()._optionalEnum = nil} var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } - var repeatedGroup: [ProtobufUnittest_Message2.RepeatedGroup] { - get {return _storage._repeatedGroup} + var repeatedGroup: [SwiftProtoTesting_Message2.RepeatedGroup] { + get {_storage._repeatedGroup} set {_uniqueStorage()._repeatedGroup = newValue} } - var repeatedMessage: [ProtobufUnittest_Message2] { - get {return _storage._repeatedMessage} + var repeatedMessage: [SwiftProtoTesting_Message2] { + get {_storage._repeatedMessage} set {_uniqueStorage()._repeatedMessage = newValue} } - var repeatedEnum: [ProtobufUnittest_Message2.Enum] { - get {return _storage._repeatedEnum} + var repeatedEnum: [SwiftProtoTesting_Message2.Enum] { + get {_storage._repeatedEnum} set {_uniqueStorage()._repeatedEnum = newValue} } @@ -431,23 +432,23 @@ struct ProtobufUnittest_Message2 { set {_uniqueStorage()._o = .oneofBytes(newValue)} } - var oneofGroup: ProtobufUnittest_Message2.OneofGroup { + var oneofGroup: SwiftProtoTesting_Message2.OneofGroup { get { if case .oneofGroup(let v)? = _storage._o {return v} - return ProtobufUnittest_Message2.OneofGroup() + return SwiftProtoTesting_Message2.OneofGroup() } set {_uniqueStorage()._o = .oneofGroup(newValue)} } - var oneofMessage: ProtobufUnittest_Message2 { + var oneofMessage: SwiftProtoTesting_Message2 { get { if case .oneofMessage(let v)? = _storage._o {return v} - return ProtobufUnittest_Message2() + return SwiftProtoTesting_Message2() } set {_uniqueStorage()._o = .oneofMessage(newValue)} } - var oneofEnum: ProtobufUnittest_Message2.Enum { + var oneofEnum: SwiftProtoTesting_Message2.Enum { get { if case .oneofEnum(let v)? = _storage._o {return v} return .baz @@ -457,103 +458,103 @@ struct ProtobufUnittest_Message2 { /// Some token map cases, too many combinations to list them all. var mapInt32Int32: Dictionary { - get {return _storage._mapInt32Int32} + get {_storage._mapInt32Int32} set {_uniqueStorage()._mapInt32Int32 = newValue} } var mapInt64Int64: Dictionary { - get {return _storage._mapInt64Int64} + get {_storage._mapInt64Int64} set {_uniqueStorage()._mapInt64Int64 = newValue} } var mapUint32Uint32: Dictionary { - get {return _storage._mapUint32Uint32} + get {_storage._mapUint32Uint32} set {_uniqueStorage()._mapUint32Uint32 = newValue} } var mapUint64Uint64: Dictionary { - get {return _storage._mapUint64Uint64} + get {_storage._mapUint64Uint64} set {_uniqueStorage()._mapUint64Uint64 = newValue} } var mapSint32Sint32: Dictionary { - get {return _storage._mapSint32Sint32} + get {_storage._mapSint32Sint32} set {_uniqueStorage()._mapSint32Sint32 = newValue} } var mapSint64Sint64: Dictionary { - get {return _storage._mapSint64Sint64} + get {_storage._mapSint64Sint64} set {_uniqueStorage()._mapSint64Sint64 = newValue} } var mapFixed32Fixed32: Dictionary { - get {return _storage._mapFixed32Fixed32} + get {_storage._mapFixed32Fixed32} set {_uniqueStorage()._mapFixed32Fixed32 = newValue} } var mapFixed64Fixed64: Dictionary { - get {return _storage._mapFixed64Fixed64} + get {_storage._mapFixed64Fixed64} set {_uniqueStorage()._mapFixed64Fixed64 = newValue} } var mapSfixed32Sfixed32: Dictionary { - get {return _storage._mapSfixed32Sfixed32} + get {_storage._mapSfixed32Sfixed32} set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} } var mapSfixed64Sfixed64: Dictionary { - get {return _storage._mapSfixed64Sfixed64} + get {_storage._mapSfixed64Sfixed64} set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} } var mapInt32Float: Dictionary { - get {return _storage._mapInt32Float} + get {_storage._mapInt32Float} set {_uniqueStorage()._mapInt32Float = newValue} } var mapInt32Double: Dictionary { - get {return _storage._mapInt32Double} + get {_storage._mapInt32Double} set {_uniqueStorage()._mapInt32Double = newValue} } var mapBoolBool: Dictionary { - get {return _storage._mapBoolBool} + get {_storage._mapBoolBool} set {_uniqueStorage()._mapBoolBool = newValue} } var mapStringString: Dictionary { - get {return _storage._mapStringString} + get {_storage._mapStringString} set {_uniqueStorage()._mapStringString = newValue} } var mapStringBytes: Dictionary { - get {return _storage._mapStringBytes} + get {_storage._mapStringBytes} set {_uniqueStorage()._mapStringBytes = newValue} } - var mapStringMessage: Dictionary { - get {return _storage._mapStringMessage} + var mapStringMessage: Dictionary { + get {_storage._mapStringMessage} set {_uniqueStorage()._mapStringMessage = newValue} } var mapInt32Bytes: Dictionary { - get {return _storage._mapInt32Bytes} + get {_storage._mapInt32Bytes} set {_uniqueStorage()._mapInt32Bytes = newValue} } - var mapInt32Enum: Dictionary { - get {return _storage._mapInt32Enum} + var mapInt32Enum: Dictionary { + get {_storage._mapInt32Enum} set {_uniqueStorage()._mapInt32Enum = newValue} } - var mapInt32Message: Dictionary { - get {return _storage._mapInt32Message} + var mapInt32Message: Dictionary { + get {_storage._mapInt32Message} set {_uniqueStorage()._mapInt32Message = newValue} } var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_O: Equatable { + enum OneOf_O: Equatable, Sendable { case oneofInt32(Int32) case oneofInt64(Int64) case oneofUint32(UInt32) @@ -569,137 +570,35 @@ struct ProtobufUnittest_Message2 { case oneofBool(Bool) case oneofString(String) case oneofBytes(Data) - case oneofGroup(ProtobufUnittest_Message2.OneofGroup) - case oneofMessage(ProtobufUnittest_Message2) - case oneofEnum(ProtobufUnittest_Message2.Enum) + case oneofGroup(SwiftProtoTesting_Message2.OneofGroup) + case oneofMessage(SwiftProtoTesting_Message2) + case oneofEnum(SwiftProtoTesting_Message2.Enum) - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_Message2.OneOf_O, rhs: ProtobufUnittest_Message2.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 (.oneofInt32, .oneofInt32): return { - guard case .oneofInt32(let l) = lhs, case .oneofInt32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofInt64, .oneofInt64): return { - guard case .oneofInt64(let l) = lhs, case .oneofInt64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint64, .oneofUint64): return { - guard case .oneofUint64(let l) = lhs, case .oneofUint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSint32, .oneofSint32): return { - guard case .oneofSint32(let l) = lhs, case .oneofSint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSint64, .oneofSint64): return { - guard case .oneofSint64(let l) = lhs, case .oneofSint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFixed32, .oneofFixed32): return { - guard case .oneofFixed32(let l) = lhs, case .oneofFixed32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFixed64, .oneofFixed64): return { - guard case .oneofFixed64(let l) = lhs, case .oneofFixed64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSfixed32, .oneofSfixed32): return { - guard case .oneofSfixed32(let l) = lhs, case .oneofSfixed32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSfixed64, .oneofSfixed64): return { - guard case .oneofSfixed64(let l) = lhs, case .oneofSfixed64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFloat, .oneofFloat): return { - guard case .oneofFloat(let l) = lhs, case .oneofFloat(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofDouble, .oneofDouble): return { - guard case .oneofDouble(let l) = lhs, case .oneofDouble(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBool, .oneofBool): return { - guard case .oneofBool(let l) = lhs, case .oneofBool(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofGroup, .oneofGroup): return { - guard case .oneofGroup(let l) = lhs, case .oneofGroup(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofMessage, .oneofMessage): return { - guard case .oneofMessage(let l) = lhs, case .oneofMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofEnum, .oneofEnum): return { - guard case .oneofEnum(let l) = lhs, case .oneofEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum Enum: SwiftProtobuf.Enum { - typealias RawValue = Int - case foo // = 0 - case bar // = 1 - case baz // = 2 - case extra2 // = 20 + enum Enum: Int, SwiftProtobuf.Enum, Swift.CaseIterable { + case foo = 0 + case bar = 1 + case baz = 2 + case extra2 = 20 init() { self = .foo } - init?(rawValue: Int) { - switch rawValue { - case 0: self = .foo - case 1: self = .bar - case 2: self = .baz - case 20: self = .extra2 - default: return nil - } - } - - var rawValue: Int { - switch self { - case .foo: return 0 - case .bar: return 1 - case .baz: return 2 - case .extra2: return 20 - } - } - } - struct OptionalGroup { + struct OptionalGroup: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -710,17 +609,17 @@ struct ProtobufUnittest_Message2 { fileprivate var _a: Int32? = nil } - struct RepeatedGroup { + struct RepeatedGroup: Sendable { // 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 a: Int32 { - get {return _a ?? 0} + get {_a ?? 0} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} @@ -731,26 +630,26 @@ struct ProtobufUnittest_Message2 { fileprivate var _a: Int32? = nil } - struct OneofGroup { + struct OneofGroup: Sendable { // 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 a: Int32 { - get {return _a ?? 116} + get {_a ?? 116} set {_a = newValue} } /// Returns true if `a` has been explicitly set. - var hasA: Bool {return self._a != nil} + var hasA: Bool {self._a != nil} /// Clears the value of `a`. Subsequent reads from it will return its default value. mutating func clearA() {self._a = nil} var b: Int32 { - get {return _b ?? 0} + get {_b ?? 0} set {_b = newValue} } /// Returns true if `b` has been explicitly set. - var hasB: Bool {return self._b != nil} + var hasB: Bool {self._b != nil} /// Clears the value of `b`. Subsequent reads from it will return its default value. mutating func clearB() {self._b = nil} @@ -767,15 +666,7 @@ struct ProtobufUnittest_Message2 { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension ProtobufUnittest_Message2.Enum: CaseIterable { - // Support synthesized by the compiler. -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_Msg2NoStorage { +struct SwiftProtoTesting_Msg2NoStorage: Sendable { // 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. @@ -785,18 +676,18 @@ struct ProtobufUnittest_Msg2NoStorage { init() {} } -struct ProtobufUnittest_Msg2UsesStorage { +struct SwiftProtoTesting_Msg2UsesStorage: @unchecked Sendable { // 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. /// Recursive class (i.e. - can build a graph), forces _StorageClass. - var y: ProtobufUnittest_Msg2UsesStorage { - get {return _storage._y ?? ProtobufUnittest_Msg2UsesStorage()} + var y: SwiftProtoTesting_Msg2UsesStorage { + get {_storage._y ?? SwiftProtoTesting_Msg2UsesStorage()} set {_uniqueStorage()._y = newValue} } /// Returns true if `y` has been explicitly set. - var hasY: Bool {return _storage._y != nil} + var hasY: Bool {_storage._y != nil} /// Clears the value of `y`. Subsequent reads from it will return its default value. mutating func clearY() {_uniqueStorage()._y = nil} @@ -808,35 +699,35 @@ struct ProtobufUnittest_Msg2UsesStorage { } /// Names that match protocols - No Storage -struct ProtobufUnittest_Msg2NamesNoStorage { +struct SwiftProtoTesting_Msg2NamesNoStorage: Sendable { // 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 isInitialized_p: Int32 { - get {return _isInitialized_p ?? 0} + get {_isInitialized_p ?? 0} set {_isInitialized_p = newValue} } /// Returns true if `isInitialized_p` has been explicitly set. - var hasIsInitialized_p: Bool {return self._isInitialized_p != nil} + var hasIsInitialized_p: Bool {self._isInitialized_p != nil} /// Clears the value of `isInitialized_p`. Subsequent reads from it will return its default value. mutating func clearIsInitialized_p() {self._isInitialized_p = nil} var debugDescription_p: Int32 { - get {return _debugDescription_p ?? 0} + get {_debugDescription_p ?? 0} set {_debugDescription_p = newValue} } /// Returns true if `debugDescription_p` has been explicitly set. - var hasDebugDescription_p: Bool {return self._debugDescription_p != nil} + var hasDebugDescription_p: Bool {self._debugDescription_p != nil} /// Clears the value of `debugDescription_p`. Subsequent reads from it will return its default value. mutating func clearDebugDescription_p() {self._debugDescription_p = nil} var value: Int32 { - get {return _value ?? 0} + get {_value ?? 0} set {_value = newValue} } /// Returns true if `value` has been explicitly set. - var hasValue: Bool {return self._value != nil} + var hasValue: Bool {self._value != nil} /// Clears the value of `value`. Subsequent reads from it will return its default value. mutating func clearValue() {self._value = nil} @@ -850,36 +741,36 @@ struct ProtobufUnittest_Msg2NamesNoStorage { } /// Names that match protocols - Storage -struct ProtobufUnittest_Msg2NamesUsesStorage { +struct SwiftProtoTesting_Msg2NamesUsesStorage: Sendable { // 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 isInitialized_p: Int32 { - get {return _isInitialized_p ?? 0} + get {_isInitialized_p ?? 0} set {_isInitialized_p = newValue} } /// Returns true if `isInitialized_p` has been explicitly set. - var hasIsInitialized_p: Bool {return self._isInitialized_p != nil} + var hasIsInitialized_p: Bool {self._isInitialized_p != nil} /// Clears the value of `isInitialized_p`. Subsequent reads from it will return its default value. mutating func clearIsInitialized_p() {self._isInitialized_p = nil} var debugDescription_p: Int32 { - get {return _debugDescription_p ?? 0} + get {_debugDescription_p ?? 0} set {_debugDescription_p = newValue} } /// Returns true if `debugDescription_p` has been explicitly set. - var hasDebugDescription_p: Bool {return self._debugDescription_p != nil} + var hasDebugDescription_p: Bool {self._debugDescription_p != nil} /// Clears the value of `debugDescription_p`. Subsequent reads from it will return its default value. mutating func clearDebugDescription_p() {self._debugDescription_p = nil} /// Recursive class, forces _StorageClass - var value: ProtobufUnittest_Msg2UsesStorage { - get {return _value ?? ProtobufUnittest_Msg2UsesStorage()} + var value: SwiftProtoTesting_Msg2UsesStorage { + get {_value ?? SwiftProtoTesting_Msg2UsesStorage()} set {_value = newValue} } /// Returns true if `value` has been explicitly set. - var hasValue: Bool {return self._value != nil} + var hasValue: Bool {self._value != nil} /// Clears the value of `value`. Subsequent reads from it will return its default value. mutating func clearValue() {self._value = nil} @@ -889,103 +780,16 @@ struct ProtobufUnittest_Msg2NamesUsesStorage { fileprivate var _isInitialized_p: Int32? = nil fileprivate var _debugDescription_p: Int32? = nil - fileprivate var _value: ProtobufUnittest_Msg2UsesStorage? = nil + fileprivate var _value: SwiftProtoTesting_Msg2UsesStorage? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_Message2: @unchecked Sendable {} -extension ProtobufUnittest_Message2.OneOf_O: @unchecked Sendable {} -extension ProtobufUnittest_Message2.Enum: @unchecked Sendable {} -extension ProtobufUnittest_Message2.OptionalGroup: @unchecked Sendable {} -extension ProtobufUnittest_Message2.RepeatedGroup: @unchecked Sendable {} -extension ProtobufUnittest_Message2.OneofGroup: @unchecked Sendable {} -extension ProtobufUnittest_Msg2NoStorage: @unchecked Sendable {} -extension ProtobufUnittest_Msg2UsesStorage: @unchecked Sendable {} -extension ProtobufUnittest_Msg2NamesNoStorage: @unchecked Sendable {} -extension ProtobufUnittest_Msg2NamesUsesStorage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Message2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Message2" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 16: .unique(proto: "OptionalGroup", json: "optionalgroup"), - 18: .standard(proto: "optional_message"), - 19: .standard(proto: "optional_enum"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 46: .unique(proto: "RepeatedGroup", json: "repeatedgroup"), - 48: .standard(proto: "repeated_message"), - 49: .standard(proto: "repeated_enum"), - 51: .standard(proto: "oneof_int32"), - 52: .standard(proto: "oneof_int64"), - 53: .standard(proto: "oneof_uint32"), - 54: .standard(proto: "oneof_uint64"), - 55: .standard(proto: "oneof_sint32"), - 56: .standard(proto: "oneof_sint64"), - 57: .standard(proto: "oneof_fixed32"), - 58: .standard(proto: "oneof_fixed64"), - 59: .standard(proto: "oneof_sfixed32"), - 60: .standard(proto: "oneof_sfixed64"), - 61: .standard(proto: "oneof_float"), - 62: .standard(proto: "oneof_double"), - 63: .standard(proto: "oneof_bool"), - 64: .standard(proto: "oneof_string"), - 65: .standard(proto: "oneof_bytes"), - 66: .unique(proto: "OneofGroup", json: "oneofgroup"), - 68: .standard(proto: "oneof_message"), - 69: .standard(proto: "oneof_enum"), - 70: .standard(proto: "map_int32_int32"), - 71: .standard(proto: "map_int64_int64"), - 72: .standard(proto: "map_uint32_uint32"), - 73: .standard(proto: "map_uint64_uint64"), - 74: .standard(proto: "map_sint32_sint32"), - 75: .standard(proto: "map_sint64_sint64"), - 76: .standard(proto: "map_fixed32_fixed32"), - 77: .standard(proto: "map_fixed64_fixed64"), - 78: .standard(proto: "map_sfixed32_sfixed32"), - 79: .standard(proto: "map_sfixed64_sfixed64"), - 80: .standard(proto: "map_int32_float"), - 81: .standard(proto: "map_int32_double"), - 82: .standard(proto: "map_bool_bool"), - 83: .standard(proto: "map_string_string"), - 84: .standard(proto: "map_string_bytes"), - 85: .standard(proto: "map_string_message"), - 86: .standard(proto: "map_int32_bytes"), - 87: .standard(proto: "map_int32_enum"), - 88: .standard(proto: "map_int32_message"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{7}OptionalGroup\0\u{4}\u{2}optional_message\0\u{3}optional_enum\0\u{4}\u{c}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{7}RepeatedGroup\0\u{4}\u{2}repeated_message\0\u{3}repeated_enum\0\u{4}\u{2}oneof_int32\0\u{3}oneof_int64\0\u{3}oneof_uint32\0\u{3}oneof_uint64\0\u{3}oneof_sint32\0\u{3}oneof_sint64\0\u{3}oneof_fixed32\0\u{3}oneof_fixed64\0\u{3}oneof_sfixed32\0\u{3}oneof_sfixed64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_bool\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{7}OneofGroup\0\u{4}\u{2}oneof_message\0\u{3}oneof_enum\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_message\0\u{3}map_int32_bytes\0\u{3}map_int32_enum\0\u{3}map_int32_message\0") fileprivate class _StorageClass { var _optionalInt32: Int32? = nil @@ -1003,9 +807,9 @@ extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._Messa var _optionalBool: Bool? = nil var _optionalString: String? = nil var _optionalBytes: Data? = nil - var _optionalGroup: ProtobufUnittest_Message2.OptionalGroup? = nil - var _optionalMessage: ProtobufUnittest_Message2? = nil - var _optionalEnum: ProtobufUnittest_Message2.Enum? = nil + var _optionalGroup: SwiftProtoTesting_Message2.OptionalGroup? = nil + var _optionalMessage: SwiftProtoTesting_Message2? = nil + var _optionalEnum: SwiftProtoTesting_Message2.Enum? = nil var _repeatedInt32: [Int32] = [] var _repeatedInt64: [Int64] = [] var _repeatedUint32: [UInt32] = [] @@ -1021,10 +825,10 @@ extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._Messa var _repeatedBool: [Bool] = [] var _repeatedString: [String] = [] var _repeatedBytes: [Data] = [] - var _repeatedGroup: [ProtobufUnittest_Message2.RepeatedGroup] = [] - var _repeatedMessage: [ProtobufUnittest_Message2] = [] - var _repeatedEnum: [ProtobufUnittest_Message2.Enum] = [] - var _o: ProtobufUnittest_Message2.OneOf_O? + var _repeatedGroup: [SwiftProtoTesting_Message2.RepeatedGroup] = [] + var _repeatedMessage: [SwiftProtoTesting_Message2] = [] + var _repeatedEnum: [SwiftProtoTesting_Message2.Enum] = [] + var _o: SwiftProtoTesting_Message2.OneOf_O? var _mapInt32Int32: Dictionary = [:] var _mapInt64Int64: Dictionary = [:] var _mapUint32Uint32: Dictionary = [:] @@ -1040,12 +844,16 @@ extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._Messa var _mapBoolBool: Dictionary = [:] var _mapStringString: Dictionary = [:] var _mapStringBytes: Dictionary = [:] - var _mapStringMessage: Dictionary = [:] + var _mapStringMessage: Dictionary = [:] var _mapInt32Bytes: Dictionary = [:] - var _mapInt32Enum: Dictionary = [:] - var _mapInt32Message: Dictionary = [:] + var _mapInt32Enum: Dictionary = [:] + var _mapInt32Message: Dictionary = [:] - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1281,7 +1089,7 @@ extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._Messa } }() case 66: try { - var v: ProtobufUnittest_Message2.OneofGroup? + var v: SwiftProtoTesting_Message2.OneofGroup? var hadOneofValue = false if let current = _storage._o { hadOneofValue = true @@ -1294,7 +1102,7 @@ extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._Messa } }() case 68: try { - var v: ProtobufUnittest_Message2? + var v: SwiftProtoTesting_Message2? var hadOneofValue = false if let current = _storage._o { hadOneofValue = true @@ -1307,7 +1115,7 @@ extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._Messa } }() case 69: try { - var v: ProtobufUnittest_Message2.Enum? + var v: SwiftProtoTesting_Message2.Enum? try decoder.decodeSingularEnumField(value: &v) if let v = v { if _storage._o != nil {try decoder.handleConflictingOneOf()} @@ -1329,10 +1137,10 @@ extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._Messa case 82: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() case 83: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() case 84: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() - case 85: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringMessage) }() + case 85: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringMessage) }() case 86: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bytes) }() - case 87: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() - case 88: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32Message) }() + case 87: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() + case 88: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32Message) }() default: break } } @@ -1574,22 +1382,22 @@ extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._Messa try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 84) } if !_storage._mapStringMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringMessage, fieldNumber: 85) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringMessage, fieldNumber: 85) } if !_storage._mapInt32Bytes.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bytes, fieldNumber: 86) } if !_storage._mapInt32Enum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 87) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 87) } if !_storage._mapInt32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32Message, fieldNumber: 88) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32Message, fieldNumber: 88) } } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Message2, rhs: ProtobufUnittest_Message2) -> Bool { + static func ==(lhs: SwiftProtoTesting_Message2, rhs: SwiftProtoTesting_Message2) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -1659,20 +1467,13 @@ extension ProtobufUnittest_Message2: SwiftProtobuf.Message, SwiftProtobuf._Messa } } -extension ProtobufUnittest_Message2.Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - 20: .same(proto: "EXTRA_2"), - ] +extension SwiftProtoTesting_Message2.Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOO\0\u{1}BAR\0\u{1}BAZ\0\u{2}\u{12}EXTRA_2\0") } -extension ProtobufUnittest_Message2.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_Message2.protoMessageName + ".OptionalGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 17: .same(proto: "a"), - ] +extension SwiftProtoTesting_Message2.OptionalGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Message2.protoMessageName + ".OptionalGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\u{11}a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1697,18 +1498,16 @@ extension ProtobufUnittest_Message2.OptionalGroup: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Message2.OptionalGroup, rhs: ProtobufUnittest_Message2.OptionalGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_Message2.OptionalGroup, rhs: SwiftProtoTesting_Message2.OptionalGroup) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Message2.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_Message2.protoMessageName + ".RepeatedGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 47: .same(proto: "a"), - ] +extension SwiftProtoTesting_Message2.RepeatedGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Message2.protoMessageName + ".RepeatedGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}/a\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1733,19 +1532,16 @@ extension ProtobufUnittest_Message2.RepeatedGroup: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Message2.RepeatedGroup, rhs: ProtobufUnittest_Message2.RepeatedGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_Message2.RepeatedGroup, rhs: SwiftProtoTesting_Message2.RepeatedGroup) -> Bool { if lhs._a != rhs._a {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Message2.OneofGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = ProtobufUnittest_Message2.protoMessageName + ".OneofGroup" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 67: .same(proto: "a"), - 167: .same(proto: "b"), - ] +extension SwiftProtoTesting_Message2.OneofGroup: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { + static let protoMessageName: String = SwiftProtoTesting_Message2.protoMessageName + ".OneofGroup" + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}C\u{1}a\0\u{2}d\u{1}b\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1774,7 +1570,7 @@ extension ProtobufUnittest_Message2.OneofGroup: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Message2.OneofGroup, rhs: ProtobufUnittest_Message2.OneofGroup) -> Bool { + static func ==(lhs: SwiftProtoTesting_Message2.OneofGroup, rhs: SwiftProtoTesting_Message2.OneofGroup) -> Bool { if lhs._a != rhs._a {return false} if lhs._b != rhs._b {return false} if lhs.unknownFields != rhs.unknownFields {return false} @@ -1782,35 +1578,37 @@ extension ProtobufUnittest_Message2.OneofGroup: SwiftProtobuf.Message, SwiftProt } } -extension ProtobufUnittest_Msg2NoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Msg2NoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg2NoStorage" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Msg2NoStorage, rhs: ProtobufUnittest_Msg2NoStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Msg2NoStorage, rhs: SwiftProtoTesting_Msg2NoStorage) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Msg2UsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Msg2UsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg2UsesStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 999: .same(proto: "y"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}g\u{f}y\0") fileprivate class _StorageClass { - var _y: ProtobufUnittest_Msg2UsesStorage? = nil + var _y: SwiftProtoTesting_Msg2UsesStorage? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1854,7 +1652,7 @@ extension ProtobufUnittest_Msg2UsesStorage: SwiftProtobuf.Message, SwiftProtobuf try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Msg2UsesStorage, rhs: ProtobufUnittest_Msg2UsesStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Msg2UsesStorage, rhs: SwiftProtoTesting_Msg2UsesStorage) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -1869,13 +1667,9 @@ extension ProtobufUnittest_Msg2UsesStorage: SwiftProtobuf.Message, SwiftProtobuf } } -extension ProtobufUnittest_Msg2NamesNoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Msg2NamesNoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg2NamesNoStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "is_initialized"), - 2: .standard(proto: "debug_description"), - 3: .same(proto: "value"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}is_initialized\0\u{3}debug_description\0\u{1}value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1908,7 +1702,7 @@ extension ProtobufUnittest_Msg2NamesNoStorage: SwiftProtobuf.Message, SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Msg2NamesNoStorage, rhs: ProtobufUnittest_Msg2NamesNoStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Msg2NamesNoStorage, rhs: SwiftProtoTesting_Msg2NamesNoStorage) -> Bool { if lhs._isInitialized_p != rhs._isInitialized_p {return false} if lhs._debugDescription_p != rhs._debugDescription_p {return false} if lhs._value != rhs._value {return false} @@ -1917,13 +1711,9 @@ extension ProtobufUnittest_Msg2NamesNoStorage: SwiftProtobuf.Message, SwiftProto } } -extension ProtobufUnittest_Msg2NamesUsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Msg2NamesUsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg2NamesUsesStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "is_initialized"), - 2: .standard(proto: "debug_description"), - 3: .same(proto: "value"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}is_initialized\0\u{3}debug_description\0\u{1}value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1956,7 +1746,7 @@ extension ProtobufUnittest_Msg2NamesUsesStorage: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Msg2NamesUsesStorage, rhs: ProtobufUnittest_Msg2NamesUsesStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Msg2NamesUsesStorage, rhs: SwiftProtoTesting_Msg2NamesUsesStorage) -> Bool { if lhs._isInitialized_p != rhs._isInitialized_p {return false} if lhs._debugDescription_p != rhs._debugDescription_p {return false} if lhs._value != rhs._value {return false} diff --git a/Tests/SwiftProtobufTests/unittest_swift_runtime_proto3.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_runtime_proto3.pb.swift index d74d4f39d..6650886e2 100644 --- a/Tests/SwiftProtobufTests/unittest_swift_runtime_proto3.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_swift_runtime_proto3.pb.swift @@ -1,5 +1,6 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: unittest_swift_runtime_proto3.proto @@ -49,184 +50,184 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP typealias Version = _2 } -struct ProtobufUnittest_Message3 { +struct SwiftProtoTesting_Message3: @unchecked Sendable { // 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 optionalInt32: Int32 { - get {return _storage._optionalInt32} + get {_storage._optionalInt32} set {_uniqueStorage()._optionalInt32 = newValue} } var optionalInt64: Int64 { - get {return _storage._optionalInt64} + get {_storage._optionalInt64} set {_uniqueStorage()._optionalInt64 = newValue} } var optionalUint32: UInt32 { - get {return _storage._optionalUint32} + get {_storage._optionalUint32} set {_uniqueStorage()._optionalUint32 = newValue} } var optionalUint64: UInt64 { - get {return _storage._optionalUint64} + get {_storage._optionalUint64} set {_uniqueStorage()._optionalUint64 = newValue} } var optionalSint32: Int32 { - get {return _storage._optionalSint32} + get {_storage._optionalSint32} set {_uniqueStorage()._optionalSint32 = newValue} } var optionalSint64: Int64 { - get {return _storage._optionalSint64} + get {_storage._optionalSint64} set {_uniqueStorage()._optionalSint64 = newValue} } var optionalFixed32: UInt32 { - get {return _storage._optionalFixed32} + get {_storage._optionalFixed32} set {_uniqueStorage()._optionalFixed32 = newValue} } var optionalFixed64: UInt64 { - get {return _storage._optionalFixed64} + get {_storage._optionalFixed64} set {_uniqueStorage()._optionalFixed64 = newValue} } var optionalSfixed32: Int32 { - get {return _storage._optionalSfixed32} + get {_storage._optionalSfixed32} set {_uniqueStorage()._optionalSfixed32 = newValue} } var optionalSfixed64: Int64 { - get {return _storage._optionalSfixed64} + get {_storage._optionalSfixed64} set {_uniqueStorage()._optionalSfixed64 = newValue} } var optionalFloat: Float { - get {return _storage._optionalFloat} + get {_storage._optionalFloat} set {_uniqueStorage()._optionalFloat = newValue} } var optionalDouble: Double { - get {return _storage._optionalDouble} + get {_storage._optionalDouble} set {_uniqueStorage()._optionalDouble = newValue} } var optionalBool: Bool { - get {return _storage._optionalBool} + get {_storage._optionalBool} set {_uniqueStorage()._optionalBool = newValue} } var optionalString: String { - get {return _storage._optionalString} + get {_storage._optionalString} set {_uniqueStorage()._optionalString = newValue} } var optionalBytes: Data { - get {return _storage._optionalBytes} + get {_storage._optionalBytes} set {_uniqueStorage()._optionalBytes = newValue} } /// No 'group' in proto3. - var optionalMessage: ProtobufUnittest_Message3 { - get {return _storage._optionalMessage ?? ProtobufUnittest_Message3()} + var optionalMessage: SwiftProtoTesting_Message3 { + get {_storage._optionalMessage ?? SwiftProtoTesting_Message3()} set {_uniqueStorage()._optionalMessage = newValue} } /// Returns true if `optionalMessage` has been explicitly set. - var hasOptionalMessage: Bool {return _storage._optionalMessage != nil} + var hasOptionalMessage: Bool {_storage._optionalMessage != nil} /// Clears the value of `optionalMessage`. Subsequent reads from it will return its default value. mutating func clearOptionalMessage() {_uniqueStorage()._optionalMessage = nil} - var optionalEnum: ProtobufUnittest_Message3.Enum { - get {return _storage._optionalEnum} + var optionalEnum: SwiftProtoTesting_Message3.Enum { + get {_storage._optionalEnum} set {_uniqueStorage()._optionalEnum = newValue} } var repeatedInt32: [Int32] { - get {return _storage._repeatedInt32} + get {_storage._repeatedInt32} set {_uniqueStorage()._repeatedInt32 = newValue} } var repeatedInt64: [Int64] { - get {return _storage._repeatedInt64} + get {_storage._repeatedInt64} set {_uniqueStorage()._repeatedInt64 = newValue} } var repeatedUint32: [UInt32] { - get {return _storage._repeatedUint32} + get {_storage._repeatedUint32} set {_uniqueStorage()._repeatedUint32 = newValue} } var repeatedUint64: [UInt64] { - get {return _storage._repeatedUint64} + get {_storage._repeatedUint64} set {_uniqueStorage()._repeatedUint64 = newValue} } var repeatedSint32: [Int32] { - get {return _storage._repeatedSint32} + get {_storage._repeatedSint32} set {_uniqueStorage()._repeatedSint32 = newValue} } var repeatedSint64: [Int64] { - get {return _storage._repeatedSint64} + get {_storage._repeatedSint64} set {_uniqueStorage()._repeatedSint64 = newValue} } var repeatedFixed32: [UInt32] { - get {return _storage._repeatedFixed32} + get {_storage._repeatedFixed32} set {_uniqueStorage()._repeatedFixed32 = newValue} } var repeatedFixed64: [UInt64] { - get {return _storage._repeatedFixed64} + get {_storage._repeatedFixed64} set {_uniqueStorage()._repeatedFixed64 = newValue} } var repeatedSfixed32: [Int32] { - get {return _storage._repeatedSfixed32} + get {_storage._repeatedSfixed32} set {_uniqueStorage()._repeatedSfixed32 = newValue} } var repeatedSfixed64: [Int64] { - get {return _storage._repeatedSfixed64} + get {_storage._repeatedSfixed64} set {_uniqueStorage()._repeatedSfixed64 = newValue} } var repeatedFloat: [Float] { - get {return _storage._repeatedFloat} + get {_storage._repeatedFloat} set {_uniqueStorage()._repeatedFloat = newValue} } var repeatedDouble: [Double] { - get {return _storage._repeatedDouble} + get {_storage._repeatedDouble} set {_uniqueStorage()._repeatedDouble = newValue} } var repeatedBool: [Bool] { - get {return _storage._repeatedBool} + get {_storage._repeatedBool} set {_uniqueStorage()._repeatedBool = newValue} } var repeatedString: [String] { - get {return _storage._repeatedString} + get {_storage._repeatedString} set {_uniqueStorage()._repeatedString = newValue} } var repeatedBytes: [Data] { - get {return _storage._repeatedBytes} + get {_storage._repeatedBytes} set {_uniqueStorage()._repeatedBytes = newValue} } /// No 'group' in proto3. - var repeatedMessage: [ProtobufUnittest_Message3] { - get {return _storage._repeatedMessage} + var repeatedMessage: [SwiftProtoTesting_Message3] { + get {_storage._repeatedMessage} set {_uniqueStorage()._repeatedMessage = newValue} } - var repeatedEnum: [ProtobufUnittest_Message3.Enum] { - get {return _storage._repeatedEnum} + var repeatedEnum: [SwiftProtoTesting_Message3.Enum] { + get {_storage._repeatedEnum} set {_uniqueStorage()._repeatedEnum = newValue} } @@ -356,15 +357,15 @@ struct ProtobufUnittest_Message3 { } /// No 'group' in proto3. - var oneofMessage: ProtobufUnittest_Message3 { + var oneofMessage: SwiftProtoTesting_Message3 { get { if case .oneofMessage(let v)? = _storage._o {return v} - return ProtobufUnittest_Message3() + return SwiftProtoTesting_Message3() } set {_uniqueStorage()._o = .oneofMessage(newValue)} } - var oneofEnum: ProtobufUnittest_Message3.Enum { + var oneofEnum: SwiftProtoTesting_Message3.Enum { get { if case .oneofEnum(let v)? = _storage._o {return v} return .foo @@ -374,103 +375,103 @@ struct ProtobufUnittest_Message3 { /// Some token map cases, too many combinations to list them all. var mapInt32Int32: Dictionary { - get {return _storage._mapInt32Int32} + get {_storage._mapInt32Int32} set {_uniqueStorage()._mapInt32Int32 = newValue} } var mapInt64Int64: Dictionary { - get {return _storage._mapInt64Int64} + get {_storage._mapInt64Int64} set {_uniqueStorage()._mapInt64Int64 = newValue} } var mapUint32Uint32: Dictionary { - get {return _storage._mapUint32Uint32} + get {_storage._mapUint32Uint32} set {_uniqueStorage()._mapUint32Uint32 = newValue} } var mapUint64Uint64: Dictionary { - get {return _storage._mapUint64Uint64} + get {_storage._mapUint64Uint64} set {_uniqueStorage()._mapUint64Uint64 = newValue} } var mapSint32Sint32: Dictionary { - get {return _storage._mapSint32Sint32} + get {_storage._mapSint32Sint32} set {_uniqueStorage()._mapSint32Sint32 = newValue} } var mapSint64Sint64: Dictionary { - get {return _storage._mapSint64Sint64} + get {_storage._mapSint64Sint64} set {_uniqueStorage()._mapSint64Sint64 = newValue} } var mapFixed32Fixed32: Dictionary { - get {return _storage._mapFixed32Fixed32} + get {_storage._mapFixed32Fixed32} set {_uniqueStorage()._mapFixed32Fixed32 = newValue} } var mapFixed64Fixed64: Dictionary { - get {return _storage._mapFixed64Fixed64} + get {_storage._mapFixed64Fixed64} set {_uniqueStorage()._mapFixed64Fixed64 = newValue} } var mapSfixed32Sfixed32: Dictionary { - get {return _storage._mapSfixed32Sfixed32} + get {_storage._mapSfixed32Sfixed32} set {_uniqueStorage()._mapSfixed32Sfixed32 = newValue} } var mapSfixed64Sfixed64: Dictionary { - get {return _storage._mapSfixed64Sfixed64} + get {_storage._mapSfixed64Sfixed64} set {_uniqueStorage()._mapSfixed64Sfixed64 = newValue} } var mapInt32Float: Dictionary { - get {return _storage._mapInt32Float} + get {_storage._mapInt32Float} set {_uniqueStorage()._mapInt32Float = newValue} } var mapInt32Double: Dictionary { - get {return _storage._mapInt32Double} + get {_storage._mapInt32Double} set {_uniqueStorage()._mapInt32Double = newValue} } var mapBoolBool: Dictionary { - get {return _storage._mapBoolBool} + get {_storage._mapBoolBool} set {_uniqueStorage()._mapBoolBool = newValue} } var mapStringString: Dictionary { - get {return _storage._mapStringString} + get {_storage._mapStringString} set {_uniqueStorage()._mapStringString = newValue} } var mapStringBytes: Dictionary { - get {return _storage._mapStringBytes} + get {_storage._mapStringBytes} set {_uniqueStorage()._mapStringBytes = newValue} } - var mapStringMessage: Dictionary { - get {return _storage._mapStringMessage} + var mapStringMessage: Dictionary { + get {_storage._mapStringMessage} set {_uniqueStorage()._mapStringMessage = newValue} } var mapInt32Bytes: Dictionary { - get {return _storage._mapInt32Bytes} + get {_storage._mapInt32Bytes} set {_uniqueStorage()._mapInt32Bytes = newValue} } - var mapInt32Enum: Dictionary { - get {return _storage._mapInt32Enum} + var mapInt32Enum: Dictionary { + get {_storage._mapInt32Enum} set {_uniqueStorage()._mapInt32Enum = newValue} } - var mapInt32Message: Dictionary { - get {return _storage._mapInt32Message} + var mapInt32Message: Dictionary { + get {_storage._mapInt32Message} set {_uniqueStorage()._mapInt32Message = newValue} } var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_O: Equatable { + enum OneOf_O: Equatable, Sendable { case oneofInt32(Int32) case oneofInt64(Int64) case oneofUint32(UInt32) @@ -487,90 +488,12 @@ struct ProtobufUnittest_Message3 { case oneofString(String) case oneofBytes(Data) /// No 'group' in proto3. - case oneofMessage(ProtobufUnittest_Message3) - case oneofEnum(ProtobufUnittest_Message3.Enum) + case oneofMessage(SwiftProtoTesting_Message3) + case oneofEnum(SwiftProtoTesting_Message3.Enum) - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_Message3.OneOf_O, rhs: ProtobufUnittest_Message3.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 (.oneofInt32, .oneofInt32): return { - guard case .oneofInt32(let l) = lhs, case .oneofInt32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofInt64, .oneofInt64): return { - guard case .oneofInt64(let l) = lhs, case .oneofInt64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint32, .oneofUint32): return { - guard case .oneofUint32(let l) = lhs, case .oneofUint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofUint64, .oneofUint64): return { - guard case .oneofUint64(let l) = lhs, case .oneofUint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSint32, .oneofSint32): return { - guard case .oneofSint32(let l) = lhs, case .oneofSint32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSint64, .oneofSint64): return { - guard case .oneofSint64(let l) = lhs, case .oneofSint64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFixed32, .oneofFixed32): return { - guard case .oneofFixed32(let l) = lhs, case .oneofFixed32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFixed64, .oneofFixed64): return { - guard case .oneofFixed64(let l) = lhs, case .oneofFixed64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSfixed32, .oneofSfixed32): return { - guard case .oneofSfixed32(let l) = lhs, case .oneofSfixed32(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofSfixed64, .oneofSfixed64): return { - guard case .oneofSfixed64(let l) = lhs, case .oneofSfixed64(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofFloat, .oneofFloat): return { - guard case .oneofFloat(let l) = lhs, case .oneofFloat(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofDouble, .oneofDouble): return { - guard case .oneofDouble(let l) = lhs, case .oneofDouble(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBool, .oneofBool): return { - guard case .oneofBool(let l) = lhs, case .oneofBool(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofString, .oneofString): return { - guard case .oneofString(let l) = lhs, case .oneofString(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofBytes, .oneofBytes): return { - guard case .oneofBytes(let l) = lhs, case .oneofBytes(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofMessage, .oneofMessage): return { - guard case .oneofMessage(let l) = lhs, case .oneofMessage(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.oneofEnum, .oneofEnum): return { - guard case .oneofEnum(let l) = lhs, case .oneofEnum(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } - enum Enum: SwiftProtobuf.Enum { + enum Enum: SwiftProtobuf.Enum, Swift.CaseIterable { typealias RawValue = Int case foo // = 0 case bar // = 1 @@ -602,6 +525,14 @@ struct ProtobufUnittest_Message3 { } } + // The compiler won't synthesize support with the UNRECOGNIZED case. + static let allCases: [SwiftProtoTesting_Message3.Enum] = [ + .foo, + .bar, + .baz, + .extra3, + ] + } init() {} @@ -609,21 +540,7 @@ struct ProtobufUnittest_Message3 { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=4.2) - -extension ProtobufUnittest_Message3.Enum: CaseIterable { - // The compiler won't synthesize support with the UNRECOGNIZED case. - static var allCases: [ProtobufUnittest_Message3.Enum] = [ - .foo, - .bar, - .baz, - .extra3, - ] -} - -#endif // swift(>=4.2) - -struct ProtobufUnittest_Msg3NoStorage { +struct SwiftProtoTesting_Msg3NoStorage: Sendable { // 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. @@ -633,18 +550,18 @@ struct ProtobufUnittest_Msg3NoStorage { init() {} } -struct ProtobufUnittest_Msg3UsesStorage { +struct SwiftProtoTesting_Msg3UsesStorage: @unchecked Sendable { // 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. /// Recursive class (i.e. - can build a graph), forces _StorageClass. - var y: ProtobufUnittest_Msg3UsesStorage { - get {return _storage._y ?? ProtobufUnittest_Msg3UsesStorage()} + var y: SwiftProtoTesting_Msg3UsesStorage { + get {_storage._y ?? SwiftProtoTesting_Msg3UsesStorage()} set {_uniqueStorage()._y = newValue} } /// Returns true if `y` has been explicitly set. - var hasY: Bool {return _storage._y != nil} + var hasY: Bool {_storage._y != nil} /// Clears the value of `y`. Subsequent reads from it will return its default value. mutating func clearY() {_uniqueStorage()._y = nil} @@ -656,7 +573,7 @@ struct ProtobufUnittest_Msg3UsesStorage { } /// Names that match protocols - No Storage -struct ProtobufUnittest_Msg3NamesNoStorage { +struct SwiftProtoTesting_Msg3NamesNoStorage: Sendable { // 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. @@ -673,7 +590,7 @@ struct ProtobufUnittest_Msg3NamesNoStorage { } /// Names that match protocols - No Storage -struct ProtobufUnittest_Msg3NamesUsesStorage { +struct SwiftProtoTesting_Msg3NamesUsesStorage: Sendable { // 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. @@ -683,12 +600,12 @@ struct ProtobufUnittest_Msg3NamesUsesStorage { var debugDescription_p: Int32 = 0 /// Recursive class, forces _StorageClass - var value: ProtobufUnittest_Msg3UsesStorage { - get {return _value ?? ProtobufUnittest_Msg3UsesStorage()} + var value: SwiftProtoTesting_Msg3UsesStorage { + get {_value ?? SwiftProtoTesting_Msg3UsesStorage()} set {_value = newValue} } /// Returns true if `value` has been explicitly set. - var hasValue: Bool {return self._value != nil} + var hasValue: Bool {self._value != nil} /// Clears the value of `value`. Subsequent reads from it will return its default value. mutating func clearValue() {self._value = nil} @@ -696,97 +613,16 @@ struct ProtobufUnittest_Msg3NamesUsesStorage { init() {} - fileprivate var _value: ProtobufUnittest_Msg3UsesStorage? = nil + fileprivate var _value: SwiftProtoTesting_Msg3UsesStorage? = nil } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_Message3: @unchecked Sendable {} -extension ProtobufUnittest_Message3.OneOf_O: @unchecked Sendable {} -extension ProtobufUnittest_Message3.Enum: @unchecked Sendable {} -extension ProtobufUnittest_Msg3NoStorage: @unchecked Sendable {} -extension ProtobufUnittest_Msg3UsesStorage: @unchecked Sendable {} -extension ProtobufUnittest_Msg3NamesNoStorage: @unchecked Sendable {} -extension ProtobufUnittest_Msg3NamesUsesStorage: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Message3: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Message3" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "optional_int32"), - 2: .standard(proto: "optional_int64"), - 3: .standard(proto: "optional_uint32"), - 4: .standard(proto: "optional_uint64"), - 5: .standard(proto: "optional_sint32"), - 6: .standard(proto: "optional_sint64"), - 7: .standard(proto: "optional_fixed32"), - 8: .standard(proto: "optional_fixed64"), - 9: .standard(proto: "optional_sfixed32"), - 10: .standard(proto: "optional_sfixed64"), - 11: .standard(proto: "optional_float"), - 12: .standard(proto: "optional_double"), - 13: .standard(proto: "optional_bool"), - 14: .standard(proto: "optional_string"), - 15: .standard(proto: "optional_bytes"), - 18: .standard(proto: "optional_message"), - 19: .standard(proto: "optional_enum"), - 31: .standard(proto: "repeated_int32"), - 32: .standard(proto: "repeated_int64"), - 33: .standard(proto: "repeated_uint32"), - 34: .standard(proto: "repeated_uint64"), - 35: .standard(proto: "repeated_sint32"), - 36: .standard(proto: "repeated_sint64"), - 37: .standard(proto: "repeated_fixed32"), - 38: .standard(proto: "repeated_fixed64"), - 39: .standard(proto: "repeated_sfixed32"), - 40: .standard(proto: "repeated_sfixed64"), - 41: .standard(proto: "repeated_float"), - 42: .standard(proto: "repeated_double"), - 43: .standard(proto: "repeated_bool"), - 44: .standard(proto: "repeated_string"), - 45: .standard(proto: "repeated_bytes"), - 48: .standard(proto: "repeated_message"), - 49: .standard(proto: "repeated_enum"), - 51: .standard(proto: "oneof_int32"), - 52: .standard(proto: "oneof_int64"), - 53: .standard(proto: "oneof_uint32"), - 54: .standard(proto: "oneof_uint64"), - 55: .standard(proto: "oneof_sint32"), - 56: .standard(proto: "oneof_sint64"), - 57: .standard(proto: "oneof_fixed32"), - 58: .standard(proto: "oneof_fixed64"), - 59: .standard(proto: "oneof_sfixed32"), - 60: .standard(proto: "oneof_sfixed64"), - 61: .standard(proto: "oneof_float"), - 62: .standard(proto: "oneof_double"), - 63: .standard(proto: "oneof_bool"), - 64: .standard(proto: "oneof_string"), - 65: .standard(proto: "oneof_bytes"), - 68: .standard(proto: "oneof_message"), - 69: .standard(proto: "oneof_enum"), - 70: .standard(proto: "map_int32_int32"), - 71: .standard(proto: "map_int64_int64"), - 72: .standard(proto: "map_uint32_uint32"), - 73: .standard(proto: "map_uint64_uint64"), - 74: .standard(proto: "map_sint32_sint32"), - 75: .standard(proto: "map_sint64_sint64"), - 76: .standard(proto: "map_fixed32_fixed32"), - 77: .standard(proto: "map_fixed64_fixed64"), - 78: .standard(proto: "map_sfixed32_sfixed32"), - 79: .standard(proto: "map_sfixed64_sfixed64"), - 80: .standard(proto: "map_int32_float"), - 81: .standard(proto: "map_int32_double"), - 82: .standard(proto: "map_bool_bool"), - 83: .standard(proto: "map_string_string"), - 84: .standard(proto: "map_string_bytes"), - 85: .standard(proto: "map_string_message"), - 86: .standard(proto: "map_int32_bytes"), - 87: .standard(proto: "map_int32_enum"), - 88: .standard(proto: "map_int32_message"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}optional_int32\0\u{3}optional_int64\0\u{3}optional_uint32\0\u{3}optional_uint64\0\u{3}optional_sint32\0\u{3}optional_sint64\0\u{3}optional_fixed32\0\u{3}optional_fixed64\0\u{3}optional_sfixed32\0\u{3}optional_sfixed64\0\u{3}optional_float\0\u{3}optional_double\0\u{3}optional_bool\0\u{3}optional_string\0\u{3}optional_bytes\0\u{4}\u{3}optional_message\0\u{3}optional_enum\0\u{4}\u{c}repeated_int32\0\u{3}repeated_int64\0\u{3}repeated_uint32\0\u{3}repeated_uint64\0\u{3}repeated_sint32\0\u{3}repeated_sint64\0\u{3}repeated_fixed32\0\u{3}repeated_fixed64\0\u{3}repeated_sfixed32\0\u{3}repeated_sfixed64\0\u{3}repeated_float\0\u{3}repeated_double\0\u{3}repeated_bool\0\u{3}repeated_string\0\u{3}repeated_bytes\0\u{4}\u{3}repeated_message\0\u{3}repeated_enum\0\u{4}\u{2}oneof_int32\0\u{3}oneof_int64\0\u{3}oneof_uint32\0\u{3}oneof_uint64\0\u{3}oneof_sint32\0\u{3}oneof_sint64\0\u{3}oneof_fixed32\0\u{3}oneof_fixed64\0\u{3}oneof_sfixed32\0\u{3}oneof_sfixed64\0\u{3}oneof_float\0\u{3}oneof_double\0\u{3}oneof_bool\0\u{3}oneof_string\0\u{3}oneof_bytes\0\u{4}\u{3}oneof_message\0\u{3}oneof_enum\0\u{3}map_int32_int32\0\u{3}map_int64_int64\0\u{3}map_uint32_uint32\0\u{3}map_uint64_uint64\0\u{3}map_sint32_sint32\0\u{3}map_sint64_sint64\0\u{3}map_fixed32_fixed32\0\u{3}map_fixed64_fixed64\0\u{3}map_sfixed32_sfixed32\0\u{3}map_sfixed64_sfixed64\0\u{3}map_int32_float\0\u{3}map_int32_double\0\u{3}map_bool_bool\0\u{3}map_string_string\0\u{3}map_string_bytes\0\u{3}map_string_message\0\u{3}map_int32_bytes\0\u{3}map_int32_enum\0\u{3}map_int32_message\0") fileprivate class _StorageClass { var _optionalInt32: Int32 = 0 @@ -804,8 +640,8 @@ extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._Messa var _optionalBool: Bool = false var _optionalString: String = String() var _optionalBytes: Data = Data() - var _optionalMessage: ProtobufUnittest_Message3? = nil - var _optionalEnum: ProtobufUnittest_Message3.Enum = .foo + var _optionalMessage: SwiftProtoTesting_Message3? = nil + var _optionalEnum: SwiftProtoTesting_Message3.Enum = .foo var _repeatedInt32: [Int32] = [] var _repeatedInt64: [Int64] = [] var _repeatedUint32: [UInt32] = [] @@ -821,9 +657,9 @@ extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._Messa var _repeatedBool: [Bool] = [] var _repeatedString: [String] = [] var _repeatedBytes: [Data] = [] - var _repeatedMessage: [ProtobufUnittest_Message3] = [] - var _repeatedEnum: [ProtobufUnittest_Message3.Enum] = [] - var _o: ProtobufUnittest_Message3.OneOf_O? + var _repeatedMessage: [SwiftProtoTesting_Message3] = [] + var _repeatedEnum: [SwiftProtoTesting_Message3.Enum] = [] + var _o: SwiftProtoTesting_Message3.OneOf_O? var _mapInt32Int32: Dictionary = [:] var _mapInt64Int64: Dictionary = [:] var _mapUint32Uint32: Dictionary = [:] @@ -839,12 +675,16 @@ extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._Messa var _mapBoolBool: Dictionary = [:] var _mapStringString: Dictionary = [:] var _mapStringBytes: Dictionary = [:] - var _mapStringMessage: Dictionary = [:] + var _mapStringMessage: Dictionary = [:] var _mapInt32Bytes: Dictionary = [:] - var _mapInt32Enum: Dictionary = [:] - var _mapInt32Message: Dictionary = [:] + var _mapInt32Enum: Dictionary = [:] + var _mapInt32Message: Dictionary = [:] - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1076,7 +916,7 @@ extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._Messa } }() case 68: try { - var v: ProtobufUnittest_Message3? + var v: SwiftProtoTesting_Message3? var hadOneofValue = false if let current = _storage._o { hadOneofValue = true @@ -1089,7 +929,7 @@ extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._Messa } }() case 69: try { - var v: ProtobufUnittest_Message3.Enum? + var v: SwiftProtoTesting_Message3.Enum? try decoder.decodeSingularEnumField(value: &v) if let v = v { if _storage._o != nil {try decoder.handleConflictingOneOf()} @@ -1111,10 +951,10 @@ extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._Messa case 82: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapBoolBool) }() case 83: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringString) }() case 84: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapStringBytes) }() - case 85: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringMessage) }() + case 85: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapStringMessage) }() case 86: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: &_storage._mapInt32Bytes) }() - case 87: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() - case 88: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32Message) }() + case 87: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: &_storage._mapInt32Enum) }() + case 88: try { try decoder.decodeMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: &_storage._mapInt32Message) }() default: break } } @@ -1157,10 +997,10 @@ extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._Messa if _storage._optionalSfixed64 != 0 { try visitor.visitSingularSFixed64Field(value: _storage._optionalSfixed64, fieldNumber: 10) } - if _storage._optionalFloat != 0 { + if _storage._optionalFloat.bitPattern != 0 { try visitor.visitSingularFloatField(value: _storage._optionalFloat, fieldNumber: 11) } - if _storage._optionalDouble != 0 { + if _storage._optionalDouble.bitPattern != 0 { try visitor.visitSingularDoubleField(value: _storage._optionalDouble, fieldNumber: 12) } if _storage._optionalBool != false { @@ -1346,22 +1186,22 @@ extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._Messa try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapStringBytes, fieldNumber: 84) } if !_storage._mapStringMessage.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringMessage, fieldNumber: 85) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapStringMessage, fieldNumber: 85) } if !_storage._mapInt32Bytes.isEmpty { try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMap.self, value: _storage._mapInt32Bytes, fieldNumber: 86) } if !_storage._mapInt32Enum.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 87) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufEnumMap.self, value: _storage._mapInt32Enum, fieldNumber: 87) } if !_storage._mapInt32Message.isEmpty { - try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32Message, fieldNumber: 88) + try visitor.visitMapField(fieldType: SwiftProtobuf._ProtobufMessageMap.self, value: _storage._mapInt32Message, fieldNumber: 88) } } try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Message3, rhs: ProtobufUnittest_Message3) -> Bool { + static func ==(lhs: SwiftProtoTesting_Message3, rhs: SwiftProtoTesting_Message3) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -1429,44 +1269,41 @@ extension ProtobufUnittest_Message3: SwiftProtobuf.Message, SwiftProtobuf._Messa } } -extension ProtobufUnittest_Message3.Enum: SwiftProtobuf._ProtoNameProviding { - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 0: .same(proto: "FOO"), - 1: .same(proto: "BAR"), - 2: .same(proto: "BAZ"), - 30: .same(proto: "EXTRA_3"), - ] +extension SwiftProtoTesting_Message3.Enum: SwiftProtobuf._ProtoNameProviding { + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0FOO\0\u{1}BAR\0\u{1}BAZ\0\u{2}\u{1c}EXTRA_3\0") } -extension ProtobufUnittest_Msg3NoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Msg3NoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg3NoStorage" static let _protobuf_nameMap = SwiftProtobuf._NameMap() mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } + // Load everything into unknown fields + while try decoder.nextFieldNumber() != nil {} } func traverse(visitor: inout V) throws { try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Msg3NoStorage, rhs: ProtobufUnittest_Msg3NoStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Msg3NoStorage, rhs: SwiftProtoTesting_Msg3NoStorage) -> Bool { if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_Msg3UsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Msg3UsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg3UsesStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 999: .same(proto: "y"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}g\u{f}y\0") fileprivate class _StorageClass { - var _y: ProtobufUnittest_Msg3UsesStorage? = nil + var _y: SwiftProtoTesting_Msg3UsesStorage? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1510,7 +1347,7 @@ extension ProtobufUnittest_Msg3UsesStorage: SwiftProtobuf.Message, SwiftProtobuf try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Msg3UsesStorage, rhs: ProtobufUnittest_Msg3UsesStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Msg3UsesStorage, rhs: SwiftProtoTesting_Msg3UsesStorage) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -1525,13 +1362,9 @@ extension ProtobufUnittest_Msg3UsesStorage: SwiftProtobuf.Message, SwiftProtobuf } } -extension ProtobufUnittest_Msg3NamesNoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Msg3NamesNoStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg3NamesNoStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "is_initialized"), - 2: .standard(proto: "debug_description"), - 3: .standard(proto: "has_value"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}is_initialized\0\u{3}debug_description\0\u{3}has_value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1560,7 +1393,7 @@ extension ProtobufUnittest_Msg3NamesNoStorage: SwiftProtobuf.Message, SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Msg3NamesNoStorage, rhs: ProtobufUnittest_Msg3NamesNoStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Msg3NamesNoStorage, rhs: SwiftProtoTesting_Msg3NamesNoStorage) -> Bool { if lhs.isInitialized_p != rhs.isInitialized_p {return false} if lhs.debugDescription_p != rhs.debugDescription_p {return false} if lhs.hasValue_p != rhs.hasValue_p {return false} @@ -1569,13 +1402,9 @@ extension ProtobufUnittest_Msg3NamesNoStorage: SwiftProtobuf.Message, SwiftProto } } -extension ProtobufUnittest_Msg3NamesUsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_Msg3NamesUsesStorage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".Msg3NamesUsesStorage" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "is_initialized"), - 2: .standard(proto: "debug_description"), - 3: .same(proto: "value"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}is_initialized\0\u{3}debug_description\0\u{1}value\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1608,7 +1437,7 @@ extension ProtobufUnittest_Msg3NamesUsesStorage: SwiftProtobuf.Message, SwiftPro try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_Msg3NamesUsesStorage, rhs: ProtobufUnittest_Msg3NamesUsesStorage) -> Bool { + static func ==(lhs: SwiftProtoTesting_Msg3NamesUsesStorage, rhs: SwiftProtoTesting_Msg3NamesUsesStorage) -> Bool { if lhs.isInitialized_p != rhs.isInitialized_p {return false} if lhs.debugDescription_p != rhs.debugDescription_p {return false} if lhs._value != rhs._value {return false} diff --git a/Tests/SwiftProtobufTests/unittest_swift_startup.pb.swift b/Tests/SwiftProtobufTests/unittest_swift_startup.pb.swift deleted file mode 100644 index f7b331b6b..000000000 --- a/Tests/SwiftProtobufTests/unittest_swift_startup.pb.swift +++ /dev/null @@ -1,225 +0,0 @@ -// DO NOT EDIT. -// swift-format-ignore-file -// -// Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: unittest_swift_startup.proto -// -// For information on using the generated types, please see the documentation: -// https://github.com/apple/swift-protobuf/ - -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -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 ProtobufObjcUnittest_TestObjCStartupMessage: 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() -} - -struct ProtobufObjcUnittest_TestObjCStartupNested { - // 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() {} -} - -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufObjcUnittest_TestObjCStartupMessage: @unchecked Sendable {} -extension ProtobufObjcUnittest_TestObjCStartupNested: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - -// MARK: - Extension support defined in unittest_swift_startup.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 ProtobufObjcUnittest_TestObjCStartupMessage { - - /// Singular - var ProtobufObjcUnittest_optionalInt32Extension: Int32 { - get {return getExtensionValue(ext: ProtobufObjcUnittest_Extensions_optional_int32_extension) ?? 0} - set {setExtensionValue(ext: ProtobufObjcUnittest_Extensions_optional_int32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufObjcUnittest_Extensions_optional_int32_extension` - /// has been explicitly set. - var hasProtobufObjcUnittest_optionalInt32Extension: Bool { - return hasExtensionValue(ext: ProtobufObjcUnittest_Extensions_optional_int32_extension) - } - /// Clears the value of extension `ProtobufObjcUnittest_Extensions_optional_int32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufObjcUnittest_optionalInt32Extension() { - clearExtensionValue(ext: ProtobufObjcUnittest_Extensions_optional_int32_extension) - } - - var ProtobufObjcUnittest_repeatedInt32Extension: [Int32] { - get {return getExtensionValue(ext: ProtobufObjcUnittest_Extensions_repeated_int32_extension) ?? []} - set {setExtensionValue(ext: ProtobufObjcUnittest_Extensions_repeated_int32_extension, value: newValue)} - } - /// Returns true if extension `ProtobufObjcUnittest_Extensions_repeated_int32_extension` - /// has been explicitly set. - var hasProtobufObjcUnittest_repeatedInt32Extension: Bool { - return hasExtensionValue(ext: ProtobufObjcUnittest_Extensions_repeated_int32_extension) - } - /// Clears the value of extension `ProtobufObjcUnittest_Extensions_repeated_int32_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufObjcUnittest_repeatedInt32Extension() { - clearExtensionValue(ext: ProtobufObjcUnittest_Extensions_repeated_int32_extension) - } - - var ProtobufObjcUnittest_TestObjCStartupNested_nestedStringExtension: String { - get {return getExtensionValue(ext: ProtobufObjcUnittest_TestObjCStartupNested.Extensions.nested_string_extension) ?? String()} - set {setExtensionValue(ext: ProtobufObjcUnittest_TestObjCStartupNested.Extensions.nested_string_extension, value: newValue)} - } - /// Returns true if extension `ProtobufObjcUnittest_TestObjCStartupNested.Extensions.nested_string_extension` - /// has been explicitly set. - var hasProtobufObjcUnittest_TestObjCStartupNested_nestedStringExtension: Bool { - return hasExtensionValue(ext: ProtobufObjcUnittest_TestObjCStartupNested.Extensions.nested_string_extension) - } - /// Clears the value of extension `ProtobufObjcUnittest_TestObjCStartupNested.Extensions.nested_string_extension`. - /// Subsequent reads from it will return its default value. - mutating func clearProtobufObjcUnittest_TestObjCStartupNested_nestedStringExtension() { - clearExtensionValue(ext: ProtobufObjcUnittest_TestObjCStartupNested.Extensions.nested_string_extension) - } - -} - -// MARK: - File's ExtensionMap: ProtobufObjcUnittest_UnittestSwiftStartup_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 ProtobufObjcUnittest_UnittestSwiftStartup_Extensions: SwiftProtobuf.SimpleExtensionMap = [ - ProtobufObjcUnittest_Extensions_optional_int32_extension, - ProtobufObjcUnittest_Extensions_repeated_int32_extension, - ProtobufObjcUnittest_TestObjCStartupNested.Extensions.nested_string_extension -] - -// 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. - -/// Singular -let ProtobufObjcUnittest_Extensions_optional_int32_extension = SwiftProtobuf.MessageExtension, ProtobufObjcUnittest_TestObjCStartupMessage>( - _protobuf_fieldNumber: 1, - fieldName: "protobuf_objc_unittest.optional_int32_extension" -) - -let ProtobufObjcUnittest_Extensions_repeated_int32_extension = SwiftProtobuf.MessageExtension, ProtobufObjcUnittest_TestObjCStartupMessage>( - _protobuf_fieldNumber: 2, - fieldName: "protobuf_objc_unittest.repeated_int32_extension" -) - -extension ProtobufObjcUnittest_TestObjCStartupNested { - enum Extensions { - static let nested_string_extension = SwiftProtobuf.MessageExtension, ProtobufObjcUnittest_TestObjCStartupMessage>( - _protobuf_fieldNumber: 3, - fieldName: "protobuf_objc_unittest.TestObjCStartupNested.nested_string_extension" - ) - } -} - -// MARK: - Code below here is support for the SwiftProtobuf runtime. - -fileprivate let _protobuf_package = "protobuf_objc_unittest" - -extension ProtobufObjcUnittest_TestObjCStartupMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestObjCStartupMessage" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - public var isInitialized: Bool { - if !_protobuf_extensionFieldValues.isInitialized {return false} - return true - } - - mutating func decodeMessage(decoder: inout D) throws { - while let fieldNumber = try decoder.nextFieldNumber() { - if (1 <= fieldNumber && fieldNumber < 536870912) { - try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: ProtobufObjcUnittest_TestObjCStartupMessage.self, fieldNumber: fieldNumber) - } - } - } - - func traverse(visitor: inout V) throws { - try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 536870912) - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufObjcUnittest_TestObjCStartupMessage, rhs: ProtobufObjcUnittest_TestObjCStartupMessage) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false} - return true - } -} - -extension ProtobufObjcUnittest_TestObjCStartupNested: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { - static let protoMessageName: String = _protobuf_package + ".TestObjCStartupNested" - static let _protobuf_nameMap = SwiftProtobuf._NameMap() - - mutating func decodeMessage(decoder: inout D) throws { - while let _ = try decoder.nextFieldNumber() { - } - } - - func traverse(visitor: inout V) throws { - try unknownFields.traverse(visitor: &visitor) - } - - static func ==(lhs: ProtobufObjcUnittest_TestObjCStartupNested, rhs: ProtobufObjcUnittest_TestObjCStartupNested) -> Bool { - if lhs.unknownFields != rhs.unknownFields {return false} - return true - } -} diff --git a/Tests/SwiftProtobufTests/unittest_well_known_types.pb.swift b/Tests/SwiftProtobufTests/unittest_well_known_types.pb.swift index d8b98850d..66900d3c9 100644 --- a/Tests/SwiftProtobufTests/unittest_well_known_types.pb.swift +++ b/Tests/SwiftProtobufTests/unittest_well_known_types.pb.swift @@ -1,13 +1,43 @@ // DO NOT EDIT. // swift-format-ignore-file +// swiftlint:disable all // // Generated by the Swift generator plugin for the protocol buffer compiler. -// Source: google/protobuf/unittest_well_known_types.proto +// Source: unittest_well_known_types.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ -import Foundation +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + import SwiftProtobuf // If the compiler emits an error on this type, it is because this file @@ -23,180 +53,180 @@ fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAP /// Test that we can include all well-known types. /// Each wrapper type is included separately, as languages /// map handle different wrappers in different ways. -struct ProtobufUnittest_TestWellKnownTypes { +struct SwiftProtoTesting_TestWellKnownTypes: @unchecked Sendable { // 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 anyField: SwiftProtobuf.Google_Protobuf_Any { - get {return _storage._anyField ?? SwiftProtobuf.Google_Protobuf_Any()} + get {_storage._anyField ?? SwiftProtobuf.Google_Protobuf_Any()} set {_uniqueStorage()._anyField = newValue} } /// Returns true if `anyField` has been explicitly set. - var hasAnyField: Bool {return _storage._anyField != nil} + var hasAnyField: Bool {_storage._anyField != nil} /// Clears the value of `anyField`. Subsequent reads from it will return its default value. mutating func clearAnyField() {_uniqueStorage()._anyField = nil} var apiField: SwiftProtobuf.Google_Protobuf_Api { - get {return _storage._apiField ?? SwiftProtobuf.Google_Protobuf_Api()} + get {_storage._apiField ?? SwiftProtobuf.Google_Protobuf_Api()} set {_uniqueStorage()._apiField = newValue} } /// Returns true if `apiField` has been explicitly set. - var hasApiField: Bool {return _storage._apiField != nil} + var hasApiField: Bool {_storage._apiField != nil} /// Clears the value of `apiField`. Subsequent reads from it will return its default value. mutating func clearApiField() {_uniqueStorage()._apiField = nil} var durationField: SwiftProtobuf.Google_Protobuf_Duration { - get {return _storage._durationField ?? SwiftProtobuf.Google_Protobuf_Duration()} + get {_storage._durationField ?? SwiftProtobuf.Google_Protobuf_Duration()} set {_uniqueStorage()._durationField = newValue} } /// Returns true if `durationField` has been explicitly set. - var hasDurationField: Bool {return _storage._durationField != nil} + var hasDurationField: Bool {_storage._durationField != nil} /// Clears the value of `durationField`. Subsequent reads from it will return its default value. mutating func clearDurationField() {_uniqueStorage()._durationField = nil} var emptyField: SwiftProtobuf.Google_Protobuf_Empty { - get {return _storage._emptyField ?? SwiftProtobuf.Google_Protobuf_Empty()} + get {_storage._emptyField ?? SwiftProtobuf.Google_Protobuf_Empty()} set {_uniqueStorage()._emptyField = newValue} } /// Returns true if `emptyField` has been explicitly set. - var hasEmptyField: Bool {return _storage._emptyField != nil} + var hasEmptyField: Bool {_storage._emptyField != nil} /// Clears the value of `emptyField`. Subsequent reads from it will return its default value. mutating func clearEmptyField() {_uniqueStorage()._emptyField = nil} var fieldMaskField: SwiftProtobuf.Google_Protobuf_FieldMask { - get {return _storage._fieldMaskField ?? SwiftProtobuf.Google_Protobuf_FieldMask()} + get {_storage._fieldMaskField ?? SwiftProtobuf.Google_Protobuf_FieldMask()} set {_uniqueStorage()._fieldMaskField = newValue} } /// Returns true if `fieldMaskField` has been explicitly set. - var hasFieldMaskField: Bool {return _storage._fieldMaskField != nil} + var hasFieldMaskField: Bool {_storage._fieldMaskField != nil} /// Clears the value of `fieldMaskField`. Subsequent reads from it will return its default value. mutating func clearFieldMaskField() {_uniqueStorage()._fieldMaskField = nil} var sourceContextField: SwiftProtobuf.Google_Protobuf_SourceContext { - get {return _storage._sourceContextField ?? SwiftProtobuf.Google_Protobuf_SourceContext()} + get {_storage._sourceContextField ?? SwiftProtobuf.Google_Protobuf_SourceContext()} set {_uniqueStorage()._sourceContextField = newValue} } /// Returns true if `sourceContextField` has been explicitly set. - var hasSourceContextField: Bool {return _storage._sourceContextField != nil} + var hasSourceContextField: Bool {_storage._sourceContextField != nil} /// Clears the value of `sourceContextField`. Subsequent reads from it will return its default value. mutating func clearSourceContextField() {_uniqueStorage()._sourceContextField = nil} var structField: SwiftProtobuf.Google_Protobuf_Struct { - get {return _storage._structField ?? SwiftProtobuf.Google_Protobuf_Struct()} + get {_storage._structField ?? SwiftProtobuf.Google_Protobuf_Struct()} set {_uniqueStorage()._structField = newValue} } /// Returns true if `structField` has been explicitly set. - var hasStructField: Bool {return _storage._structField != nil} + var hasStructField: Bool {_storage._structField != nil} /// Clears the value of `structField`. Subsequent reads from it will return its default value. mutating func clearStructField() {_uniqueStorage()._structField = nil} var timestampField: SwiftProtobuf.Google_Protobuf_Timestamp { - get {return _storage._timestampField ?? SwiftProtobuf.Google_Protobuf_Timestamp()} + get {_storage._timestampField ?? SwiftProtobuf.Google_Protobuf_Timestamp()} set {_uniqueStorage()._timestampField = newValue} } /// Returns true if `timestampField` has been explicitly set. - var hasTimestampField: Bool {return _storage._timestampField != nil} + var hasTimestampField: Bool {_storage._timestampField != nil} /// Clears the value of `timestampField`. Subsequent reads from it will return its default value. mutating func clearTimestampField() {_uniqueStorage()._timestampField = nil} var typeField: SwiftProtobuf.Google_Protobuf_Type { - get {return _storage._typeField ?? SwiftProtobuf.Google_Protobuf_Type()} + get {_storage._typeField ?? SwiftProtobuf.Google_Protobuf_Type()} set {_uniqueStorage()._typeField = newValue} } /// Returns true if `typeField` has been explicitly set. - var hasTypeField: Bool {return _storage._typeField != nil} + var hasTypeField: Bool {_storage._typeField != nil} /// Clears the value of `typeField`. Subsequent reads from it will return its default value. mutating func clearTypeField() {_uniqueStorage()._typeField = nil} var doubleField: SwiftProtobuf.Google_Protobuf_DoubleValue { - get {return _storage._doubleField ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} + get {_storage._doubleField ?? SwiftProtobuf.Google_Protobuf_DoubleValue()} set {_uniqueStorage()._doubleField = newValue} } /// Returns true if `doubleField` has been explicitly set. - var hasDoubleField: Bool {return _storage._doubleField != nil} + var hasDoubleField: Bool {_storage._doubleField != nil} /// Clears the value of `doubleField`. Subsequent reads from it will return its default value. mutating func clearDoubleField() {_uniqueStorage()._doubleField = nil} var floatField: SwiftProtobuf.Google_Protobuf_FloatValue { - get {return _storage._floatField ?? SwiftProtobuf.Google_Protobuf_FloatValue()} + get {_storage._floatField ?? SwiftProtobuf.Google_Protobuf_FloatValue()} set {_uniqueStorage()._floatField = newValue} } /// Returns true if `floatField` has been explicitly set. - var hasFloatField: Bool {return _storage._floatField != nil} + var hasFloatField: Bool {_storage._floatField != nil} /// Clears the value of `floatField`. Subsequent reads from it will return its default value. mutating func clearFloatField() {_uniqueStorage()._floatField = nil} var int64Field: SwiftProtobuf.Google_Protobuf_Int64Value { - get {return _storage._int64Field ?? SwiftProtobuf.Google_Protobuf_Int64Value()} + get {_storage._int64Field ?? SwiftProtobuf.Google_Protobuf_Int64Value()} set {_uniqueStorage()._int64Field = newValue} } /// Returns true if `int64Field` has been explicitly set. - var hasInt64Field: Bool {return _storage._int64Field != nil} + var hasInt64Field: Bool {_storage._int64Field != nil} /// Clears the value of `int64Field`. Subsequent reads from it will return its default value. mutating func clearInt64Field() {_uniqueStorage()._int64Field = nil} var uint64Field: SwiftProtobuf.Google_Protobuf_UInt64Value { - get {return _storage._uint64Field ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} + get {_storage._uint64Field ?? SwiftProtobuf.Google_Protobuf_UInt64Value()} set {_uniqueStorage()._uint64Field = newValue} } /// Returns true if `uint64Field` has been explicitly set. - var hasUint64Field: Bool {return _storage._uint64Field != nil} + var hasUint64Field: Bool {_storage._uint64Field != nil} /// Clears the value of `uint64Field`. Subsequent reads from it will return its default value. mutating func clearUint64Field() {_uniqueStorage()._uint64Field = nil} var int32Field: SwiftProtobuf.Google_Protobuf_Int32Value { - get {return _storage._int32Field ?? SwiftProtobuf.Google_Protobuf_Int32Value()} + get {_storage._int32Field ?? SwiftProtobuf.Google_Protobuf_Int32Value()} set {_uniqueStorage()._int32Field = newValue} } /// Returns true if `int32Field` has been explicitly set. - var hasInt32Field: Bool {return _storage._int32Field != nil} + var hasInt32Field: Bool {_storage._int32Field != nil} /// Clears the value of `int32Field`. Subsequent reads from it will return its default value. mutating func clearInt32Field() {_uniqueStorage()._int32Field = nil} var uint32Field: SwiftProtobuf.Google_Protobuf_UInt32Value { - get {return _storage._uint32Field ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} + get {_storage._uint32Field ?? SwiftProtobuf.Google_Protobuf_UInt32Value()} set {_uniqueStorage()._uint32Field = newValue} } /// Returns true if `uint32Field` has been explicitly set. - var hasUint32Field: Bool {return _storage._uint32Field != nil} + var hasUint32Field: Bool {_storage._uint32Field != nil} /// Clears the value of `uint32Field`. Subsequent reads from it will return its default value. mutating func clearUint32Field() {_uniqueStorage()._uint32Field = nil} var boolField: SwiftProtobuf.Google_Protobuf_BoolValue { - get {return _storage._boolField ?? SwiftProtobuf.Google_Protobuf_BoolValue()} + get {_storage._boolField ?? SwiftProtobuf.Google_Protobuf_BoolValue()} set {_uniqueStorage()._boolField = newValue} } /// Returns true if `boolField` has been explicitly set. - var hasBoolField: Bool {return _storage._boolField != nil} + var hasBoolField: Bool {_storage._boolField != nil} /// Clears the value of `boolField`. Subsequent reads from it will return its default value. mutating func clearBoolField() {_uniqueStorage()._boolField = nil} var stringField: SwiftProtobuf.Google_Protobuf_StringValue { - get {return _storage._stringField ?? SwiftProtobuf.Google_Protobuf_StringValue()} + get {_storage._stringField ?? SwiftProtobuf.Google_Protobuf_StringValue()} set {_uniqueStorage()._stringField = newValue} } /// Returns true if `stringField` has been explicitly set. - var hasStringField: Bool {return _storage._stringField != nil} + var hasStringField: Bool {_storage._stringField != nil} /// Clears the value of `stringField`. Subsequent reads from it will return its default value. mutating func clearStringField() {_uniqueStorage()._stringField = nil} var bytesField: SwiftProtobuf.Google_Protobuf_BytesValue { - get {return _storage._bytesField ?? SwiftProtobuf.Google_Protobuf_BytesValue()} + get {_storage._bytesField ?? SwiftProtobuf.Google_Protobuf_BytesValue()} set {_uniqueStorage()._bytesField = newValue} } /// Returns true if `bytesField` has been explicitly set. - var hasBytesField: Bool {return _storage._bytesField != nil} + var hasBytesField: Bool {_storage._bytesField != nil} /// Clears the value of `bytesField`. Subsequent reads from it will return its default value. mutating func clearBytesField() {_uniqueStorage()._bytesField = nil} /// Part of struct, but useful to be able to test separately var valueField: SwiftProtobuf.Google_Protobuf_Value { - get {return _storage._valueField ?? SwiftProtobuf.Google_Protobuf_Value()} + get {_storage._valueField ?? SwiftProtobuf.Google_Protobuf_Value()} set {_uniqueStorage()._valueField = newValue} } /// Returns true if `valueField` has been explicitly set. - var hasValueField: Bool {return _storage._valueField != nil} + var hasValueField: Bool {_storage._valueField != nil} /// Clears the value of `valueField`. Subsequent reads from it will return its default value. mutating func clearValueField() {_uniqueStorage()._valueField = nil} @@ -208,99 +238,99 @@ struct ProtobufUnittest_TestWellKnownTypes { } /// A repeated field for each well-known type. -struct ProtobufUnittest_RepeatedWellKnownTypes { +struct SwiftProtoTesting_RepeatedWellKnownTypes: @unchecked Sendable { // 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 anyField: [SwiftProtobuf.Google_Protobuf_Any] { - get {return _storage._anyField} + get {_storage._anyField} set {_uniqueStorage()._anyField = newValue} } var apiField: [SwiftProtobuf.Google_Protobuf_Api] { - get {return _storage._apiField} + get {_storage._apiField} set {_uniqueStorage()._apiField = newValue} } var durationField: [SwiftProtobuf.Google_Protobuf_Duration] { - get {return _storage._durationField} + get {_storage._durationField} set {_uniqueStorage()._durationField = newValue} } var emptyField: [SwiftProtobuf.Google_Protobuf_Empty] { - get {return _storage._emptyField} + get {_storage._emptyField} set {_uniqueStorage()._emptyField = newValue} } var fieldMaskField: [SwiftProtobuf.Google_Protobuf_FieldMask] { - get {return _storage._fieldMaskField} + get {_storage._fieldMaskField} set {_uniqueStorage()._fieldMaskField = newValue} } var sourceContextField: [SwiftProtobuf.Google_Protobuf_SourceContext] { - get {return _storage._sourceContextField} + get {_storage._sourceContextField} set {_uniqueStorage()._sourceContextField = newValue} } var structField: [SwiftProtobuf.Google_Protobuf_Struct] { - get {return _storage._structField} + get {_storage._structField} set {_uniqueStorage()._structField = newValue} } var timestampField: [SwiftProtobuf.Google_Protobuf_Timestamp] { - get {return _storage._timestampField} + get {_storage._timestampField} set {_uniqueStorage()._timestampField = newValue} } var typeField: [SwiftProtobuf.Google_Protobuf_Type] { - get {return _storage._typeField} + get {_storage._typeField} set {_uniqueStorage()._typeField = newValue} } /// These don't actually make a lot of sense, but they're not prohibited... var doubleField: [SwiftProtobuf.Google_Protobuf_DoubleValue] { - get {return _storage._doubleField} + get {_storage._doubleField} set {_uniqueStorage()._doubleField = newValue} } var floatField: [SwiftProtobuf.Google_Protobuf_FloatValue] { - get {return _storage._floatField} + get {_storage._floatField} set {_uniqueStorage()._floatField = newValue} } var int64Field: [SwiftProtobuf.Google_Protobuf_Int64Value] { - get {return _storage._int64Field} + get {_storage._int64Field} set {_uniqueStorage()._int64Field = newValue} } var uint64Field: [SwiftProtobuf.Google_Protobuf_UInt64Value] { - get {return _storage._uint64Field} + get {_storage._uint64Field} set {_uniqueStorage()._uint64Field = newValue} } var int32Field: [SwiftProtobuf.Google_Protobuf_Int32Value] { - get {return _storage._int32Field} + get {_storage._int32Field} set {_uniqueStorage()._int32Field = newValue} } var uint32Field: [SwiftProtobuf.Google_Protobuf_UInt32Value] { - get {return _storage._uint32Field} + get {_storage._uint32Field} set {_uniqueStorage()._uint32Field = newValue} } var boolField: [SwiftProtobuf.Google_Protobuf_BoolValue] { - get {return _storage._boolField} + get {_storage._boolField} set {_uniqueStorage()._boolField = newValue} } var stringField: [SwiftProtobuf.Google_Protobuf_StringValue] { - get {return _storage._stringField} + get {_storage._stringField} set {_uniqueStorage()._stringField = newValue} } var bytesField: [SwiftProtobuf.Google_Protobuf_BytesValue] { - get {return _storage._bytesField} + get {_storage._bytesField} set {_uniqueStorage()._bytesField = newValue} } @@ -311,12 +341,12 @@ struct ProtobufUnittest_RepeatedWellKnownTypes { fileprivate var _storage = _StorageClass.defaultInstance } -struct ProtobufUnittest_OneofWellKnownTypes { +struct SwiftProtoTesting_OneofWellKnownTypes: Sendable { // 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 oneofField: ProtobufUnittest_OneofWellKnownTypes.OneOf_OneofField? = nil + var oneofField: SwiftProtoTesting_OneofWellKnownTypes.OneOf_OneofField? = nil var anyField: SwiftProtobuf.Google_Protobuf_Any { get { @@ -464,7 +494,7 @@ struct ProtobufUnittest_OneofWellKnownTypes { var unknownFields = SwiftProtobuf.UnknownStorage() - enum OneOf_OneofField: Equatable { + enum OneOf_OneofField: Equatable, Sendable { case anyField(SwiftProtobuf.Google_Protobuf_Any) case apiField(SwiftProtobuf.Google_Protobuf_Api) case durationField(SwiftProtobuf.Google_Protobuf_Duration) @@ -484,88 +514,6 @@ struct ProtobufUnittest_OneofWellKnownTypes { case stringField(SwiftProtobuf.Google_Protobuf_StringValue) case bytesField(SwiftProtobuf.Google_Protobuf_BytesValue) - #if !swift(>=4.1) - static func ==(lhs: ProtobufUnittest_OneofWellKnownTypes.OneOf_OneofField, rhs: ProtobufUnittest_OneofWellKnownTypes.OneOf_OneofField) -> 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 (.anyField, .anyField): return { - guard case .anyField(let l) = lhs, case .anyField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.apiField, .apiField): return { - guard case .apiField(let l) = lhs, case .apiField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.durationField, .durationField): return { - guard case .durationField(let l) = lhs, case .durationField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.emptyField, .emptyField): return { - guard case .emptyField(let l) = lhs, case .emptyField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.fieldMaskField, .fieldMaskField): return { - guard case .fieldMaskField(let l) = lhs, case .fieldMaskField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.sourceContextField, .sourceContextField): return { - guard case .sourceContextField(let l) = lhs, case .sourceContextField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.structField, .structField): return { - guard case .structField(let l) = lhs, case .structField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.timestampField, .timestampField): return { - guard case .timestampField(let l) = lhs, case .timestampField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.typeField, .typeField): return { - guard case .typeField(let l) = lhs, case .typeField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.doubleField, .doubleField): return { - guard case .doubleField(let l) = lhs, case .doubleField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.floatField, .floatField): return { - guard case .floatField(let l) = lhs, case .floatField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.int64Field, .int64Field): return { - guard case .int64Field(let l) = lhs, case .int64Field(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.uint64Field, .uint64Field): return { - guard case .uint64Field(let l) = lhs, case .uint64Field(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.int32Field, .int32Field): return { - guard case .int32Field(let l) = lhs, case .int32Field(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.uint32Field, .uint32Field): return { - guard case .uint32Field(let l) = lhs, case .uint32Field(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.boolField, .boolField): return { - guard case .boolField(let l) = lhs, case .boolField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.stringField, .stringField): return { - guard case .stringField(let l) = lhs, case .stringField(let r) = rhs else { preconditionFailure() } - return l == r - }() - case (.bytesField, .bytesField): return { - guard case .bytesField(let l) = lhs, case .bytesField(let r) = rhs else { preconditionFailure() } - return l == r - }() - default: return false - } - } - #endif } init() {} @@ -574,98 +522,98 @@ struct ProtobufUnittest_OneofWellKnownTypes { /// A map field for each well-known type. We only /// need to worry about the value part of the map being the /// well-known types, as messages can't be map keys. -struct ProtobufUnittest_MapWellKnownTypes { +struct SwiftProtoTesting_MapWellKnownTypes: @unchecked Sendable { // 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 anyField: Dictionary { - get {return _storage._anyField} + get {_storage._anyField} set {_uniqueStorage()._anyField = newValue} } var apiField: Dictionary { - get {return _storage._apiField} + get {_storage._apiField} set {_uniqueStorage()._apiField = newValue} } var durationField: Dictionary { - get {return _storage._durationField} + get {_storage._durationField} set {_uniqueStorage()._durationField = newValue} } var emptyField: Dictionary { - get {return _storage._emptyField} + get {_storage._emptyField} set {_uniqueStorage()._emptyField = newValue} } var fieldMaskField: Dictionary { - get {return _storage._fieldMaskField} + get {_storage._fieldMaskField} set {_uniqueStorage()._fieldMaskField = newValue} } var sourceContextField: Dictionary { - get {return _storage._sourceContextField} + get {_storage._sourceContextField} set {_uniqueStorage()._sourceContextField = newValue} } var structField: Dictionary { - get {return _storage._structField} + get {_storage._structField} set {_uniqueStorage()._structField = newValue} } var timestampField: Dictionary { - get {return _storage._timestampField} + get {_storage._timestampField} set {_uniqueStorage()._timestampField = newValue} } var typeField: Dictionary { - get {return _storage._typeField} + get {_storage._typeField} set {_uniqueStorage()._typeField = newValue} } var doubleField: Dictionary { - get {return _storage._doubleField} + get {_storage._doubleField} set {_uniqueStorage()._doubleField = newValue} } var floatField: Dictionary { - get {return _storage._floatField} + get {_storage._floatField} set {_uniqueStorage()._floatField = newValue} } var int64Field: Dictionary { - get {return _storage._int64Field} + get {_storage._int64Field} set {_uniqueStorage()._int64Field = newValue} } var uint64Field: Dictionary { - get {return _storage._uint64Field} + get {_storage._uint64Field} set {_uniqueStorage()._uint64Field = newValue} } var int32Field: Dictionary { - get {return _storage._int32Field} + get {_storage._int32Field} set {_uniqueStorage()._int32Field = newValue} } var uint32Field: Dictionary { - get {return _storage._uint32Field} + get {_storage._uint32Field} set {_uniqueStorage()._uint32Field = newValue} } var boolField: Dictionary { - get {return _storage._boolField} + get {_storage._boolField} set {_uniqueStorage()._boolField = newValue} } var stringField: Dictionary { - get {return _storage._stringField} + get {_storage._stringField} set {_uniqueStorage()._stringField = newValue} } var bytesField: Dictionary { - get {return _storage._bytesField} + get {_storage._bytesField} set {_uniqueStorage()._bytesField = newValue} } @@ -676,41 +624,13 @@ struct ProtobufUnittest_MapWellKnownTypes { fileprivate var _storage = _StorageClass.defaultInstance } -#if swift(>=5.5) && canImport(_Concurrency) -extension ProtobufUnittest_TestWellKnownTypes: @unchecked Sendable {} -extension ProtobufUnittest_RepeatedWellKnownTypes: @unchecked Sendable {} -extension ProtobufUnittest_OneofWellKnownTypes: @unchecked Sendable {} -extension ProtobufUnittest_OneofWellKnownTypes.OneOf_OneofField: @unchecked Sendable {} -extension ProtobufUnittest_MapWellKnownTypes: @unchecked Sendable {} -#endif // swift(>=5.5) && canImport(_Concurrency) - // MARK: - Code below here is support for the SwiftProtobuf runtime. -fileprivate let _protobuf_package = "protobuf_unittest" +fileprivate let _protobuf_package = "swift_proto_testing" -extension ProtobufUnittest_TestWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_TestWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".TestWellKnownTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "any_field"), - 2: .standard(proto: "api_field"), - 3: .standard(proto: "duration_field"), - 4: .standard(proto: "empty_field"), - 5: .standard(proto: "field_mask_field"), - 6: .standard(proto: "source_context_field"), - 7: .standard(proto: "struct_field"), - 8: .standard(proto: "timestamp_field"), - 9: .standard(proto: "type_field"), - 10: .standard(proto: "double_field"), - 11: .standard(proto: "float_field"), - 12: .standard(proto: "int64_field"), - 13: .standard(proto: "uint64_field"), - 14: .standard(proto: "int32_field"), - 15: .standard(proto: "uint32_field"), - 16: .standard(proto: "bool_field"), - 17: .standard(proto: "string_field"), - 18: .standard(proto: "bytes_field"), - 19: .standard(proto: "value_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}any_field\0\u{3}api_field\0\u{3}duration_field\0\u{3}empty_field\0\u{3}field_mask_field\0\u{3}source_context_field\0\u{3}struct_field\0\u{3}timestamp_field\0\u{3}type_field\0\u{3}double_field\0\u{3}float_field\0\u{3}int64_field\0\u{3}uint64_field\0\u{3}int32_field\0\u{3}uint32_field\0\u{3}bool_field\0\u{3}string_field\0\u{3}bytes_field\0\u{3}value_field\0") fileprivate class _StorageClass { var _anyField: SwiftProtobuf.Google_Protobuf_Any? = nil @@ -733,7 +653,11 @@ extension ProtobufUnittest_TestWellKnownTypes: SwiftProtobuf.Message, SwiftProto var _bytesField: SwiftProtobuf.Google_Protobuf_BytesValue? = nil var _valueField: SwiftProtobuf.Google_Protobuf_Value? = nil - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -867,7 +791,7 @@ extension ProtobufUnittest_TestWellKnownTypes: SwiftProtobuf.Message, SwiftProto try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_TestWellKnownTypes, rhs: ProtobufUnittest_TestWellKnownTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_TestWellKnownTypes, rhs: SwiftProtoTesting_TestWellKnownTypes) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -900,28 +824,9 @@ extension ProtobufUnittest_TestWellKnownTypes: SwiftProtobuf.Message, SwiftProto } } -extension ProtobufUnittest_RepeatedWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_RepeatedWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".RepeatedWellKnownTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "any_field"), - 2: .standard(proto: "api_field"), - 3: .standard(proto: "duration_field"), - 4: .standard(proto: "empty_field"), - 5: .standard(proto: "field_mask_field"), - 6: .standard(proto: "source_context_field"), - 7: .standard(proto: "struct_field"), - 8: .standard(proto: "timestamp_field"), - 9: .standard(proto: "type_field"), - 10: .standard(proto: "double_field"), - 11: .standard(proto: "float_field"), - 12: .standard(proto: "int64_field"), - 13: .standard(proto: "uint64_field"), - 14: .standard(proto: "int32_field"), - 15: .standard(proto: "uint32_field"), - 16: .standard(proto: "bool_field"), - 17: .standard(proto: "string_field"), - 18: .standard(proto: "bytes_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}any_field\0\u{3}api_field\0\u{3}duration_field\0\u{3}empty_field\0\u{3}field_mask_field\0\u{3}source_context_field\0\u{3}struct_field\0\u{3}timestamp_field\0\u{3}type_field\0\u{3}double_field\0\u{3}float_field\0\u{3}int64_field\0\u{3}uint64_field\0\u{3}int32_field\0\u{3}uint32_field\0\u{3}bool_field\0\u{3}string_field\0\u{3}bytes_field\0") fileprivate class _StorageClass { var _anyField: [SwiftProtobuf.Google_Protobuf_Any] = [] @@ -943,7 +848,11 @@ extension ProtobufUnittest_RepeatedWellKnownTypes: SwiftProtobuf.Message, SwiftP var _stringField: [SwiftProtobuf.Google_Protobuf_StringValue] = [] var _bytesField: [SwiftProtobuf.Google_Protobuf_BytesValue] = [] - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1068,7 +977,7 @@ extension ProtobufUnittest_RepeatedWellKnownTypes: SwiftProtobuf.Message, SwiftP try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_RepeatedWellKnownTypes, rhs: ProtobufUnittest_RepeatedWellKnownTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_RepeatedWellKnownTypes, rhs: SwiftProtoTesting_RepeatedWellKnownTypes) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 @@ -1100,28 +1009,9 @@ extension ProtobufUnittest_RepeatedWellKnownTypes: SwiftProtobuf.Message, SwiftP } } -extension ProtobufUnittest_OneofWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_OneofWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".OneofWellKnownTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "any_field"), - 2: .standard(proto: "api_field"), - 3: .standard(proto: "duration_field"), - 4: .standard(proto: "empty_field"), - 5: .standard(proto: "field_mask_field"), - 6: .standard(proto: "source_context_field"), - 7: .standard(proto: "struct_field"), - 8: .standard(proto: "timestamp_field"), - 9: .standard(proto: "type_field"), - 10: .standard(proto: "double_field"), - 11: .standard(proto: "float_field"), - 12: .standard(proto: "int64_field"), - 13: .standard(proto: "uint64_field"), - 14: .standard(proto: "int32_field"), - 15: .standard(proto: "uint32_field"), - 16: .standard(proto: "bool_field"), - 17: .standard(proto: "string_field"), - 18: .standard(proto: "bytes_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}any_field\0\u{3}api_field\0\u{3}duration_field\0\u{3}empty_field\0\u{3}field_mask_field\0\u{3}source_context_field\0\u{3}struct_field\0\u{3}timestamp_field\0\u{3}type_field\0\u{3}double_field\0\u{3}float_field\0\u{3}int64_field\0\u{3}uint64_field\0\u{3}int32_field\0\u{3}uint32_field\0\u{3}bool_field\0\u{3}string_field\0\u{3}bytes_field\0") mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { @@ -1451,35 +1341,16 @@ extension ProtobufUnittest_OneofWellKnownTypes: SwiftProtobuf.Message, SwiftProt try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_OneofWellKnownTypes, rhs: ProtobufUnittest_OneofWellKnownTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_OneofWellKnownTypes, rhs: SwiftProtoTesting_OneofWellKnownTypes) -> Bool { if lhs.oneofField != rhs.oneofField {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } -extension ProtobufUnittest_MapWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { +extension SwiftProtoTesting_MapWellKnownTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = _protobuf_package + ".MapWellKnownTypes" - static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ - 1: .standard(proto: "any_field"), - 2: .standard(proto: "api_field"), - 3: .standard(proto: "duration_field"), - 4: .standard(proto: "empty_field"), - 5: .standard(proto: "field_mask_field"), - 6: .standard(proto: "source_context_field"), - 7: .standard(proto: "struct_field"), - 8: .standard(proto: "timestamp_field"), - 9: .standard(proto: "type_field"), - 10: .standard(proto: "double_field"), - 11: .standard(proto: "float_field"), - 12: .standard(proto: "int64_field"), - 13: .standard(proto: "uint64_field"), - 14: .standard(proto: "int32_field"), - 15: .standard(proto: "uint32_field"), - 16: .standard(proto: "bool_field"), - 17: .standard(proto: "string_field"), - 18: .standard(proto: "bytes_field"), - ] + static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{3}any_field\0\u{3}api_field\0\u{3}duration_field\0\u{3}empty_field\0\u{3}field_mask_field\0\u{3}source_context_field\0\u{3}struct_field\0\u{3}timestamp_field\0\u{3}type_field\0\u{3}double_field\0\u{3}float_field\0\u{3}int64_field\0\u{3}uint64_field\0\u{3}int32_field\0\u{3}uint32_field\0\u{3}bool_field\0\u{3}string_field\0\u{3}bytes_field\0") fileprivate class _StorageClass { var _anyField: Dictionary = [:] @@ -1501,7 +1372,11 @@ extension ProtobufUnittest_MapWellKnownTypes: SwiftProtobuf.Message, SwiftProtob var _stringField: Dictionary = [:] var _bytesField: Dictionary = [:] - static let defaultInstance = _StorageClass() + // 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() private init() {} @@ -1626,7 +1501,7 @@ extension ProtobufUnittest_MapWellKnownTypes: SwiftProtobuf.Message, SwiftProtob try unknownFields.traverse(visitor: &visitor) } - static func ==(lhs: ProtobufUnittest_MapWellKnownTypes, rhs: ProtobufUnittest_MapWellKnownTypes) -> Bool { + static func ==(lhs: SwiftProtoTesting_MapWellKnownTypes, rhs: SwiftProtoTesting_MapWellKnownTypes) -> Bool { if lhs._storage !== rhs._storage { let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in let _storage = _args.0 diff --git a/Tests/protoc-gen-swiftTests/DescriptorTestData.swift b/Tests/protoc-gen-swiftTests/DescriptorTestData.swift new file mode 100644 index 000000000..4964f86ae --- /dev/null +++ b/Tests/protoc-gen-swiftTests/DescriptorTestData.swift @@ -0,0 +1,53 @@ +// See Makefile how this is generated. +// swift-format-ignore-file +import Foundation +let fileDescriptorSetBytes: [UInt8] = [ + 0x0a, 0xbc, 0x04, 0x0a, 0x1c, 0x70, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x5f, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, + 0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x15, 0x73, + 0x77, 0x69, 0x66, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, + 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x22, 0x5e, 0x0a, 0x19, + 0x4d, 0x73, 0x67, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, + 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x69, 0x6e, + 0x67, 0x2a, 0x04, 0x08, 0x01, 0x10, 0x02, 0x2a, 0x04, 0x08, 0x03, 0x10, + 0x04, 0x2a, 0x04, 0x08, 0x02, 0x10, 0x03, 0x2a, 0x04, 0x08, 0x04, 0x10, + 0x05, 0x2a, 0x04, 0x08, 0x07, 0x10, 0x08, 0x2a, 0x04, 0x08, 0x09, 0x10, + 0x0a, 0x2a, 0x04, 0x08, 0x64, 0x10, 0x6f, 0x2a, 0x05, 0x08, 0x7e, 0x10, + 0x83, 0x01, 0x2a, 0x04, 0x08, 0x6f, 0x10, 0x79, 0x4a, 0x04, 0x08, 0x08, + 0x10, 0x09, 0x4a, 0x04, 0x08, 0x79, 0x10, 0x7e, 0x22, 0xd5, 0x01, 0x0a, + 0x23, 0x4d, 0x73, 0x67, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, + 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x69, + 0x6e, 0x67, 0x57, 0x69, 0x74, 0x68, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, + 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, + 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x34, + 0x18, 0x7c, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x31, 0x32, 0x34, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x31, 0x32, 0x35, 0x18, 0x7d, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x32, 0x35, 0x12, 0x1b, 0x0a, 0x08, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, 0x30, 0x18, 0xc8, 0x01, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x30, + 0x30, 0x2a, 0x04, 0x08, 0x01, 0x10, 0x02, 0x2a, 0x04, 0x08, 0x03, 0x10, + 0x04, 0x2a, 0x04, 0x08, 0x02, 0x10, 0x03, 0x2a, 0x04, 0x08, 0x04, 0x10, + 0x05, 0x2a, 0x04, 0x08, 0x07, 0x10, 0x08, 0x2a, 0x04, 0x08, 0x09, 0x10, + 0x0a, 0x2a, 0x04, 0x08, 0x64, 0x10, 0x6f, 0x2a, 0x05, 0x08, 0x7e, 0x10, + 0x83, 0x01, 0x2a, 0x04, 0x08, 0x6f, 0x10, 0x79, 0x4a, 0x04, 0x08, 0x08, + 0x10, 0x09, 0x4a, 0x04, 0x08, 0x79, 0x10, 0x7c, 0x22, 0xcc, 0x01, 0x0a, + 0x22, 0x4d, 0x73, 0x67, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, + 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x69, + 0x6e, 0x67, 0x4e, 0x6f, 0x4d, 0x65, 0x72, 0x67, 0x69, 0x6e, 0x67, 0x12, + 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x12, + 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x32, 0x12, + 0x16, 0x0a, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x05, 0x52, 0x06, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x36, 0x12, + 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x33, 0x18, 0x0d, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, + 0x33, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x31, 0x35, + 0x18, 0x0f, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x31, 0x35, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x32, 0x31, 0x18, 0x15, 0x20, 0x01, 0x28, 0x05, 0x52, 0x07, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x32, 0x31, 0x2a, 0x04, 0x08, 0x03, 0x10, 0x06, 0x2a, + 0x04, 0x08, 0x07, 0x10, 0x0d, 0x2a, 0x04, 0x08, 0x10, 0x10, 0x15 +] diff --git a/Tests/protoc-gen-swiftTests/Test_Bytecode.swift b/Tests/protoc-gen-swiftTests/Test_Bytecode.swift new file mode 100644 index 000000000..bb7c06c5d --- /dev/null +++ b/Tests/protoc-gen-swiftTests/Test_Bytecode.swift @@ -0,0 +1,226 @@ +// Tests/SwiftProtobufPluginLibraryTests/Test_Bytecode.swift - Test Bytecode +// +// Copyright (c) 2014 - 2025 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +import SwiftProtobuf +import SwiftProtobufPluginLibrary +import XCTest +import protoc_gen_swift + +/// All tests for the bytecode are in this test target even though the interpreter and reader are +/// defined in the SwiftProtobuf module so that we can test everything end-to-end in one place. +final class Test_Bytecode: XCTestCase { + private enum TestInstruction: UInt64 { + case first = 1 + case second = 2 + } + + /// In the writer and reader tests, each line of the multi-line string corresponds to the value + /// of a single `writer.write*` call (where the first line is the always-written open-quote and + /// program format integer and the last is the close-quote. + func testWriter_opcodes() { + var writer = BytecodeWriter() + writer.writeOpcode(of: .first) + writer.writeOpcode(of: .second) + XCTAssertEqual( + writer.stringLiteral, + """ + "\\0\ + \\u{1}\ + \\u{2}\ + " + """ + ) + } + + func testWriter_integers() { + var writer = BytecodeWriter() + writer.writeUInt64(0) + writer.writeUInt64(63) + writer.writeUInt64(64) + writer.writeUInt64(123_456_789) + writer.writeInt32(0) + writer.writeInt32(-1) + XCTAssertEqual( + writer.stringLiteral, + """ + "\\0\ + \\0\ + ?\ + @\\u{1}\ + Ut|V\\u{7}\ + \\0\ + \\u{7f}\\u{7f}\\u{7f}\\u{7f}\\u{7f}\\u{3}\ + " + """ + ) + } + + func testWriter_strings() { + var writer = BytecodeWriter() + writer.writeNullTerminatedString("hello") + writer.writeNullTerminatedString("ütf-èíght") + XCTAssertEqual( + writer.stringLiteral, + """ + "\\0\ + hello\\0\ + ütf-èíght\\0\ + " + """ + ) + } + + func testWriter_stringArray() { + var writer = BytecodeWriter() + writer.writeNullTerminatedStringArray(["hello", "ütf-èíght", "world"]) + XCTAssertEqual( + writer.stringLiteral, + """ + "\\0\ + \\u{3}\ + hello\\0\ + ütf-èíght\\0\ + world\\0\ + " + """ + ) + } + + func testWriter_hasInstructions() { + var writer = BytecodeWriter() + XCTAssertFalse(writer.hasData) + writer.writeUInt64(10) + XCTAssertTrue(writer.hasData) + } + + func testReader_opcodes() { + let program: StaticString = """ + \0\ + \u{1}\ + \u{2} + """ + program.withUTF8Buffer { buffer in + var reader = BytecodeReader(remainingProgram: buffer[...]) + XCTAssertTrue(reader.hasData) + XCTAssertEqual(reader.nextInstruction(), .first) + XCTAssertTrue(reader.hasData) + XCTAssertEqual(reader.nextInstruction(), .second) + XCTAssertFalse(reader.hasData) + } + } + + func testReader_integers() { + let program: StaticString = """ + \0\ + \0\ + ?\ + @\u{1}\ + Ut|V\u{7}\ + \0\ + \u{7f}\u{7f}\u{7f}\u{7f}\u{7f}\u{3} + """ + program.withUTF8Buffer { buffer in + var reader = BytecodeReader(remainingProgram: buffer[...]) + XCTAssertTrue(reader.hasData) + XCTAssertEqual(reader.nextUInt64(), 0) + XCTAssertTrue(reader.hasData) + XCTAssertEqual(reader.nextUInt64(), 63) + XCTAssertTrue(reader.hasData) + XCTAssertEqual(reader.nextUInt64(), 64) + XCTAssertTrue(reader.hasData) + XCTAssertEqual(reader.nextUInt64(), 123_456_789) + XCTAssertTrue(reader.hasData) + XCTAssertEqual(reader.nextInt32(), 0) + XCTAssertTrue(reader.hasData) + XCTAssertEqual(reader.nextInt32(), -1) + XCTAssertFalse(reader.hasData) + } + } + + func testReader_strings() { + let program: StaticString = """ + \0\ + hello\0\ + ütf-èíght\0 + """ + program.withUTF8Buffer { buffer in + var reader = BytecodeReader(remainingProgram: buffer[...]) + XCTAssertTrue(reader.hasData) + XCTAssertEqual( + String(decoding: reader.nextNullTerminatedString(), as: UTF8.self), + "hello" + ) + XCTAssertTrue(reader.hasData) + XCTAssertEqual( + String(decoding: reader.nextNullTerminatedString(), as: UTF8.self), + "ütf-èíght" + ) + XCTAssertFalse(reader.hasData) + } + } + + func testReader_stringArray() { + let program: StaticString = """ + \0\ + \u{3}\ + hello\0\ + ütf-èíght\0\ + world\0 + """ + program.withUTF8Buffer { buffer in + var reader = BytecodeReader(remainingProgram: buffer[...]) + XCTAssertTrue(reader.hasData) + XCTAssertEqual( + reader.nextNullTerminatedStringArray().map { String(decoding: $0, as: UTF8.self) }, + ["hello", "ütf-èíght", "world"] + ) + XCTAssertFalse(reader.hasData) + } + } + + func testExecution() { + enum CalculatorInstruction: UInt64 { + // Push the integer operand onto the stack. + case push = 1 + // Pops the top two integers off the stack and pushes their sum. + case add = 2 + // Pop an integer off the stack and concatenate it to the output. + case print = 3 + } + var stack = [UInt64]() + var output = "" + + // The program below contains the following instructions: + // push(integer 1), push(integer 37), add, print + let interpreter = BytecodeInterpreter( + program: """ + \0\ + \u{1}\u{5}\ + \u{1}!\ + \u{2}\ + \u{3} + """ + ) + interpreter.execute { instruction, reader in + switch instruction { + case .push: + stack.append(reader.nextUInt64()) + case .add: + let first = stack.removeLast() + let second = stack.removeLast() + stack.append(first + second) + case .print: + let value = stack.removeLast() + output.append(String(value)) + } + } + XCTAssertEqual(output, "38") + } +} diff --git a/Tests/protoc-gen-swiftTests/Test_DescriptorExtensions.swift b/Tests/protoc-gen-swiftTests/Test_DescriptorExtensions.swift new file mode 100644 index 000000000..59e44b601 --- /dev/null +++ b/Tests/protoc-gen-swiftTests/Test_DescriptorExtensions.swift @@ -0,0 +1,517 @@ +// Tests/protoc-gen-swiftTests/Test_DescriptorExtensions.swift - Test Descriptor+Extensions.swift +// +// Copyright (c) 2014 - 2017 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +import SwiftProtobuf +import SwiftProtobufPluginLibrary +import XCTest +import protoc_gen_swift + +private typealias FileDescriptorProto = Google_Protobuf_FileDescriptorProto + +final class Test_DescriptorExtensions: XCTestCase { + + func testExtensionRanges() throws { + let fileSet = try Google_Protobuf_FileDescriptorSet(serializedBytes: fileDescriptorSetBytes) + + let descriptorSet = DescriptorSet(proto: fileSet) + + let msgDescriptor = descriptorSet.descriptor(named: "swift_descriptor_test.MsgExtensionRangeOrdering")! + // Quick check of what should be in the proto file + XCTAssertEqual(msgDescriptor.messageExtensionRanges.count, 9) + XCTAssertEqual(msgDescriptor.messageExtensionRanges[0].start, 1) + XCTAssertEqual(msgDescriptor.messageExtensionRanges[1].start, 3) + XCTAssertEqual(msgDescriptor.messageExtensionRanges[2].start, 2) + XCTAssertEqual(msgDescriptor.messageExtensionRanges[3].start, 4) + XCTAssertEqual(msgDescriptor.messageExtensionRanges[4].start, 7) + XCTAssertEqual(msgDescriptor.messageExtensionRanges[5].start, 9) + XCTAssertEqual(msgDescriptor.messageExtensionRanges[6].start, 100) + XCTAssertEqual(msgDescriptor.messageExtensionRanges[7].start, 126) + XCTAssertEqual(msgDescriptor.messageExtensionRanges[8].start, 111) + + // Check sorting/merging + XCTAssertEqual(msgDescriptor._normalizedExtensionRanges.count, 5) + XCTAssertEqual(msgDescriptor._normalizedExtensionRanges[0].lowerBound, 1) + XCTAssertEqual(msgDescriptor._normalizedExtensionRanges[0].upperBound, 5) + XCTAssertEqual(msgDescriptor._normalizedExtensionRanges[1].lowerBound, 7) + XCTAssertEqual(msgDescriptor._normalizedExtensionRanges[1].upperBound, 8) + XCTAssertEqual(msgDescriptor._normalizedExtensionRanges[2].lowerBound, 9) + XCTAssertEqual(msgDescriptor._normalizedExtensionRanges[2].upperBound, 10) + XCTAssertEqual(msgDescriptor._normalizedExtensionRanges[3].lowerBound, 100) + XCTAssertEqual(msgDescriptor._normalizedExtensionRanges[3].upperBound, 121) + XCTAssertEqual(msgDescriptor._normalizedExtensionRanges[4].lowerBound, 126) + XCTAssertEqual(msgDescriptor._normalizedExtensionRanges[4].upperBound, 131) + + // Check the "ambitious" merging. + XCTAssertEqual(msgDescriptor._ambitiousExtensionRanges.count, 1) + XCTAssertEqual(msgDescriptor._ambitiousExtensionRanges[0].lowerBound, 1) + XCTAssertEqual(msgDescriptor._ambitiousExtensionRanges[0].upperBound, 131) + + let msgDescriptor2 = descriptorSet.descriptor( + named: "swift_descriptor_test.MsgExtensionRangeOrderingWithFields" + )! + // Quick check of what should be in the proto file + XCTAssertEqual(msgDescriptor2.messageExtensionRanges.count, 9) + XCTAssertEqual(msgDescriptor2.messageExtensionRanges[0].start, 1) + XCTAssertEqual(msgDescriptor2.messageExtensionRanges[1].start, 3) + XCTAssertEqual(msgDescriptor2.messageExtensionRanges[2].start, 2) + XCTAssertEqual(msgDescriptor2.messageExtensionRanges[3].start, 4) + XCTAssertEqual(msgDescriptor2.messageExtensionRanges[4].start, 7) + XCTAssertEqual(msgDescriptor2.messageExtensionRanges[5].start, 9) + XCTAssertEqual(msgDescriptor2.messageExtensionRanges[6].start, 100) + XCTAssertEqual(msgDescriptor2.messageExtensionRanges[7].start, 126) + XCTAssertEqual(msgDescriptor2.messageExtensionRanges[8].start, 111) + + // Check sorting/merging + XCTAssertEqual(msgDescriptor2._normalizedExtensionRanges.count, 5) + XCTAssertEqual(msgDescriptor2._normalizedExtensionRanges[0].lowerBound, 1) + XCTAssertEqual(msgDescriptor2._normalizedExtensionRanges[0].upperBound, 5) + XCTAssertEqual(msgDescriptor2._normalizedExtensionRanges[1].lowerBound, 7) + XCTAssertEqual(msgDescriptor2._normalizedExtensionRanges[1].upperBound, 8) + XCTAssertEqual(msgDescriptor2._normalizedExtensionRanges[2].lowerBound, 9) + XCTAssertEqual(msgDescriptor2._normalizedExtensionRanges[2].upperBound, 10) + XCTAssertEqual(msgDescriptor2._normalizedExtensionRanges[3].lowerBound, 100) + XCTAssertEqual(msgDescriptor2._normalizedExtensionRanges[3].upperBound, 121) + XCTAssertEqual(msgDescriptor2._normalizedExtensionRanges[4].lowerBound, 126) + XCTAssertEqual(msgDescriptor2._normalizedExtensionRanges[4].upperBound, 131) + + // Check the "ambitious" merging. + XCTAssertEqual(msgDescriptor2._ambitiousExtensionRanges.count, 3) + XCTAssertEqual(msgDescriptor2._ambitiousExtensionRanges[0].lowerBound, 1) + XCTAssertEqual(msgDescriptor2._ambitiousExtensionRanges[0].upperBound, 5) + XCTAssertEqual(msgDescriptor2._ambitiousExtensionRanges[1].lowerBound, 7) + XCTAssertEqual(msgDescriptor2._ambitiousExtensionRanges[1].upperBound, 121) + XCTAssertEqual(msgDescriptor2._ambitiousExtensionRanges[2].lowerBound, 126) + XCTAssertEqual(msgDescriptor2._ambitiousExtensionRanges[2].upperBound, 131) + + let msgDescriptor3 = descriptorSet.descriptor( + named: "swift_descriptor_test.MsgExtensionRangeOrderingNoMerging" + )! + // Quick check of what should be in the proto file + XCTAssertEqual(msgDescriptor3.messageExtensionRanges.count, 3) + XCTAssertEqual(msgDescriptor3.messageExtensionRanges[0].start, 3) + XCTAssertEqual(msgDescriptor3.messageExtensionRanges[1].start, 7) + XCTAssertEqual(msgDescriptor3.messageExtensionRanges[2].start, 16) + + // Check sorting/merging + XCTAssertEqual(msgDescriptor3._normalizedExtensionRanges.count, 3) + XCTAssertEqual(msgDescriptor3._normalizedExtensionRanges[0].lowerBound, 3) + XCTAssertEqual(msgDescriptor3._normalizedExtensionRanges[0].upperBound, 6) + XCTAssertEqual(msgDescriptor3._normalizedExtensionRanges[1].lowerBound, 7) + XCTAssertEqual(msgDescriptor3._normalizedExtensionRanges[1].upperBound, 13) + XCTAssertEqual(msgDescriptor3._normalizedExtensionRanges[2].lowerBound, 16) + XCTAssertEqual(msgDescriptor3._normalizedExtensionRanges[2].upperBound, 21) + + // Check the "ambitious" merging. + XCTAssertEqual(msgDescriptor3._ambitiousExtensionRanges.count, 3) + XCTAssertEqual(msgDescriptor3._ambitiousExtensionRanges[0].lowerBound, 3) + XCTAssertEqual(msgDescriptor3._ambitiousExtensionRanges[0].upperBound, 6) + XCTAssertEqual(msgDescriptor3._ambitiousExtensionRanges[1].lowerBound, 7) + XCTAssertEqual(msgDescriptor3._ambitiousExtensionRanges[1].upperBound, 13) + XCTAssertEqual(msgDescriptor3._ambitiousExtensionRanges[2].lowerBound, 16) + XCTAssertEqual(msgDescriptor3._ambitiousExtensionRanges[2].upperBound, 21) + } + + func testEnumValueAliasing() throws { + let txt = [ + "name: \"test.proto\"", + "syntax: \"proto2\"", + "enum_type {", + " name: \"TestEnum\"", + " options {", + " allow_alias: true", + " }", + " value {", + " name: \"TEST_ENUM_FOO\"", + " number: 0", // Primary + " }", + " value {", + " name: \"TEST_ENUM_BAR\"", + " number: 1", + " }", + " value {", + " name: \"TESTENUM_FOO\"", + " number: 0", // Alias + " }", + " value {", + " name: \"_FOO\"", + " number: 0", // Alias + " }", + " value {", + " name: \"FOO\"", + " number: 0", // Alias + " }", + " value {", + " name: \"TEST_ENUM_ALIAS\"", + " number: 0", // Alias (unique name) + " }", + "}", + ] + + let fileProto: Google_Protobuf_FileDescriptorProto + do { + fileProto = try Google_Protobuf_FileDescriptorProto(textFormatStrings: txt) + } catch let e { + XCTFail("Error: \(e)") + return + } + + let descriptorSet = DescriptorSet(protos: [fileProto]) + let e = descriptorSet.enumDescriptor(named: "TestEnum")! + let values = e.values + XCTAssertEqual(values.count, 6) + + let aliasInfo = EnumDescriptor.ValueAliasInfo(enumDescriptor: e) + + // Check mainValues + + XCTAssertEqual(aliasInfo.mainValues.count, 2) + XCTAssertIdentical(aliasInfo.mainValues[0], e.values[0]) + XCTAssertIdentical(aliasInfo.mainValues[1], e.values[1]) + + // Check aliases(_:) + + XCTAssertEqual(aliasInfo.aliases(e.values[0])!.count, 4) + XCTAssertIdentical(aliasInfo.aliases(e.values[0])![0], e.values[2]) + XCTAssertIdentical(aliasInfo.aliases(e.values[0])![1], e.values[3]) + XCTAssertIdentical(aliasInfo.aliases(e.values[0])![2], e.values[4]) + XCTAssertIdentical(aliasInfo.aliases(e.values[0])![3], e.values[5]) + XCTAssertNil(aliasInfo.aliases(e.values[1])) // primary with no aliases + XCTAssertNil(aliasInfo.aliases(e.values[2])) // it itself is an alias + XCTAssertNil(aliasInfo.aliases(e.values[3])) // it itself is an alias + XCTAssertNil(aliasInfo.aliases(e.values[4])) // it itself is an alias + XCTAssertNil(aliasInfo.aliases(e.values[5])) // it itself is an alias + + // Check original(of:) + + XCTAssertNil(aliasInfo.original(of: e.values[0])) + XCTAssertNil(aliasInfo.original(of: e.values[1])) + XCTAssertIdentical(aliasInfo.original(of: e.values[2]), e.values[0]) + XCTAssertIdentical(aliasInfo.original(of: e.values[3]), e.values[0]) + XCTAssertIdentical(aliasInfo.original(of: e.values[4]), e.values[0]) + XCTAssertIdentical(aliasInfo.original(of: e.values[5]), e.values[0]) + } + + func test_File_computeImports_noImportPublic() { + let configText = """ + mapping { module_name: "foo", proto_file_path: "file" } + mapping { module_name: "bar", proto_file_path: "dir1/file" } + mapping { module_name: "baz", proto_file_path: ["dir2/file","file4"] } + mapping { module_name: "foo", proto_file_path: "file5" } + """ + + let config = try! SwiftProtobuf_GenSwift_ModuleMappings(textFormatString: configText) + let mapper = try! ProtoFileToModuleMappings(moduleMappingsProto: config) + + let fileProtos = [ + FileDescriptorProto(name: "file"), + FileDescriptorProto(name: "google/protobuf/any.proto", package: "google.protobuf"), + FileDescriptorProto(name: "dir1/file", dependencies: ["file"]), + FileDescriptorProto(name: "dir2/file", dependencies: ["google/protobuf/any.proto"]), + FileDescriptorProto(name: "file4", dependencies: ["dir2/file", "dir1/file", "file"]), + FileDescriptorProto(name: "file5", dependencies: ["file"]), + ] + let descSet = DescriptorSet(protos: fileProtos) + + // (filename, symbols) + let tests: [(String, [String])] = [ + ("file", []), + ("dir1/file", ["foo"]), + ("dir2/file", []), + ("file4", ["bar", "foo"]), + ("file5", []), + ] + + for (name, symbols) in tests { + let fileDesc = descSet.files.filter { $0.name == name }.first! + assertImports( + for: fileDesc, + mappings: mapper, + symbols: symbols, + symbolsPerSection: (symbols, []), + message: "Looking for \(name)" + ) + } + } + + func test_File_computeImports_PublicImports() { + // See the notes on computeImports(namer:reexportPublicImports:asImplementationOnly:) + // about how public import complicate things. + + // Given: + // + // + File: a.proto + // message A {} + // + // enum E { + // E_UNSET = 0; + // E_A = 1; + // E_B = 2; + // } + // + // + File: imports_a_publicly.proto + // import public "a.proto"; + // + // message ImportsAPublicly { + // optional A a = 1; + // optional E e = 2; + // } + // + // + File: imports_imports_a_publicly.proto + // import public "imports_a_publicly.proto"; + // + // message ImportsImportsAPublicly { + // optional A a = 1; + // } + // + // + File: uses_a_transitively.proto + // import "imports_a_publicly.proto"; + // + // message UsesATransitively { + // optional A a = 1; + // } + // + // + File: uses_a_transitively2.proto + // import "imports_imports_a_publicly.proto"; + // + // message UsesATransitively2 { + // optional A a = 1; + // } + // + // With a mapping file of: + // + // mapping { + // module_name: "A" + // proto_file_path: "a.proto" + // } + // mapping { + // module_name: "ImportsAPublicly" + // proto_file_path: "imports_a_publicly.proto" + // } + // mapping { + // module_name: "ImportsImportsAPublicly" + // proto_file_path: "imports_imports_a_publicly.proto" + // } + + let configText = """ + mapping { module_name: "A", proto_file_path: "a.proto" } + mapping { module_name: "ImportsAPublicly", proto_file_path: "imports_a_publicly.proto" } + mapping { module_name: "ImportsImportsAPublicly", proto_file_path: "imports_imports_a_publicly.proto" } + """ + + let config = try! SwiftProtobuf_GenSwift_ModuleMappings(textFormatString: configText) + let mapper = try! ProtoFileToModuleMappings(moduleMappingsProto: config) + + let fileProtos = [ + try! FileDescriptorProto( + textFormatString: """ + name: "a.proto" + message_type { + name: "A" + } + enum_type { + name: "E" + value { + name: "E_UNSET" + number: 0 + } + value { + name: "E_A" + number: 1 + } + value { + name: "E_B" + number: 2 + } + } + """ + ), + try! FileDescriptorProto( + textFormatString: """ + name: "imports_a_publicly.proto" + dependency: "a.proto" + message_type { + name: "ImportsAPublicly" + field { + name: "a" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".A" + json_name: "a" + } + field { + name: "e" + number: 2 + label: LABEL_OPTIONAL + type: TYPE_ENUM + type_name: ".E" + json_name: "e" + } + } + public_dependency: 0 + """ + ), + try! FileDescriptorProto( + textFormatString: """ + name: "imports_imports_a_publicly.proto" + dependency: "imports_a_publicly.proto" + message_type { + name: "ImportsImportsAPublicly" + field { + name: "a" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".A" + json_name: "a" + } + } + public_dependency: 0 + """ + ), + try! FileDescriptorProto( + textFormatString: """ + name: "uses_a_transitively.proto" + dependency: "imports_a_publicly.proto" + message_type { + name: "UsesATransitively" + field { + name: "a" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".A" + json_name: "a" + } + } + """ + ), + try! FileDescriptorProto( + textFormatString: """ + name: "uses_a_transitively2.proto" + dependency: "imports_imports_a_publicly.proto" + message_type { + name: "UsesATransitively2" + field { + name: "a" + number: 1 + label: LABEL_OPTIONAL + type: TYPE_MESSAGE + type_name: ".A" + json_name: "a" + } + } + """ + ), + ] + let descSet = DescriptorSet(protos: fileProtos) + + // (filename, symbols, symbolsPerSection) + let tests: [(String, [String], (imported: [String], exported: [String]))] = [ + ("a.proto", [], ([], [])), + ("imports_a_publicly.proto", ["A"], ([], ["enum A.E", "struct A.A"])), + ( + "imports_imports_a_publicly.proto", + ["ImportsAPublicly"], + ([], ["enum A.E", "struct A.A", "struct ImportsAPublicly.ImportsAPublicly"]) + ), + // this reexports A, so we don't directly pull in A. + // just a plain `import`, nothing to re-export. + ("uses_a_transitively.proto", ["ImportsAPublicly"], (["ImportsAPublicly"], [])), + // this chain reexports A, so we don't directly pull in A. + // just a plain `import`, nothing to re-export. + ("uses_a_transitively2.proto", ["ImportsImportsAPublicly"], (["ImportsImportsAPublicly"], [])), + ] + + for (name, symbols, symbolsPerSection) in tests { + let fileDesc = descSet.files.filter { $0.name == name }.first! + assertImports( + for: fileDesc, + mappings: mapper, + symbols: symbols, + symbolsPerSection: symbolsPerSection, + message: "Looking for \(name)" + ) + } + } + + private func assertImports( + for fileDesc: FileDescriptor, + mappings: ProtoFileToModuleMappings, + symbols: [String], + symbolsPerSection: (imported: [String], exported: [String]), + message: String, + file: StaticString = #filePath, + line: UInt = #line + ) { + func symbolsSections(importDirective: String, exportedImportDirective: String) -> String { + let expectedExported = + symbolsPerSection.exported.isEmpty + ? "" + : """ + // Use of 'import public' causes re-exports: + \(symbolsPerSection.exported.map { "@_exported \(exportedImportDirective) \($0)" }.joined(separator: "\n")) + """ + var expectedLines = symbolsPerSection.imported.map { "\(importDirective) \($0)" } + if !expectedExported.isEmpty { + expectedLines.append(expectedExported) + } + return expectedLines.joined(separator: "\n") + } + do { + let result = fileDesc.computeImports(mappings: mappings, directive: .plain) + let expected = symbols.map { "import \($0)" }.joined(separator: "\n") + XCTAssertEqual(expected, result, message, file: file, line: line) + } + do { + let result = fileDesc.computeImports(mappings: mappings, directive: .plain, reexport: true) + let expected = symbolsSections(importDirective: "import", exportedImportDirective: "import") + XCTAssertEqual(expected, result, message, file: file, line: line) + } + do { + let result = fileDesc.computeImports(mappings: mappings, directive: .accessLevel(.internal)) + let expected = symbols.map { "internal import \($0)" }.joined(separator: "\n") + XCTAssertEqual(expected, result, message, file: file, line: line) + } + do { + let result = fileDesc.computeImports(mappings: mappings, directive: .accessLevel(.package), reexport: true) + let expected = symbolsSections(importDirective: "package import", exportedImportDirective: "public import") + XCTAssertEqual(expected, result, message, file: file, line: line) + } + do { + let result = fileDesc.computeImports(mappings: mappings, directive: .accessLevel(.public), reexport: true) + let expected = symbolsSections(importDirective: "public import", exportedImportDirective: "public import") + XCTAssertEqual(expected, result, message, file: file, line: line) + } + do { + let result = fileDesc.computeImports(mappings: mappings, directive: .implementationOnly) + let expected = symbols.map { "@_implementationOnly import \($0)" }.joined(separator: "\n") + XCTAssertEqual(expected, result, message, file: file, line: line) + } + } +} + +extension FileDescriptor { + fileprivate func computeImports( + mappings: ProtoFileToModuleMappings, + directive: GeneratorOptions.ImportDirective, + reexport: Bool = false + ) -> String { + let namer = SwiftProtobufNamer( + currentFile: self, + protoFileToModuleMappings: mappings + ) + return computeImports( + namer: namer, + directive: directive, + reexportPublicImports: reexport + ) + } +} diff --git a/Tests/protoc-gen-swiftTests/Test_SwiftProtobufNamerExtensions.swift b/Tests/protoc-gen-swiftTests/Test_SwiftProtobufNamerExtensions.swift new file mode 100644 index 000000000..d92743d9e --- /dev/null +++ b/Tests/protoc-gen-swiftTests/Test_SwiftProtobufNamerExtensions.swift @@ -0,0 +1,316 @@ +// Tests/SwiftProtobufPluginLibraryTests/Test_SwiftProtobufNamer.swift - Test SwiftProtobufNamer.swift +// +// Copyright (c) 2014 - 2017 Apple Inc. and the project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See LICENSE.txt for license information: +// https://github.com/apple/swift-protobuf/blob/main/LICENSE.txt +// +// ----------------------------------------------------------------------------- + +import SwiftProtobuf +import SwiftProtobufPluginLibrary +import SwiftProtobufTestHelpers +import XCTest +import protoc_gen_swift + +final class Test_SwiftProtobufNamer: XCTestCase { + + func testEnumValueHandling_AliasNameMatches() throws { + let txt = [ + "name: \"test.proto\"", + "syntax: \"proto2\"", + "enum_type {", + " name: \"TestEnum\"", + " options {", + " allow_alias: true", + " }", + " value {", + " name: \"TEST_ENUM_FOO\"", + " number: 0", // Primary + " }", + " value {", + " name: \"TEST_ENUM_BAR\"", + " number: 1", + " }", + " value {", + " name: \"TESTENUM_FOO\"", + " number: 0", // Alias + " }", + " value {", + " name: \"_FOO\"", + " number: 0", // Alias + " }", + " value {", + " name: \"FOO\"", + " number: 0", // Alias + " }", + " value {", + " name: \"TEST_ENUM_ALIAS\"", + " number: 0", // Alias (unique name) + " }", + "}", + ] + + let fileProto: Google_Protobuf_FileDescriptorProto + do { + fileProto = try Google_Protobuf_FileDescriptorProto(textFormatStrings: txt) + } catch let e { + XCTFail("Error: \(e)") + return + } + + let descriptorSet = DescriptorSet(protos: [fileProto]) + let namer = + SwiftProtobufNamer( + currentFile: descriptorSet.fileDescriptor(named: "test.proto")!, + protoFileToModuleMappings: ProtoFileToModuleMappings() + ) + + let e = descriptorSet.enumDescriptor(named: "TestEnum")! + let values = e.values + XCTAssertEqual(values.count, 6) + + // Test uniquelyNamedValues(enum:) + + let aliasInfo = EnumDescriptor.ValueAliasInfo(enumDescriptor: e) + let filtered = namer.uniquelyNamedValues(valueAliasInfo: aliasInfo) + XCTAssertEqual(filtered.count, 3) + + XCTAssertEqual(filtered[0].name, "TEST_ENUM_FOO") + XCTAssertEqual(filtered[1].name, "TEST_ENUM_BAR") + XCTAssertEqual(filtered[2].name, "TEST_ENUM_ALIAS") + XCTAssertEqual(namer.relativeName(enumValue: filtered[0]), "foo") + XCTAssertEqual(namer.relativeName(enumValue: filtered[1]), "bar") + XCTAssertEqual(namer.relativeName(enumValue: filtered[2]), "alias") + } + + func testEnumValueHandling_NameCollisions() { + let txt = [ + "name: \"test.proto\"", + "syntax: \"proto2\"", + "enum_type {", + " name: \"TestEnum\"", + " value {", + " name: \"TEST_ENUM_FOO\"", + " number: 0", // Collision + " }", + " value {", + " name: \"TEST_ENUM_BAR\"", + " number: 1", + " }", + " value {", + " name: \"TESTENUM_FOO\"", + " number: 2", // Collision + " }", + " value {", + " name: \"_FOO\"", + " number: -1", // Collision - negative value + " }", + "}", + ] + + let fileProto: Google_Protobuf_FileDescriptorProto + do { + fileProto = try Google_Protobuf_FileDescriptorProto(textFormatStrings: txt) + } catch let e { + XCTFail("Error: \(e)") + return + } + + let descriptorSet = DescriptorSet(protos: [fileProto]) + let namer = + SwiftProtobufNamer( + currentFile: descriptorSet.fileDescriptor(named: "test.proto")!, + protoFileToModuleMappings: ProtoFileToModuleMappings() + ) + + let e = descriptorSet.enumDescriptor(named: "TestEnum")! + let values = e.values + XCTAssertEqual(values.count, 4) + + // Test uniquelyNamedValues(enum:) + + let aliasInfo = EnumDescriptor.ValueAliasInfo(enumDescriptor: e) + let filtered = namer.uniquelyNamedValues(valueAliasInfo: aliasInfo) + XCTAssertEqual(filtered.count, 4) + + XCTAssertEqual(filtered[0].name, "TEST_ENUM_FOO") + XCTAssertEqual(filtered[1].name, "TEST_ENUM_BAR") + XCTAssertEqual(filtered[2].name, "TESTENUM_FOO") + XCTAssertEqual(filtered[3].name, "_FOO") + XCTAssertEqual(namer.relativeName(enumValue: filtered[0]), "foo_0") + XCTAssertEqual(namer.relativeName(enumValue: filtered[1]), "bar") + XCTAssertEqual(namer.relativeName(enumValue: filtered[2]), "foo_2") + XCTAssertEqual(namer.relativeName(enumValue: filtered[3]), "foo_n1") + } + + func testEnumValueHandling_NameCollisionsAndAliasMatches() { + let txt = [ + "name: \"test.proto\"", + "syntax: \"proto2\"", + "enum_type {", + " name: \"TestEnum\"", + " options {", + " allow_alias: true", + " }", + " value {", + " name: \"TEST_ENUM_FOO\"", + " number: 0", // Collision/Primary0 + " }", + " value {", + " name: \"TEST_ENUM_BAR\"", + " number: 1", + " }", + " value {", + " name: \"TESTENUM_FOO\"", + " number: 0", // Alias 0 + " }", + " value {", + " name: \"_FOO\"", + " number: 2", // Collision/Primary2 + " }", + " value {", + " name: \"FOO\"", + " number: 2", // Alias 2 + " }", + " value {", + " name: \"TEST_ENUM_ALIAS\"", + " number: 0", // Alias 0 - Unique name + " }", + " value {", + " name: \"mumble\"", + " number: 1", // Alias 1 - Collision with next alias + " }", + " value {", + " name: \"MUMBLE\"", + " number: 0", // Alias 0 - Collision with previous alias + " }", + "}", + ] + + let fileProto: Google_Protobuf_FileDescriptorProto + do { + fileProto = try Google_Protobuf_FileDescriptorProto(textFormatStrings: txt) + } catch let e { + XCTFail("Error: \(e)") + return + } + + let descriptorSet = DescriptorSet(protos: [fileProto]) + let namer = + SwiftProtobufNamer( + currentFile: descriptorSet.fileDescriptor(named: "test.proto")!, + protoFileToModuleMappings: ProtoFileToModuleMappings() + ) + + let e = descriptorSet.enumDescriptor(named: "TestEnum")! + let values = e.values + XCTAssertEqual(values.count, 8) + + // Test uniquelyNamedValues(enum:) + + let aliasInfo = EnumDescriptor.ValueAliasInfo(enumDescriptor: e) + let filtered = namer.uniquelyNamedValues(valueAliasInfo: aliasInfo) + XCTAssertEqual(filtered.count, 6) + + XCTAssertEqual(filtered[0].name, "TEST_ENUM_FOO") + XCTAssertEqual(filtered[1].name, "TEST_ENUM_BAR") + XCTAssertEqual(filtered[2].name, "_FOO") + XCTAssertEqual(filtered[3].name, "TEST_ENUM_ALIAS") + XCTAssertEqual(filtered[4].name, "mumble") + XCTAssertEqual(filtered[5].name, "MUMBLE") + XCTAssertEqual(namer.relativeName(enumValue: filtered[0]), "foo_0") + XCTAssertEqual(namer.relativeName(enumValue: filtered[1]), "bar") + XCTAssertEqual(namer.relativeName(enumValue: filtered[2]), "foo_2") + XCTAssertEqual(namer.relativeName(enumValue: filtered[3]), "alias") + XCTAssertEqual(namer.relativeName(enumValue: filtered[4]), "mumble_1") + XCTAssertEqual(namer.relativeName(enumValue: filtered[5]), "mumble_0") + } + + func testEnumValueHandling_UniqueAliasNameCollisions() { + // Tests were the aliases collided in naming, but not with + // the original. + + let txt = [ + "name: \"test.proto\"", + "syntax: \"proto2\"", + "enum_type {", + " name: \"AliasedEnum\"", + " options {", + " allow_alias: true", + " }", + " value {", + " name: \"ALIAS_FOO\"", + " number: 0", + " }", + " value {", + " name: \"ALIAS_BAR\"", + " number: 1", + " }", + " value {", + " name: \"ALIAS_BAZ\"", + " number: 2", + " }", + " value {", + " name: \"QUX\"", + " number: 2", // short name merged with the next because they have the same value. + " }", + " value {", + " name: \"qux\"", + " number: 2", + " }", + " value {", + " name: \"bAz\"", + " number: 2", + " }", + "}", + ] + + let fileProto: Google_Protobuf_FileDescriptorProto + do { + fileProto = try Google_Protobuf_FileDescriptorProto(textFormatStrings: txt) + } catch let e { + XCTFail("Error: \(e)") + return + } + + let descriptorSet = DescriptorSet(protos: [fileProto]) + let namer = + SwiftProtobufNamer( + currentFile: descriptorSet.fileDescriptor(named: "test.proto")!, + protoFileToModuleMappings: ProtoFileToModuleMappings() + ) + + let e = descriptorSet.enumDescriptor(named: "AliasedEnum")! + let values = e.values + XCTAssertEqual(values.count, 6) + + XCTAssertEqual(values[0].name, "ALIAS_FOO") + XCTAssertEqual(values[1].name, "ALIAS_BAR") + XCTAssertEqual(values[2].name, "ALIAS_BAZ") + XCTAssertEqual(values[3].name, "QUX") + XCTAssertEqual(values[4].name, "qux") + XCTAssertEqual(values[5].name, "bAz") + + // Test uniquelyNamedValues(enum:) + + // QUX & qux collided, so only one remains. + + let aliasInfo = EnumDescriptor.ValueAliasInfo(enumDescriptor: e) + let filtered = namer.uniquelyNamedValues(valueAliasInfo: aliasInfo) + XCTAssertEqual(filtered.count, 5) + + XCTAssertEqual(filtered[0].name, "ALIAS_FOO") + XCTAssertEqual(filtered[1].name, "ALIAS_BAR") + XCTAssertEqual(filtered[2].name, "ALIAS_BAZ") + XCTAssertEqual(filtered[3].name, "QUX") + XCTAssertEqual(filtered[4].name, "bAz") + XCTAssertEqual(namer.relativeName(enumValue: filtered[0]), "aliasFoo") + XCTAssertEqual(namer.relativeName(enumValue: filtered[1]), "aliasBar") + XCTAssertEqual(namer.relativeName(enumValue: filtered[2]), "aliasBaz") + XCTAssertEqual(namer.relativeName(enumValue: filtered[3]), "qux") + XCTAssertEqual(namer.relativeName(enumValue: filtered[4]), "bAz") + } + +}